{"version":3,"file":"mockttp.js","mappings":"koBACAA,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IACtDD,EAAQE,YAAcF,EAAQG,aAAeH,EAAQI,aAAeJ,EAAQK,qBAAkB,EAC9FL,EAAQM,iBA2GRC,eAAgCC,EAAU,CAAC,GACvC,MAAMC,EAAYD,EAAQE,gBACtB,oBAAoBC,EAAQC,kCAC1BC,EAAuBJ,EAAW,SAAU,IAC3CD,EAAQM,eACXC,OAAQ,QAEhB,EAjHA,MAAMC,EAAI,EAAQ,MACZC,EAAW,EAAQ,OACnBC,EAAa,EAAQ,OACrBC,EAAgB,EAAQ,OACxBC,EAAa,EAAQ,OACrBC,EAAY,EAAQ,OACpBC,EAAyB,EAAQ,KACjCC,EAA+B,EAAQ,OACvCC,EAAY,EAAQ,OACpBb,EAAU,EAAQ,OAClBc,EAAS,EAAQ,OACjBC,EAAU,EAAQ,KAClBC,EAAY,EAAQ,OACpBC,EAAyB,EAAQ,OACjCC,EAAyB,EAAQ,OACjCC,EAAgB,EAAQ,QACxB,MAAEC,EAAK,QAAEC,GAAYP,EAAOQ,aAAsC,IAArBC,WAAWH,MACxDX,EACAc,WACN,MAAM7B,UAAwBc,EAAcgB,YAE5CnC,EAAQK,gBAAkBA,EAC1B,MAAMD,UAAqBe,EAAcgB,WACrC,WAAAC,CAAYC,EAASC,GACjBC,MAAMF,GACNG,KAAKF,SAAWA,CACpB,EAEJtC,EAAQI,aAAeA,EACvB,MAAMD,UAAqBC,EACvB,WAAAgC,CAAYE,EAAUG,GAClBF,MAAwB,IAAlBE,EAAOC,OACP,+BAA+BJ,EAASK,kBACtB,IAAlBF,EAAOC,OACH,gCAAgCD,EAAO,GAAGJ,UAExC,yCAAyCI,EAAOG,KAAKC,GAAMA,EAAER,UAASS,KAAK,QAASR,GAChGE,KAAKC,OAASA,CAClB,EAEJzC,EAAQG,aAAeA,EACvB,MAAM4C,EAAqB,CAACvC,EAASwC,IAC5BA,EAEAxC,GAEDwC,EAAeC,UACVzC,EAAQyC,QAGJzC,EAAQyC,mBAAmBjB,EAChChB,EAAEkC,QAAQF,EAAeC,SAAS,CAAChD,EAAOkD,KACtC3C,EAAQyC,QAAQG,OAAOD,EAAKlD,EAAM,IAGjCe,EAAEqC,SAAS7C,EAAQyC,UACxBnD,OAAOwD,OAAO9C,EAAQyC,QAASD,EAAeC,SAR9CzC,EAAQyC,QAAUD,EAAeC,SAWlCzC,GAdIwC,EAFAxC,EAkBfD,eAAeM,EAAuBJ,EAAW8C,EAAM/C,GACnD,MAAMgD,EAAM,GAAG/C,IAAY8C,IAC3B,IAAIjB,EACJ,IACIA,QAAiBP,EAAMyB,EAAKhD,EAChC,CACA,MAAOqC,GACH,MAAI,EAAInB,EAAQ+B,aAAaZ,IAAiB,iBAAXA,EAAEa,KAC3B,IAAIrD,EAAgB,wCAAwCI,KAG5DoC,CACd,CACA,GAAIP,EAASK,QAAU,IAAK,CACxB,IAAIgB,QAAarB,EAASsB,OACtBC,EAAW,KACf,IACIA,EAAWC,KAAKC,MAAMJ,EAC1B,CACA,MAAOd,GAAK,CACZ,MAAIgB,GAAYA,EAASG,MACf,IAAI5D,EAAayD,EAASG,MAAO1B,GAGjC,IAAIlC,EAAa,cAAcoD,yBAA2BlB,EAASK,6BAA6BgB,IAAQrB,EAEtH,CAEI,OAAOA,EAAS2B,MAExB,CAiCA,MAAM/D,UAAoBe,EAASiD,aAC/B,WAAA9B,CAAY5B,EAAU,CAAC,GACnB+B,QACAC,KAAK2B,OAAQ,EAGb3B,KAAK4B,SAAU,EACf5B,KAAK6B,YAAc9D,UACfiC,KAAK2B,OAAQ,QACC3B,KAAK8B,gBAAgB,uEAIvC9B,KAAK+B,MAAQhE,eACKiC,KAAK8B,gBAAgB,0DAIvC9B,KAAK2B,QAAU3D,EAAQ2D,MACvB3B,KAAKgC,mBAAqBxD,EAAEyD,SAASjE,EAAS,CAC1CE,eAAgB,oBAAoBC,EAAQC,4BAC5C8D,6BAA8B,GAEtC,CACA,qBAAAC,CAAsBC,EAAqBC,GACvC,MAAMC,EAAwBF,EAAoBG,QAAQ,QAAS,MAC7DC,EAAW1D,EAAuB,GAAGwD,WAAgC,CACvE7B,QAAST,KAAKgC,mBAAmB1D,gBAAgBmC,UAErD,IAAIgC,GAAkB,EAuCtB,OAtCAD,EAASE,GAAG,WAAW,KACnBD,GAAkB,EAClBJ,EAAaM,KAAKH,GAClBA,EAASG,KAAKN,EAAc,CAAEO,KAAK,GAAQ,IAG/CJ,EAASE,GAAG,SAAUrC,IACdL,KAAK2B,OACLkB,QAAQC,KAAK,4BAA6BzC,GAC9CL,KAAK+C,KAAK,eAAgB1C,EAAE,IAGhCmC,EAASE,GAAG,YAAY3E,MAAOiF,IAC3BX,EAAaY,OAAOT,GACuB,MAApBQ,EAAW9B,KAG9BmB,EAAaU,KAAK,mBAEbN,IAA4C,UAAlBzC,KAAK4B,UACpCiB,QAAQC,KAAK,gDAAiDE,GAC1DhD,KAAKgC,mBAAmBE,6BAA+B,EACvDlC,KAAKkD,qBAAqBd,EAAqBC,IAI/CQ,QAAQM,IAAI,yDACZd,EAAaU,KAAK,oBAE1B,IAGJV,EAAaK,GAAG,UAAU,KAEtBF,EAASY,mBAAmB,WAC5BZ,EAASY,mBAAmB,YAC5BZ,EAASa,SAAS,IAEfb,CACX,CAMA,0BAAMU,CAAqBd,EAAqBC,EAAciB,EAAUtD,KAAKgC,mBAAmBE,8BAC5FlC,KAAK+C,KAAK,uBAEV,MAAMQ,EAAYvD,KAAKmC,sBAAsBC,EAAqBC,GAClE,IAAImB,SAAQ,CAACC,EAASC,KAClBH,EAAUI,KAAK,UAAWF,GAC1BF,EAAUI,KAAK,QAASD,EAAO,IAChCE,MAAK,KAEJf,QAAQC,KAAK,mCACb9C,KAAK+C,KAAK,qBAAqB,IAChCc,OAAM9F,MAAO+F,IACZ,GAAIR,EAAU,EAAG,CAIb,MAAMS,EAAe/D,KAAKgC,mBAAmBE,6BAA+BoB,EAE5E,aADM,EAAIrE,EAAO+E,OAAO,GAAKC,KAAKC,IAAI,EAAGH,IAClC/D,KAAKkD,qBAAqBd,EAAqBC,EAAciB,EAAU,EAClF,CAEAT,QAAQC,KAAK,0DAA2DgB,EAAIjE,SACxEG,KAAK2B,OACLkB,QAAQC,KAAKgB,GACjB9D,KAAK+C,KAAK,0BAA2Be,GACrCzB,EAAaU,KAAK,kBAAkB,GAE5C,CACA,sBAAAoB,CAAuB/B,GAInB,MAAQgC,QAASC,EAAUC,QAASC,GAAkB,IAAI7F,EACpD8D,EAAWxC,KAAKmC,sBAAsBC,EAAqBiC,GAUjE,OATAA,EAAS3B,GAAG,SAAUrC,GAAMkE,EAAcxB,KAAK,QAAS1C,KAExDkE,EAAc7B,GAAG,UAAU,IAAM2B,EAASzB,QAE1CyB,EAAS3B,GAAG,mBAAmB,IAAM6B,EAAcxB,KAAK,qBAIxDwB,EAAcC,gBAAgB,KACvB,IAAIhB,SAAQ,CAACC,EAASC,KACzBlB,EAASmB,KAAK,WAAW,IAAMF,EAAQc,KACvC/B,EAASmB,KAAK,QAASD,EAAO,GAEtC,CACA,sCAAAe,CAAuCrC,GACnC,MACMsC,EAAkB,GADMtC,EAAoBG,QAAQ,QAAS,qBAEnEvC,KAAK2E,mBAAqB,IAAI5F,EAA6B6F,mBAAmBF,EAAiB,CAC3FG,MAAM,EACNC,WAAW,EACXC,qBAAsB,EACtBC,kBAAmB,CAAChF,KAAKgC,mBAAmB1D,iBAC7CO,GACHmB,KAAK2E,mBAAmBM,SAAS5E,IAC7BL,KAAK+C,KAAK,qBAAsB1C,GAC5BL,KAAK2B,OACLkB,QAAQrB,MAAM,qBAAsBnB,EAAE,IAE9CL,KAAK2E,mBAAmBO,gBAAe,KACnClF,KAAK+C,KAAK,6BACVF,QAAQC,KAAK,2CAA2C,GAEhE,CACA,2BAAMqC,CAAsBpE,EAAM/C,GAE9B,IAAKgC,KAAKoC,oBACN,MAAM,IAAIgD,MAAM,gCACpB,IAAIpE,EAAMhB,KAAKoC,oBAAsBrB,EACjCjB,QAAiBP,EAAMyB,EAAKT,EAAmBvC,EAASgC,KAAKgC,mBAAmB1D,iBACpF,GAAIwB,EAASK,QAAU,IAGnB,MAFIH,KAAK2B,OACLkB,QAAQrB,MAAM,mDAAmD1B,EAASK,UACxE,IAAIvC,EAAa,cAAcoD,yBAA2BlB,EAASK,SAAUL,GAGnF,OAAOA,CAEf,CACA,qBAAMgC,CAAgBuD,EAAOC,GACzB,IACI,MAAMxF,QAAkBE,KAAKmF,sBAAsB,IAAK,CACpD5G,OAAQ,OACRkC,QAAS,IAAIjB,EAAQ,CACjB,eAAgB,qBAEpB2B,KAAMG,KAAKiE,UAAU,CAAEF,QAAOC,iBAE5B,KAAEE,EAAI,OAAEvF,SAAiBH,EAAS2B,OACxC,GAAIxB,GAAUA,EAAOC,OACjB,MAAM,IAAIvC,EAAamC,EAAUG,GAGjC,OAAOuF,CAEf,CACA,MAAOnF,GAGH,GAFIL,KAAK2B,OACLkB,QAAQrB,MAAM,8BAA8BnB,OAC1CA,aAAazC,GACf,MAAMyC,EACV,IAAIoF,EACJ,IACIA,SAAuBpF,EAAEP,SAAS2B,QAAQxB,MAC9C,CACA,MAAOyF,GAAM,CACb,MAAID,EACM,IAAI9H,EAAa0C,EAAEP,SAAU2F,GAG7BpF,CAEd,CACJ,CACA,WAAMsF,CAAMC,GACR,GAAI5F,KAAKoC,2BAA6BpC,KAAK4B,QACvC,MAAM,IAAIwD,MAAM,6BAChBpF,KAAK2B,OACLkB,QAAQM,IAAI,+BAChBnD,KAAK+C,KAAK,YACV,MAAM8C,GAAe,EAAI1G,EAAU2G,eACnC9F,KAAK4B,QAAUiE,EAAajC,MAAMmC,IAC9B/F,KAAK+C,KAAKgD,EAAS,UAAY,gBAC/B/F,KAAK4B,QAAUmE,EACRA,KAEX,IACI,MACMC,EADoB,SAAUJ,EAE9BA,EAAwB,KAAEK,UAC1BC,EACAnF,EAAOiF,EAAa,eAAe1E,KAAKiE,UAAUS,KAAgB,SAClEG,QAA4B9H,EAAuB2B,KAAKgC,mBAAmB9D,eAAgB6C,EAAMR,EAAmB,CACtHhC,OAAQ,OACRkC,QAAS,IAAIjB,EAAQ,CACjB,eAAgB,qBAEpB2B,KAAMG,KAAKiE,UAAU,CACjBa,QAASR,KAENA,EAAkBS,MAAMrI,WAEhCgC,KAAKgC,mBAAmB1D,iBAErBgI,EAAsB,OAAQH,EAC9BI,EAAYD,EACZH,EAAoBK,GACpBL,EAAoBF,KAAKQ,WACzBrE,EAAsB,GAAGpC,KAAKgC,mBAAmB9D,kBAAkBoI,EAAsB,UAAY,YAAYC,IAEjHG,QAA0B1G,KAAKmE,uBAAuB/B,GAC5DsE,EAAkBhE,GAAG,mBAAmB,KAGhC1C,KAAK0G,oBAAsBA,IAC3B7D,QAAQC,KAAK,gDACb9C,KAAK2G,OACT,IAEJ3G,KAAK0G,kBAAoBA,EAEzB1G,KAAKyE,uCAAuCrC,GAE5CpC,KAAKoC,oBAAsBA,EAE3BpC,KAAK4G,kBAAoB,IAAIvH,EAAuBwH,0BAA0B7G,KAAK8B,gBAAgB1C,EAAuB0H,qBAAqBC,UAC3I/G,KAAK2B,OACLkB,QAAQM,IAAI,8BAChB,MAAM6D,EAAiBhH,KAAKiH,oBACxB,eAAgBd,EACVA,EAAoBe,WACpB,CAEEb,KAAMF,GAGlB,OADAN,EAAapC,SAAQ,GACduD,CACX,CACA,MAAO3G,GAEH,MADAwF,EAAapC,SAAQ,GACfpD,CACV,CACJ,CACA,SAAA8G,GACI,OAAwB,IAAjBnH,KAAK4B,OAChB,CACA,YAAIwF,GACA,IAAKpH,KAAKmH,YACN,MAAM,IAAI/B,MAAM,8DACpB,OAAOpF,KAAKiH,mBAChB,CACA,UAAII,GACA,IAAKrH,KAAKmH,YACN,MAAM,IAAI/B,MAAM,kEACpB,OAAOpF,KAAK4G,iBAChB,CACA,eAAIU,GACA,IAAKtH,KAAKmH,YACN,MAAM,IAAI/B,MAAM,kEACpB,OAAOpF,KAAK0G,iBAChB,CAGA,UAAMC,GACF,IAA2B,UAAjB3G,KAAK4B,QACX,OACJ5B,KAAK+C,KAAK,YACV,MAAMwE,GAAc,EAAIpI,EAAU2G,eAClC9F,KAAK4B,QAAU2F,EAAY3D,MAAMmC,IAC7B/F,KAAK+C,KAAK,WACV/C,KAAK4B,QAAUmE,EACRA,KAEX,IACQ/F,KAAK2B,OACLkB,QAAQM,IAAI,+BAChB,IACInD,KAAK2E,oBAAoB6C,OAC7B,CACA,MAAOnH,GACHwC,QAAQM,IAAI9C,EAChB,CACAL,KAAK2E,wBAAqBuB,EAC1B,IACIlG,KAAK0G,mBAAmB9D,KAC5B,CACA,MAAOvC,GACHwC,QAAQM,IAAI9C,EAChB,CACAL,KAAK0G,uBAAoBR,QACnBlG,KAAKyH,mBACf,CACA,QAIIF,EAAY9D,SAAQ,EACxB,CACJ,CACA,iBAAAgE,GACI,OAAOzH,KAAKmF,sBAAsB,QAAS,CACvC5G,OAAQ,SACTsF,OAAOxD,IACN,KAAIA,aAAazC,GAAsC,MAAtByC,EAAEP,SAASK,QAMxC,MAAME,CACV,IACDuD,MAAK,KACJ5D,KAAKoC,yBAAsB8D,EAC3BlG,KAAK4G,uBAAoBV,EACzBlG,KAAKiH,yBAAsBf,CAAS,GAE5C,CACA,eAAMwB,CAAUrC,GACZ,aAAcrF,KAAK2H,YAAYtC,IAAQ,EAC3C,CACA,iBAAMsC,IAAeC,GACjB,MAAMC,EAAUD,EAAQxH,KAAIrC,OAASsH,QAAOC,YAAWwC,wBACnD,MAAM/B,QAAe/F,KAAK8B,iBAAgB,EAAI9C,EAAU+I,OAAO1C,GAAQC,GACvE,OAAOwC,EACDA,EAAkB/B,EAAQ,CAAEiC,YAAahI,OACzC+F,CAAM,IAEhB,OAAOvC,QAAQyE,IAAIJ,EACvB,CACA,eAAMK,CAAU7C,EAAO8C,GACnB,IAA2B,UAAjBnI,KAAK4B,QACX,MAAM,IAAIwD,MAAM,gCACpB,MAAMgD,GAAY,EAAI9I,EAAc+I,4BAA4BhD,GAChE,IAAKrF,KAAKqH,OAAOiB,aAAa,eAAgBF,GAE1C,OADAvF,QAAQC,KAAK,0EAA0EsF,KAChF5E,QAAQC,UAInB,IAAI8E,IAAgBvI,KAAK2E,mBAAmB6D,OAgB5C,OAfAxI,KAAK2E,mBAAmB8D,QAAQpD,GAAO6C,UAAU,CAC7CQ,KAAM3K,MAAON,IACT,GAAIA,EAAM+H,KAAM,CACZ,MAAM1F,EAAWrC,EAAM+H,KAAK4C,GACtBrC,EAASV,EAAMyC,wBACTzC,EAAMyC,kBAAkBhI,EAAU,CAAEkI,YAAahI,OACvDF,EACNqI,EAASpC,EACb,MACStI,EAAMwC,QACX4C,QAAQrB,MAAM,wBAAyB/D,EAAMwC,OACjD,EAEJuB,MAAQnB,GAAML,KAAK2B,OAASkB,QAAQC,KAAK,gCAAiCzC,KAEvE,IAAImD,SAAQ,CAACC,EAASC,KACrB6E,EACA9E,KAEAzD,KAAK2E,mBAAmBgE,YAAYlF,GACpCzD,KAAK2E,mBAAmBiE,eAAelF,GACvC1D,KAAK2E,mBAAmBM,QAAQvB,GACpC,GAER,CAQA,0BAAMmF,GACF,IAA2B,UAAjB7I,KAAK4B,QACX,MAAM,IAAIwD,MAAM,6DAEpB,OAAKpF,KAAKqH,OAAOyB,iBAAiB,4BAKf9I,KAAK8B,gBAAgB,oFAG1BiH,kBALH,EAMf,EAEJvL,EAAQE,YAAcA,C,6BClhBtB,SAASsL,EAAiBC,GACtB,MAA0B,UAAnBA,EAAUC,IACrB,CAJA5L,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IACtDD,EAAQ6K,2BAaR,SAAoChD,GAChC,MAAM8D,EAVV,SAA+BC,GAC3B,MAAM,YAAEC,GAAgBD,EACxB,GAA2B,IAAvBC,EAAYnJ,QAAwC,wBAAxBmJ,EAAY,GAAGH,KAC3C,MAAM,IAAI9D,MAAM,kEAEpB,OAAOiE,EAAY,GAAGC,YAC1B,CAI+BC,CAAsBlE,EAAMA,OAClDmE,WACAC,OAAOT,GACP5I,KAAI6I,GAAaA,EAAUS,KAAKjM,QACrC,GAAkC,IAA9B0L,EAAmBjJ,OACnB,MAAM,IAAIkF,MAAM,+DAA+D+D,EAAmBjJ,WAAWiJ,EAAmB7I,KAAK,SAEzI,OAAO6I,EAAmB,EAC9B,C,6BCvBA7L,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IACtDD,EAAQmM,0BAAuB,EA6B/BnM,EAAQmM,qBA5BR,MACI,WAAA/J,CAAY4G,EAAIoD,EAAaC,GACzB7J,KAAKwG,GAAKA,EACVxG,KAAK4J,YAAcA,EACnB5J,KAAK6J,mBAAqBA,CAC9B,CACA,2BAAMC,GACF,MAAMC,QAA2B/J,KAAK6J,qBACtC,GAA2B,OAAvBE,EACA,MAAM,IAAI3E,MAAM,uDAEhB,OAAO2E,CACf,CACA,qBAAMC,GACF,aAAchK,KAAK8J,yBAAyBG,YAChD,CACA,eAAMC,GACF,aAAclK,KAAK8J,yBAAyBI,SAChD,CACA,QAAAzD,GACI,OAAIzG,KAAK4J,YACE,oBAAsB5J,KAAK4J,YAG3BtM,OAAOmJ,SAAS0D,KAAKnK,KAEpC,E,qDC5BJ1C,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IACtDD,EAAQ4M,gCAA6B,EACrC,MAAM5L,EAAI,EAAQ,MACZ6L,EAAgB,EAAQ,OACxBC,EAAkB,EAAQ,OAC1BC,EAAiB,EAAQ,OACzBC,EAA2B,EAAQ,OACnCC,EAAuB,EAAQ,OACrC,SAASC,EAAqB7K,EAAS8K,GAC/B9K,EAAQ+K,aAER/K,EAAQ+K,aAAetJ,KAAKC,MAAM1B,EAAQ+K,cAE3B,qBAAVD,GAA0C,iBAAVA,IAErC9K,EAAQ+K,aAAe,CAAC,GAExB/K,EAAQgL,YACRhL,EAAQgL,WAAavJ,KAAKC,MAAM1B,EAAQgL,YAGxChL,EAAQY,SAAU,EAAI8J,EAAeO,oBAAoBjL,EAAQgL,aAE5DhL,EAAQY,UAEbZ,EAAQY,QAAUa,KAAKC,MAAM1B,EAAQY,SACrCZ,EAAQgL,YAAa,EAAIN,EAAeQ,oBAAoBlL,EAAQY,UAEpEZ,EAAQmL,aACRnL,EAAQmL,YAAc1J,KAAKC,MAAM1B,EAAQmL,aACzCnL,EAAQoL,UAAW,EAAIV,EAAeO,oBAAoBjL,EAAQmL,cAE7DnL,EAAQgL,YAAchL,EAAQsB,OACnCtB,EAAQmL,YAAc,GACtBnL,EAAQoL,SAAW,CAAC,QAEH/E,IAAjBrG,EAAQsB,OAERtB,EAAQsB,MAAO,EAAImJ,EAAgBY,iBAAiBC,EAAOC,KAAKvL,EAAQsB,KAAM,UAAWtB,EAAQY,UAGhGZ,EAAQwL,OACTxL,EAAQwL,KAAO,IACfV,GAAOW,WAAW,UAEdzL,EAAQ0L,YACR1L,EAAQ0L,YAAcjK,KAAKC,MAAM1B,EAAQ0L,aAIzC1L,EAAQ0L,YAAc,CAAC,EAGnC,CAsZA/N,EAAQ4M,2BAzYR,MACI,WAAAxK,CAAYyH,GACRrH,KAAKqH,OAASA,EACdrH,KAAKwL,sBAAwB,CAACxD,EAAayD,IAAW1N,UA2BlD,MAAM2N,SA1Ba1D,EAAYN,UAAU,CACrCrC,MAAWgF,EAAcsB,OAAS;;;;;;;;;;;kCAWhB3L,KAAKqH,OAAOiB,aAAa,UAAW,cAChD,aACA;;;kCAGYtI,KAAKqH,OAAOuE,gBAAgB,UAAW;kCACvC5L,KAAKqH,OAAOuE,gBAAgB,UAAW;;8BAE3C5L,KAAKqH,OAAOuE,gBAAgB,iBAAkB;;;kBAI5DtG,UAAW,CAAEkB,GAAIiF,MAESC,eAC9B,OAAKA,GAELA,EAAezB,aAAavJ,SAAQmL,GAAOnB,EAAqBmB,KACzDH,GAFI,IAEU,CAE7B,CACA,yBAAAI,CAA0BC,EAAOhK,EAAOuF,GACpC,MAAM0E,GAAejK,EAAQ,MAAQ,OAAS,QACxCkK,GAAgBlK,EAAQ,MAAQ,OAAS,QACzCmK,EAAkBH,EAAM3L,KAAK+L,IAC/B,MAAMC,GAAiB,EAAI3B,EAAqB4B,mBAAmBF,EAAM7E,GAIzE,OAHKtH,KAAKqH,OAAOiF,kBAAkB,WAAY,cACpCF,EAAe5F,GAEnB4F,CAAc,IAEzB,MAAO,CACH/G,MAAWgF,EAAcsB,OAAS;2BACnBK;iCACMC;;0BAEPjM,KAAKqH,OAAOuE,gBAAgB,iBAAkB;;;cAI5DtG,UAAW,CACPiH,SAAUL,GAEdpE,kBAAmB,CAAChI,GAAYkI,iBACrBlI,EAAS0M,UAAUpM,KAAI,EAAGoG,KAAIoD,iBAAkB,IAAIY,EAAyBb,qBAAqBnD,EAAIoD,EAAa5J,KAAKwL,sBAAsBxD,EAAaxB,MAG9K,CACA,2BAAAiG,CAA4BV,EAAOhK,EAAOuF,GAGtC,MAAM0E,GAAejK,EAAQ,MAAQ,OAAS,iBACxCkK,GAAgBlK,EAAQ,MAAQ,OAAS,iBACzCmK,EAAkBH,EAAM3L,KAAK+L,IAAS,EAAI1B,EAAqB4B,mBAAmBF,EAAM7E,KAC9F,MAAO,CACHjC,MAAWgF,EAAcsB,OAAS;2BACnBK;iCACMC;;;;;cAMrB3G,UAAW,CACPiH,SAAUL,GAEdpE,kBAAmB,CAAChI,GAAYkI,iBACrBlI,EAAS0M,UAAUpM,KAAI,EAAGoG,KAAIoD,iBAAkB,IAAIY,EAAyBb,qBAAqBnD,EAAIoD,EAAa5J,KAAKwL,sBAAsBxD,EAAaxB,MAG9K,CAEA,yBAAAkG,GACI,MAAO,CACHrH,MAAWgF,EAAcsB,OAAS;;;;0BAIpB3L,KAAKqH,OAAOuE,gBAAgB,iBAAkB;;;cAI5D9D,kBAAmB,CAAChI,GAAYkI,iBACJlI,EAAS6M,gBACVvM,KAAI,EAAGoG,KAAIoD,iBAAkB,IAAIY,EAAyBb,qBAAqBnD,EAAIoD,EAAa5J,KAAKwL,sBAAsBxD,EAAaxB,MAG3K,CACA,0BAAAoG,GACI,MAAO,CACHvH,MAAWgF,EAAcsB,OAAS;;;;;;;cAQlC7D,kBAAmB,CAAChI,GAAYkI,iBACHlI,EAAS+M,iBACVzM,KAAI,EAAGoG,KAAIoD,iBAAkB,IAAIY,EAAyBb,qBAAqBnD,EAAIoD,EAAa5J,KAAKwL,sBAAsBxD,EAAaxB,MAG5K,CACA,wBAAAsG,CAAyBnC,GAGrB,MAAMtF,EAAQ,CACV,oBAAyBgF,EAAcsB,OAAS;;;;;;;sBAOtC3L,KAAKqH,OAAOuE,gBAAgB,mBAAoB;sBAChD5L,KAAKqH,OAAOuE,gBAAgB,mBAAoB;;;sBAGhD5L,KAAKqH,OAAOiB,aAAa,mBAAoB,cACjD,aACA;;;sBAGItI,KAAKqH,OAAOuE,gBAAgB,mBAAoB;;eAG1DnD,QAAa4B,EAAcsB,OAAS;;;sBAG1B3L,KAAKqH,OAAOuE,gBAAgB,UAAW;;;;;sBAKvC5L,KAAKqH,OAAOuE,gBAAgB,UAAW;sBACvC5L,KAAKqH,OAAOuE,gBAAgB,UAAW;;;sBAGvC5L,KAAKqH,OAAOiB,aAAa,UAAW,cACxC,aACA;;;sBAGItI,KAAKqH,OAAOuE,gBAAgB,UAAW;;sBAEvC5L,KAAKqH,OAAOuE,gBAAgB,UAAW;sBACvC5L,KAAKqH,OAAOuE,gBAAgB,UAAW;sBACvC5L,KAAKqH,OAAOuE,gBAAgB,UAAW;;eAGjD9L,SAAcuK,EAAcsB,OAAS;;;;;;sBAM3B3L,KAAKqH,OAAOiB,aAAa,WAAY,cACzC,aACA;;;sBAGItI,KAAKqH,OAAOuE,gBAAgB,WAAY;;sBAExC5L,KAAKqH,OAAOuE,gBAAgB,WAAY;sBACxC5L,KAAKqH,OAAOuE,gBAAgB,WAAY;;eAGlD,oBAAyBvB,EAAcsB,OAAS;;;;;;;;;;;;;;sBActC3L,KAAKqH,OAAOuE,gBAAgB,UAAW;;;;;;eAOjD,qBAA0BvB,EAAcsB,OAAS;;;;;;;;sBAQvC3L,KAAKqH,OAAOuE,gBAAgB,WAAY;;;;;eAMlD,6BAAkCvB,EAAcsB,OAAS;;;;;;;;;;;eAYzD,yBAA8BtB,EAAcsB,OAAS;;;;;;;;;;;eAYrD,kBAAuBtB,EAAcsB,OAAS;;;;;;;;;;eAW9CoB,MAAW1C,EAAcsB,OAAS;;;;;;;;;sBASxB3L,KAAKqH,OAAOiB,aAAa,UAAW,cACxC,aACA;;sBAEItI,KAAKqH,OAAOuE,gBAAgB,UAAW;sBACvC5L,KAAKqH,OAAOuE,gBAAgB,UAAW;sBACvC5L,KAAKqH,OAAOuE,gBAAgB,iBAAkB;;eAGxD,yBAA8BvB,EAAcsB,OAAS;;;;;;;;;;sBAU3C3L,KAAKqH,OAAOuE,gBAAgB,sBAAuB;;eAG7D,yBAA8BvB,EAAcsB,OAAS;;;;;;;;;;sBAU3C3L,KAAKqH,OAAOuE,gBAAgB,sBAAuB;;eAG7D,mBAAwBvB,EAAcsB,OAAS;;;;;sBAKrC3L,KAAKqH,OAAOuE,gBAAgB,CAAC,sBAAuB,cAAe;sBACnE5L,KAAKqH,OAAOuE,gBAAgB,CAAC,sBAAuB,cAAe;sBACnE5L,KAAKqH,OAAOuE,gBAAgB,CAAC,sBAAuB,cAAe;sBACnE5L,KAAKqH,OAAOuE,gBAAgB,CAAC,sBAAuB,cAAe;;eAG7E,eAAoBvB,EAAcsB,OAAS;;;;;;;;;;;;;0BAa7B3L,KAAKqH,OAAOiB,aAAa,qBAAsB,cACvD,aACA;;0BAEQtI,KAAKqH,OAAOuE,gBAAgB,qBAAsB;0BAClD5L,KAAKqH,OAAOuE,gBAAgB,qBAAsB;;;;;;;;;0BASlD5L,KAAKqH,OAAOiB,aAAa,WAAY,cAC7C,aACA;;;0BAGQtI,KAAKqH,OAAOuE,gBAAgB,WAAY;;;eAItD,aAAkBvB,EAAcsB,OAAS;;;;;;;gBAQ3ChB,GACF,GAAKtF,EAEL,MAAO,CACHA,QACAyC,kBAAoBtC,IAChB,GAAc,iBAAVmF,EACAnF,EAAKiD,QAAUjK,EAAEwO,UAAUxH,EAAKiD,SAAUwE,GAEpC,OAANA,OAAa/G,EAAY+G,IACzBvC,EAAqBlF,EAAKiD,QAASkC,GAC/BnF,EAAK1F,SACL4K,EAAqBlF,EAAK1F,SAAU6K,GAGpCnF,EAAK1F,SAAW,eAGnB,GAAc,+BAAV6K,GAAoD,2BAAVA,GA/XhC9K,EAgYW2F,GA9XlCoF,aAAetJ,KAAKC,MAAM1B,EAAQ+K,cAE1C/K,EAAQqN,QAAU/B,EAAOC,KAAKvL,EAAQqN,QAAS,eA8X9B,GAAc,UAAVvC,EACLD,EAAqBlF,EAAMmF,GAC3BnF,EAAKhE,MAAQgE,EAAKhE,MAAQF,KAAKC,MAAMiE,EAAKhE,YAAS0E,OAElD,GAAc,eAAVyE,EAAwB,CAC7B,MAAM,UAAEwC,GAAc3H,OAEIU,IAAtBiH,EAAUC,UACVD,EAAUC,QAAUjC,EAAOC,KAAK+B,EAAUC,QAAS,UAE3D,MAEI1C,EAAqBlF,EAAMmF,GA9Y/C,IAAmC9K,EAgZnB,OAAO2F,CAAI,EAGvB,E,+BCzcJlI,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IACtDD,EAAQ6P,mBAAgB,EACxB,MAAM7O,EAAI,EAAQ,MACZ8O,EAAY,EAAQ,OACpBC,EAAiB,EAAQ,OACzBC,EAAkC,EAAQ,OAUhD,MAAMH,UAAsBC,EAAUG,gBAClC,WAAA7N,CAAY5B,EAAU,CAAC,GACnB+B,MAAMvB,EAAEyD,SAASjE,EAAS,CAGtB0P,MAAM,KAEV1N,KAAK+B,MAAQ,IACF/B,KAAKgI,YAAYjG,QAE5B/B,KAAK2N,gBAAkB5P,SAAUgO,IACtB/L,KAAK4N,iBAAiB7B,GAAO,GAExC/L,KAAK6N,gBAAkB9P,SAAUgO,IACtB/L,KAAK4N,iBAAiB7B,GAAO,GAExC/L,KAAK8N,kBAAoB/P,SAAUgO,IACxB/L,KAAK+N,YAAYhC,GAAO,GAEnC/L,KAAKgO,kBAAoBjQ,SAAUgO,IACxB/L,KAAK+N,YAAYhC,GAAO,GAEnC/L,KAAK4N,iBAAmB7P,MAAOgO,EAAOhK,KAClC,IAAK/B,KAAKiO,eACN,MAAM,IAAI7I,MAAM,iDACpB,MAAM,YAAEkC,GAAgBtH,KAAKgI,YAC7B,OAAOhI,KAAKgI,YAAYN,UAAU1H,KAAKiO,eAAenC,0BAA0BC,EAAOhK,EAAOuF,GAAa,EAE/GtH,KAAK+N,YAAchQ,MAAOgO,EAAOhK,KAC7B,IAAK/B,KAAKiO,eACN,MAAM,IAAI7I,MAAM,iDACpB,MAAM,YAAEkC,GAAgBtH,KAAKgI,YAC7B,OAAOhI,KAAKgI,YAAYN,UAAU1H,KAAKiO,eAAexB,4BAA4BV,EAAOhK,EAAOuF,GAAa,EAEjHtH,KAAKkO,kBAAoBlQ,EACzBgC,KAAKgI,YAAc,IAAIuF,EAAe7P,YAAY,CAC9CQ,eAAgBF,EAAQE,eACxBI,eAAgBN,EAAQwK,QAEhC,CACA,WAAA3G,GACI,OAAO7B,KAAKgI,YAAYnG,aAC5B,CACA,OAAIb,GACA,OAAOhB,KAAKgI,YAAYZ,SAASf,KAAK8H,QAC1C,CACA,QAAIlI,GACA,OAAOjG,KAAKgI,YAAYZ,SAASf,KAAKJ,IAC1C,CACA,WAAMN,CAAMM,SACFjG,KAAKgI,YAAYrC,MAAM,CACzBU,KAAM,CACFJ,OACAjI,QAASgC,KAAKkO,qBAGtBlO,KAAKiO,eAAiB,IAAIT,EAAgCpD,2BAA2BpK,KAAKgI,YAAYX,OAC1G,CACA,IAAAV,GACI,OAAO3G,KAAKgI,YAAYrB,MAC5B,CACA,wBAAMyH,GACF,IAAKpO,KAAKiO,eACN,MAAM,IAAI7I,MAAM,8DACpB,OAAOpF,KAAKgI,YAAYN,UAAU1H,KAAKiO,eAAevB,4BAC1D,CACA,yBAAM2B,GACF,IAAKrO,KAAKiO,eACN,MAAM,IAAI7I,MAAM,+DACpB,OAAOpF,KAAKgI,YAAYN,UAAU1H,KAAKiO,eAAerB,6BAC1D,CACA,0BAAM/D,GACF,OAAO7I,KAAKgI,YAAYa,sBAC5B,CACA,EAAAnG,CAAGiI,EAAOxC,GACN,GAAIwC,EAAMW,WAAW,iBAGjB,OADAtL,KAAKgI,YAAYtF,GAAGiI,EAAM2D,MAAM,IAAyBnG,GAClD3E,QAAQC,UAEnB,IAAKzD,KAAKiO,eACN,MAAM,IAAI7I,MAAM,mEACpB,MAAMmJ,EAAavO,KAAKiO,eAAenB,yBAAyBnC,GAChE,OAAK4D,EAQEvO,KAAKgI,YAAYE,UAAUqG,EAAYpG,IAH1CtF,QAAQC,KAAK,mEAAmE6H,KACzEnH,QAAQC,UAGvB,EAEJjG,EAAQ6P,cAAgBA,C,+BC7GxB/P,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IACtDD,EAAQsJ,mBAAqBtJ,EAAQqJ,wBAAqB,EAC1D,MAAMrI,EAAI,EAAQ,MAiClBhB,EAAQqJ,mBAhCR,MACI,WAAAjH,CAAYgH,GACR5G,KAAK4G,kBAAoBA,CAC7B,CACA,gBAAAkC,CAAiB0F,GACb,OAAOxO,KAAKsI,aAAa,QAASkG,EACtC,CACA,aAAAC,CAAcC,GACV,OAAOlQ,EAAEmQ,KAAK3O,KAAK4G,kBAAkBgI,MAAO,CAAElF,KAAMgF,GACxD,CACA,YAAApG,CAAaoG,EAAUtG,GACnB,MAAMyG,EAAOrQ,EAAEsQ,KAAK9O,KAAK4G,kBAAkBgI,MAAO,CAAElF,KAAMgF,IAC1D,QAAKG,KAEIrQ,EAAEsQ,KAAKD,EAAKE,OAAQ,CAAErF,KAAMtB,GACzC,CACA,eAAAwD,CAAgB8C,EAAUtG,GACtB,MACM4G,GADiBC,MAAMC,QAAQR,GAAyBA,EAAb,CAACA,IACTI,MAAMpF,GAAS1J,KAAKyO,cAAc/E,KAC3E,OAAKsF,GAEGhP,KAAKsI,aAAa0G,EAAoB5G,GACxCA,EAFK,EAIf,CACA,iBAAAkE,CAAkBoC,EAAUtG,GACxB,MAAMyG,EAAOrQ,EAAEsQ,KAAK9O,KAAK4G,kBAAkBgI,MAAO,CAAElF,KAAMgF,IAC1D,QAAKG,KAEIrQ,EAAEsQ,KAAKD,EAAKM,YAAa,CAAEzF,KAAMtB,GAC9C,GAKJ5K,EAAQsJ,mBAAqB,u6C,+BCrC7BtJ,EAAQ4R,sBAAwB5R,EAAQ6R,eAA4C7R,EAAQ,GAA0EA,EAAQ,GAAqBA,EAAQ,GAA8BA,EAAQ,GAA4BA,EAAQ,GAAkCA,EAAQ,QAAS,EAI/S,EAAQ,OACjC,IAAIW,EAAU,EAAQ,OACtBb,OAAOC,eAAeC,EAAS,KAA/B,CAA2C8R,YAAY,EAAMC,IAAK,WAAc,OAAOpR,EAAQqR,MAAQ,IAGvG,MAAMC,EAAW,EAAQ,OACzBjS,EAAQ,GAAWiS,EACnB,MAAMC,EAA4B,EAAQ,OAC1ClS,EAAQ,GAA4BkS,EACpC,MAAMC,EAA8B,EAAQ,OAC5CnS,EAAQ,GAA8BmS,EACtC,MAAMC,EAAqB,EAAQ,OACnCpS,EAAQ,GAAqBoS,EAORF,EAA0BG,wBACxBH,EAA0BI,0BAC5BJ,EAA0BK,wBAC5BL,EAA0BM,sBACnBN,EAA0BO,6BACtBP,EAA0BQ,iCAClCR,EAA0BS,yBAC3BT,EAA0BU,wBAGZT,EAA4BU,sCACjCV,EAA4BO,iCACpCP,EAA4BQ,yBAC3BR,EAA4BW,0BAEnD,IAAIC,EAAoB,EAAQ,OAChCjT,OAAOC,eAAeC,EAAS,KAA/B,CAAsD8R,YAAY,EAAMC,IAAK,WAAc,OAAOgB,EAAkBC,iBAAmB,IAWlH,EAAQ,OAE7BhT,EAAQ6R,eAAiB,EAAzB,OACA7R,EAAQ4R,sBAAwB,EAAhC,M,+BCtDA9R,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IACtDD,EAAQiQ,qBAAkB,EAC1B,MAAMgD,EAAgB,EAAQ,OACxBC,EAAyB,EAAQ,OACjCC,EAA2B,EAAQ,OACnCxS,EAAU,EAAQ,OAyExBX,EAAQiQ,gBArER,MACI,WAAA7N,CAAY5B,GACRgC,KAAK4Q,eAAkBzE,GAASnM,KAAK2N,gBAAgBxB,GAAMvI,MAAMmI,GAAUA,EAAM,KACjF/L,KAAK6Q,iBAAoB1E,GAASnM,KAAK8N,kBAAkB3B,GAAMvI,MAAMmI,GAAUA,EAAM,KACrF/L,KAAK2B,MAAQ3D,EAAQ2D,QAAS,EAC9B3B,KAAK8Q,YAAc9S,EAAQ0P,OAAQ,EACnC1N,KAAK+Q,mBAA0C7K,IAA1BlI,EAAQ+S,eACvB/S,EAAQ+S,cAEd/Q,KAAKgR,oBAA4C9K,IAA3BlI,EAAQgT,gBACxBhT,EAAQgT,cAElB,CACA,YAAIC,GACA,MAAO,CACHC,WAAYlR,KAAKgB,IACjBmQ,YAAanR,KAAKgB,IAE1B,CACA,MAAAoQ,CAAOrQ,GACH,OAAOf,KAAKgB,IAAMD,CACtB,CACA,aAAAsQ,GACI,OAAO,IAAIX,EAAuBY,mBAAmBtR,KAAK4Q,eAC9D,CACA,mBAAAW,GACI,OAAO,IAAIb,EAAuBY,mBAAmBtR,KAAK4Q,gBACrDY,WAAWrT,EAAQsT,aAAaC,SACzC,CACA,MAAAC,CAAO3Q,GACH,OAAO,IAAI0P,EAAuBY,mBAAmBnT,EAAQqR,OAAOoC,IAAK5Q,EAAKhB,KAAK4Q,eACvF,CACA,OAAAiB,CAAQ7Q,GACJ,OAAO,IAAI0P,EAAuBY,mBAAmBnT,EAAQqR,OAAOsC,KAAM9Q,EAAKhB,KAAK4Q,eACxF,CACA,MAAAmB,CAAO/Q,GACH,OAAO,IAAI0P,EAAuBY,mBAAmBnT,EAAQqR,OAAOwC,IAAKhR,EAAKhB,KAAK4Q,eACvF,CACA,SAAAqB,CAAUjR,GACN,OAAO,IAAI0P,EAAuBY,mBAAmBnT,EAAQqR,OAAO0C,OAAQlR,EAAKhB,KAAK4Q,eAC1F,CACA,QAAAuB,CAASnR,GACL,OAAO,IAAI0P,EAAuBY,mBAAmBnT,EAAQqR,OAAO4C,MAAOpR,EAAKhB,KAAK4Q,eACzF,CACA,OAAAyB,CAAQrR,GACJ,OAAO,IAAI0P,EAAuBY,mBAAmBnT,EAAQqR,OAAO8C,KAAMtR,EAAKhB,KAAK4Q,eACxF,CACA,UAAA2B,CAAWvR,GACP,GAAIhB,KAAK8Q,YACL,MAAM,IAAI1L,MAAUqL,EAAc+B,WAAa;;;mHAGwD,kGAAkG;eAG7M,OAAO,IAAI9B,EAAuBY,mBAAmBnT,EAAQqR,OAAOiD,QAASzR,EAAKhB,KAAK4Q,eAC3F,CACA,iBAAA8B,CAAkBC,EAAQ,CAAC,GACvB,OAAO,IAAIjC,EAAuBY,mBAAmBtR,KAAK4Q,gBACrDgC,sBAAsB,CACvBC,QAAS,SACLF,EAAMpU,OAAS,CAAEA,OAAQoU,EAAMpU,QAAW,CAAC,KAC3CoU,EAAMG,OAAS,CAAEA,OAAQH,EAAMG,QAAW,CAAC,GAEvD,CACA,eAAAC,GACI,OAAO,IAAIpC,EAAyBqC,qBAAqBhT,KAAK6Q,iBAClE,E,+BC3EJrT,EAAQ4M,gCAA0D,EAOlE,IAAIoD,EAAkC,EAAQ,OAC9ClQ,OAAOC,eAAeC,EAAS,6BAA8B,CAAE8R,YAAY,EAAMC,IAAK,WAAc,OAAO/B,EAAgCpD,0BAA4B,G,+BCTvK9M,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IACtDD,EAAQyV,cAAgBzV,EAAQE,YAAcF,EAAQ0V,iBAAc,EAMpE1V,EAAQ0V,YALR,MACI,WAAAtT,GACI,MAAM,IAAIwF,MAAM,8CACpB,GAGJ,IAAImI,EAAiB,EAAQ,OAC7BjQ,OAAOC,eAAeC,EAAS,cAAe,CAAE8R,YAAY,EAAMC,IAAK,WAAc,OAAOhC,EAAe7P,WAAa,IACxHF,EAAQyV,cAAgB,EAAxB,M,+BCVA3V,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IACtDD,EAAQ2V,qBAAkB,EAC1B,MAAMC,EAAW,EAAQ,MACnBjV,EAAU,EAAQ,OAClBkV,EAAwB,EAAQ,OAChCC,EAAa,EAAQ,OAmP3B9V,EAAQ2V,gBA3OR,MAKI,WAAAvT,GACII,KAAKyP,SAAW,GAChBzP,KAAKuT,SAAWpV,EAAQsT,aAAa+B,OACzC,CACA,iBAAAC,GACI,MAAO,CACHF,SAAUvT,KAAKuT,SACf9D,SAAUzP,KAAKyP,SACfiE,kBAAmB1T,KAAK0T,kBAEhC,CAaA,UAAAlC,CAAW+B,GAEP,OADAvT,KAAKuT,SAAWA,EACTvT,IACX,CAaA,OAAA2T,CAAQC,GAEJ,OADA5T,KAAKyP,SAASoE,KAAK,IAAIP,EAAWQ,YAAYF,IACvC5T,IACX,CAMA,WAAA+T,CAAYC,GAER,OADAhU,KAAKyP,SAASoE,KAAK,IAAIP,EAAWW,gBAAgBD,IAC3ChU,IACX,CAMA,OAAAkU,CAAQjO,GAEJ,OADAjG,KAAKyP,SAASoE,KAAK,IAAIP,EAAWa,YAAYlO,IACvCjG,IACX,CAKA,WAAAoU,CAAY3T,GAER,OADAT,KAAKyP,SAASoE,KAAK,IAAIP,EAAWe,cAAc5T,IACzCT,IACX,CAKA,SAAAsU,CAAUjP,GAEN,OADArF,KAAKyP,SAASoE,KAAK,IAAIP,EAAWiB,aAAalP,IACxCrF,IACX,CAMA,cAAAwU,CAAenP,GAEX,OADArF,KAAKyP,SAASoE,KAAK,IAAIP,EAAWmB,kBAAkBpP,IAC7CrF,IACX,CAKA,QAAA0U,CAASC,GAEL,OADA3U,KAAKyP,SAASoE,KAAK,IAAIP,EAAWsB,gBAAgBD,IAC3C3U,IACX,CAcA,iBAAA6U,IAAqBC,GAEjB,OADA9U,KAAKyP,SAASoE,KAAK,IAAIP,EAAWyB,yBAAyBD,IACpD9U,IACX,CAOA,QAAAgV,CAAS9H,GAIL,OAHAlN,KAAKyP,SAASoE,MAAK,EAAIT,EAAS6B,UAAU/H,GACpC,IAAIoG,EAAW4B,eAAehI,GAC9B,IAAIoG,EAAW6B,iBAAiBjI,IAC/BlN,IACX,CAKA,iBAAAoV,CAAkBlI,GAEd,OADAlN,KAAKyP,SAASoE,KAAK,IAAIP,EAAW+B,uBAAuBnI,IAClDlN,IACX,CASA,YAAAsV,CAAa7T,GAET,OADAzB,KAAKyP,SAASoE,KAAK,IAAIP,EAAWiC,gBAAgB9T,IAC3CzB,IACX,CAWA,qBAAA4S,CAAsBnR,GAElB,OADAzB,KAAKyP,SAASoE,KAAK,IAAIP,EAAWkC,wBAAwB/T,IACnDzB,IACX,CAKA,UAAAyV,CAAWC,GAEP,OADA1V,KAAKyP,SAASoE,KAAK,IAAIP,EAAWqC,cAAcD,IACzC1V,IACX,CAKA,YAAA4V,CAAaC,GAET,OADA7V,KAAKyP,SAASoE,KAAK,IAAIP,EAAWwC,gBAAgBD,IAC3C7V,IACX,CAKA,eAAA+V,CAAgBC,GAEZ,OADAhW,KAAKyP,SAASoE,KAAK,IAAIP,EAAW2C,gBAAgBD,IAC3ChW,IACX,CAKA,QAAAkW,CAAShJ,GAEL,OADAlN,KAAKyP,SAASoE,KAAK,IAAIP,EAAW6C,gBAAgBjJ,IAC3ClN,IACX,CAKA,MAAAoW,GAEI,OADApW,KAAK0T,kBAAoB,IAAIL,EAAsBgD,OAC5CrW,IACX,CAKA,IAAA2D,GAEI,OADA3D,KAAK0T,kBAAoB,IAAIL,EAAsBiD,KAC5CtW,IACX,CAKA,KAAAuW,GAEI,OADAvW,KAAK0T,kBAAoB,IAAIL,EAAsBmD,MAC5CxW,IACX,CAKA,MAAAyW,GAEI,OADAzW,KAAK0T,kBAAoB,IAAIL,EAAsBqD,OAC5C1W,IACX,CAKA,KAAA2W,CAAMC,GAEF,OADA5W,KAAK0T,kBAAoB,IAAIL,EAAsBwD,OAAOD,GACnD5W,IACX,E,+BCtPJ1C,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IACtDD,EAAQsZ,wBAA0BtZ,EAAQqZ,OAASrZ,EAAQkZ,OAASlZ,EAAQgZ,MAAQhZ,EAAQ8Y,KAAO9Y,EAAQ6Y,YAAS,EACpH,MAAMU,EAAkB,EAAQ,OAChC,MAAMV,UAAeU,EAAgBC,aACjC,WAAApX,GACIG,SAASkX,WACTjX,KAAK6O,KAAO,QAChB,CACA,UAAAqI,GACI,OAAO,CACX,CACA,OAAAC,CAAQC,GACJ,OAAOC,EAAaD,EAAkBE,IAAU,SACpD,EAEJ9Z,EAAQ6Y,OAASA,EACjB,MAAMC,UAAaS,EAAgBC,aAC/B,WAAApX,GACIG,SAASkX,WACTjX,KAAK6O,KAAO,MAChB,CACA,UAAAqI,CAAWE,GACP,OAAOA,GAAoB,CAC/B,CACA,OAAAD,CAAQC,GACJ,OAAOC,EAAaD,EAAkB,EAAG,OAC7C,EAEJ5Z,EAAQ8Y,KAAOA,EACf,MAAME,UAAcO,EAAgBC,aAChC,WAAApX,GACIG,SAASkX,WACTjX,KAAK6O,KAAO,OAChB,CACA,UAAAqI,CAAWE,GACP,OAAOA,GAAoB,CAC/B,CACA,OAAAD,CAAQC,GACJ,OAAOC,EAAaD,EAAkB,EAAG,QAC7C,EAEJ5Z,EAAQgZ,MAAQA,EAChB,MAAME,UAAeK,EAAgBC,aACjC,WAAApX,GACIG,SAASkX,WACTjX,KAAK6O,KAAO,QAChB,CACA,UAAAqI,CAAWE,GACP,OAAOA,GAAoB,CAC/B,CACA,OAAAD,CAAQC,GACJ,OAAOC,EAAaD,EAAkB,EAAG,SAC7C,EAEJ5Z,EAAQkZ,OAASA,EACjB,MAAMG,UAAeE,EAAgBC,aACjC,WAAApX,CAAY2X,GACRxX,QACAC,KAAKuX,MAAQA,EACbvX,KAAK6O,KAAO,OAChB,CACA,UAAAqI,CAAWE,GACP,OAAOA,GAAoBpX,KAAKuX,KACpC,CACA,OAAAJ,CAAQC,GACJ,OAAOC,EAAaD,EAAkBpX,KAAKuX,MAAO,GAAGvX,KAAKuX,cAC9D,EAUJ,SAASF,EAAaG,EAAMZ,EAAGlN,GAC3B,YAAaxD,IAATsR,EAEO9N,EAGAA,EAAO,KAAO8N,EAAOZ,EAAI,SAASY,KAAU,SAE3D,CAhBAha,EAAQqZ,OAASA,EACjBrZ,EAAQsZ,wBAA0B,CAC9B,OAAUT,EACV,KAAQC,EACR,MAASE,EACT,OAAUE,EACV,MAASG,E,qDC1EbvZ,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IACtDD,EAAQia,cAAgBja,EAAQ2Y,gBAAkB3Y,EAAQmY,cAAgBnY,EAAQgY,wBAA0BhY,EAAQ+X,gBAAkB/X,EAAQ2X,iBAAmB3X,EAAQ6X,uBAAyB7X,EAAQ0X,eAAiB1X,EAAQuX,yBAA2BvX,EAAQoX,gBAAkBpX,EAAQ+W,aAAe/W,EAAQiX,kBAAoBjX,EAAQ6W,cAAgB7W,EAAQyY,gBAAkBzY,EAAQka,iBAAmBla,EAAQma,kBAAoBna,EAAQ2W,YAAc3W,EAAQyW,gBAAkBzW,EAAQsW,YAActW,EAAQsY,gBAAkBtY,EAAQoa,cAAgBpa,EAAQqa,qBAAkB,EACtkBra,EAAQsa,WAgeR/Z,eAA0B8N,EAAK4D,GAC3B,OAAO,IAAIjM,SAAQ,CAACC,EAASC,KACzB,MAAMqU,EAAkBtI,EAASrP,KAAK4X,GAAYA,EAAQC,QAAQpM,KAClEkM,EAAgBrX,SAAQ3C,MAAOma,IAC3B,UACyBA,GAEjBzU,GAAQ,EAChB,CACA,MAAOpD,GACHqD,EAAOrD,EACX,KAGJmD,QAAQyE,IAAI8P,GACPnU,MAAMmC,GAAWtC,EAAQjF,EAAE2Z,MAAMpS,MACjClC,OAAOxD,GAAMqD,EAAOrD,IAAG,GAEpC,EAjfA7C,EAAQ4a,gBAkfR,SAAyB3I,GACrB,OAAwB,IAApBA,EAASvP,OACFuP,EAAS,GAAG0H,UACC,IAApB1H,EAASvP,OAEF,GAAGuP,EAAS,GAAG0H,aAAa1H,EAAS,GAAG0H,YAG5C1H,EAASnB,MAAM,GAAI,GACrBlO,KAAKiY,GAAMA,EAAElB,YACb7W,KAAK,MAAQ,SAAWmP,EAASnB,OAAO,GAAG,GAAG6I,SACvD,EA5fA,MAAM3Y,EAAI,EAAQ,MACZwC,EAAM,EAAQ,OACdyP,EAAgB,EAAQ,OACxB6H,EAAY,EAAQ,OACpBna,EAAU,EAAQ,OAClBoa,EAAQ,EAAQ,MAChBjO,EAAkB,EAAQ,OAC1ByM,EAAkB,EAAQ,OAC1ByB,EAAuB,EAAQ,OACrC,SAASC,EAAeC,GACpB,OAAOA,EAAMnW,QAAQ,QAAS,IAClC,CACA,MAAMsV,UAAwBd,EAAgBC,aAC1C,WAAApX,GACIG,SAASkX,WACTjX,KAAK6O,KAAO,UAChB,CACA,OAAAoJ,GACI,OAAO,CACX,CACA,OAAAd,GACI,MAAO,cACX,EAEJ3Z,EAAQqa,gBAAkBA,EAC1B,MAAMD,UAAsBb,EAAgBC,aACxC,WAAApX,CAAYrB,GACRwB,QACAC,KAAKzB,OAASA,EACdyB,KAAK6O,KAAO,QAChB,CACA,OAAAoJ,CAAQxP,GACJ,OAAOA,EAAQlK,SAAWJ,EAAQqR,OAAOxP,KAAKzB,OAClD,CACA,OAAA4Y,GACI,MAAO,UAAUhZ,EAAQqR,OAAOxP,KAAKzB,UACzC,EAEJf,EAAQoa,cAAgBA,EACxB,MAAM9B,UAAwBiB,EAAgBC,aAC1C,WAAApX,CAAYiW,GAIR,GAHA9V,QACAC,KAAK6V,SAAWA,EAChB7V,KAAK6O,KAAO,WACK,SAAbgH,GACa,UAAbA,GACa,OAAbA,GACa,QAAbA,EACA,MAAM,IAAIzQ,MAAM,wEAExB,CACA,OAAA6S,CAAQxP,GACJ,OAAOA,EAAQoN,WAAa7V,KAAK6V,QACrC,CACA,OAAAsB,GACI,MAAO,gBAAgBnX,KAAK6V,UAChC,EAEJrY,EAAQsY,gBAAkBA,EAC1B,MAAMhC,UAAoBiD,EAAgBC,aACtC,WAAApX,CAAYgU,GAMR,GALA7T,QACAC,KAAK4T,KAAOA,EACZ5T,KAAK6O,KAAO,OAGR+E,EAAK+E,SAAS,KACd,MAAM,IAAIvT,MAAM,qDAEf,GAAIwO,EAAK+E,SAAS,KACnB,MAAM,IAAIvT,MAAM,2DAEf,IAAKwO,EAAKjB,MAAM,8CACjB,MAAM,IAAIvN,MAAM,sBAExB,CACA,OAAA6S,CAAQxP,GACJ,MAAMmQ,EAAY,IAAI5X,EAAI6X,IAAIpQ,EAAQzH,KACtC,OAAKhB,KAAK4T,KAAKkF,SAAS,QAA+B,SAArBrQ,EAAQoN,UACrC7V,KAAK4T,KAAKkF,SAAS,SAAgC,UAArBrQ,EAAQoN,SAIhC+C,EAAU5E,WAAahU,KAAK4T,KAAKmF,MAAM,KAAK,IAAyB,KAAnBH,EAAU3S,KAG5D2S,EAAUhF,OAAS5T,KAAK4T,IAEvC,CACA,OAAAuD,GACI,MAAO,YAAYnX,KAAK4T,MAC5B,EAEJpW,EAAQsW,YAAcA,EACtB,MAAMG,UAAwB8C,EAAgBC,aAC1C,WAAApX,CAAYoU,GAMR,GALAjU,QACAC,KAAKgU,SAAWA,EAChBhU,KAAK6O,KAAO,WAGRmF,EAAS2E,SAAS,KAClB,MAAM,IAAIvT,MAAM,qDAEf,GAAI4O,EAAS2E,SAAS,KACvB,MAAM,IAAIvT,MAAM,2DAEf,IAAK4O,EAASrB,MAAM,uCACrB,MAAM,IAAIvN,MAAM,sBAExB,CACA,OAAA6S,CAAQxP,GACJ,OAAO,IAAIzH,EAAI6X,IAAIpQ,EAAQzH,KAAKgT,WAAahU,KAAKgU,QACtD,CACA,OAAAmD,GACI,MAAO,gBAAgBnX,KAAKgU,UAChC,EAEJxW,EAAQyW,gBAAkBA,EAC1B,MAAME,UAAoB4C,EAAgBC,aACtC,WAAApX,CAAYqG,GACRlG,QACAC,KAAK6O,KAAO,OACZ7O,KAAKiG,KAAOA,EAAKQ,UACrB,CACA,OAAAwR,CAAQxP,GACJ,MAAMmQ,EAAY,IAAI5X,EAAI6X,IAAIpQ,EAAQzH,KACtC,MAAmB,OAAdhB,KAAKiG,MAAsC,SAArBwC,EAAQoN,UAChB,QAAd7V,KAAKiG,MAAuC,UAArBwC,EAAQoN,SAGN,KAAnB+C,EAAU3S,KAGV,IAAIjF,EAAI6X,IAAIpQ,EAAQzH,KAAKiF,OAASjG,KAAKiG,IAEtD,CACA,OAAAkR,GACI,MAAO,YAAYnX,KAAKiG,MAC5B,EAEJzI,EAAQ2W,YAAcA,EACtB,MAAMwD,UAA0BZ,EAAgBC,aAC5C,WAAApX,CAAYmB,GAIR,GAHAhB,QACAC,KAAKe,KAAOA,EACZf,KAAK6O,KAAO,eACP7O,KAAKe,KACN,MAAM,IAAIqE,MAAM,+CACpB,IAAI,OAAE4T,EAAM,MAAE3T,GAAUrE,EAAIO,MAAMvB,KAAKe,MAAM,GAC7C,GAAIiY,EACA,MAAM,IAAI5T,MAAUqL,EAAcwI,OAAS;gEACSD;4DACJ1X,KAAKiE,UAAUF;sCACrC2T;gBAG9B,EAAIT,EAAMW,cAAclZ,KAAKe,KACjC,CACA,OAAAkX,CAAQxP,GACJ,MAAM0Q,GAAc,EAAIZ,EAAMW,cAAclZ,KAAKe,MAC3CqY,GAAS,EAAIb,EAAMW,cAAczQ,EAAQzH,KAE/C,OAAI,EAAIuX,EAAMc,eAAeF,IAElB,EAAIZ,EAAMe,wBAAwBF,KAAYD,GAEhD,EAAIZ,EAAMgB,eAAeJ,GAEvBC,IAAWD,GAIX,EAAIZ,EAAMiB,uBAAuBJ,KAAYD,CAE5D,CACA,OAAAhC,GACI,MAAO,OAAOnX,KAAKe,MACvB,EAEJvD,EAAQma,kBAAoBA,EAC5B,MAAMD,UAAyBX,EAAgBC,aAC3C,WAAApX,CAAY6Z,GACR1Z,QACAC,KAAK6O,KAAO,aACZ7O,KAAK0Z,YAAcD,EAAME,OACzB3Z,KAAK4Z,WAAaH,EAAMI,KAC5B,CACA,OAAA5B,CAAQxP,GACJ,MAAMqR,GAAc,EAAIvB,EAAMW,cAAczQ,EAAQzH,KAC9C+Y,GAAU,EAAIxB,EAAMe,wBAAwBQ,GAE5CE,EAAa,IAAIC,OAAOja,KAAK0Z,YAAa1Z,KAAK4Z,YACrD,OAAOI,EAAWE,KAAKJ,IACnBE,EAAWE,KAAKH,EACxB,CACA,OAAA5C,GACI,MAAO,aAAasB,EAAezY,KAAK0Z,gBAAgB1Z,KAAK4Z,YAAc,IAC/E,EAEJpc,EAAQka,iBAAmBA,EAC3B,MAAMzB,UAAwBc,EAAgBC,aAC1C,WAAApX,CAAY6Z,GACR1Z,QACAC,KAAK6O,KAAO,YACZ7O,KAAK0Z,YAAcD,EAAME,OACzB3Z,KAAK4Z,WAAaH,EAAMI,KAC5B,CACA,OAAA5B,CAAQxP,GACJ,MAAMqR,GAAc,EAAIvB,EAAMW,cAAczQ,EAAQzH,KAGpD,OADmB,IAAIiZ,OAAOja,KAAK0Z,YAAa1Z,KAAK4Z,YACnCM,KAAKJ,EAC3B,CACA,OAAA3C,GACI,MAAO,iBAAiBsB,EAAezY,KAAK0Z,gBAAgB1Z,KAAK4Z,YAAc,IACnF,EAEJpc,EAAQyY,gBAAkBA,EAC1B,MAAM5B,UAAsB0C,EAAgBC,aACxC,WAAApX,CAAYua,GACRpa,QACAC,KAAK6O,KAAO,SACZ7O,KAAKS,QAAUjC,EAAE4b,QAAQD,GAAc,CAACE,EAAQ1Z,IAAQA,EAAI2Z,eAChE,CACA,OAAArC,CAAQxP,GACJ,OAAOjK,EAAE+b,QAAQ9R,EAAQhI,QAAST,KAAKS,QAC3C,CACA,OAAA0W,GACI,MAAO,0BAA0B7V,KAAKiE,UAAUvF,KAAKS,UACzD,EAEJjD,EAAQ6W,cAAgBA,EACxB,MAAMI,UAA0BsC,EAAgBC,aAC5C,WAAApX,CAAYyF,GAIR,GAHAtF,QACAC,KAAKqF,MAAQA,EACbrF,KAAK6O,KAAO,qBACE,KAAVxJ,GAA6B,MAAbA,EAAM,GACtB,MAAM,IAAID,MAAM,qDAExB,CACA,OAAA6S,CAAQxP,GACJ,MAAM,OAAEuQ,GAAWhY,EAAIO,MAAMkH,EAAQzH,KACrC,OAAOhB,KAAKqF,QAAU2T,IAAYA,IAAWhZ,KAAKqF,KACtD,CACA,OAAA8R,GACI,OAAOnX,KAAKqF,MACN,mCAAmCrF,KAAKqF,UACxC,sBACV,EAEJ7H,EAAQiX,kBAAoBA,EAC5B,MAAMF,UAAqBwC,EAAgBC,aACvC,WAAApX,CAAY4a,GACRza,QACAC,KAAK6O,KAAO,QACZ7O,KAAKya,YAAcjc,EAAEwO,UAAUwN,GAAmBvN,GAAMgC,MAAMC,QAAQjC,GAAKA,EAAE7M,KAAIsa,GAAMA,EAAGjU,aAAcwG,EAAExG,YAC9G,CACA,OAAAwR,CAAQxP,GACJ,IAAI,MAAEpD,GAAUrE,EAAIO,MAAMkH,EAAQzH,KAAK,GACvC,OAAOxC,EAAE+b,QAAQlV,EAAOrF,KAAKya,YACjC,CACA,OAAAtD,GACI,MAAO,0BAA0B7V,KAAKiE,UAAUvF,KAAKya,cACzD,EAEJjd,EAAQ+W,aAAeA,EACvB,MAAMK,UAAwBmC,EAAgBC,aAC1C,WAAApX,CAAY+U,GACR5U,QACAC,KAAK2U,SAAWA,EAChB3U,KAAK6O,KAAO,WAChB,CACA,aAAMoJ,CAAQxP,GACV,MAAMkS,EAAclS,EAAQhI,QAAQ,gBACpC,QAASka,IACyD,IAA9DA,EAAYC,QAAQ,sCACpBpc,EAAE+b,cAAc9R,EAAQtH,KAAK0Z,aAAc7a,KAAK2U,SACxD,CACA,OAAAwC,GACI,MAAO,4BAA4B7V,KAAKiE,UAAUvF,KAAK2U,WAC3D,EAEJnX,EAAQoX,gBAAkBA,EAC1B,MAAMG,UAAiCgC,EAAgBC,aACnD,WAAApX,CAAYkV,GACR/U,QACAC,KAAK8U,gBAAkBA,EACvB9U,KAAK6O,KAAO,qBAChB,CACA,aAAMoJ,CAAQxP,GACV,MAAMkS,EAAclS,EAAQhI,QAAQ,gBACpC,IAAKka,EACD,OAAO,EACX,IAAKA,EAAYhC,SAAS,uBACtB,OAAO,EACX,MAAMmC,EAAWH,EAAYhI,MAAM,sBACnC,IAAKmI,EACD,OAAO,EACX,MAAMC,EAAazC,EAAU/W,YAAYkH,EAAQtH,KAAK6Z,kBAAmBF,EAAS,IAClF,OAAO9a,KAAK8U,gBAAgBqD,OAAO8C,IAC/B,MAAMC,EAAkBD,EAAU/N,QAC5B/B,EAAOC,KAAK6P,EAAU/N,cACtBhH,EACN,OAAO6U,EAAWpM,MAAMwM,IAAUD,GAAiBE,OAAOD,EAAK3V,YAA6BU,IAApBgV,KACnED,EAAUI,WAAaF,EAAKE,eAAmCnV,IAAvB+U,EAAUI,YAClDJ,EAAUvR,OAASyR,EAAKzR,WAA2BxD,IAAnB+U,EAAUvR,OAAoB,GAE3E,CACA,OAAAyN,GACI,MAAO,qCAAqC7V,KAAKiE,UAAUvF,KAAK8U,kBACpE,EAEJtX,EAAQuX,yBAA2BA,EACnC,MAAMG,UAAuB6B,EAAgBC,aACzC,WAAApX,CAAYsN,GACRnN,QACAC,KAAKkN,QAAUA,EACflN,KAAK6O,KAAO,UAChB,CACA,aAAMoJ,CAAQxP,GACV,aAAcA,EAAQtH,KAAKma,WAActb,KAAKkN,OAClD,CACA,OAAAiK,GACI,MAAO,cAAcnX,KAAKkN,UAC9B,EAEJ1P,EAAQ0X,eAAiBA,EACzB,MAAMG,UAA+B0B,EAAgBC,aACjD,WAAApX,CAAYsN,GACRnN,QACAC,KAAKkN,QAAUA,EACflN,KAAK6O,KAAO,mBAChB,CACA,aAAMoJ,CAAQxP,GACV,aAAcA,EAAQtH,KAAKma,UAAU3C,SAAS3Y,KAAKkN,QACvD,CACA,OAAAiK,GACI,MAAO,0BAA0BnX,KAAKkN,UAC1C,EAEJ1P,EAAQ6X,uBAAyBA,EACjC,MAAMF,UAAyB4B,EAAgBC,aAC3C,WAAApX,CAAY6Z,GACR1Z,QACAC,KAAK6O,KAAO,kBACZ7O,KAAKub,YAAc9B,EAAME,MAC7B,CACA,aAAM1B,CAAQxP,GAEV,OADkB,IAAIwR,OAAOja,KAAKub,aACfrB,WAAWzR,EAAQtH,KAAKma,SAC/C,CACA,OAAAnE,GACI,MAAO,yBAAyBsB,EAAezY,KAAKub,eACxD,EAEJ/d,EAAQ2X,iBAAmBA,EAC3B,MAAMI,UAAwBwB,EAAgBC,aAC1C,WAAApX,CAAYuB,GACRpB,QACAC,KAAKmB,KAAOA,EACZnB,KAAK6O,KAAO,WAChB,CACA,aAAMoJ,CAAQxP,GACV,MAAM+S,QAAsB/S,EAAQtH,KAAKsa,SAAS5X,OAAM,KAAe,IACvE,YAAqBqC,IAAjBsV,GAGOhd,EAAEkd,QAAQF,EAAcxb,KAAKmB,KAC5C,CACA,OAAAgW,GACI,MAAO,kCAAkC7V,KAAKiE,UAAUvF,KAAKmB,OACjE,EAEJ3D,EAAQ+X,gBAAkBA,EAC1B,MAAMC,UAAgCuB,EAAgBC,aAClD,WAAApX,CAAYuB,GACRpB,QACAC,KAAKmB,KAAOA,EACZnB,KAAK6O,KAAO,oBAChB,CACA,aAAMoJ,CAAQxP,GACV,MAAM+S,QAAsB/S,EAAQtH,KAAKsa,SAAS5X,OAAM,KAAe,IACvE,YAAqBqC,IAAjBsV,GAGOhd,EAAE+b,QAAQiB,EAAcxb,KAAKmB,KAC5C,CACA,OAAAgW,GACI,MAAO,8BAA8B7V,KAAKiE,UAAUvF,KAAKmB,OAC7D,EAEJ3D,EAAQgY,wBAA0BA,EAClC,MAAMG,UAAsBoB,EAAgBC,aACxC,WAAApX,CAAY8V,GACR3V,QACAC,KAAK0V,OAASA,EACd1V,KAAK6O,KAAO,QAChB,CACA,aAAMoJ,CAAQxP,GACV,SAAKA,EAAQhI,UAAYgI,EAAQhI,QAAQiV,SAGzBjN,EAAQhI,QAAQiV,OAAOqD,MAAM,KAAK3Y,KAAIsV,IAClD,MAAO/U,EAAKlD,GAASiY,EAAOqD,MAAM,KAClC,MAAO,CAAE,CAACpY,EAAIgb,SAAUle,GAAS,IAAIke,OAAQ,IAElChN,MAAKiN,GAAWpd,EAAEkd,QAAQE,EAAS5b,KAAK0V,SAC3D,CACA,OAAAyB,GACI,MAAO,0BAA0B7V,KAAKiE,UAAUvF,KAAK0V,SACzD,EAEJlY,EAAQmY,cAAgBA,EACxB,MAAMQ,UAAwBY,EAAgBC,aAC1C,WAAApX,CAAYuI,GACRpI,QACAC,KAAKmI,SAAWA,EAChBnI,KAAK6O,KAAO,UAChB,CACA,aAAMoJ,CAAQxP,GACV,MAAMoT,QAAyB,EAAIvR,EAAgBwR,yBAAyBrT,GAC5E,OAAOzI,KAAKmI,SAAS0T,EACzB,CACA,OAAA1E,GACI,MAAO,mCAAkCnX,KAAKmI,SAASuB,KAAO,KAAK1J,KAAKmI,SAASuB,QAAU,GAC/F,CAIA,SAAAqS,CAAUC,GAMN,OALAA,EAAQC,WAAUle,MAAOme,IACrB,MAAMzT,GAAU,EAAI+P,EAAqB2D,4BAA4BD,GAErE,aAD6Blc,KAAKmI,SAASgC,KAAK,KAAM1B,EACjC,IAElB,CAAEoG,KAAM7O,KAAK6O,KAAMnF,KAAM1J,KAAKmI,SAASuB,KAAM0S,QAAS,EACjE,CAIA,kBAAOC,EAAY,KAAE3S,GAAQsS,GACzB,MAAMM,EAAcve,MAAO0K,GACAuT,EAAQvT,SAAQ,EAAI+P,EAAqB+D,0BAA0B9T,IAO9F,OAHAnL,OAAOC,eAAe+e,EAAa,OAAQ,CAAE7e,MAAOiM,IAG7C,IAAIyM,EAAgBmG,EAC/B,EAEJ9e,EAAQ2Y,gBAAkBA,EAC1B3Y,EAAQia,cAAgB,CACpB,SAAYI,EACZ,OAAUD,EACV,SAAY9B,EACZ,KAAQhC,EACR,SAAYG,EACZ,KAAQE,EACR,cAAewD,EACf,aAAcD,EACd,YAAazB,EACb,OAAU5B,EACV,MAASE,EACT,qBAAsBE,EACtB,YAAaG,EACb,sBAAuBG,EACvB,WAAYG,EACZ,kBAAmBC,EACnB,oBAAqBE,EACrB,YAAaE,EACb,qBAAsBC,EACtB,OAAUG,EACV,SAAYQ,E,+BChehB7Y,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IACtDD,EAAQ4S,wBAA0B5S,EAAQgf,iCAAmChf,EAAQ2S,yBAA2B3S,EAAQif,iCAAmCjf,EAAQ0S,iCAAmC1S,EAAQyS,6BAA+BzS,EAAQkf,gBAAkBlf,EAAQwS,sBAAwBxS,EAAQuS,wBAA0BvS,EAAQsS,0BAA4BtS,EAAQqS,6BAA0B,EAC/Y,MAAMrR,EAAI,EAAQ,MACZwC,EAAM,EAAQ,OACd2b,EAAuB,EAAQ,OAC/BC,EAAW,EAAQ,OACnBnM,EAAgB,EAAQ,OACxBoM,EAAoB,EAAQ,OAC5BvS,EAAkB,EAAQ,OAC1BwS,EAAiB,EAAQ,OACzB/F,EAAkB,EAAQ,OAC1ByB,EAAuB,EAAQ,OACrC,SAASuE,EAAsBC,EAAiBC,EAAiBC,EAAkB,IAC/E,IAAKD,EACD,OAEJ,MAAME,EAAiB3e,EAAEye,GACpBG,QAAO,CAAC3f,EAAOiM,IAASA,EAAKjD,WAAW6E,WAAW,MAGpD7N,IAAUuf,EAAgBtT,KAGzBwT,EAAgBvE,SAASjP,KACzB2T,OACL,GAAIF,EAAeG,OAAS,EACxB,MAAM,IAAIlY,MAAM,qBAAqB+X,EAAe7c,KAAK,4BAEjE,CACA,MAAMuP,UAAgCkH,EAAgBC,aAClD,WAAApX,CAAYO,EAAQod,EAAe/X,EAAM/E,EAASwK,GAU9C,GATAlL,QACAC,KAAKG,OAASA,EACdH,KAAKud,cAAgBA,EACrBvd,KAAKwF,KAAOA,EACZxF,KAAKS,QAAUA,EACfT,KAAKiL,SAAWA,EAChBjL,KAAK6O,KAAO,SACZkO,EAAsB,CAAC,EAAGtc,GAC1Bsc,EAAsB,CAAC,EAAG9R,IACrBzM,EAAEgf,QAAQvS,IAAaxK,IACnBnD,OAAOmgB,QAAQhd,GAASkO,MAAK,EAAEhO,EAAKlD,KAAiC,sBAAtBkD,EAAI2Z,eAAmD,YAAV7c,IAC7F,MAAM,IAAI2H,MAAM,gEAG5B,CACA,OAAA+R,GACI,MAAO,uBAAuBnX,KAAKG,UAC9BH,KAAKud,cAAgB,KAAKvd,KAAKud,iBAAmB,KAClDvd,KAAKS,QAAU,aAAaa,KAAKiE,UAAUvF,KAAKS,WAAa,KAC7DT,KAAKwF,KAAO,cAAcxF,KAAKwF,QAAU,KACzCxF,KAAKiL,SAAW,iBAAiB3J,KAAKiE,UAAUvF,KAAKiL,YAAc,GAC5E,EAEJzN,EAAQqS,wBAA0BA,EAClC,MAAMC,UAAkCiH,EAAgBC,aACpD,WAAApX,CAAYuI,GACRpI,QACAC,KAAKmI,SAAWA,EAChBnI,KAAK6O,KAAO,UAChB,CACA,OAAAsI,GACI,MAAO,mCAAqCnX,KAAKmI,SAASuB,KAAO,KAAK1J,KAAKmI,SAASuB,QAAU,GAClG,CAIA,SAAAqS,CAAUC,GAiBN,OAhBAA,EAAQC,WAAUle,MAAOme,IACrB,MAAMzT,EAAUjK,EAAEyW,SAASiH,EAAUwB,KAAK,GAAGvc,OACvC,EAAIqX,EAAqB2D,4BAC3BD,EAAUwB,KAAK,IACb,IACKxB,EAAUwB,KAAK,GAClBvc,MAAM,EAAImJ,EAAgBY,iBAAiBgR,EAAUwB,KAAK,GAAGvc,KAAKwc,OAAQzB,EAAUwB,KAAK,GAAGjd,UAE9Fmd,QAAuB5d,KAAKmI,SAASgC,KAAK,KAAM1B,GACtD,MAA8B,iBAAnBmV,EACAA,GAGA,EAAIpF,EAAqBqF,+BAA+BD,EACnE,IAEG,CAAE/O,KAAM7O,KAAK6O,KAAMnF,KAAM1J,KAAKmI,SAASuB,KAAM0S,QAAS,EACjE,EAEJ5e,EAAQsS,0BAA4BA,EAEpC,MAAMC,UAAgCgH,EAAgBC,aAClD,WAAApX,CAAYO,EAAQ2d,EAAQrd,GACxBV,QACAC,KAAKG,OAASA,EACdH,KAAK8d,OAASA,EACd9d,KAAKS,QAAUA,EACfT,KAAK6O,KAAO,SACZkO,EAAsB,CAAC,EAAGtc,EAC9B,CACA,OAAA0W,GACI,MAAO,uBAAuBnX,KAAKG,UAC9BH,KAAKS,QAAU,aAAaa,KAAKiE,UAAUvF,KAAKS,YAAc,IAC/D,gCACR,CAIA,SAAAsb,CAAUC,GACN,MAAM+B,EAAsB,IAAInB,EAASoB,UAAU,CAC/CC,YAAY,EACZC,UAAW,SAAUC,EAAOC,EAAWjW,GACnC,IAAIkW,EAAsB7f,EAAEyW,SAASkJ,GAAS,CAAEtP,KAAM,SAAUpR,MAAO0gB,GACnE3f,EAAE8f,SAASH,GAAS,CAAEtP,KAAM,SAAUpR,MAAO0gB,EAAM1X,SAAS,WACvDjI,EAAE+f,cAAcJ,IAAU3f,EAAEggB,aAAaL,GAAU,CAAEtP,KAAM,cAAepR,OAAO,EAAIkf,EAAqB8B,QAAQN,IAC/G3f,EAAEkgB,MAAMP,IAAU,CAAEtP,KAAM,OACjCwP,GACDlW,EAAS,IAAI/C,MAAM,mCAAmC+Y,EAAM1X,wEAEhE0B,OAASjC,EAAW,CAChByE,MAAO,OACPuC,QAASmR,GAEjB,EACAM,MAAO,SAAUxW,GACbnI,KAAK6T,KAAK,CACNlJ,MAAO,QAEXxC,GACJ,IAMJ,OAHA6T,EAAQrY,KAAK,QAAQ,KACjB3D,KAAK8d,OAAOnb,KAAKob,GAAqBpb,KAAKqZ,EAAS,CAAEpZ,KAAK,GAAQ,IAEhE,CAAEiM,KAAM7O,KAAK6O,KAAM1O,OAAQH,KAAKG,OAAQM,QAAST,KAAKS,QACjE,EAEJjD,EAAQuS,wBAA0BA,EAClC,MAAMC,UAA8B+G,EAAgBC,aAChD,WAAApX,CAAYO,EAAQod,EAAeqB,EAAUne,GACzCV,QACAC,KAAKG,OAASA,EACdH,KAAKud,cAAgBA,EACrBvd,KAAK4e,SAAWA,EAChB5e,KAAKS,QAAUA,EACfT,KAAK6O,KAAO,OACZkO,EAAsB,CAAC,EAAGtc,EAC9B,CACA,OAAA0W,GACI,MAAO,uBAAuBnX,KAAKG,UAC9BH,KAAKud,cAAgB,KAAKvd,KAAKud,iBAAmB,KAClDvd,KAAKS,QAAU,aAAaa,KAAKiE,UAAUvF,KAAKS,WAAa,KAC7DT,KAAK4e,SAAW,uBAAuB5e,KAAK4e,WAAa,GAClE,EAEJphB,EAAQwS,sBAAwBA,EAKhCxS,EAAQkf,gBAAkB,+BAC1B,MAAMzM,UAAqC8G,EAAgBC,aACvD,WAAApX,CAAY5B,EAAU,CAAC,GACnB+B,QACAC,KAAK6O,KAAO,cACZ7O,KAAK6e,sBAAwB,GAC7B7e,KAAK8e,oBAAsB,GAI3B9e,KAAK+e,gBAAkB,IAAIC,IAE3B,MAAM,WAAEC,GAAejhB,EACvB,GAAIihB,GAAcA,EAAWC,WAAWvG,SAAS,KAAM,CACnD,MAAM,SAAE9C,EAAQ,SAAE7B,EAAQ,KAAE/N,EAAI,KAAElF,GAASC,EAAIO,MAAM0d,EAAWC,YAChE,GAAIne,GAAwB,MAAhBA,EAAK4a,OAAgB,CAC7B,MAAMwD,EAAane,EAAIoe,OAAO,CAAEvJ,WAAU7B,WAAU/N,UAChDgZ,EAAWC,WAAW5Q,MAAM,EAAG2Q,EAAWC,WAAWtE,QAAQ,MACjE,MAAM,IAAIxV,MAAUqL,EAAc+B,WAAa;sEACOyM,EAAWC,qBAAqB,kBAAkBC;kBAE5G,CACJ,CAGA,GAFAnf,KAAKif,WAAaA,EAClBjf,KAAK6e,sBAAwB7gB,EAAQ6gB,uBAAyB,IACzD5P,MAAMC,QAAQlP,KAAK6e,wBAAgE,kBAA/B7e,KAAK6e,sBAC1D,MAAM,IAAIzZ,MAAM,uDAUpB,GARApF,KAAKqf,cAAgBrhB,EAAQqhB,cAC7Brf,KAAKsf,YAActhB,EAAQshB,YAC3Btf,KAAKuf,2BAA6BvhB,EAAQuhB,yBAC1Cvf,KAAK8e,oBACD9gB,EAAQwhB,sBACJxhB,EAAQyhB,oBACR,GACRzf,KAAK0f,yBAA2B1hB,EAAQ0hB,0BAA4B,CAAC,EACjE1hB,EAAQ2hB,eAAiB3hB,EAAQ4hB,mBAAqBphB,EAAEgf,QAAQxf,EAAQ4hB,kBACxE,MAAM,IAAIxa,MAAM,qEAEf,GAAIpH,EAAQ2hB,cACb3f,KAAK2f,cAAgB3hB,EAAQ2hB,mBAE5B,GAAI3hB,EAAQ4hB,iBAAkB,CAC/B,GAAI,CACA5hB,EAAQ4hB,iBAAiBC,cACzB7hB,EAAQ4hB,iBAAiBE,gBAC3BrW,QAAOsW,KAAOA,IAAG7f,OAAS,EACxB,MAAM,IAAIkF,MAAM,gEAEpB,GAAI,CACApH,EAAQ4hB,iBAAiBI,YACzBhiB,EAAQ4hB,iBAAiBK,oBACzBjiB,EAAQ4hB,iBAAiBM,eACzBliB,EAAQ4hB,iBAAiBO,cACzBniB,EAAQ4hB,iBAAiBQ,kBAC3B3W,QAAOsW,KAAOA,IAAG7f,OAAS,EACxB,MAAM,IAAIkF,MAAM,8DAEpB,GAAIpH,EAAQ4hB,iBAAiBO,cAAe,CACxC,MAAME,GAAkB,EAAIxD,EAAkByD,UAAUtiB,EAAQ4hB,iBAAiBO,eACjF,GAAIE,EACA,MAAMA,CACd,CACArgB,KAAK4f,iBAAmB5hB,EAAQ4hB,gBACpC,CACA,GAAI5hB,EAAQuiB,gBAAkBviB,EAAQ8J,oBAAsBtJ,EAAEgf,QAAQxf,EAAQ8J,mBAC1E,MAAM,IAAI1C,MAAM,uEAEf,GAAIpH,EAAQuiB,eACbvgB,KAAKugB,eAAiBviB,EAAQuiB,oBAE7B,GAAIviB,EAAQ8J,kBAAmB,CAChC,GAAI,CACA9J,EAAQ8J,kBAAkB+X,cAC1B7hB,EAAQ8J,kBAAkBgY,gBAC5BrW,QAAOsW,KAAOA,IAAG7f,OAAS,EACxB,MAAM,IAAIkF,MAAM,iEAEpB,GAAI,CACApH,EAAQ8J,kBAAkBkY,YAC1BhiB,EAAQ8J,kBAAkBmY,oBAC1BjiB,EAAQ8J,kBAAkBoY,eAC1BliB,EAAQ8J,kBAAkBqY,cAC1BniB,EAAQ8J,kBAAkBsY,kBAC5B3W,QAAOsW,KAAOA,IAAG7f,OAAS,EACxB,MAAM,IAAIkF,MAAM,+DAEpB,GAAIpH,EAAQ8J,kBAAkBqY,cAAe,CACzC,MAAME,GAAkB,EAAIxD,EAAkByD,UAAUtiB,EAAQ8J,kBAAkBqY,eAClF,GAAIE,EACA,MAAMA,CACd,CACArgB,KAAK8H,kBAAoB9J,EAAQ8J,iBACrC,CACJ,CACA,OAAAqP,GACI,OAAOnX,KAAKif,WACN,0BAA0Bjf,KAAKif,WAAWC,aAC1C,6CACV,CAIA,SAAAnD,CAAUC,GA2BN,OA1BIhc,KAAK2f,eACL3D,EAAQC,UAAU,iBAAiBle,MAAO8N,IACtC,MAAM+R,QAAuB5d,KAAK2f,eAAc,EAAInH,EAAqB2D,4BAA4BtQ,EAAI6R,KAAK,KACxG8C,EAAmB5C,GACnB,EAAIpF,EAAqBqF,+BAA+BD,QACxD1X,EAIN,OAHIsa,GAAkB1gB,UAAkD,iBAA/B0gB,GAAkB1gB,WACvD0gB,EAAiB1gB,UAAW,EAAI0Y,EAAqBqF,+BAA+B2C,EAAiB1gB,WAElG0gB,CAAgB,IAG3BxgB,KAAKugB,gBACLvE,EAAQC,UAAU,kBAAkBle,MAAO8N,IACvC,MAAM+R,QAAuB5d,KAAKugB,gBAAe,EAAI/H,EAAqB2D,4BAA4BtQ,EAAI6R,KAAK,KAC/G,MAA8B,iBAAnBE,EACAA,EAEFA,GACE,EAAIpF,EAAqBqF,+BAA+BD,QAG/D,CACJ,IAGD,CACH/O,KAAM7O,KAAK6O,QACR7O,KAAKif,WAAa,CACjBA,WAAYjf,KAAKif,WAEjBwB,kBAAmBzgB,KAAKif,WAAWC,YACnC,CAAC,EACLI,aAAa,EAAIvI,EAAgB2J,sBAAsB1gB,KAAKsf,YAAatD,GACzEqD,cAAerf,KAAKqf,cACpBE,yBAA0Bvf,KAAKuf,yBAC/BoB,4BAA6B3gB,KAAK6e,sBAClCC,oBAAqB9e,KAAK8e,oBAAoB1e,KAAKwgB,GAK3C,SAAUA,EACH,CAAEC,KAAMD,EAAWC,KAAKpa,SAAS,SAGjCma,IAGflB,yBAA0BlhB,EAAEwO,UAAUhN,KAAK0f,0BAA0B,EAAGoB,MAAKC,iBAAiB,CAAGD,KAAK,EAAI/J,EAAgBiK,iBAAiBF,GAAMC,iBACjJnB,iBAAkB5f,KAAK4f,iBAAmB,IACnC5f,KAAK4f,iBAERI,YAAehgB,KAAK4f,kBAAkBI,aAChC,EAAIjJ,EAAgBiK,kBAAiB,EAAIlE,EAAemE,UAAUjhB,KAAK4f,iBAAiBI,mBACxF9Z,EAEN2Z,cAAiB7f,KAAK4f,kBAAkBC,cAClCve,KAAKiE,UAAUvF,KAAK4f,iBAAiBC,eAAe,CAACqB,EAAGjU,SAAY/G,IAAN+G,EAAkBzP,EAAQkf,gBAAkBzP,SAC1G/G,EACNga,eAAkBlgB,KAAK4f,kBAAkBM,eACnC5e,KAAKiE,UAAUvF,KAAK4f,iBAAiBM,gBAAgB,CAACgB,EAAGjU,SAAY/G,IAAN+G,EAAkBzP,EAAQkf,gBAAkBzP,SAC3G/G,EACNka,iBAAoBpgB,KAAK4f,kBAAkBQ,iBACrCpgB,KAAK4f,iBAAiBQ,iBAAiBhgB,KAAI,EAAEuS,EAAO5M,KAAY,CAC9DvH,EAAE2iB,SAASxO,GACL,CAAE+G,YAAa/G,EAAMgH,OAAQE,MAAOlH,EAAMkH,OAC1ClH,EACN5M,UAEFG,QACNA,EACJ4B,kBAAmB9H,KAAK8H,kBAAoB,IACrC9H,KAAK8H,kBAERkY,YAAehgB,KAAK8H,mBAAmBkY,aACjC,EAAIjJ,EAAgBiK,kBAAiB,EAAIlE,EAAemE,UAAUjhB,KAAK8H,kBAAkBkY,mBACzF9Z,EAEN2Z,cAAiB7f,KAAK8H,mBAAmB+X,cACnCve,KAAKiE,UAAUvF,KAAK8H,kBAAkB+X,eAAe,CAACqB,EAAGjU,SAAY/G,IAAN+G,EAAkBzP,EAAQkf,gBAAkBzP,SAC3G/G,EACNga,eAAkBlgB,KAAK8H,mBAAmBoY,eACpC5e,KAAKiE,UAAUvF,KAAK8H,kBAAkBoY,gBAAgB,CAACgB,EAAGjU,SAAY/G,IAAN+G,EAAkBzP,EAAQkf,gBAAkBzP,SAC5G/G,EACNka,iBAAoBpgB,KAAK8H,mBAAmBsY,iBACtCpgB,KAAK8H,kBAAkBsY,iBAAiBhgB,KAAI,EAAEuS,EAAO5M,KAAY,CAC/DvH,EAAE2iB,SAASxO,GACL,CAAE+G,YAAa/G,EAAMgH,OAAQE,MAAOlH,EAAMkH,OAC1ClH,EACN5M,UAEFG,QACNA,EACJkb,2BAA4BphB,KAAK2f,cACjC0B,4BAA6BrhB,KAAKugB,eAE1C,EAEJ/iB,EAAQyS,6BAA+BA,EACvC,MAAMC,UAAyC6G,EAAgBC,aAC3D,WAAApX,GACIG,SAASkX,WACTjX,KAAK6O,KAAO,kBAChB,CACA,OAAAsI,GACI,MAAO,sBACX,EAEJ3Z,EAAQ0S,iCAAmCA,EAC3C,MAAMuM,UAAyC1F,EAAgBC,aAC3D,WAAApX,GACIG,SAASkX,WACTjX,KAAK6O,KAAO,kBAChB,CACA,OAAAsI,GACI,MAAO,sBACX,EAEJ3Z,EAAQif,iCAAmCA,EAC3C,MAAMtM,UAAiC4G,EAAgBC,aACnD,WAAApX,GACIG,SAASkX,WACTjX,KAAK6O,KAAO,SAChB,CACA,OAAAsI,GACI,MAAO,0BACX,EAEJ3Z,EAAQ2S,yBAA2BA,EACnC,MAAMqM,UAAyCzF,EAAgBC,aAC3D,WAAApX,CAAYmG,GAIR,GAHAhG,QACAC,KAAK+F,OAASA,EACd/F,KAAK6O,KAAO,sBACN,WAAY9I,MAAa,UAAWA,GACtC,MAAM,IAAIX,MAAM,wDAExB,CACA,OAAA+R,GACI,MAAMmK,EAAa,WAAYthB,KAAK+F,OAC9B,SACA,QACN,MAAO,yBAAyBub,QAAiBhgB,KAAKiE,UAAUvF,KAAK+F,OAAOub,KAChF,EAEJ9jB,EAAQgf,iCAAmCA,EAC3Chf,EAAQ4S,wBAA0B,CAC9B,OAAUP,EACV,SAAYC,EACZ,OAAUC,EACV,KAAQC,EACR,YAAeC,EACf,mBAAoBC,EACpB,mBAAoBuM,EACpB,QAAWtM,EACX,oBAAqBqM,E,+BCnazBlf,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IACtDD,EAAQ8T,wBAAqB,EAC7B,MAAM8B,EAAW,EAAQ,MACnBmO,EAAgC,EAAQ,OACxCtiB,EAAS,EAAQ,OACjBuiB,EAAsB,EAAQ,OAC9BlO,EAAa,EAAQ,OAmB3B,MAAMhC,UAA2BkQ,EAAoBrO,gBACjD,WAAAvT,CAAY6hB,EAAiB1gB,EAAM2gB,GAC/B3hB,QAEA,MAAMxB,EAASkjB,aAA2BE,cAAWzb,EAAYub,OAClDvb,IAAX3H,QAAiC2H,IAATnF,EACxBf,KAAKyP,SAASoE,KAAK,IAAIP,EAAWuE,uBAGnB3R,IAAX3H,GACAyB,KAAKyP,SAASoE,KAAK,IAAIP,EAAWsE,cAAcrZ,IAEhDwC,aAAgBkZ,OAChBja,KAAKyP,SAASoE,KAAK,IAAIP,EAAWoE,iBAAiB3W,IAE9B,iBAATA,GACZf,KAAKyP,SAASoE,KAAK,IAAIP,EAAWqE,kBAAkB5W,KAKxDf,KAAK0hB,QADLD,aAA2BE,SACZF,EAGAC,CAEvB,CACA,SAAAE,CAAUzhB,EAAQ0hB,EAAeC,EAAeC,EAAmB9W,GAC/D,IAAIzF,EACA+X,EACA9c,GACA,EAAI2S,EAASkL,UAAUwD,KAAkB,EAAI1O,EAAS6B,UAAU6M,IAChEtc,EAAOsc,EACPvE,EAAgBsE,EAChBphB,EAAUshB,IAGVvc,EAAOqc,EACPphB,EAAUqhB,EACV7W,EAAW8W,GAEf,MAAM5V,EAAO,IACNnM,KAAKyT,oBACRuO,QAAS,IAAIT,EAA8B1R,wBAAwB1P,EAAQod,EAAe/X,EAAM/E,EAASwK,IAE7G,OAAOjL,KAAK0hB,QAAQvV,EACxB,CAkBA,QAAA8V,CAAS9hB,EAAQqF,EAAM/E,EAAU,CAAC,GAC9B,MAAMyhB,EAAW5gB,KAAKiE,UAAUC,GAChC/E,GAAU,EAAI2S,EAAS+O,OAAO,CAC1B,eAAgB,mBAChB,kBAAkB,EAAIljB,EAAOmjB,YAAYF,GAAUzb,WACnD,WAAc,cAGfhG,GACH,MAAM0L,EAAO,IACNnM,KAAKyT,oBACRuO,QAAS,IAAIT,EAA8B1R,wBAAwB1P,OAAQ+F,EAAWgc,EAAUzhB,IAEpG,OAAOT,KAAK0hB,QAAQvV,EACxB,CAwBA,YAAAkW,CAAala,GACT,MAAMgE,EAAO,IACNnM,KAAKyT,oBACRuO,QAAS,IAAIT,EAA8BzR,0BAA0B3H,IAEzE,OAAOnI,KAAK0hB,QAAQvV,EACxB,CAqBA,UAAAmW,CAAWniB,EAAQ2d,EAAQrd,GACvB,MAAM0L,EAAO,IACNnM,KAAKyT,oBACRuO,QAAS,IAAIT,EAA8BxR,wBAAwB5P,EAAQ2d,EAAQrd,IAEvF,OAAOT,KAAK0hB,QAAQvV,EACxB,CACA,YAAAoW,CAAapiB,EAAQqiB,EAAeC,EAAehiB,GAC/C,IAAIM,EACAwc,GACA,EAAInK,EAAS6B,UAAUwN,IACvB1hB,EAAO0hB,EACPlF,EAAgBiF,IAGhBzhB,EAAOyhB,EACP/hB,EAAUgiB,GAEd,MAAMtW,EAAO,IACNnM,KAAKyT,oBACRuO,QAAS,IAAIT,EAA8BvR,sBAAsB7P,EAAQod,EAAexc,EAAMN,IAElG,OAAOT,KAAK0hB,QAAQvV,EACxB,CAoBA,eAAAuW,CAAgB1kB,GACZ,MAAMmO,EAAO,IACNnM,KAAKyT,oBACRuO,QAAS,IAAIT,EAA8BtR,6BAA6BjS,IAE5E,OAAOgC,KAAK0hB,QAAQvV,EACxB,CAyBA,mBAAMwW,CAAclC,EAAmBziB,EAAU,CAAC,GAC9C,MAAMmO,EAAO,IACNnM,KAAKyT,oBACRuO,QAAS,IAAIT,EAA8BtR,6BAA6B,IACjEjS,EACHihB,WAAY,IACLjhB,EAAQihB,WACXC,WAAYuB,MAIxB,OAAOzgB,KAAK0hB,QAAQvV,EACxB,CAeA,mBAAAyW,GACI,MAAMzW,EAAO,IACNnM,KAAKyT,oBACRuO,QAAS,IAAIT,EAA8BrR,kCAE/C,OAAOlQ,KAAK0hB,QAAQvV,EACxB,CAmBA,mBAAA0W,GACI,MAAM1W,EAAO,IACNnM,KAAKyT,oBACRuO,QAAS,IAAIT,EAA8B9E,kCAE/C,OAAOzc,KAAK0hB,QAAQvV,EACxB,CAeA,WAAA2W,GACI,MAAM3W,EAAO,IACNnM,KAAKyT,oBACRuO,QAAS,IAAIT,EAA8BpR,0BAE/C,OAAOnQ,KAAK0hB,QAAQvV,EACxB,CAQA,qBAAA4W,CAAsBhd,GAClB,MAAMoG,EAAO,IACNnM,KAAKyT,oBACRuO,QAAS,IAAIT,EAA8B/E,iCAAiC,CAAEzW,YAElF,OAAO/F,KAAK0hB,QAAQvV,EACxB,CAQA,oBAAA6W,CAAqBxhB,GACjB,MAAM2K,EAAO,IACNnM,KAAKyT,oBACRuO,QAAS,IAAIT,EAA8B/E,iCAAiC,CAAEhb,WAElF,OAAOxB,KAAK0hB,QAAQvV,EACxB,EAEJ3O,EAAQ8T,mBAAqBA,C,6BC3U7B,SAAS2R,EAAiBvK,GACtB,OAAOA,KAAWA,EAAMlb,EAAQgT,kBACpC,CARAlT,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IACtDD,EAAQgT,uBAAoB,EAC5BhT,EAAQylB,iBAAmBA,EAC3BzlB,EAAQ0lB,iBAOR,SAA0BC,EAAUrQ,GAChC,MAAMsQ,EAAWD,EAAS3lB,EAAQgT,mBAClC,GAAI4S,KAAYtQ,EACZ,OAAOA,EAAOsQ,GAGd,MAAM,IAAIhe,MAAM,kDAAkDge,KAE1E,EAdA5lB,EAAQ6lB,wBAgBR,SAAiCC,GAC7B,GAAIL,EAAiBK,GAAgB,CACjC,MAAMF,EAAWE,EAAc9lB,EAAQgT,mBACvC,MAAM,IAAIpL,MAAM,sDAAsDge,IAC1E,CAEI,OAAOE,CAEf,EAvBA9lB,EAAQgT,kBAAoB+S,OAAO,oB,+BCLnCjmB,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IACtDD,EAAQgmB,qBAAuBA,EAC/BhmB,EAAQ6O,kBAUR,SAA2B7G,EAAMsY,GAE7B,OADA0F,EAAqBhe,GACd,CACHgB,GAAIhB,EAAKgB,GACT+M,SAAU/N,EAAK+N,SACf9D,SAAUjK,EAAKiK,SAASrP,KAAIiY,IAAK,EAAItB,EAAgBgF,WAAW1D,EAAGyF,KACnEkE,SAAS,EAAIjL,EAAgBgF,WAAWvW,EAAKwc,QAASlE,GACtDpK,kBAAmBlO,EAAKkO,oBAAqB,EAAIqD,EAAgBgF,WAAWvW,EAAKkO,kBAAmBoK,GAE5G,EAlBA,MAAM/G,EAAkB,EAAQ,OAChC,SAASyM,EAAqBhe,GAC1B,IAAKA,EAAKiK,UAAqC,IAAzBjK,EAAKiK,SAASvP,OAChC,MAAM,IAAIkF,MAAM,qDAEpB,IAAKI,EAAKwc,QACN,MAAM,IAAI5c,MAAM,uCAExB,C,+BCXA9H,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IACtDD,EAAQ8S,0BAA4B9S,EAAQ2S,yBAA2B3S,EAAQif,iCAAmCjf,EAAQ0S,iCAAmC1S,EAAQimB,iCAAmCjmB,EAAQkmB,iCAAmClmB,EAAQmmB,+BAAiCnmB,EAAQ6S,2CAAwC,EAC5U,MAAM7R,EAAI,EAAQ,MACZwC,EAAM,EAAQ,OACdyP,EAAgB,EAAQ,OACxBsG,EAAkB,EAAQ,OAC1BwK,EAAgC,EAAQ,OAC9CjkB,OAAOC,eAAeC,EAAS,mCAAoC,CAAE8R,YAAY,EAAMC,IAAK,WAAc,OAAOgS,EAA8BrR,gCAAkC,IACjL5S,OAAOC,eAAeC,EAAS,mCAAoC,CAAE8R,YAAY,EAAMC,IAAK,WAAc,OAAOgS,EAA8B9E,gCAAkC,IACjLnf,OAAOC,eAAeC,EAAS,2BAA4B,CAAE8R,YAAY,EAAMC,IAAK,WAAc,OAAOgS,EAA8BpR,wBAA0B,IACjK,MAAME,UAA8C0G,EAAgBC,aAChE,WAAApX,CAAY5B,EAAU,CAAC,GACnB+B,QACAC,KAAK6O,KAAO,iBACZ7O,KAAK6e,sBAAwB,GAC7B7e,KAAK8e,oBAAsB,GAE3B,MAAM,WAAEG,GAAejhB,EACvB,GAAIihB,GAAcA,EAAWC,WAAWvG,SAAS,KAAM,CACnD,MAAM,SAAE9C,EAAQ,SAAE7B,EAAQ,KAAE/N,EAAI,KAAElF,GAASC,EAAIO,MAAM0d,EAAWC,YAChE,GAAIne,GAAwB,MAAhBA,EAAK4a,OAAgB,CAC7B,MAAMwD,EAAane,EAAIoe,OAAO,CAAEvJ,WAAU7B,WAAU/N,UAChDgZ,EAAWC,WAAW5Q,MAAM,EAAG2Q,EAAWC,WAAWtE,QAAQ,MACjE,MAAM,IAAIxV,MAAUqL,EAAc+B,WAAa;sEACOyM,EAAWC,qBAAqB,kBAAkBC;kBAE5G,CACJ,CAGA,GAFAnf,KAAKif,WAAajhB,EAAQihB,WAC1Bjf,KAAK6e,sBAAwB7gB,EAAQ6gB,uBAAyB,IACzD5P,MAAMC,QAAQlP,KAAK6e,wBAAgE,kBAA/B7e,KAAK6e,sBAC1D,MAAM,IAAIzZ,MAAM,uDAEpBpF,KAAKqf,cAAgBrhB,EAAQqhB,cAC7Brf,KAAKsf,YAActhB,EAAQshB,YAC3Btf,KAAK8e,oBACD9gB,EAAQwhB,sBACJxhB,EAAQyhB,oBACR,GACRzf,KAAK0f,yBAA2B1hB,EAAQ0hB,0BAA4B,CAAC,CACzE,CACA,OAAAvI,GACI,OAAOnX,KAAKif,WACN,4BAA4Bjf,KAAKif,WAAWC,aAC5C,6CACV,CAIA,SAAAnD,CAAUC,GACN,MAAO,CACHnN,KAAM7O,KAAK6O,KACXoQ,WAAYjf,KAAKif,WACjBI,cAAerf,KAAKqf,cACpBC,aAAa,EAAIvI,EAAgB2J,sBAAsB1gB,KAAKsf,YAAatD,GACzE2E,4BAA6B3gB,KAAK6e,sBAClCC,oBAAqB9e,KAAK8e,oBAAoB1e,KAAKwgB,GAK3C,SAAUA,EACH,CAAEC,KAAMD,EAAWC,KAAKpa,SAAS,SAGjCma,IAGflB,yBAA0BlhB,EAAEwO,UAAUhN,KAAK0f,0BAA0B,EAAGoB,MAAKC,iBAAiB,CAAGD,KAAK,EAAI/J,EAAgBiK,iBAAiBF,GAAMC,iBAEzJ,EAEJvjB,EAAQ6S,sCAAwCA,EAChD,MAAMsT,UAAuC5M,EAAgBC,aACzD,WAAApX,GACIG,SAASkX,WACTjX,KAAK6O,KAAO,SAChB,CACA,OAAAsI,GACI,MAAO,6BACX,EAEJ3Z,EAAQmmB,+BAAiCA,EACzC,MAAMD,UAAyC3M,EAAgBC,aAC3D,WAAApX,GACIG,SAASkX,WACTjX,KAAK6O,KAAO,WAChB,CACA,OAAAsI,GACI,MAAO,uDACX,EAEJ3Z,EAAQkmB,iCAAmCA,EAC3C,MAAMD,UAAyC1M,EAAgBC,aAC3D,WAAApX,CAAYgkB,EAAYrG,EAAgB,qBAAsB9c,EAAU,CAAC,EAAGU,EAAO,IAC/EpB,QACAC,KAAK4jB,WAAaA,EAClB5jB,KAAKud,cAAgBA,EACrBvd,KAAKS,QAAUA,EACfT,KAAKmB,KAAOA,EACZnB,KAAK6O,KAAO,WAChB,CACA,OAAAsI,GACI,MAAO,uDAAuDnX,KAAK4jB,YACvE,EAEJpmB,EAAQimB,iCAAmCA,EAC3CjmB,EAAQ8S,0BAA4B,CAChC,iBAAkBD,EAClB,UAAWsT,EACX,YAAaD,EACb,YAAaD,EACb,mBAAoBlC,EAA8BrR,iCAClD,mBAAoBqR,EAA8B9E,iCAClD,QAAW8E,EAA8BpR,yB,+BClH7C7S,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IACtDD,EAAQwV,0BAAuB,EAC/B,MAAM6Q,EAAkC,EAAQ,OAC1CrC,EAAsB,EAAQ,OAC9BlO,EAAa,EAAQ,OAmB3B,MAAMN,UAA6BwO,EAAoBrO,gBAKnD,WAAAvT,CAAY8hB,GACR3hB,QACAC,KAAK0hB,QAAUA,EAEf1hB,KAAKyP,SAASoE,KAAK,IAAIP,EAAWuE,gBACtC,CAoBA,eAAA6K,CAAgB1kB,EAAU,CAAC,GACvB,MAAMmO,EAAO,IACNnM,KAAKyT,oBACRuO,QAAS,IAAI6B,EAAgCxT,sCAAsCrS,IAEvF,OAAOgC,KAAK0hB,QAAQvV,EACxB,CAyBA,mBAAMwW,CAAclC,EAAmBziB,EAAU,CAAC,GAC9C,MAAMmO,EAAO,IACNnM,KAAKyT,oBACRuO,QAAS,IAAI6B,EAAgCxT,sCAAsC,IAC5ErS,EACHihB,WAAY,IACLjhB,EAAQihB,WACXC,WAAYuB,MAIxB,OAAOzgB,KAAK0hB,QAAQvV,EACxB,CAeA,QAAA2X,GACI,MAAM3X,EAAO,IACNnM,KAAKyT,oBACRuO,QAAS,IAAI6B,EAAgCF,gCAEjD,OAAO3jB,KAAK0hB,QAAQvV,EACxB,CAeA,mBAAA4X,GACI,MAAM5X,EAAO,IACNnM,KAAKyT,oBACRuO,QAAS,IAAI6B,EAAgCH,kCAEjD,OAAO1jB,KAAK0hB,QAAQvV,EACxB,CAgBA,oBAAA6X,CAAqBJ,EAAYrG,EAAe9c,EAASU,GACrD,MAAMgL,EAAO,IACNnM,KAAKyT,oBACRuO,QAAS,IAAI6B,EAAgCJ,iCAAiCG,EAAYrG,EAAe9c,EAASU,IAEtH,OAAOnB,KAAK0hB,QAAQvV,EACxB,CAeA,mBAAAyW,GACI,MAAMzW,EAAO,IACNnM,KAAKyT,oBACRuO,QAAS,IAAI6B,EAAgC3T,kCAEjD,OAAOlQ,KAAK0hB,QAAQvV,EACxB,CAmBA,mBAAA0W,GACI,MAAM1W,EAAO,IACNnM,KAAKyT,oBACRuO,QAAS,IAAI6B,EAAgCpH,kCAEjD,OAAOzc,KAAK0hB,QAAQvV,EACxB,CAeA,WAAA2W,GACI,MAAM3W,EAAO,IACNnM,KAAKyT,oBACRuO,QAAS,IAAI6B,EAAgC1T,0BAEjD,OAAOnQ,KAAK0hB,QAAQvV,EACxB,EAEJ3O,EAAQwV,qBAAuBA,C,qDCrO/B1V,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IACtDD,EAAQ+e,yBASR,SAAkC7D,GAC9B,MAAO,IACAA,EACHvX,MAAM,EAAI2b,EAAemE,UAAUvI,EAAMvX,KAAKwc,QAAQlX,SAAS,UAEvE,EAbAjJ,EAAQ2e,2BAcR,SAAoCzD,GAChC,MAAO,IACAA,EACHvX,MAAM,EAAImJ,EAAgBY,kBAAiB,EAAI6L,EAAgBkN,mBAAmBvL,EAAMvX,MAAOuX,EAAMjY,SAE7G,EAlBAjD,EAAQqgB,8BAwBR,SAAuCnF,GACnC,IAAIwL,EAgBJ,OAfKxL,EAAMvX,KAGF3C,EAAEyW,SAASyD,EAAMvX,MACtB+iB,GAAiB,EAAInN,EAAgBiK,kBAAiB,EAAIlE,EAAemE,UAAUvI,EAAMvX,OAEpF3C,EAAE8f,SAAS5F,EAAMvX,MACtB+iB,GAAiB,EAAInN,EAAgBiK,iBAAiBtI,EAAMvX,MAEvD3C,EAAE+f,cAAc7F,EAAMvX,OAAS3C,EAAEggB,aAAa9F,EAAMvX,MACzD+iB,GAAiB,EAAIvH,EAAqB8B,QAAQ/F,EAAMvX,OAEnD,EAAImJ,EAAgB6Z,eAAezL,EAAMvX,QAC9C+iB,GAAiB,EAAInN,EAAgBiK,kBAAiB,EAAIlE,EAAemE,UAAUvI,EAAMvX,KAAKwc,UAZ9FuG,OAAiBhe,EAcd,IACAwS,EACHvX,KAAM+iB,EACN9W,QAASsL,EAAMtL,SACT,EAAI2J,EAAgBiK,kBAAiB,EAAIlE,EAAemE,UAAUvI,EAAMtL,eACxElH,EAEd,EA/CA1I,EAAQ4mB,gCAqDR,SAAyC1L,GACrC,MAAO,IACAA,EACHvX,UAAqB+E,IAAfwS,EAAMvX,KACNgK,EAAOC,KAAKsN,EAAMvX,KAAM,eACxB+E,EACNkH,aAA2BlH,IAAlBwS,EAAMtL,QACTjC,EAAOC,KAAKsN,EAAMtL,QAAS,eAC3BlH,EAEd,EA9DA,MAAM1H,EAAI,EAAQ,MACZme,EAAuB,EAAQ,OAC/BG,EAAiB,EAAQ,OACzBxS,EAAkB,EAAQ,OAC1ByM,EAAkB,EAAQ,M,qDCThCzZ,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IACtDD,EAAQ6mB,oBAAsB7mB,EAAQwZ,kBAAe,EACrDxZ,EAAQue,UAWR,SAAmBuI,EAAKxG,GACpB,MAAM9B,EAAU,IAAIqI,EAAoBvG,GAClCtY,EAAO8e,EAAIvI,UAAUC,GAE3B,OADAxW,EAAK+e,QAAUvI,EAAQuI,QAChB/e,CACX,EAfAhI,EAAQ6e,YAgBR,SAAqB7W,EAAMsY,EAAQ0G,EAAYC,GAC3C,MAAM5V,EAAOrJ,EAAKqJ,KACZmN,EAAU,IAAIqI,EAAoBvG,EAAQtY,EAAK+e,SAC/CG,EAAeD,EAAO5V,GAAMwN,YAAY7W,EAAMwW,EAASwI,GAEvDG,EAAiBD,EAAaE,QAKpC,OAJAF,EAAaE,QAAU,KACnBD,IACA3I,EAAQ4I,SAAS,EAEdF,CACX,EA1BAlnB,EAAQwjB,gBAiMR,SAAyBrD,GACrB,OAAOA,EAAOlX,SAAS,SAC3B,EAlMAjJ,EAAQymB,kBAmMR,SAA2BtG,GACvB,OAAOxS,EAAOC,KAAKuS,EAAQ,SAC/B,EApMAngB,EAAQqnB,uBAAyBA,EACjCrnB,EAAQkjB,qBAuNR,SAASA,EAAqBpB,EAAatD,GACvC,GAAIxd,EAAEsmB,WAAWxF,GAAc,CAC3B,MAAMyF,EAAa,yBAAwB,EAAIC,EAAOC,QAEtD,OADAjJ,EAAQC,UAAU8I,EAAYzF,GACvByF,CACX,CACK,OAAIvmB,EAAE0Q,QAAQoQ,GACRA,EAAYlf,KAAK8kB,GAAWxE,EAAqBwE,EAAQlJ,MAE3D,EAAIzL,EAAkB0S,kBAAkB3D,GAzB1C,CAAE,CAAC6F,GA0BgB7F,EA1BmB/O,EAAkBC,oBA4BtD8O,EACE,IACAA,EACH8F,WAAY9F,EAAY8F,YAAYhlB,KAAKilB,GAAyC,iBAAjBA,GAA6B,SAAUA,EAClG,CAAExE,KAAMwE,EAAaxE,KAAKpa,SAAS,SACnC4e,IACN7F,qBAAsBF,EAAYE,sBAAsBpf,KAAKilB,GAAiB,SAAUA,EAClF,CAAExE,KAAMwE,EAAaxE,KAAKpa,SAAS,SACnC4e,UART,CAWT,EA7OA7nB,EAAQ8nB,uBA8OR,SAASA,EAAuBhG,EAAatD,EAASwI,GAClD,GAAIhmB,EAAEyW,SAASqK,GAAc,CACzB,MAAMyF,EAAazF,EAInB,OAH4BvhB,MAAOC,SAClBge,EAAQvT,QAAQsc,EAAY/mB,EAGjD,CACK,OAAIQ,EAAE0Q,QAAQoQ,GACRA,EAAYlf,KAAK8kB,GAAWI,EAAuBJ,EAAQlJ,EAASwI,KAGpEK,EAAuBvF,EAAakF,EAEnD,EA3PA,MAAMhmB,EAAI,EAAQ,MACZoe,EAAW,EAAQ,OACnBoI,EAAS,EAAQ,OACjBzU,EAAoB,EAAQ,OAwClC/S,EAAQwZ,aArBR,MAII,SAAA+E,CAAUwJ,GAEN,OAAOvlB,IACX,CAIA,kBAAOqc,CAAY7W,EAAM+f,EAAUC,GAE/B,OAAOhnB,EAAEinB,OAAOzlB,KAAK0lB,UAAWlgB,EACpC,CAKA,OAAAof,GAAY,GAGhB,MAAMe,EAAkB,CAAEC,gBAAgB,GAI1C,MAAMvB,UAA4BzH,EAASiJ,OACvC,WAAAjmB,CAAYkmB,EAAWvB,GACnBxkB,MAAM,CAAEke,YAAY,IACpBje,KAAK8lB,UAAYA,EACjB9lB,KAAK+lB,kBAAqBvkB,IACtBxB,KAAKqD,QAAQ7B,EAAM,EAEvBxB,KAAKgmB,mBAAqB,KACtBhmB,KAAK4C,KAAK,EAEd5C,KAAKimB,mBAAsBC,IACJA,EAAQzf,WAChBsS,MAAM,MAAMtP,QAAO0c,KAAOA,IAAGzlB,SAAS0lB,IAC7C,IAAI5gB,EACJ,IACIA,EAAOlE,KAAKC,MAAM6kB,EACtB,CACA,MAAO/lB,GAGH,OAFAwC,QAAQM,IAAI9C,QACZwC,QAAQM,IAAI,0CAA2CijB,EAAY3f,WAEvE,CACIjB,EAAK+e,UAAYvkB,KAAKukB,UAClB/lB,EAAEkd,QAAQld,EAAE6nB,KAAK7gB,EAAM,WAAYmgB,GACnC3lB,KAAK4kB,SAAQ,GAEb5kB,KAAK6T,KAAKrO,GAClB,GACF,EAENxF,KAAKsmB,SAAU,EACftmB,KAAKukB,QAAUA,IAAW,EAAIS,EAAOC,MACrCjlB,KAAK8lB,UAAUpjB,GAAG,QAAS1C,KAAK+lB,mBAChC/lB,KAAK8lB,UAAUpjB,GAAG,SAAU1C,KAAKgmB,mBACrC,CAIA,MAAAO,CAAO1mB,EAAS2mB,EAAUre,GACtBtI,EAAQ0kB,QAAUvkB,KAAKukB,QACvB,MAAMpG,EAAQ7c,KAAKiE,UAAU1F,GAAW,KACnCG,KAAK8lB,UAAUW,MAAMtI,EAAOqI,GAI7Bre,IAHAnI,KAAK8lB,UAAUniB,KAAK,QAASwE,EAKrC,CACA,KAAAue,GACS1mB,KAAKsmB,UACNtmB,KAAK8lB,UAAUpjB,GAAG,OAAQ1C,KAAKimB,oBAC/BjmB,KAAKsmB,SAAU,EAEvB,CACA,OAAA7d,CAAQke,EAAcC,GAClB,IAAIC,EACArhB,EACAhH,EAAEyW,SAAS0R,IACXE,EAASF,EACTnhB,EAAOohB,GAGPphB,EAAOmhB,EAEX,MAAMG,GAAY,EAAI9B,EAAOC,MAC7B,OAAO,IAAIzhB,SAAQ,CAACC,EAASC,KACzB,MAAMqjB,EAAoBjnB,IAClBA,EAASgnB,YAAcA,IACnBhnB,EAAS0B,MAETkC,EAAOpG,OAAOwD,OAAO,IAAIsE,MAAS,CAAE4hB,WAAO9gB,GAAapG,EAAS0B,QAGjEiC,EAAQ3D,EAAS0F,MAErBxF,KAAKinB,eAAe,OAAQF,GAChC,EAEEte,EAAU,CAAEjD,OAAMshB,aACpBD,IACApe,EAAQoe,OAASA,GACrB7mB,KAAKymB,MAAMhe,GAAUpI,IACbA,EACAqD,EAAOrD,GAEPL,KAAK0C,GAAG,OAAQqkB,EAAiB,GACvC,GAEV,CACA,SAAA9K,CAAUiL,EAAYC,GAClB,IAAIC,EACAC,EACA7oB,EAAEyW,SAASiS,IACXE,EAAaF,EACbG,EAAKF,GAGLE,EAAKH,EAETlnB,KAAK0C,GAAG,QAAQ3E,MAAO0K,IACnB,MAAM,UAAEqe,EAAS,OAAED,GAAWpe,EAE9B,QAAmBvC,IAAfkhB,GAA4BP,IAAWO,EAE3C,IACI,MAAMtnB,EAAW,CACbgnB,YACAthB,WAAY6hB,EAAG5e,EAAQjD,OAE3B,IAAKxF,KAAKsnB,SACN,OACJtnB,KAAKymB,MAAM3mB,EACf,CACA,MAAO0B,GAGH,GADAA,EAAQhD,EAAE+oB,KAAK/lB,EAAOlE,OAAOkqB,oBAAoBhmB,KAC5CxB,KAAKsnB,SACN,OACJtnB,KAAKymB,MAAM,CAAEK,YAAWtlB,SAC5B,IAER,CAGA,OAAAojB,CAAQ6C,GAAkB,GACtBznB,KAAK0C,GAAG,SAAS,SAEZ+kB,EAGDznB,KAAK4C,MAFL5C,KAAK4C,IAAI+iB,GAIb3lB,KAAKoD,mBAAmB,QAExBpD,KAAK8lB,UAAUmB,eAAe,OAAQjnB,KAAKimB,oBAC3CjmB,KAAK8lB,UAAUmB,eAAe,QAASjnB,KAAK+lB,mBAC5C/lB,KAAK8lB,UAAUmB,eAAe,SAAUjnB,KAAKgmB,mBACjD,EAEJxoB,EAAQ6mB,oBAAsBA,EAO9B,MAAMc,EAA6B,gCAQnC,SAASN,EAAuBpnB,EAAO+mB,GACnC,GAJJ,SAA+B/mB,GAC3B,OAAOA,GAAS0nB,KAA8B1nB,CAClD,CAEQiqB,CAAsBjqB,GAAQ,CAC9B,MAAM0lB,EAAW,CACb,CAAC5S,EAAkBC,mBAAoB/S,EAAM0nB,IAEjD,OAAO,EAAI5U,EAAkB2S,kBAAkBC,EAAUqB,EAC7D,CAEI,OAAO/mB,CAEf,C,6BC1NA,IAAI+R,EAUAiC,EAbJnU,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IACtDD,EAAQiU,aAAejU,EAAQgS,OAAShS,EAAQY,+BAA4B,EAC5EZ,EAAQY,0BAA4B,MAEpC,SAAWoR,GACPA,EAAOA,EAAY,IAAI,GAAK,MAC5BA,EAAOA,EAAa,KAAI,GAAK,OAC7BA,EAAOA,EAAY,IAAI,GAAK,MAC5BA,EAAOA,EAAe,OAAI,GAAK,SAC/BA,EAAOA,EAAc,MAAI,GAAK,QAC9BA,EAAOA,EAAa,KAAI,GAAK,OAC7BA,EAAOA,EAAgB,QAAI,GAAK,SACnC,CARD,CAQGA,IAAWhS,EAAQgS,OAASA,EAAS,CAAC,IAEzC,SAAWiC,GACPA,EAAaA,EAAuB,SAAI,GAAK,WAC7CA,EAAaA,EAAsB,QAAI,GAAK,SAC/C,CAHD,CAGGA,IAAiBjU,EAAQiU,aAAeA,EAAe,CAAC,G,qDCjB3DnU,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IACtDD,EAAQmqB,eAAiBnqB,EAAQoqB,eAAiBpqB,EAAQqqB,iBAAmBrqB,EAAQyjB,cAAW,EAChGzjB,EAAQsqB,YAyHR,SAAqBpP,EAAOqP,EAAUC,EAAW1Q,KAC7C,MAAM2Q,EAAQ,GACd,IAAIC,EAAkBxP,EACtB,KAAOwP,EAAgBhoB,QAAQ,CAC3B,IAAIioB,EAAYD,EAAgBtN,QAAQmN,GAKxC,IAJmB,IAAfI,IACAA,EAAYD,EAAgBhoB,QAChC+nB,EAAMpU,KAAKqU,EAAgB5Z,MAAM,EAAG6Z,IACpCD,EAAkBA,EAAgB5Z,MAAM6Z,EAAYJ,EAAS7nB,QACzD+nB,EAAM/nB,SAAW8nB,EAAW,EAAG,CAC/BC,EAAMpU,KAAKqU,GACX,KACJ,CACJ,CACA,OAAOD,CACX,EAvIA,MAAMxpB,EAAW,EAAQ,OACnBqf,EAAS,EAAQ,OAEjBsK,EADS,EAAQ,OACQ3oB,OACzB,8BACA6X,IAON9Z,EAAQyjB,SANUvI,GAAUvN,EAAOmT,SAAS5F,GACtCA,EACiB,iBAAVA,EACHvN,EAAOC,KAAKsN,EAAO,QAEnBvN,EAAOC,KAAKsN,GAiDtBlb,EAAQqqB,iBA7CiB,CAAClK,EAAQ0K,KAC9B,IAAIC,GAAS,EACb,MAAMC,EAAe,IAAIzK,EAAO0K,YAAY,CAIxC,IAAAC,CAAKnL,GA4BD,OAzBKgL,IACG3K,EAAO+K,WACPH,EAAallB,QAAQsa,EAAO+K,aAI5BH,EAAa9B,MAAMtb,EAAOwd,OAAOhL,EAAOiL,gBAExCP,EAAY1lB,KAAK4lB,GACbF,EAAYQ,eACZN,EAAa3lB,MACbylB,EAAYS,iBACZP,EAAallB,UAEjBglB,EAAY3lB,GAAG,SAAUrC,IACrBkoB,EAAaxlB,KAAK,QAAS1C,EAAE,IAIjCsd,EAAO9Z,OAAM,UAEjBykB,GAAS,GAINxK,EAAOE,UAAU0H,UAAUgB,MAAMvc,KAAKnK,KAAMsd,EACvD,IAQJ,OANAK,EAAOoL,OAAOrmB,GAAG,YAAasmB,IAGrBV,GACDC,EAAaE,KAAK,EAAE,IAErBF,CAAY,EAQvB/qB,EAAQoqB,eALgBjK,IACpB,MAAM4K,EAAe,IAAIzK,EAAO0K,YAEhC,OADAD,EAAa3lB,IAAI+a,GACV4K,CAAY,EAuDvB/qB,EAAQmqB,eApDe,CAACjP,EAAOuQ,EAAUb,KACrC,IAAIY,EAAS,GACb,MAAME,EAAgB,IAAI1lB,SAAQ,CAACC,EAASC,KACxC,SAASylB,IACLD,EAAcR,WAAa,IAAItjB,MAAM,WACrC1B,EAAOwlB,EAAcR,WACzB,CAEA,GAAIhQ,EAAMmQ,cACN,OAAOplB,EAAQ0H,EAAOC,KAAK,KAC/B,GAAIsN,EAAMoQ,gBACN,OAAOK,IACX,IAAIC,EAAc,EAClB,MAAMC,EAAUlD,IACZiD,GAAejD,EAAEjmB,OACjB8oB,EAAOnV,KAAKsS,GAIRiD,EAAcH,IAGdC,EAAcH,OAAOhmB,KAAK,WAAYimB,GAEtCE,EAAcN,cAAgBI,EAAS,GACvCtQ,EAAMuO,eAAe,OAAQoC,GAU7B5lB,EAAQ0H,EAAOC,KAAK,KACxB,EAEJsN,EAAMhW,GAAG,OAAQ2mB,GACjB3Q,EAAM/U,KAAK,OAAO,KACdF,EAAQ0H,EAAOwd,OAAOK,GAAQ,IAElCtQ,EAAM/U,KAAK,UAAWwlB,GACtBzQ,EAAMhW,GAAG,SAAUrC,IACf6oB,EAAcR,WAAaQ,EAAcR,YAAcroB,EACvDqD,EAAOrD,EAAE,GACX,IAIN,OAFA6oB,EAAcN,cAAgBI,EAC9BE,EAAcH,OAAS,IAAItqB,EAASiD,aAC7BwnB,CAAa,C,2BCxHxB5rB,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IACtDD,EAAQyD,YAER,SAAqBO,GACjB,MAAwB,iBAAVA,IAAuBA,aAAiB4D,OAClD5D,EAAM3B,SACN2B,EAAMN,MACNM,EAAMwlB,MACd,C,+BCRA1pB,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IACtDD,EAAQ8rB,eAAiB9rB,EAAQ+rB,mBAAqB/rB,EAAQgsB,mBAAgB,EAC9EhsB,EAAQisB,mBAsCR,SAA4BC,GACxB,MAAM3jB,EAAS,GACf,IAAK,IAAI4jB,EAAI,EAAGA,EAAID,EAAexpB,OAAQypB,GAAK,EAC5C5jB,EAAO4jB,EAAI,GAAK,CAACD,EAAeC,GAAID,EAAeC,EAAI,IAE3D,OAAO5jB,CACX,EA3CAvI,EAAQosB,wBA4CR,SAAiC/e,GAC7B,OAAOA,EAAWgf,MACtB,EA7CArsB,EAAQsN,mBAqDR,SAA4BD,GACxB,OAAOA,EAAWif,QAAO,CAACrpB,GAAUE,EAAKlD,MAErC,MAAMssB,EAAgBtpB,EADtBE,EAAMA,EAAI2Z,eAWV,OATIrL,MAAMC,QAAQ6a,GACdA,EAAclW,KAAKpW,GAGnBgD,EAAQE,GADHopB,EACU,CAACA,EAAetsB,GAGhBA,EAEZgD,CAAO,GACf,CAAC,EACR,EAnEAjD,EAAQwsB,iCA6ER,SAA0Cnf,GAMtC,MAAMof,EAAgB,CAAC,EACvB,OAAOpf,EAAWif,QAAO,CAACrpB,GAAUE,EAAKlD,MACrC,MAAMysB,EAAevpB,EAAI2Z,cACrB2P,EAAcC,GAGdvpB,EAAMspB,EAAcC,GAKpBD,EAAcC,GAAgBvpB,EAElC,MAAMopB,EAAgBtpB,EAAQE,GAU9B,OATIsO,MAAMC,QAAQ6a,GACdA,EAAclW,KAAKpW,GAGnBgD,EAAQE,GADHopB,EACU,CAACA,EAAetsB,GAGhBA,EAEZgD,CAAO,GACf,CAAC,EACR,EA3GAjD,EAAQuN,mBA4GR,SAA4BtK,GACxB,MAAMoK,EAAa,GACnB,IAAK,IAAIlK,KAAOF,EAAS,CACrB,MAAMhD,EAAQgD,EAAQE,QACRuF,IAAVzI,IAEAwR,MAAMC,QAAQzR,GACdA,EAAMiD,SAASuM,GAAMpC,EAAWgJ,KAAK,CAAClT,EAAKsM,MAG3CpC,EAAWgJ,KAAK,CAAClT,EAAKlD,IAE9B,CACA,OAAOoN,CACX,EAzHArN,EAAQ2sB,oBA0HR,SAA6B1pB,GACzB,MAAM2pB,EAAc,GACpB,IAAK,IAAIzpB,KAAOF,EAAS,CACrB,MAAMhD,EAAQgD,EAAQE,QACRuF,IAAVzI,IAEAwR,MAAMC,QAAQzR,GACdA,EAAMiD,SAASuM,IACXmd,EAAYvW,KAAKlT,GACjBypB,EAAYvW,KAAK5G,EAAE,KAIvBmd,EAAYvW,KAAKlT,GACjBypB,EAAYvW,KAAKpW,IAEzB,CACA,OAAO2sB,CACX,EA3IA5sB,EAAQ6sB,cA8IR,SAAuBC,GACnB,IAAIC,EAAYD,EAAU7gB,QAAO,EAAE9I,KAAoB,MAAXA,EAAI,OAC3C,EAAInD,EAAQgsB,eAAee,EAAW,UAAW,EAAI/sB,EAAQgsB,eAAec,EAAW,eACxFC,EAAUC,QAAQ,CAAC,QAAQ,EAAIhtB,EAAQgsB,eAAec,EAAW,cAAc,KAInF,MAAMG,GAAgB,EAAIjtB,EAAQ8rB,gBAAgBiB,EAAW,UAK7D,OAJIE,EAAcvqB,OAAS,IACvBqqB,EAAYA,EAAU9gB,QAAO,EAAE9I,KAA+B,WAAtBA,EAAI2Z,gBAC5CiQ,EAAU1W,KAAK,CAAC,SAAU4W,EAAcnqB,KAAK,SAE1CiqB,CACX,EA1JA/sB,EAAQktB,cAqKR,SAAuBjqB,GACnB,OAAOA,EAAQgJ,QAAO,EAAE9I,MAAUgqB,EAAsBhS,SAAShY,EAAI2Z,gBACzE,EAtKA9c,EAAQotB,mBAyKR,SAA4B9qB,GAExB,CACI,aACA,iBACA,oBACA,QACFY,SAASmqB,GAAkB/qB,EAASgrB,aAAaD,IACvD,EAhLArtB,EAAQutB,eAiLR,SAAwBrhB,EAAMjM,GAC1B,IAGI,OAFA4I,EAAK2kB,mBAAmBthB,GACxBrD,EAAK4kB,oBAAoBvhB,EAAMjM,IACxB,CACX,CACA,MAAO4C,GACH,OAAO,CACX,CACJ,EAzLA,MAAMgG,EAAO,EAAQ,OAmBrB7I,EAAQgsB,cADc,CAAC3e,EAAYqgB,IAAcrgB,EAAWiE,MAAK,EAAEnO,KAASA,EAAI2Z,gBAAkB4Q,IAGlG1tB,EAAQ+rB,mBADmB,CAAC1e,EAAYqgB,IAAcrgB,EAAWsgB,WAAU,EAAExqB,KAASA,EAAI2Z,gBAAkB4Q,IAG5G1tB,EAAQ8rB,eADe,CAACze,EAAYqgB,IAAcrgB,EAAWpB,QAAO,EAAE9I,KAASA,EAAI2Z,gBAAkB4Q,IAmIrG,MAAMP,EAAwB,CAC1B,aACA,UACA,OACA,iBACA,aACA,mBACA,oB,+BC5KJrtB,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IACtDD,EAAQiM,OAIR1L,eAAsBqtB,EAAOlR,GACzB,IAAImR,QAAoB7nB,QAAQyE,IAAImjB,EAAMhrB,IAAI8Z,IAC9C,OAAOkR,EAAM3hB,QAAO,CAACwD,EAAG0c,IAAM0B,EAAY1B,IAC9C,EANAnsB,EAAQ8tB,iBAORvtB,eAAgCumB,GAC5B,OAAO9lB,EAAE+sB,UAAUjuB,OAAO+f,KAAKiH,SAAY9gB,QAAQyE,IAAI3K,OAAOkuB,OAAOlH,IACzE,EARA9mB,EAAQsI,YASR,WACI,IAAI2lB,EACAC,EACA3lB,EAAS,IAAIvC,SAAQ,CAACC,EAASC,KAC/B+nB,EAAkBhoB,EAClBioB,EAAiBhoB,CAAM,IAI3B,OAFAqC,EAAOtC,QAAUgoB,EACjB1lB,EAAOrC,OAASgoB,EACT3lB,CACX,EAlBA,MAAMvH,EAAI,EAAQ,K,qDCJlBlB,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IACtDD,EAAQmuB,iBAAmBnuB,EAAQ0N,gBAAkB1N,EAAQ2mB,cAAgB3mB,EAAQouB,UAAYpuB,EAAQquB,qBAAkB,EAC3HruB,EAAQsuB,QAAUA,EAClBtuB,EAAQuuB,iBAoDRhuB,eAAgC4f,EAAQld,GACpC,MAAMurB,EAAkBvrB,EAAQ,oBAIhC,OAAKurB,cAEexoB,QAAQC,UAAUG,MAAK,IAAM,EAAQ,UAAmBqoB,aAAatO,EAAQqO,EAAiB,CAAEE,MAAO,IADhHvO,CAEf,EA3DAngB,EAAQ2uB,iBAAmBA,EAC3B3uB,EAAQ4uB,sBAAwBA,EAChC5uB,EAAQse,wBA6NR/d,eAAuC0K,GACnC,MAAMtH,QAAakrB,EAAY5jB,EAAQtH,KAAMsH,EAAQhI,SAErD,MAAO,IADa2rB,EAAsB3jB,GAGtCtH,OACA6J,YAAavC,EAAQuC,aAAe,GACpCC,UAAU,EAAIV,EAAeO,oBAAoBrC,EAAQuC,aAAe,IAEhF,EArOAxN,EAAQ8uB,cA2PR,SAAuBxsB,EAAU8K,EAAcS,EAAMrN,GACjD,IAAIuuB,EAAkBzsB,EACtBysB,EAAgB3hB,aAAeA,EAC/B2hB,EAAgBlhB,KAAOA,EAEvB,MAAMmhB,EAAiB,IAAI1O,EAAO0K,YAC5BiE,EAAsBF,EAAgBX,UACtCc,EAAgBH,EAAgB9F,MAChCkG,EAAcJ,EAAgB3pB,IAC9BgqB,EAAsBL,EAAgBM,YACtCC,EAAqBP,EAAgBQ,WAC3C,IAAIC,EA4CAC,EA3CJV,EAAgBW,cAAgB,IAAMF,GAAkB,GACxDT,EAAgBQ,WAAa,KAAM,EAAIxiB,EAAeO,oBAAoByhB,EAAgBW,iBAC1FX,EAAgBX,UAAY,YAAalO,GAQrC,IAAIyP,EAPCviB,EAAawiB,uBACdxiB,EAAawiB,qBAAuBC,KAGpCvB,EAAQS,IAAuC,iBAAZ7O,EAAK,KACxCA,EAAK,QAAKxX,GAGVwX,EAAK,GACLyP,EAAazP,EAAK,GAEM,iBAAZA,EAAK,KACjByP,EAAazP,EAAK,IAEtBsP,EAAiBM,EAA2BH,GACxCrB,EAAQS,IACRS,EAAexC,QAAQ,CAAC,UAAW9M,EAAK,GAAGjX,aAK/C,MAAM8mB,EAAgBT,EAAmBU,MAAMxtB,MACzCytB,EAAoBT,EAAe5sB,KAAI,EAAEO,KAASA,EAAI2Z,gBACtDoT,EAAmBpwB,OAAO+f,KAAKkQ,GAerC,OAdIG,EAAiBxtB,QACjBwtB,EACKjkB,QAAQ9I,IAAS8sB,EAAkB9U,SAAShY,KAC5CgtB,UACAjtB,SAASC,IACV,MAAMlD,EAAQ8vB,EAAc5sB,GACxBsO,MAAMC,QAAQzR,GACdA,EAAMkwB,UAAUjtB,SAAQuM,GAAK+f,GAAgBxC,QAAQ,CAAC7pB,EAAKsM,WAE5C/G,IAAVzI,GACLuvB,GAAgBxC,QAAQ,CAAC7pB,EAAKlD,GAClC,IAGDgvB,EAAoBe,MAAMxtB,KAAM0d,EAC3C,EAEA6O,EAAgBqB,eAAiB,IAAMX,GAAmB,GAC1DV,EAAgBM,YAAc,YAAanP,GACvC,MAAMmQ,EAAcnQ,EAAK,GAEzB,OADAuP,EAAkBK,EAA2BO,GACtCjB,EAAoBY,MAAMxtB,KAAM0d,EAC3C,EACA,MAAMoQ,EAAgB,YAAapQ,GAE/B,OADA8O,EAAe/F,MAAM+G,MAAMhB,EAAgB9O,GACpCgP,EAAcc,MAAMxtB,KAAM0d,EACrC,EAiBA,OAhBA6O,EAAgB9F,MAAQqH,EACxBvB,EAAgB3pB,IAAM,YAAa8a,GAK/B6O,EAAgB9F,MAAQiG,EACxBF,EAAe5pB,IAAI4qB,MAAMhB,EAAgB9O,GACzC,IAAI3X,EAAS4mB,EAAYa,MAAMxtB,KAAM0d,GAErC,OADA6O,EAAgB9F,MAAQqH,EACjB/nB,CACX,EACAwmB,EAAgBprB,KAAO4sB,EAAgBvB,EAAgBxuB,EAAQirB,SAAS,IAAMsD,EAAgBQ,eAG9FP,EAAe9pB,GAAG,SAAUrC,GAAMksB,EAAgBxpB,KAAK,QAAS1C,KACzDksB,CACX,EA7UA/uB,EAAQwwB,yBAkVRjwB,eAAwC+B,GAEpC,GAAI,YAAaA,EACb,OAAOA,EACX,MAAMqB,QAAakrB,EAAYvsB,EAASqB,KAAMrB,EAASitB,cACvDjtB,EAAS8K,aAAaqjB,sBAAwBnuB,EAAS8K,aAAaqjB,uBAAyBZ,IAC7F,MAAMa,EAAoB1vB,EAAEsB,GAAUynB,KAAK,CACvC,KACA,aACA,eACA,SACDzmB,OAAO,CACNyc,cAAe,GACf9c,QAASX,EAASitB,aAClBliB,WAAY/K,EAASotB,gBACrB/rB,KAAMA,EACN6J,YAAalL,EAAS8tB,iBACtB3iB,UAAU,EAAIV,EAAeO,oBAAoBhL,EAAS8tB,oBAC3DO,UAKH,OAJMruB,aAAoBsuB,EAAMC,sBAE5BH,EAAkB3Q,cAAgBzd,EAASyd,eAExC2Q,CACX,EAzWA1wB,EAAQ8wB,sBA4WR,SAA+B5V,EAAO6V,GAClC,MAAM1iB,EAAM,CAAC,EACb,IACIA,EAAIgK,SAAW0Y,EAAOC,mBAAqB,QAAU,OAGjDD,aAAkBE,EAAMC,YACxB7iB,EAAImI,SAAWua,EAAOI,YAC1B,MAAMC,GAAQ,EAAI9R,EAAegL,aAAapP,EAAO,QAC/CmW,EAAcD,EAAM,GAAGtgB,MAAM,EAAGsgB,EAAM,GAAG1uB,QAAQuG,SAAS,UACzDlI,EAAQuwB,EAAQC,GAAgBF,EAAY9V,MAAM,KACrDxa,IACAsN,EAAItN,OAASA,EAAO+P,MAAM,EAAG,KAEjC,MAAM0gB,EAAiBxwB,EAAE2sB,UAAUyD,GAAQK,GAAyB,IAAhBA,EAAK/uB,SACzD,IACI,MACM2K,EADc+jB,EAAMtgB,MAAM,GAAuB,IAApB0gB,OAAwB9oB,EAAY8oB,GAElE5uB,KAAK6uB,IAAS,EAAInS,EAAegL,aAAamH,EAAM,IAAK,KACzDxlB,QAAQwlB,GAASA,EAAK/uB,OAAS,IAC/BE,KAAK8uB,GAAgBA,EAAY9uB,KAAI+uB,GAAKA,EAAE1oB,SAAS,QAAQkV,WAClE9P,EAAIhB,WAAaA,EACjBgB,EAAIpL,SAAU,EAAI8J,EAAeO,oBAAoBD,EACzD,CACA,MAAOxK,GAAK,CACZ,IACI,MAAMuY,EAAY5X,EAAIO,MAAMutB,GAC5BjjB,EAAI9K,KAAO6X,EAAU7X,WAAQmF,EAC7B,MAAMkpB,EAAa5wB,EAAEsQ,KAAKjD,EAAIpL,SAAS,CAAC4Z,EAAQ1Z,IAA8B,SAAtBA,EAAI2Z,gBACxD8U,EACAvjB,EAAImI,SAAW/E,MAAMC,QAAQkgB,GAAcA,EAAW,GAAKA,EAEtDxW,EAAU5E,WACfnI,EAAImI,SAAW4E,EAAU5E,UAEzB8a,EAAOnW,SAAS,SAAW9M,EAAImI,SAE/BnI,EAAI7K,IAAM8tB,EAIVjjB,EAAI7K,IAAM,GAAG6K,EAAIgK,cAAchK,EAAImI,WAAW8a,EAAOxjB,WAAW,KAAO,GAAK,MACzEwjB,GAEX,CACA,MAAOzuB,GAAK,CACZ,IACI,MAAMgvB,EAAcN,EAAahW,MAAM,KAAK,GAC5ClN,EAAIwjB,YAAcA,CACtB,CACA,MAAOhvB,GAAK,CAChB,CACA,MAAOA,GAAK,CACZ,OAAOwL,CACX,EAjaArO,EAAQ8xB,qBAsaR,SAA8B5W,EAAOjQ,GACjC,MAAM,GAAEjC,EAAE,KAAE6E,EAAI,aAAET,GAAiBnC,EAC7BmmB,GAAQ,EAAI9R,EAAegL,aAAapP,EAAO,QAC/C6W,EAAeX,EAAM,GAAGY,SAAS,EAAGZ,EAAM,GAAG1uB,QAAQuG,SAAS,UAC7DgpB,EAAcC,KAAkBC,GAAoBJ,EAAaxW,MAAM,KACxE6K,EAAagM,SAASF,EAAe,IACrCnS,EAAgBoS,EAAiBrvB,KAAK,KAEtC0uB,EAAiBxwB,EAAE2sB,UAAUyD,GAAQK,GAAyB,IAAhBA,EAAK/uB,SAEnD2K,EADc+jB,EAAMtgB,MAAM,GAAuB,IAApB0gB,OAAwB9oB,EAAY8oB,GAElE5uB,KAAK6uB,IAAS,EAAInS,EAAegL,aAAamH,EAAM,IAAK,KACzD7uB,KAAK8uB,GAAgBA,EAAY9uB,KAAI+uB,GAAKA,EAAE1oB,SAAS,QAAQkV,WAGlE,MAAO,CACHnV,KACA6E,OACAT,eACAgZ,aACArG,gBACA1S,aACApK,SATY,EAAI8J,EAAeO,oBAAoBD,GAUnD1J,MATS,EAAI3D,EAAQ0N,iBAAiBC,EAAOC,KAAK,IAAK,CAAC,GAUxDJ,YAAa,GACbC,SAAU,CAAC,EAEnB,EAhcA,MAAMzM,EAAI,EAAQ,MACZiwB,EAAQ,EAAQ,OAChBL,EAAQ,EAAQ,OAChBtQ,EAAS,EAAQ,OACjB+R,EAAc,EAAQ,OACtBvX,EAAY,EAAQ,OACpB+U,EAAM,EAAQ,OACdrsB,EAAM,EAAQ,OACd8b,EAAiB,EAAQ,OACzBvS,EAAiB,EAAQ,OA+B/B,SAASuhB,EAAQjsB,GACb,MAAQ,gBAAiBA,KAAaA,EAAQwvB,aAAa/jB,WAAW,MACjE,WAAYzL,GAAW,uBAAwBA,CACxD,CAUA9B,eAAeouB,EAAiBxO,EAAQld,GACpC,MAAMurB,EAAkBvrB,EAAQ,oBAIhC,OAAKurB,cAEexoB,QAAQC,UAAUG,MAAK,IAAM,EAAQ,UAAmBksB,aAAanS,EAAQqO,GADtFrO,CAEf,CAhDAngB,EAAQquB,gBAHiBhgB,GAA4B,QAApBA,EAAIwjB,aACH,UAA9BxjB,EAAIpL,QAAoB,YACY,UAApCoL,EAAIpL,QAAQ,oBA2BhBjD,EAAQouB,UAzBU,CAAC9rB,EAAUK,EAAQod,EAAe9c,KAChD,MAAM2pB,OAA0BlkB,IAAZzF,EACd,CAAC,EACDqrB,EAAQhsB,IAAamP,MAAMC,QAAQzO,IAI/B,EAAI8J,EAAeO,oBAAoBrK,GACvCqrB,EAAQhsB,GACJW,EACCwO,MAAMC,QAAQzO,IAGX,EAAI8J,EAAeqf,yBAAyBnpB,IAF5C,EAAI8J,EAAe4f,qBAAqB1pB,QAMpCyF,IAAlBqX,EAEAzd,EAAS8rB,UAAUzrB,EAAQiqB,GAG3BtqB,EAAS8rB,UAAUzrB,EAAQod,EAAe6M,EAC9C,EA2BJ,MAAM2D,EAAkB,CAACgC,EAAY9G,EAAS8D,KAC1C,IAAI7D,EAAgB,KAChB8G,EAAkB,KAClB7uB,EAAO,CAKP,QAAA8uB,GAEI,GAAID,EACA,OAAO,EAAIlT,EAAe8K,gBAAgBoI,GAG9C,MAAMrS,EAASxc,EAAK8f,WAEpB,OADAtD,EAAO9Z,OAAM,UACN,EAAIiZ,EAAe+K,kBAAkBlK,EAAQoS,EACxD,EACA9O,SAAQ,KACCiI,IACDA,GAAgB,EAAIpM,EAAe6K,gBAAgBoI,EAAY9G,GAC/DC,EACKtlB,MAAM+Z,GAAWqS,EAAkBrS,IACnC9Z,OAAM,UAERqlB,GAEXnrB,gBAAqB,SAEVouB,QADchrB,EAAK8f,WACM8L,KAEpCzR,OAAM,CAACkL,EAAW,SACPrlB,EAAK6Z,kBAAkBpX,MAAMssB,GAAMA,EAAEzpB,SAAS+f,KAEzD/K,OAAM,IACKta,EAAKma,SAAS1X,MAAMusB,GAAM7uB,KAAKC,MAAM4uB,KAEhDtV,WAAU,IACC1Z,EAAKma,SAAS1X,MAAMusB,GAAMN,EAAYtuB,MAAM4uB,MAG3D,OAAOhvB,CAAI,EAEfpD,eAAeqyB,EAAoBC,GAC/B,IACI,aAAaA,GACjB,CACA,MACI,MACJ,CACJ,CACA,MAAMhE,EAActuB,MAAOoD,EAAMV,KAC7B,MAAM6vB,QAAmBnvB,EAAK8f,WAC9B,OAAO,EAAIzjB,EAAQ0N,iBAAiBolB,EAAY7vB,EAAQ,EAyF5D,SAAS2rB,EAAsB3jB,GAC3B,MAAO,IACAjK,EAAE+oB,KAAK9e,EAAS,KAAM,gBAAiB,WAAY,cAAe,SAAU,MAAO,OAAQ,kBAAmB,aAAc,WAAY,UAAW,aAAc,QACpKmC,aAAcnC,EAAQmC,aAE9B,CAzFApN,EAAQ2mB,cAHehjB,GACZA,EAAKovB,eAAe,oBA4E/B/yB,EAAQ0N,gBAzEgB,CAAC/J,EAAMV,KAC3B,MAAM+vB,EAAgB,CAClB7S,OAAQxc,EACR,sBAAMsvB,GACF,OAAOL,GAAoBryB,UAAY,EAAI+e,EAAemE,gBAAgBkL,EAAiBnsB,KAAK2d,OAAQld,KAC5G,EACA,aAAMiwB,GACF,OAAON,GAAoBryB,gBAAmBiC,KAAKywB,oBAAoBhqB,YAC3E,EACA1I,QAAa,SACFqyB,GAAoBryB,SAAYuD,KAAKC,YAAaivB,EAAcE,aAE3E3yB,sBAA2B,SAChBqyB,GAAoBryB,UACvB,MAAM4c,EAAcla,EAAQ,gBAC5B,GAAIka,GAAahC,SAAS,uBACtB,OACJ,MAAMvX,QAAaovB,EAAcE,UACjC,OAAOtvB,EAAOyuB,EAAYtuB,MAAMH,QAAQ8E,CAAS,IAGzD,0BAAMyqB,GACF,OAAOP,GAAoBryB,UACvB,MAAM4c,EAAcla,EAAQ,gBAC5B,IAAKka,GAAahC,SAAS,uBACvB,OACJ,MAAMmC,EAAWH,EAAYhI,MAAM,sBAGnC,IAAKmI,EACD,OACJ,MAAM8V,GAAsB,EAAI9T,EAAemE,gBAAgBkL,EAAiBnsB,KAAK2d,OAAQld,IAC7F,OAAO6X,EAAU/W,MAAMqvB,EAAqB9V,EAAS,GAAG,GAEhE,EACA/c,YAAiB,SACNqyB,GAAoBryB,UAGvB,MAAM8yB,QAAsBL,EAAcG,uBAC1C,GAAIE,EAAe,CACf,MAAMlc,EAAW,CAAC,EAsBlB,OArBAkc,EAAcnwB,SAASya,IACnB,MAAMzR,EAAOyR,EAAKzR,KAClB,QAAaxD,IAATwD,OAKC,CAED,MAAMonB,EAAYnc,EAASjL,QACTxD,IAAd4qB,EACAnc,EAASjL,GAAQyR,EAAK3V,KAAKiB,WAEtBwI,MAAMC,QAAQ4hB,GACnBA,EAAUjd,KAAKsH,EAAK3V,KAAKiB,YAGzBkO,EAASjL,GAAQ,CAAConB,EAAW3V,EAAK3V,KAAKiB,WAE/C,KAEGkO,CACX,CAEI,OAAO6b,EAAcO,uBACzB,KAIZ,OAAOP,CAAa,EAOxBhzB,EAAQmuB,iBAJiB,CAAC9f,EAAK7N,KACF6N,EACN1K,KAAO4sB,EAAgBliB,EAAK7N,EAAQirB,SAAS,IAAMpd,EAAIpL,SAAQ,EA+BtF,MAAM6sB,EAA8BH,GAE5Ble,MAAMC,QAAQie,GACTle,MAAMC,QAAQie,EAAW,IAMnBA,GAJA,EAAI5iB,EAAekf,oBAAoB0D,IAS3C,EAAI5iB,EAAeQ,oBAAoBoiB,GAAc,CAAC,E,8BC/PrE7vB,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IACtDD,EAAQ0b,aAAe1b,EAAQwzB,iBAAmBxzB,EAAQ8b,uBAAyB9b,EAAQgc,sBAAwBhc,EAAQyzB,0BAA4BzzB,EAAQ6b,cAAgB7b,EAAQ+b,mBAAgB,EACvM,MAAMvY,EAAM,EAAQ,OACdxC,EAAI,EAAQ,MACZS,EAAS,EAAQ,OAKvBzB,EAAQ+b,cAFevY,GAAQA,EAAIsZ,cAAchP,WAAW,YACxDtK,EAAIsZ,cAAchP,WAAW,YAGjC9N,EAAQ6b,cADerY,GAAQA,EAAIsK,WAAW,KAG9C9N,EAAQyzB,0BAD2BjwB,KAAS,EAAIxD,EAAQ+b,eAAevY,MAAS,EAAIxD,EAAQ6b,eAAerY,GAK3GxD,EAAQgc,sBAHuBxY,GACpBA,EAAI+X,MAAM,MAAO,GAAGzK,OAAO,GAAGhO,KAAK,IAY9C9C,EAAQ8b,uBATwBtY,IAC5B,MAAMkwB,GAAY,EAAIjyB,EAAOkyB,YAAYnwB,EAAK,IAAK,GACnD,OAAmB,IAAfkwB,EACOlwB,EAAIsN,MAAM4iB,GAGV,EACX,EAcJ1zB,EAAQwzB,iBAXkBhwB,GAClBA,EAAIiF,KACG2pB,SAAS5uB,EAAIiF,KAAM,IAEJ,WAAjBjF,EAAI6U,UAA0C,SAAjB7U,EAAI6U,SAC/B,IAGA,GAUfrY,EAAQ0b,aAAe1a,EAAE4yB,SAASC,IAC9B,IAAIzY,EACA0Y,GAAiB,EACrB,IAEI,MAAMC,EAAaF,EAASzW,QAAQ,MAChB,IAAhB2W,IACAF,EAAWA,EAAS/iB,MAAM,EAAGijB,KAE7B,EAAI/zB,EAAQyzB,2BAA2BI,IACvCzY,EAAY5X,EAAIO,MAAM,UAAY8vB,GAClCC,GAAiB,GAGjB1Y,EAAY5X,EAAIO,MAAM8vB,UAGnBzY,EAAUhF,YACVgF,EAAUvT,aACVuT,EAAUI,cACVJ,EAAU4Y,KACb5Y,EAAU6Y,WACV7Y,EAAU6Y,SAAW7Y,EAAU6Y,SAASlvB,QAAQ,qBAAsBmvB,GAAYA,EAAQC,gBAAepvB,QAAQ,sBAAuBqvB,GAAgBC,mBAAmBD,MAE3KhZ,EAAU5E,UAAY4E,EAAU5E,SAAS8E,SAAS,OAClDF,EAAU5E,SAAW4E,EAAU5E,SAAS1F,MAAM,GAAI,KAE1B,WAAvBsK,EAAU/C,UAA4C,QAAnB+C,EAAU3S,MACtB,UAAvB2S,EAAU/C,UAA2C,OAAnB+C,EAAU3S,cACtC2S,EAAU3S,IAEzB,CACA,MAAO5F,GAGH,GAFAwC,QAAQM,IAAI,2BAA2BkuB,KACvCxuB,QAAQM,IAAI9C,IACPuY,EACD,OAAOyY,CAGf,CACA,IAAIS,EAAgB9wB,EAAIoe,OAAOxG,GAM/B,OAHI0Y,IACAQ,EAAgBA,EAAcxjB,MAAM,IAEjCwjB,CAAa,G,gEC5FxBx0B,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IACtDD,EAAQu0B,qBAAuBv0B,EAAQiC,OAASjC,EAAQw0B,MAAQx0B,EAAQy0B,cAAW,EACnFz0B,EAAQ2zB,WAGR,SAAoBzY,EAAOV,EAASpB,GAChC,IAAIsb,GAAS,EACb,KAAOtb,EAAI,IACPA,GAAQ,EACRsb,EAAQxZ,EAAMkC,QAAQ5C,EAASka,EAAQ,IACxB,IAAXA,KAGR,OAAOA,CACX,EAXA10B,EAAQ4kB,WAeR,SAAoB1J,GAChB,MAAqB,iBAAVA,EACAlb,EAAQiC,OACT0L,EAAOC,KAAKsN,EAAO,QAAQ0J,WAC3B,IAAI+P,KAAK,CAACzZ,IAAQ4E,KAGjB5E,EAAMxY,MAErB,EAvBA1C,EAAQwG,MAwBR,SAAemsB,GACX,OAAO,IAAI3sB,SAAS4uB,GAAMC,WAAWD,EAAGjC,IAC5C,EACA3yB,EAAQy0B,SAAwC,oBAAtBK,mBAAqCC,gBAAgBD,kBAC/E90B,EAAQw0B,MAA0B,oBAAXQ,QAA0BD,gBAAgBC,OACjEh1B,EAAQiC,QAAUjC,EAAQy0B,WAAaz0B,EAAQw0B,OAA4B,iBAAZS,GAAwBA,EAAQrW,QAK/F5e,EAAQu0B,qBAJqB,CAACzN,EAAKoO,IAAap1B,OAAOC,eAAe+mB,EAAKoO,EAAU,CACjFj1B,MAAO6mB,EAAIoO,GACXpL,UAAU,G,qCCpCd,IAAIqL,EAAY3yB,MAAQA,KAAK2yB,UAAa,WAStC,OARAA,EAAWr1B,OAAOwD,QAAU,SAASqvB,GACjC,IAAK,IAAIyC,EAAGjJ,EAAI,EAAG/S,EAAIK,UAAU/W,OAAQypB,EAAI/S,EAAG+S,IAE5C,IAAK,IAAIwF,KADTyD,EAAI3b,UAAU0S,GACOrsB,OAAOooB,UAAU6K,eAAepmB,KAAKyoB,EAAGzD,KACzDgB,EAAEhB,GAAKyD,EAAEzD,IAEjB,OAAOgB,CACX,EACOwC,EAASnF,MAAMxtB,KAAMiX,UAChC,EACI4b,EAAa7yB,MAAQA,KAAK6yB,WAAc,SAAUC,EAASC,EAAYC,EAAGC,GAE1E,OAAO,IAAKD,IAAMA,EAAIxvB,WAAU,SAAUC,EAASC,GAC/C,SAASwvB,EAAUz1B,GAAS,IAAM01B,EAAKF,EAAUvqB,KAAKjL,GAAS,CAAE,MAAO4C,GAAKqD,EAAOrD,EAAI,CAAE,CAC1F,SAAS+yB,EAAS31B,GAAS,IAAM01B,EAAKF,EAAiB,MAAEx1B,GAAS,CAAE,MAAO4C,GAAKqD,EAAOrD,EAAI,CAAE,CAC7F,SAAS8yB,EAAKptB,GAJlB,IAAetI,EAIasI,EAAOstB,KAAO5vB,EAAQsC,EAAOtI,QAJ1CA,EAIyDsI,EAAOtI,MAJhDA,aAAiBu1B,EAAIv1B,EAAQ,IAAIu1B,GAAE,SAAUvvB,GAAWA,EAAQhG,EAAQ,KAIjBmG,KAAKsvB,EAAWE,EAAW,CAC7GD,GAAMF,EAAYA,EAAUzF,MAAMsF,EAASC,GAAc,KAAKrqB,OAClE,GACJ,EACI4qB,EAAetzB,MAAQA,KAAKszB,aAAgB,SAAUR,EAAS3xB,GAC/D,IAAsGoyB,EAAGC,EAAGrD,EAAGsD,EAA3Gj1B,EAAI,CAAEk1B,MAAO,EAAGC,KAAM,WAAa,GAAW,EAAPxD,EAAE,GAAQ,MAAMA,EAAE,GAAI,OAAOA,EAAE,EAAI,EAAGyD,KAAM,GAAIC,IAAK,IAChG,OAAOJ,EAAI,CAAE/qB,KAAMorB,EAAK,GAAI,MAASA,EAAK,GAAI,OAAUA,EAAK,IAAwB,mBAAXvQ,SAA0BkQ,EAAElQ,OAAOwQ,UAAY,WAAa,OAAO/zB,IAAM,GAAIyzB,EACvJ,SAASK,EAAKld,GAAK,OAAO,SAAU3J,GAAK,OACzC,SAAc+mB,GACV,GAAIT,EAAG,MAAM,IAAIU,UAAU,mCAC3B,KAAOz1B,OACH,GAAI+0B,EAAI,EAAGC,IAAMrD,EAAY,EAAR6D,EAAG,GAASR,EAAU,OAAIQ,EAAG,GAAKR,EAAS,SAAOrD,EAAIqD,EAAU,SAAMrD,EAAEhmB,KAAKqpB,GAAI,GAAKA,EAAE9qB,SAAWynB,EAAIA,EAAEhmB,KAAKqpB,EAAGQ,EAAG,KAAKX,KAAM,OAAOlD,EAE3J,OADIqD,EAAI,EAAGrD,IAAG6D,EAAK,CAAS,EAARA,EAAG,GAAQ7D,EAAE1yB,QACzBu2B,EAAG,IACP,KAAK,EAAG,KAAK,EAAG7D,EAAI6D,EAAI,MACxB,KAAK,EAAc,OAAXx1B,EAAEk1B,QAAgB,CAAEj2B,MAAOu2B,EAAG,GAAIX,MAAM,GAChD,KAAK,EAAG70B,EAAEk1B,QAASF,EAAIQ,EAAG,GAAIA,EAAK,CAAC,GAAI,SACxC,KAAK,EAAGA,EAAKx1B,EAAEq1B,IAAIK,MAAO11B,EAAEo1B,KAAKM,MAAO,SACxC,QACI,MAAkB/D,GAAZA,EAAI3xB,EAAEo1B,MAAY1zB,OAAS,GAAKiwB,EAAEA,EAAEjwB,OAAS,KAAkB,IAAV8zB,EAAG,IAAsB,IAAVA,EAAG,IAAW,CAAEx1B,EAAI,EAAG,QAAU,CAC3G,GAAc,IAAVw1B,EAAG,MAAc7D,GAAM6D,EAAG,GAAK7D,EAAE,IAAM6D,EAAG,GAAK7D,EAAE,IAAM,CAAE3xB,EAAEk1B,MAAQM,EAAG,GAAI,KAAO,CACrF,GAAc,IAAVA,EAAG,IAAYx1B,EAAEk1B,MAAQvD,EAAE,GAAI,CAAE3xB,EAAEk1B,MAAQvD,EAAE,GAAIA,EAAI6D,EAAI,KAAO,CACpE,GAAI7D,GAAK3xB,EAAEk1B,MAAQvD,EAAE,GAAI,CAAE3xB,EAAEk1B,MAAQvD,EAAE,GAAI3xB,EAAEq1B,IAAIhgB,KAAKmgB,GAAK,KAAO,CAC9D7D,EAAE,IAAI3xB,EAAEq1B,IAAIK,MAChB11B,EAAEo1B,KAAKM,MAAO,SAEtBF,EAAK7yB,EAAKgJ,KAAK2oB,EAASt0B,EAC5B,CAAE,MAAO6B,GAAK2zB,EAAK,CAAC,EAAG3zB,GAAImzB,EAAI,CAAG,CAAE,QAAUD,EAAIpD,EAAI,CAAG,CACzD,GAAY,EAAR6D,EAAG,GAAQ,MAAMA,EAAG,GAAI,MAAO,CAAEv2B,MAAOu2B,EAAG,GAAKA,EAAG,QAAK,EAAQX,MAAM,EAC9E,CAtBgDF,CAAK,CAACvc,EAAG3J,GAAK,CAAG,CAuBrE,EACIknB,EAAiBn0B,MAAQA,KAAKm0B,eAAkB,SAAUC,EAAIhpB,EAAMipB,GACpE,GAAIA,GAA6B,IAArBpd,UAAU/W,OAAc,IAAK,IAA4Bo0B,EAAxB3K,EAAI,EAAG4K,EAAInpB,EAAKlL,OAAYypB,EAAI4K,EAAG5K,KACxE2K,GAAQ3K,KAAKve,IACRkpB,IAAIA,EAAKrlB,MAAMyW,UAAUpX,MAAMnE,KAAKiB,EAAM,EAAGue,IAClD2K,EAAG3K,GAAKve,EAAKue,IAGrB,OAAOyK,EAAGzL,OAAO2L,GAAMrlB,MAAMyW,UAAUpX,MAAMnE,KAAKiB,GACtD,EACA9N,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IACtDD,EAAQoH,wBAAqB,EAC7B,IAAI4vB,OAA4B,IAAX,EAAAf,EAAyB,EAAAA,EAA4B,oBAAXgB,OAAyBA,OAAS,CAAC,EAC9FC,EAAkBF,EAAQ31B,WAAa21B,EAAQG,aAC/CC,EAAU,EAAQ,OAClBC,EAAkB,EAAQ,OAC1BC,EAAc,EAAQ,OACtBC,EAAc,EAAQ,MACtBC,EAAY,EAAQ,OACpBC,EAAoB,EAAQ,OAC5BC,EAAsB,EAAQ,MAC9BC,EAAa,EAAQ,OACrBC,EAAa,EAAQ,OACrBC,EAAkB,EAAQ,OAC1BzwB,EAAsB,WACtB,SAASA,EAAmB5D,EAAKhD,EAASs3B,EAAeC,GACrD,IAAIC,EAAMx3B,GAAW,CAAC,EAAIy3B,EAAKD,EAAGE,mBAAoBA,OAA4B,IAAPD,OAAgBvvB,EAAYuvB,EAAIE,EAAKH,EAAGI,iBAAkBA,OAA0B,IAAPD,EAAgB,CAAC,EAAIA,EAAIE,EAAKL,EAAGM,WAAYA,OAAoB,IAAPD,EAAgBT,EAAWW,eAAiBF,EAAIG,EAAKR,EAAGS,QAASA,OAAiB,IAAPD,EAAgBZ,EAAWc,WAAaF,EAAIG,EAAKX,EAAG1wB,UAAWA,OAAmB,IAAPqxB,GAAwBA,EAAIC,EAAKZ,EAAGzwB,qBAAsBA,OAA8B,IAAPqxB,EAAgB9e,IAAW8e,EAAIC,EAAKb,EAAG3wB,KAAMA,OAAc,IAAPwxB,GAAwBA,EAAIC,EAAKd,EAAGe,kBAAmBA,OAA2B,IAAPD,EAAgB,EAAIA,EAAIE,EAAKhB,EAAGxwB,kBAAmBA,OAA2B,IAAPwxB,EAAgB,GAAKA,EAEppB,GADAx2B,KAAKy2B,OAASnB,GAAiBZ,GAC1B10B,KAAKy2B,OACN,MAAM,IAAIrxB,MAAM,sFAEpBpF,KAAK02B,YAAcnB,GAAsBJ,EAAWwB,WACpD32B,KAAK01B,mBAAqBA,EAC1B11B,KAAKgB,IAAMA,EACXhB,KAAK42B,WAAa,CAAC,EACnB52B,KAAK62B,gBAAkB,EACvB72B,KAAK82B,aAAehB,EACpB91B,KAAK+2B,UAAYd,EACjBj2B,KAAKg3B,oBAAsB,GAC3Bh3B,KAAK8E,UAAYA,EACjB9E,KAAKi3B,cAAe,EACpBj3B,KAAK+E,qBAAuBA,EAC5B/E,KAAK6E,OAASA,EACd7E,KAAKu2B,kBAAoBA,EACzBv2B,KAAKk3B,cAAe,EACpBl3B,KAAKm3B,QAAU,IAAIvC,EAAQ,CAAEwC,OAAQ,KACrCp3B,KAAKq3B,aAAe,IAAIxC,EAAgBnzB,aACxC1B,KAAKs3B,YAAc,GACnBt3B,KAAKwI,OAAS,KACdxI,KAAKu3B,wBAA0Bv3B,KAAKw3B,gCACpCx3B,KAAK41B,iBAAmB51B,KAAKy3B,oBAAoB7B,GACjD51B,KAAKgF,kBAAoBA,EACpBhF,KAAK6E,MACN7E,KAAK03B,SAEb,CAwcA,OAvcAp6B,OAAOC,eAAeqH,EAAmB8gB,UAAW,SAAU,CAC1DnW,IAAK,WACD,OAAoB,OAAhBvP,KAAKwI,OACExI,KAAKy2B,OAAOkB,OAEhB33B,KAAKwI,OAAOovB,UACvB,EACAtoB,YAAY,EACZuoB,cAAc,IAElBjzB,EAAmB8gB,UAAUle,MAAQ,SAAUswB,EAAUZ,QACpC,IAAbY,IAAuBA,GAAW,QACjB,IAAjBZ,IAA2BA,GAAe,GAC9Cl3B,KAAK+3B,yBACe,OAAhB/3B,KAAKwI,SACLxI,KAAKk3B,aAAeA,EAChBY,IACA93B,KAAKg4B,+BACLh4B,KAAKi4B,yBACLj4B,KAAKk4B,2BACLl4B,KAAKm4B,iBACLn4B,KAAKo4B,iBAAYlyB,EAAWmvB,EAAgB1pB,QAAQ0sB,yBAA0B,OAElFr4B,KAAKwI,OAAOhB,QACZxH,KAAKwI,OAAO8vB,OAAS,KACrBt4B,KAAKwI,OAAO+vB,QAAU,KACtBv4B,KAAKwI,OAAOgwB,UAAY,KACxBx4B,KAAKwI,OAAOiwB,QAAU,WAAc,EACpCz4B,KAAKwI,OAAS,KACdxI,KAAKq3B,aAAat0B,KAAK,gBAClB+0B,GACD93B,KAAK04B,eAGjB,EACA9zB,EAAmB8gB,UAAUjd,QAAU,SAAUA,GAC7C,IAAI+sB,EAIAmD,EAHAC,EAAc54B,KAAK44B,YAAYC,KAAK74B,MACpC84B,EAAmB94B,KAAK84B,iBAAiBD,KAAK74B,MAC9C+4B,EAAc/4B,KAAK+4B,YAAYF,KAAK74B,MAGxC,OADAA,KAAK+3B,0BACEvC,EAAK,CAAC,GACNN,EAAoBvpB,SAAW,WAC9B,OAAO3L,IACX,EACAw1B,EAAGttB,UAAY,SAAU8wB,EAAgB/zB,EAASg0B,GAC9C,IAAIC,EAAWN,EAAYI,EAAgB/zB,EAASg0B,GAkBpD,OAjBAN,EAAOG,EAAiBrwB,GAAS,SAAUjH,EAAOuE,GAChC,OAAVvE,GAA6B,OAAXuE,EACdmzB,EAASC,UACTD,EAASC,WAGR33B,EACD03B,EAAS13B,OACT03B,EAAS13B,MAAMA,EAAM,IAIrB03B,EAASxwB,MACTwwB,EAASxwB,KAAK3C,EAG1B,IACO,CACHgzB,YAAa,WACLJ,IACAI,EAAYJ,GACZA,EAAO,KAEf,EAER,EACAnD,CACR,EACA5wB,EAAmB8gB,UAAUhjB,GAAK,SAAU02B,EAAWjxB,EAAUkxB,GAC7D,IAAIrX,EAAUhiB,KAAKq3B,aAAa30B,GAAG02B,EAAWjxB,EAAUkxB,GACxD,OAAO,WACHrX,EAAQsX,IAAIF,EAAWjxB,EAAUkxB,EACrC,CACJ,EACAz0B,EAAmB8gB,UAAU/c,YAAc,SAAUR,EAAUkxB,GAC3D,OAAOr5B,KAAK0C,GAAG,YAAayF,EAAUkxB,EAC1C,EACAz0B,EAAmB8gB,UAAU6T,aAAe,SAAUpxB,EAAUkxB,GAC5D,OAAOr5B,KAAK0C,GAAG,aAAcyF,EAAUkxB,EAC3C,EACAz0B,EAAmB8gB,UAAU9c,eAAiB,SAAUT,EAAUkxB,GAC9D,OAAOr5B,KAAK0C,GAAG,eAAgByF,EAAUkxB,EAC7C,EACAz0B,EAAmB8gB,UAAU8T,cAAgB,SAAUrxB,EAAUkxB,GAC7D,OAAOr5B,KAAK0C,GAAG,cAAeyF,EAAUkxB,EAC5C,EACAz0B,EAAmB8gB,UAAUxgB,eAAiB,SAAUiD,EAAUkxB,GAC9D,OAAOr5B,KAAK0C,GAAG,eAAgByF,EAAUkxB,EAC7C,EACAz0B,EAAmB8gB,UAAUzgB,QAAU,SAAUkD,EAAUkxB,GACvD,OAAOr5B,KAAK0C,GAAG,QAASyF,EAAUkxB,EACtC,EACAz0B,EAAmB8gB,UAAUyS,eAAiB,WAC1C,IAAIsB,EAAQz5B,KACZ1C,OAAO+f,KAAKrd,KAAK42B,YAAYl2B,SAAQ,SAAUg5B,GAC3CD,EAAMV,YAAYW,EACtB,GACJ,EACA90B,EAAmB8gB,UAAUiU,iBAAmB,SAAU37B,GACtD,IAAIy7B,EAAQz5B,KACZ,OAAO,IAAIwD,SAAQ,SAAUC,EAASC,GAClC,IAAsBk2B,EAAOC,EACrBnxB,EADckxB,EAmBhBzF,EAAc,GAAIsF,EAAMnC,aAAa,GAnBduC,EAmBqBJ,GAlB1C/wB,EAAO,SAAUlH,GACjB,GAAIA,EACAkC,EAAOlC,QAGP,GAAIo4B,EAAM15B,OAAS,EAAG,CAClB,IAAIqzB,EAAIqG,EAAME,QACVvG,GACAA,EAAEwG,gBAAgBvM,MAAMqM,EAAO,CAAC77B,EAAS0K,GAEjD,MAEIjF,EAAQzF,EAGpB,IAIR,GACJ,EACA4G,EAAmB8gB,UAAUsU,IAAM,SAAU1C,GACzC,IAAImC,EAAQz5B,KASZ,OARAs3B,EAAYl3B,KAAI,SAAU65B,GACtB,GAA0C,mBAA/BA,EAAWF,gBAIlB,MAAM,IAAI30B,MAAM,2DAHhBq0B,EAAMnC,YAAYzjB,KAAKomB,EAK/B,IACOj6B,IACX,EACA4E,EAAmB8gB,UAAU+R,oBAAsB,SAAU7B,GACzD,OAAO,WAAc,OAAO,IAAIpyB,SAAQ,SAAUC,EAASC,GACvD,GAAgC,mBAArBkyB,EACP,IACI,OAAOnyB,EAAQmyB,EAAiBzrB,KAAK,MACzC,CACA,MAAO3I,GACH,OAAOkC,EAAOlC,EAClB,CAEJiC,EAAQmyB,EACZ,GAAI,CACR,EACAhxB,EAAmB8gB,UAAUoT,iBAAmB,SAAU96B,EAASgkB,GAC/D,IAAIyX,EAAQz5B,KACQ,OAAhBA,KAAKwI,QACLxI,KAAK03B,UAET,IAAIiB,EAAO34B,KAAKk6B,sBAchB,OAbAl6B,KAAK42B,WAAW+B,GAAQ,CAAE36B,QAASA,EAASgkB,QAASA,GACrDhiB,KAAK25B,iBAAiB37B,GACjB4F,MAAK,SAAUu2B,GAChBV,EAAMW,sBAAsBD,EAAkBnY,GAC1CyX,EAAM7C,WAAW+B,KACjBc,EAAM7C,WAAW+B,GAAQ,CAAE36B,QAASm8B,EAAkBnY,QAASA,GAC/DyX,EAAMrB,YAAYO,EAAMtD,EAAgB1pB,QAAQ0uB,UAAWF,GAEnE,IACKt2B,OAAM,SAAUrC,GACjBi4B,EAAMV,YAAYJ,GAClB3W,EAAQyX,EAAMa,aAAa94B,GAC/B,IACOm3B,CACX,EACA/zB,EAAmB8gB,UAAUkT,YAAc,SAAUI,EAAgBx3B,EAAO23B,GACxE,MAA8B,mBAAnBH,EACA,CACHtwB,KAAM,SAAUuE,GAAK,OAAO+rB,EAAe/rB,EAAI,EAC/CzL,MAAO,SAAUnB,GAAK,OAAOmB,GAASA,EAAMnB,EAAI,EAChD84B,SAAU,WAAc,OAAOA,GAAYA,GAAY,GAGxDH,CACX,EACAp0B,EAAmB8gB,UAAU8R,8BAAgC,WACzD,IAAI+C,EAAWv6B,KAAK82B,aAChB0D,EAAWx6B,KAAK+2B,UACpB,OAAO,IAAInC,EAAQ,CACf6F,IAAKF,EACLG,IAAKF,EACLG,OAAQ,KAEhB,EACA/1B,EAAmB8gB,UAAUsS,6BAA+B,WACpDh4B,KAAK46B,4BACLC,cAAc76B,KAAK46B,2BACnB56B,KAAK46B,0BAA4B,KAEzC,EACAh2B,EAAmB8gB,UAAUuS,uBAAyB,WAC9Cj4B,KAAK86B,sBACLC,aAAa/6B,KAAK86B,qBAClB96B,KAAK86B,oBAAsB,KAEnC,EACAl2B,EAAmB8gB,UAAUwS,yBAA2B,WAChDl4B,KAAKg7B,wBACLD,aAAa/6B,KAAKg7B,uBAClBh7B,KAAKg7B,sBAAwB,KAErC,EACAp2B,EAAmB8gB,UAAUqS,uBAAyB,WAC9C/3B,KAAKi7B,sBACLF,aAAa/6B,KAAKi7B,qBAClBj7B,KAAKi7B,oBAAsB,KAEnC,EACAr2B,EAAmB8gB,UAAUwV,qBAAuB,WAChD,IAAIzB,EAAQz5B,KACRA,KAAKu2B,kBAAoB,GAA6C,IAAxCj5B,OAAO+f,KAAKrd,KAAK42B,YAAY12B,SAC3DF,KAAKi7B,oBAAsB5I,YAAW,WACW,IAAzC/0B,OAAO+f,KAAKoc,EAAM7C,YAAY12B,QAC9Bu5B,EAAMjyB,OAEd,GAAGxH,KAAKu2B,mBAEhB,EACA3xB,EAAmB8gB,UAAU0U,sBAAwB,SAAUp8B,EAASgkB,GACpE,IAAI3c,EAAQrH,EAAQqH,MAAOC,EAAYtH,EAAQsH,UAAW61B,EAAgBn9B,EAAQm9B,cAClF,IAAK91B,EACD,MAAM,IAAID,MAAM,yBAEpB,IAAK4c,EACD,MAAM,IAAI5c,MAAM,4BAEpB,KAAM,EAAI0vB,EAAYnpB,SAAStG,MAAW,EAAI4vB,EAAkBmG,iBAAiB/1B,EAAO81B,IACnFA,KAAkB,EAAIrG,EAAYnpB,SAASwvB,IAC3C71B,KAAc,EAAIyvB,EAAYppB,SAASrG,GACxC,MAAM,IAAIF,MAAM,oIAGxB,EACAR,EAAmB8gB,UAAU2V,aAAe,SAAU70B,EAAIqI,EAAMysB,GAG5D,MAAO,CACH90B,GAAIA,EACJqI,KAAMA,EACNysB,QALkBA,GAAWA,EAAQj2B,MAAQstB,EAASA,EAAS,CAAC,EAAG2I,GAAU,CAAEj2B,MAAgC,iBAAlBi2B,EAAQj2B,MAAqBi2B,EAAQj2B,OAAQ,EAAI2vB,EAAUjtB,OAAOuzB,EAAQj2B,SACvKi2B,EAMR,EACA12B,EAAmB8gB,UAAU4U,aAAe,SAAUr6B,GAClD,OAAIgP,MAAMC,QAAQjP,GACPA,EAEPA,GAAUA,EAAOA,OACVD,KAAKs6B,aAAar6B,EAAOA,QAEhCA,GAAUA,EAAOJ,QACV,CAACI,GAEL,CAAC,CACAyJ,KAAM,gBACN7J,QAAS,gBACT07B,cAAet7B,GAE3B,EACA2E,EAAmB8gB,UAAU0S,YAAc,SAAU5xB,EAAIqI,EAAMysB,GAC3Dt7B,KAAKw7B,eAAex7B,KAAKq7B,aAAa70B,EAAIqI,EAAMysB,GACpD,EACA12B,EAAmB8gB,UAAU8V,eAAiB,SAAU37B,GACpD,OAAQG,KAAKG,QACT,KAAKH,KAAKy2B,OAAOgF,KACb,IAAIC,EAAoBp6B,KAAKiE,UAAU1F,GACvC,IACIyB,KAAKC,MAAMm6B,EACf,CACA,MAAOr7B,GACHL,KAAKq3B,aAAat0B,KAAK,QAAS,IAAIqC,MAAM,2CAA2CujB,OAAO9oB,IAChG,CACAG,KAAKwI,OAAOmzB,KAAKD,GACjB,MACJ,KAAK17B,KAAKy2B,OAAOmF,WACb57B,KAAKg3B,oBAAoBnjB,KAAKhU,GAC9B,MACJ,QACSG,KAAKi3B,cACNj3B,KAAKq3B,aAAat0B,KAAK,QAAS,IAAIqC,MAAM,yGACD9D,KAAKiE,UAAU1F,KAGxE,EACA+E,EAAmB8gB,UAAUwU,oBAAsB,WAC/C,OAAO2B,SAAS77B,KAAK62B,gBACzB,EACAjyB,EAAmB8gB,UAAUgT,aAAe,WACxC,IAAIe,EAAQz5B,KACZ,GAAKA,KAAK8E,aAAa9E,KAAKm3B,QAAQ2E,UAAY97B,KAAK+E,sBAArD,CAGK/E,KAAKi3B,eACN35B,OAAO+f,KAAKrd,KAAK42B,YAAYl2B,SAAQ,SAAUC,GAC3C84B,EAAMzC,oBAAoBnjB,KAAK4lB,EAAM4B,aAAa16B,EAAK00B,EAAgB1pB,QAAQ0uB,UAAWZ,EAAM7C,WAAWj2B,GAAK3C,SACpH,IACAgC,KAAKi3B,cAAe,GAExBj3B,KAAKk4B,2BACL,IAAIl0B,EAAQhE,KAAKm3B,QAAQ4E,WACzB/7B,KAAKg7B,sBAAwB3I,YAAW,WACpCoH,EAAM/B,SACV,GAAG1zB,EAXH,CAYJ,EACAY,EAAmB8gB,UAAUsW,yBAA2B,WACpD,IAAIvC,EAAQz5B,KACZA,KAAKg3B,oBAAoBt2B,SAAQ,SAAUb,GACvC45B,EAAM+B,eAAe37B,EACzB,IACAG,KAAKg3B,oBAAsB,EAC/B,EACApyB,EAAmB8gB,UAAUuW,gBAAkB,WACvCj8B,KAAKk8B,qBACLl8B,KAAKk8B,sBAAuB,EAG3Bl8B,KAAKi3B,cACNj3B,KAAKwH,OAAM,GAAO,EAE1B,EACA5C,EAAmB8gB,UAAUyW,uBAAyB,WAClD,IAAI1C,EAAQz5B,KACZA,KAAKi4B,yBACLj4B,KAAK86B,oBAAsBzI,YAAW,WAC9BoH,EAAMt5B,SAAWs5B,EAAMhD,OAAOgF,OAC9BhC,EAAMxC,cAAe,EACrBwC,EAAMjyB,OAAM,GAAO,GAE3B,GAAGxH,KAAKu3B,wBAAwBwE,WACpC,EACAn3B,EAAmB8gB,UAAUgS,QAAU,WACnC,IAAIlC,EACAiE,EAAQz5B,KACZA,KAAKwI,OAAS,KAAMgtB,EAAKx1B,KAAKy2B,QAAQoC,KAAKrL,MAAMgI,EAAIrB,EAAc,MAAC,EAAQn0B,KAAKgB,IAAKhB,KAAK02B,aAAc12B,KAAKgF,mBAAmB,KACjIhF,KAAKm8B,yBACLn8B,KAAKwI,OAAO8vB,OAAS,WAAc,OAAOzF,EAAU4G,OAAO,OAAQ,GAAQ,WACvE,IAAI7D,EAAkB12B,EACtB,OAAOo0B,EAAYtzB,MAAM,SAAUw1B,GAC/B,OAAQA,EAAG9B,OACP,KAAK,EACD,GAAM1zB,KAAKG,SAAWH,KAAKy2B,OAAOgF,KAAO,MAAO,CAAC,EAAG,GACpDz7B,KAAKi4B,yBACLj4B,KAAKk3B,cAAe,EACpBl3B,KAAKq3B,aAAat0B,KAAK/C,KAAKi3B,aAAe,eAAiB,cAC5DzB,EAAG9B,MAAQ,EACf,KAAK,EAED,OADA8B,EAAG5B,KAAK/f,KAAK,CAAC,EAAG,EAAG,CAAE,IACf,CAAC,EAAG7T,KAAK41B,oBACpB,KAAK,EAID,OAHAA,EAAmBJ,EAAG7B,OACtB3zB,KAAKo4B,iBAAYlyB,EAAWmvB,EAAgB1pB,QAAQywB,oBAAqBxG,GACzE51B,KAAKg8B,2BACE,CAAC,EAAG,GACf,KAAK,EAID,OAHA98B,EAAUs2B,EAAG7B,OACb3zB,KAAKo4B,iBAAYlyB,EAAWmvB,EAAgB1pB,QAAQ0wB,qBAAsBn9B,GAC1Ec,KAAKg8B,2BACE,CAAC,EAAG,GACf,KAAK,EAAG,MAAO,CAAC,GAExB,GACJ,GAAI,EACJh8B,KAAKwI,OAAO+vB,QAAU,WACbkB,EAAMvC,cACPuC,EAAMjyB,OAAM,GAAO,EAE3B,EACAxH,KAAKwI,OAAOiwB,QAAU,SAAU30B,GAC5B21B,EAAMpC,aAAat0B,KAAK,QAASe,EACrC,EACA9D,KAAKwI,OAAOgwB,UAAY,SAAUhD,GAC9B,IAAIhwB,EAAOgwB,EAAGhwB,KACdi0B,EAAM6C,oBAAoB92B,EAAKiB,WACnC,CACJ,EACA7B,EAAmB8gB,UAAU4W,oBAAsB,SAAUC,GACzD,IAAIC,EACA7D,EACJ,IAEIA,GADA6D,EAAgBl7B,KAAKC,MAAMg7B,IACN/1B,EACzB,CACA,MAAOnG,GACH,MAAM,IAAI+E,MAAM,wCAAwCujB,OAAO4T,GACnE,CACA,IAGmC,IAH/B,CAAClH,EAAgB1pB,QAAQ8wB,SACzBpH,EAAgB1pB,QAAQ+wB,aACxBrH,EAAgB1pB,QAAQgxB,WAC1B/hB,QAAQ4hB,EAAc3tB,OAAiB7O,KAAK42B,WAAW+B,GAIzD,OAAQ6D,EAAc3tB,MAClB,KAAKwmB,EAAgB1pB,QAAQ0wB,qBACrBr8B,KAAK01B,oBACL11B,KAAK01B,mBAAmB8G,EAAclB,SAE1C,MACJ,KAAKjG,EAAgB1pB,QAAQixB,mBACzB58B,KAAKq3B,aAAat0B,KAAK/C,KAAKi3B,aAAe,cAAgB,YAAauF,EAAclB,SACtFt7B,KAAKi3B,cAAe,EACpBj3B,KAAKm3B,QAAQp1B,QACb/B,KAAKu3B,wBAAwBx1B,QACzB/B,KAAK01B,oBACL11B,KAAK01B,qBAET,MACJ,KAAKL,EAAgB1pB,QAAQ+wB,aACzB,IAAI1a,EAAUhiB,KAAK42B,WAAW+B,GAAM3W,eAC7BhiB,KAAK42B,WAAW+B,GACvB3W,EAAQ7X,KAAKnK,KAAM,KAAM,MACzB,MACJ,KAAKq1B,EAAgB1pB,QAAQgxB,UACzB38B,KAAK42B,WAAW+B,GAAM3W,QAAQhiB,KAAKs6B,aAAakC,EAAclB,SAAU,aACjEt7B,KAAK42B,WAAW+B,GACvB,MACJ,KAAKtD,EAAgB1pB,QAAQ8wB,SACzB,IAAII,EAAiBL,EAAclB,QAAQr7B,OACf0yB,EAASA,EAAS,CAAC,EAAG6J,EAAclB,SAAU,CAAEr7B,OAAQD,KAAKs6B,aAAakC,EAAclB,QAAQr7B,UAAxHu8B,EAAclB,QAClBt7B,KAAK42B,WAAW+B,GAAM3W,QAAQ,KAAM6a,GACpC,MACJ,KAAKxH,EAAgB1pB,QAAQmxB,0BACzB,IAAIC,OAA+C,IAA9B/8B,KAAKk8B,qBAC1Bl8B,KAAKk8B,sBAAuB,EACxBa,GACA/8B,KAAKi8B,kBAELj8B,KAAK46B,4BACLC,cAAc76B,KAAK46B,2BACnB56B,KAAKi8B,mBAETj8B,KAAK46B,0BAA4BoC,YAAYh9B,KAAKi8B,gBAAgBpD,KAAK74B,MAAOA,KAAK+2B,WACnF,MACJ,QACI,MAAM,IAAI3xB,MAAM,8BA7CpBpF,KAAK+4B,YAAYJ,EA+CzB,EACA/zB,EAAmB8gB,UAAUqT,YAAc,SAAUJ,GAC7C34B,KAAK42B,WAAW+B,YACT34B,KAAK42B,WAAW+B,GACvB34B,KAAKk7B,uBACLl7B,KAAKo4B,YAAYO,EAAMtD,EAAgB1pB,QAAQsxB,cAAU/2B,GAEjE,EACOtB,CACX,CAxeyB,GAyezBpH,EAAQoH,mBAAqBA,C,6BC/iB7BtH,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IACtDD,EAAQ04B,WAAa14B,EAAQu4B,oBAAiB,EAE9Cv4B,EAAQu4B,eADa,IAGrBv4B,EAAQ04B,WADS,G,6BCJjB54B,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IACtD,IAAIy/B,EAAgB,WAChB,SAASA,IACL,MAAM,IAAI93B,MAAM,eACpB,CAoBA,OAnBA83B,EAAad,oBAAsB,kBACnCc,EAAaN,mBAAqB,iBAClCM,EAAab,qBAAuB,mBACpCa,EAAaJ,0BAA4B,KACzCI,EAAa7E,yBAA2B,uBACxC6E,EAAa7C,UAAY,QACzB6C,EAAaT,SAAW,OACxBS,EAAaP,UAAY,QACzBO,EAAaR,aAAe,WAC5BQ,EAAaD,SAAW,OACxBC,EAAaC,mBAAqB,qBAClCD,EAAaE,kBAAoB,oBACjCF,EAAaG,qBAAuB,uBACpCH,EAAaI,kBAAoB,oBACjCJ,EAAaK,iBAAmB,mBAChCL,EAAaM,KAAO,OACpBN,EAAaO,aAAe,eAC5BP,EAAaQ,UAAY,YACzBR,EAAaS,WAAa,YACnBT,CACX,CAxBmB,GAyBnB1/B,EAAA,QAAkB0/B,C,6BC1BlB5/B,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IACtDD,EAAQogC,sBAAwBpgC,EAAQm5B,gBAAa,EAErDn5B,EAAQm5B,WADS,aAGjBn5B,EAAQogC,sBADoB,uB,4BCJ5BtgC,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IAItDD,EAAA,QAHA,SAAkBC,GACd,OAAmB,OAAVA,GAAqC,iBAAVA,CACxC,C,6BCHAH,OAAOC,eAAeC,EAAS,aAAc,CAAEC,OAAO,IAItDD,EAAA,QAHA,SAAkBC,GACd,MAAwB,iBAAVA,CAClB,C,iBCGA,WACE,aAMA,IAJA,IAAIogC,EAAQ,mEAGRpZ,EAAS,IAAIqZ,WAAW,KACnBnU,EAAI,EAAGA,EAAIkU,GAAclU,IAChClF,EAAOoZ,EAAME,WAAWpU,IAAMA,EAGhCnsB,EAAQihB,OAAS,SAASuf,GACxB,IACArU,EADIsU,EAAQ,IAAIH,WAAWE,GACxBE,EAAMD,EAAM/9B,OAAQi+B,EAAS,GAEhC,IAAKxU,EAAI,EAAGA,EAAIuU,EAAKvU,GAAG,EACtBwU,GAAUN,EAAMI,EAAMtU,IAAM,GAC5BwU,GAAUN,GAAmB,EAAXI,EAAMtU,KAAW,EAAMsU,EAAMtU,EAAI,IAAM,GACzDwU,GAAUN,GAAuB,GAAfI,EAAMtU,EAAI,KAAY,EAAMsU,EAAMtU,EAAI,IAAM,GAC9DwU,GAAUN,EAAqB,GAAfI,EAAMtU,EAAI,IAS5B,OANKuU,EAAM,GAAO,EAChBC,EAASA,EAAOC,UAAU,EAAGD,EAAOj+B,OAAS,GAAK,IACzCg+B,EAAM,GAAM,IACrBC,EAASA,EAAOC,UAAU,EAAGD,EAAOj+B,OAAS,GAAK,MAG7Ci+B,CACT,EAEA3gC,EAAQ6gC,OAAU,SAASF,GACzB,IACqBxU,EACrB2U,EAAUC,EAAUC,EAAUC,EAF1BC,EAA+B,IAAhBP,EAAOj+B,OAC1Bg+B,EAAMC,EAAOj+B,OAAWivB,EAAI,EAGM,MAA9BgP,EAAOA,EAAOj+B,OAAS,KACzBw+B,IACkC,MAA9BP,EAAOA,EAAOj+B,OAAS,IACzBw+B,KAIJ,IAAIV,EAAc,IAAIW,YAAYD,GAClCT,EAAQ,IAAIH,WAAWE,GAEvB,IAAKrU,EAAI,EAAGA,EAAIuU,EAAKvU,GAAG,EACtB2U,EAAW7Z,EAAO0Z,EAAOJ,WAAWpU,IACpC4U,EAAW9Z,EAAO0Z,EAAOJ,WAAWpU,EAAE,IACtC6U,EAAW/Z,EAAO0Z,EAAOJ,WAAWpU,EAAE,IACtC8U,EAAWha,EAAO0Z,EAAOJ,WAAWpU,EAAE,IAEtCsU,EAAM9O,KAAQmP,GAAY,EAAMC,GAAY,EAC5CN,EAAM9O,MAAoB,GAAXoP,IAAkB,EAAMC,GAAY,EACnDP,EAAM9O,MAAoB,EAAXqP,IAAiB,EAAiB,GAAXC,EAGxC,OAAOT,CACT,CACD,CA3DD,E,oeCPA,8C,8ECkCA,QAAe,YAhCf,SAAeY,GACb,KAAK,OAASA,GACZ,MAAM3K,UAAU,gBAGlB,IAAIhnB,EACA4xB,EAAM,IAAIf,WAAW,IAuBzB,OArBAe,EAAI,IAAM5xB,EAAI2iB,SAASgP,EAAKtwB,MAAM,EAAG,GAAI,OAAS,GAClDuwB,EAAI,GAAK5xB,IAAM,GAAK,IACpB4xB,EAAI,GAAK5xB,IAAM,EAAI,IACnB4xB,EAAI,GAAS,IAAJ5xB,EAET4xB,EAAI,IAAM5xB,EAAI2iB,SAASgP,EAAKtwB,MAAM,EAAG,IAAK,OAAS,EACnDuwB,EAAI,GAAS,IAAJ5xB,EAET4xB,EAAI,IAAM5xB,EAAI2iB,SAASgP,EAAKtwB,MAAM,GAAI,IAAK,OAAS,EACpDuwB,EAAI,GAAS,IAAJ5xB,EAET4xB,EAAI,IAAM5xB,EAAI2iB,SAASgP,EAAKtwB,MAAM,GAAI,IAAK,OAAS,EACpDuwB,EAAI,GAAS,IAAJ5xB,EAGT4xB,EAAI,KAAO5xB,EAAI2iB,SAASgP,EAAKtwB,MAAM,GAAI,IAAK,KAAO,cAAgB,IACnEuwB,EAAI,IAAM5xB,EAAI,WAAc,IAC5B4xB,EAAI,IAAM5xB,IAAM,GAAK,IACrB4xB,EAAI,IAAM5xB,IAAM,GAAK,IACrB4xB,EAAI,IAAM5xB,IAAM,EAAI,IACpB4xB,EAAI,IAAU,IAAJ5xB,EACH4xB,CACT,EAEoB,I,gDClCpB,6H,+BCGA,IAAIC,E,iBACJ,IAAIC,EAAQ,IAAIjB,WAAW,IACZ,SAASkB,IAEtB,IAAKF,KAGHA,EAAoC,oBAAXG,QAA0BA,OAAOH,iBAAmBG,OAAOH,gBAAgBjG,KAAKoG,SAA+B,oBAAbC,UAAgE,mBAA7BA,SAASJ,iBAAkCI,SAASJ,gBAAgBjG,KAAKqG,WAGrO,MAAM,IAAI95B,MAAM,4GAIpB,OAAO05B,EAAgBC,EACzB,C,8ECVA,IAFA,IAAII,EAAY,GAEPxV,EAAI,EAAGA,EAAI,MAAOA,EACzBwV,EAAUtrB,MAAM8V,EAAI,KAAOljB,SAAS,IAAI24B,OAAO,IAoBjD,QAAe,YAjBf,SAAmBP,GACjB,IAAIQ,EAASpoB,UAAU/W,OAAS,QAAsBgG,IAAjB+Q,UAAU,GAAmBA,UAAU,GAAK,EAG7E2nB,GAAQO,EAAUN,EAAIQ,EAAS,IAAMF,EAAUN,EAAIQ,EAAS,IAAMF,EAAUN,EAAIQ,EAAS,IAAMF,EAAUN,EAAIQ,EAAS,IAAM,IAAMF,EAAUN,EAAIQ,EAAS,IAAMF,EAAUN,EAAIQ,EAAS,IAAM,IAAMF,EAAUN,EAAIQ,EAAS,IAAMF,EAAUN,EAAIQ,EAAS,IAAM,IAAMF,EAAUN,EAAIQ,EAAS,IAAMF,EAAUN,EAAIQ,EAAS,IAAM,IAAMF,EAAUN,EAAIQ,EAAS,KAAOF,EAAUN,EAAIQ,EAAS,KAAOF,EAAUN,EAAIQ,EAAS,KAAOF,EAAUN,EAAIQ,EAAS,KAAOF,EAAUN,EAAIQ,EAAS,KAAOF,EAAUN,EAAIQ,EAAS,MAAM/kB,cAMzf,KAAK,OAASskB,GACZ,MAAM3K,UAAU,+BAGlB,OAAO2K,CACT,EAEwB,I,2GCvBxB,IAAIU,EAEAC,EAGAC,EAAa,EACbC,EAAa,EAkFjB,QAAe,YAhFf,SAAYzhC,EAAS0hC,EAAKL,GACxB,IAAI1V,EAAI+V,GAAOL,GAAU,EACrBnP,EAAIwP,GAAO,IAAIzwB,MAAM,IAErB0wB,GADJ3hC,EAAUA,GAAW,CAAC,GACH2hC,MAAQL,EACvBM,OAAgC15B,IAArBlI,EAAQ4hC,SAAyB5hC,EAAQ4hC,SAAWL,EAInE,GAAY,MAARI,GAA4B,MAAZC,EAAkB,CACpC,IAAIC,EAAY7hC,EAAQ8hC,SAAW9hC,EAAQghC,KAAO,OAEtC,MAARW,IAEFA,EAAOL,EAAU,CAAgB,EAAfO,EAAU,GAAWA,EAAU,GAAIA,EAAU,GAAIA,EAAU,GAAIA,EAAU,GAAIA,EAAU,KAG3F,MAAZD,IAEFA,EAAWL,EAAiD,OAApCM,EAAU,IAAM,EAAIA,EAAU,IAE1D,CAMA,IAAIE,OAA0B75B,IAAlBlI,EAAQ+hC,MAAsB/hC,EAAQ+hC,MAAQC,KAAK3S,MAG3D4S,OAA0B/5B,IAAlBlI,EAAQiiC,MAAsBjiC,EAAQiiC,MAAQR,EAAa,EAEnES,EAAKH,EAAQP,GAAcS,EAAQR,GAAc,IAarD,GAXIS,EAAK,QAA0Bh6B,IAArBlI,EAAQ4hC,WACpBA,EAAWA,EAAW,EAAI,QAKvBM,EAAK,GAAKH,EAAQP,SAAiCt5B,IAAlBlI,EAAQiiC,QAC5CA,EAAQ,GAINA,GAAS,IACX,MAAM,IAAI76B,MAAM,mDAGlBo6B,EAAaO,EACbN,EAAaQ,EACbV,EAAYK,EAIZ,IAAIO,GAA4B,KAAb,WAFnBJ,GAAS,cAE+BE,GAAS,WACjD/P,EAAEvG,KAAOwW,IAAO,GAAK,IACrBjQ,EAAEvG,KAAOwW,IAAO,GAAK,IACrBjQ,EAAEvG,KAAOwW,IAAO,EAAI,IACpBjQ,EAAEvG,KAAY,IAALwW,EAET,IAAIC,EAAML,EAAQ,WAAc,IAAQ,UACxC7P,EAAEvG,KAAOyW,IAAQ,EAAI,IACrBlQ,EAAEvG,KAAa,IAANyW,EAETlQ,EAAEvG,KAAOyW,IAAQ,GAAK,GAAM,GAE5BlQ,EAAEvG,KAAOyW,IAAQ,GAAK,IAEtBlQ,EAAEvG,KAAOiW,IAAa,EAAI,IAE1B1P,EAAEvG,KAAkB,IAAXiW,EAET,IAAK,IAAIhpB,EAAI,EAAGA,EAAI,IAAKA,EACvBsZ,EAAEvG,EAAI/S,GAAK+oB,EAAK/oB,GAGlB,OAAO8oB,IAAO,OAAUxP,EAC1B,EAEiB,I,+BCtCjB,SAASmQ,EAAgBC,GACvB,OAAwC,IAAhCA,EAAe,KAAO,GAAK,GAAU,CAC/C,CAsHA,SAASC,EAAQC,EAAGhN,GAClB,IAAIiN,GAAW,MAAJD,IAAmB,MAAJhN,GAE1B,OADWgN,GAAK,KAAOhN,GAAK,KAAOiN,GAAO,KAC5B,GAAW,MAANA,CACrB,CAcA,SAASC,EAAOC,EAAGC,EAAG1Q,EAAGsQ,EAAG5N,EAAGzC,GAC7B,OAAOoQ,GATcM,EASQN,EAAQA,EAAQK,EAAGD,GAAIJ,EAAQC,EAAGrQ,OATrC2Q,EAS0ClO,GARhDiO,IAAQ,GAAKC,EAQuC5Q,GAT1E,IAAuB2Q,EAAKC,CAU5B,CAEA,SAASC,EAAMH,EAAG1Q,EAAG8Q,EAAG7a,EAAGqa,EAAG5N,EAAGzC,GAC/B,OAAOuQ,EAAOxQ,EAAI8Q,GAAK9Q,EAAI/J,EAAGya,EAAG1Q,EAAGsQ,EAAG5N,EAAGzC,EAC5C,CAEA,SAAS8Q,EAAML,EAAG1Q,EAAG8Q,EAAG7a,EAAGqa,EAAG5N,EAAGzC,GAC/B,OAAOuQ,EAAOxQ,EAAI/J,EAAI6a,GAAK7a,EAAGya,EAAG1Q,EAAGsQ,EAAG5N,EAAGzC,EAC5C,CAEA,SAAS+Q,EAAMN,EAAG1Q,EAAG8Q,EAAG7a,EAAGqa,EAAG5N,EAAGzC,GAC/B,OAAOuQ,EAAOxQ,EAAI8Q,EAAI7a,EAAGya,EAAG1Q,EAAGsQ,EAAG5N,EAAGzC,EACvC,CAEA,SAASgR,EAAMP,EAAG1Q,EAAG8Q,EAAG7a,EAAGqa,EAAG5N,EAAGzC,GAC/B,OAAOuQ,EAAOM,GAAK9Q,GAAK/J,GAAIya,EAAG1Q,EAAGsQ,EAAG5N,EAAGzC,EAC1C,C,iBAEA,MCnNA,GADS,E,SAAA,IAAI,KAAM,IDkBnB,SAAa8N,GACX,GAAqB,iBAAVA,EAAoB,CAC7B,IAAImD,EAAMC,SAASxP,mBAAmBoM,IAEtCA,EAAQ,IAAIH,WAAWsD,EAAIlhC,QAE3B,IAAK,IAAIypB,EAAI,EAAGA,EAAIyX,EAAIlhC,SAAUypB,EAChCsU,EAAMtU,GAAKyX,EAAIrD,WAAWpU,EAE9B,CAEA,OAOF,SAA8BjR,GAK5B,IAJA,IAAI4oB,EAAS,GACTC,EAA0B,GAAf7oB,EAAMxY,OACjBshC,EAAS,mBAEJ7X,EAAI,EAAGA,EAAI4X,EAAU5X,GAAK,EAAG,CACpC,IAAI6W,EAAI9nB,EAAMiR,GAAK,KAAOA,EAAI,GAAK,IAC/B8X,EAAM7R,SAAS4R,EAAOE,OAAOlB,IAAM,EAAI,IAAQgB,EAAOE,OAAW,GAAJlB,GAAW,IAC5Ec,EAAOztB,KAAK4tB,EACd,CAEA,OAAOH,CACT,CAnBSK,CAiCT,SAAoBnB,EAAGtC,GAErBsC,EAAEtC,GAAO,IAAM,KAAQA,EAAM,GAC7BsC,EAAEH,EAAgBnC,GAAO,GAAKA,EAM9B,IALA,IAAI0C,EAAI,WACJ1Q,GAAK,UACL8Q,GAAK,WACL7a,EAAI,UAECwD,EAAI,EAAGA,EAAI6W,EAAEtgC,OAAQypB,GAAK,GAAI,CACrC,IAAIiY,EAAOhB,EACPiB,EAAO3R,EACP4R,EAAOd,EACPe,EAAO5b,EACXya,EAAIG,EAAMH,EAAG1Q,EAAG8Q,EAAG7a,EAAGqa,EAAE7W,GAAI,GAAI,WAChCxD,EAAI4a,EAAM5a,EAAGya,EAAG1Q,EAAG8Q,EAAGR,EAAE7W,EAAI,GAAI,IAAK,WACrCqX,EAAID,EAAMC,EAAG7a,EAAGya,EAAG1Q,EAAGsQ,EAAE7W,EAAI,GAAI,GAAI,WACpCuG,EAAI6Q,EAAM7Q,EAAG8Q,EAAG7a,EAAGya,EAAGJ,EAAE7W,EAAI,GAAI,IAAK,YACrCiX,EAAIG,EAAMH,EAAG1Q,EAAG8Q,EAAG7a,EAAGqa,EAAE7W,EAAI,GAAI,GAAI,WACpCxD,EAAI4a,EAAM5a,EAAGya,EAAG1Q,EAAG8Q,EAAGR,EAAE7W,EAAI,GAAI,GAAI,YACpCqX,EAAID,EAAMC,EAAG7a,EAAGya,EAAG1Q,EAAGsQ,EAAE7W,EAAI,GAAI,IAAK,YACrCuG,EAAI6Q,EAAM7Q,EAAG8Q,EAAG7a,EAAGya,EAAGJ,EAAE7W,EAAI,GAAI,IAAK,UACrCiX,EAAIG,EAAMH,EAAG1Q,EAAG8Q,EAAG7a,EAAGqa,EAAE7W,EAAI,GAAI,EAAG,YACnCxD,EAAI4a,EAAM5a,EAAGya,EAAG1Q,EAAG8Q,EAAGR,EAAE7W,EAAI,GAAI,IAAK,YACrCqX,EAAID,EAAMC,EAAG7a,EAAGya,EAAG1Q,EAAGsQ,EAAE7W,EAAI,IAAK,IAAK,OACtCuG,EAAI6Q,EAAM7Q,EAAG8Q,EAAG7a,EAAGya,EAAGJ,EAAE7W,EAAI,IAAK,IAAK,YACtCiX,EAAIG,EAAMH,EAAG1Q,EAAG8Q,EAAG7a,EAAGqa,EAAE7W,EAAI,IAAK,EAAG,YACpCxD,EAAI4a,EAAM5a,EAAGya,EAAG1Q,EAAG8Q,EAAGR,EAAE7W,EAAI,IAAK,IAAK,UACtCqX,EAAID,EAAMC,EAAG7a,EAAGya,EAAG1Q,EAAGsQ,EAAE7W,EAAI,IAAK,IAAK,YAEtCiX,EAAIK,EAAML,EADV1Q,EAAI6Q,EAAM7Q,EAAG8Q,EAAG7a,EAAGya,EAAGJ,EAAE7W,EAAI,IAAK,GAAI,YACrBqX,EAAG7a,EAAGqa,EAAE7W,EAAI,GAAI,GAAI,WACpCxD,EAAI8a,EAAM9a,EAAGya,EAAG1Q,EAAG8Q,EAAGR,EAAE7W,EAAI,GAAI,GAAI,YACpCqX,EAAIC,EAAMD,EAAG7a,EAAGya,EAAG1Q,EAAGsQ,EAAE7W,EAAI,IAAK,GAAI,WACrCuG,EAAI+Q,EAAM/Q,EAAG8Q,EAAG7a,EAAGya,EAAGJ,EAAE7W,GAAI,IAAK,WACjCiX,EAAIK,EAAML,EAAG1Q,EAAG8Q,EAAG7a,EAAGqa,EAAE7W,EAAI,GAAI,GAAI,WACpCxD,EAAI8a,EAAM9a,EAAGya,EAAG1Q,EAAG8Q,EAAGR,EAAE7W,EAAI,IAAK,EAAG,UACpCqX,EAAIC,EAAMD,EAAG7a,EAAGya,EAAG1Q,EAAGsQ,EAAE7W,EAAI,IAAK,IAAK,WACtCuG,EAAI+Q,EAAM/Q,EAAG8Q,EAAG7a,EAAGya,EAAGJ,EAAE7W,EAAI,GAAI,IAAK,WACrCiX,EAAIK,EAAML,EAAG1Q,EAAG8Q,EAAG7a,EAAGqa,EAAE7W,EAAI,GAAI,EAAG,WACnCxD,EAAI8a,EAAM9a,EAAGya,EAAG1Q,EAAG8Q,EAAGR,EAAE7W,EAAI,IAAK,GAAI,YACrCqX,EAAIC,EAAMD,EAAG7a,EAAGya,EAAG1Q,EAAGsQ,EAAE7W,EAAI,GAAI,IAAK,WACrCuG,EAAI+Q,EAAM/Q,EAAG8Q,EAAG7a,EAAGya,EAAGJ,EAAE7W,EAAI,GAAI,GAAI,YACpCiX,EAAIK,EAAML,EAAG1Q,EAAG8Q,EAAG7a,EAAGqa,EAAE7W,EAAI,IAAK,GAAI,YACrCxD,EAAI8a,EAAM9a,EAAGya,EAAG1Q,EAAG8Q,EAAGR,EAAE7W,EAAI,GAAI,GAAI,UACpCqX,EAAIC,EAAMD,EAAG7a,EAAGya,EAAG1Q,EAAGsQ,EAAE7W,EAAI,GAAI,GAAI,YAEpCiX,EAAIM,EAAMN,EADV1Q,EAAI+Q,EAAM/Q,EAAG8Q,EAAG7a,EAAGya,EAAGJ,EAAE7W,EAAI,IAAK,IAAK,YACtBqX,EAAG7a,EAAGqa,EAAE7W,EAAI,GAAI,GAAI,QACpCxD,EAAI+a,EAAM/a,EAAGya,EAAG1Q,EAAG8Q,EAAGR,EAAE7W,EAAI,GAAI,IAAK,YACrCqX,EAAIE,EAAMF,EAAG7a,EAAGya,EAAG1Q,EAAGsQ,EAAE7W,EAAI,IAAK,GAAI,YACrCuG,EAAIgR,EAAMhR,EAAG8Q,EAAG7a,EAAGya,EAAGJ,EAAE7W,EAAI,IAAK,IAAK,UACtCiX,EAAIM,EAAMN,EAAG1Q,EAAG8Q,EAAG7a,EAAGqa,EAAE7W,EAAI,GAAI,GAAI,YACpCxD,EAAI+a,EAAM/a,EAAGya,EAAG1Q,EAAG8Q,EAAGR,EAAE7W,EAAI,GAAI,GAAI,YACpCqX,EAAIE,EAAMF,EAAG7a,EAAGya,EAAG1Q,EAAGsQ,EAAE7W,EAAI,GAAI,IAAK,WACrCuG,EAAIgR,EAAMhR,EAAG8Q,EAAG7a,EAAGya,EAAGJ,EAAE7W,EAAI,IAAK,IAAK,YACtCiX,EAAIM,EAAMN,EAAG1Q,EAAG8Q,EAAG7a,EAAGqa,EAAE7W,EAAI,IAAK,EAAG,WACpCxD,EAAI+a,EAAM/a,EAAGya,EAAG1Q,EAAG8Q,EAAGR,EAAE7W,GAAI,IAAK,WACjCqX,EAAIE,EAAMF,EAAG7a,EAAGya,EAAG1Q,EAAGsQ,EAAE7W,EAAI,GAAI,IAAK,WACrCuG,EAAIgR,EAAMhR,EAAG8Q,EAAG7a,EAAGya,EAAGJ,EAAE7W,EAAI,GAAI,GAAI,UACpCiX,EAAIM,EAAMN,EAAG1Q,EAAG8Q,EAAG7a,EAAGqa,EAAE7W,EAAI,GAAI,GAAI,WACpCxD,EAAI+a,EAAM/a,EAAGya,EAAG1Q,EAAG8Q,EAAGR,EAAE7W,EAAI,IAAK,IAAK,WACtCqX,EAAIE,EAAMF,EAAG7a,EAAGya,EAAG1Q,EAAGsQ,EAAE7W,EAAI,IAAK,GAAI,WAErCiX,EAAIO,EAAMP,EADV1Q,EAAIgR,EAAMhR,EAAG8Q,EAAG7a,EAAGya,EAAGJ,EAAE7W,EAAI,GAAI,IAAK,WACrBqX,EAAG7a,EAAGqa,EAAE7W,GAAI,GAAI,WAChCxD,EAAIgb,EAAMhb,EAAGya,EAAG1Q,EAAG8Q,EAAGR,EAAE7W,EAAI,GAAI,GAAI,YACpCqX,EAAIG,EAAMH,EAAG7a,EAAGya,EAAG1Q,EAAGsQ,EAAE7W,EAAI,IAAK,IAAK,YACtCuG,EAAIiR,EAAMjR,EAAG8Q,EAAG7a,EAAGya,EAAGJ,EAAE7W,EAAI,GAAI,IAAK,UACrCiX,EAAIO,EAAMP,EAAG1Q,EAAG8Q,EAAG7a,EAAGqa,EAAE7W,EAAI,IAAK,EAAG,YACpCxD,EAAIgb,EAAMhb,EAAGya,EAAG1Q,EAAG8Q,EAAGR,EAAE7W,EAAI,GAAI,IAAK,YACrCqX,EAAIG,EAAMH,EAAG7a,EAAGya,EAAG1Q,EAAGsQ,EAAE7W,EAAI,IAAK,IAAK,SACtCuG,EAAIiR,EAAMjR,EAAG8Q,EAAG7a,EAAGya,EAAGJ,EAAE7W,EAAI,GAAI,IAAK,YACrCiX,EAAIO,EAAMP,EAAG1Q,EAAG8Q,EAAG7a,EAAGqa,EAAE7W,EAAI,GAAI,EAAG,YACnCxD,EAAIgb,EAAMhb,EAAGya,EAAG1Q,EAAG8Q,EAAGR,EAAE7W,EAAI,IAAK,IAAK,UACtCqX,EAAIG,EAAMH,EAAG7a,EAAGya,EAAG1Q,EAAGsQ,EAAE7W,EAAI,GAAI,IAAK,YACrCuG,EAAIiR,EAAMjR,EAAG8Q,EAAG7a,EAAGya,EAAGJ,EAAE7W,EAAI,IAAK,GAAI,YACrCiX,EAAIO,EAAMP,EAAG1Q,EAAG8Q,EAAG7a,EAAGqa,EAAE7W,EAAI,GAAI,GAAI,WACpCxD,EAAIgb,EAAMhb,EAAGya,EAAG1Q,EAAG8Q,EAAGR,EAAE7W,EAAI,IAAK,IAAK,YACtCqX,EAAIG,EAAMH,EAAG7a,EAAGya,EAAG1Q,EAAGsQ,EAAE7W,EAAI,GAAI,GAAI,WACpCuG,EAAIiR,EAAMjR,EAAG8Q,EAAG7a,EAAGya,EAAGJ,EAAE7W,EAAI,GAAI,IAAK,WACrCiX,EAAIL,EAAQK,EAAGgB,GACf1R,EAAIqQ,EAAQrQ,EAAG2R,GACfb,EAAIT,EAAQS,EAAGc,GACf3b,EAAIoa,EAAQpa,EAAG4b,EACjB,CAEA,MAAO,CAACnB,EAAG1Q,EAAG8Q,EAAG7a,EACnB,CAtH8B6b,CA6H9B,SAAsBtpB,GACpB,GAAqB,IAAjBA,EAAMxY,OACR,MAAO,GAMT,IAHA,IAAI+hC,EAAyB,EAAfvpB,EAAMxY,OAChBohC,EAAS,IAAIY,YAAY7B,EAAgB4B,IAEpCtY,EAAI,EAAGA,EAAIsY,EAAStY,GAAK,EAChC2X,EAAO3X,GAAK,KAAsB,IAAfjR,EAAMiR,EAAI,KAAcA,EAAI,GAGjD,OAAO2X,CACT,CA1IyCa,CAAalE,GAAuB,EAAfA,EAAM/9B,QACpE,G,6GEjBO,IAAIkiC,EAAM,uCACNvpB,EAAM,uCACF,SAAS,EAACnP,EAAM0S,EAASimB,GACtC,SAASC,EAAa7kC,EAAO8kC,EAAW7C,EAAKL,GAS3C,GARqB,iBAAV5hC,IACTA,EAjBN,SAAuB+kC,GACrBA,EAAMnB,SAASxP,mBAAmB2Q,IAIlC,IAFA,IAAIvE,EAAQ,GAEHtU,EAAI,EAAGA,EAAI6Y,EAAItiC,SAAUypB,EAChCsU,EAAMpqB,KAAK2uB,EAAIzE,WAAWpU,IAG5B,OAAOsU,CACT,CAOcwE,CAAchlC,IAGC,iBAAd8kC,IACTA,GAAY,OAAMA,IAGK,KAArBA,EAAUriC,OACZ,MAAM+zB,UAAU,oEAMlB,IAAIgK,EAAQ,IAAIH,WAAW,GAAKrgC,EAAMyC,QAOtC,GANA+9B,EAAMyE,IAAIH,GACVtE,EAAMyE,IAAIjlC,EAAO8kC,EAAUriC,SAC3B+9B,EAAQoE,EAASpE,IACX,GAAgB,GAAXA,EAAM,GAAY7hB,EAC7B6hB,EAAM,GAAgB,GAAXA,EAAM,GAAY,IAEzByB,EAAK,CACPL,EAASA,GAAU,EAEnB,IAAK,IAAI1V,EAAI,EAAGA,EAAI,KAAMA,EACxB+V,EAAIL,EAAS1V,GAAKsU,EAAMtU,GAG1B,OAAO+V,CACT,CAEA,OAAO,OAAUzB,EACnB,CAGA,IACEqE,EAAa54B,KAAOA,CACtB,CAAE,MAAO5F,GAAM,CAKf,OAFAw+B,EAAaF,IAAMA,EACnBE,EAAazpB,IAAMA,EACZypB,CACT,C,4GCxCA,QAAe,YApBf,SAAYtkC,EAAS0hC,EAAKL,GAExB,IAAIsD,GADJ3kC,EAAUA,GAAW,CAAC,GACH8hC,SAAW9hC,EAAQghC,KAAO,OAK7C,GAHA2D,EAAK,GAAe,GAAVA,EAAK,GAAY,GAC3BA,EAAK,GAAe,GAAVA,EAAK,GAAY,IAEvBjD,EAAK,CACPL,EAASA,GAAU,EAEnB,IAAK,IAAI1V,EAAI,EAAGA,EAAI,KAAMA,EACxB+V,EAAIL,EAAS1V,GAAKgZ,EAAKhZ,GAGzB,OAAO+V,CACT,CAEA,OAAO,OAAUiD,EACnB,EAEiB,I,+BCrBjB,SAASpP,EAAEX,EAAG4N,EAAGhN,EAAGoP,GAClB,OAAQhQ,GACN,KAAK,EACH,OAAO4N,EAAIhN,GAAKgN,EAAIoC,EAEtB,KAAK,EAML,KAAK,EACH,OAAOpC,EAAIhN,EAAIoP,EAJjB,KAAK,EACH,OAAOpC,EAAIhN,EAAIgN,EAAIoC,EAAIpP,EAAIoP,EAKjC,CAEA,SAASC,EAAKrC,EAAG5pB,GACf,OAAO4pB,GAAK5pB,EAAI4pB,IAAM,GAAK5pB,CAC7B,C,iBA2EA,MC5FA,GADS,E,SAAA,IAAI,KAAM,IDoBnB,SAAcqnB,GACZ,IAAI6E,EAAI,CAAC,WAAY,WAAY,WAAY,YACzCC,EAAI,CAAC,WAAY,WAAY,WAAY,UAAY,YAEzD,GAAqB,iBAAV9E,EAAoB,CAC7B,IAAImD,EAAMC,SAASxP,mBAAmBoM,IAEtCA,EAAQ,GAER,IAAK,IAAItU,EAAI,EAAGA,EAAIyX,EAAIlhC,SAAUypB,EAChCsU,EAAMpqB,KAAKutB,EAAIrD,WAAWpU,GAE9B,MAAY1a,MAAMC,QAAQ+uB,KAExBA,EAAQhvB,MAAMyW,UAAUpX,MAAMnE,KAAK8zB,IAGrCA,EAAMpqB,KAAK,KAKX,IAJA,IAAI0gB,EAAI0J,EAAM/9B,OAAS,EAAI,EACvB8iC,EAAI/+B,KAAKg/B,KAAK1O,EAAI,IAClB2O,EAAI,IAAIj0B,MAAM+zB,GAETG,EAAK,EAAGA,EAAKH,IAAKG,EAAI,CAG7B,IAFA,IAAItE,EAAM,IAAIqD,YAAY,IAEjBkB,EAAI,EAAGA,EAAI,KAAMA,EACxBvE,EAAIuE,GAAKnF,EAAW,GAALkF,EAAc,EAAJC,IAAU,GAAKnF,EAAW,GAALkF,EAAc,EAAJC,EAAQ,IAAM,GAAKnF,EAAW,GAALkF,EAAc,EAAJC,EAAQ,IAAM,EAAInF,EAAW,GAALkF,EAAc,EAAJC,EAAQ,GAGvIF,EAAEC,GAAMtE,CACV,CAEAqE,EAAEF,EAAI,GAAG,IAA2B,GAApB/E,EAAM/9B,OAAS,GAAS+D,KAAKC,IAAI,EAAG,IACpDg/B,EAAEF,EAAI,GAAG,IAAM/+B,KAAKo/B,MAAMH,EAAEF,EAAI,GAAG,KACnCE,EAAEF,EAAI,GAAG,IAA2B,GAApB/E,EAAM/9B,OAAS,GAAS,WAExC,IAAK,IAAIojC,EAAM,EAAGA,EAAMN,IAAKM,EAAK,CAGhC,IAFA,IAAIC,EAAI,IAAIrB,YAAY,IAEf/R,EAAI,EAAGA,EAAI,KAAMA,EACxBoT,EAAEpT,GAAK+S,EAAEI,GAAKnT,GAGhB,IAAK,IAAIqT,EAAK,GAAIA,EAAK,KAAMA,EAC3BD,EAAEC,GAAMX,EAAKU,EAAEC,EAAK,GAAKD,EAAEC,EAAK,GAAKD,EAAEC,EAAK,IAAMD,EAAEC,EAAK,IAAK,GAShE,IANA,IAAI5C,EAAImC,EAAE,GACN7S,EAAI6S,EAAE,GACN/B,EAAI+B,EAAE,GACN5c,EAAI4c,EAAE,GACN1iC,EAAI0iC,EAAE,GAEDU,EAAM,EAAGA,EAAM,KAAMA,EAAK,CACjC,IAAI7Q,EAAI3uB,KAAKo/B,MAAMI,EAAM,IACrBC,EAAIb,EAAKjC,EAAG,GAAKrN,EAAEX,EAAG1C,EAAG8Q,EAAG7a,GAAK9lB,EAAIyiC,EAAElQ,GAAK2Q,EAAEE,KAAS,EAC3DpjC,EAAI8lB,EACJA,EAAI6a,EACJA,EAAI6B,EAAK3S,EAAG,MAAQ,EACpBA,EAAI0Q,EACJA,EAAI8C,CACN,CAEAX,EAAE,GAAKA,EAAE,GAAKnC,IAAM,EACpBmC,EAAE,GAAKA,EAAE,GAAK7S,IAAM,EACpB6S,EAAE,GAAKA,EAAE,GAAK/B,IAAM,EACpB+B,EAAE,GAAKA,EAAE,GAAK5c,IAAM,EACpB4c,EAAE,GAAKA,EAAE,GAAK1iC,IAAM,CACtB,CAEA,MAAO,CAAC0iC,EAAE,IAAM,GAAK,IAAMA,EAAE,IAAM,GAAK,IAAMA,EAAE,IAAM,EAAI,IAAa,IAAPA,EAAE,GAAWA,EAAE,IAAM,GAAK,IAAMA,EAAE,IAAM,GAAK,IAAMA,EAAE,IAAM,EAAI,IAAa,IAAPA,EAAE,GAAWA,EAAE,IAAM,GAAK,IAAMA,EAAE,IAAM,GAAK,IAAMA,EAAE,IAAM,EAAI,IAAa,IAAPA,EAAE,GAAWA,EAAE,IAAM,GAAK,IAAMA,EAAE,IAAM,GAAK,IAAMA,EAAE,IAAM,EAAI,IAAa,IAAPA,EAAE,GAAWA,EAAE,IAAM,GAAK,IAAMA,EAAE,IAAM,GAAK,IAAMA,EAAE,IAAM,EAAI,IAAa,IAAPA,EAAE,GACxV,G,8EEvFA,QAAe,YAJf,SAAkBnE,GAChB,MAAuB,iBAATA,GAAqB,IAAM1kB,KAAK0kB,EAChD,EAEuB,I,8ECIvB,QAAe,YARf,SAAiBA,GACf,KAAK,OAASA,GACZ,MAAM3K,UAAU,gBAGlB,OAAOrE,SAASgP,EAAKQ,OAAO,GAAI,GAAI,GACtC,EAEsB,I","sources":["webpack://httptoolkit-ui/./node_modules/mockttp/dist/client/admin-client.js","webpack://httptoolkit-ui/./node_modules/mockttp/dist/client/admin-query.js","webpack://httptoolkit-ui/./node_modules/mockttp/dist/client/mocked-endpoint-client.js","webpack://httptoolkit-ui/./node_modules/mockttp/dist/client/mockttp-admin-request-builder.js","webpack://httptoolkit-ui/./node_modules/mockttp/dist/client/mockttp-client.js","webpack://httptoolkit-ui/./node_modules/mockttp/dist/client/schema-introspection.js","webpack://httptoolkit-ui/./node_modules/mockttp/dist/main.browser.js","webpack://httptoolkit-ui/./node_modules/mockttp/dist/mockttp.js","webpack://httptoolkit-ui/./node_modules/mockttp/dist/pluggable-admin-api/mockttp-pluggable-admin.browser.js","webpack://httptoolkit-ui/./node_modules/mockttp/dist/pluggable-admin-api/pluggable-admin.browser.js","webpack://httptoolkit-ui/./node_modules/mockttp/dist/rules/base-rule-builder.js","webpack://httptoolkit-ui/./node_modules/mockttp/dist/rules/completion-checkers.js","webpack://httptoolkit-ui/./node_modules/mockttp/dist/rules/matchers.js","webpack://httptoolkit-ui/./node_modules/mockttp/dist/rules/requests/request-handler-definitions.js","webpack://httptoolkit-ui/./node_modules/mockttp/dist/rules/requests/request-rule-builder.js","webpack://httptoolkit-ui/./node_modules/mockttp/dist/rules/rule-parameters.js","webpack://httptoolkit-ui/./node_modules/mockttp/dist/rules/rule-serialization.js","webpack://httptoolkit-ui/./node_modules/mockttp/dist/rules/websockets/websocket-handler-definitions.js","webpack://httptoolkit-ui/./node_modules/mockttp/dist/rules/websockets/websocket-rule-builder.js","webpack://httptoolkit-ui/./node_modules/mockttp/dist/serialization/body-serialization.js","webpack://httptoolkit-ui/./node_modules/mockttp/dist/serialization/serialization.js","webpack://httptoolkit-ui/./node_modules/mockttp/dist/types.js","webpack://httptoolkit-ui/./node_modules/mockttp/dist/util/buffer-utils.js","webpack://httptoolkit-ui/./node_modules/mockttp/dist/util/error.js","webpack://httptoolkit-ui/./node_modules/mockttp/dist/util/header-utils.js","webpack://httptoolkit-ui/./node_modules/mockttp/dist/util/promise.js","webpack://httptoolkit-ui/./node_modules/mockttp/dist/util/request-utils.js","webpack://httptoolkit-ui/./node_modules/mockttp/dist/util/url.js","webpack://httptoolkit-ui/./node_modules/mockttp/dist/util/util.js","webpack://httptoolkit-ui/./node_modules/mockttp/node_modules/@httptoolkit/subscriptions-transport-ws/dist/client.js","webpack://httptoolkit-ui/./node_modules/mockttp/node_modules/@httptoolkit/subscriptions-transport-ws/dist/defaults.js","webpack://httptoolkit-ui/./node_modules/mockttp/node_modules/@httptoolkit/subscriptions-transport-ws/dist/message-types.js","webpack://httptoolkit-ui/./node_modules/mockttp/node_modules/@httptoolkit/subscriptions-transport-ws/dist/protocol.js","webpack://httptoolkit-ui/./node_modules/mockttp/node_modules/@httptoolkit/subscriptions-transport-ws/dist/utils/is-object.js","webpack://httptoolkit-ui/./node_modules/mockttp/node_modules/@httptoolkit/subscriptions-transport-ws/dist/utils/is-string.js","webpack://httptoolkit-ui/./node_modules/mockttp/node_modules/base64-arraybuffer/lib/base64-arraybuffer.js","webpack://httptoolkit-ui/./node_modules/mockttp/node_modules/uuid/dist/esm-browser/nil.js","webpack://httptoolkit-ui/./node_modules/mockttp/node_modules/uuid/dist/esm-browser/parse.js","webpack://httptoolkit-ui/./node_modules/mockttp/node_modules/uuid/dist/esm-browser/regex.js","webpack://httptoolkit-ui/./node_modules/mockttp/node_modules/uuid/dist/esm-browser/rng.js","webpack://httptoolkit-ui/./node_modules/mockttp/node_modules/uuid/dist/esm-browser/stringify.js","webpack://httptoolkit-ui/./node_modules/mockttp/node_modules/uuid/dist/esm-browser/v1.js","webpack://httptoolkit-ui/./node_modules/mockttp/node_modules/uuid/dist/esm-browser/md5.js","webpack://httptoolkit-ui/./node_modules/mockttp/node_modules/uuid/dist/esm-browser/v3.js","webpack://httptoolkit-ui/./node_modules/mockttp/node_modules/uuid/dist/esm-browser/v35.js","webpack://httptoolkit-ui/./node_modules/mockttp/node_modules/uuid/dist/esm-browser/v4.js","webpack://httptoolkit-ui/./node_modules/mockttp/node_modules/uuid/dist/esm-browser/sha1.js","webpack://httptoolkit-ui/./node_modules/mockttp/node_modules/uuid/dist/esm-browser/v5.js","webpack://httptoolkit-ui/./node_modules/mockttp/node_modules/uuid/dist/esm-browser/validate.js","webpack://httptoolkit-ui/./node_modules/mockttp/node_modules/uuid/dist/esm-browser/version.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.AdminClient = exports.GraphQLError = exports.RequestError = exports.ConnectionError = void 0;\nexports.resetAdminServer = resetAdminServer;\nconst _ = require(\"lodash\");\nconst events_1 = require(\"events\");\nconst DuplexPair = require(\"native-duplexpair\");\nconst typed_error_1 = require(\"typed-error\");\nconst CrossFetch = require(\"cross-fetch\");\nconst WebSocket = require(\"isomorphic-ws\");\nconst connectWebSocketStream = require(\"@httptoolkit/websocket-stream\");\nconst subscriptions_transport_ws_1 = require(\"@httptoolkit/subscriptions-transport-ws\");\nconst graphql_1 = require(\"graphql\");\nconst types_1 = require(\"../types\");\nconst util_1 = require(\"../util/util\");\nconst error_1 = require(\"../util/error\");\nconst promise_1 = require(\"../util/promise\");\nconst schema_introspection_1 = require(\"./schema-introspection\");\nconst schema_introspection_2 = require(\"./schema-introspection\");\nconst admin_query_1 = require(\"./admin-query\");\nconst { fetch, Headers } = util_1.isNode || typeof globalThis.fetch === 'undefined'\n    ? CrossFetch\n    : globalThis;\nclass ConnectionError extends typed_error_1.TypedError {\n}\nexports.ConnectionError = ConnectionError;\nclass RequestError extends typed_error_1.TypedError {\n    constructor(message, response) {\n        super(message);\n        this.response = response;\n    }\n}\nexports.RequestError = RequestError;\nclass GraphQLError extends RequestError {\n    constructor(response, errors) {\n        super(errors.length === 0\n            ? `GraphQL request failed with ${response.status} response`\n            : errors.length === 1\n                ? `GraphQL request failed with: ${errors[0].message}`\n                : // >1\n                    `GraphQL request failed, with errors:\\n${errors.map((e) => e.message).join('\\n')}`, response);\n        this.errors = errors;\n    }\n}\nexports.GraphQLError = GraphQLError;\nconst mergeClientOptions = (options, defaultOptions) => {\n    if (!defaultOptions)\n        return options;\n    if (!options)\n        return defaultOptions;\n    if (defaultOptions.headers) {\n        if (!options.headers) {\n            options.headers = defaultOptions.headers;\n        }\n        else if (options.headers instanceof Headers) {\n            _.forEach(defaultOptions.headers, (value, key) => {\n                options.headers.append(key, value);\n            });\n        }\n        else if (_.isObject(options.headers)) {\n            Object.assign(options.headers, defaultOptions.headers);\n        }\n    }\n    return options;\n};\nasync function requestFromAdminServer(serverUrl, path, options) {\n    const url = `${serverUrl}${path}`;\n    let response;\n    try {\n        response = await fetch(url, options);\n    }\n    catch (e) {\n        if ((0, error_1.isErrorLike)(e) && e.code === 'ECONNREFUSED') {\n            throw new ConnectionError(`Failed to connect to admin server at ${serverUrl}`);\n        }\n        else\n            throw e;\n    }\n    if (response.status >= 400) {\n        let body = await response.text();\n        let jsonBody = null;\n        try {\n            jsonBody = JSON.parse(body);\n        }\n        catch (e) { }\n        if (jsonBody && jsonBody.error) {\n            throw new RequestError(jsonBody.error, response);\n        }\n        else {\n            throw new RequestError(`Request to ${url} failed, with status ${response.status} and response body: ${body}`, response);\n        }\n    }\n    else {\n        return response.json();\n    }\n}\n/**\n * Reset a remote admin server, shutting down all Mockttp servers controlled by that\n * admin server. This is equivalent to calling `client.stop()` for all remote\n * clients of the target server.\n *\n * This can be useful in some rare cases, where a client might fail to reliably tear down\n * its own server, e.g. in Cypress testing. In this case, it's useful to reset the\n * admin server completely remotely without needing access to any previous client\n * instances, to ensure all servers from previous test runs have been shut down.\n *\n * After this is called, behaviour of any previously connected clients is undefined, and\n * it's likely that they may throw errors or experience other undefined behaviour. Ensure\n * that `client.stop()` has been called on all active clients before calling this method.\n */\nasync function resetAdminServer(options = {}) {\n    const serverUrl = options.adminServerUrl ||\n        `http://localhost:${types_1.DEFAULT_ADMIN_SERVER_PORT}`;\n    await requestFromAdminServer(serverUrl, '/reset', {\n        ...options.requestOptions,\n        method: 'POST'\n    });\n}\n/**\n * A bare admin server client. This is not intended for general use, but can be useful when\n * building admin server plugins to mock non-HTTP protocols and other advanced use cases.\n *\n * For normal usage of Mockttp, you should use `Mockttp.getRemote()` instead, to get a Mockttp\n * remote client, which wraps this class with the full Mockttp API for mocking HTTP.\n *\n * This is part of Mockttp's experimental 'pluggable admin' API. It may change\n * unpredictably, even in minor releases.\n */\nclass AdminClient extends events_1.EventEmitter {\n    constructor(options = {}) {\n        super();\n        this.debug = false;\n        // True if server is entirely initialized, false if it's entirely shut down, or a promise\n        // that resolves to one or the other if it's currently changing state.\n        this.running = false;\n        this.enableDebug = async () => {\n            this.debug = true;\n            return (await this.queryMockServer(`mutation EnableDebug {\n                enableDebug\n            }`));\n        };\n        this.reset = async () => {\n            return (await this.queryMockServer(`mutation Reset {\n                reset\n            }`));\n        };\n        this.debug = !!options.debug;\n        this.adminClientOptions = _.defaults(options, {\n            adminServerUrl: `http://localhost:${types_1.DEFAULT_ADMIN_SERVER_PORT}`,\n            adminStreamReconnectAttempts: 5\n        });\n    }\n    attachStreamWebsocket(adminSessionBaseUrl, targetStream) {\n        const adminSessionBaseWSUrl = adminSessionBaseUrl.replace(/^http/, 'ws');\n        const wsStream = connectWebSocketStream(`${adminSessionBaseWSUrl}/stream`, {\n            headers: this.adminClientOptions.requestOptions?.headers // Only used in Node.js (via WS)\n        });\n        let streamConnected = false;\n        wsStream.on('connect', () => {\n            streamConnected = true;\n            targetStream.pipe(wsStream);\n            wsStream.pipe(targetStream, { end: false });\n        });\n        // We ignore errors, but websocket closure eventually results in reconnect or shutdown\n        wsStream.on('error', (e) => {\n            if (this.debug)\n                console.warn('Admin client stream error', e);\n            this.emit('stream-error', e);\n        });\n        // When the websocket closes (after connect, either close frame, error, or socket shutdown):\n        wsStream.on('ws-close', async (closeEvent) => {\n            targetStream.unpipe(wsStream);\n            const serverShutdown = closeEvent.code === 1000;\n            if (serverShutdown) {\n                // Clean shutdown implies the server is gone, and we need to shutdown & cleanup.\n                targetStream.emit('server-shutdown');\n            }\n            else if (streamConnected && (await this.running) === true) {\n                console.warn('Admin client stream unexpectedly disconnected', closeEvent);\n                if (this.adminClientOptions.adminStreamReconnectAttempts > 0) {\n                    this.tryToReconnectStream(adminSessionBaseUrl, targetStream);\n                }\n                else {\n                    // If retries are disabled, shut down immediately:\n                    console.log('Admin client stream reconnect disabled, shutting down');\n                    targetStream.emit('server-shutdown');\n                }\n            }\n            // If never connected successfully, we do nothing.\n        });\n        targetStream.on('finish', () => {\n            // Ignore any further WebSocket events - the websocket stream is no longer useful\n            wsStream.removeAllListeners('connect');\n            wsStream.removeAllListeners('ws-close');\n            wsStream.destroy();\n        });\n        return wsStream;\n    }\n    /**\n     * Attempt to recreate a stream after disconnection, up to a limited number of retries. This is\n     * different to normal connection setup, as it assumes the target stream is otherwise already\n     * set up and active.\n     */\n    async tryToReconnectStream(adminSessionBaseUrl, targetStream, retries = this.adminClientOptions.adminStreamReconnectAttempts) {\n        this.emit('stream-reconnecting');\n        // Unclean shutdown means something has gone wrong somewhere. Try to reconnect.\n        const newStream = this.attachStreamWebsocket(adminSessionBaseUrl, targetStream);\n        new Promise((resolve, reject) => {\n            newStream.once('connect', resolve);\n            newStream.once('error', reject);\n        }).then(() => {\n            // On a successful connect, business resumes as normal.\n            console.warn('Admin client stream reconnected');\n            this.emit('stream-reconnected');\n        }).catch(async (err) => {\n            if (retries > 0) {\n                // We delay re-retrying briefly - this helps to handle cases like the computer going\n                // to sleep (where the server & client pause in parallel, but race to do so).\n                // The delay increases exponentially with retry attempts (10ms, 50, 250, 1250, 6250)\n                const retryAttempt = this.adminClientOptions.adminStreamReconnectAttempts - retries;\n                await (0, util_1.delay)(10 * Math.pow(5, retryAttempt));\n                return this.tryToReconnectStream(adminSessionBaseUrl, targetStream, retries - 1);\n            }\n            // Otherwise, once retries have failed, we give up entirely:\n            console.warn('Admin client stream reconnection failed, shutting down:', err.message);\n            if (this.debug)\n                console.warn(err);\n            this.emit('stream-reconnect-failed', err);\n            targetStream.emit('server-shutdown');\n        });\n    }\n    openStreamToMockServer(adminSessionBaseUrl) {\n        // To allow reconnects, we need to not end the client stream when an individual web socket ends.\n        // To make that work, we return a separate stream, which isn't directly connected to the websocket\n        // and doesn't receive WS 'end' events, and then we can swap the WS inputs accordingly.\n        const { socket1: wsTarget, socket2: exposedStream } = new DuplexPair();\n        const wsStream = this.attachStreamWebsocket(adminSessionBaseUrl, wsTarget);\n        wsTarget.on('error', (e) => exposedStream.emit('error', e));\n        // When the server stream ends, end the target stream, which will automatically end all websockets.\n        exposedStream.on('finish', () => wsTarget.end());\n        // Propagate 'server is definitely no longer available' back from the websockets:\n        wsTarget.on('server-shutdown', () => exposedStream.emit('server-shutdown'));\n        // These receive a lot of listeners! One channel per matcher, handler & completion checker,\n        // and each adds listeners for data/error/finish/etc. That's OK, it's not generally a leak,\n        // but maybe 100 would be a bit suspicious (unless you have 30+ active rules).\n        exposedStream.setMaxListeners(100);\n        return new Promise((resolve, reject) => {\n            wsStream.once('connect', () => resolve(exposedStream));\n            wsStream.once('error', reject);\n        });\n    }\n    prepareSubscriptionClientToAdminServer(adminSessionBaseUrl) {\n        const adminSessionBaseWSUrl = adminSessionBaseUrl.replace(/^http/, 'ws');\n        const subscriptionUrl = `${adminSessionBaseWSUrl}/subscription`;\n        this.subscriptionClient = new subscriptions_transport_ws_1.SubscriptionClient(subscriptionUrl, {\n            lazy: true, // Doesn't actually connect until you use subscriptions\n            reconnect: true,\n            reconnectionAttempts: 8,\n            wsOptionArguments: [this.adminClientOptions.requestOptions]\n        }, WebSocket);\n        this.subscriptionClient.onError((e) => {\n            this.emit('subscription-error', e);\n            if (this.debug)\n                console.error(\"Subscription error\", e);\n        });\n        this.subscriptionClient.onReconnecting(() => {\n            this.emit('subscription-reconnecting');\n            console.warn('Reconnecting Mockttp subscription client');\n        });\n    }\n    async requestFromMockServer(path, options) {\n        // Must check for session URL, not this.running, or we can't send the /stop request during shutdown!\n        if (!this.adminSessionBaseUrl)\n            throw new Error('Not connected to mock server');\n        let url = this.adminSessionBaseUrl + path;\n        let response = await fetch(url, mergeClientOptions(options, this.adminClientOptions.requestOptions));\n        if (response.status >= 400) {\n            if (this.debug)\n                console.error(`Remote client server request failed with status ${response.status}`);\n            throw new RequestError(`Request to ${url} failed, with status ${response.status}`, response);\n        }\n        else {\n            return response;\n        }\n    }\n    async queryMockServer(query, variables) {\n        try {\n            const response = (await this.requestFromMockServer('/', {\n                method: 'POST',\n                headers: new Headers({\n                    'Content-Type': 'application/json'\n                }),\n                body: JSON.stringify({ query, variables })\n            }));\n            const { data, errors } = await response.json();\n            if (errors && errors.length) {\n                throw new GraphQLError(response, errors);\n            }\n            else {\n                return data;\n            }\n        }\n        catch (e) {\n            if (this.debug)\n                console.error(`Remote client query error: ${e}`);\n            if (!(e instanceof RequestError))\n                throw e;\n            let graphQLErrors = undefined;\n            try {\n                graphQLErrors = (await e.response.json()).errors;\n            }\n            catch (e2) { }\n            if (graphQLErrors) {\n                throw new GraphQLError(e.response, graphQLErrors);\n            }\n            else {\n                throw e;\n            }\n        }\n    }\n    async start(pluginStartParams) {\n        if (this.adminSessionBaseUrl || await this.running)\n            throw new Error('Server is already started');\n        if (this.debug)\n            console.log(`Starting remote mock server`);\n        this.emit('starting');\n        const startPromise = (0, promise_1.getDeferred)();\n        this.running = startPromise.then((result) => {\n            this.emit(result ? 'started' : 'start-failed');\n            this.running = result;\n            return result;\n        });\n        try {\n            const supportOldServers = 'http' in pluginStartParams;\n            const portConfig = supportOldServers\n                ? pluginStartParams['http'].port\n                : undefined;\n            const path = portConfig ? `/start?port=${JSON.stringify(portConfig)}` : '/start';\n            const adminServerResponse = await requestFromAdminServer(this.adminClientOptions.adminServerUrl, path, mergeClientOptions({\n                method: 'POST',\n                headers: new Headers({\n                    'Content-Type': 'application/json'\n                }),\n                body: JSON.stringify({\n                    plugins: pluginStartParams,\n                    // Include all the Mockttp params at the root too, for backward compat with old admin servers:\n                    ...pluginStartParams.http?.options\n                })\n            }, this.adminClientOptions.requestOptions));\n            // Backward compat for old servers\n            const isPluginAwareServer = 'id' in adminServerResponse;\n            const sessionId = isPluginAwareServer\n                ? adminServerResponse.id\n                : adminServerResponse.port.toString();\n            const adminSessionBaseUrl = `${this.adminClientOptions.adminServerUrl}/${isPluginAwareServer ? 'session' : 'server'}/${sessionId}`;\n            // Also open a stream connection, for 2-way communication we might need later.\n            const adminServerStream = await this.openStreamToMockServer(adminSessionBaseUrl);\n            adminServerStream.on('server-shutdown', () => {\n                // When the server remotely disconnects the stream, shut down the client iff the client hasn't\n                // stopped & restarted in the meantime (can happen, since all shutdown is async).\n                if (this.adminServerStream === adminServerStream) {\n                    console.warn('Client stopping due to admin server shutdown');\n                    this.stop();\n                }\n            });\n            this.adminServerStream = adminServerStream;\n            // Create a subscription client, preconfigured & ready to connect if on() is called later:\n            this.prepareSubscriptionClientToAdminServer(adminSessionBaseUrl);\n            // We don't persist the id or resolve the start promise until everything is set up\n            this.adminSessionBaseUrl = adminSessionBaseUrl;\n            // Load the schema on server start, so we can check for feature support\n            this.adminServerSchema = new schema_introspection_2.SchemaIntrospector((await this.queryMockServer(schema_introspection_1.introspectionQuery)).__schema);\n            if (this.debug)\n                console.log('Started remote mock server');\n            const serverMetadata = this.adminServerMetadata = // Set field before we resolve the promise\n                'pluginData' in adminServerResponse\n                    ? adminServerResponse.pluginData\n                    : {\n                        // Backward compat - convert old always-HTTP data into per-plugin format:\n                        http: adminServerResponse\n                    };\n            startPromise.resolve(true);\n            return serverMetadata;\n        }\n        catch (e) {\n            startPromise.resolve(false);\n            throw e;\n        }\n    }\n    isRunning() {\n        return this.running === true;\n    }\n    get metadata() {\n        if (!this.isRunning())\n            throw new Error(\"Metadata is not available until the mock server is started\");\n        return this.adminServerMetadata;\n    }\n    get schema() {\n        if (!this.isRunning())\n            throw new Error(\"Admin schema is not available until the mock server is started\");\n        return this.adminServerSchema;\n    }\n    get adminStream() {\n        if (!this.isRunning())\n            throw new Error(\"Admin stream is not available until the mock server is started\");\n        return this.adminServerStream;\n    }\n    // Call when either we want the server to stop, or it appears that the server has already stopped,\n    // and we just want to ensure that's happened and clean everything up.\n    async stop() {\n        if (await this.running === false)\n            return; // If stopped or stopping, do nothing.\n        this.emit('stopping');\n        const stopPromise = (0, promise_1.getDeferred)();\n        this.running = stopPromise.then((result) => {\n            this.emit('stopped');\n            this.running = result;\n            return result;\n        });\n        try {\n            if (this.debug)\n                console.log('Stopping remote mock server');\n            try {\n                this.subscriptionClient?.close();\n            }\n            catch (e) {\n                console.log(e);\n            }\n            this.subscriptionClient = undefined;\n            try {\n                this.adminServerStream?.end();\n            }\n            catch (e) {\n                console.log(e);\n            }\n            this.adminServerStream = undefined;\n            await this.requestServerStop();\n        }\n        finally {\n            // The client is always stopped (and so restartable) once stopping completes, in all\n            // cases, since it can always be started again to reset it. The promise is just here\n            // so that we successfully handle (and always wait for) parallel stops.\n            stopPromise.resolve(false);\n        }\n    }\n    requestServerStop() {\n        return this.requestFromMockServer('/stop', {\n            method: 'POST'\n        }).catch((e) => {\n            if (e instanceof RequestError && e.response.status === 404) {\n                // 404 means it doesn't exist, generally because it was already stopped\n                // by some other parallel shutdown process.\n                return;\n            }\n            else {\n                throw e;\n            }\n        }).then(() => {\n            this.adminSessionBaseUrl = undefined;\n            this.adminServerSchema = undefined;\n            this.adminServerMetadata = undefined;\n        });\n    }\n    async sendQuery(query) {\n        return (await this.sendQueries(query))[0];\n    }\n    async sendQueries(...queries) {\n        const results = queries.map(async ({ query, variables, transformResponse }) => {\n            const result = await this.queryMockServer((0, graphql_1.print)(query), variables);\n            return transformResponse\n                ? transformResponse(result, { adminClient: this })\n                : result;\n        });\n        return Promise.all(results);\n    }\n    async subscribe(query, callback) {\n        if (await this.running === false)\n            throw new Error('Not connected to mock server');\n        const fieldName = (0, admin_query_1.getSingleSelectedFieldName)(query);\n        if (!this.schema.typeHasField('Subscription', fieldName)) {\n            console.warn(`Ignoring client subscription for event unrecognized by Mockttp server: ${fieldName}`);\n            return Promise.resolve();\n        }\n        // This isn't 100% correct (you can be WS-connected, but still negotiating some GQL\n        // setup) but it's good enough for our purposes (knowing-ish if the connection worked).\n        let isConnected = !!this.subscriptionClient.client;\n        this.subscriptionClient.request(query).subscribe({\n            next: async (value) => {\n                if (value.data) {\n                    const response = value.data[fieldName];\n                    const result = query.transformResponse\n                        ? await query.transformResponse(response, { adminClient: this })\n                        : response;\n                    callback(result);\n                }\n                else if (value.errors) {\n                    console.error('Error in subscription', value.errors);\n                }\n            },\n            error: (e) => this.debug && console.warn('Error in remote subscription:', e)\n        });\n        return new Promise((resolve, reject) => {\n            if (isConnected)\n                resolve();\n            else {\n                this.subscriptionClient.onConnected(resolve);\n                this.subscriptionClient.onDisconnected(reject);\n                this.subscriptionClient.onError(reject);\n            }\n        });\n    }\n    /**\n     * List the names of the rule parameters defined by the admin server. This can be\n     * used in some advanced use cases to confirm that the parameters a client wishes to\n     * reference are available.\n     *\n     * Only defined for remote clients.\n     */\n    async getRuleParameterKeys() {\n        if (await this.running === false) {\n            throw new Error('Cannot query rule parameters before the server is started');\n        }\n        if (!this.schema.queryTypeDefined('ruleParameterKeys')) {\n            // If this endpoint isn't supported, that's because parameters aren't supported\n            // at all, so we can safely report that immediately.\n            return [];\n        }\n        let result = await this.queryMockServer(`query GetRuleParameterNames {\n                ruleParameterKeys\n            }`);\n        return result.ruleParameterKeys;\n    }\n}\nexports.AdminClient = AdminClient;\n//# sourceMappingURL=admin-client.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.getSingleSelectedFieldName = getSingleSelectedFieldName;\nfunction isFieldSelection(selection) {\n    return selection.kind === 'Field';\n}\nfunction getQuerySelectionNode(gqlQuery) {\n    const { definitions } = gqlQuery;\n    if (definitions.length !== 1 || definitions[0].kind !== 'OperationDefinition') {\n        throw new Error(\"Admin queries must be defined as a single operation definition\");\n    }\n    return definitions[0].selectionSet;\n}\n// Enforces that the query selects only one field (this is relevant for subscriptions),\n// and extracts and returns the name of that field.\nfunction getSingleSelectedFieldName(query) {\n    const selectedFieldNames = getQuerySelectionNode(query.query)\n        .selections\n        .filter(isFieldSelection)\n        .map(selection => selection.name.value);\n    if (selectedFieldNames.length !== 1) {\n        throw new Error(`This admin query must select only one field, but it selects ${selectedFieldNames.length}: ${selectedFieldNames.join(', ')}`);\n    }\n    return selectedFieldNames[0];\n}\n//# sourceMappingURL=admin-query.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.MockedEndpointClient = void 0;\nclass MockedEndpointClient {\n    constructor(id, explanation, endpointDataGetter) {\n        this.id = id;\n        this.explanation = explanation;\n        this.endpointDataGetter = endpointDataGetter;\n    }\n    async getMockedEndpointData() {\n        const mockedEndpointData = await this.endpointDataGetter();\n        if (mockedEndpointData === null)\n            throw new Error(\"Can't get seen requests for unknown mocked endpoint\");\n        else\n            return mockedEndpointData;\n    }\n    async getSeenRequests() {\n        return (await this.getMockedEndpointData()).seenRequests;\n    }\n    async isPending() {\n        return (await this.getMockedEndpointData()).isPending;\n    }\n    toString() {\n        if (this.explanation) {\n            return \"Mocked endpoint: \" + this.explanation;\n        }\n        else {\n            return Object.toString.call(this);\n        }\n    }\n}\nexports.MockedEndpointClient = MockedEndpointClient;\n//# sourceMappingURL=mocked-endpoint-client.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.MockttpAdminRequestBuilder = void 0;\nconst _ = require(\"lodash\");\nconst graphql_tag_1 = require(\"graphql-tag\");\nconst request_utils_1 = require(\"../util/request-utils\");\nconst header_utils_1 = require(\"../util/header-utils\");\nconst mocked_endpoint_client_1 = require(\"./mocked-endpoint-client\");\nconst rule_serialization_1 = require(\"../rules/rule-serialization\");\nfunction normalizeHttpMessage(message, event) {\n    if (message.timingEvents) {\n        // Timing events are serialized as raw JSON\n        message.timingEvents = JSON.parse(message.timingEvents);\n    }\n    else if (event !== 'tls-client-error' && event !== 'client-error') {\n        // For backwards compat, all except errors should have timing events if they're missing\n        message.timingEvents = {};\n    }\n    if (message.rawHeaders) {\n        message.rawHeaders = JSON.parse(message.rawHeaders);\n        // We use raw headers where possible to derive headers, instead of using any pre-derived\n        // header data, for maximum accuracy (and to avoid any need to query for both).\n        message.headers = (0, header_utils_1.rawHeadersToObject)(message.rawHeaders);\n    }\n    else if (message.headers) {\n        // Backward compat for older servers:\n        message.headers = JSON.parse(message.headers);\n        message.rawHeaders = (0, header_utils_1.objectHeadersToRaw)(message.headers);\n    }\n    if (message.rawTrailers) {\n        message.rawTrailers = JSON.parse(message.rawTrailers);\n        message.trailers = (0, header_utils_1.rawHeadersToObject)(message.rawTrailers);\n    }\n    else if (message.rawHeaders && message.body) { // HTTP events with bodies should have trailers\n        message.rawTrailers = [];\n        message.trailers = {};\n    }\n    if (message.body !== undefined) {\n        // Body is serialized as the raw encoded buffer in base64\n        message.body = (0, request_utils_1.buildBodyReader)(Buffer.from(message.body, 'base64'), message.headers);\n    }\n    // For backwards compat, all except errors should have tags if they're missing\n    if (!message.tags)\n        message.tags = [];\n    if (event?.startsWith('tls-')) {\n        // TLS passthrough & error events should have raw JSON socket metadata:\n        if (message.tlsMetadata) {\n            message.tlsMetadata = JSON.parse(message.tlsMetadata);\n        }\n        else {\n            // For old servers, just use empty metadata:\n            message.tlsMetadata = {};\n        }\n    }\n}\nfunction normalizeWebSocketMessage(message) {\n    // Timing events are serialized as raw JSON\n    message.timingEvents = JSON.parse(message.timingEvents);\n    // Content is serialized as the raw encoded buffer in base64\n    message.content = Buffer.from(message.content, 'base64');\n}\n/**\n * This is part of Mockttp's experimental 'pluggable admin' API. This may change\n * unpredictably, even in minor releases.\n *\n * @internal\n */\nclass MockttpAdminRequestBuilder {\n    constructor(schema) {\n        this.schema = schema;\n        this.getEndpointDataGetter = (adminClient, ruleId) => async () => {\n            let result = await adminClient.sendQuery({\n                query: (0, graphql_tag_1.default) `\n                    query GetEndpointData($id: ID!) {\n                        mockedEndpoint(id: $id) {\n                            seenRequests {\n                                id,\n                                protocol,\n                                method,\n                                url,\n                                path,\n                                hostname\n\n                                ${this.schema.typeHasField('Request', 'rawHeaders')\n                    ? 'rawHeaders'\n                    : 'headers'}\n\n                                body,\n                                ${this.schema.asOptionalField('Request', 'timingEvents')}\n                                ${this.schema.asOptionalField('Request', 'httpVersion')}\n                            }\n                            ${this.schema.asOptionalField('MockedEndpoint', 'isPending')}\n                        }\n                    }\n                `,\n                variables: { id: ruleId }\n            });\n            const mockedEndpoint = result.mockedEndpoint;\n            if (!mockedEndpoint)\n                return null;\n            mockedEndpoint.seenRequests.forEach(req => normalizeHttpMessage(req));\n            return mockedEndpoint;\n        };\n    }\n    buildAddRequestRulesQuery(rules, reset, adminStream) {\n        const requestName = (reset ? 'Set' : 'Add') + 'Rules';\n        const mutationName = (reset ? 'set' : 'add') + 'Rules';\n        const serializedRules = rules.map((rule) => {\n            const serializedRule = (0, rule_serialization_1.serializeRuleData)(rule, adminStream);\n            if (!this.schema.typeHasInputField('MockRule', 'id')) {\n                delete serializedRule.id;\n            }\n            return serializedRule;\n        });\n        return {\n            query: (0, graphql_tag_1.default) `\n                mutation ${requestName}($newRules: [MockRule!]!) {\n                    endpoints: ${mutationName}(input: $newRules) {\n                        id,\n                        ${this.schema.asOptionalField('MockedEndpoint', 'explanation')}\n                    }\n                }\n            `,\n            variables: {\n                newRules: serializedRules\n            },\n            transformResponse: (response, { adminClient }) => {\n                return response.endpoints.map(({ id, explanation }) => new mocked_endpoint_client_1.MockedEndpointClient(id, explanation, this.getEndpointDataGetter(adminClient, id)));\n            }\n        };\n    }\n    buildAddWebSocketRulesQuery(rules, reset, adminStream) {\n        // Seperate and simpler than buildAddRequestRulesQuery, because it doesn't have to\n        // deal with backward compatibility.\n        const requestName = (reset ? 'Set' : 'Add') + 'WebSocketRules';\n        const mutationName = (reset ? 'set' : 'add') + 'WebSocketRules';\n        const serializedRules = rules.map((rule) => (0, rule_serialization_1.serializeRuleData)(rule, adminStream));\n        return {\n            query: (0, graphql_tag_1.default) `\n                mutation ${requestName}($newRules: [WebSocketMockRule!]!) {\n                    endpoints: ${mutationName}(input: $newRules) {\n                        id,\n                        explanation\n                    }\n                }\n            `,\n            variables: {\n                newRules: serializedRules\n            },\n            transformResponse: (response, { adminClient }) => {\n                return response.endpoints.map(({ id, explanation }) => new mocked_endpoint_client_1.MockedEndpointClient(id, explanation, this.getEndpointDataGetter(adminClient, id)));\n            }\n        };\n    }\n    ;\n    buildMockedEndpointsQuery() {\n        return {\n            query: (0, graphql_tag_1.default) `\n                query GetAllEndpointData {\n                    mockedEndpoints {\n                        id,\n                        ${this.schema.asOptionalField('MockedEndpoint', 'explanation')}\n                    }\n                }\n            `,\n            transformResponse: (response, { adminClient }) => {\n                const mockedEndpoints = response.mockedEndpoints;\n                return mockedEndpoints.map(({ id, explanation }) => new mocked_endpoint_client_1.MockedEndpointClient(id, explanation, this.getEndpointDataGetter(adminClient, id)));\n            }\n        };\n    }\n    buildPendingEndpointsQuery() {\n        return {\n            query: (0, graphql_tag_1.default) `\n                query GetPendingEndpointData {\n                    pendingEndpoints {\n                        id,\n                        explanation\n                    }\n                }\n            `,\n            transformResponse: (response, { adminClient }) => {\n                const pendingEndpoints = response.pendingEndpoints;\n                return pendingEndpoints.map(({ id, explanation }) => new mocked_endpoint_client_1.MockedEndpointClient(id, explanation, this.getEndpointDataGetter(adminClient, id)));\n            }\n        };\n    }\n    buildSubscriptionRequest(event) {\n        // Note the asOptionalField checks - these are a quick hack for backward compatibility,\n        // introspecting the server schema to avoid requesting fields that don't exist on old servers.\n        const query = {\n            'request-initiated': (0, graphql_tag_1.default) `subscription OnRequestInitiated {\n                requestInitiated {\n                    id\n                    protocol\n                    method\n                    url\n                    path\n                    ${this.schema.asOptionalField('InitiatedRequest', 'remoteIpAddress')}\n                    ${this.schema.asOptionalField('InitiatedRequest', 'remotePort')}\n                    hostname\n\n                    ${this.schema.typeHasField('InitiatedRequest', 'rawHeaders')\n                ? 'rawHeaders'\n                : 'headers'}\n                    timingEvents\n                    httpVersion\n                    ${this.schema.asOptionalField('InitiatedRequest', 'tags')}\n                }\n            }`,\n            request: (0, graphql_tag_1.default) `subscription OnRequest {\n                requestReceived {\n                    id\n                    ${this.schema.asOptionalField('Request', 'matchedRuleId')}\n                    protocol\n                    method\n                    url\n                    path\n                    ${this.schema.asOptionalField('Request', 'remoteIpAddress')}\n                    ${this.schema.asOptionalField('Request', 'remotePort')}\n                    hostname\n\n                    ${this.schema.typeHasField('Request', 'rawHeaders')\n                ? 'rawHeaders'\n                : 'headers'}\n\n                    body\n                    ${this.schema.asOptionalField('Request', 'rawTrailers')}\n\n                    ${this.schema.asOptionalField('Request', 'timingEvents')}\n                    ${this.schema.asOptionalField('Request', 'httpVersion')}\n                    ${this.schema.asOptionalField('Request', 'tags')}\n                }\n            }`,\n            response: (0, graphql_tag_1.default) `subscription OnResponse {\n                responseCompleted {\n                    id\n                    statusCode\n                    statusMessage\n\n                    ${this.schema.typeHasField('Response', 'rawHeaders')\n                ? 'rawHeaders'\n                : 'headers'}\n\n                    body\n                    ${this.schema.asOptionalField('Response', 'rawTrailers')}\n\n                    ${this.schema.asOptionalField('Response', 'timingEvents')}\n                    ${this.schema.asOptionalField('Response', 'tags')}\n                }\n            }`,\n            'websocket-request': (0, graphql_tag_1.default) `subscription OnWebSocketRequest {\n                webSocketRequest {\n                    id\n                    matchedRuleId\n                    protocol\n                    method\n                    url\n                    path\n                    remoteIpAddress\n                    remotePort\n                    hostname\n\n                    rawHeaders\n                    body\n                    ${this.schema.asOptionalField('Request', 'rawTrailers')}\n\n                    timingEvents\n                    httpVersion\n                    tags\n                }\n            }`,\n            'websocket-accepted': (0, graphql_tag_1.default) `subscription OnWebSocketAccepted {\n                webSocketAccepted {\n                    id\n                    statusCode\n                    statusMessage\n\n                    rawHeaders\n                    body\n                    ${this.schema.asOptionalField('Response', 'rawTrailers')}\n\n                    timingEvents\n                    tags\n                }\n            }`,\n            'websocket-message-received': (0, graphql_tag_1.default) `subscription OnWebSocketMessageReceived {\n                webSocketMessageReceived {\n                    streamId\n                    direction\n                    content\n                    isBinary\n                    eventTimestamp\n\n                    timingEvents\n                    tags\n                }\n            }`,\n            'websocket-message-sent': (0, graphql_tag_1.default) `subscription OnWebSocketMessageSent {\n                webSocketMessageSent {\n                    streamId\n                    direction\n                    content\n                    isBinary\n                    eventTimestamp\n\n                    timingEvents\n                    tags\n                }\n            }`,\n            'websocket-close': (0, graphql_tag_1.default) `subscription OnWebSocketClose {\n                webSocketClose {\n                    streamId\n\n                    closeCode\n                    closeReason\n\n                    timingEvents\n                    tags\n                }\n            }`,\n            abort: (0, graphql_tag_1.default) `subscription OnAbort {\n                requestAborted {\n                    id,\n                    protocol,\n                    method,\n                    url,\n                    path,\n                    hostname,\n\n                    ${this.schema.typeHasField('Request', 'rawHeaders')\n                ? 'rawHeaders'\n                : 'headers'}\n\n                    ${this.schema.asOptionalField('Request', 'timingEvents')}\n                    ${this.schema.asOptionalField('Request', 'tags')}\n                    ${this.schema.asOptionalField('AbortedRequest', 'error')}\n                }\n            }`,\n            'tls-passthrough-opened': (0, graphql_tag_1.default) `subscription OnTlsPassthroughOpened {\n                tlsPassthroughOpened {\n                    id\n                    upstreamPort\n\n                    hostname\n                    remoteIpAddress\n                    remotePort\n                    tags\n                    timingEvents\n                    ${this.schema.asOptionalField('TlsPassthroughEvent', 'tlsMetadata')}\n                }\n            }`,\n            'tls-passthrough-closed': (0, graphql_tag_1.default) `subscription OnTlsPassthroughClosed {\n                tlsPassthroughClosed {\n                    id\n                    upstreamPort\n\n                    hostname\n                    remoteIpAddress\n                    remotePort\n                    tags\n                    timingEvents\n                    ${this.schema.asOptionalField('TlsPassthroughEvent', 'tlsMetadata')}\n                }\n            }`,\n            'tls-client-error': (0, graphql_tag_1.default) `subscription OnTlsClientError {\n                failedTlsRequest {\n                    failureCause\n                    hostname\n                    remoteIpAddress\n                    ${this.schema.asOptionalField(['TlsHandshakeFailure', 'TlsRequest'], 'remotePort')}\n                    ${this.schema.asOptionalField(['TlsHandshakeFailure', 'TlsRequest'], 'tags')}\n                    ${this.schema.asOptionalField(['TlsHandshakeFailure', 'TlsRequest'], 'timingEvents')}\n                    ${this.schema.asOptionalField(['TlsHandshakeFailure', 'TlsRequest'], 'tlsMetadata')}\n                }\n            }`,\n            'client-error': (0, graphql_tag_1.default) `subscription OnClientError {\n                failedClientRequest {\n                    errorCode\n                    request {\n                        id\n                        timingEvents\n                        tags\n                        protocol\n                        httpVersion\n                        method\n                        url\n                        path\n\n                        ${this.schema.typeHasField('ClientErrorRequest', 'rawHeaders')\n                ? 'rawHeaders'\n                : 'headers'}\n\n                        ${this.schema.asOptionalField('ClientErrorRequest', 'remoteIpAddress')}\n                        ${this.schema.asOptionalField('ClientErrorRequest', 'remotePort')}\n                    }\n                    response {\n                        id\n                        timingEvents\n                        tags\n                        statusCode\n                        statusMessage\n\n                        ${this.schema.typeHasField('Response', 'rawHeaders')\n                ? 'rawHeaders'\n                : 'headers'}\n\n                        body\n                        ${this.schema.asOptionalField('Response', 'rawTrailers')}\n                    }\n                }\n            }`,\n            'rule-event': (0, graphql_tag_1.default) `subscription OnRuleEvent {\n                ruleEvent {\n                    requestId\n                    ruleId\n                    eventType\n                    eventData\n                }\n            }`\n        }[event];\n        if (!query)\n            return; // Unrecognized event, we can't subscribe to this.\n        return {\n            query,\n            transformResponse: (data) => {\n                if (event === 'client-error') {\n                    data.request = _.mapValues(data.request, (v) => \n                    // Normalize missing values to undefined to match the local result\n                    v === null ? undefined : v);\n                    normalizeHttpMessage(data.request, event);\n                    if (data.response) {\n                        normalizeHttpMessage(data.response, event);\n                    }\n                    else {\n                        data.response = 'aborted';\n                    }\n                }\n                else if (event === 'websocket-message-received' || event === 'websocket-message-sent') {\n                    normalizeWebSocketMessage(data);\n                }\n                else if (event === 'abort') {\n                    normalizeHttpMessage(data, event);\n                    data.error = data.error ? JSON.parse(data.error) : undefined;\n                }\n                else if (event === 'rule-event') {\n                    const { eventData } = data;\n                    // Events may include raw body data buffers, serialized as base64:\n                    if (eventData.rawBody !== undefined) {\n                        eventData.rawBody = Buffer.from(eventData.rawBody, 'base64');\n                    }\n                }\n                else {\n                    normalizeHttpMessage(data, event);\n                }\n                return data;\n            }\n        };\n    }\n}\nexports.MockttpAdminRequestBuilder = MockttpAdminRequestBuilder;\n//# sourceMappingURL=mockttp-admin-request-builder.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.MockttpClient = void 0;\nconst _ = require(\"lodash\");\nconst mockttp_1 = require(\"../mockttp\");\nconst admin_client_1 = require(\"./admin-client\");\nconst mockttp_admin_request_builder_1 = require(\"./mockttp-admin-request-builder\");\n/**\n * A Mockttp implementation, controlling a remote Mockttp admin server.\n *\n * A MockttpClient supports the exact same Mockttp API as MockttpServer, but rather\n * than directly using Node.js APIs to start a mock server and rewrite traffic, it\n * makes calls to a remote admin server to start a mock server and rewrite traffic\n * there. This is useful to allow proxy configuration from inside browser tests, and\n * to allow creating mock proxies that run on remote machines.\n */\nclass MockttpClient extends mockttp_1.AbstractMockttp {\n    constructor(options = {}) {\n        super(_.defaults(options, {\n            // Browser clients generally want cors enabled. For other clients, it doesn't hurt.\n            // TODO: Maybe detect whether we're in a browser in future\n            cors: true,\n        }));\n        this.reset = () => {\n            return this.adminClient.reset();\n        };\n        this.addRequestRules = async (...rules) => {\n            return this._addRequestRules(rules, false);\n        };\n        this.setRequestRules = async (...rules) => {\n            return this._addRequestRules(rules, true);\n        };\n        this.addWebSocketRules = async (...rules) => {\n            return this._addWsRules(rules, false);\n        };\n        this.setWebSocketRules = async (...rules) => {\n            return this._addWsRules(rules, true);\n        };\n        this._addRequestRules = async (rules, reset) => {\n            if (!this.requestBuilder)\n                throw new Error('Cannot add rules before the server is started');\n            const { adminStream } = this.adminClient;\n            return this.adminClient.sendQuery(this.requestBuilder.buildAddRequestRulesQuery(rules, reset, adminStream));\n        };\n        this._addWsRules = async (rules, reset) => {\n            if (!this.requestBuilder)\n                throw new Error('Cannot add rules before the server is started');\n            const { adminStream } = this.adminClient;\n            return this.adminClient.sendQuery(this.requestBuilder.buildAddWebSocketRulesQuery(rules, reset, adminStream));\n        };\n        this.mockServerOptions = options;\n        this.adminClient = new admin_client_1.AdminClient({\n            adminServerUrl: options.adminServerUrl,\n            requestOptions: options.client\n        });\n    }\n    enableDebug() {\n        return this.adminClient.enableDebug();\n    }\n    get url() {\n        return this.adminClient.metadata.http.mockRoot;\n    }\n    get port() {\n        return this.adminClient.metadata.http.port;\n    }\n    async start(port) {\n        await this.adminClient.start({\n            http: {\n                port,\n                options: this.mockServerOptions\n            }\n        });\n        this.requestBuilder = new mockttp_admin_request_builder_1.MockttpAdminRequestBuilder(this.adminClient.schema);\n    }\n    stop() {\n        return this.adminClient.stop();\n    }\n    async getMockedEndpoints() {\n        if (!this.requestBuilder)\n            throw new Error('Cannot query mocked endpoints before the server is started');\n        return this.adminClient.sendQuery(this.requestBuilder.buildMockedEndpointsQuery());\n    }\n    async getPendingEndpoints() {\n        if (!this.requestBuilder)\n            throw new Error('Cannot query pending endpoints before the server is started');\n        return this.adminClient.sendQuery(this.requestBuilder.buildPendingEndpointsQuery());\n    }\n    async getRuleParameterKeys() {\n        return this.adminClient.getRuleParameterKeys();\n    }\n    on(event, callback) {\n        if (event.startsWith('admin-client:')) {\n            // All MockttpClient events come from the internal admin-client instance:\n            this.adminClient.on(event.slice('admin-client:'.length), callback);\n            return Promise.resolve();\n        }\n        if (!this.requestBuilder)\n            throw new Error('Cannot subscribe to Mockttp events before the server is started');\n        const subRequest = this.requestBuilder.buildSubscriptionRequest(event);\n        if (!subRequest) {\n            // We just return an immediately promise if we don't recognize the event, which will quietly\n            // succeed but never call the corresponding callback (the same as the server and most event\n            // sources in the same kind of situation). This is what happens when the *client* doesn't\n            // recognize the event. Subscribe() below handles the unknown-to-server case.\n            console.warn(`Ignoring subscription for event unrecognized by Mockttp client: ${event}`);\n            return Promise.resolve();\n        }\n        return this.adminClient.subscribe(subRequest, callback);\n    }\n}\nexports.MockttpClient = MockttpClient;\n//# sourceMappingURL=mockttp-client.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.introspectionQuery = exports.SchemaIntrospector = void 0;\nconst _ = require(\"lodash\");\nclass SchemaIntrospector {\n    constructor(adminServerSchema) {\n        this.adminServerSchema = adminServerSchema;\n    }\n    queryTypeDefined(queryType) {\n        return this.typeHasField('Query', queryType);\n    }\n    isTypeDefined(typeName) {\n        return _.some(this.adminServerSchema.types, { name: typeName });\n    }\n    typeHasField(typeName, fieldName) {\n        const type = _.find(this.adminServerSchema.types, { name: typeName });\n        if (!type)\n            return false;\n        return !!_.find(type.fields, { name: fieldName });\n    }\n    asOptionalField(typeName, fieldName) {\n        const possibleNames = !Array.isArray(typeName) ? [typeName] : typeName;\n        const firstAvailableName = possibleNames.find((name) => this.isTypeDefined(name));\n        if (!firstAvailableName)\n            return '';\n        return (this.typeHasField(firstAvailableName, fieldName))\n            ? fieldName\n            : '';\n    }\n    typeHasInputField(typeName, fieldName) {\n        const type = _.find(this.adminServerSchema.types, { name: typeName });\n        if (!type)\n            return false;\n        return !!_.find(type.inputFields, { name: fieldName });\n    }\n}\nexports.SchemaIntrospector = SchemaIntrospector;\n// Taken from src/utilities/introspectionQuery.js in GraphQL-js\n// Copied directly, to avoid bundling the whole thing into frontend code.\nexports.introspectionQuery = `\n  query IntrospectionQuery {\n    __schema {\n      queryType { name }\n      mutationType { name }\n      subscriptionType { name }\n      types {\n        ...FullType\n      }\n      directives {\n        name\n        locations\n        args {\n          ...InputValue\n        }\n      }\n    }\n  }\n\n  fragment FullType on __Type {\n    kind\n    name\n    fields(includeDeprecated: true) {\n      name\n      args {\n        ...InputValue\n      }\n      type {\n        ...TypeRef\n      }\n      isDeprecated\n      deprecationReason\n    }\n    inputFields {\n      ...InputValue\n    }\n    interfaces {\n      ...TypeRef\n    }\n    enumValues(includeDeprecated: true) {\n      name\n      isDeprecated\n      deprecationReason\n    }\n    possibleTypes {\n      ...TypeRef\n    }\n  }\n\n  fragment InputValue on __InputValue {\n    name\n    type { ...TypeRef }\n    defaultValue\n  }\n\n  fragment TypeRef on __Type {\n    kind\n    name\n    ofType {\n      kind\n      name\n      ofType {\n        kind\n        name\n        ofType {\n          kind\n          name\n          ofType {\n            kind\n            name\n            ofType {\n              kind\n              name\n              ofType {\n                kind\n                name\n                ofType {\n                  kind\n                  name\n                }\n              }\n            }\n          }\n        }\n      }\n    }\n  }\n`;\n//# sourceMappingURL=schema-introspection.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.MockttpPluggableAdmin = exports.PluggableAdmin = exports.resetAdminServer = exports.MOCKTTP_PARAM_REF = exports.webSocketHandlers = exports.requestHandlers = exports.completionCheckers = exports.webSocketHandlerDefinitions = exports.requestHandlerDefinitions = exports.matchers = exports.RulePriority = exports.Method = void 0;\nexports.getLocal = getLocal;\nexports.getRemote = getRemote;\nexports.getAdminServer = getAdminServer;\nconst mockttp_client_1 = require(\"./client/mockttp-client\");\nvar types_1 = require(\"./types\");\nObject.defineProperty(exports, \"Method\", { enumerable: true, get: function () { return types_1.Method; } });\nObject.defineProperty(exports, \"RulePriority\", { enumerable: true, get: function () { return types_1.RulePriority; } });\n// Export rule data builders:\nconst matchers = require(\"./rules/matchers\");\nexports.matchers = matchers;\nconst requestHandlerDefinitions = require(\"./rules/requests/request-handler-definitions\");\nexports.requestHandlerDefinitions = requestHandlerDefinitions;\nconst webSocketHandlerDefinitions = require(\"./rules/websockets/websocket-handler-definitions\");\nexports.webSocketHandlerDefinitions = webSocketHandlerDefinitions;\nconst completionCheckers = require(\"./rules/completion-checkers\");\nexports.completionCheckers = completionCheckers;\n// We re-export definitions to pretend they're real handlers in the browser. This should be safe\n// because the missing methods (i.e. handle()) were always unusable in non-Node environments anyway.\n// In practice though, new browser code using this should actively use requestHandlerDefinitions instead.\n// In future, we should probably expose definitions only for both browsers & node, but that's a\n// breaking change.\nexports.requestHandlers = {\n    'SimpleHandler': requestHandlerDefinitions.SimpleHandlerDefinition,\n    'CallbackHandler': requestHandlerDefinitions.CallbackHandlerDefinition,\n    'StreamHandler': requestHandlerDefinitions.StreamHandlerDefinition,\n    'FileHandler': requestHandlerDefinitions.FileHandlerDefinition,\n    'PassThroughHandler': requestHandlerDefinitions.PassThroughHandlerDefinition,\n    'CloseConnectionHandler': requestHandlerDefinitions.CloseConnectionHandlerDefinition,\n    'TimeoutHandler': requestHandlerDefinitions.TimeoutHandlerDefinition,\n    'HandlerLookup': requestHandlerDefinitions.HandlerDefinitionLookup\n};\nexports.webSocketHandlers = {\n    'PassThroughWebSocketHandler': webSocketHandlerDefinitions.PassThroughWebSocketHandlerDefinition,\n    'CloseConnectionHandler': webSocketHandlerDefinitions.CloseConnectionHandlerDefinition,\n    'TimeoutHandler': webSocketHandlerDefinitions.TimeoutHandlerDefinition,\n    'WsHandlerLookup': webSocketHandlerDefinitions.WsHandlerDefinitionLookup\n};\nvar rule_parameters_1 = require(\"./rules/rule-parameters\");\nObject.defineProperty(exports, \"MOCKTTP_PARAM_REF\", { enumerable: true, get: function () { return rule_parameters_1.MOCKTTP_PARAM_REF; } });\n// Export the core API:\nfunction getLocal(options = {}) {\n    return new mockttp_client_1.MockttpClient(options);\n}\nfunction getRemote(options = {}) {\n    return new mockttp_client_1.MockttpClient(options);\n}\nfunction getAdminServer() {\n    throw new Error('Cannot set up an admin server within a browser');\n}\nvar admin_client_1 = require(\"./client/admin-client\");\nObject.defineProperty(exports, \"resetAdminServer\", { enumerable: true, get: function () { return admin_client_1.resetAdminServer; } });\nexports.PluggableAdmin = require(\"./pluggable-admin-api/pluggable-admin\");\nexports.MockttpPluggableAdmin = require(\"./pluggable-admin-api/mockttp-pluggable-admin\");\n//# sourceMappingURL=main.browser.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.AbstractMockttp = void 0;\nconst common_tags_1 = require(\"common-tags\");\nconst request_rule_builder_1 = require(\"./rules/requests/request-rule-builder\");\nconst websocket_rule_builder_1 = require(\"./rules/websockets/websocket-rule-builder\");\nconst types_1 = require(\"./types\");\n/**\n * @hidden\n */\nclass AbstractMockttp {\n    constructor(options) {\n        this.addRequestRule = (rule) => this.addRequestRules(rule).then((rules) => rules[0]);\n        this.addWebSocketRule = (rule) => this.addWebSocketRules(rule).then((rules) => rules[0]);\n        this.debug = options.debug || false;\n        this.corsOptions = options.cors || false;\n        this.recordTraffic = options.recordTraffic !== undefined\n            ? options.recordTraffic\n            : true;\n        this.suggestChanges = options.suggestChanges !== undefined\n            ? options.suggestChanges\n            : true;\n    }\n    get proxyEnv() {\n        return {\n            HTTP_PROXY: this.url,\n            HTTPS_PROXY: this.url\n        };\n    }\n    urlFor(path) {\n        return this.url + path;\n    }\n    forAnyRequest() {\n        return new request_rule_builder_1.RequestRuleBuilder(this.addRequestRule);\n    }\n    forUnmatchedRequest() {\n        return new request_rule_builder_1.RequestRuleBuilder(this.addRequestRule)\n            .asPriority(types_1.RulePriority.FALLBACK);\n    }\n    forGet(url) {\n        return new request_rule_builder_1.RequestRuleBuilder(types_1.Method.GET, url, this.addRequestRule);\n    }\n    forPost(url) {\n        return new request_rule_builder_1.RequestRuleBuilder(types_1.Method.POST, url, this.addRequestRule);\n    }\n    forPut(url) {\n        return new request_rule_builder_1.RequestRuleBuilder(types_1.Method.PUT, url, this.addRequestRule);\n    }\n    forDelete(url) {\n        return new request_rule_builder_1.RequestRuleBuilder(types_1.Method.DELETE, url, this.addRequestRule);\n    }\n    forPatch(url) {\n        return new request_rule_builder_1.RequestRuleBuilder(types_1.Method.PATCH, url, this.addRequestRule);\n    }\n    forHead(url) {\n        return new request_rule_builder_1.RequestRuleBuilder(types_1.Method.HEAD, url, this.addRequestRule);\n    }\n    forOptions(url) {\n        if (this.corsOptions) {\n            throw new Error((0, common_tags_1.stripIndent) `\n                Cannot mock OPTIONS requests with CORS enabled.\n\n                You can disable CORS by passing { cors: false } to getLocal/getRemote, but this may cause issues ${''}connecting to your mock server from browsers, unless you mock all required OPTIONS preflight ${''}responses by hand.\n            `);\n        }\n        return new request_rule_builder_1.RequestRuleBuilder(types_1.Method.OPTIONS, url, this.addRequestRule);\n    }\n    forJsonRpcRequest(match = {}) {\n        return new request_rule_builder_1.RequestRuleBuilder(this.addRequestRule)\n            .withJsonBodyIncluding({\n            jsonrpc: '2.0',\n            ...(match.method ? { method: match.method } : {}),\n            ...(match.params ? { params: match.params } : {})\n        });\n    }\n    forAnyWebSocket() {\n        return new websocket_rule_builder_1.WebSocketRuleBuilder(this.addWebSocketRule);\n    }\n}\nexports.AbstractMockttp = AbstractMockttp;\n//# sourceMappingURL=mockttp.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.MockttpAdminRequestBuilder = exports.MockttpAdminPlugin = void 0;\nclass MockttpAdminPlugin {\n    constructor() {\n        throw new Error(\"MockttpAdminPlugin cannot be used within a browser\");\n    }\n}\nexports.MockttpAdminPlugin = MockttpAdminPlugin;\nvar mockttp_admin_request_builder_1 = require(\"../client/mockttp-admin-request-builder\");\nObject.defineProperty(exports, \"MockttpAdminRequestBuilder\", { enumerable: true, get: function () { return mockttp_admin_request_builder_1.MockttpAdminRequestBuilder; } });\n//# sourceMappingURL=mockttp-pluggable-admin.browser.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Serialization = exports.AdminClient = exports.AdminServer = void 0;\nclass AdminServer {\n    constructor() {\n        throw new Error(\"AdminServer cannot be used within a browser\");\n    }\n}\nexports.AdminServer = AdminServer;\nvar admin_client_1 = require(\"../client/admin-client\");\nObject.defineProperty(exports, \"AdminClient\", { enumerable: true, get: function () { return admin_client_1.AdminClient; } });\nexports.Serialization = require(\"../serialization/serialization\");\n//# sourceMappingURL=pluggable-admin.browser.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.BaseRuleBuilder = void 0;\nconst lodash_1 = require(\"lodash\");\nconst types_1 = require(\"../types\");\nconst completion_checkers_1 = require(\"./completion-checkers\");\nconst matchers_1 = require(\"./matchers\");\n/**\n * @class BaseRuleBuilder\n *\n * Defines the base matching & completion methods, used for both normal\n * and websocket request handling, but excluding the handling itself\n * which differs between the two cases.\n */\nclass BaseRuleBuilder {\n    /**\n     * Mock rule builders should be constructed through the Mockttp instance you're\n     * using, not directly. You shouldn't ever need to call this constructor.\n     */\n    constructor() {\n        this.matchers = [];\n        this.priority = types_1.RulePriority.DEFAULT;\n    }\n    buildBaseRuleData() {\n        return {\n            priority: this.priority,\n            matchers: this.matchers,\n            completionChecker: this.completionChecker\n        };\n    }\n    /**\n     * Set the rule priority. Any matching rule with a higher priority will always\n     * take precedence over a matching lower-priority rule, unless the higher rule\n     * has an explicit completion check (like `.once()`) that has already been\n     * completed.\n     *\n     * The RulePriority enum defines the standard values useful for most cases,\n     * but any positive number may be used for advanced configurations.\n     *\n     * In many cases it may be simpler to use forUnmatchedRequest() to set a fallback\n     * rule explicitly, rather than manually setting the priority here.\n     */\n    asPriority(priority) {\n        this.priority = priority;\n        return this;\n    }\n    /**\n     * Match only requests sent to the given host, i.e. the full hostname plus\n     * port included in the request.\n     *\n     * This can behave somewhat confusingly when matching against the default\n     * ports for a protocol (i.e. 80/443), or when specifying a hostname here\n     * without specifying the port. In those cases it's usually better to use\n     * forHostname and/or forPort instead to explicit match the content you're\n     * interested in.\n     *\n     * @category Matching\n     */\n    forHost(host) {\n        this.matchers.push(new matchers_1.HostMatcher(host));\n        return this;\n    }\n    /**\n     * Match only requests sent to the given hostname, ignoring the port.\n     *\n     * @category Matching\n     */\n    forHostname(hostname) {\n        this.matchers.push(new matchers_1.HostnameMatcher(hostname));\n        return this;\n    }\n    /**\n     * Match only requests sent to the given port.\n     *\n     * @category Matching\n     */\n    forPort(port) {\n        this.matchers.push(new matchers_1.PortMatcher(port));\n        return this;\n    }\n    /**\n     * Match only requests that include the given headers.\n     * @category Matching\n     */\n    withHeaders(headers) {\n        this.matchers.push(new matchers_1.HeaderMatcher(headers));\n        return this;\n    }\n    /**\n     * Match only requests that include the given query parameters.\n     * @category Matching\n     */\n    withQuery(query) {\n        this.matchers.push(new matchers_1.QueryMatcher(query));\n        return this;\n    }\n    /**\n     * Match only requests that include the exact query string provided.\n     * The query string must start with a ? or be entirely empty.\n     * @category Matching\n     */\n    withExactQuery(query) {\n        this.matchers.push(new matchers_1.ExactQueryMatcher(query));\n        return this;\n    }\n    /**\n     * Match only requests whose bodies include the given URL-encoded form data.\n     * @category Matching\n     */\n    withForm(formData) {\n        this.matchers.push(new matchers_1.FormDataMatcher(formData));\n        return this;\n    }\n    /**\n     * Match only requests whose bodies include the given multipart form data.\n     *\n     * This can take any number of form parts to look for. Each part is specified\n     * with {@link MultipartFieldMatchCondition} object containing one or more of\n     * `name` (string), `filename` (string) and `content` (string or buffer) as\n     * fields to match against in the form data.\n     *\n     * Requests are matched if all conditions match at least one part in the\n     * request's form data.\n     *\n     * @category Matching\n     */\n    withMultipartForm(...matchConditions) {\n        this.matchers.push(new matchers_1.MultipartFormDataMatcher(matchConditions));\n        return this;\n    }\n    /**\n     * Match only requests whose bodies either exactly match the given string\n     * (if a string is passed) or whose bodies match a regular expression\n     * (if a regex is passed).\n     * @category Matching\n     */\n    withBody(content) {\n        this.matchers.push((0, lodash_1.isString)(content)\n            ? new matchers_1.RawBodyMatcher(content)\n            : new matchers_1.RegexBodyMatcher(content));\n        return this;\n    }\n    /**\n     * Match only requests whose bodies include the given string.\n     * @category Matching\n     */\n    withBodyIncluding(content) {\n        this.matchers.push(new matchers_1.RawBodyIncludesMatcher(content));\n        return this;\n    }\n    /**\n     * Match only requests whose bodies exactly match the given\n     * object, when parsed as JSON.\n     *\n     * Note that this only tests that the body can be parsed\n     * as JSON - it doesn't require a content-type header.\n     * @category Matching\n     */\n    withJsonBody(json) {\n        this.matchers.push(new matchers_1.JsonBodyMatcher(json));\n        return this;\n    }\n    /**\n     * Match only requests whose bodies match (contain equivalent\n     * values, ignoring extra values) the given object, when\n     * parsed as JSON. Matching behaviour is the same as Lodash's\n     * _.isMatch method.\n     *\n     * Note that this only tests that the body can be parsed\n     * as JSON - it doesn't require a content-type header.\n     * @category Matching\n     */\n    withJsonBodyIncluding(json) {\n        this.matchers.push(new matchers_1.JsonBodyFlexibleMatcher(json));\n        return this;\n    }\n    /**\n     * Match only requests that include the given cookies\n     * @category Matching\n     */\n    withCookie(cookie) {\n        this.matchers.push(new matchers_1.CookieMatcher(cookie));\n        return this;\n    }\n    /**\n     * Match only requests sent with the given protocol.\n     * @category Matching\n     */\n    withProtocol(protocol) {\n        this.matchers.push(new matchers_1.ProtocolMatcher(protocol));\n        return this;\n    }\n    /**\n     * Match only requests whose absolute url matches the given RegExp.\n     * @category Matching\n     */\n    withUrlMatching(pattern) {\n        this.matchers.push(new matchers_1.RegexUrlMatcher(pattern));\n        return this;\n    }\n    /**\n     * Match only requests when the callback returns true\n     * @category Matching\n     */\n    matching(content) {\n        this.matchers.push(new matchers_1.CallbackMatcher(content));\n        return this;\n    }\n    /**\n     * Run this rule forever, for all matching requests\n     * @category Completion\n     */\n    always() {\n        this.completionChecker = new completion_checkers_1.Always();\n        return this;\n    }\n    /**\n     * Run this rule only once, for the first matching request\n     * @category Completion\n     */\n    once() {\n        this.completionChecker = new completion_checkers_1.Once();\n        return this;\n    }\n    /**\n     * Run this rule twice, for the first two matching requests\n     * @category Completion\n     */\n    twice() {\n        this.completionChecker = new completion_checkers_1.Twice();\n        return this;\n    }\n    /**\n     * Run this rule three times, for the first three matching requests\n     * @category Completion\n     */\n    thrice() {\n        this.completionChecker = new completion_checkers_1.Thrice();\n        return this;\n    }\n    /**\n     * Run this rule the given number of times, for the first matching requests\n     * @category Completion\n     */\n    times(n) {\n        this.completionChecker = new completion_checkers_1.NTimes(n);\n        return this;\n    }\n}\nexports.BaseRuleBuilder = BaseRuleBuilder;\n//# sourceMappingURL=base-rule-builder.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.CompletionCheckerLookup = exports.NTimes = exports.Thrice = exports.Twice = exports.Once = exports.Always = void 0;\nconst serialization_1 = require(\"../serialization/serialization\");\nclass Always extends serialization_1.Serializable {\n    constructor() {\n        super(...arguments);\n        this.type = 'always';\n    }\n    isComplete() {\n        return false;\n    }\n    explain(seenRequestCount) {\n        return explainUntil(seenRequestCount, Infinity, 'always');\n    }\n}\nexports.Always = Always;\nclass Once extends serialization_1.Serializable {\n    constructor() {\n        super(...arguments);\n        this.type = 'once';\n    }\n    isComplete(seenRequestCount) {\n        return seenRequestCount >= 1;\n    }\n    explain(seenRequestCount) {\n        return explainUntil(seenRequestCount, 1, 'once');\n    }\n}\nexports.Once = Once;\nclass Twice extends serialization_1.Serializable {\n    constructor() {\n        super(...arguments);\n        this.type = 'twice';\n    }\n    isComplete(seenRequestCount) {\n        return seenRequestCount >= 2;\n    }\n    explain(seenRequestCount) {\n        return explainUntil(seenRequestCount, 2, 'twice');\n    }\n}\nexports.Twice = Twice;\nclass Thrice extends serialization_1.Serializable {\n    constructor() {\n        super(...arguments);\n        this.type = 'thrice';\n    }\n    isComplete(seenRequestCount) {\n        return seenRequestCount >= 3;\n    }\n    explain(seenRequestCount) {\n        return explainUntil(seenRequestCount, 3, 'thrice');\n    }\n}\nexports.Thrice = Thrice;\nclass NTimes extends serialization_1.Serializable {\n    constructor(count) {\n        super();\n        this.count = count;\n        this.type = 'times';\n    }\n    isComplete(seenRequestCount) {\n        return seenRequestCount >= this.count;\n    }\n    explain(seenRequestCount) {\n        return explainUntil(seenRequestCount, this.count, `${this.count} times`);\n    }\n}\nexports.NTimes = NTimes;\nexports.CompletionCheckerLookup = {\n    'always': Always,\n    'once': Once,\n    'twice': Twice,\n    'thrice': Thrice,\n    'times': NTimes\n};\nfunction explainUntil(seen, n, name) {\n    if (seen === undefined) {\n        // Generic explainer, without the specific count\n        return name;\n    }\n    else {\n        return name + \" \" + (seen < n ? `(seen ${seen})` : \"(done)\");\n    }\n}\n//# sourceMappingURL=completion-checkers.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.MatcherLookup = exports.CallbackMatcher = exports.CookieMatcher = exports.JsonBodyFlexibleMatcher = exports.JsonBodyMatcher = exports.RegexBodyMatcher = exports.RawBodyIncludesMatcher = exports.RawBodyMatcher = exports.MultipartFormDataMatcher = exports.FormDataMatcher = exports.QueryMatcher = exports.ExactQueryMatcher = exports.HeaderMatcher = exports.RegexUrlMatcher = exports.RegexPathMatcher = exports.SimplePathMatcher = exports.PortMatcher = exports.HostnameMatcher = exports.HostMatcher = exports.ProtocolMatcher = exports.MethodMatcher = exports.WildcardMatcher = void 0;\nexports.matchesAll = matchesAll;\nexports.explainMatchers = explainMatchers;\nconst _ = require(\"lodash\");\nconst url = require(\"url\");\nconst common_tags_1 = require(\"common-tags\");\nconst multipart = require(\"parse-multipart-data\");\nconst types_1 = require(\"../types\");\nconst url_1 = require(\"../util/url\");\nconst request_utils_1 = require(\"../util/request-utils\");\nconst serialization_1 = require(\"../serialization/serialization\");\nconst body_serialization_1 = require(\"../serialization/body-serialization\");\nfunction unescapeRegexp(input) {\n    return input.replace(/\\\\\\//g, '/');\n}\nclass WildcardMatcher extends serialization_1.Serializable {\n    constructor() {\n        super(...arguments);\n        this.type = 'wildcard';\n    }\n    matches() {\n        return true;\n    }\n    explain() {\n        return 'for anything';\n    }\n}\nexports.WildcardMatcher = WildcardMatcher;\nclass MethodMatcher extends serialization_1.Serializable {\n    constructor(method) {\n        super();\n        this.method = method;\n        this.type = 'method';\n    }\n    matches(request) {\n        return request.method === types_1.Method[this.method];\n    }\n    explain() {\n        return `making ${types_1.Method[this.method]}s`;\n    }\n}\nexports.MethodMatcher = MethodMatcher;\nclass ProtocolMatcher extends serialization_1.Serializable {\n    constructor(protocol) {\n        super();\n        this.protocol = protocol;\n        this.type = 'protocol';\n        if (protocol !== \"http\" &&\n            protocol !== \"https\" &&\n            protocol !== \"ws\" &&\n            protocol !== \"wss\") {\n            throw new Error(\"Invalid protocol: protocol can only be 'http', 'https', 'ws' or 'wss'\");\n        }\n    }\n    matches(request) {\n        return request.protocol === this.protocol;\n    }\n    explain() {\n        return `for protocol ${this.protocol}`;\n    }\n}\nexports.ProtocolMatcher = ProtocolMatcher;\nclass HostMatcher extends serialization_1.Serializable {\n    constructor(host) {\n        super();\n        this.host = host;\n        this.type = 'host';\n        // Validate the hostname. Goal here isn't to catch every bad hostname, but allow\n        // every good hostname, and provide friendly errors for obviously bad hostnames.\n        if (host.includes('/')) {\n            throw new Error(\"Invalid hostname: hostnames can't contain slashes\");\n        }\n        else if (host.includes('?')) {\n            throw new Error(\"Invalid hostname: hostnames can't contain query strings\");\n        }\n        else if (!host.match(/^([a-zA-Z0-9\\-]+\\.)*[a-zA-Z0-9\\-]+(:\\d+)?$/)) { // Port optional\n            throw new Error(\"Hostname is invalid\");\n        }\n    }\n    matches(request) {\n        const parsedUrl = new url.URL(request.url);\n        if ((this.host.endsWith(':80') && request.protocol === 'http') ||\n            (this.host.endsWith(':443') && request.protocol === 'https')) {\n            // On default ports, our URL normalization erases an explicit port, so that a\n            // :80 here will never match anything. This handles that case: if you send HTTP\n            // traffic on port 80 then the port is blank, but it should match for 'hostname:80'.\n            return parsedUrl.hostname === this.host.split(':')[0] && parsedUrl.port === '';\n        }\n        else {\n            return parsedUrl.host === this.host;\n        }\n    }\n    explain() {\n        return `for host ${this.host}`;\n    }\n}\nexports.HostMatcher = HostMatcher;\nclass HostnameMatcher extends serialization_1.Serializable {\n    constructor(hostname) {\n        super();\n        this.hostname = hostname;\n        this.type = 'hostname';\n        // Validate the hostname. Goal here isn't to catch every bad hostname, but allow\n        // every good hostname, and provide friendly errors for obviously bad hostnames.\n        if (hostname.includes('/')) {\n            throw new Error(\"Invalid hostname: hostnames can't contain slashes\");\n        }\n        else if (hostname.includes('?')) {\n            throw new Error(\"Invalid hostname: hostnames can't contain query strings\");\n        }\n        else if (!hostname.match(/^([a-zA-Z0-9\\-]+\\.)*[a-zA-Z0-9\\-]+$/)) { // No port\n            throw new Error(\"Hostname is invalid\");\n        }\n    }\n    matches(request) {\n        return new url.URL(request.url).hostname === this.hostname;\n    }\n    explain() {\n        return `for hostname ${this.hostname}`;\n    }\n}\nexports.HostnameMatcher = HostnameMatcher;\nclass PortMatcher extends serialization_1.Serializable {\n    constructor(port) {\n        super();\n        this.type = 'port';\n        this.port = port.toString();\n    }\n    matches(request) {\n        const parsedUrl = new url.URL(request.url);\n        if ((this.port === '80' && request.protocol === 'http') ||\n            (this.port === '443' && request.protocol === 'https')) {\n            // The port is erased during our URL preprocessing if it's the default,\n            // so for those cases we have to match that separately:\n            return parsedUrl.port === '';\n        }\n        else {\n            return new url.URL(request.url).port === this.port;\n        }\n    }\n    explain() {\n        return `for port ${this.port}`;\n    }\n}\nexports.PortMatcher = PortMatcher;\nclass SimplePathMatcher extends serialization_1.Serializable {\n    constructor(path) {\n        super();\n        this.path = path;\n        this.type = 'simple-path';\n        if (!this.path)\n            throw new Error('Invalid URL: URL to match must not be empty');\n        let { search, query } = url.parse(this.path, true);\n        if (search) {\n            throw new Error((0, common_tags_1.oneLine) `\n                Tried to match a path that contained a query (${search}).\n                To match query parameters, use .withQuery(${JSON.stringify(query)}) instead,\n                or .withExactQuery('${search}') to match this exact query string.\n            `);\n        }\n        (0, url_1.normalizeUrl)(this.path); // Fail if URL can't be normalized\n    }\n    matches(request) {\n        const expectedUrl = (0, url_1.normalizeUrl)(this.path);\n        const reqUrl = (0, url_1.normalizeUrl)(request.url);\n        // reqUrl is always absolute, expectedUrl can be absolute, relative or protocolless-absolute\n        if ((0, url_1.isRelativeUrl)(expectedUrl)) {\n            // Match the path only, for any host\n            return (0, url_1.getPathFromAbsoluteUrl)(reqUrl) === expectedUrl;\n        }\n        else if ((0, url_1.isAbsoluteUrl)(expectedUrl)) {\n            // Full absolute URL: match everything\n            return reqUrl === expectedUrl;\n        }\n        else {\n            // Absolute URL with no protocol\n            return (0, url_1.getUrlWithoutProtocol)(reqUrl) === expectedUrl;\n        }\n    }\n    explain() {\n        return `for ${this.path}`;\n    }\n}\nexports.SimplePathMatcher = SimplePathMatcher;\nclass RegexPathMatcher extends serialization_1.Serializable {\n    constructor(regex) {\n        super();\n        this.type = 'regex-path';\n        this.regexSource = regex.source;\n        this.regexFlags = regex.flags;\n    }\n    matches(request) {\n        const absoluteUrl = (0, url_1.normalizeUrl)(request.url);\n        const urlPath = (0, url_1.getPathFromAbsoluteUrl)(absoluteUrl);\n        // Test the matcher against both the path alone & the full URL\n        const urlMatcher = new RegExp(this.regexSource, this.regexFlags);\n        return urlMatcher.test(absoluteUrl) ||\n            urlMatcher.test(urlPath);\n    }\n    explain() {\n        return `matching /${unescapeRegexp(this.regexSource)}/${this.regexFlags ?? ''}`;\n    }\n}\nexports.RegexPathMatcher = RegexPathMatcher;\nclass RegexUrlMatcher extends serialization_1.Serializable {\n    constructor(regex) {\n        super();\n        this.type = 'regex-url';\n        this.regexSource = regex.source;\n        this.regexFlags = regex.flags;\n    }\n    matches(request) {\n        const absoluteUrl = (0, url_1.normalizeUrl)(request.url);\n        // Test the matcher against the full URL\n        const urlMatcher = new RegExp(this.regexSource, this.regexFlags);\n        return urlMatcher.test(absoluteUrl);\n    }\n    explain() {\n        return `matching URL /${unescapeRegexp(this.regexSource)}/${this.regexFlags ?? ''}`;\n    }\n}\nexports.RegexUrlMatcher = RegexUrlMatcher;\nclass HeaderMatcher extends serialization_1.Serializable {\n    constructor(headersInput) {\n        super();\n        this.type = 'header';\n        this.headers = _.mapKeys(headersInput, (_value, key) => key.toLowerCase());\n    }\n    matches(request) {\n        return _.isMatch(request.headers, this.headers);\n    }\n    explain() {\n        return `with headers including ${JSON.stringify(this.headers)}`;\n    }\n}\nexports.HeaderMatcher = HeaderMatcher;\nclass ExactQueryMatcher extends serialization_1.Serializable {\n    constructor(query) {\n        super();\n        this.query = query;\n        this.type = 'exact-query-string';\n        if (query !== '' && query[0] !== '?') {\n            throw new Error('Exact query matches must start with ?, or be empty');\n        }\n    }\n    matches(request) {\n        const { search } = url.parse(request.url);\n        return this.query === search || (!search && !this.query);\n    }\n    explain() {\n        return this.query\n            ? `with a query exactly matching \\`${this.query}\\``\n            : 'with no query string';\n    }\n}\nexports.ExactQueryMatcher = ExactQueryMatcher;\nclass QueryMatcher extends serialization_1.Serializable {\n    constructor(queryObjectInput) {\n        super();\n        this.type = 'query';\n        this.queryObject = _.mapValues(queryObjectInput, (v) => Array.isArray(v) ? v.map(av => av.toString()) : v.toString());\n    }\n    matches(request) {\n        let { query } = url.parse(request.url, true);\n        return _.isMatch(query, this.queryObject);\n    }\n    explain() {\n        return `with a query including ${JSON.stringify(this.queryObject)}`;\n    }\n}\nexports.QueryMatcher = QueryMatcher;\nclass FormDataMatcher extends serialization_1.Serializable {\n    constructor(formData) {\n        super();\n        this.formData = formData;\n        this.type = 'form-data';\n    }\n    async matches(request) {\n        const contentType = request.headers['content-type'];\n        return !!contentType &&\n            contentType.indexOf(\"application/x-www-form-urlencoded\") !== -1 &&\n            _.isMatch(await request.body.asFormData(), this.formData);\n    }\n    explain() {\n        return `with form data including ${JSON.stringify(this.formData)}`;\n    }\n}\nexports.FormDataMatcher = FormDataMatcher;\nclass MultipartFormDataMatcher extends serialization_1.Serializable {\n    constructor(matchConditions) {\n        super();\n        this.matchConditions = matchConditions;\n        this.type = 'multipart-form-data';\n    }\n    async matches(request) {\n        const contentType = request.headers['content-type'];\n        if (!contentType)\n            return false;\n        if (!contentType.includes(\"multipart/form-data\"))\n            return false;\n        const boundary = contentType.match(/;\\s*boundary=(\\S+)/);\n        if (!boundary)\n            return false;\n        const parsedBody = multipart.parse(await request.body.asDecodedBuffer(), boundary[1]);\n        return this.matchConditions.every((condition) => {\n            const expectedContent = condition.content\n                ? Buffer.from(condition.content)\n                : undefined;\n            return parsedBody.some((part) => (expectedContent?.equals(part.data) || expectedContent === undefined) &&\n                (condition.filename === part.filename || condition.filename === undefined) &&\n                (condition.name === part.name || condition.name === undefined));\n        });\n    }\n    explain() {\n        return `with multipart form data matching ${JSON.stringify(this.matchConditions)}`;\n    }\n}\nexports.MultipartFormDataMatcher = MultipartFormDataMatcher;\nclass RawBodyMatcher extends serialization_1.Serializable {\n    constructor(content) {\n        super();\n        this.content = content;\n        this.type = 'raw-body';\n    }\n    async matches(request) {\n        return (await request.body.asText()) === this.content;\n    }\n    explain() {\n        return `with body '${this.content}'`;\n    }\n}\nexports.RawBodyMatcher = RawBodyMatcher;\nclass RawBodyIncludesMatcher extends serialization_1.Serializable {\n    constructor(content) {\n        super();\n        this.content = content;\n        this.type = 'raw-body-includes';\n    }\n    async matches(request) {\n        return (await request.body.asText()).includes(this.content);\n    }\n    explain() {\n        return `with a body including '${this.content}'`;\n    }\n}\nexports.RawBodyIncludesMatcher = RawBodyIncludesMatcher;\nclass RegexBodyMatcher extends serialization_1.Serializable {\n    constructor(regex) {\n        super();\n        this.type = 'raw-body-regexp';\n        this.regexString = regex.source;\n    }\n    async matches(request) {\n        let bodyMatcher = new RegExp(this.regexString);\n        return bodyMatcher.test(await request.body.asText());\n    }\n    explain() {\n        return `with a body matching /${unescapeRegexp(this.regexString)}/`;\n    }\n}\nexports.RegexBodyMatcher = RegexBodyMatcher;\nclass JsonBodyMatcher extends serialization_1.Serializable {\n    constructor(body) {\n        super();\n        this.body = body;\n        this.type = 'json-body';\n    }\n    async matches(request) {\n        const receivedBody = await (request.body.asJson().catch(() => undefined));\n        if (receivedBody === undefined)\n            return false;\n        else\n            return _.isEqual(receivedBody, this.body);\n    }\n    explain() {\n        return `with a JSON body equivalent to ${JSON.stringify(this.body)}`;\n    }\n}\nexports.JsonBodyMatcher = JsonBodyMatcher;\nclass JsonBodyFlexibleMatcher extends serialization_1.Serializable {\n    constructor(body) {\n        super();\n        this.body = body;\n        this.type = 'json-body-matching';\n    }\n    async matches(request) {\n        const receivedBody = await (request.body.asJson().catch(() => undefined));\n        if (receivedBody === undefined)\n            return false;\n        else\n            return _.isMatch(receivedBody, this.body);\n    }\n    explain() {\n        return `with a JSON body including ${JSON.stringify(this.body)}`;\n    }\n}\nexports.JsonBodyFlexibleMatcher = JsonBodyFlexibleMatcher;\nclass CookieMatcher extends serialization_1.Serializable {\n    constructor(cookie) {\n        super();\n        this.cookie = cookie;\n        this.type = 'cookie';\n    }\n    async matches(request) {\n        if (!request.headers || !request.headers.cookie) {\n            return false;\n        }\n        const cookies = request.headers.cookie.split(';').map(cookie => {\n            const [key, value] = cookie.split('=');\n            return { [key.trim()]: (value || '').trim() };\n        });\n        return cookies.some(element => _.isEqual(element, this.cookie));\n    }\n    explain() {\n        return `with cookies including ${JSON.stringify(this.cookie)}`;\n    }\n}\nexports.CookieMatcher = CookieMatcher;\nclass CallbackMatcher extends serialization_1.Serializable {\n    constructor(callback) {\n        super();\n        this.callback = callback;\n        this.type = 'callback';\n    }\n    async matches(request) {\n        const completedRequest = await (0, request_utils_1.waitForCompletedRequest)(request);\n        return this.callback(completedRequest);\n    }\n    explain() {\n        return `matches using provided callback${this.callback.name ? ` (${this.callback.name})` : ''}`;\n    }\n    /**\n     * @internal\n     */\n    serialize(channel) {\n        channel.onRequest(async (streamMsg) => {\n            const request = (0, body_serialization_1.withDeserializedBodyReader)(streamMsg);\n            const callbackResult = await this.callback.call(null, request);\n            return callbackResult;\n        });\n        return { type: this.type, name: this.callback.name, version: 1 };\n    }\n    /**\n     * @internal\n     */\n    static deserialize({ name }, channel) {\n        const rpcCallback = async (request) => {\n            const callbackResult = channel.request((0, body_serialization_1.withSerializedBodyReader)(request));\n            return callbackResult;\n        };\n        // Pass across the name from the real callback, for explain()\n        Object.defineProperty(rpcCallback, 'name', { value: name });\n        // Call the client's callback (via stream), and save a handler on our end for\n        // the response that comes back.\n        return new CallbackMatcher(rpcCallback);\n    }\n}\nexports.CallbackMatcher = CallbackMatcher;\nexports.MatcherLookup = {\n    'wildcard': WildcardMatcher,\n    'method': MethodMatcher,\n    'protocol': ProtocolMatcher,\n    'host': HostMatcher,\n    'hostname': HostnameMatcher,\n    'port': PortMatcher,\n    'simple-path': SimplePathMatcher,\n    'regex-path': RegexPathMatcher,\n    'regex-url': RegexUrlMatcher,\n    'header': HeaderMatcher,\n    'query': QueryMatcher,\n    'exact-query-string': ExactQueryMatcher,\n    'form-data': FormDataMatcher,\n    'multipart-form-data': MultipartFormDataMatcher,\n    'raw-body': RawBodyMatcher,\n    'raw-body-regexp': RegexBodyMatcher,\n    'raw-body-includes': RawBodyIncludesMatcher,\n    'json-body': JsonBodyMatcher,\n    'json-body-matching': JsonBodyFlexibleMatcher,\n    'cookie': CookieMatcher,\n    'callback': CallbackMatcher,\n};\nasync function matchesAll(req, matchers) {\n    return new Promise((resolve, reject) => {\n        const resultsPromises = matchers.map((matcher) => matcher.matches(req));\n        resultsPromises.forEach(async (maybePromiseResult) => {\n            try {\n                const result = await maybePromiseResult;\n                if (!result)\n                    resolve(false); // Resolve mismatches immediately\n            }\n            catch (e) {\n                reject(e); // Resolve matcher failures immediately\n            }\n        });\n        // Otherwise resolve as normal: all true matches, exceptions reject.\n        Promise.all(resultsPromises)\n            .then((result) => resolve(_.every(result)))\n            .catch((e) => reject(e));\n    });\n}\nfunction explainMatchers(matchers) {\n    if (matchers.length === 1)\n        return matchers[0].explain();\n    if (matchers.length === 2) {\n        // With just two explanations, you can just combine them\n        return `${matchers[0].explain()} ${matchers[1].explain()}`;\n    }\n    // With 3+, we need to oxford comma separate explanations to make them readable\n    return matchers.slice(0, -1)\n        .map((m) => m.explain())\n        .join(', ') + ', and ' + matchers.slice(-1)[0].explain();\n}\n//# sourceMappingURL=matchers.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.HandlerDefinitionLookup = exports.JsonRpcResponseHandlerDefinition = exports.TimeoutHandlerDefinition = exports.ResetConnectionHandlerDefinition = exports.CloseConnectionHandlerDefinition = exports.PassThroughHandlerDefinition = exports.SERIALIZED_OMIT = exports.FileHandlerDefinition = exports.StreamHandlerDefinition = exports.CallbackHandlerDefinition = exports.SimpleHandlerDefinition = void 0;\nconst _ = require(\"lodash\");\nconst url = require(\"url\");\nconst base64_arraybuffer_1 = require(\"base64-arraybuffer\");\nconst stream_1 = require(\"stream\");\nconst common_tags_1 = require(\"common-tags\");\nconst fast_json_patch_1 = require(\"fast-json-patch\");\nconst request_utils_1 = require(\"../../util/request-utils\");\nconst buffer_utils_1 = require(\"../../util/buffer-utils\");\nconst serialization_1 = require(\"../../serialization/serialization\");\nconst body_serialization_1 = require(\"../../serialization/body-serialization\");\nfunction validateCustomHeaders(originalHeaders, modifiedHeaders, headerWhitelist = []) {\n    if (!modifiedHeaders)\n        return;\n    // We ignore most returned pseudo headers, so we error if you try to manually set them\n    const invalidHeaders = _(modifiedHeaders)\n        .pickBy((value, name) => name.toString().startsWith(':') &&\n        // We allow returning a preexisting header value - that's ignored\n        // silently, so that mutating & returning the provided headers is always safe.\n        value !== originalHeaders[name] &&\n        // In some cases, specific custom pseudoheaders may be allowed, e.g. requests\n        // can have custom :scheme and :authority headers set.\n        !headerWhitelist.includes(name))\n        .keys();\n    if (invalidHeaders.size() > 0) {\n        throw new Error(`Cannot set custom ${invalidHeaders.join(', ')} pseudoheader values`);\n    }\n}\nclass SimpleHandlerDefinition extends serialization_1.Serializable {\n    constructor(status, statusMessage, data, headers, trailers) {\n        super();\n        this.status = status;\n        this.statusMessage = statusMessage;\n        this.data = data;\n        this.headers = headers;\n        this.trailers = trailers;\n        this.type = 'simple';\n        validateCustomHeaders({}, headers);\n        validateCustomHeaders({}, trailers);\n        if (!_.isEmpty(trailers) && headers) {\n            if (!Object.entries(headers).some(([key, value]) => key.toLowerCase() === 'transfer-encoding' && value === 'chunked')) {\n                throw new Error(\"Trailers can only be set when using chunked transfer encoding\");\n            }\n        }\n    }\n    explain() {\n        return `respond with status ${this.status}` +\n            (this.statusMessage ? ` (${this.statusMessage})` : \"\") +\n            (this.headers ? `, headers ${JSON.stringify(this.headers)}` : \"\") +\n            (this.data ? ` and body \"${this.data}\"` : \"\") +\n            (this.trailers ? `then trailers ${JSON.stringify(this.trailers)}` : \"\");\n    }\n}\nexports.SimpleHandlerDefinition = SimpleHandlerDefinition;\nclass CallbackHandlerDefinition extends serialization_1.Serializable {\n    constructor(callback) {\n        super();\n        this.callback = callback;\n        this.type = 'callback';\n    }\n    explain() {\n        return 'respond using provided callback' + (this.callback.name ? ` (${this.callback.name})` : '');\n    }\n    /**\n     * @internal\n     */\n    serialize(channel) {\n        channel.onRequest(async (streamMsg) => {\n            const request = _.isString(streamMsg.args[0].body)\n                ? (0, body_serialization_1.withDeserializedBodyReader)(// New format: body serialized as base64\n                streamMsg.args[0])\n                : {\n                    ...streamMsg.args[0],\n                    body: (0, request_utils_1.buildBodyReader)(streamMsg.args[0].body.buffer, streamMsg.args[0].headers)\n                };\n            const callbackResult = await this.callback.call(null, request);\n            if (typeof callbackResult === 'string') {\n                return callbackResult;\n            }\n            else {\n                return (0, body_serialization_1.withSerializedCallbackBuffers)(callbackResult);\n            }\n        });\n        return { type: this.type, name: this.callback.name, version: 2 };\n    }\n}\nexports.CallbackHandlerDefinition = CallbackHandlerDefinition;\n;\nclass StreamHandlerDefinition extends serialization_1.Serializable {\n    constructor(status, stream, headers) {\n        super();\n        this.status = status;\n        this.stream = stream;\n        this.headers = headers;\n        this.type = 'stream';\n        validateCustomHeaders({}, headers);\n    }\n    explain() {\n        return `respond with status ${this.status}` +\n            (this.headers ? `, headers ${JSON.stringify(this.headers)},` : \"\") +\n            ' and a stream of response data';\n    }\n    /**\n     * @internal\n     */\n    serialize(channel) {\n        const serializationStream = new stream_1.Transform({\n            objectMode: true,\n            transform: function (chunk, _encoding, callback) {\n                let serializedEventData = _.isString(chunk) ? { type: 'string', value: chunk } :\n                    _.isBuffer(chunk) ? { type: 'buffer', value: chunk.toString('base64') } :\n                        (_.isArrayBuffer(chunk) || _.isTypedArray(chunk)) ? { type: 'arraybuffer', value: (0, base64_arraybuffer_1.encode)(chunk) } :\n                            _.isNil(chunk) && { type: 'nil' };\n                if (!serializedEventData) {\n                    callback(new Error(`Can't serialize streamed value: ${chunk.toString()}. Streaming must output strings, buffers or array buffers`));\n                }\n                callback(undefined, {\n                    event: 'data',\n                    content: serializedEventData\n                });\n            },\n            flush: function (callback) {\n                this.push({\n                    event: 'end'\n                });\n                callback();\n            }\n        });\n        // When we get a ping from the server-side, pipe the real stream to serialize it and send the data across\n        channel.once('data', () => {\n            this.stream.pipe(serializationStream).pipe(channel, { end: false });\n        });\n        return { type: this.type, status: this.status, headers: this.headers };\n    }\n}\nexports.StreamHandlerDefinition = StreamHandlerDefinition;\nclass FileHandlerDefinition extends serialization_1.Serializable {\n    constructor(status, statusMessage, filePath, headers) {\n        super();\n        this.status = status;\n        this.statusMessage = statusMessage;\n        this.filePath = filePath;\n        this.headers = headers;\n        this.type = 'file';\n        validateCustomHeaders({}, headers);\n    }\n    explain() {\n        return `respond with status ${this.status}` +\n            (this.statusMessage ? ` (${this.statusMessage})` : \"\") +\n            (this.headers ? `, headers ${JSON.stringify(this.headers)}` : \"\") +\n            (this.filePath ? ` and body from file ${this.filePath}` : \"\");\n    }\n}\nexports.FileHandlerDefinition = FileHandlerDefinition;\n/**\n * Used in merging as a marker for values to omit, because lodash ignores undefineds.\n * @internal\n */\nexports.SERIALIZED_OMIT = \"__mockttp__transform__omit__\";\nclass PassThroughHandlerDefinition extends serialization_1.Serializable {\n    constructor(options = {}) {\n        super();\n        this.type = 'passthrough';\n        this.ignoreHostHttpsErrors = [];\n        this.extraCACertificates = [];\n        // Used in subclass - awkwardly needs to be initialized here to ensure that its set when using a\n        // handler built from a definition. In future, we could improve this (compose instead of inheritance\n        // to better control handler construction?) but this will do for now.\n        this.outgoingSockets = new Set();\n        // If a location is provided, and it's not a bare hostname, it must be parseable\n        const { forwarding } = options;\n        if (forwarding && forwarding.targetHost.includes('/')) {\n            const { protocol, hostname, port, path } = url.parse(forwarding.targetHost);\n            if (path && path.trim() !== \"/\") {\n                const suggestion = url.format({ protocol, hostname, port }) ||\n                    forwarding.targetHost.slice(0, forwarding.targetHost.indexOf('/'));\n                throw new Error((0, common_tags_1.stripIndent) `\n                    URLs for forwarding cannot include a path, but \"${forwarding.targetHost}\" does. ${''}Did you mean ${suggestion}?\n                `);\n            }\n        }\n        this.forwarding = forwarding;\n        this.ignoreHostHttpsErrors = options.ignoreHostHttpsErrors || [];\n        if (!Array.isArray(this.ignoreHostHttpsErrors) && typeof this.ignoreHostHttpsErrors !== 'boolean') {\n            throw new Error(\"ignoreHostHttpsErrors must be an array or a boolean\");\n        }\n        this.lookupOptions = options.lookupOptions;\n        this.proxyConfig = options.proxyConfig;\n        this.simulateConnectionErrors = !!options.simulateConnectionErrors;\n        this.extraCACertificates =\n            options.additionalTrustedCAs ||\n                options.trustAdditionalCAs ||\n                [];\n        this.clientCertificateHostMap = options.clientCertificateHostMap || {};\n        if (options.beforeRequest && options.transformRequest && !_.isEmpty(options.transformRequest)) {\n            throw new Error(\"BeforeRequest and transformRequest options are mutually exclusive\");\n        }\n        else if (options.beforeRequest) {\n            this.beforeRequest = options.beforeRequest;\n        }\n        else if (options.transformRequest) {\n            if ([\n                options.transformRequest.updateHeaders,\n                options.transformRequest.replaceHeaders\n            ].filter(o => !!o).length > 1) {\n                throw new Error(\"Only one request header transform can be specified at a time\");\n            }\n            if ([\n                options.transformRequest.replaceBody,\n                options.transformRequest.replaceBodyFromFile,\n                options.transformRequest.updateJsonBody,\n                options.transformRequest.patchJsonBody,\n                options.transformRequest.matchReplaceBody\n            ].filter(o => !!o).length > 1) {\n                throw new Error(\"Only one request body transform can be specified at a time\");\n            }\n            if (options.transformRequest.patchJsonBody) {\n                const validationError = (0, fast_json_patch_1.validate)(options.transformRequest.patchJsonBody);\n                if (validationError)\n                    throw validationError;\n            }\n            this.transformRequest = options.transformRequest;\n        }\n        if (options.beforeResponse && options.transformResponse && !_.isEmpty(options.transformResponse)) {\n            throw new Error(\"BeforeResponse and transformResponse options are mutually exclusive\");\n        }\n        else if (options.beforeResponse) {\n            this.beforeResponse = options.beforeResponse;\n        }\n        else if (options.transformResponse) {\n            if ([\n                options.transformResponse.updateHeaders,\n                options.transformResponse.replaceHeaders\n            ].filter(o => !!o).length > 1) {\n                throw new Error(\"Only one response header transform can be specified at a time\");\n            }\n            if ([\n                options.transformResponse.replaceBody,\n                options.transformResponse.replaceBodyFromFile,\n                options.transformResponse.updateJsonBody,\n                options.transformResponse.patchJsonBody,\n                options.transformResponse.matchReplaceBody\n            ].filter(o => !!o).length > 1) {\n                throw new Error(\"Only one response body transform can be specified at a time\");\n            }\n            if (options.transformResponse.patchJsonBody) {\n                const validationError = (0, fast_json_patch_1.validate)(options.transformResponse.patchJsonBody);\n                if (validationError)\n                    throw validationError;\n            }\n            this.transformResponse = options.transformResponse;\n        }\n    }\n    explain() {\n        return this.forwarding\n            ? `forward the request to ${this.forwarding.targetHost}`\n            : 'pass the request through to the target host';\n    }\n    /**\n     * @internal\n     */\n    serialize(channel) {\n        if (this.beforeRequest) {\n            channel.onRequest('beforeRequest', async (req) => {\n                const callbackResult = await this.beforeRequest((0, body_serialization_1.withDeserializedBodyReader)(req.args[0]));\n                const serializedResult = callbackResult\n                    ? (0, body_serialization_1.withSerializedCallbackBuffers)(callbackResult)\n                    : undefined;\n                if (serializedResult?.response && typeof serializedResult?.response !== 'string') {\n                    serializedResult.response = (0, body_serialization_1.withSerializedCallbackBuffers)(serializedResult.response);\n                }\n                return serializedResult;\n            });\n        }\n        if (this.beforeResponse) {\n            channel.onRequest('beforeResponse', async (req) => {\n                const callbackResult = await this.beforeResponse((0, body_serialization_1.withDeserializedBodyReader)(req.args[0]));\n                if (typeof callbackResult === 'string') {\n                    return callbackResult;\n                }\n                else if (callbackResult) {\n                    return (0, body_serialization_1.withSerializedCallbackBuffers)(callbackResult);\n                }\n                else {\n                    return undefined;\n                }\n            });\n        }\n        return {\n            type: this.type,\n            ...this.forwarding ? {\n                forwarding: this.forwarding,\n                // Backward compat:\n                forwardToLocation: this.forwarding.targetHost\n            } : {},\n            proxyConfig: (0, serialization_1.serializeProxyConfig)(this.proxyConfig, channel),\n            lookupOptions: this.lookupOptions,\n            simulateConnectionErrors: this.simulateConnectionErrors,\n            ignoreHostCertificateErrors: this.ignoreHostHttpsErrors,\n            extraCACertificates: this.extraCACertificates.map((certObject) => {\n                // We use toString to make sure that buffers always end up as\n                // as UTF-8 string, to avoid serialization issues. Strings are an\n                // easy safe format here, since it's really all just plain-text PEM\n                // under the hood.\n                if ('cert' in certObject) {\n                    return { cert: certObject.cert.toString('utf8') };\n                }\n                else {\n                    return certObject;\n                }\n            }),\n            clientCertificateHostMap: _.mapValues(this.clientCertificateHostMap, ({ pfx, passphrase }) => ({ pfx: (0, serialization_1.serializeBuffer)(pfx), passphrase })),\n            transformRequest: this.transformRequest ? {\n                ...this.transformRequest,\n                // Body is always serialized as a base64 buffer:\n                replaceBody: !!this.transformRequest?.replaceBody\n                    ? (0, serialization_1.serializeBuffer)((0, buffer_utils_1.asBuffer)(this.transformRequest.replaceBody))\n                    : undefined,\n                // Update objects need to capture undefined & null as distict values:\n                updateHeaders: !!this.transformRequest?.updateHeaders\n                    ? JSON.stringify(this.transformRequest.updateHeaders, (k, v) => v === undefined ? exports.SERIALIZED_OMIT : v)\n                    : undefined,\n                updateJsonBody: !!this.transformRequest?.updateJsonBody\n                    ? JSON.stringify(this.transformRequest.updateJsonBody, (k, v) => v === undefined ? exports.SERIALIZED_OMIT : v)\n                    : undefined,\n                matchReplaceBody: !!this.transformRequest?.matchReplaceBody\n                    ? this.transformRequest.matchReplaceBody.map(([match, result]) => [\n                        _.isRegExp(match)\n                            ? { regexSource: match.source, flags: match.flags }\n                            : match,\n                        result\n                    ])\n                    : undefined,\n            } : undefined,\n            transformResponse: this.transformResponse ? {\n                ...this.transformResponse,\n                // Body is always serialized as a base64 buffer:\n                replaceBody: !!this.transformResponse?.replaceBody\n                    ? (0, serialization_1.serializeBuffer)((0, buffer_utils_1.asBuffer)(this.transformResponse.replaceBody))\n                    : undefined,\n                // Update objects need to capture undefined & null as distict values:\n                updateHeaders: !!this.transformResponse?.updateHeaders\n                    ? JSON.stringify(this.transformResponse.updateHeaders, (k, v) => v === undefined ? exports.SERIALIZED_OMIT : v)\n                    : undefined,\n                updateJsonBody: !!this.transformResponse?.updateJsonBody\n                    ? JSON.stringify(this.transformResponse.updateJsonBody, (k, v) => v === undefined ? exports.SERIALIZED_OMIT : v)\n                    : undefined,\n                matchReplaceBody: !!this.transformResponse?.matchReplaceBody\n                    ? this.transformResponse.matchReplaceBody.map(([match, result]) => [\n                        _.isRegExp(match)\n                            ? { regexSource: match.source, flags: match.flags }\n                            : match,\n                        result\n                    ])\n                    : undefined,\n            } : undefined,\n            hasBeforeRequestCallback: !!this.beforeRequest,\n            hasBeforeResponseCallback: !!this.beforeResponse\n        };\n    }\n}\nexports.PassThroughHandlerDefinition = PassThroughHandlerDefinition;\nclass CloseConnectionHandlerDefinition extends serialization_1.Serializable {\n    constructor() {\n        super(...arguments);\n        this.type = 'close-connection';\n    }\n    explain() {\n        return 'close the connection';\n    }\n}\nexports.CloseConnectionHandlerDefinition = CloseConnectionHandlerDefinition;\nclass ResetConnectionHandlerDefinition extends serialization_1.Serializable {\n    constructor() {\n        super(...arguments);\n        this.type = 'reset-connection';\n    }\n    explain() {\n        return 'reset the connection';\n    }\n}\nexports.ResetConnectionHandlerDefinition = ResetConnectionHandlerDefinition;\nclass TimeoutHandlerDefinition extends serialization_1.Serializable {\n    constructor() {\n        super(...arguments);\n        this.type = 'timeout';\n    }\n    explain() {\n        return 'time out (never respond)';\n    }\n}\nexports.TimeoutHandlerDefinition = TimeoutHandlerDefinition;\nclass JsonRpcResponseHandlerDefinition extends serialization_1.Serializable {\n    constructor(result) {\n        super();\n        this.result = result;\n        this.type = 'json-rpc-response';\n        if (!('result' in result) && !('error' in result)) {\n            throw new Error('JSON-RPC response must be either a result or an error');\n        }\n    }\n    explain() {\n        const resultType = 'result' in this.result\n            ? 'result'\n            : 'error';\n        return `send a fixed JSON-RPC ${resultType} of ${JSON.stringify(this.result[resultType])}`;\n    }\n}\nexports.JsonRpcResponseHandlerDefinition = JsonRpcResponseHandlerDefinition;\nexports.HandlerDefinitionLookup = {\n    'simple': SimpleHandlerDefinition,\n    'callback': CallbackHandlerDefinition,\n    'stream': StreamHandlerDefinition,\n    'file': FileHandlerDefinition,\n    'passthrough': PassThroughHandlerDefinition,\n    'close-connection': CloseConnectionHandlerDefinition,\n    'reset-connection': ResetConnectionHandlerDefinition,\n    'timeout': TimeoutHandlerDefinition,\n    'json-rpc-response': JsonRpcResponseHandlerDefinition\n};\n//# sourceMappingURL=request-handler-definitions.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.RequestRuleBuilder = void 0;\nconst lodash_1 = require(\"lodash\");\nconst request_handler_definitions_1 = require(\"./request-handler-definitions\");\nconst util_1 = require(\"../../util/util\");\nconst base_rule_builder_1 = require(\"../base-rule-builder\");\nconst matchers_1 = require(\"../matchers\");\n/**\n * @class RequestRuleBuilder\n\n * A builder for defining mock rules. Create one using a method like\n * `.forGet(path)` or `.forPost(path)` on a Mockttp instance, then call\n * whatever methods you'd like here to define more precise request\n * matching behaviour, control how the request is handled, and how\n * many times this rule should be applied.\n *\n * When you're done, call a `.thenX()` method to register the configured rule\n * with the server. These return a promise for a MockedEndpoint, which can be\n * used to verify the details of the requests matched by the rule.\n *\n * This returns a promise because rule registration can be asynchronous,\n * either when using a remote server or testing in the browser. Wait for the\n * promise returned by `.thenX()` methods to guarantee that the rule has taken\n * effect before sending requests to it.\n */\nclass RequestRuleBuilder extends base_rule_builder_1.BaseRuleBuilder {\n    constructor(methodOrAddRule, path, addRule) {\n        super();\n        // Add the basic method and path matchers inititally, if provided:\n        const method = methodOrAddRule instanceof Function ? undefined : methodOrAddRule;\n        if (method === undefined && path === undefined) {\n            this.matchers.push(new matchers_1.WildcardMatcher());\n        }\n        else {\n            if (method !== undefined) {\n                this.matchers.push(new matchers_1.MethodMatcher(method));\n            }\n            if (path instanceof RegExp) {\n                this.matchers.push(new matchers_1.RegexPathMatcher(path));\n            }\n            else if (typeof path === 'string') {\n                this.matchers.push(new matchers_1.SimplePathMatcher(path));\n            }\n        }\n        // Store the addRule callback:\n        if (methodOrAddRule instanceof Function) {\n            this.addRule = methodOrAddRule;\n        }\n        else {\n            this.addRule = addRule;\n        }\n    }\n    thenReply(status, dataOrMessage, dataOrHeaders, headersOrTrailers, trailers) {\n        let data;\n        let statusMessage;\n        let headers;\n        if ((0, lodash_1.isBuffer)(dataOrHeaders) || (0, lodash_1.isString)(dataOrHeaders)) {\n            data = dataOrHeaders;\n            statusMessage = dataOrMessage;\n            headers = headersOrTrailers;\n        }\n        else {\n            data = dataOrMessage;\n            headers = dataOrHeaders;\n            trailers = headersOrTrailers;\n        }\n        const rule = {\n            ...this.buildBaseRuleData(),\n            handler: new request_handler_definitions_1.SimpleHandlerDefinition(status, statusMessage, data, headers, trailers)\n        };\n        return this.addRule(rule);\n    }\n    /**\n     * Reply to matched requests with the given status & JSON and (optionally)\n     * extra headers.\n     *\n     * This method is (approximately) shorthand for:\n     * server.forGet(...).thenReply(status, JSON.stringify(data), { 'Content-Type': 'application/json' })\n     *\n     * Calling this method registers the rule with the server, so it\n     * starts to handle requests.\n     *\n     * This method returns a promise that resolves with a mocked endpoint.\n     * Wait for the promise to confirm that the rule has taken effect\n     * before sending requests to be matched. The mocked endpoint\n     * can be used to assert on the requests matched by this rule.\n     *\n     * @category Responses\n     */\n    thenJson(status, data, headers = {}) {\n        const jsonData = JSON.stringify(data);\n        headers = (0, lodash_1.merge)({\n            'Content-Type': 'application/json',\n            'Content-Length': (0, util_1.byteLength)(jsonData).toString(),\n            'Connection': 'keep-alive'\n            // ^ Neither strictly required, but without both Node will close the server\n            // connection after the response is sent, which can confuse clients.\n        }, headers);\n        const rule = {\n            ...this.buildBaseRuleData(),\n            handler: new request_handler_definitions_1.SimpleHandlerDefinition(status, undefined, jsonData, headers)\n        };\n        return this.addRule(rule);\n    }\n    /**\n     * Call the given callback for any matched requests that are received,\n     * and build a response from the result.\n     *\n     * The callback should return a response object with the fields as\n     * defined by {@link CallbackResponseMessageResult} to define the response,\n     * or the string 'close' to immediately close the connection. The callback\n     * can be asynchronous, in which case it should return this value wrapped\n     * in a promise.\n     *\n     * If the callback throws an exception, the server will return a 500\n     * with the exception message.\n     *\n     * Calling this method registers the rule with the server, so it\n     * starts to handle requests.\n     *\n     * This method returns a promise that resolves with a mocked endpoint.\n     * Wait for the promise to confirm that the rule has taken effect\n     * before sending requests to be matched. The mocked endpoint\n     * can be used to assert on the requests matched by this rule.\n     *\n     * @category Responses\n     */\n    thenCallback(callback) {\n        const rule = {\n            ...this.buildBaseRuleData(),\n            handler: new request_handler_definitions_1.CallbackHandlerDefinition(callback)\n        };\n        return this.addRule(rule);\n    }\n    /**\n     * Respond immediately with the given status (and optionally, headers),\n     * and then stream the given stream directly as the response body.\n     *\n     * Note that streams can typically only be read once, and as such\n     * this rule will only successfully trigger once. Subsequent requests\n     * will receive a 500 and an explanatory error message. To mock\n     * repeated requests with streams, create multiple streams and mock\n     * them independently.\n     *\n     * Calling this method registers the rule with the server, so it\n     * starts to handle requests.\n     *\n     * This method returns a promise that resolves with a mocked endpoint.\n     * Wait for the promise to confirm that the rule has taken effect\n     * before sending requests to be matched. The mocked endpoint\n     * can be used to assert on the requests matched by this rule.\n     *\n     * @category Responses\n     */\n    thenStream(status, stream, headers) {\n        const rule = {\n            ...this.buildBaseRuleData(),\n            handler: new request_handler_definitions_1.StreamHandlerDefinition(status, stream, headers)\n        };\n        return this.addRule(rule);\n    }\n    thenFromFile(status, pathOrMessage, pathOrHeaders, headers) {\n        let path;\n        let statusMessage;\n        if ((0, lodash_1.isString)(pathOrHeaders)) {\n            path = pathOrHeaders;\n            statusMessage = pathOrMessage;\n        }\n        else {\n            path = pathOrMessage;\n            headers = pathOrHeaders;\n        }\n        const rule = {\n            ...this.buildBaseRuleData(),\n            handler: new request_handler_definitions_1.FileHandlerDefinition(status, statusMessage, path, headers)\n        };\n        return this.addRule(rule);\n    }\n    /**\n     * Pass matched requests through to their real destination. This works\n     * for proxied requests only, direct requests will be rejected with\n     * an error.\n     *\n     * This method takes options to configure how the request is passed\n     * through. See {@link PassThroughHandlerOptions} for the full details\n     * of the options available.\n     *\n     * Calling this method registers the rule with the server, so it\n     * starts to handle requests.\n     *\n     * This method returns a promise that resolves with a mocked endpoint.\n     * Wait for the promise to confirm that the rule has taken effect\n     * before sending requests to be matched. The mocked endpoint\n     * can be used to assert on the requests matched by this rule.\n     *\n     * @category Responses\n     */\n    thenPassThrough(options) {\n        const rule = {\n            ...this.buildBaseRuleData(),\n            handler: new request_handler_definitions_1.PassThroughHandlerDefinition(options)\n        };\n        return this.addRule(rule);\n    }\n    /**\n     * Forward matched requests on to the specified forwardToUrl. The url\n     * specified must not include a path. Otherwise, an error is thrown.\n     * The path portion of the original request url is used instead.\n     *\n     * The url may optionally contain a protocol. If it does, it will override\n     * the protocol (and potentially the port, if unspecified) of the request.\n     * If no protocol is specified, the protocol (and potentially the port)\n     * of the original request URL will be used instead.\n     *\n     * This method takes options to configure how the request is passed\n     * through. See {@link PassThroughHandlerOptions} for the full details\n     * of the options available.\n     *\n     * Calling this method registers the rule with the server, so it\n     * starts to handle requests.\n     *\n     * This method returns a promise that resolves with a mocked endpoint.\n     * Wait for the promise to confirm that the rule has taken effect\n     * before sending requests to be matched. The mocked endpoint\n     * can be used to assert on the requests matched by this rule.\n     *\n     * @category Responses\n     */\n    async thenForwardTo(forwardToLocation, options = {}) {\n        const rule = {\n            ...this.buildBaseRuleData(),\n            handler: new request_handler_definitions_1.PassThroughHandlerDefinition({\n                ...options,\n                forwarding: {\n                    ...options.forwarding,\n                    targetHost: forwardToLocation\n                }\n            })\n        };\n        return this.addRule(rule);\n    }\n    /**\n     * Close connections that match this rule immediately, without\n     * any status code or response.\n     *\n     * Calling this method registers the rule with the server, so it\n     * starts to handle requests.\n     *\n     * This method returns a promise that resolves with a mocked endpoint.\n     * Wait for the promise to confirm that the rule has taken effect\n     * before sending requests to be matched. The mocked endpoint\n     * can be used to assert on the requests matched by this rule.\n     *\n     * @category Responses\n     */\n    thenCloseConnection() {\n        const rule = {\n            ...this.buildBaseRuleData(),\n            handler: new request_handler_definitions_1.CloseConnectionHandlerDefinition()\n        };\n        return this.addRule(rule);\n    }\n    /**\n     * Reset connections that match this rule immediately, sending a TCP\n     * RST packet directly, without any status code or response, and without\n     * cleanly closing the TCP connection.\n     *\n     * This is only supported in Node.js versions (>=16.17, >=18.3.0, or\n     * later), where `net.Socket` includes the `resetAndDestroy` method.\n     *\n     * Calling this method registers the rule with the server, so it\n     * starts to handle requests.\n     *\n     * This method returns a promise that resolves with a mocked endpoint.\n     * Wait for the promise to confirm that the rule has taken effect\n     * before sending requests to be matched. The mocked endpoint\n     * can be used to assert on the requests matched by this rule.\n     *\n     * @category Responses\n     */\n    thenResetConnection() {\n        const rule = {\n            ...this.buildBaseRuleData(),\n            handler: new request_handler_definitions_1.ResetConnectionHandlerDefinition()\n        };\n        return this.addRule(rule);\n    }\n    /**\n     * Hold open connections that match this rule, but never respond\n     * with anything at all, typically causing a timeout on the client side.\n     *\n     * Calling this method registers the rule with the server, so it\n     * starts to handle requests.\n     *\n     * This method returns a promise that resolves with a mocked endpoint.\n     * Wait for the promise to confirm that the rule has taken effect\n     * before sending requests to be matched. The mocked endpoint\n     * can be used to assert on the requests matched by this rule.\n     *\n     * @category Responses\n     */\n    thenTimeout() {\n        const rule = {\n            ...this.buildBaseRuleData(),\n            handler: new request_handler_definitions_1.TimeoutHandlerDefinition()\n        };\n        return this.addRule(rule);\n    }\n    /**\n     * Send a successful JSON-RPC response to a JSON-RPC request. The response data\n     * can be any JSON-serializable value. If a matching request is received that\n     * is not a valid JSON-RPC request, it will be rejected with an HTTP error.\n     *\n     * @category Responses\n     */\n    thenSendJsonRpcResult(result) {\n        const rule = {\n            ...this.buildBaseRuleData(),\n            handler: new request_handler_definitions_1.JsonRpcResponseHandlerDefinition({ result })\n        };\n        return this.addRule(rule);\n    }\n    /**\n     * Send a failing error JSON-RPC response to a JSON-RPC request. The error data\n     * can be any JSON-serializable value. If a matching request is received that\n     * is not a valid JSON-RPC request, it will be rejected with an HTTP error.\n     *\n     * @category Responses\n     */\n    thenSendJsonRpcError(error) {\n        const rule = {\n            ...this.buildBaseRuleData(),\n            handler: new request_handler_definitions_1.JsonRpcResponseHandlerDefinition({ error })\n        };\n        return this.addRule(rule);\n    }\n}\nexports.RequestRuleBuilder = RequestRuleBuilder;\n//# sourceMappingURL=request-rule-builder.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.MOCKTTP_PARAM_REF = void 0;\nexports.isParamReference = isParamReference;\nexports.dereferenceParam = dereferenceParam;\nexports.assertParamDereferenced = assertParamDereferenced;\nexports.MOCKTTP_PARAM_REF = Symbol('MOCKTTP_PARAM_REF');\nfunction isParamReference(input) {\n    return input && !!input[exports.MOCKTTP_PARAM_REF];\n}\n;\nfunction dereferenceParam(paramRef, params) {\n    const paramKey = paramRef[exports.MOCKTTP_PARAM_REF];\n    if (paramKey in params) {\n        return params[paramKey];\n    }\n    else {\n        throw new Error(`Invalid reference to undefined rule parameter '${paramKey}'`);\n    }\n}\n;\nfunction assertParamDereferenced(maybeParamRef) {\n    if (isParamReference(maybeParamRef)) {\n        const paramKey = maybeParamRef[exports.MOCKTTP_PARAM_REF];\n        throw new Error(`Non-dereferenced rule parameter used unexpectedly: ${paramKey}`);\n    }\n    else {\n        return maybeParamRef;\n    }\n}\n//# sourceMappingURL=rule-parameters.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.validateMockRuleData = validateMockRuleData;\nexports.serializeRuleData = serializeRuleData;\nconst serialization_1 = require(\"../serialization/serialization\");\nfunction validateMockRuleData(data) {\n    if (!data.matchers || data.matchers.length === 0) {\n        throw new Error('Cannot create a rule without at least one matcher');\n    }\n    if (!data.handler) {\n        throw new Error('Cannot create a rule with no handler');\n    }\n}\nfunction serializeRuleData(data, stream) {\n    validateMockRuleData(data);\n    return {\n        id: data.id,\n        priority: data.priority,\n        matchers: data.matchers.map(m => (0, serialization_1.serialize)(m, stream)),\n        handler: (0, serialization_1.serialize)(data.handler, stream),\n        completionChecker: data.completionChecker && (0, serialization_1.serialize)(data.completionChecker, stream)\n    };\n}\n;\n//# sourceMappingURL=rule-serialization.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.WsHandlerDefinitionLookup = exports.TimeoutHandlerDefinition = exports.ResetConnectionHandlerDefinition = exports.CloseConnectionHandlerDefinition = exports.RejectWebSocketHandlerDefinition = exports.ListenWebSocketHandlerDefinition = exports.EchoWebSocketHandlerDefinition = exports.PassThroughWebSocketHandlerDefinition = void 0;\nconst _ = require(\"lodash\");\nconst url = require(\"url\");\nconst common_tags_1 = require(\"common-tags\");\nconst serialization_1 = require(\"../../serialization/serialization\");\nconst request_handler_definitions_1 = require(\"../requests/request-handler-definitions\");\nObject.defineProperty(exports, \"CloseConnectionHandlerDefinition\", { enumerable: true, get: function () { return request_handler_definitions_1.CloseConnectionHandlerDefinition; } });\nObject.defineProperty(exports, \"ResetConnectionHandlerDefinition\", { enumerable: true, get: function () { return request_handler_definitions_1.ResetConnectionHandlerDefinition; } });\nObject.defineProperty(exports, \"TimeoutHandlerDefinition\", { enumerable: true, get: function () { return request_handler_definitions_1.TimeoutHandlerDefinition; } });\nclass PassThroughWebSocketHandlerDefinition extends serialization_1.Serializable {\n    constructor(options = {}) {\n        super();\n        this.type = 'ws-passthrough';\n        this.ignoreHostHttpsErrors = [];\n        this.extraCACertificates = [];\n        // If a location is provided, and it's not a bare hostname, it must be parseable\n        const { forwarding } = options;\n        if (forwarding && forwarding.targetHost.includes('/')) {\n            const { protocol, hostname, port, path } = url.parse(forwarding.targetHost);\n            if (path && path.trim() !== \"/\") {\n                const suggestion = url.format({ protocol, hostname, port }) ||\n                    forwarding.targetHost.slice(0, forwarding.targetHost.indexOf('/'));\n                throw new Error((0, common_tags_1.stripIndent) `\n                    URLs for forwarding cannot include a path, but \"${forwarding.targetHost}\" does. ${''}Did you mean ${suggestion}?\n                `);\n            }\n        }\n        this.forwarding = options.forwarding;\n        this.ignoreHostHttpsErrors = options.ignoreHostHttpsErrors || [];\n        if (!Array.isArray(this.ignoreHostHttpsErrors) && typeof this.ignoreHostHttpsErrors !== 'boolean') {\n            throw new Error(\"ignoreHostHttpsErrors must be an array or a boolean\");\n        }\n        this.lookupOptions = options.lookupOptions;\n        this.proxyConfig = options.proxyConfig;\n        this.extraCACertificates =\n            options.additionalTrustedCAs ||\n                options.trustAdditionalCAs ||\n                [];\n        this.clientCertificateHostMap = options.clientCertificateHostMap || {};\n    }\n    explain() {\n        return this.forwarding\n            ? `forward the websocket to ${this.forwarding.targetHost}`\n            : 'pass the request through to the target host';\n    }\n    /**\n     * @internal\n     */\n    serialize(channel) {\n        return {\n            type: this.type,\n            forwarding: this.forwarding,\n            lookupOptions: this.lookupOptions,\n            proxyConfig: (0, serialization_1.serializeProxyConfig)(this.proxyConfig, channel),\n            ignoreHostCertificateErrors: this.ignoreHostHttpsErrors,\n            extraCACertificates: this.extraCACertificates.map((certObject) => {\n                // We use toString to make sure that buffers always end up as\n                // as UTF-8 string, to avoid serialization issues. Strings are an\n                // easy safe format here, since it's really all just plain-text PEM\n                // under the hood.\n                if ('cert' in certObject) {\n                    return { cert: certObject.cert.toString('utf8') };\n                }\n                else {\n                    return certObject;\n                }\n            }),\n            clientCertificateHostMap: _.mapValues(this.clientCertificateHostMap, ({ pfx, passphrase }) => ({ pfx: (0, serialization_1.serializeBuffer)(pfx), passphrase }))\n        };\n    }\n}\nexports.PassThroughWebSocketHandlerDefinition = PassThroughWebSocketHandlerDefinition;\nclass EchoWebSocketHandlerDefinition extends serialization_1.Serializable {\n    constructor() {\n        super(...arguments);\n        this.type = 'ws-echo';\n    }\n    explain() {\n        return \"echo all websocket messages\";\n    }\n}\nexports.EchoWebSocketHandlerDefinition = EchoWebSocketHandlerDefinition;\nclass ListenWebSocketHandlerDefinition extends serialization_1.Serializable {\n    constructor() {\n        super(...arguments);\n        this.type = 'ws-listen';\n    }\n    explain() {\n        return \"silently accept websocket messages without responding\";\n    }\n}\nexports.ListenWebSocketHandlerDefinition = ListenWebSocketHandlerDefinition;\nclass RejectWebSocketHandlerDefinition extends serialization_1.Serializable {\n    constructor(statusCode, statusMessage = 'WebSocket rejected', headers = {}, body = '') {\n        super();\n        this.statusCode = statusCode;\n        this.statusMessage = statusMessage;\n        this.headers = headers;\n        this.body = body;\n        this.type = 'ws-reject';\n    }\n    explain() {\n        return `explicitly reject the websocket upgrade with status ${this.statusCode}`;\n    }\n}\nexports.RejectWebSocketHandlerDefinition = RejectWebSocketHandlerDefinition;\nexports.WsHandlerDefinitionLookup = {\n    'ws-passthrough': PassThroughWebSocketHandlerDefinition,\n    'ws-echo': EchoWebSocketHandlerDefinition,\n    'ws-listen': ListenWebSocketHandlerDefinition,\n    'ws-reject': RejectWebSocketHandlerDefinition,\n    'close-connection': request_handler_definitions_1.CloseConnectionHandlerDefinition,\n    'reset-connection': request_handler_definitions_1.ResetConnectionHandlerDefinition,\n    'timeout': request_handler_definitions_1.TimeoutHandlerDefinition\n};\n//# sourceMappingURL=websocket-handler-definitions.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.WebSocketRuleBuilder = void 0;\nconst websocket_handler_definitions_1 = require(\"./websocket-handler-definitions\");\nconst base_rule_builder_1 = require(\"../base-rule-builder\");\nconst matchers_1 = require(\"../matchers\");\n/**\n * @class WebSocketRuleBuilder\n\n * A builder for defining websocket mock rules. Create one using\n * `.forAnyWebSocket(path)` on a Mockttp instance, then call whatever\n * methods you'd like here to define more precise matching behaviour,\n * control how the connection is handled, and how many times this\n * rule should be applied.\n *\n * When you're done, call a `.thenX()` method to register the configured rule\n * with the server. These return a promise for a MockedEndpoint, which can be\n * used to verify the details of the requests matched by the rule.\n *\n * This returns a promise because rule registration can be asynchronous,\n * either when using a remote server or testing in the browser. Wait for the\n * promise returned by `.thenX()` methods to guarantee that the rule has taken\n * effect before sending requests to it.\n */\nclass WebSocketRuleBuilder extends base_rule_builder_1.BaseRuleBuilder {\n    /**\n     * Mock rule builders should be constructed through the Mockttp instance you're\n     * using, not directly. You shouldn't ever need to call this constructor.\n     */\n    constructor(addRule) {\n        super();\n        this.addRule = addRule;\n        // By default, websockets just match everything:\n        this.matchers.push(new matchers_1.WildcardMatcher());\n    }\n    /**\n     * Pass matched websockets through to their real destination. This works\n     * for proxied requests only, and direct requests will be rejected with\n     * an error.\n     *\n     * This method takes options to configure how the request is passed\n     * through. See {@link PassThroughWebSocketHandlerOptions} for the full\n     * details of the options available.\n     *\n     * Calling this method registers the rule with the server, so it\n     * starts to handle requests.\n     *\n     * This method returns a promise that resolves with a mocked endpoint.\n     * Wait for the promise to confirm that the rule has taken effect\n     * before sending requests to be matched. The mocked endpoint\n     * can be used to assert on the requests matched by this rule.\n     *\n     * @category Responses\n     */\n    thenPassThrough(options = {}) {\n        const rule = {\n            ...this.buildBaseRuleData(),\n            handler: new websocket_handler_definitions_1.PassThroughWebSocketHandlerDefinition(options)\n        };\n        return this.addRule(rule);\n    }\n    /**\n     * Forward matched websockets on to the specified forwardToUrl. The url\n     * specified must not include a path or an error will be thrown.\n     * The path portion of the original request url is used instead.\n     *\n     * The url may optionally contain a protocol. If it does, it will override\n     * the protocol (and potentially the port, if unspecified) of the request.\n     * If no protocol is specified, the protocol (and potentially the port)\n     * of the original request URL will be used instead.\n     *\n     * This method takes options to configure how the request is passed\n     * through. See {@link PassThroughWebSocketHandlerOptions} for the full\n     * details of the options available.\n     *\n     * Calling this method registers the rule with the server, so it\n     * starts to handle requests.\n     *\n     * This method returns a promise that resolves with a mocked endpoint.\n     * Wait for the promise to confirm that the rule has taken effect\n     * before sending requests to be matched. The mocked endpoint\n     * can be used to assert on the requests matched by this rule.\n     *\n     * @category Responses\n     */\n    async thenForwardTo(forwardToLocation, options = {}) {\n        const rule = {\n            ...this.buildBaseRuleData(),\n            handler: new websocket_handler_definitions_1.PassThroughWebSocketHandlerDefinition({\n                ...options,\n                forwarding: {\n                    ...options.forwarding,\n                    targetHost: forwardToLocation\n                }\n            })\n        };\n        return this.addRule(rule);\n    }\n    /**\n     * Accept incoming WebSocket connections, and echo every message\n     * received on the WebSocket back to the client.\n     *\n     * Calling this method registers the rule with the server, so it\n     * starts to handle requests.\n     *\n     * This method returns a promise that resolves with a mocked endpoint.\n     * Wait for the promise to confirm that the rule has taken effect\n     * before sending requests to be matched. The mocked endpoint\n     * can be used to assert on the requests matched by this rule.\n     *\n     * @category Responses\n     */\n    thenEcho() {\n        const rule = {\n            ...this.buildBaseRuleData(),\n            handler: new websocket_handler_definitions_1.EchoWebSocketHandlerDefinition()\n        };\n        return this.addRule(rule);\n    }\n    /**\n     * Accept incoming WebSocket connections, and simply listen to\n     * incoming messages without ever sending anything in return.\n     *\n     * Calling this method registers the rule with the server, so it\n     * starts to handle requests.\n     *\n     * This method returns a promise that resolves with a mocked endpoint.\n     * Wait for the promise to confirm that the rule has taken effect\n     * before sending requests to be matched. The mocked endpoint\n     * can be used to assert on the requests matched by this rule.\n     *\n     * @category Responses\n     */\n    thenPassivelyListen() {\n        const rule = {\n            ...this.buildBaseRuleData(),\n            handler: new websocket_handler_definitions_1.ListenWebSocketHandlerDefinition()\n        };\n        return this.addRule(rule);\n    }\n    /**\n     * Rejects connections, sending an HTTP response with the given\n     * status, message and body, to explicitly refuse the WebSocket\n     * handshake.\n     *\n     * Calling this method registers the rule with the server, so it\n     * starts to handle requests.\n     *\n     * This method returns a promise that resolves with a mocked endpoint.\n     * Wait for the promise to confirm that the rule has taken effect\n     * before sending requests to be matched. The mocked endpoint\n     * can be used to assert on the requests matched by this rule.\n     *\n     * @category Responses\n     */\n    thenRejectConnection(statusCode, statusMessage, headers, body) {\n        const rule = {\n            ...this.buildBaseRuleData(),\n            handler: new websocket_handler_definitions_1.RejectWebSocketHandlerDefinition(statusCode, statusMessage, headers, body)\n        };\n        return this.addRule(rule);\n    }\n    /**\n     * Close connections that match this rule immediately, without accepting\n     * the socket or sending any other response.\n     *\n     * Calling this method registers the rule with the server, so it\n     * starts to handle requests.\n     *\n     * This method returns a promise that resolves with a mocked endpoint.\n     * Wait for the promise to confirm that the rule has taken effect\n     * before sending requests to be matched. The mocked endpoint\n     * can be used to assert on the requests matched by this rule.\n     *\n     * @category Responses\n     */\n    thenCloseConnection() {\n        const rule = {\n            ...this.buildBaseRuleData(),\n            handler: new websocket_handler_definitions_1.CloseConnectionHandlerDefinition()\n        };\n        return this.addRule(rule);\n    }\n    /**\n     * Reset connections that match this rule immediately, sending a TCP\n     * RST packet directly, without accepting the socket or sending any\n     * other response, and without cleanly closing the TCP connection.\n     *\n     * This is only supported in Node.js versions (>=16.17, >=18.3.0, or\n     * later), where `net.Socket` includes the `resetAndDestroy` method.\n     *\n     * Calling this method registers the rule with the server, so it\n     * starts to handle requests.\n     *\n     * This method returns a promise that resolves with a mocked endpoint.\n     * Wait for the promise to confirm that the rule has taken effect\n     * before sending requests to be matched. The mocked endpoint\n     * can be used to assert on the requests matched by this rule.\n     *\n     * @category Responses\n     */\n    thenResetConnection() {\n        const rule = {\n            ...this.buildBaseRuleData(),\n            handler: new websocket_handler_definitions_1.ResetConnectionHandlerDefinition()\n        };\n        return this.addRule(rule);\n    }\n    /**\n     * Hold open connections that match this rule, but never respond\n     * with anything at all, typically causing a timeout on the client side.\n     *\n     * Calling this method registers the rule with the server, so it\n     * starts to handle requests.\n     *\n     * This method returns a promise that resolves with a mocked endpoint.\n     * Wait for the promise to confirm that the rule has taken effect\n     * before sending requests to be matched. The mocked endpoint\n     * can be used to assert on the requests matched by this rule.\n     *\n     * @category Responses\n     */\n    thenTimeout() {\n        const rule = {\n            ...this.buildBaseRuleData(),\n            handler: new websocket_handler_definitions_1.TimeoutHandlerDefinition()\n        };\n        return this.addRule(rule);\n    }\n}\nexports.WebSocketRuleBuilder = WebSocketRuleBuilder;\n//# sourceMappingURL=websocket-rule-builder.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.withSerializedBodyReader = withSerializedBodyReader;\nexports.withDeserializedBodyReader = withDeserializedBodyReader;\nexports.withSerializedCallbackBuffers = withSerializedCallbackBuffers;\nexports.withDeserializedCallbackBuffers = withDeserializedCallbackBuffers;\nconst _ = require(\"lodash\");\nconst base64_arraybuffer_1 = require(\"base64-arraybuffer\");\nconst buffer_utils_1 = require(\"../util/buffer-utils\");\nconst request_utils_1 = require(\"../util/request-utils\");\nconst serialization_1 = require(\"./serialization\");\nfunction withSerializedBodyReader(input) {\n    return {\n        ...input,\n        body: (0, buffer_utils_1.asBuffer)(input.body.buffer).toString('base64')\n    };\n}\nfunction withDeserializedBodyReader(input) {\n    return {\n        ...input,\n        body: (0, request_utils_1.buildBodyReader)((0, serialization_1.deserializeBuffer)(input.body), input.headers)\n    };\n}\n/**\n * Serialize a callback result (callback handlers, BeforeRequest/Response etc)\n * to transform all the many possible buffer formats into either base64-encoded\n * buffer data, or undefined.\n */\nfunction withSerializedCallbackBuffers(input) {\n    let serializedBody;\n    if (!input.body) {\n        serializedBody = undefined;\n    }\n    else if (_.isString(input.body)) {\n        serializedBody = (0, serialization_1.serializeBuffer)((0, buffer_utils_1.asBuffer)(input.body));\n    }\n    else if (_.isBuffer(input.body)) {\n        serializedBody = (0, serialization_1.serializeBuffer)(input.body);\n    }\n    else if (_.isArrayBuffer(input.body) || _.isTypedArray(input.body)) {\n        serializedBody = (0, base64_arraybuffer_1.encode)(input.body);\n    }\n    else if ((0, request_utils_1.isMockttpBody)(input.body)) {\n        serializedBody = (0, serialization_1.serializeBuffer)((0, buffer_utils_1.asBuffer)(input.body.buffer));\n    }\n    return {\n        ...input,\n        body: serializedBody,\n        rawBody: input.rawBody\n            ? (0, serialization_1.serializeBuffer)((0, buffer_utils_1.asBuffer)(input.rawBody))\n            : undefined\n    };\n}\n/**\n * Deserialize a callback result (callback handlers, BeforeRequest/Response etc)\n * to build buffer data (or undefined) from the base64-serialized data\n * produced by withSerializedCallbackBuffers\n */\nfunction withDeserializedCallbackBuffers(input) {\n    return {\n        ...input,\n        body: input.body !== undefined\n            ? Buffer.from(input.body, 'base64')\n            : undefined,\n        rawBody: input.rawBody !== undefined\n            ? Buffer.from(input.rawBody, 'base64')\n            : undefined\n    };\n}\n//# sourceMappingURL=body-serialization.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ClientServerChannel = exports.Serializable = void 0;\nexports.serialize = serialize;\nexports.deserialize = deserialize;\nexports.serializeBuffer = serializeBuffer;\nexports.deserializeBuffer = deserializeBuffer;\nexports.ensureParamsDeferenced = ensureParamsDeferenced;\nexports.serializeProxyConfig = serializeProxyConfig;\nexports.deserializeProxyConfig = deserializeProxyConfig;\nconst _ = require(\"lodash\");\nconst stream_1 = require(\"stream\");\nconst uuid_1 = require(\"uuid\");\nconst rule_parameters_1 = require(\"../rules/rule-parameters\");\nfunction serialize(obj, stream) {\n    const channel = new ClientServerChannel(stream);\n    const data = obj.serialize(channel);\n    data.topicId = channel.topicId;\n    return data;\n}\nfunction deserialize(data, stream, ruleParams, lookup) {\n    const type = data.type;\n    const channel = new ClientServerChannel(stream, data.topicId);\n    const deserialized = lookup[type].deserialize(data, channel, ruleParams);\n    // Wrap .dispose and ensure the channel is always disposed too.\n    const builtinDispose = deserialized.dispose;\n    deserialized.dispose = () => {\n        builtinDispose();\n        channel.dispose();\n    };\n    return deserialized;\n}\nclass Serializable {\n    /**\n     * @internal\n     */\n    serialize(_channel) {\n        // By default, we assume data is transferrable as-is\n        return this;\n    }\n    /**\n     * @internal\n     */\n    static deserialize(data, _channel, _ruleParams) {\n        // By default, we assume we just need to assign the right prototype\n        return _.create(this.prototype, data);\n    }\n    // This rule is being unregistered. Any handlers who need to cleanup when they know\n    // they're no longer in use should implement this and dispose accordingly.\n    // Only deserialized rules are disposed - if the originating rule needs\n    // disposing too, ping the channel and let it know.\n    dispose() { }\n}\nexports.Serializable = Serializable;\nconst DISPOSE_MESSAGE = { disposeChannel: true };\n// Wraps another stream, ensuring that messages go only to the paired channel on the\n// other client/server. In practice, each handler gets one end of these streams in\n// their serialize/deserialize methods, and can use them to sync live data reliably.\nclass ClientServerChannel extends stream_1.Duplex {\n    constructor(rawStream, topicId) {\n        super({ objectMode: true });\n        this.rawStream = rawStream;\n        this._onRawStreamError = (error) => {\n            this.destroy(error);\n        };\n        this._onRawStreamFinish = () => {\n            this.end();\n        };\n        this._readFromRawStream = (rawData) => {\n            const stringData = rawData.toString();\n            stringData.split('\\n').filter(d => !!d).forEach((rawDataLine) => {\n                let data;\n                try {\n                    data = JSON.parse(rawDataLine);\n                }\n                catch (e) {\n                    console.log(e);\n                    console.log('Received unparseable message, dropping.', rawDataLine.toString());\n                    return;\n                }\n                if (data.topicId === this.topicId) {\n                    if (_.isEqual(_.omit(data, 'topicId'), DISPOSE_MESSAGE))\n                        this.dispose(true);\n                    else\n                        this.push(data);\n                }\n            });\n        };\n        this.reading = false;\n        this.topicId = topicId || (0, uuid_1.v4)();\n        this.rawStream.on('error', this._onRawStreamError);\n        this.rawStream.on('finish', this._onRawStreamFinish);\n    }\n    /**\n     * @internal @hidden\n     */\n    _write(message, encoding, callback) {\n        message.topicId = this.topicId;\n        const chunk = JSON.stringify(message) + '\\n';\n        if (!this.rawStream.write(chunk, encoding)) {\n            this.rawStream.once('drain', callback);\n        }\n        else {\n            callback();\n        }\n    }\n    _read() {\n        if (!this.reading) {\n            this.rawStream.on('data', this._readFromRawStream);\n            this.reading = true;\n        }\n    }\n    request(actionOrData, dataOrNothing) {\n        let action;\n        let data;\n        if (_.isString(actionOrData)) {\n            action = actionOrData;\n            data = dataOrNothing;\n        }\n        else {\n            data = actionOrData;\n        }\n        const requestId = (0, uuid_1.v4)();\n        return new Promise((resolve, reject) => {\n            const responseListener = (response) => {\n                if (response.requestId === requestId) {\n                    if (response.error) {\n                        // Derialize error from plain object\n                        reject(Object.assign(new Error(), { stack: undefined }, response.error));\n                    }\n                    else {\n                        resolve(response.data);\n                    }\n                    this.removeListener('data', responseListener);\n                }\n            };\n            const request = { data, requestId };\n            if (action)\n                request.action = action;\n            this.write(request, (e) => {\n                if (e)\n                    reject(e);\n                else\n                    this.on('data', responseListener);\n            });\n        });\n    }\n    onRequest(cbOrAction, cbOrNothing) {\n        let actionName;\n        let cb;\n        if (_.isString(cbOrAction)) {\n            actionName = cbOrAction;\n            cb = cbOrNothing;\n        }\n        else {\n            cb = cbOrAction;\n        }\n        this.on('data', async (request) => {\n            const { requestId, action } = request;\n            // Filter by actionName, if set\n            if (actionName !== undefined && action !== actionName)\n                return;\n            try {\n                const response = {\n                    requestId,\n                    data: await cb(request.data)\n                };\n                if (!this.writable)\n                    return; // Response too slow - drop it\n                this.write(response);\n            }\n            catch (error) {\n                // Make the error serializable:\n                error = _.pick(error, Object.getOwnPropertyNames(error));\n                if (!this.writable)\n                    return; // Response too slow - drop it\n                this.write({ requestId, error });\n            }\n        });\n    }\n    // Shuts down the channel. Only needs to be called on one side, the other side\n    // will be shut down automatically when it receives DISPOSE_MESSAGE.\n    dispose(disposeReceived = false) {\n        this.on('error', () => { }); // Dispose is best effort - we don't care about errors\n        // Only one side needs to send a dispose - we send first if we haven't seen one.\n        if (!disposeReceived)\n            this.end(DISPOSE_MESSAGE);\n        else\n            this.end();\n        // Detach any remaining onRequest handlers:\n        this.removeAllListeners('data');\n        // Stop receiving upstream messages from the global stream:\n        this.rawStream.removeListener('data', this._readFromRawStream);\n        this.rawStream.removeListener('error', this._onRawStreamError);\n        this.rawStream.removeListener('finish', this._onRawStreamFinish);\n    }\n}\nexports.ClientServerChannel = ClientServerChannel;\nfunction serializeBuffer(buffer) {\n    return buffer.toString('base64');\n}\nfunction deserializeBuffer(buffer) {\n    return Buffer.from(buffer, 'base64');\n}\nconst SERIALIZED_PARAM_REFERENCE = \"__mockttp__param__reference__\";\nfunction serializeParam(value) {\n    // Swap the symbol for a string, since we can't serialize symbols in JSON:\n    return { [SERIALIZED_PARAM_REFERENCE]: value[rule_parameters_1.MOCKTTP_PARAM_REF] };\n}\nfunction isSerializedRuleParam(value) {\n    return value && SERIALIZED_PARAM_REFERENCE in value;\n}\nfunction ensureParamsDeferenced(value, ruleParams) {\n    if (isSerializedRuleParam(value)) {\n        const paramRef = {\n            [rule_parameters_1.MOCKTTP_PARAM_REF]: value[SERIALIZED_PARAM_REFERENCE]\n        };\n        return (0, rule_parameters_1.dereferenceParam)(paramRef, ruleParams);\n    }\n    else {\n        return value;\n    }\n}\nfunction serializeProxyConfig(proxyConfig, channel) {\n    if (_.isFunction(proxyConfig)) {\n        const callbackId = `proxyConfig-callback-${(0, uuid_1.v4)()}`;\n        channel.onRequest(callbackId, proxyConfig);\n        return callbackId;\n    }\n    else if (_.isArray(proxyConfig)) {\n        return proxyConfig.map((config) => serializeProxyConfig(config, channel));\n    }\n    else if ((0, rule_parameters_1.isParamReference)(proxyConfig)) {\n        return serializeParam(proxyConfig);\n    }\n    else if (proxyConfig) {\n        return {\n            ...proxyConfig,\n            trustedCAs: proxyConfig.trustedCAs?.map((caDefinition) => typeof caDefinition !== 'string' && 'cert' in caDefinition\n                ? { cert: caDefinition.cert.toString('utf8') } // Stringify in case of buffers\n                : caDefinition),\n            additionalTrustedCAs: proxyConfig.additionalTrustedCAs?.map((caDefinition) => 'cert' in caDefinition\n                ? { cert: caDefinition.cert.toString('utf8') } // Stringify in case of buffers\n                : caDefinition)\n        };\n    }\n}\nfunction deserializeProxyConfig(proxyConfig, channel, ruleParams) {\n    if (_.isString(proxyConfig)) {\n        const callbackId = proxyConfig;\n        const proxyConfigCallback = async (options) => {\n            return await channel.request(callbackId, options);\n        };\n        return proxyConfigCallback;\n    }\n    else if (_.isArray(proxyConfig)) {\n        return proxyConfig.map((config) => deserializeProxyConfig(config, channel, ruleParams));\n    }\n    else {\n        return ensureParamsDeferenced(proxyConfig, ruleParams);\n    }\n}\n//# sourceMappingURL=serialization.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.RulePriority = exports.Method = exports.DEFAULT_ADMIN_SERVER_PORT = void 0;\nexports.DEFAULT_ADMIN_SERVER_PORT = 45454;\nvar Method;\n(function (Method) {\n    Method[Method[\"GET\"] = 0] = \"GET\";\n    Method[Method[\"POST\"] = 1] = \"POST\";\n    Method[Method[\"PUT\"] = 2] = \"PUT\";\n    Method[Method[\"DELETE\"] = 3] = \"DELETE\";\n    Method[Method[\"PATCH\"] = 4] = \"PATCH\";\n    Method[Method[\"HEAD\"] = 5] = \"HEAD\";\n    Method[Method[\"OPTIONS\"] = 6] = \"OPTIONS\";\n})(Method || (exports.Method = Method = {}));\nvar RulePriority;\n(function (RulePriority) {\n    RulePriority[RulePriority[\"FALLBACK\"] = 0] = \"FALLBACK\";\n    RulePriority[RulePriority[\"DEFAULT\"] = 1] = \"DEFAULT\";\n})(RulePriority || (exports.RulePriority = RulePriority = {}));\n//# sourceMappingURL=types.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.streamToBuffer = exports.bufferToStream = exports.bufferThenStream = exports.asBuffer = void 0;\nexports.splitBuffer = splitBuffer;\nconst events_1 = require(\"events\");\nconst stream = require(\"stream\");\nconst util_1 = require(\"./util\");\nconst MAX_BUFFER_SIZE = util_1.isNode\n    ? require('buffer').constants.MAX_LENGTH\n    : Infinity;\nconst asBuffer = (input) => Buffer.isBuffer(input)\n    ? input\n    : typeof input === \"string\"\n        ? Buffer.from(input, 'utf8')\n        // Is Array:\n        : Buffer.from(input);\nexports.asBuffer = asBuffer;\n// Takes a buffer and a stream, returns a simple stream that outputs the buffer then the stream. The stream\n// is lazy, so doesn't read data in from the buffer or input until something here starts reading.\nconst bufferThenStream = (buffer, inputStream) => {\n    let active = false;\n    const outputStream = new stream.PassThrough({\n        // Note we use the default highWaterMark, which means this applies backpressure, pushing buffering\n        // onto the OS & backpressure on network instead of accepting data before we're ready to stream it.\n        // Without changing behaviour, we listen for read() events, and don't start streaming until we get one.\n        read(size) {\n            // On the first actual read of this stream, we pull from the buffer\n            // and then hook it up to the input.\n            if (!active) {\n                if (buffer.failedWith) {\n                    outputStream.destroy(buffer.failedWith);\n                }\n                else {\n                    // First stream everything that's been buffered so far:\n                    outputStream.write(Buffer.concat(buffer.currentChunks));\n                    // Then start streaming all future incoming data:\n                    inputStream.pipe(outputStream);\n                    if (inputStream.readableEnded)\n                        outputStream.end();\n                    if (inputStream.readableAborted)\n                        outputStream.destroy();\n                    // Forward any future errors from the input stream:\n                    inputStream.on('error', (e) => {\n                        outputStream.emit('error', e);\n                    });\n                    // Silence 'unhandled rejection' warnings here, since we'll handle\n                    // them on the stream instead\n                    buffer.catch(() => { });\n                }\n                active = true;\n            }\n            // Except for the first activation logic (above) do the default transform read() steps just\n            // like a normal PassThrough stream.\n            return stream.Transform.prototype._read.call(this, size);\n        }\n    });\n    buffer.events.on('truncate', (chunks) => {\n        // If the stream hasn't started yet, start it now, so it grabs the buffer\n        // data before it gets truncated:\n        if (!active)\n            outputStream.read(0);\n    });\n    return outputStream;\n};\nexports.bufferThenStream = bufferThenStream;\nconst bufferToStream = (buffer) => {\n    const outputStream = new stream.PassThrough();\n    outputStream.end(buffer);\n    return outputStream;\n};\nexports.bufferToStream = bufferToStream;\nconst streamToBuffer = (input, maxSize = MAX_BUFFER_SIZE) => {\n    let chunks = [];\n    const bufferPromise = new Promise((resolve, reject) => {\n        function failWithAbortError() {\n            bufferPromise.failedWith = new Error('Aborted');\n            reject(bufferPromise.failedWith);\n        }\n        // If stream has already finished/aborted, resolve accordingly immediately:\n        if (input.readableEnded)\n            return resolve(Buffer.from([]));\n        if (input.readableAborted)\n            return failWithAbortError();\n        let currentSize = 0;\n        const onData = (d) => {\n            currentSize += d.length;\n            chunks.push(d);\n            // If we go over maxSize, drop the whole stream, so the buffer\n            // resolves empty. MaxSize should be large, so this is rare,\n            // and only happens as an alternative to crashing the process.\n            if (currentSize > maxSize) {\n                // Announce truncation, so that other mechanisms (asStream) can\n                // capture this data if they're interested in it.\n                bufferPromise.events.emit('truncate', chunks);\n                // Drop all the data so far & stop reading\n                bufferPromise.currentChunks = chunks = [];\n                input.removeListener('data', onData);\n                // We then resolve immediately - the buffer is done, even if the body\n                // might still be streaming in we're not listening to it. This means\n                // that requests can 'complete' for event/callback purposes while\n                // they're actually still streaming, but only in this scenario where\n                // the data is too large to really be used by the events/callbacks.\n                // If we don't resolve, then cases which intentionally don't consume\n                // the raw stream but do consume the buffer (beforeRequest) would\n                // deadlock: beforeRequest must complete to begin streaming the\n                // full body to the target clients.\n                resolve(Buffer.from([]));\n            }\n        };\n        input.on('data', onData);\n        input.once('end', () => {\n            resolve(Buffer.concat(chunks));\n        });\n        input.once('aborted', failWithAbortError);\n        input.on('error', (e) => {\n            bufferPromise.failedWith = bufferPromise.failedWith || e;\n            reject(e);\n        });\n    });\n    bufferPromise.currentChunks = chunks;\n    bufferPromise.events = new events_1.EventEmitter();\n    return bufferPromise;\n};\nexports.streamToBuffer = streamToBuffer;\nfunction splitBuffer(input, splitter, maxParts = Infinity) {\n    const parts = [];\n    let remainingBuffer = input;\n    while (remainingBuffer.length) {\n        let endOfPart = remainingBuffer.indexOf(splitter);\n        if (endOfPart === -1)\n            endOfPart = remainingBuffer.length;\n        parts.push(remainingBuffer.slice(0, endOfPart));\n        remainingBuffer = remainingBuffer.slice(endOfPart + splitter.length);\n        if (parts.length === maxParts - 1) {\n            parts.push(remainingBuffer);\n            break;\n        }\n    }\n    return parts;\n}\n//# sourceMappingURL=buffer-utils.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.isErrorLike = isErrorLike;\n// Useful to easily cast and then examine errors that are otherwise 'unknown':\nfunction isErrorLike(error) {\n    return typeof error === 'object' && (error instanceof Error ||\n        error.message ||\n        error.code ||\n        error.stack);\n}\n//# sourceMappingURL=error.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.findRawHeaders = exports.findRawHeaderIndex = exports.findRawHeader = void 0;\nexports.pairFlatRawHeaders = pairFlatRawHeaders;\nexports.flattenPairedRawHeaders = flattenPairedRawHeaders;\nexports.rawHeadersToObject = rawHeadersToObject;\nexports.rawHeadersToObjectPreservingCase = rawHeadersToObjectPreservingCase;\nexports.objectHeadersToRaw = objectHeadersToRaw;\nexports.objectHeadersToFlat = objectHeadersToFlat;\nexports.h2HeadersToH1 = h2HeadersToH1;\nexports.h1HeadersToH2 = h1HeadersToH2;\nexports.dropDefaultHeaders = dropDefaultHeaders;\nexports.validateHeader = validateHeader;\nconst http = require(\"http\");\n/*\n\nThese utils support conversion between the various header representations that we deal\nwith. Those are:\n\n- Flat arrays of [key, value, key, value, key, ...]. This is the raw header format\n  generally used by Node.js's APIs throughout.\n- Raw header tuple arrays like [[key, value], [key, value]]. This is our own raw header\n  format, aiming to be fairly easy to use and to preserve header order, header dupes &\n  header casing throughout.\n- Formatted header objects of { key: value, key: value }. These are returned as the most\n  convenient and consistent header format: keys are lowercased, and values are either\n  strings or arrays of strings (for duplicate headers). This is returned by Node's APIs,\n  but with some unclear normalization rules, so in practice we build raw headers and\n  reconstruct this ourselves everyhere, by lowercasing & building arrays of values.\n\n*/\nconst findRawHeader = (rawHeaders, targetKey) => rawHeaders.find(([key]) => key.toLowerCase() === targetKey);\nexports.findRawHeader = findRawHeader;\nconst findRawHeaderIndex = (rawHeaders, targetKey) => rawHeaders.findIndex(([key]) => key.toLowerCase() === targetKey);\nexports.findRawHeaderIndex = findRawHeaderIndex;\nconst findRawHeaders = (rawHeaders, targetKey) => rawHeaders.filter(([key]) => key.toLowerCase() === targetKey);\nexports.findRawHeaders = findRawHeaders;\n/**\n * Return node's _very_ raw headers ([k, v, k, v, ...]) into our slightly more convenient\n * pairwise tuples [[k, v], [k, v], ...] RawHeaders structure.\n */\nfunction pairFlatRawHeaders(flatRawHeaders) {\n    const result = [];\n    for (let i = 0; i < flatRawHeaders.length; i += 2 /* Move two at a time */) {\n        result[i / 2] = [flatRawHeaders[i], flatRawHeaders[i + 1]];\n    }\n    return result;\n}\nfunction flattenPairedRawHeaders(rawHeaders) {\n    return rawHeaders.flat();\n}\n/**\n * Take a raw headers, and turn them into headers, but without some of Node's concessions\n * to ease of use, i.e. keeping multiple values as arrays.\n *\n * This lowercases all names along the way, to provide a convenient header API for most\n * downstream use cases, and to match Node's own behaviour.\n */\nfunction rawHeadersToObject(rawHeaders) {\n    return rawHeaders.reduce((headers, [key, value]) => {\n        key = key.toLowerCase();\n        const existingValue = headers[key];\n        if (Array.isArray(existingValue)) {\n            existingValue.push(value);\n        }\n        else if (existingValue) {\n            headers[key] = [existingValue, value];\n        }\n        else {\n            headers[key] = value;\n        }\n        return headers;\n    }, {});\n}\n/**\n * Take raw headers, and turn them into headers just like `rawHeadersToObject` but\n * also preserves case en route.\n *\n * This is separated because our public APIs should _not_ do this, but there's a few\n * internal use cases where we want to, notably including passing headers to WS which\n * only accepts a headers object when sending upstream requests, but does preserve\n * case from the object.\n */\nfunction rawHeadersToObjectPreservingCase(rawHeaders) {\n    // Duplicate keys with different cases in the final object clobber each other (last\n    // value wins) so we need to pick a single casing for each header name. We don't want\n    // to just use lowercase, because we want to preserve original casing wherever possible.\n    // To make that work, we use the casing from the first instance of each header, along with\n    // a lowercase -> first casing map here to look up that value later:\n    const headerNameMap = {};\n    return rawHeaders.reduce((headers, [key, value]) => {\n        const lowerCaseKey = key.toLowerCase();\n        if (headerNameMap[lowerCaseKey]) {\n            // If we've already seen this header, we need to use the same\n            // casing as before to avoid issues with duplicates:\n            key = headerNameMap[lowerCaseKey];\n        }\n        else {\n            // If we haven't, we store this key as the canonical format\n            // to make it easy to merge with any duplicates:\n            headerNameMap[lowerCaseKey] = key;\n        }\n        const existingValue = headers[key];\n        if (Array.isArray(existingValue)) {\n            existingValue.push(value);\n        }\n        else if (existingValue) {\n            headers[key] = [existingValue, value];\n        }\n        else {\n            headers[key] = value;\n        }\n        return headers;\n    }, {});\n}\nfunction objectHeadersToRaw(headers) {\n    const rawHeaders = [];\n    for (let key in headers) {\n        const value = headers[key];\n        if (value === undefined)\n            continue; // Drop undefined header values\n        if (Array.isArray(value)) {\n            value.forEach((v) => rawHeaders.push([key, v]));\n        }\n        else {\n            rawHeaders.push([key, value]);\n        }\n    }\n    return rawHeaders;\n}\nfunction objectHeadersToFlat(headers) {\n    const flatHeaders = [];\n    for (let key in headers) {\n        const value = headers[key];\n        if (value === undefined)\n            continue; // Drop undefined header values\n        if (Array.isArray(value)) {\n            value.forEach((v) => {\n                flatHeaders.push(key);\n                flatHeaders.push(v);\n            });\n        }\n        else {\n            flatHeaders.push(key);\n            flatHeaders.push(value);\n        }\n    }\n    return flatHeaders;\n}\n// See https://httptoolkit.com/blog/translating-http-2-into-http-1/ for details on the\n// transformations required between H2 & H1 when proxying.\nfunction h2HeadersToH1(h2Headers) {\n    let h1Headers = h2Headers.filter(([key]) => key[0] !== ':');\n    if (!(0, exports.findRawHeader)(h1Headers, 'host') && (0, exports.findRawHeader)(h2Headers, ':authority')) {\n        h1Headers.unshift(['Host', (0, exports.findRawHeader)(h2Headers, ':authority')[1]]);\n    }\n    // In HTTP/1 you MUST only send one cookie header - in HTTP/2 sending multiple is fine,\n    // so we have to concatenate them:\n    const cookieHeaders = (0, exports.findRawHeaders)(h1Headers, 'cookie');\n    if (cookieHeaders.length > 1) {\n        h1Headers = h1Headers.filter(([key]) => key.toLowerCase() !== 'cookie');\n        h1Headers.push(['Cookie', cookieHeaders.join('; ')]);\n    }\n    return h1Headers;\n}\n// Take from http2/util.js in Node itself\nconst HTTP2_ILLEGAL_HEADERS = [\n    'connection',\n    'upgrade',\n    'host',\n    'http2-settings',\n    'keep-alive',\n    'proxy-connection',\n    'transfer-encoding'\n];\nfunction h1HeadersToH2(headers) {\n    return headers.filter(([key]) => !HTTP2_ILLEGAL_HEADERS.includes(key.toLowerCase()));\n}\n// If the user explicitly specifies headers, we tell Node not to handle them,\n// so the user-defined headers are the full set.\nfunction dropDefaultHeaders(response) {\n    // Drop the default headers, so only the headers we explicitly configure are included\n    [\n        'connection',\n        'content-length',\n        'transfer-encoding',\n        'date'\n    ].forEach((defaultHeader) => response.removeHeader(defaultHeader));\n}\nfunction validateHeader(name, value) {\n    try {\n        http.validateHeaderName(name);\n        http.validateHeaderValue(name, value);\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n//# sourceMappingURL=header-utils.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.filter = filter;\nexports.objectAllPromise = objectAllPromise;\nexports.getDeferred = getDeferred;\nconst _ = require(\"lodash\");\nasync function filter(array, test) {\n    let testResults = await Promise.all(array.map(test));\n    return array.filter((v, i) => testResults[i]);\n}\nasync function objectAllPromise(obj) {\n    return _.zipObject(Object.keys(obj), await Promise.all(Object.values(obj)));\n}\nfunction getDeferred() {\n    let resolveCallback;\n    let rejectCallback;\n    let result = new Promise((resolve, reject) => {\n        resolveCallback = resolve;\n        rejectCallback = reject;\n    });\n    result.resolve = resolveCallback;\n    result.reject = rejectCallback;\n    return result;\n}\n//# sourceMappingURL=promise.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.parseRequestBody = exports.buildBodyReader = exports.isMockttpBody = exports.writeHead = exports.shouldKeepAlive = void 0;\nexports.isHttp2 = isHttp2;\nexports.encodeBodyBuffer = encodeBodyBuffer;\nexports.decodeBodyBuffer = decodeBodyBuffer;\nexports.buildInitiatedRequest = buildInitiatedRequest;\nexports.waitForCompletedRequest = waitForCompletedRequest;\nexports.trackResponse = trackResponse;\nexports.waitForCompletedResponse = waitForCompletedResponse;\nexports.tryToParseHttpRequest = tryToParseHttpRequest;\nexports.parseRawHttpResponse = parseRawHttpResponse;\nconst _ = require(\"lodash\");\nconst tls_1 = require(\"tls\");\nconst http2 = require(\"http2\");\nconst stream = require(\"stream\");\nconst querystring = require(\"querystring\");\nconst multipart = require(\"parse-multipart-data\");\nconst now = require(\"performance-now\");\nconst url = require(\"url\");\nconst buffer_utils_1 = require(\"./buffer-utils\");\nconst header_utils_1 = require(\"./header-utils\");\nconst shouldKeepAlive = (req) => req.httpVersion !== '1.0' &&\n    req.headers['connection'] !== 'close' &&\n    req.headers['proxy-connection'] !== 'close';\nexports.shouldKeepAlive = shouldKeepAlive;\nconst writeHead = (response, status, statusMessage, headers) => {\n    const flatHeaders = headers === undefined\n        ? {}\n        : isHttp2(response) && Array.isArray(headers)\n            // H2 raw headers support is poor so we map to object here.\n            // We should revert to flat headers once the below is resolved in LTS:\n            // https://github.com/nodejs/node/issues/51402\n            ? (0, header_utils_1.rawHeadersToObject)(headers)\n            : isHttp2(response)\n                ? headers // H2 supports object headers just fine\n                : !Array.isArray(headers)\n                    ? (0, header_utils_1.objectHeadersToFlat)(headers)\n                    // RawHeaders for H1, must be flattened:\n                    : (0, header_utils_1.flattenPairedRawHeaders)(headers);\n    // We aim to always pass flat headers to writeHead instead of calling setHeader because\n    // in most cases it's more flexible about supporting raw data, e.g. multiple headers with\n    // different casing can't be represented with setHeader at all (the latter overwrites).\n    if (statusMessage === undefined) {\n        // Cast is required as Node H2 types don't know about raw headers:\n        response.writeHead(status, flatHeaders);\n    }\n    else {\n        response.writeHead(status, statusMessage, flatHeaders);\n    }\n};\nexports.writeHead = writeHead;\nfunction isHttp2(message) {\n    return ('httpVersion' in message && !!message.httpVersion?.startsWith('2')) || // H2 request\n        ('stream' in message && 'createPushResponse' in message); // H2 response\n}\nasync function encodeBodyBuffer(buffer, headers) {\n    const contentEncoding = headers['content-encoding'];\n    // We skip encodeBuffer entirely if possible - this isn't strictly necessary, but it's useful\n    // so you can drop the http-encoding package in bundling downstream without issue in cases\n    // where you don't actually use any encodings.\n    if (!contentEncoding)\n        return buffer;\n    return await (await Promise.resolve().then(() => require('http-encoding'))).encodeBuffer(buffer, contentEncoding, { level: 1 });\n}\nasync function decodeBodyBuffer(buffer, headers) {\n    const contentEncoding = headers['content-encoding'];\n    // We skip decodeBuffer entirely if possible - this isn't strictly necessary, but it's useful\n    // so you can drop the http-encoding package in bundling downstream without issue in cases\n    // where you don't actually use any encodings.\n    if (!contentEncoding)\n        return buffer;\n    return await (await Promise.resolve().then(() => require('http-encoding'))).decodeBuffer(buffer, contentEncoding);\n}\n// Parse an in-progress request or response stream, i.e. where the body or possibly even the headers have\n// not been fully received/sent yet.\nconst parseBodyStream = (bodyStream, maxSize, getHeaders) => {\n    let bufferPromise = null;\n    let completedBuffer = null;\n    let body = {\n        // Returns a stream for the full body, not the live streaming body.\n        // Each call creates a new stream, which starts with the already seen\n        // and buffered data, and then continues with the live stream, if active.\n        // Listeners to this stream *must* be attached synchronously after this call.\n        asStream() {\n            // If we've already buffered the whole body, just stream it out:\n            if (completedBuffer)\n                return (0, buffer_utils_1.bufferToStream)(completedBuffer);\n            // Otherwise, we want to start buffering now, and wrap that with\n            // a stream that can live-stream the buffered data on demand:\n            const buffer = body.asBuffer();\n            buffer.catch(() => { }); // Errors will be handled via the stream, so silence unhandled rejections here.\n            return (0, buffer_utils_1.bufferThenStream)(buffer, bodyStream);\n        },\n        asBuffer() {\n            if (!bufferPromise) {\n                bufferPromise = (0, buffer_utils_1.streamToBuffer)(bodyStream, maxSize);\n                bufferPromise\n                    .then((buffer) => completedBuffer = buffer)\n                    .catch(() => { }); // If we get no body, completedBuffer stays null\n            }\n            return bufferPromise;\n        },\n        async asDecodedBuffer() {\n            const buffer = await body.asBuffer();\n            return decodeBodyBuffer(buffer, getHeaders());\n        },\n        asText(encoding = 'utf8') {\n            return body.asDecodedBuffer().then((b) => b.toString(encoding));\n        },\n        asJson() {\n            return body.asText().then((t) => JSON.parse(t));\n        },\n        asFormData() {\n            return body.asText().then((t) => querystring.parse(t));\n        },\n    };\n    return body;\n};\nasync function runAsyncOrUndefined(func) {\n    try {\n        return await func();\n    }\n    catch {\n        return undefined;\n    }\n}\nconst waitForBody = async (body, headers) => {\n    const bufferBody = await body.asBuffer();\n    return (0, exports.buildBodyReader)(bufferBody, headers);\n};\nconst isMockttpBody = (body) => {\n    return body.hasOwnProperty('getDecodedBuffer');\n};\nexports.isMockttpBody = isMockttpBody;\nconst buildBodyReader = (body, headers) => {\n    const completedBody = {\n        buffer: body,\n        async getDecodedBuffer() {\n            return runAsyncOrUndefined(async () => (0, buffer_utils_1.asBuffer)(await decodeBodyBuffer(this.buffer, headers)));\n        },\n        async getText() {\n            return runAsyncOrUndefined(async () => (await this.getDecodedBuffer()).toString());\n        },\n        async getJson() {\n            return runAsyncOrUndefined(async () => JSON.parse((await completedBody.getText())));\n        },\n        async getUrlEncodedFormData() {\n            return runAsyncOrUndefined(async () => {\n                const contentType = headers[\"content-type\"];\n                if (contentType?.includes(\"multipart/form-data\"))\n                    return; // Actively ignore multipart data - won't work as expected\n                const text = await completedBody.getText();\n                return text ? querystring.parse(text) : undefined;\n            });\n        },\n        async getMultipartFormData() {\n            return runAsyncOrUndefined(async () => {\n                const contentType = headers[\"content-type\"];\n                if (!contentType?.includes(\"multipart/form-data\"))\n                    return;\n                const boundary = contentType.match(/;\\s*boundary=(\\S+)/);\n                // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Type#boundary\n                // `boundary` is required for multipart entities.\n                if (!boundary)\n                    return;\n                const multipartBodyBuffer = (0, buffer_utils_1.asBuffer)(await decodeBodyBuffer(this.buffer, headers));\n                return multipart.parse(multipartBodyBuffer, boundary[1]);\n            });\n        },\n        async getFormData() {\n            return runAsyncOrUndefined(async () => {\n                // Return multi-part data if present, or fallback to default URL-encoded\n                // parsing for all other cases. Data is returned in the same format regardless.\n                const multiPartBody = await completedBody.getMultipartFormData();\n                if (multiPartBody) {\n                    const formData = {};\n                    multiPartBody.forEach((part) => {\n                        const name = part.name;\n                        if (name === undefined) {\n                            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Disposition#as_a_header_for_a_multipart_body,\n                            // The header must include `name` property to identify the field name.\n                            // So we ignore parts without a name, treating it as invalid multipart form data.\n                        }\n                        else {\n                            // We do not use `filename` or `type` here, because return value of `getFormData` must be string or string array.\n                            const prevValue = formData[name];\n                            if (prevValue === undefined) {\n                                formData[name] = part.data.toString();\n                            }\n                            else if (Array.isArray(prevValue)) {\n                                prevValue.push(part.data.toString());\n                            }\n                            else {\n                                formData[name] = [prevValue, part.data.toString()];\n                            }\n                        }\n                    });\n                    return formData;\n                }\n                else {\n                    return completedBody.getUrlEncodedFormData();\n                }\n            });\n        }\n    };\n    return completedBody;\n};\nexports.buildBodyReader = buildBodyReader;\nconst parseRequestBody = (req, options) => {\n    let transformedRequest = req;\n    transformedRequest.body = parseBodyStream(req, options.maxSize, () => req.headers);\n};\nexports.parseRequestBody = parseRequestBody;\n/**\n * Build an initiated request: the external representation of a request\n * that's just started.\n */\nfunction buildInitiatedRequest(request) {\n    return {\n        ..._.pick(request, 'id', 'matchedRuleId', 'protocol', 'httpVersion', 'method', 'url', 'path', 'remoteIpAddress', 'remotePort', 'hostname', 'headers', 'rawHeaders', 'tags'),\n        timingEvents: request.timingEvents\n    };\n}\n/**\n * Build a completed request: the external representation of a request\n * that's been completely received (but not necessarily replied to).\n */\nasync function waitForCompletedRequest(request) {\n    const body = await waitForBody(request.body, request.headers);\n    const requestData = buildInitiatedRequest(request);\n    return {\n        ...requestData,\n        body,\n        rawTrailers: request.rawTrailers ?? [],\n        trailers: (0, header_utils_1.rawHeadersToObject)(request.rawTrailers ?? [])\n    };\n}\n/**\n * Parse the accepted format of the headers argument for writeHead and addTrailers\n * into a single consistent paired-tuple format.\n */\nconst getHeaderPairsFromArgument = (headersArg) => {\n    // Two legal formats of header args (flat & object), one unofficial (tuple array)\n    if (Array.isArray(headersArg)) {\n        if (!Array.isArray(headersArg[0])) {\n            // Flat -> Raw tuples\n            return (0, header_utils_1.pairFlatRawHeaders)(headersArg);\n        }\n        else {\n            // Already raw tuples, cheeky\n            return headersArg;\n        }\n    }\n    else {\n        // Headers object -> raw tuples\n        return (0, header_utils_1.objectHeadersToRaw)(headersArg ?? {});\n    }\n};\nfunction trackResponse(response, timingEvents, tags, options) {\n    let trackedResponse = response;\n    trackedResponse.timingEvents = timingEvents;\n    trackedResponse.tags = tags;\n    // Headers are sent when .writeHead or .write() are first called\n    const trackingStream = new stream.PassThrough();\n    const originalWriteHeader = trackedResponse.writeHead;\n    const originalWrite = trackedResponse.write;\n    const originalEnd = trackedResponse.end;\n    const originalAddTrailers = trackedResponse.addTrailers;\n    const originalGetHeaders = trackedResponse.getHeaders;\n    let writtenHeaders;\n    trackedResponse.getRawHeaders = () => writtenHeaders ?? [];\n    trackedResponse.getHeaders = () => (0, header_utils_1.rawHeadersToObject)(trackedResponse.getRawHeaders());\n    trackedResponse.writeHead = function (...args) {\n        if (!timingEvents.headersSentTimestamp) {\n            timingEvents.headersSentTimestamp = now();\n        }\n        // HTTP/2 responses shouldn't have a status message:\n        if (isHttp2(trackedResponse) && typeof args[1] === 'string') {\n            args[1] = undefined;\n        }\n        let headersArg;\n        if (args[2]) {\n            headersArg = args[2];\n        }\n        else if (typeof args[1] !== 'string') {\n            headersArg = args[1];\n        }\n        writtenHeaders = getHeaderPairsFromArgument(headersArg);\n        if (isHttp2(trackedResponse)) {\n            writtenHeaders.unshift([':status', args[0].toString()]);\n        }\n        // Headers might also have been set with setHeader before. They'll be combined, with headers\n        // here taking precendence. We simulate this by pulling in all values from getHeaders() and\n        // remembering any of those that we're not about to override.\n        const storedHeaders = originalGetHeaders.apply(this);\n        const writtenHeaderKeys = writtenHeaders.map(([key]) => key.toLowerCase());\n        const storedHeaderKeys = Object.keys(storedHeaders);\n        if (storedHeaderKeys.length) {\n            storedHeaderKeys\n                .filter((key) => !writtenHeaderKeys.includes(key))\n                .reverse() // We're unshifting (these were set first) so we have to reverse to keep order.\n                .forEach((key) => {\n                const value = storedHeaders[key];\n                if (Array.isArray(value)) {\n                    value.reverse().forEach(v => writtenHeaders?.unshift([key, v]));\n                }\n                else if (value !== undefined) {\n                    writtenHeaders?.unshift([key, value]);\n                }\n            });\n        }\n        return originalWriteHeader.apply(this, args);\n    };\n    let writtenTrailers;\n    trackedResponse.getRawTrailers = () => writtenTrailers ?? [];\n    trackedResponse.addTrailers = function (...args) {\n        const trailersArg = args[0];\n        writtenTrailers = getHeaderPairsFromArgument(trailersArg);\n        return originalAddTrailers.apply(this, args);\n    };\n    const trackingWrite = function (...args) {\n        trackingStream.write.apply(trackingStream, args);\n        return originalWrite.apply(this, args);\n    };\n    trackedResponse.write = trackingWrite;\n    trackedResponse.end = function (...args) {\n        // We temporarily disable write tracking here, as .end\n        // can call this.write, but that write should not be\n        // tracked, or we'll get duplicate writes when trackingStream\n        // calls it on itself too.\n        trackedResponse.write = originalWrite;\n        trackingStream.end.apply(trackingStream, args);\n        let result = originalEnd.apply(this, args);\n        trackedResponse.write = trackingWrite;\n        return result;\n    };\n    trackedResponse.body = parseBodyStream(trackingStream, options.maxSize, () => trackedResponse.getHeaders());\n    // Proxy errors (e.g. write-after-end) to the response, so they can be\n    // handled elsewhere, rather than killing the process outright.\n    trackingStream.on('error', (e) => trackedResponse.emit('error', e));\n    return trackedResponse;\n}\n/**\n * Build a completed response: the external representation of a response\n * that's been completely written out and sent back to the client.\n */\nasync function waitForCompletedResponse(response) {\n    // Ongoing response has 'getHeaders' - completed has 'headers'.\n    if ('headers' in response)\n        return response;\n    const body = await waitForBody(response.body, response.getHeaders());\n    response.timingEvents.responseSentTimestamp = response.timingEvents.responseSentTimestamp || now();\n    const completedResponse = _(response).pick([\n        'id',\n        'statusCode',\n        'timingEvents',\n        'tags'\n    ]).assign({\n        statusMessage: '',\n        headers: response.getHeaders(),\n        rawHeaders: response.getRawHeaders(),\n        body: body,\n        rawTrailers: response.getRawTrailers(),\n        trailers: (0, header_utils_1.rawHeadersToObject)(response.getRawTrailers())\n    }).valueOf();\n    if (!(response instanceof http2.Http2ServerResponse)) {\n        // H2 has no status messages, and generates a warning if you look for one\n        completedResponse.statusMessage = response.statusMessage;\n    }\n    return completedResponse;\n}\n// Take raw HTTP request bytes received, have a go at parsing something useful out of them.\n// Very lax - this is a method to use when normal parsing has failed, not as standard\nfunction tryToParseHttpRequest(input, socket) {\n    const req = {};\n    try {\n        req.protocol = socket.__lastHopEncrypted ? \"https\" : \"http\"; // Wild guess really\n        // For TLS sockets, we default the hostname to the name given by SNI. Might be overridden\n        // by the URL or Host header later, if available.\n        if (socket instanceof tls_1.TLSSocket)\n            req.hostname = socket.servername;\n        const lines = (0, buffer_utils_1.splitBuffer)(input, '\\r\\n');\n        const requestLine = lines[0].slice(0, lines[0].length).toString('ascii');\n        const [method, rawUri, httpProtocol] = requestLine.split(\" \");\n        if (method)\n            req.method = method.slice(0, 15); // With overflows this could be *anything*. Limit it slightly.\n        // An empty line delineates the headers from the body\n        const emptyLineIndex = _.findIndex(lines, (line) => line.length === 0);\n        try {\n            const headerLines = lines.slice(1, emptyLineIndex === -1 ? undefined : emptyLineIndex);\n            const rawHeaders = headerLines\n                .map((line) => (0, buffer_utils_1.splitBuffer)(line, ':', 2))\n                .filter((line) => line.length > 1)\n                .map((headerParts) => headerParts.map(p => p.toString('utf8').trim()));\n            req.rawHeaders = rawHeaders;\n            req.headers = (0, header_utils_1.rawHeadersToObject)(rawHeaders);\n        }\n        catch (e) { }\n        try {\n            const parsedUrl = url.parse(rawUri);\n            req.path = parsedUrl.path ?? undefined;\n            const hostHeader = _.find(req.headers, (_value, key) => key.toLowerCase() === 'host');\n            if (hostHeader) {\n                req.hostname = Array.isArray(hostHeader) ? hostHeader[0] : hostHeader;\n            }\n            else if (parsedUrl.hostname) {\n                req.hostname = parsedUrl.hostname;\n            }\n            if (rawUri.includes('://') || !req.hostname) {\n                // URI is absolute, or we have no way to guess the host at all\n                req.url = rawUri;\n            }\n            else {\n                // URI is relative (or invalid) and we have a host: use it\n                req.url = `${req.protocol}://${req.hostname}${rawUri.startsWith('/') ? '' : '/' // Add a slash if the URI is garbage\n                }${rawUri}`;\n            }\n        }\n        catch (e) { }\n        try {\n            const httpVersion = httpProtocol.split('/')[1];\n            req.httpVersion = httpVersion;\n        }\n        catch (e) { }\n    }\n    catch (e) { }\n    return req;\n}\n// Take raw HTTP response bytes received, parse something useful out of them. This is *not*\n// very lax, and will throw errors due to unexpected response data, but it's used when we\n// ourselves generate the data (for websocket responses that 'ws' writes directly to the\n// socket invisibly). Fortunately all responses are very simple:\nfunction parseRawHttpResponse(input, request) {\n    const { id, tags, timingEvents } = request;\n    const lines = (0, buffer_utils_1.splitBuffer)(input, '\\r\\n');\n    const responseLine = lines[0].subarray(0, lines[0].length).toString('ascii');\n    const [_httpVersion, rawStatusCode, ...restResponseLine] = responseLine.split(\" \");\n    const statusCode = parseInt(rawStatusCode, 10);\n    const statusMessage = restResponseLine.join(' ');\n    // An empty line delineates the headers from the body\n    const emptyLineIndex = _.findIndex(lines, (line) => line.length === 0);\n    const headerLines = lines.slice(1, emptyLineIndex === -1 ? undefined : emptyLineIndex);\n    const rawHeaders = headerLines\n        .map((line) => (0, buffer_utils_1.splitBuffer)(line, ':', 2))\n        .map((headerParts) => headerParts.map(p => p.toString('utf8').trim()));\n    const headers = (0, header_utils_1.rawHeadersToObject)(rawHeaders);\n    const body = (0, exports.buildBodyReader)(Buffer.from([]), {});\n    return {\n        id,\n        tags,\n        timingEvents,\n        statusCode,\n        statusMessage,\n        rawHeaders,\n        headers,\n        body,\n        rawTrailers: [],\n        trailers: {}\n    };\n}\n//# sourceMappingURL=request-utils.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.normalizeUrl = exports.getEffectivePort = exports.getPathFromAbsoluteUrl = exports.getUrlWithoutProtocol = exports.isAbsoluteProtocollessUrl = exports.isRelativeUrl = exports.isAbsoluteUrl = void 0;\nconst url = require(\"url\");\nconst _ = require(\"lodash\");\nconst util_1 = require(\"./util\");\n// Is this URL fully qualified?\n// Note that this supports only HTTP - no websockets or anything else.\nconst isAbsoluteUrl = (url) => url.toLowerCase().startsWith('http://') ||\n    url.toLowerCase().startsWith('https://');\nexports.isAbsoluteUrl = isAbsoluteUrl;\nconst isRelativeUrl = (url) => url.startsWith('/');\nexports.isRelativeUrl = isRelativeUrl;\nconst isAbsoluteProtocollessUrl = (url) => !(0, exports.isAbsoluteUrl)(url) && !(0, exports.isRelativeUrl)(url);\nexports.isAbsoluteProtocollessUrl = isAbsoluteProtocollessUrl;\nconst getUrlWithoutProtocol = (url) => {\n    return url.split('://', 2).slice(-1).join('');\n};\nexports.getUrlWithoutProtocol = getUrlWithoutProtocol;\nconst getPathFromAbsoluteUrl = (url) => {\n    const pathIndex = (0, util_1.nthIndexOf)(url, '/', 3);\n    if (pathIndex !== -1) {\n        return url.slice(pathIndex);\n    }\n    else {\n        return '';\n    }\n};\nexports.getPathFromAbsoluteUrl = getPathFromAbsoluteUrl;\nconst getEffectivePort = (url) => {\n    if (url.port) {\n        return parseInt(url.port, 10);\n    }\n    else if (url.protocol === 'https:' || url.protocol === 'wss:') {\n        return 443;\n    }\n    else {\n        return 80;\n    }\n};\nexports.getEffectivePort = getEffectivePort;\n/**\n * Normalizes URLs to the form used when matching them.\n *\n * This accepts URLs in all three formats: relative, absolute, and protocolless-absolute,\n * and returns them in the same format but normalized.\n */\nexports.normalizeUrl = _.memoize((urlInput) => {\n    let parsedUrl;\n    let isProtocolless = false;\n    try {\n        // Strip the query and anything following it\n        const queryIndex = urlInput.indexOf('?');\n        if (queryIndex !== -1) {\n            urlInput = urlInput.slice(0, queryIndex);\n        }\n        if ((0, exports.isAbsoluteProtocollessUrl)(urlInput)) {\n            parsedUrl = url.parse('http://' + urlInput);\n            isProtocolless = true;\n        }\n        else {\n            parsedUrl = url.parse(urlInput);\n        }\n        // Trim out lots of the bits we don't like:\n        delete parsedUrl.host;\n        delete parsedUrl.query;\n        delete parsedUrl.search;\n        delete parsedUrl.hash;\n        if (parsedUrl.pathname) {\n            parsedUrl.pathname = parsedUrl.pathname.replace(/\\%[A-Fa-z0-9]{2}/g, (encoded) => encoded.toUpperCase()).replace(/[^\\u0000-\\u007F]+/g, (unicodeChar) => encodeURIComponent(unicodeChar));\n        }\n        if (parsedUrl.hostname && parsedUrl.hostname.endsWith('.')) {\n            parsedUrl.hostname = parsedUrl.hostname.slice(0, -1);\n        }\n        if ((parsedUrl.protocol === 'https:' && parsedUrl.port === '443') ||\n            (parsedUrl.protocol === 'http:' && parsedUrl.port === '80')) {\n            delete parsedUrl.port;\n        }\n    }\n    catch (e) {\n        console.log(`Failed to normalize URL ${urlInput}`);\n        console.log(e);\n        if (!parsedUrl)\n            return urlInput; // Totally unparseble: use as-is\n        // If we've successfully parsed it, we format what we managed\n        // and leave it at that:\n    }\n    let normalizedUrl = url.format(parsedUrl);\n    // If the URL came in with no protocol, it should leave with\n    // no protocol (protocol added temporarily above to allow parsing)\n    if (isProtocolless) {\n        normalizedUrl = normalizedUrl.slice('http://'.length);\n    }\n    return normalizedUrl;\n});\n//# sourceMappingURL=url.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.makePropertyWritable = exports.isNode = exports.isWeb = exports.isWorker = void 0;\nexports.nthIndexOf = nthIndexOf;\nexports.byteLength = byteLength;\nexports.delay = delay;\nfunction nthIndexOf(input, matcher, n) {\n    let index = -1;\n    while (n > 0) {\n        n = n - 1;\n        index = input.indexOf(matcher, index + 1);\n        if (index === -1)\n            break;\n    }\n    return index;\n}\n// Get the length of the given data in bytes, not characters.\n// If that's a buffer, the length is used raw, but if it's a string\n// it returns the length when encoded as UTF8.\nfunction byteLength(input) {\n    if (typeof input === 'string') {\n        return exports.isNode\n            ? Buffer.from(input, 'utf8').byteLength\n            : new Blob([input]).size;\n    }\n    else {\n        return input.length;\n    }\n}\nfunction delay(t) {\n    return new Promise((r) => setTimeout(r, t));\n}\nexports.isWorker = typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope;\nexports.isWeb = typeof Window !== 'undefined' && self instanceof Window;\nexports.isNode = !exports.isWorker && !exports.isWeb && typeof process === 'object' && process.version;\nconst makePropertyWritable = (obj, property) => Object.defineProperty(obj, property, {\n    value: obj[property],\n    writable: true\n});\nexports.makePropertyWritable = makePropertyWritable;\n//# sourceMappingURL=util.js.map","\"use strict\";\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [op[0] & 2, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nvar __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.SubscriptionClient = void 0;\nvar _global = typeof global !== 'undefined' ? global : (typeof window !== 'undefined' ? window : {});\nvar NativeWebSocket = _global.WebSocket || _global.MozWebSocket;\nvar Backoff = require(\"backo2\");\nvar eventemitter3_1 = require(\"eventemitter3\");\nvar is_string_1 = require(\"./utils/is-string\");\nvar is_object_1 = require(\"./utils/is-object\");\nvar printer_1 = require(\"graphql/language/printer\");\nvar getOperationAST_1 = require(\"graphql/utilities/getOperationAST\");\nvar symbol_observable_1 = require(\"symbol-observable\");\nvar protocol_1 = require(\"./protocol\");\nvar defaults_1 = require(\"./defaults\");\nvar message_types_1 = require(\"./message-types\");\nvar SubscriptionClient = (function () {\n    function SubscriptionClient(url, options, webSocketImpl, webSocketProtocols) {\n        var _a = (options || {}), _b = _a.connectionCallback, connectionCallback = _b === void 0 ? undefined : _b, _c = _a.connectionParams, connectionParams = _c === void 0 ? {} : _c, _d = _a.minTimeout, minTimeout = _d === void 0 ? defaults_1.MIN_WS_TIMEOUT : _d, _e = _a.timeout, timeout = _e === void 0 ? defaults_1.WS_TIMEOUT : _e, _f = _a.reconnect, reconnect = _f === void 0 ? false : _f, _g = _a.reconnectionAttempts, reconnectionAttempts = _g === void 0 ? Infinity : _g, _h = _a.lazy, lazy = _h === void 0 ? false : _h, _j = _a.inactivityTimeout, inactivityTimeout = _j === void 0 ? 0 : _j, _k = _a.wsOptionArguments, wsOptionArguments = _k === void 0 ? [] : _k;\n        this.wsImpl = webSocketImpl || NativeWebSocket;\n        if (!this.wsImpl) {\n            throw new Error('Unable to find native implementation, or alternative implementation for WebSocket!');\n        }\n        this.wsProtocols = webSocketProtocols || protocol_1.GRAPHQL_WS;\n        this.connectionCallback = connectionCallback;\n        this.url = url;\n        this.operations = {};\n        this.nextOperationId = 0;\n        this.minWsTimeout = minTimeout;\n        this.wsTimeout = timeout;\n        this.unsentMessagesQueue = [];\n        this.reconnect = reconnect;\n        this.reconnecting = false;\n        this.reconnectionAttempts = reconnectionAttempts;\n        this.lazy = !!lazy;\n        this.inactivityTimeout = inactivityTimeout;\n        this.closedByUser = false;\n        this.backoff = new Backoff({ jitter: 0.5 });\n        this.eventEmitter = new eventemitter3_1.EventEmitter();\n        this.middlewares = [];\n        this.client = null;\n        this.maxConnectTimeGenerator = this.createMaxConnectTimeGenerator();\n        this.connectionParams = this.getConnectionParams(connectionParams);\n        this.wsOptionArguments = wsOptionArguments;\n        if (!this.lazy) {\n            this.connect();\n        }\n    }\n    Object.defineProperty(SubscriptionClient.prototype, \"status\", {\n        get: function () {\n            if (this.client === null) {\n                return this.wsImpl.CLOSED;\n            }\n            return this.client.readyState;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    SubscriptionClient.prototype.close = function (isForced, closedByUser) {\n        if (isForced === void 0) { isForced = true; }\n        if (closedByUser === void 0) { closedByUser = true; }\n        this.clearInactivityTimeout();\n        if (this.client !== null) {\n            this.closedByUser = closedByUser;\n            if (isForced) {\n                this.clearCheckConnectionInterval();\n                this.clearMaxConnectTimeout();\n                this.clearTryReconnectTimeout();\n                this.unsubscribeAll();\n                this.sendMessage(undefined, message_types_1.default.GQL_CONNECTION_TERMINATE, null);\n            }\n            this.client.close();\n            this.client.onopen = null;\n            this.client.onclose = null;\n            this.client.onmessage = null;\n            this.client.onerror = function () { };\n            this.client = null;\n            this.eventEmitter.emit('disconnected');\n            if (!isForced) {\n                this.tryReconnect();\n            }\n        }\n    };\n    SubscriptionClient.prototype.request = function (request) {\n        var _a;\n        var getObserver = this.getObserver.bind(this);\n        var executeOperation = this.executeOperation.bind(this);\n        var unsubscribe = this.unsubscribe.bind(this);\n        var opId;\n        this.clearInactivityTimeout();\n        return _a = {},\n            _a[symbol_observable_1.default] = function () {\n                return this;\n            },\n            _a.subscribe = function (observerOrNext, onError, onComplete) {\n                var observer = getObserver(observerOrNext, onError, onComplete);\n                opId = executeOperation(request, function (error, result) {\n                    if (error === null && result === null) {\n                        if (observer.complete) {\n                            observer.complete();\n                        }\n                    }\n                    else if (error) {\n                        if (observer.error) {\n                            observer.error(error[0]);\n                        }\n                    }\n                    else {\n                        if (observer.next) {\n                            observer.next(result);\n                        }\n                    }\n                });\n                return {\n                    unsubscribe: function () {\n                        if (opId) {\n                            unsubscribe(opId);\n                            opId = null;\n                        }\n                    },\n                };\n            },\n            _a;\n    };\n    SubscriptionClient.prototype.on = function (eventName, callback, context) {\n        var handler = this.eventEmitter.on(eventName, callback, context);\n        return function () {\n            handler.off(eventName, callback, context);\n        };\n    };\n    SubscriptionClient.prototype.onConnected = function (callback, context) {\n        return this.on('connected', callback, context);\n    };\n    SubscriptionClient.prototype.onConnecting = function (callback, context) {\n        return this.on('connecting', callback, context);\n    };\n    SubscriptionClient.prototype.onDisconnected = function (callback, context) {\n        return this.on('disconnected', callback, context);\n    };\n    SubscriptionClient.prototype.onReconnected = function (callback, context) {\n        return this.on('reconnected', callback, context);\n    };\n    SubscriptionClient.prototype.onReconnecting = function (callback, context) {\n        return this.on('reconnecting', callback, context);\n    };\n    SubscriptionClient.prototype.onError = function (callback, context) {\n        return this.on('error', callback, context);\n    };\n    SubscriptionClient.prototype.unsubscribeAll = function () {\n        var _this = this;\n        Object.keys(this.operations).forEach(function (subId) {\n            _this.unsubscribe(subId);\n        });\n    };\n    SubscriptionClient.prototype.applyMiddlewares = function (options) {\n        var _this = this;\n        return new Promise(function (resolve, reject) {\n            var queue = function (funcs, scope) {\n                var next = function (error) {\n                    if (error) {\n                        reject(error);\n                    }\n                    else {\n                        if (funcs.length > 0) {\n                            var f = funcs.shift();\n                            if (f) {\n                                f.applyMiddleware.apply(scope, [options, next]);\n                            }\n                        }\n                        else {\n                            resolve(options);\n                        }\n                    }\n                };\n                next();\n            };\n            queue(__spreadArray([], _this.middlewares, true), _this);\n        });\n    };\n    SubscriptionClient.prototype.use = function (middlewares) {\n        var _this = this;\n        middlewares.map(function (middleware) {\n            if (typeof middleware.applyMiddleware === 'function') {\n                _this.middlewares.push(middleware);\n            }\n            else {\n                throw new Error('Middleware must implement the applyMiddleware function.');\n            }\n        });\n        return this;\n    };\n    SubscriptionClient.prototype.getConnectionParams = function (connectionParams) {\n        return function () { return new Promise(function (resolve, reject) {\n            if (typeof connectionParams === 'function') {\n                try {\n                    return resolve(connectionParams.call(null));\n                }\n                catch (error) {\n                    return reject(error);\n                }\n            }\n            resolve(connectionParams);\n        }); };\n    };\n    SubscriptionClient.prototype.executeOperation = function (options, handler) {\n        var _this = this;\n        if (this.client === null) {\n            this.connect();\n        }\n        var opId = this.generateOperationId();\n        this.operations[opId] = { options: options, handler: handler };\n        this.applyMiddlewares(options)\n            .then(function (processedOptions) {\n            _this.checkOperationOptions(processedOptions, handler);\n            if (_this.operations[opId]) {\n                _this.operations[opId] = { options: processedOptions, handler: handler };\n                _this.sendMessage(opId, message_types_1.default.GQL_START, processedOptions);\n            }\n        })\n            .catch(function (error) {\n            _this.unsubscribe(opId);\n            handler(_this.formatErrors(error));\n        });\n        return opId;\n    };\n    SubscriptionClient.prototype.getObserver = function (observerOrNext, error, complete) {\n        if (typeof observerOrNext === 'function') {\n            return {\n                next: function (v) { return observerOrNext(v); },\n                error: function (e) { return error && error(e); },\n                complete: function () { return complete && complete(); },\n            };\n        }\n        return observerOrNext;\n    };\n    SubscriptionClient.prototype.createMaxConnectTimeGenerator = function () {\n        var minValue = this.minWsTimeout;\n        var maxValue = this.wsTimeout;\n        return new Backoff({\n            min: minValue,\n            max: maxValue,\n            factor: 1.2,\n        });\n    };\n    SubscriptionClient.prototype.clearCheckConnectionInterval = function () {\n        if (this.checkConnectionIntervalId) {\n            clearInterval(this.checkConnectionIntervalId);\n            this.checkConnectionIntervalId = null;\n        }\n    };\n    SubscriptionClient.prototype.clearMaxConnectTimeout = function () {\n        if (this.maxConnectTimeoutId) {\n            clearTimeout(this.maxConnectTimeoutId);\n            this.maxConnectTimeoutId = null;\n        }\n    };\n    SubscriptionClient.prototype.clearTryReconnectTimeout = function () {\n        if (this.tryReconnectTimeoutId) {\n            clearTimeout(this.tryReconnectTimeoutId);\n            this.tryReconnectTimeoutId = null;\n        }\n    };\n    SubscriptionClient.prototype.clearInactivityTimeout = function () {\n        if (this.inactivityTimeoutId) {\n            clearTimeout(this.inactivityTimeoutId);\n            this.inactivityTimeoutId = null;\n        }\n    };\n    SubscriptionClient.prototype.setInactivityTimeout = function () {\n        var _this = this;\n        if (this.inactivityTimeout > 0 && Object.keys(this.operations).length === 0) {\n            this.inactivityTimeoutId = setTimeout(function () {\n                if (Object.keys(_this.operations).length === 0) {\n                    _this.close();\n                }\n            }, this.inactivityTimeout);\n        }\n    };\n    SubscriptionClient.prototype.checkOperationOptions = function (options, handler) {\n        var query = options.query, variables = options.variables, operationName = options.operationName;\n        if (!query) {\n            throw new Error('Must provide a query.');\n        }\n        if (!handler) {\n            throw new Error('Must provide an handler.');\n        }\n        if ((!(0, is_string_1.default)(query) && !(0, getOperationAST_1.getOperationAST)(query, operationName)) ||\n            (operationName && !(0, is_string_1.default)(operationName)) ||\n            (variables && !(0, is_object_1.default)(variables))) {\n            throw new Error('Incorrect option types. query must be a string or a document,' +\n                '`operationName` must be a string, and `variables` must be an object.');\n        }\n    };\n    SubscriptionClient.prototype.buildMessage = function (id, type, payload) {\n        var payloadToReturn = payload && payload.query ? __assign(__assign({}, payload), { query: typeof payload.query === 'string' ? payload.query : (0, printer_1.print)(payload.query) }) :\n            payload;\n        return {\n            id: id,\n            type: type,\n            payload: payloadToReturn,\n        };\n    };\n    SubscriptionClient.prototype.formatErrors = function (errors) {\n        if (Array.isArray(errors)) {\n            return errors;\n        }\n        if (errors && errors.errors) {\n            return this.formatErrors(errors.errors);\n        }\n        if (errors && errors.message) {\n            return [errors];\n        }\n        return [{\n                name: 'FormatedError',\n                message: 'Unknown error',\n                originalError: errors,\n            }];\n    };\n    SubscriptionClient.prototype.sendMessage = function (id, type, payload) {\n        this.sendMessageRaw(this.buildMessage(id, type, payload));\n    };\n    SubscriptionClient.prototype.sendMessageRaw = function (message) {\n        switch (this.status) {\n            case this.wsImpl.OPEN:\n                var serializedMessage = JSON.stringify(message);\n                try {\n                    JSON.parse(serializedMessage);\n                }\n                catch (e) {\n                    this.eventEmitter.emit('error', new Error(\"Message must be JSON-serializable. Got: \".concat(message)));\n                }\n                this.client.send(serializedMessage);\n                break;\n            case this.wsImpl.CONNECTING:\n                this.unsentMessagesQueue.push(message);\n                break;\n            default:\n                if (!this.reconnecting) {\n                    this.eventEmitter.emit('error', new Error('A message was not sent because socket is not connected, is closing or ' +\n                        'is already closed. Message was: ' + JSON.stringify(message)));\n                }\n        }\n    };\n    SubscriptionClient.prototype.generateOperationId = function () {\n        return String(++this.nextOperationId);\n    };\n    SubscriptionClient.prototype.tryReconnect = function () {\n        var _this = this;\n        if (!this.reconnect || this.backoff.attempts >= this.reconnectionAttempts) {\n            return;\n        }\n        if (!this.reconnecting) {\n            Object.keys(this.operations).forEach(function (key) {\n                _this.unsentMessagesQueue.push(_this.buildMessage(key, message_types_1.default.GQL_START, _this.operations[key].options));\n            });\n            this.reconnecting = true;\n        }\n        this.clearTryReconnectTimeout();\n        var delay = this.backoff.duration();\n        this.tryReconnectTimeoutId = setTimeout(function () {\n            _this.connect();\n        }, delay);\n    };\n    SubscriptionClient.prototype.flushUnsentMessagesQueue = function () {\n        var _this = this;\n        this.unsentMessagesQueue.forEach(function (message) {\n            _this.sendMessageRaw(message);\n        });\n        this.unsentMessagesQueue = [];\n    };\n    SubscriptionClient.prototype.checkConnection = function () {\n        if (this.wasKeepAliveReceived) {\n            this.wasKeepAliveReceived = false;\n            return;\n        }\n        if (!this.reconnecting) {\n            this.close(false, true);\n        }\n    };\n    SubscriptionClient.prototype.checkMaxConnectTimeout = function () {\n        var _this = this;\n        this.clearMaxConnectTimeout();\n        this.maxConnectTimeoutId = setTimeout(function () {\n            if (_this.status !== _this.wsImpl.OPEN) {\n                _this.reconnecting = true;\n                _this.close(false, true);\n            }\n        }, this.maxConnectTimeGenerator.duration());\n    };\n    SubscriptionClient.prototype.connect = function () {\n        var _a;\n        var _this = this;\n        this.client = new ((_a = this.wsImpl).bind.apply(_a, __spreadArray([void 0, this.url, this.wsProtocols], this.wsOptionArguments, false)))();\n        this.checkMaxConnectTimeout();\n        this.client.onopen = function () { return __awaiter(_this, void 0, void 0, function () {\n            var connectionParams, error_1;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        if (!(this.status === this.wsImpl.OPEN)) return [3, 4];\n                        this.clearMaxConnectTimeout();\n                        this.closedByUser = false;\n                        this.eventEmitter.emit(this.reconnecting ? 'reconnecting' : 'connecting');\n                        _a.label = 1;\n                    case 1:\n                        _a.trys.push([1, 3, , 4]);\n                        return [4, this.connectionParams()];\n                    case 2:\n                        connectionParams = _a.sent();\n                        this.sendMessage(undefined, message_types_1.default.GQL_CONNECTION_INIT, connectionParams);\n                        this.flushUnsentMessagesQueue();\n                        return [3, 4];\n                    case 3:\n                        error_1 = _a.sent();\n                        this.sendMessage(undefined, message_types_1.default.GQL_CONNECTION_ERROR, error_1);\n                        this.flushUnsentMessagesQueue();\n                        return [3, 4];\n                    case 4: return [2];\n                }\n            });\n        }); };\n        this.client.onclose = function () {\n            if (!_this.closedByUser) {\n                _this.close(false, false);\n            }\n        };\n        this.client.onerror = function (err) {\n            _this.eventEmitter.emit('error', err);\n        };\n        this.client.onmessage = function (_a) {\n            var data = _a.data;\n            _this.processReceivedData(data.toString());\n        };\n    };\n    SubscriptionClient.prototype.processReceivedData = function (receivedData) {\n        var parsedMessage;\n        var opId;\n        try {\n            parsedMessage = JSON.parse(receivedData);\n            opId = parsedMessage.id;\n        }\n        catch (e) {\n            throw new Error(\"Message must be JSON-parseable. Got: \".concat(receivedData));\n        }\n        if ([message_types_1.default.GQL_DATA,\n            message_types_1.default.GQL_COMPLETE,\n            message_types_1.default.GQL_ERROR,\n        ].indexOf(parsedMessage.type) !== -1 && !this.operations[opId]) {\n            this.unsubscribe(opId);\n            return;\n        }\n        switch (parsedMessage.type) {\n            case message_types_1.default.GQL_CONNECTION_ERROR:\n                if (this.connectionCallback) {\n                    this.connectionCallback(parsedMessage.payload);\n                }\n                break;\n            case message_types_1.default.GQL_CONNECTION_ACK:\n                this.eventEmitter.emit(this.reconnecting ? 'reconnected' : 'connected', parsedMessage.payload);\n                this.reconnecting = false;\n                this.backoff.reset();\n                this.maxConnectTimeGenerator.reset();\n                if (this.connectionCallback) {\n                    this.connectionCallback();\n                }\n                break;\n            case message_types_1.default.GQL_COMPLETE:\n                var handler = this.operations[opId].handler;\n                delete this.operations[opId];\n                handler.call(this, null, null);\n                break;\n            case message_types_1.default.GQL_ERROR:\n                this.operations[opId].handler(this.formatErrors(parsedMessage.payload), null);\n                delete this.operations[opId];\n                break;\n            case message_types_1.default.GQL_DATA:\n                var parsedPayload = !parsedMessage.payload.errors ?\n                    parsedMessage.payload : __assign(__assign({}, parsedMessage.payload), { errors: this.formatErrors(parsedMessage.payload.errors) });\n                this.operations[opId].handler(null, parsedPayload);\n                break;\n            case message_types_1.default.GQL_CONNECTION_KEEP_ALIVE:\n                var firstKA = typeof this.wasKeepAliveReceived === 'undefined';\n                this.wasKeepAliveReceived = true;\n                if (firstKA) {\n                    this.checkConnection();\n                }\n                if (this.checkConnectionIntervalId) {\n                    clearInterval(this.checkConnectionIntervalId);\n                    this.checkConnection();\n                }\n                this.checkConnectionIntervalId = setInterval(this.checkConnection.bind(this), this.wsTimeout);\n                break;\n            default:\n                throw new Error('Invalid message type!');\n        }\n    };\n    SubscriptionClient.prototype.unsubscribe = function (opId) {\n        if (this.operations[opId]) {\n            delete this.operations[opId];\n            this.setInactivityTimeout();\n            this.sendMessage(opId, message_types_1.default.GQL_STOP, undefined);\n        }\n    };\n    return SubscriptionClient;\n}());\nexports.SubscriptionClient = SubscriptionClient;\n//# sourceMappingURL=client.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.WS_TIMEOUT = exports.MIN_WS_TIMEOUT = void 0;\nvar MIN_WS_TIMEOUT = 1000;\nexports.MIN_WS_TIMEOUT = MIN_WS_TIMEOUT;\nvar WS_TIMEOUT = 30000;\nexports.WS_TIMEOUT = WS_TIMEOUT;\n//# sourceMappingURL=defaults.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar MessageTypes = (function () {\n    function MessageTypes() {\n        throw new Error('Static Class');\n    }\n    MessageTypes.GQL_CONNECTION_INIT = 'connection_init';\n    MessageTypes.GQL_CONNECTION_ACK = 'connection_ack';\n    MessageTypes.GQL_CONNECTION_ERROR = 'connection_error';\n    MessageTypes.GQL_CONNECTION_KEEP_ALIVE = 'ka';\n    MessageTypes.GQL_CONNECTION_TERMINATE = 'connection_terminate';\n    MessageTypes.GQL_START = 'start';\n    MessageTypes.GQL_DATA = 'data';\n    MessageTypes.GQL_ERROR = 'error';\n    MessageTypes.GQL_COMPLETE = 'complete';\n    MessageTypes.GQL_STOP = 'stop';\n    MessageTypes.SUBSCRIPTION_START = 'subscription_start';\n    MessageTypes.SUBSCRIPTION_DATA = 'subscription_data';\n    MessageTypes.SUBSCRIPTION_SUCCESS = 'subscription_success';\n    MessageTypes.SUBSCRIPTION_FAIL = 'subscription_fail';\n    MessageTypes.SUBSCRIPTION_END = 'subscription_end';\n    MessageTypes.INIT = 'init';\n    MessageTypes.INIT_SUCCESS = 'init_success';\n    MessageTypes.INIT_FAIL = 'init_fail';\n    MessageTypes.KEEP_ALIVE = 'keepalive';\n    return MessageTypes;\n}());\nexports.default = MessageTypes;\n//# sourceMappingURL=message-types.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.GRAPHQL_SUBSCRIPTIONS = exports.GRAPHQL_WS = void 0;\nvar GRAPHQL_WS = 'graphql-ws';\nexports.GRAPHQL_WS = GRAPHQL_WS;\nvar GRAPHQL_SUBSCRIPTIONS = 'graphql-subscriptions';\nexports.GRAPHQL_SUBSCRIPTIONS = GRAPHQL_SUBSCRIPTIONS;\n//# sourceMappingURL=protocol.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nfunction isObject(value) {\n    return ((value !== null) && (typeof value === 'object'));\n}\nexports.default = isObject;\n//# sourceMappingURL=is-object.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nfunction isString(value) {\n    return typeof value === 'string';\n}\nexports.default = isString;\n//# sourceMappingURL=is-string.js.map","/*\n * base64-arraybuffer\n * https://github.com/niklasvh/base64-arraybuffer\n *\n * Copyright (c) 2012 Niklas von Hertzen\n * Licensed under the MIT license.\n */\n(function(){\n  \"use strict\";\n\n  var chars = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n\n  // Use a lookup table to find the index.\n  var lookup = new Uint8Array(256);\n  for (var i = 0; i < chars.length; i++) {\n    lookup[chars.charCodeAt(i)] = i;\n  }\n\n  exports.encode = function(arraybuffer) {\n    var bytes = new Uint8Array(arraybuffer),\n    i, len = bytes.length, base64 = \"\";\n\n    for (i = 0; i < len; i+=3) {\n      base64 += chars[bytes[i] >> 2];\n      base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];\n      base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];\n      base64 += chars[bytes[i + 2] & 63];\n    }\n\n    if ((len % 3) === 2) {\n      base64 = base64.substring(0, base64.length - 1) + \"=\";\n    } else if (len % 3 === 1) {\n      base64 = base64.substring(0, base64.length - 2) + \"==\";\n    }\n\n    return base64;\n  };\n\n  exports.decode =  function(base64) {\n    var bufferLength = base64.length * 0.75,\n    len = base64.length, i, p = 0,\n    encoded1, encoded2, encoded3, encoded4;\n\n    if (base64[base64.length - 1] === \"=\") {\n      bufferLength--;\n      if (base64[base64.length - 2] === \"=\") {\n        bufferLength--;\n      }\n    }\n\n    var arraybuffer = new ArrayBuffer(bufferLength),\n    bytes = new Uint8Array(arraybuffer);\n\n    for (i = 0; i < len; i+=4) {\n      encoded1 = lookup[base64.charCodeAt(i)];\n      encoded2 = lookup[base64.charCodeAt(i+1)];\n      encoded3 = lookup[base64.charCodeAt(i+2)];\n      encoded4 = lookup[base64.charCodeAt(i+3)];\n\n      bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);\n      bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);\n      bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);\n    }\n\n    return arraybuffer;\n  };\n})();\n","export default '00000000-0000-0000-0000-000000000000';","import validate from './validate.js';\n\nfunction parse(uuid) {\n  if (!validate(uuid)) {\n    throw TypeError('Invalid UUID');\n  }\n\n  var v;\n  var arr = new Uint8Array(16); // Parse ########-....-....-....-............\n\n  arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;\n  arr[1] = v >>> 16 & 0xff;\n  arr[2] = v >>> 8 & 0xff;\n  arr[3] = v & 0xff; // Parse ........-####-....-....-............\n\n  arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;\n  arr[5] = v & 0xff; // Parse ........-....-####-....-............\n\n  arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;\n  arr[7] = v & 0xff; // Parse ........-....-....-####-............\n\n  arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;\n  arr[9] = v & 0xff; // Parse ........-....-....-....-############\n  // (Use \"/\" to avoid 32-bit truncation when bit-shifting high-order bytes)\n\n  arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff;\n  arr[11] = v / 0x100000000 & 0xff;\n  arr[12] = v >>> 24 & 0xff;\n  arr[13] = v >>> 16 & 0xff;\n  arr[14] = v >>> 8 & 0xff;\n  arr[15] = v & 0xff;\n  return arr;\n}\n\nexport default parse;","export default /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;","// Unique ID creation requires a high quality random # generator. In the browser we therefore\n// require the crypto API and do not support built-in fallback to lower quality random number\n// generators (like Math.random()).\nvar getRandomValues;\nvar rnds8 = new Uint8Array(16);\nexport default function rng() {\n  // lazy load so that environments that need to polyfill have a chance to do so\n  if (!getRandomValues) {\n    // getRandomValues needs to be invoked in a context where \"this\" is a Crypto implementation. Also,\n    // find the complete implementation of crypto (msCrypto) on IE11.\n    getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto !== 'undefined' && typeof msCrypto.getRandomValues === 'function' && msCrypto.getRandomValues.bind(msCrypto);\n\n    if (!getRandomValues) {\n      throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');\n    }\n  }\n\n  return getRandomValues(rnds8);\n}","import validate from './validate.js';\n/**\n * Convert array of 16 byte values to UUID string format of the form:\n * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX\n */\n\nvar byteToHex = [];\n\nfor (var i = 0; i < 256; ++i) {\n  byteToHex.push((i + 0x100).toString(16).substr(1));\n}\n\nfunction stringify(arr) {\n  var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n  // Note: Be careful editing this code!  It's been tuned for performance\n  // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434\n  var uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID.  If this throws, it's likely due to one\n  // of the following:\n  // - One or more input array values don't map to a hex octet (leading to\n  // \"undefined\" in the uuid)\n  // - Invalid input values for the RFC `version` or `variant` fields\n\n  if (!validate(uuid)) {\n    throw TypeError('Stringified UUID is invalid');\n  }\n\n  return uuid;\n}\n\nexport default stringify;","import rng from './rng.js';\nimport stringify from './stringify.js'; // **`v1()` - Generate time-based UUID**\n//\n// Inspired by https://github.com/LiosK/UUID.js\n// and http://docs.python.org/library/uuid.html\n\nvar _nodeId;\n\nvar _clockseq; // Previous uuid creation time\n\n\nvar _lastMSecs = 0;\nvar _lastNSecs = 0; // See https://github.com/uuidjs/uuid for API details\n\nfunction v1(options, buf, offset) {\n  var i = buf && offset || 0;\n  var b = buf || new Array(16);\n  options = options || {};\n  var node = options.node || _nodeId;\n  var clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq; // node and clockseq need to be initialized to random values if they're not\n  // specified.  We do this lazily to minimize issues related to insufficient\n  // system entropy.  See #189\n\n  if (node == null || clockseq == null) {\n    var seedBytes = options.random || (options.rng || rng)();\n\n    if (node == null) {\n      // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)\n      node = _nodeId = [seedBytes[0] | 0x01, seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]];\n    }\n\n    if (clockseq == null) {\n      // Per 4.2.2, randomize (14 bit) clockseq\n      clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff;\n    }\n  } // UUID timestamps are 100 nano-second units since the Gregorian epoch,\n  // (1582-10-15 00:00).  JSNumbers aren't precise enough for this, so\n  // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'\n  // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.\n\n\n  var msecs = options.msecs !== undefined ? options.msecs : Date.now(); // Per 4.2.1.2, use count of uuid's generated during the current clock\n  // cycle to simulate higher resolution clock\n\n  var nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1; // Time since last uuid creation (in msecs)\n\n  var dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 10000; // Per 4.2.1.2, Bump clockseq on clock regression\n\n  if (dt < 0 && options.clockseq === undefined) {\n    clockseq = clockseq + 1 & 0x3fff;\n  } // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new\n  // time interval\n\n\n  if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) {\n    nsecs = 0;\n  } // Per 4.2.1.2 Throw error if too many uuids are requested\n\n\n  if (nsecs >= 10000) {\n    throw new Error(\"uuid.v1(): Can't create more than 10M uuids/sec\");\n  }\n\n  _lastMSecs = msecs;\n  _lastNSecs = nsecs;\n  _clockseq = clockseq; // Per 4.1.4 - Convert from unix epoch to Gregorian epoch\n\n  msecs += 12219292800000; // `time_low`\n\n  var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;\n  b[i++] = tl >>> 24 & 0xff;\n  b[i++] = tl >>> 16 & 0xff;\n  b[i++] = tl >>> 8 & 0xff;\n  b[i++] = tl & 0xff; // `time_mid`\n\n  var tmh = msecs / 0x100000000 * 10000 & 0xfffffff;\n  b[i++] = tmh >>> 8 & 0xff;\n  b[i++] = tmh & 0xff; // `time_high_and_version`\n\n  b[i++] = tmh >>> 24 & 0xf | 0x10; // include version\n\n  b[i++] = tmh >>> 16 & 0xff; // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)\n\n  b[i++] = clockseq >>> 8 | 0x80; // `clock_seq_low`\n\n  b[i++] = clockseq & 0xff; // `node`\n\n  for (var n = 0; n < 6; ++n) {\n    b[i + n] = node[n];\n  }\n\n  return buf || stringify(b);\n}\n\nexport default v1;","/*\n * Browser-compatible JavaScript MD5\n *\n * Modification of JavaScript MD5\n * https://github.com/blueimp/JavaScript-MD5\n *\n * Copyright 2011, Sebastian Tschan\n * https://blueimp.net\n *\n * Licensed under the MIT license:\n * https://opensource.org/licenses/MIT\n *\n * Based on\n * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message\n * Digest Algorithm, as defined in RFC 1321.\n * Version 2.2 Copyright (C) Paul Johnston 1999 - 2009\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n * Distributed under the BSD License\n * See http://pajhome.org.uk/crypt/md5 for more info.\n */\nfunction md5(bytes) {\n  if (typeof bytes === 'string') {\n    var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape\n\n    bytes = new Uint8Array(msg.length);\n\n    for (var i = 0; i < msg.length; ++i) {\n      bytes[i] = msg.charCodeAt(i);\n    }\n  }\n\n  return md5ToHexEncodedArray(wordsToMd5(bytesToWords(bytes), bytes.length * 8));\n}\n/*\n * Convert an array of little-endian words to an array of bytes\n */\n\n\nfunction md5ToHexEncodedArray(input) {\n  var output = [];\n  var length32 = input.length * 32;\n  var hexTab = '0123456789abcdef';\n\n  for (var i = 0; i < length32; i += 8) {\n    var x = input[i >> 5] >>> i % 32 & 0xff;\n    var hex = parseInt(hexTab.charAt(x >>> 4 & 0x0f) + hexTab.charAt(x & 0x0f), 16);\n    output.push(hex);\n  }\n\n  return output;\n}\n/**\n * Calculate output length with padding and bit length\n */\n\n\nfunction getOutputLength(inputLength8) {\n  return (inputLength8 + 64 >>> 9 << 4) + 14 + 1;\n}\n/*\n * Calculate the MD5 of an array of little-endian words, and a bit length.\n */\n\n\nfunction wordsToMd5(x, len) {\n  /* append padding */\n  x[len >> 5] |= 0x80 << len % 32;\n  x[getOutputLength(len) - 1] = len;\n  var a = 1732584193;\n  var b = -271733879;\n  var c = -1732584194;\n  var d = 271733878;\n\n  for (var i = 0; i < x.length; i += 16) {\n    var olda = a;\n    var oldb = b;\n    var oldc = c;\n    var oldd = d;\n    a = md5ff(a, b, c, d, x[i], 7, -680876936);\n    d = md5ff(d, a, b, c, x[i + 1], 12, -389564586);\n    c = md5ff(c, d, a, b, x[i + 2], 17, 606105819);\n    b = md5ff(b, c, d, a, x[i + 3], 22, -1044525330);\n    a = md5ff(a, b, c, d, x[i + 4], 7, -176418897);\n    d = md5ff(d, a, b, c, x[i + 5], 12, 1200080426);\n    c = md5ff(c, d, a, b, x[i + 6], 17, -1473231341);\n    b = md5ff(b, c, d, a, x[i + 7], 22, -45705983);\n    a = md5ff(a, b, c, d, x[i + 8], 7, 1770035416);\n    d = md5ff(d, a, b, c, x[i + 9], 12, -1958414417);\n    c = md5ff(c, d, a, b, x[i + 10], 17, -42063);\n    b = md5ff(b, c, d, a, x[i + 11], 22, -1990404162);\n    a = md5ff(a, b, c, d, x[i + 12], 7, 1804603682);\n    d = md5ff(d, a, b, c, x[i + 13], 12, -40341101);\n    c = md5ff(c, d, a, b, x[i + 14], 17, -1502002290);\n    b = md5ff(b, c, d, a, x[i + 15], 22, 1236535329);\n    a = md5gg(a, b, c, d, x[i + 1], 5, -165796510);\n    d = md5gg(d, a, b, c, x[i + 6], 9, -1069501632);\n    c = md5gg(c, d, a, b, x[i + 11], 14, 643717713);\n    b = md5gg(b, c, d, a, x[i], 20, -373897302);\n    a = md5gg(a, b, c, d, x[i + 5], 5, -701558691);\n    d = md5gg(d, a, b, c, x[i + 10], 9, 38016083);\n    c = md5gg(c, d, a, b, x[i + 15], 14, -660478335);\n    b = md5gg(b, c, d, a, x[i + 4], 20, -405537848);\n    a = md5gg(a, b, c, d, x[i + 9], 5, 568446438);\n    d = md5gg(d, a, b, c, x[i + 14], 9, -1019803690);\n    c = md5gg(c, d, a, b, x[i + 3], 14, -187363961);\n    b = md5gg(b, c, d, a, x[i + 8], 20, 1163531501);\n    a = md5gg(a, b, c, d, x[i + 13], 5, -1444681467);\n    d = md5gg(d, a, b, c, x[i + 2], 9, -51403784);\n    c = md5gg(c, d, a, b, x[i + 7], 14, 1735328473);\n    b = md5gg(b, c, d, a, x[i + 12], 20, -1926607734);\n    a = md5hh(a, b, c, d, x[i + 5], 4, -378558);\n    d = md5hh(d, a, b, c, x[i + 8], 11, -2022574463);\n    c = md5hh(c, d, a, b, x[i + 11], 16, 1839030562);\n    b = md5hh(b, c, d, a, x[i + 14], 23, -35309556);\n    a = md5hh(a, b, c, d, x[i + 1], 4, -1530992060);\n    d = md5hh(d, a, b, c, x[i + 4], 11, 1272893353);\n    c = md5hh(c, d, a, b, x[i + 7], 16, -155497632);\n    b = md5hh(b, c, d, a, x[i + 10], 23, -1094730640);\n    a = md5hh(a, b, c, d, x[i + 13], 4, 681279174);\n    d = md5hh(d, a, b, c, x[i], 11, -358537222);\n    c = md5hh(c, d, a, b, x[i + 3], 16, -722521979);\n    b = md5hh(b, c, d, a, x[i + 6], 23, 76029189);\n    a = md5hh(a, b, c, d, x[i + 9], 4, -640364487);\n    d = md5hh(d, a, b, c, x[i + 12], 11, -421815835);\n    c = md5hh(c, d, a, b, x[i + 15], 16, 530742520);\n    b = md5hh(b, c, d, a, x[i + 2], 23, -995338651);\n    a = md5ii(a, b, c, d, x[i], 6, -198630844);\n    d = md5ii(d, a, b, c, x[i + 7], 10, 1126891415);\n    c = md5ii(c, d, a, b, x[i + 14], 15, -1416354905);\n    b = md5ii(b, c, d, a, x[i + 5], 21, -57434055);\n    a = md5ii(a, b, c, d, x[i + 12], 6, 1700485571);\n    d = md5ii(d, a, b, c, x[i + 3], 10, -1894986606);\n    c = md5ii(c, d, a, b, x[i + 10], 15, -1051523);\n    b = md5ii(b, c, d, a, x[i + 1], 21, -2054922799);\n    a = md5ii(a, b, c, d, x[i + 8], 6, 1873313359);\n    d = md5ii(d, a, b, c, x[i + 15], 10, -30611744);\n    c = md5ii(c, d, a, b, x[i + 6], 15, -1560198380);\n    b = md5ii(b, c, d, a, x[i + 13], 21, 1309151649);\n    a = md5ii(a, b, c, d, x[i + 4], 6, -145523070);\n    d = md5ii(d, a, b, c, x[i + 11], 10, -1120210379);\n    c = md5ii(c, d, a, b, x[i + 2], 15, 718787259);\n    b = md5ii(b, c, d, a, x[i + 9], 21, -343485551);\n    a = safeAdd(a, olda);\n    b = safeAdd(b, oldb);\n    c = safeAdd(c, oldc);\n    d = safeAdd(d, oldd);\n  }\n\n  return [a, b, c, d];\n}\n/*\n * Convert an array bytes to an array of little-endian words\n * Characters >255 have their high-byte silently ignored.\n */\n\n\nfunction bytesToWords(input) {\n  if (input.length === 0) {\n    return [];\n  }\n\n  var length8 = input.length * 8;\n  var output = new Uint32Array(getOutputLength(length8));\n\n  for (var i = 0; i < length8; i += 8) {\n    output[i >> 5] |= (input[i / 8] & 0xff) << i % 32;\n  }\n\n  return output;\n}\n/*\n * Add integers, wrapping at 2^32. This uses 16-bit operations internally\n * to work around bugs in some JS interpreters.\n */\n\n\nfunction safeAdd(x, y) {\n  var lsw = (x & 0xffff) + (y & 0xffff);\n  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);\n  return msw << 16 | lsw & 0xffff;\n}\n/*\n * Bitwise rotate a 32-bit number to the left.\n */\n\n\nfunction bitRotateLeft(num, cnt) {\n  return num << cnt | num >>> 32 - cnt;\n}\n/*\n * These functions implement the four basic operations the algorithm uses.\n */\n\n\nfunction md5cmn(q, a, b, x, s, t) {\n  return safeAdd(bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b);\n}\n\nfunction md5ff(a, b, c, d, x, s, t) {\n  return md5cmn(b & c | ~b & d, a, b, x, s, t);\n}\n\nfunction md5gg(a, b, c, d, x, s, t) {\n  return md5cmn(b & d | c & ~d, a, b, x, s, t);\n}\n\nfunction md5hh(a, b, c, d, x, s, t) {\n  return md5cmn(b ^ c ^ d, a, b, x, s, t);\n}\n\nfunction md5ii(a, b, c, d, x, s, t) {\n  return md5cmn(c ^ (b | ~d), a, b, x, s, t);\n}\n\nexport default md5;","import v35 from './v35.js';\nimport md5 from './md5.js';\nvar v3 = v35('v3', 0x30, md5);\nexport default v3;","import stringify from './stringify.js';\nimport parse from './parse.js';\n\nfunction stringToBytes(str) {\n  str = unescape(encodeURIComponent(str)); // UTF8 escape\n\n  var bytes = [];\n\n  for (var i = 0; i < str.length; ++i) {\n    bytes.push(str.charCodeAt(i));\n  }\n\n  return bytes;\n}\n\nexport var DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';\nexport var URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';\nexport default function (name, version, hashfunc) {\n  function generateUUID(value, namespace, buf, offset) {\n    if (typeof value === 'string') {\n      value = stringToBytes(value);\n    }\n\n    if (typeof namespace === 'string') {\n      namespace = parse(namespace);\n    }\n\n    if (namespace.length !== 16) {\n      throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)');\n    } // Compute hash of namespace and value, Per 4.3\n    // Future: Use spread syntax when supported on all platforms, e.g. `bytes =\n    // hashfunc([...namespace, ... value])`\n\n\n    var bytes = new Uint8Array(16 + value.length);\n    bytes.set(namespace);\n    bytes.set(value, namespace.length);\n    bytes = hashfunc(bytes);\n    bytes[6] = bytes[6] & 0x0f | version;\n    bytes[8] = bytes[8] & 0x3f | 0x80;\n\n    if (buf) {\n      offset = offset || 0;\n\n      for (var i = 0; i < 16; ++i) {\n        buf[offset + i] = bytes[i];\n      }\n\n      return buf;\n    }\n\n    return stringify(bytes);\n  } // Function#name is not settable on some platforms (#270)\n\n\n  try {\n    generateUUID.name = name; // eslint-disable-next-line no-empty\n  } catch (err) {} // For CommonJS default export support\n\n\n  generateUUID.DNS = DNS;\n  generateUUID.URL = URL;\n  return generateUUID;\n}","import rng from './rng.js';\nimport stringify from './stringify.js';\n\nfunction v4(options, buf, offset) {\n  options = options || {};\n  var rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`\n\n  rnds[6] = rnds[6] & 0x0f | 0x40;\n  rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided\n\n  if (buf) {\n    offset = offset || 0;\n\n    for (var i = 0; i < 16; ++i) {\n      buf[offset + i] = rnds[i];\n    }\n\n    return buf;\n  }\n\n  return stringify(rnds);\n}\n\nexport default v4;","// Adapted from Chris Veness' SHA1 code at\n// http://www.movable-type.co.uk/scripts/sha1.html\nfunction f(s, x, y, z) {\n  switch (s) {\n    case 0:\n      return x & y ^ ~x & z;\n\n    case 1:\n      return x ^ y ^ z;\n\n    case 2:\n      return x & y ^ x & z ^ y & z;\n\n    case 3:\n      return x ^ y ^ z;\n  }\n}\n\nfunction ROTL(x, n) {\n  return x << n | x >>> 32 - n;\n}\n\nfunction sha1(bytes) {\n  var K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6];\n  var H = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];\n\n  if (typeof bytes === 'string') {\n    var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape\n\n    bytes = [];\n\n    for (var i = 0; i < msg.length; ++i) {\n      bytes.push(msg.charCodeAt(i));\n    }\n  } else if (!Array.isArray(bytes)) {\n    // Convert Array-like to Array\n    bytes = Array.prototype.slice.call(bytes);\n  }\n\n  bytes.push(0x80);\n  var l = bytes.length / 4 + 2;\n  var N = Math.ceil(l / 16);\n  var M = new Array(N);\n\n  for (var _i = 0; _i < N; ++_i) {\n    var arr = new Uint32Array(16);\n\n    for (var j = 0; j < 16; ++j) {\n      arr[j] = bytes[_i * 64 + j * 4] << 24 | bytes[_i * 64 + j * 4 + 1] << 16 | bytes[_i * 64 + j * 4 + 2] << 8 | bytes[_i * 64 + j * 4 + 3];\n    }\n\n    M[_i] = arr;\n  }\n\n  M[N - 1][14] = (bytes.length - 1) * 8 / Math.pow(2, 32);\n  M[N - 1][14] = Math.floor(M[N - 1][14]);\n  M[N - 1][15] = (bytes.length - 1) * 8 & 0xffffffff;\n\n  for (var _i2 = 0; _i2 < N; ++_i2) {\n    var W = new Uint32Array(80);\n\n    for (var t = 0; t < 16; ++t) {\n      W[t] = M[_i2][t];\n    }\n\n    for (var _t = 16; _t < 80; ++_t) {\n      W[_t] = ROTL(W[_t - 3] ^ W[_t - 8] ^ W[_t - 14] ^ W[_t - 16], 1);\n    }\n\n    var a = H[0];\n    var b = H[1];\n    var c = H[2];\n    var d = H[3];\n    var e = H[4];\n\n    for (var _t2 = 0; _t2 < 80; ++_t2) {\n      var s = Math.floor(_t2 / 20);\n      var T = ROTL(a, 5) + f(s, b, c, d) + e + K[s] + W[_t2] >>> 0;\n      e = d;\n      d = c;\n      c = ROTL(b, 30) >>> 0;\n      b = a;\n      a = T;\n    }\n\n    H[0] = H[0] + a >>> 0;\n    H[1] = H[1] + b >>> 0;\n    H[2] = H[2] + c >>> 0;\n    H[3] = H[3] + d >>> 0;\n    H[4] = H[4] + e >>> 0;\n  }\n\n  return [H[0] >> 24 & 0xff, H[0] >> 16 & 0xff, H[0] >> 8 & 0xff, H[0] & 0xff, H[1] >> 24 & 0xff, H[1] >> 16 & 0xff, H[1] >> 8 & 0xff, H[1] & 0xff, H[2] >> 24 & 0xff, H[2] >> 16 & 0xff, H[2] >> 8 & 0xff, H[2] & 0xff, H[3] >> 24 & 0xff, H[3] >> 16 & 0xff, H[3] >> 8 & 0xff, H[3] & 0xff, H[4] >> 24 & 0xff, H[4] >> 16 & 0xff, H[4] >> 8 & 0xff, H[4] & 0xff];\n}\n\nexport default sha1;","import v35 from './v35.js';\nimport sha1 from './sha1.js';\nvar v5 = v35('v5', 0x50, sha1);\nexport default v5;","import REGEX from './regex.js';\n\nfunction validate(uuid) {\n  return typeof uuid === 'string' && REGEX.test(uuid);\n}\n\nexport default validate;","import validate from './validate.js';\n\nfunction version(uuid) {\n  if (!validate(uuid)) {\n    throw TypeError('Invalid UUID');\n  }\n\n  return parseInt(uuid.substr(14, 1), 16);\n}\n\nexport default version;"],"names":["Object","defineProperty","exports","value","AdminClient","GraphQLError","RequestError","ConnectionError","resetAdminServer","async","options","serverUrl","adminServerUrl","types_1","DEFAULT_ADMIN_SERVER_PORT","requestFromAdminServer","requestOptions","method","_","events_1","DuplexPair","typed_error_1","CrossFetch","WebSocket","connectWebSocketStream","subscriptions_transport_ws_1","graphql_1","util_1","error_1","promise_1","schema_introspection_1","schema_introspection_2","admin_query_1","fetch","Headers","isNode","globalThis","TypedError","constructor","message","response","super","this","errors","length","status","map","e","join","mergeClientOptions","defaultOptions","headers","forEach","key","append","isObject","assign","path","url","isErrorLike","code","body","text","jsonBody","JSON","parse","error","json","EventEmitter","debug","running","enableDebug","queryMockServer","reset","adminClientOptions","defaults","adminStreamReconnectAttempts","attachStreamWebsocket","adminSessionBaseUrl","targetStream","adminSessionBaseWSUrl","replace","wsStream","streamConnected","on","pipe","end","console","warn","emit","closeEvent","unpipe","tryToReconnectStream","log","removeAllListeners","destroy","retries","newStream","Promise","resolve","reject","once","then","catch","err","retryAttempt","delay","Math","pow","openStreamToMockServer","socket1","wsTarget","socket2","exposedStream","setMaxListeners","prepareSubscriptionClientToAdminServer","subscriptionUrl","subscriptionClient","SubscriptionClient","lazy","reconnect","reconnectionAttempts","wsOptionArguments","onError","onReconnecting","requestFromMockServer","Error","query","variables","stringify","data","graphQLErrors","e2","start","pluginStartParams","startPromise","getDeferred","result","portConfig","port","undefined","adminServerResponse","plugins","http","isPluginAwareServer","sessionId","id","toString","adminServerStream","stop","adminServerSchema","SchemaIntrospector","introspectionQuery","__schema","serverMetadata","adminServerMetadata","pluginData","isRunning","metadata","schema","adminStream","stopPromise","close","requestServerStop","sendQuery","sendQueries","queries","results","transformResponse","print","adminClient","all","subscribe","callback","fieldName","getSingleSelectedFieldName","typeHasField","isConnected","client","request","next","onConnected","onDisconnected","getRuleParameterKeys","queryTypeDefined","ruleParameterKeys","isFieldSelection","selection","kind","selectedFieldNames","gqlQuery","definitions","selectionSet","getQuerySelectionNode","selections","filter","name","MockedEndpointClient","explanation","endpointDataGetter","getMockedEndpointData","mockedEndpointData","getSeenRequests","seenRequests","isPending","call","MockttpAdminRequestBuilder","graphql_tag_1","request_utils_1","header_utils_1","mocked_endpoint_client_1","rule_serialization_1","normalizeHttpMessage","event","timingEvents","rawHeaders","rawHeadersToObject","objectHeadersToRaw","rawTrailers","trailers","buildBodyReader","Buffer","from","tags","startsWith","tlsMetadata","getEndpointDataGetter","ruleId","mockedEndpoint","default","asOptionalField","req","buildAddRequestRulesQuery","rules","requestName","mutationName","serializedRules","rule","serializedRule","serializeRuleData","typeHasInputField","newRules","endpoints","buildAddWebSocketRulesQuery","buildMockedEndpointsQuery","mockedEndpoints","buildPendingEndpointsQuery","pendingEndpoints","buildSubscriptionRequest","abort","mapValues","v","content","eventData","rawBody","MockttpClient","mockttp_1","admin_client_1","mockttp_admin_request_builder_1","AbstractMockttp","cors","addRequestRules","_addRequestRules","setRequestRules","addWebSocketRules","_addWsRules","setWebSocketRules","requestBuilder","mockServerOptions","mockRoot","getMockedEndpoints","getPendingEndpoints","slice","subRequest","queryType","isTypeDefined","typeName","some","types","type","find","fields","firstAvailableName","Array","isArray","inputFields","MockttpPluggableAdmin","PluggableAdmin","enumerable","get","Method","matchers","requestHandlerDefinitions","webSocketHandlerDefinitions","completionCheckers","SimpleHandlerDefinition","CallbackHandlerDefinition","StreamHandlerDefinition","FileHandlerDefinition","PassThroughHandlerDefinition","CloseConnectionHandlerDefinition","TimeoutHandlerDefinition","HandlerDefinitionLookup","PassThroughWebSocketHandlerDefinition","WsHandlerDefinitionLookup","rule_parameters_1","MOCKTTP_PARAM_REF","common_tags_1","request_rule_builder_1","websocket_rule_builder_1","addRequestRule","addWebSocketRule","corsOptions","recordTraffic","suggestChanges","proxyEnv","HTTP_PROXY","HTTPS_PROXY","urlFor","forAnyRequest","RequestRuleBuilder","forUnmatchedRequest","asPriority","RulePriority","FALLBACK","forGet","GET","forPost","POST","forPut","PUT","forDelete","DELETE","forPatch","PATCH","forHead","HEAD","forOptions","stripIndent","OPTIONS","forJsonRpcRequest","match","withJsonBodyIncluding","jsonrpc","params","forAnyWebSocket","WebSocketRuleBuilder","Serialization","AdminServer","BaseRuleBuilder","lodash_1","completion_checkers_1","matchers_1","priority","DEFAULT","buildBaseRuleData","completionChecker","forHost","host","push","HostMatcher","forHostname","hostname","HostnameMatcher","forPort","PortMatcher","withHeaders","HeaderMatcher","withQuery","QueryMatcher","withExactQuery","ExactQueryMatcher","withForm","formData","FormDataMatcher","withMultipartForm","matchConditions","MultipartFormDataMatcher","withBody","isString","RawBodyMatcher","RegexBodyMatcher","withBodyIncluding","RawBodyIncludesMatcher","withJsonBody","JsonBodyMatcher","JsonBodyFlexibleMatcher","withCookie","cookie","CookieMatcher","withProtocol","protocol","ProtocolMatcher","withUrlMatching","pattern","RegexUrlMatcher","matching","CallbackMatcher","always","Always","Once","twice","Twice","thrice","Thrice","times","n","NTimes","CompletionCheckerLookup","serialization_1","Serializable","arguments","isComplete","explain","seenRequestCount","explainUntil","Infinity","count","seen","MatcherLookup","RegexPathMatcher","SimplePathMatcher","MethodMatcher","WildcardMatcher","matchesAll","resultsPromises","matcher","matches","maybePromiseResult","every","explainMatchers","m","multipart","url_1","body_serialization_1","unescapeRegexp","input","includes","parsedUrl","URL","endsWith","split","search","oneLine","normalizeUrl","expectedUrl","reqUrl","isRelativeUrl","getPathFromAbsoluteUrl","isAbsoluteUrl","getUrlWithoutProtocol","regex","regexSource","source","regexFlags","flags","absoluteUrl","urlPath","urlMatcher","RegExp","test","headersInput","mapKeys","_value","toLowerCase","isMatch","queryObjectInput","queryObject","av","contentType","indexOf","asFormData","boundary","parsedBody","asDecodedBuffer","condition","expectedContent","part","equals","filename","asText","regexString","receivedBody","asJson","isEqual","trim","element","completedRequest","waitForCompletedRequest","serialize","channel","onRequest","streamMsg","withDeserializedBodyReader","version","deserialize","rpcCallback","withSerializedBodyReader","JsonRpcResponseHandlerDefinition","ResetConnectionHandlerDefinition","SERIALIZED_OMIT","base64_arraybuffer_1","stream_1","fast_json_patch_1","buffer_utils_1","validateCustomHeaders","originalHeaders","modifiedHeaders","headerWhitelist","invalidHeaders","pickBy","keys","size","statusMessage","isEmpty","entries","args","buffer","callbackResult","withSerializedCallbackBuffers","stream","serializationStream","Transform","objectMode","transform","chunk","_encoding","serializedEventData","isBuffer","isArrayBuffer","isTypedArray","encode","isNil","flush","filePath","ignoreHostHttpsErrors","extraCACertificates","outgoingSockets","Set","forwarding","targetHost","suggestion","format","lookupOptions","proxyConfig","simulateConnectionErrors","additionalTrustedCAs","trustAdditionalCAs","clientCertificateHostMap","beforeRequest","transformRequest","updateHeaders","replaceHeaders","o","replaceBody","replaceBodyFromFile","updateJsonBody","patchJsonBody","matchReplaceBody","validationError","validate","beforeResponse","serializedResult","forwardToLocation","serializeProxyConfig","ignoreHostCertificateErrors","certObject","cert","pfx","passphrase","serializeBuffer","asBuffer","k","isRegExp","hasBeforeRequestCallback","hasBeforeResponseCallback","resultType","request_handler_definitions_1","base_rule_builder_1","methodOrAddRule","addRule","Function","thenReply","dataOrMessage","dataOrHeaders","headersOrTrailers","handler","thenJson","jsonData","merge","byteLength","thenCallback","thenStream","thenFromFile","pathOrMessage","pathOrHeaders","thenPassThrough","thenForwardTo","thenCloseConnection","thenResetConnection","thenTimeout","thenSendJsonRpcResult","thenSendJsonRpcError","isParamReference","dereferenceParam","paramRef","paramKey","assertParamDereferenced","maybeParamRef","Symbol","validateMockRuleData","RejectWebSocketHandlerDefinition","ListenWebSocketHandlerDefinition","EchoWebSocketHandlerDefinition","statusCode","websocket_handler_definitions_1","thenEcho","thenPassivelyListen","thenRejectConnection","deserializeBuffer","serializedBody","isMockttpBody","withDeserializedCallbackBuffers","ClientServerChannel","obj","topicId","ruleParams","lookup","deserialized","builtinDispose","dispose","ensureParamsDeferenced","isFunction","callbackId","uuid_1","v4","config","SERIALIZED_PARAM_REFERENCE","trustedCAs","caDefinition","deserializeProxyConfig","_channel","_ruleParams","create","prototype","DISPOSE_MESSAGE","disposeChannel","Duplex","rawStream","_onRawStreamError","_onRawStreamFinish","_readFromRawStream","rawData","d","rawDataLine","omit","reading","_write","encoding","write","_read","actionOrData","dataOrNothing","action","requestId","responseListener","stack","removeListener","cbOrAction","cbOrNothing","actionName","cb","writable","pick","getOwnPropertyNames","disposeReceived","isSerializedRuleParam","streamToBuffer","bufferToStream","bufferThenStream","splitBuffer","splitter","maxParts","parts","remainingBuffer","endOfPart","MAX_BUFFER_SIZE","inputStream","active","outputStream","PassThrough","read","failedWith","concat","currentChunks","readableEnded","readableAborted","events","chunks","maxSize","bufferPromise","failWithAbortError","currentSize","onData","findRawHeaders","findRawHeaderIndex","findRawHeader","pairFlatRawHeaders","flatRawHeaders","i","flattenPairedRawHeaders","flat","reduce","existingValue","rawHeadersToObjectPreservingCase","headerNameMap","lowerCaseKey","objectHeadersToFlat","flatHeaders","h2HeadersToH1","h2Headers","h1Headers","unshift","cookieHeaders","h1HeadersToH2","HTTP2_ILLEGAL_HEADERS","dropDefaultHeaders","defaultHeader","removeHeader","validateHeader","validateHeaderName","validateHeaderValue","targetKey","findIndex","array","testResults","objectAllPromise","zipObject","values","resolveCallback","rejectCallback","parseRequestBody","writeHead","shouldKeepAlive","isHttp2","encodeBodyBuffer","contentEncoding","encodeBuffer","level","decodeBodyBuffer","buildInitiatedRequest","waitForBody","trackResponse","trackedResponse","trackingStream","originalWriteHeader","originalWrite","originalEnd","originalAddTrailers","addTrailers","originalGetHeaders","getHeaders","writtenHeaders","writtenTrailers","getRawHeaders","headersArg","headersSentTimestamp","now","getHeaderPairsFromArgument","storedHeaders","apply","writtenHeaderKeys","storedHeaderKeys","reverse","getRawTrailers","trailersArg","trackingWrite","parseBodyStream","waitForCompletedResponse","responseSentTimestamp","completedResponse","valueOf","http2","Http2ServerResponse","tryToParseHttpRequest","socket","__lastHopEncrypted","tls_1","TLSSocket","servername","lines","requestLine","rawUri","httpProtocol","emptyLineIndex","line","headerParts","p","hostHeader","httpVersion","parseRawHttpResponse","responseLine","subarray","_httpVersion","rawStatusCode","restResponseLine","parseInt","querystring","decodeBuffer","bodyStream","completedBuffer","asStream","b","t","runAsyncOrUndefined","func","bufferBody","hasOwnProperty","completedBody","getDecodedBuffer","getText","getMultipartFormData","multipartBodyBuffer","multiPartBody","prevValue","getUrlEncodedFormData","getEffectivePort","isAbsoluteProtocollessUrl","pathIndex","nthIndexOf","memoize","urlInput","isProtocolless","queryIndex","hash","pathname","encoded","toUpperCase","unicodeChar","encodeURIComponent","normalizedUrl","makePropertyWritable","isWeb","isWorker","index","Blob","r","setTimeout","WorkerGlobalScope","self","Window","process","property","__assign","s","__awaiter","thisArg","_arguments","P","generator","fulfilled","step","rejected","done","__generator","f","y","g","label","sent","trys","ops","verb","iterator","op","TypeError","pop","__spreadArray","to","pack","ar","l","_global","window","NativeWebSocket","MozWebSocket","Backoff","eventemitter3_1","is_string_1","is_object_1","printer_1","getOperationAST_1","symbol_observable_1","protocol_1","defaults_1","message_types_1","webSocketImpl","webSocketProtocols","_a","_b","connectionCallback","_c","connectionParams","_d","minTimeout","MIN_WS_TIMEOUT","_e","timeout","WS_TIMEOUT","_f","_g","_h","_j","inactivityTimeout","_k","wsImpl","wsProtocols","GRAPHQL_WS","operations","nextOperationId","minWsTimeout","wsTimeout","unsentMessagesQueue","reconnecting","closedByUser","backoff","jitter","eventEmitter","middlewares","maxConnectTimeGenerator","createMaxConnectTimeGenerator","getConnectionParams","connect","CLOSED","readyState","configurable","isForced","clearInactivityTimeout","clearCheckConnectionInterval","clearMaxConnectTimeout","clearTryReconnectTimeout","unsubscribeAll","sendMessage","GQL_CONNECTION_TERMINATE","onopen","onclose","onmessage","onerror","tryReconnect","opId","getObserver","bind","executeOperation","unsubscribe","observerOrNext","onComplete","observer","complete","eventName","context","off","onConnecting","onReconnected","_this","subId","applyMiddlewares","funcs","scope","shift","applyMiddleware","use","middleware","generateOperationId","processedOptions","checkOperationOptions","GQL_START","formatErrors","minValue","maxValue","min","max","factor","checkConnectionIntervalId","clearInterval","maxConnectTimeoutId","clearTimeout","tryReconnectTimeoutId","inactivityTimeoutId","setInactivityTimeout","operationName","getOperationAST","buildMessage","payload","originalError","sendMessageRaw","OPEN","serializedMessage","send","CONNECTING","String","attempts","duration","flushUnsentMessagesQueue","checkConnection","wasKeepAliveReceived","checkMaxConnectTimeout","GQL_CONNECTION_INIT","GQL_CONNECTION_ERROR","processReceivedData","receivedData","parsedMessage","GQL_DATA","GQL_COMPLETE","GQL_ERROR","GQL_CONNECTION_ACK","parsedPayload","GQL_CONNECTION_KEEP_ALIVE","firstKA","setInterval","GQL_STOP","MessageTypes","SUBSCRIPTION_START","SUBSCRIPTION_DATA","SUBSCRIPTION_SUCCESS","SUBSCRIPTION_FAIL","SUBSCRIPTION_END","INIT","INIT_SUCCESS","INIT_FAIL","KEEP_ALIVE","GRAPHQL_SUBSCRIPTIONS","chars","Uint8Array","charCodeAt","arraybuffer","bytes","len","base64","substring","decode","encoded1","encoded2","encoded3","encoded4","bufferLength","ArrayBuffer","uuid","arr","getRandomValues","rnds8","rng","crypto","msCrypto","byteToHex","substr","offset","_nodeId","_clockseq","_lastMSecs","_lastNSecs","buf","node","clockseq","seedBytes","random","msecs","Date","nsecs","dt","tl","tmh","getOutputLength","inputLength8","safeAdd","x","lsw","md5cmn","q","a","num","cnt","md5ff","c","md5gg","md5hh","md5ii","msg","unescape","output","length32","hexTab","hex","charAt","md5ToHexEncodedArray","olda","oldb","oldc","oldd","wordsToMd5","length8","Uint32Array","bytesToWords","DNS","hashfunc","generateUUID","namespace","str","stringToBytes","set","rnds","z","ROTL","K","H","N","ceil","M","_i","j","floor","_i2","W","_t","_t2","T"],"sourceRoot":""}