{"version":3,"file":"static/chunks/2951-fd6d7eff5183648e.js","mappings":"oIAQO,IAAIA,EAAiB,CACxBC,IAAK,MACLC,MAAO,QACPC,KAAM,OACNC,KAAM,OACNC,MAAO,SAEAC,EAAU,SAAUC,GAE3B,IADA,IAAIC,EAAO,GACFC,EAAK,EAAGA,EAAKC,UAAUC,OAAQF,IACpCD,EAAKC,EAAK,GAAKC,UAAUD,GAExBG,OAAOC,UAAUC,eAAeC,KAAKf,EAAgBO,KACtDA,EAAMP,EAAeC,KAEzBK,EAAQC,GAAKS,MAAMV,EAASE,ICtBzB,SAASS,EAAgBC,EAAIC,GAChC,OAAO,WAEH,IADA,IAAIX,EAAO,GACFC,EAAK,EAAGA,EAAKC,UAAUC,OAAQF,IACpCD,EAAKC,GAAMC,UAAUD,GAEzB,IACI,OAAOS,EAAGF,WAAM,EAAQR,GAE5B,MAAOY,GACHd,EAAQD,MAAMc,EAAUC,KDcpCd,EAAQJ,MAAQmB,QAAQnB,MAAMoB,KAAKD,SACnCf,EAAQL,IAAMoB,QAAQpB,IAAIqB,KAAKD,SAC/Bf,EAAQH,KAAOkB,QAAQlB,KAAKmB,KAAKD,SACjCf,EAAQF,KAAOiB,QAAQjB,KAAKkB,KAAKD,SACjCf,EAAQD,MAAQgB,QAAQhB,MAAMiB,KAAKD,SE7BnC,IAUIE,EAVAC,EAAgD,SAAUC,EAAIC,EAAMC,GACpE,GAAIA,GAA6B,IAArBjB,UAAUC,OAAc,IAAK,IAA4BiB,EAAxBC,EAAI,EAAGC,EAAIJ,EAAKf,OAAYkB,EAAIC,EAAGD,KACxED,GAAQC,KAAKH,IACRE,IAAIA,EAAKG,MAAMlB,UAAUmB,MAAMjB,KAAKW,EAAM,EAAGG,IAClDD,EAAGC,GAAKH,EAAKG,IAGrB,OAAOJ,EAAGQ,OAAOL,GAAMG,MAAMlB,UAAUmB,MAAMjB,KAAKW,KAIlDQ,GAAY,EAIT,SAASC,EAAaC,GACzBF,EAAYE,EAiBT,SAASC,EAAQnB,GACpB,OAAO,WAEH,OAAOoB,EAAcpB,EAAIqB,KAAM7B,YAGhC,SAAS4B,EAAcpB,EAAIsB,EAAShC,GACvC,IAEI,OAAOU,EAAGF,MAAMwB,EAAShC,GAE7B,MAAOiC,GAEH,GADAC,EAAsB1C,EAAeK,MAAOoC,GACxClB,EACA,IACIA,EAAwBkB,GAE5B,MAAOA,GACHC,EAAsB1C,EAAeK,MAAOoC,KAKrD,SAASC,EAAsBnC,GAElC,IADA,IAAIC,EAAO,GACFC,EAAK,EAAGA,EAAKC,UAAUC,OAAQF,IACpCD,EAAKC,EAAK,GAAKC,UAAUD,GAEzByB,GACA5B,EAAQU,WAAM,EAAQQ,EAAc,CAACjB,EAAK,aAAcC,GAAM,IC5D/D,IAAImC,EAAa,IACbC,EAAa,IAOjB,SAASC,EAAS3B,EAAI4B,EAAMC,GAC/B,IAGIC,EACAC,EAJAC,GAAuBH,QAA+BI,IAApBJ,EAAQK,SAAwBL,EAAQK,QAC1EC,GAAwBN,QAAgCI,IAArBJ,EAAQO,UAAyBP,EAAQO,SAC5EC,GAAe,EAGnB,MAAO,CACHC,UAAW,WAEP,IADA,IAAIC,EAAa,GACRhD,EAAK,EAAGA,EAAKC,UAAUC,OAAQF,IACpCgD,EAAWhD,GAAMC,UAAUD,GAE3B8C,EACAP,EAAiCS,GAGjCP,EACAhC,EAAGF,WAAM,EAAQyC,GAGjBT,EAAiCS,EAErCF,GAAe,EACfN,EAAmBS,YAAW,WACtBL,GAAyBL,GACzB9B,EAAGF,WAAM,EAAQgC,GAErBO,GAAe,EACfP,OAAiCG,IAClCL,KAEPa,OAAQ,WACJC,aAAaX,GACbM,GAAe,EACfP,OAAiCG,IAItC,SAAS,EAAOU,GAEnB,IADA,IAAIC,EAAW,GACNrD,EAAK,EAAGA,EAAKC,UAAUC,OAAQF,IACpCqD,EAASrD,EAAK,GAAKC,UAAUD,GASjC,OAPAqD,EAASC,SAAQ,SAAUC,GACvB,IAAK,IAAIC,KAAOD,EACRpD,OAAOC,UAAUC,eAAeC,KAAKiD,EAAQC,KAC7CJ,EAAOI,GAAOD,EAAOC,OAI1BJ,EAEJ,SAASK,EAAaC,GACzB,OAAO,EAAO,GAAIA,GAMf,SAASC,EAAaC,GACzB,OAAOA,GAEEC,SAASD,EAAa,IAAwB,GAAhBE,KAAKC,UAAmBF,SAASD,EAAa,IAAM,GAAKI,SAAS,IACnG,GAAGxC,OAAO,IAAK,KAAKA,OAAO,IAAK,KAAKA,OAAO,IAAK,KAAKA,OAAO,IAAK,KAAKA,OAAO,MAAMyC,QAAQ,SAAUN,GAMzG,SAASO,EAAYC,GACxB,OAAqB,IAAdA,GAAmC,IAAhBL,KAAKC,UAAkBI,EAE9C,SAASC,EAAMC,EAAKC,GACvB,OAAQD,EAAIE,QAAQD,GAGjB,SAASE,KAST,SAASC,EAAcC,EAAOC,EAAUC,GAC3C,GAAqB,kBAAVF,GAAgC,OAAVA,EAC7B,OAAOG,KAAKC,UAAUJ,GAI1B,IAAIK,EAA+BC,EAAmB7E,OAAOC,WACzD6E,EAA8BD,EAAmB1D,MAAMlB,WACvD8E,EAA8BF,EAAmB7E,OAAOgF,eAAeT,IACvEU,EAAqBJ,EAAmBN,GAC5C,IACI,OAAOG,KAAKC,UAAUJ,EAAOC,EAAUC,GAE3C,MAAOS,IACH,MAAO,sCAEX,QACIN,IACAE,IACAC,IACAE,KAGR,SAASJ,EAAmBN,GACxB,IAAIhB,EAASgB,EACTY,EAAe5B,EAAO6B,OAC1B,OAAID,UACO5B,EAAO6B,OACP,WACH7B,EAAO6B,OAASD,IAGjBd,EAEJ,SAASgB,EAASC,EAAWC,GAChC,OAAsC,IAA/BD,EAAUE,QAAQD,GAEtB,SAASE,EAAUC,GACtB,GAAIvE,MAAML,KACN,OAAOK,MAAML,KAAK4E,GAEtB,IAAIC,EAAQ,GACZ,GAAID,aAAqBE,IACrBF,EAAUvC,SAAQ,SAAU0C,GAAQ,OAAOF,EAAMG,KAAKD,WAGtD,IAAK,IAAI5E,EAAI,EAAGA,EAAIyE,EAAU3F,OAAQkB,IAClC0E,EAAMG,KAAKJ,EAAUzE,IAG7B,OAAO0E,EAEJ,SAASI,EAAKJ,EAAOK,GACxB,IAAK,IAAI/E,EAAI,EAAGA,EAAI0E,EAAM5F,OAAQkB,GAAK,EAAG,CACtC,IAAI4E,EAAOF,EAAM1E,GACjB,GAAI+E,EAAUH,EAAM5E,GAChB,OAAO4E,GAcZ,SAASI,EAAa1B,GACzB,OAAO2B,EAAS3B,IAAUA,GAAS,GAAKA,GAAS,IAE9C,SAAS2B,EAAS3B,GACrB,MAAwB,kBAAVA,EAEX,SAAS4B,EAAa5C,GACzB,OAAOvD,OAAOoG,KAAK7C,GAAQ8C,KAAI,SAAUhD,GAAO,OAAOE,EAAOF,MAK3D,SAASiD,EAAc/C,GAC1B,OAAOvD,OAAOoG,KAAK7C,GAAQ8C,KAAI,SAAUhD,GAAO,MAAO,CAACA,EAAKE,EAAOF,OAEjE,SAASkD,EAAchD,GAC1B,OAAsC,IAA/BvD,OAAOoG,KAAK7C,GAAQxD,OAUxB,SAASyG,EAAWlB,EAAWC,GAClC,OAAOD,EAAUlE,MAAM,EAAGmE,EAAOxF,UAAYwF,EAQ1C,SAASkB,IACZ,GAA0B,kBAAfC,WACP,OAAOA,WAEX1G,OAAO2G,eAAe3G,OAAOC,UAAW,YAAa,CACjD2G,IAAK,WACD,OAAOjF,MAEXkF,cAAc,IAGlB,IAAIC,EAAeC,UAgBnB,cAdO/G,OAAOC,UAAU8G,UACI,kBAAjBD,IAIHA,EADgB,kBAATE,KACQA,KAEQ,kBAAXC,OACGA,OAGA,IAGhBH,EASJ,SAASI,EAAqBC,GACjC,GAAIA,EAAQC,OACR,OAAOD,EAAQC,OAEnB,IAAIC,EAAgBF,EAAQG,KAAKxD,QAAQ,cAAe,IACxD,MAAO,GAAGzC,OAAO8F,EAAQI,SAAU,MAAMlG,OAAOgG,GAE7C,SAASG,EAAwBC,EAAWC,GAC/C,IACIC,EADQ,IAAIC,OAAO,cAAcvG,OAAOqG,EAAM,qBAC9BG,KAAKJ,GACzB,OAAOE,EAAUA,EAAQ,QAAKpF,EAE3B,SAASuF,EAAaxC,EAAWvF,EAAQgI,QAC7B,IAAXA,IAAqBA,EAAS,IAClC,IAAIC,EAAW1C,EAAU2C,WAAWlI,EAAS,GAEzCmI,EAD0BF,GAAY,OAAUA,GAAY,MAChBjI,EAAS,EAAIA,EAC7D,OAAIuF,EAAUvF,QAAUmI,EACb5C,EAEJ,GAAGjE,OAAOiE,EAAUlE,MAAM,EAAG8G,IAAkB7G,OAAO0G,GAe1D,SAASI,EAAQ5D,GACpB,OAAc,OAAVA,EACO,OAEPpD,MAAMiH,QAAQ7D,GACP,eAEGA,EA8BX,SAAS8D,EAAUC,EAAalF,EAAQmF,GAG3C,QAFiC,IAA7BA,IAAuCA,EA7B/C,WACI,GAAuB,qBAAZC,QAAyB,CAChC,IAAIC,EAAQ,IAAID,QAChB,MAAO,CACHE,mBAAoB,SAAUnE,GAC1B,IAAIoE,EAAMF,EAAME,IAAIpE,GAIpB,OAHKoE,GACDF,EAAMG,IAAIrE,GAEPoE,IAInB,IAAIhD,EAAQ,GACZ,MAAO,CACH+C,mBAAoB,SAAUnE,GAC1B,IAAIoE,EAAMhD,EAAMH,QAAQjB,IAAU,EAIlC,OAHKoE,GACDhD,EAAMG,KAAKvB,GAERoE,IASuDE,SAEvDtG,IAAXa,EACA,OAAOkF,EAEX,GAAsB,kBAAXlF,GAAkC,OAAXA,EAE9B,OAAOA,EAEN,GAAIA,aAAkB0F,KACvB,OAAO,IAAIA,KAAK1F,EAAO2F,WAEtB,GAAI3F,aAAkBwE,OAAQ,CAC/B,IAAIoB,EAAQ5F,EAAO4F,OAEf,CACI5F,EAAO6F,OAAS,IAAM,GACtB7F,EAAO8F,WAAa,IAAM,GAC1B9F,EAAO+F,UAAY,IAAM,GACzB/F,EAAOgG,OAAS,IAAM,GACtBhG,EAAOiG,QAAU,IAAM,IACzBC,KAAK,IACX,OAAO,IAAI1B,OAAOxE,EAAOA,OAAQ4F,GAErC,IAAIT,EAAyBG,mBAAmBtF,GAAhD,CAIK,GAAIjC,MAAMiH,QAAQhF,GAAS,CAE5B,IADA,IAAImG,EAAWpI,MAAMiH,QAAQE,GAAeA,EAAc,GACjDrH,EAAI,EAAGA,EAAImC,EAAOrD,SAAUkB,EACjCsI,EAAStI,GAAKoH,EAAUkB,EAAStI,GAAImC,EAAOnC,GAAIsH,GAEpD,OAAOgB,EAEX,IAAIC,EAAkC,WAAzBrB,EAAQG,GAA4BA,EAAc,GAC/D,IAAK,IAAIjF,KAAOD,EACRpD,OAAOC,UAAUC,eAAeC,KAAKiD,EAAQC,KAC7CmG,EAAOnG,GAAOgF,EAAUmB,EAAOnG,GAAMD,EAAOC,GAAMkF,IAG1D,OAAOiB,GAQJ,SAASC,EAAUlF,GACtB,OAAO8D,OAAU9F,EAAWgC,GAEzB,SAASmF,IAEZ,IADA,IAIIpB,EAJAqB,EAAU,GACL9J,EAAK,EAAGA,EAAKC,UAAUC,OAAQF,IACpC8J,EAAQ9J,GAAMC,UAAUD,GAG5B,IAAK,IAAIqF,EAAK,EAAG0E,EAAYD,EAASzE,EAAK0E,EAAU7J,OAAQmF,IAAM,CAC/D,IAAI9B,EAASwG,EAAU1E,QAER3C,IAAXa,GAAmC,OAAXA,IAG5BkF,EAAcD,EAAUC,EAAalF,IAEzC,OAAOkF,EAoBJ,SAASuB,EAAchE,GAC1B,IAAIiE,EAAW3B,EAAQtC,GACvB,MAAoB,WAAbiE,GAAsC,aAAbA,GAA2BjE,aAAgB+B,OAOxE,SAASmC,EAAUC,EAAMzF,EAAO0F,GAEnC,YADsB,IAAlBA,IAA4BA,GAAgB,GACzCD,EAAKE,MAAK,SAAUrE,GACvB,IACI,GAAoB,oBAATA,EACP,OAAOA,EAAKtB,GAEX,GAAIsB,aAAgB+B,OACrB,OAAO/B,EAAKsE,KAAK5F,GAEhB,GAAoB,kBAATsB,EACZ,OAAOoE,EAAgBzD,EAAWjC,EAAOsB,GAAQA,IAAStB,EAGlE,MAAO1C,GACHnC,EAAQD,MAAMoC,GAElB,OAAO,KAIR,SAASuI,EAAUC,GACtB,OAAIpD,OAAOqD,KAAOrD,OAAOqD,IAAIC,OAClBtD,OAAOqD,IAAIC,OAAOF,GAGtBA,EAAIvG,QAAQ,gDAAgD,SAAU0G,EAAIC,GAC7E,OAAIA,EAEW,OAAPD,EACO,SAGJ,GAAGnJ,OAAOmJ,EAAGpJ,MAAM,GAAI,GAAI,MAAMC,OAAOmJ,EAAGvC,WAAWuC,EAAGzK,OAAS,GAAG8D,SAAS,IAAK,KAGvF,KAAKxC,OAAOmJ,MAI3B,IAAIE,EAA6B,mBAC1B,SAASC,EAAkBrF,GAE9B,OAAKoF,EAA2BP,KAAK7E,QAGV/C,IAAvB0E,OAAO2D,aACA,IAAIA,aAAcC,OAAOvF,GAAWvF,OAExC,IAAI+K,KAAK,CAACxF,IAAYyF,KALlBzF,EAAUvF,OC/blB,SAASiL,EAAqBC,QACH,IAA1BA,IAAoCA,EAAwBN,GAChE,IACIO,EADAtJ,EAAU,GAEd,MAAO,CACHuJ,cAAe,WAIX,YAHwB5I,IAApB2I,IACAA,EAAkBD,EAAsB3G,EAAc1C,KAEnDsJ,GAGXtE,IAAK,WAAc,OAAOhF,GAE1BgH,IAAK,SAAUvF,EAAKkB,GAChB3C,EAAQyB,GAAOkB,EACf2G,OAAkB3I,GAGtB6I,OAAQ,SAAU/H,UACPzB,EAAQyB,GACf6H,OAAkB3I,GAGtB8I,IAAK,SAAUC,GACX1J,EAAU0J,EACVJ,OAAkB3I,GAEtBgJ,WAAY,WAAc,OAAO9B,EAAU7H,IAC3C4J,WAAY,SAAUF,GAClB1J,EAAU6H,EAAU6B,GACpBJ,OAAkB3I,GAEtBkJ,mBAAoB,SAAUpI,EAAKqI,GAC/B9J,EAAQyB,GAAOoG,EAAUiC,GACzBR,OAAkB3I,GAEtBoJ,sBAAuB,SAAUtI,UACtBzB,EAAQyB,GACf6H,OAAkB3I,GAEtBqJ,aAAc,WACVhK,EAAU,GACVsJ,OAAkB3I,IC5C9B,ICkEIsJ,EDjEAC,EAA+B,WAC/B,SAASA,IACLnK,KAAKoK,OAAS,GAYlB,OAVAD,EAAc7L,UAAU2I,IAAM,SAAUoD,GACvBrK,KAAKoK,OAAOjG,KAAKkG,GANnB,KAQPrK,KAAKoK,OAAOE,OAAO,EAAG,IAG9BH,EAAc7L,UAAUiM,MAAQ,WAC5BvK,KAAKoK,OAAO5I,SAAQ,SAAU6I,GAAY,OAAOA,OACjDrK,KAAKoK,OAAOhM,OAAS,GAElB+L,EAduB,GCA3B,SAASK,EAAiBC,GAC7B,MAAO,CAAEA,SAAUA,EAAUC,UAAWC,EAAsBF,IAElE,SAASE,EAAsBC,GAC3B,IAAIC,EAAmBC,IAAYC,YAAYC,MAE/C,OAAIH,EAAkBI,KACXjJ,KAAKM,MAAM4I,GAAYL,EAAiBD,IAiDhD,SAAsBA,GACzB,OAAO5I,KAAKM,MAAM4I,GAAYD,KAAsBL,IAhD7CO,CAAaP,GAKjB,SAASQ,EAAiBC,GAC7B,OAAK9G,EAAS8G,GAGP/I,EAAiB,IAAX+I,EAAgB,GAFlBA,EAIR,SAASP,IAMZ,OAAO,IAAI3D,MAAOC,UAEf,SAASkE,IACZ,OAAOR,IAEJ,SAASS,KACZ,OAAOR,YAAYC,MAEhB,SAASQ,KACZ,MAAO,CAAEf,SAAUc,KAAeb,UAAWY,KAE1C,SAASG,KACZ,MAAO,CAAEhB,SAAU,EAAGC,UAAWO,MAE9B,SAASS,GAAQC,EAAOC,GAC3B,OAAQA,EAAMD,EAEX,SAAST,GAAYW,EAAGC,GAC3B,OAAOD,EAAIC,EASR,SAASC,GAAgBC,GAC5B,OAAQA,EAAYf,KAYxB,SAASA,KAIL,YAHwBrK,IAApBsJ,IACAA,EAAkBa,YAAYkB,OAAO/B,iBAElCA,ECrEJ,IAwCHgC,GAvCG,SAASC,GAAUpG,EAAMnD,EAAOwJ,EAAa5L,GAChD,IAAI6L,EAAO,IAAIlF,KACfkF,EAAKC,QAAQD,EAAKjF,UAAYgF,GAC9B,IAAIG,EAAU,WAAW7M,OAAO2M,EAAKG,eACjCC,EAAWjM,GAAWA,EAAQkM,UAAY,OAAS,SACnDC,EAASnM,GAAWA,EAAQmM,OAAS,WAAWjN,OAAOc,EAAQmM,QAAU,GACzEC,EAASpM,GAAWA,EAAQoM,OAAS,UAAY,GACrDC,SAASC,OAAS,GAAGpN,OAAOqG,EAAM,KAAKrG,OAAOkD,EAAO,KAAKlD,OAAO6M,EAAS,qBAAqB7M,OAAO+M,GAAU/M,OAAOiN,GAAQjN,OAAOkN,GAEnI,SAASG,GAAUhH,GACtB,OAAOF,EAAwBgH,SAASC,OAAQ/G,GAE7C,SAASiH,GAAajH,EAAMvF,GAC/B2L,GAAUpG,EAAM,GAAI,EAAGvF,GCfpB,ICOHyM,GDJG,SAASC,KACZ,OAAOC,QAAQ7H,OAAO8H,iCAAmCL,GAFb,mCEFzC,SAASM,KACZ,IAAIC,EAuBGxI,IAAkByI,mBAtBzB,GAAKD,EAGL,MAAO,CACHE,uBAAwB,WACpB,OAAOzK,KAAK0K,MAAMH,EAAkBE,2BAExCE,KAAM,SAAUC,EAAWC,GACvBN,EAAkBI,KAAK3K,KAAKC,UAAU,CAAE2K,UAAWA,EAAWC,MAAOA,OAI1E,SAASC,GAAkBC,GAC9B,IAAIvK,OACgB,IAAhBuK,IAA0BA,EAAoD,QAArCvK,EAAKuB,IAAkBiJ,gBAA6B,IAAPxK,OAAgB,EAASA,EAAGyK,UACtH,IAAIC,EAASZ,KACb,QAAUY,GACNA,EACKT,yBACAjF,MAAK,SAAU2F,GAAe,OAAOJ,IAAgBI,IP4KzCvK,EO5KiEmK,EP4KtDlK,EO5KmE,IAAIlE,OAAOwO,GP6KvGvK,EAAUlE,OAAOmE,EAAOxF,UAAYwF,GADxC,IAAkBD,EAAWC,KMxK7B,SAASuK,GAA6BC,GACzC,QAASnB,IAA+BA,GAA4BjG,IAAIoH,GAKrE,SAASC,KACZ,OAAOpB,IAA+B,IAAIhJ,IEhC9C,IAAIqK,GAAmB,IAIhB,SAASC,GAAkBC,GAC9B,IAAIC,EAAQ,GACRC,EAAgBC,GAAeH,EAAI,SACnCI,EAAWC,OAAOL,GAetB,OAdIE,GAAiB7J,EAAW6J,EAAeE,KAC3CF,EAAgBA,EAAcjP,MAAMmP,EAASxQ,SAE7CsQ,GACAA,EAAcI,MAAM,MAAMtN,SAAQ,SAAUuN,GACxC,IAAIC,EAmBhB,SAAyBD,GACrB,IAAIE,EAAQC,GAAehJ,KAAK6I,GAChC,IAAKE,EACD,OAEJ,IAAIE,EAAWF,EAAM,IAAqC,IAA/BA,EAAM,GAAGpL,QAAQ,UACxCuL,EAASH,EAAM,IAAmC,IAA7BA,EAAM,GAAGpL,QAAQ,QACtCwL,EAAWC,GAAepJ,KAAK+I,EAAM,IACrCG,GAAUC,IAEVJ,EAAM,GAAKI,EAAS,GACpBJ,EAAM,GAAKI,EAAS,GACpBJ,EAAM,GAAKI,EAAS,IAExB,MAAO,CACHpR,KAAMkR,EAAW,CAACF,EAAM,IAAM,GAC9BM,OAAQN,EAAM,IAAMA,EAAM,QAAKrO,EAC/B4O,KAAMP,EAAM,IAAMX,GAClBS,KAAME,EAAM,IAAMA,EAAM,QAAKrO,EAC7B6O,IAAMN,OAAsBvO,EAAXqO,EAAM,IAtCFS,CAAgBX,IA0C7C,SAAkCA,GAC9B,IAAIE,EAAQU,GAA6BzJ,KAAK6I,GAC9C,IAAKE,EACD,OAEJ,MAAO,CACHhR,KAAM,GACNsR,OAAQN,EAAM,IAAMA,EAAM,QAAKrO,EAC/B4O,KAAMlB,GACNS,KAAME,EAAM,IAAMA,EAAM,QAAKrO,EAC7B6O,IAAKR,EAAM,IApDmCW,CAAyBb,IAwD/E,SAAsBA,GAClB,IAAIE,EAAQY,GAAc3J,KAAK6I,GAC/B,IAAKE,EACD,OAEJ,MAAO,CACHhR,KAAM,GACNsR,OAAQN,EAAM,IAAMA,EAAM,QAAKrO,EAC/B4O,KAAMP,EAAM,IAAMX,GAClBS,MAAOE,EAAM,GACbQ,IAAKR,EAAM,IAlEqEa,CAAaf,IAuErG,SAAwBA,GACpB,IAAIE,EAAQc,GAAc7J,KAAK6I,GAC/B,IAAKE,EACD,OAEJ,IAAIG,EAASH,EAAM,IAAMA,EAAM,GAAGpL,QAAQ,YAAc,EACpDwL,EAAWW,GAAc9J,KAAK+I,EAAM,IACpCG,GAAUC,IAEVJ,EAAM,GAAKI,EAAS,GACpBJ,EAAM,GAAKI,EAAS,GACpBJ,EAAM,QAAKrO,GAEf,MAAO,CACH3C,KAAMgR,EAAM,GAAKA,EAAM,GAAGH,MAAM,KAAO,GACvCS,OAAQN,EAAM,IAAMA,EAAM,QAAKrO,EAC/B4O,KAAMP,EAAM,IAAMX,GAClBS,KAAME,EAAM,IAAMA,EAAM,QAAKrO,EAC7B6O,IAAKR,EAAM,IAzF2FgB,CAAelB,GAC7GC,KACKA,EAAWQ,MAAQR,EAAWD,OAC/BC,EAAWQ,KAAOlB,IAEtBG,EAAMtK,KAAK6K,OAIhB,CACHkB,QAASvB,GAAeH,EAAI,WAC5BzI,KAAM4I,GAAeH,EAAI,QACzBC,MAAOA,GAGf,IAAI0B,GAAU,yFACVC,GAAe,cACflB,GAAiB,IAAIjJ,OAAO,qBAAqBvG,OAAOyQ,IAASzQ,OAAO0Q,GAAc,KAAK1Q,OAAO0Q,GAAc,cAAe,KAC/Hd,GAAiB,IAAIrJ,OAAO,YAAYvG,OAAO0Q,IAAc1Q,OAAO0Q,GAAc,QAuBtF,IAAIT,GAA+B,IAAI1J,OAAO,YAAYvG,OAAOyQ,IAASzQ,OAAO0Q,GAAc,KAAK1Q,OAAO0Q,GAAc,WAAY,KAcrI,IAAIP,GAAgB,gHAcpB,IAAIE,GAAgB,4IAChBC,GAAgB,gDAsBpB,SAASrB,GAAehL,EAAWoG,GAC/B,GAAyB,kBAAdpG,GAA2BA,GAAeoG,KAAYpG,EAAjE,CAGA,IAAIf,EAAQe,EAAUoG,GACtB,MAAwB,kBAAVnH,EAAqBA,OAAQhC,GC5GxC,IC4CHyP,GD5COC,GACA,QADAA,GAEE,UAFFA,GAGC,SAHDA,GAMC,SANDA,GAOC,SAEL,SAASC,GAAgBhN,GAC5B,IAAIiN,EAAajN,EAAGiN,WAAYC,EAAgBlN,EAAGkN,cAAeC,EAAgBnN,EAAGmN,cAAeC,EAAcpN,EAAGoN,YAAaC,EAAiBrN,EAAGqN,eAAgBnP,EAAS8B,EAAG9B,OAAQoP,EAAWtN,EAAGsN,SACxM,OAAKL,SAAsC5P,IAAvB4P,EAAWN,SAA2BO,aAAyBK,OAY5E,CACHH,YAAaA,EACblP,OAAQA,EACRoP,SAAUA,EACVJ,cAAeA,EACfP,QAASM,EAAWN,SAAW,gBAC/BzB,MAAOsC,GAAmBP,GAC1BE,cAAeA,EACfM,KAAMR,EAAWzK,KACjBkL,OAAQC,GAAmBT,EAAehP,IApBnC,CACHkP,YAAaA,EACblP,OAAQA,EACRoP,SAAUA,EACVJ,cAAeA,EACfP,QAAS,GAAGxQ,OAAOkR,EAAgB,KAAKlR,OAAOiD,EAAc8N,IAC7DhC,MAAO,gDACPiC,cAAeA,EACfM,KAAMR,GAAcA,EAAWzK,MAepC,SAASgL,GAAmBtC,GAC/B,IAAI0C,EAASC,GAAmB3C,GAQhC,OAPAA,EAAMA,MAAMjN,SAAQ,SAAU6P,GAC1B,IAAI7B,EAAsB,MAAf6B,EAAM7B,KAAe,cAAgB6B,EAAM7B,KAClDvR,EAAOoT,EAAMpT,MAAQoT,EAAMpT,KAAKG,OAAS,EAAI,IAAIsB,OAAO2R,EAAMpT,KAAK0J,KAAK,MAAO,KAAO,GACtFoH,EAAOsC,EAAMtC,KAAO,IAAIrP,OAAO2R,EAAMtC,MAAQ,GAC7CQ,EAAS8B,EAAMtC,MAAQsC,EAAM9B,OAAS,IAAI7P,OAAO2R,EAAM9B,QAAU,GACrE4B,GAAU,UAAUzR,OAAO8P,GAAM9P,OAAOzB,EAAM,OAAOyB,OAAO2R,EAAM5B,KAAK/P,OAAOqP,GAAMrP,OAAO6P,MAExF4B,EAMJ,SAASC,GAAmB3C,GAC/B,MAAO,GAAG/O,OAAO+O,EAAM1I,MAAQ,QAAS,MAAMrG,OAAO+O,EAAMyB,SASxD,SAASoB,KAOZ,IAEIC,EADAzT,EAAQ,IAAIgT,MAGhB,IAAKhT,EAAM2Q,MACP,IACI,MAAM3Q,EAEV,MAAOoC,IASX,OALAH,GAAc,WACV,IAAIyQ,EAAajC,GAAkBzQ,GACnC0S,EAAW/B,MAAQ+B,EAAW/B,MAAMhP,MAdb,GAevB8R,EAAiBR,GAAmBP,MAEjCe,EAEJ,SAASL,GAAmBpT,EAAO0T,GAGtC,IAFA,IAAIC,EAAe3T,EACfmT,EAAS,IACY,OAAjBQ,QAA0C,IAAjBA,OAA0B,EAASA,EAAaC,iBAAkBZ,OAASG,EAAO7S,OAAS,IAAI,CAC5H,IAAIoS,EAAajC,GAAkBkD,EAAaC,OAChDT,EAAO9M,KAAK,CACR+L,QAASuB,EAAaC,MAAMxB,QAC5BzO,OAAQ+P,EACRR,KAAqB,OAAfR,QAAsC,IAAfA,OAAwB,EAASA,EAAWzK,KACzE0I,MAAO+B,GAAcO,GAAmBP,KAE5CiB,EAAeA,EAAaC,MAEhC,OAAOT,EAAO7S,OAAS6S,OAASrQ,EE/F7B,SAAS+Q,GAAaC,GAEzB,IAAIC,EAAO,EAAO,GAAID,GAOtB,MANW,CAAC,KAAM,OAAQ,SACrBpQ,SAAQ,SAAUE,GACfA,KAAOmQ,IACPA,EAAKnQ,GAAOmN,OAAOgD,EAAKnQ,QAGzBmQ,EDfJ,SAASC,GAAarC,GACzB,OAAOsC,GAAStC,EVoOTlK,EAAqBD,OAAOyI,WUpOOiE,KAavC,SAASC,GAAUxC,GACtB,OAAOlK,EAAqBwM,GAAStC,IAYlC,SAASsC,GAAStC,EAAKyC,GAC1B,GAmBJ,WACI,QAAuBtR,IAAnByP,GACA,OAAOA,GAEX,IACI,IAAIZ,EAAM,IAAI0C,IAAI,oBAElB,OADA9B,GAA8B,qBAAbZ,EAAIuC,KAGzB,MAAOzO,IACH8M,IAAiB,EAErB,OAAOA,GA/BH+B,GACA,YAAgBxR,IAATsR,EAAqB,IAAIC,IAAI1C,EAAKyC,GAAQ,IAAIC,IAAI1C,GAE7D,QAAa7O,IAATsR,IAAuB,IAAI1J,KAAKiH,GAChC,MAAM,IAAIqB,MAAM,iBAAiBpR,OAAO+P,EAAK,MAEjD,IAAI4C,EAAMxF,SACNyF,EAAgBD,EAAIE,cAAc,KACtC,QAAa3R,IAATsR,EAAoB,CAEpB,IAAIM,GADJH,EAAMxF,SAAS4F,eAAeC,mBAAmB,KAC3BH,cAAc,QACpCC,EAAYR,KAAOE,EACnBG,EAAIM,KAAKC,YAAYJ,GACrBH,EAAIQ,KAAKD,YAAYN,GAGzB,OADAA,EAAcN,KAAOvC,EACd6C,EE7CJ,IACIQ,GAAkB,gBAClBC,GAAkB,oBCElBC,GAAY,CACnBC,KAAM,OACNC,IAAK,MACLC,cAAe,kBAEfC,GAAgB,CAChBH,KAAM,OACNC,IAAK,MACLC,cAAe,UAEZ,SAASE,GAAsBC,EAAmBC,EAAcC,GACnE,IAAIC,EAeR,SAAgDH,EAAmBC,GAC/D,IAAIG,EAAO,WAAWhU,OAAO0T,GAAcG,IACvCI,EAAQL,EAAkBK,MAAOC,EAAWN,EAAkBM,SAClE,GAAID,EAAO,CACP,IAAIE,EAAuB/B,GAAa6B,GACxC,OAAO,SAAUzS,GAAc,MAAO,GAAGxB,OAAOmU,EAAsB,eAAenU,OAAOoU,mBAAmB,GAAGpU,OAAOgU,EAAM,KAAKhU,OAAOwB,MAE/I,IAAIyE,EAUR,SAA2B2N,EAAmBC,GAC1C,IAAIhQ,EAAK+P,EAAkBS,KAAMA,OAAc,IAAPxQ,EAAgBuP,GAAkBvP,EAAIyQ,EAA6BV,EAAkBU,2BAC7H,GAAIA,GAA8BD,IAASjB,GACvC,MAAO,GAAGpT,OAAOsU,EAA4B,KAAKtU,OAAOoT,IAE7D,IAAImB,EAAcF,EAAKjF,MAAM,KACzBoF,EAAYD,EAAYE,MACxBC,EAAYL,IAAShB,GAAkB,GAAGrT,OAAOsT,GAAUO,GAAe,KAAO,GACrF,MAAO,GAAG7T,OAAO0U,EAAW,mBAAmB1U,OAAOuU,EAAYtM,KAAK,KAAM,KAAKjI,OAAOwU,GAlB9EG,CAAkBf,EAAmBC,GAChD,QAAc3S,IAAV+S,GAAuBC,EAAU,CAEjC,IAAIU,EAAuBxC,GAAa8B,GACxC,OAAO,SAAU1S,GACb,MAAO,GAAGxB,OAAO4U,EAAsB,eAAe5U,OAAOoU,mBAAmB,WAAWpU,OAAOiG,GAAMjG,OAAOgU,EAAM,KAAKhU,OAAOwB,MAGzI,OAAO,SAAUA,GAAc,MAAO,WAAWxB,OAAOiG,GAAMjG,OAAOgU,EAAM,KAAKhU,OAAOwB,IA9B1DqT,CAAuCjB,EAAmBC,GACvF,MAAO,CACHiB,MAAO,SAAUxW,EAAKyW,GAClB,IAAIvT,EA2ChB,SAAiCqC,EAAIgQ,EAAcC,EAAmBxV,EAAKyW,GACvE,IAAIC,EAAcnR,EAAGmR,YAAaV,EAA6BzQ,EAAGyQ,2BAC9DW,EAAO,CAAC,eAAejV,OAAO,UAAW,OAAOA,OAAO1B,IAAM0B,OAAO8T,GACpEiB,GACAE,EAAKxQ,KAAK,eAAezE,OAAO+U,EAAMG,OAAQ,eAAelV,OAAO+U,EAAMI,oBAE9E,IAAI3T,EAAa,CACb,mBACA,UAAUxB,OAAOoU,mBAAmBa,EAAKhN,KAAK,OAC9C,cAAcjI,OAAOgV,GACrB,yBAAyBhV,OAAOoU,mBAAmB,WACnD,wBACA,iBAAiBpU,OAAOmC,MAEP,QAAjB0R,GACArS,EAAWiD,KAAK,cAAczE,OAAO4L,MAErC0I,GACA9S,EAAW4T,UAEf,OAAO5T,EAAWyG,KAAK,KA/DEoN,CAAwBzB,EAAmBC,EAAcC,EAAmBxV,EAAKyW,GAClG,OAAOhB,EAAuBvS,IAElC8T,UAAWvB,EAAuB,IAClCF,aAAcA,GCHtB,IAAI0B,GAAuB,iBACpB,SAASC,GAASxT,EAAKyT,GAI1B,IAAIC,EAvBoB,IAuBc1T,EAAItD,OAAS,GAC/C+W,EAAS/W,OAASgX,GAAkBH,GAAqBzM,KAAK2M,KAC9DpX,EAAQF,KAAK,GAAG6B,OAAOgC,EAAK,+DAIhC,IAAI2T,EAAiBF,EAAShT,QAAQ,KAAM,KAC5C,MAAO,GAAGzC,OAAOgC,EAAK,KAAKhC,OAAO2V,GC3B/B,SAASC,GAA8BhC,GAC1C,IAAIqB,EDHD,SAAmBY,GACtB,IAAIC,EAAMD,EAAcC,IAAKC,EAAUF,EAAcE,QAASC,EAAUH,EAAcG,QAASC,EAAaJ,EAAcI,WACtHhB,EAAO,GAaX,OAZIa,GACAb,EAAKxQ,KAAK+Q,GAAS,MAAOM,IAE1BC,GACAd,EAAKxQ,KAAK+Q,GAAS,UAAWO,IAE9BC,GACAf,EAAKxQ,KAAK+Q,GAAS,UAAWQ,IAE9BC,GACAhB,EAAKxQ,KAAK+Q,GAAS,aAAcS,IAE9BhB,ECZIiB,CAAUtC,GACjBuC,EASR,SAAiCvC,EAAmBqB,GAChD,MAAO,CACHmB,oBAAqBzC,GAAsBC,EAAmB,OAAQqB,GACtEoB,mBAAoB1C,GAAsBC,EAAmB,MAAOqB,GACpEqB,6BAA8B3C,GAAsBC,EAAmB,gBAAiBqB,IAbrEsB,CAAwB3C,EAAmBqB,GAC9DuB,EAAoB1R,EAAaqR,GAAkBnR,KAAI,SAAUyR,GAAW,OAAOA,EAAQnB,aAC3FoB,EAcR,SAAqC9C,EAAmB4C,EAAmBvB,GACvE,IAAKrB,EAAkB+C,QACnB,OAEJ,IAAID,EAAuB,EAAO,GAAI9C,EAAmB,CACrDS,KAAMjB,GACN4B,YAAapB,EAAkB+C,QAAQ3B,cAEvC4B,EAA0B,CAC1BR,oBAAqBzC,GAAsB+C,EAAsB,OAAQzB,GACzEoB,mBAAoB1C,GAAsB+C,EAAsB,MAAOzB,IAG3E,OADAuB,EAAkB/R,KAAK1F,MAAMyX,EAAmB1R,EAAa8R,GAAyB5R,KAAI,SAAUyR,GAAW,OAAOA,EAAQnB,cACvH,EAAO,CAAEuB,cAAejD,EAAkB+C,QAAQE,eAAiBD,GA3B/CE,CAA4BlD,EAAmB4C,EAAmBvB,GAC7F,OAAO,EAAO,CACV8B,YAAa,SAAUhH,GAAO,OAAOyG,EAAkB3N,MAAK,SAAUmO,GAAkB,OAAuC,IAAhCjH,EAAI5L,QAAQ6S,OAC3GL,QAASD,EACTrC,KAAMT,EAAkBS,MAAQjB,IACjC+C,GCPA,IAAIc,GAAsB,CAC7BC,MAAO,QACPC,KAAM,OACNC,gBAAiB,mBAEd,SAASC,GAA8BzD,GAC1C,IAAI/P,EAAIyT,EAAIC,EACZ,GAAK3D,GAAsBA,EAAkBoB,YAA7C,CAIA,IAAIwC,EAAmE,QAA9C3T,EAAK+P,EAAkB4D,yBAAsC,IAAP3T,EAAgBA,EAAK+P,EAAkB6D,WACtH,QAA0BvW,IAAtBsW,GAAoC5S,EAAa4S,GAIrD,QAA8CtW,IAA1C0S,EAAkB8D,qBAAsC9S,EAAagP,EAAkB8D,qBAA3F,CVbG,IAAoCC,EUiBvC,QAA2DzW,IAAvD0S,EAAkBgE,kCACjBhT,EAAagP,EAAkBgE,kCAMpC,OVxBuCD,EUuBZ/D,EAAkBiE,2BVrBxC/X,MAAMiH,QAAQ4Q,KAGdpK,KACDA,GAA8B,IAAIhJ,IAAIoT,IAE1CA,EACKG,QAAO,SAAUC,GAAQ,MAAuB,kBAATA,KACvCjW,SAAQ,SAAUiW,GACf/T,EAAS+T,EAAM,MACf1Z,EAAQF,KAAK,8BAA8B6B,OAAO+X,EAAM,MAE5DxK,GAA4BhG,IAAIwQ,OUU7B,EAAO,CACVC,WAAYpE,EAAkBoE,YAAchZ,EAAgB4U,EAAkBoE,WAAY,8BAC1FC,cAAeC,GAAmBtE,GAClC4D,kBAAyC,OAAtBA,QAAoD,IAAtBA,EAA+BA,EAAoB,IACpGE,oBAAsE,QAAhDJ,EAAK1D,EAAkB8D,2BAAwC,IAAPJ,EAAgBA,EAAK,GACnGM,iCAAgG,QAA7DL,EAAK3D,EAAkBgE,wCAAqD,IAAPL,EAAgBA,EAAK,EAC7HxB,QAASnC,EAAkBmC,QAC3BoC,qBAAsBvE,EAAkBuE,mBAKxCC,gBAAiB,MACjBC,0BAA2B,IAC3BC,0BAA2B,GAK3BC,aAAc,IAIdC,mBAAoB,GACpBC,kBAAmB,QACpB7C,GAA8BhC,IA9B7BvV,EAAQD,MAAM,iFALdC,EAAQD,MAAM,mEAJdC,EAAQD,MAAM,iEALdC,EAAQD,MAAM,8DA8Cf,SAAS8Z,GAAmBtE,GAC/B,IAAIqE,EAAgB,GAMpB,OALAA,EAAc/K,OAOlB,SAA6B0G,GACzB,QAASA,EAAkB8E,0BAA4B9E,EAAkB+E,0BARlDC,CAAoBhF,GAC3CqE,EAAcjL,YAAc4G,EAAkB+E,0BAC1C/E,EAAkBiF,+BAClBZ,EAAchL,OZtBf,WACH,QAA4B/L,IAAxBsL,GAAmC,CAOnC,IAJA,IAAIsM,EAAiB,gBAAgB9Y,OAAOmC,KAExC4W,EAAenT,OAAOyI,SAASC,SAASc,MAAM,KAC9C4J,EAAkBD,EAAatE,MAC5BsE,EAAara,SAAW2O,GAAUyL,IACrCE,EAAkB,GAAGhZ,OAAO+Y,EAAatE,MAAO,KAAKzU,OAAOgZ,GAC5DvM,GAAUqM,EALQ,OAKyBpY,EAAY,CAAEuM,OAAQ+L,IAErE1L,GAAawL,EAAgB,CAAE7L,OAAQ+L,IACvCxM,GAAsBwM,EAE1B,OAAOxM,GYOoByM,IAEpBhB,EC3CJ,SAASiB,GAAqB3Y,GACV,IAAnBA,EAAQ4Y,QAAiB5Y,EAAQ6Y,YACjC7Y,EAAQ8Y,aAAUnY,EAClBX,EAAQ+Y,YAASpY,EACjBX,EAAQgZ,kBAAerY,GA+C/B,SAASsY,GAA8B3D,EAAetV,EAASkZ,EAAgBC,GAC3E,QAeuBxY,IAAhByY,MAfuBF,EAAeG,qBAA7C,CAGA,IAAIC,EAAgBnV,EAAKmR,EAAciE,oBAAoB,SAAUD,GACjE,OAAOnR,EAAU,CAACmR,EAAcE,OAAQxZ,EAAQwP,KAAK,MAEpD8J,IAGLtZ,EAAQ8Y,QAAU,IAAIW,GACtBzZ,EAAQ+Y,OAAS,IAAIU,GACrBzZ,EAAQgZ,cAAgB1U,EAASgR,EAAcoE,kBAAoBvX,EAAYmT,EAAcoE,iBAC7FP,EAYJ,SAA4BL,EAASC,EAAQC,EAAcW,GACvD,IAAIC,EAAiB,GAoCrB,OAnCAD,EAAgBpY,SAAQ,SAAUsY,GAC9B,OAAQA,GACJ,IAAK,UACD,EAAOD,EAAgB,CACnB,mBAAoB,MACpB,sBAAuBb,EAAOe,kBAC9B,8BAA+Bd,EAAe,IAAM,IACpD,qBAAsBF,EAAQgB,oBAElC,MAGJ,IAAK,eACD,EAAOF,EAAgB,CACnBG,YAAa,sBAAsBta,OAAOqZ,EAAQkB,4BAA6B,KAAKva,OAAOsZ,EAAOiB,4BAA6B,MAAMva,OAAOuZ,EAAe,IAAM,OAErK,MAGJ,IAAK,KACD,EAAOY,EAAgB,CACnBK,GAAI,GAAGxa,OAAOqZ,EAAQkB,4BAA6B,KAAKva,OAAOsZ,EAAOiB,4BAA6B,KAAKva,OAAOuZ,EAAe,IAAM,OAExI,MAEJ,IAAK,UACD,EAAOY,EAAgB,CACnB,eAAgBd,EAAQkB,4BACxB,cAAejB,EAAOiB,4BACtB,eAAgBhB,EAAe,IAAM,UAM9CY,EAjDAM,CAAmBla,EAAQ8Y,QAAS9Y,EAAQ+Y,OAAQ/Y,EAAQgZ,aAAcM,EAAcK,oBAKnG,SAASP,KACL,OAAO/T,OAAO8U,QAAU9U,OAAO+U,SA8CnC,IAAIX,GAAiC,WACjC,SAASA,IACL1Z,KAAKoK,OAAS,IAAIkQ,WAAW,GAC7BjB,KAAYkB,gBAAgBva,KAAKoK,QACjCpK,KAAKoK,OAAO,GAAsB,IAAjBpK,KAAKoK,OAAO,GAiCjC,OA/BAsP,EAAgBpb,UAAU4D,SAAW,SAAUsY,GAC3C,IAAIC,EAAOza,KAAK0a,UAAU,GACtBC,EAAM3a,KAAK0a,UAAU,GACrBhS,EAAM,GACV,EAAG,CACC,IAAIkS,EAAOH,EAAOD,EAAS,WAAaG,EACxCF,EAAOzY,KAAK6Y,MAAMJ,EAAOD,GACzBG,EAAM3Y,KAAK6Y,MAAMD,EAAMJ,GACvB9R,GAAOkS,EAAMJ,GAAOtY,SAASsY,GAAS9R,QACjC+R,GAAQE,GACjB,OAAOjS,GAKXgR,EAAgBpb,UAAUyb,gBAAkB,WACxC,OAAO/Z,KAAKkC,SAAS,KAKzBwX,EAAgBpb,UAAU2b,0BAA4B,WAClD,IAAIlB,EAAU/Y,KAAKkC,SAAS,IAC5B,OAAO1C,MAAM,GAAKuZ,EAAQ3a,QAAQuJ,KAAK,KAAOoR,GAElDW,EAAgBpb,UAAUoc,UAAY,SAAUI,GAC5C,OAA8B,SAAtB9a,KAAKoK,OAAO0Q,IACf9a,KAAKoK,OAAO0Q,EAAS,IAAM,KAC3B9a,KAAKoK,OAAO0Q,EAAS,IAAM,GAC5B9a,KAAKoK,OAAO0Q,EAAS,IAEtBpB,EArCyB,GC1I7B,SAASqB,GAAiCzH,GAC7C,IAAI/P,EAAIyT,EAAIC,EAAI+D,EAAIC,EAAIC,EACxB,GAAK5H,EAAkBiD,cAIvB,QAAkD3V,IAA9C0S,EAAkB6H,yBACjB7W,EAAagP,EAAkB6H,yBADpC,CAMA,IAAIC,EAAmE,QAA9C7X,EAAK+P,EAAkB8H,yBAAsC,IAAP7X,EAAgBA,EAAK+P,EAAkB+H,iBAKtH,QAJ0Bza,IAAtBwa,QAAiFxa,IAA9C0S,EAAkB6H,0BACrDpd,EAAQF,KAAK,0EACbud,OAAoBxa,QAEEA,IAAtBwa,GAAoC9W,EAAa8W,GAArD,CAIA,IAAIzB,EAA+D,QAA5C3C,EAAK1D,EAAkBqG,uBAAoC,IAAP3C,EAAgBA,EAAK1D,EAAkBgI,kBAClH,QAAwB1a,IAApB+Y,GAAkCrV,EAAaqV,GAInD,QAA+C/Y,IAA3C0S,EAAkBiI,sBAAuC/b,MAAMiH,QAAQ6M,EAAkBiI,sBAA7F,CAIA,IAAI/B,EAiCR,SAAwClG,QAES1S,IAAzC0S,EAAkBkG,yBAAgF5Y,IAA5C0S,EAAkBkI,uBACxEzd,EAAQF,KAAK,2JAGjB,QAA6C+C,IAAzC0S,EAAkBkG,mBAAkC,CACpD,IAAKha,MAAMiH,QAAQ6M,EAAkBkG,oBAEjC,YADAzb,EAAQD,MAAM,2CAGlB,GAAoD,IAAhDwV,EAAkBkG,mBAAmBpb,aAA8CwC,IAA9B0S,EAAkBmC,QAEvE,YADA1X,EAAQD,MAAM,0DAIlB,IAAI2d,EAAmB,GAYvB,OAXAnI,EAAkBkG,mBAAmBhY,SAAQ,SAAUka,GAC/CxT,EAAcwT,GACdD,EAAiBtX,KAAK,CAAEsV,MAAOiC,EAAQ9B,gBAAiB,CAAC,cDnFlE,SAAyB1V,GAC5B,IAAIyX,EAAezX,EACnB,MAAkC,WAA1BsC,EAAQmV,IACZzT,EAAcyT,EAAalC,QAC3Bja,MAAMiH,QAAQkV,EAAa/B,iBCiFdgC,CAAgBF,GAIrB3d,EAAQF,KAAK,yGAA0G6d,GAHvHD,EAAiBtX,KAAKuX,MAMvBD,EAGX,QAAgD7a,IAA5C0S,EAAkBkI,sBAAqC,CACvD,IAAKhc,MAAMiH,QAAQ6M,EAAkBkI,uBAEjC,YADAzd,EAAQD,MAAM,8CAGlB,GAAuD,IAAnDwV,EAAkBkI,sBAAsBpd,aAA8CwC,IAA9B0S,EAAkBmC,QAE1E,YADA1X,EAAQD,MAAM,0DAGlB,IAAI+d,EAAmB,GAOvB,OANAvI,EAAkBkI,sBAAsBha,SAAQ,SAAUsa,GACtD,IAAIvC,EAahB,SAAiDrV,GAC7C,IAAIuV,EACgB,kBAATvV,EACPuV,EAAQvV,EAEHA,aAAgB+B,OACrBwT,EAAQ,SAAUhK,GAAO,OAAOvL,EAAKsE,KAAKyJ,GAAUxC,KAE/B,oBAATvL,IACZuV,EAAQ,SAAUhK,GAAO,OAAOvL,EAAK+N,GAAUxC,MAEnD,QAAc7O,IAAV6Y,EAEA,YADA1b,EAAQF,KAAK,gGAAiGqG,GAGlH,MAAO,CAAEuV,MAAOA,EAAOG,gBAAiB,CAAC,YA5BbmC,CAAwCD,GACxDvC,GACAsC,EAAiB1X,KAAKoV,MAGvBsC,EAEX,MAAO,GAlFkBG,CAA+B1I,GACxD,GAAKkG,EAAL,CAGA,IAAIyC,EAAoBlF,GAA8BzD,GACtD,GAAK2I,EAAL,CAGA,IlBsI2Bra,EAAQgB,EkBtI/BsZ,KAA8E,QAAlDjF,EAAK3D,EAAkB4I,6BAA0C,IAAPjF,EAAgBA,EAAK3D,EAAkB6I,mBAC7HC,IAAsB9I,EAAkB8I,kBAC5C,OAAO,EAAO,CACV7F,cAAejD,EAAkBiD,cACjCb,QAASpC,EAAkBoC,QAC3B2G,oBAAqB/I,EAAkB+I,oBACvClB,wBAAwI,QAA9GF,EAA0D,QAApDD,EAAK1H,EAAkB6H,+BAA4C,IAAPH,EAAgBA,EAAKI,SAAsC,IAAPH,EAAgBA,EAAK,IACrKqB,sBAAgE1b,IAA9C0S,EAAkB6H,wBACpCxB,gBAAiBA,EACjBH,mBAAoBA,EACpB+B,qBAAwE,QAAjDL,EAAK5H,EAAkBiI,4BAAyC,IAAPL,EAAgBA,EAAK,GACrGgB,sBAAuBA,GAAyBE,EAChDA,kBAAmBA,EACnBG,qBAAsBjJ,EAAkBiJ,mBACxCC,eAAgBlJ,EAAkBkJ,eAClCC,eAAgBnJ,EAAkBmJ,eAClCC,qBlBsHuB9a,EkBtHa+U,GlBsHL/T,EkBtH0B0Q,EAAkBoJ,oBlBuHxEre,OAAOoG,KAAK7C,GAAQ2G,MAAK,SAAU7G,GAAO,OAAOE,EAAOF,KAASkB,KkBtH9D0Q,EAAkBoJ,oBAClB/F,GAAoBG,iBAC1B6F,gCAAiC,GAClCV,UA/BCle,EAAQD,MAAM,kDAJdC,EAAQD,MAAM,+DALdC,EAAQD,MAAM,iEAVdC,EAAQD,MAAM,wEALdC,EAAQD,MAAM,oEAwItB,SAAS8e,GAA8BrH,GACnC,IAAIsH,EAAyB,IAAI5Y,IAcjC,OAbIzE,MAAMiH,QAAQ8O,EAAciE,qBAAuBjE,EAAciE,mBAAmBpb,OAAS,GAC7FmX,EAAciE,mBAAmBhY,SAAQ,SAAUka,GAC3CxT,EAAcwT,GACdmB,EAAuB5V,IAAI,WAG3ByU,EAAO9B,gBAAgBpY,SAAQ,SAAUsY,GAAkB,OAAO+C,EAAuB5V,IAAI6S,SAIrGta,MAAMiH,QAAQ8O,EAAciG,wBAA0BjG,EAAciG,sBAAsBpd,OAAS,GACnGye,EAAuB5V,IAAI,WAExBnD,EAAU+Y,GC5Jd,SAASC,GAAmBC,EAAsBC,EAAoBC,GACzE,MAAO,CACHhd,QAAS8c,EAAqBnT,aAC9BiI,KAAMmL,EAAmBpT,aACzBsT,YAAWD,EAAYE,oBAAuBvc,GCJ/C,SAASwc,GAAgBpM,EAAMqM,GAClC,IAAIhT,EAAW/E,OAAOgY,gCAClBjT,GACAA,EAAS,CAAE2G,KAAMA,EAAMqM,QAASA,ICHxC,IAAIE,GAA4B,WAC5B,SAASA,EAAWC,GAChBxd,KAAKwd,iBAAmBA,EACxBxd,KAAKyd,UAAY,GAoBrB,OAlBAF,EAAWjf,UAAUof,UAAY,SAAUC,GACvC,IAAIC,EAAQ5d,KAKZ,OAJKA,KAAKyd,UAAUrf,QAAU4B,KAAKwd,mBAC/Bxd,KAAK6d,kBAAoB7d,KAAKwd,yBAAsB5c,GAExDZ,KAAKyd,UAAUtZ,KAAKwZ,GACb,CACHG,YAAa,WACTF,EAAMH,UAAYG,EAAMH,UAAUjG,QAAO,SAAUuG,GAAS,OAAOJ,IAAMI,MACpEH,EAAMH,UAAUrf,QAAUwf,EAAMC,mBACjCD,EAAMC,uBAKtBN,EAAWjf,UAAU0f,OAAS,SAAUC,GACpCje,KAAKyd,UAAUjc,SAAQ,SAAU0c,GAAY,OAAOA,EAASD,OAE1DV,EAvBoB,GA0BxB,SAASY,KAEZ,IADA,IAAIC,EAAc,GACTlgB,EAAK,EAAGA,EAAKC,UAAUC,OAAQF,IACpCkgB,EAAYlgB,GAAMC,UAAUD,GAEhC,IAAImgB,EAAmB,IAAId,IAAW,WAClC,IAAIe,EAAgBF,EAAY1Z,KAAI,SAAU6Z,GAC1C,OAAOA,EAAWb,WAAU,SAAUO,GAAQ,OAAOI,EAAiBL,OAAOC,SAEjF,OAAO,WAAc,OAAOK,EAAc9c,SAAQ,SAAUgd,GAAgB,OAAOA,EAAaV,qBAEpG,OAAOO,ECxBJ,SAASI,GAAuBnd,EAAQyE,GAC3C,IACI2Y,EADAC,EAAgBrZ,OAQpB,OANIqZ,EAAcC,MAAiD,oBAAlCD,EAAcC,KAAKC,aAChDH,EAAWpd,EAAOqd,EAAcC,KAAKC,WAAW9Y,KAE/C2Y,IACDA,EAAWpd,EAAOyE,IAEf2Y,ECVJ,SAASI,GAAiBC,EAAanR,EAAOoR,EAAUxe,GAC3D,OAAOye,GAAkBF,EAAa,CAACnR,GAAQoR,EAAUxe,GActD,SAASye,GAAkBF,EAAaG,EAAQF,EAAUzb,GAC7D,IAAIyT,OAAY,IAAPzT,EAAgB,GAAKA,EAAI4b,EAAOnI,EAAGmI,KAAMC,EAAUpI,EAAGoI,QAASC,EAAUrI,EAAGqI,QACjFC,EAAkBxf,EAAQqf,EACxB,SAAUvR,GACR2R,IACAP,EAASpR,IAEXoR,GACFxe,EAAU6e,EAAU,CAAED,QAASA,EAASC,QAASA,GAAYD,EAC7DnY,EAAMwX,GAAuBM,EAAa,oBAE9C,SAASQ,IACL,IAAI9V,EAASgV,GAAuBM,EAAa,uBACjDG,EAAO1d,SAAQ,SAAUoM,GAAS,OAAOnE,EAAOjL,KAAKugB,EAAanR,EAAO0R,EAAiB9e,MAE9F,OALA0e,EAAO1d,SAAQ,SAAUoM,GAAS,OAAO3G,EAAIzI,KAAKugB,EAAanR,EAAO0R,EAAiB9e,MAKhF,CACH+e,KAAMA,GC3CP,ICkBHC,GDlBOC,GACF,MADEA,GAEQ,gBCQfC,GAAqB,CACrB,0CACA,wCACA,mBACA,eAEAC,GAA2B,CbbE,gBac7BC,GAAyB,CAAEC,iBAAkB,EAAGC,eAAgB,EAAGC,kBAAkB,EAAOC,+BAA+B,GAExH,SAASC,GAAeC,EAAkB3K,GAC7C,IAAI4K,EACA5B,EAAa,IAAIhB,GA+BrB,OA9BAqC,GAAuBG,kBAClBrc,EAASic,GAA0BpK,EAAcxB,OAAS3R,EAAYmT,EAAc6B,qBACzFwI,GAAuBI,8BACnBJ,GAAuBG,kBAAoB3d,EAAYmT,EAAc+B,kCACzEkI,GAA+B,SAAUY,GACrC,GAAIR,GAAuBG,iBAAkB,CACzC,IAAIM,EAUZ,SAA0BH,EAAkBtS,GACxC,OAAO7F,EAAQ,CACXiJ,KAAM,YACN3E,KAAMf,IACNmK,QAASyK,EACTxK,QAAS,SACTjU,OAAQ,UACR6e,IAAK,CACDC,eAAgB,GAEpBC,UAAW5S,EACX6S,sBAAuB3c,EAAUuK,YACdzN,IAApBuf,EAAgCA,IAAoB,IAtBrCO,CAAiBR,EAAkBE,GACjD7B,EAAWP,OAAOqC,GAClBjD,GAAgB,YAAaiD,K1BjBrCrhB,E0BoB4B2hB,GAC5B,EAAOf,GAAwB,CAC3BC,iBAAkBtK,EAAcyC,0BAChC8H,eAAgB,IAgBb,CACHc,mBAAoB,SAAUC,GAC1BV,EAAkBU,GAEtBtC,WAAYA,EACZuC,QAASlB,GAAuBG,kBAwBjC,SAASgB,GAAkB7Q,EAASjQ,GACvCE,EAAsB1C,EAAeE,MAAOuS,EAASjQ,GACrD+gB,GAAa,EAAO,CAChBhQ,KAAMyO,GACNvP,QAASA,EACT2I,OAAQ,SACT5Y,IAEA,SAAS0gB,GAAkBzgB,GAC9B8gB,GAAa,EAAO,CAChBhQ,KAAMyO,GACN5G,OAAQ,SAiBT,SAAqB3Y,GACxB,GAAIA,aAAa4Q,MAAO,CACpB,IAAIN,EAAajC,GAAkBrO,GACnC,MAAO,CACHpC,MAAO,CACHmjB,KAAMzQ,EAAWzK,KACjB0I,MAAOsC,GAAmBmQ,GAAoB1Q,KAElDN,QAASM,EAAWN,SAG5B,MAAO,CACHpS,MAAO,CACH2Q,MAAO,4BAEXyB,QAAS,YAAYxQ,OAAOiD,EAAczC,KA/B3CihB,CAAYjhB,KAUnB,SAAS8gB,GAAapT,GACd4R,IAAgCI,GAAuBE,eAAiBF,GAAuBC,mBAC/FD,GAAuBE,gBAAkB,EACzCN,GAA6B5R,IAqB9B,SAASsT,GAAoB1Q,GAEhC,OADAA,EAAW/B,MAAQ+B,EAAW/B,MAAM+I,QAAO,SAAUnG,GAAS,OAAQA,EAAM5B,KAAOiQ,GAAmBnX,MAAK,SAAU6Y,GAAmB,OAAOvc,EAAWwM,EAAM5B,IAAK2R,SAC9J5Q,EC/GJ,SAAS6Q,KACZ,IAAIC,EACA3C,EAAgBrZ,OAYpB,GAAIqZ,EAAcC,OAId0C,EAAc7C,GAAuBE,EAAe,oBAChDA,EAAc4C,kBAAoBD,IAAgB3C,EAAc4C,kBAAkB,CAOlF,IACIC,EAAmB/C,GADD,IAAIE,EAAc4C,iBAAiB7e,GACM,oBAC/D4e,EAAcE,GAAoBA,EAAiBF,YAM3D,OAHKA,IACDA,EAAc3C,EAAc4C,kBAEzBD,ECnDJ,SAASG,GAAgBC,EAAoBrX,GAC5CwC,SAAS8U,aAAeD,GAA8C,aAAxB7U,SAAS8U,WACvDtX,IAIAyU,GAAiBxZ,OADsB,aAAvBoc,EAAoC,OAAoB,mBACpCrX,EAAU,CAAE8U,MAAM,ICNvD,IAAIyC,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,EAAGrO,GAAQ,MAAO,UAAUlL,KAAKkL,KAC7D,CAAC,KAAe,SAAUqO,EAAGrO,GAAQ,MAAO,SAASlL,KAAKkL,KAC1D,CACI,QACA,SAAUoO,EAAepO,GACrB,OAAOhQ,EAAS,CAAC,QAAS,MAAO,QAASoe,IAAuE,OAArD,sCAAsC5b,KAAKwN,KAG/G,CAAC,OAAmB,SAAUqO,EAAGrO,GAAQ,OAAiD,OAA1C,2BAA2BxN,KAAKwN,KAChF,CACI,QACA,SAAUoO,EAAepO,GACrB,OAAOhQ,EAAS,CAAC,QAAS,SAAUoe,IAAiD,OAA/B,gBAAgB5b,KAAKwN,MAIhF,SAASsO,GAAoB/V,GAChC,IAAIwD,EAAMxD,EAAOlG,KACjB,IlBrBG,SAAoB0J,GACvB,IACI,QAASsC,GAAStC,GAEtB,MAAOlM,GACH,OAAO,GkBgBN0e,CAAWxS,GAEZ,OADAsR,GAAkB,gCAAiCrhB,OAAOuM,EAAOlG,KAAM,MAChE,QAGX,IADA,IAAI2N,ElBXD,SAAqBjE,GACxB,IAAIyS,EAAWnQ,GAAStC,GAAKyS,SAC7B,MAAuB,MAAhBA,EAAS,GAAaA,EAAW,IAAIxiB,OAAOwiB,GkBSxCC,CAAY1S,GACdvR,EAAK,EAAGkkB,EAAmBP,GAAgB3jB,EAAKkkB,EAAiBhkB,OAAQF,IAAM,CACpF,IAAIqF,EAAK6e,EAAiBlkB,GAAK8S,EAAOzN,EAAG,GACzC,IAAI8e,EADkD9e,EAAG,IAC9C0I,EAAO6V,cAAepO,GAC7B,OAAO1C,EAGf,MAAO,QAEX,SAASsR,KAEL,IADA,IAAIC,EAAU,GACLrkB,EAAK,EAAGA,EAAKC,UAAUC,OAAQF,IACpCqkB,EAAQrkB,GAAMC,UAAUD,GAE5B,IAAK,IAAIoB,EAAI,EAAGA,EAAIijB,EAAQnkB,OAAQkB,GAAK,EACrC,GAAIijB,EAAQjjB,EAAI,GAAKijB,EAAQjjB,GACzB,OAAO,EAGf,OAAO,EAKJ,SAASkjB,GAAmCC,GAC/C,IAAIpX,EAAWoX,EAAMpX,SAAUqX,EAAYD,EAAMC,UAAWC,EAAcF,EAAME,YAEhF,OACWvX,EADM,IAAbC,GAAkBqX,EAAYC,EACNjX,GAAQgX,EAAWC,GAEvBtX,GAErB,SAASuX,GAAkCH,GAC9C,IAAII,EAAaC,GAAaL,GAC9B,GAAKI,EAAL,CAGA,IAAIH,EAAYG,EAAWH,UAAWK,EAAaF,EAAWE,WAAYC,EAAgBH,EAAWG,cAAeC,EAAcJ,EAAWI,YAAaC,EAAoBL,EAAWK,kBAAmBC,EAAkBN,EAAWM,gBAAiBC,EAAeP,EAAWO,aAAcC,EAAwBR,EAAWQ,sBAAuBC,EAAaT,EAAWS,WAAYC,EAAeV,EAAWU,aAAcC,EAAgBX,EAAWW,cAC/bC,EAAU,CACVC,SAAUC,GAAajB,EAAWc,EAF0bX,EAAWF,aAGveiB,WAAYD,GAAajB,EAAWa,EAAcC,IAiBtD,OAdIF,IAAeP,IACfU,EAAQI,QAAUF,GAAajB,EAAWU,EAAcE,GAEpDhB,GAAWc,EAAcC,EAAuBC,KAChDG,EAAQK,IAAMH,GAAajB,EAAWW,EAAuBC,KAIjEH,IAAoBJ,IACpBU,EAAQM,IAAMJ,GAAajB,EAAWQ,EAAmBC,IAEzDa,GAAevB,KACfgB,EAAQQ,SAAWN,GAAajB,EAAWM,EAAeC,IAEvDQ,GAEJ,SAASX,GAAaL,GAKzB,GAAKH,GAAWG,EAAMC,UAAWD,EAAMM,WAAYN,EAAMS,kBAAmBT,EAAMU,gBAAiBV,EAAMW,aAAcX,EAAMa,WAAYb,EAAMc,aAAcd,EAAMe,cAAef,EAAME,aAAxL,CAGA,IAAKqB,GAAevB,GAChB,OAAOA,EAEX,IAAIO,EAAgBP,EAAMO,cAAeC,EAAcR,EAAMQ,YAU7D,GAPID,EAAgBP,EAAMC,YACtBM,EAAgBP,EAAMC,WAEtBO,EAAcR,EAAMC,YACpBO,EAAcR,EAAMM,YAGnBT,GAAWG,EAAMC,UAAWM,EAAeC,EAAaR,EAAMM,YAGnE,OAAO,EAAO,GAAIN,EAAO,CACrBQ,YAAaA,EACbD,cAAeA,KAGvB,SAASgB,GAAevB,GAEpB,OAAOA,EAAMM,aAAeN,EAAMC,UAEtC,SAASiB,GAAale,EAAQkG,EAAOC,GACjC,MAAO,CACHP,SAAUD,EAAiBM,GAAQC,EAAOC,IAC1CD,MAAOP,EAAiBM,GAAQjG,EAAQkG,KAGzC,SAASuY,GAAYzB,GAExB,GAAIA,EAAMC,UAAYD,EAAMe,cACxB,OAAOf,EAAM0B,gBAId,SAASC,GAAoB7O,EAAe9F,GAC/C,OAAOA,IAAQ8F,EAAckB,YAAYhH,GCvItC,SAAS4U,GAAWC,GACvB,OAAOA,EAAKC,WAAaC,KAAKC,UAK3B,SAASC,GAAcJ,GAC1B,OAAOA,EAAKC,WAAaC,KAAKG,aAE3B,SAASC,GAAiBN,GAC7B,OAAOI,GAAcJ,IAASnX,QAAQmX,EAAKO,YAExC,SAASC,GAAiBR,GAC7B,IAAIO,EAAaP,EACjB,QAASO,EAAWlf,MAAQ+e,GAAcG,EAAWlf,MAQlD,SAASof,GAAcT,GAC1B,OAAOQ,GAAiBR,GAAQA,EAAK3e,KAAO2e,EAAKU,WCrB9C,ICDHC,GCCAC,GFCG,SAASC,GAAmBtY,GAC/B,IAAIoR,EAMD,SAAsCpR,GACzC,IAAIuY,EAAcvY,EAASwY,cAAc,0BACrCC,EAAgBzY,EAASwY,cAAc,4BAC3C,OAAOE,GAAwBH,GAAeA,EAAYI,QAASF,GAAiBA,EAAcE,SATvFC,CAA6B5Y,IAWrC,SAAyCA,GAC5C,IAAI6Y,EAgBD,SAA0B7Y,GAI7B,IAAK,IAAIvN,EAAI,EAAGA,EAAIuN,EAAS8Y,WAAWvnB,OAAQkB,GAAK,EAAG,CAEpD,GADIomB,EAAUE,GAAwB/Y,EAAS8Y,WAAWrmB,IAEtD,OAAOomB,EAOf,GAAI7Y,EAASgG,KACT,IAASvT,EAAIuN,EAASgG,KAAK8S,WAAWvnB,OAAS,EAAGkB,GAAK,EAAGA,GAAK,EAAG,CAC9D,IACIomB,EADApB,EAAOzX,EAASgG,KAAK8S,WAAWrmB,GAEpC,GADIomB,EAAUE,GAAwBtB,GAElC,OAAOoB,EAEX,IAAKrB,GAAWC,GACZ,OAtCEuB,CAAiBhZ,GAC/B,IAAK6Y,EACD,OAEJ,OAAOH,GAAwB1f,EAAwB6f,EAAS,YAAa7f,EAAwB6f,EAAS,eAhBzDI,CAAgCjZ,GACrF,GAAKoR,KAAQA,EAAK8H,WAAajb,IAHuB,MAMtD,OAAOmT,EAAKlF,QAcT,SAASwM,GAAwBxM,EAASiN,GAC7C,IAAID,EAAYC,GAAgBC,OAAOD,GACvC,GAAKjN,GAAYgN,EAGjB,MAAO,CACHhN,QAASA,EACTgN,UAAWA,GA8BnB,SAASH,GAAwBtB,GAC7B,GAAIA,GDzDD,SAAuBA,GAC1B,OAAOA,EAAKC,WAAaC,KAAK0B,aCwDlBC,CAAc7B,GAAO,CAC7B,IAAI7K,EAAQ,wBAAwBvT,KAAKoe,EAAKrG,MAC9C,GAAIxE,EACA,OAAOA,EAAM,IG5DzB,SAAS2M,KACL,YAA8BxlB,IAAvB0E,OAAOyF,aAA6B,eAAgBA,YAExD,SAASsb,GAA8BC,GAC1C,OAAQhhB,OAAOihB,0BACiC3lB,IAA5C2lB,oBAAoBC,qBACpBD,oBAAoBC,oBAAoB9iB,SAAS4iB,GAElD,SAASG,GAA2BC,EAAWnR,GAkD/C,IAA+ClL,EA9ClD,GA8CkDA,EAjDZ,SAAU4B,GAC5C0a,GAA4BD,EAAWnR,EAAe,CAACtJ,KAiD3DwV,GAAgB,eAAe,WAC3B,IAAIxV,EACA2a,EAAmB,CACnBN,UAAW,WACXxE,cAAeF,GACf7I,QAASoM,GAAmBtY,WAEhC,GAAIwZ,GAA8B,eAAiBtb,YAAY8b,iBAAiB,cAAczoB,OAAS,EAEnG6N,EAAS,EADalB,YAAY8b,iBAAiB,cAAc,GACjCpjB,SAAUmjB,OAEzC,CACD,IAAIE,EAA4BC,KAChC9a,EAAS,EAAO6a,EAA2B,CACvC3C,gBAAiB,EACjB9Y,SAAUyb,EAA0BnE,YACpC5c,KAAMT,OAAOyI,SAASiE,KACtB0Q,UAAW,GACZkE,GAEPvc,EAAS4B,MAnETma,KAA4B,CAC5B,IAAIY,EAAuBjc,YAAYkc,aAGvC9lB,WAAWrB,GAAQ,WAAc,OAAO6mB,GAA4BD,EAAWnR,EAAeyR,OAElG,GAAI1hB,OAAOihB,oBAAqB,CAC5B,IAAIW,EAA+BpnB,GAAQ,SAAUqnB,GACjD,OAAOR,GAA4BD,EAAWnR,EAAe4R,EAAQF,iBAErEG,EAAc,CAAC,WAAY,aAAc,WAAY,SACrDC,EAAsB,CAAC,2BAA4B,cAAe,gBACtE,IAIIA,EAAoB7lB,SAAQ,SAAUwP,GACnB,IAAIuV,oBAAoBW,GAC9BI,QAAQ,CAAEtW,KAAMA,EAAMuW,UAAU,OAGjD,MAAOrnB,GAGHknB,EAAYjjB,KAAK1F,MAAM2oB,EAAaC,GAErB,IAAId,oBAAoBW,GAC9BI,QAAQ,CAAEE,WAAYJ,IAC/BhB,MAA8B,qBAAsBrb,aAEpDA,YAAY+T,iBAAiB,4BAA4B,WACrD/T,YAAY0c,0BAInBpB,GAA8B,eAmCvC,SAAkChc,GAC9B,SAASqd,IACLrd,EAAS,EAAO0c,KAAoC,CAChDT,UAAW,gBAGnB7E,GAAgB,YAAY,WAExBtgB,WAAWrB,EAAQ4nB,OA1CnBC,EAAyB,SAAU1b,GAC/B0a,GAA4BD,EAAWnR,EAAe,CAACtJ,OAG1Doa,GAA8B,gBA6CvC,SAAkChc,GAC9B,IAAIud,EAAiB9c,IACjB+c,GAAa,EACbC,EAAuB7I,GAAkB3Z,OAAQ,CAAC,QAAqB,YAA8B,UAA0B,aAAgC,gBAAmC,SAAUyiB,GAE5M,GAAKA,EAAIC,WAAT,CAMA,IAAI/b,EAAS,CACTqa,UAAW,cACX2B,gBAAiB1c,KACjBmX,UAAWqF,EAAIrd,WAEF,gBAAbqd,EAAI/W,KACJkX,EAAkCjc,GAGlCkc,EAAWlc,MAEhB,CAAEoT,SAAS,EAAMD,SAAS,IAAQG,KAOrC,SAAS2I,EAAkCjc,GACvCgT,GAAkB3Z,OAAQ,CAAC,YAA8B,kBAAuC,SAAUsI,GACnF,cAAfA,EAAMoD,MACNmX,EAAWlc,KAEhB,CAAEkT,MAAM,IAEf,SAASgJ,EAAWlc,GAChB,IAAK4b,EAAY,CACbA,GAAa,EACbC,IAMA,IAAIM,EAAQnc,EAAOgc,gBAAkBhc,EAAOyW,UACxC0F,GAAS,GAAKA,EAAQtd,IAAY8c,GAClCvd,EAAS4B,KA3FjBoc,EAAyB,SAAUpc,GAC/B0a,GAA4BD,EAAWnR,EAAe,CAACtJ,OA+FnE,SAAS8a,KACL,IAAI5V,EAAS,GACTlF,EAASlB,YAAYkB,OACzB,IAAK,IAAIvK,KAAOuK,EACZ,GAAI1H,EAAS0H,EAAOvK,IAAO,CACvB,IAAI4mB,EAAY5mB,EACZ6mB,EAAgBtc,EAAOqc,GAC3BnX,EAAOmX,GAA+B,IAAlBC,EAAsB,EAAIxc,GAAgBwc,GAGtE,OAAOpX,EAEX,SAASwV,GAA4BD,EAAWnR,EAAe4R,GAC3D,IASIqB,EATwBrB,EAAQ3P,QAAO,SAAUiL,GACjD,MAA2B,aAApBA,EAAM6D,WACW,eAApB7D,EAAM6D,WACc,UAApB7D,EAAM6D,WACc,aAApB7D,EAAM6D,WACc,6BAApB7D,EAAM6D,WACc,gBAApB7D,EAAM6D,WACc,iBAApB7D,EAAM6D,aAE2C9O,QAAO,SAAUiL,GAAS,OAKvF,SAAgCA,GAC5B,MAA2B,eAApBA,EAAM6D,WAA8B7D,EAAMgG,cAAgB,EAN0BC,CAAuBjG,KAQtH,SAA6BlN,EAAekN,GACxC,MAA2B,aAApBA,EAAM6D,YAA6BlC,GAAoB7O,EAAekN,EAAM1c,MAT0C4iB,CAAoBpT,EAAekN,MAC5J+F,EAA6BpqB,QAC7BsoB,EAAU1I,OAAO,EAAuCwK,GC7KzD,SAASI,GAAuBjb,EAAWkb,EAAOC,GACrD,IAAIC,EAAa,EACbC,GAAiB,EACrB,MAAO,CACHC,eAAgB,WAOZ,GANmB,IAAfF,GACA5nB,YAAW,WACP4nB,EAAa,IACd1oB,IAEP0oB,GAAc,IACIF,GAASG,EAEvB,OADAA,GAAiB,GACV,EAEX,GAAID,IAAeF,EAAQ,EAAG,CAC1BG,GAAiB,EACjB,IACIF,EAAe,CACX5Y,QAAS,yBAAyBxQ,OAAOiO,EAAW,iBAAiBjO,OAAOmpB,GAC5EpnB,OAAQ6O,GACRK,YAAanF,OAGrB,QACIwd,GAAiB,GAGzB,OAAO,ICTnB,SAAS/jB,GAAIrD,EAAQ8R,GAEjB,IADA,IAAIwV,EAAUtnB,EACL1D,EAAK,EAAGqF,EAAKmQ,EAAK5E,MAAM,KAAM5Q,EAAKqF,EAAGnF,OAAQF,IAAM,CACzD,IAAIirB,EAAQ5lB,EAAGrF,GACf,IAAKkrB,GAAwBF,EAASC,GAClC,OAEJD,EAAUA,EAAQC,GAEtB,OAAOD,EAEX,SAASxf,GAAI9H,EAAQ8R,EAAM9Q,GAGvB,IAFA,IAAIsmB,EAAUtnB,EACVynB,EAAS3V,EAAK5E,MAAM,KACfxP,EAAI,EAAGA,EAAI+pB,EAAOjrB,OAAQkB,GAAK,EAAG,CACvC,IAAI6pB,EAAQE,EAAO/pB,GACnB,IAAK8pB,GAAwBF,EAASC,GAClC,OAEA7pB,IAAM+pB,EAAOjrB,OAAS,EACtB8qB,EAAUA,EAAQC,GAGlBD,EAAQC,GAASvmB,GAI7B,SAASwmB,GAAwBxnB,EAAQunB,GACrC,MAAyB,kBAAXvnB,GAAkC,OAAXA,GAAmBvD,OAAOC,UAAUC,eAAeC,KAAKoD,EAAQunB,GCjDlG,SAASG,KACZ,IAAIC,E/BKD,WACH,IAAI3mB,EAAQ0C,OAAOkkB,+BAAiCzc,GAPZ,gCAQxC,MAAwB,kBAAVnK,EAAqBA,OAAQhC,E+BP9B6oB,GACTC,E/BQD,WACH,IAAI9mB,EAAQ0C,OAAOqkB,+BAAiC5c,GAVV,gCAW1C,MAAwB,kBAAVnK,EAAqBA,OAAQhC,E+BV5BgpB,GACf,GAAIL,GAAUG,EACV,MAAO,CACHG,QAASN,EACTO,UAAWJ,EACXK,SAAU7c,MLNf,SAAS8c,KAIZ,OAHK/E,KACDA,GAID,WACH,IAAI1G,EAAa,IAAIhB,IAAW,WAC5B,IAAI0M,EAAkB3pB,EAASR,GAAQ,WACnCye,EAAWP,OAAOkM,SAClB,KAAKjpB,UACT,OAAO6d,GAAiBxZ,OAAQ,SAAuB2kB,EAAiB,CAAE7K,SAAS,EAAMC,SAAS,IAAQE,QAE9G,OAAOhB,EAXkB4L,IAElBlF,GAYJ,SAASiF,KACZ,IAAIE,EAAS9kB,OAAO+kB,eACpB,OAAID,EACO,CACHE,MAAOrE,OAAOmE,EAAOE,MAAQF,EAAOG,OACpCC,OAAQvE,OAAOmE,EAAOI,OAASJ,EAAOG,QAGvC,CACHD,MAAOrE,OAAO3gB,OAAOmlB,YAAc,GACnCD,OAAQvE,OAAO3gB,OAAOolB,aAAe,ICxBtC,SAASC,KACZ,GAAKxc,GAA6B,YASlC,OANK+W,KACDA,GAAWgF,KACKF,KAAyBtM,WAAU,SAAUkN,GACzD1F,GAAW0F,KACZ9M,aAEA,CACHoH,SAAUA,IKXlB,IAAI2F,GAAqC,CAErC,WACA,gBACA,qBACA,gBACA,cACA,qBACA,gBAEAC,GAAsCD,GAAmCnrB,OAAO,CAEhF,YAEG,SAASqrB,GAAiBxV,EAAemR,EAAWvN,EAAgB6R,EAAcC,EAAaC,EAAgBpO,EAAoBqO,GACtI,IAAI5nB,EACA6nB,IAAqB7nB,EAAK,IACJ,MAAIqlB,GAAuB,QAAqBrT,EAAcwC,0BAA2BoT,GAC/G5nB,EAAwB,OAAIqlB,GAAuB,SAAuBrT,EAAcwC,0BAA2BoT,GACnH5nB,GACA8nB,EAAoB/B,KACpBgC,ECzBD,WACH,IAAI/nB,EACAgoB,EAA4C,QAAzBhoB,EAAK+B,OAAOkmB,eAA4B,IAAPjoB,OAAgB,EAASA,EAAGiS,IAAI,WACxF,GAA+B,kBAApB+V,EACP,MAAO,CACHE,kBAAmBF,GDoBPG,GACpBhF,EAAUhJ,UAAU,IAAkC,SAAUna,GAC5D,IA0E0BqK,EA1EtB8U,EAAYnf,EAAGmf,UAAWiJ,EAAcpoB,EAAGooB,YAAaC,EAAgBroB,EAAGqoB,cAAeC,EAAqBtoB,EAAGsoB,mBAAoBC,EAAkBvoB,EAAGuoB,gBAC3JC,EAAcf,EAAagB,SAAStJ,GACpCuJ,EAAahB,EAAYiB,QAAQxJ,GAIjCyJ,EAAUhT,EAAeG,mBAAwC,SAArBqS,EAAY3a,KAA6B0R,OAAY9hB,GACrG,GAAIurB,GAAWJ,GAAeE,EAAY,CACtC,IAAIG,EAAgBP,GAAsB/O,IACtCuP,EAAWnB,EAAeoB,aAAa5J,GAgCvC6J,EAAiBxkB,EA/BJ,CACbuY,IAAK,CACDC,eAAgB,EAChBiM,MlC3BTxqB,KAAKM,MAAMwI,IAAYI,GAAYD,KAAsBF,YAAYC,QkC4B5DmhB,QAAS,CACLM,KAAMN,EAAQM,MAElBC,oBAAqB7e,KAAsB,cAAWjN,GAE1D+rB,YAAa,CACTC,GAAIrX,EAAcgB,eAEtBlK,KAAMf,IACNmK,QAASsW,EAAYtW,SAAWF,EAAcE,QAC9CC,QAASqW,EAAYrW,SAAWH,EAAcG,QAC9CjU,OAAQ,UACR0qB,QAAS,CACLS,GAAIT,EAAQS,GACZ5b,KAAMqa,EAAoB,aAAgCC,EAAgB,UAA0B,QAExGuB,KAAM,CACFD,GAAIb,EAAYa,GAChB7mB,KAAMgmB,EAAYhmB,KAClB0J,IAAKwc,EAAWxc,IAChBqd,SAAUb,EAAWa,UAEzBC,QAsCkBnf,EAtCe+d,GAuCiE,IAAvG,CAAC,QAAqB,WAA2B,aAA6B9nB,QAAQ+J,EAAMoD,OAvCtCqb,EAAW,CAAEO,GAAIP,QAAazrB,GAC/EosB,WAAY3B,EACZ4B,QAAS3B,EACTvtB,QAAS4sB,MAE4BgB,GACzCY,EAAetsB,QAAU8H,EAAQqkB,EAAcnsB,QAAS6rB,GAClD,eAAgBS,EAAeJ,UAEjCI,EAAeJ,QAAQe,WAAad,EAAclP,WAEjDtY,EAAcwnB,EAAcva,QAE7B0a,EAAeY,IAAMf,EAAcva,MAWnD,SAAoBjE,EAAO8J,EAAYkU,EAAeR,GAClD,IAAI7nB,EACJ,GAAImU,EAAY,CACZ,IAAIvG,EFrFL,SAA2BvP,EAAQwrB,EAAsBC,GAC5D,IAAIC,EAAQxlB,EAAUlG,GAClBuP,EAASkc,EAASC,GAatB,OAZAF,EAAqB5rB,SAAQ,SAAUkS,GACnC,IAAI6Z,EAAgBtoB,GAAIrD,EAAQ8R,GAC5B8Z,EAAWvoB,GAAIqoB,EAAO5Z,GACtB+Z,EAAejnB,EAAQ+mB,GACvBG,EAAUlnB,EAAQgnB,GAClBE,IAAYD,EACZ/jB,GAAI9H,EAAQ8R,EAAM8Z,GAEI,WAAjBC,GAA0C,cAAZC,GAAuC,SAAZA,GAC9DhkB,GAAI9H,EAAQ8R,EAAM,OAGnBvC,EEsEUwc,CAAkB/f,EAAsB,SAAfA,EAAMoD,KAA6B6Z,GAAqCC,IAAqC,SAAUld,GAAS,OAAO8J,EAAW9J,EAAOge,MAC/L,IAAe,IAAXza,GAAmC,SAAfvD,EAAMoD,KAC1B,OAAO,GAEI,IAAXG,GACApT,EAAQF,KAAK,+CAIrB,QADgE,QAAxC0F,EAAK6nB,EAAkBxd,EAAMoD,aAA0B,IAAPzN,OAAgB,EAASA,EAAG0lB,kBApBxF2E,CAAWrB,EAAgBhX,EAAcmC,WAAYkU,EAAeR,KAChExmB,EAAc2nB,EAAetsB,iBACtBssB,EAAetsB,QAE1BymB,EAAU1I,OAAO,GAA8BuO,QEhFxD,IAGHsB,GAAoB,GACjB,SAASC,KACRjhB,SAASkhB,YACTC,KAEJ,IAoCgBC,EAQDC,EA5CXC,GAoCYF,EApCwBD,GAqCjClP,GAAiBxZ,OAAQ,SAAqB,SAAUsI,GACtDA,EAAMwgB,WAGXH,QAzC4D1O,KAC5D8O,GA2CWH,EA3CkBI,GA4C1BxP,GAAiBxZ,OAAQ,QAAmB,SAAUsI,GACpDA,EAAMwgB,WAGXF,QAhDoD3O,KACxD,MAAO,CACHgP,iBAAkBA,GAClBC,6BAA8BA,GAC9BjP,KAAM,WACFsO,GAAoB,GACpBM,IACAE,MAIL,SAASL,KACZ,KAAIH,GAAkBzvB,OAnB2B,MAmBjD,CAGA,IAAIqwB,EAA0BZ,GAAkBA,GAAkBzvB,OAAS,GACvE4M,EAAMO,UACsB3K,IAA5B6tB,QAAyE7tB,IAAhC6tB,EAAwB7iB,KAGrEiiB,GAAkB1pB,KAAK,CACnBwH,MAAOX,KAGR,SAASsjB,KACZ,GAAiC,IAA7BT,GAAkBzvB,OAAtB,CAGA,IAAIqwB,EAA0BZ,GAAkBA,GAAkBzvB,OAAS,GACvE4M,EAAMO,UAC0B3K,IAAhC6tB,EAAwB7iB,MAG5B6iB,EAAwB7iB,IAAMZ,IAkBlC,SAASujB,GAAiB7L,GACtB,IAAK,IAAIpjB,EAAIuuB,GAAkBzvB,OAAS,EAAGkB,GAAK,EAAGA,IAAK,CACpD,IAAIovB,EAAmBb,GAAkBvuB,GACzC,QAA6BsB,IAAzB8tB,EAAiB9iB,KAAqB8W,EAAYgM,EAAiB9iB,IACnE,MAEJ,GAAI8W,EAAYgM,EAAiB/iB,aACH/K,IAAzB8tB,EAAiB9iB,KAAqB8W,EAAYgM,EAAiB9iB,KACpE,OAAO,EAGf,OAAO,EAEX,SAAS4iB,GAA6BG,EAAgBtjB,GAIlD,IAHA,IAAIujB,EAAe1jB,GAAYyjB,EAAgBtjB,GAC3CwjB,EAA4B,GAC5BC,EAAgB9sB,KAAK+sB,IAAI,EAAGlB,GAAkBzvB,OA5EG,KA6E5CkB,EAAIuuB,GAAkBzvB,OAAS,EAAGkB,GAAKwvB,EAAexvB,IAAK,CAChE,IAAIovB,EAAmBb,GAAkBvuB,GACzC,QAA6BsB,IAAzB8tB,EAAiB9iB,KAAqB+iB,EAAiBD,EAAiB9iB,IAGxE,MAEJ,KAAIgjB,EAAeF,EAAiB/iB,OAApC,CAKA,IAAI+W,EAAYiM,EAAiBD,EAAiB/iB,MAAQgjB,EAAiBD,EAAiB/iB,MACxFqjB,EAAgBtjB,GAAQijB,EAAgBjM,GAExCuM,EAAcvjB,GAAQgX,OADa9hB,IAAzB8tB,EAAiB9iB,KAAqBgjB,EAAeF,EAAiB9iB,IAAMgjB,EAAeF,EAAiB9iB,KAE1HijB,EAA0BK,QAAQ,CAC9BvjB,MAAOP,EAAiB4jB,GACxB3jB,SAAUD,EAAiB6jB,MAGnC,OAAOJ,ECpGX,ICMIM,GDNAC,GAA2B,WAC3B,SAASA,IACLpvB,KAAKqvB,UAAY,GAoBrB,OAlBAD,EAAU9wB,UAAU0f,OAAS,SAAUrQ,EAAWsQ,GAC9C,IAAIqR,EAAiBtvB,KAAKqvB,UAAU1hB,GAChC2hB,GACAA,EAAe9tB,SAAQ,SAAU6I,GAAY,OAAOA,EAAS4T,OAGrEmR,EAAU9wB,UAAUof,UAAY,SAAU/P,EAAWtD,GACjD,IAAIuT,EAAQ5d,KAKZ,OAJKA,KAAKqvB,UAAU1hB,KAChB3N,KAAKqvB,UAAU1hB,GAAa,IAEhC3N,KAAKqvB,UAAU1hB,GAAWxJ,KAAKkG,GACxB,CACHyT,YAAa,WACTF,EAAMyR,UAAU1hB,GAAaiQ,EAAMyR,UAAU1hB,GAAW6J,QAAO,SAAUuG,GAAS,OAAO1T,IAAa0T,QAI3GqR,EAtBmB,GECnBG,GAAyB,MACzBC,GAA2B,ICAlCC,GAAeC,EAAAA,EAMfC,GAAgC,WAChC,SAASA,EAAevjB,GACpB,IAAIwR,EAAQ5d,KACZA,KAAKoM,YAAcA,EACnBpM,KAAKmnB,QAAU,GACfnnB,KAAK4vB,yBAA2BC,aAAY,WAAc,OAAOjS,EAAMkS,qBAVtCzvB,KAyFrC,OAzEAsvB,EAAerxB,UAAU2I,IAAM,SAAUhH,EAASyiB,GAC9C,IAAI9E,EAAQ5d,KACRyiB,EAAQ,CACRxiB,QAASA,EACTyiB,UAAWA,EACXqN,QAASN,GACThmB,OAAQ,WACJ,IAAIumB,EAAQpS,EAAMuJ,QAAQtjB,QAAQ4e,GAC9BuN,GAAS,GACTpS,EAAMuJ,QAAQ7c,OAAO0lB,EAAO,IAGpCC,MAAO,SAAUF,GACbtN,EAAMsN,QAAUA,IAIxB,OADA/vB,KAAKmnB,QAAQ+H,QAAQzM,GACdA,GAMXkN,EAAerxB,UAAU8F,KAAO,SAAUse,QACpB,IAAdA,IAAwBA,EAAY+M,IACxC,IAAK,IAAIvxB,EAAK,EAAGqF,EAAKvD,KAAKmnB,QAASjpB,EAAKqF,EAAGnF,OAAQF,IAAM,CACtD,IAAIukB,EAAQlf,EAAGrF,GACf,GAAIukB,EAAMC,WAAaA,EAAW,CAC9B,GAAIA,GAAaD,EAAMsN,QACnB,OAAOtN,EAAMxiB,QAEjB,SAQZ0vB,EAAerxB,UAAU4xB,YAAc,SAAUH,GAC7C,IAAII,EAAcnwB,KAAKmnB,QAAQ,GAC3BgJ,GAAeA,EAAYJ,UAAYN,IACvCU,EAAYF,MAAMF,IAO1BJ,EAAerxB,UAAU8xB,QAAU,SAAU1N,GAEzC,YADkB,IAAdA,IAAwBA,EAAY+M,IACjCzvB,KAAKmnB,QACP3P,QAAO,SAAUiL,GAAS,OAAOA,EAAMC,WAAaA,GAAaA,GAAaD,EAAMsN,WACpFrrB,KAAI,SAAU+d,GAAS,OAAOA,EAAMxiB,YAK7C0vB,EAAerxB,UAAU+xB,MAAQ,WAC7BrwB,KAAKmnB,QAAU,IAKnBwI,EAAerxB,UAAUihB,KAAO,WAC5B+Q,cAActwB,KAAK4vB,2BAEvBD,EAAerxB,UAAUwxB,iBAAmB,WAExC,IADA,IAAIS,EAAmBhlB,KAAgBvL,KAAKoM,YACrCpM,KAAKmnB,QAAQ/oB,OAAS,GAAK4B,KAAKmnB,QAAQnnB,KAAKmnB,QAAQ/oB,OAAS,GAAG2xB,QAAUQ,GAC9EvwB,KAAKmnB,QAAQhT,OAGdwb,EApFwB,GCN5B,SAASa,GAAiB5uB,EAAQ6uB,EAAQC,GAC7C,IAAIhS,EAAW9c,EAAO6uB,GAClBE,EAAkBD,EAAuBhS,GACzCkS,EAAyB,WACzB,GAA+B,oBAApBD,EAIX,OAAOA,EAAgBlyB,MAAMuB,KAAM7B,YAGvC,OADAyD,EAAO6uB,GAAUG,EACV,CACHrR,KAAM,WACE3d,EAAO6uB,KAAYG,EACnBhvB,EAAO6uB,GAAU/R,EAGjBiS,EAAkBjS,IAK3B,SAASmS,GAAgCjvB,EAAQ6uB,EAAQltB,GAC5D,IAAIutB,EAASvtB,EAAGutB,OAAQC,EAAQxtB,EAAGwtB,MACnC,OAAOP,GAAiB5uB,EAAQ6uB,GAAQ,SAAU/R,GAC9C,OAAO,WACH,IACIvN,EADAlT,EAAOE,UAaX,OAXI2yB,GACA/wB,EAAc+wB,EAAQ9wB,KAAM/B,GAER,oBAAbygB,IAEPvN,EAASuN,EAASjgB,MAAMuB,KAAM/B,IAE9B8yB,GACAhxB,EAAcgxB,EAAO/wB,KAAM/B,GAGxBkT,MAIZ,SAAS6f,GAAiBpvB,EAAQmI,EAAUgnB,GAC/C,IAAIE,EAAqB5yB,OAAO6yB,yBAAyBtvB,EAAQmI,GACjE,IAAKknB,IAAuBA,EAAmBvnB,MAAQunB,EAAmB/rB,aACtE,MAAO,CAAEqa,KAAM7c,GAEnB,IAAIiuB,EAAkB,SAAUQ,EAAYvuB,GAExCzB,WAAWrB,GAAQ,WACfixB,EAAMI,EAAYvuB,MAClB,IAEJguB,EAAyB,SAAUhuB,GACnCquB,EAAmBvnB,IAAIlL,KAAKwB,KAAM4C,GAClC+tB,EAAgB3wB,KAAM4C,IAK1B,OAHAvE,OAAO2G,eAAepD,EAAQmI,EAAU,CACpCL,IAAKknB,IAEF,CACHrR,KAAM,WACF,IAAIhc,GAC8D,QAA5DA,EAAKlF,OAAO6yB,yBAAyBtvB,EAAQmI,UAA8B,IAAPxG,OAAgB,EAASA,EAAGmG,OAASknB,EAC3GvyB,OAAO2G,eAAepD,EAAQmI,EAAUknB,GAGxCN,EAAkBjuB,IH/DlC,IIFI0uB,GJEAC,GAAc,IAAIC,QACf,SAASC,KAIZ,OAHKpC,KACDA,GAIR,WACI,IAAI5Q,EAAa,IAAIhB,IAAW,WAC5B,IAAIiU,EAAyBX,GAAgCY,eAAenzB,UAAW,OAAQ,CAC3FwyB,OAAQY,KACTnS,KACCoS,EAAwBd,GAAgCY,eAAenzB,UAAW,OAAQ,CAC1FwyB,OAAQ,WACJc,GAAQpzB,KAAKwB,KAAMue,MAExBgB,KACCsS,EAAyBhB,GAAgCY,eAAenzB,UAAW,QAAS,CAC5FwyB,OAAQgB,KACTvS,KACH,OAAO,WACHiS,IACAG,IACAE,QAGR,OAAOtT,EAvBawT,IAEb5C,GAuBX,SAASuC,GAAQjB,EAAQhhB,GACrB4hB,GAAY3nB,IAAI1J,KAAM,CAClBgyB,MAAO,OACPvB,OAAQA,EACRhhB,IAAKqC,GAAajD,OAAOY,MAGjC,SAASmiB,GAAQrT,GACb,IAAIX,EAAQ5d,KACRC,EAAUoxB,GAAYpsB,IAAIjF,MAC9B,GAAKC,EAAL,CAGA,IAAIgyB,EAAehyB,EACnBgyB,EAAaD,MAAQ,QACrBC,EAAavP,UAAYnX,KACzB0mB,EAAathB,YAAcnF,KAC3BymB,EAAanZ,WAAY,EACzBmZ,EAAaC,IAAMlyB,KACnB,IAAImyB,GAAkB,EAClBC,EAAsCvB,GAAgC7wB,KAAM,qBAAsB,CAClG8wB,OAAQ,WACA9wB,KAAK2hB,aAAe8P,eAAeY,MAKnCC,OAGT/S,KACC+S,EAAQxyB,GAAQ,WAGhB,GAFA8d,EAAM2U,oBAAoB,UAAWD,GACrCF,KACID,EAAJ,CAGAA,GAAkB,EAClB,IAAIK,EAAkBvyB,EACtBuyB,EAAgBR,MAAQ,WACxBQ,EAAgBnnB,SAAWK,GAAQumB,EAAathB,YAAYjG,UAAWY,KACvEknB,EAAgB3Z,OAAS+E,EAAM/E,OAC/B0F,EAAWP,OAAOrc,EAAa6wB,QAEnCxyB,KAAK8e,iBAAiB,UAAWwT,GACjC/T,EAAWP,OAAOiU,IAEtB,SAASH,KACL,IAAI7xB,EAAUoxB,GAAYpsB,IAAIjF,MAC1BC,IACAA,EAAQ6Y,WAAY,GI/ErB,SAAS2Z,KAIZ,OAHKrB,KACDA,GAIR,WACI,IAAI7S,EAAa,IAAIhB,IAAW,WAC5B,GAAKjY,OAAOotB,MAiBZ,OAdWlC,GAAiBlrB,OAAQ,SAAS,SAAUqtB,GACnD,OAAO,SAAUC,EAAOC,GACpB,IAAIC,EACA7yB,EAAUF,EAAc2X,GAAY,KAAM,CAAC6G,EAAYqU,EAAOC,IAQlE,OAPI5yB,GACA6yB,EAAkBH,EAAcn0B,KAAKwB,KAAMC,EAAQ2yB,MAAO3yB,EAAQ4yB,MAClE9yB,EAAcgzB,GAAW,KAAM,CAACxU,EAAYuU,EAAiB7yB,KAG7D6yB,EAAkBH,EAAcn0B,KAAKwB,KAAM4yB,EAAOC,GAE/CC,MAEZvT,QAGP,OAAOhB,EAzBeyU,IAEf5B,GAyBX,SAAS1Z,GAAW6G,EAAYqU,EAAOC,GACnC,IAAIpC,EAAUoC,GAAQA,EAAKpC,QAA6B,kBAAVmC,GAAsBA,EAAMnC,QAAW,MACjFhhB,EAAMqC,GAA+B,kBAAV8gB,GAAsBA,EAAMnjB,KAAQmjB,GAE/D3yB,EAAU,CACV+xB,MAAO,QACPa,KAAMA,EACND,MAAOA,EACPnC,OAAQA,EACR9f,YANcnF,KAOdiE,IAAKA,GAGT,OADA8O,EAAWP,OAAO/d,GACXA,EAEX,SAAS8yB,GAAUxU,EAAYuU,EAAiBb,GAC5C,IAAIgB,EAAc,SAAUC,GACxB,IAAIjzB,EAAUgyB,EACdhyB,EAAQ+xB,MAAQ,UACZ,UAAWkB,GAAYA,aAAoBpiB,OAC3C7Q,EAAQ4Y,OAAS,EACjB5Y,EAAQ6Y,UAAYoa,aAAoBC,cAAgBD,EAASE,OAASD,aAAaE,UACvFpzB,EAAQnC,MAAQo1B,GAEX,WAAYA,IACjBjzB,EAAQizB,SAAWA,EACnBjzB,EAAQqzB,aAAeJ,EAASliB,KAChC/Q,EAAQ4Y,OAASqa,EAASra,OAC1B5Y,EAAQ6Y,WAAY,GAExByF,EAAWP,OAAO/d,IAEtB6yB,EAAgBS,KAAKzzB,EAAQmzB,GAAcnzB,EAAQmzB,IChEvD,IAAIO,GAAmB,EAChB,SAASC,GAAuB/M,EAAWnR,EAAe4D,GAC7D,IAAIua,E7B0BD,SAAqBne,EAAe4D,GACvC,MAAO,CACHP,qBAAsBA,GACtB+a,WAAY,SAAU1zB,GAClB,OAAOiZ,GAA8B3D,EAAetV,EAASkZ,GAAgB,SAAUU,GACnF,IAAItW,EACJ,GAAItD,EAAQ2yB,iBAAiBgB,WAAqC,QAAvBrwB,EAAKtD,EAAQ4yB,YAAyB,IAAPtvB,OAAgB,EAASA,EAAGswB,SAClG5zB,EAAQ2yB,MAAQ,IAAIgB,QAAQ3zB,EAAQ2yB,OACpCv0B,OAAOoG,KAAKoV,GAAgBrY,SAAQ,SAAUE,GAE1CzB,EAAQ2yB,MAAMiB,QAAQC,OAAOpyB,EAAKmY,EAAenY,WAGpD,CACDzB,EAAQ4yB,KAAOlxB,EAAa1B,EAAQ4yB,MACpC,IAAIkB,EAAY,GACZ9zB,EAAQ4yB,KAAKgB,mBAAmBG,QAChC/zB,EAAQ4yB,KAAKgB,QAAQryB,SAAQ,SAAUoB,EAAOlB,GAC1CqyB,EAAU5vB,KAAK,CAACzC,EAAKkB,OAGpBpD,MAAMiH,QAAQxG,EAAQ4yB,KAAKgB,SAChC5zB,EAAQ4yB,KAAKgB,QAAQryB,SAAQ,SAAUyyB,GACnCF,EAAU5vB,KAAK8vB,MAGdh0B,EAAQ4yB,KAAKgB,SAClBx1B,OAAOoG,KAAKxE,EAAQ4yB,KAAKgB,SAASryB,SAAQ,SAAUE,GAChDqyB,EAAU5vB,KAAK,CAACzC,EAAKzB,EAAQ4yB,KAAKgB,QAAQnyB,QAGlDzB,EAAQ4yB,KAAKgB,QAAUE,EAAUr0B,OAAOiF,EAAckV,SAIlEqa,SAAU,SAAUj0B,EAASiyB,GACzB,OAAOhZ,GAA8B3D,EAAetV,EAASkZ,GAAgB,SAAUU,GACnFxb,OAAOoG,KAAKoV,GAAgBrY,SAAQ,SAAUuE,GAC1CmsB,EAAIiC,iBAAiBpuB,EAAM8T,EAAe9T,Y6BhE7CquB,CAAY7e,EAAe4D,IAIrC,SAAkBuN,EAAWnR,EAAeme,GAC/C,IAAIlV,EAAe+S,KAAoB7T,WAAU,SAAU2W,GACvD,IAAIp0B,EAAUo0B,EACd,GAAKjQ,GAAoB7O,EAAetV,EAAQwP,KAGhD,OAAQxP,EAAQ+xB,OACZ,IAAK,QACD0B,EAAOQ,SAASj0B,EAASA,EAAQiyB,KACjCjyB,EAAQq0B,aAAeC,KACvB7N,EAAU1I,OAAO,EAAyB,CACtCsW,aAAcr0B,EAAQq0B,aACtB7kB,IAAKxP,EAAQwP,MAEjB,MACJ,IAAK,WACDikB,EAAO9a,qBAAqB3Y,GAC5BymB,EAAU1I,OAAO,EAA2B,CACxC3S,SAAUpL,EAAQoL,SAClBolB,OAAQxwB,EAAQwwB,OAChB6D,aAAcr0B,EAAQq0B,aACtBtb,OAAQ/Y,EAAQ+Y,OAChBrI,YAAa1Q,EAAQ0Q,YACrBkI,OAAQ5Y,EAAQ4Y,OAChBE,QAAS9Y,EAAQ8Y,QACjBE,aAAchZ,EAAQgZ,aACtBjI,KAAM,MACNvB,IAAKxP,EAAQwP,IACbyiB,IAAKjyB,EAAQiyB,UA/B7BsC,CAAS9N,EAAWnR,EAAeme,GAsChC,SAAoBhN,EAAWnR,EAAeme,GACjD,IAAIlV,EAAeiU,KAAsB/U,WAAU,SAAU2W,GACzD,IAAIp0B,EAAUo0B,EACd,GAAKjQ,GAAoB7O,EAAetV,EAAQwP,KAGhD,OAAQxP,EAAQ+xB,OACZ,IAAK,QACD0B,EAAOC,WAAW1zB,GAClBA,EAAQq0B,aAAeC,KACvB7N,EAAU1I,OAAO,EAAyB,CACtCsW,aAAcr0B,EAAQq0B,aACtB7kB,IAAKxP,EAAQwP,MAEjB,MACJ,IAAK,WA8BjB,SAAmCxP,EAASoK,GACxC,IAAIoqB,EAAiBx0B,EAAQizB,U9C6W1B,SAAoBA,GACvB,IACI,OAAOA,EAAS5F,QAEpB,MAAOptB,GAEH,Q8CnXqCw0B,CAAWz0B,EAAQizB,UACvDuB,GAAmBA,EAAe5hB,KCpFpC,SAA6B8hB,EAAQtqB,EAAU7J,GAClD,IAAIo0B,EAASD,EAAOE,YAChBC,EAAS,GACTC,EAAiB,EAoBrB,SAASC,IAKL,IAAIC,EACAC,EACJ,GANAN,EAAOxzB,SAAS+zB,MAGhBzyB,GAGIlC,EAAQ40B,kBAAmB,CAC3B,IAAIC,EACJ,GAAsB,IAAlBP,EAAO12B,OAGPi3B,EAAmBP,EAAO,OAEzB,CAEDO,EAAmB,IAAI/a,WAAWya,GAClC,IAAIO,EAAW,EACfR,EAAOtzB,SAAQ,SAAU+zB,GACrBF,EAAiB3rB,IAAI6rB,EAAOD,GAC5BA,GAAYC,EAAMn3B,UAG1B62B,EAAQI,EAAiB51B,MAAM,EAAGe,EAAQg1B,YAC1CN,EAAgBG,EAAiBj3B,OAASoC,EAAQg1B,WAEtDnrB,OAASzJ,EAAWq0B,EAAOC,IA5C/B,SAASO,IACLb,EAAOc,OAAOnC,KAAKzzB,GAAQ,SAAUqR,GAC7BA,EAAOwkB,KACPX,KAGAx0B,EAAQ40B,mBACRN,EAAO3wB,KAAKgN,EAAOvO,QAEvBmyB,GAAkB5jB,EAAOvO,MAAMxE,QACVoC,EAAQg1B,WACzBR,IAGAS,QAEJ31B,GAAQ,SAAUhC,GAAS,OAAOuM,EAASvM,OAjBnD23B,GDqFIG,CAAoBnB,EAAe5hB,MAAM,WACrCxI,EAASqB,GAAQzL,EAAQ0Q,YAAYjG,UAAWY,QACjD,CACCkqB,WAAYvP,OAAO4P,kBACnBT,mBAAmB,IAPvB/qB,EAASqB,GAAQzL,EAAQ0Q,YAAYjG,UAAWY,MAjCxCwqB,CAA0B71B,GAAS,SAAUoL,GACzCqoB,EAAO9a,qBAAqB3Y,GAC5BymB,EAAU1I,OAAO,EAA2B,CACxC3S,SAAUA,EACVolB,OAAQxwB,EAAQwwB,OAChB6D,aAAcr0B,EAAQq0B,aACtBhB,aAAcrzB,EAAQqzB,aACtBta,OAAQ/Y,EAAQ+Y,OAChBrI,YAAa1Q,EAAQ0Q,YACrBkI,OAAQ5Y,EAAQ4Y,OAChBE,QAAS9Y,EAAQ8Y,QACjBE,aAAchZ,EAAQgZ,aACtBjI,KAAM,QACNvB,IAAKxP,EAAQwP,IACbyjB,SAAUjzB,EAAQizB,SAClBL,KAAM5yB,EAAQ4yB,KACdD,MAAO3yB,EAAQ2yB,eArEnCmD,CAAWrP,EAAWnR,EAAeme,GA6EzC,SAASa,KACL,IAAIpjB,EAASqiB,GAEb,OADAA,IAAoB,EACbriB,EEtFJ,SAAS6kB,GAAiBzyB,GAC7B,IAAImjB,EAAYnjB,EAAGmjB,UAAWuP,EAAe1yB,EAAG0yB,aAAcjf,EAAKzT,EAAG2yB,SAAU7rB,OAAkB,IAAP2M,EAAgBtU,EAAOsU,EAC9Gmf,EAAc,CACdC,WAAY,EACZC,cAAe,EACfC,cAAe,EACfC,YAAa,EACbC,iBAAkB,GAElBhY,EAAekI,EAAUhJ,UAAU,IAA8B,SAAU9P,GAC3E,GAAmB,SAAfA,EAAMoD,MAAoBilB,EAAaroB,GAG3C,OAAQA,EAAMoD,MACV,IAAK,QACDmlB,EAAYC,YAAc,EAC1B/rB,IACA,MACJ,IAAK,SACD8rB,EAAYI,aAAe,EACvB3oB,EAAMmf,OAAO0J,cACbN,EAAYK,kBAAoB5oB,EAAMmf,OAAO0J,YAAYzlB,KAAK5S,QAElEiM,IACA,MACJ,IAAK,YACD8rB,EAAYE,eAAiB,EAC7BhsB,IACA,MACJ,IAAK,WACD8rB,EAAYG,eAAiB,EAC7BjsB,QAIZ,MAAO,CACHkV,KAAM,WACFf,EAAaV,eAEjBqY,YAAaA,GCtCd,IAAIO,GAAiC,IAiCrC,SAASC,GAAoBjQ,EAAWkQ,EAAuBrhB,EAAeshB,EAAyBC,GAC1G,IAAIC,EAkCD,SAAsCrQ,EAAWkQ,EAAuBrhB,GAC3E,IAAIgJ,EAAa,IAAIhB,IAAW,WAC5B,IACIyZ,EADA1Y,EAAgB,GAEhB2Y,EAAuB,EAC3B3Y,EAAcna,KAAKyyB,EAAsBlZ,UAAUwZ,GAAqBxQ,EAAUhJ,UAAU,GAAuC,SAAUyJ,GACrIA,EAAQ5e,MAAK,SAAUka,GAAS,MAA2B,aAApBA,EAAM6D,YAA6B6Q,GAAc5hB,EAAekN,EAAM1c,UAC7GmxB,OAEJxQ,EAAUhJ,UAAU,GAAyB,SAAU0Z,GACnDD,GAAc5hB,EAAe6hB,EAAW3nB,YAGlB7O,IAAtBo2B,IACAA,EAAoBI,EAAW9C,cAEnC2C,GAAwB,EACxBC,QACAxQ,EAAUhJ,UAAU,GAA2B,SAAU2Z,GACrDF,GAAc5hB,EAAe8hB,EAAQ5nB,WACf7O,IAAtBo2B,GAEAK,EAAQ/C,aAAe0C,IAG3BC,GAAwB,EACxBC,SAEJ,IAciB7sB,EAdbitB,GAcajtB,EAd4B6sB,EAe1CrG,GAAgCvrB,OAAQ,OAAQ,CAAEwrB,OAAQzmB,KAfIkV,KACjE,OAAO,WACH+X,IACAhZ,EAAc9c,SAAQ,SAAU+1B,GAAK,OAAOA,EAAEzZ,kBAElD,SAASoZ,IACL3Y,EAAWP,OAAO,CAAEwZ,OAAQP,EAAuB,QAG3D,OAAO1Y,EAvEsBkZ,CAA6B/Q,EAAWkQ,EAAuBrhB,GAC5F,OAEG,SAA+BwhB,EAAwBF,EAAyBC,GACnF,IAAIY,EACAC,GAAe,EACfC,EAAsBz2B,WAAWrB,GAAQ,WAAc,OAAO+3B,EAAS,CAAEC,aAAa,OAxClD,KAyCpCC,EAAuBjB,GACvB31B,WAAWrB,GAAQ,WAAc,OAAO+3B,EAAS,CAAEC,aAAa,EAAMlsB,IAAKN,SAAuBwrB,GAClGkB,EAA2BjB,EAAuBrZ,WAAU,SAAUna,GACtE,IAAIi0B,EAASj0B,EAAGi0B,OAChBn2B,aAAau2B,GACbv2B,aAAaq2B,GACb,IAAIO,EAAiB3sB,IAChBksB,IACDE,EAA2Bv2B,WAAWrB,GAAQ,WAAc,OAAO+3B,EAAS,CAAEC,aAAa,EAAMlsB,IAAKqsB,OA/C7E,SAkD7B1Y,EAAO,WACPoY,GAAe,EACft2B,aAAau2B,GACbv2B,aAAaq2B,GACbr2B,aAAa02B,GACbC,EAAyBla,eAE7B,SAAS+Z,EAASjqB,GACV+pB,IAGJpY,IACAsX,EAAwBjpB,IAE5B,MAAO,CAAE2R,KAAMA,GA/BR2Y,CAAsBnB,EAAwBF,EAAyBC,GAwElF,SAASK,GAAc5hB,EAAe4iB,GAClC,OAAO/vB,EAAUmN,EAAcgG,qBAAsB4c,GC7GlD,IAAIC,GAA8Bh4B,EAElC,SAASi4B,GAAiBC,EAAYC,GACzC,IAEIC,EAFAC,EAAiB,GACjB5f,EAAS,EAGb,SAAS6f,EAAYC,GACjBA,EAAMC,eAAelb,UAAUmb,GAC/BJ,EAAet0B,KAAKw0B,GACpBt3B,aAAam3B,GACbA,EAAkCr3B,WAAWrB,EAAQg5B,GAXpB14B,KAarC,SAASy4B,IACU,IAAXhgB,GAA6C4f,EAAeM,OAAM,SAAUJ,GAAS,OAAOA,EAAMK,iBAClGngB,EAAS,EACT0f,EAAWE,IAGnB,SAASK,IACLz3B,aAAam3B,GACE,IAAX3f,IACAA,EAAS,EACTggB,KAGR,OApBAH,EAAYJ,GAoBL,CACHW,UAAW,SAAUN,GACjB,OAAe,IAAX9f,IAGA4f,EAAer6B,OAAS,IAgBxC,SAA0B86B,EAAOC,GAC7B,OAAQD,EAAM53B,SAAW63B,EAAO73B,SAIRmE,EAHDyzB,EAGSnb,EAHFob,EAIvBn3B,KAAKo3B,KAAKp3B,KAAKq3B,IAAI5zB,EAAO6zB,QAAUvb,EAAMub,QAAS,GAAKt3B,KAAKq3B,IAAI5zB,EAAO8zB,QAAUxb,EAAMwb,QAAS,KApDnE,MAiDjCL,EAAMxuB,UAAYyuB,EAAOzuB,WAAa0tB,GAE9C,IAA4B3yB,EAAQsY,EApBnByb,CAAiBf,EAAeA,EAAer6B,OAAS,GAAGwP,MAAO+qB,EAAM/qB,QACzEkrB,KACO,IAEXJ,EAAYC,IACL,KAEXpZ,KAAM,WACFuZ,MCpCL,IAAIW,GAA6C,sBACjD,SAASC,GAAyBl0B,EAASm0B,GAO9C,OAAQC,GAAyCp0B,EAASi0B,KACrDE,GAA6BC,GAAyCp0B,EAASm0B,IAChFE,GAAsCr0B,EAASm0B,EAA2BG,KAC1ED,GAAsCr0B,EAASm0B,EAA2BI,KAC1E,GAER,SAASH,GAAyCI,EAAeC,GAC7D,IAAIC,EAKJ,GAiMJ,gBACyCt5B,IAAjCu5B,KACAA,GAA+B,YAAaC,YAAY97B,WAE5D,OAAO67B,GArMHE,GACAH,EAAuBF,EAAcM,QAAQ,IAAI56B,OAAOu6B,EAAuB,WAI/E,IADA,IAAIz0B,EAAUw0B,EACPx0B,GAAS,CACZ,GAAIA,EAAQ+0B,aAAaN,GAAwB,CAC7CC,EAAuB10B,EACvB,MAEJA,EAAUA,EAAQg1B,cAG1B,GAAKN,EAIL,OAAOO,GAASC,GADLR,EAAqBS,aAAaV,GACJW,SAE7C,IAgKIC,GAaAV,GA7KAL,GAAqB,CAErB,SAAUt0B,EAASm0B,GAGf,GA4JR,gBACwC/4B,IAAhCi6B,KACAA,GAA8B,WAAYC,iBAAiBx8B,WAE/D,OAAOu8B,GAhKCE,IACA,GAAI,WAAYv1B,GAAWA,EAAQw1B,QAAUx1B,EAAQw1B,OAAO58B,OAAS,EACjE,OAAO68B,GAAkBz1B,EAAQw1B,OAAO,GAAIrB,QAG/C,GAAIn0B,EAAQonB,GAAI,CACjB,IAAIsO,EAAQ11B,EAAQ21B,eAChB/2B,EAAKoB,EAAQ21B,cAAcC,iBAAiB,UAAU,SAAUF,GAAS,OAAOA,EAAMG,UAAY71B,EAAQonB,MAC9G,OAAOsO,GAASD,GAAkBC,EAAOvB,KAIjD,SAAUn0B,GACN,GAAyB,UAArBA,EAAQ81B,SAAsB,CAC9B,IAAI1I,EAAQptB,EACRwL,EAAO4hB,EAAM+H,aAAa,QAC9B,GAAa,WAAT3pB,GAA8B,WAATA,GAA8B,UAATA,EAC1C,OAAO4hB,EAAMhwB,QAKzB,SAAU4C,EAASm0B,GACf,GAAyB,WAArBn0B,EAAQ81B,UAA8C,UAArB91B,EAAQ81B,UAAyD,WAAjC91B,EAAQm1B,aAAa,QACtF,OAAOM,GAAkBz1B,EAASm0B,IAG1C,SAAUn0B,GAAW,OAAOA,EAAQm1B,aAAa,eAEjD,SAAUn1B,EAASm0B,GACf,IAAI4B,EAAsB/1B,EAAQm1B,aAAa,mBAC/C,GAAIY,EACA,OAAOA,EACFzsB,MAAM,OACNpK,KAAI,SAAUkoB,GAAM,OA0DrC,SAAwB4O,EAAY5O,GAGhC,OAAO4O,EAAWL,cAAgBK,EAAWL,cAAcM,eAAe7O,GAAM,KA7DxC6O,CAAej2B,EAASonB,MACnDpV,QAAO,SAAU0jB,GAAS,OAAO/tB,QAAQ+tB,MACzCx2B,KAAI,SAAUc,GAAW,OAAOy1B,GAAkBz1B,EAASm0B,MAC3DhyB,KAAK,MAGlB,SAAUnC,GAAW,OAAOA,EAAQm1B,aAAa,QACjD,SAAUn1B,GAAW,OAAOA,EAAQm1B,aAAa,SACjD,SAAUn1B,GAAW,OAAOA,EAAQm1B,aAAa,UACjD,SAAUn1B,GAAW,OAAOA,EAAQm1B,aAAa,gBAEjD,SAAUn1B,EAASm0B,GACf,GAAI,YAAan0B,GAAWA,EAAQhF,QAAQpC,OAAS,EACjD,OAAO68B,GAAkBz1B,EAAQhF,QAAQ,GAAIm5B,KAIrDI,GAAqB,CACrB,SAAUv0B,EAASm0B,GAA6B,OAAOsB,GAAkBz1B,EAASm0B,KAOtF,SAASE,GAAsCG,EAAeL,EAA2B+B,GAGrF,IAFA,IAAIl2B,EAAUw0B,EACV2B,EAAmB,EAChBA,GAJmB,IAKtBn2B,GACqB,SAArBA,EAAQ81B,UACa,SAArB91B,EAAQ81B,UACa,SAArB91B,EAAQ81B,UAAqB,CAC7B,IAAK,IAAIp9B,EAAK,EAAG09B,EAAeF,EAAYx9B,EAAK09B,EAAax9B,OAAQF,IAAM,CACxE,IACI29B,GAASC,EADEF,EAAa19B,IACNsH,EAASm0B,GAC/B,GAAsB,kBAAXkC,EAAqB,CAC5B,IAAIE,EAAcF,EAAOjB,OACzB,GAAImB,EACA,OAAOtB,GAASC,GAAoBqB,KAMhD,GAAyB,SAArBv2B,EAAQ81B,SACR,MAEJ91B,EAAUA,EAAQg1B,cAClBmB,GAAoB,GAG5B,SAASjB,GAAoBnD,GACzB,OAAOA,EAAEp1B,QAAQ,OAAQ,KAE7B,SAASs4B,GAASlD,GACd,OAAOA,EAAEn5B,OAAS,IAAM,GAAGsB,OAAOyG,EAAaoxB,EAAG,KAAM,UAAYA,EAOxE,SAAS0D,GAAkBz1B,EAASm0B,GAChC,IAAIn0B,EAAQw2B,kBAAZ,CAGA,GAAI,cAAex2B,EAAS,CACxB,IAAIy2B,EAASz2B,EAAQ02B,UACjBC,EAAyB,SAAUC,GAEnC,IADA,IAAI/zB,EAAO7C,EAAQ41B,iBAAiBgB,GAC3BpM,EAAQ,EAAGA,EAAQ3nB,EAAKjK,OAAQ4xB,GAAS,EAAG,CACjD,IAAIqM,EAAYh0B,EAAK2nB,GACrB,GAAI,cAAeqM,EAAW,CAC1B,IAAIC,EAAgBD,EAAUH,UAC1BI,GAAiBA,EAAc1B,OAAOx8B,OAAS,IAC/C69B,EAASA,EAAO95B,QAAQm6B,EAAe,QAevD,OC7KGnvB,QAAQN,SAAS0vB,eDsKhBJ,EAAuB,iBAG3BA,EAAuB,IAAIz8B,OAAO+5B,GAA4C,MAC1EE,GACAwC,EAAuB,IAAIz8B,OAAOi6B,EAA2B,MAE1DsC,EAEX,OAAOz2B,EAAQg3B,aEzKZ,IA8IHC,GA9IOC,GAAoB,CAC3BjD,GAEA,cACA,YACA,UACA,UACA,eACA,aACA,eAEA,iBACA,eACA,oBAKAkD,GAAmC,CAACC,GAmCxC,SAAuBp3B,GACnB,GAAIA,EAAQonB,KAAOiQ,GAAiBr3B,EAAQonB,IACxC,MAAO,IAAIltB,OAAO+I,EAAUjD,EAAQonB,OAjCxCkQ,GAAyC,CACzCF,GAmCJ,SAA0Bp3B,GACtB,GAAwB,SAApBA,EAAQu3B,QACR,OAEJ,GAAIv3B,EAAQw3B,UAAU5+B,OAAS,EAC3B,IAAK,IAAIkB,EAAI,EAAGA,EAAIkG,EAAQw3B,UAAU5+B,OAAQkB,GAAK,EAAG,CAClD,IAAI29B,EAAYz3B,EAAQw3B,UAAU19B,GAClC,IAAIu9B,GAAiBI,GAGrB,MAAO,GAAGv9B,OAAO8F,EAAQu3B,QAAS,KAAKr9B,OAAO+I,EAAUw0B,MAIpE,SAA4Bz3B,GACxB,OAAOA,EAAQu3B,UA9CZ,SAASG,GAAuBlD,EAAe3d,GAGlD,IAFA,IAAI8gB,EAAwB,GACxB33B,EAAUw0B,EACPx0B,GAAgC,SAArBA,EAAQ81B,UAAqB,CAC3C,IAAI8B,EAAyBC,GAAa73B,EAASm3B,GAAkCW,GAA0BjhB,EAAqB8gB,GACpI,GAAIC,EACA,OAAOA,EAGXD,EADkCE,GAAa73B,EAASs3B,GAAwCS,GAA+BlhB,EAAqB8gB,IAEjHK,GAAgBC,GAAoBj4B,GAAU23B,GACjF33B,EAAUA,EAAQg1B,cAEtB,OAAO2C,EAEX,SAASN,GAAiBj6B,GAStB,MAAO,QAAQ4F,KAAK5F,GAwBxB,SAASg6B,GAA2Bp3B,EAAS6W,GACzC,GAAIA,IACIqhB,EAAWC,EAAqBthB,IAEhC,OAAOqhB,EAGf,IAAK,IAAIx/B,EAAK,EAAG0/B,EAAsBlB,GAAmBx+B,EAAK0/B,EAAoBx/B,OAAQF,IAAM,CAC7F,IACIw/B,EACJ,GADIA,EAAWC,EADKC,EAAoB1/B,IAGpC,OAAOw/B,EAGf,SAASC,EAAqBE,GAC1B,GAAIr4B,EAAQ+0B,aAAasD,GACrB,MAAO,GAAGn+B,OAAO8F,EAAQu3B,QAAS,KAAKr9B,OAAOm+B,EAAe,MAAOn+B,OAAO+I,EAAUjD,EAAQm1B,aAAakD,IAAiB,OAIvI,SAASJ,GAAoBj4B,GAGzB,IAFA,IAAIs4B,EAAUt4B,EAAQg1B,cAAcuD,kBAChCC,EAAe,EACZF,GAAWA,IAAYt4B,GACtBs4B,EAAQf,UAAYv3B,EAAQu3B,UAC5BiB,GAAgB,GAEpBF,EAAUA,EAAQG,mBAEtB,MAAO,GAAGv+B,OAAO8F,EAAQu3B,QAAS,iBAAiBr9B,OAAOs+B,EAAc,KAE5E,SAASX,GAAa73B,EAAS04B,EAAiB75B,EAAWgY,EAAqB8hB,GAC5E,IAAK,IAAIjgC,EAAK,EAAGkgC,EAAoBF,EAAiBhgC,EAAKkgC,EAAkBhgC,OAAQF,IAAM,CACvF,IACImgC,GAAkBC,EADDF,EAAkBlgC,IACFsH,EAAS6W,GAC9C,GAAKgiB,EAAL,CAGA,IAAIE,EAAef,GAAgBa,EAAiBF,GACpD,GAAI95B,EAAUmB,EAAS+4B,GACnB,OAAOA,IAOnB,SAASjB,GAAyB93B,EAASk4B,GACvC,OAAmE,IAA5Dl4B,EAAQ21B,cAAcC,iBAAiBsC,GAAUt/B,OAY5D,SAASm/B,GAA8B/3B,EAASk4B,GAC5C,OACgB,IADRl4B,EAAQg1B,cAAcY,iBAO3B,WACH,QAAkCx6B,IAA9B67B,GACA,IACI5vB,SAASwY,cAAc,UACvBoX,IAA4B,EAEhC,MAAOl5B,IACHk5B,IAA4B,EAGpC,OAAOA,GAjBwC+B,GAAyBhB,GAAgB,SAAUE,GAAYA,GACzGt/B,OAET,SAASo/B,GAAgBiB,EAAQC,GAC7B,OAAOA,EAAQ,GAAGh/B,OAAO++B,EAAQ,KAAK/+B,OAAOg/B,GAASD,EC9F1D,SAASE,KACL,IAAIC,EAAYt5B,OAAOu5B,eACvB,OAAQD,GAAaA,EAAUE,YAEnC,SAASC,GAAkBnxB,GACvB,OAAQA,EAAMtM,kBAAkB09B,UAMZ,UAAfpxB,EAAMoD,OAAwC,IAApBpD,EAAMqxB,WC9DlC,SAASC,GAAmBC,EAAQC,GACvC,GAuBG,SAAgBD,GACnB,GAAIA,EAAO52B,MAAK,SAAUowB,GAAS,OAAOA,EAAM0G,kBAAkBT,aAC9D,OAAO,EAEX,IAAK,IAAIt/B,EAAI,EAAGA,EAAI6/B,EAAO/gC,OAAS,EAA8CkB,GAAK,EACnF,GAAI6/B,EAAO7/B,EA9B0B,EA8BmB,GAAGsO,MAAMlD,UAAYy0B,EAAO7/B,GAAGsO,MAAMlD,WACzFtK,EACA,OAAO,EAGf,OAAO,EAjCHk/B,CAAOH,GAQP,OAPAC,EAAUG,eAAe,cACrBJ,EAAO52B,KAAKi3B,KACZJ,EAAUG,eAAe,cAEzBH,EAAUK,UACVL,EAAUG,eAAe,eAEtB,CAAED,QAAQ,GAErB,IAAII,EAAsBP,EAAO52B,MAAK,SAAUowB,GAAS,OAAOA,EAAM0G,kBAAkBT,aAWxF,OAVAO,EAAO39B,SAAQ,SAAUm3B,GACjBA,EAAM8G,UACN9G,EAAM4G,eAAe,eAErBC,GAAO7G,KAEN+G,GACD/G,EAAM4G,eAAe,iBAGtB,CAAED,QAAQ,GAcrB,IAAIK,GAGJ,8KASO,SAASH,GAAO7G,GACnB,OAAIA,EAAMiH,kBAAmBjH,EAAM0G,kBAAkBzM,QvD+M1BptB,EuD5MJmzB,EAAM/qB,MAAMtM,OvD4MCo8B,EuD5MOvvB,GAA6B,oBAEhE,GAAGzO,OAAOigC,GAA6B,0CACzCA,KvD0MFn6B,EAAQQ,QACDR,EAAQQ,QAAQ03B,GAGvBl4B,EAAQq6B,mBACDr6B,EAAQq6B,kBAAkBnC,KANlC,IAAwBl4B,EAASk4B,EwDvPjC,SAASoC,GAAkBpZ,EAAWkQ,EAAuBrhB,GAChE,IAEIwqB,EAFAC,EAAU,IAAIrQ,GAFqB,KAGnCiJ,EAAiB,IAAIrb,GAEzBmJ,EAAUhJ,UAAU,GAAyB,WACzCsiB,EAAQ3P,WAEZ3J,EAAUhJ,UAAU,EAAoBuiB,GACxC,IAAIC,EFlBD,SAA4B38B,GAC/B,IACI48B,EAKAC,EANAC,EAAgB98B,EAAG88B,cAAeC,EAAe/8B,EAAG+8B,aAEpDC,EAAe,CACf3B,WAAW,EACXhM,OAAO,GAGP4N,EAAY,CACZ1hB,GAAiBxZ,OAAQ,eAAkC,SAAUsI,GAC7DmxB,GAAkBnxB,KAClBuyB,EAA8BxB,KAC9B4B,EAAe,CACX3B,WAAW,EACXhM,OAAOzkB,GAA6B,qBAI5BoyB,EAAa3N,OAEzBwN,EAAeC,EAAczyB,MAElC,CAAEwR,SAAS,IACdN,GAAiBxZ,OAAQ,mBAA0C,WAC1D66B,GAAgCxB,OACjC4B,EAAa3B,WAAY,KAE9B,CAAExf,SAAS,IACdN,GAAiBxZ,OAAQ6I,GAA6B,oBAAsB,YAA+B,SAAqB,SAAUipB,GACtI,GAAI2H,GAAkB3H,IAAegJ,EAAc,CAE/C,IACIK,EADAC,EAAsBH,EAE1BD,EAAaF,EAAchJ,GAAY,WAAc,OAAOsJ,KAAwB,WAAc,OAAOD,KACzGL,OAAex/B,EACXuN,GAA6B,qBAC7B2Q,GAAiBxZ,OAAQ,SAAqB,WAC1Cm7B,EAAwBn1B,MACzB,CAAE8T,SAAS,EAAMD,MAAM,OAGnC,CAAEC,SAAS,IACdN,GAAiBxZ,OAAQ,SAAqB,WAC1Ci7B,EAAa3N,OAAQ,IACtB,CAAExT,SAAS,KAElB,MAAO,CACHG,KAAM,WACFihB,EAAUh/B,SAAQ,SAAUwd,GAAY,OAAOA,EAASO,YE9BjCohB,CAAmB,CAC9CN,cAAe,SAAUO,GACrB,OAkCZ,SAA4BrrB,EAAemR,EAAWkQ,EAAuBoJ,EAASY,GAClF,IAAKrrB,EAAc6G,mBAAqB4jB,EAAQ57B,OAG5C,OAEJ,IAAIy8B,EAmER,SAAgCjzB,EAAOyO,GACnC,IAAI/a,EACAw/B,EACJ,GAAI3yB,GAA6B,YAAa,CAC1C,IAAI4yB,EAAOnzB,EAAMtM,OAAO0/B,wBACxB1/B,EAAS,CACLgpB,MAAOtoB,KAAKM,MAAMy+B,EAAKzW,OACvBE,OAAQxoB,KAAKM,MAAMy+B,EAAKvW,QACxBkT,SAAUR,GAAuBtvB,EAAMtM,OAAQ+a,IAEnDykB,EAAW,CAEPG,EAAGj/B,KAAKM,MAAMsL,EAAM0rB,QAAUyH,EAAKG,MACnCC,EAAGn/B,KAAKM,MAAMsL,EAAM2rB,QAAUwH,EAAKK,MAG3C,MAAO,CACHpwB,KAAM,QACN1P,OAAQA,EACRw/B,SAAUA,EACV/6B,KAAM2zB,GAAyB9rB,EAAMtM,OAAQ+a,IAvF3BglB,CAAuBT,EAAkBrrB,EAAc8G,qBAC7E,IAAK9G,EAAc6G,oBAAsBykB,EAAgB96B,KAGrD,OAEJ,IAAIu7B,GAA2B,EAC3BnzB,GAA6B,qBAC7BwoB,GAAoBjQ,EAAWkQ,EAAuBrhB,GAAe,SAAUgsB,GAC3ED,EAA2BC,EAAqBzJ,cAIpDpB,IAEJ,MAAO,CAAEmK,gBAAiBA,EAAiBS,yBAA0B,WAAc,OAAOA,IAvD3EE,CAAmBjsB,EAAemR,EAAWkQ,EAAuBoJ,EAASY,IAExFN,aAAc,SAAU/8B,EAAI6zB,EAAYiI,EAAiBoC,GACrD,IAAIZ,EAAkBt9B,EAAGs9B,gBAAiBS,EAA2B/9B,EAAG+9B,yBACxE,OAqDZ,SAA0B/rB,EAAemR,EAAWkQ,EAAuBoJ,EAASpH,EAAgB8I,EAAyBb,EAAiBzJ,EAAYiI,EAAiBiC,EAA0BG,GACjM,IAAI9I,EAAQgJ,GAASjb,EAAWsZ,EAASX,EAAiBoC,EAAwBZ,EAAiBzJ,GAC/F7hB,EAAc6G,mBACdslB,EAAwB/I,GAE5B,IAAIiJ,EAA0BjL,GAAoBjQ,EAAWkQ,EAAuBrhB,GAAe,SAAUgsB,GACrGA,EAAqBzJ,aAAeyJ,EAAqB31B,IAAM+sB,EAAMhoB,YAAYjG,UAEjFiuB,EAAMkJ,WAGFN,EAAqBzJ,YACrBa,EAAMpZ,KAAKgiB,EAAqB31B,KAE3B01B,IACL3I,EAAMpZ,KAGNoZ,EAAMhoB,YAAYjG,WAGlBiuB,EAAMpZ,OAILhK,EAAc6G,oBACVmlB,EAAqBzJ,YAMtBa,EAAMmJ,WAHNnJ,EAAMkJ,cAlGa,KAyGLtiB,KAC1BwiB,EAAwBrb,EAAUhJ,UAAU,GAAoB,SAAUna,GAC1E,IAAIy+B,EAAYz+B,EAAGy+B,UACnBrJ,EAAMpZ,KAAKyiB,EAAUt3B,cAErBu3B,EAAmBrJ,EAAelb,WAAU,WAC5Cib,EAAMpZ,UAEVoZ,EAAMC,eAAelb,WAAU,WAC3BqkB,EAAsBjkB,cACtB8jB,IACAK,EAAiBnkB,iBApGNokB,CAAiB3sB,EAAemR,EAAWkQ,EAAuBoJ,EAASpH,EAAgB8I,EAAyBb,EAAiBzJ,EAAYiI,EAAiBiC,EAA0BG,MAExMliB,KAMH,MAAO,CACHA,KAAM,WACF0gB,IACArH,EAAe5a,SACfkiB,KAEJhV,eAXiB,CACjBoB,aAAc,SAAU5J,GACpB,OAAOnN,EAAc6G,kBAAoB4jB,EAAQ5P,QAAQ1N,GAAasd,EAAQ57B,KAAKse,MAW3F,SAASgf,EAAwB/I,GAC7B,IAAKoH,IAAsBA,EAAkB9G,UAAUN,GAAQ,CAC3D,IAAIwJ,EAAcxJ,EAAMrL,QACxByS,EAAoB1H,GAAiBM,GAAO,SAAUwG,IAyL3D,SAAwBA,EAAQC,GACtBF,GAAmBC,EAAQC,GAAWE,QAE/CH,EAAO39B,SAAQ,SAAUm3B,GAAS,OAAOA,EAAMkJ,aAC/CzC,EAAU7f,KAAKjU,KACf8zB,EAAU0C,SAAS3C,EAAOz6B,KAAI,SAAUi0B,GAAS,OAAOA,EAAM/qB,YAG9DwxB,EAAUyC,UACV1C,EAAO39B,SAAQ,SAAUm3B,GAAS,OAAOA,EAAMmJ,eAjMvCM,CAAejD,EAAQgD,OAInC,SAASlC,IACDF,GACAA,EAAkBxgB,QAoG9B,SAASoiB,GAASjb,EAAWsZ,EAASX,EAAiBoC,EAAwBZ,EAAiBzJ,GAC5F,IAWIiL,EAXAzV,EAAK/qB,IACL8O,EAAcnF,KACd82B,EAAetC,EAAQ/4B,IAAI2lB,EAAIjc,EAAYlG,UAC3C83B,EAA0BvM,GAAiB,CAC3CtP,UAAWA,EACXuP,aAAc,SAAUroB,GACpB,YAAwBhN,IAAjBgN,EAAMmf,SACRvtB,MAAMiH,QAAQmH,EAAMmf,OAAOH,IAAMlpB,EAASkK,EAAMmf,OAAOH,GAAIA,GAAMhf,EAAMmf,OAAOH,KAAOA,MAG9F/T,EAAS,EAET2pB,EAAmB,GACnB5J,EAAiB,IAAIrb,GACzB,SAASgC,EAAKkjB,GACK,IAAX5pB,IAIJA,EAAS,GADTwpB,EAAkBI,GAGdH,EAAarS,MAAMlkB,GAAgBs2B,IAGnCC,EAAa74B,SAEjB84B,EAAwBhjB,OACxBqZ,EAAe5a,UAEnB,MAAO,CACHpQ,MAAOwpB,EACP7X,KAAMA,EACNqZ,eAAgBA,EACZ6G,eACA,OAAO8C,EAAwBpM,YAAYC,WAAa,GAExDwJ,sBACA,YAA2Bh/B,IAApByhC,GAEXhD,gBAAiBA,EACjBE,eAAgB,SAAUmD,GACtBF,EAAiBr+B,KAAKu+B,IAE1B/xB,YAAaA,EACbqoB,UAAW,WAAc,OAAkB,IAAXngB,GAAyC,IAAXA,GAC9DyU,MAAO,WAAc,OAAOqU,GAASjb,EAAWsZ,EAASX,EAAiBoC,EAAwBZ,EAAiBzJ,IACnH0K,SAAU,SAAUa,GAEhB,GADApjB,IACe,IAAX1G,EAAJ,CAGA,IAAItV,EAAKg/B,EAAwBpM,YAAaG,EAAgB/yB,EAAG+yB,cAAeF,EAAa7yB,EAAG6yB,WAAYC,EAAgB9yB,EAAG8yB,cAC3HuM,EAAsBnB,IACtBoB,EAAc,EAAO,CACrB7xB,KAAM,QACN3F,SAAUg3B,GAAmB32B,GAAQiF,EAAYjG,UAAW23B,GAC5D1xB,YAAaA,EACbic,GAAIA,EACJ4V,iBAAkBA,EAClBM,OAAQ,CACJxM,cAAeA,EACfF,WAAYA,EACZC,cAAeA,GAEnBnX,OAAsB,OAAdyjB,QAAoC,IAAdA,EAAuBA,EAAY,CAACvL,GAClExpB,MAAOwpB,EACP2L,eAAgBH,GAAuBl3B,GAAQiF,EAAYjG,UAAWk4B,IACvE/B,GACHna,EAAU1I,OAAO,EAA+B6kB,GAChDhqB,EAAS,IAEbgpB,QAAS,WACLtiB,IACA1G,EAAS,IC9MrB,SAASmqB,GAAcjW,EAAQkW,GAC3B,IAAIC,EAAuBC,GAAapW,GAClC,CACEA,OAAQ,CACJH,GAAIG,EAAOH,GACXwW,aAAch4B,EAAiB2hB,EAAO1hB,UACtCorB,YAAa,CACTzlB,KAAM+b,EAAOyV,kBAEjB1kC,MAAO,CACH8W,MAAOmY,EAAO+V,OAAO1M,YAEzBiN,UAAW,CACPzuB,MAAOmY,EAAO+V,OAAOzM,eAEzBiN,SAAU,CACN1uB,MAAOmY,EAAO+V,OAAOxM,gBAG7BhW,IAAK,CACDyM,OAAQ,CACJzrB,OAAQyrB,EAAOzrB,OACfw/B,SAAU/T,EAAO+T,SACjByC,iBAAkBxW,EAAOgW,uBAInCniC,EACFkrB,EAAmBqX,GAAapW,QAA2BnsB,EAAjBmsB,EAAO9sB,QACjDujC,EAAcz7B,EAAQ,CACtBglB,OAAQ,CACJH,GAAI/qB,IACJP,OAAQ,CACJyE,KAAMgnB,EAAOhnB,MAEjBiL,KAAM+b,EAAO/b,MAEjB3E,KAAM0gB,EAAOpc,YAAYjG,UACzBsG,KAAM,UACPkyB,GACCO,EAAeR,EAAmB1U,iBAAiBxB,EAAOpc,YAAYlG,UAI1E,YAHqB7J,IAAjB6iC,IACAD,EAAY3W,KAAO,CAAE6W,cAAeD,IAEjC,CACH3X,gBAAiBA,EACjBH,YAAa6X,EACb9gB,UAAWqK,EAAOpc,YAAYlG,SAC9BmhB,cAAeuX,GAAapW,GAAU,CAAEnf,MAAOmf,EAAOnf,MAAOsR,OAAQ6N,EAAO7N,QAAW,IAG/F,SAASikB,GAAapW,GAClB,MAAuB,WAAhBA,EAAO/b,KCpElB,IAAI2yB,GAAiB,0GAgCd,SAASC,GAA8Bv5B,GAC1C,IAAIw5B,EAYR,SAA2Bx5B,GACvB,OAAOwmB,GAAgCvrB,OAAQ,UAAW,CACtDwrB,OAAQ,SAAU5gB,EAAST,EAAKq0B,EAAQC,EAAUC,GAC9C,IAAIv1B,EACJ,GAAIu1B,EACAv1B,EAAQF,GAAkBy1B,GAC1B35B,EAASoE,EAAOu1B,OAEf,CACD,IAKInI,EALAoI,EAAa,CACbx0B,IAAKA,EACLF,OAAQw0B,EACRh1B,KAAM+0B,GAGNI,EAAMh0B,EACV,GAAkC,oBAA9B,GAAGhO,SAAS1D,KAAK0R,GAAgC,CACjD,IAAIi0B,EAASR,GAAez9B,KAAKg+B,GAC7BC,IACAtI,EAASsI,EAAO,GAChBD,EAAMC,EAAO,IAQrB95B,EALAoE,EAAQ,CACJ1I,KAAM81B,EACN3rB,QAAwB,kBAARg0B,EAAmBA,OAAMtjC,EACzC6N,MAAO,CAACw1B,IAEI/zB,OAxCGk0B,CAAkB/5B,GAAUkV,KACvD8kB,EA+CR,SAAsCh6B,GAClC,OAAOwmB,GAAgCvrB,OAAQ,uBAAwB,CACnEwrB,OAAQ,SAAU5wB,GACd,IAAIokC,EAASpkC,EAAEokC,QAAU,eACrB71B,EAAQF,GAAkB+1B,GAC9Bj6B,EAASoE,EAAO61B,MApDoBC,CAA6Bl6B,GAAUkV,KACnF,MAAO,CACHA,KAAM,WACFskB,IACAQ,MCnCZ,IAAIG,GAA0B,GACvB,SAASC,GAAsBC,GAClC,IAAIC,EAAqBD,EAAKhgC,KAAI,SAAU1G,GAIxC,OAHKwmC,GAAwBxmC,KACzBwmC,GAAwBxmC,GAOpC,SAAiCA,GAC7B,IAAIugB,EAAa,IAAIhB,IAAW,WAC5B,IAAIqnB,EAAqB9lC,QAAQd,GAYjC,OAXAc,QAAQd,GAAO,WAEX,IADA,IAAI6mC,EAAS,GACJ3mC,EAAK,EAAGA,EAAKC,UAAUC,OAAQF,IACpC2mC,EAAO3mC,GAAMC,UAAUD,GAE3B0mC,EAAmBnmC,MAAMK,QAAS+lC,GAClC,IAAIn0B,EAAgBY,KACpBvR,GAAc,WACVwe,EAAWP,OAAO8mB,GAAgBD,EAAQ7mC,EAAK0S,QAGhD,WACH5R,QAAQd,GAAO4mC,MAGvB,OAAOrmB,EAzBgCwmB,CAAwB/mC,IAEpDwmC,GAAwBxmC,MAEnC,OAAOmgB,GAAiB1f,WAAM,EAAQkmC,GAuB1C,SAASG,GAAgBD,EAAQ7mC,EAAK0S,GAElC,IACIjC,EADAyB,EAAU20B,EAAOngC,KAAI,SAAUsgC,GAAS,OAchD,SAAiCA,GAC7B,GAAqB,kBAAVA,EACP,OAAOA,EAEX,GAAIA,aAAiBl0B,MACjB,OAAOM,GAAmB7C,GAAkBy2B,IAEhD,OAAOriC,EAAcqiC,OAAOpkC,EAAW,GArBYqkC,CAAwBD,MAAWr9B,KAAK,KAE3F,GAAI3J,IAAQP,EAAeK,MAAO,CAC9B,IAAIonC,EAAkB9gC,EAAKygC,GAAQ,SAAUG,GAAS,OAAOA,aAAiBl0B,SAC9ErC,EAAQy2B,EAAkBn0B,GAAmBxC,GAAkB22B,SAAoBtkC,EACnFsP,EAAU,kBAAkBxQ,OAAOwQ,GAEvC,MAAO,CACHlS,IAAKA,EACLkS,QAASA,EACTzB,MAAOA,EACPiC,cAAeA,GC7ChB,ICJHy0B,GACA,GDGOC,GACO,eADPA,GAGO,gBAEX,SAASC,GAAqBX,GACjC,IAAItmB,EAAc,GACd1a,EAASghC,EAAMU,KACfhnB,EAAYja,KA6BpB,WACI,IAAIoa,EAAa,IAAIhB,IAAW,WAC5B,IAAI+nB,EAAqBxlC,GAAQ,SAAU8N,GACvC2Q,EAAWP,OAgBvB,SAAwCpQ,GACpC,IAAIoD,EAAOo0B,GACPl1B,EAAU,IAAIxQ,OAAOkO,EAAM23B,WAAY,kBAAkB7lC,OAAOkO,EAAM43B,mBAAoB,eAC9F,MAAO,CACHx0B,KAAMo0B,GACNK,QAAS73B,EAAM43B,mBACft1B,QAAS,GAAGxQ,OAAOsR,EAAM,MAAMtR,OAAOwQ,GACtCzB,MAAOi3B,GAAW93B,EAAM43B,mBAAoB53B,EAAM+3B,eAC5C,GAAGjmC,OAAOwQ,EAAS,oBAAqBxQ,OAAOyG,EAAayH,EAAM+3B,eAAgB,IAAK,OAAQ,KAC/F,YAAa/3B,EAAMg4B,WAAYh4B,EAAMi4B,WAAYj4B,EAAMk4B,eAzBvCC,CAA+Bn4B,OAGrD,OADWkR,GAAiBjS,SAAU,0BAA2Dy4B,GAAoB/lB,QAGzH,OAAOhB,EArCcynB,IAErB,IAAIC,EAAcvB,EAAKltB,QAAO,SAAUxZ,GAAO,OAAOA,IAAQonC,MAI9D,OAHIa,EAAY7nC,QACZggB,EAAYja,KAIpB,SAAgC8hC,GAC5B,IAAI1nB,EAAa,IAAIhB,IAAW,WAC5B,GAAKjY,OAAO4gC,kBAAZ,CAGA,IAAIC,EAAgBrmC,GAAQ,SAAUsmC,GAClC,OAAOA,EAAQ5kC,SAAQ,SAAU6kC,GAC7B9nB,EAAWP,OAwB3B,SAAkCza,GAC9B,IAAIyN,EAAOzN,EAAGyN,KAAM6B,EAAOtP,EAAGsP,KAC9B,MAAO,CACH7B,KAAMA,EACNy0B,QAAS5yB,EAAK+Z,GACd1c,QAAS,GAAGxQ,OAAOsR,EAAM,MAAMtR,OAAOmT,EAAK3C,SAC3CzB,MAAOi3B,GAAW7yB,EAAK+Z,GAAI/Z,EAAK3C,QAAS2C,EAAK+yB,WAAY/yB,EAAKgzB,WAAYhzB,EAAKizB,eA9BtDQ,CAAyBD,UAG/CnoB,EAAW,IAAI5Y,OAAO4gC,kBAAkBC,EAAe,CACvDI,MAAON,EACP1e,UAAU,IAGd,OADArJ,EAASoJ,UACF,WACHpJ,EAASsoB,kBAGjB,OAAOjoB,EAvBckoB,CAAuBR,IAErC9nB,GAAiB1f,WAAM,EAAQ2f,GAsD1C,SAASsnB,GAAW3/B,EAAMmK,EAAS01B,EAAYC,EAAYC,GACvD,OAAQF,GACJ70B,GAAmB,CACfhL,KAAMA,EACNmK,QAASA,EACTzB,MAAO,CACH,CACIe,KAAM,IACNC,IAAKm2B,EACL72B,KAAM82B,EACNt2B,OAAQu2B,MEhFrB,SAASY,GAAqBhgB,EAAWuc,EAAoB0D,GAChE,IAAIC,EAAkB,IAAIrpB,GAK1B,OCRG,SAA2BqpB,GAC9B,IAAIpoB,EAAeimB,GAAsB,CAAChnC,EAAeK,QAAQ4f,WAAU,SAAUmpB,GACjF,OAAOD,EAAgB5oB,OAAO,CAC1BrN,YAAanF,KACb0E,QAAS22B,EAAa32B,QACtBzB,MAAOo4B,EAAap4B,MACpBhN,OAAQ6O,GACRO,SAAU,UACVH,cAAem2B,EAAan2B,mBDJpCo2B,CAAkBF,GEFf,SAA2BA,GACvBhD,IAA8B,SAAUpzB,EAAYC,GACvDm2B,EAAgB5oB,OAAOzN,GAAgB,CACnCC,WAAYA,EACZC,cAAeA,EACfE,YAAanF,KACboF,eAAgB,WAChBnP,OAAQ6O,GACRO,SAAU,kBFLlBk2B,CAAkBH,GGLf,SAA0BA,GAC7B,IAAIpoB,EAAe6mB,GAAqB,CAACD,GAA4BA,KAA6B1nB,WAAU,SAAUyN,GAClH,OAAOyb,EAAgB5oB,OAAO,CAC1BrN,YAAanF,KACb0E,QAASib,EAAYjb,QACrBzB,MAAO0c,EAAY1c,MACnBuC,KAAMma,EAAYsa,QAClBhkC,OAAQ6O,GACRO,SAAU,iBHFlBm2B,CAAiBJ,GACjBA,EAAgBlpB,WAAU,SAAU5f,GAAS,OAAO4oB,EAAU1I,OAAO,GAA8B,CAAElgB,MAAOA,OAGzG,SAAgC4oB,EAAWuc,EAAoB0D,GAQlE,OAPAjgB,EAAUhJ,UAAU,IAA8B,SAAUna,GACxD,IAAIzF,EAAQyF,EAAGzF,MAAOguB,EAAkBvoB,EAAGuoB,gBAAiBD,EAAqBtoB,EAAGsoB,mBACpFnF,EAAU1I,OAAO,GAAkC,EAAO,CACtD8N,gBAAiBA,EACjBD,mBAAoBA,GAwBhC,SAAsB/tB,EAAOmlC,EAAoB0D,GAC7C,IAAIhb,EAAc,CACdtf,KAAMvO,EAAM6S,YAAYjG,UACxB5M,MAAO,CACH8uB,GAAI/qB,IACJqO,QAASpS,EAAMoS,QACfzO,OAAQ3D,EAAM2D,OACdgN,MAAO3Q,EAAM2Q,MACbw4B,eAAgBnpC,EAAM4S,cACtBM,KAAMlT,EAAMkT,KACZH,SAAU/S,EAAM+S,SAChBI,OAAQnT,EAAMmT,OACdi2B,YAAa,WAEjBl2B,KAAM,SAENyyB,EAAeR,EAAmB1U,iBAAiBzwB,EAAM6S,YAAYlG,UACrEg5B,IACA9X,EAAYkB,KAAO,CAAE6W,cAAeD,IAExC,IAAI0D,EAAqBR,EAAoBS,2BAA2BtpC,EAAM6S,YAAYlG,UACtF08B,IAAuBviC,EAAcuiC,KACrCxb,EAAY0b,cAAgBF,GAEhC,MAAO,CACHxb,YAAaA,EACbjJ,UAAW5kB,EAAM6S,YAAYlG,SAC7BmhB,cAAe,CACX9tB,MAAOA,EAAM2S,gBAnDd62B,CAAaxpC,EAAOmlC,EAAoB0D,QAExC,CACHY,SAAU,SAAUhkC,EAAIsoB,GACpB,IAAI/tB,EAAQyF,EAAGzF,MAAO4S,EAAgBnN,EAAGmN,cAAeC,EAAcpN,EAAGoN,YAAamb,EAAkBvoB,EAAGtD,QAEvGunC,EAAWj3B,GAAgB,CAC3BC,WAFa1S,aAAiBgT,MAAQvC,GAAkBzQ,QAAS8C,EAGjE6P,cAAe3S,EACf4S,cAAeA,EACfC,YAAaA,EACbC,eAAgB,WAChBnP,OAAQ6O,GACRO,SAAU,YAEd6V,EAAU1I,OAAO,GAA8B,CAC3C8N,gBAAiBA,EACjBD,mBAAoBA,EACpB/tB,MAAO0pC,MA1BZC,CAAuB/gB,EAAWuc,EAAoB0D,GIK1D,SAASe,GAAmBrQ,GAC/B,GAAKtsB,aAAiB,qBAAsBA,YAA5C,CAGA,IAAI48B,EAAkB58B,YAAY68B,iBAAiBvQ,EAAQ5nB,IAAK,YAChE,GAAKk4B,EAAgBvpC,QAAY,WAAYupC,EAAgB,GAA7D,CAGA,IAAIE,EAAaF,EACZjjC,KAAI,SAAU+d,GAAS,OAAOA,EAAMhf,YACpC+T,OAAOsL,IACPtL,QAAO,SAAUiL,GAClB,OAUR,SAAmBxW,EAAQN,EAAOC,GAC9B,IAAIk8B,EAAc,EAClB,OAAO77B,EAAOyW,WAAa/W,EAAQm8B,GAAe/X,GAAQ9jB,IAAWf,GAAYU,EAAKk8B,GAZ3EC,CAAUtlB,EAAO4U,EAAQ1mB,YAAYlG,SAAUslB,GAAQ,CAAErN,UAAW2U,EAAQ1mB,YAAYlG,SAAUY,SAAUgsB,EAAQhsB,eAE/H,OAA0B,IAAtBw8B,EAAWzpC,OACJypC,EAAW,QADtB,IAKJ,SAAS9X,GAAQ9jB,GACb,OAAOf,GAAYe,EAAOyW,UAAWzW,EAAOZ,UC/BzC,SAAS28B,GAAwBthB,EAAWnR,EAAe4D,EAAgB8uB,GAC9EvhB,EAAUhJ,UAAU,GAA2B,SAAU2Z,GACrD3Q,EAAU1I,OAAO,GAWzB,SAAwBqZ,EAAS9hB,EAAe4D,EAAgB8uB,GAC5D,IAAI1kC,EACAyN,EAAwB,QAAjBqmB,EAAQrmB,KAA2B,MAAkB,QAC5Dk3B,EAAiBR,GAAmBrQ,GACpC1mB,EAAcu3B,EAAiB19B,EAAiB09B,EAAexlB,WAAa2U,EAAQ1mB,YACpFw3B,EAA+BD,EAAiBE,GAA+BF,QAAkBtnC,EACjGynC,EA8DR,SAAmChR,EAAS9hB,GAExC,KADoB8hB,EAAQpe,cAAgBoe,EAAQte,SAAWse,EAAQre,QAEnE,OAEJ,MAAO,CACHsH,IAAK,CACDgoB,QAASjR,EAAQre,OAAOe,kBACxBwuB,SAAUlR,EAAQte,QAAQgB,kBAC1ByuB,SAAUC,GAAWlzB,KAvEXmzB,CAA0BrR,EAAS9hB,GACjDozB,EAAeC,GAAoBzvB,EAAgBxI,GACnDtF,EAAWD,EAAiBisB,EAAQhsB,UACpCw9B,EAoFR,SAAqCC,EAAkBC,GACnD,IAAK56B,GAA6B,sBAC9B,OAEJ,MAAO,CACHmS,IAAK,CACD0oB,kBAAmBF,EACnBG,2BAA4BF,EAC5BG,uBAAwBH,EAA2BD,EAAmBC,OAA2BnoC,IA5F9EuoC,CAA4B99B,EAA2C,OAAjC88B,QAA0E,IAAjCA,OAA0C,EAASA,EAA6B7E,SAASj4B,UAC/L+9B,EAAgBC,GAAqBpB,EAAkBt3B,EAAgH,QAAlGpN,EAAwB,OAAnB2kC,QAA8C,IAAnBA,OAA4B,EAASA,EAAe78B,gBAA6B,IAAP9H,EAAgBA,EAAK8zB,EAAQhsB,UAC5Mi+B,EAAgBvhC,EAAQ,CACxBsE,KAAMsE,EAAYjG,UAClB44B,SAAU,CACN1W,GAAI/qB,IACJmP,KAAMA,EACN3F,SAAUA,EACVolB,OAAQ4G,EAAQ5G,OAChB8Y,YAAalS,EAAQxe,OACrBpJ,IAAK4nB,EAAQ5nB,KAEjBuB,KAAM,YACPq3B,EAAaF,EAA8BQ,EAAcE,EAAsBO,GAClF,MAAO,CACH1mB,UAAW/R,EAAYlG,SACvBkhB,YAAa2d,EACb1d,cAAe,CACX4d,iBAAkBtB,GAAmDA,EACrEhW,IAAKmF,EAAQnF,IACbgB,SAAUmE,EAAQnE,SAClBuW,aAAcpS,EAAQzE,MACtB8W,YAAarS,EAAQxE,KACrB/0B,MAAOu5B,EAAQv5B,QA3CgC6rC,CAAetS,EAAS9hB,EAAe4D,EAAgB8uB,OAE9GvhB,EAAUhJ,UAAU,GAAuC,SAAUyJ,GACjE,IAAK,IAAIjpB,EAAK,EAAG0rC,EAAYziB,EAASjpB,EAAK0rC,EAAUxrC,OAAQF,IAAM,CAC/D,IAAIukB,EAAQmnB,EAAU1rC,GACE,aAApBukB,EAAM6D,YvCyCc,oBADNra,EuCxCmCwW,GvCyC/CX,eAA+D,UAAzB7V,EAAO6V,gBuCxC/C4E,EAAU1I,OAAO,GAAkC6rB,GAAqBpnB,EAAOlN,EAAe4D,EAAgB8uB,IvCuCvH,IAAuBh8B,KuCE9B,SAAS49B,GAAqBpnB,EAAOlN,EAAe4D,EAAgB8uB,GAChE,IAAIj3B,EAAOgR,GAAoBS,GAC3BqnB,EAAe1B,GAA+B3lB,GAC9C9R,EAAcnG,EAAiBiY,EAAMC,WACrC2lB,EAyCR,SAAiC5lB,EAAOlN,GAEpC,IADoBkN,EAAM1J,QAEtB,OAEJ,MAAO,CACHuH,IAAK,CACDioB,SAAU9lB,EAAM1J,QAChByvB,SAAUC,GAAWlzB,KAjDXw0B,CAAwBtnB,EAAOlN,GAC7CozB,EAAeC,GAAoBzvB,EAAgBxI,GACnDy4B,EAAgBC,GAAqBpB,EAAkBt3B,EAAa8R,EAAMpX,UAC1Ei+B,EAAgBvhC,EAAQ,CACxBsE,KAAMsE,EAAYjG,UAClB44B,SAAU,CACN1W,GAAI/qB,IACJmP,KAAMA,EACNvB,IAAKgT,EAAM1c,MAEfiL,KAAM,YACPq3B,EAAayB,EAAcnB,EAAcS,GAC5C,MAAO,CACH1mB,UAAW/R,EAAYlG,SACvBkhB,YAAa2d,EACb1d,cAAe,CACX4d,iBAAmD/mB,IAI/D,SAAS2lB,GAA+Bn8B,GACpC,MAAO,CACHq3B,SAAU,EAAO,CACbj4B,SAAUmX,GAAmCvW,GAC7C7C,KAAM8a,GAAYjY,IACnB2W,GAAkC3W,KA+C7C,SAASw8B,GAAWlzB,GAChB,OAAOhR,EAASgR,EAAcoE,iBAAmBpE,EAAcoE,gBAAkB,SAAM/Y,EAE3F,SAASgoC,GAAoBzvB,EAAgB6wB,GACzC,IAAI7d,EAAUhT,EAAeG,mBAAmB0wB,EAAcv/B,UAC9D,MAAO,CACH6V,IAAK,CACD2pB,WAAY9d,IAAYA,EAAQ+d,kBAI5C,SAASb,GAAqBpB,EAAkBt3B,EAAatF,GACzD,GAAK8C,GAA6B,wBAGlC,MAAO,CACHmS,IAAK,CACD6pB,YAAalC,EAAiB7X,QAAQzf,EAAYlG,SAAUY,GAC5D++B,mBAAoBv7B,OAAOhC,SAASw9B,gBN/IzC,SAASC,GAAiBvrB,GAoB7B,YAnBoB,IAAhBA,IAA0BA,EAAczZ,QACvC6/B,KACgC,WAA7Bt4B,SAAS09B,gBACTpF,GAA4B,CACxBz6B,UAAW,IAIfy6B,GAA4B,CACxBz6B,UAAWglB,EAAAA,GAEd,GAAgBzQ,GAAkBF,EAAa,CAAC,WAA4B,qBAA6C,SAAUnR,GAC7G,aAAfA,EAAMoD,MAAoD,WAA7BnE,SAAS09B,kBACtCpF,GAA0Bz6B,UAAYkD,EAAMlD,UAC5C,QAEL,CAAE0U,SAAS,IAAQG,OAGvB4lB,GOnBJ,IAAIqF,GAAuB,IAC3B,SAASC,GAAwB/jB,EAAWrc,GAC/C,IAAIqgC,EAAU,GACd,SAASC,EAAWC,GAChB,EAAOF,EAASE,GAChBvgC,EAASqgC,GAEb,IAAIG,EAyBD,SAAgCnkB,EAAWrc,GAmB9C,MAAO,CAAEkV,KAlBEmH,EAAUhJ,UAAU,GAAuC,SAAUyJ,GAC5E,IAAK,IAAIjpB,EAAK,EAAG0rC,EAAYziB,EAASjpB,EAAK0rC,EAAUxrC,OAAQF,IAAM,CAC/D,IAAIukB,EAAQmnB,EAAU1rC,GACE,eAApBukB,EAAM6D,WACNjc,EAAS,CACLygC,YAAaroB,EAAMqoB,YACnBC,iBAAkBtoB,EAAMuoB,yBACxBC,eAAgBxoB,EAAMwoB,eACtBC,UAAWzoB,EAAMgG,aAKjB0iB,UAAW1oB,EAAMe,eAAiB,GAAKf,EAAMe,eAAiBjY,KAAgBkX,EAAMe,mBAAgB5iB,QAIjHkd,aA3C0BstB,CAAuB1kB,EAAWikB,GAAYprB,KACvE8rB,EA6CD,SAAyC3kB,EAAWrc,GACvD,IAAIihC,EAAchB,KAYlB,MAAO,CAAE/qB,KAXEmH,EAAUhJ,UAAU,GAAuC,SAAUyJ,GAC5E,IAAIokB,EAAWnnC,EAAK+iB,GAAS,SAAU1E,GACnC,MAA2B,UAApBA,EAAM6D,WACM,2BAAf7D,EAAM1c,MACN0c,EAAMC,UAAY4oB,EAAY5gC,WAC9B+X,EAAMC,UAAY8nB,MAEtBe,GACAlhC,EAASkhC,EAAS7oB,cAEvB5E,aAzDmB0tB,CAAgC9kB,GAAW,SAAU+kB,GACvE,OAAOd,EAAW,CAAEc,qBAAsBA,OAC3ClsB,KACCmsB,EA+DD,SAA2ChlB,EAAW3H,EAAa1U,GACtE,IAAIihC,EAAchB,KAIdqB,EAA4Bjc,EAAAA,EAC5Bkc,EAAoB3sB,GAAkBF,EAAa,CAAC,cAAkC,YAA2B,SAAUnR,GAC3H+9B,EAA4B/9B,EAAMlD,YACnC,CAAE0U,SAAS,EAAMD,MAAM,IAAQI,KAC9BssB,EAAuBnlB,EAAUhJ,UAAU,GAAuC,SAAUyJ,GAC5F,IAAI2kB,EpEoEL,SAAkB9nC,EAAOK,GAC5B,IAAK,IAAI/E,EAAI0E,EAAM5F,OAAS,EAAGkB,GAAK,EAAGA,GAAK,EAAG,CAC3C,IAAI4E,EAAOF,EAAM1E,GACjB,GAAI+E,EAAUH,EAAM5E,EAAG0E,GACnB,OAAOE,GoExEI6nC,CAAS5kB,GAAS,SAAU1E,GACvC,MAA2B,6BAApBA,EAAM6D,WACT7D,EAAMC,UAAYipB,GAClBlpB,EAAMC,UAAY4oB,EAAY5gC,WAC9B+X,EAAMC,UAAY8nB,MAEtBsB,GACAzhC,EAASyhC,EAASppB,cAEvB5E,YACH,MAAO,CACHyB,KAAM,WACFqsB,IACAC,MAtFcG,CAAkCtlB,EAAWphB,QAAQ,SAAU2mC,GACjFtB,EAAW,CACPsB,uBAAwBA,OAE7B1sB,KACC2sB,EA6FD,SAAgCxlB,EAAWrc,GAC9C,IAAIihC,EAAchB,KAelB,MAAO,CACH/qB,KAfOmH,EAAUhJ,UAAU,GAAuC,SAAUyJ,GAC5E,IAAIglB,EAAkB/nC,EAAK+iB,GAAS,SAAU1E,GAC1C,MAA2B,gBAApBA,EAAM6D,WAA+B7D,EAAMC,UAAY4oB,EAAY5gC,aAE9E,GAAIyhC,EAAiB,CACjB,IAAIC,EAAkB1gC,GAAQygC,EAAgBzpB,UAAWypB,EAAgBlkB,iBACzE5d,EAAS,CAGL+hC,gBAAiBA,GAAmB,EAAIA,EAAkB,EAC1DC,eAAgBF,EAAgBzpB,gBAGzC5E,aA5GmBwuB,CAAuB5lB,GAAW,SAAUnjB,GAE9DonC,EAAW,CACPyB,gBAFkB7oC,EAAG6oC,gBAGrBC,eAHuD9oC,EAAG8oC,oBAK/D9sB,KACH,MAAO,CACHA,KAAM,WACFsrB,IACAQ,IACAK,IACAQ,MC7BL,SAASK,GAAiB7lB,EAAWkQ,EAAuBrhB,EAAei3B,EAAoBC,EAAaC,GAC/G,IAKIC,EALAC,EAAc,GACdrpC,EAwBR,SAA0BmjB,EAAWkQ,EAAuBrhB,EAAes3B,EAAUH,EAAWriC,GAC5F,IAAIyiC,EAAqC,iBAAbD,EACxBE,GAAkC,EAClCC,EAAwB,GAC5B,SAASC,KACAF,IAAoCD,GAAyBE,EAAsB5uC,OAAS,GAC7FiM,EAASrI,KAAK+sB,IAAItwB,MAAMuD,KAAMgrC,IAYtC,MAAO,CACHztB,KAVOoX,GAAoBjQ,EAAWkQ,EAAuBrhB,GAAe,SAAU3H,GAClFm/B,IACAA,GAAkC,EAC9Bn/B,EAAMkqB,aACNkV,EAAsB7oC,KAAKuH,GAAQghC,EAAUhiC,UAAWkD,EAAMhC,MAElEqhC,QAEL1tB,KAGC2tB,aAAc,SAAUhC,GAChB4B,IACAA,GAAwB,EACxBE,EAAsB7oC,KAAK+mC,GAC3B+B,OAhDHE,CAAiBzmB,EAAWkQ,EAAuBrhB,EAAek3B,EAAaC,GAAW,SAAUU,GACzGR,EAAYS,YAAcD,EAC1BZ,OACAc,EAA0B/pC,EAAGgc,KAAM2tB,EAAe3pC,EAAG2pC,aAYzD,OAmGO7mB,GAA8B,iBA5GjCumB,EAAYW,sBAAwB,EACnCZ,EA+DT,SAAoCjmB,EAAWrc,GAC3C,IAAImjC,EAAc,EACdloC,EAiBR,WACI,IACIod,EACAqN,EAFAntB,EAAQ,EAGZ,MAAO,CACH6qC,OAAQ,SAAUhrB,QAC4B7hB,IAAd8hB,GACxBD,EAAMC,UAAYqN,GAAW3vB,GAC7BqiB,EAAMC,UAAYA,GAAa,KAE/BA,EAAYqN,EAAUtN,EAAMC,UAC5B9f,EAAQ6f,EAAM7f,QAGdA,GAAS6f,EAAM7f,MACfmtB,EAAUtN,EAAMC,YAGxB9f,MAAO,WAAc,OAAOA,IAnCnB8qC,GAab,MAAO,CACHnuB,KAbOmH,EAAUhJ,UAAU,GAAuC,SAAUyJ,GAC5E,IAAK,IAAIjpB,EAAK,EAAG0rC,EAAYziB,EAASjpB,EAAK0rC,EAAUxrC,OAAQF,IAAM,CAC/D,IAAIukB,EAAQmnB,EAAU1rC,GACE,iBAApBukB,EAAM6D,WAAiC7D,EAAMkrB,iBAC7CroC,EAAOmoC,OAAOhrB,GACVnd,EAAO1C,QAAU4qC,IACjBA,EAAcloC,EAAO1C,QACrByH,EAAS/H,EAAMkrC,EAAa,UAIzC1vB,aA7EoB8vB,CAA2BlnB,GAAW,SAAU6mB,GAC/DX,EAAYW,sBAAwBA,EACpCf,OACDjtB,MAGHotB,EAAkBjqC,EAEf,CACH6c,KAAM,WACF+tB,IACAX,KAEJO,aAAcA,EACdN,YAAaA,GCpBd,SAASiB,GAAW9/B,EAAU2Y,EAAWkQ,EAAuBrhB,EAAeu4B,EAA0BC,EAA8BC,GAC1I,IAGIC,EAHA1qC,EAOJ,SAA0B/C,GACtB,IAAI0tC,EAAcC,GAAQznB,EAAWkQ,EAAuBrhB,EAAexH,EAAU,eAAmCtC,KAAgBjL,GACpI+e,EAAOkrB,GAAwB/jB,GAAW,SAAUgkB,GACpDwD,EAAYE,cAAc1D,GAC1BwD,EAAYG,oBACb9uB,KACH,MAAO,CAAE2uB,YAAaA,EAAa3uB,KAAMA,GAbpC+uB,CAAiBN,GAAqBO,EAA0BhrC,EAAGgc,KACxEivB,EAD4FjrC,EAAG2qC,YAE/FO,EAgBJ,WACI/nB,EAAUhJ,UAAU,GAAyB,WAEzC8wB,EAAY5iC,MAEZ4iC,EAAcE,OAAgB9tC,EAAW,CACrCmF,KAAMyoC,EAAYzoC,KAClB0P,QAAS+4B,EAAY/4B,QACrBC,QAAS84B,EAAY94B,aAI7BgR,EAAUhJ,UAAU,GAAqB,SAAUixB,GAClB,kBAAzBA,EAAcrK,SACdkK,EAAY5iC,MACZ4iC,EAAYI,oBAIpB,IAAIC,EAAoBvpC,OAAOuqB,YAAY/vB,GAAQ,WAC/C0uC,EAAYI,mBAxCiB,KA0CjC,MAAO,CACHrvB,KAAM,WACF+Q,cAAcue,KAxCFC,GAAqBvvB,KAa7C,SAASmvB,EAAgB/9B,EAAao+B,GAClC,OAAOZ,GAAQznB,EAAWkQ,EAAuBrhB,EAAexH,EAAU,eAAmC4C,EAAao+B,GAyC9H,OArDIhB,IACAE,EAyCJ,SAAmCH,GAC/B,OAAOA,EAAyBpwB,WAAU,SAAUna,GAChD,IAsHkByrC,EAAiBC,EAtH/BC,EAAc3rC,EAAG2rC,YAAaC,EAAc5rC,EAAG4rC,YACnD,GAqHmCF,EArHGE,GAqHpBH,EArHOE,GAsHThtB,WAAa+sB,EAAc/sB,WAIvD,SAAwBktB,GACpB,IAAIC,EAAkBD,EAAKE,OAAO,GAClC,QAASziC,SAAS4uB,eAAe4T,GAL3BE,CAAeN,EAAcG,OAC3BI,GAAgBP,EAAcG,QAAUI,GAAgBR,EAAgBI,MApHpE,OAHAZ,EAAY5iC,MACZ4iC,EAAYI,qBACZJ,EAAcE,QA/COe,CAA0B3B,IAoDpD,CACH4B,UAAW,SAAU3pC,EAAM4pC,QACV,IAATA,IAAmBA,EAAOrkC,KAC9BkjC,EAAYkB,UAAU3pC,EAAM4pC,GAC5BnB,EAAYH,kBAEhBuB,UAAW,SAAUpvC,EAASmQ,GAC1B69B,EAAY5iC,IAAI+E,GAChB69B,EAAYI,gBACZJ,EAAcE,EAAgB/9B,EAAanQ,IAE/C+e,KAAM,WAC6B,OAA/B0uB,QAAsE,IAA/BA,GAAiDA,EAA2BnwB,cACnHywB,IACAE,IACAD,EAAY5iC,QAIxB,SAASuiC,GAAQznB,EAAWkQ,EAAuBrhB,EAAes6B,EAAiBpD,EAAa97B,EAAao+B,QACrF,IAAhBp+B,IAA0BA,EAAcnF,MAE5C,IAIIw2B,EAEAj8B,EACA0P,EACAC,EARAkX,EAAK/qB,IACL6oC,EAAU,GACVoF,EAAgB,GAChBC,EAAkB,EAElBhiC,EAAWpM,EAAakuC,GAIxBd,IACAhpC,EAAOgpC,EAAYhpC,KACnB0P,EAAUs5B,EAAYt5B,QACtBC,EAAUq5B,EAAYr5B,SAE1BgR,EAAU1I,OAAO,EAAsB,CACnC4O,GAAIA,EACJ7mB,KAAMA,EACN4K,YAAaA,EACb8E,QAASA,EACTC,QAASA,IAGb,IAAInS,EAAKjD,EAASR,EAAQkwC,GAxGW,IAwGsC,CACvEnvC,SAAS,IACT2rC,EAAqBjpC,EAAGtC,UAAWgvC,EAA2B1sC,EAAGnC,OACjE4V,EAAKu1B,GAAiB7lB,EAAWkQ,EAAuBrhB,EAAei3B,EAAoBC,EAAa97B,GAAcu8B,EAAel2B,EAAGk2B,aAAcgD,EAA0Bl5B,EAAGuI,KAAMqtB,EAAc51B,EAAG41B,YAC1M31B,EC/FD,SAA8ByP,EAAWypB,EAAQja,GACpD,IAAI3yB,EAAKyyB,GAAiB,CACtBtP,UAAWA,EACXuP,aAAc,SAAUroB,GAAS,OAAOA,EAAMif,KAAKD,KAAOujB,GAC1Dja,SAAUA,IACV3W,EAAOhc,EAAGgc,KACd,MAAO,CACH6wB,aAAc,WACVjvC,WAAWrB,EAAQyf,GAT0B,MAWjD4W,YAL8B5yB,EAAG4yB,aD0F5Bka,CAAqB3pB,EAAWkG,EAAI4f,GAAqB8D,EAAkCr5B,EAAGm5B,aAAcja,EAAclf,EAAGkf,YAGtI,SAAS6Z,IACLD,GAAmB,EACnB,IAAIQ,OAA2B3vC,IAAdohC,EAA0B12B,IAAiB02B,EAAUt3B,UACtEgc,EAAU1I,OAAO,EAAsB,EAAO,CAC1C8xB,cAAeA,EACfC,gBAAiBA,EACjBnjB,GAAIA,EACJ7mB,KAAMA,EACN0P,QAASA,EACTC,QAASA,EACT+2B,YAAaA,EACb1+B,SAAUA,EACV4C,YAAaA,EACb+5B,QAASA,EACTr/B,SAAUK,GAAQiF,EAAYjG,UAAW6lC,GACzCC,cAAwB5vC,IAAdohC,EACV7L,YAAaA,GACdyW,IAEP,OApBAoD,IAoBO,CACHjqC,KAAMA,EACN0P,QAASA,EACTC,QAASA,EACT24B,eAAgB7B,EAChB5gC,IAAK,SAAU6kC,QACI,IAAXA,IAAqBA,EAASjlC,MAClCw2B,EAAYyO,EACZ/pB,EAAU1I,OAAO,EAAoB,CAAEgkB,UAAWA,IAClDkO,IACAI,KAEJ1B,cAAe,WAEXqB,IACAD,KAEJ5B,cAAe,SAAUxD,GACrBF,EAAUE,OACmBhqC,IAAzBgqC,EAAWM,WACXgC,EAAatC,EAAWM,YAGhCwE,UAAW,SAAU3pC,EAAM4pC,GACvB,IAAI/kC,EnElGT,SAA+B+kC,GAClC,OAAOA,EHvDW,QsEwJSe,CAAsBf,GAAQA,EAAOjkC,GAAQiF,EAAYjG,UAAWilC,GACvFG,EAOZ,SAAwB/pC,GACpB,IAAI4qC,EAAY5qC,EAAK5D,QAAQ,qBAAsB,KAC/CwuC,IAAc5qC,GACdhI,EAAQF,KAAK,wBAAwB6B,OAAOqG,EAAM,oBAAoBrG,OAAOixC,IAEjF,OAAOA,EAZeC,CAAe7qC,IAAS6E,IAuBlD,SAAS4kC,GAAgBJ,GACrB,IAAIpf,EAAQof,EAAKvrC,QAAQ,KACzB,OAAOmsB,EAAQ,EAAIof,EAAOA,EAAK3vC,MAAM,EAAGuwB,GEtLrC,SAAS6gB,GAAoBnqB,EAAWnR,EAAexH,EAAU6oB,EAAuBkX,EAA0B7K,EAAoB0D,EAAqB1pB,EAAa+wB,GAI3K,OAHAtnB,EAAUhJ,UAAU,GAAsB,SAAUmP,GAChD,OAAOnG,EAAU1I,OAAO,GAIhC,SAA2B6O,EAAMoW,EAAoB0D,EAAqB1pB,GACtE,IAAI6zB,EAAc7zB,EAAY8zB,eAAelkB,EAAKD,IAC9Cua,EAAqBR,EAAoBS,2BAA2Bva,EAAKlc,YAAYlG,UACrFumC,EAAY,CACZ1wB,IAAK,CACD2wB,iBAAkBpkB,EAAKkjB,gBACvBmB,aAAcJ,GAElBzkC,KAAMwgB,EAAKlc,YAAYjG,UACvBsG,KAAM,OACN6b,KAAM,CACFE,OAAQ,CACJnY,MAAOiY,EAAKsJ,YAAYI,aAE5BE,YAAa,CACT7hB,MAAOiY,EAAKsJ,YAAYK,kBAE5B2a,wBAAyBtkB,EAAK0gB,sBAC9B3pB,WAAYxY,EAAiByhB,EAAK6d,QAAQS,WAC1CiG,aAAchmC,EAAiByhB,EAAK6d,QAAQI,aAC5CuG,mBAAoBjmC,EAAiByhB,EAAK6d,QAAQK,kBAClDuG,gBAAiBlmC,EAAiByhB,EAAK6d,QAAQO,gBAC/CntC,MAAO,CACH8W,MAAOiY,EAAKsJ,YAAYC,YAE5Bmb,uBAAwBnmC,EAAiByhB,EAAK6d,QAAQe,sBACtD+F,kBAAmBpmC,EAAiByhB,EAAK6d,QAAQ0B,iBACjDqF,iBAAkBrmC,EAAiByhB,EAAK6d,QAAQ2B,gBAChDqF,UAAW7kB,EAAK2jB,SAChBzqC,KAAM8mB,EAAK9mB,KACX4rC,yBAA0BvmC,EAAiByhB,EAAK6d,QAAQuB,wBACxD2F,WAAYxmC,EAAiByhB,EAAK6d,QAAQQ,WAC1C9H,aAAcyO,GAAwBzmC,EAAiByhB,EAAKwgB,cAC5DyE,aAAcjlB,EAAK4f,YACnBpJ,UAAW,CACPzuB,MAAOiY,EAAKsJ,YAAYE,eAE5BiN,SAAU,CACN1uB,MAAOiY,EAAKsJ,YAAYG,eAE5Byb,WAAY3mC,EAAiByhB,EAAKxhB,UAClC2mC,sBAAuB/O,EAAmBzU,6BAA6B3B,EAAKlc,YAAYlG,SAAUoiB,EAAKxhB,WAE3Gg8B,cAAeF,IAAuBviC,EAAcuiC,GAAsBA,OAAqBvmC,EAC/FurB,QAAS,CACLe,aAAY4jB,QAAqBlwC,IAGpCgE,EAAcioB,EAAKijB,iBACpBkB,EAAUnkB,KAAKolB,exE8HhB,SAAmBrwC,EAAQjD,GAE9B,IADA,IAAIuzC,EAAY,GACPh0C,EAAK,EAAGqF,EAAKlF,OAAOoG,KAAK7C,GAAS1D,EAAKqF,EAAGnF,OAAQF,IAAM,CAC7D,IAAIwD,EAAM6B,EAAGrF,GACbg0C,EAAUxwC,GAAO/C,EAAGiD,EAAOF,IAE/B,OAAOwwC,EwEpI6BC,CAAUtlB,EAAKijB,cAAe1kC,IAElE,MAAO,CACHugB,YAAaqlB,EACbtuB,UAAWmK,EAAKlc,YAAYlG,SAC5BmhB,cAAe,CACX7d,SAAU8e,EAAK9e,WA3DuCqkC,CAAkBvlB,EAAMoW,EAAoB0D,EAAqB1pB,OAExH4wB,GAAW9/B,EAAU2Y,EAAWkQ,EAAuBrhB,EAAeu4B,GAA2Bv4B,EAAcgH,mBAAoByxB,GA6D9I,SAAS6D,GAAwBxmC,GAC7B,OAAO9G,EAAS8G,IAAaA,EAAW,OAAIzK,EAAYyK,EC9D5D,IAOIgnC,GAPAC,GAAuB,0BACvBC,GAA0B,IACnBC,GAAsB,QAI7BC,GAAqB,GAElB,SAASC,GAAqBC,EAAYC,GAC7C,IAAIrvC,EAKJ,QAJwB,IAApBqvC,IAA8BA,EAAkB,GAC/CP,KACDA,GAAoBM,GAEpBA,IAAeN,GAInB,GAAIO,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,EAAWnyC,UAEtCuyC,EAAiBC,MACEE,OAASJ,EAExB,YADAK,GAAWR,EAAYC,GAI/B,IAAIS,EAAmBV,EAAWW,QAAQP,GAC1C,GAAIE,OAEAF,EAAiBC,MACEE,OAASJ,EACxBK,GAAWR,EAAYC,OAJ/B,CAWA,GAHIS,GACAE,GAAeF,EAAkBV,EAAWnyC,SAE5CyyC,QAGMI,IAAoBG,GAAeH,IAAoB,CAGzD,IADAN,EAAiBC,MACEE,OAASJ,EAExB,YADAK,GAAWR,EAAYC,UAGpBG,EAAeG,KACtBE,GAAWL,EAAgBJ,EAAWnyC,SACtC6yC,EAAmBN,EAKC,QAA3BxvC,EAAKovC,EAAW5hB,aAA0B,IAAPxtB,GAAyBA,EAAG/E,KAAKm0C,EAAYU,GAAoBN,GACrGF,WAxDIJ,GAAmBtuC,KAAKwuC,GA8DhC,SAASM,KACL,QrBhFS3tC,OAAOmuC,QAAU,iBAAiBjrC,KAAKlD,OAAOouC,UAAUC,WqBkFrE,SAASR,GAAWR,EAAYiB,GAC5BzyC,WAAWrB,GAAQ,WACf4yC,GAAqBC,EAAYiB,EAAyB,MA9EpC,IAiF9B,SAASf,KACLR,QAAoBzxC,EACpB,IAAIizC,EAAiBpB,GAAmBqB,QACpCD,GACAnB,GAAqBmB,GAGtB,SAASN,GAAepnB,EAAS3rB,GAChCgzC,GAAernB,GAwCvB,SAAsB3rB,GAClB2L,GAAUqmC,GAAqB,GAAI,EAAGhyC,GAxClCuzC,CAAavzC,IAGjB2rB,EAAQ6nB,OAASnlC,OAAO/D,IAAY0kB,IACpC4jB,GAAWjnB,EAAS3rB,IAExB,SAAS4yC,GAAWjnB,EAAS3rB,GACzB2L,GAAUqmC,GAEP,SAAyBrmB,GAC5B,OAAO,EACYA,GACdznB,KAAI,SAAUnB,GACf,IAAI7B,EAAM6B,EAAG,GAAIX,EAAQW,EAAG,GAC5B,MAAO,GAAG7D,OAAOgC,EAAK,KAAKhC,OAAOkD,MAEjC+E,KAAK4qC,IATqB0B,CAAgB9nB,GAAUqD,GAA0BhvB,GAWhF,SAASwyC,KACZ,IAAIkB,EAAgBnnC,GAAUylC,IAC1BrmB,EAAU,GAUd,OAEJ,SAA8B+nB,GAC1B,YAA0BtzC,IAAlBszC,KACiD,IAApDA,EAAcrwC,QAAQ0uC,KAAmCD,GAAqB9pC,KAAK0rC,IAbpFC,CAAqBD,IACrBA,EAAcplC,MAAMyjC,IAAyB/wC,SAAQ,SAAUihB,GAC3D,IAAIzc,EAAUssC,GAAqBpsC,KAAKuc,GACxC,GAAgB,OAAZzc,EAAkB,CAClB,IAAItE,EAAMsE,EAAQ,GAAIpD,EAAQoD,EAAQ,GACtCmmB,EAAQzqB,GAAOkB,MAIpBupB,EAMX,SAASqnB,GAAernB,GACpB,OAAO,EAAoBA,GC5HxB,SAASioB,GAAkB5zC,EAAS6zC,EAAYC,GACnD,IAAIC,EAAkB,IAAIh3B,GACtBi3B,EAAmB,IAAIj3B,GACvBk3B,EAAwB5kB,YAAY/vB,GA8BxC,WACI4yC,GAAqB,CACjBlyC,QAASA,EACT8yC,QAAS,SAAUoB,GAAiB,OAASC,EAAgBD,QAAsB9zC,EAAL,IAC9EmwB,MAAO6jB,OtEhDcx0C,KsEezBy0C,EAyEJ,WACI,IAAI1oB,EAAU6mB,KACd,GAAI2B,EAAgBxoB,GAChB,OAAOA,EAEX,MAAO,GA9EQ2oB,GAoCnB,SAASF,EAAmBF,GAYxB,OAXKC,EAAgBD,KACjBA,EAAgB,IAEhBK,OAsBR,SAAkCL,GAC9B,OAAOG,EAAajoB,KAAO8nB,EAAc9nB,IAAMioB,EAAaR,KAAgBK,EAAcL,GAtBlFW,CAAyBN,GAIzBG,EAAeH,GAqBvBG,EAAe,GACfL,EAAiBx2B,WAnBV02B,EAWX,SAASK,IACL,YAAoCn0C,IAA7Bi0C,EAAaR,GAoBxB,SAASM,EAAgBxoB,GAGrB,YAA6BvrB,IAApBurB,EAAQ8oB,SAAyBnqC,IAAYmb,OAAOkG,EAAQ8oB,SAAW1lB,WACxD3uB,IAAnBurB,EAAQ6nB,QAAwBlpC,IAAYmb,OAAOkG,EAAQ6nB,SAEpE,MAAO,CACHkB,qBAAsB,EAAep1C,GAtFzC,WACI,IAAIq1C,EACJzC,GAAqB,CACjBlyC,QAASA,EACT8yC,QAAS,SAAUoB,GACf,IAAIU,EAAsBR,EAAmBF,GAE7C,OADAS,EA2CZ,SAA6BT,GACzB,IAAInxC,EAAK+wC,EAAoBI,EAAcL,IAAcgB,EAAe9xC,EAAG8xC,aAAcF,EAAY5xC,EAAG4xC,UACxGT,EAAcL,GAAcgB,EACxBF,IAAcT,EAAc9nB,KAC5B8nB,EAAc9nB,GAAK,IACnB8nB,EAAcO,QAAUpmC,OAAO/D,MAEnC,OAAOqqC,EAlDaG,CAAoBF,GACzBA,GAEXrkB,MAAO,SAAU2jB,GACTS,IAAcJ,KA0D9B,SAAsBL,GAClBG,EAAeH,EACfH,EAAgBv2B,SA3DJu3B,CAAab,GAEjBG,EAAeH,QtE7BEt0C,KsEsGgEa,UACzFu0C,cAtEJ,WACI9C,GAAqB,CACjBlyC,QAASA,EACT8yC,QAAS,SAAUoB,GAAiB,OAAQK,IAAsBH,EAAmBF,QAAiB9zC,MAoE1G60C,WAAY,WAAc,OAAOZ,GACjCN,gBAAiBA,EACjBC,iBAAkBA,EAClBj1B,KAAM,WACF+Q,cAAcmkB,KCtGnB,IAEHiB,GAAgB,GACb,SAASC,GAAoBn1C,EAAS6zC,EAAYC,ICClD,SAAgC9zC,GACnC,IAAI0zC,EAAgBnnC,GAAUylC,IAC1BoD,EAAe7oC,GAZc,OAa7B8oC,EAAa9oC,GAZY,SAazB+oC,EAAc/oC,GAZY,SAa9B,IAAKmnC,EAAe,CAChB,IAAI/nB,EAAU,GACVypB,IACAzpB,EAAQS,GAAKgpB,GAEbE,GAAe,SAASttC,KAAKstC,KAC7B3pB,EAAwB,KAAI2pB,GAE5BD,GAAc,UAAUrtC,KAAKqtC,KAC7B1pB,EAAuB,IAAI0pB,GAE/BtC,GAAepnB,EAAS3rB,IDhB5Bu1C,CAAuBv1C,GACvB,IAAIw1C,EAAe5B,GAAkB5zC,EAAS6zC,EAAYC,GAC1DoB,GAAcvxC,MAAK,WAAc,OAAO6xC,EAAaz2B,UACrD,IAAI02B,EAAwB,IAAItmB,GANAJ,OAkBhC,SAAS2mB,IACL,MAAO,CACHtpB,GAAIopB,EAAaP,aAAa7oB,GAC9ByoB,aAAcW,EAAaP,aAAapB,IAGhD,OAjBAqB,GAAcvxC,MAAK,WAAc,OAAO8xC,EAAsB12B,UAC9Dy2B,EAAazB,gBAAgB72B,WAAU,WACnCu4B,EAAsBhvC,IAAIivC,IAAuB3qC,SAErDyqC,EAAaxB,iBAAiB92B,WAAU,WACpCu4B,EAAsB/lB,YAAY3kB,SAEtCyqC,EAAad,uBACbe,EAAsBhvC,IAAIivC,IAAuBzqC,KAAehB,UAmBpE,SAAuByqC,GACnB,IAAI31B,EAAON,GAAkB3Z,OAAQ,CAAC,QAAqB,aAAgC,UAA0B,UAAwB4vC,EAAsB,CAAE91B,SAAS,EAAMC,SAAS,IAAQE,KACrMm2B,GAAcvxC,KAAKob,GApBnB42B,EAAc,WAAc,OAAOH,EAAad,0BAsBpD,SAAyBM,GACrB,IAAIY,EAA2Bt2C,GAAQ,WACF,YAA7B+M,SAAS09B,iBACTiL,OAGJj2B,EAAOT,GAAiBjS,SAAU,mBAA4CupC,GAA0B72B,KAC5Gm2B,GAAcvxC,KAAKob,GACnB,IAAI82B,EAA0BxmB,YAAYumB,EA/CV,KAgDhCV,GAAcvxC,MAAK,WACfmsB,cAAc+lB,MA/BlBC,EAAgB,WAAc,OAAON,EAAaR,mBAO3C,CACHe,kBAAmB,SAAU7zB,GAAa,OAAOuzB,EAAsB7xC,KAAKse,IAC5E6xB,gBAAiByB,EAAazB,gBAC9BC,iBAAkBwB,EAAaxB,kBElChC,SAASgC,GAAuBjhC,EAAemR,GAClD,IAAIvN,EAAiBw8B,GAAoBpgC,EAAcoC,cAF9B,OAE8D,SAAU8+B,GAC7F,OA8CR,SAA6BlhC,EAAekhC,GACxC,IAAIpB,EAWAA,EAOR,SAA4BA,GACxB,MAAyB,MAAjBA,GACa,MAAjBA,GACiB,MAAjBA,EApBAqB,CAAmBD,GACJA,EAETr0C,EAAYmT,EAAc2B,mBAG1B9U,EAAYmT,EAAc4F,yBAIjB,IAHA,IAHA,IAQnB,MAAO,CACHk6B,aAAcA,EACdF,UAAWwB,GAActB,IA9DlBf,CAAoB/+B,EAAekhC,MAQ9C,OANAt9B,EAAeq7B,iBAAiB92B,WAAU,WACtCgJ,EAAU1I,OAAO,MAErB7E,EAAeo7B,gBAAgB72B,WAAU,WACrCgJ,EAAU1I,OAAO,MAEd,CACH1E,mBAAoB,SAAUoJ,GAC1B,IAAIyJ,EAAUhT,EAAeo9B,kBAAkB7zB,GAC/C,GAAKyJ,GAAYwqB,GAAcxqB,EAAQkpB,cAAvC,CAGA,IAAI5oB,EAAgC,MAAzBN,EAAQkpB,aACb,EACA,EACN,MAAO,CACHzoB,GAAIT,EAAQS,GACZH,KAAMA,EACNmqB,qBAA+B,IAATnqB,EACtBoqB,qBAAkDj2C,IAAjC2U,EAAckH,eACzBlH,EAAckH,eACdlH,EAAc+G,kBAA6B,IAATmQ,EACxCyd,qBAAkDtpC,IAAjC2U,EAAciH,eACzBjH,EAAciH,eACdjH,EAAc+G,kBAA6B,IAATmQ,MA4CxD,SAASkqB,GAAcG,GACnB,MAA2B,MAAnBA,GACe,MAAnBA,ECxER,IAAIC,GAAuB,WACvB,SAASA,EAAM1f,EAASnf,EAAoBJ,EAAiBK,EAAmBF,EAAc++B,GAC1F,IAAIp5B,EAAQ5d,KACZA,KAAKq3B,QAAUA,EACfr3B,KAAKkY,mBAAqBA,EAC1BlY,KAAK8X,gBAAkBA,EACvB9X,KAAKmY,kBAAoBA,EACzBnY,KAAKiY,aAAeA,EACpBjY,KAAKg3C,mBAAqBA,EAC1Bh3C,KAAKi3C,gBAAkB,IAAI15B,GAC3Bvd,KAAKk3C,eAAiB,GACtBl3C,KAAKm3C,aAAe,GACpBn3C,KAAKo3C,iBAAmB,EACxBp3C,KAAKq3C,oBAAsB,EAC3BL,EAAmBt5B,WAAU,WAAc,OAAOE,EAAM05B,MAAM15B,EAAMyZ,QAAQkgB,eAC5Ev3C,KAAKw3C,oBAuFT,OArFAT,EAAMz4C,UAAU2I,IAAM,SAAUiJ,GAC5BlQ,KAAKy3C,YAAYvnC,IAErB6mC,EAAMz4C,UAAUo5C,OAAS,SAAUxnC,EAASxO,GACxC1B,KAAKy3C,YAAYvnC,EAASxO,IAE9Bq1C,EAAMz4C,UAAUg5C,MAAQ,SAAUK,GAE9B,QADe,IAAXA,IAAqBA,EAAS33C,KAAKq3B,QAAQ3pB,MACd,IAA7B1N,KAAKq3C,oBAA2B,CAChC,IAAIO,EAAW53C,KAAKk3C,eAAex3C,OAAO8E,EAAaxE,KAAKm3C,eACxDU,EAAa73C,KAAKo3C,iBACtBp3C,KAAKi3C,gBAAgBj5B,OAAO,CACxBo5B,iBAAkBp3C,KAAKo3C,iBACvBC,oBAAqBr3C,KAAKq3C,sBAE9Br3C,KAAKk3C,eAAiB,GACtBl3C,KAAKm3C,aAAe,GACpBn3C,KAAKo3C,iBAAmB,EACxBp3C,KAAKq3C,oBAAsB,EAC3BM,EAAO,CAAE15B,KAAM25B,EAASjwC,KAAK,MAAOkwC,WAAYA,MAGxDd,EAAMz4C,UAAUm5C,YAAc,SAAUvnC,EAASxO,GAC7C,IAAI6B,EAAKvD,KAAKszC,QAAQpjC,GAAU4nC,EAAmBv0C,EAAGu0C,iBAAkBC,EAAoBx0C,EAAGw0C,kBAC3FA,GAAqB/3C,KAAKmY,kBAC1Bpa,EAAQF,KAAK,2EAA2E6B,OAAOM,KAAKmY,kBAAmB,SAGvHnY,KAAKg4C,cAAct2C,IACnB1B,KAAKyJ,OAAO/H,GAEZ1B,KAAKi4C,0BAA0BF,IAC/B/3C,KAAKs3C,QAETt3C,KAAKmE,KAAK2zC,EAAkBC,EAAmBr2C,GAC3C1B,KAAKk4C,UACLl4C,KAAKs3C,UAGbP,EAAMz4C,UAAUg1C,QAAU,SAAUpjC,GAChC,IAAI4nC,EAAmBn1C,EAAcuN,GAErC,MAAO,CAAE4nC,iBAAkBA,EAAkBC,kBADrB/uC,EAAkB8uC,KAG9Cf,EAAMz4C,UAAU6F,KAAO,SAAU2zC,EAAkBC,EAAmBr2C,GAC9D1B,KAAKq3C,oBAAsB,IAE3Br3C,KAAKo3C,kBAAoB,QAEjBx2C,IAARc,EACA1B,KAAKm3C,aAAaz1C,GAAOo2C,EAGzB93C,KAAKk3C,eAAe/yC,KAAK2zC,GAE7B93C,KAAKo3C,kBAAoBW,EACzB/3C,KAAKq3C,qBAAuB,GAEhCN,EAAMz4C,UAAUmL,OAAS,SAAU/H,GAC/B,IAAIy2C,EAAiBn4C,KAAKm3C,aAAaz1C,UAChC1B,KAAKm3C,aAAaz1C,GACzB,IAAIq2C,EAAoB/uC,EAAkBmvC,GAC1Cn4C,KAAKo3C,kBAAoBW,EACzB/3C,KAAKq3C,qBAAuB,EACxBr3C,KAAKq3C,oBAAsB,IAC3Br3C,KAAKo3C,kBAAoB,IAGjCL,EAAMz4C,UAAU05C,cAAgB,SAAUt2C,GACtC,YAAed,IAARc,QAAgDd,IAA3BZ,KAAKm3C,aAAaz1C,IAElDq1C,EAAMz4C,UAAU25C,0BAA4B,SAAUF,GAElD,OAAO/3C,KAAKo3C,iBAAmBW,EAAoB,GAAK/3C,KAAK8X,iBAEjEi/B,EAAMz4C,UAAU45C,OAAS,WACrB,OAAOl4C,KAAKq3C,sBAAwBr3C,KAAKkY,oBAAsBlY,KAAKo3C,kBAAoBp3C,KAAK8X,iBAEjGi/B,EAAMz4C,UAAUk5C,kBAAoB,WAChC,IAAI55B,EAAQ5d,KACZmB,WAAWrB,GAAQ,WACf8d,EAAM05B,QACN15B,EAAM45B,uBACNx3C,KAAKiY,eAEN8+B,EAtGe,GCEfqB,GAAwB,QAG5B,SAASC,GAAsBh7B,EAAS2U,EAAOsmB,EAAc/kC,EAAc4X,GAChD,IAA1B6G,EAAMumB,iBAC0B,IAAhCvmB,EAAMwmB,eAAepvC,QACrB4oB,EAAMymB,iBAAiBC,UAAUr7B,GACjC3P,GAAK2P,EAAS2U,EAAOsmB,EAAc,CAC/BK,UAAW,WAAc,OAAOC,GAAoB,EAAuB5mB,EAAOsmB,EAAc/kC,EAAc4X,IAC9G0tB,UAAW,WACP7mB,EAAMwmB,eAAeM,QAAQz7B,GAC7B07B,GAAc/mB,EAAOsmB,EAAc/kC,EAAc4X,MAKzD6G,EAAMwmB,eAAeM,QAAQz7B,GAGrC,SAAS07B,GAAc/mB,EAAOsmB,EAAc/kC,EAAc4X,GACxB,IAA1B6G,EAAMumB,iBAGVp3C,WAAWrB,GAAQ,WAEf4N,GADcskB,EAAMwmB,eAAetf,QACrBlH,EAAOsmB,EAAc,CAC/BK,UAAW,WACP3mB,EAAMwmB,eAAeQ,UACrBhnB,EAAMinB,mBA1BY74C,IA2BlBw4C,GAAoB,EAAsB5mB,EAAOsmB,EAAc/kC,EAAc4X,IAEjF0tB,UAAW,WACP7mB,EAAMinB,mBAAqBj3C,KAAKk3C,IA/BlB74C,IA+BmE,EAA3B2xB,EAAMinB,oBAC5DF,GAAc/mB,EAAOsmB,EAAc/kC,EAAc4X,SAGzD6G,EAAMinB,oBAEd,SAASvrC,GAAK2P,EAAS2U,EAAOsmB,EAAc/0C,GACxC,IAAIo1C,EAAYp1C,EAAGo1C,UAAWE,EAAYt1C,EAAGs1C,UAC7C7mB,EAAMymB,iBAAiBxxC,IAAIoW,GAC3Bi7B,EAAaj7B,GAAS,SAAU6V,GAC5BlB,EAAMymB,iBAAiBhvC,OAAO4T,IAgCtC,SAA4B6V,GACxB,MAA0B,WAAlBA,EAASliB,OACS,IAApBkiB,EAASra,SAAiB66B,UAAUyF,QACd,MAApBjmB,EAASra,QACW,MAApBqa,EAASra,QACTqa,EAASra,QAAU,KApClBugC,CAAmBlmB,IACpBlB,EAAMumB,gBAAkB,EACxBI,MAIA3mB,EAAMumB,gBACFvmB,EAAMymB,iBAAiBY,oBAAsB,EAAI,EAA2B,EAChFh8B,EAAQ5I,MAAQ,CACZG,MAAOyI,EAAQ5I,MAAQ4I,EAAQ5I,MAAMG,MAAQ,EAAI,EACjDC,kBAAmBqe,EAASra,QAEhCggC,QAIZ,SAASD,GAAoBtU,EAAQtS,EAAOsmB,EAAc/kC,EAAc4X,GACrD,IAAXmZ,GAAoCtS,EAAMwmB,eAAeN,WAAalmB,EAAMsnB,oBAC5EnuB,EAAY,CACRjb,QAAS,eAAexQ,OAAO6T,EAAc,oCAAoC7T,OAAO04C,EAAuC,OAC/H32C,OAAQ6O,GACRK,YAAanF,OAEjBwmB,EAAMsnB,mBAAoB,GAE9B,IAAIC,EAAgBvnB,EAAMwmB,eAE1B,IADAxmB,EAAMwmB,eAAiBgB,KAChBD,EAAcnwC,OAAS,GAC1BivC,GAAsBkB,EAAcP,UAAWhnB,EAAOsmB,EAAc/kC,EAAc4X,GAmB1F,SAASquB,KACL,IAAIC,EAAQ,GACZ,MAAO,CACH5B,WAAY,EACZiB,QAAS,SAAUz7B,GACXrd,KAAKk4C,WAGTuB,EAAMt1C,KAAKkZ,GACXrd,KAAK63C,YAAcx6B,EAAQw6B,aAE/B3e,MAAO,WACH,OAAOugB,EAAM,IAEjBT,QAAS,WACL,IAAI37B,EAAUo8B,EAAM3F,QAIpB,OAHIz2B,IACArd,KAAK63C,YAAcx6B,EAAQw6B,YAExBx6B,GAEXjU,KAAM,WACF,OAAOqwC,EAAMr7C,QAEjB85C,OAAQ,WACJ,OAAOl4C,KAAK63C,YAAcO,KCtH/B,SAASsB,GAAkBC,EAAiBnkB,EAAYrK,GAC3D,IAAIyuB,EDoFG,CACHrB,gBAAiB,EACjBU,mBAlF0B74C,IAmF1Bq4C,iBAmCG,CACHY,oBAAqB,EACrBQ,iBAAkB,EAClBnB,UAAW,SAAUr7B,GACjB,OAAqC,IAA7Brd,KAAKq5C,qBACRr5C,KAAK65C,iBAAmBx8B,EAAQw6B,YA/HZ,OAgIjB73C,KAAKq5C,oBA/HS,IAiI1BpyC,IAAK,SAAUoW,GACXrd,KAAKq5C,qBAAuB,EAC5Br5C,KAAK65C,kBAAoBx8B,EAAQw6B,YAErCpuC,OAAQ,SAAU4T,GACdrd,KAAKq5C,qBAAuB,EAC5Br5C,KAAK65C,kBAAoBx8B,EAAQw6B,aAhDrCW,eAAgBgB,KAChBF,mBAAmB,GCxFnBQ,EAAuB,SAAUz8B,EAAS08B,GAC1C,OAwCD,SAAgCJ,EAAiBnkB,EAAYjyB,EAAIw2C,GACpE,IAAI97B,EAAO1a,EAAG0a,KAAM45B,EAAat0C,EAAGs0C,WAAYpjC,EAAQlR,EAAGkR,MAE3D,GAaJ,WAEI,IACI,OAAOnP,OAAOsuB,SAAW,cAAe,IAAIA,QAAQ,YAExD,MAAOrwB,GACH,OAAO,GApBWy2C,IAA0BnC,EAAariB,EACxC,CACjB,IAAIykB,EAAWN,EAAgBnlC,MAAM,QAASC,GAC9Cie,MAAMunB,EAAU,CAAExpB,OAAQ,OAAQ5d,KAAMoL,EAAMi8B,WAAW,EAAMC,KAAM,SAAU5mB,KAAKzzB,GAAQ,SAAUozB,GAAY,OAAsB,OAAf6mB,QAAsC,IAAfA,OAAwB,EAASA,EAAW,CAAElhC,OAAQqa,EAASra,OAAQ7H,KAAMkiB,EAASliB,UAAalR,GAAQ,WAGvPs6C,GAFaT,EAAgBnlC,MAAM,MAAOC,GAE1BwJ,EAAM87B,WAGzB,CAEDK,GADaT,EAAgBnlC,MAAM,MAAOC,GAC1BwJ,EAAM87B,IArDfM,CAAuBV,EAAiBnkB,EAAYnY,EAAS08B,IAExE,MAAO,CACHrsC,KAAM,SAAU2P,GACZg7B,GAAsBh7B,EAASu8B,EAAYE,EAAsBH,EAAgBpmC,aAAc4X,IAMnGosB,WAAY,SAAUl6B,IAK9B,SAA4Bs8B,EAAiBnkB,EAAYjyB,GACrD,IAAI0a,EAAO1a,EAAG0a,KAAM45B,EAAat0C,EAAGs0C,WAEpC,GADqBnE,UAAU4G,YAAczC,EAAariB,EAEtD,IACI,IAAI+kB,EAAYZ,EAAgBnlC,MAAM,UAEtC,GADek/B,UAAU4G,WAAWC,EAAWt8B,GAE3C,OAGR,MAAO/d,IAQf,SAA2BA,GAClBs6C,KACDA,IAAyB,EACzB75B,GAAkBzgB,IAVdu6C,CAAkBv6C,GAI1Bk6C,GADaT,EAAgBnlC,MAAM,OACnByJ,GApBRy8B,CAAmBf,EAAiBnkB,EAAYnY,KAsB5D,IAAIm9B,IAAyB,EAgCtB,SAASJ,GAAQ3qC,EAAKwO,EAAM87B,GAC/B,IAAI1iB,EAAU,IAAI5F,eACdkpB,EAAY76C,GAAQ,WAGpBu3B,EAAQ9E,oBAAoB,UAAWooB,GACxB,OAAfZ,QAAsC,IAAfA,GAAiCA,EAAW,CAAElhC,OAAQwe,EAAQxe,YAEzFwe,EAAQujB,KAAK,OAAQnrC,GAAK,GAC1B4nB,EAAQvY,iBAAiB,UAAW67B,GACpCtjB,EAAQ3pB,KAAKuQ,GChFV,SAAS48B,GAActlC,EAAemR,EAAWo0B,EAA0B3vB,EAAa6rB,GAC3F,IAAI+D,EAYR,SAAsBxlC,EAAe4V,EAAa6rB,GAC9C,IACIgE,EADAC,EAAeC,EAAe3lC,EAAcQ,oBAE5CM,EAAUd,EAAcc,aACZzV,IAAZyV,IACA2kC,EAAeE,EAAe7kC,EAAQN,qBAE1C,SAASmlC,EAAevB,GACpB,OAAO,IAAI5C,GAAM2C,GAAkBC,EAAiBpkC,EAAcuC,gBAAiBqT,GAAc5V,EAAc2C,mBAAoB3C,EAAcuC,gBAAiBvC,EAAc4C,kBAAmB5C,EAAc0C,aAAc++B,GAEnO,SAASmE,EAAyBjrC,GAC9B,OAAOnI,EAAQmI,EAAS,CAAEyc,YAAa,CAAEC,GAAIvW,EAAQE,iBAEzD,MAAO,CACH0gC,gBAAiBgE,EAAahE,gBAC9BhwC,IAAK,SAAUiJ,EAASkrC,QACD,IAAfA,IAAyBA,GAAa,GAC1CH,EAAah0C,IAAIiJ,GACb8qC,GAAgBI,GAChBJ,EAAa/zC,IAAIk0C,EAAyBjrC,KAGlDwnC,OAAQ,SAAUxnC,EAASxO,GACvBu5C,EAAavD,OAAOxnC,EAASxO,GACzBs5C,GACAA,EAAatD,OAAOyD,EAAyBjrC,GAAUxO,KArCvD25C,CAAa9lC,EAAe4V,EAAa6rB,GAUrD,OATAtwB,EAAUhJ,UAAU,IAA8B,SAAU6O,GAC5B,SAAxBA,EAAevb,KACf+pC,EAAMrD,OAAOnrB,EAAgBA,EAAeM,KAAKD,IAGjDmuB,EAAM9zC,IAAIslB,MAGlBuuB,EAAyBp9B,WAAU,SAAU9P,GAAS,OAAOmtC,EAAM9zC,IAAI2G,ExDmEpE,SAAuC2H,GAC1C,Mb/E6B,gBa+EtBA,EAAcxB,KwDpEyDunC,CAA8B/lC,OACrGwlC,ECXJ,SAASQ,GAA+BxtC,GAC3C,IAAIihC,EAAkBrtC,EAAaoM,GAC/BwQ,EAAa,IAAIhB,IAAW,WAC5B,IAoCWi+B,EApCPC,EAoBZ,SAAsBC,GAClB,IAAIC,EAA6B9qB,GAAgCmP,QAAS,YAAa,CACnFjP,MAAO2qB,IACRn8B,KACCq8B,EAAgC/qB,GAAgCmP,QAAS,eAAgB,CACzFjP,MAAO2qB,IACRn8B,KACCs8B,EAAiB/8B,GAAiBxZ,OAAQ,WAA4Bo2C,GAAiBn8B,KAC3F,MAAO,CACHA,KAAM,WACFo8B,IACAC,IACAC,MAhCsBC,CAAaC,GAAkBx8B,KACrDy8B,GAmCOR,EAnCsBO,EAoC9Bj9B,GAAiBxZ,OAAQ,aAAgCk2C,IApCTj8B,KACnD,OAAO,WACHk8B,IACAO,QAGR,SAASD,IACL,GAAI/M,EAAgBh9B,OAASjE,EAASiE,KAAtC,CAGA,IAAIm9B,EAAcxtC,EAAaoM,GAC/BwQ,EAAWP,OAAO,CACdmxB,YAAaA,EACbD,YAAaF,IAEjBA,EAAkBG,GAEtB,OAAO5wB,ECrBJ,IACH09B,GACAC,GACAC,GAqCJ,SAASC,KACoC,IAArCH,GAAsBI,aAG1Bt7B,GAAkB,yBAA0Bk7B,IAC5CK,MAKJ,SAASC,GAAcC,EAAS55C,GAC5B45C,EAAQC,KAAO75C,EACf45C,EAAQtD,IAAMl3C,KAAKk3C,IAAIsD,EAAQtD,IAAKt2C,GACpC45C,EAAQztB,IAAM/sB,KAAK+sB,IAAIytB,EAAQztB,IAAKnsB,GAExC,SAAS85C,GAAap7C,EAAQG,GAC1BH,EAAOm7C,KAAOh7C,EAAOg7C,IACrBn7C,EAAO43C,IAAMl3C,KAAKk3C,IAAI53C,EAAO43C,IAAKz3C,EAAOy3C,KACzC53C,EAAOytB,IAAM/sB,KAAK+sB,IAAIztB,EAAOytB,IAAKttB,EAAOstB,KAE7C,SAASutB,KACLL,GAAwB,CACpBI,WAAY,EACZM,gBAfG,CAAEzD,IAAKxpB,EAAAA,EAAUX,IAAK,EAAG0tB,IAAK,GAgBjCG,mBAhBG,CAAE1D,IAAKxpB,EAAAA,EAAUX,IAAK,EAAG0tB,IAAK,GAiBjCI,mBAjBG,CAAE3D,IAAKxpB,EAAAA,EAAUX,IAAK,EAAG0tB,IAAK,GAkBjCK,iBAlBG,CAAE5D,IAAKxpB,EAAAA,EAAUX,IAAK,EAAG0tB,IAAK,GAmBjCM,iBAnBG,CAAE7D,IAAKxpB,EAAAA,EAAUX,IAAK,EAAG0tB,IAAK,IAsBzC,SAASO,KACLb,IAAmB,EACnBD,GAAuB,CACnBW,mBAzBG,CAAE3D,IAAKxpB,EAAAA,EAAUX,IAAK,EAAG0tB,IAAK,GA0BjCK,iBA1BG,CAAE5D,IAAKxpB,EAAAA,EAAUX,IAAK,EAAG0tB,IAAK,GA2BjCM,iBA3BG,CAAE7D,IAAKxpB,EAAAA,EAAUX,IAAK,EAAG0tB,IAAK,IChDlC,IAEHQ,GADAC,GAAmB,GA+CvB,SAASC,KACL,MAAiC,WAA7BtwC,SAAS09B,gBACF,SAEP19B,SAASkhB,WACF,SAEJ,UAEJ,SAASqvB,GAAaC,EAAeC,QACZ,IAAxBA,IAAkCA,EA1DN,KA2D5BD,IAAkBJ,KAGtBA,GAAmBI,EACfH,GAAiB9+C,SAAWk/C,GAC5BJ,GAAiBpJ,QAErBoJ,GAAiB/4C,KAAK,CAAE6tB,MAAOirB,GAAkBv6B,UAAWnX,QCnEzD,IAAIgyC,GACO,EADPA,GAEc,EAFdA,GAGD,EAHCA,GAIA,EAJAA,GAKE,EALFA,GAMS,EANTA,GAOY,EAEZC,GACG,EADHA,GAEO,EAFPA,GAGE,EAHFA,GAID,EAJCA,GAKA,EALAA,GAMW,GAEXC,GACG,EADHA,GAEI,EAFJA,GAGW,EAHXA,GAIC,EAJDA,GAKS,EALTA,GAMA,EANAA,GAOI,EAPJA,GAQW,EARXA,GASS,EAITC,GACE,EADFA,GAEI,EAFJA,GAGA,EAHAA,GAIM,EAJNA,GAKG,EALHA,GAMA,EANAA,GAOD,EAPCA,GAQK,EARLA,GASG,EAEHC,GACD,EADCA,GAEA,EC1CAC,GAAmB,CAC1BC,OAAQ,SACRC,OAAQ,SACRlnC,MAAOD,GAAoBC,MAC3BC,KAAMF,GAAoBE,KAC1BC,gBAAiBH,GAAoBG,iBAE9BinC,GAAoB,kBAKpBC,GAA4B,SAO5BC,GAAuB,MAEvBC,GAAyB,CAChCC,OAAO,EACPC,QAAQ,EACRC,UAAU,EACVC,QAAQ,EACRC,QAAQ,EACRC,UAAU,EACVC,UAAU,GCnBP,SAASC,GAAoBp6B,EAAM5H,GACtC,IAAIsI,EAAaD,GAAcT,GAC3Bq6B,EAAyB35B,EAAa05B,GAAoB15B,EAAYtI,GAAuBA,EAEjG,OAAOkiC,GADoBC,GAAwBv6B,GACHq6B,GAK7C,SAASC,GAAmBE,EAAmBH,GAClD,OAAQA,GAEJ,KAAKf,GAAiBE,OACtB,KAAKF,GAAiBC,OAClB,OAAOc,EAEf,OAAQG,GACJ,KAAKlB,GAAiBhnC,MACtB,KAAKgnC,GAAiB/mC,KACtB,KAAK+mC,GAAiB9mC,gBACtB,KAAK8mC,GAAiBE,OACtB,KAAKF,GAAiBC,OAClB,OAAOiB,EACX,QACI,OAAOH,GAMZ,SAASE,GAAwBv6B,GAEpC,GAAKI,GAAcJ,GAAnB,CAGA,IAAIy6B,EAAWz6B,EAAKqW,aAAaojB,IAEjC,GAAqB,SAAjBz5B,EAAKyY,QACL,OAAO6gB,GAAiBhnC,MAG5B,GAAqB,UAAjB0N,EAAKyY,QAAqB,CAC1B,IAAIiiB,EAAe16B,EACnB,GAA0B,aAAtB06B,EAAahuC,MAA6C,UAAtBguC,EAAahuC,MAA0C,QAAtBguC,EAAahuC,KAClF,OAAO4sC,GAAiB/mC,KAE5B,GAA0B,WAAtBmoC,EAAahuC,KACb,OAAO4sC,GAAiB/mC,KAE5B,IAAIooC,EAAeD,EAAarkB,aAAa,gBAE7C,GAAIskB,GAAgD,IAAhCA,EAAap7C,QAAQ,OACrC,OAAO+5C,GAAiB/mC,KAIhC,OAAIkoC,IAAaf,IAA6B15B,EAAK0Y,UAAUkiB,SDhD/B,qBCiDnBtB,GAAiBE,ODxDK,SC0D7BiB,GAAwCz6B,EAAK0Y,UAAUkiB,SDrD/B,mBCsDjBtB,GAAiB/mC,KD1DgB,oBC4DxCkoC,GAAmDz6B,EAAK0Y,UAAUkiB,SDvD/B,8BCwD5BtB,GAAiB9mC,gBD/DM,UCiE9BioC,GAAyCz6B,EAAK0Y,UAAUkiB,SD5D/B,oBC6DlBtB,GAAiBhnC,MAkGzB,SAA6BpR,GAChC,GAAyB,WAArBA,EAAQ81B,SACR,OAAO,EAEX,GAAyB,SAArB91B,EAAQ81B,SAAqB,CAC7B,IAAI6jB,EAAeC,EAAsB,OACzC,MAEC,oBAAoB52C,KAAK22C,IAAiD,WAAhCC,EAAsB,OAE5C,kBAAjBD,GACiB,SAAjBA,EAER,GAAyB,SAArB35C,EAAQ81B,SAAqB,CAC7B,IAAI+jB,EAAgBD,EAAsB,QAEtCE,GADAH,EAAeC,EAAsB,OACjBA,EAAsB,aAC9C,MAEA,oCAAoC52C,KAAK62C,IACnB,qBAAlBA,GACiB,SAAjBF,GACiB,qBAAjBA,GACiB,kBAAjBA,GAEkB,aAAlBE,GACkB,gBAAlBA,GAEA,oBAAoB72C,KAAK82C,IACzB,iBAAiB92C,KAAK62C,IACJ,cAAlBA,GAEkB,WAAlBA,GACkB,cAAlBA,GACkB,YAAlBA,GAGA75C,EAAQ+0B,aAAa,eAEH,WAAlB8kB,GACkB,cAAlBA,GACkB,cAAlBA,GACkB,cAAlBA,GACkB,WAAlBA,GACA,YAAY72C,KAAK82C,IACjB,YAAY92C,KAAK82C,IAEC,6BAAlBD,GACkB,wBAAlBA,GACkB,eAAlBA,GACkB,oBAAlBA,GACkB,cAAlBA,GACkB,iBAAlBA,GACkB,+BAAlBA,EAER,SAASD,EAAsBr5C,GAC3B,OAAQP,EAAQm1B,aAAa50B,IAAS,IAAIw5C,cAE9C,OAAO,EA1JHC,CAAoBl7B,GACbs5B,GAAiBC,YAD5B,GAeG,SAAS4B,GAAen7B,EAAMo7B,GACjC,OAAQA,GACJ,KAAK9B,GAAiB/mC,KACtB,KAAK+mC,GAAiBE,OACtB,KAAKF,GAAiBC,OAClB,OAAO,EACX,KAAKD,GAAiB9mC,gBAClB,OAAOuN,GAAWC,GAAQq7B,GAAcr7B,EAAKU,YAAc26B,GAAcr7B,GAC7E,QACI,OAAO,GAGnB,SAASq7B,GAAcr7B,GACnB,IAAKA,GAAQA,EAAKC,WAAaD,EAAKK,aAChC,OAAO,EAEX,IAAInf,EAAU8e,EACd,GAAwB,UAApB9e,EAAQu3B,QACR,OAAQv3B,EAAQwL,MACZ,IAAK,SACL,IAAK,QACL,IAAK,QACL,IAAK,SACD,OAAO,EAGnB,QAASktC,GAAuB14C,EAAQu3B,SAOrC,SAAS6iB,GAAeC,EAAUC,EAAkBnB,GACvD,IAAIp7C,EAGAw8C,EAAkD,QAAjCx8C,EAAKs8C,EAASrlB,qBAAkC,IAAPj3B,OAAgB,EAASA,EAAGw5B,QACtFP,EAAcqjB,EAASrjB,aAAe,GAC1C,IAAIsjB,GAAqBtjB,EAAY5B,OAArC,CAGA,IACIolB,EAA4B,UAAlBD,QAAmCn/C,EAEjD,GADiC,WAAlBm/C,EAGXvjB,EAAcyhB,QAEb,GAPkBU,IAOOf,GAAiBE,OAE3CthB,EAAcyhB,QAEb,GAAIwB,GAAeI,EAXDlB,KAalBqB,EACD,GAEkB,aAAlBD,GACsB,WAAlBA,GACkB,aAAlBA,GACA,IAAKvjB,EAAY5B,OACb,YAKJ4B,EAFuB,WAAlBujB,EAES9B,GAGWzhB,EAtCiBr6B,QAAQ,MA1HtC,KAmKpB,OAAOq6B,GClKX,IAAIyjB,GAAoB,IAAI3uB,QACrB,SAAS4uB,GAAkB57B,GAC9B,OAAO27B,GAAkBj5C,IAAIsd,GAY1B,SAAS67B,GAAoB77B,GAChC,OAAO27B,GAAkBh7C,IAAIqf,GAU1B,SAAS87B,GAAqB56C,EAAS66C,GAO1C,IAAItjB,EAAUv3B,EAAQu3B,QAClBn6B,EAAQ4C,EAAQ5C,MACpB,GAAI68C,GAAej6C,EAAS66C,GAAmB,CAC3C,IAAIrvC,EAAOxL,EAAQwL,KACnB,GAAgB,UAAZ+rB,IAAiC,WAAT/rB,GAA8B,WAATA,GAA8B,UAATA,GAGlE,OAAOpO,EAEN,IAAKA,GAAqB,WAAZm6B,EAEf,OAEJ,OAAOkhB,GAEX,MAAgB,WAAZlhB,GAAoC,WAAZA,EACjBv3B,EAAQ5C,MAEH,UAAZm6B,GAAmC,aAAZA,EAGpBn6B,OAHP,EAKG,IAAI09C,GAAiB,+CACjBC,GAAe,oBACfC,GAAW,aACf,SAASC,GAAoBC,EAASC,GACzC,OAAOD,EAAQv+C,QAAQm+C,IAAgB,SAAUM,EAAmBC,EAAaC,EAA0BC,EAAaC,EAA0BC,GAC9I,IAAIxxC,EAAMqxC,GAA4BE,GAA4BC,EAClE,IAAKN,IAAYlxC,GAAO8wC,GAAa/3C,KAAKiH,IAAQ+wC,GAASh4C,KAAKiH,GAC5D,OAAOmxC,EAEX,IAAIM,EAAQL,GAAeE,GAAe,GAC1C,MAAO,OAAOrhD,OAAOwhD,GAAOxhD,OAG7B,SAAyB+P,EAAK0xC,GACjC,IACI,OAAOpvC,GAAStC,EAAK0xC,GAASnvC,KAElC,MAAO+P,GACH,OAAOtS,GAR4B2xC,CAAgB3xC,EAAKkxC,IAAUjhD,OAAOwhD,EAAO,QAWjF,SAASG,GAAqBC,GACjC,QAAuB1gD,IAAnB0gD,GAA0D,IAA1BA,EAAeljD,OAGnD,OAAOkjD,EAAe58C,KAAI,SAAU68C,GAChC,IAAIC,EAAQD,EAAcE,UAAYF,EAAcC,MAOpD,MALiB,CACbC,SAFWjiD,MAAML,KAAKqiD,GAAO,SAAUE,GAAW,OAAOA,EAAQhB,WAGjEiB,SAAUJ,EAAcI,eAAY/gD,EACpCghD,MAAOL,EAAcK,MAAMxjD,OAAS,EAAIoB,MAAML,KAAKoiD,EAAcK,YAAShhD,MCpF/E,SAASihD,GAAkBh1C,EAAU0I,EAAeusC,GAEvD,OAAOC,GAAoBl1C,EAAU,CACjCi1C,qBAAsBA,EACtBnD,uBAAwBppC,EAAcmH,oBACtCnH,cAAeA,IAGhB,SAASwsC,GAAoBz9B,EAAM9jB,GACtC,IAAIwhD,EAcR,SAAuB19B,EAAM9jB,GACzB,OAAQ8jB,EAAKC,UACT,KAAKD,EAAK29B,cACN,OAaL,SAA+Bp1C,EAAUrM,GAC5C,MAAO,CACHwQ,KAAMwsC,GACN73B,WAAYu8B,GAAoBr1C,EAAUrM,GAC1C2hD,mBAAoBd,GAAqBx0C,EAASs1C,qBAjBvCC,CAAsB99B,EAAM9jB,GACvC,KAAK8jB,EAAK+9B,uBACN,OA0BZ,SAAuC78C,EAAShF,GAC5C,IAAImlB,EAAa,GACbngB,EAAQmgB,WAAWvnB,SACnBunB,EAAau8B,GAAoB18C,EAAShF,IAE9C,IAAI8hD,EAAex9B,GAAiBtf,GAChC88C,GACA9hD,EAAQshD,qBAAqBS,sBAAsBC,cAAch9C,GAErE,MAAO,CACHwL,KAAMwsC,GACN73B,WAAYA,EACZ28B,aAAcA,EACdH,mBAAoBG,EACdjB,GAAqB77C,EAAQ28C,yBAC7BvhD,GAzCK6hD,CAA8Bn+B,EAAM9jB,GAC/C,KAAK8jB,EAAKo+B,mBACN,MAiBD,CACH1xC,KAAMwsC,GACNz3C,MAH2B48C,EAhBUr+B,GAmBlBve,KACnB68C,SAAUD,EAAaC,SACvBC,SAAUF,EAAaE,UApBvB,KAAKv+B,EAAKK,aACN,OAyDL,SAA8Bnf,EAAShF,GAC1C,IAAI+C,EACAw5B,EAAU+lB,GAAgBt9C,EAAQu3B,SAClCgmB,GAwKcC,EAxKOx9C,EAyKH,QAAfw9C,EAAGjmB,SAAqBimB,aAAcC,iBAzKRriD,GAGjCy/C,EAAmBzB,GAAmBC,GAAwBr5C,GAAUhF,EAAQm+C,wBAqKxF,IAAsBqE,EApKlB,GAAI3C,IAAqBzC,GAAiBE,OAAQ,CAC9C,IAAI9mC,EAAKxR,EAAQw7B,wBAAyB1W,EAAQtT,EAAGsT,MAAOE,EAASxT,EAAGwT,OACxE,MAAO,CACHxZ,KAAMwsC,GACNzgB,QAASA,EACTmmB,YAAa3/C,EAAK,CACV4/C,SAAU,GAAGzjD,OAAO4qB,EAAO,MAC3B84B,UAAW,GAAG1jD,OAAO8qB,EAAQ,OAEjCjnB,EAAGw6C,IAAqBC,GACxBz6C,GACJoiB,WAAY,GACZo9B,MAAOA,GAIf,GAAI1C,IAAqBzC,GAAiBC,OACtC,OAEJ,IAAIqF,EAoJR,SAAsC19C,EAAS66C,EAAkB7/C,GAC7D,IAAI+C,EACJ,GAAI88C,IAAqBzC,GAAiBE,OACtC,MAAO,GAKX,IAHA,IAAIuF,EAAY,GACZtmB,EAAU+lB,GAAgBt9C,EAAQu3B,SAClC1qB,EAAM7M,EAAQ21B,cACT77B,EAAI,EAAGA,EAAIkG,EAAQ09C,WAAW9kD,OAAQkB,GAAK,EAAG,CACnD,IACIu+B,EADYr4B,EAAQ09C,WAAWh/C,KAAK5E,GACVyG,KAC1Bu9C,EAAiBC,GAAmB/9C,EAAS66C,EAAkBxiB,EAAer9B,EAAQ+U,eACnE,OAAnB+tC,IACAD,EAAUxlB,GAAiBylB,GAGnC,GAAI99C,EAAQ5C,QACK,aAAZm6B,GAAsC,WAAZA,GAAoC,WAAZA,GAAoC,UAAZA,GAAsB,CACjG,IAAIymB,EAAYpD,GAAqB56C,EAAS66C,QAC5Bz/C,IAAd4iD,IACAH,EAAUzgD,MAAQ4gD,GAM1B,GAAgB,WAAZzmB,GAAwBsjB,IAAqBzC,GAAiBhnC,MAAO,CAErE,IAAI6sC,EAAgBj+C,EAChBi+C,EAAcC,WACdL,EAAUK,SAAWD,EAAcC,UAI3C,GAAgB,SAAZ3mB,EAAoB,CACpB,IAAI4mB,EAAankD,MAAML,KAAKkT,EAAIuxC,aAAax/C,MAAK,SAAUmzB,GAAK,OAAOA,EAAEvlB,OAASxM,EAAQwM,SACvF0uC,EAAUmD,GAAkBF,KACjBA,IACXN,EAAUS,SAAWpD,GAI7B,GAAgB,UAAZ3jB,GACAv3B,EAAQu+C,SAENv+C,EAAQ02B,WAAa12B,EAAQg3B,aAAe,IAAI5B,OAAOx8B,OAAQ,CACjE,IAAIsiD,GAAAA,EAAUmD,GAAkBr+C,EAAQu+C,UAEpCV,EAAUS,SAAWpD,GAW7B,IAmBIsD,EACAC,EApBAjF,EAAex5C,EACH,UAAZu3B,GAA8C,UAAtBiiB,EAAahuC,MAA0C,aAAtBguC,EAAahuC,OAClEqvC,IAAqBzC,GAAiBhnC,MACtCysC,EAAUa,UAAYlF,EAAakF,QAE9BzE,GAAeT,EAAcqB,KAClCgD,EAAUa,QAAUjG,KAM5B,GAAgB,UAAZlhB,GAAmC,UAAZA,EAAqB,CAC5C,IAAIonB,EAAe3+C,EACnB69C,EAAUe,cAAgBD,EAAaE,OAAS,SAAW,SAO/D,IAAIvC,EAAuBthD,EAAQshD,qBACnC,OAAQA,EAAqBjpC,QACzB,KAAK,EACDmrC,EAAYhiD,KAAKM,MAAMkD,EAAQw+C,WAC/BC,EAAajiD,KAAKM,MAAMkD,EAAQy+C,aAC5BD,GAAaC,IACbnC,EAAqBwC,wBAAwB56C,IAAIlE,EAAS,CAAEw+C,UAAWA,EAAWC,WAAYA,IAElG,MACJ,KAAK,EACGnC,EAAqBwC,wBAAwBt9C,IAAIxB,KAEgBw+C,GAAhEzgD,EAAKu+C,EAAqBwC,wBAAwBr/C,IAAIO,IAAyBw+C,UAAWC,EAAa1gD,EAAG0gD,YAInHA,IACAZ,EAAUkB,cAAgBN,GAE1BD,IACAX,EAAUmB,aAAeR,GAE7B,OAAOX,EA1PUoB,CAA6Bj/C,EAAS66C,EAAkB7/C,GACrEmlB,EAAa,GACjB,GAAIngB,EAAQmgB,WAAWvnB,OAAQ,CAc3BunB,EAAau8B,GAAoB18C,EAT7BhF,EAAQm+C,yBAA2B0B,GAAoB7/C,EAAQs/C,oBAAkC,SAAZ/iB,GACpDv8B,EAGA,EAAO,GAAIA,EAAS,CACjDm+C,uBAAwB0B,EACxBP,iBAA8B,SAAZ/iB,KAK9B,GAAInY,GAAiBpf,GAAU,CAC3B,IAAIqf,EAAak9B,GAAoBv8C,EAAQqf,WAAYrkB,GACtC,OAAfqkB,GACAc,EAAWxhB,KAAK0gB,GAGxB,MAAO,CACH7T,KAAMwsC,GACNzgB,QAASA,EACTmmB,WAAYA,EACZv9B,WAAYA,EACZo9B,MAAOA,GAhHI2B,CAAqBpgC,EAAM9jB,GACtC,KAAK8jB,EAAKG,UACN,OAsHZ,SAA2Bo7B,EAAUr/C,GACjC,IAAI+C,EAGAw8C,EAAkD,QAAjCx8C,EAAKs8C,EAASrlB,qBAAkC,IAAPj3B,OAAgB,EAASA,EAAGw5B,QACtFP,EAAcojB,GAAeC,EAAUr/C,EAAQs/C,mBAAoB,EAAOt/C,EAAQm+C,wBACtF,IAAKniB,EACD,OAEJ,MAAO,CACHxrB,KAAMwsC,GACNhhB,YAAaA,EACbwjB,QAA2B,UAAlBD,QAAmCn/C,GAlIjC+jD,CAAkBrgC,EAAM9jB,GACnC,KAAK8jB,EAAKsgC,mBACN,MAoID,CACH5zC,KAAMwsC,GACNhhB,YAAa,IA5HrB,IAAmCmmB,EArCVkC,CAAcvgC,EAAM9jB,GACzC,IAAKwhD,EACD,OAAO,KAGX,IAAIp1B,EAAKuzB,GAAoB77B,IAsNtBwgC,KArNHC,EAAuB/C,EAM3B,OALA+C,EAAqBn4B,GAAKA,EDDvB,SAA6BtI,EAAM0gC,GACtC/E,GAAkBv2C,IAAI4a,EAAM0gC,GCC5BC,CAAoB3gC,EAAMsI,GACtBpsB,EAAQy/C,mBACRz/C,EAAQy/C,kBAAkBh5C,IAAI2lB,GAE3Bm4B,EAwJJ,SAAS7C,GAAoB59B,EAAM9jB,GACtC,IAAI2Q,EAAS,GAOb,OANAmT,EAAKqB,WAAWnkB,SAAQ,SAAU0jD,GAC9B,IAAIC,EAAsBpD,GAAoBmD,EAAW1kD,GACrD2kD,GACAh0C,EAAOhN,KAAKghD,MAGbh0C,EAEJ,SAASoyC,GAAmB/9C,EAAS66C,EAAkBxiB,EAAetoB,GACzE,GAAI8qC,IAAqBzC,GAAiBE,OAEtC,OAAO,KAEX,IAAIwF,EAAiB99C,EAAQm1B,aAAakD,GAC1C,GAAIwiB,IAAqBzC,GAAiB/mC,MACtCgnB,IAAkBkgB,KACjBrhB,GAAkBh5B,SAASm6B,IAC5BA,IAAkBtoB,EAAc8G,oBAAqB,CACrD,IAAI0gB,EAAUv3B,EAAQu3B,QACtB,OAAQc,GAEJ,IAAK,QACL,IAAK,MACL,IAAK,cACD,OAAOogB,GAGf,IAAgB,QAAZlhB,GAAiC,WAAZA,KACC,QAAlBc,GAA6C,WAAlBA,GAC3B,MH7Le,qFGiMvB,GAAgB,MAAZd,GAAqC,SAAlBc,EACnB,OAAOogB,GAGX,GAAIqF,GAAkBz+C,EAAWg5B,EAAe,SAE5C,OAAOogB,GAGf,OAAKqF,GAA4C,kBAAnBA,GAI1BA,EAAellD,OFjOsB,KEiOqD,UAA/BklD,EAAe7jD,MAAM,EAAG,GAC5E,iBAJA6jD,EAQf,IAAIwB,GAAU,EAId,IAAIM,GAAiB,cACrB,SAAStC,GAAgB/lB,GACrB,IAAIsoB,EAAmBtoB,EAAQwiB,cAAc3kB,OAC7C,OAAIwqB,GAAe58C,KAAK68C,GAIb,MAEJA,EAEX,SAASxB,GAAkBtsB,GACvB,IACI,IAAIiqB,EAAQjqB,EAAEiqB,OAASjqB,EAAEkqB,SACzB,OAAID,EAEOf,GADiBjhD,MAAML,KAAKqiD,EAAO8D,IAAkB39C,KAAK,IACnB4vB,EAAEvlB,MAE7C,KAEX,MAAOlU,GACH,OAAO,MAGf,SAASwnD,GAAiBC,GACtB,OAEJ,SAAyBA,GACrB,MAAO,eAAgBA,EAHhBC,CAAgBD,GAAQ1B,GAAkB0B,EAAKE,aAAe,GAAKF,EAAK7E,QCnQ5E,SAASgF,GAAa93C,GACzB,OAAOT,QAAQS,EAAM+3C,gBAKlB,SAASC,GAA4BnkD,EAAQwc,GAChD,MAAO,CACHA,KAAM,EAAO,CACTxc,OAAQA,GACTwc,GACHjN,KAAMusC,GACNvxC,UAAWV,KAGZ,SAASu6C,GAAuBN,GAGnC,IAFA,IAAI7xC,EAAO,GACPoyC,EAAcP,EACXO,EAAYC,YAAY,CAC3B,IACIC,EADUxmD,MAAML,KAAK2mD,EAAYC,WAAWtE,UAC1B59C,QAAQiiD,GAC9BpyC,EAAKwb,QAAQ82B,GACbF,EAAcA,EAAYC,WAG9B,GAAKD,EAAYG,iBAAjB,CAGA,IACIj2B,EADQxwB,MAAML,KAAK2mD,EAAYG,iBAAiBxE,UAClC59C,QAAQiiD,GAE1B,OADApyC,EAAKwb,QAAQc,GACNtc,GCzBJ,SAASwyC,GAAoBC,GAChC,IAAIC,EAAuB1jD,EACvB2jD,EAAmB,GACvB,SAAS/O,IACL8O,IACAD,EAAqBE,GACrBA,EAAmB,GAEvB,MAAO,CACHC,aAAc,SAAUC,GACY,IAA5BF,EAAiBjoD,SACjBgoD,E3FsWT,SAA6B/7C,EAAUm8C,GAM1C,GAAIlhD,OAAOmhD,oBAAqB,CAC5B,IAAIC,EAAOphD,OAAOmhD,oBAAoB3mD,EAAQuK,GAAWm8C,GACzD,OAAO,WAAc,OAAOlhD,OAAOqhD,mBAAmBD,IAE1D,IAAI95B,EAAKtnB,OAAOshD,sBAAsB9mD,EAAQuK,IAC9C,OAAO,WAAc,OAAO/E,OAAOuhD,qBAAqBj6B,I2FjXrB65B,CAAoBnP,EAAO,CAAEwP,QAZnC,OAcrBT,EAAiBliD,KAAK1F,MAAM4nD,EAAkBE,IAElDjP,MAAOA,EACP/3B,KAAM,WACF6mC,MCfL,SAASW,GAAsBC,EAAkBzxC,EAAegtC,EAAuBjhD,GAC1F,IAAIigB,EAAmBF,KACvB,IAAKE,EACD,MAAO,CAAEhC,KAAM7c,EAAM40C,MAAO50C,GAEhC,IAAIukD,EAAgBf,IAAoB,SAAUK,IAsBtD,SAA0BA,EAAWS,EAAkBzxC,EAAegtC,EAAuBjhD,GACzFilD,EACK/uC,QAAO,SAAU0vC,GAAY,MAAyB,cAAlBA,EAASl2C,QAC7CxP,SAAQ,SAAU0lD,GACnBA,EAASC,aAAa3lD,SAAQ,SAAU4lD,GACpCC,GAAyBD,EAAa7E,EAAsB+E,wBAOpE,IAAIC,EAAoBhB,EAAU/uC,QAAO,SAAU0vC,GAC/C,OAAO5lD,EAAO49C,SAASgI,EAAS5lD,SJ1CjC,SAA4CgjB,GAE/C,IADA,IAAI4E,EAAU5E,EACP4E,GAAS,CACZ,IAAKg3B,GAAkBh3B,KAAapE,GAAiBoE,GACjD,OAAO,EAEXA,EAAUnE,GAAcmE,GAE5B,OAAO,EImCCs+B,CAAmCN,EAAS5lD,SAC5Co9C,GAAoBwI,EAAS5lD,OAAQiU,EAAcmH,uBAAyBkhC,GAAiBE,UAEjGv6C,EAiBR,SAAmCgjD,EAAWhxC,EAAegtC,GAyBzD,IAbA,IAAIkF,EAAqB,IAAIxjD,IACzBkjD,EAAe,IAAIO,IACnBC,EAAU,SAAUT,GACpBA,EAASU,WAAWpmD,SAAQ,SAAU8iB,GAClCmjC,EAAmBxgD,IAAIqd,MAE3B4iC,EAASC,aAAa3lD,SAAQ,SAAU8iB,GAC/BmjC,EAAmBzgD,IAAIsd,IACxB6iC,EAAaz9C,IAAI4a,EAAM4iC,EAAS5lD,QAEpCmmD,EAAmBI,OAAOvjC,OAGzBpmB,EAAK,EAAG4pD,EAAcvB,EAAWroD,EAAK4pD,EAAY1pD,OAAQF,IAAM,CAErEypD,EADeG,EAAY5pD,IAa/B,IAAI6pD,EAA2BvoD,MAAML,KAAKsoD,GA6IPO,EA5IZD,EA6IvBC,EAAMC,MAAK,SAAUp8C,EAAGC,GACpB,IAAIg1B,EAAWj1B,EAAEq8C,wBAAwBp8C,GAEzC,OAAIg1B,EAAWtc,KAAK2jC,gCACR,EAEHrnB,EAAWtc,KAAK4jC,4BAGhBtnB,EAAWtc,KAAK6jC,4BAFd,EAKFvnB,EAAWtc,KAAK8jC,6BACb,EAGL,KAjBR,IAAgCN,EAvInC,IAFA,IAAI/H,EAAoB,IAAIh8C,IACxBskD,EAAqB,GAChBhlD,EAAK,EAAGilD,EAA6BT,EAA0BxkD,EAAKilD,EAA2BpqD,OAAQmF,IAAM,CAClH,IAAI+gB,EAAOkkC,EAA2BjlD,GACtC,IAAIklD,EAAkBnkC,GAAtB,CAGA,IAAIq6B,EAAyBD,GAAoBp6B,EAAKU,WAAYzP,EAAcmH,qBAChF,GAAIiiC,IAA2Bf,GAAiBE,QAAUa,IAA2Bf,GAAiBC,OAAtG,CAGA,IAAImE,EAAiBD,GAAoBz9B,EAAM,CAC3C27B,kBAAmBA,EACnBtB,uBAAwBA,EACxBmD,qBAAsB,CAAEjpC,OAAQ,EAAkB0pC,sBAAuBA,GACzEhtC,cAAeA,IAEnB,GAAKysC,EAAL,CAGA,IAAIh9B,EAAaD,GAAcT,GAC/BikC,EAAmBpkD,KAAK,CACpBukD,OAAQC,EAAerkC,GACvBskC,SAAUzI,GAAoBn7B,GAC9BV,KAAM09B,OAId,IAAI6G,EAAuB,GAS3B,OARA1B,EAAa3lD,SAAQ,SAAUi9B,EAAQna,GAC/B47B,GAAkB57B,IAClBukC,EAAqB1kD,KAAK,CACtBykD,SAAUzI,GAAoB1hB,GAC9B7R,GAAIuzB,GAAoB77B,QAI7B,CAAEwkC,KAAMP,EAAoBQ,QAASF,EAAsBJ,kBAAmBA,GACrF,SAASA,EAAkBnkC,GACvB,OAAO47B,GAAkB57B,IAAS27B,EAAkBj5C,IAAIm5C,GAAoB77B,IAEhF,SAASqkC,EAAerkC,GAEpB,IADA,IAAI0kC,EAAc1kC,EAAK0kC,YAChBA,GAAa,CAChB,GAAI9I,GAAkB8I,GAClB,OAAO7I,GAAoB6I,GAE/BA,EAAcA,EAAYA,YAE9B,OAAO,MA7GFC,CAA0B1B,EAAkB/vC,QAAO,SAAU0vC,GAAY,MAAyB,cAAlBA,EAASl2C,QAA0BuE,EAAegtC,GAAwBuG,EAAOvlD,EAAGulD,KAAMC,EAAUxlD,EAAGwlD,QAASN,EAAoBllD,EAAGklD,kBAC5NS,EA+GR,SAAuC3C,EAAWhxC,GAa9C,IAZA,IAAIhS,EACA4lD,EAAgB,GAEhBC,EAAe,IAAInlD,IACnBsjD,EAAoBhB,EAAU/uC,QAAO,SAAU0vC,GAC/C,OAAIkC,EAAapiD,IAAIkgD,EAAS5lD,UAG9B8nD,EAAaniD,IAAIigD,EAAS5lD,SACnB,MAGFpD,EAAK,EAAGmrD,EAAsB9B,EAAmBrpD,EAAKmrD,EAAoBjrD,OAAQF,IAAM,CAC7F,IAAIgpD,EAAWmC,EAAoBnrD,GAEnC,GADYgpD,EAAS5lD,OAAOk7B,cACd0qB,EAASoC,SAAvB,CAGA,IAAI3K,EAAyBD,GAAoB35B,GAAcmiC,EAAS5lD,QAASiU,EAAcmH,qBAC3FiiC,IAA2Bf,GAAiBE,QAAUa,IAA2Bf,GAAiBC,QAGtGsL,EAAchlD,KAAK,CACfyoB,GAAIuzB,GAAoB+G,EAAS5lD,QAEjCsB,MAAiF,QAAzEW,EAAKq8C,GAAesH,EAAS5lD,QAAQ,EAAOq9C,UAA4C,IAAPp7C,EAAgBA,EAAK,QAGtH,OAAO4lD,EA5IKI,CAA8BhC,EAAkB/vC,QAAO,SAAU0vC,GACzE,MAAyB,kBAAlBA,EAASl2C,OAA6By3C,EAAkBvB,EAAS5lD,WACxEiU,GACA2tC,EA2IR,SAAoCqD,EAAWhxC,GAmB3C,IAlBA,IAAIi0C,EAAqB,GAErBC,EAAkB,IAAI/B,IACtBH,EAAoBhB,EAAU/uC,QAAO,SAAU0vC,GAC/C,IAAIwC,EAAoBD,EAAgBxkD,IAAIiiD,EAAS5lD,QACrD,QAA0B,OAAtBooD,QAAoD,IAAtBA,OAA+B,EAASA,EAAkB1iD,IAAIkgD,EAASrpB,kBAGpG6rB,EAIDA,EAAkBziD,IAAIigD,EAASrpB,eAH/B4rB,EAAgB//C,IAAIw9C,EAAS5lD,OAAQ,IAAI2C,IAAI,CAACijD,EAASrpB,kBAKpD,MAGP8rB,EAAmB,IAAIjC,IAClBxpD,EAAK,EAAG0rD,EAAsBrC,EAAmBrpD,EAAK0rD,EAAoBxrD,OAAQF,IAAM,CAC7F,IAAIgpD,EAAW0C,EAAoB1rD,GAEnC,GADsBgpD,EAAS5lD,OAAOq5B,aAAausB,EAASrpB,iBACpCqpB,EAASoC,SAAjC,CAGA,IAAI5J,EAAehB,GAAoBwI,EAAS5lD,OAAQiU,EAAcmH,qBAClE4mC,EAAiBC,GAAmB2D,EAAS5lD,OAAQo+C,EAAcwH,EAASrpB,cAAetoB,GAC3Fs0C,OAAmB,EACvB,GAA+B,UAA3B3C,EAASrpB,cAA2B,CACpC,IAAIisB,EAAa1J,GAAqB8G,EAAS5lD,OAAQo+C,GACvD,QAAmB9+C,IAAfkpD,EACA,SAEJD,EAAmBC,OAGnBD,EAD+B,kBAAnBvG,EACOA,EAGA,KAEvB,IAAIyG,EAAkBJ,EAAiB1kD,IAAIiiD,EAAS5lD,QAC/CyoD,IACDA,EAAkB,CACdn9B,GAAIuzB,GAAoB+G,EAAS5lD,QACjC4hD,WAAY,IAEhBsG,EAAmBrlD,KAAK4lD,GACxBJ,EAAiBjgD,IAAIw9C,EAAS5lD,OAAQyoD,IAE1CA,EAAgB7G,WAAWgE,EAASrpB,eAAiBgsB,GAEzD,OAAOL,EA/LUQ,CAA2BzC,EAAkB/vC,QAAO,SAAU0vC,GAC3E,MAAyB,eAAlBA,EAASl2C,OAA0By3C,EAAkBvB,EAAS5lD,WACrEiU,GACJ,IAAK2zC,EAAM9qD,SAAW8kD,EAAW9kD,SAAW2qD,EAAQ3qD,SAAW0qD,EAAK1qD,OAChE,OAEJ4oD,EAAiB,CACb8B,KAAMA,EACNC,QAASA,EACTG,MAAOA,EACPhG,WAAYA,IApDZ+G,CAAiB1D,EAAU7mD,OAAOwe,EAASgsC,eAAgBlD,EAAkBzxC,EAAegtC,EAAuBjhD,MAEnH4c,EAAW,IAAIqD,EAAiBzhB,EAAQmnD,EAAcX,eAS1D,OARApoC,EAASoJ,QAAQhmB,EAAQ,CACrB6oD,mBAAmB,EACnBjH,YAAY,EACZkH,eAAe,EACfC,uBAAuB,EACvBC,WAAW,EACXC,SAAS,IAEN,CACHhrC,KAAM,WACFrB,EAASsoB,aACTygB,EAAc1nC,QAElB+3B,MAAO,WACH2P,EAAc3P,UA8O1B,SAAS+P,GAAyBD,EAAaoD,G/D/PxC,IAAuBlmC,E+DgQtBM,GAAiBwiC,IACjBoD,EAAyBpD,EAAYviC,a/DjQfP,E+DmQZ8iC,E/DlQPxiC,GAAiBN,GAAQA,EAAKO,WAAWc,WAAarB,EAAKqB,Y+DkQvCnkB,SAAQ,SAAUk9B,GAAS,OAAO2oB,GAAyB3oB,EAAO8rB,MC7P1F,ICtBHjnD,GDsBOknD,GAAuC,SAAUnxB,EAASC,GACjE,IAAInP,EAAS9kB,OAAO+kB,eAChBqgC,EAAa,CACbC,gBAAiBrxB,EACjBsxB,gBAAiBrxB,EACjBsxB,gBAAiBvxB,EACjBwxB,gBAAiBvxB,GAErB,OAAKnP,IAbT,WACI,IAAIA,EAAS9kB,OAAO+kB,eACpB,OAAQroB,KAAK+oD,IAAI3gC,EAAO4gC,QAAU5gC,EAAO6gC,UAAY3lD,OAAO4lD,SARhD,IASRlpD,KAAK+oD,IAAI3gC,EAAO+gC,SAAW/gC,EAAOghC,WAAa9lD,OAAO+lD,SAT9C,GAuBHC,IAOLZ,EAAWG,gBAAkB7oD,KAAKM,MAAMg3B,EAAUlP,EAAOghC,YACzDV,EAAWI,gBAAkB9oD,KAAKM,MAAMi3B,EAAUnP,EAAO6gC,aANzDP,EAAWC,gBAAkB3oD,KAAKM,MAAMg3B,EAAUlP,EAAOghC,YACzDV,EAAWE,gBAAkB5oD,KAAKM,MAAMi3B,EAAUnP,EAAO6gC,YAOtDP,GAZIA,GAcJa,GAAoB,WAC3B,IAAInhC,EAAS9kB,OAAO+kB,eACpB,MAAO,CACHE,MAAOH,EAAOG,MACd6gC,WAAYhhC,EAAOghC,WACnBH,UAAW7gC,EAAO6gC,UAClBE,SAAU/gC,EAAO+gC,SACjBH,QAAS5gC,EAAO4gC,QAChBxgC,OAAQJ,EAAOI,OACfF,MAAOF,EAAOE,QAGf,SAASkhC,KACZ,IAAIH,EACAjhC,EAAS9kB,OAAO+kB,eAUpB,OARIghC,EADAjhC,EACUA,EAAO+gC,SAAW/gC,EAAOghC,gBAEXxqD,IAAnB0E,OAAO+lD,QACF/lD,OAAO+lD,QAGP/lD,OAAOmmD,aAAe,EAE7BzpD,KAAKM,MAAM+oD,GAEf,SAASK,KACZ,IAAIR,EACA9gC,EAAS9kB,OAAO+kB,eAUpB,OARI6gC,EADA9gC,EACUA,EAAO4gC,QAAU5gC,EAAO6gC,eAEVrqD,IAAnB0E,OAAO4lD,QACF5lD,OAAO4lD,QAGP5lD,OAAOqmD,aAAe,EAE7B3pD,KAAKM,MAAM4oD,GC1EtB,IAGIU,GAAY,IAAIt6B,QAChBo3B,GAAS,EACN,SAASmD,GAAoBj+C,GAIhC,OAHKg+C,GAAU5kD,IAAI4G,IACfg+C,GAAUliD,IAAIkE,EAAO86C,MAElBkD,GAAU3mD,IAAI2I,GAElB,SAASk+C,GAAcC,GAC1B,IA8BiCC,EAAIz2C,EAAegtC,EAsPlB0J,EAAoBvvC,EAe/BwvC,EAuBaxlC,EAAWylC,EA1T3CC,GA8B6BJ,EA9BUD,EAAEM,WA8BR92C,EA9BoBw2C,EAAEx2C,cA8BPgtC,EA9BsBwJ,EAAExJ,sBA+BrEwE,GAAsBiF,EAAIz2C,EAAegtC,EAAuB11C,WA9BnEy/C,EAgCD,SAA0BN,GAC7B,IAAIO,EAAiBjsD,EAASR,GAAQ,SAAU8N,GAC5C,IAAItM,EAASkrD,GAAe5+C,GAC5B,GAAIsyC,GAAkB5+C,GAAS,CAC3B,IAAImrD,EAAcC,GAAwB9+C,GAC1C,IAAK6+C,EACD,OAEJ,IAAI3rB,EAAW,CACXlU,GAAIuzB,GAAoB7+C,GACxBqrD,WAAY,EACZ1rB,EAAGwrB,EAAYxrB,EACfE,EAAGsrB,EAAYtrB,GAEnB6qB,EAAG,CAAClrB,GAAW4kB,GAAa93C,GAAS6vC,GAA8BA,QA3D3C,GA6DG,CAC/B18C,UAAU,IACXE,UACH,OAAOge,GAAkBpS,SAAU,CAAC,YAA8B,aAA+B0/C,EAAgB,CAC7GntC,SAAS,EACTC,SAAS,IACVE,KAtDoBqtC,CAAiBb,EAAEc,aACtCC,EA0ED,SAAsCd,EAAItvC,GAC7C,IAAIqwC,EAAU,SAAUn/C,GACpB,IAAItM,EAASkrD,GAAe5+C,GAC5B,GAAI8wC,GAAoBp9C,EAAQob,KAAyBkhC,GAAiBE,QAAWoC,GAAkB5+C,GAAvG,CAGA,IAEI0rD,EAFApgC,EAAKuzB,GAAoB7+C,GACzB0P,EAAOi8C,GAA4Br/C,EAAMoD,MAE7C,GAAIA,IAAS0sC,IAA6B1sC,IAAS0sC,GAA4B,CAC3E,IAAI+O,EAAcC,GAAwB9+C,GAC1C,IAAK6+C,EACD,OAEJO,EAAc,CAAEpgC,GAAIA,EAAI5b,KAAMA,EAAMiwB,EAAGwrB,EAAYxrB,EAAGE,EAAGsrB,EAAYtrB,QAGrE6rB,EAAc,CAAEpgC,GAAIA,EAAI5b,KAAMA,GAElC,IAAIk8C,EAAS,EAAO,CAAEtgC,GAAIi/B,GAAoBj+C,IAAUg4C,GAA4BnI,GAAoCuP,IACxHhB,EAAGkB,KAEP,OAAOjuC,GAAkBpS,SAAUxO,OAAOoG,KAAKwoD,IAA8BF,EAAS,CAClF3tC,SAAS,EACTC,SAAS,IACVE,KAnG2B4tC,CAA6BpB,EAAEqB,mBAAoBrB,EAAEx2C,cAAcmH,qBAC7F2wC,EAmHR,SAA4BrB,EAAItvC,EAAqB4nC,GACjD,IAAIiI,EAAiBjsD,EAASR,GAAQ,SAAU8N,GAC5C,IAAItM,EAASkrD,GAAe5+C,GAC5B,GAAKtM,GACDo9C,GAAoBp9C,EAAQob,KAAyBkhC,GAAiBE,QACrEoC,GAAkB5+C,GAFvB,CAKA,IAAIsrB,EAAKuzB,GAAoB7+C,GACzBgsD,EAAkBhsD,IAAWuL,SAC3B,CACEm3C,UAAW0H,KACXzH,WAAYuH,MAEd,CACExH,UAAWhiD,KAAKM,MAAMhB,EAAO0iD,WAC7BC,WAAYjiD,KAAKM,MAAMhB,EAAO2iD,aAEtCK,EAAwB56C,IAAIpI,EAAQgsD,GACpCtB,EAAG,CACCp/B,GAAIA,EACJqU,EAAGqsB,EAAgBrJ,WACnB9iB,EAAGmsB,EAAgBtJ,gBAvJC,KAyJG/iD,UAC/B,OAAO6d,GAAiBjS,SAAU,SAAuB0/C,EAAgB,CAAEntC,SAAS,EAAMC,SAAS,IAAQE,KA5IvFguC,CAAmBxB,EAAEyB,SAAUzB,EAAEx2C,cAAcmH,oBAAqBqvC,EAAEzH,yBACtFmJ,EA6IR,SAAoCzB,GAChC,OAAOhiC,KAAyBtM,UAAUsuC,GAAIluC,YA9IlB4vC,CAA2B3B,EAAE4B,kBACrDC,EAAeC,GAAkB9B,EAAE+B,QAAS/B,EAAEx2C,cAAcmH,qBAC5DqxC,GA8Q8B9B,EA9QyBF,EAAEE,mBA8QPvvC,EA9Q2BqvC,EAAEx2C,cAAcmH,oBA2R1FuC,GAAkBpS,SAAU,CAAC,OAAmB,UAZzC,SAAUe,GACpB,IAAItM,EAASkrD,GAAe5+C,GACvBtM,GACDo9C,GAAoBp9C,EAAQob,KAAyBkhC,GAAiBE,QACrEoC,GAAkB5+C,IAGvB2qD,EAAmB,CACfr/B,GAAIuzB,GAAoB7+C,GACxB0P,KAAqB,SAAfpD,EAAMoD,KAA6B2sC,GAA4BA,OAGS,CAAEv+B,SAAS,EAAMC,SAAS,IAAQE,MA1RpHyuC,EAyND,SAAgChC,GACnC,SAASiC,EAA2BxI,EAAYp7C,GACxCo7C,GAAcvF,GAAkBuF,EAAWyI,YAC3C7jD,EAAS81C,GAAoBsF,EAAWyI,YAGhD,IAAIC,EAA0B,CAC1Bt9B,GAAgCu9B,cAAc9vD,UAAW,aAAc,CACnEwyB,OAAQ,SAAUy0B,EAAMv1B,GACpBi+B,EAA2BjuD,MAAM,SAAU4sB,GAAM,OAAOo/B,EAAG,CAAEp/B,GAAIA,EAAIk8B,KAAM,CAAC,CAAEvD,KAAMA,EAAMv1B,MAAOA,YAGzGa,GAAgCu9B,cAAc9vD,UAAW,aAAc,CACnEwyB,OAAQ,SAAUd,GACdi+B,EAA2BjuD,MAAM,SAAU4sB,GAAM,OAAOo/B,EAAG,CAAEp/B,GAAIA,EAAIm8B,QAAS,CAAC,CAAE/4B,MAAOA,aAIrE,qBAApBq+B,gBACPC,EAA+BD,kBAG/BC,EAA+BC,cAC/BD,EAA+BE,kBAEnC,SAASF,EAA+BG,GACpCN,EAAwBhqD,KAAK0sB,GAAgC49B,EAAInwD,UAAW,aAAc,CACtFwyB,OAAQ,SAAUy0B,EAAMv1B,GACpB,IAAIpS,EAAQ5d,KACZiuD,EAA2BjuD,KAAKimD,kBAAkB,SAAUr5B,GACxD,IAAIlZ,EAAOmyC,GAAuBjoC,GAC9BlK,IACAA,EAAKvP,KAAK6rB,GAAS,GACnBg8B,EAAG,CAAEp/B,GAAIA,EAAIk8B,KAAM,CAAC,CAAEvD,KAAMA,EAAMv1B,MAAOtc,aAIrDmd,GAAgC49B,EAAInwD,UAAW,aAAc,CAC7DwyB,OAAQ,SAAUd,GACd,IAAIpS,EAAQ5d,KACZiuD,EAA2BjuD,KAAKimD,kBAAkB,SAAUr5B,GACxD,IAAIlZ,EAAOmyC,GAAuBjoC,GAC9BlK,IACAA,EAAKvP,KAAK6rB,GACVg8B,EAAG,CAAEp/B,GAAIA,EAAIm8B,QAAS,CAAC,CAAE/4B,MAAOtc,cAMpD,OAAO,WAAc,OAAOy6C,EAAwB3sD,SAAQ,SAAUktD,GAAW,OAAOA,EAAQnvC,WA3QvEovC,CAAuB5C,EAAE6C,cAC9CC,GA2RmB3C,EA3RcH,EAAEG,QA4RhCjtC,GAAkB3Z,OAAQ,CAAC,QAAqB,SAAoB,WACvE4mD,EAAQ,CAAE4C,UAAWjiD,SAASkhB,gBAC/BxO,MA7RCwvC,EA+RR,SAA0C/C,GACtC,IAAK1mD,OAAO+kB,eACR,OAAO3nB,EAEX,IAAIa,EAAKjD,EAASR,GAAQ,WACtBksD,EAAGT,SAvT8B,IAwTG,CACpCxqD,UAAU,IACVkpB,EAAkB1mB,EAAGtC,UAAW+tD,EAAiBzrD,EAAGnC,OACpDy6C,EAAiB58B,GAAkB3Z,OAAO+kB,eAAgB,CAAC,SAAuB,UAAwBJ,EAAiB,CAC3H7K,SAAS,EACTC,SAAS,IACVE,KACH,OAAO,WACHs8B,IACAmT,KA9S8BC,CAAiClD,EAAEmD,wBACjEC,GAgTgCzoC,EAhTaqlC,EAAErlC,UAgTJylC,EAhTeJ,EAAEI,cAiTzDzlC,EAAUhJ,UAAU,IAAkC,SAAUO,GACnE,IAAI1a,EAAIyT,EAAIC,EACkB,WAA1BgH,EAAK0N,YAAY3a,MACgB,UAAjCiN,EAAK0N,YAAYoB,OAAO/b,OAC4E,QAAlGgG,EAAoD,QAA9CzT,EAAK0a,EAAK0N,YAAYoB,OAAO0J,mBAAgC,IAAPlzB,OAAgB,EAASA,EAAGyN,YAAyB,IAAPgG,OAAgB,EAASA,EAAG5Y,SACxI,WAAY6f,EAAK2N,gBACqB,QAApC3U,EAAKgH,EAAK2N,cAAc1M,cAA2B,IAAPjI,OAAgB,EAASA,EAAG7Y,SAC1E+tD,EAAc,CACVngD,UAAWiS,EAAK0N,YAAYtf,KAC5B2E,KAAMusC,GACNt/B,KAAM,CACFukB,iBAAkBvkB,EAAK0N,YAAYoB,OAAO0J,YAAYzlB,KACtD46C,UAAW3tC,EAAK2N,cAAc1M,OAAOxa,KAAI,SAAUxE,GAAK,OAAO2rD,GAAoB3rD,YAIhG4d,aAhUH,MAAO,CACHw5B,MAAO,WACH8U,EAAgB9U,SAEpB/3B,KAAM,WACF6sC,EAAgB7sC,OAChB+sC,IACAQ,IACAO,IACAI,IACAG,IACAG,IACAC,IACAa,IACAE,IACAI,MA+BZ,IAAIlC,KAA+B1pD,GAAK,IASL,UAAIm6C,GACnCn6C,GAA+B,UAAIm6C,GACnCn6C,GAAsB,MAAIm6C,GAC1Bn6C,GAAmC,YAAIm6C,GACvCn6C,GAA6B,SAAIm6C,GACjCn6C,GAAsB,MAAIm6C,GAC1Bn6C,GAAoB,KAAIm6C,GACxBn6C,GAAiC,WAAIm6C,GACrCn6C,GAA6B,SAAIm6C,GACjCn6C,IA4BJ,SAASmpD,GAAwB9+C,GAC7B,IAAIrK,EAAKmiD,GAAa93C,GAASA,EAAM+3C,eAAe,GAAK/3C,EAAOqzB,EAAI19B,EAAG+1B,QAAS6H,EAAI59B,EAAGg2B,QACvF,GAAIj0B,OAAO+kB,eAAgB,CACvB,IAAIrT,EAAKyzC,GAAqCxpB,EAAGE,GACjDF,EADuEjqB,EAAG6zC,gBAE1E1pB,EAF6GnqB,EAAG8zC,gBAIpH,GAAK7kC,OAAOmpC,SAASnuB,IAAOhb,OAAOmpC,SAASjuB,GAM5C,MAAO,CAAEF,EAAGA,EAAGE,EAAGA,GALVvzB,EAAMwgB,WACNrN,GAAkB,iCAoCvB,SAAS8sC,GAAkB7B,EAAItvC,EAAqBnZ,GACvD,IAAIyT,OAAY,IAAPzT,EAAgB,GAAKA,EAAI0T,EAAKD,EAAG2rB,UAAWA,OAAmB,IAAP1rB,EAAgB,CAAC,QAAqB,UAAyBA,EAAI+D,EAAKhE,EAAG1V,OAAQA,OAAgB,IAAP0Z,EAAgBnO,SAAWmO,EACpLq0C,EAAoB,IAAI/9B,QAC5B,SAASg+B,EAAgBhuD,GACrB,IAAI++C,EAAmB3B,GAAoBp9C,EAAQob,GACnD,GAAI2jC,IAAqBzC,GAAiBE,OAA1C,CAGA,IACIyR,EADAv+C,EAAO1P,EAAO0P,KAElB,GAAa,UAATA,GAA6B,aAATA,EAAqB,CACzC,GAAIyuC,GAAen+C,EAAQ++C,GACvB,OAEJkP,EAAa,CAAEC,UAAWluD,EAAO4iD,aAEhC,CACD,IAAIthD,EAAQw9C,GAAqB9+C,EAAQ++C,GACzC,QAAcz/C,IAAVgC,EACA,OAEJ2sD,EAAa,CAAEE,KAAM7sD,GAGzB8sD,EAAYpuD,EAAQiuD,GAEpB,IJ/LgBlnD,EAAMgC,EI+LlBtE,EAAOzE,EAAOyE,KACL,UAATiL,GAAoBjL,GAAQzE,EAAO4iD,UJhMvB77C,EIiMJwE,SAASuuB,iBAAiB,6BAAgC17B,OAAOqG,EAAM,OJjM7DsE,EIiMsE,SAAU24C,GAC1FA,IAAO1hD,GAEPouD,EAAY1M,EAAI,CAAEwM,WAAW,KJnM7ChwD,MAAMlB,UAAUkD,QAAQhD,KAAK6J,EAAMgC,KI2MnC,SAASqlD,EAAYpuD,EAAQiuD,GACzB,GAAKrP,GAAkB5+C,GAAvB,CAGA,IAAIquD,EAAiBN,EAAkBpqD,IAAI3D,GACtCquD,GACDA,EAAeF,OAASF,EAAWE,MACnCE,EAAeH,YAAcD,EAAWC,YACxCH,EAAkB3lD,IAAIpI,EAAQiuD,GAC9BvD,EAAG,EAAO,CACNp/B,GAAIuzB,GAAoB7+C,IACzBiuD,MAGX,IAAIK,EAAqB3wC,GAAkB3d,EAAQqhC,GAAW,SAAU/0B,GACpE,IAAItM,EAASkrD,GAAe5+C,IACxBtM,aAAkBw5B,kBAClBx5B,aAAkBuuD,qBAClBvuD,aAAkBwuD,oBAClBR,EAAgBhuD,KAErB,CACC8d,SAAS,EACTC,SAAS,IACVE,KACC4uC,EAA0B,CAC1Bn9B,GAAiB8J,iBAAiBx8B,UAAW,QAASgxD,GACtDt+B,GAAiB8J,iBAAiBx8B,UAAW,UAAWgxD,GACxDt+B,GAAiB8+B,kBAAkBxxD,UAAW,QAASgxD,GACvDt+B,GAAiB6+B,oBAAoBvxD,UAAW,QAASgxD,GACzDt+B,GAAiB8+B,kBAAkBxxD,UAAW,gBAAiBgxD,IAEnE,OAAO,WACHnB,EAAwB3sD,SAAQ,SAAUktD,GAAW,OAAOA,EAAQnvC,UACpEqwC,KAgHR,SAASpD,GAAe5+C,GACpB,OAAuB,IAAnBA,EAAMmiD,UAAqBnrC,GAAiBhX,EAAMtM,QAC3CsM,EAAMoiD,eAAe,GAEzBpiD,EAAMtM,OC9VV,SAAS4rD,GAAO1sD,GACnB,IAAIyvD,EAAOzvD,EAAQyvD,KAEnB,IAAKA,EACD,MAAM,IAAIn/C,MAAM,6BAEpB,IAAIwzC,ECfD,WACH,IAAI4L,EAA2B,IAAI5+B,QACnC,MAAO,CACH5nB,IAAK,SAAUlE,EAAS8nD,IAChB9nD,IAAYqH,UAAaA,SAASsjD,mBAKtCD,EAAyBxmD,IAAIlE,IAAYqH,SAAWA,SAASsjD,iBAAmB3qD,EAAS8nD,IAE7FroD,IAAK,SAAUO,GACX,OAAO0qD,EAAyBjrD,IAAIO,IAExCwB,IAAK,SAAUxB,GACX,OAAO0qD,EAAyBlpD,IAAIxB,KDAd4qD,GAC1B/D,EAAa,SAAUnF,GACvB+I,EAAKrK,GAA4BnI,GAA4ByJ,KAE7D4G,EAAU,SAAUv2B,GAAK,OAAO04B,EAAKrK,GAA4BnI,GAAyBlmB,KAC1FgrB,EEjB+B,SAAUhtC,EAAehS,GAC5D,IAAI8oD,EAAa9oD,EAAG8oD,WAAYyB,EAAUvqD,EAAGuqD,QACzCuC,EAAyB,IAAI3I,IAC7BnF,EAAwB,CACxBC,cAAe,SAAU39B,GACrB,IAAIthB,EAAKwjD,GAAsBsF,EAAY92C,EAAegtC,EAAuB19B,GAAayrC,EAAuB/sD,EAAGgc,KAAM+3B,EAAQ/zC,EAAG+zC,MAErIiZ,EAAoB1C,GAAkBC,EAASv4C,EAAcmH,oBAAqB,CAClFpb,OAAQujB,EACR8d,UAAW,CAAC,YAEhB0tB,EAAuB3mD,IAAImb,EAAY,CACnCyyB,MAAOA,EACP/3B,KAAM,WACF+wC,IACAC,QAIZjJ,iBAAkB,SAAUziC,GACxB,IAAIpC,EAAQ4tC,EAAuBprD,IAAI4f,GAClCpC,GAWLA,EAAMlD,OACN8wC,EAAuBxI,OAAOhjC,IAX1B9D,GAAkB,wBAAyB,CACvC8D,WAAYA,EAAaA,EAAWyW,SAAW,eAC/Ck1B,eAAgB3rC,EAAaA,EAAW4rC,kBAAoB,KAC5DC,2BAA4BL,EAAuBjnD,KACnDunD,KAAM9rC,GAAc1W,GAA6B,oBAC3C0W,EAAW+rC,UAAUC,UAAU,EAAG,UAClCjwD,KAOlB2e,KAAM,WACF8wC,EAAuB7uD,SAAQ,SAAU+B,GAErC,OAAOgc,EADIhc,EAAGgc,YAItB+3B,MAAO,WACH+Y,EAAuB7uD,SAAQ,SAAU+B,GAErC,OAAO+zC,EADK/zC,EAAG+zC,cAK3B,OAAOiL,EF/BqBuO,CAA0BtwD,EAAQ+U,cAAe,CAAE82C,WAAYA,EAAYyB,QAASA,IAC5GiD,EAAmB,SAAU/kD,EAAW81C,QACtB,IAAd91C,IAAwBA,EAAYV,UACX,IAAzBw2C,IAAmCA,EAAuB,CAC1DjpC,OAAQ,EACRyrC,wBAAyBA,EACzB/B,sBAAuBA,IAE3B,IAAIh/C,EAAK2mB,KAAwBI,EAAQ/mB,EAAG+mB,MAAOE,EAASjnB,EAAGinB,OAC/DylC,EAAK,CACDhyC,KAAM,CACFuM,OAAQA,EACRxY,KAAM1M,OAAOyI,SAASiE,KACtBsY,MAAOA,GAEXtZ,KAAMusC,GACNvxC,UAAWA,IAEfikD,EAAK,CACDhyC,KAAM,CACF6wC,UAAWjiD,SAASkhB,YAExB/c,KAAMusC,GACNvxC,UAAWA,IAEfikD,EAAK,CACDhyC,KAAM,CACFqG,KAAMu9B,GAAkBh1C,SAAUrM,EAAQ+U,cAAeusC,GACzDkP,cAAe,CACX9vB,KAAMsqB,KACNpqB,IAAKsqB,OAGb16C,KAAMusC,GACNvxC,UAAWA,IAEX1G,OAAO+kB,gBACP4lC,EAAK,CACDhyC,KAAMstC,KACNv6C,KAAMusC,GACNvxC,UAAWA,KAIvB+kD,IACA,IAAIxtD,EAAKuoD,GAAc,CACnBplC,UAAWlmB,EAAQkmB,UACnBnR,cAAe/U,EAAQ+U,cACvB+uC,wBAAyBA,EACzBwJ,QAASA,EACT7B,mBAAoB,SAAUgF,GAC1B,OAAOhB,EAAKrK,GAA4BnI,GAAoCwT,KAEhF7D,mBAAoB,SAAU8D,GAA0B,OAAOjB,EAAKiB,IACpErE,YAAa,SAAUsE,EAAW1vD,GAAU,OAAOwuD,EAAKrK,GAA4BnkD,EAAQ,CAAE0vD,UAAWA,MACzG9E,WAAYA,EACZmB,SAAU,SAAUyD,GAAK,OAAOhB,EAAKrK,GAA4BnI,GAA0BwT,KAC3FrC,aAAc,SAAUwC,GAAK,OAAOnB,EAAKrK,GAA4BnI,GAAkC2T,KACvGzD,iBAAkB,SAAU0D,GAAK,OAAOpB,EAAKrK,GAA4BnI,GAAkC4T,KAC3GlF,cAAe,SAAUmF,GAAqB,OAAOrB,EAAKqB,IAC1DpF,QAAS,SAAUjuC,GACf,OAAOgyC,EAAK,CACRhyC,KAAMA,EACNjN,KAAMusC,GACNvxC,UAAWV,OAGnB4jD,uBAAwB,SAAUjxC,GAC9BgyC,EAAK,CACDhyC,KAAMA,EACNjN,KAAMusC,GACNvxC,UAAWV,OAGnBi3C,sBAAuBA,IACvBgP,EAAgBhuD,EAAGgc,KAAMiyC,EAA8BjuD,EAAG+zC,MAC9D,SAASma,IACLlP,EAAsBjL,QACtBka,IAEJ,MAAO,CACHjyC,KAAM,WACFgjC,EAAsBhjC,OACtBgyC,KAEJG,2BAA4B,SAAU1lD,GAClCylD,IACAV,EAAiB/kD,EAAW,CACxBu2C,sBAAuBA,EACvB1pC,OAAQ,EACRyrC,wBAAyBA,KAGjCmN,eAAgBA,EAChBlP,sBAAuBA,GGjHxB,SAASoP,GAAmB1zC,EAAM2zC,EAAUC,GAC/C,IAAIC,EAAW,IAAIC,SAMnB,OALAD,EAASh+B,OAAO,UAAW,IAAI3qB,KAAK,CAAC8U,GAAO,CACxCjN,KAAM,6BACN,GAAGtR,OAAOkyD,EAASzlC,QAAQS,GAAI,KAAKltB,OAAOkyD,EAASjmD,QACxDqmD,GAAcJ,GAAU,SAAUlwD,EAAKkB,GAAS,OAAOkvD,EAASh+B,OAAOpyB,EAAKkB,MAC5EkvD,EAASh+B,OAAO,mBAAoB+9B,EAAqB3vD,YAClD,CAAE+b,KAAM6zC,EAAUja,WAAY55B,EAAKg0C,YAEvC,SAASD,GAAcp/B,EAAOs/B,EAASC,QAC3B,IAAXA,IAAqBA,EAAS,IAClCxtD,EAAciuB,GAAOpxB,SAAQ,SAAU+B,GACnC,IAAI7B,EAAM6B,EAAG,GAAIX,EAAQW,EAAG,GACP,kBAAVX,GAAgC,OAAVA,EAC7BovD,GAAcpvD,EAAOsvD,EAAS,GAAGxyD,OAAOyyD,GAAQzyD,OAAOgC,EAAK,MAG5DwwD,EAAQ,GAAGxyD,OAAOyyD,GAAQzyD,OAAOgC,GAAMmN,OAAOjM,OClBnD,IACHwvD,GACG,SAASC,GAAiBliB,GAC7B,OAAOmiB,GAAuBniB,GAAQoiB,eAKnC,SAASC,GAAUriB,GACtBmiB,GAAuBniB,GAAQsiB,eAAiB,EAK7C,SAAS1hB,GAAeZ,GAC3B,OAAwB,OAAjBiiB,SAA0C,IAAjBA,QAA0B,EAASA,GAAantD,IAAIkrC,GAKxF,SAASmiB,GAAuBniB,GAI5B,IAAIW,EAeJ,OAlBKshB,KACDA,GAAe,IAAI1K,KAGnB0K,GAAaprD,IAAImpC,GACjBW,EAAcshB,GAAantD,IAAIkrC,IAG/BW,EAAc,CACV2hB,cAAe,EACfF,eAAgB,EAChBG,wBAAyB,GAE7BN,GAAa1oD,IAAIymC,EAAQW,GACrBshB,GAAahpD,KAnCM,IAyC/B,WACI,IAAKgpD,GACD,OAEJ,GAAIA,GAAa3tD,KACb2tD,GAAavK,OAAOuK,GAAa3tD,OAAOouC,OAAOjwC,WAE9C,CAED,IAAI+vD,GAAY,EAChBP,GAAa5wD,SAAQ,SAAUoxD,EAAQlxD,GAC/BixD,IACAP,GAAavK,OAAOnmD,GACpBixD,GAAY,OAlBhBE,IAGD/hB,ECpCX,IAAI,GAAS,EACTgiB,GAAyB,WACzB,SAASA,EAAQC,EAAQ9yD,EAAS+yD,EAAgBC,EAAeC,EAASC,GACtE,IAAIv1C,EAAQ5d,KACZA,KAAK+yD,OAASA,EACd/yD,KAAK4sB,GAAK,KACV,IAAIujB,EAASlwC,EAAQ4sB,KAAKD,GAC1B5sB,KAAK4xD,SAAW,EAAO,CACnBjmD,MAAOsnD,EAAcjnD,UACrBJ,IAAKqnD,EAAcjnD,UACnBonD,gBAAiBJ,EACjBP,cAAe,EACfY,kBAAmBJ,EAAcjiD,OAASusC,GAC1C+V,cAAe,GAA6BnjB,GAC5C1uC,OAAQ,WACTxB,GDbJ,SAAoBkwC,GACvBmiB,GAAuBniB,GAAQoiB,gBAAkB,ECa7C,CAAuBpiB,GACvB,GAAsBA,GACtB,IAAInxB,EAAWlf,GAAQ,SAAUyD,GAC7B,IAAI0a,EAAO1a,EAAG0a,KACI,YAAdA,EAAKjN,MAAoC,gBAAdiN,EAAKjN,OAGhCiN,EAAK2O,KAAOhP,EAAMgP,KDf3B,SAAsBujB,EAAQojB,GACjCjB,GAAuBniB,GAAQuiB,yBAA2Ba,ECe9C,CAAyBpjB,EAAQlyB,EAAKs1C,sBACpB,YAAdt1C,EAAKjN,MACLmiD,EAAUl1C,EAAK9M,OAAQ8M,EAAKu1C,eAC5BT,EAAOxgC,oBAAoB,UAAWvT,IAGtCk0C,EAAQj1C,EAAKw1C,uBAGZx1C,EAAK2O,GAAKhP,EAAMgP,KASrBmmC,EAAOxgC,oBAAoB,UAAWvT,GACtC+B,GAAkB,0EAG1BgyC,EAAOj0C,iBAAiB,UAAWE,GACnC5B,GAAgB,SAAU,CAAE8vC,OAAQ+F,EAAeS,QAAS1zD,KAAK4xD,WACjE5xD,KAAK+yD,OAAOY,YAAY,CAAE11C,KAAM,eAAiBve,OAAOqD,KAAKC,UAAUiwD,IAAiBrmC,GAAI5sB,KAAK4sB,GAAIG,OAAQ,UAoBjH,OAlBA+lC,EAAQx0D,UAAUk0D,UAAY,SAAUtF,GACpC,IAAI3pD,EACJvD,KAAK4xD,SAASjmD,MAAQ3J,KAAKk3C,IAAIl5C,KAAK4xD,SAASjmD,MAAOuhD,EAAOlhD,WAC3DhM,KAAK4xD,SAAShmD,IAAM5J,KAAK+sB,IAAI/uB,KAAK4xD,SAAShmD,IAAKshD,EAAOlhD,WACvDhM,KAAK4xD,SAASa,eAAiB,EAC/B,GAAsBzyD,KAAK4xD,SAAS/kC,KAAKD,KACxCrpB,EAAKvD,KAAK4xD,UAAUyB,oBAAsB9vD,EAAG8vD,kBAAoBnG,EAAOl8C,OAASusC,IAClFngC,GAAgB,SAAU,CAAE8vC,OAAQA,EAAQwG,QAAS1zD,KAAK4xD,WAC1D5xD,KAAK+yD,OAAOY,YAAY,CAAE11C,KAAM,IAAIve,OAAOqD,KAAKC,UAAUkqD,IAAUtgC,GAAI5sB,KAAK4sB,GAAIG,OAAQ,WAE7F+lC,EAAQx0D,UAAUg5C,MAAQ,SAAUhT,GAChCtkC,KAAK+yD,OAAOY,YAAY,CACpB11C,KAAM,KAAKve,OAAOqD,KAAKC,UAAUhD,KAAK4xD,UAAUnyD,MAAM,GAAI,MAC1DmtB,GAAI5sB,KAAK4sB,GACTG,OAAQ,UAEZ/sB,KAAK4zD,YAActvB,GAEhBwuB,EAnEiB,GCIjBe,GAAsB,IAyB1B,SAASC,GAAuBptC,EAAWnQ,EAAe4C,EAAgB6R,EAAc+oC,EAAahB,GACxG,OAEG,SAAkCrsC,EAAWstC,EAAmBD,EAAahB,GAChF,IAAI/gC,EAAQ,CACRnZ,OAAQ,EACRo7C,0BAA2B,QAE3BC,EAAyBxtC,EAAUhJ,UAAU,GAAsB,WACnEy2C,EAAa,kBACdr2C,YACCs2C,EAAwB1tC,EAAUhJ,UAAU,GAAqB,SAAUixB,GAC3EwlB,EAAaxlB,EAAcrK,WAC5BxmB,YACH,SAASq2C,EAAaP,GACG,IAAjB5hC,EAAMnZ,SACNmZ,EAAM0hC,QAAQpc,MAAMsc,GACpBvyD,aAAa2wB,EAAMqiC,sBAGnBriC,EADgB,SAAhB4hC,EACQ,CACJ/6C,OAAQ,EACRo7C,0BAA2BL,GAIvB,CACJ/6C,OAAQ,GAIpB,SAASy7C,EAAiBtB,EAAgBC,GACtC,IAAIhzD,EAAU+zD,IACd,GAAK/zD,EAAL,CAGA,IAAIyzD,EAAU,IAAIZ,GAAQC,EAAQ9yD,EAAS+yD,EAAgBC,GAAe,SAAUsB,IAC3Eb,EAAQE,aAAeW,EAA8BV,IACtDM,EAAa,0BAElB,SAAUl2C,EAAM4zC,GACf,IAAIx0C,EAAUs0C,GAAmB1zC,EAAMy1C,EAAQ9B,SAAUC,GAC7B,sBAAxB6B,EAAQE,aAA+D,kBAAxBF,EAAQE,YACvDG,EAAYxc,WAAWl6B,GAGvB02C,EAAYrmD,KAAK2P,MAGzB2U,EAAQ,CACJnZ,OAAQ,EACR66C,QAASA,EACTW,oBAAqBlzD,WAAWrB,GAAQ,WACpCq0D,EAAa,6BAnFO,OAuFhC,MAAO,CACH3B,UAAW,SAAUtF,GACjB,OAAQl7B,EAAMnZ,QACV,KAAK,EACDy7C,EAAiBtiC,EAAMiiC,0BAA2B/G,GAClD,MACJ,KAAK,EACDl7B,EAAM0hC,QAAQlB,UAAUtF,KAIpC3tC,KAAM,WACF40C,EAAa,QACbD,IACAE,MAtEDI,CAAyB9tC,GAAW,WAAc,OA0EtD,SAA+BnQ,EAAe4C,EAAgB6R,GACjE,IAAImB,EAAUhT,EAAeG,qBACzByS,EAAcf,EAAagB,WAC/B,IAAKG,IAAYJ,EACb,OAEJ,MAAO,CACHY,YAAa,CACTC,GAAIrW,GAER4V,QAAS,CACLS,GAAIT,EAAQS,IAEhBC,KAAM,CACFD,GAAIb,EAAYa,KAxFwC6nC,CAAsBl+C,EAAe4C,EAAgB6R,KAAkB+oC,EAAahB,G,gBChCpJ/gC,GAAQ,CAAEnZ,OAAQ,GACf,SAAS67C,GAAmBrqD,EAAUsqD,GAEzC,YADgC,IAA5BA,IAAsCA,EAA0B,MAC5D3iC,GAAMnZ,QACV,KAAK,EACDmZ,GAAQ,CAAEnZ,OAAQ,EAAiBwW,UAAW,CAAChlB,IA0BpD,SAA8BsqD,QACD,IAA5BA,IAAsCA,EAA0B,MACpE,IACI,IAAIC,EAAWD,IACfC,EAAS91C,iBAAiB,QAAShf,EAAQ+0D,KAC3CD,EAAS91C,iBAAiB,UAAWhf,GAAQ,SAAUyD,GACnD,IAeWwvD,EAfP90C,EAAO1a,EAAG0a,KACI,YAAdA,EAAKjN,KACL6jD,GAAQ52C,EAAKngB,OAEM,gBAAdmgB,EAAKjN,OAWH+hD,EAVO6B,EAWL,IAAjB5iC,GAAMnZ,SACNmZ,GAAM3C,UAAU7tB,SAAQ,SAAU6I,GAAY,OAAOA,EAAS0oD,MAC9D/gC,GAAQ,CAAEnZ,OAAQ,EAAqBk6C,OAAQA,SAV/C6B,EAASjB,YAAY,CAAE5mC,OAAQ,SAGnC,MAAOjvB,GACH+2D,GAAQ/2D,IA3CJg3D,CAAqBH,GACrB,MACJ,KAAK,EACD3iC,GAAM3C,UAAUlrB,KAAKkG,GACrB,MACJ,KAAK,EACDA,IACA,MACJ,KAAK,EACDA,EAAS2nB,GAAM+gC,SA2C3B,SAAS8B,GAAQ/2D,GACQ,IAAjBk0B,GAAMnZ,QACN9a,EAAQD,MAAM,yFAA0FA,GACpGA,aAAiBi3D,OAAUj3D,aAAiBgT,OAASpN,EAAS5F,EAAMoS,QAAS,2BAC7EnS,EAAQD,MAAM,4HAId6iB,GAAkB7iB,GAEtBk0B,GAAM3C,UAAU7tB,SAAQ,SAAU6I,GAAY,OAAOA,OACrD2nB,GAAQ,CAAEnZ,OAAQ,IAGlB8H,GAAkB7iB,GCpE1B,IAAImf,GCHG,SAAyB+3C,EAAoBC,GAEhD,QAD+B,IAA3BA,IAAqCA,EAAyBP,IAC9D7mD,MA4FkB,oBAAfrO,MAAML,MAAkD,oBAApBqvD,mBAAkC,YAAa0G,SAAS52D,WA3F/F,MAAO,CACHqN,MAAOjJ,EACP6c,KAAM7c,EACNquC,eAAgB,aAChBokB,WAAYzyD,EACZya,YAAa,WAAc,OAAO,IAG1C,IAAI6U,EAAQ,CACRnZ,OAAQ,GAERu8C,EAAgB,WAChBpjC,EAAQ,CAAEnZ,OAAQ,IAElBw8C,EAAe,WACfrjC,EAAQ,CAAEnZ,OAAQ,IAEtB,MAAO,CACHlN,MAAO,WAAc,OAAOypD,KAC5B71C,KAAM,WAAc,OAAO81C,KAC3BtkB,eAAgBA,GAChBokB,WAAY,SAAUzuC,EAAWnR,EAAe4D,EAAgB6R,GAC5DtE,EAAUhJ,UAAU,GAAyB,WACpB,IAAjBsU,EAAMnZ,QAAgD,IAAjBmZ,EAAMnZ,SAC3Cw8C,IACArjC,EAAQ,CAAEnZ,OAAQ,OAG1B6N,EAAUhJ,UAAU,GAAyB,WACpB,IAAjBsU,EAAMnZ,QACNu8C,OAGRA,EAAgB,WACZ,IAAIjpC,EAAUhT,EAAeG,qBACxB6S,GAAYA,EAAQyqB,qBAIJ,IAAjB5kB,EAAMnZ,QAAgD,IAAjBmZ,EAAMnZ,SAG/CmZ,EAAQ,CAAEnZ,OAAQ,GAClB4I,GAAgB,eAAe,WACN,IAAjBuQ,EAAMnZ,QAGVo8C,GAAuB,SAAUlC,GAC7B,GAAqB,IAAjB/gC,EAAMnZ,OAGV,GAAKk6C,EAAL,CAMA,IAAIuC,EAAgBN,EAAmBtuC,EAAWnR,EAAe4D,EAAgB6R,EAAc+nC,GAAQxzC,KACvGyS,EAAQ,CACJnZ,OAAQ,EACRy8C,cAAeA,QARftjC,EAAQ,CACJnZ,OAAQ,UAjBpBmZ,EAAQ,CAAEnZ,OAAQ,IA6B1Bw8C,EAAe,WACU,IAAjBrjC,EAAMnZ,SAGW,IAAjBmZ,EAAMnZ,QACNmZ,EAAMsjC,gBAEVtjC,EAAQ,CACJnZ,OAAQ,KAGK,IAAjBmZ,EAAMnZ,QACNu8C,KAGRj4C,YAAa,WAAc,OAAwB,IAAjB6U,EAAMnZ,SDhF9B08C,EEFX,SAAwB7uC,EAAWnR,EAAe4D,EAAgB6R,EAAc+nC,EAAQgB,GAC3F,IAGIyB,EAAgBzB,GAAera,GAAkBnkC,EAAcS,6BAA8B69C,IAH/E,SAAU/1D,GACxB4oB,EAAU1I,OAAO,GAA8B,CAAElgB,MAAOA,OAGxDyF,EAAKuwD,GAAuBptC,EAAWnR,EAAcgB,cAAe4C,EAAgB6R,EAAcwqC,EAAezC,GAASP,EAAYjvD,EAAGivD,UAAWiD,EAAwBlyD,EAAGgc,KAC/KvI,EAAKk2C,GAAO,CACZ+C,KAAMuC,EACNj9C,cAAeA,EACfmR,UAAWA,IACX4uC,EAAgBt+C,EAAGuI,KAAMmyC,EAA6B16C,EAAG06C,2BAA4BD,EAAiBz6C,EAAGy6C,eACzGiE,EAAuBhvC,EAAUhJ,UAAU,GAAoB,WAC/D+zC,IACAe,EAAU,CACNxmD,UAAWV,IACX0F,KAAMusC,QAEXz/B,YACCo2C,EAAyBxtC,EAAUhJ,UAAU,GAAsB,SAAUmP,GAC7E6kC,EAA2B7kC,EAAKlc,YAAYjG,cAC7CoT,YACH,MAAO,CACHyB,KAAM,WACFm2C,IACAxB,IACAoB,IACAG,SFvBDE,GGJJ,SAA0BC,EAAc34C,EAAa1Z,GACxD,IAAkC0T,QAAlB,IAAP1T,EAAgB,GAAKA,GAAYsyD,oCAAqCA,OAA6C,IAAP5+C,GAAuBA,EACxI6+C,GAAuB,EACvB/4C,EAAuB1T,IACvB2T,EAAqB3T,IACrB0sD,EAA6B,aAC7BC,EAA+B,aAC/BC,EAAiB,IAAI9rD,EACrB+rD,EAAoB,SAAUnwD,EAAM4pC,QACvB,IAATA,IAAmBA,EAAOrkC,KAC9B2qD,EAAehvD,KAAI,WAAc,OAAOivD,EAAkBnwD,EAAM4pC,OAEhEwmB,EAAoB,SAAU31D,EAASmQ,QACnB,IAAhBA,IAA0BA,EAAcnF,MAC5CyqD,EAAehvD,KAAI,WAAc,OAAOkvD,EAAkB31D,EAASmQ,OAEnEylD,EAAoB,SAAUrpC,EAAQX,QAChB,IAAlBA,IAA4BA,EAAgBtP,GAAmBC,EAAsBC,EAAoBC,IAC7Gg5C,EAAehvD,KAAI,WAAc,OAAOmvD,EAAkBrpC,EAAQX,OAElEiqC,EAAmB,SAAUC,EAAelqC,QACtB,IAAlBA,IAA4BA,EAAgBtP,GAAmBC,EAAsBC,EAAoBC,IAC7Gg5C,EAAehvD,KAAI,WAAc,OAAOovD,EAAiBC,EAAelqC,OAExEmqC,EAAmC,SAAU70D,EAAKkB,GAClDqzD,EAAehvD,KAAI,WAAc,OAAOsvD,EAAiC70D,EAAKkB,OA+ClF,SAAS4zD,EAAWljD,EAAmBiC,EAAey4B,GAClD,IAAIyoB,EAAkBb,EAAatiD,EAAmBiC,EAAe0H,EAAaF,EAAsBC,EAAoBgxB,GAC3HmoB,EAAoBM,EAAgB7mB,UAAWwmB,EAAoBK,EAAgBC,UAAWL,EAAmBI,EAAgBlvB,SAAU2uB,EAAoBO,EAAgB/mB,UAAW6mB,EAAmCE,EAAgBE,yBAA0BZ,EAA6BU,EAAgBG,mBACrTX,EAAe1rD,QACf0S,EAAYk4C,WAAWsB,EAAgB/vC,UAAWnR,EAAekhD,EAAgBtqC,QAASsqC,EAAgBzrC,cAE9G,IAAI4kB,EAAY9vC,GAAQ,SAAUU,GAE9B21D,EAD0C,kBAAZ31D,EAAuBA,EAAU,CAAEuF,KAAMvF,OAGvEq2D,EClFD,SAAuBC,GAC1B,IAAIC,EAAY,EAAO,CACnBrhD,QAAS,SAITshD,QAAS,SAAU3sD,GACfA,MAELysD,GASH,OANAz4D,OAAO2G,eAAe+xD,EAAW,YAAa,CAC1C9xD,IAAK,WACD,OAAOrF,GAEXq3D,YAAY,IAETF,EDgEYG,CAAc,CAC7BrkC,KAAM/yB,GAxDV,SAAiBwT,GAOb,GALA0iD,EAA+B,WAAc,OAAOluD,EAAUwL,KAK1DuiD,IAAuC3oD,KAA3C,CAGA,GAAIW,KACAyF,EA2HR,SAA4CA,GACxC,OAAO,EAAO,GAAIA,EAAmB,CACjCiD,cAAe,uCACf7B,YAAa,QACbwC,kBAAmB,MA/HCigD,CAAmC7jD,QAEtD,IAqGT,SAA0BA,GACtB,ItG/HD,SAA8B9S,GACjC,QAAwBI,IAApBiM,SAASC,QAA4C,OAApBD,SAASC,OAC1C,OAAO,EAEX,IAGI,IAAI0L,EAAiB,kBAAkB9Y,OAAOmC,KAC1Cu1D,EAAkB,OACtBjrD,GAAUqM,EAAgB4+C,EAAiB/2D,EAAYG,GACvD,IAAI62D,EAAuBtqD,GAAUyL,KAAoB4+C,EAEzD,OADApqD,GAAawL,EAAgBhY,GACtB62D,EAEX,MAAOv5D,GAEH,OADAC,EAAQD,MAAMA,IACP,GsG+GFw5D,CAAqB1/C,GAAmBtE,IAEzC,OADAvV,EAAQF,KAAK,2DACN,EAEX,GAuBoC,UAA7ByH,OAAOyI,SAASnI,SArBnB,OADA7H,EAAQD,MAAM,qDACP,EAEX,OAAO,EA9GGy5D,CAAiBjkD,GACvB,OAEJ,GA6GJ,SAAoBA,GAChB,GAAIwiD,EAIA,OAHKxiD,EAAkBuE,oBACnB9Z,EAAQD,MAAM,mCAEX,EAEX,OAAO,EApHF05D,CAAWlkD,GAAhB,CAGA,IAAIiC,EAAgBwF,GAAiCzH,GACrD,GAAKiC,EAAL,CASA,GANIpH,GAA6B,mBAE7B0oD,EAAaF,yBAA2B72D,GAAQ,SAAU4B,EAAKkB,GAC3D2zD,EAAiC70D,EAAKkB,OAGzC2S,EAAcgH,mBAGd,CAID,IAAIk7C,EAAkBxB,EACtBA,EAAiB,IAAI9rD,EACrBgsD,EAAoB,SAAU31D,GAC1Bg2D,EAAWljD,EAAmBiC,EAAe/U,IAEjDi3D,EAAgBltD,aAXhBisD,EAAWljD,EAAmBiC,GAalCugD,GAAuB,QAevB4B,oBAAqB53D,EAAQid,EAAqB9V,KAClD0wD,yBAA0B73D,EAAQid,EAAqBjT,oBAEvD8tD,uBAAwB93D,EAAQid,EAAqBtT,QACrDouD,4BAA6B/3D,EAAQid,EAAqB/S,uBAE1D8tD,oBAAqBh4D,EAAQid,EAAqB9X,KAClD8yD,iBAAkBj4D,EAAQid,EAAqBnT,YAE/CouD,oBAAqBl4D,EAAQid,EAAqBrT,KAClDuuD,iBAAkBn4D,EAAQid,EAAqBlT,YAC/CquD,mBAAoBp4D,EAAQid,EAAqB9S,cACjD2sD,mBAAoB92D,GAAQ,SAAU4iB,GAAa,OAAOqzC,EAA2BrzC,MACrFy1C,qBAAsBr4D,GAAQ,WAAc,OAAOk2D,OACnDU,UAAW52D,GAAQ,SAAUiG,EAAM9F,GAC/Bm2D,EAAkB,CACdrwD,KAAMA,EACN9F,QAAS6H,EAAU7H,GACnB0Q,YAAanF,KACbwF,KAAM,cAGdu2B,SAAU,SAAUzpC,EAAOmC,GACvB,IAAIyQ,EAAgBY,KACpBvR,GAAc,WACVs2D,EAAiB,CACbv4D,MAAOA,EACP4S,cAAeA,EACfzQ,QAAS6H,EAAU7H,GACnB0Q,YAAanF,WAIzBkkC,UAAW5vC,GAAQ,SAAUiG,EAAM4pC,GAC/BumB,EAAkBnwD,EAAM4pC,MAE5ByoB,QAASt4D,GAAQ,SAAU8R,I/FvG5B,SAAmBA,GACtB,IAAIymD,EAA+B,WAArB7xD,EAAQoL,GAItB,OAHKymD,GACDt6D,EAAQD,MAAM,oBAAqB8T,GAEhCymD,G+FmGKC,CAAU1mD,IACVoL,EAAmBnT,WAAW8H,GAAaC,OAGnD2mD,QAASz4D,EAAQkd,EAAmBpT,YACpC4uD,gBAAiB14D,GAAQ,SAAU4B,EAAKqI,GACpC,IAAIxG,EACAk1D,EAAoB9mD,IAAcpO,EAAK,GAAIA,EAAG7B,GAAOqI,EAAUxG,IAAK7B,GACxEsb,EAAmBlT,mBAAmBpI,EAAK+2D,MAE/CC,mBAAoB54D,EAAQkd,EAAmBhT,uBAE/C2uD,WAAY74D,EAAQkd,EAAmB/S,cACvC2uD,UAAW94D,EAAQkd,EAAmB/S,cACtC2lC,UAAWA,EACXipB,4BAA6B/4D,EAAQmd,EAAYtR,OACjDmtD,2BAA4Bh5D,EAAQmd,EAAYsC,QAEpD,OAAOs3C,EHxIakC,EKiBjB,SAAkBzlD,EAAmBiC,EAAe0H,EAAaF,EAAsBC,EAAoBgxB,GAC9G,IAAItnB,EAAY,IAAI0I,GACpB1I,EAAUhJ,UAAU,IAA8B,SAAU9P,GAAS,OAAOwP,GAAgB,MAAOxP,MACnG,IAAI4S,EA0DR,SAA2BjL,GACvB,IAAIiL,EAAYP,GAAe,kBAA6B1K,GAC5D,GAAI1H,KAAqB,CACrB,IAAImrD,EAAW3rD,KACfmT,EAAUjC,WAAWb,WAAU,SAAU9P,GAAS,OAAOorD,EAAStrD,KAAK,qBAAsBE,MAEjG,OAAO4S,EAhESy4C,CAAkB1jD,GAClCiL,EAAUI,oBAAmB,WACzB,IAAIrd,EAAIyT,EACR,MAAO,CACH2V,YAAa,CACTC,GAAIrX,EAAcgB,eAEtB4V,QAAS,CACLS,GAA4C,QAAvCrpB,EAAK4oB,EAAQ7S,4BAAyC,IAAP/V,OAAgB,EAASA,EAAGqpB,IAEpFC,KAAM,CACFD,GAAuC,QAAlC5V,EAAKgU,EAAagB,kBAA+B,IAAPhV,OAAgB,EAASA,EAAG4V,IAE/EG,OAAQ,CACJH,GAAI1B,EAAeoB,oBAI/B,IAAInB,EAAc,SAAUrtB,GACxB4oB,EAAU1I,OAAO,GAA8B,CAAElgB,MAAOA,KAExD6oC,ECtCD,SAAkCjgB,EAAWpd,GAEhD,QAD8B,IAA1BA,IAAoCA,EAAwBN,IAC3DmF,GAA6B,iBAC9B,MAAO,CACHi5B,2BAA4B,aAC5B8xB,yBAA0B,WAAc,OAAO,GAC/CvC,yBAA0Bj0D,GAGlC,IACI6G,EADAo9B,EAAsB,IAAIhX,GAlBeJ,OA6B7C,OATA7I,EAAUhJ,UAAU,GAAoB,SAAUna,GAC9C,IAAIy+B,EAAYz+B,EAAGy+B,UACnB2E,EAAoBzW,YAAY8R,EAAUv3B,aAE9Cic,EAAUhJ,UAAU,GAAsB,SAAUna,GAChD,IAAIoN,EAAcpN,EAAGoN,YACrBg2B,EAAoB1/B,IAAI,GAAI0J,EAAYlG,UACxClB,OAAkB3I,KAEf,CACHwmC,2BAA4B,SAAU1kB,GAAa,OAAOikB,EAAoBviC,KAAKse,IACnFw2C,yBAA0B,WACtB,IAAIC,EAAiBxyB,EAAoBviC,OACzC,OAAK+0D,QAGmBv4D,IAApB2I,IACAA,EAAkBD,EAAsB3G,EAAcw2D,KAEnD5vD,GALI,GAOfotD,yBAA0B,SAAUj1D,EAAKkB,GACrC,IAAIu2D,EAAiBxyB,EAAoBviC,OACrC+0D,IACAA,EAAez3D,GAAOoG,EAAUlF,GAChC2G,OAAkB3I,KDEJw4D,CAAyB1yC,GACnD,GAAK7Y,MEhDF,SAA6B6Y,GAChC,IAAIzY,EAASZ,KACbqZ,EAAUhJ,UAAU,IAA8B,SAAU6O,GACxDte,EAAOP,KAAK,MAAO6e,MFsDnB8sC,CAAoB3yC,OATE,CACtB,IAAIswB,EGhDL,WACH,IAAIz4B,EAAa,IAAIhB,IAAW,WAK5B,IAAI+7C,EAA+Bx6C,GAAiBjS,SAAU,oBAA4C,WACrE,WAA7BA,SAAS09B,iBACThsB,EAAWP,OAAO,CAAEsmB,OAAQ,wBAEjC,CAAEllB,SAAS,IAAQG,KAMlBg6C,EAA2Bz6C,GAAiBxZ,OAAQ,gBAAoC,WACxFiZ,EAAWP,OAAO,CAAEsmB,OAAQ,qBAC7B/kB,KACH,OAAO,WACH+5C,IACAC,QAGR,OAAOh7C,EHwBsBi7C,GACzBxiB,EAAmBt5B,WAAU,SAAU9P,GACnC8Y,EAAU1I,OAAO,EAAqBpQ,MAE1C,IAAImtC,EAAQF,GAActlC,EAAemR,EAAWlG,EAAUjC,WAAY4M,EAAa6rB,IzBjDxF,SAAoCzhC,EAAeiL,EAAWkG,EAAW3J,EAAsBC,EAAoB2pB,EAAqB8yB,GACxGj5C,EAAUM,SAAW1e,EAAYmT,EAAcoH,mCAIlF2/B,KACAU,KAGAt2B,EAAUhJ,UAAU,IAA8B,SAAU9P,GACxDuuC,IAAmB,EACnBI,GAAcL,GAAqBW,mBAAqBj4C,EAAcmY,EAAqB9X,OAAgD,EAAvC8X,EAAqBvT,iBACzH+yC,GAAcL,GAAqBY,iBAAmBl4C,EAAcoY,EAAmB/X,OAA8C,EAArC+X,EAAmBxT,iBACnH,IAAI29B,EAAqBR,EAAoBS,6BACzCsyB,EAAwBh2D,EAAS,CAAC,OAAmB,SAAsBkK,EAAMoD,OACjFm2B,IACCviC,EAAcuiC,GACnBoV,GAAcL,GAAqBa,iBAAkB2c,EAAwB/yB,EAAoBuyB,2BAA6B,MAElIO,EAAqB/7C,WAAU,SAAUna,GACrC,IAAI6zC,EAAmB7zC,EAAG6zC,iBAAkBC,EAAsB9zC,EAAG8zC,oBAGhE8E,KAGLF,GAAsBI,YAAc,EACpCE,GAAcN,GAAsBU,gBAAiBvF,GACrDmF,GAAcN,GAAsBW,mBAAoBvF,GACxDqF,GAAaT,GAAsBY,mBAAoBX,GAAqBW,oBAC5EH,GAAaT,GAAsBa,iBAAkBZ,GAAqBY,kBAC1EJ,GAAaT,GAAsBc,iBAAkBb,GAAqBa,kBAC1EC,SAEJntB,YAAY/vB,EAAQs8C,IAtCc,MyBsD9Bud,CAA2BpkD,EAAeiL,EAAWkG,EAAW3J,EAAsBC,EAAoB2pB,EAAqBoU,EAAM9D,iBAKzI,IAAI9qB,EAAWte,K/BtBZ,WACH,IAAIse,EAAU,CACVS,GAAI,uCACJH,KAAM,EACNmqB,sBAAsB,EACtBC,iBAAiB,EACjB3M,iBAAiB,GAErB,MAAO,CACH5wB,mBAAoB,WAAc,OAAO6S,I+Ba2CytC,GAAnDpjB,GAAuBjhC,EAAemR,GACvEkQ,ElF5DD,WACH,IAAIrV,EAAmBF,KACnB9C,EAAa,IAAIhB,IAAW,WAC5B,GAAKgE,EAAL,CAGA,IAAIrD,EAAW,IAAIqD,EAAiBzhB,GAAQ,WAAc,OAAOye,EAAWP,aAO5E,OANAE,EAASoJ,QAAQza,SAAU,CACvBq2C,YAAY,EACZkH,eAAe,EACfE,WAAW,EACXC,SAAS,IAEN,WAAc,OAAOrsC,EAASsoB,kBAEzC,OAAOjoB,EkF6CqBs7C,GACxB/rB,EAA2ByN,GAA+BxtC,UAC1DxK,EA8BD,SAAiCmjB,EAAWnR,EAAexH,EAAUoL,EAAgB20B,EAA0BlX,EAAuB9Z,EAAoBqO,GAC7J,IAAIH,EI5FD,SAA2BtE,GAC9B,IAAIozC,EAAqB,IAAInqC,GAFQJ,OAqBrC,OAlBA7I,EAAUhJ,UAAU,GAAsB,SAAUmP,GAChDitC,EAAmB7yD,IASvB,SAA0B4lB,GACtB,MAAO,CACHpX,QAASoX,EAAKpX,QACdC,QAASmX,EAAKnX,QACdkX,GAAIC,EAAKD,GACT7mB,KAAM8mB,EAAK9mB,MAdQg0D,CAAiBltC,GAAOA,EAAKlc,YAAYlG,aAEpEic,EAAUhJ,UAAU,GAAoB,SAAUna,GAC9C,IAAIy+B,EAAYz+B,EAAGy+B,UACnB83B,EAAmB5pC,YAAY8R,EAAUv3B,aAE7Cic,EAAUhJ,UAAU,GAAyB,WACzCo8C,EAAmBzpC,WAUhB,CACHrE,SAAU,SAAUtJ,GAAa,OAAOo3C,EAAmB11D,KAAKse,IAChEnD,KAAM,WACFu6C,EAAmBv6C,SJqERy6C,CAAkBtzC,GACjCuE,EKxFD,SAA0BvE,EAAWonB,EAA0B//B,GAClE,IACIksD,EADAC,EAAoB,IAAIvqC,GAFQJ,OAIpC7I,EAAUhJ,UAAU,GAAoB,SAAUna,GAC9C,IAAIy+B,EAAYz+B,EAAGy+B,UACnBk4B,EAAkBhqC,YAAY8R,EAAUv3B,aAE5Cic,EAAUhJ,UAAU,GAAsB,SAAUna,GAChD,IAAIoN,EAAcpN,EAAGoN,YACjBwpD,EAAUpsD,EAASiE,KACvBkoD,EAAkBjzD,IAAImzD,EAAgB,CAClC3qD,IAAK0qD,EACLrtC,SAAWmtC,GAAkBptD,SAASigB,WACtCnc,EAAYlG,UAChBwvD,EAAkBE,KAEtB,IAAIlsB,EAA6BH,EAAyBpwB,WAAU,SAAUna,GAC1E,IAAI4rC,EAAc5rC,EAAG4rC,YACjBjmB,EAAUgxC,EAAkB91D,OAChC,GAAI8kB,EAAS,CACT,IAAImxC,EAAa9uD,KACjB2uD,EAAkBhqC,YAAYmqC,GAC9BH,EAAkBjzD,IAAImzD,EAAgB,CAClC3qD,IAAK0/B,EAAYn9B,KACjB8a,SAAU5D,EAAQ4D,WAClButC,OAGZ,SAASD,EAAgB72D,GAErB,MAAO,CACHkM,IAFMlM,EAAGkM,IAGTqd,SAHyBvpB,EAAGupB,UAMpC,MAAO,CACHZ,QAAS,SAAUxJ,GAAa,OAAOw3C,EAAkB91D,KAAKse,IAC9DnD,KAAM,WACF0uB,EAA2BnwB,cAC3Bo8C,EAAkB36C,SLiDR+6C,CAAiB5zC,EAAWonB,EAA0B//B,GACpEk1B,EAAqBnV,KACrBvqB,EnD/FD,SAA+BmjB,EAAWkQ,EAAuBrhB,EAAe0tB,GACnFvc,EAAUhJ,UAAU,GAA+B,SAAUqP,GACzD,OAAOrG,EAAU1I,OAAO,GAAkCglB,GAAcjW,EAAQkW,OAEpF,IAAI/X,EAAiB,CAAEoB,aAAc5pB,GAIrC,OAHI6S,EAAc2G,wBACdgP,EAAiB4U,GAAkBpZ,EAAWkQ,EAAuBrhB,GAAe2V,gBAEjF,CACHwrC,UAAW,SAAU3pC,EAAQlB,GACzBnF,EAAU1I,OAAO,GAAkC,EAAO,CACtD6N,mBAAoBA,GACrBmX,GAAcjW,EAAQkW,MAE7B/X,eAAgBA,GmDiFXqvC,CAAsB7zC,EAAWkQ,EAAuBrhB,EAAe0tB,GAAqByzB,EAAYnzD,EAAGmzD,UAAWxrC,EAAiB3nB,EAAG2nB,eAEnJ,OADAH,GAAiBxV,EAAemR,EAAWvN,EAAgB6R,EAAcC,EAAaC,EAAgBpO,EAAoBqO,GACnH,CACHH,aAAcA,EACdiY,mBAAoBA,EACpBhY,YAAaA,EACbyrC,UAAWA,EACXxrC,eAAgBA,EAChB3L,KAAM,WACFyL,EAAazL,OACb0jB,EAAmB1jB,SA5ClBi7C,CAAwB9zC,EAAWnR,EAAexH,SAAUoe,EAAS2hB,EAA0BlX,GAAuB,WAAc,OAAO9Z,GAAmBC,EAAsBC,EAAoBC,KAAiBkO,GAAcH,EAAeznB,EAAGynB,aAAciY,EAAqB1/B,EAAG0/B,mBAAoBhY,EAAc1nB,EAAG0nB,YAAaC,EAAiB3nB,EAAG2nB,eAAgBwrC,EAAYnzD,EAAGmzD,WnFgC1Y,SAAmCnhD,GAClCqK,GAAuBI,+BACvBgB,GAAa,CACThQ,KAAMyO,GACNlK,cAAeA,ImFnCvBklD,C1F8FG,SAAmCllD,GACtC,IAAIhS,EAAIyT,EACJ0jD,EFxFD,SAAgCnlD,GACnC,IAAIhS,EAAIyT,EACJrD,EAAuC,QAA9BpQ,EAAKgS,EAAc5B,aAA0B,IAAPpQ,EAAgBA,EAAKgS,EAAc3B,SACtF,MAAO,CACH+mD,oBAAgE,QAA1C3jD,EAAKzB,EAAc2B,yBAAsC,IAAPF,EAAgBA,EAAKzB,EAAc4B,WAC3GyjD,sBAAuBrlD,EAAc6B,oBACrCyjD,oCAAqCtlD,EAAc+B,iCACnDwjD,kBAAmBvlD,EAAcmC,WACjCqjD,8BAA+BxlD,EAAc8C,0BAC7C2iD,0BAA2BzlD,EAAc6C,uBACzC6iD,eAAqBr6D,IAAV+S,IAAwBA,OAAQ/S,EAC3Cs6D,qBAAsB3lD,EAAcsC,mBACpCsjD,gCAAiC5lD,EAAcgD,6BAC/C6iD,gBAAiB7lD,EAAciH,eAC/B6+C,gBAAiB9lD,EAAckH,gBE0ED6+C,CAAuB/lD,GACzD,OAAO,EAAO,CACVgmD,oBAAqBhmD,EAAc6F,kBACnCogD,mBAAoBjmD,EAAc8F,iBAClCogD,2BAA4BlmD,EAAc4F,wBAC1CugD,kBAA4D,QAAxCn4D,EAAKgS,EAAcoE,uBAAoC,IAAPpW,EAAgBA,EAAKgS,EAAc+F,kBACvGqgD,sBAAuBpmD,EAAc8G,oBACrCu/C,4BAA6Bp8D,MAAMiH,QAAQ8O,EAAciG,wBAA0BjG,EAAciG,sBAAsBpd,OAAS,EAChIy9D,yBAA0Br8D,MAAMiH,QAAQ8O,EAAciE,qBAAuBjE,EAAciE,mBAAmBpb,OAAS,EACvH09D,6BAA8Bl/C,GAA8BrH,GAC5DwmD,sBAAuBxmD,EAAcmH,oBACrCs/C,2BAA4Bx8D,MAAMiH,QAAQ8O,EAAciG,wBAA0BjG,EAAciG,sBAAsBpd,OAAS,EAC/H69D,mBAAoB1mD,EAAc6G,kBAClC8/C,qBAAsB3mD,EAAcgH,mBACpC4/C,wBAAwE,QAA9CnlD,EAAKzB,EAAc2G,6BAA0C,IAAPlF,EAAgBA,EAAKzB,EAAc4G,mBACpHu+C,G0F/GuB0B,CAA0B9oD,IM/DjD,SAAiCoT,EAAWvN,GAC/CuN,EAAUhJ,UAAU,GAAuC,SAAUyJ,GACjE,IAAK,IAAIjpB,EAAK,EAAG0rC,EAAYziB,EAASjpB,EAAK0rC,EAAUxrC,OAAQF,IAAM,CAC/D,IAAIukB,EAAQmnB,EAAU1rC,GACtB,GAAwB,aAApBukB,EAAM6D,UACN,MAEJ,IAAI6F,EAAUhT,EAAeG,mBAAmBmJ,EAAMC,WACtD,IAAKyJ,IAAYA,EAAQ0qB,gBACrB,MAEJ,IAAIlmC,EAAcnG,EAAiBiY,EAAMC,WACrCiJ,EAAc,CACdtf,KAAMsE,EAAYjG,UAClB24B,UAAW,CACPzW,GAAI/qB,IACJwJ,SAAUD,EAAiBqX,EAAMpX,WAErC2F,KAAM,YACNsP,IAAK,CACD2pB,WAAW,IAGnBvjB,EAAU1I,OAAO,GAAkC,CAC/C2N,YAAaA,EACbjJ,UAAW/R,EAAYlG,SACvBmhB,cAAe,CAAE4d,iBAAkB/mB,EAAMhf,gBNsCrD44D,CAAwB31C,EAAWyF,GACnC,IAAI8b,GxB7DJmV,GAAaD,MAyBN,CACH/sB,QAAS,SAAU1N,EAAWrX,GAG1B,IAFA,IAAI8b,EAAU,GACV4I,EAAU7kB,GAAYwX,EAAWrX,GAC5B/L,EAAI49C,GAAiB9+C,OAAS,EAAGkB,GAAK,EAAGA,IAAK,CACnD,IAAIg9D,EAAiBpf,GAAiB59C,GAAGojB,UACzC,KAAI45C,GAAkBvsC,KAGtB5I,EAAQ+H,QAAQguB,GAAiB59C,IAC7Bg9D,EAAiB55C,GACjB,MAGR,OAAOyE,EAAQ/oB,OAAS+oB,OAAUvmB,GAEtC2e,KAxCON,GAAkB3Z,OAAQ,CACjC,WACA,QACA,OACA,mBACA,SACA,SACA,aACD,SAAUsI,GAGJA,EAAMwgB,YAGQ,WAAfxgB,EAAMoD,KACNosC,GAAa,UAEO,aAAfxvC,EAAMoD,KACXosC,GAAaxvC,EAAM2uD,UAAY,SAAwB,cAGvDnf,GAAaD,SAElB,CAAE/9B,SAAS,IAAQG,OwBsCtByoB,GAAwBthB,EAAWnR,EAAe4W,EAAS8b,GAC3D,IAAIjxB,EAAK65B,GAAoBnqB,EAAWnR,EAAexH,SAAU6oB,EAAuBkX,EAA0B7K,EAAoB0D,EAAqB1pB,EAAa+wB,GAAqB0B,EAAY14B,EAAG04B,UAAWE,EAAY54B,EAAG44B,UAClOrI,EAAWb,GAAqBhgB,EAAWuc,EAAoB0D,GAAqBY,SACxF9T,GAAuB/M,EAAWnR,EAAe4W,GACjD1F,GAA2BC,EAAWnR,GACtC,IAAIinD,EOpED,SAA8BjmD,EAAe4C,EAAgB6R,EAAcE,EAAgBD,GAC9F,MAAO,CACHhmB,IAAK,SAAUyd,GACX,IAAIqJ,EAAcf,EAAagB,SAAStJ,GACpCuJ,EAAahB,EAAYiB,QAAQxJ,GACjCyJ,EAAUhT,EAAeG,mBAAmBoJ,GAChD,GAAIyJ,GAAWJ,GAAeE,EAAY,CACtC,IAAII,EAAWnB,EAAeoB,aAAa5J,GAC3C,MAAO,CACH+5C,eAAgBlmD,EAChBmmD,WAAYvwC,EAAQS,GACpB+vC,YAAatwC,EAAW,CAAEO,GAAIP,QAAazrB,EAC3CisB,KAAM,CAAED,GAAIb,EAAYa,GAAI7mB,KAAMgmB,EAAYhmB,KAAM+mB,SAAUb,EAAWa,SAAUrd,IAAKwc,EAAWxc,SPwD7FmtD,CAAqBrnD,EAAcgB,cAAe4V,EAASnB,EAAcE,EAAgBD,GAC/G,MAAO,CACHyrC,UAAWA,EACXnvB,SAAUA,EACVmI,UAAWA,EACXinB,yBAA0BhwB,EAAoBgwB,yBAC9C/mB,UAAWA,EACXlpB,UAAWA,EACXsE,aAAcA,EACdmB,QAASA,EACTyqC,mBAAoB4F,EAAgBv3D,OL3EOgY,KIgB5C,SAAsB3V,EAAQvB,EAAM/H,GACvC,IAAI6+D,EAAyBv1D,EAAOvB,GACpCuB,EAAOvB,GAAQ/H,EACX6+D,GAA0BA,EAAuBC,GACjDD,EAAuBC,EAAEt7D,SAAQ,SAAU7C,GAAM,OAAOD,EAAgBC,EAAI,mCAApBD,MJnBhEq+D,CAAaj4D,IAAmB,SAAU6wD,K,kBaN1C,IAAIqH,EAAoC,qBAAZh+B,QACxBi+B,EAAwB,oBAARvV,IAChBwV,EAAwB,oBAARj5D,IAChBk5D,EAAwC,oBAAhBC,eAAgCA,YAAYC,OAIxE,SAASC,EAAMzxD,EAAGC,GAEhB,GAAID,IAAMC,EAAG,OAAO,EAEpB,GAAID,GAAKC,GAAiB,iBAALD,GAA6B,iBAALC,EAAe,CAC1D,GAAID,EAAEyV,cAAgBxV,EAAEwV,YAAa,OAAO,EAE5C,IAAIljB,EAAQkB,EAAGmF,EA6BX84D,EA5BJ,GAAI/9D,MAAMiH,QAAQoF,GAAI,CAEpB,IADAzN,EAASyN,EAAEzN,SACG0N,EAAE1N,OAAQ,OAAO,EAC/B,IAAKkB,EAAIlB,EAAgB,IAARkB,KACf,IAAKg+D,EAAMzxD,EAAEvM,GAAIwM,EAAExM,IAAK,OAAO,EACjC,OAAO,EAwBT,GAAI29D,GAAWpxD,aAAa67C,KAAS57C,aAAa47C,IAAM,CACtD,GAAI77C,EAAEzC,OAAS0C,EAAE1C,KAAM,OAAO,EAE9B,IADAm0D,EAAK1xD,EAAEsb,YACE7nB,EAAIi+D,EAAG1qB,QAAQld,UACjB7pB,EAAE9E,IAAI1H,EAAEsD,MAAM,IAAK,OAAO,EAEjC,IADA26D,EAAK1xD,EAAEsb,YACE7nB,EAAIi+D,EAAG1qB,QAAQld,UACjB2nC,EAAMh+D,EAAEsD,MAAM,GAAIkJ,EAAE7G,IAAI3F,EAAEsD,MAAM,KAAM,OAAO,EACpD,OAAO,EAGT,GAAIs6D,GAAWrxD,aAAa5H,KAAS6H,aAAa7H,IAAM,CACtD,GAAI4H,EAAEzC,OAAS0C,EAAE1C,KAAM,OAAO,EAE9B,IADAm0D,EAAK1xD,EAAEsb,YACE7nB,EAAIi+D,EAAG1qB,QAAQld,UACjB7pB,EAAE9E,IAAI1H,EAAEsD,MAAM,IAAK,OAAO,EACjC,OAAO,EAIT,GAAIu6D,GAAkBC,YAAYC,OAAOxxD,IAAMuxD,YAAYC,OAAOvxD,GAAI,CAEpE,IADA1N,EAASyN,EAAEzN,SACG0N,EAAE1N,OAAQ,OAAO,EAC/B,IAAKkB,EAAIlB,EAAgB,IAARkB,KACf,GAAIuM,EAAEvM,KAAOwM,EAAExM,GAAI,OAAO,EAC5B,OAAO,EAGT,GAAIuM,EAAEyV,cAAgBrb,OAAQ,OAAO4F,EAAEpK,SAAWqK,EAAErK,QAAUoK,EAAExE,QAAUyE,EAAEzE,MAC5E,GAAIwE,EAAE2xD,UAAYn/D,OAAOC,UAAUk/D,QAAS,OAAO3xD,EAAE2xD,YAAc1xD,EAAE0xD,UACrE,GAAI3xD,EAAE3J,WAAa7D,OAAOC,UAAU4D,SAAU,OAAO2J,EAAE3J,aAAe4J,EAAE5J,WAIxE,IADA9D,GADAqG,EAAOpG,OAAOoG,KAAKoH,IACLzN,UACCC,OAAOoG,KAAKqH,GAAG1N,OAAQ,OAAO,EAE7C,IAAKkB,EAAIlB,EAAgB,IAARkB,KACf,IAAKjB,OAAOC,UAAUC,eAAeC,KAAKsN,EAAGrH,EAAKnF,IAAK,OAAO,EAKhE,GAAI09D,GAAkBnxD,aAAamzB,QAAS,OAAO,EAGnD,IAAK1/B,EAAIlB,EAAgB,IAARkB,KACf,IAAiB,WAAZmF,EAAKnF,IAA+B,QAAZmF,EAAKnF,IAA4B,QAAZmF,EAAKnF,KAAiBuM,EAAE4xD,YAarEH,EAAMzxD,EAAEpH,EAAKnF,IAAKwM,EAAErH,EAAKnF,KAAM,OAAO,EAK7C,OAAO,EAGT,OAAOuM,IAAMA,GAAKC,IAAMA,EAI1B4xD,EAAOC,QAAU,SAAiB9xD,EAAGC,GACnC,IACE,OAAOwxD,EAAMzxD,EAAGC,GAChB,MAAOhO,GACP,IAAMA,EAAMoS,SAAW,IAAIuJ,MAAM,oBAO/B,OADA3a,QAAQjB,KAAK,mDACN,EAGT,MAAMC,K,kIC7HN8/D,EACM,iBADNA,EAEM,iBAFNA,EAGO,kBAGPC,EAAY,CACZC,KAAM,OACNC,KAAM,OACNC,KAAM,OACNC,KAAM,OACNC,KAAM,OACNC,KAAM,OACNC,SAAU,WACVC,OAAQ,SACRC,MAAO,QACPC,MAAO,SAOPC,GAJkBngE,OAAOoG,KAAKo5D,GAAWn5D,KAAI,SAAUqB,GACvD,OAAO83D,EAAU93D,MAIR,WADTy4D,EAEU,UAFVA,EAGM,OAHNA,EAIW,aAJXA,EAKY,YALZA,EAMW,WANXA,EAOM,OAPNA,EAQU,WARVA,EASK,MATLA,EAUK,MAVLA,EAWQ,SAGRC,EAAgB,CAChBC,UAAW,YACXC,QAAS,UACTC,MAAO,YACPC,gBAAiB,kBACjBC,YAAa,cACb,aAAc,YACdC,SAAU,WACVC,SAAU,YAGVC,EACe,eADfA,EAEO,QAFPA,EAG2B,0BAH3BA,EAIwB,sBAJxBA,EAKgB,gBAGhBC,EAAe7gE,OAAOoG,KAAKg6D,GAAeU,QAAO,SAAUC,EAAK19D,GAEhE,OADA09D,EAAIX,EAAc/8D,IAAQA,EACnB09D,IACR,IAECC,EAAoB,CAACxB,EAAUO,SAAUP,EAAUQ,OAAQR,EAAUS,OAErEgB,EAAmB,oBAEnBC,EAA4B,oBAAXC,QAAoD,kBAApBA,OAAOC,SAAwB,SAAUL,GAC5F,cAAcA,GACZ,SAAUA,GACZ,OAAOA,GAAyB,oBAAXI,QAAyBJ,EAAI99C,cAAgBk+C,QAAUJ,IAAQI,OAAOlhE,UAAY,gBAAkB8gE,GAGvHM,EAAiB,SAAUC,EAAUC,GACvC,KAAMD,aAAoBC,GACxB,MAAM,IAAIC,UAAU,sCAIpBC,EAAc,WAChB,SAASC,EAAiBz+D,EAAQ0+D,GAChC,IAAK,IAAI1gE,EAAI,EAAGA,EAAI0gE,EAAM5hE,OAAQkB,IAAK,CACrC,IAAI2gE,EAAaD,EAAM1gE,GACvB2gE,EAAWhJ,WAAagJ,EAAWhJ,aAAc,EACjDgJ,EAAW/6D,cAAe,EACtB,UAAW+6D,IAAYA,EAAWC,UAAW,GACjD7hE,OAAO2G,eAAe1D,EAAQ2+D,EAAWv+D,IAAKu+D,IAIlD,OAAO,SAAUL,EAAaO,EAAYC,GAGxC,OAFID,GAAYJ,EAAiBH,EAAYthE,UAAW6hE,GACpDC,GAAaL,EAAiBH,EAAaQ,GACxCR,GAdO,GAkBdS,EAAWhiE,OAAOiiE,QAAU,SAAUh/D,GACxC,IAAK,IAAIhC,EAAI,EAAGA,EAAInB,UAAUC,OAAQkB,IAAK,CACzC,IAAImC,EAAStD,UAAUmB,GAEvB,IAAK,IAAIoC,KAAOD,EACVpD,OAAOC,UAAUC,eAAeC,KAAKiD,EAAQC,KAC/CJ,EAAOI,GAAOD,EAAOC,IAK3B,OAAOJ,GAmBLi/D,EAA0B,SAAUnB,EAAK36D,GAC3C,IAAInD,EAAS,GAEb,IAAK,IAAIhC,KAAK8/D,EACR36D,EAAKZ,QAAQvE,IAAM,GAClBjB,OAAOC,UAAUC,eAAeC,KAAK4gE,EAAK9/D,KAC/CgC,EAAOhC,GAAK8/D,EAAI9/D,IAGlB,OAAOgC,GAGLk/D,EAA4B,SAAUn7D,EAAM7G,GAC9C,IAAK6G,EACH,MAAM,IAAIo7D,eAAe,6DAG3B,OAAOjiE,GAAyB,kBAATA,GAAqC,oBAATA,EAA8B6G,EAAP7G,GAGxEkiE,EAA0B,SAAiCh4D,GAC3D,IAAIQ,IAAS/K,UAAUC,OAAS,QAAsBwC,IAAjBzC,UAAU,KAAmBA,UAAU,GAE5E,OAAe,IAAX+K,EACO2F,OAAOnG,GAGXmG,OAAOnG,GAAKvG,QAAQ,KAAM,SAASA,QAAQ,KAAM,QAAQA,QAAQ,KAAM,QAAQA,QAAQ,KAAM,UAAUA,QAAQ,KAAM,WAG5Hw+D,EAAwB,SAA+BC,GACvD,IAAIC,EAAiBC,EAAqBF,EAAW/C,EAAUU,OAC3DwC,EAAoBD,EAAqBF,EAAW3B,GAExD,GAAI8B,GAAqBF,EAErB,OAAOE,EAAkB5+D,QAAQ,OAAO,WACpC,OAAO3C,MAAMiH,QAAQo6D,GAAkBA,EAAel5D,KAAK,IAAMk5D,KAIzE,IAAIG,EAAwBF,EAAqBF,EAAW3B,GAE5D,OAAO4B,GAAkBG,QAAyBpgE,GAGlDqgE,EAAyB,SAAgCL,GACzD,OAAOE,EAAqBF,EAAW3B,IAAwC,cAG/EiC,EAA6B,SAAoCC,EAASP,GAC1E,OAAOA,EAAUppD,QAAO,SAAUwoD,GAC9B,MAAiC,qBAAnBA,EAAMmB,MACrBz8D,KAAI,SAAUs7D,GACb,OAAOA,EAAMmB,MACdhC,QAAO,SAAUiC,EAAUl4C,GAC1B,OAAOm3C,EAAS,GAAIe,EAAUl4C,KAC/B,KAGHm4C,EAA0B,SAAiCC,EAAmBV,GAC9E,OAAOA,EAAUppD,QAAO,SAAUwoD,GAC9B,MAAwC,qBAA1BA,EAAMnC,EAAUC,SAC/Bp5D,KAAI,SAAUs7D,GACb,OAAOA,EAAMnC,EAAUC,SACxBhpD,UAAUqqD,QAAO,SAAUoC,EAAkBC,GAC5C,IAAKD,EAAiBnjE,OAGlB,IAFA,IAAIqG,EAAOpG,OAAOoG,KAAK+8D,GAEdliE,EAAI,EAAGA,EAAImF,EAAKrG,OAAQkB,IAAK,CAClC,IACImiE,EADeh9D,EAAKnF,GACiBigD,cAEzC,IAA0D,IAAtD+hB,EAAkBz9D,QAAQ49D,IAAiCD,EAAIC,GAC/D,OAAOF,EAAiB7hE,OAAO8hE,GAK3C,OAAOD,IACR,KAGHG,EAAuB,SAA8B3kC,EAASukC,EAAmBV,GAEjF,IAAIe,EAAmB,GAEvB,OAAOf,EAAUppD,QAAO,SAAUwoD,GAC9B,QAAIxgE,MAAMiH,QAAQu5D,EAAMjjC,MAGM,qBAAnBijC,EAAMjjC,IACbl/B,EAAK,WAAak/B,EAAU,mDAAwDwiC,EAAQS,EAAMjjC,IAAY,MAE3G,MACRr4B,KAAI,SAAUs7D,GACb,OAAOA,EAAMjjC,MACdjoB,UAAUqqD,QAAO,SAAUyC,EAAcC,GACxC,IAAIC,EAAmB,GAEvBD,EAAarqD,QAAO,SAAUgqD,GAG1B,IAFA,IAAIO,OAAsB,EACtBt9D,EAAOpG,OAAOoG,KAAK+8D,GACdliE,EAAI,EAAGA,EAAImF,EAAKrG,OAAQkB,IAAK,CAClC,IAAI0iE,EAAev9D,EAAKnF,GACpBmiE,EAAwBO,EAAaziB,eAGiB,IAAtD+hB,EAAkBz9D,QAAQ49D,IAAmCM,IAAwBvD,GAAiE,cAA3CgD,EAAIO,GAAqBxiB,eAAoCkiB,IAA0BjD,GAAmE,eAA7CgD,EAAIC,GAAuBliB,gBACnPwiB,EAAsBN,IAGuB,IAA7CH,EAAkBz9D,QAAQm+D,IAAyBA,IAAiBxD,GAA6BwD,IAAiBxD,GAA2BwD,IAAiBxD,IAC9JuD,EAAsBC,GAI9B,IAAKD,IAAwBP,EAAIO,GAC7B,OAAO,EAGX,IAAIn/D,EAAQ4+D,EAAIO,GAAqBxiB,cAUrC,OARKoiB,EAAiBI,KAClBJ,EAAiBI,GAAuB,IAGvCD,EAAiBC,KAClBD,EAAiBC,GAAuB,KAGvCJ,EAAiBI,GAAqBn/D,KACvCk/D,EAAiBC,GAAqBn/D,IAAS,GACxC,MAIZkS,UAAUtT,SAAQ,SAAUggE,GAC3B,OAAOI,EAAaz9D,KAAKq9D,MAK7B,IADA,IAAI/8D,EAAOpG,OAAOoG,KAAKq9D,GACdxiE,EAAI,EAAGA,EAAImF,EAAKrG,OAAQkB,IAAK,CAClC,IAAI0iE,EAAev9D,EAAKnF,GACpB2iE,EAAW,IAAa,GAAIN,EAAiBK,GAAeF,EAAiBE,IAEjFL,EAAiBK,GAAgBC,EAGrC,OAAOL,IACR,IAAI9sD,WAGPgsD,EAAuB,SAA8BF,EAAW72D,GAChE,IAAK,IAAIzK,EAAIshE,EAAUxiE,OAAS,EAAGkB,GAAK,EAAGA,IAAK,CAC5C,IAAI0gE,EAAQY,EAAUthE,GAEtB,GAAI0gE,EAAMzhE,eAAewL,GACrB,OAAOi2D,EAAMj2D,GAIrB,OAAO,MAqBPm4D,EAAc,WACd,IAAIC,EAAQh7D,KAAK6D,MAEjB,OAAO,SAAUX,GACb,IAAI+3D,EAAcj7D,KAAK6D,MAEnBo3D,EAAcD,EAAQ,IACtBA,EAAQC,EACR/3D,EAAS+3D,IAETjhE,YAAW,WACP+gE,EAAY73D,KACb,IAZG,GAiBdg4D,EAAc,SAAqBz1C,GACnC,OAAOvrB,aAAaurB,IAGpBg6B,EAA0C,qBAAXthD,OAAyBA,OAAOshD,uBAAyBthD,OAAOshD,sBAAsB7nD,KAAKuG,SAAWA,OAAOg9D,6BAA+Bh9D,OAAOi9D,0BAA4BL,EAAc,EAAAM,EAAO5b,uBAAyBsb,EAE5Prb,EAAyC,qBAAXvhD,OAAyBA,OAAOuhD,sBAAwBvhD,OAAOm9D,4BAA8Bn9D,OAAOo9D,yBAA2BL,EAAc,EAAAG,EAAO3b,sBAAwBwb,EAE1MxkE,EAAO,SAAcqmC,GACrB,OAAOplC,SAAmC,oBAAjBA,QAAQjB,MAAuBiB,QAAQjB,KAAKqmC,IAGrEy+B,GAAkB,KAmBlBC,GAAmB,SAA0BC,EAAU7W,GACvD,IAAI8W,EAAUD,EAASC,QACnBC,EAAiBF,EAASE,eAC1BC,EAAiBH,EAASG,eAC1BC,EAAWJ,EAASI,SACpBC,EAAWL,EAASK,SACpBC,EAAeN,EAASM,aACxBC,EAAsBP,EAASO,oBAC/BC,EAAaR,EAASQ,WACtBC,EAAYT,EAASS,UACrBC,EAAQV,EAASU,MACjBC,EAAkBX,EAASW,gBAE/BC,GAAiB5F,EAAUE,KAAMgF,GACjCU,GAAiB5F,EAAUI,KAAM+E,GAEjCU,GAAYH,EAAOC,GAEnB,IAAIG,EAAa,CACbb,QAASc,GAAW/F,EAAUC,KAAMgF,GACpCG,SAAUW,GAAW/F,EAAUK,KAAM+E,GACrCC,SAAUU,GAAW/F,EAAUM,KAAM+E,GACrCC,aAAcS,GAAW/F,EAAUO,SAAU+E,GAC7CE,WAAYO,GAAW/F,EAAUQ,OAAQgF,GACzCC,UAAWM,GAAW/F,EAAUS,MAAOgF,IAGvCO,EAAY,GACZC,EAAc,GAElBzlE,OAAOoG,KAAKk/D,GAAYniE,SAAQ,SAAU2/D,GACtC,IAAI4C,EAAsBJ,EAAWxC,GACjC6C,EAAUD,EAAoBC,QAC9BC,EAAUF,EAAoBE,QAG9BD,EAAQ5lE,SACRylE,EAAU1C,GAAW6C,GAErBC,EAAQ7lE,SACR0lE,EAAY3C,GAAWwC,EAAWxC,GAAS8C,YAInDjY,GAAMA,IAENoX,EAAoBP,EAAUgB,EAAWC,IAGzCI,GAAe,SAAsBC,GACrC,OAAO3kE,MAAMiH,QAAQ09D,GAAiBA,EAAcx8D,KAAK,IAAMw8D,GAG/DT,GAAc,SAAqBH,EAAOrgB,GACrB,qBAAVqgB,GAAyB12D,SAAS02D,QAAUA,IACnD12D,SAAS02D,MAAQW,GAAaX,IAGlCE,GAAiB5F,EAAUU,MAAOrb,IAGlCugB,GAAmB,SAA0B1mC,EAASmmB,GACtD,IAAIkhB,EAAav3D,SAASw3D,qBAAqBtnC,GAAS,GAExD,GAAKqnC,EAAL,CASA,IALA,IAAIE,EAAwBF,EAAWzpC,aAAa2kC,GAChDiF,EAAmBD,EAAwBA,EAAsBx1D,MAAM,KAAO,GAC9E01D,EAAqB,GAAG9kE,OAAO6kE,GAC/BE,EAAgBpmE,OAAOoG,KAAKy+C,GAEvB5jD,EAAI,EAAGA,EAAImlE,EAAcrmE,OAAQkB,IAAK,CAC3C,IAAIolE,EAAYD,EAAcnlE,GAC1BsD,EAAQsgD,EAAWwhB,IAAc,GAEjCN,EAAWzpC,aAAa+pC,KAAe9hE,GACvCwhE,EAAWO,aAAaD,EAAW9hE,IAGM,IAAzC2hE,EAAiB1gE,QAAQ6gE,IACzBH,EAAiBpgE,KAAKugE,GAG1B,IAAIE,EAAcJ,EAAmB3gE,QAAQ6gE,IACxB,IAAjBE,GACAJ,EAAmBl6D,OAAOs6D,EAAa,GAI/C,IAAK,IAAI1mE,EAAKsmE,EAAmBpmE,OAAS,EAAGF,GAAM,EAAGA,IAClDkmE,EAAWS,gBAAgBL,EAAmBtmE,IAG9CqmE,EAAiBnmE,SAAWomE,EAAmBpmE,OAC/CgmE,EAAWS,gBAAgBvF,GACpB8E,EAAWzpC,aAAa2kC,KAAsBmF,EAAc98D,KAAK,MACxEy8D,EAAWO,aAAarF,EAAkBmF,EAAc98D,KAAK,QAIjEi8D,GAAa,SAAoB5yD,EAAM2D,GACvC,IAAImwD,EAAcj4D,SAAS8F,MAAQ9F,SAASwY,cAAcw4C,EAAUG,MAChE+G,EAAWD,EAAY1pC,iBAAiBpqB,EAAO,IAAPA,sBACxCizD,EAAUzkE,MAAMlB,UAAUmB,MAAMjB,KAAKumE,GACrCf,EAAU,GACVgB,OAAgB,EA4CpB,OA1CIrwD,GAAQA,EAAKvW,QACbuW,EAAKnT,SAAQ,SAAUggE,GACnB,IAAIyD,EAAap4D,SAAS0F,cAAcvB,GAExC,IAAK,IAAI0zD,KAAalD,EAClB,GAAIA,EAAIjjE,eAAemmE,GACnB,GAAIA,IAAclG,EACdyG,EAAWrU,UAAY4Q,EAAI5Q,eACxB,GAAI8T,IAAclG,EACjByG,EAAWxf,WACXwf,EAAWxf,WAAW/E,QAAU8gB,EAAI9gB,QAEpCukB,EAAWryD,YAAY/F,SAASq4D,eAAe1D,EAAI9gB,cAEpD,CACH,IAAI99C,EAAkC,qBAAnB4+D,EAAIkD,GAA6B,GAAKlD,EAAIkD,GAC7DO,EAAWN,aAAaD,EAAW9hE,GAK/CqiE,EAAWN,aAAarF,EAAkB,QAGtC2E,EAAQ17D,MAAK,SAAU48D,EAAan1C,GAEpC,OADAg1C,EAAgBh1C,EACTi1C,EAAWG,YAAYD,MAE9BlB,EAAQ35D,OAAO06D,EAAe,GAE9BhB,EAAQ7/D,KAAK8gE,MAKzBhB,EAAQziE,SAAQ,SAAUggE,GACtB,OAAOA,EAAIx8C,WAAWqgD,YAAY7D,MAEtCwC,EAAQxiE,SAAQ,SAAUggE,GACtB,OAAOsD,EAAYlyD,YAAY4uD,MAG5B,CACHyC,QAASA,EACTD,QAASA,IAIbsB,GAAoC,SAA2CpiB,GAC/E,OAAO7kD,OAAOoG,KAAKy+C,GAAYic,QAAO,SAAUz2D,EAAKhH,GACjD,IAAI6jE,EAAkC,qBAApBriB,EAAWxhD,GAAuBA,EAAM,KAAQwhD,EAAWxhD,GAAO,IAAO,GAAKA,EAChG,OAAOgH,EAAMA,EAAM,IAAM68D,EAAOA,IACjC,KA0BHC,GAAuC,SAA8CtiB,GACrF,IAAIuiB,EAAYtnE,UAAUC,OAAS,QAAsBwC,IAAjBzC,UAAU,GAAmBA,UAAU,GAAK,GAEpF,OAAOE,OAAOoG,KAAKy+C,GAAYic,QAAO,SAAUC,EAAK19D,GAEjD,OADA09D,EAAIX,EAAc/8D,IAAQA,GAAOwhD,EAAWxhD,GACrC09D,IACRqG,IA+CHC,GAAmB,SAA0B10D,EAAM2D,EAAMzL,GACzD,OAAQ8H,GACJ,KAAK6sD,EAAUU,MACX,MAAO,CACHoH,YAAa,WACT,OAxCgB,SAAuC30D,EAAMuyD,EAAOrgB,GACpF,IAAI0iB,EAGAH,IAAaG,EAAa,CAC1BlkE,IAAK6hE,IACKjE,IAAoB,EAAMsG,GACpC5F,EAAQwF,GAAqCtiB,EAAYuiB,GAE7D,MAAO,CAAC,gBAAoB5H,EAAUU,MAAOyB,EAAOuD,IA+B7BsC,CAA8B70D,EAAM2D,EAAK4uD,MAAO5uD,EAAK6uD,kBAEhEthE,SAAU,WACN,OApFQ,SAA+B8O,EAAMuyD,EAAOrgB,EAAYh6C,GAChF,IAAI48D,EAAkBR,GAAkCpiB,GACpD6iB,EAAiB7B,GAAaX,GAClC,OAAOuC,EAAkB,IAAM90D,EAAN,6BAAqD80D,EAAkB,IAAMpF,EAAwBqF,EAAgB78D,GAAU,KAAO8H,EAAO,IAAM,IAAMA,EAAN,6BAAqD0vD,EAAwBqF,EAAgB78D,GAAU,KAAO8H,EAAO,IAiF1Qg1D,CAAsBh1D,EAAM2D,EAAK4uD,MAAO5uD,EAAK6uD,gBAAiBt6D,KAGjF,KAAK00D,EACL,KAAKA,EACD,MAAO,CACH+H,YAAa,WACT,OAAOH,GAAqC7wD,IAEhDzS,SAAU,WACN,OAAOojE,GAAkC3wD,KAGrD,QACI,MAAO,CACHgxD,YAAa,WACT,OA/Ce,SAAsC30D,EAAM2D,GAC3E,OAAOA,EAAKjQ,KAAI,SAAU88D,EAAKliE,GAC3B,IAAI2mE,EAEAC,IAAaD,EAAa,CAC1BvkE,IAAKpC,IACKggE,IAAoB,EAAM2G,GAaxC,OAXA5nE,OAAOoG,KAAK+8D,GAAKhgE,SAAQ,SAAUkjE,GAC/B,IAAIyB,EAAkB1H,EAAciG,IAAcA,EAElD,GAAIyB,IAAoB3H,GAA6B2H,IAAoB3H,EAAyB,CAC9F,IAAIh5C,EAAUg8C,EAAI5Q,WAAa4Q,EAAI9gB,QACnCwlB,EAAUE,wBAA0B,CAAEC,OAAQ7gD,QAE9C0gD,EAAUC,GAAmB3E,EAAIkD,MAIlC,gBAAoB1zD,EAAMk1D,MA4BdI,CAA6Bt1D,EAAM2D,IAE9CzS,SAAU,WACN,OAjGO,SAA8B8O,EAAM2D,EAAMzL,GACjE,OAAOyL,EAAKwqD,QAAO,SAAUz2D,EAAK84D,GAC9B,IAAI+E,EAAgBloE,OAAOoG,KAAK+8D,GAAKhqD,QAAO,SAAUktD,GAClD,QAASA,IAAclG,GAA6BkG,IAAclG,MACnEW,QAAO,SAAUqH,EAAQ9B,GACxB,IAAIa,EAAiC,qBAAnB/D,EAAIkD,GAA6BA,EAAYA,EAAY,KAAQhE,EAAwBc,EAAIkD,GAAYx7D,GAAU,IACrI,OAAOs9D,EAASA,EAAS,IAAMjB,EAAOA,IACvC,IAECkB,EAAajF,EAAI5Q,WAAa4Q,EAAI9gB,SAAW,GAE7CgmB,GAAqD,IAArCrH,EAAkBx7D,QAAQmN,GAE9C,OAAOtI,EAAM,IAAMsI,EAAZtI,6BAA2D69D,GAAiBG,EAAgB,KAAO,IAAMD,EAAa,KAAOz1D,EAAO,OAC5I,IAmFoB21D,CAAqB31D,EAAM2D,EAAMzL,OAMxD09D,GAAmB,SAA0BC,GAC7C,IAAI/D,EAAU+D,EAAK/D,QACfC,EAAiB8D,EAAK9D,eACtB75D,EAAS29D,EAAK39D,OACd85D,EAAiB6D,EAAK7D,eACtBC,EAAW4D,EAAK5D,SAChBC,EAAW2D,EAAK3D,SAChBC,EAAe0D,EAAK1D,aACpBE,EAAawD,EAAKxD,WAClBC,EAAYuD,EAAKvD,UACjBwD,EAAaD,EAAKtD,MAClBA,OAAuB3iE,IAAfkmE,EAA2B,GAAKA,EACxCtD,EAAkBqD,EAAKrD,gBAC3B,MAAO,CACHtxD,KAAMwzD,GAAiB7H,EAAUC,KAAMgF,EAAS55D,GAChD65D,eAAgB2C,GAAiB9H,EAAsBmF,EAAgB75D,GACvE85D,eAAgB0C,GAAiB9H,EAAsBoF,EAAgB95D,GACvE69D,KAAMrB,GAAiB7H,EAAUK,KAAM+E,EAAU/5D,GACjD89D,KAAMtB,GAAiB7H,EAAUM,KAAM+E,EAAUh6D,GACjD+9D,SAAUvB,GAAiB7H,EAAUO,SAAU+E,EAAcj6D,GAC7Dg+D,OAAQxB,GAAiB7H,EAAUQ,OAAQgF,EAAYn6D,GACvDi+D,MAAOzB,GAAiB7H,EAAUS,MAAOgF,EAAWp6D,GACpDq6D,MAAOmC,GAAiB7H,EAAUU,MAAO,CAAEgF,MAAOA,EAAOC,gBAAiBA,GAAmBt6D,KA4PjGk+D,GAxPS,SAAgBC,GACzB,IAAIC,EAAQC,EAEZ,OAAOA,EAAQD,EAAS,SAAUE,GAG9B,SAASC,IAEL,OADA/H,EAAe1/D,KAAMynE,GACdjH,EAA0BxgE,KAAMwnE,EAAiB/oE,MAAMuB,KAAM7B,YA8LxE,OAzuBO,SAAUupE,EAAUC,GACjC,GAA0B,oBAAfA,GAA4C,OAAfA,EACtC,MAAM,IAAI9H,UAAU,kEAAoE8H,GAG1FD,EAASppE,UAAYD,OAAOupE,OAAOD,GAAcA,EAAWrpE,UAAW,CACrEgjB,YAAa,CACX1e,MAAO8kE,EACPzQ,YAAY,EACZiJ,UAAU,EACVh7D,cAAc,KAGdyiE,IAAYtpE,OAAOwpE,eAAiBxpE,OAAOwpE,eAAeH,EAAUC,GAAcD,EAASI,UAAYH,GA0hBrGI,CAASN,EAAeD,GAOxBC,EAAcnpE,UAAU0pE,sBAAwB,SAA+BC,GAC3E,OAAQ,IAAQjoE,KAAKggE,MAAOiI,IAGhCR,EAAcnpE,UAAU4pE,yBAA2B,SAAkCxpC,EAAOypC,GACxF,IAAKA,EACD,OAAO,KAGX,OAAQzpC,EAAM1tB,MACV,KAAK6sD,EAAUQ,OACf,KAAKR,EAAUO,SACX,MAAO,CACHxN,UAAWuX,GAGnB,KAAKtK,EAAUS,MACX,MAAO,CACH5d,QAASynB,GAIrB,MAAM,IAAIr3D,MAAM,IAAM4tB,EAAM1tB,KAAO,uGAGvCy2D,EAAcnpE,UAAU8pE,yBAA2B,SAAkCvB,GACjF,IAAIwB,EAEA3pC,EAAQmoC,EAAKnoC,MACb4pC,EAAoBzB,EAAKyB,kBACzBC,EAAgB1B,EAAK0B,cACrBJ,EAAiBtB,EAAKsB,eAE1B,OAAO9H,EAAS,GAAIiI,IAAoBD,EAAwB,IAA0B3pC,EAAM1tB,MAAQ,GAAGtR,OAAO4oE,EAAkB5pC,EAAM1tB,OAAS,GAAI,CAACqvD,EAAS,GAAIkI,EAAevoE,KAAKkoE,yBAAyBxpC,EAAOypC,MAAoBE,KAGjPZ,EAAcnpE,UAAUkqE,sBAAwB,SAA+BC,GAC3E,IAAIC,EAAwBC,EAExBjqC,EAAQ+pC,EAAM/pC,MACdkqC,EAAWH,EAAMG,SACjBL,EAAgBE,EAAMF,cACtBJ,EAAiBM,EAAMN,eAE3B,OAAQzpC,EAAM1tB,MACV,KAAK6sD,EAAUU,MACX,OAAO8B,EAAS,GAAIuI,IAAWF,EAAyB,IAA2BhqC,EAAM1tB,MAAQm3D,EAAgBO,EAAuBlF,gBAAkBnD,EAAS,GAAIkI,GAAgBG,IAE3L,KAAK7K,EAAUE,KACX,OAAOsC,EAAS,GAAIuI,EAAU,CAC1B7F,eAAgB1C,EAAS,GAAIkI,KAGrC,KAAK1K,EAAUI,KACX,OAAOoC,EAAS,GAAIuI,EAAU,CAC1B5F,eAAgB3C,EAAS,GAAIkI,KAIzC,OAAOlI,EAAS,GAAIuI,IAAWD,EAAyB,IAA2BjqC,EAAM1tB,MAAQqvD,EAAS,GAAIkI,GAAgBI,KAGlIlB,EAAcnpE,UAAUuqE,4BAA8B,SAAqCP,EAAmBM,GAC1G,IAAIE,EAAoBzI,EAAS,GAAIuI,GAQrC,OANAvqE,OAAOoG,KAAK6jE,GAAmB9mE,SAAQ,SAAUunE,GAC7C,IAAIC,EAEJF,EAAoBzI,EAAS,GAAIyI,IAAoBE,EAAyB,IAA2BD,GAAkBT,EAAkBS,GAAiBC,OAG3JF,GAGXrB,EAAcnpE,UAAU2qE,sBAAwB,SAA+BvqC,EAAOypC,GAmBlF,OAAO,GAGXV,EAAcnpE,UAAU4qE,mBAAqB,SAA4BC,EAAUP,GAC/E,IAAIQ,EAASppE,KAETsoE,EAAoB,GAyCxB,OAvCA,mBAAuBa,GAAU,SAAUzqC,GACvC,GAAKA,GAAUA,EAAMshC,MAArB,CAIA,IAAIqJ,EAAe3qC,EAAMshC,MACrBmI,EAAiBkB,EAAaF,SAG9BZ,EAhOoB,SAA2CvI,GAC/E,IAAIsJ,EAAiBnrE,UAAUC,OAAS,QAAsBwC,IAAjBzC,UAAU,GAAmBA,UAAU,GAAK,GAEzF,OAAOE,OAAOoG,KAAKu7D,GAAOb,QAAO,SAAUC,EAAK19D,GAE5C,OADA09D,EAAIF,EAAax9D,IAAQA,GAAOs+D,EAAMt+D,GAC/B09D,IACRkK,GA0N6BC,CAFHhJ,EAAwB8I,EAAc,CAAC,cAMxD,OAFAD,EAAOH,sBAAsBvqC,EAAOypC,GAE5BzpC,EAAM1tB,MACV,KAAK6sD,EAAUK,KACf,KAAKL,EAAUM,KACf,KAAKN,EAAUO,SACf,KAAKP,EAAUQ,OACf,KAAKR,EAAUS,MACXgK,EAAoBc,EAAOhB,yBAAyB,CAChD1pC,MAAOA,EACP4pC,kBAAmBA,EACnBC,cAAeA,EACfJ,eAAgBA,IAEpB,MAEJ,QACIS,EAAWQ,EAAOZ,sBAAsB,CACpC9pC,MAAOA,EACPkqC,SAAUA,EACVL,cAAeA,EACfJ,eAAgBA,SAMhCS,EAAW5oE,KAAK6oE,4BAA4BP,EAAmBM,IAInEnB,EAAcnpE,UAAUkrE,OAAS,WAC7B,IAAIC,EAASzpE,KAAKggE,MACdmJ,EAAWM,EAAON,SAClBnJ,EAAQO,EAAwBkJ,EAAQ,CAAC,aAEzCb,EAAWvI,EAAS,GAAIL,GAM5B,OAJImJ,IACAP,EAAW5oE,KAAKkpE,mBAAmBC,EAAUP,IAG1C,gBAAoBvB,EAAWuB,IAG1C9I,EAAY2H,EAAe,KAAM,CAAC,CAC9B/lE,IAAK,YAyBLgI,IAAK,SAAgBggE,GACjBrC,EAAUqC,UAAYA,MAGvBjC,EAnMa,CAoMtB,aAAkBH,EAAOqC,UAAY,CACnCz3D,KAAM,WACN6wD,eAAgB,WAChBoG,SAAU,cAAoB,CAAC,YAAkB,UAAiB,WAClES,aAAc,WACdC,MAAO,SACPnJ,wBAAyB,SACzBsC,eAAgB,WAChB+D,KAAM,YAAkB,YACxBC,KAAM,YAAkB,YACxBC,SAAU,YAAkB,YAC5B7D,oBAAqB,SACrB8D,OAAQ,YAAkB,YAC1BC,MAAO,YAAkB,YACzB5D,MAAO,WACPC,gBAAiB,WACjBsG,cAAe,YAChBxC,EAAOyC,aAAe,CACrBF,OAAO,EACPnJ,yBAAyB,GAC1B4G,EAAO0C,KAAO3C,EAAU2C,KAAM1C,EAAO2C,OAAS,WAC7C,IAAIC,EAAc7C,EAAU4C,SAkB5B,OAjBKC,IAEDA,EAActD,GAAiB,CAC3B9D,QAAS,GACTC,eAAgB,GAChBrC,yBAAyB,EACzBsC,eAAgB,GAChBC,SAAU,GACVC,SAAU,GACVC,aAAc,GACdE,WAAY,GACZC,UAAW,GACXC,MAAO,GACPC,gBAAiB,MAIlB0G,GACR3C,EASY4C,CAFK,KAnmBC,SAA4BvJ,GACjD,MAAO,CACHkC,QAASzB,EAAwB,CAAC7C,EAAqBA,GAAwBoC,GAC/EmC,eAAgB7B,EAA2BtD,EAAsBgD,GACjEiJ,MAAO/I,EAAqBF,EAAW3B,GACvC/1D,OAAQ43D,EAAqBF,EAAW3B,GACxC+D,eAAgB9B,EAA2BtD,EAAsBgD,GACjEqC,SAAUvB,EAAqB7D,EAAUK,KAAM,CAACM,EAAoBA,GAAsBoC,GAC1FsC,SAAUxB,EAAqB7D,EAAUM,KAAM,CAACK,EAAqBA,EAAwBA,EAA0BA,EAAyBA,GAA2BoC,GAC3KuC,aAAczB,EAAqB7D,EAAUO,SAAU,CAACI,GAA4BoC,GACpFwC,oBAAqBnC,EAAuBL,GAC5CyC,WAAY3B,EAAqB7D,EAAUQ,OAAQ,CAACG,EAAoBA,GAA4BoC,GACpG0C,UAAW5B,EAAqB7D,EAAUS,MAAO,CAACE,GAA0BoC,GAC5E2C,MAAO5C,EAAsBC,GAC7B4C,gBAAiBtC,EAA2BtD,EAAuBgD,OAmC7C,SAAiCiC,GACvDF,IACA9b,EAAqB8b,IAGrBE,EAASgH,MACTlH,GAAkB/b,GAAsB,WACpCgc,GAAiBC,GAAU,WACvBF,GAAkB,YAI1BC,GAAiBC,GACjBF,GAAkB,QAqiB0DiE,GAA5D,EAJJ,WAChB,OAAO,SAMXQ,GAAagD,aAAehD,GAAa6C,OAEzC,Q,mCC74BA,IAF0Bz7D,EAEtB67D,EAAQ,EAAQ,OAChBC,GAHsB97D,EAGW67D,IAHwB,kBAAP77D,GAAoB,YAAaA,EAAMA,EAAY,QAAIA,EAK7G,SAAS+7D,EAAgBnL,EAAK19D,EAAKkB,GAYjC,OAXIlB,KAAO09D,EACT/gE,OAAO2G,eAAeo6D,EAAK19D,EAAK,CAC9BkB,MAAOA,EACPq0D,YAAY,EACZ/xD,cAAc,EACdg7D,UAAU,IAGZd,EAAI19D,GAAOkB,EAGNw8D,EAST,IAAIsK,IAAiC,qBAAXpkE,SAA0BA,OAAOuH,WAAYvH,OAAOuH,SAAS0F,eA8FvFmrD,EAAOC,QA7FP,SAAwB6M,EAAoBC,EAA2B7D,GACrE,GAAkC,oBAAvB4D,EACT,MAAM,IAAI15D,MAAM,iDAGlB,GAAyC,oBAA9B25D,EACT,MAAM,IAAI35D,MAAM,wDAGlB,GAAgC,qBAArB81D,GAAgE,oBAArBA,EACpD,MAAM,IAAI91D,MAAM,mEAOlB,OAAO,SAAc45D,GACnB,GAAgC,oBAArBA,EACT,MAAM,IAAI55D,MAAM,sDAGlB,IACIkhB,EADA24C,EAAmB,GAGvB,SAASC,IACP54C,EAAQw4C,EAAmBG,EAAiBjmE,KAAI,SAAUi7D,GACxD,OAAOA,EAASK,UAGd6K,EAAWnB,UACbe,EAA0Bz4C,GACjB40C,IACT50C,EAAQ40C,EAAiB50C,IAI7B,IAAI64C,EAA0B,SAAUC,GA5C5C,IAAwBpD,EAAUC,EA+C5B,SAASkD,IACP,OAAOC,EAAersE,MAAMuB,KAAM7B,YAAc6B,KAhDtB2nE,EA6CDmD,GA7CTpD,EA6CHmD,GA5CVvsE,UAAYD,OAAOupE,OAAOD,EAAWrpE,WAC9CopE,EAASppE,UAAUgjB,YAAcomD,EACjCA,EAASI,UAAYH,EAkDjBkD,EAAWb,KAAO,WAChB,OAAOh4C,GAGT64C,EAAWZ,OAAS,WAClB,GAAIY,EAAWnB,UACb,MAAM,IAAI54D,MAAM,oFAGlB,IAAIi6D,EAAgB/4C,EAGpB,OAFAA,OAAQpxB,EACR+pE,EAAmB,GACZI,GAGT,IAAIC,EAASH,EAAWvsE,UAqBxB,OAnBA0sE,EAAOC,0BAA4B,WACjCN,EAAiBxmE,KAAKnE,MACtB4qE,KAGFI,EAAOE,mBAAqB,WAC1BN,KAGFI,EAAOG,qBAAuB,WAC5B,IAAIn7C,EAAQ26C,EAAiB9mE,QAAQ7D,MACrC2qE,EAAiBrgE,OAAO0lB,EAAO,GAC/B46C,KAGFI,EAAOxB,OAAS,WACd,OAAoBc,EAAe/3D,cAAcm4D,EAAkB1qE,KAAKggE,QAGnE6K,EA7CqB,CA8C5BR,EAAMe,eAMR,OAJAb,EAAgBM,EAAY,cAAe,cAxE7C,SAAwBH,GACtB,OAAOA,EAAiBW,aAAeX,EAAiB3kE,MAAQ,YAuELulE,CAAeZ,GAAoB,KAE9FH,EAAgBM,EAAY,YAAanB,GAElCmB","sources":["webpack://_N_E/./node_modules/@datadog/browser-core/esm/tools/display.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/tools/catchUserErrors.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/tools/monitor.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/tools/utils.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/tools/contextManager.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/tools/boundedBuffer.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/tools/timeUtils.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/browser/cookie.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/domain/synthetics/syntheticsWorkerValues.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/domain/configuration/experimentalFeatures.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/transport/eventBridge.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/domain/tracekit/computeStackTrace.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/tools/error.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/tools/urlPolyfill.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/domain/user/user.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/domain/configuration/intakeSites.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/domain/configuration/endpointBuilder.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/domain/configuration/tags.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/domain/configuration/transportConfiguration.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/domain/configuration/configuration.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/tracing/tracer.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/configuration.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/commonContext.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/tools/sendToExtension.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/tools/observable.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/tools/getZoneJsOriginalValue.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/browser/addEventListener.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/domain/telemetry/rawTelemetryEvent.types.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/domain/telemetry/telemetry.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/browser/domMutationObservable.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/tools/runOnReadyState.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/resource/resourceUtils.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/browser/htmlDomUtils.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/tracing/getDocumentTraceId.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/browser/viewportObservable.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/displayContext.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/browser/performanceCollection.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/tools/createEventRateLimiter.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/tools/limitModification.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/syntheticsContext.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/assembly.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/ciTestContext.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/foregroundContexts.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/lifeCycle.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/browser/xhrObservable.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/domain/session/sessionConstants.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/tools/contextHistory.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/tools/instrumentMethod.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/browser/fetchObservable.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/requestCollection.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/tools/readBytesFromStream.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/trackEventCounts.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/waitPageActivityEnd.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/action/clickChain.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/action/getActionNameFromElement.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/tools/browserDetection.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/action/getSelectorFromElement.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/action/listenActionEvents.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/action/computeFrustration.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/action/trackClickActions.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/action/actionCollection.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/domain/tracekit/tracekit.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/domain/console/consoleObservable.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/domain/report/reportObservable.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/view/trackFirstHidden.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/error/errorCollection.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/error/trackConsoleError.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/domain/error/trackRuntimeError.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/error/trackReportError.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/resource/matchRequestTiming.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/resource/resourceCollection.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/view/trackInitialViewTimings.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/view/trackViewMetrics.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/view/trackViews.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/view/trackViewEventCounts.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/view/viewCollection.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/domain/session/sessionCookieStore.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/domain/session/sessionStore.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/domain/session/sessionManager.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/domain/session/oldCookiesMigration.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/rumSessionManager.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/transport/batch.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/transport/sendWithRetryStrategy.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/transport/httpRequest.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/transport/startRumBatch.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/browser/locationChangeObservable.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/startCustomerDataTelemetry.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/pageStateHistory.js","webpack://_N_E/./node_modules/@datadog/browser-rum/esm/types/sessionReplayConstants.js","webpack://_N_E/./node_modules/@datadog/browser-rum/esm/constants.js","webpack://_N_E/./node_modules/@datadog/browser-rum/esm/domain/record/privacy.js","webpack://_N_E/./node_modules/@datadog/browser-rum/esm/domain/record/serializationUtils.js","webpack://_N_E/./node_modules/@datadog/browser-rum/esm/domain/record/serialize.js","webpack://_N_E/./node_modules/@datadog/browser-rum/esm/domain/record/utils.js","webpack://_N_E/./node_modules/@datadog/browser-rum/esm/domain/record/mutationBatch.js","webpack://_N_E/./node_modules/@datadog/browser-rum/esm/domain/record/mutationObserver.js","webpack://_N_E/./node_modules/@datadog/browser-rum/esm/domain/record/viewports.js","webpack://_N_E/./node_modules/@datadog/browser-rum/esm/domain/record/observers.js","webpack://_N_E/./node_modules/@datadog/browser-rum/esm/domain/record/record.js","webpack://_N_E/./node_modules/@datadog/browser-rum/esm/domain/record/elementsScrollPositions.js","webpack://_N_E/./node_modules/@datadog/browser-rum/esm/domain/record/shadowRootsController.js","webpack://_N_E/./node_modules/@datadog/browser-rum/esm/domain/segmentCollection/buildReplayPayload.js","webpack://_N_E/./node_modules/@datadog/browser-rum/esm/domain/replayStats.js","webpack://_N_E/./node_modules/@datadog/browser-rum/esm/domain/segmentCollection/segment.js","webpack://_N_E/./node_modules/@datadog/browser-rum/esm/domain/segmentCollection/segmentCollection.js","webpack://_N_E/./node_modules/@datadog/browser-rum/esm/domain/segmentCollection/startDeflateWorker.js","webpack://_N_E/./node_modules/@datadog/browser-rum/esm/entries/main.js","webpack://_N_E/./node_modules/@datadog/browser-rum/esm/boot/recorderApi.js","webpack://_N_E/./node_modules/@datadog/browser-rum/esm/boot/startRecording.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/boot/rumPublicApi.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/boot/init.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/boot/startRum.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/featureFlagContext.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/transport/startRumEventBridge.js","webpack://_N_E/./node_modules/@datadog/browser-core/esm/browser/pageExitObservable.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/viewContexts.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/urlContexts.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/longTask/longTaskCollection.js","webpack://_N_E/./node_modules/@datadog/browser-rum-core/esm/domain/contexts/internalContext.js","webpack://_N_E/./node_modules/react-fast-compare/index.js","webpack://_N_E/./node_modules/react-helmet/es/Helmet.js","webpack://_N_E/./node_modules/react-side-effect/lib/index.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 ConsoleApiName = {\n    log: 'log',\n    debug: 'debug',\n    info: 'info',\n    warn: 'warn',\n    error: 'error',\n};\nexport var display = function (api) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    if (!Object.prototype.hasOwnProperty.call(ConsoleApiName, api)) {\n        api = ConsoleApiName.log;\n    }\n    display[api].apply(display, args);\n};\ndisplay.debug = console.debug.bind(console);\ndisplay.log = console.log.bind(console);\ndisplay.info = console.info.bind(console);\ndisplay.warn = console.warn.bind(console);\ndisplay.error = console.error.bind(console);\n//# sourceMappingURL=display.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 __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\nimport { ConsoleApiName, display } from './display';\nvar onMonitorErrorCollected;\nvar debugMode = false;\nexport function startMonitorErrorCollection(newOnMonitorErrorCollected) {\n    onMonitorErrorCollected = newOnMonitorErrorCollected;\n}\nexport function setDebugMode(newDebugMode) {\n    debugMode = newDebugMode;\n}\nexport function resetMonitor() {\n    onMonitorErrorCollected = undefined;\n    debugMode = false;\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 = onMonitorErrorCollected ? 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        displayIfDebugEnabled(ConsoleApiName.error, e);\n        if (onMonitorErrorCollected) {\n            try {\n                onMonitorErrorCollected(e);\n            }\n            catch (e) {\n                displayIfDebugEnabled(ConsoleApiName.error, e);\n            }\n        }\n    }\n}\nexport function displayIfDebugEnabled(api) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    if (debugMode) {\n        display.apply(void 0, __spreadArray([api, '[MONITOR]'], args, false));\n    }\n}\n//# sourceMappingURL=monitor.js.map","import { display } from './display';\nimport { monitor } from './monitor';\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_KIBI_BYTE = 1024;\nexport var ONE_MEBI_BYTE = 1024 * ONE_KIBI_BYTE;\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 some toJSON methods. We need to do that\n * because some sites badly override toJSON on certain objects. Removing all toJSON methods from\n * nested values would be too costly, so we just detach them from the root value, and native classes\n * used to build JSON values (Array and Object).\n *\n * Note: this still assumes that JSON.stringify is correct.\n */\nexport function jsonStringify(value, replacer, space) {\n    if (typeof value !== 'object' || value === null) {\n        return JSON.stringify(value);\n    }\n    // Note: The order matter here. We need to detach toJSON methods on parent classes before their\n    // subclasses.\n    var restoreObjectPrototypeToJson = detachToJsonMethod(Object.prototype);\n    var restoreArrayPrototypeToJson = detachToJsonMethod(Array.prototype);\n    var restoreValuePrototypeToJson = detachToJsonMethod(Object.getPrototypeOf(value));\n    var restoreValueToJson = detachToJsonMethod(value);\n    try {\n        return JSON.stringify(value, replacer, space);\n    }\n    catch (_a) {\n        return '<error: unable to serialize object>';\n    }\n    finally {\n        restoreObjectPrototypeToJson();\n        restoreArrayPrototypeToJson();\n        restoreValuePrototypeToJson();\n        restoreValueToJson();\n    }\n}\nfunction detachToJsonMethod(value) {\n    var object = value;\n    var objectToJson = object.toJSON;\n    if (objectToJson) {\n        delete object.toJSON;\n        return function () {\n            object.toJSON = objectToJson;\n        };\n    }\n    return noop;\n}\nexport function includes(candidate, search) {\n    return candidate.indexOf(search) !== -1;\n}\nexport function arrayFrom(arrayLike) {\n    if (Array.from) {\n        return Array.from(arrayLike);\n    }\n    var array = [];\n    if (arrayLike instanceof Set) {\n        arrayLike.forEach(function (item) { return array.push(item); });\n    }\n    else {\n        for (var i = 0; i < arrayLike.length; i++) {\n            array.push(arrayLike[i]);\n        }\n    }\n    return array;\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)) {\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}\nexport function startsWith(candidate, search) {\n    return candidate.slice(0, search.length) === search;\n}\nexport function endsWith(candidate, search) {\n    return candidate.slice(-search.length) === search;\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    }\n    return \"\".concat(candidate.slice(0, correctedLength)).concat(suffix);\n}\nexport function elementMatches(element, selector) {\n    if (element.matches) {\n        return element.matches(selector);\n    }\n    // IE11 support\n    if (element.msMatchesSelector) {\n        return element.msMatchesSelector(selector);\n    }\n    return false;\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 set = new Set();\n    array.forEach(function (item) { return set.add(item); });\n    return arrayFrom(set);\n}\nexport function isMatchOption(item) {\n    var itemType = getType(item);\n    return itemType === 'string' || itemType === 'function' || item instanceof RegExp;\n}\n/**\n * Returns true if value can be matched by at least one of the provided MatchOptions.\n * When comparing strings, setting useStartsWith to true will compare the value with the start of\n * the option, instead of requiring an exact match.\n */\nexport function matchList(list, value, useStartsWith) {\n    if (useStartsWith === void 0) { useStartsWith = false; }\n    return list.some(function (item) {\n        try {\n            if (typeof item === 'function') {\n                return item(value);\n            }\n            else if (item instanceof RegExp) {\n                return item.test(value);\n            }\n            else if (typeof item === 'string') {\n                return useStartsWith ? startsWith(value, item) : item === value;\n            }\n        }\n        catch (e) {\n            display.error(e);\n        }\n        return false;\n    });\n}\n// https://github.com/jquery/jquery/blob/a684e6ba836f7c553968d7d026ed7941e1a612d8/src/selector/escapeSelector.js\nexport function cssEscape(str) {\n    if (window.CSS && window.CSS.escape) {\n        return window.CSS.escape(str);\n    }\n    // eslint-disable-next-line no-control-regex\n    return str.replace(/([\\0-\\x1f\\x7f]|^-?\\d)|^-$|[^\\x80-\\uFFFF\\w-]/g, function (ch, asCodePoint) {\n        if (asCodePoint) {\n            // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER\n            if (ch === '\\0') {\n                return '\\uFFFD';\n            }\n            // Control characters and (dependent upon position) numbers get escaped as code points\n            return \"\".concat(ch.slice(0, -1), \"\\\\\").concat(ch.charCodeAt(ch.length - 1).toString(16), \" \");\n        }\n        // Other potentially-special ASCII characters get backslash-escaped\n        return \"\\\\\".concat(ch);\n    });\n}\n// eslint-disable-next-line no-control-regex\nvar HAS_MULTI_BYTES_CHARACTERS = /[^\\u0000-\\u007F]/;\nexport function computeBytesCount(candidate) {\n    // Accurate bytes count 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}\nexport function tryToClone(response) {\n    try {\n        return response.clone();\n    }\n    catch (e) {\n        // clone can throw if the response has already been used by another instrumentation or is disturbed\n        return;\n    }\n}\n//# sourceMappingURL=utils.js.map","import { computeBytesCount, deepClone, jsonStringify } from './utils';\nexport function createContextManager(computeBytesCountImpl) {\n    if (computeBytesCountImpl === void 0) { computeBytesCountImpl = computeBytesCount; }\n    var context = {};\n    var bytesCountCache;\n    return {\n        getBytesCount: function () {\n            if (bytesCountCache === undefined) {\n                bytesCountCache = computeBytesCountImpl(jsonStringify(context));\n            }\n            return bytesCountCache;\n        },\n        /** @deprecated use getContext instead */\n        get: function () { return context; },\n        /** @deprecated use setContextProperty instead */\n        add: function (key, value) {\n            context[key] = value;\n            bytesCountCache = undefined;\n        },\n        /** @deprecated renamed to removeContextProperty */\n        remove: function (key) {\n            delete context[key];\n            bytesCountCache = undefined;\n        },\n        /** @deprecated use setContext instead */\n        set: function (newContext) {\n            context = newContext;\n            bytesCountCache = undefined;\n        },\n        getContext: function () { return deepClone(context); },\n        setContext: function (newContext) {\n            context = deepClone(newContext);\n            bytesCountCache = undefined;\n        },\n        setContextProperty: function (key, property) {\n            context[key] = deepClone(property);\n            bytesCountCache = undefined;\n        },\n        removeContextProperty: function (key) {\n            delete context[key];\n            bytesCountCache = undefined;\n        },\n        clearContext: function () {\n            context = {};\n            bytesCountCache = undefined;\n        },\n    };\n}\n//# sourceMappingURL=contextManager.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 { isNumber, ONE_YEAR, round } from './utils';\nexport function relativeToClocks(relative) {\n    return { relative: relative, timeStamp: getCorrectedTimeStamp(relative) };\n}\nfunction getCorrectedTimeStamp(relativeTime) {\n    var correctedOrigin = (dateNow() - performance.now());\n    // apply correction only for positive drift\n    if (correctedOrigin > getNavigationStart()) {\n        return Math.round(addDuration(correctedOrigin, relativeTime));\n    }\n    return getTimeStamp(relativeTime);\n}\nexport function currentDrift() {\n    return Math.round(dateNow() - addDuration(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 dateNow() {\n    // Do not use `Date.now` because sometimes websites are wrongly \"polyfilling\" it. For example, we\n    // had some users using a very old version of `datejs`, which patched `Date.now` to return a Date\n    // instance instead of a timestamp[1]. Those users are unlikely to fix this, so let's handle this\n    // case ourselves.\n    // [1]: https://github.com/datejs/Datejs/blob/97f5c7c58c5bc5accdab8aa7602b6ac56462d778/src/core-debug.js#L14-L16\n    return new Date().getTime();\n}\nexport function timeStampNow() {\n    return dateNow();\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}\nexport function addDuration(a, b) {\n    return a + b;\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    return Math.round(addDuration(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","import { display } from '../tools/display';\nimport { findCommaSeparatedValue, generateUUID, ONE_MINUTE, 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_MINUTE, 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 { getCookie } from '../../browser/cookie';\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 willSyntheticsInjectRum() {\n    return Boolean(window._DATADOG_SYNTHETICS_INJECTS_RUM || getCookie(SYNTHETICS_INJECTS_RUM_COOKIE_NAME));\n}\nexport function getSyntheticsTestId() {\n    var value = window._DATADOG_SYNTHETICS_PUBLIC_ID || getCookie(SYNTHETICS_TEST_ID_COOKIE_NAME);\n    return typeof value === 'string' ? value : undefined;\n}\nexport function getSyntheticsResultId() {\n    var value = window._DATADOG_SYNTHETICS_RESULT_ID || getCookie(SYNTHETICS_RESULT_ID_COOKIE_NAME);\n    return typeof value === 'string' ? value : undefined;\n}\n//# sourceMappingURL=syntheticsWorkerValues.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 */\nimport { includes } from '../../tools/utils';\nimport { display } from '../../tools/display';\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        if (includes(flag, '-')) {\n            display.warn(\"please use snake case for '\".concat(flag, \"'\"));\n        }\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}\nexport function getExperimentalFeatures() {\n    return enabledExperimentalFeatures || new Set();\n}\n//# sourceMappingURL=experimentalFeatures.js.map","import { endsWith, getGlobalObject } from '../tools/utils';\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(currentHost) {\n    var _a;\n    if (currentHost === void 0) { currentHost = (_a = getGlobalObject().location) === null || _a === void 0 ? void 0 : _a.hostname; }\n    var bridge = getEventBridge();\n    return (!!bridge &&\n        bridge\n            .getAllowedWebViewHosts()\n            .some(function (allowedHost) { return currentHost === allowedHost || endsWith(currentHost, \".\".concat(allowedHost)); }));\n}\nfunction getEventBridgeGlobal() {\n    return getGlobalObject().DatadogEventBridge;\n}\n//# sourceMappingURL=eventBridge.js.map","import { startsWith } from '../../tools/utils';\nvar 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    var exString = String(ex);\n    if (stackProperty && startsWith(stackProperty, exString)) {\n        stackProperty = stackProperty.slice(exString.length);\n    }\n    if (stackProperty) {\n        stackProperty.split('\\n').forEach(function (line) {\n            var stackFrame = parseChromeLine(line) || parseChromeAnonymousLine(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 fileUrl = '((?:file|https?|blob|chrome-extension|native|eval|webpack|<anonymous>|\\\\w+\\\\.|\\\\/).*?)';\nvar filePosition = '(?::(\\\\d+))';\nvar CHROME_LINE_RE = new RegExp(\"^\\\\s*at (.*?) ?\\\\(\".concat(fileUrl).concat(filePosition, \"?\").concat(filePosition, \"?\\\\)?\\\\s*$\"), 'i');\nvar CHROME_EVAL_RE = new RegExp(\"\\\\((\\\\S*)\".concat(filePosition).concat(filePosition, \"\\\\)\"));\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 CHROME_ANONYMOUS_FUNCTION_RE = new RegExp(\"^\\\\s*at ?\".concat(fileUrl).concat(filePosition, \"?\").concat(filePosition, \"??\\\\s*$\"), 'i');\nfunction parseChromeAnonymousLine(line) {\n    var parts = CHROME_ANONYMOUS_FUNCTION_RE.exec(line);\n    if (!parts) {\n        return;\n    }\n    return {\n        args: [],\n        column: parts[3] ? +parts[3] : undefined,\n        func: UNKNOWN_FUNCTION,\n        line: parts[2] ? +parts[2] : undefined,\n        url: parts[1],\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 = /^\\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 { computeStackTrace } from '../domain/tracekit';\nimport { callMonitored } from './monitor';\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 computeRawError(_a) {\n    var stackTrace = _a.stackTrace, originalError = _a.originalError, handlingStack = _a.handlingStack, startClocks = _a.startClocks, nonErrorPrefix = _a.nonErrorPrefix, source = _a.source, handling = _a.handling;\n    if (!stackTrace || (stackTrace.message === undefined && !(originalError instanceof Error))) {\n        return {\n            startClocks: startClocks,\n            source: source,\n            handling: handling,\n            originalError: originalError,\n            message: \"\".concat(nonErrorPrefix, \" \").concat(jsonStringify(originalError)),\n            stack: 'No stack, consider using an instance of Error',\n            handlingStack: handlingStack,\n            type: stackTrace && stackTrace.name,\n        };\n    }\n    return {\n        startClocks: startClocks,\n        source: source,\n        handling: handling,\n        originalError: originalError,\n        message: stackTrace.message || 'Empty message',\n        stack: toStackTraceString(stackTrace),\n        handlingStack: handlingStack,\n        type: stackTrace.name,\n        causes: flattenErrorCauses(originalError, source),\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 monitored function should encapsulate it, that is why we need to use callMonitored inside 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}\nexport function flattenErrorCauses(error, parentSource) {\n    var currentError = error;\n    var causes = [];\n    while ((currentError === null || currentError === void 0 ? void 0 : currentError.cause) instanceof Error && causes.length < 10) {\n        var stackTrace = computeStackTrace(currentError.cause);\n        causes.push({\n            message: currentError.cause.message,\n            source: parentSource,\n            type: stackTrace === null || stackTrace === void 0 ? void 0 : stackTrace.name,\n            stack: stackTrace && toStackTraceString(stackTrace),\n        });\n        currentError = currentError.cause;\n    }\n    return causes.length ? causes : undefined;\n}\n//# sourceMappingURL=error.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 { display } from '../../tools/display';\nimport { assign, getType } from '../../tools/utils';\n/**\n * Clone input data and ensure known user properties (id, name, email)\n * are strings, as defined here:\n * https://docs.datadoghq.com/logs/log_configuration/attributes_naming_convention/#user-related-attributes\n */\nexport function sanitizeUser(newUser) {\n    // We shallow clone only to prevent mutation of user data.\n    var user = assign({}, newUser);\n    var keys = ['id', 'name', 'email'];\n    keys.forEach(function (key) {\n        if (key in user) {\n            user[key] = String(user[key]);\n        }\n    });\n    return user;\n}\n/**\n * Simple check to ensure user is valid\n */\nexport function checkUser(newUser) {\n    var isValid = getType(newUser) === 'object';\n    if (!isValid) {\n        display.error('Unsupported user:', newUser);\n    }\n    return isValid;\n}\n//# sourceMappingURL=user.js.map","export var INTAKE_SITE_STAGING = 'datad0g.com';\nexport var INTAKE_SITE_US1 = 'datadoghq.com';\nexport var INTAKE_SITE_AP1 = 'ap1.datadoghq.com';\nexport var INTAKE_SITE_US1_FED = 'ddog-gov.com';\n//# sourceMappingURL=intakeSites.js.map","import { timeStampNow } from '../../tools/timeUtils';\nimport { normalizeUrl } from '../../tools/urlPolyfill';\nimport { generateUUID } from '../../tools/utils';\nimport { INTAKE_SITE_AP1, INTAKE_SITE_US1 } from './intakeSites';\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 function createEndpointBuilder(initConfiguration, endpointType, configurationTags) {\n    var buildUrlWithParameters = createEndpointUrlWithParametersBuilder(initConfiguration, endpointType);\n    return {\n        build: function (api, retry) {\n            var parameters = buildEndpointParameters(initConfiguration, endpointType, configurationTags, api, retry);\n            return buildUrlWithParameters(parameters);\n        },\n        urlPrefix: buildUrlWithParameters(''),\n        endpointType: endpointType,\n    };\n}\n/**\n * Create a function used to build a full endpoint url from provided parameters. The goal of this\n * function is to pre-compute some parts of the URL to avoid re-computing everything on every\n * request, as only parameters are changing.\n */\nfunction createEndpointUrlWithParametersBuilder(initConfiguration, endpointType) {\n    var path = \"/api/v2/\".concat(INTAKE_TRACKS[endpointType]);\n    var proxy = initConfiguration.proxy, proxyUrl = initConfiguration.proxyUrl;\n    if (proxy) {\n        var normalizedProxyUrl_1 = normalizeUrl(proxy);\n        return function (parameters) { return \"\".concat(normalizedProxyUrl_1, \"?ddforward=\").concat(encodeURIComponent(\"\".concat(path, \"?\").concat(parameters))); };\n    }\n    var host = buildEndpointHost(initConfiguration, endpointType);\n    if (proxy === undefined && proxyUrl) {\n        // TODO: remove this in a future major.\n        var normalizedProxyUrl_2 = normalizeUrl(proxyUrl);\n        return function (parameters) {\n            return \"\".concat(normalizedProxyUrl_2, \"?ddforward=\").concat(encodeURIComponent(\"https://\".concat(host).concat(path, \"?\").concat(parameters)));\n        };\n    }\n    return function (parameters) { return \"https://\".concat(host).concat(path, \"?\").concat(parameters); };\n}\nfunction buildEndpointHost(initConfiguration, endpointType) {\n    var _a = initConfiguration.site, site = _a === void 0 ? INTAKE_SITE_US1 : _a, internalAnalyticsSubdomain = initConfiguration.internalAnalyticsSubdomain;\n    if (internalAnalyticsSubdomain && site === INTAKE_SITE_US1) {\n        return \"\".concat(internalAnalyticsSubdomain, \".\").concat(INTAKE_SITE_US1);\n    }\n    var domainParts = site.split('.');\n    var extension = domainParts.pop();\n    var subdomain = site !== INTAKE_SITE_AP1 ? \"\".concat(ENDPOINTS[endpointType], \".\") : '';\n    return \"\".concat(subdomain, \"browser-intake-\").concat(domainParts.join('-'), \".\").concat(extension);\n}\n/**\n * Build parameters to be used for an intake request. Parameters should be re-built for each\n * request, as they change randomly.\n */\nfunction buildEndpointParameters(_a, endpointType, configurationTags, api, retry) {\n    var clientToken = _a.clientToken, internalAnalyticsSubdomain = _a.internalAnalyticsSubdomain;\n    var tags = [\"sdk_version:\".concat(\"4.34.0\"), \"api:\".concat(api)].concat(configurationTags);\n    if (retry) {\n        tags.push(\"retry_count:\".concat(retry.count), \"retry_after:\".concat(retry.lastFailureStatus));\n    }\n    var parameters = [\n        'ddsource=browser',\n        \"ddtags=\".concat(encodeURIComponent(tags.join(','))),\n        \"dd-api-key=\".concat(clientToken),\n        \"dd-evp-origin-version=\".concat(encodeURIComponent(\"4.34.0\")),\n        'dd-evp-origin=browser',\n        \"dd-request-id=\".concat(generateUUID()),\n    ];\n    if (endpointType === 'rum') {\n        parameters.push(\"batch_time=\".concat(timeStampNow()));\n    }\n    if (internalAnalyticsSubdomain) {\n        parameters.reverse();\n    }\n    return parameters.join('&');\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 { assign, objectValues } from '../../tools/utils';\nimport { createEndpointBuilder } from './endpointBuilder';\nimport { buildTags } from './tags';\nimport { INTAKE_SITE_US1 } from './intakeSites';\nexport function computeTransportConfiguration(initConfiguration) {\n    var tags = buildTags(initConfiguration);\n    var endpointBuilders = computeEndpointBuilders(initConfiguration, tags);\n    var intakeUrlPrefixes = objectValues(endpointBuilders).map(function (builder) { return builder.urlPrefix; });\n    var replicaConfiguration = computeReplicaConfiguration(initConfiguration, intakeUrlPrefixes, tags);\n    return assign({\n        isIntakeUrl: function (url) { return intakeUrlPrefixes.some(function (intakeEndpoint) { return url.indexOf(intakeEndpoint) === 0; }); },\n        replica: replicaConfiguration,\n        site: initConfiguration.site || INTAKE_SITE_US1,\n    }, endpointBuilders);\n}\nfunction computeEndpointBuilders(initConfiguration, tags) {\n    return {\n        logsEndpointBuilder: createEndpointBuilder(initConfiguration, 'logs', tags),\n        rumEndpointBuilder: createEndpointBuilder(initConfiguration, 'rum', tags),\n        sessionReplayEndpointBuilder: createEndpointBuilder(initConfiguration, 'sessionReplay', tags),\n    };\n}\nfunction computeReplicaConfiguration(initConfiguration, intakeUrlPrefixes, tags) {\n    if (!initConfiguration.replica) {\n        return;\n    }\n    var replicaConfiguration = assign({}, initConfiguration, {\n        site: INTAKE_SITE_US1,\n        clientToken: initConfiguration.replica.clientToken,\n    });\n    var replicaEndpointBuilders = {\n        logsEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'logs', tags),\n        rumEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'rum', tags),\n    };\n    intakeUrlPrefixes.push.apply(intakeUrlPrefixes, objectValues(replicaEndpointBuilders).map(function (builder) { return builder.urlPrefix; }));\n    return assign({ applicationId: initConfiguration.replica.applicationId }, replicaEndpointBuilders);\n}\n//# sourceMappingURL=transportConfiguration.js.map","import { getCurrentSite } from '../../browser/cookie';\nimport { catchUserErrors } from '../../tools/catchUserErrors';\nimport { display } from '../../tools/display';\nimport { assign, isPercentage, ONE_KIBI_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, _c;\n    if (!initConfiguration || !initConfiguration.clientToken) {\n        display.error('Client Token is not configured, we will not send any data.');\n        return;\n    }\n    var sessionSampleRate = (_a = initConfiguration.sessionSampleRate) !== null && _a !== void 0 ? _a : initConfiguration.sampleRate;\n    if (sessionSampleRate !== undefined && !isPercentage(sessionSampleRate)) {\n        display.error('Session 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    if (initConfiguration.telemetryConfigurationSampleRate !== undefined &&\n        !isPercentage(initConfiguration.telemetryConfigurationSampleRate)) {\n        display.error('Telemetry Configuration 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        sessionSampleRate: sessionSampleRate !== null && sessionSampleRate !== void 0 ? sessionSampleRate : 100,\n        telemetrySampleRate: (_b = initConfiguration.telemetrySampleRate) !== null && _b !== void 0 ? _b : 20,\n        telemetryConfigurationSampleRate: (_c = initConfiguration.telemetryConfigurationSampleRate) !== null && _c !== void 0 ? _c : 5,\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_KIBI_BYTE,\n        eventRateLimiterThreshold: 3000,\n        maxTelemetryEventsPerPage: 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        batchMessagesLimit: 50,\n        messageBytesLimit: 256 * ONE_KIBI_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}\nexport function serializeConfiguration(configuration) {\n    var _a, _b;\n    var proxy = (_a = configuration.proxy) !== null && _a !== void 0 ? _a : configuration.proxyUrl;\n    return {\n        session_sample_rate: (_b = configuration.sessionSampleRate) !== null && _b !== void 0 ? _b : configuration.sampleRate,\n        telemetry_sample_rate: configuration.telemetrySampleRate,\n        telemetry_configuration_sample_rate: configuration.telemetryConfigurationSampleRate,\n        use_before_send: !!configuration.beforeSend,\n        use_cross_site_session_cookie: configuration.useCrossSiteSessionCookie,\n        use_secure_session_cookie: configuration.useSecureSessionCookie,\n        use_proxy: proxy !== undefined ? !!proxy : undefined,\n        silent_multiple_init: configuration.silentMultipleInit,\n        track_session_across_subdomains: configuration.trackSessionAcrossSubdomains,\n        track_resources: configuration.trackResources,\n        track_long_task: configuration.trackLongTasks,\n    };\n}\n//# sourceMappingURL=configuration.js.map","import { objectEntries, shallowClone, performDraw, isNumber, assign, find, getType, isMatchOption, matchList, } from '@datadog/browser-core';\nexport function isTracingOption(item) {\n    var expectedItem = item;\n    return (getType(expectedItem) === 'object' &&\n        isMatchOption(expectedItem.match) &&\n        Array.isArray(expectedItem.propagatorTypes));\n}\n/**\n * Clear tracing information to avoid incomplete traces. Ideally, we should do it when the\n * request did not reach the server, but 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        context.traceSampled = 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() || !sessionManager.findTrackedSession()) {\n        return;\n    }\n    var tracingOption = find(configuration.allowedTracingUrls, function (tracingOption) {\n        return matchList([tracingOption.match], context.url, true);\n    });\n    if (!tracingOption) {\n        return;\n    }\n    context.traceId = new TraceIdentifier();\n    context.spanId = new TraceIdentifier();\n    context.traceSampled = !isNumber(configuration.traceSampleRate) || performDraw(configuration.traceSampleRate);\n    inject(makeTracingHeaders(context.traceId, context.spanId, context.traceSampled, tracingOption.propagatorTypes));\n}\nexport function isTracingSupported() {\n    return getCrypto() !== undefined;\n}\nfunction getCrypto() {\n    return window.crypto || window.msCrypto;\n}\n/**\n * When trace is not sampled, set priority to '0' instead of not adding the tracing headers\n * to prepare the implementation for sampling delegation.\n */\nfunction makeTracingHeaders(traceId, spanId, traceSampled, propagatorTypes) {\n    var tracingHeaders = {};\n    propagatorTypes.forEach(function (propagatorType) {\n        switch (propagatorType) {\n            case 'datadog': {\n                assign(tracingHeaders, {\n                    'x-datadog-origin': 'rum',\n                    'x-datadog-parent-id': spanId.toDecimalString(),\n                    'x-datadog-sampling-priority': traceSampled ? '1' : '0',\n                    'x-datadog-trace-id': traceId.toDecimalString(),\n                });\n                break;\n            }\n            // https://www.w3.org/TR/trace-context/\n            case 'tracecontext': {\n                assign(tracingHeaders, {\n                    traceparent: \"00-0000000000000000\".concat(traceId.toPaddedHexadecimalString(), \"-\").concat(spanId.toPaddedHexadecimalString(), \"-0\").concat(traceSampled ? '1' : '0'),\n                });\n                break;\n            }\n            // https://github.com/openzipkin/b3-propagation\n            case 'b3': {\n                assign(tracingHeaders, {\n                    b3: \"\".concat(traceId.toPaddedHexadecimalString(), \"-\").concat(spanId.toPaddedHexadecimalString(), \"-\").concat(traceSampled ? '1' : '0'),\n                });\n                break;\n            }\n            case 'b3multi': {\n                assign(tracingHeaders, {\n                    'X-B3-TraceId': traceId.toPaddedHexadecimalString(),\n                    'X-B3-SpanId': spanId.toPaddedHexadecimalString(),\n                    'X-B3-Sampled': traceSampled ? '1' : '0',\n                });\n                break;\n            }\n        }\n    });\n    return tracingHeaders;\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    /**\n     * Format used by OTel headers\n     */\n    TraceIdentifier.prototype.toPaddedHexadecimalString = function () {\n        var traceId = this.toString(16);\n        return Array(17 - traceId.length).join('0') + traceId;\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 { arrayFrom, getOrigin, isMatchOption, serializeConfiguration, assign, DefaultPrivacyLevel, display, isPercentage, objectHasValue, validateAndBuildConfiguration, } from '@datadog/browser-core';\nimport { isTracingOption } from './tracing/tracer';\nexport function validateAndBuildRumConfiguration(initConfiguration) {\n    var _a, _b, _c, _d, _e, _f;\n    if (!initConfiguration.applicationId) {\n        display.error('Application ID is not configured, no RUM data will be collected.');\n        return;\n    }\n    if (initConfiguration.sessionReplaySampleRate !== undefined &&\n        !isPercentage(initConfiguration.sessionReplaySampleRate)) {\n        display.error('Session Replay Sample Rate should be a number between 0 and 100');\n        return;\n    }\n    // TODO remove fallback in next major\n    var premiumSampleRate = (_a = initConfiguration.premiumSampleRate) !== null && _a !== void 0 ? _a : initConfiguration.replaySampleRate;\n    if (premiumSampleRate !== undefined && initConfiguration.sessionReplaySampleRate !== undefined) {\n        display.warn('Ignoring Premium Sample Rate because Session Replay Sample Rate is set');\n        premiumSampleRate = undefined;\n    }\n    if (premiumSampleRate !== undefined && !isPercentage(premiumSampleRate)) {\n        display.error('Premium Sample Rate should be a number between 0 and 100');\n        return;\n    }\n    var traceSampleRate = (_b = initConfiguration.traceSampleRate) !== null && _b !== void 0 ? _b : initConfiguration.tracingSampleRate;\n    if (traceSampleRate !== undefined && !isPercentage(traceSampleRate)) {\n        display.error('Trace Sample Rate should be a number between 0 and 100');\n        return;\n    }\n    if (initConfiguration.excludedActivityUrls !== undefined && !Array.isArray(initConfiguration.excludedActivityUrls)) {\n        display.error('Excluded Activity Urls should be an array');\n        return;\n    }\n    var allowedTracingUrls = validateAndBuildTracingOptions(initConfiguration);\n    if (!allowedTracingUrls) {\n        return;\n    }\n    var baseConfiguration = validateAndBuildConfiguration(initConfiguration);\n    if (!baseConfiguration) {\n        return;\n    }\n    var trackUserInteractions = !!((_c = initConfiguration.trackUserInteractions) !== null && _c !== void 0 ? _c : initConfiguration.trackInteractions);\n    var trackFrustrations = !!initConfiguration.trackFrustrations;\n    return assign({\n        applicationId: initConfiguration.applicationId,\n        version: initConfiguration.version,\n        actionNameAttribute: initConfiguration.actionNameAttribute,\n        sessionReplaySampleRate: (_e = (_d = initConfiguration.sessionReplaySampleRate) !== null && _d !== void 0 ? _d : premiumSampleRate) !== null && _e !== void 0 ? _e : 100,\n        oldPlansBehavior: initConfiguration.sessionReplaySampleRate === undefined,\n        traceSampleRate: traceSampleRate,\n        allowedTracingUrls: allowedTracingUrls,\n        excludedActivityUrls: (_f = initConfiguration.excludedActivityUrls) !== null && _f !== void 0 ? _f : [],\n        trackUserInteractions: trackUserInteractions || trackFrustrations,\n        trackFrustrations: trackFrustrations,\n        trackViewsManually: !!initConfiguration.trackViewsManually,\n        trackResources: initConfiguration.trackResources,\n        trackLongTasks: initConfiguration.trackLongTasks,\n        defaultPrivacyLevel: objectHasValue(DefaultPrivacyLevel, initConfiguration.defaultPrivacyLevel)\n            ? initConfiguration.defaultPrivacyLevel\n            : DefaultPrivacyLevel.MASK_USER_INPUT,\n        customerDataTelemetrySampleRate: 1,\n    }, baseConfiguration);\n}\n/**\n * Handles allowedTracingUrls and processes legacy allowedTracingOrigins\n */\nfunction validateAndBuildTracingOptions(initConfiguration) {\n    // Advise about parameters precedence.\n    if (initConfiguration.allowedTracingUrls !== undefined && initConfiguration.allowedTracingOrigins !== undefined) {\n        display.warn('Both allowedTracingUrls and allowedTracingOrigins (deprecated) have been defined. The parameter allowedTracingUrls will override allowedTracingOrigins.');\n    }\n    // Handle allowedTracingUrls first\n    if (initConfiguration.allowedTracingUrls !== undefined) {\n        if (!Array.isArray(initConfiguration.allowedTracingUrls)) {\n            display.error('Allowed Tracing URLs should be an array');\n            return;\n        }\n        if (initConfiguration.allowedTracingUrls.length !== 0 && initConfiguration.service === undefined) {\n            display.error('Service needs to be configured when tracing is enabled');\n            return;\n        }\n        // Convert from (MatchOption | TracingOption) to TracingOption, remove unknown properties\n        var tracingOptions_1 = [];\n        initConfiguration.allowedTracingUrls.forEach(function (option) {\n            if (isMatchOption(option)) {\n                tracingOptions_1.push({ match: option, propagatorTypes: ['datadog'] });\n            }\n            else if (isTracingOption(option)) {\n                tracingOptions_1.push(option);\n            }\n            else {\n                display.warn('Allowed Tracing Urls parameters should be a string, RegExp, function, or an object. Ignoring parameter', option);\n            }\n        });\n        return tracingOptions_1;\n    }\n    // Handle conversion of allowedTracingOrigins to allowedTracingUrls\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 needs to be configured when tracing is enabled');\n            return;\n        }\n        var tracingOptions_2 = [];\n        initConfiguration.allowedTracingOrigins.forEach(function (legacyMatchOption) {\n            var tracingOption = convertLegacyMatchOptionToTracingOption(legacyMatchOption);\n            if (tracingOption) {\n                tracingOptions_2.push(tracingOption);\n            }\n        });\n        return tracingOptions_2;\n    }\n    return [];\n}\n/**\n * Converts parameters from the deprecated allowedTracingOrigins\n * to allowedTracingUrls. Handles the change from origin to full URLs.\n */\nfunction convertLegacyMatchOptionToTracingOption(item) {\n    var match;\n    if (typeof item === 'string') {\n        match = item;\n    }\n    else if (item instanceof RegExp) {\n        match = function (url) { return item.test(getOrigin(url)); };\n    }\n    else if (typeof item === 'function') {\n        match = function (url) { return item(getOrigin(url)); };\n    }\n    if (match === undefined) {\n        display.warn('Allowed Tracing Origins parameters should be a string, RegExp or function. Ignoring parameter', item);\n        return undefined;\n    }\n    return { match: match, propagatorTypes: ['datadog'] };\n}\n/**\n * Combines the selected tracing propagators from the different options in allowedTracingUrls,\n * and assumes 'datadog' has been selected when using allowedTracingOrigins\n */\nfunction getSelectedTracingPropagators(configuration) {\n    var usedTracingPropagators = new Set();\n    if (Array.isArray(configuration.allowedTracingUrls) && configuration.allowedTracingUrls.length > 0) {\n        configuration.allowedTracingUrls.forEach(function (option) {\n            if (isMatchOption(option)) {\n                usedTracingPropagators.add('datadog');\n            }\n            else {\n                option.propagatorTypes.forEach(function (propagatorType) { return usedTracingPropagators.add(propagatorType); });\n            }\n        });\n    }\n    if (Array.isArray(configuration.allowedTracingOrigins) && configuration.allowedTracingOrigins.length > 0) {\n        usedTracingPropagators.add('datadog');\n    }\n    return arrayFrom(usedTracingPropagators);\n}\nexport function serializeRumConfiguration(configuration) {\n    var _a, _b;\n    var baseSerializedConfiguration = serializeConfiguration(configuration);\n    return assign({\n        premium_sample_rate: configuration.premiumSampleRate,\n        replay_sample_rate: configuration.replaySampleRate,\n        session_replay_sample_rate: configuration.sessionReplaySampleRate,\n        trace_sample_rate: (_a = configuration.traceSampleRate) !== null && _a !== void 0 ? _a : configuration.tracingSampleRate,\n        action_name_attribute: configuration.actionNameAttribute,\n        use_allowed_tracing_origins: Array.isArray(configuration.allowedTracingOrigins) && configuration.allowedTracingOrigins.length > 0,\n        use_allowed_tracing_urls: Array.isArray(configuration.allowedTracingUrls) && configuration.allowedTracingUrls.length > 0,\n        selected_tracing_propagators: getSelectedTracingPropagators(configuration),\n        default_privacy_level: configuration.defaultPrivacyLevel,\n        use_excluded_activity_urls: Array.isArray(configuration.allowedTracingOrigins) && configuration.allowedTracingOrigins.length > 0,\n        track_frustrations: configuration.trackFrustrations,\n        track_views_manually: configuration.trackViewsManually,\n        track_user_interactions: (_b = configuration.trackUserInteractions) !== null && _b !== void 0 ? _b : configuration.trackInteractions,\n    }, baseSerializedConfiguration);\n}\n//# sourceMappingURL=configuration.js.map","export function buildCommonContext(globalContextManager, userContextManager, recorderApi) {\n    return {\n        context: globalContextManager.getContext(),\n        user: userContextManager.getContext(),\n        hasReplay: recorderApi.isRecording() ? true : undefined,\n    };\n}\n//# sourceMappingURL=commonContext.js.map","export function sendToExtension(type, payload) {\n    var callback = window.__ddBrowserSdkExtensionCallback;\n    if (callback) {\n        callback({ type: type, payload: payload });\n    }\n}\n//# sourceMappingURL=sendToExtension.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","/**\n * Gets the original value for a DOM API that was potentially patched by Zone.js.\n *\n * Zone.js[1] is a library that patches a bunch of JS and DOM APIs. It usually stores the original\n * value of the patched functions/constructors/methods in a hidden property prefixed by\n * __zone_symbol__.\n *\n * In multiple occasions, we observed that Zone.js is the culprit of important issues leading to\n * browser resource exhaustion (memory leak, high CPU usage). This method is used as a workaround to\n * use the original DOM API instead of the one patched by Zone.js.\n *\n * [1]: https://github.com/angular/angular/tree/main/packages/zone.js\n */\nexport function getZoneJsOriginalValue(target, name) {\n    var browserWindow = window;\n    var original;\n    if (browserWindow.Zone && typeof browserWindow.Zone.__symbol__ === 'function') {\n        original = target[browserWindow.Zone.__symbol__(name)];\n    }\n    if (!original) {\n        original = target[name];\n    }\n    return original;\n}\n//# sourceMappingURL=getZoneJsOriginalValue.js.map","import { monitor } from '../tools/monitor';\nimport { getZoneJsOriginalValue } from '../tools/getZoneJsOriginalValue';\n/**\n * Add an event listener to an event target 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(eventTarget, event, listener, options) {\n    return addEventListeners(eventTarget, [event], listener, options);\n}\n/**\n * Add event listeners to an event target 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(eventTarget, 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    var add = getZoneJsOriginalValue(eventTarget, 'addEventListener');\n    events.forEach(function (event) { return add.call(eventTarget, event, wrappedListener, options); });\n    function stop() {\n        var remove = getZoneJsOriginalValue(eventTarget, 'removeEventListener');\n        events.forEach(function (event) { return remove.call(eventTarget, event, wrappedListener, options); });\n    }\n    return {\n        stop: stop,\n    };\n}\n//# sourceMappingURL=addEventListener.js.map","export var TelemetryType = {\n    log: 'log',\n    configuration: 'configuration',\n};\n//# sourceMappingURL=rawTelemetryEvent.types.js.map","import { ConsoleApiName } from '../../tools/display';\nimport { toStackTraceString } from '../../tools/error';\nimport { assign, combine, jsonStringify, performDraw, includes, startsWith, arrayFrom } from '../../tools/utils';\nimport { getExperimentalFeatures, INTAKE_SITE_STAGING, INTAKE_SITE_US1_FED } from '../configuration';\nimport { computeStackTrace } from '../tracekit';\nimport { Observable } from '../../tools/observable';\nimport { timeStampNow } from '../../tools/timeUtils';\nimport { displayIfDebugEnabled, startMonitorErrorCollection } from '../../tools/monitor';\nimport { sendToExtension } from '../../tools/sendToExtension';\nimport { TelemetryType } from './rawTelemetryEvent.types';\nvar ALLOWED_FRAME_URLS = [\n    'https://www.datadoghq-browser-agent.com',\n    'https://www.datad0g-browser-agent.com',\n    'http://localhost',\n    '<anonymous>',\n];\nvar TELEMETRY_EXCLUDED_SITES = [INTAKE_SITE_US1_FED];\nvar telemetryConfiguration = { maxEventsPerPage: 0, sentEventCount: 0, telemetryEnabled: false, telemetryConfigurationEnabled: false };\nvar onRawTelemetryEventCollected;\nexport function startTelemetry(telemetryService, configuration) {\n    var contextProvider;\n    var observable = new Observable();\n    telemetryConfiguration.telemetryEnabled =\n        !includes(TELEMETRY_EXCLUDED_SITES, configuration.site) && performDraw(configuration.telemetrySampleRate);\n    telemetryConfiguration.telemetryConfigurationEnabled =\n        telemetryConfiguration.telemetryEnabled && performDraw(configuration.telemetryConfigurationSampleRate);\n    onRawTelemetryEventCollected = function (rawEvent) {\n        if (telemetryConfiguration.telemetryEnabled) {\n            var event_1 = toTelemetryEvent(telemetryService, rawEvent);\n            observable.notify(event_1);\n            sendToExtension('telemetry', event_1);\n        }\n    };\n    startMonitorErrorCollection(addTelemetryError);\n    assign(telemetryConfiguration, {\n        maxEventsPerPage: configuration.maxTelemetryEventsPerPage,\n        sentEventCount: 0,\n    });\n    function toTelemetryEvent(telemetryService, event) {\n        return combine({\n            type: 'telemetry',\n            date: timeStampNow(),\n            service: telemetryService,\n            version: \"4.34.0\",\n            source: 'browser',\n            _dd: {\n                format_version: 2,\n            },\n            telemetry: event,\n            experimental_features: arrayFrom(getExperimentalFeatures()),\n        }, contextProvider !== undefined ? contextProvider() : {});\n    }\n    return {\n        setContextProvider: function (provider) {\n            contextProvider = provider;\n        },\n        observable: observable,\n        enabled: telemetryConfiguration.telemetryEnabled,\n    };\n}\nexport function startFakeTelemetry() {\n    var events = [];\n    assign(telemetryConfiguration, {\n        maxEventsPerPage: Infinity,\n        sentEventCount: 0,\n    });\n    onRawTelemetryEventCollected = function (event) {\n        events.push(event);\n    };\n    return events;\n}\nexport function resetTelemetry() {\n    onRawTelemetryEventCollected = undefined;\n}\n/**\n * Avoid mixing telemetry events from different data centers\n * but keep replicating staging events for reliability\n */\nexport function isTelemetryReplicationAllowed(configuration) {\n    return configuration.site === INTAKE_SITE_STAGING;\n}\nexport function addTelemetryDebug(message, context) {\n    displayIfDebugEnabled(ConsoleApiName.debug, message, context);\n    addTelemetry(assign({\n        type: TelemetryType.log,\n        message: message,\n        status: \"debug\" /* debug */,\n    }, context));\n}\nexport function addTelemetryError(e) {\n    addTelemetry(assign({\n        type: TelemetryType.log,\n        status: \"error\" /* error */,\n    }, formatError(e)));\n}\nexport function addTelemetryConfiguration(configuration) {\n    if (telemetryConfiguration.telemetryConfigurationEnabled) {\n        addTelemetry({\n            type: TelemetryType.configuration,\n            configuration: configuration,\n        });\n    }\n}\nfunction addTelemetry(event) {\n    if (onRawTelemetryEventCollected && telemetryConfiguration.sentEventCount < telemetryConfiguration.maxEventsPerPage) {\n        telemetryConfiguration.sentEventCount += 1;\n        onRawTelemetryEventCollected(event);\n    }\n}\nexport function formatError(e) {\n    if (e instanceof Error) {\n        var stackTrace = computeStackTrace(e);\n        return {\n            error: {\n                kind: stackTrace.name,\n                stack: toStackTraceString(scrubCustomerFrames(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 scrubCustomerFrames(stackTrace) {\n    stackTrace.stack = stackTrace.stack.filter(function (frame) { return !frame.url || ALLOWED_FRAME_URLS.some(function (allowedFrameUrl) { return startsWith(frame.url, allowedFrameUrl); }); });\n    return stackTrace;\n}\n//# sourceMappingURL=telemetry.js.map","import { monitor, noop, Observable, getZoneJsOriginalValue } 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 try to get the original MutationObserver constructor stored by\n    // Zone.js.\n    //\n    // [1] https://github.com/angular/angular/issues/26948\n    // [2] https://github.com/angular/angular/issues/31712\n    if (browserWindow.Zone) {\n        // Zone.js 0.8.6+ is storing original class constructors into the browser 'window' object[3].\n        //\n        // [3] https://github.com/angular/angular/blob/6375fa79875c0fe7b815efc45940a6e6f5c9c9eb/packages/zone.js/lib/common/utils.ts#L288\n        constructor = getZoneJsOriginalValue(browserWindow, 'MutationObserver');\n        if (browserWindow.MutationObserver && constructor === browserWindow.MutationObserver) {\n            // Anterior Zone.js versions (used in Angular 2) does not expose the original MutationObserver\n            // in the 'window' object. Luckily, the patched MutationObserver class is storing an original\n            // instance in its properties[4]. Let's get the original MutationObserver constructor from\n            // there.\n            //\n            // [4] https://github.com/angular/zone.js/blob/v0.8.5/lib/common/utils.ts#L412\n            var patchedInstance = new browserWindow.MutationObserver(noop);\n            var originalInstance = getZoneJsOriginalValue(patchedInstance, 'originalInstance');\n            constructor = originalInstance && originalInstance.constructor;\n        }\n    }\n    if (!constructor) {\n        constructor = browserWindow.MutationObserver;\n    }\n    return constructor;\n}\n//# sourceMappingURL=domMutationObservable.js.map","import { addEventListener } from '../browser/addEventListener';\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//# sourceMappingURL=runOnReadyState.js.map","import { assign, addTelemetryDebug, 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        addTelemetryDebug(\"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","export function isTextNode(node) {\n    return node.nodeType === Node.TEXT_NODE;\n}\nexport function isCommentNode(node) {\n    return node.nodeType === Node.COMMENT_NODE;\n}\nexport function isElementNode(node) {\n    return node.nodeType === Node.ELEMENT_NODE;\n}\nexport function isNodeShadowHost(node) {\n    return isElementNode(node) && Boolean(node.shadowRoot);\n}\nexport function isNodeShadowRoot(node) {\n    var shadowRoot = node;\n    return !!shadowRoot.host && isElementNode(shadowRoot.host);\n}\nexport function getChildNodes(node) {\n    return isNodeShadowHost(node) ? node.shadowRoot.childNodes : node.childNodes;\n}\n/**\n * Return `host` in case if the current node is a shadow root otherwise will return the `parentNode`\n */\nexport function getParentNode(node) {\n    return isNodeShadowRoot(node) ? node.host : node.parentNode;\n}\n//# sourceMappingURL=htmlDomUtils.js.map","import { dateNow, findCommaSeparatedValue, ONE_MINUTE } from '@datadog/browser-core';\nimport { isCommentNode, isTextNode } from '../../browser/htmlDomUtils';\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 <= dateNow() - 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    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}\n//# sourceMappingURL=getDocumentTraceId.js.map","import { monitor, Observable, throttle, addEventListener } from '@datadog/browser-core';\nvar viewportObservable;\nexport function initViewportObservable() {\n    if (!viewportObservable) {\n        viewportObservable = createViewportObservable();\n    }\n    return viewportObservable;\n}\nexport function createViewportObservable() {\n    var observable = new Observable(function () {\n        var updateDimension = throttle(monitor(function () {\n            observable.notify(getViewportDimension());\n        }), 200).throttled;\n        return addEventListener(window, \"resize\" /* RESIZE */, updateDimension, { capture: true, passive: true }).stop;\n    });\n    return observable;\n}\n// excludes the width and height of any rendered classic scrollbar that is fixed to the visual viewport\nexport function getViewportDimension() {\n    var visual = window.visualViewport;\n    if (visual) {\n        return {\n            width: Number(visual.width * visual.scale),\n            height: Number(visual.height * visual.scale),\n        };\n    }\n    return {\n        width: Number(window.innerWidth || 0),\n        height: Number(window.innerHeight || 0),\n    };\n}\n//# sourceMappingURL=viewportObservable.js.map","import { isExperimentalFeatureEnabled } from '@datadog/browser-core';\nimport { getViewportDimension, initViewportObservable } from '../../browser/viewportObservable';\nvar viewport;\nvar stopListeners;\nexport function getDisplayContext() {\n    if (!isExperimentalFeatureEnabled('clickmap')) {\n        return;\n    }\n    if (!viewport) {\n        viewport = getViewportDimension();\n        stopListeners = initViewportObservable().subscribe(function (viewportDimension) {\n            viewport = viewportDimension;\n        }).unsubscribe;\n    }\n    return {\n        viewport: viewport,\n    };\n}\nexport function resetDisplayContext() {\n    if (stopListeners) {\n        stopListeners();\n    }\n    viewport = undefined;\n}\n//# sourceMappingURL=displayContext.js.map","import { dateNow, 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 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 = dateNow();\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 < dateNow() - 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            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 { ErrorSource } from './error';\nimport { clocksNow } from './timeUtils';\nimport { ONE_MINUTE } from './utils';\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 && Object.prototype.hasOwnProperty.call(object, field);\n}\n//# sourceMappingURL=limitModification.js.map","import { getSyntheticsResultId, getSyntheticsTestId, willSyntheticsInjectRum } from '@datadog/browser-core';\nexport function getSyntheticsContext() {\n    var testId = getSyntheticsTestId();\n    var resultId = getSyntheticsResultId();\n    if (testId && resultId) {\n        return {\n            test_id: testId,\n            result_id: resultId,\n            injected: willSyntheticsInjectRum(),\n        };\n    }\n}\n//# sourceMappingURL=syntheticsContext.js.map","import { combine, isEmptyObject, limitModification, timeStampNow, currentDrift, display, createEventRateLimiter, canUseEventBridge, } from '@datadog/browser-core';\nimport { getSyntheticsContext } from './contexts/syntheticsContext';\nimport { getCiTestContext } from './contexts/ciTestContext';\nimport { getDisplayContext } from './contexts/displayContext';\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, buildCommonContext, reportError) {\n    var _a;\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 || buildCommonContext();\n            var actionId = actionContexts.findActionId(startTime);\n            var rumContext = {\n                _dd: {\n                    format_version: 2,\n                    drift: currentDrift(),\n                    session: {\n                        plan: session.plan,\n                    },\n                    browser_sdk_version: canUseEventBridge() ? \"4.34.0\" : undefined,\n                },\n                application: {\n                    id: configuration.applicationId,\n                },\n                date: timeStampNow(),\n                service: viewContext.service || configuration.service,\n                version: viewContext.version || configuration.version,\n                source: 'browser',\n                session: {\n                    id: session.id,\n                    type: syntheticsContext ? \"synthetics\" /* SYNTHETICS */ : ciTestContext ? \"ci_test\" /* CI_TEST */ : \"user\" /* USER */,\n                },\n                view: {\n                    id: viewContext.id,\n                    name: viewContext.name,\n                    url: urlContext.url,\n                    referrer: urlContext.referrer,\n                },\n                action: needToAssembleWithAction(rawRumEvent) && actionId ? { id: actionId } : undefined,\n                synthetics: syntheticsContext,\n                ci_test: ciTestContext,\n                display: getDisplayContext(),\n            };\n            var serverRumEvent = combine(rumContext, 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 { addDuration, 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    var eventEndTime = addDuration(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 { instrumentMethodAndCallOriginal } from '../tools/instrumentMethod';\nimport { monitor } from '../tools/monitor';\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(String(url)),\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 { ONE_HOUR, ONE_MINUTE } from '../../tools/utils';\nexport var SESSION_TIME_OUT_DELAY = 4 * ONE_HOUR;\nexport var SESSION_EXPIRATION_DELAY = 15 * ONE_MINUTE;\n//# sourceMappingURL=sessionConstants.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 { callMonitored, monitor } from './monitor';\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        if (typeof instrumentation !== 'function') {\n            return undefined;\n        }\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 { instrumentMethod } from '../tools/instrumentMethod';\nimport { callMonitored, monitor } from '../tools/monitor';\nimport { Observable } from '../tools/observable';\nimport { clocksNow } 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 = 'resolve';\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        }\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        }\n        observable.notify(context);\n    };\n    responsePromise.then(monitor(reportFetch), monitor(reportFetch));\n}\n//# sourceMappingURL=fetchObservable.js.map","import { initFetchObservable, initXhrObservable, readBytesFromStream, elapsed, timeStampNow, tryToClone, } 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                    url: context.url,\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                    traceSampled: context.traceSampled,\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                    url: context.url,\n                });\n                break;\n            case 'resolve':\n                waitForResponseToComplete(context, function (duration) {\n                    tracer.clearTracingIfNeeded(context);\n                    lifeCycle.notify(6 /* REQUEST_COMPLETED */, {\n                        duration: 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                        traceSampled: context.traceSampled,\n                        type: \"fetch\" /* FETCH */,\n                        url: context.url,\n                        response: context.response,\n                        init: context.init,\n                        input: context.input,\n                    });\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}\nfunction waitForResponseToComplete(context, callback) {\n    var clonedResponse = context.response && tryToClone(context.response);\n    if (!clonedResponse || !clonedResponse.body) {\n        // do not try to wait for the response if the clone failed, fetch error or null body\n        callback(elapsed(context.startClocks.timeStamp, timeStampNow()));\n    }\n    else {\n        readBytesFromStream(clonedResponse.body, function () {\n            callback(elapsed(context.startClocks.timeStamp, timeStampNow()));\n        }, {\n            bytesLimit: Number.POSITIVE_INFINITY,\n            collectStreamBody: false,\n        });\n    }\n}\n//# sourceMappingURL=requestCollection.js.map","import { monitor } from './monitor';\nimport { noop } from './utils';\n/**\n * Read bytes from a ReadableStream until at least `limit` bytes have been read (or until the end of\n * the stream). The callback is invoked with the at most `limit` bytes, and indicates that the limit\n * has been exceeded if more bytes were available.\n */\nexport function readBytesFromStream(stream, callback, options) {\n    var reader = stream.getReader();\n    var chunks = [];\n    var readBytesCount = 0;\n    readMore();\n    function readMore() {\n        reader.read().then(monitor(function (result) {\n            if (result.done) {\n                onDone();\n                return;\n            }\n            if (options.collectStreamBody) {\n                chunks.push(result.value);\n            }\n            readBytesCount += result.value.length;\n            if (readBytesCount > options.bytesLimit) {\n                onDone();\n            }\n            else {\n                readMore();\n            }\n        }), monitor(function (error) { return callback(error); }));\n    }\n    function onDone() {\n        reader.cancel().catch(\n        // we don't care if cancel fails, but we still need to catch the error to avoid reporting it\n        // as an unhandled rejection\n        noop);\n        var bytes;\n        var limitExceeded;\n        if (options.collectStreamBody) {\n            var completeBuffer_1;\n            if (chunks.length === 1) {\n                // optimization: if the response is small enough to fit in a single buffer (provided by the browser), just\n                // use it directly.\n                completeBuffer_1 = chunks[0];\n            }\n            else {\n                // else, we need to copy buffers into a larger buffer to concatenate them.\n                completeBuffer_1 = new Uint8Array(readBytesCount);\n                var offset_1 = 0;\n                chunks.forEach(function (chunk) {\n                    completeBuffer_1.set(chunk, offset_1);\n                    offset_1 += chunk.length;\n                });\n            }\n            bytes = completeBuffer_1.slice(0, options.bytesLimit);\n            limitExceeded = completeBuffer_1.length > options.bytesLimit;\n        }\n        callback(undefined, bytes, limitExceeded);\n    }\n}\n//# sourceMappingURL=readBytesFromStream.js.map","import { noop } from '@datadog/browser-core';\nexport function trackEventCounts(_a) {\n    var lifeCycle = _a.lifeCycle, isChildEvent = _a.isChildEvent, _b = _a.onChange, callback = _b === void 0 ? noop : _b;\n    var eventCounts = {\n        errorCount: 0,\n        longTaskCount: 0,\n        resourceCount: 0,\n        actionCount: 0,\n        frustrationCount: 0,\n    };\n    var subscription = lifeCycle.subscribe(11 /* RUM_EVENT_COLLECTED */, function (event) {\n        if (event.type === 'view' || !isChildEvent(event)) {\n            return;\n        }\n        switch (event.type) {\n            case \"error\" /* ERROR */:\n                eventCounts.errorCount += 1;\n                callback();\n                break;\n            case \"action\" /* ACTION */:\n                eventCounts.actionCount += 1;\n                if (event.action.frustration) {\n                    eventCounts.frustrationCount += event.action.frustration.type.length;\n                }\n                callback();\n                break;\n            case \"long_task\" /* LONG_TASK */:\n                eventCounts.longTaskCount += 1;\n                callback();\n                break;\n            case \"resource\" /* RESOURCE */:\n                eventCounts.resourceCount += 1;\n                callback();\n                break;\n        }\n    });\n    return {\n        stop: function () {\n            subscription.unsubscribe();\n        },\n        eventCounts: eventCounts,\n    };\n}\n//# sourceMappingURL=trackEventCounts.js.map","import { instrumentMethodAndCallOriginal, matchList, 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 page activity end\n *\n * Detection lifecycle:\n * ```\n *                        Wait page activity end\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 waitPageActivityEnd(lifeCycle, domMutationObservable, configuration, pageActivityEndCallback, maxDuration) {\n    var pageActivityObservable = createPageActivityObservable(lifeCycle, domMutationObservable, configuration);\n    return doWaitPageActivityEnd(pageActivityObservable, pageActivityEndCallback, maxDuration);\n}\nexport function doWaitPageActivityEnd(pageActivityObservable, pageActivityEndCallback, maxDuration) {\n    var pageActivityEndTimeoutId;\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(pageActivityEndTimeoutId);\n        var lastChangeTime = timeStampNow();\n        if (!isBusy) {\n            pageActivityEndTimeoutId = 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(pageActivityEndTimeoutId);\n        clearTimeout(maxDurationTimeoutId);\n        pageActivitySubscription.unsubscribe();\n    };\n    function complete(event) {\n        if (hasCompleted) {\n            return;\n        }\n        stop();\n        pageActivityEndCallback(event);\n    }\n    return { stop: stop };\n}\nexport function createPageActivityObservable(lifeCycle, domMutationObservable, configuration) {\n    var observable = new Observable(function () {\n        var subscriptions = [];\n        var firstRequestIndex;\n        var pendingRequestsCount = 0;\n        subscriptions.push(domMutationObservable.subscribe(notifyPageActivity), lifeCycle.subscribe(0 /* PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n            if (entries.some(function (entry) { return entry.entryType === 'resource' && !isExcludedUrl(configuration, entry.name); })) {\n                notifyPageActivity();\n            }\n        }), lifeCycle.subscribe(5 /* REQUEST_STARTED */, function (startEvent) {\n            if (isExcludedUrl(configuration, startEvent.url)) {\n                return;\n            }\n            if (firstRequestIndex === undefined) {\n                firstRequestIndex = startEvent.requestIndex;\n            }\n            pendingRequestsCount += 1;\n            notifyPageActivity();\n        }), lifeCycle.subscribe(6 /* REQUEST_COMPLETED */, function (request) {\n            if (isExcludedUrl(configuration, request.url) ||\n                firstRequestIndex === undefined ||\n                // If the request started before the tracking start, ignore it\n                request.requestIndex < firstRequestIndex) {\n                return;\n            }\n            pendingRequestsCount -= 1;\n            notifyPageActivity();\n        }));\n        var stopTrackingWindowOpen = trackWindowOpen(notifyPageActivity).stop;\n        return function () {\n            stopTrackingWindowOpen();\n            subscriptions.forEach(function (s) { return s.unsubscribe(); });\n        };\n        function notifyPageActivity() {\n            observable.notify({ isBusy: pendingRequestsCount > 0 });\n        }\n    });\n    return observable;\n}\nfunction isExcludedUrl(configuration, requestUrl) {\n    return matchList(configuration.excludedActivityUrls, requestUrl);\n}\nfunction trackWindowOpen(callback) {\n    return instrumentMethodAndCallOriginal(window, 'open', { before: callback });\n}\n//# sourceMappingURL=waitPageActivityEnd.js.map","import { monitor, ONE_SECOND } from '@datadog/browser-core';\nexport var MAX_DURATION_BETWEEN_CLICKS = ONE_SECOND;\nexport var MAX_DISTANCE_BETWEEN_CLICKS = 100;\nexport function createClickChain(firstClick, onFinalize) {\n    var bufferedClicks = [];\n    var status = 0 /* WaitingForMoreClicks */;\n    var maxDurationBetweenClicksTimeout;\n    appendClick(firstClick);\n    function appendClick(click) {\n        click.stopObservable.subscribe(tryFinalize);\n        bufferedClicks.push(click);\n        clearTimeout(maxDurationBetweenClicksTimeout);\n        maxDurationBetweenClicksTimeout = setTimeout(monitor(dontAcceptMoreClick), MAX_DURATION_BETWEEN_CLICKS);\n    }\n    function tryFinalize() {\n        if (status === 1 /* WaitingForClicksToStop */ && bufferedClicks.every(function (click) { return click.isStopped(); })) {\n            status = 2 /* Finalized */;\n            onFinalize(bufferedClicks);\n        }\n    }\n    function dontAcceptMoreClick() {\n        clearTimeout(maxDurationBetweenClicksTimeout);\n        if (status === 0 /* WaitingForMoreClicks */) {\n            status = 1 /* WaitingForClicksToStop */;\n            tryFinalize();\n        }\n    }\n    return {\n        tryAppend: function (click) {\n            if (status !== 0 /* WaitingForMoreClicks */) {\n                return false;\n            }\n            if (bufferedClicks.length > 0 &&\n                !areEventsSimilar(bufferedClicks[bufferedClicks.length - 1].event, click.event)) {\n                dontAcceptMoreClick();\n                return false;\n            }\n            appendClick(click);\n            return true;\n        },\n        stop: function () {\n            dontAcceptMoreClick();\n        },\n    };\n}\n/**\n * Checks whether two events are similar by comparing their target, position and timestamp\n */\nfunction areEventsSimilar(first, second) {\n    return (first.target === second.target &&\n        mouseEventDistance(first, second) <= MAX_DISTANCE_BETWEEN_CLICKS &&\n        first.timeStamp - second.timeStamp <= MAX_DURATION_BETWEEN_CLICKS);\n}\nfunction mouseEventDistance(origin, other) {\n    return Math.sqrt(Math.pow(origin.clientX - other.clientX, 2) + Math.pow(origin.clientY - other.clientY, 2));\n}\n//# sourceMappingURL=clickChain.js.map","import { safeTruncate, isIE, find } 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 */\nexport var DEFAULT_PROGRAMMATIC_ACTION_NAME_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_ACTION_NAME_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 &&\n                find(element.ownerDocument.querySelectorAll('label'), function (label) { return label.htmlFor === element.id; });\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_ACTION_NAME_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","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 { cssEscape } from '@datadog/browser-core';\nimport { DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE } from './getActionNameFromElement';\n/**\n * Stable attributes are attributes that are commonly used to identify parts of a UI (ex:\n * component). Those attribute values should not be generated randomly (hardcoded most of the time)\n * and stay the same across deploys. They are not necessarily unique across the document.\n */\nexport var STABLE_ATTRIBUTES = [\n    DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE,\n    // Common test attributes (list provided by google recorder)\n    'data-testid',\n    'data-test',\n    'data-qa',\n    'data-cy',\n    'data-test-id',\n    'data-qa-id',\n    'data-testing',\n    // FullStory decorator attributes:\n    'data-component',\n    'data-element',\n    'data-source-file',\n];\n// Selectors to use if they target a single element on the whole document. Those selectors are\n// considered as \"stable\" and uniquely identify an element regardless of the page state. If we find\n// one, we should consider the selector \"complete\" and stop iterating over ancestors.\nvar GLOBALLY_UNIQUE_SELECTOR_GETTERS = [getStableAttributeSelector, getIDSelector];\n// Selectors to use if they target a single element among an element descendants. Those selectors\n// are more brittle than \"globally unique\" selectors and should be combined with ancestor selectors\n// to improve specificity.\nvar UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS = [\n    getStableAttributeSelector,\n    getClassSelector,\n    getTagNameSelector,\n];\nexport function getSelectorFromElement(targetElement, actionNameAttribute) {\n    var targetElementSelector = '';\n    var element = targetElement;\n    while (element && element.nodeName !== 'HTML') {\n        var globallyUniqueSelector = findSelector(element, GLOBALLY_UNIQUE_SELECTOR_GETTERS, isSelectorUniqueGlobally, actionNameAttribute, targetElementSelector);\n        if (globallyUniqueSelector) {\n            return globallyUniqueSelector;\n        }\n        var uniqueSelectorAmongChildren = findSelector(element, UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS, isSelectorUniqueAmongSiblings, actionNameAttribute, targetElementSelector);\n        targetElementSelector =\n            uniqueSelectorAmongChildren || combineSelector(getPositionSelector(element), targetElementSelector);\n        element = element.parentElement;\n    }\n    return targetElementSelector;\n}\nfunction isGeneratedValue(value) {\n    // To compute the \"URL path group\", the backend replaces every URL path parts as a question mark\n    // if it thinks the part is an identifier. The condition it uses is to checks whether a digit is\n    // present.\n    //\n    // Here, we use the same strategy: if a the value contains a digit, we consider it generated. This\n    // strategy might be a bit naive and fail in some cases, but there are many fallbacks to generate\n    // CSS selectors so it should be fine most of the time. We might want to allow customers to\n    // provide their own `isGeneratedValue` at some point.\n    return /[0-9]/.test(value);\n}\nfunction getIDSelector(element) {\n    if (element.id && !isGeneratedValue(element.id)) {\n        return \"#\".concat(cssEscape(element.id));\n    }\n}\nfunction getClassSelector(element) {\n    if (element.tagName === 'BODY') {\n        return;\n    }\n    if (element.classList.length > 0) {\n        for (var i = 0; i < element.classList.length; i += 1) {\n            var className = element.classList[i];\n            if (isGeneratedValue(className)) {\n                continue;\n            }\n            return \"\".concat(element.tagName, \".\").concat(cssEscape(className));\n        }\n    }\n}\nfunction getTagNameSelector(element) {\n    return element.tagName;\n}\nfunction getStableAttributeSelector(element, actionNameAttribute) {\n    if (actionNameAttribute) {\n        var selector = getAttributeSelector(actionNameAttribute);\n        if (selector) {\n            return selector;\n        }\n    }\n    for (var _i = 0, STABLE_ATTRIBUTES_1 = STABLE_ATTRIBUTES; _i < STABLE_ATTRIBUTES_1.length; _i++) {\n        var attributeName = STABLE_ATTRIBUTES_1[_i];\n        var selector = getAttributeSelector(attributeName);\n        if (selector) {\n            return selector;\n        }\n    }\n    function getAttributeSelector(attributeName) {\n        if (element.hasAttribute(attributeName)) {\n            return \"\".concat(element.tagName, \"[\").concat(attributeName, \"=\\\"\").concat(cssEscape(element.getAttribute(attributeName)), \"\\\"]\");\n        }\n    }\n}\nfunction getPositionSelector(element) {\n    var sibling = element.parentElement.firstElementChild;\n    var elementIndex = 1;\n    while (sibling && sibling !== element) {\n        if (sibling.tagName === element.tagName) {\n            elementIndex += 1;\n        }\n        sibling = sibling.nextElementSibling;\n    }\n    return \"\".concat(element.tagName, \":nth-of-type(\").concat(elementIndex, \")\");\n}\nfunction findSelector(element, selectorGetters, predicate, actionNameAttribute, childSelector) {\n    for (var _i = 0, selectorGetters_1 = selectorGetters; _i < selectorGetters_1.length; _i++) {\n        var selectorGetter = selectorGetters_1[_i];\n        var elementSelector = selectorGetter(element, actionNameAttribute);\n        if (!elementSelector) {\n            continue;\n        }\n        var fullSelector = combineSelector(elementSelector, childSelector);\n        if (predicate(element, fullSelector)) {\n            return fullSelector;\n        }\n    }\n}\n/**\n * Check whether the selector is unique among the whole document.\n */\nfunction isSelectorUniqueGlobally(element, selector) {\n    return element.ownerDocument.querySelectorAll(selector).length === 1;\n}\n/**\n * Check whether the selector is unique among the element siblings. In other words, it returns true\n * if \"ELEMENT_PARENT > SELECTOR\" returns a single element.\n *\n * The result will be less accurate on browsers that don't support :scope (i. e. IE): it will check\n * for any element matching the selector contained in the parent (in other words,\n * \"ELEMENT_PARENT SELECTOR\" returns a single element), regardless of whether the selector is a\n * direct descendent of the element parent. This should not impact results too much: if it\n * inaccurately returns false, we'll just fall back to another strategy.\n */\nfunction isSelectorUniqueAmongSiblings(element, selector) {\n    return (element.parentElement.querySelectorAll(supportScopeSelector() ? combineSelector(':scope', selector) : selector)\n        .length === 1);\n}\nfunction combineSelector(parent, child) {\n    return child ? \"\".concat(parent, \">\").concat(child) : parent;\n}\nvar supportScopeSelectorCache;\nexport function supportScopeSelector() {\n    if (supportScopeSelectorCache === undefined) {\n        try {\n            document.querySelector(':scope');\n            supportScopeSelectorCache = true;\n        }\n        catch (_a) {\n            supportScopeSelectorCache = false;\n        }\n    }\n    return supportScopeSelectorCache;\n}\n//# sourceMappingURL=getSelectorFromElement.js.map","import { addEventListener, isExperimentalFeatureEnabled, timeStampNow } from '@datadog/browser-core';\nexport function listenActionEvents(_a) {\n    var onPointerDown = _a.onPointerDown, onStartEvent = _a.onStartEvent;\n    var selectionEmptyAtPointerDown;\n    var userActivity = {\n        selection: false,\n        input: false,\n    };\n    var clickContext;\n    var listeners = [\n        addEventListener(window, \"pointerdown\" /* POINTER_DOWN */, function (event) {\n            if (isValidMouseEvent(event)) {\n                selectionEmptyAtPointerDown = isSelectionEmpty();\n                userActivity = {\n                    selection: false,\n                    input: isExperimentalFeatureEnabled('dead_click_fixes')\n                        ? false\n                        : // Mimics the issue that was fixed in https://github.com/DataDog/browser-sdk/pull/1968\n                            // The goal is to release all dead click fixes at the same time\n                            userActivity.input,\n                };\n                clickContext = onPointerDown(event);\n            }\n        }, { capture: true }),\n        addEventListener(window, \"selectionchange\" /* SELECTION_CHANGE */, function () {\n            if (!selectionEmptyAtPointerDown || !isSelectionEmpty()) {\n                userActivity.selection = true;\n            }\n        }, { capture: true }),\n        addEventListener(window, isExperimentalFeatureEnabled('dead_click_fixes') ? \"pointerup\" /* POINTER_UP */ : \"click\" /* CLICK */, function (startEvent) {\n            if (isValidMouseEvent(startEvent) && clickContext) {\n                // Use a scoped variable to make sure the value is not changed by other clicks\n                var localUserActivity_1 = userActivity;\n                var clickEventTimeStamp_1;\n                onStartEvent(clickContext, startEvent, function () { return localUserActivity_1; }, function () { return clickEventTimeStamp_1; });\n                clickContext = undefined;\n                if (isExperimentalFeatureEnabled('dead_click_fixes')) {\n                    addEventListener(window, \"click\" /* CLICK */, function () {\n                        clickEventTimeStamp_1 = timeStampNow();\n                    }, { capture: true, once: true });\n                }\n            }\n        }, { capture: true }),\n        addEventListener(window, \"input\" /* INPUT */, function () {\n            userActivity.input = true;\n        }, { capture: true }),\n    ];\n    return {\n        stop: function () {\n            listeners.forEach(function (listener) { return listener.stop(); });\n        },\n    };\n}\nfunction isSelectionEmpty() {\n    var selection = window.getSelection();\n    return !selection || selection.isCollapsed;\n}\nfunction isValidMouseEvent(event) {\n    return (event.target instanceof Element &&\n        // Only consider 'primary' pointer events for now. Multi-touch support could be implemented in\n        // the future.\n        // On Chrome, click events are PointerEvent with `isPrimary = false`, but we should still\n        // consider them valid. This could be removed when we enable the `click-action-on-pointerup`\n        // flag, since we won't rely on click events anymore.\n        (event.type === 'click' || event.isPrimary !== false));\n}\n//# sourceMappingURL=listenActionEvents.js.map","import { elementMatches, isExperimentalFeatureEnabled, ONE_SECOND } from '@datadog/browser-core';\nvar MIN_CLICKS_PER_SECOND_TO_CONSIDER_RAGE = 3;\nexport function computeFrustration(clicks, rageClick) {\n    if (isRage(clicks)) {\n        rageClick.addFrustration(\"rage_click\" /* RAGE_CLICK */);\n        if (clicks.some(isDead)) {\n            rageClick.addFrustration(\"dead_click\" /* DEAD_CLICK */);\n        }\n        if (rageClick.hasError) {\n            rageClick.addFrustration(\"error_click\" /* ERROR_CLICK */);\n        }\n        return { isRage: true };\n    }\n    var hasSelectionChanged = clicks.some(function (click) { return click.getUserActivity().selection; });\n    clicks.forEach(function (click) {\n        if (click.hasError) {\n            click.addFrustration(\"error_click\" /* ERROR_CLICK */);\n        }\n        if (isDead(click) &&\n            // Avoid considering clicks part of a double-click or triple-click selections as dead clicks\n            !hasSelectionChanged) {\n            click.addFrustration(\"dead_click\" /* DEAD_CLICK */);\n        }\n    });\n    return { isRage: false };\n}\nexport function isRage(clicks) {\n    if (clicks.some(function (click) { return click.getUserActivity().selection; })) {\n        return false;\n    }\n    for (var i = 0; i < clicks.length - (MIN_CLICKS_PER_SECOND_TO_CONSIDER_RAGE - 1); i += 1) {\n        if (clicks[i + MIN_CLICKS_PER_SECOND_TO_CONSIDER_RAGE - 1].event.timeStamp - clicks[i].event.timeStamp <=\n            ONE_SECOND) {\n            return true;\n        }\n    }\n    return false;\n}\nvar DEAD_CLICK_EXCLUDE_SELECTOR = \n// inputs that don't trigger a meaningful event like \"input\" when clicked, including textual\n// inputs (using a negative selector is shorter here)\n'input:not([type=\"checkbox\"]):not([type=\"radio\"]):not([type=\"button\"]):not([type=\"submit\"]):not([type=\"reset\"]):not([type=\"range\"]),' +\n    'textarea,' +\n    'select,' +\n    // canvas, as there is no good way to detect activity occurring on them\n    'canvas,' +\n    // links that are interactive (have an href attribute) or any of their descendants, as they can\n    // open a new tab or navigate to a hash without triggering a meaningful event\n    'a[href],' +\n    'a[href] *';\nexport function isDead(click) {\n    if (click.hasPageActivity || click.getUserActivity().input) {\n        return false;\n    }\n    return !elementMatches(click.event.target, isExperimentalFeatureEnabled('dead_click_fixes')\n        ? // contenteditable and their descendants don't always trigger meaningful changes when manipulated\n            \"\".concat(DEAD_CLICK_EXCLUDE_SELECTOR, \",[contenteditable],[contenteditable] *\")\n        : DEAD_CLICK_EXCLUDE_SELECTOR);\n}\n//# sourceMappingURL=computeFrustration.js.map","import { includes, timeStampNow, isExperimentalFeatureEnabled, Observable, assign, getRelativeTime, ONE_MINUTE, ContextHistory, generateUUID, clocksNow, ONE_SECOND, elapsed, } from '@datadog/browser-core';\nimport { trackEventCounts } from '../../trackEventCounts';\nimport { PAGE_ACTIVITY_VALIDATION_DELAY, waitPageActivityEnd } from '../../waitPageActivityEnd';\nimport { createClickChain } from './clickChain';\nimport { getActionNameFromElement } from './getActionNameFromElement';\nimport { getSelectorFromElement } from './getSelectorFromElement';\nimport { listenActionEvents } from './listenActionEvents';\nimport { computeFrustration } from './computeFrustration';\n// Maximum duration for click actions\nexport var CLICK_ACTION_MAX_DURATION = 10 * ONE_SECOND;\nexport var ACTION_CONTEXT_TIME_OUT_DELAY = 5 * ONE_MINUTE; // arbitrary\nexport function trackClickActions(lifeCycle, domMutationObservable, configuration) {\n    var history = new ContextHistory(ACTION_CONTEXT_TIME_OUT_DELAY);\n    var stopObservable = new Observable();\n    var currentClickChain;\n    lifeCycle.subscribe(8 /* SESSION_RENEWED */, function () {\n        history.reset();\n    });\n    lifeCycle.subscribe(4 /* VIEW_ENDED */, stopClickChain);\n    var stopActionEventsListener = listenActionEvents({\n        onPointerDown: function (pointerDownEvent) {\n            return processPointerDown(configuration, lifeCycle, domMutationObservable, history, pointerDownEvent);\n        },\n        onStartEvent: function (_a, startEvent, getUserActivity, getClickEventTimeStamp) {\n            var clickActionBase = _a.clickActionBase, hadActivityOnPointerDown = _a.hadActivityOnPointerDown;\n            return startClickAction(configuration, lifeCycle, domMutationObservable, history, stopObservable, appendClickToClickChain, clickActionBase, startEvent, getUserActivity, hadActivityOnPointerDown, getClickEventTimeStamp);\n        },\n    }).stop;\n    var actionContexts = {\n        findActionId: function (startTime) {\n            return configuration.trackFrustrations ? history.findAll(startTime) : history.find(startTime);\n        },\n    };\n    return {\n        stop: function () {\n            stopClickChain();\n            stopObservable.notify();\n            stopActionEventsListener();\n        },\n        actionContexts: actionContexts,\n    };\n    function appendClickToClickChain(click) {\n        if (!currentClickChain || !currentClickChain.tryAppend(click)) {\n            var rageClick_1 = click.clone();\n            currentClickChain = createClickChain(click, function (clicks) {\n                finalizeClicks(clicks, rageClick_1);\n            });\n        }\n    }\n    function stopClickChain() {\n        if (currentClickChain) {\n            currentClickChain.stop();\n        }\n    }\n}\nfunction processPointerDown(configuration, lifeCycle, domMutationObservable, history, pointerDownEvent) {\n    if (!configuration.trackFrustrations && history.find()) {\n        // TODO: remove this in a future major version. To keep retrocompatibility, ignore any new\n        // action if another one is already occurring.\n        return;\n    }\n    var clickActionBase = computeClickActionBase(pointerDownEvent, configuration.actionNameAttribute);\n    if (!configuration.trackFrustrations && !clickActionBase.name) {\n        // TODO: remove this in a future major version. To keep retrocompatibility, ignore any action\n        // with a blank name\n        return;\n    }\n    var hadActivityOnPointerDown = false;\n    if (isExperimentalFeatureEnabled('dead_click_fixes')) {\n        waitPageActivityEnd(lifeCycle, domMutationObservable, configuration, function (pageActivityEndEvent) {\n            hadActivityOnPointerDown = pageActivityEndEvent.hadActivity;\n        }, \n        // We don't care about the activity duration, we just want to know whether an activity did happen\n        // within the \"validation delay\" or not. Limit the duration so the callback is called sooner.\n        PAGE_ACTIVITY_VALIDATION_DELAY);\n    }\n    return { clickActionBase: clickActionBase, hadActivityOnPointerDown: function () { return hadActivityOnPointerDown; } };\n}\nfunction startClickAction(configuration, lifeCycle, domMutationObservable, history, stopObservable, appendClickToClickChain, clickActionBase, startEvent, getUserActivity, hadActivityOnPointerDown, getClickEventTimeStamp) {\n    var click = newClick(lifeCycle, history, getUserActivity, getClickEventTimeStamp, clickActionBase, startEvent);\n    if (configuration.trackFrustrations) {\n        appendClickToClickChain(click);\n    }\n    var stopWaitPageActivityEnd = waitPageActivityEnd(lifeCycle, domMutationObservable, configuration, function (pageActivityEndEvent) {\n        if (pageActivityEndEvent.hadActivity && pageActivityEndEvent.end < click.startClocks.timeStamp) {\n            // If the clock is looking weird, just discard the click\n            click.discard();\n        }\n        else {\n            if (pageActivityEndEvent.hadActivity) {\n                click.stop(pageActivityEndEvent.end);\n            }\n            else if (hadActivityOnPointerDown()) {\n                click.stop(\n                // using the click start as activity end, so the click will have some activity but its\n                // duration will be 0 (as the activity started before the click start)\n                click.startClocks.timeStamp);\n            }\n            else {\n                click.stop();\n            }\n            // Validate or discard the click only if we don't track frustrations. It'll be done when\n            // the click chain is finalized.\n            if (!configuration.trackFrustrations) {\n                if (!pageActivityEndEvent.hadActivity) {\n                    // If we are not tracking frustrations, we should discard the click to keep backward\n                    // compatibility.\n                    click.discard();\n                }\n                else {\n                    click.validate();\n                }\n            }\n        }\n    }, CLICK_ACTION_MAX_DURATION).stop;\n    var viewEndedSubscription = lifeCycle.subscribe(4 /* VIEW_ENDED */, function (_a) {\n        var endClocks = _a.endClocks;\n        click.stop(endClocks.timeStamp);\n    });\n    var stopSubscription = stopObservable.subscribe(function () {\n        click.stop();\n    });\n    click.stopObservable.subscribe(function () {\n        viewEndedSubscription.unsubscribe();\n        stopWaitPageActivityEnd();\n        stopSubscription.unsubscribe();\n    });\n}\nfunction computeClickActionBase(event, actionNameAttribute) {\n    var target;\n    var position;\n    if (isExperimentalFeatureEnabled('clickmap')) {\n        var rect = event.target.getBoundingClientRect();\n        target = {\n            width: Math.round(rect.width),\n            height: Math.round(rect.height),\n            selector: getSelectorFromElement(event.target, actionNameAttribute),\n        };\n        position = {\n            // Use clientX and Y because for SVG element offsetX and Y are relatives to the <svg> element\n            x: Math.round(event.clientX - rect.left),\n            y: Math.round(event.clientY - rect.top),\n        };\n    }\n    return {\n        type: \"click\" /* CLICK */,\n        target: target,\n        position: position,\n        name: getActionNameFromElement(event.target, actionNameAttribute),\n    };\n}\nfunction newClick(lifeCycle, history, getUserActivity, getClickEventTimeStamp, clickActionBase, startEvent) {\n    var id = generateUUID();\n    var startClocks = clocksNow();\n    var historyEntry = history.add(id, startClocks.relative);\n    var eventCountsSubscription = trackEventCounts({\n        lifeCycle: lifeCycle,\n        isChildEvent: function (event) {\n            return event.action !== undefined &&\n                (Array.isArray(event.action.id) ? includes(event.action.id, id) : event.action.id === id);\n        },\n    });\n    var status = 0 /* ONGOING */;\n    var activityEndTime;\n    var frustrationTypes = [];\n    var stopObservable = new Observable();\n    function stop(newActivityEndTime) {\n        if (status !== 0 /* ONGOING */) {\n            return;\n        }\n        activityEndTime = newActivityEndTime;\n        status = 1 /* STOPPED */;\n        if (activityEndTime) {\n            historyEntry.close(getRelativeTime(activityEndTime));\n        }\n        else {\n            historyEntry.remove();\n        }\n        eventCountsSubscription.stop();\n        stopObservable.notify();\n    }\n    return {\n        event: startEvent,\n        stop: stop,\n        stopObservable: stopObservable,\n        get hasError() {\n            return eventCountsSubscription.eventCounts.errorCount > 0;\n        },\n        get hasPageActivity() {\n            return activityEndTime !== undefined;\n        },\n        getUserActivity: getUserActivity,\n        addFrustration: function (frustrationType) {\n            frustrationTypes.push(frustrationType);\n        },\n        startClocks: startClocks,\n        isStopped: function () { return status === 1 /* STOPPED */ || status === 2 /* FINALIZED */; },\n        clone: function () { return newClick(lifeCycle, history, getUserActivity, getClickEventTimeStamp, clickActionBase, startEvent); },\n        validate: function (domEvents) {\n            stop();\n            if (status !== 1 /* STOPPED */) {\n                return;\n            }\n            var _a = eventCountsSubscription.eventCounts, resourceCount = _a.resourceCount, errorCount = _a.errorCount, longTaskCount = _a.longTaskCount;\n            var clickEventTimeStamp = getClickEventTimeStamp();\n            var clickAction = assign({\n                type: \"click\" /* CLICK */,\n                duration: activityEndTime && elapsed(startClocks.timeStamp, activityEndTime),\n                startClocks: startClocks,\n                id: id,\n                frustrationTypes: frustrationTypes,\n                counts: {\n                    resourceCount: resourceCount,\n                    errorCount: errorCount,\n                    longTaskCount: longTaskCount,\n                },\n                events: domEvents !== null && domEvents !== void 0 ? domEvents : [startEvent],\n                event: startEvent,\n                pointerUpDelay: clickEventTimeStamp && elapsed(startClocks.timeStamp, clickEventTimeStamp),\n            }, clickActionBase);\n            lifeCycle.notify(1 /* AUTO_ACTION_COMPLETED */, clickAction);\n            status = 2 /* FINALIZED */;\n        },\n        discard: function () {\n            stop();\n            status = 2 /* FINALIZED */;\n        },\n    };\n}\nexport function finalizeClicks(clicks, rageClick) {\n    var isRage = computeFrustration(clicks, rageClick).isRage;\n    if (isRage) {\n        clicks.forEach(function (click) { return click.discard(); });\n        rageClick.stop(timeStampNow());\n        rageClick.validate(clicks.map(function (click) { return click.event; }));\n    }\n    else {\n        rageClick.discard();\n        clicks.forEach(function (click) { return click.validate(); });\n    }\n}\n//# sourceMappingURL=trackClickActions.js.map","import { noop, assign, combine, toServerDuration, generateUUID } from '@datadog/browser-core';\nimport { trackClickActions } from './trackClickActions';\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.trackUserInteractions) {\n        actionContexts = trackClickActions(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                id: action.id,\n                loading_time: toServerDuration(action.duration),\n                frustration: {\n                    type: action.frustrationTypes,\n                },\n                error: {\n                    count: action.counts.errorCount,\n                },\n                long_task: {\n                    count: action.counts.longTaskCount,\n                },\n                resource: {\n                    count: action.counts.resourceCount,\n                },\n            },\n            _dd: {\n                action: {\n                    target: action.target,\n                    position: action.position,\n                    pointer_up_delay: action.pointerUpDelay,\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, events: action.events } : {},\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 { computeStackTrace } from '../tracekit';\nimport { createHandlingStack, formatErrorMessage, toStackTraceString } from '../../tools/error';\nimport { mergeObservables, Observable } from '../../tools/observable';\nimport { find, jsonStringify } from '../../tools/utils';\nimport { ConsoleApiName } from '../../tools/display';\nimport { callMonitored } from '../../tools/monitor';\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 { monitor } from '../../tools/monitor';\nimport { mergeObservables, Observable } from '../../tools/observable';\nimport { includes, safeTruncate } from '../../tools/utils';\nimport { addEventListener } from '../../browser/addEventListener';\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, event.originalPolicy\n            ? \"\".concat(message, \" of the policy \\\"\").concat(safeTruncate(event.originalPolicy, 100, '...'), \"\\\"\")\n            : 'no policy', 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(eventTarget) {\n    if (eventTarget === void 0) { eventTarget = 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(eventTarget, [\"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 { isEmptyObject, assign, ErrorSource, generateUUID, computeRawError, computeStackTrace, Observable, trackRuntimeError, } from '@datadog/browser-core';\nimport { trackConsoleError } from './trackConsoleError';\nimport { trackReportError } from './trackReportError';\nexport function startErrorCollection(lifeCycle, foregroundContexts, featureFlagContexts) {\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, featureFlagContexts);\n}\nexport function doStartErrorCollection(lifeCycle, foregroundContexts, featureFlagContexts) {\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, featureFlagContexts)));\n    });\n    return {\n        addError: function (_a, savedCommonContext) {\n            var error = _a.error, handlingStack = _a.handlingStack, startClocks = _a.startClocks, customerContext = _a.context;\n            var stackTrace = error instanceof Error ? computeStackTrace(error) : undefined;\n            var rawError = computeRawError({\n                stackTrace: stackTrace,\n                originalError: error,\n                handlingStack: handlingStack,\n                startClocks: startClocks,\n                nonErrorPrefix: 'Provided',\n                source: ErrorSource.CUSTOM,\n                handling: \"handled\" /* HANDLED */,\n            });\n            lifeCycle.notify(12 /* RAW_ERROR_COLLECTED */, {\n                customerContext: customerContext,\n                savedCommonContext: savedCommonContext,\n                error: rawError,\n            });\n        },\n    };\n}\nfunction processError(error, foregroundContexts, featureFlagContexts) {\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            causes: error.causes,\n            source_type: 'browser',\n        },\n        type: \"error\" /* ERROR */,\n    };\n    var inForeground = foregroundContexts.isInForegroundAt(error.startClocks.relative);\n    if (inForeground) {\n        rawRumEvent.view = { in_foreground: inForeground };\n    }\n    var featureFlagContext = featureFlagContexts.findFeatureFlagEvaluations(error.startClocks.relative);\n    if (featureFlagContext && !isEmptyObject(featureFlagContext)) {\n        rawRumEvent.feature_flags = featureFlagContext;\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, computeRawError } from '../../tools/error';\nimport { clocksNow } from '../../tools/timeUtils';\nimport { startUnhandledErrorCollection } from '../tracekit';\nexport function trackRuntimeError(errorObservable) {\n    return startUnhandledErrorCollection(function (stackTrace, originalError) {\n        errorObservable.notify(computeRawError({\n            stackTrace: stackTrace,\n            originalError: originalError,\n            startClocks: clocksNow(),\n            nonErrorPrefix: 'Uncaught',\n            source: ErrorSource.SOURCE,\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 { addDuration } from '@datadog/browser-core';\nimport { 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 *\n * Strategy:\n * - from valid nested entries (with 1 ms error margin)\n * - if a single timing match, return the timing\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    return;\n}\nfunction endTime(timing) {\n    return addDuration(timing.startTime, timing.duration);\n}\nfunction isBetween(timing, start, end) {\n    var errorMargin = 1;\n    return timing.startTime >= start - errorMargin && endTime(timing) <= addDuration(end, errorMargin);\n}\n//# sourceMappingURL=matchRequestTiming.js.map","import { combine, generateUUID, toServerDuration, relativeToClocks, assign, isNumber, isExperimentalFeatureEnabled, } from '@datadog/browser-core';\nimport { matchRequestTiming } from './matchRequestTiming';\nimport { computePerformanceResourceDetails, computePerformanceResourceDuration, computeResourceKind, computeSize, isRequestKind, } from './resourceUtils';\nexport function startResourceCollection(lifeCycle, configuration, sessionManager, pageStateHistory) {\n    lifeCycle.subscribe(6 /* REQUEST_COMPLETED */, function (request) {\n        lifeCycle.notify(10 /* RAW_RUM_EVENT_COLLECTED */, processRequest(request, configuration, sessionManager, pageStateHistory));\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, configuration, sessionManager, pageStateHistory));\n            }\n        }\n    });\n}\nfunction processRequest(request, configuration, sessionManager, pageStateHistory) {\n    var _a;\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, configuration);\n    var indexingInfo = computeIndexingInfo(sessionManager, startClocks);\n    var duration = toServerDuration(request.duration);\n    var durationOverrideInfo = computeDurationOverrideInfo(duration, correspondingTimingOverrides === null || correspondingTimingOverrides === void 0 ? void 0 : correspondingTimingOverrides.resource.duration);\n    var pageStateInfo = computePageStateInfo(pageStateHistory, startClocks, (_a = matchingTiming === null || matchingTiming === void 0 ? void 0 : matchingTiming.duration) !== null && _a !== void 0 ? _a : request.duration);\n    var resourceEvent = combine({\n        date: startClocks.timeStamp,\n        resource: {\n            id: generateUUID(),\n            type: type,\n            duration: duration,\n            method: request.method,\n            status_code: request.status,\n            url: request.url,\n        },\n        type: \"resource\" /* RESOURCE */,\n    }, tracingInfo, correspondingTimingOverrides, indexingInfo, durationOverrideInfo, pageStateInfo);\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, configuration, sessionManager, pageStateHistory) {\n    var type = computeResourceKind(entry);\n    var entryMetrics = computePerformanceEntryMetrics(entry);\n    var startClocks = relativeToClocks(entry.startTime);\n    var tracingInfo = computeEntryTracingInfo(entry, configuration);\n    var indexingInfo = computeIndexingInfo(sessionManager, startClocks);\n    var pageStateInfo = computePageStateInfo(pageStateHistory, startClocks, entry.duration);\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, indexingInfo, pageStateInfo);\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, configuration) {\n    var hasBeenTraced = request.traceSampled && 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            rule_psr: getRulePsr(configuration),\n        },\n    };\n}\nfunction computeEntryTracingInfo(entry, configuration) {\n    var hasBeenTraced = entry.traceId;\n    if (!hasBeenTraced) {\n        return undefined;\n    }\n    return {\n        _dd: {\n            trace_id: entry.traceId,\n            rule_psr: getRulePsr(configuration),\n        },\n    };\n}\nfunction computeDurationOverrideInfo(computedDuration, performanceEntryDuration) {\n    if (!isExperimentalFeatureEnabled('resource_durations')) {\n        return;\n    }\n    return {\n        _dd: {\n            computed_duration: computedDuration,\n            performance_entry_duration: performanceEntryDuration,\n            override_duration_diff: performanceEntryDuration ? computedDuration - performanceEntryDuration : undefined,\n        },\n    };\n}\n// TODO next major: use directly PerformanceEntry type in domain context\nfunction toPerformanceEntryRepresentation(entry) {\n    return entry;\n}\n/**\n * @returns number between 0 and 1 which represents trace sample rate\n */\nfunction getRulePsr(configuration) {\n    return isNumber(configuration.traceSampleRate) ? configuration.traceSampleRate / 100 : undefined;\n}\nfunction computeIndexingInfo(sessionManager, resourceStart) {\n    var session = sessionManager.findTrackedSession(resourceStart.relative);\n    return {\n        _dd: {\n            discarded: !session || !session.resourceAllowed,\n        },\n    };\n}\nfunction computePageStateInfo(pageStateHistory, startClocks, duration) {\n    if (!isExperimentalFeatureEnabled('resource_page_states')) {\n        return;\n    }\n    return {\n        _dd: {\n            page_states: pageStateHistory.findAll(startClocks.relative, duration),\n            page_was_discarded: String(document.wasDiscarded),\n        },\n    };\n}\n//# sourceMappingURL=resourceCollection.js.map","import { assign, addEventListeners, elapsed, ONE_MINUTE, find, findLast, relativeNow, } 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                    // In some cases the value reported is negative or is larger\n                    // than the current page time. Ignore these cases:\n                    // https://github.com/GoogleChrome/web-vitals/issues/137\n                    // https://github.com/GoogleChrome/web-vitals/issues/162\n                    firstByte: entry.responseStart >= 0 && entry.responseStart <= relativeNow() ? entry.responseStart : undefined,\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, eventTarget, 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(eventTarget, [\"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 { waitPageActivityEnd } from '../../waitPageActivityEnd';\nexport function trackViewMetrics(lifeCycle, domMutationObservable, configuration, scheduleViewUpdate, loadingType, viewStart) {\n    var viewMetrics = {};\n    var _a = trackLoadingTime(lifeCycle, domMutationObservable, configuration, 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            stopLoadingTimeTracking();\n            stopCLSTracking();\n        },\n        setLoadEvent: setLoadEvent,\n        viewMetrics: viewMetrics,\n    };\n}\nfunction trackLoadingTime(lifeCycle, domMutationObservable, configuration, 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 = waitPageActivityEnd(lifeCycle, domMutationObservable, configuration, 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';\nimport { trackViewEventCounts } from './trackViewEventCounts';\nexport var THROTTLE_VIEW_UPDATE_PERIOD = 3000;\nexport var SESSION_KEEP_ALIVE_INTERVAL = 5 * ONE_MINUTE;\nexport function trackViews(location, lifeCycle, domMutationObservable, configuration, 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, configuration, 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, configuration, 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 /* PAGE_EXITED */, function (pageExitEvent) {\n            if (pageExitEvent.reason === \"before_unload\" /* UNLOADING */) {\n                currentView.end();\n                currentView.triggerUpdate();\n            }\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, configuration, 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 */, {\n        id: id,\n        name: name,\n        startClocks: startClocks,\n        service: service,\n        version: version,\n    });\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, configuration, scheduleViewUpdate, loadingType, startClocks), setLoadEvent = _b.setLoadEvent, stopViewMetricsTracking = _b.stop, viewMetrics = _b.viewMetrics;\n    var _c = trackViewEventCounts(lifeCycle, id, scheduleViewUpdate), scheduleStopEventCountsTracking = _c.scheduleStop, eventCounts = _c.eventCounts;\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            eventCounts: eventCounts,\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            lifeCycle.notify(4 /* VIEW_ENDED */, { endClocks: endClocks });\n            stopViewMetricsTracking();\n            scheduleStopEventCountsTracking();\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 { monitor, ONE_MINUTE } from '@datadog/browser-core';\nimport { trackEventCounts } from '../../trackEventCounts';\n// Some events are not being counted as they transcend views. To reduce the occurrence;\n// an arbitrary delay is added for stopping event counting after the view ends.\n//\n// Ideally, we would not stop and keep counting events until the end of the session.\n// But this might have a small performance impact if there are many many views:\n// we would need to go through each event to see if the related view matches.\n// So let's have a fairly short delay to avoid impacting performances too much.\n//\n// In the future, we could have views stored in a data structure similar to ContextHistory. Whenever\n// a child event is collected, we could look into this history to find the matching view and\n// increase the associated and increase its counter. Having a centralized data structure for it\n// would allow us to look for views more efficiently.\n//\n// For now, having a small cleanup delay will already improve the situation in most cases.\nexport var KEEP_TRACKING_EVENT_COUNTS_AFTER_VIEW_DELAY = 5 * ONE_MINUTE;\nexport function trackViewEventCounts(lifeCycle, viewId, onChange) {\n    var _a = trackEventCounts({\n        lifeCycle: lifeCycle,\n        isChildEvent: function (event) { return event.view.id === viewId; },\n        onChange: onChange,\n    }), stop = _a.stop, eventCounts = _a.eventCounts;\n    return {\n        scheduleStop: function () {\n            setTimeout(monitor(stop), KEEP_TRACKING_EVENT_COUNTS_AFTER_VIEW_DELAY);\n        },\n        eventCounts: eventCounts,\n    };\n}\n//# sourceMappingURL=trackViewEventCounts.js.map","import { isEmptyObject, mapValues, toServerDuration, isNumber } from '@datadog/browser-core';\nimport { trackViews } from './trackViews';\nexport function startViewCollection(lifeCycle, configuration, location, domMutationObservable, locationChangeObservable, foregroundContexts, featureFlagContexts, recorderApi, initialViewOptions) {\n    lifeCycle.subscribe(3 /* VIEW_UPDATED */, function (view) {\n        return lifeCycle.notify(10 /* RAW_RUM_EVENT_COLLECTED */, processViewUpdate(view, foregroundContexts, featureFlagContexts, recorderApi));\n    });\n    return trackViews(location, lifeCycle, domMutationObservable, configuration, locationChangeObservable, !configuration.trackViewsManually, initialViewOptions);\n}\nfunction processViewUpdate(view, foregroundContexts, featureFlagContexts, recorderApi) {\n    var replayStats = recorderApi.getReplayStats(view.id);\n    var featureFlagContext = featureFlagContexts.findFeatureFlagEvaluations(view.startClocks.relative);\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.actionCount,\n            },\n            frustration: {\n                count: view.eventCounts.frustrationCount,\n            },\n            cumulative_layout_shift: view.cumulativeLayoutShift,\n            first_byte: toServerDuration(view.timings.firstByte),\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        feature_flags: featureFlagContext && !isEmptyObject(featureFlagContext) ? featureFlagContext : undefined,\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 { getCookie, setCookie } from '../../browser/cookie';\nimport { isChromium } from '../../tools/browserDetection';\nimport { monitor } from '../../tools/monitor';\nimport { dateNow } from '../../tools/timeUtils';\nimport * as utils from '../../tools/utils';\nimport { SESSION_EXPIRATION_DELAY } from './sessionConstants';\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(dateNow() + 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","import { COOKIE_ACCESS_DELAY } from '../../browser/cookie';\nimport { monitor } from '../../tools/monitor';\nimport { Observable } from '../../tools/observable';\nimport { dateNow } from '../../tools/timeUtils';\nimport * as utils from '../../tools/utils';\nimport { SESSION_TIME_OUT_DELAY } from './sessionConstants';\nimport { retrieveSession, withCookieLockAccess } from './sessionCookieStore';\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(dateNow());\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 || dateNow() - Number(session.created) < SESSION_TIME_OUT_DELAY) &&\n            (session.expire === undefined || dateNow() < 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 * as utils from '../../tools/utils';\nimport { ContextHistory } from '../../tools/contextHistory';\nimport { relativeNow, clocksOrigin } from '../../tools/timeUtils';\nimport { monitor } from '../../tools/monitor';\nimport { addEventListener, addEventListeners } from '../../browser/addEventListener';\nimport { tryOldCookiesMigration } from './oldCookiesMigration';\nimport { startSessionStore } from './sessionStore';\nimport { SESSION_TIME_OUT_DELAY } from './sessionConstants';\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 = 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 = 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            var plan = session.trackingType === \"1\" /* TRACKED_WITH_SESSION_REPLAY */\n                ? 2 /* WITH_SESSION_REPLAY */\n                : 1 /* WITHOUT_SESSION_REPLAY */;\n            return {\n                id: session.id,\n                plan: plan,\n                sessionReplayAllowed: plan === 2 /* WITH_SESSION_REPLAY */,\n                longTaskAllowed: configuration.trackLongTasks !== undefined\n                    ? configuration.trackLongTasks\n                    : configuration.oldPlansBehavior && plan === 2 /* WITH_SESSION_REPLAY */,\n                resourceAllowed: configuration.trackResources !== undefined\n                    ? configuration.trackResources\n                    : configuration.oldPlansBehavior && plan === 2 /* WITH_SESSION_REPLAY */,\n            };\n        },\n    };\n}\n/**\n * Start a tracked replay session stub\n */\nexport function startRumSessionManagerStub() {\n    var session = {\n        id: '00000000-aaaa-0000-aaaa-000000000000',\n        plan: 1 /* WITHOUT_SESSION_REPLAY */,\n        sessionReplayAllowed: false,\n        longTaskAllowed: true,\n        resourceAllowed: true,\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.sessionSampleRate)) {\n        trackingType = \"0\" /* NOT_TRACKED */;\n    }\n    else if (!performDraw(configuration.sessionReplaySampleRate)) {\n        trackingType = \"2\" /* TRACKED_WITHOUT_SESSION_REPLAY */;\n    }\n    else {\n        trackingType = \"1\" /* TRACKED_WITH_SESSION_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_WITH_SESSION_REPLAY */ ||\n        trackingType === \"2\" /* TRACKED_WITHOUT_SESSION_REPLAY */);\n}\nfunction isTypeTracked(rumSessionType) {\n    return (rumSessionType === \"2\" /* TRACKED_WITHOUT_SESSION_REPLAY */ ||\n        rumSessionType === \"1\" /* TRACKED_WITH_SESSION_REPLAY */);\n}\n//# sourceMappingURL=rumSessionManager.js.map","import { display } from '../tools/display';\nimport { computeBytesCount, jsonStringify, objectValues } from '../tools/utils';\nimport { monitor } from '../tools/monitor';\nimport { Observable } from '../tools/observable';\nvar Batch = /** @class */ (function () {\n    function Batch(request, batchMessagesLimit, batchBytesLimit, messageBytesLimit, flushTimeout, pageExitObservable) {\n        var _this = this;\n        this.request = request;\n        this.batchMessagesLimit = batchMessagesLimit;\n        this.batchBytesLimit = batchBytesLimit;\n        this.messageBytesLimit = messageBytesLimit;\n        this.flushTimeout = flushTimeout;\n        this.pageExitObservable = pageExitObservable;\n        this.flushObservable = new Observable();\n        this.pushOnlyBuffer = [];\n        this.upsertBuffer = {};\n        this.bufferBytesCount = 0;\n        this.bufferMessagesCount = 0;\n        pageExitObservable.subscribe(function () { return _this.flush(_this.request.sendOnExit); });\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 (sendFn) {\n        if (sendFn === void 0) { sendFn = this.request.send; }\n        if (this.bufferMessagesCount !== 0) {\n            var messages = this.pushOnlyBuffer.concat(objectValues(this.upsertBuffer));\n            var bytesCount = this.bufferBytesCount;\n            this.flushObservable.notify({\n                bufferBytesCount: this.bufferBytesCount,\n                bufferMessagesCount: this.bufferMessagesCount,\n            });\n            this.pushOnlyBuffer = [];\n            this.upsertBuffer = {};\n            this.bufferBytesCount = 0;\n            this.bufferMessagesCount = 0;\n            sendFn({ data: messages.join('\\n'), bytesCount: bytesCount });\n        }\n    };\n    Batch.prototype.addOrUpdate = function (message, key) {\n        var _a = this.process(message), processedMessage = _a.processedMessage, messageBytesCount = _a.messageBytesCount;\n        if (messageBytesCount >= this.messageBytesLimit) {\n            display.warn(\"Discarded a message whose size was bigger than the maximum allowed size \".concat(this.messageBytesLimit, \"KB.\"));\n            return;\n        }\n        if (this.hasMessageFor(key)) {\n            this.remove(key);\n        }\n        if (this.willReachedBytesLimitWith(messageBytesCount)) {\n            this.flush();\n        }\n        this.push(processedMessage, messageBytesCount, key);\n        if (this.isFull()) {\n            this.flush();\n        }\n    };\n    Batch.prototype.process = function (message) {\n        var processedMessage = jsonStringify(message);\n        var messageBytesCount = computeBytesCount(processedMessage);\n        return { processedMessage: processedMessage, messageBytesCount: messageBytesCount };\n    };\n    Batch.prototype.push = function (processedMessage, messageBytesCount, key) {\n        if (this.bufferMessagesCount > 0) {\n            // \\n separator at serialization\n            this.bufferBytesCount += 1;\n        }\n        if (key !== undefined) {\n            this.upsertBuffer[key] = processedMessage;\n        }\n        else {\n            this.pushOnlyBuffer.push(processedMessage);\n        }\n        this.bufferBytesCount += messageBytesCount;\n        this.bufferMessagesCount += 1;\n    };\n    Batch.prototype.remove = function (key) {\n        var removedMessage = this.upsertBuffer[key];\n        delete this.upsertBuffer[key];\n        var messageBytesCount = computeBytesCount(removedMessage);\n        this.bufferBytesCount -= messageBytesCount;\n        this.bufferMessagesCount -= 1;\n        if (this.bufferMessagesCount > 0) {\n            this.bufferBytesCount -= 1;\n        }\n    };\n    Batch.prototype.hasMessageFor = function (key) {\n        return key !== undefined && this.upsertBuffer[key] !== undefined;\n    };\n    Batch.prototype.willReachedBytesLimitWith = function (messageBytesCount) {\n        // byte of the separator at the end of the message\n        return this.bufferBytesCount + messageBytesCount + 1 >= this.batchBytesLimit;\n    };\n    Batch.prototype.isFull = function () {\n        return this.bufferMessagesCount === this.batchMessagesLimit || this.bufferBytesCount >= this.batchBytesLimit;\n    };\n    Batch.prototype.flushPeriodically = function () {\n        var _this = this;\n        setTimeout(monitor(function () {\n            _this.flush();\n            _this.flushPeriodically();\n        }), this.flushTimeout);\n    };\n    return Batch;\n}());\nexport { Batch };\n//# sourceMappingURL=batch.js.map","import { monitor } from '../tools/monitor';\nimport { clocksNow } from '../tools/timeUtils';\nimport { ONE_KIBI_BYTE, ONE_MEBI_BYTE, ONE_SECOND, ONE_MINUTE } from '../tools/utils';\nimport { ErrorSource } from '../tools/error';\nexport var MAX_ONGOING_BYTES_COUNT = 80 * ONE_KIBI_BYTE;\nexport var MAX_ONGOING_REQUESTS = 32;\nexport var MAX_QUEUE_BYTES_COUNT = 3 * ONE_MEBI_BYTE;\nexport var MAX_BACKOFF_TIME = ONE_MINUTE;\nexport var INITIAL_BACKOFF_TIME = ONE_SECOND;\nexport function sendWithRetryStrategy(payload, state, sendStrategy, endpointType, reportError) {\n    if (state.transportStatus === 0 /* UP */ &&\n        state.queuedPayloads.size() === 0 &&\n        state.bandwidthMonitor.canHandle(payload)) {\n        send(payload, state, sendStrategy, {\n            onSuccess: function () { return retryQueuedPayloads(0 /* AFTER_SUCCESS */, state, sendStrategy, endpointType, reportError); },\n            onFailure: function () {\n                state.queuedPayloads.enqueue(payload);\n                scheduleRetry(state, sendStrategy, endpointType, reportError);\n            },\n        });\n    }\n    else {\n        state.queuedPayloads.enqueue(payload);\n    }\n}\nfunction scheduleRetry(state, sendStrategy, endpointType, reportError) {\n    if (state.transportStatus !== 2 /* DOWN */) {\n        return;\n    }\n    setTimeout(monitor(function () {\n        var payload = state.queuedPayloads.first();\n        send(payload, state, sendStrategy, {\n            onSuccess: function () {\n                state.queuedPayloads.dequeue();\n                state.currentBackoffTime = INITIAL_BACKOFF_TIME;\n                retryQueuedPayloads(1 /* AFTER_RESUME */, state, sendStrategy, endpointType, reportError);\n            },\n            onFailure: function () {\n                state.currentBackoffTime = Math.min(MAX_BACKOFF_TIME, state.currentBackoffTime * 2);\n                scheduleRetry(state, sendStrategy, endpointType, reportError);\n            },\n        });\n    }), state.currentBackoffTime);\n}\nfunction send(payload, state, sendStrategy, _a) {\n    var onSuccess = _a.onSuccess, onFailure = _a.onFailure;\n    state.bandwidthMonitor.add(payload);\n    sendStrategy(payload, function (response) {\n        state.bandwidthMonitor.remove(payload);\n        if (!shouldRetryRequest(response)) {\n            state.transportStatus = 0 /* UP */;\n            onSuccess();\n        }\n        else {\n            // do not consider transport down if another ongoing request could succeed\n            state.transportStatus =\n                state.bandwidthMonitor.ongoingRequestCount > 0 ? 1 /* FAILURE_DETECTED */ : 2 /* DOWN */;\n            payload.retry = {\n                count: payload.retry ? payload.retry.count + 1 : 1,\n                lastFailureStatus: response.status,\n            };\n            onFailure();\n        }\n    });\n}\nfunction retryQueuedPayloads(reason, state, sendStrategy, endpointType, reportError) {\n    if (reason === 0 /* AFTER_SUCCESS */ && state.queuedPayloads.isFull() && !state.queueFullReported) {\n        reportError({\n            message: \"Reached max \".concat(endpointType, \" events size queued for upload: \").concat(MAX_QUEUE_BYTES_COUNT / ONE_MEBI_BYTE, \"MiB\"),\n            source: ErrorSource.AGENT,\n            startClocks: clocksNow(),\n        });\n        state.queueFullReported = true;\n    }\n    var previousQueue = state.queuedPayloads;\n    state.queuedPayloads = newPayloadQueue();\n    while (previousQueue.size() > 0) {\n        sendWithRetryStrategy(previousQueue.dequeue(), state, sendStrategy, endpointType, reportError);\n    }\n}\nfunction shouldRetryRequest(response) {\n    return (response.type !== 'opaque' &&\n        ((response.status === 0 && !navigator.onLine) ||\n            response.status === 408 ||\n            response.status === 429 ||\n            response.status >= 500));\n}\nexport function newRetryState() {\n    return {\n        transportStatus: 0 /* UP */,\n        currentBackoffTime: INITIAL_BACKOFF_TIME,\n        bandwidthMonitor: newBandwidthMonitor(),\n        queuedPayloads: newPayloadQueue(),\n        queueFullReported: false,\n    };\n}\nfunction newPayloadQueue() {\n    var queue = [];\n    return {\n        bytesCount: 0,\n        enqueue: function (payload) {\n            if (this.isFull()) {\n                return;\n            }\n            queue.push(payload);\n            this.bytesCount += payload.bytesCount;\n        },\n        first: function () {\n            return queue[0];\n        },\n        dequeue: function () {\n            var payload = queue.shift();\n            if (payload) {\n                this.bytesCount -= payload.bytesCount;\n            }\n            return payload;\n        },\n        size: function () {\n            return queue.length;\n        },\n        isFull: function () {\n            return this.bytesCount >= MAX_QUEUE_BYTES_COUNT;\n        },\n    };\n}\nfunction newBandwidthMonitor() {\n    return {\n        ongoingRequestCount: 0,\n        ongoingByteCount: 0,\n        canHandle: function (payload) {\n            return (this.ongoingRequestCount === 0 ||\n                (this.ongoingByteCount + payload.bytesCount <= MAX_ONGOING_BYTES_COUNT &&\n                    this.ongoingRequestCount < MAX_ONGOING_REQUESTS));\n        },\n        add: function (payload) {\n            this.ongoingRequestCount += 1;\n            this.ongoingByteCount += payload.bytesCount;\n        },\n        remove: function (payload) {\n            this.ongoingRequestCount -= 1;\n            this.ongoingByteCount -= payload.bytesCount;\n        },\n    };\n}\n//# sourceMappingURL=sendWithRetryStrategy.js.map","import { addTelemetryError } from '../domain/telemetry';\nimport { monitor } from '../tools/monitor';\nimport { newRetryState, sendWithRetryStrategy } from './sendWithRetryStrategy';\nexport function createHttpRequest(endpointBuilder, bytesLimit, reportError) {\n    var retryState = newRetryState();\n    var sendStrategyForRetry = function (payload, onResponse) {\n        return fetchKeepAliveStrategy(endpointBuilder, bytesLimit, payload, onResponse);\n    };\n    return {\n        send: function (payload) {\n            sendWithRetryStrategy(payload, retryState, sendStrategyForRetry, endpointBuilder.endpointType, reportError);\n        },\n        /**\n         * Since fetch keepalive behaves like regular fetch on Firefox,\n         * keep using sendBeaconStrategy on exit\n         */\n        sendOnExit: function (payload) {\n            sendBeaconStrategy(endpointBuilder, bytesLimit, payload);\n        },\n    };\n}\nfunction sendBeaconStrategy(endpointBuilder, bytesLimit, _a) {\n    var data = _a.data, bytesCount = _a.bytesCount;\n    var canUseBeacon = !!navigator.sendBeacon && bytesCount < bytesLimit;\n    if (canUseBeacon) {\n        try {\n            var beaconUrl = endpointBuilder.build('beacon');\n            var isQueued = navigator.sendBeacon(beaconUrl, data);\n            if (isQueued) {\n                return;\n            }\n        }\n        catch (e) {\n            reportBeaconError(e);\n        }\n    }\n    var xhrUrl = endpointBuilder.build('xhr');\n    sendXHR(xhrUrl, data);\n}\nvar hasReportedBeaconError = false;\nfunction reportBeaconError(e) {\n    if (!hasReportedBeaconError) {\n        hasReportedBeaconError = true;\n        addTelemetryError(e);\n    }\n}\nexport function fetchKeepAliveStrategy(endpointBuilder, bytesLimit, _a, onResponse) {\n    var data = _a.data, bytesCount = _a.bytesCount, retry = _a.retry;\n    var canUseKeepAlive = isKeepAliveSupported() && bytesCount < bytesLimit;\n    if (canUseKeepAlive) {\n        var fetchUrl = endpointBuilder.build('fetch', retry);\n        fetch(fetchUrl, { method: 'POST', body: data, keepalive: true, mode: 'cors' }).then(monitor(function (response) { return onResponse === null || onResponse === void 0 ? void 0 : onResponse({ status: response.status, type: response.type }); }), monitor(function () {\n            var xhrUrl = endpointBuilder.build('xhr', retry);\n            // failed to queue the request\n            sendXHR(xhrUrl, data, onResponse);\n        }));\n    }\n    else {\n        var xhrUrl = endpointBuilder.build('xhr', retry);\n        sendXHR(xhrUrl, data, onResponse);\n    }\n}\nfunction isKeepAliveSupported() {\n    // Request can throw, cf https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#errors\n    try {\n        return window.Request && 'keepalive' in new Request('http://a');\n    }\n    catch (_a) {\n        return false;\n    }\n}\nexport function sendXHR(url, data, onResponse) {\n    var request = new XMLHttpRequest();\n    var onLoadEnd = monitor(function () {\n        // prevent multiple onResponse callbacks\n        // if the xhr instance is reused by a third party\n        request.removeEventListener('loadend', onLoadEnd);\n        onResponse === null || onResponse === void 0 ? void 0 : onResponse({ status: request.status });\n    });\n    request.open('POST', url, true);\n    request.addEventListener('loadend', onLoadEnd);\n    request.send(data);\n}\n//# sourceMappingURL=httpRequest.js.map","import { Batch, combine, createHttpRequest, isTelemetryReplicationAllowed } from '@datadog/browser-core';\nexport function startRumBatch(configuration, lifeCycle, telemetryEventObservable, reportError, pageExitObservable) {\n    var batch = makeRumBatch(configuration, reportError, pageExitObservable);\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, isTelemetryReplicationAllowed(configuration)); });\n    return batch;\n}\nfunction makeRumBatch(configuration, reportError, pageExitObservable) {\n    var primaryBatch = createRumBatch(configuration.rumEndpointBuilder);\n    var replicaBatch;\n    var replica = configuration.replica;\n    if (replica !== undefined) {\n        replicaBatch = createRumBatch(replica.rumEndpointBuilder);\n    }\n    function createRumBatch(endpointBuilder) {\n        return new Batch(createHttpRequest(endpointBuilder, configuration.batchBytesLimit, reportError), configuration.batchMessagesLimit, configuration.batchBytesLimit, configuration.messageBytesLimit, configuration.flushTimeout, pageExitObservable);\n    }\n    function withReplicaApplicationId(message) {\n        return combine(message, { application: { id: replica.applicationId } });\n    }\n    return {\n        flushObservable: primaryBatch.flushObservable,\n        add: function (message, replicated) {\n            if (replicated === void 0) { replicated = true; }\n            primaryBatch.add(message);\n            if (replicaBatch && replicated) {\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 { isEmptyObject, includes, performDraw, ONE_SECOND, addTelemetryDebug, monitor } from '@datadog/browser-core';\nexport var MEASURES_PERIOD_DURATION = 10 * ONE_SECOND;\nvar currentPeriodMeasures;\nvar currentBatchMeasures;\nvar batchHasRumEvent;\nexport function startCustomerDataTelemetry(configuration, telemetry, lifeCycle, globalContextManager, userContextManager, featureFlagContexts, batchFlushObservable) {\n    var customerDataTelemetryEnabled = telemetry.enabled && performDraw(configuration.customerDataTelemetrySampleRate);\n    if (!customerDataTelemetryEnabled) {\n        return;\n    }\n    initCurrentPeriodMeasures();\n    initCurrentBatchMeasures();\n    // We measure the data of every view updates even if there could only be one per batch due to the upsert\n    // It means that contexts bytes count sums can be higher than it really is\n    lifeCycle.subscribe(11 /* RUM_EVENT_COLLECTED */, function (event) {\n        batchHasRumEvent = true;\n        updateMeasure(currentBatchMeasures.globalContextBytes, !isEmptyObject(globalContextManager.get()) ? globalContextManager.getBytesCount() : 0);\n        updateMeasure(currentBatchMeasures.userContextBytes, !isEmptyObject(userContextManager.get()) ? userContextManager.getBytesCount() : 0);\n        var featureFlagContext = featureFlagContexts.findFeatureFlagEvaluations();\n        var hasFeatureFlagContext = includes([\"view\" /* VIEW */, \"error\" /* ERROR */], event.type) &&\n            featureFlagContext &&\n            !isEmptyObject(featureFlagContext);\n        updateMeasure(currentBatchMeasures.featureFlagBytes, hasFeatureFlagContext ? featureFlagContexts.getFeatureFlagBytesCount() : 0);\n    });\n    batchFlushObservable.subscribe(function (_a) {\n        var bufferBytesCount = _a.bufferBytesCount, bufferMessagesCount = _a.bufferMessagesCount;\n        // Don't measure batch that only contains telemetry events to avoid batch sending loop\n        // It could happen because after each batch we are adding a customer data measures telemetry event to the next one\n        if (!batchHasRumEvent) {\n            return;\n        }\n        currentPeriodMeasures.batchCount += 1;\n        updateMeasure(currentPeriodMeasures.batchBytesCount, bufferBytesCount);\n        updateMeasure(currentPeriodMeasures.batchMessagesCount, bufferMessagesCount);\n        mergeMeasure(currentPeriodMeasures.globalContextBytes, currentBatchMeasures.globalContextBytes);\n        mergeMeasure(currentPeriodMeasures.userContextBytes, currentBatchMeasures.userContextBytes);\n        mergeMeasure(currentPeriodMeasures.featureFlagBytes, currentBatchMeasures.featureFlagBytes);\n        initCurrentBatchMeasures();\n    });\n    setInterval(monitor(sendCurrentPeriodMeasures), MEASURES_PERIOD_DURATION);\n}\nfunction sendCurrentPeriodMeasures() {\n    if (currentPeriodMeasures.batchCount === 0) {\n        return;\n    }\n    addTelemetryDebug('Customer data measures', currentPeriodMeasures);\n    initCurrentPeriodMeasures();\n}\nfunction createMeasure() {\n    return { min: Infinity, max: 0, sum: 0 };\n}\nfunction updateMeasure(measure, value) {\n    measure.sum += value;\n    measure.min = Math.min(measure.min, value);\n    measure.max = Math.max(measure.max, value);\n}\nfunction mergeMeasure(target, source) {\n    target.sum += source.sum;\n    target.min = Math.min(target.min, source.min);\n    target.max = Math.max(target.max, source.max);\n}\nfunction initCurrentPeriodMeasures() {\n    currentPeriodMeasures = {\n        batchCount: 0,\n        batchBytesCount: createMeasure(),\n        batchMessagesCount: createMeasure(),\n        globalContextBytes: createMeasure(),\n        userContextBytes: createMeasure(),\n        featureFlagBytes: createMeasure(),\n    };\n}\nfunction initCurrentBatchMeasures() {\n    batchHasRumEvent = false;\n    currentBatchMeasures = {\n        globalContextBytes: createMeasure(),\n        userContextBytes: createMeasure(),\n        featureFlagBytes: createMeasure(),\n    };\n}\n//# sourceMappingURL=startCustomerDataTelemetry.js.map","import { addDuration, addEventListeners, relativeNow } from '@datadog/browser-core';\nexport var MAX_PAGE_STATE_ENTRIES = 500;\nvar pageStateEntries = [];\nvar currentPageState;\nexport function startPageStateHistory() {\n    addPageState(getPageState());\n    var stop = addEventListeners(window, [\n        \"pageshow\" /* PAGE_SHOW */,\n        \"focus\" /* FOCUS */,\n        \"blur\" /* BLUR */,\n        \"visibilitychange\" /* VISIBILITY_CHANGE */,\n        \"resume\" /* RESUME */,\n        \"freeze\" /* FREEZE */,\n        \"pagehide\" /* PAGE_HIDE */,\n    ], function (event) {\n        // Only get events fired by the browser to avoid false currentPageState changes done with custom events\n        // cf: developer extension auto flush: https://github.com/DataDog/browser-sdk/blob/2f72bf05a672794c9e33965351964382a94c72ba/developer-extension/src/panel/flushEvents.ts#L11-L12\n        if (!event.isTrusted) {\n            return;\n        }\n        if (event.type === \"freeze\" /* FREEZE */) {\n            addPageState(\"frozen\" /* FROZEN */);\n        }\n        else if (event.type === \"pagehide\" /* PAGE_HIDE */) {\n            addPageState(event.persisted ? \"frozen\" /* FROZEN */ : \"terminated\" /* TERMINATED */);\n        }\n        else {\n            addPageState(getPageState());\n        }\n    }, { capture: true }).stop;\n    return {\n        findAll: function (startTime, duration) {\n            var entries = [];\n            var endTime = addDuration(startTime, duration);\n            for (var i = pageStateEntries.length - 1; i >= 0; i--) {\n                var stateStartTime = pageStateEntries[i].startTime;\n                if (stateStartTime >= endTime) {\n                    continue;\n                }\n                entries.unshift(pageStateEntries[i]);\n                if (stateStartTime < startTime) {\n                    break;\n                }\n            }\n            return entries.length ? entries : undefined;\n        },\n        stop: stop,\n    };\n}\nfunction getPageState() {\n    if (document.visibilityState === 'hidden') {\n        return \"hidden\" /* HIDDEN */;\n    }\n    if (document.hasFocus()) {\n        return \"active\" /* ACTIVE */;\n    }\n    return \"passive\" /* PASSIVE */;\n}\nexport function addPageState(nextPageState, maxPageStateEntries) {\n    if (maxPageStateEntries === void 0) { maxPageStateEntries = MAX_PAGE_STATE_ENTRIES; }\n    if (nextPageState === currentPageState) {\n        return;\n    }\n    currentPageState = nextPageState;\n    if (pageStateEntries.length === maxPageStateEntries) {\n        pageStateEntries.shift();\n    }\n    pageStateEntries.push({ state: currentPageState, startTime: relativeNow() });\n}\nexport function resetPageStates() {\n    pageStateEntries = [];\n    currentPageState = undefined;\n}\n//# sourceMappingURL=pageStateHistory.js.map","export var RecordType = {\n    FullSnapshot: 2,\n    IncrementalSnapshot: 3,\n    Meta: 4,\n    Focus: 6,\n    ViewEnd: 7,\n    VisualViewport: 8,\n    FrustrationRecord: 9,\n};\nexport var NodeType = {\n    Document: 0,\n    DocumentType: 1,\n    Element: 2,\n    Text: 3,\n    CDATA: 4,\n    DocumentFragment: 11,\n};\nexport 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 MouseInteractionType = {\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 MediaInteractionType = {\n    Play: 0,\n    Pause: 1,\n};\n//# sourceMappingURL=sessionReplayConstants.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 { isElementNode, getParentNode, isTextNode } from '@datadog/browser-rum-core';\nimport { 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;\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 parentNode = getParentNode(node);\n    var parentNodePrivacyLevel = parentNode ? getNodePrivacyLevel(parentNode, defaultPrivacyLevel) : 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 (!isElementNode(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 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/**\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        // Link as script - Ignore only when rel=preload, modulepreload or prefetch\n        (/preload|prefetch/i.test(relAttribute) && 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//# sourceMappingURL=privacy.js.map","import { buildUrl } from '@datadog/browser-core';\nimport { getParentNode, isNodeShadowRoot } from '@datadog/browser-rum-core';\nimport { 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) && !isNodeShadowRoot(current)) {\n            return false;\n        }\n        current = getParentNode(current);\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}\nexport var URL_IN_CSS_REF = /url\\((?:(')([^']*)'|(\")([^\"]*)\"|([^)]*))\\)/gm;\nexport var ABSOLUTE_URL = /^[A-Za-z]+:|^\\/\\//;\nexport var DATA_URI = /^data:.*,/i;\nexport function switchToAbsoluteUrl(cssText, cssHref) {\n    return cssText.replace(URL_IN_CSS_REF, function (matchingSubstring, singleQuote, urlWrappedInSingleQuotes, doubleQuote, urlWrappedInDoubleQuotes, urlNotWrappedInQuotes) {\n        var url = urlWrappedInSingleQuotes || urlWrappedInDoubleQuotes || urlNotWrappedInQuotes;\n        if (!cssHref || !url || ABSOLUTE_URL.test(url) || DATA_URI.test(url)) {\n            return matchingSubstring;\n        }\n        var quote = singleQuote || doubleQuote || '';\n        return \"url(\".concat(quote).concat(makeUrlAbsolute(url, cssHref)).concat(quote, \")\");\n    });\n}\nexport function makeUrlAbsolute(url, baseUrl) {\n    try {\n        return buildUrl(url, baseUrl).href;\n    }\n    catch (_) {\n        return url;\n    }\n}\nexport function serializeStyleSheets(cssStyleSheets) {\n    if (cssStyleSheets === undefined || cssStyleSheets.length === 0) {\n        return undefined;\n    }\n    return cssStyleSheets.map(function (cssStyleSheet) {\n        var rules = cssStyleSheet.cssRules || cssStyleSheet.rules;\n        var cssRules = Array.from(rules, function (cssRule) { return cssRule.cssText; });\n        var styleSheet = {\n            cssRules: cssRules,\n            disabled: cssStyleSheet.disabled || undefined,\n            media: cssStyleSheet.media.length > 0 ? Array.from(cssStyleSheet.media) : undefined,\n        };\n        return styleSheet;\n    });\n}\n//# sourceMappingURL=serializationUtils.js.map","import { assign, startsWith } from '@datadog/browser-core';\nimport { isNodeShadowHost, isNodeShadowRoot, STABLE_ATTRIBUTES } from '@datadog/browser-rum-core';\nimport { NodePrivacyLevel, PRIVACY_ATTR_NAME, PRIVACY_ATTR_VALUE_HIDDEN, CENSORED_STRING_MARK, CENSORED_IMG_MARK, } from '../../constants';\nimport { NodeType } from '../../types';\nimport { getTextContent, shouldMaskNode, reducePrivacyLevel, getNodeSelfPrivacyLevel, MAX_ATTRIBUTE_VALUE_CHAR_LENGTH, } from './privacy';\nimport { getSerializedNodeId, setSerializedNodeId, getElementInputValue, switchToAbsoluteUrl, serializeStyleSheets, } from './serializationUtils';\nexport function serializeDocument(document, configuration, serializationContext) {\n    // We are sure that Documents are never ignored, so this function never returns null\n    return serializeNodeWithId(document, {\n        serializationContext: serializationContext,\n        parentNodePrivacyLevel: configuration.defaultPrivacyLevel,\n        configuration: configuration,\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_FRAGMENT_NODE:\n            return serializeDocumentFragmentNode(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: NodeType.Document,\n        childNodes: serializeChildNodes(document, options),\n        adoptedStyleSheets: serializeStyleSheets(document.adoptedStyleSheets),\n    };\n}\nfunction serializeDocumentTypeNode(documentType) {\n    return {\n        type: NodeType.DocumentType,\n        name: documentType.name,\n        publicId: documentType.publicId,\n        systemId: documentType.systemId,\n    };\n}\nfunction serializeDocumentFragmentNode(element, options) {\n    var childNodes = [];\n    if (element.childNodes.length) {\n        childNodes = serializeChildNodes(element, options);\n    }\n    var isShadowRoot = isNodeShadowRoot(element);\n    if (isShadowRoot) {\n        options.serializationContext.shadowRootsController.addShadowRoot(element);\n    }\n    return {\n        type: NodeType.DocumentFragment,\n        childNodes: childNodes,\n        isShadowRoot: isShadowRoot,\n        adoptedStyleSheets: isShadowRoot\n            ? serializeStyleSheets(element.adoptedStyleSheets)\n            : undefined,\n    };\n}\n/**\n * Serializing Element nodes involves capturing:\n * 1. HTML ATTRIBUTES:\n * 2. JS STATE:\n * - scroll offsets\n * - Form fields (input value, checkbox checked, option 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: NodeType.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, options);\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    if (isNodeShadowHost(element)) {\n        var shadowRoot = serializeNodeWithId(element.shadowRoot, options);\n        if (shadowRoot !== null) {\n            childNodes.push(shadowRoot);\n        }\n    }\n    return {\n        type: NodeType.Element,\n        tagName: tagName,\n        attributes: attributes,\n        childNodes: childNodes,\n        isSVG: isSVG,\n    };\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: NodeType.Text,\n        textContent: textContent,\n        isStyle: parentTagName === 'STYLE' ? true : undefined,\n    };\n}\nfunction serializeCDataNode() {\n    return {\n        type: NodeType.CDATA,\n        textContent: '',\n    };\n}\nexport function serializeChildNodes(node, options) {\n    var result = [];\n    node.childNodes.forEach(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, configuration) {\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        attributeName !== PRIVACY_ATTR_NAME &&\n        !STABLE_ATTRIBUTES.includes(attributeName) &&\n        attributeName !== configuration.actionNameAttribute) {\n        var tagName = element.tagName;\n        switch (attributeName) {\n            // Mask Attribute text content\n            case 'title':\n            case 'alt':\n            case 'placeholder':\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 && startsWith(attributeName, 'data-')) {\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        if (rules) {\n            var styleSheetCssText = Array.from(rules, getCssRuleString).join('');\n            return switchToAbsoluteUrl(styleSheetCssText, s.href);\n        }\n        return 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, options) {\n    var _a;\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, options.configuration);\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            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 only for full snapshot\n     */\n    var scrollTop;\n    var scrollLeft;\n    var serializationContext = options.serializationContext;\n    switch (serializationContext.status) {\n        case 0 /* INITIAL_FULL_SNAPSHOT */:\n            scrollTop = Math.round(element.scrollTop);\n            scrollLeft = Math.round(element.scrollLeft);\n            if (scrollTop || scrollLeft) {\n                serializationContext.elementsScrollPositions.set(element, { scrollTop: scrollTop, scrollLeft: scrollLeft });\n            }\n            break;\n        case 1 /* SUBSEQUENT_FULL_SNAPSHOT */:\n            if (serializationContext.elementsScrollPositions.has(element)) {\n                ;\n                (_a = serializationContext.elementsScrollPositions.get(element), scrollTop = _a.scrollTop, scrollLeft = _a.scrollLeft);\n            }\n            break;\n    }\n    if (scrollLeft) {\n        safeAttrs.rr_scrollLeft = scrollLeft;\n    }\n    if (scrollTop) {\n        safeAttrs.rr_scrollTop = scrollTop;\n    }\n    return safeAttrs;\n}\n//# sourceMappingURL=serialize.js.map","import { assign, timeStampNow } from '@datadog/browser-core';\nimport { RecordType } from '../../types';\nexport function isTouchEvent(event) {\n    return Boolean(event.changedTouches);\n}\nexport function forEach(list, callback) {\n    Array.prototype.forEach.call(list, callback);\n}\nexport function assembleIncrementalSnapshot(source, data) {\n    return {\n        data: assign({\n            source: source,\n        }, data),\n        type: RecordType.IncrementalSnapshot,\n        timestamp: timeStampNow(),\n    };\n}\nexport function getPathToNestedCSSRule(rule) {\n    var path = [];\n    var currentRule = rule;\n    while (currentRule.parentRule) {\n        var rules_1 = Array.from(currentRule.parentRule.cssRules);\n        var index_1 = rules_1.indexOf(currentRule);\n        path.unshift(index_1);\n        currentRule = currentRule.parentRule;\n    }\n    // A rule may not be attached to a stylesheet\n    if (!currentRule.parentStyleSheet) {\n        return;\n    }\n    var rules = Array.from(currentRule.parentStyleSheet.cssRules);\n    var index = rules.indexOf(currentRule);\n    path.unshift(index);\n    return path;\n}\n//# sourceMappingURL=utils.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","import { monitor, noop } from '@datadog/browser-core';\nimport { getChildNodes, isNodeShadowHost, getMutationObserverConstructor, getParentNode, } 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 { createMutationBatch } from './mutationBatch';\n/**\n * Buffers and aggregate mutations generated by a MutationObserver into MutationPayload\n */\nexport function startMutationObserver(mutationCallback, configuration, shadowRootsController, target) {\n    var MutationObserver = getMutationObserverConstructor();\n    if (!MutationObserver) {\n        return { stop: noop, flush: noop };\n    }\n    var mutationBatch = createMutationBatch(function (mutations) {\n        processMutations(mutations.concat(observer.takeRecords()), mutationCallback, configuration, shadowRootsController, target);\n    });\n    var observer = new MutationObserver(monitor(mutationBatch.addMutations));\n    observer.observe(target, {\n        attributeOldValue: true,\n        attributes: true,\n        characterData: true,\n        characterDataOldValue: true,\n        childList: true,\n        subtree: true,\n    });\n    return {\n        stop: function () {\n            observer.disconnect();\n            mutationBatch.stop();\n        },\n        flush: function () {\n            mutationBatch.flush();\n        },\n    };\n}\nfunction processMutations(mutations, mutationCallback, configuration, shadowRootsController, target) {\n    mutations\n        .filter(function (mutation) { return mutation.type === 'childList'; })\n        .forEach(function (mutation) {\n        mutation.removedNodes.forEach(function (removedNode) {\n            traverseRemovedShadowDom(removedNode, shadowRootsController.removeShadowRoot);\n        });\n    });\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 target.contains(mutation.target) &&\n            nodeAndAncestorsHaveSerializedNode(mutation.target) &&\n            getNodePrivacyLevel(mutation.target, configuration.defaultPrivacyLevel) !== NodePrivacyLevel.HIDDEN;\n    });\n    var _a = processChildListMutations(filteredMutations.filter(function (mutation) { return mutation.type === 'childList'; }), configuration, shadowRootsController), 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    }), configuration);\n    var attributes = processAttributesMutations(filteredMutations.filter(function (mutation) {\n        return mutation.type === 'attributes' && !hasBeenSerialized(mutation.target);\n    }), configuration);\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, configuration, shadowRootsController) {\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        mutation.addedNodes.forEach(function (node) {\n            addedAndMovedNodes.add(node);\n        });\n        mutation.removedNodes.forEach(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, configuration.defaultPrivacyLevel);\n        if (parentNodePrivacyLevel === NodePrivacyLevel.HIDDEN || parentNodePrivacyLevel === NodePrivacyLevel.IGNORE) {\n            continue;\n        }\n        var serializedNode = serializeNodeWithId(node, {\n            serializedNodeIds: serializedNodeIds,\n            parentNodePrivacyLevel: parentNodePrivacyLevel,\n            serializationContext: { status: 2 /* MUTATION */, shadowRootsController: shadowRootsController },\n            configuration: configuration,\n        });\n        if (!serializedNode) {\n            continue;\n        }\n        var parentNode = getParentNode(node);\n        addedNodeMutations.push({\n            nextId: getNextSibling(node),\n            parentId: getSerializedNodeId(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, configuration) {\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(getParentNode(mutation.target), configuration.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, configuration) {\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, configuration.defaultPrivacyLevel);\n        var attributeValue = serializeAttribute(mutation.target, privacyLevel, mutation.attributeName, configuration);\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}\nfunction traverseRemovedShadowDom(removedNode, shadowDomRemovedCallback) {\n    if (isNodeShadowHost(removedNode)) {\n        shadowDomRemovedCallback(removedNode.shadowRoot);\n    }\n    getChildNodes(removedNode).forEach(function (child) { return traverseRemovedShadowDom(child, shadowDomRemovedCallback); });\n}\n//# sourceMappingURL=mutationObserver.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};\nexport function getScrollX() {\n    var scrollX;\n    var visual = window.visualViewport;\n    if (visual) {\n        scrollX = visual.pageLeft - visual.offsetLeft;\n    }\n    else if (window.scrollX !== undefined) {\n        scrollX = window.scrollX;\n    }\n    else {\n        scrollX = window.pageXOffset || 0;\n    }\n    return Math.round(scrollX);\n}\nexport function getScrollY() {\n    var scrollY;\n    var visual = window.visualViewport;\n    if (visual) {\n        scrollY = visual.pageTop - visual.offsetTop;\n    }\n    else if (window.scrollY !== undefined) {\n        scrollY = window.scrollY;\n    }\n    else {\n        scrollY = window.pageYOffset || 0;\n    }\n    return Math.round(scrollY);\n}\n//# sourceMappingURL=viewports.js.map","var _a;\nimport { instrumentSetter, instrumentMethodAndCallOriginal, assign, monitor, throttle, addEventListeners, addEventListener, noop, addTelemetryDebug, } from '@datadog/browser-core';\nimport { isNodeShadowHost, initViewportObservable, } from '@datadog/browser-rum-core';\nimport { NodePrivacyLevel } from '../../constants';\nimport { RecordType, IncrementalSource, MediaInteractionType, MouseInteractionType } from '../../types';\nimport { getNodePrivacyLevel, shouldMaskNode } from './privacy';\nimport { getElementInputValue, getSerializedNodeId, hasSerializedNode } from './serializationUtils';\nimport { assembleIncrementalSnapshot, forEach, getPathToNestedCSSRule, isTouchEvent } from './utils';\nimport { startMutationObserver } from './mutationObserver';\nimport { getVisualViewport, getScrollX, getScrollY, convertMouseEventToLayoutCoordinates } from './viewports';\nvar MOUSE_MOVE_OBSERVER_THRESHOLD = 50;\nvar SCROLL_OBSERVER_THRESHOLD = 100;\nvar VISUAL_VIEWPORT_OBSERVER_THRESHOLD = 200;\nvar recordIds = new WeakMap();\nvar nextId = 1;\nexport function getRecordIdForEvent(event) {\n    if (!recordIds.has(event)) {\n        recordIds.set(event, nextId++);\n    }\n    return recordIds.get(event);\n}\nexport function initObservers(o) {\n    var mutationHandler = initMutationObserver(o.mutationCb, o.configuration, o.shadowRootsController);\n    var mousemoveHandler = initMoveObserver(o.mousemoveCb);\n    var mouseInteractionHandler = initMouseInteractionObserver(o.mouseInteractionCb, o.configuration.defaultPrivacyLevel);\n    var scrollHandler = initScrollObserver(o.scrollCb, o.configuration.defaultPrivacyLevel, o.elementsScrollPositions);\n    var viewportResizeHandler = initViewportResizeObserver(o.viewportResizeCb);\n    var inputHandler = initInputObserver(o.inputCb, o.configuration.defaultPrivacyLevel);\n    var mediaInteractionHandler = initMediaInteractionObserver(o.mediaInteractionCb, o.configuration.defaultPrivacyLevel);\n    var styleSheetObserver = initStyleSheetObserver(o.styleSheetCb);\n    var focusHandler = initFocusObserver(o.focusCb);\n    var visualViewportResizeHandler = initVisualViewportResizeObserver(o.visualViewportResizeCb);\n    var frustrationHandler = initFrustrationObserver(o.lifeCycle, o.frustrationCb);\n    return {\n        flush: function () {\n            mutationHandler.flush();\n        },\n        stop: function () {\n            mutationHandler.stop();\n            mousemoveHandler();\n            mouseInteractionHandler();\n            scrollHandler();\n            viewportResizeHandler();\n            inputHandler();\n            mediaInteractionHandler();\n            styleSheetObserver();\n            focusHandler();\n            visualViewportResizeHandler();\n            frustrationHandler();\n        },\n    };\n}\nexport function initMutationObserver(cb, configuration, shadowRootsController) {\n    return startMutationObserver(cb, configuration, shadowRootsController, document);\n}\nexport function initMoveObserver(cb) {\n    var updatePosition = throttle(monitor(function (event) {\n        var target = getEventTarget(event);\n        if (hasSerializedNode(target)) {\n            var coordinates = tryToComputeCoordinates(event);\n            if (!coordinates) {\n                return;\n            }\n            var position = {\n                id: getSerializedNodeId(target),\n                timeOffset: 0,\n                x: coordinates.x,\n                y: coordinates.y,\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    // Listen for pointerup DOM events instead of mouseup for MouseInteraction/MouseUp records. This\n    // allows to reference such records from Frustration records.\n    //\n    // In the context of supporting Mobile Session Replay, we introduced `PointerInteraction` records\n    // used by the Mobile SDKs in place of `MouseInteraction`. In the future, we should replace\n    // `MouseInteraction` by `PointerInteraction` in the Browser SDK so we have an uniform way to\n    // convey such interaction. This would cleanly solve the issue since we would have\n    // `PointerInteraction/Up` records that we could reference from `Frustration` records.\n    _a[\"pointerup\" /* POINTER_UP */] = MouseInteractionType.MouseUp,\n    _a[\"mousedown\" /* MOUSE_DOWN */] = MouseInteractionType.MouseDown,\n    _a[\"click\" /* CLICK */] = MouseInteractionType.Click,\n    _a[\"contextmenu\" /* CONTEXT_MENU */] = MouseInteractionType.ContextMenu,\n    _a[\"dblclick\" /* DBL_CLICK */] = MouseInteractionType.DblClick,\n    _a[\"focus\" /* FOCUS */] = MouseInteractionType.Focus,\n    _a[\"blur\" /* BLUR */] = MouseInteractionType.Blur,\n    _a[\"touchstart\" /* TOUCH_START */] = MouseInteractionType.TouchStart,\n    _a[\"touchend\" /* TOUCH_END */] = MouseInteractionType.TouchEnd,\n    _a);\nexport function initMouseInteractionObserver(cb, defaultPrivacyLevel) {\n    var handler = function (event) {\n        var target = getEventTarget(event);\n        if (getNodePrivacyLevel(target, defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN || !hasSerializedNode(target)) {\n            return;\n        }\n        var id = getSerializedNodeId(target);\n        var type = eventTypeToMouseInteraction[event.type];\n        var interaction;\n        if (type !== MouseInteractionType.Blur && type !== MouseInteractionType.Focus) {\n            var coordinates = tryToComputeCoordinates(event);\n            if (!coordinates) {\n                return;\n            }\n            interaction = { id: id, type: type, x: coordinates.x, y: coordinates.y };\n        }\n        else {\n            interaction = { id: id, type: type };\n        }\n        var record = assign({ id: getRecordIdForEvent(event) }, assembleIncrementalSnapshot(IncrementalSource.MouseInteraction, interaction));\n        cb(record);\n    };\n    return addEventListeners(document, Object.keys(eventTypeToMouseInteraction), handler, {\n        capture: true,\n        passive: true,\n    }).stop;\n}\nfunction tryToComputeCoordinates(event) {\n    var _a = isTouchEvent(event) ? event.changedTouches[0] : event, x = _a.clientX, y = _a.clientY;\n    if (window.visualViewport) {\n        var _b = convertMouseEventToLayoutCoordinates(x, y), visualViewportX = _b.visualViewportX, visualViewportY = _b.visualViewportY;\n        x = visualViewportX;\n        y = visualViewportY;\n    }\n    if (!Number.isFinite(x) || !Number.isFinite(y)) {\n        if (event.isTrusted) {\n            addTelemetryDebug('mouse/touch event without x/y');\n        }\n        return undefined;\n    }\n    return { x: x, y: y };\n}\nfunction initScrollObserver(cb, defaultPrivacyLevel, elementsScrollPositions) {\n    var updatePosition = throttle(monitor(function (event) {\n        var target = getEventTarget(event);\n        if (!target ||\n            getNodePrivacyLevel(target, defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN ||\n            !hasSerializedNode(target)) {\n            return;\n        }\n        var id = getSerializedNodeId(target);\n        var scrollPositions = target === document\n            ? {\n                scrollTop: getScrollY(),\n                scrollLeft: getScrollX(),\n            }\n            : {\n                scrollTop: Math.round(target.scrollTop),\n                scrollLeft: Math.round(target.scrollLeft),\n            };\n        elementsScrollPositions.set(target, scrollPositions);\n        cb({\n            id: id,\n            x: scrollPositions.scrollLeft,\n            y: scrollPositions.scrollTop,\n        });\n    }), SCROLL_OBSERVER_THRESHOLD).throttled;\n    return addEventListener(document, \"scroll\" /* SCROLL */, updatePosition, { capture: true, passive: true }).stop;\n}\nfunction initViewportResizeObserver(cb) {\n    return initViewportObservable().subscribe(cb).unsubscribe;\n}\nexport function initInputObserver(cb, defaultPrivacyLevel, _a) {\n    var _b = _a === void 0 ? {} : _a, _c = _b.domEvents, domEvents = _c === void 0 ? [\"input\" /* INPUT */, \"change\" /* CHANGE */] : _c, _d = _b.target, target = _d === void 0 ? document : _d;\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(target, domEvents, function (event) {\n        var target = getEventTarget(event);\n        if (target instanceof HTMLInputElement ||\n            target instanceof HTMLTextAreaElement ||\n            target instanceof HTMLSelectElement) {\n            onElementChange(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}\nexport function initStyleSheetObserver(cb) {\n    function checkStyleSheetAndCallback(styleSheet, callback) {\n        if (styleSheet && hasSerializedNode(styleSheet.ownerNode)) {\n            callback(getSerializedNodeId(styleSheet.ownerNode));\n        }\n    }\n    var instrumentationStoppers = [\n        instrumentMethodAndCallOriginal(CSSStyleSheet.prototype, 'insertRule', {\n            before: function (rule, index) {\n                checkStyleSheetAndCallback(this, function (id) { return cb({ id: id, adds: [{ rule: rule, index: index }] }); });\n            },\n        }),\n        instrumentMethodAndCallOriginal(CSSStyleSheet.prototype, 'deleteRule', {\n            before: function (index) {\n                checkStyleSheetAndCallback(this, function (id) { return cb({ id: id, removes: [{ index: index }] }); });\n            },\n        }),\n    ];\n    if (typeof CSSGroupingRule !== 'undefined') {\n        instrumentGroupingCSSRuleClass(CSSGroupingRule);\n    }\n    else {\n        instrumentGroupingCSSRuleClass(CSSMediaRule);\n        instrumentGroupingCSSRuleClass(CSSSupportsRule);\n    }\n    function instrumentGroupingCSSRuleClass(cls) {\n        instrumentationStoppers.push(instrumentMethodAndCallOriginal(cls.prototype, 'insertRule', {\n            before: function (rule, index) {\n                var _this = this;\n                checkStyleSheetAndCallback(this.parentStyleSheet, function (id) {\n                    var path = getPathToNestedCSSRule(_this);\n                    if (path) {\n                        path.push(index || 0);\n                        cb({ id: id, adds: [{ rule: rule, index: path }] });\n                    }\n                });\n            },\n        }), instrumentMethodAndCallOriginal(cls.prototype, 'deleteRule', {\n            before: function (index) {\n                var _this = this;\n                checkStyleSheetAndCallback(this.parentStyleSheet, function (id) {\n                    var path = getPathToNestedCSSRule(_this);\n                    if (path) {\n                        path.push(index);\n                        cb({ id: id, removes: [{ index: path }] });\n                    }\n                });\n            },\n        }));\n    }\n    return function () { return instrumentationStoppers.forEach(function (stopper) { return stopper.stop(); }); };\n}\nfunction initMediaInteractionObserver(mediaInteractionCb, defaultPrivacyLevel) {\n    var handler = function (event) {\n        var target = getEventTarget(event);\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 */ ? MediaInteractionType.Play : MediaInteractionType.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}\nexport function initFrustrationObserver(lifeCycle, frustrationCb) {\n    return lifeCycle.subscribe(10 /* RAW_RUM_EVENT_COLLECTED */, function (data) {\n        var _a, _b, _c;\n        if (data.rawRumEvent.type === \"action\" /* ACTION */ &&\n            data.rawRumEvent.action.type === \"click\" /* CLICK */ &&\n            ((_b = (_a = data.rawRumEvent.action.frustration) === null || _a === void 0 ? void 0 : _a.type) === null || _b === void 0 ? void 0 : _b.length) &&\n            'events' in data.domainContext &&\n            ((_c = data.domainContext.events) === null || _c === void 0 ? void 0 : _c.length)) {\n            frustrationCb({\n                timestamp: data.rawRumEvent.date,\n                type: RecordType.FrustrationRecord,\n                data: {\n                    frustrationTypes: data.rawRumEvent.action.frustration.type,\n                    recordIds: data.domainContext.events.map(function (e) { return getRecordIdForEvent(e); }),\n                },\n            });\n        }\n    }).unsubscribe;\n}\nfunction getEventTarget(event) {\n    if (event.composed === true && isNodeShadowHost(event.target)) {\n        return event.composedPath()[0];\n    }\n    return event.target;\n}\n//# sourceMappingURL=observers.js.map","import { timeStampNow } from '@datadog/browser-core';\nimport { getViewportDimension } from '@datadog/browser-rum-core';\nimport { RecordType, IncrementalSource } from '../../types';\nimport { serializeDocument } from './serialize';\nimport { initObservers } from './observers';\nimport { getVisualViewport, getScrollX, getScrollY } from './viewports';\nimport { assembleIncrementalSnapshot } from './utils';\nimport { createElementsScrollPositions } from './elementsScrollPositions';\nimport { initShadowRootsController } from './shadowRootsController';\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 elementsScrollPositions = createElementsScrollPositions();\n    var mutationCb = function (mutation) {\n        emit(assembleIncrementalSnapshot(IncrementalSource.Mutation, mutation));\n    };\n    var inputCb = function (s) { return emit(assembleIncrementalSnapshot(IncrementalSource.Input, s)); };\n    var shadowRootsController = initShadowRootsController(options.configuration, { mutationCb: mutationCb, inputCb: inputCb });\n    var takeFullSnapshot = function (timestamp, serializationContext) {\n        if (timestamp === void 0) { timestamp = timeStampNow(); }\n        if (serializationContext === void 0) { serializationContext = {\n            status: 0 /* INITIAL_FULL_SNAPSHOT */,\n            elementsScrollPositions: elementsScrollPositions,\n            shadowRootsController: shadowRootsController,\n        }; }\n        var _a = getViewportDimension(), width = _a.width, height = _a.height;\n        emit({\n            data: {\n                height: height,\n                href: window.location.href,\n                width: width,\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.configuration, serializationContext),\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 _a = initObservers({\n        lifeCycle: options.lifeCycle,\n        configuration: options.configuration,\n        elementsScrollPositions: elementsScrollPositions,\n        inputCb: inputCb,\n        mediaInteractionCb: function (p) {\n            return emit(assembleIncrementalSnapshot(IncrementalSource.MediaInteraction, p));\n        },\n        mouseInteractionCb: function (mouseInteractionRecord) { return emit(mouseInteractionRecord); },\n        mousemoveCb: function (positions, source) { return emit(assembleIncrementalSnapshot(source, { positions: positions })); },\n        mutationCb: mutationCb,\n        scrollCb: function (p) { return emit(assembleIncrementalSnapshot(IncrementalSource.Scroll, p)); },\n        styleSheetCb: function (r) { return emit(assembleIncrementalSnapshot(IncrementalSource.StyleSheetRule, r)); },\n        viewportResizeCb: function (d) { return emit(assembleIncrementalSnapshot(IncrementalSource.ViewportResize, d)); },\n        frustrationCb: function (frustrationRecord) { return emit(frustrationRecord); },\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        shadowRootsController: shadowRootsController,\n    }), stopObservers = _a.stop, flushMutationsFromObservers = _a.flush;\n    function flushMutations() {\n        shadowRootsController.flush();\n        flushMutationsFromObservers();\n    }\n    return {\n        stop: function () {\n            shadowRootsController.stop();\n            stopObservers();\n        },\n        takeSubsequentFullSnapshot: function (timestamp) {\n            flushMutations();\n            takeFullSnapshot(timestamp, {\n                shadowRootsController: shadowRootsController,\n                status: 1 /* SUBSEQUENT_FULL_SNAPSHOT */,\n                elementsScrollPositions: elementsScrollPositions,\n            });\n        },\n        flushMutations: flushMutations,\n        shadowRootsController: shadowRootsController,\n    };\n}\n//# sourceMappingURL=record.js.map","export function createElementsScrollPositions() {\n    var scrollPositionsByElement = new WeakMap();\n    return {\n        set: function (element, scrollPositions) {\n            if (element === document && !document.scrollingElement) {\n                // cf https://drafts.csswg.org/cssom-view/#dom-document-scrollingelement,\n                // in some cases scrolling elements can not be defined, we don't support those for now\n                return;\n            }\n            scrollPositionsByElement.set(element === document ? document.scrollingElement : element, scrollPositions);\n        },\n        get: function (element) {\n            return scrollPositionsByElement.get(element);\n        },\n        has: function (element) {\n            return scrollPositionsByElement.has(element);\n        },\n    };\n}\n//# sourceMappingURL=elementsScrollPositions.js.map","import { addTelemetryDebug, isExperimentalFeatureEnabled } from '@datadog/browser-core';\nimport { startMutationObserver } from './mutationObserver';\nimport { initInputObserver } from './observers';\nexport var initShadowRootsController = function (configuration, _a) {\n    var mutationCb = _a.mutationCb, inputCb = _a.inputCb;\n    var controllerByShadowRoot = new Map();\n    var shadowRootsController = {\n        addShadowRoot: function (shadowRoot) {\n            var _a = startMutationObserver(mutationCb, configuration, shadowRootsController, shadowRoot), stopMutationObserver = _a.stop, flush = _a.flush;\n            // the change event no do bubble up across the shadow root, we have to listen on the shadow root\n            var stopInputObserver = initInputObserver(inputCb, configuration.defaultPrivacyLevel, {\n                target: shadowRoot,\n                domEvents: [\"change\" /* CHANGE */],\n            });\n            controllerByShadowRoot.set(shadowRoot, {\n                flush: flush,\n                stop: function () {\n                    stopMutationObserver();\n                    stopInputObserver();\n                },\n            });\n        },\n        removeShadowRoot: function (shadowRoot) {\n            var entry = controllerByShadowRoot.get(shadowRoot);\n            if (!entry) {\n                addTelemetryDebug('no shadow root in map', {\n                    shadowRoot: shadowRoot ? shadowRoot.nodeName : 'no node name',\n                    childrenLength: shadowRoot ? shadowRoot.childElementCount : '-1',\n                    controllerByShadowRootSize: controllerByShadowRoot.size,\n                    html: shadowRoot && isExperimentalFeatureEnabled('shadow_dom_debug')\n                        ? shadowRoot.innerHTML.substring(0, 2000)\n                        : undefined,\n                });\n                return;\n            }\n            entry.stop();\n            controllerByShadowRoot.delete(shadowRoot);\n        },\n        stop: function () {\n            controllerByShadowRoot.forEach(function (_a) {\n                var stop = _a.stop;\n                return stop();\n            });\n        },\n        flush: function () {\n            controllerByShadowRoot.forEach(function (_a) {\n                var flush = _a.flush;\n                return flush();\n            });\n        },\n    };\n    return shadowRootsController;\n};\n//# sourceMappingURL=shadowRootsController.js.map","import { objectEntries } from '@datadog/browser-core';\nexport function buildReplayPayload(data, metadata, rawSegmentBytesCount) {\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', rawSegmentBytesCount.toString());\n    return { data: formData, bytesCount: data.byteLength };\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=buildReplayPayload.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, additionalBytesCount) {\n    getOrCreateReplayStats(viewId).segments_total_raw_size += additionalBytesCount;\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 { addTelemetryDebug, assign, monitor, sendToExtension } 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.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            source: 'browser',\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.additionalBytesCount);\n                if (data.type === 'flushed') {\n                    onFlushed(data.result, data.rawBytesCount);\n                    worker.removeEventListener('message', listener);\n                }\n                else {\n                    onWrote(data.compressedBytesCount);\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                addTelemetryDebug(\"Segment did not receive a 'flush' response before being replaced.\");\n            }\n        });\n        worker.addEventListener('message', listener);\n        sendToExtension('record', { record: initialRecord, segment: this.metadata });\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.start = Math.min(this.metadata.start, record.timestamp);\n        this.metadata.end = Math.max(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        sendToExtension('record', { record: record, segment: this.metadata });\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.flushReason = reason;\n    };\n    return Segment;\n}());\nexport { Segment };\n//# sourceMappingURL=segment.js.map","import { ONE_SECOND, monitor } from '@datadog/browser-core';\nimport { buildReplayPayload } from './buildReplayPayload';\nimport { Segment } from './segment';\nexport var SEGMENT_DURATION_LIMIT = 30 * ONE_SECOND;\n/**\n * beacon payload max queue size implementation is 64kb\n * ensure that we leave room for logs, rum and potential other users\n */\nexport var SEGMENT_BYTES_LIMIT = 60000;\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 many 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 bytes count 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, httpRequest, worker) {\n    return doStartSegmentCollection(lifeCycle, function () { return computeSegmentContext(applicationId, sessionManager, viewContexts); }, httpRequest, worker);\n}\nexport function doStartSegmentCollection(lifeCycle, getSegmentContext, httpRequest, worker) {\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 unsubscribePageExited = lifeCycle.subscribe(9 /* PAGE_EXITED */, function (pageExitEvent) {\n        flushSegment(pageExitEvent.reason);\n    }).unsubscribe;\n    function flushSegment(flushReason) {\n        if (state.status === 1 /* SegmentPending */) {\n            state.segment.flush(flushReason);\n            clearTimeout(state.expirationTimeoutId);\n        }\n        if (flushReason !== 'stop') {\n            state = {\n                status: 0 /* WaitingForInitialRecord */,\n                nextSegmentCreationReason: flushReason,\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 (compressedSegmentBytesCount) {\n            if (!segment.flushReason && compressedSegmentBytesCount > SEGMENT_BYTES_LIMIT) {\n                flushSegment('segment_bytes_limit');\n            }\n        }, function (data, rawSegmentBytesCount) {\n            var payload = buildReplayPayload(data, segment.metadata, rawSegmentBytesCount);\n            if (segment.flushReason === 'visibility_hidden' || segment.flushReason === 'before_unload') {\n                httpRequest.sendOnExit(payload);\n            }\n            else {\n                httpRequest.send(payload);\n            }\n        });\n        state = {\n            status: 1 /* SegmentPending */,\n            segment: segment,\n            expirationTimeoutId: setTimeout(monitor(function () {\n                flushSegment('segment_duration_limit');\n            }), SEGMENT_DURATION_LIMIT),\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('stop');\n            unsubscribeViewCreated();\n            unsubscribePageExited();\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.id,\n        },\n    };\n}\nexport function setSegmentBytesLimit(newSegmentBytesLimit) {\n    if (newSegmentBytesLimit === void 0) { newSegmentBytesLimit = 60000; }\n    SEGMENT_BYTES_LIMIT = newSegmentBytesLimit;\n}\n//# sourceMappingURL=segmentCollection.js.map","import { addTelemetryError, 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            addTelemetryError(error);\n        }\n        state.callbacks.forEach(function (callback) { return callback(); });\n        state = { status: 2 /* Error */ };\n    }\n    else {\n        addTelemetryError(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 { 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() || !isBrowserSupported()) {\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.sessionReplayAllowed) {\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/**\n * Test for Browser features used while recording\n */\nfunction isBrowserSupported() {\n    return (\n    // Array.from is a bit less supported by browsers than CSSSupportsRule, but has higher chances\n    // to be polyfilled. Test for both to be more confident. We could add more things if we find out\n    // this test is not sufficient.\n    typeof Array.from === 'function' && typeof CSSSupportsRule === 'function' && 'forEach' in NodeList.prototype);\n}\n//# sourceMappingURL=recorderApi.js.map","import { timeStampNow, createHttpRequest } from '@datadog/browser-core';\nimport { record } from '../domain/record';\nimport { startSegmentCollection, SEGMENT_BYTES_LIMIT } from '../domain/segmentCollection';\nimport { RecordType } from '../types';\nexport function startRecording(lifeCycle, configuration, sessionManager, viewContexts, worker, httpRequest) {\n    var reportError = function (error) {\n        lifeCycle.notify(12 /* RAW_ERROR_COLLECTED */, { error: error });\n    };\n    var replayRequest = httpRequest || createHttpRequest(configuration.sessionReplayEndpointBuilder, SEGMENT_BYTES_LIMIT, reportError);\n    var _a = startSegmentCollection(lifeCycle, configuration.applicationId, sessionManager, viewContexts, replayRequest, worker), addRecord = _a.addRecord, stopSegmentCollection = _a.stop;\n    var _b = record({\n        emit: addRecord,\n        configuration: configuration,\n        lifeCycle: lifeCycle,\n    }), stopRecording = _b.stop, takeSubsequentFullSnapshot = _b.takeSubsequentFullSnapshot, 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        takeSubsequentFullSnapshot(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 { isExperimentalFeatureEnabled, willSyntheticsInjectRum, assign, BoundedBuffer, buildCookieOptions, createContextManager, deepClone, makePublicApi, monitor, clocksNow, timeStampNow, display, callMonitored, createHandlingStack, canUseEventBridge, areCookiesAuthorized, checkUser, sanitizeUser, } from '@datadog/browser-core';\nimport { validateAndBuildRumConfiguration } from '../domain/configuration';\nimport { buildCommonContext } from '../domain/contexts/commonContext';\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 userContextManager = createContextManager();\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 = buildCommonContext(globalContextManager, userContextManager, recorderApi); }\n        bufferApiCalls.add(function () { return addActionStrategy(action, commonContext); });\n    };\n    var addErrorStrategy = function (providedError, commonContext) {\n        if (commonContext === void 0) { commonContext = buildCommonContext(globalContextManager, userContextManager, recorderApi); }\n        bufferApiCalls.add(function () { return addErrorStrategy(providedError, commonContext); });\n    };\n    var addFeatureFlagEvaluationStrategy = function (key, value) {\n        bufferApiCalls.add(function () { return addFeatureFlagEvaluationStrategy(key, value); });\n    };\n    function initRum(initConfiguration) {\n        // This function should be available, regardless of initialization success.\n        getInitConfigurationStrategy = function () { return deepClone(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 (isExperimentalFeatureEnabled('feature_flags')) {\n            ;\n            rumPublicApi.addFeatureFlagEvaluation = monitor(function (key, value) {\n                addFeatureFlagEvaluationStrategy(key, value);\n            });\n        }\n        if (!configuration.trackViewsManually) {\n            doStartRum(initConfiguration, 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(initConfiguration, configuration, options);\n            };\n            beforeInitCalls.drain();\n        }\n        isAlreadyInitialized = true;\n    }\n    function doStartRum(initConfiguration, configuration, initialViewOptions) {\n        var startRumResults = startRumImpl(initConfiguration, configuration, recorderApi, globalContextManager, userContextManager, initialViewOptions);\n        (startViewStrategy = startRumResults.startView, addActionStrategy = startRumResults.addAction, addErrorStrategy = startRumResults.addError, addTimingStrategy = startRumResults.addTiming, addFeatureFlagEvaluationStrategy = startRumResults.addFeatureFlagEvaluation, 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        /** @deprecated: use setGlobalContextProperty instead */\n        addRumGlobalContext: monitor(globalContextManager.add),\n        setGlobalContextProperty: monitor(globalContextManager.setContextProperty),\n        /** @deprecated: use removeGlobalContextProperty instead */\n        removeRumGlobalContext: monitor(globalContextManager.remove),\n        removeGlobalContextProperty: monitor(globalContextManager.removeContextProperty),\n        /** @deprecated: use getGlobalContext instead */\n        getRumGlobalContext: monitor(globalContextManager.get),\n        getGlobalContext: monitor(globalContextManager.getContext),\n        /** @deprecated: use setGlobalContext instead */\n        setRumGlobalContext: monitor(globalContextManager.set),\n        setGlobalContext: monitor(globalContextManager.setContext),\n        clearGlobalContext: monitor(globalContextManager.clearContext),\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            if (checkUser(newUser)) {\n                userContextManager.setContext(sanitizeUser(newUser));\n            }\n        }),\n        getUser: monitor(userContextManager.getContext),\n        setUserProperty: monitor(function (key, property) {\n            var _a;\n            var sanitizedProperty = sanitizeUser((_a = {}, _a[key] = property, _a))[key];\n            userContextManager.setContextProperty(key, sanitizedProperty);\n        }),\n        removeUserProperty: monitor(userContextManager.removeContextProperty),\n        /** @deprecated: renamed to clearUser */\n        removeUser: monitor(userContextManager.clearContext),\n        clearUser: monitor(userContextManager.clearContext),\n        startView: startView,\n        startSessionReplayRecording: monitor(recorderApi.start),\n        stopSessionReplayRecording: monitor(recorderApi.stop),\n    });\n    return rumPublicApi;\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            sessionSampleRate: 100,\n        });\n    }\n    function isLocalFile() {\n        return window.location.protocol === 'file:';\n    }\n}\n//# sourceMappingURL=rumPublicApi.js.map","import { catchUserErrors } from '../tools/catchUserErrors';\nimport { setDebugMode } from '../tools/monitor';\nimport { assign } from '../tools/utils';\nexport function makePublicApi(stub) {\n    var publicApi = assign({\n        version: \"4.34.0\",\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 { sendToExtension, createPageExitObservable, addTelemetryConfiguration, startTelemetry, canUseEventBridge, getEventBridge, } from '@datadog/browser-core';\nimport { createDOMMutationObservable } from '../browser/domMutationObservable';\nimport { startPerformanceCollection } from '../browser/performanceCollection';\nimport { startRumAssembly } from '../domain/assembly';\nimport { startForegroundContexts } from '../domain/contexts/foregroundContexts';\nimport { startInternalContext } from '../domain/contexts/internalContext';\nimport { LifeCycle } from '../domain/lifeCycle';\nimport { startViewContexts } from '../domain/contexts/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/contexts/urlContexts';\nimport { createLocationChangeObservable } from '../browser/locationChangeObservable';\nimport { serializeRumConfiguration } from '../domain/configuration';\nimport { startFeatureFlagContexts } from '../domain/contexts/featureFlagContext';\nimport { startCustomerDataTelemetry } from '../domain/startCustomerDataTelemetry';\nimport { startPageStateHistory } from '../domain/contexts/pageStateHistory';\nimport { buildCommonContext } from '../domain/contexts/commonContext';\nexport function startRum(initConfiguration, configuration, recorderApi, globalContextManager, userContextManager, initialViewOptions) {\n    var lifeCycle = new LifeCycle();\n    lifeCycle.subscribe(11 /* RUM_EVENT_COLLECTED */, function (event) { return sendToExtension('rum', event); });\n    var telemetry = startRumTelemetry(configuration);\n    telemetry.setContextProvider(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.id,\n            },\n            action: {\n                id: actionContexts.findActionId(),\n            },\n        });\n    });\n    var reportError = function (error) {\n        lifeCycle.notify(12 /* RAW_ERROR_COLLECTED */, { error: error });\n    };\n    var featureFlagContexts = startFeatureFlagContexts(lifeCycle);\n    if (!canUseEventBridge()) {\n        var pageExitObservable = createPageExitObservable();\n        pageExitObservable.subscribe(function (event) {\n            lifeCycle.notify(9 /* PAGE_EXITED */, event);\n        });\n        var batch = startRumBatch(configuration, lifeCycle, telemetry.observable, reportError, pageExitObservable);\n        startCustomerDataTelemetry(configuration, telemetry, lifeCycle, globalContextManager, userContextManager, featureFlagContexts, batch.flushObservable);\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, function () { return buildCommonContext(globalContextManager, userContextManager, recorderApi); }, reportError), viewContexts = _a.viewContexts, foregroundContexts = _a.foregroundContexts, urlContexts = _a.urlContexts, actionContexts = _a.actionContexts, addAction = _a.addAction;\n    addTelemetryConfiguration(serializeRumConfiguration(initConfiguration));\n    startLongTaskCollection(lifeCycle, session);\n    var pageStateHistory = startPageStateHistory();\n    startResourceCollection(lifeCycle, configuration, session, pageStateHistory);\n    var _b = startViewCollection(lifeCycle, configuration, location, domMutationObservable, locationChangeObservable, foregroundContexts, featureFlagContexts, recorderApi, initialViewOptions), addTiming = _b.addTiming, startView = _b.startView;\n    var addError = startErrorCollection(lifeCycle, foregroundContexts, featureFlagContexts).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        addFeatureFlagEvaluation: featureFlagContexts.addFeatureFlagEvaluation,\n        startView: startView,\n        lifeCycle: lifeCycle,\n        viewContexts: viewContexts,\n        session: session,\n        getInternalContext: internalContext.get,\n    };\n}\nfunction startRumTelemetry(configuration) {\n    var telemetry = startTelemetry(\"browser-rum-sdk\" /* RUM */, configuration);\n    if (canUseEventBridge()) {\n        var bridge_1 = getEventBridge();\n        telemetry.observable.subscribe(function (event) { return bridge_1.send('internal_telemetry', event); });\n    }\n    return telemetry;\n}\nexport function startRumEventCollection(lifeCycle, configuration, location, sessionManager, locationChangeObservable, domMutationObservable, buildCommonContext, reportError) {\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, buildCommonContext, reportError);\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 { jsonStringify, computeBytesCount, deepClone, noop, isExperimentalFeatureEnabled, SESSION_TIME_OUT_DELAY, ContextHistory, } from '@datadog/browser-core';\nexport var FEATURE_FLAG_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY;\n/**\n * Start feature flag contexts\n *\n * Feature flag contexts follow the life of views.\n * A new context is added when a view is created and ended when the view is ended\n *\n * Note: we choose not to add a new context at each evaluation to save memory\n */\nexport function startFeatureFlagContexts(lifeCycle, computeBytesCountImpl) {\n    if (computeBytesCountImpl === void 0) { computeBytesCountImpl = computeBytesCount; }\n    if (!isExperimentalFeatureEnabled('feature_flags')) {\n        return {\n            findFeatureFlagEvaluations: function () { return undefined; },\n            getFeatureFlagBytesCount: function () { return 0; },\n            addFeatureFlagEvaluation: noop,\n        };\n    }\n    var featureFlagContexts = new ContextHistory(FEATURE_FLAG_CONTEXT_TIME_OUT_DELAY);\n    var bytesCountCache;\n    lifeCycle.subscribe(4 /* VIEW_ENDED */, function (_a) {\n        var endClocks = _a.endClocks;\n        featureFlagContexts.closeActive(endClocks.relative);\n    });\n    lifeCycle.subscribe(2 /* VIEW_CREATED */, function (_a) {\n        var startClocks = _a.startClocks;\n        featureFlagContexts.add({}, startClocks.relative);\n        bytesCountCache = undefined;\n    });\n    return {\n        findFeatureFlagEvaluations: function (startTime) { return featureFlagContexts.find(startTime); },\n        getFeatureFlagBytesCount: function () {\n            var currentContext = featureFlagContexts.find();\n            if (!currentContext) {\n                return 0;\n            }\n            if (bytesCountCache === undefined) {\n                bytesCountCache = computeBytesCountImpl(jsonStringify(currentContext));\n            }\n            return bytesCountCache;\n        },\n        addFeatureFlagEvaluation: function (key, value) {\n            var currentContext = featureFlagContexts.find();\n            if (currentContext) {\n                currentContext[key] = deepClone(value);\n                bytesCountCache = undefined;\n            }\n        },\n    };\n}\n//# sourceMappingURL=featureFlagContext.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 { Observable } from '../tools/observable';\nimport { addEventListener } from './addEventListener';\nexport function createPageExitObservable() {\n    var observable = new Observable(function () {\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        var stopVisibilityChangeListener = addEventListener(document, \"visibilitychange\" /* VISIBILITY_CHANGE */, function () {\n            if (document.visibilityState === 'hidden') {\n                observable.notify({ reason: \"visibility_hidden\" /* HIDDEN */ });\n            }\n        }, { capture: true }).stop;\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        var stopBeforeUnloadListener = addEventListener(window, \"beforeunload\" /* BEFORE_UNLOAD */, function () {\n            observable.notify({ reason: \"before_unload\" /* UNLOADING */ });\n        }).stop;\n        return function () {\n            stopVisibilityChangeListener();\n            stopBeforeUnloadListener();\n        };\n    });\n    return observable;\n}\n//# sourceMappingURL=pageExitObservable.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            id: view.id,\n            name: view.name,\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.referrer,\n            }), changeTime);\n        }\n    });\n    function buildUrlContext(_a) {\n        var url = _a.url, referrer = _a.referrer;\n        return {\n            url: url,\n            referrer: referrer,\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.longTaskAllowed) {\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                _dd: {\n                    discarded: false,\n                },\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","/**\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: { id: viewContext.id, name: viewContext.name, referrer: urlContext.referrer, url: urlContext.url },\n                };\n            }\n        },\n    };\n}\n//# sourceMappingURL=internalContext.js.map","/* global Map:readonly, Set:readonly, ArrayBuffer:readonly */\n\nvar hasElementType = typeof Element !== 'undefined';\nvar hasMap = typeof Map === 'function';\nvar hasSet = typeof Set === 'function';\nvar hasArrayBuffer = typeof ArrayBuffer === 'function' && !!ArrayBuffer.isView;\n\n// Note: We **don't** need `envHasBigInt64Array` in fde es6/index.js\n\nfunction equal(a, b) {\n  // START: fast-deep-equal es6/index.js 3.1.1\n  if (a === b) return true;\n\n  if (a && b && typeof a == 'object' && typeof b == 'object') {\n    if (a.constructor !== b.constructor) return false;\n\n    var length, i, keys;\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0;)\n        if (!equal(a[i], b[i])) return false;\n      return true;\n    }\n\n    // START: Modifications:\n    // 1. Extra `has<Type> &&` helpers in initial condition allow es6 code\n    //    to co-exist with es5.\n    // 2. Replace `for of` with es5 compliant iteration using `for`.\n    //    Basically, take:\n    //\n    //    ```js\n    //    for (i of a.entries())\n    //      if (!b.has(i[0])) return false;\n    //    ```\n    //\n    //    ... and convert to:\n    //\n    //    ```js\n    //    it = a.entries();\n    //    while (!(i = it.next()).done)\n    //      if (!b.has(i.value[0])) return false;\n    //    ```\n    //\n    //    **Note**: `i` access switches to `i.value`.\n    var it;\n    if (hasMap && (a instanceof Map) && (b instanceof Map)) {\n      if (a.size !== b.size) return false;\n      it = a.entries();\n      while (!(i = it.next()).done)\n        if (!b.has(i.value[0])) return false;\n      it = a.entries();\n      while (!(i = it.next()).done)\n        if (!equal(i.value[1], b.get(i.value[0]))) return false;\n      return true;\n    }\n\n    if (hasSet && (a instanceof Set) && (b instanceof Set)) {\n      if (a.size !== b.size) return false;\n      it = a.entries();\n      while (!(i = it.next()).done)\n        if (!b.has(i.value[0])) return false;\n      return true;\n    }\n    // END: Modifications\n\n    if (hasArrayBuffer && ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0;)\n        if (a[i] !== b[i]) return false;\n      return true;\n    }\n\n    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;\n    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();\n    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();\n\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) return false;\n\n    for (i = length; i-- !== 0;)\n      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;\n    // END: fast-deep-equal\n\n    // START: react-fast-compare\n    // custom handling for DOM elements\n    if (hasElementType && a instanceof Element) return false;\n\n    // custom handling for React/Preact\n    for (i = length; i-- !== 0;) {\n      if ((keys[i] === '_owner' || keys[i] === '__v' || keys[i] === '__o') && a.$$typeof) {\n        // React-specific: avoid traversing React elements' _owner\n        // Preact-specific: avoid traversing Preact elements' __v and __o\n        //    __v = $_original / $_vnode\n        //    __o = $_owner\n        // These properties contain circular references and are not needed when\n        // comparing the actual elements (and not their owners)\n        // .$$typeof and ._store on just reasonable markers of elements\n\n        continue;\n      }\n\n      // all other properties should be traversed as usual\n      if (!equal(a[keys[i]], b[keys[i]])) return false;\n    }\n    // END: react-fast-compare\n\n    // START: fast-deep-equal\n    return true;\n  }\n\n  return a !== a && b !== b;\n}\n// end fast-deep-equal\n\nmodule.exports = function isEqual(a, b) {\n  try {\n    return equal(a, b);\n  } catch (error) {\n    if (((error.message || '').match(/stack|recursion/i))) {\n      // warn on circular references, don't crash\n      // browsers give this different errors name and messages:\n      // chrome/safari: \"RangeError\", \"Maximum call stack size exceeded\"\n      // firefox: \"InternalError\", too much recursion\"\n      // edge: \"Error\", \"Out of stack space\"\n      console.warn('react-fast-compare cannot handle circular refs');\n      return false;\n    }\n    // some other error. we should definitely know about these\n    throw error;\n  }\n};\n","import PropTypes from 'prop-types';\nimport withSideEffect from 'react-side-effect';\nimport isEqual from 'react-fast-compare';\nimport React from 'react';\nimport objectAssign from 'object-assign';\n\nvar ATTRIBUTE_NAMES = {\n    BODY: \"bodyAttributes\",\n    HTML: \"htmlAttributes\",\n    TITLE: \"titleAttributes\"\n};\n\nvar TAG_NAMES = {\n    BASE: \"base\",\n    BODY: \"body\",\n    HEAD: \"head\",\n    HTML: \"html\",\n    LINK: \"link\",\n    META: \"meta\",\n    NOSCRIPT: \"noscript\",\n    SCRIPT: \"script\",\n    STYLE: \"style\",\n    TITLE: \"title\"\n};\n\nvar VALID_TAG_NAMES = Object.keys(TAG_NAMES).map(function (name) {\n    return TAG_NAMES[name];\n});\n\nvar TAG_PROPERTIES = {\n    CHARSET: \"charset\",\n    CSS_TEXT: \"cssText\",\n    HREF: \"href\",\n    HTTPEQUIV: \"http-equiv\",\n    INNER_HTML: \"innerHTML\",\n    ITEM_PROP: \"itemprop\",\n    NAME: \"name\",\n    PROPERTY: \"property\",\n    REL: \"rel\",\n    SRC: \"src\",\n    TARGET: \"target\"\n};\n\nvar REACT_TAG_MAP = {\n    accesskey: \"accessKey\",\n    charset: \"charSet\",\n    class: \"className\",\n    contenteditable: \"contentEditable\",\n    contextmenu: \"contextMenu\",\n    \"http-equiv\": \"httpEquiv\",\n    itemprop: \"itemProp\",\n    tabindex: \"tabIndex\"\n};\n\nvar HELMET_PROPS = {\n    DEFAULT_TITLE: \"defaultTitle\",\n    DEFER: \"defer\",\n    ENCODE_SPECIAL_CHARACTERS: \"encodeSpecialCharacters\",\n    ON_CHANGE_CLIENT_STATE: \"onChangeClientState\",\n    TITLE_TEMPLATE: \"titleTemplate\"\n};\n\nvar HTML_TAG_MAP = Object.keys(REACT_TAG_MAP).reduce(function (obj, key) {\n    obj[REACT_TAG_MAP[key]] = key;\n    return obj;\n}, {});\n\nvar SELF_CLOSING_TAGS = [TAG_NAMES.NOSCRIPT, TAG_NAMES.SCRIPT, TAG_NAMES.STYLE];\n\nvar HELMET_ATTRIBUTE = \"data-react-helmet\";\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) {\n  return typeof obj;\n} : function (obj) {\n  return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n};\n\nvar classCallCheck = function (instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n};\n\nvar createClass = function () {\n  function defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      Object.defineProperty(target, descriptor.key, descriptor);\n    }\n  }\n\n  return function (Constructor, protoProps, staticProps) {\n    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) defineProperties(Constructor, staticProps);\n    return Constructor;\n  };\n}();\n\nvar _extends = Object.assign || function (target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i];\n\n    for (var key in source) {\n      if (Object.prototype.hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n\n  return target;\n};\n\nvar inherits = function (subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass);\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      enumerable: false,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;\n};\n\nvar objectWithoutProperties = function (obj, keys) {\n  var target = {};\n\n  for (var i in obj) {\n    if (keys.indexOf(i) >= 0) continue;\n    if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;\n    target[i] = obj[i];\n  }\n\n  return target;\n};\n\nvar possibleConstructorReturn = function (self, call) {\n  if (!self) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self;\n};\n\nvar encodeSpecialCharacters = function encodeSpecialCharacters(str) {\n    var encode = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n\n    if (encode === false) {\n        return String(str);\n    }\n\n    return String(str).replace(/&/g, \"&amp;\").replace(/</g, \"&lt;\").replace(/>/g, \"&gt;\").replace(/\"/g, \"&quot;\").replace(/'/g, \"&#x27;\");\n};\n\nvar getTitleFromPropsList = function getTitleFromPropsList(propsList) {\n    var innermostTitle = getInnermostProperty(propsList, TAG_NAMES.TITLE);\n    var innermostTemplate = getInnermostProperty(propsList, HELMET_PROPS.TITLE_TEMPLATE);\n\n    if (innermostTemplate && innermostTitle) {\n        // use function arg to avoid need to escape $ characters\n        return innermostTemplate.replace(/%s/g, function () {\n            return Array.isArray(innermostTitle) ? innermostTitle.join(\"\") : innermostTitle;\n        });\n    }\n\n    var innermostDefaultTitle = getInnermostProperty(propsList, HELMET_PROPS.DEFAULT_TITLE);\n\n    return innermostTitle || innermostDefaultTitle || undefined;\n};\n\nvar getOnChangeClientState = function getOnChangeClientState(propsList) {\n    return getInnermostProperty(propsList, HELMET_PROPS.ON_CHANGE_CLIENT_STATE) || function () {};\n};\n\nvar getAttributesFromPropsList = function getAttributesFromPropsList(tagType, propsList) {\n    return propsList.filter(function (props) {\n        return typeof props[tagType] !== \"undefined\";\n    }).map(function (props) {\n        return props[tagType];\n    }).reduce(function (tagAttrs, current) {\n        return _extends({}, tagAttrs, current);\n    }, {});\n};\n\nvar getBaseTagFromPropsList = function getBaseTagFromPropsList(primaryAttributes, propsList) {\n    return propsList.filter(function (props) {\n        return typeof props[TAG_NAMES.BASE] !== \"undefined\";\n    }).map(function (props) {\n        return props[TAG_NAMES.BASE];\n    }).reverse().reduce(function (innermostBaseTag, tag) {\n        if (!innermostBaseTag.length) {\n            var keys = Object.keys(tag);\n\n            for (var i = 0; i < keys.length; i++) {\n                var attributeKey = keys[i];\n                var lowerCaseAttributeKey = attributeKey.toLowerCase();\n\n                if (primaryAttributes.indexOf(lowerCaseAttributeKey) !== -1 && tag[lowerCaseAttributeKey]) {\n                    return innermostBaseTag.concat(tag);\n                }\n            }\n        }\n\n        return innermostBaseTag;\n    }, []);\n};\n\nvar getTagsFromPropsList = function getTagsFromPropsList(tagName, primaryAttributes, propsList) {\n    // Calculate list of tags, giving priority innermost component (end of the propslist)\n    var approvedSeenTags = {};\n\n    return propsList.filter(function (props) {\n        if (Array.isArray(props[tagName])) {\n            return true;\n        }\n        if (typeof props[tagName] !== \"undefined\") {\n            warn(\"Helmet: \" + tagName + \" should be of type \\\"Array\\\". Instead found type \\\"\" + _typeof(props[tagName]) + \"\\\"\");\n        }\n        return false;\n    }).map(function (props) {\n        return props[tagName];\n    }).reverse().reduce(function (approvedTags, instanceTags) {\n        var instanceSeenTags = {};\n\n        instanceTags.filter(function (tag) {\n            var primaryAttributeKey = void 0;\n            var keys = Object.keys(tag);\n            for (var i = 0; i < keys.length; i++) {\n                var attributeKey = keys[i];\n                var lowerCaseAttributeKey = attributeKey.toLowerCase();\n\n                // Special rule with link tags, since rel and href are both primary tags, rel takes priority\n                if (primaryAttributes.indexOf(lowerCaseAttributeKey) !== -1 && !(primaryAttributeKey === TAG_PROPERTIES.REL && tag[primaryAttributeKey].toLowerCase() === \"canonical\") && !(lowerCaseAttributeKey === TAG_PROPERTIES.REL && tag[lowerCaseAttributeKey].toLowerCase() === \"stylesheet\")) {\n                    primaryAttributeKey = lowerCaseAttributeKey;\n                }\n                // Special case for innerHTML which doesn't work lowercased\n                if (primaryAttributes.indexOf(attributeKey) !== -1 && (attributeKey === TAG_PROPERTIES.INNER_HTML || attributeKey === TAG_PROPERTIES.CSS_TEXT || attributeKey === TAG_PROPERTIES.ITEM_PROP)) {\n                    primaryAttributeKey = attributeKey;\n                }\n            }\n\n            if (!primaryAttributeKey || !tag[primaryAttributeKey]) {\n                return false;\n            }\n\n            var value = tag[primaryAttributeKey].toLowerCase();\n\n            if (!approvedSeenTags[primaryAttributeKey]) {\n                approvedSeenTags[primaryAttributeKey] = {};\n            }\n\n            if (!instanceSeenTags[primaryAttributeKey]) {\n                instanceSeenTags[primaryAttributeKey] = {};\n            }\n\n            if (!approvedSeenTags[primaryAttributeKey][value]) {\n                instanceSeenTags[primaryAttributeKey][value] = true;\n                return true;\n            }\n\n            return false;\n        }).reverse().forEach(function (tag) {\n            return approvedTags.push(tag);\n        });\n\n        // Update seen tags with tags from this instance\n        var keys = Object.keys(instanceSeenTags);\n        for (var i = 0; i < keys.length; i++) {\n            var attributeKey = keys[i];\n            var tagUnion = objectAssign({}, approvedSeenTags[attributeKey], instanceSeenTags[attributeKey]);\n\n            approvedSeenTags[attributeKey] = tagUnion;\n        }\n\n        return approvedTags;\n    }, []).reverse();\n};\n\nvar getInnermostProperty = function getInnermostProperty(propsList, property) {\n    for (var i = propsList.length - 1; i >= 0; i--) {\n        var props = propsList[i];\n\n        if (props.hasOwnProperty(property)) {\n            return props[property];\n        }\n    }\n\n    return null;\n};\n\nvar reducePropsToState = function reducePropsToState(propsList) {\n    return {\n        baseTag: getBaseTagFromPropsList([TAG_PROPERTIES.HREF, TAG_PROPERTIES.TARGET], propsList),\n        bodyAttributes: getAttributesFromPropsList(ATTRIBUTE_NAMES.BODY, propsList),\n        defer: getInnermostProperty(propsList, HELMET_PROPS.DEFER),\n        encode: getInnermostProperty(propsList, HELMET_PROPS.ENCODE_SPECIAL_CHARACTERS),\n        htmlAttributes: getAttributesFromPropsList(ATTRIBUTE_NAMES.HTML, propsList),\n        linkTags: getTagsFromPropsList(TAG_NAMES.LINK, [TAG_PROPERTIES.REL, TAG_PROPERTIES.HREF], propsList),\n        metaTags: getTagsFromPropsList(TAG_NAMES.META, [TAG_PROPERTIES.NAME, TAG_PROPERTIES.CHARSET, TAG_PROPERTIES.HTTPEQUIV, TAG_PROPERTIES.PROPERTY, TAG_PROPERTIES.ITEM_PROP], propsList),\n        noscriptTags: getTagsFromPropsList(TAG_NAMES.NOSCRIPT, [TAG_PROPERTIES.INNER_HTML], propsList),\n        onChangeClientState: getOnChangeClientState(propsList),\n        scriptTags: getTagsFromPropsList(TAG_NAMES.SCRIPT, [TAG_PROPERTIES.SRC, TAG_PROPERTIES.INNER_HTML], propsList),\n        styleTags: getTagsFromPropsList(TAG_NAMES.STYLE, [TAG_PROPERTIES.CSS_TEXT], propsList),\n        title: getTitleFromPropsList(propsList),\n        titleAttributes: getAttributesFromPropsList(ATTRIBUTE_NAMES.TITLE, propsList)\n    };\n};\n\nvar rafPolyfill = function () {\n    var clock = Date.now();\n\n    return function (callback) {\n        var currentTime = Date.now();\n\n        if (currentTime - clock > 16) {\n            clock = currentTime;\n            callback(currentTime);\n        } else {\n            setTimeout(function () {\n                rafPolyfill(callback);\n            }, 0);\n        }\n    };\n}();\n\nvar cafPolyfill = function cafPolyfill(id) {\n    return clearTimeout(id);\n};\n\nvar requestAnimationFrame = typeof window !== \"undefined\" ? window.requestAnimationFrame && window.requestAnimationFrame.bind(window) || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || rafPolyfill : global.requestAnimationFrame || rafPolyfill;\n\nvar cancelAnimationFrame = typeof window !== \"undefined\" ? window.cancelAnimationFrame || window.webkitCancelAnimationFrame || window.mozCancelAnimationFrame || cafPolyfill : global.cancelAnimationFrame || cafPolyfill;\n\nvar warn = function warn(msg) {\n    return console && typeof console.warn === \"function\" && console.warn(msg);\n};\n\nvar _helmetCallback = null;\n\nvar handleClientStateChange = function handleClientStateChange(newState) {\n    if (_helmetCallback) {\n        cancelAnimationFrame(_helmetCallback);\n    }\n\n    if (newState.defer) {\n        _helmetCallback = requestAnimationFrame(function () {\n            commitTagChanges(newState, function () {\n                _helmetCallback = null;\n            });\n        });\n    } else {\n        commitTagChanges(newState);\n        _helmetCallback = null;\n    }\n};\n\nvar commitTagChanges = function commitTagChanges(newState, cb) {\n    var baseTag = newState.baseTag,\n        bodyAttributes = newState.bodyAttributes,\n        htmlAttributes = newState.htmlAttributes,\n        linkTags = newState.linkTags,\n        metaTags = newState.metaTags,\n        noscriptTags = newState.noscriptTags,\n        onChangeClientState = newState.onChangeClientState,\n        scriptTags = newState.scriptTags,\n        styleTags = newState.styleTags,\n        title = newState.title,\n        titleAttributes = newState.titleAttributes;\n\n    updateAttributes(TAG_NAMES.BODY, bodyAttributes);\n    updateAttributes(TAG_NAMES.HTML, htmlAttributes);\n\n    updateTitle(title, titleAttributes);\n\n    var tagUpdates = {\n        baseTag: updateTags(TAG_NAMES.BASE, baseTag),\n        linkTags: updateTags(TAG_NAMES.LINK, linkTags),\n        metaTags: updateTags(TAG_NAMES.META, metaTags),\n        noscriptTags: updateTags(TAG_NAMES.NOSCRIPT, noscriptTags),\n        scriptTags: updateTags(TAG_NAMES.SCRIPT, scriptTags),\n        styleTags: updateTags(TAG_NAMES.STYLE, styleTags)\n    };\n\n    var addedTags = {};\n    var removedTags = {};\n\n    Object.keys(tagUpdates).forEach(function (tagType) {\n        var _tagUpdates$tagType = tagUpdates[tagType],\n            newTags = _tagUpdates$tagType.newTags,\n            oldTags = _tagUpdates$tagType.oldTags;\n\n\n        if (newTags.length) {\n            addedTags[tagType] = newTags;\n        }\n        if (oldTags.length) {\n            removedTags[tagType] = tagUpdates[tagType].oldTags;\n        }\n    });\n\n    cb && cb();\n\n    onChangeClientState(newState, addedTags, removedTags);\n};\n\nvar flattenArray = function flattenArray(possibleArray) {\n    return Array.isArray(possibleArray) ? possibleArray.join(\"\") : possibleArray;\n};\n\nvar updateTitle = function updateTitle(title, attributes) {\n    if (typeof title !== \"undefined\" && document.title !== title) {\n        document.title = flattenArray(title);\n    }\n\n    updateAttributes(TAG_NAMES.TITLE, attributes);\n};\n\nvar updateAttributes = function updateAttributes(tagName, attributes) {\n    var elementTag = document.getElementsByTagName(tagName)[0];\n\n    if (!elementTag) {\n        return;\n    }\n\n    var helmetAttributeString = elementTag.getAttribute(HELMET_ATTRIBUTE);\n    var helmetAttributes = helmetAttributeString ? helmetAttributeString.split(\",\") : [];\n    var attributesToRemove = [].concat(helmetAttributes);\n    var attributeKeys = Object.keys(attributes);\n\n    for (var i = 0; i < attributeKeys.length; i++) {\n        var attribute = attributeKeys[i];\n        var value = attributes[attribute] || \"\";\n\n        if (elementTag.getAttribute(attribute) !== value) {\n            elementTag.setAttribute(attribute, value);\n        }\n\n        if (helmetAttributes.indexOf(attribute) === -1) {\n            helmetAttributes.push(attribute);\n        }\n\n        var indexToSave = attributesToRemove.indexOf(attribute);\n        if (indexToSave !== -1) {\n            attributesToRemove.splice(indexToSave, 1);\n        }\n    }\n\n    for (var _i = attributesToRemove.length - 1; _i >= 0; _i--) {\n        elementTag.removeAttribute(attributesToRemove[_i]);\n    }\n\n    if (helmetAttributes.length === attributesToRemove.length) {\n        elementTag.removeAttribute(HELMET_ATTRIBUTE);\n    } else if (elementTag.getAttribute(HELMET_ATTRIBUTE) !== attributeKeys.join(\",\")) {\n        elementTag.setAttribute(HELMET_ATTRIBUTE, attributeKeys.join(\",\"));\n    }\n};\n\nvar updateTags = function updateTags(type, tags) {\n    var headElement = document.head || document.querySelector(TAG_NAMES.HEAD);\n    var tagNodes = headElement.querySelectorAll(type + \"[\" + HELMET_ATTRIBUTE + \"]\");\n    var oldTags = Array.prototype.slice.call(tagNodes);\n    var newTags = [];\n    var indexToDelete = void 0;\n\n    if (tags && tags.length) {\n        tags.forEach(function (tag) {\n            var newElement = document.createElement(type);\n\n            for (var attribute in tag) {\n                if (tag.hasOwnProperty(attribute)) {\n                    if (attribute === TAG_PROPERTIES.INNER_HTML) {\n                        newElement.innerHTML = tag.innerHTML;\n                    } else if (attribute === TAG_PROPERTIES.CSS_TEXT) {\n                        if (newElement.styleSheet) {\n                            newElement.styleSheet.cssText = tag.cssText;\n                        } else {\n                            newElement.appendChild(document.createTextNode(tag.cssText));\n                        }\n                    } else {\n                        var value = typeof tag[attribute] === \"undefined\" ? \"\" : tag[attribute];\n                        newElement.setAttribute(attribute, value);\n                    }\n                }\n            }\n\n            newElement.setAttribute(HELMET_ATTRIBUTE, \"true\");\n\n            // Remove a duplicate tag from domTagstoRemove, so it isn't cleared.\n            if (oldTags.some(function (existingTag, index) {\n                indexToDelete = index;\n                return newElement.isEqualNode(existingTag);\n            })) {\n                oldTags.splice(indexToDelete, 1);\n            } else {\n                newTags.push(newElement);\n            }\n        });\n    }\n\n    oldTags.forEach(function (tag) {\n        return tag.parentNode.removeChild(tag);\n    });\n    newTags.forEach(function (tag) {\n        return headElement.appendChild(tag);\n    });\n\n    return {\n        oldTags: oldTags,\n        newTags: newTags\n    };\n};\n\nvar generateElementAttributesAsString = function generateElementAttributesAsString(attributes) {\n    return Object.keys(attributes).reduce(function (str, key) {\n        var attr = typeof attributes[key] !== \"undefined\" ? key + \"=\\\"\" + attributes[key] + \"\\\"\" : \"\" + key;\n        return str ? str + \" \" + attr : attr;\n    }, \"\");\n};\n\nvar generateTitleAsString = function generateTitleAsString(type, title, attributes, encode) {\n    var attributeString = generateElementAttributesAsString(attributes);\n    var flattenedTitle = flattenArray(title);\n    return attributeString ? \"<\" + type + \" \" + HELMET_ATTRIBUTE + \"=\\\"true\\\" \" + attributeString + \">\" + encodeSpecialCharacters(flattenedTitle, encode) + \"</\" + type + \">\" : \"<\" + type + \" \" + HELMET_ATTRIBUTE + \"=\\\"true\\\">\" + encodeSpecialCharacters(flattenedTitle, encode) + \"</\" + type + \">\";\n};\n\nvar generateTagsAsString = function generateTagsAsString(type, tags, encode) {\n    return tags.reduce(function (str, tag) {\n        var attributeHtml = Object.keys(tag).filter(function (attribute) {\n            return !(attribute === TAG_PROPERTIES.INNER_HTML || attribute === TAG_PROPERTIES.CSS_TEXT);\n        }).reduce(function (string, attribute) {\n            var attr = typeof tag[attribute] === \"undefined\" ? attribute : attribute + \"=\\\"\" + encodeSpecialCharacters(tag[attribute], encode) + \"\\\"\";\n            return string ? string + \" \" + attr : attr;\n        }, \"\");\n\n        var tagContent = tag.innerHTML || tag.cssText || \"\";\n\n        var isSelfClosing = SELF_CLOSING_TAGS.indexOf(type) === -1;\n\n        return str + \"<\" + type + \" \" + HELMET_ATTRIBUTE + \"=\\\"true\\\" \" + attributeHtml + (isSelfClosing ? \"/>\" : \">\" + tagContent + \"</\" + type + \">\");\n    }, \"\");\n};\n\nvar convertElementAttributestoReactProps = function convertElementAttributestoReactProps(attributes) {\n    var initProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    return Object.keys(attributes).reduce(function (obj, key) {\n        obj[REACT_TAG_MAP[key] || key] = attributes[key];\n        return obj;\n    }, initProps);\n};\n\nvar convertReactPropstoHtmlAttributes = function convertReactPropstoHtmlAttributes(props) {\n    var initAttributes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    return Object.keys(props).reduce(function (obj, key) {\n        obj[HTML_TAG_MAP[key] || key] = props[key];\n        return obj;\n    }, initAttributes);\n};\n\nvar generateTitleAsReactComponent = function generateTitleAsReactComponent(type, title, attributes) {\n    var _initProps;\n\n    // assigning into an array to define toString function on it\n    var initProps = (_initProps = {\n        key: title\n    }, _initProps[HELMET_ATTRIBUTE] = true, _initProps);\n    var props = convertElementAttributestoReactProps(attributes, initProps);\n\n    return [React.createElement(TAG_NAMES.TITLE, props, title)];\n};\n\nvar generateTagsAsReactComponent = function generateTagsAsReactComponent(type, tags) {\n    return tags.map(function (tag, i) {\n        var _mappedTag;\n\n        var mappedTag = (_mappedTag = {\n            key: i\n        }, _mappedTag[HELMET_ATTRIBUTE] = true, _mappedTag);\n\n        Object.keys(tag).forEach(function (attribute) {\n            var mappedAttribute = REACT_TAG_MAP[attribute] || attribute;\n\n            if (mappedAttribute === TAG_PROPERTIES.INNER_HTML || mappedAttribute === TAG_PROPERTIES.CSS_TEXT) {\n                var content = tag.innerHTML || tag.cssText;\n                mappedTag.dangerouslySetInnerHTML = { __html: content };\n            } else {\n                mappedTag[mappedAttribute] = tag[attribute];\n            }\n        });\n\n        return React.createElement(type, mappedTag);\n    });\n};\n\nvar getMethodsForTag = function getMethodsForTag(type, tags, encode) {\n    switch (type) {\n        case TAG_NAMES.TITLE:\n            return {\n                toComponent: function toComponent() {\n                    return generateTitleAsReactComponent(type, tags.title, tags.titleAttributes, encode);\n                },\n                toString: function toString() {\n                    return generateTitleAsString(type, tags.title, tags.titleAttributes, encode);\n                }\n            };\n        case ATTRIBUTE_NAMES.BODY:\n        case ATTRIBUTE_NAMES.HTML:\n            return {\n                toComponent: function toComponent() {\n                    return convertElementAttributestoReactProps(tags);\n                },\n                toString: function toString() {\n                    return generateElementAttributesAsString(tags);\n                }\n            };\n        default:\n            return {\n                toComponent: function toComponent() {\n                    return generateTagsAsReactComponent(type, tags);\n                },\n                toString: function toString() {\n                    return generateTagsAsString(type, tags, encode);\n                }\n            };\n    }\n};\n\nvar mapStateOnServer = function mapStateOnServer(_ref) {\n    var baseTag = _ref.baseTag,\n        bodyAttributes = _ref.bodyAttributes,\n        encode = _ref.encode,\n        htmlAttributes = _ref.htmlAttributes,\n        linkTags = _ref.linkTags,\n        metaTags = _ref.metaTags,\n        noscriptTags = _ref.noscriptTags,\n        scriptTags = _ref.scriptTags,\n        styleTags = _ref.styleTags,\n        _ref$title = _ref.title,\n        title = _ref$title === undefined ? \"\" : _ref$title,\n        titleAttributes = _ref.titleAttributes;\n    return {\n        base: getMethodsForTag(TAG_NAMES.BASE, baseTag, encode),\n        bodyAttributes: getMethodsForTag(ATTRIBUTE_NAMES.BODY, bodyAttributes, encode),\n        htmlAttributes: getMethodsForTag(ATTRIBUTE_NAMES.HTML, htmlAttributes, encode),\n        link: getMethodsForTag(TAG_NAMES.LINK, linkTags, encode),\n        meta: getMethodsForTag(TAG_NAMES.META, metaTags, encode),\n        noscript: getMethodsForTag(TAG_NAMES.NOSCRIPT, noscriptTags, encode),\n        script: getMethodsForTag(TAG_NAMES.SCRIPT, scriptTags, encode),\n        style: getMethodsForTag(TAG_NAMES.STYLE, styleTags, encode),\n        title: getMethodsForTag(TAG_NAMES.TITLE, { title: title, titleAttributes: titleAttributes }, encode)\n    };\n};\n\nvar Helmet = function Helmet(Component) {\n    var _class, _temp;\n\n    return _temp = _class = function (_React$Component) {\n        inherits(HelmetWrapper, _React$Component);\n\n        function HelmetWrapper() {\n            classCallCheck(this, HelmetWrapper);\n            return possibleConstructorReturn(this, _React$Component.apply(this, arguments));\n        }\n\n        HelmetWrapper.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {\n            return !isEqual(this.props, nextProps);\n        };\n\n        HelmetWrapper.prototype.mapNestedChildrenToProps = function mapNestedChildrenToProps(child, nestedChildren) {\n            if (!nestedChildren) {\n                return null;\n            }\n\n            switch (child.type) {\n                case TAG_NAMES.SCRIPT:\n                case TAG_NAMES.NOSCRIPT:\n                    return {\n                        innerHTML: nestedChildren\n                    };\n\n                case TAG_NAMES.STYLE:\n                    return {\n                        cssText: nestedChildren\n                    };\n            }\n\n            throw new Error(\"<\" + child.type + \" /> elements are self-closing and can not contain children. Refer to our API for more information.\");\n        };\n\n        HelmetWrapper.prototype.flattenArrayTypeChildren = function flattenArrayTypeChildren(_ref) {\n            var _babelHelpers$extends;\n\n            var child = _ref.child,\n                arrayTypeChildren = _ref.arrayTypeChildren,\n                newChildProps = _ref.newChildProps,\n                nestedChildren = _ref.nestedChildren;\n\n            return _extends({}, arrayTypeChildren, (_babelHelpers$extends = {}, _babelHelpers$extends[child.type] = [].concat(arrayTypeChildren[child.type] || [], [_extends({}, newChildProps, this.mapNestedChildrenToProps(child, nestedChildren))]), _babelHelpers$extends));\n        };\n\n        HelmetWrapper.prototype.mapObjectTypeChildren = function mapObjectTypeChildren(_ref2) {\n            var _babelHelpers$extends2, _babelHelpers$extends3;\n\n            var child = _ref2.child,\n                newProps = _ref2.newProps,\n                newChildProps = _ref2.newChildProps,\n                nestedChildren = _ref2.nestedChildren;\n\n            switch (child.type) {\n                case TAG_NAMES.TITLE:\n                    return _extends({}, newProps, (_babelHelpers$extends2 = {}, _babelHelpers$extends2[child.type] = nestedChildren, _babelHelpers$extends2.titleAttributes = _extends({}, newChildProps), _babelHelpers$extends2));\n\n                case TAG_NAMES.BODY:\n                    return _extends({}, newProps, {\n                        bodyAttributes: _extends({}, newChildProps)\n                    });\n\n                case TAG_NAMES.HTML:\n                    return _extends({}, newProps, {\n                        htmlAttributes: _extends({}, newChildProps)\n                    });\n            }\n\n            return _extends({}, newProps, (_babelHelpers$extends3 = {}, _babelHelpers$extends3[child.type] = _extends({}, newChildProps), _babelHelpers$extends3));\n        };\n\n        HelmetWrapper.prototype.mapArrayTypeChildrenToProps = function mapArrayTypeChildrenToProps(arrayTypeChildren, newProps) {\n            var newFlattenedProps = _extends({}, newProps);\n\n            Object.keys(arrayTypeChildren).forEach(function (arrayChildName) {\n                var _babelHelpers$extends4;\n\n                newFlattenedProps = _extends({}, newFlattenedProps, (_babelHelpers$extends4 = {}, _babelHelpers$extends4[arrayChildName] = arrayTypeChildren[arrayChildName], _babelHelpers$extends4));\n            });\n\n            return newFlattenedProps;\n        };\n\n        HelmetWrapper.prototype.warnOnInvalidChildren = function warnOnInvalidChildren(child, nestedChildren) {\n            if (process.env.NODE_ENV !== \"production\") {\n                if (!VALID_TAG_NAMES.some(function (name) {\n                    return child.type === name;\n                })) {\n                    if (typeof child.type === \"function\") {\n                        return warn(\"You may be attempting to nest <Helmet> components within each other, which is not allowed. Refer to our API for more information.\");\n                    }\n\n                    return warn(\"Only elements types \" + VALID_TAG_NAMES.join(\", \") + \" are allowed. Helmet does not support rendering <\" + child.type + \"> elements. Refer to our API for more information.\");\n                }\n\n                if (nestedChildren && typeof nestedChildren !== \"string\" && (!Array.isArray(nestedChildren) || nestedChildren.some(function (nestedChild) {\n                    return typeof nestedChild !== \"string\";\n                }))) {\n                    throw new Error(\"Helmet expects a string as a child of <\" + child.type + \">. Did you forget to wrap your children in braces? ( <\" + child.type + \">{``}</\" + child.type + \"> ) Refer to our API for more information.\");\n                }\n            }\n\n            return true;\n        };\n\n        HelmetWrapper.prototype.mapChildrenToProps = function mapChildrenToProps(children, newProps) {\n            var _this2 = this;\n\n            var arrayTypeChildren = {};\n\n            React.Children.forEach(children, function (child) {\n                if (!child || !child.props) {\n                    return;\n                }\n\n                var _child$props = child.props,\n                    nestedChildren = _child$props.children,\n                    childProps = objectWithoutProperties(_child$props, [\"children\"]);\n\n                var newChildProps = convertReactPropstoHtmlAttributes(childProps);\n\n                _this2.warnOnInvalidChildren(child, nestedChildren);\n\n                switch (child.type) {\n                    case TAG_NAMES.LINK:\n                    case TAG_NAMES.META:\n                    case TAG_NAMES.NOSCRIPT:\n                    case TAG_NAMES.SCRIPT:\n                    case TAG_NAMES.STYLE:\n                        arrayTypeChildren = _this2.flattenArrayTypeChildren({\n                            child: child,\n                            arrayTypeChildren: arrayTypeChildren,\n                            newChildProps: newChildProps,\n                            nestedChildren: nestedChildren\n                        });\n                        break;\n\n                    default:\n                        newProps = _this2.mapObjectTypeChildren({\n                            child: child,\n                            newProps: newProps,\n                            newChildProps: newChildProps,\n                            nestedChildren: nestedChildren\n                        });\n                        break;\n                }\n            });\n\n            newProps = this.mapArrayTypeChildrenToProps(arrayTypeChildren, newProps);\n            return newProps;\n        };\n\n        HelmetWrapper.prototype.render = function render() {\n            var _props = this.props,\n                children = _props.children,\n                props = objectWithoutProperties(_props, [\"children\"]);\n\n            var newProps = _extends({}, props);\n\n            if (children) {\n                newProps = this.mapChildrenToProps(children, newProps);\n            }\n\n            return React.createElement(Component, newProps);\n        };\n\n        createClass(HelmetWrapper, null, [{\n            key: \"canUseDOM\",\n\n\n            // Component.peek comes from react-side-effect:\n            // For testing, you may use a static peek() method available on the returned component.\n            // It lets you get the current state without resetting the mounted instance stack.\n            // Don’t use it for anything other than testing.\n\n            /**\n             * @param {Object} base: {\"target\": \"_blank\", \"href\": \"http://mysite.com/\"}\n             * @param {Object} bodyAttributes: {\"className\": \"root\"}\n             * @param {String} defaultTitle: \"Default Title\"\n             * @param {Boolean} defer: true\n             * @param {Boolean} encodeSpecialCharacters: true\n             * @param {Object} htmlAttributes: {\"lang\": \"en\", \"amp\": undefined}\n             * @param {Array} link: [{\"rel\": \"canonical\", \"href\": \"http://mysite.com/example\"}]\n             * @param {Array} meta: [{\"name\": \"description\", \"content\": \"Test description\"}]\n             * @param {Array} noscript: [{\"innerHTML\": \"<img src='http://mysite.com/js/test.js'\"}]\n             * @param {Function} onChangeClientState: \"(newState) => console.log(newState)\"\n             * @param {Array} script: [{\"type\": \"text/javascript\", \"src\": \"http://mysite.com/js/test.js\"}]\n             * @param {Array} style: [{\"type\": \"text/css\", \"cssText\": \"div { display: block; color: blue; }\"}]\n             * @param {String} title: \"Title\"\n             * @param {Object} titleAttributes: {\"itemprop\": \"name\"}\n             * @param {String} titleTemplate: \"MySite.com - %s\"\n             */\n            set: function set$$1(canUseDOM) {\n                Component.canUseDOM = canUseDOM;\n            }\n        }]);\n        return HelmetWrapper;\n    }(React.Component), _class.propTypes = {\n        base: PropTypes.object,\n        bodyAttributes: PropTypes.object,\n        children: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.node), PropTypes.node]),\n        defaultTitle: PropTypes.string,\n        defer: PropTypes.bool,\n        encodeSpecialCharacters: PropTypes.bool,\n        htmlAttributes: PropTypes.object,\n        link: PropTypes.arrayOf(PropTypes.object),\n        meta: PropTypes.arrayOf(PropTypes.object),\n        noscript: PropTypes.arrayOf(PropTypes.object),\n        onChangeClientState: PropTypes.func,\n        script: PropTypes.arrayOf(PropTypes.object),\n        style: PropTypes.arrayOf(PropTypes.object),\n        title: PropTypes.string,\n        titleAttributes: PropTypes.object,\n        titleTemplate: PropTypes.string\n    }, _class.defaultProps = {\n        defer: true,\n        encodeSpecialCharacters: true\n    }, _class.peek = Component.peek, _class.rewind = function () {\n        var mappedState = Component.rewind();\n        if (!mappedState) {\n            // provide fallback if mappedState is undefined\n            mappedState = mapStateOnServer({\n                baseTag: [],\n                bodyAttributes: {},\n                encodeSpecialCharacters: true,\n                htmlAttributes: {},\n                linkTags: [],\n                metaTags: [],\n                noscriptTags: [],\n                scriptTags: [],\n                styleTags: [],\n                title: \"\",\n                titleAttributes: {}\n            });\n        }\n\n        return mappedState;\n    }, _temp;\n};\n\nvar NullComponent = function NullComponent() {\n    return null;\n};\n\nvar HelmetSideEffects = withSideEffect(reducePropsToState, handleClientStateChange, mapStateOnServer)(NullComponent);\n\nvar HelmetExport = Helmet(HelmetSideEffects);\nHelmetExport.renderStatic = HelmetExport.rewind;\n\nexport default HelmetExport;\nexport { HelmetExport as Helmet };\n","'use strict';\n\nfunction _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }\n\nvar React = require('react');\nvar React__default = _interopDefault(React);\n\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nfunction _inheritsLoose(subClass, superClass) {\n  subClass.prototype = Object.create(superClass.prototype);\n  subClass.prototype.constructor = subClass;\n  subClass.__proto__ = superClass;\n}\n\nvar canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);\nfunction withSideEffect(reducePropsToState, handleStateChangeOnClient, mapStateOnServer) {\n  if (typeof reducePropsToState !== 'function') {\n    throw new Error('Expected reducePropsToState to be a function.');\n  }\n\n  if (typeof handleStateChangeOnClient !== 'function') {\n    throw new Error('Expected handleStateChangeOnClient to be a function.');\n  }\n\n  if (typeof mapStateOnServer !== 'undefined' && typeof mapStateOnServer !== 'function') {\n    throw new Error('Expected mapStateOnServer to either be undefined or a function.');\n  }\n\n  function getDisplayName(WrappedComponent) {\n    return WrappedComponent.displayName || WrappedComponent.name || 'Component';\n  }\n\n  return function wrap(WrappedComponent) {\n    if (typeof WrappedComponent !== 'function') {\n      throw new Error('Expected WrappedComponent to be a React component.');\n    }\n\n    var mountedInstances = [];\n    var state;\n\n    function emitChange() {\n      state = reducePropsToState(mountedInstances.map(function (instance) {\n        return instance.props;\n      }));\n\n      if (SideEffect.canUseDOM) {\n        handleStateChangeOnClient(state);\n      } else if (mapStateOnServer) {\n        state = mapStateOnServer(state);\n      }\n    }\n\n    var SideEffect = /*#__PURE__*/function (_PureComponent) {\n      _inheritsLoose(SideEffect, _PureComponent);\n\n      function SideEffect() {\n        return _PureComponent.apply(this, arguments) || this;\n      }\n\n      // Try to use displayName of wrapped component\n      // Expose canUseDOM so tests can monkeypatch it\n      SideEffect.peek = function peek() {\n        return state;\n      };\n\n      SideEffect.rewind = function rewind() {\n        if (SideEffect.canUseDOM) {\n          throw new Error('You may only call rewind() on the server. Call peek() to read the current state.');\n        }\n\n        var recordedState = state;\n        state = undefined;\n        mountedInstances = [];\n        return recordedState;\n      };\n\n      var _proto = SideEffect.prototype;\n\n      _proto.UNSAFE_componentWillMount = function UNSAFE_componentWillMount() {\n        mountedInstances.push(this);\n        emitChange();\n      };\n\n      _proto.componentDidUpdate = function componentDidUpdate() {\n        emitChange();\n      };\n\n      _proto.componentWillUnmount = function componentWillUnmount() {\n        var index = mountedInstances.indexOf(this);\n        mountedInstances.splice(index, 1);\n        emitChange();\n      };\n\n      _proto.render = function render() {\n        return /*#__PURE__*/React__default.createElement(WrappedComponent, this.props);\n      };\n\n      return SideEffect;\n    }(React.PureComponent);\n\n    _defineProperty(SideEffect, \"displayName\", \"SideEffect(\" + getDisplayName(WrappedComponent) + \")\");\n\n    _defineProperty(SideEffect, \"canUseDOM\", canUseDOM);\n\n    return SideEffect;\n  };\n}\n\nmodule.exports = withSideEffect;\n"],"names":["ConsoleApiName","log","debug","info","warn","error","display","api","args","_i","arguments","length","Object","prototype","hasOwnProperty","call","apply","catchUserErrors","fn","errorMsg","err","console","bind","onMonitorErrorCollected","__spreadArray","to","from","pack","ar","i","l","Array","slice","concat","debugMode","setDebugMode","newDebugMode","monitor","callMonitored","this","context","e","displayIfDebugEnabled","ONE_SECOND","ONE_MINUTE","throttle","wait","options","pendingExecutionWithParameters","pendingTimeoutId","needLeadingExecution","undefined","leading","needTrailingExecution","trailing","inWaitPeriod","throttled","parameters","setTimeout","cancel","clearTimeout","target","toAssign","forEach","source","key","shallowClone","object","generateUUID","placeholder","parseInt","Math","random","toString","replace","performDraw","threshold","round","num","decimals","toFixed","noop","jsonStringify","value","replacer","space","JSON","stringify","restoreObjectPrototypeToJson","detachToJsonMethod","restoreArrayPrototypeToJson","restoreValuePrototypeToJson","getPrototypeOf","restoreValueToJson","_a","objectToJson","toJSON","includes","candidate","search","indexOf","arrayFrom","arrayLike","array","Set","item","push","find","predicate","isPercentage","isNumber","objectValues","keys","map","objectEntries","isEmptyObject","startsWith","getGlobalObject","globalThis","defineProperty","get","configurable","globalObject","_dd_temp_","self","window","getLinkElementOrigin","element","origin","sanitizedHost","host","protocol","findCommaSeparatedValue","rawString","name","matches","RegExp","exec","safeTruncate","suffix","lastChar","charCodeAt","correctedLength","getType","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","isMatchOption","itemType","matchList","list","useStartsWith","some","test","cssEscape","str","CSS","escape","ch","asCodePoint","HAS_MULTI_BYTES_CHARACTERS","computeBytesCount","TextEncoder","encode","Blob","size","createContextManager","computeBytesCountImpl","bytesCountCache","getBytesCount","remove","set","newContext","getContext","setContext","setContextProperty","property","removeContextProperty","clearContext","navigationStart","BoundedBuffer","buffer","callback","splice","drain","relativeToClocks","relative","timeStamp","getCorrectedTimeStamp","relativeTime","correctedOrigin","dateNow","performance","now","getNavigationStart","addDuration","getTimeStamp","toServerDuration","duration","timeStampNow","relativeNow","clocksNow","clocksOrigin","elapsed","start","end","a","b","getRelativeTime","timestamp","timing","getCurrentSiteCache","setCookie","expireDelay","date","setTime","expires","toUTCString","sameSite","crossSite","domain","secure","document","cookie","getCookie","deleteCookie","enabledExperimentalFeatures","willSyntheticsInjectRum","Boolean","_DATADOG_SYNTHETICS_INJECTS_RUM","getEventBridge","eventBridgeGlobal","DatadogEventBridge","getAllowedWebViewHosts","parse","send","eventType","event","canUseEventBridge","currentHost","location","hostname","bridge","allowedHost","isExperimentalFeatureEnabled","featureName","getExperimentalFeatures","UNKNOWN_FUNCTION","computeStackTrace","ex","stack","stackProperty","tryToGetString","exString","String","split","line","stackFrame","parts","CHROME_LINE_RE","isNative","isEval","submatch","CHROME_EVAL_RE","column","func","url","parseChromeLine","CHROME_ANONYMOUS_FUNCTION_RE","parseChromeAnonymousLine","WINJS_LINE_RE","parseWinLine","GECKO_LINE_RE","GECKO_EVAL_RE","parseGeckoLine","message","fileUrl","filePosition","isURLSupported","ErrorSource","computeRawError","stackTrace","originalError","handlingStack","startClocks","nonErrorPrefix","handling","Error","toStackTraceString","type","causes","flattenErrorCauses","result","formatErrorMessage","frame","createHandlingStack","formattedStack","parentSource","currentError","cause","sanitizeUser","newUser","user","normalizeUrl","buildUrl","href","getOrigin","base","URL","checkURLSupported","doc","anchorElement","createElement","baseElement","implementation","createHTMLDocument","head","appendChild","body","INTAKE_SITE_US1","INTAKE_SITE_AP1","ENDPOINTS","logs","rum","sessionReplay","INTAKE_TRACKS","createEndpointBuilder","initConfiguration","endpointType","configurationTags","buildUrlWithParameters","path","proxy","proxyUrl","normalizedProxyUrl_1","encodeURIComponent","site","internalAnalyticsSubdomain","domainParts","extension","pop","subdomain","buildEndpointHost","normalizedProxyUrl_2","createEndpointUrlWithParametersBuilder","build","retry","clientToken","tags","count","lastFailureStatus","reverse","buildEndpointParameters","urlPrefix","FORBIDDEN_CHARACTERS","buildTag","rawValue","valueSizeLimit","sanitizedValue","computeTransportConfiguration","configuration","env","service","version","datacenter","buildTags","endpointBuilders","logsEndpointBuilder","rumEndpointBuilder","sessionReplayEndpointBuilder","computeEndpointBuilders","intakeUrlPrefixes","builder","replicaConfiguration","replica","replicaEndpointBuilders","applicationId","computeReplicaConfiguration","isIntakeUrl","intakeEndpoint","DefaultPrivacyLevel","ALLOW","MASK","MASK_USER_INPUT","validateAndBuildConfiguration","_b","_c","sessionSampleRate","sampleRate","telemetrySampleRate","enabledFeatures","telemetryConfigurationSampleRate","enableExperimentalFeatures","filter","flag","beforeSend","cookieOptions","buildCookieOptions","silentMultipleInit","batchBytesLimit","eventRateLimiterThreshold","maxTelemetryEventsPerPage","flushTimeout","batchMessagesLimit","messageBytesLimit","useSecureSessionCookie","useCrossSiteSessionCookie","mustUseSecureCookie","trackSessionAcrossSubdomains","testCookieName","domainLevels","candidateDomain","getCurrentSite","clearTracingIfNeeded","status","isAborted","traceId","spanId","traceSampled","injectHeadersIfTracingAllowed","sessionManager","inject","getCrypto","findTrackedSession","tracingOption","allowedTracingUrls","match","TraceIdentifier","traceSampleRate","propagatorTypes","tracingHeaders","propagatorType","toDecimalString","traceparent","toPaddedHexadecimalString","b3","makeTracingHeaders","crypto","msCrypto","Uint8Array","getRandomValues","radix","high","readInt32","low","mod","floor","offset","validateAndBuildRumConfiguration","_d","_e","_f","sessionReplaySampleRate","premiumSampleRate","replaySampleRate","tracingSampleRate","excludedActivityUrls","allowedTracingOrigins","tracingOptions_1","option","expectedItem","isTracingOption","tracingOptions_2","legacyMatchOption","convertLegacyMatchOptionToTracingOption","validateAndBuildTracingOptions","baseConfiguration","trackUserInteractions","trackInteractions","trackFrustrations","actionNameAttribute","oldPlansBehavior","trackViewsManually","trackResources","trackLongTasks","defaultPrivacyLevel","customerDataTelemetrySampleRate","getSelectedTracingPropagators","usedTracingPropagators","buildCommonContext","globalContextManager","userContextManager","recorderApi","hasReplay","isRecording","sendToExtension","payload","__ddBrowserSdkExtensionCallback","Observable","onFirstSubscribe","observers","subscribe","f","_this","onLastUnsubscribe","unsubscribe","other","notify","data","observer","mergeObservables","observables","globalObservable","subscriptions","observable","subscription","getZoneJsOriginalValue","original","browserWindow","Zone","__symbol__","addEventListener","eventTarget","listener","addEventListeners","events","once","capture","passive","wrappedListener","stop","onRawTelemetryEventCollected","TelemetryType","ALLOWED_FRAME_URLS","TELEMETRY_EXCLUDED_SITES","telemetryConfiguration","maxEventsPerPage","sentEventCount","telemetryEnabled","telemetryConfigurationEnabled","startTelemetry","telemetryService","contextProvider","rawEvent","event_1","_dd","format_version","telemetry","experimental_features","toTelemetryEvent","addTelemetryError","setContextProvider","provider","enabled","addTelemetryDebug","addTelemetry","kind","scrubCustomerFrames","formatError","allowedFrameUrl","getMutationObserverConstructor","constructor","MutationObserver","originalInstance","runOnReadyState","expectedReadyState","readyState","FAKE_INITIAL_DOCUMENT","RESOURCE_TYPES","initiatorType","_","computeResourceKind","isValidUrl","pathname","getPathName","RESOURCE_TYPES_1","isType","areInOrder","numbers","computePerformanceResourceDuration","entry","startTime","responseEnd","computePerformanceResourceDetails","validEntry","toValidEntry","fetchStart","redirectStart","redirectEnd","domainLookupStart","domainLookupEnd","connectStart","secureConnectionStart","connectEnd","requestStart","responseStart","details","download","formatTiming","first_byte","connect","ssl","dns","hasRedirection","redirect","computeSize","decodedBodySize","isAllowedRequestUrl","isTextNode","node","nodeType","Node","TEXT_NODE","isElementNode","ELEMENT_NODE","isNodeShadowHost","shadowRoot","isNodeShadowRoot","getParentNode","parentNode","viewportObservable","viewport","getDocumentTraceId","traceIdMeta","querySelector","traceTimeMeta","createDocumentTraceData","content","getDocumentTraceDataFromMeta","comment","childNodes","getTraceCommentFromNode","findTraceComment","getDocumentTraceDataFromComment","traceTime","rawTraceTime","Number","COMMENT_NODE","isCommentNode","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","sendTimingIfPointerIsNotCancelled","sendTiming","delay","retrieveFirstInputTiming","numberKey","timingElement","rumAllowedPerformanceEntries","loadEventEnd","isIncompleteNavigation","isForbiddenResource","createEventRateLimiter","limit","onLimitReached","eventCount","allowNextEvent","isLimitReached","current","field","isValidObjectContaining","fields","getSyntheticsContext","testId","_DATADOG_SYNTHETICS_PUBLIC_ID","getSyntheticsTestId","resultId","_DATADOG_SYNTHETICS_RESULT_ID","getSyntheticsResultId","test_id","result_id","injected","initViewportObservable","updateDimension","getViewportDimension","createViewportObservable","visual","visualViewport","width","scale","height","innerWidth","innerHeight","getDisplayContext","viewportDimension","VIEW_EVENTS_MODIFIABLE_FIELD_PATHS","OTHER_EVENTS_MODIFIABLE_FIELD_PATHS","startRumAssembly","viewContexts","urlContexts","actionContexts","reportError","eventRateLimiters","syntheticsContext","ciTestContext","testExecutionId","Cypress","test_execution_id","getCiTestContext","rawRumEvent","domainContext","savedCommonContext","customerContext","viewContext","findView","urlContext","findUrl","session","commonContext","actionId","findActionId","serverRumEvent","drift","plan","browser_sdk_version","application","id","view","referrer","action","synthetics","ci_test","has_replay","usr","modifiableFieldPaths","modifier","clone","originalValue","newValue","originalType","newType","limitModification","shouldSend","foregroundPeriods","startForegroundContexts","hasFocus","addNewForegroundPeriod","onFocusChange","onBlurChange","stopForegroundTracking","isTrusted","stopBlurTracking","closeForegroundPeriod","isInForegroundAt","selectInForegroundPeriodsFor","currentForegroundPeriod","foregroundPeriod","eventStartTime","eventEndTime","filteredForegroundPeriods","earliestIndex","max","startDuration","endDuration","unshift","xhrObservable","LifeCycle","callbacks","eventCallbacks","SESSION_TIME_OUT_DELAY","SESSION_EXPIRATION_DELAY","END_OF_TIMES","Infinity","ContextHistory","clearOldContextsInterval","setInterval","clearOldContexts","endTime","index","close","closeActive","latestEntry","findAll","reset","clearInterval","oldTimeThreshold","instrumentMethod","method","instrumentationFactory","instrumentation","instrumentationWrapper","instrumentMethodAndCallOriginal","before","after","instrumentSetter","originalDescriptor","getOwnPropertyDescriptor","thisObject","fetchObservable","xhrContexts","WeakMap","initXhrObservable","stopInstrumentingStart","XMLHttpRequest","openXhr","stopInstrumentingSend","sendXhr","stopInstrumentingAbort","abortXhr","createXhrObservable","state","startContext","xhr","hasBeenReported","stopInstrumentingOnReadyStateChange","DONE","onEnd","removeEventListener","completeContext","initFetchObservable","fetch","originalFetch","input","init","responsePromise","afterSend","createFetchObservable","reportFetch","response","DOMException","code","ABORT_ERR","responseType","then","nextRequestIndex","startRequestCollection","tracer","traceFetch","Request","headers","append","headers_1","Headers","header","traceXhr","setRequestHeader","startTracer","rawContext","requestIndex","getNextRequestIndex","trackXhr","clonedResponse","tryToClone","stream","reader","getReader","chunks","readBytesCount","onDone","bytes","limitExceeded","catch","collectStreamBody","completeBuffer_1","offset_1","chunk","bytesLimit","readMore","read","done","readBytesFromStream","POSITIVE_INFINITY","waitForResponseToComplete","trackFetch","trackEventCounts","isChildEvent","onChange","eventCounts","errorCount","longTaskCount","resourceCount","actionCount","frustrationCount","frustration","PAGE_ACTIVITY_VALIDATION_DELAY","waitPageActivityEnd","domMutationObservable","pageActivityEndCallback","maxDuration","pageActivityObservable","firstRequestIndex","pendingRequestsCount","notifyPageActivity","isExcludedUrl","startEvent","request","stopTrackingWindowOpen","s","isBusy","createPageActivityObservable","pageActivityEndTimeoutId","hasCompleted","validationTimeoutId","complete","hadActivity","maxDurationTimeoutId","pageActivitySubscription","lastChangeTime","doWaitPageActivityEnd","requestUrl","MAX_DURATION_BETWEEN_CLICKS","createClickChain","firstClick","onFinalize","maxDurationBetweenClicksTimeout","bufferedClicks","appendClick","click","stopObservable","tryFinalize","dontAcceptMoreClick","every","isStopped","tryAppend","first","second","sqrt","pow","clientX","clientY","areEventsSimilar","DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE","getActionNameFromElement","userProgrammaticAttribute","getActionNameFromElementProgrammatically","getActionNameFromElementForStrategies","priorityStrategies","fallbackStrategies","targetElement","programmaticAttribute","elementWithAttribute","supportsElementClosestResult","HTMLElement","supportsElementClosest","closest","hasAttribute","parentElement","truncate","normalizeWhitespace","getAttribute","trim","supportsLabelPropertyResult","HTMLInputElement","supportsLabelProperty","labels","getTextualContent","label","ownerDocument","querySelectorAll","htmlFor","nodeName","labelledByAttribute","refElement","getElementById","strategies","recursionCounter","strategies_1","name_1","strategy","trimmedName","isContentEditable","text_1","innerText","removeTextFromElements","query","element_1","textToReplace","documentMode","textContent","supportScopeSelectorCache","STABLE_ATTRIBUTES","GLOBALLY_UNIQUE_SELECTOR_GETTERS","getStableAttributeSelector","isGeneratedValue","UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS","tagName","classList","className","getSelectorFromElement","targetElementSelector","globallyUniqueSelector","findSelector","isSelectorUniqueGlobally","isSelectorUniqueAmongSiblings","combineSelector","getPositionSelector","selector","getAttributeSelector","STABLE_ATTRIBUTES_1","attributeName","sibling","firstElementChild","elementIndex","nextElementSibling","selectorGetters","childSelector","selectorGetters_1","elementSelector","selectorGetter","fullSelector","supportScopeSelector","parent","child","isSelectionEmpty","selection","getSelection","isCollapsed","isValidMouseEvent","Element","isPrimary","computeFrustration","clicks","rageClick","getUserActivity","isRage","addFrustration","isDead","hasError","hasSelectionChanged","DEAD_CLICK_EXCLUDE_SELECTOR","hasPageActivity","msMatchesSelector","trackClickActions","currentClickChain","history","stopClickChain","stopActionEventsListener","selectionEmptyAtPointerDown","clickContext","onPointerDown","onStartEvent","userActivity","listeners","clickEventTimeStamp_1","localUserActivity_1","listenActionEvents","pointerDownEvent","clickActionBase","position","rect","getBoundingClientRect","x","left","y","top","computeClickActionBase","hadActivityOnPointerDown","pageActivityEndEvent","processPointerDown","getClickEventTimeStamp","appendClickToClickChain","newClick","stopWaitPageActivityEnd","discard","validate","viewEndedSubscription","endClocks","stopSubscription","startClickAction","rageClick_1","finalizeClicks","activityEndTime","historyEntry","eventCountsSubscription","frustrationTypes","newActivityEndTime","frustrationType","domEvents","clickEventTimeStamp","clickAction","counts","pointerUpDelay","processAction","foregroundContexts","autoActionProperties","isAutoAction","loading_time","long_task","resource","pointer_up_delay","actionEvent","inForeground","in_foreground","ERROR_TYPES_RE","startUnhandledErrorCollection","stopInstrumentingOnError","lineNo","columnNo","errorObj","location_1","msg","groups","instrumentOnError","stopInstrumentingOnUnhandledRejection","reason","instrumentUnhandledRejection","consoleObservablesByApi","initConsoleObservable","apis","consoleObservables","originalConsoleApi","params","buildConsoleLog","createConsoleObservable","param","formatConsoleParameters","firstErrorParam","trackFirstHiddenSingleton","RawReportType","initReportObservable","handleCspViolation","blockedURI","effectiveDirective","subtype","buildStack","originalPolicy","sourceFile","lineNumber","columnNumber","buildRawReportFromCspViolation","createCspViolationReportObservable","reportTypes","ReportingObserver","handleReports","reports","report","buildRawReportFromReport","types","disconnect","createReportObservable","startErrorCollection","featureFlagContexts","errorObservable","consoleError","trackConsoleError","trackRuntimeError","trackReportError","handling_stack","source_type","featureFlagContext","findFeatureFlagEvaluations","feature_flags","processError","addError","rawError","doStartErrorCollection","matchRequestTiming","sameNameEntries","getEntriesByName","candidates","errorMargin","isBetween","startResourceCollection","pageStateHistory","matchingTiming","correspondingTimingOverrides","computePerformanceEntryMetrics","tracingInfo","span_id","trace_id","rule_psr","getRulePsr","computeRequestTracingInfo","indexingInfo","computeIndexingInfo","durationOverrideInfo","computedDuration","performanceEntryDuration","computed_duration","performance_entry_duration","override_duration_diff","computeDurationOverrideInfo","pageStateInfo","computePageStateInfo","resourceEvent","status_code","performanceEntry","requestInput","requestInit","processRequest","entries_1","processResourceEntry","entryMetrics","computeEntryTracingInfo","resourceStart","discarded","resourceAllowed","page_states","page_was_discarded","wasDiscarded","trackFirstHidden","visibilityState","TIMING_MAXIMUM_DELAY","trackInitialViewTimings","timings","setTimings","newTimings","stopNavigationTracking","domComplete","domContentLoaded","domContentLoadedEventEnd","domInteractive","loadEvent","firstByte","trackNavigationTimings","stopFCPTracking","firstHidden","fcpEntry","trackFirstContentfulPaintTiming","firstContentfulPaint","stopLCPTracking","firstInteractionTimestamp","stopEventListener","unsubscribeLifeCycle","lcpEntry","findLast","trackLargestContentfulPaintTiming","largestContentfulPaint","stopFIDTracking","firstInputEntry","firstInputDelay","firstInputTime","trackFirstInputTimings","trackViewMetrics","scheduleViewUpdate","loadingType","viewStart","stopCLSTracking","viewMetrics","loadType","isWaitingForLoadEvent","isWaitingForActivityLoadingTime","loadingTimeCandidates","invokeCallbackIfAllCandidatesAreReceived","setLoadEvent","trackLoadingTime","newLoadingTime","loadingTime","stopLoadingTimeTracking","cumulativeLayoutShift","maxClsValue","update","slidingSessionWindow","hadRecentInput","trackCumulativeLayoutShift","trackViews","locationChangeObservable","areViewsTrackedAutomatically","initialViewOptions","locationChangeSubscription","initialView","newView","updateTimings","scheduleUpdate","trackInitialView","stopInitialViewTracking","currentView","stopViewLifeCycle","trackViewChange","pageExitEvent","triggerUpdate","keepAliveInterval","startViewLifeCycle","viewOptions","currentLocation","otherLocation","oldLocation","newLocation","hash","correspondingId","substr","isHashAnAnchor","getPathFromHash","renewViewOnLocationChange","addTiming","time","startView","initialLocation","customTimings","documentVersion","triggerViewUpdate","cancelScheduleViewUpdate","stopViewMetricsTracking","viewId","scheduleStop","trackViewEventCounts","scheduleStopEventCountsTracking","currentEnd","isActive","clocks","looksLikeRelativeTime","sanitized","sanitizeTiming","startViewCollection","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","discardNegativeDuration","loading_type","time_spent","in_foreground_periods","custom_timings","newObject","mapValues","processViewUpdate","ongoingOperations","SESSION_ENTRY_REGEXP","SESSION_ENTRY_SEPARATOR","SESSION_COOKIE_NAME","bufferedOperations","withCookieLockAccess","operations","numberOfRetries","next","currentLock","currentSession","retrieveSession","isCookieLockEnabled","lock","retryLater","setSession","processedSession","process","persistSession","isExpiredState","chrome","navigator","userAgent","currentNumberOfRetries","nextOperations","shift","clearSession","expire","toSessionString","sessionString","isValidSessionString","startSessionStore","productKey","computeSessionState","renewObservable","expireObservable","watchSessionTimeoutId","cookieSession","isActiveSession","synchronizeSession","sessionCache","retrieveActiveSession","hasSessionInCache","isSessionInCacheOutdated","created","expandOrRenewSession","isTracked","synchronizedSession","trackingType","expandOrRenewCookie","renewSession","expandSession","getSession","stopCallbacks","startSessionManager","oldSessionId","oldRumType","oldLogsType","tryOldCookiesMigration","sessionStore","sessionContextHistory","buildSessionContext","trackActivity","expandSessionWhenVisible","visibilityCheckInterval","trackVisibility","findActiveSession","startRumSessionManager","rawTrackingType","hasValidRumSession","isTypeTracked","sessionReplayAllowed","longTaskAllowed","rumSessionType","Batch","pageExitObservable","flushObservable","pushOnlyBuffer","upsertBuffer","bufferBytesCount","bufferMessagesCount","flush","sendOnExit","flushPeriodically","addOrUpdate","upsert","sendFn","messages","bytesCount","processedMessage","messageBytesCount","hasMessageFor","willReachedBytesLimitWith","isFull","removedMessage","MAX_QUEUE_BYTES_COUNT","sendWithRetryStrategy","sendStrategy","transportStatus","queuedPayloads","bandwidthMonitor","canHandle","onSuccess","retryQueuedPayloads","onFailure","enqueue","scheduleRetry","dequeue","currentBackoffTime","min","onLine","shouldRetryRequest","ongoingRequestCount","queueFullReported","previousQueue","newPayloadQueue","queue","createHttpRequest","endpointBuilder","retryState","ongoingByteCount","sendStrategyForRetry","onResponse","isKeepAliveSupported","fetchUrl","keepalive","mode","sendXHR","fetchKeepAliveStrategy","sendBeacon","beaconUrl","hasReportedBeaconError","reportBeaconError","sendBeaconStrategy","onLoadEnd","open","startRumBatch","telemetryEventObservable","batch","replicaBatch","primaryBatch","createRumBatch","withReplicaApplicationId","replicated","makeRumBatch","isTelemetryReplicationAllowed","createLocationChangeObservable","onHashChange","stopHistoryTracking","onHistoryChange","stopInstrumentingPushState","stopInstrumentingReplaceState","removeListener","trackHistory","onLocationChange","stopHashTracking","currentPeriodMeasures","currentBatchMeasures","batchHasRumEvent","sendCurrentPeriodMeasures","batchCount","initCurrentPeriodMeasures","updateMeasure","measure","sum","mergeMeasure","batchBytesCount","batchMessagesCount","globalContextBytes","userContextBytes","featureFlagBytes","initCurrentBatchMeasures","currentPageState","pageStateEntries","getPageState","addPageState","nextPageState","maxPageStateEntries","RecordType","NodeType","IncrementalSource","MouseInteractionType","MediaInteractionType","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","parentNodePrivacyLevel","reducePrivacyLevel","getNodeSelfPrivacyLevel","childPrivacyLevel","privAttr","inputElement","autocomplete","contains","relAttribute","getLowerCaseAttribute","nameAttribute","propertyAttribute","toLowerCase","shouldIgnoreElement","shouldMaskNode","privacyLevel","isFormElement","getTextContent","textNode","ignoreWhiteSpace","parentTagName","isStyle","serializedNodeIds","hasSerializedNode","getSerializedNodeId","getElementInputValue","nodePrivacyLevel","URL_IN_CSS_REF","ABSOLUTE_URL","DATA_URI","switchToAbsoluteUrl","cssText","cssHref","matchingSubstring","singleQuote","urlWrappedInSingleQuotes","doubleQuote","urlWrappedInDoubleQuotes","urlNotWrappedInQuotes","quote","baseUrl","makeUrlAbsolute","serializeStyleSheets","cssStyleSheets","cssStyleSheet","rules","cssRules","cssRule","disabled","media","serializeDocument","serializationContext","serializeNodeWithId","serializedNode","DOCUMENT_NODE","serializeChildNodes","adoptedStyleSheets","serializeDocumentNode","DOCUMENT_FRAGMENT_NODE","isShadowRoot","shadowRootsController","addShadowRoot","serializeDocumentFragmentNode","DOCUMENT_TYPE_NODE","documentType","publicId","systemId","getValidTagName","isSVG","el","SVGElement","attributes","rr_width","rr_height","safeAttrs","attributeValue","serializeAttribute","formValue","optionElement","selected","stylesheet","styleSheets","getCssRulesString","_cssText","sheet","scrollTop","scrollLeft","checked","mediaElement","rr_mediaState","paused","elementsScrollPositions","rr_scrollLeft","rr_scrollTop","getAttributesForPrivacyLevel","serializeElementNode","serializeTextNode","CDATA_SECTION_NODE","serializeNode","_nextId","serializedNodeWithId","serializeNodeId","setSerializedNodeId","childNode","serializedChildNode","TAG_NAME_REGEX","processedTagName","getCssRuleString","rule","isCSSImportRule","styleSheet","isTouchEvent","changedTouches","assembleIncrementalSnapshot","getPathToNestedCSSRule","currentRule","parentRule","index_1","parentStyleSheet","createMutationBatch","processMutationBatch","cancelScheduledFlush","pendingMutations","addMutations","mutations","opts","requestIdleCallback","id_1","cancelIdleCallback","requestAnimationFrame","cancelAnimationFrame","timeout","startMutationObserver","mutationCallback","mutationBatch","mutation","removedNodes","removedNode","traverseRemovedShadowDom","removeShadowRoot","filteredMutations","nodeAndAncestorsHaveSerializedNode","addedAndMovedNodes","Map","_loop_1","addedNodes","delete","mutations_1","sortedAddedAndMovedNodes","nodes","sort","compareDocumentPosition","DOCUMENT_POSITION_CONTAINED_BY","DOCUMENT_POSITION_CONTAINS","DOCUMENT_POSITION_FOLLOWING","DOCUMENT_POSITION_PRECEDING","addedNodeMutations","sortedAddedAndMovedNodes_1","hasBeenSerialized","nextId","getNextSibling","parentId","removedNodeMutations","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","shadowDomRemovedCallback","convertMouseEventToLayoutCoordinates","normalised","layoutViewportX","layoutViewportY","visualViewportX","visualViewportY","abs","pageTop","offsetTop","scrollY","pageLeft","offsetLeft","scrollX","isVisualViewportFactoredIn","getVisualViewport","getScrollX","pageXOffset","getScrollY","pageYOffset","recordIds","getRecordIdForEvent","initObservers","o","cb","mediaInteractionCb","focusCb","frustrationCb","mutationHandler","mutationCb","mousemoveHandler","updatePosition","getEventTarget","coordinates","tryToComputeCoordinates","timeOffset","initMoveObserver","mousemoveCb","mouseInteractionHandler","handler","interaction","eventTypeToMouseInteraction","record","initMouseInteractionObserver","mouseInteractionCb","scrollHandler","scrollPositions","initScrollObserver","scrollCb","viewportResizeHandler","initViewportResizeObserver","viewportResizeCb","inputHandler","initInputObserver","inputCb","mediaInteractionHandler","styleSheetObserver","checkStyleSheetAndCallback","ownerNode","instrumentationStoppers","CSSStyleSheet","CSSGroupingRule","instrumentGroupingCSSRuleClass","CSSMediaRule","CSSSupportsRule","cls","stopper","initStyleSheetObserver","styleSheetCb","focusHandler","has_focus","visualViewportResizeHandler","cancelThrottle","initVisualViewportResizeObserver","visualViewportResizeCb","frustrationHandler","isFinite","lastInputStateMap","onElementChange","inputState","isChecked","text","cbWithDedup","lastInputState","stopEventListeners","HTMLTextAreaElement","HTMLSelectElement","composed","composedPath","emit","scrollPositionsByElement","scrollingElement","createElementsScrollPositions","controllerByShadowRoot","stopMutationObserver","stopInputObserver","childrenLength","childElementCount","controllerByShadowRootSize","html","innerHTML","substring","initShadowRootsController","takeFullSnapshot","initialOffset","p","mouseInteractionRecord","positions","r","d","frustrationRecord","stopObservers","flushMutationsFromObservers","flushMutations","takeSubsequentFullSnapshot","buildReplayPayload","metadata","rawSegmentBytesCount","formData","FormData","toFormEntries","byteLength","onEntry","prefix","statsPerView","getSegmentsCount","getOrCreateReplayStats","segments_count","addRecord","records_count","segments_total_raw_size","isFirst_1","_value","deleteOldestStats","Segment","worker","creationReason","initialRecord","onWrote","onFlushed","creation_reason","has_full_snapshot","index_in_view","additionalBytesCount","rawBytesCount","compressedBytesCount","segment","postMessage","flushReason","SEGMENT_BYTES_LIMIT","startSegmentCollection","httpRequest","getSegmentContext","nextSegmentCreationReason","unsubscribeViewCreated","flushSegment","unsubscribePageExited","expirationTimeoutId","createNewSegment","compressedSegmentBytesCount","doStartSegmentCollection","computeSegmentContext","startDeflateWorker","createDeflateWorkerImpl","worker_1","onError","doStartDeflateWorker","Event","startRecordingImpl","startDeflateWorkerImpl","NodeList","onRumStart","startStrategy","stopStrategy","stopRecording","makeRecorderApi","replayRequest","stopSegmentCollection","unsubscribeViewEnded","datadogRum","startRumImpl","ignoreInitIfSyntheticsWillInjectRum","isAlreadyInitialized","getInternalContextStrategy","getInitConfigurationStrategy","bufferApiCalls","addTimingStrategy","startViewStrategy","addActionStrategy","addErrorStrategy","providedError","addFeatureFlagEvaluationStrategy","doStartRum","startRumResults","addAction","addFeatureFlagEvaluation","getInternalContext","rumPublicApi","stub","publicApi","onReady","enumerable","makePublicApi","overrideInitConfigurationForBridge","testCookieValue","isCookieCorrectlySet","areCookiesAuthorized","canHandleSession","canInitRum","beforeInitCalls","addRumGlobalContext","setGlobalContextProperty","removeRumGlobalContext","removeGlobalContextProperty","getRumGlobalContext","getGlobalContext","setRumGlobalContext","setGlobalContext","clearGlobalContext","getInitConfiguration","setUser","isValid","checkUser","getUser","setUserProperty","sanitizedProperty","removeUserProperty","removeUser","clearUser","startSessionReplayRecording","stopSessionReplayRecording","makeRumPublicApi","bridge_1","startRumTelemetry","getFeatureFlagBytesCount","currentContext","startFeatureFlagContexts","startRumEventBridge","stopVisibilityChangeListener","stopBeforeUnloadListener","createPageExitObservable","batchFlushObservable","hasFeatureFlagContext","startCustomerDataTelemetry","startRumSessionManagerStub","createDOMMutationObservable","viewContextHistory","buildViewContext","startViewContexts","previousViewUrl","urlContextHistory","viewUrl","buildUrlContext","changeTime","startUrlContexts","startActionCollection","startRumEventCollection","addTelemetryConfiguration","baseSerializedConfiguration","session_sample_rate","telemetry_sample_rate","telemetry_configuration_sample_rate","use_before_send","use_cross_site_session_cookie","use_secure_session_cookie","use_proxy","silent_multiple_init","track_session_across_subdomains","track_resources","track_long_task","serializeConfiguration","premium_sample_rate","replay_sample_rate","session_replay_sample_rate","trace_sample_rate","action_name_attribute","use_allowed_tracing_origins","use_allowed_tracing_urls","selected_tracing_propagators","default_privacy_level","use_excluded_activity_urls","track_frustrations","track_views_manually","track_user_interactions","serializeRumConfiguration","startLongTaskCollection","stateStartTime","persisted","internalContext","application_id","session_id","user_action","startInternalContext","existingGlobalVariable","q","defineGlobal","hasElementType","hasMap","hasSet","hasArrayBuffer","ArrayBuffer","isView","equal","it","valueOf","$$typeof","module","exports","ATTRIBUTE_NAMES","TAG_NAMES","BASE","BODY","HEAD","HTML","LINK","META","NOSCRIPT","SCRIPT","STYLE","TITLE","TAG_PROPERTIES","REACT_TAG_MAP","accesskey","charset","class","contenteditable","contextmenu","itemprop","tabindex","HELMET_PROPS","HTML_TAG_MAP","reduce","obj","SELF_CLOSING_TAGS","HELMET_ATTRIBUTE","_typeof","Symbol","iterator","classCallCheck","instance","Constructor","TypeError","createClass","defineProperties","props","descriptor","writable","protoProps","staticProps","_extends","assign","objectWithoutProperties","possibleConstructorReturn","ReferenceError","encodeSpecialCharacters","getTitleFromPropsList","propsList","innermostTitle","getInnermostProperty","innermostTemplate","innermostDefaultTitle","getOnChangeClientState","getAttributesFromPropsList","tagType","tagAttrs","getBaseTagFromPropsList","primaryAttributes","innermostBaseTag","tag","lowerCaseAttributeKey","getTagsFromPropsList","approvedSeenTags","approvedTags","instanceTags","instanceSeenTags","primaryAttributeKey","attributeKey","tagUnion","rafPolyfill","clock","currentTime","cafPolyfill","webkitRequestAnimationFrame","mozRequestAnimationFrame","g","webkitCancelAnimationFrame","mozCancelAnimationFrame","_helmetCallback","commitTagChanges","newState","baseTag","bodyAttributes","htmlAttributes","linkTags","metaTags","noscriptTags","onChangeClientState","scriptTags","styleTags","title","titleAttributes","updateAttributes","updateTitle","tagUpdates","updateTags","addedTags","removedTags","_tagUpdates$tagType","newTags","oldTags","flattenArray","possibleArray","elementTag","getElementsByTagName","helmetAttributeString","helmetAttributes","attributesToRemove","attributeKeys","attribute","setAttribute","indexToSave","removeAttribute","headElement","tagNodes","indexToDelete","newElement","createTextNode","existingTag","isEqualNode","removeChild","generateElementAttributesAsString","attr","convertElementAttributestoReactProps","initProps","getMethodsForTag","toComponent","_initProps","generateTitleAsReactComponent","attributeString","flattenedTitle","generateTitleAsString","_mappedTag","mappedTag","mappedAttribute","dangerouslySetInnerHTML","__html","generateTagsAsReactComponent","attributeHtml","string","tagContent","isSelfClosing","generateTagsAsString","mapStateOnServer","_ref","_ref$title","link","meta","noscript","script","style","HelmetExport","Component","_class","_temp","_React$Component","HelmetWrapper","subClass","superClass","create","setPrototypeOf","__proto__","inherits","shouldComponentUpdate","nextProps","mapNestedChildrenToProps","nestedChildren","flattenArrayTypeChildren","_babelHelpers$extends","arrayTypeChildren","newChildProps","mapObjectTypeChildren","_ref2","_babelHelpers$extends2","_babelHelpers$extends3","newProps","mapArrayTypeChildrenToProps","newFlattenedProps","arrayChildName","_babelHelpers$extends4","warnOnInvalidChildren","mapChildrenToProps","children","_this2","_child$props","initAttributes","convertReactPropstoHtmlAttributes","render","_props","canUseDOM","propTypes","defaultTitle","defer","titleTemplate","defaultProps","peek","rewind","mappedState","Helmet","renderStatic","React","React__default","_defineProperty","reducePropsToState","handleStateChangeOnClient","WrappedComponent","mountedInstances","emitChange","SideEffect","_PureComponent","recordedState","_proto","UNSAFE_componentWillMount","componentDidUpdate","componentWillUnmount","PureComponent","displayName","getDisplayName"],"sourceRoot":""}