{"version":3,"file":"vendors-480cd651.xxxxxxxx.bundle.js","mappings":"u/BASA,MAAMA,EAAS,KAETC,EAAqB,sBAErBC,EAAwB,wBAqBxBC,EAAwB,KAGxBC,EAAuB,IAQvBC,EAA+B,IAUgE,SAASC,EAAiBC,GAAO,IAAIC,EAA+BC,EAAQF,EAAI,GAAQG,EAAI,EAAG,KAAOA,EAAIH,EAAII,QAAQ,CAAE,MAAMC,EAAKL,EAAIG,GAAUG,EAAKN,EAAIG,EAAI,GAAY,GAARA,GAAK,GAAe,mBAAPE,GAAkC,iBAAPA,IAAmC,MAATH,EAAiB,OAA+B,WAAPG,GAA0B,mBAAPA,GAA2BJ,EAAgBC,EAAOA,EAAQI,EAAGJ,IAA0B,SAAPG,GAAwB,iBAAPA,IAAyBH,EAAQI,EAAG,IAAIC,IAASL,EAAMM,KAAKP,KAAkBM,IAAQN,OAAgBQ,EAAa,CAAE,OAAOP,CAAO,CAAC,IAAIQ,EAa9mB,SAASC,EAAaC,GAClB,MAAMC,EAAOd,EAAiB,CAACa,EAAG,iBAAkBE,GAAKA,EAAED,OAC3D,OAAOE,QAAQhB,EAAiB,CAACc,EAAM,iBAAkBG,GAAMA,EAAGC,eAAiBL,EACvF,CACA,SAASM,EAAkBD,GACvB,MAAsD,wBAA/CE,OAAOC,UAAUC,SAASb,KAAKS,EAC1C,CA2BA,SAASK,EAAoBC,GACzB,IACI,MAAMC,EAAQD,EAAEC,OAASD,EAAEE,SAC3B,OAAOD,IA7B6BE,EA8BKC,MAAMC,KAAKJ,EAAOK,GAAeC,KAAK,KA7BvEC,SAAS,6BAChBL,EAAQK,SAAS,qCAClBL,EAAUA,EAAQM,QAAQ,0BAA2B,2DAElDN,GA0BG,IACV,CACA,MAAOO,GACH,OAAO,IACX,CAnCJ,IAA4CP,CAoC5C,CACA,SAASG,EAAcK,GACnB,IAAIC,EACJ,GAkBJ,SAAyBD,GACrB,MAAO,eAAgBA,CAC3B,CApBQE,CAAgBF,GAChB,IACIC,EACIb,EAAoBY,EAAKG,aAnCzC,SAA+BH,GAC3B,MAAM,QAAER,GAAYQ,EACpB,GAAIR,EAAQY,MAAM,KAAKlC,OAAS,EAC5B,OAAOsB,EACX,MAAMa,EAAY,CAAC,UAAW,OAAOC,KAAKC,UAAUP,EAAKQ,UAazD,MAZuB,KAAnBR,EAAKS,UACLJ,EAAUK,KAAK,SAEVV,EAAKS,WACVJ,EAAUK,KAAK,SAASV,EAAKS,cAE7BT,EAAKW,cACLN,EAAUK,KAAK,YAAYV,EAAKW,iBAEhCX,EAAKY,MAAM1C,QACXmC,EAAUK,KAAKV,EAAKY,MAAMC,WAEvBR,EAAUT,KAAK,KAAO,GACjC,CAkBoBkB,CAAsBd,EAClC,CACA,MAAOD,GACP,MAEC,GAYT,SAAwBC,GACpB,MAAO,iBAAkBA,CAC7B,CAdae,CAAef,IAASA,EAAKgB,aAAanB,SAAS,KACxD,OAAuBG,EAAKR,QAMVM,QADR,uCACuB,UAJrC,OAAOG,GAAqBD,EAAKR,OACrC,EAvEA,SAAWyB,GACPA,EAASA,EAAmB,SAAI,GAAK,WACrCA,EAASA,EAAuB,aAAI,GAAK,eACzCA,EAASA,EAAkB,QAAI,GAAK,UACpCA,EAASA,EAAe,KAAI,GAAK,OACjCA,EAASA,EAAgB,MAAI,GAAK,QAClCA,EAASA,EAAkB,QAAI,GAAK,SACvC,CAPD,CAOGzC,IAAeA,EAAa,CAAC,IA2EhC,MAAM0C,EACF,WAAAC,GACIC,KAAKC,UAAY,IAAIC,IACrBF,KAAKG,YAAc,IAAIC,OAC3B,CACA,KAAAC,CAAM/C,GACF,IAAKA,EACD,OAAQ,EAEZ,OA5F6C,OAAzBgD,EA2FT7D,EAAiB,CAACuD,KAAM,SAAUO,GAAMA,EAAGC,QAAS,OAAQC,GAAMA,EAAGnD,GAAI,iBAAkBoD,GAAMA,EAAGC,MA3FnDL,GA4FrB,EA5F/C,IAA4BA,CA6FxB,CACA,OAAAM,CAAQD,GACJ,OAAOX,KAAKC,UAAUY,IAAIF,IAAO,IACrC,CACA,MAAAG,GACI,OAAOzC,MAAMC,KAAK0B,KAAKC,UAAUc,OACrC,CACA,OAAAP,CAAQlD,GACJ,OAAO0C,KAAKG,YAAYU,IAAIvD,IAAM,IACtC,CACA,iBAAA0D,CAAkB1D,GACd,MAAMqD,EAAKX,KAAKK,MAAM/C,GACtB0C,KAAKC,UAAUgB,OAAON,GAClBrD,EAAE4D,YACF5D,EAAE4D,WAAWC,QAASC,GAAcpB,KAAKgB,kBAAkBI,GAEnE,CACA,GAAAC,CAAIV,GACA,OAAOX,KAAKC,UAAUoB,IAAIV,EAC9B,CACA,OAAAW,CAAQC,GACJ,OAAOvB,KAAKG,YAAYkB,IAAIE,EAChC,CACA,GAAAC,CAAIlE,EAAGmE,GACH,MAAMd,EAAKc,EAAKd,GAChBX,KAAKC,UAAUyB,IAAIf,EAAIrD,GACvB0C,KAAKG,YAAYuB,IAAIpE,EAAGmE,EAC5B,CACA,OAAA/C,CAAQiC,EAAIrD,GACR,MAAMqE,EAAU3B,KAAKY,QAAQD,GAC7B,GAAIgB,EAAS,CACT,MAAMF,EAAOzB,KAAKG,YAAYU,IAAIc,GAC9BF,GACAzB,KAAKG,YAAYuB,IAAIpE,EAAGmE,EAChC,CACAzB,KAAKC,UAAUyB,IAAIf,EAAIrD,EAC3B,CACA,KAAAsE,GACI5B,KAAKC,UAAY,IAAIC,IACrBF,KAAKG,YAAc,IAAIC,OAC3B,EAKJ,SAASyB,GAAgB,iBAAEC,EAAgB,QAAEC,EAAO,KAAEC,IAIlD,MAHgB,WAAZD,IACAA,EAAU,UAEPtE,QAAQqE,EAAiBC,EAAQE,gBACnCD,GAAQF,EAAiBE,IACjB,aAATA,GACa,UAAZD,IAAwBC,GAAQF,EAAuB,KAChE,CACA,SAASI,GAAe,SAAEC,EAAQ,QAAEC,EAAO,MAAExF,EAAK,YAAEyF,IAChD,IAAIC,EAAO1F,GAAS,GACpB,OAAKuF,GAGDE,IACAC,EAAOD,EAAYC,EAAMF,IAEtB,IAAIG,OAAOD,EAAKxF,SALZwF,CAMf,CACA,SAASL,EAAYO,GACjB,OAAOA,EAAIP,aACf,CACA,SAASQ,EAAYD,GACjB,OAAOA,EAAIC,aACf,CACA,MAAMC,EAA0B,qBAmBhC,SAASC,EAAaP,GAClB,MAAMJ,EAAOI,EAAQJ,KACrB,OAAOI,EAAQQ,aAAa,uBACtB,WACAZ,EAEMC,EAAYD,GACd,IACd,CACA,SAASa,EAAcC,EAAIf,EAASC,GAChC,MAAgB,UAAZD,GAAiC,UAATC,GAA6B,aAATA,EAGzCc,EAAGlG,MAFCkG,EAAGC,aAAa,UAAY,EAG3C,CAEA,IAAIC,EAAM,EACV,MAAMC,EAAe,IAAIC,OAAO,gBAEhC,SAASC,IACL,OAAOH,GACX,CAsBA,IAAII,EACAC,EACJ,MAAMC,EAAiB,6CACjBC,GAAqB,sBACrBC,GAAgB,YAChBC,GAAW,wBACjB,SAASC,GAAqBtF,EAASgB,GACnC,OAAQhB,GAAW,IAAIM,QAAQ4E,EAAgB,CAACK,EAAQC,EAAQC,EAAOC,EAAQC,EAAOC,KAClF,MAAMC,EAAWJ,GAASE,GAASC,EAC7BE,EAAaN,GAAUE,GAAU,GACvC,IAAKG,EACD,OAAON,EAEX,GAAIJ,GAAmBY,KAAKF,IAAaT,GAAcW,KAAKF,GACxD,MAAO,OAAOC,IAAaD,IAAWC,KAE1C,GAAIT,GAASU,KAAKF,GACd,MAAO,OAAOC,IAAaD,IAAWC,KAE1C,GAAoB,MAAhBD,EAAS,GACT,MAAO,OAAOC,IA/B1B,SAAuBE,GACnB,IAAIT,EAAS,GAQb,OANIA,EADAS,EAAIC,QAAQ,OAAS,EACZD,EAAIpF,MAAM,KAAKsF,MAAM,EAAG,GAAG9F,KAAK,KAGhC4F,EAAIpF,MAAM,KAAK,GAE5B2E,EAASA,EAAO3E,MAAM,KAAK,GACpB2E,CACX,CAqBuCY,CAAcnF,GAAQ6E,IAAWC,KAEhE,MAAMM,EAAQpF,EAAKJ,MAAM,KACnByF,EAAQR,EAASjF,MAAM,KAC7BwF,EAAME,MACN,IAAK,MAAMC,KAAQF,EACF,MAATE,IAGc,OAATA,EACLH,EAAME,MAGNF,EAAMlF,KAAKqF,IAGnB,MAAO,OAAOT,IAAaM,EAAMhG,KAAK,OAAO0F,MAErD,CACA,MAAMU,GAAoB,qBACpBC,GAA0B,qBA2DhC,SAASC,GAAcC,EAAKC,GACxB,IAAKA,GAA4C,KAA1BA,EAAeC,OAClC,OAAOD,EAEX,MAAME,EAAIH,EAAII,cAAc,KAE5B,OADAD,EAAE9F,KAAO4F,EACFE,EAAE9F,IACb,CAIA,SAASgG,KACL,MAAMF,EAAIG,SAASF,cAAc,KAEjC,OADAD,EAAE9F,KAAO,GACF8F,EAAE9F,IACb,CACA,SAASkG,GAAmBP,EAAKhD,EAASwD,EAAM3I,EAAOwF,EAASoD,GAC5D,OAAK5I,EAGQ,QAAT2I,GACU,SAATA,IAAiC,QAAZxD,GAAkC,MAAbnF,EAAM,KAGnC,eAAT2I,GAAsC,MAAb3I,EAAM,GAF7BkI,GAAcC,EAAKnI,GAKZ,eAAT2I,GACQ,UAAZxD,GAAmC,OAAZA,GAAgC,OAAZA,EAG9B,WAATwD,EAzFb,SAAiCR,EAAKC,GAClC,GAA8B,KAA1BA,EAAeC,OACf,OAAOD,EAEX,IAAIS,EAAM,EACV,SAASC,EAAkBC,GACvB,IAAIC,EACJ,MAAMC,EAAQF,EAAMG,KAAKd,EAAee,UAAUN,IAClD,OAAII,GACAD,EAAQC,EAAM,GACdJ,GAAOG,EAAM9I,OACN8I,GAEJ,EACX,CACA,MAAMI,EAAS,GACf,KACIN,EAAkBb,MACdY,GAAOT,EAAelI,SAFjB,CAKT,IAAIsH,EAAMsB,EAAkBd,IAC5B,GAAsB,MAAlBR,EAAIE,OAAO,GACXF,EAAMU,GAAcC,EAAKX,EAAI2B,UAAU,EAAG3B,EAAItH,OAAS,IACvDkJ,EAAO1G,KAAK8E,OAEX,CACD,IAAI6B,EAAiB,GACrB7B,EAAMU,GAAcC,EAAKX,GACzB,IAAI8B,GAAW,EACf,OAAa,CACT,MAAMC,EAAInB,EAAeoB,OAAOX,GAChC,GAAU,KAANU,EAAU,CACVH,EAAO1G,MAAM8E,EAAM6B,GAAgBhB,QACnC,KACJ,CACK,GAAKiB,EAWI,MAANC,IACAD,GAAW,OAZC,CAChB,GAAU,MAANC,EAAW,CACXV,GAAO,EACPO,EAAO1G,MAAM8E,EAAM6B,GAAgBhB,QACnC,KACJ,CACe,MAANkB,IACLD,GAAW,EAEnB,CAMAD,GAAkBE,EAClBV,GAAO,CACX,CACJ,CACJ,CACA,OAAOO,EAAOxH,KAAK,KACvB,CAiCe6H,CAAwBtB,EAAKnI,GAEtB,UAAT2I,EACE7B,GAAqB9G,EAAOwI,MAElB,WAAZrD,GAAiC,SAATwD,EACtBT,GAAcC,EAAKnI,GAEC,mBAApB4I,EACAA,EAAgBD,EAAM3I,EAAOwF,GAEjCxF,EAdIkI,GAAcC,EAAKnI,GAXnBA,CA0Bf,CACA,SAAS0J,GAAgBvE,EAASwD,EAAMgB,GACpC,OAAoB,UAAZxE,GAAmC,UAAZA,IAAiC,aAATwD,CAC3D,CAoCA,SAASiB,GAAgBjF,EAAMkF,EAAgBC,EAAQC,IAAUC,EAAW,GACxE,OAAKrF,EAEDA,EAAKsF,WAAatF,EAAKuF,cAEvBF,EAAWF,GADH,EAGRD,EAAelF,GACRqF,EACJJ,GAAgBjF,EAAKwF,WAAYN,EAAgBC,EAAOE,EAAW,IAP9D,CAQhB,CACA,SAASI,GAAqBC,EAAWC,GACrC,OAAQ3F,IACJ,MAAMuB,EAAKvB,EACX,GAAW,OAAPuB,EACA,OAAO,EACX,IACI,GAAImE,EACA,GAAyB,iBAAdA,GACP,GAAInE,EAAGqE,QAAQ,IAAIF,KACf,OAAO,OAEV,GA/BrB,SAAkCnE,EAAIsE,GAClC,IAAK,IAAIC,EAASvE,EAAGwE,UAAUxK,OAAQuK,KAAW,CAC9C,MAAMJ,EAAYnE,EAAGwE,UAAUD,GAC/B,GAAID,EAAMjD,KAAK8C,GACX,OAAO,CAEf,CACA,OAAO,CACX,CAuByBM,CAAyBzE,EAAImE,GAClC,OAAO,EAGf,SAAIC,IAAYpE,EAAGqE,QAAQD,GAG/B,CACA,MAAOM,GACH,OAAO,CACX,EAER,CACA,SAASC,GAAgBlG,EAAMmG,EAAeC,EAAkBC,EAAiBC,EAAoBC,GACjG,IACI,MAAMhF,EAAKvB,EAAKsF,WAAatF,EAAKuF,aAC5BvF,EACAA,EAAKwG,cACX,GAAW,OAAPjF,EACA,OAAO,EACX,GAAmB,UAAfA,EAAGf,QAAqB,CACxB,MAAMiG,EAAelF,EAAGC,aAAa,gBAUrC,GATqC,CACjC,mBACA,eACA,YACA,SACA,eACA,cACA,UAE6BtE,SAASuJ,GACtC,OAAO,CAEf,CACA,IAAIC,GAAgB,EAChBC,GAAkB,EACtB,GAAIJ,EAAa,CAEb,GADAI,EAAiB1B,GAAgB1D,EAAIkE,GAAqBY,EAAiBC,IACvEK,EAAiB,EACjB,OAAO,EAEXD,EAAezB,GAAgB1D,EAAIkE,GAAqBU,EAAeC,GAAmBO,GAAkB,EAAIA,EAAiBvB,IACrI,KACK,CAED,GADAsB,EAAezB,GAAgB1D,EAAIkE,GAAqBU,EAAeC,IACnEM,EAAe,EACf,OAAO,EAEXC,EAAiB1B,GAAgB1D,EAAIkE,GAAqBY,EAAiBC,GAAqBI,GAAgB,EAAIA,EAAetB,IACvI,CACA,OAAOsB,GAAgB,IACjBC,GAAkB,IACdD,GAAgBC,IAEpBA,GAAkB,IAEZJ,EAChB,CACA,MAAOK,GACP,CACA,QAASL,CACb,CAkWA,SAASM,GAAcC,GACnB,OAAIA,QACO,GAGAA,EAAUpG,aAEzB,CAyEA,SAASqG,GAAoBhL,EAAGiL,GAC5B,MAAM,IAAExD,EAAG,OAAEyD,EAAM,WAAEC,EAAU,cAAEC,EAAa,gBAAEC,EAAe,YAAEb,EAAW,cAAEJ,EAAa,gBAAEE,EAAe,iBAAED,EAAgB,mBAAEE,EAAkB,UAAEe,GAAY,EAAK,iBAAEC,GAAmB,EAAI,iBAAE/G,EAAmB,CAAC,EAAC,gBAAE0D,EAAe,WAAEsD,EAAU,YAAEzG,EAAW,eAAE0G,EAAc,eAAEC,EAAiB,CAAC,EAAC,aAAEC,GAAe,EAAK,aAAEC,GAAe,EAAK,YAAEC,EAAW,aAAEC,EAAY,kBAAEC,EAAoB,IAAI,iBAAEC,EAAgB,sBAAEC,EAAwB,IAAI,gBAAEC,EAAkB,KAAM,EAAK,kBAAEC,GAAoB,GAAWlB,EACrf,IAAI,mBAAEmB,GAAqB,GAASnB,EACpC,MAAMoB,EAzXV,SAAuBrM,EAAGiL,GACtB,MAAM,IAAExD,EAAG,OAAEyD,EAAM,WAAEC,EAAU,cAAEC,EAAa,gBAAEC,EAAe,YAAEb,EAAW,gBAAEtC,EAAe,cAAEkC,EAAa,gBAAEE,EAAe,iBAAED,EAAgB,mBAAEE,EAAkB,iBAAEgB,EAAgB,iBAAE/G,EAAmB,CAAC,EAAC,WAAEgH,EAAU,YAAEzG,EAAW,eAAE2G,EAAiB,CAAC,EAAC,aAAEC,EAAY,aAAEC,EAAY,gBAAEM,EAAe,kBAAEC,GAAoB,GAAWlB,EAClUqB,EA0EV,SAAmB7E,EAAKyD,GACpB,IAAKA,EAAOlH,QAAQyD,GAChB,OACJ,MAAM8E,EAAQrB,EAAOnI,MAAM0E,GAC3B,OAAiB,IAAV8E,OAAc1M,EAAY0M,CACrC,CA/EmBC,CAAU/E,EAAKyD,GAC9B,OAAQlL,EAAEuJ,UACN,KAAKvJ,EAAEyM,cACH,MAAqB,eAAjBzM,EAAE0M,WACK,CACHhI,KAAM5E,EAAW6M,SACjB/I,WAAY,GACZ8I,WAAY1M,EAAE0M,YAIX,CACHhI,KAAM5E,EAAW6M,SACjB/I,WAAY,IAGxB,KAAK5D,EAAE4M,mBACH,MAAO,CACHlI,KAAM5E,EAAW+M,aACjB5E,KAAMjI,EAAEiI,KACR6E,SAAU9M,EAAE8M,SACZC,SAAU/M,EAAE+M,SACZT,UAER,KAAKtM,EAAEwJ,aACH,OA6GZ,SAA8BxJ,EAAGiL,GAC7B,MAAM,IAAExD,EAAG,WAAE0D,EAAU,cAAEC,EAAa,gBAAEC,EAAe,iBAAEE,EAAgB,iBAAE/G,EAAmB,CAAC,EAAC,gBAAE0D,EAAe,YAAEnD,EAAW,eAAE2G,EAAiB,CAAC,EAAC,aAAEC,EAAY,aAAEC,EAAY,gBAAEM,EAAe,kBAAEC,GAAoB,EAAK,OAAEG,EAAM,YAAE9B,EAAW,cAAEJ,EAAa,gBAAEE,EAAe,iBAAED,EAAgB,mBAAEE,GAAwBU,EACtT+B,EA7TV,SAA2BlI,EAASqG,EAAYC,EAAeC,GAC3D,IACI,GAAIA,GAAmBvG,EAAQ+E,QAAQwB,GACnC,OAAO,EAEX,GAA0B,iBAAfF,GACP,GAAIrG,EAAQkF,UAAUiD,SAAS9B,GAC3B,OAAO,OAIX,IAAK,IAAIpB,EAASjF,EAAQkF,UAAUxK,OAAQuK,KAAW,CACnD,MAAMJ,EAAY7E,EAAQkF,UAAUD,GACpC,GAAIoB,EAAWtE,KAAK8C,GAChB,OAAO,CAEf,CAEJ,GAAIyB,EACA,OAAOtG,EAAQ+E,QAAQuB,EAE/B,CACA,MAAOP,GACP,CACA,OAAO,CACX,CAoSsBqC,CAAkBlN,EAAGmL,EAAYC,EAAeC,GAC5D5G,EAteV,SAAyBK,GACrB,GAAIA,aAAmBqI,gBACnB,MAAO,OAEX,MAAMC,EAAmBzI,EAAYG,EAAQL,SAC7C,OAAIkB,EAAakB,KAAKuG,GACX,MAEJA,CACX,CA6doBC,CAAgBrN,GAChC,IAAIsN,EAAa,CAAC,EAClB,MAAMC,EAAMvN,EAAEsN,WAAW9N,OACzB,IAAK,IAAID,EAAI,EAAGA,EAAIgO,EAAKhO,IAAK,CAC1B,MAAMiO,EAAOxN,EAAEsN,WAAW/N,GACtBiO,EAAKvF,OAASe,GAAgBvE,EAAS+I,EAAKvF,KAAMuF,EAAKlO,SACvDgO,EAAWE,EAAKvF,MAAQD,GAAmBP,EAAKhD,EAASE,EAAY6I,EAAKvF,MAAOuF,EAAKlO,MAAOU,EAAGkI,GAExG,CACA,GAAgB,SAAZzD,GAAsB8G,EAAkB,CACxC,MAAMkC,EAAa1M,MAAMC,KAAKyG,EAAIiG,aAAaC,KAAMhN,GAC1CA,EAAEmB,OAAS9B,EAAE8B,MAExB,IAAIhB,EAAU,KACV2M,IACA3M,EAAUJ,EAAoB+M,IAE9B3M,WACOwM,EAAWM,WACXN,EAAWxL,KAClBwL,EAAWO,SAAWzH,GAAqBtF,EAAS2M,EAAW3L,MAEvE,CACA,GAAgB,UAAZ2C,GACAzE,EAAE8N,SACA9N,EAAE+N,WAAa/N,EAAEgO,aAAe,IAAIrG,OAAOnI,OAAQ,CACrD,MAAMsB,EAAUJ,EAAoBV,EAAE8N,OAClChN,IACAwM,EAAWO,SAAWzH,GAAqBtF,EAASgH,MAE5D,CACA,GAAgB,UAAZrD,GACY,aAAZA,GACY,WAAZA,GACY,WAAZA,EAAsB,CACtB,MAAMe,EAAKxF,EACL0E,EAAOW,EAAaG,GACpBlG,EAAQiG,EAAcC,EAAIL,EAAYV,GAAUC,GAChDuJ,EAAUzI,EAAGyI,QACnB,GAAa,WAATvJ,GAA8B,WAATA,GAAqBpF,EAAO,CACjD,MAAM4O,EAAY/D,GAAgB3E,EAAI4E,EAAeC,EAAkBC,EAAiBC,EAAoBhG,EAAgB,CACxHG,OACAD,QAASU,EAAYV,GACrBD,sBAEJ8I,EAAWhO,MAAQsF,EAAe,CAC9BC,SAAUqJ,EACVpJ,QAASU,EACTlG,QACAyF,eAER,CACIkJ,IACAX,EAAWW,QAAUA,EAE7B,CASA,GARgB,WAAZxJ,IACIzE,EAAEmO,WAAa3J,EAAyB,OACxC8I,EAAWa,UAAW,SAGfb,EAAWa,UAGV,WAAZ1J,GAAwBmH,EACxB,GAAoB,OAAhB5L,EAAEoO,WA/kBd,SAAyBC,GACrB,MAAMC,EAAMD,EAAOE,WAAW,MAC9B,IAAKD,EACD,OAAO,EAEX,IAAK,IAAIE,EAAI,EAAGA,EAAIH,EAAOI,MAAOD,GADhB,GAEd,IAAK,IAAIE,EAAI,EAAGA,EAAIL,EAAOM,OAAQD,GAFrB,GAEqC,CAC/C,MAAME,EAAeN,EAAIM,aACnBC,EAAuBzJ,KAA2BwJ,EAClDA,EAAaxJ,GACbwJ,EAEN,GADoB,IAAIE,YAAYD,EAAqBjP,KAAK0O,EAAKE,EAAGE,EAAGK,KAAKC,IAPpE,GAOmFX,EAAOI,MAAQD,GAAIO,KAAKC,IAP3G,GAO0HX,EAAOM,OAASD,IAAIO,KAAKC,QAC7IC,KAAMC,GAAoB,IAAVA,GAC5B,OAAO,CACf,CAEJ,OAAO,CACX,EA+jBiBC,CAAgBrP,KACjBsN,EAAWgC,WAAatP,EAAEuP,UAAU7D,EAAehH,KAAMgH,EAAe8D,eAG3E,KAAM,cAAexP,GAAI,CAC1B,MAAMyP,EAAgBzP,EAAEuP,UAAU7D,EAAehH,KAAMgH,EAAe8D,SAChEE,EAAc3H,SAASF,cAAc,UAC3C6H,EAAYjB,MAAQzO,EAAEyO,MACtBiB,EAAYf,OAAS3O,EAAE2O,OAEnBc,IADuBC,EAAYH,UAAU7D,EAAehH,KAAMgH,EAAe8D,WAEjFlC,EAAWgC,WAAaG,EAEhC,CAEJ,GAAgB,QAAZhL,GAAqBkH,EAAc,CAC9B7F,IACDA,EAAgB2B,EAAII,cAAc,UAClC9B,EAAYD,EAAcyI,WAAW,OAEzC,MAAMoB,EAAQ3P,EACR4P,EAAWD,EAAME,YACvBF,EAAME,YAAc,YACpB,MAAMC,EAAoB,KACtBH,EAAMI,oBAAoB,OAAQD,GAClC,IACIhK,EAAc2I,MAAQkB,EAAMK,aAC5BlK,EAAc6I,OAASgB,EAAMM,cAC7BlK,EAAUmK,UAAUP,EAAO,EAAG,GAC9BrC,EAAWgC,WAAaxJ,EAAcyJ,UAAU7D,EAAehH,KAAMgH,EAAe8D,QACxF,CACA,MAAOW,GACHC,QAAQC,KAAK,yBAAyBV,EAAMW,sBAAsBH,IACtE,CACAP,EACOtC,EAAWuC,YAAcD,EAC1BD,EAAMY,gBAAgB,gBAE5BZ,EAAMa,UAAmC,IAAvBb,EAAMK,aACxBF,IAEAH,EAAMc,iBAAiB,OAAQX,EACvC,CAeA,GAdgB,UAAZrL,GAAmC,UAAZA,IACvB6I,EAAWoD,cAAgB1Q,EAAE2Q,OACvB,SACA,SACNrD,EAAWsD,oBAAsB5Q,EAAE6Q,aAElC1E,IACGnM,EAAE8Q,aACFxD,EAAWyD,cAAgB/Q,EAAE8Q,YAE7B9Q,EAAEgR,YACF1D,EAAW2D,aAAejR,EAAEgR,YAGhChE,EAAW,CACX,MAAM,MAAEyB,EAAK,OAAEE,GAAW3O,EAAEkR,wBAC5B5D,EAAa,CACT6D,MAAO7D,EAAW6D,MAClBC,SAAU,GAAG3C,MACb4C,UAAW,GAAG1C,MAEtB,CAOA,IAAI2C,EANY,WAAZ7M,GAAyByH,EAAgBoB,EAAWiE,OAC/CvR,EAAEwR,kBACHlE,EAAWmE,OAASnE,EAAWiE,YAE5BjE,EAAWiE,KAGtB,IACQG,eAAenO,IAAIkB,KACnB6M,GAAkB,EAC1B,CACA,MAAOzG,GACP,CACA,MAAO,CACHnG,KAAM5E,EAAW6R,QACjBlN,UACA6I,aACA1J,WAAY,GACZgO,OA3fcpM,EA2fMxF,EA1fjBG,QAAuB,QAAfqF,EAAGf,SAAqBe,EAAGqM,uBA0fZhS,GAC1BmN,YACAV,SACAwF,SAAUR,GA9flB,IAAsB9L,CAggBtB,CA1QmBuM,CAAqB/R,EAAG,CAC3ByH,MACA0D,aACAC,gBACAC,kBACAE,mBACArD,kBACA1D,mBACAO,cACA2G,iBACAC,eACAC,eACAM,kBACAC,oBACAG,SACA9B,cACAJ,gBACAE,kBACAD,mBACAE,uBAER,KAAKvK,EAAEgS,UACH,OAiCZ,SAA2BhS,EAAGiL,GAC1B,MAAM,YAAET,EAAW,cAAEJ,EAAa,gBAAEE,EAAe,iBAAED,EAAgB,mBAAEE,EAAkB,WAAEiB,EAAU,iBAAEhH,EAAgB,YAAEO,EAAW,OAAEuH,GAAYrB,EAC5IgH,EAAgBjS,EAAEyJ,YAAczJ,EAAEyJ,WAAWhF,QACnD,IAAIuJ,EAAchO,EAAEgO,YACpB,MAAMkE,EAA4B,UAAlBD,QAAmCpS,EAC7CsS,EAA6B,WAAlBF,QAAoCpS,EAC/CuS,EAA+B,aAAlBH,QAAsCpS,EACzD,GAAIqS,GAAWlE,EAAa,CACxB,IACQhO,EAAEqS,aAAerS,EAAEsS,iBAEdnT,EAAiB,CAACa,EAAG,SAAUuS,GAAMA,EAAG9I,WAAY,SAAU+I,GAAMA,EAAG1E,MAAO,iBAAkB2E,GAAMA,EAAG5R,aAC9GmN,EAActN,EAAoBV,EAAEyJ,WAAWqE,OAEvD,CACA,MAAOqC,GACHC,QAAQC,KAAK,wDAAwDF,IAAOnQ,EAChF,CACAgO,EAAc5H,GAAqB4H,EAAalG,KACpD,CACIqK,IACAnE,EAAc,sBAElB,MAAME,EAAY/D,GAAgBnK,EAAGoK,EAAeC,EAAkBC,EAAiBC,EAAoBC,GAwB3G,OAvBK0H,GAAYC,GAAaC,IAAcpE,IAAeE,IACvDF,EAAcxC,EACRA,EAAWwC,EAAahO,EAAEyK,eAC1BuD,EAAY5M,QAAQ,QAAS,MAEnCgR,GAAcpE,IAAgBxJ,EAAiBkO,UAAYxE,KAC3DF,EAAcjJ,EACRA,EAAYiJ,EAAahO,EAAEyJ,YAC3BuE,EAAY5M,QAAQ,QAAS,MAEjB,WAAlB6Q,GAA8BjE,IAM9BA,EAAcpJ,EAAe,CACzBC,SAAUsF,GAAgBnK,EAAGoK,EAAeC,EAAkBC,EAAiBC,EAN7DhG,EAAgB,CAClCG,KAAM,KACND,QAASwN,EACTzN,sBAIAM,QAAS9E,EACTV,MAAO0O,EACPjJ,iBAGD,CACHL,KAAM5E,EAAW6S,KACjB3E,YAAaA,GAAe,GAC5BkE,UACA5F,SAER,CAtFmBsG,CAAkB5S,EAAG,CACxBwK,cACAJ,gBACAE,kBACAD,mBACAE,qBACAiB,aACAhH,mBACAO,cACAuH,WAER,KAAKtM,EAAE6S,mBACH,MAAO,CACHnO,KAAM5E,EAAWgT,MACjB9E,YAAa,GACb1B,UAER,KAAKtM,EAAE+S,aACH,MAAO,CACHrO,KAAM5E,EAAWkT,QACjBhF,YAAahO,EAAEgO,aAAe,GAC9B1B,UAER,QACI,OAAO,EAEnB,CA8S4B2G,CAAcjT,EAAG,CACrCyH,MACAyD,SACAC,aACAC,gBACAZ,cACAa,kBACAjB,gBACAE,kBACAD,mBACAE,qBACAgB,mBACA/G,mBACA0D,kBACAsD,aACAzG,cACA2G,iBACAC,eACAC,eACAM,kBACAC,sBAEJ,IAAKE,EAED,OADA+D,QAAQC,KAAKrQ,EAAG,kBACT,KAEX,IAAIqD,EAEAA,EADA6H,EAAOlH,QAAQhE,GACVkL,EAAOnI,MAAM/C,IAvG1B,SAAyBkT,EAAIzH,GACzB,GAAIA,EAAe0H,SAAWD,EAAGxO,OAAS5E,EAAWkT,QACjD,OAAO,EAEN,GAAIE,EAAGxO,OAAS5E,EAAW6R,QAAS,CACrC,GAAIlG,EAAe2H,SACC,WAAfF,EAAGzO,SACgB,SAAfyO,EAAGzO,UACuB,YAAtByO,EAAG5F,WAAWM,KACW,kBAAtBsF,EAAG5F,WAAWM,MACG,WAArBsF,EAAG5F,WAAW+F,IACF,SAAfH,EAAGzO,SACsB,aAAtByO,EAAG5F,WAAWM,KACgB,iBAAvBsF,EAAG5F,WAAWxL,MACrBoR,EAAG5F,WAAWxL,KAAKwR,SAAS,QACpC,OAAO,EAEN,GAAI7H,EAAe8H,cACH,SAAfL,EAAGzO,SAA4C,kBAAtByO,EAAG5F,WAAWM,KACrB,SAAfsF,EAAGzO,UACCqG,GAAcoI,EAAG5F,WAAWrF,MAAMM,MAAM,sCACC,qBAAtCuC,GAAcoI,EAAG5F,WAAWrF,OACS,SAArC6C,GAAcoI,EAAG5F,WAAWM,MACS,qBAArC9C,GAAcoI,EAAG5F,WAAWM,MACS,kBAArC9C,GAAcoI,EAAG5F,WAAWM,OACxC,OAAO,EAEN,GAAmB,SAAfsF,EAAGzO,QAAoB,CAC5B,GAAIgH,EAAe+H,sBACf1I,GAAcoI,EAAG5F,WAAWrF,MAAMM,MAAM,0BACxC,OAAO,EAEN,GAAIkD,EAAegI,iBACnB3I,GAAcoI,EAAG5F,WAAWoG,UAAUnL,MAAM,sBACzCuC,GAAcoI,EAAG5F,WAAWrF,MAAMM,MAAM,mBACF,cAAtCuC,GAAcoI,EAAG5F,WAAWrF,OAChC,OAAO,EAEN,GAAIwD,EAAekI,iBACmB,WAAtC7I,GAAcoI,EAAG5F,WAAWrF,OACa,cAAtC6C,GAAcoI,EAAG5F,WAAWrF,OACU,YAAtC6C,GAAcoI,EAAG5F,WAAWrF,OAChC,OAAO,EAEN,GAAIwD,EAAemI,wBACY/T,IAAhCqT,EAAG5F,WAAW,cACd,OAAO,EAEN,GAAI7B,EAAeoI,qBACmB,WAAtC/I,GAAcoI,EAAG5F,WAAWrF,OACa,cAAtC6C,GAAcoI,EAAG5F,WAAWrF,OACU,cAAtC6C,GAAcoI,EAAG5F,WAAWrF,OACU,cAAtC6C,GAAcoI,EAAG5F,WAAWrF,OACU,WAAtC6C,GAAcoI,EAAG5F,WAAWrF,OAC5B6C,GAAcoI,EAAG5F,WAAWoG,UAAUnL,MAAM,cAC5CuC,GAAcoI,EAAG5F,WAAWoG,UAAUnL,MAAM,cAChD,OAAO,EAEN,GAAIkD,EAAeqI,uBACmB,6BAAtChJ,GAAcoI,EAAG5F,WAAWrF,OACa,wBAAtC6C,GAAcoI,EAAG5F,WAAWrF,OACU,eAAtC6C,GAAcoI,EAAG5F,WAAWrF,OACU,oBAAtC6C,GAAcoI,EAAG5F,WAAWrF,OACU,cAAtC6C,GAAcoI,EAAG5F,WAAWrF,OACU,iBAAtC6C,GAAcoI,EAAG5F,WAAWrF,OACU,+BAAtC6C,GAAcoI,EAAG5F,WAAWrF,OAChC,OAAO,CAEf,CACJ,CACA,OAAO,CACX,CAkCa8L,CAAgB1H,EAAiBZ,KACpCW,GACEC,EAAgB3H,OAAS5E,EAAW6S,MACnCtG,EAAgB6F,SAChB7F,EAAgB2B,YAAY5M,QAAQ,cAAe,IAAI5B,QAIvDqG,KA9vBQ,EAgwBjB,MAAMmO,EAAiBzT,OAAO0T,OAAO5H,EAAiB,CAAEhJ,OAExD,GADA6H,EAAOhH,IAAIlE,EAAGgU,IAjwBG,IAkwBb3Q,EACA,OAAO,KAEPwI,GACAA,EAAY7L,GAEhB,IAAIkU,GAAe5I,EACnB,GAAI0I,EAAetP,OAAS5E,EAAW6R,QAAS,CAC5CuC,EAAcA,IAAgBF,EAAehH,iBACtCgH,EAAehH,UACtB,MAAM3M,EAAaL,EAAEK,WACjBA,GAAcC,EAAkBD,KAChC2T,EAAeG,cAAe,EACtC,CACA,IAAKH,EAAetP,OAAS5E,EAAW6M,UACpCqH,EAAetP,OAAS5E,EAAW6R,UACnCuC,EAAa,CACTzI,EAAe2I,gBACfJ,EAAetP,OAAS5E,EAAW6R,SACR,SAA3BqC,EAAevP,UACf2H,GAAqB,GAEzB,MAAMiI,EAAgB,CAClB5M,MACAyD,SACAC,aACAC,gBACAZ,cACAa,kBACAjB,gBACAE,kBACAD,mBACAE,qBACAe,YACAC,mBACA/G,mBACA0D,kBACAsD,aACAzG,cACA0G,iBACAC,iBACAC,eACAC,eACAQ,qBACAP,cACAC,eACAC,oBACAC,mBACAC,wBACAC,mBAEJ,IAAK,MAAMoI,KAAUvT,MAAMC,KAAKhB,EAAE4D,YAAa,CAC3C,MAAM2Q,EAAsBvJ,GAAoBsJ,EAAQD,GACpDE,GACAP,EAAepQ,WAAW5B,KAAKuS,EAEvC,CACA,GAz/BR,SAAqBvU,GACjB,OAAOA,EAAEuJ,WAAavJ,EAAEwJ,YAC5B,CAu/BYgL,CAAYxU,IAAMA,EAAEK,WACpB,IAAK,MAAMiU,KAAUvT,MAAMC,KAAKhB,EAAEK,WAAWuD,YAAa,CACtD,MAAM2Q,EAAsBvJ,GAAoBsJ,EAAQD,GACpDE,IACAjU,EAAkBN,EAAEK,cACfkU,EAAoBE,UAAW,GACpCT,EAAepQ,WAAW5B,KAAKuS,GAEvC,CAER,CAsFA,OArFIvU,EAAEyJ,YACF1J,EAAaC,EAAEyJ,aACfnJ,EAAkBN,EAAEyJ,cACpBuK,EAAeS,UAAW,GAE1BT,EAAetP,OAAS5E,EAAW6R,SACR,WAA3BqC,EAAevP,SAxiBvB,SAA0BiQ,EAAUC,EAAU5I,GAC1C,MAAM6I,EAAMF,EAASG,cACrB,IAAKD,EACD,OAEJ,IACIE,EADAC,GAAQ,EAEZ,IACID,EAAaF,EAAI7M,SAAS+M,UAC9B,CACA,MAAOzT,GACH,MACJ,CACA,GAAmB,aAAfyT,EAA2B,CAC3B,MAAME,EAAQC,WAAW,KAChBF,IACDJ,IACAI,GAAQ,IAEbhJ,GAMH,YALA2I,EAASjE,iBAAiB,OAAQ,KAC9ByE,aAAaF,GACbD,GAAQ,EACRJ,KAGR,CACA,MAAMQ,EAAW,cACjB,GAAIP,EAAIQ,SAAStT,OAASqT,GACtBT,EAASnD,MAAQ4D,GACA,KAAjBT,EAASnD,IAET,OADA0D,WAAWN,EAAU,GACdD,EAASjE,iBAAiB,OAAQkE,GAE7CD,EAASjE,iBAAiB,OAAQkE,EACtC,CAsgBQU,CAAiBrV,EAAG,KAChB,MAAMsV,EAAYtV,EAAEwR,gBACpB,GAAI8D,GAAaxJ,EAAc,CAC3B,MAAMyJ,EAAuBvK,GAAoBsK,EAAW,CACxD7N,IAAK6N,EACLpK,SACAC,aACAC,gBACAC,kBACAb,cACAJ,gBACAE,kBACAD,mBACAE,qBACAe,WAAW,EACXC,mBACA/G,mBACA0D,kBACAsD,aACAzG,cACA0G,iBACAC,iBACAC,eACAC,eACAQ,qBACAP,cACAC,eACAC,oBACAC,mBACAC,wBACAC,oBAEAqJ,GACAzJ,EAAa9L,EAAGuV,EAExB,GACDxJ,GAEHiI,EAAetP,OAAS5E,EAAW6R,SACR,SAA3BqC,EAAevP,SACmB,eAAlCuP,EAAe1G,WAAWM,KA7iBlC,SAA8B4H,EAAMb,EAAUc,GAC1C,IACIC,EADAX,GAAQ,EAEZ,IACIW,EAAmBF,EAAK1H,KAC5B,CACA,MAAOzM,GACH,MACJ,CACA,GAAIqU,EACA,OACJ,MAAMV,EAAQC,WAAW,KAChBF,IACDJ,IACAI,GAAQ,IAEbU,GACHD,EAAK/E,iBAAiB,OAAQ,KAC1ByE,aAAaF,GACbD,GAAQ,EACRJ,KAER,CAwhBQgB,CAAqB3V,EAAG,KACpB,GAAIgM,EAAkB,CAClB,MAAM4J,EAAqB5K,GAAoBhL,EAAG,CAC9CyH,MACAyD,SACAC,aACAC,gBACAC,kBACAb,cACAJ,gBACAE,kBACAD,mBACAE,qBACAe,WAAW,EACXC,mBACA/G,mBACA0D,kBACAsD,aACAzG,cACA0G,iBACAC,iBACAC,eACAC,eACAQ,qBACAP,cACAC,eACAC,oBACAC,mBACAC,wBACAC,oBAEA0J,GACA5J,EAAiBhM,EAAG4V,EAE5B,GACD3J,GAEA+H,CACX,CAyEA,SAAS6B,GAAiBzW,GAAO,IAAIC,EAA+BC,EAAQF,EAAI,GAAQG,EAAI,EAAG,KAAOA,EAAIH,EAAII,QAAQ,CAAE,MAAMC,EAAKL,EAAIG,GAAUG,EAAKN,EAAIG,EAAI,GAAY,GAARA,GAAK,GAAe,mBAAPE,GAAkC,iBAAPA,IAAmC,MAATH,EAAiB,OAA+B,WAAPG,GAA0B,mBAAPA,GAA2BJ,EAAgBC,EAAOA,EAAQI,EAAGJ,IAA0B,SAAPG,GAAwB,iBAAPA,IAAyBH,EAAQI,EAAG,IAAIC,IAASL,EAAMM,KAAKP,KAAkBM,IAAQN,OAAgBQ,EAAa,CAAE,OAAOP,CAAO,CACpgB,SAASwW,GAAGpR,EAAMhF,EAAIqW,EAAShO,UAC3B,MAAMkD,EAAU,CAAE+K,SAAS,EAAMC,SAAS,GAE1C,OADAF,EAAOtF,iBAAiB/L,EAAMhF,EAAIuL,GAC3B,IAAM8K,EAAOhG,oBAAoBrL,EAAMhF,EAAIuL,EACtD,CACA,MAAMiL,GAAiC,4NAKvC,IAAIC,GAAU,CACVC,IAAK,CAAC,EACN,KAAArT,GAEI,OADAqN,QAAQ/O,MAAM6U,KACN,CACZ,EACA,OAAA5S,GAEI,OADA8M,QAAQ/O,MAAM6U,IACP,IACX,EACA,iBAAAxS,GACI0M,QAAQ/O,MAAM6U,GAClB,EACA,GAAAnS,GAEI,OADAqM,QAAQ/O,MAAM6U,KACP,CACX,EACA,KAAA5R,GACI8L,QAAQ/O,MAAM6U,GAClB,GAYJ,SAASG,GAAWC,EAAMC,EAAMtL,EAAU,CAAC,GACvC,IAAIuL,EAAU,KACVC,EAAW,EACf,OAAO,YAAa9W,GAChB,MAAM+W,EAAMC,KAAKD,MACZD,IAAgC,IAApBxL,EAAQ2L,UACrBH,EAAWC,GAEf,MAAMG,EAAYN,GAAQG,EAAMD,GAC1BK,EAAUpU,KACZmU,GAAa,GAAKA,EAAYN,GAC1BC,IA+RhB,YAA2BO,GAChBC,GAAkB,eAAlBA,IAAqCD,EAChD,CAhSgBE,CAAeT,GACfA,EAAU,MAEdC,EAAWC,EACXJ,EAAKY,MAAMJ,EAASnX,IAEd6W,IAAgC,IAArBvL,EAAQkM,WACzBX,EAAUY,GAAa,KACnBX,GAA+B,IAApBxL,EAAQ2L,QAAoB,EAAID,KAAKD,MAChDF,EAAU,KACVF,EAAKY,MAAMJ,EAASnX,IACrBkX,GAEX,CACJ,CACA,SAASQ,GAAWtB,EAAQuB,EAAKC,EAAGC,EAAW5C,EAAM6C,QACjD,MAAMC,EAAW9C,EAAIrU,OAAOoX,yBAAyB5B,EAAQuB,GAa7D,OAZA1C,EAAIrU,OAAOqX,eAAe7B,EAAQuB,EAAKE,EACjCD,EACA,CACE,GAAAnT,CAAI9E,GACA8X,GAAa,KACTG,EAAEnT,IAAIxE,KAAK8C,KAAMpD,IAClB,GACCoY,GAAYA,EAAStT,KACrBsT,EAAStT,IAAIxE,KAAK8C,KAAMpD,EAEhC,IAED,IAAM+X,GAAWtB,EAAQuB,EAAKI,GAAY,CAAC,GAAG,EACzD,CACA,SAASG,GAAMC,EAAQ7P,EAAM8P,GACzB,IACI,KAAM9P,KAAQ6P,GACV,MAAO,OAGX,MAAMJ,EAAWI,EAAO7P,GAClB+P,EAAUD,EAAYL,GAW5B,MAVuB,mBAAZM,IACPA,EAAQxX,UAAYwX,EAAQxX,WAAa,CAAC,EAC1CD,OAAO0X,iBAAiBD,EAAS,CAC7BE,mBAAoB,CAChBC,YAAY,EACZ7Y,MAAOoY,MAInBI,EAAO7P,GAAQ+P,EACR,KACHF,EAAO7P,GAAQyP,EAEvB,CACA,MAAOxN,GACH,MAAO,MAEX,CACJ,CA/EsB,oBAAXuN,QAA0BA,OAAOW,OAASX,OAAOY,UACxDlC,GAAU,IAAIiC,MAAMjC,GAAS,CACzB,GAAA5S,CAAIwS,EAAQuC,EAAMC,GAId,MAHa,QAATD,GACAlI,QAAQ/O,MAAM6U,IAEXmC,QAAQ9U,IAAIwS,EAAQuC,EAAMC,EACrC,KAyER,IAAIC,GAAe7B,KAAKD,IAIxB,SAAS+B,GAAgB7D,GACrB,MAAMnN,EAAMmN,EAAI7M,SAChB,MAAO,CACH2Q,KAAMjR,EAAIkR,iBACJlR,EAAIkR,iBAAiB7H,gBACDjR,IAApB+U,EAAIgE,YACAhE,EAAIgE,YACJ/C,GAAiB,CAACpO,EAAK,iBAAkBvH,GAAKA,EAAE2Y,gBAAiB,SAAUzY,GAAMA,EAAG0Q,cAClF+E,GAAiB,CAACpO,EAAK,iBAAkBxE,GAAMA,EAAG6V,KAAM,iBAAkB3V,GAAMA,EAAGsH,cAAe,iBAAkBrH,GAAMA,EAAG0N,cAC7H+E,GAAiB,CAACpO,EAAK,iBAAkB8K,GAAMA,EAAGuG,KAAM,iBAAkBtG,GAAMA,EAAG1B,cACnF,EACZiI,IAAKtR,EAAIkR,iBACHlR,EAAIkR,iBAAiB3H,eACDnR,IAApB+U,EAAIoE,YACApE,EAAIoE,YACJnD,GAAiB,CAACpO,EAAK,iBAAkBgL,GAAMA,EAAGoG,gBAAiB,SAAUI,GAAMA,EAAGjI,aACpF6E,GAAiB,CAACpO,EAAK,iBAAkByR,GAAOA,EAAIJ,KAAM,iBAAkBK,GAAOA,EAAI1O,cAAe,iBAAkB2O,GAAOA,EAAIpI,aACnI6E,GAAiB,CAACpO,EAAK,iBAAkB4R,GAAOA,EAAIP,KAAM,iBAAkBQ,GAAOA,EAAItI,aACvF,EAEpB,CACA,SAASuI,KACL,OAAQ9B,OAAO+B,aACVzR,SAAS8Q,iBAAmB9Q,SAAS8Q,gBAAgBY,cACrD1R,SAAS+Q,MAAQ/Q,SAAS+Q,KAAKW,YACxC,CACA,SAASC,KACL,OAAQjC,OAAOkC,YACV5R,SAAS8Q,iBAAmB9Q,SAAS8Q,gBAAgBe,aACrD7R,SAAS+Q,MAAQ/Q,SAAS+Q,KAAKc,WACxC,CACA,SAASC,GAAqB5V,GAC1B,OAAKA,EAGMA,EAAKsF,WAAatF,EAAKuF,aAC5BvF,EACAA,EAAKwG,cAJA,IAMf,CACA,SAASqP,GAAU7V,EAAMkH,EAAYC,EAAeC,EAAiB0O,GACjE,IAAK9V,EACD,OAAO,EAEX,MAAMuB,EAAKqU,GAAqB5V,GAChC,IAAKuB,EACD,OAAO,EAEX,MAAMwU,EAAmBtQ,GAAqByB,EAAYC,GAC1D,IAAK2O,EAAgB,CACjB,MAAME,EAAc5O,GAAmB7F,EAAGqE,QAAQwB,GAClD,OAAO2O,EAAiBxU,KAAQyU,CACpC,CACA,MAAMC,EAAgBhR,GAAgB1D,EAAIwU,GAC1C,IAAIG,GAAmB,EACvB,QAAID,EAAgB,KAGhB7O,IACA8O,EAAkBjR,GAAgB1D,EAAIkE,GAAqB,KAAM2B,KAEjE6O,GAAiB,GAAKC,EAAkB,GAGrCD,EAAgBC,EAC3B,CAIA,SAASC,GAAUpa,EAAGkL,GAClB,OA/pCiB,IA+pCVA,EAAOnI,MAAM/C,EACxB,CACA,SAASqa,GAAkBtE,EAAQ7K,GAC/B,GAAInL,EAAagW,GACb,OAAO,EAEX,MAAM1S,EAAK6H,EAAOnI,MAAMgT,GACxB,OAAK7K,EAAOnH,IAAIV,MAGZ0S,EAAOtM,YACPsM,EAAOtM,WAAWF,WAAawM,EAAOtJ,kBAGrCsJ,EAAOtM,YAGL4Q,GAAkBtE,EAAOtM,WAAYyB,GAChD,CACA,SAASoP,GAAoBC,GACzB,OAAOpa,QAAQoa,EAAMC,eACzB,CAyBA,SAASC,GAAmBza,EAAGkL,GAC3B,OAAO/K,QAAuB,WAAfH,EAAE0a,UAAyBxP,EAAOhI,QAAQlD,GAC7D,CACA,SAAS2a,GAAuB3a,EAAGkL,GAC/B,OAAO/K,QAAuB,SAAfH,EAAE0a,UACb1a,EAAEuJ,WAAavJ,EAAEwJ,cACjBxJ,EAAEyF,cACwB,eAA1BzF,EAAEyF,aAAa,QACfyF,EAAOhI,QAAQlD,GACvB,CACA,SAAS4a,GAAc5a,GACnB,OAAOG,QAAQ0V,GAAiB,CAAC7V,EAAG,iBAAkB6a,GAAOA,EAAIxa,aACrE,CAnIM,iBAAiBwG,KAAK8P,KAAKD,MAAMjW,cACnC+X,GAAe,KAAM,IAAI7B,MAAOmE,WAmIpC,MAAMC,GACF,WAAAtY,GACIC,KAAKW,GAAK,EACVX,KAAKsY,WAAa,IAAIlY,QACtBJ,KAAKuY,WAAa,IAAIrY,GAC1B,CACA,KAAAG,CAAM0K,GACF,OAAO,OAAiB/K,KAAKsY,WAAWzX,IAAIkK,GAAa,KAAS,EACtE,CACA,GAAA1J,CAAI0J,GACA,OAAO/K,KAAKsY,WAAWjX,IAAI0J,EAC/B,CACA,GAAAvJ,CAAIuJ,EAAYpK,GACZ,GAAIX,KAAKqB,IAAI0J,GACT,OAAO/K,KAAKK,MAAM0K,GACtB,IAAIyN,EAQJ,OANIA,OADOrb,IAAPwD,EACQX,KAAKW,KAGLA,EACZX,KAAKsY,WAAW5W,IAAIqJ,EAAYyN,GAChCxY,KAAKuY,WAAW7W,IAAI8W,EAAOzN,GACpByN,CACX,CACA,QAAAC,CAAS9X,GACL,OAAOX,KAAKuY,WAAW1X,IAAIF,IAAO,IACtC,CACA,KAAAiB,GACI5B,KAAKsY,WAAa,IAAIlY,QACtBJ,KAAKuY,WAAa,IAAIrY,IACtBF,KAAKW,GAAK,CACd,CACA,UAAA+X,GACI,OAAO1Y,KAAKW,IAChB,EAEJ,SAASgY,GAAcrb,GACnB,IAAIsb,EAAa,KAIjB,OAHIzF,GAAiB,CAAC7V,EAAG,SAAUub,GAAOA,EAAIC,YAAa,eAAgBC,GAAOA,IAAO,iBAAkBC,GAAOA,EAAInS,aAAeoS,KAAKC,wBACtI5b,EAAEwb,cAAcvb,OAChBqb,EAAatb,EAAEwb,cAAcvb,MAC1Bqb,CACX,CAeA,SAASO,GAAM7b,GACX,MAAMyH,EAAMzH,EAAE8b,cACd,QAAKrU,IAEEA,EAAIwF,SAASjN,IAXxB,SAAyBA,GACrB,MAAMyH,EAAMzH,EAAE8b,cACd,IAAKrU,EACD,OAAO,EACX,MAAM6T,EAXV,SAA2Btb,GACvB,IACIsb,EADAS,EAAiB/b,EAErB,KAAQsb,EAAaD,GAAcU,IAC/BA,EAAiBT,EACrB,OAAOS,CACX,CAKuBC,CAAkBhc,GACrC,OAAOyH,EAAIwF,SAASqO,EACxB,CAK8BW,CAAgBjc,GAC9C,CACA,MAAMkc,GAAwB,CAAC,EAC/B,SAASlF,GAAkB/O,GACvB,MAAMkU,EAASD,GAAsBjU,GACrC,GAAIkU,EACA,OAAOA,EAEX,MAAMpU,EAAW0P,OAAO1P,SACxB,IAAIqU,EAAO3E,OAAOxP,GAClB,GAAIF,GAA8C,mBAA3BA,EAASF,cAC5B,IACI,MAAMwU,EAAUtU,EAASF,cAAc,UACvCwU,EAAQC,QAAS,EACjBvU,EAASwU,KAAKC,YAAYH,GAC1B,MAAMxH,EAAgBwH,EAAQxH,cAC1BA,GAAiBA,EAAc5M,KAC/BmU,EACIvH,EAAc5M,IAEtBF,EAASwU,KAAKE,YAAYJ,EAC9B,CACA,MAAOxR,GACP,CAEJ,OAAQqR,GAAsBjU,GAAQmU,EAAKM,KAAKjF,OACpD,CAIA,SAASL,MAAgBL,GACrB,OAAOC,GAAkB,aAAlBA,IAAmCD,EAC9C,CAKA,IAAI4F,GAA4B,CAAEC,IAChCA,EAAWA,EAA6B,iBAAI,GAAK,mBACjDA,EAAWA,EAAiB,KAAI,GAAK,OACrCA,EAAWA,EAAyB,aAAI,GAAK,eAC7CA,EAAWA,EAAgC,oBAAI,GAAK,sBACpDA,EAAWA,EAAiB,KAAI,GAAK,OACrCA,EAAWA,EAAmB,OAAI,GAAK,SACvCA,EAAWA,EAAmB,OAAI,GAAK,SAChCA,GARuB,CAS7BD,IAAa,CAAC,GACbE,GAAoC,CAAEC,IACxCA,EAAmBA,EAA6B,SAAI,GAAK,WACzDA,EAAmBA,EAA8B,UAAI,GAAK,YAC1DA,EAAmBA,EAAqC,iBAAI,GAAK,mBACjEA,EAAmBA,EAA2B,OAAI,GAAK,SACvDA,EAAmBA,EAAmC,eAAI,GAAK,iBAC/DA,EAAmBA,EAA0B,MAAI,GAAK,QACtDA,EAAmBA,EAA8B,UAAI,GAAK,YAC1DA,EAAmBA,EAAqC,iBAAI,GAAK,mBACjEA,EAAmBA,EAAmC,eAAI,GAAK,iBAC/DA,EAAmBA,EAAmC,eAAI,GAAK,iBAC/DA,EAAmBA,EAAyB,KAAI,IAAM,OACtDA,EAAmBA,EAAwB,IAAI,IAAM,MACrDA,EAAmBA,EAAyB,KAAI,IAAM,OACtDA,EAAmBA,EAAqC,iBAAI,IAAM,mBAClEA,EAAmBA,EAA8B,UAAI,IAAM,YAC3DA,EAAmBA,EAAsC,kBAAI,IAAM,oBACnEA,EAAmBA,EAAkC,cAAI,IAAM,gBACxDA,GAlB+B,CAmBrCD,IAAqB,CAAC,GACrBE,GAAoC,CAAEC,IACxCA,EAAmBA,EAA4B,QAAI,GAAK,UACxDA,EAAmBA,EAA8B,UAAI,GAAK,YAC1DA,EAAmBA,EAA0B,MAAI,GAAK,QACtDA,EAAmBA,EAAgC,YAAI,GAAK,cAC5DA,EAAmBA,EAA6B,SAAI,GAAK,WACzDA,EAAmBA,EAA0B,MAAI,GAAK,QACtDA,EAAmBA,EAAyB,KAAI,GAAK,OACrDA,EAAmBA,EAA+B,WAAI,GAAK,aAC3DA,EAAmBA,EAAuC,mBAAI,GAAK,qBACnEA,EAAmBA,EAA6B,SAAI,GAAK,WACzDA,EAAmBA,EAAgC,YAAI,IAAM,cACtDA,GAZ+B,CAarCD,IAAqB,CAAC,GACrBE,GAA+B,CAAEC,IACnCA,EAAcA,EAAqB,MAAI,GAAK,QAC5CA,EAAcA,EAAmB,IAAI,GAAK,MAC1CA,EAAcA,EAAqB,MAAI,GAAK,QACrCA,GAJ0B,CAKhCD,IAAgB,CAAC,GAEpB,SAASE,GAAiB/d,GAAO,IAAIC,EAA+BC,EAAQF,EAAI,GAAQG,EAAI,EAAG,KAAOA,EAAIH,EAAII,QAAQ,CAAE,MAAMC,EAAKL,EAAIG,GAAUG,EAAKN,EAAIG,EAAI,GAAY,GAARA,GAAK,GAAe,mBAAPE,GAAkC,iBAAPA,IAAmC,MAATH,EAAiB,OAA+B,WAAPG,GAA0B,mBAAPA,GAA2BJ,EAAgBC,EAAOA,EAAQI,EAAGJ,IAA0B,SAAPG,GAAwB,iBAAPA,IAAyBH,EAAQI,EAAG,IAAIC,IAASL,EAAMM,KAAKP,KAAkBM,IAAQN,OAAgBQ,EAAa,CAAE,OAAOP,CAAO,CACpgB,SAAS8d,GAAmBpd,GACxB,MAAO,SAAUA,CACrB,CACA,MAAMqd,GACF,WAAA5a,GACIC,KAAKlD,OAAS,EACdkD,KAAK6Z,KAAO,KACZ7Z,KAAK4a,KAAO,IAChB,CACA,GAAA/Z,CAAIga,GACA,GAAIA,GAAY7a,KAAKlD,OACjB,MAAM,IAAIge,MAAM,kCAEpB,IAAIC,EAAU/a,KAAK6Z,KACnB,IAAK,IAAImB,EAAQ,EAAGA,EAAQH,EAAUG,IAClCD,EAAUN,GAAiB,CAACM,EAAS,iBAAkBvd,GAAKA,EAAEyd,QAAU,KAE5E,OAAOF,CACX,CACA,OAAAG,CAAQ5d,GACJ,MAAMiE,EAAO,CACT3E,MAAOU,EACPyW,SAAU,KACVkH,KAAM,MAGV,GADA3d,EAAE6d,KAAO5Z,EACLjE,EAAEsS,iBAAmB8K,GAAmBpd,EAAEsS,iBAAkB,CAC5D,MAAMmL,EAAUzd,EAAEsS,gBAAgBuL,KAAKF,KACvC1Z,EAAK0Z,KAAOF,EACZxZ,EAAKwS,SAAWzW,EAAEsS,gBAAgBuL,KAClC7d,EAAEsS,gBAAgBuL,KAAKF,KAAO1Z,EAC1BwZ,IACAA,EAAQhH,SAAWxS,EAE3B,MACK,GAAIjE,EAAEqS,aACP+K,GAAmBpd,EAAEqS,cACrBrS,EAAEqS,YAAYwL,KAAKpH,SAAU,CAC7B,MAAMgH,EAAUzd,EAAEqS,YAAYwL,KAAKpH,SACnCxS,EAAKwS,SAAWgH,EAChBxZ,EAAK0Z,KAAO3d,EAAEqS,YAAYwL,KAC1B7d,EAAEqS,YAAYwL,KAAKpH,SAAWxS,EAC1BwZ,IACAA,EAAQE,KAAO1Z,EAEvB,MAEQvB,KAAK6Z,OACL7Z,KAAK6Z,KAAK9F,SAAWxS,GAEzBA,EAAK0Z,KAAOjb,KAAK6Z,KACjB7Z,KAAK6Z,KAAOtY,EAEE,OAAdA,EAAK0Z,OACLjb,KAAK4a,KAAOrZ,GAEhBvB,KAAKlD,QACT,CACA,UAAAse,CAAW9d,GACP,MAAMyd,EAAUzd,EAAE6d,KACbnb,KAAK6Z,OAGLkB,EAAQhH,UAUTgH,EAAQhH,SAASkH,KAAOF,EAAQE,KAC5BF,EAAQE,KACRF,EAAQE,KAAKlH,SAAWgH,EAAQhH,SAGhC/T,KAAK4a,KAAOG,EAAQhH,WAdxB/T,KAAK6Z,KAAOkB,EAAQE,KAChBjb,KAAK6Z,KACL7Z,KAAK6Z,KAAK9F,SAAW,KAGrB/T,KAAK4a,KAAO,MAYhBtd,EAAE6d,aACK7d,EAAE6d,KAEbnb,KAAKlD,SACT,EAEJ,MAAMue,GAAU,CAAC1a,EAAI2a,IAAa,GAAG3a,KAAM2a,IAC3C,MAAMC,GACF,WAAAxb,GACIC,KAAKwb,QAAS,EACdxb,KAAKyb,QAAS,EACdzb,KAAK0b,MAAQ,GACb1b,KAAK4K,WAAa,GAClB5K,KAAK2b,aAAe,IAAIvb,QACxBJ,KAAK4b,QAAU,GACf5b,KAAK6b,WAAa,GAClB7b,KAAK8b,SAAW,CAAC,EACjB9b,KAAK+b,SAAW,IAAIC,IACpBhc,KAAKic,SAAW,IAAID,IACpBhc,KAAKkc,WAAa,IAAIF,IACtBhc,KAAKmc,iBAAoBC,IACrBA,EAAUjb,QAAQnB,KAAKqc,iBACvBrc,KAAKsc,QAETtc,KAAKsc,KAAO,KACR,GAAItc,KAAKwb,QAAUxb,KAAKyb,OACpB,OAEJ,MAAMc,EAAO,GACPC,EAAW,IAAIR,IACfS,EAAU,IAAI9B,GACd+B,EAAapf,IACf,IAAIqf,EAAKrf,EACLsf,GAn+CC,EAo+CL,MAp+CK,IAo+CEA,GACHD,EAAKA,GAAMA,EAAGhN,YACdiN,EAASD,GAAM3c,KAAKwI,OAAOnI,MAAMsc,GAErC,OAAOC,GAELC,EAAWvf,IACb,IAAKA,EAAEyJ,aAAeoS,GAAM7b,GACxB,OAEJ,MAAMge,EAAWje,EAAaC,EAAEyJ,YAC1B/G,KAAKwI,OAAOnI,MAAMsY,GAAcrb,IAChC0C,KAAKwI,OAAOnI,MAAM/C,EAAEyJ,YACpB6V,EAASF,EAAUpf,GACzB,IAAkB,IAAdge,IAA+B,IAAZsB,EACnB,OAAOH,EAAQvB,QAAQ5d,GAE3B,MAAMkT,EAAKlI,GAAoBhL,EAAG,CAC9ByH,IAAK/E,KAAK+E,IACVyD,OAAQxI,KAAKwI,OACbC,WAAYzI,KAAKyI,WACjBC,cAAe1I,KAAK0I,cACpBZ,YAAa9H,KAAK8H,YAClBa,gBAAiB3I,KAAK2I,gBACtBjB,cAAe1H,KAAK0H,cACpBE,gBAAiB5H,KAAK4H,gBACtBD,iBAAkB3H,KAAK2H,iBACvBE,mBAAoB7H,KAAK6H,mBACzBe,WAAW,EACXa,mBAAmB,EACnBZ,iBAAkB7I,KAAK6I,iBACvB/G,iBAAkB9B,KAAK8B,iBACvB0D,gBAAiBxF,KAAKwF,gBACtBsD,WAAY9I,KAAK8I,WACjBzG,YAAarC,KAAKqC,YAClB0G,eAAgB/I,KAAK+I,eACrBC,eAAgBhJ,KAAKgJ,eACrBE,aAAclJ,KAAKkJ,aACnBD,aAAcjJ,KAAKiJ,aACnBE,YAAc2T,IACN/E,GAAmB+E,EAAU9c,KAAKwI,SAClCxI,KAAK+c,cAAcC,UAAUF,GAE7B7E,GAAuB6E,EAAU9c,KAAKwI,SACtCxI,KAAKid,kBAAkBC,iBAAiBJ,GAExC5E,GAAc5a,IACd0C,KAAKmd,iBAAiBC,cAAc9f,EAAEK,WAAYqC,KAAK+E,MAG/DqE,aAAc,CAACiU,EAAQC,KACnBtd,KAAK+c,cAAcQ,aAAaF,EAAQC,GACxCtd,KAAKmd,iBAAiBK,oBAAoBH,IAE9C/T,iBAAkB,CAACwJ,EAAMwK,KACrBtd,KAAKid,kBAAkBQ,kBAAkB3K,EAAMwK,MAGnD9M,IACA+L,EAAKjd,KAAK,CACNgc,WACAsB,SACArb,KAAMiP,IAEVgM,EAAShb,IAAIgP,EAAG7P,MAGxB,KAAOX,KAAK6b,WAAW/e,QACnBkD,KAAKwI,OAAOxH,kBAAkBhB,KAAK6b,WAAW6B,SAElD,IAAK,MAAMpgB,KAAK0C,KAAKic,SACb0B,GAAgB3d,KAAK4b,QAASte,EAAG0C,KAAKwI,UACrCxI,KAAKic,SAAS5a,IAAI/D,EAAEyJ,aAGzB8V,EAAQvf,GAEZ,IAAK,MAAMA,KAAK0C,KAAK+b,SACZ6B,GAAgB5d,KAAKkc,WAAY5e,IACjCqgB,GAAgB3d,KAAK4b,QAASte,EAAG0C,KAAKwI,QAGlCoV,GAAgB5d,KAAKic,SAAU3e,GACpCuf,EAAQvf,GAGR0C,KAAKkc,WAAW1a,IAAIlE,GANpBuf,EAAQvf,GAShB,IAAIugB,EAAY,KAChB,KAAOpB,EAAQ3f,QAAQ,CACnB,IAAIyE,EAAO,KACX,GAAIsc,EAAW,CACX,MAAMvC,EAAWtb,KAAKwI,OAAOnI,MAAMwd,EAAUjhB,MAAMmK,YAC7C6V,EAASF,EAAUmB,EAAUjhB,QACjB,IAAd0e,IAA+B,IAAZsB,IACnBrb,EAAOsc,EAEf,CACA,IAAKtc,EAAM,CACP,IAAIuc,EAAWrB,EAAQ7B,KACvB,KAAOkD,GAAU,CACb,MAAMC,EAAQD,EAEd,GADAA,EAAWA,EAAS/J,SAChBgK,EAAO,CACP,MAAMzC,EAAWtb,KAAKwI,OAAOnI,MAAM0d,EAAMnhB,MAAMmK,YAE/C,IAAgB,IADD2V,EAAUqB,EAAMnhB,OAE3B,SACC,IAAkB,IAAd0e,EAAiB,CACtB/Z,EAAOwc,EACP,KACJ,CACK,CACD,MAAMC,EAAgBD,EAAMnhB,MAC5B,GAAIohB,EAAcjX,YACdiX,EAAcjX,WAAWF,WACrBoS,KAAKC,uBAAwB,CACjC,MAAMN,EAAaoF,EAAcjX,WAC5BxJ,KAEL,IAAkB,IADDyC,KAAKwI,OAAOnI,MAAMuY,GACd,CACjBrX,EAAOwc,EACP,KACJ,CACJ,CACJ,CACJ,CACJ,CACJ,CACA,IAAKxc,EAAM,CACP,KAAOkb,EAAQ5C,MACX4C,EAAQrB,WAAWqB,EAAQ5C,KAAKjd,OAEpC,KACJ,CACAihB,EAAYtc,EAAKwS,SACjB0I,EAAQrB,WAAW7Z,EAAK3E,OACxBigB,EAAQtb,EAAK3E,MACjB,CACA,MAAMqhB,EAAU,CACZvC,MAAO1b,KAAK0b,MACPhI,IAAKpR,IAAS,CACf3B,GAAIX,KAAKwI,OAAOnI,MAAMiC,EAAKf,MAC3B3E,MAAO0F,EAAK1F,SAEXshB,OAAQ5b,IAAUka,EAASnb,IAAIiB,EAAK3B,KACpCud,OAAQ5b,GAAStC,KAAKwI,OAAOnH,IAAIiB,EAAK3B,KAC3CiK,WAAY5K,KAAK4K,WACZ8I,IAAKyK,IACN,MAAM,WAAEvT,GAAeuT,EACvB,GAAgC,iBAArBvT,EAAWwT,MAAoB,CACtC,MAAMC,EAAYnf,KAAKC,UAAUgf,EAAUG,WACrCC,EAAiBrf,KAAKC,UAAUgf,EAAUK,kBAC5CH,EAAUvhB,OAAS8N,EAAWwT,MAAMthB,SAC/BuhB,EAAYE,GAAgBvf,MAAM,QAAQlC,SAC3C8N,EAAWwT,MAAMpf,MAAM,QAAQlC,SAC/B8N,EAAWwT,MAAQD,EAAUG,UAGzC,CACA,MAAO,CACH3d,GAAIX,KAAKwI,OAAOnI,MAAM8d,EAAU5c,MAChCqJ,WAAYA,KAGfsT,OAAQC,IAAe3B,EAASnb,IAAI8c,EAAUxd,KAC9Cud,OAAQC,GAAcne,KAAKwI,OAAOnH,IAAI8c,EAAUxd,KACrDib,QAAS5b,KAAK4b,QACdW,SAEC0B,EAAQvC,MAAM5e,QACdmhB,EAAQrT,WAAW9N,QACnBmhB,EAAQrC,QAAQ9e,QAChBmhB,EAAQ1B,KAAKzf,UAGlBkD,KAAK0b,MAAQ,GACb1b,KAAK4K,WAAa,GAClB5K,KAAK2b,aAAe,IAAIvb,QACxBJ,KAAK4b,QAAU,GACf5b,KAAK+b,SAAW,IAAIC,IACpBhc,KAAKic,SAAW,IAAID,IACpBhc,KAAKkc,WAAa,IAAIF,IACtBhc,KAAK8b,SAAW,CAAC,EACjB9b,KAAKye,WAAWR,KAEpBje,KAAKqc,gBAAmBqC,IACpB,IAAIhH,GAAUgH,EAAErL,OAAQrT,KAAKwI,QAG7B,OAAQkW,EAAE1c,MACN,IAAK,gBAAiB,CAClB,MAAMpF,EAAQ8hB,EAAErL,OAAO/H,YAClB8L,GAAUsH,EAAErL,OAAQrT,KAAKyI,WAAYzI,KAAK0I,cAAe1I,KAAK2I,iBAAiB,IAChF/L,IAAU8hB,EAAExR,UACZlN,KAAK0b,MAAMpc,KAAK,CACZ1C,MAAO6K,GAAgBiX,EAAErL,OAAQrT,KAAK0H,cAAe1H,KAAK2H,iBAAkB3H,KAAK4H,gBAAiB5H,KAAK6H,mBAAoB7H,KAAK8H,cAAgBlL,EAC1IoD,KAAK8I,WACD9I,KAAK8I,WAAWlM,EAAOua,GAAqBuH,EAAErL,SAC9CzW,EAAM8B,QAAQ,QAAS,KAC3B9B,EACN2E,KAAMmd,EAAErL,SAGhB,KACJ,CACA,IAAK,aAAc,CACf,MAAMA,EAASqL,EAAErL,OACjB,IAAIsL,EAAgBD,EAAEC,cAClB/hB,EAAQ8hB,EAAErL,OAAOtQ,aAAa4b,GAClC,GAAsB,UAAlBA,EAA2B,CAC3B,MAAM3c,EAAOW,EAAa0Q,GACpBtR,EAAUsR,EAAOtR,QACvBnF,EAAQiG,EAAcwQ,EAAQtR,EAASC,GACvC,MAAM4c,EAAgB/c,EAAgB,CAClCC,iBAAkB9B,KAAK8B,iBACvBC,UACAC,SAGJpF,EAAQsF,EAAe,CACnBC,SAFcsF,GAAgBiX,EAAErL,OAAQrT,KAAK0H,cAAe1H,KAAK2H,iBAAkB3H,KAAK4H,gBAAiB5H,KAAK6H,mBAAoB+W,GAGlIxc,QAASiR,EACTzW,QACAyF,YAAarC,KAAKqC,aAE1B,CACA,GAAI+U,GAAUsH,EAAErL,OAAQrT,KAAKyI,WAAYzI,KAAK0I,cAAe1I,KAAK2I,iBAAiB,IAC/E/L,IAAU8hB,EAAExR,SACZ,OAEJ,IAAI2R,EAAO7e,KAAK2b,aAAa9a,IAAI6d,EAAErL,QACnC,GAAuB,WAAnBA,EAAOtR,SACW,QAAlB4c,IACC3e,KAAKwJ,gBAAgB5M,GAAQ,CAC9B,GAAKyW,EAAOvE,gBAIR,OAHA6P,EAAgB,QAKxB,CAgBA,GAfKE,IACDA,EAAO,CACHtd,KAAMmd,EAAErL,OACRzI,WAAY,CAAC,EACb0T,UAAW,CAAC,EACZE,iBAAkB,CAAC,GAEvBxe,KAAK4K,WAAWtL,KAAKuf,GACrB7e,KAAK2b,aAAaja,IAAIgd,EAAErL,OAAQwL,IAEd,SAAlBF,GACmB,UAAnBtL,EAAOtR,SAC8B,cAApC2c,EAAExR,UAAY,IAAIjL,eACnBoR,EAAOyL,aAAa,sBAAuB,SAE1CxY,GAAgB+M,EAAOtR,QAAS4c,KACjCE,EAAKjU,WAAW+T,GAAiBrZ,GAAmBtF,KAAK+E,IAAK9C,EAAYoR,EAAOtR,SAAUE,EAAY0c,GAAgB/hB,EAAOyW,EAAQrT,KAAKwF,iBACrH,UAAlBmZ,GAA2B,CAC3B,IAAK3e,KAAK+e,cACN,IACI/e,KAAK+e,cACD1Z,SAAS2Z,eAAeC,oBAChC,CACA,MAAO9W,GACHnI,KAAK+e,cAAgB/e,KAAK+E,GAC9B,CAEJ,MAAMma,EAAMlf,KAAK+e,cAAc5Z,cAAc,QACzCuZ,EAAExR,UACFgS,EAAIJ,aAAa,QAASJ,EAAExR,UAEhC,IAAK,MAAMiS,KAAS9gB,MAAMC,KAAK+U,EAAO+K,OAAQ,CAC1C,MAAMgB,EAAW/L,EAAO+K,MAAMiB,iBAAiBF,GACzCG,EAAcjM,EAAO+K,MAAMmB,oBAAoBJ,GACjDC,IAAaF,EAAId,MAAMiB,iBAAiBF,IACxCG,IAAgBJ,EAAId,MAAMmB,oBAAoBJ,GAE1CN,EAAKP,UAAUa,GADC,KAAhBG,EACwBF,EAGA,CAACA,EAAUE,GAIvCT,EAAKL,iBAAiBW,GAAS,CAACC,EAAUE,EAElD,CACA,IAAK,MAAMH,KAAS9gB,MAAMC,KAAK4gB,EAAId,OACc,KAAzC/K,EAAO+K,MAAMiB,iBAAiBF,KAC9BN,EAAKP,UAAUa,IAAS,EAGpC,CAEJ,KACJ,CACA,IAAK,YACD,GAAI/H,GAAUsH,EAAErL,OAAQrT,KAAKyI,WAAYzI,KAAK0I,cAAe1I,KAAK2I,iBAAiB,GAC/E,OAEJ+V,EAAEc,WAAWre,QAAS7D,GAAM0C,KAAKyf,QAAQniB,EAAGohB,EAAErL,SAC9CqL,EAAEgB,aAAave,QAAS7D,IACpB,MAAMqiB,EAAS3f,KAAKwI,OAAOnI,MAAM/C,GAC3Bge,EAAWje,EAAaqhB,EAAErL,QAC1BrT,KAAKwI,OAAOnI,MAAMqe,EAAErL,OAAO9V,MAC3ByC,KAAKwI,OAAOnI,MAAMqe,EAAErL,QACtB+D,GAAUsH,EAAErL,OAAQrT,KAAKyI,WAAYzI,KAAK0I,cAAe1I,KAAK2I,iBAAiB,IAC/E+O,GAAUpa,EAAG0C,KAAKwI,UA/nB9C,SAAsBlL,EAAGkL,GACrB,OAA4B,IAArBA,EAAOnI,MAAM/C,EACxB,CA8nB6BsiB,CAAatiB,EAAG0C,KAAKwI,UAGtBxI,KAAK+b,SAAS1a,IAAI/D,IAClBuiB,GAAW7f,KAAK+b,SAAUze,GAC1B0C,KAAKkc,WAAW1a,IAAIlE,IAEf0C,KAAK+b,SAAS1a,IAAIqd,EAAErL,UAAuB,IAAZsM,GAC/BhI,GAAkB+G,EAAErL,OAAQrT,KAAKwI,UACjCxI,KAAKic,SAAS5a,IAAI/D,IACvB0C,KAAK8b,SAAST,GAAQsE,EAAQrE,IAC9BuE,GAAW7f,KAAKic,SAAU3e,GAG1B0C,KAAK4b,QAAQtc,KAAK,CACdgc,WACA3a,GAAIgf,EACJ5N,YAAU1U,EAAaqhB,EAAErL,UAAWzV,EAAkB8gB,EAAErL,eAElDlW,KAGd6C,KAAK6b,WAAWvc,KAAKhC,QAMrC0C,KAAKyf,QAAU,CAACniB,EAAG+V,KACf,IAAIrT,KAAK8f,qBAAqBC,cAAcziB,EAAG0C,QAE3CA,KAAK+b,SAAS1a,IAAI/D,KAAM0C,KAAKic,SAAS5a,IAAI/D,GAA9C,CAEA,GAAI0C,KAAKwI,OAAOlH,QAAQhE,GAAI,CACxB,GAAIoa,GAAUpa,EAAG0C,KAAKwI,QAClB,OAEJxI,KAAKic,SAASza,IAAIlE,GAClB,IAAI0iB,EAAW,KACX3M,GAAUrT,KAAKwI,OAAOlH,QAAQ+R,KAC9B2M,EAAWhgB,KAAKwI,OAAOnI,MAAMgT,IAE7B2M,IAA0B,IAAdA,IACZhgB,KAAK8b,SAAST,GAAQrb,KAAKwI,OAAOnI,MAAM/C,GAAI0iB,KAAa,EAEjE,MAEIhgB,KAAK+b,SAASva,IAAIlE,GAClB0C,KAAKkc,WAAWjb,OAAO3D,GAEtB8Z,GAAU9Z,EAAG0C,KAAKyI,WAAYzI,KAAK0I,cAAe1I,KAAK2I,iBAAiB,KACzErL,EAAE4D,WAAWC,QAASyQ,GAAW5R,KAAKyf,QAAQ7N,IAC1CsG,GAAc5a,IACdA,EAAEK,WAAWuD,WAAWC,QAASyQ,IAC7B5R,KAAK8f,qBAAqBte,IAAIoQ,EAAQ5R,MACtCA,KAAKyf,QAAQ7N,EAAQtU,KAvBvB,EA4BlB,CACA,IAAA2iB,CAAK1X,GACD,CACI,aACA,aACA,gBACA,kBACA,cACA,gBACA,kBACA,mBACA,qBACA,mBACA,mBACA,kBACA,aACA,cACA,kBACA,eACA,eACA,iBACA,iBACA,MACA,SACA,gBACA,oBACA,mBACA,gBACA,wBACFpH,QAASyT,IACP5U,KAAK4U,GAAOrM,EAAQqM,IAE5B,CACA,MAAAsL,GACIlgB,KAAKwb,QAAS,EACdxb,KAAKmgB,cAAcD,QACvB,CACA,QAAAE,GACIpgB,KAAKwb,QAAS,EACdxb,KAAKmgB,cAAcC,WACnBpgB,KAAKsc,MACT,CACA,QAAA+D,GACI,OAAOrgB,KAAKwb,MAChB,CACA,IAAA8E,GACItgB,KAAKyb,QAAS,EACdzb,KAAKmgB,cAAcG,MACvB,CACA,MAAAC,GACIvgB,KAAKyb,QAAS,EACdzb,KAAKmgB,cAAcI,SACnBvgB,KAAKsc,MACT,CACA,KAAA1a,GACI5B,KAAKmd,iBAAiBvb,QACtB5B,KAAKmgB,cAAcve,OACvB,EAEJ,SAASie,GAAWW,EAASljB,GACzBkjB,EAAQvf,OAAO3D,GACfA,EAAE4D,WAAWC,QAASyQ,GAAWiO,GAAWW,EAAS5O,GACzD,CACA,SAAS+L,GAAgB/B,EAASte,EAAGkL,GACjC,OAAuB,IAAnBoT,EAAQ9e,QAEL2jB,GAAiB7E,EAASte,EAAGkL,EACxC,CACA,SAASiY,GAAiB7E,EAASte,EAAGkL,GAClC,MAAM,WAAEzB,GAAezJ,EACvB,IAAKyJ,EACD,OAAO,EAEX,MAAMuU,EAAW9S,EAAOnI,MAAM0G,GAC9B,QAAI6U,EAAQnP,KAAMiU,GAAMA,EAAE/f,KAAO2a,IAG1BmF,GAAiB7E,EAAS7U,EAAYyB,EACjD,CACA,SAASoV,GAAgBlc,EAAKpE,GAC1B,OAAiB,IAAboE,EAAIif,MAEDC,GAAiBlf,EAAKpE,EACjC,CACA,SAASsjB,GAAiBlf,EAAKpE,GAC3B,MAAM,WAAEyJ,GAAezJ,EACvB,QAAKyJ,MAGDrF,EAAIL,IAAI0F,IAGL6Z,GAAiBlf,EAAKqF,GACjC,CAEA,IAAI8Z,GACJ,SAASC,GAAqBC,GAC1BF,GAAeE,CACnB,CACA,SAASC,KACLH,QAAe1jB,CACnB,CACA,MAAM8jB,GAAmBC,GAChBL,GAGgB,IAAKxM,KACtB,IACI,OAAO6M,KAAM7M,EACjB,CACA,MAAO1V,GACH,GAAIkiB,KAAwC,IAAxBA,GAAaliB,GAC7B,MAAO,OAGX,MAAMA,CACV,CACH,EAbUuiB,EAiBf,SAASC,GAAiBzkB,GAAO,IAAIC,EAA+BC,EAAQF,EAAI,GAAQG,EAAI,EAAG,KAAOA,EAAIH,EAAII,QAAQ,CAAE,MAAMC,EAAKL,EAAIG,GAAUG,EAAKN,EAAIG,EAAI,GAAY,GAARA,GAAK,GAAe,mBAAPE,GAAkC,iBAAPA,IAAmC,MAATH,EAAiB,OAA+B,WAAPG,GAA0B,mBAAPA,GAA2BJ,EAAgBC,EAAOA,EAAQI,EAAGJ,IAA0B,SAAPG,GAAwB,iBAAPA,IAAyBH,EAAQI,EAAG,IAAIC,IAASL,EAAMM,KAAKP,KAAkBM,IAAQN,OAAgBQ,EAAa,CAAE,OAAOP,CAAO,CACpgB,MAAMwkB,GAAkB,GACxB,SAASC,GAAexJ,GACpB,IACI,GAAI,iBAAkBA,EAAO,CACzB,MAAMyJ,EAAOzJ,EAAM0J,eACnB,GAAID,EAAKxkB,OACL,OAAOwkB,EAAK,EAEpB,MACK,GAAI,SAAUzJ,GAASA,EAAMyJ,KAAKxkB,OACnC,OAAO+a,EAAMyJ,KAAK,EAE1B,CACA,MAAO9Z,GACP,CACA,OAAOqQ,GAASA,EAAMxE,MAC1B,CACA,SAASmO,GAAqBjZ,EAASkZ,GACnC,MAAMC,EAAiB,IAAInG,GAC3B6F,GAAgB9hB,KAAKoiB,GACrBA,EAAezB,KAAK1X,GACpB,IAAIoZ,EAAuB5M,OAAO6M,kBAC9B7M,OAAO8M,qBACX,MAAMC,EAAoBX,GAAiB,CAACpM,OAAQ,iBAAkBvX,GAAKA,EAAEukB,KAAM,iBAAkBrkB,GAAMA,EAAGskB,WAAY,eAAgBzhB,GAAMA,EAAG,sBAC/IuhB,GACA/M,OAAO+M,KACPH,EAAuB5M,OAAO+M,IAElC,MAAMG,EAAW,IAAIN,EAAqBV,GAAiB7E,IACnD7T,EAAQ2Z,aAAgD,IAAlC3Z,EAAQ2Z,WAAW9F,IAG7CsF,EAAevF,iBAAiBnC,KAAK0H,EAArCA,CAAqDtF,MAUzD,OARA6F,EAASE,QAAQV,EAAQ,CACrB7W,YAAY,EACZwX,mBAAmB,EACnBC,eAAe,EACfC,uBAAuB,EACvBC,WAAW,EACXC,SAAS,IAENP,CACX,CAoJA,SAASQ,IAAmB,SAAEC,EAAQ,IAAE3d,EAAG,OAAEyD,EAAM,WAAEC,EAAU,cAAEC,EAAa,gBAAEC,EAAe,SAAEga,IAwB7F,OAAOvP,GAAG,SAvBa6N,GAAgBtN,GAAWsN,GAAiB2B,IAC/D,MAAMvP,EAASgO,GAAeuB,GAC9B,IAAKvP,GACD+D,GAAU/D,EAAQ5K,EAAYC,EAAeC,GAAiB,GAC9D,OAEJ,MAAMhI,EAAK6H,EAAOnI,MAAMgT,GACxB,GAAIA,IAAWtO,GAAOA,EAAI8d,YAAa,CACnC,MAAMC,EAAgB/M,GAAgBhR,EAAI8d,aAC1CH,EAAS,CACL/hB,KACAmL,EAAGgX,EAAc9M,KACjBhK,EAAG8W,EAAczM,KAEzB,MAEIqM,EAAS,CACL/hB,KACAmL,EAAGuH,EAAOjF,WACVpC,EAAGqH,EAAO/E,cAGlBqU,EAASI,QAAU,MACahe,EACxC,CAkBA,MAAMie,GAAa,CAAC,QAAS,WAAY,UACnCC,GAAoB,IAAI7iB,QAC9B,SAAS8iB,IAAkB,QAAEC,EAAO,IAAEpe,EAAG,OAAEyD,EAAM,WAAEC,EAAU,cAAEC,EAAa,gBAAEC,EAAe,YAAEya,EAAW,eAAEC,EAAc,iBAAEvhB,EAAgB,YAAEO,EAAW,SAAEsgB,EAAQ,qBAAEW,EAAoB,cAAE5b,EAAa,gBAAEE,EAAe,iBAAED,EAAgB,mBAAEE,IACzO,SAAS0b,EAAa1L,GAClB,IAAIxE,EAASgO,GAAexJ,GAC5B,MAAM2L,EAAgB3L,EAAM4L,UACtB1hB,EAAUsR,GAAU5Q,EAAY4Q,EAAOtR,SAG7C,GAFgB,WAAZA,IACAsR,EAASA,EAAOtL,gBACfsL,IACAtR,GACDihB,GAAW3e,QAAQtC,GAAW,GAC9BqV,GAAU/D,EAAQ5K,EAAYC,EAAeC,GAAiB,GAC9D,OAEJ,MAAM7F,EAAKuQ,EACX,GAAIvQ,EAAGwE,UAAUiD,SAAS6Y,IACrBC,GAAkBvgB,EAAGqE,QAAQkc,GAC9B,OAEJ,MAAMrhB,EAAOW,EAAa0Q,GAC1B,IAAI/Q,EAAOO,EAAcC,EAAIf,EAASC,GAClC0hB,GAAY,EAChB,MAAM9E,EAAgB/c,EAAgB,CAClCC,mBACAC,UACAC,SAEEwJ,EAAY/D,GAAgB4L,EAAQ3L,EAAeC,EAAkBC,EAAiBC,EAAoB+W,GACnG,UAAT5c,GAA6B,aAATA,IACpB0hB,EAAYrQ,EAAO9H,SAEvBjJ,EAAOJ,EAAe,CAClBC,SAAUqJ,EACVpJ,QAASiR,EACTzW,MAAO0F,EACPD,gBAEJshB,EAAYtQ,EAAQiQ,EACd,CAAEhhB,OAAMohB,YAAWF,iBACnB,CAAElhB,OAAMohB,cACd,MAAMne,EAAO8N,EAAO9N,KACP,UAATvD,GAAoBuD,GAAQme,GAC5B3e,EACK6e,iBAAiB,6BAA6Bre,OAC9CpE,QAAS2B,IACV,GAAIA,IAAOuQ,EAAQ,CACf,MAAM/Q,EAAOJ,EAAe,CACxBC,SAAUqJ,EACVpJ,QAASU,EACTlG,MAAOiG,EAAcC,EAAIf,EAASC,GAClCK,gBAEJshB,EAAY7gB,EAAIwgB,EACV,CAAEhhB,OAAMohB,WAAYA,EAAWF,eAAe,GAC9C,CAAElhB,OAAMohB,WAAYA,GAC9B,GAGZ,CACA,SAASC,EAAYtQ,EAAQwQ,GACzB,MAAMC,EAAiBb,GAAkBpiB,IAAIwS,GAC7C,IAAKyQ,GACDA,EAAexhB,OAASuhB,EAAEvhB,MAC1BwhB,EAAeJ,YAAcG,EAAEH,UAAW,CAC1CT,GAAkBvhB,IAAI2R,EAAQwQ,GAC9B,MAAMljB,EAAK6H,EAAOnI,MAAMgT,GACxB4N,GAAgBkC,EAAhBlC,CAAyB,IAClB4C,EACHljB,MAER,CACJ,CACA,MACMojB,GAD4B,SAAnBpB,EAASqB,MAAmB,CAAC,UAAY,CAAC,QAAS,WAC1CtQ,IAAKuQ,GAAc7Q,GAAG6Q,EAAWhD,GAAgBsC,GAAexe,IAClFmf,EAAgBnf,EAAI8d,YAC1B,IAAKqB,EACD,MAAO,KACHH,EAAS5iB,QAASgjB,GAAMA,MAGhC,MAAMC,EAAqBF,EAAcrmB,OAAOoX,yBAAyBiP,EAAcG,iBAAiBvmB,UAAW,SAC7GwmB,EAAiB,CACnB,CAACJ,EAAcG,iBAAiBvmB,UAAW,SAC3C,CAAComB,EAAcG,iBAAiBvmB,UAAW,WAC3C,CAAComB,EAAcK,kBAAkBzmB,UAAW,SAC5C,CAAComB,EAAcM,oBAAoB1mB,UAAW,SAC9C,CAAComB,EAAcK,kBAAkBzmB,UAAW,iBAC5C,CAAComB,EAAcO,kBAAkB3mB,UAAW,aAYhD,OAVIsmB,GAAsBA,EAAmB1iB,KACzCqiB,EAASzkB,QAAQglB,EAAe5Q,IAAKgR,GAAM/P,GAAW+P,EAAE,GAAIA,EAAE,GAAI,CAC9D,GAAAhjB,GACIuf,GAAgBsC,EAAhBtC,CAA8B,CAC1B5N,OAAQrT,KACRyjB,WAAW,GAEnB,IACD,EAAOS,KAEPjD,GAAgB,KACnB8C,EAAS5iB,QAASgjB,GAAMA,MAEhC,CACA,SAASQ,GAA0B/lB,GAsB/B,OApBA,SAAiBgmB,EAAWnf,GACxB,GAAKof,GAAiB,oBAClBD,EAAUE,sBAAsBC,iBAC/BF,GAAiB,iBACdD,EAAUE,sBAAsBE,cACnCH,GAAiB,oBACdD,EAAUE,sBAAsBG,iBACnCJ,GAAiB,qBACdD,EAAUE,sBAAsBI,iBAAmB,CACvD,MACMlK,EADQ3c,MAAMC,KAAKsmB,EAAUE,WAAW3mB,UAC1BkG,QAAQugB,GAC5Bnf,EAAI0f,QAAQnK,EAChB,MACK,GAAI4J,EAAUQ,iBAAkB,CACjC,MACMpK,EADQ3c,MAAMC,KAAKsmB,EAAUQ,iBAAiBjnB,UAChCkG,QAAQugB,GAC5Bnf,EAAI0f,QAAQnK,EAChB,CACA,OAAOvV,CACX,CACO4f,CAAQzmB,EArBG,GAsBtB,CACA,SAAS0mB,GAAgBla,EAAO5C,EAAQ+c,GACpC,IAAI5kB,EAAI6kB,EACR,OAAKpa,GAEDA,EAAMqa,UACN9kB,EAAK6H,EAAOnI,MAAM+K,EAAMqa,WAExBD,EAAUD,EAAYllB,MAAM+K,GACzB,CACHoa,UACA7kB,OAPO,CAAC,CAShB,CA+IA,SAAS+kB,IAA8B,OAAEld,EAAM,kBAAEyU,GAAsB1f,GACnE,IAAIooB,EAAS,KAETA,EADkB,cAAlBpoB,EAAKya,SACIxP,EAAOnI,MAAM9C,GAEbiL,EAAOnI,MAAM9C,EAAKA,MAC/B,MAAMqoB,EAAgC,cAAlBroB,EAAKya,SACnBmJ,GAAiB,CAAC5jB,EAAM,SAAUkD,GAAMA,EAAGoiB,YAAa,iBAAkBniB,GAAMA,EAAGuJ,WACnFkX,GAAiB,CAAC5jB,EAAM,SAAUsS,GAAMA,EAAGuJ,cAAe,iBAAkBtJ,GAAMA,EAAG+S,YAAa,iBAAkB9S,GAAMA,EAAG8V,aAC7HC,EAA6B3E,GAAiB,CAACyE,EAAa,iBAAkBrP,GAAMA,EAAGzY,YACvFD,OAAOoX,yBAAyBkM,GAAiB,CAACyE,EAAa,iBAAkBpP,GAAOA,EAAI1Y,YAAa,2BACzGX,EACN,OAAe,OAAXwoB,IACY,IAAZA,GACCC,GACAE,GAGLjoB,OAAOqX,eAAe3X,EAAM,qBAAsB,CAC9CwoB,aAAcD,EAA2BC,aACzCtQ,WAAYqQ,EAA2BrQ,WACvC,GAAA5U,GACI,OAAOsgB,GAAiB,CAAC2E,EAA4B,SAAUrP,GAAOA,EAAI5V,IAAK,iBAAkB6V,GAAOA,EAAIxZ,KAAM,OAAQyZ,GAAOA,EAAI3W,OACzI,EACA,GAAA0B,CAAIskB,GACA,MAAMC,EAAS9E,GAAiB,CAAC2E,EAA4B,SAAUlP,GAAOA,EAAIlV,IAAK,iBAAkBwkB,GAAOA,EAAIhpB,KAAM,OAAQipB,GAAOA,EAAInmB,KAAMgmB,KACnJ,GAAe,OAAXL,IAA+B,IAAZA,EACnB,IACI1I,EAAkBmJ,iBAAiBJ,EAAQL,EAC/C,CACA,MAAOxd,GACP,CAEJ,OAAO8d,CACX,IAEGhF,GAAgB,KACnBpjB,OAAOqX,eAAe3X,EAAM,qBAAsB,CAC9CwoB,aAAcD,EAA2BC,aACzCtQ,WAAYqQ,EAA2BrQ,WACvC5U,IAAKilB,EAA2BjlB,IAChCa,IAAKokB,EAA2BpkB,SAzB7B,MA4Bf,CAyKA,SAAS2kB,GAAcC,EAAGC,EAAS,CAAC,GAChC,MAAMrC,EAAgBoC,EAAEvhB,IAAI8d,YAC5B,IAAKqB,EACD,MAAO,OAGX,MAAMsC,EAAmBhF,GAAqB8E,EAAGA,EAAEvhB,KAC7C0hB,EArrBV,UAA0B,YAAEC,EAAW,SAAE/D,EAAQ,IAAE5d,EAAG,OAAEyD,IACpD,IAA2B,IAAvBma,EAASgE,UACT,MAAO,OAGX,MAAMC,EAA0C,iBAAvBjE,EAASgE,UAAyBhE,EAASgE,UAAY,GAC1EE,EAA0D,iBAA/BlE,EAASmE,kBACpCnE,EAASmE,kBACT,IACN,IACIC,EADAC,EAAY,GAEhB,MAAMC,EAAYtT,GAAWsN,GAAiB7L,IAC1C,MAAM8R,EAAcjT,KAAKD,MAAQ+S,EACjCL,EAAYM,EAAUtT,IAAKgR,IACvBA,EAAEyC,YAAcD,EACTxC,IACPtP,GACJ4R,EAAY,GACZD,EAAe,OACfF,GACEO,EAAiBnG,GAAgBtN,GAAWsN,GAAiB2B,IAC/D,MAAMvP,EAASgO,GAAeuB,IACxB,QAAEyE,EAAO,QAAEC,GAAY1P,GAAoBgL,GAC3CA,EAAI9K,eAAe,GACnB8K,EACDmE,IACDA,EAAejR,MAEnBkR,EAAU1nB,KAAK,CACXwM,EAAGub,EACHrb,EAAGsb,EACH3mB,GAAI6H,EAAOnI,MAAMgT,GACjB8T,WAAYrR,KAAiBiR,IAEjCE,EAA+B,oBAAdM,WAA6B3E,aAAe2E,UACvDpN,GAAkBqN,KAClB5E,aAAe6E,WACXtN,GAAkBuN,UAClBvN,GAAkBwN,aAC5Bf,EAAW,CACXnS,UAAU,KAERsP,EAAW,CACb3Q,GAAG,YAAagU,EAAgBriB,GAChCqO,GAAG,YAAagU,EAAgBriB,GAChCqO,GAAG,OAAQgU,EAAgBriB,IAE/B,OAAOkc,GAAgB,KACnB8C,EAAS5iB,QAASgjB,GAAMA,MAEhC,CAmoB6ByD,CAAiBtB,GACpCuB,EAnoBV,UAAsC,mBAAEC,EAAkB,IAAE/iB,EAAG,OAAEyD,EAAM,WAAEC,EAAU,cAAEC,EAAa,gBAAEC,EAAe,SAAEga,IACjH,IAAkC,IAA9BA,EAASoF,iBACT,MAAO,OAGX,MAAMC,GAA2C,IAA9BrF,EAASoF,uBACM5qB,IAA9BwlB,EAASoF,iBACP,CAAC,EACDpF,EAASoF,iBACThE,EAAW,GACjB,IAAIkE,EAAqB,KAkFzB,OApBApqB,OAAOkD,KAAKsZ,IACP6D,OAAQtJ,GAAQsT,OAAOC,MAAMD,OAAOtT,MACpCA,EAAIhE,SAAS,eACM,IAApBoX,EAAWpT,IACVzT,QAASinB,IACV,IAAInE,EAAYhiB,EAAYmmB,GAC5B,MAAMrH,EAnES,CAACqH,GACRvQ,IACJ,MAAMxE,EAASgO,GAAexJ,GAC9B,GAAIT,GAAU/D,EAAQ5K,EAAYC,EAAeC,GAAiB,GAC9D,OAEJ,IAAI0f,EAAc,KACdC,EAAeF,EACnB,GAAI,gBAAiBvQ,EAAO,CACxB,OAAQA,EAAMwQ,aACV,IAAK,QACDA,EAAc9N,GAAagO,MAC3B,MACJ,IAAK,QACDF,EAAc9N,GAAaiO,MAC3B,MACJ,IAAK,MACDH,EAAc9N,GAAakO,IAG/BJ,IAAgB9N,GAAaiO,MACzBnO,GAAkB+N,KAAc/N,GAAkBqO,UAClDJ,EAAe,aAEVjO,GAAkB+N,KAAc/N,GAAkBsO,UACvDL,EAAe,YAGE/N,GAAakO,GAC1C,MACS7Q,GAAoBC,KACzBwQ,EAAc9N,GAAaiO,OAEX,OAAhBH,GACAJ,EAAqBI,GAChBC,EAAaM,WAAW,UACzBP,IAAgB9N,GAAaiO,OAC5BF,EAAaM,WAAW,UACrBP,IAAgB9N,GAAagO,SACjCF,EAAc,OAGbhO,GAAkB+N,KAAc/N,GAAkBwO,QACvDR,EAAcJ,EACdA,EAAqB,MAEzB,MAAM9f,EAAIyP,GAAoBC,GAASA,EAAMC,eAAe,GAAKD,EACjE,IAAK1P,EACD,OAEJ,MAAMxH,EAAK6H,EAAOnI,MAAMgT,IAClB,QAAEgU,EAAO,QAAEC,GAAYnf,EAC7B8Y,GAAgB6G,EAAhB7G,CAAoC,CAChCjf,KAAMqY,GAAkBiO,GACxB3nB,KACAmL,EAAGub,EACHrb,EAAGsb,KACiB,OAAhBe,GAAwB,CAAEA,kBAUtBS,CAAWV,GAC3B,GAAIrT,OAAOgU,aACP,OAAQ1O,GAAkB+N,IACtB,KAAK/N,GAAkBqO,UACvB,KAAKrO,GAAkBsO,QACnB1E,EAAYA,EAAUvlB,QAAQ,QAAS,WACvC,MACJ,KAAK2b,GAAkB2O,WACvB,KAAK3O,GAAkB4O,SACnB,OAGZlF,EAASzkB,KAAK8T,GAAG6Q,EAAWlD,EAAShc,MAElCkc,GAAgB,KACnB8C,EAAS5iB,QAASgjB,GAAMA,MAEhC,CAoiBoC+E,CAA6B5C,GACvD6C,EAAgB1G,GAAmB6D,GACnC8C,EA3gBV,UAAoC,iBAAEC,IAAoB,IAAEnX,IACxD,IAAIoX,GAAS,EACTC,GAAS,EAab,OAAOnW,GAAG,SAZc6N,GAAgBtN,GAAWsN,GAAgB,KAC/D,MAAMhV,EAAS4K,KACT9K,EAAQiL,KACVsS,IAAUrd,GAAUsd,IAAUxd,IAC9Bsd,EAAiB,CACbtd,MAAOmc,OAAOnc,GACdE,OAAQic,OAAOjc,KAEnBqd,EAAQrd,EACRsd,EAAQxd,KAEZ,MACiCmG,EACzC,CA2fkCsX,CAA2BlD,EAAG,CACxDpU,IAAKgS,IAEHuF,EAAevG,GAAkBoD,GACjCoD,EApIV,UAAsC,mBAAEC,EAAkB,WAAElhB,EAAU,cAAEC,EAAa,gBAAEC,EAAe,OAAEH,EAAM,SAAEma,EAAQ,IAAE5d,IACtH,MAAMgc,EAAUE,GAAiBjf,GAAS2R,GAAWsN,GAAiBpJ,IAClE,MAAMxE,EAASgO,GAAexJ,GAC9B,IAAKxE,GACD+D,GAAU/D,EAAQ5K,EAAYC,EAAeC,GAAiB,GAC9D,OAEJ,MAAM,YAAEwF,EAAW,OAAEyb,EAAM,MAAEC,EAAK,aAAEC,GAAiBzW,EACrDsW,EAAmB,CACf3nB,OACArB,GAAI6H,EAAOnI,MAAMgT,GACjBlF,cACAyb,SACAC,QACAC,mBAEJnH,EAASnjB,OAAS,MAChBukB,EAAW,CACb3Q,GAAG,OAAQ2N,EAAQ,GAAIhc,GACvBqO,GAAG,QAAS2N,EAAQ,GAAIhc,GACxBqO,GAAG,SAAU2N,EAAQ,GAAIhc,GACzBqO,GAAG,eAAgB2N,EAAQ,GAAIhc,GAC/BqO,GAAG,aAAc2N,EAAQ,GAAIhc,IAEjC,OAAOkc,GAAgB,KACnB8C,EAAS5iB,QAASgjB,GAAMA,MAEhC,CAyGoC4F,CAA6BzD,GACvD0D,EAlXV,UAAgC,iBAAEC,EAAgB,OAAEzhB,EAAM,kBAAEyU,IAAqB,IAAE/K,IAC/E,IAAKA,EAAIgY,gBAAkBhY,EAAIgY,cAAcpsB,UACzC,MAAO,OAGX,MAAMqsB,EAAajY,EAAIgY,cAAcpsB,UAAUqsB,WAC/CjY,EAAIgY,cAAcpsB,UAAUqsB,WAAa,IAAIzU,MAAMyU,EAAY,CAC3D3V,MAAOyM,GAAgB,CAAC5N,EAAQ+W,EAASC,KACrC,MAAOzrB,EAAMoc,GAASqP,GAChB,GAAE1pB,EAAE,QAAE6kB,GAAYF,GAAgB8E,EAAS5hB,EAAQyU,EAAkBsI,aAQ3E,OAPK5kB,IAAc,IAARA,GAAe6kB,IAAwB,IAAbA,IACjCyE,EAAiB,CACbtpB,KACA6kB,UACAjJ,KAAM,CAAC,CAAE3d,OAAMoc,YAGhB3H,EAAOmB,MAAM4V,EAASC,OAGrC,MAAMC,EAAapY,EAAIgY,cAAcpsB,UAAUwsB,WAe/C,IAAI5rB,EAkBA6rB,EAhCJrY,EAAIgY,cAAcpsB,UAAUwsB,WAAa,IAAI5U,MAAM4U,EAAY,CAC3D9V,MAAOyM,GAAgB,CAAC5N,EAAQ+W,EAASC,KACrC,MAAOrP,GAASqP,GACV,GAAE1pB,EAAE,QAAE6kB,GAAYF,GAAgB8E,EAAS5hB,EAAQyU,EAAkBsI,aAQ3E,OAPK5kB,IAAc,IAARA,GAAe6kB,IAAwB,IAAbA,IACjCyE,EAAiB,CACbtpB,KACA6kB,UACA5J,QAAS,CAAC,CAAEZ,YAGb3H,EAAOmB,MAAM4V,EAASC,OAIjCnY,EAAIgY,cAAcpsB,UAAUY,UAC5BA,EAAUwT,EAAIgY,cAAcpsB,UAAUY,QACtCwT,EAAIgY,cAAcpsB,UAAUY,QAAU,IAAIgX,MAAMhX,EAAS,CACrD8V,MAAOyM,GAAgB,CAAC5N,EAAQ+W,EAASC,KACrC,MAAO/nB,GAAQ+nB,GACT,GAAE1pB,EAAE,QAAE6kB,GAAYF,GAAgB8E,EAAS5hB,EAAQyU,EAAkBsI,aAQ3E,OAPK5kB,IAAc,IAARA,GAAe6kB,IAAwB,IAAbA,IACjCyE,EAAiB,CACbtpB,KACA6kB,UACA9mB,QAAS4D,IAGV+Q,EAAOmB,MAAM4V,EAASC,QAKrCnY,EAAIgY,cAAcpsB,UAAUysB,cAC5BA,EAAcrY,EAAIgY,cAAcpsB,UAAUysB,YAC1CrY,EAAIgY,cAAcpsB,UAAUysB,YAAc,IAAI7U,MAAM6U,EAAa,CAC7D/V,MAAOyM,GAAgB,CAAC5N,EAAQ+W,EAASC,KACrC,MAAO/nB,GAAQ+nB,GACT,GAAE1pB,EAAE,QAAE6kB,GAAYF,GAAgB8E,EAAS5hB,EAAQyU,EAAkBsI,aAQ3E,OAPK5kB,IAAc,IAARA,GAAe6kB,IAAwB,IAAbA,IACjCyE,EAAiB,CACbtpB,KACA6kB,UACA+E,YAAajoB,IAGd+Q,EAAOmB,MAAM4V,EAASC,QAIzC,MAAMG,EAA8B,CAAC,EACjCC,GAA4B,mBAC5BD,EAA4BzF,gBAAkB7S,EAAI6S,iBAG9C0F,GAA4B,kBAC5BD,EAA4BxF,aAAe9S,EAAI8S,cAE/CyF,GAA4B,sBAC5BD,EAA4BtF,iBAAmBhT,EAAIgT,kBAEnDuF,GAA4B,qBAC5BD,EAA4BvF,gBAAkB/S,EAAI+S,kBAG1D,MAAMyF,EAAsB,CAAC,EA6C7B,OA5CA7sB,OAAO8sB,QAAQH,GAA6BrpB,QAAQ,EAAEypB,EAAS5oB,MAC3D0oB,EAAoBE,GAAW,CAC3BT,WAAYnoB,EAAKlE,UAAUqsB,WAC3BG,WAAYtoB,EAAKlE,UAAUwsB,YAE/BtoB,EAAKlE,UAAUqsB,WAAa,IAAIzU,MAAMgV,EAAoBE,GAAST,WAAY,CAC3E3V,MAAOyM,GAAgB,CAAC5N,EAAQ+W,EAASC,KACrC,MAAOzrB,EAAMoc,GAASqP,GAChB,GAAE1pB,EAAE,QAAE6kB,GAAYF,GAAgB8E,EAAQhF,iBAAkB5c,EAAQyU,EAAkBsI,aAgB5F,OAfK5kB,IAAc,IAARA,GAAe6kB,IAAwB,IAAbA,IACjCyE,EAAiB,CACbtpB,KACA6kB,UACAjJ,KAAM,CACF,CACI3d,OACAoc,MAAO,IACA2J,GAA0ByF,GAC7BpP,GAAS,OAMtB3H,EAAOmB,MAAM4V,EAASC,OAGrCroB,EAAKlE,UAAUwsB,WAAa,IAAI5U,MAAMgV,EAAoBE,GAASN,WAAY,CAC3E9V,MAAOyM,GAAgB,CAAC5N,EAAQ+W,EAASC,KACrC,MAAOrP,GAASqP,GACV,GAAE1pB,EAAE,QAAE6kB,GAAYF,GAAgB8E,EAAQhF,iBAAkB5c,EAAQyU,EAAkBsI,aAU5F,OATK5kB,IAAc,IAARA,GAAe6kB,IAAwB,IAAbA,IACjCyE,EAAiB,CACbtpB,KACA6kB,UACA5J,QAAS,CACL,CAAEZ,MAAO,IAAI2J,GAA0ByF,GAAUpP,OAItD3H,EAAOmB,MAAM4V,EAASC,SAIlCpJ,GAAgB,KACnB/O,EAAIgY,cAAcpsB,UAAUqsB,WAAaA,EACzCjY,EAAIgY,cAAcpsB,UAAUwsB,WAAaA,EACzC5rB,IAAYwT,EAAIgY,cAAcpsB,UAAUY,QAAUA,GAClD6rB,IAAgBrY,EAAIgY,cAAcpsB,UAAUysB,YAAcA,GAC1D1sB,OAAO8sB,QAAQH,GAA6BrpB,QAAQ,EAAEypB,EAAS5oB,MAC3DA,EAAKlE,UAAUqsB,WAAaO,EAAoBE,GAAST,WACzDnoB,EAAKlE,UAAUwsB,WAAaI,EAAoBE,GAASN,cAGrE,CAqO+BO,CAAuBvE,EAAG,CAAEpU,IAAKgS,IACtD4G,EAA4BpF,GAA8BY,EAAGA,EAAEvhB,KAC/DgmB,EAzLV,UAAsC,mBAAEC,EAAkB,OAAExiB,EAAM,oBAAEyiB,EAAmB,kBAAEhO,IAAsB,IAAE/K,IAC7G,MAAMgZ,EAAchZ,EAAIiZ,oBAAoBrtB,UAAUotB,YACtDhZ,EAAIiZ,oBAAoBrtB,UAAUotB,YAAc,IAAIxV,MAAMwV,EAAa,CACnE1W,MAAOyM,GAAgB,CAAC5N,EAAQ+W,EAASC,KACrC,MAAOrZ,EAAUpU,EAAOwuB,GAAYf,EACpC,GAAIY,EAAoB5pB,IAAI2P,GACxB,OAAOka,EAAY1W,MAAM4V,EAAS,CAACpZ,EAAUpU,EAAOwuB,IAExD,MAAM,GAAEzqB,EAAE,QAAE6kB,GAAYF,GAAgBnE,GAAiB,CAACiJ,EAAS,SAAUiB,GAAOA,EAAIvG,WAAY,iBAAkB3M,GAAOA,EAAIiN,mBAAoB5c,EAAQyU,EAAkBsI,aAa/K,OAZK5kB,IAAc,IAARA,GAAe6kB,IAAwB,IAAbA,IACjCwF,EAAmB,CACfrqB,KACA6kB,UACA9jB,IAAK,CACDsP,WACApU,QACAwuB,YAEJpQ,MAAO2J,GAA0ByF,EAAQtF,cAG1CzR,EAAOmB,MAAM4V,EAASC,OAGrC,MAAMiB,EAAiBpZ,EAAIiZ,oBAAoBrtB,UAAUwtB,eAqBzD,OApBApZ,EAAIiZ,oBAAoBrtB,UAAUwtB,eAAiB,IAAI5V,MAAM4V,EAAgB,CACzE9W,MAAOyM,GAAgB,CAAC5N,EAAQ+W,EAASC,KACrC,MAAOrZ,GAAYqZ,EACnB,GAAIY,EAAoB5pB,IAAI2P,GACxB,OAAOsa,EAAe9W,MAAM4V,EAAS,CAACpZ,IAE1C,MAAM,GAAErQ,EAAE,QAAE6kB,GAAYF,GAAgBnE,GAAiB,CAACiJ,EAAS,SAAUvR,GAAOA,EAAIiM,WAAY,iBAAkB/L,GAAOA,EAAIqM,mBAAoB5c,EAAQyU,EAAkBsI,aAW/K,OAVK5kB,IAAc,IAARA,GAAe6kB,IAAwB,IAAbA,IACjCwF,EAAmB,CACfrqB,KACA6kB,UACA+F,OAAQ,CACJva,YAEJgK,MAAO2J,GAA0ByF,EAAQtF,cAG1CzR,EAAOmB,MAAM4V,EAASC,OAG9BpJ,GAAgB,KACnB/O,EAAIiZ,oBAAoBrtB,UAAUotB,YAAcA,EAChDhZ,EAAIiZ,oBAAoBrtB,UAAUwtB,eAAiBA,GAE3D,CAwIqCE,CAA6BlF,EAAG,CAC7DpU,IAAKgS,IAEHuH,EAAenF,EAAEoF,aA9G3B,UAA0B,OAAEC,EAAM,IAAE5mB,IAChC,MAAMmN,EAAMnN,EAAI8d,YAChB,IAAK3Q,EACD,MAAO,OAGX,MAAM6R,EAAW,GACX6H,EAAU,IAAIxrB,QACdyrB,EAAmB3Z,EAAI4Z,SAC7B5Z,EAAI4Z,SAAW,SAAkBC,EAAQ3W,EAAQ4W,GAC7C,MAAMC,EAAW,IAAIJ,EAAiBE,EAAQ3W,EAAQ4W,GAStD,OARAJ,EAAQlqB,IAAIuqB,EAAU,CAClBF,SACAvf,OAA0B,iBAAX4I,EACf4W,cACAE,WAA8B,iBAAX9W,EACbA,EACAlW,KAAKC,UAAUd,MAAMC,KAAK,IAAI6tB,WAAW/W,OAE5C6W,CACX,EACA,MAAMG,EAAiBjX,GAAMpQ,EAAIsnB,MAAO,MAAO,SAAUrX,GACrD,OAAO,SAAUiX,GAQb,OAPAvX,GAAauM,GAAgB,KACzB,MAAMyD,EAAIkH,EAAQ/qB,IAAIorB,GAClBvH,IACAiH,EAAOjH,GACPkH,EAAQ3qB,OAAOgrB,MAEnB,GACGjX,EAASR,MAAMxU,KAAM,CAACisB,GACjC,CACJ,GAKA,OAJAlI,EAASzkB,KAAK,KACV4S,EAAI4Z,SAAWD,IAEnB9H,EAASzkB,KAAK8sB,GACPnL,GAAgB,KACnB8C,EAAS5iB,QAASgjB,GAAMA,MAEhC,CAuEUmI,CAAiBhG,GACjB,OAEAiG,EAzEV,SAA+BC,GAC3B,MAAM,IAAEznB,EAAG,OAAEyD,EAAM,WAAEC,EAAU,cAAEC,EAAa,gBAAEC,EAAe,YAAE8jB,GAAiBD,EAClF,IAAIE,GAAY,EAChB,MAAMC,EAAkB1L,GAAgB,KACpC,MAAM2L,EAAY7nB,EAAI8nB,eACtB,IAAKD,GAAcF,GAAavL,GAAiB,CAACyL,EAAW,iBAAkB5T,GAAOA,EAAI8T,cACtF,OACJJ,EAAYE,EAAUE,cAAe,EACrC,MAAMC,EAAS,GACTC,EAAQJ,EAAUK,YAAc,EACtC,IAAK,IAAIpwB,EAAI,EAAGA,EAAImwB,EAAOnwB,IAAK,CAC5B,MAAMqwB,EAAQN,EAAUO,WAAWtwB,IAC7B,eAAEuwB,EAAc,YAAEC,EAAW,aAAEC,EAAY,UAAEC,GAAcL,EACjD9V,GAAUgW,EAAgB3kB,EAAYC,EAAeC,GAAiB,IAClFyO,GAAUkW,EAAc7kB,EAAYC,EAAeC,GAAiB,IAGxEokB,EAAOztB,KAAK,CACRkuB,MAAOhlB,EAAOnI,MAAM+sB,GACpBC,cACAI,IAAKjlB,EAAOnI,MAAMitB,GAClBC,aAER,CACAd,EAAY,CAAEM,aAGlB,OADAJ,IACOvZ,GAAG,kBAAmBuZ,EACjC,CA6C8Be,CAAsBpH,GAC1CqH,EA7CV,UAAmC,IAAE5oB,EAAG,gBAAE6oB,IACtC,MAAM1b,EAAMnN,EAAI8d,YAChB,OAAK3Q,GAAQA,EAAIlD,eAEMmG,GAAMjD,EAAIlD,eAAgB,SAAU,SAAUgG,GACjE,OAAO,SAAUzP,EAAMxF,EAAawI,GAChC,IACIqlB,EAAgB,CACZC,OAAQ,CACJtoB,SAGZ,CACA,MAAO4C,GACP,CACA,OAAO6M,EAASR,MAAMxU,KAAM,CAACuF,EAAMxF,EAAawI,GACpD,CACJ,GAdW,MAgBf,CA0BkCulB,CAA0BxH,GAClDyH,EAAiB,GACvB,IAAK,MAAMC,KAAU1H,EAAE2H,QACnBF,EAAezuB,KAAK0uB,EAAO/L,SAAS+L,EAAOE,SAAUhK,EAAe8J,EAAOzlB,UAE/E,OAAO0Y,GAAgB,KACnBG,GAAgBjgB,QAASgtB,GAAMA,EAAEvsB,SACjC4kB,EAAiB4H,aACjB3H,IACAoB,IACAsB,IACAC,IACAK,IACAC,IACAM,IACAc,IACAC,IACAU,IACAc,IACAoB,IACAI,EAAe5sB,QAASgjB,GAAMA,MAEtC,CACA,SAASU,GAAiBjP,GACtB,YAA+B,IAAjBb,OAAOa,EACzB,CACA,SAAS6U,GAA4B7U,GACjC,OAAOnY,aAAgC,IAAjBsX,OAAOa,IACzBb,OAAOa,GAAM9X,WACb,eAAgBiX,OAAOa,GAAM9X,WAC7B,eAAgBiX,OAAOa,GAAM9X,UACrC,CAEA,MAAMuwB,GACF,WAAAtuB,CAAYuuB,GACRtuB,KAAKsuB,aAAeA,EACpBtuB,KAAKuuB,sBAAwB,IAAInuB,QACjCJ,KAAKwuB,sBAAwB,IAAIpuB,OACrC,CACA,KAAAC,CAAMgd,EAAQoR,EAAUC,EAAeC,GACnC,MAAMC,EAAkBF,GAAiB1uB,KAAK6uB,mBAAmBxR,GAC3DyR,EAAkBH,GAAiB3uB,KAAK+uB,mBAAmB1R,GACjE,IAAI1c,EAAKiuB,EAAgB/tB,IAAI4tB,GAM7B,OALK9tB,IACDA,EAAKX,KAAKsuB,eACVM,EAAgBltB,IAAI+sB,EAAU9tB,GAC9BmuB,EAAgBptB,IAAIf,EAAI8tB,IAErB9tB,CACX,CACA,MAAAG,CAAOuc,EAAQoR,GACX,MAAMG,EAAkB5uB,KAAK6uB,mBAAmBxR,GAC1CyR,EAAkB9uB,KAAK+uB,mBAAmB1R,GAChD,OAAOoR,EAAS/a,IAAK/S,GAAOX,KAAKK,MAAMgd,EAAQ1c,EAAIiuB,EAAiBE,GACxE,CACA,WAAAE,CAAY3R,EAAQ1c,EAAI+S,GACpB,MAAMob,EAAkBpb,GAAO1T,KAAK+uB,mBAAmB1R,GACvD,GAAkB,iBAAP1c,EACP,OAAOA,EAEX,OADiBmuB,EAAgBjuB,IAAIF,KAEzB,CAEhB,CACA,YAAAsuB,CAAa5R,EAAQ6R,GACjB,MAAMJ,EAAkB9uB,KAAK+uB,mBAAmB1R,GAChD,OAAO6R,EAAIxb,IAAK/S,GAAOX,KAAKgvB,YAAY3R,EAAQ1c,EAAImuB,GACxD,CACA,KAAAltB,CAAMyb,GACF,IAAKA,EAGD,OAFArd,KAAKuuB,sBAAwB,IAAInuB,aACjCJ,KAAKwuB,sBAAwB,IAAIpuB,SAGrCJ,KAAKuuB,sBAAsBttB,OAAOoc,GAClCrd,KAAKwuB,sBAAsBvtB,OAAOoc,EACtC,CACA,kBAAAwR,CAAmBxR,GACf,IAAIuR,EAAkB5uB,KAAKuuB,sBAAsB1tB,IAAIwc,GAKrD,OAJKuR,IACDA,EAAkB,IAAI1uB,IACtBF,KAAKuuB,sBAAsB7sB,IAAI2b,EAAQuR,IAEpCA,CACX,CACA,kBAAAG,CAAmB1R,GACf,IAAIyR,EAAkB9uB,KAAKwuB,sBAAsB3tB,IAAIwc,GAKrD,OAJKyR,IACDA,EAAkB,IAAI5uB,IACtBF,KAAKwuB,sBAAsB9sB,IAAI2b,EAAQyR,IAEpCA,CACX,EAGJ,SAASK,GAAiBzyB,GAAO,IAAIC,EAA+BC,EAAQF,EAAI,GAAQG,EAAI,EAAG,KAAOA,EAAIH,EAAII,QAAQ,CAAE,MAAMC,EAAKL,EAAIG,GAAUG,EAAKN,EAAIG,EAAI,GAAY,GAARA,GAAK,GAAe,mBAAPE,GAAkC,iBAAPA,IAAmC,MAATH,EAAiB,OAA+B,WAAPG,GAA0B,mBAAPA,GAA2BJ,EAAgBC,EAAOA,EAAQI,EAAGJ,IAA0B,SAAPG,GAAwB,iBAAPA,IAAyBH,EAAQI,EAAG,IAAIC,IAASL,EAAMM,KAAKP,KAAkBM,IAAQN,OAAgBQ,EAAa,CAAE,OAAOP,CAAO,CACpgB,MAAMwyB,GACF,WAAArvB,GACIC,KAAKqvB,wBAA0B,IAAIhB,GAAwBlrB,GAC3DnD,KAAKsvB,2BAA6B,IAAIlvB,OAC1C,CACA,SAAA4c,GACA,CACA,eAAAuS,GACA,CACA,YAAAhS,GACA,EAEJ,MAAMiS,GACF,WAAAzvB,CAAYwI,GACRvI,KAAKyvB,QAAU,IAAIrvB,QACnBJ,KAAK0vB,qBAAuB,IAAItvB,QAChCJ,KAAKqvB,wBAA0B,IAAIhB,GAAwBlrB,GAC3DnD,KAAKsvB,2BAA6B,IAAIlvB,QACtCJ,KAAKye,WAAalW,EAAQkW,WAC1Bze,KAAK2vB,YAAcpnB,EAAQonB,YAC3B3vB,KAAKid,kBAAoB1U,EAAQ0U,kBACjCjd,KAAK4vB,yBAA2BrnB,EAAQqnB,yBACxC5vB,KAAK6vB,6BAA+B,IAAIxB,GAAwBruB,KAAKid,kBAAkBsI,YAAY7M,WAAWsB,KAAKha,KAAKid,kBAAkBsI,cAC1IvlB,KAAKwI,OAASD,EAAQC,OAClBxI,KAAK4vB,0BACL7a,OAAOhH,iBAAiB,UAAW/N,KAAK8vB,cAAc9V,KAAKha,MAEnE,CACA,SAAAgd,CAAUhL,GACNhS,KAAKyvB,QAAQ/tB,IAAIsQ,GAAU,GACvBA,EAASG,eACTnS,KAAK0vB,qBAAqBhuB,IAAIsQ,EAASG,cAAeH,EAC9D,CACA,eAAAud,CAAgBrO,GACZlhB,KAAK+vB,aAAe7O,CACxB,CACA,YAAA3D,CAAavL,EAAUsL,GACnBtd,KAAKye,WAAW,CACZlC,KAAM,CACF,CACIjB,SAAUtb,KAAKwI,OAAOnI,MAAM2R,GAC5B4K,OAAQ,KACRrb,KAAM+b,IAGd1B,QAAS,GACTF,MAAO,GACP9Q,WAAY,GACZolB,gBAAgB,IAEpBb,GAAiB,CAACnvB,KAAM,SAAUxC,GAAKA,EAAEuyB,aAAc,eAAgBryB,GAAMA,EAAGsU,KAC5EA,EAASlD,iBACTkD,EAASlD,gBAAgBmhB,oBACzBje,EAASlD,gBAAgBmhB,mBAAmBnzB,OAAS,GACrDkD,KAAKid,kBAAkBmJ,iBAAiBpU,EAASlD,gBAAgBmhB,mBAAoBjwB,KAAKwI,OAAOnI,MAAM2R,EAASlD,iBACxH,CACA,aAAAghB,CAAcI,GACV,MAAMC,EAA0BD,EAChC,GAA0C,UAAtCC,EAAwB5jB,KAAKvK,MAC7BmuB,EAAwBxsB,SAAWwsB,EAAwB5jB,KAAK5I,OAChE,OAEJ,IAD2BusB,EAAQ9a,OAE/B,OACJ,MAAMpD,EAAWhS,KAAK0vB,qBAAqB7uB,IAAIqvB,EAAQ9a,QACvD,IAAKpD,EACD,OACJ,MAAMoe,EAAmBpwB,KAAKqwB,0BAA0Bre,EAAUme,EAAwB5jB,KAAKsL,OAC3FuY,GACApwB,KAAK2vB,YAAYS,EAAkBD,EAAwB5jB,KAAK+jB,WACxE,CACA,yBAAAD,CAA0Bre,EAAU7J,GAChC,OAAQA,EAAEnG,MACN,KAAKiY,GAAUsW,aAAc,CACzBvwB,KAAKqvB,wBAAwBztB,MAAMoQ,GACnChS,KAAK6vB,6BAA6BjuB,MAAMoQ,GACxChS,KAAKwwB,gBAAgBroB,EAAEoE,KAAKhL,KAAMyQ,GAClC,MAAMpI,EAASzB,EAAEoE,KAAKhL,KAAKZ,GAG3B,OAFAX,KAAKsvB,2BAA2B5tB,IAAIsQ,EAAUpI,GAC9C5J,KAAKywB,kBAAkBtoB,EAAEoE,KAAKhL,KAAMqI,GAC7B,CACH8mB,UAAWvoB,EAAEuoB,UACb1uB,KAAMiY,GAAU0W,oBAChBpkB,KAAM,CACF6I,OAAQ+E,GAAkByW,SAC1BrU,KAAM,CACF,CACIjB,SAAUtb,KAAKwI,OAAOnI,MAAM2R,GAC5B4K,OAAQ,KACRrb,KAAM4G,EAAEoE,KAAKhL,OAGrBqa,QAAS,GACTF,MAAO,GACP9Q,WAAY,GACZolB,gBAAgB,GAG5B,CACA,KAAK/V,GAAU4W,KACf,KAAK5W,GAAU6W,KACf,KAAK7W,GAAU8W,iBACX,OAAO,EAEX,KAAK9W,GAAU+W,OACX,OAAO7oB,EAEX,KAAK8R,GAAUgX,OAEX,OADAjxB,KAAKkxB,WAAW/oB,EAAEoE,KAAK0R,QAASjM,EAAU,CAAC,KAAM,WAAY,aAAc,WACpE7J,EAEX,KAAK8R,GAAU0W,oBACX,OAAQxoB,EAAEoE,KAAK6I,QACX,KAAK+E,GAAkByW,SAoBnB,OAnBAzoB,EAAEoE,KAAKgQ,KAAKpb,QAAS7D,IACjB0C,KAAKkxB,WAAW5zB,EAAG0U,EAAU,CACzB,WACA,SACA,eAEJhS,KAAKwwB,gBAAgBlzB,EAAEiE,KAAMyQ,GAC7B,MAAMpI,EAAS5J,KAAKsvB,2BAA2BzuB,IAAImR,GACnDpI,GAAU5J,KAAKywB,kBAAkBnzB,EAAEiE,KAAMqI,KAE7CzB,EAAEoE,KAAKqP,QAAQza,QAAS7D,IACpB0C,KAAKkxB,WAAW5zB,EAAG0U,EAAU,CAAC,WAAY,SAE9C7J,EAAEoE,KAAK3B,WAAWzJ,QAAS7D,IACvB0C,KAAKkxB,WAAW5zB,EAAG0U,EAAU,CAAC,SAElC7J,EAAEoE,KAAKmP,MAAMva,QAAS7D,IAClB0C,KAAKkxB,WAAW5zB,EAAG0U,EAAU,CAAC,SAE3B7J,EAEX,KAAKgS,GAAkBqN,KACvB,KAAKrN,GAAkBwN,UACvB,KAAKxN,GAAkBuN,UAInB,OAHAvf,EAAEoE,KAAKya,UAAU7lB,QAASujB,IACtB1kB,KAAKkxB,WAAWxM,EAAG1S,EAAU,CAAC,SAE3B7J,EAEX,KAAKgS,GAAkBgX,eACnB,OAAO,EAEX,KAAKhX,GAAkBiX,iBACvB,KAAKjX,GAAkBkX,iBACvB,KAAKlX,GAAkBmX,OACvB,KAAKnX,GAAkBoX,eACvB,KAAKpX,GAAkBqX,MAEnB,OADAxxB,KAAKkxB,WAAW/oB,EAAEoE,KAAMyF,EAAU,CAAC,OAC5B7J,EAEX,KAAKgS,GAAkBsX,eACvB,KAAKtX,GAAkBuX,iBAGnB,OAFA1xB,KAAKkxB,WAAW/oB,EAAEoE,KAAMyF,EAAU,CAAC,OACnChS,KAAK2xB,gBAAgBxpB,EAAEoE,KAAMyF,EAAU,CAAC,YACjC7J,EAEX,KAAKgS,GAAkByX,KACnB,OAAOzpB,EAEX,KAAKgS,GAAkB0X,UAInB,OAHA1pB,EAAEoE,KAAKwgB,OAAO5rB,QAAS+rB,IACnBltB,KAAKkxB,WAAWhE,EAAOlb,EAAU,CAAC,QAAS,UAExC7J,EAEX,KAAKgS,GAAkB2X,kBAMnB,OALA9xB,KAAKkxB,WAAW/oB,EAAEoE,KAAMyF,EAAU,CAAC,OACnChS,KAAK2xB,gBAAgBxpB,EAAEoE,KAAMyF,EAAU,CAAC,aACxCmd,GAAiB,CAAChnB,EAAG,SAAU5H,GAAMA,EAAGgM,KAAM,SAAU9L,GAAMA,EAAGsxB,OAAQ,iBAAkBrxB,GAAMA,EAAGS,QAAS,OAAQ0O,GAAMA,EAAIuO,IAC3Hpe,KAAK2xB,gBAAgBvT,EAAOpM,EAAU,CAAC,gBAEpC7J,GAKvB,OAAO,CACX,CACA,OAAAzJ,CAAQszB,EAAcC,EAAKjgB,EAAUjR,GACjC,IAAK,MAAM6T,KAAO7T,GACT1C,MAAM6zB,QAAQD,EAAIrd,KAA6B,iBAAbqd,EAAIrd,MAEvCvW,MAAM6zB,QAAQD,EAAIrd,IAClBqd,EAAIrd,GAAOod,EAAalxB,OAAOkR,EAAUigB,EAAIrd,IAG7Cqd,EAAIrd,GAAOod,EAAa3xB,MAAM2R,EAAUigB,EAAIrd,KAGpD,OAAOqd,CACX,CACA,UAAAf,CAAWe,EAAKjgB,EAAUjR,GACtB,OAAOf,KAAKtB,QAAQsB,KAAKqvB,wBAAyB4C,EAAKjgB,EAAUjR,EACrE,CACA,eAAA4wB,CAAgBM,EAAKjgB,EAAUjR,GAC3B,OAAOf,KAAKtB,QAAQsB,KAAK6vB,6BAA8BoC,EAAKjgB,EAAUjR,EAC1E,CACA,eAAAyvB,CAAgBjvB,EAAMyQ,GAClBhS,KAAKkxB,WAAW3vB,EAAMyQ,EAAU,CAAC,KAAM,WACnC,eAAgBzQ,GAChBA,EAAKL,WAAWC,QAASgxB,IACrBnyB,KAAKwwB,gBAAgB2B,EAAOngB,IAGxC,CACA,iBAAAye,CAAkBlvB,EAAMqI,GAChBrI,EAAKS,OAAS5E,EAAW6M,UAAa1I,EAAKqI,SAC3CrI,EAAKqI,OAASA,GACd,eAAgBrI,GAChBA,EAAKL,WAAWC,QAASgxB,IACrBnyB,KAAKywB,kBAAkB0B,EAAOvoB,IAG1C,EAGJ,MAAMwoB,GACF,IAAAnS,GACA,CACA,aAAA7C,GACA,CACA,mBAAAI,GACA,CACA,KAAA5b,GACA,EAEJ,MAAMywB,GACF,WAAAtyB,CAAYwI,GACRvI,KAAKsyB,WAAa,IAAIC,QACtBvyB,KAAKwyB,gBAAkB,GACvBxyB,KAAKye,WAAalW,EAAQkW,WAC1Bze,KAAK0iB,SAAWna,EAAQma,SACxB1iB,KAAK2R,cAAgBpJ,EAAQoJ,cAC7B3R,KAAKwI,OAASD,EAAQC,OACtBxI,KAAKigB,MACT,CACA,IAAAA,GACIjgB,KAAK4B,QACL5B,KAAKyyB,kBAAkBxjB,QAAS5J,SACpC,CACA,aAAA+X,CAAczf,EAAYoH,GACtB,IAAKnH,EAAkBD,GACnB,OACJ,GAAIqC,KAAKsyB,WAAWjxB,IAAI1D,GACpB,OACJqC,KAAKsyB,WAAW9wB,IAAI7D,GACpB,MAAMskB,EAAWT,GAAqB,IAC/BxhB,KAAK2R,cACR5M,MACA0Z,WAAYze,KAAKye,WACjBjW,OAAQxI,KAAKwI,OACb2U,iBAAkBnd,MACnBrC,GACHqC,KAAKwyB,gBAAgBlzB,KAAK,IAAM2iB,EAASmM,cACzCpuB,KAAKwyB,gBAAgBlzB,KAAKmjB,GAAmB,IACtCziB,KAAK2R,cACR+Q,SAAU1iB,KAAK0iB,SACf3d,IAAKpH,EACL6K,OAAQxI,KAAKwI,UAEjBkM,GAAa,KACL/W,EAAWsyB,oBACXtyB,EAAWsyB,mBAAmBnzB,OAAS,GACvCkD,KAAK2R,cAAcsL,kBAAkBmJ,iBAAiBzoB,EAAWsyB,mBAAoBjwB,KAAKwI,OAAOnI,MAAM1C,EAAWJ,OACtHyC,KAAKwyB,gBAAgBlzB,KAAKomB,GAA8B,CACpDld,OAAQxI,KAAKwI,OACbyU,kBAAmBjd,KAAK2R,cAAcsL,mBACvCtf,KACJ,EACP,CACA,mBAAA6f,CAAoBkV,GACXA,EAAcvgB,eAAkBugB,EAAc5jB,iBAEnD9O,KAAKyyB,kBAAkBC,EAAcvgB,cAAclD,QAASyjB,EAAc5jB,gBAC9E,CACA,iBAAA2jB,CAAkBrwB,EAAS2C,GACvB,MAAM4tB,EAAU3yB,KAChBA,KAAKwyB,gBAAgBlzB,KAAK6V,GAAM/S,EAAQtE,UAAW,eAAgB,SAAUkX,GACzE,OAAO,SAAU4d,GACb,MAAMj1B,EAAaqX,EAAS9X,KAAK8C,KAAM4yB,GAGvC,OAFI5yB,KAAKrC,YAAcwb,GAAMnZ,OACzB2yB,EAAQvV,cAAcpd,KAAKrC,WAAYoH,GACpCpH,CACX,CACJ,GACJ,CACA,KAAAiE,GACI5B,KAAKwyB,gBAAgBrxB,QAAS4f,IAC1B,IACIA,GACJ,CACA,MAAO5Y,GACP,IAEJnI,KAAKwyB,gBAAkB,GACvBxyB,KAAKsyB,WAAa,IAAIC,OAC1B,EAGJ,MAAMM,GACF,KAAAjxB,GACA,CACA,MAAAse,GACA,CACA,QAAAE,GACA,CACA,IAAAE,GACA,CACA,MAAAC,GACA,CACA,QAAAuS,GACA,EAGJ,MAAMC,GACF,WAAAhzB,CAAYwI,GACRvI,KAAKgzB,oBAAsB,IAAIT,QAC/BvyB,KAAKulB,YAAc,IAAIlN,GACvBrY,KAAKye,WAAalW,EAAQkW,WAC1Bze,KAAKizB,oBAAsB1qB,EAAQ0qB,mBACvC,CACA,iBAAAxV,CAAkByV,EAAQ5V,GAClB,aAAcA,EAAQ1S,YACtB5K,KAAKye,WAAW,CACZlC,KAAM,GACNX,QAAS,GACTF,MAAO,GACP9Q,WAAY,CACR,CACIjK,GAAI2c,EAAQ3c,GACZiK,WAAY0S,EACP1S,eAIrB5K,KAAKkd,iBAAiBgW,EAC1B,CACA,gBAAAhW,CAAiBgW,GACTlzB,KAAKgzB,oBAAoB3xB,IAAI6xB,KAEjClzB,KAAKgzB,oBAAoBxxB,IAAI0xB,GAC7BlzB,KAAKmzB,6BAA6BD,GACtC,CACA,gBAAA9M,CAAiBJ,EAAQL,GACrB,GAAsB,IAAlBK,EAAOlpB,OACP,OACJ,MAAMs2B,EAAwB,CAC1BzyB,GAAIglB,EACJ0N,SAAU,IAERtB,EAAS,GACf,IAAK,MAAM3mB,KAAS4a,EAAQ,CACxB,IAAIR,EACCxlB,KAAKulB,YAAYlkB,IAAI+J,GAWtBoa,EAAUxlB,KAAKulB,YAAYllB,MAAM+K,IAVjCoa,EAAUxlB,KAAKulB,YAAY/jB,IAAI4J,GAC/B2mB,EAAOzyB,KAAK,CACRkmB,UACAtnB,MAAOG,MAAMC,KAAK8M,EAAMlN,OAASo1B,QAAS,CAAC5S,EAAG1F,KAAU,CACpDpc,KAAML,EAAcmiB,GACpB1F,cAMZoY,EAAsBC,SAAS/zB,KAAKkmB,EACxC,CACIuM,EAAOj1B,OAAS,IAChBs2B,EAAsBrB,OAASA,GACnC/xB,KAAKizB,oBAAoBG,EAC7B,CACA,KAAAxxB,GACI5B,KAAKulB,YAAY3jB,QACjB5B,KAAKgzB,oBAAsB,IAAIT,OACnC,CACA,4BAAAY,CAA6BD,GAC7B,EAGJ,MAAMK,GACF,WAAAxzB,GACIC,KAAKwzB,QAAU,IAAIpzB,QACnBJ,KAAKyzB,MAAO,EACZzzB,KAAK0zB,mBACT,CACA,iBAAAA,IAt3DJ,YAAoCrf,GACzBC,GAAkB,wBAAlBA,IAA8CD,EACzD,CAq3DQsf,CAAwB,KACpB3zB,KAAK4zB,QACD5zB,KAAKyzB,MACLzzB,KAAK0zB,qBAEjB,CACA,aAAA3T,CAAcxe,EAAMsyB,GAChB,MAAMC,EAAU9zB,KAAKwzB,QAAQ3yB,IAAIU,GACjC,OAAQuyB,GAAWz1B,MAAMC,KAAKw1B,GAASrnB,KAAMD,GAAWA,IAAWqnB,EACvE,CACA,GAAAryB,CAAID,EAAMiL,GACNxM,KAAKwzB,QAAQ9xB,IAAIH,GAAOvB,KAAKwzB,QAAQ3yB,IAAIU,IAAS,IAAIya,KAAOxa,IAAIgL,GACrE,CACA,KAAAonB,GACI5zB,KAAKwzB,QAAU,IAAIpzB,OACvB,CACA,OAAA2zB,GACI/zB,KAAKyzB,MAAO,CAChB,EAGJ,IAAI9D,GACAqE,GACJ,MAAMxrB,GAjwGK,IAAI1I,EAkwGf,SAASm0B,GAAO1rB,EAAU,CAAC,GACvB,MAAM,KAAE+T,EAAI,iBAAE4X,EAAgB,iBAAEC,EAAgB,WAAE1rB,EAAa,WAAU,cAAEC,EAAgB,KAAI,gBAAEC,EAAkB,KAAI,YAAEya,EAAc,YAAW,eAAEC,EAAiB,KAAI,YAAEvb,GAAc,EAAK,cAAEJ,EAAgB,UAAS,gBAAEE,EAAkB,KAAI,iBAAED,EAAmB,KAAI,mBAAEE,EAAqB,KAAI,iBAAEgB,GAAmB,EAAI,cAAEurB,EAAetyB,iBAAkBuyB,EAAmBtrB,eAAgBurB,EAAe,gBAAE9uB,EAAe,YAAEnD,EAAW,WAAEyG,EAAU,cAAEyrB,EAAgB,KAAI,OAAEC,EAAM,SAAE7R,EAAW,CAAC,EAAC,eAAE3Z,EAAiB,CAAC,EAAC,cAAEyrB,EAAa,aAAEvrB,GAAe,EAAK,yBAAE0mB,GAA2B,EAAK,YAAE8E,GAAsC,qBAAxBnsB,EAAQmsB,YACxlBnsB,EAAQmsB,YACR,QAAM,qBAAEpR,GAAuB,EAAK,aAAEoI,GAAe,EAAK,aAAEziB,GAAe,EAAK,QAAEglB,EAAO,gBAAEzkB,EAAkB,KAAM,EAAK,oBAAEyhB,EAAsB,IAAIjP,IAAI,IAAG,aAAE6E,EAAY,WAAEqB,EAAU,iBAAEyS,GAAsBpsB,EACnNuY,GAAqBD,GACrB,MAAM+T,GAAkBhF,GAClB7a,OAAO8f,SAAW9f,OAExB,IAAI+f,GAAoB,EACxB,IAAKF,EACD,IACQ7f,OAAO8f,OAAOxvB,WACdyvB,GAAoB,EAE5B,CACA,MAAO3sB,GACH2sB,GAAoB,CACxB,CAEJ,GAAIF,IAAoBtY,EACpB,MAAM,IAAIxB,MAAM,kCAEE3d,IAAlBs3B,QAAsDt3B,IAAvBwlB,EAASgE,YACxChE,EAASgE,UAAY8N,GAEzBjsB,GAAO5G,QACP,MAAME,GAAqC,IAAlBsyB,EACnB,CACEW,OAAO,EACPC,MAAM,EACN,kBAAkB,EAClBC,OAAO,EACPC,OAAO,EACPC,QAAQ,EACRjI,OAAO,EACPkI,QAAQ,EACRC,KAAK,EACL/yB,MAAM,EACNgzB,MAAM,EACNlxB,KAAK,EACLmxB,MAAM,EACNvlB,UAAU,EACVwlB,QAAQ,EACRC,OAAO,EACPC,UAAU,QAEUv4B,IAAtBk3B,EACIA,EACA,CAAC,EACLtrB,GAAqC,IAApBurB,GAAgD,QAApBA,EAC7C,CACE5jB,QAAQ,EACRD,SAAS,EACTI,aAAa,EACba,gBAAgB,EAChBX,gBAAgB,EAChBE,gBAAgB,EAChBC,mBAAmB,EACnBE,sBAAsB,EACtBD,mBAAwC,QAApBmjB,EACpBxjB,qBAA0C,QAApBwjB,GAExBA,GAEI,CAAC,EAEX,IAAIqB,GA/kER,SAAkBzjB,EAAM6C,QAChB,aAAc7C,IAAQA,EAAI0jB,SAAS93B,UAAUqD,UAC7C+Q,EAAI0jB,SAAS93B,UAAUqD,QAAU9C,MAAMP,UAClCqD,SAEL,iBAAkB+Q,IAAQA,EAAI2jB,aAAa/3B,UAAUqD,UACrD+Q,EAAI2jB,aAAa/3B,UAAUqD,QAAU9C,MAAMP,UACtCqD,SAEJ8X,KAAKnb,UAAUyM,WAChB0O,KAAKnb,UAAUyM,SAAW,IAAItN,KAC1B,IAAIsE,EAAOtE,EAAK,GAChB,KAAM,KAAKA,GACP,MAAM,IAAI64B,UAAU,0BAExB,GACI,GAAI91B,OAASuB,EACT,OAAO,QAELA,EAAOA,GAAQA,EAAKwF,YAC9B,OAAO,GAGnB,CAujEIgvB,GAEA,IAAIC,EAA2B,EAC/B,MAAMC,EAAkB9tB,IACpB,IAAK,MAAM6lB,KAAUC,GAAW,GACxBD,EAAOiI,iBACP9tB,EAAI6lB,EAAOiI,eAAe9tB,IAOlC,OAJIqsB,IACCM,IACD3sB,EAAIqsB,EAAOrsB,IAERA,GAEXwnB,GAAc,CAACjP,EAAG4P,KACd,MAAMnoB,EAAIuY,EAQV,GAPAvY,EAAEuoB,UAAY5a,OACV,OAAe,CAACsL,GAAiB,SAAU5jB,GAAKA,EAAE,GAAI,iBAAkBE,GAAMA,EAAG2iB,SAAU,OAAQ9f,GAAMA,OACzG4H,EAAEnG,OAASiY,GAAUsW,cACnBpoB,EAAEnG,OAASiY,GAAU0W,qBACnBxoB,EAAEoE,KAAK6I,SAAW+E,GAAkByW,UACxCxP,GAAgBjgB,QAAS+0B,GAAQA,EAAI9V,YAErCwU,GACA,OAAe,CAACtY,EAAM,eAAgB7b,GAAMA,EAAGw1B,EAAe9tB,GAAImoB,UAEjE,GAAIwE,EAAmB,CACxB,MAAM5E,EAAU,CACZluB,KAAM,QACN6V,MAAOoe,EAAe9tB,GACtBxE,OAAQoR,OAAOrC,SAAS/O,OACxB2sB,cAEJvb,OAAO8f,OAAOsB,YAAYjG,EAAS,IACvC,CACA,GAAI/nB,EAAEnG,OAASiY,GAAUsW,aACrBoF,EAAwBxtB,EACxB6tB,EAA2B,OAE1B,GAAI7tB,EAAEnG,OAASiY,GAAU0W,oBAAqB,CAC/C,GAAIxoB,EAAEoE,KAAK6I,SAAW+E,GAAkByW,UACpCzoB,EAAEoE,KAAKyjB,eACP,OAEJgG,IACA,MAAMI,EAAcjC,GAAoB6B,GAA4B7B,EAC9DkC,EAAanC,GACfyB,GACAxtB,EAAEuoB,UAAYiF,EAAsBjF,UAAYwD,GAChDkC,GAAeC,IACfC,IAAiB,EAEzB,GAEJ,MAAMC,EAAuB7X,IACzBiR,GAAY,CACR3tB,KAAMiY,GAAU0W,oBAChBpkB,KAAM,CACF6I,OAAQ+E,GAAkByW,YACvBlS,MAIT8X,EAAqB9R,GAAMiL,GAAY,CACzC3tB,KAAMiY,GAAU0W,oBAChBpkB,KAAM,CACF6I,OAAQ+E,GAAkBmX,UACvB5M,KAGL+R,EAA6B/R,GAAMiL,GAAY,CACjD3tB,KAAMiY,GAAU0W,oBAChBpkB,KAAM,CACF6I,OAAQ+E,GAAkBoX,kBACvB7M,KAULzH,EAAoB,IAAI8V,GAAkB,CAC5CtU,WAAY8X,EACZtD,oBATkC/tB,GAAMyqB,GAAY,CACpD3tB,KAAMiY,GAAU0W,oBAChBpkB,KAAM,CACF6I,OAAQ+E,GAAkB2X,qBACvB5sB,OAOL6X,EAAoD,kBAA7B2Z,0BAA0CA,yBACjE,IAAItH,GACJ,IAAII,GAAc,CAChBhnB,UACAiW,WAAY8X,EACZtZ,kBAAmBA,EACnB2S,2BACAD,iBAER,IAAK,MAAM3B,KAAUC,GAAW,GACxBD,EAAO2I,WACP3I,EAAO2I,UAAU,CACbC,WAAYpuB,GACZ6mB,wBAAyBtS,EAAcsS,wBACvCQ,6BAA8B9S,EAAc8S,+BAGxD,MAAM/P,EAAuB,IAAIyT,GAC3BpT,EA4SV,SAA2B0W,EAAoBtuB,GAC3C,IACI,OAAOsuB,EACDA,EAAmBtuB,GACnB,IAAIsqB,EACd,CACA,MAAOrrB,GAEH,OADAkG,QAAQC,KAAK,sCACN,IAAIklB,EACf,CACJ,CAtT0BiE,CAAkBnC,EAAkB,CACtDnsB,UACA0J,IAAK6C,OACL0J,WAAaiG,GAAMiL,GAAY,CAC3B3tB,KAAMiY,GAAU0W,oBAChBpkB,KAAM,CACF6I,OAAQ+E,GAAkBoX,kBACvB7M,KAGXxb,eACAT,aACAC,gBACAC,kBACA4rB,gBACA5R,SAAUA,EAAiB,OAC3B3Z,iBACA6X,iBAEE1D,GAA2D,kBAAjC4Z,8BAC5BA,6BACE,IAAI3E,GACJ,IAAIC,GAAiB,CACnB5T,WAAY8X,EACZ7T,SAAU8T,EACV7kB,cAAe,CACXuQ,aACAzZ,aACAC,gBACAC,kBACAb,cACAJ,gBACAE,kBACAD,mBACAE,qBACAgB,mBACA/G,mBACAkH,iBACAxD,kBACAsD,aACAzG,cACA6G,eACAD,eACA0Z,WACA5Z,iBACAgU,gBACAE,oBACAkD,gBACA3W,kBACAsW,wBAEJtX,YAEF8tB,GAAmB,CAAChG,GAAa,KACnCX,GAAY,CACR3tB,KAAMiY,GAAU4W,KAChBtkB,KAAM,CACFnN,KAAM2V,OAAOrC,SAAStT,KACtB2M,MAAOiL,KACP/K,OAAQ4K,OAEbyZ,GACHrT,EAAkBrb,QAClBub,GAAiB8C,OACjBmB,GAAgBjgB,QAAS+0B,GAAQA,EAAI5V,QACrC,MAAM/e,EAlhFd,SAAkBjE,EAAGiL,GACjB,MAAM,OAAEC,EAAS,IAAI1I,EAAQ,WAAE2I,EAAa,WAAU,cAAEC,EAAgB,KAAI,gBAAEC,EAAkB,KAAI,YAAEb,GAAc,EAAK,cAAEJ,EAAgB,UAAS,gBAAEE,EAAkB,KAAI,iBAAED,EAAmB,KAAI,mBAAEE,EAAqB,KAAI,iBAAEgB,GAAmB,EAAI,aAAEI,GAAe,EAAK,aAAEC,GAAe,EAAK,cAAEkrB,GAAgB,EAAK,gBAAE5uB,EAAe,WAAEsD,EAAU,YAAEzG,EAAW,QAAE20B,GAAU,EAAK,eAAEhuB,EAAc,mBAAEU,EAAkB,YAAEP,EAAW,aAAEC,EAAY,kBAAEC,EAAiB,iBAAEC,EAAgB,sBAAEC,EAAqB,gBAAEC,EAAkB,KAAM,GAAWjB,GAAW,CAAC,EAuCniB,OAAOD,GAAoBhL,EAAG,CAC1ByH,IAAKzH,EACLkL,SACAC,aACAC,gBACAC,kBACAb,cACAJ,gBACAE,kBACAD,mBACAE,qBACAe,WAAW,EACXC,mBACA/G,kBAnDuC,IAAlBsyB,EACnB,CACEW,OAAO,EACPC,MAAM,EACN,kBAAkB,EAClBC,OAAO,EACPC,OAAO,EACPC,QAAQ,EACRjI,OAAO,EACPkI,QAAQ,EACRC,KAAK,EACL/yB,MAAM,EACNgzB,MAAM,EACNlxB,KAAK,EACLmxB,MAAM,EACNvlB,UAAU,EACVwlB,QAAQ,IAEQ,IAAlBpB,EACI,CAAC,EACDA,EAgCN5uB,kBACAsD,aACAzG,cACA0G,gBAlC+B,IAAZiuB,GAAgC,QAAZA,EAEnC,CACItmB,QAAQ,EACRD,SAAS,EACTI,aAAa,EACba,gBAAgB,EAChBZ,qBAAkC,QAAZkmB,EACtBjmB,gBAAgB,EAChBE,gBAAgB,EAChBC,mBAAmB,EACnBC,oBAAoB,EACpBC,sBAAsB,IAEhB,IAAZ4lB,EACI,CAAC,EACDA,EAmBNhuB,iBACAC,eACAC,eACAQ,qBACAP,cACAC,eACAC,oBACAC,mBACAC,wBACAC,kBACAC,mBAAmB,GAE3B,CA48EqBqpB,CAASztB,SAAU,CAC5BmD,UACAC,aACAC,gBACAC,kBACAb,cACAJ,gBACAE,kBACAD,mBACAE,qBACAgB,mBACAurB,cAAetyB,EACf0D,kBACAnD,cACAyG,aACAkuB,QAASjuB,EACTC,iBACAE,eACAD,eACAE,YAAc7L,IACNya,GAAmBza,EAAGkL,KACtBuU,EAAcC,UAAU1f,GAExB2a,GAAuB3a,EAAGkL,KAC1ByU,EAAkBC,iBAAiB5f,GAEnC4a,GAAc5a,IACd6f,GAAiBC,cAAc9f,EAAEK,WAAY0H,WAGrD+D,aAAc,CAACiU,EAAQC,KACnBP,EAAcQ,aAAaF,EAAQC,GACnCH,GAAiBK,oBAAoBH,IAEzC/T,iBAAkB,CAAC4pB,EAAQ5V,KACvBL,EAAkBQ,kBAAkByV,EAAQ5V,IAEhD9T,oBAEJ,IAAKjI,EACD,OAAOmM,QAAQC,KAAK,mCAExBgiB,GAAY,CACR3tB,KAAMiY,GAAUsW,aAChBhkB,KAAM,CACFhL,OACA01B,cAAelhB,GAAgBhB,WAGvCqM,GAAgBjgB,QAAS+0B,GAAQA,EAAI3V,UACjClb,SAAS4qB,oBAAsB5qB,SAAS4qB,mBAAmBnzB,OAAS,GACpEmgB,EAAkBmJ,iBAAiB/gB,SAAS4qB,mBAAoBznB,GAAOnI,MAAMgF,YAErF2uB,GAAoBsC,GACpB,IACI,MAAMvS,EAAW,GACX5B,EAAWpd,GACNkc,GAAgBoF,GAAhBpF,CAA+B,CAClCiB,aACAzD,WAAY8X,EACZ7P,YAAa,CAACM,EAAW5R,IAAWua,GAAY,CAC5C3tB,KAAMiY,GAAU0W,oBAChBpkB,KAAM,CACF6I,SACA4R,eAGRc,mBAAqBjT,GAAM8a,GAAY,CACnC3tB,KAAMiY,GAAU0W,oBAChBpkB,KAAM,CACF6I,OAAQ+E,GAAkBkX,oBACvBxc,KAGX6N,SAAU8T,EACVnN,iBAAmBxU,GAAM8a,GAAY,CACjC3tB,KAAMiY,GAAU0W,oBAChBpkB,KAAM,CACF6I,OAAQ+E,GAAkBgX,kBACvBtc,KAGXsO,QAAUU,GAAM8L,GAAY,CACxB3tB,KAAMiY,GAAU0W,oBAChBpkB,KAAM,CACF6I,OAAQ+E,GAAkBqX,SACvB3N,KAGX8F,mBAAqBjF,GAAMiL,GAAY,CACnC3tB,KAAMiY,GAAU0W,oBAChBpkB,KAAM,CACF6I,OAAQ+E,GAAkBiX,oBACvB1M,KAGXuF,iBAAmBvJ,GAAMiP,GAAY,CACjC3tB,KAAMiY,GAAU0W,oBAChBpkB,KAAM,CACF6I,OAAQ+E,GAAkBsX,kBACvB/Q,KAGXsK,mBAAqBtK,GAAMiP,GAAY,CACnC3tB,KAAMiY,GAAU0W,oBAChBpkB,KAAM,CACF6I,OAAQ+E,GAAkBuX,oBACvBhR,KAGXwW,iBAAkBT,EAClB9K,OAASjH,GAAMiL,GAAY,CACvB3tB,KAAMiY,GAAU0W,oBAChBpkB,KAAM,CACF6I,OAAQ+E,GAAkByX,QACvBlN,KAGX+H,YAAc/H,IACViL,GAAY,CACR3tB,KAAMiY,GAAU0W,oBAChBpkB,KAAM,CACF6I,OAAQ+E,GAAkB0X,aACvBnN,MAIfkJ,gBAAkBznB,IACdwpB,GAAY,CACR3tB,KAAMiY,GAAU0W,oBAChBpkB,KAAM,CACF6I,OAAQ+E,GAAkBgd,iBACvBhxB,MAIfsC,aACA2a,cACAC,iBACAvb,cACAJ,gBACAE,kBACAD,mBACAE,qBACA/F,mBACA+G,mBACA8Z,WACAzZ,eACAD,eACAqa,uBACAoI,eACA3mB,MACAS,kBACAnD,cACAyG,aACAU,kBACAd,gBACAC,kBACAI,iBACAC,iBACAR,UACAuU,gBACAE,oBACAE,oBACA2C,uBACAK,gBACA8K,sBACAgD,SAAS,OAAe,CAACA,EACvC,iBAAkBvtB,GAAMA,EAAGwd,OAAQ,OAAQrO,GAAMA,EAAI6U,GAAMA,EAAEzC,UAC7D,iBAAkBnS,GAAMA,EAAG4D,IAAK,OAAQ3D,GAAMA,EAAI2U,IAAM,CACtCzC,SAAUyC,EAAEzC,SACZ1Z,QAASmc,EAAEnc,QACX2lB,SAAWjQ,GAAY0R,GAAY,CAC/B3tB,KAAMiY,GAAU+W,OAChBzkB,KAAM,CACFyhB,OAAQtJ,EAAEnf,KACV0Y,mBAGH,IACV,CAAC,GAERlB,EAAcwS,gBAAiBvd,IAC3B,IACI+R,EAASzkB,KAAK6iB,EAAQnQ,EAASlD,iBACnC,CACA,MAAOnQ,GACH+O,QAAQC,KAAKhP,EACjB,IAEJ,MAAMshB,EAAO,KACTqW,KACAvS,EAASzkB,KAAK6iB,EAAQ9c,YAwB1B,MAtB4B,gBAAxBA,SAAS+M,YACe,aAAxB/M,SAAS+M,WACT6N,KAGA8D,EAASzkB,KAAK8T,GAAG,mBAAoB,KACjCuc,GAAY,CACR3tB,KAAMiY,GAAU8W,iBAChBxkB,KAAM,CAAC,IAES,qBAAhBmoB,GACAzU,OAER8D,EAASzkB,KAAK8T,GAAG,OAAQ,KACrBuc,GAAY,CACR3tB,KAAMiY,GAAU6W,KAChBvkB,KAAM,CAAC,IAES,SAAhBmoB,GACAzU,KACLlL,UAEA,KACHgP,EAAS5iB,QAASgjB,GAAMA,KACxBrE,EAAqBiU,UACrBC,QAAoB72B,EACpB6jB,KAER,CACA,MAAOriB,GACH+O,QAAQC,KAAKhP,EACjB,CACJ,CA2BA,SAASy4B,GAAc1G,GAErB,OADaA,EAAY,WACXA,EAAwB,IAAZA,CAC5B,CAKA,SAAS2G,GAAa3G,GAEpB,OADaA,EAAY,WACXA,EAAY,IAAOA,CACnC,CAKA,SAAS4G,GAAmBC,EAAQC,GACN,uBAAxBA,EAAWC,WAIX,CAAC,WAAY,YAAYh5B,SAAS+4B,EAAWC,UAC/CF,EAAOG,sBAEPH,EAAOI,+BAGTJ,EAAOK,UAAU,KAGfL,EAAOM,kBAAkB,CACvB71B,KAAMiY,GAAUgX,OAGhBP,UAAyC,KAA7B8G,EAAW9G,WAAa,GACpCnkB,KAAM,CACJurB,IAAK,aAEL7Z,SAAS,QAAUuZ,EAAY,GAAI,QAKR,YAAxBA,EAAWC,WAEtB,CAKA,SAASM,GAAsB31B,GAE7B,OAD2BA,EAAQ41B,QAJR,aAKE51B,CAC/B,CAQA,SAAS61B,GAAmBpgB,GAC1B,MAAMxE,EAAS6kB,GAAcrgB,GAE7B,OAAKxE,GAAYA,aAAkBpE,QAI5B8oB,GAAsB1kB,GAHpBA,CAIX,CAGA,SAAS6kB,GAAcrgB,GACrB,OAOF,SAA2BA,GACzB,MAAwB,iBAAVA,KAAwBA,GAAS,WAAYA,CAC7D,CATMsgB,CAAkBtgB,GACbA,EAAMxE,OAGRwE,CACT,CAMA,IAAIkM,GAxGJkQ,GAAOzrB,OAASA,GAChByrB,GAAOqC,iBAPP,SAA0BhG,GACtB,IAAK0D,GACD,MAAM,IAAIlZ,MAAM,mDAEpBkZ,GAAkB1D,EACtB,EAsJA,MAAM8H,GAGH,WAAAr4B,CACCw3B,EACAc,EAEAC,EAAsBhB,IAEtBt3B,KAAKu4B,cAAgB,EACrBv4B,KAAKw4B,YAAc,EACnBx4B,KAAKy4B,QAAU,GAGfz4B,KAAK04B,SAAWL,EAAgBvkB,QAAU,IAC1C9T,KAAK24B,WAAaN,EAAgBzR,UAAY,IAC9C5mB,KAAK44B,cAAgBP,EAAgBQ,cAAgB,IACrD74B,KAAK84B,QAAUvB,EACfv3B,KAAK+4B,gBAAkBV,EAAgBhV,eACvCrjB,KAAKs4B,oBAAsBA,CAC7B,CAGC,YAAAU,GACC,MAAMC,GA/DY/X,EA+DqB,KAErClhB,KAAKu4B,cAAgBW,MA/DpBnV,KACHA,GAAW,IAeb,QAAK5nB,EAAQ,OAAQ,SAAUg9B,GAC7B,OAAO,YAAal8B,GAClB,GAAI8mB,GACF,IACEA,GAAS5iB,QAAQ4f,GAAWA,IAC9B,CAAE,MAAO5Y,GAET,CAGF,OAAOgxB,EAAmB3kB,MAAMrY,EAAQc,EAC1C,CACF,IAvBA8mB,GAASzkB,KAAK4hB,GAEP,KACL,MAAMzb,EAAMse,GAAWA,GAAS1f,QAAQ6c,IAAO,EAC3Czb,GAAO,GACT,GAAY2zB,OAAO3zB,EAAK,KAZ9B,IAAsByb,EAoElBlhB,KAAKq5B,UAAY,KACfJ,IAEAj5B,KAAKy4B,QAAU,GACfz4B,KAAKu4B,cAAgB,EACrBv4B,KAAKw4B,YAAc,EAEvB,CAGC,eAAAc,GACKt5B,KAAKq5B,WACPr5B,KAAKq5B,YAGHr5B,KAAKu5B,oBACP/mB,aAAaxS,KAAKu5B,mBAEtB,CAGC,WAAAC,CAAYhC,EAAYj2B,GACvB,GAiKJ,SAAuBA,EAAM8hB,GAC3B,OAAKoW,GAAgBh7B,SAAS8C,EAAKQ,WAKd,UAAjBR,EAAKQ,UAAwB,CAAC,SAAU,UAAUtD,SAAS8C,EAAKwB,aAAa,SAAW,QAQzE,MAAjBxB,EAAKQ,WACJR,EAAKqB,aAAa,aAAgBrB,EAAKqB,aAAa,WAA6C,UAAhCrB,EAAKwB,aAAa,gBAKlFsgB,IAAkB9hB,EAAK4F,QAAQkc,KAKrC,CA1LQqW,CAAcn4B,EAAMvB,KAAK+4B,mBA4LjC,SAA2BvB,GACzB,SAAUA,EAAWjrB,MAA0C,iBAA3BirB,EAAWjrB,KAAKoT,SAAuB6X,EAAW9G,UACxF,CA9LsDiJ,CAAkBnC,GAClE,OAGF,MAAMoC,EAAW,CACflJ,UAAW2G,GAAaG,EAAW9G,WACnCmJ,gBAAiBrC,EAEjBsC,WAAY,EACZv4B,QAKAvB,KAAKy4B,QAAQhsB,KAAKstB,GAASA,EAAMx4B,OAASq4B,EAASr4B,MAAQ8K,KAAK2tB,IAAID,EAAMrJ,UAAYkJ,EAASlJ,WAAa,KAK9G1wB,KAAKy4B,QAAQn5B,KAAKs6B,GAGU,IAAxB55B,KAAKy4B,QAAQ37B,QACfkD,KAAKi6B,uBAET,CAGC,gBAAAC,CAAiBxJ,EAAYzc,KAAKD,OACjChU,KAAKu4B,cAAgBlB,GAAa3G,EACpC,CAGC,cAAAyJ,CAAezJ,EAAYzc,KAAKD,OAC/BhU,KAAKw4B,YAAcnB,GAAa3G,EAClC,CAGC,aAAA0J,CAAch4B,GACb,MAAMb,EAAOw2B,GAAsB31B,GACnCpC,KAAKq6B,kBAAkB94B,EACzB,CAGC,iBAAA84B,CAAkB94B,GACjBvB,KAAKs6B,WAAW/4B,GAAMJ,QAAQ44B,IAC5BA,EAAMD,cAEV,CAGC,UAAAQ,CAAW/4B,GACV,OAAOvB,KAAKy4B,QAAQva,OAAO6b,GAASA,EAAMx4B,OAASA,EACrD,CAGC,YAAAg5B,GACC,MAAMC,EAAiB,GAEjBxmB,EAAMklB,KAEZl5B,KAAKy4B,QAAQt3B,QAAQ44B,KACdA,EAAMU,eAAiBz6B,KAAKu4B,gBAC/BwB,EAAMU,cAAgBV,EAAMrJ,WAAa1wB,KAAKu4B,cAAgBv4B,KAAKu4B,cAAgBwB,EAAMrJ,eAAYvzB,IAElG48B,EAAMW,aAAe16B,KAAKw4B,cAC7BuB,EAAMW,YAAcX,EAAMrJ,WAAa1wB,KAAKw4B,YAAcx4B,KAAKw4B,YAAcuB,EAAMrJ,eAAYvzB,GAI7F48B,EAAMrJ,UAAY1wB,KAAK04B,UAAY1kB,GACrCwmB,EAAel7B,KAAKy6B,KAKxB,IAAK,MAAMA,KAASS,EAAgB,CAClC,MAAM/0B,EAAMzF,KAAKy4B,QAAQp0B,QAAQ01B,GAE7Bt0B,GAAO,IACTzF,KAAK26B,qBAAqBZ,GAC1B/5B,KAAKy4B,QAAQW,OAAO3zB,EAAK,GAE7B,CAGIzF,KAAKy4B,QAAQ37B,QACfkD,KAAKi6B,sBAET,CAGC,oBAAAU,CAAqBZ,GACpB,MAAMxC,EAASv3B,KAAK84B,QACd8B,EAAYb,EAAMW,aAAeX,EAAMW,aAAe16B,KAAK44B,cAC3DiC,EAAcd,EAAMU,eAAiBV,EAAMU,eAAiBz6B,KAAK24B,WAEjEmC,GAAeF,IAAcC,GAC7B,WAAEf,EAAU,gBAAED,GAAoBE,EAGxC,GAAIe,EAAa,CAGf,MAAMC,EAAmF,IAAhE1uB,KAAKC,IAAIytB,EAAMU,eAAiBz6B,KAAK04B,SAAU14B,KAAK04B,UACvEsC,EAAYD,EAAmC,IAAhB/6B,KAAK04B,SAAkB,WAAa,UAEnElB,EAAa,CACjBx1B,KAAM,UACNkuB,QAAS2J,EAAgB3J,QACzBQ,UAAWmJ,EAAgBnJ,UAC3B+G,SAAU,uBACVlrB,KAAM,IACDstB,EAAgBttB,KACnBnI,IAAKjI,EAAOuW,SAAStT,KACrB67B,MAAO1D,EAAO2D,kBACdH,mBACAC,YAGAlB,WAAYA,GAAc,IAK9B,YADA95B,KAAKs4B,oBAAoBf,EAAQC,EAEnC,CAGA,GAAIsC,EAAa,EAAG,CAClB,MAAMtC,EAAa,CACjBx1B,KAAM,UACNkuB,QAAS2J,EAAgB3J,QACzBQ,UAAWmJ,EAAgBnJ,UAC3B+G,SAAU,gBACVlrB,KAAM,IACDstB,EAAgBttB,KACnBnI,IAAKjI,EAAOuW,SAAStT,KACrB67B,MAAO1D,EAAO2D,kBACdpB,aACAqB,QAAQ,IAIZn7B,KAAKs4B,oBAAoBf,EAAQC,EACnC,CACF,CAGC,oBAAAyC,GACKj6B,KAAKu5B,oBACP/mB,aAAaxS,KAAKu5B,oBAGpBv5B,KAAKu5B,mBAAqBhnB,WAAW,IAAMvS,KAAKu6B,eAAgB,IAClE,EAGF,MAAMd,GAAkB,CAAC,IAAK,SAAU,SAmCxC,SAASP,KACP,OAAOjlB,KAAKD,MAAQ,GACtB,CAoDA,SAASonB,GACP5D,GAEA,MAAO,CACL9G,UAAWzc,KAAKD,MAAQ,IACxBhS,KAAM,aACHw1B,EAEP,CAEA,IAAI33B,IACJ,SAAWA,GACPA,EAASA,EAAmB,SAAI,GAAK,WACrCA,EAASA,EAAuB,aAAI,GAAK,eACzCA,EAASA,EAAkB,QAAI,GAAK,UACpCA,EAASA,EAAe,KAAI,GAAK,OACjCA,EAASA,EAAgB,MAAI,GAAK,QAClCA,EAASA,EAAkB,QAAI,GAAK,SACvC,CAPD,CAOGA,KAAaA,GAAW,CAAC,IAI5B,MAAMw7B,GAAuB,IAAIrf,IAAI,CACnC,KACA,QACA,aACA,OACA,OACA,MACA,QACA,eACA,cACA,WACA,gBACA,0BAMF,SAASsf,GAAsB1wB,GAC7B,MAAMqnB,EAAM,CAAC,EACb,IAAK,MAAMrd,KAAOhK,EAChB,GAAIywB,GAAqBh6B,IAAIuT,GAAM,CACjC,IAAI2mB,EAAgB3mB,EAER,gBAARA,GAAiC,iBAARA,IAC3B2mB,EAAgB,UAGlBtJ,EAAIsJ,GAAiB3wB,EAAWgK,EAClC,CAGF,OAAOqd,CACT,CAyCA,SAASuJ,GAAqBnoB,EAAQ6c,GACpC,MAAMvQ,EAASsU,GAAOzrB,OAAOnI,MAAMgT,GAC7B9R,EAAOoe,GAAUsU,GAAOzrB,OAAO5H,QAAQ+e,GACvCle,EAAOF,GAAQ0yB,GAAOzrB,OAAOhI,QAAQe,GACrCa,EAAUX,GAoDlB,SAAmBF,GACjB,OAAOA,EAAKS,OAASnC,GAASoP,OAChC,CAtD0BwsB,CAAUh6B,GAAQA,EAAO,KAEjD,MAAO,CACLyuB,UACA3jB,KAAMnK,EACF,CACEud,SACApe,KAAM,CACJZ,GAAIgf,EACJ5d,QAASK,EAAQL,QACjBuJ,YAAajN,MAAMC,KAAK8D,EAAQlB,YAC7BwS,IAAKnS,GAASA,EAAKS,OAASnC,GAASoQ,MAAQ1O,EAAK+J,aAClD4S,OAAOzgB,SACPiW,IAAIpR,GAAQ,EAAQ2C,QACpBzG,KAAK,IACRoM,WAAY0wB,GAAsBl5B,EAAQwI,cAG9C,CAAC,EAET,CAiGA,MAAM8wB,GAEH,CAEDC,SAuFF,SACEC,GAEA,MAAM,UACJC,EAAS,cACTC,EAAa,KACbv2B,EAAI,YACJw2B,EAAW,UACXC,EAAS,gBACTC,EAAe,gBACfC,EAAe,eACfC,EAAc,aACdC,GACER,EAGJ,MAAI,CAAC,QAAS,kBAAkBn9B,SAASq9B,GAChC,KAGF,CACL95B,KAAM,GAAG65B,KAAaC,IACtBtO,MAAO6O,GAAgBL,GACvBvO,IAAK4O,GAAgBN,GACrBx2B,OACAgH,KAAM,CACJoU,KAAMyb,EACNE,WAAYH,EACZF,kBACAC,mBAGN,EAtHEK,MA4BF,SAA0BX,GACxB,MAAM,SAAEY,EAAQ,UAAEX,EAAS,KAAEt2B,EAAI,UAAEy2B,GAAcJ,EAE3CpO,EAAQ6O,GAAgBL,GAC9B,MAAO,CACLh6B,KAAM65B,EACNt2B,OACAioB,QACAC,IAAKD,EAAQgP,EACbjwB,UAAMpP,EAEV,EArCEs/B,WAuCF,SAA+Bb,GAC7B,MAAM,UACJC,EAAS,KACTt2B,EAAI,gBACJ02B,EAAe,SACfO,EAAQ,YACRE,EAAW,gBACXR,EAAe,2BACfS,EAA0B,yBAC1BC,EAAwB,eACxBC,EAAc,eACdC,EAAc,aACdC,EAAY,cACZC,EAAa,UACbhB,EAAS,aACTI,EAAY,KACZp6B,GACE45B,EAGJ,OAAiB,IAAbY,EACK,KAGF,CACLx6B,KAAM,GAAG65B,KAAa75B,IACtBwrB,MAAO6O,GAAgBL,GACvBvO,IAAK4O,GAAgBK,GACrBn3B,OACAgH,KAAM,CACJoU,KAAMyb,EACNH,kBACAC,kBACAM,WACAK,iBACAF,6BACAC,2BACAE,iBACAC,eACAL,cACAM,iBAGN,GAtEA,SAASC,GAAuBrB,GAC9B,OAAKF,GAAYE,EAAMC,WAIhBH,GAAYE,EAAMC,WAAWD,GAH3B,IAIX,CAEA,SAASS,GAAgB/G,GAGvB,QAAS,MAAgCn5B,EAAO+gC,YAAYC,YAAc7H,GAAQ,GACpF,CAkKA,MAAM8H,GAA2C,oBAArBC,kBAAoCA,iBAShE,SAASC,GAAQpN,EAASqN,GACnBH,KAIL,KAAOI,KAAKtN,GAERqN,GACFE,GAAiBvN,GAErB,CAMA,SAASwN,GAAgBxN,EAASqN,GAC3BH,KAIL,KAAOI,KAAKtN,GAERqN,GAGFhrB,WAAW,KACTkrB,GAAiBvN,IAChB,GAEP,CAEA,SAASuN,GAAiBvN,IACxB,QACE,CACEuH,SAAU,UACVlrB,KAAM,CACJoxB,OAAQ,UAEVC,MAAO,OACP1N,WAEF,CAAE0N,MAAO,QAEb,CAGA,MAAMC,WAAqC/iB,MACxC,WAAA/a,GACC+9B,MAAM,kDACR,EAOF,MAAMC,GAKH,WAAAh+B,GACCC,KAAKg+B,OAAS,GACdh+B,KAAKi+B,WAAa,EAClBj+B,KAAKk+B,aAAc,CACrB,CAGC,aAAIC,GACH,OAAOn+B,KAAKg+B,OAAOlhC,OAAS,CAC9B,CAGC,QAAIkF,GACH,MAAO,MACT,CAGC,OAAA+xB,GACC/zB,KAAKg+B,OAAS,EAChB,CAGC,cAAMI,CAASvmB,GACd,MAAMwmB,EAAYn/B,KAAKC,UAAU0Y,GAAO/a,OAExC,GADAkD,KAAKi+B,YAAcI,EACfr+B,KAAKi+B,WAAazhC,EACpB,MAAM,IAAIqhC,GAGZ79B,KAAKg+B,OAAO1+B,KAAKuY,EACnB,CAGC,MAAAymB,GACC,OAAO,IAAIC,QAAQC,IAIjB,MAAMC,EAAYz+B,KAAKg+B,OACvBh+B,KAAK4zB,QACL4K,EAAQt/B,KAAKC,UAAUs/B,KAE3B,CAGC,KAAA7K,GACC5zB,KAAKg+B,OAAS,GACdh+B,KAAKi+B,WAAa,EAClBj+B,KAAKk+B,aAAc,CACrB,CAGC,oBAAAQ,GACC,MAAMhO,EAAY1wB,KAAKg+B,OAAOtqB,IAAImE,GAASA,EAAM6Y,WAAWiO,OAAO,GAEnE,OAAKjO,EAIE0G,GAAc1G,GAHZ,IAIX,EAOF,MAAMkO,GAEH,WAAA7+B,CAAY8+B,GACX7+B,KAAK8+B,QAAUD,EACf7+B,KAAKgD,IAAM,CACb,CAMC,WAAA+7B,GAEC,OAAI/+B,KAAKg/B,sBAITh/B,KAAKg/B,oBAAsB,IAAIT,QAAQ,CAACC,EAASS,KAC/Cj/B,KAAK8+B,QAAQ/wB,iBACX,UACA,EAAGxB,WACG,EAAQ2yB,QACVV,IAEAS,KAGJ,CAAEE,MAAM,IAGVn/B,KAAK8+B,QAAQ/wB,iBACX,QACApP,IACEsgC,EAAOtgC,IAET,CAAEwgC,MAAM,OArBHn/B,KAAKg/B,mBA0BhB,CAKC,OAAAjL,GACCuJ,GAAQ,0CACRt9B,KAAK8+B,QAAQM,WACf,CAKC,WAAAjJ,CAAYkJ,EAAQC,GACnB,MAAM3+B,EAAKX,KAAKu/B,qBAEhB,OAAO,IAAIhB,QAAQ,CAACC,EAASS,KAC3B,MAAMhtB,EAAW,EAAG1F,WAClB,MAAMizB,EAAWjzB,EACjB,GAAIizB,EAASH,SAAWA,GAMpBG,EAAS7+B,KAAOA,EAApB,CAOA,GAFAX,KAAK8+B,QAAQzxB,oBAAoB,UAAW4E,IAEvCutB,EAASN,QAKZ,OAHA9B,IAAe,KAAOz+B,MAAM,WAAY6gC,EAASA,eAEjDP,EAAO,IAAInkB,MAAM,gCAInB0jB,EAAQgB,EAASA,SAbjB,GAkBFx/B,KAAK8+B,QAAQ/wB,iBAAiB,UAAWkE,GACzCjS,KAAK8+B,QAAQ3I,YAAY,CAAEx1B,KAAI0+B,SAAQC,SAE3C,CAGC,kBAAAC,GACC,OAAOv/B,KAAKgD,KACd,EAOF,MAAMy8B,GAGH,WAAA1/B,CAAY8+B,GACX7+B,KAAK8+B,QAAU,IAAIF,GAAcC,GACjC7+B,KAAK0/B,mBAAqB,KAC1B1/B,KAAKi+B,WAAa,EAClBj+B,KAAKk+B,aAAc,CACrB,CAGC,aAAIC,GACH,QAASn+B,KAAK0/B,kBAChB,CAGC,QAAI19B,GACH,MAAO,QACT,CAMC,WAAA+8B,GACC,OAAO/+B,KAAK8+B,QAAQC,aACtB,CAKC,OAAAhL,GACC/zB,KAAK8+B,QAAQ/K,SACf,CAOC,QAAAqK,CAASvmB,GACR,MAAM6Y,EAAY0G,GAAcvf,EAAM6Y,aACjC1wB,KAAK0/B,oBAAsBhP,EAAY1wB,KAAK0/B,sBAC/C1/B,KAAK0/B,mBAAqBhP,GAG5B,MAAMnkB,EAAOrN,KAAKC,UAAU0Y,GAG5B,OAFA7X,KAAKi+B,YAAc1xB,EAAKzP,OAEpBkD,KAAKi+B,WAAazhC,EACb+hC,QAAQU,OAAO,IAAIpB,IAGrB79B,KAAK2/B,mBAAmBpzB,EACjC,CAKC,MAAA+xB,GACC,OAAOt+B,KAAK4/B,gBACd,CAGC,KAAAhM,GACC5zB,KAAK0/B,mBAAqB,KAC1B1/B,KAAKi+B,WAAa,EAClBj+B,KAAKk+B,aAAc,EAGnBl+B,KAAK8+B,QAAQ3I,YAAY,SAAS0J,KAAK,KAAM13B,IAC3Ci1B,IAAe,KAAOzvB,KAAK,oDAAqDxF,IAEpF,CAGC,oBAAAu2B,GACC,OAAO1+B,KAAK0/B,kBACd,CAKC,kBAAAC,CAAmBpzB,GAClB,OAAOvM,KAAK8+B,QAAQ3I,YAAY,WAAY5pB,EAC9C,CAKC,oBAAMqzB,GACL,MAAMJ,QAAiBx/B,KAAK8+B,QAAQ3I,YAAY,UAKhD,OAHAn2B,KAAK0/B,mBAAqB,KAC1B1/B,KAAKi+B,WAAa,EAEXuB,CACT,EAQF,MAAMM,GAEH,WAAA//B,CAAY8+B,GACX7+B,KAAK+/B,UAAY,IAAIhC,GACrB/9B,KAAKggC,aAAe,IAAIP,GAA6BZ,GACrD7+B,KAAKigC,MAAQjgC,KAAK+/B,UAElB//B,KAAKkgC,6BAA+BlgC,KAAKmgC,uBAC3C,CAGC,QAAIn+B,GACH,OAAOhC,KAAKigC,MAAMj+B,IACpB,CAGC,aAAIm8B,GACH,OAAOn+B,KAAKigC,MAAM9B,SACpB,CAGC,eAAID,GACH,OAAOl+B,KAAKigC,MAAM/B,WACpB,CAEC,eAAIA,CAAYthC,GACfoD,KAAKigC,MAAM/B,YAActhC,CAC3B,CAGC,OAAAm3B,GACC/zB,KAAK+/B,UAAUhM,UACf/zB,KAAKggC,aAAajM,SACpB,CAGC,KAAAH,GACC,OAAO5zB,KAAKigC,MAAMrM,OACpB,CAGC,oBAAA8K,GACC,OAAO1+B,KAAKigC,MAAMvB,sBACpB,CAOC,QAAAN,CAASvmB,GACR,OAAO7X,KAAKigC,MAAM7B,SAASvmB,EAC7B,CAGC,YAAMymB,GAIL,aAFMt+B,KAAKogC,uBAEJpgC,KAAKigC,MAAM3B,QACpB,CAGC,oBAAA8B,GACC,OAAOpgC,KAAKkgC,4BACd,CAGC,2BAAMC,GACL,UACQngC,KAAKggC,aAAajB,aAC1B,CAAE,MAAOpgC,GAIP,YADA2+B,GAAQ,gFAEV,OAGMt9B,KAAKqgC,4BACb,CAGC,gCAAMA,GACL,MAAM,OAAErC,EAAM,YAAEE,GAAgBl+B,KAAK+/B,UAE/BO,EAAmB,GACzB,IAAK,MAAMzoB,KAASmmB,EAClBsC,EAAiBhhC,KAAKU,KAAKggC,aAAa5B,SAASvmB,IAGnD7X,KAAKggC,aAAa9B,YAAcA,EAIhCl+B,KAAKigC,MAAQjgC,KAAKggC,aAGlB,UACQzB,QAAQgC,IAAID,EACpB,CAAE,MAAO3hC,GACPy+B,IAAe,KAAOzvB,KAAK,wDAAyDhP,EACtF,CACF,EAoDF,SAAS6hC,KACP,IAEE,MAAO,mBAAoBrkC,KAAYA,EAAOskC,cAChD,CAAE,MAAOt4B,GACP,OAAO,CACT,CACF,CA+BA,SAASu4B,GAAUC,GACjB,YAAmBxjC,IAAfwjC,GAKGt0B,KAAKu0B,SAAWD,CACzB,CAKA,SAASE,GAAYC,GACnB,MAAM9sB,EAAMC,KAAKD,MASjB,MAAO,CACLrT,GATSmgC,EAAQngC,KAAM,UAUvBogC,QARcD,EAAQC,SAAW/sB,EASjCgtB,aARmBF,EAAQE,cAAgBhtB,EAS3CitB,UARgBH,EAAQG,WAAa,EASrCC,QARcJ,EAAQI,QAStBC,kBARwBL,EAAQK,kBAUpC,CAKA,SAASC,GAAYN,GACnB,GAAKN,KAIL,IACErkC,EAAOskC,eAAeY,QAAQjlC,EAAoB8C,KAAKC,UAAU2hC,GACnE,CAAE,MAAO34B,GAET,CACF,CAcA,SAASm5B,IACP,kBAAEC,EAAiB,eAAEC,EAAc,cAAEC,GAAgB,IACrD,kBAAEN,GAAsB,CAAC,GAEzB,MAAMD,EAbR,SAA8BK,EAAmBC,GAC/C,OAAOd,GAAUa,GAAqB,YAAYC,GAAiB,QACrE,CAWkBE,CAAqBH,EAAmBC,GAClDV,EAAUD,GAAY,CAC1BK,UACAC,sBAOF,OAJIM,GACFL,GAAYN,GAGPA,CACT,CAgCA,SAASa,GACPC,EACAC,EACAC,GAAc,IAAI7tB,MAGlB,OAAoB,OAAhB2tB,QAAmCzkC,IAAX0kC,GAAwBA,EAAS,GAK9C,IAAXA,GAIGD,EAAcC,GAAUC,CACjC,CAKA,SAASC,GACPjB,GACA,kBACEkB,EAAiB,kBACjBC,EAAiB,WACjBH,EAAa7tB,KAAKD,QAGpB,OAEE2tB,GAAUb,EAAQC,QAASiB,EAAmBF,IAG9CH,GAAUb,EAAQE,aAAciB,EAAmBH,EAEvD,CAGA,SAASI,GACPpB,GACA,kBAAEmB,EAAiB,kBAAED,IAGrB,QAAKD,GAAiBjB,EAAS,CAAEmB,oBAAmBD,wBAK5B,WAApBlB,EAAQI,SAA8C,IAAtBJ,EAAQG,UAK9C,CAMA,SAASkB,IACP,eACEC,EAAc,kBACdH,EAAiB,kBACjBD,EAAiB,kBACjBb,GAIFkB,GAEA,MAAMC,EAAkBD,EAAeZ,eAlGzC,SAAsBW,GACpB,IAAK5B,KACH,OAAO,KAGT,IAEE,MAAM+B,EAA2BpmC,EAAOskC,eAAe+B,QAAQpmC,GAE/D,IAAKmmC,EACH,OAAO,KAGT,MAAME,EAAavjC,KAAKwjC,MAAMH,GAI9B,OAFA7E,GAAgB,oCAAqC0E,GAE9CvB,GAAY4B,EACrB,CAAE,MAAOt6B,GACP,OAAO,IACT,CACF,CA6E0Dw6B,CAAaP,GAGrE,OAAKE,EAKAJ,GAAqBI,EAAiB,CAAEL,oBAAmBD,uBAIhEtE,GAAgB,sEACT4D,GAAce,EAAgB,CAAElB,kBAAmBmB,EAAgB3hC,MAJjE2hC,GALP5E,GAAgB,gCAAiC0E,GAC1Cd,GAAce,EAAgB,CAAElB,sBAS3C,CAcA,SAASyB,GAAarL,EAAQ1f,EAAOyY,GACnC,QAAKuS,GAAetL,EAAQ1f,KAM5BirB,GAAUvL,EAAQ1f,EAAOyY,IAElB,EACT,CAoBAyS,eAAeD,GACbvL,EACA1f,EACAyY,GAEA,IAAKiH,EAAOyL,YACV,OAAO,KAGT,IACM1S,GAAuC,WAAzBiH,EAAO0L,eACvB1L,EAAOyL,YAAYpP,QAGjBtD,IACFiH,EAAOyL,YAAY9E,aAAc,GAGnC,MAEMgF,EAiDV,SACErrB,EACAqW,GAEA,IACE,GAAwB,mBAAbA,GApHf,SAAuBrW,GACrB,OAAOA,EAAM7V,OAASiY,GAAUgX,MAClC,CAkH0CkS,CAActrB,GAClD,OAAOqW,EAASrW,EAEpB,CAAE,MAAOlZ,GAGP,OAFAy+B,IACE,KAAOz+B,MAAM,6FAA8FA,GACtG,IACT,CAEA,OAAOkZ,CACT,CAhEuCurB,CAAmBvrB,EAFhC0f,EAAO8L,aAE8CC,yBAE3E,IAAKJ,EACH,OAGF,aAAa3L,EAAOyL,YAAY5E,SAAS8E,EAC3C,CAAE,MAAOvkC,GACP,MAAM4kC,EAAS5kC,GAASA,aAAiBk/B,GAA+B,uBAAyB,WAEjGT,IAAe,KAAOz+B,MAAMA,SACtB44B,EAAOiM,KAAK,CAAED,WAEpB,MAAME,GAAS,UAEXA,GACFA,EAAOC,mBAAmB,qBAAsB,SAEpD,CACF,CAGA,SAASb,GAAetL,EAAQ1f,GAC9B,IAAK0f,EAAOyL,aAAezL,EAAOoM,aAAepM,EAAOqM,YACtD,OAAO,EAGT,MAAMC,EAAgBzM,GAAcvf,EAAM6Y,WAM1C,QAAImT,EAAgBtM,EAAOuM,SAASC,iBAAmB9vB,KAAKD,OAKxD6vB,EAAgBtM,EAAO1rB,aAAam4B,iBAAmBzM,EAAO8L,aAAarB,oBAC7E1E,GACE,0CAA0CuG,0CAC1CtM,EAAO8L,aAAaY,aAAa7B,gBAE5B,GAIX,CAoBA,SAAS8B,GAAarsB,GACpB,OAAQA,EAAM7V,IAChB,CAGA,SAASmiC,GAAmBtsB,GAC1B,MAAsB,gBAAfA,EAAM7V,IACf,CAQA,SAASoiC,GAAgBvsB,GACvB,MAAsB,aAAfA,EAAM7V,IACf,CAKA,SAASqiC,GAAqB9M,GAG5B,MAAM+M,EAoER,WACE,MAAMb,GAAS,UACf,IAAKA,EACH,OAAO,EAGT,MAAMc,EAAYd,EAAOe,eACzB,OAAKD,GAKFA,EAAe,KAAEE,4BAJX,CAMX,CAlF4BC,GAE1B,MAAO,CAAC7sB,EAAO8sB,KACb,IAAKpN,EAAOqM,cAAiBM,GAAarsB,KAAWssB,GAAmBtsB,GACtE,OAGF,MAAMykB,EAAaqI,GAAgBA,EAAarI,WAK5CgI,KAAuBhI,GAAcA,EAAa,KAAOA,GAAc,OAIvE6H,GAAmBtsB,GAS3B,SAAgC0f,EAAQ1f,GACtC,MAAM+sB,EAAgBrN,EAAO1rB,aAKzBgM,EAAMgtB,UAAYhtB,EAAMgtB,SAASC,OAASjtB,EAAMgtB,SAASC,MAAMC,UAAYH,EAAcI,SAASrkB,KAAO,KAC3GikB,EAAcI,SAASxjC,IAAIqW,EAAMgtB,SAASC,MAAMC,SAEpD,CAjBME,CAAuB1N,EAAQ1f,GAmBrC,SAA0B0f,EAAQ1f,GAChC,MAAM+sB,EAAgBrN,EAAO1rB,aAc7B,GANIgM,EAAMqtB,UAAYN,EAAcO,SAASxkB,KAAO,KAClDikB,EAAcO,SAAS3jC,IAAIqW,EAAMqtB,UAKN,WAAzB3N,EAAO0L,gBAA+BprB,EAAMutB,OAASvtB,EAAMutB,KAAKC,SAClE,OAGF,MAAM,oBAAEC,GAAwB/N,EAAO8L,cACJ,mBAAxBiC,GAAuCA,EAAoBztB,KAItEtF,WAAW,KAITglB,EAAOgO,6BAEX,CA7CIC,CAAiBjO,EAAQ1f,IAE7B,CA0PA,SAAS4tB,GACPlO,EACA5M,GAEA,OAAOA,EAAQjX,IAAI,EAAG1R,OAAMwrB,QAAOC,MAAKloB,OAAMgH,WAC5C,MAAMizB,EAAWjI,EAAOM,kBAAkB,CACxC71B,KAAMiY,GAAUgX,OAChBP,UAAWlD,EACXjhB,KAAM,CACJurB,IAAK,kBACL7Z,QAAS,CACPlhB,GAAIiF,EACJ0jC,YAAangC,EACbogC,eAAgBnY,EAChBoY,aAAcnY,EACdlhB,WAMN,MAA2B,iBAAbizB,EAAwBjB,QAAQC,QAAQ,MAAQgB,GAElE,CA2DA,SAASqG,GACPtO,EACAtR,GAEKsR,EAAOqM,aAIG,OAAX3d,IAlBN,SAA6BsR,EAAQnzB,GAEnC,QAAIg5B,KAAe7F,EAAO8L,aAAaY,aAAa7B,kBAI7C,OAAmBh+B,GAAK,UACjC,CAeM0hC,CAAoBvO,EAAQtR,EAAO1gB,OAIvCgyB,EAAOK,UAAU,KACf6N,GAAuBlO,EAAQ,CAACtR,KAIzB,IAEX,CAqFA,SAAS8f,GACP3vB,EACA4vB,GAEA,GAAK5vB,EAIL,IACE,GAAoB,iBAATA,EACT,OAAO4vB,EAAYC,OAAO7vB,GAAMtZ,OAGlC,GAAIsZ,aAAgB8vB,gBAClB,OAAOF,EAAYC,OAAO7vB,EAAKrY,YAAYjB,OAG7C,GAAIsZ,aAAgB+vB,SAAU,CAC5B,MAAMC,EAAcC,GAAmBjwB,GACvC,OAAO4vB,EAAYC,OAAOG,GAAatpC,MACzC,CAEA,GAAIsZ,aAAgBkwB,KAClB,OAAOlwB,EAAKuK,KAGd,GAAIvK,aAAgBmwB,YAClB,OAAOnwB,EAAKowB,UAIhB,CAAE,MAAOr+B,GAET,CAGF,CAGA,SAASs+B,GAAyBC,GAChC,IAAKA,EACH,OAGF,MAAM/lB,EAAOgmB,SAASD,EAAQ,IAC9B,OAAOve,MAAMxH,QAAQxjB,EAAYwjB,CACnC,CAGA,SAASimB,GAAcxwB,GACrB,IACE,GAAoB,iBAATA,EACT,MAAO,CAACA,GAGV,GAAIA,aAAgB8vB,gBAClB,MAAO,CAAC9vB,EAAKrY,YAGf,GAAIqY,aAAgB+vB,SAClB,MAAO,CAACE,GAAmBjwB,IAG7B,IAAKA,EACH,MAAO,MAACjZ,EAEZ,CAAE,MAAOqK,GAEP,OADA41B,IAAe,KAAOzvB,KAAK,oCAAqCyI,GACzD,MAACjZ,EAAW,mBACrB,CAIA,OAFAigC,IAAe,KAAOI,KAAK,sDAAuDpnB,GAE3E,MAACjZ,EAAW,wBACrB,CAGA,SAAS0pC,GACPrJ,EACAsJ,GAEA,IAAKtJ,EACH,MAAO,CACLuJ,QAAS,CAAC,EACVpmB,UAAMxjB,EACN6pC,MAAO,CACLC,SAAU,CAACH,KAKjB,MAAMI,EAAU,IAAK1J,EAAKwJ,OACpBG,EAAmBD,EAAQD,UAAY,GAI7C,OAHAC,EAAQD,SAAW,IAAIE,EAAkBL,GAEzCtJ,EAAKwJ,MAAQE,EACN1J,CACT,CAGA,SAAS4J,GACPplC,EACAuK,GAEA,IAAKA,EACH,OAAO,KAGT,MAAM,eAAEo5B,EAAc,aAAEC,EAAY,IAAExhC,EAAG,OAAEi7B,EAAM,WAAE/C,EAAU,QAAE+K,EAAO,SAAE7H,GAAajzB,EAerF,MAbe,CACbvK,OACAwrB,MAAOmY,EAAiB,IACxBlY,IAAKmY,EAAe,IACpBrgC,KAAMnB,EACNmI,MAAM,QAAkB,CACtB8yB,SACA/C,aACA+K,UACA7H,aAKN,CAGA,SAAS8H,GAAqCC,GAC5C,MAAO,CACLR,QAAS,CAAC,EACVpmB,KAAM4mB,EACNP,MAAO,CACLC,SAAU,CAAC,gBAGjB,CAGA,SAASO,GACPT,EACAQ,EACAnxB,GAEA,IAAKmxB,GAA4C,IAAhC1pC,OAAOkD,KAAKgmC,GAASjqC,OACpC,OAGF,IAAKyqC,EACH,MAAO,CACLR,WAIJ,IAAK3wB,EACH,MAAO,CACL2wB,UACApmB,KAAM4mB,GAIV,MAAM/J,EAAO,CACXuJ,UACApmB,KAAM4mB,IAGAnxB,KAAMqxB,EAAc,SAAER,GA8BhC,SAA8B7wB,GAG5B,IAAKA,GAAwB,iBAATA,EAClB,MAAO,CACLA,QAIJ,MAAMsxB,EAAmBtxB,EAAKtZ,OAASR,EACjCqrC,EAkCR,SAA4BnlC,GAC1B,MAAMolC,EAAQplC,EAAI,GACZqlC,EAAOrlC,EAAIA,EAAI1F,OAAS,GAG9B,MAAkB,MAAV8qC,GAA0B,MAATC,GAA4B,MAAVD,GAA0B,MAATC,CAC9D,CAxCyBC,CAAmB1xB,GAE1C,GAAIsxB,EAAkB,CACpB,MAAMK,EAAgB3xB,EAAK9R,MAAM,EAAGhI,GAEpC,OAAIqrC,EACK,CACLvxB,KAAM2xB,EACNd,SAAU,CAAC,yBAIR,CACL7wB,KAAM,GAAG2xB,KACTd,SAAU,CAAC,kBAEf,CAEA,GAAIU,EACF,IAEE,MAAO,CACLvxB,KAFelX,KAAKwjC,MAAMtsB,GAI9B,CAAE,MAAO4xB,GAET,CAGF,MAAO,CACL5xB,OAEJ,CAxE6C6xB,CAAqB7xB,GAQhE,OAPAonB,EAAKpnB,KAAOqxB,EACRR,GAAYA,EAASnqC,OAAS,IAChC0gC,EAAKwJ,MAAQ,CACXC,aAIGzJ,CACT,CAGA,SAAS0K,GAAkBnB,EAASoB,GAClC,OAAOtqC,OAAOkD,KAAKgmC,GAASqB,OAAO,CAACC,EAAiBzzB,KACnD,MAAM2mB,EAAgB3mB,EAAI3S,cAK1B,OAHIkmC,EAAe1pC,SAAS88B,IAAkBwL,EAAQnyB,KACpDyzB,EAAgB9M,GAAiBwL,EAAQnyB,IAEpCyzB,GACN,CAAC,EACN,CAEA,SAAShC,GAAmBiC,GAI1B,OAAO,IAAIpC,gBAAgBoC,GAAUvqC,UACvC,CAuDA,SAASwqC,GAAWnkC,EAAKokC,GACvB,MAAMC,EAMR,SAAoBrkC,EAAKskC,EAAUvsC,EAAOkJ,SAASqjC,SAEjD,GAAItkC,EAAIwkB,WAAW,YAAcxkB,EAAIwkB,WAAW,aAAexkB,EAAIwkB,WAAWzsB,EAAOuW,SAAS/O,QAC5F,OAAOS,EAET,MAAMukC,EAAW,IAAIC,IAAIxkC,EAAKskC,GAG9B,GAAIC,EAAShlC,SAAW,IAAIilC,IAAIF,GAAS/kC,OACvC,OAAOS,EAGT,MAAMqkC,EAAUE,EAASvpC,KAGzB,OAAKgF,EAAIwM,SAAS,MAAQ63B,EAAQ73B,SAAS,KAClC63B,EAAQnkC,MAAM,GAAI,GAGpBmkC,CACT,CA1BkBI,CAAWzkC,GAE3B,OAAO,QAAyBqkC,EAASD,EAC3C,CA6NA,SAASM,GAAwBC,EAAY,IAE3C,GAAyB,IAArBA,EAAUjsC,QAAwC,iBAAjBisC,EAAU,GAI/C,OAAQA,EAAU,GAAK3yB,IACzB,CAEA,SAAS4yB,GAAcjC,EAASoB,GAC9B,MAAMc,EAAa,CAAC,EAQpB,OANAd,EAAehnC,QAAQulC,IACjBK,EAAQlmC,IAAI6lC,KACduC,EAAWvC,GAAUK,EAAQlmC,IAAI6lC,MAI9BuC,CACT,CAcA,SAASC,GACPllB,EACAmkB,GAEA,IAAKnkB,EACH,MAAO,CAAC,EAGV,MAAM+iB,EAAU/iB,EAAM+iB,QAEtB,OAAKA,EAIDA,aAAmBoC,QACdH,GAAcjC,EAASoB,GAI5B9pC,MAAM6zB,QAAQ6U,GACT,CAAC,EAGHmB,GAAkBnB,EAASoB,GAZzB,CAAC,CAaZ,CA8OA,SAASiB,GAAyB7R,GAChC,MAAMkM,GAAS,UAEf,IACE,MAAMuC,EAAc,IAAIqD,aAElB,uBACJC,EAAsB,sBACtBC,EAAqB,qBACrBC,EAAoB,sBACpBC,EAAqB,uBACrBC,GACEnS,EAAO8L,aAEL96B,EAAU,CACdgvB,SACAyO,cACAsD,yBACAC,wBACAC,uBACAC,wBACAC,0BAGEjG,GAAUA,EAAOrwB,GACnBqwB,EAAOrwB,GAAG,sBAAuB,CAACokB,EAAYmS,IAYpD,SACEphC,EACAivB,EACAmS,GAEA,GAAKnS,EAAWjrB,KAIhB,KA2BF,SAA0BirB,GACxB,MAA+B,QAAxBA,EAAWC,QACpB,EA5BQmS,CAAiBpS,IAkCzB,SAAoBmS,GAClB,OAAOA,GAAQA,EAAKE,GACtB,CApCwCC,CAAWH,KAhOnD,SACEnS,EACAmS,EACAphC,GAEA,MAAM,IAAEshC,EAAG,MAAE7lB,GAAU2lB,EAEvB,IAAKE,EACH,OAGF,MAAME,EAAUhE,GAAY/hB,EAAOzb,EAAQy9B,aACrCgE,EAAUH,EAAII,kBAAkB,kBAClCxD,GAAyBoD,EAAII,kBAAkB,mBAiJrD,SACE7zB,EACA8zB,EACAlE,GAEA,IAEE,OAAOD,GAD0B,SAAjBmE,GAA2B9zB,GAAwB,iBAATA,EAAoBlX,KAAKC,UAAUiX,GAAQA,EACzE4vB,EAC9B,CAAE,MAAOgC,GACP,MACF,CACF,CA3JMmC,CAAaN,EAAIrK,SAAUqK,EAAIK,aAAc3hC,EAAQy9B,kBAEzC7oC,IAAZ4sC,IACFvS,EAAWjrB,KAAK69B,kBAAoBL,QAEtB5sC,IAAZ6sC,IACFxS,EAAWjrB,KAAK89B,mBAAqBL,EAEzC,CA8MMM,CAAoB9S,EAAYmS,EAAMphC,GAzP5Cw6B,eACEvL,EACAmS,EACAphC,GAEA,IACE,MAAMgE,EAuCV,SACEirB,EACAmS,EACAphC,GAEA,MAAMyL,EAAMC,KAAKD,OACX,eAAE2xB,EAAiB3xB,EAAG,aAAE4xB,EAAe5xB,EAAG,MAAEgQ,EAAK,IAAE6lB,GAAQF,GAE3D,IACJvlC,EAAG,OACHi7B,EACAkL,YAAajO,EAAa,EAC1B8N,kBAAmBI,EACnBH,mBAAoBI,GAClBjT,EAAWjrB,KAEf,IAAKnI,EACH,OAAO,KAGT,IAAKylC,IAAQtB,GAAWnkC,EAAKmE,EAAQ+gC,yBAA2Bf,GAAWnkC,EAAKmE,EAAQghC,uBAGtF,MAAO,CACL5D,iBACAC,eACAxhC,MACAi7B,SACA/C,aACA+K,QARcC,GAAqCkD,GASnDhL,SARe8H,GAAqCmD,IAYxD,MAAMC,EAAUb,EAAI,MACdJ,EAAwBiB,EAC1BxC,GAAkBwC,EAAQC,gBAAiBpiC,EAAQkhC,uBACnD,CAAC,EACCC,EAAyBxB,GAmBjC,SAA4B2B,GAC1B,MAAM9C,EAAU8C,EAAIe,wBAEpB,OAAK7D,EAIEA,EAAQ/nC,MAAM,QAAQopC,OAAO,CAACyC,EAAKC,KACxC,MAAOl2B,EAAKhY,GAASkuC,EAAK9rC,MAAM,MAEhC,OADA6rC,EAAIj2B,EAAI3S,eAAiBrF,EAClBiuC,GACN,CAAC,GAPK,CAAC,CAQZ,CA/BmDE,CAAmBlB,GAAMthC,EAAQmhC,yBAE3EsB,EAAaC,GAAkB1iC,EAAQihC,qBAAuB5C,GAAc5iB,GAAS,MAAC7mB,IACtF+tC,EAAcC,GAAmB5iC,EAAQihC,qBA8BlD,SAA6BK,GAE3B,MAAMuB,EAAS,GAEf,IACE,MAAO,CAACvB,EAAIwB,aACd,CAAE,MAAOljC,GACPijC,EAAO9rC,KAAK6I,EACd,CAGA,IACE,OAqBJ,SACEiO,EACA8zB,GAEA,IACE,GAAoB,iBAAT9zB,EACT,MAAO,CAACA,GAGV,GAAIA,aAAgBnM,SAClB,MAAO,CAACmM,EAAKA,KAAKk1B,WAGpB,GAAqB,SAAjBpB,GAA2B9zB,GAAwB,iBAATA,EAC5C,MAAO,CAAClX,KAAKC,UAAUiX,IAGzB,IAAKA,EACH,MAAO,MAACjZ,EAEZ,CAAE,MAAOqK,GAEP,OADA41B,IAAe,KAAOzvB,KAAK,oCAAqCyI,GACzD,MAACjZ,EAAW,mBACrB,CAIA,OAFAigC,IAAe,KAAOI,KAAK,sDAAuDpnB,GAE3E,MAACjZ,EAAW,wBACrB,CAjDWouC,CAAkB1B,EAAIrK,SAAUqK,EAAIK,aAC7C,CAAE,MAAO/hC,GACPijC,EAAO9rC,KAAK6I,EACd,CAIA,OAFAi1B,IAAe,KAAOzvB,KAAK,8CAA+Cy9B,GAEnE,MAACjuC,EACV,CAlDyEquC,CAAoB3B,GAAO,MAAC1sC,GAE7FkqC,EAAUG,GAA8BiC,EAAuBe,EAAiBQ,GAChFxL,EAAWgI,GAA8BkC,EAAwBe,EAAkBS,GAEzF,MAAO,CACLvF,iBACAC,eACAxhC,MACAi7B,SACA/C,aACA+K,QAAS4D,EAAiBpE,GAAaQ,EAAS4D,GAAkB5D,EAClE7H,SAAU2L,EAAkBtE,GAAarH,EAAU2L,GAAmB3L,EAE1E,CA9FiBiM,CAAgBjU,EAAYmS,EAAMphC,GAGzC0d,EAASmhB,GAA4B,eAAgB76B,GAC3Ds5B,GAAqBt9B,EAAQgvB,OAAQtR,EACvC,CAAE,MAAOtnB,GACPy+B,IAAe,KAAOz+B,MAAM,4CAA6CA,EAC3E,CACF,CA+OM+sC,CAA6BlU,EAAYmS,EAAMphC,IAsBrD,SAA4BivB,GAC1B,MAA+B,UAAxBA,EAAWC,QACpB,CArBQkU,CAAmBnU,IA2B3B,SAAsBmS,GACpB,OAAOA,GAAQA,EAAKnK,QACtB,CA7B0CoM,CAAajC,KA1gBvD,SACEnS,EACAmS,EACAphC,GAEA,MAAM,MAAEyb,EAAK,SAAEwb,GAAamK,EAGtBI,EAAUhE,GADH/hB,EAAQ8kB,GAAwB9kB,QAAS7mB,EACpBoL,EAAQy9B,aAEpCgE,EAAUxK,EAAWiH,GAAyBjH,EAASuH,QAAQlmC,IAAI,wBAAqB1D,OAE9EA,IAAZ4sC,IACFvS,EAAWjrB,KAAK69B,kBAAoBL,QAEtB5sC,IAAZ6sC,IACFxS,EAAWjrB,KAAK89B,mBAAqBL,EAEzC,CA4fM6B,CAAsBrU,EAAYmS,EAAMphC,GAriB9Cw6B,eACEvL,EACAmS,EACAphC,GAIA,IACE,MAAMgE,QAmCVw2B,eACEvL,EACAmS,EACAphC,GAIA,MAAMyL,EAAMC,KAAKD,OACX,eAAE2xB,EAAiB3xB,EAAG,aAAE4xB,EAAe5xB,GAAQ21B,GAE/C,IACJvlC,EAAG,OACHi7B,EACAkL,YAAajO,EAAa,EAC1B8N,kBAAmBI,EACnBH,mBAAoBI,GAClBjT,EAAWjrB,KAETu/B,EACJvD,GAAWnkC,EAAKmE,EAAQ+gC,0BAA4Bf,GAAWnkC,EAAKmE,EAAQghC,uBAExElC,EAAUyE,EAgBlB,UACE,qBAAEtC,EAAoB,sBAAEC,GACxBzlB,EACAwmB,GAEA,MAAMzD,EAAU/iB,GAgIoBmkB,EAhIasB,EAiIxB,KADAV,EAhIiB/kB,GAiI5BlnB,QAAwC,iBAAjBisC,EAAU,GACtCG,GAAsBH,EAAU,GAAKZ,GAGrB,IAArBY,EAAUjsC,OACLosC,GAAsBH,EAAU,GAAKZ,GAGvC,CAAC,GAzIkE,CAAC,EAgI7E,IAA2BY,EAAWZ,EA9HpC,IAAKqB,EACH,OAAOhC,GAA8BT,EAASyD,OAAiBrtC,GAIjE,MAAM6tC,EAAclC,GAAwB9kB,IACrC+nB,EAASjF,GAAWF,GAAcoE,GACnCz+B,EAAOi7B,GAA8BT,EAASyD,EAAiBuB,GAErE,OAAIjF,EACKD,GAAat6B,EAAMu6B,GAGrBv6B,CACT,CApCMy/B,CAAgBzjC,EAASohC,EAAK3lB,MAAOwmB,GACrClD,GAAqCkD,GACnChL,QAqCRuD,eACE+I,GACA,qBACEtC,EAAoB,YACpBxD,EAAW,uBACX0D,GAIFlK,EACAiL,GAEA,IAAKqB,QAAuC3uC,IAArBstC,EACrB,OAAOnD,GAAqCmD,GAG9C,MAAM1D,EAAUvH,EAAWwJ,GAAcxJ,EAASuH,QAAS2C,GAA0B,CAAC,EAEtF,IAAKlK,IAAcgK,QAA6CrsC,IAArBstC,EACzC,OAAOjD,GAA8BT,EAAS0D,OAAkBttC,GAGlE,MAAO8uC,EAAUnF,SAkDnB/D,eAAuCvD,GACrC,MAAM0M,EA0ER,SAA2B1M,GACzB,IAEE,OAAOA,EAAS2M,OAClB,CAAE,MAAOxtC,GAEPy+B,IAAe,KAAOzvB,KAAK,yCAA0ChP,EACvE,CACF,CAlFcytC,CAAkB5M,GAE9B,IAAK0M,EACH,MAAO,MAAC/uC,EAAW,oBAGrB,IACE,MAAMmF,QAkFV,SAA6Bk9B,GAC3B,OAAO,IAAIjB,QAAQ,CAACC,EAASS,KAC3B,MAAMnrB,EAAUvB,WAAW,IAAM0sB,EAAO,IAAInkB,MAAM,+CAAgD,MAWtGioB,eAAgCvD,GAG9B,aAAaA,EAASl9B,MACxB,EAbI+pC,CAAiB7M,GACdK,KACCyM,GAAO9N,EAAQ8N,GACf/I,GAAUtE,EAAOsE,IAElBgJ,QAAQ,IAAM/5B,aAAasB,KAElC,CA7FuB04B,CAAoBN,GACvC,MAAO,CAAC5pC,EACV,CAAE,MAAO3D,GAEP,OADAy+B,IAAe,KAAOzvB,KAAK,iDAAkDhP,GACtE,MAACxB,EAAW,mBACrB,CACF,CAhEoCsvC,CAAwBjN,GACpDvZ,EAeR,SACEgmB,GACA,qBACEzC,EAAoB,YACpBxD,EAAW,iBACXyE,EAAgB,eAChBqB,EAAc,QACd/E,IAKF,IACE,MAAMpmB,EACJsrB,GAAYA,EAASnvC,aAA+BK,IAArBstC,EAC3B1E,GAAYkG,EAAUjG,GACtByE,EAEN,OAAKqB,EAKItE,GAA8BT,EAASpmB,EAD5C6oB,EACkDyC,OAGF9uC,GAP3CmqC,GAAqC3mB,EAQhD,CAAE,MAAOhiB,GAGP,OAFAy+B,IAAe,KAAOzvB,KAAK,6CAA8ChP,GAElE6oC,GAA8BT,EAAS0D,OAAkBttC,EAClE,CACF,CA/CiBuvC,CAAgBT,EAAU,CACvCzC,uBACAxD,cACAyE,mBACAqB,iBACA/E,YAGF,OAAID,EACKD,GAAa5gB,EAAQ6gB,GAGvB7gB,CACT,CAzEyB0mB,CAAiBb,EAAgBvjC,EAASohC,EAAKnK,SAAUiL,GAEhF,MAAO,CACL9E,iBACAC,eACAxhC,MACAi7B,SACA/C,aACA+K,UACA7H,WAEJ,CAtEuBoN,CAAkBpV,EAAYmS,EAAMphC,GAGjD0d,EAASmhB,GAA4B,iBAAkB76B,GAC7Ds5B,GAAqBt9B,EAAQgvB,OAAQtR,EACvC,CAAE,MAAOtnB,GACPy+B,IAAe,KAAOz+B,MAAM,8CAA+CA,EAC7E,CACF,CAyhBMkuC,CAA+BrV,EAAYmS,EAAMphC,GAErD,CAAE,MAAOJ,GACPi1B,IAAe,KAAOzvB,KAAK,0CAC7B,CACF,CA9C6Dm/B,CAA2BvkC,EAASivB,EAAYmS,MAGvG,OAr1BN,SAAiCpS,GAC/B,OAAQwV,IACN,IAAKxV,EAAOqM,YACV,OAGF,MAAM3d,EA/BV,SAAqB8mB,GACnB,MAAM,eAAEpH,EAAc,aAAEC,EAAY,UAAEoH,EAAS,SAAExN,GAAauN,EAE9D,IAAKnH,EACH,OAAO,KAIT,MAAM,OAAEvG,EAAM,IAAEj7B,GAAQ4oC,EAExB,MAAO,CACLhrC,KAAM,iBACNwrB,MAAOmY,EAAiB,IACxBlY,IAAKmY,EAAe,IACpBrgC,KAAMnB,EACNmI,KAAM,CACJ8yB,SACA/C,WAAYkD,EAAW,EAAYyN,YAAS9vC,GAGlD,CAWmB+vC,CAAYH,GAE3BlH,GAAqBtO,EAAQtR,GAEjC,CA20BqCknB,CAAwB5V,KACvD,QA1yBN,SAA+BA,GAC7B,OAAQwV,IACN,IAAKxV,EAAOqM,YACV,OAGF,MAAM3d,EArCV,SAAmB8mB,GACjB,MAAM,eAAEpH,EAAc,aAAEC,EAAY,IAAEiE,GAAQkD,EAExCK,EAAgBvD,EAAI,MAE1B,IAAKlE,IAAmBC,IAAiBwH,EACvC,OAAO,KAIT,MAAM,OAAE/N,EAAM,IAAEj7B,EAAKmmC,YAAajO,GAAe8Q,EAEjD,YAAYjwC,IAARiH,EACK,KAGF,CACLpC,KAAM,eACNuD,KAAMnB,EACNopB,MAAOmY,EAAiB,IACxBlY,IAAKmY,EAAe,IACpBr5B,KAAM,CACJ8yB,SACA/C,cAGN,CAWmB+Q,CAAUN,GAEzBlH,GAAqBtO,EAAQtR,GAEjC,CAgyBmCqnB,CAAsB/V,IAEvD,CAAE,MAAO/vB,GAET,CACF,CAuDA,IAAI+lC,GAAmB,KA0KvB,SAASC,GAAS/J,GAChB,SAAUA,IAAUA,EAAOrwB,GAC7B,CAqBA,SAASq6B,GAAkBC,GACzB,MAAM,gBAAEC,EAAe,gBAAEC,EAAe,eAAEC,GAAmBH,EAGvDpY,EAAOrhB,KAAKD,MAAQ,IAC1B,MAAO,CACLhS,KAAM,SACNuD,KAAM,SACNioB,MAAO8H,EACP7H,IAAK6H,EACL/oB,KAAM,CACJuhC,OAAQ,CACNH,kBACAC,kBACAC,mBAIR,CAsEA,SAASE,GAAuBxW,GAC9B,IAAIyW,GAAgB,EAEpB,MAAO,CAACn2B,EAAOo2B,KAEb,IAAK1W,EAAOI,+BAGV,YAFAyF,IAAe,KAAOzvB,KAAK,0DAO7B,MAAM2iB,EAAa2d,IAAgBD,EACnCA,GAAgB,EAEZzW,EAAO2W,eA/4Ff,SAA8CA,EAAer2B,GAC3D,IASE,IA0BJ,SAA4BA,GAC1B,OArayC,IAqalCA,EAAM7V,IACf,CA5BSmsC,CAAmBt2B,GACtB,OAGF,MAAM,OAAEzC,GAAWyC,EAAMtL,KASzB,GARI6I,IAAW+E,GAAkByW,UAC/Bsd,EAAchU,iBAAiBriB,EAAM6Y,WAGnCtb,IAAW+E,GAAkBmX,QAC/B4c,EAAc/T,eAAetiB,EAAM6Y,WAoBzC,SACE7Y,GAEA,OAAOA,EAAMtL,KAAK6I,SAAW+E,GAAkBkX,gBACjD,CArBQ+c,CAA8Bv2B,GAAQ,CACxC,MAAM,KAAE7V,EAAI,GAAErB,GAAOkX,EAAMtL,KACrBhL,EAAO0yB,GAAOzrB,OAAO5H,QAAQD,GAE/BY,aAAgB8sC,aAAersC,IAASqY,GAAkBwO,OAC5DqlB,EAAc9T,cAAc74B,EAEhC,CACF,CAAE,MAAO4G,GAET,CACF,CA82FMmmC,CAAqC/W,EAAO2W,cAAer2B,GAI7D0f,EAAOK,UAAU,KAYf,GAN6B,WAAzBL,EAAO0L,eAA8B3S,GACvCiH,EAAOgX,mBAKJ3L,GAAarL,EAAQ1f,EAAOyY,GAE/B,OAAO,EAKT,IAAKA,EACH,OAAO,EAiBT,GAsEN,SAA0BiH,EAAQjH,GAE3BA,GAAeiH,EAAOuJ,SAAwC,IAA7BvJ,EAAOuJ,QAAQG,WAIrD2B,GAAarL,EAnCf,SAA4BA,GAC1B,MAAMhvB,EAAUgvB,EAAO8L,aACvB,MAAO,CACLrhC,KAAMiY,GAAUgX,OAChBP,UAAWzc,KAAKD,MAChBzH,KAAM,CACJurB,IAAK,UACL7Z,QAAS,CACPuwB,mBAAoBjX,EAAOkX,oBAC3BlN,kBAAmBh5B,EAAQg5B,kBAC3BmN,gBAAiBnmC,EAAQmmC,gBACzBC,qBAAsBpmC,EAAQqmC,eAC9BC,cAAetmC,EAAQsmC,cACvB/mC,YAAaS,EAAQT,YACrBssB,cAAe7rB,EAAQ6rB,cACvBwa,iBAAgBrX,EAAOyL,aAA0C,WAA5BzL,EAAOyL,YAAYhhC,KACxD8sC,qBAAsBvmC,EAAQ+gC,uBAAuBxsC,OAAS,EAC9D0sC,qBAAsBjhC,EAAQihC,qBAC9BuF,yBAA0BxmC,EAAQkhC,sBAAsB3sC,OAAS,EACjEkyC,0BAA2BzmC,EAAQmhC,uBAAuB5sC,OAAS,IAI3E,CAYuBmyC,CAAmB1X,IAAS,EACnD,CArFM2X,CAAiB3X,EAAQjH,GAQrBiH,EAAOuJ,SAAWvJ,EAAOuJ,QAAQK,kBACnC,OAAO,EAKT,GAA6B,WAAzB5J,EAAO0L,eAA8B1L,EAAOuJ,SAAWvJ,EAAOyL,YAAa,CAC7E,MAAMmM,EAAgB5X,EAAOyL,YAAYtE,uBACrCyQ,IACF7R,GACE,uEAAuE,IAAIrpB,KAAKk7B,KAChF5X,EAAO8L,aAAaY,aAAa7B,gBAGnC7K,EAAOuJ,QAAQC,QAAUoO,EAErB5X,EAAO8L,aAAa5B,eACtBL,GAAY7J,EAAOuJ,SAGzB,CAaA,MAX6B,YAAzBvJ,EAAO0L,eAQJ1L,EAAO6X,SAGP,IAGb,CA8RA,MAAMC,WAAiCv0B,MACpC,WAAA/a,CAAYu8B,GACXwB,MAAM,kCAAkCxB,IAC1C,EAMF,MAAMgT,WAAuBx0B,MAE1B,WAAA/a,CAAYwvC,GACXzR,MAAM,kBACN99B,KAAKuvC,WAAaA,CACpB,EAMFxM,eAAeyM,GACbC,EACAC,EAAc,CACZ1iB,MAAO,EACP2iB,SA1hPwB,MA6hP1B,MAAM,cAAEC,EAAa,QAAErnC,GAAYknC,EAGnC,GAAKG,EAAc9yC,OAInB,IAEE,aAnKJimC,gBAAiC,cAC/B6M,EAAa,SACbvK,EACApE,UAAW4O,EAAU,aACrBC,EAAY,UACZpf,EAAS,QACToQ,IAEA,MAAMiP,EA5FR,UAA8B,cAC5BH,EAAa,QACb7I,IAIA,IAAIiJ,EAGJ,MAAMC,EAAgB,GAAG/wC,KAAKC,UAAU4nC,OAGxC,GAA6B,iBAAlB6I,EACTI,EAAsB,GAAGC,IAAgBL,QACpC,CACL,MAEMM,GAFM,IAAI7G,aAEKpD,OAAOgK,GAE5BD,EAAsB,IAAI7jB,WAAW+jB,EAASpzC,OAAS8yC,EAAc9yC,QACrEkzC,EAAoBtuC,IAAIwuC,GACxBF,EAAoBtuC,IAAIkuC,EAAeM,EAASpzC,OAClD,CAEA,OAAOkzC,CACT,CAmEgCG,CAAqB,CACjDP,gBACA7I,QAAS,CACP8I,iBAIE,KAAErH,EAAI,SAAErD,EAAQ,SAAEH,EAAQ,iBAAEhB,GAAqB8L,EAEjDrM,GAAS,UACT2M,GAAQ,UACR7L,EAAYd,GAAUA,EAAOe,eAC7B6L,EAAM5M,GAAUA,EAAO6M,SAE7B,KAAK7M,GAAWc,GAAc8L,GAAQvP,EAAQI,SAC5C,OAGF,MAAMqP,EAAY,CAChBvuC,KAh7OsB,eAi7OtBwuC,uBAAwBxM,EAAmB,IAC3CtT,UAAWA,EAAY,IACvB+f,UAAWtL,EACXuL,UAAW1L,EACXwD,OACAmI,UAAWtL,EACXwK,aACAe,YAAa9P,EAAQI,SAGjB2P,QA5FR9N,gBAAkC,OAChCU,EAAM,MACN2M,EACA/K,SAAUH,EAAQ,MAClBrtB,IAIA,MAKMi5B,EAAY,CAAE5L,WAAU6L,aAJI,iBAAzBtN,EAAOuN,eAAuD,OAAzBvN,EAAOuN,eAA2B3yC,MAAM6zB,QAAQuR,EAAOuN,oBAE/F7zC,EADAU,OAAOkD,KAAK0iC,EAAOuN,gBAKrBvN,EAAOnnB,MACTmnB,EAAOnnB,KAAK,kBAAmBzE,EAAOi5B,GAGxC,MAAMG,QAAuB,QAC3BxN,EAAOJ,aACPxrB,EACAi5B,EACAV,EACA3M,GACA,WAIF,IAAKwN,EACH,OAAO,KAMTA,EAAcC,SAAWD,EAAcC,UAAY,aAGnD,MAAMC,EAAW1N,EAAO2N,gBAAkB3N,EAAO2N,kBAC3C,KAAE7rC,EAAI,QAAE8rC,GAAaF,GAAYA,EAASG,KAAQ,CAAC,EAQzD,OANAL,EAAcK,IAAM,IACfL,EAAcK,IACjB/rC,KAAMA,GAAQ,4BACd8rC,QAASA,GAAW,SAGfJ,CACT,CA2C4BM,CAAmB,CAAEnB,QAAO3M,SAAQ4B,WAAUxtB,MAAO04B,IAE/E,IAAKM,EAIH,OAFApN,EAAOC,mBAAmB,kBAAmB,SAAU6M,QACvDjT,GAAQ,mEA0CHuT,EAAYW,sBAEnB,MAAMC,EAvMR,SACEZ,EACAjB,EACAS,EACAqB,GAEA,OAAO,SACL,QAA2Bb,GAAa,QAAgCA,GAAca,EAAQrB,GAC9F,CACE,CAAC,CAAEruC,KAAM,gBAAkB6uC,GAC3B,CACE,CACE7uC,KAAM,mBAINlF,OAC2B,iBAAlB8yC,GAA6B,IAAIvG,aAAcpD,OAAO2J,GAAe9yC,OAAS8yC,EAAc9yC,QAEvG8yC,IAIR,CAgLmB+B,CAAqBd,EAAad,EAAuBM,EAAK5M,EAAOJ,aAAaqO,QAEnG,IAAIlS,EAEJ,IACEA,QAAiB+E,EAAUqN,KAAKH,EAClC,CAAE,MAAOhkC,GACP,MAAM9O,EAAQ,IAAImc,MAAMze,GAExB,IAGEsC,EAAMkzC,MAAQpkC,CAChB,CAAE,MAAOtF,GAET,CACA,MAAMxJ,CACR,CAGA,IAAK6gC,EACH,OAAOA,EAIT,GAAmC,iBAAxBA,EAASlD,aAA4BkD,EAASlD,WAAa,KAAOkD,EAASlD,YAAc,KAClG,MAAM,IAAI+S,GAAyB7P,EAASlD,YAG9C,MAAMiT,GAAa,QAAiB,CAAC,EAAG/P,GACxC,IAAI,QAAc+P,EAAY,UAC5B,MAAM,IAAID,GAAeC,GAG3B,OAAO/P,CACT,CAwCUsS,CAAkBrC,IACjB,CACT,CAAE,MAAOhiC,GACP,GAAIA,aAAe4hC,IAA4B5hC,aAAe6hC,GAC5D,MAAM7hC,EAcR,IAVA,OAAW,UAAW,CACpBskC,YAAarC,EAAY1iB,QAGvBoQ,IAAe70B,EAAQ07B,cAAgB17B,EAAQ07B,aAAa+N,oBAC9D,QAAiBvkC,GAKfiiC,EAAY1iB,OAtjPI,EAsjPsB,CACxC,MAAMruB,EAAQ,IAAImc,MAAM,GAAGze,4BAE3B,IAGEsC,EAAMkzC,MAAQpkC,CAChB,CAAE,MAAOtF,GAET,CAEA,MAAMxJ,CACR,CAKA,OAFA+wC,EAAYC,YAAcD,EAAY1iB,MAE/B,IAAIuR,QAAQ,CAACC,EAASS,KAC3B1sB,WAAWwwB,UACT,UACQyM,GAAWC,EAAYC,GAC7BlR,GAAQ,EACV,CAAE,MAAO/wB,GACPwxB,EAAOxxB,EACT,GACCiiC,EAAYC,WAEnB,CACF,CAEA,MAAMsC,GAAY,cA6DlB,MAAMC,GAmDH,WAAAnyC,EAAY,QACXwI,EAAO,iBACP4pC,IAGDD,GAAgBp0C,UAAUs0C,OAAOl1C,KAAK8C,MAAMkyC,GAAgBp0C,UAAUu0C,QAAQn1C,KAAK8C,MAAMkyC,GAAgBp0C,UAAUw0C,QAAQp1C,KAAK8C,MAAMkyC,GAAgBp0C,UAAUy0C,QAAQr1C,KAAK8C,MAAMkyC,GAAgBp0C,UAAU00C,QAAQt1C,KAAK8C,MAAMkyC,GAAgBp0C,UAAU20C,QAAQv1C,KAAK8C,MACtQA,KAAKgjC,YAAc,KACnBhjC,KAAK0yC,mBAAqB,GAC1B1yC,KAAK2yC,yBAA2B,GAChC3yC,KAAKijC,cAAgB,UACrBjjC,KAAK8jC,SAAW,CACdC,iBA9tP8B,IA+tP9B9B,kBA5tP+B,KA8tPjCjiC,KAAK4yC,cAAgB3+B,KAAKD,MAC1BhU,KAAK6yC,YAAa,EAClB7yC,KAAK8yC,WAAY,EACjB9yC,KAAK+yC,8BAA+B,EACpC/yC,KAAKgzC,SAAW,CACd7N,SAAU,IAAInpB,IACdgpB,SAAU,IAAIhpB,IACdwsB,KAAM,GACNxE,iBAAkB/vB,KAAKD,MACvBi/B,WAAY,IAGdjzC,KAAKkzC,kBAAoBf,EACzBnyC,KAAKmzC,SAAW5qC,EAEhBvI,KAAKozC,gBA9oBT,SAAkBx/B,EAAMC,EAAMtL,GAC5B,IAAI8qC,EAEAC,EACAC,EAEJ,MAAMC,EAAUjrC,GAAWA,EAAQirC,QAAUnnC,KAAKonC,IAAIlrC,EAAQirC,QAAS3/B,GAAQ,EAE/E,SAAS6/B,IAGP,OAFAC,IACAN,EAAsBz/B,IACfy/B,CACT,CAEA,SAASM,SACKx2C,IAAZm2C,GAAyB9gC,aAAa8gC,QACvBn2C,IAAfo2C,GAA4B/gC,aAAa+gC,GACzCD,EAAUC,OAAap2C,CACzB,CASA,SAASy2C,IAUP,OATIN,GACF9gC,aAAa8gC,GAEfA,EAAU/gC,WAAWmhC,EAAY7/B,GAE7B2/B,QAA0Br2C,IAAfo2C,IACbA,EAAahhC,WAAWmhC,EAAYF,IAG/BH,CACT,CAIA,OAFAO,EAAUC,OAASF,EACnBC,EAAUxE,MArBV,WACE,YAAgBjyC,IAAZm2C,QAAwCn2C,IAAfo2C,EACpBG,IAEFL,CACT,EAiBOO,CACT,CAmmB2BE,CAAS,IAAM9zC,KAAK+zC,SAAU/zC,KAAKmzC,SAASa,cAAe,CAChFR,QAASxzC,KAAKmzC,SAASc,gBAGzBj0C,KAAKk0C,mBArIT,SACEl3C,EACAm3C,EACAC,GAEA,MAAMC,EAAU,IAAIn0C,IAepB,IAAIo0C,GAAc,EAElB,MAAO,IAAIjgC,KAET,MAAML,EAAM3H,KAAKkoC,MAAMtgC,KAAKD,MAAQ,KAMpC,GAvBe,CAACA,IAChB,MAAM4S,EAAY5S,EAAMogC,EACxBC,EAAQlzC,QAAQ,CAACoF,EAAQqO,KACnBA,EAAMgS,GACRytB,EAAQpzC,OAAO2T,MAgBnB4/B,CAASxgC,GAVF,IAAIqgC,EAAQI,UAAUrM,OAAO,CAACljC,EAAGipB,IAAMjpB,EAAIipB,EAAG,IAa7BgmB,EAAU,CAChC,MAAMO,EAAeJ,EAErB,OADAA,GAAc,EACPI,EA5CG,YA4CsBzC,EAClC,CAEAqC,GAAc,EACd,MAAMtnB,EAAQqnB,EAAQxzC,IAAImT,IAAQ,EAGlC,OAFAqgC,EAAQ3yC,IAAIsS,EAAKgZ,EAAQ,GAElBhwB,KAAMqX,GAEjB,CA2F8BsgC,CACxB,CAAC98B,EAAOyY,IA9xEd,SACEiH,EACA1f,EACAyY,GAEA,OAAKuS,GAAetL,EAAQ1f,GAIrBirB,GAAUvL,EAAQ1f,EAAOyY,GAHvBiO,QAAQC,QAAQ,KAI3B,CAoxE6BJ,CAASp+B,KAAM6X,EAAOyY,GAE7C,IAEA,GAGF,MAAM,iBAAEskB,EAAgB,yBAAEC,GAA6B70C,KAAKqjC,aAEtDhL,EAAkBuc,EACpB,CACEhuB,UAAWva,KAAKC,IAxuPG,IAwuPuBsoC,GAC1C9gC,QAAS8gC,EACT/b,cAxuPwB,IAyuPxBxV,eAAgBwxB,EAA2BA,EAAyBr2C,KAAK,KAAO,SAElFrB,EAEAk7B,IACFr4B,KAAKkuC,cAAgB,IAAI9V,GAAcp4B,KAAMq4B,GAEjD,CAGC,UAAAxsB,GACC,OAAO7L,KAAKgzC,QACd,CAGC,SAAApP,GACC,OAAO5jC,KAAK6yC,UACd,CAGC,QAAAlP,GACC,OAAO3jC,KAAK8yC,SACd,CAKC,iBAAArE,GACC,OAAOhxC,QAAQuC,KAAK80C,QACtB,CAGC,UAAAzR,GACC,OAAOrjC,KAAKmzC,QACd,CAMC,kBAAA4B,CAAmB5T,GAClB,MAAM,gBAAEuN,EAAe,kBAAEnN,GAAsBvhC,KAAKmzC,SAIhDzE,GAAmB,GAAKnN,GAAqB,IAMjDvhC,KAAKg1C,8BAA8B7T,GAE9BnhC,KAAK8gC,SAMmB,IAAzB9gC,KAAK8gC,QAAQI,UAQjBlhC,KAAKijC,cAAyC,WAAzBjjC,KAAK8gC,QAAQI,SAAmD,IAA3BlhC,KAAK8gC,QAAQG,UAAkB,SAAW,UAEpGvD,GACE,+BAA+B19B,KAAKijC,qBACpCjjC,KAAKmzC,SAASlP,aAAa7B,gBAG7BpiC,KAAKi1C,wBAnBHj1C,KAAKk1C,iBAAiB,IAAIp6B,MAAM,4CAoBpC,CASC,KAAA0S,GACC,GAAIxtB,KAAK6yC,YAAqC,YAAvB7yC,KAAKijC,cAC1B,MAAM,IAAInoB,MAAM,2CAGlB,GAAI9a,KAAK6yC,YAAqC,WAAvB7yC,KAAKijC,cAC1B,MAAM,IAAInoB,MAAM,sEAGlB4iB,GAAgB,2CAA4C19B,KAAKmzC,SAASlP,aAAa7B,gBAMvFpiC,KAAKm1C,sBAEL,MAAMrU,EAAUqB,GACd,CACEH,kBAAmBhiC,KAAKmzC,SAASnR,kBACjCC,kBAAmBjiC,KAAK8jC,SAAS7B,kBACjCG,eAAgBpiC,KAAKmzC,SAASlP,aAAa7B,gBAE7C,CACEX,cAAezhC,KAAKmzC,SAAS1R,cAE7BF,kBAAmB,EACnBC,gBAAgB,IAIpBxhC,KAAK8gC,QAAUA,EAEf9gC,KAAKi1C,sBACP,CAMC,cAAAG,GACC,GAAIp1C,KAAK6yC,WACP,MAAM,IAAI/3B,MAAM,2CAGlB4iB,GAAgB,0CAA2C19B,KAAKmzC,SAASlP,aAAa7B,gBAEtF,MAAMtB,EAAUqB,GACd,CACEF,kBAAmBjiC,KAAK8jC,SAAS7B,kBACjCD,kBAAmBhiC,KAAKmzC,SAASnR,kBACjCI,eAAgBpiC,KAAKmzC,SAASlP,aAAa7B,gBAE7C,CACEX,cAAezhC,KAAKmzC,SAAS1R,cAC7BF,kBAAmB,EACnBC,gBAAgB,IAIpBxhC,KAAK8gC,QAAUA,EAEf9gC,KAAKijC,cAAgB,SACrBjjC,KAAKi1C,sBACP,CAOC,cAAAI,GACC,IACE,MAAMC,EAAgBt1C,KAAK80C,QAE3B90C,KAAKu1C,eAAiBthB,GAAO,IACxBj0B,KAAKkzC,qBAImB,WAAvBlzC,KAAKijC,eAA8B,CAAE/O,iBA35PpB,KA45PrB5X,KAAMyxB,GAAuB/tC,MAC7BkiB,WAAYliB,KAAKw1C,sBACbF,EACA,CACEpsC,aAAcosC,EAAcpsC,aAC5ByrB,iBAAkB2gB,EAAc3gB,iBAChChS,SAAU2yB,EAAc3yB,SACxB3Z,eAAgBssC,EAActsC,gBAEhC,CAAC,GAET,CAAE,MAAOyE,GACPzN,KAAKk1C,iBAAiBznC,EACxB,CACF,CAQC,aAAAgoC,GACC,IAME,OALIz1C,KAAKu1C,iBACPv1C,KAAKu1C,iBACLv1C,KAAKu1C,oBAAiBp4C,IAGjB,CACT,CAAE,MAAOsQ,GAEP,OADAzN,KAAKk1C,iBAAiBznC,IACf,CACT,CACF,CAMC,UAAM+1B,EAAK,WAAEkS,GAAa,EAAK,OAAEnS,GAAW,CAAC,GAC5C,GAAKvjC,KAAK6yC,WAAV,CAMA7yC,KAAK6yC,YAAa,EAElB,IACEvV,GACE,4BAA2BiG,EAAS,iBAAiBA,IAAW,IAChEvjC,KAAKmzC,SAASlP,aAAa7B,gBAG7BpiC,KAAK21C,mBACL31C,KAAKy1C,gBAELz1C,KAAKozC,gBAAgBS,SAGjB6B,SACI11C,KAAK+zC,OAAO,CAAE6B,OAAO,IAI7B51C,KAAKgjC,aAAehjC,KAAKgjC,YAAYjP,UACrC/zB,KAAKgjC,YAAc,KA7wFHzL,EAixFHv3B,KAzwFnB,WACE,GAAKwgC,KAIL,IACErkC,EAAOskC,eAAeoV,WAAWz5C,EACnC,CAAE,MAAO+L,GAET,CACF,CAjBE2tC,GACAve,EAAOuJ,aAAU3jC,CAgxFf,CAAE,MAAOsQ,GACPzN,KAAKk1C,iBAAiBznC,EACxB,CA/BA,CArvFJ,IAAsB8pB,CAqxFpB,CAOC,KAAAwe,GACK/1C,KAAK8yC,YAIT9yC,KAAK8yC,WAAY,EACjB9yC,KAAKy1C,gBAELnY,GAAQ,0BAA2Bt9B,KAAKmzC,SAASlP,aAAa7B,gBAChE,CAQC,MAAA4T,GACMh2C,KAAK8yC,WAAc9yC,KAAKi2C,kBAI7Bj2C,KAAK8yC,WAAY,EACjB9yC,KAAKq1C,iBAEL/X,GAAQ,2BAA4Bt9B,KAAKmzC,SAASlP,aAAa7B,gBACjE,CASC,+BAAMmD,EAA0B,kBAAE2Q,GAAoB,GAAS,CAAC,GAC/D,GAA2B,YAAvBl2C,KAAKijC,cACP,OAAOjjC,KAAKm2C,iBAGd,MAAMC,EAAeniC,KAAKD,MAE1BspB,GAAQ,wCAAyCt9B,KAAKmzC,SAASlP,aAAa7B,sBAMtEpiC,KAAKm2C,iBAEX,MAAME,EAAsBr2C,KAAKy1C,gBAE5BS,GAAsBG,GAKG,YAAzBr2C,KAAmB,gBAKxBA,KAAKijC,cAAgB,UAGjBjjC,KAAK8gC,UACP9gC,KAAKm1C,oBAAoBiB,GACzBp2C,KAAKs2C,uBAAuBF,GAC5Bp2C,KAAKu2C,qBAGPv2C,KAAKq1C,iBACP,CAUC,SAAAzd,CAAU1W,GAET,MAAMs1B,EAAWt1B,IAIU,WAAvBlhB,KAAKijC,gBAMQ,IAAbuT,GAMJx2C,KAAKozC,iBACP,CAOC,mBAAA1b,GAKC,GAJA13B,KAAKm1C,sBAIAn1C,KAAKu1C,eAaVv1C,KAAK23B,+BAEL33B,KAAKs2C,6BAfL,CAGE,IAAKt2C,KAAKi2C,gBACR,OAIFj2C,KAAKg2C,QAEP,CAMF,CASC,kBAAAS,GACCz2C,KAAKm1C,sBACLn1C,KAAKs2C,wBACP,CAKC,gBAAAI,GACC,MAA2B,WAAvB12C,KAAKijC,cACA1E,QAAQC,UAGVx+B,KAAKm2C,gBACd,CAKC,KAAA/G,GACC,OAAOpvC,KAAKozC,iBACd,CAOC,cAAA+C,GAGC,OAFAn2C,KAAKozC,kBAEEpzC,KAAKozC,gBAAgBhE,OAC9B,CAKC,WAAAuH,GACC32C,KAAKozC,gBAAgBS,QACvB,CAGC,YAAA+C,GACC,OAAO52C,KAAK8gC,SAAW9gC,KAAK8gC,QAAQngC,EACtC,CAUC,4BAAAg3B,GAKC,KACE33B,KAAK4yC,eACLjR,GAAU3hC,KAAK4yC,cAAe5yC,KAAK8jC,SAASC,mBAC5C/jC,KAAK8gC,SACoB,YAAzB9gC,KAAK8gC,QAAQI,SAYf,QAAKlhC,KAAKi2C,gBANRj2C,KAAK+1C,OAYT,CAOC,eAAAxH,GACC,MAAMsI,EAAU,GAAG16C,EAAOuW,SAASokC,WAAW36C,EAAOuW,SAASqkC,OAAO56C,EAAOuW,SAAS0iB,SAC/EhxB,EAAM,GAAGjI,EAAOuW,SAAS/O,SAASkzC,IAExC72C,KAAK0yC,mBAAqB,GAC1B1yC,KAAK2yC,yBAA2B,GAGhC3yC,KAAKg3C,gBAELh3C,KAAKgzC,SAASC,WAAa7uC,EAC3BpE,KAAKgzC,SAAShP,iBAAmB/vB,KAAKD,MACtChU,KAAKgzC,SAASxK,KAAKlpC,KAAK8E,EAC1B,CAMC,iBAAAyzB,CACChgB,EACAyY,GAEA,MAAM4b,EAAMlsC,KAAKk0C,mBAAmBr8B,EAAOyY,GAI3C,GAAI4b,IAAQ+F,GAAW,CACrB,MAAMza,EAAa4D,GAAiB,CAClC3D,SAAU,qBAGZz3B,KAAK43B,UAAU,KAELgL,GAAa5iC,KAAM,CACzBgC,KAz2IoB,EA02IpB0uB,UAAW8G,EAAW9G,WAAa,EACnCnkB,KAAM,CACJurB,IAAK,aACL7Z,QAASuZ,EACT2D,QAAQ,KAIhB,CAEA,OAAO+Q,CACT,CAMC,eAAAhR,GAEC,MAAM+b,EAAkBj3C,KAAKi3C,kBAAmB,UAAkBC,iBAG5D9hC,GADc6hC,IAAmB,QAAWA,GAAiB1qC,MAAS,CAAC,GACnD,MAC1B,GAAK0qC,GAAoB7hC,GAAW,CAAC,QAAS,UAAU3W,SAAS2W,GAIjE,OAAO,QAAW6hC,GAAiBvR,WACrC,CAMC,oBAAAuP,GACCj1C,KAAKuuC,kBAILvuC,KAAKs2C,yBAELt2C,KAAKgjC,YAroGT,UAA2B,eACzB4L,EACAuI,UAAWC,IAEX,GACExI,GAEA75B,OAAOsiC,OACP,CACA,MAAMxY,EAWV,SAAqBuY,GACnB,IACE,MAAMD,EAAYC,IAgB4B,oBAArCE,kCAAqDA,iCAIzD,GA1eT,WAAa,MAAMnvC,EAAE,IAAIm+B,KAAK,CAFpB,kjUAEyB,OAAOsC,IAAI2O,gBAAgBpvC,EAAE,CAuerDA,IAfP,IAAKgvC,EACH,OAGF7Z,GAAQ,qCAAoC8Z,EAAkB,SAASA,IAAoB,KAC3F,MAAMvY,EAAS,IAAIwY,OAAOF,GAC1B,OAAO,IAAIrX,GAAiBjB,EAC9B,CAAE,MAAOlgC,GACP2+B,GAAQ,+CAEV,CACF,CA1BmBka,CAAYJ,GAE3B,GAAIvY,EACF,OAAOA,CAEX,CAGA,OADAvB,GAAQ,gCACD,IAAIS,EACb,CAmnGuB0Z,CAAkB,CACnC7I,eAAgB5uC,KAAKmzC,SAASvE,eAC9BuI,UAAWn3C,KAAKmzC,SAASgE,YAG3Bn3C,KAAK21C,mBACL31C,KAAK03C,gBAGL13C,KAAK6yC,YAAa,EAClB7yC,KAAK8yC,WAAY,EAEjB9yC,KAAKq1C,gBACP,CAGC,gBAAAH,CAAiBv2C,GAChBy+B,IAAe,KAAOz+B,MAAM,WAAYA,GAEpCy+B,IAAep9B,KAAKmzC,SAASlP,cAAgBjkC,KAAKmzC,SAASlP,aAAa+N,oBAC1E,QAAiBrzC,EAErB,CAKC,6BAAAq2C,CAA8B7T,GAG7B,MAAMK,EAAiBxhC,KAAKmzC,SAASzE,gBAAkB,EAEjD5N,EAAUqB,GACd,CACEF,kBAAmBjiC,KAAK8jC,SAAS7B,kBACjCD,kBAAmBhiC,KAAKmzC,SAASnR,kBACjCI,eAAgBpiC,KAAKmzC,SAASlP,aAAa7B,eAC3CjB,qBAEF,CACEM,cAAezhC,KAAKmzC,SAAS1R,cAC7BF,kBAAmBvhC,KAAKmzC,SAAS5R,kBACjCC,mBAIJxhC,KAAK8gC,QAAUA,CACjB,CAMC,aAAAmV,GAGC,IAAKj2C,KAAK8gC,QACR,OAAO,EAGT,MAAM6W,EAAiB33C,KAAK8gC,QAE5B,OACEoB,GAAqByV,EAAgB,CACnC1V,kBAAmBjiC,KAAK8jC,SAAS7B,kBACjCD,kBAAmBhiC,KAAKmzC,SAASnR,sBAKnChiC,KAAK43C,gBAAgBD,IACd,EAIX,CAOC,qBAAMC,CAAgB9W,GAChB9gC,KAAK6yC,mBAGJ7yC,KAAKwjC,KAAK,CAAED,OAAQ,oBAC1BvjC,KAAK+0C,mBAAmBjU,EAAQngC,IAClC,CAKC,aAAA+2C,GACC,IACEv7C,EAAOkJ,SAAS0I,iBAAiB,mBAAoB/N,KAAK63C,yBAC1D17C,EAAO4R,iBAAiB,OAAQ/N,KAAK83C,mBACrC37C,EAAO4R,iBAAiB,QAAS/N,KAAK+3C,oBACtC57C,EAAO4R,iBAAiB,UAAW/N,KAAKg4C,sBAEpCh4C,KAAKkuC,eACPluC,KAAKkuC,cAAclV,eAIhBh5B,KAAK+yC,+BAx6ChB,SAA4Bxb,GAE1B,MAAM6Y,GAAQ,UACR3M,GAAS,UAEf2M,EAAM6H,iBA7GN,CAAC1gB,GACA6Y,IACC,IAAK7Y,EAAOqM,YACV,OAGF,MAAM3d,EAYV,SAAqBmqB,GAKnB,MAAM8H,EAAgB9H,EAAM+H,mBAAqB/H,EAAM+H,oBAIvD,OAAI5K,KAAqB2K,GAAkBA,GAI3C3K,GAAmB2K,GAGSA,EAtCRzgB,UAuClB,CAAC,QAAS,MAAO,eAAgB,sBAAsBh5B,SAASy5C,EAAczgB,WAC9EygB,EAAczgB,SAAS7O,WAAW,OAE3B,KAGsB,YAA3BsvB,EAAczgB,SAQpB,SACED,GAEA,MAAMv6B,EAAOu6B,EAAWjrB,MAAQirB,EAAWjrB,KAAK6rC,UAEhD,IAAK/5C,MAAM6zB,QAAQj1B,IAAyB,IAAhBA,EAAKH,OAC/B,OAAOs+B,GAAiB5D,GAG1B,IAAI6gB,GAAc,EAGlB,MAAMC,EAAiBr7C,EAAKyW,IAAI4rB,IAC9B,IAAKA,EACH,OAAOA,EAET,GAAmB,iBAARA,EACT,OAAIA,EAAIxiC,OAASP,GACf87C,GAAc,EACP,GAAG/Y,EAAIh7B,MAAM,EAAG/H,OAGlB+iC,EAET,GAAmB,iBAARA,EACT,IACE,MAAMiZ,GAAgB,QAAUjZ,EAAK,GAErC,OADoBpgC,KAAKC,UAAUo5C,GACnBz7C,OAASP,GACvB87C,GAAc,EAEP,GAAGn5C,KAAKC,UAAUo5C,EAAe,KAAM,GAAGj0C,MAAM,EAAG/H,OAErDg8C,CACT,CAAE,MAAOpwC,GAET,CAGF,OAAOm3B,IAGT,OAAOlE,GAAiB,IACnB5D,EACHjrB,KAAM,IACDirB,EAAWjrB,KACd6rC,UAAWE,KACPD,EAAc,CAAErR,MAAO,CAAEC,SAAU,CAAC,2BAA+B,CAAC,IAG9E,CAzDWuR,CAA2BN,GAG7B9c,GAAiB8c,IAjBf,IAkBX,CAxCmBO,CAAYrI,GAEtBnqB,GAILqR,GAAmBC,EAAQtR,IAiGNyyB,CAAoBnhB,KAC3C,OAjnFwB,CACxBA,GAEQwV,IACN,IAAKxV,EAAOqM,YACV,OAGF,MAAM3d,EA6DV,SAAmB8mB,GACjB,MAAM,OAAE15B,EAAM,QAAE6c,GAQlB,SAAsB6c,GACpB,MAAM4L,EAA+B,UAArB5L,EAAYxnC,KAE5B,IAAI2qB,EACA7c,EAAS,KAGb,IACEA,EAASslC,EAAU1gB,GAAmB8U,EAAYl1B,OAAUqgB,GAAc6U,EAAYl1B,OACtFqY,GAAU,QAAiB7c,EAAQ,CAAEulC,gBAAiB,OAAU,WAClE,CAAE,MAAOzwC,GACP+nB,EAAU,WACZ,CAEA,MAAO,CAAE7c,SAAQ6c,UACnB,CAvB8B2oB,CAAa9L,GAEzC,OAAO3R,GAAiB,CACtB3D,SAAU,MAAMsV,EAAYxnC,UACzBi2B,GAAqBnoB,EAAQ6c,IAEpC,CApEmB4oB,CAAU/L,GAEzB,IAAK9mB,EACH,OAGF,MAAM0yB,EAA+B,UAArB5L,EAAYxnC,KACtBsS,EAAQ8gC,EAAW5L,EAAkB,WAAI5vC,EAvXnD,IAAqB+wC,EAAerU,EAAiBt4B,IA0X/Co3C,GACAphB,EAAO2W,eACPr2B,GACAA,EAAMxE,SACLwE,EAAMkhC,QACNlhC,EAAMmhC,SACNnhC,EAAMohC,SACNphC,EAAMqhC,WAjYQhL,EAoYb3W,EAAO2W,cApYqBrU,EAqY5B5T,EArY6C1kB,EAsY7C02B,GAAmB8U,EAAYl1B,OArYrCq2B,EAAc1U,YAAYK,EAAiBt4B,IAyYzC+1B,GAAmBC,EAAQtR,IA+kFUkzB,CAAkB5hB,KACzD,OAjmCF,SAAmCA,GACjC,OAAQwV,IACN,IAAKxV,EAAOqM,YACV,OAGF,MAAM3d,EAzBV,SAAuB8mB,GACrB,MAAM,KAAEzuC,EAAI,GAAE86C,GAAOrM,EAEf/4B,EAAMC,KAAKD,MAAQ,IAEzB,MAAO,CACLhS,KAAM,kBACNwrB,MAAOxZ,EACPyZ,IAAKzZ,EACLzO,KAAM6zC,EACN7sC,KAAM,CACJwH,SAAUzV,GAGhB,CAWmB+6C,CAActM,GAEd,OAAX9mB,IAKJsR,EAAO1rB,aAAa28B,KAAKlpC,KAAK2mB,EAAO1gB,MACrCgyB,EAAOG,sBAEPH,EAAOK,UAAU,KACf6N,GAAuBlO,EAAQ,CAACtR,KAEzB,KAGb,CA2kCmCqzB,CAA0B/hB,IAC3D6R,GAAyB7R,GAIzB,MAAMtB,EA/tCR,SACEsB,EACAgiB,GAAgC,GAEhC,MAAMC,EAAmBD,EAAgClV,GAAqB9M,QAAUp6B,EAExF,OAAOU,OAAO0T,OACZ,CAACsG,EAAO8xB,KAEN,IAAKpS,EAAOqM,YACV,OAAO/rB,EAGT,GAhON,SAAuBA,GACrB,MAAsB,iBAAfA,EAAM7V,IACf,CA8NUy3C,CAAc5hC,GAIhB,cADOA,EAAM6hC,YACN7hC,EAIT,IAAKqsB,GAAarsB,KAAWssB,GAAmBtsB,KAAWusB,GAAgBvsB,GACzE,OAAOA,EAKT,IADwB0f,EAAOI,+BAE7B,OAAO9f,EAGT,GAAIusB,GAAgBvsB,GAOlB,OAJA0f,EAAO6X,QACPv3B,EAAMgtB,SAAS8U,SAAShJ,UAAYpZ,EAAOqf,eA7FnD,SAA+Brf,EAAQ1f,GACrC0f,EAAOG,sBACPH,EAAOK,UAAU,KACV/f,EAAM6Y,YAQX6G,EAAOM,kBAAkB,CACvB71B,KAAMiY,GAAUgX,OAChBP,UAA6B,IAAlB7Y,EAAM6Y,UACjBnkB,KAAM,CACJurB,IAAK,aACL7Z,QAAS,CACPyS,UAAW7Y,EAAM6Y,UACjB1uB,KAAM,UACNy1B,SAAU,kBACVlrB,KAAM,CACJqtC,WAAY/hC,EAAMqtB,eAMnB,GAEX,CAkEQ2U,CAAsBtiB,EAAQ1f,GACvBA,EAKT,GArHN,SAAsBA,EAAO8xB,GAC3B,QAAI9xB,EAAM7V,OAAS6V,EAAMiiC,YAAcjiC,EAAMiiC,UAAUrF,SAAW58B,EAAMiiC,UAAUrF,OAAO33C,SAKrF6sC,EAAKoQ,oBAAqBpQ,EAAKoQ,kBAAkBC,UAKvD,CA0GUC,CAAapiC,EAAO8xB,KAAUpS,EAAO8L,aAAaY,aAAa+N,kBAEjE,OADA5U,IAAe,KAAO8c,IAAI,+CAAgDriC,GACnE,KAMT,MAAMsiC,EAzEZ,SAAoC5iB,EAAQ1f,GAC1C,MAA6B,WAAzB0f,EAAO0L,eAMPprB,EAAMqY,UAAY7zB,MAKjBwb,EAAMiiC,WAAajiC,EAAM7V,OAIvB0+B,GAAUnJ,EAAO8L,aAAaqL,gBACvC,CAwDkC0L,CAA2B7iB,EAAQ1f,GAiB/D,OAb0BsiC,GAAgD,YAAzB5iB,EAAO0L,iBAGtDprB,EAAMutB,KAAO,IAAKvtB,EAAMutB,KAAMC,SAAU9N,EAAOqf,iBAK7C4C,GAEFA,EAAiB3hC,EAAO,CAAEykB,WAAY,MAGjCzkB,GAET,CAAElX,GAAI,UAEV,CAupCyB05C,CAA0B9iB,GAASiW,GAAS/J,IAC/DA,GAAUA,EAAO6W,kBACnB7W,EAAO6W,kBAAkBrkB,IAEzB,OAAkBA,GAIhBuX,GAAS/J,KACXA,EAAOrwB,GAAG,kBAr1Cd,SAA+BmkB,GAC7B,OAAQ1f,IACD0f,EAAOqM,aAAgBM,GAAarsB,IAQ7C,SAA8B0f,EAAQ1f,GACpC,MAAM0iC,EAAiB1iC,EAAMiiC,WAAajiC,EAAMiiC,UAAUrF,QAAU58B,EAAMiiC,UAAUrF,OAAO,GAAG73C,MAChE,iBAAnB29C,IAOTA,EAAe10C,MAAM,6EAIrB00C,EAAe10C,MAAM,qEAKrByxB,GAAmBC,EAHA6D,GAAiB,CAClC3D,SAAU,yBAIhB,CAxBI+iB,CAAqBjjB,EAAQ1f,GAEjC,CA60CiC4iC,CAAsBljB,IACnDkM,EAAOrwB,GAAG,iBAAkBixB,GAAqB9M,IACjDkM,EAAOrwB,GAAG,YAAcsnC,IACtB,MAAMrV,EAAW9N,EAAOqf,eAEpBvR,GAAY9N,EAAOqM,aAAwC,YAAzBrM,EAAO0L,eAEnB1L,EAAOI,iCAE7B+iB,EAAI/J,UAAYtL,KAKtB5B,EAAOrwB,GAAG,mBAAoBunC,IAC5BpjB,EAAO0f,gBAAkB0D,IAK3BlX,EAAOrwB,GAAG,oBAAqBunC,IAC7BpjB,EAAO0f,gBAAkB0D,IAI3BlX,EAAOrwB,GAAG,qBAAsB,CAACwnC,EAAeryC,KAC9C,MAAM88B,EAAW9N,EAAOqf,eACpBruC,GAAWA,EAAQsyC,eAAiBtjB,EAAOqM,aAAeyB,GAExDuV,EAAc/V,UAAY+V,EAAc/V,SAAS8U,WACnDiB,EAAc/V,SAAS8U,SAAShJ,UAAYtL,KAKtD,CAi3CQyV,CAAmB96C,MAEnBA,KAAK+yC,8BAA+B,EAExC,CAAE,MAAOtlC,GACPzN,KAAKk1C,iBAAiBznC,EACxB,CAEAzN,KAAK+6C,4BA9tHT,SAAkCxjB,GAChC,SAASyjB,EAAoBpf,GAEtBrE,EAAOmb,mBAAmBj0C,SAASm9B,IACtCrE,EAAOmb,mBAAmBpzC,KAAKs8B,EAEnC,CAEA,SAASqf,GAAU,QAAEtwB,IACnBA,EAAQxpB,QAAQ65C,EAClB,CAEA,MAAME,EAAiB,GAavB,MAXA,CAAE,aAAc,QAAS,YAAc/5C,QAAQa,IAC7Ck5C,EAAe57C,MAAK,QAAqC0C,EAAMi5C,MAGjEC,EAAe57C,MACb,QAA6B,EAAG67B,aAC9B5D,EAAOob,yBAAyBrzC,KAlDtC,SAAmC67B,GAGjC,MAAMxQ,EAAUwQ,EAAOxQ,QACjBwwB,EAAYxwB,EAAQA,EAAQ7tB,OAAS,GACrCsF,EAAU+4C,EAAYA,EAAU/4C,aAAUjF,EAE1CP,EAAQu+B,EAAOv+B,MAEf6wB,EAAM4O,GAAgBz/B,GAc5B,MAZa,CACXoF,KAAM,2BACNuD,KAAM,2BACNioB,MAAOC,EACPA,MACAlhB,KAAM,CACJ3P,QACA+jB,KAAM/jB,EACN+iB,OAAQvd,EAAU6xB,GAAOzrB,OAAOnI,MAAM+B,QAAWjF,GAKvD,CA0B2Ci+C,CAA0BjgB,OAK5D,KACL+f,EAAe/5C,QAAQk6C,GAAiBA,KAE5C,CAksHuCC,CAAyBt7C,KAC9D,CAKC,gBAAA21C,GACC,IACEx5C,EAAOkJ,SAASgI,oBAAoB,mBAAoBrN,KAAK63C,yBAE7D17C,EAAOkR,oBAAoB,OAAQrN,KAAK83C,mBACxC37C,EAAOkR,oBAAoB,QAASrN,KAAK+3C,oBACzC57C,EAAOkR,oBAAoB,UAAWrN,KAAKg4C,sBAEvCh4C,KAAKkuC,eACPluC,KAAKkuC,cAAc5U,kBAGjBt5B,KAAK+6C,6BACP/6C,KAAK+6C,6BAET,CAAE,MAAOttC,GACPzN,KAAKk1C,iBAAiBznC,EACxB,CACF,CAQC,MAAA2kC,GAAUpyC,KAAK63C,wBAA0B,KACA,YAApC17C,EAAOkJ,SAASk2C,gBAClBv7C,KAAKw7C,6BAELx7C,KAAKy7C,6BAEP,CAKD,OAAApJ,GAAWryC,KAAK83C,kBAAoB,KACnC,MAAMtgB,EAAa4D,GAAiB,CAClC3D,SAAU,YAKZz3B,KAAKy7C,2BAA2BjkB,GAChC,CAKD,OAAA8a,GAAWtyC,KAAK+3C,mBAAqB,KACpC,MAAMvgB,EAAa4D,GAAiB,CAClC3D,SAAU,aAKZz3B,KAAKw7C,2BAA2BhkB,GAChC,CAGD,OAAA+a,GAAWvyC,KAAKg4C,qBAAwBngC,KA3/H3C,SAA6B0f,EAAQ1f,GACnC,IAAK0f,EAAOqM,YACV,OAMFrM,EAAOkf,qBAEP,MAAMjf,EAUR,SAA+B3f,GAC7B,MAAM,QAAEmhC,EAAO,SAAEE,EAAQ,QAAED,EAAO,OAAEF,EAAM,IAAEnkC,EAAG,OAAEvB,GAAWwE,EAG5D,IAAKxE,GA+BP,SAAwBA,GACtB,MAA0B,UAAnBA,EAAOtR,SAA0C,aAAnBsR,EAAOtR,SAA0BsR,EAAOqoC,iBAC/E,CAjCiBC,CAAetoC,KAAauB,EACzC,OAAO,KAIT,MAAMgnC,EAAiB5C,GAAWC,GAAWF,EACvC8C,EAAgC,IAAfjnC,EAAI9X,OAI3B,IAAK8+C,GAAkBC,EACrB,OAAO,KAGT,MAAM3rB,GAAU,QAAiB7c,EAAQ,CAAEulC,gBAAiB,OAAU,YAGtE,OAAOxd,GAAiB,CACtB3D,SAAU,aACVvH,UACA3jB,KAAM,IALeivB,GAAqBnoB,EAAS6c,GAM/B3jB,KAClBysC,UACAE,WACAD,UACAF,SACAnkC,QAGN,CA3CqBknC,CAAsBjkC,GAEpC2f,GAILF,GAAmBC,EAAQC,EAC7B,CA2+HIukB,CAAoB/7C,KAAM6X,GAC1B,CAKD,0BAAA4jC,CAA2BjkB,GACrBx3B,KAAK8gC,UAIMiB,GAAiB/hC,KAAK8gC,QAAS,CAC7CkB,kBAAmBhiC,KAAKmzC,SAASnR,kBACjCC,kBAAmBjiC,KAAK8jC,SAAS7B,sBAO/BzK,GACFx3B,KAAKg8C,wBAAwBxkB,GAQ1Bx3B,KAAK02C,oBACZ,CAKC,0BAAA8E,CAA2BhkB,GACrBx3B,KAAK8gC,UAIc9gC,KAAK23B,+BAUzBH,GACFx3B,KAAKg8C,wBAAwBxkB,GAL7B8F,GAAQ,gEAOZ,CAKC,mBAAA6X,CAAoBvC,EAAgB3+B,KAAKD,OACxChU,KAAK4yC,cAAgBA,CACvB,CAKC,sBAAA0D,CAAuB1D,EAAgB3+B,KAAKD,OACvChU,KAAK8gC,UACP9gC,KAAK8gC,QAAQE,aAAe4R,EAC5B5yC,KAAKu2C,oBAET,CAKC,uBAAAyF,CAAwBxkB,GACvBx3B,KAAK43B,UAAU,KAGb53B,KAAK63B,kBAAkB,CACrB71B,KAAMiY,GAAUgX,OAChBP,UAAW8G,EAAW9G,WAAa,EACnCnkB,KAAM,CACJurB,IAAK,aACL7Z,QAASuZ,MAIjB,CAMC,sBAAAykB,GACC,MAAMvJ,GAjhIR/nB,EAihIsD3qB,KAAK0yC,mBA/gIpD/nB,EAAQjX,IAAIupB,IAAwB/e,OAAOzgB,UA+gI6By+C,OAAOl8C,KAAK2yC,0BAlhI7F,IACEhoB,EAshIE,OAHA3qB,KAAK0yC,mBAAqB,GAC1B1yC,KAAK2yC,yBAA2B,GAEzBpU,QAAQgC,IAAIkF,GAAuBzlC,KAAM0yC,GAClD,CAKC,aAAAsE,GAECh3C,KAAKgzC,SAAS7N,SAASvR,QACvB5zB,KAAKgzC,SAAShO,SAASpR,QACvB5zB,KAAKgzC,SAASxK,KAAO,EACvB,CAGC,sCAAA2T,GACC,MAAM,QAAErb,EAAO,YAAEkC,GAAgBhjC,KACjC,IAAK8gC,IAAYkC,EACf,OAIF,GAAIlC,EAAQG,UACV,OAGF,MAAMkO,EAAgBnM,EAAYtE,uBAC9ByQ,GAAiBA,EAAgBnvC,KAAKgzC,SAAShP,mBACjDhkC,KAAKgzC,SAAShP,iBAAmBmL,EAErC,CAKC,gBAAAiN,GACC,MAAMpJ,EAAW,CACfhP,iBAAkBhkC,KAAKgzC,SAAShP,iBAChCiP,WAAYjzC,KAAKgzC,SAASC,WAC1B9N,SAAU9mC,MAAMC,KAAK0B,KAAKgzC,SAAS7N,UACnCH,SAAU3mC,MAAMC,KAAK0B,KAAKgzC,SAAShO,UACnCwD,KAAMxoC,KAAKgzC,SAASxK,MAKtB,OAFAxoC,KAAKg3C,gBAEEhE,CACT,CAUC,eAAMqJ,GACL,MAAMhX,EAAWrlC,KAAK42C,eAEtB,GAAK52C,KAAK8gC,SAAY9gC,KAAKgjC,aAAgBqC,GAQ3C,SAHMrlC,KAAKi8C,yBAGNj8C,KAAKgjC,aAAgBhjC,KAAKgjC,YAAY7E,kBAzlD/C4E,eAA8BxL,GAE5B,IACE,OAAOgH,QAAQgC,IACbkF,GAAuBlO,EAAQ,CAE7BkW,GAAkBtxC,EAAO+gC,YAAY4Q,UAG3C,CAAE,MAAOnvC,GAEP,MAAO,EACT,CACF,CAilDU29C,CAAet8C,MAGhBA,KAAKgjC,aAKNqC,IAAarlC,KAAK42C,gBAItB,IAEE52C,KAAKm8C,yCAEL,MAAMzrB,EAAYzc,KAAKD,MAKvB,GAAI0c,EAAY1wB,KAAKgzC,SAAShP,iBAAmBhkC,KAAKmzC,SAASnR,kBAAoB,IACjF,MAAM,IAAIlnB,MAAM,2CAGlB,MAAMg1B,EAAe9vC,KAAKo8C,mBAEpBnb,EAAYjhC,KAAK8gC,QAAQG,YAC/BjhC,KAAKu2C,oBAGL,MAAM3G,QAAsB5vC,KAAKgjC,YAAY1E,eAEvCkR,GAAW,CACfnK,WACAuK,gBACA3O,YACA6O,eACAhP,QAAS9gC,KAAK8gC,QACdv4B,QAASvI,KAAKqjC,aACd3S,aAEJ,CAAE,MAAOjjB,GACPzN,KAAKk1C,iBAAiBznC,GAOtBzN,KAAKwjC,KAAK,CAAED,OAAQ,eAEpB,MAAME,GAAS,UAEXA,GACFA,EAAOC,mBAAmB,aAAc,SAE5C,OArEEtG,IAAe,KAAOz+B,MAAM,qDAsEhC,CAMC,OAAA6zC,GAAWxyC,KAAK+zC,OAAShR,OACxB6S,SAAQ,GAGT,CAAC,KACA,IAAK51C,KAAK6yC,aAAe+C,EAEvB,OAGF,IAAK51C,KAAK23B,+BAER,YADAyF,IAAe,KAAOz+B,MAAM,sEAI9B,IAAKqB,KAAK8gC,QAER,OAGF,MAAMtT,EAAQxtB,KAAK8gC,QAAQC,QAErBvE,EADMvoB,KAAKD,MACMwZ,EAGvBxtB,KAAKozC,gBAAgBS,SAIrB,MAAM0I,EAAW/f,EAAWx8B,KAAKmzC,SAASqJ,kBACpCC,EAAUjgB,EAAWx8B,KAAKmzC,SAASnR,kBAAoB,IAC7D,GAAIua,GAAYE,EAWd,OAVAnf,GACE,8BAA8BjxB,KAAKkoC,MAAM/X,EAAW,iBAClD+f,EAAW,QAAU,8BAEvBv8C,KAAKmzC,SAASlP,aAAa7B,qBAGzBma,GACFv8C,KAAKozC,mBAKT,MAAMpQ,EAAchjC,KAAKgjC,YAQzB,GAPIA,GAA0C,IAA3BhjC,KAAK8gC,QAAQG,YAAoB+B,EAAY9E,aAC9DZ,GAAQ,sDAAuDt9B,KAAKmzC,SAASlP,aAAa7B,iBAMvFpiC,KAAK08C,WAIR,OAHA18C,KAAK08C,WAAa18C,KAAKq8C,kBACjBr8C,KAAK08C,gBACX18C,KAAK08C,gBAAav/C,GAUpB,UACQ6C,KAAK08C,UACb,CAAE,MAAOjvC,GACP2vB,IAAe,KAAOz+B,MAAM8O,EAC9B,CAAE,QACAzN,KAAKozC,iBACP,EACA,CAGD,iBAAAmD,GACKv2C,KAAK8gC,SAAW9gC,KAAKmzC,SAAS1R,eAChCL,GAAYphC,KAAK8gC,QAErB,CAGC,OAAA2R,GAAWzyC,KAAKw1C,mBAAsBp5B,IACrC,MAAM4Q,EAAQ5Q,EAAUtf,OAElB6/C,EAAgB38C,KAAKmzC,SAASwJ,cAE9BC,EAAoBD,GAAiB3vB,EAAQ2vB,EAInD,GAAI3vB,EAL4BhtB,KAAKmzC,SAAS0J,yBAKPD,EAAmB,CACxD,MAAMplB,EAAa4D,GAAiB,CAClC3D,SAAU,mBACVlrB,KAAM,CACJygB,QACAtmB,MAAOk2C,KAGX58C,KAAKg8C,wBAAwBxkB,EAC/B,CAGA,OAAIolB,IAGF58C,KAAKwjC,KAAK,CAAED,OAAQ,gBAAiBmS,WAAmC,YAAvB11C,KAAKijC,iBAC/C,GAKT,EAGJ,SAAS6Z,GACPC,EACAC,EACAC,EACAC,GAEA,MAEMC,EAAe,IAChBJ,KAH2D,iBAA7BG,EAAwCA,EAAyBl+C,MAAM,KAAO,MAQ5Gg+C,GAkBL,YAdqC,IAA1BC,IAE4B,iBAA1BA,GACTE,EAAa79C,KAAK,IAAI29C,MAGxB,QAAe,KAEbvvC,QAAQC,KACN,8IAKCwvC,EAAa3+C,KAAK,IAC3B,CAuFA,MAAM4+C,GACJ,mGAEIC,GAA0B,CAAC,iBAAkB,eAAgB,UAEnE,IAAIC,IAAe,EAWnB,MAAMC,GAIH,mBAAOC,GAAgBx9C,KAAKW,GAAK,QAAS,CAkB1C,WAAAZ,EAAY,cACXi0C,EAx9R4B,IAw9RW,cACvCC,EAt9R4B,KAs9RW,kBACvCuI,EAh8RwB,KAg8Re,kBACvCxa,EAAoByb,KAAmB,cACvChc,GAAgB,EAAI,eACpBmN,GAAiB,EAAI,UACrBuI,EAAS,aACTlT,EAAe,CAAC,EAAC,kBACjB1C,EAAiB,gBACjBmN,EAAe,YACf5mC,GAAc,EAAI,cAClBssB,GAAgB,EAAI,cACpBya,GAAgB,EAAI,wBAEpBgO,EAA0B,IAAG,cAC7BF,EAAgB,IAAK,iBAErB/H,EAAmB,IAAI,yBACvBC,EAA2B,GAAE,uBAE7BvL,EAAyB,GAAE,sBAC3BC,EAAwB,GAAE,qBAC1BC,GAAuB,EAAI,sBAC3BC,EAAwB,GAAE,uBAC1BC,EAAyB,GAAE,KAE3BgU,EAAO,GAAE,eACTC,EAAiB,CAAC,QAAS,eAAc,OACzCC,EAAS,GAAE,MACXC,EAAQ,GAAE,QACVC,EAAU,GAAE,OACZC,EAAS,GAAE,OACXC,EAAM,wBAEN1a,EAAuB,oBACvBgC,EAAmB,WAGnB78B,EAAU,cAEVC,EAAa,iBAEb5G,EAAgB,cAEhB4F,EAAa,iBAEbC,EAAgB,YAEhByb,GACE,CAAC,GAEHpjB,KAAKuF,KAAOg4C,GAAS58C,GAErB,MAAMs9C,EA9KV,UAA2B,KACzBP,EAAI,OACJE,EAAM,MACNC,EAAK,QACLC,EAAO,OACPC,EAAM,WAGNt1C,EAAU,cAEVC,EAAa,cAEbhB,EAAa,iBAEbC,EAAgB,YAEhByb,IAEA,MAKM7a,EAAU,CAEdZ,iBALmBm1C,GAAUY,EAAM,CAAC,eAAgB,sBAAuBh2C,EAAeC,GAM1FE,mBALqBi1C,GAAUc,EAAQ,CAAC,iBAAkB,yBAO1Dl1C,cAAeo0C,GACbe,EACA,CAAC,gBAAiB,sBAZU,kBAa5Bp1C,EACAC,GAEFC,gBAAiBm0C,GAAUgB,EAAS,CAAC,kBAAmB,0BACxDz6B,eAAgBy5B,GAAUiB,EAAQ,CAAC,iBAAkB,uBAAwB,sBAAuB36B,IAWtG,OARI3a,aAAsBvF,SACxBqF,EAAQE,WAAaA,GAGnBf,aAAyBxE,SAC3BqF,EAAQb,cAAgBA,GAGnBa,CACT,CA+H2B21C,CAAkB,CACvCR,OACAE,SACAC,QACAC,UACAC,SACAt1C,aACAC,gBACAhB,gBACAC,mBACAyb,gBAmGF,GAhGApjB,KAAKkzC,kBAAoB,CACvB9e,gBACAtsB,cACAhG,iBAAkB,IAAMA,GAAoB,CAAC,EAAIq8C,UAAU,GAC3Dr1C,WAAYk1C,EACZ37C,YAAa27C,EACbx4C,gBAAiB,CAACoP,EAAKhY,EAAOkG,IA7IpC,UAAuB,GACrBA,EAAE,IACF8R,EAAG,eACH+oC,EAAc,YACd71C,EAAW,eACXm2C,EAAc,MACdrhD,IAGA,OAAKkL,EAKDm2C,EAAep2C,oBAAsB/E,EAAGqE,QAAQ82C,EAAep2C,oBAC1DjL,EAIP+gD,EAAel/C,SAASmW,IAGf,UAARA,GAAkC,UAAf9R,EAAGf,SAAuB,CAAC,SAAU,UAAUtD,SAASqE,EAAGC,aAAa,SAAW,IAEhGnG,EAAM8B,QAAQ,QAAS,KAGzB9B,EAjBEA,CAkBX,CAkHQwhD,CAAc,CACZT,iBACA71C,cACAm2C,iBACArpC,MACAhY,QACAkG,UAGDm7C,EAGHl1C,eAAgB,MAChBF,kBAAkB,EAElBI,cAAc,EAGdyiB,cAAc,EACd7K,aAAepT,IACb,IACEA,EAAIusC,WAAY,CAClB,CAAE,MAAOr7C,GAGT,IAIJqB,KAAKq+C,gBAAkB,CACrBrK,gBACAC,gBACAuI,kBAAmBnwC,KAAKC,IAAIkwC,EAriSA,MAsiS5Bxa,kBAAmB31B,KAAKC,IAAI01B,EAniSN,MAoiStBP,gBACAF,oBACAmN,kBACAE,iBACAuI,YACAtI,gBACAza,gBACAtsB,cACA+0C,0BACAF,gBACA/H,mBACAC,2BACAvL,yBACAC,wBACAC,uBACAC,sBAAuB6U,GAAyB7U,GAChDC,uBAAwB4U,GAAyB5U,GACjDpG,0BACAgC,sBAEArB,gBAG+B,iBAAtB1C,IAET7zB,QAAQC,KACN,oQAGkC4zB,QAGpCvhC,KAAKq+C,gBAAgB9c,kBAAoBA,GAGZ,iBAApBmN,IAEThhC,QAAQC,KACN,kQAGkC+gC,QAGpC1uC,KAAKq+C,gBAAgB3P,gBAAkBA,GAGrC1uC,KAAKq+C,gBAAgBxP,gBAGvB7uC,KAAKkzC,kBAAkBxqC,cAAiB1I,KAAKkzC,kBAAkBxqC,cAE3D,GAAG1I,KAAKkzC,kBAAkBxqC,iBAAiB00C,KAD3CA,IAIFp9C,KAAKu+C,iBAAkB,SACzB,MAAM,IAAIzjC,MAAM,8DAGlB9a,KAAKu+C,gBAAiB,CACxB,CAGC,kBAAIA,GACH,OAAOjB,EACT,CAGC,kBAAIiB,CAAe3hD,GAClB0gD,GAAe1gD,CACjB,CAKC,SAAA4hD,IACM,WAILx+C,KAAKy+C,SAULlsC,WAAW,IAAMvS,KAAK0+C,eACxB,CASC,KAAAlxB,GACMxtB,KAAK84B,SAIV94B,KAAK84B,QAAQtL,OACf,CAMC,cAAA4nB,GACMp1C,KAAK84B,SAIV94B,KAAK84B,QAAQsc,gBACf,CAMC,IAAA5R,GACC,OAAKxjC,KAAK84B,QAIH94B,KAAK84B,QAAQ0K,KAAK,CAAEkS,WAA2C,YAA/B11C,KAAK84B,QAAQmK,gBAH3C1E,QAAQC,SAInB,CASC,KAAA4Q,CAAM7mC,GACL,OAAKvI,KAAK84B,SAAY94B,KAAK84B,QAAQ8K,YAI5B5jC,KAAK84B,QAAQyM,0BAA0Bh9B,GAHrCg2B,QAAQC,SAInB,CAKC,WAAAmgB,GACC,GAAK3+C,KAAK84B,SAAY94B,KAAK84B,QAAQ8K,YAInC,OAAO5jC,KAAK84B,QAAQ8d,cACtB,CAKC,WAAA8H,GACM1+C,KAAK84B,UAQV94B,KAAK4+C,wCAEL5+C,KAAK84B,QAAQic,qBACf,CAGC,MAAA0J,GAEC,MAAMI,EA+BV,SAAqCC,GACnC,MAAMrb,GAAS,UACTsb,EAAMtb,GAAWA,EAAOJ,aAExBwb,EAAe,CAAEtd,kBAAmB,EAAGmN,gBAAiB,MAAM,QAAkBoQ,IAEtF,OAAKC,GASiC,MAApCD,EAAevd,mBACmB,MAAlCud,EAAepQ,iBACiB,MAAhCqQ,EAAIC,0BAC4B,MAAhCD,EAAIE,2BAEJ,QAAe,KAEbvxC,QAAQC,KACN,2GAKsC,iBAAjCoxC,EAAIC,2BACbH,EAAatd,kBAAoBwd,EAAIC,0BAGK,iBAAjCD,EAAIE,2BACbJ,EAAanQ,gBAAkBqQ,EAAIE,0BAG9BJ,KA7BL,QAAe,KAEbnxC,QAAQC,KAAK,kCAERkxC,EA0BX,CApEyBK,CAA4Bl/C,KAAKq+C,iBAEtDr+C,KAAK84B,QAAU,IAAIoZ,GAAgB,CACjC3pC,QAASs2C,EACT1M,iBAAkBnyC,KAAKkzC,mBAE3B,CAGC,qCAAA0L,GAIC,IACE,MACMO,GADS,UACkBC,qBAAqB,gBAGtD,IAAKD,EACH,OAGFn/C,KAAK84B,QAAiB,QAAIqmB,EAAkB9b,YAC9C,CAAE,MAAOl7B,GAET,CAEF,EA2CF,SAASm2C,GAAyBvX,GAChC,MAAO,IAAIsW,MAA4BtW,EAAQrzB,IAAIgzB,GAAUA,EAAOzkC,eACtE,CA5CCs7C,GAASC,c","sources":["webpack://iadviser/./node_modules/@sentry/replay/esm/index.js"],"sourcesContent":["import { _nullishCoalesce, _optionalChain } from '@sentry/utils';\nimport { addBreadcrumb, getClient, isSentryRequestUrl, getCurrentScope, addEventProcessor, prepareEvent, getIsolationScope, setContext, captureException, spanToJSON, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from '@sentry/core';\nimport { GLOBAL_OBJ, normalize, fill, htmlTreeAsString, browserPerformanceTimeOrigin, logger, uuid4, SENTRY_XHR_DATA_KEY, dropUndefinedKeys, stringMatchesSomePattern, addFetchInstrumentationHandler, addXhrInstrumentationHandler, addClickKeypressInstrumentationHandler, addHistoryInstrumentationHandler, createEnvelope, createEventEnvelopeHeaders, getSdkMetadataForEnvelopeHeader, updateRateLimits, isRateLimited, consoleSandbox, isBrowser } from '@sentry/utils';\nimport { addPerformanceInstrumentationHandler, addLcpInstrumentationHandler } from '@sentry-internal/tracing';\n\n// exporting a separate copy of `WINDOW` rather than exporting the one from `@sentry/browser`\n// prevents the browser package from being bundled in the CDN bundle, and avoids a\n// circular dependency between the browser and replay packages should `@sentry/browser` import\n// from `@sentry/replay` in the future\nconst WINDOW = GLOBAL_OBJ ;\n\nconst REPLAY_SESSION_KEY = 'sentryReplaySession';\nconst REPLAY_EVENT_NAME = 'replay_event';\nconst UNABLE_TO_SEND_REPLAY = 'Unable to send Replay';\n\n// The idle limit for a session after which recording is paused.\nconst SESSION_IDLE_PAUSE_DURATION = 300000; // 5 minutes in ms\n\n// The idle limit for a session after which the session expires.\nconst SESSION_IDLE_EXPIRE_DURATION = 900000; // 15 minutes in ms\n\n/** Default flush delays */\nconst DEFAULT_FLUSH_MIN_DELAY = 5000;\n// XXX: Temp fix for our debounce logic where `maxWait` would never occur if it\n// was the same as `wait`\nconst DEFAULT_FLUSH_MAX_DELAY = 5500;\n\n/* How long to wait for error checkouts */\nconst BUFFER_CHECKOUT_TIME = 60000;\n\nconst RETRY_BASE_INTERVAL = 5000;\nconst RETRY_MAX_COUNT = 3;\n\n/* The max (uncompressed) size in bytes of a network body. Any body larger than this will be truncated. */\nconst NETWORK_BODY_MAX_SIZE = 150000;\n\n/* The max size of a single console arg that is captured. Any arg larger than this will be truncated. */\nconst CONSOLE_ARG_MAX_SIZE = 5000;\n\n/* Min. time to wait before we consider something a slow click. */\nconst SLOW_CLICK_THRESHOLD = 3000;\n/* For scroll actions after a click, we only look for a very short time period to detect programmatic scrolling. */\nconst SLOW_CLICK_SCROLL_TIMEOUT = 300;\n\n/** When encountering a total segment size exceeding this size, stop the replay (as we cannot properly ingest it). */\nconst REPLAY_MAX_EVENT_BUFFER_SIZE = 20000000; // ~20MB\n\n/** Replays must be min. 5s long before we send them. */\nconst MIN_REPLAY_DURATION = 4999;\n/* The max. allowed value that the minReplayDuration can be set to. */\nconst MIN_REPLAY_DURATION_LIMIT = 15000;\n\n/** The max. length of a replay. */\nconst MAX_REPLAY_DURATION = 3600000; // 60 minutes in ms;\n\nfunction _nullishCoalesce$1(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }function _optionalChain$5(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var NodeType$1;\n(function (NodeType) {\n NodeType[NodeType[\"Document\"] = 0] = \"Document\";\n NodeType[NodeType[\"DocumentType\"] = 1] = \"DocumentType\";\n NodeType[NodeType[\"Element\"] = 2] = \"Element\";\n NodeType[NodeType[\"Text\"] = 3] = \"Text\";\n NodeType[NodeType[\"CDATA\"] = 4] = \"CDATA\";\n NodeType[NodeType[\"Comment\"] = 5] = \"Comment\";\n})(NodeType$1 || (NodeType$1 = {}));\n\nfunction isElement$1(n) {\n return n.nodeType === n.ELEMENT_NODE;\n}\nfunction isShadowRoot(n) {\n const host = _optionalChain$5([n, 'optionalAccess', _ => _.host]);\n return Boolean(_optionalChain$5([host, 'optionalAccess', _2 => _2.shadowRoot]) === n);\n}\nfunction isNativeShadowDom(shadowRoot) {\n return Object.prototype.toString.call(shadowRoot) === '[object ShadowRoot]';\n}\nfunction fixBrowserCompatibilityIssuesInCSS(cssText) {\n if (cssText.includes(' background-clip: text;') &&\n !cssText.includes(' -webkit-background-clip: text;')) {\n cssText = cssText.replace(' background-clip: text;', ' -webkit-background-clip: text; background-clip: text;');\n }\n return cssText;\n}\nfunction escapeImportStatement(rule) {\n const { cssText } = rule;\n if (cssText.split('\"').length < 3)\n return cssText;\n const statement = ['@import', `url(${JSON.stringify(rule.href)})`];\n if (rule.layerName === '') {\n statement.push(`layer`);\n }\n else if (rule.layerName) {\n statement.push(`layer(${rule.layerName})`);\n }\n if (rule.supportsText) {\n statement.push(`supports(${rule.supportsText})`);\n }\n if (rule.media.length) {\n statement.push(rule.media.mediaText);\n }\n return statement.join(' ') + ';';\n}\nfunction stringifyStylesheet(s) {\n try {\n const rules = s.rules || s.cssRules;\n return rules\n ? fixBrowserCompatibilityIssuesInCSS(Array.from(rules, stringifyRule).join(''))\n : null;\n }\n catch (error) {\n return null;\n }\n}\nfunction stringifyRule(rule) {\n let importStringified;\n if (isCSSImportRule(rule)) {\n try {\n importStringified =\n stringifyStylesheet(rule.styleSheet) ||\n escapeImportStatement(rule);\n }\n catch (error) {\n }\n }\n else if (isCSSStyleRule(rule) && rule.selectorText.includes(':')) {\n return fixSafariColons(rule.cssText);\n }\n return importStringified || rule.cssText;\n}\nfunction fixSafariColons(cssStringified) {\n const regex = /(\\[(?:[\\w-]+)[^\\\\])(:(?:[\\w-]+)\\])/gm;\n return cssStringified.replace(regex, '$1\\\\$2');\n}\nfunction isCSSImportRule(rule) {\n return 'styleSheet' in rule;\n}\nfunction isCSSStyleRule(rule) {\n return 'selectorText' in rule;\n}\nclass Mirror {\n constructor() {\n this.idNodeMap = new Map();\n this.nodeMetaMap = new WeakMap();\n }\n getId(n) {\n if (!n)\n return -1;\n const id = _optionalChain$5([this, 'access', _3 => _3.getMeta, 'call', _4 => _4(n), 'optionalAccess', _5 => _5.id]);\n return _nullishCoalesce$1(id, () => ( -1));\n }\n getNode(id) {\n return this.idNodeMap.get(id) || null;\n }\n getIds() {\n return Array.from(this.idNodeMap.keys());\n }\n getMeta(n) {\n return this.nodeMetaMap.get(n) || null;\n }\n removeNodeFromMap(n) {\n const id = this.getId(n);\n this.idNodeMap.delete(id);\n if (n.childNodes) {\n n.childNodes.forEach((childNode) => this.removeNodeFromMap(childNode));\n }\n }\n has(id) {\n return this.idNodeMap.has(id);\n }\n hasNode(node) {\n return this.nodeMetaMap.has(node);\n }\n add(n, meta) {\n const id = meta.id;\n this.idNodeMap.set(id, n);\n this.nodeMetaMap.set(n, meta);\n }\n replace(id, n) {\n const oldNode = this.getNode(id);\n if (oldNode) {\n const meta = this.nodeMetaMap.get(oldNode);\n if (meta)\n this.nodeMetaMap.set(n, meta);\n }\n this.idNodeMap.set(id, n);\n }\n reset() {\n this.idNodeMap = new Map();\n this.nodeMetaMap = new WeakMap();\n }\n}\nfunction createMirror() {\n return new Mirror();\n}\nfunction shouldMaskInput({ maskInputOptions, tagName, type, }) {\n if (tagName === 'OPTION') {\n tagName = 'SELECT';\n }\n return Boolean(maskInputOptions[tagName.toLowerCase()] ||\n (type && maskInputOptions[type]) ||\n type === 'password' ||\n (tagName === 'INPUT' && !type && maskInputOptions['text']));\n}\nfunction maskInputValue({ isMasked, element, value, maskInputFn, }) {\n let text = value || '';\n if (!isMasked) {\n return text;\n }\n if (maskInputFn) {\n text = maskInputFn(text, element);\n }\n return '*'.repeat(text.length);\n}\nfunction toLowerCase(str) {\n return str.toLowerCase();\n}\nfunction toUpperCase(str) {\n return str.toUpperCase();\n}\nconst ORIGINAL_ATTRIBUTE_NAME = '__rrweb_original__';\nfunction is2DCanvasBlank(canvas) {\n const ctx = canvas.getContext('2d');\n if (!ctx)\n return true;\n const chunkSize = 50;\n for (let x = 0; x < canvas.width; x += chunkSize) {\n for (let y = 0; y < canvas.height; y += chunkSize) {\n const getImageData = ctx.getImageData;\n const originalGetImageData = ORIGINAL_ATTRIBUTE_NAME in getImageData\n ? getImageData[ORIGINAL_ATTRIBUTE_NAME]\n : getImageData;\n const pixelBuffer = new Uint32Array(originalGetImageData.call(ctx, x, y, Math.min(chunkSize, canvas.width - x), Math.min(chunkSize, canvas.height - y)).data.buffer);\n if (pixelBuffer.some((pixel) => pixel !== 0))\n return false;\n }\n }\n return true;\n}\nfunction getInputType(element) {\n const type = element.type;\n return element.hasAttribute('data-rr-is-password')\n ? 'password'\n : type\n ?\n toLowerCase(type)\n : null;\n}\nfunction getInputValue(el, tagName, type) {\n if (tagName === 'INPUT' && (type === 'radio' || type === 'checkbox')) {\n return el.getAttribute('value') || '';\n }\n return el.value;\n}\n\nlet _id = 1;\nconst tagNameRegex = new RegExp('[^a-z0-9-_:]');\nconst IGNORED_NODE = -2;\nfunction genId() {\n return _id++;\n}\nfunction getValidTagName(element) {\n if (element instanceof HTMLFormElement) {\n return 'form';\n }\n const processedTagName = toLowerCase(element.tagName);\n if (tagNameRegex.test(processedTagName)) {\n return 'div';\n }\n return processedTagName;\n}\nfunction extractOrigin(url) {\n let origin = '';\n if (url.indexOf('//') > -1) {\n origin = url.split('/').slice(0, 3).join('/');\n }\n else {\n origin = url.split('/')[0];\n }\n origin = origin.split('?')[0];\n return origin;\n}\nlet canvasService;\nlet canvasCtx;\nconst URL_IN_CSS_REF = /url\\((?:(')([^']*)'|(\")(.*?)\"|([^)]*))\\)/gm;\nconst URL_PROTOCOL_MATCH = /^(?:[a-z+]+:)?\\/\\//i;\nconst URL_WWW_MATCH = /^www\\..*/i;\nconst DATA_URI = /^(data:)([^,]*),(.*)/i;\nfunction absoluteToStylesheet(cssText, href) {\n return (cssText || '').replace(URL_IN_CSS_REF, (origin, quote1, path1, quote2, path2, path3) => {\n const filePath = path1 || path2 || path3;\n const maybeQuote = quote1 || quote2 || '';\n if (!filePath) {\n return origin;\n }\n if (URL_PROTOCOL_MATCH.test(filePath) || URL_WWW_MATCH.test(filePath)) {\n return `url(${maybeQuote}${filePath}${maybeQuote})`;\n }\n if (DATA_URI.test(filePath)) {\n return `url(${maybeQuote}${filePath}${maybeQuote})`;\n }\n if (filePath[0] === '/') {\n return `url(${maybeQuote}${extractOrigin(href) + filePath}${maybeQuote})`;\n }\n const stack = href.split('/');\n const parts = filePath.split('/');\n stack.pop();\n for (const part of parts) {\n if (part === '.') {\n continue;\n }\n else if (part === '..') {\n stack.pop();\n }\n else {\n stack.push(part);\n }\n }\n return `url(${maybeQuote}${stack.join('/')}${maybeQuote})`;\n });\n}\nconst SRCSET_NOT_SPACES = /^[^ \\t\\n\\r\\u000c]+/;\nconst SRCSET_COMMAS_OR_SPACES = /^[, \\t\\n\\r\\u000c]+/;\nfunction getAbsoluteSrcsetString(doc, attributeValue) {\n if (attributeValue.trim() === '') {\n return attributeValue;\n }\n let pos = 0;\n function collectCharacters(regEx) {\n let chars;\n const match = regEx.exec(attributeValue.substring(pos));\n if (match) {\n chars = match[0];\n pos += chars.length;\n return chars;\n }\n return '';\n }\n const output = [];\n while (true) {\n collectCharacters(SRCSET_COMMAS_OR_SPACES);\n if (pos >= attributeValue.length) {\n break;\n }\n let url = collectCharacters(SRCSET_NOT_SPACES);\n if (url.slice(-1) === ',') {\n url = absoluteToDoc(doc, url.substring(0, url.length - 1));\n output.push(url);\n }\n else {\n let descriptorsStr = '';\n url = absoluteToDoc(doc, url);\n let inParens = false;\n while (true) {\n const c = attributeValue.charAt(pos);\n if (c === '') {\n output.push((url + descriptorsStr).trim());\n break;\n }\n else if (!inParens) {\n if (c === ',') {\n pos += 1;\n output.push((url + descriptorsStr).trim());\n break;\n }\n else if (c === '(') {\n inParens = true;\n }\n }\n else {\n if (c === ')') {\n inParens = false;\n }\n }\n descriptorsStr += c;\n pos += 1;\n }\n }\n }\n return output.join(', ');\n}\nfunction absoluteToDoc(doc, attributeValue) {\n if (!attributeValue || attributeValue.trim() === '') {\n return attributeValue;\n }\n const a = doc.createElement('a');\n a.href = attributeValue;\n return a.href;\n}\nfunction isSVGElement(el) {\n return Boolean(el.tagName === 'svg' || el.ownerSVGElement);\n}\nfunction getHref() {\n const a = document.createElement('a');\n a.href = '';\n return a.href;\n}\nfunction transformAttribute(doc, tagName, name, value, element, maskAttributeFn) {\n if (!value) {\n return value;\n }\n if (name === 'src' ||\n (name === 'href' && !(tagName === 'use' && value[0] === '#'))) {\n return absoluteToDoc(doc, value);\n }\n else if (name === 'xlink:href' && value[0] !== '#') {\n return absoluteToDoc(doc, value);\n }\n else if (name === 'background' &&\n (tagName === 'table' || tagName === 'td' || tagName === 'th')) {\n return absoluteToDoc(doc, value);\n }\n else if (name === 'srcset') {\n return getAbsoluteSrcsetString(doc, value);\n }\n else if (name === 'style') {\n return absoluteToStylesheet(value, getHref());\n }\n else if (tagName === 'object' && name === 'data') {\n return absoluteToDoc(doc, value);\n }\n if (typeof maskAttributeFn === 'function') {\n return maskAttributeFn(name, value, element);\n }\n return value;\n}\nfunction ignoreAttribute(tagName, name, _value) {\n return (tagName === 'video' || tagName === 'audio') && name === 'autoplay';\n}\nfunction _isBlockedElement(element, blockClass, blockSelector, unblockSelector) {\n try {\n if (unblockSelector && element.matches(unblockSelector)) {\n return false;\n }\n if (typeof blockClass === 'string') {\n if (element.classList.contains(blockClass)) {\n return true;\n }\n }\n else {\n for (let eIndex = element.classList.length; eIndex--;) {\n const className = element.classList[eIndex];\n if (blockClass.test(className)) {\n return true;\n }\n }\n }\n if (blockSelector) {\n return element.matches(blockSelector);\n }\n }\n catch (e) {\n }\n return false;\n}\nfunction elementClassMatchesRegex(el, regex) {\n for (let eIndex = el.classList.length; eIndex--;) {\n const className = el.classList[eIndex];\n if (regex.test(className)) {\n return true;\n }\n }\n return false;\n}\nfunction distanceToMatch(node, matchPredicate, limit = Infinity, distance = 0) {\n if (!node)\n return -1;\n if (node.nodeType !== node.ELEMENT_NODE)\n return -1;\n if (distance > limit)\n return -1;\n if (matchPredicate(node))\n return distance;\n return distanceToMatch(node.parentNode, matchPredicate, limit, distance + 1);\n}\nfunction createMatchPredicate(className, selector) {\n return (node) => {\n const el = node;\n if (el === null)\n return false;\n try {\n if (className) {\n if (typeof className === 'string') {\n if (el.matches(`.${className}`))\n return true;\n }\n else if (elementClassMatchesRegex(el, className)) {\n return true;\n }\n }\n if (selector && el.matches(selector))\n return true;\n return false;\n }\n catch (e2) {\n return false;\n }\n };\n}\nfunction needMaskingText(node, maskTextClass, maskTextSelector, unmaskTextClass, unmaskTextSelector, maskAllText) {\n try {\n const el = node.nodeType === node.ELEMENT_NODE\n ? node\n : node.parentElement;\n if (el === null)\n return false;\n if (el.tagName === 'INPUT') {\n const autocomplete = el.getAttribute('autocomplete');\n const disallowedAutocompleteValues = [\n 'current-password',\n 'new-password',\n 'cc-number',\n 'cc-exp',\n 'cc-exp-month',\n 'cc-exp-year',\n 'cc-csc',\n ];\n if (disallowedAutocompleteValues.includes(autocomplete)) {\n return true;\n }\n }\n let maskDistance = -1;\n let unmaskDistance = -1;\n if (maskAllText) {\n unmaskDistance = distanceToMatch(el, createMatchPredicate(unmaskTextClass, unmaskTextSelector));\n if (unmaskDistance < 0) {\n return true;\n }\n maskDistance = distanceToMatch(el, createMatchPredicate(maskTextClass, maskTextSelector), unmaskDistance >= 0 ? unmaskDistance : Infinity);\n }\n else {\n maskDistance = distanceToMatch(el, createMatchPredicate(maskTextClass, maskTextSelector));\n if (maskDistance < 0) {\n return false;\n }\n unmaskDistance = distanceToMatch(el, createMatchPredicate(unmaskTextClass, unmaskTextSelector), maskDistance >= 0 ? maskDistance : Infinity);\n }\n return maskDistance >= 0\n ? unmaskDistance >= 0\n ? maskDistance <= unmaskDistance\n : true\n : unmaskDistance >= 0\n ? false\n : !!maskAllText;\n }\n catch (e) {\n }\n return !!maskAllText;\n}\nfunction onceIframeLoaded(iframeEl, listener, iframeLoadTimeout) {\n const win = iframeEl.contentWindow;\n if (!win) {\n return;\n }\n let fired = false;\n let readyState;\n try {\n readyState = win.document.readyState;\n }\n catch (error) {\n return;\n }\n if (readyState !== 'complete') {\n const timer = setTimeout(() => {\n if (!fired) {\n listener();\n fired = true;\n }\n }, iframeLoadTimeout);\n iframeEl.addEventListener('load', () => {\n clearTimeout(timer);\n fired = true;\n listener();\n });\n return;\n }\n const blankUrl = 'about:blank';\n if (win.location.href !== blankUrl ||\n iframeEl.src === blankUrl ||\n iframeEl.src === '') {\n setTimeout(listener, 0);\n return iframeEl.addEventListener('load', listener);\n }\n iframeEl.addEventListener('load', listener);\n}\nfunction onceStylesheetLoaded(link, listener, styleSheetLoadTimeout) {\n let fired = false;\n let styleSheetLoaded;\n try {\n styleSheetLoaded = link.sheet;\n }\n catch (error) {\n return;\n }\n if (styleSheetLoaded)\n return;\n const timer = setTimeout(() => {\n if (!fired) {\n listener();\n fired = true;\n }\n }, styleSheetLoadTimeout);\n link.addEventListener('load', () => {\n clearTimeout(timer);\n fired = true;\n listener();\n });\n}\nfunction serializeNode(n, options) {\n const { doc, mirror, blockClass, blockSelector, unblockSelector, maskAllText, maskAttributeFn, maskTextClass, unmaskTextClass, maskTextSelector, unmaskTextSelector, inlineStylesheet, maskInputOptions = {}, maskTextFn, maskInputFn, dataURLOptions = {}, inlineImages, recordCanvas, keepIframeSrcFn, newlyAddedElement = false, } = options;\n const rootId = getRootId(doc, mirror);\n switch (n.nodeType) {\n case n.DOCUMENT_NODE:\n if (n.compatMode !== 'CSS1Compat') {\n return {\n type: NodeType$1.Document,\n childNodes: [],\n compatMode: n.compatMode,\n };\n }\n else {\n return {\n type: NodeType$1.Document,\n childNodes: [],\n };\n }\n case n.DOCUMENT_TYPE_NODE:\n return {\n type: NodeType$1.DocumentType,\n name: n.name,\n publicId: n.publicId,\n systemId: n.systemId,\n rootId,\n };\n case n.ELEMENT_NODE:\n return serializeElementNode(n, {\n doc,\n blockClass,\n blockSelector,\n unblockSelector,\n inlineStylesheet,\n maskAttributeFn,\n maskInputOptions,\n maskInputFn,\n dataURLOptions,\n inlineImages,\n recordCanvas,\n keepIframeSrcFn,\n newlyAddedElement,\n rootId,\n maskAllText,\n maskTextClass,\n unmaskTextClass,\n maskTextSelector,\n unmaskTextSelector,\n });\n case n.TEXT_NODE:\n return serializeTextNode(n, {\n maskAllText,\n maskTextClass,\n unmaskTextClass,\n maskTextSelector,\n unmaskTextSelector,\n maskTextFn,\n maskInputOptions,\n maskInputFn,\n rootId,\n });\n case n.CDATA_SECTION_NODE:\n return {\n type: NodeType$1.CDATA,\n textContent: '',\n rootId,\n };\n case n.COMMENT_NODE:\n return {\n type: NodeType$1.Comment,\n textContent: n.textContent || '',\n rootId,\n };\n default:\n return false;\n }\n}\nfunction getRootId(doc, mirror) {\n if (!mirror.hasNode(doc))\n return undefined;\n const docId = mirror.getId(doc);\n return docId === 1 ? undefined : docId;\n}\nfunction serializeTextNode(n, options) {\n const { maskAllText, maskTextClass, unmaskTextClass, maskTextSelector, unmaskTextSelector, maskTextFn, maskInputOptions, maskInputFn, rootId, } = options;\n const parentTagName = n.parentNode && n.parentNode.tagName;\n let textContent = n.textContent;\n const isStyle = parentTagName === 'STYLE' ? true : undefined;\n const isScript = parentTagName === 'SCRIPT' ? true : undefined;\n const isTextarea = parentTagName === 'TEXTAREA' ? true : undefined;\n if (isStyle && textContent) {\n try {\n if (n.nextSibling || n.previousSibling) {\n }\n else if (_optionalChain$5([n, 'access', _6 => _6.parentNode, 'access', _7 => _7.sheet, 'optionalAccess', _8 => _8.cssRules])) {\n textContent = stringifyStylesheet(n.parentNode.sheet);\n }\n }\n catch (err) {\n console.warn(`Cannot get CSS styles from text's parentNode. Error: ${err}`, n);\n }\n textContent = absoluteToStylesheet(textContent, getHref());\n }\n if (isScript) {\n textContent = 'SCRIPT_PLACEHOLDER';\n }\n const forceMask = needMaskingText(n, maskTextClass, maskTextSelector, unmaskTextClass, unmaskTextSelector, maskAllText);\n if (!isStyle && !isScript && !isTextarea && textContent && forceMask) {\n textContent = maskTextFn\n ? maskTextFn(textContent, n.parentElement)\n : textContent.replace(/[\\S]/g, '*');\n }\n if (isTextarea && textContent && (maskInputOptions.textarea || forceMask)) {\n textContent = maskInputFn\n ? maskInputFn(textContent, n.parentNode)\n : textContent.replace(/[\\S]/g, '*');\n }\n if (parentTagName === 'OPTION' && textContent) {\n const isInputMasked = shouldMaskInput({\n type: null,\n tagName: parentTagName,\n maskInputOptions,\n });\n textContent = maskInputValue({\n isMasked: needMaskingText(n, maskTextClass, maskTextSelector, unmaskTextClass, unmaskTextSelector, isInputMasked),\n element: n,\n value: textContent,\n maskInputFn,\n });\n }\n return {\n type: NodeType$1.Text,\n textContent: textContent || '',\n isStyle,\n rootId,\n };\n}\nfunction serializeElementNode(n, options) {\n const { doc, blockClass, blockSelector, unblockSelector, inlineStylesheet, maskInputOptions = {}, maskAttributeFn, maskInputFn, dataURLOptions = {}, inlineImages, recordCanvas, keepIframeSrcFn, newlyAddedElement = false, rootId, maskAllText, maskTextClass, unmaskTextClass, maskTextSelector, unmaskTextSelector, } = options;\n const needBlock = _isBlockedElement(n, blockClass, blockSelector, unblockSelector);\n const tagName = getValidTagName(n);\n let attributes = {};\n const len = n.attributes.length;\n for (let i = 0; i < len; i++) {\n const attr = n.attributes[i];\n if (attr.name && !ignoreAttribute(tagName, attr.name, attr.value)) {\n attributes[attr.name] = transformAttribute(doc, tagName, toLowerCase(attr.name), attr.value, n, maskAttributeFn);\n }\n }\n if (tagName === 'link' && inlineStylesheet) {\n const stylesheet = Array.from(doc.styleSheets).find((s) => {\n return s.href === n.href;\n });\n let cssText = null;\n if (stylesheet) {\n cssText = stringifyStylesheet(stylesheet);\n }\n if (cssText) {\n delete attributes.rel;\n delete attributes.href;\n attributes._cssText = absoluteToStylesheet(cssText, stylesheet.href);\n }\n }\n if (tagName === 'style' &&\n n.sheet &&\n !(n.innerText || n.textContent || '').trim().length) {\n const cssText = stringifyStylesheet(n.sheet);\n if (cssText) {\n attributes._cssText = absoluteToStylesheet(cssText, getHref());\n }\n }\n if (tagName === 'input' ||\n tagName === 'textarea' ||\n tagName === 'select' ||\n tagName === 'option') {\n const el = n;\n const type = getInputType(el);\n const value = getInputValue(el, toUpperCase(tagName), type);\n const checked = el.checked;\n if (type !== 'submit' && type !== 'button' && value) {\n const forceMask = needMaskingText(el, maskTextClass, maskTextSelector, unmaskTextClass, unmaskTextSelector, shouldMaskInput({\n type,\n tagName: toUpperCase(tagName),\n maskInputOptions,\n }));\n attributes.value = maskInputValue({\n isMasked: forceMask,\n element: el,\n value,\n maskInputFn,\n });\n }\n if (checked) {\n attributes.checked = checked;\n }\n }\n if (tagName === 'option') {\n if (n.selected && !maskInputOptions['select']) {\n attributes.selected = true;\n }\n else {\n delete attributes.selected;\n }\n }\n if (tagName === 'canvas' && recordCanvas) {\n if (n.__context === '2d') {\n if (!is2DCanvasBlank(n)) {\n attributes.rr_dataURL = n.toDataURL(dataURLOptions.type, dataURLOptions.quality);\n }\n }\n else if (!('__context' in n)) {\n const canvasDataURL = n.toDataURL(dataURLOptions.type, dataURLOptions.quality);\n const blankCanvas = document.createElement('canvas');\n blankCanvas.width = n.width;\n blankCanvas.height = n.height;\n const blankCanvasDataURL = blankCanvas.toDataURL(dataURLOptions.type, dataURLOptions.quality);\n if (canvasDataURL !== blankCanvasDataURL) {\n attributes.rr_dataURL = canvasDataURL;\n }\n }\n }\n if (tagName === 'img' && inlineImages) {\n if (!canvasService) {\n canvasService = doc.createElement('canvas');\n canvasCtx = canvasService.getContext('2d');\n }\n const image = n;\n const oldValue = image.crossOrigin;\n image.crossOrigin = 'anonymous';\n const recordInlineImage = () => {\n image.removeEventListener('load', recordInlineImage);\n try {\n canvasService.width = image.naturalWidth;\n canvasService.height = image.naturalHeight;\n canvasCtx.drawImage(image, 0, 0);\n attributes.rr_dataURL = canvasService.toDataURL(dataURLOptions.type, dataURLOptions.quality);\n }\n catch (err) {\n console.warn(`Cannot inline img src=${image.currentSrc}! Error: ${err}`);\n }\n oldValue\n ? (attributes.crossOrigin = oldValue)\n : image.removeAttribute('crossorigin');\n };\n if (image.complete && image.naturalWidth !== 0)\n recordInlineImage();\n else\n image.addEventListener('load', recordInlineImage);\n }\n if (tagName === 'audio' || tagName === 'video') {\n attributes.rr_mediaState = n.paused\n ? 'paused'\n : 'played';\n attributes.rr_mediaCurrentTime = n.currentTime;\n }\n if (!newlyAddedElement) {\n if (n.scrollLeft) {\n attributes.rr_scrollLeft = n.scrollLeft;\n }\n if (n.scrollTop) {\n attributes.rr_scrollTop = n.scrollTop;\n }\n }\n if (needBlock) {\n const { width, height } = n.getBoundingClientRect();\n attributes = {\n class: attributes.class,\n rr_width: `${width}px`,\n rr_height: `${height}px`,\n };\n }\n if (tagName === 'iframe' && !keepIframeSrcFn(attributes.src)) {\n if (!n.contentDocument) {\n attributes.rr_src = attributes.src;\n }\n delete attributes.src;\n }\n let isCustomElement;\n try {\n if (customElements.get(tagName))\n isCustomElement = true;\n }\n catch (e) {\n }\n return {\n type: NodeType$1.Element,\n tagName,\n attributes,\n childNodes: [],\n isSVG: isSVGElement(n) || undefined,\n needBlock,\n rootId,\n isCustom: isCustomElement,\n };\n}\nfunction lowerIfExists(maybeAttr) {\n if (maybeAttr === undefined || maybeAttr === null) {\n return '';\n }\n else {\n return maybeAttr.toLowerCase();\n }\n}\nfunction slimDOMExcluded(sn, slimDOMOptions) {\n if (slimDOMOptions.comment && sn.type === NodeType$1.Comment) {\n return true;\n }\n else if (sn.type === NodeType$1.Element) {\n if (slimDOMOptions.script &&\n (sn.tagName === 'script' ||\n (sn.tagName === 'link' &&\n (sn.attributes.rel === 'preload' ||\n sn.attributes.rel === 'modulepreload') &&\n sn.attributes.as === 'script') ||\n (sn.tagName === 'link' &&\n sn.attributes.rel === 'prefetch' &&\n typeof sn.attributes.href === 'string' &&\n sn.attributes.href.endsWith('.js')))) {\n return true;\n }\n else if (slimDOMOptions.headFavicon &&\n ((sn.tagName === 'link' && sn.attributes.rel === 'shortcut icon') ||\n (sn.tagName === 'meta' &&\n (lowerIfExists(sn.attributes.name).match(/^msapplication-tile(image|color)$/) ||\n lowerIfExists(sn.attributes.name) === 'application-name' ||\n lowerIfExists(sn.attributes.rel) === 'icon' ||\n lowerIfExists(sn.attributes.rel) === 'apple-touch-icon' ||\n lowerIfExists(sn.attributes.rel) === 'shortcut icon')))) {\n return true;\n }\n else if (sn.tagName === 'meta') {\n if (slimDOMOptions.headMetaDescKeywords &&\n lowerIfExists(sn.attributes.name).match(/^description|keywords$/)) {\n return true;\n }\n else if (slimDOMOptions.headMetaSocial &&\n (lowerIfExists(sn.attributes.property).match(/^(og|twitter|fb):/) ||\n lowerIfExists(sn.attributes.name).match(/^(og|twitter):/) ||\n lowerIfExists(sn.attributes.name) === 'pinterest')) {\n return true;\n }\n else if (slimDOMOptions.headMetaRobots &&\n (lowerIfExists(sn.attributes.name) === 'robots' ||\n lowerIfExists(sn.attributes.name) === 'googlebot' ||\n lowerIfExists(sn.attributes.name) === 'bingbot')) {\n return true;\n }\n else if (slimDOMOptions.headMetaHttpEquiv &&\n sn.attributes['http-equiv'] !== undefined) {\n return true;\n }\n else if (slimDOMOptions.headMetaAuthorship &&\n (lowerIfExists(sn.attributes.name) === 'author' ||\n lowerIfExists(sn.attributes.name) === 'generator' ||\n lowerIfExists(sn.attributes.name) === 'framework' ||\n lowerIfExists(sn.attributes.name) === 'publisher' ||\n lowerIfExists(sn.attributes.name) === 'progid' ||\n lowerIfExists(sn.attributes.property).match(/^article:/) ||\n lowerIfExists(sn.attributes.property).match(/^product:/))) {\n return true;\n }\n else if (slimDOMOptions.headMetaVerification &&\n (lowerIfExists(sn.attributes.name) === 'google-site-verification' ||\n lowerIfExists(sn.attributes.name) === 'yandex-verification' ||\n lowerIfExists(sn.attributes.name) === 'csrf-token' ||\n lowerIfExists(sn.attributes.name) === 'p:domain_verify' ||\n lowerIfExists(sn.attributes.name) === 'verify-v1' ||\n lowerIfExists(sn.attributes.name) === 'verification' ||\n lowerIfExists(sn.attributes.name) === 'shopify-checkout-api-token')) {\n return true;\n }\n }\n }\n return false;\n}\nfunction serializeNodeWithId(n, options) {\n const { doc, mirror, blockClass, blockSelector, unblockSelector, maskAllText, maskTextClass, unmaskTextClass, maskTextSelector, unmaskTextSelector, skipChild = false, inlineStylesheet = true, maskInputOptions = {}, maskAttributeFn, maskTextFn, maskInputFn, slimDOMOptions, dataURLOptions = {}, inlineImages = false, recordCanvas = false, onSerialize, onIframeLoad, iframeLoadTimeout = 5000, onStylesheetLoad, stylesheetLoadTimeout = 5000, keepIframeSrcFn = () => false, newlyAddedElement = false, } = options;\n let { preserveWhiteSpace = true } = options;\n const _serializedNode = serializeNode(n, {\n doc,\n mirror,\n blockClass,\n blockSelector,\n maskAllText,\n unblockSelector,\n maskTextClass,\n unmaskTextClass,\n maskTextSelector,\n unmaskTextSelector,\n inlineStylesheet,\n maskInputOptions,\n maskAttributeFn,\n maskTextFn,\n maskInputFn,\n dataURLOptions,\n inlineImages,\n recordCanvas,\n keepIframeSrcFn,\n newlyAddedElement,\n });\n if (!_serializedNode) {\n console.warn(n, 'not serialized');\n return null;\n }\n let id;\n if (mirror.hasNode(n)) {\n id = mirror.getId(n);\n }\n else if (slimDOMExcluded(_serializedNode, slimDOMOptions) ||\n (!preserveWhiteSpace &&\n _serializedNode.type === NodeType$1.Text &&\n !_serializedNode.isStyle &&\n !_serializedNode.textContent.replace(/^\\s+|\\s+$/gm, '').length)) {\n id = IGNORED_NODE;\n }\n else {\n id = genId();\n }\n const serializedNode = Object.assign(_serializedNode, { id });\n mirror.add(n, serializedNode);\n if (id === IGNORED_NODE) {\n return null;\n }\n if (onSerialize) {\n onSerialize(n);\n }\n let recordChild = !skipChild;\n if (serializedNode.type === NodeType$1.Element) {\n recordChild = recordChild && !serializedNode.needBlock;\n delete serializedNode.needBlock;\n const shadowRoot = n.shadowRoot;\n if (shadowRoot && isNativeShadowDom(shadowRoot))\n serializedNode.isShadowHost = true;\n }\n if ((serializedNode.type === NodeType$1.Document ||\n serializedNode.type === NodeType$1.Element) &&\n recordChild) {\n if (slimDOMOptions.headWhitespace &&\n serializedNode.type === NodeType$1.Element &&\n serializedNode.tagName === 'head') {\n preserveWhiteSpace = false;\n }\n const bypassOptions = {\n doc,\n mirror,\n blockClass,\n blockSelector,\n maskAllText,\n unblockSelector,\n maskTextClass,\n unmaskTextClass,\n maskTextSelector,\n unmaskTextSelector,\n skipChild,\n inlineStylesheet,\n maskInputOptions,\n maskAttributeFn,\n maskTextFn,\n maskInputFn,\n slimDOMOptions,\n dataURLOptions,\n inlineImages,\n recordCanvas,\n preserveWhiteSpace,\n onSerialize,\n onIframeLoad,\n iframeLoadTimeout,\n onStylesheetLoad,\n stylesheetLoadTimeout,\n keepIframeSrcFn,\n };\n for (const childN of Array.from(n.childNodes)) {\n const serializedChildNode = serializeNodeWithId(childN, bypassOptions);\n if (serializedChildNode) {\n serializedNode.childNodes.push(serializedChildNode);\n }\n }\n if (isElement$1(n) && n.shadowRoot) {\n for (const childN of Array.from(n.shadowRoot.childNodes)) {\n const serializedChildNode = serializeNodeWithId(childN, bypassOptions);\n if (serializedChildNode) {\n isNativeShadowDom(n.shadowRoot) &&\n (serializedChildNode.isShadow = true);\n serializedNode.childNodes.push(serializedChildNode);\n }\n }\n }\n }\n if (n.parentNode &&\n isShadowRoot(n.parentNode) &&\n isNativeShadowDom(n.parentNode)) {\n serializedNode.isShadow = true;\n }\n if (serializedNode.type === NodeType$1.Element &&\n serializedNode.tagName === 'iframe') {\n onceIframeLoaded(n, () => {\n const iframeDoc = n.contentDocument;\n if (iframeDoc && onIframeLoad) {\n const serializedIframeNode = serializeNodeWithId(iframeDoc, {\n doc: iframeDoc,\n mirror,\n blockClass,\n blockSelector,\n unblockSelector,\n maskAllText,\n maskTextClass,\n unmaskTextClass,\n maskTextSelector,\n unmaskTextSelector,\n skipChild: false,\n inlineStylesheet,\n maskInputOptions,\n maskAttributeFn,\n maskTextFn,\n maskInputFn,\n slimDOMOptions,\n dataURLOptions,\n inlineImages,\n recordCanvas,\n preserveWhiteSpace,\n onSerialize,\n onIframeLoad,\n iframeLoadTimeout,\n onStylesheetLoad,\n stylesheetLoadTimeout,\n keepIframeSrcFn,\n });\n if (serializedIframeNode) {\n onIframeLoad(n, serializedIframeNode);\n }\n }\n }, iframeLoadTimeout);\n }\n if (serializedNode.type === NodeType$1.Element &&\n serializedNode.tagName === 'link' &&\n serializedNode.attributes.rel === 'stylesheet') {\n onceStylesheetLoaded(n, () => {\n if (onStylesheetLoad) {\n const serializedLinkNode = serializeNodeWithId(n, {\n doc,\n mirror,\n blockClass,\n blockSelector,\n unblockSelector,\n maskAllText,\n maskTextClass,\n unmaskTextClass,\n maskTextSelector,\n unmaskTextSelector,\n skipChild: false,\n inlineStylesheet,\n maskInputOptions,\n maskAttributeFn,\n maskTextFn,\n maskInputFn,\n slimDOMOptions,\n dataURLOptions,\n inlineImages,\n recordCanvas,\n preserveWhiteSpace,\n onSerialize,\n onIframeLoad,\n iframeLoadTimeout,\n onStylesheetLoad,\n stylesheetLoadTimeout,\n keepIframeSrcFn,\n });\n if (serializedLinkNode) {\n onStylesheetLoad(n, serializedLinkNode);\n }\n }\n }, stylesheetLoadTimeout);\n }\n return serializedNode;\n}\nfunction snapshot(n, options) {\n const { mirror = new Mirror(), blockClass = 'rr-block', blockSelector = null, unblockSelector = null, maskAllText = false, maskTextClass = 'rr-mask', unmaskTextClass = null, maskTextSelector = null, unmaskTextSelector = null, inlineStylesheet = true, inlineImages = false, recordCanvas = false, maskAllInputs = false, maskAttributeFn, maskTextFn, maskInputFn, slimDOM = false, dataURLOptions, preserveWhiteSpace, onSerialize, onIframeLoad, iframeLoadTimeout, onStylesheetLoad, stylesheetLoadTimeout, keepIframeSrcFn = () => false, } = options || {};\n const maskInputOptions = maskAllInputs === true\n ? {\n color: true,\n date: true,\n 'datetime-local': true,\n email: true,\n month: true,\n number: true,\n range: true,\n search: true,\n tel: true,\n text: true,\n time: true,\n url: true,\n week: true,\n textarea: true,\n select: true,\n }\n : maskAllInputs === false\n ? {}\n : maskAllInputs;\n const slimDOMOptions = slimDOM === true || slimDOM === 'all'\n ?\n {\n script: true,\n comment: true,\n headFavicon: true,\n headWhitespace: true,\n headMetaDescKeywords: slimDOM === 'all',\n headMetaSocial: true,\n headMetaRobots: true,\n headMetaHttpEquiv: true,\n headMetaAuthorship: true,\n headMetaVerification: true,\n }\n : slimDOM === false\n ? {}\n : slimDOM;\n return serializeNodeWithId(n, {\n doc: n,\n mirror,\n blockClass,\n blockSelector,\n unblockSelector,\n maskAllText,\n maskTextClass,\n unmaskTextClass,\n maskTextSelector,\n unmaskTextSelector,\n skipChild: false,\n inlineStylesheet,\n maskInputOptions,\n maskAttributeFn,\n maskTextFn,\n maskInputFn,\n slimDOMOptions,\n dataURLOptions,\n inlineImages,\n recordCanvas,\n preserveWhiteSpace,\n onSerialize,\n onIframeLoad,\n iframeLoadTimeout,\n onStylesheetLoad,\n stylesheetLoadTimeout,\n keepIframeSrcFn,\n newlyAddedElement: false,\n });\n}\n\nfunction _optionalChain$4(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }\nfunction on(type, fn, target = document) {\n const options = { capture: true, passive: true };\n target.addEventListener(type, fn, options);\n return () => target.removeEventListener(type, fn, options);\n}\nconst DEPARTED_MIRROR_ACCESS_WARNING = 'Please stop import mirror directly. Instead of that,' +\n '\\r\\n' +\n 'now you can use replayer.getMirror() to access the mirror instance of a replayer,' +\n '\\r\\n' +\n 'or you can use record.mirror to access the mirror instance during recording.';\nlet _mirror = {\n map: {},\n getId() {\n console.error(DEPARTED_MIRROR_ACCESS_WARNING);\n return -1;\n },\n getNode() {\n console.error(DEPARTED_MIRROR_ACCESS_WARNING);\n return null;\n },\n removeNodeFromMap() {\n console.error(DEPARTED_MIRROR_ACCESS_WARNING);\n },\n has() {\n console.error(DEPARTED_MIRROR_ACCESS_WARNING);\n return false;\n },\n reset() {\n console.error(DEPARTED_MIRROR_ACCESS_WARNING);\n },\n};\nif (typeof window !== 'undefined' && window.Proxy && window.Reflect) {\n _mirror = new Proxy(_mirror, {\n get(target, prop, receiver) {\n if (prop === 'map') {\n console.error(DEPARTED_MIRROR_ACCESS_WARNING);\n }\n return Reflect.get(target, prop, receiver);\n },\n });\n}\nfunction throttle$1(func, wait, options = {}) {\n let timeout = null;\n let previous = 0;\n return function (...args) {\n const now = Date.now();\n if (!previous && options.leading === false) {\n previous = now;\n }\n const remaining = wait - (now - previous);\n const context = this;\n if (remaining <= 0 || remaining > wait) {\n if (timeout) {\n clearTimeout$1(timeout);\n timeout = null;\n }\n previous = now;\n func.apply(context, args);\n }\n else if (!timeout && options.trailing !== false) {\n timeout = setTimeout$1(() => {\n previous = options.leading === false ? 0 : Date.now();\n timeout = null;\n func.apply(context, args);\n }, remaining);\n }\n };\n}\nfunction hookSetter(target, key, d, isRevoked, win = window) {\n const original = win.Object.getOwnPropertyDescriptor(target, key);\n win.Object.defineProperty(target, key, isRevoked\n ? d\n : {\n set(value) {\n setTimeout$1(() => {\n d.set.call(this, value);\n }, 0);\n if (original && original.set) {\n original.set.call(this, value);\n }\n },\n });\n return () => hookSetter(target, key, original || {}, true);\n}\nfunction patch(source, name, replacement) {\n try {\n if (!(name in source)) {\n return () => {\n };\n }\n const original = source[name];\n const wrapped = replacement(original);\n if (typeof wrapped === 'function') {\n wrapped.prototype = wrapped.prototype || {};\n Object.defineProperties(wrapped, {\n __rrweb_original__: {\n enumerable: false,\n value: original,\n },\n });\n }\n source[name] = wrapped;\n return () => {\n source[name] = original;\n };\n }\n catch (e2) {\n return () => {\n };\n }\n}\nlet nowTimestamp = Date.now;\nif (!(/[1-9][0-9]{12}/.test(Date.now().toString()))) {\n nowTimestamp = () => new Date().getTime();\n}\nfunction getWindowScroll(win) {\n const doc = win.document;\n return {\n left: doc.scrollingElement\n ? doc.scrollingElement.scrollLeft\n : win.pageXOffset !== undefined\n ? win.pageXOffset\n : _optionalChain$4([doc, 'optionalAccess', _ => _.documentElement, 'access', _2 => _2.scrollLeft]) ||\n _optionalChain$4([doc, 'optionalAccess', _3 => _3.body, 'optionalAccess', _4 => _4.parentElement, 'optionalAccess', _5 => _5.scrollLeft]) ||\n _optionalChain$4([doc, 'optionalAccess', _6 => _6.body, 'optionalAccess', _7 => _7.scrollLeft]) ||\n 0,\n top: doc.scrollingElement\n ? doc.scrollingElement.scrollTop\n : win.pageYOffset !== undefined\n ? win.pageYOffset\n : _optionalChain$4([doc, 'optionalAccess', _8 => _8.documentElement, 'access', _9 => _9.scrollTop]) ||\n _optionalChain$4([doc, 'optionalAccess', _10 => _10.body, 'optionalAccess', _11 => _11.parentElement, 'optionalAccess', _12 => _12.scrollTop]) ||\n _optionalChain$4([doc, 'optionalAccess', _13 => _13.body, 'optionalAccess', _14 => _14.scrollTop]) ||\n 0,\n };\n}\nfunction getWindowHeight() {\n return (window.innerHeight ||\n (document.documentElement && document.documentElement.clientHeight) ||\n (document.body && document.body.clientHeight));\n}\nfunction getWindowWidth() {\n return (window.innerWidth ||\n (document.documentElement && document.documentElement.clientWidth) ||\n (document.body && document.body.clientWidth));\n}\nfunction closestElementOfNode(node) {\n if (!node) {\n return null;\n }\n const el = node.nodeType === node.ELEMENT_NODE\n ? node\n : node.parentElement;\n return el;\n}\nfunction isBlocked(node, blockClass, blockSelector, unblockSelector, checkAncestors) {\n if (!node) {\n return false;\n }\n const el = closestElementOfNode(node);\n if (!el) {\n return false;\n }\n const blockedPredicate = createMatchPredicate(blockClass, blockSelector);\n if (!checkAncestors) {\n const isUnblocked = unblockSelector && el.matches(unblockSelector);\n return blockedPredicate(el) && !isUnblocked;\n }\n const blockDistance = distanceToMatch(el, blockedPredicate);\n let unblockDistance = -1;\n if (blockDistance < 0) {\n return false;\n }\n if (unblockSelector) {\n unblockDistance = distanceToMatch(el, createMatchPredicate(null, unblockSelector));\n }\n if (blockDistance > -1 && unblockDistance < 0) {\n return true;\n }\n return blockDistance < unblockDistance;\n}\nfunction isSerialized(n, mirror) {\n return mirror.getId(n) !== -1;\n}\nfunction isIgnored(n, mirror) {\n return mirror.getId(n) === IGNORED_NODE;\n}\nfunction isAncestorRemoved(target, mirror) {\n if (isShadowRoot(target)) {\n return false;\n }\n const id = mirror.getId(target);\n if (!mirror.has(id)) {\n return true;\n }\n if (target.parentNode &&\n target.parentNode.nodeType === target.DOCUMENT_NODE) {\n return false;\n }\n if (!target.parentNode) {\n return true;\n }\n return isAncestorRemoved(target.parentNode, mirror);\n}\nfunction legacy_isTouchEvent(event) {\n return Boolean(event.changedTouches);\n}\nfunction polyfill(win = window) {\n if ('NodeList' in win && !win.NodeList.prototype.forEach) {\n win.NodeList.prototype.forEach = Array.prototype\n .forEach;\n }\n if ('DOMTokenList' in win && !win.DOMTokenList.prototype.forEach) {\n win.DOMTokenList.prototype.forEach = Array.prototype\n .forEach;\n }\n if (!Node.prototype.contains) {\n Node.prototype.contains = (...args) => {\n let node = args[0];\n if (!(0 in args)) {\n throw new TypeError('1 argument is required');\n }\n do {\n if (this === node) {\n return true;\n }\n } while ((node = node && node.parentNode));\n return false;\n };\n }\n}\nfunction isSerializedIframe(n, mirror) {\n return Boolean(n.nodeName === 'IFRAME' && mirror.getMeta(n));\n}\nfunction isSerializedStylesheet(n, mirror) {\n return Boolean(n.nodeName === 'LINK' &&\n n.nodeType === n.ELEMENT_NODE &&\n n.getAttribute &&\n n.getAttribute('rel') === 'stylesheet' &&\n mirror.getMeta(n));\n}\nfunction hasShadowRoot(n) {\n return Boolean(_optionalChain$4([n, 'optionalAccess', _18 => _18.shadowRoot]));\n}\nclass StyleSheetMirror {\n constructor() {\n this.id = 1;\n this.styleIDMap = new WeakMap();\n this.idStyleMap = new Map();\n }\n getId(stylesheet) {\n return _nullishCoalesce(this.styleIDMap.get(stylesheet), () => ( -1));\n }\n has(stylesheet) {\n return this.styleIDMap.has(stylesheet);\n }\n add(stylesheet, id) {\n if (this.has(stylesheet))\n return this.getId(stylesheet);\n let newId;\n if (id === undefined) {\n newId = this.id++;\n }\n else\n newId = id;\n this.styleIDMap.set(stylesheet, newId);\n this.idStyleMap.set(newId, stylesheet);\n return newId;\n }\n getStyle(id) {\n return this.idStyleMap.get(id) || null;\n }\n reset() {\n this.styleIDMap = new WeakMap();\n this.idStyleMap = new Map();\n this.id = 1;\n }\n generateId() {\n return this.id++;\n }\n}\nfunction getShadowHost(n) {\n let shadowHost = null;\n if (_optionalChain$4([n, 'access', _19 => _19.getRootNode, 'optionalCall', _20 => _20(), 'optionalAccess', _21 => _21.nodeType]) === Node.DOCUMENT_FRAGMENT_NODE &&\n n.getRootNode().host)\n shadowHost = n.getRootNode().host;\n return shadowHost;\n}\nfunction getRootShadowHost(n) {\n let rootShadowHost = n;\n let shadowHost;\n while ((shadowHost = getShadowHost(rootShadowHost)))\n rootShadowHost = shadowHost;\n return rootShadowHost;\n}\nfunction shadowHostInDom(n) {\n const doc = n.ownerDocument;\n if (!doc)\n return false;\n const shadowHost = getRootShadowHost(n);\n return doc.contains(shadowHost);\n}\nfunction inDom(n) {\n const doc = n.ownerDocument;\n if (!doc)\n return false;\n return doc.contains(n) || shadowHostInDom(n);\n}\nconst cachedImplementations = {};\nfunction getImplementation(name) {\n const cached = cachedImplementations[name];\n if (cached) {\n return cached;\n }\n const document = window.document;\n let impl = window[name];\n if (document && typeof document.createElement === 'function') {\n try {\n const sandbox = document.createElement('iframe');\n sandbox.hidden = true;\n document.head.appendChild(sandbox);\n const contentWindow = sandbox.contentWindow;\n if (contentWindow && contentWindow[name]) {\n impl =\n contentWindow[name];\n }\n document.head.removeChild(sandbox);\n }\n catch (e) {\n }\n }\n return (cachedImplementations[name] = impl.bind(window));\n}\nfunction onRequestAnimationFrame(...rest) {\n return getImplementation('requestAnimationFrame')(...rest);\n}\nfunction setTimeout$1(...rest) {\n return getImplementation('setTimeout')(...rest);\n}\nfunction clearTimeout$1(...rest) {\n return getImplementation('clearTimeout')(...rest);\n}\n\nvar EventType = /* @__PURE__ */ ((EventType2) => {\n EventType2[EventType2[\"DomContentLoaded\"] = 0] = \"DomContentLoaded\";\n EventType2[EventType2[\"Load\"] = 1] = \"Load\";\n EventType2[EventType2[\"FullSnapshot\"] = 2] = \"FullSnapshot\";\n EventType2[EventType2[\"IncrementalSnapshot\"] = 3] = \"IncrementalSnapshot\";\n EventType2[EventType2[\"Meta\"] = 4] = \"Meta\";\n EventType2[EventType2[\"Custom\"] = 5] = \"Custom\";\n EventType2[EventType2[\"Plugin\"] = 6] = \"Plugin\";\n return EventType2;\n})(EventType || {});\nvar IncrementalSource = /* @__PURE__ */ ((IncrementalSource2) => {\n IncrementalSource2[IncrementalSource2[\"Mutation\"] = 0] = \"Mutation\";\n IncrementalSource2[IncrementalSource2[\"MouseMove\"] = 1] = \"MouseMove\";\n IncrementalSource2[IncrementalSource2[\"MouseInteraction\"] = 2] = \"MouseInteraction\";\n IncrementalSource2[IncrementalSource2[\"Scroll\"] = 3] = \"Scroll\";\n IncrementalSource2[IncrementalSource2[\"ViewportResize\"] = 4] = \"ViewportResize\";\n IncrementalSource2[IncrementalSource2[\"Input\"] = 5] = \"Input\";\n IncrementalSource2[IncrementalSource2[\"TouchMove\"] = 6] = \"TouchMove\";\n IncrementalSource2[IncrementalSource2[\"MediaInteraction\"] = 7] = \"MediaInteraction\";\n IncrementalSource2[IncrementalSource2[\"StyleSheetRule\"] = 8] = \"StyleSheetRule\";\n IncrementalSource2[IncrementalSource2[\"CanvasMutation\"] = 9] = \"CanvasMutation\";\n IncrementalSource2[IncrementalSource2[\"Font\"] = 10] = \"Font\";\n IncrementalSource2[IncrementalSource2[\"Log\"] = 11] = \"Log\";\n IncrementalSource2[IncrementalSource2[\"Drag\"] = 12] = \"Drag\";\n IncrementalSource2[IncrementalSource2[\"StyleDeclaration\"] = 13] = \"StyleDeclaration\";\n IncrementalSource2[IncrementalSource2[\"Selection\"] = 14] = \"Selection\";\n IncrementalSource2[IncrementalSource2[\"AdoptedStyleSheet\"] = 15] = \"AdoptedStyleSheet\";\n IncrementalSource2[IncrementalSource2[\"CustomElement\"] = 16] = \"CustomElement\";\n return IncrementalSource2;\n})(IncrementalSource || {});\nvar MouseInteractions = /* @__PURE__ */ ((MouseInteractions2) => {\n MouseInteractions2[MouseInteractions2[\"MouseUp\"] = 0] = \"MouseUp\";\n MouseInteractions2[MouseInteractions2[\"MouseDown\"] = 1] = \"MouseDown\";\n MouseInteractions2[MouseInteractions2[\"Click\"] = 2] = \"Click\";\n MouseInteractions2[MouseInteractions2[\"ContextMenu\"] = 3] = \"ContextMenu\";\n MouseInteractions2[MouseInteractions2[\"DblClick\"] = 4] = \"DblClick\";\n MouseInteractions2[MouseInteractions2[\"Focus\"] = 5] = \"Focus\";\n MouseInteractions2[MouseInteractions2[\"Blur\"] = 6] = \"Blur\";\n MouseInteractions2[MouseInteractions2[\"TouchStart\"] = 7] = \"TouchStart\";\n MouseInteractions2[MouseInteractions2[\"TouchMove_Departed\"] = 8] = \"TouchMove_Departed\";\n MouseInteractions2[MouseInteractions2[\"TouchEnd\"] = 9] = \"TouchEnd\";\n MouseInteractions2[MouseInteractions2[\"TouchCancel\"] = 10] = \"TouchCancel\";\n return MouseInteractions2;\n})(MouseInteractions || {});\nvar PointerTypes = /* @__PURE__ */ ((PointerTypes2) => {\n PointerTypes2[PointerTypes2[\"Mouse\"] = 0] = \"Mouse\";\n PointerTypes2[PointerTypes2[\"Pen\"] = 1] = \"Pen\";\n PointerTypes2[PointerTypes2[\"Touch\"] = 2] = \"Touch\";\n return PointerTypes2;\n})(PointerTypes || {});\n\nfunction _optionalChain$3(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }\nfunction isNodeInLinkedList(n) {\n return '__ln' in n;\n}\nclass DoubleLinkedList {\n constructor() {\n this.length = 0;\n this.head = null;\n this.tail = null;\n }\n get(position) {\n if (position >= this.length) {\n throw new Error('Position outside of list range');\n }\n let current = this.head;\n for (let index = 0; index < position; index++) {\n current = _optionalChain$3([current, 'optionalAccess', _ => _.next]) || null;\n }\n return current;\n }\n addNode(n) {\n const node = {\n value: n,\n previous: null,\n next: null,\n };\n n.__ln = node;\n if (n.previousSibling && isNodeInLinkedList(n.previousSibling)) {\n const current = n.previousSibling.__ln.next;\n node.next = current;\n node.previous = n.previousSibling.__ln;\n n.previousSibling.__ln.next = node;\n if (current) {\n current.previous = node;\n }\n }\n else if (n.nextSibling &&\n isNodeInLinkedList(n.nextSibling) &&\n n.nextSibling.__ln.previous) {\n const current = n.nextSibling.__ln.previous;\n node.previous = current;\n node.next = n.nextSibling.__ln;\n n.nextSibling.__ln.previous = node;\n if (current) {\n current.next = node;\n }\n }\n else {\n if (this.head) {\n this.head.previous = node;\n }\n node.next = this.head;\n this.head = node;\n }\n if (node.next === null) {\n this.tail = node;\n }\n this.length++;\n }\n removeNode(n) {\n const current = n.__ln;\n if (!this.head) {\n return;\n }\n if (!current.previous) {\n this.head = current.next;\n if (this.head) {\n this.head.previous = null;\n }\n else {\n this.tail = null;\n }\n }\n else {\n current.previous.next = current.next;\n if (current.next) {\n current.next.previous = current.previous;\n }\n else {\n this.tail = current.previous;\n }\n }\n if (n.__ln) {\n delete n.__ln;\n }\n this.length--;\n }\n}\nconst moveKey = (id, parentId) => `${id}@${parentId}`;\nclass MutationBuffer {\n constructor() {\n this.frozen = false;\n this.locked = false;\n this.texts = [];\n this.attributes = [];\n this.attributeMap = new WeakMap();\n this.removes = [];\n this.mapRemoves = [];\n this.movedMap = {};\n this.addedSet = new Set();\n this.movedSet = new Set();\n this.droppedSet = new Set();\n this.processMutations = (mutations) => {\n mutations.forEach(this.processMutation);\n this.emit();\n };\n this.emit = () => {\n if (this.frozen || this.locked) {\n return;\n }\n const adds = [];\n const addedIds = new Set();\n const addList = new DoubleLinkedList();\n const getNextId = (n) => {\n let ns = n;\n let nextId = IGNORED_NODE;\n while (nextId === IGNORED_NODE) {\n ns = ns && ns.nextSibling;\n nextId = ns && this.mirror.getId(ns);\n }\n return nextId;\n };\n const pushAdd = (n) => {\n if (!n.parentNode || !inDom(n)) {\n return;\n }\n const parentId = isShadowRoot(n.parentNode)\n ? this.mirror.getId(getShadowHost(n))\n : this.mirror.getId(n.parentNode);\n const nextId = getNextId(n);\n if (parentId === -1 || nextId === -1) {\n return addList.addNode(n);\n }\n const sn = serializeNodeWithId(n, {\n doc: this.doc,\n mirror: this.mirror,\n blockClass: this.blockClass,\n blockSelector: this.blockSelector,\n maskAllText: this.maskAllText,\n unblockSelector: this.unblockSelector,\n maskTextClass: this.maskTextClass,\n unmaskTextClass: this.unmaskTextClass,\n maskTextSelector: this.maskTextSelector,\n unmaskTextSelector: this.unmaskTextSelector,\n skipChild: true,\n newlyAddedElement: true,\n inlineStylesheet: this.inlineStylesheet,\n maskInputOptions: this.maskInputOptions,\n maskAttributeFn: this.maskAttributeFn,\n maskTextFn: this.maskTextFn,\n maskInputFn: this.maskInputFn,\n slimDOMOptions: this.slimDOMOptions,\n dataURLOptions: this.dataURLOptions,\n recordCanvas: this.recordCanvas,\n inlineImages: this.inlineImages,\n onSerialize: (currentN) => {\n if (isSerializedIframe(currentN, this.mirror)) {\n this.iframeManager.addIframe(currentN);\n }\n if (isSerializedStylesheet(currentN, this.mirror)) {\n this.stylesheetManager.trackLinkElement(currentN);\n }\n if (hasShadowRoot(n)) {\n this.shadowDomManager.addShadowRoot(n.shadowRoot, this.doc);\n }\n },\n onIframeLoad: (iframe, childSn) => {\n this.iframeManager.attachIframe(iframe, childSn);\n this.shadowDomManager.observeAttachShadow(iframe);\n },\n onStylesheetLoad: (link, childSn) => {\n this.stylesheetManager.attachLinkElement(link, childSn);\n },\n });\n if (sn) {\n adds.push({\n parentId,\n nextId,\n node: sn,\n });\n addedIds.add(sn.id);\n }\n };\n while (this.mapRemoves.length) {\n this.mirror.removeNodeFromMap(this.mapRemoves.shift());\n }\n for (const n of this.movedSet) {\n if (isParentRemoved(this.removes, n, this.mirror) &&\n !this.movedSet.has(n.parentNode)) {\n continue;\n }\n pushAdd(n);\n }\n for (const n of this.addedSet) {\n if (!isAncestorInSet(this.droppedSet, n) &&\n !isParentRemoved(this.removes, n, this.mirror)) {\n pushAdd(n);\n }\n else if (isAncestorInSet(this.movedSet, n)) {\n pushAdd(n);\n }\n else {\n this.droppedSet.add(n);\n }\n }\n let candidate = null;\n while (addList.length) {\n let node = null;\n if (candidate) {\n const parentId = this.mirror.getId(candidate.value.parentNode);\n const nextId = getNextId(candidate.value);\n if (parentId !== -1 && nextId !== -1) {\n node = candidate;\n }\n }\n if (!node) {\n let tailNode = addList.tail;\n while (tailNode) {\n const _node = tailNode;\n tailNode = tailNode.previous;\n if (_node) {\n const parentId = this.mirror.getId(_node.value.parentNode);\n const nextId = getNextId(_node.value);\n if (nextId === -1)\n continue;\n else if (parentId !== -1) {\n node = _node;\n break;\n }\n else {\n const unhandledNode = _node.value;\n if (unhandledNode.parentNode &&\n unhandledNode.parentNode.nodeType ===\n Node.DOCUMENT_FRAGMENT_NODE) {\n const shadowHost = unhandledNode.parentNode\n .host;\n const parentId = this.mirror.getId(shadowHost);\n if (parentId !== -1) {\n node = _node;\n break;\n }\n }\n }\n }\n }\n }\n if (!node) {\n while (addList.head) {\n addList.removeNode(addList.head.value);\n }\n break;\n }\n candidate = node.previous;\n addList.removeNode(node.value);\n pushAdd(node.value);\n }\n const payload = {\n texts: this.texts\n .map((text) => ({\n id: this.mirror.getId(text.node),\n value: text.value,\n }))\n .filter((text) => !addedIds.has(text.id))\n .filter((text) => this.mirror.has(text.id)),\n attributes: this.attributes\n .map((attribute) => {\n const { attributes } = attribute;\n if (typeof attributes.style === 'string') {\n const diffAsStr = JSON.stringify(attribute.styleDiff);\n const unchangedAsStr = JSON.stringify(attribute._unchangedStyles);\n if (diffAsStr.length < attributes.style.length) {\n if ((diffAsStr + unchangedAsStr).split('var(').length ===\n attributes.style.split('var(').length) {\n attributes.style = attribute.styleDiff;\n }\n }\n }\n return {\n id: this.mirror.getId(attribute.node),\n attributes: attributes,\n };\n })\n .filter((attribute) => !addedIds.has(attribute.id))\n .filter((attribute) => this.mirror.has(attribute.id)),\n removes: this.removes,\n adds,\n };\n if (!payload.texts.length &&\n !payload.attributes.length &&\n !payload.removes.length &&\n !payload.adds.length) {\n return;\n }\n this.texts = [];\n this.attributes = [];\n this.attributeMap = new WeakMap();\n this.removes = [];\n this.addedSet = new Set();\n this.movedSet = new Set();\n this.droppedSet = new Set();\n this.movedMap = {};\n this.mutationCb(payload);\n };\n this.processMutation = (m) => {\n if (isIgnored(m.target, this.mirror)) {\n return;\n }\n switch (m.type) {\n case 'characterData': {\n const value = m.target.textContent;\n if (!isBlocked(m.target, this.blockClass, this.blockSelector, this.unblockSelector, false) &&\n value !== m.oldValue) {\n this.texts.push({\n value: needMaskingText(m.target, this.maskTextClass, this.maskTextSelector, this.unmaskTextClass, this.unmaskTextSelector, this.maskAllText) && value\n ? this.maskTextFn\n ? this.maskTextFn(value, closestElementOfNode(m.target))\n : value.replace(/[\\S]/g, '*')\n : value,\n node: m.target,\n });\n }\n break;\n }\n case 'attributes': {\n const target = m.target;\n let attributeName = m.attributeName;\n let value = m.target.getAttribute(attributeName);\n if (attributeName === 'value') {\n const type = getInputType(target);\n const tagName = target.tagName;\n value = getInputValue(target, tagName, type);\n const isInputMasked = shouldMaskInput({\n maskInputOptions: this.maskInputOptions,\n tagName,\n type,\n });\n const forceMask = needMaskingText(m.target, this.maskTextClass, this.maskTextSelector, this.unmaskTextClass, this.unmaskTextSelector, isInputMasked);\n value = maskInputValue({\n isMasked: forceMask,\n element: target,\n value,\n maskInputFn: this.maskInputFn,\n });\n }\n if (isBlocked(m.target, this.blockClass, this.blockSelector, this.unblockSelector, false) ||\n value === m.oldValue) {\n return;\n }\n let item = this.attributeMap.get(m.target);\n if (target.tagName === 'IFRAME' &&\n attributeName === 'src' &&\n !this.keepIframeSrcFn(value)) {\n if (!target.contentDocument) {\n attributeName = 'rr_src';\n }\n else {\n return;\n }\n }\n if (!item) {\n item = {\n node: m.target,\n attributes: {},\n styleDiff: {},\n _unchangedStyles: {},\n };\n this.attributes.push(item);\n this.attributeMap.set(m.target, item);\n }\n if (attributeName === 'type' &&\n target.tagName === 'INPUT' &&\n (m.oldValue || '').toLowerCase() === 'password') {\n target.setAttribute('data-rr-is-password', 'true');\n }\n if (!ignoreAttribute(target.tagName, attributeName)) {\n item.attributes[attributeName] = transformAttribute(this.doc, toLowerCase(target.tagName), toLowerCase(attributeName), value, target, this.maskAttributeFn);\n if (attributeName === 'style') {\n if (!this.unattachedDoc) {\n try {\n this.unattachedDoc =\n document.implementation.createHTMLDocument();\n }\n catch (e) {\n this.unattachedDoc = this.doc;\n }\n }\n const old = this.unattachedDoc.createElement('span');\n if (m.oldValue) {\n old.setAttribute('style', m.oldValue);\n }\n for (const pname of Array.from(target.style)) {\n const newValue = target.style.getPropertyValue(pname);\n const newPriority = target.style.getPropertyPriority(pname);\n if (newValue !== old.style.getPropertyValue(pname) ||\n newPriority !== old.style.getPropertyPriority(pname)) {\n if (newPriority === '') {\n item.styleDiff[pname] = newValue;\n }\n else {\n item.styleDiff[pname] = [newValue, newPriority];\n }\n }\n else {\n item._unchangedStyles[pname] = [newValue, newPriority];\n }\n }\n for (const pname of Array.from(old.style)) {\n if (target.style.getPropertyValue(pname) === '') {\n item.styleDiff[pname] = false;\n }\n }\n }\n }\n break;\n }\n case 'childList': {\n if (isBlocked(m.target, this.blockClass, this.blockSelector, this.unblockSelector, true)) {\n return;\n }\n m.addedNodes.forEach((n) => this.genAdds(n, m.target));\n m.removedNodes.forEach((n) => {\n const nodeId = this.mirror.getId(n);\n const parentId = isShadowRoot(m.target)\n ? this.mirror.getId(m.target.host)\n : this.mirror.getId(m.target);\n if (isBlocked(m.target, this.blockClass, this.blockSelector, this.unblockSelector, false) ||\n isIgnored(n, this.mirror) ||\n !isSerialized(n, this.mirror)) {\n return;\n }\n if (this.addedSet.has(n)) {\n deepDelete(this.addedSet, n);\n this.droppedSet.add(n);\n }\n else if (this.addedSet.has(m.target) && nodeId === -1) ;\n else if (isAncestorRemoved(m.target, this.mirror)) ;\n else if (this.movedSet.has(n) &&\n this.movedMap[moveKey(nodeId, parentId)]) {\n deepDelete(this.movedSet, n);\n }\n else {\n this.removes.push({\n parentId,\n id: nodeId,\n isShadow: isShadowRoot(m.target) && isNativeShadowDom(m.target)\n ? true\n : undefined,\n });\n }\n this.mapRemoves.push(n);\n });\n break;\n }\n }\n };\n this.genAdds = (n, target) => {\n if (this.processedNodeManager.inOtherBuffer(n, this))\n return;\n if (this.addedSet.has(n) || this.movedSet.has(n))\n return;\n if (this.mirror.hasNode(n)) {\n if (isIgnored(n, this.mirror)) {\n return;\n }\n this.movedSet.add(n);\n let targetId = null;\n if (target && this.mirror.hasNode(target)) {\n targetId = this.mirror.getId(target);\n }\n if (targetId && targetId !== -1) {\n this.movedMap[moveKey(this.mirror.getId(n), targetId)] = true;\n }\n }\n else {\n this.addedSet.add(n);\n this.droppedSet.delete(n);\n }\n if (!isBlocked(n, this.blockClass, this.blockSelector, this.unblockSelector, false)) {\n n.childNodes.forEach((childN) => this.genAdds(childN));\n if (hasShadowRoot(n)) {\n n.shadowRoot.childNodes.forEach((childN) => {\n this.processedNodeManager.add(childN, this);\n this.genAdds(childN, n);\n });\n }\n }\n };\n }\n init(options) {\n [\n 'mutationCb',\n 'blockClass',\n 'blockSelector',\n 'unblockSelector',\n 'maskAllText',\n 'maskTextClass',\n 'unmaskTextClass',\n 'maskTextSelector',\n 'unmaskTextSelector',\n 'inlineStylesheet',\n 'maskInputOptions',\n 'maskAttributeFn',\n 'maskTextFn',\n 'maskInputFn',\n 'keepIframeSrcFn',\n 'recordCanvas',\n 'inlineImages',\n 'slimDOMOptions',\n 'dataURLOptions',\n 'doc',\n 'mirror',\n 'iframeManager',\n 'stylesheetManager',\n 'shadowDomManager',\n 'canvasManager',\n 'processedNodeManager',\n ].forEach((key) => {\n this[key] = options[key];\n });\n }\n freeze() {\n this.frozen = true;\n this.canvasManager.freeze();\n }\n unfreeze() {\n this.frozen = false;\n this.canvasManager.unfreeze();\n this.emit();\n }\n isFrozen() {\n return this.frozen;\n }\n lock() {\n this.locked = true;\n this.canvasManager.lock();\n }\n unlock() {\n this.locked = false;\n this.canvasManager.unlock();\n this.emit();\n }\n reset() {\n this.shadowDomManager.reset();\n this.canvasManager.reset();\n }\n}\nfunction deepDelete(addsSet, n) {\n addsSet.delete(n);\n n.childNodes.forEach((childN) => deepDelete(addsSet, childN));\n}\nfunction isParentRemoved(removes, n, mirror) {\n if (removes.length === 0)\n return false;\n return _isParentRemoved(removes, n, mirror);\n}\nfunction _isParentRemoved(removes, n, mirror) {\n const { parentNode } = n;\n if (!parentNode) {\n return false;\n }\n const parentId = mirror.getId(parentNode);\n if (removes.some((r) => r.id === parentId)) {\n return true;\n }\n return _isParentRemoved(removes, parentNode, mirror);\n}\nfunction isAncestorInSet(set, n) {\n if (set.size === 0)\n return false;\n return _isAncestorInSet(set, n);\n}\nfunction _isAncestorInSet(set, n) {\n const { parentNode } = n;\n if (!parentNode) {\n return false;\n }\n if (set.has(parentNode)) {\n return true;\n }\n return _isAncestorInSet(set, parentNode);\n}\n\nlet errorHandler;\nfunction registerErrorHandler(handler) {\n errorHandler = handler;\n}\nfunction unregisterErrorHandler() {\n errorHandler = undefined;\n}\nconst callbackWrapper = (cb) => {\n if (!errorHandler) {\n return cb;\n }\n const rrwebWrapped = ((...rest) => {\n try {\n return cb(...rest);\n }\n catch (error) {\n if (errorHandler && errorHandler(error) === true) {\n return () => {\n };\n }\n throw error;\n }\n });\n return rrwebWrapped;\n};\n\nfunction _optionalChain$2(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }\nconst mutationBuffers = [];\nfunction getEventTarget(event) {\n try {\n if ('composedPath' in event) {\n const path = event.composedPath();\n if (path.length) {\n return path[0];\n }\n }\n else if ('path' in event && event.path.length) {\n return event.path[0];\n }\n }\n catch (e2) {\n }\n return event && event.target;\n}\nfunction initMutationObserver(options, rootEl) {\n const mutationBuffer = new MutationBuffer();\n mutationBuffers.push(mutationBuffer);\n mutationBuffer.init(options);\n let mutationObserverCtor = window.MutationObserver ||\n window.__rrMutationObserver;\n const angularZoneSymbol = _optionalChain$2([window, 'optionalAccess', _ => _.Zone, 'optionalAccess', _2 => _2.__symbol__, 'optionalCall', _3 => _3('MutationObserver')]);\n if (angularZoneSymbol &&\n window[angularZoneSymbol]) {\n mutationObserverCtor = window[angularZoneSymbol];\n }\n const observer = new mutationObserverCtor(callbackWrapper((mutations) => {\n if (options.onMutation && options.onMutation(mutations) === false) {\n return;\n }\n mutationBuffer.processMutations.bind(mutationBuffer)(mutations);\n }));\n observer.observe(rootEl, {\n attributes: true,\n attributeOldValue: true,\n characterData: true,\n characterDataOldValue: true,\n childList: true,\n subtree: true,\n });\n return observer;\n}\nfunction initMoveObserver({ mousemoveCb, sampling, doc, mirror, }) {\n if (sampling.mousemove === false) {\n return () => {\n };\n }\n const threshold = typeof sampling.mousemove === 'number' ? sampling.mousemove : 50;\n const callbackThreshold = typeof sampling.mousemoveCallback === 'number'\n ? sampling.mousemoveCallback\n : 500;\n let positions = [];\n let timeBaseline;\n const wrappedCb = throttle$1(callbackWrapper((source) => {\n const totalOffset = Date.now() - timeBaseline;\n mousemoveCb(positions.map((p) => {\n p.timeOffset -= totalOffset;\n return p;\n }), source);\n positions = [];\n timeBaseline = null;\n }), callbackThreshold);\n const updatePosition = callbackWrapper(throttle$1(callbackWrapper((evt) => {\n const target = getEventTarget(evt);\n const { clientX, clientY } = legacy_isTouchEvent(evt)\n ? evt.changedTouches[0]\n : evt;\n if (!timeBaseline) {\n timeBaseline = nowTimestamp();\n }\n positions.push({\n x: clientX,\n y: clientY,\n id: mirror.getId(target),\n timeOffset: nowTimestamp() - timeBaseline,\n });\n wrappedCb(typeof DragEvent !== 'undefined' && evt instanceof DragEvent\n ? IncrementalSource.Drag\n : evt instanceof MouseEvent\n ? IncrementalSource.MouseMove\n : IncrementalSource.TouchMove);\n }), threshold, {\n trailing: false,\n }));\n const handlers = [\n on('mousemove', updatePosition, doc),\n on('touchmove', updatePosition, doc),\n on('drag', updatePosition, doc),\n ];\n return callbackWrapper(() => {\n handlers.forEach((h) => h());\n });\n}\nfunction initMouseInteractionObserver({ mouseInteractionCb, doc, mirror, blockClass, blockSelector, unblockSelector, sampling, }) {\n if (sampling.mouseInteraction === false) {\n return () => {\n };\n }\n const disableMap = sampling.mouseInteraction === true ||\n sampling.mouseInteraction === undefined\n ? {}\n : sampling.mouseInteraction;\n const handlers = [];\n let currentPointerType = null;\n const getHandler = (eventKey) => {\n return (event) => {\n const target = getEventTarget(event);\n if (isBlocked(target, blockClass, blockSelector, unblockSelector, true)) {\n return;\n }\n let pointerType = null;\n let thisEventKey = eventKey;\n if ('pointerType' in event) {\n switch (event.pointerType) {\n case 'mouse':\n pointerType = PointerTypes.Mouse;\n break;\n case 'touch':\n pointerType = PointerTypes.Touch;\n break;\n case 'pen':\n pointerType = PointerTypes.Pen;\n break;\n }\n if (pointerType === PointerTypes.Touch) {\n if (MouseInteractions[eventKey] === MouseInteractions.MouseDown) {\n thisEventKey = 'TouchStart';\n }\n else if (MouseInteractions[eventKey] === MouseInteractions.MouseUp) {\n thisEventKey = 'TouchEnd';\n }\n }\n else if (pointerType === PointerTypes.Pen) ;\n }\n else if (legacy_isTouchEvent(event)) {\n pointerType = PointerTypes.Touch;\n }\n if (pointerType !== null) {\n currentPointerType = pointerType;\n if ((thisEventKey.startsWith('Touch') &&\n pointerType === PointerTypes.Touch) ||\n (thisEventKey.startsWith('Mouse') &&\n pointerType === PointerTypes.Mouse)) {\n pointerType = null;\n }\n }\n else if (MouseInteractions[eventKey] === MouseInteractions.Click) {\n pointerType = currentPointerType;\n currentPointerType = null;\n }\n const e = legacy_isTouchEvent(event) ? event.changedTouches[0] : event;\n if (!e) {\n return;\n }\n const id = mirror.getId(target);\n const { clientX, clientY } = e;\n callbackWrapper(mouseInteractionCb)({\n type: MouseInteractions[thisEventKey],\n id,\n x: clientX,\n y: clientY,\n ...(pointerType !== null && { pointerType }),\n });\n };\n };\n Object.keys(MouseInteractions)\n .filter((key) => Number.isNaN(Number(key)) &&\n !key.endsWith('_Departed') &&\n disableMap[key] !== false)\n .forEach((eventKey) => {\n let eventName = toLowerCase(eventKey);\n const handler = getHandler(eventKey);\n if (window.PointerEvent) {\n switch (MouseInteractions[eventKey]) {\n case MouseInteractions.MouseDown:\n case MouseInteractions.MouseUp:\n eventName = eventName.replace('mouse', 'pointer');\n break;\n case MouseInteractions.TouchStart:\n case MouseInteractions.TouchEnd:\n return;\n }\n }\n handlers.push(on(eventName, handler, doc));\n });\n return callbackWrapper(() => {\n handlers.forEach((h) => h());\n });\n}\nfunction initScrollObserver({ scrollCb, doc, mirror, blockClass, blockSelector, unblockSelector, sampling, }) {\n const updatePosition = callbackWrapper(throttle$1(callbackWrapper((evt) => {\n const target = getEventTarget(evt);\n if (!target ||\n isBlocked(target, blockClass, blockSelector, unblockSelector, true)) {\n return;\n }\n const id = mirror.getId(target);\n if (target === doc && doc.defaultView) {\n const scrollLeftTop = getWindowScroll(doc.defaultView);\n scrollCb({\n id,\n x: scrollLeftTop.left,\n y: scrollLeftTop.top,\n });\n }\n else {\n scrollCb({\n id,\n x: target.scrollLeft,\n y: target.scrollTop,\n });\n }\n }), sampling.scroll || 100));\n return on('scroll', updatePosition, doc);\n}\nfunction initViewportResizeObserver({ viewportResizeCb }, { win }) {\n let lastH = -1;\n let lastW = -1;\n const updateDimension = callbackWrapper(throttle$1(callbackWrapper(() => {\n const height = getWindowHeight();\n const width = getWindowWidth();\n if (lastH !== height || lastW !== width) {\n viewportResizeCb({\n width: Number(width),\n height: Number(height),\n });\n lastH = height;\n lastW = width;\n }\n }), 200));\n return on('resize', updateDimension, win);\n}\nconst INPUT_TAGS = ['INPUT', 'TEXTAREA', 'SELECT'];\nconst lastInputValueMap = new WeakMap();\nfunction initInputObserver({ inputCb, doc, mirror, blockClass, blockSelector, unblockSelector, ignoreClass, ignoreSelector, maskInputOptions, maskInputFn, sampling, userTriggeredOnInput, maskTextClass, unmaskTextClass, maskTextSelector, unmaskTextSelector, }) {\n function eventHandler(event) {\n let target = getEventTarget(event);\n const userTriggered = event.isTrusted;\n const tagName = target && toUpperCase(target.tagName);\n if (tagName === 'OPTION')\n target = target.parentElement;\n if (!target ||\n !tagName ||\n INPUT_TAGS.indexOf(tagName) < 0 ||\n isBlocked(target, blockClass, blockSelector, unblockSelector, true)) {\n return;\n }\n const el = target;\n if (el.classList.contains(ignoreClass) ||\n (ignoreSelector && el.matches(ignoreSelector))) {\n return;\n }\n const type = getInputType(target);\n let text = getInputValue(el, tagName, type);\n let isChecked = false;\n const isInputMasked = shouldMaskInput({\n maskInputOptions,\n tagName,\n type,\n });\n const forceMask = needMaskingText(target, maskTextClass, maskTextSelector, unmaskTextClass, unmaskTextSelector, isInputMasked);\n if (type === 'radio' || type === 'checkbox') {\n isChecked = target.checked;\n }\n text = maskInputValue({\n isMasked: forceMask,\n element: target,\n value: text,\n maskInputFn,\n });\n cbWithDedup(target, userTriggeredOnInput\n ? { text, isChecked, userTriggered }\n : { text, isChecked });\n const name = target.name;\n if (type === 'radio' && name && isChecked) {\n doc\n .querySelectorAll(`input[type=\"radio\"][name=\"${name}\"]`)\n .forEach((el) => {\n if (el !== target) {\n const text = maskInputValue({\n isMasked: forceMask,\n element: el,\n value: getInputValue(el, tagName, type),\n maskInputFn,\n });\n cbWithDedup(el, userTriggeredOnInput\n ? { text, isChecked: !isChecked, userTriggered: false }\n : { text, isChecked: !isChecked });\n }\n });\n }\n }\n function cbWithDedup(target, v) {\n const lastInputValue = lastInputValueMap.get(target);\n if (!lastInputValue ||\n lastInputValue.text !== v.text ||\n lastInputValue.isChecked !== v.isChecked) {\n lastInputValueMap.set(target, v);\n const id = mirror.getId(target);\n callbackWrapper(inputCb)({\n ...v,\n id,\n });\n }\n }\n const events = sampling.input === 'last' ? ['change'] : ['input', 'change'];\n const handlers = events.map((eventName) => on(eventName, callbackWrapper(eventHandler), doc));\n const currentWindow = doc.defaultView;\n if (!currentWindow) {\n return () => {\n handlers.forEach((h) => h());\n };\n }\n const propertyDescriptor = currentWindow.Object.getOwnPropertyDescriptor(currentWindow.HTMLInputElement.prototype, 'value');\n const hookProperties = [\n [currentWindow.HTMLInputElement.prototype, 'value'],\n [currentWindow.HTMLInputElement.prototype, 'checked'],\n [currentWindow.HTMLSelectElement.prototype, 'value'],\n [currentWindow.HTMLTextAreaElement.prototype, 'value'],\n [currentWindow.HTMLSelectElement.prototype, 'selectedIndex'],\n [currentWindow.HTMLOptionElement.prototype, 'selected'],\n ];\n if (propertyDescriptor && propertyDescriptor.set) {\n handlers.push(...hookProperties.map((p) => hookSetter(p[0], p[1], {\n set() {\n callbackWrapper(eventHandler)({\n target: this,\n isTrusted: false,\n });\n },\n }, false, currentWindow)));\n }\n return callbackWrapper(() => {\n handlers.forEach((h) => h());\n });\n}\nfunction getNestedCSSRulePositions(rule) {\n const positions = [];\n function recurse(childRule, pos) {\n if ((hasNestedCSSRule('CSSGroupingRule') &&\n childRule.parentRule instanceof CSSGroupingRule) ||\n (hasNestedCSSRule('CSSMediaRule') &&\n childRule.parentRule instanceof CSSMediaRule) ||\n (hasNestedCSSRule('CSSSupportsRule') &&\n childRule.parentRule instanceof CSSSupportsRule) ||\n (hasNestedCSSRule('CSSConditionRule') &&\n childRule.parentRule instanceof CSSConditionRule)) {\n const rules = Array.from(childRule.parentRule.cssRules);\n const index = rules.indexOf(childRule);\n pos.unshift(index);\n }\n else if (childRule.parentStyleSheet) {\n const rules = Array.from(childRule.parentStyleSheet.cssRules);\n const index = rules.indexOf(childRule);\n pos.unshift(index);\n }\n return pos;\n }\n return recurse(rule, positions);\n}\nfunction getIdAndStyleId(sheet, mirror, styleMirror) {\n let id, styleId;\n if (!sheet)\n return {};\n if (sheet.ownerNode)\n id = mirror.getId(sheet.ownerNode);\n else\n styleId = styleMirror.getId(sheet);\n return {\n styleId,\n id,\n };\n}\nfunction initStyleSheetObserver({ styleSheetRuleCb, mirror, stylesheetManager }, { win }) {\n if (!win.CSSStyleSheet || !win.CSSStyleSheet.prototype) {\n return () => {\n };\n }\n const insertRule = win.CSSStyleSheet.prototype.insertRule;\n win.CSSStyleSheet.prototype.insertRule = new Proxy(insertRule, {\n apply: callbackWrapper((target, thisArg, argumentsList) => {\n const [rule, index] = argumentsList;\n const { id, styleId } = getIdAndStyleId(thisArg, mirror, stylesheetManager.styleMirror);\n if ((id && id !== -1) || (styleId && styleId !== -1)) {\n styleSheetRuleCb({\n id,\n styleId,\n adds: [{ rule, index }],\n });\n }\n return target.apply(thisArg, argumentsList);\n }),\n });\n const deleteRule = win.CSSStyleSheet.prototype.deleteRule;\n win.CSSStyleSheet.prototype.deleteRule = new Proxy(deleteRule, {\n apply: callbackWrapper((target, thisArg, argumentsList) => {\n const [index] = argumentsList;\n const { id, styleId } = getIdAndStyleId(thisArg, mirror, stylesheetManager.styleMirror);\n if ((id && id !== -1) || (styleId && styleId !== -1)) {\n styleSheetRuleCb({\n id,\n styleId,\n removes: [{ index }],\n });\n }\n return target.apply(thisArg, argumentsList);\n }),\n });\n let replace;\n if (win.CSSStyleSheet.prototype.replace) {\n replace = win.CSSStyleSheet.prototype.replace;\n win.CSSStyleSheet.prototype.replace = new Proxy(replace, {\n apply: callbackWrapper((target, thisArg, argumentsList) => {\n const [text] = argumentsList;\n const { id, styleId } = getIdAndStyleId(thisArg, mirror, stylesheetManager.styleMirror);\n if ((id && id !== -1) || (styleId && styleId !== -1)) {\n styleSheetRuleCb({\n id,\n styleId,\n replace: text,\n });\n }\n return target.apply(thisArg, argumentsList);\n }),\n });\n }\n let replaceSync;\n if (win.CSSStyleSheet.prototype.replaceSync) {\n replaceSync = win.CSSStyleSheet.prototype.replaceSync;\n win.CSSStyleSheet.prototype.replaceSync = new Proxy(replaceSync, {\n apply: callbackWrapper((target, thisArg, argumentsList) => {\n const [text] = argumentsList;\n const { id, styleId } = getIdAndStyleId(thisArg, mirror, stylesheetManager.styleMirror);\n if ((id && id !== -1) || (styleId && styleId !== -1)) {\n styleSheetRuleCb({\n id,\n styleId,\n replaceSync: text,\n });\n }\n return target.apply(thisArg, argumentsList);\n }),\n });\n }\n const supportedNestedCSSRuleTypes = {};\n if (canMonkeyPatchNestedCSSRule('CSSGroupingRule')) {\n supportedNestedCSSRuleTypes.CSSGroupingRule = win.CSSGroupingRule;\n }\n else {\n if (canMonkeyPatchNestedCSSRule('CSSMediaRule')) {\n supportedNestedCSSRuleTypes.CSSMediaRule = win.CSSMediaRule;\n }\n if (canMonkeyPatchNestedCSSRule('CSSConditionRule')) {\n supportedNestedCSSRuleTypes.CSSConditionRule = win.CSSConditionRule;\n }\n if (canMonkeyPatchNestedCSSRule('CSSSupportsRule')) {\n supportedNestedCSSRuleTypes.CSSSupportsRule = win.CSSSupportsRule;\n }\n }\n const unmodifiedFunctions = {};\n Object.entries(supportedNestedCSSRuleTypes).forEach(([typeKey, type]) => {\n unmodifiedFunctions[typeKey] = {\n insertRule: type.prototype.insertRule,\n deleteRule: type.prototype.deleteRule,\n };\n type.prototype.insertRule = new Proxy(unmodifiedFunctions[typeKey].insertRule, {\n apply: callbackWrapper((target, thisArg, argumentsList) => {\n const [rule, index] = argumentsList;\n const { id, styleId } = getIdAndStyleId(thisArg.parentStyleSheet, mirror, stylesheetManager.styleMirror);\n if ((id && id !== -1) || (styleId && styleId !== -1)) {\n styleSheetRuleCb({\n id,\n styleId,\n adds: [\n {\n rule,\n index: [\n ...getNestedCSSRulePositions(thisArg),\n index || 0,\n ],\n },\n ],\n });\n }\n return target.apply(thisArg, argumentsList);\n }),\n });\n type.prototype.deleteRule = new Proxy(unmodifiedFunctions[typeKey].deleteRule, {\n apply: callbackWrapper((target, thisArg, argumentsList) => {\n const [index] = argumentsList;\n const { id, styleId } = getIdAndStyleId(thisArg.parentStyleSheet, mirror, stylesheetManager.styleMirror);\n if ((id && id !== -1) || (styleId && styleId !== -1)) {\n styleSheetRuleCb({\n id,\n styleId,\n removes: [\n { index: [...getNestedCSSRulePositions(thisArg), index] },\n ],\n });\n }\n return target.apply(thisArg, argumentsList);\n }),\n });\n });\n return callbackWrapper(() => {\n win.CSSStyleSheet.prototype.insertRule = insertRule;\n win.CSSStyleSheet.prototype.deleteRule = deleteRule;\n replace && (win.CSSStyleSheet.prototype.replace = replace);\n replaceSync && (win.CSSStyleSheet.prototype.replaceSync = replaceSync);\n Object.entries(supportedNestedCSSRuleTypes).forEach(([typeKey, type]) => {\n type.prototype.insertRule = unmodifiedFunctions[typeKey].insertRule;\n type.prototype.deleteRule = unmodifiedFunctions[typeKey].deleteRule;\n });\n });\n}\nfunction initAdoptedStyleSheetObserver({ mirror, stylesheetManager, }, host) {\n let hostId = null;\n if (host.nodeName === '#document')\n hostId = mirror.getId(host);\n else\n hostId = mirror.getId(host.host);\n const patchTarget = host.nodeName === '#document'\n ? _optionalChain$2([host, 'access', _4 => _4.defaultView, 'optionalAccess', _5 => _5.Document])\n : _optionalChain$2([host, 'access', _6 => _6.ownerDocument, 'optionalAccess', _7 => _7.defaultView, 'optionalAccess', _8 => _8.ShadowRoot]);\n const originalPropertyDescriptor = _optionalChain$2([patchTarget, 'optionalAccess', _9 => _9.prototype])\n ? Object.getOwnPropertyDescriptor(_optionalChain$2([patchTarget, 'optionalAccess', _10 => _10.prototype]), 'adoptedStyleSheets')\n : undefined;\n if (hostId === null ||\n hostId === -1 ||\n !patchTarget ||\n !originalPropertyDescriptor)\n return () => {\n };\n Object.defineProperty(host, 'adoptedStyleSheets', {\n configurable: originalPropertyDescriptor.configurable,\n enumerable: originalPropertyDescriptor.enumerable,\n get() {\n return _optionalChain$2([originalPropertyDescriptor, 'access', _11 => _11.get, 'optionalAccess', _12 => _12.call, 'call', _13 => _13(this)]);\n },\n set(sheets) {\n const result = _optionalChain$2([originalPropertyDescriptor, 'access', _14 => _14.set, 'optionalAccess', _15 => _15.call, 'call', _16 => _16(this, sheets)]);\n if (hostId !== null && hostId !== -1) {\n try {\n stylesheetManager.adoptStyleSheets(sheets, hostId);\n }\n catch (e) {\n }\n }\n return result;\n },\n });\n return callbackWrapper(() => {\n Object.defineProperty(host, 'adoptedStyleSheets', {\n configurable: originalPropertyDescriptor.configurable,\n enumerable: originalPropertyDescriptor.enumerable,\n get: originalPropertyDescriptor.get,\n set: originalPropertyDescriptor.set,\n });\n });\n}\nfunction initStyleDeclarationObserver({ styleDeclarationCb, mirror, ignoreCSSAttributes, stylesheetManager, }, { win }) {\n const setProperty = win.CSSStyleDeclaration.prototype.setProperty;\n win.CSSStyleDeclaration.prototype.setProperty = new Proxy(setProperty, {\n apply: callbackWrapper((target, thisArg, argumentsList) => {\n const [property, value, priority] = argumentsList;\n if (ignoreCSSAttributes.has(property)) {\n return setProperty.apply(thisArg, [property, value, priority]);\n }\n const { id, styleId } = getIdAndStyleId(_optionalChain$2([thisArg, 'access', _17 => _17.parentRule, 'optionalAccess', _18 => _18.parentStyleSheet]), mirror, stylesheetManager.styleMirror);\n if ((id && id !== -1) || (styleId && styleId !== -1)) {\n styleDeclarationCb({\n id,\n styleId,\n set: {\n property,\n value,\n priority,\n },\n index: getNestedCSSRulePositions(thisArg.parentRule),\n });\n }\n return target.apply(thisArg, argumentsList);\n }),\n });\n const removeProperty = win.CSSStyleDeclaration.prototype.removeProperty;\n win.CSSStyleDeclaration.prototype.removeProperty = new Proxy(removeProperty, {\n apply: callbackWrapper((target, thisArg, argumentsList) => {\n const [property] = argumentsList;\n if (ignoreCSSAttributes.has(property)) {\n return removeProperty.apply(thisArg, [property]);\n }\n const { id, styleId } = getIdAndStyleId(_optionalChain$2([thisArg, 'access', _19 => _19.parentRule, 'optionalAccess', _20 => _20.parentStyleSheet]), mirror, stylesheetManager.styleMirror);\n if ((id && id !== -1) || (styleId && styleId !== -1)) {\n styleDeclarationCb({\n id,\n styleId,\n remove: {\n property,\n },\n index: getNestedCSSRulePositions(thisArg.parentRule),\n });\n }\n return target.apply(thisArg, argumentsList);\n }),\n });\n return callbackWrapper(() => {\n win.CSSStyleDeclaration.prototype.setProperty = setProperty;\n win.CSSStyleDeclaration.prototype.removeProperty = removeProperty;\n });\n}\nfunction initMediaInteractionObserver({ mediaInteractionCb, blockClass, blockSelector, unblockSelector, mirror, sampling, doc, }) {\n const handler = callbackWrapper((type) => throttle$1(callbackWrapper((event) => {\n const target = getEventTarget(event);\n if (!target ||\n isBlocked(target, blockClass, blockSelector, unblockSelector, true)) {\n return;\n }\n const { currentTime, volume, muted, playbackRate } = target;\n mediaInteractionCb({\n type,\n id: mirror.getId(target),\n currentTime,\n volume,\n muted,\n playbackRate,\n });\n }), sampling.media || 500));\n const handlers = [\n on('play', handler(0), doc),\n on('pause', handler(1), doc),\n on('seeked', handler(2), doc),\n on('volumechange', handler(3), doc),\n on('ratechange', handler(4), doc),\n ];\n return callbackWrapper(() => {\n handlers.forEach((h) => h());\n });\n}\nfunction initFontObserver({ fontCb, doc }) {\n const win = doc.defaultView;\n if (!win) {\n return () => {\n };\n }\n const handlers = [];\n const fontMap = new WeakMap();\n const originalFontFace = win.FontFace;\n win.FontFace = function FontFace(family, source, descriptors) {\n const fontFace = new originalFontFace(family, source, descriptors);\n fontMap.set(fontFace, {\n family,\n buffer: typeof source !== 'string',\n descriptors,\n fontSource: typeof source === 'string'\n ? source\n : JSON.stringify(Array.from(new Uint8Array(source))),\n });\n return fontFace;\n };\n const restoreHandler = patch(doc.fonts, 'add', function (original) {\n return function (fontFace) {\n setTimeout$1(callbackWrapper(() => {\n const p = fontMap.get(fontFace);\n if (p) {\n fontCb(p);\n fontMap.delete(fontFace);\n }\n }), 0);\n return original.apply(this, [fontFace]);\n };\n });\n handlers.push(() => {\n win.FontFace = originalFontFace;\n });\n handlers.push(restoreHandler);\n return callbackWrapper(() => {\n handlers.forEach((h) => h());\n });\n}\nfunction initSelectionObserver(param) {\n const { doc, mirror, blockClass, blockSelector, unblockSelector, selectionCb, } = param;\n let collapsed = true;\n const updateSelection = callbackWrapper(() => {\n const selection = doc.getSelection();\n if (!selection || (collapsed && _optionalChain$2([selection, 'optionalAccess', _21 => _21.isCollapsed])))\n return;\n collapsed = selection.isCollapsed || false;\n const ranges = [];\n const count = selection.rangeCount || 0;\n for (let i = 0; i < count; i++) {\n const range = selection.getRangeAt(i);\n const { startContainer, startOffset, endContainer, endOffset } = range;\n const blocked = isBlocked(startContainer, blockClass, blockSelector, unblockSelector, true) ||\n isBlocked(endContainer, blockClass, blockSelector, unblockSelector, true);\n if (blocked)\n continue;\n ranges.push({\n start: mirror.getId(startContainer),\n startOffset,\n end: mirror.getId(endContainer),\n endOffset,\n });\n }\n selectionCb({ ranges });\n });\n updateSelection();\n return on('selectionchange', updateSelection);\n}\nfunction initCustomElementObserver({ doc, customElementCb, }) {\n const win = doc.defaultView;\n if (!win || !win.customElements)\n return () => { };\n const restoreHandler = patch(win.customElements, 'define', function (original) {\n return function (name, constructor, options) {\n try {\n customElementCb({\n define: {\n name,\n },\n });\n }\n catch (e) {\n }\n return original.apply(this, [name, constructor, options]);\n };\n });\n return restoreHandler;\n}\nfunction initObservers(o, _hooks = {}) {\n const currentWindow = o.doc.defaultView;\n if (!currentWindow) {\n return () => {\n };\n }\n const mutationObserver = initMutationObserver(o, o.doc);\n const mousemoveHandler = initMoveObserver(o);\n const mouseInteractionHandler = initMouseInteractionObserver(o);\n const scrollHandler = initScrollObserver(o);\n const viewportResizeHandler = initViewportResizeObserver(o, {\n win: currentWindow,\n });\n const inputHandler = initInputObserver(o);\n const mediaInteractionHandler = initMediaInteractionObserver(o);\n const styleSheetObserver = initStyleSheetObserver(o, { win: currentWindow });\n const adoptedStyleSheetObserver = initAdoptedStyleSheetObserver(o, o.doc);\n const styleDeclarationObserver = initStyleDeclarationObserver(o, {\n win: currentWindow,\n });\n const fontObserver = o.collectFonts\n ? initFontObserver(o)\n : () => {\n };\n const selectionObserver = initSelectionObserver(o);\n const customElementObserver = initCustomElementObserver(o);\n const pluginHandlers = [];\n for (const plugin of o.plugins) {\n pluginHandlers.push(plugin.observer(plugin.callback, currentWindow, plugin.options));\n }\n return callbackWrapper(() => {\n mutationBuffers.forEach((b) => b.reset());\n mutationObserver.disconnect();\n mousemoveHandler();\n mouseInteractionHandler();\n scrollHandler();\n viewportResizeHandler();\n inputHandler();\n mediaInteractionHandler();\n styleSheetObserver();\n adoptedStyleSheetObserver();\n styleDeclarationObserver();\n fontObserver();\n selectionObserver();\n customElementObserver();\n pluginHandlers.forEach((h) => h());\n });\n}\nfunction hasNestedCSSRule(prop) {\n return typeof window[prop] !== 'undefined';\n}\nfunction canMonkeyPatchNestedCSSRule(prop) {\n return Boolean(typeof window[prop] !== 'undefined' &&\n window[prop].prototype &&\n 'insertRule' in window[prop].prototype &&\n 'deleteRule' in window[prop].prototype);\n}\n\nclass CrossOriginIframeMirror {\n constructor(generateIdFn) {\n this.generateIdFn = generateIdFn;\n this.iframeIdToRemoteIdMap = new WeakMap();\n this.iframeRemoteIdToIdMap = new WeakMap();\n }\n getId(iframe, remoteId, idToRemoteMap, remoteToIdMap) {\n const idToRemoteIdMap = idToRemoteMap || this.getIdToRemoteIdMap(iframe);\n const remoteIdToIdMap = remoteToIdMap || this.getRemoteIdToIdMap(iframe);\n let id = idToRemoteIdMap.get(remoteId);\n if (!id) {\n id = this.generateIdFn();\n idToRemoteIdMap.set(remoteId, id);\n remoteIdToIdMap.set(id, remoteId);\n }\n return id;\n }\n getIds(iframe, remoteId) {\n const idToRemoteIdMap = this.getIdToRemoteIdMap(iframe);\n const remoteIdToIdMap = this.getRemoteIdToIdMap(iframe);\n return remoteId.map((id) => this.getId(iframe, id, idToRemoteIdMap, remoteIdToIdMap));\n }\n getRemoteId(iframe, id, map) {\n const remoteIdToIdMap = map || this.getRemoteIdToIdMap(iframe);\n if (typeof id !== 'number')\n return id;\n const remoteId = remoteIdToIdMap.get(id);\n if (!remoteId)\n return -1;\n return remoteId;\n }\n getRemoteIds(iframe, ids) {\n const remoteIdToIdMap = this.getRemoteIdToIdMap(iframe);\n return ids.map((id) => this.getRemoteId(iframe, id, remoteIdToIdMap));\n }\n reset(iframe) {\n if (!iframe) {\n this.iframeIdToRemoteIdMap = new WeakMap();\n this.iframeRemoteIdToIdMap = new WeakMap();\n return;\n }\n this.iframeIdToRemoteIdMap.delete(iframe);\n this.iframeRemoteIdToIdMap.delete(iframe);\n }\n getIdToRemoteIdMap(iframe) {\n let idToRemoteIdMap = this.iframeIdToRemoteIdMap.get(iframe);\n if (!idToRemoteIdMap) {\n idToRemoteIdMap = new Map();\n this.iframeIdToRemoteIdMap.set(iframe, idToRemoteIdMap);\n }\n return idToRemoteIdMap;\n }\n getRemoteIdToIdMap(iframe) {\n let remoteIdToIdMap = this.iframeRemoteIdToIdMap.get(iframe);\n if (!remoteIdToIdMap) {\n remoteIdToIdMap = new Map();\n this.iframeRemoteIdToIdMap.set(iframe, remoteIdToIdMap);\n }\n return remoteIdToIdMap;\n }\n}\n\nfunction _optionalChain$1(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }\nclass IframeManagerNoop {\n constructor() {\n this.crossOriginIframeMirror = new CrossOriginIframeMirror(genId);\n this.crossOriginIframeRootIdMap = new WeakMap();\n }\n addIframe() {\n }\n addLoadListener() {\n }\n attachIframe() {\n }\n}\nclass IframeManager {\n constructor(options) {\n this.iframes = new WeakMap();\n this.crossOriginIframeMap = new WeakMap();\n this.crossOriginIframeMirror = new CrossOriginIframeMirror(genId);\n this.crossOriginIframeRootIdMap = new WeakMap();\n this.mutationCb = options.mutationCb;\n this.wrappedEmit = options.wrappedEmit;\n this.stylesheetManager = options.stylesheetManager;\n this.recordCrossOriginIframes = options.recordCrossOriginIframes;\n this.crossOriginIframeStyleMirror = new CrossOriginIframeMirror(this.stylesheetManager.styleMirror.generateId.bind(this.stylesheetManager.styleMirror));\n this.mirror = options.mirror;\n if (this.recordCrossOriginIframes) {\n window.addEventListener('message', this.handleMessage.bind(this));\n }\n }\n addIframe(iframeEl) {\n this.iframes.set(iframeEl, true);\n if (iframeEl.contentWindow)\n this.crossOriginIframeMap.set(iframeEl.contentWindow, iframeEl);\n }\n addLoadListener(cb) {\n this.loadListener = cb;\n }\n attachIframe(iframeEl, childSn) {\n this.mutationCb({\n adds: [\n {\n parentId: this.mirror.getId(iframeEl),\n nextId: null,\n node: childSn,\n },\n ],\n removes: [],\n texts: [],\n attributes: [],\n isAttachIframe: true,\n });\n _optionalChain$1([this, 'access', _ => _.loadListener, 'optionalCall', _2 => _2(iframeEl)]);\n if (iframeEl.contentDocument &&\n iframeEl.contentDocument.adoptedStyleSheets &&\n iframeEl.contentDocument.adoptedStyleSheets.length > 0)\n this.stylesheetManager.adoptStyleSheets(iframeEl.contentDocument.adoptedStyleSheets, this.mirror.getId(iframeEl.contentDocument));\n }\n handleMessage(message) {\n const crossOriginMessageEvent = message;\n if (crossOriginMessageEvent.data.type !== 'rrweb' ||\n crossOriginMessageEvent.origin !== crossOriginMessageEvent.data.origin)\n return;\n const iframeSourceWindow = message.source;\n if (!iframeSourceWindow)\n return;\n const iframeEl = this.crossOriginIframeMap.get(message.source);\n if (!iframeEl)\n return;\n const transformedEvent = this.transformCrossOriginEvent(iframeEl, crossOriginMessageEvent.data.event);\n if (transformedEvent)\n this.wrappedEmit(transformedEvent, crossOriginMessageEvent.data.isCheckout);\n }\n transformCrossOriginEvent(iframeEl, e) {\n switch (e.type) {\n case EventType.FullSnapshot: {\n this.crossOriginIframeMirror.reset(iframeEl);\n this.crossOriginIframeStyleMirror.reset(iframeEl);\n this.replaceIdOnNode(e.data.node, iframeEl);\n const rootId = e.data.node.id;\n this.crossOriginIframeRootIdMap.set(iframeEl, rootId);\n this.patchRootIdOnNode(e.data.node, rootId);\n return {\n timestamp: e.timestamp,\n type: EventType.IncrementalSnapshot,\n data: {\n source: IncrementalSource.Mutation,\n adds: [\n {\n parentId: this.mirror.getId(iframeEl),\n nextId: null,\n node: e.data.node,\n },\n ],\n removes: [],\n texts: [],\n attributes: [],\n isAttachIframe: true,\n },\n };\n }\n case EventType.Meta:\n case EventType.Load:\n case EventType.DomContentLoaded: {\n return false;\n }\n case EventType.Plugin: {\n return e;\n }\n case EventType.Custom: {\n this.replaceIds(e.data.payload, iframeEl, ['id', 'parentId', 'previousId', 'nextId']);\n return e;\n }\n case EventType.IncrementalSnapshot: {\n switch (e.data.source) {\n case IncrementalSource.Mutation: {\n e.data.adds.forEach((n) => {\n this.replaceIds(n, iframeEl, [\n 'parentId',\n 'nextId',\n 'previousId',\n ]);\n this.replaceIdOnNode(n.node, iframeEl);\n const rootId = this.crossOriginIframeRootIdMap.get(iframeEl);\n rootId && this.patchRootIdOnNode(n.node, rootId);\n });\n e.data.removes.forEach((n) => {\n this.replaceIds(n, iframeEl, ['parentId', 'id']);\n });\n e.data.attributes.forEach((n) => {\n this.replaceIds(n, iframeEl, ['id']);\n });\n e.data.texts.forEach((n) => {\n this.replaceIds(n, iframeEl, ['id']);\n });\n return e;\n }\n case IncrementalSource.Drag:\n case IncrementalSource.TouchMove:\n case IncrementalSource.MouseMove: {\n e.data.positions.forEach((p) => {\n this.replaceIds(p, iframeEl, ['id']);\n });\n return e;\n }\n case IncrementalSource.ViewportResize: {\n return false;\n }\n case IncrementalSource.MediaInteraction:\n case IncrementalSource.MouseInteraction:\n case IncrementalSource.Scroll:\n case IncrementalSource.CanvasMutation:\n case IncrementalSource.Input: {\n this.replaceIds(e.data, iframeEl, ['id']);\n return e;\n }\n case IncrementalSource.StyleSheetRule:\n case IncrementalSource.StyleDeclaration: {\n this.replaceIds(e.data, iframeEl, ['id']);\n this.replaceStyleIds(e.data, iframeEl, ['styleId']);\n return e;\n }\n case IncrementalSource.Font: {\n return e;\n }\n case IncrementalSource.Selection: {\n e.data.ranges.forEach((range) => {\n this.replaceIds(range, iframeEl, ['start', 'end']);\n });\n return e;\n }\n case IncrementalSource.AdoptedStyleSheet: {\n this.replaceIds(e.data, iframeEl, ['id']);\n this.replaceStyleIds(e.data, iframeEl, ['styleIds']);\n _optionalChain$1([e, 'access', _3 => _3.data, 'access', _4 => _4.styles, 'optionalAccess', _5 => _5.forEach, 'call', _6 => _6((style) => {\n this.replaceStyleIds(style, iframeEl, ['styleId']);\n })]);\n return e;\n }\n }\n }\n }\n return false;\n }\n replace(iframeMirror, obj, iframeEl, keys) {\n for (const key of keys) {\n if (!Array.isArray(obj[key]) && typeof obj[key] !== 'number')\n continue;\n if (Array.isArray(obj[key])) {\n obj[key] = iframeMirror.getIds(iframeEl, obj[key]);\n }\n else {\n obj[key] = iframeMirror.getId(iframeEl, obj[key]);\n }\n }\n return obj;\n }\n replaceIds(obj, iframeEl, keys) {\n return this.replace(this.crossOriginIframeMirror, obj, iframeEl, keys);\n }\n replaceStyleIds(obj, iframeEl, keys) {\n return this.replace(this.crossOriginIframeStyleMirror, obj, iframeEl, keys);\n }\n replaceIdOnNode(node, iframeEl) {\n this.replaceIds(node, iframeEl, ['id', 'rootId']);\n if ('childNodes' in node) {\n node.childNodes.forEach((child) => {\n this.replaceIdOnNode(child, iframeEl);\n });\n }\n }\n patchRootIdOnNode(node, rootId) {\n if (node.type !== NodeType$1.Document && !node.rootId)\n node.rootId = rootId;\n if ('childNodes' in node) {\n node.childNodes.forEach((child) => {\n this.patchRootIdOnNode(child, rootId);\n });\n }\n }\n}\n\nclass ShadowDomManagerNoop {\n init() {\n }\n addShadowRoot() {\n }\n observeAttachShadow() {\n }\n reset() {\n }\n}\nclass ShadowDomManager {\n constructor(options) {\n this.shadowDoms = new WeakSet();\n this.restoreHandlers = [];\n this.mutationCb = options.mutationCb;\n this.scrollCb = options.scrollCb;\n this.bypassOptions = options.bypassOptions;\n this.mirror = options.mirror;\n this.init();\n }\n init() {\n this.reset();\n this.patchAttachShadow(Element, document);\n }\n addShadowRoot(shadowRoot, doc) {\n if (!isNativeShadowDom(shadowRoot))\n return;\n if (this.shadowDoms.has(shadowRoot))\n return;\n this.shadowDoms.add(shadowRoot);\n const observer = initMutationObserver({\n ...this.bypassOptions,\n doc,\n mutationCb: this.mutationCb,\n mirror: this.mirror,\n shadowDomManager: this,\n }, shadowRoot);\n this.restoreHandlers.push(() => observer.disconnect());\n this.restoreHandlers.push(initScrollObserver({\n ...this.bypassOptions,\n scrollCb: this.scrollCb,\n doc: shadowRoot,\n mirror: this.mirror,\n }));\n setTimeout$1(() => {\n if (shadowRoot.adoptedStyleSheets &&\n shadowRoot.adoptedStyleSheets.length > 0)\n this.bypassOptions.stylesheetManager.adoptStyleSheets(shadowRoot.adoptedStyleSheets, this.mirror.getId(shadowRoot.host));\n this.restoreHandlers.push(initAdoptedStyleSheetObserver({\n mirror: this.mirror,\n stylesheetManager: this.bypassOptions.stylesheetManager,\n }, shadowRoot));\n }, 0);\n }\n observeAttachShadow(iframeElement) {\n if (!iframeElement.contentWindow || !iframeElement.contentDocument)\n return;\n this.patchAttachShadow(iframeElement.contentWindow.Element, iframeElement.contentDocument);\n }\n patchAttachShadow(element, doc) {\n const manager = this;\n this.restoreHandlers.push(patch(element.prototype, 'attachShadow', function (original) {\n return function (option) {\n const shadowRoot = original.call(this, option);\n if (this.shadowRoot && inDom(this))\n manager.addShadowRoot(this.shadowRoot, doc);\n return shadowRoot;\n };\n }));\n }\n reset() {\n this.restoreHandlers.forEach((handler) => {\n try {\n handler();\n }\n catch (e) {\n }\n });\n this.restoreHandlers = [];\n this.shadowDoms = new WeakSet();\n }\n}\n\nclass CanvasManagerNoop {\n reset() {\n }\n freeze() {\n }\n unfreeze() {\n }\n lock() {\n }\n unlock() {\n }\n snapshot() {\n }\n}\n\nclass StylesheetManager {\n constructor(options) {\n this.trackedLinkElements = new WeakSet();\n this.styleMirror = new StyleSheetMirror();\n this.mutationCb = options.mutationCb;\n this.adoptedStyleSheetCb = options.adoptedStyleSheetCb;\n }\n attachLinkElement(linkEl, childSn) {\n if ('_cssText' in childSn.attributes)\n this.mutationCb({\n adds: [],\n removes: [],\n texts: [],\n attributes: [\n {\n id: childSn.id,\n attributes: childSn\n .attributes,\n },\n ],\n });\n this.trackLinkElement(linkEl);\n }\n trackLinkElement(linkEl) {\n if (this.trackedLinkElements.has(linkEl))\n return;\n this.trackedLinkElements.add(linkEl);\n this.trackStylesheetInLinkElement(linkEl);\n }\n adoptStyleSheets(sheets, hostId) {\n if (sheets.length === 0)\n return;\n const adoptedStyleSheetData = {\n id: hostId,\n styleIds: [],\n };\n const styles = [];\n for (const sheet of sheets) {\n let styleId;\n if (!this.styleMirror.has(sheet)) {\n styleId = this.styleMirror.add(sheet);\n styles.push({\n styleId,\n rules: Array.from(sheet.rules || CSSRule, (r, index) => ({\n rule: stringifyRule(r),\n index,\n })),\n });\n }\n else\n styleId = this.styleMirror.getId(sheet);\n adoptedStyleSheetData.styleIds.push(styleId);\n }\n if (styles.length > 0)\n adoptedStyleSheetData.styles = styles;\n this.adoptedStyleSheetCb(adoptedStyleSheetData);\n }\n reset() {\n this.styleMirror.reset();\n this.trackedLinkElements = new WeakSet();\n }\n trackStylesheetInLinkElement(linkEl) {\n }\n}\n\nclass ProcessedNodeManager {\n constructor() {\n this.nodeMap = new WeakMap();\n this.loop = true;\n this.periodicallyClear();\n }\n periodicallyClear() {\n onRequestAnimationFrame(() => {\n this.clear();\n if (this.loop)\n this.periodicallyClear();\n });\n }\n inOtherBuffer(node, thisBuffer) {\n const buffers = this.nodeMap.get(node);\n return (buffers && Array.from(buffers).some((buffer) => buffer !== thisBuffer));\n }\n add(node, buffer) {\n this.nodeMap.set(node, (this.nodeMap.get(node) || new Set()).add(buffer));\n }\n clear() {\n this.nodeMap = new WeakMap();\n }\n destroy() {\n this.loop = false;\n }\n}\n\nlet wrappedEmit;\nlet _takeFullSnapshot;\nconst mirror = createMirror();\nfunction record(options = {}) {\n const { emit, checkoutEveryNms, checkoutEveryNth, blockClass = 'rr-block', blockSelector = null, unblockSelector = null, ignoreClass = 'rr-ignore', ignoreSelector = null, maskAllText = false, maskTextClass = 'rr-mask', unmaskTextClass = null, maskTextSelector = null, unmaskTextSelector = null, inlineStylesheet = true, maskAllInputs, maskInputOptions: _maskInputOptions, slimDOMOptions: _slimDOMOptions, maskAttributeFn, maskInputFn, maskTextFn, maxCanvasSize = null, packFn, sampling = {}, dataURLOptions = {}, mousemoveWait, recordCanvas = false, recordCrossOriginIframes = false, recordAfter = options.recordAfter === 'DOMContentLoaded'\n ? options.recordAfter\n : 'load', userTriggeredOnInput = false, collectFonts = false, inlineImages = false, plugins, keepIframeSrcFn = () => false, ignoreCSSAttributes = new Set([]), errorHandler, onMutation, getCanvasManager, } = options;\n registerErrorHandler(errorHandler);\n const inEmittingFrame = recordCrossOriginIframes\n ? window.parent === window\n : true;\n let passEmitsToParent = false;\n if (!inEmittingFrame) {\n try {\n if (window.parent.document) {\n passEmitsToParent = false;\n }\n }\n catch (e) {\n passEmitsToParent = true;\n }\n }\n if (inEmittingFrame && !emit) {\n throw new Error('emit function is required');\n }\n if (mousemoveWait !== undefined && sampling.mousemove === undefined) {\n sampling.mousemove = mousemoveWait;\n }\n mirror.reset();\n const maskInputOptions = maskAllInputs === true\n ? {\n color: true,\n date: true,\n 'datetime-local': true,\n email: true,\n month: true,\n number: true,\n range: true,\n search: true,\n tel: true,\n text: true,\n time: true,\n url: true,\n week: true,\n textarea: true,\n select: true,\n radio: true,\n checkbox: true,\n }\n : _maskInputOptions !== undefined\n ? _maskInputOptions\n : {};\n const slimDOMOptions = _slimDOMOptions === true || _slimDOMOptions === 'all'\n ? {\n script: true,\n comment: true,\n headFavicon: true,\n headWhitespace: true,\n headMetaSocial: true,\n headMetaRobots: true,\n headMetaHttpEquiv: true,\n headMetaVerification: true,\n headMetaAuthorship: _slimDOMOptions === 'all',\n headMetaDescKeywords: _slimDOMOptions === 'all',\n }\n : _slimDOMOptions\n ? _slimDOMOptions\n : {};\n polyfill();\n let lastFullSnapshotEvent;\n let incrementalSnapshotCount = 0;\n const eventProcessor = (e) => {\n for (const plugin of plugins || []) {\n if (plugin.eventProcessor) {\n e = plugin.eventProcessor(e);\n }\n }\n if (packFn &&\n !passEmitsToParent) {\n e = packFn(e);\n }\n return e;\n };\n wrappedEmit = (r, isCheckout) => {\n const e = r;\n e.timestamp = nowTimestamp();\n if (_optionalChain([mutationBuffers, 'access', _ => _[0], 'optionalAccess', _2 => _2.isFrozen, 'call', _3 => _3()]) &&\n e.type !== EventType.FullSnapshot &&\n !(e.type === EventType.IncrementalSnapshot &&\n e.data.source === IncrementalSource.Mutation)) {\n mutationBuffers.forEach((buf) => buf.unfreeze());\n }\n if (inEmittingFrame) {\n _optionalChain([emit, 'optionalCall', _4 => _4(eventProcessor(e), isCheckout)]);\n }\n else if (passEmitsToParent) {\n const message = {\n type: 'rrweb',\n event: eventProcessor(e),\n origin: window.location.origin,\n isCheckout,\n };\n window.parent.postMessage(message, '*');\n }\n if (e.type === EventType.FullSnapshot) {\n lastFullSnapshotEvent = e;\n incrementalSnapshotCount = 0;\n }\n else if (e.type === EventType.IncrementalSnapshot) {\n if (e.data.source === IncrementalSource.Mutation &&\n e.data.isAttachIframe) {\n return;\n }\n incrementalSnapshotCount++;\n const exceedCount = checkoutEveryNth && incrementalSnapshotCount >= checkoutEveryNth;\n const exceedTime = checkoutEveryNms &&\n lastFullSnapshotEvent &&\n e.timestamp - lastFullSnapshotEvent.timestamp > checkoutEveryNms;\n if (exceedCount || exceedTime) {\n takeFullSnapshot(true);\n }\n }\n };\n const wrappedMutationEmit = (m) => {\n wrappedEmit({\n type: EventType.IncrementalSnapshot,\n data: {\n source: IncrementalSource.Mutation,\n ...m,\n },\n });\n };\n const wrappedScrollEmit = (p) => wrappedEmit({\n type: EventType.IncrementalSnapshot,\n data: {\n source: IncrementalSource.Scroll,\n ...p,\n },\n });\n const wrappedCanvasMutationEmit = (p) => wrappedEmit({\n type: EventType.IncrementalSnapshot,\n data: {\n source: IncrementalSource.CanvasMutation,\n ...p,\n },\n });\n const wrappedAdoptedStyleSheetEmit = (a) => wrappedEmit({\n type: EventType.IncrementalSnapshot,\n data: {\n source: IncrementalSource.AdoptedStyleSheet,\n ...a,\n },\n });\n const stylesheetManager = new StylesheetManager({\n mutationCb: wrappedMutationEmit,\n adoptedStyleSheetCb: wrappedAdoptedStyleSheetEmit,\n });\n const iframeManager = typeof __RRWEB_EXCLUDE_IFRAME__ === 'boolean' && __RRWEB_EXCLUDE_IFRAME__\n ? new IframeManagerNoop()\n : new IframeManager({\n mirror,\n mutationCb: wrappedMutationEmit,\n stylesheetManager: stylesheetManager,\n recordCrossOriginIframes,\n wrappedEmit,\n });\n for (const plugin of plugins || []) {\n if (plugin.getMirror)\n plugin.getMirror({\n nodeMirror: mirror,\n crossOriginIframeMirror: iframeManager.crossOriginIframeMirror,\n crossOriginIframeStyleMirror: iframeManager.crossOriginIframeStyleMirror,\n });\n }\n const processedNodeManager = new ProcessedNodeManager();\n const canvasManager = _getCanvasManager(getCanvasManager, {\n mirror,\n win: window,\n mutationCb: (p) => wrappedEmit({\n type: EventType.IncrementalSnapshot,\n data: {\n source: IncrementalSource.CanvasMutation,\n ...p,\n },\n }),\n recordCanvas,\n blockClass,\n blockSelector,\n unblockSelector,\n maxCanvasSize,\n sampling: sampling['canvas'],\n dataURLOptions,\n errorHandler,\n });\n const shadowDomManager = typeof __RRWEB_EXCLUDE_SHADOW_DOM__ === 'boolean' &&\n __RRWEB_EXCLUDE_SHADOW_DOM__\n ? new ShadowDomManagerNoop()\n : new ShadowDomManager({\n mutationCb: wrappedMutationEmit,\n scrollCb: wrappedScrollEmit,\n bypassOptions: {\n onMutation,\n blockClass,\n blockSelector,\n unblockSelector,\n maskAllText,\n maskTextClass,\n unmaskTextClass,\n maskTextSelector,\n unmaskTextSelector,\n inlineStylesheet,\n maskInputOptions,\n dataURLOptions,\n maskAttributeFn,\n maskTextFn,\n maskInputFn,\n recordCanvas,\n inlineImages,\n sampling,\n slimDOMOptions,\n iframeManager,\n stylesheetManager,\n canvasManager,\n keepIframeSrcFn,\n processedNodeManager,\n },\n mirror,\n });\n const takeFullSnapshot = (isCheckout = false) => {\n wrappedEmit({\n type: EventType.Meta,\n data: {\n href: window.location.href,\n width: getWindowWidth(),\n height: getWindowHeight(),\n },\n }, isCheckout);\n stylesheetManager.reset();\n shadowDomManager.init();\n mutationBuffers.forEach((buf) => buf.lock());\n const node = snapshot(document, {\n mirror,\n blockClass,\n blockSelector,\n unblockSelector,\n maskAllText,\n maskTextClass,\n unmaskTextClass,\n maskTextSelector,\n unmaskTextSelector,\n inlineStylesheet,\n maskAllInputs: maskInputOptions,\n maskAttributeFn,\n maskInputFn,\n maskTextFn,\n slimDOM: slimDOMOptions,\n dataURLOptions,\n recordCanvas,\n inlineImages,\n onSerialize: (n) => {\n if (isSerializedIframe(n, mirror)) {\n iframeManager.addIframe(n);\n }\n if (isSerializedStylesheet(n, mirror)) {\n stylesheetManager.trackLinkElement(n);\n }\n if (hasShadowRoot(n)) {\n shadowDomManager.addShadowRoot(n.shadowRoot, document);\n }\n },\n onIframeLoad: (iframe, childSn) => {\n iframeManager.attachIframe(iframe, childSn);\n shadowDomManager.observeAttachShadow(iframe);\n },\n onStylesheetLoad: (linkEl, childSn) => {\n stylesheetManager.attachLinkElement(linkEl, childSn);\n },\n keepIframeSrcFn,\n });\n if (!node) {\n return console.warn('Failed to snapshot the document');\n }\n wrappedEmit({\n type: EventType.FullSnapshot,\n data: {\n node,\n initialOffset: getWindowScroll(window),\n },\n });\n mutationBuffers.forEach((buf) => buf.unlock());\n if (document.adoptedStyleSheets && document.adoptedStyleSheets.length > 0)\n stylesheetManager.adoptStyleSheets(document.adoptedStyleSheets, mirror.getId(document));\n };\n _takeFullSnapshot = takeFullSnapshot;\n try {\n const handlers = [];\n const observe = (doc) => {\n return callbackWrapper(initObservers)({\n onMutation,\n mutationCb: wrappedMutationEmit,\n mousemoveCb: (positions, source) => wrappedEmit({\n type: EventType.IncrementalSnapshot,\n data: {\n source,\n positions,\n },\n }),\n mouseInteractionCb: (d) => wrappedEmit({\n type: EventType.IncrementalSnapshot,\n data: {\n source: IncrementalSource.MouseInteraction,\n ...d,\n },\n }),\n scrollCb: wrappedScrollEmit,\n viewportResizeCb: (d) => wrappedEmit({\n type: EventType.IncrementalSnapshot,\n data: {\n source: IncrementalSource.ViewportResize,\n ...d,\n },\n }),\n inputCb: (v) => wrappedEmit({\n type: EventType.IncrementalSnapshot,\n data: {\n source: IncrementalSource.Input,\n ...v,\n },\n }),\n mediaInteractionCb: (p) => wrappedEmit({\n type: EventType.IncrementalSnapshot,\n data: {\n source: IncrementalSource.MediaInteraction,\n ...p,\n },\n }),\n styleSheetRuleCb: (r) => wrappedEmit({\n type: EventType.IncrementalSnapshot,\n data: {\n source: IncrementalSource.StyleSheetRule,\n ...r,\n },\n }),\n styleDeclarationCb: (r) => wrappedEmit({\n type: EventType.IncrementalSnapshot,\n data: {\n source: IncrementalSource.StyleDeclaration,\n ...r,\n },\n }),\n canvasMutationCb: wrappedCanvasMutationEmit,\n fontCb: (p) => wrappedEmit({\n type: EventType.IncrementalSnapshot,\n data: {\n source: IncrementalSource.Font,\n ...p,\n },\n }),\n selectionCb: (p) => {\n wrappedEmit({\n type: EventType.IncrementalSnapshot,\n data: {\n source: IncrementalSource.Selection,\n ...p,\n },\n });\n },\n customElementCb: (c) => {\n wrappedEmit({\n type: EventType.IncrementalSnapshot,\n data: {\n source: IncrementalSource.CustomElement,\n ...c,\n },\n });\n },\n blockClass,\n ignoreClass,\n ignoreSelector,\n maskAllText,\n maskTextClass,\n unmaskTextClass,\n maskTextSelector,\n unmaskTextSelector,\n maskInputOptions,\n inlineStylesheet,\n sampling,\n recordCanvas,\n inlineImages,\n userTriggeredOnInput,\n collectFonts,\n doc,\n maskAttributeFn,\n maskInputFn,\n maskTextFn,\n keepIframeSrcFn,\n blockSelector,\n unblockSelector,\n slimDOMOptions,\n dataURLOptions,\n mirror,\n iframeManager,\n stylesheetManager,\n shadowDomManager,\n processedNodeManager,\n canvasManager,\n ignoreCSSAttributes,\n plugins: _optionalChain([plugins\n, 'optionalAccess', _5 => _5.filter, 'call', _6 => _6((p) => p.observer)\n, 'optionalAccess', _7 => _7.map, 'call', _8 => _8((p) => ({\n observer: p.observer,\n options: p.options,\n callback: (payload) => wrappedEmit({\n type: EventType.Plugin,\n data: {\n plugin: p.name,\n payload,\n },\n }),\n }))]) || [],\n }, {});\n };\n iframeManager.addLoadListener((iframeEl) => {\n try {\n handlers.push(observe(iframeEl.contentDocument));\n }\n catch (error) {\n console.warn(error);\n }\n });\n const init = () => {\n takeFullSnapshot();\n handlers.push(observe(document));\n };\n if (document.readyState === 'interactive' ||\n document.readyState === 'complete') {\n init();\n }\n else {\n handlers.push(on('DOMContentLoaded', () => {\n wrappedEmit({\n type: EventType.DomContentLoaded,\n data: {},\n });\n if (recordAfter === 'DOMContentLoaded')\n init();\n }));\n handlers.push(on('load', () => {\n wrappedEmit({\n type: EventType.Load,\n data: {},\n });\n if (recordAfter === 'load')\n init();\n }, window));\n }\n return () => {\n handlers.forEach((h) => h());\n processedNodeManager.destroy();\n _takeFullSnapshot = undefined;\n unregisterErrorHandler();\n };\n }\n catch (error) {\n console.warn(error);\n }\n}\nfunction takeFullSnapshot(isCheckout) {\n if (!_takeFullSnapshot) {\n throw new Error('please take full snapshot after start recording');\n }\n _takeFullSnapshot(isCheckout);\n}\nrecord.mirror = mirror;\nrecord.takeFullSnapshot = takeFullSnapshot;\nfunction _getCanvasManager(getCanvasManagerFn, options) {\n try {\n return getCanvasManagerFn\n ? getCanvasManagerFn(options)\n : new CanvasManagerNoop();\n }\n catch (e2) {\n console.warn('Unable to initialize CanvasManager');\n return new CanvasManagerNoop();\n }\n}\n\nconst ReplayEventTypeIncrementalSnapshot = 3;\nconst ReplayEventTypeCustom = 5;\n\n/**\n * Converts a timestamp to ms, if it was in s, or keeps it as ms.\n */\nfunction timestampToMs(timestamp) {\n const isMs = timestamp > 9999999999;\n return isMs ? timestamp : timestamp * 1000;\n}\n\n/**\n * Converts a timestamp to s, if it was in ms, or keeps it as s.\n */\nfunction timestampToS(timestamp) {\n const isMs = timestamp > 9999999999;\n return isMs ? timestamp / 1000 : timestamp;\n}\n\n/**\n * Add a breadcrumb event to replay.\n */\nfunction addBreadcrumbEvent(replay, breadcrumb) {\n if (breadcrumb.category === 'sentry.transaction') {\n return;\n }\n\n if (['ui.click', 'ui.input'].includes(breadcrumb.category )) {\n replay.triggerUserActivity();\n } else {\n replay.checkAndHandleExpiredSession();\n }\n\n replay.addUpdate(() => {\n // This should never reject\n // eslint-disable-next-line @typescript-eslint/no-floating-promises\n replay.throttledAddEvent({\n type: EventType.Custom,\n // TODO: We were converting from ms to seconds for breadcrumbs, spans,\n // but maybe we should just keep them as milliseconds\n timestamp: (breadcrumb.timestamp || 0) * 1000,\n data: {\n tag: 'breadcrumb',\n // normalize to max. 10 depth and 1_000 properties per object\n payload: normalize(breadcrumb, 10, 1000),\n },\n });\n\n // Do not flush after console log messages\n return breadcrumb.category === 'console';\n });\n}\n\nconst INTERACTIVE_SELECTOR = 'button,a';\n\n/** Get the closest interactive parent element, or else return the given element. */\nfunction getClosestInteractive(element) {\n const closestInteractive = element.closest(INTERACTIVE_SELECTOR);\n return closestInteractive || element;\n}\n\n/**\n * For clicks, we check if the target is inside of a button or link\n * If so, we use this as the target instead\n * This is useful because if you click on the image in ,\n * The target will be the image, not the button, which we don't want here\n */\nfunction getClickTargetNode(event) {\n const target = getTargetNode(event);\n\n if (!target || !(target instanceof Element)) {\n return target;\n }\n\n return getClosestInteractive(target);\n}\n\n/** Get the event target node. */\nfunction getTargetNode(event) {\n if (isEventWithTarget(event)) {\n return event.target ;\n }\n\n return event;\n}\n\nfunction isEventWithTarget(event) {\n return typeof event === 'object' && !!event && 'target' in event;\n}\n\nlet handlers;\n\n/**\n * Register a handler to be called when `window.open()` is called.\n * Returns a cleanup function.\n */\nfunction onWindowOpen(cb) {\n // Ensure to only register this once\n if (!handlers) {\n handlers = [];\n monkeyPatchWindowOpen();\n }\n\n handlers.push(cb);\n\n return () => {\n const pos = handlers ? handlers.indexOf(cb) : -1;\n if (pos > -1) {\n (handlers ).splice(pos, 1);\n }\n };\n}\n\nfunction monkeyPatchWindowOpen() {\n fill(WINDOW, 'open', function (originalWindowOpen) {\n return function (...args) {\n if (handlers) {\n try {\n handlers.forEach(handler => handler());\n } catch (e) {\n // ignore errors in here\n }\n }\n\n return originalWindowOpen.apply(WINDOW, args);\n };\n });\n}\n\n/** Handle a click. */\nfunction handleClick(clickDetector, clickBreadcrumb, node) {\n clickDetector.handleClick(clickBreadcrumb, node);\n}\n\n/** A click detector class that can be used to detect slow or rage clicks on elements. */\nclass ClickDetector {\n // protected for testing\n\n constructor(\n replay,\n slowClickConfig,\n // Just for easier testing\n _addBreadcrumbEvent = addBreadcrumbEvent,\n ) {\n this._lastMutation = 0;\n this._lastScroll = 0;\n this._clicks = [];\n\n // We want everything in s, but options are in ms\n this._timeout = slowClickConfig.timeout / 1000;\n this._threshold = slowClickConfig.threshold / 1000;\n this._scollTimeout = slowClickConfig.scrollTimeout / 1000;\n this._replay = replay;\n this._ignoreSelector = slowClickConfig.ignoreSelector;\n this._addBreadcrumbEvent = _addBreadcrumbEvent;\n }\n\n /** Register click detection handlers on mutation or scroll. */\n addListeners() {\n const cleanupWindowOpen = onWindowOpen(() => {\n // Treat window.open as mutation\n this._lastMutation = nowInSeconds();\n });\n\n this._teardown = () => {\n cleanupWindowOpen();\n\n this._clicks = [];\n this._lastMutation = 0;\n this._lastScroll = 0;\n };\n }\n\n /** Clean up listeners. */\n removeListeners() {\n if (this._teardown) {\n this._teardown();\n }\n\n if (this._checkClickTimeout) {\n clearTimeout(this._checkClickTimeout);\n }\n }\n\n /** @inheritDoc */\n handleClick(breadcrumb, node) {\n if (ignoreElement(node, this._ignoreSelector) || !isClickBreadcrumb(breadcrumb)) {\n return;\n }\n\n const newClick = {\n timestamp: timestampToS(breadcrumb.timestamp),\n clickBreadcrumb: breadcrumb,\n // Set this to 0 so we know it originates from the click breadcrumb\n clickCount: 0,\n node,\n };\n\n // If there was a click in the last 1s on the same element, ignore it - only keep a single reference per second\n if (\n this._clicks.some(click => click.node === newClick.node && Math.abs(click.timestamp - newClick.timestamp) < 1)\n ) {\n return;\n }\n\n this._clicks.push(newClick);\n\n // If this is the first new click, set a timeout to check for multi clicks\n if (this._clicks.length === 1) {\n this._scheduleCheckClicks();\n }\n }\n\n /** @inheritDoc */\n registerMutation(timestamp = Date.now()) {\n this._lastMutation = timestampToS(timestamp);\n }\n\n /** @inheritDoc */\n registerScroll(timestamp = Date.now()) {\n this._lastScroll = timestampToS(timestamp);\n }\n\n /** @inheritDoc */\n registerClick(element) {\n const node = getClosestInteractive(element);\n this._handleMultiClick(node );\n }\n\n /** Count multiple clicks on elements. */\n _handleMultiClick(node) {\n this._getClicks(node).forEach(click => {\n click.clickCount++;\n });\n }\n\n /** Get all pending clicks for a given node. */\n _getClicks(node) {\n return this._clicks.filter(click => click.node === node);\n }\n\n /** Check the clicks that happened. */\n _checkClicks() {\n const timedOutClicks = [];\n\n const now = nowInSeconds();\n\n this._clicks.forEach(click => {\n if (!click.mutationAfter && this._lastMutation) {\n click.mutationAfter = click.timestamp <= this._lastMutation ? this._lastMutation - click.timestamp : undefined;\n }\n if (!click.scrollAfter && this._lastScroll) {\n click.scrollAfter = click.timestamp <= this._lastScroll ? this._lastScroll - click.timestamp : undefined;\n }\n\n // All of these are in seconds!\n if (click.timestamp + this._timeout <= now) {\n timedOutClicks.push(click);\n }\n });\n\n // Remove \"old\" clicks\n for (const click of timedOutClicks) {\n const pos = this._clicks.indexOf(click);\n\n if (pos > -1) {\n this._generateBreadcrumbs(click);\n this._clicks.splice(pos, 1);\n }\n }\n\n // Trigger new check, unless no clicks left\n if (this._clicks.length) {\n this._scheduleCheckClicks();\n }\n }\n\n /** Generate matching breadcrumb(s) for the click. */\n _generateBreadcrumbs(click) {\n const replay = this._replay;\n const hadScroll = click.scrollAfter && click.scrollAfter <= this._scollTimeout;\n const hadMutation = click.mutationAfter && click.mutationAfter <= this._threshold;\n\n const isSlowClick = !hadScroll && !hadMutation;\n const { clickCount, clickBreadcrumb } = click;\n\n // Slow click\n if (isSlowClick) {\n // If `mutationAfter` is set, it means a mutation happened after the threshold, but before the timeout\n // If not, it means we just timed out without scroll & mutation\n const timeAfterClickMs = Math.min(click.mutationAfter || this._timeout, this._timeout) * 1000;\n const endReason = timeAfterClickMs < this._timeout * 1000 ? 'mutation' : 'timeout';\n\n const breadcrumb = {\n type: 'default',\n message: clickBreadcrumb.message,\n timestamp: clickBreadcrumb.timestamp,\n category: 'ui.slowClickDetected',\n data: {\n ...clickBreadcrumb.data,\n url: WINDOW.location.href,\n route: replay.getCurrentRoute(),\n timeAfterClickMs,\n endReason,\n // If clickCount === 0, it means multiClick was not correctly captured here\n // - we still want to send 1 in this case\n clickCount: clickCount || 1,\n },\n };\n\n this._addBreadcrumbEvent(replay, breadcrumb);\n return;\n }\n\n // Multi click\n if (clickCount > 1) {\n const breadcrumb = {\n type: 'default',\n message: clickBreadcrumb.message,\n timestamp: clickBreadcrumb.timestamp,\n category: 'ui.multiClick',\n data: {\n ...clickBreadcrumb.data,\n url: WINDOW.location.href,\n route: replay.getCurrentRoute(),\n clickCount,\n metric: true,\n },\n };\n\n this._addBreadcrumbEvent(replay, breadcrumb);\n }\n }\n\n /** Schedule to check current clicks. */\n _scheduleCheckClicks() {\n if (this._checkClickTimeout) {\n clearTimeout(this._checkClickTimeout);\n }\n\n this._checkClickTimeout = setTimeout(() => this._checkClicks(), 1000);\n }\n}\n\nconst SLOW_CLICK_TAGS = ['A', 'BUTTON', 'INPUT'];\n\n/** exported for tests only */\nfunction ignoreElement(node, ignoreSelector) {\n if (!SLOW_CLICK_TAGS.includes(node.tagName)) {\n return true;\n }\n\n // If tag, we only want to consider input[type='submit'] & input[type='button']\n if (node.tagName === 'INPUT' && !['submit', 'button'].includes(node.getAttribute('type') || '')) {\n return true;\n }\n\n // If tag, detect special variants that may not lead to an action\n // If target !== _self, we may open the link somewhere else, which would lead to no action\n // Also, when downloading a file, we may not leave the page, but still not trigger an action\n if (\n node.tagName === 'A' &&\n (node.hasAttribute('download') || (node.hasAttribute('target') && node.getAttribute('target') !== '_self'))\n ) {\n return true;\n }\n\n if (ignoreSelector && node.matches(ignoreSelector)) {\n return true;\n }\n\n return false;\n}\n\nfunction isClickBreadcrumb(breadcrumb) {\n return !!(breadcrumb.data && typeof breadcrumb.data.nodeId === 'number' && breadcrumb.timestamp);\n}\n\n// This is good enough for us, and is easier to test/mock than `timestampInSeconds`\nfunction nowInSeconds() {\n return Date.now() / 1000;\n}\n\n/** Update the click detector based on a recording event of rrweb. */\nfunction updateClickDetectorForRecordingEvent(clickDetector, event) {\n try {\n // note: We only consider incremental snapshots here\n // This means that any full snapshot is ignored for mutation detection - the reason is that we simply cannot know if a mutation happened here.\n // E.g. think that we are buffering, an error happens and we take a full snapshot because we switched to session mode -\n // in this scenario, we would not know if a dead click happened because of the error, which is a key dead click scenario.\n // Instead, by ignoring full snapshots, we have the risk that we generate a false positive\n // (if a mutation _did_ happen but was \"swallowed\" by the full snapshot)\n // But this should be more unlikely as we'd generally capture the incremental snapshot right away\n\n if (!isIncrementalEvent(event)) {\n return;\n }\n\n const { source } = event.data;\n if (source === IncrementalSource.Mutation) {\n clickDetector.registerMutation(event.timestamp);\n }\n\n if (source === IncrementalSource.Scroll) {\n clickDetector.registerScroll(event.timestamp);\n }\n\n if (isIncrementalMouseInteraction(event)) {\n const { type, id } = event.data;\n const node = record.mirror.getNode(id);\n\n if (node instanceof HTMLElement && type === MouseInteractions.Click) {\n clickDetector.registerClick(node);\n }\n }\n } catch (e) {\n // ignore errors here, e.g. if accessing something that does not exist\n }\n}\n\nfunction isIncrementalEvent(event) {\n return event.type === ReplayEventTypeIncrementalSnapshot;\n}\n\nfunction isIncrementalMouseInteraction(\n event,\n) {\n return event.data.source === IncrementalSource.MouseInteraction;\n}\n\n/**\n * Create a breadcrumb for a replay.\n */\nfunction createBreadcrumb(\n breadcrumb,\n) {\n return {\n timestamp: Date.now() / 1000,\n type: 'default',\n ...breadcrumb,\n };\n}\n\nvar NodeType;\n(function (NodeType) {\n NodeType[NodeType[\"Document\"] = 0] = \"Document\";\n NodeType[NodeType[\"DocumentType\"] = 1] = \"DocumentType\";\n NodeType[NodeType[\"Element\"] = 2] = \"Element\";\n NodeType[NodeType[\"Text\"] = 3] = \"Text\";\n NodeType[NodeType[\"CDATA\"] = 4] = \"CDATA\";\n NodeType[NodeType[\"Comment\"] = 5] = \"Comment\";\n})(NodeType || (NodeType = {}));\n\n// Note that these are the serialized attributes and not attributes directly on\n// the DOM Node. Attributes we are interested in:\nconst ATTRIBUTES_TO_RECORD = new Set([\n 'id',\n 'class',\n 'aria-label',\n 'role',\n 'name',\n 'alt',\n 'title',\n 'data-test-id',\n 'data-testid',\n 'disabled',\n 'aria-disabled',\n 'data-sentry-component',\n]);\n\n/**\n * Inclusion list of attributes that we want to record from the DOM element\n */\nfunction getAttributesToRecord(attributes) {\n const obj = {};\n for (const key in attributes) {\n if (ATTRIBUTES_TO_RECORD.has(key)) {\n let normalizedKey = key;\n\n if (key === 'data-testid' || key === 'data-test-id') {\n normalizedKey = 'testId';\n }\n\n obj[normalizedKey] = attributes[key];\n }\n }\n\n return obj;\n}\n\nconst handleDomListener = (\n replay,\n) => {\n return (handlerData) => {\n if (!replay.isEnabled()) {\n return;\n }\n\n const result = handleDom(handlerData);\n\n if (!result) {\n return;\n }\n\n const isClick = handlerData.name === 'click';\n const event = isClick ? (handlerData.event ) : undefined;\n // Ignore clicks if ctrl/alt/meta/shift keys are held down as they alter behavior of clicks (e.g. open in new tab)\n if (\n isClick &&\n replay.clickDetector &&\n event &&\n event.target &&\n !event.altKey &&\n !event.metaKey &&\n !event.ctrlKey &&\n !event.shiftKey\n ) {\n handleClick(\n replay.clickDetector,\n result ,\n getClickTargetNode(handlerData.event ) ,\n );\n }\n\n addBreadcrumbEvent(replay, result);\n };\n};\n\n/** Get the base DOM breadcrumb. */\nfunction getBaseDomBreadcrumb(target, message) {\n const nodeId = record.mirror.getId(target);\n const node = nodeId && record.mirror.getNode(nodeId);\n const meta = node && record.mirror.getMeta(node);\n const element = meta && isElement(meta) ? meta : null;\n\n return {\n message,\n data: element\n ? {\n nodeId,\n node: {\n id: nodeId,\n tagName: element.tagName,\n textContent: Array.from(element.childNodes)\n .map((node) => node.type === NodeType.Text && node.textContent)\n .filter(Boolean) // filter out empty values\n .map(text => (text ).trim())\n .join(''),\n attributes: getAttributesToRecord(element.attributes),\n },\n }\n : {},\n };\n}\n\n/**\n * An event handler to react to DOM events.\n * Exported for tests.\n */\nfunction handleDom(handlerData) {\n const { target, message } = getDomTarget(handlerData);\n\n return createBreadcrumb({\n category: `ui.${handlerData.name}`,\n ...getBaseDomBreadcrumb(target, message),\n });\n}\n\nfunction getDomTarget(handlerData) {\n const isClick = handlerData.name === 'click';\n\n let message;\n let target = null;\n\n // Accessing event.target can throw (see getsentry/raven-js#838, #768)\n try {\n target = isClick ? getClickTargetNode(handlerData.event ) : getTargetNode(handlerData.event );\n message = htmlTreeAsString(target, { maxStringLength: 200 }) || '';\n } catch (e) {\n message = '';\n }\n\n return { target, message };\n}\n\nfunction isElement(node) {\n return node.type === NodeType.Element;\n}\n\n/** Handle keyboard events & create breadcrumbs. */\nfunction handleKeyboardEvent(replay, event) {\n if (!replay.isEnabled()) {\n return;\n }\n\n // Update user activity, but do not restart recording as it can create\n // noisy/low-value replays (e.g. user comes back from idle, hits alt-tab, new\n // session with a single \"keydown\" breadcrumb is created)\n replay.updateUserActivity();\n\n const breadcrumb = getKeyboardBreadcrumb(event);\n\n if (!breadcrumb) {\n return;\n }\n\n addBreadcrumbEvent(replay, breadcrumb);\n}\n\n/** exported only for tests */\nfunction getKeyboardBreadcrumb(event) {\n const { metaKey, shiftKey, ctrlKey, altKey, key, target } = event;\n\n // never capture for input fields\n if (!target || isInputElement(target ) || !key) {\n return null;\n }\n\n // Note: We do not consider shift here, as that means \"uppercase\"\n const hasModifierKey = metaKey || ctrlKey || altKey;\n const isCharacterKey = key.length === 1; // other keys like Escape, Tab, etc have a longer length\n\n // Do not capture breadcrumb if only a word key is pressed\n // This could leak e.g. user input\n if (!hasModifierKey && isCharacterKey) {\n return null;\n }\n\n const message = htmlTreeAsString(target, { maxStringLength: 200 }) || '';\n const baseBreadcrumb = getBaseDomBreadcrumb(target , message);\n\n return createBreadcrumb({\n category: 'ui.keyDown',\n message,\n data: {\n ...baseBreadcrumb.data,\n metaKey,\n shiftKey,\n ctrlKey,\n altKey,\n key,\n },\n });\n}\n\nfunction isInputElement(target) {\n return target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable;\n}\n\n// Map entryType -> function to normalize data for event\nconst ENTRY_TYPES\n\n = {\n // @ts-expect-error TODO: entry type does not fit the create* functions entry type\n resource: createResourceEntry,\n paint: createPaintEntry,\n // @ts-expect-error TODO: entry type does not fit the create* functions entry type\n navigation: createNavigationEntry,\n};\n\n/**\n * Create replay performance entries from the browser performance entries.\n */\nfunction createPerformanceEntries(\n entries,\n) {\n return entries.map(createPerformanceEntry).filter(Boolean) ;\n}\n\nfunction createPerformanceEntry(entry) {\n if (!ENTRY_TYPES[entry.entryType]) {\n return null;\n }\n\n return ENTRY_TYPES[entry.entryType](entry);\n}\n\nfunction getAbsoluteTime(time) {\n // browserPerformanceTimeOrigin can be undefined if `performance` or\n // `performance.now` doesn't exist, but this is already checked by this integration\n return ((browserPerformanceTimeOrigin || WINDOW.performance.timeOrigin) + time) / 1000;\n}\n\nfunction createPaintEntry(entry) {\n const { duration, entryType, name, startTime } = entry;\n\n const start = getAbsoluteTime(startTime);\n return {\n type: entryType,\n name,\n start,\n end: start + duration,\n data: undefined,\n };\n}\n\nfunction createNavigationEntry(entry) {\n const {\n entryType,\n name,\n decodedBodySize,\n duration,\n domComplete,\n encodedBodySize,\n domContentLoadedEventStart,\n domContentLoadedEventEnd,\n domInteractive,\n loadEventStart,\n loadEventEnd,\n redirectCount,\n startTime,\n transferSize,\n type,\n } = entry;\n\n // Ignore entries with no duration, they do not seem to be useful and cause dupes\n if (duration === 0) {\n return null;\n }\n\n return {\n type: `${entryType}.${type}`,\n start: getAbsoluteTime(startTime),\n end: getAbsoluteTime(domComplete),\n name,\n data: {\n size: transferSize,\n decodedBodySize,\n encodedBodySize,\n duration,\n domInteractive,\n domContentLoadedEventStart,\n domContentLoadedEventEnd,\n loadEventStart,\n loadEventEnd,\n domComplete,\n redirectCount,\n },\n };\n}\n\nfunction createResourceEntry(\n entry,\n) {\n const {\n entryType,\n initiatorType,\n name,\n responseEnd,\n startTime,\n decodedBodySize,\n encodedBodySize,\n responseStatus,\n transferSize,\n } = entry;\n\n // Core SDK handles these\n if (['fetch', 'xmlhttprequest'].includes(initiatorType)) {\n return null;\n }\n\n return {\n type: `${entryType}.${initiatorType}`,\n start: getAbsoluteTime(startTime),\n end: getAbsoluteTime(responseEnd),\n name,\n data: {\n size: transferSize,\n statusCode: responseStatus,\n decodedBodySize,\n encodedBodySize,\n },\n };\n}\n\n/**\n * Add a LCP event to the replay based on an LCP metric.\n */\nfunction getLargestContentfulPaint(metric\n\n) {\n const entries = metric.entries;\n const lastEntry = entries[entries.length - 1] ;\n const element = lastEntry ? lastEntry.element : undefined;\n\n const value = metric.value;\n\n const end = getAbsoluteTime(value);\n\n const data = {\n type: 'largest-contentful-paint',\n name: 'largest-contentful-paint',\n start: end,\n end,\n data: {\n value,\n size: value,\n nodeId: element ? record.mirror.getId(element) : undefined,\n },\n };\n\n return data;\n}\n\n/**\n * Sets up a PerformanceObserver to listen to all performance entry types.\n * Returns a callback to stop observing.\n */\nfunction setupPerformanceObserver(replay) {\n function addPerformanceEntry(entry) {\n // It is possible for entries to come up multiple times\n if (!replay.performanceEntries.includes(entry)) {\n replay.performanceEntries.push(entry);\n }\n }\n\n function onEntries({ entries }) {\n entries.forEach(addPerformanceEntry);\n }\n\n const clearCallbacks = [];\n\n (['navigation', 'paint', 'resource'] ).forEach(type => {\n clearCallbacks.push(addPerformanceInstrumentationHandler(type, onEntries));\n });\n\n clearCallbacks.push(\n addLcpInstrumentationHandler(({ metric }) => {\n replay.replayPerformanceEntries.push(getLargestContentfulPaint(metric));\n }),\n );\n\n // A callback to cleanup all handlers\n return () => {\n clearCallbacks.forEach(clearCallback => clearCallback());\n };\n}\n\n/**\n * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.\n *\n * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.\n */\nconst DEBUG_BUILD = (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__);\n\nconst r = `var t=Uint8Array,n=Uint16Array,r=Int32Array,e=new t([0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0,0]),i=new t([0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13,0,0]),a=new t([16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]),s=function(t,e){for(var i=new n(31),a=0;a<31;++a)i[a]=e+=1<>1|(21845&c)<<1;v=(61680&(v=(52428&v)>>2|(13107&v)<<2))>>4|(3855&v)<<4,u[c]=((65280&v)>>8|(255&v)<<8)>>1}var d=function(t,r,e){for(var i=t.length,a=0,s=new n(r);a>h]=l}else for(o=new n(i),a=0;a>15-t[a]);return o},g=new t(288);for(c=0;c<144;++c)g[c]=8;for(c=144;c<256;++c)g[c]=9;for(c=256;c<280;++c)g[c]=7;for(c=280;c<288;++c)g[c]=8;var w=new t(32);for(c=0;c<32;++c)w[c]=5;var p=d(g,9,0),y=d(w,5,0),m=function(t){return(t+7)/8|0},b=function(n,r,e){return(null==r||r<0)&&(r=0),(null==e||e>n.length)&&(e=n.length),new t(n.subarray(r,e))},M=[\"unexpected EOF\",\"invalid block type\",\"invalid length/literal\",\"invalid distance\",\"stream finished\",\"no stream handler\",,\"no callback\",\"invalid UTF-8 data\",\"extra field too long\",\"date not in range 1980-2099\",\"filename too long\",\"stream finishing\",\"invalid zip data\"],E=function(t,n,r){var e=new Error(n||M[t]);if(e.code=t,Error.captureStackTrace&&Error.captureStackTrace(e,E),!r)throw e;return e},z=function(t,n,r){r<<=7&n;var e=n/8|0;t[e]|=r,t[e+1]|=r>>8},A=function(t,n,r){r<<=7&n;var e=n/8|0;t[e]|=r,t[e+1]|=r>>8,t[e+2]|=r>>16},_=function(r,e){for(var i=[],a=0;ad&&(d=o[a].s);var g=new n(d+1),w=x(i[c-1],g,0);if(w>e){a=0;var p=0,y=w-e,m=1<e))break;p+=m-(1<>=y;p>0;){var M=o[a].s;g[M]=0&&p;--a){var E=o[a].s;g[E]==e&&(--g[E],++p)}w=e}return{t:new t(g),l:w}},x=function(t,n,r){return-1==t.s?Math.max(x(t.l,n,r+1),x(t.r,n,r+1)):n[t.s]=r},D=function(t){for(var r=t.length;r&&!t[--r];);for(var e=new n(++r),i=0,a=t[0],s=1,o=function(t){e[i++]=t},f=1;f<=r;++f)if(t[f]==a&&f!=r)++s;else{if(!a&&s>2){for(;s>138;s-=138)o(32754);s>2&&(o(s>10?s-11<<5|28690:s-3<<5|12305),s=0)}else if(s>3){for(o(a),--s;s>6;s-=6)o(8304);s>2&&(o(s-3<<5|8208),s=0)}for(;s--;)o(a);s=1,a=t[f]}return{c:e.subarray(0,i),n:r}},T=function(t,n){for(var r=0,e=0;e>8,t[i+2]=255^t[i],t[i+3]=255^t[i+1];for(var a=0;a4&&!H[a[K-1]];--K);var N,P,Q,R,V=v+5<<3,W=T(f,g)+T(h,w)+l,X=T(f,M)+T(h,C)+l+14+3*K+T(q,H)+2*q[16]+3*q[17]+7*q[18];if(c>=0&&V<=W&&V<=X)return k(r,m,t.subarray(c,c+v));if(z(r,m,1+(X15&&(z(r,m,tt[B]>>5&127),m+=tt[B]>>12)}}}else N=p,P=g,Q=y,R=w;for(B=0;B255){A(r,m,N[(nt=rt>>18&31)+257]),m+=P[nt+257],nt>7&&(z(r,m,rt>>23&31),m+=e[nt]);var et=31&rt;A(r,m,Q[et]),m+=R[et],et>3&&(A(r,m,rt>>5&8191),m+=i[et])}else A(r,m,N[rt]),m+=P[rt]}return A(r,m,N[256]),m+P[256]},U=new r([65540,131080,131088,131104,262176,1048704,1048832,2114560,2117632]),F=new t(0),I=function(){for(var t=new Int32Array(256),n=0;n<256;++n){for(var r=n,e=9;--e;)r=(1&r&&-306674912)^r>>>1;t[n]=r}return t}(),S=function(){var t=1,n=0;return{p:function(r){for(var e=t,i=n,a=0|r.length,s=0;s!=a;){for(var o=Math.min(s+2655,a);s>16),i=(65535&i)+15*(i>>16)}t=e,n=i},d:function(){return(255&(t%=65521))<<24|(65280&t)<<8|(255&(n%=65521))<<8|n>>8}}},L=function(a,s,o,f,u){if(!u&&(u={l:1},s.dictionary)){var c=s.dictionary.subarray(-32768),v=new t(c.length+a.length);v.set(c),v.set(a,c.length),a=v,u.w=c.length}return function(a,s,o,f,u,c){var v=c.z||a.length,d=new t(f+v+5*(1+Math.ceil(v/7e3))+u),g=d.subarray(f,d.length-u),w=c.l,p=7&(c.r||0);if(s){p&&(g[0]=c.r>>3);for(var y=U[s-1],M=y>>13,E=8191&y,z=(1<7e3||q>24576)&&(N>423||!w)){p=C(a,g,0,F,I,S,O,q,G,j-G,p),q=L=O=0,G=j;for(var P=0;P<286;++P)I[P]=0;for(P=0;P<30;++P)S[P]=0}var Q=2,R=0,V=E,W=J-K&32767;if(N>2&&H==T(j-W))for(var X=Math.min(M,N)-1,Y=Math.min(32767,j),Z=Math.min(258,N);W<=Y&&--V&&J!=K;){if(a[j+Q]==a[j+Q-W]){for(var $=0;$Q){if(Q=$,R=W,$>X)break;var tt=Math.min(W,$-2),nt=0;for(P=0;Pnt&&(nt=et,K=rt)}}}W+=(J=K)-(K=A[J])&32767}if(R){F[q++]=268435456|h[Q]<<18|l[R];var it=31&h[Q],at=31&l[R];O+=e[it]+i[at],++I[257+it],++S[at],B=j+Q,++L}else F[q++]=a[j],++I[a[j]]}}for(j=Math.max(j,B);j=v&&(g[p/8|0]=w,st=v),p=k(g,p+1,a.subarray(j,st))}c.i=v}return b(d,0,f+m(p)+u)}(a,null==s.level?6:s.level,null==s.mem?Math.ceil(1.5*Math.max(8,Math.min(13,Math.log(a.length)))):12+s.mem,o,f,u)},O=function(t,n,r){for(;r;++n)t[n]=r,r>>>=8},j=function(){function n(n,r){if(\"function\"==typeof n&&(r=n,n={}),this.ondata=r,this.o=n||{},this.s={l:0,i:32768,w:32768,z:32768},this.b=new t(98304),this.o.dictionary){var e=this.o.dictionary.subarray(-32768);this.b.set(e,32768-e.length),this.s.i=32768-e.length}}return n.prototype.p=function(t,n){this.ondata(L(t,this.o,0,0,this.s),n)},n.prototype.push=function(n,r){this.ondata||E(5),this.s.l&&E(4);var e=n.length+this.s.z;if(e>this.b.length){if(e>2*this.b.length-32768){var i=new t(-32768&e);i.set(this.b.subarray(0,this.s.z)),this.b=i}var a=this.b.length-this.s.z;a&&(this.b.set(n.subarray(0,a),this.s.z),this.s.z=this.b.length,this.p(this.b,!1)),this.b.set(this.b.subarray(-32768)),this.b.set(n.subarray(a),32768),this.s.z=n.length-a+32768,this.s.i=32766,this.s.w=32768}else this.b.set(n,this.s.z),this.s.z+=n.length;this.s.l=1&r,(this.s.z>this.s.w+8191||r)&&(this.p(this.b,r||!1),this.s.w=this.s.i,this.s.i-=2)},n}();function q(t,n){n||(n={});var r=function(){var t=-1;return{p:function(n){for(var r=t,e=0;e>>8;t=r},d:function(){return~t}}}(),e=t.length;r.p(t);var i,a=L(t,n,10+((i=n).filename?i.filename.length+1:0),8),s=a.length;return function(t,n){var r=n.filename;if(t[0]=31,t[1]=139,t[2]=8,t[8]=n.level<2?4:9==n.level?2:0,t[9]=3,0!=n.mtime&&O(t,4,Math.floor(new Date(n.mtime||Date.now())/1e3)),r){t[3]=8;for(var e=0;e<=r.length;++e)t[e+10]=r.charCodeAt(e)}}(a,n),O(a,s-8,r.d()),O(a,s-4,e),a}var B=function(){function t(t,n){this.c=S(),this.v=1,j.call(this,t,n)}return t.prototype.push=function(t,n){this.c.p(t),j.prototype.push.call(this,t,n)},t.prototype.p=function(t,n){var r=L(t,this.o,this.v&&(this.o.dictionary?6:2),n&&4,this.s);this.v&&(function(t,n){var r=n.level,e=0==r?0:r<6?1:9==r?3:2;if(t[0]=120,t[1]=e<<6|(n.dictionary&&32),t[1]|=31-(t[0]<<8|t[1])%31,n.dictionary){var i=S();i.p(n.dictionary),O(t,2,i.d())}}(r,this.o),this.v=0),n&&O(r,r.length-4,this.c.d()),this.ondata(r,n)},t}(),G=\"undefined\"!=typeof TextEncoder&&new TextEncoder,H=\"undefined\"!=typeof TextDecoder&&new TextDecoder;try{H.decode(F,{stream:!0})}catch(t){}var J=function(){function t(t){this.ondata=t}return t.prototype.push=function(t,n){this.ondata||E(5),this.d&&E(4),this.ondata(K(t),this.d=n||!1)},t}();function K(n,r){if(r){for(var e=new t(n.length),i=0;i>1)),o=0,f=function(t){s[o++]=t};for(i=0;is.length){var h=new t(o+8+(a-i<<1));h.set(s),s=h}var l=n.charCodeAt(i);l<128||r?f(l):l<2048?(f(192|l>>6),f(128|63&l)):l>55295&&l<57344?(f(240|(l=65536+(1047552&l)|1023&n.charCodeAt(++i))>>18),f(128|l>>12&63),f(128|l>>6&63),f(128|63&l)):(f(224|l>>12),f(128|l>>6&63),f(128|63&l))}return b(s,0,o)}const N=new class{constructor(){this._init()}clear(){this._init()}addEvent(t){if(!t)throw new Error(\"Adding invalid event\");const n=this._hasEvents?\",\":\"\";this.stream.push(n+t),this._hasEvents=!0}finish(){this.stream.push(\"]\",!0);const t=function(t){let n=0;for(let r=0,e=t.length;r{this._deflatedData.push(t)},this.stream=new J(((t,n)=>{this.deflate.push(t,n)})),this.stream.push(\"[\")}},P={clear:()=>{N.clear()},addEvent:t=>N.addEvent(t),finish:()=>N.finish(),compress:t=>function(t){return q(K(t))}(t)};addEventListener(\"message\",(function(t){const n=t.data.method,r=t.data.id,e=t.data.arg;if(n in P&&\"function\"==typeof P[n])try{const t=P[n](e);postMessage({id:r,method:n,success:!0,response:t})}catch(t){postMessage({id:r,method:n,success:!1,response:t.message}),console.error(t)}})),postMessage({id:void 0,method:\"init\",success:!0,response:void 0});`;\n\nfunction e(){const e=new Blob([r]);return URL.createObjectURL(e)}\n\n/**\n * Log a message in debug mode, and add a breadcrumb when _experiment.traceInternals is enabled.\n */\nfunction logInfo(message, shouldAddBreadcrumb) {\n if (!DEBUG_BUILD) {\n return;\n }\n\n logger.info(message);\n\n if (shouldAddBreadcrumb) {\n addLogBreadcrumb(message);\n }\n}\n\n/**\n * Log a message, and add a breadcrumb in the next tick.\n * This is necessary when the breadcrumb may be added before the replay is initialized.\n */\nfunction logInfoNextTick(message, shouldAddBreadcrumb) {\n if (!DEBUG_BUILD) {\n return;\n }\n\n logger.info(message);\n\n if (shouldAddBreadcrumb) {\n // Wait a tick here to avoid race conditions for some initial logs\n // which may be added before replay is initialized\n setTimeout(() => {\n addLogBreadcrumb(message);\n }, 0);\n }\n}\n\nfunction addLogBreadcrumb(message) {\n addBreadcrumb(\n {\n category: 'console',\n data: {\n logger: 'replay',\n },\n level: 'info',\n message,\n },\n { level: 'info' },\n );\n}\n\n/** This error indicates that the event buffer size exceeded the limit.. */\nclass EventBufferSizeExceededError extends Error {\n constructor() {\n super(`Event buffer exceeded maximum size of ${REPLAY_MAX_EVENT_BUFFER_SIZE}.`);\n }\n}\n\n/**\n * A basic event buffer that does not do any compression.\n * Used as fallback if the compression worker cannot be loaded or is disabled.\n */\nclass EventBufferArray {\n /** All the events that are buffered to be sent. */\n\n /** @inheritdoc */\n\n constructor() {\n this.events = [];\n this._totalSize = 0;\n this.hasCheckout = false;\n }\n\n /** @inheritdoc */\n get hasEvents() {\n return this.events.length > 0;\n }\n\n /** @inheritdoc */\n get type() {\n return 'sync';\n }\n\n /** @inheritdoc */\n destroy() {\n this.events = [];\n }\n\n /** @inheritdoc */\n async addEvent(event) {\n const eventSize = JSON.stringify(event).length;\n this._totalSize += eventSize;\n if (this._totalSize > REPLAY_MAX_EVENT_BUFFER_SIZE) {\n throw new EventBufferSizeExceededError();\n }\n\n this.events.push(event);\n }\n\n /** @inheritdoc */\n finish() {\n return new Promise(resolve => {\n // Make a copy of the events array reference and immediately clear the\n // events member so that we do not lose new events while uploading\n // attachment.\n const eventsRet = this.events;\n this.clear();\n resolve(JSON.stringify(eventsRet));\n });\n }\n\n /** @inheritdoc */\n clear() {\n this.events = [];\n this._totalSize = 0;\n this.hasCheckout = false;\n }\n\n /** @inheritdoc */\n getEarliestTimestamp() {\n const timestamp = this.events.map(event => event.timestamp).sort()[0];\n\n if (!timestamp) {\n return null;\n }\n\n return timestampToMs(timestamp);\n }\n}\n\n/**\n * Event buffer that uses a web worker to compress events.\n * Exported only for testing.\n */\nclass WorkerHandler {\n\n constructor(worker) {\n this._worker = worker;\n this._id = 0;\n }\n\n /**\n * Ensure the worker is ready (or not).\n * This will either resolve when the worker is ready, or reject if an error occured.\n */\n ensureReady() {\n // Ensure we only check once\n if (this._ensureReadyPromise) {\n return this._ensureReadyPromise;\n }\n\n this._ensureReadyPromise = new Promise((resolve, reject) => {\n this._worker.addEventListener(\n 'message',\n ({ data }) => {\n if ((data ).success) {\n resolve();\n } else {\n reject();\n }\n },\n { once: true },\n );\n\n this._worker.addEventListener(\n 'error',\n error => {\n reject(error);\n },\n { once: true },\n );\n });\n\n return this._ensureReadyPromise;\n }\n\n /**\n * Destroy the worker.\n */\n destroy() {\n logInfo('[Replay] Destroying compression worker');\n this._worker.terminate();\n }\n\n /**\n * Post message to worker and wait for response before resolving promise.\n */\n postMessage(method, arg) {\n const id = this._getAndIncrementId();\n\n return new Promise((resolve, reject) => {\n const listener = ({ data }) => {\n const response = data ;\n if (response.method !== method) {\n return;\n }\n\n // There can be multiple listeners for a single method, the id ensures\n // that the response matches the caller.\n if (response.id !== id) {\n return;\n }\n\n // At this point, we'll always want to remove listener regardless of result status\n this._worker.removeEventListener('message', listener);\n\n if (!response.success) {\n // TODO: Do some error handling, not sure what\n DEBUG_BUILD && logger.error('[Replay]', response.response);\n\n reject(new Error('Error in compression worker'));\n return;\n }\n\n resolve(response.response );\n };\n\n // Note: we can't use `once` option because it's possible it needs to\n // listen to multiple messages\n this._worker.addEventListener('message', listener);\n this._worker.postMessage({ id, method, arg });\n });\n }\n\n /** Get the current ID and increment it for the next call. */\n _getAndIncrementId() {\n return this._id++;\n }\n}\n\n/**\n * Event buffer that uses a web worker to compress events.\n * Exported only for testing.\n */\nclass EventBufferCompressionWorker {\n /** @inheritdoc */\n\n constructor(worker) {\n this._worker = new WorkerHandler(worker);\n this._earliestTimestamp = null;\n this._totalSize = 0;\n this.hasCheckout = false;\n }\n\n /** @inheritdoc */\n get hasEvents() {\n return !!this._earliestTimestamp;\n }\n\n /** @inheritdoc */\n get type() {\n return 'worker';\n }\n\n /**\n * Ensure the worker is ready (or not).\n * This will either resolve when the worker is ready, or reject if an error occured.\n */\n ensureReady() {\n return this._worker.ensureReady();\n }\n\n /**\n * Destroy the event buffer.\n */\n destroy() {\n this._worker.destroy();\n }\n\n /**\n * Add an event to the event buffer.\n *\n * Returns true if event was successfuly received and processed by worker.\n */\n addEvent(event) {\n const timestamp = timestampToMs(event.timestamp);\n if (!this._earliestTimestamp || timestamp < this._earliestTimestamp) {\n this._earliestTimestamp = timestamp;\n }\n\n const data = JSON.stringify(event);\n this._totalSize += data.length;\n\n if (this._totalSize > REPLAY_MAX_EVENT_BUFFER_SIZE) {\n return Promise.reject(new EventBufferSizeExceededError());\n }\n\n return this._sendEventToWorker(data);\n }\n\n /**\n * Finish the event buffer and return the compressed data.\n */\n finish() {\n return this._finishRequest();\n }\n\n /** @inheritdoc */\n clear() {\n this._earliestTimestamp = null;\n this._totalSize = 0;\n this.hasCheckout = false;\n\n // We do not wait on this, as we assume the order of messages is consistent for the worker\n this._worker.postMessage('clear').then(null, e => {\n DEBUG_BUILD && logger.warn('[Replay] Sending \"clear\" message to worker failed', e);\n });\n }\n\n /** @inheritdoc */\n getEarliestTimestamp() {\n return this._earliestTimestamp;\n }\n\n /**\n * Send the event to the worker.\n */\n _sendEventToWorker(data) {\n return this._worker.postMessage('addEvent', data);\n }\n\n /**\n * Finish the request and return the compressed data from the worker.\n */\n async _finishRequest() {\n const response = await this._worker.postMessage('finish');\n\n this._earliestTimestamp = null;\n this._totalSize = 0;\n\n return response;\n }\n}\n\n/**\n * This proxy will try to use the compression worker, and fall back to use the simple buffer if an error occurs there.\n * This can happen e.g. if the worker cannot be loaded.\n * Exported only for testing.\n */\nclass EventBufferProxy {\n\n constructor(worker) {\n this._fallback = new EventBufferArray();\n this._compression = new EventBufferCompressionWorker(worker);\n this._used = this._fallback;\n\n this._ensureWorkerIsLoadedPromise = this._ensureWorkerIsLoaded();\n }\n\n /** @inheritdoc */\n get type() {\n return this._used.type;\n }\n\n /** @inheritDoc */\n get hasEvents() {\n return this._used.hasEvents;\n }\n\n /** @inheritdoc */\n get hasCheckout() {\n return this._used.hasCheckout;\n }\n /** @inheritdoc */\n set hasCheckout(value) {\n this._used.hasCheckout = value;\n }\n\n /** @inheritDoc */\n destroy() {\n this._fallback.destroy();\n this._compression.destroy();\n }\n\n /** @inheritdoc */\n clear() {\n return this._used.clear();\n }\n\n /** @inheritdoc */\n getEarliestTimestamp() {\n return this._used.getEarliestTimestamp();\n }\n\n /**\n * Add an event to the event buffer.\n *\n * Returns true if event was successfully added.\n */\n addEvent(event) {\n return this._used.addEvent(event);\n }\n\n /** @inheritDoc */\n async finish() {\n // Ensure the worker is loaded, so the sent event is compressed\n await this.ensureWorkerIsLoaded();\n\n return this._used.finish();\n }\n\n /** Ensure the worker has loaded. */\n ensureWorkerIsLoaded() {\n return this._ensureWorkerIsLoadedPromise;\n }\n\n /** Actually check if the worker has been loaded. */\n async _ensureWorkerIsLoaded() {\n try {\n await this._compression.ensureReady();\n } catch (error) {\n // If the worker fails to load, we fall back to the simple buffer.\n // Nothing more to do from our side here\n logInfo('[Replay] Failed to load the compression worker, falling back to simple buffer');\n return;\n }\n\n // Now we need to switch over the array buffer to the compression worker\n await this._switchToCompressionWorker();\n }\n\n /** Switch the used buffer to the compression worker. */\n async _switchToCompressionWorker() {\n const { events, hasCheckout } = this._fallback;\n\n const addEventPromises = [];\n for (const event of events) {\n addEventPromises.push(this._compression.addEvent(event));\n }\n\n this._compression.hasCheckout = hasCheckout;\n\n // We switch over to the new buffer immediately - any further events will be added\n // after the previously buffered ones\n this._used = this._compression;\n\n // Wait for original events to be re-added before resolving\n try {\n await Promise.all(addEventPromises);\n } catch (error) {\n DEBUG_BUILD && logger.warn('[Replay] Failed to add events when switching buffers.', error);\n }\n }\n}\n\n/**\n * Create an event buffer for replays.\n */\nfunction createEventBuffer({\n useCompression,\n workerUrl: customWorkerUrl,\n}) {\n if (\n useCompression &&\n // eslint-disable-next-line no-restricted-globals\n window.Worker\n ) {\n const worker = _loadWorker(customWorkerUrl);\n\n if (worker) {\n return worker;\n }\n }\n\n logInfo('[Replay] Using simple buffer');\n return new EventBufferArray();\n}\n\nfunction _loadWorker(customWorkerUrl) {\n try {\n const workerUrl = customWorkerUrl || _getWorkerUrl();\n\n if (!workerUrl) {\n return;\n }\n\n logInfo(`[Replay] Using compression worker${customWorkerUrl ? ` from ${customWorkerUrl}` : ''}`);\n const worker = new Worker(workerUrl);\n return new EventBufferProxy(worker);\n } catch (error) {\n logInfo('[Replay] Failed to create compression worker');\n // Fall back to use simple event buffer array\n }\n}\n\nfunction _getWorkerUrl() {\n if (typeof __SENTRY_EXCLUDE_REPLAY_WORKER__ === 'undefined' || !__SENTRY_EXCLUDE_REPLAY_WORKER__) {\n return e();\n }\n\n return '';\n}\n\n/** If sessionStorage is available. */\nfunction hasSessionStorage() {\n try {\n // This can throw, e.g. when being accessed in a sandboxed iframe\n return 'sessionStorage' in WINDOW && !!WINDOW.sessionStorage;\n } catch (e) {\n return false;\n }\n}\n\n/**\n * Removes the session from Session Storage and unsets session in replay instance\n */\nfunction clearSession(replay) {\n deleteSession();\n replay.session = undefined;\n}\n\n/**\n * Deletes a session from storage\n */\nfunction deleteSession() {\n if (!hasSessionStorage()) {\n return;\n }\n\n try {\n WINDOW.sessionStorage.removeItem(REPLAY_SESSION_KEY);\n } catch (e) {\n // Ignore potential SecurityError exceptions\n }\n}\n\n/**\n * Given a sample rate, returns true if replay should be sampled.\n *\n * 1.0 = 100% sampling\n * 0.0 = 0% sampling\n */\nfunction isSampled(sampleRate) {\n if (sampleRate === undefined) {\n return false;\n }\n\n // Math.random() returns a number in range of 0 to 1 (inclusive of 0, but not 1)\n return Math.random() < sampleRate;\n}\n\n/**\n * Get a session with defaults & applied sampling.\n */\nfunction makeSession(session) {\n const now = Date.now();\n const id = session.id || uuid4();\n // Note that this means we cannot set a started/lastActivity of `0`, but this should not be relevant outside of tests.\n const started = session.started || now;\n const lastActivity = session.lastActivity || now;\n const segmentId = session.segmentId || 0;\n const sampled = session.sampled;\n const previousSessionId = session.previousSessionId;\n\n return {\n id,\n started,\n lastActivity,\n segmentId,\n sampled,\n previousSessionId,\n };\n}\n\n/**\n * Save a session to session storage.\n */\nfunction saveSession(session) {\n if (!hasSessionStorage()) {\n return;\n }\n\n try {\n WINDOW.sessionStorage.setItem(REPLAY_SESSION_KEY, JSON.stringify(session));\n } catch (e) {\n // Ignore potential SecurityError exceptions\n }\n}\n\n/**\n * Get the sampled status for a session based on sample rates & current sampled status.\n */\nfunction getSessionSampleType(sessionSampleRate, allowBuffering) {\n return isSampled(sessionSampleRate) ? 'session' : allowBuffering ? 'buffer' : false;\n}\n\n/**\n * Create a new session, which in its current implementation is a Sentry event\n * that all replays will be saved to as attachments. Currently, we only expect\n * one of these Sentry events per \"replay session\".\n */\nfunction createSession(\n { sessionSampleRate, allowBuffering, stickySession = false },\n { previousSessionId } = {},\n) {\n const sampled = getSessionSampleType(sessionSampleRate, allowBuffering);\n const session = makeSession({\n sampled,\n previousSessionId,\n });\n\n if (stickySession) {\n saveSession(session);\n }\n\n return session;\n}\n\n/**\n * Fetches a session from storage\n */\nfunction fetchSession(traceInternals) {\n if (!hasSessionStorage()) {\n return null;\n }\n\n try {\n // This can throw if cookies are disabled\n const sessionStringFromStorage = WINDOW.sessionStorage.getItem(REPLAY_SESSION_KEY);\n\n if (!sessionStringFromStorage) {\n return null;\n }\n\n const sessionObj = JSON.parse(sessionStringFromStorage) ;\n\n logInfoNextTick('[Replay] Loading existing session', traceInternals);\n\n return makeSession(sessionObj);\n } catch (e) {\n return null;\n }\n}\n\n/**\n * Given an initial timestamp and an expiry duration, checks to see if current\n * time should be considered as expired.\n */\nfunction isExpired(\n initialTime,\n expiry,\n targetTime = +new Date(),\n) {\n // Always expired if < 0\n if (initialTime === null || expiry === undefined || expiry < 0) {\n return true;\n }\n\n // Never expires if == 0\n if (expiry === 0) {\n return false;\n }\n\n return initialTime + expiry <= targetTime;\n}\n\n/**\n * Checks to see if session is expired\n */\nfunction isSessionExpired(\n session,\n {\n maxReplayDuration,\n sessionIdleExpire,\n targetTime = Date.now(),\n },\n) {\n return (\n // First, check that maximum session length has not been exceeded\n isExpired(session.started, maxReplayDuration, targetTime) ||\n // check that the idle timeout has not been exceeded (i.e. user has\n // performed an action within the last `sessionIdleExpire` ms)\n isExpired(session.lastActivity, sessionIdleExpire, targetTime)\n );\n}\n\n/** If the session should be refreshed or not. */\nfunction shouldRefreshSession(\n session,\n { sessionIdleExpire, maxReplayDuration },\n) {\n // If not expired, all good, just keep the session\n if (!isSessionExpired(session, { sessionIdleExpire, maxReplayDuration })) {\n return false;\n }\n\n // If we are buffering & haven't ever flushed yet, always continue\n if (session.sampled === 'buffer' && session.segmentId === 0) {\n return false;\n }\n\n return true;\n}\n\n/**\n * Get or create a session, when initializing the replay.\n * Returns a session that may be unsampled.\n */\nfunction loadOrCreateSession(\n {\n traceInternals,\n sessionIdleExpire,\n maxReplayDuration,\n previousSessionId,\n }\n\n,\n sessionOptions,\n) {\n const existingSession = sessionOptions.stickySession && fetchSession(traceInternals);\n\n // No session exists yet, just create a new one\n if (!existingSession) {\n logInfoNextTick('[Replay] Creating new session', traceInternals);\n return createSession(sessionOptions, { previousSessionId });\n }\n\n if (!shouldRefreshSession(existingSession, { sessionIdleExpire, maxReplayDuration })) {\n return existingSession;\n }\n\n logInfoNextTick('[Replay] Session in sessionStorage is expired, creating new one...');\n return createSession(sessionOptions, { previousSessionId: existingSession.id });\n}\n\nfunction isCustomEvent(event) {\n return event.type === EventType.Custom;\n}\n\n/**\n * Add an event to the event buffer.\n * In contrast to `addEvent`, this does not return a promise & does not wait for the adding of the event to succeed/fail.\n * Instead this returns `true` if we tried to add the event, else false.\n * It returns `false` e.g. if we are paused, disabled, or out of the max replay duration.\n *\n * `isCheckout` is true if this is either the very first event, or an event triggered by `checkoutEveryNms`.\n */\nfunction addEventSync(replay, event, isCheckout) {\n if (!shouldAddEvent(replay, event)) {\n return false;\n }\n\n // This should never reject\n // eslint-disable-next-line @typescript-eslint/no-floating-promises\n _addEvent(replay, event, isCheckout);\n\n return true;\n}\n\n/**\n * Add an event to the event buffer.\n * Resolves to `null` if no event was added, else to `void`.\n *\n * `isCheckout` is true if this is either the very first event, or an event triggered by `checkoutEveryNms`.\n */\nfunction addEvent(\n replay,\n event,\n isCheckout,\n) {\n if (!shouldAddEvent(replay, event)) {\n return Promise.resolve(null);\n }\n\n return _addEvent(replay, event, isCheckout);\n}\n\nasync function _addEvent(\n replay,\n event,\n isCheckout,\n) {\n if (!replay.eventBuffer) {\n return null;\n }\n\n try {\n if (isCheckout && replay.recordingMode === 'buffer') {\n replay.eventBuffer.clear();\n }\n\n if (isCheckout) {\n replay.eventBuffer.hasCheckout = true;\n }\n\n const replayOptions = replay.getOptions();\n\n const eventAfterPossibleCallback = maybeApplyCallback(event, replayOptions.beforeAddRecordingEvent);\n\n if (!eventAfterPossibleCallback) {\n return;\n }\n\n return await replay.eventBuffer.addEvent(eventAfterPossibleCallback);\n } catch (error) {\n const reason = error && error instanceof EventBufferSizeExceededError ? 'addEventSizeExceeded' : 'addEvent';\n\n DEBUG_BUILD && logger.error(error);\n await replay.stop({ reason });\n\n const client = getClient();\n\n if (client) {\n client.recordDroppedEvent('internal_sdk_error', 'replay');\n }\n }\n}\n\n/** Exported only for tests. */\nfunction shouldAddEvent(replay, event) {\n if (!replay.eventBuffer || replay.isPaused() || !replay.isEnabled()) {\n return false;\n }\n\n const timestampInMs = timestampToMs(event.timestamp);\n\n // Throw out events that happen more than 5 minutes ago. This can happen if\n // page has been left open and idle for a long period of time and user\n // comes back to trigger a new session. The performance entries rely on\n // `performance.timeOrigin`, which is when the page first opened.\n if (timestampInMs + replay.timeouts.sessionIdlePause < Date.now()) {\n return false;\n }\n\n // Throw out events that are +60min from the initial timestamp\n if (timestampInMs > replay.getContext().initialTimestamp + replay.getOptions().maxReplayDuration) {\n logInfo(\n `[Replay] Skipping event with timestamp ${timestampInMs} because it is after maxReplayDuration`,\n replay.getOptions()._experiments.traceInternals,\n );\n return false;\n }\n\n return true;\n}\n\nfunction maybeApplyCallback(\n event,\n callback,\n) {\n try {\n if (typeof callback === 'function' && isCustomEvent(event)) {\n return callback(event);\n }\n } catch (error) {\n DEBUG_BUILD &&\n logger.error('[Replay] An error occured in the `beforeAddRecordingEvent` callback, skipping the event...', error);\n return null;\n }\n\n return event;\n}\n\n/** If the event is an error event */\nfunction isErrorEvent(event) {\n return !event.type;\n}\n\n/** If the event is a transaction event */\nfunction isTransactionEvent(event) {\n return event.type === 'transaction';\n}\n\n/** If the event is an replay event */\nfunction isReplayEvent(event) {\n return event.type === 'replay_event';\n}\n\n/** If the event is a feedback event */\nfunction isFeedbackEvent(event) {\n return event.type === 'feedback';\n}\n\n/**\n * Returns a listener to be added to `client.on('afterSendErrorEvent, listener)`.\n */\nfunction handleAfterSendEvent(replay) {\n // Custom transports may still be returning `Promise`, which means we cannot expect the status code to be available there\n // TODO (v8): remove this check as it will no longer be necessary\n const enforceStatusCode = isBaseTransportSend();\n\n return (event, sendResponse) => {\n if (!replay.isEnabled() || (!isErrorEvent(event) && !isTransactionEvent(event))) {\n return;\n }\n\n const statusCode = sendResponse && sendResponse.statusCode;\n\n // We only want to do stuff on successful error sending, otherwise you get error replays without errors attached\n // If not using the base transport, we allow `undefined` response (as a custom transport may not implement this correctly yet)\n // If we do use the base transport, we skip if we encountered an non-OK status code\n if (enforceStatusCode && (!statusCode || statusCode < 200 || statusCode >= 300)) {\n return;\n }\n\n if (isTransactionEvent(event)) {\n handleTransactionEvent(replay, event);\n return;\n }\n\n handleErrorEvent(replay, event);\n };\n}\n\nfunction handleTransactionEvent(replay, event) {\n const replayContext = replay.getContext();\n\n // Collect traceIds in _context regardless of `recordingMode`\n // In error mode, _context gets cleared on every checkout\n // We limit to max. 100 transactions linked\n if (event.contexts && event.contexts.trace && event.contexts.trace.trace_id && replayContext.traceIds.size < 100) {\n replayContext.traceIds.add(event.contexts.trace.trace_id );\n }\n}\n\nfunction handleErrorEvent(replay, event) {\n const replayContext = replay.getContext();\n\n // Add error to list of errorIds of replay. This is ok to do even if not\n // sampled because context will get reset at next checkout.\n // XXX: There is also a race condition where it's possible to capture an\n // error to Sentry before Replay SDK has loaded, but response returns after\n // it was loaded, and this gets called.\n // We limit to max. 100 errors linked\n if (event.event_id && replayContext.errorIds.size < 100) {\n replayContext.errorIds.add(event.event_id);\n }\n\n // If error event is tagged with replay id it means it was sampled (when in buffer mode)\n // Need to be very careful that this does not cause an infinite loop\n if (replay.recordingMode !== 'buffer' || !event.tags || !event.tags.replayId) {\n return;\n }\n\n const { beforeErrorSampling } = replay.getOptions();\n if (typeof beforeErrorSampling === 'function' && !beforeErrorSampling(event)) {\n return;\n }\n\n setTimeout(() => {\n // Capture current event buffer as new replay\n // This should never reject\n // eslint-disable-next-line @typescript-eslint/no-floating-promises\n replay.sendBufferedReplayOrFlush();\n });\n}\n\nfunction isBaseTransportSend() {\n const client = getClient();\n if (!client) {\n return false;\n }\n\n const transport = client.getTransport();\n if (!transport) {\n return false;\n }\n\n return (\n (transport.send ).__sentry__baseTransport__ || false\n );\n}\n\n/**\n * Returns a listener to be added to `client.on('afterSendErrorEvent, listener)`.\n */\nfunction handleBeforeSendEvent(replay) {\n return (event) => {\n if (!replay.isEnabled() || !isErrorEvent(event)) {\n return;\n }\n\n handleHydrationError(replay, event);\n };\n}\n\nfunction handleHydrationError(replay, event) {\n const exceptionValue = event.exception && event.exception.values && event.exception.values[0].value;\n if (typeof exceptionValue !== 'string') {\n return;\n }\n\n if (\n // Only matches errors in production builds of react-dom\n // Example https://reactjs.org/docs/error-decoder.html?invariant=423\n exceptionValue.match(/reactjs\\.org\\/docs\\/error-decoder\\.html\\?invariant=(418|419|422|423|425)/) ||\n // Development builds of react-dom\n // Error 1: Hydration failed because the initial UI does not match what was rendered on the server.\n // Error 2: Text content does not match server-rendered HTML. Warning: Text content did not match.\n exceptionValue.match(/(does not match server-rendered HTML|Hydration failed because)/i)\n ) {\n const breadcrumb = createBreadcrumb({\n category: 'replay.hydrate-error',\n });\n addBreadcrumbEvent(replay, breadcrumb);\n }\n}\n\n/**\n * Returns true if we think the given event is an error originating inside of rrweb.\n */\nfunction isRrwebError(event, hint) {\n if (event.type || !event.exception || !event.exception.values || !event.exception.values.length) {\n return false;\n }\n\n // @ts-expect-error this may be set by rrweb when it finds errors\n if (hint.originalException && hint.originalException.__rrweb__) {\n return true;\n }\n\n return false;\n}\n\n/**\n * Add a feedback breadcrumb event to replay.\n */\nfunction addFeedbackBreadcrumb(replay, event) {\n replay.triggerUserActivity();\n replay.addUpdate(() => {\n if (!event.timestamp) {\n // Ignore events that don't have timestamps (this shouldn't happen, more of a typing issue)\n // Return true here so that we don't flush\n return true;\n }\n\n // This should never reject\n // eslint-disable-next-line @typescript-eslint/no-floating-promises\n replay.throttledAddEvent({\n type: EventType.Custom,\n timestamp: event.timestamp * 1000,\n data: {\n tag: 'breadcrumb',\n payload: {\n timestamp: event.timestamp,\n type: 'default',\n category: 'sentry.feedback',\n data: {\n feedbackId: event.event_id,\n },\n },\n },\n } );\n\n return false;\n });\n}\n\n/**\n * Determine if event should be sampled (only applies in buffer mode).\n * When an event is captured by `hanldleGlobalEvent`, when in buffer mode\n * we determine if we want to sample the error or not.\n */\nfunction shouldSampleForBufferEvent(replay, event) {\n if (replay.recordingMode !== 'buffer') {\n return false;\n }\n\n // ignore this error because otherwise we could loop indefinitely with\n // trying to capture replay and failing\n if (event.message === UNABLE_TO_SEND_REPLAY) {\n return false;\n }\n\n // Require the event to be an error event & to have an exception\n if (!event.exception || event.type) {\n return false;\n }\n\n return isSampled(replay.getOptions().errorSampleRate);\n}\n\n/**\n * Returns a listener to be added to `addEventProcessor(listener)`.\n */\nfunction handleGlobalEventListener(\n replay,\n includeAfterSendEventHandling = false,\n) {\n const afterSendHandler = includeAfterSendEventHandling ? handleAfterSendEvent(replay) : undefined;\n\n return Object.assign(\n (event, hint) => {\n // Do nothing if replay has been disabled\n if (!replay.isEnabled()) {\n return event;\n }\n\n if (isReplayEvent(event)) {\n // Replays have separate set of breadcrumbs, do not include breadcrumbs\n // from core SDK\n delete event.breadcrumbs;\n return event;\n }\n\n // We only want to handle errors, transactions, and feedbacks, nothing else\n if (!isErrorEvent(event) && !isTransactionEvent(event) && !isFeedbackEvent(event)) {\n return event;\n }\n\n // Ensure we do not add replay_id if the session is expired\n const isSessionActive = replay.checkAndHandleExpiredSession();\n if (!isSessionActive) {\n return event;\n }\n\n if (isFeedbackEvent(event)) {\n // This should never reject\n // eslint-disable-next-line @typescript-eslint/no-floating-promises\n replay.flush();\n event.contexts.feedback.replay_id = replay.getSessionId();\n // Add a replay breadcrumb for this piece of feedback\n addFeedbackBreadcrumb(replay, event);\n return event;\n }\n\n // Unless `captureExceptions` is enabled, we want to ignore errors coming from rrweb\n // As there can be a bunch of stuff going wrong in internals there, that we don't want to bubble up to users\n if (isRrwebError(event, hint) && !replay.getOptions()._experiments.captureExceptions) {\n DEBUG_BUILD && logger.log('[Replay] Ignoring error from rrweb internals', event);\n return null;\n }\n\n // When in buffer mode, we decide to sample here.\n // Later, in `handleAfterSendEvent`, if the replayId is set, we know that we sampled\n // And convert the buffer session to a full session\n const isErrorEventSampled = shouldSampleForBufferEvent(replay, event);\n\n // Tag errors if it has been sampled in buffer mode, or if it is session mode\n // Only tag transactions if in session mode\n const shouldTagReplayId = isErrorEventSampled || replay.recordingMode === 'session';\n\n if (shouldTagReplayId) {\n event.tags = { ...event.tags, replayId: replay.getSessionId() };\n }\n\n // In cases where a custom client is used that does not support the new hooks (yet),\n // we manually call this hook method here\n if (afterSendHandler) {\n // Pretend the error had a 200 response so we always capture it\n afterSendHandler(event, { statusCode: 200 });\n }\n\n return event;\n },\n { id: 'Replay' },\n );\n}\n\n/**\n * Create a \"span\" for each performance entry.\n */\nfunction createPerformanceSpans(\n replay,\n entries,\n) {\n return entries.map(({ type, start, end, name, data }) => {\n const response = replay.throttledAddEvent({\n type: EventType.Custom,\n timestamp: start,\n data: {\n tag: 'performanceSpan',\n payload: {\n op: type,\n description: name,\n startTimestamp: start,\n endTimestamp: end,\n data,\n },\n },\n });\n\n // If response is a string, it means its either THROTTLED or SKIPPED\n return typeof response === 'string' ? Promise.resolve(null) : response;\n });\n}\n\nfunction handleHistory(handlerData) {\n const { from, to } = handlerData;\n\n const now = Date.now() / 1000;\n\n return {\n type: 'navigation.push',\n start: now,\n end: now,\n name: to,\n data: {\n previous: from,\n },\n };\n}\n\n/**\n * Returns a listener to be added to `addHistoryInstrumentationHandler(listener)`.\n */\nfunction handleHistorySpanListener(replay) {\n return (handlerData) => {\n if (!replay.isEnabled()) {\n return;\n }\n\n const result = handleHistory(handlerData);\n\n if (result === null) {\n return;\n }\n\n // Need to collect visited URLs\n replay.getContext().urls.push(result.name);\n replay.triggerUserActivity();\n\n replay.addUpdate(() => {\n createPerformanceSpans(replay, [result]);\n // Returning false to flush\n return false;\n });\n };\n}\n\n/**\n * Check whether a given request URL should be filtered out. This is so we\n * don't log Sentry ingest requests.\n */\nfunction shouldFilterRequest(replay, url) {\n // If we enabled the `traceInternals` experiment, we want to trace everything\n if (DEBUG_BUILD && replay.getOptions()._experiments.traceInternals) {\n return false;\n }\n\n return isSentryRequestUrl(url, getClient());\n}\n\n/** Add a performance entry breadcrumb */\nfunction addNetworkBreadcrumb(\n replay,\n result,\n) {\n if (!replay.isEnabled()) {\n return;\n }\n\n if (result === null) {\n return;\n }\n\n if (shouldFilterRequest(replay, result.name)) {\n return;\n }\n\n replay.addUpdate(() => {\n createPerformanceSpans(replay, [result]);\n // Returning true will cause `addUpdate` to not flush\n // We do not want network requests to cause a flush. This will prevent\n // recurring/polling requests from keeping the replay session alive.\n return true;\n });\n}\n\n/** only exported for tests */\nfunction handleFetch(handlerData) {\n const { startTimestamp, endTimestamp, fetchData, response } = handlerData;\n\n if (!endTimestamp) {\n return null;\n }\n\n // This is only used as a fallback, so we know the body sizes are never set here\n const { method, url } = fetchData;\n\n return {\n type: 'resource.fetch',\n start: startTimestamp / 1000,\n end: endTimestamp / 1000,\n name: url,\n data: {\n method,\n statusCode: response ? (response ).status : undefined,\n },\n };\n}\n\n/**\n * Returns a listener to be added to `addFetchInstrumentationHandler(listener)`.\n */\nfunction handleFetchSpanListener(replay) {\n return (handlerData) => {\n if (!replay.isEnabled()) {\n return;\n }\n\n const result = handleFetch(handlerData);\n\n addNetworkBreadcrumb(replay, result);\n };\n}\n\n/** only exported for tests */\nfunction handleXhr(handlerData) {\n const { startTimestamp, endTimestamp, xhr } = handlerData;\n\n const sentryXhrData = xhr[SENTRY_XHR_DATA_KEY];\n\n if (!startTimestamp || !endTimestamp || !sentryXhrData) {\n return null;\n }\n\n // This is only used as a fallback, so we know the body sizes are never set here\n const { method, url, status_code: statusCode } = sentryXhrData;\n\n if (url === undefined) {\n return null;\n }\n\n return {\n type: 'resource.xhr',\n name: url,\n start: startTimestamp / 1000,\n end: endTimestamp / 1000,\n data: {\n method,\n statusCode,\n },\n };\n}\n\n/**\n * Returns a listener to be added to `addXhrInstrumentationHandler(listener)`.\n */\nfunction handleXhrSpanListener(replay) {\n return (handlerData) => {\n if (!replay.isEnabled()) {\n return;\n }\n\n const result = handleXhr(handlerData);\n\n addNetworkBreadcrumb(replay, result);\n };\n}\n\n/** Get the size of a body. */\nfunction getBodySize(\n body,\n textEncoder,\n) {\n if (!body) {\n return undefined;\n }\n\n try {\n if (typeof body === 'string') {\n return textEncoder.encode(body).length;\n }\n\n if (body instanceof URLSearchParams) {\n return textEncoder.encode(body.toString()).length;\n }\n\n if (body instanceof FormData) {\n const formDataStr = _serializeFormData(body);\n return textEncoder.encode(formDataStr).length;\n }\n\n if (body instanceof Blob) {\n return body.size;\n }\n\n if (body instanceof ArrayBuffer) {\n return body.byteLength;\n }\n\n // Currently unhandled types: ArrayBufferView, ReadableStream\n } catch (e) {\n // just return undefined\n }\n\n return undefined;\n}\n\n/** Convert a Content-Length header to number/undefined. */\nfunction parseContentLengthHeader(header) {\n if (!header) {\n return undefined;\n }\n\n const size = parseInt(header, 10);\n return isNaN(size) ? undefined : size;\n}\n\n/** Get the string representation of a body. */\nfunction getBodyString(body) {\n try {\n if (typeof body === 'string') {\n return [body];\n }\n\n if (body instanceof URLSearchParams) {\n return [body.toString()];\n }\n\n if (body instanceof FormData) {\n return [_serializeFormData(body)];\n }\n\n if (!body) {\n return [undefined];\n }\n } catch (e2) {\n DEBUG_BUILD && logger.warn('[Replay] Failed to serialize body', body);\n return [undefined, 'BODY_PARSE_ERROR'];\n }\n\n DEBUG_BUILD && logger.info('[Replay] Skipping network body because of body type', body);\n\n return [undefined, 'UNPARSEABLE_BODY_TYPE'];\n}\n\n/** Merge a warning into an existing network request/response. */\nfunction mergeWarning(\n info,\n warning,\n) {\n if (!info) {\n return {\n headers: {},\n size: undefined,\n _meta: {\n warnings: [warning],\n },\n };\n }\n\n const newMeta = { ...info._meta };\n const existingWarnings = newMeta.warnings || [];\n newMeta.warnings = [...existingWarnings, warning];\n\n info._meta = newMeta;\n return info;\n}\n\n/** Convert ReplayNetworkRequestData to a PerformanceEntry. */\nfunction makeNetworkReplayBreadcrumb(\n type,\n data,\n) {\n if (!data) {\n return null;\n }\n\n const { startTimestamp, endTimestamp, url, method, statusCode, request, response } = data;\n\n const result = {\n type,\n start: startTimestamp / 1000,\n end: endTimestamp / 1000,\n name: url,\n data: dropUndefinedKeys({\n method,\n statusCode,\n request,\n response,\n }),\n };\n\n return result;\n}\n\n/** Build the request or response part of a replay network breadcrumb that was skipped. */\nfunction buildSkippedNetworkRequestOrResponse(bodySize) {\n return {\n headers: {},\n size: bodySize,\n _meta: {\n warnings: ['URL_SKIPPED'],\n },\n };\n}\n\n/** Build the request or response part of a replay network breadcrumb. */\nfunction buildNetworkRequestOrResponse(\n headers,\n bodySize,\n body,\n) {\n if (!bodySize && Object.keys(headers).length === 0) {\n return undefined;\n }\n\n if (!bodySize) {\n return {\n headers,\n };\n }\n\n if (!body) {\n return {\n headers,\n size: bodySize,\n };\n }\n\n const info = {\n headers,\n size: bodySize,\n };\n\n const { body: normalizedBody, warnings } = normalizeNetworkBody(body);\n info.body = normalizedBody;\n if (warnings && warnings.length > 0) {\n info._meta = {\n warnings,\n };\n }\n\n return info;\n}\n\n/** Filter a set of headers */\nfunction getAllowedHeaders(headers, allowedHeaders) {\n return Object.keys(headers).reduce((filteredHeaders, key) => {\n const normalizedKey = key.toLowerCase();\n // Avoid putting empty strings into the headers\n if (allowedHeaders.includes(normalizedKey) && headers[key]) {\n filteredHeaders[normalizedKey] = headers[key];\n }\n return filteredHeaders;\n }, {});\n}\n\nfunction _serializeFormData(formData) {\n // This is a bit simplified, but gives us a decent estimate\n // This converts e.g. { name: 'Anne Smith', age: 13 } to 'name=Anne+Smith&age=13'\n // @ts-expect-error passing FormData to URLSearchParams actually works\n return new URLSearchParams(formData).toString();\n}\n\nfunction normalizeNetworkBody(body)\n\n {\n if (!body || typeof body !== 'string') {\n return {\n body,\n };\n }\n\n const exceedsSizeLimit = body.length > NETWORK_BODY_MAX_SIZE;\n const isProbablyJson = _strIsProbablyJson(body);\n\n if (exceedsSizeLimit) {\n const truncatedBody = body.slice(0, NETWORK_BODY_MAX_SIZE);\n\n if (isProbablyJson) {\n return {\n body: truncatedBody,\n warnings: ['MAYBE_JSON_TRUNCATED'],\n };\n }\n\n return {\n body: `${truncatedBody}…`,\n warnings: ['TEXT_TRUNCATED'],\n };\n }\n\n if (isProbablyJson) {\n try {\n const jsonBody = JSON.parse(body);\n return {\n body: jsonBody,\n };\n } catch (e3) {\n // fall back to just send the body as string\n }\n }\n\n return {\n body,\n };\n}\n\nfunction _strIsProbablyJson(str) {\n const first = str[0];\n const last = str[str.length - 1];\n\n // Simple check: If this does not start & end with {} or [], it's not JSON\n return (first === '[' && last === ']') || (first === '{' && last === '}');\n}\n\n/** Match an URL against a list of strings/Regex. */\nfunction urlMatches(url, urls) {\n const fullUrl = getFullUrl(url);\n\n return stringMatchesSomePattern(fullUrl, urls);\n}\n\n/** exported for tests */\nfunction getFullUrl(url, baseURI = WINDOW.document.baseURI) {\n // Short circuit for common cases:\n if (url.startsWith('http://') || url.startsWith('https://') || url.startsWith(WINDOW.location.origin)) {\n return url;\n }\n const fixedUrl = new URL(url, baseURI);\n\n // If these do not match, we are not dealing with a relative URL, so just return it\n if (fixedUrl.origin !== new URL(baseURI).origin) {\n return url;\n }\n\n const fullUrl = fixedUrl.href;\n\n // Remove trailing slashes, if they don't match the original URL\n if (!url.endsWith('/') && fullUrl.endsWith('/')) {\n return fullUrl.slice(0, -1);\n }\n\n return fullUrl;\n}\n\n/**\n * Capture a fetch breadcrumb to a replay.\n * This adds additional data (where approriate).\n */\nasync function captureFetchBreadcrumbToReplay(\n breadcrumb,\n hint,\n options\n\n,\n) {\n try {\n const data = await _prepareFetchData(breadcrumb, hint, options);\n\n // Create a replay performance entry from this breadcrumb\n const result = makeNetworkReplayBreadcrumb('resource.fetch', data);\n addNetworkBreadcrumb(options.replay, result);\n } catch (error) {\n DEBUG_BUILD && logger.error('[Replay] Failed to capture fetch breadcrumb', error);\n }\n}\n\n/**\n * Enrich a breadcrumb with additional data.\n * This has to be sync & mutate the given breadcrumb,\n * as the breadcrumb is afterwards consumed by other handlers.\n */\nfunction enrichFetchBreadcrumb(\n breadcrumb,\n hint,\n options,\n) {\n const { input, response } = hint;\n\n const body = input ? _getFetchRequestArgBody(input) : undefined;\n const reqSize = getBodySize(body, options.textEncoder);\n\n const resSize = response ? parseContentLengthHeader(response.headers.get('content-length')) : undefined;\n\n if (reqSize !== undefined) {\n breadcrumb.data.request_body_size = reqSize;\n }\n if (resSize !== undefined) {\n breadcrumb.data.response_body_size = resSize;\n }\n}\n\nasync function _prepareFetchData(\n breadcrumb,\n hint,\n options\n\n,\n) {\n const now = Date.now();\n const { startTimestamp = now, endTimestamp = now } = hint;\n\n const {\n url,\n method,\n status_code: statusCode = 0,\n request_body_size: requestBodySize,\n response_body_size: responseBodySize,\n } = breadcrumb.data;\n\n const captureDetails =\n urlMatches(url, options.networkDetailAllowUrls) && !urlMatches(url, options.networkDetailDenyUrls);\n\n const request = captureDetails\n ? _getRequestInfo(options, hint.input, requestBodySize)\n : buildSkippedNetworkRequestOrResponse(requestBodySize);\n const response = await _getResponseInfo(captureDetails, options, hint.response, responseBodySize);\n\n return {\n startTimestamp,\n endTimestamp,\n url,\n method,\n statusCode,\n request,\n response,\n };\n}\n\nfunction _getRequestInfo(\n { networkCaptureBodies, networkRequestHeaders },\n input,\n requestBodySize,\n) {\n const headers = input ? getRequestHeaders(input, networkRequestHeaders) : {};\n\n if (!networkCaptureBodies) {\n return buildNetworkRequestOrResponse(headers, requestBodySize, undefined);\n }\n\n // We only want to transmit string or string-like bodies\n const requestBody = _getFetchRequestArgBody(input);\n const [bodyStr, warning] = getBodyString(requestBody);\n const data = buildNetworkRequestOrResponse(headers, requestBodySize, bodyStr);\n\n if (warning) {\n return mergeWarning(data, warning);\n }\n\n return data;\n}\n\n/** Exported only for tests. */\nasync function _getResponseInfo(\n captureDetails,\n {\n networkCaptureBodies,\n textEncoder,\n networkResponseHeaders,\n }\n\n,\n response,\n responseBodySize,\n) {\n if (!captureDetails && responseBodySize !== undefined) {\n return buildSkippedNetworkRequestOrResponse(responseBodySize);\n }\n\n const headers = response ? getAllHeaders(response.headers, networkResponseHeaders) : {};\n\n if (!response || (!networkCaptureBodies && responseBodySize !== undefined)) {\n return buildNetworkRequestOrResponse(headers, responseBodySize, undefined);\n }\n\n const [bodyText, warning] = await _parseFetchResponseBody(response);\n const result = getResponseData(bodyText, {\n networkCaptureBodies,\n textEncoder,\n responseBodySize,\n captureDetails,\n headers,\n });\n\n if (warning) {\n return mergeWarning(result, warning);\n }\n\n return result;\n}\n\nfunction getResponseData(\n bodyText,\n {\n networkCaptureBodies,\n textEncoder,\n responseBodySize,\n captureDetails,\n headers,\n }\n\n,\n) {\n try {\n const size =\n bodyText && bodyText.length && responseBodySize === undefined\n ? getBodySize(bodyText, textEncoder)\n : responseBodySize;\n\n if (!captureDetails) {\n return buildSkippedNetworkRequestOrResponse(size);\n }\n\n if (networkCaptureBodies) {\n return buildNetworkRequestOrResponse(headers, size, bodyText);\n }\n\n return buildNetworkRequestOrResponse(headers, size, undefined);\n } catch (error) {\n DEBUG_BUILD && logger.warn('[Replay] Failed to serialize response body', error);\n // fallback\n return buildNetworkRequestOrResponse(headers, responseBodySize, undefined);\n }\n}\n\nasync function _parseFetchResponseBody(response) {\n const res = _tryCloneResponse(response);\n\n if (!res) {\n return [undefined, 'BODY_PARSE_ERROR'];\n }\n\n try {\n const text = await _tryGetResponseText(res);\n return [text];\n } catch (error) {\n DEBUG_BUILD && logger.warn('[Replay] Failed to get text body from response', error);\n return [undefined, 'BODY_PARSE_ERROR'];\n }\n}\n\nfunction _getFetchRequestArgBody(fetchArgs = []) {\n // We only support getting the body from the fetch options\n if (fetchArgs.length !== 2 || typeof fetchArgs[1] !== 'object') {\n return undefined;\n }\n\n return (fetchArgs[1] ).body;\n}\n\nfunction getAllHeaders(headers, allowedHeaders) {\n const allHeaders = {};\n\n allowedHeaders.forEach(header => {\n if (headers.get(header)) {\n allHeaders[header] = headers.get(header) ;\n }\n });\n\n return allHeaders;\n}\n\nfunction getRequestHeaders(fetchArgs, allowedHeaders) {\n if (fetchArgs.length === 1 && typeof fetchArgs[0] !== 'string') {\n return getHeadersFromOptions(fetchArgs[0] , allowedHeaders);\n }\n\n if (fetchArgs.length === 2) {\n return getHeadersFromOptions(fetchArgs[1] , allowedHeaders);\n }\n\n return {};\n}\n\nfunction getHeadersFromOptions(\n input,\n allowedHeaders,\n) {\n if (!input) {\n return {};\n }\n\n const headers = input.headers;\n\n if (!headers) {\n return {};\n }\n\n if (headers instanceof Headers) {\n return getAllHeaders(headers, allowedHeaders);\n }\n\n // We do not support this, as it is not really documented (anymore?)\n if (Array.isArray(headers)) {\n return {};\n }\n\n return getAllowedHeaders(headers, allowedHeaders);\n}\n\nfunction _tryCloneResponse(response) {\n try {\n // We have to clone this, as the body can only be read once\n return response.clone();\n } catch (error) {\n // this can throw if the response was already consumed before\n DEBUG_BUILD && logger.warn('[Replay] Failed to clone response body', error);\n }\n}\n\n/**\n * Get the response body of a fetch request, or timeout after 500ms.\n * Fetch can return a streaming body, that may not resolve (or not for a long time).\n * If that happens, we rather abort after a short time than keep waiting for this.\n */\nfunction _tryGetResponseText(response) {\n return new Promise((resolve, reject) => {\n const timeout = setTimeout(() => reject(new Error('Timeout while trying to read response body')), 500);\n\n _getResponseText(response)\n .then(\n txt => resolve(txt),\n reason => reject(reason),\n )\n .finally(() => clearTimeout(timeout));\n });\n}\n\nasync function _getResponseText(response) {\n // Force this to be a promise, just to be safe\n // eslint-disable-next-line no-return-await\n return await response.text();\n}\n\n/**\n * Capture an XHR breadcrumb to a replay.\n * This adds additional data (where approriate).\n */\nasync function captureXhrBreadcrumbToReplay(\n breadcrumb,\n hint,\n options,\n) {\n try {\n const data = _prepareXhrData(breadcrumb, hint, options);\n\n // Create a replay performance entry from this breadcrumb\n const result = makeNetworkReplayBreadcrumb('resource.xhr', data);\n addNetworkBreadcrumb(options.replay, result);\n } catch (error) {\n DEBUG_BUILD && logger.error('[Replay] Failed to capture xhr breadcrumb', error);\n }\n}\n\n/**\n * Enrich a breadcrumb with additional data.\n * This has to be sync & mutate the given breadcrumb,\n * as the breadcrumb is afterwards consumed by other handlers.\n */\nfunction enrichXhrBreadcrumb(\n breadcrumb,\n hint,\n options,\n) {\n const { xhr, input } = hint;\n\n if (!xhr) {\n return;\n }\n\n const reqSize = getBodySize(input, options.textEncoder);\n const resSize = xhr.getResponseHeader('content-length')\n ? parseContentLengthHeader(xhr.getResponseHeader('content-length'))\n : _getBodySize(xhr.response, xhr.responseType, options.textEncoder);\n\n if (reqSize !== undefined) {\n breadcrumb.data.request_body_size = reqSize;\n }\n if (resSize !== undefined) {\n breadcrumb.data.response_body_size = resSize;\n }\n}\n\nfunction _prepareXhrData(\n breadcrumb,\n hint,\n options,\n) {\n const now = Date.now();\n const { startTimestamp = now, endTimestamp = now, input, xhr } = hint;\n\n const {\n url,\n method,\n status_code: statusCode = 0,\n request_body_size: requestBodySize,\n response_body_size: responseBodySize,\n } = breadcrumb.data;\n\n if (!url) {\n return null;\n }\n\n if (!xhr || !urlMatches(url, options.networkDetailAllowUrls) || urlMatches(url, options.networkDetailDenyUrls)) {\n const request = buildSkippedNetworkRequestOrResponse(requestBodySize);\n const response = buildSkippedNetworkRequestOrResponse(responseBodySize);\n return {\n startTimestamp,\n endTimestamp,\n url,\n method,\n statusCode,\n request,\n response,\n };\n }\n\n const xhrInfo = xhr[SENTRY_XHR_DATA_KEY];\n const networkRequestHeaders = xhrInfo\n ? getAllowedHeaders(xhrInfo.request_headers, options.networkRequestHeaders)\n : {};\n const networkResponseHeaders = getAllowedHeaders(getResponseHeaders(xhr), options.networkResponseHeaders);\n\n const [requestBody, requestWarning] = options.networkCaptureBodies ? getBodyString(input) : [undefined];\n const [responseBody, responseWarning] = options.networkCaptureBodies ? _getXhrResponseBody(xhr) : [undefined];\n\n const request = buildNetworkRequestOrResponse(networkRequestHeaders, requestBodySize, requestBody);\n const response = buildNetworkRequestOrResponse(networkResponseHeaders, responseBodySize, responseBody);\n\n return {\n startTimestamp,\n endTimestamp,\n url,\n method,\n statusCode,\n request: requestWarning ? mergeWarning(request, requestWarning) : request,\n response: responseWarning ? mergeWarning(response, responseWarning) : response,\n };\n}\n\nfunction getResponseHeaders(xhr) {\n const headers = xhr.getAllResponseHeaders();\n\n if (!headers) {\n return {};\n }\n\n return headers.split('\\r\\n').reduce((acc, line) => {\n const [key, value] = line.split(': ');\n acc[key.toLowerCase()] = value;\n return acc;\n }, {});\n}\n\nfunction _getXhrResponseBody(xhr) {\n // We collect errors that happen, but only log them if we can't get any response body\n const errors = [];\n\n try {\n return [xhr.responseText];\n } catch (e) {\n errors.push(e);\n }\n\n // Try to manually parse the response body, if responseText fails\n try {\n return _parseXhrResponse(xhr.response, xhr.responseType);\n } catch (e) {\n errors.push(e);\n }\n\n DEBUG_BUILD && logger.warn('[Replay] Failed to get xhr response body', ...errors);\n\n return [undefined];\n}\n\n/**\n * Get the string representation of the XHR response.\n * Based on MDN, these are the possible types of the response:\n * string\n * ArrayBuffer\n * Blob\n * Document\n * POJO\n *\n * Exported only for tests.\n */\nfunction _parseXhrResponse(\n body,\n responseType,\n) {\n try {\n if (typeof body === 'string') {\n return [body];\n }\n\n if (body instanceof Document) {\n return [body.body.outerHTML];\n }\n\n if (responseType === 'json' && body && typeof body === 'object') {\n return [JSON.stringify(body)];\n }\n\n if (!body) {\n return [undefined];\n }\n } catch (e2) {\n DEBUG_BUILD && logger.warn('[Replay] Failed to serialize body', body);\n return [undefined, 'BODY_PARSE_ERROR'];\n }\n\n DEBUG_BUILD && logger.info('[Replay] Skipping network body because of body type', body);\n\n return [undefined, 'UNPARSEABLE_BODY_TYPE'];\n}\n\nfunction _getBodySize(\n body,\n responseType,\n textEncoder,\n) {\n try {\n const bodyStr = responseType === 'json' && body && typeof body === 'object' ? JSON.stringify(body) : body;\n return getBodySize(bodyStr, textEncoder);\n } catch (e3) {\n return undefined;\n }\n}\n\n/**\n * This method does two things:\n * - It enriches the regular XHR/fetch breadcrumbs with request/response size data\n * - It captures the XHR/fetch breadcrumbs to the replay\n * (enriching it with further data that is _not_ added to the regular breadcrumbs)\n */\nfunction handleNetworkBreadcrumbs(replay) {\n const client = getClient();\n\n try {\n const textEncoder = new TextEncoder();\n\n const {\n networkDetailAllowUrls,\n networkDetailDenyUrls,\n networkCaptureBodies,\n networkRequestHeaders,\n networkResponseHeaders,\n } = replay.getOptions();\n\n const options = {\n replay,\n textEncoder,\n networkDetailAllowUrls,\n networkDetailDenyUrls,\n networkCaptureBodies,\n networkRequestHeaders,\n networkResponseHeaders,\n };\n\n if (client && client.on) {\n client.on('beforeAddBreadcrumb', (breadcrumb, hint) => beforeAddNetworkBreadcrumb(options, breadcrumb, hint));\n } else {\n // Fallback behavior\n addFetchInstrumentationHandler(handleFetchSpanListener(replay));\n addXhrInstrumentationHandler(handleXhrSpanListener(replay));\n }\n } catch (e2) {\n // Do nothing\n }\n}\n\n/** just exported for tests */\nfunction beforeAddNetworkBreadcrumb(\n options,\n breadcrumb,\n hint,\n) {\n if (!breadcrumb.data) {\n return;\n }\n\n try {\n if (_isXhrBreadcrumb(breadcrumb) && _isXhrHint(hint)) {\n // This has to be sync, as we need to ensure the breadcrumb is enriched in the same tick\n // Because the hook runs synchronously, and the breadcrumb is afterwards passed on\n // So any async mutations to it will not be reflected in the final breadcrumb\n enrichXhrBreadcrumb(breadcrumb, hint, options);\n\n // This call should not reject\n // eslint-disable-next-line @typescript-eslint/no-floating-promises\n captureXhrBreadcrumbToReplay(breadcrumb, hint, options);\n }\n\n if (_isFetchBreadcrumb(breadcrumb) && _isFetchHint(hint)) {\n // This has to be sync, as we need to ensure the breadcrumb is enriched in the same tick\n // Because the hook runs synchronously, and the breadcrumb is afterwards passed on\n // So any async mutations to it will not be reflected in the final breadcrumb\n enrichFetchBreadcrumb(breadcrumb, hint, options);\n\n // This call should not reject\n // eslint-disable-next-line @typescript-eslint/no-floating-promises\n captureFetchBreadcrumbToReplay(breadcrumb, hint, options);\n }\n } catch (e) {\n DEBUG_BUILD && logger.warn('Error when enriching network breadcrumb');\n }\n}\n\nfunction _isXhrBreadcrumb(breadcrumb) {\n return breadcrumb.category === 'xhr';\n}\n\nfunction _isFetchBreadcrumb(breadcrumb) {\n return breadcrumb.category === 'fetch';\n}\n\nfunction _isXhrHint(hint) {\n return hint && hint.xhr;\n}\n\nfunction _isFetchHint(hint) {\n return hint && hint.response;\n}\n\nlet _LAST_BREADCRUMB = null;\n\nfunction isBreadcrumbWithCategory(breadcrumb) {\n return !!breadcrumb.category;\n}\n\nconst handleScopeListener =\n (replay) =>\n (scope) => {\n if (!replay.isEnabled()) {\n return;\n }\n\n const result = handleScope(scope);\n\n if (!result) {\n return;\n }\n\n addBreadcrumbEvent(replay, result);\n };\n\n/**\n * An event handler to handle scope changes.\n */\nfunction handleScope(scope) {\n // TODO (v8): Remove this guard. This was put in place because we introduced\n // Scope.getLastBreadcrumb mid-v7 which caused incompatibilities with older SDKs.\n // For now, we'll just return null if the method doesn't exist but we should eventually\n // get rid of this guard.\n const newBreadcrumb = scope.getLastBreadcrumb && scope.getLastBreadcrumb();\n\n // Listener can be called when breadcrumbs have not changed, so we store the\n // reference to the last crumb and only return a crumb if it has changed\n if (_LAST_BREADCRUMB === newBreadcrumb || !newBreadcrumb) {\n return null;\n }\n\n _LAST_BREADCRUMB = newBreadcrumb;\n\n if (\n !isBreadcrumbWithCategory(newBreadcrumb) ||\n ['fetch', 'xhr', 'sentry.event', 'sentry.transaction'].includes(newBreadcrumb.category) ||\n newBreadcrumb.category.startsWith('ui.')\n ) {\n return null;\n }\n\n if (newBreadcrumb.category === 'console') {\n return normalizeConsoleBreadcrumb(newBreadcrumb);\n }\n\n return createBreadcrumb(newBreadcrumb);\n}\n\n/** exported for tests only */\nfunction normalizeConsoleBreadcrumb(\n breadcrumb,\n) {\n const args = breadcrumb.data && breadcrumb.data.arguments;\n\n if (!Array.isArray(args) || args.length === 0) {\n return createBreadcrumb(breadcrumb);\n }\n\n let isTruncated = false;\n\n // Avoid giant args captures\n const normalizedArgs = args.map(arg => {\n if (!arg) {\n return arg;\n }\n if (typeof arg === 'string') {\n if (arg.length > CONSOLE_ARG_MAX_SIZE) {\n isTruncated = true;\n return `${arg.slice(0, CONSOLE_ARG_MAX_SIZE)}…`;\n }\n\n return arg;\n }\n if (typeof arg === 'object') {\n try {\n const normalizedArg = normalize(arg, 7);\n const stringified = JSON.stringify(normalizedArg);\n if (stringified.length > CONSOLE_ARG_MAX_SIZE) {\n isTruncated = true;\n // We use the pretty printed JSON string here as a base\n return `${JSON.stringify(normalizedArg, null, 2).slice(0, CONSOLE_ARG_MAX_SIZE)}…`;\n }\n return normalizedArg;\n } catch (e) {\n // fall back to default\n }\n }\n\n return arg;\n });\n\n return createBreadcrumb({\n ...breadcrumb,\n data: {\n ...breadcrumb.data,\n arguments: normalizedArgs,\n ...(isTruncated ? { _meta: { warnings: ['CONSOLE_ARG_TRUNCATED'] } } : {}),\n },\n });\n}\n\n/**\n * Add global listeners that cannot be removed.\n */\nfunction addGlobalListeners(replay) {\n // Listeners from core SDK //\n const scope = getCurrentScope();\n const client = getClient();\n\n scope.addScopeListener(handleScopeListener(replay));\n addClickKeypressInstrumentationHandler(handleDomListener(replay));\n addHistoryInstrumentationHandler(handleHistorySpanListener(replay));\n handleNetworkBreadcrumbs(replay);\n\n // Tag all (non replay) events that get sent to Sentry with the current\n // replay ID so that we can reference them later in the UI\n const eventProcessor = handleGlobalEventListener(replay, !hasHooks(client));\n if (client && client.addEventProcessor) {\n client.addEventProcessor(eventProcessor);\n } else {\n addEventProcessor(eventProcessor);\n }\n\n // If a custom client has no hooks yet, we continue to use the \"old\" implementation\n if (hasHooks(client)) {\n client.on('beforeSendEvent', handleBeforeSendEvent(replay));\n client.on('afterSendEvent', handleAfterSendEvent(replay));\n client.on('createDsc', (dsc) => {\n const replayId = replay.getSessionId();\n // We do not want to set the DSC when in buffer mode, as that means the replay has not been sent (yet)\n if (replayId && replay.isEnabled() && replay.recordingMode === 'session') {\n // Ensure to check that the session is still active - it could have expired in the meanwhile\n const isSessionActive = replay.checkAndHandleExpiredSession();\n if (isSessionActive) {\n dsc.replay_id = replayId;\n }\n }\n });\n\n client.on('startTransaction', transaction => {\n replay.lastTransaction = transaction;\n });\n\n // We may be missing the initial startTransaction due to timing issues,\n // so we capture it on finish again.\n client.on('finishTransaction', transaction => {\n replay.lastTransaction = transaction;\n });\n\n // We want to flush replay\n client.on('beforeSendFeedback', (feedbackEvent, options) => {\n const replayId = replay.getSessionId();\n if (options && options.includeReplay && replay.isEnabled() && replayId) {\n // This should never reject\n if (feedbackEvent.contexts && feedbackEvent.contexts.feedback) {\n feedbackEvent.contexts.feedback.replay_id = replayId;\n }\n }\n });\n }\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction hasHooks(client) {\n return !!(client && client.on);\n}\n\n/**\n * Create a \"span\" for the total amount of memory being used by JS objects\n * (including v8 internal objects).\n */\nasync function addMemoryEntry(replay) {\n // window.performance.memory is a non-standard API and doesn't work on all browsers, so we try-catch this\n try {\n return Promise.all(\n createPerformanceSpans(replay, [\n // @ts-expect-error memory doesn't exist on type Performance as the API is non-standard (we check that it exists above)\n createMemoryEntry(WINDOW.performance.memory),\n ]),\n );\n } catch (error) {\n // Do nothing\n return [];\n }\n}\n\nfunction createMemoryEntry(memoryEntry) {\n const { jsHeapSizeLimit, totalJSHeapSize, usedJSHeapSize } = memoryEntry;\n // we don't want to use `getAbsoluteTime` because it adds the event time to the\n // time origin, so we get the current timestamp instead\n const time = Date.now() / 1000;\n return {\n type: 'memory',\n name: 'memory',\n start: time,\n end: time,\n data: {\n memory: {\n jsHeapSizeLimit,\n totalJSHeapSize,\n usedJSHeapSize,\n },\n },\n };\n}\n\n/**\n * Heavily simplified debounce function based on lodash.debounce.\n *\n * This function takes a callback function (@param fun) and delays its invocation\n * by @param wait milliseconds. Optionally, a maxWait can be specified in @param options,\n * which ensures that the callback is invoked at least once after the specified max. wait time.\n *\n * @param func the function whose invocation is to be debounced\n * @param wait the minimum time until the function is invoked after it was called once\n * @param options the options object, which can contain the `maxWait` property\n *\n * @returns the debounced version of the function, which needs to be called at least once to start the\n * debouncing process. Subsequent calls will reset the debouncing timer and, in case @paramfunc\n * was already invoked in the meantime, return @param func's return value.\n * The debounced function has two additional properties:\n * - `flush`: Invokes the debounced function immediately and returns its return value\n * - `cancel`: Cancels the debouncing process and resets the debouncing timer\n */\nfunction debounce(func, wait, options) {\n let callbackReturnValue;\n\n let timerId;\n let maxTimerId;\n\n const maxWait = options && options.maxWait ? Math.max(options.maxWait, wait) : 0;\n\n function invokeFunc() {\n cancelTimers();\n callbackReturnValue = func();\n return callbackReturnValue;\n }\n\n function cancelTimers() {\n timerId !== undefined && clearTimeout(timerId);\n maxTimerId !== undefined && clearTimeout(maxTimerId);\n timerId = maxTimerId = undefined;\n }\n\n function flush() {\n if (timerId !== undefined || maxTimerId !== undefined) {\n return invokeFunc();\n }\n return callbackReturnValue;\n }\n\n function debounced() {\n if (timerId) {\n clearTimeout(timerId);\n }\n timerId = setTimeout(invokeFunc, wait);\n\n if (maxWait && maxTimerId === undefined) {\n maxTimerId = setTimeout(invokeFunc, maxWait);\n }\n\n return callbackReturnValue;\n }\n\n debounced.cancel = cancelTimers;\n debounced.flush = flush;\n return debounced;\n}\n\n/**\n * Handler for recording events.\n *\n * Adds to event buffer, and has varying flushing behaviors if the event was a checkout.\n */\nfunction getHandleRecordingEmit(replay) {\n let hadFirstEvent = false;\n\n return (event, _isCheckout) => {\n // If this is false, it means session is expired, create and a new session and wait for checkout\n if (!replay.checkAndHandleExpiredSession()) {\n DEBUG_BUILD && logger.warn('[Replay] Received replay event after session expired.');\n\n return;\n }\n\n // `_isCheckout` is only set when the checkout is due to `checkoutEveryNms`\n // We also want to treat the first event as a checkout, so we handle this specifically here\n const isCheckout = _isCheckout || !hadFirstEvent;\n hadFirstEvent = true;\n\n if (replay.clickDetector) {\n updateClickDetectorForRecordingEvent(replay.clickDetector, event);\n }\n\n // The handler returns `true` if we do not want to trigger debounced flush, `false` if we want to debounce flush.\n replay.addUpdate(() => {\n // The session is always started immediately on pageload/init, but for\n // error-only replays, it should reflect the most recent checkout\n // when an error occurs. Clear any state that happens before this current\n // checkout. This needs to happen before `addEvent()` which updates state\n // dependent on this reset.\n if (replay.recordingMode === 'buffer' && isCheckout) {\n replay.setInitialState();\n }\n\n // If the event is not added (e.g. due to being paused, disabled, or out of the max replay duration),\n // Skip all further steps\n if (!addEventSync(replay, event, isCheckout)) {\n // Return true to skip scheduling a debounced flush\n return true;\n }\n\n // Different behavior for full snapshots (type=2), ignore other event types\n // See https://github.com/rrweb-io/rrweb/blob/d8f9290ca496712aa1e7d472549480c4e7876594/packages/rrweb/src/types.ts#L16\n if (!isCheckout) {\n return false;\n }\n\n // Additionally, create a meta event that will capture certain SDK settings.\n // In order to handle buffer mode, this needs to either be done when we\n // receive checkout events or at flush time.\n //\n // `isCheckout` is always true, but want to be explicit that it should\n // only be added for checkouts\n addSettingsEvent(replay, isCheckout);\n\n // If there is a previousSessionId after a full snapshot occurs, then\n // the replay session was started due to session expiration. The new session\n // is started before triggering a new checkout and contains the id\n // of the previous session. Do not immediately flush in this case\n // to avoid capturing only the checkout and instead the replay will\n // be captured if they perform any follow-up actions.\n if (replay.session && replay.session.previousSessionId) {\n return true;\n }\n\n // When in buffer mode, make sure we adjust the session started date to the current earliest event of the buffer\n // this should usually be the timestamp of the checkout event, but to be safe...\n if (replay.recordingMode === 'buffer' && replay.session && replay.eventBuffer) {\n const earliestEvent = replay.eventBuffer.getEarliestTimestamp();\n if (earliestEvent) {\n logInfo(\n `[Replay] Updating session start time to earliest event in buffer to ${new Date(earliestEvent)}`,\n replay.getOptions()._experiments.traceInternals,\n );\n\n replay.session.started = earliestEvent;\n\n if (replay.getOptions().stickySession) {\n saveSession(replay.session);\n }\n }\n }\n\n if (replay.recordingMode === 'session') {\n // If the full snapshot is due to an initial load, we will not have\n // a previous session ID. In this case, we want to buffer events\n // for a set amount of time before flushing. This can help avoid\n // capturing replays of users that immediately close the window.\n\n // This should never reject\n // eslint-disable-next-line @typescript-eslint/no-floating-promises\n void replay.flush();\n }\n\n return true;\n });\n };\n}\n\n/**\n * Exported for tests\n */\nfunction createOptionsEvent(replay) {\n const options = replay.getOptions();\n return {\n type: EventType.Custom,\n timestamp: Date.now(),\n data: {\n tag: 'options',\n payload: {\n shouldRecordCanvas: replay.isRecordingCanvas(),\n sessionSampleRate: options.sessionSampleRate,\n errorSampleRate: options.errorSampleRate,\n useCompressionOption: options.useCompression,\n blockAllMedia: options.blockAllMedia,\n maskAllText: options.maskAllText,\n maskAllInputs: options.maskAllInputs,\n useCompression: replay.eventBuffer ? replay.eventBuffer.type === 'worker' : false,\n networkDetailHasUrls: options.networkDetailAllowUrls.length > 0,\n networkCaptureBodies: options.networkCaptureBodies,\n networkRequestHasHeaders: options.networkRequestHeaders.length > 0,\n networkResponseHasHeaders: options.networkResponseHeaders.length > 0,\n },\n },\n };\n}\n\n/**\n * Add a \"meta\" event that contains a simplified view on current configuration\n * options. This should only be included on the first segment of a recording.\n */\nfunction addSettingsEvent(replay, isCheckout) {\n // Only need to add this event when sending the first segment\n if (!isCheckout || !replay.session || replay.session.segmentId !== 0) {\n return;\n }\n\n addEventSync(replay, createOptionsEvent(replay), false);\n}\n\n/**\n * Create a replay envelope ready to be sent.\n * This includes both the replay event, as well as the recording data.\n */\nfunction createReplayEnvelope(\n replayEvent,\n recordingData,\n dsn,\n tunnel,\n) {\n return createEnvelope(\n createEventEnvelopeHeaders(replayEvent, getSdkMetadataForEnvelopeHeader(replayEvent), tunnel, dsn),\n [\n [{ type: 'replay_event' }, replayEvent],\n [\n {\n type: 'replay_recording',\n // If string then we need to encode to UTF8, otherwise will have\n // wrong size. TextEncoder has similar browser support to\n // MutationObserver, although it does not accept IE11.\n length:\n typeof recordingData === 'string' ? new TextEncoder().encode(recordingData).length : recordingData.length,\n },\n recordingData,\n ],\n ],\n );\n}\n\n/**\n * Prepare the recording data ready to be sent.\n */\nfunction prepareRecordingData({\n recordingData,\n headers,\n}\n\n) {\n let payloadWithSequence;\n\n // XXX: newline is needed to separate sequence id from events\n const replayHeaders = `${JSON.stringify(headers)}\n`;\n\n if (typeof recordingData === 'string') {\n payloadWithSequence = `${replayHeaders}${recordingData}`;\n } else {\n const enc = new TextEncoder();\n // XXX: newline is needed to separate sequence id from events\n const sequence = enc.encode(replayHeaders);\n // Merge the two Uint8Arrays\n payloadWithSequence = new Uint8Array(sequence.length + recordingData.length);\n payloadWithSequence.set(sequence);\n payloadWithSequence.set(recordingData, sequence.length);\n }\n\n return payloadWithSequence;\n}\n\n/**\n * Prepare a replay event & enrich it with the SDK metadata.\n */\nasync function prepareReplayEvent({\n client,\n scope,\n replayId: event_id,\n event,\n}\n\n) {\n const integrations =\n typeof client._integrations === 'object' && client._integrations !== null && !Array.isArray(client._integrations)\n ? Object.keys(client._integrations)\n : undefined;\n\n const eventHint = { event_id, integrations };\n\n if (client.emit) {\n client.emit('preprocessEvent', event, eventHint);\n }\n\n const preparedEvent = (await prepareEvent(\n client.getOptions(),\n event,\n eventHint,\n scope,\n client,\n getIsolationScope(),\n )) ;\n\n // If e.g. a global event processor returned null\n if (!preparedEvent) {\n return null;\n }\n\n // This normally happens in browser client \"_prepareEvent\"\n // but since we do not use this private method from the client, but rather the plain import\n // we need to do this manually.\n preparedEvent.platform = preparedEvent.platform || 'javascript';\n\n // extract the SDK name because `client._prepareEvent` doesn't add it to the event\n const metadata = client.getSdkMetadata && client.getSdkMetadata();\n const { name, version } = (metadata && metadata.sdk) || {};\n\n preparedEvent.sdk = {\n ...preparedEvent.sdk,\n name: name || 'sentry.javascript.unknown',\n version: version || '0.0.0',\n };\n\n return preparedEvent;\n}\n\n/**\n * Send replay attachment using `fetch()`\n */\nasync function sendReplayRequest({\n recordingData,\n replayId,\n segmentId: segment_id,\n eventContext,\n timestamp,\n session,\n}) {\n const preparedRecordingData = prepareRecordingData({\n recordingData,\n headers: {\n segment_id,\n },\n });\n\n const { urls, errorIds, traceIds, initialTimestamp } = eventContext;\n\n const client = getClient();\n const scope = getCurrentScope();\n const transport = client && client.getTransport();\n const dsn = client && client.getDsn();\n\n if (!client || !transport || !dsn || !session.sampled) {\n return;\n }\n\n const baseEvent = {\n type: REPLAY_EVENT_NAME,\n replay_start_timestamp: initialTimestamp / 1000,\n timestamp: timestamp / 1000,\n error_ids: errorIds,\n trace_ids: traceIds,\n urls,\n replay_id: replayId,\n segment_id,\n replay_type: session.sampled,\n };\n\n const replayEvent = await prepareReplayEvent({ scope, client, replayId, event: baseEvent });\n\n if (!replayEvent) {\n // Taken from baseclient's `_processEvent` method, where this is handled for errors/transactions\n client.recordDroppedEvent('event_processor', 'replay', baseEvent);\n logInfo('An event processor returned `null`, will not send event.');\n return;\n }\n\n /*\n For reference, the fully built event looks something like this:\n {\n \"type\": \"replay_event\",\n \"timestamp\": 1670837008.634,\n \"error_ids\": [\n \"errorId\"\n ],\n \"trace_ids\": [\n \"traceId\"\n ],\n \"urls\": [\n \"https://example.com\"\n ],\n \"replay_id\": \"eventId\",\n \"segment_id\": 3,\n \"replay_type\": \"error\",\n \"platform\": \"javascript\",\n \"event_id\": \"eventId\",\n \"environment\": \"production\",\n \"sdk\": {\n \"integrations\": [\n \"BrowserTracing\",\n \"Replay\"\n ],\n \"name\": \"sentry.javascript.browser\",\n \"version\": \"7.25.0\"\n },\n \"sdkProcessingMetadata\": {},\n \"contexts\": {\n },\n }\n */\n\n // Prevent this data (which, if it exists, was used in earlier steps in the processing pipeline) from being sent to\n // sentry. (Note: Our use of this property comes and goes with whatever we might be debugging, whatever hacks we may\n // have temporarily added, etc. Even if we don't happen to be using it at some point in the future, let's not get rid\n // of this `delete`, lest we miss putting it back in the next time the property is in use.)\n delete replayEvent.sdkProcessingMetadata;\n\n const envelope = createReplayEnvelope(replayEvent, preparedRecordingData, dsn, client.getOptions().tunnel);\n\n let response;\n\n try {\n response = await transport.send(envelope);\n } catch (err) {\n const error = new Error(UNABLE_TO_SEND_REPLAY);\n\n try {\n // In case browsers don't allow this property to be writable\n // @ts-expect-error This needs lib es2022 and newer\n error.cause = err;\n } catch (e) {\n // nothing to do\n }\n throw error;\n }\n\n // TODO (v8): we can remove this guard once transport.send's type signature doesn't include void anymore\n if (!response) {\n return response;\n }\n\n // If the status code is invalid, we want to immediately stop & not retry\n if (typeof response.statusCode === 'number' && (response.statusCode < 200 || response.statusCode >= 300)) {\n throw new TransportStatusCodeError(response.statusCode);\n }\n\n const rateLimits = updateRateLimits({}, response);\n if (isRateLimited(rateLimits, 'replay')) {\n throw new RateLimitError(rateLimits);\n }\n\n return response;\n}\n\n/**\n * This error indicates that the transport returned an invalid status code.\n */\nclass TransportStatusCodeError extends Error {\n constructor(statusCode) {\n super(`Transport returned status code ${statusCode}`);\n }\n}\n\n/**\n * This error indicates that we hit a rate limit API error.\n */\nclass RateLimitError extends Error {\n\n constructor(rateLimits) {\n super('Rate limit hit');\n this.rateLimits = rateLimits;\n }\n}\n\n/**\n * Finalize and send the current replay event to Sentry\n */\nasync function sendReplay(\n replayData,\n retryConfig = {\n count: 0,\n interval: RETRY_BASE_INTERVAL,\n },\n) {\n const { recordingData, options } = replayData;\n\n // short circuit if there's no events to upload (this shouldn't happen as _runFlush makes this check)\n if (!recordingData.length) {\n return;\n }\n\n try {\n await sendReplayRequest(replayData);\n return true;\n } catch (err) {\n if (err instanceof TransportStatusCodeError || err instanceof RateLimitError) {\n throw err;\n }\n\n // Capture error for every failed replay\n setContext('Replays', {\n _retryCount: retryConfig.count,\n });\n\n if (DEBUG_BUILD && options._experiments && options._experiments.captureExceptions) {\n captureException(err);\n }\n\n // If an error happened here, it's likely that uploading the attachment\n // failed, we'll can retry with the same events payload\n if (retryConfig.count >= RETRY_MAX_COUNT) {\n const error = new Error(`${UNABLE_TO_SEND_REPLAY} - max retries exceeded`);\n\n try {\n // In case browsers don't allow this property to be writable\n // @ts-expect-error This needs lib es2022 and newer\n error.cause = err;\n } catch (e) {\n // nothing to do\n }\n\n throw error;\n }\n\n // will retry in intervals of 5, 10, 30\n retryConfig.interval *= ++retryConfig.count;\n\n return new Promise((resolve, reject) => {\n setTimeout(async () => {\n try {\n await sendReplay(replayData, retryConfig);\n resolve(true);\n } catch (err) {\n reject(err);\n }\n }, retryConfig.interval);\n });\n }\n}\n\nconst THROTTLED = '__THROTTLED';\nconst SKIPPED = '__SKIPPED';\n\n/**\n * Create a throttled function off a given function.\n * When calling the throttled function, it will call the original function only\n * if it hasn't been called more than `maxCount` times in the last `durationSeconds`.\n *\n * Returns `THROTTLED` if throttled for the first time, after that `SKIPPED`,\n * or else the return value of the original function.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction throttle(\n fn,\n maxCount,\n durationSeconds,\n) {\n const counter = new Map();\n\n const _cleanup = (now) => {\n const threshold = now - durationSeconds;\n counter.forEach((_value, key) => {\n if (key < threshold) {\n counter.delete(key);\n }\n });\n };\n\n const _getTotalCount = () => {\n return [...counter.values()].reduce((a, b) => a + b, 0);\n };\n\n let isThrottled = false;\n\n return (...rest) => {\n // Date in second-precision, which we use as basis for the throttling\n const now = Math.floor(Date.now() / 1000);\n\n // First, make sure to delete any old entries\n _cleanup(now);\n\n // If already over limit, do nothing\n if (_getTotalCount() >= maxCount) {\n const wasThrottled = isThrottled;\n isThrottled = true;\n return wasThrottled ? SKIPPED : THROTTLED;\n }\n\n isThrottled = false;\n const count = counter.get(now) || 0;\n counter.set(now, count + 1);\n\n return fn(...rest);\n };\n}\n\n/* eslint-disable max-lines */ // TODO: We might want to split this file up\n\n/**\n * The main replay container class, which holds all the state and methods for recording and sending replays.\n */\nclass ReplayContainer {\n\n /**\n * Recording can happen in one of three modes:\n * - session: Record the whole session, sending it continuously\n * - buffer: Always keep the last 60s of recording, requires:\n * - having replaysOnErrorSampleRate > 0 to capture replay when an error occurs\n * - or calling `flush()` to send the replay\n */\n\n /**\n * The current or last active transcation.\n * This is only available when performance is enabled.\n */\n\n /**\n * These are here so we can overwrite them in tests etc.\n * @hidden\n */\n\n /**\n * Options to pass to `rrweb.record()`\n */\n\n /**\n * Timestamp of the last user activity. This lives across sessions.\n */\n\n /**\n * Is the integration currently active?\n */\n\n /**\n * Paused is a state where:\n * - DOM Recording is not listening at all\n * - Nothing will be added to event buffer (e.g. core SDK events)\n */\n\n /**\n * Have we attached listeners to the core SDK?\n * Note we have to track this as there is no way to remove instrumentation handlers.\n */\n\n /**\n * Function to stop recording\n */\n\n /**\n * Internal use for canvas recording options\n */\n\n constructor({\n options,\n recordingOptions,\n }\n\n) {ReplayContainer.prototype.__init.call(this);ReplayContainer.prototype.__init2.call(this);ReplayContainer.prototype.__init3.call(this);ReplayContainer.prototype.__init4.call(this);ReplayContainer.prototype.__init5.call(this);ReplayContainer.prototype.__init6.call(this);\n this.eventBuffer = null;\n this.performanceEntries = [];\n this.replayPerformanceEntries = [];\n this.recordingMode = 'session';\n this.timeouts = {\n sessionIdlePause: SESSION_IDLE_PAUSE_DURATION,\n sessionIdleExpire: SESSION_IDLE_EXPIRE_DURATION,\n } ;\n this._lastActivity = Date.now();\n this._isEnabled = false;\n this._isPaused = false;\n this._hasInitializedCoreListeners = false;\n this._context = {\n errorIds: new Set(),\n traceIds: new Set(),\n urls: [],\n initialTimestamp: Date.now(),\n initialUrl: '',\n };\n\n this._recordingOptions = recordingOptions;\n this._options = options;\n\n this._debouncedFlush = debounce(() => this._flush(), this._options.flushMinDelay, {\n maxWait: this._options.flushMaxDelay,\n });\n\n this._throttledAddEvent = throttle(\n (event, isCheckout) => addEvent(this, event, isCheckout),\n // Max 300 events...\n 300,\n // ... per 5s\n 5,\n );\n\n const { slowClickTimeout, slowClickIgnoreSelectors } = this.getOptions();\n\n const slowClickConfig = slowClickTimeout\n ? {\n threshold: Math.min(SLOW_CLICK_THRESHOLD, slowClickTimeout),\n timeout: slowClickTimeout,\n scrollTimeout: SLOW_CLICK_SCROLL_TIMEOUT,\n ignoreSelector: slowClickIgnoreSelectors ? slowClickIgnoreSelectors.join(',') : '',\n }\n : undefined;\n\n if (slowClickConfig) {\n this.clickDetector = new ClickDetector(this, slowClickConfig);\n }\n }\n\n /** Get the event context. */\n getContext() {\n return this._context;\n }\n\n /** If recording is currently enabled. */\n isEnabled() {\n return this._isEnabled;\n }\n\n /** If recording is currently paused. */\n isPaused() {\n return this._isPaused;\n }\n\n /**\n * Determine if canvas recording is enabled\n */\n isRecordingCanvas() {\n return Boolean(this._canvas);\n }\n\n /** Get the replay integration options. */\n getOptions() {\n return this._options;\n }\n\n /**\n * Initializes the plugin based on sampling configuration. Should not be\n * called outside of constructor.\n */\n initializeSampling(previousSessionId) {\n const { errorSampleRate, sessionSampleRate } = this._options;\n\n // If neither sample rate is > 0, then do nothing - user will need to call one of\n // `start()` or `startBuffering` themselves.\n if (errorSampleRate <= 0 && sessionSampleRate <= 0) {\n return;\n }\n\n // Otherwise if there is _any_ sample rate set, try to load an existing\n // session, or create a new one.\n this._initializeSessionForSampling(previousSessionId);\n\n if (!this.session) {\n // This should not happen, something wrong has occurred\n this._handleException(new Error('Unable to initialize and create session'));\n return;\n }\n\n if (this.session.sampled === false) {\n // This should only occur if `errorSampleRate` is 0 and was unsampled for\n // session-based replay. In this case there is nothing to do.\n return;\n }\n\n // If segmentId > 0, it means we've previously already captured this session\n // In this case, we still want to continue in `session` recording mode\n this.recordingMode = this.session.sampled === 'buffer' && this.session.segmentId === 0 ? 'buffer' : 'session';\n\n logInfoNextTick(\n `[Replay] Starting replay in ${this.recordingMode} mode`,\n this._options._experiments.traceInternals,\n );\n\n this._initializeRecording();\n }\n\n /**\n * Start a replay regardless of sampling rate. Calling this will always\n * create a new session. Will throw an error if replay is already in progress.\n *\n * Creates or loads a session, attaches listeners to varying events (DOM,\n * _performanceObserver, Recording, Sentry SDK, etc)\n */\n start() {\n if (this._isEnabled && this.recordingMode === 'session') {\n throw new Error('Replay recording is already in progress');\n }\n\n if (this._isEnabled && this.recordingMode === 'buffer') {\n throw new Error('Replay buffering is in progress, call `flush()` to save the replay');\n }\n\n logInfoNextTick('[Replay] Starting replay in session mode', this._options._experiments.traceInternals);\n\n // Required as user activity is initially set in\n // constructor, so if `start()` is called after\n // session idle expiration, a replay will not be\n // created due to an idle timeout.\n this._updateUserActivity();\n\n const session = loadOrCreateSession(\n {\n maxReplayDuration: this._options.maxReplayDuration,\n sessionIdleExpire: this.timeouts.sessionIdleExpire,\n traceInternals: this._options._experiments.traceInternals,\n },\n {\n stickySession: this._options.stickySession,\n // This is intentional: create a new session-based replay when calling `start()`\n sessionSampleRate: 1,\n allowBuffering: false,\n },\n );\n\n this.session = session;\n\n this._initializeRecording();\n }\n\n /**\n * Start replay buffering. Buffers until `flush()` is called or, if\n * `replaysOnErrorSampleRate` > 0, an error occurs.\n */\n startBuffering() {\n if (this._isEnabled) {\n throw new Error('Replay recording is already in progress');\n }\n\n logInfoNextTick('[Replay] Starting replay in buffer mode', this._options._experiments.traceInternals);\n\n const session = loadOrCreateSession(\n {\n sessionIdleExpire: this.timeouts.sessionIdleExpire,\n maxReplayDuration: this._options.maxReplayDuration,\n traceInternals: this._options._experiments.traceInternals,\n },\n {\n stickySession: this._options.stickySession,\n sessionSampleRate: 0,\n allowBuffering: true,\n },\n );\n\n this.session = session;\n\n this.recordingMode = 'buffer';\n this._initializeRecording();\n }\n\n /**\n * Start recording.\n *\n * Note that this will cause a new DOM checkout\n */\n startRecording() {\n try {\n const canvasOptions = this._canvas;\n\n this._stopRecording = record({\n ...this._recordingOptions,\n // When running in error sampling mode, we need to overwrite `checkoutEveryNms`\n // Without this, it would record forever, until an error happens, which we don't want\n // instead, we'll always keep the last 60 seconds of replay before an error happened\n ...(this.recordingMode === 'buffer' && { checkoutEveryNms: BUFFER_CHECKOUT_TIME }),\n emit: getHandleRecordingEmit(this),\n onMutation: this._onMutationHandler,\n ...(canvasOptions\n ? {\n recordCanvas: canvasOptions.recordCanvas,\n getCanvasManager: canvasOptions.getCanvasManager,\n sampling: canvasOptions.sampling,\n dataURLOptions: canvasOptions.dataURLOptions,\n }\n : {}),\n });\n } catch (err) {\n this._handleException(err);\n }\n }\n\n /**\n * Stops the recording, if it was running.\n *\n * Returns true if it was previously stopped, or is now stopped,\n * otherwise false.\n */\n stopRecording() {\n try {\n if (this._stopRecording) {\n this._stopRecording();\n this._stopRecording = undefined;\n }\n\n return true;\n } catch (err) {\n this._handleException(err);\n return false;\n }\n }\n\n /**\n * Currently, this needs to be manually called (e.g. for tests). Sentry SDK\n * does not support a teardown\n */\n async stop({ forceFlush = false, reason } = {}) {\n if (!this._isEnabled) {\n return;\n }\n\n // We can't move `_isEnabled` after awaiting a flush, otherwise we can\n // enter into an infinite loop when `stop()` is called while flushing.\n this._isEnabled = false;\n\n try {\n logInfo(\n `[Replay] Stopping Replay${reason ? ` triggered by ${reason}` : ''}`,\n this._options._experiments.traceInternals,\n );\n\n this._removeListeners();\n this.stopRecording();\n\n this._debouncedFlush.cancel();\n // See comment above re: `_isEnabled`, we \"force\" a flush, ignoring the\n // `_isEnabled` state of the plugin since it was disabled above.\n if (forceFlush) {\n await this._flush({ force: true });\n }\n\n // After flush, destroy event buffer\n this.eventBuffer && this.eventBuffer.destroy();\n this.eventBuffer = null;\n\n // Clear session from session storage, note this means if a new session\n // is started after, it will not have `previousSessionId`\n clearSession(this);\n } catch (err) {\n this._handleException(err);\n }\n }\n\n /**\n * Pause some replay functionality. See comments for `_isPaused`.\n * This differs from stop as this only stops DOM recording, it is\n * not as thorough of a shutdown as `stop()`.\n */\n pause() {\n if (this._isPaused) {\n return;\n }\n\n this._isPaused = true;\n this.stopRecording();\n\n logInfo('[Replay] Pausing replay', this._options._experiments.traceInternals);\n }\n\n /**\n * Resumes recording, see notes for `pause().\n *\n * Note that calling `startRecording()` here will cause a\n * new DOM checkout.`\n */\n resume() {\n if (!this._isPaused || !this._checkSession()) {\n return;\n }\n\n this._isPaused = false;\n this.startRecording();\n\n logInfo('[Replay] Resuming replay', this._options._experiments.traceInternals);\n }\n\n /**\n * If not in \"session\" recording mode, flush event buffer which will create a new replay.\n * Unless `continueRecording` is false, the replay will continue to record and\n * behave as a \"session\"-based replay.\n *\n * Otherwise, queue up a flush.\n */\n async sendBufferedReplayOrFlush({ continueRecording = true } = {}) {\n if (this.recordingMode === 'session') {\n return this.flushImmediate();\n }\n\n const activityTime = Date.now();\n\n logInfo('[Replay] Converting buffer to session', this._options._experiments.traceInternals);\n\n // Allow flush to complete before resuming as a session recording, otherwise\n // the checkout from `startRecording` may be included in the payload.\n // Prefer to keep the error replay as a separate (and smaller) segment\n // than the session replay.\n await this.flushImmediate();\n\n const hasStoppedRecording = this.stopRecording();\n\n if (!continueRecording || !hasStoppedRecording) {\n return;\n }\n\n // To avoid race conditions where this is called multiple times, we check here again that we are still buffering\n if ((this.recordingMode ) === 'session') {\n return;\n }\n\n // Re-start recording in session-mode\n this.recordingMode = 'session';\n\n // Once this session ends, we do not want to refresh it\n if (this.session) {\n this._updateUserActivity(activityTime);\n this._updateSessionActivity(activityTime);\n this._maybeSaveSession();\n }\n\n this.startRecording();\n }\n\n /**\n * We want to batch uploads of replay events. Save events only if\n * `` milliseconds have elapsed since the last event\n * *OR* if `` milliseconds have elapsed.\n *\n * Accepts a callback to perform side-effects and returns true to stop batch\n * processing and hand back control to caller.\n */\n addUpdate(cb) {\n // We need to always run `cb` (e.g. in the case of `this.recordingMode == 'buffer'`)\n const cbResult = cb();\n\n // If this option is turned on then we will only want to call `flush`\n // explicitly\n if (this.recordingMode === 'buffer') {\n return;\n }\n\n // If callback is true, we do not want to continue with flushing -- the\n // caller will need to handle it.\n if (cbResult === true) {\n return;\n }\n\n // addUpdate is called quite frequently - use _debouncedFlush so that it\n // respects the flush delays and does not flush immediately\n this._debouncedFlush();\n }\n\n /**\n * Updates the user activity timestamp and resumes recording. This should be\n * called in an event handler for a user action that we consider as the user\n * being \"active\" (e.g. a mouse click).\n */\n triggerUserActivity() {\n this._updateUserActivity();\n\n // This case means that recording was once stopped due to inactivity.\n // Ensure that recording is resumed.\n if (!this._stopRecording) {\n // Create a new session, otherwise when the user action is flushed, it\n // will get rejected due to an expired session.\n if (!this._checkSession()) {\n return;\n }\n\n // Note: This will cause a new DOM checkout\n this.resume();\n return;\n }\n\n // Otherwise... recording was never suspended, continue as normalish\n this.checkAndHandleExpiredSession();\n\n this._updateSessionActivity();\n }\n\n /**\n * Updates the user activity timestamp *without* resuming\n * recording. Some user events (e.g. keydown) can be create\n * low-value replays that only contain the keypress as a\n * breadcrumb. Instead this would require other events to\n * create a new replay after a session has expired.\n */\n updateUserActivity() {\n this._updateUserActivity();\n this._updateSessionActivity();\n }\n\n /**\n * Only flush if `this.recordingMode === 'session'`\n */\n conditionalFlush() {\n if (this.recordingMode === 'buffer') {\n return Promise.resolve();\n }\n\n return this.flushImmediate();\n }\n\n /**\n * Flush using debounce flush\n */\n flush() {\n return this._debouncedFlush() ;\n }\n\n /**\n * Always flush via `_debouncedFlush` so that we do not have flushes triggered\n * from calling both `flush` and `_debouncedFlush`. Otherwise, there could be\n * cases of mulitple flushes happening closely together.\n */\n flushImmediate() {\n this._debouncedFlush();\n // `.flush` is provided by the debounced function, analogously to lodash.debounce\n return this._debouncedFlush.flush() ;\n }\n\n /**\n * Cancels queued up flushes.\n */\n cancelFlush() {\n this._debouncedFlush.cancel();\n }\n\n /** Get the current sesion (=replay) ID */\n getSessionId() {\n return this.session && this.session.id;\n }\n\n /**\n * Checks if recording should be stopped due to user inactivity. Otherwise\n * check if session is expired and create a new session if so. Triggers a new\n * full snapshot on new session.\n *\n * Returns true if session is not expired, false otherwise.\n * @hidden\n */\n checkAndHandleExpiredSession() {\n // Prevent starting a new session if the last user activity is older than\n // SESSION_IDLE_PAUSE_DURATION. Otherwise non-user activity can trigger a new\n // session+recording. This creates noisy replays that do not have much\n // content in them.\n if (\n this._lastActivity &&\n isExpired(this._lastActivity, this.timeouts.sessionIdlePause) &&\n this.session &&\n this.session.sampled === 'session'\n ) {\n // Pause recording only for session-based replays. Otherwise, resuming\n // will create a new replay and will conflict with users who only choose\n // to record error-based replays only. (e.g. the resumed replay will not\n // contain a reference to an error)\n this.pause();\n return;\n }\n\n // --- There is recent user activity --- //\n // This will create a new session if expired, based on expiry length\n if (!this._checkSession()) {\n // Check session handles the refreshing itself\n return false;\n }\n\n return true;\n }\n\n /**\n * Capture some initial state that can change throughout the lifespan of the\n * replay. This is required because otherwise they would be captured at the\n * first flush.\n */\n setInitialState() {\n const urlPath = `${WINDOW.location.pathname}${WINDOW.location.hash}${WINDOW.location.search}`;\n const url = `${WINDOW.location.origin}${urlPath}`;\n\n this.performanceEntries = [];\n this.replayPerformanceEntries = [];\n\n // Reset _context as well\n this._clearContext();\n\n this._context.initialUrl = url;\n this._context.initialTimestamp = Date.now();\n this._context.urls.push(url);\n }\n\n /**\n * Add a breadcrumb event, that may be throttled.\n * If it was throttled, we add a custom breadcrumb to indicate that.\n */\n throttledAddEvent(\n event,\n isCheckout,\n ) {\n const res = this._throttledAddEvent(event, isCheckout);\n\n // If this is THROTTLED, it means we have throttled the event for the first time\n // In this case, we want to add a breadcrumb indicating that something was skipped\n if (res === THROTTLED) {\n const breadcrumb = createBreadcrumb({\n category: 'replay.throttled',\n });\n\n this.addUpdate(() => {\n // Return `false` if the event _was_ added, as that means we schedule a flush\n return !addEventSync(this, {\n type: ReplayEventTypeCustom,\n timestamp: breadcrumb.timestamp || 0,\n data: {\n tag: 'breadcrumb',\n payload: breadcrumb,\n metric: true,\n },\n });\n });\n }\n\n return res;\n }\n\n /**\n * This will get the parametrized route name of the current page.\n * This is only available if performance is enabled, and if an instrumented router is used.\n */\n getCurrentRoute() {\n // eslint-disable-next-line deprecation/deprecation\n const lastTransaction = this.lastTransaction || getCurrentScope().getTransaction();\n\n const attributes = (lastTransaction && spanToJSON(lastTransaction).data) || {};\n const source = attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE];\n if (!lastTransaction || !source || !['route', 'custom'].includes(source)) {\n return undefined;\n }\n\n return spanToJSON(lastTransaction).description;\n }\n\n /**\n * Initialize and start all listeners to varying events (DOM,\n * Performance Observer, Recording, Sentry SDK, etc)\n */\n _initializeRecording() {\n this.setInitialState();\n\n // this method is generally called on page load or manually - in both cases\n // we should treat it as an activity\n this._updateSessionActivity();\n\n this.eventBuffer = createEventBuffer({\n useCompression: this._options.useCompression,\n workerUrl: this._options.workerUrl,\n });\n\n this._removeListeners();\n this._addListeners();\n\n // Need to set as enabled before we start recording, as `record()` can trigger a flush with a new checkout\n this._isEnabled = true;\n this._isPaused = false;\n\n this.startRecording();\n }\n\n /** A wrapper to conditionally capture exceptions. */\n _handleException(error) {\n DEBUG_BUILD && logger.error('[Replay]', error);\n\n if (DEBUG_BUILD && this._options._experiments && this._options._experiments.captureExceptions) {\n captureException(error);\n }\n }\n\n /**\n * Loads (or refreshes) the current session.\n */\n _initializeSessionForSampling(previousSessionId) {\n // Whenever there is _any_ error sample rate, we always allow buffering\n // Because we decide on sampling when an error occurs, we need to buffer at all times if sampling for errors\n const allowBuffering = this._options.errorSampleRate > 0;\n\n const session = loadOrCreateSession(\n {\n sessionIdleExpire: this.timeouts.sessionIdleExpire,\n maxReplayDuration: this._options.maxReplayDuration,\n traceInternals: this._options._experiments.traceInternals,\n previousSessionId,\n },\n {\n stickySession: this._options.stickySession,\n sessionSampleRate: this._options.sessionSampleRate,\n allowBuffering,\n },\n );\n\n this.session = session;\n }\n\n /**\n * Checks and potentially refreshes the current session.\n * Returns false if session is not recorded.\n */\n _checkSession() {\n // If there is no session yet, we do not want to refresh anything\n // This should generally not happen, but to be safe....\n if (!this.session) {\n return false;\n }\n\n const currentSession = this.session;\n\n if (\n shouldRefreshSession(currentSession, {\n sessionIdleExpire: this.timeouts.sessionIdleExpire,\n maxReplayDuration: this._options.maxReplayDuration,\n })\n ) {\n // This should never reject\n // eslint-disable-next-line @typescript-eslint/no-floating-promises\n this._refreshSession(currentSession);\n return false;\n }\n\n return true;\n }\n\n /**\n * Refresh a session with a new one.\n * This stops the current session (without forcing a flush, as that would never work since we are expired),\n * and then does a new sampling based on the refreshed session.\n */\n async _refreshSession(session) {\n if (!this._isEnabled) {\n return;\n }\n await this.stop({ reason: 'refresh session' });\n this.initializeSampling(session.id);\n }\n\n /**\n * Adds listeners to record events for the replay\n */\n _addListeners() {\n try {\n WINDOW.document.addEventListener('visibilitychange', this._handleVisibilityChange);\n WINDOW.addEventListener('blur', this._handleWindowBlur);\n WINDOW.addEventListener('focus', this._handleWindowFocus);\n WINDOW.addEventListener('keydown', this._handleKeyboardEvent);\n\n if (this.clickDetector) {\n this.clickDetector.addListeners();\n }\n\n // There is no way to remove these listeners, so ensure they are only added once\n if (!this._hasInitializedCoreListeners) {\n addGlobalListeners(this);\n\n this._hasInitializedCoreListeners = true;\n }\n } catch (err) {\n this._handleException(err);\n }\n\n this._performanceCleanupCallback = setupPerformanceObserver(this);\n }\n\n /**\n * Cleans up listeners that were created in `_addListeners`\n */\n _removeListeners() {\n try {\n WINDOW.document.removeEventListener('visibilitychange', this._handleVisibilityChange);\n\n WINDOW.removeEventListener('blur', this._handleWindowBlur);\n WINDOW.removeEventListener('focus', this._handleWindowFocus);\n WINDOW.removeEventListener('keydown', this._handleKeyboardEvent);\n\n if (this.clickDetector) {\n this.clickDetector.removeListeners();\n }\n\n if (this._performanceCleanupCallback) {\n this._performanceCleanupCallback();\n }\n } catch (err) {\n this._handleException(err);\n }\n }\n\n /**\n * Handle when visibility of the page content changes. Opening a new tab will\n * cause the state to change to hidden because of content of current page will\n * be hidden. Likewise, moving a different window to cover the contents of the\n * page will also trigger a change to a hidden state.\n */\n __init() {this._handleVisibilityChange = () => {\n if (WINDOW.document.visibilityState === 'visible') {\n this._doChangeToForegroundTasks();\n } else {\n this._doChangeToBackgroundTasks();\n }\n };}\n\n /**\n * Handle when page is blurred\n */\n __init2() {this._handleWindowBlur = () => {\n const breadcrumb = createBreadcrumb({\n category: 'ui.blur',\n });\n\n // Do not count blur as a user action -- it's part of the process of them\n // leaving the page\n this._doChangeToBackgroundTasks(breadcrumb);\n };}\n\n /**\n * Handle when page is focused\n */\n __init3() {this._handleWindowFocus = () => {\n const breadcrumb = createBreadcrumb({\n category: 'ui.focus',\n });\n\n // Do not count focus as a user action -- instead wait until they focus and\n // interactive with page\n this._doChangeToForegroundTasks(breadcrumb);\n };}\n\n /** Ensure page remains active when a key is pressed. */\n __init4() {this._handleKeyboardEvent = (event) => {\n handleKeyboardEvent(this, event);\n };}\n\n /**\n * Tasks to run when we consider a page to be hidden (via blurring and/or visibility)\n */\n _doChangeToBackgroundTasks(breadcrumb) {\n if (!this.session) {\n return;\n }\n\n const expired = isSessionExpired(this.session, {\n maxReplayDuration: this._options.maxReplayDuration,\n sessionIdleExpire: this.timeouts.sessionIdleExpire,\n });\n\n if (expired) {\n return;\n }\n\n if (breadcrumb) {\n this._createCustomBreadcrumb(breadcrumb);\n }\n\n // Send replay when the page/tab becomes hidden. There is no reason to send\n // replay if it becomes visible, since no actions we care about were done\n // while it was hidden\n // This should never reject\n // eslint-disable-next-line @typescript-eslint/no-floating-promises\n void this.conditionalFlush();\n }\n\n /**\n * Tasks to run when we consider a page to be visible (via focus and/or visibility)\n */\n _doChangeToForegroundTasks(breadcrumb) {\n if (!this.session) {\n return;\n }\n\n const isSessionActive = this.checkAndHandleExpiredSession();\n\n if (!isSessionActive) {\n // If the user has come back to the page within SESSION_IDLE_PAUSE_DURATION\n // ms, we will re-use the existing session, otherwise create a new\n // session\n logInfo('[Replay] Document has become active, but session has expired');\n return;\n }\n\n if (breadcrumb) {\n this._createCustomBreadcrumb(breadcrumb);\n }\n }\n\n /**\n * Update user activity (across session lifespans)\n */\n _updateUserActivity(_lastActivity = Date.now()) {\n this._lastActivity = _lastActivity;\n }\n\n /**\n * Updates the session's last activity timestamp\n */\n _updateSessionActivity(_lastActivity = Date.now()) {\n if (this.session) {\n this.session.lastActivity = _lastActivity;\n this._maybeSaveSession();\n }\n }\n\n /**\n * Helper to create (and buffer) a replay breadcrumb from a core SDK breadcrumb\n */\n _createCustomBreadcrumb(breadcrumb) {\n this.addUpdate(() => {\n // This should never reject\n // eslint-disable-next-line @typescript-eslint/no-floating-promises\n this.throttledAddEvent({\n type: EventType.Custom,\n timestamp: breadcrumb.timestamp || 0,\n data: {\n tag: 'breadcrumb',\n payload: breadcrumb,\n },\n });\n });\n }\n\n /**\n * Observed performance events are added to `this.performanceEntries`. These\n * are included in the replay event before it is finished and sent to Sentry.\n */\n _addPerformanceEntries() {\n const performanceEntries = createPerformanceEntries(this.performanceEntries).concat(this.replayPerformanceEntries);\n\n this.performanceEntries = [];\n this.replayPerformanceEntries = [];\n\n return Promise.all(createPerformanceSpans(this, performanceEntries));\n }\n\n /**\n * Clear _context\n */\n _clearContext() {\n // XXX: `initialTimestamp` and `initialUrl` do not get cleared\n this._context.errorIds.clear();\n this._context.traceIds.clear();\n this._context.urls = [];\n }\n\n /** Update the initial timestamp based on the buffer content. */\n _updateInitialTimestampFromEventBuffer() {\n const { session, eventBuffer } = this;\n if (!session || !eventBuffer) {\n return;\n }\n\n // we only ever update this on the initial segment\n if (session.segmentId) {\n return;\n }\n\n const earliestEvent = eventBuffer.getEarliestTimestamp();\n if (earliestEvent && earliestEvent < this._context.initialTimestamp) {\n this._context.initialTimestamp = earliestEvent;\n }\n }\n\n /**\n * Return and clear _context\n */\n _popEventContext() {\n const _context = {\n initialTimestamp: this._context.initialTimestamp,\n initialUrl: this._context.initialUrl,\n errorIds: Array.from(this._context.errorIds),\n traceIds: Array.from(this._context.traceIds),\n urls: this._context.urls,\n };\n\n this._clearContext();\n\n return _context;\n }\n\n /**\n * Flushes replay event buffer to Sentry.\n *\n * Performance events are only added right before flushing - this is\n * due to the buffered performance observer events.\n *\n * Should never be called directly, only by `flush`\n */\n async _runFlush() {\n const replayId = this.getSessionId();\n\n if (!this.session || !this.eventBuffer || !replayId) {\n DEBUG_BUILD && logger.error('[Replay] No session or eventBuffer found to flush.');\n return;\n }\n\n await this._addPerformanceEntries();\n\n // Check eventBuffer again, as it could have been stopped in the meanwhile\n if (!this.eventBuffer || !this.eventBuffer.hasEvents) {\n return;\n }\n\n // Only attach memory event if eventBuffer is not empty\n await addMemoryEntry(this);\n\n // Check eventBuffer again, as it could have been stopped in the meanwhile\n if (!this.eventBuffer) {\n return;\n }\n\n // if this changed in the meanwhile, e.g. because the session was refreshed or similar, we abort here\n if (replayId !== this.getSessionId()) {\n return;\n }\n\n try {\n // This uses the data from the eventBuffer, so we need to call this before `finish()\n this._updateInitialTimestampFromEventBuffer();\n\n const timestamp = Date.now();\n\n // Check total duration again, to avoid sending outdated stuff\n // We leave 30s wiggle room to accomodate late flushing etc.\n // This _could_ happen when the browser is suspended during flushing, in which case we just want to stop\n if (timestamp - this._context.initialTimestamp > this._options.maxReplayDuration + 30000) {\n throw new Error('Session is too long, not sending replay');\n }\n\n const eventContext = this._popEventContext();\n // Always increment segmentId regardless of outcome of sending replay\n const segmentId = this.session.segmentId++;\n this._maybeSaveSession();\n\n // Note this empties the event buffer regardless of outcome of sending replay\n const recordingData = await this.eventBuffer.finish();\n\n await sendReplay({\n replayId,\n recordingData,\n segmentId,\n eventContext,\n session: this.session,\n options: this.getOptions(),\n timestamp,\n });\n } catch (err) {\n this._handleException(err);\n\n // This means we retried 3 times and all of them failed,\n // or we ran into a problem we don't want to retry, like rate limiting.\n // In this case, we want to completely stop the replay - otherwise, we may get inconsistent segments\n // This should never reject\n // eslint-disable-next-line @typescript-eslint/no-floating-promises\n this.stop({ reason: 'sendReplay' });\n\n const client = getClient();\n\n if (client) {\n client.recordDroppedEvent('send_error', 'replay');\n }\n }\n }\n\n /**\n * Flush recording data to Sentry. Creates a lock so that only a single flush\n * can be active at a time. Do not call this directly.\n */\n __init5() {this._flush = async ({\n force = false,\n }\n\n = {}) => {\n if (!this._isEnabled && !force) {\n // This can happen if e.g. the replay was stopped because of exceeding the retry limit\n return;\n }\n\n if (!this.checkAndHandleExpiredSession()) {\n DEBUG_BUILD && logger.error('[Replay] Attempting to finish replay event after session expired.');\n return;\n }\n\n if (!this.session) {\n // should never happen, as we would have bailed out before\n return;\n }\n\n const start = this.session.started;\n const now = Date.now();\n const duration = now - start;\n\n // A flush is about to happen, cancel any queued flushes\n this._debouncedFlush.cancel();\n\n // If session is too short, or too long (allow some wiggle room over maxReplayDuration), do not send it\n // This _should_ not happen, but it may happen if flush is triggered due to a page activity change or similar\n const tooShort = duration < this._options.minReplayDuration;\n const tooLong = duration > this._options.maxReplayDuration + 5000;\n if (tooShort || tooLong) {\n logInfo(\n `[Replay] Session duration (${Math.floor(duration / 1000)}s) is too ${\n tooShort ? 'short' : 'long'\n }, not sending replay.`,\n this._options._experiments.traceInternals,\n );\n\n if (tooShort) {\n this._debouncedFlush();\n }\n return;\n }\n\n const eventBuffer = this.eventBuffer;\n if (eventBuffer && this.session.segmentId === 0 && !eventBuffer.hasCheckout) {\n logInfo('[Replay] Flushing initial segment without checkout.', this._options._experiments.traceInternals);\n // TODO FN: Evaluate if we want to stop here, or remove this again?\n }\n\n // this._flushLock acts as a lock so that future calls to `_flush()`\n // will be blocked until this promise resolves\n if (!this._flushLock) {\n this._flushLock = this._runFlush();\n await this._flushLock;\n this._flushLock = undefined;\n return;\n }\n\n // Wait for previous flush to finish, then call the debounced `_flush()`.\n // It's possible there are other flush requests queued and waiting for it\n // to resolve. We want to reduce all outstanding requests (as well as any\n // new flush requests that occur within a second of the locked flush\n // completing) into a single flush.\n\n try {\n await this._flushLock;\n } catch (err) {\n DEBUG_BUILD && logger.error(err);\n } finally {\n this._debouncedFlush();\n }\n };}\n\n /** Save the session, if it is sticky */\n _maybeSaveSession() {\n if (this.session && this._options.stickySession) {\n saveSession(this.session);\n }\n }\n\n /** Handler for rrweb.record.onMutation */\n __init6() {this._onMutationHandler = (mutations) => {\n const count = mutations.length;\n\n const mutationLimit = this._options.mutationLimit;\n const mutationBreadcrumbLimit = this._options.mutationBreadcrumbLimit;\n const overMutationLimit = mutationLimit && count > mutationLimit;\n\n // Create a breadcrumb if a lot of mutations happen at the same time\n // We can show this in the UI as an information with potential performance improvements\n if (count > mutationBreadcrumbLimit || overMutationLimit) {\n const breadcrumb = createBreadcrumb({\n category: 'replay.mutations',\n data: {\n count,\n limit: overMutationLimit,\n },\n });\n this._createCustomBreadcrumb(breadcrumb);\n }\n\n // Stop replay if over the mutation limit\n if (overMutationLimit) {\n // This should never reject\n // eslint-disable-next-line @typescript-eslint/no-floating-promises\n this.stop({ reason: 'mutationLimit', forceFlush: this.recordingMode === 'session' });\n return false;\n }\n\n // `true` means we use the regular mutation handling by rrweb\n return true;\n };}\n}\n\nfunction getOption(\n selectors,\n defaultSelectors,\n deprecatedClassOption,\n deprecatedSelectorOption,\n) {\n const deprecatedSelectors = typeof deprecatedSelectorOption === 'string' ? deprecatedSelectorOption.split(',') : [];\n\n const allSelectors = [\n ...selectors,\n // @deprecated\n ...deprecatedSelectors,\n\n // sentry defaults\n ...defaultSelectors,\n ];\n\n // @deprecated\n if (typeof deprecatedClassOption !== 'undefined') {\n // NOTE: No support for RegExp\n if (typeof deprecatedClassOption === 'string') {\n allSelectors.push(`.${deprecatedClassOption}`);\n }\n\n consoleSandbox(() => {\n // eslint-disable-next-line no-console\n console.warn(\n '[Replay] You are using a deprecated configuration item for privacy. Read the documentation on how to use the new privacy configuration.',\n );\n });\n }\n\n return allSelectors.join(',');\n}\n\n/**\n * Returns privacy related configuration for use in rrweb\n */\nfunction getPrivacyOptions({\n mask,\n unmask,\n block,\n unblock,\n ignore,\n\n // eslint-disable-next-line deprecation/deprecation\n blockClass,\n // eslint-disable-next-line deprecation/deprecation\n blockSelector,\n // eslint-disable-next-line deprecation/deprecation\n maskTextClass,\n // eslint-disable-next-line deprecation/deprecation\n maskTextSelector,\n // eslint-disable-next-line deprecation/deprecation\n ignoreClass,\n}) {\n const defaultBlockedElements = ['base[href=\"/\"]'];\n\n const maskSelector = getOption(mask, ['.sentry-mask', '[data-sentry-mask]'], maskTextClass, maskTextSelector);\n const unmaskSelector = getOption(unmask, ['.sentry-unmask', '[data-sentry-unmask]']);\n\n const options = {\n // We are making the decision to make text and input selectors the same\n maskTextSelector: maskSelector,\n unmaskTextSelector: unmaskSelector,\n\n blockSelector: getOption(\n block,\n ['.sentry-block', '[data-sentry-block]', ...defaultBlockedElements],\n blockClass,\n blockSelector,\n ),\n unblockSelector: getOption(unblock, ['.sentry-unblock', '[data-sentry-unblock]']),\n ignoreSelector: getOption(ignore, ['.sentry-ignore', '[data-sentry-ignore]', 'input[type=\"file\"]'], ignoreClass),\n };\n\n if (blockClass instanceof RegExp) {\n options.blockClass = blockClass;\n }\n\n if (maskTextClass instanceof RegExp) {\n options.maskTextClass = maskTextClass;\n }\n\n return options;\n}\n\n/**\n * Masks an attribute if necessary, otherwise return attribute value as-is.\n */\nfunction maskAttribute({\n el,\n key,\n maskAttributes,\n maskAllText,\n privacyOptions,\n value,\n}) {\n // We only mask attributes if `maskAllText` is true\n if (!maskAllText) {\n return value;\n }\n\n // unmaskTextSelector takes precendence\n if (privacyOptions.unmaskTextSelector && el.matches(privacyOptions.unmaskTextSelector)) {\n return value;\n }\n\n if (\n maskAttributes.includes(key) ||\n // Need to mask `value` attribute for `` if it's a button-like\n // type\n (key === 'value' && el.tagName === 'INPUT' && ['submit', 'button'].includes(el.getAttribute('type') || ''))\n ) {\n return value.replace(/[\\S]/g, '*');\n }\n\n return value;\n}\n\nconst MEDIA_SELECTORS =\n 'img,image,svg,video,object,picture,embed,map,audio,link[rel=\"icon\"],link[rel=\"apple-touch-icon\"]';\n\nconst DEFAULT_NETWORK_HEADERS = ['content-length', 'content-type', 'accept'];\n\nlet _initialized = false;\n\nconst replayIntegration$1 = ((options) => {\n // eslint-disable-next-line deprecation/deprecation\n return new Replay$1(options);\n}) ;\n\n/**\n * The main replay integration class, to be passed to `init({ integrations: [] })`.\n * @deprecated Use `replayIntegration()` instead.\n */\nclass Replay$1 {\n /**\n * @inheritDoc\n */\n static __initStatic() {this.id = 'Replay';}\n\n /**\n * @inheritDoc\n */\n\n /**\n * Options to pass to `rrweb.record()`\n */\n\n /**\n * Initial options passed to the replay integration, merged with default values.\n * Note: `sessionSampleRate` and `errorSampleRate` are not required here, as they\n * can only be finally set when setupOnce() is called.\n *\n * @private\n */\n\n constructor({\n flushMinDelay = DEFAULT_FLUSH_MIN_DELAY,\n flushMaxDelay = DEFAULT_FLUSH_MAX_DELAY,\n minReplayDuration = MIN_REPLAY_DURATION,\n maxReplayDuration = MAX_REPLAY_DURATION,\n stickySession = true,\n useCompression = true,\n workerUrl,\n _experiments = {},\n sessionSampleRate,\n errorSampleRate,\n maskAllText = true,\n maskAllInputs = true,\n blockAllMedia = true,\n\n mutationBreadcrumbLimit = 750,\n mutationLimit = 10000,\n\n slowClickTimeout = 7000,\n slowClickIgnoreSelectors = [],\n\n networkDetailAllowUrls = [],\n networkDetailDenyUrls = [],\n networkCaptureBodies = true,\n networkRequestHeaders = [],\n networkResponseHeaders = [],\n\n mask = [],\n maskAttributes = ['title', 'placeholder'],\n unmask = [],\n block = [],\n unblock = [],\n ignore = [],\n maskFn,\n\n beforeAddRecordingEvent,\n beforeErrorSampling,\n\n // eslint-disable-next-line deprecation/deprecation\n blockClass,\n // eslint-disable-next-line deprecation/deprecation\n blockSelector,\n // eslint-disable-next-line deprecation/deprecation\n maskInputOptions,\n // eslint-disable-next-line deprecation/deprecation\n maskTextClass,\n // eslint-disable-next-line deprecation/deprecation\n maskTextSelector,\n // eslint-disable-next-line deprecation/deprecation\n ignoreClass,\n } = {}) {\n // eslint-disable-next-line deprecation/deprecation\n this.name = Replay$1.id;\n\n const privacyOptions = getPrivacyOptions({\n mask,\n unmask,\n block,\n unblock,\n ignore,\n blockClass,\n blockSelector,\n maskTextClass,\n maskTextSelector,\n ignoreClass,\n });\n\n this._recordingOptions = {\n maskAllInputs,\n maskAllText,\n maskInputOptions: { ...(maskInputOptions || {}), password: true },\n maskTextFn: maskFn,\n maskInputFn: maskFn,\n maskAttributeFn: (key, value, el) =>\n maskAttribute({\n maskAttributes,\n maskAllText,\n privacyOptions,\n key,\n value,\n el,\n }),\n\n ...privacyOptions,\n\n // Our defaults\n slimDOMOptions: 'all',\n inlineStylesheet: true,\n // Disable inline images as it will increase segment/replay size\n inlineImages: false,\n // collect fonts, but be aware that `sentry.io` needs to be an allowed\n // origin for playback\n collectFonts: true,\n errorHandler: (err) => {\n try {\n err.__rrweb__ = true;\n } catch (error) {\n // ignore errors here\n // this can happen if the error is frozen or does not allow mutation for other reasons\n }\n },\n };\n\n this._initialOptions = {\n flushMinDelay,\n flushMaxDelay,\n minReplayDuration: Math.min(minReplayDuration, MIN_REPLAY_DURATION_LIMIT),\n maxReplayDuration: Math.min(maxReplayDuration, MAX_REPLAY_DURATION),\n stickySession,\n sessionSampleRate,\n errorSampleRate,\n useCompression,\n workerUrl,\n blockAllMedia,\n maskAllInputs,\n maskAllText,\n mutationBreadcrumbLimit,\n mutationLimit,\n slowClickTimeout,\n slowClickIgnoreSelectors,\n networkDetailAllowUrls,\n networkDetailDenyUrls,\n networkCaptureBodies,\n networkRequestHeaders: _getMergedNetworkHeaders(networkRequestHeaders),\n networkResponseHeaders: _getMergedNetworkHeaders(networkResponseHeaders),\n beforeAddRecordingEvent,\n beforeErrorSampling,\n\n _experiments,\n };\n\n if (typeof sessionSampleRate === 'number') {\n // eslint-disable-next-line\n console.warn(\n `[Replay] You are passing \\`sessionSampleRate\\` to the Replay integration.\nThis option is deprecated and will be removed soon.\nInstead, configure \\`replaysSessionSampleRate\\` directly in the SDK init options, e.g.:\nSentry.init({ replaysSessionSampleRate: ${sessionSampleRate} })`,\n );\n\n this._initialOptions.sessionSampleRate = sessionSampleRate;\n }\n\n if (typeof errorSampleRate === 'number') {\n // eslint-disable-next-line\n console.warn(\n `[Replay] You are passing \\`errorSampleRate\\` to the Replay integration.\nThis option is deprecated and will be removed soon.\nInstead, configure \\`replaysOnErrorSampleRate\\` directly in the SDK init options, e.g.:\nSentry.init({ replaysOnErrorSampleRate: ${errorSampleRate} })`,\n );\n\n this._initialOptions.errorSampleRate = errorSampleRate;\n }\n\n if (this._initialOptions.blockAllMedia) {\n // `blockAllMedia` is a more user friendly option to configure blocking\n // embedded media elements\n this._recordingOptions.blockSelector = !this._recordingOptions.blockSelector\n ? MEDIA_SELECTORS\n : `${this._recordingOptions.blockSelector},${MEDIA_SELECTORS}`;\n }\n\n if (this._isInitialized && isBrowser()) {\n throw new Error('Multiple Sentry Session Replay instances are not supported');\n }\n\n this._isInitialized = true;\n }\n\n /** If replay has already been initialized */\n get _isInitialized() {\n return _initialized;\n }\n\n /** Update _isInitialized */\n set _isInitialized(value) {\n _initialized = value;\n }\n\n /**\n * Setup and initialize replay container\n */\n setupOnce() {\n if (!isBrowser()) {\n return;\n }\n\n this._setup();\n\n // Once upon a time, we tried to create a transaction in `setupOnce` and it would\n // potentially create a transaction before some native SDK integrations have run\n // and applied their own global event processor. An example is:\n // https://github.com/getsentry/sentry-javascript/blob/b47ceafbdac7f8b99093ce6023726ad4687edc48/packages/browser/src/integrations/useragent.ts\n //\n // So we call `this._initialize()` in next event loop as a workaround to wait for other\n // global event processors to finish. This is no longer needed, but keeping it\n // here to avoid any future issues.\n setTimeout(() => this._initialize());\n }\n\n /**\n * Start a replay regardless of sampling rate. Calling this will always\n * create a new session. Will throw an error if replay is already in progress.\n *\n * Creates or loads a session, attaches listeners to varying events (DOM,\n * PerformanceObserver, Recording, Sentry SDK, etc)\n */\n start() {\n if (!this._replay) {\n return;\n }\n\n this._replay.start();\n }\n\n /**\n * Start replay buffering. Buffers until `flush()` is called or, if\n * `replaysOnErrorSampleRate` > 0, until an error occurs.\n */\n startBuffering() {\n if (!this._replay) {\n return;\n }\n\n this._replay.startBuffering();\n }\n\n /**\n * Currently, this needs to be manually called (e.g. for tests). Sentry SDK\n * does not support a teardown\n */\n stop() {\n if (!this._replay) {\n return Promise.resolve();\n }\n\n return this._replay.stop({ forceFlush: this._replay.recordingMode === 'session' });\n }\n\n /**\n * If not in \"session\" recording mode, flush event buffer which will create a new replay.\n * Unless `continueRecording` is false, the replay will continue to record and\n * behave as a \"session\"-based replay.\n *\n * Otherwise, queue up a flush.\n */\n flush(options) {\n if (!this._replay || !this._replay.isEnabled()) {\n return Promise.resolve();\n }\n\n return this._replay.sendBufferedReplayOrFlush(options);\n }\n\n /**\n * Get the current session ID.\n */\n getReplayId() {\n if (!this._replay || !this._replay.isEnabled()) {\n return;\n }\n\n return this._replay.getSessionId();\n }\n\n /**\n * Initializes replay.\n */\n _initialize() {\n if (!this._replay) {\n return;\n }\n\n // We have to run this in _initialize, because this runs in setTimeout\n // So when this runs all integrations have been added\n // Before this, we cannot access integrations on the client,\n // so we need to mutate the options here\n this._maybeLoadFromReplayCanvasIntegration();\n\n this._replay.initializeSampling();\n }\n\n /** Setup the integration. */\n _setup() {\n // Client is not available in constructor, so we need to wait until setupOnce\n const finalOptions = loadReplayOptionsFromClient(this._initialOptions);\n\n this._replay = new ReplayContainer({\n options: finalOptions,\n recordingOptions: this._recordingOptions,\n });\n }\n\n /** Get canvas options from ReplayCanvas integration, if it is also added. */\n _maybeLoadFromReplayCanvasIntegration() {\n // To save bundle size, we skip checking for stuff here\n // and instead just try-catch everything - as generally this should all be defined\n /* eslint-disable @typescript-eslint/no-non-null-assertion */\n try {\n const client = getClient();\n const canvasIntegration = client.getIntegrationByName('ReplayCanvas')\n\n;\n if (!canvasIntegration) {\n return;\n }\n\n this._replay['_canvas'] = canvasIntegration.getOptions();\n } catch (e) {\n // ignore errors here\n }\n /* eslint-enable @typescript-eslint/no-non-null-assertion */\n }\n}Replay$1.__initStatic();\n\n/** Parse Replay-related options from SDK options */\nfunction loadReplayOptionsFromClient(initialOptions) {\n const client = getClient();\n const opt = client && (client.getOptions() );\n\n const finalOptions = { sessionSampleRate: 0, errorSampleRate: 0, ...dropUndefinedKeys(initialOptions) };\n\n if (!opt) {\n consoleSandbox(() => {\n // eslint-disable-next-line no-console\n console.warn('SDK client is not available.');\n });\n return finalOptions;\n }\n\n if (\n initialOptions.sessionSampleRate == null && // TODO remove once deprecated rates are removed\n initialOptions.errorSampleRate == null && // TODO remove once deprecated rates are removed\n opt.replaysSessionSampleRate == null &&\n opt.replaysOnErrorSampleRate == null\n ) {\n consoleSandbox(() => {\n // eslint-disable-next-line no-console\n console.warn(\n 'Replay is disabled because neither `replaysSessionSampleRate` nor `replaysOnErrorSampleRate` are set.',\n );\n });\n }\n\n if (typeof opt.replaysSessionSampleRate === 'number') {\n finalOptions.sessionSampleRate = opt.replaysSessionSampleRate;\n }\n\n if (typeof opt.replaysOnErrorSampleRate === 'number') {\n finalOptions.errorSampleRate = opt.replaysOnErrorSampleRate;\n }\n\n return finalOptions;\n}\n\nfunction _getMergedNetworkHeaders(headers) {\n return [...DEFAULT_NETWORK_HEADERS, ...headers.map(header => header.toLowerCase())];\n}\n\n/**\n * This is a small utility to get a type-safe instance of the Replay integration.\n */\n// eslint-disable-next-line deprecation/deprecation\nfunction getReplay$1() {\n const client = getClient();\n return (\n client && client.getIntegrationByName && client.getIntegrationByName('Replay')\n );\n}\n\n// eslint-disable-next-line deprecation/deprecation\n\n/** @deprecated Use the export from `@sentry/replay` or from framework-specific SDKs like `@sentry/react` or `@sentry/vue` */\nconst getReplay = getReplay$1;\n\n/** @deprecated Use the export from `@sentry/replay` or from framework-specific SDKs like `@sentry/react` or `@sentry/vue` */\nconst replayIntegration = replayIntegration$1;\n\n/** @deprecated Use the export from `@sentry/replay` or from framework-specific SDKs like `@sentry/react` or `@sentry/vue` */\n// eslint-disable-next-line deprecation/deprecation\nclass Replay extends Replay$1 {}\n\nexport { Replay$1 as InternalReplay, Replay, getReplay, getReplay$1 as internalGetReplay, replayIntegration$1 as internalReplayIntegration, replayIntegration };\n//# sourceMappingURL=index.js.map\n"],"names":["WINDOW","REPLAY_SESSION_KEY","UNABLE_TO_SEND_REPLAY","NETWORK_BODY_MAX_SIZE","CONSOLE_ARG_MAX_SIZE","REPLAY_MAX_EVENT_BUFFER_SIZE","_optionalChain$5","ops","lastAccessLHS","value","i","length","op","fn","args","call","undefined","NodeType$1","isShadowRoot","n","host","_","Boolean","_2","shadowRoot","isNativeShadowDom","Object","prototype","toString","stringifyStylesheet","s","rules","cssRules","cssText","Array","from","stringifyRule","join","includes","replace","error","rule","importStringified","isCSSImportRule","styleSheet","split","statement","JSON","stringify","href","layerName","push","supportsText","media","mediaText","escapeImportStatement","isCSSStyleRule","selectorText","NodeType","Mirror","constructor","this","idNodeMap","Map","nodeMetaMap","WeakMap","getId","lhs","_3","getMeta","_4","_5","id","getNode","get","getIds","keys","removeNodeFromMap","delete","childNodes","forEach","childNode","has","hasNode","node","add","meta","set","oldNode","reset","shouldMaskInput","maskInputOptions","tagName","type","toLowerCase","maskInputValue","isMasked","element","maskInputFn","text","repeat","str","toUpperCase","ORIGINAL_ATTRIBUTE_NAME","getInputType","hasAttribute","getInputValue","el","getAttribute","_id","tagNameRegex","RegExp","genId","canvasService","canvasCtx","URL_IN_CSS_REF","URL_PROTOCOL_MATCH","URL_WWW_MATCH","DATA_URI","absoluteToStylesheet","origin","quote1","path1","quote2","path2","path3","filePath","maybeQuote","test","url","indexOf","slice","extractOrigin","stack","parts","pop","part","SRCSET_NOT_SPACES","SRCSET_COMMAS_OR_SPACES","absoluteToDoc","doc","attributeValue","trim","a","createElement","getHref","document","transformAttribute","name","maskAttributeFn","pos","collectCharacters","regEx","chars","match","exec","substring","output","descriptorsStr","inParens","c","charAt","getAbsoluteSrcsetString","ignoreAttribute","_value","distanceToMatch","matchPredicate","limit","Infinity","distance","nodeType","ELEMENT_NODE","parentNode","createMatchPredicate","className","selector","matches","regex","eIndex","classList","elementClassMatchesRegex","e2","needMaskingText","maskTextClass","maskTextSelector","unmaskTextClass","unmaskTextSelector","maskAllText","parentElement","autocomplete","maskDistance","unmaskDistance","e","lowerIfExists","maybeAttr","serializeNodeWithId","options","mirror","blockClass","blockSelector","unblockSelector","skipChild","inlineStylesheet","maskTextFn","slimDOMOptions","dataURLOptions","inlineImages","recordCanvas","onSerialize","onIframeLoad","iframeLoadTimeout","onStylesheetLoad","stylesheetLoadTimeout","keepIframeSrcFn","newlyAddedElement","preserveWhiteSpace","_serializedNode","rootId","docId","getRootId","DOCUMENT_NODE","compatMode","Document","DOCUMENT_TYPE_NODE","DocumentType","publicId","systemId","needBlock","contains","_isBlockedElement","HTMLFormElement","processedTagName","getValidTagName","attributes","len","attr","stylesheet","styleSheets","find","rel","_cssText","sheet","innerText","textContent","checked","forceMask","selected","__context","canvas","ctx","getContext","x","width","y","height","getImageData","originalGetImageData","Uint32Array","Math","min","data","buffer","some","pixel","is2DCanvasBlank","rr_dataURL","toDataURL","quality","canvasDataURL","blankCanvas","image","oldValue","crossOrigin","recordInlineImage","removeEventListener","naturalWidth","naturalHeight","drawImage","err","console","warn","currentSrc","removeAttribute","complete","addEventListener","rr_mediaState","paused","rr_mediaCurrentTime","currentTime","scrollLeft","rr_scrollLeft","scrollTop","rr_scrollTop","getBoundingClientRect","class","rr_width","rr_height","isCustomElement","src","contentDocument","rr_src","customElements","Element","isSVG","ownerSVGElement","isCustom","serializeElementNode","TEXT_NODE","parentTagName","isStyle","isScript","isTextarea","nextSibling","previousSibling","_6","_7","_8","textarea","Text","serializeTextNode","CDATA_SECTION_NODE","CDATA","COMMENT_NODE","Comment","serializeNode","sn","comment","script","as","endsWith","headFavicon","headMetaDescKeywords","headMetaSocial","property","headMetaRobots","headMetaHttpEquiv","headMetaAuthorship","headMetaVerification","slimDOMExcluded","serializedNode","assign","recordChild","isShadowHost","headWhitespace","bypassOptions","childN","serializedChildNode","isElement$1","isShadow","iframeEl","listener","win","contentWindow","readyState","fired","timer","setTimeout","clearTimeout","blankUrl","location","onceIframeLoaded","iframeDoc","serializedIframeNode","link","styleSheetLoadTimeout","styleSheetLoaded","onceStylesheetLoaded","serializedLinkNode","_optionalChain$4","on","target","capture","passive","DEPARTED_MIRROR_ACCESS_WARNING","_mirror","map","throttle$1","func","wait","timeout","previous","now","Date","leading","remaining","context","rest","getImplementation","clearTimeout$1","apply","trailing","setTimeout$1","hookSetter","key","d","isRevoked","window","original","getOwnPropertyDescriptor","defineProperty","patch","source","replacement","wrapped","defineProperties","__rrweb_original__","enumerable","Proxy","Reflect","prop","receiver","nowTimestamp","getWindowScroll","left","scrollingElement","pageXOffset","documentElement","body","top","pageYOffset","_9","_10","_11","_12","_13","_14","getWindowHeight","innerHeight","clientHeight","getWindowWidth","innerWidth","clientWidth","closestElementOfNode","isBlocked","checkAncestors","blockedPredicate","isUnblocked","blockDistance","unblockDistance","isIgnored","isAncestorRemoved","legacy_isTouchEvent","event","changedTouches","isSerializedIframe","nodeName","isSerializedStylesheet","hasShadowRoot","_18","getTime","StyleSheetMirror","styleIDMap","idStyleMap","newId","getStyle","generateId","getShadowHost","shadowHost","_19","getRootNode","_20","_21","Node","DOCUMENT_FRAGMENT_NODE","inDom","ownerDocument","rootShadowHost","getRootShadowHost","shadowHostInDom","cachedImplementations","cached","impl","sandbox","hidden","head","appendChild","removeChild","bind","EventType","EventType2","IncrementalSource","IncrementalSource2","MouseInteractions","MouseInteractions2","PointerTypes","PointerTypes2","_optionalChain$3","isNodeInLinkedList","DoubleLinkedList","tail","position","Error","current","index","next","addNode","__ln","removeNode","moveKey","parentId","MutationBuffer","frozen","locked","texts","attributeMap","removes","mapRemoves","movedMap","addedSet","Set","movedSet","droppedSet","processMutations","mutations","processMutation","emit","adds","addedIds","addList","getNextId","ns","nextId","pushAdd","currentN","iframeManager","addIframe","stylesheetManager","trackLinkElement","shadowDomManager","addShadowRoot","iframe","childSn","attachIframe","observeAttachShadow","attachLinkElement","shift","isParentRemoved","isAncestorInSet","candidate","tailNode","_node","unhandledNode","payload","filter","attribute","style","diffAsStr","styleDiff","unchangedAsStr","_unchangedStyles","mutationCb","m","attributeName","isInputMasked","item","setAttribute","unattachedDoc","implementation","createHTMLDocument","old","pname","newValue","getPropertyValue","newPriority","getPropertyPriority","addedNodes","genAdds","removedNodes","nodeId","isSerialized","deepDelete","processedNodeManager","inOtherBuffer","targetId","init","freeze","canvasManager","unfreeze","isFrozen","lock","unlock","addsSet","_isParentRemoved","r","size","_isAncestorInSet","errorHandler","registerErrorHandler","handler","unregisterErrorHandler","callbackWrapper","cb","_optionalChain$2","mutationBuffers","getEventTarget","path","composedPath","initMutationObserver","rootEl","mutationBuffer","mutationObserverCtor","MutationObserver","__rrMutationObserver","angularZoneSymbol","Zone","__symbol__","observer","onMutation","observe","attributeOldValue","characterData","characterDataOldValue","childList","subtree","initScrollObserver","scrollCb","sampling","evt","defaultView","scrollLeftTop","scroll","INPUT_TAGS","lastInputValueMap","initInputObserver","inputCb","ignoreClass","ignoreSelector","userTriggeredOnInput","eventHandler","userTriggered","isTrusted","isChecked","cbWithDedup","querySelectorAll","v","lastInputValue","handlers","input","eventName","currentWindow","h","propertyDescriptor","HTMLInputElement","hookProperties","HTMLSelectElement","HTMLTextAreaElement","HTMLOptionElement","p","getNestedCSSRulePositions","childRule","hasNestedCSSRule","parentRule","CSSGroupingRule","CSSMediaRule","CSSSupportsRule","CSSConditionRule","unshift","parentStyleSheet","recurse","getIdAndStyleId","styleMirror","styleId","ownerNode","initAdoptedStyleSheetObserver","hostId","patchTarget","ShadowRoot","originalPropertyDescriptor","configurable","sheets","result","_15","_16","adoptStyleSheets","initObservers","o","_hooks","mutationObserver","mousemoveHandler","mousemoveCb","mousemove","threshold","callbackThreshold","mousemoveCallback","timeBaseline","positions","wrappedCb","totalOffset","timeOffset","updatePosition","clientX","clientY","DragEvent","Drag","MouseEvent","MouseMove","TouchMove","initMoveObserver","mouseInteractionHandler","mouseInteractionCb","mouseInteraction","disableMap","currentPointerType","Number","isNaN","eventKey","pointerType","thisEventKey","Mouse","Touch","Pen","MouseDown","MouseUp","startsWith","Click","getHandler","PointerEvent","TouchStart","TouchEnd","initMouseInteractionObserver","scrollHandler","viewportResizeHandler","viewportResizeCb","lastH","lastW","initViewportResizeObserver","inputHandler","mediaInteractionHandler","mediaInteractionCb","volume","muted","playbackRate","initMediaInteractionObserver","styleSheetObserver","styleSheetRuleCb","CSSStyleSheet","insertRule","thisArg","argumentsList","deleteRule","replaceSync","supportedNestedCSSRuleTypes","canMonkeyPatchNestedCSSRule","unmodifiedFunctions","entries","typeKey","initStyleSheetObserver","adoptedStyleSheetObserver","styleDeclarationObserver","styleDeclarationCb","ignoreCSSAttributes","setProperty","CSSStyleDeclaration","priority","_17","removeProperty","remove","initStyleDeclarationObserver","fontObserver","collectFonts","fontCb","fontMap","originalFontFace","FontFace","family","descriptors","fontFace","fontSource","Uint8Array","restoreHandler","fonts","initFontObserver","selectionObserver","param","selectionCb","collapsed","updateSelection","selection","getSelection","isCollapsed","ranges","count","rangeCount","range","getRangeAt","startContainer","startOffset","endContainer","endOffset","start","end","initSelectionObserver","customElementObserver","customElementCb","define","initCustomElementObserver","pluginHandlers","plugin","plugins","callback","b","disconnect","CrossOriginIframeMirror","generateIdFn","iframeIdToRemoteIdMap","iframeRemoteIdToIdMap","remoteId","idToRemoteMap","remoteToIdMap","idToRemoteIdMap","getIdToRemoteIdMap","remoteIdToIdMap","getRemoteIdToIdMap","getRemoteId","getRemoteIds","ids","_optionalChain$1","IframeManagerNoop","crossOriginIframeMirror","crossOriginIframeRootIdMap","addLoadListener","IframeManager","iframes","crossOriginIframeMap","wrappedEmit","recordCrossOriginIframes","crossOriginIframeStyleMirror","handleMessage","loadListener","isAttachIframe","adoptedStyleSheets","message","crossOriginMessageEvent","transformedEvent","transformCrossOriginEvent","isCheckout","FullSnapshot","replaceIdOnNode","patchRootIdOnNode","timestamp","IncrementalSnapshot","Mutation","Meta","Load","DomContentLoaded","Plugin","Custom","replaceIds","ViewportResize","MediaInteraction","MouseInteraction","Scroll","CanvasMutation","Input","StyleSheetRule","StyleDeclaration","replaceStyleIds","Font","Selection","AdoptedStyleSheet","styles","iframeMirror","obj","isArray","child","ShadowDomManagerNoop","ShadowDomManager","shadowDoms","WeakSet","restoreHandlers","patchAttachShadow","iframeElement","manager","option","CanvasManagerNoop","snapshot","StylesheetManager","trackedLinkElements","adoptedStyleSheetCb","linkEl","trackStylesheetInLinkElement","adoptedStyleSheetData","styleIds","CSSRule","ProcessedNodeManager","nodeMap","loop","periodicallyClear","onRequestAnimationFrame","clear","thisBuffer","buffers","destroy","_takeFullSnapshot","record","checkoutEveryNms","checkoutEveryNth","maskAllInputs","_maskInputOptions","_slimDOMOptions","maxCanvasSize","packFn","mousemoveWait","recordAfter","getCanvasManager","inEmittingFrame","parent","passEmitsToParent","color","date","email","month","number","search","tel","time","week","select","radio","checkbox","lastFullSnapshotEvent","NodeList","DOMTokenList","TypeError","polyfill","incrementalSnapshotCount","eventProcessor","buf","postMessage","exceedCount","exceedTime","takeFullSnapshot","wrappedMutationEmit","wrappedScrollEmit","wrappedCanvasMutationEmit","__RRWEB_EXCLUDE_IFRAME__","getMirror","nodeMirror","getCanvasManagerFn","_getCanvasManager","__RRWEB_EXCLUDE_SHADOW_DOM__","slimDOM","initialOffset","canvasMutationCb","CustomElement","timestampToMs","timestampToS","addBreadcrumbEvent","replay","breadcrumb","category","triggerUserActivity","checkAndHandleExpiredSession","addUpdate","throttledAddEvent","tag","getClosestInteractive","closest","getClickTargetNode","getTargetNode","isEventWithTarget","ClickDetector","slowClickConfig","_addBreadcrumbEvent","_lastMutation","_lastScroll","_clicks","_timeout","_threshold","_scollTimeout","scrollTimeout","_replay","_ignoreSelector","addListeners","cleanupWindowOpen","nowInSeconds","originalWindowOpen","splice","_teardown","removeListeners","_checkClickTimeout","handleClick","SLOW_CLICK_TAGS","ignoreElement","isClickBreadcrumb","newClick","clickBreadcrumb","clickCount","click","abs","_scheduleCheckClicks","registerMutation","registerScroll","registerClick","_handleMultiClick","_getClicks","_checkClicks","timedOutClicks","mutationAfter","scrollAfter","_generateBreadcrumbs","hadScroll","hadMutation","isSlowClick","timeAfterClickMs","endReason","route","getCurrentRoute","metric","createBreadcrumb","ATTRIBUTES_TO_RECORD","getAttributesToRecord","normalizedKey","getBaseDomBreadcrumb","isElement","ENTRY_TYPES","resource","entry","entryType","initiatorType","responseEnd","startTime","decodedBodySize","encodedBodySize","responseStatus","transferSize","getAbsoluteTime","statusCode","paint","duration","navigation","domComplete","domContentLoadedEventStart","domContentLoadedEventEnd","domInteractive","loadEventStart","loadEventEnd","redirectCount","createPerformanceEntry","performance","timeOrigin","DEBUG_BUILD","__SENTRY_DEBUG__","logInfo","shouldAddBreadcrumb","info","addLogBreadcrumb","logInfoNextTick","logger","level","EventBufferSizeExceededError","super","EventBufferArray","events","_totalSize","hasCheckout","hasEvents","addEvent","eventSize","finish","Promise","resolve","eventsRet","getEarliestTimestamp","sort","WorkerHandler","worker","_worker","ensureReady","_ensureReadyPromise","reject","success","once","terminate","method","arg","_getAndIncrementId","response","EventBufferCompressionWorker","_earliestTimestamp","_sendEventToWorker","_finishRequest","then","EventBufferProxy","_fallback","_compression","_used","_ensureWorkerIsLoadedPromise","_ensureWorkerIsLoaded","ensureWorkerIsLoaded","_switchToCompressionWorker","addEventPromises","all","hasSessionStorage","sessionStorage","isSampled","sampleRate","random","makeSession","session","started","lastActivity","segmentId","sampled","previousSessionId","saveSession","setItem","createSession","sessionSampleRate","allowBuffering","stickySession","getSessionSampleType","isExpired","initialTime","expiry","targetTime","isSessionExpired","maxReplayDuration","sessionIdleExpire","shouldRefreshSession","loadOrCreateSession","traceInternals","sessionOptions","existingSession","sessionStringFromStorage","getItem","sessionObj","parse","fetchSession","addEventSync","shouldAddEvent","_addEvent","async","eventBuffer","recordingMode","eventAfterPossibleCallback","isCustomEvent","maybeApplyCallback","getOptions","beforeAddRecordingEvent","reason","stop","client","recordDroppedEvent","isPaused","isEnabled","timestampInMs","timeouts","sessionIdlePause","initialTimestamp","_experiments","isErrorEvent","isTransactionEvent","isFeedbackEvent","handleAfterSendEvent","enforceStatusCode","transport","getTransport","__sentry__baseTransport__","isBaseTransportSend","sendResponse","replayContext","contexts","trace","trace_id","traceIds","handleTransactionEvent","event_id","errorIds","tags","replayId","beforeErrorSampling","sendBufferedReplayOrFlush","handleErrorEvent","createPerformanceSpans","description","startTimestamp","endTimestamp","addNetworkBreadcrumb","shouldFilterRequest","getBodySize","textEncoder","encode","URLSearchParams","FormData","formDataStr","_serializeFormData","Blob","ArrayBuffer","byteLength","parseContentLengthHeader","header","parseInt","getBodyString","mergeWarning","warning","headers","_meta","warnings","newMeta","existingWarnings","makeNetworkReplayBreadcrumb","request","buildSkippedNetworkRequestOrResponse","bodySize","buildNetworkRequestOrResponse","normalizedBody","exceedsSizeLimit","isProbablyJson","first","last","_strIsProbablyJson","truncatedBody","e3","normalizeNetworkBody","getAllowedHeaders","allowedHeaders","reduce","filteredHeaders","formData","urlMatches","urls","fullUrl","baseURI","fixedUrl","URL","getFullUrl","_getFetchRequestArgBody","fetchArgs","getAllHeaders","allHeaders","getHeadersFromOptions","Headers","handleNetworkBreadcrumbs","TextEncoder","networkDetailAllowUrls","networkDetailDenyUrls","networkCaptureBodies","networkRequestHeaders","networkResponseHeaders","hint","_isXhrBreadcrumb","xhr","_isXhrHint","reqSize","resSize","getResponseHeader","responseType","_getBodySize","request_body_size","response_body_size","enrichXhrBreadcrumb","status_code","requestBodySize","responseBodySize","xhrInfo","request_headers","getAllResponseHeaders","acc","line","getResponseHeaders","requestBody","requestWarning","responseBody","responseWarning","errors","responseText","outerHTML","_parseXhrResponse","_getXhrResponseBody","_prepareXhrData","captureXhrBreadcrumbToReplay","_isFetchBreadcrumb","_isFetchHint","enrichFetchBreadcrumb","captureDetails","bodyStr","_getRequestInfo","bodyText","res","clone","_tryCloneResponse","_getResponseText","txt","finally","_tryGetResponseText","_parseFetchResponseBody","getResponseData","_getResponseInfo","_prepareFetchData","captureFetchBreadcrumbToReplay","beforeAddNetworkBreadcrumb","handlerData","fetchData","status","handleFetch","handleFetchSpanListener","sentryXhrData","handleXhr","handleXhrSpanListener","_LAST_BREADCRUMB","hasHooks","createMemoryEntry","memoryEntry","jsHeapSizeLimit","totalJSHeapSize","usedJSHeapSize","memory","getHandleRecordingEmit","hadFirstEvent","_isCheckout","clickDetector","isIncrementalEvent","isIncrementalMouseInteraction","HTMLElement","updateClickDetectorForRecordingEvent","setInitialState","shouldRecordCanvas","isRecordingCanvas","errorSampleRate","useCompressionOption","useCompression","blockAllMedia","networkDetailHasUrls","networkRequestHasHeaders","networkResponseHasHeaders","createOptionsEvent","addSettingsEvent","earliestEvent","flush","TransportStatusCodeError","RateLimitError","rateLimits","sendReplay","replayData","retryConfig","interval","recordingData","segment_id","eventContext","preparedRecordingData","payloadWithSequence","replayHeaders","sequence","prepareRecordingData","scope","dsn","getDsn","baseEvent","replay_start_timestamp","error_ids","trace_ids","replay_id","replay_type","replayEvent","eventHint","integrations","_integrations","preparedEvent","platform","metadata","getSdkMetadata","version","sdk","prepareReplayEvent","sdkProcessingMetadata","envelope","tunnel","createReplayEnvelope","send","cause","sendReplayRequest","_retryCount","captureExceptions","THROTTLED","ReplayContainer","recordingOptions","__init","__init2","__init3","__init4","__init5","__init6","performanceEntries","replayPerformanceEntries","_lastActivity","_isEnabled","_isPaused","_hasInitializedCoreListeners","_context","initialUrl","_recordingOptions","_options","_debouncedFlush","callbackReturnValue","timerId","maxTimerId","maxWait","max","invokeFunc","cancelTimers","debounced","cancel","debounce","_flush","flushMinDelay","flushMaxDelay","_throttledAddEvent","maxCount","durationSeconds","counter","isThrottled","floor","_cleanup","values","wasThrottled","throttle","slowClickTimeout","slowClickIgnoreSelectors","_canvas","initializeSampling","_initializeSessionForSampling","_initializeRecording","_handleException","_updateUserActivity","startBuffering","startRecording","canvasOptions","_stopRecording","_onMutationHandler","stopRecording","forceFlush","_removeListeners","force","removeItem","deleteSession","pause","resume","_checkSession","continueRecording","flushImmediate","activityTime","hasStoppedRecording","_updateSessionActivity","_maybeSaveSession","cbResult","updateUserActivity","conditionalFlush","cancelFlush","getSessionId","urlPath","pathname","hash","_clearContext","lastTransaction","getTransaction","workerUrl","customWorkerUrl","Worker","__SENTRY_EXCLUDE_REPLAY_WORKER__","createObjectURL","_loadWorker","createEventBuffer","_addListeners","currentSession","_refreshSession","_handleVisibilityChange","_handleWindowBlur","_handleWindowFocus","_handleKeyboardEvent","addScopeListener","newBreadcrumb","getLastBreadcrumb","arguments","isTruncated","normalizedArgs","normalizedArg","normalizeConsoleBreadcrumb","handleScope","handleScopeListener","isClick","maxStringLength","getDomTarget","handleDom","altKey","metaKey","ctrlKey","shiftKey","handleDomListener","to","handleHistory","handleHistorySpanListener","includeAfterSendEventHandling","afterSendHandler","isReplayEvent","breadcrumbs","feedback","feedbackId","addFeedbackBreadcrumb","exception","originalException","__rrweb__","isRrwebError","log","isErrorEventSampled","shouldSampleForBufferEvent","handleGlobalEventListener","addEventProcessor","exceptionValue","handleHydrationError","handleBeforeSendEvent","dsc","transaction","feedbackEvent","includeReplay","addGlobalListeners","_performanceCleanupCallback","addPerformanceEntry","onEntries","clearCallbacks","lastEntry","getLargestContentfulPaint","clearCallback","setupPerformanceObserver","visibilityState","_doChangeToForegroundTasks","_doChangeToBackgroundTasks","isContentEditable","isInputElement","hasModifierKey","isCharacterKey","getKeyboardBreadcrumb","handleKeyboardEvent","_createCustomBreadcrumb","_addPerformanceEntries","concat","_updateInitialTimestampFromEventBuffer","_popEventContext","_runFlush","addMemoryEntry","tooShort","minReplayDuration","tooLong","_flushLock","mutationLimit","overMutationLimit","mutationBreadcrumbLimit","getOption","selectors","defaultSelectors","deprecatedClassOption","deprecatedSelectorOption","allSelectors","MEDIA_SELECTORS","DEFAULT_NETWORK_HEADERS","_initialized","Replay$1","__initStatic","MAX_REPLAY_DURATION","mask","maskAttributes","unmask","block","unblock","ignore","maskFn","privacyOptions","getPrivacyOptions","password","maskAttribute","_initialOptions","_getMergedNetworkHeaders","_isInitialized","setupOnce","_setup","_initialize","getReplayId","_maybeLoadFromReplayCanvasIntegration","finalOptions","initialOptions","opt","replaysSessionSampleRate","replaysOnErrorSampleRate","loadReplayOptionsFromClient","canvasIntegration","getIntegrationByName"],"sourceRoot":""}