{"version":3,"file":"static/js/main.8305eae5.js","mappings":";kCAEA,IAAIA,EAASC,OAAOC,UAAUC,eAC1BC,EAAQH,OAAOC,UAAUG,SACzBC,EAAiBL,OAAOK,eACxBC,EAAON,OAAOO,yBAEdC,EAAU,SAAiBC,GAC9B,MAA6B,oBAAlBC,MAAMF,QACTE,MAAMF,QAAQC,GAGK,mBAApBN,EAAMQ,KAAKF,EACnB,EAEIG,EAAgB,SAAuBC,GAC1C,IAAKA,GAA2B,oBAApBV,EAAMQ,KAAKE,GACtB,OAAO,EAGR,IASIC,EATAC,EAAoBhB,EAAOY,KAAKE,EAAK,eACrCG,EAAmBH,EAAII,aAAeJ,EAAII,YAAYhB,WAAaF,EAAOY,KAAKE,EAAII,YAAYhB,UAAW,iBAE9G,GAAIY,EAAII,cAAgBF,IAAsBC,EAC7C,OAAO,EAMR,IAAKF,KAAOD,GAEZ,MAAsB,qBAARC,GAAuBf,EAAOY,KAAKE,EAAKC,EACvD,EAGII,EAAc,SAAqBC,EAAQC,GAC1Cf,GAAmC,cAAjBe,EAAQC,KAC7BhB,EAAec,EAAQC,EAAQC,KAAM,CACpCC,YAAY,EACZC,cAAc,EACdC,MAAOJ,EAAQK,SACfC,UAAU,IAGXP,EAAOC,EAAQC,MAAQD,EAAQK,QAEjC,EAGIE,EAAc,SAAqBd,EAAKQ,GAC3C,GAAa,cAATA,EAAsB,CACzB,IAAKtB,EAAOY,KAAKE,EAAKQ,GACrB,OACM,GAAIf,EAGV,OAAOA,EAAKO,EAAKQ,GAAMG,KAEzB,CAEA,OAAOX,EAAIQ,EACZ,EAEAO,EAAOC,QAAU,SAASC,IACzB,IAAIV,EAASC,EAAMU,EAAKC,EAAMC,EAAaC,EACvCf,EAASgB,UAAU,GACnBC,EAAI,EACJC,EAASF,UAAUE,OACnBC,GAAO,EAaX,IAVsB,mBAAXnB,IACVmB,EAAOnB,EACPA,EAASgB,UAAU,IAAM,CAAC,EAE1BC,EAAI,IAES,MAAVjB,GAAqC,kBAAXA,GAAyC,oBAAXA,KAC3DA,EAAS,CAAC,GAGJiB,EAAIC,IAAUD,EAGpB,GAAe,OAFfhB,EAAUe,UAAUC,IAInB,IAAKf,KAAQD,EACZW,EAAMJ,EAAYR,EAAQE,GAItBF,KAHJa,EAAOL,EAAYP,EAASC,MAKvBiB,GAAQN,IAASpB,EAAcoB,KAAUC,EAAczB,EAAQwB,MAC9DC,GACHA,GAAc,EACdC,EAAQH,GAAOvB,EAAQuB,GAAOA,EAAM,IAEpCG,EAAQH,GAAOnB,EAAcmB,GAAOA,EAAM,CAAC,EAI5Cb,EAAYC,EAAQ,CAAEE,KAAMA,EAAMI,SAAUK,EAAOQ,EAAMJ,EAAOF,MAGtC,qBAATA,GACjBd,EAAYC,EAAQ,CAAEE,KAAMA,EAAMI,SAAUO,KAQjD,OAAOb,CACR,WClHA,IAAIoB,EAAgB,kCAEhBC,EAAgB,MAChBC,EAAmB,OAGnBC,EAAiB,yCACjBC,EAAc,QACdC,EAAc,uDACdC,EAAkB,UAGlBC,EAAa,aAMbC,EAAe,GA8OnB,SAASC,EAAKC,GACZ,OAAOA,EAAMA,EAAIC,QAAQJ,EAAYC,GAAgBA,CACvD,CAnOAnB,EAAOC,QAAU,SAAUsB,EAAO/B,GAChC,GAAqB,kBAAV+B,EACT,MAAM,IAAIC,UAAU,mCAGtB,IAAKD,EAAO,MAAO,GAEnB/B,EAAUA,GAAW,CAAC,EAKtB,IAAIiC,EAAS,EACTC,EAAS,EAOb,SAASC,EAAeN,GACtB,IAAIO,EAAQP,EAAIQ,MAAMjB,GAClBgB,IAAOH,GAAUG,EAAMnB,QAC3B,IAAID,EAAIa,EAAIS,YAvCF,MAwCVJ,GAAUlB,EAAIa,EAAIZ,OAASD,EAAIkB,EAASL,EAAIZ,MAC9C,CAOA,SAASsB,IACP,IAAIC,EAAQ,CAAEC,KAAMR,EAAQC,OAAQA,GACpC,OAAO,SAAUQ,GAGf,OAFAA,EAAKH,SAAW,IAAII,EAASH,GAC7BI,IACOF,CACT,CACF,CAUA,SAASC,EAASH,GAChBK,KAAKL,MAAQA,EACbK,KAAKC,IAAM,CAAEL,KAAMR,EAAQC,OAAQA,GACnCW,KAAKE,OAAS/C,EAAQ+C,MACxB,CAKAJ,EAAS9D,UAAUmE,QAAUjB,EAE7B,IAAIkB,EAAa,GAQjB,SAASC,EAAMC,GACb,IAAIC,EAAM,IAAIC,MACZrD,EAAQ+C,OAAS,IAAMd,EAAS,IAAMC,EAAS,KAAOiB,GAQxD,GANAC,EAAIE,OAASH,EACbC,EAAIG,SAAWvD,EAAQ+C,OACvBK,EAAIX,KAAOR,EACXmB,EAAIlB,OAASA,EACbkB,EAAIL,OAAShB,GAET/B,EAAQwD,OAGV,MAAMJ,EAFNH,EAAWQ,KAAKL,EAIpB,CAQA,SAASf,EAAMqB,GACb,IAAIC,EAAID,EAAGE,KAAK7B,GAChB,GAAK4B,EAAL,CACA,IAAI9B,EAAM8B,EAAE,GAGZ,OAFAxB,EAAeN,GACfE,EAAQA,EAAM8B,MAAMhC,EAAIZ,QACjB0C,CAJO,CAKhB,CAKA,SAASf,IACPP,EAAMhB,EACR,CAQA,SAASyC,EAASC,GAChB,IAAIC,EAEJ,IADAD,EAAQA,GAAS,GACTC,EAAIC,MACA,IAAND,GACFD,EAAMN,KAAKO,GAGf,OAAOD,CACT,CAQA,SAASE,IACP,IAAIC,EAAM3B,IACV,GAnJgB,KAmJKR,EAAMoC,OAAO,IAlJvB,KAkJyCpC,EAAMoC,OAAO,GAAjE,CAGA,IADA,IAAInD,EAAI,EAENW,GAAgBI,EAAMoC,OAAOnD,KAtJpB,KAuJIe,EAAMoC,OAAOnD,IAxJZ,KAwJmCe,EAAMoC,OAAOnD,EAAI,OAEhEA,EAIJ,GAFAA,GAAK,EAEDW,IAAiBI,EAAMoC,OAAOnD,EAAI,GACpC,OAAOkC,EAAM,0BAGf,IAAIrB,EAAME,EAAM8B,MAAM,EAAG7C,EAAI,GAM7B,OALAkB,GAAU,EACVC,EAAeN,GACfE,EAAQA,EAAM8B,MAAM7C,GACpBkB,GAAU,EAEHgC,EAAI,CACTE,KApKa,UAqKbH,QAASpC,GAvBgE,CAyB7E,CAQA,SAASwC,IACP,IAAIH,EAAM3B,IAGN+B,EAAOjC,EAAMf,GACjB,GAAKgD,EAAL,CAIA,GAHAL,KAGK5B,EAAMd,GAAc,OAAO2B,EAAM,wBAGtC,IAAIqB,EAAMlC,EAAMb,GAEZgD,EAAMN,EAAI,CACZE,KA7LiB,cA8LjBK,SAAU7C,EAAK0C,EAAK,GAAGxC,QAAQX,EAAeQ,IAC9CvB,MAAOmE,EACH3C,EAAK2C,EAAI,GAAGzC,QAAQX,EAAeQ,IACnCA,IAMN,OAFAU,EAAMZ,GAEC+C,CApBU,CAqBnB,CAyBA,OADA5B,IAjBA,WACE,IAKI8B,EALAC,EAAQ,GAMZ,IAJAb,EAASa,GAIDD,EAAOL,MACA,IAATK,IACFC,EAAMlB,KAAKiB,GACXZ,EAASa,IAIb,OAAOA,CACT,CAGOC,EACT,wBC1MApE,EAAOC,QA5BS,SAASoE,EAAWC,EAAQC,EAAGC,EAAGhB,EAAGiB,EAAGC,EAAGC,GAOzD,IAAKN,EAAW,CACd,IAAI3B,EACJ,QAAekC,IAAXN,EACF5B,EAAQ,IAAIG,MACV,qIAGG,CACL,IAAIgC,EAAO,CAACN,EAAGC,EAAGhB,EAAGiB,EAAGC,EAAGC,GACvBG,EAAW,GACfpC,EAAQ,IAAIG,MACVyB,EAAOhD,QAAQ,OAAO,WAAa,OAAOuD,EAAKC,IAAa,MAExDrF,KAAO,qBACf,CAGA,MADAiD,EAAMqC,YAAc,EACdrC,CACR,CACF,8BC5CAtE,OAAOK,eAAewB,EAAS,aAAc,CAC3CL,OAAO,IAETK,EAAAA,QAQA,WACE,IAAK,IAAI+E,EAAOzE,UAAUE,OAAQwE,EAAanG,MAAMkG,GAAOE,EAAO,EAAGA,EAAOF,EAAME,IACjFD,EAAWC,GAAQ3E,UAAU2E,GAwB/B,OAAO,EAAIC,EAA6BC,UArBxC,WACE,IAAK,IAAIC,EAAQ9E,UAAUE,OAAQoE,EAAO/F,MAAMuG,GAAQC,EAAQ,EAAGA,EAAQD,EAAOC,IAChFT,EAAKS,GAAS/E,UAAU+E,GAG1B,IAAI5C,EAAQ,KAaZ,OAXAuC,EAAWM,SAAQ,SAAUC,GAC3B,GAAa,MAAT9C,EAAJ,CAIA,IAAI+C,EAASD,EAAUE,WAAMd,EAAWC,GAC1B,MAAVY,IACF/C,EAAQ+C,EAJV,CAMF,IAEO/C,CACT,GAGF,EAjCA,IAIgCzD,EAJ5B0G,EAA8BC,EAAQ,KAEtCT,GAE4BlG,EAF0B0G,IAEL1G,EAAI4G,WAAa5G,EAAM,CAAEmG,QAASnG,GA8BvFe,EAAOC,QAAUA,EAAiB,kCCvClC7B,OAAOK,eAAewB,EAAS,aAAc,CAC3CL,OAAO,IAETK,EAAAA,QAYA,SAAoC6F,GAClC,SAASC,EAAUC,EAAYC,EAAOC,EAAUC,EAAeC,EAAUC,GACvE,IAAIC,EAAoBH,GAAiB,gBACrCI,EAAmBF,GAAgBH,EAEvC,GAAuB,MAAnBD,EAAMC,GACR,OAAIF,EACK,IAAInD,MAAM,YAAcuD,EAAW,KAAOG,EAAhC,2BAAsFD,EAAoB,MAGtH,KAGT,IAAK,IAAItB,EAAOzE,UAAUE,OAAQoE,EAAO/F,MAAMkG,EAAO,EAAIA,EAAO,EAAI,GAAIE,EAAO,EAAGA,EAAOF,EAAME,IAC9FL,EAAKK,EAAO,GAAK3E,UAAU2E,GAG7B,OAAOY,EAASJ,WAAMd,EAAW,CAACqB,EAAOC,EAAUI,EAAmBF,EAAUG,GAAkBC,OAAO3B,GAC3G,CAEA,IAAI4B,EAAmBV,EAAUW,KAAK,MAAM,GAG5C,OAFAD,EAAiBT,WAAaD,EAAUW,KAAK,MAAM,GAE5CD,CACT,EACAzG,EAAOC,QAAUA,EAAiB,oCCjClC,IAAI0G,EAAuBf,EAAQ,KAEnC,SAASgB,IAAiB,CAC1B,SAASC,IAA0B,CACnCA,EAAuBC,kBAAoBF,EAE3C5G,EAAOC,QAAU,WACf,SAAS8G,EAAKd,EAAOC,EAAUC,EAAeC,EAAUC,EAAcW,GACpE,GAAIA,IAAWL,EAAf,CAIA,IAAI/D,EAAM,IAAIC,MACZ,mLAKF,MADAD,EAAInD,KAAO,sBACLmD,CAPN,CAQF,CAEA,SAASqE,IACP,OAAOF,CACT,CAHAA,EAAKf,WAAae,EAMlB,IAAIG,EAAiB,CACnBC,MAAOJ,EACPK,OAAQL,EACRM,KAAMN,EACNO,KAAMP,EACNQ,OAAQR,EACRS,OAAQT,EACRU,OAAQV,EACRW,OAAQX,EAERY,IAAKZ,EACLa,QAASX,EACTY,QAASd,EACTe,YAAaf,EACbgB,WAAYd,EACZ/E,KAAM6E,EACNiB,SAAUf,EACVgB,MAAOhB,EACPiB,UAAWjB,EACXkB,MAAOlB,EACPmB,MAAOnB,EAEPoB,eAAgBxB,EAChBC,kBAAmBF,GAKrB,OAFAM,EAAeoB,UAAYpB,EAEpBA,CACT,iBC/CElH,EAAOC,QAAU2F,EAAQ,IAARA,yBCNnB5F,EAAOC,QAFoB,2ECGd,IAAIsI,EAAG3C,EAAQ,IAAS4C,EAAG5C,EAAQ,KAAa,SAAS6C,EAAElE,GAAG,IAAI,IAAIC,EAAE,yDAAyDD,EAAEf,EAAE,EAAEA,EAAEjD,UAAUE,OAAO+C,IAAIgB,GAAG,WAAWkE,mBAAmBnI,UAAUiD,IAAI,MAAM,yBAAyBe,EAAE,WAAWC,EAAE,gHAAgH,CAAC,IAAImE,EAAG,IAAIC,IAAIC,EAAG,CAAC,EAAE,SAASC,EAAGvE,EAAEC,GAAGuE,EAAGxE,EAAEC,GAAGuE,EAAGxE,EAAE,UAAUC,EAAE,CACxb,SAASuE,EAAGxE,EAAEC,GAAW,IAARqE,EAAGtE,GAAGC,EAAMD,EAAE,EAAEA,EAAEC,EAAE/D,OAAO8D,IAAIoE,EAAGK,IAAIxE,EAAED,GAAG,CAC5D,IAAI0E,IAAK,qBAAqBC,QAAQ,qBAAqBA,OAAOC,UAAU,qBAAqBD,OAAOC,SAASC,eAAeC,EAAGjL,OAAOC,UAAUC,eAAegL,EAAG,8VAA8VC,EACpgB,CAAC,EAAEC,EAAG,CAAC,EACiN,SAASC,EAAElF,EAAEC,EAAEhB,EAAEiB,EAAEC,EAAEC,EAAE+E,GAAGrH,KAAKsH,gBAAgB,IAAInF,GAAG,IAAIA,GAAG,IAAIA,EAAEnC,KAAKuH,cAAcnF,EAAEpC,KAAKwH,mBAAmBnF,EAAErC,KAAKyH,gBAAgBtG,EAAEnB,KAAK0H,aAAaxF,EAAElC,KAAKuB,KAAKY,EAAEnC,KAAK2H,YAAYrF,EAAEtC,KAAK4H,kBAAkBP,CAAC,CAAC,IAAIQ,EAAE,CAAC,EACpb,uIAAuIC,MAAM,KAAK5E,SAAQ,SAAShB,GAAG2F,EAAE3F,GAAG,IAAIkF,EAAElF,EAAE,GAAE,EAAGA,EAAE,MAAK,GAAG,EAAG,IAAG,CAAC,CAAC,gBAAgB,kBAAkB,CAAC,YAAY,SAAS,CAAC,UAAU,OAAO,CAAC,YAAY,eAAegB,SAAQ,SAAShB,GAAG,IAAIC,EAAED,EAAE,GAAG2F,EAAE1F,GAAG,IAAIiF,EAAEjF,EAAE,GAAE,EAAGD,EAAE,GAAG,MAAK,GAAG,EAAG,IAAG,CAAC,kBAAkB,YAAY,aAAa,SAASgB,SAAQ,SAAShB,GAAG2F,EAAE3F,GAAG,IAAIkF,EAAElF,EAAE,GAAE,EAAGA,EAAE6F,cAAc,MAAK,GAAG,EAAG,IAC1e,CAAC,cAAc,4BAA4B,YAAY,iBAAiB7E,SAAQ,SAAShB,GAAG2F,EAAE3F,GAAG,IAAIkF,EAAElF,EAAE,GAAE,EAAGA,EAAE,MAAK,GAAG,EAAG,IAAG,8OAA8O4F,MAAM,KAAK5E,SAAQ,SAAShB,GAAG2F,EAAE3F,GAAG,IAAIkF,EAAElF,EAAE,GAAE,EAAGA,EAAE6F,cAAc,MAAK,GAAG,EAAG,IACxb,CAAC,UAAU,WAAW,QAAQ,YAAY7E,SAAQ,SAAShB,GAAG2F,EAAE3F,GAAG,IAAIkF,EAAElF,EAAE,GAAE,EAAGA,EAAE,MAAK,GAAG,EAAG,IAAG,CAAC,UAAU,YAAYgB,SAAQ,SAAShB,GAAG2F,EAAE3F,GAAG,IAAIkF,EAAElF,EAAE,GAAE,EAAGA,EAAE,MAAK,GAAG,EAAG,IAAG,CAAC,OAAO,OAAO,OAAO,QAAQgB,SAAQ,SAAShB,GAAG2F,EAAE3F,GAAG,IAAIkF,EAAElF,EAAE,GAAE,EAAGA,EAAE,MAAK,GAAG,EAAG,IAAG,CAAC,UAAU,SAASgB,SAAQ,SAAShB,GAAG2F,EAAE3F,GAAG,IAAIkF,EAAElF,EAAE,GAAE,EAAGA,EAAE6F,cAAc,MAAK,GAAG,EAAG,IAAG,IAAIC,EAAG,gBAAgB,SAASC,EAAG/F,GAAG,OAAOA,EAAE,GAAGgG,aAAa,CAIxZ,SAASC,EAAGjG,EAAEC,EAAEhB,EAAEiB,GAAG,IAAIC,EAAEwF,EAAE5L,eAAekG,GAAG0F,EAAE1F,GAAG,MAAQ,OAAOE,EAAE,IAAIA,EAAEd,KAAKa,KAAK,EAAED,EAAE/D,SAAS,MAAM+D,EAAE,IAAI,MAAMA,EAAE,IAAI,MAAMA,EAAE,IAAI,MAAMA,EAAE,MAP9I,SAAYD,EAAEC,EAAEhB,EAAEiB,GAAG,GAAG,OAAOD,GAAG,qBAAqBA,GADqE,SAAYD,EAAEC,EAAEhB,EAAEiB,GAAG,GAAG,OAAOjB,GAAG,IAAIA,EAAEI,KAAK,OAAM,EAAG,cAAcY,GAAG,IAAK,WAAW,IAAK,SAAS,OAAM,EAAG,IAAK,UAAU,OAAGC,IAAc,OAAOjB,GAASA,EAAEmG,gBAAmD,WAAnCpF,EAAEA,EAAE6F,cAAc/G,MAAM,EAAE,KAAsB,UAAUkB,GAAE,QAAQ,OAAM,EAAG,CAC/TkG,CAAGlG,EAAEC,EAAEhB,EAAEiB,GAAG,OAAM,EAAG,GAAGA,EAAE,OAAM,EAAG,GAAG,OAAOjB,EAAE,OAAOA,EAAEI,MAAM,KAAK,EAAE,OAAOY,EAAE,KAAK,EAAE,OAAM,IAAKA,EAAE,KAAK,EAAE,OAAOkG,MAAMlG,GAAG,KAAK,EAAE,OAAOkG,MAAMlG,IAAI,EAAEA,EAAE,OAAM,CAAE,CAOtEmG,CAAGnG,EAAEhB,EAAEkB,EAAED,KAAKjB,EAAE,MAAMiB,GAAG,OAAOC,EARxK,SAAYH,GAAG,QAAG8E,EAAGtK,KAAKyK,EAAGjF,KAAe8E,EAAGtK,KAAKwK,EAAGhF,KAAe+E,EAAGsB,KAAKrG,GAAUiF,EAAGjF,IAAG,GAAGgF,EAAGhF,IAAG,GAAS,GAAE,CAQwDsG,CAAGrG,KAAK,OAAOhB,EAAEe,EAAEuG,gBAAgBtG,GAAGD,EAAEwG,aAAavG,EAAE,GAAGhB,IAAIkB,EAAEoF,gBAAgBvF,EAAEG,EAAEqF,cAAc,OAAOvG,EAAE,IAAIkB,EAAEd,MAAQ,GAAGJ,GAAGgB,EAAEE,EAAEkF,cAAcnF,EAAEC,EAAEmF,mBAAmB,OAAOrG,EAAEe,EAAEuG,gBAAgBtG,IAAahB,EAAE,KAAXkB,EAAEA,EAAEd,OAAc,IAAIc,IAAG,IAAKlB,EAAE,GAAG,GAAGA,EAAEiB,EAAEF,EAAEyG,eAAevG,EAAED,EAAEhB,GAAGe,EAAEwG,aAAavG,EAAEhB,KAAI,CAHjd,0jCAA0jC2G,MAAM,KAAK5E,SAAQ,SAAShB,GAAG,IAAIC,EAAED,EAAEjD,QAAQ+I,EACzmCC,GAAIJ,EAAE1F,GAAG,IAAIiF,EAAEjF,EAAE,GAAE,EAAGD,EAAE,MAAK,GAAG,EAAG,IAAG,2EAA2E4F,MAAM,KAAK5E,SAAQ,SAAShB,GAAG,IAAIC,EAAED,EAAEjD,QAAQ+I,EAAGC,GAAIJ,EAAE1F,GAAG,IAAIiF,EAAEjF,EAAE,GAAE,EAAGD,EAAE,gCAA+B,GAAG,EAAG,IAAG,CAAC,WAAW,WAAW,aAAagB,SAAQ,SAAShB,GAAG,IAAIC,EAAED,EAAEjD,QAAQ+I,EAAGC,GAAIJ,EAAE1F,GAAG,IAAIiF,EAAEjF,EAAE,GAAE,EAAGD,EAAE,wCAAuC,GAAG,EAAG,IAAG,CAAC,WAAW,eAAegB,SAAQ,SAAShB,GAAG2F,EAAE3F,GAAG,IAAIkF,EAAElF,EAAE,GAAE,EAAGA,EAAE6F,cAAc,MAAK,GAAG,EAAG,IACldF,EAAEe,UAAU,IAAIxB,EAAE,YAAY,GAAE,EAAG,aAAa,gCAA+B,GAAG,GAAI,CAAC,MAAM,OAAO,SAAS,cAAclE,SAAQ,SAAShB,GAAG2F,EAAE3F,GAAG,IAAIkF,EAAElF,EAAE,GAAE,EAAGA,EAAE6F,cAAc,MAAK,GAAG,EAAG,IAE5L,IAAIc,EAAG3C,EAAG4C,mDAAmDC,EAAGC,OAAOC,IAAI,iBAAiBC,EAAGF,OAAOC,IAAI,gBAAgBE,EAAGH,OAAOC,IAAI,kBAAkBG,EAAGJ,OAAOC,IAAI,qBAAqBI,EAAGL,OAAOC,IAAI,kBAAkBK,EAAGN,OAAOC,IAAI,kBAAkBM,EAAGP,OAAOC,IAAI,iBAAiBO,EAAGR,OAAOC,IAAI,qBAAqBQ,EAAGT,OAAOC,IAAI,kBAAkBS,EAAGV,OAAOC,IAAI,uBAAuBU,EAAGX,OAAOC,IAAI,cAAcW,EAAGZ,OAAOC,IAAI,cAAcD,OAAOC,IAAI,eAAeD,OAAOC,IAAI,0BACje,IAAIY,EAAGb,OAAOC,IAAI,mBAAmBD,OAAOC,IAAI,uBAAuBD,OAAOC,IAAI,eAAeD,OAAOC,IAAI,wBAAwB,IAAIa,EAAGd,OAAOe,SAAS,SAASC,EAAG9H,GAAG,OAAG,OAAOA,GAAG,kBAAkBA,EAAS,KAAwC,oBAAnCA,EAAE4H,GAAI5H,EAAE4H,IAAK5H,EAAE,eAA0CA,EAAE,IAAI,CAAC,IAAoB+H,EAAhBC,EAAEnO,OAAOoO,OAAU,SAASC,EAAGlI,GAAG,QAAG,IAAS+H,EAAG,IAAI,MAAMzJ,OAAQ,CAAC,MAAMW,GAAG,IAAIgB,EAAEhB,EAAEkJ,MAAMtL,OAAOS,MAAM,gBAAgByK,EAAG9H,GAAGA,EAAE,IAAI,EAAE,CAAC,MAAM,KAAK8H,EAAG/H,CAAC,CAAC,IAAIoI,GAAG,EACzb,SAASC,EAAGrI,EAAEC,GAAG,IAAID,GAAGoI,EAAG,MAAM,GAAGA,GAAG,EAAG,IAAInJ,EAAEX,MAAMgK,kBAAkBhK,MAAMgK,uBAAkB,EAAO,IAAI,GAAGrI,EAAE,GAAGA,EAAE,WAAW,MAAM3B,OAAQ,EAAEzE,OAAOK,eAAe+F,EAAEnG,UAAU,QAAQ,CAACyO,IAAI,WAAW,MAAMjK,OAAQ,IAAI,kBAAkBkK,SAASA,QAAQC,UAAU,CAAC,IAAID,QAAQC,UAAUxI,EAAE,GAAG,CAAC,MAAMyI,GAAG,IAAIxI,EAAEwI,CAAC,CAACF,QAAQC,UAAUzI,EAAE,GAAGC,EAAE,KAAK,CAAC,IAAIA,EAAEzF,MAAM,CAAC,MAAMkO,GAAGxI,EAAEwI,CAAC,CAAC1I,EAAExF,KAAKyF,EAAEnG,UAAU,KAAK,CAAC,IAAI,MAAMwE,OAAQ,CAAC,MAAMoK,GAAGxI,EAAEwI,CAAC,CAAC1I,GAAG,CAAC,CAAC,MAAM0I,GAAG,GAAGA,GAAGxI,GAAG,kBAAkBwI,EAAEP,MAAM,CAAC,IAAI,IAAIhI,EAAEuI,EAAEP,MAAMvC,MAAM,MACnfxF,EAAEF,EAAEiI,MAAMvC,MAAM,MAAMT,EAAEhF,EAAEjE,OAAO,EAAEyM,EAAEvI,EAAElE,OAAO,EAAE,GAAGiJ,GAAG,GAAGwD,GAAGxI,EAAEgF,KAAK/E,EAAEuI,IAAIA,IAAI,KAAK,GAAGxD,GAAG,GAAGwD,EAAExD,IAAIwD,IAAI,GAAGxI,EAAEgF,KAAK/E,EAAEuI,GAAG,CAAC,GAAG,IAAIxD,GAAG,IAAIwD,EAAG,MAAMxD,IAAQ,IAAJwD,GAASxI,EAAEgF,KAAK/E,EAAEuI,GAAG,CAAC,IAAIC,EAAE,KAAKzI,EAAEgF,GAAGpI,QAAQ,WAAW,QAA6F,OAArFiD,EAAE6I,aAAaD,EAAEE,SAAS,iBAAiBF,EAAEA,EAAE7L,QAAQ,cAAciD,EAAE6I,cAAqBD,CAAC,QAAO,GAAGzD,GAAG,GAAGwD,GAAG,KAAK,CAAC,CAAC,CAAC,QAAQP,GAAG,EAAG9J,MAAMgK,kBAAkBrJ,CAAC,CAAC,OAAOe,EAAEA,EAAEA,EAAE6I,aAAa7I,EAAE9E,KAAK,IAAIgN,EAAGlI,GAAG,EAAE,CAC9Z,SAAS+I,EAAG/I,GAAG,OAAOA,EAAEgJ,KAAK,KAAK,EAAE,OAAOd,EAAGlI,EAAEX,MAAM,KAAK,GAAG,OAAO6I,EAAG,QAAQ,KAAK,GAAG,OAAOA,EAAG,YAAY,KAAK,GAAG,OAAOA,EAAG,gBAAgB,KAAK,EAAE,KAAK,EAAE,KAAK,GAAG,OAAOlI,EAAEqI,EAAGrI,EAAEX,MAAK,GAAM,KAAK,GAAG,OAAOW,EAAEqI,EAAGrI,EAAEX,KAAK4J,QAAO,GAAM,KAAK,EAAE,OAAOjJ,EAAEqI,EAAGrI,EAAEX,MAAK,GAAM,QAAQ,MAAM,GAAG,CACxR,SAAS6J,EAAGlJ,GAAG,GAAG,MAAMA,EAAE,OAAO,KAAK,GAAG,oBAAoBA,EAAE,OAAOA,EAAE6I,aAAa7I,EAAE9E,MAAM,KAAK,GAAG,kBAAkB8E,EAAE,OAAOA,EAAE,OAAOA,GAAG,KAAKiH,EAAG,MAAM,WAAW,KAAKD,EAAG,MAAM,SAAS,KAAKG,EAAG,MAAM,WAAW,KAAKD,EAAG,MAAM,aAAa,KAAKK,EAAG,MAAM,WAAW,KAAKC,EAAG,MAAM,eAAe,GAAG,kBAAkBxH,EAAE,OAAOA,EAAEmJ,UAAU,KAAK9B,EAAG,OAAOrH,EAAE6I,aAAa,WAAW,YAAY,KAAKzB,EAAG,OAAOpH,EAAEoJ,SAASP,aAAa,WAAW,YAAY,KAAKvB,EAAG,IAAIrH,EAAED,EAAEiJ,OAC7Z,OADoajJ,EAAEA,EAAE6I,eACnd7I,EAAE,MADieA,EAAEC,EAAE4I,aAClf5I,EAAE/E,MAAM,IAAY,cAAc8E,EAAE,IAAI,cAAqBA,EAAE,KAAKyH,EAAG,OAA6B,QAAtBxH,EAAED,EAAE6I,aAAa,MAAc5I,EAAEiJ,EAAGlJ,EAAEX,OAAO,OAAO,KAAKqI,EAAGzH,EAAED,EAAEqJ,SAASrJ,EAAEA,EAAEsJ,MAAM,IAAI,OAAOJ,EAAGlJ,EAAEC,GAAG,CAAC,MAAMhB,GAAG,EAAE,OAAO,IAAI,CAC3M,SAASsK,EAAGvJ,GAAG,IAAIC,EAAED,EAAEX,KAAK,OAAOW,EAAEgJ,KAAK,KAAK,GAAG,MAAM,QAAQ,KAAK,EAAE,OAAO/I,EAAE4I,aAAa,WAAW,YAAY,KAAK,GAAG,OAAO5I,EAAEmJ,SAASP,aAAa,WAAW,YAAY,KAAK,GAAG,MAAM,qBAAqB,KAAK,GAAG,OAAkB7I,GAAXA,EAAEC,EAAEgJ,QAAWJ,aAAa7I,EAAE9E,MAAM,GAAG+E,EAAE4I,cAAc,KAAK7I,EAAE,cAAcA,EAAE,IAAI,cAAc,KAAK,EAAE,MAAM,WAAW,KAAK,EAAE,OAAOC,EAAE,KAAK,EAAE,MAAM,SAAS,KAAK,EAAE,MAAM,OAAO,KAAK,EAAE,MAAM,OAAO,KAAK,GAAG,OAAOiJ,EAAGjJ,GAAG,KAAK,EAAE,OAAOA,IAAIiH,EAAG,aAAa,OAAO,KAAK,GAAG,MAAM,YACtf,KAAK,GAAG,MAAM,WAAW,KAAK,GAAG,MAAM,QAAQ,KAAK,GAAG,MAAM,WAAW,KAAK,GAAG,MAAM,eAAe,KAAK,GAAG,MAAM,gBAAgB,KAAK,EAAE,KAAK,EAAE,KAAK,GAAG,KAAK,EAAE,KAAK,GAAG,KAAK,GAAG,GAAG,oBAAoBjH,EAAE,OAAOA,EAAE4I,aAAa5I,EAAE/E,MAAM,KAAK,GAAG,kBAAkB+E,EAAE,OAAOA,EAAE,OAAO,IAAI,CAAC,SAASuJ,EAAGxJ,GAAG,cAAcA,GAAG,IAAK,UAAU,IAAK,SAAS,IAAK,SAAS,IAAK,YAAqB,IAAK,SAAS,OAAOA,EAAE,QAAQ,MAAM,GAAG,CACra,SAASyJ,EAAGzJ,GAAG,IAAIC,EAAED,EAAEX,KAAK,OAAOW,EAAEA,EAAE0J,WAAW,UAAU1J,EAAE6F,gBAAgB,aAAa5F,GAAG,UAAUA,EAAE,CAEtF,SAAS0J,EAAG3J,GAAGA,EAAE4J,gBAAgB5J,EAAE4J,cADvD,SAAY5J,GAAG,IAAIC,EAAEwJ,EAAGzJ,GAAG,UAAU,QAAQf,EAAEpF,OAAOO,yBAAyB4F,EAAElF,YAAYhB,UAAUmG,GAAGC,EAAE,GAAGF,EAAEC,GAAG,IAAID,EAAEjG,eAAekG,IAAI,qBAAqBhB,GAAG,oBAAoBA,EAAE4K,KAAK,oBAAoB5K,EAAEsJ,IAAI,CAAC,IAAIpI,EAAElB,EAAE4K,IAAIzJ,EAAEnB,EAAEsJ,IAAiL,OAA7K1O,OAAOK,eAAe8F,EAAEC,EAAE,CAAC7E,cAAa,EAAGyO,IAAI,WAAW,OAAO1J,EAAE3F,KAAKsD,KAAK,EAAEyK,IAAI,SAASvI,GAAGE,EAAE,GAAGF,EAAEI,EAAE5F,KAAKsD,KAAKkC,EAAE,IAAInG,OAAOK,eAAe8F,EAAEC,EAAE,CAAC9E,WAAW8D,EAAE9D,aAAmB,CAAC2O,SAAS,WAAW,OAAO5J,CAAC,EAAE6J,SAAS,SAAS/J,GAAGE,EAAE,GAAGF,CAAC,EAAEgK,aAAa,WAAWhK,EAAE4J,cACxf,YAAY5J,EAAEC,EAAE,EAAE,CAAC,CAAkDgK,CAAGjK,GAAG,CAAC,SAASkK,EAAGlK,GAAG,IAAIA,EAAE,OAAM,EAAG,IAAIC,EAAED,EAAE4J,cAAc,IAAI3J,EAAE,OAAM,EAAG,IAAIhB,EAAEgB,EAAE6J,WAAe5J,EAAE,GAAqD,OAAlDF,IAAIE,EAAEuJ,EAAGzJ,GAAGA,EAAEmK,QAAQ,OAAO,QAAQnK,EAAE3E,QAAO2E,EAAEE,KAAajB,IAAGgB,EAAE8J,SAAS/J,IAAG,EAAM,CAAC,SAASoK,EAAGpK,GAAwD,GAAG,qBAAxDA,EAAEA,IAAI,qBAAqB4E,SAASA,cAAS,IAAkC,OAAO,KAAK,IAAI,OAAO5E,EAAEqK,eAAerK,EAAEsK,IAAI,CAAC,MAAMrK,GAAG,OAAOD,EAAEsK,IAAI,CAAC,CACpa,SAASC,EAAGvK,EAAEC,GAAG,IAAIhB,EAAEgB,EAAEkK,QAAQ,OAAOnC,EAAE,CAAC,EAAE/H,EAAE,CAACuK,oBAAe,EAAOC,kBAAa,EAAOpP,WAAM,EAAO8O,QAAQ,MAAMlL,EAAEA,EAAEe,EAAE0K,cAAcC,gBAAgB,CAAC,SAASC,EAAG5K,EAAEC,GAAG,IAAIhB,EAAE,MAAMgB,EAAEwK,aAAa,GAAGxK,EAAEwK,aAAavK,EAAE,MAAMD,EAAEkK,QAAQlK,EAAEkK,QAAQlK,EAAEuK,eAAevL,EAAEuK,EAAG,MAAMvJ,EAAE5E,MAAM4E,EAAE5E,MAAM4D,GAAGe,EAAE0K,cAAc,CAACC,eAAezK,EAAE2K,aAAa5L,EAAE6L,WAAW,aAAa7K,EAAEZ,MAAM,UAAUY,EAAEZ,KAAK,MAAMY,EAAEkK,QAAQ,MAAMlK,EAAE5E,MAAM,CAAC,SAAS0P,EAAG/K,EAAEC,GAAe,OAAZA,EAAEA,EAAEkK,UAAiBlE,EAAGjG,EAAE,UAAUC,GAAE,EAAG,CAC9d,SAAS+K,EAAGhL,EAAEC,GAAG8K,EAAG/K,EAAEC,GAAG,IAAIhB,EAAEuK,EAAGvJ,EAAE5E,OAAO6E,EAAED,EAAEZ,KAAK,GAAG,MAAMJ,EAAK,WAAWiB,GAAM,IAAIjB,GAAG,KAAKe,EAAE3E,OAAO2E,EAAE3E,OAAO4D,KAAEe,EAAE3E,MAAM,GAAG4D,GAAOe,EAAE3E,QAAQ,GAAG4D,IAAIe,EAAE3E,MAAM,GAAG4D,QAAQ,GAAG,WAAWiB,GAAG,UAAUA,EAA8B,YAA3BF,EAAEuG,gBAAgB,SAAgBtG,EAAElG,eAAe,SAASkR,GAAGjL,EAAEC,EAAEZ,KAAKJ,GAAGgB,EAAElG,eAAe,iBAAiBkR,GAAGjL,EAAEC,EAAEZ,KAAKmK,EAAGvJ,EAAEwK,eAAe,MAAMxK,EAAEkK,SAAS,MAAMlK,EAAEuK,iBAAiBxK,EAAEwK,iBAAiBvK,EAAEuK,eAAe,CACla,SAASU,EAAGlL,EAAEC,EAAEhB,GAAG,GAAGgB,EAAElG,eAAe,UAAUkG,EAAElG,eAAe,gBAAgB,CAAC,IAAImG,EAAED,EAAEZ,KAAK,KAAK,WAAWa,GAAG,UAAUA,QAAG,IAASD,EAAE5E,OAAO,OAAO4E,EAAE5E,OAAO,OAAO4E,EAAE,GAAGD,EAAE0K,cAAcG,aAAa5L,GAAGgB,IAAID,EAAE3E,QAAQ2E,EAAE3E,MAAM4E,GAAGD,EAAEyK,aAAaxK,CAAC,CAAU,MAAThB,EAAEe,EAAE9E,QAAc8E,EAAE9E,KAAK,IAAI8E,EAAEwK,iBAAiBxK,EAAE0K,cAAcC,eAAe,KAAK1L,IAAIe,EAAE9E,KAAK+D,EAAE,CACzV,SAASgM,GAAGjL,EAAEC,EAAEhB,GAAM,WAAWgB,GAAGmK,EAAGpK,EAAEmL,iBAAiBnL,IAAE,MAAMf,EAAEe,EAAEyK,aAAa,GAAGzK,EAAE0K,cAAcG,aAAa7K,EAAEyK,eAAe,GAAGxL,IAAIe,EAAEyK,aAAa,GAAGxL,GAAE,CAAC,IAAImM,GAAG7Q,MAAMF,QAC7K,SAASgR,GAAGrL,EAAEC,EAAEhB,EAAEiB,GAAe,GAAZF,EAAEA,EAAE/E,QAAWgF,EAAE,CAACA,EAAE,CAAC,EAAE,IAAI,IAAIE,EAAE,EAAEA,EAAElB,EAAE/C,OAAOiE,IAAIF,EAAE,IAAIhB,EAAEkB,KAAI,EAAG,IAAIlB,EAAE,EAAEA,EAAEe,EAAE9D,OAAO+C,IAAIkB,EAAEF,EAAElG,eAAe,IAAIiG,EAAEf,GAAG5D,OAAO2E,EAAEf,GAAGqM,WAAWnL,IAAIH,EAAEf,GAAGqM,SAASnL,GAAGA,GAAGD,IAAIF,EAAEf,GAAGsM,iBAAgB,EAAG,KAAK,CAAmB,IAAlBtM,EAAE,GAAGuK,EAAGvK,GAAGgB,EAAE,KAASE,EAAE,EAAEA,EAAEH,EAAE9D,OAAOiE,IAAI,CAAC,GAAGH,EAAEG,GAAG9E,QAAQ4D,EAAiD,OAA9Ce,EAAEG,GAAGmL,UAAS,OAAGpL,IAAIF,EAAEG,GAAGoL,iBAAgB,IAAW,OAAOtL,GAAGD,EAAEG,GAAGqL,WAAWvL,EAAED,EAAEG,GAAG,CAAC,OAAOF,IAAIA,EAAEqL,UAAS,EAAG,CAAC,CACxY,SAASG,GAAGzL,EAAEC,GAAG,GAAG,MAAMA,EAAEyL,wBAAwB,MAAMpN,MAAM4F,EAAE,KAAK,OAAO8D,EAAE,CAAC,EAAE/H,EAAE,CAAC5E,WAAM,EAAOoP,kBAAa,EAAOkB,SAAS,GAAG3L,EAAE0K,cAAcG,cAAc,CAAC,SAASe,GAAG5L,EAAEC,GAAG,IAAIhB,EAAEgB,EAAE5E,MAAM,GAAG,MAAM4D,EAAE,CAA+B,GAA9BA,EAAEgB,EAAE0L,SAAS1L,EAAEA,EAAEwK,aAAgB,MAAMxL,EAAE,CAAC,GAAG,MAAMgB,EAAE,MAAM3B,MAAM4F,EAAE,KAAK,GAAGkH,GAAGnM,GAAG,CAAC,GAAG,EAAEA,EAAE/C,OAAO,MAAMoC,MAAM4F,EAAE,KAAKjF,EAAEA,EAAE,EAAE,CAACgB,EAAEhB,CAAC,CAAC,MAAMgB,IAAIA,EAAE,IAAIhB,EAAEgB,CAAC,CAACD,EAAE0K,cAAc,CAACG,aAAarB,EAAGvK,GAAG,CACnY,SAAS4M,GAAG7L,EAAEC,GAAG,IAAIhB,EAAEuK,EAAGvJ,EAAE5E,OAAO6E,EAAEsJ,EAAGvJ,EAAEwK,cAAc,MAAMxL,KAAIA,EAAE,GAAGA,KAAMe,EAAE3E,QAAQ2E,EAAE3E,MAAM4D,GAAG,MAAMgB,EAAEwK,cAAczK,EAAEyK,eAAexL,IAAIe,EAAEyK,aAAaxL,IAAI,MAAMiB,IAAIF,EAAEyK,aAAa,GAAGvK,EAAE,CAAC,SAAS4L,GAAG9L,GAAG,IAAIC,EAAED,EAAE+L,YAAY9L,IAAID,EAAE0K,cAAcG,cAAc,KAAK5K,GAAG,OAAOA,IAAID,EAAE3E,MAAM4E,EAAE,CAAC,SAAS+L,GAAGhM,GAAG,OAAOA,GAAG,IAAK,MAAM,MAAM,6BAA6B,IAAK,OAAO,MAAM,qCAAqC,QAAQ,MAAM,+BAA+B,CAC7c,SAASiM,GAAGjM,EAAEC,GAAG,OAAO,MAAMD,GAAG,iCAAiCA,EAAEgM,GAAG/L,GAAG,+BAA+BD,GAAG,kBAAkBC,EAAE,+BAA+BD,CAAC,CAChK,IAAIkM,GAAelM,GAAZmM,IAAYnM,GAAsJ,SAASA,EAAEC,GAAG,GAAG,+BAA+BD,EAAEoM,cAAc,cAAcpM,EAAEA,EAAEqM,UAAUpM,MAAM,CAA2F,KAA1FiM,GAAGA,IAAItH,SAASC,cAAc,QAAUwH,UAAU,QAAQpM,EAAEqM,UAAUrS,WAAW,SAAagG,EAAEiM,GAAGK,WAAWvM,EAAEuM,YAAYvM,EAAEwM,YAAYxM,EAAEuM,YAAY,KAAKtM,EAAEsM,YAAYvM,EAAEyM,YAAYxM,EAAEsM,WAAW,CAAC,EAAvb,qBAAqBG,OAAOA,MAAMC,wBAAwB,SAAS1M,EAAEhB,EAAEiB,EAAEC,GAAGuM,MAAMC,yBAAwB,WAAW,OAAO3M,GAAEC,EAAEhB,EAAM,GAAE,EAAEe,IACtK,SAAS4M,GAAG5M,EAAEC,GAAG,GAAGA,EAAE,CAAC,IAAIhB,EAAEe,EAAEuM,WAAW,GAAGtN,GAAGA,IAAIe,EAAE6M,WAAW,IAAI5N,EAAE6N,SAAwB,YAAd7N,EAAE8N,UAAU9M,EAAS,CAACD,EAAE+L,YAAY9L,CAAC,CACtH,IAAI+M,GAAG,CAACC,yBAAwB,EAAGC,aAAY,EAAGC,mBAAkB,EAAGC,kBAAiB,EAAGC,kBAAiB,EAAGC,SAAQ,EAAGC,cAAa,EAAGC,iBAAgB,EAAGC,aAAY,EAAGC,SAAQ,EAAGC,MAAK,EAAGC,UAAS,EAAGC,cAAa,EAAGC,YAAW,EAAGC,cAAa,EAAGC,WAAU,EAAGC,UAAS,EAAGC,SAAQ,EAAGC,YAAW,EAAGC,aAAY,EAAGC,cAAa,EAAGC,YAAW,EAAGC,eAAc,EAAGC,gBAAe,EAAGC,iBAAgB,EAAGC,YAAW,EAAGC,WAAU,EAAGC,YAAW,EAAGC,SAAQ,EAAGC,OAAM,EAAGC,SAAQ,EAAGC,SAAQ,EAAGC,QAAO,EAAGC,QAAO,EAClfC,MAAK,EAAGC,aAAY,EAAGC,cAAa,EAAGC,aAAY,EAAGC,iBAAgB,EAAGC,kBAAiB,EAAGC,kBAAiB,EAAGC,eAAc,EAAGC,aAAY,GAAIC,GAAG,CAAC,SAAS,KAAK,MAAM,KAA6H,SAASC,GAAG7P,EAAEC,EAAEhB,GAAG,OAAO,MAAMgB,GAAG,mBAAmBA,GAAG,KAAKA,EAAE,GAAGhB,GAAG,kBAAkBgB,GAAG,IAAIA,GAAG+M,GAAGjT,eAAeiG,IAAIgN,GAAGhN,IAAI,GAAGC,GAAGpD,OAAOoD,EAAE,IAAI,CACzb,SAAS6P,GAAG9P,EAAEC,GAAa,IAAI,IAAIhB,KAAlBe,EAAEA,EAAEhD,MAAmBiD,EAAE,GAAGA,EAAElG,eAAekF,GAAG,CAAC,IAAIiB,EAAE,IAAIjB,EAAE8Q,QAAQ,MAAM5P,EAAE0P,GAAG5Q,EAAEgB,EAAEhB,GAAGiB,GAAG,UAAUjB,IAAIA,EAAE,YAAYiB,EAAEF,EAAEjF,YAAYkE,EAAEkB,GAAGH,EAAEf,GAAGkB,CAAC,CAAC,CADYtG,OAAOmW,KAAKhD,IAAIhM,SAAQ,SAAShB,GAAG4P,GAAG5O,SAAQ,SAASf,GAAGA,EAAEA,EAAED,EAAEZ,OAAO,GAAG4G,cAAchG,EAAEiQ,UAAU,GAAGjD,GAAG/M,GAAG+M,GAAGhN,EAAE,GAAE,IAChI,IAAIkQ,GAAGlI,EAAE,CAACmI,UAAS,GAAI,CAACC,MAAK,EAAGC,MAAK,EAAGC,IAAG,EAAGC,KAAI,EAAGC,OAAM,EAAGC,IAAG,EAAGC,KAAI,EAAGC,OAAM,EAAGC,QAAO,EAAGC,MAAK,EAAGC,MAAK,EAAGC,OAAM,EAAG/S,QAAO,EAAGgT,OAAM,EAAGC,KAAI,IAClT,SAASC,GAAGlR,EAAEC,GAAG,GAAGA,EAAE,CAAC,GAAGiQ,GAAGlQ,KAAK,MAAMC,EAAE0L,UAAU,MAAM1L,EAAEyL,yBAAyB,MAAMpN,MAAM4F,EAAE,IAAIlE,IAAI,GAAG,MAAMC,EAAEyL,wBAAwB,CAAC,GAAG,MAAMzL,EAAE0L,SAAS,MAAMrN,MAAM4F,EAAE,KAAK,GAAG,kBAAkBjE,EAAEyL,2BAA2B,WAAWzL,EAAEyL,yBAAyB,MAAMpN,MAAM4F,EAAE,IAAK,CAAC,GAAG,MAAMjE,EAAEjD,OAAO,kBAAkBiD,EAAEjD,MAAM,MAAMsB,MAAM4F,EAAE,IAAK,CAAC,CAClW,SAASiN,GAAGnR,EAAEC,GAAG,IAAI,IAAID,EAAE+P,QAAQ,KAAK,MAAM,kBAAkB9P,EAAEmR,GAAG,OAAOpR,GAAG,IAAK,iBAAiB,IAAK,gBAAgB,IAAK,YAAY,IAAK,gBAAgB,IAAK,gBAAgB,IAAK,mBAAmB,IAAK,iBAAiB,IAAK,gBAAgB,OAAM,EAAG,QAAQ,OAAM,EAAG,CAAC,IAAIqR,GAAG,KAAK,SAASC,GAAGtR,GAA6F,OAA1FA,EAAEA,EAAEhF,QAAQgF,EAAEuR,YAAY5M,QAAS6M,0BAA0BxR,EAAEA,EAAEwR,yBAAgC,IAAIxR,EAAE8M,SAAS9M,EAAEyR,WAAWzR,CAAC,CAAC,IAAI0R,GAAG,KAAKC,GAAG,KAAKC,GAAG,KACpc,SAASC,GAAG7R,GAAG,GAAGA,EAAE8R,GAAG9R,GAAG,CAAC,GAAG,oBAAoB0R,GAAG,MAAMpT,MAAM4F,EAAE,MAAM,IAAIjE,EAAED,EAAE+R,UAAU9R,IAAIA,EAAE+R,GAAG/R,GAAGyR,GAAG1R,EAAE+R,UAAU/R,EAAEX,KAAKY,GAAG,CAAC,CAAC,SAASgS,GAAGjS,GAAG2R,GAAGC,GAAGA,GAAGlT,KAAKsB,GAAG4R,GAAG,CAAC5R,GAAG2R,GAAG3R,CAAC,CAAC,SAASkS,KAAK,GAAGP,GAAG,CAAC,IAAI3R,EAAE2R,GAAG1R,EAAE2R,GAAoB,GAAjBA,GAAGD,GAAG,KAAKE,GAAG7R,GAAMC,EAAE,IAAID,EAAE,EAAEA,EAAEC,EAAE/D,OAAO8D,IAAI6R,GAAG5R,EAAED,GAAG,CAAC,CAAC,SAASmS,GAAGnS,EAAEC,GAAG,OAAOD,EAAEC,EAAE,CAAC,SAASmS,KAAK,CAAC,IAAIC,IAAG,EAAG,SAASC,GAAGtS,EAAEC,EAAEhB,GAAG,GAAGoT,GAAG,OAAOrS,EAAEC,EAAEhB,GAAGoT,IAAG,EAAG,IAAI,OAAOF,GAAGnS,EAAEC,EAAEhB,EAAE,CAAC,QAAWoT,IAAG,GAAG,OAAOV,IAAI,OAAOC,MAAGQ,KAAKF,KAAI,CAAC,CAChb,SAASK,GAAGvS,EAAEC,GAAG,IAAIhB,EAAEe,EAAE+R,UAAU,GAAG,OAAO9S,EAAE,OAAO,KAAK,IAAIiB,EAAE8R,GAAG/S,GAAG,GAAG,OAAOiB,EAAE,OAAO,KAAKjB,EAAEiB,EAAED,GAAGD,EAAE,OAAOC,GAAG,IAAK,UAAU,IAAK,iBAAiB,IAAK,gBAAgB,IAAK,uBAAuB,IAAK,cAAc,IAAK,qBAAqB,IAAK,cAAc,IAAK,qBAAqB,IAAK,YAAY,IAAK,mBAAmB,IAAK,gBAAgBC,GAAGA,EAAEsL,YAAqBtL,IAAI,YAAbF,EAAEA,EAAEX,OAAuB,UAAUW,GAAG,WAAWA,GAAG,aAAaA,IAAIA,GAAGE,EAAE,MAAMF,EAAE,QAAQA,GAAE,EAAG,GAAGA,EAAE,OAAO,KAAK,GAAGf,GAAG,oBACleA,EAAE,MAAMX,MAAM4F,EAAE,IAAIjE,SAAShB,IAAI,OAAOA,CAAC,CAAC,IAAIuT,IAAG,EAAG,GAAG9N,EAAG,IAAI,IAAI+N,GAAG,CAAC,EAAE5Y,OAAOK,eAAeuY,GAAG,UAAU,CAAC5I,IAAI,WAAW2I,IAAG,CAAE,IAAI7N,OAAO+N,iBAAiB,OAAOD,GAAGA,IAAI9N,OAAOgO,oBAAoB,OAAOF,GAAGA,GAAG,CAAC,MAAMzS,IAAGwS,IAAG,CAAE,CAAC,SAASI,GAAG5S,EAAEC,EAAEhB,EAAEiB,EAAEC,EAAEC,EAAE+E,EAAEwD,EAAEC,GAAG,IAAIF,EAAEnO,MAAMT,UAAUgF,MAAMtE,KAAKwB,UAAU,GAAG,IAAIiE,EAAEkB,MAAMlC,EAAEyJ,EAAE,CAAC,MAAM9J,GAAGd,KAAK+U,QAAQjU,EAAE,CAAC,CAAC,IAAIkU,IAAG,EAAGC,GAAG,KAAKC,IAAG,EAAGC,GAAG,KAAKC,GAAG,CAACL,QAAQ,SAAS7S,GAAG8S,IAAG,EAAGC,GAAG/S,CAAC,GAAG,SAASmT,GAAGnT,EAAEC,EAAEhB,EAAEiB,EAAEC,EAAEC,EAAE+E,EAAEwD,EAAEC,GAAGkK,IAAG,EAAGC,GAAG,KAAKH,GAAGzR,MAAM+R,GAAGlX,UAAU,CACjW,SAASoX,GAAGpT,GAAG,IAAIC,EAAED,EAAEf,EAAEe,EAAE,GAAGA,EAAEqT,UAAU,KAAKpT,EAAEqT,QAAQrT,EAAEA,EAAEqT,WAAW,CAACtT,EAAEC,EAAE,GAAO,KAAa,MAAjBA,EAAED,GAASuT,SAActU,EAAEgB,EAAEqT,QAAQtT,EAAEC,EAAEqT,aAAatT,EAAE,CAAC,OAAO,IAAIC,EAAE+I,IAAI/J,EAAE,IAAI,CAAC,SAASuU,GAAGxT,GAAG,GAAG,KAAKA,EAAEgJ,IAAI,CAAC,IAAI/I,EAAED,EAAEyT,cAAsE,GAAxD,OAAOxT,IAAkB,QAAdD,EAAEA,EAAEqT,aAAqBpT,EAAED,EAAEyT,gBAAmB,OAAOxT,EAAE,OAAOA,EAAEyT,UAAU,CAAC,OAAO,IAAI,CAAC,SAASC,GAAG3T,GAAG,GAAGoT,GAAGpT,KAAKA,EAAE,MAAM1B,MAAM4F,EAAE,KAAM,CAE1S,SAAS0P,GAAG5T,GAAW,OAAO,QAAfA,EADtN,SAAYA,GAAG,IAAIC,EAAED,EAAEqT,UAAU,IAAIpT,EAAE,CAAS,GAAG,QAAXA,EAAEmT,GAAGpT,IAAe,MAAM1B,MAAM4F,EAAE,MAAM,OAAOjE,IAAID,EAAE,KAAKA,CAAC,CAAC,IAAI,IAAIf,EAAEe,EAAEE,EAAED,IAAI,CAAC,IAAIE,EAAElB,EAAEqU,OAAO,GAAG,OAAOnT,EAAE,MAAM,IAAIC,EAAED,EAAEkT,UAAU,GAAG,OAAOjT,EAAE,CAAY,GAAG,QAAdF,EAAEC,EAAEmT,QAAmB,CAACrU,EAAEiB,EAAE,QAAQ,CAAC,KAAK,CAAC,GAAGC,EAAE0T,QAAQzT,EAAEyT,MAAM,CAAC,IAAIzT,EAAED,EAAE0T,MAAMzT,GAAG,CAAC,GAAGA,IAAInB,EAAE,OAAO0U,GAAGxT,GAAGH,EAAE,GAAGI,IAAIF,EAAE,OAAOyT,GAAGxT,GAAGF,EAAEG,EAAEA,EAAE0T,OAAO,CAAC,MAAMxV,MAAM4F,EAAE,KAAM,CAAC,GAAGjF,EAAEqU,SAASpT,EAAEoT,OAAOrU,EAAEkB,EAAED,EAAEE,MAAM,CAAC,IAAI,IAAI+E,GAAE,EAAGwD,EAAExI,EAAE0T,MAAMlL,GAAG,CAAC,GAAGA,IAAI1J,EAAE,CAACkG,GAAE,EAAGlG,EAAEkB,EAAED,EAAEE,EAAE,KAAK,CAAC,GAAGuI,IAAIzI,EAAE,CAACiF,GAAE,EAAGjF,EAAEC,EAAElB,EAAEmB,EAAE,KAAK,CAACuI,EAAEA,EAAEmL,OAAO,CAAC,IAAI3O,EAAE,CAAC,IAAIwD,EAAEvI,EAAEyT,MAAMlL,GAAG,CAAC,GAAGA,IAC5f1J,EAAE,CAACkG,GAAE,EAAGlG,EAAEmB,EAAEF,EAAEC,EAAE,KAAK,CAAC,GAAGwI,IAAIzI,EAAE,CAACiF,GAAE,EAAGjF,EAAEE,EAAEnB,EAAEkB,EAAE,KAAK,CAACwI,EAAEA,EAAEmL,OAAO,CAAC,IAAI3O,EAAE,MAAM7G,MAAM4F,EAAE,KAAM,CAAC,CAAC,GAAGjF,EAAEoU,YAAYnT,EAAE,MAAM5B,MAAM4F,EAAE,KAAM,CAAC,GAAG,IAAIjF,EAAE+J,IAAI,MAAM1K,MAAM4F,EAAE,MAAM,OAAOjF,EAAE8S,UAAUgC,UAAU9U,EAAEe,EAAEC,CAAC,CAAkB+T,CAAGhU,IAAmBiU,GAAGjU,GAAG,IAAI,CAAC,SAASiU,GAAGjU,GAAG,GAAG,IAAIA,EAAEgJ,KAAK,IAAIhJ,EAAEgJ,IAAI,OAAOhJ,EAAE,IAAIA,EAAEA,EAAE6T,MAAM,OAAO7T,GAAG,CAAC,IAAIC,EAAEgU,GAAGjU,GAAG,GAAG,OAAOC,EAAE,OAAOA,EAAED,EAAEA,EAAE8T,OAAO,CAAC,OAAO,IAAI,CAC1X,IAAII,GAAGjQ,EAAGkQ,0BAA0BC,GAAGnQ,EAAGoQ,wBAAwBC,GAAGrQ,EAAGsQ,qBAAqBC,GAAGvQ,EAAGwQ,sBAAsBC,GAAEzQ,EAAG0Q,aAAaC,GAAG3Q,EAAG4Q,iCAAiCC,GAAG7Q,EAAG8Q,2BAA2BC,GAAG/Q,EAAGgR,8BAA8BC,GAAGjR,EAAGkR,wBAAwBC,GAAGnR,EAAGoR,qBAAqBC,GAAGrR,EAAGsR,sBAAsBC,GAAG,KAAKC,GAAG,KACvV,IAAIC,GAAGC,KAAKC,MAAMD,KAAKC,MAAiC,SAAY5V,GAAU,OAAPA,KAAK,EAAS,IAAIA,EAAE,GAAG,IAAI6V,GAAG7V,GAAG8V,GAAG,GAAG,CAAC,EAA/ED,GAAGF,KAAKI,IAAID,GAAGH,KAAKK,IAA4D,IAAIC,GAAG,GAAGC,GAAG,QAC7H,SAASC,GAAGnW,GAAG,OAAOA,GAAGA,GAAG,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,GAAG,OAAO,GAAG,KAAK,GAAG,OAAO,GAAG,KAAK,GAAG,KAAK,IAAI,KAAK,IAAI,KAAK,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,MAAM,KAAK,MAAM,KAAK,MAAM,KAAK,OAAO,KAAK,OAAO,KAAK,OAAO,KAAK,QAAQ,KAAK,QAAQ,OAAS,QAAFA,EAAU,KAAK,QAAQ,KAAK,QAAQ,KAAK,SAAS,KAAK,SAAS,KAAK,SAAS,OAAS,UAAFA,EAAY,KAAK,UAAU,OAAO,UAAU,KAAK,UAAU,OAAO,UAAU,KAAK,UAAU,OAAO,UAAU,KAAK,WAAW,OAAO,WACzgB,QAAQ,OAAOA,EAAE,CAAC,SAASoW,GAAGpW,EAAEC,GAAG,IAAIhB,EAAEe,EAAEqW,aAAa,GAAG,IAAIpX,EAAE,OAAO,EAAE,IAAIiB,EAAE,EAAEC,EAAEH,EAAEsW,eAAelW,EAAEJ,EAAEuW,YAAYpR,EAAI,UAAFlG,EAAY,GAAG,IAAIkG,EAAE,CAAC,IAAIwD,EAAExD,GAAGhF,EAAE,IAAIwI,EAAEzI,EAAEiW,GAAGxN,GAAS,KAALvI,GAAG+E,KAAUjF,EAAEiW,GAAG/V,GAAI,MAAa,KAAP+E,EAAElG,GAAGkB,GAAQD,EAAEiW,GAAGhR,GAAG,IAAI/E,IAAIF,EAAEiW,GAAG/V,IAAI,GAAG,IAAIF,EAAE,OAAO,EAAE,GAAG,IAAID,GAAGA,IAAIC,GAAG,KAAKD,EAAEE,MAAKA,EAAED,GAAGA,KAAEE,EAAEH,GAAGA,IAAQ,KAAKE,GAAG,KAAO,QAAFC,IAAY,OAAOH,EAA0C,GAAxC,KAAO,EAAFC,KAAOA,GAAK,GAAFjB,GAA4B,KAAtBgB,EAAED,EAAEwW,gBAAwB,IAAIxW,EAAEA,EAAEyW,cAAcxW,GAAGC,EAAE,EAAED,GAAcE,EAAE,IAAblB,EAAE,GAAGyW,GAAGzV,IAAUC,GAAGF,EAAEf,GAAGgB,IAAIE,EAAE,OAAOD,CAAC,CACvc,SAASwW,GAAG1W,EAAEC,GAAG,OAAOD,GAAG,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,OAAOC,EAAE,IAAI,KAAK,EAAE,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,IAAI,KAAK,IAAI,KAAK,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,MAAM,KAAK,MAAM,KAAK,MAAM,KAAK,OAAO,KAAK,OAAO,KAAK,OAAO,KAAK,QAAQ,KAAK,QAAQ,OAAOA,EAAE,IAAuJ,QAAQ,OAAO,EAAE,CACrN,SAAS0W,GAAG3W,GAAgC,OAAO,KAApCA,GAAkB,WAAhBA,EAAEqW,cAAsCrW,EAAI,WAAFA,EAAa,WAAW,CAAC,CAAC,SAAS4W,KAAK,IAAI5W,EAAEiW,GAAoC,OAA1B,KAAQ,SAAfA,KAAK,MAAqBA,GAAG,IAAWjW,CAAC,CAAC,SAAS6W,GAAG7W,GAAG,IAAI,IAAIC,EAAE,GAAGhB,EAAE,EAAE,GAAGA,EAAEA,IAAIgB,EAAEvB,KAAKsB,GAAG,OAAOC,CAAC,CAC3a,SAAS6W,GAAG9W,EAAEC,EAAEhB,GAAGe,EAAEqW,cAAcpW,EAAE,YAAYA,IAAID,EAAEsW,eAAe,EAAEtW,EAAEuW,YAAY,IAAGvW,EAAEA,EAAE+W,YAAW9W,EAAE,GAAGyV,GAAGzV,IAAQhB,CAAC,CACzH,SAAS+X,GAAGhX,EAAEC,GAAG,IAAIhB,EAAEe,EAAEwW,gBAAgBvW,EAAE,IAAID,EAAEA,EAAEyW,cAAcxX,GAAG,CAAC,IAAIiB,EAAE,GAAGwV,GAAGzW,GAAGkB,EAAE,GAAGD,EAAEC,EAAEF,EAAED,EAAEE,GAAGD,IAAID,EAAEE,IAAID,GAAGhB,IAAIkB,CAAC,CAAC,CAAC,IAAI8W,GAAE,EAAE,SAASC,GAAGlX,GAAS,OAAO,GAAbA,IAAIA,GAAa,EAAEA,EAAE,KAAO,UAAFA,GAAa,GAAG,UAAU,EAAE,CAAC,CAAC,IAAImX,GAAGC,GAAGC,GAAGC,GAAGC,GAAGC,IAAG,EAAGC,GAAG,GAAGC,GAAG,KAAKC,GAAG,KAAKC,GAAG,KAAKC,GAAG,IAAIC,IAAIC,GAAG,IAAID,IAAIE,GAAG,GAAGC,GAAG,6PAA6PrS,MAAM,KAChiB,SAASsS,GAAGlY,EAAEC,GAAG,OAAOD,GAAG,IAAK,UAAU,IAAK,WAAW0X,GAAG,KAAK,MAAM,IAAK,YAAY,IAAK,YAAYC,GAAG,KAAK,MAAM,IAAK,YAAY,IAAK,WAAWC,GAAG,KAAK,MAAM,IAAK,cAAc,IAAK,aAAaC,GAAGM,OAAOlY,EAAEmY,WAAW,MAAM,IAAK,oBAAoB,IAAK,qBAAqBL,GAAGI,OAAOlY,EAAEmY,WAAW,CACnT,SAASC,GAAGrY,EAAEC,EAAEhB,EAAEiB,EAAEC,EAAEC,GAAG,OAAG,OAAOJ,GAAGA,EAAEsY,cAAclY,GAASJ,EAAE,CAACuY,UAAUtY,EAAEuY,aAAavZ,EAAEwZ,iBAAiBvY,EAAEoY,YAAYlY,EAAEsY,iBAAiB,CAACvY,IAAI,OAAOF,IAAY,QAARA,EAAE6R,GAAG7R,KAAamX,GAAGnX,IAAID,IAAEA,EAAEyY,kBAAkBvY,EAAED,EAAED,EAAE0Y,iBAAiB,OAAOvY,IAAI,IAAIF,EAAE8P,QAAQ5P,IAAIF,EAAEvB,KAAKyB,GAAUH,EAAC,CAEpR,SAAS2Y,GAAG3Y,GAAG,IAAIC,EAAE2Y,GAAG5Y,EAAEhF,QAAQ,GAAG,OAAOiF,EAAE,CAAC,IAAIhB,EAAEmU,GAAGnT,GAAG,GAAG,OAAOhB,EAAE,GAAW,MAARgB,EAAEhB,EAAE+J,MAAY,GAAW,QAAR/I,EAAEuT,GAAGvU,IAA4D,OAA/Ce,EAAEuY,UAAUtY,OAAEsX,GAAGvX,EAAE6Y,UAAS,WAAWxB,GAAGpY,EAAE,SAAgB,GAAG,IAAIgB,GAAGhB,EAAE8S,UAAUgC,QAAQN,cAAcqF,aAAmE,YAArD9Y,EAAEuY,UAAU,IAAItZ,EAAE+J,IAAI/J,EAAE8S,UAAUgH,cAAc,KAAY,CAAC/Y,EAAEuY,UAAU,IAAI,CAClT,SAASS,GAAGhZ,GAAG,GAAG,OAAOA,EAAEuY,UAAU,OAAM,EAAG,IAAI,IAAItY,EAAED,EAAE0Y,iBAAiB,EAAEzY,EAAE/D,QAAQ,CAAC,IAAI+C,EAAEga,GAAGjZ,EAAEwY,aAAaxY,EAAEyY,iBAAiBxY,EAAE,GAAGD,EAAEsY,aAAa,GAAG,OAAOrZ,EAAiG,OAAe,QAARgB,EAAE6R,GAAG7S,KAAamY,GAAGnX,GAAGD,EAAEuY,UAAUtZ,GAAE,EAA3H,IAAIiB,EAAE,IAAtBjB,EAAEe,EAAEsY,aAAwBxd,YAAYmE,EAAEI,KAAKJ,GAAGoS,GAAGnR,EAAEjB,EAAEjE,OAAOke,cAAchZ,GAAGmR,GAAG,KAA0DpR,EAAEkZ,OAAO,CAAC,OAAM,CAAE,CAAC,SAASC,GAAGpZ,EAAEC,EAAEhB,GAAG+Z,GAAGhZ,IAAIf,EAAEkZ,OAAOlY,EAAE,CAAC,SAASoZ,KAAK7B,IAAG,EAAG,OAAOE,IAAIsB,GAAGtB,MAAMA,GAAG,MAAM,OAAOC,IAAIqB,GAAGrB,MAAMA,GAAG,MAAM,OAAOC,IAAIoB,GAAGpB,MAAMA,GAAG,MAAMC,GAAG7W,QAAQoY,IAAIrB,GAAG/W,QAAQoY,GAAG,CACnf,SAASE,GAAGtZ,EAAEC,GAAGD,EAAEuY,YAAYtY,IAAID,EAAEuY,UAAU,KAAKf,KAAKA,IAAG,EAAGvT,EAAGkQ,0BAA0BlQ,EAAGkR,wBAAwBkE,KAAK,CAC5H,SAASE,GAAGvZ,GAAG,SAASC,EAAEA,GAAG,OAAOqZ,GAAGrZ,EAAED,EAAE,CAAC,GAAG,EAAEyX,GAAGvb,OAAO,CAACod,GAAG7B,GAAG,GAAGzX,GAAG,IAAI,IAAIf,EAAE,EAAEA,EAAEwY,GAAGvb,OAAO+C,IAAI,CAAC,IAAIiB,EAAEuX,GAAGxY,GAAGiB,EAAEqY,YAAYvY,IAAIE,EAAEqY,UAAU,KAAK,CAAC,CAAyF,IAAxF,OAAOb,IAAI4B,GAAG5B,GAAG1X,GAAG,OAAO2X,IAAI2B,GAAG3B,GAAG3X,GAAG,OAAO4X,IAAI0B,GAAG1B,GAAG5X,GAAG6X,GAAG7W,QAAQf,GAAG8X,GAAG/W,QAAQf,GAAOhB,EAAE,EAAEA,EAAE+Y,GAAG9b,OAAO+C,KAAIiB,EAAE8X,GAAG/Y,IAAKsZ,YAAYvY,IAAIE,EAAEqY,UAAU,MAAM,KAAK,EAAEP,GAAG9b,QAAiB,QAAR+C,EAAE+Y,GAAG,IAAYO,WAAYI,GAAG1Z,GAAG,OAAOA,EAAEsZ,WAAWP,GAAGmB,OAAO,CAAC,IAAIK,GAAG7S,EAAG8S,wBAAwBC,IAAG,EAC5a,SAASC,GAAG3Z,EAAEC,EAAEhB,EAAEiB,GAAG,IAAIC,EAAE8W,GAAE7W,EAAEoZ,GAAGI,WAAWJ,GAAGI,WAAW,KAAK,IAAI3C,GAAE,EAAE4C,GAAG7Z,EAAEC,EAAEhB,EAAEiB,EAAE,CAAC,QAAQ+W,GAAE9W,EAAEqZ,GAAGI,WAAWxZ,CAAC,CAAC,CAAC,SAAS0Z,GAAG9Z,EAAEC,EAAEhB,EAAEiB,GAAG,IAAIC,EAAE8W,GAAE7W,EAAEoZ,GAAGI,WAAWJ,GAAGI,WAAW,KAAK,IAAI3C,GAAE,EAAE4C,GAAG7Z,EAAEC,EAAEhB,EAAEiB,EAAE,CAAC,QAAQ+W,GAAE9W,EAAEqZ,GAAGI,WAAWxZ,CAAC,CAAC,CACjO,SAASyZ,GAAG7Z,EAAEC,EAAEhB,EAAEiB,GAAG,GAAGwZ,GAAG,CAAC,IAAIvZ,EAAE8Y,GAAGjZ,EAAEC,EAAEhB,EAAEiB,GAAG,GAAG,OAAOC,EAAE4Z,GAAG/Z,EAAEC,EAAEC,EAAE8Z,GAAG/a,GAAGiZ,GAAGlY,EAAEE,QAAQ,GANtF,SAAYF,EAAEC,EAAEhB,EAAEiB,EAAEC,GAAG,OAAOF,GAAG,IAAK,UAAU,OAAOyX,GAAGW,GAAGX,GAAG1X,EAAEC,EAAEhB,EAAEiB,EAAEC,IAAG,EAAG,IAAK,YAAY,OAAOwX,GAAGU,GAAGV,GAAG3X,EAAEC,EAAEhB,EAAEiB,EAAEC,IAAG,EAAG,IAAK,YAAY,OAAOyX,GAAGS,GAAGT,GAAG5X,EAAEC,EAAEhB,EAAEiB,EAAEC,IAAG,EAAG,IAAK,cAAc,IAAIC,EAAED,EAAEiY,UAAkD,OAAxCP,GAAGtP,IAAInI,EAAEiY,GAAGR,GAAGhO,IAAIzJ,IAAI,KAAKJ,EAAEC,EAAEhB,EAAEiB,EAAEC,KAAU,EAAG,IAAK,oBAAoB,OAAOC,EAAED,EAAEiY,UAAUL,GAAGxP,IAAInI,EAAEiY,GAAGN,GAAGlO,IAAIzJ,IAAI,KAAKJ,EAAEC,EAAEhB,EAAEiB,EAAEC,KAAI,EAAG,OAAM,CAAE,CAM1Q8Z,CAAG9Z,EAAEH,EAAEC,EAAEhB,EAAEiB,GAAGA,EAAEga,uBAAuB,GAAGhC,GAAGlY,EAAEE,GAAK,EAAFD,IAAM,EAAEgY,GAAGlI,QAAQ/P,GAAG,CAAC,KAAK,OAAOG,GAAG,CAAC,IAAIC,EAAE0R,GAAG3R,GAA0D,GAAvD,OAAOC,GAAG+W,GAAG/W,GAAiB,QAAdA,EAAE6Y,GAAGjZ,EAAEC,EAAEhB,EAAEiB,KAAa6Z,GAAG/Z,EAAEC,EAAEC,EAAE8Z,GAAG/a,GAAMmB,IAAID,EAAE,MAAMA,EAAEC,CAAC,CAAC,OAAOD,GAAGD,EAAEga,iBAAiB,MAAMH,GAAG/Z,EAAEC,EAAEC,EAAE,KAAKjB,EAAE,CAAC,CAAC,IAAI+a,GAAG,KACpU,SAASf,GAAGjZ,EAAEC,EAAEhB,EAAEiB,GAA2B,GAAxB8Z,GAAG,KAAwB,QAAXha,EAAE4Y,GAAV5Y,EAAEsR,GAAGpR,KAAuB,GAAW,QAARD,EAAEmT,GAAGpT,IAAYA,EAAE,UAAU,GAAW,MAARf,EAAEgB,EAAE+I,KAAW,CAAS,GAAG,QAAXhJ,EAAEwT,GAAGvT,IAAe,OAAOD,EAAEA,EAAE,IAAI,MAAM,GAAG,IAAIf,EAAE,CAAC,GAAGgB,EAAE8R,UAAUgC,QAAQN,cAAcqF,aAAa,OAAO,IAAI7Y,EAAE+I,IAAI/I,EAAE8R,UAAUgH,cAAc,KAAK/Y,EAAE,IAAI,MAAMC,IAAID,IAAIA,EAAE,MAAW,OAALga,GAAGha,EAAS,IAAI,CAC7S,SAASma,GAAGna,GAAG,OAAOA,GAAG,IAAK,SAAS,IAAK,QAAQ,IAAK,QAAQ,IAAK,cAAc,IAAK,OAAO,IAAK,MAAM,IAAK,WAAW,IAAK,WAAW,IAAK,UAAU,IAAK,YAAY,IAAK,OAAO,IAAK,UAAU,IAAK,WAAW,IAAK,QAAQ,IAAK,UAAU,IAAK,UAAU,IAAK,WAAW,IAAK,QAAQ,IAAK,YAAY,IAAK,UAAU,IAAK,QAAQ,IAAK,QAAQ,IAAK,OAAO,IAAK,gBAAgB,IAAK,cAAc,IAAK,YAAY,IAAK,aAAa,IAAK,QAAQ,IAAK,SAAS,IAAK,SAAS,IAAK,SAAS,IAAK,cAAc,IAAK,WAAW,IAAK,aAAa,IAAK,eAAe,IAAK,SAAS,IAAK,kBAAkB,IAAK,YAAY,IAAK,mBAAmB,IAAK,iBAAiB,IAAK,oBAAoB,IAAK,aAAa,IAAK,YAAY,IAAK,cAAc,IAAK,OAAO,IAAK,mBAAmB,IAAK,QAAQ,IAAK,aAAa,IAAK,WAAW,IAAK,SAAS,IAAK,cAAc,OAAO,EAAE,IAAK,OAAO,IAAK,YAAY,IAAK,WAAW,IAAK,YAAY,IAAK,WAAW,IAAK,YAAY,IAAK,WAAW,IAAK,YAAY,IAAK,cAAc,IAAK,aAAa,IAAK,cAAc,IAAK,SAAS,IAAK,SAAS,IAAK,YAAY,IAAK,QAAQ,IAAK,aAAa,IAAK,aAAa,IAAK,eAAe,IAAK,eAAe,OAAO,EACpqC,IAAK,UAAU,OAAO4U,MAAM,KAAKE,GAAG,OAAO,EAAE,KAAKE,GAAG,OAAO,EAAE,KAAKE,GAAG,KAAKE,GAAG,OAAO,GAAG,KAAKE,GAAG,OAAO,UAAU,QAAQ,OAAO,GAAG,QAAQ,OAAO,GAAG,CAAC,IAAI8E,GAAG,KAAKC,GAAG,KAAKC,GAAG,KAAK,SAASC,KAAK,GAAGD,GAAG,OAAOA,GAAG,IAAIta,EAAkBE,EAAhBD,EAAEoa,GAAGpb,EAAEgB,EAAE/D,OAASiE,EAAE,UAAUia,GAAGA,GAAG/e,MAAM+e,GAAGrO,YAAY3L,EAAED,EAAEjE,OAAO,IAAI8D,EAAE,EAAEA,EAAEf,GAAGgB,EAAED,KAAKG,EAAEH,GAAGA,KAAK,IAAImF,EAAElG,EAAEe,EAAE,IAAIE,EAAE,EAAEA,GAAGiF,GAAGlF,EAAEhB,EAAEiB,KAAKC,EAAEC,EAAEF,GAAGA,KAAK,OAAOoa,GAAGna,EAAErB,MAAMkB,EAAE,EAAEE,EAAE,EAAEA,OAAE,EAAO,CACxY,SAASsa,GAAGxa,GAAG,IAAIC,EAAED,EAAEya,QAA+E,MAAvE,aAAaza,EAAgB,KAAbA,EAAEA,EAAE0a,WAAgB,KAAKza,IAAID,EAAE,IAAKA,EAAEC,EAAE,KAAKD,IAAIA,EAAE,IAAW,IAAIA,GAAG,KAAKA,EAAEA,EAAE,CAAC,CAAC,SAAS2a,KAAK,OAAM,CAAE,CAAC,SAASC,KAAK,OAAM,CAAE,CAC5K,SAASC,GAAG7a,GAAG,SAASC,EAAEA,EAAEC,EAAEC,EAAEC,EAAE+E,GAA6G,IAAI,IAAIlG,KAAlHnB,KAAKgd,WAAW7a,EAAEnC,KAAKid,YAAY5a,EAAErC,KAAKuB,KAAKa,EAAEpC,KAAKwa,YAAYlY,EAAEtC,KAAK9C,OAAOmK,EAAErH,KAAKkd,cAAc,KAAkBhb,EAAEA,EAAEjG,eAAekF,KAAKgB,EAAED,EAAEf,GAAGnB,KAAKmB,GAAGgB,EAAEA,EAAEG,GAAGA,EAAEnB,IAAgI,OAA5HnB,KAAKmd,oBAAoB,MAAM7a,EAAE8a,iBAAiB9a,EAAE8a,kBAAiB,IAAK9a,EAAE+a,aAAaR,GAAGC,GAAG9c,KAAKsd,qBAAqBR,GAAU9c,IAAI,CAC9E,OAD+EkK,EAAE/H,EAAEnG,UAAU,CAACuhB,eAAe,WAAWvd,KAAKod,kBAAiB,EAAG,IAAIlb,EAAElC,KAAKwa,YAAYtY,IAAIA,EAAEqb,eAAerb,EAAEqb,iBAAiB,mBAAmBrb,EAAEmb,cAC7enb,EAAEmb,aAAY,GAAIrd,KAAKmd,mBAAmBN,GAAG,EAAET,gBAAgB,WAAW,IAAIla,EAAElC,KAAKwa,YAAYtY,IAAIA,EAAEka,gBAAgBla,EAAEka,kBAAkB,mBAAmBla,EAAEsb,eAAetb,EAAEsb,cAAa,GAAIxd,KAAKsd,qBAAqBT,GAAG,EAAEY,QAAQ,WAAW,EAAEC,aAAab,KAAY1a,CAAC,CACjR,IAAoLwb,GAAGC,GAAGC,GAAtLC,GAAG,CAACC,WAAW,EAAEC,QAAQ,EAAEC,WAAW,EAAEC,UAAU,SAAShc,GAAG,OAAOA,EAAEgc,WAAWC,KAAKC,KAAK,EAAEhB,iBAAiB,EAAEiB,UAAU,GAAGC,GAAGvB,GAAGe,IAAIS,GAAGrU,EAAE,CAAC,EAAE4T,GAAG,CAACU,KAAK,EAAEC,OAAO,IAAIC,GAAG3B,GAAGwB,IAAaI,GAAGzU,EAAE,CAAC,EAAEqU,GAAG,CAACK,QAAQ,EAAEC,QAAQ,EAAEC,QAAQ,EAAEC,QAAQ,EAAEC,MAAM,EAAEC,MAAM,EAAEC,QAAQ,EAAEC,SAAS,EAAEC,OAAO,EAAEC,QAAQ,EAAEC,iBAAiBC,GAAGC,OAAO,EAAEC,QAAQ,EAAEC,cAAc,SAASxd,GAAG,YAAO,IAASA,EAAEwd,cAAcxd,EAAEyd,cAAczd,EAAEuR,WAAWvR,EAAE0d,UAAU1d,EAAEyd,YAAYzd,EAAEwd,aAAa,EAAEG,UAAU,SAAS3d,GAAG,MAAG,cAC3eA,EAASA,EAAE2d,WAAU3d,IAAI2b,KAAKA,IAAI,cAAc3b,EAAEX,MAAMoc,GAAGzb,EAAE0c,QAAQf,GAAGe,QAAQhB,GAAG1b,EAAE2c,QAAQhB,GAAGgB,SAASjB,GAAGD,GAAG,EAAEE,GAAG3b,GAAUyb,GAAE,EAAEmC,UAAU,SAAS5d,GAAG,MAAM,cAAcA,EAAEA,EAAE4d,UAAUlC,EAAE,IAAImC,GAAGhD,GAAG4B,IAAiCqB,GAAGjD,GAA7B7S,EAAE,CAAC,EAAEyU,GAAG,CAACsB,aAAa,KAA4CC,GAAGnD,GAA9B7S,EAAE,CAAC,EAAEqU,GAAG,CAACmB,cAAc,KAA0ES,GAAGpD,GAA5D7S,EAAE,CAAC,EAAE4T,GAAG,CAACsC,cAAc,EAAEC,YAAY,EAAEC,cAAc,KAAcC,GAAGrW,EAAE,CAAC,EAAE4T,GAAG,CAAC0C,cAAc,SAASte,GAAG,MAAM,kBAAkBA,EAAEA,EAAEse,cAAc3Z,OAAO2Z,aAAa,IAAIC,GAAG1D,GAAGwD,IAAyBG,GAAG3D,GAArB7S,EAAE,CAAC,EAAE4T,GAAG,CAAC6C,KAAK,KAAcC,GAAG,CAACC,IAAI,SACxfC,SAAS,IAAIC,KAAK,YAAYC,GAAG,UAAUC,MAAM,aAAaC,KAAK,YAAYC,IAAI,SAASC,IAAI,KAAKC,KAAK,cAAcC,KAAK,cAAcC,OAAO,aAAaC,gBAAgB,gBAAgBC,GAAG,CAAC,EAAE,YAAY,EAAE,MAAM,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,GAAG,UAAU,GAAG,MAAM,GAAG,QAAQ,GAAG,WAAW,GAAG,SAAS,GAAG,IAAI,GAAG,SAAS,GAAG,WAAW,GAAG,MAAM,GAAG,OAAO,GAAG,YAAY,GAAG,UAAU,GAAG,aAAa,GAAG,YAAY,GAAG,SAAS,GAAG,SAAS,IAAI,KAAK,IAAI,KAAK,IAAI,KAAK,IAAI,KAAK,IAAI,KAAK,IAAI,KAAK,IAAI,KACtf,IAAI,KAAK,IAAI,KAAK,IAAI,MAAM,IAAI,MAAM,IAAI,MAAM,IAAI,UAAU,IAAI,aAAa,IAAI,QAAQC,GAAG,CAACC,IAAI,SAASC,QAAQ,UAAUC,KAAK,UAAUC,MAAM,YAAY,SAASC,GAAG7f,GAAG,IAAIC,EAAEnC,KAAKwa,YAAY,OAAOrY,EAAEmd,iBAAiBnd,EAAEmd,iBAAiBpd,MAAIA,EAAEwf,GAAGxf,OAAMC,EAAED,EAAK,CAAC,SAASqd,KAAK,OAAOwC,EAAE,CAChS,IAAIC,GAAG9X,EAAE,CAAC,EAAEqU,GAAG,CAAC1hB,IAAI,SAASqF,GAAG,GAAGA,EAAErF,IAAI,CAAC,IAAIsF,EAAEye,GAAG1e,EAAErF,MAAMqF,EAAErF,IAAI,GAAG,iBAAiBsF,EAAE,OAAOA,CAAC,CAAC,MAAM,aAAaD,EAAEX,KAAc,MAARW,EAAEwa,GAAGxa,IAAU,QAAQ+f,OAAOC,aAAahgB,GAAI,YAAYA,EAAEX,MAAM,UAAUW,EAAEX,KAAKkgB,GAAGvf,EAAEya,UAAU,eAAe,EAAE,EAAEwF,KAAK,EAAEpe,SAAS,EAAEmb,QAAQ,EAAEC,SAAS,EAAEC,OAAO,EAAEC,QAAQ,EAAE+C,OAAO,EAAEC,OAAO,EAAE/C,iBAAiBC,GAAG3C,SAAS,SAAS1a,GAAG,MAAM,aAAaA,EAAEX,KAAKmb,GAAGxa,GAAG,CAAC,EAAEya,QAAQ,SAASza,GAAG,MAAM,YAAYA,EAAEX,MAAM,UAAUW,EAAEX,KAAKW,EAAEya,QAAQ,CAAC,EAAE2F,MAAM,SAASpgB,GAAG,MAAM,aAC7eA,EAAEX,KAAKmb,GAAGxa,GAAG,YAAYA,EAAEX,MAAM,UAAUW,EAAEX,KAAKW,EAAEya,QAAQ,CAAC,IAAI4F,GAAGxF,GAAGiF,IAAiIQ,GAAGzF,GAA7H7S,EAAE,CAAC,EAAEyU,GAAG,CAACrE,UAAU,EAAEmI,MAAM,EAAEC,OAAO,EAAEC,SAAS,EAAEC,mBAAmB,EAAEC,MAAM,EAAEC,MAAM,EAAEC,MAAM,EAAEC,YAAY,EAAEC,UAAU,KAAmIC,GAAGnG,GAArH7S,EAAE,CAAC,EAAEqU,GAAG,CAAC4E,QAAQ,EAAEC,cAAc,EAAEC,eAAe,EAAEjE,OAAO,EAAEC,QAAQ,EAAEH,QAAQ,EAAEC,SAAS,EAAEG,iBAAiBC,MAA0E+D,GAAGvG,GAA3D7S,EAAE,CAAC,EAAE4T,GAAG,CAACpW,aAAa,EAAE2Y,YAAY,EAAEC,cAAc,KAAciD,GAAGrZ,EAAE,CAAC,EAAEyU,GAAG,CAAC6E,OAAO,SAASthB,GAAG,MAAM,WAAWA,EAAEA,EAAEshB,OAAO,gBAAgBthB,GAAGA,EAAEuhB,YAAY,CAAC,EACnfC,OAAO,SAASxhB,GAAG,MAAM,WAAWA,EAAEA,EAAEwhB,OAAO,gBAAgBxhB,GAAGA,EAAEyhB,YAAY,eAAezhB,GAAGA,EAAE0hB,WAAW,CAAC,EAAEC,OAAO,EAAEC,UAAU,IAAIC,GAAGhH,GAAGwG,IAAIS,GAAG,CAAC,EAAE,GAAG,GAAG,IAAIC,GAAGrd,GAAI,qBAAqBC,OAAOqd,GAAG,KAAKtd,GAAI,iBAAiBE,WAAWod,GAAGpd,SAASqd,cAAc,IAAIC,GAAGxd,GAAI,cAAcC,SAASqd,GAAGG,GAAGzd,KAAMqd,IAAIC,IAAI,EAAEA,IAAI,IAAIA,IAAII,GAAGrC,OAAOC,aAAa,IAAIqC,IAAG,EAC1W,SAASC,GAAGtiB,EAAEC,GAAG,OAAOD,GAAG,IAAK,QAAQ,OAAO,IAAI8hB,GAAG/R,QAAQ9P,EAAEwa,SAAS,IAAK,UAAU,OAAO,MAAMxa,EAAEwa,QAAQ,IAAK,WAAW,IAAK,YAAY,IAAK,WAAW,OAAM,EAAG,QAAQ,OAAM,EAAG,CAAC,SAAS8H,GAAGviB,GAAc,MAAM,kBAAjBA,EAAEA,EAAEuc,SAAkC,SAASvc,EAAEA,EAAEye,KAAK,IAAI,CAAC,IAAI+D,IAAG,EAE9Q,IAAIC,GAAG,CAACC,OAAM,EAAGC,MAAK,EAAGC,UAAS,EAAG,kBAAiB,EAAGC,OAAM,EAAGC,OAAM,EAAG9f,QAAO,EAAG+f,UAAS,EAAGC,OAAM,EAAGC,QAAO,EAAGC,KAAI,EAAGC,MAAK,EAAGC,MAAK,EAAGC,KAAI,EAAGC,MAAK,GAAI,SAASC,GAAGvjB,GAAG,IAAIC,EAAED,GAAGA,EAAE0J,UAAU1J,EAAE0J,SAAS7D,cAAc,MAAM,UAAU5F,IAAIwiB,GAAGziB,EAAEX,MAAM,aAAaY,CAAO,CAAC,SAASujB,GAAGxjB,EAAEC,EAAEhB,EAAEiB,GAAG+R,GAAG/R,GAAsB,GAAnBD,EAAEwjB,GAAGxjB,EAAE,aAAgB/D,SAAS+C,EAAE,IAAImd,GAAG,WAAW,SAAS,KAAKnd,EAAEiB,GAAGF,EAAEtB,KAAK,CAACglB,MAAMzkB,EAAE0kB,UAAU1jB,IAAI,CAAC,IAAI2jB,GAAG,KAAKC,GAAG,KAAK,SAASllB,GAAGqB,GAAG8jB,GAAG9jB,EAAE,EAAE,CAAC,SAAS+jB,GAAG/jB,GAAe,GAAGkK,EAAT8Z,GAAGhkB,IAAY,OAAOA,CAAC,CACpe,SAASikB,GAAGjkB,EAAEC,GAAG,GAAG,WAAWD,EAAE,OAAOC,CAAC,CAAC,IAAIikB,IAAG,EAAG,GAAGxf,EAAG,CAAC,IAAIyf,GAAG,GAAGzf,EAAG,CAAC,IAAI0f,GAAG,YAAYxf,SAAS,IAAIwf,GAAG,CAAC,IAAIC,GAAGzf,SAASC,cAAc,OAAOwf,GAAG7d,aAAa,UAAU,WAAW4d,GAAG,oBAAoBC,GAAGC,OAAO,CAACH,GAAGC,EAAE,MAAMD,IAAG,EAAGD,GAAGC,MAAMvf,SAASqd,cAAc,EAAErd,SAASqd,aAAa,CAAC,SAASsC,KAAKX,KAAKA,GAAGY,YAAY,mBAAmBC,IAAIZ,GAAGD,GAAG,KAAK,CAAC,SAASa,GAAGzkB,GAAG,GAAG,UAAUA,EAAEwF,cAAcue,GAAGF,IAAI,CAAC,IAAI5jB,EAAE,GAAGujB,GAAGvjB,EAAE4jB,GAAG7jB,EAAEsR,GAAGtR,IAAIsS,GAAG3T,GAAGsB,EAAE,CAAC,CAC/b,SAASykB,GAAG1kB,EAAEC,EAAEhB,GAAG,YAAYe,GAAGukB,KAAUV,GAAG5kB,GAAR2kB,GAAG3jB,GAAU0kB,YAAY,mBAAmBF,KAAK,aAAazkB,GAAGukB,IAAI,CAAC,SAASK,GAAG5kB,GAAG,GAAG,oBAAoBA,GAAG,UAAUA,GAAG,YAAYA,EAAE,OAAO+jB,GAAGF,GAAG,CAAC,SAASgB,GAAG7kB,EAAEC,GAAG,GAAG,UAAUD,EAAE,OAAO+jB,GAAG9jB,EAAE,CAAC,SAAS6kB,GAAG9kB,EAAEC,GAAG,GAAG,UAAUD,GAAG,WAAWA,EAAE,OAAO+jB,GAAG9jB,EAAE,CAAiE,IAAI8kB,GAAG,oBAAoBlrB,OAAOuX,GAAGvX,OAAOuX,GAA5G,SAAYpR,EAAEC,GAAG,OAAOD,IAAIC,IAAI,IAAID,GAAG,EAAEA,IAAI,EAAEC,IAAID,IAAIA,GAAGC,IAAIA,CAAC,EACtW,SAAS+kB,GAAGhlB,EAAEC,GAAG,GAAG8kB,GAAG/kB,EAAEC,GAAG,OAAM,EAAG,GAAG,kBAAkBD,GAAG,OAAOA,GAAG,kBAAkBC,GAAG,OAAOA,EAAE,OAAM,EAAG,IAAIhB,EAAEpF,OAAOmW,KAAKhQ,GAAGE,EAAErG,OAAOmW,KAAK/P,GAAG,GAAGhB,EAAE/C,SAASgE,EAAEhE,OAAO,OAAM,EAAG,IAAIgE,EAAE,EAAEA,EAAEjB,EAAE/C,OAAOgE,IAAI,CAAC,IAAIC,EAAElB,EAAEiB,GAAG,IAAI4E,EAAGtK,KAAKyF,EAAEE,KAAK4kB,GAAG/kB,EAAEG,GAAGF,EAAEE,IAAI,OAAM,CAAE,CAAC,OAAM,CAAE,CAAC,SAAS8kB,GAAGjlB,GAAG,KAAKA,GAAGA,EAAEuM,YAAYvM,EAAEA,EAAEuM,WAAW,OAAOvM,CAAC,CACtU,SAASklB,GAAGllB,EAAEC,GAAG,IAAwBC,EAApBjB,EAAEgmB,GAAGjlB,GAAO,IAAJA,EAAE,EAAYf,GAAG,CAAC,GAAG,IAAIA,EAAE6N,SAAS,CAA0B,GAAzB5M,EAAEF,EAAEf,EAAE8M,YAAY7P,OAAU8D,GAAGC,GAAGC,GAAGD,EAAE,MAAM,CAACtC,KAAKsB,EAAEkmB,OAAOllB,EAAED,GAAGA,EAAEE,CAAC,CAACF,EAAE,CAAC,KAAKf,GAAG,CAAC,GAAGA,EAAEmmB,YAAY,CAACnmB,EAAEA,EAAEmmB,YAAY,MAAMplB,CAAC,CAACf,EAAEA,EAAEwS,UAAU,CAACxS,OAAE,CAAM,CAACA,EAAEgmB,GAAGhmB,EAAE,CAAC,CAAC,SAASomB,GAAGrlB,EAAEC,GAAG,SAAOD,IAAGC,KAAED,IAAIC,KAAKD,GAAG,IAAIA,EAAE8M,YAAY7M,GAAG,IAAIA,EAAE6M,SAASuY,GAAGrlB,EAAEC,EAAEwR,YAAY,aAAazR,EAAEA,EAAEslB,SAASrlB,KAAGD,EAAEulB,4BAAwD,GAA7BvlB,EAAEulB,wBAAwBtlB,KAAY,CAC9Z,SAASulB,KAAK,IAAI,IAAIxlB,EAAE2E,OAAO1E,EAAEmK,IAAKnK,aAAaD,EAAEylB,mBAAmB,CAAC,IAAI,IAAIxmB,EAAE,kBAAkBgB,EAAEylB,cAAc7jB,SAAS8jB,IAAI,CAAC,MAAMzlB,GAAGjB,GAAE,CAAE,CAAC,IAAGA,EAAyB,MAAMgB,EAAEmK,GAA/BpK,EAAEC,EAAEylB,eAAgC9gB,SAAS,CAAC,OAAO3E,CAAC,CAAC,SAAS2lB,GAAG5lB,GAAG,IAAIC,EAAED,GAAGA,EAAE0J,UAAU1J,EAAE0J,SAAS7D,cAAc,OAAO5F,IAAI,UAAUA,IAAI,SAASD,EAAEX,MAAM,WAAWW,EAAEX,MAAM,QAAQW,EAAEX,MAAM,QAAQW,EAAEX,MAAM,aAAaW,EAAEX,OAAO,aAAaY,GAAG,SAASD,EAAE6lB,gBAAgB,CACxa,SAASC,GAAG9lB,GAAG,IAAIC,EAAEulB,KAAKvmB,EAAEe,EAAE+lB,YAAY7lB,EAAEF,EAAEgmB,eAAe,GAAG/lB,IAAIhB,GAAGA,GAAGA,EAAEkM,eAAeka,GAAGpmB,EAAEkM,cAAc8a,gBAAgBhnB,GAAG,CAAC,GAAG,OAAOiB,GAAG0lB,GAAG3mB,GAAG,GAAGgB,EAAEC,EAAEzC,WAAc,KAARuC,EAAEE,EAAEnC,OAAiBiC,EAAEC,GAAG,mBAAmBhB,EAAEA,EAAEinB,eAAejmB,EAAEhB,EAAEknB,aAAaxQ,KAAKyQ,IAAIpmB,EAAEf,EAAE5D,MAAMa,aAAa,IAAG8D,GAAGC,EAAEhB,EAAEkM,eAAevG,WAAW3E,EAAEomB,aAAa1hB,QAAS2hB,aAAa,CAACtmB,EAAEA,EAAEsmB,eAAe,IAAInmB,EAAElB,EAAE8M,YAAY7P,OAAOkE,EAAEuV,KAAKyQ,IAAIlmB,EAAEzC,MAAM0C,GAAGD,OAAE,IAASA,EAAEnC,IAAIqC,EAAEuV,KAAKyQ,IAAIlmB,EAAEnC,IAAIoC,IAAIH,EAAErE,QAAQyE,EAAEF,IAAIC,EAAED,EAAEA,EAAEE,EAAEA,EAAED,GAAGA,EAAE+kB,GAAGjmB,EAAEmB,GAAG,IAAI+E,EAAE+f,GAAGjmB,EACvfiB,GAAGC,GAAGgF,IAAI,IAAInF,EAAEumB,YAAYvmB,EAAEwmB,aAAarmB,EAAExC,MAAMqC,EAAEymB,eAAetmB,EAAEglB,QAAQnlB,EAAE0mB,YAAYvhB,EAAExH,MAAMqC,EAAE2mB,cAAcxhB,EAAEggB,WAAUllB,EAAEA,EAAE2mB,eAAgBC,SAAS1mB,EAAExC,KAAKwC,EAAEglB,QAAQnlB,EAAE8mB,kBAAkB1mB,EAAEF,GAAGF,EAAE+mB,SAAS9mB,GAAGD,EAAErE,OAAOwJ,EAAExH,KAAKwH,EAAEggB,UAAUllB,EAAE+mB,OAAO7hB,EAAExH,KAAKwH,EAAEggB,QAAQnlB,EAAE+mB,SAAS9mB,IAAI,CAAM,IAALA,EAAE,GAAOD,EAAEf,EAAEe,EAAEA,EAAEyR,YAAY,IAAIzR,EAAE8M,UAAU7M,EAAEvB,KAAK,CAAC4E,QAAQtD,EAAEinB,KAAKjnB,EAAEknB,WAAWC,IAAInnB,EAAEonB,YAAmD,IAAvC,oBAAoBnoB,EAAEooB,OAAOpoB,EAAEooB,QAAYpoB,EAAE,EAAEA,EAAEgB,EAAE/D,OAAO+C,KAAIe,EAAEC,EAAEhB,IAAKqE,QAAQ4jB,WAAWlnB,EAAEinB,KAAKjnB,EAAEsD,QAAQ8jB,UAAUpnB,EAAEmnB,GAAG,CAAC,CACzf,IAAIG,GAAG5iB,GAAI,iBAAiBE,UAAU,IAAIA,SAASqd,aAAasF,GAAG,KAAKC,GAAG,KAAKC,GAAG,KAAKC,IAAG,EAC3F,SAASC,GAAG3nB,EAAEC,EAAEhB,GAAG,IAAIiB,EAAEjB,EAAE0F,SAAS1F,EAAEA,EAAE2F,SAAS,IAAI3F,EAAE6N,SAAS7N,EAAEA,EAAEkM,cAAcuc,IAAI,MAAMH,IAAIA,KAAKnd,EAAGlK,KAAU,mBAALA,EAAEqnB,KAAyB3B,GAAG1lB,GAAGA,EAAE,CAACzC,MAAMyC,EAAEgmB,eAAenoB,IAAImC,EAAEimB,cAAuFjmB,EAAE,CAACsmB,YAA3EtmB,GAAGA,EAAEiL,eAAejL,EAAEiL,cAAckb,aAAa1hB,QAAQ2hB,gBAA+BE,WAAWC,aAAavmB,EAAEumB,aAAaC,UAAUxmB,EAAEwmB,UAAUC,YAAYzmB,EAAEymB,aAAcc,IAAIzC,GAAGyC,GAAGvnB,KAAKunB,GAAGvnB,EAAsB,GAApBA,EAAEujB,GAAG+D,GAAG,aAAgBtrB,SAAS+D,EAAE,IAAImc,GAAG,WAAW,SAAS,KAAKnc,EAAEhB,GAAGe,EAAEtB,KAAK,CAACglB,MAAMzjB,EAAE0jB,UAAUzjB,IAAID,EAAEjF,OAAOusB,KAAK,CACtf,SAASK,GAAG5nB,EAAEC,GAAG,IAAIhB,EAAE,CAAC,EAAiF,OAA/EA,EAAEe,EAAE6F,eAAe5F,EAAE4F,cAAc5G,EAAE,SAASe,GAAG,SAASC,EAAEhB,EAAE,MAAMe,GAAG,MAAMC,EAAShB,CAAC,CAAC,IAAI4oB,GAAG,CAACC,aAAaF,GAAG,YAAY,gBAAgBG,mBAAmBH,GAAG,YAAY,sBAAsBI,eAAeJ,GAAG,YAAY,kBAAkBK,cAAcL,GAAG,aAAa,kBAAkBM,GAAG,CAAC,EAAEC,GAAG,CAAC,EACpF,SAASC,GAAGpoB,GAAG,GAAGkoB,GAAGloB,GAAG,OAAOkoB,GAAGloB,GAAG,IAAI6nB,GAAG7nB,GAAG,OAAOA,EAAE,IAAYf,EAARgB,EAAE4nB,GAAG7nB,GAAK,IAAIf,KAAKgB,EAAE,GAAGA,EAAElG,eAAekF,IAAIA,KAAKkpB,GAAG,OAAOD,GAAGloB,GAAGC,EAAEhB,GAAG,OAAOe,CAAC,CAA/X0E,IAAKyjB,GAAGvjB,SAASC,cAAc,OAAO7H,MAAM,mBAAmB2H,gBAAgBkjB,GAAGC,aAAaO,iBAAiBR,GAAGE,mBAAmBM,iBAAiBR,GAAGG,eAAeK,WAAW,oBAAoB1jB,eAAekjB,GAAGI,cAAcrO,YAAwJ,IAAI0O,GAAGF,GAAG,gBAAgBG,GAAGH,GAAG,sBAAsBI,GAAGJ,GAAG,kBAAkBK,GAAGL,GAAG,iBAAiBM,GAAG,IAAI5Q,IAAI6Q,GAAG,smBAAsmB/iB,MAAM,KAC/lC,SAASgjB,GAAG5oB,EAAEC,GAAGyoB,GAAGngB,IAAIvI,EAAEC,GAAGsE,EAAGtE,EAAE,CAACD,GAAG,CAAC,IAAI,IAAI6oB,GAAG,EAAEA,GAAGF,GAAGzsB,OAAO2sB,KAAK,CAAC,IAAIC,GAAGH,GAAGE,IAA2DD,GAApDE,GAAGjjB,cAAuD,MAAtCijB,GAAG,GAAG9iB,cAAc8iB,GAAGhqB,MAAM,IAAiB,CAAC8pB,GAAGN,GAAG,kBAAkBM,GAAGL,GAAG,wBAAwBK,GAAGJ,GAAG,oBAAoBI,GAAG,WAAW,iBAAiBA,GAAG,UAAU,WAAWA,GAAG,WAAW,UAAUA,GAAGH,GAAG,mBAAmBjkB,EAAG,eAAe,CAAC,WAAW,cAAcA,EAAG,eAAe,CAAC,WAAW,cAAcA,EAAG,iBAAiB,CAAC,aAAa,gBAC7cA,EAAG,iBAAiB,CAAC,aAAa,gBAAgBD,EAAG,WAAW,oEAAoEqB,MAAM,MAAMrB,EAAG,WAAW,uFAAuFqB,MAAM,MAAMrB,EAAG,gBAAgB,CAAC,iBAAiB,WAAW,YAAY,UAAUA,EAAG,mBAAmB,2DAA2DqB,MAAM,MAAMrB,EAAG,qBAAqB,6DAA6DqB,MAAM,MAC/frB,EAAG,sBAAsB,8DAA8DqB,MAAM,MAAM,IAAImjB,GAAG,6NAA6NnjB,MAAM,KAAKojB,GAAG,IAAI3kB,IAAI,0CAA0CuB,MAAM,KAAK3D,OAAO8mB,KACzZ,SAASE,GAAGjpB,EAAEC,EAAEhB,GAAG,IAAIiB,EAAEF,EAAEX,MAAM,gBAAgBW,EAAEgb,cAAc/b,EAlDjE,SAAYe,EAAEC,EAAEhB,EAAEiB,EAAEC,EAAEC,EAAE+E,EAAEwD,EAAEC,GAA4B,GAAzBuK,GAAGhS,MAAMrD,KAAK9B,WAAc8W,GAAG,CAAC,IAAGA,GAAgC,MAAMxU,MAAM4F,EAAE,MAA1C,IAAIwE,EAAEqK,GAAGD,IAAG,EAAGC,GAAG,KAA8BC,KAAKA,IAAG,EAAGC,GAAGvK,EAAE,CAAC,CAkDpEwgB,CAAGhpB,EAAED,OAAE,EAAOD,GAAGA,EAAEgb,cAAc,IAAI,CACxG,SAAS8I,GAAG9jB,EAAEC,GAAGA,EAAE,KAAO,EAAFA,GAAK,IAAI,IAAIhB,EAAE,EAAEA,EAAEe,EAAE9D,OAAO+C,IAAI,CAAC,IAAIiB,EAAEF,EAAEf,GAAGkB,EAAED,EAAEwjB,MAAMxjB,EAAEA,EAAEyjB,UAAU3jB,EAAE,CAAC,IAAII,OAAE,EAAO,GAAGH,EAAE,IAAI,IAAIkF,EAAEjF,EAAEhE,OAAO,EAAE,GAAGiJ,EAAEA,IAAI,CAAC,IAAIwD,EAAEzI,EAAEiF,GAAGyD,EAAED,EAAEwgB,SAASzgB,EAAEC,EAAEqS,cAA2B,GAAbrS,EAAEA,EAAEygB,SAAYxgB,IAAIxI,GAAGD,EAAEib,uBAAuB,MAAMpb,EAAEipB,GAAG9oB,EAAEwI,EAAED,GAAGtI,EAAEwI,CAAC,MAAM,IAAIzD,EAAE,EAAEA,EAAEjF,EAAEhE,OAAOiJ,IAAI,CAAoD,GAA5CyD,GAAPD,EAAEzI,EAAEiF,IAAOgkB,SAASzgB,EAAEC,EAAEqS,cAAcrS,EAAEA,EAAEygB,SAAYxgB,IAAIxI,GAAGD,EAAEib,uBAAuB,MAAMpb,EAAEipB,GAAG9oB,EAAEwI,EAAED,GAAGtI,EAAEwI,CAAC,CAAC,CAAC,CAAC,GAAGoK,GAAG,MAAMhT,EAAEiT,GAAGD,IAAG,EAAGC,GAAG,KAAKjT,CAAE,CAC5a,SAASqpB,GAAErpB,EAAEC,GAAG,IAAIhB,EAAEgB,EAAEqpB,SAAI,IAASrqB,IAAIA,EAAEgB,EAAEqpB,IAAI,IAAIjlB,KAAK,IAAInE,EAAEF,EAAE,WAAWf,EAAEsqB,IAAIrpB,KAAKspB,GAAGvpB,EAAED,EAAE,GAAE,GAAIf,EAAEwF,IAAIvE,GAAG,CAAC,SAASupB,GAAGzpB,EAAEC,EAAEhB,GAAG,IAAIiB,EAAE,EAAED,IAAIC,GAAG,GAAGspB,GAAGvqB,EAAEe,EAAEE,EAAED,EAAE,CAAC,IAAIypB,GAAG,kBAAkB/T,KAAKgU,SAAS1vB,SAAS,IAAI6E,MAAM,GAAG,SAAS8qB,GAAG5pB,GAAG,IAAIA,EAAE0pB,IAAI,CAAC1pB,EAAE0pB,KAAI,EAAGtlB,EAAGpD,SAAQ,SAASf,GAAG,oBAAoBA,IAAI+oB,GAAGO,IAAItpB,IAAIwpB,GAAGxpB,GAAE,EAAGD,GAAGypB,GAAGxpB,GAAE,EAAGD,GAAG,IAAG,IAAIC,EAAE,IAAID,EAAE8M,SAAS9M,EAAEA,EAAEmL,cAAc,OAAOlL,GAAGA,EAAEypB,MAAMzpB,EAAEypB,KAAI,EAAGD,GAAG,mBAAkB,EAAGxpB,GAAG,CAAC,CACjb,SAASupB,GAAGxpB,EAAEC,EAAEhB,EAAEiB,GAAG,OAAOia,GAAGla,IAAI,KAAK,EAAE,IAAIE,EAAEwZ,GAAG,MAAM,KAAK,EAAExZ,EAAE2Z,GAAG,MAAM,QAAQ3Z,EAAE0Z,GAAG5a,EAAEkB,EAAEgC,KAAK,KAAKlC,EAAEhB,EAAEe,GAAGG,OAAE,GAAQqS,IAAI,eAAevS,GAAG,cAAcA,GAAG,UAAUA,IAAIE,GAAE,GAAID,OAAE,IAASC,EAAEH,EAAE0S,iBAAiBzS,EAAEhB,EAAE,CAAC4qB,SAAQ,EAAGC,QAAQ3pB,IAAIH,EAAE0S,iBAAiBzS,EAAEhB,GAAE,QAAI,IAASkB,EAAEH,EAAE0S,iBAAiBzS,EAAEhB,EAAE,CAAC6qB,QAAQ3pB,IAAIH,EAAE0S,iBAAiBzS,EAAEhB,GAAE,EAAG,CAClV,SAAS8a,GAAG/Z,EAAEC,EAAEhB,EAAEiB,EAAEC,GAAG,IAAIC,EAAEF,EAAE,GAAG,KAAO,EAAFD,IAAM,KAAO,EAAFA,IAAM,OAAOC,EAAEF,EAAE,OAAO,CAAC,GAAG,OAAOE,EAAE,OAAO,IAAIiF,EAAEjF,EAAE8I,IAAI,GAAG,IAAI7D,GAAG,IAAIA,EAAE,CAAC,IAAIwD,EAAEzI,EAAE6R,UAAUgH,cAAc,GAAGpQ,IAAIxI,GAAG,IAAIwI,EAAEmE,UAAUnE,EAAE8I,aAAatR,EAAE,MAAM,GAAG,IAAIgF,EAAE,IAAIA,EAAEjF,EAAEoT,OAAO,OAAOnO,GAAG,CAAC,IAAIyD,EAAEzD,EAAE6D,IAAI,IAAG,IAAIJ,GAAG,IAAIA,MAAKA,EAAEzD,EAAE4M,UAAUgH,iBAAkB5Y,GAAG,IAAIyI,EAAEkE,UAAUlE,EAAE6I,aAAatR,GAAE,OAAOgF,EAAEA,EAAEmO,MAAM,CAAC,KAAK,OAAO3K,GAAG,CAAS,GAAG,QAAXxD,EAAEyT,GAAGjQ,IAAe,OAAe,GAAG,KAAXC,EAAEzD,EAAE6D,MAAc,IAAIJ,EAAE,CAAC1I,EAAEE,EAAE+E,EAAE,SAASnF,CAAC,CAAC2I,EAAEA,EAAE8I,UAAU,CAAC,CAACvR,EAAEA,EAAEoT,MAAM,CAAChB,IAAG,WAAW,IAAIpS,EAAEE,EAAED,EAAEmR,GAAGrS,GAAGkG,EAAE,GACpfnF,EAAE,CAAC,IAAI2I,EAAE+f,GAAG7e,IAAI7J,GAAG,QAAG,IAAS2I,EAAE,CAAC,IAAIC,EAAEwT,GAAG2N,EAAE/pB,EAAE,OAAOA,GAAG,IAAK,WAAW,GAAG,IAAIwa,GAAGvb,GAAG,MAAMe,EAAE,IAAK,UAAU,IAAK,QAAQ4I,EAAEyX,GAAG,MAAM,IAAK,UAAU0J,EAAE,QAAQnhB,EAAEoV,GAAG,MAAM,IAAK,WAAW+L,EAAE,OAAOnhB,EAAEoV,GAAG,MAAM,IAAK,aAAa,IAAK,YAAYpV,EAAEoV,GAAG,MAAM,IAAK,QAAQ,GAAG,IAAI/e,EAAEqe,OAAO,MAAMtd,EAAE,IAAK,WAAW,IAAK,WAAW,IAAK,YAAY,IAAK,YAAY,IAAK,UAAU,IAAK,WAAW,IAAK,YAAY,IAAK,cAAc4I,EAAEiV,GAAG,MAAM,IAAK,OAAO,IAAK,UAAU,IAAK,YAAY,IAAK,WAAW,IAAK,YAAY,IAAK,WAAW,IAAK,YAAY,IAAK,OAAOjV,EAC1iBkV,GAAG,MAAM,IAAK,cAAc,IAAK,WAAW,IAAK,YAAY,IAAK,aAAalV,EAAEoY,GAAG,MAAM,KAAKsH,GAAG,KAAKC,GAAG,KAAKC,GAAG5f,EAAEqV,GAAG,MAAM,KAAKwK,GAAG7f,EAAEwY,GAAG,MAAM,IAAK,SAASxY,EAAE4T,GAAG,MAAM,IAAK,QAAQ5T,EAAEiZ,GAAG,MAAM,IAAK,OAAO,IAAK,MAAM,IAAK,QAAQjZ,EAAE2V,GAAG,MAAM,IAAK,oBAAoB,IAAK,qBAAqB,IAAK,gBAAgB,IAAK,cAAc,IAAK,cAAc,IAAK,aAAa,IAAK,cAAc,IAAK,YAAY3V,EAAE0X,GAAG,IAAI0J,EAAE,KAAO,EAAF/pB,GAAKgqB,GAAGD,GAAG,WAAWhqB,EAAEkqB,EAAEF,EAAE,OAAOrhB,EAAEA,EAAE,UAAU,KAAKA,EAAEqhB,EAAE,GAAG,IAAI,IAAQG,EAAJC,EAAElqB,EAAI,OAC/ekqB,GAAG,CAAK,IAAIC,GAARF,EAAEC,GAAUrY,UAAsF,GAA5E,IAAIoY,EAAEnhB,KAAK,OAAOqhB,IAAIF,EAAEE,EAAE,OAAOH,IAAc,OAAVG,EAAE9X,GAAG6X,EAAEF,KAAYF,EAAEtrB,KAAK4rB,GAAGF,EAAEC,EAAEF,MAASF,EAAE,MAAMG,EAAEA,EAAE9W,MAAM,CAAC,EAAE0W,EAAE9tB,SAASyM,EAAE,IAAIC,EAAED,EAAEohB,EAAE,KAAK9qB,EAAEkB,GAAGgF,EAAEzG,KAAK,CAACglB,MAAM/a,EAAEgb,UAAUqG,IAAI,CAAC,CAAC,GAAG,KAAO,EAAF/pB,GAAK,CAA4E,GAAnC2I,EAAE,aAAa5I,GAAG,eAAeA,KAAtE2I,EAAE,cAAc3I,GAAG,gBAAgBA,IAA2Cf,IAAIoS,MAAK0Y,EAAE9qB,EAAEue,eAAeve,EAAEwe,eAAe7E,GAAGmR,KAAIA,EAAEQ,OAAgB3hB,GAAGD,KAAGA,EAAExI,EAAEwE,SAASxE,EAAEA,GAAGwI,EAAExI,EAAEgL,eAAexC,EAAE0d,aAAa1d,EAAE6hB,aAAa7lB,OAAUiE,GAAqCA,EAAE1I,EAAiB,QAAf6pB,GAAnCA,EAAE9qB,EAAEue,eAAeve,EAAEye,WAAkB9E,GAAGmR,GAAG,QAC9dA,KAARE,EAAE7W,GAAG2W,KAAU,IAAIA,EAAE/gB,KAAK,IAAI+gB,EAAE/gB,OAAK+gB,EAAE,QAAUnhB,EAAE,KAAKmhB,EAAE7pB,GAAK0I,IAAImhB,GAAE,CAAgU,GAA/TC,EAAEnM,GAAGwM,EAAE,eAAeH,EAAE,eAAeE,EAAE,QAAW,eAAepqB,GAAG,gBAAgBA,IAAEgqB,EAAE1J,GAAG+J,EAAE,iBAAiBH,EAAE,iBAAiBE,EAAE,WAAUH,EAAE,MAAMrhB,EAAED,EAAEqb,GAAGpb,GAAGuhB,EAAE,MAAMJ,EAAEphB,EAAEqb,GAAG+F,IAAGphB,EAAE,IAAIqhB,EAAEK,EAAED,EAAE,QAAQxhB,EAAE3J,EAAEkB,IAAKnF,OAAOivB,EAAEthB,EAAE6U,cAAc2M,EAAEE,EAAE,KAAKzR,GAAGzY,KAAKD,KAAI8pB,EAAE,IAAIA,EAAEE,EAAEE,EAAE,QAAQL,EAAE9qB,EAAEkB,IAAKnF,OAAOmvB,EAAEH,EAAExM,cAAcyM,EAAEI,EAAEL,GAAGC,EAAEI,EAAKzhB,GAAGmhB,EAAE9pB,EAAE,CAAa,IAARiqB,EAAEH,EAAEK,EAAE,EAAMD,EAAhBH,EAAEphB,EAAkBuhB,EAAEA,EAAEM,GAAGN,GAAGC,IAAQ,IAAJD,EAAE,EAAME,EAAEH,EAAEG,EAAEA,EAAEI,GAAGJ,GAAGF,IAAI,KAAK,EAAEC,EAAED,GAAGH,EAAES,GAAGT,GAAGI,IAAI,KAAK,EAAED,EAAEC,GAAGF,EACpfO,GAAGP,GAAGC,IAAI,KAAKC,KAAK,CAAC,GAAGJ,IAAIE,GAAG,OAAOA,GAAGF,IAAIE,EAAE7W,UAAU,MAAMpT,EAAE+pB,EAAES,GAAGT,GAAGE,EAAEO,GAAGP,EAAE,CAACF,EAAE,IAAI,MAAMA,EAAE,KAAK,OAAOphB,GAAG8hB,GAAGvlB,EAAEwD,EAAEC,EAAEohB,GAAE,GAAI,OAAOD,GAAG,OAAOE,GAAGS,GAAGvlB,EAAE8kB,EAAEF,EAAEC,GAAE,EAAG,CAA8D,GAAG,YAA1CphB,GAAjBD,EAAEzI,EAAE8jB,GAAG9jB,GAAGyE,QAAW+E,UAAUf,EAAEe,SAAS7D,gBAA+B,UAAU+C,GAAG,SAASD,EAAEtJ,KAAK,IAAIsrB,EAAG1G,QAAQ,GAAGV,GAAG5a,GAAG,GAAGub,GAAGyG,EAAG7F,OAAO,CAAC6F,EAAG/F,GAAG,IAAIgG,EAAGlG,EAAE,MAAM9b,EAAED,EAAEe,WAAW,UAAUd,EAAE/C,gBAAgB,aAAa8C,EAAEtJ,MAAM,UAAUsJ,EAAEtJ,QAAQsrB,EAAG9F,IACrV,OAD4V8F,IAAKA,EAAGA,EAAG3qB,EAAEE,IAAKsjB,GAAGre,EAAEwlB,EAAG1rB,EAAEkB,IAAWyqB,GAAIA,EAAG5qB,EAAE2I,EAAEzI,GAAG,aAAaF,IAAI4qB,EAAGjiB,EAAE+B,gBAClfkgB,EAAG9f,YAAY,WAAWnC,EAAEtJ,MAAM4L,GAAGtC,EAAE,SAASA,EAAEtN,QAAOuvB,EAAG1qB,EAAE8jB,GAAG9jB,GAAGyE,OAAc3E,GAAG,IAAK,WAAaujB,GAAGqH,IAAK,SAASA,EAAG/E,mBAAgB0B,GAAGqD,EAAGpD,GAAGtnB,EAAEunB,GAAG,MAAK,MAAM,IAAK,WAAWA,GAAGD,GAAGD,GAAG,KAAK,MAAM,IAAK,YAAYG,IAAG,EAAG,MAAM,IAAK,cAAc,IAAK,UAAU,IAAK,UAAUA,IAAG,EAAGC,GAAGxiB,EAAElG,EAAEkB,GAAG,MAAM,IAAK,kBAAkB,GAAGmnB,GAAG,MAAM,IAAK,UAAU,IAAK,QAAQK,GAAGxiB,EAAElG,EAAEkB,GAAG,IAAI0qB,EAAG,GAAG9I,GAAG9hB,EAAE,CAAC,OAAOD,GAAG,IAAK,mBAAmB,IAAI8qB,EAAG,qBAAqB,MAAM7qB,EAAE,IAAK,iBAAiB6qB,EAAG,mBACpe,MAAM7qB,EAAE,IAAK,oBAAoB6qB,EAAG,sBAAsB,MAAM7qB,EAAE6qB,OAAG,CAAM,MAAMtI,GAAGF,GAAGtiB,EAAEf,KAAK6rB,EAAG,oBAAoB,YAAY9qB,GAAG,MAAMf,EAAEwb,UAAUqQ,EAAG,sBAAsBA,IAAK3I,IAAI,OAAOljB,EAAEkhB,SAASqC,IAAI,uBAAuBsI,EAAG,qBAAqBA,GAAItI,KAAKqI,EAAGtQ,OAAYF,GAAG,UAARD,GAAGja,GAAkBia,GAAG/e,MAAM+e,GAAGrO,YAAYyW,IAAG,IAAiB,GAAZoI,EAAGnH,GAAGvjB,EAAE4qB,IAAS5uB,SAAS4uB,EAAG,IAAItM,GAAGsM,EAAG9qB,EAAE,KAAKf,EAAEkB,GAAGgF,EAAEzG,KAAK,CAACglB,MAAMoH,EAAGnH,UAAUiH,IAAKC,EAAGC,EAAGrM,KAAKoM,EAAa,QAATA,EAAGtI,GAAGtjB,MAAe6rB,EAAGrM,KAAKoM,MAAUA,EAAG3I,GA5BhM,SAAYliB,EAAEC,GAAG,OAAOD,GAAG,IAAK,iBAAiB,OAAOuiB,GAAGtiB,GAAG,IAAK,WAAW,OAAG,KAAKA,EAAEmgB,MAAa,MAAKiC,IAAG,EAAUD,IAAG,IAAK,YAAY,OAAOpiB,EAAEC,EAAEwe,QAAS2D,IAAIC,GAAG,KAAKriB,EAAE,QAAQ,OAAO,KAAK,CA4BE+qB,CAAG/qB,EAAEf,GA3Bzd,SAAYe,EAAEC,GAAG,GAAGuiB,GAAG,MAAM,mBAAmBxiB,IAAI+hB,IAAIO,GAAGtiB,EAAEC,IAAID,EAAEua,KAAKD,GAAGD,GAAGD,GAAG,KAAKoI,IAAG,EAAGxiB,GAAG,KAAK,OAAOA,GAAG,IAAK,QAAgQ,QAAQ,OAAO,KAA3P,IAAK,WAAW,KAAKC,EAAE+c,SAAS/c,EAAEid,QAAQjd,EAAEkd,UAAUld,EAAE+c,SAAS/c,EAAEid,OAAO,CAAC,GAAGjd,EAAE+qB,MAAM,EAAE/qB,EAAE+qB,KAAK9uB,OAAO,OAAO+D,EAAE+qB,KAAK,GAAG/qB,EAAEmgB,MAAM,OAAOL,OAAOC,aAAa/f,EAAEmgB,MAAM,CAAC,OAAO,KAAK,IAAK,iBAAiB,OAAO+B,IAAI,OAAOliB,EAAEkgB,OAAO,KAAKlgB,EAAEwe,KAAyB,CA2BqFwM,CAAGjrB,EAAEf,MACje,GADoeiB,EAAEujB,GAAGvjB,EAAE,kBACvehE,SAASiE,EAAE,IAAIqe,GAAG,gBAAgB,cAAc,KAAKvf,EAAEkB,GAAGgF,EAAEzG,KAAK,CAACglB,MAAMvjB,EAAEwjB,UAAUzjB,IAAIC,EAAEse,KAAKoM,GAAG,CAAC/G,GAAG3e,EAAElF,EAAE,GAAE,CAAC,SAASqqB,GAAGtqB,EAAEC,EAAEhB,GAAG,MAAM,CAACkqB,SAASnpB,EAAEopB,SAASnpB,EAAE+a,cAAc/b,EAAE,CAAC,SAASwkB,GAAGzjB,EAAEC,GAAG,IAAI,IAAIhB,EAAEgB,EAAE,UAAUC,EAAE,GAAG,OAAOF,GAAG,CAAC,IAAIG,EAAEH,EAAEI,EAAED,EAAE4R,UAAU,IAAI5R,EAAE6I,KAAK,OAAO5I,IAAID,EAAEC,EAAY,OAAVA,EAAEmS,GAAGvS,EAAEf,KAAYiB,EAAEgrB,QAAQZ,GAAGtqB,EAAEI,EAAED,IAAc,OAAVC,EAAEmS,GAAGvS,EAAEC,KAAYC,EAAExB,KAAK4rB,GAAGtqB,EAAEI,EAAED,KAAKH,EAAEA,EAAEsT,MAAM,CAAC,OAAOpT,CAAC,CAAC,SAASuqB,GAAGzqB,GAAG,GAAG,OAAOA,EAAE,OAAO,KAAK,GAAGA,EAAEA,EAAEsT,aAAatT,GAAG,IAAIA,EAAEgJ,KAAK,OAAOhJ,GAAI,IAAI,CACnd,SAAS0qB,GAAG1qB,EAAEC,EAAEhB,EAAEiB,EAAEC,GAAG,IAAI,IAAIC,EAAEH,EAAE6a,WAAW3V,EAAE,GAAG,OAAOlG,GAAGA,IAAIiB,GAAG,CAAC,IAAIyI,EAAE1J,EAAE2J,EAAED,EAAE0K,UAAU3K,EAAEC,EAAEoJ,UAAU,GAAG,OAAOnJ,GAAGA,IAAI1I,EAAE,MAAM,IAAIyI,EAAEK,KAAK,OAAON,IAAIC,EAAED,EAAEvI,EAAa,OAAVyI,EAAE2J,GAAGtT,EAAEmB,KAAY+E,EAAE+lB,QAAQZ,GAAGrrB,EAAE2J,EAAED,IAAKxI,GAAc,OAAVyI,EAAE2J,GAAGtT,EAAEmB,KAAY+E,EAAEzG,KAAK4rB,GAAGrrB,EAAE2J,EAAED,KAAM1J,EAAEA,EAAEqU,MAAM,CAAC,IAAInO,EAAEjJ,QAAQ8D,EAAEtB,KAAK,CAACglB,MAAMzjB,EAAE0jB,UAAUxe,GAAG,CAAC,IAAIgmB,GAAG,SAASC,GAAG,iBAAiB,SAASC,GAAGrrB,GAAG,OAAO,kBAAkBA,EAAEA,EAAE,GAAGA,GAAGjD,QAAQouB,GAAG,MAAMpuB,QAAQquB,GAAG,GAAG,CAAC,SAASE,GAAGtrB,EAAEC,EAAEhB,GAAW,GAARgB,EAAEorB,GAAGprB,GAAMorB,GAAGrrB,KAAKC,GAAGhB,EAAE,MAAMX,MAAM4F,EAAE,KAAM,CAAC,SAASqnB,KAAK,CAC9e,IAAIC,GAAG,KAAKC,GAAG,KAAK,SAASC,GAAG1rB,EAAEC,GAAG,MAAM,aAAaD,GAAG,aAAaA,GAAG,kBAAkBC,EAAE0L,UAAU,kBAAkB1L,EAAE0L,UAAU,kBAAkB1L,EAAEyL,yBAAyB,OAAOzL,EAAEyL,yBAAyB,MAAMzL,EAAEyL,wBAAwBigB,MAAM,CAC5P,IAAIC,GAAG,oBAAoBC,WAAWA,gBAAW,EAAOC,GAAG,oBAAoBC,aAAaA,kBAAa,EAAOC,GAAG,oBAAoBC,QAAQA,aAAQ,EAAOC,GAAG,oBAAoBC,eAAeA,eAAe,qBAAqBH,GAAG,SAAShsB,GAAG,OAAOgsB,GAAGI,QAAQ,MAAMC,KAAKrsB,GAAGssB,MAAMC,GAAG,EAAEX,GAAG,SAASW,GAAGvsB,GAAG6rB,YAAW,WAAW,MAAM7rB,CAAE,GAAE,CACpV,SAASwsB,GAAGxsB,EAAEC,GAAG,IAAIhB,EAAEgB,EAAEC,EAAE,EAAE,EAAE,CAAC,IAAIC,EAAElB,EAAEmmB,YAA6B,GAAjBplB,EAAEwM,YAAYvN,GAAMkB,GAAG,IAAIA,EAAE2M,SAAS,GAAY,QAAT7N,EAAEkB,EAAEse,MAAc,CAAC,GAAG,IAAIve,EAA0B,OAAvBF,EAAEwM,YAAYrM,QAAGoZ,GAAGtZ,GAAUC,GAAG,KAAK,MAAMjB,GAAG,OAAOA,GAAG,OAAOA,GAAGiB,IAAIjB,EAAEkB,CAAC,OAAOlB,GAAGsa,GAAGtZ,EAAE,CAAC,SAASwsB,GAAGzsB,GAAG,KAAK,MAAMA,EAAEA,EAAEA,EAAEolB,YAAY,CAAC,IAAInlB,EAAED,EAAE8M,SAAS,GAAG,IAAI7M,GAAG,IAAIA,EAAE,MAAM,GAAG,IAAIA,EAAE,CAAU,GAAG,OAAZA,EAAED,EAAEye,OAAiB,OAAOxe,GAAG,OAAOA,EAAE,MAAM,GAAG,OAAOA,EAAE,OAAO,IAAI,CAAC,CAAC,OAAOD,CAAC,CACjY,SAAS0sB,GAAG1sB,GAAGA,EAAEA,EAAE2sB,gBAAgB,IAAI,IAAI1sB,EAAE,EAAED,GAAG,CAAC,GAAG,IAAIA,EAAE8M,SAAS,CAAC,IAAI7N,EAAEe,EAAEye,KAAK,GAAG,MAAMxf,GAAG,OAAOA,GAAG,OAAOA,EAAE,CAAC,GAAG,IAAIgB,EAAE,OAAOD,EAAEC,GAAG,KAAK,OAAOhB,GAAGgB,GAAG,CAACD,EAAEA,EAAE2sB,eAAe,CAAC,OAAO,IAAI,CAAC,IAAIC,GAAGjX,KAAKgU,SAAS1vB,SAAS,IAAI6E,MAAM,GAAG+tB,GAAG,gBAAgBD,GAAGE,GAAG,gBAAgBF,GAAGrC,GAAG,oBAAoBqC,GAAGtD,GAAG,iBAAiBsD,GAAGG,GAAG,oBAAoBH,GAAGI,GAAG,kBAAkBJ,GAClX,SAAShU,GAAG5Y,GAAG,IAAIC,EAAED,EAAE6sB,IAAI,GAAG5sB,EAAE,OAAOA,EAAE,IAAI,IAAIhB,EAAEe,EAAEyR,WAAWxS,GAAG,CAAC,GAAGgB,EAAEhB,EAAEsrB,KAAKtrB,EAAE4tB,IAAI,CAAe,GAAd5tB,EAAEgB,EAAEoT,UAAa,OAAOpT,EAAE4T,OAAO,OAAO5U,GAAG,OAAOA,EAAE4U,MAAM,IAAI7T,EAAE0sB,GAAG1sB,GAAG,OAAOA,GAAG,CAAC,GAAGf,EAAEe,EAAE6sB,IAAI,OAAO5tB,EAAEe,EAAE0sB,GAAG1sB,EAAE,CAAC,OAAOC,CAAC,CAAKhB,GAAJe,EAAEf,GAAMwS,UAAU,CAAC,OAAO,IAAI,CAAC,SAASK,GAAG9R,GAAkB,QAAfA,EAAEA,EAAE6sB,KAAK7sB,EAAEuqB,MAAc,IAAIvqB,EAAEgJ,KAAK,IAAIhJ,EAAEgJ,KAAK,KAAKhJ,EAAEgJ,KAAK,IAAIhJ,EAAEgJ,IAAI,KAAKhJ,CAAC,CAAC,SAASgkB,GAAGhkB,GAAG,GAAG,IAAIA,EAAEgJ,KAAK,IAAIhJ,EAAEgJ,IAAI,OAAOhJ,EAAE+R,UAAU,MAAMzT,MAAM4F,EAAE,IAAK,CAAC,SAAS8N,GAAGhS,GAAG,OAAOA,EAAE8sB,KAAK,IAAI,CAAC,IAAIG,GAAG,GAAGC,IAAI,EAAE,SAASC,GAAGntB,GAAG,MAAM,CAAC+T,QAAQ/T,EAAE,CACve,SAASotB,GAAEptB,GAAG,EAAEktB,KAAKltB,EAAE+T,QAAQkZ,GAAGC,IAAID,GAAGC,IAAI,KAAKA,KAAK,CAAC,SAASG,GAAErtB,EAAEC,GAAGitB,KAAKD,GAAGC,IAAIltB,EAAE+T,QAAQ/T,EAAE+T,QAAQ9T,CAAC,CAAC,IAAIqtB,GAAG,CAAC,EAAEC,GAAEJ,GAAGG,IAAIE,GAAGL,IAAG,GAAIM,GAAGH,GAAG,SAASI,GAAG1tB,EAAEC,GAAG,IAAIhB,EAAEe,EAAEX,KAAKsuB,aAAa,IAAI1uB,EAAE,OAAOquB,GAAG,IAAIptB,EAAEF,EAAE+R,UAAU,GAAG7R,GAAGA,EAAE0tB,8CAA8C3tB,EAAE,OAAOC,EAAE2tB,0CAA0C,IAASztB,EAALD,EAAE,CAAC,EAAI,IAAIC,KAAKnB,EAAEkB,EAAEC,GAAGH,EAAEG,GAAoH,OAAjHF,KAAIF,EAAEA,EAAE+R,WAAY6b,4CAA4C3tB,EAAED,EAAE6tB,0CAA0C1tB,GAAUA,CAAC,CAC9d,SAAS2tB,GAAG9tB,GAAyB,OAAO,QAA7BA,EAAEA,EAAE+tB,yBAAmC,IAAS/tB,CAAC,CAAC,SAASguB,KAAKZ,GAAEI,IAAIJ,GAAEG,GAAE,CAAC,SAASU,GAAGjuB,EAAEC,EAAEhB,GAAG,GAAGsuB,GAAExZ,UAAUuZ,GAAG,MAAMhvB,MAAM4F,EAAE,MAAMmpB,GAAEE,GAAEttB,GAAGotB,GAAEG,GAAGvuB,EAAE,CAAC,SAASivB,GAAGluB,EAAEC,EAAEhB,GAAG,IAAIiB,EAAEF,EAAE+R,UAAgC,GAAtB9R,EAAEA,EAAE8tB,kBAAqB,oBAAoB7tB,EAAEiuB,gBAAgB,OAAOlvB,EAAwB,IAAI,IAAIkB,KAA9BD,EAAEA,EAAEiuB,kBAAiC,KAAKhuB,KAAKF,GAAG,MAAM3B,MAAM4F,EAAE,IAAIqF,EAAGvJ,IAAI,UAAUG,IAAI,OAAO6H,EAAE,CAAC,EAAE/I,EAAEiB,EAAE,CACxX,SAASkuB,GAAGpuB,GAA2G,OAAxGA,GAAGA,EAAEA,EAAE+R,YAAY/R,EAAEquB,2CAA2Cf,GAAGG,GAAGF,GAAExZ,QAAQsZ,GAAEE,GAAEvtB,GAAGqtB,GAAEG,GAAGA,GAAGzZ,UAAe,CAAE,CAAC,SAASua,GAAGtuB,EAAEC,EAAEhB,GAAG,IAAIiB,EAAEF,EAAE+R,UAAU,IAAI7R,EAAE,MAAM5B,MAAM4F,EAAE,MAAMjF,GAAGe,EAAEkuB,GAAGluB,EAAEC,EAAEwtB,IAAIvtB,EAAEmuB,0CAA0CruB,EAAEotB,GAAEI,IAAIJ,GAAEG,IAAGF,GAAEE,GAAEvtB,IAAIotB,GAAEI,IAAIH,GAAEG,GAAGvuB,EAAE,CAAC,IAAIsvB,GAAG,KAAKC,IAAG,EAAGC,IAAG,EAAG,SAASC,GAAG1uB,GAAG,OAAOuuB,GAAGA,GAAG,CAACvuB,GAAGuuB,GAAG7vB,KAAKsB,EAAE,CAChW,SAAS2uB,KAAK,IAAIF,IAAI,OAAOF,GAAG,CAACE,IAAG,EAAG,IAAIzuB,EAAE,EAAEC,EAAEgX,GAAE,IAAI,IAAIhY,EAAEsvB,GAAG,IAAItX,GAAE,EAAEjX,EAAEf,EAAE/C,OAAO8D,IAAI,CAAC,IAAIE,EAAEjB,EAAEe,GAAG,GAAGE,EAAEA,GAAE,SAAU,OAAOA,EAAE,CAACquB,GAAG,KAAKC,IAAG,CAAE,CAAC,MAAMruB,GAAG,MAAM,OAAOouB,KAAKA,GAAGA,GAAGzvB,MAAMkB,EAAE,IAAIkU,GAAGY,GAAG6Z,IAAIxuB,CAAE,CAAC,QAAQ8W,GAAEhX,EAAEwuB,IAAG,CAAE,CAAC,CAAC,OAAO,IAAI,CAAC,IAAIG,GAAG,GAAGC,GAAG,EAAEC,GAAG,KAAKC,GAAG,EAAEC,GAAG,GAAGC,GAAG,EAAEC,GAAG,KAAKC,GAAG,EAAEC,GAAG,GAAG,SAASC,GAAGrvB,EAAEC,GAAG2uB,GAAGC,MAAME,GAAGH,GAAGC,MAAMC,GAAGA,GAAG9uB,EAAE+uB,GAAG9uB,CAAC,CACjV,SAASqvB,GAAGtvB,EAAEC,EAAEhB,GAAG+vB,GAAGC,MAAME,GAAGH,GAAGC,MAAMG,GAAGJ,GAAGC,MAAMC,GAAGA,GAAGlvB,EAAE,IAAIE,EAAEivB,GAAGnvB,EAAEovB,GAAG,IAAIjvB,EAAE,GAAGuV,GAAGxV,GAAG,EAAEA,KAAK,GAAGC,GAAGlB,GAAG,EAAE,IAAImB,EAAE,GAAGsV,GAAGzV,GAAGE,EAAE,GAAG,GAAGC,EAAE,CAAC,IAAI+E,EAAEhF,EAAEA,EAAE,EAAEC,GAAGF,GAAG,GAAGiF,GAAG,GAAGlL,SAAS,IAAIiG,IAAIiF,EAAEhF,GAAGgF,EAAEgqB,GAAG,GAAG,GAAGzZ,GAAGzV,GAAGE,EAAElB,GAAGkB,EAAED,EAAEkvB,GAAGhvB,EAAEJ,CAAC,MAAMmvB,GAAG,GAAG/uB,EAAEnB,GAAGkB,EAAED,EAAEkvB,GAAGpvB,CAAC,CAAC,SAASuvB,GAAGvvB,GAAG,OAAOA,EAAEsT,SAAS+b,GAAGrvB,EAAE,GAAGsvB,GAAGtvB,EAAE,EAAE,GAAG,CAAC,SAASwvB,GAAGxvB,GAAG,KAAKA,IAAI8uB,IAAIA,GAAGF,KAAKC,IAAID,GAAGC,IAAI,KAAKE,GAAGH,KAAKC,IAAID,GAAGC,IAAI,KAAK,KAAK7uB,IAAIkvB,IAAIA,GAAGF,KAAKC,IAAID,GAAGC,IAAI,KAAKG,GAAGJ,KAAKC,IAAID,GAAGC,IAAI,KAAKE,GAAGH,KAAKC,IAAID,GAAGC,IAAI,IAAI,CAAC,IAAIQ,GAAG,KAAKC,GAAG,KAAKC,IAAE,EAAGC,GAAG,KACje,SAASC,GAAG7vB,EAAEC,GAAG,IAAIhB,EAAE6wB,GAAG,EAAE,KAAK,KAAK,GAAG7wB,EAAEsE,YAAY,UAAUtE,EAAE8S,UAAU9R,EAAEhB,EAAEqU,OAAOtT,EAAgB,QAAdC,EAAED,EAAE+vB,YAAoB/vB,EAAE+vB,UAAU,CAAC9wB,GAAGe,EAAEuT,OAAO,IAAItT,EAAEvB,KAAKO,EAAE,CACxJ,SAAS+wB,GAAGhwB,EAAEC,GAAG,OAAOD,EAAEgJ,KAAK,KAAK,EAAE,IAAI/J,EAAEe,EAAEX,KAAyE,OAAO,QAA3EY,EAAE,IAAIA,EAAE6M,UAAU7N,EAAE4G,gBAAgB5F,EAAEyJ,SAAS7D,cAAc,KAAK5F,KAAmBD,EAAE+R,UAAU9R,EAAEwvB,GAAGzvB,EAAE0vB,GAAGjD,GAAGxsB,EAAEsM,aAAY,GAAO,KAAK,EAAE,OAAoD,QAA7CtM,EAAE,KAAKD,EAAEiwB,cAAc,IAAIhwB,EAAE6M,SAAS,KAAK7M,KAAYD,EAAE+R,UAAU9R,EAAEwvB,GAAGzvB,EAAE0vB,GAAG,MAAK,GAAO,KAAK,GAAG,OAA+B,QAAxBzvB,EAAE,IAAIA,EAAE6M,SAAS,KAAK7M,KAAYhB,EAAE,OAAOiwB,GAAG,CAAClV,GAAGmV,GAAGe,SAASd,IAAI,KAAKpvB,EAAEyT,cAAc,CAACC,WAAWzT,EAAEkwB,YAAYlxB,EAAEmxB,UAAU,aAAYnxB,EAAE6wB,GAAG,GAAG,KAAK,KAAK,IAAK/d,UAAU9R,EAAEhB,EAAEqU,OAAOtT,EAAEA,EAAE6T,MAAM5U,EAAEwwB,GAAGzvB,EAAE0vB,GAClf,MAAK,GAAO,QAAQ,OAAM,EAAG,CAAC,SAASW,GAAGrwB,GAAG,OAAO,KAAY,EAAPA,EAAEswB,OAAS,KAAa,IAARtwB,EAAEuT,MAAU,CAAC,SAASgd,GAAGvwB,GAAG,GAAG2vB,GAAE,CAAC,IAAI1vB,EAAEyvB,GAAG,GAAGzvB,EAAE,CAAC,IAAIhB,EAAEgB,EAAE,IAAI+vB,GAAGhwB,EAAEC,GAAG,CAAC,GAAGowB,GAAGrwB,GAAG,MAAM1B,MAAM4F,EAAE,MAAMjE,EAAEwsB,GAAGxtB,EAAEmmB,aAAa,IAAIllB,EAAEuvB,GAAGxvB,GAAG+vB,GAAGhwB,EAAEC,GAAG4vB,GAAG3vB,EAAEjB,IAAIe,EAAEuT,OAAe,KAATvT,EAAEuT,MAAY,EAAEoc,IAAE,EAAGF,GAAGzvB,EAAE,CAAC,KAAK,CAAC,GAAGqwB,GAAGrwB,GAAG,MAAM1B,MAAM4F,EAAE,MAAMlE,EAAEuT,OAAe,KAATvT,EAAEuT,MAAY,EAAEoc,IAAE,EAAGF,GAAGzvB,CAAC,CAAC,CAAC,CAAC,SAASwwB,GAAGxwB,GAAG,IAAIA,EAAEA,EAAEsT,OAAO,OAAOtT,GAAG,IAAIA,EAAEgJ,KAAK,IAAIhJ,EAAEgJ,KAAK,KAAKhJ,EAAEgJ,KAAKhJ,EAAEA,EAAEsT,OAAOmc,GAAGzvB,CAAC,CACha,SAASywB,GAAGzwB,GAAG,GAAGA,IAAIyvB,GAAG,OAAM,EAAG,IAAIE,GAAE,OAAOa,GAAGxwB,GAAG2vB,IAAE,GAAG,EAAG,IAAI1vB,EAAkG,IAA/FA,EAAE,IAAID,EAAEgJ,QAAQ/I,EAAE,IAAID,EAAEgJ,OAAgB/I,EAAE,UAAXA,EAAED,EAAEX,OAAmB,SAASY,IAAIyrB,GAAG1rB,EAAEX,KAAKW,EAAE0wB,gBAAmBzwB,IAAIA,EAAEyvB,IAAI,CAAC,GAAGW,GAAGrwB,GAAG,MAAM2wB,KAAKryB,MAAM4F,EAAE,MAAM,KAAKjE,GAAG4vB,GAAG7vB,EAAEC,GAAGA,EAAEwsB,GAAGxsB,EAAEmlB,YAAY,CAAO,GAANoL,GAAGxwB,GAAM,KAAKA,EAAEgJ,IAAI,CAAgD,KAA7BhJ,EAAE,QAApBA,EAAEA,EAAEyT,eAAyBzT,EAAE0T,WAAW,MAAW,MAAMpV,MAAM4F,EAAE,MAAMlE,EAAE,CAAiB,IAAhBA,EAAEA,EAAEolB,YAAgBnlB,EAAE,EAAED,GAAG,CAAC,GAAG,IAAIA,EAAE8M,SAAS,CAAC,IAAI7N,EAAEe,EAAEye,KAAK,GAAG,OAAOxf,EAAE,CAAC,GAAG,IAAIgB,EAAE,CAACyvB,GAAGjD,GAAGzsB,EAAEolB,aAAa,MAAMplB,CAAC,CAACC,GAAG,KAAK,MAAMhB,GAAG,OAAOA,GAAG,OAAOA,GAAGgB,GAAG,CAACD,EAAEA,EAAEolB,WAAW,CAACsK,GACjgB,IAAI,CAAC,MAAMA,GAAGD,GAAGhD,GAAGzsB,EAAE+R,UAAUqT,aAAa,KAAK,OAAM,CAAE,CAAC,SAASuL,KAAK,IAAI,IAAI3wB,EAAE0vB,GAAG1vB,GAAGA,EAAEysB,GAAGzsB,EAAEolB,YAAY,CAAC,SAASwL,KAAKlB,GAAGD,GAAG,KAAKE,IAAE,CAAE,CAAC,SAASkB,GAAG7wB,GAAG,OAAO4vB,GAAGA,GAAG,CAAC5vB,GAAG4vB,GAAGlxB,KAAKsB,EAAE,CAAC,IAAI8wB,GAAGnqB,EAAG8S,wBAChM,SAASsX,GAAG/wB,EAAEC,EAAEhB,GAAW,GAAG,QAAXe,EAAEf,EAAE+xB,MAAiB,oBAAoBhxB,GAAG,kBAAkBA,EAAE,CAAC,GAAGf,EAAEgyB,OAAO,CAAY,GAAXhyB,EAAEA,EAAEgyB,OAAY,CAAC,GAAG,IAAIhyB,EAAE+J,IAAI,MAAM1K,MAAM4F,EAAE,MAAM,IAAIhE,EAAEjB,EAAE8S,SAAS,CAAC,IAAI7R,EAAE,MAAM5B,MAAM4F,EAAE,IAAIlE,IAAI,IAAIG,EAAED,EAAEE,EAAE,GAAGJ,EAAE,OAAG,OAAOC,GAAG,OAAOA,EAAE+wB,KAAK,oBAAoB/wB,EAAE+wB,KAAK/wB,EAAE+wB,IAAIE,aAAa9wB,EAASH,EAAE+wB,KAAI/wB,EAAE,SAASD,GAAG,IAAIC,EAAEE,EAAEgxB,KAAK,OAAOnxB,SAASC,EAAEG,GAAGH,EAAEG,GAAGJ,CAAC,EAAEC,EAAEixB,WAAW9wB,EAASH,EAAC,CAAC,GAAG,kBAAkBD,EAAE,MAAM1B,MAAM4F,EAAE,MAAM,IAAIjF,EAAEgyB,OAAO,MAAM3yB,MAAM4F,EAAE,IAAIlE,GAAI,CAAC,OAAOA,CAAC,CAC/c,SAASoxB,GAAGpxB,EAAEC,GAAuC,MAApCD,EAAEnG,OAAOC,UAAUG,SAASO,KAAKyF,GAAS3B,MAAM4F,EAAE,GAAG,oBAAoBlE,EAAE,qBAAqBnG,OAAOmW,KAAK/P,GAAGoxB,KAAK,MAAM,IAAIrxB,GAAI,CAAC,SAASsxB,GAAGtxB,GAAiB,OAAOC,EAAfD,EAAEsJ,OAAetJ,EAAEqJ,SAAS,CACrM,SAASkoB,GAAGvxB,GAAG,SAASC,EAAEA,EAAEhB,GAAG,GAAGe,EAAE,CAAC,IAAIE,EAAED,EAAE8vB,UAAU,OAAO7vB,GAAGD,EAAE8vB,UAAU,CAAC9wB,GAAGgB,EAAEsT,OAAO,IAAIrT,EAAExB,KAAKO,EAAE,CAAC,CAAC,SAASA,EAAEA,EAAEiB,GAAG,IAAIF,EAAE,OAAO,KAAK,KAAK,OAAOE,GAAGD,EAAEhB,EAAEiB,GAAGA,EAAEA,EAAE4T,QAAQ,OAAO,IAAI,CAAC,SAAS5T,EAAEF,EAAEC,GAAG,IAAID,EAAE,IAAI8X,IAAI,OAAO7X,GAAG,OAAOA,EAAEtF,IAAIqF,EAAEuI,IAAItI,EAAEtF,IAAIsF,GAAGD,EAAEuI,IAAItI,EAAEuxB,MAAMvxB,GAAGA,EAAEA,EAAE6T,QAAQ,OAAO9T,CAAC,CAAC,SAASG,EAAEH,EAAEC,GAAsC,OAAnCD,EAAEyxB,GAAGzxB,EAAEC,IAAKuxB,MAAM,EAAExxB,EAAE8T,QAAQ,KAAY9T,CAAC,CAAC,SAASI,EAAEH,EAAEhB,EAAEiB,GAAa,OAAVD,EAAEuxB,MAAMtxB,EAAMF,EAA6C,QAAjBE,EAAED,EAAEoT,YAA6BnT,EAAEA,EAAEsxB,OAAQvyB,GAAGgB,EAAEsT,OAAO,EAAEtU,GAAGiB,GAAED,EAAEsT,OAAO,EAAStU,IAArGgB,EAAEsT,OAAO,QAAQtU,EAAqF,CAAC,SAASkG,EAAElF,GACzd,OAD4dD,GAC7f,OAAOC,EAAEoT,YAAYpT,EAAEsT,OAAO,GAAUtT,CAAC,CAAC,SAAS0I,EAAE3I,EAAEC,EAAEhB,EAAEiB,GAAG,OAAG,OAAOD,GAAG,IAAIA,EAAE+I,MAAW/I,EAAEyxB,GAAGzyB,EAAEe,EAAEswB,KAAKpwB,IAAKoT,OAAOtT,EAAEC,KAAEA,EAAEE,EAAEF,EAAEhB,IAAKqU,OAAOtT,EAASC,EAAC,CAAC,SAAS2I,EAAE5I,EAAEC,EAAEhB,EAAEiB,GAAG,IAAIE,EAAEnB,EAAEI,KAAK,OAAGe,IAAI6G,EAAUrI,EAAEoB,EAAEC,EAAEhB,EAAEyC,MAAMiK,SAASzL,EAAEjB,EAAEtE,KAAQ,OAAOsF,IAAIA,EAAEsD,cAAcnD,GAAG,kBAAkBA,GAAG,OAAOA,GAAGA,EAAE+I,WAAWzB,GAAI4pB,GAAGlxB,KAAKH,EAAEZ,QAAaa,EAAEC,EAAEF,EAAEhB,EAAEyC,QAASsvB,IAAID,GAAG/wB,EAAEC,EAAEhB,GAAGiB,EAAEoT,OAAOtT,EAAEE,KAAEA,EAAEyxB,GAAG1yB,EAAEI,KAAKJ,EAAEtE,IAAIsE,EAAEyC,MAAM,KAAK1B,EAAEswB,KAAKpwB,IAAK8wB,IAAID,GAAG/wB,EAAEC,EAAEhB,GAAGiB,EAAEoT,OAAOtT,EAASE,EAAC,CAAC,SAASwI,EAAE1I,EAAEC,EAAEhB,EAAEiB,GAAG,OAAG,OAAOD,GAAG,IAAIA,EAAE+I,KACjf/I,EAAE8R,UAAUgH,gBAAgB9Z,EAAE8Z,eAAe9Y,EAAE8R,UAAU6f,iBAAiB3yB,EAAE2yB,iBAAsB3xB,EAAE4xB,GAAG5yB,EAAEe,EAAEswB,KAAKpwB,IAAKoT,OAAOtT,EAAEC,KAAEA,EAAEE,EAAEF,EAAEhB,EAAE0M,UAAU,KAAM2H,OAAOtT,EAASC,EAAC,CAAC,SAASrB,EAAEoB,EAAEC,EAAEhB,EAAEiB,EAAEE,GAAG,OAAG,OAAOH,GAAG,IAAIA,EAAE+I,MAAW/I,EAAE6xB,GAAG7yB,EAAEe,EAAEswB,KAAKpwB,EAAEE,IAAKkT,OAAOtT,EAAEC,KAAEA,EAAEE,EAAEF,EAAEhB,IAAKqU,OAAOtT,EAASC,EAAC,CAAC,SAAS8xB,EAAE/xB,EAAEC,EAAEhB,GAAG,GAAG,kBAAkBgB,GAAG,KAAKA,GAAG,kBAAkBA,EAAE,OAAOA,EAAEyxB,GAAG,GAAGzxB,EAAED,EAAEswB,KAAKrxB,IAAKqU,OAAOtT,EAAEC,EAAE,GAAG,kBAAkBA,GAAG,OAAOA,EAAE,CAAC,OAAOA,EAAEkJ,UAAU,KAAKtC,EAAG,OAAO5H,EAAE0yB,GAAG1xB,EAAEZ,KAAKY,EAAEtF,IAAIsF,EAAEyB,MAAM,KAAK1B,EAAEswB,KAAKrxB,IACjf+xB,IAAID,GAAG/wB,EAAE,KAAKC,GAAGhB,EAAEqU,OAAOtT,EAAEf,EAAE,KAAK+H,EAAG,OAAO/G,EAAE4xB,GAAG5xB,EAAED,EAAEswB,KAAKrxB,IAAKqU,OAAOtT,EAAEC,EAAE,KAAKyH,EAAiB,OAAOqqB,EAAE/xB,GAAEE,EAAnBD,EAAEqJ,OAAmBrJ,EAAEoJ,UAAUpK,GAAG,GAAGmM,GAAGnL,IAAI6H,EAAG7H,GAAG,OAAOA,EAAE6xB,GAAG7xB,EAAED,EAAEswB,KAAKrxB,EAAE,OAAQqU,OAAOtT,EAAEC,EAAEmxB,GAAGpxB,EAAEC,EAAE,CAAC,OAAO,IAAI,CAAC,SAAS+xB,EAAEhyB,EAAEC,EAAEhB,EAAEiB,GAAG,IAAIC,EAAE,OAAOF,EAAEA,EAAEtF,IAAI,KAAK,GAAG,kBAAkBsE,GAAG,KAAKA,GAAG,kBAAkBA,EAAE,OAAO,OAAOkB,EAAE,KAAKwI,EAAE3I,EAAEC,EAAE,GAAGhB,EAAEiB,GAAG,GAAG,kBAAkBjB,GAAG,OAAOA,EAAE,CAAC,OAAOA,EAAEkK,UAAU,KAAKtC,EAAG,OAAO5H,EAAEtE,MAAMwF,EAAEyI,EAAE5I,EAAEC,EAAEhB,EAAEiB,GAAG,KAAK,KAAK8G,EAAG,OAAO/H,EAAEtE,MAAMwF,EAAEuI,EAAE1I,EAAEC,EAAEhB,EAAEiB,GAAG,KAAK,KAAKwH,EAAG,OAAiBsqB,EAAEhyB,EACpfC,GADweE,EAAElB,EAAEqK,OACxerK,EAAEoK,UAAUnJ,GAAG,GAAGkL,GAAGnM,IAAI6I,EAAG7I,GAAG,OAAO,OAAOkB,EAAE,KAAKvB,EAAEoB,EAAEC,EAAEhB,EAAEiB,EAAE,MAAMkxB,GAAGpxB,EAAEf,EAAE,CAAC,OAAO,IAAI,CAAC,SAASgzB,EAAEjyB,EAAEC,EAAEhB,EAAEiB,EAAEC,GAAG,GAAG,kBAAkBD,GAAG,KAAKA,GAAG,kBAAkBA,EAAE,OAAwByI,EAAE1I,EAAnBD,EAAEA,EAAE6J,IAAI5K,IAAI,KAAW,GAAGiB,EAAEC,GAAG,GAAG,kBAAkBD,GAAG,OAAOA,EAAE,CAAC,OAAOA,EAAEiJ,UAAU,KAAKtC,EAAG,OAA2C+B,EAAE3I,EAAtCD,EAAEA,EAAE6J,IAAI,OAAO3J,EAAEvF,IAAIsE,EAAEiB,EAAEvF,MAAM,KAAWuF,EAAEC,GAAG,KAAK6G,EAAG,OAA2C0B,EAAEzI,EAAtCD,EAAEA,EAAE6J,IAAI,OAAO3J,EAAEvF,IAAIsE,EAAEiB,EAAEvF,MAAM,KAAWuF,EAAEC,GAAG,KAAKuH,EAAiB,OAAOuqB,EAAEjyB,EAAEC,EAAEhB,GAAEmB,EAAvBF,EAAEoJ,OAAuBpJ,EAAEmJ,UAAUlJ,GAAG,GAAGiL,GAAGlL,IAAI4H,EAAG5H,GAAG,OAAwBtB,EAAEqB,EAAnBD,EAAEA,EAAE6J,IAAI5K,IAAI,KAAWiB,EAAEC,EAAE,MAAMixB,GAAGnxB,EAAEC,EAAE,CAAC,OAAO,IAAI,CAC9f,SAAS6pB,EAAE5pB,EAAEgF,EAAEwD,EAAEC,GAAG,IAAI,IAAIF,EAAE,KAAK9J,EAAE,KAAKurB,EAAEhlB,EAAEilB,EAAEjlB,EAAE,EAAE+kB,EAAE,KAAK,OAAOC,GAAGC,EAAEzhB,EAAEzM,OAAOkuB,IAAI,CAACD,EAAEqH,MAAMpH,GAAGF,EAAEC,EAAEA,EAAE,MAAMD,EAAEC,EAAErW,QAAQ,IAAIiW,EAAEiI,EAAE7xB,EAAEgqB,EAAExhB,EAAEyhB,GAAGxhB,GAAG,GAAG,OAAOmhB,EAAE,CAAC,OAAOI,IAAIA,EAAED,GAAG,KAAK,CAAClqB,GAAGmqB,GAAG,OAAOJ,EAAE1W,WAAWpT,EAAEE,EAAEgqB,GAAGhlB,EAAE/E,EAAE2pB,EAAE5kB,EAAEilB,GAAG,OAAOxrB,EAAE8J,EAAEqhB,EAAEnrB,EAAEkV,QAAQiW,EAAEnrB,EAAEmrB,EAAEI,EAAED,CAAC,CAAC,GAAGE,IAAIzhB,EAAEzM,OAAO,OAAO+C,EAAEkB,EAAEgqB,GAAGwF,IAAGN,GAAGlvB,EAAEiqB,GAAG1hB,EAAE,GAAG,OAAOyhB,EAAE,CAAC,KAAKC,EAAEzhB,EAAEzM,OAAOkuB,IAAkB,QAAdD,EAAE4H,EAAE5xB,EAAEwI,EAAEyhB,GAAGxhB,MAAczD,EAAE/E,EAAE+pB,EAAEhlB,EAAEilB,GAAG,OAAOxrB,EAAE8J,EAAEyhB,EAAEvrB,EAAEkV,QAAQqW,EAAEvrB,EAAEurB,GAAc,OAAXwF,IAAGN,GAAGlvB,EAAEiqB,GAAU1hB,CAAC,CAAC,IAAIyhB,EAAEjqB,EAAEC,EAAEgqB,GAAGC,EAAEzhB,EAAEzM,OAAOkuB,IAAsB,QAAlBF,EAAE+H,EAAE9H,EAAEhqB,EAAEiqB,EAAEzhB,EAAEyhB,GAAGxhB,MAAc5I,GAAG,OAAOkqB,EAAE7W,WAAW8W,EAAEhS,OAAO,OACvf+R,EAAEvvB,IAAIyvB,EAAEF,EAAEvvB,KAAKwK,EAAE/E,EAAE8pB,EAAE/kB,EAAEilB,GAAG,OAAOxrB,EAAE8J,EAAEwhB,EAAEtrB,EAAEkV,QAAQoW,EAAEtrB,EAAEsrB,GAAuD,OAApDlqB,GAAGmqB,EAAEnpB,SAAQ,SAAShB,GAAG,OAAOC,EAAEE,EAAEH,EAAE,IAAG2vB,IAAGN,GAAGlvB,EAAEiqB,GAAU1hB,CAAC,CAAC,SAASshB,EAAE7pB,EAAEgF,EAAEwD,EAAEC,GAAG,IAAIF,EAAEZ,EAAGa,GAAG,GAAG,oBAAoBD,EAAE,MAAMpK,MAAM4F,EAAE,MAAkB,GAAG,OAAfyE,EAAED,EAAElO,KAAKmO,IAAc,MAAMrK,MAAM4F,EAAE,MAAM,IAAI,IAAIimB,EAAEzhB,EAAE,KAAK9J,EAAEuG,EAAEilB,EAAEjlB,EAAE,EAAE+kB,EAAE,KAAKH,EAAEphB,EAAEupB,OAAO,OAAOtzB,IAAImrB,EAAEoI,KAAK/H,IAAIL,EAAEphB,EAAEupB,OAAO,CAACtzB,EAAE4yB,MAAMpH,GAAGF,EAAEtrB,EAAEA,EAAE,MAAMsrB,EAAEtrB,EAAEkV,QAAQ,IAAIkW,EAAEgI,EAAE7xB,EAAEvB,EAAEmrB,EAAE1uB,MAAMuN,GAAG,GAAG,OAAOohB,EAAE,CAAC,OAAOprB,IAAIA,EAAEsrB,GAAG,KAAK,CAAClqB,GAAGpB,GAAG,OAAOorB,EAAE3W,WAAWpT,EAAEE,EAAEvB,GAAGuG,EAAE/E,EAAE4pB,EAAE7kB,EAAEilB,GAAG,OAAOD,EAAEzhB,EAAEshB,EAAEG,EAAErW,QAAQkW,EAAEG,EAAEH,EAAEprB,EAAEsrB,CAAC,CAAC,GAAGH,EAAEoI,KAAK,OAAOlzB,EAAEkB,EACzfvB,GAAG+wB,IAAGN,GAAGlvB,EAAEiqB,GAAG1hB,EAAE,GAAG,OAAO9J,EAAE,CAAC,MAAMmrB,EAAEoI,KAAK/H,IAAIL,EAAEphB,EAAEupB,OAAwB,QAAjBnI,EAAEgI,EAAE5xB,EAAE4pB,EAAE1uB,MAAMuN,MAAczD,EAAE/E,EAAE2pB,EAAE5kB,EAAEilB,GAAG,OAAOD,EAAEzhB,EAAEqhB,EAAEI,EAAErW,QAAQiW,EAAEI,EAAEJ,GAAc,OAAX4F,IAAGN,GAAGlvB,EAAEiqB,GAAU1hB,CAAC,CAAC,IAAI9J,EAAEsB,EAAEC,EAAEvB,IAAImrB,EAAEoI,KAAK/H,IAAIL,EAAEphB,EAAEupB,OAA4B,QAArBnI,EAAEkI,EAAErzB,EAAEuB,EAAEiqB,EAAEL,EAAE1uB,MAAMuN,MAAc5I,GAAG,OAAO+pB,EAAE1W,WAAWzU,EAAEuZ,OAAO,OAAO4R,EAAEpvB,IAAIyvB,EAAEL,EAAEpvB,KAAKwK,EAAE/E,EAAE2pB,EAAE5kB,EAAEilB,GAAG,OAAOD,EAAEzhB,EAAEqhB,EAAEI,EAAErW,QAAQiW,EAAEI,EAAEJ,GAAuD,OAApD/pB,GAAGpB,EAAEoC,SAAQ,SAAShB,GAAG,OAAOC,EAAEE,EAAEH,EAAE,IAAG2vB,IAAGN,GAAGlvB,EAAEiqB,GAAU1hB,CAAC,CAG3T,OAH4T,SAASuhB,EAAEjqB,EAAEE,EAAEE,EAAEuI,GAAkF,GAA/E,kBAAkBvI,GAAG,OAAOA,GAAGA,EAAEf,OAAO4H,GAAI,OAAO7G,EAAEzF,MAAMyF,EAAEA,EAAEsB,MAAMiK,UAAa,kBAAkBvL,GAAG,OAAOA,EAAE,CAAC,OAAOA,EAAE+I,UAAU,KAAKtC,EAAG7G,EAAE,CAAC,IAAI,IAAI4I,EAC7hBxI,EAAEzF,IAAI+N,EAAExI,EAAE,OAAOwI,GAAG,CAAC,GAAGA,EAAE/N,MAAMiO,EAAE,CAAU,IAATA,EAAExI,EAAEf,QAAY4H,GAAI,GAAG,IAAIyB,EAAEM,IAAI,CAAC/J,EAAEe,EAAE0I,EAAEoL,UAAS5T,EAAEC,EAAEuI,EAAEtI,EAAEsB,MAAMiK,WAAY2H,OAAOtT,EAAEA,EAAEE,EAAE,MAAMF,CAAC,OAAO,GAAG0I,EAAEnF,cAAcqF,GAAG,kBAAkBA,GAAG,OAAOA,GAAGA,EAAEO,WAAWzB,GAAI4pB,GAAG1oB,KAAKF,EAAErJ,KAAK,CAACJ,EAAEe,EAAE0I,EAAEoL,UAAS5T,EAAEC,EAAEuI,EAAEtI,EAAEsB,QAASsvB,IAAID,GAAG/wB,EAAE0I,EAAEtI,GAAGF,EAAEoT,OAAOtT,EAAEA,EAAEE,EAAE,MAAMF,CAAC,CAACf,EAAEe,EAAE0I,GAAG,KAAK,CAAMzI,EAAED,EAAE0I,GAAGA,EAAEA,EAAEoL,OAAO,CAAC1T,EAAEf,OAAO4H,IAAI/G,EAAE4xB,GAAG1xB,EAAEsB,MAAMiK,SAAS3L,EAAEswB,KAAK3nB,EAAEvI,EAAEzF,MAAO2Y,OAAOtT,EAAEA,EAAEE,KAAIyI,EAAEgpB,GAAGvxB,EAAEf,KAAKe,EAAEzF,IAAIyF,EAAEsB,MAAM,KAAK1B,EAAEswB,KAAK3nB,IAAKqoB,IAAID,GAAG/wB,EAAEE,EAAEE,GAAGuI,EAAE2K,OAAOtT,EAAEA,EAAE2I,EAAE,CAAC,OAAOxD,EAAEnF,GAAG,KAAKgH,EAAGhH,EAAE,CAAC,IAAI0I,EAAEtI,EAAEzF,IAAI,OACzfuF,GAAG,CAAC,GAAGA,EAAEvF,MAAM+N,EAAC,CAAC,GAAG,IAAIxI,EAAE8I,KAAK9I,EAAE6R,UAAUgH,gBAAgB3Y,EAAE2Y,eAAe7Y,EAAE6R,UAAU6f,iBAAiBxxB,EAAEwxB,eAAe,CAAC3yB,EAAEe,EAAEE,EAAE4T,UAAS5T,EAAEC,EAAED,EAAEE,EAAEuL,UAAU,KAAM2H,OAAOtT,EAAEA,EAAEE,EAAE,MAAMF,CAAC,CAAMf,EAAEe,EAAEE,GAAG,KAAM,CAAKD,EAAED,EAAEE,GAAGA,EAAEA,EAAE4T,OAAO,EAAC5T,EAAE2xB,GAAGzxB,EAAEJ,EAAEswB,KAAK3nB,IAAK2K,OAAOtT,EAAEA,EAAEE,CAAC,CAAC,OAAOiF,EAAEnF,GAAG,KAAK0H,EAAG,OAAiBuiB,EAAEjqB,EAAEE,GAAdwI,EAAEtI,EAAEkJ,OAAclJ,EAAEiJ,UAAUV,GAAG,GAAGyC,GAAGhL,GAAG,OAAO2pB,EAAE/pB,EAAEE,EAAEE,EAAEuI,GAAG,GAAGb,EAAG1H,GAAG,OAAO4pB,EAAEhqB,EAAEE,EAAEE,EAAEuI,GAAGyoB,GAAGpxB,EAAEI,EAAE,CAAC,MAAM,kBAAkBA,GAAG,KAAKA,GAAG,kBAAkBA,GAAGA,EAAE,GAAGA,EAAE,OAAOF,GAAG,IAAIA,EAAE8I,KAAK/J,EAAEe,EAAEE,EAAE4T,UAAS5T,EAAEC,EAAED,EAAEE,IAAKkT,OAAOtT,EAAEA,EAAEE,IACnfjB,EAAEe,EAAEE,IAAGA,EAAEwxB,GAAGtxB,EAAEJ,EAAEswB,KAAK3nB,IAAK2K,OAAOtT,EAAEA,EAAEE,GAAGiF,EAAEnF,IAAIf,EAAEe,EAAEE,EAAE,CAAS,CAAC,IAAIkyB,GAAGb,IAAG,GAAIc,GAAGd,IAAG,GAAIe,GAAGnF,GAAG,MAAMoF,GAAG,KAAKC,GAAG,KAAKC,GAAG,KAAK,SAASC,KAAKD,GAAGD,GAAGD,GAAG,IAAI,CAAC,SAASI,GAAG3yB,GAAG,IAAIC,EAAEqyB,GAAGve,QAAQqZ,GAAEkF,IAAItyB,EAAE4yB,cAAc3yB,CAAC,CAAC,SAAS4yB,GAAG7yB,EAAEC,EAAEhB,GAAG,KAAK,OAAOe,GAAG,CAAC,IAAIE,EAAEF,EAAEqT,UAA+H,IAApHrT,EAAE8yB,WAAW7yB,KAAKA,GAAGD,EAAE8yB,YAAY7yB,EAAE,OAAOC,IAAIA,EAAE4yB,YAAY7yB,IAAI,OAAOC,IAAIA,EAAE4yB,WAAW7yB,KAAKA,IAAIC,EAAE4yB,YAAY7yB,GAAMD,IAAIf,EAAE,MAAMe,EAAEA,EAAEsT,MAAM,CAAC,CACnZ,SAASyf,GAAG/yB,EAAEC,GAAGsyB,GAAGvyB,EAAEyyB,GAAGD,GAAG,KAAsB,QAAjBxyB,EAAEA,EAAEgzB,eAAuB,OAAOhzB,EAAEizB,eAAe,KAAKjzB,EAAEkzB,MAAMjzB,KAAKkzB,IAAG,GAAInzB,EAAEizB,aAAa,KAAK,CAAC,SAASG,GAAGpzB,GAAG,IAAIC,EAAED,EAAE4yB,cAAc,GAAGH,KAAKzyB,EAAE,GAAGA,EAAE,CAACqzB,QAAQrzB,EAAEszB,cAAcrzB,EAAEiyB,KAAK,MAAM,OAAOM,GAAG,CAAC,GAAG,OAAOD,GAAG,MAAMj0B,MAAM4F,EAAE,MAAMsuB,GAAGxyB,EAAEuyB,GAAGS,aAAa,CAACE,MAAM,EAAED,aAAajzB,EAAE,MAAMwyB,GAAGA,GAAGN,KAAKlyB,EAAE,OAAOC,CAAC,CAAC,IAAIszB,GAAG,KAAK,SAASC,GAAGxzB,GAAG,OAAOuzB,GAAGA,GAAG,CAACvzB,GAAGuzB,GAAG70B,KAAKsB,EAAE,CACvY,SAASyzB,GAAGzzB,EAAEC,EAAEhB,EAAEiB,GAAG,IAAIC,EAAEF,EAAEyzB,YAA+E,OAAnE,OAAOvzB,GAAGlB,EAAEizB,KAAKjzB,EAAEu0B,GAAGvzB,KAAKhB,EAAEizB,KAAK/xB,EAAE+xB,KAAK/xB,EAAE+xB,KAAKjzB,GAAGgB,EAAEyzB,YAAYz0B,EAAS00B,GAAG3zB,EAAEE,EAAE,CAAC,SAASyzB,GAAG3zB,EAAEC,GAAGD,EAAEkzB,OAAOjzB,EAAE,IAAIhB,EAAEe,EAAEqT,UAAqC,IAA3B,OAAOpU,IAAIA,EAAEi0B,OAAOjzB,GAAGhB,EAAEe,EAAMA,EAAEA,EAAEsT,OAAO,OAAOtT,GAAGA,EAAE8yB,YAAY7yB,EAAgB,QAAdhB,EAAEe,EAAEqT,aAAqBpU,EAAE6zB,YAAY7yB,GAAGhB,EAAEe,EAAEA,EAAEA,EAAEsT,OAAO,OAAO,IAAIrU,EAAE+J,IAAI/J,EAAE8S,UAAU,IAAI,CAAC,IAAI6hB,IAAG,EAAG,SAASC,GAAG7zB,GAAGA,EAAE8zB,YAAY,CAACC,UAAU/zB,EAAEyT,cAAcugB,gBAAgB,KAAKC,eAAe,KAAKC,OAAO,CAACC,QAAQ,KAAKT,YAAY,KAAKR,MAAM,GAAGkB,QAAQ,KAAK,CAC/e,SAASC,GAAGr0B,EAAEC,GAAGD,EAAEA,EAAE8zB,YAAY7zB,EAAE6zB,cAAc9zB,IAAIC,EAAE6zB,YAAY,CAACC,UAAU/zB,EAAE+zB,UAAUC,gBAAgBh0B,EAAEg0B,gBAAgBC,eAAej0B,EAAEi0B,eAAeC,OAAOl0B,EAAEk0B,OAAOE,QAAQp0B,EAAEo0B,SAAS,CAAC,SAASE,GAAGt0B,EAAEC,GAAG,MAAM,CAACs0B,UAAUv0B,EAAEw0B,KAAKv0B,EAAE+I,IAAI,EAAEyrB,QAAQ,KAAKC,SAAS,KAAKxC,KAAK,KAAK,CACtR,SAASyC,GAAG30B,EAAEC,EAAEhB,GAAG,IAAIiB,EAAEF,EAAE8zB,YAAY,GAAG,OAAO5zB,EAAE,OAAO,KAAgB,GAAXA,EAAEA,EAAEg0B,OAAU,KAAO,EAAFU,IAAK,CAAC,IAAIz0B,EAAED,EAAEi0B,QAA+D,OAAvD,OAAOh0B,EAAEF,EAAEiyB,KAAKjyB,GAAGA,EAAEiyB,KAAK/xB,EAAE+xB,KAAK/xB,EAAE+xB,KAAKjyB,GAAGC,EAAEi0B,QAAQl0B,EAAS0zB,GAAG3zB,EAAEf,EAAE,CAAoF,OAAnE,QAAhBkB,EAAED,EAAEwzB,cAAsBzzB,EAAEiyB,KAAKjyB,EAAEuzB,GAAGtzB,KAAKD,EAAEiyB,KAAK/xB,EAAE+xB,KAAK/xB,EAAE+xB,KAAKjyB,GAAGC,EAAEwzB,YAAYzzB,EAAS0zB,GAAG3zB,EAAEf,EAAE,CAAC,SAAS41B,GAAG70B,EAAEC,EAAEhB,GAAmB,GAAG,QAAnBgB,EAAEA,EAAE6zB,eAA0B7zB,EAAEA,EAAEi0B,OAAO,KAAO,QAAFj1B,IAAY,CAAC,IAAIiB,EAAED,EAAEizB,MAAwBj0B,GAAlBiB,GAAGF,EAAEqW,aAAkBpW,EAAEizB,MAAMj0B,EAAE+X,GAAGhX,EAAEf,EAAE,CAAC,CACrZ,SAAS61B,GAAG90B,EAAEC,GAAG,IAAIhB,EAAEe,EAAE8zB,YAAY5zB,EAAEF,EAAEqT,UAAU,GAAG,OAAOnT,GAAoBjB,KAAhBiB,EAAEA,EAAE4zB,aAAmB,CAAC,IAAI3zB,EAAE,KAAKC,EAAE,KAAyB,GAAG,QAAvBnB,EAAEA,EAAE+0B,iBAA4B,CAAC,EAAE,CAAC,IAAI7uB,EAAE,CAACovB,UAAUt1B,EAAEs1B,UAAUC,KAAKv1B,EAAEu1B,KAAKxrB,IAAI/J,EAAE+J,IAAIyrB,QAAQx1B,EAAEw1B,QAAQC,SAASz1B,EAAEy1B,SAASxC,KAAK,MAAM,OAAO9xB,EAAED,EAAEC,EAAE+E,EAAE/E,EAAEA,EAAE8xB,KAAK/sB,EAAElG,EAAEA,EAAEizB,IAAI,OAAO,OAAOjzB,GAAG,OAAOmB,EAAED,EAAEC,EAAEH,EAAEG,EAAEA,EAAE8xB,KAAKjyB,CAAC,MAAME,EAAEC,EAAEH,EAAiH,OAA/GhB,EAAE,CAAC80B,UAAU7zB,EAAE6zB,UAAUC,gBAAgB7zB,EAAE8zB,eAAe7zB,EAAE8zB,OAAOh0B,EAAEg0B,OAAOE,QAAQl0B,EAAEk0B,cAASp0B,EAAE8zB,YAAY70B,EAAQ,CAAoB,QAAnBe,EAAEf,EAAEg1B,gBAAwBh1B,EAAE+0B,gBAAgB/zB,EAAED,EAAEkyB,KACnfjyB,EAAEhB,EAAEg1B,eAAeh0B,CAAC,CACpB,SAAS80B,GAAG/0B,EAAEC,EAAEhB,EAAEiB,GAAG,IAAIC,EAAEH,EAAE8zB,YAAYF,IAAG,EAAG,IAAIxzB,EAAED,EAAE6zB,gBAAgB7uB,EAAEhF,EAAE8zB,eAAetrB,EAAExI,EAAE+zB,OAAOC,QAAQ,GAAG,OAAOxrB,EAAE,CAACxI,EAAE+zB,OAAOC,QAAQ,KAAK,IAAIvrB,EAAED,EAAED,EAAEE,EAAEspB,KAAKtpB,EAAEspB,KAAK,KAAK,OAAO/sB,EAAE/E,EAAEsI,EAAEvD,EAAE+sB,KAAKxpB,EAAEvD,EAAEyD,EAAE,IAAIhK,EAAEoB,EAAEqT,UAAU,OAAOzU,KAAoB+J,GAAhB/J,EAAEA,EAAEk1B,aAAgBG,kBAAmB9uB,IAAI,OAAOwD,EAAE/J,EAAEo1B,gBAAgBtrB,EAAEC,EAAEupB,KAAKxpB,EAAE9J,EAAEq1B,eAAerrB,GAAG,CAAC,GAAG,OAAOxI,EAAE,CAAC,IAAI2xB,EAAE5xB,EAAE4zB,UAA6B,IAAnB5uB,EAAE,EAAEvG,EAAE8J,EAAEE,EAAE,KAAKD,EAAEvI,IAAI,CAAC,IAAI4xB,EAAErpB,EAAE6rB,KAAKvC,EAAEtpB,EAAE4rB,UAAU,IAAIr0B,EAAE8xB,KAAKA,EAAE,CAAC,OAAOpzB,IAAIA,EAAEA,EAAEszB,KAAK,CAACqC,UAAUtC,EAAEuC,KAAK,EAAExrB,IAAIL,EAAEK,IAAIyrB,QAAQ9rB,EAAE8rB,QAAQC,SAAS/rB,EAAE+rB,SACvfxC,KAAK,OAAOlyB,EAAE,CAAC,IAAI+pB,EAAE/pB,EAAEgqB,EAAErhB,EAAU,OAARqpB,EAAE/xB,EAAEgyB,EAAEhzB,EAAS+qB,EAAEhhB,KAAK,KAAK,EAAc,GAAG,oBAAf+gB,EAAEC,EAAEyK,SAAiC,CAAC1C,EAAEhI,EAAEvvB,KAAKy3B,EAAEF,EAAEC,GAAG,MAAMhyB,CAAC,CAAC+xB,EAAEhI,EAAE,MAAM/pB,EAAE,KAAK,EAAE+pB,EAAExW,OAAe,MAATwW,EAAExW,MAAa,IAAI,KAAK,EAAsD,GAAG,QAA3Cye,EAAE,oBAAdjI,EAAEC,EAAEyK,SAAgC1K,EAAEvvB,KAAKy3B,EAAEF,EAAEC,GAAGjI,SAAe,IAASiI,EAAE,MAAMhyB,EAAE+xB,EAAE/pB,EAAE,CAAC,EAAE+pB,EAAEC,GAAG,MAAMhyB,EAAE,KAAK,EAAE4zB,IAAG,EAAG,CAAC,OAAOjrB,EAAE+rB,UAAU,IAAI/rB,EAAE6rB,OAAOx0B,EAAEuT,OAAO,GAAe,QAAZye,EAAE7xB,EAAEi0B,SAAiBj0B,EAAEi0B,QAAQ,CAACzrB,GAAGqpB,EAAEtzB,KAAKiK,GAAG,MAAMspB,EAAE,CAACsC,UAAUtC,EAAEuC,KAAKxC,EAAEhpB,IAAIL,EAAEK,IAAIyrB,QAAQ9rB,EAAE8rB,QAAQC,SAAS/rB,EAAE+rB,SAASxC,KAAK,MAAM,OAAOtzB,GAAG8J,EAAE9J,EAAEqzB,EAAErpB,EAAEmpB,GAAGnzB,EAAEA,EAAEszB,KAAKD,EAAE9sB,GAAG6sB,EAC3e,GAAG,QAAZrpB,EAAEA,EAAEupB,MAAiB,IAAsB,QAAnBvpB,EAAExI,EAAE+zB,OAAOC,SAAiB,MAAexrB,GAAJqpB,EAAErpB,GAAMupB,KAAKF,EAAEE,KAAK,KAAK/xB,EAAE8zB,eAAejC,EAAE7xB,EAAE+zB,OAAOC,QAAQ,IAAI,EAAsG,GAA5F,OAAOv1B,IAAIgK,EAAEmpB,GAAG5xB,EAAE4zB,UAAUnrB,EAAEzI,EAAE6zB,gBAAgBtrB,EAAEvI,EAAE8zB,eAAer1B,EAA4B,QAA1BqB,EAAEE,EAAE+zB,OAAOR,aAAwB,CAACvzB,EAAEF,EAAE,GAAGkF,GAAGhF,EAAEq0B,KAAKr0B,EAAEA,EAAE+xB,WAAW/xB,IAAIF,EAAE,MAAM,OAAOG,IAAID,EAAE+zB,OAAOhB,MAAM,GAAG8B,IAAI7vB,EAAEnF,EAAEkzB,MAAM/tB,EAAEnF,EAAEyT,cAAcse,CAAC,CAAC,CAC9V,SAASkD,GAAGj1B,EAAEC,EAAEhB,GAA8B,GAA3Be,EAAEC,EAAEm0B,QAAQn0B,EAAEm0B,QAAQ,KAAQ,OAAOp0B,EAAE,IAAIC,EAAE,EAAEA,EAAED,EAAE9D,OAAO+D,IAAI,CAAC,IAAIC,EAAEF,EAAEC,GAAGE,EAAED,EAAEw0B,SAAS,GAAG,OAAOv0B,EAAE,CAAqB,GAApBD,EAAEw0B,SAAS,KAAKx0B,EAAEjB,EAAK,oBAAoBkB,EAAE,MAAM7B,MAAM4F,EAAE,IAAI/D,IAAIA,EAAE3F,KAAK0F,EAAE,CAAC,CAAC,CAAC,IAAIg1B,GAAG,CAAC,EAAEC,GAAGhI,GAAG+H,IAAIE,GAAGjI,GAAG+H,IAAIG,GAAGlI,GAAG+H,IAAI,SAASI,GAAGt1B,GAAG,GAAGA,IAAIk1B,GAAG,MAAM52B,MAAM4F,EAAE,MAAM,OAAOlE,CAAC,CACnS,SAASu1B,GAAGv1B,EAAEC,GAAyC,OAAtCotB,GAAEgI,GAAGp1B,GAAGotB,GAAE+H,GAAGp1B,GAAGqtB,GAAE8H,GAAGD,IAAIl1B,EAAEC,EAAE6M,UAAmB,KAAK,EAAE,KAAK,GAAG7M,GAAGA,EAAEA,EAAEgmB,iBAAiBhmB,EAAEmM,aAAaH,GAAG,KAAK,IAAI,MAAM,QAAkEhM,EAAEgM,GAArChM,GAAvBD,EAAE,IAAIA,EAAEC,EAAEwR,WAAWxR,GAAMmM,cAAc,KAAKpM,EAAEA,EAAEw1B,SAAkBpI,GAAE+H,IAAI9H,GAAE8H,GAAGl1B,EAAE,CAAC,SAASw1B,KAAKrI,GAAE+H,IAAI/H,GAAEgI,IAAIhI,GAAEiI,GAAG,CAAC,SAASK,GAAG11B,GAAGs1B,GAAGD,GAAGthB,SAAS,IAAI9T,EAAEq1B,GAAGH,GAAGphB,SAAa9U,EAAEgN,GAAGhM,EAAED,EAAEX,MAAMY,IAAIhB,IAAIouB,GAAE+H,GAAGp1B,GAAGqtB,GAAE8H,GAAGl2B,GAAG,CAAC,SAAS02B,GAAG31B,GAAGo1B,GAAGrhB,UAAU/T,IAAIotB,GAAE+H,IAAI/H,GAAEgI,IAAI,CAAC,IAAIQ,GAAEzI,GAAG,GACxZ,SAAS0I,GAAG71B,GAAG,IAAI,IAAIC,EAAED,EAAE,OAAOC,GAAG,CAAC,GAAG,KAAKA,EAAE+I,IAAI,CAAC,IAAI/J,EAAEgB,EAAEwT,cAAc,GAAG,OAAOxU,IAAmB,QAAfA,EAAEA,EAAEyU,aAAqB,OAAOzU,EAAEwf,MAAM,OAAOxf,EAAEwf,MAAM,OAAOxe,CAAC,MAAM,GAAG,KAAKA,EAAE+I,UAAK,IAAS/I,EAAEywB,cAAcoF,aAAa,GAAG,KAAa,IAAR71B,EAAEsT,OAAW,OAAOtT,OAAO,GAAG,OAAOA,EAAE4T,MAAM,CAAC5T,EAAE4T,MAAMP,OAAOrT,EAAEA,EAAEA,EAAE4T,MAAM,QAAQ,CAAC,GAAG5T,IAAID,EAAE,MAAM,KAAK,OAAOC,EAAE6T,SAAS,CAAC,GAAG,OAAO7T,EAAEqT,QAAQrT,EAAEqT,SAAStT,EAAE,OAAO,KAAKC,EAAEA,EAAEqT,MAAM,CAACrT,EAAE6T,QAAQR,OAAOrT,EAAEqT,OAAOrT,EAAEA,EAAE6T,OAAO,CAAC,OAAO,IAAI,CAAC,IAAIiiB,GAAG,GACrc,SAASC,KAAK,IAAI,IAAIh2B,EAAE,EAAEA,EAAE+1B,GAAG75B,OAAO8D,IAAI+1B,GAAG/1B,GAAGi2B,8BAA8B,KAAKF,GAAG75B,OAAO,CAAC,CAAC,IAAIg6B,GAAGvvB,EAAGwvB,uBAAuBC,GAAGzvB,EAAG8S,wBAAwB4c,GAAG,EAAEC,GAAE,KAAKC,GAAE,KAAKC,GAAE,KAAKC,IAAG,EAAGC,IAAG,EAAGC,GAAG,EAAEC,GAAG,EAAE,SAASC,KAAI,MAAMv4B,MAAM4F,EAAE,KAAM,CAAC,SAAS4yB,GAAG92B,EAAEC,GAAG,GAAG,OAAOA,EAAE,OAAM,EAAG,IAAI,IAAIhB,EAAE,EAAEA,EAAEgB,EAAE/D,QAAQ+C,EAAEe,EAAE9D,OAAO+C,IAAI,IAAI8lB,GAAG/kB,EAAEf,GAAGgB,EAAEhB,IAAI,OAAM,EAAG,OAAM,CAAE,CAChW,SAAS83B,GAAG/2B,EAAEC,EAAEhB,EAAEiB,EAAEC,EAAEC,GAAyH,GAAtHi2B,GAAGj2B,EAAEk2B,GAAEr2B,EAAEA,EAAEwT,cAAc,KAAKxT,EAAE6zB,YAAY,KAAK7zB,EAAEizB,MAAM,EAAEgD,GAAGniB,QAAQ,OAAO/T,GAAG,OAAOA,EAAEyT,cAAcujB,GAAGC,GAAGj3B,EAAEf,EAAEiB,EAAEC,GAAMu2B,GAAG,CAACt2B,EAAE,EAAE,EAAE,CAAY,GAAXs2B,IAAG,EAAGC,GAAG,EAAK,IAAIv2B,EAAE,MAAM9B,MAAM4F,EAAE,MAAM9D,GAAG,EAAEo2B,GAAED,GAAE,KAAKt2B,EAAE6zB,YAAY,KAAKoC,GAAGniB,QAAQmjB,GAAGl3B,EAAEf,EAAEiB,EAAEC,EAAE,OAAOu2B,GAAG,CAA+D,GAA9DR,GAAGniB,QAAQojB,GAAGl3B,EAAE,OAAOs2B,IAAG,OAAOA,GAAErE,KAAKmE,GAAG,EAAEG,GAAED,GAAED,GAAE,KAAKG,IAAG,EAAMx2B,EAAE,MAAM3B,MAAM4F,EAAE,MAAM,OAAOlE,CAAC,CAAC,SAASo3B,KAAK,IAAIp3B,EAAE,IAAI22B,GAAQ,OAALA,GAAG,EAAS32B,CAAC,CAC/Y,SAASq3B,KAAK,IAAIr3B,EAAE,CAACyT,cAAc,KAAKsgB,UAAU,KAAKuD,UAAU,KAAKC,MAAM,KAAKrF,KAAK,MAA8C,OAAxC,OAAOsE,GAAEF,GAAE7iB,cAAc+iB,GAAEx2B,EAAEw2B,GAAEA,GAAEtE,KAAKlyB,EAASw2B,EAAC,CAAC,SAASgB,KAAK,GAAG,OAAOjB,GAAE,CAAC,IAAIv2B,EAAEs2B,GAAEjjB,UAAUrT,EAAE,OAAOA,EAAEA,EAAEyT,cAAc,IAAI,MAAMzT,EAAEu2B,GAAErE,KAAK,IAAIjyB,EAAE,OAAOu2B,GAAEF,GAAE7iB,cAAc+iB,GAAEtE,KAAK,GAAG,OAAOjyB,EAAEu2B,GAAEv2B,EAAEs2B,GAAEv2B,MAAM,CAAC,GAAG,OAAOA,EAAE,MAAM1B,MAAM4F,EAAE,MAAUlE,EAAE,CAACyT,eAAP8iB,GAAEv2B,GAAqByT,cAAcsgB,UAAUwC,GAAExC,UAAUuD,UAAUf,GAAEe,UAAUC,MAAMhB,GAAEgB,MAAMrF,KAAK,MAAM,OAAOsE,GAAEF,GAAE7iB,cAAc+iB,GAAEx2B,EAAEw2B,GAAEA,GAAEtE,KAAKlyB,CAAC,CAAC,OAAOw2B,EAAC,CACje,SAASiB,GAAGz3B,EAAEC,GAAG,MAAM,oBAAoBA,EAAEA,EAAED,GAAGC,CAAC,CACnD,SAASy3B,GAAG13B,GAAG,IAAIC,EAAEu3B,KAAKv4B,EAAEgB,EAAEs3B,MAAM,GAAG,OAAOt4B,EAAE,MAAMX,MAAM4F,EAAE,MAAMjF,EAAE04B,oBAAoB33B,EAAE,IAAIE,EAAEq2B,GAAEp2B,EAAED,EAAEo3B,UAAUl3B,EAAEnB,EAAEk1B,QAAQ,GAAG,OAAO/zB,EAAE,CAAC,GAAG,OAAOD,EAAE,CAAC,IAAIgF,EAAEhF,EAAE+xB,KAAK/xB,EAAE+xB,KAAK9xB,EAAE8xB,KAAK9xB,EAAE8xB,KAAK/sB,CAAC,CAACjF,EAAEo3B,UAAUn3B,EAAEC,EAAEnB,EAAEk1B,QAAQ,IAAI,CAAC,GAAG,OAAOh0B,EAAE,CAACC,EAAED,EAAE+xB,KAAKhyB,EAAEA,EAAE6zB,UAAU,IAAIprB,EAAExD,EAAE,KAAKyD,EAAE,KAAKF,EAAEtI,EAAE,EAAE,CAAC,IAAIxB,EAAE8J,EAAE8rB,KAAK,IAAI6B,GAAGz3B,KAAKA,EAAE,OAAOgK,IAAIA,EAAEA,EAAEspB,KAAK,CAACsC,KAAK,EAAEoD,OAAOlvB,EAAEkvB,OAAOC,cAAcnvB,EAAEmvB,cAAcC,WAAWpvB,EAAEovB,WAAW5F,KAAK,OAAOhyB,EAAEwI,EAAEmvB,cAAcnvB,EAAEovB,WAAW93B,EAAEE,EAAEwI,EAAEkvB,YAAY,CAAC,IAAI7F,EAAE,CAACyC,KAAK51B,EAAEg5B,OAAOlvB,EAAEkvB,OAAOC,cAAcnvB,EAAEmvB,cACngBC,WAAWpvB,EAAEovB,WAAW5F,KAAK,MAAM,OAAOtpB,GAAGD,EAAEC,EAAEmpB,EAAE5sB,EAAEjF,GAAG0I,EAAEA,EAAEspB,KAAKH,EAAEuE,GAAEpD,OAAOt0B,EAAEo2B,IAAIp2B,CAAC,CAAC8J,EAAEA,EAAEwpB,IAAI,OAAO,OAAOxpB,GAAGA,IAAItI,GAAG,OAAOwI,EAAEzD,EAAEjF,EAAE0I,EAAEspB,KAAKvpB,EAAEoc,GAAG7kB,EAAED,EAAEwT,iBAAiB0f,IAAG,GAAIlzB,EAAEwT,cAAcvT,EAAED,EAAE8zB,UAAU5uB,EAAElF,EAAEq3B,UAAU1uB,EAAE3J,EAAE84B,kBAAkB73B,CAAC,CAAiB,GAAG,QAAnBF,EAAEf,EAAEy0B,aAAwB,CAACvzB,EAAEH,EAAE,GAAGI,EAAED,EAAEq0B,KAAK8B,GAAEpD,OAAO9yB,EAAE40B,IAAI50B,EAAED,EAAEA,EAAE+xB,WAAW/xB,IAAIH,EAAE,MAAM,OAAOG,IAAIlB,EAAEi0B,MAAM,GAAG,MAAM,CAACjzB,EAAEwT,cAAcxU,EAAE+4B,SAAS,CAC9X,SAASC,GAAGj4B,GAAG,IAAIC,EAAEu3B,KAAKv4B,EAAEgB,EAAEs3B,MAAM,GAAG,OAAOt4B,EAAE,MAAMX,MAAM4F,EAAE,MAAMjF,EAAE04B,oBAAoB33B,EAAE,IAAIE,EAAEjB,EAAE+4B,SAAS73B,EAAElB,EAAEk1B,QAAQ/zB,EAAEH,EAAEwT,cAAc,GAAG,OAAOtT,EAAE,CAAClB,EAAEk1B,QAAQ,KAAK,IAAIhvB,EAAEhF,EAAEA,EAAE+xB,KAAK,GAAG9xB,EAAEJ,EAAEI,EAAE+E,EAAEyyB,QAAQzyB,EAAEA,EAAE+sB,WAAW/sB,IAAIhF,GAAG4kB,GAAG3kB,EAAEH,EAAEwT,iBAAiB0f,IAAG,GAAIlzB,EAAEwT,cAAcrT,EAAE,OAAOH,EAAEq3B,YAAYr3B,EAAE8zB,UAAU3zB,GAAGnB,EAAE84B,kBAAkB33B,CAAC,CAAC,MAAM,CAACA,EAAEF,EAAE,CAAC,SAASg4B,KAAK,CACpW,SAASC,GAAGn4B,EAAEC,GAAG,IAAIhB,EAAEq3B,GAAEp2B,EAAEs3B,KAAKr3B,EAAEF,IAAIG,GAAG2kB,GAAG7kB,EAAEuT,cAActT,GAAsE,GAAnEC,IAAIF,EAAEuT,cAActT,EAAEgzB,IAAG,GAAIjzB,EAAEA,EAAEq3B,MAAMa,GAAGC,GAAGl2B,KAAK,KAAKlD,EAAEiB,EAAEF,GAAG,CAACA,IAAOE,EAAEo4B,cAAcr4B,GAAGG,GAAG,OAAOo2B,IAAuB,EAApBA,GAAE/iB,cAAczK,IAAM,CAAuD,GAAtD/J,EAAEsU,OAAO,KAAKglB,GAAG,EAAEC,GAAGr2B,KAAK,KAAKlD,EAAEiB,EAAEC,EAAEF,QAAG,EAAO,MAAS,OAAOw4B,GAAE,MAAMn6B,MAAM4F,EAAE,MAAM,KAAQ,GAAHmyB,KAAQqC,GAAGz5B,EAAEgB,EAAEE,EAAE,CAAC,OAAOA,CAAC,CAAC,SAASu4B,GAAG14B,EAAEC,EAAEhB,GAAGe,EAAEuT,OAAO,MAAMvT,EAAE,CAACs4B,YAAYr4B,EAAE5E,MAAM4D,GAAmB,QAAhBgB,EAAEq2B,GAAExC,cAAsB7zB,EAAE,CAAC04B,WAAW,KAAKC,OAAO,MAAMtC,GAAExC,YAAY7zB,EAAEA,EAAE24B,OAAO,CAAC54B,IAAgB,QAAXf,EAAEgB,EAAE24B,QAAgB34B,EAAE24B,OAAO,CAAC54B,GAAGf,EAAEP,KAAKsB,EAAG,CAClf,SAASw4B,GAAGx4B,EAAEC,EAAEhB,EAAEiB,GAAGD,EAAE5E,MAAM4D,EAAEgB,EAAEq4B,YAAYp4B,EAAE24B,GAAG54B,IAAI64B,GAAG94B,EAAE,CAAC,SAASq4B,GAAGr4B,EAAEC,EAAEhB,GAAG,OAAOA,GAAE,WAAW45B,GAAG54B,IAAI64B,GAAG94B,EAAE,GAAE,CAAC,SAAS64B,GAAG74B,GAAG,IAAIC,EAAED,EAAEs4B,YAAYt4B,EAAEA,EAAE3E,MAAM,IAAI,IAAI4D,EAAEgB,IAAI,OAAO8kB,GAAG/kB,EAAEf,EAAE,CAAC,MAAMiB,GAAG,OAAM,CAAE,CAAC,CAAC,SAAS44B,GAAG94B,GAAG,IAAIC,EAAE0zB,GAAG3zB,EAAE,GAAG,OAAOC,GAAG84B,GAAG94B,EAAED,EAAE,GAAG,EAAE,CAClQ,SAASg5B,GAAGh5B,GAAG,IAAIC,EAAEo3B,KAA8M,MAAzM,oBAAoBr3B,IAAIA,EAAEA,KAAKC,EAAEwT,cAAcxT,EAAE8zB,UAAU/zB,EAAEA,EAAE,CAACm0B,QAAQ,KAAKT,YAAY,KAAKR,MAAM,EAAE8E,SAAS,KAAKL,oBAAoBF,GAAGM,kBAAkB/3B,GAAGC,EAAEs3B,MAAMv3B,EAAEA,EAAEA,EAAEg4B,SAASiB,GAAG92B,KAAK,KAAKm0B,GAAEt2B,GAAS,CAACC,EAAEwT,cAAczT,EAAE,CAC5P,SAASu4B,GAAGv4B,EAAEC,EAAEhB,EAAEiB,GAA8O,OAA3OF,EAAE,CAACgJ,IAAIhJ,EAAEk5B,OAAOj5B,EAAEk5B,QAAQl6B,EAAEm6B,KAAKl5B,EAAEgyB,KAAK,MAAsB,QAAhBjyB,EAAEq2B,GAAExC,cAAsB7zB,EAAE,CAAC04B,WAAW,KAAKC,OAAO,MAAMtC,GAAExC,YAAY7zB,EAAEA,EAAE04B,WAAW34B,EAAEkyB,KAAKlyB,GAAmB,QAAff,EAAEgB,EAAE04B,YAAoB14B,EAAE04B,WAAW34B,EAAEkyB,KAAKlyB,GAAGE,EAAEjB,EAAEizB,KAAKjzB,EAAEizB,KAAKlyB,EAAEA,EAAEkyB,KAAKhyB,EAAED,EAAE04B,WAAW34B,GAAWA,CAAC,CAAC,SAASq5B,KAAK,OAAO7B,KAAK/jB,aAAa,CAAC,SAAS6lB,GAAGt5B,EAAEC,EAAEhB,EAAEiB,GAAG,IAAIC,EAAEk3B,KAAKf,GAAE/iB,OAAOvT,EAAEG,EAAEsT,cAAc8kB,GAAG,EAAEt4B,EAAEhB,OAAE,OAAO,IAASiB,EAAE,KAAKA,EAAE,CAC9Y,SAASq5B,GAAGv5B,EAAEC,EAAEhB,EAAEiB,GAAG,IAAIC,EAAEq3B,KAAKt3B,OAAE,IAASA,EAAE,KAAKA,EAAE,IAAIE,OAAE,EAAO,GAAG,OAAOm2B,GAAE,CAAC,IAAIpxB,EAAEoxB,GAAE9iB,cAA0B,GAAZrT,EAAE+E,EAAEg0B,QAAW,OAAOj5B,GAAG42B,GAAG52B,EAAEiF,EAAEi0B,MAAmC,YAA5Bj5B,EAAEsT,cAAc8kB,GAAGt4B,EAAEhB,EAAEmB,EAAEF,GAAU,CAACo2B,GAAE/iB,OAAOvT,EAAEG,EAAEsT,cAAc8kB,GAAG,EAAEt4B,EAAEhB,EAAEmB,EAAEF,EAAE,CAAC,SAASs5B,GAAGx5B,EAAEC,GAAG,OAAOq5B,GAAG,QAAQ,EAAEt5B,EAAEC,EAAE,CAAC,SAASm4B,GAAGp4B,EAAEC,GAAG,OAAOs5B,GAAG,KAAK,EAAEv5B,EAAEC,EAAE,CAAC,SAASw5B,GAAGz5B,EAAEC,GAAG,OAAOs5B,GAAG,EAAE,EAAEv5B,EAAEC,EAAE,CAAC,SAASy5B,GAAG15B,EAAEC,GAAG,OAAOs5B,GAAG,EAAE,EAAEv5B,EAAEC,EAAE,CAChX,SAAS05B,GAAG35B,EAAEC,GAAG,MAAG,oBAAoBA,GAASD,EAAEA,IAAIC,EAAED,GAAG,WAAWC,EAAE,KAAK,GAAK,OAAOA,QAAG,IAASA,GAASD,EAAEA,IAAIC,EAAE8T,QAAQ/T,EAAE,WAAWC,EAAE8T,QAAQ,IAAI,QAA1E,CAA2E,CAAC,SAAS6lB,GAAG55B,EAAEC,EAAEhB,GAA6C,OAA1CA,EAAE,OAAOA,QAAG,IAASA,EAAEA,EAAEgD,OAAO,CAACjC,IAAI,KAAYu5B,GAAG,EAAE,EAAEI,GAAGx3B,KAAK,KAAKlC,EAAED,GAAGf,EAAE,CAAC,SAAS46B,KAAK,CAAC,SAASC,GAAG95B,EAAEC,GAAG,IAAIhB,EAAEu4B,KAAKv3B,OAAE,IAASA,EAAE,KAAKA,EAAE,IAAIC,EAAEjB,EAAEwU,cAAc,OAAG,OAAOvT,GAAG,OAAOD,GAAG62B,GAAG72B,EAAEC,EAAE,IAAWA,EAAE,IAAGjB,EAAEwU,cAAc,CAACzT,EAAEC,GAAUD,EAAC,CAC7Z,SAAS+5B,GAAG/5B,EAAEC,GAAG,IAAIhB,EAAEu4B,KAAKv3B,OAAE,IAASA,EAAE,KAAKA,EAAE,IAAIC,EAAEjB,EAAEwU,cAAc,OAAG,OAAOvT,GAAG,OAAOD,GAAG62B,GAAG72B,EAAEC,EAAE,IAAWA,EAAE,IAAGF,EAAEA,IAAIf,EAAEwU,cAAc,CAACzT,EAAEC,GAAUD,EAAC,CAAC,SAASg6B,GAAGh6B,EAAEC,EAAEhB,GAAG,OAAG,KAAQ,GAAHo3B,KAAcr2B,EAAE+zB,YAAY/zB,EAAE+zB,WAAU,EAAGZ,IAAG,GAAInzB,EAAEyT,cAAcxU,IAAE8lB,GAAG9lB,EAAEgB,KAAKhB,EAAE2X,KAAK0f,GAAEpD,OAAOj0B,EAAE+1B,IAAI/1B,EAAEe,EAAE+zB,WAAU,GAAW9zB,EAAC,CAAC,SAASg6B,GAAGj6B,EAAEC,GAAG,IAAIhB,EAAEgY,GAAEA,GAAE,IAAIhY,GAAG,EAAEA,EAAEA,EAAE,EAAEe,GAAE,GAAI,IAAIE,EAAEk2B,GAAGxc,WAAWwc,GAAGxc,WAAW,CAAC,EAAE,IAAI5Z,GAAE,GAAIC,GAAG,CAAC,QAAQgX,GAAEhY,EAAEm3B,GAAGxc,WAAW1Z,CAAC,CAAC,CAAC,SAASg6B,KAAK,OAAO1C,KAAK/jB,aAAa,CAC1d,SAAS0mB,GAAGn6B,EAAEC,EAAEhB,GAAG,IAAIiB,EAAEk6B,GAAGp6B,GAAkE,GAA/Df,EAAE,CAACu1B,KAAKt0B,EAAE03B,OAAO34B,EAAE44B,eAAc,EAAGC,WAAW,KAAK5F,KAAK,MAASmI,GAAGr6B,GAAGs6B,GAAGr6B,EAAEhB,QAAQ,GAAiB,QAAdA,EAAEw0B,GAAGzzB,EAAEC,EAAEhB,EAAEiB,IAAY,CAAW64B,GAAG95B,EAAEe,EAAEE,EAAXq6B,MAAgBC,GAAGv7B,EAAEgB,EAAEC,EAAE,CAAC,CAC/K,SAAS+4B,GAAGj5B,EAAEC,EAAEhB,GAAG,IAAIiB,EAAEk6B,GAAGp6B,GAAGG,EAAE,CAACq0B,KAAKt0B,EAAE03B,OAAO34B,EAAE44B,eAAc,EAAGC,WAAW,KAAK5F,KAAK,MAAM,GAAGmI,GAAGr6B,GAAGs6B,GAAGr6B,EAAEE,OAAO,CAAC,IAAIC,EAAEJ,EAAEqT,UAAU,GAAG,IAAIrT,EAAEkzB,QAAQ,OAAO9yB,GAAG,IAAIA,EAAE8yB,QAAiC,QAAxB9yB,EAAEH,EAAE03B,qBAA8B,IAAI,IAAIxyB,EAAElF,EAAE83B,kBAAkBpvB,EAAEvI,EAAE+E,EAAElG,GAAqC,GAAlCkB,EAAE03B,eAAc,EAAG13B,EAAE23B,WAAWnvB,EAAKoc,GAAGpc,EAAExD,GAAG,CAAC,IAAIyD,EAAE3I,EAAEyzB,YAA+E,OAAnE,OAAO9qB,GAAGzI,EAAE+xB,KAAK/xB,EAAEqzB,GAAGvzB,KAAKE,EAAE+xB,KAAKtpB,EAAEspB,KAAKtpB,EAAEspB,KAAK/xB,QAAGF,EAAEyzB,YAAYvzB,EAAQ,CAAC,CAAC,MAAMuI,GAAG,CAAwB,QAAdzJ,EAAEw0B,GAAGzzB,EAAEC,EAAEE,EAAED,MAAoB64B,GAAG95B,EAAEe,EAAEE,EAAbC,EAAEo6B,MAAgBC,GAAGv7B,EAAEgB,EAAEC,GAAG,CAAC,CAC/c,SAASm6B,GAAGr6B,GAAG,IAAIC,EAAED,EAAEqT,UAAU,OAAOrT,IAAIs2B,IAAG,OAAOr2B,GAAGA,IAAIq2B,EAAC,CAAC,SAASgE,GAAGt6B,EAAEC,GAAGy2B,GAAGD,IAAG,EAAG,IAAIx3B,EAAEe,EAAEm0B,QAAQ,OAAOl1B,EAAEgB,EAAEiyB,KAAKjyB,GAAGA,EAAEiyB,KAAKjzB,EAAEizB,KAAKjzB,EAAEizB,KAAKjyB,GAAGD,EAAEm0B,QAAQl0B,CAAC,CAAC,SAASu6B,GAAGx6B,EAAEC,EAAEhB,GAAG,GAAG,KAAO,QAAFA,GAAW,CAAC,IAAIiB,EAAED,EAAEizB,MAAwBj0B,GAAlBiB,GAAGF,EAAEqW,aAAkBpW,EAAEizB,MAAMj0B,EAAE+X,GAAGhX,EAAEf,EAAE,CAAC,CAC9P,IAAIk4B,GAAG,CAACsD,YAAYrH,GAAGsH,YAAY7D,GAAE8D,WAAW9D,GAAE+D,UAAU/D,GAAEgE,oBAAoBhE,GAAEiE,mBAAmBjE,GAAEkE,gBAAgBlE,GAAEmE,QAAQnE,GAAEoE,WAAWpE,GAAEqE,OAAOrE,GAAEsE,SAAStE,GAAEuE,cAAcvE,GAAEwE,iBAAiBxE,GAAEyE,cAAczE,GAAE0E,iBAAiB1E,GAAE2E,qBAAqB3E,GAAE4E,MAAM5E,GAAE6E,0BAAyB,GAAI1E,GAAG,CAACyD,YAAYrH,GAAGsH,YAAY,SAAS16B,EAAEC,GAA4C,OAAzCo3B,KAAK5jB,cAAc,CAACzT,OAAE,IAASC,EAAE,KAAKA,GAAUD,CAAC,EAAE26B,WAAWvH,GAAGwH,UAAUpB,GAAGqB,oBAAoB,SAAS76B,EAAEC,EAAEhB,GAA6C,OAA1CA,EAAE,OAAOA,QAAG,IAASA,EAAEA,EAAEgD,OAAO,CAACjC,IAAI,KAAYs5B,GAAG,QAC3f,EAAEK,GAAGx3B,KAAK,KAAKlC,EAAED,GAAGf,EAAE,EAAE87B,gBAAgB,SAAS/6B,EAAEC,GAAG,OAAOq5B,GAAG,QAAQ,EAAEt5B,EAAEC,EAAE,EAAE66B,mBAAmB,SAAS96B,EAAEC,GAAG,OAAOq5B,GAAG,EAAE,EAAEt5B,EAAEC,EAAE,EAAE+6B,QAAQ,SAASh7B,EAAEC,GAAG,IAAIhB,EAAEo4B,KAAqD,OAAhDp3B,OAAE,IAASA,EAAE,KAAKA,EAAED,EAAEA,IAAIf,EAAEwU,cAAc,CAACzT,EAAEC,GAAUD,CAAC,EAAEi7B,WAAW,SAASj7B,EAAEC,EAAEhB,GAAG,IAAIiB,EAAEm3B,KAAkM,OAA7Lp3B,OAAE,IAAShB,EAAEA,EAAEgB,GAAGA,EAAEC,EAAEuT,cAAcvT,EAAE6zB,UAAU9zB,EAAED,EAAE,CAACm0B,QAAQ,KAAKT,YAAY,KAAKR,MAAM,EAAE8E,SAAS,KAAKL,oBAAoB33B,EAAE+3B,kBAAkB93B,GAAGC,EAAEq3B,MAAMv3B,EAAEA,EAAEA,EAAEg4B,SAASmC,GAAGh4B,KAAK,KAAKm0B,GAAEt2B,GAAS,CAACE,EAAEuT,cAAczT,EAAE,EAAEk7B,OAAO,SAASl7B,GAC3d,OAAdA,EAAE,CAAC+T,QAAQ/T,GAAhBq3B,KAA4B5jB,cAAczT,CAAC,EAAEm7B,SAASnC,GAAGoC,cAAcvB,GAAGwB,iBAAiB,SAASr7B,GAAG,OAAOq3B,KAAK5jB,cAAczT,CAAC,EAAEs7B,cAAc,WAAW,IAAIt7B,EAAEg5B,IAAG,GAAI/4B,EAAED,EAAE,GAA6C,OAA1CA,EAAEi6B,GAAG93B,KAAK,KAAKnC,EAAE,IAAIq3B,KAAK5jB,cAAczT,EAAQ,CAACC,EAAED,EAAE,EAAEu7B,iBAAiB,WAAW,EAAEC,qBAAqB,SAASx7B,EAAEC,EAAEhB,GAAG,IAAIiB,EAAEo2B,GAAEn2B,EAAEk3B,KAAK,GAAG1H,GAAE,CAAC,QAAG,IAAS1wB,EAAE,MAAMX,MAAM4F,EAAE,MAAMjF,EAAEA,GAAG,KAAK,CAAO,GAANA,EAAEgB,IAAO,OAAOw4B,GAAE,MAAMn6B,MAAM4F,EAAE,MAAM,KAAQ,GAAHmyB,KAAQqC,GAAGx4B,EAAED,EAAEhB,EAAE,CAACkB,EAAEsT,cAAcxU,EAAE,IAAImB,EAAE,CAAC/E,MAAM4D,EAAEq5B,YAAYr4B,GACvZ,OAD0ZE,EAAEo3B,MAAMn3B,EAAEo5B,GAAGnB,GAAGl2B,KAAK,KAAKjC,EACpfE,EAAEJ,GAAG,CAACA,IAAIE,EAAEqT,OAAO,KAAKglB,GAAG,EAAEC,GAAGr2B,KAAK,KAAKjC,EAAEE,EAAEnB,EAAEgB,QAAG,EAAO,MAAahB,CAAC,EAAEw8B,MAAM,WAAW,IAAIz7B,EAAEq3B,KAAKp3B,EAAEw4B,GAAEkD,iBAAiB,GAAGhM,GAAE,CAAC,IAAI1wB,EAAEmwB,GAAkDnvB,EAAE,IAAIA,EAAE,KAA9ChB,GAAHkwB,KAAU,GAAG,GAAGzZ,GAAhByZ,IAAsB,IAAIl1B,SAAS,IAAIgF,GAAuB,GAAPA,EAAE03B,QAAW12B,GAAG,IAAIhB,EAAEhF,SAAS,KAAKgG,GAAG,GAAG,MAAaA,EAAE,IAAIA,EAAE,KAAfhB,EAAE23B,MAAmB38B,SAAS,IAAI,IAAI,OAAO+F,EAAEyT,cAAcxT,CAAC,EAAEy7B,0BAAyB,GAAIzE,GAAG,CAACwD,YAAYrH,GAAGsH,YAAYZ,GAAGa,WAAWvH,GAAGwH,UAAUxC,GAAGyC,oBAAoBjB,GAAGkB,mBAAmBrB,GAAGsB,gBAAgBrB,GAAGsB,QAAQjB,GAAGkB,WAAWvD,GAAGwD,OAAO7B,GAAG8B,SAAS,WAAW,OAAOzD,GAAGD,GAAG,EACrhB2D,cAAcvB,GAAGwB,iBAAiB,SAASr7B,GAAc,OAAOg6B,GAAZxC,KAAiBjB,GAAE9iB,cAAczT,EAAE,EAAEs7B,cAAc,WAAgD,MAAM,CAArC5D,GAAGD,IAAI,GAAKD,KAAK/jB,cAAyB,EAAE8nB,iBAAiBrD,GAAGsD,qBAAqBrD,GAAGsD,MAAMvB,GAAGwB,0BAAyB,GAAIxE,GAAG,CAACuD,YAAYrH,GAAGsH,YAAYZ,GAAGa,WAAWvH,GAAGwH,UAAUxC,GAAGyC,oBAAoBjB,GAAGkB,mBAAmBrB,GAAGsB,gBAAgBrB,GAAGsB,QAAQjB,GAAGkB,WAAWhD,GAAGiD,OAAO7B,GAAG8B,SAAS,WAAW,OAAOlD,GAAGR,GAAG,EAAE2D,cAAcvB,GAAGwB,iBAAiB,SAASr7B,GAAG,IAAIC,EAAEu3B,KAAK,OAAO,OACzfjB,GAAEt2B,EAAEwT,cAAczT,EAAEg6B,GAAG/5B,EAAEs2B,GAAE9iB,cAAczT,EAAE,EAAEs7B,cAAc,WAAgD,MAAM,CAArCrD,GAAGR,IAAI,GAAKD,KAAK/jB,cAAyB,EAAE8nB,iBAAiBrD,GAAGsD,qBAAqBrD,GAAGsD,MAAMvB,GAAGwB,0BAAyB,GAAI,SAASE,GAAG57B,EAAEC,GAAG,GAAGD,GAAGA,EAAE67B,aAAa,CAA4B,IAAI,IAAI58B,KAAnCgB,EAAE+H,EAAE,CAAC,EAAE/H,GAAGD,EAAEA,EAAE67B,kBAA4B,IAAS57B,EAAEhB,KAAKgB,EAAEhB,GAAGe,EAAEf,IAAI,OAAOgB,CAAC,CAAC,OAAOA,CAAC,CAAC,SAAS67B,GAAG97B,EAAEC,EAAEhB,EAAEiB,GAA8BjB,EAAE,QAAXA,EAAEA,EAAEiB,EAAtBD,EAAED,EAAEyT,sBAAmC,IAASxU,EAAEgB,EAAE+H,EAAE,CAAC,EAAE/H,EAAEhB,GAAGe,EAAEyT,cAAcxU,EAAE,IAAIe,EAAEkzB,QAAQlzB,EAAE8zB,YAAYC,UAAU90B,EAAE,CACrd,IAAI88B,GAAG,CAACC,UAAU,SAASh8B,GAAG,SAAOA,EAAEA,EAAEi8B,kBAAiB7oB,GAAGpT,KAAKA,CAAI,EAAEk8B,gBAAgB,SAASl8B,EAAEC,EAAEhB,GAAGe,EAAEA,EAAEi8B,gBAAgB,IAAI/7B,EAAEq6B,KAAIp6B,EAAEi6B,GAAGp6B,GAAGI,EAAEk0B,GAAGp0B,EAAEC,GAAGC,EAAEq0B,QAAQx0B,OAAE,IAAShB,GAAG,OAAOA,IAAImB,EAAEs0B,SAASz1B,GAAe,QAAZgB,EAAE00B,GAAG30B,EAAEI,EAAED,MAAc44B,GAAG94B,EAAED,EAAEG,EAAED,GAAG20B,GAAG50B,EAAED,EAAEG,GAAG,EAAEg8B,oBAAoB,SAASn8B,EAAEC,EAAEhB,GAAGe,EAAEA,EAAEi8B,gBAAgB,IAAI/7B,EAAEq6B,KAAIp6B,EAAEi6B,GAAGp6B,GAAGI,EAAEk0B,GAAGp0B,EAAEC,GAAGC,EAAE4I,IAAI,EAAE5I,EAAEq0B,QAAQx0B,OAAE,IAAShB,GAAG,OAAOA,IAAImB,EAAEs0B,SAASz1B,GAAe,QAAZgB,EAAE00B,GAAG30B,EAAEI,EAAED,MAAc44B,GAAG94B,EAAED,EAAEG,EAAED,GAAG20B,GAAG50B,EAAED,EAAEG,GAAG,EAAEi8B,mBAAmB,SAASp8B,EAAEC,GAAGD,EAAEA,EAAEi8B,gBAAgB,IAAIh9B,EAAEs7B,KAAIr6B,EACnfk6B,GAAGp6B,GAAGG,EAAEm0B,GAAGr1B,EAAEiB,GAAGC,EAAE6I,IAAI,OAAE,IAAS/I,GAAG,OAAOA,IAAIE,EAAEu0B,SAASz0B,GAAe,QAAZA,EAAE00B,GAAG30B,EAAEG,EAAED,MAAc64B,GAAG94B,EAAED,EAAEE,EAAEjB,GAAG41B,GAAG50B,EAAED,EAAEE,GAAG,GAAG,SAASm8B,GAAGr8B,EAAEC,EAAEhB,EAAEiB,EAAEC,EAAEC,EAAE+E,GAAiB,MAAM,oBAApBnF,EAAEA,EAAE+R,WAAsCuqB,sBAAsBt8B,EAAEs8B,sBAAsBp8B,EAAEE,EAAE+E,IAAGlF,EAAEnG,YAAWmG,EAAEnG,UAAUyiC,wBAAsBvX,GAAG/lB,EAAEiB,KAAK8kB,GAAG7kB,EAAEC,GAAK,CAC1S,SAASo8B,GAAGx8B,EAAEC,EAAEhB,GAAG,IAAIiB,GAAE,EAAGC,EAAEmtB,GAAOltB,EAAEH,EAAEw8B,YAA2W,MAA/V,kBAAkBr8B,GAAG,OAAOA,EAAEA,EAAEgzB,GAAGhzB,IAAID,EAAE2tB,GAAG7tB,GAAGwtB,GAAGF,GAAExZ,QAAyB3T,GAAGF,EAAE,QAAtBA,EAAED,EAAE0tB,oBAA4B,IAASztB,GAAGwtB,GAAG1tB,EAAEG,GAAGmtB,IAAIrtB,EAAE,IAAIA,EAAEhB,EAAEmB,GAAGJ,EAAEyT,cAAc,OAAOxT,EAAEy8B,YAAO,IAASz8B,EAAEy8B,MAAMz8B,EAAEy8B,MAAM,KAAKz8B,EAAE08B,QAAQZ,GAAG/7B,EAAE+R,UAAU9R,EAAEA,EAAEg8B,gBAAgBj8B,EAAEE,KAAIF,EAAEA,EAAE+R,WAAY6b,4CAA4CztB,EAAEH,EAAE6tB,0CAA0CztB,GAAUH,CAAC,CAC5Z,SAAS28B,GAAG58B,EAAEC,EAAEhB,EAAEiB,GAAGF,EAAEC,EAAEy8B,MAAM,oBAAoBz8B,EAAE48B,2BAA2B58B,EAAE48B,0BAA0B59B,EAAEiB,GAAG,oBAAoBD,EAAE68B,kCAAkC78B,EAAE68B,iCAAiC79B,EAAEiB,GAAGD,EAAEy8B,QAAQ18B,GAAG+7B,GAAGI,oBAAoBl8B,EAAEA,EAAEy8B,MAAM,KAAK,CACpQ,SAASK,GAAG/8B,EAAEC,EAAEhB,EAAEiB,GAAG,IAAIC,EAAEH,EAAE+R,UAAU5R,EAAEuB,MAAMzC,EAAEkB,EAAEu8B,MAAM18B,EAAEyT,cAActT,EAAEgxB,KAAK,CAAC,EAAE0C,GAAG7zB,GAAG,IAAII,EAAEH,EAAEw8B,YAAY,kBAAkBr8B,GAAG,OAAOA,EAAED,EAAEkzB,QAAQD,GAAGhzB,IAAIA,EAAE0tB,GAAG7tB,GAAGwtB,GAAGF,GAAExZ,QAAQ5T,EAAEkzB,QAAQ3F,GAAG1tB,EAAEI,IAAID,EAAEu8B,MAAM18B,EAAEyT,cAA2C,oBAA7BrT,EAAEH,EAAE+8B,4BAAiDlB,GAAG97B,EAAEC,EAAEG,EAAEnB,GAAGkB,EAAEu8B,MAAM18B,EAAEyT,eAAe,oBAAoBxT,EAAE+8B,0BAA0B,oBAAoB78B,EAAE88B,yBAAyB,oBAAoB98B,EAAE+8B,2BAA2B,oBAAoB/8B,EAAEg9B,qBAAqBl9B,EAAEE,EAAEu8B,MACrf,oBAAoBv8B,EAAEg9B,oBAAoBh9B,EAAEg9B,qBAAqB,oBAAoBh9B,EAAE+8B,2BAA2B/8B,EAAE+8B,4BAA4Bj9B,IAAIE,EAAEu8B,OAAOX,GAAGI,oBAAoBh8B,EAAEA,EAAEu8B,MAAM,MAAM3H,GAAG/0B,EAAEf,EAAEkB,EAAED,GAAGC,EAAEu8B,MAAM18B,EAAEyT,eAAe,oBAAoBtT,EAAEi9B,oBAAoBp9B,EAAEuT,OAAO,QAAQ,CAAC,SAAS8pB,GAAGr9B,EAAEC,GAAG,IAAI,IAAIhB,EAAE,GAAGiB,EAAED,EAAE,GAAGhB,GAAG8J,EAAG7I,GAAGA,EAAEA,EAAEoT,aAAapT,GAAG,IAAIC,EAAElB,CAAC,CAAC,MAAMmB,GAAGD,EAAE,6BAA6BC,EAAEk9B,QAAQ,KAAKl9B,EAAE+H,KAAK,CAAC,MAAM,CAAC9M,MAAM2E,EAAEhC,OAAOiC,EAAEkI,MAAMhI,EAAEo9B,OAAO,KAAK,CAC1d,SAASC,GAAGx9B,EAAEC,EAAEhB,GAAG,MAAM,CAAC5D,MAAM2E,EAAEhC,OAAO,KAAKmK,MAAM,MAAMlJ,EAAEA,EAAE,KAAKs+B,OAAO,MAAMt9B,EAAEA,EAAE,KAAK,CAAC,SAASw9B,GAAGz9B,EAAEC,GAAG,IAAIy9B,QAAQv/B,MAAM8B,EAAE5E,MAAM,CAAC,MAAM4D,GAAG4sB,YAAW,WAAW,MAAM5sB,CAAE,GAAE,CAAC,CAAC,IAAI0+B,GAAG,oBAAoBC,QAAQA,QAAQ9lB,IAAI,SAAS+lB,GAAG79B,EAAEC,EAAEhB,IAAGA,EAAEq1B,IAAI,EAAEr1B,IAAK+J,IAAI,EAAE/J,EAAEw1B,QAAQ,CAACnxB,QAAQ,MAAM,IAAIpD,EAAED,EAAE5E,MAAsD,OAAhD4D,EAAEy1B,SAAS,WAAWoJ,KAAKA,IAAG,EAAGC,GAAG79B,GAAGu9B,GAAGz9B,EAAEC,EAAE,EAAShB,CAAC,CACrW,SAAS++B,GAAGh+B,EAAEC,EAAEhB,IAAGA,EAAEq1B,IAAI,EAAEr1B,IAAK+J,IAAI,EAAE,IAAI9I,EAAEF,EAAEX,KAAK4+B,yBAAyB,GAAG,oBAAoB/9B,EAAE,CAAC,IAAIC,EAAEF,EAAE5E,MAAM4D,EAAEw1B,QAAQ,WAAW,OAAOv0B,EAAEC,EAAE,EAAElB,EAAEy1B,SAAS,WAAW+I,GAAGz9B,EAAEC,EAAE,CAAC,CAAC,IAAIG,EAAEJ,EAAE+R,UAA8O,OAApO,OAAO3R,GAAG,oBAAoBA,EAAE89B,oBAAoBj/B,EAAEy1B,SAAS,WAAW+I,GAAGz9B,EAAEC,GAAG,oBAAoBC,IAAI,OAAOi+B,GAAGA,GAAG,IAAI95B,IAAI,CAACvG,OAAOqgC,GAAG15B,IAAI3G,OAAO,IAAImB,EAAEgB,EAAEkI,MAAMrK,KAAKogC,kBAAkBj+B,EAAE5E,MAAM,CAAC+iC,eAAe,OAAOn/B,EAAEA,EAAE,IAAI,GAAUA,CAAC,CACnb,SAASo/B,GAAGr+B,EAAEC,EAAEhB,GAAG,IAAIiB,EAAEF,EAAEs+B,UAAU,GAAG,OAAOp+B,EAAE,CAACA,EAAEF,EAAEs+B,UAAU,IAAIX,GAAG,IAAIx9B,EAAE,IAAIkE,IAAInE,EAAEqI,IAAItI,EAAEE,EAAE,WAAiB,KAAXA,EAAED,EAAE2J,IAAI5J,MAAgBE,EAAE,IAAIkE,IAAInE,EAAEqI,IAAItI,EAAEE,IAAIA,EAAEopB,IAAItqB,KAAKkB,EAAEsE,IAAIxF,GAAGe,EAAEu+B,GAAGp8B,KAAK,KAAKnC,EAAEC,EAAEhB,GAAGgB,EAAEosB,KAAKrsB,EAAEA,GAAG,CAAC,SAASw+B,GAAGx+B,GAAG,EAAE,CAAC,IAAIC,EAA4E,IAAvEA,EAAE,KAAKD,EAAEgJ,OAAsB/I,EAAE,QAApBA,EAAED,EAAEyT,gBAAyB,OAAOxT,EAAEyT,YAAuBzT,EAAE,OAAOD,EAAEA,EAAEA,EAAEsT,MAAM,OAAO,OAAOtT,GAAG,OAAO,IAAI,CAChW,SAASy+B,GAAGz+B,EAAEC,EAAEhB,EAAEiB,EAAEC,GAAG,OAAG,KAAY,EAAPH,EAAEswB,OAAetwB,IAAIC,EAAED,EAAEuT,OAAO,OAAOvT,EAAEuT,OAAO,IAAItU,EAAEsU,OAAO,OAAOtU,EAAEsU,QAAQ,MAAM,IAAItU,EAAE+J,MAAM,OAAO/J,EAAEoU,UAAUpU,EAAE+J,IAAI,KAAI/I,EAAEq0B,IAAI,EAAE,IAAKtrB,IAAI,EAAE2rB,GAAG11B,EAAEgB,EAAE,KAAKhB,EAAEi0B,OAAO,GAAGlzB,IAAEA,EAAEuT,OAAO,MAAMvT,EAAEkzB,MAAM/yB,EAASH,EAAC,CAAC,IAAI0+B,GAAG/3B,EAAGg4B,kBAAkBxL,IAAG,EAAG,SAASyL,GAAG5+B,EAAEC,EAAEhB,EAAEiB,GAAGD,EAAE4T,MAAM,OAAO7T,EAAEqyB,GAAGpyB,EAAE,KAAKhB,EAAEiB,GAAGkyB,GAAGnyB,EAAED,EAAE6T,MAAM5U,EAAEiB,EAAE,CACnV,SAAS2+B,GAAG7+B,EAAEC,EAAEhB,EAAEiB,EAAEC,GAAGlB,EAAEA,EAAEgK,OAAO,IAAI7I,EAAEH,EAAE+wB,IAAqC,OAAjC+B,GAAG9yB,EAAEE,GAAGD,EAAE62B,GAAG/2B,EAAEC,EAAEhB,EAAEiB,EAAEE,EAAED,GAAGlB,EAAEm4B,KAAQ,OAAOp3B,GAAImzB,IAA2ExD,IAAG1wB,GAAGswB,GAAGtvB,GAAGA,EAAEsT,OAAO,EAAEqrB,GAAG5+B,EAAEC,EAAEC,EAAEC,GAAUF,EAAE4T,QAA7G5T,EAAE6zB,YAAY9zB,EAAE8zB,YAAY7zB,EAAEsT,QAAQ,KAAKvT,EAAEkzB,QAAQ/yB,EAAE2+B,GAAG9+B,EAAEC,EAAEE,GAAoD,CACzN,SAAS4+B,GAAG/+B,EAAEC,EAAEhB,EAAEiB,EAAEC,GAAG,GAAG,OAAOH,EAAE,CAAC,IAAII,EAAEnB,EAAEI,KAAK,MAAG,oBAAoBe,GAAI4+B,GAAG5+B,SAAI,IAASA,EAAEy7B,cAAc,OAAO58B,EAAEggC,cAAS,IAAShgC,EAAE48B,eAAoD77B,EAAE2xB,GAAG1yB,EAAEI,KAAK,KAAKa,EAAED,EAAEA,EAAEqwB,KAAKnwB,IAAK6wB,IAAI/wB,EAAE+wB,IAAIhxB,EAAEsT,OAAOrT,EAASA,EAAE4T,MAAM7T,IAArGC,EAAE+I,IAAI,GAAG/I,EAAEZ,KAAKe,EAAE8+B,GAAGl/B,EAAEC,EAAEG,EAAEF,EAAEC,GAAyE,CAAW,GAAVC,EAAEJ,EAAE6T,MAAS,KAAK7T,EAAEkzB,MAAM/yB,GAAG,CAAC,IAAIgF,EAAE/E,EAAEswB,cAA0C,IAAhBzxB,EAAE,QAAdA,EAAEA,EAAEggC,SAAmBhgC,EAAE+lB,IAAQ7f,EAAEjF,IAAIF,EAAEgxB,MAAM/wB,EAAE+wB,IAAI,OAAO8N,GAAG9+B,EAAEC,EAAEE,EAAE,CAA6C,OAA5CF,EAAEsT,OAAO,GAAEvT,EAAEyxB,GAAGrxB,EAAEF,IAAK8wB,IAAI/wB,EAAE+wB,IAAIhxB,EAAEsT,OAAOrT,EAASA,EAAE4T,MAAM7T,CAAC,CAC1b,SAASk/B,GAAGl/B,EAAEC,EAAEhB,EAAEiB,EAAEC,GAAG,GAAG,OAAOH,EAAE,CAAC,IAAII,EAAEJ,EAAE0wB,cAAc,GAAG1L,GAAG5kB,EAAEF,IAAIF,EAAEgxB,MAAM/wB,EAAE+wB,IAAI,IAAGmC,IAAG,EAAGlzB,EAAEgwB,aAAa/vB,EAAEE,EAAE,KAAKJ,EAAEkzB,MAAM/yB,GAAsC,OAAOF,EAAEizB,MAAMlzB,EAAEkzB,MAAM4L,GAAG9+B,EAAEC,EAAEE,GAAjE,KAAa,OAARH,EAAEuT,SAAgB4f,IAAG,EAAyC,EAAC,OAAOgM,GAAGn/B,EAAEC,EAAEhB,EAAEiB,EAAEC,EAAE,CACxN,SAASi/B,GAAGp/B,EAAEC,EAAEhB,GAAG,IAAIiB,EAAED,EAAEgwB,aAAa9vB,EAAED,EAAEyL,SAASvL,EAAE,OAAOJ,EAAEA,EAAEyT,cAAc,KAAK,GAAG,WAAWvT,EAAEowB,KAAK,GAAG,KAAY,EAAPrwB,EAAEqwB,MAAQrwB,EAAEwT,cAAc,CAAC4rB,UAAU,EAAEC,UAAU,KAAKC,YAAY,MAAMlS,GAAEmS,GAAGC,IAAIA,IAAIxgC,MAAM,CAAC,GAAG,KAAO,WAAFA,GAAc,OAAOe,EAAE,OAAOI,EAAEA,EAAEi/B,UAAUpgC,EAAEA,EAAEgB,EAAEizB,MAAMjzB,EAAE6yB,WAAW,WAAW7yB,EAAEwT,cAAc,CAAC4rB,UAAUr/B,EAAEs/B,UAAU,KAAKC,YAAY,MAAMt/B,EAAE6zB,YAAY,KAAKzG,GAAEmS,GAAGC,IAAIA,IAAIz/B,EAAE,KAAKC,EAAEwT,cAAc,CAAC4rB,UAAU,EAAEC,UAAU,KAAKC,YAAY,MAAMr/B,EAAE,OAAOE,EAAEA,EAAEi/B,UAAUpgC,EAAEouB,GAAEmS,GAAGC,IAAIA,IAAIv/B,CAAC,MAAM,OACtfE,GAAGF,EAAEE,EAAEi/B,UAAUpgC,EAAEgB,EAAEwT,cAAc,MAAMvT,EAAEjB,EAAEouB,GAAEmS,GAAGC,IAAIA,IAAIv/B,EAAc,OAAZ0+B,GAAG5+B,EAAEC,EAAEE,EAAElB,GAAUgB,EAAE4T,KAAK,CAAC,SAAS6rB,GAAG1/B,EAAEC,GAAG,IAAIhB,EAAEgB,EAAE+wB,KAAO,OAAOhxB,GAAG,OAAOf,GAAG,OAAOe,GAAGA,EAAEgxB,MAAM/xB,KAAEgB,EAAEsT,OAAO,IAAItT,EAAEsT,OAAO,QAAO,CAAC,SAAS4rB,GAAGn/B,EAAEC,EAAEhB,EAAEiB,EAAEC,GAAG,IAAIC,EAAE0tB,GAAG7uB,GAAGwuB,GAAGF,GAAExZ,QAAmD,OAA3C3T,EAAEstB,GAAGztB,EAAEG,GAAG2yB,GAAG9yB,EAAEE,GAAGlB,EAAE83B,GAAG/2B,EAAEC,EAAEhB,EAAEiB,EAAEE,EAAED,GAAGD,EAAEk3B,KAAQ,OAAOp3B,GAAImzB,IAA2ExD,IAAGzvB,GAAGqvB,GAAGtvB,GAAGA,EAAEsT,OAAO,EAAEqrB,GAAG5+B,EAAEC,EAAEhB,EAAEkB,GAAUF,EAAE4T,QAA7G5T,EAAE6zB,YAAY9zB,EAAE8zB,YAAY7zB,EAAEsT,QAAQ,KAAKvT,EAAEkzB,QAAQ/yB,EAAE2+B,GAAG9+B,EAAEC,EAAEE,GAAoD,CACla,SAASw/B,GAAG3/B,EAAEC,EAAEhB,EAAEiB,EAAEC,GAAG,GAAG2tB,GAAG7uB,GAAG,CAAC,IAAImB,GAAE,EAAGguB,GAAGnuB,EAAE,MAAMG,GAAE,EAAW,GAAR2yB,GAAG9yB,EAAEE,GAAM,OAAOF,EAAE8R,UAAU6tB,GAAG5/B,EAAEC,GAAGu8B,GAAGv8B,EAAEhB,EAAEiB,GAAG68B,GAAG98B,EAAEhB,EAAEiB,EAAEC,GAAGD,GAAE,OAAQ,GAAG,OAAOF,EAAE,CAAC,IAAImF,EAAElF,EAAE8R,UAAUpJ,EAAE1I,EAAEywB,cAAcvrB,EAAEzD,MAAMiH,EAAE,IAAIC,EAAEzD,EAAEkuB,QAAQ3qB,EAAEzJ,EAAEw9B,YAAY,kBAAkB/zB,GAAG,OAAOA,EAAEA,EAAE0qB,GAAG1qB,GAAyBA,EAAEglB,GAAGztB,EAA1ByI,EAAEolB,GAAG7uB,GAAGwuB,GAAGF,GAAExZ,SAAmB,IAAInV,EAAEK,EAAE+9B,yBAAyBjL,EAAE,oBAAoBnzB,GAAG,oBAAoBuG,EAAE83B,wBAAwBlL,GAAG,oBAAoB5sB,EAAE23B,kCAAkC,oBAAoB33B,EAAE03B,4BAC1dl0B,IAAIzI,GAAG0I,IAAIF,IAAIk0B,GAAG38B,EAAEkF,EAAEjF,EAAEwI,GAAGkrB,IAAG,EAAG,IAAI5B,EAAE/xB,EAAEwT,cAActO,EAAEu3B,MAAM1K,EAAE+C,GAAG90B,EAAEC,EAAEiF,EAAEhF,GAAGyI,EAAE3I,EAAEwT,cAAc9K,IAAIzI,GAAG8xB,IAAIppB,GAAG4kB,GAAGzZ,SAAS6f,IAAI,oBAAoBh1B,IAAIk9B,GAAG77B,EAAEhB,EAAEL,EAAEsB,GAAG0I,EAAE3I,EAAEwT,gBAAgB9K,EAAEirB,IAAIyI,GAAGp8B,EAAEhB,EAAE0J,EAAEzI,EAAE8xB,EAAEppB,EAAEF,KAAKqpB,GAAG,oBAAoB5sB,EAAE+3B,2BAA2B,oBAAoB/3B,EAAEg4B,qBAAqB,oBAAoBh4B,EAAEg4B,oBAAoBh4B,EAAEg4B,qBAAqB,oBAAoBh4B,EAAE+3B,2BAA2B/3B,EAAE+3B,6BAA6B,oBAAoB/3B,EAAEi4B,oBAAoBn9B,EAAEsT,OAAO,WAClf,oBAAoBpO,EAAEi4B,oBAAoBn9B,EAAEsT,OAAO,SAAStT,EAAEywB,cAAcxwB,EAAED,EAAEwT,cAAc7K,GAAGzD,EAAEzD,MAAMxB,EAAEiF,EAAEu3B,MAAM9zB,EAAEzD,EAAEkuB,QAAQ3qB,EAAExI,EAAEyI,IAAI,oBAAoBxD,EAAEi4B,oBAAoBn9B,EAAEsT,OAAO,SAASrT,GAAE,EAAG,KAAK,CAACiF,EAAElF,EAAE8R,UAAUsiB,GAAGr0B,EAAEC,GAAG0I,EAAE1I,EAAEywB,cAAchoB,EAAEzI,EAAEZ,OAAOY,EAAEsD,YAAYoF,EAAEizB,GAAG37B,EAAEZ,KAAKsJ,GAAGxD,EAAEzD,MAAMgH,EAAEqpB,EAAE9xB,EAAEgwB,aAAa+B,EAAE7sB,EAAEkuB,QAAwB,kBAAhBzqB,EAAE3J,EAAEw9B,cAAiC,OAAO7zB,EAAEA,EAAEwqB,GAAGxqB,GAAyBA,EAAE8kB,GAAGztB,EAA1B2I,EAAEklB,GAAG7uB,GAAGwuB,GAAGF,GAAExZ,SAAmB,IAAIke,EAAEhzB,EAAE+9B,0BAA0Bp+B,EAAE,oBAAoBqzB,GAAG,oBAAoB9sB,EAAE83B,0BAC9e,oBAAoB93B,EAAE23B,kCAAkC,oBAAoB33B,EAAE03B,4BAA4Bl0B,IAAIopB,GAAGC,IAAIppB,IAAIg0B,GAAG38B,EAAEkF,EAAEjF,EAAE0I,GAAGgrB,IAAG,EAAG5B,EAAE/xB,EAAEwT,cAActO,EAAEu3B,MAAM1K,EAAE+C,GAAG90B,EAAEC,EAAEiF,EAAEhF,GAAG,IAAI4pB,EAAE9pB,EAAEwT,cAAc9K,IAAIopB,GAAGC,IAAIjI,GAAGyD,GAAGzZ,SAAS6f,IAAI,oBAAoB3B,IAAI6J,GAAG77B,EAAEhB,EAAEgzB,EAAE/xB,GAAG6pB,EAAE9pB,EAAEwT,gBAAgB/K,EAAEkrB,IAAIyI,GAAGp8B,EAAEhB,EAAEyJ,EAAExI,EAAE8xB,EAAEjI,EAAEnhB,KAAI,IAAKhK,GAAG,oBAAoBuG,EAAE06B,4BAA4B,oBAAoB16B,EAAE26B,sBAAsB,oBAAoB36B,EAAE26B,qBAAqB36B,EAAE26B,oBAAoB5/B,EAAE6pB,EAAEnhB,GAAG,oBAAoBzD,EAAE06B,4BAC5f16B,EAAE06B,2BAA2B3/B,EAAE6pB,EAAEnhB,IAAI,oBAAoBzD,EAAE46B,qBAAqB9/B,EAAEsT,OAAO,GAAG,oBAAoBpO,EAAE83B,0BAA0Bh9B,EAAEsT,OAAO,QAAQ,oBAAoBpO,EAAE46B,oBAAoBp3B,IAAI3I,EAAE0wB,eAAesB,IAAIhyB,EAAEyT,gBAAgBxT,EAAEsT,OAAO,GAAG,oBAAoBpO,EAAE83B,yBAAyBt0B,IAAI3I,EAAE0wB,eAAesB,IAAIhyB,EAAEyT,gBAAgBxT,EAAEsT,OAAO,MAAMtT,EAAEywB,cAAcxwB,EAAED,EAAEwT,cAAcsW,GAAG5kB,EAAEzD,MAAMxB,EAAEiF,EAAEu3B,MAAM3S,EAAE5kB,EAAEkuB,QAAQzqB,EAAE1I,EAAEwI,IAAI,oBAAoBvD,EAAE46B,oBAAoBp3B,IAAI3I,EAAE0wB,eAAesB,IACjfhyB,EAAEyT,gBAAgBxT,EAAEsT,OAAO,GAAG,oBAAoBpO,EAAE83B,yBAAyBt0B,IAAI3I,EAAE0wB,eAAesB,IAAIhyB,EAAEyT,gBAAgBxT,EAAEsT,OAAO,MAAMrT,GAAE,EAAG,CAAC,OAAO8/B,GAAGhgC,EAAEC,EAAEhB,EAAEiB,EAAEE,EAAED,EAAE,CACnK,SAAS6/B,GAAGhgC,EAAEC,EAAEhB,EAAEiB,EAAEC,EAAEC,GAAGs/B,GAAG1/B,EAAEC,GAAG,IAAIkF,EAAE,KAAa,IAARlF,EAAEsT,OAAW,IAAIrT,IAAIiF,EAAE,OAAOhF,GAAGmuB,GAAGruB,EAAEhB,GAAE,GAAI6/B,GAAG9+B,EAAEC,EAAEG,GAAGF,EAAED,EAAE8R,UAAU2sB,GAAG3qB,QAAQ9T,EAAE,IAAI0I,EAAExD,GAAG,oBAAoBlG,EAAEg/B,yBAAyB,KAAK/9B,EAAE+I,SAAwI,OAA/HhJ,EAAEsT,OAAO,EAAE,OAAOvT,GAAGmF,GAAGlF,EAAE4T,MAAMue,GAAGnyB,EAAED,EAAE6T,MAAM,KAAKzT,GAAGH,EAAE4T,MAAMue,GAAGnyB,EAAE,KAAK0I,EAAEvI,IAAIw+B,GAAG5+B,EAAEC,EAAE0I,EAAEvI,GAAGH,EAAEwT,cAAcvT,EAAEw8B,MAAMv8B,GAAGmuB,GAAGruB,EAAEhB,GAAE,GAAWgB,EAAE4T,KAAK,CAAC,SAASosB,GAAGjgC,GAAG,IAAIC,EAAED,EAAE+R,UAAU9R,EAAEigC,eAAejS,GAAGjuB,EAAEC,EAAEigC,eAAejgC,EAAEigC,iBAAiBjgC,EAAEozB,SAASpzB,EAAEozB,SAASpF,GAAGjuB,EAAEC,EAAEozB,SAAQ,GAAIkC,GAAGv1B,EAAEC,EAAE8Y,cAAc,CAC5e,SAASonB,GAAGngC,EAAEC,EAAEhB,EAAEiB,EAAEC,GAAuC,OAApCywB,KAAKC,GAAG1wB,GAAGF,EAAEsT,OAAO,IAAIqrB,GAAG5+B,EAAEC,EAAEhB,EAAEiB,GAAUD,EAAE4T,KAAK,CAAC,IAaqLusB,GAAGC,GAAGC,GAAGC,GAb1LC,GAAG,CAAC9sB,WAAW,KAAKyc,YAAY,KAAKC,UAAU,GAAG,SAASqQ,GAAGzgC,GAAG,MAAM,CAACq/B,UAAUr/B,EAAEs/B,UAAU,KAAKC,YAAY,KAAK,CAClM,SAASmB,GAAG1gC,EAAEC,EAAEhB,GAAG,IAA0D0J,EAAtDzI,EAAED,EAAEgwB,aAAa9vB,EAAEy1B,GAAE7hB,QAAQ3T,GAAE,EAAG+E,EAAE,KAAa,IAARlF,EAAEsT,OAAqJ,IAAvI5K,EAAExD,KAAKwD,GAAE,OAAO3I,GAAG,OAAOA,EAAEyT,gBAAiB,KAAO,EAAFtT,IAASwI,GAAEvI,GAAE,EAAGH,EAAEsT,QAAQ,KAAY,OAAOvT,GAAG,OAAOA,EAAEyT,gBAActT,GAAG,GAAEktB,GAAEuI,GAAI,EAAFz1B,GAAQ,OAAOH,EAA2B,OAAxBuwB,GAAGtwB,GAAwB,QAArBD,EAAEC,EAAEwT,gBAA2C,QAAfzT,EAAEA,EAAE0T,aAA4B,KAAY,EAAPzT,EAAEqwB,MAAQrwB,EAAEizB,MAAM,EAAE,OAAOlzB,EAAEye,KAAKxe,EAAEizB,MAAM,EAAEjzB,EAAEizB,MAAM,WAAW,OAAK/tB,EAAEjF,EAAEyL,SAAS3L,EAAEE,EAAEygC,SAAgBvgC,GAAGF,EAAED,EAAEqwB,KAAKlwB,EAAEH,EAAE4T,MAAM1O,EAAE,CAACmrB,KAAK,SAAS3kB,SAASxG,GAAG,KAAO,EAAFjF,IAAM,OAAOE,GAAGA,EAAE0yB,WAAW,EAAE1yB,EAAE6vB,aAC7e9qB,GAAG/E,EAAEwgC,GAAGz7B,EAAEjF,EAAE,EAAE,MAAMF,EAAE8xB,GAAG9xB,EAAEE,EAAEjB,EAAE,MAAMmB,EAAEkT,OAAOrT,EAAED,EAAEsT,OAAOrT,EAAEG,EAAE0T,QAAQ9T,EAAEC,EAAE4T,MAAMzT,EAAEH,EAAE4T,MAAMJ,cAAcgtB,GAAGxhC,GAAGgB,EAAEwT,cAAc+sB,GAAGxgC,GAAG6gC,GAAG5gC,EAAEkF,IAAqB,GAAG,QAArBhF,EAAEH,EAAEyT,gBAA2C,QAAf9K,EAAExI,EAAEuT,YAAqB,OAGpM,SAAY1T,EAAEC,EAAEhB,EAAEiB,EAAEC,EAAEC,EAAE+E,GAAG,GAAGlG,EAAG,OAAW,IAARgB,EAAEsT,OAAiBtT,EAAEsT,QAAQ,IAAwButB,GAAG9gC,EAAEC,EAAEkF,EAA3BjF,EAAEs9B,GAAGl/B,MAAM4F,EAAE,SAAsB,OAAOjE,EAAEwT,eAAqBxT,EAAE4T,MAAM7T,EAAE6T,MAAM5T,EAAEsT,OAAO,IAAI,OAAKnT,EAAEF,EAAEygC,SAASxgC,EAAEF,EAAEqwB,KAAKpwB,EAAE0gC,GAAG,CAACtQ,KAAK,UAAU3kB,SAASzL,EAAEyL,UAAUxL,EAAE,EAAE,OAAMC,EAAE0xB,GAAG1xB,EAAED,EAAEgF,EAAE,OAAQoO,OAAO,EAAErT,EAAEoT,OAAOrT,EAAEG,EAAEkT,OAAOrT,EAAEC,EAAE4T,QAAQ1T,EAAEH,EAAE4T,MAAM3T,EAAE,KAAY,EAAPD,EAAEqwB,OAAS8B,GAAGnyB,EAAED,EAAE6T,MAAM,KAAK1O,GAAGlF,EAAE4T,MAAMJ,cAAcgtB,GAAGt7B,GAAGlF,EAAEwT,cAAc+sB,GAAUpgC,GAAE,GAAG,KAAY,EAAPH,EAAEqwB,MAAQ,OAAOwQ,GAAG9gC,EAAEC,EAAEkF,EAAE,MAAM,GAAG,OAAOhF,EAAEse,KAAK,CAChd,GADidve,EAAEC,EAAEilB,aAAajlB,EAAEilB,YAAY2b,QAC3e,IAAIp4B,EAAEzI,EAAE8gC,KAA0C,OAArC9gC,EAAEyI,EAA0Cm4B,GAAG9gC,EAAEC,EAAEkF,EAA/BjF,EAAEs9B,GAAlBp9B,EAAE9B,MAAM4F,EAAE,MAAahE,OAAE,GAA0B,CAAwB,GAAvByI,EAAE,KAAKxD,EAAEnF,EAAE8yB,YAAeK,IAAIxqB,EAAE,CAAK,GAAG,QAAPzI,EAAEu4B,IAAc,CAAC,OAAOtzB,GAAGA,GAAG,KAAK,EAAEhF,EAAE,EAAE,MAAM,KAAK,GAAGA,EAAE,EAAE,MAAM,KAAK,GAAG,KAAK,IAAI,KAAK,IAAI,KAAK,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,MAAM,KAAK,MAAM,KAAK,MAAM,KAAK,OAAO,KAAK,OAAO,KAAK,OAAO,KAAK,QAAQ,KAAK,QAAQ,KAAK,QAAQ,KAAK,QAAQ,KAAK,SAAS,KAAK,SAAS,KAAK,SAASA,EAAE,GAAG,MAAM,KAAK,UAAUA,EAAE,UAAU,MAAM,QAAQA,EAAE,EAChd,KADkdA,EAAE,KAAKA,GAAGD,EAAEoW,eAAenR,IAAI,EAAEhF,IAC5eA,IAAIC,EAAEgwB,YAAYhwB,EAAEgwB,UAAUjwB,EAAEwzB,GAAG3zB,EAAEG,GAAG44B,GAAG74B,EAAEF,EAAEG,GAAG,GAAG,CAA0B,OAAzB8gC,KAAgCH,GAAG9gC,EAAEC,EAAEkF,EAAlCjF,EAAEs9B,GAAGl/B,MAAM4F,EAAE,OAAyB,CAAC,MAAG,OAAO/D,EAAEse,MAAYxe,EAAEsT,OAAO,IAAItT,EAAE4T,MAAM7T,EAAE6T,MAAM5T,EAAEihC,GAAG/+B,KAAK,KAAKnC,GAAGG,EAAEghC,YAAYlhC,EAAE,OAAKD,EAAEI,EAAE+vB,YAAYT,GAAGjD,GAAGtsB,EAAEilB,aAAaqK,GAAGxvB,EAAE0vB,IAAE,EAAGC,GAAG,KAAK,OAAO5vB,IAAIgvB,GAAGC,MAAME,GAAGH,GAAGC,MAAMG,GAAGJ,GAAGC,MAAMC,GAAGC,GAAGnvB,EAAEga,GAAGoV,GAAGpvB,EAAEkwB,SAAShB,GAAGjvB,GAAGA,EAAE4gC,GAAG5gC,EAAEC,EAAEyL,UAAU1L,EAAEsT,OAAO,KAAYtT,EAAC,CALrKmhC,CAAGphC,EAAEC,EAAEkF,EAAEjF,EAAEyI,EAAExI,EAAElB,GAAG,GAAGmB,EAAE,CAACA,EAAEF,EAAEygC,SAASx7B,EAAElF,EAAEqwB,KAAe3nB,GAAVxI,EAAEH,EAAE6T,OAAUC,QAAQ,IAAIlL,EAAE,CAAC0nB,KAAK,SAAS3kB,SAASzL,EAAEyL,UAChF,OAD0F,KAAO,EAAFxG,IAAMlF,EAAE4T,QAAQ1T,IAAGD,EAAED,EAAE4T,OAAQif,WAAW,EAAE5yB,EAAE+vB,aAAarnB,EAAE3I,EAAE8vB,UAAU,OAAO7vB,EAAEuxB,GAAGtxB,EAAEyI,IAAKy4B,aAA4B,SAAflhC,EAAEkhC,aAAuB,OAAO14B,EAAEvI,EAAEqxB,GAAG9oB,EAAEvI,IAAIA,EAAE0xB,GAAG1xB,EAAE+E,EAAElG,EAAE,OAAQsU,OAAO,EAAGnT,EAAEkT,OACnfrT,EAAEC,EAAEoT,OAAOrT,EAAEC,EAAE4T,QAAQ1T,EAAEH,EAAE4T,MAAM3T,EAAEA,EAAEE,EAAEA,EAAEH,EAAE4T,MAA8B1O,EAAE,QAA1BA,EAAEnF,EAAE6T,MAAMJ,eAAyBgtB,GAAGxhC,GAAG,CAACogC,UAAUl6B,EAAEk6B,UAAUpgC,EAAEqgC,UAAU,KAAKC,YAAYp6B,EAAEo6B,aAAan/B,EAAEqT,cAActO,EAAE/E,EAAE0yB,WAAW9yB,EAAE8yB,YAAY7zB,EAAEgB,EAAEwT,cAAc+sB,GAAUtgC,CAAC,CAAoO,OAAzNF,GAAVI,EAAEJ,EAAE6T,OAAUC,QAAQ5T,EAAEuxB,GAAGrxB,EAAE,CAACkwB,KAAK,UAAU3kB,SAASzL,EAAEyL,WAAW,KAAY,EAAP1L,EAAEqwB,QAAUpwB,EAAEgzB,MAAMj0B,GAAGiB,EAAEoT,OAAOrT,EAAEC,EAAE4T,QAAQ,KAAK,OAAO9T,IAAkB,QAAdf,EAAEgB,EAAE8vB,YAAoB9vB,EAAE8vB,UAAU,CAAC/vB,GAAGC,EAAEsT,OAAO,IAAItU,EAAEP,KAAKsB,IAAIC,EAAE4T,MAAM3T,EAAED,EAAEwT,cAAc,KAAYvT,CAAC,CACnd,SAAS2gC,GAAG7gC,EAAEC,GAA8D,OAA3DA,EAAE2gC,GAAG,CAACtQ,KAAK,UAAU3kB,SAAS1L,GAAGD,EAAEswB,KAAK,EAAE,OAAQhd,OAAOtT,EAASA,EAAE6T,MAAM5T,CAAC,CAAC,SAAS6gC,GAAG9gC,EAAEC,EAAEhB,EAAEiB,GAAwG,OAArG,OAAOA,GAAG2wB,GAAG3wB,GAAGkyB,GAAGnyB,EAAED,EAAE6T,MAAM,KAAK5U,IAAGe,EAAE6gC,GAAG5gC,EAAEA,EAAEgwB,aAAatkB,WAAY4H,OAAO,EAAEtT,EAAEwT,cAAc,KAAYzT,CAAC,CAGkJ,SAASshC,GAAGthC,EAAEC,EAAEhB,GAAGe,EAAEkzB,OAAOjzB,EAAE,IAAIC,EAAEF,EAAEqT,UAAU,OAAOnT,IAAIA,EAAEgzB,OAAOjzB,GAAG4yB,GAAG7yB,EAAEsT,OAAOrT,EAAEhB,EAAE,CACxc,SAASsiC,GAAGvhC,EAAEC,EAAEhB,EAAEiB,EAAEC,GAAG,IAAIC,EAAEJ,EAAEyT,cAAc,OAAOrT,EAAEJ,EAAEyT,cAAc,CAAC+tB,YAAYvhC,EAAEwhC,UAAU,KAAKC,mBAAmB,EAAEC,KAAKzhC,EAAE0hC,KAAK3iC,EAAE4iC,SAAS1hC,IAAIC,EAAEohC,YAAYvhC,EAAEG,EAAEqhC,UAAU,KAAKrhC,EAAEshC,mBAAmB,EAAEthC,EAAEuhC,KAAKzhC,EAAEE,EAAEwhC,KAAK3iC,EAAEmB,EAAEyhC,SAAS1hC,EAAE,CAC3O,SAAS2hC,GAAG9hC,EAAEC,EAAEhB,GAAG,IAAIiB,EAAED,EAAEgwB,aAAa9vB,EAAED,EAAE41B,YAAY11B,EAAEF,EAAE0hC,KAAsC,GAAjChD,GAAG5+B,EAAEC,EAAEC,EAAEyL,SAAS1M,GAAkB,KAAO,GAAtBiB,EAAE01B,GAAE7hB,UAAqB7T,EAAI,EAAFA,EAAI,EAAED,EAAEsT,OAAO,QAAQ,CAAC,GAAG,OAAOvT,GAAG,KAAa,IAARA,EAAEuT,OAAWvT,EAAE,IAAIA,EAAEC,EAAE4T,MAAM,OAAO7T,GAAG,CAAC,GAAG,KAAKA,EAAEgJ,IAAI,OAAOhJ,EAAEyT,eAAe6tB,GAAGthC,EAAEf,EAAEgB,QAAQ,GAAG,KAAKD,EAAEgJ,IAAIs4B,GAAGthC,EAAEf,EAAEgB,QAAQ,GAAG,OAAOD,EAAE6T,MAAM,CAAC7T,EAAE6T,MAAMP,OAAOtT,EAAEA,EAAEA,EAAE6T,MAAM,QAAQ,CAAC,GAAG7T,IAAIC,EAAE,MAAMD,EAAE,KAAK,OAAOA,EAAE8T,SAAS,CAAC,GAAG,OAAO9T,EAAEsT,QAAQtT,EAAEsT,SAASrT,EAAE,MAAMD,EAAEA,EAAEA,EAAEsT,MAAM,CAACtT,EAAE8T,QAAQR,OAAOtT,EAAEsT,OAAOtT,EAAEA,EAAE8T,OAAO,CAAC5T,GAAG,CAAC,CAAQ,GAAPmtB,GAAEuI,GAAE11B,GAAM,KAAY,EAAPD,EAAEqwB,MAAQrwB,EAAEwT,cAC/e,UAAU,OAAOtT,GAAG,IAAK,WAAqB,IAAVlB,EAAEgB,EAAE4T,MAAU1T,EAAE,KAAK,OAAOlB,GAAiB,QAAde,EAAEf,EAAEoU,YAAoB,OAAOwiB,GAAG71B,KAAKG,EAAElB,GAAGA,EAAEA,EAAE6U,QAAY,QAAJ7U,EAAEkB,IAAYA,EAAEF,EAAE4T,MAAM5T,EAAE4T,MAAM,OAAO1T,EAAElB,EAAE6U,QAAQ7U,EAAE6U,QAAQ,MAAMytB,GAAGthC,GAAE,EAAGE,EAAElB,EAAEmB,GAAG,MAAM,IAAK,YAA6B,IAAjBnB,EAAE,KAAKkB,EAAEF,EAAE4T,MAAU5T,EAAE4T,MAAM,KAAK,OAAO1T,GAAG,CAAe,GAAG,QAAjBH,EAAEG,EAAEkT,YAAuB,OAAOwiB,GAAG71B,GAAG,CAACC,EAAE4T,MAAM1T,EAAE,KAAK,CAACH,EAAEG,EAAE2T,QAAQ3T,EAAE2T,QAAQ7U,EAAEA,EAAEkB,EAAEA,EAAEH,CAAC,CAACuhC,GAAGthC,GAAE,EAAGhB,EAAE,KAAKmB,GAAG,MAAM,IAAK,WAAWmhC,GAAGthC,GAAE,EAAG,KAAK,UAAK,GAAQ,MAAM,QAAQA,EAAEwT,cAAc,KAAK,OAAOxT,EAAE4T,KAAK,CAC7d,SAAS+rB,GAAG5/B,EAAEC,GAAG,KAAY,EAAPA,EAAEqwB,OAAS,OAAOtwB,IAAIA,EAAEqT,UAAU,KAAKpT,EAAEoT,UAAU,KAAKpT,EAAEsT,OAAO,EAAE,CAAC,SAASurB,GAAG9+B,EAAEC,EAAEhB,GAAyD,GAAtD,OAAOe,IAAIC,EAAE+yB,aAAahzB,EAAEgzB,cAAcgC,IAAI/0B,EAAEizB,MAAS,KAAKj0B,EAAEgB,EAAE6yB,YAAY,OAAO,KAAK,GAAG,OAAO9yB,GAAGC,EAAE4T,QAAQ7T,EAAE6T,MAAM,MAAMvV,MAAM4F,EAAE,MAAM,GAAG,OAAOjE,EAAE4T,MAAM,CAA4C,IAAjC5U,EAAEwyB,GAAZzxB,EAAEC,EAAE4T,MAAa7T,EAAEiwB,cAAchwB,EAAE4T,MAAM5U,EAAMA,EAAEqU,OAAOrT,EAAE,OAAOD,EAAE8T,SAAS9T,EAAEA,EAAE8T,SAAQ7U,EAAEA,EAAE6U,QAAQ2d,GAAGzxB,EAAEA,EAAEiwB,eAAgB3c,OAAOrT,EAAEhB,EAAE6U,QAAQ,IAAI,CAAC,OAAO7T,EAAE4T,KAAK,CAO9a,SAASkuB,GAAG/hC,EAAEC,GAAG,IAAI0vB,GAAE,OAAO3vB,EAAE6hC,UAAU,IAAK,SAAS5hC,EAAED,EAAE4hC,KAAK,IAAI,IAAI3iC,EAAE,KAAK,OAAOgB,GAAG,OAAOA,EAAEoT,YAAYpU,EAAEgB,GAAGA,EAAEA,EAAE6T,QAAQ,OAAO7U,EAAEe,EAAE4hC,KAAK,KAAK3iC,EAAE6U,QAAQ,KAAK,MAAM,IAAK,YAAY7U,EAAEe,EAAE4hC,KAAK,IAAI,IAAI1hC,EAAE,KAAK,OAAOjB,GAAG,OAAOA,EAAEoU,YAAYnT,EAAEjB,GAAGA,EAAEA,EAAE6U,QAAQ,OAAO5T,EAAED,GAAG,OAAOD,EAAE4hC,KAAK5hC,EAAE4hC,KAAK,KAAK5hC,EAAE4hC,KAAK9tB,QAAQ,KAAK5T,EAAE4T,QAAQ,KAAK,CAC5U,SAASkuB,GAAEhiC,GAAG,IAAIC,EAAE,OAAOD,EAAEqT,WAAWrT,EAAEqT,UAAUQ,QAAQ7T,EAAE6T,MAAM5U,EAAE,EAAEiB,EAAE,EAAE,GAAGD,EAAE,IAAI,IAAIE,EAAEH,EAAE6T,MAAM,OAAO1T,GAAGlB,GAAGkB,EAAE+yB,MAAM/yB,EAAE2yB,WAAW5yB,GAAkB,SAAfC,EAAEkhC,aAAsBnhC,GAAW,SAARC,EAAEoT,MAAepT,EAAEmT,OAAOtT,EAAEG,EAAEA,EAAE2T,aAAa,IAAI3T,EAAEH,EAAE6T,MAAM,OAAO1T,GAAGlB,GAAGkB,EAAE+yB,MAAM/yB,EAAE2yB,WAAW5yB,GAAGC,EAAEkhC,aAAanhC,GAAGC,EAAEoT,MAAMpT,EAAEmT,OAAOtT,EAAEG,EAAEA,EAAE2T,QAAyC,OAAjC9T,EAAEqhC,cAAcnhC,EAAEF,EAAE8yB,WAAW7zB,EAASgB,CAAC,CAC7V,SAASgiC,GAAGjiC,EAAEC,EAAEhB,GAAG,IAAIiB,EAAED,EAAEgwB,aAAmB,OAANT,GAAGvvB,GAAUA,EAAE+I,KAAK,KAAK,EAAE,KAAK,GAAG,KAAK,GAAG,KAAK,EAAE,KAAK,GAAG,KAAK,EAAE,KAAK,EAAE,KAAK,GAAG,KAAK,EAAE,KAAK,GAAG,OAAOg5B,GAAE/hC,GAAG,KAAK,KAAK,EAUtD,KAAK,GAAG,OAAO6tB,GAAG7tB,EAAEZ,OAAO2uB,KAAKgU,GAAE/hC,GAAG,KAVqD,KAAK,EAA2Q,OAAzQC,EAAED,EAAE8R,UAAU0jB,KAAKrI,GAAEI,IAAIJ,GAAEG,IAAGyI,KAAK91B,EAAEggC,iBAAiBhgC,EAAEmzB,QAAQnzB,EAAEggC,eAAehgC,EAAEggC,eAAe,MAAS,OAAOlgC,GAAG,OAAOA,EAAE6T,QAAM4c,GAAGxwB,GAAGA,EAAEsT,OAAO,EAAE,OAAOvT,GAAGA,EAAEyT,cAAcqF,cAAc,KAAa,IAAR7Y,EAAEsT,SAAatT,EAAEsT,OAAO,KAAK,OAAOqc,KAAKsS,GAAGtS,IAAIA,GAAG,QAAOyQ,GAAGrgC,EAAEC,GAAG+hC,GAAE/hC,GAAU,KAAK,KAAK,EAAE01B,GAAG11B,GAAG,IAAIE,EAAEm1B,GAAGD,GAAGthB,SAC7e,GAAT9U,EAAEgB,EAAEZ,KAAQ,OAAOW,GAAG,MAAMC,EAAE8R,UAAUuuB,GAAGtgC,EAAEC,EAAEhB,EAAEiB,EAAEC,GAAGH,EAAEgxB,MAAM/wB,EAAE+wB,MAAM/wB,EAAEsT,OAAO,IAAItT,EAAEsT,OAAO,aAAa,CAAC,IAAIrT,EAAE,CAAC,GAAG,OAAOD,EAAE8R,UAAU,MAAMzT,MAAM4F,EAAE,MAAW,OAAL89B,GAAE/hC,GAAU,IAAI,CAAkB,GAAjBD,EAAEs1B,GAAGH,GAAGphB,SAAY0c,GAAGxwB,GAAG,CAACC,EAAED,EAAE8R,UAAU9S,EAAEgB,EAAEZ,KAAK,IAAIe,EAAEH,EAAEywB,cAA+C,OAAjCxwB,EAAE2sB,IAAI5sB,EAAEC,EAAE4sB,IAAI1sB,EAAEJ,EAAE,KAAY,EAAPC,EAAEqwB,MAAerxB,GAAG,IAAK,SAASoqB,GAAE,SAASnpB,GAAGmpB,GAAE,QAAQnpB,GAAG,MAAM,IAAK,SAAS,IAAK,SAAS,IAAK,QAAQmpB,GAAE,OAAOnpB,GAAG,MAAM,IAAK,QAAQ,IAAK,QAAQ,IAAIC,EAAE,EAAEA,EAAE4oB,GAAG7sB,OAAOiE,IAAIkpB,GAAEN,GAAG5oB,GAAGD,GAAG,MAAM,IAAK,SAASmpB,GAAE,QAAQnpB,GAAG,MAAM,IAAK,MAAM,IAAK,QAAQ,IAAK,OAAOmpB,GAAE,QACnhBnpB,GAAGmpB,GAAE,OAAOnpB,GAAG,MAAM,IAAK,UAAUmpB,GAAE,SAASnpB,GAAG,MAAM,IAAK,QAAQ0K,EAAG1K,EAAEE,GAAGipB,GAAE,UAAUnpB,GAAG,MAAM,IAAK,SAASA,EAAEwK,cAAc,CAACy3B,cAAc/hC,EAAEgiC,UAAU/Y,GAAE,UAAUnpB,GAAG,MAAM,IAAK,WAAW0L,GAAG1L,EAAEE,GAAGipB,GAAE,UAAUnpB,GAAkB,IAAI,IAAIiF,KAAvB+L,GAAGjS,EAAEmB,GAAGD,EAAE,KAAkBC,EAAE,GAAGA,EAAErG,eAAeoL,GAAG,CAAC,IAAIwD,EAAEvI,EAAE+E,GAAG,aAAaA,EAAE,kBAAkBwD,EAAEzI,EAAE6L,cAAcpD,KAAI,IAAKvI,EAAEiiC,0BAA0B/W,GAAGprB,EAAE6L,YAAYpD,EAAE3I,GAAGG,EAAE,CAAC,WAAWwI,IAAI,kBAAkBA,GAAGzI,EAAE6L,cAAc,GAAGpD,KAAI,IAAKvI,EAAEiiC,0BAA0B/W,GAAGprB,EAAE6L,YAC1epD,EAAE3I,GAAGG,EAAE,CAAC,WAAW,GAAGwI,IAAIrE,EAAGvK,eAAeoL,IAAI,MAAMwD,GAAG,aAAaxD,GAAGkkB,GAAE,SAASnpB,EAAE,CAAC,OAAOjB,GAAG,IAAK,QAAQ0K,EAAGzJ,GAAGgL,EAAGhL,EAAEE,GAAE,GAAI,MAAM,IAAK,WAAWuJ,EAAGzJ,GAAG4L,GAAG5L,GAAG,MAAM,IAAK,SAAS,IAAK,SAAS,MAAM,QAAQ,oBAAoBE,EAAEkiC,UAAUpiC,EAAEqiC,QAAQhX,IAAIrrB,EAAEC,EAAEF,EAAE6zB,YAAY5zB,EAAE,OAAOA,IAAID,EAAEsT,OAAO,EAAE,KAAK,CAACpO,EAAE,IAAIhF,EAAE2M,SAAS3M,EAAEA,EAAEgL,cAAc,iCAAiCnL,IAAIA,EAAEgM,GAAG/M,IAAI,iCAAiCe,EAAE,WAAWf,IAAGe,EAAEmF,EAAEN,cAAc,QAASwH,UAAU,qBAAuBrM,EAAEA,EAAEwM,YAAYxM,EAAEuM,aAC/f,kBAAkBrM,EAAEkR,GAAGpR,EAAEmF,EAAEN,cAAc5F,EAAE,CAACmS,GAAGlR,EAAEkR,MAAMpR,EAAEmF,EAAEN,cAAc5F,GAAG,WAAWA,IAAIkG,EAAEnF,EAAEE,EAAEkiC,SAASj9B,EAAEi9B,UAAS,EAAGliC,EAAEsiC,OAAOr9B,EAAEq9B,KAAKtiC,EAAEsiC,QAAQxiC,EAAEmF,EAAEs9B,gBAAgBziC,EAAEf,GAAGe,EAAE6sB,IAAI5sB,EAAED,EAAE8sB,IAAI5sB,EAAEkgC,GAAGpgC,EAAEC,GAAE,GAAG,GAAIA,EAAE8R,UAAU/R,EAAEA,EAAE,CAAW,OAAVmF,EAAEgM,GAAGlS,EAAEiB,GAAUjB,GAAG,IAAK,SAASoqB,GAAE,SAASrpB,GAAGqpB,GAAE,QAAQrpB,GAAGG,EAAED,EAAE,MAAM,IAAK,SAAS,IAAK,SAAS,IAAK,QAAQmpB,GAAE,OAAOrpB,GAAGG,EAAED,EAAE,MAAM,IAAK,QAAQ,IAAK,QAAQ,IAAIC,EAAE,EAAEA,EAAE4oB,GAAG7sB,OAAOiE,IAAIkpB,GAAEN,GAAG5oB,GAAGH,GAAGG,EAAED,EAAE,MAAM,IAAK,SAASmpB,GAAE,QAAQrpB,GAAGG,EAAED,EAAE,MAAM,IAAK,MAAM,IAAK,QAAQ,IAAK,OAAOmpB,GAAE,QAClfrpB,GAAGqpB,GAAE,OAAOrpB,GAAGG,EAAED,EAAE,MAAM,IAAK,UAAUmpB,GAAE,SAASrpB,GAAGG,EAAED,EAAE,MAAM,IAAK,QAAQ0K,EAAG5K,EAAEE,GAAGC,EAAEoK,EAAGvK,EAAEE,GAAGmpB,GAAE,UAAUrpB,GAAG,MAAM,IAAK,SAAiL,QAAQG,EAAED,QAAxK,IAAK,SAASF,EAAE0K,cAAc,CAACy3B,cAAcjiC,EAAEkiC,UAAUjiC,EAAE6H,EAAE,CAAC,EAAE9H,EAAE,CAAC7E,WAAM,IAASguB,GAAE,UAAUrpB,GAAG,MAAM,IAAK,WAAW4L,GAAG5L,EAAEE,GAAGC,EAAEsL,GAAGzL,EAAEE,GAAGmpB,GAAE,UAAUrpB,GAAiC,IAAII,KAAhB8Q,GAAGjS,EAAEkB,GAAGwI,EAAExI,EAAa,GAAGwI,EAAE5O,eAAeqG,GAAG,CAAC,IAAIwI,EAAED,EAAEvI,GAAG,UAAUA,EAAE0P,GAAG9P,EAAE4I,GAAG,4BAA4BxI,EAAuB,OAApBwI,EAAEA,EAAEA,EAAE+iB,YAAO,IAAgBxf,GAAGnM,EAAE4I,GAAI,aAAaxI,EAAE,kBAAkBwI,GAAG,aAC7e3J,GAAG,KAAK2J,IAAIgE,GAAG5M,EAAE4I,GAAG,kBAAkBA,GAAGgE,GAAG5M,EAAE,GAAG4I,GAAG,mCAAmCxI,GAAG,6BAA6BA,GAAG,cAAcA,IAAIkE,EAAGvK,eAAeqG,GAAG,MAAMwI,GAAG,aAAaxI,GAAGipB,GAAE,SAASrpB,GAAG,MAAM4I,GAAG3C,EAAGjG,EAAEI,EAAEwI,EAAEzD,GAAG,CAAC,OAAOlG,GAAG,IAAK,QAAQ0K,EAAG3J,GAAGkL,EAAGlL,EAAEE,GAAE,GAAI,MAAM,IAAK,WAAWyJ,EAAG3J,GAAG8L,GAAG9L,GAAG,MAAM,IAAK,SAAS,MAAME,EAAE7E,OAAO2E,EAAEwG,aAAa,QAAQ,GAAGgD,EAAGtJ,EAAE7E,QAAQ,MAAM,IAAK,SAAS2E,EAAEoiC,WAAWliC,EAAEkiC,SAAmB,OAAVhiC,EAAEF,EAAE7E,OAAcgQ,GAAGrL,IAAIE,EAAEkiC,SAAShiC,GAAE,GAAI,MAAMF,EAAEuK,cAAcY,GAAGrL,IAAIE,EAAEkiC,SAASliC,EAAEuK,cAClf,GAAI,MAAM,QAAQ,oBAAoBtK,EAAEmiC,UAAUtiC,EAAEuiC,QAAQhX,IAAI,OAAOtsB,GAAG,IAAK,SAAS,IAAK,QAAQ,IAAK,SAAS,IAAK,WAAWiB,IAAIA,EAAEwiC,UAAU,MAAM1iC,EAAE,IAAK,MAAME,GAAE,EAAG,MAAMF,EAAE,QAAQE,GAAE,EAAG,CAACA,IAAID,EAAEsT,OAAO,EAAE,CAAC,OAAOtT,EAAE+wB,MAAM/wB,EAAEsT,OAAO,IAAItT,EAAEsT,OAAO,QAAQ,CAAM,OAALyuB,GAAE/hC,GAAU,KAAK,KAAK,EAAE,GAAGD,GAAG,MAAMC,EAAE8R,UAAUwuB,GAAGvgC,EAAEC,EAAED,EAAE0wB,cAAcxwB,OAAO,CAAC,GAAG,kBAAkBA,GAAG,OAAOD,EAAE8R,UAAU,MAAMzT,MAAM4F,EAAE,MAAsC,GAAhCjF,EAAEq2B,GAAGD,GAAGthB,SAASuhB,GAAGH,GAAGphB,SAAY0c,GAAGxwB,GAAG,CAAyC,GAAxCC,EAAED,EAAE8R,UAAU9S,EAAEgB,EAAEywB,cAAcxwB,EAAE2sB,IAAI5sB,GAAKG,EAAEF,EAAE6M,YAAY9N,IAC/e,QADofe,EACvfyvB,IAAY,OAAOzvB,EAAEgJ,KAAK,KAAK,EAAEsiB,GAAGprB,EAAE6M,UAAU9N,EAAE,KAAY,EAAPe,EAAEswB,OAAS,MAAM,KAAK,GAAE,IAAKtwB,EAAE0wB,cAAc2R,0BAA0B/W,GAAGprB,EAAE6M,UAAU9N,EAAE,KAAY,EAAPe,EAAEswB,OAASlwB,IAAIH,EAAEsT,OAAO,EAAE,MAAMrT,GAAG,IAAIjB,EAAE6N,SAAS7N,EAAEA,EAAEkM,eAAew3B,eAAeziC,IAAK2sB,IAAI5sB,EAAEA,EAAE8R,UAAU7R,CAAC,CAAM,OAAL8hC,GAAE/hC,GAAU,KAAK,KAAK,GAA0B,GAAvBmtB,GAAEwI,IAAG11B,EAAED,EAAEwT,cAAiB,OAAOzT,GAAG,OAAOA,EAAEyT,eAAe,OAAOzT,EAAEyT,cAAcC,WAAW,CAAC,GAAGic,IAAG,OAAOD,IAAI,KAAY,EAAPzvB,EAAEqwB,OAAS,KAAa,IAARrwB,EAAEsT,OAAWod,KAAKC,KAAK3wB,EAAEsT,OAAO,MAAMnT,GAAE,OAAQ,GAAGA,EAAEqwB,GAAGxwB,GAAG,OAAOC,GAAG,OAAOA,EAAEwT,WAAW,CAAC,GAAG,OAC5f1T,EAAE,CAAC,IAAII,EAAE,MAAM9B,MAAM4F,EAAE,MAAqD,KAA7B9D,EAAE,QAApBA,EAAEH,EAAEwT,eAAyBrT,EAAEsT,WAAW,MAAW,MAAMpV,MAAM4F,EAAE,MAAM9D,EAAEysB,IAAI5sB,CAAC,MAAM2wB,KAAK,KAAa,IAAR3wB,EAAEsT,SAAatT,EAAEwT,cAAc,MAAMxT,EAAEsT,OAAO,EAAEyuB,GAAE/hC,GAAGG,GAAE,CAAE,MAAM,OAAOwvB,KAAKsS,GAAGtS,IAAIA,GAAG,MAAMxvB,GAAE,EAAG,IAAIA,EAAE,OAAe,MAARH,EAAEsT,MAAYtT,EAAE,IAAI,CAAC,OAAG,KAAa,IAARA,EAAEsT,QAAkBtT,EAAEizB,MAAMj0B,EAAEgB,KAAEC,EAAE,OAAOA,MAAO,OAAOF,GAAG,OAAOA,EAAEyT,gBAAgBvT,IAAID,EAAE4T,MAAMN,OAAO,KAAK,KAAY,EAAPtT,EAAEqwB,QAAU,OAAOtwB,GAAG,KAAe,EAAV41B,GAAE7hB,SAAW,IAAI6uB,KAAIA,GAAE,GAAG3B,OAAO,OAAOhhC,EAAE6zB,cAAc7zB,EAAEsT,OAAO,GAAGyuB,GAAE/hC,GAAU,MAAK,KAAK,EAAE,OAAOw1B,KACrf4K,GAAGrgC,EAAEC,GAAG,OAAOD,GAAG4pB,GAAG3pB,EAAE8R,UAAUgH,eAAeipB,GAAE/hC,GAAG,KAAK,KAAK,GAAG,OAAO0yB,GAAG1yB,EAAEZ,KAAK+J,UAAU44B,GAAE/hC,GAAG,KAA+C,KAAK,GAA0B,GAAvBmtB,GAAEwI,IAAwB,QAArBx1B,EAAEH,EAAEwT,eAA0B,OAAOuuB,GAAE/hC,GAAG,KAAuC,GAAlCC,EAAE,KAAa,IAARD,EAAEsT,OAA4B,QAAjBpO,EAAE/E,EAAEqhC,WAAsB,GAAGvhC,EAAE6hC,GAAG3hC,GAAE,OAAQ,CAAC,GAAG,IAAIwiC,IAAG,OAAO5iC,GAAG,KAAa,IAARA,EAAEuT,OAAW,IAAIvT,EAAEC,EAAE4T,MAAM,OAAO7T,GAAG,CAAS,GAAG,QAAXmF,EAAE0wB,GAAG71B,IAAe,CAAmG,IAAlGC,EAAEsT,OAAO,IAAIwuB,GAAG3hC,GAAE,GAAoB,QAAhBF,EAAEiF,EAAE2uB,eAAuB7zB,EAAE6zB,YAAY5zB,EAAED,EAAEsT,OAAO,GAAGtT,EAAEohC,aAAa,EAAEnhC,EAAEjB,EAAMA,EAAEgB,EAAE4T,MAAM,OAAO5U,GAAOe,EAAEE,GAANE,EAAEnB,GAAQsU,OAAO,SAC/d,QAAdpO,EAAE/E,EAAEiT,YAAoBjT,EAAE0yB,WAAW,EAAE1yB,EAAE8yB,MAAMlzB,EAAEI,EAAEyT,MAAM,KAAKzT,EAAEihC,aAAa,EAAEjhC,EAAEswB,cAAc,KAAKtwB,EAAEqT,cAAc,KAAKrT,EAAE0zB,YAAY,KAAK1zB,EAAE4yB,aAAa,KAAK5yB,EAAE2R,UAAU,OAAO3R,EAAE0yB,WAAW3tB,EAAE2tB,WAAW1yB,EAAE8yB,MAAM/tB,EAAE+tB,MAAM9yB,EAAEyT,MAAM1O,EAAE0O,MAAMzT,EAAEihC,aAAa,EAAEjhC,EAAE2vB,UAAU,KAAK3vB,EAAEswB,cAAcvrB,EAAEurB,cAActwB,EAAEqT,cAActO,EAAEsO,cAAcrT,EAAE0zB,YAAY3uB,EAAE2uB,YAAY1zB,EAAEf,KAAK8F,EAAE9F,KAAKW,EAAEmF,EAAE6tB,aAAa5yB,EAAE4yB,aAAa,OAAOhzB,EAAE,KAAK,CAACkzB,MAAMlzB,EAAEkzB,MAAMD,aAAajzB,EAAEizB,eAAeh0B,EAAEA,EAAE6U,QAA2B,OAAnBuZ,GAAEuI,GAAY,EAAVA,GAAE7hB,QAAU,GAAU9T,EAAE4T,KAAK,CAAC7T,EAClgBA,EAAE8T,OAAO,CAAC,OAAO1T,EAAEwhC,MAAMltB,KAAImuB,KAAK5iC,EAAEsT,OAAO,IAAIrT,GAAE,EAAG6hC,GAAG3hC,GAAE,GAAIH,EAAEizB,MAAM,QAAQ,KAAK,CAAC,IAAIhzB,EAAE,GAAW,QAARF,EAAE61B,GAAG1wB,KAAa,GAAGlF,EAAEsT,OAAO,IAAIrT,GAAE,EAAmB,QAAhBjB,EAAEe,EAAE8zB,eAAuB7zB,EAAE6zB,YAAY70B,EAAEgB,EAAEsT,OAAO,GAAGwuB,GAAG3hC,GAAE,GAAI,OAAOA,EAAEwhC,MAAM,WAAWxhC,EAAEyhC,WAAW18B,EAAEkO,YAAYsc,GAAE,OAAOqS,GAAE/hC,GAAG,UAAU,EAAEyU,KAAItU,EAAEshC,mBAAmBmB,IAAI,aAAa5jC,IAAIgB,EAAEsT,OAAO,IAAIrT,GAAE,EAAG6hC,GAAG3hC,GAAE,GAAIH,EAAEizB,MAAM,SAAS9yB,EAAEohC,aAAar8B,EAAE2O,QAAQ7T,EAAE4T,MAAM5T,EAAE4T,MAAM1O,IAAa,QAATlG,EAAEmB,EAAEuhC,MAAc1iC,EAAE6U,QAAQ3O,EAAElF,EAAE4T,MAAM1O,EAAE/E,EAAEuhC,KAAKx8B,EAAE,CAAC,OAAG,OAAO/E,EAAEwhC,MAAY3hC,EAAEG,EAAEwhC,KAAKxhC,EAAEqhC,UAC9exhC,EAAEG,EAAEwhC,KAAK3hC,EAAE6T,QAAQ1T,EAAEshC,mBAAmBhtB,KAAIzU,EAAE6T,QAAQ,KAAK7U,EAAE22B,GAAE7hB,QAAQsZ,GAAEuI,GAAE11B,EAAI,EAAFjB,EAAI,EAAI,EAAFA,GAAKgB,IAAE+hC,GAAE/hC,GAAU,MAAK,KAAK,GAAG,KAAK,GAAG,OAAO6iC,KAAK5iC,EAAE,OAAOD,EAAEwT,cAAc,OAAOzT,GAAG,OAAOA,EAAEyT,gBAAgBvT,IAAID,EAAEsT,OAAO,MAAMrT,GAAG,KAAY,EAAPD,EAAEqwB,MAAQ,KAAQ,WAAHmP,MAAiBuC,GAAE/hC,GAAkB,EAAfA,EAAEohC,eAAiBphC,EAAEsT,OAAO,OAAOyuB,GAAE/hC,GAAG,KAAK,KAAK,GAAe,KAAK,GAAG,OAAO,KAAK,MAAM3B,MAAM4F,EAAE,IAAIjE,EAAE+I,KAAM,CAClX,SAAS+5B,GAAG/iC,EAAEC,GAAS,OAANuvB,GAAGvvB,GAAUA,EAAE+I,KAAK,KAAK,EAAE,OAAO8kB,GAAG7tB,EAAEZ,OAAO2uB,KAAiB,OAAZhuB,EAAEC,EAAEsT,QAAetT,EAAEsT,OAAS,MAAHvT,EAAS,IAAIC,GAAG,KAAK,KAAK,EAAE,OAAOw1B,KAAKrI,GAAEI,IAAIJ,GAAEG,IAAGyI,KAAe,KAAO,OAAjBh2B,EAAEC,EAAEsT,SAAqB,KAAO,IAAFvT,IAAQC,EAAEsT,OAAS,MAAHvT,EAAS,IAAIC,GAAG,KAAK,KAAK,EAAE,OAAO01B,GAAG11B,GAAG,KAAK,KAAK,GAA0B,GAAvBmtB,GAAEwI,IAAwB,QAArB51B,EAAEC,EAAEwT,gBAA2B,OAAOzT,EAAE0T,WAAW,CAAC,GAAG,OAAOzT,EAAEoT,UAAU,MAAM/U,MAAM4F,EAAE,MAAM0sB,IAAI,CAAW,OAAS,OAAnB5wB,EAAEC,EAAEsT,QAAsBtT,EAAEsT,OAAS,MAAHvT,EAAS,IAAIC,GAAG,KAAK,KAAK,GAAG,OAAOmtB,GAAEwI,IAAG,KAAK,KAAK,EAAE,OAAOH,KAAK,KAAK,KAAK,GAAG,OAAO9C,GAAG1yB,EAAEZ,KAAK+J,UAAU,KAAK,KAAK,GAAG,KAAK,GAAG,OAAO05B,KAC1gB,KAAyB,QAAQ,OAAO,KAAK,CArB7C1C,GAAG,SAASpgC,EAAEC,GAAG,IAAI,IAAIhB,EAAEgB,EAAE4T,MAAM,OAAO5U,GAAG,CAAC,GAAG,IAAIA,EAAE+J,KAAK,IAAI/J,EAAE+J,IAAIhJ,EAAEyM,YAAYxN,EAAE8S,gBAAgB,GAAG,IAAI9S,EAAE+J,KAAK,OAAO/J,EAAE4U,MAAM,CAAC5U,EAAE4U,MAAMP,OAAOrU,EAAEA,EAAEA,EAAE4U,MAAM,QAAQ,CAAC,GAAG5U,IAAIgB,EAAE,MAAM,KAAK,OAAOhB,EAAE6U,SAAS,CAAC,GAAG,OAAO7U,EAAEqU,QAAQrU,EAAEqU,SAASrT,EAAE,OAAOhB,EAAEA,EAAEqU,MAAM,CAACrU,EAAE6U,QAAQR,OAAOrU,EAAEqU,OAAOrU,EAAEA,EAAE6U,OAAO,CAAC,EAAEusB,GAAG,WAAW,EACxTC,GAAG,SAAStgC,EAAEC,EAAEhB,EAAEiB,GAAG,IAAIC,EAAEH,EAAE0wB,cAAc,GAAGvwB,IAAID,EAAE,CAACF,EAAEC,EAAE8R,UAAUujB,GAAGH,GAAGphB,SAAS,IAA4R5O,EAAxR/E,EAAE,KAAK,OAAOnB,GAAG,IAAK,QAAQkB,EAAEoK,EAAGvK,EAAEG,GAAGD,EAAEqK,EAAGvK,EAAEE,GAAGE,EAAE,GAAG,MAAM,IAAK,SAASD,EAAE6H,EAAE,CAAC,EAAE7H,EAAE,CAAC9E,WAAM,IAAS6E,EAAE8H,EAAE,CAAC,EAAE9H,EAAE,CAAC7E,WAAM,IAAS+E,EAAE,GAAG,MAAM,IAAK,WAAWD,EAAEsL,GAAGzL,EAAEG,GAAGD,EAAEuL,GAAGzL,EAAEE,GAAGE,EAAE,GAAG,MAAM,QAAQ,oBAAoBD,EAAEmiC,SAAS,oBAAoBpiC,EAAEoiC,UAAUtiC,EAAEuiC,QAAQhX,IAAyB,IAAI7iB,KAAzBwI,GAAGjS,EAAEiB,GAASjB,EAAE,KAAckB,EAAE,IAAID,EAAEnG,eAAe2O,IAAIvI,EAAEpG,eAAe2O,IAAI,MAAMvI,EAAEuI,GAAG,GAAG,UAAUA,EAAE,CAAC,IAAIC,EAAExI,EAAEuI,GAAG,IAAIvD,KAAKwD,EAAEA,EAAE5O,eAAeoL,KACjflG,IAAIA,EAAE,CAAC,GAAGA,EAAEkG,GAAG,GAAG,KAAK,4BAA4BuD,GAAG,aAAaA,GAAG,mCAAmCA,GAAG,6BAA6BA,GAAG,cAAcA,IAAIpE,EAAGvK,eAAe2O,GAAGtI,IAAIA,EAAE,KAAKA,EAAEA,GAAG,IAAI1B,KAAKgK,EAAE,OAAO,IAAIA,KAAKxI,EAAE,CAAC,IAAI0I,EAAE1I,EAAEwI,GAAyB,GAAtBC,EAAE,MAAMxI,EAAEA,EAAEuI,QAAG,EAAUxI,EAAEnG,eAAe2O,IAAIE,IAAID,IAAI,MAAMC,GAAG,MAAMD,GAAG,GAAG,UAAUD,EAAE,GAAGC,EAAE,CAAC,IAAIxD,KAAKwD,GAAGA,EAAE5O,eAAeoL,IAAIyD,GAAGA,EAAE7O,eAAeoL,KAAKlG,IAAIA,EAAE,CAAC,GAAGA,EAAEkG,GAAG,IAAI,IAAIA,KAAKyD,EAAEA,EAAE7O,eAAeoL,IAAIwD,EAAExD,KAAKyD,EAAEzD,KAAKlG,IAAIA,EAAE,CAAC,GAAGA,EAAEkG,GAAGyD,EAAEzD,GAAG,MAAMlG,IAAImB,IAAIA,EAAE,IAAIA,EAAE1B,KAAKgK,EACpfzJ,IAAIA,EAAE2J,MAAM,4BAA4BF,GAAGE,EAAEA,EAAEA,EAAE+iB,YAAO,EAAOhjB,EAAEA,EAAEA,EAAEgjB,YAAO,EAAO,MAAM/iB,GAAGD,IAAIC,IAAIxI,EAAEA,GAAG,IAAI1B,KAAKgK,EAAEE,IAAI,aAAaF,EAAE,kBAAkBE,GAAG,kBAAkBA,IAAIxI,EAAEA,GAAG,IAAI1B,KAAKgK,EAAE,GAAGE,GAAG,mCAAmCF,GAAG,6BAA6BA,IAAIpE,EAAGvK,eAAe2O,IAAI,MAAME,GAAG,aAAaF,GAAG2gB,GAAE,SAASrpB,GAAGI,GAAGuI,IAAIC,IAAIxI,EAAE,MAAMA,EAAEA,GAAG,IAAI1B,KAAKgK,EAAEE,GAAG,CAAC3J,IAAImB,EAAEA,GAAG,IAAI1B,KAAK,QAAQO,GAAG,IAAIyJ,EAAEtI,GAAKH,EAAE6zB,YAAYprB,KAAEzI,EAAEsT,OAAO,EAAC,CAAC,EAAEgtB,GAAG,SAASvgC,EAAEC,EAAEhB,EAAEiB,GAAGjB,IAAIiB,IAAID,EAAEsT,OAAO,EAAE,EAkBlb,IAAIyvB,IAAG,EAAGC,IAAE,EAAGC,GAAG,oBAAoBC,QAAQA,QAAQ9+B,IAAI++B,GAAE,KAAK,SAASC,GAAGrjC,EAAEC,GAAG,IAAIhB,EAAEe,EAAEgxB,IAAI,GAAG,OAAO/xB,EAAE,GAAG,oBAAoBA,EAAE,IAAIA,EAAE,KAAK,CAAC,MAAMiB,GAAGojC,GAAEtjC,EAAEC,EAAEC,EAAE,MAAMjB,EAAE8U,QAAQ,IAAI,CAAC,SAASwvB,GAAGvjC,EAAEC,EAAEhB,GAAG,IAAIA,GAAG,CAAC,MAAMiB,GAAGojC,GAAEtjC,EAAEC,EAAEC,EAAE,CAAC,CAAC,IAAIsjC,IAAG,EAIxR,SAASC,GAAGzjC,EAAEC,EAAEhB,GAAG,IAAIiB,EAAED,EAAE6zB,YAAyC,GAAG,QAAhC5zB,EAAE,OAAOA,EAAEA,EAAEy4B,WAAW,MAAiB,CAAC,IAAIx4B,EAAED,EAAEA,EAAEgyB,KAAK,EAAE,CAAC,IAAI/xB,EAAE6I,IAAIhJ,KAAKA,EAAE,CAAC,IAAII,EAAED,EAAEg5B,QAAQh5B,EAAEg5B,aAAQ,OAAO,IAAS/4B,GAAGmjC,GAAGtjC,EAAEhB,EAAEmB,EAAE,CAACD,EAAEA,EAAE+xB,IAAI,OAAO/xB,IAAID,EAAE,CAAC,CAAC,SAASwjC,GAAG1jC,EAAEC,GAAgD,GAAG,QAAhCA,EAAE,QAAlBA,EAAEA,EAAE6zB,aAAuB7zB,EAAE04B,WAAW,MAAiB,CAAC,IAAI15B,EAAEgB,EAAEA,EAAEiyB,KAAK,EAAE,CAAC,IAAIjzB,EAAE+J,IAAIhJ,KAAKA,EAAE,CAAC,IAAIE,EAAEjB,EAAEi6B,OAAOj6B,EAAEk6B,QAAQj5B,GAAG,CAACjB,EAAEA,EAAEizB,IAAI,OAAOjzB,IAAIgB,EAAE,CAAC,CAAC,SAAS0jC,GAAG3jC,GAAG,IAAIC,EAAED,EAAEgxB,IAAI,GAAG,OAAO/wB,EAAE,CAAC,IAAIhB,EAAEe,EAAE+R,UAAiB/R,EAAEgJ,IAA8BhJ,EAAEf,EAAE,oBAAoBgB,EAAEA,EAAED,GAAGC,EAAE8T,QAAQ/T,CAAC,CAAC,CAClf,SAAS4jC,GAAG5jC,GAAG,IAAIC,EAAED,EAAEqT,UAAU,OAAOpT,IAAID,EAAEqT,UAAU,KAAKuwB,GAAG3jC,IAAID,EAAE6T,MAAM,KAAK7T,EAAE+vB,UAAU,KAAK/vB,EAAE8T,QAAQ,KAAK,IAAI9T,EAAEgJ,MAAoB,QAAd/I,EAAED,EAAE+R,oBAA4B9R,EAAE4sB,WAAW5sB,EAAE6sB,WAAW7sB,EAAEqpB,WAAWrpB,EAAE8sB,WAAW9sB,EAAE+sB,MAAMhtB,EAAE+R,UAAU,KAAK/R,EAAEsT,OAAO,KAAKtT,EAAEgzB,aAAa,KAAKhzB,EAAE0wB,cAAc,KAAK1wB,EAAEyT,cAAc,KAAKzT,EAAEiwB,aAAa,KAAKjwB,EAAE+R,UAAU,KAAK/R,EAAE8zB,YAAY,IAAI,CAAC,SAAS+P,GAAG7jC,GAAG,OAAO,IAAIA,EAAEgJ,KAAK,IAAIhJ,EAAEgJ,KAAK,IAAIhJ,EAAEgJ,GAAG,CACna,SAAS86B,GAAG9jC,GAAGA,EAAE,OAAO,CAAC,KAAK,OAAOA,EAAE8T,SAAS,CAAC,GAAG,OAAO9T,EAAEsT,QAAQuwB,GAAG7jC,EAAEsT,QAAQ,OAAO,KAAKtT,EAAEA,EAAEsT,MAAM,CAA2B,IAA1BtT,EAAE8T,QAAQR,OAAOtT,EAAEsT,OAAWtT,EAAEA,EAAE8T,QAAQ,IAAI9T,EAAEgJ,KAAK,IAAIhJ,EAAEgJ,KAAK,KAAKhJ,EAAEgJ,KAAK,CAAC,GAAW,EAARhJ,EAAEuT,MAAQ,SAASvT,EAAE,GAAG,OAAOA,EAAE6T,OAAO,IAAI7T,EAAEgJ,IAAI,SAAShJ,EAAOA,EAAE6T,MAAMP,OAAOtT,EAAEA,EAAEA,EAAE6T,KAAK,CAAC,KAAa,EAAR7T,EAAEuT,OAAS,OAAOvT,EAAE+R,SAAS,CAAC,CACzT,SAASgyB,GAAG/jC,EAAEC,EAAEhB,GAAG,IAAIiB,EAAEF,EAAEgJ,IAAI,GAAG,IAAI9I,GAAG,IAAIA,EAAEF,EAAEA,EAAE+R,UAAU9R,EAAE,IAAIhB,EAAE6N,SAAS7N,EAAEwS,WAAWuyB,aAAahkC,EAAEC,GAAGhB,EAAE+kC,aAAahkC,EAAEC,IAAI,IAAIhB,EAAE6N,UAAU7M,EAAEhB,EAAEwS,YAAauyB,aAAahkC,EAAEf,IAAKgB,EAAEhB,GAAIwN,YAAYzM,GAA4B,QAAxBf,EAAEA,EAAEglC,2BAA8B,IAAShlC,GAAG,OAAOgB,EAAEsiC,UAAUtiC,EAAEsiC,QAAQhX,UAAU,GAAG,IAAIrrB,GAAc,QAAVF,EAAEA,EAAE6T,OAAgB,IAAIkwB,GAAG/jC,EAAEC,EAAEhB,GAAGe,EAAEA,EAAE8T,QAAQ,OAAO9T,GAAG+jC,GAAG/jC,EAAEC,EAAEhB,GAAGe,EAAEA,EAAE8T,OAAO,CAC1X,SAASowB,GAAGlkC,EAAEC,EAAEhB,GAAG,IAAIiB,EAAEF,EAAEgJ,IAAI,GAAG,IAAI9I,GAAG,IAAIA,EAAEF,EAAEA,EAAE+R,UAAU9R,EAAEhB,EAAE+kC,aAAahkC,EAAEC,GAAGhB,EAAEwN,YAAYzM,QAAQ,GAAG,IAAIE,GAAc,QAAVF,EAAEA,EAAE6T,OAAgB,IAAIqwB,GAAGlkC,EAAEC,EAAEhB,GAAGe,EAAEA,EAAE8T,QAAQ,OAAO9T,GAAGkkC,GAAGlkC,EAAEC,EAAEhB,GAAGe,EAAEA,EAAE8T,OAAO,CAAC,IAAIqwB,GAAE,KAAKC,IAAG,EAAG,SAASC,GAAGrkC,EAAEC,EAAEhB,GAAG,IAAIA,EAAEA,EAAE4U,MAAM,OAAO5U,GAAGqlC,GAAGtkC,EAAEC,EAAEhB,GAAGA,EAAEA,EAAE6U,OAAO,CACnR,SAASwwB,GAAGtkC,EAAEC,EAAEhB,GAAG,GAAGwW,IAAI,oBAAoBA,GAAG8uB,qBAAqB,IAAI9uB,GAAG8uB,qBAAqB/uB,GAAGvW,EAAE,CAAC,MAAM0J,GAAG,CAAC,OAAO1J,EAAE+J,KAAK,KAAK,EAAEi6B,IAAGI,GAAGpkC,EAAEgB,GAAG,KAAK,EAAE,IAAIC,EAAEikC,GAAEhkC,EAAEikC,GAAGD,GAAE,KAAKE,GAAGrkC,EAAEC,EAAEhB,GAAOmlC,GAAGjkC,EAAE,QAATgkC,GAAEjkC,KAAkBkkC,IAAIpkC,EAAEmkC,GAAEllC,EAAEA,EAAE8S,UAAU,IAAI/R,EAAE8M,SAAS9M,EAAEyR,WAAWjF,YAAYvN,GAAGe,EAAEwM,YAAYvN,IAAIklC,GAAE33B,YAAYvN,EAAE8S,YAAY,MAAM,KAAK,GAAG,OAAOoyB,KAAIC,IAAIpkC,EAAEmkC,GAAEllC,EAAEA,EAAE8S,UAAU,IAAI/R,EAAE8M,SAAS0f,GAAGxsB,EAAEyR,WAAWxS,GAAG,IAAIe,EAAE8M,UAAU0f,GAAGxsB,EAAEf,GAAGsa,GAAGvZ,IAAIwsB,GAAG2X,GAAEllC,EAAE8S,YAAY,MAAM,KAAK,EAAE7R,EAAEikC,GAAEhkC,EAAEikC,GAAGD,GAAEllC,EAAE8S,UAAUgH,cAAcqrB,IAAG,EAClfC,GAAGrkC,EAAEC,EAAEhB,GAAGklC,GAAEjkC,EAAEkkC,GAAGjkC,EAAE,MAAM,KAAK,EAAE,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,IAAI8iC,KAAoB,QAAhB/iC,EAAEjB,EAAE60B,cAAsC,QAAf5zB,EAAEA,EAAEy4B,aAAsB,CAACx4B,EAAED,EAAEA,EAAEgyB,KAAK,EAAE,CAAC,IAAI9xB,EAAED,EAAEgF,EAAE/E,EAAE+4B,QAAQ/4B,EAAEA,EAAE4I,SAAI,IAAS7D,IAAI,KAAO,EAAF/E,IAAe,KAAO,EAAFA,KAAfmjC,GAAGtkC,EAAEgB,EAAEkF,GAAyBhF,EAAEA,EAAE+xB,IAAI,OAAO/xB,IAAID,EAAE,CAACmkC,GAAGrkC,EAAEC,EAAEhB,GAAG,MAAM,KAAK,EAAE,IAAIgkC,KAAII,GAAGpkC,EAAEgB,GAAiB,oBAAdC,EAAEjB,EAAE8S,WAAgCyyB,sBAAsB,IAAItkC,EAAEwB,MAAMzC,EAAEyxB,cAAcxwB,EAAEw8B,MAAMz9B,EAAEwU,cAAcvT,EAAEskC,sBAAsB,CAAC,MAAM77B,GAAG26B,GAAErkC,EAAEgB,EAAE0I,EAAE,CAAC07B,GAAGrkC,EAAEC,EAAEhB,GAAG,MAAM,KAAK,GAAGolC,GAAGrkC,EAAEC,EAAEhB,GAAG,MAAM,KAAK,GAAU,EAAPA,EAAEqxB,MAAQ2S,IAAG/iC,EAAE+iC,KAAI,OAChfhkC,EAAEwU,cAAc4wB,GAAGrkC,EAAEC,EAAEhB,GAAGgkC,GAAE/iC,GAAGmkC,GAAGrkC,EAAEC,EAAEhB,GAAG,MAAM,QAAQolC,GAAGrkC,EAAEC,EAAEhB,GAAG,CAAC,SAASwlC,GAAGzkC,GAAG,IAAIC,EAAED,EAAE8zB,YAAY,GAAG,OAAO7zB,EAAE,CAACD,EAAE8zB,YAAY,KAAK,IAAI70B,EAAEe,EAAE+R,UAAU,OAAO9S,IAAIA,EAAEe,EAAE+R,UAAU,IAAImxB,IAAIjjC,EAAEe,SAAQ,SAASf,GAAG,IAAIC,EAAEwkC,GAAGviC,KAAK,KAAKnC,EAAEC,GAAGhB,EAAEsqB,IAAItpB,KAAKhB,EAAEwF,IAAIxE,GAAGA,EAAEosB,KAAKnsB,EAAEA,GAAG,GAAE,CAAC,CACzQ,SAASykC,GAAG3kC,EAAEC,GAAG,IAAIhB,EAAEgB,EAAE8vB,UAAU,GAAG,OAAO9wB,EAAE,IAAI,IAAIiB,EAAE,EAAEA,EAAEjB,EAAE/C,OAAOgE,IAAI,CAAC,IAAIC,EAAElB,EAAEiB,GAAG,IAAI,IAAIE,EAAEJ,EAAEmF,EAAElF,EAAE0I,EAAExD,EAAEnF,EAAE,KAAK,OAAO2I,GAAG,CAAC,OAAOA,EAAEK,KAAK,KAAK,EAAEm7B,GAAEx7B,EAAEoJ,UAAUqyB,IAAG,EAAG,MAAMpkC,EAAE,KAAK,EAA4C,KAAK,EAAEmkC,GAAEx7B,EAAEoJ,UAAUgH,cAAcqrB,IAAG,EAAG,MAAMpkC,EAAE2I,EAAEA,EAAE2K,MAAM,CAAC,GAAG,OAAO6wB,GAAE,MAAM7lC,MAAM4F,EAAE,MAAMogC,GAAGlkC,EAAE+E,EAAEhF,GAAGgkC,GAAE,KAAKC,IAAG,EAAG,IAAIx7B,EAAEzI,EAAEkT,UAAU,OAAOzK,IAAIA,EAAE0K,OAAO,MAAMnT,EAAEmT,OAAO,IAAI,CAAC,MAAM5K,GAAG46B,GAAEnjC,EAAEF,EAAEyI,EAAE,CAAC,CAAC,GAAkB,MAAfzI,EAAEohC,aAAmB,IAAIphC,EAAEA,EAAE4T,MAAM,OAAO5T,GAAG2kC,GAAG3kC,EAAED,GAAGC,EAAEA,EAAE6T,OAAO,CACje,SAAS8wB,GAAG5kC,EAAEC,GAAG,IAAIhB,EAAEe,EAAEqT,UAAUnT,EAAEF,EAAEuT,MAAM,OAAOvT,EAAEgJ,KAAK,KAAK,EAAE,KAAK,GAAG,KAAK,GAAG,KAAK,GAAiB,GAAd27B,GAAG1kC,EAAED,GAAG6kC,GAAG7kC,GAAQ,EAAFE,EAAI,CAAC,IAAIujC,GAAG,EAAEzjC,EAAEA,EAAEsT,QAAQowB,GAAG,EAAE1jC,EAAE,CAAC,MAAMgqB,GAAGsZ,GAAEtjC,EAAEA,EAAEsT,OAAO0W,EAAE,CAAC,IAAIyZ,GAAG,EAAEzjC,EAAEA,EAAEsT,OAAO,CAAC,MAAM0W,GAAGsZ,GAAEtjC,EAAEA,EAAEsT,OAAO0W,EAAE,CAAC,CAAC,MAAM,KAAK,EAAE2a,GAAG1kC,EAAED,GAAG6kC,GAAG7kC,GAAK,IAAFE,GAAO,OAAOjB,GAAGokC,GAAGpkC,EAAEA,EAAEqU,QAAQ,MAAM,KAAK,EAAgD,GAA9CqxB,GAAG1kC,EAAED,GAAG6kC,GAAG7kC,GAAK,IAAFE,GAAO,OAAOjB,GAAGokC,GAAGpkC,EAAEA,EAAEqU,QAAmB,GAARtT,EAAEuT,MAAS,CAAC,IAAIpT,EAAEH,EAAE+R,UAAU,IAAInF,GAAGzM,EAAE,GAAG,CAAC,MAAM6pB,GAAGsZ,GAAEtjC,EAAEA,EAAEsT,OAAO0W,EAAE,CAAC,CAAC,GAAK,EAAF9pB,GAAoB,OAAdC,EAAEH,EAAE+R,WAAmB,CAAC,IAAI3R,EAAEJ,EAAE0wB,cAAcvrB,EAAE,OAAOlG,EAAEA,EAAEyxB,cAActwB,EAAEuI,EAAE3I,EAAEX,KAAKuJ,EAAE5I,EAAE8zB,YACje,GAAnB9zB,EAAE8zB,YAAY,KAAQ,OAAOlrB,EAAE,IAAI,UAAUD,GAAG,UAAUvI,EAAEf,MAAM,MAAMe,EAAElF,MAAM6P,EAAG5K,EAAEC,GAAG+Q,GAAGxI,EAAExD,GAAG,IAAIuD,EAAEyI,GAAGxI,EAAEvI,GAAG,IAAI+E,EAAE,EAAEA,EAAEyD,EAAE1M,OAAOiJ,GAAG,EAAE,CAAC,IAAIvG,EAAEgK,EAAEzD,GAAG4sB,EAAEnpB,EAAEzD,EAAE,GAAG,UAAUvG,EAAEkR,GAAG3P,EAAE4xB,GAAG,4BAA4BnzB,EAAEuN,GAAGhM,EAAE4xB,GAAG,aAAanzB,EAAEgO,GAAGzM,EAAE4xB,GAAG9rB,EAAG9F,EAAEvB,EAAEmzB,EAAErpB,EAAE,CAAC,OAAOC,GAAG,IAAK,QAAQqC,EAAG7K,EAAEC,GAAG,MAAM,IAAK,WAAWyL,GAAG1L,EAAEC,GAAG,MAAM,IAAK,SAAS,IAAI4xB,EAAE7xB,EAAEuK,cAAcy3B,YAAYhiC,EAAEuK,cAAcy3B,cAAc/hC,EAAEgiC,SAAS,IAAInQ,EAAE7xB,EAAE/E,MAAM,MAAM42B,EAAE5mB,GAAGlL,IAAIC,EAAEgiC,SAASnQ,GAAE,GAAID,MAAM5xB,EAAEgiC,WAAW,MAAMhiC,EAAEqK,aAAaY,GAAGlL,IAAIC,EAAEgiC,SACnfhiC,EAAEqK,cAAa,GAAIY,GAAGlL,IAAIC,EAAEgiC,SAAShiC,EAAEgiC,SAAS,GAAG,IAAG,IAAKjiC,EAAE2sB,IAAI1sB,CAAC,CAAC,MAAM4pB,GAAGsZ,GAAEtjC,EAAEA,EAAEsT,OAAO0W,EAAE,CAAC,CAAC,MAAM,KAAK,EAAgB,GAAd2a,GAAG1kC,EAAED,GAAG6kC,GAAG7kC,GAAQ,EAAFE,EAAI,CAAC,GAAG,OAAOF,EAAE+R,UAAU,MAAMzT,MAAM4F,EAAE,MAAM/D,EAAEH,EAAE+R,UAAU3R,EAAEJ,EAAE0wB,cAAc,IAAIvwB,EAAE4M,UAAU3M,CAAC,CAAC,MAAM4pB,GAAGsZ,GAAEtjC,EAAEA,EAAEsT,OAAO0W,EAAE,CAAC,CAAC,MAAM,KAAK,EAAgB,GAAd2a,GAAG1kC,EAAED,GAAG6kC,GAAG7kC,GAAQ,EAAFE,GAAK,OAAOjB,GAAGA,EAAEwU,cAAcqF,aAAa,IAAIS,GAAGtZ,EAAE8Y,cAAc,CAAC,MAAMiR,GAAGsZ,GAAEtjC,EAAEA,EAAEsT,OAAO0W,EAAE,CAAC,MAAM,KAAK,EAG4G,QAAQ2a,GAAG1kC,EACnfD,GAAG6kC,GAAG7kC,SAJ4Y,KAAK,GAAG2kC,GAAG1kC,EAAED,GAAG6kC,GAAG7kC,GAAqB,MAAlBG,EAAEH,EAAE6T,OAAQN,QAAanT,EAAE,OAAOD,EAAEsT,cAActT,EAAE4R,UAAU+yB,SAAS1kC,GAAGA,GAClf,OAAOD,EAAEkT,WAAW,OAAOlT,EAAEkT,UAAUI,gBAAgBsxB,GAAGrwB,OAAQ,EAAFxU,GAAKukC,GAAGzkC,GAAG,MAAM,KAAK,GAAsF,GAAnFpB,EAAE,OAAOK,GAAG,OAAOA,EAAEwU,cAAqB,EAAPzT,EAAEswB,MAAQ2S,IAAGv6B,EAAEu6B,KAAIrkC,EAAE+lC,GAAG1kC,EAAED,GAAGijC,GAAEv6B,GAAGi8B,GAAG1kC,EAAED,GAAG6kC,GAAG7kC,GAAQ,KAAFE,EAAO,CAA0B,GAAzBwI,EAAE,OAAO1I,EAAEyT,eAAkBzT,EAAE+R,UAAU+yB,SAASp8B,KAAK9J,GAAG,KAAY,EAAPoB,EAAEswB,MAAQ,IAAI8S,GAAEpjC,EAAEpB,EAAEoB,EAAE6T,MAAM,OAAOjV,GAAG,CAAC,IAAImzB,EAAEqR,GAAExkC,EAAE,OAAOwkC,IAAG,CAAe,OAAVnR,GAAJD,EAAEoR,IAAMvvB,MAAame,EAAEhpB,KAAK,KAAK,EAAE,KAAK,GAAG,KAAK,GAAG,KAAK,GAAGy6B,GAAG,EAAEzR,EAAEA,EAAE1e,QAAQ,MAAM,KAAK,EAAE+vB,GAAGrR,EAAEA,EAAE1e,QAAQ,IAAIyW,EAAEiI,EAAEjgB,UAAU,GAAG,oBAAoBgY,EAAEya,qBAAqB,CAACtkC,EAAE8xB,EAAE/yB,EAAE+yB,EAAE1e,OAAO,IAAIrT,EAAEC,EAAE6pB,EAAEroB,MACpfzB,EAAEywB,cAAc3G,EAAE2S,MAAMz8B,EAAEwT,cAAcsW,EAAEya,sBAAsB,CAAC,MAAMxa,GAAGsZ,GAAEpjC,EAAEjB,EAAE+qB,EAAE,CAAC,CAAC,MAAM,KAAK,EAAEqZ,GAAGrR,EAAEA,EAAE1e,QAAQ,MAAM,KAAK,GAAG,GAAG,OAAO0e,EAAEve,cAAc,CAACuxB,GAAGjT,GAAG,QAAQ,EAAE,OAAOE,GAAGA,EAAE3e,OAAO0e,EAAEoR,GAAEnR,GAAG+S,GAAGjT,EAAE,CAACnzB,EAAEA,EAAEkV,OAAO,CAAC9T,EAAE,IAAIpB,EAAE,KAAKmzB,EAAE/xB,IAAI,CAAC,GAAG,IAAI+xB,EAAE/oB,KAAK,GAAG,OAAOpK,EAAE,CAACA,EAAEmzB,EAAE,IAAI5xB,EAAE4xB,EAAEhgB,UAAUrJ,EAAa,oBAAVtI,EAAED,EAAEnD,OAA4BjC,YAAYqF,EAAErF,YAAY,UAAU,OAAO,aAAaqF,EAAE6kC,QAAQ,QAASt8B,EAAEopB,EAAEhgB,UAAkC5M,OAAE,KAA1ByD,EAAEmpB,EAAErB,cAAc1zB,QAAoB,OAAO4L,GAAGA,EAAE7O,eAAe,WAAW6O,EAAEq8B,QAAQ,KAAKt8B,EAAE3L,MAAMioC,QACzfp1B,GAAG,UAAU1K,GAAG,CAAC,MAAM6kB,GAAGsZ,GAAEtjC,EAAEA,EAAEsT,OAAO0W,EAAE,CAAC,OAAO,GAAG,IAAI+H,EAAE/oB,KAAK,GAAG,OAAOpK,EAAE,IAAImzB,EAAEhgB,UAAUhF,UAAUrE,EAAE,GAAGqpB,EAAErB,aAAa,CAAC,MAAM1G,GAAGsZ,GAAEtjC,EAAEA,EAAEsT,OAAO0W,EAAE,OAAO,IAAI,KAAK+H,EAAE/oB,KAAK,KAAK+oB,EAAE/oB,KAAK,OAAO+oB,EAAEte,eAAese,IAAI/xB,IAAI,OAAO+xB,EAAEle,MAAM,CAACke,EAAEle,MAAMP,OAAOye,EAAEA,EAAEA,EAAEle,MAAM,QAAQ,CAAC,GAAGke,IAAI/xB,EAAE,MAAMA,EAAE,KAAK,OAAO+xB,EAAEje,SAAS,CAAC,GAAG,OAAOie,EAAEze,QAAQye,EAAEze,SAAStT,EAAE,MAAMA,EAAEpB,IAAImzB,IAAInzB,EAAE,MAAMmzB,EAAEA,EAAEze,MAAM,CAAC1U,IAAImzB,IAAInzB,EAAE,MAAMmzB,EAAEje,QAAQR,OAAOye,EAAEze,OAAOye,EAAEA,EAAEje,OAAO,CAAC,CAAC,MAAM,KAAK,GAAG6wB,GAAG1kC,EAAED,GAAG6kC,GAAG7kC,GAAK,EAAFE,GAAKukC,GAAGzkC,GAAS,KAAK,IACtd,CAAC,SAAS6kC,GAAG7kC,GAAG,IAAIC,EAAED,EAAEuT,MAAM,GAAK,EAAFtT,EAAI,CAAC,IAAID,EAAE,CAAC,IAAI,IAAIf,EAAEe,EAAEsT,OAAO,OAAOrU,GAAG,CAAC,GAAG4kC,GAAG5kC,GAAG,CAAC,IAAIiB,EAAEjB,EAAE,MAAMe,CAAC,CAACf,EAAEA,EAAEqU,MAAM,CAAC,MAAMhV,MAAM4F,EAAE,KAAM,CAAC,OAAOhE,EAAE8I,KAAK,KAAK,EAAE,IAAI7I,EAAED,EAAE6R,UAAkB,GAAR7R,EAAEqT,QAAW3G,GAAGzM,EAAE,IAAID,EAAEqT,QAAQ,IAAgB2wB,GAAGlkC,EAAT8jC,GAAG9jC,GAAUG,GAAG,MAAM,KAAK,EAAE,KAAK,EAAE,IAAIgF,EAAEjF,EAAE6R,UAAUgH,cAAsBgrB,GAAG/jC,EAAT8jC,GAAG9jC,GAAUmF,GAAG,MAAM,QAAQ,MAAM7G,MAAM4F,EAAE,MAAO,CAAC,MAAM0E,GAAG06B,GAAEtjC,EAAEA,EAAEsT,OAAO1K,EAAE,CAAC5I,EAAEuT,QAAQ,CAAC,CAAG,KAAFtT,IAASD,EAAEuT,QAAQ,KAAK,CAAC,SAAS2xB,GAAGllC,EAAEC,EAAEhB,GAAGmkC,GAAEpjC,EAAEmlC,GAAGnlC,EAAEC,EAAEhB,EAAE,CACvb,SAASkmC,GAAGnlC,EAAEC,EAAEhB,GAAG,IAAI,IAAIiB,EAAE,KAAY,EAAPF,EAAEswB,MAAQ,OAAO8S,IAAG,CAAC,IAAIjjC,EAAEijC,GAAEhjC,EAAED,EAAE0T,MAAM,GAAG,KAAK1T,EAAE6I,KAAK9I,EAAE,CAAC,IAAIiF,EAAE,OAAOhF,EAAEsT,eAAeuvB,GAAG,IAAI79B,EAAE,CAAC,IAAIwD,EAAExI,EAAEkT,UAAUzK,EAAE,OAAOD,GAAG,OAAOA,EAAE8K,eAAewvB,GAAEt6B,EAAEq6B,GAAG,IAAIt6B,EAAEu6B,GAAO,GAALD,GAAG79B,GAAM89B,GAAEr6B,KAAKF,EAAE,IAAI06B,GAAEjjC,EAAE,OAAOijC,IAAOx6B,GAAJzD,EAAEi+B,IAAMvvB,MAAM,KAAK1O,EAAE6D,KAAK,OAAO7D,EAAEsO,cAAc2xB,GAAGjlC,GAAG,OAAOyI,GAAGA,EAAE0K,OAAOnO,EAAEi+B,GAAEx6B,GAAGw8B,GAAGjlC,GAAG,KAAK,OAAOC,GAAGgjC,GAAEhjC,EAAE+kC,GAAG/kC,EAAEH,EAAEhB,GAAGmB,EAAEA,EAAE0T,QAAQsvB,GAAEjjC,EAAE6iC,GAAGr6B,EAAEs6B,GAAEv6B,CAAC,CAAC28B,GAAGrlC,EAAM,MAAM,KAAoB,KAAfG,EAAEkhC,eAAoB,OAAOjhC,GAAGA,EAAEkT,OAAOnT,EAAEijC,GAAEhjC,GAAGilC,GAAGrlC,EAAM,CAAC,CACvc,SAASqlC,GAAGrlC,GAAG,KAAK,OAAOojC,IAAG,CAAC,IAAInjC,EAAEmjC,GAAE,GAAG,KAAa,KAARnjC,EAAEsT,OAAY,CAAC,IAAItU,EAAEgB,EAAEoT,UAAU,IAAI,GAAG,KAAa,KAARpT,EAAEsT,OAAY,OAAOtT,EAAE+I,KAAK,KAAK,EAAE,KAAK,GAAG,KAAK,GAAGi6B,IAAGS,GAAG,EAAEzjC,GAAG,MAAM,KAAK,EAAE,IAAIC,EAAED,EAAE8R,UAAU,GAAW,EAAR9R,EAAEsT,QAAU0vB,GAAE,GAAG,OAAOhkC,EAAEiB,EAAEk9B,wBAAwB,CAAC,IAAIj9B,EAAEF,EAAEsD,cAActD,EAAEZ,KAAKJ,EAAEyxB,cAAckL,GAAG37B,EAAEZ,KAAKJ,EAAEyxB,eAAexwB,EAAE6/B,mBAAmB5/B,EAAElB,EAAEwU,cAAcvT,EAAEolC,oCAAoC,CAAC,IAAIllC,EAAEH,EAAE6zB,YAAY,OAAO1zB,GAAG60B,GAAGh1B,EAAEG,EAAEF,GAAG,MAAM,KAAK,EAAE,IAAIiF,EAAElF,EAAE6zB,YAAY,GAAG,OAAO3uB,EAAE,CAAQ,GAAPlG,EAAE,KAAQ,OAAOgB,EAAE4T,MAAM,OAAO5T,EAAE4T,MAAM7K,KAAK,KAAK,EACvf,KAAK,EAAE/J,EAAEgB,EAAE4T,MAAM9B,UAAUkjB,GAAGh1B,EAAEkF,EAAElG,EAAE,CAAC,MAAM,KAAK,EAAE,IAAI0J,EAAE1I,EAAE8R,UAAU,GAAG,OAAO9S,GAAW,EAARgB,EAAEsT,MAAQ,CAACtU,EAAE0J,EAAE,IAAIC,EAAE3I,EAAEywB,cAAc,OAAOzwB,EAAEZ,MAAM,IAAK,SAAS,IAAK,QAAQ,IAAK,SAAS,IAAK,WAAWuJ,EAAE85B,WAAWzjC,EAAEooB,QAAQ,MAAM,IAAK,MAAMze,EAAEhN,MAAMqD,EAAErD,IAAIgN,EAAEhN,KAAK,CAAC,MAAM,KAAK,EAAQ,KAAK,EAAQ,KAAK,GAAyJ,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,MAAhM,KAAK,GAAG,GAAG,OAAOqE,EAAEwT,cAAc,CAAC,IAAI/K,EAAEzI,EAAEoT,UAAU,GAAG,OAAO3K,EAAE,CAAC,IAAI9J,EAAE8J,EAAE+K,cAAc,GAAG,OAAO7U,EAAE,CAAC,IAAImzB,EAAEnzB,EAAE8U,WAAW,OAAOqe,GAAGxY,GAAGwY,EAAE,CAAC,CAAC,CAAC,MAC5c,QAAQ,MAAMzzB,MAAM4F,EAAE,MAAO++B,IAAW,IAARhjC,EAAEsT,OAAWowB,GAAG1jC,EAAE,CAAC,MAAM+xB,GAAGsR,GAAErjC,EAAEA,EAAEqT,OAAO0e,EAAE,CAAC,CAAC,GAAG/xB,IAAID,EAAE,CAACojC,GAAE,KAAK,KAAK,CAAa,GAAG,QAAfnkC,EAAEgB,EAAE6T,SAAoB,CAAC7U,EAAEqU,OAAOrT,EAAEqT,OAAO8vB,GAAEnkC,EAAE,KAAK,CAACmkC,GAAEnjC,EAAEqT,MAAM,CAAC,CAAC,SAAS0xB,GAAGhlC,GAAG,KAAK,OAAOojC,IAAG,CAAC,IAAInjC,EAAEmjC,GAAE,GAAGnjC,IAAID,EAAE,CAACojC,GAAE,KAAK,KAAK,CAAC,IAAInkC,EAAEgB,EAAE6T,QAAQ,GAAG,OAAO7U,EAAE,CAACA,EAAEqU,OAAOrT,EAAEqT,OAAO8vB,GAAEnkC,EAAE,KAAK,CAACmkC,GAAEnjC,EAAEqT,MAAM,CAAC,CACvS,SAAS8xB,GAAGplC,GAAG,KAAK,OAAOojC,IAAG,CAAC,IAAInjC,EAAEmjC,GAAE,IAAI,OAAOnjC,EAAE+I,KAAK,KAAK,EAAE,KAAK,GAAG,KAAK,GAAG,IAAI/J,EAAEgB,EAAEqT,OAAO,IAAIowB,GAAG,EAAEzjC,EAAE,CAAC,MAAM2I,GAAG06B,GAAErjC,EAAEhB,EAAE2J,EAAE,CAAC,MAAM,KAAK,EAAE,IAAI1I,EAAED,EAAE8R,UAAU,GAAG,oBAAoB7R,EAAEk9B,kBAAkB,CAAC,IAAIj9B,EAAEF,EAAEqT,OAAO,IAAIpT,EAAEk9B,mBAAmB,CAAC,MAAMx0B,GAAG06B,GAAErjC,EAAEE,EAAEyI,EAAE,CAAC,CAAC,IAAIxI,EAAEH,EAAEqT,OAAO,IAAIqwB,GAAG1jC,EAAE,CAAC,MAAM2I,GAAG06B,GAAErjC,EAAEG,EAAEwI,EAAE,CAAC,MAAM,KAAK,EAAE,IAAIzD,EAAElF,EAAEqT,OAAO,IAAIqwB,GAAG1jC,EAAE,CAAC,MAAM2I,GAAG06B,GAAErjC,EAAEkF,EAAEyD,EAAE,EAAE,CAAC,MAAMA,GAAG06B,GAAErjC,EAAEA,EAAEqT,OAAO1K,EAAE,CAAC,GAAG3I,IAAID,EAAE,CAACojC,GAAE,KAAK,KAAK,CAAC,IAAIz6B,EAAE1I,EAAE6T,QAAQ,GAAG,OAAOnL,EAAE,CAACA,EAAE2K,OAAOrT,EAAEqT,OAAO8vB,GAAEz6B,EAAE,KAAK,CAACy6B,GAAEnjC,EAAEqT,MAAM,CAAC,CAC7d,IAwBkNiyB,GAxB9MC,GAAG7vB,KAAK8vB,KAAKC,GAAG/+B,EAAGwvB,uBAAuBwP,GAAGh/B,EAAGg4B,kBAAkBiH,GAAGj/B,EAAG8S,wBAAwBmb,GAAE,EAAE6D,GAAE,KAAKoN,GAAE,KAAKC,GAAE,EAAErG,GAAG,EAAED,GAAGrS,GAAG,GAAGyV,GAAE,EAAEmD,GAAG,KAAK/Q,GAAG,EAAEgR,GAAG,EAAEC,GAAG,EAAEC,GAAG,KAAKC,GAAG,KAAKpB,GAAG,EAAElC,GAAGuD,IAASC,GAAG,KAAKvI,IAAG,EAAGC,GAAG,KAAKI,GAAG,KAAKmI,IAAG,EAAGC,GAAG,KAAKC,GAAG,EAAEC,GAAG,EAAEC,GAAG,KAAKC,IAAI,EAAEC,GAAG,EAAE,SAASrM,KAAI,OAAO,KAAO,EAAF3F,IAAKlgB,MAAK,IAAIiyB,GAAGA,GAAGA,GAAGjyB,IAAG,CAChU,SAAS0lB,GAAGp6B,GAAG,OAAG,KAAY,EAAPA,EAAEswB,MAAe,EAAK,KAAO,EAAFsE,KAAM,IAAIkR,GAASA,IAAGA,GAAK,OAAOhV,GAAGlX,YAAkB,IAAIgtB,KAAKA,GAAGhwB,MAAMgwB,IAAU,KAAP5mC,EAAEiX,IAAkBjX,EAAiBA,OAAE,KAAjBA,EAAE2E,OAAO+e,OAAmB,GAAGvJ,GAAGna,EAAEX,KAAc,CAAC,SAAS05B,GAAG/4B,EAAEC,EAAEhB,EAAEiB,GAAG,GAAG,GAAGumC,GAAG,MAAMA,GAAG,EAAEC,GAAG,KAAKpoC,MAAM4F,EAAE,MAAM4S,GAAG9W,EAAEf,EAAEiB,GAAM,KAAO,EAAF00B,KAAM50B,IAAIy4B,KAAEz4B,IAAIy4B,KAAI,KAAO,EAAF7D,MAAOoR,IAAI/mC,GAAG,IAAI2jC,IAAGiE,GAAG7mC,EAAE8lC,KAAIgB,GAAG9mC,EAAEE,GAAG,IAAIjB,GAAG,IAAI21B,IAAG,KAAY,EAAP30B,EAAEqwB,QAAUuS,GAAGnuB,KAAI,IAAI8Z,IAAIG,MAAK,CAC1Y,SAASmY,GAAG9mC,EAAEC,GAAG,IAAIhB,EAAEe,EAAE+mC,cA3MzB,SAAY/mC,EAAEC,GAAG,IAAI,IAAIhB,EAAEe,EAAEsW,eAAepW,EAAEF,EAAEuW,YAAYpW,EAAEH,EAAEgnC,gBAAgB5mC,EAAEJ,EAAEqW,aAAa,EAAEjW,GAAG,CAAC,IAAI+E,EAAE,GAAGuQ,GAAGtV,GAAGuI,EAAE,GAAGxD,EAAEyD,EAAEzI,EAAEgF,IAAO,IAAIyD,EAAM,KAAKD,EAAE1J,IAAI,KAAK0J,EAAEzI,KAAGC,EAAEgF,GAAGuR,GAAG/N,EAAE1I,IAAQ2I,GAAG3I,IAAID,EAAEinC,cAAct+B,GAAGvI,IAAIuI,CAAC,CAAC,CA2MnLu+B,CAAGlnC,EAAEC,GAAG,IAAIC,EAAEkW,GAAGpW,EAAEA,IAAIy4B,GAAEqN,GAAE,GAAG,GAAG,IAAI5lC,EAAE,OAAOjB,GAAGmV,GAAGnV,GAAGe,EAAE+mC,aAAa,KAAK/mC,EAAEmnC,iBAAiB,OAAO,GAAGlnC,EAAEC,GAAGA,EAAEF,EAAEmnC,mBAAmBlnC,EAAE,CAAgB,GAAf,MAAMhB,GAAGmV,GAAGnV,GAAM,IAAIgB,EAAE,IAAID,EAAEgJ,IA5IsJ,SAAYhJ,GAAGwuB,IAAG,EAAGE,GAAG1uB,EAAE,CA4I5KonC,CAAGC,GAAGllC,KAAK,KAAKnC,IAAI0uB,GAAG2Y,GAAGllC,KAAK,KAAKnC,IAAIksB,IAAG,WAAW,KAAO,EAAF0I,KAAMjG,IAAI,IAAG1vB,EAAE,SAAS,CAAC,OAAOiY,GAAGhX,IAAI,KAAK,EAAEjB,EAAE6V,GAAG,MAAM,KAAK,EAAE7V,EAAE+V,GAAG,MAAM,KAAK,GAAwC,QAAQ/V,EAAEiW,SAApC,KAAK,UAAUjW,EAAEqW,GAAsBrW,EAAEqoC,GAAGroC,EAAEsoC,GAAGplC,KAAK,KAAKnC,GAAG,CAACA,EAAEmnC,iBAAiBlnC,EAAED,EAAE+mC,aAAa9nC,CAAC,CAAC,CAC7c,SAASsoC,GAAGvnC,EAAEC,GAAc,GAAX0mC,IAAI,EAAEC,GAAG,EAAK,KAAO,EAAFhS,IAAK,MAAMt2B,MAAM4F,EAAE,MAAM,IAAIjF,EAAEe,EAAE+mC,aAAa,GAAGS,MAAMxnC,EAAE+mC,eAAe9nC,EAAE,OAAO,KAAK,IAAIiB,EAAEkW,GAAGpW,EAAEA,IAAIy4B,GAAEqN,GAAE,GAAG,GAAG,IAAI5lC,EAAE,OAAO,KAAK,GAAG,KAAO,GAAFA,IAAO,KAAKA,EAAEF,EAAEinC,eAAehnC,EAAEA,EAAEwnC,GAAGznC,EAAEE,OAAO,CAACD,EAAEC,EAAE,IAAIC,EAAEy0B,GAAEA,IAAG,EAAE,IAAIx0B,EAAEsnC,KAAgD,IAAxCjP,KAAIz4B,GAAG8lC,KAAI7lC,IAAEomC,GAAG,KAAKxD,GAAGnuB,KAAI,IAAIizB,GAAG3nC,EAAEC,UAAU2nC,KAAK,KAAK,CAAC,MAAMj/B,GAAGk/B,GAAG7nC,EAAE2I,EAAE,CAAU+pB,KAAKgT,GAAG3xB,QAAQ3T,EAAEw0B,GAAEz0B,EAAE,OAAO0lC,GAAE5lC,EAAE,GAAGw4B,GAAE,KAAKqN,GAAE,EAAE7lC,EAAE2iC,GAAE,CAAC,GAAG,IAAI3iC,EAAE,CAAyC,GAAxC,IAAIA,IAAY,KAARE,EAAEwW,GAAG3W,MAAWE,EAAEC,EAAEF,EAAE6nC,GAAG9nC,EAAEG,KAAQ,IAAIF,EAAE,MAAMhB,EAAE8mC,GAAG4B,GAAG3nC,EAAE,GAAG6mC,GAAG7mC,EAAEE,GAAG4mC,GAAG9mC,EAAE0U,MAAKzV,EAAE,GAAG,IAAIgB,EAAE4mC,GAAG7mC,EAAEE,OAChf,CAAuB,GAAtBC,EAAEH,EAAE+T,QAAQV,UAAa,KAAO,GAAFnT,KAGnC,SAAYF,GAAG,IAAI,IAAIC,EAAED,IAAI,CAAC,GAAW,MAARC,EAAEsT,MAAY,CAAC,IAAItU,EAAEgB,EAAE6zB,YAAY,GAAG,OAAO70B,GAAe,QAAXA,EAAEA,EAAE25B,QAAiB,IAAI,IAAI14B,EAAE,EAAEA,EAAEjB,EAAE/C,OAAOgE,IAAI,CAAC,IAAIC,EAAElB,EAAEiB,GAAGE,EAAED,EAAEm4B,YAAYn4B,EAAEA,EAAE9E,MAAM,IAAI,IAAI0pB,GAAG3kB,IAAID,GAAG,OAAM,CAAE,CAAC,MAAMgF,GAAG,OAAM,CAAE,CAAC,CAAC,CAAW,GAAVlG,EAAEgB,EAAE4T,MAAwB,MAAf5T,EAAEohC,cAAoB,OAAOpiC,EAAEA,EAAEqU,OAAOrT,EAAEA,EAAEhB,MAAM,CAAC,GAAGgB,IAAID,EAAE,MAAM,KAAK,OAAOC,EAAE6T,SAAS,CAAC,GAAG,OAAO7T,EAAEqT,QAAQrT,EAAEqT,SAAStT,EAAE,OAAM,EAAGC,EAAEA,EAAEqT,MAAM,CAACrT,EAAE6T,QAAQR,OAAOrT,EAAEqT,OAAOrT,EAAEA,EAAE6T,OAAO,CAAC,CAAC,OAAM,CAAE,CAHvXi0B,CAAG5nC,KAAe,KAAVF,EAAEwnC,GAAGznC,EAAEE,MAAmB,KAARE,EAAEuW,GAAG3W,MAAWE,EAAEE,EAAEH,EAAE6nC,GAAG9nC,EAAEI,KAAK,IAAIH,GAAG,MAAMhB,EAAE8mC,GAAG4B,GAAG3nC,EAAE,GAAG6mC,GAAG7mC,EAAEE,GAAG4mC,GAAG9mC,EAAE0U,MAAKzV,EAAqC,OAAnCe,EAAEgoC,aAAa7nC,EAAEH,EAAEioC,cAAc/nC,EAASD,GAAG,KAAK,EAAE,KAAK,EAAE,MAAM3B,MAAM4F,EAAE,MAAM,KAAK,EAC8B,KAAK,EAAEgkC,GAAGloC,EAAEmmC,GAAGE,IAAI,MAD7B,KAAK,EAAU,GAARQ,GAAG7mC,EAAEE,IAAS,UAAFA,KAAeA,GAAiB,IAAbD,EAAE8kC,GAAG,IAAIrwB,MAAU,CAAC,GAAG,IAAI0B,GAAGpW,EAAE,GAAG,MAAyB,KAAnBG,EAAEH,EAAEsW,gBAAqBpW,KAAKA,EAAE,CAACq6B,KAAIv6B,EAAEuW,aAAavW,EAAEsW,eAAenW,EAAE,KAAK,CAACH,EAAEmoC,cAAcvc,GAAGsc,GAAG/lC,KAAK,KAAKnC,EAAEmmC,GAAGE,IAAIpmC,GAAG,KAAK,CAACioC,GAAGloC,EAAEmmC,GAAGE,IAAI,MAAM,KAAK,EAAU,GAARQ,GAAG7mC,EAAEE,IAAS,QAAFA,KAC9eA,EAAE,MAAqB,IAAfD,EAAED,EAAE+W,WAAe5W,GAAG,EAAE,EAAED,GAAG,CAAC,IAAIiF,EAAE,GAAGuQ,GAAGxV,GAAGE,EAAE,GAAG+E,GAAEA,EAAElF,EAAEkF,IAAKhF,IAAIA,EAAEgF,GAAGjF,IAAIE,CAAC,CAAqG,GAApGF,EAAEC,EAAqG,IAA3FD,GAAG,KAAXA,EAAEwU,KAAIxU,GAAW,IAAI,IAAIA,EAAE,IAAI,KAAKA,EAAE,KAAK,KAAKA,EAAE,KAAK,IAAIA,EAAE,IAAI,KAAKA,EAAE,KAAK,KAAKslC,GAAGtlC,EAAE,OAAOA,GAAU,CAACF,EAAEmoC,cAAcvc,GAAGsc,GAAG/lC,KAAK,KAAKnC,EAAEmmC,GAAGE,IAAInmC,GAAG,KAAK,CAACgoC,GAAGloC,EAAEmmC,GAAGE,IAAI,MAA+B,QAAQ,MAAM/nC,MAAM4F,EAAE,MAAO,CAAC,CAAW,OAAV4iC,GAAG9mC,EAAE0U,MAAY1U,EAAE+mC,eAAe9nC,EAAEsoC,GAAGplC,KAAK,KAAKnC,GAAG,IAAI,CACrX,SAAS8nC,GAAG9nC,EAAEC,GAAG,IAAIhB,EAAEinC,GAA2G,OAAxGlmC,EAAE+T,QAAQN,cAAcqF,eAAe6uB,GAAG3nC,EAAEC,GAAGsT,OAAO,KAAe,KAAVvT,EAAEynC,GAAGznC,EAAEC,MAAWA,EAAEkmC,GAAGA,GAAGlnC,EAAE,OAAOgB,GAAGiiC,GAAGjiC,IAAWD,CAAC,CAAC,SAASkiC,GAAGliC,GAAG,OAAOmmC,GAAGA,GAAGnmC,EAAEmmC,GAAGznC,KAAKyC,MAAMglC,GAAGnmC,EAAE,CAE5L,SAAS6mC,GAAG7mC,EAAEC,GAAuD,IAApDA,IAAIgmC,GAAGhmC,IAAI+lC,GAAGhmC,EAAEsW,gBAAgBrW,EAAED,EAAEuW,cAActW,EAAMD,EAAEA,EAAEgnC,gBAAgB,EAAE/mC,GAAG,CAAC,IAAIhB,EAAE,GAAGyW,GAAGzV,GAAGC,EAAE,GAAGjB,EAAEe,EAAEf,IAAI,EAAEgB,IAAIC,CAAC,CAAC,CAAC,SAASmnC,GAAGrnC,GAAG,GAAG,KAAO,EAAF40B,IAAK,MAAMt2B,MAAM4F,EAAE,MAAMsjC,KAAK,IAAIvnC,EAAEmW,GAAGpW,EAAE,GAAG,GAAG,KAAO,EAAFC,GAAK,OAAO6mC,GAAG9mC,EAAE0U,MAAK,KAAK,IAAIzV,EAAEwoC,GAAGznC,EAAEC,GAAG,GAAG,IAAID,EAAEgJ,KAAK,IAAI/J,EAAE,CAAC,IAAIiB,EAAEyW,GAAG3W,GAAG,IAAIE,IAAID,EAAEC,EAAEjB,EAAE6oC,GAAG9nC,EAAEE,GAAG,CAAC,GAAG,IAAIjB,EAAE,MAAMA,EAAE8mC,GAAG4B,GAAG3nC,EAAE,GAAG6mC,GAAG7mC,EAAEC,GAAG6mC,GAAG9mC,EAAE0U,MAAKzV,EAAE,GAAG,IAAIA,EAAE,MAAMX,MAAM4F,EAAE,MAAiF,OAA3ElE,EAAEgoC,aAAahoC,EAAE+T,QAAQV,UAAUrT,EAAEioC,cAAchoC,EAAEioC,GAAGloC,EAAEmmC,GAAGE,IAAIS,GAAG9mC,EAAE0U,MAAY,IAAI,CACvd,SAAS0zB,GAAGpoC,EAAEC,GAAG,IAAIhB,EAAE21B,GAAEA,IAAG,EAAE,IAAI,OAAO50B,EAAEC,EAAE,CAAC,QAAY,KAAJ20B,GAAE31B,KAAU4jC,GAAGnuB,KAAI,IAAI8Z,IAAIG,KAAK,CAAC,CAAC,SAAS0Z,GAAGroC,GAAG,OAAOumC,IAAI,IAAIA,GAAGv9B,KAAK,KAAO,EAAF4rB,KAAM4S,KAAK,IAAIvnC,EAAE20B,GAAEA,IAAG,EAAE,IAAI31B,EAAE2mC,GAAGhsB,WAAW1Z,EAAE+W,GAAE,IAAI,GAAG2uB,GAAGhsB,WAAW,KAAK3C,GAAE,EAAEjX,EAAE,OAAOA,GAAG,CAAC,QAAQiX,GAAE/W,EAAE0lC,GAAGhsB,WAAW3a,EAAM,KAAO,GAAX21B,GAAE30B,KAAa0uB,IAAI,CAAC,CAAC,SAASmU,KAAKrD,GAAGD,GAAGzrB,QAAQqZ,GAAEoS,GAAG,CAChT,SAASmI,GAAG3nC,EAAEC,GAAGD,EAAEgoC,aAAa,KAAKhoC,EAAEioC,cAAc,EAAE,IAAIhpC,EAAEe,EAAEmoC,cAAiD,IAAlC,IAAIlpC,IAAIe,EAAEmoC,eAAe,EAAErc,GAAG7sB,IAAO,OAAO4mC,GAAE,IAAI5mC,EAAE4mC,GAAEvyB,OAAO,OAAOrU,GAAG,CAAC,IAAIiB,EAAEjB,EAAQ,OAANuwB,GAAGtvB,GAAUA,EAAE8I,KAAK,KAAK,EAA6B,QAA3B9I,EAAEA,EAAEb,KAAK0uB,yBAA4B,IAAS7tB,GAAG8tB,KAAK,MAAM,KAAK,EAAEyH,KAAKrI,GAAEI,IAAIJ,GAAEG,IAAGyI,KAAK,MAAM,KAAK,EAAEL,GAAGz1B,GAAG,MAAM,KAAK,EAAEu1B,KAAK,MAAM,KAAK,GAAc,KAAK,GAAGrI,GAAEwI,IAAG,MAAM,KAAK,GAAGjD,GAAGzyB,EAAEb,KAAK+J,UAAU,MAAM,KAAK,GAAG,KAAK,GAAG05B,KAAK7jC,EAAEA,EAAEqU,MAAM,CAAqE,GAApEmlB,GAAEz4B,EAAE6lC,GAAE7lC,EAAEyxB,GAAGzxB,EAAE+T,QAAQ,MAAM+xB,GAAErG,GAAGx/B,EAAE2iC,GAAE,EAAEmD,GAAG,KAAKE,GAAGD,GAAGhR,GAAG,EAAEmR,GAAGD,GAAG,KAAQ,OAAO3S,GAAG,CAAC,IAAItzB,EAC1f,EAAEA,EAAEszB,GAAGr3B,OAAO+D,IAAI,GAA2B,QAAhBC,GAARjB,EAAEs0B,GAAGtzB,IAAOyzB,aAAqB,CAACz0B,EAAEy0B,YAAY,KAAK,IAAIvzB,EAAED,EAAEgyB,KAAK9xB,EAAEnB,EAAEk1B,QAAQ,GAAG,OAAO/zB,EAAE,CAAC,IAAI+E,EAAE/E,EAAE8xB,KAAK9xB,EAAE8xB,KAAK/xB,EAAED,EAAEgyB,KAAK/sB,CAAC,CAAClG,EAAEk1B,QAAQj0B,CAAC,CAACqzB,GAAG,IAAI,CAAC,OAAOvzB,CAAC,CAC3K,SAAS6nC,GAAG7nC,EAAEC,GAAG,OAAE,CAAC,IAAIhB,EAAE4mC,GAAE,IAAuB,GAAnBnT,KAAKwD,GAAGniB,QAAQojB,GAAMV,GAAG,CAAC,IAAI,IAAIv2B,EAAEo2B,GAAE7iB,cAAc,OAAOvT,GAAG,CAAC,IAAIC,EAAED,EAAEq3B,MAAM,OAAOp3B,IAAIA,EAAEg0B,QAAQ,MAAMj0B,EAAEA,EAAEgyB,IAAI,CAACuE,IAAG,CAAE,CAA4C,GAA3CJ,GAAG,EAAEG,GAAED,GAAED,GAAE,KAAKI,IAAG,EAAGC,GAAG,EAAEgP,GAAG5xB,QAAQ,KAAQ,OAAO9U,GAAG,OAAOA,EAAEqU,OAAO,CAACsvB,GAAE,EAAEmD,GAAG9lC,EAAE4lC,GAAE,KAAK,KAAK,CAAC7lC,EAAE,CAAC,IAAII,EAAEJ,EAAEmF,EAAElG,EAAEqU,OAAO3K,EAAE1J,EAAE2J,EAAE3I,EAAqB,GAAnBA,EAAE6lC,GAAEn9B,EAAE4K,OAAO,MAAS,OAAO3K,GAAG,kBAAkBA,GAAG,oBAAoBA,EAAEyjB,KAAK,CAAC,IAAI3jB,EAAEE,EAAEhK,EAAE+J,EAAEopB,EAAEnzB,EAAEoK,IAAI,GAAG,KAAY,EAAPpK,EAAE0xB,QAAU,IAAIyB,GAAG,KAAKA,GAAG,KAAKA,GAAG,CAAC,IAAIC,EAAEpzB,EAAEyU,UAAU2e,GAAGpzB,EAAEk1B,YAAY9B,EAAE8B,YAAYl1B,EAAE6U,cAAcue,EAAEve,cACxe7U,EAAEs0B,MAAMlB,EAAEkB,QAAQt0B,EAAEk1B,YAAY,KAAKl1B,EAAE6U,cAAc,KAAK,CAAC,IAAIwe,EAAEuM,GAAGr5B,GAAG,GAAG,OAAO8sB,EAAE,CAACA,EAAE1e,QAAQ,IAAIkrB,GAAGxM,EAAE9sB,EAAEwD,EAAEvI,EAAEH,GAAU,EAAPgyB,EAAE3B,MAAQ+N,GAAGj+B,EAAEsI,EAAEzI,GAAO2I,EAAEF,EAAE,IAAIqhB,GAAZ9pB,EAAEgyB,GAAc6B,YAAY,GAAG,OAAO/J,EAAE,CAAC,IAAIC,EAAE,IAAI3lB,IAAI2lB,EAAEvlB,IAAImE,GAAG3I,EAAE6zB,YAAY9J,CAAC,MAAMD,EAAEtlB,IAAImE,GAAG,MAAM5I,CAAC,CAAM,GAAG,KAAO,EAAFC,GAAK,CAACo+B,GAAGj+B,EAAEsI,EAAEzI,GAAGghC,KAAK,MAAMjhC,CAAC,CAAC4I,EAAEtK,MAAM4F,EAAE,KAAM,MAAM,GAAGyrB,IAAU,EAAPhnB,EAAE2nB,KAAO,CAAC,IAAIrG,EAAEuU,GAAGr5B,GAAG,GAAG,OAAO8kB,EAAE,CAAC,KAAa,MAARA,EAAE1W,SAAe0W,EAAE1W,OAAO,KAAKkrB,GAAGxU,EAAE9kB,EAAEwD,EAAEvI,EAAEH,GAAG4wB,GAAGwM,GAAGz0B,EAAED,IAAI,MAAM3I,CAAC,CAAC,CAACI,EAAEwI,EAAEy0B,GAAGz0B,EAAED,GAAG,IAAIi6B,KAAIA,GAAE,GAAG,OAAOsD,GAAGA,GAAG,CAAC9lC,GAAG8lC,GAAGxnC,KAAK0B,GAAGA,EAAE+E,EAAE,EAAE,CAAC,OAAO/E,EAAE4I,KAAK,KAAK,EAAE5I,EAAEmT,OAAO,MACpftT,IAAIA,EAAEG,EAAE8yB,OAAOjzB,EAAkB60B,GAAG10B,EAAby9B,GAAGz9B,EAAEwI,EAAE3I,IAAW,MAAMD,EAAE,KAAK,EAAE2I,EAAEC,EAAE,IAAIwhB,EAAEhqB,EAAEf,KAAK8qB,EAAE/pB,EAAE2R,UAAU,GAAG,KAAa,IAAR3R,EAAEmT,SAAa,oBAAoB6W,EAAE6T,0BAA0B,OAAO9T,GAAG,oBAAoBA,EAAE+T,oBAAoB,OAAOC,KAAKA,GAAG5U,IAAIY,KAAK,CAAC/pB,EAAEmT,OAAO,MAAMtT,IAAIA,EAAEG,EAAE8yB,OAAOjzB,EAAkB60B,GAAG10B,EAAb49B,GAAG59B,EAAEuI,EAAE1I,IAAW,MAAMD,CAAC,EAAEI,EAAEA,EAAEkT,MAAM,OAAO,OAAOlT,EAAE,CAACkoC,GAAGrpC,EAAE,CAAC,MAAM0rB,GAAI1qB,EAAE0qB,EAAGkb,KAAI5mC,GAAG,OAAOA,IAAI4mC,GAAE5mC,EAAEA,EAAEqU,QAAQ,QAAQ,CAAC,KAAK,CAAS,CAAC,SAASo0B,KAAK,IAAI1nC,EAAE0lC,GAAG3xB,QAAsB,OAAd2xB,GAAG3xB,QAAQojB,GAAU,OAAOn3B,EAAEm3B,GAAGn3B,CAAC,CACrd,SAASihC,KAAQ,IAAI2B,IAAG,IAAIA,IAAG,IAAIA,KAAEA,GAAE,GAAE,OAAOnK,IAAG,KAAQ,UAAHzD,KAAe,KAAQ,UAAHgR,KAAea,GAAGpO,GAAEqN,GAAE,CAAC,SAAS2B,GAAGznC,EAAEC,GAAG,IAAIhB,EAAE21B,GAAEA,IAAG,EAAE,IAAI10B,EAAEwnC,KAAqC,IAA7BjP,KAAIz4B,GAAG8lC,KAAI7lC,IAAEomC,GAAG,KAAKsB,GAAG3nC,EAAEC,UAAUsoC,KAAK,KAAK,CAAC,MAAMpoC,GAAG0nC,GAAG7nC,EAAEG,EAAE,CAAgC,GAAtBuyB,KAAKkC,GAAE31B,EAAEymC,GAAG3xB,QAAQ7T,EAAK,OAAO2lC,GAAE,MAAMvnC,MAAM4F,EAAE,MAAiB,OAAXu0B,GAAE,KAAKqN,GAAE,EAASlD,EAAC,CAAC,SAAS2F,KAAK,KAAK,OAAO1C,IAAG2C,GAAG3C,GAAE,CAAC,SAAS+B,KAAK,KAAK,OAAO/B,KAAIvxB,MAAMk0B,GAAG3C,GAAE,CAAC,SAAS2C,GAAGxoC,GAAG,IAAIC,EAAEslC,GAAGvlC,EAAEqT,UAAUrT,EAAEy/B,IAAIz/B,EAAE0wB,cAAc1wB,EAAEiwB,aAAa,OAAOhwB,EAAEqoC,GAAGtoC,GAAG6lC,GAAE5lC,EAAE0lC,GAAG5xB,QAAQ,IAAI,CAC1d,SAASu0B,GAAGtoC,GAAG,IAAIC,EAAED,EAAE,EAAE,CAAC,IAAIf,EAAEgB,EAAEoT,UAAqB,GAAXrT,EAAEC,EAAEqT,OAAU,KAAa,MAARrT,EAAEsT,QAAc,GAAgB,QAAbtU,EAAEgjC,GAAGhjC,EAAEgB,EAAEw/B,KAAkB,YAAJoG,GAAE5mC,OAAc,CAAW,GAAG,QAAbA,EAAE8jC,GAAG9jC,EAAEgB,IAAmC,OAAnBhB,EAAEsU,OAAO,WAAMsyB,GAAE5mC,GAAS,GAAG,OAAOe,EAAmE,OAAX4iC,GAAE,OAAEiD,GAAE,MAA5D7lC,EAAEuT,OAAO,MAAMvT,EAAEqhC,aAAa,EAAErhC,EAAE+vB,UAAU,IAA4B,CAAa,GAAG,QAAf9vB,EAAEA,EAAE6T,SAAyB,YAAJ+xB,GAAE5lC,GAAS4lC,GAAE5lC,EAAED,CAAC,OAAO,OAAOC,GAAG,IAAI2iC,KAAIA,GAAE,EAAE,CAAC,SAASsF,GAAGloC,EAAEC,EAAEhB,GAAG,IAAIiB,EAAE+W,GAAE9W,EAAEylC,GAAGhsB,WAAW,IAAIgsB,GAAGhsB,WAAW,KAAK3C,GAAE,EAC3Y,SAAYjX,EAAEC,EAAEhB,EAAEiB,GAAG,GAAGsnC,WAAW,OAAOjB,IAAI,GAAG,KAAO,EAAF3R,IAAK,MAAMt2B,MAAM4F,EAAE,MAAMjF,EAAEe,EAAEgoC,aAAa,IAAI7nC,EAAEH,EAAEioC,cAAc,GAAG,OAAOhpC,EAAE,OAAO,KAA2C,GAAtCe,EAAEgoC,aAAa,KAAKhoC,EAAEioC,cAAc,EAAKhpC,IAAIe,EAAE+T,QAAQ,MAAMzV,MAAM4F,EAAE,MAAMlE,EAAE+mC,aAAa,KAAK/mC,EAAEmnC,iBAAiB,EAAE,IAAI/mC,EAAEnB,EAAEi0B,MAAMj0B,EAAE6zB,WAA8J,GAzNtT,SAAY9yB,EAAEC,GAAG,IAAIhB,EAAEe,EAAEqW,cAAcpW,EAAED,EAAEqW,aAAapW,EAAED,EAAEsW,eAAe,EAAEtW,EAAEuW,YAAY,EAAEvW,EAAEinC,cAAchnC,EAAED,EAAEyoC,kBAAkBxoC,EAAED,EAAEwW,gBAAgBvW,EAAEA,EAAED,EAAEyW,cAAc,IAAIvW,EAAEF,EAAE+W,WAAW,IAAI/W,EAAEA,EAAEgnC,gBAAgB,EAAE/nC,GAAG,CAAC,IAAIkB,EAAE,GAAGuV,GAAGzW,GAAGmB,EAAE,GAAGD,EAAEF,EAAEE,GAAG,EAAED,EAAEC,IAAI,EAAEH,EAAEG,IAAI,EAAElB,IAAImB,CAAC,CAAC,CAyN5GsoC,CAAG1oC,EAAEI,GAAGJ,IAAIy4B,KAAIoN,GAAEpN,GAAE,KAAKqN,GAAE,GAAG,KAAoB,KAAf7mC,EAAEoiC,eAAoB,KAAa,KAARpiC,EAAEsU,QAAa+yB,KAAKA,IAAG,EAAGgB,GAAGpyB,IAAG,WAAgB,OAALsyB,KAAY,IAAI,KAAIpnC,EAAE,KAAa,MAARnB,EAAEsU,OAAgB,KAAoB,MAAftU,EAAEoiC,eAAqBjhC,EAAE,CAACA,EAAEwlC,GAAGhsB,WAAWgsB,GAAGhsB,WAAW,KAChf,IAAIzU,EAAE8R,GAAEA,GAAE,EAAE,IAAItO,EAAEisB,GAAEA,IAAG,EAAE+Q,GAAG5xB,QAAQ,KA1CpC,SAAY/T,EAAEC,GAAgB,GAAburB,GAAG9R,GAAakM,GAAV5lB,EAAEwlB,MAAc,CAAC,GAAG,mBAAmBxlB,EAAE,IAAIf,EAAE,CAACxB,MAAMuC,EAAEkmB,eAAenoB,IAAIiC,EAAEmmB,mBAAmBnmB,EAAE,CAA8C,IAAIE,GAAjDjB,GAAGA,EAAEe,EAAEmL,gBAAgBlM,EAAEonB,aAAa1hB,QAAe2hB,cAAcrnB,EAAEqnB,eAAe,GAAGpmB,GAAG,IAAIA,EAAEqmB,WAAW,CAACtnB,EAAEiB,EAAEsmB,WAAW,IAAIrmB,EAAED,EAAEumB,aAAarmB,EAAEF,EAAEwmB,UAAUxmB,EAAEA,EAAEymB,YAAY,IAAI1nB,EAAE6N,SAAS1M,EAAE0M,QAAQ,CAAC,MAAMud,GAAGprB,EAAE,KAAK,MAAMe,CAAC,CAAC,IAAImF,EAAE,EAAEwD,GAAG,EAAEC,GAAG,EAAEF,EAAE,EAAE9J,EAAE,EAAEmzB,EAAE/xB,EAAEgyB,EAAE,KAAK/xB,EAAE,OAAO,CAAC,IAAI,IAAIgyB,EAAKF,IAAI9yB,GAAG,IAAIkB,GAAG,IAAI4xB,EAAEjlB,WAAWnE,EAAExD,EAAEhF,GAAG4xB,IAAI3xB,GAAG,IAAIF,GAAG,IAAI6xB,EAAEjlB,WAAWlE,EAAEzD,EAAEjF,GAAG,IAAI6xB,EAAEjlB,WAAW3H,GACnf4sB,EAAEhlB,UAAU7Q,QAAW,QAAQ+1B,EAAEF,EAAExlB,aAAkBylB,EAAED,EAAEA,EAAEE,EAAE,OAAO,CAAC,GAAGF,IAAI/xB,EAAE,MAAMC,EAA8C,GAA5C+xB,IAAI/yB,KAAKyJ,IAAIvI,IAAIwI,EAAExD,GAAG6sB,IAAI5xB,KAAKxB,IAAIsB,IAAI0I,EAAEzD,GAAM,QAAQ8sB,EAAEF,EAAE3M,aAAa,MAAU4M,GAAJD,EAAEC,GAAMvgB,UAAU,CAACsgB,EAAEE,CAAC,CAAChzB,GAAG,IAAI0J,IAAI,IAAIC,EAAE,KAAK,CAACnL,MAAMkL,EAAE5K,IAAI6K,EAAE,MAAM3J,EAAE,IAAI,CAACA,EAAEA,GAAG,CAACxB,MAAM,EAAEM,IAAI,EAAE,MAAMkB,EAAE,KAA+C,IAA1CwsB,GAAG,CAAC1F,YAAY/lB,EAAEgmB,eAAe/mB,GAAGya,IAAG,EAAO0pB,GAAEnjC,EAAE,OAAOmjC,IAAG,GAAOpjC,GAAJC,EAAEmjC,IAAMvvB,MAAM,KAAoB,KAAf5T,EAAEohC,eAAoB,OAAOrhC,EAAEA,EAAEsT,OAAOrT,EAAEmjC,GAAEpjC,OAAO,KAAK,OAAOojC,IAAG,CAACnjC,EAAEmjC,GAAE,IAAI,IAAIrZ,EAAE9pB,EAAEoT,UAAU,GAAG,KAAa,KAARpT,EAAEsT,OAAY,OAAOtT,EAAE+I,KAAK,KAAK,EAAE,KAAK,GAAG,KAAK,GACvK,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,GAAG,MAA3W,KAAK,EAAE,GAAG,OAAO+gB,EAAE,CAAC,IAAIC,EAAED,EAAE2G,cAAczG,EAAEF,EAAEtW,cAAcyW,EAAEjqB,EAAE8R,UAAUqY,EAAEF,EAAE+S,wBAAwBh9B,EAAEsD,cAActD,EAAEZ,KAAK2qB,EAAE4R,GAAG37B,EAAEZ,KAAK2qB,GAAGC,GAAGC,EAAEob,oCAAoClb,CAAC,CAAC,MAAM,KAAK,EAAE,IAAID,EAAElqB,EAAE8R,UAAUgH,cAAc,IAAIoR,EAAErd,SAASqd,EAAEpe,YAAY,GAAG,IAAIoe,EAAErd,UAAUqd,EAAElE,iBAAiBkE,EAAE3d,YAAY2d,EAAElE,iBAAiB,MAAyC,QAAQ,MAAM3nB,MAAM4F,EAAE,MAAO,CAAC,MAAMmmB,GAAGiZ,GAAErjC,EAAEA,EAAEqT,OAAO+W,EAAE,CAAa,GAAG,QAAfrqB,EAAEC,EAAE6T,SAAoB,CAAC9T,EAAEsT,OAAOrT,EAAEqT,OAAO8vB,GAAEpjC,EAAE,KAAK,CAACojC,GAAEnjC,EAAEqT,MAAM,CAACyW,EAAEyZ,GAAGA,IAAG,CAAW,CAwCldmF,CAAG3oC,EAAEf,GAAG2lC,GAAG3lC,EAAEe,GAAG8lB,GAAG2F,IAAI/R,KAAK8R,GAAGC,GAAGD,GAAG,KAAKxrB,EAAE+T,QAAQ9U,EAAEimC,GAAGjmC,EAAEe,EAAEG,GAAGqU,KAAKogB,GAAEjsB,EAAEsO,GAAE9R,EAAEygC,GAAGhsB,WAAWxZ,CAAC,MAAMJ,EAAE+T,QAAQ9U,EAAsF,GAApFqnC,KAAKA,IAAG,EAAGC,GAAGvmC,EAAEwmC,GAAGrmC,GAAGC,EAAEJ,EAAEqW,aAAa,IAAIjW,IAAI+9B,GAAG,MAhOmJ,SAAYn+B,GAAG,GAAGyV,IAAI,oBAAoBA,GAAGmzB,kBAAkB,IAAInzB,GAAGmzB,kBAAkBpzB,GAAGxV,OAAE,EAAO,OAAuB,IAAhBA,EAAE+T,QAAQR,OAAW,CAAC,MAAMtT,GAAG,CAAC,CAgOxR4oC,CAAG5pC,EAAE8S,WAAa+0B,GAAG9mC,EAAE0U,MAAQ,OAAOzU,EAAE,IAAIC,EAAEF,EAAE8oC,mBAAmB7pC,EAAE,EAAEA,EAAEgB,EAAE/D,OAAO+C,IAAIkB,EAAEF,EAAEhB,GAAGiB,EAAEC,EAAE9E,MAAM,CAAC+iC,eAAej+B,EAAEgI,MAAMo1B,OAAOp9B,EAAEo9B,SAAS,GAAGO,GAAG,MAAMA,IAAG,EAAG99B,EAAE+9B,GAAGA,GAAG,KAAK/9B,EAAE,KAAQ,EAAHwmC,KAAO,IAAIxmC,EAAEgJ,KAAKw+B,KAAKpnC,EAAEJ,EAAEqW,aAAa,KAAO,EAAFjW,GAAKJ,IAAI0mC,GAAGD,MAAMA,GAAG,EAAEC,GAAG1mC,GAAGymC,GAAG,EAAE9X,IAAgB,CAFxFoa,CAAG/oC,EAAEC,EAAEhB,EAAEiB,EAAE,CAAC,QAAQ0lC,GAAGhsB,WAAWzZ,EAAE8W,GAAE/W,CAAC,CAAC,OAAO,IAAI,CAGhc,SAASsnC,KAAK,GAAG,OAAOjB,GAAG,CAAC,IAAIvmC,EAAEkX,GAAGsvB,IAAIvmC,EAAE2lC,GAAGhsB,WAAW3a,EAAEgY,GAAE,IAAmC,GAA/B2uB,GAAGhsB,WAAW,KAAK3C,GAAE,GAAGjX,EAAE,GAAGA,EAAK,OAAOumC,GAAG,IAAIrmC,GAAE,MAAO,CAAmB,GAAlBF,EAAEumC,GAAGA,GAAG,KAAKC,GAAG,EAAK,KAAO,EAAF5R,IAAK,MAAMt2B,MAAM4F,EAAE,MAAM,IAAI/D,EAAEy0B,GAAO,IAALA,IAAG,EAAMwO,GAAEpjC,EAAE+T,QAAQ,OAAOqvB,IAAG,CAAC,IAAIhjC,EAAEgjC,GAAEj+B,EAAE/E,EAAEyT,MAAM,GAAG,KAAa,GAARuvB,GAAE7vB,OAAU,CAAC,IAAI5K,EAAEvI,EAAE2vB,UAAU,GAAG,OAAOpnB,EAAE,CAAC,IAAI,IAAIC,EAAE,EAAEA,EAAED,EAAEzM,OAAO0M,IAAI,CAAC,IAAIF,EAAEC,EAAEC,GAAG,IAAIw6B,GAAE16B,EAAE,OAAO06B,IAAG,CAAC,IAAIxkC,EAAEwkC,GAAE,OAAOxkC,EAAEoK,KAAK,KAAK,EAAE,KAAK,GAAG,KAAK,GAAGy6B,GAAG,EAAE7kC,EAAEwB,GAAG,IAAI2xB,EAAEnzB,EAAEiV,MAAM,GAAG,OAAOke,EAAEA,EAAEze,OAAO1U,EAAEwkC,GAAErR,OAAO,KAAK,OAAOqR,IAAG,CAAK,IAAIpR,GAARpzB,EAAEwkC,IAAUtvB,QAAQme,EAAErzB,EAAE0U,OAAa,GAANswB,GAAGhlC,GAAMA,IACnf8J,EAAE,CAAC06B,GAAE,KAAK,KAAK,CAAC,GAAG,OAAOpR,EAAE,CAACA,EAAE1e,OAAO2e,EAAEmR,GAAEpR,EAAE,KAAK,CAACoR,GAAEnR,CAAC,CAAC,CAAC,CAAC,IAAIlI,EAAE3pB,EAAEiT,UAAU,GAAG,OAAO0W,EAAE,CAAC,IAAIC,EAAED,EAAElW,MAAM,GAAG,OAAOmW,EAAE,CAACD,EAAElW,MAAM,KAAK,EAAE,CAAC,IAAIoW,EAAED,EAAElW,QAAQkW,EAAElW,QAAQ,KAAKkW,EAAEC,CAAC,OAAO,OAAOD,EAAE,CAAC,CAACoZ,GAAEhjC,CAAC,CAAC,CAAC,GAAG,KAAoB,KAAfA,EAAEihC,eAAoB,OAAOl8B,EAAEA,EAAEmO,OAAOlT,EAAEgjC,GAAEj+B,OAAOlF,EAAE,KAAK,OAAOmjC,IAAG,CAAK,GAAG,KAAa,MAApBhjC,EAAEgjC,IAAY7vB,OAAY,OAAOnT,EAAE4I,KAAK,KAAK,EAAE,KAAK,GAAG,KAAK,GAAGy6B,GAAG,EAAErjC,EAAEA,EAAEkT,QAAQ,IAAI4W,EAAE9pB,EAAE0T,QAAQ,GAAG,OAAOoW,EAAE,CAACA,EAAE5W,OAAOlT,EAAEkT,OAAO8vB,GAAElZ,EAAE,MAAMjqB,CAAC,CAACmjC,GAAEhjC,EAAEkT,MAAM,CAAC,CAAC,IAAI8W,EAAEpqB,EAAE+T,QAAQ,IAAIqvB,GAAEhZ,EAAE,OAAOgZ,IAAG,CAAK,IAAIjZ,GAARhlB,EAAEi+B,IAAUvvB,MAAM,GAAG,KAAoB,KAAf1O,EAAEk8B,eAAoB,OAClflX,EAAEA,EAAE7W,OAAOnO,EAAEi+B,GAAEjZ,OAAOlqB,EAAE,IAAIkF,EAAEilB,EAAE,OAAOgZ,IAAG,CAAK,GAAG,KAAa,MAApBz6B,EAAEy6B,IAAY7vB,OAAY,IAAI,OAAO5K,EAAEK,KAAK,KAAK,EAAE,KAAK,GAAG,KAAK,GAAG06B,GAAG,EAAE/6B,GAAG,CAAC,MAAMgiB,GAAI2Y,GAAE36B,EAAEA,EAAE2K,OAAOqX,EAAG,CAAC,GAAGhiB,IAAIxD,EAAE,CAACi+B,GAAE,KAAK,MAAMnjC,CAAC,CAAC,IAAIoqB,EAAE1hB,EAAEmL,QAAQ,GAAG,OAAOuW,EAAE,CAACA,EAAE/W,OAAO3K,EAAE2K,OAAO8vB,GAAE/Y,EAAE,MAAMpqB,CAAC,CAACmjC,GAAEz6B,EAAE2K,MAAM,CAAC,CAAU,GAATshB,GAAEz0B,EAAEwuB,KAAQlZ,IAAI,oBAAoBA,GAAGuzB,sBAAsB,IAAIvzB,GAAGuzB,sBAAsBxzB,GAAGxV,EAAE,CAAC,MAAM2qB,GAAI,CAACzqB,GAAE,CAAE,CAAC,OAAOA,CAAC,CAAC,QAAQ+W,GAAEhY,EAAE2mC,GAAGhsB,WAAW3Z,CAAC,CAAC,CAAC,OAAM,CAAE,CAAC,SAASgpC,GAAGjpC,EAAEC,EAAEhB,GAAyBe,EAAE20B,GAAG30B,EAAjBC,EAAE49B,GAAG79B,EAAfC,EAAEo9B,GAAGp+B,EAAEgB,GAAY,GAAY,GAAGA,EAAEs6B,KAAI,OAAOv6B,IAAI8W,GAAG9W,EAAE,EAAEC,GAAG6mC,GAAG9mC,EAAEC,GAAG,CACze,SAASqjC,GAAEtjC,EAAEC,EAAEhB,GAAG,GAAG,IAAIe,EAAEgJ,IAAIigC,GAAGjpC,EAAEA,EAAEf,QAAQ,KAAK,OAAOgB,GAAG,CAAC,GAAG,IAAIA,EAAE+I,IAAI,CAACigC,GAAGhpC,EAAED,EAAEf,GAAG,KAAK,CAAM,GAAG,IAAIgB,EAAE+I,IAAI,CAAC,IAAI9I,EAAED,EAAE8R,UAAU,GAAG,oBAAoB9R,EAAEZ,KAAK4+B,0BAA0B,oBAAoB/9B,EAAEg+B,oBAAoB,OAAOC,KAAKA,GAAG5U,IAAIrpB,IAAI,CAAuBD,EAAE00B,GAAG10B,EAAjBD,EAAEg+B,GAAG/9B,EAAfD,EAAEq9B,GAAGp+B,EAAEe,GAAY,GAAY,GAAGA,EAAEu6B,KAAI,OAAOt6B,IAAI6W,GAAG7W,EAAE,EAAED,GAAG8mC,GAAG7mC,EAAED,IAAI,KAAK,CAAC,CAACC,EAAEA,EAAEqT,MAAM,CAAC,CACnV,SAASirB,GAAGv+B,EAAEC,EAAEhB,GAAG,IAAIiB,EAAEF,EAAEs+B,UAAU,OAAOp+B,GAAGA,EAAEiY,OAAOlY,GAAGA,EAAEs6B,KAAIv6B,EAAEuW,aAAavW,EAAEsW,eAAerX,EAAEw5B,KAAIz4B,IAAI8lC,GAAE7mC,KAAKA,IAAI,IAAI2jC,IAAG,IAAIA,KAAM,UAAFkD,MAAeA,IAAG,IAAIpxB,KAAIqwB,GAAG4C,GAAG3nC,EAAE,GAAGimC,IAAIhnC,GAAG6nC,GAAG9mC,EAAEC,EAAE,CAAC,SAASipC,GAAGlpC,EAAEC,GAAG,IAAIA,IAAI,KAAY,EAAPD,EAAEswB,MAAQrwB,EAAE,GAAGA,EAAEiW,GAAU,KAAQ,WAAfA,KAAK,MAAuBA,GAAG,WAAW,IAAIjX,EAAEs7B,KAAc,QAAVv6B,EAAE2zB,GAAG3zB,EAAEC,MAAc6W,GAAG9W,EAAEC,EAAEhB,GAAG6nC,GAAG9mC,EAAEf,GAAG,CAAC,SAASiiC,GAAGlhC,GAAG,IAAIC,EAAED,EAAEyT,cAAcxU,EAAE,EAAE,OAAOgB,IAAIhB,EAAEgB,EAAEmwB,WAAW8Y,GAAGlpC,EAAEf,EAAE,CACjZ,SAASylC,GAAG1kC,EAAEC,GAAG,IAAIhB,EAAE,EAAE,OAAOe,EAAEgJ,KAAK,KAAK,GAAG,IAAI9I,EAAEF,EAAE+R,UAAc5R,EAAEH,EAAEyT,cAAc,OAAOtT,IAAIlB,EAAEkB,EAAEiwB,WAAW,MAAM,KAAK,GAAGlwB,EAAEF,EAAE+R,UAAU,MAAM,QAAQ,MAAMzT,MAAM4F,EAAE,MAAO,OAAOhE,GAAGA,EAAEiY,OAAOlY,GAAGipC,GAAGlpC,EAAEf,EAAE,CAQqK,SAASqoC,GAAGtnC,EAAEC,GAAG,OAAOiU,GAAGlU,EAAEC,EAAE,CACjZ,SAASkpC,GAAGnpC,EAAEC,EAAEhB,EAAEiB,GAAGpC,KAAKkL,IAAIhJ,EAAElC,KAAKnD,IAAIsE,EAAEnB,KAAKgW,QAAQhW,KAAK+V,MAAM/V,KAAKwV,OAAOxV,KAAKiU,UAAUjU,KAAKuB,KAAKvB,KAAKyF,YAAY,KAAKzF,KAAK0zB,MAAM,EAAE1zB,KAAKkzB,IAAI,KAAKlzB,KAAKmyB,aAAahwB,EAAEnC,KAAKk1B,aAAal1B,KAAK2V,cAAc3V,KAAKg2B,YAAYh2B,KAAK4yB,cAAc,KAAK5yB,KAAKwyB,KAAKpwB,EAAEpC,KAAKujC,aAAavjC,KAAKyV,MAAM,EAAEzV,KAAKiyB,UAAU,KAAKjyB,KAAKg1B,WAAWh1B,KAAKo1B,MAAM,EAAEp1B,KAAKuV,UAAU,IAAI,CAAC,SAASyc,GAAG9vB,EAAEC,EAAEhB,EAAEiB,GAAG,OAAO,IAAIipC,GAAGnpC,EAAEC,EAAEhB,EAAEiB,EAAE,CAAC,SAAS8+B,GAAGh/B,GAAiB,UAAdA,EAAEA,EAAElG,aAAuBkG,EAAEopC,iBAAiB,CAEpd,SAAS3X,GAAGzxB,EAAEC,GAAG,IAAIhB,EAAEe,EAAEqT,UACuB,OADb,OAAOpU,IAAGA,EAAE6wB,GAAG9vB,EAAEgJ,IAAI/I,EAAED,EAAErF,IAAIqF,EAAEswB,OAAQ/sB,YAAYvD,EAAEuD,YAAYtE,EAAEI,KAAKW,EAAEX,KAAKJ,EAAE8S,UAAU/R,EAAE+R,UAAU9S,EAAEoU,UAAUrT,EAAEA,EAAEqT,UAAUpU,IAAIA,EAAEgxB,aAAahwB,EAAEhB,EAAEI,KAAKW,EAAEX,KAAKJ,EAAEsU,MAAM,EAAEtU,EAAEoiC,aAAa,EAAEpiC,EAAE8wB,UAAU,MAAM9wB,EAAEsU,MAAc,SAARvT,EAAEuT,MAAetU,EAAE6zB,WAAW9yB,EAAE8yB,WAAW7zB,EAAEi0B,MAAMlzB,EAAEkzB,MAAMj0B,EAAE4U,MAAM7T,EAAE6T,MAAM5U,EAAEyxB,cAAc1wB,EAAE0wB,cAAczxB,EAAEwU,cAAczT,EAAEyT,cAAcxU,EAAE60B,YAAY9zB,EAAE8zB,YAAY7zB,EAAED,EAAEgzB,aAAa/zB,EAAE+zB,aAAa,OAAO/yB,EAAE,KAAK,CAACizB,MAAMjzB,EAAEizB,MAAMD,aAAahzB,EAAEgzB,cAC/eh0B,EAAE6U,QAAQ9T,EAAE8T,QAAQ7U,EAAEuyB,MAAMxxB,EAAEwxB,MAAMvyB,EAAE+xB,IAAIhxB,EAAEgxB,IAAW/xB,CAAC,CACxD,SAAS0yB,GAAG3xB,EAAEC,EAAEhB,EAAEiB,EAAEC,EAAEC,GAAG,IAAI+E,EAAE,EAAM,GAAJjF,EAAEF,EAAK,oBAAoBA,EAAEg/B,GAAGh/B,KAAKmF,EAAE,QAAQ,GAAG,kBAAkBnF,EAAEmF,EAAE,OAAOnF,EAAE,OAAOA,GAAG,KAAKiH,EAAG,OAAO6qB,GAAG7yB,EAAE0M,SAASxL,EAAEC,EAAEH,GAAG,KAAKiH,EAAG/B,EAAE,EAAEhF,GAAG,EAAE,MAAM,KAAKgH,EAAG,OAAOnH,EAAE8vB,GAAG,GAAG7wB,EAAEgB,EAAI,EAAFE,IAAOoD,YAAY4D,EAAGnH,EAAEkzB,MAAM9yB,EAAEJ,EAAE,KAAKuH,EAAG,OAAOvH,EAAE8vB,GAAG,GAAG7wB,EAAEgB,EAAEE,IAAKoD,YAAYgE,EAAGvH,EAAEkzB,MAAM9yB,EAAEJ,EAAE,KAAKwH,EAAG,OAAOxH,EAAE8vB,GAAG,GAAG7wB,EAAEgB,EAAEE,IAAKoD,YAAYiE,EAAGxH,EAAEkzB,MAAM9yB,EAAEJ,EAAE,KAAK2H,EAAG,OAAOi5B,GAAG3hC,EAAEkB,EAAEC,EAAEH,GAAG,QAAQ,GAAG,kBAAkBD,GAAG,OAAOA,EAAE,OAAOA,EAAEmJ,UAAU,KAAK/B,EAAGjC,EAAE,GAAG,MAAMnF,EAAE,KAAKqH,EAAGlC,EAAE,EAAE,MAAMnF,EAAE,KAAKsH,EAAGnC,EAAE,GACpf,MAAMnF,EAAE,KAAKyH,EAAGtC,EAAE,GAAG,MAAMnF,EAAE,KAAK0H,EAAGvC,EAAE,GAAGjF,EAAE,KAAK,MAAMF,EAAE,MAAM1B,MAAM4F,EAAE,IAAI,MAAMlE,EAAEA,SAASA,EAAE,KAAuD,OAAjDC,EAAE6vB,GAAG3qB,EAAElG,EAAEgB,EAAEE,IAAKoD,YAAYvD,EAAEC,EAAEZ,KAAKa,EAAED,EAAEizB,MAAM9yB,EAASH,CAAC,CAAC,SAAS6xB,GAAG9xB,EAAEC,EAAEhB,EAAEiB,GAA2B,OAAxBF,EAAE8vB,GAAG,EAAE9vB,EAAEE,EAAED,IAAKizB,MAAMj0B,EAASe,CAAC,CAAC,SAAS4gC,GAAG5gC,EAAEC,EAAEhB,EAAEiB,GAAuE,OAApEF,EAAE8vB,GAAG,GAAG9vB,EAAEE,EAAED,IAAKsD,YAAYoE,EAAG3H,EAAEkzB,MAAMj0B,EAAEe,EAAE+R,UAAU,CAAC+yB,UAAS,GAAW9kC,CAAC,CAAC,SAAS0xB,GAAG1xB,EAAEC,EAAEhB,GAA8B,OAA3Be,EAAE8vB,GAAG,EAAE9vB,EAAE,KAAKC,IAAKizB,MAAMj0B,EAASe,CAAC,CAC5W,SAAS6xB,GAAG7xB,EAAEC,EAAEhB,GAA8J,OAA3JgB,EAAE6vB,GAAG,EAAE,OAAO9vB,EAAE2L,SAAS3L,EAAE2L,SAAS,GAAG3L,EAAErF,IAAIsF,IAAKizB,MAAMj0B,EAAEgB,EAAE8R,UAAU,CAACgH,cAAc/Y,EAAE+Y,cAAcswB,gBAAgB,KAAKzX,eAAe5xB,EAAE4xB,gBAAuB3xB,CAAC,CACtL,SAASqpC,GAAGtpC,EAAEC,EAAEhB,EAAEiB,EAAEC,GAAGrC,KAAKkL,IAAI/I,EAAEnC,KAAKib,cAAc/Y,EAAElC,KAAKkqC,aAAalqC,KAAKwgC,UAAUxgC,KAAKiW,QAAQjW,KAAKurC,gBAAgB,KAAKvrC,KAAKqqC,eAAe,EAAErqC,KAAKipC,aAAajpC,KAAKoiC,eAAepiC,KAAKu1B,QAAQ,KAAKv1B,KAAKqpC,iBAAiB,EAAErpC,KAAKiZ,WAAWF,GAAG,GAAG/Y,KAAKkpC,gBAAgBnwB,IAAI,GAAG/Y,KAAK0Y,eAAe1Y,KAAKmqC,cAAcnqC,KAAK2qC,iBAAiB3qC,KAAKmpC,aAAanpC,KAAKyY,YAAYzY,KAAKwY,eAAexY,KAAKuY,aAAa,EAAEvY,KAAK2Y,cAAcI,GAAG,GAAG/Y,KAAK69B,iBAAiBz7B,EAAEpC,KAAKgrC,mBAAmB3oC,EAAErC,KAAKyrC,gCAC/e,IAAI,CAAC,SAASC,GAAGxpC,EAAEC,EAAEhB,EAAEiB,EAAEC,EAAEC,EAAE+E,EAAEwD,EAAEC,GAAgN,OAA7M5I,EAAE,IAAIspC,GAAGtpC,EAAEC,EAAEhB,EAAE0J,EAAEC,GAAG,IAAI3I,GAAGA,EAAE,GAAE,IAAKG,IAAIH,GAAG,IAAIA,EAAE,EAAEG,EAAE0vB,GAAG,EAAE,KAAK,KAAK7vB,GAAGD,EAAE+T,QAAQ3T,EAAEA,EAAE2R,UAAU/R,EAAEI,EAAEqT,cAAc,CAACnQ,QAAQpD,EAAE4Y,aAAa7Z,EAAEwqC,MAAM,KAAKlK,YAAY,KAAKmK,0BAA0B,MAAM7V,GAAGzzB,GAAUJ,CAAC,CACzP,SAAS2pC,GAAG3pC,GAAG,IAAIA,EAAE,OAAOstB,GAAuBttB,EAAE,CAAC,GAAGoT,GAA1BpT,EAAEA,EAAEi8B,mBAA8Bj8B,GAAG,IAAIA,EAAEgJ,IAAI,MAAM1K,MAAM4F,EAAE,MAAM,IAAIjE,EAAED,EAAE,EAAE,CAAC,OAAOC,EAAE+I,KAAK,KAAK,EAAE/I,EAAEA,EAAE8R,UAAUshB,QAAQ,MAAMrzB,EAAE,KAAK,EAAE,GAAG8tB,GAAG7tB,EAAEZ,MAAM,CAACY,EAAEA,EAAE8R,UAAUsc,0CAA0C,MAAMruB,CAAC,EAAEC,EAAEA,EAAEqT,MAAM,OAAO,OAAOrT,GAAG,MAAM3B,MAAM4F,EAAE,KAAM,CAAC,GAAG,IAAIlE,EAAEgJ,IAAI,CAAC,IAAI/J,EAAEe,EAAEX,KAAK,GAAGyuB,GAAG7uB,GAAG,OAAOivB,GAAGluB,EAAEf,EAAEgB,EAAE,CAAC,OAAOA,CAAC,CACpW,SAAS2pC,GAAG5pC,EAAEC,EAAEhB,EAAEiB,EAAEC,EAAEC,EAAE+E,EAAEwD,EAAEC,GAAwK,OAArK5I,EAAEwpC,GAAGvqC,EAAEiB,GAAE,EAAGF,EAAEG,EAAEC,EAAE+E,EAAEwD,EAAEC,IAAKyqB,QAAQsW,GAAG,MAAM1qC,EAAEe,EAAE+T,SAAsB3T,EAAEk0B,GAAhBp0B,EAAEq6B,KAAIp6B,EAAEi6B,GAAGn7B,KAAey1B,cAAS,IAASz0B,GAAG,OAAOA,EAAEA,EAAE,KAAK00B,GAAG11B,EAAEmB,EAAED,GAAGH,EAAE+T,QAAQmf,MAAM/yB,EAAE2W,GAAG9W,EAAEG,EAAED,GAAG4mC,GAAG9mC,EAAEE,GAAUF,CAAC,CAAC,SAAS6pC,GAAG7pC,EAAEC,EAAEhB,EAAEiB,GAAG,IAAIC,EAAEF,EAAE8T,QAAQ3T,EAAEm6B,KAAIp1B,EAAEi1B,GAAGj6B,GAAsL,OAAnLlB,EAAE0qC,GAAG1qC,GAAG,OAAOgB,EAAEozB,QAAQpzB,EAAEozB,QAAQp0B,EAAEgB,EAAEigC,eAAejhC,GAAEgB,EAAEq0B,GAAGl0B,EAAE+E,IAAKsvB,QAAQ,CAACnxB,QAAQtD,GAAuB,QAApBE,OAAE,IAASA,EAAE,KAAKA,KAAaD,EAAEy0B,SAASx0B,GAAe,QAAZF,EAAE20B,GAAGx0B,EAAEF,EAAEkF,MAAc4zB,GAAG/4B,EAAEG,EAAEgF,EAAE/E,GAAGy0B,GAAG70B,EAAEG,EAAEgF,IAAWA,CAAC,CAC3b,SAAS2kC,GAAG9pC,GAAe,OAAZA,EAAEA,EAAE+T,SAAcF,OAAyB7T,EAAE6T,MAAM7K,IAAoDhJ,EAAE6T,MAAM9B,WAAhF,IAA0F,CAAC,SAASg4B,GAAG/pC,EAAEC,GAAqB,GAAG,QAArBD,EAAEA,EAAEyT,gBAA2B,OAAOzT,EAAE0T,WAAW,CAAC,IAAIzU,EAAEe,EAAEowB,UAAUpwB,EAAEowB,UAAU,IAAInxB,GAAGA,EAAEgB,EAAEhB,EAAEgB,CAAC,CAAC,CAAC,SAAS+pC,GAAGhqC,EAAEC,GAAG8pC,GAAG/pC,EAAEC,IAAID,EAAEA,EAAEqT,YAAY02B,GAAG/pC,EAAEC,EAAE,CAnB7SslC,GAAG,SAASvlC,EAAEC,EAAEhB,GAAG,GAAG,OAAOe,EAAE,GAAGA,EAAE0wB,gBAAgBzwB,EAAEgwB,cAAczC,GAAGzZ,QAAQof,IAAG,MAAO,CAAC,GAAG,KAAKnzB,EAAEkzB,MAAMj0B,IAAI,KAAa,IAARgB,EAAEsT,OAAW,OAAO4f,IAAG,EAzE1I,SAAYnzB,EAAEC,EAAEhB,GAAG,OAAOgB,EAAE+I,KAAK,KAAK,EAAEi3B,GAAGhgC,GAAG2wB,KAAK,MAAM,KAAK,EAAE8E,GAAGz1B,GAAG,MAAM,KAAK,EAAE6tB,GAAG7tB,EAAEZ,OAAO+uB,GAAGnuB,GAAG,MAAM,KAAK,EAAEs1B,GAAGt1B,EAAEA,EAAE8R,UAAUgH,eAAe,MAAM,KAAK,GAAG,IAAI7Y,EAAED,EAAEZ,KAAK+J,SAASjJ,EAAEF,EAAEywB,cAAcr1B,MAAMgyB,GAAEiF,GAAGpyB,EAAE0yB,eAAe1yB,EAAE0yB,cAAczyB,EAAE,MAAM,KAAK,GAAqB,GAAG,QAArBD,EAAED,EAAEwT,eAA2B,OAAG,OAAOvT,EAAEwT,YAAkB2Z,GAAEuI,GAAY,EAAVA,GAAE7hB,SAAW9T,EAAEsT,OAAO,IAAI,MAAQ,KAAKtU,EAAEgB,EAAE4T,MAAMif,YAAmB4N,GAAG1gC,EAAEC,EAAEhB,IAAGouB,GAAEuI,GAAY,EAAVA,GAAE7hB,SAA8B,QAAnB/T,EAAE8+B,GAAG9+B,EAAEC,EAAEhB,IAAmBe,EAAE8T,QAAQ,MAAKuZ,GAAEuI,GAAY,EAAVA,GAAE7hB,SAAW,MAAM,KAAK,GAC7d,GADge7T,EAAE,KAAKjB,EACrfgB,EAAE6yB,YAAe,KAAa,IAAR9yB,EAAEuT,OAAW,CAAC,GAAGrT,EAAE,OAAO4hC,GAAG9hC,EAAEC,EAAEhB,GAAGgB,EAAEsT,OAAO,GAAG,CAA6F,GAA1E,QAAlBpT,EAAEF,EAAEwT,iBAAyBtT,EAAEshC,UAAU,KAAKthC,EAAEyhC,KAAK,KAAKzhC,EAAEw4B,WAAW,MAAMtL,GAAEuI,GAAEA,GAAE7hB,SAAY7T,EAAE,MAAW,OAAO,KAAK,KAAK,GAAG,KAAK,GAAG,OAAOD,EAAEizB,MAAM,EAAEkM,GAAGp/B,EAAEC,EAAEhB,GAAG,OAAO6/B,GAAG9+B,EAAEC,EAAEhB,EAAE,CAwE7GgrC,CAAGjqC,EAAEC,EAAEhB,GAAGk0B,GAAG,KAAa,OAARnzB,EAAEuT,MAAmB,MAAM4f,IAAG,EAAGxD,IAAG,KAAa,QAAR1vB,EAAEsT,QAAgB+b,GAAGrvB,EAAE8uB,GAAG9uB,EAAEuxB,OAAiB,OAAVvxB,EAAEizB,MAAM,EAASjzB,EAAE+I,KAAK,KAAK,EAAE,IAAI9I,EAAED,EAAEZ,KAAKugC,GAAG5/B,EAAEC,GAAGD,EAAEC,EAAEgwB,aAAa,IAAI9vB,EAAEutB,GAAGztB,EAAEstB,GAAExZ,SAASgf,GAAG9yB,EAAEhB,GAAGkB,EAAE42B,GAAG,KAAK92B,EAAEC,EAAEF,EAAEG,EAAElB,GAAG,IAAImB,EAAEg3B,KACvI,OAD4In3B,EAAEsT,OAAO,EAAE,kBAAkBpT,GAAG,OAAOA,GAAG,oBAAoBA,EAAE8I,aAAQ,IAAS9I,EAAEgJ,UAAUlJ,EAAE+I,IAAI,EAAE/I,EAAEwT,cAAc,KAAKxT,EAAE6zB,YAC1e,KAAKhG,GAAG5tB,IAAIE,GAAE,EAAGguB,GAAGnuB,IAAIG,GAAE,EAAGH,EAAEwT,cAAc,OAAOtT,EAAEu8B,YAAO,IAASv8B,EAAEu8B,MAAMv8B,EAAEu8B,MAAM,KAAK7I,GAAG5zB,GAAGE,EAAEw8B,QAAQZ,GAAG97B,EAAE8R,UAAU5R,EAAEA,EAAE87B,gBAAgBh8B,EAAE88B,GAAG98B,EAAEC,EAAEF,EAAEf,GAAGgB,EAAE+/B,GAAG,KAAK//B,EAAEC,GAAE,EAAGE,EAAEnB,KAAKgB,EAAE+I,IAAI,EAAE2mB,IAAGvvB,GAAGmvB,GAAGtvB,GAAG2+B,GAAG,KAAK3+B,EAAEE,EAAElB,GAAGgB,EAAEA,EAAE4T,OAAc5T,EAAE,KAAK,GAAGC,EAAED,EAAEsD,YAAYvD,EAAE,CAAqF,OAApF4/B,GAAG5/B,EAAEC,GAAGD,EAAEC,EAAEgwB,aAAuB/vB,GAAVC,EAAED,EAAEoJ,OAAUpJ,EAAEmJ,UAAUpJ,EAAEZ,KAAKa,EAAEC,EAAEF,EAAE+I,IAQtU,SAAYhJ,GAAG,GAAG,oBAAoBA,EAAE,OAAOg/B,GAAGh/B,GAAG,EAAE,EAAE,QAAG,IAASA,GAAG,OAAOA,EAAE,CAAc,IAAbA,EAAEA,EAAEmJ,YAAgB7B,EAAG,OAAO,GAAG,GAAGtH,IAAIyH,EAAG,OAAO,EAAE,CAAC,OAAO,CAAC,CAR2LyiC,CAAGhqC,GAAGF,EAAE47B,GAAG17B,EAAEF,GAAUG,GAAG,KAAK,EAAEF,EAAEk/B,GAAG,KAAKl/B,EAAEC,EAAEF,EAAEf,GAAG,MAAMe,EAAE,KAAK,EAAEC,EAAE0/B,GAAG,KAAK1/B,EAAEC,EAAEF,EAAEf,GAAG,MAAMe,EAAE,KAAK,GAAGC,EAAE4+B,GAAG,KAAK5+B,EAAEC,EAAEF,EAAEf,GAAG,MAAMe,EAAE,KAAK,GAAGC,EAAE8+B,GAAG,KAAK9+B,EAAEC,EAAE07B,GAAG17B,EAAEb,KAAKW,GAAGf,GAAG,MAAMe,EAAE,MAAM1B,MAAM4F,EAAE,IACvgBhE,EAAE,IAAK,CAAC,OAAOD,EAAE,KAAK,EAAE,OAAOC,EAAED,EAAEZ,KAAKc,EAAEF,EAAEgwB,aAA2CkP,GAAGn/B,EAAEC,EAAEC,EAArCC,EAAEF,EAAEsD,cAAcrD,EAAEC,EAAEy7B,GAAG17B,EAAEC,GAAclB,GAAG,KAAK,EAAE,OAAOiB,EAAED,EAAEZ,KAAKc,EAAEF,EAAEgwB,aAA2C0P,GAAG3/B,EAAEC,EAAEC,EAArCC,EAAEF,EAAEsD,cAAcrD,EAAEC,EAAEy7B,GAAG17B,EAAEC,GAAclB,GAAG,KAAK,EAAEe,EAAE,CAAO,GAANigC,GAAGhgC,GAAM,OAAOD,EAAE,MAAM1B,MAAM4F,EAAE,MAAMhE,EAAED,EAAEgwB,aAA+B9vB,GAAlBC,EAAEH,EAAEwT,eAAkBnQ,QAAQ+wB,GAAGr0B,EAAEC,GAAG80B,GAAG90B,EAAEC,EAAE,KAAKjB,GAAG,IAAIkG,EAAElF,EAAEwT,cAA0B,GAAZvT,EAAEiF,EAAE7B,QAAWlD,EAAE0Y,aAAY,CAAC,GAAG1Y,EAAE,CAACkD,QAAQpD,EAAE4Y,cAAa,EAAG2wB,MAAMtkC,EAAEskC,MAAMC,0BAA0BvkC,EAAEukC,0BAA0BnK,YAAYp6B,EAAEo6B,aAAat/B,EAAE6zB,YAAYC,UAChf3zB,EAAEH,EAAEwT,cAAcrT,EAAU,IAARH,EAAEsT,MAAU,CAAuBtT,EAAEkgC,GAAGngC,EAAEC,EAAEC,EAAEjB,EAAjCkB,EAAEk9B,GAAG/+B,MAAM4F,EAAE,MAAMjE,IAAmB,MAAMD,CAAC,CAAM,GAAGE,IAAIC,EAAE,CAAuBF,EAAEkgC,GAAGngC,EAAEC,EAAEC,EAAEjB,EAAjCkB,EAAEk9B,GAAG/+B,MAAM4F,EAAE,MAAMjE,IAAmB,MAAMD,CAAC,CAAM,IAAI0vB,GAAGjD,GAAGxsB,EAAE8R,UAAUgH,cAAcxM,YAAYkjB,GAAGxvB,EAAE0vB,IAAE,EAAGC,GAAG,KAAK3wB,EAAEozB,GAAGpyB,EAAE,KAAKC,EAAEjB,GAAGgB,EAAE4T,MAAM5U,EAAEA,GAAGA,EAAEsU,OAAe,EAATtU,EAAEsU,MAAS,KAAKtU,EAAEA,EAAE6U,OAAQ,KAAI,CAAM,GAAL8c,KAAQ1wB,IAAIC,EAAE,CAACF,EAAE6+B,GAAG9+B,EAAEC,EAAEhB,GAAG,MAAMe,CAAC,CAAC4+B,GAAG5+B,EAAEC,EAAEC,EAAEjB,EAAE,CAACgB,EAAEA,EAAE4T,KAAK,CAAC,OAAO5T,EAAE,KAAK,EAAE,OAAOy1B,GAAGz1B,GAAG,OAAOD,GAAGuwB,GAAGtwB,GAAGC,EAAED,EAAEZ,KAAKc,EAAEF,EAAEgwB,aAAa7vB,EAAE,OAAOJ,EAAEA,EAAE0wB,cAAc,KAAKvrB,EAAEhF,EAAEwL,SAAS+f,GAAGxrB,EAAEC,GAAGgF,EAAE,KAAK,OAAO/E,GAAGsrB,GAAGxrB,EAAEE,KAAKH,EAAEsT,OAAO,IACnfmsB,GAAG1/B,EAAEC,GAAG2+B,GAAG5+B,EAAEC,EAAEkF,EAAElG,GAAGgB,EAAE4T,MAAM,KAAK,EAAE,OAAO,OAAO7T,GAAGuwB,GAAGtwB,GAAG,KAAK,KAAK,GAAG,OAAOygC,GAAG1gC,EAAEC,EAAEhB,GAAG,KAAK,EAAE,OAAOs2B,GAAGt1B,EAAEA,EAAE8R,UAAUgH,eAAe7Y,EAAED,EAAEgwB,aAAa,OAAOjwB,EAAEC,EAAE4T,MAAMue,GAAGnyB,EAAE,KAAKC,EAAEjB,GAAG2/B,GAAG5+B,EAAEC,EAAEC,EAAEjB,GAAGgB,EAAE4T,MAAM,KAAK,GAAG,OAAO3T,EAAED,EAAEZ,KAAKc,EAAEF,EAAEgwB,aAA2C4O,GAAG7+B,EAAEC,EAAEC,EAArCC,EAAEF,EAAEsD,cAAcrD,EAAEC,EAAEy7B,GAAG17B,EAAEC,GAAclB,GAAG,KAAK,EAAE,OAAO2/B,GAAG5+B,EAAEC,EAAEA,EAAEgwB,aAAahxB,GAAGgB,EAAE4T,MAAM,KAAK,EAAmD,KAAK,GAAG,OAAO+qB,GAAG5+B,EAAEC,EAAEA,EAAEgwB,aAAatkB,SAAS1M,GAAGgB,EAAE4T,MAAM,KAAK,GAAG7T,EAAE,CACxZ,GADyZE,EAAED,EAAEZ,KAAK+J,SAASjJ,EAAEF,EAAEgwB,aAAa7vB,EAAEH,EAAEywB,cAClfvrB,EAAEhF,EAAE9E,MAAMgyB,GAAEiF,GAAGpyB,EAAE0yB,eAAe1yB,EAAE0yB,cAAcztB,EAAK,OAAO/E,EAAE,GAAG2kB,GAAG3kB,EAAE/E,MAAM8J,IAAI,GAAG/E,EAAEuL,WAAWxL,EAAEwL,WAAW6hB,GAAGzZ,QAAQ,CAAC9T,EAAE6+B,GAAG9+B,EAAEC,EAAEhB,GAAG,MAAMe,CAAC,OAAO,IAAc,QAAVI,EAAEH,EAAE4T,SAAiBzT,EAAEkT,OAAOrT,GAAG,OAAOG,GAAG,CAAC,IAAIuI,EAAEvI,EAAE4yB,aAAa,GAAG,OAAOrqB,EAAE,CAACxD,EAAE/E,EAAEyT,MAAM,IAAI,IAAIjL,EAAED,EAAEsqB,aAAa,OAAOrqB,GAAG,CAAC,GAAGA,EAAEyqB,UAAUnzB,EAAE,CAAC,GAAG,IAAIE,EAAE4I,IAAI,EAACJ,EAAE0rB,IAAI,EAAEr1B,GAAGA,IAAK+J,IAAI,EAAE,IAAIN,EAAEtI,EAAE0zB,YAAY,GAAG,OAAOprB,EAAE,CAAY,IAAI9J,GAAf8J,EAAEA,EAAEwrB,QAAeC,QAAQ,OAAOv1B,EAAEgK,EAAEspB,KAAKtpB,GAAGA,EAAEspB,KAAKtzB,EAAEszB,KAAKtzB,EAAEszB,KAAKtpB,GAAGF,EAAEyrB,QAAQvrB,CAAC,CAAC,CAACxI,EAAE8yB,OAAOj0B,EAAgB,QAAd2J,EAAExI,EAAEiT,aAAqBzK,EAAEsqB,OAAOj0B,GAAG4zB,GAAGzyB,EAAEkT,OAClfrU,EAAEgB,GAAG0I,EAAEuqB,OAAOj0B,EAAE,KAAK,CAAC2J,EAAEA,EAAEspB,IAAI,CAAC,MAAM,GAAG,KAAK9xB,EAAE4I,IAAI7D,EAAE/E,EAAEf,OAAOY,EAAEZ,KAAK,KAAKe,EAAEyT,WAAW,GAAG,KAAKzT,EAAE4I,IAAI,CAAY,GAAG,QAAd7D,EAAE/E,EAAEkT,QAAmB,MAAMhV,MAAM4F,EAAE,MAAMiB,EAAE+tB,OAAOj0B,EAAgB,QAAd0J,EAAExD,EAAEkO,aAAqB1K,EAAEuqB,OAAOj0B,GAAG4zB,GAAG1tB,EAAElG,EAAEgB,GAAGkF,EAAE/E,EAAE0T,OAAO,MAAM3O,EAAE/E,EAAEyT,MAAM,GAAG,OAAO1O,EAAEA,EAAEmO,OAAOlT,OAAO,IAAI+E,EAAE/E,EAAE,OAAO+E,GAAG,CAAC,GAAGA,IAAIlF,EAAE,CAACkF,EAAE,KAAK,KAAK,CAAa,GAAG,QAAf/E,EAAE+E,EAAE2O,SAAoB,CAAC1T,EAAEkT,OAAOnO,EAAEmO,OAAOnO,EAAE/E,EAAE,KAAK,CAAC+E,EAAEA,EAAEmO,MAAM,CAAClT,EAAE+E,CAAC,CAACy5B,GAAG5+B,EAAEC,EAAEE,EAAEwL,SAAS1M,GAAGgB,EAAEA,EAAE4T,KAAK,CAAC,OAAO5T,EAAE,KAAK,EAAE,OAAOE,EAAEF,EAAEZ,KAAKa,EAAED,EAAEgwB,aAAatkB,SAASonB,GAAG9yB,EAAEhB,GAAWiB,EAAEA,EAAVC,EAAEizB,GAAGjzB,IAAUF,EAAEsT,OAAO,EAAEqrB,GAAG5+B,EAAEC,EAAEC,EAAEjB,GACpfgB,EAAE4T,MAAM,KAAK,GAAG,OAAgB1T,EAAEy7B,GAAX17B,EAAED,EAAEZ,KAAYY,EAAEgwB,cAA6B8O,GAAG/+B,EAAEC,EAAEC,EAAtBC,EAAEy7B,GAAG17B,EAAEb,KAAKc,GAAclB,GAAG,KAAK,GAAG,OAAOigC,GAAGl/B,EAAEC,EAAEA,EAAEZ,KAAKY,EAAEgwB,aAAahxB,GAAG,KAAK,GAAG,OAAOiB,EAAED,EAAEZ,KAAKc,EAAEF,EAAEgwB,aAAa9vB,EAAEF,EAAEsD,cAAcrD,EAAEC,EAAEy7B,GAAG17B,EAAEC,GAAGy/B,GAAG5/B,EAAEC,GAAGA,EAAE+I,IAAI,EAAE8kB,GAAG5tB,IAAIF,GAAE,EAAGouB,GAAGnuB,IAAID,GAAE,EAAG+yB,GAAG9yB,EAAEhB,GAAGu9B,GAAGv8B,EAAEC,EAAEC,GAAG48B,GAAG98B,EAAEC,EAAEC,EAAElB,GAAG+gC,GAAG,KAAK//B,EAAEC,GAAE,EAAGF,EAAEf,GAAG,KAAK,GAAG,OAAO6iC,GAAG9hC,EAAEC,EAAEhB,GAAG,KAAK,GAAG,OAAOmgC,GAAGp/B,EAAEC,EAAEhB,GAAG,MAAMX,MAAM4F,EAAE,IAAIjE,EAAE+I,KAAM,EAYxC,IAAImhC,GAAG,oBAAoBC,YAAYA,YAAY,SAASpqC,GAAG09B,QAAQv/B,MAAM6B,EAAE,EAAE,SAASqqC,GAAGrqC,GAAGlC,KAAKwsC,cAActqC,CAAC,CACjI,SAASuqC,GAAGvqC,GAAGlC,KAAKwsC,cAActqC,CAAC,CAC5J,SAASwqC,GAAGxqC,GAAG,SAASA,GAAG,IAAIA,EAAE8M,UAAU,IAAI9M,EAAE8M,UAAU,KAAK9M,EAAE8M,SAAS,CAAC,SAAS29B,GAAGzqC,GAAG,SAASA,GAAG,IAAIA,EAAE8M,UAAU,IAAI9M,EAAE8M,UAAU,KAAK9M,EAAE8M,WAAW,IAAI9M,EAAE8M,UAAU,iCAAiC9M,EAAE+M,WAAW,CAAC,SAAS29B,KAAK,CAExa,SAASC,GAAG3qC,EAAEC,EAAEhB,EAAEiB,EAAEC,GAAG,IAAIC,EAAEnB,EAAEglC,oBAAoB,GAAG7jC,EAAE,CAAC,IAAI+E,EAAE/E,EAAE,GAAG,oBAAoBD,EAAE,CAAC,IAAIwI,EAAExI,EAAEA,EAAE,WAAW,IAAIH,EAAE8pC,GAAG3kC,GAAGwD,EAAEnO,KAAKwF,EAAE,CAAC,CAAC6pC,GAAG5pC,EAAEkF,EAAEnF,EAAEG,EAAE,MAAMgF,EADxJ,SAAYnF,EAAEC,EAAEhB,EAAEiB,EAAEC,GAAG,GAAGA,EAAE,CAAC,GAAG,oBAAoBD,EAAE,CAAC,IAAIE,EAAEF,EAAEA,EAAE,WAAW,IAAIF,EAAE8pC,GAAG3kC,GAAG/E,EAAE5F,KAAKwF,EAAE,CAAC,CAAC,IAAImF,EAAEykC,GAAG3pC,EAAEC,EAAEF,EAAE,EAAE,MAAK,EAAG,EAAG,GAAG0qC,IAAmF,OAA/E1qC,EAAEikC,oBAAoB9+B,EAAEnF,EAAEuqB,IAAIplB,EAAE4O,QAAQ6V,GAAG,IAAI5pB,EAAE8M,SAAS9M,EAAEyR,WAAWzR,GAAGqoC,KAAYljC,CAAC,CAAC,KAAKhF,EAAEH,EAAE6M,WAAW7M,EAAEwM,YAAYrM,GAAG,GAAG,oBAAoBD,EAAE,CAAC,IAAIyI,EAAEzI,EAAEA,EAAE,WAAW,IAAIF,EAAE8pC,GAAGlhC,GAAGD,EAAEnO,KAAKwF,EAAE,CAAC,CAAC,IAAI4I,EAAE4gC,GAAGxpC,EAAE,GAAE,EAAG,KAAK,GAAK,EAAG,EAAG,GAAG0qC,IAA0G,OAAtG1qC,EAAEikC,oBAAoBr7B,EAAE5I,EAAEuqB,IAAI3hB,EAAEmL,QAAQ6V,GAAG,IAAI5pB,EAAE8M,SAAS9M,EAAEyR,WAAWzR,GAAGqoC,IAAG,WAAWwB,GAAG5pC,EAAE2I,EAAE3J,EAAEiB,EAAE,IAAU0I,CAAC,CACpUgiC,CAAG3rC,EAAEgB,EAAED,EAAEG,EAAED,GAAG,OAAO4pC,GAAG3kC,EAAE,CAHpLolC,GAAGzwC,UAAUmP,OAAOohC,GAAGvwC,UAAUmP,OAAO,SAASjJ,GAAG,IAAIC,EAAEnC,KAAKwsC,cAAc,GAAG,OAAOrqC,EAAE,MAAM3B,MAAM4F,EAAE,MAAM2lC,GAAG7pC,EAAEC,EAAE,KAAK,KAAK,EAAEsqC,GAAGzwC,UAAU+wC,QAAQR,GAAGvwC,UAAU+wC,QAAQ,WAAW,IAAI7qC,EAAElC,KAAKwsC,cAAc,GAAG,OAAOtqC,EAAE,CAAClC,KAAKwsC,cAAc,KAAK,IAAIrqC,EAAED,EAAE+Y,cAAcsvB,IAAG,WAAWwB,GAAG,KAAK7pC,EAAE,KAAK,KAAK,IAAGC,EAAEsqB,IAAI,IAAI,CAAC,EACzTggB,GAAGzwC,UAAUgxC,2BAA2B,SAAS9qC,GAAG,GAAGA,EAAE,CAAC,IAAIC,EAAEqX,KAAKtX,EAAE,CAACuY,UAAU,KAAKvd,OAAOgF,EAAE6Y,SAAS5Y,GAAG,IAAI,IAAIhB,EAAE,EAAEA,EAAE+Y,GAAG9b,QAAQ,IAAI+D,GAAGA,EAAE+X,GAAG/Y,GAAG4Z,SAAS5Z,KAAK+Y,GAAG+yB,OAAO9rC,EAAE,EAAEe,GAAG,IAAIf,GAAG0Z,GAAG3Y,EAAE,CAAC,EAEXmX,GAAG,SAASnX,GAAG,OAAOA,EAAEgJ,KAAK,KAAK,EAAE,IAAI/I,EAAED,EAAE+R,UAAU,GAAG9R,EAAE8T,QAAQN,cAAcqF,aAAa,CAAC,IAAI7Z,EAAEkX,GAAGlW,EAAEoW,cAAc,IAAIpX,IAAI+X,GAAG/W,EAAI,EAAFhB,GAAK6nC,GAAG7mC,EAAEyU,MAAK,KAAO,EAAFkgB,MAAOiO,GAAGnuB,KAAI,IAAIia,MAAM,CAAC,MAAM,KAAK,GAAG0Z,IAAG,WAAW,IAAIpoC,EAAE0zB,GAAG3zB,EAAE,GAAG,GAAG,OAAOC,EAAE,CAAC,IAAIhB,EAAEs7B,KAAIxB,GAAG94B,EAAED,EAAE,EAAEf,EAAE,CAAC,IAAG+qC,GAAGhqC,EAAE,GAAG,EAC/boX,GAAG,SAASpX,GAAG,GAAG,KAAKA,EAAEgJ,IAAI,CAAC,IAAI/I,EAAE0zB,GAAG3zB,EAAE,WAAW,GAAG,OAAOC,EAAa84B,GAAG94B,EAAED,EAAE,UAAXu6B,MAAwByP,GAAGhqC,EAAE,UAAU,CAAC,EAAEqX,GAAG,SAASrX,GAAG,GAAG,KAAKA,EAAEgJ,IAAI,CAAC,IAAI/I,EAAEm6B,GAAGp6B,GAAGf,EAAE00B,GAAG3zB,EAAEC,GAAG,GAAG,OAAOhB,EAAa85B,GAAG95B,EAAEe,EAAEC,EAAXs6B,MAAgByP,GAAGhqC,EAAEC,EAAE,CAAC,EAAEqX,GAAG,WAAW,OAAOL,EAAC,EAAEM,GAAG,SAASvX,EAAEC,GAAG,IAAIhB,EAAEgY,GAAE,IAAI,OAAOA,GAAEjX,EAAEC,GAAG,CAAC,QAAQgX,GAAEhY,CAAC,CAAC,EAClSyS,GAAG,SAAS1R,EAAEC,EAAEhB,GAAG,OAAOgB,GAAG,IAAK,QAAyB,GAAjB+K,EAAGhL,EAAEf,GAAGgB,EAAEhB,EAAE/D,KAAQ,UAAU+D,EAAEI,MAAM,MAAMY,EAAE,CAAC,IAAIhB,EAAEe,EAAEf,EAAEwS,YAAYxS,EAAEA,EAAEwS,WAAsF,IAA3ExS,EAAEA,EAAE+rC,iBAAiB,cAAcC,KAAKC,UAAU,GAAGjrC,GAAG,mBAAuBA,EAAE,EAAEA,EAAEhB,EAAE/C,OAAO+D,IAAI,CAAC,IAAIC,EAAEjB,EAAEgB,GAAG,GAAGC,IAAIF,GAAGE,EAAEirC,OAAOnrC,EAAEmrC,KAAK,CAAC,IAAIhrC,EAAE6R,GAAG9R,GAAG,IAAIC,EAAE,MAAM7B,MAAM4F,EAAE,KAAKgG,EAAGhK,GAAG8K,EAAG9K,EAAEC,EAAE,CAAC,CAAC,CAAC,MAAM,IAAK,WAAW0L,GAAG7L,EAAEf,GAAG,MAAM,IAAK,SAAmB,OAAVgB,EAAEhB,EAAE5D,QAAegQ,GAAGrL,IAAIf,EAAEmjC,SAASniC,GAAE,GAAI,EAAEkS,GAAGi2B,GAAGh2B,GAAGi2B,GACpa,IAAI+C,GAAG,CAACC,uBAAsB,EAAGC,OAAO,CAACx5B,GAAGkS,GAAGhS,GAAGC,GAAGC,GAAGk2B,KAAKmD,GAAG,CAACC,wBAAwB5yB,GAAG6yB,WAAW,EAAEC,QAAQ,SAASC,oBAAoB,aAC1IC,GAAG,CAACH,WAAWF,GAAGE,WAAWC,QAAQH,GAAGG,QAAQC,oBAAoBJ,GAAGI,oBAAoBE,eAAeN,GAAGM,eAAeC,kBAAkB,KAAKC,4BAA4B,KAAKC,4BAA4B,KAAKC,cAAc,KAAKC,wBAAwB,KAAKC,wBAAwB,KAAKC,gBAAgB,KAAKC,mBAAmB,KAAKC,eAAe,KAAKC,qBAAqB5lC,EAAGwvB,uBAAuBqW,wBAAwB,SAASxsC,GAAW,OAAO,QAAfA,EAAE4T,GAAG5T,IAAmB,KAAKA,EAAE+R,SAAS,EAAEy5B,wBAAwBD,GAAGC,yBARjN,WAAc,OAAO,IAAI,EASpUiB,4BAA4B,KAAKC,gBAAgB,KAAKC,aAAa,KAAKC,kBAAkB,KAAKC,gBAAgB,KAAKC,kBAAkB,mCAAmC,GAAG,qBAAqBC,+BAA+B,CAAC,IAAIC,GAAGD,+BAA+B,IAAIC,GAAGC,YAAYD,GAAGE,cAAc,IAAI13B,GAAGw3B,GAAGG,OAAOvB,IAAIn2B,GAAGu3B,EAAE,CAAC,MAAMhtC,IAAG,CAAC,CAACtE,EAAQkL,mDAAmDwkC,GAC/Y1vC,EAAQ0xC,aAAa,SAASptC,EAAEC,GAAG,IAAIhB,EAAE,EAAEjD,UAAUE,aAAQ,IAASF,UAAU,GAAGA,UAAU,GAAG,KAAK,IAAIwuC,GAAGvqC,GAAG,MAAM3B,MAAM4F,EAAE,MAAM,OAbuH,SAAYlE,EAAEC,EAAEhB,GAAG,IAAIiB,EAAE,EAAElE,UAAUE,aAAQ,IAASF,UAAU,GAAGA,UAAU,GAAG,KAAK,MAAM,CAACmN,SAASnC,EAAGrM,IAAI,MAAMuF,EAAE,KAAK,GAAGA,EAAEyL,SAAS3L,EAAE+Y,cAAc9Y,EAAE2xB,eAAe3yB,EAAE,CAa1RouC,CAAGrtC,EAAEC,EAAE,KAAKhB,EAAE,EAAEvD,EAAQ4xC,WAAW,SAASttC,EAAEC,GAAG,IAAIuqC,GAAGxqC,GAAG,MAAM1B,MAAM4F,EAAE,MAAM,IAAIjF,GAAE,EAAGiB,EAAE,GAAGC,EAAEgqC,GAA4P,OAAzP,OAAOlqC,QAAG,IAASA,KAAI,IAAKA,EAAEstC,sBAAsBtuC,GAAE,QAAI,IAASgB,EAAE07B,mBAAmBz7B,EAAED,EAAE07B,uBAAkB,IAAS17B,EAAE6oC,qBAAqB3oC,EAAEF,EAAE6oC,qBAAqB7oC,EAAEupC,GAAGxpC,EAAE,GAAE,EAAG,KAAK,EAAKf,EAAE,EAAGiB,EAAEC,GAAGH,EAAEuqB,IAAItqB,EAAE8T,QAAQ6V,GAAG,IAAI5pB,EAAE8M,SAAS9M,EAAEyR,WAAWzR,GAAU,IAAIqqC,GAAGpqC,EAAE,EACrfvE,EAAQ8xC,YAAY,SAASxtC,GAAG,GAAG,MAAMA,EAAE,OAAO,KAAK,GAAG,IAAIA,EAAE8M,SAAS,OAAO9M,EAAE,IAAIC,EAAED,EAAEi8B,gBAAgB,QAAG,IAASh8B,EAAE,CAAC,GAAG,oBAAoBD,EAAEiJ,OAAO,MAAM3K,MAAM4F,EAAE,MAAiC,MAA3BlE,EAAEnG,OAAOmW,KAAKhQ,GAAGqxB,KAAK,KAAW/yB,MAAM4F,EAAE,IAAIlE,GAAI,CAAqC,OAA5BA,EAAE,QAAVA,EAAE4T,GAAG3T,IAAc,KAAKD,EAAE+R,SAAkB,EAAErW,EAAQ+xC,UAAU,SAASztC,GAAG,OAAOqoC,GAAGroC,EAAE,EAAEtE,EAAQgyC,QAAQ,SAAS1tC,EAAEC,EAAEhB,GAAG,IAAIwrC,GAAGxqC,GAAG,MAAM3B,MAAM4F,EAAE,MAAM,OAAOymC,GAAG,KAAK3qC,EAAEC,GAAE,EAAGhB,EAAE,EAC/YvD,EAAQiyC,YAAY,SAAS3tC,EAAEC,EAAEhB,GAAG,IAAIurC,GAAGxqC,GAAG,MAAM1B,MAAM4F,EAAE,MAAM,IAAIhE,EAAE,MAAMjB,GAAGA,EAAE2uC,iBAAiB,KAAKztC,GAAE,EAAGC,EAAE,GAAG+E,EAAEglC,GAAyO,GAAtO,OAAOlrC,QAAG,IAASA,KAAI,IAAKA,EAAEsuC,sBAAsBptC,GAAE,QAAI,IAASlB,EAAE08B,mBAAmBv7B,EAAEnB,EAAE08B,uBAAkB,IAAS18B,EAAE6pC,qBAAqB3jC,EAAElG,EAAE6pC,qBAAqB7oC,EAAE2pC,GAAG3pC,EAAE,KAAKD,EAAE,EAAE,MAAMf,EAAEA,EAAE,KAAKkB,EAAE,EAAGC,EAAE+E,GAAGnF,EAAEuqB,IAAItqB,EAAE8T,QAAQ6V,GAAG5pB,GAAME,EAAE,IAAIF,EAAE,EAAEA,EAAEE,EAAEhE,OAAO8D,IAA2BG,GAAhBA,GAAPlB,EAAEiB,EAAEF,IAAO6tC,aAAgB5uC,EAAE6uC,SAAS,MAAM7tC,EAAEspC,gCAAgCtpC,EAAEspC,gCAAgC,CAACtqC,EAAEkB,GAAGF,EAAEspC,gCAAgC7qC,KAAKO,EACvhBkB,GAAG,OAAO,IAAIoqC,GAAGtqC,EAAE,EAAEvE,EAAQuN,OAAO,SAASjJ,EAAEC,EAAEhB,GAAG,IAAIwrC,GAAGxqC,GAAG,MAAM3B,MAAM4F,EAAE,MAAM,OAAOymC,GAAG,KAAK3qC,EAAEC,GAAE,EAAGhB,EAAE,EAAEvD,EAAQqyC,uBAAuB,SAAS/tC,GAAG,IAAIyqC,GAAGzqC,GAAG,MAAM1B,MAAM4F,EAAE,KAAK,QAAOlE,EAAEikC,sBAAqBoE,IAAG,WAAWsC,GAAG,KAAK,KAAK3qC,GAAE,GAAG,WAAWA,EAAEikC,oBAAoB,KAAKjkC,EAAEuqB,IAAI,IAAI,GAAE,KAAG,EAAM,EAAE7uB,EAAQsyC,wBAAwB5F,GAC/U1sC,EAAQuyC,oCAAoC,SAASjuC,EAAEC,EAAEhB,EAAEiB,GAAG,IAAIuqC,GAAGxrC,GAAG,MAAMX,MAAM4F,EAAE,MAAM,GAAG,MAAMlE,QAAG,IAASA,EAAEi8B,gBAAgB,MAAM39B,MAAM4F,EAAE,KAAK,OAAOymC,GAAG3qC,EAAEC,EAAEhB,GAAE,EAAGiB,EAAE,EAAExE,EAAQgwC,QAAQ,8DC/T7L,IAAI9sC,EAAIyC,EAAQ,KAEd3F,EAAQ4xC,WAAa1uC,EAAE0uC,WACvB5xC,EAAQiyC,YAAc/uC,EAAE+uC,yCCH1B,SAASO,IAEP,GAC4C,qBAAnCnB,gCAC4C,oBAA5CA,+BAA+BmB,SAcxC,IAEEnB,+BAA+BmB,SAASA,EAC1C,CAAE,MAAO7vC,GAGPq/B,QAAQv/B,MAAME,EAChB,CACF,CAKE6vC,GACAzyC,EAAOC,QAAU,EAAjBD,iCCzBW,IAAI2E,EAAEiB,EAAQ,IAASuH,EAAE9B,OAAOC,IAAI,iBAAiB2B,EAAE5B,OAAOC,IAAI,kBAAkBnI,EAAE/E,OAAOC,UAAUC,eAAegwB,EAAE3pB,EAAEwG,mDAAmD+3B,kBAAkBz6B,EAAE,CAACvJ,KAAI,EAAGq2B,KAAI,EAAGmd,QAAO,EAAGC,UAAS,GAChP,SAASrc,EAAE9yB,EAAEe,EAAEmF,GAAG,IAAIlF,EAAEC,EAAE,CAAC,EAAEC,EAAE,KAAKwI,EAAE,KAAiF,IAAI1I,UAAhF,IAASkF,IAAIhF,EAAE,GAAGgF,QAAG,IAASnF,EAAErF,MAAMwF,EAAE,GAAGH,EAAErF,UAAK,IAASqF,EAAEgxB,MAAMroB,EAAE3I,EAAEgxB,KAAchxB,EAAEpB,EAAEpE,KAAKwF,EAAEC,KAAKiE,EAAEnK,eAAekG,KAAKC,EAAED,GAAGD,EAAEC,IAAI,GAAGhB,GAAGA,EAAE48B,aAAa,IAAI57B,KAAKD,EAAEf,EAAE48B,kBAAe,IAAS37B,EAAED,KAAKC,EAAED,GAAGD,EAAEC,IAAI,MAAM,CAACkJ,SAASP,EAAEvJ,KAAKJ,EAAEtE,IAAIwF,EAAE6wB,IAAIroB,EAAEjH,MAAMxB,EAAE+wB,OAAOlH,EAAEhW,QAAQ,CAACrY,EAAQ2yC,SAAS3lC,EAAEhN,EAAQ4yC,IAAIvc,EAAEr2B,EAAQ6yC,KAAKxc,4BCD7V,IAAIrpB,EAAE5B,OAAOC,IAAI,iBAAiBgjB,EAAEjjB,OAAOC,IAAI,gBAAgB7C,EAAE4C,OAAOC,IAAI,kBAAkBgrB,EAAEjrB,OAAOC,IAAI,qBAAqBirB,EAAElrB,OAAOC,IAAI,kBAAkBijB,EAAEljB,OAAOC,IAAI,kBAAkBojB,EAAErjB,OAAOC,IAAI,iBAAiB7B,EAAE4B,OAAOC,IAAI,qBAAqBqjB,EAAEtjB,OAAOC,IAAI,kBAAkBmjB,EAAEpjB,OAAOC,IAAI,cAAckrB,EAAEnrB,OAAOC,IAAI,cAAcpB,EAAEmB,OAAOe,SACzW,IAAI6M,EAAE,CAACsnB,UAAU,WAAW,OAAM,CAAE,EAAEI,mBAAmB,WAAW,EAAED,oBAAoB,WAAW,EAAED,gBAAgB,WAAW,GAAGjlB,EAAEpd,OAAOoO,OAAOohB,EAAE,CAAC,EAAE,SAAS+D,EAAEptB,EAAEC,EAAEE,GAAGrC,KAAK4D,MAAM1B,EAAElC,KAAKu1B,QAAQpzB,EAAEnC,KAAKqzB,KAAK9H,EAAEvrB,KAAK6+B,QAAQx8B,GAAGuU,CAAC,CACwI,SAAS2V,IAAI,CAAyB,SAASgD,EAAErtB,EAAEC,EAAEE,GAAGrC,KAAK4D,MAAM1B,EAAElC,KAAKu1B,QAAQpzB,EAAEnC,KAAKqzB,KAAK9H,EAAEvrB,KAAK6+B,QAAQx8B,GAAGuU,CAAC,CADxP0Y,EAAEtzB,UAAUsvC,iBAAiB,CAAC,EACpQhc,EAAEtzB,UAAU00C,SAAS,SAASxuC,EAAEC,GAAG,GAAG,kBAAkBD,GAAG,oBAAoBA,GAAG,MAAMA,EAAE,MAAM1B,MAAM,yHAAyHR,KAAK6+B,QAAQT,gBAAgBp+B,KAAKkC,EAAEC,EAAE,WAAW,EAAEmtB,EAAEtzB,UAAU20C,YAAY,SAASzuC,GAAGlC,KAAK6+B,QAAQP,mBAAmBt+B,KAAKkC,EAAE,cAAc,EAAgBqqB,EAAEvwB,UAAUszB,EAAEtzB,UAAsF,IAAIyzB,EAAEF,EAAEvzB,UAAU,IAAIuwB,EACrfkD,EAAEzyB,YAAYuyB,EAAEpW,EAAEsW,EAAEH,EAAEtzB,WAAWyzB,EAAEgP,sBAAqB,EAAG,IAAI5M,EAAEp1B,MAAMF,QAAQ4vB,EAAEpwB,OAAOC,UAAUC,eAAe66B,EAAE,CAAC7gB,QAAQ,MAAM6hB,EAAE,CAACj7B,KAAI,EAAGq2B,KAAI,EAAGmd,QAAO,EAAGC,UAAS,GACtK,SAAS9X,EAAEt2B,EAAEC,EAAEE,GAAG,IAAID,EAAEjB,EAAE,CAAC,EAAE2J,EAAE,KAAKD,EAAE,KAAK,GAAG,MAAM1I,EAAE,IAAIC,UAAK,IAASD,EAAE+wB,MAAMroB,EAAE1I,EAAE+wB,UAAK,IAAS/wB,EAAEtF,MAAMiO,EAAE,GAAG3I,EAAEtF,KAAKsF,EAAEgqB,EAAEzvB,KAAKyF,EAAEC,KAAK01B,EAAE77B,eAAemG,KAAKjB,EAAEiB,GAAGD,EAAEC,IAAI,IAAIiF,EAAEnJ,UAAUE,OAAO,EAAE,GAAG,IAAIiJ,EAAElG,EAAE0M,SAASxL,OAAO,GAAG,EAAEgF,EAAE,CAAC,IAAI,IAAI/E,EAAE7F,MAAM4K,GAAGvG,EAAE,EAAEA,EAAEuG,EAAEvG,IAAIwB,EAAExB,GAAG5C,UAAU4C,EAAE,GAAGK,EAAE0M,SAASvL,CAAC,CAAC,GAAGJ,GAAGA,EAAE67B,aAAa,IAAI37B,KAAKiF,EAAEnF,EAAE67B,kBAAe,IAAS58B,EAAEiB,KAAKjB,EAAEiB,GAAGiF,EAAEjF,IAAI,MAAM,CAACiJ,SAAST,EAAErJ,KAAKW,EAAErF,IAAIiO,EAAEooB,IAAIroB,EAAEjH,MAAMzC,EAAEgyB,OAAO2D,EAAE7gB,QAAQ,CAChV,SAASyiB,EAAEx2B,GAAG,MAAM,kBAAkBA,GAAG,OAAOA,GAAGA,EAAEmJ,WAAWT,CAAC,CAAoG,IAAImuB,EAAE,OAAO,SAAS4B,EAAEz4B,EAAEC,GAAG,MAAM,kBAAkBD,GAAG,OAAOA,GAAG,MAAMA,EAAErF,IAA7K,SAAgBqF,GAAG,IAAIC,EAAE,CAAC,IAAI,KAAK,IAAI,MAAM,MAAM,IAAID,EAAEjD,QAAQ,SAAQ,SAASiD,GAAG,OAAOC,EAAED,EAAE,GAAE,CAA+E0uC,CAAO,GAAG1uC,EAAErF,KAAKsF,EAAEhG,SAAS,GAAG,CAC/W,SAASsgC,EAAEv6B,EAAEC,EAAEE,EAAED,EAAEjB,GAAG,IAAI2J,SAAS5I,EAAK,cAAc4I,GAAG,YAAYA,IAAE5I,EAAE,MAAK,IAAI2I,GAAE,EAAG,GAAG,OAAO3I,EAAE2I,GAAE,OAAQ,OAAOC,GAAG,IAAK,SAAS,IAAK,SAASD,GAAE,EAAG,MAAM,IAAK,SAAS,OAAO3I,EAAEmJ,UAAU,KAAKT,EAAE,KAAKqhB,EAAEphB,GAAE,GAAI,GAAGA,EAAE,OAAW1J,EAAEA,EAAN0J,EAAE3I,GAASA,EAAE,KAAKE,EAAE,IAAIu4B,EAAE9vB,EAAE,GAAGzI,EAAEyvB,EAAE1wB,IAAIkB,EAAE,GAAG,MAAMH,IAAIG,EAAEH,EAAEjD,QAAQ85B,EAAE,OAAO,KAAK0D,EAAEt7B,EAAEgB,EAAEE,EAAE,IAAG,SAASH,GAAG,OAAOA,CAAC,KAAI,MAAMf,IAAIu3B,EAAEv3B,KAAKA,EADnW,SAAWe,EAAEC,GAAG,MAAM,CAACkJ,SAAST,EAAErJ,KAAKW,EAAEX,KAAK1E,IAAIsF,EAAE+wB,IAAIhxB,EAAEgxB,IAAItvB,MAAM1B,EAAE0B,MAAMuvB,OAAOjxB,EAAEixB,OAAO,CACyQsF,CAAEt3B,EAAEkB,IAAIlB,EAAEtE,KAAKgO,GAAGA,EAAEhO,MAAMsE,EAAEtE,IAAI,IAAI,GAAGsE,EAAEtE,KAAKoC,QAAQ85B,EAAE,OAAO,KAAK72B,IAAIC,EAAEvB,KAAKO,IAAI,EAAyB,GAAvB0J,EAAE,EAAEzI,EAAE,KAAKA,EAAE,IAAIA,EAAE,IAAOyvB,EAAE3vB,GAAG,IAAI,IAAImF,EAAE,EAAEA,EAAEnF,EAAE9D,OAAOiJ,IAAI,CAC/e,IAAI/E,EAAEF,EAAEu4B,EADwe7vB,EACrf5I,EAAEmF,GAAeA,GAAGwD,GAAG4xB,EAAE3xB,EAAE3I,EAAEE,EAAEC,EAAEnB,EAAE,MAAM,GAAGmB,EAPsU,SAAWJ,GAAG,OAAG,OAAOA,GAAG,kBAAkBA,EAAS,KAAsC,oBAAjCA,EAAE2F,GAAG3F,EAAE2F,IAAI3F,EAAE,eAA0CA,EAAE,IAAI,CAO5bgI,CAAEhI,GAAG,oBAAoBI,EAAE,IAAIJ,EAAEI,EAAE5F,KAAKwF,GAAGmF,EAAE,IAAIyD,EAAE5I,EAAEkyB,QAAQC,MAA6BxpB,GAAG4xB,EAA1B3xB,EAAEA,EAAEvN,MAA0B4E,EAAEE,EAAtBC,EAAEF,EAAEu4B,EAAE7vB,EAAEzD,KAAkBlG,QAAQ,GAAG,WAAW2J,EAAE,MAAM3I,EAAE8f,OAAO/f,GAAG1B,MAAM,mDAAmD,oBAAoB2B,EAAE,qBAAqBpG,OAAOmW,KAAKhQ,GAAGqxB,KAAK,MAAM,IAAIpxB,GAAG,6EAA6E,OAAO0I,CAAC,CACzZ,SAASq5B,EAAEhiC,EAAEC,EAAEE,GAAG,GAAG,MAAMH,EAAE,OAAOA,EAAE,IAAIE,EAAE,GAAGjB,EAAE,EAAmD,OAAjDs7B,EAAEv6B,EAAEE,EAAE,GAAG,IAAG,SAASF,GAAG,OAAOC,EAAEzF,KAAK2F,EAAEH,EAAEf,IAAI,IAAUiB,CAAC,CAAC,SAAS0iC,EAAE5iC,GAAG,IAAI,IAAIA,EAAE2uC,QAAQ,CAAC,IAAI1uC,EAAED,EAAE4uC,SAAQ3uC,EAAEA,KAAMosB,MAAK,SAASpsB,GAAM,IAAID,EAAE2uC,UAAU,IAAI3uC,EAAE2uC,UAAQ3uC,EAAE2uC,QAAQ,EAAE3uC,EAAE4uC,QAAQ3uC,EAAC,IAAE,SAASA,GAAM,IAAID,EAAE2uC,UAAU,IAAI3uC,EAAE2uC,UAAQ3uC,EAAE2uC,QAAQ,EAAE3uC,EAAE4uC,QAAQ3uC,EAAC,KAAI,IAAID,EAAE2uC,UAAU3uC,EAAE2uC,QAAQ,EAAE3uC,EAAE4uC,QAAQ3uC,EAAE,CAAC,GAAG,IAAID,EAAE2uC,QAAQ,OAAO3uC,EAAE4uC,QAAQ/tC,QAAQ,MAAMb,EAAE4uC,OAAQ,CAC5Z,IAAI3L,EAAE,CAAClvB,QAAQ,MAAMqvB,EAAE,CAACxpB,WAAW,MAAM0pB,EAAE,CAACnN,uBAAuB8M,EAAExpB,wBAAwB2pB,EAAEzE,kBAAkB/J,GAAG,SAASuP,IAAI,MAAM7lC,MAAM,2DAA4D,CACzM5C,EAAQmzC,SAAS,CAACC,IAAI9M,EAAEhhC,QAAQ,SAAShB,EAAEC,EAAEE,GAAG6hC,EAAEhiC,GAAE,WAAWC,EAAEkB,MAAMrD,KAAK9B,UAAU,GAAEmE,EAAE,EAAE4uC,MAAM,SAAS/uC,GAAG,IAAIC,EAAE,EAAuB,OAArB+hC,EAAEhiC,GAAE,WAAWC,GAAG,IAAUA,CAAC,EAAE+uC,QAAQ,SAAShvC,GAAG,OAAOgiC,EAAEhiC,GAAE,SAASA,GAAG,OAAOA,CAAC,KAAI,EAAE,EAAEivC,KAAK,SAASjvC,GAAG,IAAIw2B,EAAEx2B,GAAG,MAAM1B,MAAM,yEAAyE,OAAO0B,CAAC,GAAGtE,EAAQwzC,UAAU9hB,EAAE1xB,EAAQ2yC,SAASnqC,EAAExI,EAAQyzC,SAASnd,EAAEt2B,EAAQ0zC,cAAc/hB,EAAE3xB,EAAQ2zC,WAAWtd,EAAEr2B,EAAQ4zC,SAASllB,EAClc1uB,EAAQkL,mDAAmD08B,EAAE5nC,EAAQ6zC,IAAIpL,EACzEzoC,EAAQ8zC,aAAa,SAASxvC,EAAEC,EAAEE,GAAG,GAAG,OAAOH,QAAG,IAASA,EAAE,MAAM1B,MAAM,iFAAiF0B,EAAE,KAAK,IAAIE,EAAE+W,EAAE,CAAC,EAAEjX,EAAE0B,OAAOzC,EAAEe,EAAErF,IAAIiO,EAAE5I,EAAEgxB,IAAIroB,EAAE3I,EAAEixB,OAAO,GAAG,MAAMhxB,EAAE,CAAoE,QAAnE,IAASA,EAAE+wB,MAAMpoB,EAAE3I,EAAE+wB,IAAIroB,EAAEisB,EAAE7gB,cAAS,IAAS9T,EAAEtF,MAAMsE,EAAE,GAAGgB,EAAEtF,KAAQqF,EAAEX,MAAMW,EAAEX,KAAKw8B,aAAa,IAAI12B,EAAEnF,EAAEX,KAAKw8B,aAAa,IAAIz7B,KAAKH,EAAEgqB,EAAEzvB,KAAKyF,EAAEG,KAAKw1B,EAAE77B,eAAeqG,KAAKF,EAAEE,QAAG,IAASH,EAAEG,SAAI,IAAS+E,EAAEA,EAAE/E,GAAGH,EAAEG,GAAG,CAAC,IAAIA,EAAEpE,UAAUE,OAAO,EAAE,GAAG,IAAIkE,EAAEF,EAAEyL,SAASxL,OAAO,GAAG,EAAEC,EAAE,CAAC+E,EAAE5K,MAAM6F,GACrf,IAAI,IAAIxB,EAAE,EAAEA,EAAEwB,EAAExB,IAAIuG,EAAEvG,GAAG5C,UAAU4C,EAAE,GAAGsB,EAAEyL,SAASxG,CAAC,CAAC,MAAM,CAACgE,SAAST,EAAErJ,KAAKW,EAAEX,KAAK1E,IAAIsE,EAAE+xB,IAAIpoB,EAAElH,MAAMxB,EAAE+wB,OAAOtoB,EAAE,EAAEjN,EAAQ+zC,cAAc,SAASzvC,GAAqK,OAAlKA,EAAE,CAACmJ,SAASghB,EAAEyI,cAAc5yB,EAAE0vC,eAAe1vC,EAAE2vC,aAAa,EAAEC,SAAS,KAAKC,SAAS,KAAKC,cAAc,KAAKC,YAAY,OAAQH,SAAS,CAACzmC,SAAS6gB,EAAE5gB,SAASpJ,GAAUA,EAAE6vC,SAAS7vC,CAAC,EAAEtE,EAAQmJ,cAAcyxB,EAAE56B,EAAQs0C,cAAc,SAAShwC,GAAG,IAAIC,EAAEq2B,EAAEn0B,KAAK,KAAKnC,GAAY,OAATC,EAAEZ,KAAKW,EAASC,CAAC,EAAEvE,EAAQu0C,UAAU,WAAW,MAAM,CAACl8B,QAAQ,KAAK,EAC9drY,EAAQw0C,WAAW,SAASlwC,GAAG,MAAM,CAACmJ,SAASjE,EAAE+D,OAAOjJ,EAAE,EAAEtE,EAAQy0C,eAAe3Z,EAAE96B,EAAQ00C,KAAK,SAASpwC,GAAG,MAAM,CAACmJ,SAAS8oB,EAAE5oB,SAAS,CAACslC,SAAS,EAAEC,QAAQ5uC,GAAGsJ,MAAMs5B,EAAE,EAAElnC,EAAQ20C,KAAK,SAASrwC,EAAEC,GAAG,MAAM,CAACkJ,SAAS+gB,EAAE7qB,KAAKW,EAAEi/B,aAAQ,IAASh/B,EAAE,KAAKA,EAAE,EAAEvE,EAAQ40C,gBAAgB,SAAStwC,GAAG,IAAIC,EAAEmjC,EAAExpB,WAAWwpB,EAAExpB,WAAW,CAAC,EAAE,IAAI5Z,GAAG,CAAC,QAAQojC,EAAExpB,WAAW3Z,CAAC,CAAC,EAAEvE,EAAQ60C,aAAapM,EAAEzoC,EAAQg/B,YAAY,SAAS16B,EAAEC,GAAG,OAAOgjC,EAAElvB,QAAQ2mB,YAAY16B,EAAEC,EAAE,EAAEvE,EAAQi/B,WAAW,SAAS36B,GAAG,OAAOijC,EAAElvB,QAAQ4mB,WAAW36B,EAAE,EAC3ftE,EAAQ0/B,cAAc,WAAW,EAAE1/B,EAAQ2/B,iBAAiB,SAASr7B,GAAG,OAAOijC,EAAElvB,QAAQsnB,iBAAiBr7B,EAAE,EAAEtE,EAAQk/B,UAAU,SAAS56B,EAAEC,GAAG,OAAOgjC,EAAElvB,QAAQ6mB,UAAU56B,EAAEC,EAAE,EAAEvE,EAAQ+/B,MAAM,WAAW,OAAOwH,EAAElvB,QAAQ0nB,OAAO,EAAE//B,EAAQm/B,oBAAoB,SAAS76B,EAAEC,EAAEE,GAAG,OAAO8iC,EAAElvB,QAAQ8mB,oBAAoB76B,EAAEC,EAAEE,EAAE,EAAEzE,EAAQo/B,mBAAmB,SAAS96B,EAAEC,GAAG,OAAOgjC,EAAElvB,QAAQ+mB,mBAAmB96B,EAAEC,EAAE,EAAEvE,EAAQq/B,gBAAgB,SAAS/6B,EAAEC,GAAG,OAAOgjC,EAAElvB,QAAQgnB,gBAAgB/6B,EAAEC,EAAE,EACzdvE,EAAQs/B,QAAQ,SAASh7B,EAAEC,GAAG,OAAOgjC,EAAElvB,QAAQinB,QAAQh7B,EAAEC,EAAE,EAAEvE,EAAQu/B,WAAW,SAASj7B,EAAEC,EAAEE,GAAG,OAAO8iC,EAAElvB,QAAQknB,WAAWj7B,EAAEC,EAAEE,EAAE,EAAEzE,EAAQw/B,OAAO,SAASl7B,GAAG,OAAOijC,EAAElvB,QAAQmnB,OAAOl7B,EAAE,EAAEtE,EAAQy/B,SAAS,SAASn7B,GAAG,OAAOijC,EAAElvB,QAAQonB,SAASn7B,EAAE,EAAEtE,EAAQ8/B,qBAAqB,SAASx7B,EAAEC,EAAEE,GAAG,OAAO8iC,EAAElvB,QAAQynB,qBAAqBx7B,EAAEC,EAAEE,EAAE,EAAEzE,EAAQ4/B,cAAc,WAAW,OAAO2H,EAAElvB,QAAQunB,eAAe,EAAE5/B,EAAQgwC,QAAQ,oCCtBlajwC,EAAOC,QAAU,EAAjBD,iCCAAA,EAAOC,QAAU,EAAjBD,+BCMW,SAAS2E,EAAEJ,EAAEC,GAAG,IAAIhB,EAAEe,EAAE9D,OAAO8D,EAAEtB,KAAKuB,GAAGD,EAAE,KAAK,EAAEf,GAAG,CAAC,IAAIiB,EAAEjB,EAAE,IAAI,EAAEkB,EAAEH,EAAEE,GAAG,KAAG,EAAEiF,EAAEhF,EAAEF,IAA0B,MAAMD,EAA7BA,EAAEE,GAAGD,EAAED,EAAEf,GAAGkB,EAAElB,EAAEiB,CAAc,CAAC,CAAC,SAASyI,EAAE3I,GAAG,OAAO,IAAIA,EAAE9D,OAAO,KAAK8D,EAAE,EAAE,CAAC,SAAS4I,EAAE5I,GAAG,GAAG,IAAIA,EAAE9D,OAAO,OAAO,KAAK,IAAI+D,EAAED,EAAE,GAAGf,EAAEe,EAAEwwC,MAAM,GAAGvxC,IAAIgB,EAAE,CAACD,EAAE,GAAGf,EAAEe,EAAE,IAAI,IAAIE,EAAE,EAAEC,EAAEH,EAAE9D,OAAOkuB,EAAEjqB,IAAI,EAAED,EAAEkqB,GAAG,CAAC,IAAIxrB,EAAE,GAAGsB,EAAE,GAAG,EAAE+W,EAAEjX,EAAEpB,GAAGmrB,EAAEnrB,EAAE,EAAEsrB,EAAElqB,EAAE+pB,GAAG,GAAG,EAAE5kB,EAAE8R,EAAEhY,GAAG8qB,EAAE5pB,GAAG,EAAEgF,EAAE+kB,EAAEjT,IAAIjX,EAAEE,GAAGgqB,EAAElqB,EAAE+pB,GAAG9qB,EAAEiB,EAAE6pB,IAAI/pB,EAAEE,GAAG+W,EAAEjX,EAAEpB,GAAGK,EAAEiB,EAAEtB,OAAQ,MAAGmrB,EAAE5pB,GAAG,EAAEgF,EAAE+kB,EAAEjrB,IAA0B,MAAMe,EAA7BA,EAAEE,GAAGgqB,EAAElqB,EAAE+pB,GAAG9qB,EAAEiB,EAAE6pB,CAAc,EAAC,CAAC,OAAO9pB,CAAC,CAC3c,SAASkF,EAAEnF,EAAEC,GAAG,IAAIhB,EAAEe,EAAEywC,UAAUxwC,EAAEwwC,UAAU,OAAO,IAAIxxC,EAAEA,EAAEe,EAAEga,GAAG/Z,EAAE+Z,EAAE,CAAC,GAAG,kBAAkB02B,aAAa,oBAAoBA,YAAYx0B,IAAI,CAAC,IAAIxT,EAAEgoC,YAAYh1C,EAAQiZ,aAAa,WAAW,OAAOjM,EAAEwT,KAAK,CAAC,KAAK,CAAC,IAAIhY,EAAE+X,KAAK8V,EAAE7tB,EAAEgY,MAAMxgB,EAAQiZ,aAAa,WAAW,OAAOzQ,EAAEgY,MAAM6V,CAAC,CAAC,CAAC,IAAIC,EAAE,GAAGhI,EAAE,GAAGG,EAAE,EAAEjlB,EAAE,KAAK+sB,EAAE,EAAEtsB,GAAE,EAAGqC,GAAE,EAAG0M,GAAE,EAAG2U,EAAE,oBAAoBwC,WAAWA,WAAW,KAAKuB,EAAE,oBAAoBrB,aAAaA,aAAa,KAAK1B,EAAE,qBAAqBsmB,aAAaA,aAAa,KACnT,SAAStjB,EAAErtB,GAAG,IAAI,IAAIC,EAAE0I,EAAEqhB,GAAG,OAAO/pB,GAAG,CAAC,GAAG,OAAOA,EAAEy0B,SAAS9rB,EAAEohB,OAAQ,MAAG/pB,EAAE2wC,WAAW5wC,GAAgD,MAA9C4I,EAAEohB,GAAG/pB,EAAEwwC,UAAUxwC,EAAE4wC,eAAezwC,EAAE4xB,EAAE/xB,EAAa,CAACA,EAAE0I,EAAEqhB,EAAE,CAAC,CAAC,SAASuD,EAAEvtB,GAAa,GAAV0U,GAAE,EAAG2Y,EAAErtB,IAAOgI,EAAE,GAAG,OAAOW,EAAEqpB,GAAGhqB,GAAE,EAAG2nB,EAAE1F,OAAO,CAAC,IAAIhqB,EAAE0I,EAAEqhB,GAAG,OAAO/pB,GAAG20B,EAAErH,EAAEttB,EAAE2wC,UAAU5wC,EAAE,CAAC,CACra,SAASiqB,EAAEjqB,EAAEC,GAAG+H,GAAE,EAAG0M,IAAIA,GAAE,EAAG0Y,EAAEwI,GAAGA,GAAG,GAAGjwB,GAAE,EAAG,IAAI1G,EAAEgzB,EAAE,IAAS,IAAL5E,EAAEptB,GAAOiF,EAAEyD,EAAEqpB,GAAG,OAAO9sB,MAAMA,EAAE2rC,eAAe5wC,IAAID,IAAIs2B,MAAM,CAAC,IAAIp2B,EAAEgF,EAAEwvB,SAAS,GAAG,oBAAoBx0B,EAAE,CAACgF,EAAEwvB,SAAS,KAAKzC,EAAE/sB,EAAE4rC,cAAc,IAAI3wC,EAAED,EAAEgF,EAAE2rC,gBAAgB5wC,GAAGA,EAAEvE,EAAQiZ,eAAe,oBAAoBxU,EAAE+E,EAAEwvB,SAASv0B,EAAE+E,IAAIyD,EAAEqpB,IAAIppB,EAAEopB,GAAG3E,EAAEptB,EAAE,MAAM2I,EAAEopB,GAAG9sB,EAAEyD,EAAEqpB,EAAE,CAAC,GAAG,OAAO9sB,EAAE,IAAIklB,GAAE,MAAO,CAAC,IAAIxrB,EAAE+J,EAAEqhB,GAAG,OAAOprB,GAAGg2B,EAAErH,EAAE3uB,EAAEgyC,UAAU3wC,GAAGmqB,GAAE,CAAE,CAAC,OAAOA,CAAC,CAAC,QAAQllB,EAAE,KAAK+sB,EAAEhzB,EAAE0G,GAAE,CAAE,CAAC,CAD1a,qBAAqBorC,gBAAW,IAASA,UAAUC,iBAAY,IAASD,UAAUC,WAAWC,gBAAgBF,UAAUC,WAAWC,eAAe9uC,KAAK4uC,UAAUC,YAC2Q,IACzPhP,EAD6PzL,GAAE,EAAGC,EAAE,KAAKZ,GAAG,EAAEiB,EAAE,EAAE4B,GAAG,EACvc,SAASnC,IAAI,QAAO56B,EAAQiZ,eAAe8jB,EAAE5B,EAAO,CAAC,SAAS0D,IAAI,GAAG,OAAO/D,EAAE,CAAC,IAAIx2B,EAAEtE,EAAQiZ,eAAe8jB,EAAEz4B,EAAE,IAAIC,GAAE,EAAG,IAAIA,EAAEu2B,GAAE,EAAGx2B,EAAE,CAAC,QAAQC,EAAE+hC,KAAKzL,GAAE,EAAGC,EAAE,KAAK,CAAC,MAAMD,GAAE,CAAE,CAAO,GAAG,oBAAoBlM,EAAE2X,EAAE,WAAW3X,EAAEkQ,EAAE,OAAO,GAAG,qBAAqB2W,eAAe,CAAC,IAAItO,EAAE,IAAIsO,eAAejO,EAAEL,EAAEuO,MAAMvO,EAAEwO,MAAMC,UAAU9W,EAAEyH,EAAE,WAAWiB,EAAEqO,YAAY,KAAK,CAAC,MAAMtP,EAAE,WAAW3Y,EAAEkR,EAAE,EAAE,EAAE,SAAS5K,EAAE3vB,GAAGw2B,EAAEx2B,EAAEu2B,IAAIA,GAAE,EAAGyL,IAAI,CAAC,SAASpN,EAAE50B,EAAEC,GAAG21B,EAAEvM,GAAE,WAAWrpB,EAAEtE,EAAQiZ,eAAe,GAAE1U,EAAE,CAC5dvE,EAAQ6Z,sBAAsB,EAAE7Z,EAAQqZ,2BAA2B,EAAErZ,EAAQ2Z,qBAAqB,EAAE3Z,EAAQyZ,wBAAwB,EAAEzZ,EAAQ61C,mBAAmB,KAAK71C,EAAQuZ,8BAA8B,EAAEvZ,EAAQ2Y,wBAAwB,SAASrU,GAAGA,EAAE00B,SAAS,IAAI,EAAEh5B,EAAQ81C,2BAA2B,WAAWxpC,GAAGrC,IAAIqC,GAAE,EAAG2nB,EAAE1F,GAAG,EAC1UvuB,EAAQ+1C,wBAAwB,SAASzxC,GAAG,EAAEA,GAAG,IAAIA,EAAE09B,QAAQv/B,MAAM,mHAAmH04B,EAAE,EAAE72B,EAAE2V,KAAK+7B,MAAM,IAAI1xC,GAAG,CAAC,EAAEtE,EAAQmZ,iCAAiC,WAAW,OAAOod,CAAC,EAAEv2B,EAAQi2C,8BAA8B,WAAW,OAAOhpC,EAAEqpB,EAAE,EAAEt2B,EAAQk2C,cAAc,SAAS5xC,GAAG,OAAOiyB,GAAG,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,IAAIhyB,EAAE,EAAE,MAAM,QAAQA,EAAEgyB,EAAE,IAAIhzB,EAAEgzB,EAAEA,EAAEhyB,EAAE,IAAI,OAAOD,GAAG,CAAC,QAAQiyB,EAAEhzB,CAAC,CAAC,EAAEvD,EAAQm2C,wBAAwB,WAAW,EAC9fn2C,EAAQ+Y,sBAAsB,WAAW,EAAE/Y,EAAQo2C,yBAAyB,SAAS9xC,EAAEC,GAAG,OAAOD,GAAG,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,QAAQA,EAAE,EAAE,IAAIf,EAAEgzB,EAAEA,EAAEjyB,EAAE,IAAI,OAAOC,GAAG,CAAC,QAAQgyB,EAAEhzB,CAAC,CAAC,EAChMvD,EAAQyY,0BAA0B,SAASnU,EAAEC,EAAEhB,GAAG,IAAIiB,EAAExE,EAAQiZ,eAA8F,OAA/E,kBAAkB1V,GAAG,OAAOA,EAAaA,EAAE,kBAAZA,EAAEA,EAAE8yC,QAA6B,EAAE9yC,EAAEiB,EAAEjB,EAAEiB,EAAGjB,EAAEiB,EAASF,GAAG,KAAK,EAAE,IAAIG,GAAG,EAAE,MAAM,KAAK,EAAEA,EAAE,IAAI,MAAM,KAAK,EAAEA,EAAE,WAAW,MAAM,KAAK,EAAEA,EAAE,IAAI,MAAM,QAAQA,EAAE,IAAmN,OAAzMH,EAAE,CAACga,GAAGmQ,IAAIuK,SAASz0B,EAAE6wC,cAAc9wC,EAAE4wC,UAAU3xC,EAAE4xC,eAAvD1wC,EAAElB,EAAEkB,EAAoEswC,WAAW,GAAGxxC,EAAEiB,GAAGF,EAAEywC,UAAUxxC,EAAEmB,EAAE4pB,EAAEhqB,GAAG,OAAO2I,EAAEqpB,IAAIhyB,IAAI2I,EAAEqhB,KAAKtV,GAAG0Y,EAAEwI,GAAGA,GAAG,GAAGlhB,GAAE,EAAGkgB,EAAErH,EAAEtuB,EAAEiB,MAAMF,EAAEywC,UAAUtwC,EAAEC,EAAE4xB,EAAEhyB,GAAGgI,GAAGrC,IAAIqC,GAAE,EAAG2nB,EAAE1F,KAAYjqB,CAAC,EACnetE,EAAQ6Y,qBAAqB+hB,EAAE56B,EAAQs2C,sBAAsB,SAAShyC,GAAG,IAAIC,EAAEgyB,EAAE,OAAO,WAAW,IAAIhzB,EAAEgzB,EAAEA,EAAEhyB,EAAE,IAAI,OAAOD,EAAEmB,MAAMrD,KAAK9B,UAAU,CAAC,QAAQi2B,EAAEhzB,CAAC,CAAC,CAAC,8BCf7JxD,EAAOC,QAAU,EAAjBD,4KC0BFC,EAAAA,QAAA,SACEsB,EACA6K,GAEA,IAAIoqC,EAAkC,KAEtC,IAAKj1C,GAA0B,kBAAVA,EACnB,OAAOi1C,EAGT,IAAMpyC,GAAe,EAAAqyC,EAAArxC,SAAM7D,GACrBm1C,EAAkC,oBAAbtqC,EAiB3B,OAfAhI,EAAamB,SAAQ,SAAC1B,GACpB,GAAyB,gBAArBA,EAAYD,KAAhB,CAIQ,IAAAK,EAAoBJ,EAAWI,SAArBrE,EAAUiE,EAAWjE,MAEnC82C,EACFtqC,EAASnI,EAAUrE,EAAOiE,GACjBjE,KACT42C,EAAcA,GAAe,CAAC,GAClBvyC,GAAYrE,EAR1B,CAUF,IAEO42C,CACT,EAzDA,IAAAC,EAAAE,EAAA/wC,EAAA,mBCDA,OAOC,WACA,aAEA,IAAIzH,EAAS,CAAC,EAAEG,eAEhB,SAASs4C,IAGR,IAFA,IAAIC,EAAU,GAELr2C,EAAI,EAAGA,EAAID,UAAUE,OAAQD,IAAK,CAC1C,IAAIs2C,EAAMv2C,UAAUC,GAChBs2C,IACHD,EAAUE,EAAYF,EAASG,EAAWF,IAE5C,CAEA,OAAOD,CACR,CAEA,SAASG,EAAYF,GACpB,GAAmB,kBAARA,GAAmC,kBAARA,EACrC,OAAOA,EAGR,GAAmB,kBAARA,EACV,MAAO,GAGR,GAAIh4C,MAAMF,QAAQk4C,GACjB,OAAOF,EAAWlxC,MAAM,KAAMoxC,GAG/B,GAAIA,EAAIt4C,WAAaJ,OAAOC,UAAUG,WAAas4C,EAAIt4C,SAASA,WAAW6O,SAAS,iBACnF,OAAOypC,EAAIt4C,WAGZ,IAAIq4C,EAAU,GAEd,IAAK,IAAI33C,KAAO43C,EACX34C,EAAOY,KAAK+3C,EAAK53C,IAAQ43C,EAAI53C,KAChC23C,EAAUE,EAAYF,EAAS33C,IAIjC,OAAO23C,CACR,CAEA,SAASE,EAAan3C,EAAOq3C,GAC5B,OAAKA,EAIDr3C,EACIA,EAAQ,IAAMq3C,EAGfr3C,EAAQq3C,EAPPr3C,CAQT,CAEqCI,EAAOC,SAC3C22C,EAAWxxC,QAAUwxC,EACrB52C,EAAOC,QAAU22C,QAKhB,KAFwB,EAAF,WACtB,OAAOA,CACP,UAFoB,OAEpB,YAIF,CArEA,KCNGM,EAA2B,CAAC,EAGhC,SAASC,EAAoBC,GAE5B,IAAIC,EAAeH,EAAyBE,GAC5C,QAAqBxyC,IAAjByyC,EACH,OAAOA,EAAap3C,QAGrB,IAAID,EAASk3C,EAAyBE,GAAY,CAGjDn3C,QAAS,CAAC,GAOX,OAHAq3C,EAAoBF,GAAUr4C,KAAKiB,EAAOC,QAASD,EAAQA,EAAOC,QAASk3C,GAGpEn3C,EAAOC,OACf,CAGAk3C,EAAoBh0C,EAAIm0C,ECxBxBH,EAAoB7oB,EAAKtuB,IACxB,IAAIu3C,EAASv3C,GAAUA,EAAO6F,WAC7B,IAAO7F,EAAiB,QACxB,IAAM,EAEP,OADAm3C,EAAoB1yC,EAAE8yC,EAAQ,CAAEhzC,EAAGgzC,IAC5BA,CAAM,QCNd,IACIC,EADAC,EAAWr5C,OAAOs5C,eAAkBz4C,GAASb,OAAOs5C,eAAez4C,GAASA,GAASA,EAAa,UAQtGk4C,EAAoB5oB,EAAI,SAAS3uB,EAAOi1B,GAEvC,GADU,EAAPA,IAAUj1B,EAAQyC,KAAKzC,IAChB,EAAPi1B,EAAU,OAAOj1B,EACpB,GAAoB,kBAAVA,GAAsBA,EAAO,CACtC,GAAW,EAAPi1B,GAAaj1B,EAAMiG,WAAY,OAAOjG,EAC1C,GAAW,GAAPi1B,GAAoC,oBAAfj1B,EAAMgxB,KAAqB,OAAOhxB,CAC5D,CACA,IAAI+3C,EAAKv5C,OAAOq/B,OAAO,MACvB0Z,EAAoB5gB,EAAEohB,GACtB,IAAIC,EAAM,CAAC,EACXJ,EAAiBA,GAAkB,CAAC,KAAMC,EAAS,CAAC,GAAIA,EAAS,IAAKA,EAASA,IAC/E,IAAI,IAAIn/B,EAAiB,EAAPuc,GAAYj1B,EAAyB,iBAAX0Y,KAAyBk/B,EAAeljC,QAAQgE,GAAUA,EAAUm/B,EAASn/B,GACxHla,OAAOy5C,oBAAoBv/B,GAAS/S,SAASrG,GAAS04C,EAAI14C,GAAO,IAAOU,EAAMV,KAI/E,OAFA04C,EAAa,QAAI,IAAM,EACvBT,EAAoB1yC,EAAEkzC,EAAIC,GACnBD,CACR,MCxBAR,EAAoB1yC,EAAI,CAACxE,EAAS63C,KACjC,IAAI,IAAI54C,KAAO44C,EACXX,EAAoBY,EAAED,EAAY54C,KAASi4C,EAAoBY,EAAE93C,EAASf,IAC5Ed,OAAOK,eAAewB,EAASf,EAAK,CAAEQ,YAAY,EAAM0O,IAAK0pC,EAAW54C,IAE1E,ECNDi4C,EAAoBxyC,EAAI,CAAC,EAGzBwyC,EAAoBzyC,EAAKszC,GACjBxnB,QAAQynB,IAAI75C,OAAOmW,KAAK4iC,EAAoBxyC,GAAGuzC,QAAO,CAACC,EAAUj5C,KACvEi4C,EAAoBxyC,EAAEzF,GAAK84C,EAASG,GAC7BA,IACL,KCNJhB,EAAoBzoB,EAAKspB,GAEjB,aAAeA,EAAf,qBCFRb,EAAoBiB,SAAYJ,IAEf,ECHjBb,EAAoBztC,EAAI,WACvB,GAA0B,kBAAf2uC,WAAyB,OAAOA,WAC3C,IACC,OAAOh2C,MAAQ,IAAIi2C,SAAS,cAAb,EAChB,CAAE,MAAO5zC,GACR,GAAsB,kBAAXwE,OAAqB,OAAOA,MACxC,CACA,CAPuB,GCAxBiuC,EAAoBY,EAAI,CAAC94C,EAAK6E,IAAU1F,OAAOC,UAAUC,eAAeS,KAAKE,EAAK6E,SCAlF,IAAIy0C,EAAa,CAAC,EACdC,EAAoB,qBAExBrB,EAAoBlqC,EAAI,CAAC2a,EAAK8O,EAAMx3B,EAAK84C,KACxC,GAAGO,EAAW3wB,GAAQ2wB,EAAW3wB,GAAK3kB,KAAKyzB,OAA3C,CACA,IAAI+hB,EAAQC,EACZ,QAAW9zC,IAAR1F,EAEF,IADA,IAAIy5C,EAAUxvC,SAASyvC,qBAAqB,UACpCp4C,EAAI,EAAGA,EAAIm4C,EAAQl4C,OAAQD,IAAK,CACvC,IAAIq4C,EAAIF,EAAQn4C,GAChB,GAAGq4C,EAAEC,aAAa,QAAUlxB,GAAOixB,EAAEC,aAAa,iBAAmBN,EAAoBt5C,EAAK,CAAEu5C,EAASI,EAAG,KAAO,CACpH,CAEGJ,IACHC,GAAa,GACbD,EAAStvC,SAASC,cAAc,WAEzB2vC,QAAU,QACjBN,EAAOO,QAAU,IACb7B,EAAoB8B,IACvBR,EAAO1tC,aAAa,QAASosC,EAAoB8B,IAElDR,EAAO1tC,aAAa,eAAgBytC,EAAoBt5C,GAExDu5C,EAAOt4C,IAAMynB,GAEd2wB,EAAW3wB,GAAO,CAAC8O,GACnB,IAAIwiB,EAAmB,CAACC,EAAMlxB,KAE7BwwB,EAAOW,QAAUX,EAAOY,OAAS,KACjC/oB,aAAa0oB,GACb,IAAIM,EAAUf,EAAW3wB,GAIzB,UAHO2wB,EAAW3wB,GAClB6wB,EAAOziC,YAAcyiC,EAAOziC,WAAWjF,YAAY0nC,GACnDa,GAAWA,EAAQ/zC,SAASg0C,GAAQA,EAAGtxB,KACpCkxB,EAAM,OAAOA,EAAKlxB,EAAM,EAExB+wB,EAAU5oB,WAAW8oB,EAAiBxyC,KAAK,UAAM9B,EAAW,CAAEhB,KAAM,UAAWrE,OAAQk5C,IAAW,MACtGA,EAAOW,QAAUF,EAAiBxyC,KAAK,KAAM+xC,EAAOW,SACpDX,EAAOY,OAASH,EAAiBxyC,KAAK,KAAM+xC,EAAOY,QACnDX,GAAcvvC,SAASqwC,KAAKxoC,YAAYynC,EApCkB,CAoCX,MCvChDtB,EAAoB5gB,EAAKt2B,IACH,qBAAXoL,QAA0BA,OAAOouC,aAC1Cr7C,OAAOK,eAAewB,EAASoL,OAAOouC,YAAa,CAAE75C,MAAO,WAE7DxB,OAAOK,eAAewB,EAAS,aAAc,CAAEL,OAAO,GAAO,ECL9Du3C,EAAoB1uC,EAAI,UCKxB,IAAIixC,EAAkB,CACrB,IAAK,GAGNvC,EAAoBxyC,EAAEg1C,EAAI,CAAC3B,EAASG,KAElC,IAAIyB,EAAqBzC,EAAoBY,EAAE2B,EAAiB1B,GAAW0B,EAAgB1B,QAAWpzC,EACtG,GAA0B,IAAvBg1C,EAGF,GAAGA,EACFzB,EAASl1C,KAAK22C,EAAmB,QAC3B,CAGL,IAAIC,EAAU,IAAIrpB,SAAQ,CAACG,EAASmpB,IAAYF,EAAqBF,EAAgB1B,GAAW,CAACrnB,EAASmpB,KAC1G3B,EAASl1C,KAAK22C,EAAmB,GAAKC,GAGtC,IAAIjyB,EAAMuvB,EAAoB1uC,EAAI0uC,EAAoBzoB,EAAEspB,GAEpDt1C,EAAQ,IAAIG,MAgBhBs0C,EAAoBlqC,EAAE2a,GAfFK,IACnB,GAAGkvB,EAAoBY,EAAE2B,EAAiB1B,KAEf,KAD1B4B,EAAqBF,EAAgB1B,MACR0B,EAAgB1B,QAAWpzC,GACrDg1C,GAAoB,CACtB,IAAIG,EAAY9xB,IAAyB,SAAfA,EAAMrkB,KAAkB,UAAYqkB,EAAMrkB,MAChEo2C,EAAU/xB,GAASA,EAAM1oB,QAAU0oB,EAAM1oB,OAAOY,IACpDuC,EAAMm/B,QAAU,iBAAmBmW,EAAU,cAAgB+B,EAAY,KAAOC,EAAU,IAC1Ft3C,EAAMjD,KAAO,iBACbiD,EAAMkB,KAAOm2C,EACbr3C,EAAMu3C,QAAUD,EAChBJ,EAAmB,GAAGl3C,EACvB,CACD,GAEwC,SAAWs1C,EAASA,EAE/D,CACD,EAcF,IAAIkC,EAAuB,CAACC,EAA4Bn3B,KACvD,IAKIo0B,EAAUY,EALVoC,EAAWp3B,EAAK,GAChBq3B,EAAcr3B,EAAK,GACnBs3B,EAAUt3B,EAAK,GAGIxiB,EAAI,EAC3B,GAAG45C,EAASG,MAAMh8B,GAAgC,IAAxBm7B,EAAgBn7B,KAAa,CACtD,IAAI64B,KAAYiD,EACZlD,EAAoBY,EAAEsC,EAAajD,KACrCD,EAAoBh0C,EAAEi0C,GAAYiD,EAAYjD,IAGhD,GAAGkD,EAAsBA,EAAQnD,EAClC,CAEA,IADGgD,GAA4BA,EAA2Bn3B,GACrDxiB,EAAI45C,EAAS35C,OAAQD,IACzBw3C,EAAUoC,EAAS55C,GAChB22C,EAAoBY,EAAE2B,EAAiB1B,IAAY0B,EAAgB1B,IACrE0B,EAAgB1B,GAAS,KAE1B0B,EAAgB1B,GAAW,CAC5B,EAIGwC,EAAqBC,KAAoC,8BAAIA,KAAoC,+BAAK,GAC1GD,EAAmBj1C,QAAQ20C,EAAqBxzC,KAAK,KAAM,IAC3D8zC,EAAmBv3C,KAAOi3C,EAAqBxzC,KAAK,KAAM8zC,EAAmBv3C,KAAKyD,KAAK8zC,0XChF3EE,uRAAZ,SAAYA,GAQVA,EAAA,UAOAA,EAAA,YAMAA,EAAA,iBACD,CAtBD,CAAYA,IAAAA,EAsBX,KAqKD,MAAMC,EAAoB,WAySV,SAAAC,EAAUh7C,EAAYiiC,GACpC,IAAc,IAAVjiC,GAA6B,OAAVA,GAAmC,qBAAVA,EAC9C,MAAM,IAAIiD,MAAMg/B,EAEpB,CAEgB,SAAAgZ,EAAQC,EAAWjZ,GACjC,IAAKiZ,EAAM,CAEc,qBAAZ7Y,SAAyBA,QAAQ8Y,KAAKlZ,GAEjD,IAME,MAAM,IAAIh/B,MAAMg/B,EAEjB,CAAC,MAAOn9B,GAAI,CACd,CACH,CASA,SAASs2C,EAAgB50C,EAAoB2vB,GAC3C,MAAO,CACLklB,IAAK70C,EAAS66B,MACd/hC,IAAKkH,EAASlH,IACdg8C,IAAKnlB,EAET,CAKM,SAAUolB,EACd7iC,EACA8iC,EACAna,EACA/hC,GAcA,YAfA,IAAA+hC,IAAAA,EAAa,MAGDoa,EAAA,CACVC,SAA6B,kBAAZhjC,EAAuBA,EAAUA,EAAQgjC,SAC1D9zB,OAAQ,GACR+zB,KAAM,IACY,kBAAPH,EAAkBI,EAAUJ,GAAMA,EAAE,CAC/Cna,QAKA/hC,IAAMk8C,GAAOA,EAAgBl8C,KAAQA,GAjChCgb,KAAKgU,SAAS1vB,SAAS,IAAIi9C,OAAO,EAAG,IAoC9C,CAKgB,SAAAC,EAAUC,GAIV,IAJW,SACzBL,EAAW,IAAG,OACd9zB,EAAS,GAAE,KACX+zB,EAAO,IACOI,EAKd,OAJIn0B,GAAqB,MAAXA,IACZ8zB,GAAiC,MAArB9zB,EAAO7jB,OAAO,GAAa6jB,EAAS,IAAMA,GACpD+zB,GAAiB,MAATA,IACVD,GAA+B,MAAnBC,EAAK53C,OAAO,GAAa43C,EAAO,IAAMA,GAC7CD,CACT,CAKM,SAAUE,EAAUI,GACxB,IAAIC,EAA4B,CAAC,EAEjC,GAAID,EAAM,CACR,IAAIE,EAAYF,EAAKtnC,QAAQ,KACzBwnC,GAAa,IACfD,EAAWN,KAAOK,EAAKH,OAAOK,GAC9BF,EAAOA,EAAKH,OAAO,EAAGK,IAGxB,IAAIC,EAAcH,EAAKtnC,QAAQ,KAC3BynC,GAAe,IACjBF,EAAWr0B,OAASo0B,EAAKH,OAAOM,GAChCH,EAAOA,EAAKH,OAAO,EAAGM,IAGpBH,IACFC,EAAWP,SAAWM,EAEzB,CAED,OAAOC,CACT,CASA,SAASG,EACPC,EACAC,EACAC,EACA38C,QAAA,IAAAA,IAAAA,EAA6B,CAAC,GAE9B,IAAI,OAAE0J,EAASC,SAASyhB,YAAY,SAAEwxB,GAAW,GAAU58C,EACvD68C,EAAgBnzC,EAAOozC,QACvBngB,EAASue,EAAO6B,IAChB5uB,EAA4B,KAE5BoI,EAAQymB,IASZ,SAASA,IAEP,OADYH,EAAcpb,OAAS,CAAEia,IAAK,OAC7BA,GACf,CAEA,SAASuB,IACPtgB,EAASue,EAAO6B,IAChB,IAAIG,EAAYF,IACZG,EAAqB,MAAbD,EAAoB,KAAOA,EAAY3mB,EACnDA,EAAQ2mB,EACJ/uB,GACFA,EAAS,CAAEwO,SAAQ/1B,SAAUk2C,EAAQl2C,SAAUu2C,SAEnD,CA+CA,SAASC,EAAUxB,GAIjB,IAAIxmC,EACyB,SAA3B1L,EAAO9C,SAASy2C,OACZ3zC,EAAO9C,SAASy2C,OAChB3zC,EAAO9C,SAAS8jB,KAElBA,EAAqB,kBAAPkxB,EAAkBA,EAAKM,EAAWN,GASpD,OALAlxB,EAAOA,EAAK5oB,QAAQ,KAAM,OAC1Bs5C,EACEhmC,EACsE,sEAAAsV,GAEjE,IAAI4yB,IAAI5yB,EAAMtV,EACvB,CApFa,MAATmhB,IACFA,EAAQ,EACRsmB,EAAcU,aAAY1B,EAAM,GAAAgB,EAAcpb,MAAO,CAAAia,IAAKnlB,IAAS,KAoFrE,IAAIumB,EAAmB,CACrB,UAAIngB,GACF,OAAOA,GAET,YAAI/1B,GACF,OAAO61C,EAAY/yC,EAAQmzC,IAE7BW,MAAAA,CAAOzD,GACL,GAAI5rB,EACF,MAAM,IAAI9qB,MAAM,8CAKlB,OAHAqG,EAAO+N,iBAAiB0jC,EAAmB8B,GAC3C9uB,EAAW4rB,EAEJ,KACLrwC,EAAOgO,oBAAoByjC,EAAmB8B,GAC9C9uB,EAAW,IAAI,GAGnBuuB,WAAWd,GACFc,EAAWhzC,EAAQkyC,GAE5BwB,YACAK,cAAAA,CAAe7B,GAEb,IAAIxzB,EAAMg1B,EAAUxB,GACpB,MAAO,CACLE,SAAU1zB,EAAI0zB,SACd9zB,OAAQI,EAAIJ,OACZ+zB,KAAM3zB,EAAI2zB,OAGdt4C,KAlGF,SAAcm4C,EAAQna,GACpB9E,EAASue,EAAOwC,KAChB,IAAI92C,EAAW+0C,EAAemB,EAAQl2C,SAAUg1C,EAAIna,GAChDkb,GAAkBA,EAAiB/1C,EAAUg1C,GAEjDrlB,EAAQymB,IAAa,EACrB,IAAIW,EAAenC,EAAgB50C,EAAU2vB,GACzCnO,EAAM00B,EAAQJ,WAAW91C,GAG7B,IACEi2C,EAAce,UAAUD,EAAc,GAAIv1B,GAC1C,MAAOllB,GAKP,GAAIA,aAAiB26C,cAA+B,mBAAf36C,EAAMjD,KACzC,MAAMiD,EAIRwG,EAAO9C,SAASoG,OAAOob,EACxB,CAEGw0B,GAAYzuB,GACdA,EAAS,CAAEwO,SAAQ/1B,SAAUk2C,EAAQl2C,SAAUu2C,MAAO,GAE1D,EAuEEr7C,QArEF,SAAiB85C,EAAQna,GACvB9E,EAASue,EAAO4C,QAChB,IAAIl3C,EAAW+0C,EAAemB,EAAQl2C,SAAUg1C,EAAIna,GAChDkb,GAAkBA,EAAiB/1C,EAAUg1C,GAEjDrlB,EAAQymB,IACR,IAAIW,EAAenC,EAAgB50C,EAAU2vB,GACzCnO,EAAM00B,EAAQJ,WAAW91C,GAC7Bi2C,EAAcU,aAAaI,EAAc,GAAIv1B,GAEzCw0B,GAAYzuB,GACdA,EAAS,CAAEwO,SAAQ/1B,SAAUk2C,EAAQl2C,SAAUu2C,MAAO,GAE1D,EAyDEY,GAAGjvB,GACM+tB,EAAckB,GAAGjvB,IAI5B,OAAOguB,CACT,CC7tBA,IAAYkB,GAAZ,SAAYA,GACVA,EAAA,YACAA,EAAA,oBACAA,EAAA,oBACAA,EAAA,aACD,CALD,CAAYA,IAAAA,EAKX,KAyRiC,IAAI50C,IAAuB,CAC3D,OACA,gBACA,OACA,KACA,QACA,aAoNI,SAAU60C,EAGdC,EACAC,EACAC,GAEA,YAFQ,IAARA,IAAAA,EAAW,KAEJC,EAAgBH,EAAQC,EAAaC,GAAU,EACxD,CAEM,SAAUC,EAGdH,EACAC,EACAC,EACAE,GAEA,IAGIxC,EAAWyC,GAFU,kBAAhBJ,EAA2BnC,EAAUmC,GAAeA,GAEvBrC,UAAY,IAAKsC,GAEvD,GAAgB,MAAZtC,EACF,OAAO,KAGT,IAAI0C,EAAWC,EAAcP,IAmM/B,SAA2BM,GACzBA,EAASE,MAAK,CAAC35C,EAAGC,IAChBD,EAAE45C,QAAU35C,EAAE25C,MACV35C,EAAE25C,MAAQ55C,EAAE45C,MAyCpB,SAAwB55C,EAAaC,GACnC,IAAI45C,EACF75C,EAAE9D,SAAW+D,EAAE/D,QAAU8D,EAAElB,MAAM,GAAI,GAAGg7C,OAAM,CAAC/vB,EAAG9tB,IAAM8tB,IAAM9pB,EAAEhE,KAElE,OAAO49C,EAKH75C,EAAEA,EAAE9D,OAAS,GAAK+D,EAAEA,EAAE/D,OAAS,GAG/B,CACN,CArDQ69C,CACE/5C,EAAEg6C,WAAWlL,KAAKh+B,GAASA,EAAKmpC,gBAChCh6C,EAAE+5C,WAAWlL,KAAKh+B,GAASA,EAAKmpC,kBAG1C,CA3MEC,CAAkBT,GAElB,IAAIU,EAAU,KACd,IAAK,IAAIl+C,EAAI,EAAc,MAAXk+C,GAAmBl+C,EAAIw9C,EAASv9C,SAAUD,EAAG,CAO3D,IAAIm+C,EAAUC,EAAWtD,GACzBoD,EAAUG,EACRb,EAASx9C,GACTm+C,EACAb,EAEH,CAED,OAAOY,CACT,CAyCA,SAAST,EAGPP,EACAM,EACAc,EACAC,QAF2C,IAA3Cf,IAAAA,EAA2C,SAC3C,IAAAc,IAAAA,EAA4C,SAClC,IAAVC,IAAAA,EAAa,IAEb,IAAIC,EAAeA,CACjBC,EACAlpB,EACAmpB,KAEA,IAAI7pC,EAAmC,CACrC6pC,kBACmBt6C,IAAjBs6C,EAA6BD,EAAMrD,MAAQ,GAAKsD,EAClDC,eAAuC,IAAxBF,EAAME,cACrBX,cAAezoB,EACfkpB,SAGE5pC,EAAK6pC,aAAaE,WAAW,OAC/BxE,EACEvlC,EAAK6pC,aAAaE,WAAWL,GAC7B,wBAAwB1pC,EAAK6pC,aAA7B,wBACMH,EADN,4GAKF1pC,EAAK6pC,aAAe7pC,EAAK6pC,aAAa77C,MAAM07C,EAAWt+C,SAGzD,IAAIm7C,EAAOyD,EAAU,CAACN,EAAY1pC,EAAK6pC,eACnCX,EAAaO,EAAYt4C,OAAO6O,GAKhC4pC,EAAM/uC,UAAY+uC,EAAM/uC,SAASzP,OAAS,IAC5Cm6C,GAGkB,IAAhBqE,EAAMlpB,MACN,4FACuC6lB,EAAI,MAE7CqC,EAAcgB,EAAM/uC,SAAU8tC,EAAUO,EAAY3C,KAKpC,MAAdqD,EAAMrD,MAAiBqD,EAAMlpB,QAIjCioB,EAAS/6C,KAAK,CACZ24C,OACAuC,MAAOmB,EAAa1D,EAAMqD,EAAMlpB,OAChCwoB,cACA,EAaJ,OAXAb,EAAOn4C,SAAQ,CAAC05C,EAAOlpB,KAAS,IAAAwpB,EAE9B,GAAmB,KAAfN,EAAMrD,MAA0B,OAAX2D,EAACN,EAAMrD,OAAN2D,EAAYlyC,SAAS,KAG7C,IAAK,IAAImyC,KAAYC,EAAwBR,EAAMrD,MACjDoD,EAAaC,EAAOlpB,EAAOypB,QAH7BR,EAAaC,EAAOlpB,EAKrB,IAGIioB,CACT,CAgBA,SAASyB,EAAwB7D,GAC/B,IAAI8D,EAAW9D,EAAKzxC,MAAM,KAC1B,GAAwB,IAApBu1C,EAASj/C,OAAc,MAAO,GAElC,IAAKk/C,KAAUC,GAAQF,EAGnBG,EAAaF,EAAMG,SAAS,KAE5BC,EAAWJ,EAAMr+C,QAAQ,MAAO,IAEpC,GAAoB,IAAhBs+C,EAAKn/C,OAGP,OAAOo/C,EAAa,CAACE,EAAU,IAAM,CAACA,GAGxC,IAAIC,EAAeP,EAAwBG,EAAKhqB,KAAK,MAEjDnwB,EAAmB,GAqBvB,OAZAA,EAAOxC,QACF+8C,EAAa3M,KAAK4M,GACP,KAAZA,EAAiBF,EAAW,CAACA,EAAUE,GAASrqB,KAAK,QAKrDiqB,GACFp6C,EAAOxC,QAAQ+8C,GAIVv6C,EAAO4tC,KAAKmM,GACjB5D,EAAKwD,WAAW,MAAqB,KAAbI,EAAkB,IAAMA,GAEpD,CAaA,MAAMU,EAAU,YACVC,EAAsB,EACtBC,EAAkB,EAClBC,EAAoB,EACpBC,EAAqB,GACrBC,GAAgB,EAChBC,EAAW3H,GAAoB,MAANA,EAE/B,SAASyG,EAAa1D,EAAc7lB,GAClC,IAAI2pB,EAAW9D,EAAKzxC,MAAM,KACtBs2C,EAAef,EAASj/C,OAS5B,OARIi/C,EAASnF,KAAKiG,KAChBC,GAAgBF,GAGdxqB,IACF0qB,GAAgBL,GAGXV,EACJgB,QAAQ7H,IAAO2H,EAAQ3H,KACvBX,QACC,CAACiG,EAAOwC,IACNxC,GACC+B,EAAQt1C,KAAK+1C,GACVR,EACY,KAAZQ,EACAN,EACAC,IACNG,EAEN,CAiBA,SAAS5B,EAIP+B,EACAtF,EACAwC,QAAY,IAAZA,IAAAA,GAAe,GAEf,IAAI,WAAES,GAAeqC,EAEjBC,EAAgB,CAAC,EACjBC,EAAkB,IAClBpC,EAA2D,GAC/D,IAAK,IAAIl+C,EAAI,EAAGA,EAAI+9C,EAAW99C,SAAUD,EAAG,CAC1C,IAAI6U,EAAOkpC,EAAW/9C,GAClB8B,EAAM9B,IAAM+9C,EAAW99C,OAAS,EAChCsgD,EACkB,MAApBD,EACIxF,EACAA,EAASj4C,MAAMy9C,EAAgBrgD,SAAW,IAC5CoB,EAAQm/C,EACV,CAAEpF,KAAMvmC,EAAK6pC,aAAcC,cAAe9pC,EAAK8pC,cAAe78C,OAC9Dy+C,GAGE9B,EAAQ5pC,EAAK4pC,MAkBjB,IAfGp9C,GACDS,GACAw7C,IACCS,EAAWA,EAAW99C,OAAS,GAAGw+C,MAAMlpB,QAEzCl0B,EAAQm/C,EACN,CACEpF,KAAMvmC,EAAK6pC,aACXC,cAAe9pC,EAAK8pC,cACpB78C,KAAK,GAEPy+C,KAICl/C,EACH,OAAO,KAGTzD,OAAOoO,OAAOq0C,EAAeh/C,EAAMo/C,QAEnCvC,EAAQz7C,KAAK,CAEXg+C,OAAQJ,EACRvF,SAAU+D,EAAU,CAACyB,EAAiBj/C,EAAMy5C,WAC5C4F,aAAcC,EACZ9B,EAAU,CAACyB,EAAiBj/C,EAAMq/C,gBAEpCjC,UAGyB,MAAvBp9C,EAAMq/C,eACRJ,EAAkBzB,EAAU,CAACyB,EAAiBj/C,EAAMq/C,eAEvD,CAED,OAAOxC,CACT,CAiHgB,SAAAsC,EAIdI,EACA9F,GAEuB,kBAAZ8F,IACTA,EAAU,CAAExF,KAAMwF,EAASjC,eAAe,EAAO78C,KAAK,IAGxD,IAAK++C,EAASC,GA4ChB,SACE1F,EACAuD,EACA78C,QADa,IAAb68C,IAAAA,GAAgB,QACb,IAAH78C,IAAAA,GAAM,GAENu4C,EACW,MAATe,IAAiBA,EAAKkE,SAAS,MAAQlE,EAAKkE,SAAS,MACrD,eAAelE,EAAf,oCACMA,EAAKt6C,QAAQ,MAAO,MAD1B,qIAGsCs6C,EAAKt6C,QAAQ,MAAO,MAAK,MAGjE,IAAI2/C,EAA8B,GAC9BM,EACF,IACA3F,EACGt6C,QAAQ,UAAW,IACnBA,QAAQ,OAAQ,KAChBA,QAAQ,qBAAsB,QAC9BA,QACC,qBACA,CAACkgD,EAAWC,EAAmB5B,KAC7BoB,EAAOh+C,KAAK,CAAEw+C,YAAW5B,WAA0B,MAAdA,IAC9BA,EAAa,eAAiB,gBAIzCjE,EAAKkE,SAAS,MAChBmB,EAAOh+C,KAAK,CAAEw+C,UAAW,MACzBF,GACW,MAAT3F,GAAyB,OAATA,EACZ,QACA,qBACGt5C,EAETi/C,GAAgB,QACE,KAAT3F,GAAwB,MAATA,IAQxB2F,GAAgB,iBAKlB,IAAIF,EAAU,IAAIK,OAAOH,EAAcpC,OAAgBv6C,EAAY,KAEnE,MAAO,CAACy8C,EAASJ,EACnB,CAjGkCU,CAC9BP,EAAQxF,KACRwF,EAAQjC,cACRiC,EAAQ9+C,KAGNT,EAAQy5C,EAASz5C,MAAMw/C,GAC3B,IAAKx/C,EAAO,OAAO,KAEnB,IAAIi/C,EAAkBj/C,EAAM,GACxBq/C,EAAeJ,EAAgBx/C,QAAQ,UAAW,MAClDsgD,EAAgB//C,EAAMwB,MAAM,GAC5B49C,EAAiBK,EAAepJ,QAClC,CAACtD,EAAI+G,EAA6B5lB,KAAS,IAApC,UAAE0rB,EAAS,WAAE5B,GAAYlE,EAG9B,GAAkB,MAAd8F,EAAmB,CACrB,IAAII,EAAaD,EAAc7rB,IAAU,GACzCmrB,EAAeJ,EACZz9C,MAAM,EAAGy9C,EAAgBrgD,OAASohD,EAAWphD,QAC7Ca,QAAQ,UAAW,KACvB,CAED,MAAM1B,EAAQgiD,EAAc7rB,GAM5B,OAJE6e,EAAK6M,GADH5B,IAAejgD,OACCgF,GAEChF,GAAS,IAAI0B,QAAQ,OAAQ,KAE3CszC,CAAI,GAEb,CAAC,GAGH,MAAO,CACLqM,SACA3F,SAAUwF,EACVI,eACAE,UAEJ,CA2DM,SAAUxC,EAAWh/C,GACzB,IACE,OAAOA,EACJuK,MAAM,KACNkpC,KAAK5pC,GAAMq4C,mBAAmBr4C,GAAGnI,QAAQ,MAAO,SAChDs0B,KAAK,KACR,MAAOlzB,GAQP,OAPAm4C,GACE,EACA,iBAAiBj7C,EAAjB,oHAEe8C,EAAK,MAGf9C,CACR,CACH,CAKgB,SAAAm+C,EACdzC,EACAsC,GAEA,GAAiB,MAAbA,EAAkB,OAAOtC,EAE7B,IAAKA,EAASlxC,cAAcg1C,WAAWxB,EAASxzC,eAC9C,OAAO,KAKT,IAAI23C,EAAanE,EAASkC,SAAS,KAC/BlC,EAASn9C,OAAS,EAClBm9C,EAASn9C,OACTuhD,EAAW1G,EAAS33C,OAAOo+C,GAC/B,OAAIC,GAAyB,MAAbA,EAEP,KAGF1G,EAASj4C,MAAM0+C,IAAe,GACvC,OAiNa1C,EAAa4C,GACxBA,EAAMrsB,KAAK,KAAKt0B,QAAQ,SAAU,KAKvB6/C,EAAqB7F,GAChCA,EAASh6C,QAAQ,OAAQ,IAAIA,QAAQ,OAAQ,KAwELuB,MAySpC,SAAUq/C,EAAqBx/C,GACnC,OACW,MAATA,GACwB,kBAAjBA,EAAMy/C,QACe,kBAArBz/C,EAAM0/C,YACa,mBAAnB1/C,EAAM2/C,UACb,SAAU3/C,CAEd,CClgCA,MAAM4/C,EAAgD,CACpD,OACA,MACA,QACA,UAMIC,GAJuB,IAAI35C,IAC/B05C,GAG2C,CAC3C,SACGA,IAEuB,IAAI15C,IAAgB25C,GAEpB,IAAI35C,IAAI,CAAC,IAAK,IAAK,IAAK,IAAK,MACf,IAAIA,IAAI,CAAC,IAAK,MAwoFlByC,OAAO,gPC9vGtC,MAAMm3C,EACXC,EAAAA,cAAoD,MAK/C,MAAMC,EAAyBD,EAAAA,cAEpC,MA8CK,MAAME,EAAoBF,EAAAA,cAC/B,MAYK,MAAMG,EAAkBH,EAAAA,cAC7B,YAaWI,EAAeJ,EAAAA,cAAwC,CAClEK,OAAQ,KACRpE,QAAS,GACTqE,aAAa,IAOR,MAAMC,EAAoBP,EAAAA,cAAyB,MClFnD,SAASQ,IACd,OAA4C,MAArCR,EAAAA,WAAiBG,EAC1B,CAYO,SAASM,IAQd,OANED,KADFE,GAAU,GAOHV,EAAAA,WAAiBG,GAAiBx8C,QAC3C,CA2OO,SAASg9C,EACd1F,EACAC,EACA0F,EACAC,GAGEL,KADFE,GAAU,GAOV,IAAI,UAAE7N,GAAcmN,EAAAA,WAAiBE,IAC/BjE,QAAS6E,GAAkBd,EAAAA,WAAiBI,GAC9CW,EAAaD,EAAcA,EAAc9iD,OAAS,GAClDgjD,EAAeD,EAAaA,EAAWvC,OAAS,CAAC,EAEjDyC,GADiBF,GAAaA,EAAWlI,SACpBkI,EAAaA,EAAWtC,aAAe,KAC9CsC,GAAcA,EAAWvE,MAqC3C,IAEI74C,EAFAu9C,EAAsBT,IAG1B,GAAIvF,EAAa,KAAAiG,EACf,IAAIC,EACqB,kBAAhBlG,EAA2BnC,EAAUmC,GAAeA,EAGpC,MAAvB+F,IAC4B,OADFE,EACxBC,EAAkBvI,eAAQ,EAA1BsI,EAA4BxE,WAAWsE,KAF3CP,GAAU,GASV/8C,EAAWy9C,CACb,MACEz9C,EAAWu9C,EAGb,IAAIrI,EAAWl1C,EAASk1C,UAAY,IAEhCyF,EAAoBzF,EACxB,GAA2B,MAAvBoI,EAA4B,CAe9B,IAAII,EAAiBJ,EAAmBpiD,QAAQ,MAAO,IAAI6I,MAAM,KAEjE42C,EAAoB,IADLzF,EAASh6C,QAAQ,MAAO,IAAI6I,MAAM,KACd9G,MAAMygD,EAAerjD,QAAQm1B,KAAK,IACvE,CAEA,IAAI8oB,EAAUjB,EAAYC,EAAQ,CAAEpC,SAAUyF,IAmB9C,IAAIgD,EAAkBC,GACpBtF,GACEA,EAAQrL,KAAKxxC,GACXzD,OAAOoO,OAAO,CAAC,EAAG3K,EAAO,CACvBo/C,OAAQ7iD,OAAOoO,OAAO,CAAC,EAAGi3C,EAAc5hD,EAAMo/C,QAC9C3F,SAAU+D,EAAU,CAClBqE,EAEApO,EAAU2H,eACN3H,EAAU2H,eAAep7C,EAAMy5C,UAAUA,SACzCz5C,EAAMy5C,WAEZ4F,aACyB,MAAvBr/C,EAAMq/C,aACFwC,EACArE,EAAU,CACRqE,EAEApO,EAAU2H,eACN3H,EAAU2H,eAAep7C,EAAMq/C,cAAc5F,SAC7Cz5C,EAAMq/C,mBAIxBqC,EACAF,EACAC,GAMF,OAAI3F,GAAeoG,EAEftB,EAAAA,cAACG,EAAgBzO,SAAQ,CACvBv0C,MAAO,CACLwG,SAAQi1C,EAAA,CACNC,SAAU,IACV9zB,OAAQ,GACR+zB,KAAM,GACNta,MAAO,KACP/hC,IAAK,WACFkH,GAEL69C,eAAgBvJ,EAAe6B,MAGhCwH,GAKAA,CACT,CAEA,SAASG,IACP,IAAIxhD,EA0cC,WAAkC,IAAAyhD,EACvC,IAAIzhD,EAAQ+/C,EAAAA,WAAiBO,GACzB/hB,EAAQmjB,GAAmBC,GAAoBC,eAC/CC,EAAUC,GAAkBH,GAAoBC,eAIpD,QAAc1/C,IAAVlC,EACF,OAAOA,EAIT,OAAO,OAAPyhD,EAAOljB,EAAMwjB,aAAN,EAAAN,EAAeI,EACxB,CAvdcG,GACR7iB,EAAUqgB,EAAqBx/C,GAC5BA,EAAMy/C,OAAU,IAAAz/C,EAAM0/C,WACzB1/C,aAAiBG,MACjBH,EAAMm/B,QACN2N,KAAKC,UAAU/sC,GACfgK,EAAQhK,aAAiBG,MAAQH,EAAMgK,MAAQ,KAC/Ci4C,EAAY,yBACZC,EAAY,CAAEC,QAAS,SAAUC,gBAAiBH,GAsBtD,OACElC,EAAAA,cAAAA,EAAAA,SAAA,KACEA,EAAAA,cAAI,2CACJA,EAAAA,cAAA,MAAIlhD,MAAO,CAAEwjD,UAAW,WAAaljB,GACpCn1B,EAAQ+1C,EAAAA,cAAA,OAAKlhD,MAAOqjD,GAAYl4C,GAAe,KAvBtC,KA2BhB,CAEA,MAAMs4C,EAAsBvC,EAAAA,cAACyB,EAAqB,MAgB3C,MAAMe,UAA4BxC,EAAAA,UAIvCpjD,WAAAA,CAAY4G,GACVi/C,MAAMj/C,GACN5D,KAAK4+B,MAAQ,CACX76B,SAAUH,EAAMG,SAChB++C,aAAcl/C,EAAMk/C,aACpBziD,MAAOuD,EAAMvD,MAEjB,CAEA,+BAAO8/B,CAAyB9/B,GAC9B,MAAO,CAAEA,MAAOA,EAClB,CAEA,+BAAO6+B,CACLt7B,EACAg7B,GAUA,OACEA,EAAM76B,WAAaH,EAAMG,UACD,SAAvB66B,EAAMkkB,cAAkD,SAAvBl/C,EAAMk/C,aAEjC,CACLziD,MAAOuD,EAAMvD,MACb0D,SAAUH,EAAMG,SAChB++C,aAAcl/C,EAAMk/C,cAQjB,CACLziD,WAAuBkC,IAAhBqB,EAAMvD,MAAsBuD,EAAMvD,MAAQu+B,EAAMv+B,MACvD0D,SAAU66B,EAAM76B,SAChB++C,aAAcl/C,EAAMk/C,cAAgBlkB,EAAMkkB,aAE9C,CAEA1iB,iBAAAA,CAAkB//B,EAAY0iD,GAC5BnjB,QAAQv/B,MACN,wDACAA,EACA0iD,EAEJ,CAEA53C,MAAAA,GACE,YAA4B5I,IAArBvC,KAAK4+B,MAAMv+B,MAChB+/C,EAAAA,cAACI,EAAa1O,SAAQ,CAACv0C,MAAOyC,KAAK4D,MAAMo/C,cACvC5C,EAAAA,cAACO,EAAkB7O,SAAQ,CACzBv0C,MAAOyC,KAAK4+B,MAAMv+B,MAClBwN,SAAU7N,KAAK4D,MAAMq/C,aAIzBjjD,KAAK4D,MAAMiK,QAEf,EASF,SAASq1C,EAAa5J,GAAwD,IAAvD,aAAE0J,EAAY,MAAExjD,EAAK,SAAEqO,GAA8ByrC,EACtE6J,EAAoB/C,EAAAA,WAAiBD,GAazC,OAREgD,GACAA,EAAkBC,QAClBD,EAAkBE,gBACjB7jD,EAAMo9C,MAAM0G,cAAgB9jD,EAAMo9C,MAAM2G,iBAEzCJ,EAAkBE,cAAcG,2BAA6BhkD,EAAMo9C,MAAM1gC,IAIzEkkC,EAAAA,cAACI,EAAa1O,SAAQ,CAACv0C,MAAOylD,GAC3Bn1C,EAGP,CAEO,SAAS8zC,GACdtF,EACA6E,EACAF,EACAC,GAC2B,IAAAwC,EAC3B,QAJ2B,IAA3BvC,IAAAA,EAA8B,SACc,IAA5CF,IAAAA,EAA+C,WACX,IAApCC,IAAAA,EAAuC,MAExB,MAAX5E,EAAiB,KAAAqH,EACnB,IAAK1C,EACH,OAAO,KAGT,GAAIA,EAAgBoB,OAGlB/F,EAAU2E,EAAgB3E,YACrB,MACL,OAAAqH,EAAAzC,IAAAyC,EAAQC,qBACiB,IAAzBzC,EAAc9iD,SACb4iD,EAAgB4C,aACjB5C,EAAgB3E,QAAQj+C,OAAS,GAUjC,OAAO,KAFPi+C,EAAU2E,EAAgB3E,OAG5B,CACF,CAEA,IAAIqF,EAAkBrF,EAGlB+F,EAAS,OAAHqB,EAAGzC,QAAA,EAAAyC,EAAiBrB,OAC9B,GAAc,MAAVA,EAAgB,CAClB,IAAIyB,EAAanC,EAAgBoC,WAC9BhjD,GAAMA,EAAE87C,MAAM1gC,SAA+B3Z,KAAnB,MAAN6/C,OAAM,EAANA,EAASthD,EAAE87C,MAAM1gC,OAGtC2nC,GAAc,GADhB/C,GAAU,GAMVY,EAAkBA,EAAgB1gD,MAChC,EACA6W,KAAKyQ,IAAIo5B,EAAgBtjD,OAAQylD,EAAa,GAElD,CAIA,IAAIE,GAAiB,EACjBC,GAAiB,EACrB,GAAIhD,GAAmBC,GAAUA,EAAO0C,oBACtC,IAAK,IAAIxlD,EAAI,EAAGA,EAAIujD,EAAgBtjD,OAAQD,IAAK,CAC/C,IAAIqB,EAAQkiD,EAAgBvjD,GAM5B,IAJIqB,EAAMo9C,MAAMqH,iBAAmBzkD,EAAMo9C,MAAMsH,0BAC7CF,EAAgB7lD,GAGdqB,EAAMo9C,MAAM1gC,GAAI,CAClB,IAAI,WAAEioC,EAAU,OAAE/B,GAAWpB,EACzBoD,EACF5kD,EAAMo9C,MAAMyH,aACmB9hD,IAA/B4hD,EAAW3kD,EAAMo9C,MAAM1gC,OACrBkmC,QAAqC7/C,IAA3B6/C,EAAO5iD,EAAMo9C,MAAM1gC,KACjC,GAAI1c,EAAMo9C,MAAMtK,MAAQ8R,EAAkB,CAIxCL,GAAiB,EAEfrC,EADEsC,GAAiB,EACDtC,EAAgB1gD,MAAM,EAAGgjD,EAAgB,GAEzC,CAACtC,EAAgB,IAErC,KACF,CACF,CACF,CAGF,OAAOA,EAAgB4C,aAAY,CAAC7D,EAAQjhD,EAAOk0B,KAEjD,IAAIrzB,EACAkkD,GAA8B,EAC9BjB,EAAuC,KACvCY,EAAiD,KA0VzD,IAAqBrnD,EAzVbmkD,IACF3gD,EAAQ+hD,GAAU5iD,EAAMo9C,MAAM1gC,GAAKkmC,EAAO5iD,EAAMo9C,MAAM1gC,SAAM3Z,EAC5D+gD,EAAe9jD,EAAMo9C,MAAM0G,cAAgBX,EAEvCoB,IACEC,EAAgB,GAAe,IAAVtwB,GAoVZ72B,EAlVT,kBACA,GAkVI2nD,GAAc3nD,KAC1B2nD,GAAc3nD,IAAO,GAhVf0nD,GAA8B,EAC9BL,EAAyB,MAChBF,IAAkBtwB,IAC3B6wB,GAA8B,EAC9BL,EAAyB1kD,EAAMo9C,MAAMsH,wBAA0B,QAKrE,IAAI7H,EAAU6E,EAAc/8C,OAAOu9C,EAAgB1gD,MAAM,EAAG0yB,EAAQ,IAChE+wB,EAAcA,KAChB,IAAI52C,EAkBJ,OAhBEA,EADExN,EACSijD,EACFiB,EACEL,EACF1kD,EAAMo9C,MAAMxL,UAOVgP,EAAAA,cAAC5gD,EAAMo9C,MAAMxL,UAAS,MACxB5xC,EAAMo9C,MAAMp3C,QACVhG,EAAMo9C,MAAMp3C,QAEZi7C,EAGXL,EAAAA,cAAC8C,EAAa,CACZ1jD,MAAOA,EACPwjD,aAAc,CACZvC,SACApE,UACAqE,YAAgC,MAAnBM,GAEfnzC,SAAUA,GACV,EAMN,OAAOmzC,IACJxhD,EAAMo9C,MAAM2G,eAAiB/jD,EAAMo9C,MAAM0G,cAA0B,IAAV5vB,GAC1D0sB,EAAAA,cAACwC,EAAmB,CAClB7+C,SAAUi9C,EAAgBj9C,SAC1B++C,aAAc9B,EAAgB8B,aAC9BG,UAAWK,EACXjjD,MAAOA,EACPwN,SAAU42C,IACVzB,aAAc,CAAEvC,OAAQ,KAAMpE,UAASqE,aAAa,KAGtD+D,GACD,GACA,KACL,CAAC,IAQIzC,GAAmB,SAAnBA,GAAmB,OAAnBA,EAAmB,wBAAnBA,EAAmB,8BAAnBA,EAAmB,8BAAnBA,EAAmB,8BAAnBA,EAAmB,8BAAnBA,EAAmB,wCAAnBA,EAAmB,wBAAnBA,EAAmB,gCAAnBA,EAAmB,gCAAnBA,EAAmB,wBAAnBA,CAAmB,EAAnBA,IAAmB,IAyBxB,SAASD,GAAmB2C,GAC1B,IAAI9lB,EAAQwhB,EAAAA,WAAiBC,GAE7B,OADUzhB,GAAVkiB,GAAU,GACHliB,CACT,CASA,SAASujB,GAAkBuC,GACzB,IAAI9H,EARN,WACE,IAAIA,EAAQwD,EAAAA,WAAiBI,GAE7B,OADU5D,GAAVkE,GAAU,GACHlE,CACT,CAIc+H,GACRC,EAAYhI,EAAMP,QAAQO,EAAMP,QAAQj+C,OAAS,GAKrD,OAHEwmD,EAAUhI,MAAM1gC,IADlB4kC,GAAU,GAIH8D,EAAUhI,MAAM1gC,EACzB,CA4NA,MAAMsoC,GAAyC,CAAC,ECvlChD,MAAMK,GAA4C,CAAC,EASnD,MAAMC,GAAiBA,CAACC,EAAczkD,EAAayS,KAP5C,IAA+BysB,EAC/BqlB,GAD+BrlB,EAUlC,kDAAwCl/B,EAAxC,sBACuBykD,EADvB,4DAE+BhyC,EAAI,OAVnC8xC,GAAcrlB,IAAW,EACzBI,QAAQ8Y,KAAKlZ,GAUd,EAEI,SAASwlB,GACdC,EACAC,GAEiB,MAAZD,GAAAA,EAAcE,oBACjBL,GACE,qBACA,kFACA,kEAKD,MAAAG,GAAAA,EAAcG,sBACbF,GAAiBA,EAAaE,sBAEhCN,GACE,uBACA,kEACA,oEAIAI,IACGA,EAAaG,mBAChBP,GACE,oBACA,yDACA,iEAICI,EAAaI,wBAChBR,GACE,yBACA,uEACA,sEAICI,EAAavB,qBAChBmB,GACE,sBACA,wDACA,mEAICI,EAAaK,gCAChBT,GACE,iCACA,+EACA,8EAIR,CCY4B1E,EAAsB,gBAgT3C,SAASoF,GAAMC,GACpB3E,GAAU,EAKZ,CAqBO,SAAS4E,GAAMC,GAQqB,IAPzCpK,SAAUqK,EAAe,IAAG,SAC5B/3C,EAAW,KACX9J,SAAU8hD,EAAY,eACtBjE,EAAiBvJ,EAAe6B,IAAG,UACnCjH,EACAmQ,OAAQ0C,GAAa,EAAK,OAC1B7E,GACY0E,EAET/E,KADHE,GAAU,GAQV,IAAIvF,EAAWqK,EAAa3mD,QAAQ,OAAQ,KACxC8mD,EAAoB3F,EAAAA,SACtB,KAAM,CACJ7E,WACAtI,YACAmQ,OAAQ0C,EACR7E,OAAMjI,EAAA,CACJoM,sBAAsB,GACnBnE,MAGP,CAAC1F,EAAU0F,EAAQhO,EAAW6S,IAGJ,kBAAjBD,IACTA,EAAe1M,EAAU0M,IAG3B,IAAI,SACF5M,EAAW,IAAG,OACd9zB,EAAS,GAAE,KACX+zB,EAAO,GAAE,MACTta,EAAQ,KAAI,IACZ/hC,EAAM,WACJgpD,EAEAG,EAAkB5F,EAAAA,SAAc,KAClC,IAAI6F,EAAmBvK,EAAczC,EAAUsC,GAE/C,OAAwB,MAApB0K,EACK,KAGF,CACLliD,SAAU,CACRk1C,SAAUgN,EACV9gC,SACA+zB,OACAta,QACA/hC,OAEF+kD,iBACD,GACA,CAACrG,EAAUtC,EAAU9zB,EAAQ+zB,EAAMta,EAAO/hC,EAAK+kD,IASlD,OAAuB,MAAnBoE,EACK,KAIP5F,EAAAA,cAACE,EAAkBxO,SAAQ,CAACv0C,MAAOwoD,GACjC3F,EAAAA,cAACG,EAAgBzO,SAAQ,CAACjkC,SAAUA,EAAUtQ,MAAOyoD,IAG3D,CAaO,SAASE,GAAMC,GAGqB,IAHpB,SACrBt4C,EAAQ,SACR9J,GACYoiD,EACZ,OF3KOpF,EE2KUqF,GAAyBv4C,GAAW9J,EACvD,CAuC4B,IAAIoqB,SAAQ,SAEPiyB,EAAAA,UAkH1B,SAASgG,GACdv4C,EACA6uC,QAAoB,IAApBA,IAAAA,EAAuB,IAEvB,IAAIrB,EAAwB,GA6D5B,OA3DA+E,EAAAA,SAAel9C,QAAQ2K,GAAU,CAACrI,EAASkuB,KACzC,IAAK0sB,EAAAA,eAAqB56C,GAGxB,OAGF,IAAI6gD,EAAW,IAAI3J,EAAYhpB,GAE/B,GAAIluB,EAAQjE,OAAS6+C,EAAAA,SAMnB,YAJA/E,EAAOz6C,KAAKyC,MACVg4C,EACA+K,GAAyB5gD,EAAQ5B,MAAMiK,SAAUw4C,IAMnD7gD,EAAQjE,OAASikD,IADnB1E,GAAU,GAQPt7C,EAAQ5B,MAAM8vB,OAAUluB,EAAQ5B,MAAMiK,UADzCizC,GAAU,GAKV,IAAIlE,EAAqB,CACvB1gC,GAAI1W,EAAQ5B,MAAMsY,IAAMmqC,EAAS9yB,KAAK,KACtCupB,cAAet3C,EAAQ5B,MAAMk5C,cAC7Bt3C,QAASA,EAAQ5B,MAAM4B,QACvB4rC,UAAW5rC,EAAQ5B,MAAMwtC,UACzB1d,MAAOluB,EAAQ5B,MAAM8vB,MACrB6lB,KAAM/zC,EAAQ5B,MAAM21C,KACpB8K,OAAQ7+C,EAAQ5B,MAAMygD,OACtBvqB,OAAQt0B,EAAQ5B,MAAMk2B,OACtBwpB,aAAc99C,EAAQ5B,MAAM0/C,aAC5BC,cAAe/9C,EAAQ5B,MAAM2/C,cAC7B+C,iBACiC,MAA/B9gD,EAAQ5B,MAAM2/C,eACgB,MAA9B/9C,EAAQ5B,MAAM0/C,aAChBiD,iBAAkB/gD,EAAQ5B,MAAM2iD,iBAChCC,OAAQhhD,EAAQ5B,MAAM4iD,OACtBlU,KAAM9sC,EAAQ5B,MAAM0uC,MAGlB9sC,EAAQ5B,MAAMiK,WAChB+uC,EAAM/uC,SAAWu4C,GACf5gD,EAAQ5B,MAAMiK,SACdw4C,IAIJhL,EAAOz6C,KAAKg8C,EAAM,IAGbvB,CACT,CC1fgD,IAAI90C,IAAI,CACtD,oCACA,sBACA,eCeF,IACEM,OAAO4/C,qBAHT,GAIC,CAAC,MAAOpkD,IACP,CAgJiE,IAAI2X,IAkCvE,MACM0sC,GAAsBtG,EAAsB,gBAE5BuG,EAAmB,UAEvBvG,EAAY,MAiWxB,SAAUwG,GAAaC,GAKR,IALS,SAC5BtL,EAAQ,SACR1tC,EAAQ,OACRozC,EAAM,OACNp6C,GACmBggD,EACfC,EAAa1G,EAAAA,SACS,MAAtB0G,EAAW7wC,UACb6wC,EAAW7wC,QRpbC,SACd9Y,GAoBA,YApBA,IAAAA,IAAAA,EAAiC,CAAC,GAoB3Bw8C,GAlBP,SACE9yC,EACAmzC,GAEA,IAAI,SAAEf,EAAQ,OAAE9zB,EAAM,KAAE+zB,GAASryC,EAAO9C,SACxC,OAAO+0C,EACL,GACA,CAAEG,WAAU9zB,SAAQ+zB,QAEnBc,EAAcpb,OAASob,EAAcpb,MAAMga,KAAQ,KACnDoB,EAAcpb,OAASob,EAAcpb,MAAM/hC,KAAQ,UAExD,IAEA,SAA2BgK,EAAgBkyC,GACzC,MAAqB,kBAAPA,EAAkBA,EAAKM,EAAWN,EAClD,GAKE,KACA57C,EAEJ,CQyZyB4pD,CAAqB,CAAElgD,SAAQkzC,UAAU,KAGhE,IAAIE,EAAU6M,EAAW7wC,SACpB2oB,EAAOooB,GAAgB5G,EAAAA,SAAe,CACzCtmB,OAAQmgB,EAAQngB,OAChB/1B,SAAUk2C,EAAQl2C,YAEhB,mBAAEohD,GAAuBlE,GAAU,CAAC,EACpCvQ,EAAW0P,EAAAA,aACZ6G,IACC9B,GAAsBuB,GAClBA,IAAoB,IAAMM,EAAaC,KACvCD,EAAaC,EAAS,GAE5B,CAACD,EAAc7B,IAOjB,OAJA/E,EAAAA,iBAAsB,IAAMnG,EAAQU,OAAOjK,IAAW,CAACuJ,EAASvJ,IAEhE0P,EAAAA,WAAgB,IAAM8G,GAAyBjG,IAAS,CAACA,IAGvDb,EAAAA,cAACsF,GAAM,CACLnK,SAAUA,EACV1tC,SAAUA,EACV9J,SAAU66B,EAAM76B,SAChB69C,eAAgBhjB,EAAM9E,OACtBmZ,UAAWgH,EACXgH,OAAQA,GAGd,CA0HoB,qBAAXp6C,QACoB,qBAApBA,OAAOC,UACPD,OAAOC,SAASC,cAyazB,IAAKogD,GAQAnF,IARL,SAAKmF,GACHA,EAAA,4CACAA,EAAA,sBACAA,EAAA,oCACAA,EAAA,wBACAA,EAAA,+CACD,EAND,CAAKA,KAAAA,GAMJ,KAED,SAAKnF,GACHA,EAAA,wBACAA,EAAA,0BACAA,EAAA,2CACD,CAJD,CAAKA,KAAAA,GAIJ,8BC32CD,MACaoF,GAAe,SAACC,GAA0B,IAAhBx/B,EAAI3pB,UAAAE,OAAA,QAAAmE,IAAArE,UAAA,GAAAA,UAAA,GAAG,KAC5C,OAAgB,MAAZmpD,EAAyBplC,OAAOolC,GAC7Bx/B,GAAQ,IACjB,EACA,GALuCu4B,EAAAA,cAAoB,MCD3D,SAAS,KACP,OAAO,GAAWrkD,OAAOoO,OAASpO,OAAOoO,OAAO9F,OAAS,SAAU4nB,GACjE,IAAK,IAAI5pB,EAAI,EAAGA,EAAInE,UAAUE,OAAQiE,IAAK,CACzC,IAAI6pB,EAAIhuB,UAAUmE,GAClB,IAAK,IAAI6xB,KAAKhI,GAAG,CAAG,GAAEjwB,eAAeS,KAAKwvB,EAAGgI,KAAOjI,EAAEiI,GAAKhI,EAAEgI,GAC/D,CACA,OAAOjI,CACT,EAAG,GAAS5oB,MAAM,KAAMnF,UAC1B,CCRA,SAAS,GAA8Bg2B,EAAG7xB,GACxC,GAAI,MAAQ6xB,EAAG,MAAO,CAAC,EACvB,IAAIhI,EAAI,CAAC,EACT,IAAK,IAAID,KAAKiI,EAAG,GAAI,CAAC,EAAEj4B,eAAeS,KAAKw3B,EAAGjI,GAAI,CACjD,GAAI5pB,EAAE2I,SAASihB,GAAI,SACnBC,EAAED,GAAKiI,EAAEjI,EACX,CACA,OAAOC,CACT,QCuBO,SAASo7B,GAAWzqD,GACzB,MAAO,UAAYA,EAAIyE,OAAO,GAAG4G,cAAgBrL,EAAIu8C,OAAO,EAC9D,CC9BA,SAASmO,GAAe9S,GAAO,IAAI53C,EAEnC,SAAsBgW,EAAO20C,GAAQ,GAAqB,kBAAV30C,GAAgC,OAAVA,EAAgB,OAAOA,EAAO,IAAI40C,EAAO50C,EAAM7J,OAAO0+C,aAAc,QAAanlD,IAATklD,EAAoB,CAAE,IAAIE,EAAMF,EAAK/qD,KAAKmW,EAAO20C,GAAQ,WAAY,GAAmB,kBAARG,EAAkB,OAAOA,EAAK,MAAM,IAAIxoD,UAAU,+CAAiD,CAAE,OAAiB,WAATqoD,EAAoBvlC,OAAS2lC,QAAQ/0C,EAAQ,CAF/Ug1C,CAAapT,EAAK,UAAW,MAAsB,kBAAR53C,EAAmBA,EAAMolB,OAAOplB,EAAM,CAqC3G,SAASirD,GAAgBlkD,EAAOmkD,GAC7C,OAAOhsD,OAAOmW,KAAK61C,GAAQlS,QAAO,SAAUzyC,EAAQ4kD,GAClD,IAAIC,EAEA3O,EAAOl2C,EACPuJ,EAAe2sC,EAAK4O,GAAiBF,IACrCG,EAAa7O,EAAK0O,GAClBzK,EAAO6K,GAA8B9O,EAAM,CAAC4O,GAAiBF,GAAYA,GAAWhX,IAAIuW,KAExFc,EAAcN,EAAOC,GAErBM,EAzCR,SAA6BC,EAAW57C,EAAc67C,GACpD,IAAIC,GAAarrB,EAAAA,EAAAA,aAAqB76B,IAAdgmD,GAEpBG,GAAYrrB,EAAAA,EAAAA,UAAS1wB,GACrBg8C,EAAaD,EAAU,GACvBhY,EAAWgY,EAAU,GAErBE,OAAuBrmD,IAAdgmD,EACTM,EAAUJ,EAAWxyC,QAWzB,OAVAwyC,EAAWxyC,QAAU2yC,GAMhBA,GAAUC,GAAWF,IAAeh8C,GACvC+jC,EAAS/jC,GAGJ,CAACi8C,EAASL,EAAYI,GAAY/rB,EAAAA,EAAAA,cAAY,SAAUr/B,GAC7D,IAAK,IAAIoF,EAAOzE,UAAUE,OAAQoE,EAAO,IAAI/F,MAAMkG,EAAO,EAAIA,EAAO,EAAI,GAAIE,EAAO,EAAGA,EAAOF,EAAME,IAClGL,EAAKK,EAAO,GAAK3E,UAAU2E,GAGzB2lD,GAASA,EAAQnlD,WAAM,EAAQ,CAAC9F,GAAO4G,OAAO3B,IAClDkuC,EAASnzC,EACX,GAAG,CAACirD,IACN,CAc+BM,CAAoBX,EAAYx7C,EAAc/I,EAAMykD,IAC3E9qD,EAAQ+qD,EAAqB,GAC7BE,EAAUF,EAAqB,GAEnC,OAAOtP,GAAS,CAAC,EAAGuE,IAAO0K,EAAY,CAAC,GAAaD,GAAazqD,EAAO0qD,EAAUI,GAAeG,EAASP,GAC7G,GAAGrkD,EACL,CClDA,SAASy7B,KAEP,IAAIT,EAAQ5+B,KAAKhD,YAAYkiC,yBAAyBl/B,KAAK4D,MAAO5D,KAAK4+B,OACzD,OAAVA,QAA4Br8B,IAAVq8B,GACpB5+B,KAAK0wC,SAAS9R,EAElB,CAEA,SAASG,GAA0BgqB,GAQjC/oD,KAAK0wC,SALL,SAAiBsY,GACf,IAAIpqB,EAAQ5+B,KAAKhD,YAAYkiC,yBAAyB6pB,EAAWC,GACjE,OAAiB,OAAVpqB,QAA4Br8B,IAAVq8B,EAAsBA,EAAQ,IACzD,EAEsBv6B,KAAKrE,MAC7B,CAEA,SAASgiC,GAAoB+mB,EAAWE,GACtC,IACE,IAAIC,EAAYlpD,KAAK4D,MACjBolD,EAAYhpD,KAAK4+B,MACrB5+B,KAAK4D,MAAQmlD,EACb/oD,KAAK4+B,MAAQqqB,EACbjpD,KAAKmpD,6BAA8B,EACnCnpD,KAAKopD,wBAA0BppD,KAAKm/B,wBAClC+pB,EACAF,EAEJ,CAAE,QACAhpD,KAAK4D,MAAQslD,EACblpD,KAAK4+B,MAAQoqB,CACf,CACF,CAIA3pB,GAAmBgqB,8BAA+B,EAClDtqB,GAA0BsqB,8BAA+B,EACzDrnB,GAAoBqnB,8BAA+B,gBC1C5C,MAAMC,GAAsB,CAAC,MAAO,KAAM,KAAM,KAAM,KAAM,MACtDC,GAAyB,KAChCC,GAA4BpJ,EAAAA,cAAoB,CACpDqJ,SAAU,CAAC,EACXC,YAAaJ,GACbK,cAAeJ,MAEX,SACJxX,GAAQ,SACRD,IACE0X,GAqBG,SAASI,GAAmBC,EAAQC,GACzC,MAAM,SACJL,IACE5sB,EAAAA,EAAAA,YAAW2sB,IACf,OAAOK,GAAUJ,EAASK,IAAkBA,CAC9C,CA2CA,MC9EMC,GAA2B3J,EAAAA,YAAiB,CAAA9G,EAK/CpmB,KAAQ,IALwC,SACjD82B,EAAQ,UACRC,EAAS,GACTC,KACGtmD,GACJ01C,EACC0Q,EAAWJ,GAAmBI,EAAU,gBACxC,MAAM5Y,EAAY8Y,IAAOtmD,EAAMikB,KAAO,IAAM,QAC5C,OAAoBsiC,EAAAA,GAAAA,KAAK/Y,EAAW,IAC/BxtC,EACHsvB,IAAKA,EACL+2B,UAAW1V,KAAW0V,EAAWD,IACjC,IAEJD,GAAYh/C,YAAc,cAC1B,YChBe,SAASsC,GAAcxN,GACpC,OAAOA,GAAQA,EAAKwN,eAAiBvG,QACvC,CCCe,SAASsjD,GAAiBvqD,EAAMwqD,GAC7C,OCFa,SAAqBxqD,GAClC,IAAIyqD,EAAMj9C,GAAcxN,GACxB,OAAOyqD,GAAOA,EAAI/hC,aAAe1hB,MACnC,CDDS0jD,CAAY1qD,GAAMuqD,iBAAiBvqD,EAAMwqD,EAClD,CEVA,IAAIG,GAAS,WCMb,IAAIC,GAAY,OACD,SAASC,GAAmBtlD,GACzC,ODPa,SAAmBA,GAChC,OAAOA,EAAOnG,QAAQurD,GAAQ,OAAOziD,aACvC,CCKS4iD,CAAUvlD,GAAQnG,QAAQwrD,GAAW,OAC9C,CCTA,IAAIG,GAAsB,8EC+B1B,SA3BA,SAAe/qD,EAAM+B,GACnB,IAAIipD,EAAM,GACNC,EAAa,GAEjB,GAAwB,kBAAblpD,EACT,OAAO/B,EAAKX,MAAM6rD,iBAAiBJ,GAAU/oD,KAAcwoD,GAAiBvqD,GAAMkrD,iBAAiBJ,GAAU/oD,IAG/G7F,OAAOmW,KAAKtQ,GAAUsB,SAAQ,SAAUrG,GACtC,IAAIU,EAAQqE,EAAS/E,GAEhBU,GAAmB,IAAVA,GDdH,SAAqBA,GAClC,SAAUA,IAASqtD,GAAoBriD,KAAKhL,GAC9C,CCceytD,CAAYnuD,GAGrBguD,GAAOF,GAAU9tD,GAAO,KAAOU,EAAQ,IAFvCutD,GAAcjuD,EAAM,IAAMU,EAAQ,KAFlCsC,EAAKX,MAAM+rD,eAAeN,GAAU9tD,GAMxC,IAEIiuD,IACFD,GAAO,cAAgBC,EAAa,KAGtCjrD,EAAKX,MAAMgsD,SAAW,IAAML,CAC9B,EC7BA,SAASM,GAAgBj/B,EAAG7pB,GAC1B,OAAO8oD,GAAkBpvD,OAAOqvD,eAAiBrvD,OAAOqvD,eAAe/mD,OAAS,SAAU6nB,EAAG7pB,GAC3F,OAAO6pB,EAAEm/B,UAAYhpD,EAAG6pB,CAC1B,EAAGi/B,GAAgBj/B,EAAG7pB,EACxB,CCJA,UACY,ECAZ,GAAe+9C,EAAAA,cAAoB,MCD5B,ICSIkL,GAAY,YACZC,GAAS,SACTC,GAAW,WACXC,GAAU,UACVC,GAAU,UA6FjBC,GAA0B,SAAUC,GCzGxC,IAAwB1/B,EAAGwpB,ED4GzB,SAASiW,EAAW/nD,EAAO2xB,GACzB,IAAIs2B,EAEJA,EAAQD,EAAiBlvD,KAAKsD,KAAM4D,EAAO2xB,IAAYv1B,KACvD,IAGI8rD,EADAC,EAFcx2B,MAEuBy2B,WAAapoD,EAAMqoD,MAAQroD,EAAMmoD,OAuB1E,OArBAF,EAAMK,aAAe,KAEjBtoD,EAAMuoD,GACJJ,GACFD,EAAgBP,GAChBM,EAAMK,aAAeV,IAErBM,EAAgBL,GAIhBK,EADEloD,EAAMwoD,eAAiBxoD,EAAMyoD,aACff,GAEAC,GAIpBM,EAAMjtB,MAAQ,CACZkhB,OAAQgM,GAEVD,EAAMS,aAAe,KACdT,CACT,CC1IyBnW,ED0GEkW,GC1GL1/B,ED0GPy/B,GCzGb3vD,UAAYD,OAAOq/B,OAAOsa,EAAE15C,WAAYkwB,EAAElwB,UAAUgB,YAAckvB,EAAG,GAAeA,EAAGwpB,GD2IzFiW,EAAWzsB,yBAA2B,SAAkCoa,EAAM0P,GAG5E,OAFa1P,EAAK6S,IAEJnD,EAAUlJ,SAAWwL,GAC1B,CACLxL,OAAQyL,IAIL,IACT,EAkBA,IAAIgB,EAASZ,EAAW3vD,UAkPxB,OAhPAuwD,EAAOjtB,kBAAoB,WACzBt/B,KAAKwsD,cAAa,EAAMxsD,KAAKksD,aAC/B,EAEAK,EAAOtqB,mBAAqB,SAA4BinB,GACtD,IAAIuD,EAAa,KAEjB,GAAIvD,IAAclpD,KAAK4D,MAAO,CAC5B,IAAIk8C,EAAS9/C,KAAK4+B,MAAMkhB,OAEpB9/C,KAAK4D,MAAMuoD,GACTrM,IAAW0L,IAAY1L,IAAW2L,KACpCgB,EAAajB,IAGX1L,IAAW0L,IAAY1L,IAAW2L,KACpCgB,EAAaf,GAGnB,CAEA1rD,KAAKwsD,cAAa,EAAOC,EAC3B,EAEAF,EAAO7lB,qBAAuB,WAC5B1mC,KAAK0sD,oBACP,EAEAH,EAAOI,YAAc,WACnB,IACIC,EAAMX,EAAOF,EADbpV,EAAU32C,KAAK4D,MAAM+yC,QAWzB,OATAiW,EAAOX,EAAQF,EAASpV,EAET,MAAXA,GAAsC,kBAAZA,IAC5BiW,EAAOjW,EAAQiW,KACfX,EAAQtV,EAAQsV,MAEhBF,OAA4BxpD,IAAnBo0C,EAAQoV,OAAuBpV,EAAQoV,OAASE,GAGpD,CACLW,KAAMA,EACNX,MAAOA,EACPF,OAAQA,EAEZ,EAEAQ,EAAOC,aAAe,SAAsBK,EAAUJ,GAKpD,QAJiB,IAAbI,IACFA,GAAW,GAGM,OAAfJ,EAIF,GAFAzsD,KAAK0sD,qBAEDD,IAAejB,GAAU,CAC3B,GAAIxrD,KAAK4D,MAAMwoD,eAAiBpsD,KAAK4D,MAAMyoD,aAAc,CACvD,IAAIxsD,EAAOG,KAAK4D,MAAMkpD,QAAU9sD,KAAK4D,MAAMkpD,QAAQ72C,QAAU0wC,EAAAA,YAAqB3mD,MAI9EH,GDzOW,SAAqBA,GACrCA,EAAKypB,SACd,CCuOoByjC,CAAYltD,EACxB,CAEAG,KAAKgtD,aAAaH,EACpB,MACE7sD,KAAKitD,mBAEEjtD,KAAK4D,MAAMwoD,eAAiBpsD,KAAK4+B,MAAMkhB,SAAWyL,IAC3DvrD,KAAK0wC,SAAS,CACZoP,OAAQwL,IAGd,EAEAiB,EAAOS,aAAe,SAAsBH,GAC1C,IAAIK,EAASltD,KAETisD,EAAQjsD,KAAK4D,MAAMqoD,MACnBkB,EAAYntD,KAAKu1B,QAAUv1B,KAAKu1B,QAAQy2B,WAAaa,EAErDO,EAAQptD,KAAK4D,MAAMkpD,QAAU,CAACK,GAAa,CAACxG,EAAAA,YAAqB3mD,MAAOmtD,GACxEE,EAAYD,EAAM,GAClBE,EAAiBF,EAAM,GAEvBG,EAAWvtD,KAAK2sD,cAChBa,EAAeL,EAAYI,EAASxB,OAASwB,EAAStB,OAGrDY,IAAaZ,GAASlE,GACzB/nD,KAAKytD,aAAa,CAChB3N,OAAQ2L,KACP,WACDyB,EAAOtpD,MAAM8pD,UAAUL,EACzB,KAIFrtD,KAAK4D,MAAM+pD,QAAQN,EAAWC,GAC9BttD,KAAKytD,aAAa,CAChB3N,OAAQ0L,KACP,WACD0B,EAAOtpD,MAAMgqD,WAAWP,EAAWC,GAEnCJ,EAAOW,gBAAgBL,GAAc,WACnCN,EAAOO,aAAa,CAClB3N,OAAQ2L,KACP,WACDyB,EAAOtpD,MAAM8pD,UAAUL,EAAWC,EACpC,GACF,GACF,IACF,EAEAf,EAAOU,YAAc,WACnB,IAAIa,EAAS9tD,KAET4sD,EAAO5sD,KAAK4D,MAAMgpD,KAClBW,EAAWvtD,KAAK2sD,cAChBU,EAAYrtD,KAAK4D,MAAMkpD,aAAUvqD,EAAYokD,EAAAA,YAAqB3mD,MAEjE4sD,IAAQ7E,IASb/nD,KAAK4D,MAAMmqD,OAAOV,GAClBrtD,KAAKytD,aAAa,CAChB3N,OAAQ4L,KACP,WACDoC,EAAOlqD,MAAMoqD,UAAUX,GAEvBS,EAAOD,gBAAgBN,EAASX,MAAM,WACpCkB,EAAOL,aAAa,CAClB3N,OAAQyL,KACP,WACDuC,EAAOlqD,MAAMqqD,SAASZ,EACxB,GACF,GACF,KArBErtD,KAAKytD,aAAa,CAChB3N,OAAQyL,KACP,WACDuC,EAAOlqD,MAAMqqD,SAASZ,EACxB,GAkBJ,EAEAd,EAAOG,mBAAqB,WACA,OAAtB1sD,KAAKssD,eACPtsD,KAAKssD,aAAa4B,SAClBluD,KAAKssD,aAAe,KAExB,EAEAC,EAAOkB,aAAe,SAAsBxE,EAAWryB,GAIrDA,EAAW52B,KAAKmuD,gBAAgBv3B,GAChC52B,KAAK0wC,SAASuY,EAAWryB,EAC3B,EAEA21B,EAAO4B,gBAAkB,SAAyBv3B,GAChD,IAAIw3B,EAASpuD,KAETquD,GAAS,EAcb,OAZAruD,KAAKssD,aAAe,SAAU1mC,GACxByoC,IACFA,GAAS,EACTD,EAAO9B,aAAe,KACtB11B,EAAShR,GAEb,EAEA5lB,KAAKssD,aAAa4B,OAAS,WACzBG,GAAS,CACX,EAEOruD,KAAKssD,YACd,EAEAC,EAAOsB,gBAAkB,SAAyBlX,EAAS6R,GACzDxoD,KAAKmuD,gBAAgB3F,GACrB,IAAI3oD,EAAOG,KAAK4D,MAAMkpD,QAAU9sD,KAAK4D,MAAMkpD,QAAQ72C,QAAU0wC,EAAAA,YAAqB3mD,MAC9EsuD,EAA0C,MAAX3X,IAAoB32C,KAAK4D,MAAM2qD,eAElE,GAAK1uD,IAAQyuD,EAAb,CAKA,GAAItuD,KAAK4D,MAAM2qD,eAAgB,CAC7B,IAAIC,EAAQxuD,KAAK4D,MAAMkpD,QAAU,CAAC9sD,KAAKssD,cAAgB,CAACzsD,EAAMG,KAAKssD,cAC/De,EAAYmB,EAAM,GAClBC,EAAoBD,EAAM,GAE9BxuD,KAAK4D,MAAM2qD,eAAelB,EAAWoB,EACvC,CAEe,MAAX9X,GACF5oB,WAAW/tB,KAAKssD,aAAc3V,EAXhC,MAFE5oB,WAAW/tB,KAAKssD,aAAc,EAelC,EAEAC,EAAOphD,OAAS,WACd,IAAI20C,EAAS9/C,KAAK4+B,MAAMkhB,OAExB,GAAIA,IAAWwL,GACb,OAAO,KAGT,IAAIoD,EAAc1uD,KAAK4D,MACnBiK,EAAW6gD,EAAY7gD,SAgBvB8gD,GAfMD,EAAYvC,GACFuC,EAAYrC,aACXqC,EAAYtC,cACnBsC,EAAY3C,OACb2C,EAAYzC,MACbyC,EAAY9B,KACT8B,EAAY/X,QACL+X,EAAYH,eACnBG,EAAYf,QACTe,EAAYd,WACbc,EAAYhB,UACfgB,EAAYX,OACTW,EAAYV,UACbU,EAAYT,SACbS,EAAY5B,QACV1E,GAA8BsG,EAAa,CAAC,WAAY,KAAM,eAAgB,gBAAiB,SAAU,QAAS,OAAQ,UAAW,iBAAkB,UAAW,aAAc,YAAa,SAAU,YAAa,WAAY,aAEjP,OAGEtO,EAAAA,cAAoBwO,GAAuB9c,SAAU,CACnDv0C,MAAO,MACc,oBAAbsQ,EAA0BA,EAASiyC,EAAQ6O,GAAcvO,EAAAA,aAAmBA,EAAAA,SAAejP,KAAKtjC,GAAW8gD,GAEzH,EAEOhD,CACT,CAlT8B,CAkT5BvL,EAAAA,WA+LF,SAASyO,KAAQ,CA7LjBlD,GAAWhtB,YAAciwB,GACzBjD,GAAWmD,UA0LP,CAAC,EAILnD,GAAW5tB,aAAe,CACxBouB,IAAI,EACJE,cAAc,EACdD,eAAe,EACfL,QAAQ,EACRE,OAAO,EACPW,MAAM,EACNe,QAASkB,GACTjB,WAAYiB,GACZnB,UAAWmB,GACXd,OAAQc,GACRb,UAAWa,GACXZ,SAAUY,IAEZlD,GAAWL,UAAYA,GACvBK,GAAWJ,OAASA,GACpBI,GAAWH,SAAWA,GACtBG,GAAWF,QAAUA,GACrBE,GAAWD,QAAUA,GACrB,YEhnBA,KAAoC,qBAAX7kD,SAA0BA,OAAOC,WAAYD,OAAOC,SAASC,eCE/E,IAAIgoD,IAAmB,EACnBC,IAAgB,EAE3B,IACE,IAAI7xD,GAAU,CACZ,WAAI6uB,GACF,OAAO+iC,IAAmB,CAC5B,EAEA,QAAIE,GAEF,OAAOD,GAAgBD,IAAmB,CAC5C,GAIEG,KACFroD,OAAO+N,iBAAiB,OAAQzX,GAASA,IACzC0J,OAAOgO,oBAAoB,OAAQ1X,IAAS,GAEhD,CAAE,MAAOkF,IACP,CAgCF,SArBA,SAA0BxC,EAAMsvD,EAAW3G,EAASrrD,GAClD,GAAIA,GAA8B,mBAAZA,IAA0B6xD,GAAe,CAC7D,IAAIC,EAAO9xD,EAAQ8xD,KACfljC,EAAU5uB,EAAQ4uB,QAClBqjC,EAAiB5G,GAEhBwG,IAAiBC,IACpBG,EAAiB5G,EAAQ6G,QAAU,SAASC,EAAY1pC,GACtD5lB,KAAK6U,oBAAoBs6C,EAAWG,EAAavjC,GACjDy8B,EAAQ9rD,KAAKsD,KAAM4lB,EACrB,EAEA4iC,EAAQ6G,OAASD,GAGnBvvD,EAAK+U,iBAAiBu6C,EAAWC,EAAgBL,GAAmB5xD,EAAU4uB,EAChF,CAEAlsB,EAAK+U,iBAAiBu6C,EAAW3G,EAASrrD,EAC5C,ECpCA,SATA,SAA6B0C,EAAMsvD,EAAW3G,EAASrrD,GACrD,IAAI4uB,EAAU5uB,GAA8B,mBAAZA,EAAwBA,EAAQ4uB,QAAU5uB,EAC1E0C,EAAKgV,oBAAoBs6C,EAAW3G,EAASz8B,GAEzCy8B,EAAQ6G,QACVxvD,EAAKgV,oBAAoBs6C,EAAW3G,EAAQ6G,OAAQtjC,EAExD,ECLA,SAPA,SAAgBlsB,EAAMsvD,EAAW3G,EAASrrD,GAExC,OADAyX,GAAiB/U,EAAMsvD,EAAW3G,EAASrrD,GACpC,WACL0X,GAAoBhV,EAAMsvD,EAAW3G,EAASrrD,EAChD,CACF,ECEA,SAASoyD,GAAqB/pD,EAASgqD,EAAUhN,QAC/B,IAAZA,IACFA,EAAU,GAGZ,IAAIiN,GAAS,EACTjJ,EAASz4B,YAAW,WACjB0hC,GCTM,SAAsB5vD,EAAMsvD,EAAWnxC,EAASC,GAS7D,QARgB,IAAZD,IACFA,GAAU,QAGO,IAAfC,IACFA,GAAa,GAGXpe,EAAM,CACR,IAAI+lB,EAAQ9e,SAAS4oD,YAAY,cACjC9pC,EAAM+pC,UAAUR,EAAWnxC,EAASC,GACpCpe,EAAKub,cAAcwK,EACrB,CACF,CDLiBgqC,CAAapqD,EAAS,iBAAiB,EACtD,GAAGgqD,EAAWhN,GACVqN,EAASlV,GAAOn1C,EAAS,iBAAiB,WAC5CiqD,GAAS,CACX,GAAG,CACDR,MAAM,IAER,OAAO,WACLhhC,aAAau4B,GACbqJ,GACF,CACF,CAEe,SAASC,GAActqD,EAASgjD,EAASgH,EAAUhN,GAChD,MAAZgN,IAAkBA,EA3BxB,SAAuB3vD,GACrB,IAAIb,EAAM6rD,GAAIhrD,EAAM,uBAAyB,GACzCkwD,GAA8B,IAAvB/wD,EAAIiT,QAAQ,MAAe,IAAO,EAC7C,OAAO+9C,WAAWhxD,GAAO+wD,CAC3B,CAuBmCE,CAAczqD,IAAY,GAC3D,IAAI0qD,EAAgBX,GAAqB/pD,EAASgqD,EAAUhN,GACxDqN,EAASlV,GAAOn1C,EAAS,gBAAiBgjD,GAC9C,OAAO,WACL0H,IACAL,GACF,CACF,CEpCA,SAASI,GAAcpwD,EAAM+B,GAC3B,MAAM5C,EAAM6rD,GAAIhrD,EAAM+B,IAAa,GAC7BmuD,GAA8B,IAAvB/wD,EAAIiT,QAAQ,MAAe,IAAO,EAC/C,OAAO+9C,WAAWhxD,GAAO+wD,CAC3B,CACe,SAASI,GAAsB3qD,EAASgjD,GACrD,MAAMgH,EAAWS,GAAczqD,EAAS,sBAClCyuC,EAAQgc,GAAczqD,EAAS,mBAC/BqqD,EAASC,GAActqD,GAASnD,IAChCA,EAAEnF,SAAWsI,IACfqqD,IACArH,EAAQnmD,GACV,GACCmtD,EAAWvb,EAChB,CCOA,SAdA,WAAyC,QAAAtxC,EAAAzE,UAAAE,OAAPgyD,EAAK,IAAA3zD,MAAAkG,GAAAE,EAAA,EAAAA,EAAAF,EAAAE,IAALutD,EAAKvtD,GAAA3E,UAAA2E,GACrC,OAAOutD,EAAM/R,QAAO/7C,GAAU,MAALA,IAAWuzC,QAAO,CAACwa,EAAK/tD,KAC/C,GAAiB,oBAANA,EACT,MAAM,IAAI9B,MAAM,2EAElB,OAAY,OAAR6vD,EAAqB/tD,EAClB,WAAkC,QAAAU,EAAA9E,UAAAE,OAANoE,EAAI,IAAA/F,MAAAuG,GAAAC,EAAA,EAAAA,EAAAD,EAAAC,IAAJT,EAAIS,GAAA/E,UAAA+E,GAErCotD,EAAIhtD,MAAMrD,KAAMwC,GAEhBF,EAAEe,MAAMrD,KAAMwC,EAChB,CAAC,GACA,KACL,ECpBe,SAAS8tD,GAAqBzwD,GAE3CA,EAAK0wD,YACP,CCJA,MAAMC,GAAUt9B,GAAQA,GAAsB,oBAARA,EAA2B31B,IAC/D21B,EAAIjd,QAAU1Y,CAAK,EADsC21B,EA+B3D,SAHA,SAAuBu9B,EAAMC,GAC3B,OAAOxzB,EAAAA,EAAAA,UAAQ,IA1BV,SAAmBuzB,EAAMC,GAC9B,MAAMxuD,EAAIsuD,GAAQC,GACZtuD,EAAIquD,GAAQE,GAClB,OAAOnzD,IACD2E,GAAGA,EAAE3E,GACL4E,GAAGA,EAAE5E,EAAM,CAEnB,CAmBuBozD,CAAUF,EAAMC,IAAO,CAACD,EAAMC,GACrD,ECvBA,MAAME,GAAiCxQ,EAAAA,YAAiB,CAAA9G,EAWrDpmB,KAAQ,IAX8C,QACvDy6B,EAAO,WACPC,EAAU,UACVF,EAAS,OACTK,EAAM,UACNC,EAAS,SACTC,EAAQ,eACRM,EAAc,SACd1gD,EAAQ,SACRgjD,KACGjtD,GACJ01C,EACC,MAAMwT,GAAU1vB,EAAAA,EAAAA,QAAO,MACjB0zB,EAAYC,GAAcjE,EAAS+D,GACnCG,EAAY98B,ICrBL,IAAyB+8B,EDsBpCH,GCtBoCG,EDsBV/8B,ICrBF,aAAc+8B,EAC/BtK,EAAAA,YAAqBsK,GAED,MAAtBA,EAA6BA,EAAqB,KDkB1B,EAEzBC,EAAYt6B,GAAY3jB,IACxB2jB,GAAYk2B,EAAQ72C,SACtB2gB,EAASk2B,EAAQ72C,QAAShD,EAC5B,EAIIk+C,GAAcv0B,EAAAA,EAAAA,aAAYs0B,EAAUvD,GAAU,CAACA,IAC/CyD,GAAiBx0B,EAAAA,EAAAA,aAAYs0B,EAAUtD,GAAa,CAACA,IACrDyD,GAAgBz0B,EAAAA,EAAAA,aAAYs0B,EAAUxD,GAAY,CAACA,IACnD4D,GAAa10B,EAAAA,EAAAA,aAAYs0B,EAAUnD,GAAS,CAACA,IAC7CwD,GAAgB30B,EAAAA,EAAAA,aAAYs0B,EAAUlD,GAAY,CAACA,IACnDwD,GAAe50B,EAAAA,EAAAA,aAAYs0B,EAAUjD,GAAW,CAACA,IACjDwD,GAAuB70B,EAAAA,EAAAA,aAAYs0B,EAAU3C,GAAiB,CAACA,IAGrE,OAAoBpE,EAAAA,GAAAA,KAAKwB,GAAY,CACnCz4B,IAAKA,KACFtvB,EACH+pD,QAASwD,EACTzD,UAAW2D,EACXzD,WAAYwD,EACZrD,OAAQuD,EACRrD,SAAUuD,EACVxD,UAAWuD,EACXhD,eAAgBkD,EAChB3E,QAASA,EACTj/C,SAA8B,oBAAbA,EAA0B,CAACiyC,EAAQ4R,IAEpD7jD,EAASiyC,EAAQ,IACZ4R,EACHx+B,IAAK89B,IACW5Q,EAAAA,aAAmBvyC,EAAU,CAC7CqlB,IAAK89B,KAEP,IAEJ,MErDMW,GAAU,CACdjvC,OAAQ,CAAC,YAAa,gBACtBD,MAAO,CAAC,aAAc,gBAExB,SAASmvC,GAAyBC,EAAWC,GAC3C,MACMv0D,EAAQu0D,EADC,SAASD,EAAU,GAAG3pD,gBAAgB2pD,EAAU7wD,MAAM,MAE/D+wD,EAAUJ,GAAQE,GACxB,OAAOt0D,EAEPy0D,SAASnH,GAAIiH,EAAMC,EAAQ,IAAK,IAEhCC,SAASnH,GAAIiH,EAAMC,EAAQ,IAAK,GAClC,CACA,MAAME,GAAiB,CACrB,CAAC1G,IAAS,WACV,CAACG,IAAU,aACX,CAACF,IAAW,aACZ,CAACC,IAAU,iBAmEb,GAjE8BrL,EAAAA,YAAiB,CAAA9G,EAgB5CpmB,KAAQ,IAhBqC,QAC9Cy6B,EAAO,WACPC,EAAU,UACVF,EAAS,OACTK,EAAM,UACNC,EAAS,UACT/D,EAAS,SACTp8C,EAAQ,UACRgkD,EAAY,SACZ1F,GAAI+F,GAAS,EAAK,QAClBvb,EAAU,IAAG,aACb0V,GAAe,EAAK,cACpBD,GAAgB,EAAK,OACrBL,GAAS,EAAK,kBACdoG,EAAoBP,MACjBhuD,GACJ01C,EAEC,MAAM8Y,EAAyC,oBAAdP,EAA2BA,IAAcA,EAGpEV,GAAcj0B,EAAAA,EAAAA,UAAQ,IAAMm1B,IAAsBP,IACtDA,EAAK5yD,MAAMkzD,GAAqB,GAAG,GAClCzE,IAAU,CAACyE,EAAmBzE,IAC3ByD,GAAiBl0B,EAAAA,EAAAA,UAAQ,IAAMm1B,IAAsBP,IACzD,MAAMQ,EAAS,SAASF,EAAkB,GAAGlqD,gBAAgBkqD,EAAkBpxD,MAAM,KACrF8wD,EAAK5yD,MAAMkzD,GAAqB,GAAGN,EAAKQ,MAAW,GAClD1E,IAAa,CAACwE,EAAmBxE,IAC9ByD,GAAgBn0B,EAAAA,EAAAA,UAAQ,IAAMm1B,IAAsBP,IACxDA,EAAK5yD,MAAMkzD,GAAqB,IAAI,GACnC1E,IAAY,CAAC0E,EAAmB1E,IAG7B4D,GAAap0B,EAAAA,EAAAA,UAAQ,IAAMm1B,IAAsBP,IACrDA,EAAK5yD,MAAMkzD,GAAqB,GAAGD,EAAkBC,EAAmBN,OACxExB,GAAqBwB,EAAK,GACzB/D,IAAS,CAACA,EAAQoE,EAAmBC,IAClCb,GAAgBr0B,EAAAA,EAAAA,UAAQ,IAAMm1B,IAAsBP,IACxDA,EAAK5yD,MAAMkzD,GAAqB,IAAI,GACnCpE,IAAY,CAACoE,EAAmBpE,IACnC,OAAoB7D,EAAAA,GAAAA,KAAKyG,GAAmB,CAC1C19B,IAAKA,EACLq7B,eAAgB4B,MACbvsD,EACH,gBAAiBA,EAAM2uD,KAAOL,EAAS,KACvCvE,QAASwD,EACTvD,WAAYwD,EACZ1D,UAAW2D,EACXtD,OAAQuD,EACRtD,UAAWuD,EACXV,SAAUhjD,EAASqlB,IACnBi5B,GAAI+F,EACJvb,QAASA,EACT0V,aAAcA,EACdD,cAAeA,EACfL,OAAQA,EACRl+C,SAAUA,CAAC+wB,EAAO8yB,IAA4BtR,EAAAA,aAAmBvyC,EAAU,IACtE6jD,EACHzH,UAAW1V,KAAW0V,EAAWp8C,EAASjK,MAAMqmD,UAAWgI,GAAerzB,GAA8B,UAAtBwzB,GAAiC,0BAErH,ICnFE78B,GAAuB6qB,EAAAA,cAAoB,MACjD7qB,GAAQxqB,YAAc,gBACtB,YCAMynD,GAA8BpS,EAAAA,YAAiB,CAAA9G,EAIlDpmB,KAAQ,IAJ2C,SACpDrlB,EAAQ,SACRm8C,KACGpmD,GACJ01C,EACC0Q,EAAWJ,GAAmBI,EAAU,mBACxC,MAAMz0B,GAAUsH,EAAAA,EAAAA,YAAW41B,IAC3B,OAAoBtI,EAAAA,GAAAA,KAAKuI,GAAU,CACjCvG,MAAO52B,IAAWA,EAAQo9B,aACvB/uD,EACHiK,UAAuBs8C,EAAAA,GAAAA,KAAK,MAAO,CACjCj3B,IAAKA,EACL+2B,UAAWD,EACXn8C,SAAUA,KAEZ,IAEJ2kD,GAAeznD,YAAc,iBAC7B,YCRA,SAPA,SAAyBxN,GACvB,MAAM21B,GAAMkK,EAAAA,EAAAA,QAAO7/B,GAInB,OAHAu/B,EAAAA,EAAAA,YAAU,KACR5J,EAAIjd,QAAU1Y,CAAK,GAClB,CAACA,IACG21B,CACT,ECfe,SAAS0/B,GAAiB1b,GACvC,MAAMhkB,EAAM2/B,GAAgB3b,GAC5B,OAAOta,EAAAA,EAAAA,cAAY,WACjB,OAAO1J,EAAIjd,SAAWid,EAAIjd,WAAQ/X,UACpC,GAAG,CAACg1B,GACN,CCEA,MAAM4/B,GAA4B1S,EAAAA,YAAiB,CAAA9G,EAShDpmB,KAAQ,IATyC,SAClD82B,EAAQ,UACRC,EAAS,SACTp8C,EAAQ,MACRklD,EAAQ,oBAER7I,GAAI9Y,EAAY,SAAQ,QACxB5M,KACG5gC,GACJ01C,EACC0Q,EAAWJ,GAAmBI,EAAU,kBACxC,MAAM,SACJgJ,EAAQ,SACRL,IACE91B,EAAAA,EAAAA,YAAW41B,KAAkB,CAAC,EAC5BQ,EAAcL,IAAiBvwD,IAC/BmiC,GAASA,EAAQniC,GACjB2wD,GAAUA,GAAU,IAK1B,MAHkB,WAAd5hB,IACFxtC,EAAMrC,KAAO,WAEK4oD,EAAAA,GAAAA,KAAK/Y,EAAW,IAC/BxtC,EACHsvB,IAAKA,EACLsR,QAASyuB,EACT,aAAcF,EACd9I,UAAW1V,KAAW0V,EAAWD,GAAW2I,GAAY,aACxD9kD,SAAUA,IAAyBs8C,EAAAA,GAAAA,KAAK,OAAQ,CAC9CF,UAAW,GAAGD,YAEhB,IAEJ8I,GAAa/nD,YAAc,eAC3B,YC1CMmoD,GAAkC,qBAAXC,EAAAA,GAE7BA,EAAAA,EAAOlgB,WAEsB,gBAA7BkgB,EAAAA,EAAOlgB,UAAUmgB,QAWjB,GAVkC,qBAAbtsD,UAUGosD,GAAgBj2B,EAAAA,gBAAkBH,EAAAA,UCdpDu2B,GAAmB,IAAIvzB,QACvBwzB,GAAaA,CAACC,EAAOC,KACzB,IAAKD,IAAUC,EAAc,OAC7B,MAAMC,EAAWJ,GAAiBtnD,IAAIynD,IAAiB,IAAIx5C,IAC3Dq5C,GAAiB5oD,IAAI+oD,EAAcC,GACnC,IAAIC,EAAMD,EAAS1nD,IAAIwnD,GAMvB,OALKG,IACHA,EAAMF,EAAaG,WAAWJ,GAC9BG,EAAIE,SAAW,EACfH,EAAShpD,IAAIipD,EAAIG,MAAOH,IAEnBA,CAAG,EAqBG,SAASI,GAAcP,GAA0E,IAAnEC,EAAYt1D,UAAAE,OAAA,QAAAmE,IAAArE,UAAA,GAAAA,UAAA,GAAqB,qBAAX2I,YAAyBtE,EAAYsE,OACtG,MAAM6sD,EAAMJ,GAAWC,EAAOC,IACvBnX,EAAS0X,IAAc12B,EAAAA,EAAAA,WAAS,MAAMq2B,GAAMA,EAAIrX,UAsBvD,OArBAvf,IAAU,KACR,IAAI42B,EAAMJ,GAAWC,EAAOC,GAC5B,IAAKE,EACH,OAAOK,GAAW,GAEpB,IAAIN,EAAWJ,GAAiBtnD,IAAIynD,GACpC,MAAMQ,EAAeA,KACnBD,EAAWL,EAAIrX,QAAQ,EAKzB,OAHAqX,EAAIE,WACJF,EAAIO,YAAYD,GAChBA,IACO,KACLN,EAAIQ,eAAeF,GACnBN,EAAIE,WACAF,EAAIE,UAAY,IACN,MAAZH,GAA4BA,EAASp5C,OAAOq5C,EAAIG,QAElDH,OAAMnxD,CAAS,CAChB,GACA,CAACgxD,IACGlX,CACT,CCgDA,MAQA,GA3FO,SAA8B8X,GACnC,MAAMC,EAAQr4D,OAAOmW,KAAKiiD,GAC1B,SAASE,EAAId,EAAOn/B,GAClB,OAAIm/B,IAAUn/B,EACLA,EAEFm/B,EAAQ,GAAGA,SAAan/B,IAASA,CAC1C,CAIA,SAASkgC,EAAYC,GACnB,MAAMngC,EAJR,SAAiBmgC,GACf,OAAOH,EAAMv8C,KAAKyQ,IAAI8rC,EAAMniD,QAAQsiD,GAAc,EAAGH,EAAMh2D,OAAS,GACtE,CAEeo2D,CAAQD,GACrB,IAAIh3D,EAAQ42D,EAAiB//B,GAE7B,OAD+B72B,EAAV,kBAAVA,EAA+BA,EAAQ,GAAX,KAAgC,QAAQA,aACxE,eAAeA,IACxB,CAiEA,OAvBA,SAAuBk3D,EAAiBC,EAAW7tD,GACjD,IAAI8tD,EAoBJ,MAnB+B,kBAApBF,GACTE,EAAgBF,EAChB5tD,EAAS6tD,EACTA,GAAY,IAEZA,EAAYA,IAAa,EACzBC,EAAgB,CACd,CAACF,GAAkBC,IAYhBZ,IATK52B,EAAAA,EAAAA,UAAQ,IAAMnhC,OAAO64D,QAAQD,GAAe9e,QAAO,CAAC0d,EAAKja,KAAuB,IAApBz8C,EAAK63D,GAAUpb,EAOrF,MANkB,OAAdob,IAAoC,IAAdA,IACxBnB,EAAQc,EAAId,EAvDlB,SAAqBgB,GACnB,IAAIh3D,EAAQ42D,EAAiBI,GAI7B,MAHqB,kBAAVh3D,IACTA,EAAQ,GAAGA,OAEN,eAAeA,IACxB,CAiDyBs3D,CAAYh4D,KAEf,SAAd63D,IAAsC,IAAdA,IAC1BnB,EAAQc,EAAId,EAAOe,EAAYz3D,KAE1B02D,CAAK,GACX,KAAK,CAACpmB,KAAKC,UAAUunB,KACI9tD,EAC9B,CAEF,CACsBiuD,CAAqB,CACzCC,GAAI,EACJC,GAAI,IACJx4C,GAAI,IACJuU,GAAI,IACJkkC,GAAI,KACJC,IAAK,OC1GQ,SAAS3oD,GAAc+9C,QACxB,IAARA,IACFA,EAAMj9C,MAKR,IACE,IAAIghD,EAAS/D,EAAI/9C,cAGjB,OAAK8hD,GAAWA,EAAOziD,SAChByiD,EADiC,IAE1C,CAAE,MAAOhsD,IAEP,OAAOioD,EAAI99C,IACb,CACF,CChBe,SAASgb,GAAS+N,EAAS11B,GAGxC,OAAI01B,EAAQ/N,SAAiB+N,EAAQ/N,SAAS3nB,GAC1C01B,EAAQ9N,wBAAgC8N,IAAY11B,MAAmD,GAAxC01B,EAAQ9N,wBAAwB5nB,SAAnG,CACF,CCJe,SAASs1D,GAAeje,GACrC,MAAMke,ECFO,SAAuB73D,GACpC,MAAM83D,GAAWj4B,EAAAA,EAAAA,QAAO7/B,GAExB,OADA83D,EAASp/C,QAAU1Y,EACZ83D,CACT,CDFoBC,CAAcpe,IAChCpa,EAAAA,EAAAA,YAAU,IAAM,IAAMs4B,EAAUn/C,WAAW,GAC7C,CEVO,SAASs/C,GAAS3zD,GACvB,MAAO,cAAsBA,GAC/B,CCDO,MAAM4zD,GAAsBD,GAAS,cAgG5C,SA1FA,MACEv4D,WAAAA,GAIQ,IAJI,cACVqQ,EAAa,wBACbooD,GAA0B,EAAI,MAC9BC,GAAQ,GACTx3D,UAAAE,OAAA,QAAAmE,IAAArE,UAAA,GAAAA,UAAA,GAAG,CAAC,EACH8B,KAAKy1D,wBAA0BA,EAC/Bz1D,KAAK01D,MAAQA,EACb11D,KAAK21D,OAAS,GACd31D,KAAKqN,cAAgBA,CACvB,CACAuoD,iBAAAA,GACE,OClBW,WAAyD,IAA1BvoD,EAAanP,UAAAE,OAAA,QAAAmE,IAAArE,UAAA,GAAAA,UAAA,GAAG4I,SAC5D,MAAMD,EAASwG,EAAckb,YAC7B,OAAO1Q,KAAKg+C,IAAIhvD,EAAOivD,WAAazoD,EAAc8a,gBAAgB4tC,YACpE,CDeWC,CAAsBh2D,KAAKqN,cACpC,CACA4oD,UAAAA,GACE,OAAQj2D,KAAKqN,eAAiBvG,UAAU0F,IAC1C,CACA0pD,kBAAAA,CAAmBC,GACjB,CAEFC,qBAAAA,CAAsBD,GACpB,CAEFE,iBAAAA,CAAkBC,GAChB,MAAMp3D,EAAQ,CACZkzB,SAAU,UAKNmkC,EAAcv2D,KAAK01D,MAAQ,cAAgB,eAC3Cc,EAAYx2D,KAAKi2D,aACvBK,EAAep3D,MAAQ,CACrBkzB,SAAUokC,EAAUt3D,MAAMkzB,SAC1B,CAACmkC,GAAcC,EAAUt3D,MAAMq3D,IAE7BD,EAAeG,iBAGjBv3D,EAAMq3D,GAAe,GAAGvE,SAASnH,GAAI2L,EAAWD,IAAgB,IAAK,IAAMD,EAAeG,oBAE5FD,EAAU9tD,aAAa8sD,GAAqB,IAC5C3K,GAAI2L,EAAWt3D,EACjB,CACAw3D,KAAAA,GACE,IAAI12D,KAAK21D,QAAQzyD,SAAQpC,GAAKd,KAAK6vD,OAAO/uD,IAC5C,CACA61D,oBAAAA,CAAqBL,GACnB,MAAME,EAAYx2D,KAAKi2D,aACvBO,EAAU/tD,gBAAgB+sD,IAC1Bz5D,OAAOoO,OAAOqsD,EAAUt3D,MAAOo3D,EAAep3D,MAChD,CACAyH,GAAAA,CAAIiwD,GACF,IAAIC,EAAW72D,KAAK21D,OAAO1jD,QAAQ2kD,GACnC,OAAkB,IAAdC,EACKA,GAETA,EAAW72D,KAAK21D,OAAOv3D,OACvB4B,KAAK21D,OAAO/0D,KAAKg2D,GACjB52D,KAAKk2D,mBAAmBU,GACP,IAAbC,IAGJ72D,KAAK4+B,MAAQ,CACX63B,eAAgBz2D,KAAK41D,oBACrB12D,MAAO,CAAC,GAENc,KAAKy1D,yBACPz1D,KAAKq2D,kBAAkBr2D,KAAK4+B,QAPrBi4B,EAUX,CACAhH,MAAAA,CAAO+G,GACL,MAAMC,EAAW72D,KAAK21D,OAAO1jD,QAAQ2kD,IACnB,IAAdC,IAGJ72D,KAAK21D,OAAO1oB,OAAO4pB,EAAU,IAIxB72D,KAAK21D,OAAOv3D,QAAU4B,KAAKy1D,yBAC9Bz1D,KAAK22D,qBAAqB32D,KAAK4+B,OAEjC5+B,KAAKo2D,sBAAsBQ,GAC7B,CACAE,UAAAA,CAAWF,GACT,QAAS52D,KAAK21D,OAAOv3D,QAAU4B,KAAK21D,OAAO31D,KAAK21D,OAAOv3D,OAAS,KAAOw4D,CACzE,GE/FIG,IAAuBplB,EAAAA,EAAAA,eAAcud,GAAYroD,YAAStE,GAClCw0D,GAAQjlB,SAQvB,SAASklB,KACtB,OAAOn6B,EAAAA,EAAAA,YAAWk6B,GACpB,CCTO,MAAME,GAAsBA,CAAC/jC,EAAKpsB,IAClCooD,GACM,MAAPh8B,GAAqBpsB,GAAYuG,MAAiBb,MACnC,oBAAR0mB,IAAoBA,EAAMA,KACjCA,GAAO,YAAaA,IAAKA,EAAMA,EAAIjd,SACnCid,IAAQ,aAAcA,GAAOA,EAAIgkC,uBAA+BhkC,EAC7D,MALgB,KC0BzB,SA5BA,SAAuBomB,GAMpB,IANqB,SACtBzrC,EACAs+C,GAAI+F,EAAM,SACVjE,EAAQ,aACR5B,EAAY,cACZD,GACD9S,EACC,MAAMpmB,GAAMkK,EAAAA,EAAAA,QAAO,MACb+5B,GAAgB/5B,EAAAA,EAAAA,QAAO80B,GACvBV,EAAeoB,GAAiB3E,IACtCnxB,EAAAA,EAAAA,YAAU,KACJo1B,EAAQiF,EAAclhD,SAAU,EAClCu7C,EAAat+B,EAAIjd,QACnB,GACC,CAACi8C,EAAQV,IACZ,MAAM4F,EAAcrG,GAAc79B,EAAKrlB,EAASqlB,KAC1Cnd,GAAqB27B,EAAAA,EAAAA,cAAa7jC,EAAU,CAChDqlB,IAAKkkC,IAEP,OAAIlF,EAAen8C,EACfq2C,IAGC+K,EAAclhD,SAAWo2C,EAFrB,KAKFt2C,CACT,EC1BO,SAASshD,KACd,MAAMC,EAAQlX,EAAAA,QAAct4C,MAAM,KAClC,MAAO,CACLyvD,OAAQD,EAAM,GACdE,OAAQF,EAAM,GACdG,OAAQH,EAAM,GAElB,CCXA,MAAMI,GAAY,CAAC,UAAW,aAAc,YAAa,SAAU,YAAa,WAAY,iBAAkB,YCA9G,MAAMA,GAAY,CAAC,aAMnB,MAAMC,GAA6BvX,EAAAA,YAAiB,CAAC9G,EAAMpmB,KACzD,IACI+vB,UAAW7R,GACTkI,EAEN,MAAMse,EDCO,SAA+Bte,GAC5C,IAAI,QACAqU,EAAO,WACPC,EAAU,UACVF,EAAS,OACTK,EAAM,UACNC,EAAS,SACTC,EAAQ,eACRM,EAAc,SACd1gD,GACEyrC,EACJ11C,EAtBJ,SAAuCswB,EAAG7xB,GAAK,GAAI,MAAQ6xB,EAAG,MAAO,CAAC,EAAG,IAAIhI,EAAI,CAAC,EAAG,IAAK,IAAID,KAAKiI,EAAG,GAAI,CAAC,EAAEj4B,eAAeS,KAAKw3B,EAAGjI,GAAI,CAAE,GAAI5pB,EAAE4P,QAAQga,IAAM,EAAG,SAAUC,EAAED,GAAKiI,EAAEjI,EAAI,CAAE,OAAOC,CAAG,CAsBxLk8B,CAA8B9O,EAAMoe,IAC9C,MAAM,MACJH,GACEF,KACExG,EAAW0G,GAAS,GAAK1pD,EAASjK,MAAMsvB,IAAMrlB,EAASqlB,IACvD45B,GAAU1vB,EAAAA,EAAAA,QAAO,MACjB0zB,EAAYC,GAAcjE,EAA6B,oBAAbj/C,EAA0B,KAAOgjD,GAC3EK,EAAYt6B,GAAY3jB,IACxB2jB,GAAYk2B,EAAQ72C,SACtB2gB,EAASk2B,EAAQ72C,QAAShD,EAC5B,EAIIk+C,GAAcv0B,EAAAA,EAAAA,aAAYs0B,EAAUvD,GAAU,CAACA,IAC/CyD,GAAiBx0B,EAAAA,EAAAA,aAAYs0B,EAAUtD,GAAa,CAACA,IACrDyD,GAAgBz0B,EAAAA,EAAAA,aAAYs0B,EAAUxD,GAAY,CAACA,IACnD4D,GAAa10B,EAAAA,EAAAA,aAAYs0B,EAAUnD,GAAS,CAACA,IAC7CwD,GAAgB30B,EAAAA,EAAAA,aAAYs0B,EAAUlD,GAAY,CAACA,IACnDwD,GAAe50B,EAAAA,EAAAA,aAAYs0B,EAAUjD,GAAW,CAACA,IACjDwD,GAAuB70B,EAAAA,EAAAA,aAAYs0B,EAAU3C,GAAiB,CAACA,IAGrE,OAAOxyD,OAAOoO,OAAO,CAAC,EAAGvG,EAAO,CAC9BkpD,WACCa,GAAW,CACZA,QAASwD,GACRvD,GAAc,CACfA,WAAYwD,GACX1D,GAAa,CACdA,UAAW2D,GACVtD,GAAU,CACXA,OAAQuD,GACPtD,GAAa,CACdA,UAAWuD,GACVtD,GAAY,CACbA,SAAUuD,GACTjD,GAAkB,CACnBA,eAAgBkD,GACf,CACD5jD,SAA8B,oBAAbA,EAA0B,CAACiyC,EAAQ4R,IAEpD7jD,EAASiyC,EAAQ/jD,OAAOoO,OAAO,CAAC,EAAGunD,EAAY,CAC7Cx+B,IAAK49B,MACYpf,EAAAA,EAAAA,cAAa7jC,EAAU,CACxCqlB,IAAK49B,KAGX,CC5D0B+G,CAV1B,SAAuC3jC,EAAG7xB,GAAK,GAAI,MAAQ6xB,EAAG,MAAO,CAAC,EAAG,IAAIhI,EAAI,CAAC,EAAG,IAAK,IAAID,KAAKiI,EAAG,GAAI,CAAC,EAAEj4B,eAAeS,KAAKw3B,EAAGjI,GAAI,CAAE,GAAI5pB,EAAE4P,QAAQga,IAAM,EAAG,SAAUC,EAAED,GAAKiI,EAAEjI,EAAI,CAAE,OAAOC,CAAG,CASxLk8B,CAA8B9O,EAAMoe,KAE9C,OAAoBvN,EAAAA,GAAAA,KAAK/Y,EAAWr1C,OAAOoO,OAAO,CAChD+oB,IAAKA,GACJ0kC,GAAiB,IAEtB,MC4Be,SAASE,GAAoB1K,GAMzC,IAN0C,SAC3Cv/C,EACAs+C,GAAI+F,EAAM,SACVjE,EAAQ,UACRP,EAAS,WACT5xC,GACDsxC,EACC,MAAO2K,EAAQC,IAAa36B,EAAAA,EAAAA,WAAU60B,GAGlCA,GAAU6F,GACZC,GAAU,GAEZ,MAAM9kC,EAlDD,SAAsBomB,GAG1B,IAFD6S,GAAI+F,EAAM,aACV+F,GACD3e,EACC,MAAMpmB,GAAMkK,EAAAA,EAAAA,QAAO,MACb86B,GAAe96B,EAAAA,EAAAA,SAAO,GACtB+6B,EAAmBvF,GAAiBqF,GAuB1C,OAtBAG,IAAoB,KAClB,IAAKllC,EAAIjd,QACP,OAEF,IAAIoiD,GAAQ,EAOZ,OANAF,EAAiB,CACfhM,GAAI+F,EACJ1sD,QAAS0tB,EAAIjd,QACbqiD,QAASJ,EAAajiD,QACtBsiD,QAASA,IAAMF,IAEV,KACLA,GAAQ,CAAI,CACb,GACA,CAACnG,EAAQiG,IACZC,IAAoB,KAClBF,EAAajiD,SAAU,EAEhB,KACLiiD,EAAajiD,SAAU,CAAI,IAE5B,IACIid,CACT,CAoBcsK,CAAc,CACxB2uB,KAAM+F,EACN+F,aAAc96D,IAUZgxB,QAAQG,QAAQxS,EAAW3e,IAAUoxB,MATpBiqC,KACXr7D,EAAQo7D,YACRp7D,EAAQgvD,GACG,MAAbuB,GAA6BA,EAAUvwD,EAAQqI,QAASrI,EAAQm7D,UAEhEN,GAAU,GACE,MAAZ/J,GAA4BA,EAAS9wD,EAAQqI,UAC/C,IAEkDnF,IAElD,MADKlD,EAAQgvD,IAAI6L,GAAU,GACrB33D,CAAK,GACX,IAGA+2D,EAAcrG,GAAc79B,EAAKrlB,EAASqlB,KAChD,OAAO6kC,IAAW7F,EAAS,MAAoBxgB,EAAAA,EAAAA,cAAa7jC,EAAU,CACpEqlB,IAAKkkC,GAET,CACO,SAASqB,GAAiBxV,EAAWyV,EAAe90D,GACzD,OAAIq/C,GACkBkH,EAAAA,GAAAA,KAAKwN,GAAe57D,OAAOoO,OAAO,CAAC,EAAGvG,EAAO,CAC/Dq/C,UAAWA,KAGXyV,GACkBvO,EAAAA,GAAAA,KAAK2N,GAAsB/7D,OAAOoO,OAAO,CAAC,EAAGvG,EAAO,CACtEkY,WAAY48C,MAGIvO,EAAAA,GAAAA,KAAKwO,GAAgB58D,OAAOoO,OAAO,CAAC,EAAGvG,GAC7D,CC5FA,MAAM8zD,GAAY,CAAC,OAAQ,OAAQ,YAAa,QAAS,WAAY,WAAY,WAAY,kBAAmB,kBAAmB,aAAc,gBAAiB,qBAAsB,wBAAyB,YAAa,eAAgB,eAAgB,sBAAuB,eAAgB,iBAAkB,UAAW,YAAa,SAAU,SAAU,SAAU,WAAY,YAAa,UAAW,aAAc,aAqB/Z,IAAIkB,GAaJ,SAASC,GAAgBC,GACvB,MAAMjyD,EAASmwD,KACT+B,EAAeD,GARvB,SAAoBjyD,GAIlB,OAHK+xD,KAASA,GAAU,IAAII,GAAa,CACvC3rD,cAAyB,MAAVxG,OAAiB,EAASA,EAAOC,YAE3C8xD,EACT,CAGmCK,CAAWpyD,GACtC+vD,GAAQx5B,EAAAA,EAAAA,QAAO,CACnB87B,OAAQ,KACRC,SAAU,OAEZ,OAAOp9D,OAAOoO,OAAOysD,EAAM3gD,QAAS,CAClCtP,IAAKA,IAAMoyD,EAAapyD,IAAIiwD,EAAM3gD,SAClC45C,OAAQA,IAAMkJ,EAAalJ,OAAO+G,EAAM3gD,SACxC6gD,WAAYA,IAAMiC,EAAajC,WAAWF,EAAM3gD,SAChDmjD,cAAcx8B,EAAAA,EAAAA,cAAY1J,IACxB0jC,EAAM3gD,QAAQijD,OAAShmC,CAAG,GACzB,IACHmmC,gBAAgBz8B,EAAAA,EAAAA,cAAY1J,IAC1B0jC,EAAM3gD,QAAQkjD,SAAWjmC,CAAG,GAC3B,KAEP,CACA,MAAMomC,IAAqBlnB,EAAAA,EAAAA,aAAW,CAACkH,EAAMpmB,KAC3C,IAAI,KACAqmC,GAAO,EAAK,KACZhH,EAAO,SAAQ,UACftI,EAAS,MACT/qD,EAAK,SACL2O,EAAQ,SACRsrD,GAAW,EAAI,SACfK,GAAW,EAAI,gBACfC,EAAe,gBACfC,EAAe,WACf59C,EAAU,cACV48C,EAAa,mBACbiB,EAAkB,sBAClBC,EAAqB,UACrBh1B,GAAY,EAAI,aAChBi1B,GAAe,EAAI,aACnBC,GAAe,EAAI,oBACnBC,EAAmB,aACnBC,EAAY,eACZC,EAAiBr2D,IAAsBumD,EAAAA,GAAAA,KAAK,MAAOpuD,OAAOoO,OAAO,CAAC,EAAGvG,IACrEg1D,QAASsB,EACT1D,UAAW2D,EAAY,OACvBC,EAAM,OACNC,EAASA,OAAQ,OACjBtM,EAAM,SACNE,EAAQ,UACRD,EAAS,QACTL,EAAO,WACPC,EAAU,UACVF,GACEpU,EACJiE,EApFJ,SAAuCrpB,EAAG7xB,GAAK,GAAI,MAAQ6xB,EAAG,MAAO,CAAC,EAAG,IAAIhI,EAAI,CAAC,EAAG,IAAK,IAAID,KAAKiI,EAAG,GAAI,CAAC,EAAEj4B,eAAeS,KAAKw3B,EAAGjI,GAAI,CAAE,GAAI5pB,EAAE4P,QAAQga,IAAM,EAAG,SAAUC,EAAED,GAAKiI,EAAEjI,EAAI,CAAE,OAAOC,CAAG,CAoFzLk8B,CAA8B9O,EAAMoe,IAC7C,MAAMnN,EAAcyM,KACdR,EN3EO,SAA0BtjC,EAAKonC,GAC5C,MAAMzzD,EAASmwD,MACRuD,EAAaC,IAAUn9B,EAAAA,EAAAA,WAAS,IAAM45B,GAAoB/jC,EAAe,MAAVrsB,OAAiB,EAASA,EAAOC,YACvG,IAAKyzD,EAAa,CAChB,MAAME,EAAWxD,GAAoB/jC,GACjCunC,GAAUD,EAAOC,EACvB,CAYA,OAXA39B,EAAAA,EAAAA,YAAU,KACJw9B,GAAcC,GAChBD,EAAWC,EACb,GACC,CAACD,EAAYC,KAChBz9B,EAAAA,EAAAA,YAAU,KACR,MAAM49B,EAAUzD,GAAoB/jC,GAChCwnC,IAAYH,GACdC,EAAOE,EACT,GACC,CAACxnC,EAAKqnC,IACFA,CACT,CMwDoBI,CAAiBR,GAC7BvD,EAAQiC,GAAgBqB,GACxBh8B,ECnEO,WACb,MAAM08B,GAAUx9B,EAAAA,EAAAA,SAAO,GACjBc,GAAYd,EAAAA,EAAAA,SAAO,IAAMw9B,EAAQ3kD,UAOvC,OANA6mB,EAAAA,EAAAA,YAAU,KACR89B,EAAQ3kD,SAAU,EACX,KACL2kD,EAAQ3kD,SAAU,CAAK,IAExB,IACIioB,EAAUjoB,OACnB,CDyDoB4kD,GACZC,EEvEO,SAAqBv9D,GAClC,MAAM21B,GAAMkK,EAAAA,EAAAA,QAAO,MAInB,OAHAN,EAAAA,EAAAA,YAAU,KACR5J,EAAIjd,QAAU1Y,CAAK,IAEd21B,EAAIjd,OACb,CFiEmB8kD,CAAYxB,IACtBxB,EAAQC,IAAa36B,EAAAA,EAAAA,WAAUk8B,GAChCyB,GAAe59B,EAAAA,EAAAA,QAAO,OAC5BL,EAAAA,EAAAA,qBAAoB7J,GAAK,IAAM0jC,GAAO,CAACA,IACnC1H,KAAc4L,GAAYvB,IAC5ByB,EAAa/kD,QAAU1J,GAA6B,MAAfg+C,OAAsB,EAASA,EAAYzjD,WAI9EyyD,GAAQxB,GACVC,GAAU,GAEZ,MAAMiD,EAAarI,IAAiB,KAalC,GAZAgE,EAAMjwD,MACNu0D,EAAyBjlD,QAAU0kC,GAAO7zC,SAAU,UAAWq0D,GAC/DC,EAAuBnlD,QAAU0kC,GAAO7zC,SAAU,SAGlD,IAAMinB,WAAWstC,KAAqB,GAClCjB,GACFA,IAKEx1B,EAAW,CACb,IAAI02B,EAAuBC,EAC3B,MAAMC,EAAuBjvD,GAAyH,OAA1G+uD,EAA0D,OAAjCC,EAAgB3E,EAAMsC,aAAkB,EAASqC,EAAcluD,eAAyBiuD,EAAuC,MAAf/Q,OAAsB,EAASA,EAAYzjD,UAC5N8vD,EAAMsC,QAAUsC,IAAyBh0C,GAASovC,EAAMsC,OAAQsC,KAClER,EAAa/kD,QAAUulD,EACvB5E,EAAMsC,OAAO3vC,QAEjB,KAEIkyC,EAAa7I,IAAiB,KAKhC,IAAI8I,GAJN9E,EAAM/G,SAC8B,MAApCqL,EAAyBjlD,SAA2BilD,EAAyBjlD,UAC3C,MAAlCmlD,EAAuBnlD,SAA2BmlD,EAAuBnlD,UACrE6jD,KAGgD,OAAjD4B,EAAwBV,EAAa/kD,UAA2D,MAA/BylD,EAAsBnyC,OAAyBmyC,EAAsBnyC,MAAMwwC,GAC7IiB,EAAa/kD,QAAU,KACzB,KAOF6mB,EAAAA,EAAAA,YAAU,KACHy8B,GAAS/C,GACdyE,GAAY,GACX,CAAC1B,EAAM/C,EAAqCyE,KAK/Cn+B,EAAAA,EAAAA,YAAU,KACHi7B,GACL0D,GAAY,GACX,CAAC1D,EAAQ0D,IACZtG,IAAe,KACbsG,GAAY,IAKd,MAAMJ,EAAqBzI,IAAiB,KAC1C,IAAKiH,IAAiB37B,MAAgB04B,EAAME,aAC1C,OAEF,MAAM0E,EAAuBjvD,GAA6B,MAAfg+C,OAAsB,EAASA,EAAYzjD,UAClF8vD,EAAMsC,QAAUsC,IAAyBh0C,GAASovC,EAAMsC,OAAQsC,IAClE5E,EAAMsC,OAAO3vC,OACf,IAEIoyC,EAAsB/I,IAAiBvwD,IACvCA,EAAEnF,SAAWmF,EAAE6a,gBAGA,MAAnBu8C,GAAmCA,EAAgBp3D,IAClC,IAAb82D,GACFkB,IACF,IAEIc,EAAwBvI,IAAiBvwD,IACzCm3D,GJhLD,SAAkBn3D,GACvB,MAAkB,WAAXA,EAAE8f,MAAmC,KAAd9f,EAAEsa,OAClC,CI8KoBi/C,CAASv5D,IAAMu0D,EAAME,eAChB,MAAnB4C,GAAmCA,EAAgBr3D,GAC9CA,EAAE+a,kBACLi9C,IAEJ,IAEIe,GAAyBh+B,EAAAA,EAAAA,UACzB89B,GAA2B99B,EAAAA,EAAAA,UAKjC,IAAKo5B,EACH,OAAO,KAET,MAAMqF,EAAc9/D,OAAOoO,OAAO,CAChCooD,OACAr/B,IAAK0jC,EAAMwC,aAEX,aAAuB,WAAT7G,QAA2BhwD,GACxCg7C,EAAM,CACPr+C,QACA+qD,YACA6R,UAAW,IAEb,IAAI5C,EAASc,EAAeA,EAAa6B,IAA4B1R,EAAAA,GAAAA,KAAK,MAAOpuD,OAAOoO,OAAO,CAAC,EAAG0xD,EAAa,CAC9GhuD,SAAuBuyC,EAAAA,aAAmBvyC,EAAU,CAClD0kD,KAAM,gBAGV2G,EAAST,GAAiB38C,EAAY48C,EAAe,CACnDtM,eAAe,EACfC,cAAc,EACdN,QAAQ,EACRI,KAAMoN,EACNxL,SACAC,YACAC,SA7BmB,WACnB+J,GAAU,GACE,MAAZ/J,GAA4BA,KAAS/vD,UACvC,EA2BEyvD,UACAC,aACAF,YACA7/C,SAAUqrD,IAEZ,IAAI6C,EAAkB,KActB,OAbI5C,IACF4C,EAAkB9B,EAAe,CAC/B/mC,IAAK0jC,EAAMyC,eACX70B,QAASm3B,IAEXI,EAAkBtD,GAAiBkB,EAAoBC,EAAuB,CAC5EzN,KAAMoN,EACNxN,QAAQ,EACRM,cAAc,EACdD,eAAe,EACfv+C,SAAUkuD,MAGM5R,EAAAA,GAAAA,KAAK6R,GAAAA,SAAW,CAClCnuD,SAAuB84C,EAAAA,cAAoCsV,EAAAA,GAAAA,MAAMD,GAAAA,SAAW,CAC1EnuD,SAAU,CAACkuD,EAAiB7C,KAC1B1C,IACJ,IAEJ8C,GAAMvuD,YAAc,QACpB,SAAehP,OAAOoO,OAAOmvD,GAAO,CAClC4C,QAASlD,KG1OLmD,GAAa,CACjB,CAAC3Q,IAAW,OACZ,CAACC,IAAU,QAEP2Q,GAAoBhc,EAAAA,YAAiB,CAAA9G,EAMxCpmB,KAAQ,IANiC,UAC1C+2B,EAAS,SACTp8C,EAAQ,kBACRwuD,EAAoB,CAAC,EAAC,QACtB1O,KACGpQ,GACJjE,EACC,MAAM11C,EAAQ,CACZuoD,IAAI,EACJxV,QAAS,IACT0V,cAAc,EACdD,eAAe,EACfL,QAAQ,KACLxO,GAEC4T,GAAcv0B,EAAAA,EAAAA,cAAY,CAAC/8B,EAAMy8D,KACrChM,GAAqBzwD,GACV,MAAX8tD,GAAmBA,EAAQ9tD,EAAMy8D,EAAY,GAC5C,CAAC3O,KACE,MACJ4J,GACEF,KACExG,EAAW0G,GAAS,GAAK1pD,EAASjK,MAAMsvB,IAAMrlB,EAASqlB,IAC7D,OAAoBi3B,EAAAA,GAAAA,KAAKyG,GAAmB,CAC1C19B,IAAKA,EACLq7B,eAAgB4B,MACbvsD,EACH+pD,QAASwD,EACTN,SAAUA,EACVhjD,SAAUA,CAACiyC,EAAQ4R,IAA4BtR,EAAAA,aAAmBvyC,EAAU,IACvE6jD,EACHzH,UAAW1V,KAAW,OAAQ0V,EAAWp8C,EAASjK,MAAMqmD,UAAWkS,GAAWrc,GAASuc,EAAkBvc,OAE3G,IAEJsc,GAAKrxD,YAAc,OACnB,YC3CMwxD,GAA6Bnc,EAAAA,YAAiB,CAAA9G,EAKjDpmB,KAAQ,IAL0C,UACnD+2B,EAAS,SACTD,EACAE,GAAI9Y,EAAY,SACbxtC,GACJ01C,EAEC,OADA0Q,EAAWJ,GAAmBI,EAAU,mBACpBG,EAAAA,GAAAA,KAAK/Y,EAAW,CAClCle,IAAKA,EACL+2B,UAAW1V,KAAW0V,EAAWD,MAC9BpmD,GACH,IAEJ24D,GAAcxxD,YAAc,gBAC5B,YCXMyxD,GAAmB,CACvB,CAAChR,IAAW,OACZ,CAACC,IAAU,QAEPgR,GAAiCrc,EAAAA,YAAiB,CAAA9G,EASrDpmB,KAAQ,IAT8C,SACvD82B,EAAQ,UACRC,EAAS,SACTp8C,EACAs+C,GAAI+F,GAAS,EAAK,aAClB7F,GAAe,EAAK,cACpBD,GAAgB,EAAK,OACrBL,GAAS,KACNnoD,GACJ01C,EAEC,OADA0Q,EAAWJ,GAAmBI,EAAU,cACpBG,EAAAA,GAAAA,KAAKyG,GAAmB,CAC1C19B,IAAKA,EACLq7B,eAAgB4B,GAChBhE,GAAI+F,EACJ7F,aAAcA,EACdD,cAAeA,EACfL,OAAQA,KACLnoD,EACHitD,SAAUhjD,EAASqlB,IACnBrlB,SAAUA,CAACiyC,EAAQ4R,IAA4BtR,EAAAA,aAAmBvyC,EAAU,IACvE6jD,EACHzH,UAAW1V,KAAW0V,EAAWp8C,EAASjK,MAAMqmD,WAAYnK,IAAW0L,IAAY1L,IAAW4L,KAAY,GAAG1B,aAAqBwS,GAAiB1c,OAErJ,IAEJ2c,GAAkB1xD,YAAc,oBAChC,YCjCA,GAJkCq1C,EAAAA,cAAoB,CAEpDia,MAAAA,GAAU,6BCDZ,MAAMvL,GAAY,CAEhB,aAAc7oD,KAAAA,OAEdu+B,QAASv+B,KAAAA,KAMTy2D,QAASz2D,KAAAA,MAAgB,CAAC,WAEtB02D,GAA2Bvc,EAAAA,YAAiB,CAAA9G,EAK/CpmB,KAAG,IAL6C,UACjD+2B,EAAS,QACTyS,EACA,aAAcE,EAAY,WACvBh5D,GACJ01C,EAAA,OAAuB6Q,EAAAA,GAAAA,KAAK,SAAU,CACrCj3B,IAAKA,EACL3xB,KAAM,SACN0oD,UAAW1V,KAAW,YAAamoB,GAAW,aAAaA,IAAWzS,GACtE,aAAc2S,KACXh5D,GACH,IACF+4D,GAAY5xD,YAAc,cAC1B4xD,GAAY7N,UAAYA,GACxB,YCrBM+N,GAAmCzc,EAAAA,YAAiB,CAAA9G,EAOvDpmB,KAAQ,IAPgD,WACzD4pC,EAAa,QAAO,aACpBC,EAAY,YACZC,GAAc,EAAK,OACnB3C,EAAM,SACNxsD,KACGjK,GACJ01C,EACC,MAAM/jB,GAAUsH,EAAAA,EAAAA,YAAWogC,IACrBhK,EAAcL,IAAiB,KACxB,MAAXr9B,GAAmBA,EAAQ8kC,SACjB,MAAVA,GAAkBA,GAAQ,IAE5B,OAAoB4B,EAAAA,GAAAA,MAAM,MAAO,CAC/B/oC,IAAKA,KACFtvB,EACHiK,SAAU,CAACA,EAAUmvD,IAA4B7S,EAAAA,GAAAA,KAAKwS,GAAa,CACjE,aAAcG,EACdJ,QAASK,EACTv4B,QAASyuB,MAEX,IAEJ,MCzBMiK,GAA+B9c,EAAAA,YAAiB,CAAA9G,EAMnDpmB,KAAQ,IAN4C,SACrD82B,EAAQ,UACRC,EAAS,WACT6S,EAAa,QAAO,YACpBE,GAAc,KACXp5D,GACJ01C,EAEC,OADA0Q,EAAWJ,GAAmBI,EAAU,qBACpBG,EAAAA,GAAAA,KAAK0S,GAAqB,CAC5C3pC,IAAKA,KACFtvB,EACHqmD,UAAW1V,KAAW0V,EAAWD,GACjC8S,WAAYA,EACZE,YAAaA,GACb,IAEJE,GAAgBnyD,YAAc,kBAC9B,YCrBA,GAAgBk/C,GAA0B7J,EAAAA,YAAiB,CAACh6C,EAAG8sB,KAAqBi3B,EAAAA,GAAAA,KAAK,MAAO,IAC3F/jD,EACH8sB,IAAKA,EACL+2B,UAAW1V,KAAWnuC,EAAE6jD,UAAWA,OCC/BkT,GAAgBC,GAAiB,MACjCC,GAA8Bjd,EAAAA,YAAiB,CAAA9G,EAKlDpmB,KAAQ,IAL2C,UACpD+2B,EAAS,SACTD,EACAE,GAAI9Y,EAAY+rB,MACbv5D,GACJ01C,EAEC,OADA0Q,EAAWJ,GAAmBI,EAAU,oBACpBG,EAAAA,GAAAA,KAAK/Y,EAAW,CAClCle,IAAKA,EACL+2B,UAAW1V,KAAW0V,EAAWD,MAC9BpmD,GACH,IAEJy5D,GAAetyD,YAAc,iBAC7B,YCtBA,IAAImmC,GAAU+E,SAASj6C,UAAUqI,KAAK3H,KAAKu5C,SAASj6C,UAAUU,KAAM,GAAGsE,OAQxD,SAASs8D,GAAI93D,EAAS+3D,GACnC,OAAOrsB,GAAQ1rC,EAAQ0nC,iBAAiBqwB,GAC1C,CCVA,SAASC,GAAiBC,EAAWC,GACnC,OAAOD,EAAUx+D,QAAQ,IAAIogD,OAAO,UAAYqe,EAAgB,YAAa,KAAM,MAAMz+D,QAAQ,OAAQ,KAAKA,QAAQ,aAAc,GACtI,CCGA,MAAM0+D,GACW,oDADXA,GAEY,cAFZA,GAGY,kBAElB,MAAMC,WAA8B5E,GAClC6E,cAAAA,CAAep8D,EAAM+D,EAASs4D,GAC5B,MAAMC,EAASv4D,EAAQtG,MAAMuC,GAG7B+D,EAAQy9B,QAAQxhC,GAAQs8D,EACxBlT,GAAIrlD,EAAS,CACX,CAAC/D,GAAO,GAAGuuD,WAAWnF,GAAIrlD,EAAS/D,IAASq8D,OAEhD,CACAE,OAAAA,CAAQv8D,EAAM+D,GACZ,MAAMjI,EAAQiI,EAAQy9B,QAAQxhC,QAChBc,IAAVhF,WACKiI,EAAQy9B,QAAQxhC,GACvBopD,GAAIrlD,EAAS,CACX,CAAC/D,GAAOlE,IAGd,CACA84D,iBAAAA,CAAkBC,GAChBzT,MAAMwT,kBAAkBC,GACxB,MAAME,EAAYx2D,KAAKi2D,aCvBZ,IAAkBzwD,EAASykD,EDyBtC,GCzBsCA,EDwBlB,cCxBSzkD,EDwBpBgxD,GCvBCyH,UAAWz4D,EAAQy4D,UAAUt3D,IAAIsjD,GCHhC,SAAkBzkD,EAASykD,GACxC,OAAIzkD,EAAQy4D,YAAoBhU,GAAazkD,EAAQy4D,UAAUz2C,SAASyiC,IACkC,KAAlG,KAAOzkD,EAAQykD,UAAUiU,SAAW14D,EAAQykD,WAAa,KAAKh4C,QAAQ,IAAMg4C,EAAY,IAClG,CDAoEkU,CAAS34D,EAASykD,KAA6C,kBAAtBzkD,EAAQykD,UAAwBzkD,EAAQykD,UAAYzkD,EAAQykD,UAAY,IAAMA,EAAezkD,EAAQkD,aAAa,SAAUlD,EAAQykD,WAAazkD,EAAQykD,UAAUiU,SAAW,IAAM,IAAMjU,KDwB9RqM,EAAeG,eAAgB,OACpC,MAAMF,EAAcv2D,KAAK01D,MAAQ,cAAgB,eAC3C0I,EAAap+D,KAAK01D,MAAQ,aAAe,cAC/C4H,GAAI9G,EAAWmH,IAAwBz6D,SAAQ4oC,GAAM9rC,KAAK69D,eAAetH,EAAazqB,EAAIwqB,EAAeG,kBACzG6G,GAAI9G,EAAWmH,IAAyBz6D,SAAQ4oC,GAAM9rC,KAAK69D,eAAeO,EAAYtyB,GAAKwqB,EAAeG,kBAC1G6G,GAAI9G,EAAWmH,IAAyBz6D,SAAQ4oC,GAAM9rC,KAAK69D,eAAeO,EAAYtyB,EAAIwqB,EAAeG,iBAC3G,CACAE,oBAAAA,CAAqBL,GACnBzT,MAAM8T,qBAAqBL,GAC3B,MAAME,EAAYx2D,KAAKi2D,aD/BZ,IAAqBzwD,EAASykD,ICgClB,cDhCSzkD,ECgCpBgxD,GD/BFyH,UACVz4D,EAAQy4D,UAAUpO,OAAO5F,GACa,kBAAtBzkD,EAAQykD,UACxBzkD,EAAQykD,UAAYuT,GAAiBh4D,EAAQykD,UAAWA,GAExDzkD,EAAQkD,aAAa,QAAS80D,GAAiBh4D,EAAQykD,WAAazkD,EAAQykD,UAAUiU,SAAW,GAAIjU,IC2BrG,MAAMsM,EAAcv2D,KAAK01D,MAAQ,cAAgB,eAC3C0I,EAAap+D,KAAK01D,MAAQ,aAAe,cAC/C4H,GAAI9G,EAAWmH,IAAwBz6D,SAAQ4oC,GAAM9rC,KAAKg+D,QAAQzH,EAAazqB,KAC/EwxB,GAAI9G,EAAWmH,IAAyBz6D,SAAQ4oC,GAAM9rC,KAAKg+D,QAAQI,EAAYtyB,KAC/EwxB,GAAI9G,EAAWmH,IAAyBz6D,SAAQ4oC,GAAM9rC,KAAKg+D,QAAQI,EAAYtyB,IACjF,EAEF,IAAIuyB,GAKJ,YGrCA,SAASC,GAAiB16D,GACxB,OAAoBumD,EAAAA,GAAAA,KAAKsS,GAAmB,IACvC74D,GAEP,CACA,SAAS26D,GAAmB36D,GAC1B,OAAoBumD,EAAAA,GAAAA,KAAKiS,GAAM,IAC1Bx4D,GAEP,CACA,MAAM46D,GAAyBpe,EAAAA,YAAiB,CAAA9G,EA+B7CpmB,KAAQ,IA/BsC,SAC/C82B,EAAQ,UACRC,EAAS,SACTp8C,EACA,kBAAmB4wD,EAAc,UACjCC,EAAY,QAAO,WACnBC,EAAU,KAGVpF,GAAO,EAAK,SACZJ,GAAW,EAAI,SACfK,GAAW,EAAI,OACflH,GAAS,EAAK,gBACdoH,EAAe,OACfU,EAAM,OACNC,EAAM,UACN7D,EAAS,UACT5xB,GAAY,EAAI,aAChBi1B,GAAe,EAAI,aACnBC,GAAe,EAAI,oBACnBC,EAAmB,UACnBrM,EAAS,OACTK,EAAM,UACNC,EAAS,QACTL,EAAO,WACPC,EAAU,SACVK,EAAQ,kBACR2Q,EACAhG,QAASiG,EAAY,iBACrBC,GAAmB,KAChBl7D,GACJ01C,EACC,MAAMyf,GAAe37B,EAAAA,EAAAA,UACrB4sB,EAAWJ,GAAmBI,EAAU,aACxC,MAAO+U,EAAeC,IAAoB3hC,EAAAA,EAAAA,WAAS,GAC7Co+B,EAAa7I,GAAiByH,GAC9B4E,EAA0BC,GAAcP,GAAc,KAAM,OAClE7hC,EAAAA,EAAAA,YAAU,KAGRkiC,EAAiBL,EAAapF,IAAS0F,EAA0B1F,EAAK,GACrE,CAACA,EAAMoF,EAAYM,IACtB,MAAME,GAAejiC,EAAAA,EAAAA,UAAQ,KAAM,CACjCm9B,OAAQoB,KACN,CAACA,IAaL,MAQMxB,GAAiBr9B,EAAAA,EAAAA,cAAYwiC,IAA8BjV,EAAAA,GAAAA,KAAK,MAAO,IACxEiV,EACHnV,UAAW1V,KAAW,GAAGyV,aAAqB4U,MAC5C,CAACA,EAAmB5U,IAClBgQ,EAAe6B,IAA4B1R,EAAAA,GAAAA,KAAK,MAAO,IACxD0R,KACAj4D,EACHqmD,UAAW1V,KAAW0V,EAAW0U,EAAa,GAAG3U,KAAY2U,IAAe3U,EAAU,GAAGA,KAAY0U,KACrG,kBAAmBD,EACnB5wD,SAAUA,IAEZ,OAAoBouD,EAAAA,GAAAA,MAAMD,GAAAA,SAAW,CACnCnuD,SAAU,EAAEkxD,IAAkBJ,GAAcG,IAAqB9E,EAAa,CAAC,IAAiB7P,EAAAA,GAAAA,KAAK8S,GAAanrB,SAAU,CAC1Hv0C,MAAO4hE,EACPtxD,UAAuBs8C,EAAAA,GAAAA,KAAKkV,GAAW,CACrC9F,KAAMwF,EACN7rC,IAAKA,EACLimC,SAAUA,EACV3C,UAAWA,EACXgD,SAAUA,EACV50B,UAAWA,EACXi1B,aAAcA,IAAiBvH,EAC/BwH,aAAcA,EACdC,oBAAqBA,EACrBL,gBAAiBA,EACjBU,OAAQA,EACRC,OAAQoB,EACR9N,QAnCc,SAAC9tD,GACfA,IAAMA,EAAKX,MAAMogE,WAAa,WAAU,QAAA38D,EAAAzE,UAAAE,OADhBoE,EAAI,IAAA/F,MAAAkG,EAAA,EAAAA,EAAA,KAAAE,EAAA,EAAAA,EAAAF,EAAAE,IAAJL,EAAIK,EAAA,GAAA3E,UAAA2E,GAErB,MAAX8qD,GAAmBA,EAAQ9tD,KAAS2C,EACtC,EAiCMorD,WAAYA,EACZF,UAAWA,EACXK,OAAQA,EACRC,UAAWA,EACXC,SApCe,SAACpuD,GAChBA,IAAMA,EAAKX,MAAMogE,WAAa,IAAG,QAAAt8D,EAAA9E,UAAAE,OADRoE,EAAI,IAAA/F,MAAAuG,EAAA,EAAAA,EAAA,KAAAC,EAAA,EAAAA,EAAAD,EAAAC,IAAJT,EAAIS,EAAA,GAAA/E,UAAA+E,GAErB,MAAZgrD,GAAoBA,KAAYzrD,EAClC,EAkCMo2D,QApDAiG,IACAvM,GAGGyG,EAAa9iD,UAAS8iD,EAAa9iD,QAAU,IAAI2nD,GAAsB,CAC1EnI,yBAAyB,KAEpBsD,EAAa9iD,SH9BnB,SAA0B9Y,GAE/B,OADKkhE,KAAeA,GAAgB,IAAIT,GAAsBzgE,IACvDkhE,EACT,CG6BWkB,IA4CHzjD,WAAYwiD,GACZ3E,mBAAoB4E,GACpBtE,eAAgBA,EAChBD,aAAcA,QAGlB,IAEJwE,GAAUzzD,YAAc,YACxB,SAAehP,OAAOoO,OAAOq0D,GAAW,CACtCgB,KAAMjD,GACNkD,OAAQvC,GACRwC,MAAOrC,KCpIHsC,GAA+Bvf,EAAAA,YAAiB,CAAA9G,EAGnDpmB,KAAQ,IAH4C,OACrDmnC,KACGz2D,GACJ01C,EACC,MAAM/jB,GAAUsH,EAAAA,EAAAA,YAAW41B,IACrBgJ,EAAa7I,IAAiB,KACvB,MAAXr9B,GAAuC,MAApBA,EAAQy9B,UAAoBz9B,EAAQy9B,WAC7C,MAAVqH,GAAkBA,GAAQ,IAE5B,OAAoBlQ,EAAAA,GAAAA,KAAKqU,GAAW,CAClCtrC,IAAKA,EACLqmC,OAAoB,MAAXhkC,IAAmBA,EAAQo9B,aACjC/uD,EACHk7D,kBAAkB,EAClBzE,OAAQoB,GACR,IAEJkE,GAAgB50D,YAAc,kBAC9B,YCpBM60D,GAA0Bxf,EAAAA,YAAiB,CAAA9G,EAK9CpmB,KAAQ,IALuC,UAChD+2B,EAAS,SACTD,EACAE,GAAI9Y,EAAY,UACbxtC,GACJ01C,EAEC,OADA0Q,EAAWJ,GAAmBI,EAAU,gBACpBG,EAAAA,GAAAA,KAAK/Y,EAAW,CAClCle,IAAKA,EACL+2B,UAAW1V,KAAW0V,EAAWD,MAC9BpmD,GACH,IAEJg8D,GAAW70D,YAAc,aACzB,YCLM80D,GAAsBzf,EAAAA,YAAiB,CAACx8C,EAAOsvB,KACnD,MACE82B,SAAU8V,EAAe,OACzBC,GAAS,EAAI,QACbrD,EAAU,QAAO,GACjBtsC,EAAE,MACF4vC,EAAK,OACLC,EAAM,UACNhW,EAEAC,GAAI9Y,EAAY,MAAK,SACrBuhB,EAAQ,SACRK,EAAQ,SACRkN,EAAQ,iBACRC,GAAmB,KAChBC,GACDtY,GAAgBlkD,EAAO,CACzB+uD,SAAU,aAEN3I,EAAWJ,GAAmBkW,EAAiB,UAC/CO,GAAiBzjC,EAAAA,EAAAA,cAAY,WACrB,MAAZsjC,GAAoBA,KAAShiE,WACzBiiE,GAAoBxN,IACV,MAAZK,GAAoBA,GAAS,GAEjC,GAAG,CAACkN,EAAUC,EAAkBxN,EAAUK,SAKbzwD,IAAzB69D,EAAgB7N,MAAoC,QAAdnhB,IACxCgvB,EAAgB7N,KAAO,cAEzB,IAAI+N,EAAc,GAAGtW,WACC,kBAAX+V,IAAqBO,EAAc,GAAGA,KAAeP,KAChE,MAAMQ,GAAgBrjC,EAAAA,EAAAA,UAAQ,KAAM,CAClC81B,SAAUA,IAAkB,MAAZA,OAAmB,EAASA,GAAUL,GACtD3I,WACA2I,WAAYA,EACZoN,YACE,CAAC/V,EAAU2I,EAAUoN,EAAQ/M,IACjC,OAAoB7I,EAAAA,GAAAA,KAAKsI,GAAc3gB,SAAU,CAC/Cv0C,MAAOgjE,EACP1yD,UAAuBs8C,EAAAA,GAAAA,KAAKqW,GAAkB1uB,SAAU,CACtDv0C,MAAO8iE,EACPxyD,UAAuBs8C,EAAAA,GAAAA,KAAK/Y,EAAW,CACrCle,IAAKA,KACFktC,EACHnW,UAAW1V,KAAW0V,EAAWD,EAAU+V,GAAUO,EAAa5D,GAAW,GAAG1S,KAAY0S,IAAWtsC,GAAM,MAAMA,IAAM6vC,GAAU,UAAUA,IAAUD,GAAS,SAASA,UAG7K,IAEJH,GAAO90D,YAAc,SACrB,SAAehP,OAAOoO,OAAO01D,GAAQ,CACnCY,MAAO1W,GACP2I,SAAUF,GACVgM,UAAWmB,GACXe,KAAMd,GACNe,OAAQ7N,KCpEJ8N,GAAyBxgB,EAAAA,YAAiB,CAAA9G,EAO7CpmB,KAAQ,IAPsC,SAC/C82B,EAAQ,MACR6W,GAAQ,EAER3W,GAAI9Y,EAAY,MAAK,UACrB6Y,KACGrmD,GACJ01C,EACC,MAAMuQ,EAASD,GAAmBI,EAAU,aACtC8W,EAA0B,kBAAVD,EAAqB,IAAIA,IAAU,SACzD,OAAoB1W,EAAAA,GAAAA,KAAK/Y,EAAW,CAClCle,IAAKA,KACFtvB,EACHqmD,UAAW1V,KAAW0V,EAAW4W,EAAQ,GAAGhX,IAASiX,IAAWjX,IAChE,IAEJ+W,GAAU71D,YAAc,YACxB,mBCtBA,MAAMg2D,GAA0B3gB,EAAAA,cAAoB,MACpD2gB,GAAWh2D,YAAc,aACzB,YCDA,GADgCq1C,EAAAA,cAAoB,MCD9CsX,GAAY,CAAC,KAAM,YAOlB,SAASsJ,GAAc5T,GAU3B,IAV4B,QAC7B11B,EAAO,SACPhqB,EAAQ,KACRma,EAAI,OACJ3qB,EAAM,IACN+jE,EAAG,KACH1O,EAAI,QACJ/tB,EAAO,SACPs3B,EAAW,EAAC,KACZv6D,GACD6rD,EACM11B,IAEDA,EADU,MAAR7P,GAA0B,MAAV3qB,GAAyB,MAAP+jE,EAC1B,IAEA,UAGd,MAAMjuD,EAAO,CACX0kB,WAEF,GAAgB,WAAZA,EACF,MAAO,CAAC,CACNn2B,KAAMA,GAAQ,SACdmM,YACCsF,GAEL,MAAMigD,EAAcrtC,KACdlY,GAAwB,MAAZgqB,GA/Bb,SAAuB7P,GAC5B,OAAQA,GAAwB,MAAhBA,EAAK9oB,MACvB,CA6BuCmiE,CAAcr5C,KAC/CjC,EAAMrI,iBAEJ7P,EACFkY,EAAMxJ,kBAGG,MAAXooB,GAA2BA,EAAQ5e,EAAM,EAe3C,MAPgB,MAAZ8R,IAEF7P,IAASA,EAAO,KACZna,IACFma,OAAOtlB,IAGJ,CAAC,CACNgwD,KAAc,MAARA,EAAeA,EAAO,SAG5B7kD,cAAUnL,EACVu5D,SAAUpuD,OAAWnL,EAAYu5D,EACjCj0C,OACA3qB,OAAoB,MAAZw6B,EAAkBx6B,OAASqF,EACnC,gBAAkBmL,QAAWnL,EAC7B0+D,IAAiB,MAAZvpC,EAAkBupC,OAAM1+D,EAC7BiiC,QAASyuB,EACTkO,UAxBoBv7C,IACF,MAAdA,EAAM/oB,MACR+oB,EAAMrI,iBACN01C,EAAYrtC,GACd,GAqBC5S,EACL,CACA,MAAMouD,GAAsBhhB,EAAAA,YAAiB,CAAC9G,EAAMpmB,KAClD,IACIg3B,GAAImX,EAAM,SACV3zD,GACE4rC,EACJ11C,EA3EJ,SAAuCswB,EAAG7xB,GAAK,GAAI,MAAQ6xB,EAAG,MAAO,CAAC,EAAG,IAAIhI,EAAI,CAAC,EAAG,IAAK,IAAID,KAAKiI,EAAG,GAAI,CAAC,EAAEj4B,eAAeS,KAAKw3B,EAAGjI,GAAI,CAAE,GAAI5pB,EAAE4P,QAAQga,IAAM,EAAG,SAAUC,EAAED,GAAKiI,EAAEjI,EAAI,CAAE,OAAOC,CAAG,CA2ExLk8B,CAA8B9O,EAAMoe,IAC9C,MAAO4J,GACL5pC,QAAS0Z,IACN4vB,GAAejlE,OAAOoO,OAAO,CAChCutB,QAAS2pC,EACT3zD,YACC9J,IACH,OAAoBumD,EAAAA,GAAAA,KAAK/Y,EAAWr1C,OAAOoO,OAAO,CAAC,EAAGvG,EAAO09D,EAAa,CACxEpuC,IAAKA,IACJ,IAELkuC,GAAOr2D,YAAc,SACrB,YCxFM2sD,GAAY,CAAC,KAAM,SAAU,YAW5B,SAAS6J,GAAUnU,GAOvB,IAPwB,IACzBvwD,EAAG,QACH2nC,EAAO,OACP6pB,EAAM,GACNnyC,EAAE,KACFq2C,EAAI,SACJ7kD,GACD0/C,EACC,MAAMoU,GAAiB3kC,EAAAA,EAAAA,YAAW2jC,IAC5BiB,GAAa5kC,EAAAA,EAAAA,YAAWkkC,IACxBW,GAAa7kC,EAAAA,EAAAA,YAAW8kC,IAC9B,IAAIC,EAAWvT,EACf,MAAMzqD,EAAQ,CACZ2uD,QAEF,GAAIkP,EAAY,CACTlP,GAA4B,YAApBkP,EAAWlP,OAAoB3uD,EAAM2uD,KAAO,OACzD,MAAMsP,EAAsBJ,EAAWK,gBAAuB,MAAPjlE,EAAcA,EAAM,MACrEklE,EAAsBN,EAAWO,gBAAuB,MAAPnlE,EAAcA,EAAM,MAG3E+G,EAAM2xD,GAAS,cAAgB14D,EAC/B+G,EAAMsY,GAAK2lD,GAAuB3lD,EAClC0lD,EAAqB,MAAVvT,GAAyB,MAAPxxD,EAAc4kE,EAAWQ,YAAcplE,EAAMwxD,GAWtEuT,IAA4B,MAAdF,GAAsBA,EAAWtV,eAAkC,MAAdsV,GAAsBA,EAAWrV,gBAAezoD,EAAM,iBAAmBm+D,EAClJ,CAqBA,MApBmB,QAAfn+D,EAAM2uD,OACR3uD,EAAM,iBAAmBg+D,EACpBA,IACHh+D,EAAMk4D,UAAY,GAEhBpuD,IACF9J,EAAMk4D,UAAY,EAClBl4D,EAAM,kBAAmB,IAG7BA,EAAM4gC,QAAUouB,IAAiBvwD,IAC3BqL,IACO,MAAX82B,GAA2BA,EAAQniC,GACxB,MAAPxF,GAGA2kE,IAAmBn/D,EAAEib,wBACvBkkD,EAAe3kE,EAAKwF,GACtB,IAEK,CAACuB,EAAO,CACbg+D,YAEJ,CACA,MAAMM,GAAuB9hB,EAAAA,YAAiB,CAAC9G,EAAMpmB,KACnD,IACIg3B,GAAI9Y,EAAYgwB,GAAM,OACtB/S,EAAM,SACNhH,GACE/N,EACJn8C,EA5EJ,SAAuC+2B,EAAG7xB,GAAK,GAAI,MAAQ6xB,EAAG,MAAO,CAAC,EAAG,IAAIhI,EAAI,CAAC,EAAG,IAAK,IAAID,KAAKiI,EAAG,GAAI,CAAC,EAAEj4B,eAAeS,KAAKw3B,EAAGjI,GAAI,CAAE,GAAI5pB,EAAE4P,QAAQga,IAAM,EAAG,SAAUC,EAAED,GAAKiI,EAAEjI,EAAI,CAAE,OAAOC,CAAG,CA4EtLk8B,CAA8B9O,EAAMoe,IAChD,MAAO9zD,EAAOoP,GAAQuuD,GAAWxlE,OAAOoO,OAAO,CAC7CtN,IAAKuqD,GAAaC,EAAUlqD,EAAQ0qB,MACpCwmC,UACClxD,IAIH,OADAyG,EAAM2xD,GAAS,WAAaviD,EAAK4uD,UACbzX,EAAAA,GAAAA,KAAK/Y,EAAWr1C,OAAOoO,OAAO,CAAC,EAAGhN,EAASyG,EAAO,CACpEsvB,IAAKA,IACJ,IAELgvC,GAAQn3D,YAAc,UACtB,YC1FM2sD,GAAY,CAAC,KAAM,WAAY,YAAa,OAAQ,aAc1D,MAAM7I,GAAOA,OACPsT,GAAiB5M,GAAS,aAC1B6M,GAAmBhiB,EAAAA,YAAiB,CAAC9G,EAAMpmB,KAC/C,IAEIg3B,GAAI9Y,EAAY,MAAK,SACrB8uB,EAAQ,UACR+B,EAAS,KACT1P,EAAI,UACJ4O,GACE7nB,EACJ11C,EAxBJ,SAAuCswB,EAAG7xB,GAAK,GAAI,MAAQ6xB,EAAG,MAAO,CAAC,EAAG,IAAIhI,EAAI,CAAC,EAAG,IAAK,IAAID,KAAKiI,EAAG,GAAI,CAAC,EAAEj4B,eAAeS,KAAKw3B,EAAGjI,GAAI,CAAE,GAAI5pB,EAAE4P,QAAQga,IAAM,EAAG,SAAUC,EAAED,GAAKiI,EAAEjI,EAAI,CAAE,OAAOC,CAAG,CAwBxLk8B,CAA8B9O,EAAMoe,IAG9C,MAAM/mB,ECVO,WAGb,MAAO,CAAEzW,IAAYiD,EAAAA,EAAAA,aAAWyB,IAAUA,IAAO,GACjD,OAAO1E,CACT,CDKsBmoC,GACdC,GAAkBllC,EAAAA,EAAAA,SAAO,GACzBokC,GAAiB3kC,EAAAA,EAAAA,YAAW2jC,IAC5BkB,GAAa7kC,EAAAA,EAAAA,YAAW8kC,IAC9B,IAAIK,EAAiBF,EACjBJ,IACFnP,EAAOA,GAAQ,UACf0P,EAAYP,EAAWO,UAEvBD,EAAkBN,EAAWM,gBAC7BF,EAAkBJ,EAAWI,iBAE/B,MAAMS,GAAWnlC,EAAAA,EAAAA,QAAO,MAClBolC,EAAmBn7C,IACvB,MAAMo7C,EAAkBF,EAAStsD,QACjC,IAAKwsD,EAAiB,OAAO,KAC7B,MAAMC,EAAQpF,GAAImF,EAAiB,IAAIN,iCACjCQ,EAAcF,EAAgBG,cAAc,wBAClD,IAAKD,GAAeA,IAAgB77D,SAASyF,cAAe,OAAO,KACnE,MAAMmnB,EAAQgvC,EAAMzwD,QAAQ0wD,GAC5B,IAAe,IAAXjvC,EAAc,OAAO,KACzB,IAAI2mB,EAAY3mB,EAAQrM,EAGxB,OAFIgzB,GAAaqoB,EAAMtkE,SAAQi8C,EAAY,GACvCA,EAAY,IAAGA,EAAYqoB,EAAMtkE,OAAS,GACvCskE,EAAMroB,EAAU,EAEnBwoB,EAAeA,CAAChmE,EAAK+oB,KACd,MAAP/oB,IACQ,MAAZqjE,GAA4BA,EAASrjE,EAAK+oB,GACxB,MAAlB47C,GAAkCA,EAAe3kE,EAAK+oB,GAAM,GA0B9DkX,EAAAA,EAAAA,YAAU,KACR,GAAIylC,EAAStsD,SAAWqsD,EAAgBrsD,QAAS,CAC/C,MAAM0sD,EAAcJ,EAAStsD,QAAQ2sD,cAAc,IAAIT,2BACxC,MAAfQ,GAA+BA,EAAYp5C,OAC7C,CACA+4C,EAAgBrsD,SAAU,CAAK,IAEjC,MAAM66C,EAAYC,GAAc79B,EAAKqvC,GACrC,OAAoBpY,EAAAA,GAAAA,KAAKqW,GAAkB1uB,SAAU,CACnDv0C,MAAOslE,EACPh1D,UAAuBs8C,EAAAA,GAAAA,KAAK4W,GAAWjvB,SAAU,CAC/Cv0C,MAAO,CACLg1D,OAEA0P,UAAW7a,GAAa6a,GACxBD,gBAAiBA,GAAmBnT,GACpCiT,gBAAiBA,GAAmBjT,IAEtChhD,UAAuBs8C,EAAAA,GAAAA,KAAK/Y,EAAWr1C,OAAOoO,OAAO,CAAC,EAAGvG,EAAO,CAC9Du9D,UA3CgBv7C,IAEpB,GADa,MAAbu7C,GAA6BA,EAAUv7C,IAClC87C,EACH,OAEF,IAAIoB,EACJ,OAAQl9C,EAAM/oB,KACZ,IAAK,YACL,IAAK,UACHimE,EAAkBN,GAAkB,GACpC,MACF,IAAK,aACL,IAAK,YACHM,EAAkBN,EAAiB,GACnC,MACF,QACE,OpCtED,IAAkB5gE,EoCwEhBkhE,IACLl9C,EAAMrI,iBACNslD,EAAaC,EAAgB7/B,SpC1ERrhC,EoC0EyB,WpCzEzC,OAAqBA,OoCyEoC,KAAMgkB,GACpE08C,EAAgBrsD,SAAU,EAC1B06B,IAAa,EAsBTzd,IAAK49B,EACLyB,KAAMA,QAGV,IAEJ6P,GAAIr3D,YAAc,MAClB,SAAehP,OAAOoO,OAAOi4D,GAAK,CAChCW,KAAMb,KE5GF3sC,GAAuB6qB,EAAAA,cAAoB,MACjD7qB,GAAQxqB,YAAc,oBACtB,YCCMm3D,GAAuB9hB,EAAAA,YAAiB,CAAA9G,EAK3CpmB,KAAQ,IALoC,UAC7C+2B,EAAS,SACTD,EACAE,GAAI9Y,EAAY,SACbxtC,GACJ01C,EAEC,OADA0Q,EAAWJ,GAAmBI,EAAU,aACpBG,EAAAA,GAAAA,KAAK/Y,EAAW,CAClCle,IAAKA,EACL+2B,UAAW1V,KAAW0V,EAAWD,MAC9BpmD,GACH,IAEJs+D,GAAQn3D,YAAc,UACtB,YClBkB,IAAI+0B,QCFtB,MAAM43B,GAAY,CAAC,aAgBnB,MAAMsL,GAAsB5iB,EAAAA,YAAiB,CAAC9G,EAAMpmB,KAClD,IAAI,UACAiuC,GACE7nB,EACJ11C,EAnBJ,SAAuCswB,EAAG7xB,GAAK,GAAI,MAAQ6xB,EAAG,MAAO,CAAC,EAAG,IAAIhI,EAAI,CAAC,EAAG,IAAK,IAAID,KAAKiI,EAAG,GAAI,CAAC,EAAEj4B,eAAeS,KAAKw3B,EAAGjI,GAAI,CAAE,GAAI5pB,EAAE4P,QAAQga,IAAM,EAAG,SAAUC,EAAED,GAAKiI,EAAEjI,EAAI,CAAE,OAAOC,CAAG,CAmBxLk8B,CAA8B9O,EAAMoe,IAC9C,MAAO4J,GAAeN,GAAejlE,OAAOoO,OAAO,CACjDutB,QAAS,KACR9zB,IACGq/D,EAAgBrQ,IAAiBvwD,IACrCi/D,EAAYH,UAAU9+D,GACT,MAAb8+D,GAA6BA,EAAU9+D,EAAE,IAE3C,OAnB4BwlB,EAmBVjkB,EAAMikB,OAlBQ,MAAhBA,EAAK9oB,QAkB2B,WAAf6E,EAAM2uD,MAOnBpI,EAAAA,GAAAA,KAAK,IAAKpuD,OAAOoO,OAAO,CAC1C+oB,IAAKA,GACJtvB,EAAO,CACRu9D,UAAWA,MATShX,EAAAA,GAAAA,KAAK,IAAKpuD,OAAOoO,OAAO,CAC1C+oB,IAAKA,GACJtvB,EAAO09D,EAAa,CACrBH,UAAW8B,KAvBV,IAAuBp7C,CA8BzB,IAELm7C,GAAOj4D,YAAc,SACrB,YCjCMm4D,GAAuB9iB,EAAAA,YAAiB,CAAA9G,EAQ3CpmB,KAAQ,IARoC,SAC7C82B,EAAQ,UACRC,EACAC,GAAI9Y,EAAY4xB,GAAM,OACtB3U,EAAM,SACNhH,EAAQ,SACR35C,GAAW,KACR9J,GACJ01C,EACC0Q,EAAWJ,GAAmBI,EAAU,YACxC,MAAOmZ,EAAcnwD,GAAQuuD,GAAW,CACtC1kE,IAAKuqD,GAAaC,EAAUzjD,EAAMikB,MAClCwmC,SACA3gD,cACG9J,IAEL,OAAoBumD,EAAAA,GAAAA,KAAK/Y,EAAW,IAC/BxtC,KACAu/D,EACHjwC,IAAKA,EACLxlB,SAAUA,EACVu8C,UAAW1V,KAAW0V,EAAWD,EAAUt8C,GAAY,WAAYsF,EAAK4uD,UAAY,WACpF,IAEJsB,GAAQn4D,YAAc,UACtB,YCpBMq3D,GAAmBhiB,EAAAA,YAAiB,CAACgjB,EAAmBlwC,KAC5D,MAAM,GACJg3B,EAAK,MACLF,SAAU8V,EAAe,QACzBpD,EAAO,KACP2G,GAAO,EAAK,QACZC,GAAU,EAAK,OACfC,EAAM,aACNC,EAAY,UACZvZ,EAAS,UACTgY,KACGr+D,GACDkkD,GAAgBsb,EAAmB,CACrCnB,UAAW,aAEPjY,EAAWJ,GAAmBkW,EAAiB,OACrD,IAAI2D,EACAC,EACAC,GAAW,EACf,MAAMpD,GAAgB1jC,EAAAA,EAAAA,YAAW41B,IAC3BmR,GAAoB/mC,EAAAA,EAAAA,YAAWgnC,IASrC,OARItD,GACFkD,EAAiBlD,EAAcvW,SAC/B2Z,EAAqB,MAAVJ,GAAwBA,GAC1BK,KAEPF,sBACEE,IAEczZ,EAAAA,GAAAA,KAAK2Z,GAAS,CAChC5Z,GAAIA,EACJh3B,IAAKA,EACL+uC,UAAWA,EACXhY,UAAW1V,KAAW0V,EAAW,CAC/B,CAACD,IAAY2Z,EACb,CAAC,GAAGF,SAAuBE,EAC3B,CAAC,GAAGF,gBAA8BE,GAAYH,EAC9C,CAAC,GAAGE,KAAsBhH,OAAcgH,EACxC,CAAC,GAAG1Z,KAAY0S,OAAcA,EAC9B,CAAC,GAAG1S,UAAkBqZ,EACtB,CAAC,GAAGrZ,eAAuBsZ,OAE1B1/D,GACH,IAEJw+D,GAAIr3D,YAAc,MAClB,SAAehP,OAAOoO,OAAOi4D,GAAK,CAChCW,KAAMb,GACN6B,KAAMb,KCxDFc,GAAwB5jB,EAAAA,YAAiB,CAAA9G,EAK5CpmB,KAAQ,IALqC,UAC9C+2B,EAAS,SACTD,EACAE,GAAI9Y,EAAY,SACbxtC,GACJ01C,EAEC,OADA0Q,EAAWJ,GAAmBI,EAAU,cACpBG,EAAAA,GAAAA,KAAK/Y,EAAW,CAClCle,IAAKA,EACL+2B,UAAW1V,KAAW0V,EAAWD,MAC9BpmD,GACH,IAEJogE,GAASj5D,YAAc,WACvB,YCdMk5D,GAA0B7jB,EAAAA,YAAiB,CAAA9G,EAK9CpmB,KAAQ,IALuC,UAChD+2B,EAAS,SACTD,EACAE,GAAI9Y,EAAY,SACbxtC,GACJ01C,EAEC,OADA0Q,EAAWJ,GAAmBI,EAAU,gBACpBG,EAAAA,GAAAA,KAAK/Y,EAAW,CAClCle,IAAKA,EACL+2B,UAAW1V,KAAW0V,EAAWD,MAC9BpmD,GACH,IAEJqgE,GAAWl5D,YAAc,aACzB,YCZMm5D,GAA0B9jB,EAAAA,YAAiB,CAAA9G,EAM9CpmB,KAAQ,IANuC,SAChD82B,EAAQ,UACRC,EAEAC,GAAI9Y,EAAY,SACbxtC,GACJ01C,EACC,MAAMuQ,EAASD,GAAmBI,EAAU,eACtCma,GAAejnC,EAAAA,EAAAA,UAAQ,KAAM,CACjCwmC,mBAAoB7Z,KAClB,CAACA,IACL,OAAoBM,EAAAA,GAAAA,KAAK0Z,GAAkB/xB,SAAU,CACnDv0C,MAAO4mE,EACPt2D,UAAuBs8C,EAAAA,GAAAA,KAAK/Y,EAAW,CACrCle,IAAKA,KACFtvB,EACHqmD,UAAW1V,KAAW0V,EAAWJ,MAEnC,IAEJqa,GAAWn5D,YAAc,aACzB,YCvBMq5D,GAAuBhkB,EAAAA,YAE7B,CAAA9G,EAMGpmB,KAAQ,IANV,SACC82B,EAAQ,UACRC,EAAS,QACTyS,EACAxS,GAAI9Y,EAAY,SACbxtC,GACJ01C,EACC,MAAMuQ,EAASD,GAAmBI,EAAU,YAC5C,OAAoBG,EAAAA,GAAAA,KAAK/Y,EAAW,CAClCle,IAAKA,EACL+2B,UAAW1V,KAAWmoB,EAAU,GAAG7S,KAAU6S,IAAY7S,EAAQI,MAC9DrmD,GACH,IAEJwgE,GAAQr5D,YAAc,UACtB,YCjBMs5D,GAA8BjkB,EAAAA,YAAiB,CAAA9G,EAKlDpmB,KAAQ,IAL2C,UACpD+2B,EAAS,SACTD,EACAE,GAAI9Y,EAAY,SACbxtC,GACJ01C,EAEC,OADA0Q,EAAWJ,GAAmBI,EAAU,qBACpBG,EAAAA,GAAAA,KAAK/Y,EAAW,CAClCle,IAAKA,EACL+2B,UAAW1V,KAAW0V,EAAWD,MAC9BpmD,GACH,IAEJygE,GAAet5D,YAAc,iBAC7B,YCdMu5D,GAAwBlkB,EAAAA,YAAiB,CAAA9G,EAK5CpmB,KAAQ,IALqC,UAC9C+2B,EAAS,SACTD,EACAE,GAAI9Y,EAAY,OACbxtC,GACJ01C,EAEC,OADA0Q,EAAWJ,GAAmBI,EAAU,cACpBG,EAAAA,GAAAA,KAAK/Y,EAAW,CAClCle,IAAKA,EACL+2B,UAAW1V,KAAW0V,EAAWD,MAC9BpmD,GACH,IAEJ0gE,GAASv5D,YAAc,WACvB,YCbMw5D,GAAgBnH,GAAiB,MACjCoH,GAA4BpkB,EAAAA,YAAiB,CAAA9G,EAKhDpmB,KAAQ,IALyC,UAClD+2B,EAAS,SACTD,EACAE,GAAI9Y,EAAYmzB,MACb3gE,GACJ01C,EAEC,OADA0Q,EAAWJ,GAAmBI,EAAU,kBACpBG,EAAAA,GAAAA,KAAK/Y,EAAW,CAClCle,IAAKA,EACL+2B,UAAW1V,KAAW0V,EAAWD,MAC9BpmD,GACH,IAEJ4gE,GAAaz5D,YAAc,eAC3B,YChBM05D,GAAwBrkB,EAAAA,YAAiB,CAAA9G,EAK5CpmB,KAAQ,IALqC,UAC9C+2B,EAAS,SACTD,EACAE,GAAI9Y,EAAY,OACbxtC,GACJ01C,EAEC,OADA0Q,EAAWJ,GAAmBI,EAAU,cACpBG,EAAAA,GAAAA,KAAK/Y,EAAW,CAClCle,IAAKA,EACL+2B,UAAW1V,KAAW0V,EAAWD,MAC9BpmD,GACH,IAEJ6gE,GAAS15D,YAAc,WACvB,YCbMoyD,GAAgBC,GAAiB,MACjCsH,GAAyBtkB,EAAAA,YAAiB,CAAA9G,EAK7CpmB,KAAQ,IALsC,UAC/C+2B,EAAS,SACTD,EACAE,GAAI9Y,EAAY+rB,MACbv5D,GACJ01C,EAEC,OADA0Q,EAAWJ,GAAmBI,EAAU,eACpBG,EAAAA,GAAAA,KAAK/Y,EAAW,CAClCle,IAAKA,EACL+2B,UAAW1V,KAAW0V,EAAWD,MAC9BpmD,GACH,IAEJ8gE,GAAU35D,YAAc,YACxB,YCPM45D,GAAoBvkB,EAAAA,YAAiB,CAAA9G,EAWxCpmB,KAAQ,IAXiC,SAC1C82B,EAAQ,UACRC,EAAS,GACT75B,EAAE,KACF/K,EAAI,OACJu/C,EAAM,KACNp4D,GAAO,EAAK,SACZqB,EAEAq8C,GAAI9Y,EAAY,SACbxtC,GACJ01C,EACC,MAAMuQ,EAASD,GAAmBI,EAAU,QAC5C,OAAoBG,EAAAA,GAAAA,KAAK/Y,EAAW,CAClCle,IAAKA,KACFtvB,EACHqmD,UAAW1V,KAAW0V,EAAWJ,EAAQz5B,GAAM,MAAMA,IAAM/K,GAAQ,QAAQA,IAAQu/C,GAAU,UAAUA,KACvG/2D,SAAUrB,GAAoB29C,EAAAA,GAAAA,KAAK6Z,GAAU,CAC3Cn2D,SAAUA,IACPA,GACL,IAEJ82D,GAAK55D,YAAc,OACnB,SAAehP,OAAOoO,OAAOw6D,GAAM,CACjCE,IAAKT,GACL1E,MAAOgF,GACPI,SAAUN,GACVhF,KAAMwE,GACND,KAAMO,GACN5D,KAAM+D,GACNhF,OAAQyE,GACRa,OAAQd,GACRe,WAAYX,KC5CC,SAASY,KACtB,OACE9a,EAAAA,GAAAA,KAACyW,GAAS,CAAA/yD,UACRs8C,EAAAA,GAAAA,KAACwa,GAAI,CAAA92D,UACHouD,EAAAA,GAAAA,MAAC0I,GAAKnF,KAAI,CAAA3xD,SAAA,EACRs8C,EAAAA,GAAAA,KAACwa,GAAKjF,MAAK,CAAA7xD,SAAC,gBACZs8C,EAAAA,GAAAA,KAACwa,GAAKjE,KAAI,CAAA7yD,SAAC,qDAOrB,CChBO,MAAMq3D,GAAW,CACtB,0BAA2B,CACzB,MAAS,0BACT,UAAa,6BACb,OAAU,q8FAEZ,uCAAwC,CACtC,MAAS,yCACT,UAAa,6BACb,OAAU,sgEAEZ,8BAA+B,CAC7B,MAAS,8BACT,UAAa,6BACb,OAAU,2uHAEZ,oBAAqB,CACnB,MAAS,oBACT,UAAa,6BACb,OAAU,g/BAEZ,2DAA4D,CAC1D,MAAS,4DACT,UAAa,6BACb,OAAU,83GAEZ,uCAAwC,CACtC,MAAS,wCACT,UAAa,6BACb,OAAU,wwDAEZ,4BAA6B,CAC3B,MAAS,4BACT,UAAa,6BACb,OAAU,wrCAEZ,4BAA6B,CAC3B,MAAS,+BACT,UAAa,6BACb,OAAU,qzCAEZ,gBAAiB,CACf,MAAS,gBACT,UAAa,6BACb,OAAU,o3DAEZ,oDAAqD,CACnD,MAAS,sDACT,UAAa,6BACb,OAAU,qyEAEZ,6BAA8B,CAC5B,MAAS,6BACT,UAAa,6BACb,OAAU,gzFAEZ,2BAA4B,CAC1B,MAAS,2BACT,UAAa,6BACb,OAAU,2lFAEZ,6BAA8B,CAC5B,MAAS,6BACT,UAAa,6BACb,OAAU,w0HAEZ,oBAAqB,CACnB,MAAS,qBACT,UAAa,6BACb,OAAU,k2RAEZ,qBAAsB,CACpB,MAAS,qBACT,UAAa,6BACb,OAAU,+tFAEZ,iCAAkC,CAChC,MAAS,iCACT,UAAa,6BACb,OAAU,+9DAEZ,sBAAuB,CACrB,MAAS,sBACT,UAAa,6BACb,OAAU,+1DAEZ,+BAAgC,CAC9B,MAAS,+BACT,UAAa,6BACb,OAAU,qwGAEZ,wBAAyB,CACvB,MAAS,0BACT,UAAa,6BACb,OAAU,0xDAEZ,oCAAqC,CACnC,MAAS,qCACT,UAAa,6BACb,OAAU,0lKAEZ,mEAAoE,CAClE,MAAS,oEACT,UAAa,6BACb,OAAU,qxFAEZ,gBAAiB,CACf,MAAS,gBACT,UAAa,6BACb,OAAU,mvFAEZ,sBAAuB,CACrB,MAAS,sBACT,UAAa,6BACb,OAAU,uoEAEZ,UAAa,CACX,MAAS,qBACT,UAAa,6BACb,OAAU,+/HAEZ,kCAAmC,CACjC,MAAS,kCACT,UAAa,6BACb,OAAU,i+GAEZ,uCAAwC,CACtC,MAAS,wCACT,UAAa,6BACb,OAAU,y4BAEZ,6BAA8B,CAC5B,MAAS,6BACT,UAAa,6BACb,OAAU,y4GAEZ,kBAAmB,CACjB,MAAS,kBACT,UAAa,6BACb,OAAU,+uDAEZ,oDAAqD,CACnD,MAAS,sDACT,UAAa,6BACb,OAAU,gyEAEZ,2CAA4C,CAC1C,MAAS,4CACT,UAAa,6BACb,OAAU,kqGAEZ,sBAAuB,CACrB,MAAS,uBACT,UAAa,6BACb,OAAU,4kDAEZ,+BAAgC,CAC9B,MAAS,+BACT,UAAa,6BACb,OAAU,q0DAEZ,+BAAgC,CAC9B,MAAS,gCACT,UAAa,6BACb,OAAU,41DAEZ,aAAc,CACZ,MAAS,cACT,UAAa,6BACb,OAAU,wkKAEZ,4CAA6C,CAC3C,MAAS,4CACT,UAAa,6BACb,OAAU,4+EAEZ,8BAA+B,CAC7B,MAAS,gCACT,UAAa,6BACb,OAAU,shIAEZ,6DAA8D,CAC5D,MAAS,8DACT,UAAa,6BACb,OAAU,yrIAEZ,kCAAmC,CACjC,MAAS,oCACT,UAAa,6BACb,OAAU,6rDAEZ,kBAAmB,CACjB,MAAS,kBACT,UAAa,6BACb,OAAU,m5CAEZ,MAAS,CACP,MAAS,cACT,OAAU,otDACV,UAAa,8BAEf,yCAA0C,CACxC,MAAS,0CACT,UAAa,6BACb,OAAU,6zHAEZ,wCAAyC,CACvC,MAAS,0CACT,UAAa,6BACb,OAAU,g3EAEZ,6CAA8C,CAC5C,MAAS,8CACT,UAAa,6BACb,OAAU,w8CAEZ,6CAA8C,CAC5C,MAAS,6CACT,UAAa,6BACb,OAAU,y9CAEZ,8BAA+B,CAC7B,MAAS,8BACT,UAAa,6BACb,OAAU,isFAEZ,wCAAyC,CACvC,MAAS,wCACT,UAAa,6BACb,OAAU,+9EAEZ,4BAA6B,CAC3B,MAAS,4BACT,UAAa,6BACb,OAAU,+/DAEZ,uBAAwB,CACtB,MAAS,wBACT,UAAa,6BACb,OAAU,suJAEZ,yCAA0C,CACxC,MAAS,yCACT,UAAa,6BACb,OAAU,u0DAEZ,iBAAkB,CAChB,MAAS,yBACT,UAAa,6BACb,OAAU,+zKAEZ,kDAAmD,CACjD,MAAS,kDACT,UAAa,6BACb,OAAU,2+HAEZ,iBAAkB,CAChB,MAAS,iBACT,UAAa,6BACb,OAAU,gqGAEZ,kBAAmB,CACjB,MAAS,kBACT,UAAa,6BACb,OAAU,03DAEZ,uDAAwD,CACtD,MAAS,uDACT,UAAa,6BACb,OAAU,k8EAEZ,UAAa,CACX,MAAS,qDACT,UAAa,6BACb,OAAU,0sgBAEZ,2BAA4B,CAC1B,MAAS,4BACT,UAAa,6BACb,OAAU,mkGAEZ,kBAAmB,CACjB,MAAS,kBACT,UAAa,6BACb,OAAU,2pGAEZ,gCAAiC,CAC/B,MAAS,gCACT,UAAa,6BACb,OAAU,kyEAEZ,gCAAiC,CAC/B,MAAS,iCACT,UAAa,6BACb,OAAU,4xEAEZ,sCAAuC,CACrC,MAAS,sCACT,UAAa,6BACb,OAAU,y2FAEZ,sBAAuB,CACrB,MAAS,sBACT,UAAa,6BACb,OAAU,2tDAEZ,kCAAmC,CACjC,MAAS,mCACT,UAAa,6BACb,OAAU,+9CAEZ,8BAA+B,CAC7B,MAAS,8BACT,UAAa,6BACb,OAAU,whJAEZ,gCAAiC,CAC/B,MAAS,iCACT,UAAa,6BACb,OAAU,2jIAEZ,oCAAqC,CACnC,MAAS,oCACT,UAAa,6BACb,OAAU,ojFAEZ,+BAAgC,CAC9B,MAAS,+BACT,UAAa,6BACb,OAAU,k3HAEZ,qDAAsD,CACpD,MAAS,qDACT,UAAa,6BACb,OAAU,6kFAEZ,SAAY,CACV,MAAS,6BACT,UAAa,6BACb,OAAU,wkTAEZ,oBAAqB,CACnB,MAAS,oBACT,UAAa,6BACb,OAAU,oqGAEZ,sBAAuB,CACrB,MAAS,uBACT,UAAa,6BACb,OAAU,s0EAEZ,iCAAkC,CAChC,MAAS,kCACT,UAAa,6BACb,OAAU,itCAEZ,wBAAyB,CACvB,MAAS,wBACT,UAAa,6BACb,OAAU,oiKAEZ,+BAAgC,CAC9B,MAAS,gCACT,UAAa,6BACb,OAAU,25DAEZ,sBAAuB,CACrB,MAAS,sBACT,UAAa,6BACb,OAAU,mrEAEZ,MAAS,CACP,MAAS,2CACT,UAAa,6BACb,OAAU,u/aAEZ,kBAAmB,CACjB,MAAS,kBACT,UAAa,6BACb,OAAU,s8DAEZ,+CAAgD,CAC9C,MAAS,gDACT,UAAa,6BACb,OAAU,0nCAEZ,gBAAiB,CACf,MAAS,gBACT,UAAa,6BACb,OAAU,qvDAEZ,uDAAwD,CACtD,MAAS,uDACT,UAAa,6BACb,OAAU,sqNAEZ,qCAAsC,CACpC,MAAS,sCACT,UAAa,6BACb,OAAU,+tDAEZ,8BAA+B,CAC7B,MAAS,+BACT,UAAa,6BACb,OAAU,q2DAEZ,qDAAsD,CACpD,MAAS,sDACT,UAAa,6BACb,OAAU,mvGAEZ,0DAA2D,CACzD,MAAS,2DACT,UAAa,6BACb,OAAU,wlHAEZ,wCAAyC,CACvC,MAAS,yCACT,UAAa,6BACb,OAAU,igDAEZ,oCAAqC,CACnC,MAAS,qCACT,UAAa,6BACb,OAAU,k3EAEZ,YAAa,CACX,MAAS,oCACT,UAAa,6BACb,OAAU,8zJAEZ,kEAAmE,CACjE,MAAS,kEACT,UAAa,6BACb,OAAU,k8BAEZ,2CAA4C,CAC1C,MAAS,2CACT,UAAa,6BACb,OAAU,mqFAEZ,8CAA+C,CAC7C,MAAS,+CACT,UAAa,6BACb,OAAU,68CAEZ,iCAAkC,CAChC,MAAS,kCACT,UAAa,6BACb,OAAU,2sGAEZ,iDAAkD,CAChD,MAAS,iDACT,UAAa,6BACb,OAAU,mqPAEZ,oCAAqC,CACnC,MAAS,oCACT,UAAa,6BACb,OAAU,4qIAEZ,kBAAmB,CACjB,MAAS,kBACT,UAAa,6BACb,OAAU,gpFAEZ,iBAAkB,CAChB,MAAS,iBACT,UAAa,6BACb,OAAU,6vKAEZ,qCAAsC,CACpC,MAAS,sCACT,UAAa,6BACb,OAAU,ikEAEZ,+CAAgD,CAC9C,MAAS,gDACT,UAAa,6BACb,OAAU,ggEAEZ,2BAA4B,CAC1B,MAAS,2BACT,UAAa,6BACb,OAAU,inBAEZ,gDAAiD,CAC/C,MAAS,iDACT,UAAa,6BACb,OAAU,4yJAEZ,qCAAsC,CACpC,MAAS,qCACT,UAAa,6BACb,OAAU,4xEAEZ,oCAAqC,CACnC,MAAS,oCACT,UAAa,6BACb,OAAU,+uDAEZ,oBAAqB,CACnB,MAAS,oBACT,UAAa,6BACb,OAAU,o+FAEZ,kBAAmB,CACjB,MAAS,kBACT,UAAa,6BACb,OAAU,07EAEZ,uBAAwB,CACtB,MAAS,uBACT,UAAa,6BACb,OAAU,m2EAEZ,oDAAqD,CACnD,MAAS,oDACT,UAAa,6BACb,OAAU,4/EAEZ,0CAA2C,CACzC,MAAS,2CACT,UAAa,6BACb,OAAU,y4FAEZ,wBAAyB,CACvB,MAAS,wBACT,UAAa,6BACb,OAAU,0qFAEZ,eAAgB,CACd,MAAS,eACT,UAAa,6BACb,OAAU,8rDAEZ,+BAAgC,CAC9B,MAAS,+BACT,UAAa,6BACb,OAAU,mnDAEZ,kCAAmC,CACjC,MAAS,kCACT,UAAa,6BACb,OAAU,imHAEZ,kCAAmC,CACjC,MAAS,kCACT,UAAa,6BACb,OAAU,+rFAEZ,0CAA2C,CACzC,MAAS,2CACT,UAAa,6BACb,OAAU,ioCAEZ,yCAA0C,CACxC,MAAS,yCACT,UAAa,6BACb,OAAU,8+EAEZ,sBAAuB,CACrB,MAAS,sBACT,UAAa,6BACb,OAAU,6yGAEZ,qCAAsC,CACpC,MAAS,sCACT,UAAa,6BACb,OAAU,+3IAEZ,gBAAiB,CACf,MAAS,gBACT,UAAa,6BACb,OAAU,+pFAEZ,+CAAgD,CAC9C,MAAS,+CACT,UAAa,6BACb,OAAU,8yEAEZ,iBAAkB,CAChB,MAAS,iBACT,UAAa,6BACb,OAAU,oiFAEZ,+DAAgE,CAC9D,MAAS,+DACT,UAAa,6BACb,OAAU,upFAEZ,qCAAsC,CACpC,MAAS,qCACT,UAAa,6BACb,OAAU,4jHAEZ,sBAAuB,CACrB,MAAS,sBACT,UAAa,6BACb,OAAU,yrKAEZ,8BAA+B,CAC7B,MAAS,+BACT,UAAa,6BACb,OAAU,wcCrlBd,MAGMC,GAAS,0DACTC,GAAY,2DAGZC,GAAe,CAAC,EA0Cf,SAASjoE,GAAKA,EAAMD,GAGzB,QAFiBA,GAAWkoE,IACR70B,IAAM40B,GAAYD,IAC5B58D,KAAKnL,EACjB,CCtDA,MAAMyD,GAAK,eAyBX,SAASykE,GAAM/nE,GACb,MAAiC,KAA1BA,EAAM0B,QAAQ4B,GAAI,GAC3B,CC3BO,MAAM0kE,GAOXvoE,WAAAA,CAAY4E,EAAU4jE,EAAQC,GAC5BzlE,KAAK4B,SAAWA,EAChB5B,KAAKwlE,OAASA,EACVC,IACFzlE,KAAKylE,MAAQA,EAEjB,ECPK,SAASC,GAAMC,EAAaF,GAEjC,MAAM7jE,EAAW,CAAC,EAEZ4jE,EAAS,CAAC,EAChB,IAAI9xC,GAAS,EAEb,OAASA,EAAQiyC,EAAYvnE,QAC3BrC,OAAOoO,OAAOvI,EAAU+jE,EAAYjyC,GAAO9xB,UAC3C7F,OAAOoO,OAAOq7D,EAAQG,EAAYjyC,GAAO8xC,QAG3C,OAAO,IAAID,GAAO3jE,EAAU4jE,EAAQC,EACtC,CCrBO,SAASvU,GAAU3zD,GACxB,OAAOA,EAAMwK,aACf,CFiBAw9D,GAAOvpE,UAAU4F,SAAW,CAAC,EAE7B2jE,GAAOvpE,UAAUwpE,OAAS,CAAC,EAE3BD,GAAOvpE,UAAUypE,MAAQ,KG3BlB,MAAMG,GAMX5oE,WAAAA,CAAY4E,EAAUikE,GAEpB7lE,KAAK4B,SAAWA,EAEhB5B,KAAK6lE,UAAYA,CACnB,EAIFD,GAAK5pE,UAAUypE,MAAQ,KACvBG,GAAK5pE,UAAU8pE,SAAU,EACzBF,GAAK5pE,UAAU+pE,YAAa,EAC5BH,GAAK5pE,UAAUgqE,mBAAoB,EACnCJ,GAAK5pE,UAAUkJ,QAAS,EACxB0gE,GAAK5pE,UAAUiqE,gBAAiB,EAChCL,GAAK5pE,UAAUkqE,gBAAiB,EAChCN,GAAK5pE,UAAUmqE,uBAAwB,EACvCP,GAAK5pE,UAAUyL,iBAAkB,EACjCm+D,GAAK5pE,UAAUoqE,SAAU,ECxBzB,IAAIC,GAAS,EAEN,MAAMP,GAAUQ,KACVP,GAAaO,KACbN,GAAoBM,KACpBphE,GAASohE,KACTJ,GAAiBI,KACjBL,GAAiBK,KACjBH,GAAwBG,KAErC,SAASA,KACP,OAAO,KAAOD,EAChB,CCPA,MAAME,GAASxqE,OAAOmW,KAAKs0D,GAEpB,MAAMC,WAAoBb,GAQ/B5oE,WAAAA,CAAY4E,EAAUikE,EAAWa,EAAMjB,GACrC,IAAI/xC,GAAS,EAMb,GAJAmvB,MAAMjhD,EAAUikE,GAEhBc,GAAK3mE,KAAM,QAASylE,GAEA,kBAATiB,EACT,OAAShzC,EAAQ6yC,GAAOnoE,QAAQ,CAC9B,MAAMwoE,EAAQL,GAAO7yC,GACrBizC,GAAK3mE,KAAMumE,GAAO7yC,IAASgzC,EAAOF,EAAMI,MAAYJ,EAAMI,GAC5D,CAEJ,EAUF,SAASD,GAAKE,EAAQhqE,EAAKU,GACrBA,IAEFspE,EAAOhqE,GAAOU,EAElB,CAZAkpE,GAAYzqE,UAAUoqE,SAAU,ECbhC,MAAMU,GAAM,CAAC,EAAE7qE,eAMR,SAASm/B,GAAOqa,GAErB,MAAM7zC,EAAW,CAAC,EAEZ4jE,EAAS,CAAC,EAEhB,IAAI/jE,EAEJ,IAAKA,KAAQg0C,EAAWsxB,WACtB,GAAID,GAAIpqE,KAAK+4C,EAAWsxB,WAAYtlE,GAAO,CACzC,MAAMlE,EAAQk4C,EAAWsxB,WAAWtlE,GAC9BulE,EAAO,IAAIP,GACfhlE,EACAg0C,EAAWwxB,UAAUxxB,EAAWyxB,YAAc,CAAC,EAAGzlE,GAClDlE,EACAk4C,EAAWgwB,OAIXhwB,EAAWhuC,iBACXguC,EAAWhuC,gBAAgBuD,SAASvJ,KAEpCulE,EAAKv/D,iBAAkB,GAGzB7F,EAASH,GAAQulE,EAEjBxB,EAAOtU,GAAUzvD,IAASA,EAC1B+jE,EAAOtU,GAAU8V,EAAKnB,YAAcpkE,CACtC,CAGF,OAAO,IAAI8jE,GAAO3jE,EAAU4jE,EAAQ/vB,EAAWgwB,MACjD,CCvDO,MAAM0B,GAAQ/rC,GAAO,CAC1BqqC,MAAO,QACPwB,UAASA,CAAC9nB,EAAG19C,IACJ,SAAWA,EAAKT,MAAM,GAAG+G,cAElCg/D,WAAY,CACVK,aAAc,KACdC,aAAc,KACdC,UAAW,KACXC,UAAW,KACXC,UAAW,KACXC,WAAY,KACZC,UAAW,QCZFC,GAAMvsC,GAAO,CACxBqqC,MAAO,MACPwB,UAASA,CAAC9nB,EAAG19C,IACJ,OAASA,EAAKT,MAAM,GAAG+G,cAEhCg/D,WAAY,CAACa,QAAS,KAAMC,QAAS,KAAMC,SAAU,QCFhD,SAASC,GAAuBb,EAAYrB,GACjD,OAAOA,KAAaqB,EAAaA,EAAWrB,GAAaA,CAC3D,CCAO,SAASmC,GAAyBd,EAAYtlE,GACnD,OAAOmmE,GAAuBb,EAAYtlE,EAASmG,cACrD,CCNO,MAAMkgE,GAAQ7sC,GAAO,CAC1BqqC,MAAO,QACPyB,WAAY,CAACgB,WAAY,eACzBjB,UAAWe,GACXjB,WAAY,CAACkB,MAAO,KAAME,WAAY,QCJ3BC,GAAOhtC,GAAO,CACzB6rC,UAASA,CAAC9nB,EAAG19C,IACK,SAATA,EAAkBA,EAAO,QAAUA,EAAKT,MAAM,GAAG+G,cAE1Dg/D,WAAY,CACVsB,qBAAsB,KACtBC,WAAYvC,GACZwC,iBAAkB,KAClBC,SAAUzC,GACV0C,YAAa1C,GACb2C,aAAcxjE,GACdyjE,aAAczjE,GACd0jE,YAAa1jE,GACb2jE,aAAc3C,GACd4C,YAAa,KACbC,gBAAiB7C,GACjB8C,YAAa,KACbC,aAAclD,GACdmD,eAAgBhD,GAChBiD,iBAAkB,KAClBC,aAAcrD,GACdsD,WAAYnD,GACZoD,YAAavD,GACbwD,aAAc,KACdC,WAAYzD,GACZ0D,YAAa,KACbC,iBAAkB,KAClB9M,UAAW,KACX+M,eAAgBzD,GAChB0D,UAAW1kE,GACX2kE,SAAU,KACVC,UAAW/D,GACXgE,cAAehE,GACfiE,oBAAqBjE,GACrBkE,gBAAiB,KACjBC,SAAUhE,GACViE,gBAAiB,KACjBC,aAAcllE,GACdmlE,YAAatE,GACbuE,aAAcvE,GACdwE,aAAc,KACdC,aAAczE,GACd0E,oBAAqBvE,GACrBwE,aAAcxlE,GACdylE,aAAczlE,GACd0lE,YAAa1lE,GACb2lE,aAAc9E,GACd+E,YAAa5lE,GACb6lE,SAAU,KACVC,aAAc9lE,GACd+lE,aAAc/lE,GACdgmE,aAAchmE,GACdimE,cAAe,KACf5Y,KAAM,QC7CG6Y,GAAOhwC,GAAO,CACzBqqC,MAAO,OACPyB,WAAY,CACVmE,cAAe,iBACfC,UAAW,QACXC,QAAS,MACTC,UAAW,cAEbvE,UAAWe,GACXvgE,gBAAiB,CAAC,UAAW,WAAY,QAAS,YAClDs/D,WAAY,CAEV0E,KAAM,KACNC,OAAQzF,GACR0F,cAAezF,GACf0F,UAAW1F,GACXpsC,OAAQ,KACR+xC,MAAO,KACPC,gBAAiBhG,GACjBiG,oBAAqBjG,GACrBkG,eAAgBlG,GAChBmG,IAAK,KACL/hB,GAAI,KACJgiB,MAAOpG,GACPqG,eAAgB,KAChBC,aAAclG,GACdthC,UAAWkhC,GACXuG,SAAUvG,GACVwG,SAAUpG,GACVn6C,QAAS,KACTwgD,QAAS,KACTlgE,QAASy5D,GACT0G,KAAM,KACNviB,UAAWic,GACXuG,KAAMvnE,GACNwnE,QAAS,KACTvsE,QAAS,KACT4nB,gBAAiBg+C,GACjB4G,SAAU7G,GACV8G,aAAc1G,GACd2G,OAAQ3nE,GAAS+gE,GACjB6G,YAAa,KACbnsD,KAAM,KACNosD,SAAU,KACVC,SAAU,KACVjqE,QAAS+iE,GACTmH,MAAOnH,GACPoH,IAAK,KACLC,QAAS,KACTz/D,SAAUo4D,GACVsH,SAAUpH,GACVqH,UAAWtH,GACXuH,QAAS,KACTC,aAAc,KACdC,cAAe,KACfngC,KAAM,KACNogC,WAAY,KACZC,YAAa,KACbC,WAAY,KACZC,eAAgB9H,GAChB+H,WAAY,KACZC,QAAS5H,GACTxjD,OAAQxd,GACR6oE,OAAQjI,GACRkI,KAAM9oE,GACN2iB,KAAM,KACNomD,SAAU,KACVC,QAAShI,GACTiI,UAAWjI,GACXhqD,GAAI,KACJkyD,WAAY,KACZC,YAAa,KACbC,MAAOxI,GACPyI,UAAW,KACXC,UAAW,KACXl7D,GAAI,KACJm7D,MAAO3I,GACP4I,OAAQ,KACRC,SAAUzI,GACV0I,QAAS1I,GACT2I,UAAW/I,GACXgJ,SAAU5I,GACV6I,KAAM,KACNhc,MAAO,KACPic,KAAM,KACNC,SAAU,KACVC,KAAM,KACNC,QAAS,KACTC,KAAMtJ,GACNuJ,IAAKnqE,GACLoqE,SAAU,KACVC,IAAK,KACLC,UAAWtqE,GACX2uD,MAAO,KACP4b,OAAQ,KACRnnD,IAAK,KACLonD,UAAWxqE,GACXo/B,SAAUwhC,GACV6J,MAAO7J,GACP1oE,KAAM,KACNwyE,MAAO,KACPC,SAAU/J,GACVgK,WAAYhK,GACZiK,QAAS,KACTC,aAAc,KACdC,WAAY,KACZC,cAAe,KACfC,cAAe,KACfC,eAAgB,KAChBC,eAAgB,KAChBC,OAAQ,KACRC,SAAU,KACVC,UAAW,KACXC,iBAAkB,KAClBC,SAAU,KACVlsC,QAAS,KACTmsC,QAAS,KACTC,cAAe,KACfC,cAAe,KACfC,kBAAmB,KACnBC,OAAQ,KACRC,YAAa,KACbC,MAAO,KACPC,WAAY,KACZC,OAAQ,KACRC,UAAW,KACXC,YAAa,KACbC,WAAY,KACZC,YAAa,KACbC,WAAY,KACZC,YAAa,KACbC,OAAQ,KACRC,iBAAkB,KAClBC,UAAW,KACXC,QAAS,KACT98D,QAAS,KACT+8D,QAAS,KACTC,WAAY,KACZC,aAAc,KACdC,QAAS,KACTC,UAAW,KACX/Q,UAAW,KACXgR,WAAY,KACZC,QAAS,KACTC,iBAAkB,KAClBC,OAAQ,KACRC,aAAc,KACdC,iBAAkB,KAClBC,UAAW,KACXC,YAAa,KACbC,UAAW,KACXC,eAAgB,KAChBC,YAAa,KACbC,aAAc,KACdC,aAAc,KACdC,YAAa,KACbC,WAAY,KACZC,YAAa,KACbC,UAAW,KACXC,UAAW,KACXC,SAAU,KACVC,WAAY,KACZC,WAAY,KACZC,QAAS,KACTC,QAAS,KACTC,OAAQ,KACRC,UAAW,KACXC,WAAY,KACZC,WAAY,KACZC,aAAc,KACdC,mBAAoB,KACpBC,QAAS,KACTC,SAAU,KACVC,SAAU,KACVC,YAAa,KACbC,0BAA2B,KAC3BC,SAAU,KACVC,UAAW,KACXpU,SAAU,KACVqU,aAAc,KACdC,UAAW,KACXC,UAAW,KACXC,SAAU,KACVC,UAAW,KACXC,aAAc,KACd5hB,SAAU,KACV6hB,qBAAsB,KACtBC,SAAU,KACVC,eAAgB,KAChBC,UAAW,KACXC,QAAS,KACTC,KAAMpP,GACNqP,QAASjwE,GACT65C,QAAS,KACTq2B,KAAMlP,GACNmP,YAAa,KACbC,YAAaxP,GACbyP,QAAS,KACTC,cAAe,KACfC,oBAAqB,KACrBC,OAAQ,KACRC,QAAS,KACTC,SAAU9P,GACV+P,eAAgB,KAChB5U,IAAKiF,GACLxoB,SAAUooB,GACVgQ,SAAUhQ,GACViQ,KAAM7wE,GACN8wE,QAAS9wE,GACT+wE,QAAS/P,GACTgQ,MAAO,KACPC,OAAQrQ,GACRsQ,SAAUtQ,GACVt4D,SAAUs4D,GACVuQ,mBAAoBvQ,GACpBwQ,yBAA0BxQ,GAC1ByQ,eAAgB,KAChBzwE,MAAO,KACP4+B,KAAMx/B,GACNsxE,MAAO,KACPC,KAAM,KACNC,KAAMxxE,GACNyxE,WAAY5Q,GACZjoE,IAAK,KACL84E,OAAQ,KACRC,QAAS,KACTC,OAAQ,KACRn3E,MAAOuF,GACP6xE,KAAM,KACN73E,MAAO,KACP48D,SAAU52D,GACVhI,OAAQ,KACR85E,MAAO,KACPC,UAAW,KACX11E,KAAM,KACN21E,cAAepR,GACfqR,OAAQ,KACR55E,MAAOwoE,GACPtjD,MAAOvd,GACPkyE,KAAM,KACNC,mBAAoB,KAIpBC,MAAO,KACPC,MAAO,KACPC,QAAStR,GACTuR,KAAM,KACNC,WAAY,KACZC,QAAS,KACT/S,OAAQ1/D,GACR0yE,YAAa,KACbC,aAAc3yE,GACd4yE,YAAa,KACbC,YAAa,KACb7qD,KAAM,KACN8qD,QAAS,KACTC,QAAS,KACTC,MAAO,KACP/1D,KAAM,KACNg2D,SAAU,KACVC,SAAU,KACVxzD,MAAO,KACPyzD,QAASvS,GACTwS,QAASxS,GACTlgD,MAAO,KACP2yD,KAAM,KACNC,MAAO,KACPC,YAAa,KACbC,OAAQxzE,GACRyzE,WAAYzzE,GACZ6N,KAAM,KACN6lE,SAAU,KACVC,OAAQ,KACRC,aAAc5zE,GACd6zE,YAAa7zE,GACb8zE,SAAUlT,GACVmT,OAAQnT,GACRoT,QAASpT,GACTqT,OAAQrT,GACR3gE,OAAQ,KACRi0E,QAAS,KACTC,OAAQ,KACRC,IAAK,KACLC,YAAar0E,GACbhE,MAAO,KACPs4E,OAAQ,KACRC,UAAW1T,GACX2T,QAAS,KACTC,QAAS,KACTt0D,KAAM,KACNu0D,UAAW10E,GACX20E,UAAW,KACXjsC,QAAS,KACTksC,OAAQ,KACRC,MAAO,KACPC,OAAQ90E,GAGR+0E,kBAAmB,KACnBC,YAAa,KACbC,SAAU,KACVC,wBAAyBtU,GACzBuU,sBAAuBvU,GACvBjc,OAAQ,KACRjoD,SAAU,KACV04E,QAASp1E,GACTq1E,SAAU,KACVC,aAAc,QCrTLC,GAAMr/C,GAAO,CACxBqqC,MAAO,MACPyB,WAAY,CACVwT,aAAc,gBACdC,kBAAmB,qBACnBC,WAAY,cACZC,cAAe,iBACfC,UAAW,aACX7wB,UAAW,QACX8wB,SAAU,YACVC,SAAU,YACVC,mBAAoB,sBACpBC,0BAA2B,8BAC3BC,aAAc,gBACdC,eAAgB,kBAChBtO,YAAa,cACbuO,SAAU,WACVC,iBAAkB,oBAClBC,iBAAkB,oBAClBjqE,YAAa,eACbkqE,SAAU,YACVC,WAAY,cACZlqE,aAAc,gBACdmqE,WAAY,cACZC,SAAU,YACVC,eAAgB,mBAChBC,YAAa,eACbn5B,UAAW,aACXo5B,YAAa,eACblrE,WAAY,cACZmrE,UAAW,aACXC,2BAA4B,+BAC5BC,yBAA0B,6BAC1BhO,SAAU,WACViO,UAAW,cACXC,aAAc,iBACdC,aAAc,iBACdC,eAAgB,kBAChBC,cAAe,iBACfC,cAAe,iBACfC,UAAW,aACXC,UAAW,aACXC,YAAa,eACbC,QAAS,WACTC,YAAa,gBACbC,aAAc,iBACdC,QAAS,WACTC,QAAS,WACTC,QAAS,WACTC,SAAU,YACVC,MAAO,SACPC,UAAW,cACXC,WAAY,eACZrN,QAAS,UACTsN,WAAY,aACZrN,aAAc,eACdG,cAAe,gBACfmN,QAAS,UACT/M,SAAU,WACVC,UAAW,YACXC,iBAAkB,mBAClBC,SAAU,WACVlsC,QAAS,UACTmsC,QAAS,UACTI,OAAQ,SACRC,YAAa,cACbC,MAAO,QACPC,WAAY,aACZC,OAAQ,SACRC,UAAW,YACXC,YAAa,cACbC,WAAY,aACZC,YAAa,cACbC,WAAY,aACZC,YAAa,cACbC,OAAQ,SACRC,iBAAkB,mBAClBC,UAAW,YACX2L,MAAO,QACP1L,QAAS,UACT98D,QAAS,UACT+8D,QAAS,UACT0L,UAAW,YACXC,WAAY,aACZzL,aAAc,eACdC,QAAS,UACTC,UAAW,YACX/Q,UAAW,YACXgR,WAAY,aACZC,QAAS,UACTE,OAAQ,SACRC,aAAc,eACdC,iBAAkB,mBAClBE,YAAa,cACbC,UAAW,YACXE,YAAa,cACbC,aAAc,eACdC,aAAc,eACdC,YAAa,cACbC,WAAY,aACZC,YAAa,cACbC,UAAW,YACXuK,aAAc,eACdtK,UAAW,YACXC,SAAU,WACVC,WAAY,aACZC,WAAY,aACZC,QAAS,UACTC,QAAS,UACTC,OAAQ,SACRC,UAAW,YACXC,WAAY,aACZC,WAAY,aACZC,aAAc,eACd6J,SAAU,WACV3J,QAAS,UACTC,SAAU,WACVC,SAAU,WACVG,SAAU,WACVC,UAAW,YACXpU,SAAU,WACV9F,OAAQ,SACRoa,UAAW,YACXC,UAAW,YACXC,SAAU,WACVC,UAAW,YACXC,aAAc,eACd5hB,SAAU,WACV8hB,SAAU,WACVC,eAAgB,iBAChBC,UAAW,YACX4I,OAAQ,SACRC,iBAAkB,oBAClBC,kBAAmB,qBACnBC,WAAY,cACZC,QAAS,WACTC,cAAe,iBACfpI,eAAgB,iBAChBqI,gBAAiB,mBACjBC,eAAgB,kBAChBC,UAAW,aACX5sE,YAAa,eACb6sE,sBAAuB,yBACvBC,uBAAwB,0BACxBC,gBAAiB,mBACjBC,iBAAkB,oBAClBC,cAAe,iBACfC,eAAgB,kBAChBC,iBAAkB,oBAClB/sE,cAAe,iBACfC,YAAa,eACbiqD,SAAU,WACV8iB,WAAY,cACZC,eAAgB,kBAChBC,cAAe,iBACfC,gBAAiB,mBACjBC,OAAQ,SACRC,kBAAmB,qBACnBC,mBAAoB,sBACpBC,YAAa,eACbC,aAAc,gBACdC,WAAY,eACZC,YAAa,eACbC,SAAU,YACVC,aAAc,gBACdC,cAAe,iBACfC,aAAc,gBACdC,SAAU,aACVC,YAAa,gBACbC,YAAa,gBACbC,YAAa,eACbC,YAAa,eACbC,QAAS,WAETC,cAAe,gBACfC,cAAe,iBAEjBjZ,UAAWc,GACXhB,WAAY,CACVoZ,MAAOha,GACPuU,aAAcx1E,GACdk7E,WAAY,KACZC,SAAU,KACV1F,kBAAmB,KACnB2F,WAAYp7E,GACZq7E,UAAWr7E,GACX01E,WAAY,KACZ4F,OAAQt7E,GACRqC,cAAe,KACfk5E,cAAe,KACfC,QAASx7E,GACTy7E,UAAW,KACX9F,cAAe,KACf+F,cAAe,KACfC,YAAa,KACbC,KAAM,KACNC,MAAO,KACPC,KAAM97E,GACN+7E,GAAI,KACJC,SAAU,KACVpG,UAAW51E,GACX+kD,UAAWic,GACXib,KAAM,KACNpG,SAAU,KACVqG,cAAe,KACfpG,SAAU,KACVp2D,MAAO,KACPq2D,mBAAoB,KACpBC,0BAA2B,KAC3BC,aAAc,KACdC,eAAgB,KAChBj7E,QAAS,KACTkhF,kBAAmB,KACnBC,iBAAkB,KAClBxU,YAAa,KACbyU,OAAQ,KACRC,GAAI,KACJC,GAAI,KACJr/E,EAAG,KACHi5E,SAAU,KACVqG,cAAe,KACfC,QAASz8E,GACT08E,gBAAiB18E,GACjBwvD,UAAW,KACXvtB,QAAS,KACT06C,IAAK,KACLC,QAAS58E,GACTo2E,iBAAkB,KAClBlO,SAAUtH,GACVic,GAAI,KACJC,GAAI,KACJC,SAAU,KACVC,SAAU,KACVC,UAAWj9E,GACXq2E,iBAAkB,KAClBt7E,IAAK,KACL2lB,MAAO,KACPw8D,SAAUl9E,GACVm9E,0BAA2B,KAC3Bhf,KAAM,KACN/xD,YAAapM,GACbs2E,SAAU,KACVn9B,OAAQ,KACRikC,UAAW,KACXC,YAAa,KACb9G,WAAY,KACZlqE,aAAc,KACdixE,UAAW,KACXC,eAAgB,KAChB/G,WAAY,KACZC,SAAU,KACVC,eAAgB,KAChBC,YAAa,KACbn5B,UAAW,KACXo5B,YAAa,KACblrE,WAAY,KACZ3O,OAAQ,KACRygF,GAAI,KACJC,KAAM,KACNC,GAAI,KACJC,GAAI,KACJC,GAAI7c,GACJ8c,GAAI9c,GACJ8V,UAAW9V,GACX+V,2BAA4B,KAC5BC,yBAA0B,KAC1B+G,SAAU,KACVC,kBAAmB,KACnBC,cAAe,KACf16B,QAAS,KACT26B,QAASj+E,GACTk+E,kBAAmB,KACnBC,WAAY,KACZ3gE,OAAQ,KACRmF,KAAM,KACNomD,SAAU,KACViO,UAAWh3E,GACXi3E,aAAcj3E,GACdk3E,aAAcl3E,GACdgX,GAAI,KACJonE,YAAap+E,GACbm3E,eAAgB,KAChBkH,kBAAmB,KACnBp3B,GAAI,KACJq3B,IAAK,KACLC,UAAWv+E,GACX4F,EAAG5F,GACHw+E,GAAIx+E,GACJy+E,GAAIz+E,GACJ0+E,GAAI1+E,GACJ2+E,GAAI3+E,GACJ4+E,aAAc3d,GACd4d,iBAAkB,KAClBC,UAAW,KACXC,WAAY,KACZC,SAAU,KACVC,QAAS,KACTnV,KAAM,KACNoV,aAAc,KACd9H,cAAe,KACfC,cAAe,KACf8H,kBAAmBn/E,GACnBo/E,MAAO,KACP9H,UAAW,KACXC,UAAW,KACXC,YAAa,KACb6H,aAAc,KACdC,YAAa,KACbC,YAAa,KACb/d,KAAM,KACNge,iBAAkB,KAClBC,UAAW,KACXC,aAAc,KACdrV,IAAK,KACL1b,MAAO,KACPgxB,uBAAwB,KACxBC,sBAAuB,KACvBC,UAAW7/E,GACX8/E,UAAW,KACXvV,OAAQ,KACRnnD,IAAK,KACLkK,KAAM,KACNp1B,KAAM,KACNu/E,QAAS,KACTC,YAAa,KACbC,aAAc,KACdC,QAAS,KACTC,QAAS,KACTC,QAAS,KACTC,SAAU,KACVC,MAAO,KACPC,UAAW,KACXC,WAAY,KACZ6H,WAAY,KACZC,SAAU,KACV79D,OAAQ,KACR0oD,QAAS,KACTsN,WAAY,KACZrN,aAAc,KACdG,cAAe,KACfmN,QAAS,KACT/M,SAAU,KACVC,UAAW,KACXC,iBAAkB,KAClBC,SAAU,KACVlsC,QAAS,KACTmsC,QAAS,KACTI,OAAQ,KACRC,YAAa,KACbC,MAAO,KACPC,WAAY,KACZC,OAAQ,KACRC,UAAW,KACXC,YAAa,KACbC,WAAY,KACZC,YAAa,KACbC,WAAY,KACZC,YAAa,KACbC,OAAQ,KACRC,iBAAkB,KAClBC,UAAW,KACX2L,MAAO,KACP1L,QAAS,KACT98D,QAAS,KACT+8D,QAAS,KACT0L,UAAW,KACXC,WAAY,KACZzL,aAAc,KACdC,QAAS,KACTC,UAAW,KACX/Q,UAAW,KACXgR,WAAY,KACZC,QAAS,KACTE,OAAQ,KACRC,aAAc,KACdC,iBAAkB,KAClBE,YAAa,KACbC,UAAW,KACXE,YAAa,KACbC,aAAc,KACdC,aAAc,KACdC,YAAa,KACbC,WAAY,KACZC,YAAa,KACbC,UAAW,KACXuK,aAAc,KACdtK,UAAW,KACXC,SAAU,KACVC,WAAY,KACZC,WAAY,KACZC,QAAS,KACTC,QAAS,KACTC,OAAQ,KACRC,UAAW,KACXC,WAAY,KACZC,WAAY,KACZC,aAAc,KACd6J,SAAU,KACV3J,QAAS,KACTC,SAAU,KACVC,SAAU,KACVG,SAAU,KACVC,UAAW,KACXpU,SAAU,KACV9F,OAAQ,KACRoa,UAAW,KACXC,UAAW,KACXC,SAAU,KACVC,UAAW,KACXC,aAAc,KACd5hB,SAAU,KACV8hB,SAAU,KACVC,eAAgB,KAChBC,UAAW,KACX4I,OAAQ,KACR7sE,QAAS,KACTo0E,SAAU,KACVn0E,MAAO,KACPo0E,OAAQ,KACRC,YAAa,KACb7qC,OAAQ,KACRpoB,SAAU,KACVkzD,QAAS,KACTzH,iBAAkB34E,GAClB44E,kBAAmB54E,GACnB64E,WAAY,KACZC,QAAS,KACTzkC,KAAM,KACNgsC,WAAYrgF,GACZsgF,oBAAqB,KACrBC,iBAAkB,KAClBC,aAAc,KACdC,MAAO,KACPvQ,KAAMlP,GACN0f,MAAO,KACP3F,cAAe,KACfhC,cAAe,KACf4H,OAAQ,KACRC,UAAW5gF,GACX6gF,UAAW7gF,GACX8gF,UAAW9gF,GACX+gF,cAAe,KACfC,oBAAqB,KACrBC,eAAgB,KAChBC,UAAW,KACXxkF,SAAUukE,GACVjyC,EAAG,KACHmyD,OAAQ,KACRxQ,eAAgB,KAChByQ,KAAM,KACNC,KAAM,KACNtlB,IAAKkF,GACLmT,IAAKnT,GACL+X,gBAAiB,KACjBsI,YAAa,KACbC,UAAW,KACXC,mBAAoBvgB,GACpBwgB,iBAAkBxgB,GAClBygB,cAAezgB,GACf0gB,gBAAiB1gB,GACjB2gB,SAAU,KACVC,QAAS,KACT3jF,OAAQ,KACR4jF,OAAQ,KACRC,GAAI,KACJC,GAAI,KACJC,MAAO,KACPC,KAAM,KACNjJ,eAAgB,KAChBkJ,KAAM,KACNC,MAAO,KACPC,aAAc,KACdC,iBAAkBtiF,GAClBuiF,iBAAkBviF,GAClBwiF,aAAc,KACdC,QAAS,KACTC,YAAa,KACbC,aAAc,KACdC,MAAO,KACPC,MAAO,KACPC,YAAa,KACb5J,UAAW,KACX5sE,YAAa,KACb6sE,sBAAuBn5E,GACvBo5E,uBAAwBp5E,GACxBE,OAAQ,KACR6iF,OAAQ,KACR1J,gBAAiBpY,GACjBqY,iBAAkB,KAClBC,cAAe,KACfC,eAAgB,KAChBC,iBAAkBz5E,GAClB0M,cAAe1M,GACf2M,YAAa,KACb3S,MAAO,KACPgpF,aAAchjF,GACdijF,aAAc,KACdC,oBAAqB,KACrBC,WAAY,KACZC,cAAe,KACfC,qBAAsB,KACtBC,eAAgBriB,GAChBrK,SAAU52D,GACVujF,YAAa,KACbvrF,OAAQ,KACRwrF,QAASxjF,GACTyjF,QAASzjF,GACT05E,WAAY,KACZC,eAAgB,KAChBC,cAAe,KACf8J,WAAY,KACZ1I,cAAe,KACflJ,MAAO,KACP6R,kBAAmB,KACnBtnF,KAAM,KACNy9E,OAAQ7Y,GACRptB,GAAI,KACJkuB,UAAW,KACX8X,gBAAiB,KACjB+J,GAAI,KACJC,GAAI,KACJ9J,kBAAmB/5E,GACnBg6E,mBAAoBh6E,GACpB8jF,QAAS,KACT7J,YAAa,KACbC,aAAc,KACdC,WAAYn6E,GACZ2hE,OAAQ,KACRyY,YAAap6E,GACbu6E,cAAev6E,GACfw6E,aAAc,KACdH,SAAUr6E,GACVs6E,aAAct6E,GACd0oC,QAAS,KACT+xC,SAAUz6E,GACV06E,YAAa16E,GACb26E,YAAa36E,GACb+jF,QAAS,KACTC,WAAY,KACZ5pB,WAAY,KACZ78C,MAAO,KACP0mE,OAAQ,KACRrJ,YAAa,KACbC,YAAa,KACb3zD,EAAG,KACHg9D,GAAI,KACJC,GAAI,KACJC,iBAAkB,KAClBtJ,QAAS96E,GACTivB,EAAG,KACHo1D,GAAI,KACJC,GAAI,KACJC,iBAAkB,KAClB5hF,EAAG,KACH6hF,WAAY,QCpiBHte,GAAO1F,GAAM,CAACiC,GAAKR,GAAOc,GAAOG,GAAMuhB,IAAW,QAClDlP,GAAM/U,GAAM,CAACiC,GAAKR,GAAOc,GAAOG,GAAMwhB,IAAU,OCTvDC,GAAQ,kBACRC,GAAO,UACPC,GAAM,SA+CZ,SAASC,GAAMC,GACb,MAAO,IAAMA,EAAGliF,aAClB,CAMA,SAASmiF,GAAUD,GACjB,OAAOA,EAAG3oF,OAAO,GAAG4G,aACtB,CC1DO,MAAMiiF,GAAc,CACzBlS,QAAS,UACToD,SAAU,WACV3M,OAAQ,SACR6P,gBAAiB,kBACjBC,iBAAkB,mBAClBC,cAAe,gBACfC,eAAgB,iBAChBC,iBAAkB,mBAClBK,OAAQ,SACR5X,aAAc,eACdC,aAAc,eACdC,UAAW,YACXC,UAAW,YACXC,UAAW,YACXC,WAAY,aACZC,UAAW,YACXS,WAAY,4BCvBd,SAAeiiB,GAAAA,SAAyBA,GC0B3BC,GAAWC,GAAM,OAUjBC,GAAaD,GAAM,SAUhC,SAASA,GAAM/oF,GACb,OAQA,SAAe1B,GACb,MAAMyqF,EAASzqF,GAAQA,EAAKH,UAAYG,EAAKH,SAAS6B,IAAU,CAAC,EAEjE,GACwB,kBAAf+oF,EAAM1qF,MACb0qF,EAAM1qF,KAAO,GACW,kBAAjB0qF,EAAMjrF,QACbirF,EAAMjrF,OAAS,EAEf,MAAO,CACLO,KAAM0qF,EAAM1qF,KACZP,OAAQirF,EAAMjrF,OACdgoB,OAC0B,kBAAjBijE,EAAMjjE,QAAuBijE,EAAMjjE,QAAU,EAChDijE,EAAMjjE,YACN9kB,EAGZ,CACF,CCzCO,SAASioF,GAAkBjtF,GAEhC,OAAKA,GAA0B,kBAAVA,EAKjB,aAAcA,GAAS,SAAUA,EAC5BmC,GAASnC,EAAMmC,UAIpB,UAAWnC,GAAS,QAASA,EACxBmC,GAASnC,GAId,SAAUA,GAAS,WAAYA,EAC1B+sF,GAAM/sF,GAIR,GAnBE,EAoBX,CAMA,SAAS+sF,GAAMA,GACb,OAAO52D,GAAM42D,GAASA,EAAM1qF,MAAQ,IAAM8zB,GAAM42D,GAASA,EAAMjrF,OACjE,CAMA,SAASK,GAAS2B,GAChB,OAAOipF,GAAMjpF,GAAOA,EAAI1B,OAAS,IAAM2qF,GAAMjpF,GAAOA,EAAIpB,IAC1D,CAMA,SAASyzB,GAAMn2B,GACb,OAAOA,GAA0B,kBAAVA,EAAqBA,EAAQ,CACtD,CCvDO,MAAMktF,WAAqBjqF,MAwDhCxD,WAAAA,CAAY0tF,EAAeC,EAAwBnwC,GACjDqI,QAEsC,kBAA3B8nC,IACTnwC,EAASmwC,EACTA,OAAyBpoF,GAI3B,IAAI9B,EAAS,GAETtD,EAAU,CAAC,EACXytF,GAAc,EAwClB,GAtCID,IAMAxtF,EAHA,SAAUwtF,GACV,WAAYA,GAMZ,UAAWA,GACX,QAASA,EALC,CAACE,MAAOF,GAUX,SAAUA,EACP,CACRG,UAAW,CAACH,GACZE,MAAOF,EAAuBjrF,UAKtB,IAAIirF,IAIW,kBAAlBD,EACTjqF,EAASiqF,GAGDvtF,EAAQ4tF,OAASL,IACzBE,GAAc,EACdnqF,EAASiqF,EAAclrD,QACvBriC,EAAQ4tF,MAAQL,IAGbvtF,EAAQ6tF,SAAW7tF,EAAQ+C,QAA4B,kBAAXs6C,EAAqB,CACpE,MAAM9mB,EAAQ8mB,EAAOvoC,QAAQ,MAEd,IAAXyhB,EACFv2B,EAAQ6tF,OAASxwC,GAEjBr9C,EAAQ+C,OAASs6C,EAAOx5C,MAAM,EAAG0yB,GACjCv2B,EAAQ6tF,OAASxwC,EAAOx5C,MAAM0yB,EAAQ,GAE1C,CAEA,IAAKv2B,EAAQ0tF,OAAS1tF,EAAQ2tF,WAAa3tF,EAAQ2tF,UAAW,CAC5D,MAAMG,EAAS9tF,EAAQ2tF,UAAU3tF,EAAQ2tF,UAAU1sF,OAAS,GAExD6sF,IACF9tF,EAAQ0tF,MAAQI,EAAOvrF,SAE3B,CAEA,MAAMC,EACJxC,EAAQ0tF,OAAS,UAAW1tF,EAAQ0tF,MAChC1tF,EAAQ0tF,MAAMlrF,MACdxC,EAAQ0tF,MAQd7qF,KAAK8qF,UAAY3tF,EAAQ2tF,gBAAavoF,EAOtCvC,KAAK+qF,MAAQ5tF,EAAQ4tF,YAASxoF,EAO9BvC,KAAKX,OAASM,EAAQA,EAAMN,YAASkD,EAWrCvC,KAAKkrF,WAAQ3oF,EAObvC,KAAKmrF,KAQLnrF,KAAKw/B,QAAU/+B,EAOfT,KAAKJ,KAAOD,EAAQA,EAAMC,UAAO2C,EASjCvC,KAAK5C,KAAOotF,GAAkBrtF,EAAQ0tF,QAAU,MAOhD7qF,KAAK6qF,MAAQ1tF,EAAQ0tF,YAAStoF,EAO9BvC,KAAKS,OAAST,KAAKw/B,QAOnBx/B,KAAKgrF,OAAS7tF,EAAQ6tF,aAAUzoF,EAOhCvC,KAAKE,OAAS/C,EAAQ+C,aAAUqC,EAWhCvC,KAAKqK,MACHugF,GAAeztF,EAAQ4tF,OAAwC,kBAAxB5tF,EAAQ4tF,MAAM1gF,MACjDlN,EAAQ4tF,MAAM1gF,MACd,GAYNrK,KAAK+9D,OAOL/9D,KAAKorF,SAOLprF,KAAKqrF,KAULrrF,KAAKulB,GAEP,EAGFklE,GAAazuF,UAAUmvF,KAAO,GAC9BV,GAAazuF,UAAUoB,KAAO,GAC9BqtF,GAAazuF,UAAUyE,OAAS,GAChCgqF,GAAazuF,UAAUwjC,QAAU,GACjCirD,GAAazuF,UAAUqO,MAAQ,GAC/BogF,GAAazuF,UAAUqD,YAASkD,EAChCkoF,GAAazuF,UAAU4D,UAAO2C,EAC9BkoF,GAAazuF,UAAU8uF,eAAYvoF,EACnCkoF,GAAazuF,UAAU+uF,WAAQxoF,EAC/BkoF,GAAazuF,UAAUkvF,WAAQ3oF,EAC/BkoF,GAAazuF,UAAU6uF,WAAQtoF,EAC/BkoF,GAAazuF,UAAUgvF,YAASzoF,EAChCkoF,GAAazuF,UAAUkE,YAASqC,ECvShC,MAAMukE,GAAM,CAAC,EAAE7qE,eAGTqvF,GAAW,IAAItxE,IAEf+vE,GAAM,SACNwB,GAAgB,YAahBC,GAAgB,IAAIjlF,IAAI,CAAC,QAAS,QAAS,QAAS,QAAS,OAE7DklF,GAAmB,IAAIllF,IAAI,CAAC,KAAM,OAElCmlF,GAAO,0DAcN,SAASC,GAAaC,EAAMzuF,GACjC,IAAKA,QAAgCoF,IAArBpF,EAAQozC,SACtB,MAAM,IAAIpxC,UAAU,kCAGtB,MAAM0sF,EAAW1uF,EAAQ0uF,eAAYtpF,EAErC,IAAI64B,EAEJ,GAAIj+B,EAAQ2uF,YAAa,CACvB,GAA8B,oBAAnB3uF,EAAQ4uF,OACjB,MAAM,IAAI5sF,UACR,yDAIJi8B,EA8TJ,SAA2BywD,EAAUE,GACnC,OAAO3wD,EAEP,SAASA,EAAOv7B,EAAM0B,EAAMqC,EAAO/G,GAEjC,MAAMmvF,EAAmBvvF,MAAMF,QAAQqH,EAAMiK,UACvCy8E,EAAQC,GAAW1qF,GACzB,OAAOksF,EACLxqF,EACAqC,EACA/G,EACAmvF,EACA,CACEC,aAAc3B,EAAQA,EAAMjrF,OAAS,OAAIkD,EACzC2pF,SAAUL,EACVM,WAAY7B,EAAQA,EAAM1qF,UAAO2C,QAEnCA,EAEJ,CACF,CAlVa6pF,CAAkBP,EAAU1uF,EAAQ4uF,OAC/C,KAAO,CACL,GAA2B,oBAAhB5uF,EAAQqzC,IACjB,MAAM,IAAIrxC,UAAU,wCAGtB,GAA4B,oBAAjBhC,EAAQszC,KACjB,MAAM,IAAItxC,UAAU,yCAGtBi8B,EAiSJ,SAA0B+jB,EAAG3O,EAAKC,GAChC,OAAOrV,EAEP,SAASA,EAAO+jB,EAAG59C,EAAMqC,EAAO/G,GAE9B,MACMq6C,EADmBz6C,MAAMF,QAAQqH,EAAMiK,UACf4iC,EAAOD,EACrC,OAAO3zC,EAAMq6C,EAAG31C,EAAMqC,EAAO/G,GAAOq6C,EAAG31C,EAAMqC,EAC/C,CACF,CA1SayoF,CAAiBR,EAAU1uF,EAAQqzC,IAAKrzC,EAAQszC,KAC3D,CAGA,MAAM7R,EAAQ,CACZ2R,SAAUpzC,EAAQozC,SAClBu6C,UAAW,GACXwB,WAAYnvF,EAAQmvF,YAAc,CAAC,EACnClxD,SACAmxD,yBAA0BpvF,EAAQovF,0BAA4B,QAC9DC,UAAWrvF,EAAQsvF,gBAAkBtvF,EAAQsvF,uBAAoBlqF,EACjEspF,WACAa,mBAAoBvvF,EAAQuvF,qBAAsB,EAClDC,UAA+B,IAArBxvF,EAAQwvF,SAClBC,SAAUzvF,EAAQyvF,WAAY,EAC9BC,OAA0B,QAAlB1vF,EAAQsoE,MAAkBgV,GAAMrP,GACxC0hB,sBAAuB3vF,EAAQ2vF,uBAAyB,MACxDC,uBAAyD,IAAlC5vF,EAAQ4vF,uBAG3B3pF,EAAS4pF,GAAIpuD,EAAOgtD,OAAMrpF,GAGhC,OAAIa,GAA4B,kBAAXA,EACZA,EAIFw7B,EAAMxD,OACXwwD,EACAhtD,EAAM2R,SACN,CAAC1iC,SAAUzK,QAAUb,QACrBA,EAEJ,CAcA,SAASyqF,GAAIpuD,EAAO/+B,EAAMhD,GACxB,MAAkB,YAAdgD,EAAK0B,KAqCX,SAAiBq9B,EAAO/+B,EAAMhD,GAC5B,MAAMowF,EAAeruD,EAAMiuD,OAC3B,IAAIA,EAASI,EAEsB,QAA/BptF,EAAK63B,QAAQ3vB,eAAkD,SAAvBklF,EAAaxnB,QACvDonB,EAASpS,GACT77C,EAAMiuD,OAASA,GAGjBjuD,EAAMksD,UAAUlqF,KAAKf,GAErB,MAAM0B,EAAO2rF,GAAsBtuD,EAAO/+B,EAAK63B,SAAS,GAClD9zB,EAkPR,SAA4Bg7B,EAAO/+B,GAEjC,MAAM+D,EAAQ,CAAC,EAEf,IAAIupF,EAEA1rF,EAEJ,IAAKA,KAAQ5B,EAAKknE,WAChB,GAAa,aAATtlE,GAAuBqlE,GAAIpqE,KAAKmD,EAAKknE,WAAYtlE,GAAO,CAC1D,MAAM2B,EAASgqF,GAAexuD,EAAOn9B,EAAM5B,EAAKknE,WAAWtlE,IAE3D,GAAI2B,EAAQ,CACV,MAAOvG,EAAKU,GAAS6F,EAGnBw7B,EAAMmuD,uBACE,UAARlwF,GACiB,kBAAVU,GACPkuF,GAAiBhgE,IAAI5rB,EAAK63B,SAE1By1D,EAAa5vF,EAEbqG,EAAM/G,GAAOU,CAEjB,CACF,CAGF,GAAI4vF,EAAY,EAEsBvpF,EAAM1E,QAAU0E,EAAM1E,MAAQ,CAAC,IAC7B,QAAhC0/B,EAAMkuD,sBAAkC,aAAe,aAC3DK,CACJ,CAEA,OAAOvpF,CACT,CAvRgBypF,CAAmBzuD,EAAO/+B,GACxC,IAAIgO,EAAWy/E,GAAe1uD,EAAO/+B,GAEjC2rF,GAAc//D,IAAI5rB,EAAK63B,WACzB7pB,EAAWA,EAASwwC,QAAO,SAAUtoC,GACnC,MAAwB,kBAAVA,KvBxKM,kBADCw3E,EuByK0Bx3E,GvBvKhC,SAAfw3E,EAAMhsF,MACJ+jE,GAAMioB,EAAMhwF,OAEd+nE,GAAMioB,IALL,IAAoBA,CuB0KvB,KAUF,OAPAC,GAAQ5uD,EAAOh7B,EAAOrC,EAAM1B,GAC5B4tF,GAAY7pF,EAAOiK,GAGnB+wB,EAAMksD,UAAUp4C,MAChB9T,EAAMiuD,OAASI,EAERruD,EAAMxD,OAAOv7B,EAAM0B,EAAMqC,EAAO/G,EACzC,CAjEW2I,CAAQo5B,EAAO/+B,EAAMhD,GAGZ,sBAAdgD,EAAK0B,MAA8C,sBAAd1B,EAAK0B,KA0EhD,SAAuBq9B,EAAO/+B,GAC5B,GAAIA,EAAK8gB,MAAQ9gB,EAAK8gB,KAAK+sE,QAAU9uD,EAAM4tD,UAAW,CACpD,MACMmB,EADU9tF,EAAK8gB,KAAK+sE,OACClhF,KAAK,GAIhC,OAHOmhF,EAAWpsF,KAIhBq9B,EAAM4tD,UAAUoB,mBAAmBD,EAAWA,WAElD,CAEAE,GAAYjvD,EAAO/+B,EAAKH,SAC1B,CAtFWouF,CAAclvD,EAAO/+B,GAGZ,sBAAdA,EAAK0B,MAA8C,sBAAd1B,EAAK0B,KAsHhD,SAAuBq9B,EAAO/+B,EAAMhD,GAClC,MAAMowF,EAAeruD,EAAMiuD,OAC3B,IAAIA,EAASI,EAEK,QAAdptF,EAAKzC,MAAyC,SAAvB6vF,EAAaxnB,QACtConB,EAASpS,GACT77C,EAAMiuD,OAASA,GAGjBjuD,EAAMksD,UAAUlqF,KAAKf,GAErB,MAAM0B,EACU,OAAd1B,EAAKzC,KACDwhC,EAAM2R,SACN28C,GAAsBtuD,EAAO/+B,EAAKzC,MAAM,GACxCwG,EAuMR,SAA+Bg7B,EAAO/+B,GAEpC,MAAM+D,EAAQ,CAAC,EAEf,IAAK,MAAMiiE,KAAahmE,EAAKqnE,WAC3B,GAAuB,8BAAnBrB,EAAUtkE,KACZ,GAAIskE,EAAUllD,MAAQklD,EAAUllD,KAAK+sE,QAAU9uD,EAAM4tD,UAAW,CAC9D,MACMmB,EADU9nB,EAAUllD,KAAK+sE,OACJlhF,KAAK,GACzBmhF,EAAWpsF,KAClB,MAAMwsF,EAAmBJ,EAAWA,WAC7BI,EAAiBxsF,KACxB,MAAMK,EAAWmsF,EAAiBhnB,WAAW,GACtCnlE,EAASL,KAEhBxF,OAAOoO,OACLvG,EACAg7B,EAAM4tD,UAAUoB,mBAAmBhsF,EAASosF,UAEhD,MACEH,GAAYjvD,EAAO/+B,EAAKH,cAErB,CAEL,MAAMtC,EAAOyoE,EAAUzoE,KAEvB,IAAIG,EAEJ,GAAIsoE,EAAUtoE,OAAoC,kBAApBsoE,EAAUtoE,MACtC,GACEsoE,EAAUtoE,MAAMojB,MAChBklD,EAAUtoE,MAAMojB,KAAK+sE,QACrB9uD,EAAM4tD,UACN,CACA,MACMmB,EADU9nB,EAAUtoE,MAAMojB,KAAK+sE,OACVlhF,KAAK,GACzBmhF,EAAWpsF,KAClBhE,EAAQqhC,EAAM4tD,UAAUoB,mBAAmBD,EAAWA,WACxD,MACEE,GAAYjvD,EAAO/+B,EAAKH,eAG1BnC,EAA4B,OAApBsoE,EAAUtoE,OAAwBsoE,EAAUtoE,MAItDqG,EAAMxG,GAA2CG,CACnD,CAGF,OAAOqG,CACT,CA1PgBqqF,CAAsBrvD,EAAO/+B,GACrCgO,EAAWy/E,GAAe1uD,EAAO/+B,GASvC,OAPA2tF,GAAQ5uD,EAAOh7B,EAAOrC,EAAM1B,GAC5B4tF,GAAY7pF,EAAOiK,GAGnB+wB,EAAMksD,UAAUp4C,MAChB9T,EAAMiuD,OAASI,EAERruD,EAAMxD,OAAOv7B,EAAM0B,EAAMqC,EAAO/G,EACzC,CA/IWqxF,CAActvD,EAAO/+B,EAAMhD,GAGlB,aAAdgD,EAAK0B,KA2FX,SAAgBq9B,EAAO/+B,GACrB,GAAIA,EAAK8gB,MAAQ9gB,EAAK8gB,KAAK+sE,QAAU9uD,EAAM4tD,UAEzC,OACE5tD,EAAM4tD,UAAU2B,gBAAgBtuF,EAAK8gB,KAAK+sE,QAI9CG,GAAYjvD,EAAO/+B,EAAKH,SAC1B,CAnGW0uF,CAAOxvD,EAAO/+B,GAGL,SAAdA,EAAK0B,KAsJX,SAAcq9B,EAAO/+B,EAAMhD,GAEzB,MAAM+G,EAAQ,CAAC,EAIf,OAFA6pF,GAAY7pF,EAAO0pF,GAAe1uD,EAAO/+B,IAElC++B,EAAMxD,OAAOv7B,EAAM++B,EAAM2R,SAAU3sC,EAAO/G,EACnD,CA5JWwxF,CAAKzvD,EAAO/+B,EAAMhD,GAGT,SAAdgD,EAAK0B,KAqKX,SAAc49C,EAAGt/C,GACf,OAAOA,EAAKtC,KACd,CAtKW8nB,CAAKuZ,EAAO/+B,QADrB,CAGF,CAoLA,SAAS2tF,GAAQ5uD,EAAOh7B,EAAOrC,EAAM1B,GAEf,kBAAT0B,GAAqBA,IAASq9B,EAAM2R,UAAY3R,EAAMguD,WAC/DhpF,EAAM/D,KAAOA,EAEjB,CAYA,SAAS4tF,GAAY7pF,EAAOiK,GAC1B,GAAIA,EAASzP,OAAS,EAAG,CACvB,MAAMb,EAAQsQ,EAASzP,OAAS,EAAIyP,EAAWA,EAAS,GAEpDtQ,IACFqG,EAAMiK,SAAWtQ,EAErB,CACF,CA+KA,SAAS+vF,GAAe1uD,EAAO/+B,GAE7B,MAAMgO,EAAW,GACjB,IAAI6lB,GAAS,EAIb,MAAM46D,EAAe1vD,EAAM+tD,SAAW,IAAI3yE,IAAQsxE,GAElD,OAAS53D,EAAQ7zB,EAAKgO,SAASzP,QAAQ,CACrC,MAAM2X,EAAQlW,EAAKgO,SAAS6lB,GAE5B,IAAI72B,EAEJ,GAAI+hC,EAAM+tD,SAAU,CAClB,MAAMvvF,EACW,YAAf2Y,EAAMxU,KACFwU,EAAM2hB,QACS,sBAAf3hB,EAAMxU,MACW,sBAAfwU,EAAMxU,KACNwU,EAAM3Y,UACNmF,EAER,GAAInF,EAAM,CACR,MAAM6zC,EAAQq9C,EAAaviF,IAAI3O,IAAS,EACxCP,EAAMO,EAAO,IAAM6zC,EACnBq9C,EAAa7jF,IAAIrN,EAAM6zC,EAAQ,EACjC,CACF,CAEA,MAAM7tC,EAAS4pF,GAAIpuD,EAAO7oB,EAAOlZ,QAClB0F,IAAXa,GAAsByK,EAASjN,KAAKwC,EAC1C,CAEA,OAAOyK,CACT,CAcA,SAASu/E,GAAexuD,EAAOn9B,EAAMlE,GACnC,MAAMypE,EN1jBD,SAAc6lB,EAAQtvF,GAC3B,MAAMioE,EAAStU,GAAU3zD,GACzB,IAAIkE,EAAOlE,EACPgxF,EAAO3oB,GAEX,GAAIJ,KAAUqnB,EAAOrnB,OACnB,OAAOqnB,EAAOjrF,SAASirF,EAAOrnB,OAAOA,IAGvC,GAAIA,EAAOpnE,OAAS,GAA4B,SAAvBonE,EAAOxkE,MAAM,EAAG,IAAiB6oF,GAAMthF,KAAKhL,GAAQ,CAE3E,GAAwB,MAApBA,EAAM+D,OAAO,GAAY,CAE3B,MAAMi8C,EAAOhgD,EAAMyD,MAAM,GAAG/B,QAAQ6qF,GAAMI,IAC1CzoF,EAAO,OAAS87C,EAAKj8C,OAAO,GAAG4G,cAAgBq1C,EAAKv8C,MAAM,EAC5D,KAAO,CAEL,MAAMu8C,EAAOhgD,EAAMyD,MAAM,GAEzB,IAAK8oF,GAAKvhF,KAAKg1C,GAAO,CACpB,IAAIixC,EAASjxC,EAAKt+C,QAAQ8qF,GAAKC,IAEN,MAArBwE,EAAOltF,OAAO,KAChBktF,EAAS,IAAMA,GAGjBjxF,EAAQ,OAASixF,CACnB,CACF,CAEAD,EAAO9nB,EACT,CAEA,OAAO,IAAI8nB,EAAK9sF,EAAMlE,EACxB,CMwhBekxF,CAAK7vD,EAAMiuD,OAAQprF,GAGhC,KACY,OAAVlE,QACUgF,IAAVhF,GACkB,kBAAVA,GAAsBqqD,OAAOv/C,MAAM9K,IAH7C,CAeA,GAPId,MAAMF,QAAQgB,KAGhBA,EAAQypE,EAAKf,eC7hBV,SAAmBY,EAAQ1pE,GAChC,MAAMuxF,EAAWvxF,GAAW,CAAC,EAK7B,OAF4C,KAA9B0pE,EAAOA,EAAOzoE,OAAS,GAAY,IAAIyoE,EAAQ,IAAMA,GAGhEtzC,MACEm7D,EAASC,SAAW,IAAM,IACzB,MACsB,IAArBD,EAASE,QAAoB,GAAK,MAEtC7vF,MACL,CDghBkC8vF,CAAOtxF,GAAgBA,EEnkBzCg2B,KAAK,KAAKx0B,QFukBF,UAAlBioE,EAAKplE,SAAsB,CAC7B,IAAIuyC,EACe,kBAAV52C,EAAqBA,EA6BlC,SAAoBqhC,EAAOrhC,GAEzB,MAAM6F,EAAS,CAAC,EAEhB,IACE0rF,GAAcvxF,EAAOwxF,EACvB,CAAE,MAAO1uF,GACP,IAAKu+B,EAAM8tD,mBAAoB,CAC7B,MAAM3B,EAA8B1qF,EAC9Bm/B,EAAU,IAAIirD,GAAa,iCAAkC,CACjEK,UAAWlsD,EAAMksD,UACjBC,QACAC,OAAQ,QACR9qF,OAAQ,6BAKV,MAHAs/B,EAAQ2rD,KAAOvsD,EAAMitD,eAAYtpF,EACjCi9B,EAAQja,IAAMmmE,GAAO,gCAEflsD,CACR,CACF,CAEA,OAAOp8B,EAaP,SAAS2rF,EAAS3xF,EAAMG,GACtB,IAAIV,EAAMO,EAEc,OAApBP,EAAImE,MAAM,EAAG,KACS,SAApBnE,EAAImE,MAAM,EAAG,KAAenE,EAAM,MAAQA,EAAImE,MAAM,IACxDnE,EAAMA,EAAIoC,QAAQssF,GAAeyD,KAGnC5rF,EAAOvG,GAAOU,CAChB,CACF,CA1E0C0xF,CAAWrwD,EAAO3c,OAAO1kB,IAM/D,MAJoC,QAAhCqhC,EAAMkuD,wBACR34C,EAqKN,SAAoC+6C,GAElC,MAAMC,EAAY,CAAC,EAEnB,IAAIxM,EAEJ,IAAKA,KAAQuM,EACPpoB,GAAIpqE,KAAKwyF,EAAWvM,KACtBwM,EAAUC,GAA0BzM,IAASuM,EAAUvM,IAI3D,OAAOwM,CACT,CAlLoBE,CAA2Bl7C,IAGpC,CAAC,QAASA,EACnB,CAEA,MAAO,CAC8B,UAAnCvV,EAAM2tD,0BAAwCvlB,EAAKvB,MAC/C0kB,GAAYnjB,EAAKplE,WAAaolE,EAAKplE,SACnColE,EAAKnB,UACTtoE,EAxBF,CA0BF,CAyEA,SAAS2vF,GAAsBtuD,EAAOxhC,EAAMkyF,GAE1C,IAAIlsF,EAEJ,GAAKksF,EAEE,GAAIlyF,EAAK4N,SAAS,KAAM,CAC7B,MAAMukF,EAAcnyF,EAAK0K,MAAM,KAC/B,IAEIjI,EAFA6zB,GAAS,EAIb,OAASA,EAAQ67D,EAAYnxF,QAAQ,CAEnC,MAAMqD,EAAO+tF,GAAiBD,EAAY77D,IACtC,CAACnyB,KAAM,aAAcnE,KAAMmyF,EAAY77D,IACvC,CAACnyB,KAAM,UAAWhE,MAAOgyF,EAAY77D,IACzC7zB,EAAOA,EACH,CACE0B,KAAM,mBACN4D,OAAQtF,EACR+B,SAAUH,EACVguF,SAAUC,QAAQh8D,GAAuB,YAAdjyB,EAAKF,MAChCouF,UAAU,GAEZluF,CACN,CAGA2B,EAASvD,CACX,MACEuD,EACEosF,GAAiBpyF,KAAU,SAASmL,KAAKnL,GACrC,CAACmE,KAAM,aAAcnE,QACrB,CAACmE,KAAM,UAAWhE,MAAOH,QA7B/BgG,EAAS,CAAC7B,KAAM,UAAWhE,MAAOH,GAkCpC,GAAoB,YAAhBgG,EAAO7B,KAAoB,CAC7B,MAAMnE,EAAmDgG,EAAO7F,MAEhE,OAAOupE,GAAIpqE,KAAKkiC,EAAM0tD,WAAYlvF,GAAQwhC,EAAM0tD,WAAWlvF,GAAQA,CACrE,CAGA,GAAIwhC,EAAM4tD,UACR,OAAO5tD,EAAM4tD,UAAUoB,mBAAmBxqF,GAG5CyqF,GAAYjvD,EACd,CAOA,SAASivD,GAAYjvD,EAAOisD,GAC1B,MAAMrrD,EAAU,IAAIirD,GAClB,sDACA,CACEK,UAAWlsD,EAAMksD,UACjBD,QACAG,OAAQ,aACR9qF,OAAQ,6BAMZ,MAHAs/B,EAAQ2rD,KAAOvsD,EAAMitD,eAAYtpF,EACjCi9B,EAAQja,IAAMmmE,GAAO,qDAEflsD,CACR,CA6BA,SAAS4vD,GAA0BzM,GACjC,IAAI5pC,EAAK4pC,EAAK1jF,QAAQ8qF,GAAK6F,IAG3B,MADuB,QAAnB72C,EAAG/3C,MAAM,EAAG,KAAc+3C,EAAK,IAAMA,GAClCA,CACT,CAYA,SAASi2C,GAAQ7vC,EAAG0wC,GAClB,OAAOA,EAAG3nF,aACZ,CAUA,SAAS0nF,GAAO3F,GACd,MAAO,IAAMA,EAAGliF,aAClB,CGnzBO,MAAM+nF,GAAgB,CAC3Bh2D,OAAQ,CAAC,QACT0yC,KAAM,CAAC,aAAc,MAAO,MAAO,KACnC7rD,KAAM,CAAC,UACP8sD,WAAY,CAAC,SAAU,SACvB5lD,KAAM,CAAC,IAAK,OAAQ,OAAQ,QAC5BkoE,KAAM,CAAC,YACPrhB,OAAQ,KACRY,SAAU,CAAC,QACX8F,KAAM,CAAC,IAAK,QACZM,OAAQ,CAAC,SACT53E,IAAK,CACH,QACA,QACA,SACA,MACA,QACA,SACA,SACA,QACA,UChBEunE,GAAe,CAAC,EAuCtB,SAAS2nB,GAAIzvF,EAAOyyF,EAAiBC,GACnC,GAqDF,SAAc1yF,GACZ,OAAOmyF,QAAQnyF,GAA0B,kBAAVA,EACjC,CAvDMsC,CAAKtC,GAAQ,CACf,GAAI,UAAWA,EACb,MAAsB,SAAfA,EAAMgE,MAAoB0uF,EAAmB1yF,EAAMA,MAAX,GAGjD,GAAIyyF,GAAmB,QAASzyF,GAASA,EAAM0uE,IAC7C,OAAO1uE,EAAM0uE,IAGf,GAAI,aAAc1uE,EAChB,OAAOq4C,GAAIr4C,EAAMsQ,SAAUmiF,EAAiBC,EAEhD,CAEA,OAAIxzF,MAAMF,QAAQgB,GACTq4C,GAAIr4C,EAAOyyF,EAAiBC,GAG9B,EACT,CAcA,SAASr6C,GAAIixB,EAAQmpB,EAAiBC,GAEpC,MAAM7sF,EAAS,GACf,IAAIswB,GAAS,EAEb,OAASA,EAAQmzC,EAAOzoE,QACtBgF,EAAOswB,GAASs5D,GAAInmB,EAAOnzC,GAAQs8D,EAAiBC,GAGtD,OAAO7sF,EAAOmwB,KAAK,GACrB,CCzEO,SAAS0Z,GAAOiiC,EAAMvvE,EAAOkwD,EAAQ6S,GAC1C,MAAMziE,EAAMivE,EAAK9wE,OACjB,IAEI8xF,EAFAC,EAAa,EAajB,GAPExwF,EADEA,EAAQ,GACDA,EAAQM,EAAM,EAAIA,EAAMN,EAEzBA,EAAQM,EAAMA,EAAMN,EAE9BkwD,EAASA,EAAS,EAAIA,EAAS,EAG3B6S,EAAMtkE,OAAS,IACjB8xF,EAAazzF,MAAMkmF,KAAKjgB,GACxBwtB,EAAW9iE,QAAQztB,EAAOkwD,GAE1Bqf,EAAKjiC,UAAUijD,QAMf,IAHIrgC,GAAQqf,EAAKjiC,OAAOttC,EAAOkwD,GAGxBsgC,EAAaztB,EAAMtkE,QACxB8xF,EAAaxtB,EAAM1hE,MAAMmvF,EAAYA,EAAa,KAClDD,EAAW9iE,QAAQztB,EAAO,GAE1BuvE,EAAKjiC,UAAUijD,GACfC,GAAc,IACdxwF,GAAS,GAGf,CAkBO,SAASiB,GAAKsuE,EAAMxM,GACzB,OAAIwM,EAAK9wE,OAAS,GAChB6uC,GAAOiiC,EAAMA,EAAK9wE,OAAQ,EAAGskE,GACtBwM,GAEFxM,CACT,CCnDO,MAAM0tB,GAOXpzF,WAAAA,CAAYs7D,GAEVt4D,KAAKmpB,KAAOmvC,EAAU,IAAIA,GAAW,GAErCt4D,KAAKqwF,MAAQ,EACf,CAWAtkF,GAAAA,CAAI2nB,GACF,GAAIA,EAAQ,GAAKA,GAAS1zB,KAAKmpB,KAAK/qB,OAAS4B,KAAKqwF,MAAMjyF,OACtD,MAAM,IAAIkyF,WAAW,wBAA0B58D,EAAQ,kCAAoC1zB,KAAKmpB,KAAK/qB,OAAS4B,KAAKqwF,MAAMjyF,QAAU,KAErI,OAAIs1B,EAAQ1zB,KAAKmpB,KAAK/qB,OAAe4B,KAAKmpB,KAAKuK,GACxC1zB,KAAKqwF,MAAMrwF,KAAKqwF,MAAMjyF,OAASs1B,EAAQ1zB,KAAKmpB,KAAK/qB,OAAS,EACnE,CAMA,UAAIA,GACF,OAAO4B,KAAKmpB,KAAK/qB,OAAS4B,KAAKqwF,MAAMjyF,MACvC,CASAid,KAAAA,GAEE,OADArb,KAAKuwF,UAAU,GACRvwF,KAAKqwF,MAAM39C,KACpB,CAaA1xC,KAAAA,CAAMrB,EAAOM,GAEX,MAAMuwF,EAAe,OAARvwF,QAAwBsC,IAARtC,EAAoB2nD,OAAO6oC,kBAAoBxwF,EAC5E,GAAIuwF,EAAOxwF,KAAKmpB,KAAK/qB,OACnB,OAAO4B,KAAKmpB,KAAKnoB,MAAMrB,EAAO6wF,GAEhC,GAAI7wF,EAAQK,KAAKmpB,KAAK/qB,OACpB,OAAO4B,KAAKqwF,MAAMrvF,MAAMhB,KAAKqwF,MAAMjyF,OAASoyF,EAAOxwF,KAAKmpB,KAAK/qB,OAAQ4B,KAAKqwF,MAAMjyF,OAASuB,EAAQK,KAAKmpB,KAAK/qB,QAAQsyF,UAErH,MAAMxhB,EAAOlvE,KAAKmpB,KAAKnoB,MAAMrB,GAE7B,OADAuvE,EAAKtuE,QAAQZ,KAAKqwF,MAAMrvF,MAAMhB,KAAKqwF,MAAMjyF,OAASoyF,EAAOxwF,KAAKmpB,KAAK/qB,QAAQsyF,WACpExhB,CACT,CAsBAjiC,MAAAA,CAAOttC,EAAOgxF,EAAajuB,GAEzB,MAAMzxB,EAAQ0/C,GAAe,EAC7B3wF,KAAKuwF,UAAU14E,KAAK+4E,MAAMjxF,IAC1B,MAAMkxF,EAAU7wF,KAAKqwF,MAAMpjD,OAAOjtC,KAAKqwF,MAAMjyF,OAAS6yC,EAAO2W,OAAO6oC,mBAEpE,OADI/tB,GAAOouB,GAAY9wF,KAAKmpB,KAAMu5C,GAC3BmuB,EAAQH,SACjB,CAUAh+C,GAAAA,GAEE,OADA1yC,KAAKuwF,UAAU3oC,OAAO6oC,mBACfzwF,KAAKmpB,KAAKupB,KACnB,CAWA9xC,IAAAA,CAAKmwF,GACH/wF,KAAKuwF,UAAU3oC,OAAO6oC,mBACtBzwF,KAAKmpB,KAAKvoB,KAAKmwF,EACjB,CAWAC,QAAAA,CAAStuB,GACP1iE,KAAKuwF,UAAU3oC,OAAO6oC,mBACtBK,GAAY9wF,KAAKmpB,KAAMu5C,EACzB,CAWAt1C,OAAAA,CAAQ2jE,GACN/wF,KAAKuwF,UAAU,GACfvwF,KAAKqwF,MAAMzvF,KAAKmwF,EAClB,CAWAE,WAAAA,CAAYvuB,GACV1iE,KAAKuwF,UAAU,GACfO,GAAY9wF,KAAKqwF,MAAO3tB,EAAMguB,UAChC,CAcAH,SAAAA,CAAUtkE,GACR,KAAIA,IAAMjsB,KAAKmpB,KAAK/qB,QAAU6tB,EAAIjsB,KAAKmpB,KAAK/qB,QAAgC,IAAtB4B,KAAKqwF,MAAMjyF,QAAgB6tB,EAAI,GAA0B,IAArBjsB,KAAKmpB,KAAK/qB,QACpG,GAAI6tB,EAAIjsB,KAAKmpB,KAAK/qB,OAAQ,CAExB,MAAMyyF,EAAU7wF,KAAKmpB,KAAK8jB,OAAOhhB,EAAG27B,OAAO6oC,mBAC3CK,GAAY9wF,KAAKqwF,MAAOQ,EAAQH,UAClC,KAAO,CAEL,MAAMG,EAAU7wF,KAAKqwF,MAAMpjD,OAAOjtC,KAAKmpB,KAAK/qB,OAAS4B,KAAKqwF,MAAMjyF,OAAS6tB,EAAG27B,OAAO6oC,mBACnFK,GAAY9wF,KAAKmpB,KAAM0nE,EAAQH,UACjC,CACF,EAeF,SAASI,GAAY5hB,EAAMmhB,GAEzB,IAAIF,EAAa,EACjB,GAAIE,EAAMjyF,OAAS,IACjB8wE,EAAKtuE,QAAQyvF,QAEb,KAAOF,EAAaE,EAAMjyF,QACxB8wE,EAAKtuE,QAAQyvF,EAAMrvF,MAAMmvF,EAAYA,EAAa,MAClDA,GAAc,GAGpB,CCzOO,SAASe,GAAYC,GAE1B,MAAMC,EAAQ,CAAC,EACf,IAEIxrE,EAEAyrE,EAEAC,EAEAC,EAEArB,EAEAsB,EAEAC,EAdA/9D,GAAS,EAeb,MAAMg+D,EAAS,IAAItB,GAAae,GAChC,OAASz9D,EAAQg+D,EAAOtzF,QAAQ,CAC9B,KAAOs1B,KAAS09D,GACd19D,EAAQ09D,EAAM19D,GAMhB,GAJA9N,EAAQ8rE,EAAO3lF,IAAI2nB,GAIfA,GAA2B,cAAlB9N,EAAM,GAAGrkB,MAA0D,mBAAlCmwF,EAAO3lF,IAAI2nB,EAAQ,GAAG,GAAGnyB,OACrEiwF,EAAY5rE,EAAM,GAAG+rE,WAAWD,OAChCJ,EAAa,EACTA,EAAaE,EAAUpzF,QAA4C,oBAAlCozF,EAAUF,GAAY,GAAG/vF,OAC5D+vF,GAAc,GAEZA,EAAaE,EAAUpzF,QAA4C,YAAlCozF,EAAUF,GAAY,GAAG/vF,MAC5D,OAAS+vF,EAAaE,EAAUpzF,QACQ,YAAlCozF,EAAUF,GAAY,GAAG/vF,MAGS,cAAlCiwF,EAAUF,GAAY,GAAG/vF,OAC3BiwF,EAAUF,GAAY,GAAGM,6BAA8B,EACvDN,KAOR,GAAiB,UAAb1rE,EAAM,GACJA,EAAM,GAAGisE,cACX91F,OAAOoO,OAAOinF,EAAOU,GAAWJ,EAAQh+D,IACxCA,EAAQ09D,EAAM19D,GACd+9D,GAAO,QAIN,GAAI7rE,EAAM,GAAGmsE,WAAY,CAG5B,IAFAT,EAAa59D,EACb29D,OAAY9uF,EACL+uF,MACLC,EAAaG,EAAO3lF,IAAIulF,GACG,eAAvBC,EAAW,GAAGhwF,MAAgD,oBAAvBgwF,EAAW,GAAGhwF,OACjC,UAAlBgwF,EAAW,KACTF,IACFK,EAAO3lF,IAAIslF,GAAW,GAAG9vF,KAAO,mBAElCgwF,EAAW,GAAGhwF,KAAO,aACrB8vF,EAAYC,GAMdD,IAEFzrE,EAAM,GAAG3lB,IAAM,IACVyxF,EAAO3lF,IAAIslF,GAAW,GAAG1xF,OAI9BuwF,EAAawB,EAAO1wF,MAAMqwF,EAAW39D,GACrCw8D,EAAW9iE,QAAQxH,GACnB8rE,EAAOzkD,OAAOokD,EAAW39D,EAAQ29D,EAAY,EAAGnB,GAEpD,CACF,CAIA,OADAjjD,GAAOkkD,EAAa,EAAGvpC,OAAO6oC,kBAAmBiB,EAAO1wF,MAAM,KACtDywF,CACV,CAYA,SAASK,GAAWJ,EAAQM,GAC1B,MAAMC,EAAQP,EAAO3lF,IAAIimF,GAAY,GAC/Bz8D,EAAUm8D,EAAO3lF,IAAIimF,GAAY,GACvC,IAAIE,EAAgBF,EAAa,EAEjC,MAAMG,EAAiB,GACjBC,EAAYH,EAAMN,YAAcp8D,EAAQ88D,OAAOJ,EAAMJ,aAAaI,EAAMtyF,OACxE2yF,EAAcF,EAAUV,OAExBN,EAAQ,GAERmB,EAAO,CAAC,EAEd,IAAIC,EAEAC,EACA/+D,GAAS,EAETzd,EAAUg8E,EACVn0B,EAAS,EACTn+D,EAAQ,EACZ,MAAM+yF,EAAS,CAAC/yF,GAIhB,KAAOsW,GAAS,CAEd,KAAOy7E,EAAO3lF,MAAMmmF,GAAe,KAAOj8E,IAG1Ck8E,EAAevxF,KAAKsxF,GACfj8E,EAAQ07E,aACXa,EAASj9D,EAAQo9D,YAAY18E,GACxBA,EAAQme,MACXo+D,EAAO5xF,KAAK,MAEV6xF,GACFL,EAAUQ,WAAW38E,EAAQtW,OAE3BsW,EAAQ27E,8BACVQ,EAAUS,oCAAqC,GAEjDT,EAAUU,MAAMN,GACZv8E,EAAQ27E,8BACVQ,EAAUS,wCAAqCtwF,IAKnDkwF,EAAWx8E,EACXA,EAAUA,EAAQme,IACpB,CAKA,IADAne,EAAUg8E,IACDv+D,EAAQ4+D,EAAYl0F,QAGD,SAA1Bk0F,EAAY5+D,GAAO,IAA+C,UAA9B4+D,EAAY5+D,EAAQ,GAAG,IAAkB4+D,EAAY5+D,GAAO,GAAGnyB,OAAS+wF,EAAY5+D,EAAQ,GAAG,GAAGnyB,MAAQ+wF,EAAY5+D,GAAO,GAAG/zB,MAAMC,OAAS0yF,EAAY5+D,GAAO,GAAGzzB,IAAIL,OAC3MD,EAAQ+zB,EAAQ,EAChBg/D,EAAO9xF,KAAKjB,GAEZsW,EAAQ07E,gBAAapvF,EACrB0T,EAAQw8E,cAAWlwF,EACnB0T,EAAUA,EAAQme,MAqBtB,IAhBAg+D,EAAUV,OAAS,GAKfz7E,GAEFA,EAAQ07E,gBAAapvF,EACrB0T,EAAQw8E,cAAWlwF,GAEnBmwF,EAAOhgD,MAKThf,EAAQg/D,EAAOt0F,OACRs1B,KAAS,CACd,MAAM1yB,EAAQsxF,EAAYtxF,MAAM0xF,EAAOh/D,GAAQg/D,EAAOh/D,EAAQ,IACxD/zB,EAAQwyF,EAAez/C,MAC7B0+C,EAAMxwF,KAAK,CAACjB,EAAOA,EAAQqB,EAAM5C,OAAS,IAC1CszF,EAAOzkD,OAAOttC,EAAO,EAAGqB,EAC1B,CAGA,IAFAowF,EAAMV,UACNh9D,GAAS,IACAA,EAAQ09D,EAAMhzF,QACrBm0F,EAAKz0B,EAASszB,EAAM19D,GAAO,IAAMoqC,EAASszB,EAAM19D,GAAO,GACvDoqC,GAAUszB,EAAM19D,GAAO,GAAK09D,EAAM19D,GAAO,GAAK,EAEhD,OAAO6+D,CACT,CChNA,MAAMt2F,GAAiB,CAAC,EAAEA,eAgC1B,SAAS82F,GAAgBn9C,EAAKo9C,GAE5B,IAAIC,EAEJ,IAAKA,KAAQD,EAAW,CACtB,MAEM7pE,GAFQltB,GAAeS,KAAKk5C,EAAKq9C,GAAQr9C,EAAIq9C,QAAQ1wF,KAEpCqzC,EAAIq9C,GAAQ,CAAC,GAE9B5C,EAAQ2C,EAAUC,GAExB,IAAI9wE,EAEJ,GAAIkuE,EACF,IAAKluE,KAAQkuE,EAAO,CACbp0F,GAAeS,KAAKysB,EAAMhH,KAAOgH,EAAKhH,GAAQ,IACnD,MAAM5kB,EAAQ8yF,EAAMluE,GACpB+wE,GAEE/pE,EAAKhH,GACL1lB,MAAMF,QAAQgB,GAASA,EAAQA,EAAQ,CAACA,GAAS,GAErD,CAEJ,CACF,CAaA,SAAS21F,GAAWC,EAAUjkB,GAC5B,IAAIx7C,GAAS,EAEb,MAAM0/D,EAAS,GAEf,OAAS1/D,EAAQw7C,EAAK9wE,SAEE,UAApB8wE,EAAKx7C,GAAO/sB,IAAkBwsF,EAAWC,GAAQxyF,KAAKsuE,EAAKx7C,IAG/DuZ,GAAOkmD,EAAU,EAAG,EAAGC,EACzB,CCvEO,MAAMC,GAAaC,GAAW,YAcxBC,GAAoBD,GAAW,cAuB/BE,GAAaF,GAAW,uBAa9B,SAASG,GAAatxE,GAC3B,OAGW,OAATA,IAAkBA,EAAO,IAAe,MAATA,EAEnC,CAaO,MAAMuxE,GAAaJ,GAAW,MAoBxBK,GAAgBL,GAAW,cAe3BM,GAAmBN,GAAW,kBAiBpC,SAASO,GAAmB1xE,GACjC,OAAgB,OAATA,GAAiBA,GAAQ,CAClC,CAWO,SAAS2xE,GAA0B3xE,GACxC,OAAgB,OAATA,IAAkBA,EAAO,GAAc,KAATA,EACvC,CAiBO,SAAS4xE,GAAc5xE,GAC5B,OAAiB,IAAVA,IAAyB,IAAVA,GAAwB,KAATA,CACvC,CAuBO,MAAM6xE,GAAqBV,GAAW,gBAsBhCW,GAAoBX,GAAW,MAU5C,SAASA,GAAWY,GAClB,OAUA,SAAe/xE,GACb,OAAgB,OAATA,GAAiBA,GAAQ,GAAK+xE,EAAM3rF,KAAK0Z,OAAOC,aAAaC,GACtE,CACF,CC7MO,SAASgyE,GAAa79D,EAASwR,EAAIvmC,EAAMguE,GAC9C,MAAM6kB,EAAQ7kB,EAAMA,EAAM,EAAI3nB,OAAO6oC,kBACrC,IAAI/rD,EAAO,EACX,OAGA,SAAeviB,GACb,GAAI4xE,GAAc5xE,GAEhB,OADAmU,EAAQ21B,MAAM1qD,GACPsoD,EAAO1nC,GAEhB,OAAO2lB,EAAG3lB,EACZ,EAGA,SAAS0nC,EAAO1nC,GACd,OAAI4xE,GAAc5xE,IAASuiB,IAAS0vD,GAClC99D,EAAQ+9D,QAAQlyE,GACT0nC,IAETvzB,EAAQs2B,KAAKrrD,GACNumC,EAAG3lB,GACZ,CACF,CClDO,MAAMhiB,GAAU,CACrBm0F,SASF,SAA2Bh+D,GACzB,MAAMi+D,EAAej+D,EAAQk+D,QAAQx0F,KAAKqyF,OAAOa,WAAWuB,gBAM5D,SAAoCtyE,GAClC,GAAa,OAATA,EAEF,YADAmU,EAAQ+9D,QAAQlyE,GAMlB,OAHAmU,EAAQ21B,MAAM,cACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,cACNunC,GAAa79D,EAASi+D,EAAc,aAC7C,IAGA,SAA0BpyE,GAExB,OADAmU,EAAQ21B,MAAM,aACPyoC,EAAUvyE,EACnB,IAnBA,IAAIswE,EACJ,OAAO8B,EAqBP,SAASG,EAAUvyE,GACjB,MAAM8vE,EAAQ37D,EAAQ21B,MAAM,YAAa,CACvC4lC,YAAa,OACbY,aAMF,OAJIA,IACFA,EAASr+D,KAAO69D,GAElBQ,EAAWR,EACJtxE,EAAKwB,EACd,CAGA,SAASxB,EAAKwB,GACZ,OAAa,OAATA,GACFmU,EAAQs2B,KAAK,aACbt2B,EAAQs2B,KAAK,kBACbt2B,EAAQ+9D,QAAQlyE,IAGd0xE,GAAmB1xE,IACrBmU,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,aACN8nC,IAITp+D,EAAQ+9D,QAAQlyE,GACTxB,EACT,CACF,GCvDO,MAAM7Z,GAAW,CACtBwtF,SAcF,SAA4Bh+D,GAC1B,MAAM8hB,EAAOp4C,KAEPqK,EAAQ,GACd,IAEIsqF,EAEAC,EAEAC,EANAC,EAAY,EAOhB,OAAOn1F,EAGP,SAASA,EAAMwiB,GAWb,GAAI2yE,EAAYzqF,EAAMjM,OAAQ,CAC5B,MAAM2yF,EAAO1mF,EAAMyqF,GAEnB,OADA18C,EAAKke,eAAiBy6B,EAAK,GACpBz6D,EAAQk+D,QAAQzD,EAAK,GAAGgE,aAAcC,EAAkBC,EAAxD3+D,CAA4EnU,EACrF,CAGA,OAAO8yE,EAAmB9yE,EAC5B,CAGA,SAAS6yE,EAAiB7yE,GAMxB,GALA2yE,IAKI18C,EAAKke,eAAe4+B,WAAY,CAClC98C,EAAKke,eAAe4+B,gBAAa3yF,EAC7BoyF,GACFQ,IAKF,MAAMC,EAAmBh9C,EAAKs5C,OAAOtzF,OACrC,IAEIksF,EAFA+K,EAAkBD,EAKtB,KAAOC,KACL,GAAwC,SAApCj9C,EAAKs5C,OAAO2D,GAAiB,IAA0D,cAAzCj9C,EAAKs5C,OAAO2D,GAAiB,GAAG9zF,KAAsB,CACtG+oF,EAAQlyC,EAAKs5C,OAAO2D,GAAiB,GAAGp1F,IACxC,KACF,CAEFq1F,EAAeR,GAGf,IAAIphE,EAAQ0hE,EACZ,KAAO1hE,EAAQ0kB,EAAKs5C,OAAOtzF,QACzBg6C,EAAKs5C,OAAOh+D,GAAO,GAAGzzB,IAAM,IACvBqqF,GAEL52D,IAQF,OAJAuZ,GAAOmL,EAAKs5C,OAAQ2D,EAAkB,EAAG,EAAGj9C,EAAKs5C,OAAO1wF,MAAMo0F,IAG9Dh9C,EAAKs5C,OAAOtzF,OAASs1B,EACduhE,EAAmB9yE,EAC5B,CACA,OAAOxiB,EAAMwiB,EACf,CAGA,SAAS8yE,EAAmB9yE,GAM1B,GAAI2yE,IAAczqF,EAAMjM,OAAQ,CAI9B,IAAKu2F,EACH,OAAOY,EAAkBpzE,GAM3B,GAAIwyE,EAAUa,kBAAoBb,EAAUa,iBAAiBC,SAC3D,OAAOC,EAAUvzE,GAQnBi2B,EAAKu9C,UAAYjG,QAAQiF,EAAUa,mBAAqBb,EAAUiB,8BACpE,CAIA,OADAx9C,EAAKke,eAAiB,CAAC,EAChBhgC,EAAQswC,MAAMivB,GAAoBC,EAAsBC,EAAxDz/D,CAA+EnU,EACxF,CAGA,SAAS2zE,EAAqB3zE,GAG5B,OAFIwyE,GAAWQ,IACfG,EAAeR,GACRS,EAAkBpzE,EAC3B,CAGA,SAAS4zE,EAAsB5zE,GAG7B,OAFAi2B,EAAKi6C,OAAO//C,KAAK8F,EAAKh6B,MAAMxe,MAAQk1F,IAAczqF,EAAMjM,OACxDy2F,EAAkBz8C,EAAKh6B,MAAMiJ,OACtBquE,EAAUvzE,EACnB,CAGA,SAASozE,EAAkBpzE,GAGzB,OADAi2B,EAAKke,eAAiB,CAAC,EAChBhgC,EAAQk+D,QAAQqB,GAAoBG,EAAmBN,EAAvDp/D,CAAkEnU,EAC3E,CAGA,SAAS6zE,EAAkB7zE,GAIzB,OAHA2yE,IACAzqF,EAAMzJ,KAAK,CAACw3C,EAAKo9C,iBAAkBp9C,EAAKke,iBAEjCi/B,EAAkBpzE,EAC3B,CAGA,SAASuzE,EAAUvzE,GACjB,OAAa,OAATA,GACEwyE,GAAWQ,IACfG,EAAe,QACfh/D,EAAQ+9D,QAAQlyE,KAGlBwyE,EAAYA,GAAav8C,EAAKi6C,OAAO4D,KAAK79C,EAAKh6B,OAC/CkY,EAAQ21B,MAAM,YAAa,CACzB0lC,WAAYgD,EACZ9C,YAAa,OACbY,SAAUmC,IAELsB,EAAa/zE,GACtB,CAGA,SAAS+zE,EAAa/zE,GACpB,OAAa,OAATA,GACFg0E,EAAa7/D,EAAQs2B,KAAK,cAAc,GACxC0oC,EAAe,QACfh/D,EAAQ+9D,QAAQlyE,IAGd0xE,GAAmB1xE,IACrBmU,EAAQ+9D,QAAQlyE,GAChBg0E,EAAa7/D,EAAQs2B,KAAK,cAE1BkoC,EAAY,EACZ18C,EAAKu9C,eAAYpzF,EACV5C,IAET22B,EAAQ+9D,QAAQlyE,GACT+zE,EACT,CAUA,SAASC,EAAalE,EAAOmE,GAC3B,MAAM5D,EAASp6C,EAAKu6C,YAAYV,GAyChC,GAxCImE,GAAW5D,EAAO5xF,KAAK,MAC3BqxF,EAAMQ,SAAWmC,EACbA,IAAYA,EAAWxgE,KAAO69D,GAClC2C,EAAa3C,EACb0C,EAAU/B,WAAWX,EAAMtyF,OAC3Bg1F,EAAU7B,MAAMN,GAmCZp6C,EAAKi6C,OAAO//C,KAAK2/C,EAAMtyF,MAAMC,MAAO,CACtC,IAAI8zB,EAAQihE,EAAUjD,OAAOtzF,OAC7B,KAAOs1B,KACL,GAEAihE,EAAUjD,OAAOh+D,GAAO,GAAG/zB,MAAM0nB,OAASwtE,KAEzCF,EAAUjD,OAAOh+D,GAAO,GAAGzzB,KAE5B00F,EAAUjD,OAAOh+D,GAAO,GAAGzzB,IAAIonB,OAASwtE,GAGtC,OAMJ,MAAMO,EAAmBh9C,EAAKs5C,OAAOtzF,OACrC,IAEIi4F,EAEA/L,EAJA+K,EAAkBD,EAOtB,KAAOC,KACL,GAAwC,SAApCj9C,EAAKs5C,OAAO2D,GAAiB,IAA0D,cAAzCj9C,EAAKs5C,OAAO2D,GAAiB,GAAG9zF,KAAsB,CACtG,GAAI80F,EAAM,CACR/L,EAAQlyC,EAAKs5C,OAAO2D,GAAiB,GAAGp1F,IACxC,KACF,CACAo2F,GAAO,CACT,CAMF,IAJAf,EAAeR,GAGfphE,EAAQ0hE,EACD1hE,EAAQ0kB,EAAKs5C,OAAOtzF,QACzBg6C,EAAKs5C,OAAOh+D,GAAO,GAAGzzB,IAAM,IACvBqqF,GAEL52D,IAIFuZ,GAAOmL,EAAKs5C,OAAQ2D,EAAkB,EAAG,EAAGj9C,EAAKs5C,OAAO1wF,MAAMo0F,IAG9Dh9C,EAAKs5C,OAAOtzF,OAASs1B,CACvB,CACF,CAQA,SAAS4hE,EAAe5wD,GACtB,IAAIhR,EAAQrpB,EAAMjM,OAGlB,KAAOs1B,KAAUgR,GAAM,CACrB,MAAM4xD,EAAQjsF,EAAMqpB,GACpB0kB,EAAKke,eAAiBggC,EAAM,GAC5BA,EAAM,GAAG1pC,KAAKlwD,KAAK07C,EAAM9hB,EAC3B,CACAjsB,EAAMjM,OAASsmC,CACjB,CACA,SAASywD,IACPR,EAAU7B,MAAM,CAAC,OACjB8B,OAAaryF,EACboyF,OAAYpyF,EACZ61C,EAAKke,eAAe4+B,gBAAa3yF,CACnC,CACF,GAjUMszF,GAAqB,CACzBvB,SAwUF,SAA2Bh+D,EAASwR,EAAIyuD,GAGtC,OAAOpC,GAAa79D,EAASA,EAAQk+D,QAAQx0F,KAAKqyF,OAAOa,WAAWpsF,SAAUghC,EAAIyuD,GAAM,aAAcv2F,KAAKqyF,OAAOa,WAAWsD,QAAQC,KAAKzrF,SAAS,qBAAkBzI,EAAY,EACnL,GC7VO,MAAMm0F,GAAY,CACvBC,SAAS,EACTrC,SAQF,SAA2Bh+D,EAASwR,EAAIyuD,GACtC,OAgBA,SAAep0E,GACb,OAAO4xE,GAAc5xE,GAAQgyE,GAAa79D,EAASsgE,EAAO,aAA7BzC,CAA2ChyE,GAAQy0E,EAAMz0E,EACxF,EAgBA,SAASy0E,EAAMz0E,GACb,OAAgB,OAATA,GAAiB0xE,GAAmB1xE,GAAQ2lB,EAAG3lB,GAAQo0E,EAAIp0E,EACpE,CACF,GC1CO,MAAMhiB,GAAU,CACrBmuB,QAgBF,SAAwBojE,GAEtB,OADAR,GAAYQ,GACLA,CACT,EAlBE4C,SAyBF,SAAyBh+D,EAASwR,GAEhC,IAAI2qD,EACJ,OAYA,SAAoBtwE,GAKlB,OAJAmU,EAAQ21B,MAAM,WACdwmC,EAAWn8D,EAAQ21B,MAAM,eAAgB,CACvC4lC,YAAa,YAERgF,EAAY10E,EACrB,EAYA,SAAS00E,EAAY10E,GACnB,OAAa,OAATA,EACK20E,EAAW30E,GAKhB0xE,GAAmB1xE,GACdmU,EAAQswC,MAAMmwB,GAAuBC,EAAiBF,EAAtDxgE,CAAkEnU,IAI3EmU,EAAQ+9D,QAAQlyE,GACT00E,EACT,CAOA,SAASC,EAAW30E,GAGlB,OAFAmU,EAAQs2B,KAAK,gBACbt2B,EAAQs2B,KAAK,WACN9kB,EAAG3lB,EACZ,CAOA,SAAS60E,EAAgB70E,GAQvB,OAPAmU,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,gBACb6lC,EAASr+D,KAAOkC,EAAQ21B,MAAM,eAAgB,CAC5C4lC,YAAa,UACbY,aAEFA,EAAWA,EAASr+D,KACbyiE,CACT,CACF,GAhGME,GAAwB,CAC5BJ,SAAS,EACTrC,SAqGF,SAA8Bh+D,EAASwR,EAAIyuD,GACzC,MAAMn+C,EAAOp4C,KACb,OAOA,SAAwBmiB,GAKtB,OAJAmU,EAAQs2B,KAAK,gBACbt2B,EAAQ21B,MAAM,cACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,cACNunC,GAAa79D,EAAS2gE,EAAU,aACzC,EAOA,SAASA,EAAS90E,GAChB,GAAa,OAATA,GAAiB0xE,GAAmB1xE,GACtC,OAAOo0E,EAAIp0E,GAKb,MAAM2hB,EAAOsU,EAAKs5C,OAAOt5C,EAAKs5C,OAAOtzF,OAAS,GAC9C,OAAKg6C,EAAKi6C,OAAOa,WAAWsD,QAAQC,KAAKzrF,SAAS,iBAAmB84B,GAAyB,eAAjBA,EAAK,GAAGviC,MAAyBuiC,EAAK,GAAGozD,eAAepzD,EAAK,IAAI,GAAM1lC,QAAU,EACrJ0pC,EAAG3lB,GAELmU,EAAQq/D,UAAUv9C,EAAKi6C,OAAOa,WAAW+C,KAAMM,EAAKzuD,EAApDxR,CAAwDnU,EACjE,CACF,GCrJO,MAAM8zE,GAAO,CAClB3B,SASF,SAAwBh+D,GACtB,MAAM8hB,EAAOp4C,KACPs4D,EAAUhiC,EAAQk+D,QAExBkC,IAMA,SAAuBv0E,GACrB,GAAa,OAATA,EAEF,YADAmU,EAAQ+9D,QAAQlyE,GAOlB,OAJAmU,EAAQ21B,MAAM,mBACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,mBACbxU,EAAKo9C,sBAAmBjzF,EACjB+1D,CACT,GAdAhiC,EAAQk+D,QAAQx0F,KAAKqyF,OAAOa,WAAWiE,YAAaC,EAAgBjD,GAAa79D,EAASA,EAAQk+D,QAAQx0F,KAAKqyF,OAAOa,WAAW+C,KAAMmB,EAAgB9gE,EAAQk+D,QAAQr0F,GAASi3F,IAAkB,gBAClM,OAAO9+B,EAgBP,SAAS8+B,EAAej1E,GACtB,GAAa,OAATA,EAQJ,OAJAmU,EAAQ21B,MAAM,cACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,cACbxU,EAAKo9C,sBAAmBjzF,EACjB+1D,EAPLhiC,EAAQ+9D,QAAQlyE,EAQpB,CACF,GC9CO,MAAMk1E,GAAW,CACtBC,WAAYC,MAEDnyF,GAASoyF,GAAkB,UAC3BnyE,GAAOmyE,GAAkB,QAQtC,SAASA,GAAkBC,GACzB,MAAO,CACLH,WAAYC,GAAyB,SAAVE,EAAmBC,QAAyBn1F,GACvE+xF,SAQF,SAAwBh+D,GACtB,MAAM8hB,EAAOp4C,KACPkzF,EAAalzF,KAAKqyF,OAAOa,WAAWuE,GACpCpyE,EAAOiR,EAAQk+D,QAAQtB,EAAYvzF,EAAOg4F,GAChD,OAAOh4F,EAGP,SAASA,EAAMwiB,GACb,OAAOy1E,EAAQz1E,GAAQkD,EAAKlD,GAAQw1E,EAAQx1E,EAC9C,CAGA,SAASw1E,EAAQx1E,GACf,GAAa,OAATA,EAMJ,OAFAmU,EAAQ21B,MAAM,QACd31B,EAAQ+9D,QAAQlyE,GACTxB,EALL2V,EAAQ+9D,QAAQlyE,EAMpB,CAGA,SAASxB,EAAKwB,GACZ,OAAIy1E,EAAQz1E,IACVmU,EAAQs2B,KAAK,QACNvnC,EAAKlD,KAIdmU,EAAQ+9D,QAAQlyE,GACTxB,EACT,CAQA,SAASi3E,EAAQz1E,GACf,GAAa,OAATA,EACF,OAAO,EAET,MAAM+sD,EAAOgkB,EAAW/wE,GACxB,IAAIuR,GAAS,EACb,GAAIw7C,EAGF,OAASx7C,EAAQw7C,EAAK9wE,QAAQ,CAC5B,MAAM2yF,EAAO7hB,EAAKx7C,GAClB,IAAKq9D,EAAK0B,UAAY1B,EAAK0B,SAAS/1F,KAAK07C,EAAMA,EAAKq6C,UAClD,OAAO,CAEX,CAEF,OAAO,CACT,CACF,EACF,CAQA,SAAS8E,GAAeM,GACtB,OAGA,SAAwBnG,EAAQn8D,GAC9B,IAEI02B,EAFAv4B,GAAS,EAMb,OAASA,GAASg+D,EAAOtzF,aACTmE,IAAV0pD,EACEylC,EAAOh+D,IAAoC,SAA1Bg+D,EAAOh+D,GAAO,GAAGnyB,OACpC0qD,EAAQv4B,EACRA,KAEQg+D,EAAOh+D,IAAoC,SAA1Bg+D,EAAOh+D,GAAO,GAAGnyB,OAExCmyB,IAAUu4B,EAAQ,IACpBylC,EAAOzlC,GAAO,GAAGhsD,IAAMyxF,EAAOh+D,EAAQ,GAAG,GAAGzzB,IAC5CyxF,EAAOzkD,OAAOgf,EAAQ,EAAGv4B,EAAQu4B,EAAQ,GACzCv4B,EAAQu4B,EAAQ,GAElBA,OAAQ1pD,GAGZ,OAAOs1F,EAAgBA,EAAcnG,EAAQn8D,GAAWm8D,CAC1D,CACF,CAaA,SAASgG,GAAuBhG,EAAQn8D,GACtC,IAAIy8D,EAAa,EAEjB,OAASA,GAAcN,EAAOtzF,QAC5B,IAAK4zF,IAAeN,EAAOtzF,QAAyC,eAA/BszF,EAAOM,GAAY,GAAGzwF,OAA6D,SAAnCmwF,EAAOM,EAAa,GAAG,GAAGzwF,KAAiB,CAC9H,MAAMof,EAAO+wE,EAAOM,EAAa,GAAG,GAC9B8F,EAASviE,EAAQo9D,YAAYhyE,GACnC,IAIIo3E,EAJArkE,EAAQokE,EAAO15F,OACf45F,GAAe,EACftzD,EAAO,EAGX,KAAOhR,KAAS,CACd,MAAMukE,EAAQH,EAAOpkE,GACrB,GAAqB,kBAAVukE,EAAoB,CAE7B,IADAD,EAAcC,EAAM75F,OACyB,KAAtC65F,EAAMC,WAAWF,EAAc,IACpCtzD,IACAszD,IAEF,GAAIA,EAAa,MACjBA,GAAe,CACjB,MAEK,IAAe,IAAXC,EACPF,GAAO,EACPrzD,SACK,IAAe,IAAXuzD,EAEJ,CAELvkE,IACA,KACF,CACF,CACA,GAAIgR,EAAM,CACR,MAAMutD,EAAQ,CACZ1wF,KAAMywF,IAAeN,EAAOtzF,QAAU25F,GAAQrzD,EAAO,EAAI,aAAe,oBACxE/kC,MAAO,CACLw4F,aAAczkE,EAAQskE,EAAcr3E,EAAKhhB,MAAMw4F,aAAeH,EAC9DI,OAAQz3E,EAAKhhB,MAAMy4F,OAAS1kE,EAC5B9zB,KAAM+gB,EAAK1gB,IAAIL,KACfP,OAAQshB,EAAK1gB,IAAIZ,OAASqlC,EAC1Brd,OAAQ1G,EAAK1gB,IAAIonB,OAASqd,GAE5BzkC,IAAK,IACA0gB,EAAK1gB,MAGZ0gB,EAAK1gB,IAAM,IACNgyF,EAAMtyF,OAEPghB,EAAKhhB,MAAM0nB,SAAW1G,EAAK1gB,IAAIonB,OACjCtrB,OAAOoO,OAAOwW,EAAMsxE,IAEpBP,EAAOzkD,OAAO+kD,EAAY,EAAG,CAAC,QAASC,EAAO18D,GAAU,CAAC,OAAQ08D,EAAO18D,IACxEy8D,GAAc,EAElB,CACAA,GACF,CAEF,OAAON,CACT,CCjMO,MAAM2G,GAAgB,CAC3Bj7F,KAAM,gBACNk3F,SAQF,SAA+Bh+D,EAASwR,EAAIyuD,GAC1C,IAEI+B,EAFA5zD,EAAO,EAGX,OAYA,SAAeviB,GAGb,OAFAmU,EAAQ21B,MAAM,iBAehB,SAAgB9pC,GAEd,OADAm2E,EAASn2E,EACFy1E,EAAQz1E,EACjB,CAhBSixE,CAAOjxE,EAChB,EA2BA,SAASy1E,EAAQz1E,GACf,OAAIA,IAASm2E,GACXhiE,EAAQ21B,MAAM,yBACPssC,EAASp2E,IAEduiB,GAAQ,IAAe,OAATviB,GAAiB0xE,GAAmB1xE,KACpDmU,EAAQs2B,KAAK,iBACN9kB,EAAG3lB,IAELo0E,EAAIp0E,EACb,CAYA,SAASo2E,EAASp2E,GAChB,OAAIA,IAASm2E,GACXhiE,EAAQ+9D,QAAQlyE,GAChBuiB,IACO6zD,IAETjiE,EAAQs2B,KAAK,yBACNmnC,GAAc5xE,GAAQgyE,GAAa79D,EAASshE,EAAS,aAA/BzD,CAA6ChyE,GAAQy1E,EAAQz1E,GAC5F,CACF,GCpFO,MAAM+sD,GAAO,CAClB6lB,aAAc,CACZT,SAiHJ,SAAkCh+D,EAASwR,EAAIyuD,GAC7C,MAAMn+C,EAAOp4C,KAEb,OADAo4C,EAAKke,eAAe4+B,gBAAa3yF,EAC1B+zB,EAAQswC,MAAM8vB,GAAW8B,EAASC,GAGzC,SAASD,EAAQr2E,GAKf,OAJAi2B,EAAKke,eAAeoiC,kBAAoBtgD,EAAKke,eAAeoiC,mBAAqBtgD,EAAKke,eAAeqiC,iBAI9FxE,GAAa79D,EAASwR,EAAI,iBAAkBsQ,EAAKke,eAAe5xB,KAAO,EAAvEyvD,CAA0EhyE,EACnF,CAGA,SAASs2E,EAASt2E,GAChB,OAAIi2B,EAAKke,eAAeoiC,oBAAsB3E,GAAc5xE,IAC1Di2B,EAAKke,eAAeoiC,uBAAoBn2F,EACxC61C,EAAKke,eAAeqiC,sBAAmBp2F,EAChCq2F,EAAiBz2E,KAE1Bi2B,EAAKke,eAAeoiC,uBAAoBn2F,EACxC61C,EAAKke,eAAeqiC,sBAAmBp2F,EAChC+zB,EAAQk+D,QAAQqE,GAAiB/wD,EAAI8wD,EAArCtiE,CAAuDnU,GAChE,CAGA,SAASy2E,EAAiBz2E,GAOxB,OALAi2B,EAAKke,eAAe4+B,YAAa,EAEjC98C,EAAKu9C,eAAYpzF,EAGV4xF,GAAa79D,EAASA,EAAQk+D,QAAQtlB,GAAMpnC,EAAIyuD,GAAM,aAAcn+C,EAAKi6C,OAAOa,WAAWsD,QAAQC,KAAKzrF,SAAS,qBAAkBzI,EAAY,EAA/I4xF,CAAkJhyE,EAC3J,CACF,GAnJEyqC,KA0KF,SAAyBt2B,GACvBA,EAAQs2B,KAAK5sD,KAAKs2D,eAAe/0D,KACnC,EA3KEnE,KAAM,OACNk3F,SAuBF,SAA2Bh+D,EAASwR,EAAIyuD,GACtC,MAAMn+C,EAAOp4C,KACP8jC,EAAOsU,EAAKs5C,OAAOt5C,EAAKs5C,OAAOtzF,OAAS,GAC9C,IAAI06F,EAAch1D,GAAyB,eAAjBA,EAAK,GAAGviC,KAAwBuiC,EAAK,GAAGozD,eAAepzD,EAAK,IAAI,GAAM1lC,OAAS,EACrGsmC,EAAO,EACX,OAGA,SAAeviB,GACb,MAAM4sD,EAAO32B,EAAKke,eAAe/0D,OAAkB,KAAT4gB,GAAwB,KAATA,GAAwB,KAATA,EAAc,gBAAkB,eACxG,GAAa,kBAAT4sD,GAA4B32B,EAAKke,eAAegiC,QAAUn2E,IAASi2B,EAAKke,eAAegiC,OAAS5E,GAAWvxE,GAAO,CAOpH,GANKi2B,EAAKke,eAAe/0D,OACvB62C,EAAKke,eAAe/0D,KAAOwtE,EAC3Bz4C,EAAQ21B,MAAM8iB,EAAM,CAClBgjB,YAAY,KAGH,kBAAThjB,EAEF,OADAz4C,EAAQ21B,MAAM,kBACE,KAAT9pC,GAAwB,KAATA,EAAcmU,EAAQswC,MAAMyxB,GAAe9B,EAAKwC,EAAlCziE,CAA4CnU,GAAQ42E,EAAS52E,GAEnG,IAAKi2B,EAAKu9C,WAAsB,KAATxzE,EAGrB,OAFAmU,EAAQ21B,MAAM,kBACd31B,EAAQ21B,MAAM,iBACP+sC,EAAO72E,EAElB,CACA,OAAOo0E,EAAIp0E,EACb,EAGA,SAAS62E,EAAO72E,GACd,OAAIuxE,GAAWvxE,MAAWuiB,EAAO,IAC/BpO,EAAQ+9D,QAAQlyE,GACT62E,KAEH5gD,EAAKu9C,WAAajxD,EAAO,KAAO0T,EAAKke,eAAegiC,OAASn2E,IAASi2B,EAAKke,eAAegiC,OAAkB,KAATn2E,GAAwB,KAATA,IACtHmU,EAAQs2B,KAAK,iBACNmsC,EAAS52E,IAEXo0E,EAAIp0E,EACb,CAKA,SAAS42E,EAAS52E,GAKhB,OAJAmU,EAAQ21B,MAAM,kBACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,kBACbxU,EAAKke,eAAegiC,OAASlgD,EAAKke,eAAegiC,QAAUn2E,EACpDmU,EAAQswC,MAAM8vB,GAErBt+C,EAAKu9C,UAAYY,EAAMiC,EAASliE,EAAQk+D,QAAQyE,GAAmCC,EAAaC,GAClG,CAGA,SAASX,EAAQr2E,GAGf,OAFAi2B,EAAKke,eAAeqiC,kBAAmB,EACvCG,IACOI,EAAY/2E,EACrB,CAGA,SAASg3E,EAAYh3E,GACnB,OAAI4xE,GAAc5xE,IAChBmU,EAAQ21B,MAAM,4BACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,4BACNssC,GAEF3C,EAAIp0E,EACb,CAGA,SAAS+2E,EAAY/2E,GAEnB,OADAi2B,EAAKke,eAAe5xB,KAAOo0D,EAAc1gD,EAAK8+C,eAAe5gE,EAAQs2B,KAAK,mBAAmB,GAAMxuD,OAC5F0pC,EAAG3lB,EACZ,CACF,GAlGM82E,GAAoC,CACxCtC,SAAS,EACTrC,SA2KF,SAA0Ch+D,EAASwR,EAAIyuD,GACrD,MAAMn+C,EAAOp4C,KAIb,OAAOm0F,GAAa79D,GAGpB,SAAqBnU,GACnB,MAAM2hB,EAAOsU,EAAKs5C,OAAOt5C,EAAKs5C,OAAOtzF,OAAS,GAC9C,OAAQ21F,GAAc5xE,IAAS2hB,GAAyB,6BAAjBA,EAAK,GAAGviC,KAAsCumC,EAAG3lB,GAAQo0E,EAAIp0E,EACtG,GAN0C,2BAA4Bi2B,EAAKi6C,OAAOa,WAAWsD,QAAQC,KAAKzrF,SAAS,qBAAkBzI,EAAY,EAOnJ,GAnLMs2F,GAAkB,CACtBlC,SAAS,EACTrC,SA4IF,SAAwBh+D,EAASwR,EAAIyuD,GACnC,MAAMn+C,EAAOp4C,KACb,OAAOm0F,GAAa79D,GAGpB,SAAqBnU,GACnB,MAAM2hB,EAAOsU,EAAKs5C,OAAOt5C,EAAKs5C,OAAOtzF,OAAS,GAC9C,OAAO0lC,GAAyB,mBAAjBA,EAAK,GAAGviC,MAA6BuiC,EAAK,GAAGozD,eAAepzD,EAAK,IAAI,GAAM1lC,SAAWg6C,EAAKke,eAAe5xB,KAAOoD,EAAG3lB,GAAQo0E,EAAIp0E,EACjJ,GAN0C,iBAAkBi2B,EAAKke,eAAe5xB,KAAO,EAOzF,GC3KO,MAAM00D,GAAa,CACxBrE,aAAc,CACZT,SAgFJ,SAAwCh+D,EAASwR,EAAIyuD,GACnD,MAAMn+C,EAAOp4C,KACb,OAeA,SAAmBmiB,GACjB,GAAI4xE,GAAc5xE,GAGhB,OAAOgyE,GAAa79D,EAAS+iE,EAAY,aAAcjhD,EAAKi6C,OAAOa,WAAWsD,QAAQC,KAAKzrF,SAAS,qBAAkBzI,EAAY,EAA3H4xF,CAA8HhyE,GAEvI,OAAOk3E,EAAWl3E,EACpB,EAeA,SAASk3E,EAAWl3E,GAClB,OAAOmU,EAAQk+D,QAAQ4E,GAAYtxD,EAAIyuD,EAAhCjgE,CAAqCnU,EAC9C,CACF,GAxHEyqC,KA2HF,SAAct2B,GACZA,EAAQs2B,KAAK,aACf,EA5HExvD,KAAM,aACNk3F,SAQF,SAAiCh+D,EAASwR,EAAIyuD,GAC5C,MAAMn+C,EAAOp4C,KACb,OAYA,SAAemiB,GACb,GAAa,KAATA,EAAa,CACf,MAAMyc,EAAQwZ,EAAKke,eAWnB,OAVK13B,EAAMs2C,OACT5+C,EAAQ21B,MAAM,aAAc,CAC1B8lC,YAAY,IAEdnzD,EAAMs2C,MAAO,GAEf5+C,EAAQ21B,MAAM,oBACd31B,EAAQ21B,MAAM,oBACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,oBACNgqC,CACT,CACA,OAAOL,EAAIp0E,EACb,EAYA,SAASy0E,EAAMz0E,GACb,OAAI4xE,GAAc5xE,IAChBmU,EAAQ21B,MAAM,8BACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,8BACbt2B,EAAQs2B,KAAK,oBACN9kB,IAETxR,EAAQs2B,KAAK,oBACN9kB,EAAG3lB,GACZ,CACF,GCtCO,SAASm3E,GAAmBhjE,EAASwR,EAAIyuD,EAAKh1F,EAAMg4F,EAAaC,EAAmBC,EAASC,EAAYnqB,GAC9G,MAAM6kB,EAAQ7kB,GAAO3nB,OAAO6oC,kBAC5B,IAAIkJ,EAAU,EACd,OAcA,SAAex3E,GACb,GAAa,KAATA,EAMF,OALAmU,EAAQ21B,MAAM1qD,GACd+0B,EAAQ21B,MAAMstC,GACdjjE,EAAQ21B,MAAMutC,GACdljE,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK4sC,GACNI,EAIT,GAAa,OAATz3E,GAA0B,KAATA,GAAwB,KAATA,GAAesxE,GAAatxE,GAC9D,OAAOo0E,EAAIp0E,GAQb,OANAmU,EAAQ21B,MAAM1qD,GACd+0B,EAAQ21B,MAAMwtC,GACdnjE,EAAQ21B,MAAMytC,GACdpjE,EAAQ21B,MAAM,cAAe,CAC3B4lC,YAAa,WAERgI,EAAI13E,EACb,EAYA,SAASy3E,EAAez3E,GACtB,OAAa,KAATA,GACFmU,EAAQ21B,MAAMutC,GACdljE,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK4sC,GACbljE,EAAQs2B,KAAK2sC,GACbjjE,EAAQs2B,KAAKrrD,GACNumC,IAETxR,EAAQ21B,MAAMytC,GACdpjE,EAAQ21B,MAAM,cAAe,CAC3B4lC,YAAa,WAERiI,EAAS33E,GAClB,CAYA,SAAS23E,EAAS33E,GAChB,OAAa,KAATA,GACFmU,EAAQs2B,KAAK,eACbt2B,EAAQs2B,KAAK8sC,GACNE,EAAez3E,IAEX,OAATA,GAA0B,KAATA,GAAe0xE,GAAmB1xE,GAC9Co0E,EAAIp0E,IAEbmU,EAAQ+9D,QAAQlyE,GACA,KAATA,EAAc43E,EAAiBD,EACxC,CAYA,SAASC,EAAe53E,GACtB,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAChCmU,EAAQ+9D,QAAQlyE,GACT23E,GAEFA,EAAS33E,EAClB,CAYA,SAAS03E,EAAI13E,GACX,OAAKw3E,GAAqB,OAATx3E,GAA0B,KAATA,IAAe2xE,GAA0B3xE,GAOvEw3E,EAAUvF,GAAkB,KAATjyE,GACrBmU,EAAQ+9D,QAAQlyE,GAChBw3E,IACOE,GAEI,KAAT13E,GACFmU,EAAQ+9D,QAAQlyE,GAChBw3E,IACOE,GAMI,OAAT13E,GAA0B,KAATA,GAAwB,KAATA,GAAesxE,GAAatxE,GACvDo0E,EAAIp0E,IAEbmU,EAAQ+9D,QAAQlyE,GACA,KAATA,EAAc63E,EAAYH,IAxB/BvjE,EAAQs2B,KAAK,eACbt2B,EAAQs2B,KAAK8sC,GACbpjE,EAAQs2B,KAAK6sC,GACbnjE,EAAQs2B,KAAKrrD,GACNumC,EAAG3lB,GAqBd,CAYA,SAAS63E,EAAU73E,GACjB,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAChCmU,EAAQ+9D,QAAQlyE,GACT03E,GAEFA,EAAI13E,EACb,CACF,CCpKO,SAAS83E,GAAa3jE,EAASwR,EAAIyuD,EAAKh1F,EAAM24F,EAAYR,GAC/D,MAAMthD,EAAOp4C,KACb,IAEIq2F,EAFA3xD,EAAO,EAGX,OAYA,SAAeviB,GAMb,OALAmU,EAAQ21B,MAAM1qD,GACd+0B,EAAQ21B,MAAMiuC,GACd5jE,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAKstC,GACb5jE,EAAQ21B,MAAMytC,GACP9B,CACT,EAYA,SAASA,EAAQz1E,GACf,OAAIuiB,EAAO,KAAgB,OAATviB,GAA0B,KAATA,GAAwB,KAATA,IAAgBk0E,GAMzD,KAATl0E,IAAgBuiB,GAAQ,2BAA4B0T,EAAKi6C,OAAOa,WACvDqD,EAAIp0E,GAEA,KAATA,GACFmU,EAAQs2B,KAAK8sC,GACbpjE,EAAQ21B,MAAMiuC,GACd5jE,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAKstC,GACb5jE,EAAQs2B,KAAKrrD,GACNumC,GAIL+rD,GAAmB1xE,IACrBmU,EAAQ21B,MAAM,cACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,cACNgrC,IAETthE,EAAQ21B,MAAM,cAAe,CAC3B4lC,YAAa,WAERsI,EAAYh4E,GACrB,CAYA,SAASg4E,EAAYh4E,GACnB,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAe0xE,GAAmB1xE,IAASuiB,IAAS,KACtFpO,EAAQs2B,KAAK,eACNgrC,EAAQz1E,KAEjBmU,EAAQ+9D,QAAQlyE,GACXk0E,IAAMA,GAAQtC,GAAc5xE,IACjB,KAATA,EAAci4E,EAAcD,EACrC,CAYA,SAASC,EAAYj4E,GACnB,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAChCmU,EAAQ+9D,QAAQlyE,GAChBuiB,IACOy1D,GAEFA,EAAYh4E,EACrB,CACF,CCzGO,SAASk4E,GAAa/jE,EAASwR,EAAIyuD,EAAKh1F,EAAM24F,EAAYR,GAE/D,IAAIpB,EACJ,OAYA,SAAen2E,GACb,GAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,EAMhC,OALAmU,EAAQ21B,MAAM1qD,GACd+0B,EAAQ21B,MAAMiuC,GACd5jE,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAKstC,GACb5B,EAAkB,KAATn2E,EAAc,GAAKA,EACrB4+D,EAET,OAAOwV,EAAIp0E,EACb,EAcA,SAAS4+D,EAAM5+D,GACb,OAAIA,IAASm2E,GACXhiE,EAAQ21B,MAAMiuC,GACd5jE,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAKstC,GACb5jE,EAAQs2B,KAAKrrD,GACNumC,IAETxR,EAAQ21B,MAAMytC,GACP9B,EAAQz1E,GACjB,CAYA,SAASy1E,EAAQz1E,GACf,OAAIA,IAASm2E,GACXhiE,EAAQs2B,KAAK8sC,GACN3Y,EAAMuX,IAEF,OAATn2E,EACKo0E,EAAIp0E,GAIT0xE,GAAmB1xE,IAErBmU,EAAQ21B,MAAM,cACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,cACNunC,GAAa79D,EAASshE,EAAS,gBAExCthE,EAAQ21B,MAAM,cAAe,CAC3B4lC,YAAa,WAERmH,EAAO72E,GAChB,CAOA,SAAS62E,EAAO72E,GACd,OAAIA,IAASm2E,GAAmB,OAATn2E,GAAiB0xE,GAAmB1xE,IACzDmU,EAAQs2B,KAAK,eACNgrC,EAAQz1E,KAEjBmU,EAAQ+9D,QAAQlyE,GACA,KAATA,EAAcyuB,EAASooD,EAChC,CAYA,SAASpoD,EAAOzuB,GACd,OAAIA,IAASm2E,GAAmB,KAATn2E,GACrBmU,EAAQ+9D,QAAQlyE,GACT62E,GAEFA,EAAO72E,EAChB,CACF,CCrIO,SAASm4E,GAAkBhkE,EAASwR,GAEzC,IAAIuuD,EACJ,OAGA,SAAS12F,EAAMwiB,GACb,GAAI0xE,GAAmB1xE,GAKrB,OAJAmU,EAAQ21B,MAAM,cACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,cACbypC,GAAO,EACA12F,EAET,GAAIo0F,GAAc5xE,GAChB,OAAOgyE,GAAa79D,EAAS32B,EAAO02F,EAAO,aAAe,aAAnDlC,CAAiEhyE,GAE1E,OAAO2lB,EAAG3lB,EACZ,CACF,CCxBO,SAASo4E,GAAoBh9F,GAClC,OAAOA,EAEN0B,QAAQ,cAAe,KAEvBA,QAAQ,SAAU,IAOlB8I,cAAcG,aACjB,CCfO,MAAMutC,GAAa,CACxBr4C,KAAM,aACNk3F,SAcF,SAA4Bh+D,EAASwR,EAAIyuD,GACvC,MAAMn+C,EAAOp4C,KAEb,IAAIw6F,EACJ,OAYA,SAAer4E,GAKb,OADAmU,EAAQ21B,MAAM,cAchB,SAAgB9pC,GAGd,OAAO83E,GAAav9F,KAAK07C,EAAM9hB,EAASmkE,EAExClE,EAAK,kBAAmB,wBAAyB,wBAF1C0D,CAEmE93E,EAC5E,CAnBSixE,CAAOjxE,EAChB,EA8BA,SAASs4E,EAAWt4E,GAElB,OADAq4E,EAAaD,GAAoBniD,EAAK8+C,eAAe9+C,EAAKs5C,OAAOt5C,EAAKs5C,OAAOtzF,OAAS,GAAG,IAAI4C,MAAM,GAAI,IAC1F,KAATmhB,GACFmU,EAAQ21B,MAAM,oBACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,oBACN8tC,GAEFnE,EAAIp0E,EACb,CAYA,SAASu4E,EAAYv4E,GAEnB,OAAO2xE,GAA0B3xE,GAAQm4E,GAAkBhkE,EAASqkE,EAA3BL,CAA8Cn4E,GAAQw4E,EAAkBx4E,EACnH,CAYA,SAASw4E,EAAkBx4E,GACzB,OAAOm3E,GAAmBhjE,EAASskE,EAEnCrE,EAAK,wBAAyB,+BAAgC,qCAAsC,2BAA4B,8BAFzH+C,CAEwJn3E,EACjK,CAYA,SAASy4E,EAAiBz4E,GACxB,OAAOmU,EAAQk+D,QAAQqG,GAAajE,EAAOA,EAApCtgE,CAA2CnU,EACpD,CAcA,SAASy0E,EAAMz0E,GACb,OAAO4xE,GAAc5xE,GAAQgyE,GAAa79D,EAASwkE,EAAiB,aAAvC3G,CAAqDhyE,GAAQ24E,EAAgB34E,EAC5G,CAcA,SAAS24E,EAAgB34E,GACvB,OAAa,OAATA,GAAiB0xE,GAAmB1xE,IACtCmU,EAAQs2B,KAAK,cAKbxU,EAAKi6C,OAAOjsB,QAAQxlE,KAAK45F,GAKlB1yD,EAAG3lB,IAELo0E,EAAIp0E,EACb,CACF,GAlKM04E,GAAc,CAClBlE,SAAS,EACTrC,SAuKF,SAA6Bh+D,EAASwR,EAAIyuD,GACxC,OAcA,SAAqBp0E,GACnB,OAAO2xE,GAA0B3xE,GAAQm4E,GAAkBhkE,EAASykE,EAA3BT,CAAyCn4E,GAAQo0E,EAAIp0E,EAChG,EAaA,SAAS44E,EAAa54E,GACpB,OAAOk4E,GAAa/jE,EAAS0kE,EAAYzE,EAAK,kBAAmB,wBAAyB,wBAAnF8D,CAA4Gl4E,EACrH,CAYA,SAAS64E,EAAW74E,GAClB,OAAO4xE,GAAc5xE,GAAQgyE,GAAa79D,EAAS2kE,EAA8B,aAApD9G,CAAkEhyE,GAAQ84E,EAA6B94E,EACtI,CAYA,SAAS84E,EAA6B94E,GACpC,OAAgB,OAATA,GAAiB0xE,GAAmB1xE,GAAQ2lB,EAAG3lB,GAAQo0E,EAAIp0E,EACpE,CACF,GCjPO,MAAM+4E,GAAe,CAC1B99F,KAAM,eACNk3F,SAcF,SAA8Bh+D,EAASwR,EAAIyuD,GACzC,MAAMn+C,EAAOp4C,KACb,OAgBA,SAAemiB,GAMb,OAHAmU,EAAQ21B,MAAM,gBAGPkoC,GAAa79D,EAAS6kE,EAAa,aAAc,EAAjDhH,CAAwDhyE,EACjE,EAYA,SAASg5E,EAAYh5E,GACnB,MAAM2hB,EAAOsU,EAAKs5C,OAAOt5C,EAAKs5C,OAAOtzF,OAAS,GAC9C,OAAO0lC,GAAyB,eAAjBA,EAAK,GAAGviC,MAAyBuiC,EAAK,GAAGozD,eAAepzD,EAAK,IAAI,GAAM1lC,QAAU,EAAIw5F,EAAQz1E,GAAQo0E,EAAIp0E,EAC1H,CAYA,SAASy1E,EAAQz1E,GACf,OAAa,OAATA,EACKy0E,EAAMz0E,GAEX0xE,GAAmB1xE,GACdmU,EAAQk+D,QAAQ4G,GAAcxD,EAAShB,EAAvCtgE,CAA8CnU,IAEvDmU,EAAQ21B,MAAM,iBACP+sC,EAAO72E,GAChB,CAYA,SAAS62E,EAAO72E,GACd,OAAa,OAATA,GAAiB0xE,GAAmB1xE,IACtCmU,EAAQs2B,KAAK,iBACNgrC,EAAQz1E,KAEjBmU,EAAQ+9D,QAAQlyE,GACT62E,EACT,CAGA,SAASpC,EAAMz0E,GAKb,OAJAmU,EAAQs2B,KAAK,gBAIN9kB,EAAG3lB,EACZ,CACF,GApGMi5E,GAAe,CACnBzE,SAAS,EACTrC,SAyGF,SAA8Bh+D,EAASwR,EAAIyuD,GACzC,MAAMn+C,EAAOp4C,KACb,OAAOo7F,EAaP,SAASA,EAAaj5E,GAGpB,OAAIi2B,EAAKi6C,OAAO//C,KAAK8F,EAAKh6B,MAAMxe,MACvB22F,EAAIp0E,GAET0xE,GAAmB1xE,IACrBmU,EAAQ21B,MAAM,cACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,cACNwuC,GASFjH,GAAa79D,EAAS6kE,EAAa,aAAc,EAAjDhH,CAAwDhyE,EACjE,CAYA,SAASg5E,EAAYh5E,GACnB,MAAM2hB,EAAOsU,EAAKs5C,OAAOt5C,EAAKs5C,OAAOtzF,OAAS,GAC9C,OAAO0lC,GAAyB,eAAjBA,EAAK,GAAGviC,MAAyBuiC,EAAK,GAAGozD,eAAepzD,EAAK,IAAI,GAAM1lC,QAAU,EAAI0pC,EAAG3lB,GAAQ0xE,GAAmB1xE,GAAQi5E,EAAaj5E,GAAQo0E,EAAIp0E,EACrK,CACF,GCjKO,MAAMk5E,GAAa,CACxBj+F,KAAM,aACNkxB,QAKF,SAA2BojE,EAAQn8D,GACjC,IAGIp1B,EAEAklB,EALAyxE,EAAapF,EAAOtzF,OAAS,EAC7Bm2F,EAAe,EAOkB,eAAjC7C,EAAO6C,GAAc,GAAGhzF,OAC1BgzF,GAAgB,GAIduC,EAAa,EAAIvC,GAA+C,eAA/B7C,EAAOoF,GAAY,GAAGv1F,OACzDu1F,GAAc,GAEmB,uBAA/BpF,EAAOoF,GAAY,GAAGv1F,OAAkCgzF,IAAiBuC,EAAa,GAAKA,EAAa,EAAIvC,GAAmD,eAAnC7C,EAAOoF,EAAa,GAAG,GAAGv1F,QACxJu1F,GAAcvC,EAAe,IAAMuC,EAAa,EAAI,GAElDA,EAAavC,IACfp0F,EAAU,CACRoB,KAAM,iBACN5B,MAAO+xF,EAAO6C,GAAc,GAAG50F,MAC/BM,IAAKyxF,EAAOoF,GAAY,GAAG72F,KAE7BolB,EAAO,CACL9jB,KAAM,YACN5B,MAAO+xF,EAAO6C,GAAc,GAAG50F,MAC/BM,IAAKyxF,EAAOoF,GAAY,GAAG72F,IAC3B4xF,YAAa,QAEf5kD,GAAOykD,EAAQ6C,EAAcuC,EAAavC,EAAe,EAAG,CAAC,CAAC,QAASp0F,EAASo1B,GAAU,CAAC,QAASlQ,EAAMkQ,GAAU,CAAC,OAAQlQ,EAAMkQ,GAAU,CAAC,OAAQp1B,EAASo1B,MAEjK,OAAOm8D,CACT,EAvCE4C,SA8CF,SAA4Bh+D,EAASwR,EAAIyuD,GACvC,IAAI7xD,EAAO,EACX,OAYA,SAAeviB,GAGb,OADAmU,EAAQ21B,MAAM,cAchB,SAAgB9pC,GAEd,OADAmU,EAAQ21B,MAAM,sBACPqvC,EAAan5E,EACtB,CAhBSixE,CAAOjxE,EAChB,EA2BA,SAASm5E,EAAan5E,GACpB,OAAa,KAATA,GAAeuiB,IAAS,GAC1BpO,EAAQ+9D,QAAQlyE,GACTm5E,GAII,OAATn5E,GAAiB2xE,GAA0B3xE,IAC7CmU,EAAQs2B,KAAK,sBACNgrC,EAAQz1E,IAEVo0E,EAAIp0E,EACb,CAYA,SAASy1E,EAAQz1E,GACf,OAAa,KAATA,GACFmU,EAAQ21B,MAAM,sBACPsvC,EAAgBp5E,IAEZ,OAATA,GAAiB0xE,GAAmB1xE,IACtCmU,EAAQs2B,KAAK,cAIN9kB,EAAG3lB,IAER4xE,GAAc5xE,GACTgyE,GAAa79D,EAASshE,EAAS,aAA/BzD,CAA6ChyE,IAKtDmU,EAAQ21B,MAAM,kBACPtrC,EAAKwB,GACd,CAcA,SAASo5E,EAAgBp5E,GACvB,OAAa,KAATA,GACFmU,EAAQ+9D,QAAQlyE,GACTo5E,IAETjlE,EAAQs2B,KAAK,sBACNgrC,EAAQz1E,GACjB,CAYA,SAASxB,EAAKwB,GACZ,OAAa,OAATA,GAA0B,KAATA,GAAe2xE,GAA0B3xE,IAC5DmU,EAAQs2B,KAAK,kBACNgrC,EAAQz1E,KAEjBmU,EAAQ+9D,QAAQlyE,GACTxB,EACT,CACF,GCpLO,MAAM66E,GAAkB,CAC7Bp+F,KAAM,kBACNq+F,UAKF,SAAkC/J,EAAQn8D,GAExC,IAEIp1B,EAEAklB,EAEAowB,EANA/hB,EAAQg+D,EAAOtzF,OAUnB,KAAOs1B,KACL,GAAyB,UAArBg+D,EAAOh+D,GAAO,GAAgB,CAChC,GAA8B,YAA1Bg+D,EAAOh+D,GAAO,GAAGnyB,KAAoB,CACvCpB,EAAUuzB,EACV,KACF,CAC8B,cAA1Bg+D,EAAOh+D,GAAO,GAAGnyB,OACnB8jB,EAAOqO,EAEX,KAGgC,YAA1Bg+D,EAAOh+D,GAAO,GAAGnyB,MAEnBmwF,EAAOzkD,OAAOvZ,EAAO,GAElB+hB,GAAwC,eAA1Bi8C,EAAOh+D,GAAO,GAAGnyB,OAClCk0C,EAAa/hB,GAInB,MAAMgoE,EAAU,CACdn6F,KAAM,gBACN5B,MAAO,IACF+xF,EAAOrsE,GAAM,GAAG1lB,OAErBM,IAAK,IACAyxF,EAAOA,EAAOtzF,OAAS,GAAG,GAAG6B,MAKpCyxF,EAAOrsE,GAAM,GAAG9jB,KAAO,oBAInBk0C,GACFi8C,EAAOzkD,OAAO5nB,EAAM,EAAG,CAAC,QAASq2E,EAASnmE,IAC1Cm8D,EAAOzkD,OAAOwI,EAAa,EAAG,EAAG,CAAC,OAAQi8C,EAAOvxF,GAAS,GAAIo1B,IAC9Dm8D,EAAOvxF,GAAS,GAAGF,IAAM,IACpByxF,EAAOj8C,GAAY,GAAGx1C,MAG3ByxF,EAAOvxF,GAAS,GAAKu7F,EAKvB,OADAhK,EAAO9wF,KAAK,CAAC,OAAQ86F,EAASnmE,IACvBm8D,CACT,EAjEE4C,SAwEF,SAAiCh+D,EAASwR,EAAIyuD,GAC5C,MAAMn+C,EAAOp4C,KAEb,IAAIs4F,EACJ,OAaA,SAAen2E,GACb,IAEIw5E,EAFAjoE,EAAQ0kB,EAAKs5C,OAAOtzF,OAIxB,KAAOs1B,KAGL,GAAmC,eAA/B0kB,EAAKs5C,OAAOh+D,GAAO,GAAGnyB,MAAwD,eAA/B62C,EAAKs5C,OAAOh+D,GAAO,GAAGnyB,MAAwD,YAA/B62C,EAAKs5C,OAAOh+D,GAAO,GAAGnyB,KAAoB,CAC1Io6F,EAA2C,cAA/BvjD,EAAKs5C,OAAOh+D,GAAO,GAAGnyB,KAClC,KACF,CAKF,IAAK62C,EAAKi6C,OAAO//C,KAAK8F,EAAKh6B,MAAMxe,QAAUw4C,EAAKu9C,WAAagG,GAG3D,OAFArlE,EAAQ21B,MAAM,qBACdqsC,EAASn2E,EAiBb,SAAgBA,GAEd,OADAmU,EAAQ21B,MAAM,6BACP+sC,EAAO72E,EAChB,CAnBWixE,CAAOjxE,GAEhB,OAAOo0E,EAAIp0E,EACb,EA6BA,SAAS62E,EAAO72E,GACd,OAAIA,IAASm2E,GACXhiE,EAAQ+9D,QAAQlyE,GACT62E,IAET1iE,EAAQs2B,KAAK,6BACNmnC,GAAc5xE,GAAQgyE,GAAa79D,EAASsgE,EAAO,aAA7BzC,CAA2ChyE,GAAQy0E,EAAMz0E,GACxF,CAaA,SAASy0E,EAAMz0E,GACb,OAAa,OAATA,GAAiB0xE,GAAmB1xE,IACtCmU,EAAQs2B,KAAK,qBACN9kB,EAAG3lB,IAELo0E,EAAIp0E,EACb,CACF,GCzKO,MAAMy5E,GAAiB,CAC5B,UACA,UACA,QACA,OACA,WACA,aACA,OACA,UACA,SACA,MACA,WACA,KACA,UACA,SACA,MACA,MACA,KACA,KACA,WACA,aACA,SACA,SACA,OACA,QACA,WACA,KACA,KACA,KACA,KACA,KACA,KACA,OACA,SACA,KACA,OACA,SACA,SACA,KACA,OACA,OACA,OACA,WACA,MACA,WACA,KACA,WACA,SACA,IACA,QACA,SACA,UACA,UACA,QACA,QACA,KACA,QACA,KACA,QACA,QACA,KACA,QACA,MAeWC,GAAe,CAAC,MAAO,SAAU,QAAS,YC5E1CC,GAAW,CACtBrG,UAAU,EACVr4F,KAAM,WACNq+F,UAeF,SAA2B/J,GACzB,IAAIh+D,EAAQg+D,EAAOtzF,OACnB,KAAOs1B,MACoB,UAArBg+D,EAAOh+D,GAAO,IAA4C,aAA1Bg+D,EAAOh+D,GAAO,GAAGnyB,QAInDmyB,EAAQ,GAAmC,eAA9Bg+D,EAAOh+D,EAAQ,GAAG,GAAGnyB,OAEpCmwF,EAAOh+D,GAAO,GAAG/zB,MAAQ+xF,EAAOh+D,EAAQ,GAAG,GAAG/zB,MAE9C+xF,EAAOh+D,EAAQ,GAAG,GAAG/zB,MAAQ+xF,EAAOh+D,EAAQ,GAAG,GAAG/zB,MAElD+xF,EAAOzkD,OAAOvZ,EAAQ,EAAG,IAE3B,OAAOg+D,CACT,EA9BE4C,SAqCF,SAA0Bh+D,EAASwR,EAAIyuD,GACrC,MAAMn+C,EAAOp4C,KAEb,IAAIs4F,EAEAyD,EAEAC,EAEAtoE,EAEAuoE,EACJ,OAYA,SAAe95E,GAEb,OAaF,SAAgBA,GAId,OAHAmU,EAAQ21B,MAAM,YACd31B,EAAQ21B,MAAM,gBACd31B,EAAQ+9D,QAAQlyE,GACT+yD,CACT,CAlBSke,CAAOjxE,EAChB,EAiCA,SAAS+yD,EAAK/yD,GACZ,OAAa,KAATA,GACFmU,EAAQ+9D,QAAQlyE,GACT+5E,GAEI,KAAT/5E,GACFmU,EAAQ+9D,QAAQlyE,GAChB45E,GAAa,EACNI,GAEI,KAATh6E,GACFmU,EAAQ+9D,QAAQlyE,GAChBm2E,EAAS,EAMFlgD,EAAKu9C,UAAY7tD,EAAKs0D,GAI3B/I,GAAWlxE,IAEbmU,EAAQ+9D,QAAQlyE,GAChB65E,EAAS/5E,OAAOC,aAAaC,GACtBuV,GAEF6+D,EAAIp0E,EACb,CAgBA,SAAS+5E,EAAgB/5E,GACvB,OAAa,KAATA,GACFmU,EAAQ+9D,QAAQlyE,GAChBm2E,EAAS,EACF+D,GAEI,KAATl6E,GACFmU,EAAQ+9D,QAAQlyE,GAChBm2E,EAAS,EACT5kE,EAAQ,EACD4oE,GAILjJ,GAAWlxE,IACbmU,EAAQ+9D,QAAQlyE,GAChBm2E,EAAS,EAGFlgD,EAAKu9C,UAAY7tD,EAAKs0D,GAExB7F,EAAIp0E,EACb,CAYA,SAASk6E,EAAkBl6E,GACzB,OAAa,KAATA,GACFmU,EAAQ+9D,QAAQlyE,GAGTi2B,EAAKu9C,UAAY7tD,EAAKs0D,GAExB7F,EAAIp0E,EACb,CAYA,SAASm6E,EAAgBn6E,GACvB,MAAM5kB,EAAQ,SACd,OAAI4kB,IAAS5kB,EAAM26F,WAAWxkE,MAC5B4C,EAAQ+9D,QAAQlyE,GACF5kB,IAAVm2B,EAGK0kB,EAAKu9C,UAAY7tD,EAAKitD,EAExBuH,GAEF/F,EAAIp0E,EACb,CAYA,SAASg6E,EAAch6E,GACrB,OAAIkxE,GAAWlxE,IAEbmU,EAAQ+9D,QAAQlyE,GAChB65E,EAAS/5E,OAAOC,aAAaC,GACtBuV,GAEF6+D,EAAIp0E,EACb,CAcA,SAASuV,EAAQvV,GACf,GAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAe2xE,GAA0B3xE,GAAO,CAClF,MAAMo6E,EAAiB,KAATp6E,EACR/kB,EAAO4+F,EAAOj0F,cACpB,OAAKw0F,GAAUR,IAAcF,GAAa7wF,SAAS5N,GAM/Cw+F,GAAe5wF,SAASgxF,EAAOj0F,gBACjCuwF,EAAS,EACLiE,GACFjmE,EAAQ+9D,QAAQlyE,GACTq6E,GAKFpkD,EAAKu9C,UAAY7tD,EAAG3lB,GAAQ4yE,EAAa5yE,KAElDm2E,EAAS,EAEFlgD,EAAKu9C,YAAcv9C,EAAKi6C,OAAO//C,KAAK8F,EAAKh6B,MAAMxe,MAAQ22F,EAAIp0E,GAAQ45E,EAAaU,EAAwBt6E,GAAQu6E,EAA4Bv6E,KAlBjJm2E,EAAS,EAGFlgD,EAAKu9C,UAAY7tD,EAAG3lB,GAAQ4yE,EAAa5yE,GAgBpD,CAGA,OAAa,KAATA,GAAeoxE,GAAkBpxE,IACnCmU,EAAQ+9D,QAAQlyE,GAChB65E,GAAU/5E,OAAOC,aAAaC,GACvBuV,GAEF6+D,EAAIp0E,EACb,CAYA,SAASq6E,EAAiBr6E,GACxB,OAAa,KAATA,GACFmU,EAAQ+9D,QAAQlyE,GAGTi2B,EAAKu9C,UAAY7tD,EAAKitD,GAExBwB,EAAIp0E,EACb,CAYA,SAASs6E,EAAwBt6E,GAC/B,OAAI4xE,GAAc5xE,IAChBmU,EAAQ+9D,QAAQlyE,GACTs6E,GAEFE,EAAYx6E,EACrB,CAyBA,SAASu6E,EAA4Bv6E,GACnC,OAAa,KAATA,GACFmU,EAAQ+9D,QAAQlyE,GACTw6E,GAII,KAATx6E,GAAwB,KAATA,GAAekxE,GAAWlxE,IAC3CmU,EAAQ+9D,QAAQlyE,GACTy6E,GAEL7I,GAAc5xE,IAChBmU,EAAQ+9D,QAAQlyE,GACTu6E,GAEFC,EAAYx6E,EACrB,CAgBA,SAASy6E,EAAsBz6E,GAE7B,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAeoxE,GAAkBpxE,IAChFmU,EAAQ+9D,QAAQlyE,GACTy6E,GAEFC,EAA2B16E,EACpC,CAeA,SAAS06E,EAA2B16E,GAClC,OAAa,KAATA,GACFmU,EAAQ+9D,QAAQlyE,GACT26E,GAEL/I,GAAc5xE,IAChBmU,EAAQ+9D,QAAQlyE,GACT06E,GAEFH,EAA4Bv6E,EACrC,CAeA,SAAS26E,EAA6B36E,GACpC,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,EACzDo0E,EAAIp0E,GAEA,KAATA,GAAwB,KAATA,GACjBmU,EAAQ+9D,QAAQlyE,GAChB85E,EAAU95E,EACH46E,GAELhJ,GAAc5xE,IAChBmU,EAAQ+9D,QAAQlyE,GACT26E,GAEFE,EAA+B76E,EACxC,CAcA,SAAS46E,EAA6B56E,GACpC,OAAIA,IAAS85E,GACX3lE,EAAQ+9D,QAAQlyE,GAChB85E,EAAU,KACHgB,GAEI,OAAT96E,GAAiB0xE,GAAmB1xE,GAC/Bo0E,EAAIp0E,IAEbmU,EAAQ+9D,QAAQlyE,GACT46E,EACT,CAYA,SAASC,EAA+B76E,GACtC,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAe2xE,GAA0B3xE,GAC/I06E,EAA2B16E,IAEpCmU,EAAQ+9D,QAAQlyE,GACT66E,EACT,CAaA,SAASC,EAAkC96E,GACzC,OAAa,KAATA,GAAwB,KAATA,GAAe4xE,GAAc5xE,GACvCu6E,EAA4Bv6E,GAE9Bo0E,EAAIp0E,EACb,CAYA,SAASw6E,EAAYx6E,GACnB,OAAa,KAATA,GACFmU,EAAQ+9D,QAAQlyE,GACT+6E,GAEF3G,EAAIp0E,EACb,CAYA,SAAS+6E,EAAc/6E,GACrB,OAAa,OAATA,GAAiB0xE,GAAmB1xE,GAG/B4yE,EAAa5yE,GAElB4xE,GAAc5xE,IAChBmU,EAAQ+9D,QAAQlyE,GACT+6E,GAEF3G,EAAIp0E,EACb,CAYA,SAAS4yE,EAAa5yE,GACpB,OAAa,KAATA,GAA0B,IAAXm2E,GACjBhiE,EAAQ+9D,QAAQlyE,GACTg7E,GAEI,KAATh7E,GAA0B,IAAXm2E,GACjBhiE,EAAQ+9D,QAAQlyE,GACTi7E,GAEI,KAATj7E,GAA0B,IAAXm2E,GACjBhiE,EAAQ+9D,QAAQlyE,GACTk7E,GAEI,KAATl7E,GAA0B,IAAXm2E,GACjBhiE,EAAQ+9D,QAAQlyE,GACTi6E,GAEI,KAATj6E,GAA0B,IAAXm2E,GACjBhiE,EAAQ+9D,QAAQlyE,GACTm7E,IAELzJ,GAAmB1xE,IAAqB,IAAXm2E,GAA2B,IAAXA,EAIpC,OAATn2E,GAAiB0xE,GAAmB1xE,IACtCmU,EAAQs2B,KAAK,gBACN2wC,EAAkBp7E,KAE3BmU,EAAQ+9D,QAAQlyE,GACT4yE,IARLz+D,EAAQs2B,KAAK,gBACNt2B,EAAQswC,MAAM42B,GAAiBC,EAAmBF,EAAlDjnE,CAAqEnU,GAQhF,CAaA,SAASo7E,EAAkBp7E,GACzB,OAAOmU,EAAQswC,MAAM82B,GAA0BC,EAA0BF,EAAlEnnE,CAAqFnU,EAC9F,CAaA,SAASw7E,EAAyBx7E,GAIhC,OAHAmU,EAAQ21B,MAAM,cACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,cACNgxC,CACT,CAaA,SAASA,EAAmBz7E,GAC1B,OAAa,OAATA,GAAiB0xE,GAAmB1xE,GAC/Bo7E,EAAkBp7E,IAE3BmU,EAAQ21B,MAAM,gBACP8oC,EAAa5yE,GACtB,CAYA,SAASg7E,EAA0Bh7E,GACjC,OAAa,KAATA,GACFmU,EAAQ+9D,QAAQlyE,GACTi6E,GAEFrH,EAAa5yE,EACtB,CAYA,SAASi7E,EAAuBj7E,GAC9B,OAAa,KAATA,GACFmU,EAAQ+9D,QAAQlyE,GAChB65E,EAAS,GACF6B,GAEF9I,EAAa5yE,EACtB,CAYA,SAAS07E,EAAsB17E,GAC7B,GAAa,KAATA,EAAa,CACf,MAAM/kB,EAAO4+F,EAAOj0F,cACpB,OAAI8zF,GAAa7wF,SAAS5N,IACxBk5B,EAAQ+9D,QAAQlyE,GACTk7E,GAEFtI,EAAa5yE,EACtB,CACA,OAAIkxE,GAAWlxE,IAAS65E,EAAO59F,OAAS,GAEtCk4B,EAAQ+9D,QAAQlyE,GAChB65E,GAAU/5E,OAAOC,aAAaC,GACvB07E,GAEF9I,EAAa5yE,EACtB,CAYA,SAASm7E,EAAwBn7E,GAC/B,OAAa,KAATA,GACFmU,EAAQ+9D,QAAQlyE,GACTi6E,GAEFrH,EAAa5yE,EACtB,CAoBA,SAASi6E,EAA8Bj6E,GACrC,OAAa,KAATA,GACFmU,EAAQ+9D,QAAQlyE,GACTk7E,GAII,KAATl7E,GAA0B,IAAXm2E,GACjBhiE,EAAQ+9D,QAAQlyE,GACTi6E,GAEFrH,EAAa5yE,EACtB,CAYA,SAASk7E,EAAkBl7E,GACzB,OAAa,OAATA,GAAiB0xE,GAAmB1xE,IACtCmU,EAAQs2B,KAAK,gBACN6wC,EAAkBt7E,KAE3BmU,EAAQ+9D,QAAQlyE,GACTk7E,EACT,CAYA,SAASI,EAAkBt7E,GAMzB,OALAmU,EAAQs2B,KAAK,YAKN9kB,EAAG3lB,EACZ,CACF,GA1wBMq7E,GAAkB,CACtB7G,SAAS,EACTrC,SA6zBF,SAAiCh+D,EAASwR,EAAIyuD,GAC5C,OAaA,SAAep0E,GAIb,OAHAmU,EAAQ21B,MAAM,cACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,cACNt2B,EAAQk+D,QAAQkC,GAAW5uD,EAAIyuD,EACxC,CACF,GA/0BMmH,GAA2B,CAC/B/G,SAAS,EACTrC,SA2wBF,SAA0Ch+D,EAASwR,EAAIyuD,GACrD,MAAMn+C,EAAOp4C,KACb,OAaA,SAAemiB,GACb,GAAI0xE,GAAmB1xE,GAIrB,OAHAmU,EAAQ21B,MAAM,cACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,cACNgqC,EAET,OAAOL,EAAIp0E,EACb,EAaA,SAASy0E,EAAMz0E,GACb,OAAOi2B,EAAKi6C,OAAO//C,KAAK8F,EAAKh6B,MAAMxe,MAAQ22F,EAAIp0E,GAAQ2lB,EAAG3lB,EAC5D,CACF,GCn0BA,MAAM27E,GAAsB,CAC1BnH,SAAS,EACTrC,SAiaF,SAAqCh+D,EAASwR,EAAIyuD,GAChD,MAAMn+C,EAAOp4C,KACb,OAOA,SAAemiB,GACb,GAAa,OAATA,EACF,OAAOo0E,EAAIp0E,GAKb,OAHAmU,EAAQ21B,MAAM,cACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,cACN8nC,CACT,EAOA,SAASA,EAAUvyE,GACjB,OAAOi2B,EAAKi6C,OAAO//C,KAAK8F,EAAKh6B,MAAMxe,MAAQ22F,EAAIp0E,GAAQ2lB,EAAG3lB,EAC5D,CACF,GAxba47E,GAAa,CACxBtI,UAAU,EACVr4F,KAAM,aACNk3F,SAQF,SAA4Bh+D,EAASwR,EAAIyuD,GACvC,MAAMn+C,EAAOp4C,KAEPg+F,EAAa,CACjBrH,SAAS,EACTrC,SAiSF,SAA4Bh+D,EAASwR,EAAIyuD,GACvC,IAAI7xD,EAAO,EACX,OAAOu5D,EAOP,SAASA,EAAY97E,GAInB,OAHAmU,EAAQ21B,MAAM,cACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,cACNjtD,CACT,CAcA,SAASA,EAAMwiB,GAKb,OADAmU,EAAQ21B,MAAM,mBACP8nC,GAAc5xE,GAAQgyE,GAAa79D,EAAS4nE,EAAqB,aAAc9lD,EAAKi6C,OAAOa,WAAWsD,QAAQC,KAAKzrF,SAAS,qBAAkBzI,EAAY,EAApI4xF,CAAuIhyE,GAAQ+7E,EAAoB/7E,EAClM,CAcA,SAAS+7E,EAAoB/7E,GAC3B,OAAIA,IAASm2E,GACXhiE,EAAQ21B,MAAM,2BACPkyC,EAAch8E,IAEhBo0E,EAAIp0E,EACb,CAcA,SAASg8E,EAAch8E,GACrB,OAAIA,IAASm2E,GACX5zD,IACApO,EAAQ+9D,QAAQlyE,GACTg8E,GAELz5D,GAAQ05D,GACV9nE,EAAQs2B,KAAK,2BACNmnC,GAAc5xE,GAAQgyE,GAAa79D,EAAS+nE,EAAoB,aAA1ClK,CAAwDhyE,GAAQk8E,EAAmBl8E,IAE3Go0E,EAAIp0E,EACb,CAcA,SAASk8E,EAAmBl8E,GAC1B,OAAa,OAATA,GAAiB0xE,GAAmB1xE,IACtCmU,EAAQs2B,KAAK,mBACN9kB,EAAG3lB,IAELo0E,EAAIp0E,EACb,CACF,GAnYA,IAGIm2E,EAHAgG,EAAgB,EAChBF,EAAW,EAGf,OAcA,SAAej8E,GAEb,OAeF,SAA4BA,GAC1B,MAAM2hB,EAAOsU,EAAKs5C,OAAOt5C,EAAKs5C,OAAOtzF,OAAS,GAM9C,OALAkgG,EAAgBx6D,GAAyB,eAAjBA,EAAK,GAAGviC,KAAwBuiC,EAAK,GAAGozD,eAAepzD,EAAK,IAAI,GAAM1lC,OAAS,EACvGk6F,EAASn2E,EACTmU,EAAQ21B,MAAM,cACd31B,EAAQ21B,MAAM,mBACd31B,EAAQ21B,MAAM,2BACPqvC,EAAan5E,EACtB,CAvBSo8E,CAAmBp8E,EAC5B,EAoCA,SAASm5E,EAAan5E,GACpB,OAAIA,IAASm2E,GACX8F,IACA9nE,EAAQ+9D,QAAQlyE,GACTm5E,GAEL8C,EAAW,EACN7H,EAAIp0E,IAEbmU,EAAQs2B,KAAK,2BACNmnC,GAAc5xE,GAAQgyE,GAAa79D,EAASkoE,EAAY,aAAlCrK,CAAgDhyE,GAAQq8E,EAAWr8E,GAClG,CAcA,SAASq8E,EAAWr8E,GAClB,OAAa,OAATA,GAAiB0xE,GAAmB1xE,IACtCmU,EAAQs2B,KAAK,mBACNxU,EAAKu9C,UAAY7tD,EAAG3lB,GAAQmU,EAAQswC,MAAMk3B,GAAqBW,EAAgB7H,EAAnDtgE,CAA0DnU,KAE/FmU,EAAQ21B,MAAM,uBACd31B,EAAQ21B,MAAM,cAAe,CAC3B4lC,YAAa,WAER7qB,EAAK7kD,GACd,CAcA,SAAS6kD,EAAK7kD,GACZ,OAAa,OAATA,GAAiB0xE,GAAmB1xE,IACtCmU,EAAQs2B,KAAK,eACbt2B,EAAQs2B,KAAK,uBACN4xC,EAAWr8E,IAEhB4xE,GAAc5xE,IAChBmU,EAAQs2B,KAAK,eACbt2B,EAAQs2B,KAAK,uBACNunC,GAAa79D,EAASooE,EAAY,aAAlCvK,CAAgDhyE,IAE5C,KAATA,GAAeA,IAASm2E,EACnB/B,EAAIp0E,IAEbmU,EAAQ+9D,QAAQlyE,GACT6kD,EACT,CAcA,SAAS03B,EAAWv8E,GAClB,OAAa,OAATA,GAAiB0xE,GAAmB1xE,GAC/Bq8E,EAAWr8E,IAEpBmU,EAAQ21B,MAAM,uBACd31B,EAAQ21B,MAAM,cAAe,CAC3B4lC,YAAa,WAER7+E,EAAKmP,GACd,CAcA,SAASnP,EAAKmP,GACZ,OAAa,OAATA,GAAiB0xE,GAAmB1xE,IACtCmU,EAAQs2B,KAAK,eACbt2B,EAAQs2B,KAAK,uBACN4xC,EAAWr8E,IAEP,KAATA,GAAeA,IAASm2E,EACnB/B,EAAIp0E,IAEbmU,EAAQ+9D,QAAQlyE,GACTnP,EACT,CAeA,SAASyrF,EAAet8E,GACtB,OAAOmU,EAAQk+D,QAAQwJ,EAAYpH,EAAO+H,EAAnCroE,CAAkDnU,EAC3D,CAcA,SAASw8E,EAAcx8E,GAIrB,OAHAmU,EAAQ21B,MAAM,cACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,cACN2nC,CACT,CAcA,SAASA,EAAapyE,GACpB,OAAOm8E,EAAgB,GAAKvK,GAAc5xE,GAAQgyE,GAAa79D,EAASsoE,EAAoB,aAAcN,EAAgB,EAAxEnK,CAA2EhyE,GAAQy8E,EAAmBz8E,EAC1J,CAcA,SAASy8E,EAAmBz8E,GAC1B,OAAa,OAATA,GAAiB0xE,GAAmB1xE,GAC/BmU,EAAQswC,MAAMk3B,GAAqBW,EAAgB7H,EAAnDtgE,CAA0DnU,IAEnEmU,EAAQ21B,MAAM,iBACP4yC,EAAa18E,GACtB,CAcA,SAAS08E,EAAa18E,GACpB,OAAa,OAATA,GAAiB0xE,GAAmB1xE,IACtCmU,EAAQs2B,KAAK,iBACNgyC,EAAmBz8E,KAE5BmU,EAAQ+9D,QAAQlyE,GACT08E,EACT,CAcA,SAASjI,EAAMz0E,GAEb,OADAmU,EAAQs2B,KAAK,cACN9kB,EAAG3lB,EACZ,CA4GF,GCraA,MAAM3c,GAAUsB,SAASC,cAAc,KAMhC,SAAS+3F,GAA8BvhG,GAC5C,MAAMwhG,EAAqB,IAAMxhG,EAAQ,IACzCiI,GAAQ+I,UAAYwwF,EACpB,MAAM7xE,EAAO1nB,GAAQyI,YAUrB,OAAyC,KAArCif,EAAKgrE,WAAWhrE,EAAK9uB,OAAS,IAAiC,SAAVb,KAQlD2vB,IAAS6xE,GAA6B7xE,EAC/C,CCnBO,MAAM6xE,GAAqB,CAChC3hG,KAAM,qBACNk3F,SAQF,SAAoCh+D,EAASwR,EAAIyuD,GAC/C,MAAMn+C,EAAOp4C,KACb,IAEIuvE,EAEAhnE,EAJAm8B,EAAO,EAKX,OAgBA,SAAeviB,GAKb,OAJAmU,EAAQ21B,MAAM,sBACd31B,EAAQ21B,MAAM,4BACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,4BACNsoB,CACT,EAiBA,SAASA,EAAK/yD,GACZ,OAAa,KAATA,GACFmU,EAAQ21B,MAAM,mCACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,mCACNoyC,IAET1oE,EAAQ21B,MAAM,2BACdsjB,EAAM,GACNhnE,EAAOgrF,GACAh2F,EAAM4kB,GACf,CAcA,SAAS68E,EAAQ78E,GACf,OAAa,KAATA,GAAwB,MAATA,GACjBmU,EAAQ21B,MAAM,uCACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,uCACbt2B,EAAQ21B,MAAM,2BACdsjB,EAAM,EACNhnE,EAAOorF,GACAp2F,IAET+4B,EAAQ21B,MAAM,2BACdsjB,EAAM,EACNhnE,EAAOmrF,GACAn2F,EAAM4kB,GACf,CAmBA,SAAS5kB,EAAM4kB,GACb,GAAa,KAATA,GAAeuiB,EAAM,CACvB,MAAMutD,EAAQ37D,EAAQs2B,KAAK,2BAC3B,OAAIrkD,IAASgrF,IAAsBuL,GAA8B1mD,EAAK8+C,eAAejF,KAMrF37D,EAAQ21B,MAAM,4BACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,4BACbt2B,EAAQs2B,KAAK,sBACN9kB,GATEyuD,EAAIp0E,EAUf,CACA,OAAI5Z,EAAK4Z,IAASuiB,IAAS6qC,GACzBj5C,EAAQ+9D,QAAQlyE,GACT5kB,GAEFg5F,EAAIp0E,EACb,CACF,GCzIO,MAAM88E,GAAkB,CAC7B7hG,KAAM,kBACNk3F,SAQF,SAAiCh+D,EAASwR,EAAIyuD,GAC5C,OAYA,SAAep0E,GAKb,OAJAmU,EAAQ21B,MAAM,mBACd31B,EAAQ21B,MAAM,gBACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,gBACNosC,CACT,EAYA,SAASA,EAAO72E,GAEd,OAAIyxE,GAAiBzxE,IACnBmU,EAAQ21B,MAAM,wBACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,wBACbt2B,EAAQs2B,KAAK,mBACN9kB,GAEFyuD,EAAIp0E,EACb,CACF,GCnDO,MAAM+8E,GAAa,CACxB9hG,KAAM,aACNk3F,SAQF,SAA4Bh+D,EAASwR,GACnC,OAGA,SAAe3lB,GAIb,OAHAmU,EAAQ21B,MAAM,cACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,cACNunC,GAAa79D,EAASwR,EAAI,aACnC,CACF,GChBO,SAASwvD,GAAWpE,EAAYxB,EAAQn8D,GAE7C,MAAMk6B,EAAS,GACf,IAAI/7B,GAAS,EAEb,OAASA,EAAQw/D,EAAW90F,QAAQ,CAClC,MAAMkwB,EAAU4kE,EAAWx/D,GAAO4jE,WAE9BhpE,IAAYmhC,EAAOzkD,SAASsjB,KAC9BojE,EAASpjE,EAAQojE,EAAQn8D,GACzBk6B,EAAO7uD,KAAK0tB,GAEhB,CAEA,OAAOojE,CACT,CCVO,MAAMyN,GAAW,CACtB/hG,KAAM,WACNk6F,WAmBF,SAA4B5F,GAC1B,IAAIh+D,GAAS,EAEb,MAAM0rE,EAAY,GAClB,OAAS1rE,EAAQg+D,EAAOtzF,QAAQ,CAC9B,MAAM6zF,EAAQP,EAAOh+D,GAAO,GAE5B,GADA0rE,EAAUx+F,KAAK8wF,EAAOh+D,IACH,eAAfu+D,EAAM1wF,MAAwC,cAAf0wF,EAAM1wF,MAAuC,aAAf0wF,EAAM1wF,KAAqB,CAE1F,MAAM8lB,EAAwB,eAAf4qE,EAAM1wF,KAAwB,EAAI,EACjD0wF,EAAM1wF,KAAO,OACbmyB,GAASrM,CACX,CACF,CAGIqqE,EAAOtzF,SAAWghG,EAAUhhG,QAC9B6uC,GAAOykD,EAAQ,EAAGA,EAAOtzF,OAAQghG,GAEnC,OAAO1N,CACT,EAtCE+J,UAyCF,SAA2B/J,EAAQn8D,GACjC,IAGI08D,EAEA/c,EAEAmqB,EAEAxrC,EATAngC,EAAQg+D,EAAOtzF,OACfipB,EAAS,EAWb,KAAOqM,KAEL,GADAu+D,EAAQP,EAAOh+D,GAAO,GAClBwhD,EAAM,CAER,GAAmB,SAAf+c,EAAM1wF,MAAkC,cAAf0wF,EAAM1wF,MAAwB0wF,EAAMqN,UAC/D,MAKuB,UAArB5N,EAAOh+D,GAAO,IAAiC,cAAfu+D,EAAM1wF,OACxC0wF,EAAMqN,WAAY,EAEtB,MAAO,GAAID,GACT,GAAyB,UAArB3N,EAAOh+D,GAAO,KAAkC,eAAfu+D,EAAM1wF,MAAwC,cAAf0wF,EAAM1wF,QAA0B0wF,EAAMsN,YACxGrqB,EAAOxhD,EACY,cAAfu+D,EAAM1wF,MAAsB,CAC9B8lB,EAAS,EACT,KACF,MAEsB,aAAf4qE,EAAM1wF,OACf89F,EAAQ3rE,GAGZ,MAAM8rE,EAAQ,CACZj+F,KAA+B,cAAzBmwF,EAAOxc,GAAM,GAAG3zE,KAAuB,OAAS,QACtD5B,MAAO,IACF+xF,EAAOxc,GAAM,GAAGv1E,OAErBM,IAAK,IACAyxF,EAAOA,EAAOtzF,OAAS,GAAG,GAAG6B,MAG9B8yD,EAAQ,CACZxxD,KAAM,QACN5B,MAAO,IACF+xF,EAAOxc,GAAM,GAAGv1E,OAErBM,IAAK,IACAyxF,EAAO2N,GAAO,GAAGp/F,MAGlBolB,EAAO,CACX9jB,KAAM,YACN5B,MAAO,IACF+xF,EAAOxc,EAAO7tD,EAAS,GAAG,GAAGpnB,KAElCA,IAAK,IACAyxF,EAAO2N,EAAQ,GAAG,GAAG1/F,QAyB5B,OAtBAk0D,EAAQ,CAAC,CAAC,QAAS2rC,EAAOjqE,GAAU,CAAC,QAASw9B,EAAOx9B,IAGrDs+B,EAAQjzD,GAAKizD,EAAO69B,EAAO1wF,MAAMk0E,EAAO,EAAGA,EAAO7tD,EAAS,IAG3DwsC,EAAQjzD,GAAKizD,EAAO,CAAC,CAAC,QAASxuC,EAAMkQ,KAKrCs+B,EAAQjzD,GAAKizD,EAAOyjC,GAAW/hE,EAAQ88D,OAAOa,WAAWuM,WAAWhJ,KAAM/E,EAAO1wF,MAAMk0E,EAAO7tD,EAAS,EAAGg4E,EAAQ,GAAI9pE,IAGtHs+B,EAAQjzD,GAAKizD,EAAO,CAAC,CAAC,OAAQxuC,EAAMkQ,GAAUm8D,EAAO2N,EAAQ,GAAI3N,EAAO2N,EAAQ,GAAI,CAAC,OAAQtsC,EAAOx9B,KAGpGs+B,EAAQjzD,GAAKizD,EAAO69B,EAAO1wF,MAAMq+F,EAAQ,IAGzCxrC,EAAQjzD,GAAKizD,EAAO,CAAC,CAAC,OAAQ2rC,EAAOjqE,KACrC0X,GAAOykD,EAAQxc,EAAMwc,EAAOtzF,OAAQy1D,GAC7B69B,CACT,EAhIE4C,SAuIF,SAA0Bh+D,EAASwR,EAAIyuD,GACrC,MAAMn+C,EAAOp4C,KACb,IAEI0/F,EAEAt5B,EAJA1yC,EAAQ0kB,EAAKs5C,OAAOtzF,OAOxB,KAAOs1B,KACL,IAAoC,eAA/B0kB,EAAKs5C,OAAOh+D,GAAO,GAAGnyB,MAAwD,cAA/B62C,EAAKs5C,OAAOh+D,GAAO,GAAGnyB,QAA0B62C,EAAKs5C,OAAOh+D,GAAO,GAAG6rE,UAAW,CACnIG,EAAatnD,EAAKs5C,OAAOh+D,GAAO,GAChC,KACF,CAEF,OAiBA,SAAevR,GAEb,IAAKu9E,EACH,OAAOnJ,EAAIp0E,GAYb,GAAIu9E,EAAWJ,UACb,OAAOK,EAAYx9E,GAWrB,OATAikD,EAAUhuB,EAAKi6C,OAAOjsB,QAAQp7D,SAASuvF,GAAoBniD,EAAK8+C,eAAe,CAC7Ev3F,MAAO+/F,EAAWz/F,IAClBA,IAAKm4C,EAAKh6B,UAEZkY,EAAQ21B,MAAM,YACd31B,EAAQ21B,MAAM,eACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,eACbt2B,EAAQs2B,KAAK,YACNgqC,CACT,EAkBA,SAASA,EAAMz0E,GAKb,OAAa,KAATA,EACKmU,EAAQk+D,QAAQoL,GAAmBC,EAAYz5B,EAAUy5B,EAAaF,EAAtErpE,CAAmFnU,GAI/E,KAATA,EACKmU,EAAQk+D,QAAQsL,GAAwBD,EAAYz5B,EAAU25B,EAAmBJ,EAAjFrpE,CAA8FnU,GAIhGikD,EAAUy5B,EAAW19E,GAAQw9E,EAAYx9E,EAClD,CAgBA,SAAS49E,EAAiB59E,GACxB,OAAOmU,EAAQk+D,QAAQwL,GAA6BH,EAAYF,EAAzDrpE,CAAsEnU,EAC/E,CAkBA,SAAS09E,EAAW19E,GAElB,OAAO2lB,EAAG3lB,EACZ,CAkBA,SAASw9E,EAAYx9E,GAEnB,OADAu9E,EAAWH,WAAY,EAChBhJ,EAAIp0E,EACb,CACF,GA9RMy9E,GAAoB,CACxBtL,SAoSF,SAA0Bh+D,EAASwR,EAAIyuD,GACrC,OAYA,SAAuBp0E,GAKrB,OAJAmU,EAAQ21B,MAAM,YACd31B,EAAQ21B,MAAM,kBACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,kBACNqzC,CACT,EAYA,SAASA,EAAe99E,GACtB,OAAO2xE,GAA0B3xE,GAAQm4E,GAAkBhkE,EAAS4pE,EAA3B5F,CAAyCn4E,GAAQ+9E,EAAa/9E,EACzG,CAYA,SAAS+9E,EAAa/9E,GACpB,OAAa,KAATA,EACKg+E,EAAYh+E,GAEdm3E,GAAmBhjE,EAAS8pE,EAA0BC,EAA4B,sBAAuB,6BAA8B,mCAAoC,yBAA0B,4BAA6B,GAAlO/G,CAAsOn3E,EAC/O,CAYA,SAASi+E,EAAyBj+E,GAChC,OAAO2xE,GAA0B3xE,GAAQm4E,GAAkBhkE,EAASgqE,EAA3BhG,CAA4Cn4E,GAAQg+E,EAAYh+E,EAC3G,CAYA,SAASk+E,EAA2Bl+E,GAClC,OAAOo0E,EAAIp0E,EACb,CAYA,SAASm+E,EAAgBn+E,GACvB,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,EACzBk4E,GAAa/jE,EAASiqE,EAAoBhK,EAAK,gBAAiB,sBAAuB,sBAAvF8D,CAA8Gl4E,GAEhHg+E,EAAYh+E,EACrB,CAYA,SAASo+E,EAAmBp+E,GAC1B,OAAO2xE,GAA0B3xE,GAAQm4E,GAAkBhkE,EAAS6pE,EAA3B7F,CAAwCn4E,GAAQg+E,EAAYh+E,EACvG,CAYA,SAASg+E,EAAYh+E,GACnB,OAAa,KAATA,GACFmU,EAAQ21B,MAAM,kBACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,kBACbt2B,EAAQs2B,KAAK,YACN9kB,GAEFyuD,EAAIp0E,EACb,CACF,GApaM29E,GAAyB,CAC7BxL,SA0aF,SAA+Bh+D,EAASwR,EAAIyuD,GAC1C,MAAMn+C,EAAOp4C,KACb,OAYA,SAAuBmiB,GACrB,OAAO83E,GAAav9F,KAAK07C,EAAM9hB,EAASkqE,EAAoBC,EAAsB,YAAa,kBAAmB,kBAA3GxG,CAA8H93E,EACvI,EAYA,SAASq+E,EAAmBr+E,GAC1B,OAAOi2B,EAAKi6C,OAAOjsB,QAAQp7D,SAASuvF,GAAoBniD,EAAK8+C,eAAe9+C,EAAKs5C,OAAOt5C,EAAKs5C,OAAOtzF,OAAS,GAAG,IAAI4C,MAAM,GAAI,KAAO8mC,EAAG3lB,GAAQo0E,EAAIp0E,EACtJ,CAYA,SAASs+E,EAAqBt+E,GAC5B,OAAOo0E,EAAIp0E,EACb,CACF,GApdM69E,GAA8B,CAClC1L,SA0dF,SAAoCh+D,EAASwR,EAAIyuD,GAC/C,OAcA,SAAiCp0E,GAO/B,OAJAmU,EAAQ21B,MAAM,aACd31B,EAAQ21B,MAAM,mBACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,mBACN8zC,CACT,EAcA,SAASA,EAAuBv+E,GAC9B,OAAa,KAATA,GACFmU,EAAQ21B,MAAM,mBACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,mBACbt2B,EAAQs2B,KAAK,aACN9kB,GAEFyuD,EAAIp0E,EACb,CACF,GCniBO,MAAMw+E,GAAkB,CAC7BvjG,KAAM,kBACNk6F,WAAY6H,GAAS7H,WACrBhD,SAQF,SAAiCh+D,EAASwR,EAAIyuD,GAC5C,MAAMn+C,EAAOp4C,KACb,OAYA,SAAemiB,GAKb,OAJAmU,EAAQ21B,MAAM,cACd31B,EAAQ21B,MAAM,oBACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,oBACNsoB,CACT,EAYA,SAASA,EAAK/yD,GACZ,OAAa,KAATA,GACFmU,EAAQ21B,MAAM,eACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,eACbt2B,EAAQs2B,KAAK,cACNgqC,GAEFL,EAAIp0E,EACb,CA6BA,SAASy0E,EAAMz0E,GAMb,OAAgB,KAATA,GAAe,2BAA4Bi2B,EAAKi6C,OAAOa,WAAaqD,EAAIp0E,GAAQ2lB,EAAG3lB,EAC5F,CACF,GClFO,SAASy+E,GAAkBz+E,GAChC,OAAa,OAATA,GAAiB2xE,GAA0B3xE,IAAS8xE,GAAkB9xE,GACjE,EAEL6xE,GAAmB7xE,GACd,OADT,CAGF,CCRO,MAAM0+E,GAAY,CACvBzjG,KAAM,YACNk6F,WAUF,SAA6B5F,EAAQn8D,GACnC,IAEI2/C,EAEAsqB,EAEAn6E,EAEAy7E,EAEAC,EAEAC,EAEAC,EAEA55E,EAhBAqM,GAAS,EAsBb,OAASA,EAAQg+D,EAAOtzF,QAEtB,GAAyB,UAArBszF,EAAOh+D,GAAO,IAA4C,sBAA1Bg+D,EAAOh+D,GAAO,GAAGnyB,MAAgCmwF,EAAOh+D,GAAO,GAAGwtE,OAIpG,IAHAhsB,EAAOxhD,EAGAwhD,KAEL,GAAwB,SAApBwc,EAAOxc,GAAM,IAA0C,sBAAzBwc,EAAOxc,GAAM,GAAG3zE,MAAgCmwF,EAAOxc,GAAM,GAAGisB,OAElG5rE,EAAQ2hE,eAAexF,EAAOxc,GAAM,IAAIgjB,WAAW,KAAO3iE,EAAQ2hE,eAAexF,EAAOh+D,GAAO,IAAIwkE,WAAW,GAAI,CAKhH,IAAKxG,EAAOxc,GAAM,GAAGgsB,QAAUxP,EAAOh+D,GAAO,GAAGytE,SAAWzP,EAAOh+D,GAAO,GAAGzzB,IAAIonB,OAASqqE,EAAOh+D,GAAO,GAAG/zB,MAAM0nB,QAAU,MAAQqqE,EAAOxc,GAAM,GAAGj1E,IAAIonB,OAASqqE,EAAOxc,GAAM,GAAGv1E,MAAM0nB,OAASqqE,EAAOh+D,GAAO,GAAGzzB,IAAIonB,OAASqqE,EAAOh+D,GAAO,GAAG/zB,MAAM0nB,QAAU,GAC3P,SAIF25E,EAAMtP,EAAOxc,GAAM,GAAGj1E,IAAIonB,OAASqqE,EAAOxc,GAAM,GAAGv1E,MAAM0nB,OAAS,GAAKqqE,EAAOh+D,GAAO,GAAGzzB,IAAIonB,OAASqqE,EAAOh+D,GAAO,GAAG/zB,MAAM0nB,OAAS,EAAI,EAAI,EAC7I,MAAM1nB,EAAQ,IACT+xF,EAAOxc,GAAM,GAAGj1E,KAEfA,EAAM,IACPyxF,EAAOh+D,GAAO,GAAG/zB,OAEtByhG,GAAUzhG,GAAQqhG,GAClBI,GAAUnhG,EAAK+gG,GACfF,EAAkB,CAChBv/F,KAAMy/F,EAAM,EAAI,iBAAmB,mBACnCrhG,QACAM,IAAK,IACAyxF,EAAOxc,GAAM,GAAGj1E,MAGvB8gG,EAAkB,CAChBx/F,KAAMy/F,EAAM,EAAI,iBAAmB,mBACnCrhG,MAAO,IACF+xF,EAAOh+D,GAAO,GAAG/zB,OAEtBM,OAEFolB,EAAO,CACL9jB,KAAMy/F,EAAM,EAAI,aAAe,eAC/BrhG,MAAO,IACF+xF,EAAOxc,GAAM,GAAGj1E,KAErBA,IAAK,IACAyxF,EAAOh+D,GAAO,GAAG/zB,QAGxB6/F,EAAQ,CACNj+F,KAAMy/F,EAAM,EAAI,SAAW,WAC3BrhG,MAAO,IACFmhG,EAAgBnhG,OAErBM,IAAK,IACA8gG,EAAgB9gG,MAGvByxF,EAAOxc,GAAM,GAAGj1E,IAAM,IACjB6gG,EAAgBnhG,OAErB+xF,EAAOh+D,GAAO,GAAG/zB,MAAQ,IACpBohG,EAAgB9gG,KAErBghG,EAAa,GAGTvP,EAAOxc,GAAM,GAAGj1E,IAAIonB,OAASqqE,EAAOxc,GAAM,GAAGv1E,MAAM0nB,SACrD45E,EAAargG,GAAKqgG,EAAY,CAAC,CAAC,QAASvP,EAAOxc,GAAM,GAAI3/C,GAAU,CAAC,OAAQm8D,EAAOxc,GAAM,GAAI3/C,MAIhG0rE,EAAargG,GAAKqgG,EAAY,CAAC,CAAC,QAASzB,EAAOjqE,GAAU,CAAC,QAASurE,EAAiBvrE,GAAU,CAAC,OAAQurE,EAAiBvrE,GAAU,CAAC,QAASlQ,EAAMkQ,KAKnJ0rE,EAAargG,GAAKqgG,EAAY3J,GAAW/hE,EAAQ88D,OAAOa,WAAWuM,WAAWhJ,KAAM/E,EAAO1wF,MAAMk0E,EAAO,EAAGxhD,GAAQ6B,IAGnH0rE,EAAargG,GAAKqgG,EAAY,CAAC,CAAC,OAAQ57E,EAAMkQ,GAAU,CAAC,QAASwrE,EAAiBxrE,GAAU,CAAC,OAAQwrE,EAAiBxrE,GAAU,CAAC,OAAQiqE,EAAOjqE,KAG7Im8D,EAAOh+D,GAAO,GAAGzzB,IAAIonB,OAASqqE,EAAOh+D,GAAO,GAAG/zB,MAAM0nB,QACvDA,EAAS,EACT45E,EAAargG,GAAKqgG,EAAY,CAAC,CAAC,QAASvP,EAAOh+D,GAAO,GAAI6B,GAAU,CAAC,OAAQm8D,EAAOh+D,GAAO,GAAI6B,MAEhGlO,EAAS,EAEX4lB,GAAOykD,EAAQxc,EAAO,EAAGxhD,EAAQwhD,EAAO,EAAG+rB,GAC3CvtE,EAAQwhD,EAAO+rB,EAAW7iG,OAASipB,EAAS,EAC5C,KACF,CAMNqM,GAAS,EACT,OAASA,EAAQg+D,EAAOtzF,QACQ,sBAA1BszF,EAAOh+D,GAAO,GAAGnyB,OACnBmwF,EAAOh+D,GAAO,GAAGnyB,KAAO,QAG5B,OAAOmwF,CACT,EA5IE4C,SAmJF,SAA2Bh+D,EAASwR,GAClC,MAAMu5D,EAAmBrhG,KAAKqyF,OAAOa,WAAWmO,iBAAiB5K,KAC3DhE,EAAWzyF,KAAKyyF,SAChBW,EAASwN,GAAkBnO,GAGjC,IAAI6F,EACJ,OAYA,SAAen2E,GAGb,OAFAm2E,EAASn2E,EACTmU,EAAQ21B,MAAM,qBACP+sC,EAAO72E,EAChB,EAYA,SAAS62E,EAAO72E,GACd,GAAIA,IAASm2E,EAEX,OADAhiE,EAAQ+9D,QAAQlyE,GACT62E,EAET,MAAM/G,EAAQ37D,EAAQs2B,KAAK,qBAGrBgqC,EAAQgK,GAAkBz+E,GAI1B+yD,GAAQ0hB,GAAmB,IAAVA,GAAexD,GAAUiO,EAAiBr2F,SAASmX,GACpEk9E,GAASjM,GAAqB,IAAXA,GAAgBwD,GAASyK,EAAiBr2F,SAASynF,GAG5E,OAFAR,EAAMkP,MAAQzR,QAAmB,KAAX4I,EAAgBpjB,EAAOA,IAASke,IAAWiM,IACjEpN,EAAMiP,OAASxR,QAAmB,KAAX4I,EAAgB+G,EAAQA,IAAUzI,IAAU1hB,IAC5DptC,EAAG3lB,EACZ,CACF,GAeA,SAASi/E,GAAU9W,EAAOjjE,GACxBijE,EAAMjrF,QAAUgoB,EAChBijE,EAAMjjE,QAAUA,EAChBijE,EAAM6N,cAAgB9wE,CACxB,CCrOO,MAAMi6E,GAAW,CACtBlkG,KAAM,WACNk3F,SAQF,SAA0Bh+D,EAASwR,EAAIyuD,GACrC,IAAI7xD,EAAO,EACX,OAcA,SAAeviB,GAMb,OALAmU,EAAQ21B,MAAM,YACd31B,EAAQ21B,MAAM,kBACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,kBACbt2B,EAAQ21B,MAAM,oBACPipB,CACT,EAcA,SAASA,EAAK/yD,GACZ,OAAIkxE,GAAWlxE,IACbmU,EAAQ+9D,QAAQlyE,GACTo/E,GAEI,KAATp/E,EACKo0E,EAAIp0E,GAENq/E,EAAWr/E,EACpB,CAcA,SAASo/E,EAAmBp/E,GAE1B,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAeoxE,GAAkBpxE,IAEjEuiB,EAAO,EACA+8D,EAAyBt/E,IAE3Bq/E,EAAWr/E,EACpB,CAcA,SAASs/E,EAAyBt/E,GAChC,OAAa,KAATA,GACFmU,EAAQ+9D,QAAQlyE,GAChBuiB,EAAO,EACAg9D,IAIK,KAATv/E,GAAwB,KAATA,GAAwB,KAATA,GAAeoxE,GAAkBpxE,KAAUuiB,IAAS,IACrFpO,EAAQ+9D,QAAQlyE,GACTs/E,IAET/8D,EAAO,EACA88D,EAAWr/E,GACpB,CAYA,SAASu/E,EAAUv/E,GACjB,OAAa,KAATA,GACFmU,EAAQs2B,KAAK,oBACbt2B,EAAQ21B,MAAM,kBACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,kBACbt2B,EAAQs2B,KAAK,YACN9kB,GAII,OAAT3lB,GAA0B,KAATA,GAAwB,KAATA,GAAesxE,GAAatxE,GACvDo0E,EAAIp0E,IAEbmU,EAAQ+9D,QAAQlyE,GACTu/E,EACT,CAYA,SAASF,EAAWr/E,GAClB,OAAa,KAATA,GACFmU,EAAQ+9D,QAAQlyE,GACTw/E,GAELnO,GAAWrxE,IACbmU,EAAQ+9D,QAAQlyE,GACTq/E,GAEFjL,EAAIp0E,EACb,CAYA,SAASw/E,EAAiBx/E,GACxB,OAAOoxE,GAAkBpxE,GAAQy/E,EAAWz/E,GAAQo0E,EAAIp0E,EAC1D,CAYA,SAASy/E,EAAWz/E,GAClB,OAAa,KAATA,GACFmU,EAAQ+9D,QAAQlyE,GAChBuiB,EAAO,EACAi9D,GAEI,KAATx/E,GAEFmU,EAAQs2B,KAAK,oBAAoBrrD,KAAO,gBACxC+0B,EAAQ21B,MAAM,kBACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,kBACbt2B,EAAQs2B,KAAK,YACN9kB,GAEF+5D,EAAW1/E,EACpB,CAcA,SAAS0/E,EAAW1/E,GAElB,IAAc,KAATA,GAAeoxE,GAAkBpxE,KAAUuiB,IAAS,GAAI,CAC3D,MAAMtQ,EAAgB,KAATjS,EAAc0/E,EAAaD,EAExC,OADAtrE,EAAQ+9D,QAAQlyE,GACTiS,CACT,CACA,OAAOmiE,EAAIp0E,EACb,CACF,GC3NO,MAAM2/E,GAAW,CACtB1kG,KAAM,WACNk3F,SAQF,SAA0Bh+D,EAASwR,EAAIyuD,GACrC,MAAMn+C,EAAOp4C,KAEb,IAAIs4F,EAEA5kE,EAEAquE,EACJ,OAYA,SAAe5/E,GAIb,OAHAmU,EAAQ21B,MAAM,YACd31B,EAAQ21B,MAAM,gBACd31B,EAAQ+9D,QAAQlyE,GACT+yD,CACT,EAgBA,SAASA,EAAK/yD,GACZ,OAAa,KAATA,GACFmU,EAAQ+9D,QAAQlyE,GACT+5E,GAEI,KAAT/5E,GACFmU,EAAQ+9D,QAAQlyE,GACTg6E,GAEI,KAATh6E,GACFmU,EAAQ+9D,QAAQlyE,GACT6/E,GAIL3O,GAAWlxE,IACbmU,EAAQ+9D,QAAQlyE,GACT8/E,GAEF1L,EAAIp0E,EACb,CAgBA,SAAS+5E,EAAgB/5E,GACvB,OAAa,KAATA,GACFmU,EAAQ+9D,QAAQlyE,GACTk6E,GAEI,KAATl6E,GACFmU,EAAQ+9D,QAAQlyE,GAChBuR,EAAQ,EACD4oE,GAELjJ,GAAWlxE,IACbmU,EAAQ+9D,QAAQlyE,GACT3gB,GAEF+0F,EAAIp0E,EACb,CAYA,SAASk6E,EAAkBl6E,GACzB,OAAa,KAATA,GACFmU,EAAQ+9D,QAAQlyE,GACT+/E,GAEF3L,EAAIp0E,EACb,CAYA,SAAS/gB,EAAQ+gB,GACf,OAAa,OAATA,EACKo0E,EAAIp0E,GAEA,KAATA,GACFmU,EAAQ+9D,QAAQlyE,GACTggF,GAELtO,GAAmB1xE,IACrB4/E,EAAc3gG,EACPghG,EAAiBjgF,KAE1BmU,EAAQ+9D,QAAQlyE,GACT/gB,EACT,CAYA,SAAS+gG,EAAahgF,GACpB,OAAa,KAATA,GACFmU,EAAQ+9D,QAAQlyE,GACT+/E,GAEF9gG,EAAQ+gB,EACjB,CAYA,SAAS+/E,EAAW//E,GAClB,OAAgB,KAATA,EAAcliB,EAAIkiB,GAAiB,KAATA,EAAcggF,EAAahgF,GAAQ/gB,EAAQ+gB,EAC9E,CAYA,SAASm6E,EAAgBn6E,GACvB,MAAM5kB,EAAQ,SACd,OAAI4kB,IAAS5kB,EAAM26F,WAAWxkE,MAC5B4C,EAAQ+9D,QAAQlyE,GACC5kB,IAAVm2B,EAAyB2uE,EAAQ/F,GAEnC/F,EAAIp0E,EACb,CAYA,SAASkgF,EAAMlgF,GACb,OAAa,OAATA,EACKo0E,EAAIp0E,GAEA,KAATA,GACFmU,EAAQ+9D,QAAQlyE,GACTmgF,GAELzO,GAAmB1xE,IACrB4/E,EAAcM,EACPD,EAAiBjgF,KAE1BmU,EAAQ+9D,QAAQlyE,GACTkgF,EACT,CAYA,SAASC,EAAWngF,GAClB,OAAa,KAATA,GACFmU,EAAQ+9D,QAAQlyE,GACTogF,GAEFF,EAAMlgF,EACf,CAYA,SAASogF,EAASpgF,GAChB,OAAa,KAATA,EACKliB,EAAIkiB,GAEA,KAATA,GACFmU,EAAQ+9D,QAAQlyE,GACTogF,GAEFF,EAAMlgF,EACf,CAYA,SAAS3gB,EAAY2gB,GACnB,OAAa,OAATA,GAA0B,KAATA,EACZliB,EAAIkiB,GAET0xE,GAAmB1xE,IACrB4/E,EAAcvgG,EACP4gG,EAAiBjgF,KAE1BmU,EAAQ+9D,QAAQlyE,GACT3gB,EACT,CAYA,SAASwgG,EAAY7/E,GACnB,OAAa,OAATA,EACKo0E,EAAIp0E,GAEA,KAATA,GACFmU,EAAQ+9D,QAAQlyE,GACTqgF,GAEL3O,GAAmB1xE,IACrB4/E,EAAcC,EACPI,EAAiBjgF,KAE1BmU,EAAQ+9D,QAAQlyE,GACT6/E,EACT,CAYA,SAASQ,EAAiBrgF,GACxB,OAAgB,KAATA,EAAcliB,EAAIkiB,GAAQ6/E,EAAY7/E,EAC/C,CAYA,SAASg6E,EAAch6E,GAErB,OAAIkxE,GAAWlxE,IACbmU,EAAQ+9D,QAAQlyE,GACTsgF,GAEFlM,EAAIp0E,EACb,CAYA,SAASsgF,EAAStgF,GAEhB,OAAa,KAATA,GAAeoxE,GAAkBpxE,IACnCmU,EAAQ+9D,QAAQlyE,GACTsgF,GAEFC,EAAgBvgF,EACzB,CAYA,SAASugF,EAAgBvgF,GACvB,OAAI0xE,GAAmB1xE,IACrB4/E,EAAcW,EACPN,EAAiBjgF,IAEtB4xE,GAAc5xE,IAChBmU,EAAQ+9D,QAAQlyE,GACTugF,GAEFziG,EAAIkiB,EACb,CAYA,SAAS8/E,EAAQ9/E,GAEf,OAAa,KAATA,GAAeoxE,GAAkBpxE,IACnCmU,EAAQ+9D,QAAQlyE,GACT8/E,GAEI,KAAT9/E,GAAwB,KAATA,GAAe2xE,GAA0B3xE,GACnDwgF,EAAexgF,GAEjBo0E,EAAIp0E,EACb,CAYA,SAASwgF,EAAexgF,GACtB,OAAa,KAATA,GACFmU,EAAQ+9D,QAAQlyE,GACTliB,GAII,KAATkiB,GAAwB,KAATA,GAAekxE,GAAWlxE,IAC3CmU,EAAQ+9D,QAAQlyE,GACTygF,GAEL/O,GAAmB1xE,IACrB4/E,EAAcY,EACPP,EAAiBjgF,IAEtB4xE,GAAc5xE,IAChBmU,EAAQ+9D,QAAQlyE,GACTwgF,GAEF1iG,EAAIkiB,EACb,CAYA,SAASygF,EAAqBzgF,GAE5B,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAeoxE,GAAkBpxE,IAChFmU,EAAQ+9D,QAAQlyE,GACTygF,GAEFC,EAA0B1gF,EACnC,CAaA,SAAS0gF,EAA0B1gF,GACjC,OAAa,KAATA,GACFmU,EAAQ+9D,QAAQlyE,GACT2gF,GAELjP,GAAmB1xE,IACrB4/E,EAAcc,EACPT,EAAiBjgF,IAEtB4xE,GAAc5xE,IAChBmU,EAAQ+9D,QAAQlyE,GACT0gF,GAEFF,EAAexgF,EACxB,CAaA,SAAS2gF,EAA4B3gF,GACnC,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,EACzDo0E,EAAIp0E,GAEA,KAATA,GAAwB,KAATA,GACjBmU,EAAQ+9D,QAAQlyE,GAChBm2E,EAASn2E,EACF4gF,GAELlP,GAAmB1xE,IACrB4/E,EAAce,EACPV,EAAiBjgF,IAEtB4xE,GAAc5xE,IAChBmU,EAAQ+9D,QAAQlyE,GACT2gF,IAETxsE,EAAQ+9D,QAAQlyE,GACT6gF,EACT,CAYA,SAASD,EAA4B5gF,GACnC,OAAIA,IAASm2E,GACXhiE,EAAQ+9D,QAAQlyE,GAChBm2E,OAAS/1F,EACF0gG,GAEI,OAAT9gF,EACKo0E,EAAIp0E,GAET0xE,GAAmB1xE,IACrB4/E,EAAcgB,EACPX,EAAiBjgF,KAE1BmU,EAAQ+9D,QAAQlyE,GACT4gF,EACT,CAYA,SAASC,EAA8B7gF,GACrC,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,EACxEo0E,EAAIp0E,GAEA,KAATA,GAAwB,KAATA,GAAe2xE,GAA0B3xE,GACnDwgF,EAAexgF,IAExBmU,EAAQ+9D,QAAQlyE,GACT6gF,EACT,CAaA,SAASC,EAAiC9gF,GACxC,OAAa,KAATA,GAAwB,KAATA,GAAe2xE,GAA0B3xE,GACnDwgF,EAAexgF,GAEjBo0E,EAAIp0E,EACb,CAYA,SAASliB,EAAIkiB,GACX,OAAa,KAATA,GACFmU,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,gBACbt2B,EAAQs2B,KAAK,YACN9kB,GAEFyuD,EAAIp0E,EACb,CAgBA,SAASigF,EAAiBjgF,GAKxB,OAJAmU,EAAQs2B,KAAK,gBACbt2B,EAAQ21B,MAAM,cACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,cACNs2C,CACT,CAgBA,SAASA,EAAgB/gF,GAGvB,OAAO4xE,GAAc5xE,GAAQgyE,GAAa79D,EAAS6sE,EAAuB,aAAc/qD,EAAKi6C,OAAOa,WAAWsD,QAAQC,KAAKzrF,SAAS,qBAAkBzI,EAAY,EAAtI4xF,CAAyIhyE,GAAQghF,EAAsBhhF,EACtM,CAgBA,SAASghF,EAAsBhhF,GAE7B,OADAmU,EAAQ21B,MAAM,gBACP81C,EAAY5/E,EACrB,CACF,GCzpBO,MAAMihF,GAAiB,CAC5BhmG,KAAM,iBACNk6F,WAAY6H,GAAS7H,WACrBhD,SAQF,SAAgCh+D,EAASwR,EAAIyuD,GAC3C,MAAMn+C,EAAOp4C,KACb,OAYA,SAAemiB,GAMb,OALAmU,EAAQ21B,MAAM,aACd31B,EAAQ21B,MAAM,eACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,eACbt2B,EAAQs2B,KAAK,aACNgqC,CACT,EAGA,SAASA,EAAMz0E,GAKb,OAAgB,KAATA,GAAe,2BAA4Bi2B,EAAKi6C,OAAOa,WAAaqD,EAAIp0E,GAAQ2lB,EAAG3lB,EAC5F,CACF,GC3CO,MAAMkhF,GAAkB,CAC7BjmG,KAAM,kBACNk3F,SAQF,SAAiCh+D,EAASwR,EAAIyuD,GAC5C,OAaA,SAAep0E,GAGb,OAFAmU,EAAQ21B,MAAM,mBACd31B,EAAQ+9D,QAAQlyE,GACTy0E,CACT,EAaA,SAASA,EAAMz0E,GACb,OAAI0xE,GAAmB1xE,IACrBmU,EAAQs2B,KAAK,mBACN9kB,EAAG3lB,IAELo0E,EAAIp0E,EACb,CACF,GC7CO,MAAMmhF,GAAW,CACtBlmG,KAAM,WACNq1F,SA2DF,SAAkBtwE,GAEhB,OAAgB,KAATA,GAA+D,oBAAhDniB,KAAK0xF,OAAO1xF,KAAK0xF,OAAOtzF,OAAS,GAAG,GAAGmD,IAC/D,EA7DE+sB,QAMF,SAAyBojE,GACvB,IAGIh+D,EAEAu4B,EALAs3C,EAAgB7R,EAAOtzF,OAAS,EAChColG,EAAiB,EAOrB,IAAwC,eAAnC9R,EAAO8R,GAAgB,GAAGjiG,MAA4D,UAAnCmwF,EAAO8R,GAAgB,GAAGjiG,QAAwD,eAAlCmwF,EAAO6R,GAAe,GAAGhiG,MAA2D,UAAlCmwF,EAAO6R,GAAe,GAAGhiG,MAIjL,IAHAmyB,EAAQ8vE,IAGC9vE,EAAQ6vE,GACf,GAA8B,iBAA1B7R,EAAOh+D,GAAO,GAAGnyB,KAAyB,CAE5CmwF,EAAO8R,GAAgB,GAAGjiG,KAAO,kBACjCmwF,EAAO6R,GAAe,GAAGhiG,KAAO,kBAChCiiG,GAAkB,EAClBD,GAAiB,EACjB,KACF,CAKJ7vE,EAAQ8vE,EAAiB,EACzBD,IACA,OAAS7vE,GAAS6vE,QACFhhG,IAAV0pD,EACEv4B,IAAU6vE,GAA2C,eAA1B7R,EAAOh+D,GAAO,GAAGnyB,OAC9C0qD,EAAQv4B,GAEDA,IAAU6vE,GAA2C,eAA1B7R,EAAOh+D,GAAO,GAAGnyB,OACrDmwF,EAAOzlC,GAAO,GAAG1qD,KAAO,eACpBmyB,IAAUu4B,EAAQ,IACpBylC,EAAOzlC,GAAO,GAAGhsD,IAAMyxF,EAAOh+D,EAAQ,GAAG,GAAGzzB,IAC5CyxF,EAAOzkD,OAAOgf,EAAQ,EAAGv4B,EAAQu4B,EAAQ,GACzCs3C,GAAiB7vE,EAAQu4B,EAAQ,EACjCv4B,EAAQu4B,EAAQ,GAElBA,OAAQ1pD,GAGZ,OAAOmvF,CACT,EAlDE4C,SAmEF,SAA0Bh+D,EAASwR,EAAIyuD,GAErC,IAEI7xD,EAEAutD,EAJAmM,EAAW,EAKf,OAcA,SAAej8E,GAGb,OAFAmU,EAAQ21B,MAAM,YACd31B,EAAQ21B,MAAM,oBACPqvC,EAAan5E,EACtB,EAYA,SAASm5E,EAAan5E,GACpB,OAAa,KAATA,GACFmU,EAAQ+9D,QAAQlyE,GAChBi8E,IACO9C,IAEThlE,EAAQs2B,KAAK,oBACN62C,EAAQthF,GACjB,CAYA,SAASshF,EAAQthF,GAEf,OAAa,OAATA,EACKo0E,EAAIp0E,GAMA,KAATA,GACFmU,EAAQ21B,MAAM,SACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,SACN62C,GAII,KAATthF,GACF8vE,EAAQ37D,EAAQ21B,MAAM,oBACtBvnB,EAAO,EACAy5D,EAAch8E,IAEnB0xE,GAAmB1xE,IACrBmU,EAAQ21B,MAAM,cACd31B,EAAQ+9D,QAAQlyE,GAChBmU,EAAQs2B,KAAK,cACN62C,IAITntE,EAAQ21B,MAAM,gBACPtrC,EAAKwB,GACd,CAYA,SAASxB,EAAKwB,GACZ,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAe0xE,GAAmB1xE,IACpEmU,EAAQs2B,KAAK,gBACN62C,EAAQthF,KAEjBmU,EAAQ+9D,QAAQlyE,GACTxB,EACT,CAYA,SAASw9E,EAAch8E,GAErB,OAAa,KAATA,GACFmU,EAAQ+9D,QAAQlyE,GAChBuiB,IACOy5D,GAILz5D,IAAS05D,GACX9nE,EAAQs2B,KAAK,oBACbt2B,EAAQs2B,KAAK,YACN9kB,EAAG3lB,KAIZ8vE,EAAM1wF,KAAO,eACNof,EAAKwB,GACd,CACF,GCxNO,MAAMrb,GAAW,CACtB,GAAMooE,GACN,GAAMA,GACN,GAAMA,GACN,GAAMA,GACN,GAAMA,GACN,GAAMA,GACN,GAAMA,GACN,GAAMA,GACN,GAAMA,GACN,GAAMA,GACN,GAAMA,GACN,GAAMA,GACN,GAAMA,GACN,GAAMkqB,IAIK3E,GAAiB,CAC5B,GAAMh/C,IAIK0hD,GAAc,CACzB,EAAE,GAAI+D,GACN,EAAE,GAAIA,GACN,GAAMA,IAIKjF,GAAO,CAClB,GAAMoF,GACN,GAAMhD,GACN,GAAM,CAACmD,GAAiBnD,IACxB,GAAMyD,GACN,GAAMN,GACN,GAAMnD,GACN,GAAM0F,GACN,IAAOA,IAII34F,GAAS,CACpB,GAAM25F,GACN,GAAME,IAIK55E,GAAO,CAClB,EAAE,GAAI65E,GACN,EAAE,GAAIA,GACN,EAAE,GAAIA,GACN,GAAMyB,GACN,GAAM5B,GACN,GAAM8B,GACN,GAAM,CAACS,GAAUQ,IACjB,GAAMsB,GACN,GAAM,CAACC,GAAiBpE,IACxB,GAAME,GACN,GAAM0B,GACN,GAAMyC,IAIK7D,GAAa,CACxBhJ,KAAM,CAACoK,GAAW6C,KAIPrC,GAAmB,CAC9B5K,KAAM,CAAC,GAAI,KAIAD,GAAU,CACrBC,KAAM,ICvBD,SAASkN,GAAgBtR,EAAQuR,EAAYjhB,GAElD,IAAI2H,EAAQ,CACV6N,cAAe,EACfC,OAAQ,EACRx4F,KAAM+iF,GAAQA,EAAK/iF,MAAQ,EAC3BP,OAAQsjF,GAAQA,EAAKtjF,QAAU,EAC/BgoB,OAAQs7D,GAAQA,EAAKt7D,QAAU,GAGjC,MAAMw8E,EAAc,CAAC,EAEfC,EAAuB,GAE7B,IAAIhM,EAAS,GAETztF,EAAQ,GAER05F,GAAW,EAOf,MAAMztE,EAAU,CACdk+D,QAASwP,GAoNX,SAA+Br5F,EAAWq8D,GACxCi9B,EAAUt5F,EAAWq8D,EAAK2b,KAC5B,IArNE/b,MAAOo9B,EAAiBE,GACxB7P,QAsJF,SAAiBlyE,GACX0xE,GAAmB1xE,IACrBmoE,EAAM1qF,OACN0qF,EAAMjrF,OAAS,EACfirF,EAAMjjE,SAAoB,IAAVlF,EAAc,EAAI,EAClCgiF,MACmB,IAAVhiF,IACTmoE,EAAMjrF,SACNirF,EAAMjjE,UAIJijE,EAAM6N,aAAe,EACvB7N,EAAM8N,UAEN9N,EAAM6N,eAGF7N,EAAM6N,eAIVL,EAAOxN,EAAM8N,QAAQh6F,SACnBksF,EAAM6N,cAAgB,EACtB7N,EAAM8N,WAKV7iE,EAAQk9D,SAAWtwE,EAGnB4hF,GAAW,CACb,EAtLE93C,MAyLF,SAAe1qD,EAAM6iG,GAGnB,MAAMnS,EAAQmS,GAAU,CAAC,EAKzB,OAJAnS,EAAM1wF,KAAOA,EACb0wF,EAAMtyF,MAAQye,IACdmX,EAAQm8D,OAAO9wF,KAAK,CAAC,QAASqxF,EAAO18D,IACrClrB,EAAMzJ,KAAKqxF,GACJA,CACT,EAjMErlC,KAoMF,SAAcrrD,GACZ,MAAM0wF,EAAQ5nF,EAAMqoC,MAGpB,OAFAu/C,EAAMhyF,IAAMme,IACZmX,EAAQm8D,OAAO9wF,KAAK,CAAC,OAAQqxF,EAAO18D,IAC7B08D,CACT,EAxME0D,UAAWqO,EAAiBE,EAAmB,CAC7CvO,WAAW,KASTpgE,EAAU,CACdpT,KAAM,KACNm0C,eAAgB,CAAC,EACjBs8B,WA8EF,SAAoBr1F,GAClBsmG,EAAYtmG,EAAMqC,MAAQrC,EAAM8B,OAChC8kG,GACF,EAhFEzS,OAAQ,GACRtzE,MACAi0E,SACAI,SAAU,KACVyE,eA4CF,SAAwBjF,EAAOoS,GAC7B,OAsZJ,SAAyBvM,EAAQuM,GAC/B,IAAI3wE,GAAS,EAEb,MAAMtwB,EAAS,GAEf,IAAIkhG,EACJ,OAAS5wE,EAAQokE,EAAO15F,QAAQ,CAC9B,MAAM65F,EAAQH,EAAOpkE,GAErB,IAAIn2B,EACJ,GAAqB,kBAAV06F,EACT16F,EAAQ06F,OACH,OAAQA,GACb,KAAM,EAEF16F,EAAQ,KACR,MAEJ,KAAM,EAEFA,EAAQ,KACR,MAEJ,KAAM,EAEFA,EAAQ,OACR,MAEJ,KAAM,EAEFA,EAAQ8mG,EAAa,IAAM,KAC3B,MAEJ,KAAM,EAEF,IAAKA,GAAcC,EAAO,SAC1B/mG,EAAQ,IACR,MAEJ,QAGIA,EAAQ0kB,OAAOC,aAAa+1E,GAGlCqM,GAAmB,IAAXrM,EACR70F,EAAOxC,KAAKrD,EACd,CACA,OAAO6F,EAAOmwB,KAAK,GACrB,CAvcWgxE,CAAgB5R,EAAYV,GAAQoS,EAC7C,EA7CE1R,cACAG,MAsBF,SAAe9xF,GAKb,GAJA82F,EAASl3F,GAAKk3F,EAAQ92F,GACtBwjG,IAGkC,OAA9B1M,EAAOA,EAAO15F,OAAS,GACzB,MAAO,GAMT,OAJA6lG,EAAUL,EAAY,GAGtBruE,EAAQm8D,OAAS4F,GAAWwM,EAAsBvuE,EAAQm8D,OAAQn8D,GAC3DA,EAAQm8D,MACjB,GA3BA,IAOI+S,EAPA7lE,EAAQglE,EAAWtP,SAAS53F,KAAK64B,EAASe,GAW9C,OAHIstE,EAAWtM,YACbwM,EAAqBljG,KAAKgjG,GAErBruE,EA4BP,SAASo9D,EAAYV,GACnB,OA2WJ,SAAqB6F,EAAQ7F,GAC3B,MAAMvyC,EAAauyC,EAAMtyF,MAAMy4F,OACzBsM,EAAmBzS,EAAMtyF,MAAMw4F,aAC/BwM,EAAW1S,EAAMhyF,IAAIm4F,OACrBwM,EAAiB3S,EAAMhyF,IAAIk4F,aAEjC,IAAI35E,EACJ,GAAIkhC,IAAeilD,EAEjBnmF,EAAO,CAACs5E,EAAOp4C,GAAY1+C,MAAM0jG,EAAkBE,QAC9C,CAEL,GADApmF,EAAOs5E,EAAO92F,MAAM0+C,EAAYilD,GAC5BD,GAAoB,EAAG,CACzB,MAAMvtD,EAAO34B,EAAK,GACE,kBAAT24B,EACT34B,EAAK,GAAK24B,EAAKn2C,MAAM0jG,GAErBlmF,EAAKnD,OAET,CACIupF,EAAiB,GAEnBpmF,EAAK5d,KAAKk3F,EAAO6M,GAAU3jG,MAAM,EAAG4jG,GAExC,CACA,OAAOpmF,CACT,CArYWqmF,CAAY/M,EAAQ7F,EAC7B,CAGA,SAAS7zE,IAEP,MAAM,aACJ+5E,EAAY,OACZC,EAAM,KACNx4F,EAAI,OACJP,EAAM,OACNgoB,GACEijE,EACJ,MAAO,CACL6N,eACAC,SACAx4F,OACAP,SACAgoB,SAEJ,CAuBA,SAASm9E,IAEP,IAAIM,EACJ,KAAOxa,EAAM8N,OAASN,EAAO15F,QAAQ,CACnC,MAAM65F,EAAQH,EAAOxN,EAAM8N,QAG3B,GAAqB,kBAAVH,EAKT,IAJA6M,EAAaxa,EAAM8N,OACf9N,EAAM6N,aAAe,IACvB7N,EAAM6N,aAAe,GAEhB7N,EAAM8N,SAAW0M,GAAcxa,EAAM6N,aAAeF,EAAM75F,QAC/D88C,EAAG+8C,EAAMC,WAAW5N,EAAM6N,oBAG5Bj9C,EAAG+8C,EAEP,CACF,CAUA,SAAS/8C,EAAG/4B,GACV4hF,OAAWxhG,EACXkiG,EAAetiF,EACfyc,EAAQA,EAAMzc,EAChB,CAwEA,SAAS+hF,EAAkB/kD,EAAG6nB,GAC5BA,EAAKhJ,SACP,CAUA,SAASgmC,EAAiBe,EAAUX,GAClC,OAeA,SAAclR,EAAY6O,EAAaiD,GAErC,IAAIC,EAEAC,EAEA1P,EAEAxuB,EACJ,OAAOvqE,MAAMF,QAAQ22F,GACrBiS,EAAuBjS,GAAc,aAAcA,EAEnDiS,EAAuB,CAAC,IAUxB,SAA+Bn0D,GAC7B,OAAOrxC,EAGP,SAASA,EAAMwiB,GACb,MAAMgH,EAAgB,OAAThH,GAAiB6uB,EAAI7uB,GAC5ByzB,EAAe,OAATzzB,GAAiB6uB,EAAIylD,KAKjC,OAAO0O,EAJM,IAGT1oG,MAAMF,QAAQ4sB,GAAQA,EAAOA,EAAO,CAACA,GAAQ,MAAS1sB,MAAMF,QAAQq5C,GAAOA,EAAMA,EAAM,CAACA,GAAO,IAC5FuvD,CAA6BhjF,EACtC,CACF,CAvBiEijF,CAAsBlS,GAiCvF,SAASiS,EAAuBj2B,GAG9B,OAFA+1B,EAAmB/1B,EACnBg2B,EAAiB,EACG,IAAhBh2B,EAAK9wE,OACA4mG,EAEFK,EAAgBn2B,EAAKg2B,GAC9B,CAUA,SAASG,EAAgB16F,GACvB,OAGA,SAAewX,GAKb6kD,EAgER,WACE,MAAMs+B,EAAalnF,IACbmnF,EAAgBhwE,EAAQk9D,SACxB+S,EAAwBjwE,EAAQigE,iBAChCiQ,EAAmBlwE,EAAQm8D,OAAOtzF,OAClCsnG,EAAajpG,MAAMkmF,KAAKt4E,GAC9B,MAAO,CACLs4E,KAAM8iB,EACNznC,WASF,SAASA,IACPssB,EAAQgb,EACR/vE,EAAQk9D,SAAW8S,EACnBhwE,EAAQigE,iBAAmBgQ,EAC3BjwE,EAAQm8D,OAAOtzF,OAASqnG,EACxBp7F,EAAQq7F,EACRvB,GACF,CACF,CAzFewB,GACPnQ,EAAmB7qF,EACdA,EAAUgsF,UACbphE,EAAQigE,iBAAmB7qF,GAK7B,GAAIA,EAAUvN,MAAQm4B,EAAQ88D,OAAOa,WAAWsD,QAAQC,KAAKzrF,SAASL,EAAUvN,MAC9E,OAAOm5F,EAAIp0E,GAEb,OAAOxX,EAAU2pF,SAAS53F,KAI1B0nG,EAASroG,OAAOoO,OAAOpO,OAAOq/B,OAAO7F,GAAU6uE,GAAU7uE,EAASe,EAASwR,EAAIyuD,EAJxE5rF,CAI6EwX,EACtF,CACF,CAGA,SAAS2lB,EAAG3lB,GAGV,OAFA4hF,GAAW,EACXgB,EAASvP,EAAkBxuB,GACpB+6B,CACT,CAGA,SAASxL,EAAIp0E,GAGX,OAFA4hF,GAAW,EACX/8B,EAAKhJ,YACCknC,EAAiBD,EAAiB7mG,OAC/BinG,EAAgBJ,EAAiBC,IAEnCF,CACT,CACF,CACF,CAUA,SAASf,EAAUt5F,EAAWg4E,GACxBh4E,EAAU2sF,aAAewM,EAAqB94F,SAASL,IACzDm5F,EAAqBljG,KAAK+J,GAExBA,EAAU2jB,SACZ2e,GAAO1X,EAAQm8D,OAAQ/O,EAAMptD,EAAQm8D,OAAOtzF,OAASukF,EAAMh4E,EAAU2jB,QAAQiH,EAAQm8D,OAAO1wF,MAAM2hF,GAAOptD,IAEvG5qB,EAAU8wF,YACZlmE,EAAQm8D,OAAS/mF,EAAU8wF,UAAUlmE,EAAQm8D,OAAQn8D,GAEzD,CA0CA,SAAS4uE,IACH7Z,EAAM1qF,QAAQikG,GAAevZ,EAAMjrF,OAAS,IAC9CirF,EAAMjrF,OAASwkG,EAAYvZ,EAAM1qF,MACjC0qF,EAAMjjE,QAAUw8E,EAAYvZ,EAAM1qF,MAAQ,EAE9C,CACF,CCteO,SAASgmG,GAAMzoG,GACpB,MACM+1F,ExCLD,SAA2B2S,GAEhC,MAAMjwD,EAAM,CAAC,EACb,IAAIliB,GAAS,EAEb,OAASA,EAAQmyE,EAAWznG,QAC1B20F,GAAgBn9C,EAAKiwD,EAAWnyE,IAGlC,OAAOkiB,CACT,CwCJEkwD,CAAkB,CAACC,MAFF5oG,GAAW,CAAC,GAEsB0oG,YAAc,KAG3DxT,EAAS,CACba,aACA/yF,QAASi7B,EAAOj7B,IAChBimE,QAAS,GACTt/D,SAAUs0B,EAAOt0B,IACjBmvF,KAAM76D,EAAO66D,IACb3jD,KAAM,CAAC,EACPltC,OAAQg2B,EAAOh2B,IACfigB,KAAM+V,EAAO/V,KAEf,OAAOgtE,EAQP,SAASj3D,EAAOk9B,GACd,OAEA,SAAiBqqB,GACf,OAAOghB,GAAgBtR,EAAQ/5B,EAASqqB,EAC1C,CACF,CACF,CCtCA,MAAMx9D,GAAS,cCHR,SAAS6gF,GAAgCzoG,EAAOgV,GACrD,MAAM4P,EAAOylC,OAAOoK,SAASz0D,EAAOgV,GACpC,OAEA4P,EAAO,GAAc,KAATA,GAAeA,EAAO,IAAMA,EAAO,IAE/CA,EAAO,KAAOA,EAAO,KAErBA,EAAO,OAAUA,EAAO,OAExBA,EAAO,OAAUA,EAAO,OACJ,SAAZ,MAAPA,IAAiD,SAAZ,MAAPA,IAE/BA,EAAO,QACE,SAEFF,OAAOgkF,cAAc9jF,EAC9B,CC7BA,MAAM+jF,GAA6B,oEA4BnC,SAASC,GAAOlc,EAAI4F,EAAIuW,GACtB,GAAIvW,EAEF,OAAOA,EAKT,GAAa,KADAuW,EAAGlO,WAAW,GACV,CACf,MAAM/gD,EAAOivD,EAAGlO,WAAW,GACrBmO,EAAe,MAATlvD,GAAyB,KAATA,EAC5B,OAAO6uD,GAAgCI,EAAGplG,MAAMqlG,EAAM,EAAI,GAAIA,EAAM,GAAK,GAC3E,CACA,OAAOvH,GAA8BsH,IAAOnc,CAC9C,CCIA,MAAMnjB,GAAM,CAAC,EAAE7qE,eAyBR,SAASqqG,GAAa/oG,EAAOgpG,EAAUppG,GAK5C,MAJwB,kBAAbopG,IACTppG,EAAUopG,EACVA,OAAWhkG,GAUf,SAAkBpF,GAEhB,MAAM4qD,EAAS,CACb+C,WAAY,GACZ07C,eAAgB,CAAC,WAAY,WAAY,UAAW,YAAa,UACjEv6C,MAAO,CACLq1C,SAAUmF,EAAO1zF,IACjB2zF,iBAAkBC,EAClBC,cAAeD,EACfE,WAAYJ,EAAO/K,GACnBtC,WAAYqN,EAAOrN,GACnB6F,gBAAiB0H,EACjB5H,mBAAoB4H,EACpB5I,WAAY0I,EAAOK,GACnBC,oBAAqB/K,EACrBgL,oBAAqBhL,EACrBd,aAAcuL,EAAOK,EAAU9K,GAC/BsH,SAAUmD,EAAOnD,EAAUtH,GAC3BiL,aAAcN,EACdhmF,KAAMgmF,EACNO,cAAeP,EACflxD,WAAYgxD,EAAOhxD,GACnB0xD,4BAA6BnL,EAC7BoL,sBAAuBpL,EACvBqL,sBAAuBrL,EACvBsL,SAAUb,EAAOa,GACjBjE,gBAAiBoD,EAAOc,GACxBC,kBAAmBf,EAAOc,GAC1BzL,SAAU2K,EAAOr7B,EAAM4wB,GACvByL,aAAcd,EACd7E,SAAU2E,EAAOr7B,EAAM4wB,GACvB0L,aAAcf,EACdgB,MAAOlB,EAAOkB,IACd50C,MAAOipC,EACPjpF,KAAM0zF,EAAO1zF,IACb60F,SAAUnB,EAAOmB,IACjBC,cAAeC,EACfC,YAAatB,EAAOv3B,GAAM84B,GAC1BC,cAAexB,EAAOv3B,IACtBysB,UAAW8K,EAAO9K,IAClBuM,UAAWC,EACXC,gBAAiBpM,EACjBqM,0BAA2BrM,EAC3BsM,oBAAqBtM,EACrBuM,cAAe9B,EAAO/K,GACtB8M,OAAQ/B,EAAO+B,IACfnQ,cAAeoO,EAAOpO,KAExBzrC,KAAM,CACJi6C,WAAY4B,IACZC,mBAAoBC,EACpBrH,SAAUmH,IACV7B,cAAegC,EACflC,iBAAkBmC,EAClBzP,WAAYqP,IACZK,qBAAsBC,EACtBC,oCAAqCC,EACrCC,gCAAiCD,EACjCE,wBAAyBC,EACzBrK,mBAAoBsK,EACpBtL,WAAY0K,EAAOa,GACnBC,gBAAiBC,EACjBzC,oBAAqB0C,EACrBzC,oBAAqB0C,EACrBxC,cAAe6B,EACf7N,aAAcuN,EAAOkB,GACrBrG,SAAUmF,EAAOmB,GACjB3C,aAAc8B,EACdpoF,KAAMooF,EACNtzD,WAAYgzD,IACZtB,4BAA6B0C,EAC7BzC,sBAAuB0C,EACvBzC,sBAAuB0C,EACvBzC,SAAUmB,IACVpF,gBAAiBoF,EAAOuB,GACxBxC,kBAAmBiB,EAAOuB,GAC1BlO,SAAU2M,EAAOwB,GACjBxC,aAAcsB,EACdjH,SAAU2G,EAAOyB,GACjBxC,aAAcqB,EACdpB,MAAOc,EAAO0B,GACdp3C,MAAOq3C,EACPC,UAAWC,EACXpL,WAAYqL,EACZx3F,KAAM01F,EAAO+B,GACb5C,SAAUa,IACVV,YAAaU,IACbR,cAAeQ,IACf9M,UAAW8M,IACXL,gBAAiBqC,EACjBpC,0BAA2BqC,EAC3BpC,oBAAqBqC,EACrB7jB,SAAU8jB,EACVrC,cAAeE,EAAOoC,GACtBC,0BAA2BC,EAC3BC,kBAAmBC,EACnBzC,OAAQC,IACRpQ,cAAeoQ,MAGnByC,GAAUnjD,GAAS5qD,GAAW,CAAC,GAAGguG,iBAAmB,IAGrD,MAAMxqF,EAAO,CAAC,EACd,OAAOyqF,EAUP,SAASA,EAAQ1Z,GAEf,IAAI9F,EAAO,CACTrqF,KAAM,OACNsM,SAAU,IAGZ,MAAM0nB,EAAU,CACdlrB,MAAO,CAACuhF,GACRyf,WAAY,GACZtjD,SACAkE,QACAW,OACAovC,SACAsP,SACA3qF,QAGI4qF,EAAY,GAClB,IAAI73E,GAAS,EACb,OAASA,EAAQg+D,EAAOtzF,QAGtB,GAA8B,gBAA1BszF,EAAOh+D,GAAO,GAAGnyB,MAAoD,kBAA1BmwF,EAAOh+D,GAAO,GAAGnyB,KAC9D,GAAyB,UAArBmwF,EAAOh+D,GAAO,GAChB63E,EAAU3qG,KAAK8yB,OACV,CAELA,EAAQ83E,EAAY9Z,EADP6Z,EAAU74D,MACWhf,EACpC,CAIJ,IADAA,GAAS,IACAA,EAAQg+D,EAAOtzF,QAAQ,CAC9B,MAAMoqD,EAAUT,EAAO2pC,EAAOh+D,GAAO,IACjCozC,GAAIpqE,KAAK8rD,EAASkpC,EAAOh+D,GAAO,GAAGnyB,OACrCinD,EAAQkpC,EAAOh+D,GAAO,GAAGnyB,MAAM7E,KAAKX,OAAOoO,OAAO,CAChD+sF,eAAgBxF,EAAOh+D,GAAO,GAAGwjE,gBAChC3hE,GAAUm8D,EAAOh+D,GAAO,GAE/B,CAGA,GAAI6B,EAAQ81E,WAAWjtG,OAAS,EAAG,CACjC,MAAM0lC,EAAOvO,EAAQ81E,WAAW91E,EAAQ81E,WAAWjtG,OAAS,IAC5C0lC,EAAK,IAAM2nE,IACnB/uG,KAAK64B,OAAShzB,EAAWuhC,EAAK,GACxC,CAkBA,IAfA8nD,EAAKlsF,SAAW,CACdC,MAAO2qF,GAAMoH,EAAOtzF,OAAS,EAAIszF,EAAO,GAAG,GAAG/xF,MAAQ,CACpDC,KAAM,EACNP,OAAQ,EACRgoB,OAAQ,IAEVpnB,IAAKqqF,GAAMoH,EAAOtzF,OAAS,EAAIszF,EAAOA,EAAOtzF,OAAS,GAAG,GAAG6B,IAAM,CAChEL,KAAM,EACNP,OAAQ,EACRgoB,OAAQ,KAKZqM,GAAS,IACAA,EAAQq0B,EAAO+C,WAAW1sD,QACjCwtF,EAAO7jC,EAAO+C,WAAWp3B,GAAOk4D,IAASA,EAE3C,OAAOA,CACT,CAQA,SAAS4f,EAAY9Z,EAAQ/xF,EAAOvB,GAClC,IAIIwpG,EAEAvW,EAEAqa,EAEA3S,EAVArlE,EAAQ/zB,EAAQ,EAChBgsG,GAAoB,EACpBC,GAAa,EASjB,OAASl4E,GAASt1B,GAAQ,CACxB,MAAMwnB,EAAQ8rE,EAAOh+D,GACrB,OAAQ9N,EAAM,GAAGrkB,MACf,IAAK,gBACL,IAAK,cACL,IAAK,aAEgB,UAAbqkB,EAAM,GACR+lF,IAEAA,IAEF5S,OAAWx2F,EACX,MAEJ,IAAK,kBAEgB,UAAbqjB,EAAM,MACJgiF,GAAa7O,GAAa4S,GAAqBD,IACjDA,EAAsBh4E,GAExBqlE,OAAWx2F,GAEb,MAEJ,IAAK,aACL,IAAK,gBACL,IAAK,iBACL,IAAK,iBACL,IAAK,2BAID,MAEJ,QAEIw2F,OAAWx2F,EAGjB,IAAKopG,GAAiC,UAAb/lF,EAAM,IAAoC,mBAAlBA,EAAM,GAAGrkB,OAAmD,IAAtBoqG,GAAwC,SAAb/lF,EAAM,KAAoC,kBAAlBA,EAAM,GAAGrkB,MAA8C,gBAAlBqkB,EAAM,GAAGrkB,MAAyB,CAC/M,GAAIqmG,EAAU,CACZ,IAAIiE,EAAYn4E,EAEhB,IADA29D,OAAY9uF,EACLspG,KAAa,CAClB,MAAMC,EAAYpa,EAAOma,GACzB,GAA0B,eAAtBC,EAAU,GAAGvqG,MAA+C,oBAAtBuqG,EAAU,GAAGvqG,KAA4B,CACjF,GAAqB,SAAjBuqG,EAAU,GAAe,SACzBza,IACFK,EAAOL,GAAW,GAAG9vF,KAAO,kBAC5BqqG,GAAa,GAEfE,EAAU,GAAGvqG,KAAO,aACpB8vF,EAAYwa,CACd,MAAO,GAA0B,eAAtBC,EAAU,GAAGvqG,MAA+C,qBAAtBuqG,EAAU,GAAGvqG,MAAqD,+BAAtBuqG,EAAU,GAAGvqG,MAA+D,qBAAtBuqG,EAAU,GAAGvqG,MAAqD,mBAAtBuqG,EAAU,GAAGvqG,KAG1M,KAEJ,CACImqG,KAAyBra,GAAaqa,EAAsBra,KAC9DuW,EAASmE,SAAU,GAIrBnE,EAAS3nG,IAAMlE,OAAOoO,OAAO,CAAC,EAAGknF,EAAYK,EAAOL,GAAW,GAAG1xF,MAAQimB,EAAM,GAAG3lB,KACnFyxF,EAAOzkD,OAAOokD,GAAa39D,EAAO,EAAG,CAAC,OAAQk0E,EAAUhiF,EAAM,KAC9D8N,IACAt1B,GACF,CAGA,GAAsB,mBAAlBwnB,EAAM,GAAGrkB,KAA2B,CAEtC,MAAMwvF,EAAO,CACXxvF,KAAM,WACNwqG,SAAS,EACTpsG,MAAO5D,OAAOoO,OAAO,CAAC,EAAGyb,EAAM,GAAGjmB,OAElCM,SAAKsC,GAEPqlG,EAAW7W,EACXW,EAAOzkD,OAAOvZ,EAAO,EAAG,CAAC,QAASq9D,EAAMnrE,EAAM,KAC9C8N,IACAt1B,IACAstG,OAAsBnpG,EACtBw2F,GAAW,CACb,CACF,CACF,CAEA,OADArH,EAAO/xF,GAAO,GAAGosG,QAAUH,EACpBxtG,CACT,CAYA,SAASqoG,EAAOrrE,EAAQi5B,GACtB,OAAO6gB,EAOP,SAASA,EAAK+c,GACZhmC,EAAMvvD,KAAKsD,KAAMo7B,EAAO62D,GAAQA,GAC5B59B,GAAKA,EAAI33D,KAAKsD,KAAMiyF,EAC1B,CACF,CAKA,SAAS+J,IACPh8F,KAAKqK,MAAMzJ,KAAK,CACdW,KAAM,WACNsM,SAAU,IAEd,CAKA,SAASo+C,EAAMpsD,EAAMoyF,EAAO+Z,GACXhsG,KAAKqK,MAAMrK,KAAKqK,MAAMjM,OAAS,GAEtByP,SACfjN,KAAKf,GACdG,KAAKqK,MAAMzJ,KAAKf,GAChBG,KAAKqrG,WAAWzqG,KAAK,CAACqxF,EAAO+Z,QAAgBzpG,IAC7C1C,EAAKH,SAAW,CACdC,MAAO2qF,GAAM2H,EAAMtyF,OAEnBM,SAAKsC,EAET,CAUA,SAASkmG,EAAOp0C,GACd,OAAOgrC,EAOP,SAASA,EAAMpN,GACT59B,GAAKA,EAAI33D,KAAKsD,KAAMiyF,GACxBrlC,EAAKlwD,KAAKsD,KAAMiyF,EAClB,CACF,CAKA,SAASrlC,EAAKqlC,EAAOga,GACnB,MAAMpsG,EAAOG,KAAKqK,MAAMqoC,MAClBwiC,EAAOl1E,KAAKqrG,WAAW34D,MAC7B,IAAKwiC,EACH,MAAM,IAAI10E,MAAM,iBAAmByxF,EAAM1wF,KAAO,MAAQipF,GAAkB,CACxE7qF,MAAOsyF,EAAMtyF,MACbM,IAAKgyF,EAAMhyF,MACR,yBACA,GAAIi1E,EAAK,GAAG3zE,OAAS0wF,EAAM1wF,KAChC,GAAI0qG,EACFA,EAAYvvG,KAAKsD,KAAMiyF,EAAO/c,EAAK,QAC9B,EACWA,EAAK,IAAMu2B,IACnB/uG,KAAKsD,KAAMiyF,EAAO/c,EAAK,GACjC,CAEFr1E,EAAKH,SAASO,IAAMqqF,GAAM2H,EAAMhyF,IAClC,CAKA,SAASqrG,IACP,OhDvcG,SAAkB/tG,EAAOJ,GAC9B,MAAMuxF,EAAWvxF,GAAWkoE,GAQ5B,OAAO2nB,GAAIzvF,EAN2B,mBAA7BmxF,EAASsB,iBACZtB,EAASsB,gBAGmB,mBAAzBtB,EAASuB,aAA4BvB,EAASuB,YAGzD,CgD6bW9zF,CAAS6D,KAAKqK,MAAMqoC,MAC7B,CAUA,SAASs1D,IACPhoG,KAAK2gB,KAAKurF,6BAA8B,CAC1C,CAMA,SAASpE,EAAqB7V,GAC5B,GAAIjyF,KAAK2gB,KAAKurF,4BAA6B,CACxBlsG,KAAKqK,MAAMrK,KAAKqK,MAAMjM,OAAS,GACvCuB,MAAQioD,OAAOoK,SAAShyD,KAAKk3F,eAAejF,GAAQ,IAC7DjyF,KAAK2gB,KAAKurF,iCAA8B3pG,CAC1C,CACF,CAMA,SAASknG,IACP,MAAM9oF,EAAO3gB,KAAKsrG,SACLtrG,KAAKqK,MAAMrK,KAAKqK,MAAMjM,OAAS,GACvC4wE,KAAOruD,CACd,CAMA,SAAS+oF,IACP,MAAM/oF,EAAO3gB,KAAKsrG,SACLtrG,KAAKqK,MAAMrK,KAAKqK,MAAMjM,OAAS,GACvC4U,KAAO2N,CACd,CAMA,SAAS6oF,IAEHxpG,KAAK2gB,KAAKwrF,iBACdnsG,KAAKg8F,SACLh8F,KAAK2gB,KAAKwrF,gBAAiB,EAC7B,CAMA,SAAS7C,IACP,MAAM3oF,EAAO3gB,KAAKsrG,SACLtrG,KAAKqK,MAAMrK,KAAKqK,MAAMjM,OAAS,GACvCb,MAAQojB,EAAK1hB,QAAQ,2BAA4B,IACtDe,KAAK2gB,KAAKwrF,oBAAiB5pG,CAC7B,CAMA,SAASonG,IACP,MAAMhpF,EAAO3gB,KAAKsrG,SACLtrG,KAAKqK,MAAMrK,KAAKqK,MAAMjM,OAAS,GACvCb,MAAQojB,EAAK1hB,QAAQ,eAAgB,GAC5C,CAMA,SAAS6qG,EAA4B7X,GACnC,MAAMl/B,EAAQ/yD,KAAKsrG,SACbzrG,EAAOG,KAAKqK,MAAMrK,KAAKqK,MAAMjM,OAAS,GAC5CyB,EAAKkzD,MAAQA,EACblzD,EAAK26F,WAAaD,GAAoBv6F,KAAKk3F,eAAejF,IAAQlqF,aACpE,CAMA,SAASgiG,IACP,MAAMppF,EAAO3gB,KAAKsrG,SACLtrG,KAAKqK,MAAMrK,KAAKqK,MAAMjM,OAAS,GACvC44E,MAAQr2D,CACf,CAMA,SAASkpF,IACP,MAAMlpF,EAAO3gB,KAAKsrG,SACLtrG,KAAKqK,MAAMrK,KAAKqK,MAAMjM,OAAS,GACvCmnB,IAAM5E,CACb,CAMA,SAASgoF,EAAyB1W,GAChC,MAAMpyF,EAAOG,KAAKqK,MAAMrK,KAAKqK,MAAMjM,OAAS,GAC5C,IAAKyB,EAAKusG,MAAO,CACf,MAAMA,EAAQpsG,KAAKk3F,eAAejF,GAAO7zF,OACzCyB,EAAKusG,MAAQA,CACf,CACF,CAMA,SAASnB,IACPjrG,KAAK2gB,KAAK0rF,8BAA+B,CAC3C,CAMA,SAAStB,EAAgC9Y,GAC1BjyF,KAAKqK,MAAMrK,KAAKqK,MAAMjM,OAAS,GACvCguG,MAAsD,KAA9CpsG,KAAKk3F,eAAejF,GAAOqa,YAAY,GAAY,EAAI,CACtE,CAMA,SAASzB,IACP7qG,KAAK2gB,KAAK0rF,kCAA+B9pG,CAC3C,CAOA,SAASokG,EAAY1U,GACnB,MAEMl2C,EAFO/7C,KAAKqK,MAAMrK,KAAKqK,MAAMjM,OAAS,GAEtByP,SACtB,IAAIi2B,EAAOiY,EAASA,EAAS39C,OAAS,GACjC0lC,GAAsB,SAAdA,EAAKviC,OAEhBuiC,EAAOze,KACPye,EAAKpkC,SAAW,CACdC,MAAO2qF,GAAM2H,EAAMtyF,OAEnBM,SAAKsC,GAEPw5C,EAASn7C,KAAKkjC,IAEhB9jC,KAAKqK,MAAMzJ,KAAKkjC,EAClB,CAOA,SAASilE,EAAW9W,GAClB,MAAMnuD,EAAO9jC,KAAKqK,MAAMqoC,MACxB5O,EAAKvmC,OAASyC,KAAKk3F,eAAejF,GAClCnuD,EAAKpkC,SAASO,IAAMqqF,GAAM2H,EAAMhyF,IAClC,CAOA,SAASsqG,EAAiBtY,GACxB,MAAM18D,EAAUv1B,KAAKqK,MAAMrK,KAAKqK,MAAMjM,OAAS,GAE/C,GAAI4B,KAAK2gB,KAAK4rF,YAAa,CAIzB,OAHah3E,EAAQ1nB,SAAS0nB,EAAQ1nB,SAASzP,OAAS,GACnDsB,SAASO,IAAMqqF,GAAM2H,EAAMhyF,UAChCD,KAAK2gB,KAAK4rF,iBAAchqG,EAE1B,EACKvC,KAAK2gB,KAAK0rF,8BAAgCtkD,EAAOy+C,eAAex7F,SAASuqB,EAAQh0B,QACpFolG,EAAYjqG,KAAKsD,KAAMiyF,GACvB8W,EAAWrsG,KAAKsD,KAAMiyF,GAE1B,CAOA,SAAS+X,IACPhqG,KAAK2gB,KAAK4rF,aAAc,CAC1B,CAOA,SAAStC,IACP,MAAMtpF,EAAO3gB,KAAKsrG,SACLtrG,KAAKqK,MAAMrK,KAAKqK,MAAMjM,OAAS,GACvCb,MAAQojB,CACf,CAOA,SAASupF,IACP,MAAMvpF,EAAO3gB,KAAKsrG,SACLtrG,KAAKqK,MAAMrK,KAAKqK,MAAMjM,OAAS,GACvCb,MAAQojB,CACf,CAOA,SAASipF,IACP,MAAMjpF,EAAO3gB,KAAKsrG,SACLtrG,KAAKqK,MAAMrK,KAAKqK,MAAMjM,OAAS,GACvCb,MAAQojB,CACf,CAOA,SAAS6pF,IACP,MAAM3qG,EAAOG,KAAKqK,MAAMrK,KAAKqK,MAAMjM,OAAS,GAK5C,GAAI4B,KAAK2gB,KAAK6rF,YAAa,CAEzB,MAAMC,EAAgBzsG,KAAK2gB,KAAK8rF,eAAiB,WACjD5sG,EAAK0B,MAAQ,YAEb1B,EAAK4sG,cAAgBA,SAEd5sG,EAAK0lB,WACL1lB,EAAKm3E,KACd,aAESn3E,EAAK26F,kBAEL36F,EAAKkzD,MAEd/yD,KAAK2gB,KAAK8rF,mBAAgBlqG,CAC5B,CAOA,SAAS4nG,IACP,MAAMtqG,EAAOG,KAAKqK,MAAMrK,KAAKqK,MAAMjM,OAAS,GAK5C,GAAI4B,KAAK2gB,KAAK6rF,YAAa,CAEzB,MAAMC,EAAgBzsG,KAAK2gB,KAAK8rF,eAAiB,WACjD5sG,EAAK0B,MAAQ,YAEb1B,EAAK4sG,cAAgBA,SAEd5sG,EAAK0lB,WACL1lB,EAAKm3E,KACd,aAESn3E,EAAK26F,kBAEL36F,EAAKkzD,MAEd/yD,KAAK2gB,KAAK8rF,mBAAgBlqG,CAC5B,CAOA,SAAS+nG,EAAgBrY,GACvB,MAAM7sF,EAASpF,KAAKk3F,eAAejF,GAC7Bya,EAAW1sG,KAAKqK,MAAMrK,KAAKqK,MAAMjM,OAAS,GAGhDsuG,EAAS35C,MDzwBN,SAAsBx1D,GAC3B,OAAOA,EAAM0B,QAAQinG,GAA4BC,GACnD,CCuwBqBwG,CAAavnG,GAE9BsnG,EAASlS,WAAaD,GAAoBn1F,GAAQ2C,aACpD,CAOA,SAASqiG,IACP,MAAMwC,EAAW5sG,KAAKqK,MAAMrK,KAAKqK,MAAMjM,OAAS,GAC1Cb,EAAQyC,KAAKsrG,SACbzrG,EAAOG,KAAKqK,MAAMrK,KAAKqK,MAAMjM,OAAS,GAG5C,GADA4B,KAAK2gB,KAAK6rF,aAAc,EACN,SAAd3sG,EAAK0B,KAAiB,CAExB,MAAMsM,EAAW++F,EAAS/+F,SAC1BhO,EAAKgO,SAAWA,CAClB,MACEhO,EAAKosE,IAAM1uE,CAEf,CAOA,SAASmtG,IACP,MAAM/pF,EAAO3gB,KAAKsrG,SACLtrG,KAAKqK,MAAMrK,KAAKqK,MAAMjM,OAAS,GACvCmnB,IAAM5E,CACb,CAOA,SAASgqF,IACP,MAAMhqF,EAAO3gB,KAAKsrG,SACLtrG,KAAKqK,MAAMrK,KAAKqK,MAAMjM,OAAS,GACvC44E,MAAQr2D,CACf,CAOA,SAASiqF,IACP5qG,KAAK2gB,KAAK6rF,iBAAcjqG,CAC1B,CAOA,SAAS4lG,IACPnoG,KAAK2gB,KAAK8rF,cAAgB,WAC5B,CAOA,SAAShC,EAAsBxY,GAC7B,MAAMl/B,EAAQ/yD,KAAKsrG,SACbzrG,EAAOG,KAAKqK,MAAMrK,KAAKqK,MAAMjM,OAAS,GAG5CyB,EAAKkzD,MAAQA,EAEblzD,EAAK26F,WAAaD,GAAoBv6F,KAAKk3F,eAAejF,IAAQlqF,cAClE/H,KAAK2gB,KAAK8rF,cAAgB,MAC5B,CAOA,SAASxD,EAA+BhX,GACtCjyF,KAAK2gB,KAAKksF,uBAAyB5a,EAAM1wF,IAC3C,CAMA,SAAS6nG,EAA8BnX,GACrC,MAAMtxE,EAAO3gB,KAAKk3F,eAAejF,GAC3B1wF,EAAOvB,KAAK2gB,KAAKksF,uBAEvB,IAAItvG,EACJ,GAAIgE,EACFhE,EAAQyoG,GAAgCrlF,EAAe,oCAATpf,EAA6C,GAAK,IAChGvB,KAAK2gB,KAAKksF,4BAAyBtqG,MAC9B,CAELhF,EADeuhG,GAA8Bn+E,EAE/C,CACa3gB,KAAKqK,MAAMrK,KAAKqK,MAAMjM,OAAS,GACvCb,OAASA,CAChB,CAMA,SAAS8rG,EAAyBpX,GACnBjyF,KAAKqK,MAAMqoC,MACnBhzC,SAASO,IAAMqqF,GAAM2H,EAAMhyF,IAClC,CAMA,SAAS4oG,EAAuB5W,GAC9B8W,EAAWrsG,KAAKsD,KAAMiyF,GACTjyF,KAAKqK,MAAMrK,KAAKqK,MAAMjM,OAAS,GACvCmnB,IAAMvlB,KAAKk3F,eAAejF,EACjC,CAMA,SAAS2W,EAAoB3W,GAC3B8W,EAAWrsG,KAAKsD,KAAMiyF,GACTjyF,KAAKqK,MAAMrK,KAAKqK,MAAMjM,OAAS,GACvCmnB,IAAM,UAAYvlB,KAAKk3F,eAAejF,EAC7C,CAOA,SAASmH,IACP,MAAO,CACL73F,KAAM,aACNsM,SAAU,GAEd,CAGA,SAASi5F,IACP,MAAO,CACLvlG,KAAM,OACNytE,KAAM,KACNh8D,KAAM,KACNzV,MAAO,GAEX,CAGA,SAAS+lG,IACP,MAAO,CACL/hG,KAAM,aACNhE,MAAO,GAEX,CAGA,SAASk4C,IACP,MAAO,CACLl0C,KAAM,aACNi5F,WAAY,GACZznC,MAAO,KACPikB,MAAO,KACPzxD,IAAK,GAET,CAGA,SAAS+hF,IACP,MAAO,CACL/lG,KAAM,WACNsM,SAAU,GAEd,CAGA,SAAS6tF,IACP,MAAO,CACLn6F,KAAM,UAEN6qG,MAAO,EACPv+F,SAAU,GAEd,CAGA,SAAS05F,IACP,MAAO,CACLhmG,KAAM,QAEV,CAGA,SAAS6pE,IACP,MAAO,CACL7pE,KAAM,OACNhE,MAAO,GAEX,CAGA,SAASoqG,KACP,MAAO,CACLpmG,KAAM,QACNy1E,MAAO,KACPzxD,IAAK,GACL0mD,IAAK,KAET,CAGA,SAASl5D,KACP,MAAO,CACLxR,KAAM,OACNy1E,MAAO,KACPzxD,IAAK,GACL1X,SAAU,GAEd,CAMA,SAASqhE,GAAK+iB,GACZ,MAAO,CACL1wF,KAAM,OACNurG,QAAwB,gBAAf7a,EAAM1wF,KACf5B,MAAO,KACPotG,OAAQ9a,EAAM8Z,QACdl+F,SAAU,GAEd,CAMA,SAAS+5F,GAAS3V,GAChB,MAAO,CACL1wF,KAAM,WACNwrG,OAAQ9a,EAAM8Z,QACd1/F,QAAS,KACTwB,SAAU,GAEd,CAGA,SAAS8tF,KACP,MAAO,CACLp6F,KAAM,YACNsM,SAAU,GAEd,CAGA,SAAS26F,KACP,MAAO,CACLjnG,KAAM,SACNsM,SAAU,GAEd,CAGA,SAASwX,KACP,MAAO,CACL9jB,KAAM,OACNhE,MAAO,GAEX,CAGA,SAAS86F,KACP,MAAO,CACL92F,KAAM,gBAEV,CACF,CA7+BSyrG,CAAS7vG,EAAT6vG,CClEF,SAAqBtb,GAC1B,MAAQR,GAAYQ,KAGpB,OAAOA,CACT,CD6D2Bub,CAAYrH,GAAMzoG,GAAS2J,WAAWgsF,MHvD1D,WACL,IAKIoa,EALA7tG,EAAS,EACT28F,EAAS,GAETr8F,GAAQ,EAGZ,OAIA,SAAsBpC,EAAOgpG,EAAUtmG,GAErC,MAAM63F,EAAS,GAEf,IAAIt4F,EAEA40B,EAEA89D,EAEAib,EAEAhrF,EAWJ,IAVA5kB,EAAQy+F,GAA2B,kBAAVz+F,EAAqBA,EAAMpB,WAAa,IAAIixG,YAAY7G,QAAYhkG,GAAW4jG,OAAO5oG,IAC/G20F,EAAgB,EAChB8J,EAAS,GACLr8F,IAE0B,QAAxBpC,EAAM26F,WAAW,IACnBhG,IAEFvyF,OAAQ4C,GAEH2vF,EAAgB30F,EAAMa,QAAQ,CAKnC,GAJA+mB,GAAOkoF,UAAYnb,EACnB1yF,EAAQ2lB,GAAOpkB,KAAKxD,GACpB4vG,EAAc3tG,QAAyB+C,IAAhB/C,EAAMk0B,MAAsBl0B,EAAMk0B,MAAQn2B,EAAMa,OACvE+jB,EAAO5kB,EAAM26F,WAAWiV,IACnB3tG,EAAO,CACVw8F,EAASz+F,EAAMyD,MAAMkxF,GACrB,KACF,CACA,GAAa,KAAT/vE,GAAe+vE,IAAkBib,GAAeD,EAClDpV,EAAOl3F,MAAM,GACbssG,OAAmB3qG,OAUnB,OARI2qG,IACFpV,EAAOl3F,MAAM,GACbssG,OAAmB3qG,GAEjB2vF,EAAgBib,IAClBrV,EAAOl3F,KAAKrD,EAAMyD,MAAMkxF,EAAeib,IACvC9tG,GAAU8tG,EAAcjb,GAElB/vE,GACN,KAAK,EAED21E,EAAOl3F,KAAK,OACZvB,IACA,MAEJ,KAAK,EAID,IAFA+0B,EAA+B,EAAxBvc,KAAK8vB,KAAKtoC,EAAS,GAC1By4F,EAAOl3F,MAAM,GACNvB,IAAW+0B,GAAM0jE,EAAOl3F,MAAM,GACrC,MAEJ,KAAK,GAEDk3F,EAAOl3F,MAAM,GACbvB,EAAS,EACT,MAEJ,QAEI6tG,GAAmB,EACnB7tG,EAAS,EAIjB6yF,EAAgBib,EAAc,CAChC,CAMA,OALIltG,IACEitG,GAAkBpV,EAAOl3F,MAAM,GAC/Bo7F,GAAQlE,EAAOl3F,KAAKo7F,GACxBlE,EAAOl3F,KAAK,OAEPk3F,CACT,CACF,CGpCuEwV,GAAa/vG,EAAOgpG,GAAU,KACrG,CAs/BA,SAASjc,GAAMloF,GACb,MAAO,CACLxC,KAAMwC,EAAExC,KACRP,OAAQ+C,EAAE/C,OACVgoB,OAAQjlB,EAAEilB,OAEd,CAOA,SAAS6jF,GAAUqC,EAAU1H,GAC3B,IAAInyE,GAAS,EACb,OAASA,EAAQmyE,EAAWznG,QAAQ,CAClC,MAAMb,EAAQsoG,EAAWnyE,GACrBj3B,MAAMF,QAAQgB,GAChB2tG,GAAUqC,EAAUhwG,GAEpBy1F,GAAUua,EAAUhwG,EAExB,CACF,CAOA,SAASy1F,GAAUua,EAAUva,GAE3B,IAAIn2F,EACJ,IAAKA,KAAOm2F,EACV,GAAIlsB,GAAIpqE,KAAKs2F,EAAWn2F,GACtB,OAAQA,GACN,IAAK,iBACH,CACE,MAAMwzF,EAAQ2C,EAAUn2F,GACpBwzF,GACFkd,EAAS1wG,GAAK+D,QAAQyvF,GAExB,KACF,CACF,IAAK,aACH,CACE,MAAMA,EAAQ2C,EAAUn2F,GACpBwzF,GACFkd,EAAS1wG,GAAK+D,QAAQyvF,GAExB,KACF,CACF,IAAK,QACL,IAAK,OACH,CACE,MAAMA,EAAQ2C,EAAUn2F,GACpBwzF,GACFt0F,OAAOoO,OAAOojG,EAAS1wG,GAAMwzF,GAE/B,KACF,EAKV,CAGA,SAASob,GAAetiF,EAAMknE,GAC5B,MAAIlnE,EACI,IAAI3oB,MAAM,iBAAmB2oB,EAAK5nB,KAAO,MAAQipF,GAAkB,CACvE7qF,MAAOwpB,EAAKxpB,MACZM,IAAKkpB,EAAKlpB,MACP,0BAA4BowF,EAAM9uF,KAAO,MAAQipF,GAAkB,CACtE7qF,MAAO0wF,EAAM1wF,MACbM,IAAKowF,EAAMpwF,MACR,aAEC,IAAIO,MAAM,oCAAsC6vF,EAAM9uF,KAAO,MAAQipF,GAAkB,CAC3F7qF,MAAO0wF,EAAM1wF,MACbM,IAAKowF,EAAMpwF,MACR,kBAET,CEnoCe,SAASutG,GAAYrwG,GAGlC,MAAMi7C,EAAOp4C,KAEbo4C,EAAKi6C,OAKL,SAAgB/nC,GACd,OAAOg8C,GAAah8C,EAAK,IACpBlS,EAAKz3B,KAAK,eACVxjB,EAIH0oG,WAAYztD,EAAKz3B,KAAK,wBAA0B,GAChDwqF,gBAAiB/yD,EAAKz3B,KAAK,2BAA6B,IAE5D,CACF,CC1CO,MCOD8sF,GAAsB,kBAATr1D,KAAoBA,KAAOpC,WAuEjC03D,GAAcC,GArENC,EAACC,EAAG1uD,KACvB,MAAM+K,EAAKA,CAAC4jD,EAAKp6E,KACfm6E,EAAEpjG,IAAIipB,EAAOo6E,GACNA,GAGHC,EAASr6E,IACb,GAAIm6E,EAAEpiF,IAAIiI,GACR,OAAOm6E,EAAE9hG,IAAI2nB,GAEf,MAAOnyB,EAAMhE,GAAS4hD,EAAEzrB,GACxB,OAAQnyB,GACN,KDpBoB,ECqBpB,KDtBoB,ECuBlB,OAAO2oD,EAAG3sD,EAAOm2B,GACnB,KDtBoB,ECsBR,CACV,MAAMl3B,EAAM0tD,EAAG,GAAIx2B,GACnB,IAAK,MAAMA,KAASn2B,EAClBf,EAAIoE,KAAKmtG,EAAOr6E,IAClB,OAAOl3B,CACT,CACA,KD3BoB,EC2BP,CACX,MAAM2I,EAAS+kD,EAAG,CAAC,EAAGx2B,GACtB,IAAK,MAAO72B,EAAK62B,KAAUn2B,EACzB4H,EAAO4oG,EAAOlxG,IAAQkxG,EAAOr6E,GAC/B,OAAOvuB,CACT,CACA,KDhCoB,ECiClB,OAAO+kD,EAAG,IAAI/rC,KAAK5gB,GAAQm2B,GAC7B,KDjCoB,ECiCP,CACX,MAAM,OAACxzB,EAAM,MAAEuV,GAASlY,EACxB,OAAO2sD,EAAG,IAAI7K,OAAOn/C,EAAQuV,GAAQie,EACvC,CACA,KDpCoB,ECoCV,CACR,MAAMsd,EAAMkZ,EAAG,IAAIlwC,IAAK0Z,GACxB,IAAK,MAAO72B,EAAK62B,KAAUn2B,EACzByzC,EAAIvmC,IAAIsjG,EAAOlxG,GAAMkxG,EAAOr6E,IAC9B,OAAOsd,CACT,CACA,KDzCoB,ECyCV,CACR,MAAMvmC,EAAMy/C,EAAG,IAAI3jD,IAAKmtB,GACxB,IAAK,MAAMA,KAASn2B,EAClBkN,EAAI9D,IAAIonG,EAAOr6E,IACjB,OAAOjpB,CACT,CACA,KD9CoB,EC8CR,CACV,MAAM,KAACrN,EAAI,QAAEoiC,GAAWjiC,EACxB,OAAO2sD,EAAG,IAAIujD,GAAIrwG,GAAMoiC,GAAU9L,EACpC,CACA,KDjDoB,ECkDlB,OAAOw2B,EAAG8jD,OAAOzwG,GAAQm2B,GAC3B,IAAK,SACH,OAAOw2B,EAAGnuD,OAAOiyG,OAAOzwG,IAASm2B,GAErC,OAAOw2B,EAAG,IAAIujD,GAAIlsG,GAAMhE,GAAQm2B,EAAM,EAGxC,OAAOq6E,CAAM,EAY0BH,CAAa,IAAI5zF,IAAK2zF,EAAtBC,CAAkC,GCvErEK,GAAQ,IAEP9xG,SAAQA,IAAI,CAAC,GACd,KAAC+V,IAAQnW,OAETijF,GAASzhF,IACb,MAAMgE,SAAchE,EACpB,GAAa,WAATgE,IAAsBhE,EACxB,MAAO,CFde,EEcHgE,GAErB,MAAM2sG,EAAW/xG,GAASO,KAAKa,GAAOyD,MAAM,GAAI,GAChD,OAAQktG,GACN,IAAK,QACH,MAAO,CFlBa,EEkBLD,IACjB,IAAK,SACH,MAAO,CFnBa,EEmBJA,IAClB,IAAK,OACH,MAAO,CFpBa,EEoBNA,IAChB,IAAK,SACH,MAAO,CFrBa,EEqBJA,IAClB,IAAK,MACH,MAAO,CFtBa,EEsBPA,IACf,IAAK,MACH,MAAO,CFvBa,EEuBPA,IAGjB,OAAIC,EAASljG,SAAS,SACb,CFhCe,EEgCPkjG,GAEbA,EAASljG,SAAS,SACb,CF7Be,EE6BPkjG,GAEV,CFpCiB,EEoCRA,EAAS,EAGrBC,GAAa70D,IAAA,IAAE80D,EAAM7sG,GAAK+3C,EAAA,OFzCN,IE0CxB80D,IACU,aAAT7sG,GAAgC,WAATA,EAAkB,EAiH9B8sG,GAAY,SAAC9wG,GAA8B,IAAvB,KAAC+wG,EAAI,MAAEC,GAAMrwG,UAAAE,OAAA,QAAAmE,IAAArE,UAAA,GAAAA,UAAA,GAAG,CAAC,EACjD,MAAMihD,EAAI,GACV,MAhHiBqvD,EAACC,EAAQH,EAAMT,EAAG1uD,KAEnC,MAAM+K,EAAKA,CAAC4jD,EAAKvwG,KACf,MAAMm2B,EAAQyrB,EAAEv+C,KAAKktG,GAAO,EAE5B,OADAD,EAAEpjG,IAAIlN,EAAOm2B,GACNA,CAAK,EAGRg7E,EAAOnxG,IACX,GAAIswG,EAAEpiF,IAAIluB,GACR,OAAOswG,EAAE9hG,IAAIxO,GAEf,IAAK6wG,EAAM7sG,GAAQy9E,GAAOzhF,GAC1B,OAAQ6wG,GACN,KF5DoB,EE4DJ,CACd,IAAI9X,EAAQ/4F,EACZ,OAAQgE,GACN,IAAK,SACH6sG,EFxDc,EEyDd9X,EAAQ/4F,EAAMpB,WACd,MACF,IAAK,WACL,IAAK,SACH,GAAIsyG,EACF,MAAM,IAAItvG,UAAU,uBAAyBoC,GAC/C+0F,EAAQ,KACR,MACF,IAAK,YACH,OAAOpsC,EAAG,EF3EI,GE2EI3sD,GAEtB,OAAO2sD,EAAG,CAACkkD,EAAM9X,GAAQ/4F,EAC3B,CACA,KF7EoB,EE6ER,CACV,GAAIgE,EACF,OAAO2oD,EAAG,CAAC3oD,EAAM,IAAIhE,IAASA,GAEhC,MAAMf,EAAM,GACNk3B,EAAQw2B,EAAG,CAACkkD,EAAM5xG,GAAMe,GAC9B,IAAK,MAAM+4F,KAAS/4F,EAClBf,EAAIoE,KAAK8tG,EAAKpY,IAChB,OAAO5iE,CACT,CACA,KFtFoB,EEsFP,CACX,GAAInyB,EACF,OAAQA,GACN,IAAK,SACH,OAAO2oD,EAAG,CAAC3oD,EAAMhE,EAAMpB,YAAaoB,GACtC,IAAK,UACL,IAAK,SACL,IAAK,SACH,OAAO2sD,EAAG,CAAC3oD,EAAMhE,EAAMiR,WAAYjR,GAIzC,GAAI+wG,GAAS,WAAY/wG,EACvB,OAAOmxG,EAAKnxG,EAAMoxG,UAEpB,MAAM/5C,EAAU,GACVlhC,EAAQw2B,EAAG,CAACkkD,EAAMx5C,GAAUr3D,GAClC,IAAK,MAAMV,KAAOqV,GAAK3U,IACjBkxG,GAAWN,GAAWnvB,GAAOzhF,EAAMV,MACrC+3D,EAAQh0D,KAAK,CAAC8tG,EAAK7xG,GAAM6xG,EAAKnxG,EAAMV,MAExC,OAAO62B,CACT,CACA,KF5GoB,EE6GlB,OAAOw2B,EAAG,CAACkkD,EAAM7wG,EAAMqxG,eAAgBrxG,GACzC,KF7GoB,EE6GP,CACX,MAAM,OAAC2C,EAAM,MAAEuV,GAASlY,EACxB,OAAO2sD,EAAG,CAACkkD,EAAM,CAACluG,SAAQuV,UAASlY,EACrC,CACA,KFhHoB,EEgHV,CACR,MAAMq3D,EAAU,GACVlhC,EAAQw2B,EAAG,CAACkkD,EAAMx5C,GAAUr3D,GAClC,IAAK,MAAOV,EAAKy5F,KAAU/4F,GACrBkxG,IAAYN,GAAWnvB,GAAOniF,MAASsxG,GAAWnvB,GAAOsX,MAC3D1hC,EAAQh0D,KAAK,CAAC8tG,EAAK7xG,GAAM6xG,EAAKpY,KAElC,OAAO5iE,CACT,CACA,KFxHoB,EEwHV,CACR,MAAMkhC,EAAU,GACVlhC,EAAQw2B,EAAG,CAACkkD,EAAMx5C,GAAUr3D,GAClC,IAAK,MAAM+4F,KAAS/4F,GACdkxG,GAAWN,GAAWnvB,GAAOsX,KAC/B1hC,EAAQh0D,KAAK8tG,EAAKpY,IAEtB,OAAO5iE,CACT,EAGF,MAAM,QAAC8L,GAAWjiC,EAClB,OAAO2sD,EAAG,CAACkkD,EAAM,CAAChxG,KAAMmE,EAAMi+B,YAAWjiC,EAAM,EAGjD,OAAOmxG,CAAI,EAiBJF,GAAaF,GAAQC,KAAUD,EAAM,IAAIt0F,IAAKmlC,EAA9CqvD,CAAiDjxG,GAAQ4hD,CAClE,ECjJA,GAA0C,oBAApB0vD,gBAEpB,CAACvpG,EAAKnI,IACJA,IAAY,SAAUA,GAAW,UAAWA,GAC1CuwG,GAAYW,GAAU/oG,EAAKnI,IAAY0xG,gBAAgBvpG,GAE3D,CAACA,EAAKnI,IAAYuwG,GAAYW,GAAU/oG,EAAKnI,ICmCxC,SAAS2xG,GAAavxG,GAE3B,MAAM6F,EAAS,GACf,IAAIswB,GAAS,EACT/zB,EAAQ,EACRovG,EAAO,EACX,OAASr7E,EAAQn2B,EAAMa,QAAQ,CAC7B,MAAM+jB,EAAO5kB,EAAM26F,WAAWxkE,GAE9B,IAAIz0B,EAAU,GAGd,GAAa,KAATkjB,GAAeoxE,GAAkBh2F,EAAM26F,WAAWxkE,EAAQ,KAAO6/D,GAAkBh2F,EAAM26F,WAAWxkE,EAAQ,IAC9Gq7E,EAAO,OAGJ,GAAI5sF,EAAO,IACT,oBAAoB5Z,KAAK0Z,OAAOC,aAAaC,MAChDljB,EAAUgjB,OAAOC,aAAaC,SAI7B,GAAIA,EAAO,OAAUA,EAAO,MAAQ,CACvC,MAAMiS,EAAO72B,EAAM26F,WAAWxkE,EAAQ,GAGlCvR,EAAO,OAAUiS,EAAO,OAAUA,EAAO,OAC3Cn1B,EAAUgjB,OAAOC,aAAaC,EAAMiS,GACpC26E,EAAO,GAIP9vG,EAAU,QAEd,MAGEA,EAAUgjB,OAAOC,aAAaC,GAE5BljB,IACFmE,EAAOxC,KAAKrD,EAAMyD,MAAMrB,EAAO+zB,GAAQrtB,mBAAmBpH,IAC1DU,EAAQ+zB,EAAQq7E,EAAO,EACvB9vG,EAAU,IAER8vG,IACFr7E,GAASq7E,EACTA,EAAO,EAEX,CACA,OAAO3rG,EAAOmwB,KAAK,IAAMh2B,EAAMyD,MAAMrB,EACvC,CC1BO,SAASqvG,GAA2B7vD,EAAG8vD,GAE5C,MAAM7rG,EAAS,CAAC,CAAC7B,KAAM,OAAQhE,MAAO,WAWtC,OATI0xG,EAAmB,GACrB7rG,EAAOxC,KAAK,CACVW,KAAM,UACNm2B,QAAS,MACTqvC,WAAY,CAAC,EACbl5D,SAAU,CAAC,CAACtM,KAAM,OAAQhE,MAAO0kB,OAAOgtF,OAIrC7rG,CACT,CAaO,SAAS8rG,GAAyBC,EAAgBF,GACvD,MACE,sBACCE,EAAiB,IACjBF,EAAmB,EAAI,IAAMA,EAAmB,GAErD,CChDO,MA0EMG,GAgBT,SAAU7mG,GACR,GAAa,OAATA,QAA0BhG,IAATgG,EACnB,OAAOu/B,GAGT,GAAoB,oBAATv/B,EACT,OAAO8mG,GAAY9mG,GAGrB,GAAoB,kBAATA,EACT,OAAO9L,MAAMF,QAAQgM,GAe7B,SAAoB+mG,GAElB,MAAM/oC,EAAS,GACf,IAAI7yC,GAAS,EAEb,OAASA,EAAQ47E,EAAMlxG,QACrBmoE,EAAO7yC,GAAS07E,GAAQE,EAAM57E,IAGhC,OAAO27E,GAAY/pG,GAMnB,SAASA,IACP,IAAIouB,GAAS,EAAC,QAAA/wB,EAAAzE,UAAAE,OADA8xF,EAAU,IAAAzzF,MAAAkG,GAAAE,EAAA,EAAAA,EAAAF,EAAAE,IAAVqtF,EAAUrtF,GAAA3E,UAAA2E,GAGxB,OAAS6wB,EAAQ6yC,EAAOnoE,QACtB,GAAImoE,EAAO7yC,GAAOrwB,MAAMrD,KAAMkwF,GAAa,OAAO,EAGpD,OAAO,CACT,CACF,CAvCqCqf,CAAWhnG,GA+ChD,SAAsBq+D,GACpB,MAAM4oC,EAAwD5oC,EAE9D,OAAOyoC,GAAYz5D,GAMnB,SAASA,EAAI/1C,GACX,MAAM4vG,EACoB5vG,EAI1B,IAAIhD,EAEJ,IAAKA,KAAO+pE,EACV,GAAI6oC,EAAa5yG,KAAS2yG,EAAc3yG,GAAM,OAAO,EAGvD,OAAO,CACT,CACF,CAtEwD6yG,CAAannG,GAG/D,GAAoB,kBAATA,EACT,OA0ER,SAAqBq+D,GACnB,OAAOyoC,GAAY9tG,GAKnB,SAASA,EAAK1B,GACZ,OAAOA,GAAQA,EAAK0B,OAASqlE,CAC/B,CACF,CAnFe+oC,CAAYpnG,GAGrB,MAAM,IAAI/H,MAAM,+CAClB,EAuFJ,SAAS6uG,GAAYO,GACnB,OAMA,SAAeryG,EAAOm2B,EAAOu3D,GAC3B,OAAOyE,QACLmgB,GAAetyG,IACbqyG,EAAalzG,KACXsD,KACAzC,EACiB,kBAAVm2B,EAAqBA,OAAQnxB,EACpC0oF,QAAU1oF,GAGlB,CACF,CAEA,SAASulC,KACP,OAAO,CACT,CAMA,SAAS+nE,GAAetyG,GACtB,OAAiB,OAAVA,GAAmC,kBAAVA,GAAsB,SAAUA,CAClE,CCnEA,MAAM+nE,GAAQ,GAKDwqC,IAAW,EAKXC,IAAO,EAsDb,SAASC,GAAapkB,EAAMrjF,EAAM0nG,EAASvf,GAEhD,IAAI9pB,EAEgB,oBAATr+D,GAA0C,oBAAZ0nG,GACvCvf,EAAUuf,EAEVA,EAAU1nG,GAGVq+D,EAAQr+D,EAGV,MAAM+K,EAAK87F,GAAQxoC,GACbmQ,EAAO2Z,GAAW,EAAI,GAS5B,SAASwf,EAAQrwG,EAAM6zB,EAAOy8E,GAC5B,MAAM5yG,EACJsC,GAAwB,kBAATA,EAAoBA,EAAO,CAAC,EAG7C,GAA0B,kBAAftC,EAAMgE,KAAmB,CAClC,MAAMnE,EAEqB,kBAAlBG,EAAMm6B,QACTn6B,EAAMm6B,QAEc,kBAAfn6B,EAAMH,KACXG,EAAMH,UACNmF,EAENxG,OAAOK,eAAeg0G,EAAO,OAAQ,CACnC7yG,MACE,SAAiBsC,EAAK0B,MAAQnE,EAAO,IAAMA,EAAO,IAAM,IAAO,KAErE,CAEA,OAAOgzG,EAEP,SAASA,IAEP,IAEIC,EAEAhpF,EAEAipF,EANAltG,EAASkiE,GAQb,KAAK/8D,GAAQ+K,EAAGzT,EAAM6zB,EAAOy8E,EAAQA,EAAQ/xG,OAAS,SAAMmE,MAE1Da,EA0CR,SAAkB7F,GAChB,GAAId,MAAMF,QAAQgB,GAChB,OAAOA,EAGT,GAAqB,kBAAVA,EACT,MAAO,CAACuyG,GAAUvyG,GAGpB,OAAiB,OAAVA,QAA4BgF,IAAVhF,EAAsB+nE,GAAQ,CAAC/nE,EAC1D,CApDiBgzG,CAASN,EAAQpwG,EAAMswG,IAE5B/sG,EAAO,KAAO2sG,IAChB,OAAO3sG,EAIX,GAAI,aAAcvD,GAAQA,EAAKgO,SAAU,CACvC,MAAM2iG,EAA2C3wG,EAEjD,GAAI2wG,EAAa3iG,UArHL,SAqHiBzK,EAAO,GAIlC,IAHAikB,GAAUqpE,EAAU8f,EAAa3iG,SAASzP,QAAU,GAAK24E,EACzDu5B,EAAeH,EAAQhsG,OAAOqsG,GAEvBnpF,GAAU,GAAKA,EAASmpF,EAAa3iG,SAASzP,QAAQ,CAC3D,MAAM2X,EAAQy6F,EAAa3iG,SAASwZ,GAIpC,GAFAgpF,EAAYH,EAAQn6F,EAAOsR,EAAQipF,EAAvBJ,GAERG,EAAU,KAAON,GACnB,OAAOM,EAGThpF,EAC0B,kBAAjBgpF,EAAU,GAAkBA,EAAU,GAAKhpF,EAAS0vD,CAC/D,CAEJ,CAEA,OAAO3zE,CACT,CACF,CAzEA8sG,CAAQtkB,OAAMrpF,EAAW,GAAzB2tG,EA0EF,CCnGO,SAASE,GAAMxkB,EAAM6kB,EAAeC,EAAkBC,GAE3D,IAAIjgB,EAEAnoF,EAEA0nG,EAGuB,oBAAlBQ,GACqB,oBAArBC,GAEPnoG,OAAOhG,EACP0tG,EAAUQ,EACV/f,EAAUggB,IAGVnoG,EAAOkoG,EAEPR,EAAUS,EACVhgB,EAAUigB,GAGZX,GAAapkB,EAAMrjF,GAMnB,SAAkB1I,EAAMswG,GACtB,MAAMllB,EAASklB,EAAQA,EAAQ/xG,OAAS,GAClCs1B,EAAQu3D,EAASA,EAAOp9E,SAASoE,QAAQpS,QAAQ0C,EACvD,OAAO0tG,EAAQpwG,EAAM6zB,EAAOu3D,EAC9B,GAVmCyF,EAWrC,CClSO,SAASkgB,GAAOhyE,EAAO/+B,GAC5B,MAAMgxG,EAAUhxG,EAAK4sG,cACrB,IAAI3rC,EAAS,IAQb,GANgB,cAAZ+vC,EACF/vC,GAAU,KACW,SAAZ+vC,IACT/vC,GAAU,KAAOjhE,EAAKkzD,OAASlzD,EAAK26F,YAAc,KAGlC,mBAAd36F,EAAK0B,KACP,MAAO,CAAC,CAACA,KAAM,OAAQhE,MAAO,KAAOsC,EAAKosE,IAAMnL,IAGlD,MAAMgwC,EAAWlyE,EAAMgX,IAAI/1C,GACrBs3C,EAAO25D,EAAS,GAElB35D,GAAsB,SAAdA,EAAK51C,KACf41C,EAAK55C,MAAQ,IAAM45C,EAAK55C,MAExBuzG,EAAS1jF,QAAQ,CAAC7rB,KAAM,OAAQhE,MAAO,MAGzC,MAAMumC,EAAOgtE,EAASA,EAAS1yG,OAAS,GAQxC,OANI0lC,GAAsB,SAAdA,EAAKviC,KACfuiC,EAAKvmC,OAASujE,EAEdgwC,EAASlwG,KAAK,CAACW,KAAM,OAAQhE,MAAOujE,IAG/BgwC,CACT,CCgEA,SAASC,GAAclxG,GACrB,MAAMktG,EAASltG,EAAKktG,OAEpB,OAAkB,OAAXA,QAA8BxqG,IAAXwqG,EACtBltG,EAAKgO,SAASzP,OAAS,EACvB2uG,CACN,CChHO,SAASiE,GAAUzzG,GACxB,MAAM2C,EAAS+hB,OAAO1kB,GAChB4nB,EAAS,YACf,IAAI3lB,EAAQ2lB,EAAOpkB,KAAKb,GACpB2jC,EAAO,EAEX,MAAMtkC,EAAQ,GAEd,KAAOC,GACLD,EAAMqB,KACJqwG,GAAS/wG,EAAOc,MAAM6iC,EAAMrkC,EAAMk0B,OAAQmQ,EAAO,GAAG,GACpDrkC,EAAM,IAGRqkC,EAAOrkC,EAAMk0B,MAAQl0B,EAAM,GAAGpB,OAC9BoB,EAAQ2lB,EAAOpkB,KAAKb,GAKtB,OAFAX,EAAMqB,KAAKqwG,GAAS/wG,EAAOc,MAAM6iC,GAAOA,EAAO,GAAG,IAE3CtkC,EAAMg0B,KAAK,GACpB,CAYA,SAAS09E,GAAS1zG,EAAOoC,EAAOM,GAC9B,IAAIy/C,EAAa,EACbilD,EAAWpnG,EAAMa,OAErB,GAAIuB,EAAO,CACT,IAAIwiB,EAAO5kB,EAAM+uG,YAAY5sD,GAE7B,KApDQ,IAoDDv9B,GAnDG,KAmDaA,GACrBu9B,IACAv9B,EAAO5kB,EAAM+uG,YAAY5sD,EAE7B,CAEA,GAAIz/C,EAAK,CACP,IAAIkiB,EAAO5kB,EAAM+uG,YAAY3H,EAAW,GAExC,KA7DQ,IA6DDxiF,GA5DG,KA4DaA,GACrBwiF,IACAxiF,EAAO5kB,EAAM+uG,YAAY3H,EAAW,EAExC,CAEA,OAAOA,EAAWjlD,EAAaniD,EAAMyD,MAAM0+C,EAAYilD,GAAY,EACrE,CCvCO,MAAMuM,GAAW,CACtBC,WCXK,SAAoBvyE,EAAO/+B,GAEhC,MAAMuD,EAAS,CACb7B,KAAM,UACNm2B,QAAS,aACTqvC,WAAY,CAAC,EACbl5D,SAAU+wB,EAAMw4C,KAAKx4C,EAAMgX,IAAI/1C,IAAO,IAGxC,OADA++B,EAAM64B,MAAM53D,EAAMuD,GACXw7B,EAAMwyE,UAAUvxG,EAAMuD,EAC/B,EDEEiuG,MEXK,SAAmBzyE,EAAO/+B,GAE/B,MAAMuD,EAAS,CAAC7B,KAAM,UAAWm2B,QAAS,KAAMqvC,WAAY,CAAC,EAAGl5D,SAAU,IAE1E,OADA+wB,EAAM64B,MAAM53D,EAAMuD,GACX,CAACw7B,EAAMwyE,UAAUvxG,EAAMuD,GAAS,CAAC7B,KAAM,OAAQhE,MAAO,MAC/D,EFOE4kB,KGZK,SAAcyc,EAAO/+B,GAC1B,MAAMtC,EAAQsC,EAAKtC,MAAQsC,EAAKtC,MAAQ,KAAO,GAEzCwpE,EAAa,CAAC,EAEhBlnE,EAAKmvE,OACPjI,EAAW9c,UAAY,CAAC,YAAcpqD,EAAKmvE,OAK7C,IAAI5rE,EAAS,CACX7B,KAAM,UACNm2B,QAAS,OACTqvC,aACAl5D,SAAU,CAAC,CAACtM,KAAM,OAAQhE,WAa5B,OAVIsC,EAAKmT,OACP5P,EAAOud,KAAO,CAAC3N,KAAMnT,EAAKmT,OAG5B4rB,EAAM64B,MAAM53D,EAAMuD,GAClBA,EAASw7B,EAAMwyE,UAAUvxG,EAAMuD,GAG/BA,EAAS,CAAC7B,KAAM,UAAWm2B,QAAS,MAAOqvC,WAAY,CAAC,EAAGl5D,SAAU,CAACzK,IACtEw7B,EAAM64B,MAAM53D,EAAMuD,GACXA,CACT,EHhBEiX,OIdK,SAAuBukB,EAAO/+B,GAEnC,MAAMuD,EAAS,CACb7B,KAAM,UACNm2B,QAAS,MACTqvC,WAAY,CAAC,EACbl5D,SAAU+wB,EAAMgX,IAAI/1C,IAGtB,OADA++B,EAAM64B,MAAM53D,EAAMuD,GACXw7B,EAAMwyE,UAAUvxG,EAAMuD,EAC/B,EJKEkkG,SKfK,SAAkB1oE,EAAO/+B,GAE9B,MAAMuD,EAAS,CACb7B,KAAM,UACNm2B,QAAS,KACTqvC,WAAY,CAAC,EACbl5D,SAAU+wB,EAAMgX,IAAI/1C,IAGtB,OADA++B,EAAM64B,MAAM53D,EAAMuD,GACXw7B,EAAMwyE,UAAUvxG,EAAMuD,EAC/B,ELMEkuG,kBMjBK,SAA2B1yE,EAAO/+B,GACvC,MAAM0xG,EACmC,kBAAhC3yE,EAAMzhC,QAAQo0G,cACjB3yE,EAAMzhC,QAAQo0G,cACd,gBACAr1F,EAAK+F,OAAOpiB,EAAK26F,YAAYtyF,cAC7BspG,EAAS1C,GAAa5yF,EAAGnU,eACzB2rB,EAAQkL,EAAM6yE,cAAcx/F,QAAQiK,GAE1C,IAAIw1F,EAEAC,EAAe/yE,EAAMgzE,eAAe7lG,IAAImQ,QAEvB3Z,IAAjBovG,GACFA,EAAe,EACf/yE,EAAM6yE,cAAc7wG,KAAKsb,GACzBw1F,EAAU9yE,EAAM6yE,cAAcrzG,QAE9BszG,EAAUh+E,EAAQ,EAGpBi+E,GAAgB,EAChB/yE,EAAMgzE,eAAennG,IAAIyR,EAAIy1F,GAG7B,MAAM5+F,EAAO,CACXxR,KAAM,UACNm2B,QAAS,IACTqvC,WAAY,CACVl/C,KAAM,IAAM0pF,EAAgB,MAAQC,EACpCt1F,GACEq1F,EACA,SACAC,GACCG,EAAe,EAAI,IAAMA,EAAe,IAC3CE,iBAAiB,EACjB9oC,gBAAiB,CAAC,mBAEpBl7D,SAAU,CAAC,CAACtM,KAAM,OAAQhE,MAAO0kB,OAAOyvF,MAE1C9yE,EAAM64B,MAAM53D,EAAMkT,GAGlB,MAAM++F,EAAM,CACVvwG,KAAM,UACNm2B,QAAS,MACTqvC,WAAY,CAAC,EACbl5D,SAAU,CAACkF,IAGb,OADA6rB,EAAM64B,MAAM53D,EAAMiyG,GACXlzE,EAAMwyE,UAAUvxG,EAAMiyG,EAC/B,ENjCEpW,QOjBK,SAAiB98D,EAAO/+B,GAE7B,MAAMuD,EAAS,CACb7B,KAAM,UACNm2B,QAAS,IAAM73B,EAAKusG,MACpBrlC,WAAY,CAAC,EACbl5D,SAAU+wB,EAAMgX,IAAI/1C,IAGtB,OADA++B,EAAM64B,MAAM53D,EAAMuD,GACXw7B,EAAMwyE,UAAUvxG,EAAMuD,EAC/B,EPQEgoE,KQhBK,SAAcxsC,EAAO/+B,GAC1B,GAAI++B,EAAMzhC,QAAQ40G,mBAAoB,CAEpC,MAAM3uG,EAAS,CAAC7B,KAAM,MAAOhE,MAAOsC,EAAKtC,OAEzC,OADAqhC,EAAM64B,MAAM53D,EAAMuD,GACXw7B,EAAMwyE,UAAUvxG,EAAMuD,EAC/B,CAGF,ERQE4uG,eSjBK,SAAwBpzE,EAAO/+B,GACpC,MAAMqc,EAAK+F,OAAOpiB,EAAK26F,YAAYtyF,cAC7ButC,EAAa7W,EAAMqzE,eAAelmG,IAAImQ,GAE5C,IAAKu5B,EACH,OAAOm7D,GAAOhyE,EAAO/+B,GAIvB,MAAMknE,EAAa,CAACjpE,IAAKgxG,GAAar5D,EAAWlwB,KAAO,IAAK0mD,IAAKpsE,EAAKosE,KAE9C,OAArBx2B,EAAWuhC,YAAuCz0E,IAArBkzC,EAAWuhC,QAC1CjQ,EAAWiQ,MAAQvhC,EAAWuhC,OAIhC,MAAM5zE,EAAS,CAAC7B,KAAM,UAAWm2B,QAAS,MAAOqvC,aAAYl5D,SAAU,IAEvE,OADA+wB,EAAM64B,MAAM53D,EAAMuD,GACXw7B,EAAMwyE,UAAUvxG,EAAMuD,EAC/B,ETDEukG,MUpBK,SAAe/oE,EAAO/+B,GAE3B,MAAMknE,EAAa,CAACjpE,IAAKgxG,GAAajvG,EAAK0lB,MAE1B,OAAb1lB,EAAKosE,UAA6B1pE,IAAb1C,EAAKosE,MAC5BlF,EAAWkF,IAAMpsE,EAAKosE,KAGL,OAAfpsE,EAAKm3E,YAAiCz0E,IAAf1C,EAAKm3E,QAC9BjQ,EAAWiQ,MAAQn3E,EAAKm3E,OAI1B,MAAM5zE,EAAS,CAAC7B,KAAM,UAAWm2B,QAAS,MAAOqvC,aAAYl5D,SAAU,IAEvE,OADA+wB,EAAM64B,MAAM53D,EAAMuD,GACXw7B,EAAMwyE,UAAUvxG,EAAMuD,EAC/B,EVKE8uG,WWpBK,SAAoBtzE,EAAO/+B,GAEhC,MAAMwlB,EAAO,CAAC9jB,KAAM,OAAQhE,MAAOsC,EAAKtC,MAAM0B,QAAQ,YAAa,MACnE2/B,EAAM64B,MAAM53D,EAAMwlB,GAGlB,MAAMjiB,EAAS,CACb7B,KAAM,UACNm2B,QAAS,OACTqvC,WAAY,CAAC,EACbl5D,SAAU,CAACwX,IAGb,OADAuZ,EAAM64B,MAAM53D,EAAMuD,GACXw7B,EAAMwyE,UAAUvxG,EAAMuD,EAC/B,EXOE+uG,cYpBK,SAAuBvzE,EAAO/+B,GACnC,MAAMqc,EAAK+F,OAAOpiB,EAAK26F,YAAYtyF,cAC7ButC,EAAa7W,EAAMqzE,eAAelmG,IAAImQ,GAE5C,IAAKu5B,EACH,OAAOm7D,GAAOhyE,EAAO/+B,GAIvB,MAAMknE,EAAa,CAACl/C,KAAMinF,GAAar5D,EAAWlwB,KAAO,KAEhC,OAArBkwB,EAAWuhC,YAAuCz0E,IAArBkzC,EAAWuhC,QAC1CjQ,EAAWiQ,MAAQvhC,EAAWuhC,OAIhC,MAAM5zE,EAAS,CACb7B,KAAM,UACNm2B,QAAS,IACTqvC,aACAl5D,SAAU+wB,EAAMgX,IAAI/1C,IAGtB,OADA++B,EAAM64B,MAAM53D,EAAMuD,GACXw7B,EAAMwyE,UAAUvxG,EAAMuD,EAC/B,EZHE2P,KavBK,SAAc6rB,EAAO/+B,GAE1B,MAAMknE,EAAa,CAACl/C,KAAMinF,GAAajvG,EAAK0lB,MAEzB,OAAf1lB,EAAKm3E,YAAiCz0E,IAAf1C,EAAKm3E,QAC9BjQ,EAAWiQ,MAAQn3E,EAAKm3E,OAI1B,MAAM5zE,EAAS,CACb7B,KAAM,UACNm2B,QAAS,IACTqvC,aACAl5D,SAAU+wB,EAAMgX,IAAI/1C,IAGtB,OADA++B,EAAM64B,MAAM53D,EAAMuD,GACXw7B,EAAMwyE,UAAUvxG,EAAMuD,EAC/B,EbOEwkG,SFnBK,SAAkBhpE,EAAO/+B,EAAMorF,GACpC,MAAM3Q,EAAU17C,EAAMgX,IAAI/1C,GACpBuyG,EAAQnnB,EAyEhB,SAAmBprF,GACjB,IAAIuyG,GAAQ,EACZ,GAAkB,SAAdvyG,EAAK0B,KAAiB,CACxB6wG,EAAQvyG,EAAKktG,SAAU,EACvB,MAAMl/F,EAAWhO,EAAKgO,SACtB,IAAI6lB,GAAS,EAEb,MAAQ0+E,KAAW1+E,EAAQ7lB,EAASzP,QAClCg0G,EAAQrB,GAAcljG,EAAS6lB,GAEnC,CAEA,OAAO0+E,CACT,CAtFyBC,CAAUpnB,GAAU8lB,GAAclxG,GAEnDknE,EAAa,CAAC,EAEdl5D,EAAW,GAEjB,GAA4B,mBAAjBhO,EAAKwM,QAAuB,CACrC,MAAM8qC,EAAOmjC,EAAQ,GAErB,IAAIqhB,EAEAxkD,GAAsB,YAAdA,EAAK51C,MAAuC,MAAjB41C,EAAKzf,QAC1CikE,EAAYxkD,GAEZwkD,EAAY,CAACp6F,KAAM,UAAWm2B,QAAS,IAAKqvC,WAAY,CAAC,EAAGl5D,SAAU,IACtEysE,EAAQltD,QAAQuuE,IAGdA,EAAU9tF,SAASzP,OAAS,GAC9Bu9F,EAAU9tF,SAASuf,QAAQ,CAAC7rB,KAAM,OAAQhE,MAAO,MAGnDo+F,EAAU9tF,SAASuf,QAAQ,CACzB7rB,KAAM,UACNm2B,QAAS,QACTqvC,WAAY,CAACxlE,KAAM,WAAY8K,QAASxM,EAAKwM,QAASqB,UAAU,GAChEG,SAAU,KAKZk5D,EAAW9c,UAAY,CAAC,iBAC1B,CAEA,IAAIv2B,GAAS,EAEb,OAASA,EAAQ4mD,EAAQl8E,QAAQ,CAC/B,MAAM2X,EAAQukE,EAAQ5mD,IAIpB0+E,GACU,IAAV1+E,GACe,YAAf3d,EAAMxU,MACY,MAAlBwU,EAAM2hB,UAEN7pB,EAASjN,KAAK,CAACW,KAAM,OAAQhE,MAAO,OAGnB,YAAfwY,EAAMxU,MAAwC,MAAlBwU,EAAM2hB,SAAoB06E,EAGxDvkG,EAASjN,KAAKmV,GAFdlI,EAASjN,QAAQmV,EAAMlI,SAI3B,CAEA,MAAMi2B,EAAOw2C,EAAQA,EAAQl8E,OAAS,GAGlC0lC,IAASsuE,GAAuB,YAAdtuE,EAAKviC,MAAuC,MAAjBuiC,EAAKpM,UACpD7pB,EAASjN,KAAK,CAACW,KAAM,OAAQhE,MAAO,OAItC,MAAM6F,EAAS,CAAC7B,KAAM,UAAWm2B,QAAS,KAAMqvC,aAAYl5D,YAE5D,OADA+wB,EAAM64B,MAAM53D,EAAMuD,GACXw7B,EAAMwyE,UAAUvxG,EAAMuD,EAC/B,EEjDE8rE,KcxBK,SAActwC,EAAO/+B,GAE1B,MAAMknE,EAAa,CAAC,EACduT,EAAU17C,EAAMgX,IAAI/1C,GAC1B,IAAI6zB,GAAS,EAOb,IAL0B,kBAAf7zB,EAAKF,OAAqC,IAAfE,EAAKF,QACzConE,EAAWpnE,MAAQE,EAAKF,SAIjB+zB,EAAQ4mD,EAAQl8E,QAAQ,CAC/B,MAAM2X,EAAQukE,EAAQ5mD,GAEtB,GACiB,YAAf3d,EAAMxU,MACY,OAAlBwU,EAAM2hB,SACN3hB,EAAMgxD,YACNtqE,MAAMF,QAAQwZ,EAAMgxD,WAAW9c,YAC/Bl0C,EAAMgxD,WAAW9c,UAAUj/C,SAAS,kBACpC,CACA+7D,EAAW9c,UAAY,CAAC,sBACxB,KACF,CACF,CAGA,MAAM7mD,EAAS,CACb7B,KAAM,UACNm2B,QAAS73B,EAAKitG,QAAU,KAAO,KAC/B/lC,aACAl5D,SAAU+wB,EAAMw4C,KAAKkD,GAAS,IAGhC,OADA17C,EAAM64B,MAAM53D,EAAMuD,GACXw7B,EAAMwyE,UAAUvxG,EAAMuD,EAC/B,EdVEu4F,Ue1BK,SAAmB/8D,EAAO/+B,GAE/B,MAAMuD,EAAS,CACb7B,KAAM,UACNm2B,QAAS,IACTqvC,WAAY,CAAC,EACbl5D,SAAU+wB,EAAMgX,IAAI/1C,IAGtB,OADA++B,EAAM64B,MAAM53D,EAAMuD,GACXw7B,EAAMwyE,UAAUvxG,EAAMuD,EAC/B,EfkBEirF,KgB3BK,SAAczvD,EAAO/+B,GAE1B,MAAMuD,EAAS,CAAC7B,KAAM,OAAQsM,SAAU+wB,EAAMw4C,KAAKx4C,EAAMgX,IAAI/1C,KAE7D,OADA++B,EAAM64B,MAAM53D,EAAMuD,GACXw7B,EAAMwyE,UAAUvxG,EAAMuD,EAC/B,EhBuBEolG,OiB7BK,SAAgB5pE,EAAO/+B,GAE5B,MAAMuD,EAAS,CACb7B,KAAM,UACNm2B,QAAS,SACTqvC,WAAY,CAAC,EACbl5D,SAAU+wB,EAAMgX,IAAI/1C,IAGtB,OADA++B,EAAM64B,MAAM53D,EAAMuD,GACXw7B,EAAMwyE,UAAUvxG,EAAMuD,EAC/B,EjBoBEkvG,MkB/BK,SAAe1zE,EAAO/+B,GAC3B,MAAMk2E,EAAOn3C,EAAMgX,IAAI/1C,GACjB0yG,EAAWx8B,EAAK16D,QAEhBm3F,EAAe,GAErB,GAAID,EAAU,CAEZ,MAAMp7D,EAAO,CACX51C,KAAM,UACNm2B,QAAS,QACTqvC,WAAY,CAAC,EACbl5D,SAAU+wB,EAAMw4C,KAAK,CAACm7B,IAAW,IAEnC3zE,EAAM64B,MAAM53D,EAAKgO,SAAS,GAAIspC,GAC9Bq7D,EAAa5xG,KAAKu2C,EACpB,CAEA,GAAI4+B,EAAK33E,OAAS,EAAG,CAEnB,MAAMoO,EAAO,CACXjL,KAAM,UACNm2B,QAAS,QACTqvC,WAAY,CAAC,EACbl5D,SAAU+wB,EAAMw4C,KAAKrB,GAAM,IAGvBp2E,EAAQ4qF,GAAW1qF,EAAKgO,SAAS,IACjC5N,EAAMoqF,GAASxqF,EAAKgO,SAAShO,EAAKgO,SAASzP,OAAS,IACtDuB,GAASM,IAAKuM,EAAK9M,SAAW,CAACC,QAAOM,QAC1CuyG,EAAa5xG,KAAK4L,EACpB,CAGA,MAAMpJ,EAAS,CACb7B,KAAM,UACNm2B,QAAS,QACTqvC,WAAY,CAAC,EACbl5D,SAAU+wB,EAAMw4C,KAAKo7B,GAAc,IAGrC,OADA5zE,EAAM64B,MAAM53D,EAAMuD,GACXw7B,EAAMwyE,UAAUvxG,EAAMuD,EAC/B,ElBVEqvG,UmB/BK,SAAmB7zE,EAAO/+B,GAI/B,MAAMuD,EAAS,CACb7B,KAAM,UACNm2B,QAAS,KACTqvC,WAAY,CAAC,EACbl5D,SAAU+wB,EAAMgX,IAAI/1C,IAGtB,OADA++B,EAAM64B,MAAM53D,EAAMuD,GACXw7B,EAAMwyE,UAAUvxG,EAAMuD,EAC/B,EnBoBEsvG,SoB3BK,SAAkB9zE,EAAO/+B,EAAMorF,GACpC,MAAMlvC,EAAWkvC,EAASA,EAAOp9E,cAAWtL,EAGtCm1B,EAAuB,KADZqkB,EAAWA,EAAS9pC,QAAQpS,GAAQ,GACpB,KAAO,KAElCy3E,EAAQ2T,GAA0B,UAAhBA,EAAO1pF,KAAmB0pF,EAAO3T,WAAQ/0E,EAC3DnE,EAASk5E,EAAQA,EAAMl5E,OAASyB,EAAKgO,SAASzP,OACpD,IAAIu0G,GAAa,EAEjB,MAAMC,EAAQ,GAEd,OAASD,EAAYv0G,GAAQ,CAE3B,MAAMy0G,EAAOhzG,EAAKgO,SAAS8kG,GAErB5rC,EAAa,CAAC,EACdomB,EAAa7V,EAAQA,EAAMq7B,QAAapwG,EAE1C4qF,IACFpmB,EAAWuQ,MAAQ6V,GAIrB,IAAI/pF,EAAS,CAAC7B,KAAM,UAAWm2B,UAASqvC,aAAYl5D,SAAU,IAE1DglG,IACFzvG,EAAOyK,SAAW+wB,EAAMgX,IAAIi9D,GAC5Bj0E,EAAM64B,MAAMo7C,EAAMzvG,GAClBA,EAASw7B,EAAMwyE,UAAUyB,EAAMzvG,IAGjCwvG,EAAMhyG,KAAKwC,EACb,CAGA,MAAMA,EAAS,CACb7B,KAAM,UACNm2B,QAAS,KACTqvC,WAAY,CAAC,EACbl5D,SAAU+wB,EAAMw4C,KAAKw7B,GAAO,IAG9B,OADAh0E,EAAM64B,MAAM53D,EAAMuD,GACXw7B,EAAMwyE,UAAUvxG,EAAMuD,EAC/B,EpBhBEiiB,KqBjCK,SAAcuZ,EAAO/+B,GAE1B,MAAMuD,EAAS,CAAC7B,KAAM,OAAQhE,MAAOyzG,GAAU/uF,OAAOpiB,EAAKtC,SAE3D,OADAqhC,EAAM64B,MAAM53D,EAAMuD,GACXw7B,EAAMwyE,UAAUvxG,EAAMuD,EAC/B,ErB6BEi1F,csBlCK,SAAuBz5D,EAAO/+B,GAEnC,MAAMuD,EAAS,CACb7B,KAAM,UACNm2B,QAAS,KACTqvC,WAAY,CAAC,EACbl5D,SAAU,IAGZ,OADA+wB,EAAM64B,MAAM53D,EAAMuD,GACXw7B,EAAMwyE,UAAUvxG,EAAMuD,EAC/B,EtByBE0vG,KAAMC,GACNC,KAAMD,GACNt9D,WAAYs9D,GACZE,mBAAoBF,IAItB,SAASA,KAET,CuBoHA,MAAMjsC,GAAM,CAAC,EAAE7qE,eAGTopE,GAAe,CAAC,EAsJtB,SAAS5N,GAAMkrB,EAAM5pC,GACf4pC,EAAKjjF,WAAUq5C,EAAGr5C,S7FtPjB,SAAkBG,GACvB,MAAMF,EAAQ4qF,GAAW1qF,GACnBI,EAAMoqF,GAASxqF,GAErB,GAAIF,GAASM,EACX,MAAO,CAACN,QAAOM,MAEnB,C6F+OmCP,CAASijF,GAC5C,CAcA,SAASyuB,GAAUzuB,EAAM5pC,GAEvB,IAAI31C,EAAS21C,EAGb,GAAI4pC,GAAQA,EAAKhiE,KAAM,CACrB,MAAMuyF,EAAQvwB,EAAKhiE,KAAKuyF,MAClBC,EAAYxwB,EAAKhiE,KAAKwyF,UACtBC,EAAczwB,EAAKhiE,KAAKyyF,YAE9B,GAAqB,kBAAVF,EAGT,GAAoB,YAAhB9vG,EAAO7B,KACT6B,EAAOs0B,QAAUw7E,MAMd,CAIH9vG,EAAS,CAAC7B,KAAM,UAAWm2B,QAASw7E,EAAOnsC,WAAY,CAAC,EAAGl5D,SAD1C,aAAczK,EAASA,EAAOyK,SAAW,CAACzK,GAE7D,CAGkB,YAAhBA,EAAO7B,MAAsB6xG,GAC/Br3G,OAAOoO,OAAO/G,EAAO2jE,WAAY8nC,GAAgBuE,IAIjD,aAAchwG,GACdA,EAAOyK,UACO,OAAdslG,QACc5wG,IAAd4wG,IAEA/vG,EAAOyK,SAAWslG,EAEtB,CAEA,OAAO/vG,CACT,CAYA,SAASiwG,GAAsBz0E,EAAO/+B,GACpC,MAAM8gB,EAAO9gB,EAAK8gB,MAAQ,CAAC,EAErBvd,IACJ,UAAWvD,IACTinE,GAAIpqE,KAAKikB,EAAM,gBAAkBmmD,GAAIpqE,KAAKikB,EAAM,aAE9C,CACEpf,KAAM,UACNm2B,QAAS,MACTqvC,WAAY,CAAC,EACbl5D,SAAU+wB,EAAMgX,IAAI/1C,IALtB,CAAC0B,KAAM,OAAQhE,MAAOsC,EAAKtC,OASjC,OADAqhC,EAAM64B,MAAM53D,EAAMuD,GACXw7B,EAAMwyE,UAAUvxG,EAAMuD,EAC/B,CAcO,SAASg0E,GAAKk8B,EAAOlB,GAE1B,MAAMhvG,EAAS,GACf,IAAIswB,GAAS,EAMb,IAJI0+E,GACFhvG,EAAOxC,KAAK,CAACW,KAAM,OAAQhE,MAAO,SAG3Bm2B,EAAQ4/E,EAAMl1G,QACjBs1B,GAAOtwB,EAAOxC,KAAK,CAACW,KAAM,OAAQhE,MAAO,OAC7C6F,EAAOxC,KAAK0yG,EAAM5/E,IAOpB,OAJI0+E,GAASkB,EAAMl1G,OAAS,GAC1BgF,EAAOxC,KAAK,CAACW,KAAM,OAAQhE,MAAO,OAG7B6F,CACT,CAUA,SAASmwG,GAAuBh2G,GAC9B,IAAIm2B,EAAQ,EACRvR,EAAO5kB,EAAM26F,WAAWxkE,GAE5B,KAAgB,IAATvR,GAAuB,KAATA,GACnBuR,IACAvR,EAAO5kB,EAAM26F,WAAWxkE,GAG1B,OAAOn2B,EAAMyD,MAAM0yB,EACrB,CCjYO,SAAS8/E,GAAO5nB,EAAMzuF,GAC3B,MAAMyhC,ED0GD,SAAqBgtD,EAAMzuF,GAChC,MAAMuxF,EAAWvxF,GAAWkoE,GAEtB4sC,EAAiB,IAAIj4F,IAErBy5F,EAAe,IAAIz5F,IAEnB43F,EAAiB,IAAI53F,IAIrBk3F,EAAW,IAAIwC,MAAoBhlB,EAASwiB,UAG5CtyE,EAAQ,CACZgX,IA0EF,SAAaq1C,GAEX,MAAMpkB,EAAS,GAEf,GAAI,aAAcokB,EAAQ,CACxB,MAAMqoB,EAAQroB,EAAOp9E,SACrB,IAAI6lB,GAAS,EACb,OAASA,EAAQ4/E,EAAMl1G,QAAQ,CAC7B,MAAMgF,EAASw7B,EAAMouD,IAAIsmB,EAAM5/E,GAAQu3D,GAGvC,GAAI7nF,EAAQ,CACV,GAAIswB,GAAmC,UAA1B4/E,EAAM5/E,EAAQ,GAAGnyB,OACvB9E,MAAMF,QAAQ6G,IAA2B,SAAhBA,EAAO7B,OACnC6B,EAAO7F,MAAQg2G,GAAuBnwG,EAAO7F,SAG1Cd,MAAMF,QAAQ6G,IAA2B,YAAhBA,EAAO7B,MAAoB,CACvD,MAAM41C,EAAO/zC,EAAOyK,SAAS,GAEzBspC,GAAsB,SAAdA,EAAK51C,OACf41C,EAAK55C,MAAQg2G,GAAuBp8D,EAAK55C,OAE7C,CAGEd,MAAMF,QAAQ6G,GAChByjE,EAAOjmE,QAAQwC,GAEfyjE,EAAOjmE,KAAKwC,EAEhB,CACF,CACF,CAEA,OAAOyjE,CACT,EA7GEuqC,aACAa,iBACAwB,eACA7B,iBACAH,cAAe,GACfP,WACAlkB,IAgCF,SAAantF,EAAMorF,GACjB,MAAM1pF,EAAO1B,EAAK0B,KACZilD,EAAS5nB,EAAMsyE,SAAS3vG,GAE9B,GAAIulE,GAAIpqE,KAAKkiC,EAAMsyE,SAAU3vG,IAASilD,EACpC,OAAOA,EAAO5nB,EAAO/+B,EAAMorF,GAG7B,GAAIrsD,EAAMzhC,QAAQw2G,aAAe/0E,EAAMzhC,QAAQw2G,YAAY3oG,SAASzJ,GAAO,CACzE,GAAI,aAAc1B,EAAM,CACtB,MAAM,SAACgO,KAAa+lG,GAAW/zG,EACzBuD,EAASyrG,GAAgB+E,GAI/B,OAFAxwG,EAAOyK,SAAW+wB,EAAMgX,IAAI/1C,GAErBuD,CACT,CAGA,OAAOyrG,GAAgBhvG,EACzB,CAIA,OAFgB++B,EAAMzhC,QAAQ02G,gBAAkBR,IAEjCz0E,EAAO/+B,EAAMorF,EAC9B,EAxDE9tF,QAASuxF,EACTj3B,SACA2f,SAiBF,OAdAg5B,GAAMxkB,GAAM,SAAU/rF,GACpB,GAAkB,eAAdA,EAAK0B,MAAuC,uBAAd1B,EAAK0B,KAA+B,CACpE,MAAMyvC,EAAoB,eAAdnxC,EAAK0B,KAAwB0wG,EAAiBwB,EACpDv3F,EAAK+F,OAAOpiB,EAAK26F,YAAYtyF,cAI9B8oC,EAAIvlB,IAAIvP,IAEX80B,EAAIvmC,IAAIyR,EAAIrc,EAEhB,CACF,IAEO++B,CAoFT,CCxOgBk1E,CAAYloB,EAAMzuF,GAC1B0C,EAAO++B,EAAMouD,IAAIpB,OAAMrpF,GACvBwxG,E/BkCD,SAAgBn1E,GACrB,MAAM2yE,EACmC,kBAAhC3yE,EAAMzhC,QAAQo0G,cACjB3yE,EAAMzhC,QAAQo0G,cACd,gBACAyC,EACJp1E,EAAMzhC,QAAQ62G,qBAAuBhF,GACjCiF,EACJr1E,EAAMzhC,QAAQ82G,mBAAqB/E,GAC/BgF,EAAgBt1E,EAAMzhC,QAAQ+2G,eAAiB,YAC/CC,EAAuBv1E,EAAMzhC,QAAQg3G,sBAAwB,KAC7DC,EAA0Bx1E,EAAMzhC,QAAQi3G,yBAA2B,CACvEnqD,UAAW,CAAC,YAGRoqD,EAAY,GAClB,IAAIlF,GAAkB,EAEtB,OAASA,EAAiBvwE,EAAM6yE,cAAcrzG,QAAQ,CACpD,MAAMq3C,EAAa7W,EAAM60E,aAAa1nG,IACpC6yB,EAAM6yE,cAActC,IAGtB,IAAK15D,EACH,SAGF,MAAMt1C,EAAUy+B,EAAMgX,IAAIH,GACpBv5B,EAAK+F,OAAOwzB,EAAW+kD,YAAYtyF,cACnCspG,EAAS1C,GAAa5yF,EAAGnU,eAC/B,IAAIknG,EAAmB,EAEvB,MAAMqF,EAAiB,GACjBC,EAAS31E,EAAMgzE,eAAe7lG,IAAImQ,GAGxC,UAAkB3Z,IAAXgyG,KAA0BtF,GAAoBsF,GAAQ,CACvDD,EAAel2G,OAAS,GAC1Bk2G,EAAe1zG,KAAK,CAACW,KAAM,OAAQhE,MAAO,MAG5C,IAAIsQ,EAC6B,kBAAxBmmG,EACHA,EACAA,EAAoB7E,EAAgBF,GAElB,kBAAbphG,IACTA,EAAW,CAACtM,KAAM,OAAQhE,MAAOsQ,IAGnCymG,EAAe1zG,KAAK,CAClBW,KAAM,UACNm2B,QAAS,IACTqvC,WAAY,CACVl/C,KACE,IACA0pF,EACA,SACAC,GACCvC,EAAmB,EAAI,IAAMA,EAAmB,IACnDuF,oBAAqB,GACrB53C,UAC+B,kBAAtBq3C,EACHA,EACAA,EAAkB9E,EAAgBF,GACxChlD,UAAW,CAAC,0BAEdp8C,SAAUpR,MAAMF,QAAQsR,GAAYA,EAAW,CAACA,IAEpD,CAEA,MAAMi2B,EAAO3jC,EAAQA,EAAQ/B,OAAS,GAEtC,GAAI0lC,GAAsB,YAAdA,EAAKviC,MAAuC,MAAjBuiC,EAAKpM,QAAiB,CAC3D,MAAM+8E,EAAW3wE,EAAKj2B,SAASi2B,EAAKj2B,SAASzP,OAAS,GAClDq2G,GAA8B,SAAlBA,EAASlzG,KACvBkzG,EAASl3G,OAAS,IAElBumC,EAAKj2B,SAASjN,KAAK,CAACW,KAAM,OAAQhE,MAAO,MAG3CumC,EAAKj2B,SAASjN,QAAQ0zG,EACxB,MACEn0G,EAAQS,QAAQ0zG,GAIlB,MAAM1M,EAAW,CACfrmG,KAAM,UACNm2B,QAAS,KACTqvC,WAAY,CAAC7qD,GAAIq1F,EAAgB,MAAQC,GACzC3jG,SAAU+wB,EAAMw4C,KAAKj3E,GAAS,IAGhCy+B,EAAM64B,MAAMhiB,EAAYmyD,GAExByM,EAAUzzG,KAAKgnG,EACjB,CAEA,GAAyB,IAArByM,EAAUj2G,OAId,MAAO,CACLmD,KAAM,UACNm2B,QAAS,UACTqvC,WAAY,CAAC2tC,eAAe,EAAMzqD,UAAW,CAAC,cAC9Cp8C,SAAU,CACR,CACEtM,KAAM,UACNm2B,QAASy8E,EACTptC,WAAY,IACP8nC,GAAgBuF,GACnBl4F,GAAI,kBAENrO,SAAU,CAAC,CAACtM,KAAM,OAAQhE,MAAO22G,KAEnC,CAAC3yG,KAAM,OAAQhE,MAAO,MACtB,CACEgE,KAAM,UACNm2B,QAAS,KACTqvC,WAAY,CAAC,EACbl5D,SAAU+wB,EAAMw4C,KAAKi9B,GAAW,IAElC,CAAC9yG,KAAM,OAAQhE,MAAO,OAG5B,C+BjKeo3G,CAAO/1E,GAEdx7B,EAAS3G,MAAMF,QAAQsD,GACzB,CAAC0B,KAAM,OAAQsM,SAAUhO,GACzBA,GAAQ,CAAC0B,KAAM,OAAQsM,SAAU,IAUrC,OARIkmG,GAKF3wG,EAAOyK,SAASjN,KAAK,CAACW,KAAM,OAAQhE,MAAO,MAAOw2G,GAG7C3wG,CACT,CC8Be,SAASwxG,GAAaC,EAAa13G,GAChD,OAAI03G,GAAe,QAASA,EAInB3oC,eAAgB0f,EAAMT,GAE3B,MAAM2pB,EACJtB,GAAO5nB,EAAM,CAACT,UAAShuF,UAEnB03G,EAAYE,IAAID,EAAU3pB,EAClC,EAMK,SAAUS,EAAMT,GAMrB,OACEqoB,GAAO5nB,EAAM,CAACT,UAAU0pB,GAAe13G,GAE3C,CACF,CC3JO,SAAS63G,GAAK30G,GACnB,GAAIA,EACF,MAAMA,CAEV,eCXe,SAAS1D,GAAcY,GACrC,GAAqB,kBAAVA,GAAgC,OAAVA,EAChC,OAAO,EAGR,MAAMvB,EAAYD,OAAOs5C,eAAe93C,GACxC,OAAsB,OAAdvB,GAAsBA,IAAcD,OAAOC,WAAkD,OAArCD,OAAOs5C,eAAer5C,OAA0BgN,OAAOouC,eAAe75C,MAAYyL,OAAOe,YAAYxM,EACtK,CC+BO,SAAS03G,KAEd,MAAMC,EAAM,GAENC,EAAW,CAACJ,IAKlB,WAAwB,QAAApyG,EAAAzE,UAAAE,OAARyoE,EAAM,IAAApqE,MAAAkG,GAAAE,EAAA,EAAAA,EAAAF,EAAAE,IAANgkE,EAAMhkE,GAAA3E,UAAA2E,GACpB,IAAIuyG,GAAmB,EAEvB,MAAMx+E,EAAWiwC,EAAOn0B,MAExB,GAAwB,oBAAb9b,EACT,MAAM,IAAIz3B,UAAU,2CAA6Cy3B,IAWnE,SAASxC,EAAK/zB,GACZ,MAAM62C,EAAKg+D,IAAME,GACjB,IAAI1hF,GAAS,EAEb,GAAIrzB,EACFu2B,EAASv2B,OADX,CAKA,QAAA2C,EAAA9E,UAAAE,OATsBi3G,EAAM,IAAA54G,MAAAuG,EAAA,EAAAA,EAAA,KAAAC,EAAA,EAAAA,EAAAD,EAAAC,IAANoyG,EAAMpyG,EAAA,GAAA/E,UAAA+E,GAU5B,OAASywB,EAAQmzC,EAAOzoE,QACA,OAAlBi3G,EAAO3hF,SAAqCnxB,IAAlB8yG,EAAO3hF,KACnC2hF,EAAO3hF,GAASmzC,EAAOnzC,IAK3BmzC,EAASwuC,EAGLn+D,EAqDH,SAAco+D,EAAY1+E,GAE/B,IAAI64B,EAEJ,OAAO8lD,EAQP,SAASA,IAAuB,QAAAC,EAAAt3G,UAAAE,OAAZ8xF,EAAU,IAAAzzF,MAAA+4G,GAAAC,EAAA,EAAAA,EAAAD,EAAAC,IAAVvlB,EAAUulB,GAAAv3G,UAAAu3G,GAC5B,MAAMC,EAAoBJ,EAAWl3G,OAAS8xF,EAAW9xF,OAEzD,IAAIgF,EAEAsyG,GACFxlB,EAAWtvF,KAAKyzB,GAGlB,IACEjxB,EAASkyG,EAAWjyG,MAAMrD,KAAMkwF,EAClC,CAAE,MAAO7vF,GAOP,GAAIq1G,GAAqBjmD,EACvB,MAPsCpvD,EAUxC,OAAOg0B,EAViCh0B,EAW1C,CAEKq1G,IACCtyG,GAAUA,EAAOmrB,MAA+B,oBAAhBnrB,EAAOmrB,KACzCnrB,EAAOmrB,KAAKA,EAAM8F,GACTjxB,aAAkB5C,MAC3B6zB,EAAKjxB,GAELmrB,EAAKnrB,GAGX,CAOA,SAASixB,EAAKh0B,GACZ,IAAKovD,EAAQ,CACXA,GAAS,EAAI,QAAAkmD,EAAAz3G,UAAAE,OAFOi3G,EAAM,IAAA54G,MAAAk5G,EAAA,EAAAA,EAAA,KAAAC,EAAA,EAAAA,EAAAD,EAAAC,IAANP,EAAMO,EAAA,GAAA13G,UAAA03G,GAG1Bh/E,EAASv2B,KAAUg1G,EACrB,CACF,CAOA,SAAS9mF,EAAKhxB,GACZ82B,EAAK,KAAM92B,EACb,CACF,CAxHQ65E,CAAKlgC,EAAI9iB,EAATgjD,IAAkBi+B,GAElBz+E,EAAS,QAASy+E,EAhBpB,CAkBF,CAjCAjhF,CAAK,QAASyyC,EAkChB,EAhDuBm6B,IAmDvB,SAAa6U,GACX,GAA0B,oBAAfA,EACT,MAAM,IAAI12G,UACR,+CAAiD02G,GAKrD,OADAX,EAAIt0G,KAAKi1G,GACFV,CACT,GA1DA,OAAOA,CA2DT,CCpDO,MAAMW,GAAU,CAACv6D,SAcxB,SAAkBhC,EAAMw8D,GACtB,QAAgBxzG,IAAZwzG,GAA4C,kBAAZA,EAClC,MAAM,IAAI52G,UAAU,mCAGtB62G,GAAWz8D,GACX,IAII08D,EAJAt2G,EAAQ,EACRM,GAAO,EACPyzB,EAAQ6lB,EAAKn7C,OAIjB,QACcmE,IAAZwzG,GACmB,IAAnBA,EAAQ33G,QACR23G,EAAQ33G,OAASm7C,EAAKn7C,OACtB,CACA,KAAOs1B,KACL,GAAgC,KAA5B6lB,EAAK+yD,YAAY54E,IAGnB,GAAIuiF,EAAc,CAChBt2G,EAAQ+zB,EAAQ,EAChB,KACF,OACSzzB,EAAM,IAGfg2G,GAAe,EACfh2G,EAAMyzB,EAAQ,GAIlB,OAAOzzB,EAAM,EAAI,GAAKs5C,EAAKv4C,MAAMrB,EAAOM,EAC1C,CAEA,GAAI81G,IAAYx8D,EACd,MAAO,GAGT,IAAI28D,GAAoB,EACpBC,EAAeJ,EAAQ33G,OAAS,EAEpC,KAAOs1B,KACL,GAAgC,KAA5B6lB,EAAK+yD,YAAY54E,IAGnB,GAAIuiF,EAAc,CAChBt2G,EAAQ+zB,EAAQ,EAChB,KACF,OAEIwiF,EAAmB,IAGrBD,GAAe,EACfC,EAAmBxiF,EAAQ,GAGzByiF,GAAgB,IAEd58D,EAAK+yD,YAAY54E,KAAWqiF,EAAQzJ,YAAY6J,KAC9CA,EAAe,IAGjBl2G,EAAMyzB,IAKRyiF,GAAgB,EAChBl2G,EAAMi2G,IAMVv2G,IAAUM,EACZA,EAAMi2G,EACGj2G,EAAM,IACfA,EAAMs5C,EAAKn7C,QAGb,OAAOm7C,EAAKv4C,MAAMrB,EAAOM,EAC3B,EAlGkCm2G,QA4GlC,SAAiB78D,GAGf,GAFAy8D,GAAWz8D,GAES,IAAhBA,EAAKn7C,OACP,MAAO,IAGT,IAGIi4G,EAHAp2G,GAAO,EACPyzB,EAAQ6lB,EAAKn7C,OAKjB,OAASs1B,GACP,GAAgC,KAA5B6lB,EAAK+yD,YAAY54E,IACnB,GAAI2iF,EAAgB,CAClBp2G,EAAMyzB,EACN,KACF,OACU2iF,IAEVA,GAAiB,GAIrB,OAAOp2G,EAAM,EACe,KAAxBs5C,EAAK+yD,YAAY,GACf,IACA,IACM,IAARrsG,GAAqC,KAAxBs5C,EAAK+yD,YAAY,GAC5B,KACA/yD,EAAKv4C,MAAM,EAAGf,EACtB,EA5I2C81G,QAsJ3C,SAAiBx8D,GACfy8D,GAAWz8D,GAEX,IASI88D,EATA3iF,EAAQ6lB,EAAKn7C,OAEb6B,GAAO,EACPq2G,EAAY,EACZC,GAAY,EAGZC,EAAc,EAIlB,KAAO9iF,KAAS,CACd,MAAMvR,EAAOo3B,EAAK+yD,YAAY54E,GAE9B,GAAa,KAATvR,EAWAliB,EAAM,IAGRo2G,GAAiB,EACjBp2G,EAAMyzB,EAAQ,GAGH,KAATvR,EAEEo0F,EAAW,EACbA,EAAW7iF,EACc,IAAhB8iF,IACTA,EAAc,GAEPD,GAAY,IAGrBC,GAAe,QAzBf,GAAIH,EAAgB,CAClBC,EAAY5iF,EAAQ,EACpB,KACF,CAwBJ,CAEA,GACE6iF,EAAW,GACXt2G,EAAM,GAEU,IAAhBu2G,GAEiB,IAAhBA,GAAqBD,IAAat2G,EAAM,GAAKs2G,IAAaD,EAAY,EAEvE,MAAO,GAGT,OAAO/8D,EAAKv4C,MAAMu1G,EAAUt2G,EAC9B,EAnNoDszB,KA6NpD,WACE,IAEIkjF,EAFA/iF,GAAS,EAEH,QAAA/wB,EAAAzE,UAAAE,OAHKi/C,EAAQ,IAAA5gD,MAAAkG,GAAAE,EAAA,EAAAA,EAAAF,EAAAE,IAARw6C,EAAQx6C,GAAA3E,UAAA2E,GAKvB,OAAS6wB,EAAQ2pB,EAASj/C,QACxB43G,GAAW34D,EAAS3pB,IAEhB2pB,EAAS3pB,KACX+iF,OACal0G,IAAXk0G,EAAuBp5D,EAAS3pB,GAAS+iF,EAAS,IAAMp5D,EAAS3pB,IAIvE,YAAkBnxB,IAAXk0G,EAAuB,IAahC,SAAmBl9D,GACjBy8D,GAAWz8D,GAEX,MAAMm9D,EAAmC,KAAxBn9D,EAAK+yD,YAAY,GAGlC,IAAI/uG,EAuBN,SAAyBg8C,EAAMo9D,GAC7B,IAMIx0F,EAEAy0F,EARAxzG,EAAS,GACTyzG,EAAoB,EACpBC,GAAa,EACbC,EAAO,EACPrjF,GAAS,EAMb,OAASA,GAAS6lB,EAAKn7C,QAAQ,CAC7B,GAAIs1B,EAAQ6lB,EAAKn7C,OACf+jB,EAAOo3B,EAAK+yD,YAAY54E,OACnB,IAAa,KAATvR,EACT,MAEAA,EAAO,EACT,CAEA,GAAa,KAATA,EAAuB,CACzB,GAAI20F,IAAcpjF,EAAQ,GAAc,IAATqjF,QAExB,GAAID,IAAcpjF,EAAQ,GAAc,IAATqjF,EAAY,CAChD,GACE3zG,EAAOhF,OAAS,GACM,IAAtBy4G,GAC0C,KAA1CzzG,EAAOkpG,YAAYlpG,EAAOhF,OAAS,IACO,KAA1CgF,EAAOkpG,YAAYlpG,EAAOhF,OAAS,GAEnC,GAAIgF,EAAOhF,OAAS,GAGlB,GAFAw4G,EAAiBxzG,EAAO3D,YAAY,KAEhCm3G,IAAmBxzG,EAAOhF,OAAS,EAAG,CACpCw4G,EAAiB,GACnBxzG,EAAS,GACTyzG,EAAoB,IAEpBzzG,EAASA,EAAOpC,MAAM,EAAG41G,GACzBC,EAAoBzzG,EAAOhF,OAAS,EAAIgF,EAAO3D,YAAY,MAG7Dq3G,EAAYpjF,EACZqjF,EAAO,EACP,QACF,OACK,GAAI3zG,EAAOhF,OAAS,EAAG,CAC5BgF,EAAS,GACTyzG,EAAoB,EACpBC,EAAYpjF,EACZqjF,EAAO,EACP,QACF,CAGEJ,IACFvzG,EAASA,EAAOhF,OAAS,EAAIgF,EAAS,MAAQ,KAC9CyzG,EAAoB,EAExB,MACMzzG,EAAOhF,OAAS,EAClBgF,GAAU,IAAMm2C,EAAKv4C,MAAM81G,EAAY,EAAGpjF,GAE1CtwB,EAASm2C,EAAKv4C,MAAM81G,EAAY,EAAGpjF,GAGrCmjF,EAAoBnjF,EAAQojF,EAAY,EAG1CA,EAAYpjF,EACZqjF,EAAO,CACT,MAAoB,KAAT50F,GAAyB40F,GAAQ,EAC1CA,IAEAA,GAAQ,CAEZ,CAEA,OAAO3zG,CACT,CAtGc4zG,CAAgBz9D,GAAOm9D,GAEd,IAAjBn5G,EAAMa,QAAiBs4G,IACzBn5G,EAAQ,KAGNA,EAAMa,OAAS,GAA2C,KAAtCm7C,EAAK+yD,YAAY/yD,EAAKn7C,OAAS,KACrDb,GAAS,KAGX,OAAOm5G,EAAW,IAAMn5G,EAAQA,CAClC,CA9BsC2zD,CAAUulD,EAChD,EA5O0DQ,IAAK,KA8W/D,SAASjB,GAAWz8D,GAClB,GAAoB,kBAATA,EACT,MAAM,IAAIp6C,UACR,mCAAqCguC,KAAKC,UAAUmM,GAG1D,CCpaO,MAAM29D,GAAU,CAACC,IAExB,WACE,MAAO,GACT,GCYO,SAASC,GAAMC,GACpB,OAAO3nB,QACa,OAAlB2nB,GAC2B,kBAAlBA,GACP,SAAUA,GACVA,EAAcxvF,MACd,aAAcwvF,GACdA,EAAcC,eAES/0G,IAAvB80G,EAAcE,KAEpB,CClBO,SAASC,GAAUj+D,GACxB,GAAoB,kBAATA,EACTA,EAAO,IAAIkB,IAAIlB,QACV,IAAK69D,GAAM79D,GAAO,CAEvB,MAAMl5C,EAAQ,IAAIlB,UAChB,+EACEo6C,EACA,KAGJ,MADAl5C,EAAM8hB,KAAO,uBACP9hB,CACR,CAEA,GAAsB,UAAlBk5C,EAAK+9D,SAAsB,CAE7B,MAAMj3G,EAAQ,IAAIlB,UAAU,kCAE5B,MADAkB,EAAM8hB,KAAO,yBACP9hB,CACR,CAEA,OAWF,SAA6BklB,GAC3B,GAAqB,KAAjBA,EAAIkyF,SAAiB,CAEvB,MAAMp3G,EAAQ,IAAIlB,UAChB,wDAGF,MADAkB,EAAM8hB,KAAO,4BACP9hB,CACR,CAEA,MAAM44C,EAAW1zB,EAAI0zB,SACrB,IAAIvlB,GAAS,EAEb,OAASA,EAAQulB,EAAS76C,QACxB,GACkC,KAAhC66C,EAASqzD,YAAY54E,IACe,KAApCulB,EAASqzD,YAAY54E,EAAQ,GAC7B,CACA,MAAMgkF,EAAQz+D,EAASqzD,YAAY54E,EAAQ,GAC3C,GAAc,KAAVgkF,GAAoC,MAAVA,EAAyB,CAErD,MAAMr3G,EAAQ,IAAIlB,UAChB,uDAGF,MADAkB,EAAM8hB,KAAO,4BACP9hB,CACR,CACF,CAGF,OAAOo/C,mBAAmBxG,EAC5B,CA1CS0+D,CAAoBp+D,EAC7B,CCdA,MAAMvoC,GAA8B,CAClC,UACA,OACA,WACA,OACA,UACA,WAGK,MAAM4mG,GAuBX56G,WAAAA,CAAYO,GAEV,IAAIJ,EAKFA,EAHGI,EAEM65G,GAAM75G,GACL,CAACg8C,KAAMh8C,GACS,kBAAVA,GA+jBtB,SAAsBA,GACpB,OAAOmyF,QACLnyF,GACmB,kBAAVA,GACP,eAAgBA,GAChB,eAAgBA,EAEtB,CAtkB4Cs6G,CAAat6G,GACzC,CAACA,SAEDA,EANA,CAAC,EAkBbyC,KAAKm3G,IAAM,QAASh6G,EAAU,GAAK+5G,GAAQC,MAU3Cn3G,KAAK2gB,KAAO,CAAC,EASb3gB,KAAKi6C,QAAU,GAOfj6C,KAAK83G,SAAW,GAOhB93G,KAAKzC,MAYLyC,KAAKgxC,IAULhxC,KAAKoD,OASLpD,KAAK+3G,OAIL,IAkBItgB,EAlBA/jE,GAAS,EAEb,OAASA,EAAQ1iB,GAAM5S,QAAQ,CAC7B,MAAMq5F,EAAQzmF,GAAM0iB,GAKlB+jE,KAASt6F,QACUoF,IAAnBpF,EAAQs6F,IACW,OAAnBt6F,EAAQs6F,KAGRz3F,KAAKy3F,GAAmB,YAAVA,EAAsB,IAAIt6F,EAAQs6F,IAAUt6F,EAAQs6F,GAEtE,CAMA,IAAKA,KAASt6F,EAEP6T,GAAMhG,SAASysF,KAElBz3F,KAAKy3F,GAASt6F,EAAQs6F,GAG5B,CAQA,YAAIl8C,GACF,MAA4B,kBAAdv7C,KAAKu5C,KACfu8D,GAAQv6D,SAASv7C,KAAKu5C,WACtBh3C,CACN,CAcA,YAAIg5C,CAASA,GACXy8D,GAAez8D,EAAU,YACzB08D,GAAW18D,EAAU,YACrBv7C,KAAKu5C,KAAOu8D,GAAQviF,KAAKvzB,KAAKo2G,SAAW,GAAI76D,EAC/C,CAQA,WAAI66D,GACF,MAA4B,kBAAdp2G,KAAKu5C,KACfu8D,GAAQM,QAAQp2G,KAAKu5C,WACrBh3C,CACN,CAYA,WAAI6zG,CAAQA,GACVJ,GAAWh2G,KAAKu7C,SAAU,WAC1Bv7C,KAAKu5C,KAAOu8D,GAAQviF,KAAK6iF,GAAW,GAAIp2G,KAAKu7C,SAC/C,CAQA,WAAIw6D,GACF,MAA4B,kBAAd/1G,KAAKu5C,KACfu8D,GAAQC,QAAQ/1G,KAAKu5C,WACrBh3C,CACN,CAcA,WAAIwzG,CAAQA,GAIV,GAHAkC,GAAWlC,EAAS,WACpBC,GAAWh2G,KAAKo2G,QAAS,WAErBL,EAAS,CACX,GAA+B,KAA3BA,EAAQzJ,YAAY,GACtB,MAAM,IAAI9rG,MAAM,iCAGlB,GAAIu1G,EAAQ/qG,SAAS,IAAK,GACxB,MAAM,IAAIxK,MAAM,yCAEpB,CAEAR,KAAKu5C,KAAOu8D,GAAQviF,KAAKvzB,KAAKo2G,QAASp2G,KAAKk4G,MAAQnC,GAAW,IACjE,CAQA,QAAIx8D,GACF,OAAOv5C,KAAKi6C,QAAQj6C,KAAKi6C,QAAQ77C,OAAS,EAC5C,CAcA,QAAIm7C,CAAKA,GACH69D,GAAM79D,KACRA,EAAOi+D,GAAUj+D,IAGnBy+D,GAAez+D,EAAM,QAEjBv5C,KAAKu5C,OAASA,GAChBv5C,KAAKi6C,QAAQr5C,KAAK24C,EAEtB,CAQA,QAAI2+D,GACF,MAA4B,kBAAdl4G,KAAKu5C,KACfu8D,GAAQv6D,SAASv7C,KAAKu5C,KAAMv5C,KAAK+1G,cACjCxzG,CACN,CAcA,QAAI21G,CAAKA,GACPF,GAAeE,EAAM,QACrBD,GAAWC,EAAM,QACjBl4G,KAAKu5C,KAAOu8D,GAAQviF,KAAKvzB,KAAKo2G,SAAW,GAAI8B,GAAQl4G,KAAK+1G,SAAW,IACvE,CA+DAoC,IAAAA,CAAKztB,EAAeC,EAAwBnwC,GAE1C,MAAMhb,EAAUx/B,KAAKw/B,QAAQkrD,EAAeC,EAAwBnwC,GAIpE,MAFAhb,EAAQ0rD,OAAQ,EAEV1rD,CACR,CA4DAwnC,IAAAA,CAAK0jB,EAAeC,EAAwBnwC,GAE1C,MAAMhb,EAAUx/B,KAAKw/B,QAAQkrD,EAAeC,EAAwBnwC,GAIpE,OAFAhb,EAAQ0rD,WAAQ3oF,EAETi9B,CACT,CA4DAA,OAAAA,CAAQkrD,EAAeC,EAAwBnwC,GAC7C,MAAMhb,EAAU,IAAIirD,GAElBC,EACAC,EACAnwC,GAYF,OATIx6C,KAAKu5C,OACP/Z,EAAQpiC,KAAO4C,KAAKu5C,KAAO,IAAM/Z,EAAQpiC,KACzCoiC,EAAQ2rD,KAAOnrF,KAAKu5C,MAGtB/Z,EAAQ0rD,OAAQ,EAEhBlrF,KAAK83G,SAASl3G,KAAK4+B,GAEZA,CACT,CAeArjC,QAAAA,CAASoqG,GACP,QAAmBhkG,IAAfvC,KAAKzC,MACP,MAAO,GAGT,GAA0B,kBAAfyC,KAAKzC,MACd,OAAOyC,KAAKzC,MAId,OADgB,IAAI6vG,YAAY7G,QAAYhkG,GAC7B4jG,OAAOnmG,KAAKzC,MAC7B,EAaF,SAAS06G,GAAWG,EAAMh7G,GACxB,GAAIg7G,GAAQA,EAAKptG,SAAS8qG,GAAQmB,KAChC,MAAM,IAAIz2G,MACR,IAAMpD,EAAO,uCAAyC04G,GAAQmB,IAAM,IAG1E,CAYA,SAASe,GAAeI,EAAMh7G,GAC5B,IAAKg7G,EACH,MAAM,IAAI53G,MAAM,IAAMpD,EAAO,oBAEjC,CAYA,SAAS44G,GAAWz8D,EAAMn8C,GACxB,IAAKm8C,EACH,MAAM,IAAI/4C,MAAM,YAAcpD,EAAO,kCAEzC,CCjnBO,MAAMi7G,GAYP,SAAUz2G,GACR,MAEM02G,EAFOt4G,KACOhD,YAIXhB,UAEHuB,EAAQ+6G,EAAM12G,GAEdyB,EAAQ,WACZ,OAAO9F,EAAM8F,MAAMA,EAAOnF,UAC5B,EAgBA,OAdAnC,OAAOqvD,eAAe/nD,EAAOi1G,GActBj1G,CACT,ECiUAyjE,GAAM,CAAC,EAAE7qE,eAeR,MAAMs8G,WAAkBF,GAI7Br7G,WAAAA,GAEE6lD,MAAM,QAeN7iD,KAAKw4G,cAAWj2G,EAYhBvC,KAAKy4G,YAASl2G,EAadvC,KAAK04G,UAAY,GAajB14G,KAAKgtG,cAAWzqG,EAShBvC,KAAK24G,aAAe,EASpB34G,KAAK44G,YAASr2G,EASdvC,KAAK64G,UAAY,CAAC,EAUlB74G,KAAKqyF,YAAS9vF,EASdvC,KAAK84G,aAAe7D,IACtB,CAaAl3G,IAAAA,GAEE,MAAM82G,EAEF,IAAI0D,GAER,IAAI7kF,GAAS,EAEb,OAASA,EAAQ1zB,KAAK04G,UAAUt6G,QAAQ,CACtC,MAAM26G,EAAW/4G,KAAK04G,UAAUhlF,GAChCmhF,EAAY7T,OAAO+X,EACrB,CAIA,OAFAlE,EAAYl0F,KAAK9iB,IAAO,EAAM,CAAC,EAAGmC,KAAK64G,YAEhChE,CACT,CA6DAl0F,IAAAA,CAAK9jB,EAAKU,GACR,MAAmB,kBAARV,EAEgB,IAArBqB,UAAUE,QACZ46G,GAAe,OAAQh5G,KAAK44G,QAC5B54G,KAAK64G,UAAUh8G,GAAOU,EACfyC,MAID8mE,GAAIpqE,KAAKsD,KAAK64G,UAAWh8G,IAAQmD,KAAK64G,UAAUh8G,SAAS0F,EAI/D1F,GACFm8G,GAAe,OAAQh5G,KAAK44G,QAC5B54G,KAAK64G,UAAYh8G,EACVmD,MAIFA,KAAK64G,SACd,CAmBAI,MAAAA,GACE,GAAIj5G,KAAK44G,OACP,OAAO54G,KAMT,MAAMo4C,EAAyDp4C,KAE/D,OAASA,KAAK24G,YAAc34G,KAAK04G,UAAUt6G,QAAQ,CACjD,MAAO26G,KAAa57G,GAAW6C,KAAK04G,UAAU14G,KAAK24G,aAEnD,IAAmB,IAAfx7G,EAAQ,GACV,UAGiB,IAAfA,EAAQ,KACVA,EAAQ,QAAKoF,GAGf,MAAM22G,EAAcH,EAASr8G,KAAK07C,KAASj7C,GAEhB,oBAAhB+7G,GACTl5G,KAAK84G,aAAa9X,IAAIkY,EAE1B,CAKA,OAHAl5G,KAAK44G,QAAS,EACd54G,KAAK24G,YAAc/wD,OAAO6oC,kBAEnBzwF,IACT,CAgBA4lG,KAAAA,CAAMza,GACJnrF,KAAKi5G,SACL,MAAME,EAAWC,GAAMjuB,GACjBkH,EAASryF,KAAKqyF,QAAUryF,KAAKy4G,OAEnC,OADAY,GAAa,QAAShnB,GACfA,EAAOpwE,OAAOk3F,GAAWA,EAClC,CA4CAG,OAAAA,CAAQnuB,EAAM92D,GACZ,MAAM+jB,EAAOp4C,KAMb,OAJAA,KAAKi5G,SACLI,GAAa,UAAWr5G,KAAKqyF,QAAUryF,KAAKy4G,QAC5Cc,GAAe,UAAWv5G,KAAKgtG,UAAYhtG,KAAKw4G,UAEzCnkF,EAAOmlF,OAASj3G,EAAW8xB,GAAQ,IAAIlG,QAAQqrF,GAQtD,SAASA,EAASlrF,EAASmpB,GACzB,MAAM0hE,EAAWC,GAAMjuB,GAGjBsuB,EAEsBrhE,EAAKwtD,MAAMuT,GA+BvC,SAASO,EAASr5G,EAAO8qF,GACnB9qF,IAAU8qF,EACZ1zC,EAAOp3C,GACEiuB,EACTA,EAAQ68D,GAGR92D,OAAK9xB,EAAW4oF,EAEpB,CArCA/yC,EAAK28D,IAAI0E,EAAWN,GAAU,SAAU94G,EAAOurF,EAAMT,GACnD,GAAI9qF,IAAUurF,IAAST,EACrB,OAAOuuB,EAASr5G,GAKlB,MAAMs5G,EAEsB/tB,EAGtBguB,EAAgBxhE,EAAKhL,UAAUusE,EAAaxuB,GA2iB1D,IAAyB5tF,EACC,kBADDA,EAziBGq8G,IAqjB5B,SAAsBr8G,GACpB,OAAOmyF,QACLnyF,GACmB,kBAAVA,GACP,eAAgBA,GAChB,eAAgBA,EAEtB,CAlBsCs6G,CAAat6G,GAziBzC4tF,EAAK5tF,MAAQq8G,EAEbzuB,EAAK/nF,OAASw2G,EAGhBF,EAASr5G,EAAsD8qF,EACjE,GAiBF,CACF,CAiCA0uB,WAAAA,CAAY1uB,GAEV,IAEI/nF,EAFA02G,GAAW,EAYf,OARA95G,KAAKi5G,SACLI,GAAa,cAAer5G,KAAKqyF,QAAUryF,KAAKy4G,QAChDc,GAAe,cAAev5G,KAAKgtG,UAAYhtG,KAAKw4G,UAEpDx4G,KAAKs5G,QAAQnuB,GASb,SAAkB9qF,EAAO8qF,GACvB2uB,GAAW,EACX9E,GAAK30G,GACL+C,EAAS+nF,CACX,IAZA4uB,GAAW,cAAe,UAAWD,GAG9B12G,CAUT,CAwCA2xG,GAAAA,CAAInpB,EAAMT,EAAM92D,GACd2lF,GAAWpuB,GACX5rF,KAAKi5G,SAEL,MAAMH,EAAe94G,KAAK84G,aAO1B,OALKzkF,GAAwB,oBAAT82D,IAClB92D,EAAO82D,EACPA,OAAO5oF,GAGF8xB,EAAOmlF,OAASj3G,EAAW8xB,GAAQ,IAAIlG,QAAQqrF,GAWtD,SAASA,EAASlrF,EAASmpB,GAKzB,MAAM0hE,EAAWC,GAAMjuB,GACvB2tB,EAAa/D,IAAInpB,EAAMutB,GAQvB,SAAkB94G,EAAO45G,EAAY9uB,GACnC,MAAM+uB,EAEFD,GAAcruB,EAGdvrF,EACFo3C,EAAOp3C,GACEiuB,EACTA,EAAQ4rF,GAGR7lF,OAAK9xB,EAAW23G,EAAe/uB,EAEnC,GACF,CACF,CAmBAgvB,OAAAA,CAAQvuB,EAAMT,GAEZ,IAEI/nF,EAFA02G,GAAW,EAQf,OAJA95G,KAAK+0G,IAAInpB,EAAMT,GASf,SAAkB9qF,EAAOurF,GACvBopB,GAAK30G,GACL+C,EAASwoF,EACTkuB,GAAW,CACb,IAXAC,GAAW,UAAW,MAAOD,GAEtB12G,CAUT,CA+BAgqC,SAAAA,CAAUw+C,EAAMT,GACdnrF,KAAKi5G,SACL,MAAME,EAAWC,GAAMjuB,GACjB6hB,EAAWhtG,KAAKgtG,UAAYhtG,KAAKw4G,SAIvC,OAHAe,GAAe,YAAavM,GAC5BgN,GAAWpuB,GAEJohB,EAASphB,EAAMutB,EACxB,CA2DAnY,GAAAA,CAAIzjG,GACF,MAAMm7G,EAAY14G,KAAK04G,UACjBG,EAAY74G,KAAK64G,UAIvB,GAFAG,GAAe,MAAOh5G,KAAK44G,QAEb,OAAVr7G,QAA4BgF,IAAVhF,QAEf,GAAqB,oBAAVA,EAAsB,SAAAoF,EAAAzE,UAAAE,OAR5B8xF,EAAU,IAAAzzF,MAAAkG,EAAA,EAAAA,EAAA,KAAAE,EAAA,EAAAA,EAAAF,EAAAE,IAAVqtF,EAAUrtF,EAAA,GAAA3E,UAAA2E,GASpBu3G,EAAU78G,EAAO2yF,EACnB,KAAO,IAAqB,kBAAV3yF,EAOhB,MAAM,IAAI4B,UAAU,+BAAiC5B,EAAQ,KANzDd,MAAMF,QAAQgB,GAChB88G,EAAQ98G,GAER+8G,EAAU/8G,EAId,CAEA,OAAOyC,KAMP,SAAS2G,EAAIpJ,GACX,GAAqB,oBAAVA,EACT68G,EAAU78G,EAAO,QACZ,IAAqB,kBAAVA,EAShB,MAAM,IAAI4B,UAAU,+BAAiC5B,EAAQ,KAR7D,GAAId,MAAMF,QAAQgB,GAAQ,CACxB,MAAOg9G,KAAWrqB,GAC4B3yF,EAC9C68G,EAAUG,EAAQrqB,EACpB,MACEoqB,EAAU/8G,EAId,CACF,CAMA,SAAS+8G,EAAUl3G,GACjB,KAAM,YAAaA,MAAa,aAAcA,GAC5C,MAAM,IAAI5C,MACR,8KAIJ65G,EAAQj3G,EAAOo3G,SAEXp3G,EAAOsrF,WACTmqB,EAAUnqB,SAAW7wF,IAAO,EAAMg7G,EAAUnqB,SAAUtrF,EAAOsrF,UAEjE,CAMA,SAAS2rB,EAAQG,GACf,IAAI9mF,GAAS,EAEb,GAAgB,OAAZ8mF,QAAgCj4G,IAAZi4G,OAEjB,KAAI/9G,MAAMF,QAAQi+G,GAMvB,MAAM,IAAIr7G,UAAU,oCAAsCq7G,EAAU,KALpE,OAAS9mF,EAAQ8mF,EAAQp8G,QAAQ,CAE/BuI,EADc6zG,EAAQ9mF,GAExB,CAGF,CACF,CAOA,SAAS0mF,EAAUG,EAAQrqB,GACzB,IAAIx8D,GAAS,EACT+mF,GAAc,EAElB,OAAS/mF,EAAQglF,EAAUt6G,QACzB,GAAIs6G,EAAUhlF,GAAO,KAAO6mF,EAAQ,CAClCE,EAAa/mF,EACb,KACF,CAGF,IAAoB,IAAhB+mF,EACF/B,EAAU93G,KAAK,CAAC25G,KAAWrqB,SAIxB,GAAIA,EAAW9xF,OAAS,EAAG,CAC9B,IAAKs8G,KAAYn9D,GAAQ2yC,EACzB,MAAMyqB,EAAiBjC,EAAU+B,GAAY,GACzCG,GAAWD,IAAmBC,GAAWF,KAC3CA,EAAU78G,IAAO,EAAM88G,EAAgBD,IAGzChC,EAAU+B,GAAc,CAACF,EAAQG,KAAYn9D,EAC/C,CACF,CACF,EA+BK,MAAMs9D,IAAU,IAAItC,IAAYU,SASvC,SAASI,GAAaj8G,EAAMG,GAC1B,GAAqB,oBAAVA,EACT,MAAM,IAAI4B,UAAU,WAAa/B,EAAO,qBAE5C,CASA,SAASm8G,GAAen8G,EAAMG,GAC5B,GAAqB,oBAAVA,EACT,MAAM,IAAI4B,UAAU,WAAa/B,EAAO,uBAE5C,CASA,SAAS47G,GAAe57G,EAAMw7G,GAC5B,GAAIA,EACF,MAAM,IAAIp4G,MACR,gBACEpD,EACA,mHAGR,CAQA,SAAS48G,GAAWn6G,GAGlB,IAAK+6G,GAAW/6G,IAA8B,kBAAdA,EAAK0B,KACnC,MAAM,IAAIpC,UAAU,uBAAyBU,EAAO,IAGxD,CAUA,SAASk6G,GAAW38G,EAAM09G,EAAWhB,GACnC,IAAKA,EACH,MAAM,IAAIt5G,MACR,IAAMpD,EAAO,0BAA4B09G,EAAY,YAG3D,CAMA,SAAS1B,GAAM77G,GACb,OAOF,SAAyBA,GACvB,OAAOmyF,QACLnyF,GACmB,kBAAVA,GACP,YAAaA,GACb,aAAcA,EAEpB,CAdSw9G,CAAgBx9G,GAASA,EAAQ,IAAIq6G,GAAMr6G,EACpD,CCtqCA,MAIMy9G,GAAe,GAEfC,GAA2B,CAAClJ,oBAAoB,GAChDmJ,GAAe,gCAIfC,GAAe,CACnB,CAACx4B,KAAM,aAAczmE,GAAI,wCACzB,CAACymE,KAAM,qBAAsBzmE,GAAI,wCACjC,CACEymE,KAAM,YACNzmE,GAAI,qDACJ68B,GAAI,gBAEN,CACE4pC,KAAM,eACNzmE,GAAI,qDACJ68B,GAAI,mBAEN,CACE4pC,KAAM,kBACNzmE,GAAI,qDACJ68B,GAAI,sBAEN,CAAC4pC,KAAM,aAAczmE,GAAI,wCACzB,CAACymE,KAAM,sBAAuBzmE,GAAI,+BAClC,CACEymE,KAAM,mBACNzmE,GAAI,kDAEN,CAACymE,KAAM,aAAczmE,GAAI,qBACzB,CAACymE,KAAM,UAAWzmE,GAAI,kCAAmC68B,GAAI,iBAC7D,CAAC4pC,KAAM,eAAgBzmE,GAAI,wBAC3B,CAACymE,KAAM,YAAazmE,GAAI,iCAAkC68B,GAAI,cAC9D,CAAC4pC,KAAM,SAAUzmE,GAAI,4BAA6B68B,GAAI,YACtD,CAAC4pC,KAAM,YAAazmE,GAAI,qBACxB,CAACymE,KAAM,oBAAqBzmE,GAAI,oBAAqB68B,GAAI,gBACzD,CAAC4pC,KAAM,mBAAoBzmE,GAAI,oBAAqB68B,GAAI,iBAWnD,SAASqiE,GAASj+G,GACvB,MAAMk+G,EAAkBl+G,EAAQk+G,gBAC1BC,EAAen+G,EAAQm+G,aACvBztG,EAAW1Q,EAAQ0Q,UAAY,GAC/Bo8C,EAAY9sD,EAAQ8sD,UACpBqiC,EAAanvF,EAAQmvF,WACrBivB,EAAqBp+G,EAAQo+G,mBAC7BC,EAAgBr+G,EAAQq+G,eAAiBR,GACzCS,EAAgBt+G,EAAQs+G,eAAiBT,GACzCU,EAAsBv+G,EAAQu+G,oBAChC,IAAIv+G,EAAQu+G,uBAAwBT,IACpCA,GACEU,EAAWx+G,EAAQw+G,SACnBC,EAAmBz+G,EAAQy+G,iBAC3BC,EAAe1+G,EAAQ0+G,cAAgBC,GAEvCC,EAAYlB,KACf7Z,IAAIwM,IACJxM,IAAIya,GACJza,IAAI4T,GAAc8G,GAClB1a,IAAIwa,GAEDrwB,EAAO,IAAIysB,GAEO,kBAAb/pG,IACTs9E,EAAK5tF,MAAQsQ,GAef,IAAK,MAAMmuG,KAAeb,GACpBp/G,OAAOD,OAAOqB,EAAS6+G,EAAYr5B,QAGjCq5B,EAAYr5B,KAEXq5B,EAAYjjE,IACCijE,EAAYjjE,GAK1BijE,EAAY9/F,IAMpB,MAAM+/F,EAAYF,EAAUnW,MAAMza,GAElC,IAAI2pB,EAAWiH,EAAU5B,QAAQ8B,EAAW9wB,GAiB5C,OAdIlhC,IACF6qD,EAAW,CACTvzG,KAAM,UACNm2B,QAAS,MACTqvC,WAAY,CAAC9c,aAEbp8C,SACoB,SAAlBinG,EAASvzG,KAAkBuzG,EAASjnG,SAAW,CAACinG,KAKtD1E,GAAM0E,GAaN,SAAmBj1G,EAAM6zB,EAAOu3D,GAC9B,GAAkB,QAAdprF,EAAK0B,MAAkB0pF,GAA2B,kBAAVv3D,EAO1C,OANIioF,EACF1wB,EAAOp9E,SAASo/B,OAAOvZ,EAAO,GAE9Bu3D,EAAOp9E,SAAS6lB,GAAS,CAACnyB,KAAM,OAAQhE,MAAOsC,EAAKtC,OAG/Cm2B,EAGT,GAAkB,YAAd7zB,EAAK0B,KAAoB,CAE3B,IAAI1E,EAEJ,IAAKA,KAAOizF,GACV,GACE/zF,OAAOD,OAAOg0F,GAAejzF,IAC7Bd,OAAOD,OAAO+D,EAAKknE,WAAYlqE,GAC/B,CACA,MAAMU,EAAQsC,EAAKknE,WAAWlqE,GACxB0L,EAAOunF,GAAcjzF,IACd,OAAT0L,GAAiBA,EAAKyC,SAASnL,EAAK63B,YACtC73B,EAAKknE,WAAWlqE,GAAOg/G,EAAa55F,OAAO1kB,GAAS,IAAKV,EAAKgD,GAElE,CAEJ,CAEA,GAAkB,YAAdA,EAAK0B,KAAoB,CAC3B,IAAIsuD,EAASwrD,GACRA,EAAgBrwG,SAASnL,EAAK63B,WAC/B6jF,GACAA,EAAmBvwG,SAASnL,EAAK63B,SAOrC,IAJKm4B,GAAUyrD,GAAiC,kBAAV5nF,IACpCm8B,GAAUyrD,EAAaz7G,EAAM6zB,EAAOu3D,IAGlCp7B,GAAUo7B,GAA2B,kBAAVv3D,EAO7B,OANIkoF,GAAoB/7G,EAAKgO,SAC3Bo9E,EAAOp9E,SAASo/B,OAAOvZ,EAAO,KAAM7zB,EAAKgO,UAEzCo9E,EAAOp9E,SAASo/B,OAAOvZ,EAAO,GAGzBA,CAEX,CACF,IA7DOi4D,GAAampB,EAAU,CAC5BvkE,SAAQ,YACR+7C,aACAI,oBAAoB,EACpBl8C,IAAG,OACHC,KAAI,QACJk8C,UAAU,EACVC,UAAU,GAuDd,CAWO,SAASkvB,GAAoBv+G,GAIlC,MAAM2+G,EAAQ3+G,EAAM0U,QAAQ,KACtBkqG,EAAe5+G,EAAM0U,QAAQ,KAC7BmqG,EAAa7+G,EAAM0U,QAAQ,KAC3BsqF,EAAQh/F,EAAM0U,QAAQ,KAE5B,OAEEiqG,EAAQ,GAEP3f,GAAS,GAAK2f,EAAQ3f,GACtB4f,GAAgB,GAAKD,EAAQC,GAC7BC,GAAc,GAAKF,EAAQE,GAE5BlB,GAAa3yG,KAAKhL,EAAMyD,MAAM,EAAGk7G,IAE1B3+G,EAGF,EACT,CC3TA,MA4BA,GA5BuB8+G,KACrB,MAAM,OAAEC,G3O+RH,WAKL,IAAI,QAAEjgE,GAAY+D,EAAAA,WAAiBI,GAC/BW,EAAa9E,EAAQA,EAAQj+C,OAAS,GAC1C,OAAO+iD,EAAcA,EAAWvC,OAAiB,CAAC,CACpD,C2OvSqB29D,GAInB,GAFA38E,QAAQ3nB,IAAI,cAAeqkG,GAEvBA,GAAUp3C,GAASo3C,GAAkC,CACvD,MAAM,OAAEE,EAAM,UAAEC,GAAcv3C,GAASo3C,GACvC,OACErgD,EAAAA,GAAAA,MAAA,OAAKhS,UAAU,aAAYp8C,SAAA,EACzBs8C,EAAAA,GAAAA,KAACuyD,GAAa,CAAA7uG,SAAE2uG,KAChBryD,EAAAA,GAAAA,KAAA,KAAGF,UAAU,kBAAkB/qD,MAAO,CAAEy8E,SAAU,OAAQ9tE,SACvD,IAAIsQ,KAAKs+F,GAAWE,yBAI7B,CAEA,MAAe,KAAXL,QAA4B/5G,IAAX+5G,GAEjBnyD,EAAAA,GAAAA,KAAA,OAAKF,UAAU,aAAYp8C,UACzBs8C,EAAAA,GAAAA,KAACuyD,GAAa,CAAA7uG,SAAEq3D,GAAgB,MAA2Bs3C,YAK1DryD,EAAAA,GAAAA,KAAA,MAAAt8C,SAAI,kBAAmB,EChBjB,SAAS+uG,GAAQtjE,GAA0D,IAAzD,KAAEujE,EAAI,UAAEC,GAA8CxjE,EACrF,OACE6Q,EAAAA,GAAAA,KAAA,KAAGtiC,KAAMi1F,EAAW7yD,UAAU,OAAO/qD,MAAO,CAAEujB,MAAO,QAASo8D,eAAgB,OAAQj6D,MAAO,WAAY/W,UACvGouD,EAAAA,GAAAA,MAAA,OAAKhS,UAAU,YAAWp8C,SAAA,EACxBs8C,EAAAA,GAAAA,KAAA,MAAIF,UAAU,aAAYp8C,SAAEgvG,EAAK7lC,SACjC7sB,EAAAA,GAAAA,KAAA,MAAIF,UAAU,gCAA+Bp8C,SAAE,IAAIsQ,KAAK0+F,EAAKJ,WAAWE,2BAIhF,CClBe,SAASI,KAAQ,IAADC,EAC3B,MAAOC,EAAYC,IAAiB7/E,EAAAA,EAAAA,UAAS,IAMvC8/E,EAAgBphH,OAAO64D,QAAQsQ,IAAU7mB,QAAO/E,IAAA,IAAEz8C,EAAKggH,GAAKvjE,EAAA,OAC9DujE,EAAK7lC,MAAMjvE,cAAchJ,OAAOiM,SAASiyG,EAAWl1G,cAAchJ,OAAO,IAG7E,OACEk9D,EAAAA,GAAAA,MAAA,OAAKhS,UAAU,aAAYp8C,SAAA,EACzBs8C,EAAAA,GAAAA,KAACuyD,GAAa,CAAA7uG,SAAmB,QAAnBmvG,EAAE93C,GAAgB,aAAC,IAAA83C,OAAA,EAAjBA,EAAmBR,UACnCvgD,EAAAA,GAAAA,MAAA,OAAKhS,UAAU,OAAMp8C,SAAA,EACnBs8C,EAAAA,GAAAA,KAAA,MAAAt8C,SAAI,kBACJs8C,EAAAA,GAAAA,KAAA,SAAO+jB,QAAQ,SAASjkB,UAAU,aAAYp8C,SAAC,gCAC/Cs8C,EAAAA,GAAAA,KAAA,SACE5oD,KAAK,OACL0oD,UAAU,eACV/tC,GAAG,SACHm5D,YAAY,mBACZ93E,MAAO0/G,EACPvsC,SApBoB9qD,IACxBs3F,EAAct3F,EAAM1oB,OAAOK,MAAM,OAsBhC4/G,EAAcnsE,KAAI,CAAAoc,EAAc15B,KAAK,IAAjB72B,EAAKggH,GAAKzvD,EAAA,OAC7BjD,EAAAA,GAAAA,KAACyyD,GAAQ,CAAaC,KAAMA,EAAMC,UAAW,IAAIjgH,KAAlC62B,EAA2C,MAIpE,CCEA,SA7BA,WACE,OACEy2B,EAAAA,GAAAA,KAACvD,GAAa,CAAA/4C,UACZouD,EAAAA,GAAAA,MAAA,OAAKhS,UAAU,MAAKp8C,SAAA,EAClBs8C,EAAAA,GAAAA,KAAC0V,GAAM,CAACzvC,GAAG,OAAOssC,QAAQ,OAAOqD,OAAO,KAAIlyD,UAC1CouD,EAAAA,GAAAA,MAAC2E,GAAS,CAAA/yD,SAAA,EACRs8C,EAAAA,GAAAA,KAAC0V,GAAOY,MAAK,CAAC54C,KAAK,IAAGha,SAAC,iBACvBs8C,EAAAA,GAAAA,KAAC0V,GAAOc,OAAM,CAAC,gBAAc,sBAC7BxW,EAAAA,GAAAA,KAAC0V,GAAOnN,SAAQ,CAACx2C,GAAG,mBAAkBrO,UACpCs8C,EAAAA,GAAAA,KAACiY,GAAG,CAACnY,UAAU,UAASp8C,UACtBs8C,EAAAA,GAAAA,KAACiY,GAAI2B,KAAI,CAACl8C,KAAK,IAAGha,SAAC,mBAM3Bs8C,EAAAA,GAAAA,KAACyW,GAAS,CAAC3W,UAAU,OAAMp8C,UACzBouD,EAAAA,GAAAA,MAAC/V,GAAM,CAAAr4C,SAAA,EACLs8C,EAAAA,GAAAA,KAAC3E,GAAK,CAACjM,KAAK,IAAI/zC,SAAS2kD,EAAAA,GAAAA,KAAC4yD,GAAI,OAC9B5yD,EAAAA,GAAAA,KAAC3E,GAAK,CAACjM,KAAK,SAAS/zC,SAAS2kD,EAAAA,GAAAA,KAAC8a,GAAK,OACpC9a,EAAAA,GAAAA,KAAC3E,GAAK,CAACjM,KAAK,WAAW/zC,SAAS2kD,EAAAA,GAAAA,KAACkyD,GAAI,OACrClyD,EAAAA,GAAAA,KAAC3E,GAAK,CAACjM,KAAK,gBAAgB/zC,SAAS2kD,EAAAA,GAAAA,KAACkyD,GAAI,eAMtD,ECxBA,GAZwBe,IAClBA,GAAeA,aAAuBnnE,UACxC,6BAAqB1nB,MAAK+qB,IAAkD,IAAjD,OAAE+jE,EAAM,OAAEC,EAAM,OAAEC,EAAM,OAAEC,EAAM,QAAEC,GAASnkE,EACpE+jE,EAAOD,GACPE,EAAOF,GACPG,EAAOH,GACPI,EAAOJ,GACPK,EAAQL,EAAY,GAExB,ECHWz2D,EAAAA,WAAoB7/C,SAAS42G,eAAe,SACpDvyG,QACHg/C,EAAAA,GAAAA,KAAC/J,EAAAA,WAAgB,CAAAvyC,UACfs8C,EAAAA,GAAAA,KAACwzD,GAAG,OAIRC","sources":["../node_modules/extend/index.js","../node_modules/inline-style-parser/index.js","../node_modules/invariant/browser.js","../node_modules/prop-types-extra/lib/all.js","../node_modules/prop-types-extra/lib/utils/createChainableTypeChecker.js","../node_modules/prop-types/factoryWithThrowingShims.js","../node_modules/prop-types/index.js","../node_modules/prop-types/lib/ReactPropTypesSecret.js","../node_modules/react-dom/cjs/react-dom.production.min.js","../node_modules/react-dom/client.js","../node_modules/react-dom/index.js","../node_modules/react/cjs/react-jsx-runtime.production.min.js","../node_modules/react/cjs/react.production.min.js","../node_modules/react/index.js","../node_modules/react/jsx-runtime.js","../node_modules/scheduler/cjs/scheduler.production.min.js","../node_modules/scheduler/index.js","../node_modules/style-to-object/src/index.ts","../node_modules/classnames/index.js","../webpack/bootstrap","../webpack/runtime/compat get default export","../webpack/runtime/create fake namespace object","../webpack/runtime/define property getters","../webpack/runtime/ensure chunk","../webpack/runtime/get javascript chunk filename","../webpack/runtime/get mini-css chunk filename","../webpack/runtime/global","../webpack/runtime/hasOwnProperty shorthand","../webpack/runtime/load script","../webpack/runtime/make namespace object","../webpack/runtime/publicPath","../webpack/runtime/jsonp chunk loading","../node_modules/@remix-run/router/history.ts","../node_modules/@remix-run/router/utils.ts","../node_modules/@remix-run/router/router.ts","../node_modules/react-router/lib/context.ts","../node_modules/react-router/lib/hooks.tsx","../node_modules/react-router/lib/deprecations.ts","../node_modules/react-router/lib/components.tsx","../node_modules/react-router-dom/dom.ts","../node_modules/react-router-dom/index.tsx","../node_modules/@restart/ui/esm/SelectableContext.js","../node_modules/@babel/runtime/helpers/esm/extends.js","../node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js","../node_modules/uncontrollable/lib/esm/utils.js","../node_modules/uncontrollable/lib/esm/hook.js","../node_modules/react-lifecycles-compat/react-lifecycles-compat.es.js","../node_modules/react-bootstrap/esm/ThemeProvider.js","../node_modules/react-bootstrap/esm/NavbarBrand.js","../node_modules/dom-helpers/esm/ownerDocument.js","../node_modules/dom-helpers/esm/getComputedStyle.js","../node_modules/dom-helpers/esm/ownerWindow.js","../node_modules/dom-helpers/esm/hyphenate.js","../node_modules/dom-helpers/esm/hyphenateStyle.js","../node_modules/dom-helpers/esm/isTransform.js","../node_modules/dom-helpers/esm/css.js","../node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js","../node_modules/react-transition-group/esm/config.js","../node_modules/react-transition-group/esm/TransitionGroupContext.js","../node_modules/react-transition-group/esm/utils/reflow.js","../node_modules/react-transition-group/esm/Transition.js","../node_modules/@babel/runtime/helpers/esm/inheritsLoose.js","../node_modules/dom-helpers/esm/canUseDOM.js","../node_modules/dom-helpers/esm/addEventListener.js","../node_modules/dom-helpers/esm/removeEventListener.js","../node_modules/dom-helpers/esm/listen.js","../node_modules/dom-helpers/esm/transitionEnd.js","../node_modules/dom-helpers/esm/triggerEvent.js","../node_modules/react-bootstrap/esm/transitionEndListener.js","../node_modules/react-bootstrap/esm/createChainedFunction.js","../node_modules/react-bootstrap/esm/triggerBrowserReflow.js","../node_modules/@restart/hooks/esm/useMergedRefs.js","../node_modules/react-bootstrap/esm/TransitionWrapper.js","../node_modules/react-bootstrap/esm/safeFindDOMNode.js","../node_modules/react-bootstrap/esm/Collapse.js","../node_modules/react-bootstrap/esm/NavbarContext.js","../node_modules/react-bootstrap/esm/NavbarCollapse.js","../node_modules/@restart/hooks/esm/useCommittedRef.js","../node_modules/@restart/hooks/esm/useEventCallback.js","../node_modules/react-bootstrap/esm/NavbarToggle.js","../node_modules/@restart/hooks/esm/useIsomorphicEffect.js","../node_modules/@restart/hooks/esm/useMediaQuery.js","../node_modules/@restart/hooks/esm/useBreakpoint.js","../node_modules/dom-helpers/esm/activeElement.js","../node_modules/dom-helpers/esm/contains.js","../node_modules/@restart/hooks/esm/useWillUnmount.js","../node_modules/@restart/hooks/esm/useUpdatedRef.js","../node_modules/@restart/ui/esm/DataKey.js","../node_modules/@restart/ui/esm/ModalManager.js","../node_modules/@restart/ui/esm/getScrollbarWidth.js","../node_modules/@restart/ui/esm/useWindow.js","../node_modules/@restart/ui/esm/useWaitForDOMRef.js","../node_modules/@restart/ui/esm/NoopTransition.js","../node_modules/@restart/ui/esm/utils.js","../node_modules/@restart/ui/esm/useRTGTransitionProps.js","../node_modules/@restart/ui/esm/RTGTransition.js","../node_modules/@restart/ui/esm/ImperativeTransition.js","../node_modules/@restart/ui/esm/Modal.js","../node_modules/@restart/hooks/esm/useMounted.js","../node_modules/@restart/hooks/esm/usePrevious.js","../node_modules/react-bootstrap/esm/Fade.js","../node_modules/react-bootstrap/esm/OffcanvasBody.js","../node_modules/react-bootstrap/esm/OffcanvasToggling.js","../node_modules/react-bootstrap/esm/ModalContext.js","../node_modules/react-bootstrap/esm/CloseButton.js","../node_modules/react-bootstrap/esm/AbstractModalHeader.js","../node_modules/react-bootstrap/esm/OffcanvasHeader.js","../node_modules/react-bootstrap/esm/divWithClassName.js","../node_modules/react-bootstrap/esm/OffcanvasTitle.js","../node_modules/dom-helpers/esm/querySelectorAll.js","../node_modules/dom-helpers/esm/removeClass.js","../node_modules/react-bootstrap/esm/BootstrapModalManager.js","../node_modules/dom-helpers/esm/addClass.js","../node_modules/dom-helpers/esm/hasClass.js","../node_modules/react-bootstrap/esm/Offcanvas.js","../node_modules/react-bootstrap/esm/NavbarOffcanvas.js","../node_modules/react-bootstrap/esm/NavbarText.js","../node_modules/react-bootstrap/esm/Navbar.js","../node_modules/react-bootstrap/esm/Container.js","../node_modules/@restart/ui/esm/NavContext.js","../node_modules/@restart/ui/esm/TabContext.js","../node_modules/@restart/ui/esm/Button.js","../node_modules/@restart/ui/esm/NavItem.js","../node_modules/@restart/ui/esm/Nav.js","../node_modules/@restart/hooks/esm/useForceUpdate.js","../node_modules/react-bootstrap/esm/CardHeaderContext.js","../node_modules/react-bootstrap/esm/NavItem.js","../node_modules/@restart/hooks/esm/useResizeObserver.js","../node_modules/@restart/ui/esm/Anchor.js","../node_modules/react-bootstrap/esm/NavLink.js","../node_modules/react-bootstrap/esm/Nav.js","../node_modules/react-bootstrap/esm/CardBody.js","../node_modules/react-bootstrap/esm/CardFooter.js","../node_modules/react-bootstrap/esm/CardHeader.js","../node_modules/react-bootstrap/esm/CardImg.js","../node_modules/react-bootstrap/esm/CardImgOverlay.js","../node_modules/react-bootstrap/esm/CardLink.js","../node_modules/react-bootstrap/esm/CardSubtitle.js","../node_modules/react-bootstrap/esm/CardText.js","../node_modules/react-bootstrap/esm/CardTitle.js","../node_modules/react-bootstrap/esm/Card.js","About.tsx","postsDist.tsx","../node_modules/estree-util-is-identifier-name/lib/index.js","../node_modules/hast-util-whitespace/lib/index.js","../node_modules/property-information/lib/util/schema.js","../node_modules/property-information/lib/util/merge.js","../node_modules/property-information/lib/normalize.js","../node_modules/property-information/lib/util/info.js","../node_modules/property-information/lib/util/types.js","../node_modules/property-information/lib/util/defined-info.js","../node_modules/property-information/lib/util/create.js","../node_modules/property-information/lib/xlink.js","../node_modules/property-information/lib/xml.js","../node_modules/property-information/lib/util/case-sensitive-transform.js","../node_modules/property-information/lib/util/case-insensitive-transform.js","../node_modules/property-information/lib/xmlns.js","../node_modules/property-information/lib/aria.js","../node_modules/property-information/lib/html.js","../node_modules/property-information/lib/svg.js","../node_modules/property-information/index.js","../node_modules/property-information/lib/find.js","../node_modules/property-information/lib/hast-to-react.js","../node_modules/style-to-object/esm/index.mjs","../node_modules/unist-util-position/lib/index.js","../node_modules/unist-util-stringify-position/lib/index.js","../node_modules/vfile-message/lib/index.js","../node_modules/hast-util-to-jsx-runtime/lib/index.js","../node_modules/comma-separated-tokens/index.js","../node_modules/space-separated-tokens/index.js","../node_modules/html-url-attributes/lib/index.js","../node_modules/mdast-util-to-string/lib/index.js","../node_modules/micromark-util-chunked/index.js","../node_modules/micromark-util-subtokenize/lib/splice-buffer.js","../node_modules/micromark-util-subtokenize/index.js","../node_modules/micromark-util-combine-extensions/index.js","../node_modules/micromark-util-character/index.js","../node_modules/micromark-factory-space/index.js","../node_modules/micromark/lib/initialize/content.js","../node_modules/micromark/lib/initialize/document.js","../node_modules/micromark-core-commonmark/lib/blank-line.js","../node_modules/micromark-core-commonmark/lib/content.js","../node_modules/micromark/lib/initialize/flow.js","../node_modules/micromark/lib/initialize/text.js","../node_modules/micromark-core-commonmark/lib/thematic-break.js","../node_modules/micromark-core-commonmark/lib/list.js","../node_modules/micromark-core-commonmark/lib/block-quote.js","../node_modules/micromark-factory-destination/index.js","../node_modules/micromark-factory-label/index.js","../node_modules/micromark-factory-title/index.js","../node_modules/micromark-factory-whitespace/index.js","../node_modules/micromark-util-normalize-identifier/index.js","../node_modules/micromark-core-commonmark/lib/definition.js","../node_modules/micromark-core-commonmark/lib/code-indented.js","../node_modules/micromark-core-commonmark/lib/heading-atx.js","../node_modules/micromark-core-commonmark/lib/setext-underline.js","../node_modules/micromark-util-html-tag-name/index.js","../node_modules/micromark-core-commonmark/lib/html-flow.js","../node_modules/micromark-core-commonmark/lib/code-fenced.js","../node_modules/decode-named-character-reference/index.dom.js","../node_modules/micromark-core-commonmark/lib/character-reference.js","../node_modules/micromark-core-commonmark/lib/character-escape.js","../node_modules/micromark-core-commonmark/lib/line-ending.js","../node_modules/micromark-util-resolve-all/index.js","../node_modules/micromark-core-commonmark/lib/label-end.js","../node_modules/micromark-core-commonmark/lib/label-start-image.js","../node_modules/micromark-util-classify-character/index.js","../node_modules/micromark-core-commonmark/lib/attention.js","../node_modules/micromark-core-commonmark/lib/autolink.js","../node_modules/micromark-core-commonmark/lib/html-text.js","../node_modules/micromark-core-commonmark/lib/label-start-link.js","../node_modules/micromark-core-commonmark/lib/hard-break-escape.js","../node_modules/micromark-core-commonmark/lib/code-text.js","../node_modules/micromark/lib/constructs.js","../node_modules/micromark/lib/create-tokenizer.js","../node_modules/micromark/lib/parse.js","../node_modules/micromark/lib/preprocess.js","../node_modules/micromark-util-decode-numeric-character-reference/index.js","../node_modules/micromark-util-decode-string/index.js","../node_modules/mdast-util-from-markdown/lib/index.js","../node_modules/micromark/lib/postprocess.js","../node_modules/remark-parse/lib/index.js","../node_modules/@ungap/structured-clone/esm/types.js","../node_modules/@ungap/structured-clone/esm/deserialize.js","../node_modules/@ungap/structured-clone/esm/serialize.js","../node_modules/@ungap/structured-clone/esm/index.js","../node_modules/micromark-util-sanitize-uri/index.js","../node_modules/mdast-util-to-hast/lib/footer.js","../node_modules/unist-util-is/lib/index.js","../node_modules/unist-util-visit-parents/lib/index.js","../node_modules/unist-util-visit/lib/index.js","../node_modules/mdast-util-to-hast/lib/revert.js","../node_modules/mdast-util-to-hast/lib/handlers/list-item.js","../node_modules/trim-lines/index.js","../node_modules/mdast-util-to-hast/lib/handlers/index.js","../node_modules/mdast-util-to-hast/lib/handlers/blockquote.js","../node_modules/mdast-util-to-hast/lib/handlers/break.js","../node_modules/mdast-util-to-hast/lib/handlers/code.js","../node_modules/mdast-util-to-hast/lib/handlers/delete.js","../node_modules/mdast-util-to-hast/lib/handlers/emphasis.js","../node_modules/mdast-util-to-hast/lib/handlers/footnote-reference.js","../node_modules/mdast-util-to-hast/lib/handlers/heading.js","../node_modules/mdast-util-to-hast/lib/handlers/html.js","../node_modules/mdast-util-to-hast/lib/handlers/image-reference.js","../node_modules/mdast-util-to-hast/lib/handlers/image.js","../node_modules/mdast-util-to-hast/lib/handlers/inline-code.js","../node_modules/mdast-util-to-hast/lib/handlers/link-reference.js","../node_modules/mdast-util-to-hast/lib/handlers/link.js","../node_modules/mdast-util-to-hast/lib/handlers/list.js","../node_modules/mdast-util-to-hast/lib/handlers/paragraph.js","../node_modules/mdast-util-to-hast/lib/handlers/root.js","../node_modules/mdast-util-to-hast/lib/handlers/strong.js","../node_modules/mdast-util-to-hast/lib/handlers/table.js","../node_modules/mdast-util-to-hast/lib/handlers/table-cell.js","../node_modules/mdast-util-to-hast/lib/handlers/table-row.js","../node_modules/mdast-util-to-hast/lib/handlers/text.js","../node_modules/mdast-util-to-hast/lib/handlers/thematic-break.js","../node_modules/mdast-util-to-hast/lib/state.js","../node_modules/mdast-util-to-hast/lib/index.js","../node_modules/remark-rehype/lib/index.js","../node_modules/bail/index.js","../node_modules/unified/node_modules/is-plain-obj/index.js","../node_modules/trough/lib/index.js","../node_modules/vfile/lib/minpath.browser.js","../node_modules/vfile/lib/minproc.browser.js","../node_modules/vfile/lib/minurl.shared.js","../node_modules/vfile/lib/minurl.browser.js","../node_modules/vfile/lib/index.js","../node_modules/unified/lib/callable-instance.js","../node_modules/unified/lib/index.js","../node_modules/react-markdown/lib/index.js","Post.tsx","components/PostCard.tsx","components/Home.tsx","App.tsx","reportWebVitals.js","index.tsx"],"sourcesContent":["'use strict';\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar toStr = Object.prototype.toString;\nvar defineProperty = Object.defineProperty;\nvar gOPD = Object.getOwnPropertyDescriptor;\n\nvar isArray = function isArray(arr) {\n\tif (typeof Array.isArray === 'function') {\n\t\treturn Array.isArray(arr);\n\t}\n\n\treturn toStr.call(arr) === '[object Array]';\n};\n\nvar isPlainObject = function isPlainObject(obj) {\n\tif (!obj || toStr.call(obj) !== '[object Object]') {\n\t\treturn false;\n\t}\n\n\tvar hasOwnConstructor = hasOwn.call(obj, 'constructor');\n\tvar hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');\n\t// Not own constructor property must be Object\n\tif (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {\n\t\treturn false;\n\t}\n\n\t// Own properties are enumerated firstly, so to speed up,\n\t// if last one is own, then all properties are own.\n\tvar key;\n\tfor (key in obj) { /**/ }\n\n\treturn typeof key === 'undefined' || hasOwn.call(obj, key);\n};\n\n// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target\nvar setProperty = function setProperty(target, options) {\n\tif (defineProperty && options.name === '__proto__') {\n\t\tdefineProperty(target, options.name, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: true,\n\t\t\tvalue: options.newValue,\n\t\t\twritable: true\n\t\t});\n\t} else {\n\t\ttarget[options.name] = options.newValue;\n\t}\n};\n\n// Return undefined instead of __proto__ if '__proto__' is not an own property\nvar getProperty = function getProperty(obj, name) {\n\tif (name === '__proto__') {\n\t\tif (!hasOwn.call(obj, name)) {\n\t\t\treturn void 0;\n\t\t} else if (gOPD) {\n\t\t\t// In early versions of node, obj['__proto__'] is buggy when obj has\n\t\t\t// __proto__ as an own property. Object.getOwnPropertyDescriptor() works.\n\t\t\treturn gOPD(obj, name).value;\n\t\t}\n\t}\n\n\treturn obj[name];\n};\n\nmodule.exports = function extend() {\n\tvar options, name, src, copy, copyIsArray, clone;\n\tvar target = arguments[0];\n\tvar i = 1;\n\tvar length = arguments.length;\n\tvar deep = false;\n\n\t// Handle a deep copy situation\n\tif (typeof target === 'boolean') {\n\t\tdeep = target;\n\t\ttarget = arguments[1] || {};\n\t\t// skip the boolean and the target\n\t\ti = 2;\n\t}\n\tif (target == null || (typeof target !== 'object' && typeof target !== 'function')) {\n\t\ttarget = {};\n\t}\n\n\tfor (; i < length; ++i) {\n\t\toptions = arguments[i];\n\t\t// Only deal with non-null/undefined values\n\t\tif (options != null) {\n\t\t\t// Extend the base object\n\t\t\tfor (name in options) {\n\t\t\t\tsrc = getProperty(target, name);\n\t\t\t\tcopy = getProperty(options, name);\n\n\t\t\t\t// Prevent never-ending loop\n\t\t\t\tif (target !== copy) {\n\t\t\t\t\t// Recurse if we're merging plain objects or arrays\n\t\t\t\t\tif (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {\n\t\t\t\t\t\tif (copyIsArray) {\n\t\t\t\t\t\t\tcopyIsArray = false;\n\t\t\t\t\t\t\tclone = src && isArray(src) ? src : [];\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tclone = src && isPlainObject(src) ? src : {};\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Never move original objects, clone them\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: extend(deep, clone, copy) });\n\n\t\t\t\t\t// Don't bring in undefined values\n\t\t\t\t\t} else if (typeof copy !== 'undefined') {\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: copy });\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Return the modified object\n\treturn target;\n};\n","// http://www.w3.org/TR/CSS21/grammar.html\n// https://github.com/visionmedia/css-parse/pull/49#issuecomment-30088027\nvar COMMENT_REGEX = /\\/\\*[^*]*\\*+([^/*][^*]*\\*+)*\\//g;\n\nvar NEWLINE_REGEX = /\\n/g;\nvar WHITESPACE_REGEX = /^\\s*/;\n\n// declaration\nvar PROPERTY_REGEX = /^(\\*?[-#/*\\\\\\w]+(\\[[0-9a-z_-]+\\])?)\\s*/;\nvar COLON_REGEX = /^:\\s*/;\nvar VALUE_REGEX = /^((?:'(?:\\\\'|.)*?'|\"(?:\\\\\"|.)*?\"|\\([^)]*?\\)|[^};])+)/;\nvar SEMICOLON_REGEX = /^[;\\s]*/;\n\n// https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String/Trim#Polyfill\nvar TRIM_REGEX = /^\\s+|\\s+$/g;\n\n// strings\nvar NEWLINE = '\\n';\nvar FORWARD_SLASH = '/';\nvar ASTERISK = '*';\nvar EMPTY_STRING = '';\n\n// types\nvar TYPE_COMMENT = 'comment';\nvar TYPE_DECLARATION = 'declaration';\n\n/**\n * @param {String} style\n * @param {Object} [options]\n * @return {Object[]}\n * @throws {TypeError}\n * @throws {Error}\n */\nmodule.exports = function (style, options) {\n  if (typeof style !== 'string') {\n    throw new TypeError('First argument must be a string');\n  }\n\n  if (!style) return [];\n\n  options = options || {};\n\n  /**\n   * Positional.\n   */\n  var lineno = 1;\n  var column = 1;\n\n  /**\n   * Update lineno and column based on `str`.\n   *\n   * @param {String} str\n   */\n  function updatePosition(str) {\n    var lines = str.match(NEWLINE_REGEX);\n    if (lines) lineno += lines.length;\n    var i = str.lastIndexOf(NEWLINE);\n    column = ~i ? str.length - i : column + str.length;\n  }\n\n  /**\n   * Mark position and patch `node.position`.\n   *\n   * @return {Function}\n   */\n  function position() {\n    var start = { line: lineno, column: column };\n    return function (node) {\n      node.position = new Position(start);\n      whitespace();\n      return node;\n    };\n  }\n\n  /**\n   * Store position information for a node.\n   *\n   * @constructor\n   * @property {Object} start\n   * @property {Object} end\n   * @property {undefined|String} source\n   */\n  function Position(start) {\n    this.start = start;\n    this.end = { line: lineno, column: column };\n    this.source = options.source;\n  }\n\n  /**\n   * Non-enumerable source string.\n   */\n  Position.prototype.content = style;\n\n  var errorsList = [];\n\n  /**\n   * Error `msg`.\n   *\n   * @param {String} msg\n   * @throws {Error}\n   */\n  function error(msg) {\n    var err = new Error(\n      options.source + ':' + lineno + ':' + column + ': ' + msg\n    );\n    err.reason = msg;\n    err.filename = options.source;\n    err.line = lineno;\n    err.column = column;\n    err.source = style;\n\n    if (options.silent) {\n      errorsList.push(err);\n    } else {\n      throw err;\n    }\n  }\n\n  /**\n   * Match `re` and return captures.\n   *\n   * @param {RegExp} re\n   * @return {undefined|Array}\n   */\n  function match(re) {\n    var m = re.exec(style);\n    if (!m) return;\n    var str = m[0];\n    updatePosition(str);\n    style = style.slice(str.length);\n    return m;\n  }\n\n  /**\n   * Parse whitespace.\n   */\n  function whitespace() {\n    match(WHITESPACE_REGEX);\n  }\n\n  /**\n   * Parse comments.\n   *\n   * @param {Object[]} [rules]\n   * @return {Object[]}\n   */\n  function comments(rules) {\n    var c;\n    rules = rules || [];\n    while ((c = comment())) {\n      if (c !== false) {\n        rules.push(c);\n      }\n    }\n    return rules;\n  }\n\n  /**\n   * Parse comment.\n   *\n   * @return {Object}\n   * @throws {Error}\n   */\n  function comment() {\n    var pos = position();\n    if (FORWARD_SLASH != style.charAt(0) || ASTERISK != style.charAt(1)) return;\n\n    var i = 2;\n    while (\n      EMPTY_STRING != style.charAt(i) &&\n      (ASTERISK != style.charAt(i) || FORWARD_SLASH != style.charAt(i + 1))\n    ) {\n      ++i;\n    }\n    i += 2;\n\n    if (EMPTY_STRING === style.charAt(i - 1)) {\n      return error('End of comment missing');\n    }\n\n    var str = style.slice(2, i - 2);\n    column += 2;\n    updatePosition(str);\n    style = style.slice(i);\n    column += 2;\n\n    return pos({\n      type: TYPE_COMMENT,\n      comment: str\n    });\n  }\n\n  /**\n   * Parse declaration.\n   *\n   * @return {Object}\n   * @throws {Error}\n   */\n  function declaration() {\n    var pos = position();\n\n    // prop\n    var prop = match(PROPERTY_REGEX);\n    if (!prop) return;\n    comment();\n\n    // :\n    if (!match(COLON_REGEX)) return error(\"property missing ':'\");\n\n    // val\n    var val = match(VALUE_REGEX);\n\n    var ret = pos({\n      type: TYPE_DECLARATION,\n      property: trim(prop[0].replace(COMMENT_REGEX, EMPTY_STRING)),\n      value: val\n        ? trim(val[0].replace(COMMENT_REGEX, EMPTY_STRING))\n        : EMPTY_STRING\n    });\n\n    // ;\n    match(SEMICOLON_REGEX);\n\n    return ret;\n  }\n\n  /**\n   * Parse declarations.\n   *\n   * @return {Object[]}\n   */\n  function declarations() {\n    var decls = [];\n\n    comments(decls);\n\n    // declarations\n    var decl;\n    while ((decl = declaration())) {\n      if (decl !== false) {\n        decls.push(decl);\n        comments(decls);\n      }\n    }\n\n    return decls;\n  }\n\n  whitespace();\n  return declarations();\n};\n\n/**\n * Trim `str`.\n *\n * @param {String} str\n * @return {String}\n */\nfunction trim(str) {\n  return str ? str.replace(TRIM_REGEX, EMPTY_STRING) : EMPTY_STRING;\n}\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\n/**\n * Use invariant() to assert state which your program assumes to be true.\n *\n * Provide sprintf-style format (only %s is supported) and arguments\n * to provide information about what broke and what you were\n * expecting.\n *\n * The invariant message will be stripped in production, but the invariant\n * will remain to ensure logic does not differ in production.\n */\n\nvar invariant = function(condition, format, a, b, c, d, e, f) {\n  if (process.env.NODE_ENV !== 'production') {\n    if (format === undefined) {\n      throw new Error('invariant requires an error message argument');\n    }\n  }\n\n  if (!condition) {\n    var error;\n    if (format === undefined) {\n      error = new Error(\n        'Minified exception occurred; use the non-minified dev environment ' +\n        'for the full error message and additional helpful warnings.'\n      );\n    } else {\n      var args = [a, b, c, d, e, f];\n      var argIndex = 0;\n      error = new Error(\n        format.replace(/%s/g, function() { return args[argIndex++]; })\n      );\n      error.name = 'Invariant Violation';\n    }\n\n    error.framesToPop = 1; // we don't care about invariant's own frame\n    throw error;\n  }\n};\n\nmodule.exports = invariant;\n","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = all;\n\nvar _createChainableTypeChecker = require('./utils/createChainableTypeChecker');\n\nvar _createChainableTypeChecker2 = _interopRequireDefault(_createChainableTypeChecker);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction all() {\n  for (var _len = arguments.length, validators = Array(_len), _key = 0; _key < _len; _key++) {\n    validators[_key] = arguments[_key];\n  }\n\n  function allPropTypes() {\n    for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n      args[_key2] = arguments[_key2];\n    }\n\n    var error = null;\n\n    validators.forEach(function (validator) {\n      if (error != null) {\n        return;\n      }\n\n      var result = validator.apply(undefined, args);\n      if (result != null) {\n        error = result;\n      }\n    });\n\n    return error;\n  }\n\n  return (0, _createChainableTypeChecker2.default)(allPropTypes);\n}\nmodule.exports = exports['default'];","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = createChainableTypeChecker;\n/**\n * Copyright 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n */\n\n// Mostly taken from ReactPropTypes.\n\nfunction createChainableTypeChecker(validate) {\n  function checkType(isRequired, props, propName, componentName, location, propFullName) {\n    var componentNameSafe = componentName || '<<anonymous>>';\n    var propFullNameSafe = propFullName || propName;\n\n    if (props[propName] == null) {\n      if (isRequired) {\n        return new Error('Required ' + location + ' `' + propFullNameSafe + '` was not specified ' + ('in `' + componentNameSafe + '`.'));\n      }\n\n      return null;\n    }\n\n    for (var _len = arguments.length, args = Array(_len > 6 ? _len - 6 : 0), _key = 6; _key < _len; _key++) {\n      args[_key - 6] = arguments[_key];\n    }\n\n    return validate.apply(undefined, [props, propName, componentNameSafe, location, propFullNameSafe].concat(args));\n  }\n\n  var chainedCheckType = checkType.bind(null, false);\n  chainedCheckType.isRequired = checkType.bind(null, true);\n\n  return chainedCheckType;\n}\nmodule.exports = exports['default'];","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\n\nfunction emptyFunction() {}\nfunction emptyFunctionWithReset() {}\nemptyFunctionWithReset.resetWarningCache = emptyFunction;\n\nmodule.exports = function() {\n  function shim(props, propName, componentName, location, propFullName, secret) {\n    if (secret === ReactPropTypesSecret) {\n      // It is still safe when called from React.\n      return;\n    }\n    var err = new Error(\n      'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +\n      'Use PropTypes.checkPropTypes() to call them. ' +\n      'Read more at http://fb.me/use-check-prop-types'\n    );\n    err.name = 'Invariant Violation';\n    throw err;\n  };\n  shim.isRequired = shim;\n  function getShim() {\n    return shim;\n  };\n  // Important!\n  // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.\n  var ReactPropTypes = {\n    array: shim,\n    bigint: shim,\n    bool: shim,\n    func: shim,\n    number: shim,\n    object: shim,\n    string: shim,\n    symbol: shim,\n\n    any: shim,\n    arrayOf: getShim,\n    element: shim,\n    elementType: shim,\n    instanceOf: getShim,\n    node: shim,\n    objectOf: getShim,\n    oneOf: getShim,\n    oneOfType: getShim,\n    shape: getShim,\n    exact: getShim,\n\n    checkPropTypes: emptyFunctionWithReset,\n    resetWarningCache: emptyFunction\n  };\n\n  ReactPropTypes.PropTypes = ReactPropTypes;\n\n  return ReactPropTypes;\n};\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nif (process.env.NODE_ENV !== 'production') {\n  var ReactIs = require('react-is');\n\n  // By explicitly using `prop-types` you are opting into new development behavior.\n  // http://fb.me/prop-types-in-prod\n  var throwOnDirectAccess = true;\n  module.exports = require('./factoryWithTypeCheckers')(ReactIs.isElement, throwOnDirectAccess);\n} else {\n  // By explicitly using `prop-types` you are opting into new production behavior.\n  // http://fb.me/prop-types-in-prod\n  module.exports = require('./factoryWithThrowingShims')();\n}\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';\n\nmodule.exports = ReactPropTypesSecret;\n","/**\n * @license React\n * react-dom.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n/*\n Modernizr 3.0.0pre (Custom Build) | MIT\n*/\n'use strict';var aa=require(\"react\"),ca=require(\"scheduler\");function p(a){for(var b=\"https://reactjs.org/docs/error-decoder.html?invariant=\"+a,c=1;c<arguments.length;c++)b+=\"&args[]=\"+encodeURIComponent(arguments[c]);return\"Minified React error #\"+a+\"; visit \"+b+\" for the full message or use the non-minified dev environment for full errors and additional helpful warnings.\"}var da=new Set,ea={};function fa(a,b){ha(a,b);ha(a+\"Capture\",b)}\nfunction ha(a,b){ea[a]=b;for(a=0;a<b.length;a++)da.add(b[a])}\nvar ia=!(\"undefined\"===typeof window||\"undefined\"===typeof window.document||\"undefined\"===typeof window.document.createElement),ja=Object.prototype.hasOwnProperty,ka=/^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$/,la=\n{},ma={};function oa(a){if(ja.call(ma,a))return!0;if(ja.call(la,a))return!1;if(ka.test(a))return ma[a]=!0;la[a]=!0;return!1}function pa(a,b,c,d){if(null!==c&&0===c.type)return!1;switch(typeof b){case \"function\":case \"symbol\":return!0;case \"boolean\":if(d)return!1;if(null!==c)return!c.acceptsBooleans;a=a.toLowerCase().slice(0,5);return\"data-\"!==a&&\"aria-\"!==a;default:return!1}}\nfunction qa(a,b,c,d){if(null===b||\"undefined\"===typeof b||pa(a,b,c,d))return!0;if(d)return!1;if(null!==c)switch(c.type){case 3:return!b;case 4:return!1===b;case 5:return isNaN(b);case 6:return isNaN(b)||1>b}return!1}function v(a,b,c,d,e,f,g){this.acceptsBooleans=2===b||3===b||4===b;this.attributeName=d;this.attributeNamespace=e;this.mustUseProperty=c;this.propertyName=a;this.type=b;this.sanitizeURL=f;this.removeEmptyString=g}var z={};\n\"children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style\".split(\" \").forEach(function(a){z[a]=new v(a,0,!1,a,null,!1,!1)});[[\"acceptCharset\",\"accept-charset\"],[\"className\",\"class\"],[\"htmlFor\",\"for\"],[\"httpEquiv\",\"http-equiv\"]].forEach(function(a){var b=a[0];z[b]=new v(b,1,!1,a[1],null,!1,!1)});[\"contentEditable\",\"draggable\",\"spellCheck\",\"value\"].forEach(function(a){z[a]=new v(a,2,!1,a.toLowerCase(),null,!1,!1)});\n[\"autoReverse\",\"externalResourcesRequired\",\"focusable\",\"preserveAlpha\"].forEach(function(a){z[a]=new v(a,2,!1,a,null,!1,!1)});\"allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope\".split(\" \").forEach(function(a){z[a]=new v(a,3,!1,a.toLowerCase(),null,!1,!1)});\n[\"checked\",\"multiple\",\"muted\",\"selected\"].forEach(function(a){z[a]=new v(a,3,!0,a,null,!1,!1)});[\"capture\",\"download\"].forEach(function(a){z[a]=new v(a,4,!1,a,null,!1,!1)});[\"cols\",\"rows\",\"size\",\"span\"].forEach(function(a){z[a]=new v(a,6,!1,a,null,!1,!1)});[\"rowSpan\",\"start\"].forEach(function(a){z[a]=new v(a,5,!1,a.toLowerCase(),null,!1,!1)});var ra=/[\\-:]([a-z])/g;function sa(a){return a[1].toUpperCase()}\n\"accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height\".split(\" \").forEach(function(a){var b=a.replace(ra,\nsa);z[b]=new v(b,1,!1,a,null,!1,!1)});\"xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type\".split(\" \").forEach(function(a){var b=a.replace(ra,sa);z[b]=new v(b,1,!1,a,\"http://www.w3.org/1999/xlink\",!1,!1)});[\"xml:base\",\"xml:lang\",\"xml:space\"].forEach(function(a){var b=a.replace(ra,sa);z[b]=new v(b,1,!1,a,\"http://www.w3.org/XML/1998/namespace\",!1,!1)});[\"tabIndex\",\"crossOrigin\"].forEach(function(a){z[a]=new v(a,1,!1,a.toLowerCase(),null,!1,!1)});\nz.xlinkHref=new v(\"xlinkHref\",1,!1,\"xlink:href\",\"http://www.w3.org/1999/xlink\",!0,!1);[\"src\",\"href\",\"action\",\"formAction\"].forEach(function(a){z[a]=new v(a,1,!1,a.toLowerCase(),null,!0,!0)});\nfunction ta(a,b,c,d){var e=z.hasOwnProperty(b)?z[b]:null;if(null!==e?0!==e.type:d||!(2<b.length)||\"o\"!==b[0]&&\"O\"!==b[0]||\"n\"!==b[1]&&\"N\"!==b[1])qa(b,c,e,d)&&(c=null),d||null===e?oa(b)&&(null===c?a.removeAttribute(b):a.setAttribute(b,\"\"+c)):e.mustUseProperty?a[e.propertyName]=null===c?3===e.type?!1:\"\":c:(b=e.attributeName,d=e.attributeNamespace,null===c?a.removeAttribute(b):(e=e.type,c=3===e||4===e&&!0===c?\"\":\"\"+c,d?a.setAttributeNS(d,b,c):a.setAttribute(b,c)))}\nvar ua=aa.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,va=Symbol.for(\"react.element\"),wa=Symbol.for(\"react.portal\"),ya=Symbol.for(\"react.fragment\"),za=Symbol.for(\"react.strict_mode\"),Aa=Symbol.for(\"react.profiler\"),Ba=Symbol.for(\"react.provider\"),Ca=Symbol.for(\"react.context\"),Da=Symbol.for(\"react.forward_ref\"),Ea=Symbol.for(\"react.suspense\"),Fa=Symbol.for(\"react.suspense_list\"),Ga=Symbol.for(\"react.memo\"),Ha=Symbol.for(\"react.lazy\");Symbol.for(\"react.scope\");Symbol.for(\"react.debug_trace_mode\");\nvar Ia=Symbol.for(\"react.offscreen\");Symbol.for(\"react.legacy_hidden\");Symbol.for(\"react.cache\");Symbol.for(\"react.tracing_marker\");var Ja=Symbol.iterator;function Ka(a){if(null===a||\"object\"!==typeof a)return null;a=Ja&&a[Ja]||a[\"@@iterator\"];return\"function\"===typeof a?a:null}var A=Object.assign,La;function Ma(a){if(void 0===La)try{throw Error();}catch(c){var b=c.stack.trim().match(/\\n( *(at )?)/);La=b&&b[1]||\"\"}return\"\\n\"+La+a}var Na=!1;\nfunction Oa(a,b){if(!a||Na)return\"\";Na=!0;var c=Error.prepareStackTrace;Error.prepareStackTrace=void 0;try{if(b)if(b=function(){throw Error();},Object.defineProperty(b.prototype,\"props\",{set:function(){throw Error();}}),\"object\"===typeof Reflect&&Reflect.construct){try{Reflect.construct(b,[])}catch(l){var d=l}Reflect.construct(a,[],b)}else{try{b.call()}catch(l){d=l}a.call(b.prototype)}else{try{throw Error();}catch(l){d=l}a()}}catch(l){if(l&&d&&\"string\"===typeof l.stack){for(var e=l.stack.split(\"\\n\"),\nf=d.stack.split(\"\\n\"),g=e.length-1,h=f.length-1;1<=g&&0<=h&&e[g]!==f[h];)h--;for(;1<=g&&0<=h;g--,h--)if(e[g]!==f[h]){if(1!==g||1!==h){do if(g--,h--,0>h||e[g]!==f[h]){var k=\"\\n\"+e[g].replace(\" at new \",\" at \");a.displayName&&k.includes(\"<anonymous>\")&&(k=k.replace(\"<anonymous>\",a.displayName));return k}while(1<=g&&0<=h)}break}}}finally{Na=!1,Error.prepareStackTrace=c}return(a=a?a.displayName||a.name:\"\")?Ma(a):\"\"}\nfunction Pa(a){switch(a.tag){case 5:return Ma(a.type);case 16:return Ma(\"Lazy\");case 13:return Ma(\"Suspense\");case 19:return Ma(\"SuspenseList\");case 0:case 2:case 15:return a=Oa(a.type,!1),a;case 11:return a=Oa(a.type.render,!1),a;case 1:return a=Oa(a.type,!0),a;default:return\"\"}}\nfunction Qa(a){if(null==a)return null;if(\"function\"===typeof a)return a.displayName||a.name||null;if(\"string\"===typeof a)return a;switch(a){case ya:return\"Fragment\";case wa:return\"Portal\";case Aa:return\"Profiler\";case za:return\"StrictMode\";case Ea:return\"Suspense\";case Fa:return\"SuspenseList\"}if(\"object\"===typeof a)switch(a.$$typeof){case Ca:return(a.displayName||\"Context\")+\".Consumer\";case Ba:return(a._context.displayName||\"Context\")+\".Provider\";case Da:var b=a.render;a=a.displayName;a||(a=b.displayName||\nb.name||\"\",a=\"\"!==a?\"ForwardRef(\"+a+\")\":\"ForwardRef\");return a;case Ga:return b=a.displayName||null,null!==b?b:Qa(a.type)||\"Memo\";case Ha:b=a._payload;a=a._init;try{return Qa(a(b))}catch(c){}}return null}\nfunction Ra(a){var b=a.type;switch(a.tag){case 24:return\"Cache\";case 9:return(b.displayName||\"Context\")+\".Consumer\";case 10:return(b._context.displayName||\"Context\")+\".Provider\";case 18:return\"DehydratedFragment\";case 11:return a=b.render,a=a.displayName||a.name||\"\",b.displayName||(\"\"!==a?\"ForwardRef(\"+a+\")\":\"ForwardRef\");case 7:return\"Fragment\";case 5:return b;case 4:return\"Portal\";case 3:return\"Root\";case 6:return\"Text\";case 16:return Qa(b);case 8:return b===za?\"StrictMode\":\"Mode\";case 22:return\"Offscreen\";\ncase 12:return\"Profiler\";case 21:return\"Scope\";case 13:return\"Suspense\";case 19:return\"SuspenseList\";case 25:return\"TracingMarker\";case 1:case 0:case 17:case 2:case 14:case 15:if(\"function\"===typeof b)return b.displayName||b.name||null;if(\"string\"===typeof b)return b}return null}function Sa(a){switch(typeof a){case \"boolean\":case \"number\":case \"string\":case \"undefined\":return a;case \"object\":return a;default:return\"\"}}\nfunction Ta(a){var b=a.type;return(a=a.nodeName)&&\"input\"===a.toLowerCase()&&(\"checkbox\"===b||\"radio\"===b)}\nfunction Ua(a){var b=Ta(a)?\"checked\":\"value\",c=Object.getOwnPropertyDescriptor(a.constructor.prototype,b),d=\"\"+a[b];if(!a.hasOwnProperty(b)&&\"undefined\"!==typeof c&&\"function\"===typeof c.get&&\"function\"===typeof c.set){var e=c.get,f=c.set;Object.defineProperty(a,b,{configurable:!0,get:function(){return e.call(this)},set:function(a){d=\"\"+a;f.call(this,a)}});Object.defineProperty(a,b,{enumerable:c.enumerable});return{getValue:function(){return d},setValue:function(a){d=\"\"+a},stopTracking:function(){a._valueTracker=\nnull;delete a[b]}}}}function Va(a){a._valueTracker||(a._valueTracker=Ua(a))}function Wa(a){if(!a)return!1;var b=a._valueTracker;if(!b)return!0;var c=b.getValue();var d=\"\";a&&(d=Ta(a)?a.checked?\"true\":\"false\":a.value);a=d;return a!==c?(b.setValue(a),!0):!1}function Xa(a){a=a||(\"undefined\"!==typeof document?document:void 0);if(\"undefined\"===typeof a)return null;try{return a.activeElement||a.body}catch(b){return a.body}}\nfunction Ya(a,b){var c=b.checked;return A({},b,{defaultChecked:void 0,defaultValue:void 0,value:void 0,checked:null!=c?c:a._wrapperState.initialChecked})}function Za(a,b){var c=null==b.defaultValue?\"\":b.defaultValue,d=null!=b.checked?b.checked:b.defaultChecked;c=Sa(null!=b.value?b.value:c);a._wrapperState={initialChecked:d,initialValue:c,controlled:\"checkbox\"===b.type||\"radio\"===b.type?null!=b.checked:null!=b.value}}function ab(a,b){b=b.checked;null!=b&&ta(a,\"checked\",b,!1)}\nfunction bb(a,b){ab(a,b);var c=Sa(b.value),d=b.type;if(null!=c)if(\"number\"===d){if(0===c&&\"\"===a.value||a.value!=c)a.value=\"\"+c}else a.value!==\"\"+c&&(a.value=\"\"+c);else if(\"submit\"===d||\"reset\"===d){a.removeAttribute(\"value\");return}b.hasOwnProperty(\"value\")?cb(a,b.type,c):b.hasOwnProperty(\"defaultValue\")&&cb(a,b.type,Sa(b.defaultValue));null==b.checked&&null!=b.defaultChecked&&(a.defaultChecked=!!b.defaultChecked)}\nfunction db(a,b,c){if(b.hasOwnProperty(\"value\")||b.hasOwnProperty(\"defaultValue\")){var d=b.type;if(!(\"submit\"!==d&&\"reset\"!==d||void 0!==b.value&&null!==b.value))return;b=\"\"+a._wrapperState.initialValue;c||b===a.value||(a.value=b);a.defaultValue=b}c=a.name;\"\"!==c&&(a.name=\"\");a.defaultChecked=!!a._wrapperState.initialChecked;\"\"!==c&&(a.name=c)}\nfunction cb(a,b,c){if(\"number\"!==b||Xa(a.ownerDocument)!==a)null==c?a.defaultValue=\"\"+a._wrapperState.initialValue:a.defaultValue!==\"\"+c&&(a.defaultValue=\"\"+c)}var eb=Array.isArray;\nfunction fb(a,b,c,d){a=a.options;if(b){b={};for(var e=0;e<c.length;e++)b[\"$\"+c[e]]=!0;for(c=0;c<a.length;c++)e=b.hasOwnProperty(\"$\"+a[c].value),a[c].selected!==e&&(a[c].selected=e),e&&d&&(a[c].defaultSelected=!0)}else{c=\"\"+Sa(c);b=null;for(e=0;e<a.length;e++){if(a[e].value===c){a[e].selected=!0;d&&(a[e].defaultSelected=!0);return}null!==b||a[e].disabled||(b=a[e])}null!==b&&(b.selected=!0)}}\nfunction gb(a,b){if(null!=b.dangerouslySetInnerHTML)throw Error(p(91));return A({},b,{value:void 0,defaultValue:void 0,children:\"\"+a._wrapperState.initialValue})}function hb(a,b){var c=b.value;if(null==c){c=b.children;b=b.defaultValue;if(null!=c){if(null!=b)throw Error(p(92));if(eb(c)){if(1<c.length)throw Error(p(93));c=c[0]}b=c}null==b&&(b=\"\");c=b}a._wrapperState={initialValue:Sa(c)}}\nfunction ib(a,b){var c=Sa(b.value),d=Sa(b.defaultValue);null!=c&&(c=\"\"+c,c!==a.value&&(a.value=c),null==b.defaultValue&&a.defaultValue!==c&&(a.defaultValue=c));null!=d&&(a.defaultValue=\"\"+d)}function jb(a){var b=a.textContent;b===a._wrapperState.initialValue&&\"\"!==b&&null!==b&&(a.value=b)}function kb(a){switch(a){case \"svg\":return\"http://www.w3.org/2000/svg\";case \"math\":return\"http://www.w3.org/1998/Math/MathML\";default:return\"http://www.w3.org/1999/xhtml\"}}\nfunction lb(a,b){return null==a||\"http://www.w3.org/1999/xhtml\"===a?kb(b):\"http://www.w3.org/2000/svg\"===a&&\"foreignObject\"===b?\"http://www.w3.org/1999/xhtml\":a}\nvar mb,nb=function(a){return\"undefined\"!==typeof MSApp&&MSApp.execUnsafeLocalFunction?function(b,c,d,e){MSApp.execUnsafeLocalFunction(function(){return a(b,c,d,e)})}:a}(function(a,b){if(\"http://www.w3.org/2000/svg\"!==a.namespaceURI||\"innerHTML\"in a)a.innerHTML=b;else{mb=mb||document.createElement(\"div\");mb.innerHTML=\"<svg>\"+b.valueOf().toString()+\"</svg>\";for(b=mb.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;b.firstChild;)a.appendChild(b.firstChild)}});\nfunction ob(a,b){if(b){var c=a.firstChild;if(c&&c===a.lastChild&&3===c.nodeType){c.nodeValue=b;return}}a.textContent=b}\nvar pb={animationIterationCount:!0,aspectRatio:!0,borderImageOutset:!0,borderImageSlice:!0,borderImageWidth:!0,boxFlex:!0,boxFlexGroup:!0,boxOrdinalGroup:!0,columnCount:!0,columns:!0,flex:!0,flexGrow:!0,flexPositive:!0,flexShrink:!0,flexNegative:!0,flexOrder:!0,gridArea:!0,gridRow:!0,gridRowEnd:!0,gridRowSpan:!0,gridRowStart:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnSpan:!0,gridColumnStart:!0,fontWeight:!0,lineClamp:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,tabSize:!0,widows:!0,zIndex:!0,\nzoom:!0,fillOpacity:!0,floodOpacity:!0,stopOpacity:!0,strokeDasharray:!0,strokeDashoffset:!0,strokeMiterlimit:!0,strokeOpacity:!0,strokeWidth:!0},qb=[\"Webkit\",\"ms\",\"Moz\",\"O\"];Object.keys(pb).forEach(function(a){qb.forEach(function(b){b=b+a.charAt(0).toUpperCase()+a.substring(1);pb[b]=pb[a]})});function rb(a,b,c){return null==b||\"boolean\"===typeof b||\"\"===b?\"\":c||\"number\"!==typeof b||0===b||pb.hasOwnProperty(a)&&pb[a]?(\"\"+b).trim():b+\"px\"}\nfunction sb(a,b){a=a.style;for(var c in b)if(b.hasOwnProperty(c)){var d=0===c.indexOf(\"--\"),e=rb(c,b[c],d);\"float\"===c&&(c=\"cssFloat\");d?a.setProperty(c,e):a[c]=e}}var tb=A({menuitem:!0},{area:!0,base:!0,br:!0,col:!0,embed:!0,hr:!0,img:!0,input:!0,keygen:!0,link:!0,meta:!0,param:!0,source:!0,track:!0,wbr:!0});\nfunction ub(a,b){if(b){if(tb[a]&&(null!=b.children||null!=b.dangerouslySetInnerHTML))throw Error(p(137,a));if(null!=b.dangerouslySetInnerHTML){if(null!=b.children)throw Error(p(60));if(\"object\"!==typeof b.dangerouslySetInnerHTML||!(\"__html\"in b.dangerouslySetInnerHTML))throw Error(p(61));}if(null!=b.style&&\"object\"!==typeof b.style)throw Error(p(62));}}\nfunction vb(a,b){if(-1===a.indexOf(\"-\"))return\"string\"===typeof b.is;switch(a){case \"annotation-xml\":case \"color-profile\":case \"font-face\":case \"font-face-src\":case \"font-face-uri\":case \"font-face-format\":case \"font-face-name\":case \"missing-glyph\":return!1;default:return!0}}var wb=null;function xb(a){a=a.target||a.srcElement||window;a.correspondingUseElement&&(a=a.correspondingUseElement);return 3===a.nodeType?a.parentNode:a}var yb=null,zb=null,Ab=null;\nfunction Bb(a){if(a=Cb(a)){if(\"function\"!==typeof yb)throw Error(p(280));var b=a.stateNode;b&&(b=Db(b),yb(a.stateNode,a.type,b))}}function Eb(a){zb?Ab?Ab.push(a):Ab=[a]:zb=a}function Fb(){if(zb){var a=zb,b=Ab;Ab=zb=null;Bb(a);if(b)for(a=0;a<b.length;a++)Bb(b[a])}}function Gb(a,b){return a(b)}function Hb(){}var Ib=!1;function Jb(a,b,c){if(Ib)return a(b,c);Ib=!0;try{return Gb(a,b,c)}finally{if(Ib=!1,null!==zb||null!==Ab)Hb(),Fb()}}\nfunction Kb(a,b){var c=a.stateNode;if(null===c)return null;var d=Db(c);if(null===d)return null;c=d[b];a:switch(b){case \"onClick\":case \"onClickCapture\":case \"onDoubleClick\":case \"onDoubleClickCapture\":case \"onMouseDown\":case \"onMouseDownCapture\":case \"onMouseMove\":case \"onMouseMoveCapture\":case \"onMouseUp\":case \"onMouseUpCapture\":case \"onMouseEnter\":(d=!d.disabled)||(a=a.type,d=!(\"button\"===a||\"input\"===a||\"select\"===a||\"textarea\"===a));a=!d;break a;default:a=!1}if(a)return null;if(c&&\"function\"!==\ntypeof c)throw Error(p(231,b,typeof c));return c}var Lb=!1;if(ia)try{var Mb={};Object.defineProperty(Mb,\"passive\",{get:function(){Lb=!0}});window.addEventListener(\"test\",Mb,Mb);window.removeEventListener(\"test\",Mb,Mb)}catch(a){Lb=!1}function Nb(a,b,c,d,e,f,g,h,k){var l=Array.prototype.slice.call(arguments,3);try{b.apply(c,l)}catch(m){this.onError(m)}}var Ob=!1,Pb=null,Qb=!1,Rb=null,Sb={onError:function(a){Ob=!0;Pb=a}};function Tb(a,b,c,d,e,f,g,h,k){Ob=!1;Pb=null;Nb.apply(Sb,arguments)}\nfunction Ub(a,b,c,d,e,f,g,h,k){Tb.apply(this,arguments);if(Ob){if(Ob){var l=Pb;Ob=!1;Pb=null}else throw Error(p(198));Qb||(Qb=!0,Rb=l)}}function Vb(a){var b=a,c=a;if(a.alternate)for(;b.return;)b=b.return;else{a=b;do b=a,0!==(b.flags&4098)&&(c=b.return),a=b.return;while(a)}return 3===b.tag?c:null}function Wb(a){if(13===a.tag){var b=a.memoizedState;null===b&&(a=a.alternate,null!==a&&(b=a.memoizedState));if(null!==b)return b.dehydrated}return null}function Xb(a){if(Vb(a)!==a)throw Error(p(188));}\nfunction Yb(a){var b=a.alternate;if(!b){b=Vb(a);if(null===b)throw Error(p(188));return b!==a?null:a}for(var c=a,d=b;;){var e=c.return;if(null===e)break;var f=e.alternate;if(null===f){d=e.return;if(null!==d){c=d;continue}break}if(e.child===f.child){for(f=e.child;f;){if(f===c)return Xb(e),a;if(f===d)return Xb(e),b;f=f.sibling}throw Error(p(188));}if(c.return!==d.return)c=e,d=f;else{for(var g=!1,h=e.child;h;){if(h===c){g=!0;c=e;d=f;break}if(h===d){g=!0;d=e;c=f;break}h=h.sibling}if(!g){for(h=f.child;h;){if(h===\nc){g=!0;c=f;d=e;break}if(h===d){g=!0;d=f;c=e;break}h=h.sibling}if(!g)throw Error(p(189));}}if(c.alternate!==d)throw Error(p(190));}if(3!==c.tag)throw Error(p(188));return c.stateNode.current===c?a:b}function Zb(a){a=Yb(a);return null!==a?$b(a):null}function $b(a){if(5===a.tag||6===a.tag)return a;for(a=a.child;null!==a;){var b=$b(a);if(null!==b)return b;a=a.sibling}return null}\nvar ac=ca.unstable_scheduleCallback,bc=ca.unstable_cancelCallback,cc=ca.unstable_shouldYield,dc=ca.unstable_requestPaint,B=ca.unstable_now,ec=ca.unstable_getCurrentPriorityLevel,fc=ca.unstable_ImmediatePriority,gc=ca.unstable_UserBlockingPriority,hc=ca.unstable_NormalPriority,ic=ca.unstable_LowPriority,jc=ca.unstable_IdlePriority,kc=null,lc=null;function mc(a){if(lc&&\"function\"===typeof lc.onCommitFiberRoot)try{lc.onCommitFiberRoot(kc,a,void 0,128===(a.current.flags&128))}catch(b){}}\nvar oc=Math.clz32?Math.clz32:nc,pc=Math.log,qc=Math.LN2;function nc(a){a>>>=0;return 0===a?32:31-(pc(a)/qc|0)|0}var rc=64,sc=4194304;\nfunction tc(a){switch(a&-a){case 1:return 1;case 2:return 2;case 4:return 4;case 8:return 8;case 16:return 16;case 32:return 32;case 64:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:return a&4194240;case 4194304:case 8388608:case 16777216:case 33554432:case 67108864:return a&130023424;case 134217728:return 134217728;case 268435456:return 268435456;case 536870912:return 536870912;case 1073741824:return 1073741824;\ndefault:return a}}function uc(a,b){var c=a.pendingLanes;if(0===c)return 0;var d=0,e=a.suspendedLanes,f=a.pingedLanes,g=c&268435455;if(0!==g){var h=g&~e;0!==h?d=tc(h):(f&=g,0!==f&&(d=tc(f)))}else g=c&~e,0!==g?d=tc(g):0!==f&&(d=tc(f));if(0===d)return 0;if(0!==b&&b!==d&&0===(b&e)&&(e=d&-d,f=b&-b,e>=f||16===e&&0!==(f&4194240)))return b;0!==(d&4)&&(d|=c&16);b=a.entangledLanes;if(0!==b)for(a=a.entanglements,b&=d;0<b;)c=31-oc(b),e=1<<c,d|=a[c],b&=~e;return d}\nfunction vc(a,b){switch(a){case 1:case 2:case 4:return b+250;case 8:case 16:case 32:case 64:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:return b+5E3;case 4194304:case 8388608:case 16777216:case 33554432:case 67108864:return-1;case 134217728:case 268435456:case 536870912:case 1073741824:return-1;default:return-1}}\nfunction wc(a,b){for(var c=a.suspendedLanes,d=a.pingedLanes,e=a.expirationTimes,f=a.pendingLanes;0<f;){var g=31-oc(f),h=1<<g,k=e[g];if(-1===k){if(0===(h&c)||0!==(h&d))e[g]=vc(h,b)}else k<=b&&(a.expiredLanes|=h);f&=~h}}function xc(a){a=a.pendingLanes&-1073741825;return 0!==a?a:a&1073741824?1073741824:0}function yc(){var a=rc;rc<<=1;0===(rc&4194240)&&(rc=64);return a}function zc(a){for(var b=[],c=0;31>c;c++)b.push(a);return b}\nfunction Ac(a,b,c){a.pendingLanes|=b;536870912!==b&&(a.suspendedLanes=0,a.pingedLanes=0);a=a.eventTimes;b=31-oc(b);a[b]=c}function Bc(a,b){var c=a.pendingLanes&~b;a.pendingLanes=b;a.suspendedLanes=0;a.pingedLanes=0;a.expiredLanes&=b;a.mutableReadLanes&=b;a.entangledLanes&=b;b=a.entanglements;var d=a.eventTimes;for(a=a.expirationTimes;0<c;){var e=31-oc(c),f=1<<e;b[e]=0;d[e]=-1;a[e]=-1;c&=~f}}\nfunction Cc(a,b){var c=a.entangledLanes|=b;for(a=a.entanglements;c;){var d=31-oc(c),e=1<<d;e&b|a[d]&b&&(a[d]|=b);c&=~e}}var C=0;function Dc(a){a&=-a;return 1<a?4<a?0!==(a&268435455)?16:536870912:4:1}var Ec,Fc,Gc,Hc,Ic,Jc=!1,Kc=[],Lc=null,Mc=null,Nc=null,Oc=new Map,Pc=new Map,Qc=[],Rc=\"mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset submit\".split(\" \");\nfunction Sc(a,b){switch(a){case \"focusin\":case \"focusout\":Lc=null;break;case \"dragenter\":case \"dragleave\":Mc=null;break;case \"mouseover\":case \"mouseout\":Nc=null;break;case \"pointerover\":case \"pointerout\":Oc.delete(b.pointerId);break;case \"gotpointercapture\":case \"lostpointercapture\":Pc.delete(b.pointerId)}}\nfunction Tc(a,b,c,d,e,f){if(null===a||a.nativeEvent!==f)return a={blockedOn:b,domEventName:c,eventSystemFlags:d,nativeEvent:f,targetContainers:[e]},null!==b&&(b=Cb(b),null!==b&&Fc(b)),a;a.eventSystemFlags|=d;b=a.targetContainers;null!==e&&-1===b.indexOf(e)&&b.push(e);return a}\nfunction Uc(a,b,c,d,e){switch(b){case \"focusin\":return Lc=Tc(Lc,a,b,c,d,e),!0;case \"dragenter\":return Mc=Tc(Mc,a,b,c,d,e),!0;case \"mouseover\":return Nc=Tc(Nc,a,b,c,d,e),!0;case \"pointerover\":var f=e.pointerId;Oc.set(f,Tc(Oc.get(f)||null,a,b,c,d,e));return!0;case \"gotpointercapture\":return f=e.pointerId,Pc.set(f,Tc(Pc.get(f)||null,a,b,c,d,e)),!0}return!1}\nfunction Vc(a){var b=Wc(a.target);if(null!==b){var c=Vb(b);if(null!==c)if(b=c.tag,13===b){if(b=Wb(c),null!==b){a.blockedOn=b;Ic(a.priority,function(){Gc(c)});return}}else if(3===b&&c.stateNode.current.memoizedState.isDehydrated){a.blockedOn=3===c.tag?c.stateNode.containerInfo:null;return}}a.blockedOn=null}\nfunction Xc(a){if(null!==a.blockedOn)return!1;for(var b=a.targetContainers;0<b.length;){var c=Yc(a.domEventName,a.eventSystemFlags,b[0],a.nativeEvent);if(null===c){c=a.nativeEvent;var d=new c.constructor(c.type,c);wb=d;c.target.dispatchEvent(d);wb=null}else return b=Cb(c),null!==b&&Fc(b),a.blockedOn=c,!1;b.shift()}return!0}function Zc(a,b,c){Xc(a)&&c.delete(b)}function $c(){Jc=!1;null!==Lc&&Xc(Lc)&&(Lc=null);null!==Mc&&Xc(Mc)&&(Mc=null);null!==Nc&&Xc(Nc)&&(Nc=null);Oc.forEach(Zc);Pc.forEach(Zc)}\nfunction ad(a,b){a.blockedOn===b&&(a.blockedOn=null,Jc||(Jc=!0,ca.unstable_scheduleCallback(ca.unstable_NormalPriority,$c)))}\nfunction bd(a){function b(b){return ad(b,a)}if(0<Kc.length){ad(Kc[0],a);for(var c=1;c<Kc.length;c++){var d=Kc[c];d.blockedOn===a&&(d.blockedOn=null)}}null!==Lc&&ad(Lc,a);null!==Mc&&ad(Mc,a);null!==Nc&&ad(Nc,a);Oc.forEach(b);Pc.forEach(b);for(c=0;c<Qc.length;c++)d=Qc[c],d.blockedOn===a&&(d.blockedOn=null);for(;0<Qc.length&&(c=Qc[0],null===c.blockedOn);)Vc(c),null===c.blockedOn&&Qc.shift()}var cd=ua.ReactCurrentBatchConfig,dd=!0;\nfunction ed(a,b,c,d){var e=C,f=cd.transition;cd.transition=null;try{C=1,fd(a,b,c,d)}finally{C=e,cd.transition=f}}function gd(a,b,c,d){var e=C,f=cd.transition;cd.transition=null;try{C=4,fd(a,b,c,d)}finally{C=e,cd.transition=f}}\nfunction fd(a,b,c,d){if(dd){var e=Yc(a,b,c,d);if(null===e)hd(a,b,d,id,c),Sc(a,d);else if(Uc(e,a,b,c,d))d.stopPropagation();else if(Sc(a,d),b&4&&-1<Rc.indexOf(a)){for(;null!==e;){var f=Cb(e);null!==f&&Ec(f);f=Yc(a,b,c,d);null===f&&hd(a,b,d,id,c);if(f===e)break;e=f}null!==e&&d.stopPropagation()}else hd(a,b,d,null,c)}}var id=null;\nfunction Yc(a,b,c,d){id=null;a=xb(d);a=Wc(a);if(null!==a)if(b=Vb(a),null===b)a=null;else if(c=b.tag,13===c){a=Wb(b);if(null!==a)return a;a=null}else if(3===c){if(b.stateNode.current.memoizedState.isDehydrated)return 3===b.tag?b.stateNode.containerInfo:null;a=null}else b!==a&&(a=null);id=a;return null}\nfunction jd(a){switch(a){case \"cancel\":case \"click\":case \"close\":case \"contextmenu\":case \"copy\":case \"cut\":case \"auxclick\":case \"dblclick\":case \"dragend\":case \"dragstart\":case \"drop\":case \"focusin\":case \"focusout\":case \"input\":case \"invalid\":case \"keydown\":case \"keypress\":case \"keyup\":case \"mousedown\":case \"mouseup\":case \"paste\":case \"pause\":case \"play\":case \"pointercancel\":case \"pointerdown\":case \"pointerup\":case \"ratechange\":case \"reset\":case \"resize\":case \"seeked\":case \"submit\":case \"touchcancel\":case \"touchend\":case \"touchstart\":case \"volumechange\":case \"change\":case \"selectionchange\":case \"textInput\":case \"compositionstart\":case \"compositionend\":case \"compositionupdate\":case \"beforeblur\":case \"afterblur\":case \"beforeinput\":case \"blur\":case \"fullscreenchange\":case \"focus\":case \"hashchange\":case \"popstate\":case \"select\":case \"selectstart\":return 1;case \"drag\":case \"dragenter\":case \"dragexit\":case \"dragleave\":case \"dragover\":case \"mousemove\":case \"mouseout\":case \"mouseover\":case \"pointermove\":case \"pointerout\":case \"pointerover\":case \"scroll\":case \"toggle\":case \"touchmove\":case \"wheel\":case \"mouseenter\":case \"mouseleave\":case \"pointerenter\":case \"pointerleave\":return 4;\ncase \"message\":switch(ec()){case fc:return 1;case gc:return 4;case hc:case ic:return 16;case jc:return 536870912;default:return 16}default:return 16}}var kd=null,ld=null,md=null;function nd(){if(md)return md;var a,b=ld,c=b.length,d,e=\"value\"in kd?kd.value:kd.textContent,f=e.length;for(a=0;a<c&&b[a]===e[a];a++);var g=c-a;for(d=1;d<=g&&b[c-d]===e[f-d];d++);return md=e.slice(a,1<d?1-d:void 0)}\nfunction od(a){var b=a.keyCode;\"charCode\"in a?(a=a.charCode,0===a&&13===b&&(a=13)):a=b;10===a&&(a=13);return 32<=a||13===a?a:0}function pd(){return!0}function qd(){return!1}\nfunction rd(a){function b(b,d,e,f,g){this._reactName=b;this._targetInst=e;this.type=d;this.nativeEvent=f;this.target=g;this.currentTarget=null;for(var c in a)a.hasOwnProperty(c)&&(b=a[c],this[c]=b?b(f):f[c]);this.isDefaultPrevented=(null!=f.defaultPrevented?f.defaultPrevented:!1===f.returnValue)?pd:qd;this.isPropagationStopped=qd;return this}A(b.prototype,{preventDefault:function(){this.defaultPrevented=!0;var a=this.nativeEvent;a&&(a.preventDefault?a.preventDefault():\"unknown\"!==typeof a.returnValue&&\n(a.returnValue=!1),this.isDefaultPrevented=pd)},stopPropagation:function(){var a=this.nativeEvent;a&&(a.stopPropagation?a.stopPropagation():\"unknown\"!==typeof a.cancelBubble&&(a.cancelBubble=!0),this.isPropagationStopped=pd)},persist:function(){},isPersistent:pd});return b}\nvar sd={eventPhase:0,bubbles:0,cancelable:0,timeStamp:function(a){return a.timeStamp||Date.now()},defaultPrevented:0,isTrusted:0},td=rd(sd),ud=A({},sd,{view:0,detail:0}),vd=rd(ud),wd,xd,yd,Ad=A({},ud,{screenX:0,screenY:0,clientX:0,clientY:0,pageX:0,pageY:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,getModifierState:zd,button:0,buttons:0,relatedTarget:function(a){return void 0===a.relatedTarget?a.fromElement===a.srcElement?a.toElement:a.fromElement:a.relatedTarget},movementX:function(a){if(\"movementX\"in\na)return a.movementX;a!==yd&&(yd&&\"mousemove\"===a.type?(wd=a.screenX-yd.screenX,xd=a.screenY-yd.screenY):xd=wd=0,yd=a);return wd},movementY:function(a){return\"movementY\"in a?a.movementY:xd}}),Bd=rd(Ad),Cd=A({},Ad,{dataTransfer:0}),Dd=rd(Cd),Ed=A({},ud,{relatedTarget:0}),Fd=rd(Ed),Gd=A({},sd,{animationName:0,elapsedTime:0,pseudoElement:0}),Hd=rd(Gd),Id=A({},sd,{clipboardData:function(a){return\"clipboardData\"in a?a.clipboardData:window.clipboardData}}),Jd=rd(Id),Kd=A({},sd,{data:0}),Ld=rd(Kd),Md={Esc:\"Escape\",\nSpacebar:\" \",Left:\"ArrowLeft\",Up:\"ArrowUp\",Right:\"ArrowRight\",Down:\"ArrowDown\",Del:\"Delete\",Win:\"OS\",Menu:\"ContextMenu\",Apps:\"ContextMenu\",Scroll:\"ScrollLock\",MozPrintableKey:\"Unidentified\"},Nd={8:\"Backspace\",9:\"Tab\",12:\"Clear\",13:\"Enter\",16:\"Shift\",17:\"Control\",18:\"Alt\",19:\"Pause\",20:\"CapsLock\",27:\"Escape\",32:\" \",33:\"PageUp\",34:\"PageDown\",35:\"End\",36:\"Home\",37:\"ArrowLeft\",38:\"ArrowUp\",39:\"ArrowRight\",40:\"ArrowDown\",45:\"Insert\",46:\"Delete\",112:\"F1\",113:\"F2\",114:\"F3\",115:\"F4\",116:\"F5\",117:\"F6\",118:\"F7\",\n119:\"F8\",120:\"F9\",121:\"F10\",122:\"F11\",123:\"F12\",144:\"NumLock\",145:\"ScrollLock\",224:\"Meta\"},Od={Alt:\"altKey\",Control:\"ctrlKey\",Meta:\"metaKey\",Shift:\"shiftKey\"};function Pd(a){var b=this.nativeEvent;return b.getModifierState?b.getModifierState(a):(a=Od[a])?!!b[a]:!1}function zd(){return Pd}\nvar Qd=A({},ud,{key:function(a){if(a.key){var b=Md[a.key]||a.key;if(\"Unidentified\"!==b)return b}return\"keypress\"===a.type?(a=od(a),13===a?\"Enter\":String.fromCharCode(a)):\"keydown\"===a.type||\"keyup\"===a.type?Nd[a.keyCode]||\"Unidentified\":\"\"},code:0,location:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,repeat:0,locale:0,getModifierState:zd,charCode:function(a){return\"keypress\"===a.type?od(a):0},keyCode:function(a){return\"keydown\"===a.type||\"keyup\"===a.type?a.keyCode:0},which:function(a){return\"keypress\"===\na.type?od(a):\"keydown\"===a.type||\"keyup\"===a.type?a.keyCode:0}}),Rd=rd(Qd),Sd=A({},Ad,{pointerId:0,width:0,height:0,pressure:0,tangentialPressure:0,tiltX:0,tiltY:0,twist:0,pointerType:0,isPrimary:0}),Td=rd(Sd),Ud=A({},ud,{touches:0,targetTouches:0,changedTouches:0,altKey:0,metaKey:0,ctrlKey:0,shiftKey:0,getModifierState:zd}),Vd=rd(Ud),Wd=A({},sd,{propertyName:0,elapsedTime:0,pseudoElement:0}),Xd=rd(Wd),Yd=A({},Ad,{deltaX:function(a){return\"deltaX\"in a?a.deltaX:\"wheelDeltaX\"in a?-a.wheelDeltaX:0},\ndeltaY:function(a){return\"deltaY\"in a?a.deltaY:\"wheelDeltaY\"in a?-a.wheelDeltaY:\"wheelDelta\"in a?-a.wheelDelta:0},deltaZ:0,deltaMode:0}),Zd=rd(Yd),$d=[9,13,27,32],ae=ia&&\"CompositionEvent\"in window,be=null;ia&&\"documentMode\"in document&&(be=document.documentMode);var ce=ia&&\"TextEvent\"in window&&!be,de=ia&&(!ae||be&&8<be&&11>=be),ee=String.fromCharCode(32),fe=!1;\nfunction ge(a,b){switch(a){case \"keyup\":return-1!==$d.indexOf(b.keyCode);case \"keydown\":return 229!==b.keyCode;case \"keypress\":case \"mousedown\":case \"focusout\":return!0;default:return!1}}function he(a){a=a.detail;return\"object\"===typeof a&&\"data\"in a?a.data:null}var ie=!1;function je(a,b){switch(a){case \"compositionend\":return he(b);case \"keypress\":if(32!==b.which)return null;fe=!0;return ee;case \"textInput\":return a=b.data,a===ee&&fe?null:a;default:return null}}\nfunction ke(a,b){if(ie)return\"compositionend\"===a||!ae&&ge(a,b)?(a=nd(),md=ld=kd=null,ie=!1,a):null;switch(a){case \"paste\":return null;case \"keypress\":if(!(b.ctrlKey||b.altKey||b.metaKey)||b.ctrlKey&&b.altKey){if(b.char&&1<b.char.length)return b.char;if(b.which)return String.fromCharCode(b.which)}return null;case \"compositionend\":return de&&\"ko\"!==b.locale?null:b.data;default:return null}}\nvar le={color:!0,date:!0,datetime:!0,\"datetime-local\":!0,email:!0,month:!0,number:!0,password:!0,range:!0,search:!0,tel:!0,text:!0,time:!0,url:!0,week:!0};function me(a){var b=a&&a.nodeName&&a.nodeName.toLowerCase();return\"input\"===b?!!le[a.type]:\"textarea\"===b?!0:!1}function ne(a,b,c,d){Eb(d);b=oe(b,\"onChange\");0<b.length&&(c=new td(\"onChange\",\"change\",null,c,d),a.push({event:c,listeners:b}))}var pe=null,qe=null;function re(a){se(a,0)}function te(a){var b=ue(a);if(Wa(b))return a}\nfunction ve(a,b){if(\"change\"===a)return b}var we=!1;if(ia){var xe;if(ia){var ye=\"oninput\"in document;if(!ye){var ze=document.createElement(\"div\");ze.setAttribute(\"oninput\",\"return;\");ye=\"function\"===typeof ze.oninput}xe=ye}else xe=!1;we=xe&&(!document.documentMode||9<document.documentMode)}function Ae(){pe&&(pe.detachEvent(\"onpropertychange\",Be),qe=pe=null)}function Be(a){if(\"value\"===a.propertyName&&te(qe)){var b=[];ne(b,qe,a,xb(a));Jb(re,b)}}\nfunction Ce(a,b,c){\"focusin\"===a?(Ae(),pe=b,qe=c,pe.attachEvent(\"onpropertychange\",Be)):\"focusout\"===a&&Ae()}function De(a){if(\"selectionchange\"===a||\"keyup\"===a||\"keydown\"===a)return te(qe)}function Ee(a,b){if(\"click\"===a)return te(b)}function Fe(a,b){if(\"input\"===a||\"change\"===a)return te(b)}function Ge(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var He=\"function\"===typeof Object.is?Object.is:Ge;\nfunction Ie(a,b){if(He(a,b))return!0;if(\"object\"!==typeof a||null===a||\"object\"!==typeof b||null===b)return!1;var c=Object.keys(a),d=Object.keys(b);if(c.length!==d.length)return!1;for(d=0;d<c.length;d++){var e=c[d];if(!ja.call(b,e)||!He(a[e],b[e]))return!1}return!0}function Je(a){for(;a&&a.firstChild;)a=a.firstChild;return a}\nfunction Ke(a,b){var c=Je(a);a=0;for(var d;c;){if(3===c.nodeType){d=a+c.textContent.length;if(a<=b&&d>=b)return{node:c,offset:b-a};a=d}a:{for(;c;){if(c.nextSibling){c=c.nextSibling;break a}c=c.parentNode}c=void 0}c=Je(c)}}function Le(a,b){return a&&b?a===b?!0:a&&3===a.nodeType?!1:b&&3===b.nodeType?Le(a,b.parentNode):\"contains\"in a?a.contains(b):a.compareDocumentPosition?!!(a.compareDocumentPosition(b)&16):!1:!1}\nfunction Me(){for(var a=window,b=Xa();b instanceof a.HTMLIFrameElement;){try{var c=\"string\"===typeof b.contentWindow.location.href}catch(d){c=!1}if(c)a=b.contentWindow;else break;b=Xa(a.document)}return b}function Ne(a){var b=a&&a.nodeName&&a.nodeName.toLowerCase();return b&&(\"input\"===b&&(\"text\"===a.type||\"search\"===a.type||\"tel\"===a.type||\"url\"===a.type||\"password\"===a.type)||\"textarea\"===b||\"true\"===a.contentEditable)}\nfunction Oe(a){var b=Me(),c=a.focusedElem,d=a.selectionRange;if(b!==c&&c&&c.ownerDocument&&Le(c.ownerDocument.documentElement,c)){if(null!==d&&Ne(c))if(b=d.start,a=d.end,void 0===a&&(a=b),\"selectionStart\"in c)c.selectionStart=b,c.selectionEnd=Math.min(a,c.value.length);else if(a=(b=c.ownerDocument||document)&&b.defaultView||window,a.getSelection){a=a.getSelection();var e=c.textContent.length,f=Math.min(d.start,e);d=void 0===d.end?f:Math.min(d.end,e);!a.extend&&f>d&&(e=d,d=f,f=e);e=Ke(c,f);var g=Ke(c,\nd);e&&g&&(1!==a.rangeCount||a.anchorNode!==e.node||a.anchorOffset!==e.offset||a.focusNode!==g.node||a.focusOffset!==g.offset)&&(b=b.createRange(),b.setStart(e.node,e.offset),a.removeAllRanges(),f>d?(a.addRange(b),a.extend(g.node,g.offset)):(b.setEnd(g.node,g.offset),a.addRange(b)))}b=[];for(a=c;a=a.parentNode;)1===a.nodeType&&b.push({element:a,left:a.scrollLeft,top:a.scrollTop});\"function\"===typeof c.focus&&c.focus();for(c=0;c<b.length;c++)a=b[c],a.element.scrollLeft=a.left,a.element.scrollTop=a.top}}\nvar Pe=ia&&\"documentMode\"in document&&11>=document.documentMode,Qe=null,Re=null,Se=null,Te=!1;\nfunction Ue(a,b,c){var d=c.window===c?c.document:9===c.nodeType?c:c.ownerDocument;Te||null==Qe||Qe!==Xa(d)||(d=Qe,\"selectionStart\"in d&&Ne(d)?d={start:d.selectionStart,end:d.selectionEnd}:(d=(d.ownerDocument&&d.ownerDocument.defaultView||window).getSelection(),d={anchorNode:d.anchorNode,anchorOffset:d.anchorOffset,focusNode:d.focusNode,focusOffset:d.focusOffset}),Se&&Ie(Se,d)||(Se=d,d=oe(Re,\"onSelect\"),0<d.length&&(b=new td(\"onSelect\",\"select\",null,b,c),a.push({event:b,listeners:d}),b.target=Qe)))}\nfunction Ve(a,b){var c={};c[a.toLowerCase()]=b.toLowerCase();c[\"Webkit\"+a]=\"webkit\"+b;c[\"Moz\"+a]=\"moz\"+b;return c}var We={animationend:Ve(\"Animation\",\"AnimationEnd\"),animationiteration:Ve(\"Animation\",\"AnimationIteration\"),animationstart:Ve(\"Animation\",\"AnimationStart\"),transitionend:Ve(\"Transition\",\"TransitionEnd\")},Xe={},Ye={};\nia&&(Ye=document.createElement(\"div\").style,\"AnimationEvent\"in window||(delete We.animationend.animation,delete We.animationiteration.animation,delete We.animationstart.animation),\"TransitionEvent\"in window||delete We.transitionend.transition);function Ze(a){if(Xe[a])return Xe[a];if(!We[a])return a;var b=We[a],c;for(c in b)if(b.hasOwnProperty(c)&&c in Ye)return Xe[a]=b[c];return a}var $e=Ze(\"animationend\"),af=Ze(\"animationiteration\"),bf=Ze(\"animationstart\"),cf=Ze(\"transitionend\"),df=new Map,ef=\"abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel\".split(\" \");\nfunction ff(a,b){df.set(a,b);fa(b,[a])}for(var gf=0;gf<ef.length;gf++){var hf=ef[gf],jf=hf.toLowerCase(),kf=hf[0].toUpperCase()+hf.slice(1);ff(jf,\"on\"+kf)}ff($e,\"onAnimationEnd\");ff(af,\"onAnimationIteration\");ff(bf,\"onAnimationStart\");ff(\"dblclick\",\"onDoubleClick\");ff(\"focusin\",\"onFocus\");ff(\"focusout\",\"onBlur\");ff(cf,\"onTransitionEnd\");ha(\"onMouseEnter\",[\"mouseout\",\"mouseover\"]);ha(\"onMouseLeave\",[\"mouseout\",\"mouseover\"]);ha(\"onPointerEnter\",[\"pointerout\",\"pointerover\"]);\nha(\"onPointerLeave\",[\"pointerout\",\"pointerover\"]);fa(\"onChange\",\"change click focusin focusout input keydown keyup selectionchange\".split(\" \"));fa(\"onSelect\",\"focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange\".split(\" \"));fa(\"onBeforeInput\",[\"compositionend\",\"keypress\",\"textInput\",\"paste\"]);fa(\"onCompositionEnd\",\"compositionend focusout keydown keypress keyup mousedown\".split(\" \"));fa(\"onCompositionStart\",\"compositionstart focusout keydown keypress keyup mousedown\".split(\" \"));\nfa(\"onCompositionUpdate\",\"compositionupdate focusout keydown keypress keyup mousedown\".split(\" \"));var lf=\"abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting\".split(\" \"),mf=new Set(\"cancel close invalid load scroll toggle\".split(\" \").concat(lf));\nfunction nf(a,b,c){var d=a.type||\"unknown-event\";a.currentTarget=c;Ub(d,b,void 0,a);a.currentTarget=null}\nfunction se(a,b){b=0!==(b&4);for(var c=0;c<a.length;c++){var d=a[c],e=d.event;d=d.listeners;a:{var f=void 0;if(b)for(var g=d.length-1;0<=g;g--){var h=d[g],k=h.instance,l=h.currentTarget;h=h.listener;if(k!==f&&e.isPropagationStopped())break a;nf(e,h,l);f=k}else for(g=0;g<d.length;g++){h=d[g];k=h.instance;l=h.currentTarget;h=h.listener;if(k!==f&&e.isPropagationStopped())break a;nf(e,h,l);f=k}}}if(Qb)throw a=Rb,Qb=!1,Rb=null,a;}\nfunction D(a,b){var c=b[of];void 0===c&&(c=b[of]=new Set);var d=a+\"__bubble\";c.has(d)||(pf(b,a,2,!1),c.add(d))}function qf(a,b,c){var d=0;b&&(d|=4);pf(c,a,d,b)}var rf=\"_reactListening\"+Math.random().toString(36).slice(2);function sf(a){if(!a[rf]){a[rf]=!0;da.forEach(function(b){\"selectionchange\"!==b&&(mf.has(b)||qf(b,!1,a),qf(b,!0,a))});var b=9===a.nodeType?a:a.ownerDocument;null===b||b[rf]||(b[rf]=!0,qf(\"selectionchange\",!1,b))}}\nfunction pf(a,b,c,d){switch(jd(b)){case 1:var e=ed;break;case 4:e=gd;break;default:e=fd}c=e.bind(null,b,c,a);e=void 0;!Lb||\"touchstart\"!==b&&\"touchmove\"!==b&&\"wheel\"!==b||(e=!0);d?void 0!==e?a.addEventListener(b,c,{capture:!0,passive:e}):a.addEventListener(b,c,!0):void 0!==e?a.addEventListener(b,c,{passive:e}):a.addEventListener(b,c,!1)}\nfunction hd(a,b,c,d,e){var f=d;if(0===(b&1)&&0===(b&2)&&null!==d)a:for(;;){if(null===d)return;var g=d.tag;if(3===g||4===g){var h=d.stateNode.containerInfo;if(h===e||8===h.nodeType&&h.parentNode===e)break;if(4===g)for(g=d.return;null!==g;){var k=g.tag;if(3===k||4===k)if(k=g.stateNode.containerInfo,k===e||8===k.nodeType&&k.parentNode===e)return;g=g.return}for(;null!==h;){g=Wc(h);if(null===g)return;k=g.tag;if(5===k||6===k){d=f=g;continue a}h=h.parentNode}}d=d.return}Jb(function(){var d=f,e=xb(c),g=[];\na:{var h=df.get(a);if(void 0!==h){var k=td,n=a;switch(a){case \"keypress\":if(0===od(c))break a;case \"keydown\":case \"keyup\":k=Rd;break;case \"focusin\":n=\"focus\";k=Fd;break;case \"focusout\":n=\"blur\";k=Fd;break;case \"beforeblur\":case \"afterblur\":k=Fd;break;case \"click\":if(2===c.button)break a;case \"auxclick\":case \"dblclick\":case \"mousedown\":case \"mousemove\":case \"mouseup\":case \"mouseout\":case \"mouseover\":case \"contextmenu\":k=Bd;break;case \"drag\":case \"dragend\":case \"dragenter\":case \"dragexit\":case \"dragleave\":case \"dragover\":case \"dragstart\":case \"drop\":k=\nDd;break;case \"touchcancel\":case \"touchend\":case \"touchmove\":case \"touchstart\":k=Vd;break;case $e:case af:case bf:k=Hd;break;case cf:k=Xd;break;case \"scroll\":k=vd;break;case \"wheel\":k=Zd;break;case \"copy\":case \"cut\":case \"paste\":k=Jd;break;case \"gotpointercapture\":case \"lostpointercapture\":case \"pointercancel\":case \"pointerdown\":case \"pointermove\":case \"pointerout\":case \"pointerover\":case \"pointerup\":k=Td}var t=0!==(b&4),J=!t&&\"scroll\"===a,x=t?null!==h?h+\"Capture\":null:h;t=[];for(var w=d,u;null!==\nw;){u=w;var F=u.stateNode;5===u.tag&&null!==F&&(u=F,null!==x&&(F=Kb(w,x),null!=F&&t.push(tf(w,F,u))));if(J)break;w=w.return}0<t.length&&(h=new k(h,n,null,c,e),g.push({event:h,listeners:t}))}}if(0===(b&7)){a:{h=\"mouseover\"===a||\"pointerover\"===a;k=\"mouseout\"===a||\"pointerout\"===a;if(h&&c!==wb&&(n=c.relatedTarget||c.fromElement)&&(Wc(n)||n[uf]))break a;if(k||h){h=e.window===e?e:(h=e.ownerDocument)?h.defaultView||h.parentWindow:window;if(k){if(n=c.relatedTarget||c.toElement,k=d,n=n?Wc(n):null,null!==\nn&&(J=Vb(n),n!==J||5!==n.tag&&6!==n.tag))n=null}else k=null,n=d;if(k!==n){t=Bd;F=\"onMouseLeave\";x=\"onMouseEnter\";w=\"mouse\";if(\"pointerout\"===a||\"pointerover\"===a)t=Td,F=\"onPointerLeave\",x=\"onPointerEnter\",w=\"pointer\";J=null==k?h:ue(k);u=null==n?h:ue(n);h=new t(F,w+\"leave\",k,c,e);h.target=J;h.relatedTarget=u;F=null;Wc(e)===d&&(t=new t(x,w+\"enter\",n,c,e),t.target=u,t.relatedTarget=J,F=t);J=F;if(k&&n)b:{t=k;x=n;w=0;for(u=t;u;u=vf(u))w++;u=0;for(F=x;F;F=vf(F))u++;for(;0<w-u;)t=vf(t),w--;for(;0<u-w;)x=\nvf(x),u--;for(;w--;){if(t===x||null!==x&&t===x.alternate)break b;t=vf(t);x=vf(x)}t=null}else t=null;null!==k&&wf(g,h,k,t,!1);null!==n&&null!==J&&wf(g,J,n,t,!0)}}}a:{h=d?ue(d):window;k=h.nodeName&&h.nodeName.toLowerCase();if(\"select\"===k||\"input\"===k&&\"file\"===h.type)var na=ve;else if(me(h))if(we)na=Fe;else{na=De;var xa=Ce}else(k=h.nodeName)&&\"input\"===k.toLowerCase()&&(\"checkbox\"===h.type||\"radio\"===h.type)&&(na=Ee);if(na&&(na=na(a,d))){ne(g,na,c,e);break a}xa&&xa(a,h,d);\"focusout\"===a&&(xa=h._wrapperState)&&\nxa.controlled&&\"number\"===h.type&&cb(h,\"number\",h.value)}xa=d?ue(d):window;switch(a){case \"focusin\":if(me(xa)||\"true\"===xa.contentEditable)Qe=xa,Re=d,Se=null;break;case \"focusout\":Se=Re=Qe=null;break;case \"mousedown\":Te=!0;break;case \"contextmenu\":case \"mouseup\":case \"dragend\":Te=!1;Ue(g,c,e);break;case \"selectionchange\":if(Pe)break;case \"keydown\":case \"keyup\":Ue(g,c,e)}var $a;if(ae)b:{switch(a){case \"compositionstart\":var ba=\"onCompositionStart\";break b;case \"compositionend\":ba=\"onCompositionEnd\";\nbreak b;case \"compositionupdate\":ba=\"onCompositionUpdate\";break b}ba=void 0}else ie?ge(a,c)&&(ba=\"onCompositionEnd\"):\"keydown\"===a&&229===c.keyCode&&(ba=\"onCompositionStart\");ba&&(de&&\"ko\"!==c.locale&&(ie||\"onCompositionStart\"!==ba?\"onCompositionEnd\"===ba&&ie&&($a=nd()):(kd=e,ld=\"value\"in kd?kd.value:kd.textContent,ie=!0)),xa=oe(d,ba),0<xa.length&&(ba=new Ld(ba,a,null,c,e),g.push({event:ba,listeners:xa}),$a?ba.data=$a:($a=he(c),null!==$a&&(ba.data=$a))));if($a=ce?je(a,c):ke(a,c))d=oe(d,\"onBeforeInput\"),\n0<d.length&&(e=new Ld(\"onBeforeInput\",\"beforeinput\",null,c,e),g.push({event:e,listeners:d}),e.data=$a)}se(g,b)})}function tf(a,b,c){return{instance:a,listener:b,currentTarget:c}}function oe(a,b){for(var c=b+\"Capture\",d=[];null!==a;){var e=a,f=e.stateNode;5===e.tag&&null!==f&&(e=f,f=Kb(a,c),null!=f&&d.unshift(tf(a,f,e)),f=Kb(a,b),null!=f&&d.push(tf(a,f,e)));a=a.return}return d}function vf(a){if(null===a)return null;do a=a.return;while(a&&5!==a.tag);return a?a:null}\nfunction wf(a,b,c,d,e){for(var f=b._reactName,g=[];null!==c&&c!==d;){var h=c,k=h.alternate,l=h.stateNode;if(null!==k&&k===d)break;5===h.tag&&null!==l&&(h=l,e?(k=Kb(c,f),null!=k&&g.unshift(tf(c,k,h))):e||(k=Kb(c,f),null!=k&&g.push(tf(c,k,h))));c=c.return}0!==g.length&&a.push({event:b,listeners:g})}var xf=/\\r\\n?/g,yf=/\\u0000|\\uFFFD/g;function zf(a){return(\"string\"===typeof a?a:\"\"+a).replace(xf,\"\\n\").replace(yf,\"\")}function Af(a,b,c){b=zf(b);if(zf(a)!==b&&c)throw Error(p(425));}function Bf(){}\nvar Cf=null,Df=null;function Ef(a,b){return\"textarea\"===a||\"noscript\"===a||\"string\"===typeof b.children||\"number\"===typeof b.children||\"object\"===typeof b.dangerouslySetInnerHTML&&null!==b.dangerouslySetInnerHTML&&null!=b.dangerouslySetInnerHTML.__html}\nvar Ff=\"function\"===typeof setTimeout?setTimeout:void 0,Gf=\"function\"===typeof clearTimeout?clearTimeout:void 0,Hf=\"function\"===typeof Promise?Promise:void 0,Jf=\"function\"===typeof queueMicrotask?queueMicrotask:\"undefined\"!==typeof Hf?function(a){return Hf.resolve(null).then(a).catch(If)}:Ff;function If(a){setTimeout(function(){throw a;})}\nfunction Kf(a,b){var c=b,d=0;do{var e=c.nextSibling;a.removeChild(c);if(e&&8===e.nodeType)if(c=e.data,\"/$\"===c){if(0===d){a.removeChild(e);bd(b);return}d--}else\"$\"!==c&&\"$?\"!==c&&\"$!\"!==c||d++;c=e}while(c);bd(b)}function Lf(a){for(;null!=a;a=a.nextSibling){var b=a.nodeType;if(1===b||3===b)break;if(8===b){b=a.data;if(\"$\"===b||\"$!\"===b||\"$?\"===b)break;if(\"/$\"===b)return null}}return a}\nfunction Mf(a){a=a.previousSibling;for(var b=0;a;){if(8===a.nodeType){var c=a.data;if(\"$\"===c||\"$!\"===c||\"$?\"===c){if(0===b)return a;b--}else\"/$\"===c&&b++}a=a.previousSibling}return null}var Nf=Math.random().toString(36).slice(2),Of=\"__reactFiber$\"+Nf,Pf=\"__reactProps$\"+Nf,uf=\"__reactContainer$\"+Nf,of=\"__reactEvents$\"+Nf,Qf=\"__reactListeners$\"+Nf,Rf=\"__reactHandles$\"+Nf;\nfunction Wc(a){var b=a[Of];if(b)return b;for(var c=a.parentNode;c;){if(b=c[uf]||c[Of]){c=b.alternate;if(null!==b.child||null!==c&&null!==c.child)for(a=Mf(a);null!==a;){if(c=a[Of])return c;a=Mf(a)}return b}a=c;c=a.parentNode}return null}function Cb(a){a=a[Of]||a[uf];return!a||5!==a.tag&&6!==a.tag&&13!==a.tag&&3!==a.tag?null:a}function ue(a){if(5===a.tag||6===a.tag)return a.stateNode;throw Error(p(33));}function Db(a){return a[Pf]||null}var Sf=[],Tf=-1;function Uf(a){return{current:a}}\nfunction E(a){0>Tf||(a.current=Sf[Tf],Sf[Tf]=null,Tf--)}function G(a,b){Tf++;Sf[Tf]=a.current;a.current=b}var Vf={},H=Uf(Vf),Wf=Uf(!1),Xf=Vf;function Yf(a,b){var c=a.type.contextTypes;if(!c)return Vf;var d=a.stateNode;if(d&&d.__reactInternalMemoizedUnmaskedChildContext===b)return d.__reactInternalMemoizedMaskedChildContext;var e={},f;for(f in c)e[f]=b[f];d&&(a=a.stateNode,a.__reactInternalMemoizedUnmaskedChildContext=b,a.__reactInternalMemoizedMaskedChildContext=e);return e}\nfunction Zf(a){a=a.childContextTypes;return null!==a&&void 0!==a}function $f(){E(Wf);E(H)}function ag(a,b,c){if(H.current!==Vf)throw Error(p(168));G(H,b);G(Wf,c)}function bg(a,b,c){var d=a.stateNode;b=b.childContextTypes;if(\"function\"!==typeof d.getChildContext)return c;d=d.getChildContext();for(var e in d)if(!(e in b))throw Error(p(108,Ra(a)||\"Unknown\",e));return A({},c,d)}\nfunction cg(a){a=(a=a.stateNode)&&a.__reactInternalMemoizedMergedChildContext||Vf;Xf=H.current;G(H,a);G(Wf,Wf.current);return!0}function dg(a,b,c){var d=a.stateNode;if(!d)throw Error(p(169));c?(a=bg(a,b,Xf),d.__reactInternalMemoizedMergedChildContext=a,E(Wf),E(H),G(H,a)):E(Wf);G(Wf,c)}var eg=null,fg=!1,gg=!1;function hg(a){null===eg?eg=[a]:eg.push(a)}function ig(a){fg=!0;hg(a)}\nfunction jg(){if(!gg&&null!==eg){gg=!0;var a=0,b=C;try{var c=eg;for(C=1;a<c.length;a++){var d=c[a];do d=d(!0);while(null!==d)}eg=null;fg=!1}catch(e){throw null!==eg&&(eg=eg.slice(a+1)),ac(fc,jg),e;}finally{C=b,gg=!1}}return null}var kg=[],lg=0,mg=null,ng=0,og=[],pg=0,qg=null,rg=1,sg=\"\";function tg(a,b){kg[lg++]=ng;kg[lg++]=mg;mg=a;ng=b}\nfunction ug(a,b,c){og[pg++]=rg;og[pg++]=sg;og[pg++]=qg;qg=a;var d=rg;a=sg;var e=32-oc(d)-1;d&=~(1<<e);c+=1;var f=32-oc(b)+e;if(30<f){var g=e-e%5;f=(d&(1<<g)-1).toString(32);d>>=g;e-=g;rg=1<<32-oc(b)+e|c<<e|d;sg=f+a}else rg=1<<f|c<<e|d,sg=a}function vg(a){null!==a.return&&(tg(a,1),ug(a,1,0))}function wg(a){for(;a===mg;)mg=kg[--lg],kg[lg]=null,ng=kg[--lg],kg[lg]=null;for(;a===qg;)qg=og[--pg],og[pg]=null,sg=og[--pg],og[pg]=null,rg=og[--pg],og[pg]=null}var xg=null,yg=null,I=!1,zg=null;\nfunction Ag(a,b){var c=Bg(5,null,null,0);c.elementType=\"DELETED\";c.stateNode=b;c.return=a;b=a.deletions;null===b?(a.deletions=[c],a.flags|=16):b.push(c)}\nfunction Cg(a,b){switch(a.tag){case 5:var c=a.type;b=1!==b.nodeType||c.toLowerCase()!==b.nodeName.toLowerCase()?null:b;return null!==b?(a.stateNode=b,xg=a,yg=Lf(b.firstChild),!0):!1;case 6:return b=\"\"===a.pendingProps||3!==b.nodeType?null:b,null!==b?(a.stateNode=b,xg=a,yg=null,!0):!1;case 13:return b=8!==b.nodeType?null:b,null!==b?(c=null!==qg?{id:rg,overflow:sg}:null,a.memoizedState={dehydrated:b,treeContext:c,retryLane:1073741824},c=Bg(18,null,null,0),c.stateNode=b,c.return=a,a.child=c,xg=a,yg=\nnull,!0):!1;default:return!1}}function Dg(a){return 0!==(a.mode&1)&&0===(a.flags&128)}function Eg(a){if(I){var b=yg;if(b){var c=b;if(!Cg(a,b)){if(Dg(a))throw Error(p(418));b=Lf(c.nextSibling);var d=xg;b&&Cg(a,b)?Ag(d,c):(a.flags=a.flags&-4097|2,I=!1,xg=a)}}else{if(Dg(a))throw Error(p(418));a.flags=a.flags&-4097|2;I=!1;xg=a}}}function Fg(a){for(a=a.return;null!==a&&5!==a.tag&&3!==a.tag&&13!==a.tag;)a=a.return;xg=a}\nfunction Gg(a){if(a!==xg)return!1;if(!I)return Fg(a),I=!0,!1;var b;(b=3!==a.tag)&&!(b=5!==a.tag)&&(b=a.type,b=\"head\"!==b&&\"body\"!==b&&!Ef(a.type,a.memoizedProps));if(b&&(b=yg)){if(Dg(a))throw Hg(),Error(p(418));for(;b;)Ag(a,b),b=Lf(b.nextSibling)}Fg(a);if(13===a.tag){a=a.memoizedState;a=null!==a?a.dehydrated:null;if(!a)throw Error(p(317));a:{a=a.nextSibling;for(b=0;a;){if(8===a.nodeType){var c=a.data;if(\"/$\"===c){if(0===b){yg=Lf(a.nextSibling);break a}b--}else\"$\"!==c&&\"$!\"!==c&&\"$?\"!==c||b++}a=a.nextSibling}yg=\nnull}}else yg=xg?Lf(a.stateNode.nextSibling):null;return!0}function Hg(){for(var a=yg;a;)a=Lf(a.nextSibling)}function Ig(){yg=xg=null;I=!1}function Jg(a){null===zg?zg=[a]:zg.push(a)}var Kg=ua.ReactCurrentBatchConfig;\nfunction Lg(a,b,c){a=c.ref;if(null!==a&&\"function\"!==typeof a&&\"object\"!==typeof a){if(c._owner){c=c._owner;if(c){if(1!==c.tag)throw Error(p(309));var d=c.stateNode}if(!d)throw Error(p(147,a));var e=d,f=\"\"+a;if(null!==b&&null!==b.ref&&\"function\"===typeof b.ref&&b.ref._stringRef===f)return b.ref;b=function(a){var b=e.refs;null===a?delete b[f]:b[f]=a};b._stringRef=f;return b}if(\"string\"!==typeof a)throw Error(p(284));if(!c._owner)throw Error(p(290,a));}return a}\nfunction Mg(a,b){a=Object.prototype.toString.call(b);throw Error(p(31,\"[object Object]\"===a?\"object with keys {\"+Object.keys(b).join(\", \")+\"}\":a));}function Ng(a){var b=a._init;return b(a._payload)}\nfunction Og(a){function b(b,c){if(a){var d=b.deletions;null===d?(b.deletions=[c],b.flags|=16):d.push(c)}}function c(c,d){if(!a)return null;for(;null!==d;)b(c,d),d=d.sibling;return null}function d(a,b){for(a=new Map;null!==b;)null!==b.key?a.set(b.key,b):a.set(b.index,b),b=b.sibling;return a}function e(a,b){a=Pg(a,b);a.index=0;a.sibling=null;return a}function f(b,c,d){b.index=d;if(!a)return b.flags|=1048576,c;d=b.alternate;if(null!==d)return d=d.index,d<c?(b.flags|=2,c):d;b.flags|=2;return c}function g(b){a&&\nnull===b.alternate&&(b.flags|=2);return b}function h(a,b,c,d){if(null===b||6!==b.tag)return b=Qg(c,a.mode,d),b.return=a,b;b=e(b,c);b.return=a;return b}function k(a,b,c,d){var f=c.type;if(f===ya)return m(a,b,c.props.children,d,c.key);if(null!==b&&(b.elementType===f||\"object\"===typeof f&&null!==f&&f.$$typeof===Ha&&Ng(f)===b.type))return d=e(b,c.props),d.ref=Lg(a,b,c),d.return=a,d;d=Rg(c.type,c.key,c.props,null,a.mode,d);d.ref=Lg(a,b,c);d.return=a;return d}function l(a,b,c,d){if(null===b||4!==b.tag||\nb.stateNode.containerInfo!==c.containerInfo||b.stateNode.implementation!==c.implementation)return b=Sg(c,a.mode,d),b.return=a,b;b=e(b,c.children||[]);b.return=a;return b}function m(a,b,c,d,f){if(null===b||7!==b.tag)return b=Tg(c,a.mode,d,f),b.return=a,b;b=e(b,c);b.return=a;return b}function q(a,b,c){if(\"string\"===typeof b&&\"\"!==b||\"number\"===typeof b)return b=Qg(\"\"+b,a.mode,c),b.return=a,b;if(\"object\"===typeof b&&null!==b){switch(b.$$typeof){case va:return c=Rg(b.type,b.key,b.props,null,a.mode,c),\nc.ref=Lg(a,null,b),c.return=a,c;case wa:return b=Sg(b,a.mode,c),b.return=a,b;case Ha:var d=b._init;return q(a,d(b._payload),c)}if(eb(b)||Ka(b))return b=Tg(b,a.mode,c,null),b.return=a,b;Mg(a,b)}return null}function r(a,b,c,d){var e=null!==b?b.key:null;if(\"string\"===typeof c&&\"\"!==c||\"number\"===typeof c)return null!==e?null:h(a,b,\"\"+c,d);if(\"object\"===typeof c&&null!==c){switch(c.$$typeof){case va:return c.key===e?k(a,b,c,d):null;case wa:return c.key===e?l(a,b,c,d):null;case Ha:return e=c._init,r(a,\nb,e(c._payload),d)}if(eb(c)||Ka(c))return null!==e?null:m(a,b,c,d,null);Mg(a,c)}return null}function y(a,b,c,d,e){if(\"string\"===typeof d&&\"\"!==d||\"number\"===typeof d)return a=a.get(c)||null,h(b,a,\"\"+d,e);if(\"object\"===typeof d&&null!==d){switch(d.$$typeof){case va:return a=a.get(null===d.key?c:d.key)||null,k(b,a,d,e);case wa:return a=a.get(null===d.key?c:d.key)||null,l(b,a,d,e);case Ha:var f=d._init;return y(a,b,c,f(d._payload),e)}if(eb(d)||Ka(d))return a=a.get(c)||null,m(b,a,d,e,null);Mg(b,d)}return null}\nfunction n(e,g,h,k){for(var l=null,m=null,u=g,w=g=0,x=null;null!==u&&w<h.length;w++){u.index>w?(x=u,u=null):x=u.sibling;var n=r(e,u,h[w],k);if(null===n){null===u&&(u=x);break}a&&u&&null===n.alternate&&b(e,u);g=f(n,g,w);null===m?l=n:m.sibling=n;m=n;u=x}if(w===h.length)return c(e,u),I&&tg(e,w),l;if(null===u){for(;w<h.length;w++)u=q(e,h[w],k),null!==u&&(g=f(u,g,w),null===m?l=u:m.sibling=u,m=u);I&&tg(e,w);return l}for(u=d(e,u);w<h.length;w++)x=y(u,e,w,h[w],k),null!==x&&(a&&null!==x.alternate&&u.delete(null===\nx.key?w:x.key),g=f(x,g,w),null===m?l=x:m.sibling=x,m=x);a&&u.forEach(function(a){return b(e,a)});I&&tg(e,w);return l}function t(e,g,h,k){var l=Ka(h);if(\"function\"!==typeof l)throw Error(p(150));h=l.call(h);if(null==h)throw Error(p(151));for(var u=l=null,m=g,w=g=0,x=null,n=h.next();null!==m&&!n.done;w++,n=h.next()){m.index>w?(x=m,m=null):x=m.sibling;var t=r(e,m,n.value,k);if(null===t){null===m&&(m=x);break}a&&m&&null===t.alternate&&b(e,m);g=f(t,g,w);null===u?l=t:u.sibling=t;u=t;m=x}if(n.done)return c(e,\nm),I&&tg(e,w),l;if(null===m){for(;!n.done;w++,n=h.next())n=q(e,n.value,k),null!==n&&(g=f(n,g,w),null===u?l=n:u.sibling=n,u=n);I&&tg(e,w);return l}for(m=d(e,m);!n.done;w++,n=h.next())n=y(m,e,w,n.value,k),null!==n&&(a&&null!==n.alternate&&m.delete(null===n.key?w:n.key),g=f(n,g,w),null===u?l=n:u.sibling=n,u=n);a&&m.forEach(function(a){return b(e,a)});I&&tg(e,w);return l}function J(a,d,f,h){\"object\"===typeof f&&null!==f&&f.type===ya&&null===f.key&&(f=f.props.children);if(\"object\"===typeof f&&null!==f){switch(f.$$typeof){case va:a:{for(var k=\nf.key,l=d;null!==l;){if(l.key===k){k=f.type;if(k===ya){if(7===l.tag){c(a,l.sibling);d=e(l,f.props.children);d.return=a;a=d;break a}}else if(l.elementType===k||\"object\"===typeof k&&null!==k&&k.$$typeof===Ha&&Ng(k)===l.type){c(a,l.sibling);d=e(l,f.props);d.ref=Lg(a,l,f);d.return=a;a=d;break a}c(a,l);break}else b(a,l);l=l.sibling}f.type===ya?(d=Tg(f.props.children,a.mode,h,f.key),d.return=a,a=d):(h=Rg(f.type,f.key,f.props,null,a.mode,h),h.ref=Lg(a,d,f),h.return=a,a=h)}return g(a);case wa:a:{for(l=f.key;null!==\nd;){if(d.key===l)if(4===d.tag&&d.stateNode.containerInfo===f.containerInfo&&d.stateNode.implementation===f.implementation){c(a,d.sibling);d=e(d,f.children||[]);d.return=a;a=d;break a}else{c(a,d);break}else b(a,d);d=d.sibling}d=Sg(f,a.mode,h);d.return=a;a=d}return g(a);case Ha:return l=f._init,J(a,d,l(f._payload),h)}if(eb(f))return n(a,d,f,h);if(Ka(f))return t(a,d,f,h);Mg(a,f)}return\"string\"===typeof f&&\"\"!==f||\"number\"===typeof f?(f=\"\"+f,null!==d&&6===d.tag?(c(a,d.sibling),d=e(d,f),d.return=a,a=d):\n(c(a,d),d=Qg(f,a.mode,h),d.return=a,a=d),g(a)):c(a,d)}return J}var Ug=Og(!0),Vg=Og(!1),Wg=Uf(null),Xg=null,Yg=null,Zg=null;function $g(){Zg=Yg=Xg=null}function ah(a){var b=Wg.current;E(Wg);a._currentValue=b}function bh(a,b,c){for(;null!==a;){var d=a.alternate;(a.childLanes&b)!==b?(a.childLanes|=b,null!==d&&(d.childLanes|=b)):null!==d&&(d.childLanes&b)!==b&&(d.childLanes|=b);if(a===c)break;a=a.return}}\nfunction ch(a,b){Xg=a;Zg=Yg=null;a=a.dependencies;null!==a&&null!==a.firstContext&&(0!==(a.lanes&b)&&(dh=!0),a.firstContext=null)}function eh(a){var b=a._currentValue;if(Zg!==a)if(a={context:a,memoizedValue:b,next:null},null===Yg){if(null===Xg)throw Error(p(308));Yg=a;Xg.dependencies={lanes:0,firstContext:a}}else Yg=Yg.next=a;return b}var fh=null;function gh(a){null===fh?fh=[a]:fh.push(a)}\nfunction hh(a,b,c,d){var e=b.interleaved;null===e?(c.next=c,gh(b)):(c.next=e.next,e.next=c);b.interleaved=c;return ih(a,d)}function ih(a,b){a.lanes|=b;var c=a.alternate;null!==c&&(c.lanes|=b);c=a;for(a=a.return;null!==a;)a.childLanes|=b,c=a.alternate,null!==c&&(c.childLanes|=b),c=a,a=a.return;return 3===c.tag?c.stateNode:null}var jh=!1;function kh(a){a.updateQueue={baseState:a.memoizedState,firstBaseUpdate:null,lastBaseUpdate:null,shared:{pending:null,interleaved:null,lanes:0},effects:null}}\nfunction lh(a,b){a=a.updateQueue;b.updateQueue===a&&(b.updateQueue={baseState:a.baseState,firstBaseUpdate:a.firstBaseUpdate,lastBaseUpdate:a.lastBaseUpdate,shared:a.shared,effects:a.effects})}function mh(a,b){return{eventTime:a,lane:b,tag:0,payload:null,callback:null,next:null}}\nfunction nh(a,b,c){var d=a.updateQueue;if(null===d)return null;d=d.shared;if(0!==(K&2)){var e=d.pending;null===e?b.next=b:(b.next=e.next,e.next=b);d.pending=b;return ih(a,c)}e=d.interleaved;null===e?(b.next=b,gh(d)):(b.next=e.next,e.next=b);d.interleaved=b;return ih(a,c)}function oh(a,b,c){b=b.updateQueue;if(null!==b&&(b=b.shared,0!==(c&4194240))){var d=b.lanes;d&=a.pendingLanes;c|=d;b.lanes=c;Cc(a,c)}}\nfunction ph(a,b){var c=a.updateQueue,d=a.alternate;if(null!==d&&(d=d.updateQueue,c===d)){var e=null,f=null;c=c.firstBaseUpdate;if(null!==c){do{var g={eventTime:c.eventTime,lane:c.lane,tag:c.tag,payload:c.payload,callback:c.callback,next:null};null===f?e=f=g:f=f.next=g;c=c.next}while(null!==c);null===f?e=f=b:f=f.next=b}else e=f=b;c={baseState:d.baseState,firstBaseUpdate:e,lastBaseUpdate:f,shared:d.shared,effects:d.effects};a.updateQueue=c;return}a=c.lastBaseUpdate;null===a?c.firstBaseUpdate=b:a.next=\nb;c.lastBaseUpdate=b}\nfunction qh(a,b,c,d){var e=a.updateQueue;jh=!1;var f=e.firstBaseUpdate,g=e.lastBaseUpdate,h=e.shared.pending;if(null!==h){e.shared.pending=null;var k=h,l=k.next;k.next=null;null===g?f=l:g.next=l;g=k;var m=a.alternate;null!==m&&(m=m.updateQueue,h=m.lastBaseUpdate,h!==g&&(null===h?m.firstBaseUpdate=l:h.next=l,m.lastBaseUpdate=k))}if(null!==f){var q=e.baseState;g=0;m=l=k=null;h=f;do{var r=h.lane,y=h.eventTime;if((d&r)===r){null!==m&&(m=m.next={eventTime:y,lane:0,tag:h.tag,payload:h.payload,callback:h.callback,\nnext:null});a:{var n=a,t=h;r=b;y=c;switch(t.tag){case 1:n=t.payload;if(\"function\"===typeof n){q=n.call(y,q,r);break a}q=n;break a;case 3:n.flags=n.flags&-65537|128;case 0:n=t.payload;r=\"function\"===typeof n?n.call(y,q,r):n;if(null===r||void 0===r)break a;q=A({},q,r);break a;case 2:jh=!0}}null!==h.callback&&0!==h.lane&&(a.flags|=64,r=e.effects,null===r?e.effects=[h]:r.push(h))}else y={eventTime:y,lane:r,tag:h.tag,payload:h.payload,callback:h.callback,next:null},null===m?(l=m=y,k=q):m=m.next=y,g|=r;\nh=h.next;if(null===h)if(h=e.shared.pending,null===h)break;else r=h,h=r.next,r.next=null,e.lastBaseUpdate=r,e.shared.pending=null}while(1);null===m&&(k=q);e.baseState=k;e.firstBaseUpdate=l;e.lastBaseUpdate=m;b=e.shared.interleaved;if(null!==b){e=b;do g|=e.lane,e=e.next;while(e!==b)}else null===f&&(e.shared.lanes=0);rh|=g;a.lanes=g;a.memoizedState=q}}\nfunction sh(a,b,c){a=b.effects;b.effects=null;if(null!==a)for(b=0;b<a.length;b++){var d=a[b],e=d.callback;if(null!==e){d.callback=null;d=c;if(\"function\"!==typeof e)throw Error(p(191,e));e.call(d)}}}var th={},uh=Uf(th),vh=Uf(th),wh=Uf(th);function xh(a){if(a===th)throw Error(p(174));return a}\nfunction yh(a,b){G(wh,b);G(vh,a);G(uh,th);a=b.nodeType;switch(a){case 9:case 11:b=(b=b.documentElement)?b.namespaceURI:lb(null,\"\");break;default:a=8===a?b.parentNode:b,b=a.namespaceURI||null,a=a.tagName,b=lb(b,a)}E(uh);G(uh,b)}function zh(){E(uh);E(vh);E(wh)}function Ah(a){xh(wh.current);var b=xh(uh.current);var c=lb(b,a.type);b!==c&&(G(vh,a),G(uh,c))}function Bh(a){vh.current===a&&(E(uh),E(vh))}var L=Uf(0);\nfunction Ch(a){for(var b=a;null!==b;){if(13===b.tag){var c=b.memoizedState;if(null!==c&&(c=c.dehydrated,null===c||\"$?\"===c.data||\"$!\"===c.data))return b}else if(19===b.tag&&void 0!==b.memoizedProps.revealOrder){if(0!==(b.flags&128))return b}else if(null!==b.child){b.child.return=b;b=b.child;continue}if(b===a)break;for(;null===b.sibling;){if(null===b.return||b.return===a)return null;b=b.return}b.sibling.return=b.return;b=b.sibling}return null}var Dh=[];\nfunction Eh(){for(var a=0;a<Dh.length;a++)Dh[a]._workInProgressVersionPrimary=null;Dh.length=0}var Fh=ua.ReactCurrentDispatcher,Gh=ua.ReactCurrentBatchConfig,Hh=0,M=null,N=null,O=null,Ih=!1,Jh=!1,Kh=0,Lh=0;function P(){throw Error(p(321));}function Mh(a,b){if(null===b)return!1;for(var c=0;c<b.length&&c<a.length;c++)if(!He(a[c],b[c]))return!1;return!0}\nfunction Nh(a,b,c,d,e,f){Hh=f;M=b;b.memoizedState=null;b.updateQueue=null;b.lanes=0;Fh.current=null===a||null===a.memoizedState?Oh:Ph;a=c(d,e);if(Jh){f=0;do{Jh=!1;Kh=0;if(25<=f)throw Error(p(301));f+=1;O=N=null;b.updateQueue=null;Fh.current=Qh;a=c(d,e)}while(Jh)}Fh.current=Rh;b=null!==N&&null!==N.next;Hh=0;O=N=M=null;Ih=!1;if(b)throw Error(p(300));return a}function Sh(){var a=0!==Kh;Kh=0;return a}\nfunction Th(){var a={memoizedState:null,baseState:null,baseQueue:null,queue:null,next:null};null===O?M.memoizedState=O=a:O=O.next=a;return O}function Uh(){if(null===N){var a=M.alternate;a=null!==a?a.memoizedState:null}else a=N.next;var b=null===O?M.memoizedState:O.next;if(null!==b)O=b,N=a;else{if(null===a)throw Error(p(310));N=a;a={memoizedState:N.memoizedState,baseState:N.baseState,baseQueue:N.baseQueue,queue:N.queue,next:null};null===O?M.memoizedState=O=a:O=O.next=a}return O}\nfunction Vh(a,b){return\"function\"===typeof b?b(a):b}\nfunction Wh(a){var b=Uh(),c=b.queue;if(null===c)throw Error(p(311));c.lastRenderedReducer=a;var d=N,e=d.baseQueue,f=c.pending;if(null!==f){if(null!==e){var g=e.next;e.next=f.next;f.next=g}d.baseQueue=e=f;c.pending=null}if(null!==e){f=e.next;d=d.baseState;var h=g=null,k=null,l=f;do{var m=l.lane;if((Hh&m)===m)null!==k&&(k=k.next={lane:0,action:l.action,hasEagerState:l.hasEagerState,eagerState:l.eagerState,next:null}),d=l.hasEagerState?l.eagerState:a(d,l.action);else{var q={lane:m,action:l.action,hasEagerState:l.hasEagerState,\neagerState:l.eagerState,next:null};null===k?(h=k=q,g=d):k=k.next=q;M.lanes|=m;rh|=m}l=l.next}while(null!==l&&l!==f);null===k?g=d:k.next=h;He(d,b.memoizedState)||(dh=!0);b.memoizedState=d;b.baseState=g;b.baseQueue=k;c.lastRenderedState=d}a=c.interleaved;if(null!==a){e=a;do f=e.lane,M.lanes|=f,rh|=f,e=e.next;while(e!==a)}else null===e&&(c.lanes=0);return[b.memoizedState,c.dispatch]}\nfunction Xh(a){var b=Uh(),c=b.queue;if(null===c)throw Error(p(311));c.lastRenderedReducer=a;var d=c.dispatch,e=c.pending,f=b.memoizedState;if(null!==e){c.pending=null;var g=e=e.next;do f=a(f,g.action),g=g.next;while(g!==e);He(f,b.memoizedState)||(dh=!0);b.memoizedState=f;null===b.baseQueue&&(b.baseState=f);c.lastRenderedState=f}return[f,d]}function Yh(){}\nfunction Zh(a,b){var c=M,d=Uh(),e=b(),f=!He(d.memoizedState,e);f&&(d.memoizedState=e,dh=!0);d=d.queue;$h(ai.bind(null,c,d,a),[a]);if(d.getSnapshot!==b||f||null!==O&&O.memoizedState.tag&1){c.flags|=2048;bi(9,ci.bind(null,c,d,e,b),void 0,null);if(null===Q)throw Error(p(349));0!==(Hh&30)||di(c,b,e)}return e}function di(a,b,c){a.flags|=16384;a={getSnapshot:b,value:c};b=M.updateQueue;null===b?(b={lastEffect:null,stores:null},M.updateQueue=b,b.stores=[a]):(c=b.stores,null===c?b.stores=[a]:c.push(a))}\nfunction ci(a,b,c,d){b.value=c;b.getSnapshot=d;ei(b)&&fi(a)}function ai(a,b,c){return c(function(){ei(b)&&fi(a)})}function ei(a){var b=a.getSnapshot;a=a.value;try{var c=b();return!He(a,c)}catch(d){return!0}}function fi(a){var b=ih(a,1);null!==b&&gi(b,a,1,-1)}\nfunction hi(a){var b=Th();\"function\"===typeof a&&(a=a());b.memoizedState=b.baseState=a;a={pending:null,interleaved:null,lanes:0,dispatch:null,lastRenderedReducer:Vh,lastRenderedState:a};b.queue=a;a=a.dispatch=ii.bind(null,M,a);return[b.memoizedState,a]}\nfunction bi(a,b,c,d){a={tag:a,create:b,destroy:c,deps:d,next:null};b=M.updateQueue;null===b?(b={lastEffect:null,stores:null},M.updateQueue=b,b.lastEffect=a.next=a):(c=b.lastEffect,null===c?b.lastEffect=a.next=a:(d=c.next,c.next=a,a.next=d,b.lastEffect=a));return a}function ji(){return Uh().memoizedState}function ki(a,b,c,d){var e=Th();M.flags|=a;e.memoizedState=bi(1|b,c,void 0,void 0===d?null:d)}\nfunction li(a,b,c,d){var e=Uh();d=void 0===d?null:d;var f=void 0;if(null!==N){var g=N.memoizedState;f=g.destroy;if(null!==d&&Mh(d,g.deps)){e.memoizedState=bi(b,c,f,d);return}}M.flags|=a;e.memoizedState=bi(1|b,c,f,d)}function mi(a,b){return ki(8390656,8,a,b)}function $h(a,b){return li(2048,8,a,b)}function ni(a,b){return li(4,2,a,b)}function oi(a,b){return li(4,4,a,b)}\nfunction pi(a,b){if(\"function\"===typeof b)return a=a(),b(a),function(){b(null)};if(null!==b&&void 0!==b)return a=a(),b.current=a,function(){b.current=null}}function qi(a,b,c){c=null!==c&&void 0!==c?c.concat([a]):null;return li(4,4,pi.bind(null,b,a),c)}function ri(){}function si(a,b){var c=Uh();b=void 0===b?null:b;var d=c.memoizedState;if(null!==d&&null!==b&&Mh(b,d[1]))return d[0];c.memoizedState=[a,b];return a}\nfunction ti(a,b){var c=Uh();b=void 0===b?null:b;var d=c.memoizedState;if(null!==d&&null!==b&&Mh(b,d[1]))return d[0];a=a();c.memoizedState=[a,b];return a}function ui(a,b,c){if(0===(Hh&21))return a.baseState&&(a.baseState=!1,dh=!0),a.memoizedState=c;He(c,b)||(c=yc(),M.lanes|=c,rh|=c,a.baseState=!0);return b}function vi(a,b){var c=C;C=0!==c&&4>c?c:4;a(!0);var d=Gh.transition;Gh.transition={};try{a(!1),b()}finally{C=c,Gh.transition=d}}function wi(){return Uh().memoizedState}\nfunction xi(a,b,c){var d=yi(a);c={lane:d,action:c,hasEagerState:!1,eagerState:null,next:null};if(zi(a))Ai(b,c);else if(c=hh(a,b,c,d),null!==c){var e=R();gi(c,a,d,e);Bi(c,b,d)}}\nfunction ii(a,b,c){var d=yi(a),e={lane:d,action:c,hasEagerState:!1,eagerState:null,next:null};if(zi(a))Ai(b,e);else{var f=a.alternate;if(0===a.lanes&&(null===f||0===f.lanes)&&(f=b.lastRenderedReducer,null!==f))try{var g=b.lastRenderedState,h=f(g,c);e.hasEagerState=!0;e.eagerState=h;if(He(h,g)){var k=b.interleaved;null===k?(e.next=e,gh(b)):(e.next=k.next,k.next=e);b.interleaved=e;return}}catch(l){}finally{}c=hh(a,b,e,d);null!==c&&(e=R(),gi(c,a,d,e),Bi(c,b,d))}}\nfunction zi(a){var b=a.alternate;return a===M||null!==b&&b===M}function Ai(a,b){Jh=Ih=!0;var c=a.pending;null===c?b.next=b:(b.next=c.next,c.next=b);a.pending=b}function Bi(a,b,c){if(0!==(c&4194240)){var d=b.lanes;d&=a.pendingLanes;c|=d;b.lanes=c;Cc(a,c)}}\nvar Rh={readContext:eh,useCallback:P,useContext:P,useEffect:P,useImperativeHandle:P,useInsertionEffect:P,useLayoutEffect:P,useMemo:P,useReducer:P,useRef:P,useState:P,useDebugValue:P,useDeferredValue:P,useTransition:P,useMutableSource:P,useSyncExternalStore:P,useId:P,unstable_isNewReconciler:!1},Oh={readContext:eh,useCallback:function(a,b){Th().memoizedState=[a,void 0===b?null:b];return a},useContext:eh,useEffect:mi,useImperativeHandle:function(a,b,c){c=null!==c&&void 0!==c?c.concat([a]):null;return ki(4194308,\n4,pi.bind(null,b,a),c)},useLayoutEffect:function(a,b){return ki(4194308,4,a,b)},useInsertionEffect:function(a,b){return ki(4,2,a,b)},useMemo:function(a,b){var c=Th();b=void 0===b?null:b;a=a();c.memoizedState=[a,b];return a},useReducer:function(a,b,c){var d=Th();b=void 0!==c?c(b):b;d.memoizedState=d.baseState=b;a={pending:null,interleaved:null,lanes:0,dispatch:null,lastRenderedReducer:a,lastRenderedState:b};d.queue=a;a=a.dispatch=xi.bind(null,M,a);return[d.memoizedState,a]},useRef:function(a){var b=\nTh();a={current:a};return b.memoizedState=a},useState:hi,useDebugValue:ri,useDeferredValue:function(a){return Th().memoizedState=a},useTransition:function(){var a=hi(!1),b=a[0];a=vi.bind(null,a[1]);Th().memoizedState=a;return[b,a]},useMutableSource:function(){},useSyncExternalStore:function(a,b,c){var d=M,e=Th();if(I){if(void 0===c)throw Error(p(407));c=c()}else{c=b();if(null===Q)throw Error(p(349));0!==(Hh&30)||di(d,b,c)}e.memoizedState=c;var f={value:c,getSnapshot:b};e.queue=f;mi(ai.bind(null,d,\nf,a),[a]);d.flags|=2048;bi(9,ci.bind(null,d,f,c,b),void 0,null);return c},useId:function(){var a=Th(),b=Q.identifierPrefix;if(I){var c=sg;var d=rg;c=(d&~(1<<32-oc(d)-1)).toString(32)+c;b=\":\"+b+\"R\"+c;c=Kh++;0<c&&(b+=\"H\"+c.toString(32));b+=\":\"}else c=Lh++,b=\":\"+b+\"r\"+c.toString(32)+\":\";return a.memoizedState=b},unstable_isNewReconciler:!1},Ph={readContext:eh,useCallback:si,useContext:eh,useEffect:$h,useImperativeHandle:qi,useInsertionEffect:ni,useLayoutEffect:oi,useMemo:ti,useReducer:Wh,useRef:ji,useState:function(){return Wh(Vh)},\nuseDebugValue:ri,useDeferredValue:function(a){var b=Uh();return ui(b,N.memoizedState,a)},useTransition:function(){var a=Wh(Vh)[0],b=Uh().memoizedState;return[a,b]},useMutableSource:Yh,useSyncExternalStore:Zh,useId:wi,unstable_isNewReconciler:!1},Qh={readContext:eh,useCallback:si,useContext:eh,useEffect:$h,useImperativeHandle:qi,useInsertionEffect:ni,useLayoutEffect:oi,useMemo:ti,useReducer:Xh,useRef:ji,useState:function(){return Xh(Vh)},useDebugValue:ri,useDeferredValue:function(a){var b=Uh();return null===\nN?b.memoizedState=a:ui(b,N.memoizedState,a)},useTransition:function(){var a=Xh(Vh)[0],b=Uh().memoizedState;return[a,b]},useMutableSource:Yh,useSyncExternalStore:Zh,useId:wi,unstable_isNewReconciler:!1};function Ci(a,b){if(a&&a.defaultProps){b=A({},b);a=a.defaultProps;for(var c in a)void 0===b[c]&&(b[c]=a[c]);return b}return b}function Di(a,b,c,d){b=a.memoizedState;c=c(d,b);c=null===c||void 0===c?b:A({},b,c);a.memoizedState=c;0===a.lanes&&(a.updateQueue.baseState=c)}\nvar Ei={isMounted:function(a){return(a=a._reactInternals)?Vb(a)===a:!1},enqueueSetState:function(a,b,c){a=a._reactInternals;var d=R(),e=yi(a),f=mh(d,e);f.payload=b;void 0!==c&&null!==c&&(f.callback=c);b=nh(a,f,e);null!==b&&(gi(b,a,e,d),oh(b,a,e))},enqueueReplaceState:function(a,b,c){a=a._reactInternals;var d=R(),e=yi(a),f=mh(d,e);f.tag=1;f.payload=b;void 0!==c&&null!==c&&(f.callback=c);b=nh(a,f,e);null!==b&&(gi(b,a,e,d),oh(b,a,e))},enqueueForceUpdate:function(a,b){a=a._reactInternals;var c=R(),d=\nyi(a),e=mh(c,d);e.tag=2;void 0!==b&&null!==b&&(e.callback=b);b=nh(a,e,d);null!==b&&(gi(b,a,d,c),oh(b,a,d))}};function Fi(a,b,c,d,e,f,g){a=a.stateNode;return\"function\"===typeof a.shouldComponentUpdate?a.shouldComponentUpdate(d,f,g):b.prototype&&b.prototype.isPureReactComponent?!Ie(c,d)||!Ie(e,f):!0}\nfunction Gi(a,b,c){var d=!1,e=Vf;var f=b.contextType;\"object\"===typeof f&&null!==f?f=eh(f):(e=Zf(b)?Xf:H.current,d=b.contextTypes,f=(d=null!==d&&void 0!==d)?Yf(a,e):Vf);b=new b(c,f);a.memoizedState=null!==b.state&&void 0!==b.state?b.state:null;b.updater=Ei;a.stateNode=b;b._reactInternals=a;d&&(a=a.stateNode,a.__reactInternalMemoizedUnmaskedChildContext=e,a.__reactInternalMemoizedMaskedChildContext=f);return b}\nfunction Hi(a,b,c,d){a=b.state;\"function\"===typeof b.componentWillReceiveProps&&b.componentWillReceiveProps(c,d);\"function\"===typeof b.UNSAFE_componentWillReceiveProps&&b.UNSAFE_componentWillReceiveProps(c,d);b.state!==a&&Ei.enqueueReplaceState(b,b.state,null)}\nfunction Ii(a,b,c,d){var e=a.stateNode;e.props=c;e.state=a.memoizedState;e.refs={};kh(a);var f=b.contextType;\"object\"===typeof f&&null!==f?e.context=eh(f):(f=Zf(b)?Xf:H.current,e.context=Yf(a,f));e.state=a.memoizedState;f=b.getDerivedStateFromProps;\"function\"===typeof f&&(Di(a,b,f,c),e.state=a.memoizedState);\"function\"===typeof b.getDerivedStateFromProps||\"function\"===typeof e.getSnapshotBeforeUpdate||\"function\"!==typeof e.UNSAFE_componentWillMount&&\"function\"!==typeof e.componentWillMount||(b=e.state,\n\"function\"===typeof e.componentWillMount&&e.componentWillMount(),\"function\"===typeof e.UNSAFE_componentWillMount&&e.UNSAFE_componentWillMount(),b!==e.state&&Ei.enqueueReplaceState(e,e.state,null),qh(a,c,e,d),e.state=a.memoizedState);\"function\"===typeof e.componentDidMount&&(a.flags|=4194308)}function Ji(a,b){try{var c=\"\",d=b;do c+=Pa(d),d=d.return;while(d);var e=c}catch(f){e=\"\\nError generating stack: \"+f.message+\"\\n\"+f.stack}return{value:a,source:b,stack:e,digest:null}}\nfunction Ki(a,b,c){return{value:a,source:null,stack:null!=c?c:null,digest:null!=b?b:null}}function Li(a,b){try{console.error(b.value)}catch(c){setTimeout(function(){throw c;})}}var Mi=\"function\"===typeof WeakMap?WeakMap:Map;function Ni(a,b,c){c=mh(-1,c);c.tag=3;c.payload={element:null};var d=b.value;c.callback=function(){Oi||(Oi=!0,Pi=d);Li(a,b)};return c}\nfunction Qi(a,b,c){c=mh(-1,c);c.tag=3;var d=a.type.getDerivedStateFromError;if(\"function\"===typeof d){var e=b.value;c.payload=function(){return d(e)};c.callback=function(){Li(a,b)}}var f=a.stateNode;null!==f&&\"function\"===typeof f.componentDidCatch&&(c.callback=function(){Li(a,b);\"function\"!==typeof d&&(null===Ri?Ri=new Set([this]):Ri.add(this));var c=b.stack;this.componentDidCatch(b.value,{componentStack:null!==c?c:\"\"})});return c}\nfunction Si(a,b,c){var d=a.pingCache;if(null===d){d=a.pingCache=new Mi;var e=new Set;d.set(b,e)}else e=d.get(b),void 0===e&&(e=new Set,d.set(b,e));e.has(c)||(e.add(c),a=Ti.bind(null,a,b,c),b.then(a,a))}function Ui(a){do{var b;if(b=13===a.tag)b=a.memoizedState,b=null!==b?null!==b.dehydrated?!0:!1:!0;if(b)return a;a=a.return}while(null!==a);return null}\nfunction Vi(a,b,c,d,e){if(0===(a.mode&1))return a===b?a.flags|=65536:(a.flags|=128,c.flags|=131072,c.flags&=-52805,1===c.tag&&(null===c.alternate?c.tag=17:(b=mh(-1,1),b.tag=2,nh(c,b,1))),c.lanes|=1),a;a.flags|=65536;a.lanes=e;return a}var Wi=ua.ReactCurrentOwner,dh=!1;function Xi(a,b,c,d){b.child=null===a?Vg(b,null,c,d):Ug(b,a.child,c,d)}\nfunction Yi(a,b,c,d,e){c=c.render;var f=b.ref;ch(b,e);d=Nh(a,b,c,d,f,e);c=Sh();if(null!==a&&!dh)return b.updateQueue=a.updateQueue,b.flags&=-2053,a.lanes&=~e,Zi(a,b,e);I&&c&&vg(b);b.flags|=1;Xi(a,b,d,e);return b.child}\nfunction $i(a,b,c,d,e){if(null===a){var f=c.type;if(\"function\"===typeof f&&!aj(f)&&void 0===f.defaultProps&&null===c.compare&&void 0===c.defaultProps)return b.tag=15,b.type=f,bj(a,b,f,d,e);a=Rg(c.type,null,d,b,b.mode,e);a.ref=b.ref;a.return=b;return b.child=a}f=a.child;if(0===(a.lanes&e)){var g=f.memoizedProps;c=c.compare;c=null!==c?c:Ie;if(c(g,d)&&a.ref===b.ref)return Zi(a,b,e)}b.flags|=1;a=Pg(f,d);a.ref=b.ref;a.return=b;return b.child=a}\nfunction bj(a,b,c,d,e){if(null!==a){var f=a.memoizedProps;if(Ie(f,d)&&a.ref===b.ref)if(dh=!1,b.pendingProps=d=f,0!==(a.lanes&e))0!==(a.flags&131072)&&(dh=!0);else return b.lanes=a.lanes,Zi(a,b,e)}return cj(a,b,c,d,e)}\nfunction dj(a,b,c){var d=b.pendingProps,e=d.children,f=null!==a?a.memoizedState:null;if(\"hidden\"===d.mode)if(0===(b.mode&1))b.memoizedState={baseLanes:0,cachePool:null,transitions:null},G(ej,fj),fj|=c;else{if(0===(c&1073741824))return a=null!==f?f.baseLanes|c:c,b.lanes=b.childLanes=1073741824,b.memoizedState={baseLanes:a,cachePool:null,transitions:null},b.updateQueue=null,G(ej,fj),fj|=a,null;b.memoizedState={baseLanes:0,cachePool:null,transitions:null};d=null!==f?f.baseLanes:c;G(ej,fj);fj|=d}else null!==\nf?(d=f.baseLanes|c,b.memoizedState=null):d=c,G(ej,fj),fj|=d;Xi(a,b,e,c);return b.child}function gj(a,b){var c=b.ref;if(null===a&&null!==c||null!==a&&a.ref!==c)b.flags|=512,b.flags|=2097152}function cj(a,b,c,d,e){var f=Zf(c)?Xf:H.current;f=Yf(b,f);ch(b,e);c=Nh(a,b,c,d,f,e);d=Sh();if(null!==a&&!dh)return b.updateQueue=a.updateQueue,b.flags&=-2053,a.lanes&=~e,Zi(a,b,e);I&&d&&vg(b);b.flags|=1;Xi(a,b,c,e);return b.child}\nfunction hj(a,b,c,d,e){if(Zf(c)){var f=!0;cg(b)}else f=!1;ch(b,e);if(null===b.stateNode)ij(a,b),Gi(b,c,d),Ii(b,c,d,e),d=!0;else if(null===a){var g=b.stateNode,h=b.memoizedProps;g.props=h;var k=g.context,l=c.contextType;\"object\"===typeof l&&null!==l?l=eh(l):(l=Zf(c)?Xf:H.current,l=Yf(b,l));var m=c.getDerivedStateFromProps,q=\"function\"===typeof m||\"function\"===typeof g.getSnapshotBeforeUpdate;q||\"function\"!==typeof g.UNSAFE_componentWillReceiveProps&&\"function\"!==typeof g.componentWillReceiveProps||\n(h!==d||k!==l)&&Hi(b,g,d,l);jh=!1;var r=b.memoizedState;g.state=r;qh(b,d,g,e);k=b.memoizedState;h!==d||r!==k||Wf.current||jh?(\"function\"===typeof m&&(Di(b,c,m,d),k=b.memoizedState),(h=jh||Fi(b,c,h,d,r,k,l))?(q||\"function\"!==typeof g.UNSAFE_componentWillMount&&\"function\"!==typeof g.componentWillMount||(\"function\"===typeof g.componentWillMount&&g.componentWillMount(),\"function\"===typeof g.UNSAFE_componentWillMount&&g.UNSAFE_componentWillMount()),\"function\"===typeof g.componentDidMount&&(b.flags|=4194308)):\n(\"function\"===typeof g.componentDidMount&&(b.flags|=4194308),b.memoizedProps=d,b.memoizedState=k),g.props=d,g.state=k,g.context=l,d=h):(\"function\"===typeof g.componentDidMount&&(b.flags|=4194308),d=!1)}else{g=b.stateNode;lh(a,b);h=b.memoizedProps;l=b.type===b.elementType?h:Ci(b.type,h);g.props=l;q=b.pendingProps;r=g.context;k=c.contextType;\"object\"===typeof k&&null!==k?k=eh(k):(k=Zf(c)?Xf:H.current,k=Yf(b,k));var y=c.getDerivedStateFromProps;(m=\"function\"===typeof y||\"function\"===typeof g.getSnapshotBeforeUpdate)||\n\"function\"!==typeof g.UNSAFE_componentWillReceiveProps&&\"function\"!==typeof g.componentWillReceiveProps||(h!==q||r!==k)&&Hi(b,g,d,k);jh=!1;r=b.memoizedState;g.state=r;qh(b,d,g,e);var n=b.memoizedState;h!==q||r!==n||Wf.current||jh?(\"function\"===typeof y&&(Di(b,c,y,d),n=b.memoizedState),(l=jh||Fi(b,c,l,d,r,n,k)||!1)?(m||\"function\"!==typeof g.UNSAFE_componentWillUpdate&&\"function\"!==typeof g.componentWillUpdate||(\"function\"===typeof g.componentWillUpdate&&g.componentWillUpdate(d,n,k),\"function\"===typeof g.UNSAFE_componentWillUpdate&&\ng.UNSAFE_componentWillUpdate(d,n,k)),\"function\"===typeof g.componentDidUpdate&&(b.flags|=4),\"function\"===typeof g.getSnapshotBeforeUpdate&&(b.flags|=1024)):(\"function\"!==typeof g.componentDidUpdate||h===a.memoizedProps&&r===a.memoizedState||(b.flags|=4),\"function\"!==typeof g.getSnapshotBeforeUpdate||h===a.memoizedProps&&r===a.memoizedState||(b.flags|=1024),b.memoizedProps=d,b.memoizedState=n),g.props=d,g.state=n,g.context=k,d=l):(\"function\"!==typeof g.componentDidUpdate||h===a.memoizedProps&&r===\na.memoizedState||(b.flags|=4),\"function\"!==typeof g.getSnapshotBeforeUpdate||h===a.memoizedProps&&r===a.memoizedState||(b.flags|=1024),d=!1)}return jj(a,b,c,d,f,e)}\nfunction jj(a,b,c,d,e,f){gj(a,b);var g=0!==(b.flags&128);if(!d&&!g)return e&&dg(b,c,!1),Zi(a,b,f);d=b.stateNode;Wi.current=b;var h=g&&\"function\"!==typeof c.getDerivedStateFromError?null:d.render();b.flags|=1;null!==a&&g?(b.child=Ug(b,a.child,null,f),b.child=Ug(b,null,h,f)):Xi(a,b,h,f);b.memoizedState=d.state;e&&dg(b,c,!0);return b.child}function kj(a){var b=a.stateNode;b.pendingContext?ag(a,b.pendingContext,b.pendingContext!==b.context):b.context&&ag(a,b.context,!1);yh(a,b.containerInfo)}\nfunction lj(a,b,c,d,e){Ig();Jg(e);b.flags|=256;Xi(a,b,c,d);return b.child}var mj={dehydrated:null,treeContext:null,retryLane:0};function nj(a){return{baseLanes:a,cachePool:null,transitions:null}}\nfunction oj(a,b,c){var d=b.pendingProps,e=L.current,f=!1,g=0!==(b.flags&128),h;(h=g)||(h=null!==a&&null===a.memoizedState?!1:0!==(e&2));if(h)f=!0,b.flags&=-129;else if(null===a||null!==a.memoizedState)e|=1;G(L,e&1);if(null===a){Eg(b);a=b.memoizedState;if(null!==a&&(a=a.dehydrated,null!==a))return 0===(b.mode&1)?b.lanes=1:\"$!\"===a.data?b.lanes=8:b.lanes=1073741824,null;g=d.children;a=d.fallback;return f?(d=b.mode,f=b.child,g={mode:\"hidden\",children:g},0===(d&1)&&null!==f?(f.childLanes=0,f.pendingProps=\ng):f=pj(g,d,0,null),a=Tg(a,d,c,null),f.return=b,a.return=b,f.sibling=a,b.child=f,b.child.memoizedState=nj(c),b.memoizedState=mj,a):qj(b,g)}e=a.memoizedState;if(null!==e&&(h=e.dehydrated,null!==h))return rj(a,b,g,d,h,e,c);if(f){f=d.fallback;g=b.mode;e=a.child;h=e.sibling;var k={mode:\"hidden\",children:d.children};0===(g&1)&&b.child!==e?(d=b.child,d.childLanes=0,d.pendingProps=k,b.deletions=null):(d=Pg(e,k),d.subtreeFlags=e.subtreeFlags&14680064);null!==h?f=Pg(h,f):(f=Tg(f,g,c,null),f.flags|=2);f.return=\nb;d.return=b;d.sibling=f;b.child=d;d=f;f=b.child;g=a.child.memoizedState;g=null===g?nj(c):{baseLanes:g.baseLanes|c,cachePool:null,transitions:g.transitions};f.memoizedState=g;f.childLanes=a.childLanes&~c;b.memoizedState=mj;return d}f=a.child;a=f.sibling;d=Pg(f,{mode:\"visible\",children:d.children});0===(b.mode&1)&&(d.lanes=c);d.return=b;d.sibling=null;null!==a&&(c=b.deletions,null===c?(b.deletions=[a],b.flags|=16):c.push(a));b.child=d;b.memoizedState=null;return d}\nfunction qj(a,b){b=pj({mode:\"visible\",children:b},a.mode,0,null);b.return=a;return a.child=b}function sj(a,b,c,d){null!==d&&Jg(d);Ug(b,a.child,null,c);a=qj(b,b.pendingProps.children);a.flags|=2;b.memoizedState=null;return a}\nfunction rj(a,b,c,d,e,f,g){if(c){if(b.flags&256)return b.flags&=-257,d=Ki(Error(p(422))),sj(a,b,g,d);if(null!==b.memoizedState)return b.child=a.child,b.flags|=128,null;f=d.fallback;e=b.mode;d=pj({mode:\"visible\",children:d.children},e,0,null);f=Tg(f,e,g,null);f.flags|=2;d.return=b;f.return=b;d.sibling=f;b.child=d;0!==(b.mode&1)&&Ug(b,a.child,null,g);b.child.memoizedState=nj(g);b.memoizedState=mj;return f}if(0===(b.mode&1))return sj(a,b,g,null);if(\"$!\"===e.data){d=e.nextSibling&&e.nextSibling.dataset;\nif(d)var h=d.dgst;d=h;f=Error(p(419));d=Ki(f,d,void 0);return sj(a,b,g,d)}h=0!==(g&a.childLanes);if(dh||h){d=Q;if(null!==d){switch(g&-g){case 4:e=2;break;case 16:e=8;break;case 64:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:case 4194304:case 8388608:case 16777216:case 33554432:case 67108864:e=32;break;case 536870912:e=268435456;break;default:e=0}e=0!==(e&(d.suspendedLanes|g))?0:e;\n0!==e&&e!==f.retryLane&&(f.retryLane=e,ih(a,e),gi(d,a,e,-1))}tj();d=Ki(Error(p(421)));return sj(a,b,g,d)}if(\"$?\"===e.data)return b.flags|=128,b.child=a.child,b=uj.bind(null,a),e._reactRetry=b,null;a=f.treeContext;yg=Lf(e.nextSibling);xg=b;I=!0;zg=null;null!==a&&(og[pg++]=rg,og[pg++]=sg,og[pg++]=qg,rg=a.id,sg=a.overflow,qg=b);b=qj(b,d.children);b.flags|=4096;return b}function vj(a,b,c){a.lanes|=b;var d=a.alternate;null!==d&&(d.lanes|=b);bh(a.return,b,c)}\nfunction wj(a,b,c,d,e){var f=a.memoizedState;null===f?a.memoizedState={isBackwards:b,rendering:null,renderingStartTime:0,last:d,tail:c,tailMode:e}:(f.isBackwards=b,f.rendering=null,f.renderingStartTime=0,f.last=d,f.tail=c,f.tailMode=e)}\nfunction xj(a,b,c){var d=b.pendingProps,e=d.revealOrder,f=d.tail;Xi(a,b,d.children,c);d=L.current;if(0!==(d&2))d=d&1|2,b.flags|=128;else{if(null!==a&&0!==(a.flags&128))a:for(a=b.child;null!==a;){if(13===a.tag)null!==a.memoizedState&&vj(a,c,b);else if(19===a.tag)vj(a,c,b);else if(null!==a.child){a.child.return=a;a=a.child;continue}if(a===b)break a;for(;null===a.sibling;){if(null===a.return||a.return===b)break a;a=a.return}a.sibling.return=a.return;a=a.sibling}d&=1}G(L,d);if(0===(b.mode&1))b.memoizedState=\nnull;else switch(e){case \"forwards\":c=b.child;for(e=null;null!==c;)a=c.alternate,null!==a&&null===Ch(a)&&(e=c),c=c.sibling;c=e;null===c?(e=b.child,b.child=null):(e=c.sibling,c.sibling=null);wj(b,!1,e,c,f);break;case \"backwards\":c=null;e=b.child;for(b.child=null;null!==e;){a=e.alternate;if(null!==a&&null===Ch(a)){b.child=e;break}a=e.sibling;e.sibling=c;c=e;e=a}wj(b,!0,c,null,f);break;case \"together\":wj(b,!1,null,null,void 0);break;default:b.memoizedState=null}return b.child}\nfunction ij(a,b){0===(b.mode&1)&&null!==a&&(a.alternate=null,b.alternate=null,b.flags|=2)}function Zi(a,b,c){null!==a&&(b.dependencies=a.dependencies);rh|=b.lanes;if(0===(c&b.childLanes))return null;if(null!==a&&b.child!==a.child)throw Error(p(153));if(null!==b.child){a=b.child;c=Pg(a,a.pendingProps);b.child=c;for(c.return=b;null!==a.sibling;)a=a.sibling,c=c.sibling=Pg(a,a.pendingProps),c.return=b;c.sibling=null}return b.child}\nfunction yj(a,b,c){switch(b.tag){case 3:kj(b);Ig();break;case 5:Ah(b);break;case 1:Zf(b.type)&&cg(b);break;case 4:yh(b,b.stateNode.containerInfo);break;case 10:var d=b.type._context,e=b.memoizedProps.value;G(Wg,d._currentValue);d._currentValue=e;break;case 13:d=b.memoizedState;if(null!==d){if(null!==d.dehydrated)return G(L,L.current&1),b.flags|=128,null;if(0!==(c&b.child.childLanes))return oj(a,b,c);G(L,L.current&1);a=Zi(a,b,c);return null!==a?a.sibling:null}G(L,L.current&1);break;case 19:d=0!==(c&\nb.childLanes);if(0!==(a.flags&128)){if(d)return xj(a,b,c);b.flags|=128}e=b.memoizedState;null!==e&&(e.rendering=null,e.tail=null,e.lastEffect=null);G(L,L.current);if(d)break;else return null;case 22:case 23:return b.lanes=0,dj(a,b,c)}return Zi(a,b,c)}var zj,Aj,Bj,Cj;\nzj=function(a,b){for(var c=b.child;null!==c;){if(5===c.tag||6===c.tag)a.appendChild(c.stateNode);else if(4!==c.tag&&null!==c.child){c.child.return=c;c=c.child;continue}if(c===b)break;for(;null===c.sibling;){if(null===c.return||c.return===b)return;c=c.return}c.sibling.return=c.return;c=c.sibling}};Aj=function(){};\nBj=function(a,b,c,d){var e=a.memoizedProps;if(e!==d){a=b.stateNode;xh(uh.current);var f=null;switch(c){case \"input\":e=Ya(a,e);d=Ya(a,d);f=[];break;case \"select\":e=A({},e,{value:void 0});d=A({},d,{value:void 0});f=[];break;case \"textarea\":e=gb(a,e);d=gb(a,d);f=[];break;default:\"function\"!==typeof e.onClick&&\"function\"===typeof d.onClick&&(a.onclick=Bf)}ub(c,d);var g;c=null;for(l in e)if(!d.hasOwnProperty(l)&&e.hasOwnProperty(l)&&null!=e[l])if(\"style\"===l){var h=e[l];for(g in h)h.hasOwnProperty(g)&&\n(c||(c={}),c[g]=\"\")}else\"dangerouslySetInnerHTML\"!==l&&\"children\"!==l&&\"suppressContentEditableWarning\"!==l&&\"suppressHydrationWarning\"!==l&&\"autoFocus\"!==l&&(ea.hasOwnProperty(l)?f||(f=[]):(f=f||[]).push(l,null));for(l in d){var k=d[l];h=null!=e?e[l]:void 0;if(d.hasOwnProperty(l)&&k!==h&&(null!=k||null!=h))if(\"style\"===l)if(h){for(g in h)!h.hasOwnProperty(g)||k&&k.hasOwnProperty(g)||(c||(c={}),c[g]=\"\");for(g in k)k.hasOwnProperty(g)&&h[g]!==k[g]&&(c||(c={}),c[g]=k[g])}else c||(f||(f=[]),f.push(l,\nc)),c=k;else\"dangerouslySetInnerHTML\"===l?(k=k?k.__html:void 0,h=h?h.__html:void 0,null!=k&&h!==k&&(f=f||[]).push(l,k)):\"children\"===l?\"string\"!==typeof k&&\"number\"!==typeof k||(f=f||[]).push(l,\"\"+k):\"suppressContentEditableWarning\"!==l&&\"suppressHydrationWarning\"!==l&&(ea.hasOwnProperty(l)?(null!=k&&\"onScroll\"===l&&D(\"scroll\",a),f||h===k||(f=[])):(f=f||[]).push(l,k))}c&&(f=f||[]).push(\"style\",c);var l=f;if(b.updateQueue=l)b.flags|=4}};Cj=function(a,b,c,d){c!==d&&(b.flags|=4)};\nfunction Dj(a,b){if(!I)switch(a.tailMode){case \"hidden\":b=a.tail;for(var c=null;null!==b;)null!==b.alternate&&(c=b),b=b.sibling;null===c?a.tail=null:c.sibling=null;break;case \"collapsed\":c=a.tail;for(var d=null;null!==c;)null!==c.alternate&&(d=c),c=c.sibling;null===d?b||null===a.tail?a.tail=null:a.tail.sibling=null:d.sibling=null}}\nfunction S(a){var b=null!==a.alternate&&a.alternate.child===a.child,c=0,d=0;if(b)for(var e=a.child;null!==e;)c|=e.lanes|e.childLanes,d|=e.subtreeFlags&14680064,d|=e.flags&14680064,e.return=a,e=e.sibling;else for(e=a.child;null!==e;)c|=e.lanes|e.childLanes,d|=e.subtreeFlags,d|=e.flags,e.return=a,e=e.sibling;a.subtreeFlags|=d;a.childLanes=c;return b}\nfunction Ej(a,b,c){var d=b.pendingProps;wg(b);switch(b.tag){case 2:case 16:case 15:case 0:case 11:case 7:case 8:case 12:case 9:case 14:return S(b),null;case 1:return Zf(b.type)&&$f(),S(b),null;case 3:d=b.stateNode;zh();E(Wf);E(H);Eh();d.pendingContext&&(d.context=d.pendingContext,d.pendingContext=null);if(null===a||null===a.child)Gg(b)?b.flags|=4:null===a||a.memoizedState.isDehydrated&&0===(b.flags&256)||(b.flags|=1024,null!==zg&&(Fj(zg),zg=null));Aj(a,b);S(b);return null;case 5:Bh(b);var e=xh(wh.current);\nc=b.type;if(null!==a&&null!=b.stateNode)Bj(a,b,c,d,e),a.ref!==b.ref&&(b.flags|=512,b.flags|=2097152);else{if(!d){if(null===b.stateNode)throw Error(p(166));S(b);return null}a=xh(uh.current);if(Gg(b)){d=b.stateNode;c=b.type;var f=b.memoizedProps;d[Of]=b;d[Pf]=f;a=0!==(b.mode&1);switch(c){case \"dialog\":D(\"cancel\",d);D(\"close\",d);break;case \"iframe\":case \"object\":case \"embed\":D(\"load\",d);break;case \"video\":case \"audio\":for(e=0;e<lf.length;e++)D(lf[e],d);break;case \"source\":D(\"error\",d);break;case \"img\":case \"image\":case \"link\":D(\"error\",\nd);D(\"load\",d);break;case \"details\":D(\"toggle\",d);break;case \"input\":Za(d,f);D(\"invalid\",d);break;case \"select\":d._wrapperState={wasMultiple:!!f.multiple};D(\"invalid\",d);break;case \"textarea\":hb(d,f),D(\"invalid\",d)}ub(c,f);e=null;for(var g in f)if(f.hasOwnProperty(g)){var h=f[g];\"children\"===g?\"string\"===typeof h?d.textContent!==h&&(!0!==f.suppressHydrationWarning&&Af(d.textContent,h,a),e=[\"children\",h]):\"number\"===typeof h&&d.textContent!==\"\"+h&&(!0!==f.suppressHydrationWarning&&Af(d.textContent,\nh,a),e=[\"children\",\"\"+h]):ea.hasOwnProperty(g)&&null!=h&&\"onScroll\"===g&&D(\"scroll\",d)}switch(c){case \"input\":Va(d);db(d,f,!0);break;case \"textarea\":Va(d);jb(d);break;case \"select\":case \"option\":break;default:\"function\"===typeof f.onClick&&(d.onclick=Bf)}d=e;b.updateQueue=d;null!==d&&(b.flags|=4)}else{g=9===e.nodeType?e:e.ownerDocument;\"http://www.w3.org/1999/xhtml\"===a&&(a=kb(c));\"http://www.w3.org/1999/xhtml\"===a?\"script\"===c?(a=g.createElement(\"div\"),a.innerHTML=\"<script>\\x3c/script>\",a=a.removeChild(a.firstChild)):\n\"string\"===typeof d.is?a=g.createElement(c,{is:d.is}):(a=g.createElement(c),\"select\"===c&&(g=a,d.multiple?g.multiple=!0:d.size&&(g.size=d.size))):a=g.createElementNS(a,c);a[Of]=b;a[Pf]=d;zj(a,b,!1,!1);b.stateNode=a;a:{g=vb(c,d);switch(c){case \"dialog\":D(\"cancel\",a);D(\"close\",a);e=d;break;case \"iframe\":case \"object\":case \"embed\":D(\"load\",a);e=d;break;case \"video\":case \"audio\":for(e=0;e<lf.length;e++)D(lf[e],a);e=d;break;case \"source\":D(\"error\",a);e=d;break;case \"img\":case \"image\":case \"link\":D(\"error\",\na);D(\"load\",a);e=d;break;case \"details\":D(\"toggle\",a);e=d;break;case \"input\":Za(a,d);e=Ya(a,d);D(\"invalid\",a);break;case \"option\":e=d;break;case \"select\":a._wrapperState={wasMultiple:!!d.multiple};e=A({},d,{value:void 0});D(\"invalid\",a);break;case \"textarea\":hb(a,d);e=gb(a,d);D(\"invalid\",a);break;default:e=d}ub(c,e);h=e;for(f in h)if(h.hasOwnProperty(f)){var k=h[f];\"style\"===f?sb(a,k):\"dangerouslySetInnerHTML\"===f?(k=k?k.__html:void 0,null!=k&&nb(a,k)):\"children\"===f?\"string\"===typeof k?(\"textarea\"!==\nc||\"\"!==k)&&ob(a,k):\"number\"===typeof k&&ob(a,\"\"+k):\"suppressContentEditableWarning\"!==f&&\"suppressHydrationWarning\"!==f&&\"autoFocus\"!==f&&(ea.hasOwnProperty(f)?null!=k&&\"onScroll\"===f&&D(\"scroll\",a):null!=k&&ta(a,f,k,g))}switch(c){case \"input\":Va(a);db(a,d,!1);break;case \"textarea\":Va(a);jb(a);break;case \"option\":null!=d.value&&a.setAttribute(\"value\",\"\"+Sa(d.value));break;case \"select\":a.multiple=!!d.multiple;f=d.value;null!=f?fb(a,!!d.multiple,f,!1):null!=d.defaultValue&&fb(a,!!d.multiple,d.defaultValue,\n!0);break;default:\"function\"===typeof e.onClick&&(a.onclick=Bf)}switch(c){case \"button\":case \"input\":case \"select\":case \"textarea\":d=!!d.autoFocus;break a;case \"img\":d=!0;break a;default:d=!1}}d&&(b.flags|=4)}null!==b.ref&&(b.flags|=512,b.flags|=2097152)}S(b);return null;case 6:if(a&&null!=b.stateNode)Cj(a,b,a.memoizedProps,d);else{if(\"string\"!==typeof d&&null===b.stateNode)throw Error(p(166));c=xh(wh.current);xh(uh.current);if(Gg(b)){d=b.stateNode;c=b.memoizedProps;d[Of]=b;if(f=d.nodeValue!==c)if(a=\nxg,null!==a)switch(a.tag){case 3:Af(d.nodeValue,c,0!==(a.mode&1));break;case 5:!0!==a.memoizedProps.suppressHydrationWarning&&Af(d.nodeValue,c,0!==(a.mode&1))}f&&(b.flags|=4)}else d=(9===c.nodeType?c:c.ownerDocument).createTextNode(d),d[Of]=b,b.stateNode=d}S(b);return null;case 13:E(L);d=b.memoizedState;if(null===a||null!==a.memoizedState&&null!==a.memoizedState.dehydrated){if(I&&null!==yg&&0!==(b.mode&1)&&0===(b.flags&128))Hg(),Ig(),b.flags|=98560,f=!1;else if(f=Gg(b),null!==d&&null!==d.dehydrated){if(null===\na){if(!f)throw Error(p(318));f=b.memoizedState;f=null!==f?f.dehydrated:null;if(!f)throw Error(p(317));f[Of]=b}else Ig(),0===(b.flags&128)&&(b.memoizedState=null),b.flags|=4;S(b);f=!1}else null!==zg&&(Fj(zg),zg=null),f=!0;if(!f)return b.flags&65536?b:null}if(0!==(b.flags&128))return b.lanes=c,b;d=null!==d;d!==(null!==a&&null!==a.memoizedState)&&d&&(b.child.flags|=8192,0!==(b.mode&1)&&(null===a||0!==(L.current&1)?0===T&&(T=3):tj()));null!==b.updateQueue&&(b.flags|=4);S(b);return null;case 4:return zh(),\nAj(a,b),null===a&&sf(b.stateNode.containerInfo),S(b),null;case 10:return ah(b.type._context),S(b),null;case 17:return Zf(b.type)&&$f(),S(b),null;case 19:E(L);f=b.memoizedState;if(null===f)return S(b),null;d=0!==(b.flags&128);g=f.rendering;if(null===g)if(d)Dj(f,!1);else{if(0!==T||null!==a&&0!==(a.flags&128))for(a=b.child;null!==a;){g=Ch(a);if(null!==g){b.flags|=128;Dj(f,!1);d=g.updateQueue;null!==d&&(b.updateQueue=d,b.flags|=4);b.subtreeFlags=0;d=c;for(c=b.child;null!==c;)f=c,a=d,f.flags&=14680066,\ng=f.alternate,null===g?(f.childLanes=0,f.lanes=a,f.child=null,f.subtreeFlags=0,f.memoizedProps=null,f.memoizedState=null,f.updateQueue=null,f.dependencies=null,f.stateNode=null):(f.childLanes=g.childLanes,f.lanes=g.lanes,f.child=g.child,f.subtreeFlags=0,f.deletions=null,f.memoizedProps=g.memoizedProps,f.memoizedState=g.memoizedState,f.updateQueue=g.updateQueue,f.type=g.type,a=g.dependencies,f.dependencies=null===a?null:{lanes:a.lanes,firstContext:a.firstContext}),c=c.sibling;G(L,L.current&1|2);return b.child}a=\na.sibling}null!==f.tail&&B()>Gj&&(b.flags|=128,d=!0,Dj(f,!1),b.lanes=4194304)}else{if(!d)if(a=Ch(g),null!==a){if(b.flags|=128,d=!0,c=a.updateQueue,null!==c&&(b.updateQueue=c,b.flags|=4),Dj(f,!0),null===f.tail&&\"hidden\"===f.tailMode&&!g.alternate&&!I)return S(b),null}else 2*B()-f.renderingStartTime>Gj&&1073741824!==c&&(b.flags|=128,d=!0,Dj(f,!1),b.lanes=4194304);f.isBackwards?(g.sibling=b.child,b.child=g):(c=f.last,null!==c?c.sibling=g:b.child=g,f.last=g)}if(null!==f.tail)return b=f.tail,f.rendering=\nb,f.tail=b.sibling,f.renderingStartTime=B(),b.sibling=null,c=L.current,G(L,d?c&1|2:c&1),b;S(b);return null;case 22:case 23:return Hj(),d=null!==b.memoizedState,null!==a&&null!==a.memoizedState!==d&&(b.flags|=8192),d&&0!==(b.mode&1)?0!==(fj&1073741824)&&(S(b),b.subtreeFlags&6&&(b.flags|=8192)):S(b),null;case 24:return null;case 25:return null}throw Error(p(156,b.tag));}\nfunction Ij(a,b){wg(b);switch(b.tag){case 1:return Zf(b.type)&&$f(),a=b.flags,a&65536?(b.flags=a&-65537|128,b):null;case 3:return zh(),E(Wf),E(H),Eh(),a=b.flags,0!==(a&65536)&&0===(a&128)?(b.flags=a&-65537|128,b):null;case 5:return Bh(b),null;case 13:E(L);a=b.memoizedState;if(null!==a&&null!==a.dehydrated){if(null===b.alternate)throw Error(p(340));Ig()}a=b.flags;return a&65536?(b.flags=a&-65537|128,b):null;case 19:return E(L),null;case 4:return zh(),null;case 10:return ah(b.type._context),null;case 22:case 23:return Hj(),\nnull;case 24:return null;default:return null}}var Jj=!1,U=!1,Kj=\"function\"===typeof WeakSet?WeakSet:Set,V=null;function Lj(a,b){var c=a.ref;if(null!==c)if(\"function\"===typeof c)try{c(null)}catch(d){W(a,b,d)}else c.current=null}function Mj(a,b,c){try{c()}catch(d){W(a,b,d)}}var Nj=!1;\nfunction Oj(a,b){Cf=dd;a=Me();if(Ne(a)){if(\"selectionStart\"in a)var c={start:a.selectionStart,end:a.selectionEnd};else a:{c=(c=a.ownerDocument)&&c.defaultView||window;var d=c.getSelection&&c.getSelection();if(d&&0!==d.rangeCount){c=d.anchorNode;var e=d.anchorOffset,f=d.focusNode;d=d.focusOffset;try{c.nodeType,f.nodeType}catch(F){c=null;break a}var g=0,h=-1,k=-1,l=0,m=0,q=a,r=null;b:for(;;){for(var y;;){q!==c||0!==e&&3!==q.nodeType||(h=g+e);q!==f||0!==d&&3!==q.nodeType||(k=g+d);3===q.nodeType&&(g+=\nq.nodeValue.length);if(null===(y=q.firstChild))break;r=q;q=y}for(;;){if(q===a)break b;r===c&&++l===e&&(h=g);r===f&&++m===d&&(k=g);if(null!==(y=q.nextSibling))break;q=r;r=q.parentNode}q=y}c=-1===h||-1===k?null:{start:h,end:k}}else c=null}c=c||{start:0,end:0}}else c=null;Df={focusedElem:a,selectionRange:c};dd=!1;for(V=b;null!==V;)if(b=V,a=b.child,0!==(b.subtreeFlags&1028)&&null!==a)a.return=b,V=a;else for(;null!==V;){b=V;try{var n=b.alternate;if(0!==(b.flags&1024))switch(b.tag){case 0:case 11:case 15:break;\ncase 1:if(null!==n){var t=n.memoizedProps,J=n.memoizedState,x=b.stateNode,w=x.getSnapshotBeforeUpdate(b.elementType===b.type?t:Ci(b.type,t),J);x.__reactInternalSnapshotBeforeUpdate=w}break;case 3:var u=b.stateNode.containerInfo;1===u.nodeType?u.textContent=\"\":9===u.nodeType&&u.documentElement&&u.removeChild(u.documentElement);break;case 5:case 6:case 4:case 17:break;default:throw Error(p(163));}}catch(F){W(b,b.return,F)}a=b.sibling;if(null!==a){a.return=b.return;V=a;break}V=b.return}n=Nj;Nj=!1;return n}\nfunction Pj(a,b,c){var d=b.updateQueue;d=null!==d?d.lastEffect:null;if(null!==d){var e=d=d.next;do{if((e.tag&a)===a){var f=e.destroy;e.destroy=void 0;void 0!==f&&Mj(b,c,f)}e=e.next}while(e!==d)}}function Qj(a,b){b=b.updateQueue;b=null!==b?b.lastEffect:null;if(null!==b){var c=b=b.next;do{if((c.tag&a)===a){var d=c.create;c.destroy=d()}c=c.next}while(c!==b)}}function Rj(a){var b=a.ref;if(null!==b){var c=a.stateNode;switch(a.tag){case 5:a=c;break;default:a=c}\"function\"===typeof b?b(a):b.current=a}}\nfunction Sj(a){var b=a.alternate;null!==b&&(a.alternate=null,Sj(b));a.child=null;a.deletions=null;a.sibling=null;5===a.tag&&(b=a.stateNode,null!==b&&(delete b[Of],delete b[Pf],delete b[of],delete b[Qf],delete b[Rf]));a.stateNode=null;a.return=null;a.dependencies=null;a.memoizedProps=null;a.memoizedState=null;a.pendingProps=null;a.stateNode=null;a.updateQueue=null}function Tj(a){return 5===a.tag||3===a.tag||4===a.tag}\nfunction Uj(a){a:for(;;){for(;null===a.sibling;){if(null===a.return||Tj(a.return))return null;a=a.return}a.sibling.return=a.return;for(a=a.sibling;5!==a.tag&&6!==a.tag&&18!==a.tag;){if(a.flags&2)continue a;if(null===a.child||4===a.tag)continue a;else a.child.return=a,a=a.child}if(!(a.flags&2))return a.stateNode}}\nfunction Vj(a,b,c){var d=a.tag;if(5===d||6===d)a=a.stateNode,b?8===c.nodeType?c.parentNode.insertBefore(a,b):c.insertBefore(a,b):(8===c.nodeType?(b=c.parentNode,b.insertBefore(a,c)):(b=c,b.appendChild(a)),c=c._reactRootContainer,null!==c&&void 0!==c||null!==b.onclick||(b.onclick=Bf));else if(4!==d&&(a=a.child,null!==a))for(Vj(a,b,c),a=a.sibling;null!==a;)Vj(a,b,c),a=a.sibling}\nfunction Wj(a,b,c){var d=a.tag;if(5===d||6===d)a=a.stateNode,b?c.insertBefore(a,b):c.appendChild(a);else if(4!==d&&(a=a.child,null!==a))for(Wj(a,b,c),a=a.sibling;null!==a;)Wj(a,b,c),a=a.sibling}var X=null,Xj=!1;function Yj(a,b,c){for(c=c.child;null!==c;)Zj(a,b,c),c=c.sibling}\nfunction Zj(a,b,c){if(lc&&\"function\"===typeof lc.onCommitFiberUnmount)try{lc.onCommitFiberUnmount(kc,c)}catch(h){}switch(c.tag){case 5:U||Lj(c,b);case 6:var d=X,e=Xj;X=null;Yj(a,b,c);X=d;Xj=e;null!==X&&(Xj?(a=X,c=c.stateNode,8===a.nodeType?a.parentNode.removeChild(c):a.removeChild(c)):X.removeChild(c.stateNode));break;case 18:null!==X&&(Xj?(a=X,c=c.stateNode,8===a.nodeType?Kf(a.parentNode,c):1===a.nodeType&&Kf(a,c),bd(a)):Kf(X,c.stateNode));break;case 4:d=X;e=Xj;X=c.stateNode.containerInfo;Xj=!0;\nYj(a,b,c);X=d;Xj=e;break;case 0:case 11:case 14:case 15:if(!U&&(d=c.updateQueue,null!==d&&(d=d.lastEffect,null!==d))){e=d=d.next;do{var f=e,g=f.destroy;f=f.tag;void 0!==g&&(0!==(f&2)?Mj(c,b,g):0!==(f&4)&&Mj(c,b,g));e=e.next}while(e!==d)}Yj(a,b,c);break;case 1:if(!U&&(Lj(c,b),d=c.stateNode,\"function\"===typeof d.componentWillUnmount))try{d.props=c.memoizedProps,d.state=c.memoizedState,d.componentWillUnmount()}catch(h){W(c,b,h)}Yj(a,b,c);break;case 21:Yj(a,b,c);break;case 22:c.mode&1?(U=(d=U)||null!==\nc.memoizedState,Yj(a,b,c),U=d):Yj(a,b,c);break;default:Yj(a,b,c)}}function ak(a){var b=a.updateQueue;if(null!==b){a.updateQueue=null;var c=a.stateNode;null===c&&(c=a.stateNode=new Kj);b.forEach(function(b){var d=bk.bind(null,a,b);c.has(b)||(c.add(b),b.then(d,d))})}}\nfunction ck(a,b){var c=b.deletions;if(null!==c)for(var d=0;d<c.length;d++){var e=c[d];try{var f=a,g=b,h=g;a:for(;null!==h;){switch(h.tag){case 5:X=h.stateNode;Xj=!1;break a;case 3:X=h.stateNode.containerInfo;Xj=!0;break a;case 4:X=h.stateNode.containerInfo;Xj=!0;break a}h=h.return}if(null===X)throw Error(p(160));Zj(f,g,e);X=null;Xj=!1;var k=e.alternate;null!==k&&(k.return=null);e.return=null}catch(l){W(e,b,l)}}if(b.subtreeFlags&12854)for(b=b.child;null!==b;)dk(b,a),b=b.sibling}\nfunction dk(a,b){var c=a.alternate,d=a.flags;switch(a.tag){case 0:case 11:case 14:case 15:ck(b,a);ek(a);if(d&4){try{Pj(3,a,a.return),Qj(3,a)}catch(t){W(a,a.return,t)}try{Pj(5,a,a.return)}catch(t){W(a,a.return,t)}}break;case 1:ck(b,a);ek(a);d&512&&null!==c&&Lj(c,c.return);break;case 5:ck(b,a);ek(a);d&512&&null!==c&&Lj(c,c.return);if(a.flags&32){var e=a.stateNode;try{ob(e,\"\")}catch(t){W(a,a.return,t)}}if(d&4&&(e=a.stateNode,null!=e)){var f=a.memoizedProps,g=null!==c?c.memoizedProps:f,h=a.type,k=a.updateQueue;\na.updateQueue=null;if(null!==k)try{\"input\"===h&&\"radio\"===f.type&&null!=f.name&&ab(e,f);vb(h,g);var l=vb(h,f);for(g=0;g<k.length;g+=2){var m=k[g],q=k[g+1];\"style\"===m?sb(e,q):\"dangerouslySetInnerHTML\"===m?nb(e,q):\"children\"===m?ob(e,q):ta(e,m,q,l)}switch(h){case \"input\":bb(e,f);break;case \"textarea\":ib(e,f);break;case \"select\":var r=e._wrapperState.wasMultiple;e._wrapperState.wasMultiple=!!f.multiple;var y=f.value;null!=y?fb(e,!!f.multiple,y,!1):r!==!!f.multiple&&(null!=f.defaultValue?fb(e,!!f.multiple,\nf.defaultValue,!0):fb(e,!!f.multiple,f.multiple?[]:\"\",!1))}e[Pf]=f}catch(t){W(a,a.return,t)}}break;case 6:ck(b,a);ek(a);if(d&4){if(null===a.stateNode)throw Error(p(162));e=a.stateNode;f=a.memoizedProps;try{e.nodeValue=f}catch(t){W(a,a.return,t)}}break;case 3:ck(b,a);ek(a);if(d&4&&null!==c&&c.memoizedState.isDehydrated)try{bd(b.containerInfo)}catch(t){W(a,a.return,t)}break;case 4:ck(b,a);ek(a);break;case 13:ck(b,a);ek(a);e=a.child;e.flags&8192&&(f=null!==e.memoizedState,e.stateNode.isHidden=f,!f||\nnull!==e.alternate&&null!==e.alternate.memoizedState||(fk=B()));d&4&&ak(a);break;case 22:m=null!==c&&null!==c.memoizedState;a.mode&1?(U=(l=U)||m,ck(b,a),U=l):ck(b,a);ek(a);if(d&8192){l=null!==a.memoizedState;if((a.stateNode.isHidden=l)&&!m&&0!==(a.mode&1))for(V=a,m=a.child;null!==m;){for(q=V=m;null!==V;){r=V;y=r.child;switch(r.tag){case 0:case 11:case 14:case 15:Pj(4,r,r.return);break;case 1:Lj(r,r.return);var n=r.stateNode;if(\"function\"===typeof n.componentWillUnmount){d=r;c=r.return;try{b=d,n.props=\nb.memoizedProps,n.state=b.memoizedState,n.componentWillUnmount()}catch(t){W(d,c,t)}}break;case 5:Lj(r,r.return);break;case 22:if(null!==r.memoizedState){gk(q);continue}}null!==y?(y.return=r,V=y):gk(q)}m=m.sibling}a:for(m=null,q=a;;){if(5===q.tag){if(null===m){m=q;try{e=q.stateNode,l?(f=e.style,\"function\"===typeof f.setProperty?f.setProperty(\"display\",\"none\",\"important\"):f.display=\"none\"):(h=q.stateNode,k=q.memoizedProps.style,g=void 0!==k&&null!==k&&k.hasOwnProperty(\"display\")?k.display:null,h.style.display=\nrb(\"display\",g))}catch(t){W(a,a.return,t)}}}else if(6===q.tag){if(null===m)try{q.stateNode.nodeValue=l?\"\":q.memoizedProps}catch(t){W(a,a.return,t)}}else if((22!==q.tag&&23!==q.tag||null===q.memoizedState||q===a)&&null!==q.child){q.child.return=q;q=q.child;continue}if(q===a)break a;for(;null===q.sibling;){if(null===q.return||q.return===a)break a;m===q&&(m=null);q=q.return}m===q&&(m=null);q.sibling.return=q.return;q=q.sibling}}break;case 19:ck(b,a);ek(a);d&4&&ak(a);break;case 21:break;default:ck(b,\na),ek(a)}}function ek(a){var b=a.flags;if(b&2){try{a:{for(var c=a.return;null!==c;){if(Tj(c)){var d=c;break a}c=c.return}throw Error(p(160));}switch(d.tag){case 5:var e=d.stateNode;d.flags&32&&(ob(e,\"\"),d.flags&=-33);var f=Uj(a);Wj(a,f,e);break;case 3:case 4:var g=d.stateNode.containerInfo,h=Uj(a);Vj(a,h,g);break;default:throw Error(p(161));}}catch(k){W(a,a.return,k)}a.flags&=-3}b&4096&&(a.flags&=-4097)}function hk(a,b,c){V=a;ik(a,b,c)}\nfunction ik(a,b,c){for(var d=0!==(a.mode&1);null!==V;){var e=V,f=e.child;if(22===e.tag&&d){var g=null!==e.memoizedState||Jj;if(!g){var h=e.alternate,k=null!==h&&null!==h.memoizedState||U;h=Jj;var l=U;Jj=g;if((U=k)&&!l)for(V=e;null!==V;)g=V,k=g.child,22===g.tag&&null!==g.memoizedState?jk(e):null!==k?(k.return=g,V=k):jk(e);for(;null!==f;)V=f,ik(f,b,c),f=f.sibling;V=e;Jj=h;U=l}kk(a,b,c)}else 0!==(e.subtreeFlags&8772)&&null!==f?(f.return=e,V=f):kk(a,b,c)}}\nfunction kk(a){for(;null!==V;){var b=V;if(0!==(b.flags&8772)){var c=b.alternate;try{if(0!==(b.flags&8772))switch(b.tag){case 0:case 11:case 15:U||Qj(5,b);break;case 1:var d=b.stateNode;if(b.flags&4&&!U)if(null===c)d.componentDidMount();else{var e=b.elementType===b.type?c.memoizedProps:Ci(b.type,c.memoizedProps);d.componentDidUpdate(e,c.memoizedState,d.__reactInternalSnapshotBeforeUpdate)}var f=b.updateQueue;null!==f&&sh(b,f,d);break;case 3:var g=b.updateQueue;if(null!==g){c=null;if(null!==b.child)switch(b.child.tag){case 5:c=\nb.child.stateNode;break;case 1:c=b.child.stateNode}sh(b,g,c)}break;case 5:var h=b.stateNode;if(null===c&&b.flags&4){c=h;var k=b.memoizedProps;switch(b.type){case \"button\":case \"input\":case \"select\":case \"textarea\":k.autoFocus&&c.focus();break;case \"img\":k.src&&(c.src=k.src)}}break;case 6:break;case 4:break;case 12:break;case 13:if(null===b.memoizedState){var l=b.alternate;if(null!==l){var m=l.memoizedState;if(null!==m){var q=m.dehydrated;null!==q&&bd(q)}}}break;case 19:case 17:case 21:case 22:case 23:case 25:break;\ndefault:throw Error(p(163));}U||b.flags&512&&Rj(b)}catch(r){W(b,b.return,r)}}if(b===a){V=null;break}c=b.sibling;if(null!==c){c.return=b.return;V=c;break}V=b.return}}function gk(a){for(;null!==V;){var b=V;if(b===a){V=null;break}var c=b.sibling;if(null!==c){c.return=b.return;V=c;break}V=b.return}}\nfunction jk(a){for(;null!==V;){var b=V;try{switch(b.tag){case 0:case 11:case 15:var c=b.return;try{Qj(4,b)}catch(k){W(b,c,k)}break;case 1:var d=b.stateNode;if(\"function\"===typeof d.componentDidMount){var e=b.return;try{d.componentDidMount()}catch(k){W(b,e,k)}}var f=b.return;try{Rj(b)}catch(k){W(b,f,k)}break;case 5:var g=b.return;try{Rj(b)}catch(k){W(b,g,k)}}}catch(k){W(b,b.return,k)}if(b===a){V=null;break}var h=b.sibling;if(null!==h){h.return=b.return;V=h;break}V=b.return}}\nvar lk=Math.ceil,mk=ua.ReactCurrentDispatcher,nk=ua.ReactCurrentOwner,ok=ua.ReactCurrentBatchConfig,K=0,Q=null,Y=null,Z=0,fj=0,ej=Uf(0),T=0,pk=null,rh=0,qk=0,rk=0,sk=null,tk=null,fk=0,Gj=Infinity,uk=null,Oi=!1,Pi=null,Ri=null,vk=!1,wk=null,xk=0,yk=0,zk=null,Ak=-1,Bk=0;function R(){return 0!==(K&6)?B():-1!==Ak?Ak:Ak=B()}\nfunction yi(a){if(0===(a.mode&1))return 1;if(0!==(K&2)&&0!==Z)return Z&-Z;if(null!==Kg.transition)return 0===Bk&&(Bk=yc()),Bk;a=C;if(0!==a)return a;a=window.event;a=void 0===a?16:jd(a.type);return a}function gi(a,b,c,d){if(50<yk)throw yk=0,zk=null,Error(p(185));Ac(a,c,d);if(0===(K&2)||a!==Q)a===Q&&(0===(K&2)&&(qk|=c),4===T&&Ck(a,Z)),Dk(a,d),1===c&&0===K&&0===(b.mode&1)&&(Gj=B()+500,fg&&jg())}\nfunction Dk(a,b){var c=a.callbackNode;wc(a,b);var d=uc(a,a===Q?Z:0);if(0===d)null!==c&&bc(c),a.callbackNode=null,a.callbackPriority=0;else if(b=d&-d,a.callbackPriority!==b){null!=c&&bc(c);if(1===b)0===a.tag?ig(Ek.bind(null,a)):hg(Ek.bind(null,a)),Jf(function(){0===(K&6)&&jg()}),c=null;else{switch(Dc(d)){case 1:c=fc;break;case 4:c=gc;break;case 16:c=hc;break;case 536870912:c=jc;break;default:c=hc}c=Fk(c,Gk.bind(null,a))}a.callbackPriority=b;a.callbackNode=c}}\nfunction Gk(a,b){Ak=-1;Bk=0;if(0!==(K&6))throw Error(p(327));var c=a.callbackNode;if(Hk()&&a.callbackNode!==c)return null;var d=uc(a,a===Q?Z:0);if(0===d)return null;if(0!==(d&30)||0!==(d&a.expiredLanes)||b)b=Ik(a,d);else{b=d;var e=K;K|=2;var f=Jk();if(Q!==a||Z!==b)uk=null,Gj=B()+500,Kk(a,b);do try{Lk();break}catch(h){Mk(a,h)}while(1);$g();mk.current=f;K=e;null!==Y?b=0:(Q=null,Z=0,b=T)}if(0!==b){2===b&&(e=xc(a),0!==e&&(d=e,b=Nk(a,e)));if(1===b)throw c=pk,Kk(a,0),Ck(a,d),Dk(a,B()),c;if(6===b)Ck(a,d);\nelse{e=a.current.alternate;if(0===(d&30)&&!Ok(e)&&(b=Ik(a,d),2===b&&(f=xc(a),0!==f&&(d=f,b=Nk(a,f))),1===b))throw c=pk,Kk(a,0),Ck(a,d),Dk(a,B()),c;a.finishedWork=e;a.finishedLanes=d;switch(b){case 0:case 1:throw Error(p(345));case 2:Pk(a,tk,uk);break;case 3:Ck(a,d);if((d&130023424)===d&&(b=fk+500-B(),10<b)){if(0!==uc(a,0))break;e=a.suspendedLanes;if((e&d)!==d){R();a.pingedLanes|=a.suspendedLanes&e;break}a.timeoutHandle=Ff(Pk.bind(null,a,tk,uk),b);break}Pk(a,tk,uk);break;case 4:Ck(a,d);if((d&4194240)===\nd)break;b=a.eventTimes;for(e=-1;0<d;){var g=31-oc(d);f=1<<g;g=b[g];g>e&&(e=g);d&=~f}d=e;d=B()-d;d=(120>d?120:480>d?480:1080>d?1080:1920>d?1920:3E3>d?3E3:4320>d?4320:1960*lk(d/1960))-d;if(10<d){a.timeoutHandle=Ff(Pk.bind(null,a,tk,uk),d);break}Pk(a,tk,uk);break;case 5:Pk(a,tk,uk);break;default:throw Error(p(329));}}}Dk(a,B());return a.callbackNode===c?Gk.bind(null,a):null}\nfunction Nk(a,b){var c=sk;a.current.memoizedState.isDehydrated&&(Kk(a,b).flags|=256);a=Ik(a,b);2!==a&&(b=tk,tk=c,null!==b&&Fj(b));return a}function Fj(a){null===tk?tk=a:tk.push.apply(tk,a)}\nfunction Ok(a){for(var b=a;;){if(b.flags&16384){var c=b.updateQueue;if(null!==c&&(c=c.stores,null!==c))for(var d=0;d<c.length;d++){var e=c[d],f=e.getSnapshot;e=e.value;try{if(!He(f(),e))return!1}catch(g){return!1}}}c=b.child;if(b.subtreeFlags&16384&&null!==c)c.return=b,b=c;else{if(b===a)break;for(;null===b.sibling;){if(null===b.return||b.return===a)return!0;b=b.return}b.sibling.return=b.return;b=b.sibling}}return!0}\nfunction Ck(a,b){b&=~rk;b&=~qk;a.suspendedLanes|=b;a.pingedLanes&=~b;for(a=a.expirationTimes;0<b;){var c=31-oc(b),d=1<<c;a[c]=-1;b&=~d}}function Ek(a){if(0!==(K&6))throw Error(p(327));Hk();var b=uc(a,0);if(0===(b&1))return Dk(a,B()),null;var c=Ik(a,b);if(0!==a.tag&&2===c){var d=xc(a);0!==d&&(b=d,c=Nk(a,d))}if(1===c)throw c=pk,Kk(a,0),Ck(a,b),Dk(a,B()),c;if(6===c)throw Error(p(345));a.finishedWork=a.current.alternate;a.finishedLanes=b;Pk(a,tk,uk);Dk(a,B());return null}\nfunction Qk(a,b){var c=K;K|=1;try{return a(b)}finally{K=c,0===K&&(Gj=B()+500,fg&&jg())}}function Rk(a){null!==wk&&0===wk.tag&&0===(K&6)&&Hk();var b=K;K|=1;var c=ok.transition,d=C;try{if(ok.transition=null,C=1,a)return a()}finally{C=d,ok.transition=c,K=b,0===(K&6)&&jg()}}function Hj(){fj=ej.current;E(ej)}\nfunction Kk(a,b){a.finishedWork=null;a.finishedLanes=0;var c=a.timeoutHandle;-1!==c&&(a.timeoutHandle=-1,Gf(c));if(null!==Y)for(c=Y.return;null!==c;){var d=c;wg(d);switch(d.tag){case 1:d=d.type.childContextTypes;null!==d&&void 0!==d&&$f();break;case 3:zh();E(Wf);E(H);Eh();break;case 5:Bh(d);break;case 4:zh();break;case 13:E(L);break;case 19:E(L);break;case 10:ah(d.type._context);break;case 22:case 23:Hj()}c=c.return}Q=a;Y=a=Pg(a.current,null);Z=fj=b;T=0;pk=null;rk=qk=rh=0;tk=sk=null;if(null!==fh){for(b=\n0;b<fh.length;b++)if(c=fh[b],d=c.interleaved,null!==d){c.interleaved=null;var e=d.next,f=c.pending;if(null!==f){var g=f.next;f.next=e;d.next=g}c.pending=d}fh=null}return a}\nfunction Mk(a,b){do{var c=Y;try{$g();Fh.current=Rh;if(Ih){for(var d=M.memoizedState;null!==d;){var e=d.queue;null!==e&&(e.pending=null);d=d.next}Ih=!1}Hh=0;O=N=M=null;Jh=!1;Kh=0;nk.current=null;if(null===c||null===c.return){T=1;pk=b;Y=null;break}a:{var f=a,g=c.return,h=c,k=b;b=Z;h.flags|=32768;if(null!==k&&\"object\"===typeof k&&\"function\"===typeof k.then){var l=k,m=h,q=m.tag;if(0===(m.mode&1)&&(0===q||11===q||15===q)){var r=m.alternate;r?(m.updateQueue=r.updateQueue,m.memoizedState=r.memoizedState,\nm.lanes=r.lanes):(m.updateQueue=null,m.memoizedState=null)}var y=Ui(g);if(null!==y){y.flags&=-257;Vi(y,g,h,f,b);y.mode&1&&Si(f,l,b);b=y;k=l;var n=b.updateQueue;if(null===n){var t=new Set;t.add(k);b.updateQueue=t}else n.add(k);break a}else{if(0===(b&1)){Si(f,l,b);tj();break a}k=Error(p(426))}}else if(I&&h.mode&1){var J=Ui(g);if(null!==J){0===(J.flags&65536)&&(J.flags|=256);Vi(J,g,h,f,b);Jg(Ji(k,h));break a}}f=k=Ji(k,h);4!==T&&(T=2);null===sk?sk=[f]:sk.push(f);f=g;do{switch(f.tag){case 3:f.flags|=65536;\nb&=-b;f.lanes|=b;var x=Ni(f,k,b);ph(f,x);break a;case 1:h=k;var w=f.type,u=f.stateNode;if(0===(f.flags&128)&&(\"function\"===typeof w.getDerivedStateFromError||null!==u&&\"function\"===typeof u.componentDidCatch&&(null===Ri||!Ri.has(u)))){f.flags|=65536;b&=-b;f.lanes|=b;var F=Qi(f,h,b);ph(f,F);break a}}f=f.return}while(null!==f)}Sk(c)}catch(na){b=na;Y===c&&null!==c&&(Y=c=c.return);continue}break}while(1)}function Jk(){var a=mk.current;mk.current=Rh;return null===a?Rh:a}\nfunction tj(){if(0===T||3===T||2===T)T=4;null===Q||0===(rh&268435455)&&0===(qk&268435455)||Ck(Q,Z)}function Ik(a,b){var c=K;K|=2;var d=Jk();if(Q!==a||Z!==b)uk=null,Kk(a,b);do try{Tk();break}catch(e){Mk(a,e)}while(1);$g();K=c;mk.current=d;if(null!==Y)throw Error(p(261));Q=null;Z=0;return T}function Tk(){for(;null!==Y;)Uk(Y)}function Lk(){for(;null!==Y&&!cc();)Uk(Y)}function Uk(a){var b=Vk(a.alternate,a,fj);a.memoizedProps=a.pendingProps;null===b?Sk(a):Y=b;nk.current=null}\nfunction Sk(a){var b=a;do{var c=b.alternate;a=b.return;if(0===(b.flags&32768)){if(c=Ej(c,b,fj),null!==c){Y=c;return}}else{c=Ij(c,b);if(null!==c){c.flags&=32767;Y=c;return}if(null!==a)a.flags|=32768,a.subtreeFlags=0,a.deletions=null;else{T=6;Y=null;return}}b=b.sibling;if(null!==b){Y=b;return}Y=b=a}while(null!==b);0===T&&(T=5)}function Pk(a,b,c){var d=C,e=ok.transition;try{ok.transition=null,C=1,Wk(a,b,c,d)}finally{ok.transition=e,C=d}return null}\nfunction Wk(a,b,c,d){do Hk();while(null!==wk);if(0!==(K&6))throw Error(p(327));c=a.finishedWork;var e=a.finishedLanes;if(null===c)return null;a.finishedWork=null;a.finishedLanes=0;if(c===a.current)throw Error(p(177));a.callbackNode=null;a.callbackPriority=0;var f=c.lanes|c.childLanes;Bc(a,f);a===Q&&(Y=Q=null,Z=0);0===(c.subtreeFlags&2064)&&0===(c.flags&2064)||vk||(vk=!0,Fk(hc,function(){Hk();return null}));f=0!==(c.flags&15990);if(0!==(c.subtreeFlags&15990)||f){f=ok.transition;ok.transition=null;\nvar g=C;C=1;var h=K;K|=4;nk.current=null;Oj(a,c);dk(c,a);Oe(Df);dd=!!Cf;Df=Cf=null;a.current=c;hk(c,a,e);dc();K=h;C=g;ok.transition=f}else a.current=c;vk&&(vk=!1,wk=a,xk=e);f=a.pendingLanes;0===f&&(Ri=null);mc(c.stateNode,d);Dk(a,B());if(null!==b)for(d=a.onRecoverableError,c=0;c<b.length;c++)e=b[c],d(e.value,{componentStack:e.stack,digest:e.digest});if(Oi)throw Oi=!1,a=Pi,Pi=null,a;0!==(xk&1)&&0!==a.tag&&Hk();f=a.pendingLanes;0!==(f&1)?a===zk?yk++:(yk=0,zk=a):yk=0;jg();return null}\nfunction Hk(){if(null!==wk){var a=Dc(xk),b=ok.transition,c=C;try{ok.transition=null;C=16>a?16:a;if(null===wk)var d=!1;else{a=wk;wk=null;xk=0;if(0!==(K&6))throw Error(p(331));var e=K;K|=4;for(V=a.current;null!==V;){var f=V,g=f.child;if(0!==(V.flags&16)){var h=f.deletions;if(null!==h){for(var k=0;k<h.length;k++){var l=h[k];for(V=l;null!==V;){var m=V;switch(m.tag){case 0:case 11:case 15:Pj(8,m,f)}var q=m.child;if(null!==q)q.return=m,V=q;else for(;null!==V;){m=V;var r=m.sibling,y=m.return;Sj(m);if(m===\nl){V=null;break}if(null!==r){r.return=y;V=r;break}V=y}}}var n=f.alternate;if(null!==n){var t=n.child;if(null!==t){n.child=null;do{var J=t.sibling;t.sibling=null;t=J}while(null!==t)}}V=f}}if(0!==(f.subtreeFlags&2064)&&null!==g)g.return=f,V=g;else b:for(;null!==V;){f=V;if(0!==(f.flags&2048))switch(f.tag){case 0:case 11:case 15:Pj(9,f,f.return)}var x=f.sibling;if(null!==x){x.return=f.return;V=x;break b}V=f.return}}var w=a.current;for(V=w;null!==V;){g=V;var u=g.child;if(0!==(g.subtreeFlags&2064)&&null!==\nu)u.return=g,V=u;else b:for(g=w;null!==V;){h=V;if(0!==(h.flags&2048))try{switch(h.tag){case 0:case 11:case 15:Qj(9,h)}}catch(na){W(h,h.return,na)}if(h===g){V=null;break b}var F=h.sibling;if(null!==F){F.return=h.return;V=F;break b}V=h.return}}K=e;jg();if(lc&&\"function\"===typeof lc.onPostCommitFiberRoot)try{lc.onPostCommitFiberRoot(kc,a)}catch(na){}d=!0}return d}finally{C=c,ok.transition=b}}return!1}function Xk(a,b,c){b=Ji(c,b);b=Ni(a,b,1);a=nh(a,b,1);b=R();null!==a&&(Ac(a,1,b),Dk(a,b))}\nfunction W(a,b,c){if(3===a.tag)Xk(a,a,c);else for(;null!==b;){if(3===b.tag){Xk(b,a,c);break}else if(1===b.tag){var d=b.stateNode;if(\"function\"===typeof b.type.getDerivedStateFromError||\"function\"===typeof d.componentDidCatch&&(null===Ri||!Ri.has(d))){a=Ji(c,a);a=Qi(b,a,1);b=nh(b,a,1);a=R();null!==b&&(Ac(b,1,a),Dk(b,a));break}}b=b.return}}\nfunction Ti(a,b,c){var d=a.pingCache;null!==d&&d.delete(b);b=R();a.pingedLanes|=a.suspendedLanes&c;Q===a&&(Z&c)===c&&(4===T||3===T&&(Z&130023424)===Z&&500>B()-fk?Kk(a,0):rk|=c);Dk(a,b)}function Yk(a,b){0===b&&(0===(a.mode&1)?b=1:(b=sc,sc<<=1,0===(sc&130023424)&&(sc=4194304)));var c=R();a=ih(a,b);null!==a&&(Ac(a,b,c),Dk(a,c))}function uj(a){var b=a.memoizedState,c=0;null!==b&&(c=b.retryLane);Yk(a,c)}\nfunction bk(a,b){var c=0;switch(a.tag){case 13:var d=a.stateNode;var e=a.memoizedState;null!==e&&(c=e.retryLane);break;case 19:d=a.stateNode;break;default:throw Error(p(314));}null!==d&&d.delete(b);Yk(a,c)}var Vk;\nVk=function(a,b,c){if(null!==a)if(a.memoizedProps!==b.pendingProps||Wf.current)dh=!0;else{if(0===(a.lanes&c)&&0===(b.flags&128))return dh=!1,yj(a,b,c);dh=0!==(a.flags&131072)?!0:!1}else dh=!1,I&&0!==(b.flags&1048576)&&ug(b,ng,b.index);b.lanes=0;switch(b.tag){case 2:var d=b.type;ij(a,b);a=b.pendingProps;var e=Yf(b,H.current);ch(b,c);e=Nh(null,b,d,a,e,c);var f=Sh();b.flags|=1;\"object\"===typeof e&&null!==e&&\"function\"===typeof e.render&&void 0===e.$$typeof?(b.tag=1,b.memoizedState=null,b.updateQueue=\nnull,Zf(d)?(f=!0,cg(b)):f=!1,b.memoizedState=null!==e.state&&void 0!==e.state?e.state:null,kh(b),e.updater=Ei,b.stateNode=e,e._reactInternals=b,Ii(b,d,a,c),b=jj(null,b,d,!0,f,c)):(b.tag=0,I&&f&&vg(b),Xi(null,b,e,c),b=b.child);return b;case 16:d=b.elementType;a:{ij(a,b);a=b.pendingProps;e=d._init;d=e(d._payload);b.type=d;e=b.tag=Zk(d);a=Ci(d,a);switch(e){case 0:b=cj(null,b,d,a,c);break a;case 1:b=hj(null,b,d,a,c);break a;case 11:b=Yi(null,b,d,a,c);break a;case 14:b=$i(null,b,d,Ci(d.type,a),c);break a}throw Error(p(306,\nd,\"\"));}return b;case 0:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:Ci(d,e),cj(a,b,d,e,c);case 1:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:Ci(d,e),hj(a,b,d,e,c);case 3:a:{kj(b);if(null===a)throw Error(p(387));d=b.pendingProps;f=b.memoizedState;e=f.element;lh(a,b);qh(b,d,null,c);var g=b.memoizedState;d=g.element;if(f.isDehydrated)if(f={element:d,isDehydrated:!1,cache:g.cache,pendingSuspenseBoundaries:g.pendingSuspenseBoundaries,transitions:g.transitions},b.updateQueue.baseState=\nf,b.memoizedState=f,b.flags&256){e=Ji(Error(p(423)),b);b=lj(a,b,d,c,e);break a}else if(d!==e){e=Ji(Error(p(424)),b);b=lj(a,b,d,c,e);break a}else for(yg=Lf(b.stateNode.containerInfo.firstChild),xg=b,I=!0,zg=null,c=Vg(b,null,d,c),b.child=c;c;)c.flags=c.flags&-3|4096,c=c.sibling;else{Ig();if(d===e){b=Zi(a,b,c);break a}Xi(a,b,d,c)}b=b.child}return b;case 5:return Ah(b),null===a&&Eg(b),d=b.type,e=b.pendingProps,f=null!==a?a.memoizedProps:null,g=e.children,Ef(d,e)?g=null:null!==f&&Ef(d,f)&&(b.flags|=32),\ngj(a,b),Xi(a,b,g,c),b.child;case 6:return null===a&&Eg(b),null;case 13:return oj(a,b,c);case 4:return yh(b,b.stateNode.containerInfo),d=b.pendingProps,null===a?b.child=Ug(b,null,d,c):Xi(a,b,d,c),b.child;case 11:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:Ci(d,e),Yi(a,b,d,e,c);case 7:return Xi(a,b,b.pendingProps,c),b.child;case 8:return Xi(a,b,b.pendingProps.children,c),b.child;case 12:return Xi(a,b,b.pendingProps.children,c),b.child;case 10:a:{d=b.type._context;e=b.pendingProps;f=b.memoizedProps;\ng=e.value;G(Wg,d._currentValue);d._currentValue=g;if(null!==f)if(He(f.value,g)){if(f.children===e.children&&!Wf.current){b=Zi(a,b,c);break a}}else for(f=b.child,null!==f&&(f.return=b);null!==f;){var h=f.dependencies;if(null!==h){g=f.child;for(var k=h.firstContext;null!==k;){if(k.context===d){if(1===f.tag){k=mh(-1,c&-c);k.tag=2;var l=f.updateQueue;if(null!==l){l=l.shared;var m=l.pending;null===m?k.next=k:(k.next=m.next,m.next=k);l.pending=k}}f.lanes|=c;k=f.alternate;null!==k&&(k.lanes|=c);bh(f.return,\nc,b);h.lanes|=c;break}k=k.next}}else if(10===f.tag)g=f.type===b.type?null:f.child;else if(18===f.tag){g=f.return;if(null===g)throw Error(p(341));g.lanes|=c;h=g.alternate;null!==h&&(h.lanes|=c);bh(g,c,b);g=f.sibling}else g=f.child;if(null!==g)g.return=f;else for(g=f;null!==g;){if(g===b){g=null;break}f=g.sibling;if(null!==f){f.return=g.return;g=f;break}g=g.return}f=g}Xi(a,b,e.children,c);b=b.child}return b;case 9:return e=b.type,d=b.pendingProps.children,ch(b,c),e=eh(e),d=d(e),b.flags|=1,Xi(a,b,d,c),\nb.child;case 14:return d=b.type,e=Ci(d,b.pendingProps),e=Ci(d.type,e),$i(a,b,d,e,c);case 15:return bj(a,b,b.type,b.pendingProps,c);case 17:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:Ci(d,e),ij(a,b),b.tag=1,Zf(d)?(a=!0,cg(b)):a=!1,ch(b,c),Gi(b,d,e),Ii(b,d,e,c),jj(null,b,d,!0,a,c);case 19:return xj(a,b,c);case 22:return dj(a,b,c)}throw Error(p(156,b.tag));};function Fk(a,b){return ac(a,b)}\nfunction $k(a,b,c,d){this.tag=a;this.key=c;this.sibling=this.child=this.return=this.stateNode=this.type=this.elementType=null;this.index=0;this.ref=null;this.pendingProps=b;this.dependencies=this.memoizedState=this.updateQueue=this.memoizedProps=null;this.mode=d;this.subtreeFlags=this.flags=0;this.deletions=null;this.childLanes=this.lanes=0;this.alternate=null}function Bg(a,b,c,d){return new $k(a,b,c,d)}function aj(a){a=a.prototype;return!(!a||!a.isReactComponent)}\nfunction Zk(a){if(\"function\"===typeof a)return aj(a)?1:0;if(void 0!==a&&null!==a){a=a.$$typeof;if(a===Da)return 11;if(a===Ga)return 14}return 2}\nfunction Pg(a,b){var c=a.alternate;null===c?(c=Bg(a.tag,b,a.key,a.mode),c.elementType=a.elementType,c.type=a.type,c.stateNode=a.stateNode,c.alternate=a,a.alternate=c):(c.pendingProps=b,c.type=a.type,c.flags=0,c.subtreeFlags=0,c.deletions=null);c.flags=a.flags&14680064;c.childLanes=a.childLanes;c.lanes=a.lanes;c.child=a.child;c.memoizedProps=a.memoizedProps;c.memoizedState=a.memoizedState;c.updateQueue=a.updateQueue;b=a.dependencies;c.dependencies=null===b?null:{lanes:b.lanes,firstContext:b.firstContext};\nc.sibling=a.sibling;c.index=a.index;c.ref=a.ref;return c}\nfunction Rg(a,b,c,d,e,f){var g=2;d=a;if(\"function\"===typeof a)aj(a)&&(g=1);else if(\"string\"===typeof a)g=5;else a:switch(a){case ya:return Tg(c.children,e,f,b);case za:g=8;e|=8;break;case Aa:return a=Bg(12,c,b,e|2),a.elementType=Aa,a.lanes=f,a;case Ea:return a=Bg(13,c,b,e),a.elementType=Ea,a.lanes=f,a;case Fa:return a=Bg(19,c,b,e),a.elementType=Fa,a.lanes=f,a;case Ia:return pj(c,e,f,b);default:if(\"object\"===typeof a&&null!==a)switch(a.$$typeof){case Ba:g=10;break a;case Ca:g=9;break a;case Da:g=11;\nbreak a;case Ga:g=14;break a;case Ha:g=16;d=null;break a}throw Error(p(130,null==a?a:typeof a,\"\"));}b=Bg(g,c,b,e);b.elementType=a;b.type=d;b.lanes=f;return b}function Tg(a,b,c,d){a=Bg(7,a,d,b);a.lanes=c;return a}function pj(a,b,c,d){a=Bg(22,a,d,b);a.elementType=Ia;a.lanes=c;a.stateNode={isHidden:!1};return a}function Qg(a,b,c){a=Bg(6,a,null,b);a.lanes=c;return a}\nfunction Sg(a,b,c){b=Bg(4,null!==a.children?a.children:[],a.key,b);b.lanes=c;b.stateNode={containerInfo:a.containerInfo,pendingChildren:null,implementation:a.implementation};return b}\nfunction al(a,b,c,d,e){this.tag=b;this.containerInfo=a;this.finishedWork=this.pingCache=this.current=this.pendingChildren=null;this.timeoutHandle=-1;this.callbackNode=this.pendingContext=this.context=null;this.callbackPriority=0;this.eventTimes=zc(0);this.expirationTimes=zc(-1);this.entangledLanes=this.finishedLanes=this.mutableReadLanes=this.expiredLanes=this.pingedLanes=this.suspendedLanes=this.pendingLanes=0;this.entanglements=zc(0);this.identifierPrefix=d;this.onRecoverableError=e;this.mutableSourceEagerHydrationData=\nnull}function bl(a,b,c,d,e,f,g,h,k){a=new al(a,b,c,h,k);1===b?(b=1,!0===f&&(b|=8)):b=0;f=Bg(3,null,null,b);a.current=f;f.stateNode=a;f.memoizedState={element:d,isDehydrated:c,cache:null,transitions:null,pendingSuspenseBoundaries:null};kh(f);return a}function cl(a,b,c){var d=3<arguments.length&&void 0!==arguments[3]?arguments[3]:null;return{$$typeof:wa,key:null==d?null:\"\"+d,children:a,containerInfo:b,implementation:c}}\nfunction dl(a){if(!a)return Vf;a=a._reactInternals;a:{if(Vb(a)!==a||1!==a.tag)throw Error(p(170));var b=a;do{switch(b.tag){case 3:b=b.stateNode.context;break a;case 1:if(Zf(b.type)){b=b.stateNode.__reactInternalMemoizedMergedChildContext;break a}}b=b.return}while(null!==b);throw Error(p(171));}if(1===a.tag){var c=a.type;if(Zf(c))return bg(a,c,b)}return b}\nfunction el(a,b,c,d,e,f,g,h,k){a=bl(c,d,!0,a,e,f,g,h,k);a.context=dl(null);c=a.current;d=R();e=yi(c);f=mh(d,e);f.callback=void 0!==b&&null!==b?b:null;nh(c,f,e);a.current.lanes=e;Ac(a,e,d);Dk(a,d);return a}function fl(a,b,c,d){var e=b.current,f=R(),g=yi(e);c=dl(c);null===b.context?b.context=c:b.pendingContext=c;b=mh(f,g);b.payload={element:a};d=void 0===d?null:d;null!==d&&(b.callback=d);a=nh(e,b,g);null!==a&&(gi(a,e,g,f),oh(a,e,g));return g}\nfunction gl(a){a=a.current;if(!a.child)return null;switch(a.child.tag){case 5:return a.child.stateNode;default:return a.child.stateNode}}function hl(a,b){a=a.memoizedState;if(null!==a&&null!==a.dehydrated){var c=a.retryLane;a.retryLane=0!==c&&c<b?c:b}}function il(a,b){hl(a,b);(a=a.alternate)&&hl(a,b)}function jl(){return null}var kl=\"function\"===typeof reportError?reportError:function(a){console.error(a)};function ll(a){this._internalRoot=a}\nml.prototype.render=ll.prototype.render=function(a){var b=this._internalRoot;if(null===b)throw Error(p(409));fl(a,b,null,null)};ml.prototype.unmount=ll.prototype.unmount=function(){var a=this._internalRoot;if(null!==a){this._internalRoot=null;var b=a.containerInfo;Rk(function(){fl(null,a,null,null)});b[uf]=null}};function ml(a){this._internalRoot=a}\nml.prototype.unstable_scheduleHydration=function(a){if(a){var b=Hc();a={blockedOn:null,target:a,priority:b};for(var c=0;c<Qc.length&&0!==b&&b<Qc[c].priority;c++);Qc.splice(c,0,a);0===c&&Vc(a)}};function nl(a){return!(!a||1!==a.nodeType&&9!==a.nodeType&&11!==a.nodeType)}function ol(a){return!(!a||1!==a.nodeType&&9!==a.nodeType&&11!==a.nodeType&&(8!==a.nodeType||\" react-mount-point-unstable \"!==a.nodeValue))}function pl(){}\nfunction ql(a,b,c,d,e){if(e){if(\"function\"===typeof d){var f=d;d=function(){var a=gl(g);f.call(a)}}var g=el(b,d,a,0,null,!1,!1,\"\",pl);a._reactRootContainer=g;a[uf]=g.current;sf(8===a.nodeType?a.parentNode:a);Rk();return g}for(;e=a.lastChild;)a.removeChild(e);if(\"function\"===typeof d){var h=d;d=function(){var a=gl(k);h.call(a)}}var k=bl(a,0,!1,null,null,!1,!1,\"\",pl);a._reactRootContainer=k;a[uf]=k.current;sf(8===a.nodeType?a.parentNode:a);Rk(function(){fl(b,k,c,d)});return k}\nfunction rl(a,b,c,d,e){var f=c._reactRootContainer;if(f){var g=f;if(\"function\"===typeof e){var h=e;e=function(){var a=gl(g);h.call(a)}}fl(b,g,a,e)}else g=ql(c,b,a,e,d);return gl(g)}Ec=function(a){switch(a.tag){case 3:var b=a.stateNode;if(b.current.memoizedState.isDehydrated){var c=tc(b.pendingLanes);0!==c&&(Cc(b,c|1),Dk(b,B()),0===(K&6)&&(Gj=B()+500,jg()))}break;case 13:Rk(function(){var b=ih(a,1);if(null!==b){var c=R();gi(b,a,1,c)}}),il(a,1)}};\nFc=function(a){if(13===a.tag){var b=ih(a,134217728);if(null!==b){var c=R();gi(b,a,134217728,c)}il(a,134217728)}};Gc=function(a){if(13===a.tag){var b=yi(a),c=ih(a,b);if(null!==c){var d=R();gi(c,a,b,d)}il(a,b)}};Hc=function(){return C};Ic=function(a,b){var c=C;try{return C=a,b()}finally{C=c}};\nyb=function(a,b,c){switch(b){case \"input\":bb(a,c);b=c.name;if(\"radio\"===c.type&&null!=b){for(c=a;c.parentNode;)c=c.parentNode;c=c.querySelectorAll(\"input[name=\"+JSON.stringify(\"\"+b)+'][type=\"radio\"]');for(b=0;b<c.length;b++){var d=c[b];if(d!==a&&d.form===a.form){var e=Db(d);if(!e)throw Error(p(90));Wa(d);bb(d,e)}}}break;case \"textarea\":ib(a,c);break;case \"select\":b=c.value,null!=b&&fb(a,!!c.multiple,b,!1)}};Gb=Qk;Hb=Rk;\nvar sl={usingClientEntryPoint:!1,Events:[Cb,ue,Db,Eb,Fb,Qk]},tl={findFiberByHostInstance:Wc,bundleType:0,version:\"18.3.1\",rendererPackageName:\"react-dom\"};\nvar ul={bundleType:tl.bundleType,version:tl.version,rendererPackageName:tl.rendererPackageName,rendererConfig:tl.rendererConfig,overrideHookState:null,overrideHookStateDeletePath:null,overrideHookStateRenamePath:null,overrideProps:null,overridePropsDeletePath:null,overridePropsRenamePath:null,setErrorHandler:null,setSuspenseHandler:null,scheduleUpdate:null,currentDispatcherRef:ua.ReactCurrentDispatcher,findHostInstanceByFiber:function(a){a=Zb(a);return null===a?null:a.stateNode},findFiberByHostInstance:tl.findFiberByHostInstance||\njl,findHostInstancesForRefresh:null,scheduleRefresh:null,scheduleRoot:null,setRefreshHandler:null,getCurrentFiber:null,reconcilerVersion:\"18.3.1-next-f1338f8080-20240426\"};if(\"undefined\"!==typeof __REACT_DEVTOOLS_GLOBAL_HOOK__){var vl=__REACT_DEVTOOLS_GLOBAL_HOOK__;if(!vl.isDisabled&&vl.supportsFiber)try{kc=vl.inject(ul),lc=vl}catch(a){}}exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=sl;\nexports.createPortal=function(a,b){var c=2<arguments.length&&void 0!==arguments[2]?arguments[2]:null;if(!nl(b))throw Error(p(200));return cl(a,b,null,c)};exports.createRoot=function(a,b){if(!nl(a))throw Error(p(299));var c=!1,d=\"\",e=kl;null!==b&&void 0!==b&&(!0===b.unstable_strictMode&&(c=!0),void 0!==b.identifierPrefix&&(d=b.identifierPrefix),void 0!==b.onRecoverableError&&(e=b.onRecoverableError));b=bl(a,1,!1,null,null,c,!1,d,e);a[uf]=b.current;sf(8===a.nodeType?a.parentNode:a);return new ll(b)};\nexports.findDOMNode=function(a){if(null==a)return null;if(1===a.nodeType)return a;var b=a._reactInternals;if(void 0===b){if(\"function\"===typeof a.render)throw Error(p(188));a=Object.keys(a).join(\",\");throw Error(p(268,a));}a=Zb(b);a=null===a?null:a.stateNode;return a};exports.flushSync=function(a){return Rk(a)};exports.hydrate=function(a,b,c){if(!ol(b))throw Error(p(200));return rl(null,a,b,!0,c)};\nexports.hydrateRoot=function(a,b,c){if(!nl(a))throw Error(p(405));var d=null!=c&&c.hydratedSources||null,e=!1,f=\"\",g=kl;null!==c&&void 0!==c&&(!0===c.unstable_strictMode&&(e=!0),void 0!==c.identifierPrefix&&(f=c.identifierPrefix),void 0!==c.onRecoverableError&&(g=c.onRecoverableError));b=el(b,null,a,1,null!=c?c:null,e,!1,f,g);a[uf]=b.current;sf(a);if(d)for(a=0;a<d.length;a++)c=d[a],e=c._getVersion,e=e(c._source),null==b.mutableSourceEagerHydrationData?b.mutableSourceEagerHydrationData=[c,e]:b.mutableSourceEagerHydrationData.push(c,\ne);return new ml(b)};exports.render=function(a,b,c){if(!ol(b))throw Error(p(200));return rl(null,a,b,!1,c)};exports.unmountComponentAtNode=function(a){if(!ol(a))throw Error(p(40));return a._reactRootContainer?(Rk(function(){rl(null,null,a,!1,function(){a._reactRootContainer=null;a[uf]=null})}),!0):!1};exports.unstable_batchedUpdates=Qk;\nexports.unstable_renderSubtreeIntoContainer=function(a,b,c,d){if(!ol(c))throw Error(p(200));if(null==a||void 0===a._reactInternals)throw Error(p(38));return rl(a,b,c,!1,d)};exports.version=\"18.3.1-next-f1338f8080-20240426\";\n","'use strict';\n\nvar m = require('react-dom');\nif (process.env.NODE_ENV === 'production') {\n  exports.createRoot = m.createRoot;\n  exports.hydrateRoot = m.hydrateRoot;\n} else {\n  var i = m.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;\n  exports.createRoot = function(c, o) {\n    i.usingClientEntryPoint = true;\n    try {\n      return m.createRoot(c, o);\n    } finally {\n      i.usingClientEntryPoint = false;\n    }\n  };\n  exports.hydrateRoot = function(c, h, o) {\n    i.usingClientEntryPoint = true;\n    try {\n      return m.hydrateRoot(c, h, o);\n    } finally {\n      i.usingClientEntryPoint = false;\n    }\n  };\n}\n","'use strict';\n\nfunction checkDCE() {\n  /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */\n  if (\n    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined' ||\n    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE !== 'function'\n  ) {\n    return;\n  }\n  if (process.env.NODE_ENV !== 'production') {\n    // This branch is unreachable because this function is only called\n    // in production, but the condition is true only in development.\n    // Therefore if the branch is still here, dead code elimination wasn't\n    // properly applied.\n    // Don't change the message. React DevTools relies on it. Also make sure\n    // this message doesn't occur elsewhere in this function, or it will cause\n    // a false positive.\n    throw new Error('^_^');\n  }\n  try {\n    // Verify that the code above has been dead code eliminated (DCE'd).\n    __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(checkDCE);\n  } catch (err) {\n    // DevTools shouldn't crash React, no matter what.\n    // We should still report in case we break this code.\n    console.error(err);\n  }\n}\n\nif (process.env.NODE_ENV === 'production') {\n  // DCE check should happen before ReactDOM bundle executes so that\n  // DevTools can report bad minification during injection.\n  checkDCE();\n  module.exports = require('./cjs/react-dom.production.min.js');\n} else {\n  module.exports = require('./cjs/react-dom.development.js');\n}\n","/**\n * @license React\n * react-jsx-runtime.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var f=require(\"react\"),k=Symbol.for(\"react.element\"),l=Symbol.for(\"react.fragment\"),m=Object.prototype.hasOwnProperty,n=f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,p={key:!0,ref:!0,__self:!0,__source:!0};\nfunction q(c,a,g){var b,d={},e=null,h=null;void 0!==g&&(e=\"\"+g);void 0!==a.key&&(e=\"\"+a.key);void 0!==a.ref&&(h=a.ref);for(b in a)m.call(a,b)&&!p.hasOwnProperty(b)&&(d[b]=a[b]);if(c&&c.defaultProps)for(b in a=c.defaultProps,a)void 0===d[b]&&(d[b]=a[b]);return{$$typeof:k,type:c,key:e,ref:h,props:d,_owner:n.current}}exports.Fragment=l;exports.jsx=q;exports.jsxs=q;\n","/**\n * @license React\n * react.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var l=Symbol.for(\"react.element\"),n=Symbol.for(\"react.portal\"),p=Symbol.for(\"react.fragment\"),q=Symbol.for(\"react.strict_mode\"),r=Symbol.for(\"react.profiler\"),t=Symbol.for(\"react.provider\"),u=Symbol.for(\"react.context\"),v=Symbol.for(\"react.forward_ref\"),w=Symbol.for(\"react.suspense\"),x=Symbol.for(\"react.memo\"),y=Symbol.for(\"react.lazy\"),z=Symbol.iterator;function A(a){if(null===a||\"object\"!==typeof a)return null;a=z&&a[z]||a[\"@@iterator\"];return\"function\"===typeof a?a:null}\nvar B={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},C=Object.assign,D={};function E(a,b,e){this.props=a;this.context=b;this.refs=D;this.updater=e||B}E.prototype.isReactComponent={};\nE.prototype.setState=function(a,b){if(\"object\"!==typeof a&&\"function\"!==typeof a&&null!=a)throw Error(\"setState(...): takes an object of state variables to update or a function which returns an object of state variables.\");this.updater.enqueueSetState(this,a,b,\"setState\")};E.prototype.forceUpdate=function(a){this.updater.enqueueForceUpdate(this,a,\"forceUpdate\")};function F(){}F.prototype=E.prototype;function G(a,b,e){this.props=a;this.context=b;this.refs=D;this.updater=e||B}var H=G.prototype=new F;\nH.constructor=G;C(H,E.prototype);H.isPureReactComponent=!0;var I=Array.isArray,J=Object.prototype.hasOwnProperty,K={current:null},L={key:!0,ref:!0,__self:!0,__source:!0};\nfunction M(a,b,e){var d,c={},k=null,h=null;if(null!=b)for(d in void 0!==b.ref&&(h=b.ref),void 0!==b.key&&(k=\"\"+b.key),b)J.call(b,d)&&!L.hasOwnProperty(d)&&(c[d]=b[d]);var g=arguments.length-2;if(1===g)c.children=e;else if(1<g){for(var f=Array(g),m=0;m<g;m++)f[m]=arguments[m+2];c.children=f}if(a&&a.defaultProps)for(d in g=a.defaultProps,g)void 0===c[d]&&(c[d]=g[d]);return{$$typeof:l,type:a,key:k,ref:h,props:c,_owner:K.current}}\nfunction N(a,b){return{$$typeof:l,type:a.type,key:b,ref:a.ref,props:a.props,_owner:a._owner}}function O(a){return\"object\"===typeof a&&null!==a&&a.$$typeof===l}function escape(a){var b={\"=\":\"=0\",\":\":\"=2\"};return\"$\"+a.replace(/[=:]/g,function(a){return b[a]})}var P=/\\/+/g;function Q(a,b){return\"object\"===typeof a&&null!==a&&null!=a.key?escape(\"\"+a.key):b.toString(36)}\nfunction R(a,b,e,d,c){var k=typeof a;if(\"undefined\"===k||\"boolean\"===k)a=null;var h=!1;if(null===a)h=!0;else switch(k){case \"string\":case \"number\":h=!0;break;case \"object\":switch(a.$$typeof){case l:case n:h=!0}}if(h)return h=a,c=c(h),a=\"\"===d?\".\"+Q(h,0):d,I(c)?(e=\"\",null!=a&&(e=a.replace(P,\"$&/\")+\"/\"),R(c,b,e,\"\",function(a){return a})):null!=c&&(O(c)&&(c=N(c,e+(!c.key||h&&h.key===c.key?\"\":(\"\"+c.key).replace(P,\"$&/\")+\"/\")+a)),b.push(c)),1;h=0;d=\"\"===d?\".\":d+\":\";if(I(a))for(var g=0;g<a.length;g++){k=\na[g];var f=d+Q(k,g);h+=R(k,b,e,f,c)}else if(f=A(a),\"function\"===typeof f)for(a=f.call(a),g=0;!(k=a.next()).done;)k=k.value,f=d+Q(k,g++),h+=R(k,b,e,f,c);else if(\"object\"===k)throw b=String(a),Error(\"Objects are not valid as a React child (found: \"+(\"[object Object]\"===b?\"object with keys {\"+Object.keys(a).join(\", \")+\"}\":b)+\"). If you meant to render a collection of children, use an array instead.\");return h}\nfunction S(a,b,e){if(null==a)return a;var d=[],c=0;R(a,d,\"\",\"\",function(a){return b.call(e,a,c++)});return d}function T(a){if(-1===a._status){var b=a._result;b=b();b.then(function(b){if(0===a._status||-1===a._status)a._status=1,a._result=b},function(b){if(0===a._status||-1===a._status)a._status=2,a._result=b});-1===a._status&&(a._status=0,a._result=b)}if(1===a._status)return a._result.default;throw a._result;}\nvar U={current:null},V={transition:null},W={ReactCurrentDispatcher:U,ReactCurrentBatchConfig:V,ReactCurrentOwner:K};function X(){throw Error(\"act(...) is not supported in production builds of React.\");}\nexports.Children={map:S,forEach:function(a,b,e){S(a,function(){b.apply(this,arguments)},e)},count:function(a){var b=0;S(a,function(){b++});return b},toArray:function(a){return S(a,function(a){return a})||[]},only:function(a){if(!O(a))throw Error(\"React.Children.only expected to receive a single React element child.\");return a}};exports.Component=E;exports.Fragment=p;exports.Profiler=r;exports.PureComponent=G;exports.StrictMode=q;exports.Suspense=w;\nexports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=W;exports.act=X;\nexports.cloneElement=function(a,b,e){if(null===a||void 0===a)throw Error(\"React.cloneElement(...): The argument must be a React element, but you passed \"+a+\".\");var d=C({},a.props),c=a.key,k=a.ref,h=a._owner;if(null!=b){void 0!==b.ref&&(k=b.ref,h=K.current);void 0!==b.key&&(c=\"\"+b.key);if(a.type&&a.type.defaultProps)var g=a.type.defaultProps;for(f in b)J.call(b,f)&&!L.hasOwnProperty(f)&&(d[f]=void 0===b[f]&&void 0!==g?g[f]:b[f])}var f=arguments.length-2;if(1===f)d.children=e;else if(1<f){g=Array(f);\nfor(var m=0;m<f;m++)g[m]=arguments[m+2];d.children=g}return{$$typeof:l,type:a.type,key:c,ref:k,props:d,_owner:h}};exports.createContext=function(a){a={$$typeof:u,_currentValue:a,_currentValue2:a,_threadCount:0,Provider:null,Consumer:null,_defaultValue:null,_globalName:null};a.Provider={$$typeof:t,_context:a};return a.Consumer=a};exports.createElement=M;exports.createFactory=function(a){var b=M.bind(null,a);b.type=a;return b};exports.createRef=function(){return{current:null}};\nexports.forwardRef=function(a){return{$$typeof:v,render:a}};exports.isValidElement=O;exports.lazy=function(a){return{$$typeof:y,_payload:{_status:-1,_result:a},_init:T}};exports.memo=function(a,b){return{$$typeof:x,type:a,compare:void 0===b?null:b}};exports.startTransition=function(a){var b=V.transition;V.transition={};try{a()}finally{V.transition=b}};exports.unstable_act=X;exports.useCallback=function(a,b){return U.current.useCallback(a,b)};exports.useContext=function(a){return U.current.useContext(a)};\nexports.useDebugValue=function(){};exports.useDeferredValue=function(a){return U.current.useDeferredValue(a)};exports.useEffect=function(a,b){return U.current.useEffect(a,b)};exports.useId=function(){return U.current.useId()};exports.useImperativeHandle=function(a,b,e){return U.current.useImperativeHandle(a,b,e)};exports.useInsertionEffect=function(a,b){return U.current.useInsertionEffect(a,b)};exports.useLayoutEffect=function(a,b){return U.current.useLayoutEffect(a,b)};\nexports.useMemo=function(a,b){return U.current.useMemo(a,b)};exports.useReducer=function(a,b,e){return U.current.useReducer(a,b,e)};exports.useRef=function(a){return U.current.useRef(a)};exports.useState=function(a){return U.current.useState(a)};exports.useSyncExternalStore=function(a,b,e){return U.current.useSyncExternalStore(a,b,e)};exports.useTransition=function(){return U.current.useTransition()};exports.version=\"18.3.1\";\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react.production.min.js');\n} else {\n  module.exports = require('./cjs/react.development.js');\n}\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react-jsx-runtime.production.min.js');\n} else {\n  module.exports = require('./cjs/react-jsx-runtime.development.js');\n}\n","/**\n * @license React\n * scheduler.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';function f(a,b){var c=a.length;a.push(b);a:for(;0<c;){var d=c-1>>>1,e=a[d];if(0<g(e,b))a[d]=b,a[c]=e,c=d;else break a}}function h(a){return 0===a.length?null:a[0]}function k(a){if(0===a.length)return null;var b=a[0],c=a.pop();if(c!==b){a[0]=c;a:for(var d=0,e=a.length,w=e>>>1;d<w;){var m=2*(d+1)-1,C=a[m],n=m+1,x=a[n];if(0>g(C,c))n<e&&0>g(x,C)?(a[d]=x,a[n]=c,d=n):(a[d]=C,a[m]=c,d=m);else if(n<e&&0>g(x,c))a[d]=x,a[n]=c,d=n;else break a}}return b}\nfunction g(a,b){var c=a.sortIndex-b.sortIndex;return 0!==c?c:a.id-b.id}if(\"object\"===typeof performance&&\"function\"===typeof performance.now){var l=performance;exports.unstable_now=function(){return l.now()}}else{var p=Date,q=p.now();exports.unstable_now=function(){return p.now()-q}}var r=[],t=[],u=1,v=null,y=3,z=!1,A=!1,B=!1,D=\"function\"===typeof setTimeout?setTimeout:null,E=\"function\"===typeof clearTimeout?clearTimeout:null,F=\"undefined\"!==typeof setImmediate?setImmediate:null;\n\"undefined\"!==typeof navigator&&void 0!==navigator.scheduling&&void 0!==navigator.scheduling.isInputPending&&navigator.scheduling.isInputPending.bind(navigator.scheduling);function G(a){for(var b=h(t);null!==b;){if(null===b.callback)k(t);else if(b.startTime<=a)k(t),b.sortIndex=b.expirationTime,f(r,b);else break;b=h(t)}}function H(a){B=!1;G(a);if(!A)if(null!==h(r))A=!0,I(J);else{var b=h(t);null!==b&&K(H,b.startTime-a)}}\nfunction J(a,b){A=!1;B&&(B=!1,E(L),L=-1);z=!0;var c=y;try{G(b);for(v=h(r);null!==v&&(!(v.expirationTime>b)||a&&!M());){var d=v.callback;if(\"function\"===typeof d){v.callback=null;y=v.priorityLevel;var e=d(v.expirationTime<=b);b=exports.unstable_now();\"function\"===typeof e?v.callback=e:v===h(r)&&k(r);G(b)}else k(r);v=h(r)}if(null!==v)var w=!0;else{var m=h(t);null!==m&&K(H,m.startTime-b);w=!1}return w}finally{v=null,y=c,z=!1}}var N=!1,O=null,L=-1,P=5,Q=-1;\nfunction M(){return exports.unstable_now()-Q<P?!1:!0}function R(){if(null!==O){var a=exports.unstable_now();Q=a;var b=!0;try{b=O(!0,a)}finally{b?S():(N=!1,O=null)}}else N=!1}var S;if(\"function\"===typeof F)S=function(){F(R)};else if(\"undefined\"!==typeof MessageChannel){var T=new MessageChannel,U=T.port2;T.port1.onmessage=R;S=function(){U.postMessage(null)}}else S=function(){D(R,0)};function I(a){O=a;N||(N=!0,S())}function K(a,b){L=D(function(){a(exports.unstable_now())},b)}\nexports.unstable_IdlePriority=5;exports.unstable_ImmediatePriority=1;exports.unstable_LowPriority=4;exports.unstable_NormalPriority=3;exports.unstable_Profiling=null;exports.unstable_UserBlockingPriority=2;exports.unstable_cancelCallback=function(a){a.callback=null};exports.unstable_continueExecution=function(){A||z||(A=!0,I(J))};\nexports.unstable_forceFrameRate=function(a){0>a||125<a?console.error(\"forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported\"):P=0<a?Math.floor(1E3/a):5};exports.unstable_getCurrentPriorityLevel=function(){return y};exports.unstable_getFirstCallbackNode=function(){return h(r)};exports.unstable_next=function(a){switch(y){case 1:case 2:case 3:var b=3;break;default:b=y}var c=y;y=b;try{return a()}finally{y=c}};exports.unstable_pauseExecution=function(){};\nexports.unstable_requestPaint=function(){};exports.unstable_runWithPriority=function(a,b){switch(a){case 1:case 2:case 3:case 4:case 5:break;default:a=3}var c=y;y=a;try{return b()}finally{y=c}};\nexports.unstable_scheduleCallback=function(a,b,c){var d=exports.unstable_now();\"object\"===typeof c&&null!==c?(c=c.delay,c=\"number\"===typeof c&&0<c?d+c:d):c=d;switch(a){case 1:var e=-1;break;case 2:e=250;break;case 5:e=1073741823;break;case 4:e=1E4;break;default:e=5E3}e=c+e;a={id:u++,callback:b,priorityLevel:a,startTime:c,expirationTime:e,sortIndex:-1};c>d?(a.sortIndex=c,f(t,a),null===h(r)&&a===h(t)&&(B?(E(L),L=-1):B=!0,K(H,c-d))):(a.sortIndex=e,f(r,a),A||z||(A=!0,I(J)));return a};\nexports.unstable_shouldYield=M;exports.unstable_wrapCallback=function(a){var b=y;return function(){var c=y;y=b;try{return a.apply(this,arguments)}finally{y=c}}};\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/scheduler.production.min.js');\n} else {\n  module.exports = require('./cjs/scheduler.development.js');\n}\n","import type { Declaration } from 'inline-style-parser';\nimport parse from 'inline-style-parser';\n\nexport { Declaration };\n\ninterface StyleObject {\n  [name: string]: string;\n}\n\ntype Iterator = (\n  property: string,\n  value: string,\n  declaration: Declaration,\n) => void;\n\n/**\n * Parses inline style to object.\n *\n * @param style - Inline style.\n * @param iterator - Iterator.\n * @returns - Style object or null.\n *\n * @example Parsing inline style to object:\n *\n * ```js\n * import parse from 'style-to-object';\n * parse('line-height: 42;'); // { 'line-height': '42' }\n * ```\n */\nexport default function StyleToObject(\n  style: string,\n  iterator?: Iterator,\n): StyleObject | null {\n  let styleObject: StyleObject | null = null;\n\n  if (!style || typeof style !== 'string') {\n    return styleObject;\n  }\n\n  const declarations = parse(style);\n  const hasIterator = typeof iterator === 'function';\n\n  declarations.forEach((declaration) => {\n    if (declaration.type !== 'declaration') {\n      return;\n    }\n\n    const { property, value } = declaration;\n\n    if (hasIterator) {\n      iterator(property, value, declaration);\n    } else if (value) {\n      styleObject = styleObject || {};\n      styleObject[property] = value;\n    }\n  });\n\n  return styleObject;\n}\n","/*!\n\tCopyright (c) 2018 Jed Watson.\n\tLicensed under the MIT License (MIT), see\n\thttp://jedwatson.github.io/classnames\n*/\n/* global define */\n\n(function () {\n\t'use strict';\n\n\tvar hasOwn = {}.hasOwnProperty;\n\n\tfunction classNames () {\n\t\tvar classes = '';\n\n\t\tfor (var i = 0; i < arguments.length; i++) {\n\t\t\tvar arg = arguments[i];\n\t\t\tif (arg) {\n\t\t\t\tclasses = appendClass(classes, parseValue(arg));\n\t\t\t}\n\t\t}\n\n\t\treturn classes;\n\t}\n\n\tfunction parseValue (arg) {\n\t\tif (typeof arg === 'string' || typeof arg === 'number') {\n\t\t\treturn arg;\n\t\t}\n\n\t\tif (typeof arg !== 'object') {\n\t\t\treturn '';\n\t\t}\n\n\t\tif (Array.isArray(arg)) {\n\t\t\treturn classNames.apply(null, arg);\n\t\t}\n\n\t\tif (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes('[native code]')) {\n\t\t\treturn arg.toString();\n\t\t}\n\n\t\tvar classes = '';\n\n\t\tfor (var key in arg) {\n\t\t\tif (hasOwn.call(arg, key) && arg[key]) {\n\t\t\t\tclasses = appendClass(classes, key);\n\t\t\t}\n\t\t}\n\n\t\treturn classes;\n\t}\n\n\tfunction appendClass (value, newClass) {\n\t\tif (!newClass) {\n\t\t\treturn value;\n\t\t}\n\t\n\t\tif (value) {\n\t\t\treturn value + ' ' + newClass;\n\t\t}\n\t\n\t\treturn value + newClass;\n\t}\n\n\tif (typeof module !== 'undefined' && module.exports) {\n\t\tclassNames.default = classNames;\n\t\tmodule.exports = classNames;\n\t} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {\n\t\t// register as 'classnames', consistent with npm package name\n\t\tdefine('classnames', [], function () {\n\t\t\treturn classNames;\n\t\t});\n\t} else {\n\t\twindow.classNames = classNames;\n\t}\n}());\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n// expose the modules object (__webpack_modules__)\n__webpack_require__.m = __webpack_modules__;\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","var getProto = Object.getPrototypeOf ? (obj) => (Object.getPrototypeOf(obj)) : (obj) => (obj.__proto__);\nvar leafPrototypes;\n// create a fake namespace object\n// mode & 1: value is a module id, require it\n// mode & 2: merge all properties of value into the ns\n// mode & 4: return value when already ns object\n// mode & 16: return value when it's Promise-like\n// mode & 8|1: behave like require\n__webpack_require__.t = function(value, mode) {\n\tif(mode & 1) value = this(value);\n\tif(mode & 8) return value;\n\tif(typeof value === 'object' && value) {\n\t\tif((mode & 4) && value.__esModule) return value;\n\t\tif((mode & 16) && typeof value.then === 'function') return value;\n\t}\n\tvar ns = Object.create(null);\n\t__webpack_require__.r(ns);\n\tvar def = {};\n\tleafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];\n\tfor(var current = mode & 2 && value; typeof current == 'object' && !~leafPrototypes.indexOf(current); current = getProto(current)) {\n\t\tObject.getOwnPropertyNames(current).forEach((key) => (def[key] = () => (value[key])));\n\t}\n\tdef['default'] = () => (value);\n\t__webpack_require__.d(ns, def);\n\treturn ns;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.f = {};\n// This file contains only the entry chunk.\n// The chunk loading function for additional chunks\n__webpack_require__.e = (chunkId) => {\n\treturn Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key) => {\n\t\t__webpack_require__.f[key](chunkId, promises);\n\t\treturn promises;\n\t}, []));\n};","// This function allow to reference async chunks\n__webpack_require__.u = (chunkId) => {\n\t// return url for filenames based on template\n\treturn \"static/js/\" + chunkId + \".\" + \"0c407378\" + \".chunk.js\";\n};","// This function allow to reference async chunks\n__webpack_require__.miniCssF = (chunkId) => {\n\t// return url for filenames based on template\n\treturn undefined;\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","var inProgress = {};\nvar dataWebpackPrefix = \"northern-cardinal:\";\n// loadScript function to load a script via script tag\n__webpack_require__.l = (url, done, key, chunkId) => {\n\tif(inProgress[url]) { inProgress[url].push(done); return; }\n\tvar script, needAttach;\n\tif(key !== undefined) {\n\t\tvar scripts = document.getElementsByTagName(\"script\");\n\t\tfor(var i = 0; i < scripts.length; i++) {\n\t\t\tvar s = scripts[i];\n\t\t\tif(s.getAttribute(\"src\") == url || s.getAttribute(\"data-webpack\") == dataWebpackPrefix + key) { script = s; break; }\n\t\t}\n\t}\n\tif(!script) {\n\t\tneedAttach = true;\n\t\tscript = document.createElement('script');\n\n\t\tscript.charset = 'utf-8';\n\t\tscript.timeout = 120;\n\t\tif (__webpack_require__.nc) {\n\t\t\tscript.setAttribute(\"nonce\", __webpack_require__.nc);\n\t\t}\n\t\tscript.setAttribute(\"data-webpack\", dataWebpackPrefix + key);\n\n\t\tscript.src = url;\n\t}\n\tinProgress[url] = [done];\n\tvar onScriptComplete = (prev, event) => {\n\t\t// avoid mem leaks in IE.\n\t\tscript.onerror = script.onload = null;\n\t\tclearTimeout(timeout);\n\t\tvar doneFns = inProgress[url];\n\t\tdelete inProgress[url];\n\t\tscript.parentNode && script.parentNode.removeChild(script);\n\t\tdoneFns && doneFns.forEach((fn) => (fn(event)));\n\t\tif(prev) return prev(event);\n\t}\n\tvar timeout = setTimeout(onScriptComplete.bind(null, undefined, { type: 'timeout', target: script }), 120000);\n\tscript.onerror = onScriptComplete.bind(null, script.onerror);\n\tscript.onload = onScriptComplete.bind(null, script.onload);\n\tneedAttach && document.head.appendChild(script);\n};","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","__webpack_require__.p = \"/\";","// no baseURI\n\n// object to store loaded and loading chunks\n// undefined = chunk not loaded, null = chunk preloaded/prefetched\n// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded\nvar installedChunks = {\n\t792: 0\n};\n\n__webpack_require__.f.j = (chunkId, promises) => {\n\t\t// JSONP chunk loading for javascript\n\t\tvar installedChunkData = __webpack_require__.o(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;\n\t\tif(installedChunkData !== 0) { // 0 means \"already installed\".\n\n\t\t\t// a Promise means \"currently loading\".\n\t\t\tif(installedChunkData) {\n\t\t\t\tpromises.push(installedChunkData[2]);\n\t\t\t} else {\n\t\t\t\tif(true) { // all chunks have JS\n\t\t\t\t\t// setup Promise in chunk cache\n\t\t\t\t\tvar promise = new Promise((resolve, reject) => (installedChunkData = installedChunks[chunkId] = [resolve, reject]));\n\t\t\t\t\tpromises.push(installedChunkData[2] = promise);\n\n\t\t\t\t\t// start chunk loading\n\t\t\t\t\tvar url = __webpack_require__.p + __webpack_require__.u(chunkId);\n\t\t\t\t\t// create error before stack unwound to get useful stacktrace later\n\t\t\t\t\tvar error = new Error();\n\t\t\t\t\tvar loadingEnded = (event) => {\n\t\t\t\t\t\tif(__webpack_require__.o(installedChunks, chunkId)) {\n\t\t\t\t\t\t\tinstalledChunkData = installedChunks[chunkId];\n\t\t\t\t\t\t\tif(installedChunkData !== 0) installedChunks[chunkId] = undefined;\n\t\t\t\t\t\t\tif(installedChunkData) {\n\t\t\t\t\t\t\t\tvar errorType = event && (event.type === 'load' ? 'missing' : event.type);\n\t\t\t\t\t\t\t\tvar realSrc = event && event.target && event.target.src;\n\t\t\t\t\t\t\t\terror.message = 'Loading chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';\n\t\t\t\t\t\t\t\terror.name = 'ChunkLoadError';\n\t\t\t\t\t\t\t\terror.type = errorType;\n\t\t\t\t\t\t\t\terror.request = realSrc;\n\t\t\t\t\t\t\t\tinstalledChunkData[1](error);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t\t__webpack_require__.l(url, loadingEnded, \"chunk-\" + chunkId, chunkId);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n};\n\n// no prefetching\n\n// no preloaded\n\n// no HMR\n\n// no HMR manifest\n\n// no on chunks loaded\n\n// install a JSONP callback for chunk loading\nvar webpackJsonpCallback = (parentChunkLoadingFunction, data) => {\n\tvar chunkIds = data[0];\n\tvar moreModules = data[1];\n\tvar runtime = data[2];\n\t// add \"moreModules\" to the modules object,\n\t// then flag all \"chunkIds\" as loaded and fire callback\n\tvar moduleId, chunkId, i = 0;\n\tif(chunkIds.some((id) => (installedChunks[id] !== 0))) {\n\t\tfor(moduleId in moreModules) {\n\t\t\tif(__webpack_require__.o(moreModules, moduleId)) {\n\t\t\t\t__webpack_require__.m[moduleId] = moreModules[moduleId];\n\t\t\t}\n\t\t}\n\t\tif(runtime) var result = runtime(__webpack_require__);\n\t}\n\tif(parentChunkLoadingFunction) parentChunkLoadingFunction(data);\n\tfor(;i < chunkIds.length; i++) {\n\t\tchunkId = chunkIds[i];\n\t\tif(__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) {\n\t\t\tinstalledChunks[chunkId][0]();\n\t\t}\n\t\tinstalledChunks[chunkId] = 0;\n\t}\n\n}\n\nvar chunkLoadingGlobal = self[\"webpackChunknorthern_cardinal\"] = self[\"webpackChunknorthern_cardinal\"] || [];\nchunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));\nchunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));","////////////////////////////////////////////////////////////////////////////////\n//#region Types and Constants\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Actions represent the type of change to a location value.\n */\nexport enum Action {\n  /**\n   * A POP indicates a change to an arbitrary index in the history stack, such\n   * as a back or forward navigation. It does not describe the direction of the\n   * navigation, only that the current index changed.\n   *\n   * Note: This is the default action for newly created history objects.\n   */\n  Pop = \"POP\",\n\n  /**\n   * A PUSH indicates a new entry being added to the history stack, such as when\n   * a link is clicked and a new page loads. When this happens, all subsequent\n   * entries in the stack are lost.\n   */\n  Push = \"PUSH\",\n\n  /**\n   * A REPLACE indicates the entry at the current index in the history stack\n   * being replaced by a new one.\n   */\n  Replace = \"REPLACE\",\n}\n\n/**\n * The pathname, search, and hash values of a URL.\n */\nexport interface Path {\n  /**\n   * A URL pathname, beginning with a /.\n   */\n  pathname: string;\n\n  /**\n   * A URL search string, beginning with a ?.\n   */\n  search: string;\n\n  /**\n   * A URL fragment identifier, beginning with a #.\n   */\n  hash: string;\n}\n\n// TODO: (v7) Change the Location generic default from `any` to `unknown` and\n// remove Remix `useLocation` wrapper.\n\n/**\n * An entry in a history stack. A location contains information about the\n * URL path, as well as possibly some arbitrary state and a key.\n */\nexport interface Location<State = any> extends Path {\n  /**\n   * A value of arbitrary data associated with this location.\n   */\n  state: State;\n\n  /**\n   * A unique string associated with this location. May be used to safely store\n   * and retrieve data in some other storage API, like `localStorage`.\n   *\n   * Note: This value is always \"default\" on the initial location.\n   */\n  key: string;\n}\n\n/**\n * A change to the current location.\n */\nexport interface Update {\n  /**\n   * The action that triggered the change.\n   */\n  action: Action;\n\n  /**\n   * The new location.\n   */\n  location: Location;\n\n  /**\n   * The delta between this location and the former location in the history stack\n   */\n  delta: number | null;\n}\n\n/**\n * A function that receives notifications about location changes.\n */\nexport interface Listener {\n  (update: Update): void;\n}\n\n/**\n * Describes a location that is the destination of some navigation, either via\n * `history.push` or `history.replace`. This may be either a URL or the pieces\n * of a URL path.\n */\nexport type To = string | Partial<Path>;\n\n/**\n * A history is an interface to the navigation stack. The history serves as the\n * source of truth for the current location, as well as provides a set of\n * methods that may be used to change it.\n *\n * It is similar to the DOM's `window.history` object, but with a smaller, more\n * focused API.\n */\nexport interface History {\n  /**\n   * The last action that modified the current location. This will always be\n   * Action.Pop when a history instance is first created. This value is mutable.\n   */\n  readonly action: Action;\n\n  /**\n   * The current location. This value is mutable.\n   */\n  readonly location: Location;\n\n  /**\n   * Returns a valid href for the given `to` value that may be used as\n   * the value of an <a href> attribute.\n   *\n   * @param to - The destination URL\n   */\n  createHref(to: To): string;\n\n  /**\n   * Returns a URL for the given `to` value\n   *\n   * @param to - The destination URL\n   */\n  createURL(to: To): URL;\n\n  /**\n   * Encode a location the same way window.history would do (no-op for memory\n   * history) so we ensure our PUSH/REPLACE navigations for data routers\n   * behave the same as POP\n   *\n   * @param to Unencoded path\n   */\n  encodeLocation(to: To): Path;\n\n  /**\n   * Pushes a new location onto the history stack, increasing its length by one.\n   * If there were any entries in the stack after the current one, they are\n   * lost.\n   *\n   * @param to - The new URL\n   * @param state - Data to associate with the new location\n   */\n  push(to: To, state?: any): void;\n\n  /**\n   * Replaces the current location in the history stack with a new one.  The\n   * location that was replaced will no longer be available.\n   *\n   * @param to - The new URL\n   * @param state - Data to associate with the new location\n   */\n  replace(to: To, state?: any): void;\n\n  /**\n   * Navigates `n` entries backward/forward in the history stack relative to the\n   * current index. For example, a \"back\" navigation would use go(-1).\n   *\n   * @param delta - The delta in the stack index\n   */\n  go(delta: number): void;\n\n  /**\n   * Sets up a listener that will be called whenever the current location\n   * changes.\n   *\n   * @param listener - A function that will be called when the location changes\n   * @returns unlisten - A function that may be used to stop listening\n   */\n  listen(listener: Listener): () => void;\n}\n\ntype HistoryState = {\n  usr: any;\n  key?: string;\n  idx: number;\n};\n\nconst PopStateEventType = \"popstate\";\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Memory History\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A user-supplied object that describes a location. Used when providing\n * entries to `createMemoryHistory` via its `initialEntries` option.\n */\nexport type InitialEntry = string | Partial<Location>;\n\nexport type MemoryHistoryOptions = {\n  initialEntries?: InitialEntry[];\n  initialIndex?: number;\n  v5Compat?: boolean;\n};\n\n/**\n * A memory history stores locations in memory. This is useful in stateful\n * environments where there is no web browser, such as node tests or React\n * Native.\n */\nexport interface MemoryHistory extends History {\n  /**\n   * The current index in the history stack.\n   */\n  readonly index: number;\n}\n\n/**\n * Memory history stores the current location in memory. It is designed for use\n * in stateful non-browser environments like tests and React Native.\n */\nexport function createMemoryHistory(\n  options: MemoryHistoryOptions = {}\n): MemoryHistory {\n  let { initialEntries = [\"/\"], initialIndex, v5Compat = false } = options;\n  let entries: Location[]; // Declare so we can access from createMemoryLocation\n  entries = initialEntries.map((entry, index) =>\n    createMemoryLocation(\n      entry,\n      typeof entry === \"string\" ? null : entry.state,\n      index === 0 ? \"default\" : undefined\n    )\n  );\n  let index = clampIndex(\n    initialIndex == null ? entries.length - 1 : initialIndex\n  );\n  let action = Action.Pop;\n  let listener: Listener | null = null;\n\n  function clampIndex(n: number): number {\n    return Math.min(Math.max(n, 0), entries.length - 1);\n  }\n  function getCurrentLocation(): Location {\n    return entries[index];\n  }\n  function createMemoryLocation(\n    to: To,\n    state: any = null,\n    key?: string\n  ): Location {\n    let location = createLocation(\n      entries ? getCurrentLocation().pathname : \"/\",\n      to,\n      state,\n      key\n    );\n    warning(\n      location.pathname.charAt(0) === \"/\",\n      `relative pathnames are not supported in memory history: ${JSON.stringify(\n        to\n      )}`\n    );\n    return location;\n  }\n\n  function createHref(to: To) {\n    return typeof to === \"string\" ? to : createPath(to);\n  }\n\n  let history: MemoryHistory = {\n    get index() {\n      return index;\n    },\n    get action() {\n      return action;\n    },\n    get location() {\n      return getCurrentLocation();\n    },\n    createHref,\n    createURL(to) {\n      return new URL(createHref(to), \"http://localhost\");\n    },\n    encodeLocation(to: To) {\n      let path = typeof to === \"string\" ? parsePath(to) : to;\n      return {\n        pathname: path.pathname || \"\",\n        search: path.search || \"\",\n        hash: path.hash || \"\",\n      };\n    },\n    push(to, state) {\n      action = Action.Push;\n      let nextLocation = createMemoryLocation(to, state);\n      index += 1;\n      entries.splice(index, entries.length, nextLocation);\n      if (v5Compat && listener) {\n        listener({ action, location: nextLocation, delta: 1 });\n      }\n    },\n    replace(to, state) {\n      action = Action.Replace;\n      let nextLocation = createMemoryLocation(to, state);\n      entries[index] = nextLocation;\n      if (v5Compat && listener) {\n        listener({ action, location: nextLocation, delta: 0 });\n      }\n    },\n    go(delta) {\n      action = Action.Pop;\n      let nextIndex = clampIndex(index + delta);\n      let nextLocation = entries[nextIndex];\n      index = nextIndex;\n      if (listener) {\n        listener({ action, location: nextLocation, delta });\n      }\n    },\n    listen(fn: Listener) {\n      listener = fn;\n      return () => {\n        listener = null;\n      };\n    },\n  };\n\n  return history;\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Browser History\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A browser history stores the current location in regular URLs in a web\n * browser environment. This is the standard for most web apps and provides the\n * cleanest URLs the browser's address bar.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#browserhistory\n */\nexport interface BrowserHistory extends UrlHistory {}\n\nexport type BrowserHistoryOptions = UrlHistoryOptions;\n\n/**\n * Browser history stores the location in regular URLs. This is the standard for\n * most web apps, but it requires some configuration on the server to ensure you\n * serve the same app at multiple URLs.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory\n */\nexport function createBrowserHistory(\n  options: BrowserHistoryOptions = {}\n): BrowserHistory {\n  function createBrowserLocation(\n    window: Window,\n    globalHistory: Window[\"history\"]\n  ) {\n    let { pathname, search, hash } = window.location;\n    return createLocation(\n      \"\",\n      { pathname, search, hash },\n      // state defaults to `null` because `window.history.state` does\n      (globalHistory.state && globalHistory.state.usr) || null,\n      (globalHistory.state && globalHistory.state.key) || \"default\"\n    );\n  }\n\n  function createBrowserHref(window: Window, to: To) {\n    return typeof to === \"string\" ? to : createPath(to);\n  }\n\n  return getUrlBasedHistory(\n    createBrowserLocation,\n    createBrowserHref,\n    null,\n    options\n  );\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Hash History\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A hash history stores the current location in the fragment identifier portion\n * of the URL in a web browser environment.\n *\n * This is ideal for apps that do not control the server for some reason\n * (because the fragment identifier is never sent to the server), including some\n * shared hosting environments that do not provide fine-grained controls over\n * which pages are served at which URLs.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#hashhistory\n */\nexport interface HashHistory extends UrlHistory {}\n\nexport type HashHistoryOptions = UrlHistoryOptions;\n\n/**\n * Hash history stores the location in window.location.hash. This makes it ideal\n * for situations where you don't want to send the location to the server for\n * some reason, either because you do cannot configure it or the URL space is\n * reserved for something else.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createhashhistory\n */\nexport function createHashHistory(\n  options: HashHistoryOptions = {}\n): HashHistory {\n  function createHashLocation(\n    window: Window,\n    globalHistory: Window[\"history\"]\n  ) {\n    let {\n      pathname = \"/\",\n      search = \"\",\n      hash = \"\",\n    } = parsePath(window.location.hash.substr(1));\n\n    // Hash URL should always have a leading / just like window.location.pathname\n    // does, so if an app ends up at a route like /#something then we add a\n    // leading slash so all of our path-matching behaves the same as if it would\n    // in a browser router.  This is particularly important when there exists a\n    // root splat route (<Route path=\"*\">) since that matches internally against\n    // \"/*\" and we'd expect /#something to 404 in a hash router app.\n    if (!pathname.startsWith(\"/\") && !pathname.startsWith(\".\")) {\n      pathname = \"/\" + pathname;\n    }\n\n    return createLocation(\n      \"\",\n      { pathname, search, hash },\n      // state defaults to `null` because `window.history.state` does\n      (globalHistory.state && globalHistory.state.usr) || null,\n      (globalHistory.state && globalHistory.state.key) || \"default\"\n    );\n  }\n\n  function createHashHref(window: Window, to: To) {\n    let base = window.document.querySelector(\"base\");\n    let href = \"\";\n\n    if (base && base.getAttribute(\"href\")) {\n      let url = window.location.href;\n      let hashIndex = url.indexOf(\"#\");\n      href = hashIndex === -1 ? url : url.slice(0, hashIndex);\n    }\n\n    return href + \"#\" + (typeof to === \"string\" ? to : createPath(to));\n  }\n\n  function validateHashLocation(location: Location, to: To) {\n    warning(\n      location.pathname.charAt(0) === \"/\",\n      `relative pathnames are not supported in hash history.push(${JSON.stringify(\n        to\n      )})`\n    );\n  }\n\n  return getUrlBasedHistory(\n    createHashLocation,\n    createHashHref,\n    validateHashLocation,\n    options\n  );\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region UTILS\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * @private\n */\nexport function invariant(value: boolean, message?: string): asserts value;\nexport function invariant<T>(\n  value: T | null | undefined,\n  message?: string\n): asserts value is T;\nexport function invariant(value: any, message?: string) {\n  if (value === false || value === null || typeof value === \"undefined\") {\n    throw new Error(message);\n  }\n}\n\nexport function warning(cond: any, message: string) {\n  if (!cond) {\n    // eslint-disable-next-line no-console\n    if (typeof console !== \"undefined\") console.warn(message);\n\n    try {\n      // Welcome to debugging history!\n      //\n      // This error is thrown as a convenience, so you can more easily\n      // find the source for a warning that appears in the console by\n      // enabling \"pause on exceptions\" in your JavaScript debugger.\n      throw new Error(message);\n      // eslint-disable-next-line no-empty\n    } catch (e) {}\n  }\n}\n\nfunction createKey() {\n  return Math.random().toString(36).substr(2, 8);\n}\n\n/**\n * For browser-based histories, we combine the state and key into an object\n */\nfunction getHistoryState(location: Location, index: number): HistoryState {\n  return {\n    usr: location.state,\n    key: location.key,\n    idx: index,\n  };\n}\n\n/**\n * Creates a Location object with a unique key from the given Path\n */\nexport function createLocation(\n  current: string | Location,\n  to: To,\n  state: any = null,\n  key?: string\n): Readonly<Location> {\n  let location: Readonly<Location> = {\n    pathname: typeof current === \"string\" ? current : current.pathname,\n    search: \"\",\n    hash: \"\",\n    ...(typeof to === \"string\" ? parsePath(to) : to),\n    state,\n    // TODO: This could be cleaned up.  push/replace should probably just take\n    // full Locations now and avoid the need to run through this flow at all\n    // But that's a pretty big refactor to the current test suite so going to\n    // keep as is for the time being and just let any incoming keys take precedence\n    key: (to && (to as Location).key) || key || createKey(),\n  };\n  return location;\n}\n\n/**\n * Creates a string URL path from the given pathname, search, and hash components.\n */\nexport function createPath({\n  pathname = \"/\",\n  search = \"\",\n  hash = \"\",\n}: Partial<Path>) {\n  if (search && search !== \"?\")\n    pathname += search.charAt(0) === \"?\" ? search : \"?\" + search;\n  if (hash && hash !== \"#\")\n    pathname += hash.charAt(0) === \"#\" ? hash : \"#\" + hash;\n  return pathname;\n}\n\n/**\n * Parses a string URL path into its separate pathname, search, and hash components.\n */\nexport function parsePath(path: string): Partial<Path> {\n  let parsedPath: Partial<Path> = {};\n\n  if (path) {\n    let hashIndex = path.indexOf(\"#\");\n    if (hashIndex >= 0) {\n      parsedPath.hash = path.substr(hashIndex);\n      path = path.substr(0, hashIndex);\n    }\n\n    let searchIndex = path.indexOf(\"?\");\n    if (searchIndex >= 0) {\n      parsedPath.search = path.substr(searchIndex);\n      path = path.substr(0, searchIndex);\n    }\n\n    if (path) {\n      parsedPath.pathname = path;\n    }\n  }\n\n  return parsedPath;\n}\n\nexport interface UrlHistory extends History {}\n\nexport type UrlHistoryOptions = {\n  window?: Window;\n  v5Compat?: boolean;\n};\n\nfunction getUrlBasedHistory(\n  getLocation: (window: Window, globalHistory: Window[\"history\"]) => Location,\n  createHref: (window: Window, to: To) => string,\n  validateLocation: ((location: Location, to: To) => void) | null,\n  options: UrlHistoryOptions = {}\n): UrlHistory {\n  let { window = document.defaultView!, v5Compat = false } = options;\n  let globalHistory = window.history;\n  let action = Action.Pop;\n  let listener: Listener | null = null;\n\n  let index = getIndex()!;\n  // Index should only be null when we initialize. If not, it's because the\n  // user called history.pushState or history.replaceState directly, in which\n  // case we should log a warning as it will result in bugs.\n  if (index == null) {\n    index = 0;\n    globalHistory.replaceState({ ...globalHistory.state, idx: index }, \"\");\n  }\n\n  function getIndex(): number {\n    let state = globalHistory.state || { idx: null };\n    return state.idx;\n  }\n\n  function handlePop() {\n    action = Action.Pop;\n    let nextIndex = getIndex();\n    let delta = nextIndex == null ? null : nextIndex - index;\n    index = nextIndex;\n    if (listener) {\n      listener({ action, location: history.location, delta });\n    }\n  }\n\n  function push(to: To, state?: any) {\n    action = Action.Push;\n    let location = createLocation(history.location, to, state);\n    if (validateLocation) validateLocation(location, to);\n\n    index = getIndex() + 1;\n    let historyState = getHistoryState(location, index);\n    let url = history.createHref(location);\n\n    // try...catch because iOS limits us to 100 pushState calls :/\n    try {\n      globalHistory.pushState(historyState, \"\", url);\n    } catch (error) {\n      // If the exception is because `state` can't be serialized, let that throw\n      // outwards just like a replace call would so the dev knows the cause\n      // https://html.spec.whatwg.org/multipage/nav-history-apis.html#shared-history-push/replace-state-steps\n      // https://html.spec.whatwg.org/multipage/structured-data.html#structuredserializeinternal\n      if (error instanceof DOMException && error.name === \"DataCloneError\") {\n        throw error;\n      }\n      // They are going to lose state here, but there is no real\n      // way to warn them about it since the page will refresh...\n      window.location.assign(url);\n    }\n\n    if (v5Compat && listener) {\n      listener({ action, location: history.location, delta: 1 });\n    }\n  }\n\n  function replace(to: To, state?: any) {\n    action = Action.Replace;\n    let location = createLocation(history.location, to, state);\n    if (validateLocation) validateLocation(location, to);\n\n    index = getIndex();\n    let historyState = getHistoryState(location, index);\n    let url = history.createHref(location);\n    globalHistory.replaceState(historyState, \"\", url);\n\n    if (v5Compat && listener) {\n      listener({ action, location: history.location, delta: 0 });\n    }\n  }\n\n  function createURL(to: To): URL {\n    // window.location.origin is \"null\" (the literal string value) in Firefox\n    // under certain conditions, notably when serving from a local HTML file\n    // See https://bugzilla.mozilla.org/show_bug.cgi?id=878297\n    let base =\n      window.location.origin !== \"null\"\n        ? window.location.origin\n        : window.location.href;\n\n    let href = typeof to === \"string\" ? to : createPath(to);\n    // Treating this as a full URL will strip any trailing spaces so we need to\n    // pre-encode them since they might be part of a matching splat param from\n    // an ancestor route\n    href = href.replace(/ $/, \"%20\");\n    invariant(\n      base,\n      `No window.location.(origin|href) available to create URL for href: ${href}`\n    );\n    return new URL(href, base);\n  }\n\n  let history: History = {\n    get action() {\n      return action;\n    },\n    get location() {\n      return getLocation(window, globalHistory);\n    },\n    listen(fn: Listener) {\n      if (listener) {\n        throw new Error(\"A history only accepts one active listener\");\n      }\n      window.addEventListener(PopStateEventType, handlePop);\n      listener = fn;\n\n      return () => {\n        window.removeEventListener(PopStateEventType, handlePop);\n        listener = null;\n      };\n    },\n    createHref(to) {\n      return createHref(window, to);\n    },\n    createURL,\n    encodeLocation(to) {\n      // Encode a Location the same way window.location would\n      let url = createURL(to);\n      return {\n        pathname: url.pathname,\n        search: url.search,\n        hash: url.hash,\n      };\n    },\n    push,\n    replace,\n    go(n) {\n      return globalHistory.go(n);\n    },\n  };\n\n  return history;\n}\n\n//#endregion\n","import type { Location, Path, To } from \"./history\";\nimport { invariant, parsePath, warning } from \"./history\";\n\n/**\n * Map of routeId -> data returned from a loader/action/error\n */\nexport interface RouteData {\n  [routeId: string]: any;\n}\n\nexport enum ResultType {\n  data = \"data\",\n  deferred = \"deferred\",\n  redirect = \"redirect\",\n  error = \"error\",\n}\n\n/**\n * Successful result from a loader or action\n */\nexport interface SuccessResult {\n  type: ResultType.data;\n  data: unknown;\n  statusCode?: number;\n  headers?: Headers;\n}\n\n/**\n * Successful defer() result from a loader or action\n */\nexport interface DeferredResult {\n  type: ResultType.deferred;\n  deferredData: DeferredData;\n  statusCode?: number;\n  headers?: Headers;\n}\n\n/**\n * Redirect result from a loader or action\n */\nexport interface RedirectResult {\n  type: ResultType.redirect;\n  // We keep the raw Response for redirects so we can return it verbatim\n  response: Response;\n}\n\n/**\n * Unsuccessful result from a loader or action\n */\nexport interface ErrorResult {\n  type: ResultType.error;\n  error: unknown;\n  statusCode?: number;\n  headers?: Headers;\n}\n\n/**\n * Result from a loader or action - potentially successful or unsuccessful\n */\nexport type DataResult =\n  | SuccessResult\n  | DeferredResult\n  | RedirectResult\n  | ErrorResult;\n\ntype LowerCaseFormMethod = \"get\" | \"post\" | \"put\" | \"patch\" | \"delete\";\ntype UpperCaseFormMethod = Uppercase<LowerCaseFormMethod>;\n\n/**\n * Users can specify either lowercase or uppercase form methods on `<Form>`,\n * useSubmit(), `<fetcher.Form>`, etc.\n */\nexport type HTMLFormMethod = LowerCaseFormMethod | UpperCaseFormMethod;\n\n/**\n * Active navigation/fetcher form methods are exposed in lowercase on the\n * RouterState\n */\nexport type FormMethod = LowerCaseFormMethod;\nexport type MutationFormMethod = Exclude<FormMethod, \"get\">;\n\n/**\n * In v7, active navigation/fetcher form methods are exposed in uppercase on the\n * RouterState.  This is to align with the normalization done via fetch().\n */\nexport type V7_FormMethod = UpperCaseFormMethod;\nexport type V7_MutationFormMethod = Exclude<V7_FormMethod, \"GET\">;\n\nexport type FormEncType =\n  | \"application/x-www-form-urlencoded\"\n  | \"multipart/form-data\"\n  | \"application/json\"\n  | \"text/plain\";\n\n// Thanks https://github.com/sindresorhus/type-fest!\ntype JsonObject = { [Key in string]: JsonValue } & {\n  [Key in string]?: JsonValue | undefined;\n};\ntype JsonArray = JsonValue[] | readonly JsonValue[];\ntype JsonPrimitive = string | number | boolean | null;\ntype JsonValue = JsonPrimitive | JsonObject | JsonArray;\n\n/**\n * @private\n * Internal interface to pass around for action submissions, not intended for\n * external consumption\n */\nexport type Submission =\n  | {\n      formMethod: FormMethod | V7_FormMethod;\n      formAction: string;\n      formEncType: FormEncType;\n      formData: FormData;\n      json: undefined;\n      text: undefined;\n    }\n  | {\n      formMethod: FormMethod | V7_FormMethod;\n      formAction: string;\n      formEncType: FormEncType;\n      formData: undefined;\n      json: JsonValue;\n      text: undefined;\n    }\n  | {\n      formMethod: FormMethod | V7_FormMethod;\n      formAction: string;\n      formEncType: FormEncType;\n      formData: undefined;\n      json: undefined;\n      text: string;\n    };\n\n/**\n * @private\n * Arguments passed to route loader/action functions.  Same for now but we keep\n * this as a private implementation detail in case they diverge in the future.\n */\ninterface DataFunctionArgs<Context> {\n  request: Request;\n  params: Params;\n  context?: Context;\n}\n\n// TODO: (v7) Change the defaults from any to unknown in and remove Remix wrappers:\n//   ActionFunction, ActionFunctionArgs, LoaderFunction, LoaderFunctionArgs\n//   Also, make them a type alias instead of an interface\n\n/**\n * Arguments passed to loader functions\n */\nexport interface LoaderFunctionArgs<Context = any>\n  extends DataFunctionArgs<Context> {}\n\n/**\n * Arguments passed to action functions\n */\nexport interface ActionFunctionArgs<Context = any>\n  extends DataFunctionArgs<Context> {}\n\n/**\n * Loaders and actions can return anything except `undefined` (`null` is a\n * valid return value if there is no data to return).  Responses are preferred\n * and will ease any future migration to Remix\n */\ntype DataFunctionValue = Response | NonNullable<unknown> | null;\n\ntype DataFunctionReturnValue = Promise<DataFunctionValue> | DataFunctionValue;\n\n/**\n * Route loader function signature\n */\nexport type LoaderFunction<Context = any> = {\n  (\n    args: LoaderFunctionArgs<Context>,\n    handlerCtx?: unknown\n  ): DataFunctionReturnValue;\n} & { hydrate?: boolean };\n\n/**\n * Route action function signature\n */\nexport interface ActionFunction<Context = any> {\n  (\n    args: ActionFunctionArgs<Context>,\n    handlerCtx?: unknown\n  ): DataFunctionReturnValue;\n}\n\n/**\n * Arguments passed to shouldRevalidate function\n */\nexport interface ShouldRevalidateFunctionArgs {\n  currentUrl: URL;\n  currentParams: AgnosticDataRouteMatch[\"params\"];\n  nextUrl: URL;\n  nextParams: AgnosticDataRouteMatch[\"params\"];\n  formMethod?: Submission[\"formMethod\"];\n  formAction?: Submission[\"formAction\"];\n  formEncType?: Submission[\"formEncType\"];\n  text?: Submission[\"text\"];\n  formData?: Submission[\"formData\"];\n  json?: Submission[\"json\"];\n  actionStatus?: number;\n  actionResult?: any;\n  defaultShouldRevalidate: boolean;\n}\n\n/**\n * Route shouldRevalidate function signature.  This runs after any submission\n * (navigation or fetcher), so we flatten the navigation/fetcher submission\n * onto the arguments.  It shouldn't matter whether it came from a navigation\n * or a fetcher, what really matters is the URLs and the formData since loaders\n * have to re-run based on the data models that were potentially mutated.\n */\nexport interface ShouldRevalidateFunction {\n  (args: ShouldRevalidateFunctionArgs): boolean;\n}\n\n/**\n * Function provided by the framework-aware layers to set `hasErrorBoundary`\n * from the framework-aware `errorElement` prop\n *\n * @deprecated Use `mapRouteProperties` instead\n */\nexport interface DetectErrorBoundaryFunction {\n  (route: AgnosticRouteObject): boolean;\n}\n\nexport interface DataStrategyMatch\n  extends AgnosticRouteMatch<string, AgnosticDataRouteObject> {\n  shouldLoad: boolean;\n  resolve: (\n    handlerOverride?: (\n      handler: (ctx?: unknown) => DataFunctionReturnValue\n    ) => DataFunctionReturnValue\n  ) => Promise<DataStrategyResult>;\n}\n\nexport interface DataStrategyFunctionArgs<Context = any>\n  extends DataFunctionArgs<Context> {\n  matches: DataStrategyMatch[];\n  fetcherKey: string | null;\n}\n\n/**\n * Result from a loader or action called via dataStrategy\n */\nexport interface DataStrategyResult {\n  type: \"data\" | \"error\";\n  result: unknown; // data, Error, Response, DeferredData, DataWithResponseInit\n}\n\nexport interface DataStrategyFunction {\n  (args: DataStrategyFunctionArgs): Promise<Record<string, DataStrategyResult>>;\n}\n\nexport type AgnosticPatchRoutesOnNavigationFunctionArgs<\n  O extends AgnosticRouteObject = AgnosticRouteObject,\n  M extends AgnosticRouteMatch = AgnosticRouteMatch\n> = {\n  path: string;\n  matches: M[];\n  patch: (routeId: string | null, children: O[]) => void;\n};\n\nexport type AgnosticPatchRoutesOnNavigationFunction<\n  O extends AgnosticRouteObject = AgnosticRouteObject,\n  M extends AgnosticRouteMatch = AgnosticRouteMatch\n> = (\n  opts: AgnosticPatchRoutesOnNavigationFunctionArgs<O, M>\n) => void | Promise<void>;\n\n/**\n * Function provided by the framework-aware layers to set any framework-specific\n * properties from framework-agnostic properties\n */\nexport interface MapRoutePropertiesFunction {\n  (route: AgnosticRouteObject): {\n    hasErrorBoundary: boolean;\n  } & Record<string, any>;\n}\n\n/**\n * Keys we cannot change from within a lazy() function. We spread all other keys\n * onto the route. Either they're meaningful to the router, or they'll get\n * ignored.\n */\nexport type ImmutableRouteKey =\n  | \"lazy\"\n  | \"caseSensitive\"\n  | \"path\"\n  | \"id\"\n  | \"index\"\n  | \"children\";\n\nexport const immutableRouteKeys = new Set<ImmutableRouteKey>([\n  \"lazy\",\n  \"caseSensitive\",\n  \"path\",\n  \"id\",\n  \"index\",\n  \"children\",\n]);\n\ntype RequireOne<T, Key = keyof T> = Exclude<\n  {\n    [K in keyof T]: K extends Key ? Omit<T, K> & Required<Pick<T, K>> : never;\n  }[keyof T],\n  undefined\n>;\n\n/**\n * lazy() function to load a route definition, which can add non-matching\n * related properties to a route\n */\nexport interface LazyRouteFunction<R extends AgnosticRouteObject> {\n  (): Promise<RequireOne<Omit<R, ImmutableRouteKey>>>;\n}\n\n/**\n * Base RouteObject with common props shared by all types of routes\n */\ntype AgnosticBaseRouteObject = {\n  caseSensitive?: boolean;\n  path?: string;\n  id?: string;\n  loader?: LoaderFunction | boolean;\n  action?: ActionFunction | boolean;\n  hasErrorBoundary?: boolean;\n  shouldRevalidate?: ShouldRevalidateFunction;\n  handle?: any;\n  lazy?: LazyRouteFunction<AgnosticBaseRouteObject>;\n};\n\n/**\n * Index routes must not have children\n */\nexport type AgnosticIndexRouteObject = AgnosticBaseRouteObject & {\n  children?: undefined;\n  index: true;\n};\n\n/**\n * Non-index routes may have children, but cannot have index\n */\nexport type AgnosticNonIndexRouteObject = AgnosticBaseRouteObject & {\n  children?: AgnosticRouteObject[];\n  index?: false;\n};\n\n/**\n * A route object represents a logical route, with (optionally) its child\n * routes organized in a tree-like structure.\n */\nexport type AgnosticRouteObject =\n  | AgnosticIndexRouteObject\n  | AgnosticNonIndexRouteObject;\n\nexport type AgnosticDataIndexRouteObject = AgnosticIndexRouteObject & {\n  id: string;\n};\n\nexport type AgnosticDataNonIndexRouteObject = AgnosticNonIndexRouteObject & {\n  children?: AgnosticDataRouteObject[];\n  id: string;\n};\n\n/**\n * A data route object, which is just a RouteObject with a required unique ID\n */\nexport type AgnosticDataRouteObject =\n  | AgnosticDataIndexRouteObject\n  | AgnosticDataNonIndexRouteObject;\n\nexport type RouteManifest = Record<string, AgnosticDataRouteObject | undefined>;\n\n// Recursive helper for finding path parameters in the absence of wildcards\ntype _PathParam<Path extends string> =\n  // split path into individual path segments\n  Path extends `${infer L}/${infer R}`\n    ? _PathParam<L> | _PathParam<R>\n    : // find params after `:`\n    Path extends `:${infer Param}`\n    ? Param extends `${infer Optional}?`\n      ? Optional\n      : Param\n    : // otherwise, there aren't any params present\n      never;\n\n/**\n * Examples:\n * \"/a/b/*\" -> \"*\"\n * \":a\" -> \"a\"\n * \"/a/:b\" -> \"b\"\n * \"/a/blahblahblah:b\" -> \"b\"\n * \"/:a/:b\" -> \"a\" | \"b\"\n * \"/:a/b/:c/*\" -> \"a\" | \"c\" | \"*\"\n */\nexport type PathParam<Path extends string> =\n  // check if path is just a wildcard\n  Path extends \"*\" | \"/*\"\n    ? \"*\"\n    : // look for wildcard at the end of the path\n    Path extends `${infer Rest}/*`\n    ? \"*\" | _PathParam<Rest>\n    : // look for params in the absence of wildcards\n      _PathParam<Path>;\n\n// Attempt to parse the given string segment. If it fails, then just return the\n// plain string type as a default fallback. Otherwise, return the union of the\n// parsed string literals that were referenced as dynamic segments in the route.\nexport type ParamParseKey<Segment extends string> =\n  // if you could not find path params, fallback to `string`\n  [PathParam<Segment>] extends [never] ? string : PathParam<Segment>;\n\n/**\n * The parameters that were parsed from the URL path.\n */\nexport type Params<Key extends string = string> = {\n  readonly [key in Key]: string | undefined;\n};\n\n/**\n * A RouteMatch contains info about how a route matched a URL.\n */\nexport interface AgnosticRouteMatch<\n  ParamKey extends string = string,\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n> {\n  /**\n   * The names and values of dynamic parameters in the URL.\n   */\n  params: Params<ParamKey>;\n  /**\n   * The portion of the URL pathname that was matched.\n   */\n  pathname: string;\n  /**\n   * The portion of the URL pathname that was matched before child routes.\n   */\n  pathnameBase: string;\n  /**\n   * The route object that was used to match.\n   */\n  route: RouteObjectType;\n}\n\nexport interface AgnosticDataRouteMatch\n  extends AgnosticRouteMatch<string, AgnosticDataRouteObject> {}\n\nfunction isIndexRoute(\n  route: AgnosticRouteObject\n): route is AgnosticIndexRouteObject {\n  return route.index === true;\n}\n\n// Walk the route tree generating unique IDs where necessary, so we are working\n// solely with AgnosticDataRouteObject's within the Router\nexport function convertRoutesToDataRoutes(\n  routes: AgnosticRouteObject[],\n  mapRouteProperties: MapRoutePropertiesFunction,\n  parentPath: string[] = [],\n  manifest: RouteManifest = {}\n): AgnosticDataRouteObject[] {\n  return routes.map((route, index) => {\n    let treePath = [...parentPath, String(index)];\n    let id = typeof route.id === \"string\" ? route.id : treePath.join(\"-\");\n    invariant(\n      route.index !== true || !route.children,\n      `Cannot specify children on an index route`\n    );\n    invariant(\n      !manifest[id],\n      `Found a route id collision on id \"${id}\".  Route ` +\n        \"id's must be globally unique within Data Router usages\"\n    );\n\n    if (isIndexRoute(route)) {\n      let indexRoute: AgnosticDataIndexRouteObject = {\n        ...route,\n        ...mapRouteProperties(route),\n        id,\n      };\n      manifest[id] = indexRoute;\n      return indexRoute;\n    } else {\n      let pathOrLayoutRoute: AgnosticDataNonIndexRouteObject = {\n        ...route,\n        ...mapRouteProperties(route),\n        id,\n        children: undefined,\n      };\n      manifest[id] = pathOrLayoutRoute;\n\n      if (route.children) {\n        pathOrLayoutRoute.children = convertRoutesToDataRoutes(\n          route.children,\n          mapRouteProperties,\n          treePath,\n          manifest\n        );\n      }\n\n      return pathOrLayoutRoute;\n    }\n  });\n}\n\n/**\n * Matches the given routes to a location and returns the match data.\n *\n * @see https://reactrouter.com/v6/utils/match-routes\n */\nexport function matchRoutes<\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n>(\n  routes: RouteObjectType[],\n  locationArg: Partial<Location> | string,\n  basename = \"/\"\n): AgnosticRouteMatch<string, RouteObjectType>[] | null {\n  return matchRoutesImpl(routes, locationArg, basename, false);\n}\n\nexport function matchRoutesImpl<\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n>(\n  routes: RouteObjectType[],\n  locationArg: Partial<Location> | string,\n  basename: string,\n  allowPartial: boolean\n): AgnosticRouteMatch<string, RouteObjectType>[] | null {\n  let location =\n    typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n\n  let pathname = stripBasename(location.pathname || \"/\", basename);\n\n  if (pathname == null) {\n    return null;\n  }\n\n  let branches = flattenRoutes(routes);\n  rankRouteBranches(branches);\n\n  let matches = null;\n  for (let i = 0; matches == null && i < branches.length; ++i) {\n    // Incoming pathnames are generally encoded from either window.location\n    // or from router.navigate, but we want to match against the unencoded\n    // paths in the route definitions.  Memory router locations won't be\n    // encoded here but there also shouldn't be anything to decode so this\n    // should be a safe operation.  This avoids needing matchRoutes to be\n    // history-aware.\n    let decoded = decodePath(pathname);\n    matches = matchRouteBranch<string, RouteObjectType>(\n      branches[i],\n      decoded,\n      allowPartial\n    );\n  }\n\n  return matches;\n}\n\nexport interface UIMatch<Data = unknown, Handle = unknown> {\n  id: string;\n  pathname: string;\n  params: AgnosticRouteMatch[\"params\"];\n  data: Data;\n  handle: Handle;\n}\n\nexport function convertRouteMatchToUiMatch(\n  match: AgnosticDataRouteMatch,\n  loaderData: RouteData\n): UIMatch {\n  let { route, pathname, params } = match;\n  return {\n    id: route.id,\n    pathname,\n    params,\n    data: loaderData[route.id],\n    handle: route.handle,\n  };\n}\n\ninterface RouteMeta<\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n> {\n  relativePath: string;\n  caseSensitive: boolean;\n  childrenIndex: number;\n  route: RouteObjectType;\n}\n\ninterface RouteBranch<\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n> {\n  path: string;\n  score: number;\n  routesMeta: RouteMeta<RouteObjectType>[];\n}\n\nfunction flattenRoutes<\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n>(\n  routes: RouteObjectType[],\n  branches: RouteBranch<RouteObjectType>[] = [],\n  parentsMeta: RouteMeta<RouteObjectType>[] = [],\n  parentPath = \"\"\n): RouteBranch<RouteObjectType>[] {\n  let flattenRoute = (\n    route: RouteObjectType,\n    index: number,\n    relativePath?: string\n  ) => {\n    let meta: RouteMeta<RouteObjectType> = {\n      relativePath:\n        relativePath === undefined ? route.path || \"\" : relativePath,\n      caseSensitive: route.caseSensitive === true,\n      childrenIndex: index,\n      route,\n    };\n\n    if (meta.relativePath.startsWith(\"/\")) {\n      invariant(\n        meta.relativePath.startsWith(parentPath),\n        `Absolute route path \"${meta.relativePath}\" nested under path ` +\n          `\"${parentPath}\" is not valid. An absolute child route path ` +\n          `must start with the combined path of all its parent routes.`\n      );\n\n      meta.relativePath = meta.relativePath.slice(parentPath.length);\n    }\n\n    let path = joinPaths([parentPath, meta.relativePath]);\n    let routesMeta = parentsMeta.concat(meta);\n\n    // Add the children before adding this route to the array, so we traverse the\n    // route tree depth-first and child routes appear before their parents in\n    // the \"flattened\" version.\n    if (route.children && route.children.length > 0) {\n      invariant(\n        // Our types know better, but runtime JS may not!\n        // @ts-expect-error\n        route.index !== true,\n        `Index routes must not have child routes. Please remove ` +\n          `all child routes from route path \"${path}\".`\n      );\n      flattenRoutes(route.children, branches, routesMeta, path);\n    }\n\n    // Routes without a path shouldn't ever match by themselves unless they are\n    // index routes, so don't add them to the list of possible branches.\n    if (route.path == null && !route.index) {\n      return;\n    }\n\n    branches.push({\n      path,\n      score: computeScore(path, route.index),\n      routesMeta,\n    });\n  };\n  routes.forEach((route, index) => {\n    // coarse-grain check for optional params\n    if (route.path === \"\" || !route.path?.includes(\"?\")) {\n      flattenRoute(route, index);\n    } else {\n      for (let exploded of explodeOptionalSegments(route.path)) {\n        flattenRoute(route, index, exploded);\n      }\n    }\n  });\n\n  return branches;\n}\n\n/**\n * Computes all combinations of optional path segments for a given path,\n * excluding combinations that are ambiguous and of lower priority.\n *\n * For example, `/one/:two?/three/:four?/:five?` explodes to:\n * - `/one/three`\n * - `/one/:two/three`\n * - `/one/three/:four`\n * - `/one/three/:five`\n * - `/one/:two/three/:four`\n * - `/one/:two/three/:five`\n * - `/one/three/:four/:five`\n * - `/one/:two/three/:four/:five`\n */\nfunction explodeOptionalSegments(path: string): string[] {\n  let segments = path.split(\"/\");\n  if (segments.length === 0) return [];\n\n  let [first, ...rest] = segments;\n\n  // Optional path segments are denoted by a trailing `?`\n  let isOptional = first.endsWith(\"?\");\n  // Compute the corresponding required segment: `foo?` -> `foo`\n  let required = first.replace(/\\?$/, \"\");\n\n  if (rest.length === 0) {\n    // Intepret empty string as omitting an optional segment\n    // `[\"one\", \"\", \"three\"]` corresponds to omitting `:two` from `/one/:two?/three` -> `/one/three`\n    return isOptional ? [required, \"\"] : [required];\n  }\n\n  let restExploded = explodeOptionalSegments(rest.join(\"/\"));\n\n  let result: string[] = [];\n\n  // All child paths with the prefix.  Do this for all children before the\n  // optional version for all children, so we get consistent ordering where the\n  // parent optional aspect is preferred as required.  Otherwise, we can get\n  // child sections interspersed where deeper optional segments are higher than\n  // parent optional segments, where for example, /:two would explode _earlier_\n  // then /:one.  By always including the parent as required _for all children_\n  // first, we avoid this issue\n  result.push(\n    ...restExploded.map((subpath) =>\n      subpath === \"\" ? required : [required, subpath].join(\"/\")\n    )\n  );\n\n  // Then, if this is an optional value, add all child versions without\n  if (isOptional) {\n    result.push(...restExploded);\n  }\n\n  // for absolute paths, ensure `/` instead of empty segment\n  return result.map((exploded) =>\n    path.startsWith(\"/\") && exploded === \"\" ? \"/\" : exploded\n  );\n}\n\nfunction rankRouteBranches(branches: RouteBranch[]): void {\n  branches.sort((a, b) =>\n    a.score !== b.score\n      ? b.score - a.score // Higher score first\n      : compareIndexes(\n          a.routesMeta.map((meta) => meta.childrenIndex),\n          b.routesMeta.map((meta) => meta.childrenIndex)\n        )\n  );\n}\n\nconst paramRe = /^:[\\w-]+$/;\nconst dynamicSegmentValue = 3;\nconst indexRouteValue = 2;\nconst emptySegmentValue = 1;\nconst staticSegmentValue = 10;\nconst splatPenalty = -2;\nconst isSplat = (s: string) => s === \"*\";\n\nfunction computeScore(path: string, index: boolean | undefined): number {\n  let segments = path.split(\"/\");\n  let initialScore = segments.length;\n  if (segments.some(isSplat)) {\n    initialScore += splatPenalty;\n  }\n\n  if (index) {\n    initialScore += indexRouteValue;\n  }\n\n  return segments\n    .filter((s) => !isSplat(s))\n    .reduce(\n      (score, segment) =>\n        score +\n        (paramRe.test(segment)\n          ? dynamicSegmentValue\n          : segment === \"\"\n          ? emptySegmentValue\n          : staticSegmentValue),\n      initialScore\n    );\n}\n\nfunction compareIndexes(a: number[], b: number[]): number {\n  let siblings =\n    a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]);\n\n  return siblings\n    ? // If two routes are siblings, we should try to match the earlier sibling\n      // first. This allows people to have fine-grained control over the matching\n      // behavior by simply putting routes with identical paths in the order they\n      // want them tried.\n      a[a.length - 1] - b[b.length - 1]\n    : // Otherwise, it doesn't really make sense to rank non-siblings by index,\n      // so they sort equally.\n      0;\n}\n\nfunction matchRouteBranch<\n  ParamKey extends string = string,\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n>(\n  branch: RouteBranch<RouteObjectType>,\n  pathname: string,\n  allowPartial = false\n): AgnosticRouteMatch<ParamKey, RouteObjectType>[] | null {\n  let { routesMeta } = branch;\n\n  let matchedParams = {};\n  let matchedPathname = \"/\";\n  let matches: AgnosticRouteMatch<ParamKey, RouteObjectType>[] = [];\n  for (let i = 0; i < routesMeta.length; ++i) {\n    let meta = routesMeta[i];\n    let end = i === routesMeta.length - 1;\n    let remainingPathname =\n      matchedPathname === \"/\"\n        ? pathname\n        : pathname.slice(matchedPathname.length) || \"/\";\n    let match = matchPath(\n      { path: meta.relativePath, caseSensitive: meta.caseSensitive, end },\n      remainingPathname\n    );\n\n    let route = meta.route;\n\n    if (\n      !match &&\n      end &&\n      allowPartial &&\n      !routesMeta[routesMeta.length - 1].route.index\n    ) {\n      match = matchPath(\n        {\n          path: meta.relativePath,\n          caseSensitive: meta.caseSensitive,\n          end: false,\n        },\n        remainingPathname\n      );\n    }\n\n    if (!match) {\n      return null;\n    }\n\n    Object.assign(matchedParams, match.params);\n\n    matches.push({\n      // TODO: Can this as be avoided?\n      params: matchedParams as Params<ParamKey>,\n      pathname: joinPaths([matchedPathname, match.pathname]),\n      pathnameBase: normalizePathname(\n        joinPaths([matchedPathname, match.pathnameBase])\n      ),\n      route,\n    });\n\n    if (match.pathnameBase !== \"/\") {\n      matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);\n    }\n  }\n\n  return matches;\n}\n\n/**\n * Returns a path with params interpolated.\n *\n * @see https://reactrouter.com/v6/utils/generate-path\n */\nexport function generatePath<Path extends string>(\n  originalPath: Path,\n  params: {\n    [key in PathParam<Path>]: string | null;\n  } = {} as any\n): string {\n  let path: string = originalPath;\n  if (path.endsWith(\"*\") && path !== \"*\" && !path.endsWith(\"/*\")) {\n    warning(\n      false,\n      `Route path \"${path}\" will be treated as if it were ` +\n        `\"${path.replace(/\\*$/, \"/*\")}\" because the \\`*\\` character must ` +\n        `always follow a \\`/\\` in the pattern. To get rid of this warning, ` +\n        `please change the route path to \"${path.replace(/\\*$/, \"/*\")}\".`\n    );\n    path = path.replace(/\\*$/, \"/*\") as Path;\n  }\n\n  // ensure `/` is added at the beginning if the path is absolute\n  const prefix = path.startsWith(\"/\") ? \"/\" : \"\";\n\n  const stringify = (p: any) =>\n    p == null ? \"\" : typeof p === \"string\" ? p : String(p);\n\n  const segments = path\n    .split(/\\/+/)\n    .map((segment, index, array) => {\n      const isLastSegment = index === array.length - 1;\n\n      // only apply the splat if it's the last segment\n      if (isLastSegment && segment === \"*\") {\n        const star = \"*\" as PathParam<Path>;\n        // Apply the splat\n        return stringify(params[star]);\n      }\n\n      const keyMatch = segment.match(/^:([\\w-]+)(\\??)$/);\n      if (keyMatch) {\n        const [, key, optional] = keyMatch;\n        let param = params[key as PathParam<Path>];\n        invariant(optional === \"?\" || param != null, `Missing \":${key}\" param`);\n        return stringify(param);\n      }\n\n      // Remove any optional markers from optional static segments\n      return segment.replace(/\\?$/g, \"\");\n    })\n    // Remove empty segments\n    .filter((segment) => !!segment);\n\n  return prefix + segments.join(\"/\");\n}\n\n/**\n * A PathPattern is used to match on some portion of a URL pathname.\n */\nexport interface PathPattern<Path extends string = string> {\n  /**\n   * A string to match against a URL pathname. May contain `:id`-style segments\n   * to indicate placeholders for dynamic parameters. May also end with `/*` to\n   * indicate matching the rest of the URL pathname.\n   */\n  path: Path;\n  /**\n   * Should be `true` if the static portions of the `path` should be matched in\n   * the same case.\n   */\n  caseSensitive?: boolean;\n  /**\n   * Should be `true` if this pattern should match the entire URL pathname.\n   */\n  end?: boolean;\n}\n\n/**\n * A PathMatch contains info about how a PathPattern matched on a URL pathname.\n */\nexport interface PathMatch<ParamKey extends string = string> {\n  /**\n   * The names and values of dynamic parameters in the URL.\n   */\n  params: Params<ParamKey>;\n  /**\n   * The portion of the URL pathname that was matched.\n   */\n  pathname: string;\n  /**\n   * The portion of the URL pathname that was matched before child routes.\n   */\n  pathnameBase: string;\n  /**\n   * The pattern that was used to match.\n   */\n  pattern: PathPattern;\n}\n\ntype Mutable<T> = {\n  -readonly [P in keyof T]: T[P];\n};\n\n/**\n * Performs pattern matching on a URL pathname and returns information about\n * the match.\n *\n * @see https://reactrouter.com/v6/utils/match-path\n */\nexport function matchPath<\n  ParamKey extends ParamParseKey<Path>,\n  Path extends string\n>(\n  pattern: PathPattern<Path> | Path,\n  pathname: string\n): PathMatch<ParamKey> | null {\n  if (typeof pattern === \"string\") {\n    pattern = { path: pattern, caseSensitive: false, end: true };\n  }\n\n  let [matcher, compiledParams] = compilePath(\n    pattern.path,\n    pattern.caseSensitive,\n    pattern.end\n  );\n\n  let match = pathname.match(matcher);\n  if (!match) return null;\n\n  let matchedPathname = match[0];\n  let pathnameBase = matchedPathname.replace(/(.)\\/+$/, \"$1\");\n  let captureGroups = match.slice(1);\n  let params: Params = compiledParams.reduce<Mutable<Params>>(\n    (memo, { paramName, isOptional }, index) => {\n      // We need to compute the pathnameBase here using the raw splat value\n      // instead of using params[\"*\"] later because it will be decoded then\n      if (paramName === \"*\") {\n        let splatValue = captureGroups[index] || \"\";\n        pathnameBase = matchedPathname\n          .slice(0, matchedPathname.length - splatValue.length)\n          .replace(/(.)\\/+$/, \"$1\");\n      }\n\n      const value = captureGroups[index];\n      if (isOptional && !value) {\n        memo[paramName] = undefined;\n      } else {\n        memo[paramName] = (value || \"\").replace(/%2F/g, \"/\");\n      }\n      return memo;\n    },\n    {}\n  );\n\n  return {\n    params,\n    pathname: matchedPathname,\n    pathnameBase,\n    pattern,\n  };\n}\n\ntype CompiledPathParam = { paramName: string; isOptional?: boolean };\n\nfunction compilePath(\n  path: string,\n  caseSensitive = false,\n  end = true\n): [RegExp, CompiledPathParam[]] {\n  warning(\n    path === \"*\" || !path.endsWith(\"*\") || path.endsWith(\"/*\"),\n    `Route path \"${path}\" will be treated as if it were ` +\n      `\"${path.replace(/\\*$/, \"/*\")}\" because the \\`*\\` character must ` +\n      `always follow a \\`/\\` in the pattern. To get rid of this warning, ` +\n      `please change the route path to \"${path.replace(/\\*$/, \"/*\")}\".`\n  );\n\n  let params: CompiledPathParam[] = [];\n  let regexpSource =\n    \"^\" +\n    path\n      .replace(/\\/*\\*?$/, \"\") // Ignore trailing / and /*, we'll handle it below\n      .replace(/^\\/*/, \"/\") // Make sure it has a leading /\n      .replace(/[\\\\.*+^${}|()[\\]]/g, \"\\\\$&\") // Escape special regex chars\n      .replace(\n        /\\/:([\\w-]+)(\\?)?/g,\n        (_: string, paramName: string, isOptional) => {\n          params.push({ paramName, isOptional: isOptional != null });\n          return isOptional ? \"/?([^\\\\/]+)?\" : \"/([^\\\\/]+)\";\n        }\n      );\n\n  if (path.endsWith(\"*\")) {\n    params.push({ paramName: \"*\" });\n    regexpSource +=\n      path === \"*\" || path === \"/*\"\n        ? \"(.*)$\" // Already matched the initial /, just match the rest\n        : \"(?:\\\\/(.+)|\\\\/*)$\"; // Don't include the / in params[\"*\"]\n  } else if (end) {\n    // When matching to the end, ignore trailing slashes\n    regexpSource += \"\\\\/*$\";\n  } else if (path !== \"\" && path !== \"/\") {\n    // If our path is non-empty and contains anything beyond an initial slash,\n    // then we have _some_ form of path in our regex, so we should expect to\n    // match only if we find the end of this path segment.  Look for an optional\n    // non-captured trailing slash (to match a portion of the URL) or the end\n    // of the path (if we've matched to the end).  We used to do this with a\n    // word boundary but that gives false positives on routes like\n    // /user-preferences since `-` counts as a word boundary.\n    regexpSource += \"(?:(?=\\\\/|$))\";\n  } else {\n    // Nothing to match for \"\" or \"/\"\n  }\n\n  let matcher = new RegExp(regexpSource, caseSensitive ? undefined : \"i\");\n\n  return [matcher, params];\n}\n\nexport function decodePath(value: string) {\n  try {\n    return value\n      .split(\"/\")\n      .map((v) => decodeURIComponent(v).replace(/\\//g, \"%2F\"))\n      .join(\"/\");\n  } catch (error) {\n    warning(\n      false,\n      `The URL path \"${value}\" could not be decoded because it is is a ` +\n        `malformed URL segment. This is probably due to a bad percent ` +\n        `encoding (${error}).`\n    );\n\n    return value;\n  }\n}\n\n/**\n * @private\n */\nexport function stripBasename(\n  pathname: string,\n  basename: string\n): string | null {\n  if (basename === \"/\") return pathname;\n\n  if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {\n    return null;\n  }\n\n  // We want to leave trailing slash behavior in the user's control, so if they\n  // specify a basename with a trailing slash, we should support it\n  let startIndex = basename.endsWith(\"/\")\n    ? basename.length - 1\n    : basename.length;\n  let nextChar = pathname.charAt(startIndex);\n  if (nextChar && nextChar !== \"/\") {\n    // pathname does not start with basename/\n    return null;\n  }\n\n  return pathname.slice(startIndex) || \"/\";\n}\n\n/**\n * Returns a resolved path object relative to the given pathname.\n *\n * @see https://reactrouter.com/v6/utils/resolve-path\n */\nexport function resolvePath(to: To, fromPathname = \"/\"): Path {\n  let {\n    pathname: toPathname,\n    search = \"\",\n    hash = \"\",\n  } = typeof to === \"string\" ? parsePath(to) : to;\n\n  let pathname = toPathname\n    ? toPathname.startsWith(\"/\")\n      ? toPathname\n      : resolvePathname(toPathname, fromPathname)\n    : fromPathname;\n\n  return {\n    pathname,\n    search: normalizeSearch(search),\n    hash: normalizeHash(hash),\n  };\n}\n\nfunction resolvePathname(relativePath: string, fromPathname: string): string {\n  let segments = fromPathname.replace(/\\/+$/, \"\").split(\"/\");\n  let relativeSegments = relativePath.split(\"/\");\n\n  relativeSegments.forEach((segment) => {\n    if (segment === \"..\") {\n      // Keep the root \"\" segment so the pathname starts at /\n      if (segments.length > 1) segments.pop();\n    } else if (segment !== \".\") {\n      segments.push(segment);\n    }\n  });\n\n  return segments.length > 1 ? segments.join(\"/\") : \"/\";\n}\n\nfunction getInvalidPathError(\n  char: string,\n  field: string,\n  dest: string,\n  path: Partial<Path>\n) {\n  return (\n    `Cannot include a '${char}' character in a manually specified ` +\n    `\\`to.${field}\\` field [${JSON.stringify(\n      path\n    )}].  Please separate it out to the ` +\n    `\\`to.${dest}\\` field. Alternatively you may provide the full path as ` +\n    `a string in <Link to=\"...\"> and the router will parse it for you.`\n  );\n}\n\n/**\n * @private\n *\n * When processing relative navigation we want to ignore ancestor routes that\n * do not contribute to the path, such that index/pathless layout routes don't\n * interfere.\n *\n * For example, when moving a route element into an index route and/or a\n * pathless layout route, relative link behavior contained within should stay\n * the same.  Both of the following examples should link back to the root:\n *\n *   <Route path=\"/\">\n *     <Route path=\"accounts\" element={<Link to=\"..\"}>\n *   </Route>\n *\n *   <Route path=\"/\">\n *     <Route path=\"accounts\">\n *       <Route element={<AccountsLayout />}>       // <-- Does not contribute\n *         <Route index element={<Link to=\"..\"} />  // <-- Does not contribute\n *       </Route\n *     </Route>\n *   </Route>\n */\nexport function getPathContributingMatches<\n  T extends AgnosticRouteMatch = AgnosticRouteMatch\n>(matches: T[]) {\n  return matches.filter(\n    (match, index) =>\n      index === 0 || (match.route.path && match.route.path.length > 0)\n  );\n}\n\n// Return the array of pathnames for the current route matches - used to\n// generate the routePathnames input for resolveTo()\nexport function getResolveToMatches<\n  T extends AgnosticRouteMatch = AgnosticRouteMatch\n>(matches: T[], v7_relativeSplatPath: boolean) {\n  let pathMatches = getPathContributingMatches(matches);\n\n  // When v7_relativeSplatPath is enabled, use the full pathname for the leaf\n  // match so we include splat values for \".\" links.  See:\n  // https://github.com/remix-run/react-router/issues/11052#issuecomment-1836589329\n  if (v7_relativeSplatPath) {\n    return pathMatches.map((match, idx) =>\n      idx === pathMatches.length - 1 ? match.pathname : match.pathnameBase\n    );\n  }\n\n  return pathMatches.map((match) => match.pathnameBase);\n}\n\n/**\n * @private\n */\nexport function resolveTo(\n  toArg: To,\n  routePathnames: string[],\n  locationPathname: string,\n  isPathRelative = false\n): Path {\n  let to: Partial<Path>;\n  if (typeof toArg === \"string\") {\n    to = parsePath(toArg);\n  } else {\n    to = { ...toArg };\n\n    invariant(\n      !to.pathname || !to.pathname.includes(\"?\"),\n      getInvalidPathError(\"?\", \"pathname\", \"search\", to)\n    );\n    invariant(\n      !to.pathname || !to.pathname.includes(\"#\"),\n      getInvalidPathError(\"#\", \"pathname\", \"hash\", to)\n    );\n    invariant(\n      !to.search || !to.search.includes(\"#\"),\n      getInvalidPathError(\"#\", \"search\", \"hash\", to)\n    );\n  }\n\n  let isEmptyPath = toArg === \"\" || to.pathname === \"\";\n  let toPathname = isEmptyPath ? \"/\" : to.pathname;\n\n  let from: string;\n\n  // Routing is relative to the current pathname if explicitly requested.\n  //\n  // If a pathname is explicitly provided in `to`, it should be relative to the\n  // route context. This is explained in `Note on `<Link to>` values` in our\n  // migration guide from v5 as a means of disambiguation between `to` values\n  // that begin with `/` and those that do not. However, this is problematic for\n  // `to` values that do not provide a pathname. `to` can simply be a search or\n  // hash string, in which case we should assume that the navigation is relative\n  // to the current location's pathname and *not* the route pathname.\n  if (toPathname == null) {\n    from = locationPathname;\n  } else {\n    let routePathnameIndex = routePathnames.length - 1;\n\n    // With relative=\"route\" (the default), each leading .. segment means\n    // \"go up one route\" instead of \"go up one URL segment\".  This is a key\n    // difference from how <a href> works and a major reason we call this a\n    // \"to\" value instead of a \"href\".\n    if (!isPathRelative && toPathname.startsWith(\"..\")) {\n      let toSegments = toPathname.split(\"/\");\n\n      while (toSegments[0] === \"..\") {\n        toSegments.shift();\n        routePathnameIndex -= 1;\n      }\n\n      to.pathname = toSegments.join(\"/\");\n    }\n\n    from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : \"/\";\n  }\n\n  let path = resolvePath(to, from);\n\n  // Ensure the pathname has a trailing slash if the original \"to\" had one\n  let hasExplicitTrailingSlash =\n    toPathname && toPathname !== \"/\" && toPathname.endsWith(\"/\");\n  // Or if this was a link to the current path which has a trailing slash\n  let hasCurrentTrailingSlash =\n    (isEmptyPath || toPathname === \".\") && locationPathname.endsWith(\"/\");\n  if (\n    !path.pathname.endsWith(\"/\") &&\n    (hasExplicitTrailingSlash || hasCurrentTrailingSlash)\n  ) {\n    path.pathname += \"/\";\n  }\n\n  return path;\n}\n\n/**\n * @private\n */\nexport function getToPathname(to: To): string | undefined {\n  // Empty strings should be treated the same as / paths\n  return to === \"\" || (to as Path).pathname === \"\"\n    ? \"/\"\n    : typeof to === \"string\"\n    ? parsePath(to).pathname\n    : to.pathname;\n}\n\n/**\n * @private\n */\nexport const joinPaths = (paths: string[]): string =>\n  paths.join(\"/\").replace(/\\/\\/+/g, \"/\");\n\n/**\n * @private\n */\nexport const normalizePathname = (pathname: string): string =>\n  pathname.replace(/\\/+$/, \"\").replace(/^\\/*/, \"/\");\n\n/**\n * @private\n */\nexport const normalizeSearch = (search: string): string =>\n  !search || search === \"?\"\n    ? \"\"\n    : search.startsWith(\"?\")\n    ? search\n    : \"?\" + search;\n\n/**\n * @private\n */\nexport const normalizeHash = (hash: string): string =>\n  !hash || hash === \"#\" ? \"\" : hash.startsWith(\"#\") ? hash : \"#\" + hash;\n\nexport type JsonFunction = <Data>(\n  data: Data,\n  init?: number | ResponseInit\n) => Response;\n\n/**\n * This is a shortcut for creating `application/json` responses. Converts `data`\n * to JSON and sets the `Content-Type` header.\n *\n * @deprecated The `json` method is deprecated in favor of returning raw objects.\n * This method will be removed in v7.\n */\nexport const json: JsonFunction = (data, init = {}) => {\n  let responseInit = typeof init === \"number\" ? { status: init } : init;\n\n  let headers = new Headers(responseInit.headers);\n  if (!headers.has(\"Content-Type\")) {\n    headers.set(\"Content-Type\", \"application/json; charset=utf-8\");\n  }\n\n  return new Response(JSON.stringify(data), {\n    ...responseInit,\n    headers,\n  });\n};\n\nexport class DataWithResponseInit<D> {\n  type: string = \"DataWithResponseInit\";\n  data: D;\n  init: ResponseInit | null;\n\n  constructor(data: D, init?: ResponseInit) {\n    this.data = data;\n    this.init = init || null;\n  }\n}\n\n/**\n * Create \"responses\" that contain `status`/`headers` without forcing\n * serialization into an actual `Response` - used by Remix single fetch\n */\nexport function data<D>(data: D, init?: number | ResponseInit) {\n  return new DataWithResponseInit(\n    data,\n    typeof init === \"number\" ? { status: init } : init\n  );\n}\n\nexport interface TrackedPromise extends Promise<any> {\n  _tracked?: boolean;\n  _data?: any;\n  _error?: any;\n}\n\nexport class AbortedDeferredError extends Error {}\n\nexport class DeferredData {\n  private pendingKeysSet: Set<string> = new Set<string>();\n  private controller: AbortController;\n  private abortPromise: Promise<void>;\n  private unlistenAbortSignal: () => void;\n  private subscribers: Set<(aborted: boolean, settledKey?: string) => void> =\n    new Set();\n  data: Record<string, unknown>;\n  init?: ResponseInit;\n  deferredKeys: string[] = [];\n\n  constructor(data: Record<string, unknown>, responseInit?: ResponseInit) {\n    invariant(\n      data && typeof data === \"object\" && !Array.isArray(data),\n      \"defer() only accepts plain objects\"\n    );\n\n    // Set up an AbortController + Promise we can race against to exit early\n    // cancellation\n    let reject: (e: AbortedDeferredError) => void;\n    this.abortPromise = new Promise((_, r) => (reject = r));\n    this.controller = new AbortController();\n    let onAbort = () =>\n      reject(new AbortedDeferredError(\"Deferred data aborted\"));\n    this.unlistenAbortSignal = () =>\n      this.controller.signal.removeEventListener(\"abort\", onAbort);\n    this.controller.signal.addEventListener(\"abort\", onAbort);\n\n    this.data = Object.entries(data).reduce(\n      (acc, [key, value]) =>\n        Object.assign(acc, {\n          [key]: this.trackPromise(key, value),\n        }),\n      {}\n    );\n\n    if (this.done) {\n      // All incoming values were resolved\n      this.unlistenAbortSignal();\n    }\n\n    this.init = responseInit;\n  }\n\n  private trackPromise(\n    key: string,\n    value: Promise<unknown> | unknown\n  ): TrackedPromise | unknown {\n    if (!(value instanceof Promise)) {\n      return value;\n    }\n\n    this.deferredKeys.push(key);\n    this.pendingKeysSet.add(key);\n\n    // We store a little wrapper promise that will be extended with\n    // _data/_error props upon resolve/reject\n    let promise: TrackedPromise = Promise.race([value, this.abortPromise]).then(\n      (data) => this.onSettle(promise, key, undefined, data as unknown),\n      (error) => this.onSettle(promise, key, error as unknown)\n    );\n\n    // Register rejection listeners to avoid uncaught promise rejections on\n    // errors or aborted deferred values\n    promise.catch(() => {});\n\n    Object.defineProperty(promise, \"_tracked\", { get: () => true });\n    return promise;\n  }\n\n  private onSettle(\n    promise: TrackedPromise,\n    key: string,\n    error: unknown,\n    data?: unknown\n  ): unknown {\n    if (\n      this.controller.signal.aborted &&\n      error instanceof AbortedDeferredError\n    ) {\n      this.unlistenAbortSignal();\n      Object.defineProperty(promise, \"_error\", { get: () => error });\n      return Promise.reject(error);\n    }\n\n    this.pendingKeysSet.delete(key);\n\n    if (this.done) {\n      // Nothing left to abort!\n      this.unlistenAbortSignal();\n    }\n\n    // If the promise was resolved/rejected with undefined, we'll throw an error as you\n    // should always resolve with a value or null\n    if (error === undefined && data === undefined) {\n      let undefinedError = new Error(\n        `Deferred data for key \"${key}\" resolved/rejected with \\`undefined\\`, ` +\n          `you must resolve/reject with a value or \\`null\\`.`\n      );\n      Object.defineProperty(promise, \"_error\", { get: () => undefinedError });\n      this.emit(false, key);\n      return Promise.reject(undefinedError);\n    }\n\n    if (data === undefined) {\n      Object.defineProperty(promise, \"_error\", { get: () => error });\n      this.emit(false, key);\n      return Promise.reject(error);\n    }\n\n    Object.defineProperty(promise, \"_data\", { get: () => data });\n    this.emit(false, key);\n    return data;\n  }\n\n  private emit(aborted: boolean, settledKey?: string) {\n    this.subscribers.forEach((subscriber) => subscriber(aborted, settledKey));\n  }\n\n  subscribe(fn: (aborted: boolean, settledKey?: string) => void) {\n    this.subscribers.add(fn);\n    return () => this.subscribers.delete(fn);\n  }\n\n  cancel() {\n    this.controller.abort();\n    this.pendingKeysSet.forEach((v, k) => this.pendingKeysSet.delete(k));\n    this.emit(true);\n  }\n\n  async resolveData(signal: AbortSignal) {\n    let aborted = false;\n    if (!this.done) {\n      let onAbort = () => this.cancel();\n      signal.addEventListener(\"abort\", onAbort);\n      aborted = await new Promise((resolve) => {\n        this.subscribe((aborted) => {\n          signal.removeEventListener(\"abort\", onAbort);\n          if (aborted || this.done) {\n            resolve(aborted);\n          }\n        });\n      });\n    }\n    return aborted;\n  }\n\n  get done() {\n    return this.pendingKeysSet.size === 0;\n  }\n\n  get unwrappedData() {\n    invariant(\n      this.data !== null && this.done,\n      \"Can only unwrap data on initialized and settled deferreds\"\n    );\n\n    return Object.entries(this.data).reduce(\n      (acc, [key, value]) =>\n        Object.assign(acc, {\n          [key]: unwrapTrackedPromise(value),\n        }),\n      {}\n    );\n  }\n\n  get pendingKeys() {\n    return Array.from(this.pendingKeysSet);\n  }\n}\n\nfunction isTrackedPromise(value: any): value is TrackedPromise {\n  return (\n    value instanceof Promise && (value as TrackedPromise)._tracked === true\n  );\n}\n\nfunction unwrapTrackedPromise(value: any) {\n  if (!isTrackedPromise(value)) {\n    return value;\n  }\n\n  if (value._error) {\n    throw value._error;\n  }\n  return value._data;\n}\n\nexport type DeferFunction = (\n  data: Record<string, unknown>,\n  init?: number | ResponseInit\n) => DeferredData;\n\n/**\n * @deprecated The `defer` method is deprecated in favor of returning raw\n * objects. This method will be removed in v7.\n */\nexport const defer: DeferFunction = (data, init = {}) => {\n  let responseInit = typeof init === \"number\" ? { status: init } : init;\n\n  return new DeferredData(data, responseInit);\n};\n\nexport type RedirectFunction = (\n  url: string,\n  init?: number | ResponseInit\n) => Response;\n\n/**\n * A redirect response. Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nexport const redirect: RedirectFunction = (url, init = 302) => {\n  let responseInit = init;\n  if (typeof responseInit === \"number\") {\n    responseInit = { status: responseInit };\n  } else if (typeof responseInit.status === \"undefined\") {\n    responseInit.status = 302;\n  }\n\n  let headers = new Headers(responseInit.headers);\n  headers.set(\"Location\", url);\n\n  return new Response(null, {\n    ...responseInit,\n    headers,\n  });\n};\n\n/**\n * A redirect response that will force a document reload to the new location.\n * Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nexport const redirectDocument: RedirectFunction = (url, init) => {\n  let response = redirect(url, init);\n  response.headers.set(\"X-Remix-Reload-Document\", \"true\");\n  return response;\n};\n\n/**\n * A redirect response that will perform a `history.replaceState` instead of a\n * `history.pushState` for client-side navigation redirects.\n * Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nexport const replace: RedirectFunction = (url, init) => {\n  let response = redirect(url, init);\n  response.headers.set(\"X-Remix-Replace\", \"true\");\n  return response;\n};\n\nexport type ErrorResponse = {\n  status: number;\n  statusText: string;\n  data: any;\n};\n\n/**\n * @private\n * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies\n *\n * We don't export the class for public use since it's an implementation\n * detail, but we export the interface above so folks can build their own\n * abstractions around instances via isRouteErrorResponse()\n */\nexport class ErrorResponseImpl implements ErrorResponse {\n  status: number;\n  statusText: string;\n  data: any;\n  private error?: Error;\n  private internal: boolean;\n\n  constructor(\n    status: number,\n    statusText: string | undefined,\n    data: any,\n    internal = false\n  ) {\n    this.status = status;\n    this.statusText = statusText || \"\";\n    this.internal = internal;\n    if (data instanceof Error) {\n      this.data = data.toString();\n      this.error = data;\n    } else {\n      this.data = data;\n    }\n  }\n}\n\n/**\n * Check if the given error is an ErrorResponse generated from a 4xx/5xx\n * Response thrown from an action/loader\n */\nexport function isRouteErrorResponse(error: any): error is ErrorResponse {\n  return (\n    error != null &&\n    typeof error.status === \"number\" &&\n    typeof error.statusText === \"string\" &&\n    typeof error.internal === \"boolean\" &&\n    \"data\" in error\n  );\n}\n","import type { History, Location, Path, To } from \"./history\";\nimport {\n  Action as HistoryAction,\n  createLocation,\n  createPath,\n  invariant,\n  parsePath,\n  warning,\n} from \"./history\";\nimport type {\n  AgnosticDataRouteMatch,\n  AgnosticDataRouteObject,\n  DataStrategyMatch,\n  AgnosticRouteObject,\n  DataResult,\n  DataStrategyFunction,\n  DataStrategyFunctionArgs,\n  DeferredData,\n  DeferredResult,\n  DetectErrorBoundaryFunction,\n  ErrorResult,\n  FormEncType,\n  FormMethod,\n  HTMLFormMethod,\n  DataStrategyResult,\n  ImmutableRouteKey,\n  MapRoutePropertiesFunction,\n  MutationFormMethod,\n  RedirectResult,\n  RouteData,\n  RouteManifest,\n  ShouldRevalidateFunctionArgs,\n  Submission,\n  SuccessResult,\n  UIMatch,\n  V7_FormMethod,\n  V7_MutationFormMethod,\n  AgnosticPatchRoutesOnNavigationFunction,\n  DataWithResponseInit,\n} from \"./utils\";\nimport {\n  ErrorResponseImpl,\n  ResultType,\n  convertRouteMatchToUiMatch,\n  convertRoutesToDataRoutes,\n  getPathContributingMatches,\n  getResolveToMatches,\n  immutableRouteKeys,\n  isRouteErrorResponse,\n  joinPaths,\n  matchRoutes,\n  matchRoutesImpl,\n  resolveTo,\n  stripBasename,\n} from \"./utils\";\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Types and Constants\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A Router instance manages all navigation and data loading/mutations\n */\nexport interface Router {\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Return the basename for the router\n   */\n  get basename(): RouterInit[\"basename\"];\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Return the future config for the router\n   */\n  get future(): FutureConfig;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Return the current state of the router\n   */\n  get state(): RouterState;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Return the routes for this router instance\n   */\n  get routes(): AgnosticDataRouteObject[];\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Return the window associated with the router\n   */\n  get window(): RouterInit[\"window\"];\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Initialize the router, including adding history listeners and kicking off\n   * initial data fetches.  Returns a function to cleanup listeners and abort\n   * any in-progress loads\n   */\n  initialize(): Router;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Subscribe to router.state updates\n   *\n   * @param fn function to call with the new state\n   */\n  subscribe(fn: RouterSubscriber): () => void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Enable scroll restoration behavior in the router\n   *\n   * @param savedScrollPositions Object that will manage positions, in case\n   *                             it's being restored from sessionStorage\n   * @param getScrollPosition    Function to get the active Y scroll position\n   * @param getKey               Function to get the key to use for restoration\n   */\n  enableScrollRestoration(\n    savedScrollPositions: Record<string, number>,\n    getScrollPosition: GetScrollPositionFunction,\n    getKey?: GetScrollRestorationKeyFunction\n  ): () => void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Navigate forward/backward in the history stack\n   * @param to Delta to move in the history stack\n   */\n  navigate(to: number): Promise<void>;\n\n  /**\n   * Navigate to the given path\n   * @param to Path to navigate to\n   * @param opts Navigation options (method, submission, etc.)\n   */\n  navigate(to: To | null, opts?: RouterNavigateOptions): Promise<void>;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Trigger a fetcher load/submission\n   *\n   * @param key     Fetcher key\n   * @param routeId Route that owns the fetcher\n   * @param href    href to fetch\n   * @param opts    Fetcher options, (method, submission, etc.)\n   */\n  fetch(\n    key: string,\n    routeId: string,\n    href: string | null,\n    opts?: RouterFetchOptions\n  ): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Trigger a revalidation of all current route loaders and fetcher loads\n   */\n  revalidate(): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Utility function to create an href for the given location\n   * @param location\n   */\n  createHref(location: Location | URL): string;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Utility function to URL encode a destination path according to the internal\n   * history implementation\n   * @param to\n   */\n  encodeLocation(to: To): Path;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Get/create a fetcher for the given key\n   * @param key\n   */\n  getFetcher<TData = any>(key: string): Fetcher<TData>;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Delete the fetcher for a given key\n   * @param key\n   */\n  deleteFetcher(key: string): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Cleanup listeners and abort any in-progress loads\n   */\n  dispose(): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Get a navigation blocker\n   * @param key The identifier for the blocker\n   * @param fn The blocker function implementation\n   */\n  getBlocker(key: string, fn: BlockerFunction): Blocker;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Delete a navigation blocker\n   * @param key The identifier for the blocker\n   */\n  deleteBlocker(key: string): void;\n\n  /**\n   * @internal\n   * PRIVATE DO NOT USE\n   *\n   * Patch additional children routes into an existing parent route\n   * @param routeId The parent route id or a callback function accepting `patch`\n   *                to perform batch patching\n   * @param children The additional children routes\n   */\n  patchRoutes(routeId: string | null, children: AgnosticRouteObject[]): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * HMR needs to pass in-flight route updates to React Router\n   * TODO: Replace this with granular route update APIs (addRoute, updateRoute, deleteRoute)\n   */\n  _internalSetRoutes(routes: AgnosticRouteObject[]): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Internal fetch AbortControllers accessed by unit tests\n   */\n  _internalFetchControllers: Map<string, AbortController>;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Internal pending DeferredData instances accessed by unit tests\n   */\n  _internalActiveDeferreds: Map<string, DeferredData>;\n}\n\n/**\n * State maintained internally by the router.  During a navigation, all states\n * reflect the the \"old\" location unless otherwise noted.\n */\nexport interface RouterState {\n  /**\n   * The action of the most recent navigation\n   */\n  historyAction: HistoryAction;\n\n  /**\n   * The current location reflected by the router\n   */\n  location: Location;\n\n  /**\n   * The current set of route matches\n   */\n  matches: AgnosticDataRouteMatch[];\n\n  /**\n   * Tracks whether we've completed our initial data load\n   */\n  initialized: boolean;\n\n  /**\n   * Current scroll position we should start at for a new view\n   *  - number -> scroll position to restore to\n   *  - false -> do not restore scroll at all (used during submissions)\n   *  - null -> don't have a saved position, scroll to hash or top of page\n   */\n  restoreScrollPosition: number | false | null;\n\n  /**\n   * Indicate whether this navigation should skip resetting the scroll position\n   * if we are unable to restore the scroll position\n   */\n  preventScrollReset: boolean;\n\n  /**\n   * Tracks the state of the current navigation\n   */\n  navigation: Navigation;\n\n  /**\n   * Tracks any in-progress revalidations\n   */\n  revalidation: RevalidationState;\n\n  /**\n   * Data from the loaders for the current matches\n   */\n  loaderData: RouteData;\n\n  /**\n   * Data from the action for the current matches\n   */\n  actionData: RouteData | null;\n\n  /**\n   * Errors caught from loaders for the current matches\n   */\n  errors: RouteData | null;\n\n  /**\n   * Map of current fetchers\n   */\n  fetchers: Map<string, Fetcher>;\n\n  /**\n   * Map of current blockers\n   */\n  blockers: Map<string, Blocker>;\n}\n\n/**\n * Data that can be passed into hydrate a Router from SSR\n */\nexport type HydrationState = Partial<\n  Pick<RouterState, \"loaderData\" | \"actionData\" | \"errors\">\n>;\n\n/**\n * Future flags to toggle new feature behavior\n */\nexport interface FutureConfig {\n  v7_fetcherPersist: boolean;\n  v7_normalizeFormMethod: boolean;\n  v7_partialHydration: boolean;\n  v7_prependBasename: boolean;\n  v7_relativeSplatPath: boolean;\n  v7_skipActionErrorRevalidation: boolean;\n}\n\n/**\n * Initialization options for createRouter\n */\nexport interface RouterInit {\n  routes: AgnosticRouteObject[];\n  history: History;\n  basename?: string;\n  /**\n   * @deprecated Use `mapRouteProperties` instead\n   */\n  detectErrorBoundary?: DetectErrorBoundaryFunction;\n  mapRouteProperties?: MapRoutePropertiesFunction;\n  future?: Partial<FutureConfig>;\n  hydrationData?: HydrationState;\n  window?: Window;\n  dataStrategy?: DataStrategyFunction;\n  patchRoutesOnNavigation?: AgnosticPatchRoutesOnNavigationFunction;\n}\n\n/**\n * State returned from a server-side query() call\n */\nexport interface StaticHandlerContext {\n  basename: Router[\"basename\"];\n  location: RouterState[\"location\"];\n  matches: RouterState[\"matches\"];\n  loaderData: RouterState[\"loaderData\"];\n  actionData: RouterState[\"actionData\"];\n  errors: RouterState[\"errors\"];\n  statusCode: number;\n  loaderHeaders: Record<string, Headers>;\n  actionHeaders: Record<string, Headers>;\n  activeDeferreds: Record<string, DeferredData> | null;\n  _deepestRenderedBoundaryId?: string | null;\n}\n\n/**\n * A StaticHandler instance manages a singular SSR navigation/fetch event\n */\nexport interface StaticHandler {\n  dataRoutes: AgnosticDataRouteObject[];\n  query(\n    request: Request,\n    opts?: {\n      requestContext?: unknown;\n      skipLoaderErrorBubbling?: boolean;\n      dataStrategy?: DataStrategyFunction;\n    }\n  ): Promise<StaticHandlerContext | Response>;\n  queryRoute(\n    request: Request,\n    opts?: {\n      routeId?: string;\n      requestContext?: unknown;\n      dataStrategy?: DataStrategyFunction;\n    }\n  ): Promise<any>;\n}\n\ntype ViewTransitionOpts = {\n  currentLocation: Location;\n  nextLocation: Location;\n};\n\n/**\n * Subscriber function signature for changes to router state\n */\nexport interface RouterSubscriber {\n  (\n    state: RouterState,\n    opts: {\n      deletedFetchers: string[];\n      viewTransitionOpts?: ViewTransitionOpts;\n      flushSync: boolean;\n    }\n  ): void;\n}\n\n/**\n * Function signature for determining the key to be used in scroll restoration\n * for a given location\n */\nexport interface GetScrollRestorationKeyFunction {\n  (location: Location, matches: UIMatch[]): string | null;\n}\n\n/**\n * Function signature for determining the current scroll position\n */\nexport interface GetScrollPositionFunction {\n  (): number;\n}\n\nexport type RelativeRoutingType = \"route\" | \"path\";\n\n// Allowed for any navigation or fetch\ntype BaseNavigateOrFetchOptions = {\n  preventScrollReset?: boolean;\n  relative?: RelativeRoutingType;\n  flushSync?: boolean;\n};\n\n// Only allowed for navigations\ntype BaseNavigateOptions = BaseNavigateOrFetchOptions & {\n  replace?: boolean;\n  state?: any;\n  fromRouteId?: string;\n  viewTransition?: boolean;\n};\n\n// Only allowed for submission navigations\ntype BaseSubmissionOptions = {\n  formMethod?: HTMLFormMethod;\n  formEncType?: FormEncType;\n} & (\n  | { formData: FormData; body?: undefined }\n  | { formData?: undefined; body: any }\n);\n\n/**\n * Options for a navigate() call for a normal (non-submission) navigation\n */\ntype LinkNavigateOptions = BaseNavigateOptions;\n\n/**\n * Options for a navigate() call for a submission navigation\n */\ntype SubmissionNavigateOptions = BaseNavigateOptions & BaseSubmissionOptions;\n\n/**\n * Options to pass to navigate() for a navigation\n */\nexport type RouterNavigateOptions =\n  | LinkNavigateOptions\n  | SubmissionNavigateOptions;\n\n/**\n * Options for a fetch() load\n */\ntype LoadFetchOptions = BaseNavigateOrFetchOptions;\n\n/**\n * Options for a fetch() submission\n */\ntype SubmitFetchOptions = BaseNavigateOrFetchOptions & BaseSubmissionOptions;\n\n/**\n * Options to pass to fetch()\n */\nexport type RouterFetchOptions = LoadFetchOptions | SubmitFetchOptions;\n\n/**\n * Potential states for state.navigation\n */\nexport type NavigationStates = {\n  Idle: {\n    state: \"idle\";\n    location: undefined;\n    formMethod: undefined;\n    formAction: undefined;\n    formEncType: undefined;\n    formData: undefined;\n    json: undefined;\n    text: undefined;\n  };\n  Loading: {\n    state: \"loading\";\n    location: Location;\n    formMethod: Submission[\"formMethod\"] | undefined;\n    formAction: Submission[\"formAction\"] | undefined;\n    formEncType: Submission[\"formEncType\"] | undefined;\n    formData: Submission[\"formData\"] | undefined;\n    json: Submission[\"json\"] | undefined;\n    text: Submission[\"text\"] | undefined;\n  };\n  Submitting: {\n    state: \"submitting\";\n    location: Location;\n    formMethod: Submission[\"formMethod\"];\n    formAction: Submission[\"formAction\"];\n    formEncType: Submission[\"formEncType\"];\n    formData: Submission[\"formData\"];\n    json: Submission[\"json\"];\n    text: Submission[\"text\"];\n  };\n};\n\nexport type Navigation = NavigationStates[keyof NavigationStates];\n\nexport type RevalidationState = \"idle\" | \"loading\";\n\n/**\n * Potential states for fetchers\n */\ntype FetcherStates<TData = any> = {\n  Idle: {\n    state: \"idle\";\n    formMethod: undefined;\n    formAction: undefined;\n    formEncType: undefined;\n    text: undefined;\n    formData: undefined;\n    json: undefined;\n    data: TData | undefined;\n  };\n  Loading: {\n    state: \"loading\";\n    formMethod: Submission[\"formMethod\"] | undefined;\n    formAction: Submission[\"formAction\"] | undefined;\n    formEncType: Submission[\"formEncType\"] | undefined;\n    text: Submission[\"text\"] | undefined;\n    formData: Submission[\"formData\"] | undefined;\n    json: Submission[\"json\"] | undefined;\n    data: TData | undefined;\n  };\n  Submitting: {\n    state: \"submitting\";\n    formMethod: Submission[\"formMethod\"];\n    formAction: Submission[\"formAction\"];\n    formEncType: Submission[\"formEncType\"];\n    text: Submission[\"text\"];\n    formData: Submission[\"formData\"];\n    json: Submission[\"json\"];\n    data: TData | undefined;\n  };\n};\n\nexport type Fetcher<TData = any> =\n  FetcherStates<TData>[keyof FetcherStates<TData>];\n\ninterface BlockerBlocked {\n  state: \"blocked\";\n  reset(): void;\n  proceed(): void;\n  location: Location;\n}\n\ninterface BlockerUnblocked {\n  state: \"unblocked\";\n  reset: undefined;\n  proceed: undefined;\n  location: undefined;\n}\n\ninterface BlockerProceeding {\n  state: \"proceeding\";\n  reset: undefined;\n  proceed: undefined;\n  location: Location;\n}\n\nexport type Blocker = BlockerUnblocked | BlockerBlocked | BlockerProceeding;\n\nexport type BlockerFunction = (args: {\n  currentLocation: Location;\n  nextLocation: Location;\n  historyAction: HistoryAction;\n}) => boolean;\n\ninterface ShortCircuitable {\n  /**\n   * startNavigation does not need to complete the navigation because we\n   * redirected or got interrupted\n   */\n  shortCircuited?: boolean;\n}\n\ntype PendingActionResult = [string, SuccessResult | ErrorResult];\n\ninterface HandleActionResult extends ShortCircuitable {\n  /**\n   * Route matches which may have been updated from fog of war discovery\n   */\n  matches?: RouterState[\"matches\"];\n  /**\n   * Tuple for the returned or thrown value from the current action.  The routeId\n   * is the action route for success and the bubbled boundary route for errors.\n   */\n  pendingActionResult?: PendingActionResult;\n}\n\ninterface HandleLoadersResult extends ShortCircuitable {\n  /**\n   * Route matches which may have been updated from fog of war discovery\n   */\n  matches?: RouterState[\"matches\"];\n  /**\n   * loaderData returned from the current set of loaders\n   */\n  loaderData?: RouterState[\"loaderData\"];\n  /**\n   * errors thrown from the current set of loaders\n   */\n  errors?: RouterState[\"errors\"];\n}\n\n/**\n * Cached info for active fetcher.load() instances so they can participate\n * in revalidation\n */\ninterface FetchLoadMatch {\n  routeId: string;\n  path: string;\n}\n\n/**\n * Identified fetcher.load() calls that need to be revalidated\n */\ninterface RevalidatingFetcher extends FetchLoadMatch {\n  key: string;\n  match: AgnosticDataRouteMatch | null;\n  matches: AgnosticDataRouteMatch[] | null;\n  controller: AbortController | null;\n}\n\nconst validMutationMethodsArr: MutationFormMethod[] = [\n  \"post\",\n  \"put\",\n  \"patch\",\n  \"delete\",\n];\nconst validMutationMethods = new Set<MutationFormMethod>(\n  validMutationMethodsArr\n);\n\nconst validRequestMethodsArr: FormMethod[] = [\n  \"get\",\n  ...validMutationMethodsArr,\n];\nconst validRequestMethods = new Set<FormMethod>(validRequestMethodsArr);\n\nconst redirectStatusCodes = new Set([301, 302, 303, 307, 308]);\nconst redirectPreserveMethodStatusCodes = new Set([307, 308]);\n\nexport const IDLE_NAVIGATION: NavigationStates[\"Idle\"] = {\n  state: \"idle\",\n  location: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined,\n  json: undefined,\n  text: undefined,\n};\n\nexport const IDLE_FETCHER: FetcherStates[\"Idle\"] = {\n  state: \"idle\",\n  data: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined,\n  json: undefined,\n  text: undefined,\n};\n\nexport const IDLE_BLOCKER: BlockerUnblocked = {\n  state: \"unblocked\",\n  proceed: undefined,\n  reset: undefined,\n  location: undefined,\n};\n\nconst ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\\/\\/)/i;\n\nconst defaultMapRouteProperties: MapRoutePropertiesFunction = (route) => ({\n  hasErrorBoundary: Boolean(route.hasErrorBoundary),\n});\n\nconst TRANSITIONS_STORAGE_KEY = \"remix-router-transitions\";\n\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region createRouter\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Create a router and listen to history POP navigations\n */\nexport function createRouter(init: RouterInit): Router {\n  const routerWindow = init.window\n    ? init.window\n    : typeof window !== \"undefined\"\n    ? window\n    : undefined;\n  const isBrowser =\n    typeof routerWindow !== \"undefined\" &&\n    typeof routerWindow.document !== \"undefined\" &&\n    typeof routerWindow.document.createElement !== \"undefined\";\n  const isServer = !isBrowser;\n\n  invariant(\n    init.routes.length > 0,\n    \"You must provide a non-empty routes array to createRouter\"\n  );\n\n  let mapRouteProperties: MapRoutePropertiesFunction;\n  if (init.mapRouteProperties) {\n    mapRouteProperties = init.mapRouteProperties;\n  } else if (init.detectErrorBoundary) {\n    // If they are still using the deprecated version, wrap it with the new API\n    let detectErrorBoundary = init.detectErrorBoundary;\n    mapRouteProperties = (route) => ({\n      hasErrorBoundary: detectErrorBoundary(route),\n    });\n  } else {\n    mapRouteProperties = defaultMapRouteProperties;\n  }\n\n  // Routes keyed by ID\n  let manifest: RouteManifest = {};\n  // Routes in tree format for matching\n  let dataRoutes = convertRoutesToDataRoutes(\n    init.routes,\n    mapRouteProperties,\n    undefined,\n    manifest\n  );\n  let inFlightDataRoutes: AgnosticDataRouteObject[] | undefined;\n  let basename = init.basename || \"/\";\n  let dataStrategyImpl = init.dataStrategy || defaultDataStrategy;\n  let patchRoutesOnNavigationImpl = init.patchRoutesOnNavigation;\n\n  // Config driven behavior flags\n  let future: FutureConfig = {\n    v7_fetcherPersist: false,\n    v7_normalizeFormMethod: false,\n    v7_partialHydration: false,\n    v7_prependBasename: false,\n    v7_relativeSplatPath: false,\n    v7_skipActionErrorRevalidation: false,\n    ...init.future,\n  };\n  // Cleanup function for history\n  let unlistenHistory: (() => void) | null = null;\n  // Externally-provided functions to call on all state changes\n  let subscribers = new Set<RouterSubscriber>();\n  // Externally-provided object to hold scroll restoration locations during routing\n  let savedScrollPositions: Record<string, number> | null = null;\n  // Externally-provided function to get scroll restoration keys\n  let getScrollRestorationKey: GetScrollRestorationKeyFunction | null = null;\n  // Externally-provided function to get current scroll position\n  let getScrollPosition: GetScrollPositionFunction | null = null;\n  // One-time flag to control the initial hydration scroll restoration.  Because\n  // we don't get the saved positions from <ScrollRestoration /> until _after_\n  // the initial render, we need to manually trigger a separate updateState to\n  // send along the restoreScrollPosition\n  // Set to true if we have `hydrationData` since we assume we were SSR'd and that\n  // SSR did the initial scroll restoration.\n  let initialScrollRestored = init.hydrationData != null;\n\n  let initialMatches = matchRoutes(dataRoutes, init.history.location, basename);\n  let initialErrors: RouteData | null = null;\n\n  if (initialMatches == null && !patchRoutesOnNavigationImpl) {\n    // If we do not match a user-provided-route, fall back to the root\n    // to allow the error boundary to take over\n    let error = getInternalRouterError(404, {\n      pathname: init.history.location.pathname,\n    });\n    let { matches, route } = getShortCircuitMatches(dataRoutes);\n    initialMatches = matches;\n    initialErrors = { [route.id]: error };\n  }\n\n  // In SPA apps, if the user provided a patchRoutesOnNavigation implementation and\n  // our initial match is a splat route, clear them out so we run through lazy\n  // discovery on hydration in case there's a more accurate lazy route match.\n  // In SSR apps (with `hydrationData`), we expect that the server will send\n  // up the proper matched routes so we don't want to run lazy discovery on\n  // initial hydration and want to hydrate into the splat route.\n  if (initialMatches && !init.hydrationData) {\n    let fogOfWar = checkFogOfWar(\n      initialMatches,\n      dataRoutes,\n      init.history.location.pathname\n    );\n    if (fogOfWar.active) {\n      initialMatches = null;\n    }\n  }\n\n  let initialized: boolean;\n  if (!initialMatches) {\n    initialized = false;\n    initialMatches = [];\n\n    // If partial hydration and fog of war is enabled, we will be running\n    // `patchRoutesOnNavigation` during hydration so include any partial matches as\n    // the initial matches so we can properly render `HydrateFallback`'s\n    if (future.v7_partialHydration) {\n      let fogOfWar = checkFogOfWar(\n        null,\n        dataRoutes,\n        init.history.location.pathname\n      );\n      if (fogOfWar.active && fogOfWar.matches) {\n        initialMatches = fogOfWar.matches;\n      }\n    }\n  } else if (initialMatches.some((m) => m.route.lazy)) {\n    // All initialMatches need to be loaded before we're ready.  If we have lazy\n    // functions around still then we'll need to run them in initialize()\n    initialized = false;\n  } else if (!initialMatches.some((m) => m.route.loader)) {\n    // If we've got no loaders to run, then we're good to go\n    initialized = true;\n  } else if (future.v7_partialHydration) {\n    // If partial hydration is enabled, we're initialized so long as we were\n    // provided with hydrationData for every route with a loader, and no loaders\n    // were marked for explicit hydration\n    let loaderData = init.hydrationData ? init.hydrationData.loaderData : null;\n    let errors = init.hydrationData ? init.hydrationData.errors : null;\n    // If errors exist, don't consider routes below the boundary\n    if (errors) {\n      let idx = initialMatches.findIndex(\n        (m) => errors![m.route.id] !== undefined\n      );\n      initialized = initialMatches\n        .slice(0, idx + 1)\n        .every((m) => !shouldLoadRouteOnHydration(m.route, loaderData, errors));\n    } else {\n      initialized = initialMatches.every(\n        (m) => !shouldLoadRouteOnHydration(m.route, loaderData, errors)\n      );\n    }\n  } else {\n    // Without partial hydration - we're initialized if we were provided any\n    // hydrationData - which is expected to be complete\n    initialized = init.hydrationData != null;\n  }\n\n  let router: Router;\n  let state: RouterState = {\n    historyAction: init.history.action,\n    location: init.history.location,\n    matches: initialMatches,\n    initialized,\n    navigation: IDLE_NAVIGATION,\n    // Don't restore on initial updateState() if we were SSR'd\n    restoreScrollPosition: init.hydrationData != null ? false : null,\n    preventScrollReset: false,\n    revalidation: \"idle\",\n    loaderData: (init.hydrationData && init.hydrationData.loaderData) || {},\n    actionData: (init.hydrationData && init.hydrationData.actionData) || null,\n    errors: (init.hydrationData && init.hydrationData.errors) || initialErrors,\n    fetchers: new Map(),\n    blockers: new Map(),\n  };\n\n  // -- Stateful internal variables to manage navigations --\n  // Current navigation in progress (to be committed in completeNavigation)\n  let pendingAction: HistoryAction = HistoryAction.Pop;\n\n  // Should the current navigation prevent the scroll reset if scroll cannot\n  // be restored?\n  let pendingPreventScrollReset = false;\n\n  // AbortController for the active navigation\n  let pendingNavigationController: AbortController | null;\n\n  // Should the current navigation enable document.startViewTransition?\n  let pendingViewTransitionEnabled = false;\n\n  // Store applied view transitions so we can apply them on POP\n  let appliedViewTransitions: Map<string, Set<string>> = new Map<\n    string,\n    Set<string>\n  >();\n\n  // Cleanup function for persisting applied transitions to sessionStorage\n  let removePageHideEventListener: (() => void) | null = null;\n\n  // We use this to avoid touching history in completeNavigation if a\n  // revalidation is entirely uninterrupted\n  let isUninterruptedRevalidation = false;\n\n  // Use this internal flag to force revalidation of all loaders:\n  //  - submissions (completed or interrupted)\n  //  - useRevalidator()\n  //  - X-Remix-Revalidate (from redirect)\n  let isRevalidationRequired = false;\n\n  // Use this internal array to capture routes that require revalidation due\n  // to a cancelled deferred on action submission\n  let cancelledDeferredRoutes: string[] = [];\n\n  // Use this internal array to capture fetcher loads that were cancelled by an\n  // action navigation and require revalidation\n  let cancelledFetcherLoads: Set<string> = new Set();\n\n  // AbortControllers for any in-flight fetchers\n  let fetchControllers = new Map<string, AbortController>();\n\n  // Track loads based on the order in which they started\n  let incrementingLoadId = 0;\n\n  // Track the outstanding pending navigation data load to be compared against\n  // the globally incrementing load when a fetcher load lands after a completed\n  // navigation\n  let pendingNavigationLoadId = -1;\n\n  // Fetchers that triggered data reloads as a result of their actions\n  let fetchReloadIds = new Map<string, number>();\n\n  // Fetchers that triggered redirect navigations\n  let fetchRedirectIds = new Set<string>();\n\n  // Most recent href/match for fetcher.load calls for fetchers\n  let fetchLoadMatches = new Map<string, FetchLoadMatch>();\n\n  // Ref-count mounted fetchers so we know when it's ok to clean them up\n  let activeFetchers = new Map<string, number>();\n\n  // Fetchers that have requested a delete when using v7_fetcherPersist,\n  // they'll be officially removed after they return to idle\n  let deletedFetchers = new Set<string>();\n\n  // Store DeferredData instances for active route matches.  When a\n  // route loader returns defer() we stick one in here.  Then, when a nested\n  // promise resolves we update loaderData.  If a new navigation starts we\n  // cancel active deferreds for eliminated routes.\n  let activeDeferreds = new Map<string, DeferredData>();\n\n  // Store blocker functions in a separate Map outside of router state since\n  // we don't need to update UI state if they change\n  let blockerFunctions = new Map<string, BlockerFunction>();\n\n  // Map of pending patchRoutesOnNavigation() promises (keyed by path/matches) so\n  // that we only kick them off once for a given combo\n  let pendingPatchRoutes = new Map<\n    string,\n    ReturnType<AgnosticPatchRoutesOnNavigationFunction>\n  >();\n\n  // Flag to ignore the next history update, so we can revert the URL change on\n  // a POP navigation that was blocked by the user without touching router state\n  let unblockBlockerHistoryUpdate: (() => void) | undefined = undefined;\n\n  // Initialize the router, all side effects should be kicked off from here.\n  // Implemented as a Fluent API for ease of:\n  //   let router = createRouter(init).initialize();\n  function initialize() {\n    // If history informs us of a POP navigation, start the navigation but do not update\n    // state.  We'll update our own state once the navigation completes\n    unlistenHistory = init.history.listen(\n      ({ action: historyAction, location, delta }) => {\n        // Ignore this event if it was just us resetting the URL from a\n        // blocked POP navigation\n        if (unblockBlockerHistoryUpdate) {\n          unblockBlockerHistoryUpdate();\n          unblockBlockerHistoryUpdate = undefined;\n          return;\n        }\n\n        warning(\n          blockerFunctions.size === 0 || delta != null,\n          \"You are trying to use a blocker on a POP navigation to a location \" +\n            \"that was not created by @remix-run/router. This will fail silently in \" +\n            \"production. This can happen if you are navigating outside the router \" +\n            \"via `window.history.pushState`/`window.location.hash` instead of using \" +\n            \"router navigation APIs.  This can also happen if you are using \" +\n            \"createHashRouter and the user manually changes the URL.\"\n        );\n\n        let blockerKey = shouldBlockNavigation({\n          currentLocation: state.location,\n          nextLocation: location,\n          historyAction,\n        });\n\n        if (blockerKey && delta != null) {\n          // Restore the URL to match the current UI, but don't update router state\n          let nextHistoryUpdatePromise = new Promise<void>((resolve) => {\n            unblockBlockerHistoryUpdate = resolve;\n          });\n          init.history.go(delta * -1);\n\n          // Put the blocker into a blocked state\n          updateBlocker(blockerKey, {\n            state: \"blocked\",\n            location,\n            proceed() {\n              updateBlocker(blockerKey!, {\n                state: \"proceeding\",\n                proceed: undefined,\n                reset: undefined,\n                location,\n              });\n              // Re-do the same POP navigation we just blocked, after the url\n              // restoration is also complete.  See:\n              // https://github.com/remix-run/react-router/issues/11613\n              nextHistoryUpdatePromise.then(() => init.history.go(delta));\n            },\n            reset() {\n              let blockers = new Map(state.blockers);\n              blockers.set(blockerKey!, IDLE_BLOCKER);\n              updateState({ blockers });\n            },\n          });\n          return;\n        }\n\n        return startNavigation(historyAction, location);\n      }\n    );\n\n    if (isBrowser) {\n      // FIXME: This feels gross.  How can we cleanup the lines between\n      // scrollRestoration/appliedTransitions persistance?\n      restoreAppliedTransitions(routerWindow, appliedViewTransitions);\n      let _saveAppliedTransitions = () =>\n        persistAppliedTransitions(routerWindow, appliedViewTransitions);\n      routerWindow.addEventListener(\"pagehide\", _saveAppliedTransitions);\n      removePageHideEventListener = () =>\n        routerWindow.removeEventListener(\"pagehide\", _saveAppliedTransitions);\n    }\n\n    // Kick off initial data load if needed.  Use Pop to avoid modifying history\n    // Note we don't do any handling of lazy here.  For SPA's it'll get handled\n    // in the normal navigation flow.  For SSR it's expected that lazy modules are\n    // resolved prior to router creation since we can't go into a fallbackElement\n    // UI for SSR'd apps\n    if (!state.initialized) {\n      startNavigation(HistoryAction.Pop, state.location, {\n        initialHydration: true,\n      });\n    }\n\n    return router;\n  }\n\n  // Clean up a router and it's side effects\n  function dispose() {\n    if (unlistenHistory) {\n      unlistenHistory();\n    }\n    if (removePageHideEventListener) {\n      removePageHideEventListener();\n    }\n    subscribers.clear();\n    pendingNavigationController && pendingNavigationController.abort();\n    state.fetchers.forEach((_, key) => deleteFetcher(key));\n    state.blockers.forEach((_, key) => deleteBlocker(key));\n  }\n\n  // Subscribe to state updates for the router\n  function subscribe(fn: RouterSubscriber) {\n    subscribers.add(fn);\n    return () => subscribers.delete(fn);\n  }\n\n  // Update our state and notify the calling context of the change\n  function updateState(\n    newState: Partial<RouterState>,\n    opts: {\n      flushSync?: boolean;\n      viewTransitionOpts?: ViewTransitionOpts;\n    } = {}\n  ): void {\n    state = {\n      ...state,\n      ...newState,\n    };\n\n    // Prep fetcher cleanup so we can tell the UI which fetcher data entries\n    // can be removed\n    let completedFetchers: string[] = [];\n    let deletedFetchersKeys: string[] = [];\n\n    if (future.v7_fetcherPersist) {\n      state.fetchers.forEach((fetcher, key) => {\n        if (fetcher.state === \"idle\") {\n          if (deletedFetchers.has(key)) {\n            // Unmounted from the UI and can be totally removed\n            deletedFetchersKeys.push(key);\n          } else {\n            // Returned to idle but still mounted in the UI, so semi-remains for\n            // revalidations and such\n            completedFetchers.push(key);\n          }\n        }\n      });\n    }\n\n    // Iterate over a local copy so that if flushSync is used and we end up\n    // removing and adding a new subscriber due to the useCallback dependencies,\n    // we don't get ourselves into a loop calling the new subscriber immediately\n    [...subscribers].forEach((subscriber) =>\n      subscriber(state, {\n        deletedFetchers: deletedFetchersKeys,\n        viewTransitionOpts: opts.viewTransitionOpts,\n        flushSync: opts.flushSync === true,\n      })\n    );\n\n    // Remove idle fetchers from state since we only care about in-flight fetchers.\n    if (future.v7_fetcherPersist) {\n      completedFetchers.forEach((key) => state.fetchers.delete(key));\n      deletedFetchersKeys.forEach((key) => deleteFetcher(key));\n    }\n  }\n\n  // Complete a navigation returning the state.navigation back to the IDLE_NAVIGATION\n  // and setting state.[historyAction/location/matches] to the new route.\n  // - Location is a required param\n  // - Navigation will always be set to IDLE_NAVIGATION\n  // - Can pass any other state in newState\n  function completeNavigation(\n    location: Location,\n    newState: Partial<Omit<RouterState, \"action\" | \"location\" | \"navigation\">>,\n    { flushSync }: { flushSync?: boolean } = {}\n  ): void {\n    // Deduce if we're in a loading/actionReload state:\n    // - We have committed actionData in the store\n    // - The current navigation was a mutation submission\n    // - We're past the submitting state and into the loading state\n    // - The location being loaded is not the result of a redirect\n    let isActionReload =\n      state.actionData != null &&\n      state.navigation.formMethod != null &&\n      isMutationMethod(state.navigation.formMethod) &&\n      state.navigation.state === \"loading\" &&\n      location.state?._isRedirect !== true;\n\n    let actionData: RouteData | null;\n    if (newState.actionData) {\n      if (Object.keys(newState.actionData).length > 0) {\n        actionData = newState.actionData;\n      } else {\n        // Empty actionData -> clear prior actionData due to an action error\n        actionData = null;\n      }\n    } else if (isActionReload) {\n      // Keep the current data if we're wrapping up the action reload\n      actionData = state.actionData;\n    } else {\n      // Clear actionData on any other completed navigations\n      actionData = null;\n    }\n\n    // Always preserve any existing loaderData from re-used routes\n    let loaderData = newState.loaderData\n      ? mergeLoaderData(\n          state.loaderData,\n          newState.loaderData,\n          newState.matches || [],\n          newState.errors\n        )\n      : state.loaderData;\n\n    // On a successful navigation we can assume we got through all blockers\n    // so we can start fresh\n    let blockers = state.blockers;\n    if (blockers.size > 0) {\n      blockers = new Map(blockers);\n      blockers.forEach((_, k) => blockers.set(k, IDLE_BLOCKER));\n    }\n\n    // Always respect the user flag.  Otherwise don't reset on mutation\n    // submission navigations unless they redirect\n    let preventScrollReset =\n      pendingPreventScrollReset === true ||\n      (state.navigation.formMethod != null &&\n        isMutationMethod(state.navigation.formMethod) &&\n        location.state?._isRedirect !== true);\n\n    // Commit any in-flight routes at the end of the HMR revalidation \"navigation\"\n    if (inFlightDataRoutes) {\n      dataRoutes = inFlightDataRoutes;\n      inFlightDataRoutes = undefined;\n    }\n\n    if (isUninterruptedRevalidation) {\n      // If this was an uninterrupted revalidation then do not touch history\n    } else if (pendingAction === HistoryAction.Pop) {\n      // Do nothing for POP - URL has already been updated\n    } else if (pendingAction === HistoryAction.Push) {\n      init.history.push(location, location.state);\n    } else if (pendingAction === HistoryAction.Replace) {\n      init.history.replace(location, location.state);\n    }\n\n    let viewTransitionOpts: ViewTransitionOpts | undefined;\n\n    // On POP, enable transitions if they were enabled on the original navigation\n    if (pendingAction === HistoryAction.Pop) {\n      // Forward takes precedence so they behave like the original navigation\n      let priorPaths = appliedViewTransitions.get(state.location.pathname);\n      if (priorPaths && priorPaths.has(location.pathname)) {\n        viewTransitionOpts = {\n          currentLocation: state.location,\n          nextLocation: location,\n        };\n      } else if (appliedViewTransitions.has(location.pathname)) {\n        // If we don't have a previous forward nav, assume we're popping back to\n        // the new location and enable if that location previously enabled\n        viewTransitionOpts = {\n          currentLocation: location,\n          nextLocation: state.location,\n        };\n      }\n    } else if (pendingViewTransitionEnabled) {\n      // Store the applied transition on PUSH/REPLACE\n      let toPaths = appliedViewTransitions.get(state.location.pathname);\n      if (toPaths) {\n        toPaths.add(location.pathname);\n      } else {\n        toPaths = new Set<string>([location.pathname]);\n        appliedViewTransitions.set(state.location.pathname, toPaths);\n      }\n      viewTransitionOpts = {\n        currentLocation: state.location,\n        nextLocation: location,\n      };\n    }\n\n    updateState(\n      {\n        ...newState, // matches, errors, fetchers go through as-is\n        actionData,\n        loaderData,\n        historyAction: pendingAction,\n        location,\n        initialized: true,\n        navigation: IDLE_NAVIGATION,\n        revalidation: \"idle\",\n        restoreScrollPosition: getSavedScrollPosition(\n          location,\n          newState.matches || state.matches\n        ),\n        preventScrollReset,\n        blockers,\n      },\n      {\n        viewTransitionOpts,\n        flushSync: flushSync === true,\n      }\n    );\n\n    // Reset stateful navigation vars\n    pendingAction = HistoryAction.Pop;\n    pendingPreventScrollReset = false;\n    pendingViewTransitionEnabled = false;\n    isUninterruptedRevalidation = false;\n    isRevalidationRequired = false;\n    cancelledDeferredRoutes = [];\n  }\n\n  // Trigger a navigation event, which can either be a numerical POP or a PUSH\n  // replace with an optional submission\n  async function navigate(\n    to: number | To | null,\n    opts?: RouterNavigateOptions\n  ): Promise<void> {\n    if (typeof to === \"number\") {\n      init.history.go(to);\n      return;\n    }\n\n    let normalizedPath = normalizeTo(\n      state.location,\n      state.matches,\n      basename,\n      future.v7_prependBasename,\n      to,\n      future.v7_relativeSplatPath,\n      opts?.fromRouteId,\n      opts?.relative\n    );\n    let { path, submission, error } = normalizeNavigateOptions(\n      future.v7_normalizeFormMethod,\n      false,\n      normalizedPath,\n      opts\n    );\n\n    let currentLocation = state.location;\n    let nextLocation = createLocation(state.location, path, opts && opts.state);\n\n    // When using navigate as a PUSH/REPLACE we aren't reading an already-encoded\n    // URL from window.location, so we need to encode it here so the behavior\n    // remains the same as POP and non-data-router usages.  new URL() does all\n    // the same encoding we'd get from a history.pushState/window.location read\n    // without having to touch history\n    nextLocation = {\n      ...nextLocation,\n      ...init.history.encodeLocation(nextLocation),\n    };\n\n    let userReplace = opts && opts.replace != null ? opts.replace : undefined;\n\n    let historyAction = HistoryAction.Push;\n\n    if (userReplace === true) {\n      historyAction = HistoryAction.Replace;\n    } else if (userReplace === false) {\n      // no-op\n    } else if (\n      submission != null &&\n      isMutationMethod(submission.formMethod) &&\n      submission.formAction === state.location.pathname + state.location.search\n    ) {\n      // By default on submissions to the current location we REPLACE so that\n      // users don't have to double-click the back button to get to the prior\n      // location.  If the user redirects to a different location from the\n      // action/loader this will be ignored and the redirect will be a PUSH\n      historyAction = HistoryAction.Replace;\n    }\n\n    let preventScrollReset =\n      opts && \"preventScrollReset\" in opts\n        ? opts.preventScrollReset === true\n        : undefined;\n\n    let flushSync = (opts && opts.flushSync) === true;\n\n    let blockerKey = shouldBlockNavigation({\n      currentLocation,\n      nextLocation,\n      historyAction,\n    });\n\n    if (blockerKey) {\n      // Put the blocker into a blocked state\n      updateBlocker(blockerKey, {\n        state: \"blocked\",\n        location: nextLocation,\n        proceed() {\n          updateBlocker(blockerKey!, {\n            state: \"proceeding\",\n            proceed: undefined,\n            reset: undefined,\n            location: nextLocation,\n          });\n          // Send the same navigation through\n          navigate(to, opts);\n        },\n        reset() {\n          let blockers = new Map(state.blockers);\n          blockers.set(blockerKey!, IDLE_BLOCKER);\n          updateState({ blockers });\n        },\n      });\n      return;\n    }\n\n    return await startNavigation(historyAction, nextLocation, {\n      submission,\n      // Send through the formData serialization error if we have one so we can\n      // render at the right error boundary after we match routes\n      pendingError: error,\n      preventScrollReset,\n      replace: opts && opts.replace,\n      enableViewTransition: opts && opts.viewTransition,\n      flushSync,\n    });\n  }\n\n  // Revalidate all current loaders.  If a navigation is in progress or if this\n  // is interrupted by a navigation, allow this to \"succeed\" by calling all\n  // loaders during the next loader round\n  function revalidate() {\n    interruptActiveLoads();\n    updateState({ revalidation: \"loading\" });\n\n    // If we're currently submitting an action, we don't need to start a new\n    // navigation, we'll just let the follow up loader execution call all loaders\n    if (state.navigation.state === \"submitting\") {\n      return;\n    }\n\n    // If we're currently in an idle state, start a new navigation for the current\n    // action/location and mark it as uninterrupted, which will skip the history\n    // update in completeNavigation\n    if (state.navigation.state === \"idle\") {\n      startNavigation(state.historyAction, state.location, {\n        startUninterruptedRevalidation: true,\n      });\n      return;\n    }\n\n    // Otherwise, if we're currently in a loading state, just start a new\n    // navigation to the navigation.location but do not trigger an uninterrupted\n    // revalidation so that history correctly updates once the navigation completes\n    startNavigation(\n      pendingAction || state.historyAction,\n      state.navigation.location,\n      {\n        overrideNavigation: state.navigation,\n        // Proxy through any rending view transition\n        enableViewTransition: pendingViewTransitionEnabled === true,\n      }\n    );\n  }\n\n  // Start a navigation to the given action/location.  Can optionally provide a\n  // overrideNavigation which will override the normalLoad in the case of a redirect\n  // navigation\n  async function startNavigation(\n    historyAction: HistoryAction,\n    location: Location,\n    opts?: {\n      initialHydration?: boolean;\n      submission?: Submission;\n      fetcherSubmission?: Submission;\n      overrideNavigation?: Navigation;\n      pendingError?: ErrorResponseImpl;\n      startUninterruptedRevalidation?: boolean;\n      preventScrollReset?: boolean;\n      replace?: boolean;\n      enableViewTransition?: boolean;\n      flushSync?: boolean;\n    }\n  ): Promise<void> {\n    // Abort any in-progress navigations and start a new one. Unset any ongoing\n    // uninterrupted revalidations unless told otherwise, since we want this\n    // new navigation to update history normally\n    pendingNavigationController && pendingNavigationController.abort();\n    pendingNavigationController = null;\n    pendingAction = historyAction;\n    isUninterruptedRevalidation =\n      (opts && opts.startUninterruptedRevalidation) === true;\n\n    // Save the current scroll position every time we start a new navigation,\n    // and track whether we should reset scroll on completion\n    saveScrollPosition(state.location, state.matches);\n    pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;\n\n    pendingViewTransitionEnabled = (opts && opts.enableViewTransition) === true;\n\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let loadingNavigation = opts && opts.overrideNavigation;\n    let matches = matchRoutes(routesToUse, location, basename);\n    let flushSync = (opts && opts.flushSync) === true;\n\n    let fogOfWar = checkFogOfWar(matches, routesToUse, location.pathname);\n    if (fogOfWar.active && fogOfWar.matches) {\n      matches = fogOfWar.matches;\n    }\n\n    // Short circuit with a 404 on the root error boundary if we match nothing\n    if (!matches) {\n      let { error, notFoundMatches, route } = handleNavigational404(\n        location.pathname\n      );\n      completeNavigation(\n        location,\n        {\n          matches: notFoundMatches,\n          loaderData: {},\n          errors: {\n            [route.id]: error,\n          },\n        },\n        { flushSync }\n      );\n      return;\n    }\n\n    // Short circuit if it's only a hash change and not a revalidation or\n    // mutation submission.\n    //\n    // Ignore on initial page loads because since the initial hydration will always\n    // be \"same hash\".  For example, on /page#hash and submit a <Form method=\"post\">\n    // which will default to a navigation to /page\n    if (\n      state.initialized &&\n      !isRevalidationRequired &&\n      isHashChangeOnly(state.location, location) &&\n      !(opts && opts.submission && isMutationMethod(opts.submission.formMethod))\n    ) {\n      completeNavigation(location, { matches }, { flushSync });\n      return;\n    }\n\n    // Create a controller/Request for this navigation\n    pendingNavigationController = new AbortController();\n    let request = createClientSideRequest(\n      init.history,\n      location,\n      pendingNavigationController.signal,\n      opts && opts.submission\n    );\n    let pendingActionResult: PendingActionResult | undefined;\n\n    if (opts && opts.pendingError) {\n      // If we have a pendingError, it means the user attempted a GET submission\n      // with binary FormData so assign here and skip to handleLoaders.  That\n      // way we handle calling loaders above the boundary etc.  It's not really\n      // different from an actionError in that sense.\n      pendingActionResult = [\n        findNearestBoundary(matches).route.id,\n        { type: ResultType.error, error: opts.pendingError },\n      ];\n    } else if (\n      opts &&\n      opts.submission &&\n      isMutationMethod(opts.submission.formMethod)\n    ) {\n      // Call action if we received an action submission\n      let actionResult = await handleAction(\n        request,\n        location,\n        opts.submission,\n        matches,\n        fogOfWar.active,\n        { replace: opts.replace, flushSync }\n      );\n\n      if (actionResult.shortCircuited) {\n        return;\n      }\n\n      // If we received a 404 from handleAction, it's because we couldn't lazily\n      // discover the destination route so we don't want to call loaders\n      if (actionResult.pendingActionResult) {\n        let [routeId, result] = actionResult.pendingActionResult;\n        if (\n          isErrorResult(result) &&\n          isRouteErrorResponse(result.error) &&\n          result.error.status === 404\n        ) {\n          pendingNavigationController = null;\n\n          completeNavigation(location, {\n            matches: actionResult.matches,\n            loaderData: {},\n            errors: {\n              [routeId]: result.error,\n            },\n          });\n          return;\n        }\n      }\n\n      matches = actionResult.matches || matches;\n      pendingActionResult = actionResult.pendingActionResult;\n      loadingNavigation = getLoadingNavigation(location, opts.submission);\n      flushSync = false;\n      // No need to do fog of war matching again on loader execution\n      fogOfWar.active = false;\n\n      // Create a GET request for the loaders\n      request = createClientSideRequest(\n        init.history,\n        request.url,\n        request.signal\n      );\n    }\n\n    // Call loaders\n    let {\n      shortCircuited,\n      matches: updatedMatches,\n      loaderData,\n      errors,\n    } = await handleLoaders(\n      request,\n      location,\n      matches,\n      fogOfWar.active,\n      loadingNavigation,\n      opts && opts.submission,\n      opts && opts.fetcherSubmission,\n      opts && opts.replace,\n      opts && opts.initialHydration === true,\n      flushSync,\n      pendingActionResult\n    );\n\n    if (shortCircuited) {\n      return;\n    }\n\n    // Clean up now that the action/loaders have completed.  Don't clean up if\n    // we short circuited because pendingNavigationController will have already\n    // been assigned to a new controller for the next navigation\n    pendingNavigationController = null;\n\n    completeNavigation(location, {\n      matches: updatedMatches || matches,\n      ...getActionDataForCommit(pendingActionResult),\n      loaderData,\n      errors,\n    });\n  }\n\n  // Call the action matched by the leaf route for this navigation and handle\n  // redirects/errors\n  async function handleAction(\n    request: Request,\n    location: Location,\n    submission: Submission,\n    matches: AgnosticDataRouteMatch[],\n    isFogOfWar: boolean,\n    opts: { replace?: boolean; flushSync?: boolean } = {}\n  ): Promise<HandleActionResult> {\n    interruptActiveLoads();\n\n    // Put us in a submitting state\n    let navigation = getSubmittingNavigation(location, submission);\n    updateState({ navigation }, { flushSync: opts.flushSync === true });\n\n    if (isFogOfWar) {\n      let discoverResult = await discoverRoutes(\n        matches,\n        location.pathname,\n        request.signal\n      );\n      if (discoverResult.type === \"aborted\") {\n        return { shortCircuited: true };\n      } else if (discoverResult.type === \"error\") {\n        let boundaryId = findNearestBoundary(discoverResult.partialMatches)\n          .route.id;\n        return {\n          matches: discoverResult.partialMatches,\n          pendingActionResult: [\n            boundaryId,\n            {\n              type: ResultType.error,\n              error: discoverResult.error,\n            },\n          ],\n        };\n      } else if (!discoverResult.matches) {\n        let { notFoundMatches, error, route } = handleNavigational404(\n          location.pathname\n        );\n        return {\n          matches: notFoundMatches,\n          pendingActionResult: [\n            route.id,\n            {\n              type: ResultType.error,\n              error,\n            },\n          ],\n        };\n      } else {\n        matches = discoverResult.matches;\n      }\n    }\n\n    // Call our action and get the result\n    let result: DataResult;\n    let actionMatch = getTargetMatch(matches, location);\n\n    if (!actionMatch.route.action && !actionMatch.route.lazy) {\n      result = {\n        type: ResultType.error,\n        error: getInternalRouterError(405, {\n          method: request.method,\n          pathname: location.pathname,\n          routeId: actionMatch.route.id,\n        }),\n      };\n    } else {\n      let results = await callDataStrategy(\n        \"action\",\n        state,\n        request,\n        [actionMatch],\n        matches,\n        null\n      );\n      result = results[actionMatch.route.id];\n\n      if (request.signal.aborted) {\n        return { shortCircuited: true };\n      }\n    }\n\n    if (isRedirectResult(result)) {\n      let replace: boolean;\n      if (opts && opts.replace != null) {\n        replace = opts.replace;\n      } else {\n        // If the user didn't explicity indicate replace behavior, replace if\n        // we redirected to the exact same location we're currently at to avoid\n        // double back-buttons\n        let location = normalizeRedirectLocation(\n          result.response.headers.get(\"Location\")!,\n          new URL(request.url),\n          basename\n        );\n        replace = location === state.location.pathname + state.location.search;\n      }\n      await startRedirectNavigation(request, result, true, {\n        submission,\n        replace,\n      });\n      return { shortCircuited: true };\n    }\n\n    if (isDeferredResult(result)) {\n      throw getInternalRouterError(400, { type: \"defer-action\" });\n    }\n\n    if (isErrorResult(result)) {\n      // Store off the pending error - we use it to determine which loaders\n      // to call and will commit it when we complete the navigation\n      let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);\n\n      // By default, all submissions to the current location are REPLACE\n      // navigations, but if the action threw an error that'll be rendered in\n      // an errorElement, we fall back to PUSH so that the user can use the\n      // back button to get back to the pre-submission form location to try\n      // again\n      if ((opts && opts.replace) !== true) {\n        pendingAction = HistoryAction.Push;\n      }\n\n      return {\n        matches,\n        pendingActionResult: [boundaryMatch.route.id, result],\n      };\n    }\n\n    return {\n      matches,\n      pendingActionResult: [actionMatch.route.id, result],\n    };\n  }\n\n  // Call all applicable loaders for the given matches, handling redirects,\n  // errors, etc.\n  async function handleLoaders(\n    request: Request,\n    location: Location,\n    matches: AgnosticDataRouteMatch[],\n    isFogOfWar: boolean,\n    overrideNavigation?: Navigation,\n    submission?: Submission,\n    fetcherSubmission?: Submission,\n    replace?: boolean,\n    initialHydration?: boolean,\n    flushSync?: boolean,\n    pendingActionResult?: PendingActionResult\n  ): Promise<HandleLoadersResult> {\n    // Figure out the right navigation we want to use for data loading\n    let loadingNavigation =\n      overrideNavigation || getLoadingNavigation(location, submission);\n\n    // If this was a redirect from an action we don't have a \"submission\" but\n    // we have it on the loading navigation so use that if available\n    let activeSubmission =\n      submission ||\n      fetcherSubmission ||\n      getSubmissionFromNavigation(loadingNavigation);\n\n    // If this is an uninterrupted revalidation, we remain in our current idle\n    // state.  If not, we need to switch to our loading state and load data,\n    // preserving any new action data or existing action data (in the case of\n    // a revalidation interrupting an actionReload)\n    // If we have partialHydration enabled, then don't update the state for the\n    // initial data load since it's not a \"navigation\"\n    let shouldUpdateNavigationState =\n      !isUninterruptedRevalidation &&\n      (!future.v7_partialHydration || !initialHydration);\n\n    // When fog of war is enabled, we enter our `loading` state earlier so we\n    // can discover new routes during the `loading` state.  We skip this if\n    // we've already run actions since we would have done our matching already.\n    // If the children() function threw then, we want to proceed with the\n    // partial matches it discovered.\n    if (isFogOfWar) {\n      if (shouldUpdateNavigationState) {\n        let actionData = getUpdatedActionData(pendingActionResult);\n        updateState(\n          {\n            navigation: loadingNavigation,\n            ...(actionData !== undefined ? { actionData } : {}),\n          },\n          {\n            flushSync,\n          }\n        );\n      }\n\n      let discoverResult = await discoverRoutes(\n        matches,\n        location.pathname,\n        request.signal\n      );\n\n      if (discoverResult.type === \"aborted\") {\n        return { shortCircuited: true };\n      } else if (discoverResult.type === \"error\") {\n        let boundaryId = findNearestBoundary(discoverResult.partialMatches)\n          .route.id;\n        return {\n          matches: discoverResult.partialMatches,\n          loaderData: {},\n          errors: {\n            [boundaryId]: discoverResult.error,\n          },\n        };\n      } else if (!discoverResult.matches) {\n        let { error, notFoundMatches, route } = handleNavigational404(\n          location.pathname\n        );\n        return {\n          matches: notFoundMatches,\n          loaderData: {},\n          errors: {\n            [route.id]: error,\n          },\n        };\n      } else {\n        matches = discoverResult.matches;\n      }\n    }\n\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(\n      init.history,\n      state,\n      matches,\n      activeSubmission,\n      location,\n      future.v7_partialHydration && initialHydration === true,\n      future.v7_skipActionErrorRevalidation,\n      isRevalidationRequired,\n      cancelledDeferredRoutes,\n      cancelledFetcherLoads,\n      deletedFetchers,\n      fetchLoadMatches,\n      fetchRedirectIds,\n      routesToUse,\n      basename,\n      pendingActionResult\n    );\n\n    // Cancel pending deferreds for no-longer-matched routes or routes we're\n    // about to reload.  Note that if this is an action reload we would have\n    // already cancelled all pending deferreds so this would be a no-op\n    cancelActiveDeferreds(\n      (routeId) =>\n        !(matches && matches.some((m) => m.route.id === routeId)) ||\n        (matchesToLoad && matchesToLoad.some((m) => m.route.id === routeId))\n    );\n\n    pendingNavigationLoadId = ++incrementingLoadId;\n\n    // Short circuit if we have no loaders to run\n    if (matchesToLoad.length === 0 && revalidatingFetchers.length === 0) {\n      let updatedFetchers = markFetchRedirectsDone();\n      completeNavigation(\n        location,\n        {\n          matches,\n          loaderData: {},\n          // Commit pending error if we're short circuiting\n          errors:\n            pendingActionResult && isErrorResult(pendingActionResult[1])\n              ? { [pendingActionResult[0]]: pendingActionResult[1].error }\n              : null,\n          ...getActionDataForCommit(pendingActionResult),\n          ...(updatedFetchers ? { fetchers: new Map(state.fetchers) } : {}),\n        },\n        { flushSync }\n      );\n      return { shortCircuited: true };\n    }\n\n    if (shouldUpdateNavigationState) {\n      let updates: Partial<RouterState> = {};\n      if (!isFogOfWar) {\n        // Only update navigation/actionNData if we didn't already do it above\n        updates.navigation = loadingNavigation;\n        let actionData = getUpdatedActionData(pendingActionResult);\n        if (actionData !== undefined) {\n          updates.actionData = actionData;\n        }\n      }\n      if (revalidatingFetchers.length > 0) {\n        updates.fetchers = getUpdatedRevalidatingFetchers(revalidatingFetchers);\n      }\n      updateState(updates, { flushSync });\n    }\n\n    revalidatingFetchers.forEach((rf) => {\n      abortFetcher(rf.key);\n      if (rf.controller) {\n        // Fetchers use an independent AbortController so that aborting a fetcher\n        // (via deleteFetcher) does not abort the triggering navigation that\n        // triggered the revalidation\n        fetchControllers.set(rf.key, rf.controller);\n      }\n    });\n\n    // Proxy navigation abort through to revalidation fetchers\n    let abortPendingFetchRevalidations = () =>\n      revalidatingFetchers.forEach((f) => abortFetcher(f.key));\n    if (pendingNavigationController) {\n      pendingNavigationController.signal.addEventListener(\n        \"abort\",\n        abortPendingFetchRevalidations\n      );\n    }\n\n    let { loaderResults, fetcherResults } =\n      await callLoadersAndMaybeResolveData(\n        state,\n        matches,\n        matchesToLoad,\n        revalidatingFetchers,\n        request\n      );\n\n    if (request.signal.aborted) {\n      return { shortCircuited: true };\n    }\n\n    // Clean up _after_ loaders have completed.  Don't clean up if we short\n    // circuited because fetchControllers would have been aborted and\n    // reassigned to new controllers for the next navigation\n    if (pendingNavigationController) {\n      pendingNavigationController.signal.removeEventListener(\n        \"abort\",\n        abortPendingFetchRevalidations\n      );\n    }\n\n    revalidatingFetchers.forEach((rf) => fetchControllers.delete(rf.key));\n\n    // If any loaders returned a redirect Response, start a new REPLACE navigation\n    let redirect = findRedirect(loaderResults);\n    if (redirect) {\n      await startRedirectNavigation(request, redirect.result, true, {\n        replace,\n      });\n      return { shortCircuited: true };\n    }\n\n    redirect = findRedirect(fetcherResults);\n    if (redirect) {\n      // If this redirect came from a fetcher make sure we mark it in\n      // fetchRedirectIds so it doesn't get revalidated on the next set of\n      // loader executions\n      fetchRedirectIds.add(redirect.key);\n      await startRedirectNavigation(request, redirect.result, true, {\n        replace,\n      });\n      return { shortCircuited: true };\n    }\n\n    // Process and commit output from loaders\n    let { loaderData, errors } = processLoaderData(\n      state,\n      matches,\n      loaderResults,\n      pendingActionResult,\n      revalidatingFetchers,\n      fetcherResults,\n      activeDeferreds\n    );\n\n    // Wire up subscribers to update loaderData as promises settle\n    activeDeferreds.forEach((deferredData, routeId) => {\n      deferredData.subscribe((aborted) => {\n        // Note: No need to updateState here since the TrackedPromise on\n        // loaderData is stable across resolve/reject\n        // Remove this instance if we were aborted or if promises have settled\n        if (aborted || deferredData.done) {\n          activeDeferreds.delete(routeId);\n        }\n      });\n    });\n\n    // Preserve SSR errors during partial hydration\n    if (future.v7_partialHydration && initialHydration && state.errors) {\n      errors = { ...state.errors, ...errors };\n    }\n\n    let updatedFetchers = markFetchRedirectsDone();\n    let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);\n    let shouldUpdateFetchers =\n      updatedFetchers || didAbortFetchLoads || revalidatingFetchers.length > 0;\n\n    return {\n      matches,\n      loaderData,\n      errors,\n      ...(shouldUpdateFetchers ? { fetchers: new Map(state.fetchers) } : {}),\n    };\n  }\n\n  function getUpdatedActionData(\n    pendingActionResult: PendingActionResult | undefined\n  ): Record<string, RouteData> | null | undefined {\n    if (pendingActionResult && !isErrorResult(pendingActionResult[1])) {\n      // This is cast to `any` currently because `RouteData`uses any and it\n      // would be a breaking change to use any.\n      // TODO: v7 - change `RouteData` to use `unknown` instead of `any`\n      return {\n        [pendingActionResult[0]]: pendingActionResult[1].data as any,\n      };\n    } else if (state.actionData) {\n      if (Object.keys(state.actionData).length === 0) {\n        return null;\n      } else {\n        return state.actionData;\n      }\n    }\n  }\n\n  function getUpdatedRevalidatingFetchers(\n    revalidatingFetchers: RevalidatingFetcher[]\n  ) {\n    revalidatingFetchers.forEach((rf) => {\n      let fetcher = state.fetchers.get(rf.key);\n      let revalidatingFetcher = getLoadingFetcher(\n        undefined,\n        fetcher ? fetcher.data : undefined\n      );\n      state.fetchers.set(rf.key, revalidatingFetcher);\n    });\n    return new Map(state.fetchers);\n  }\n\n  // Trigger a fetcher load/submit for the given fetcher key\n  function fetch(\n    key: string,\n    routeId: string,\n    href: string | null,\n    opts?: RouterFetchOptions\n  ) {\n    if (isServer) {\n      throw new Error(\n        \"router.fetch() was called during the server render, but it shouldn't be. \" +\n          \"You are likely calling a useFetcher() method in the body of your component. \" +\n          \"Try moving it to a useEffect or a callback.\"\n      );\n    }\n\n    abortFetcher(key);\n\n    let flushSync = (opts && opts.flushSync) === true;\n\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let normalizedPath = normalizeTo(\n      state.location,\n      state.matches,\n      basename,\n      future.v7_prependBasename,\n      href,\n      future.v7_relativeSplatPath,\n      routeId,\n      opts?.relative\n    );\n    let matches = matchRoutes(routesToUse, normalizedPath, basename);\n\n    let fogOfWar = checkFogOfWar(matches, routesToUse, normalizedPath);\n    if (fogOfWar.active && fogOfWar.matches) {\n      matches = fogOfWar.matches;\n    }\n\n    if (!matches) {\n      setFetcherError(\n        key,\n        routeId,\n        getInternalRouterError(404, { pathname: normalizedPath }),\n        { flushSync }\n      );\n      return;\n    }\n\n    let { path, submission, error } = normalizeNavigateOptions(\n      future.v7_normalizeFormMethod,\n      true,\n      normalizedPath,\n      opts\n    );\n\n    if (error) {\n      setFetcherError(key, routeId, error, { flushSync });\n      return;\n    }\n\n    let match = getTargetMatch(matches, path);\n\n    let preventScrollReset = (opts && opts.preventScrollReset) === true;\n\n    if (submission && isMutationMethod(submission.formMethod)) {\n      handleFetcherAction(\n        key,\n        routeId,\n        path,\n        match,\n        matches,\n        fogOfWar.active,\n        flushSync,\n        preventScrollReset,\n        submission\n      );\n      return;\n    }\n\n    // Store off the match so we can call it's shouldRevalidate on subsequent\n    // revalidations\n    fetchLoadMatches.set(key, { routeId, path });\n    handleFetcherLoader(\n      key,\n      routeId,\n      path,\n      match,\n      matches,\n      fogOfWar.active,\n      flushSync,\n      preventScrollReset,\n      submission\n    );\n  }\n\n  // Call the action for the matched fetcher.submit(), and then handle redirects,\n  // errors, and revalidation\n  async function handleFetcherAction(\n    key: string,\n    routeId: string,\n    path: string,\n    match: AgnosticDataRouteMatch,\n    requestMatches: AgnosticDataRouteMatch[],\n    isFogOfWar: boolean,\n    flushSync: boolean,\n    preventScrollReset: boolean,\n    submission: Submission\n  ) {\n    interruptActiveLoads();\n    fetchLoadMatches.delete(key);\n\n    function detectAndHandle405Error(m: AgnosticDataRouteMatch) {\n      if (!m.route.action && !m.route.lazy) {\n        let error = getInternalRouterError(405, {\n          method: submission.formMethod,\n          pathname: path,\n          routeId: routeId,\n        });\n        setFetcherError(key, routeId, error, { flushSync });\n        return true;\n      }\n      return false;\n    }\n\n    if (!isFogOfWar && detectAndHandle405Error(match)) {\n      return;\n    }\n\n    // Put this fetcher into it's submitting state\n    let existingFetcher = state.fetchers.get(key);\n    updateFetcherState(key, getSubmittingFetcher(submission, existingFetcher), {\n      flushSync,\n    });\n\n    let abortController = new AbortController();\n    let fetchRequest = createClientSideRequest(\n      init.history,\n      path,\n      abortController.signal,\n      submission\n    );\n\n    if (isFogOfWar) {\n      let discoverResult = await discoverRoutes(\n        requestMatches,\n        path,\n        fetchRequest.signal\n      );\n\n      if (discoverResult.type === \"aborted\") {\n        return;\n      } else if (discoverResult.type === \"error\") {\n        setFetcherError(key, routeId, discoverResult.error, { flushSync });\n        return;\n      } else if (!discoverResult.matches) {\n        setFetcherError(\n          key,\n          routeId,\n          getInternalRouterError(404, { pathname: path }),\n          { flushSync }\n        );\n        return;\n      } else {\n        requestMatches = discoverResult.matches;\n        match = getTargetMatch(requestMatches, path);\n\n        if (detectAndHandle405Error(match)) {\n          return;\n        }\n      }\n    }\n\n    // Call the action for the fetcher\n    fetchControllers.set(key, abortController);\n\n    let originatingLoadId = incrementingLoadId;\n    let actionResults = await callDataStrategy(\n      \"action\",\n      state,\n      fetchRequest,\n      [match],\n      requestMatches,\n      key\n    );\n    let actionResult = actionResults[match.route.id];\n\n    if (fetchRequest.signal.aborted) {\n      // We can delete this so long as we weren't aborted by our own fetcher\n      // re-submit which would have put _new_ controller is in fetchControllers\n      if (fetchControllers.get(key) === abortController) {\n        fetchControllers.delete(key);\n      }\n      return;\n    }\n\n    // When using v7_fetcherPersist, we don't want errors bubbling up to the UI\n    // or redirects processed for unmounted fetchers so we just revert them to\n    // idle\n    if (future.v7_fetcherPersist && deletedFetchers.has(key)) {\n      if (isRedirectResult(actionResult) || isErrorResult(actionResult)) {\n        updateFetcherState(key, getDoneFetcher(undefined));\n        return;\n      }\n      // Let SuccessResult's fall through for revalidation\n    } else {\n      if (isRedirectResult(actionResult)) {\n        fetchControllers.delete(key);\n        if (pendingNavigationLoadId > originatingLoadId) {\n          // A new navigation was kicked off after our action started, so that\n          // should take precedence over this redirect navigation.  We already\n          // set isRevalidationRequired so all loaders for the new route should\n          // fire unless opted out via shouldRevalidate\n          updateFetcherState(key, getDoneFetcher(undefined));\n          return;\n        } else {\n          fetchRedirectIds.add(key);\n          updateFetcherState(key, getLoadingFetcher(submission));\n          return startRedirectNavigation(fetchRequest, actionResult, false, {\n            fetcherSubmission: submission,\n            preventScrollReset,\n          });\n        }\n      }\n\n      // Process any non-redirect errors thrown\n      if (isErrorResult(actionResult)) {\n        setFetcherError(key, routeId, actionResult.error);\n        return;\n      }\n    }\n\n    if (isDeferredResult(actionResult)) {\n      throw getInternalRouterError(400, { type: \"defer-action\" });\n    }\n\n    // Start the data load for current matches, or the next location if we're\n    // in the middle of a navigation\n    let nextLocation = state.navigation.location || state.location;\n    let revalidationRequest = createClientSideRequest(\n      init.history,\n      nextLocation,\n      abortController.signal\n    );\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let matches =\n      state.navigation.state !== \"idle\"\n        ? matchRoutes(routesToUse, state.navigation.location, basename)\n        : state.matches;\n\n    invariant(matches, \"Didn't find any matches after fetcher action\");\n\n    let loadId = ++incrementingLoadId;\n    fetchReloadIds.set(key, loadId);\n\n    let loadFetcher = getLoadingFetcher(submission, actionResult.data);\n    state.fetchers.set(key, loadFetcher);\n\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(\n      init.history,\n      state,\n      matches,\n      submission,\n      nextLocation,\n      false,\n      future.v7_skipActionErrorRevalidation,\n      isRevalidationRequired,\n      cancelledDeferredRoutes,\n      cancelledFetcherLoads,\n      deletedFetchers,\n      fetchLoadMatches,\n      fetchRedirectIds,\n      routesToUse,\n      basename,\n      [match.route.id, actionResult]\n    );\n\n    // Put all revalidating fetchers into the loading state, except for the\n    // current fetcher which we want to keep in it's current loading state which\n    // contains it's action submission info + action data\n    revalidatingFetchers\n      .filter((rf) => rf.key !== key)\n      .forEach((rf) => {\n        let staleKey = rf.key;\n        let existingFetcher = state.fetchers.get(staleKey);\n        let revalidatingFetcher = getLoadingFetcher(\n          undefined,\n          existingFetcher ? existingFetcher.data : undefined\n        );\n        state.fetchers.set(staleKey, revalidatingFetcher);\n        abortFetcher(staleKey);\n        if (rf.controller) {\n          fetchControllers.set(staleKey, rf.controller);\n        }\n      });\n\n    updateState({ fetchers: new Map(state.fetchers) });\n\n    let abortPendingFetchRevalidations = () =>\n      revalidatingFetchers.forEach((rf) => abortFetcher(rf.key));\n\n    abortController.signal.addEventListener(\n      \"abort\",\n      abortPendingFetchRevalidations\n    );\n\n    let { loaderResults, fetcherResults } =\n      await callLoadersAndMaybeResolveData(\n        state,\n        matches,\n        matchesToLoad,\n        revalidatingFetchers,\n        revalidationRequest\n      );\n\n    if (abortController.signal.aborted) {\n      return;\n    }\n\n    abortController.signal.removeEventListener(\n      \"abort\",\n      abortPendingFetchRevalidations\n    );\n\n    fetchReloadIds.delete(key);\n    fetchControllers.delete(key);\n    revalidatingFetchers.forEach((r) => fetchControllers.delete(r.key));\n\n    let redirect = findRedirect(loaderResults);\n    if (redirect) {\n      return startRedirectNavigation(\n        revalidationRequest,\n        redirect.result,\n        false,\n        { preventScrollReset }\n      );\n    }\n\n    redirect = findRedirect(fetcherResults);\n    if (redirect) {\n      // If this redirect came from a fetcher make sure we mark it in\n      // fetchRedirectIds so it doesn't get revalidated on the next set of\n      // loader executions\n      fetchRedirectIds.add(redirect.key);\n      return startRedirectNavigation(\n        revalidationRequest,\n        redirect.result,\n        false,\n        { preventScrollReset }\n      );\n    }\n\n    // Process and commit output from loaders\n    let { loaderData, errors } = processLoaderData(\n      state,\n      matches,\n      loaderResults,\n      undefined,\n      revalidatingFetchers,\n      fetcherResults,\n      activeDeferreds\n    );\n\n    // Since we let revalidations complete even if the submitting fetcher was\n    // deleted, only put it back to idle if it hasn't been deleted\n    if (state.fetchers.has(key)) {\n      let doneFetcher = getDoneFetcher(actionResult.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n\n    abortStaleFetchLoads(loadId);\n\n    // If we are currently in a navigation loading state and this fetcher is\n    // more recent than the navigation, we want the newer data so abort the\n    // navigation and complete it with the fetcher data\n    if (\n      state.navigation.state === \"loading\" &&\n      loadId > pendingNavigationLoadId\n    ) {\n      invariant(pendingAction, \"Expected pending action\");\n      pendingNavigationController && pendingNavigationController.abort();\n\n      completeNavigation(state.navigation.location, {\n        matches,\n        loaderData,\n        errors,\n        fetchers: new Map(state.fetchers),\n      });\n    } else {\n      // otherwise just update with the fetcher data, preserving any existing\n      // loaderData for loaders that did not need to reload.  We have to\n      // manually merge here since we aren't going through completeNavigation\n      updateState({\n        errors,\n        loaderData: mergeLoaderData(\n          state.loaderData,\n          loaderData,\n          matches,\n          errors\n        ),\n        fetchers: new Map(state.fetchers),\n      });\n      isRevalidationRequired = false;\n    }\n  }\n\n  // Call the matched loader for fetcher.load(), handling redirects, errors, etc.\n  async function handleFetcherLoader(\n    key: string,\n    routeId: string,\n    path: string,\n    match: AgnosticDataRouteMatch,\n    matches: AgnosticDataRouteMatch[],\n    isFogOfWar: boolean,\n    flushSync: boolean,\n    preventScrollReset: boolean,\n    submission?: Submission\n  ) {\n    let existingFetcher = state.fetchers.get(key);\n    updateFetcherState(\n      key,\n      getLoadingFetcher(\n        submission,\n        existingFetcher ? existingFetcher.data : undefined\n      ),\n      { flushSync }\n    );\n\n    let abortController = new AbortController();\n    let fetchRequest = createClientSideRequest(\n      init.history,\n      path,\n      abortController.signal\n    );\n\n    if (isFogOfWar) {\n      let discoverResult = await discoverRoutes(\n        matches,\n        path,\n        fetchRequest.signal\n      );\n\n      if (discoverResult.type === \"aborted\") {\n        return;\n      } else if (discoverResult.type === \"error\") {\n        setFetcherError(key, routeId, discoverResult.error, { flushSync });\n        return;\n      } else if (!discoverResult.matches) {\n        setFetcherError(\n          key,\n          routeId,\n          getInternalRouterError(404, { pathname: path }),\n          { flushSync }\n        );\n        return;\n      } else {\n        matches = discoverResult.matches;\n        match = getTargetMatch(matches, path);\n      }\n    }\n\n    // Call the loader for this fetcher route match\n    fetchControllers.set(key, abortController);\n\n    let originatingLoadId = incrementingLoadId;\n    let results = await callDataStrategy(\n      \"loader\",\n      state,\n      fetchRequest,\n      [match],\n      matches,\n      key\n    );\n    let result = results[match.route.id];\n\n    // Deferred isn't supported for fetcher loads, await everything and treat it\n    // as a normal load.  resolveDeferredData will return undefined if this\n    // fetcher gets aborted, so we just leave result untouched and short circuit\n    // below if that happens\n    if (isDeferredResult(result)) {\n      result =\n        (await resolveDeferredData(result, fetchRequest.signal, true)) ||\n        result;\n    }\n\n    // We can delete this so long as we weren't aborted by our our own fetcher\n    // re-load which would have put _new_ controller is in fetchControllers\n    if (fetchControllers.get(key) === abortController) {\n      fetchControllers.delete(key);\n    }\n\n    if (fetchRequest.signal.aborted) {\n      return;\n    }\n\n    // We don't want errors bubbling up or redirects followed for unmounted\n    // fetchers, so short circuit here if it was removed from the UI\n    if (deletedFetchers.has(key)) {\n      updateFetcherState(key, getDoneFetcher(undefined));\n      return;\n    }\n\n    // If the loader threw a redirect Response, start a new REPLACE navigation\n    if (isRedirectResult(result)) {\n      if (pendingNavigationLoadId > originatingLoadId) {\n        // A new navigation was kicked off after our loader started, so that\n        // should take precedence over this redirect navigation\n        updateFetcherState(key, getDoneFetcher(undefined));\n        return;\n      } else {\n        fetchRedirectIds.add(key);\n        await startRedirectNavigation(fetchRequest, result, false, {\n          preventScrollReset,\n        });\n        return;\n      }\n    }\n\n    // Process any non-redirect errors thrown\n    if (isErrorResult(result)) {\n      setFetcherError(key, routeId, result.error);\n      return;\n    }\n\n    invariant(!isDeferredResult(result), \"Unhandled fetcher deferred data\");\n\n    // Put the fetcher back into an idle state\n    updateFetcherState(key, getDoneFetcher(result.data));\n  }\n\n  /**\n   * Utility function to handle redirects returned from an action or loader.\n   * Normally, a redirect \"replaces\" the navigation that triggered it.  So, for\n   * example:\n   *\n   *  - user is on /a\n   *  - user clicks a link to /b\n   *  - loader for /b redirects to /c\n   *\n   * In a non-JS app the browser would track the in-flight navigation to /b and\n   * then replace it with /c when it encountered the redirect response.  In\n   * the end it would only ever update the URL bar with /c.\n   *\n   * In client-side routing using pushState/replaceState, we aim to emulate\n   * this behavior and we also do not update history until the end of the\n   * navigation (including processed redirects).  This means that we never\n   * actually touch history until we've processed redirects, so we just use\n   * the history action from the original navigation (PUSH or REPLACE).\n   */\n  async function startRedirectNavigation(\n    request: Request,\n    redirect: RedirectResult,\n    isNavigation: boolean,\n    {\n      submission,\n      fetcherSubmission,\n      preventScrollReset,\n      replace,\n    }: {\n      submission?: Submission;\n      fetcherSubmission?: Submission;\n      preventScrollReset?: boolean;\n      replace?: boolean;\n    } = {}\n  ) {\n    if (redirect.response.headers.has(\"X-Remix-Revalidate\")) {\n      isRevalidationRequired = true;\n    }\n\n    let location = redirect.response.headers.get(\"Location\");\n    invariant(location, \"Expected a Location header on the redirect Response\");\n    location = normalizeRedirectLocation(\n      location,\n      new URL(request.url),\n      basename\n    );\n    let redirectLocation = createLocation(state.location, location, {\n      _isRedirect: true,\n    });\n\n    if (isBrowser) {\n      let isDocumentReload = false;\n\n      if (redirect.response.headers.has(\"X-Remix-Reload-Document\")) {\n        // Hard reload if the response contained X-Remix-Reload-Document\n        isDocumentReload = true;\n      } else if (ABSOLUTE_URL_REGEX.test(location)) {\n        const url = init.history.createURL(location);\n        isDocumentReload =\n          // Hard reload if it's an absolute URL to a new origin\n          url.origin !== routerWindow.location.origin ||\n          // Hard reload if it's an absolute URL that does not match our basename\n          stripBasename(url.pathname, basename) == null;\n      }\n\n      if (isDocumentReload) {\n        if (replace) {\n          routerWindow.location.replace(location);\n        } else {\n          routerWindow.location.assign(location);\n        }\n        return;\n      }\n    }\n\n    // There's no need to abort on redirects, since we don't detect the\n    // redirect until the action/loaders have settled\n    pendingNavigationController = null;\n\n    let redirectHistoryAction =\n      replace === true || redirect.response.headers.has(\"X-Remix-Replace\")\n        ? HistoryAction.Replace\n        : HistoryAction.Push;\n\n    // Use the incoming submission if provided, fallback on the active one in\n    // state.navigation\n    let { formMethod, formAction, formEncType } = state.navigation;\n    if (\n      !submission &&\n      !fetcherSubmission &&\n      formMethod &&\n      formAction &&\n      formEncType\n    ) {\n      submission = getSubmissionFromNavigation(state.navigation);\n    }\n\n    // If this was a 307/308 submission we want to preserve the HTTP method and\n    // re-submit the GET/POST/PUT/PATCH/DELETE as a submission navigation to the\n    // redirected location\n    let activeSubmission = submission || fetcherSubmission;\n    if (\n      redirectPreserveMethodStatusCodes.has(redirect.response.status) &&\n      activeSubmission &&\n      isMutationMethod(activeSubmission.formMethod)\n    ) {\n      await startNavigation(redirectHistoryAction, redirectLocation, {\n        submission: {\n          ...activeSubmission,\n          formAction: location,\n        },\n        // Preserve these flags across redirects\n        preventScrollReset: preventScrollReset || pendingPreventScrollReset,\n        enableViewTransition: isNavigation\n          ? pendingViewTransitionEnabled\n          : undefined,\n      });\n    } else {\n      // If we have a navigation submission, we will preserve it through the\n      // redirect navigation\n      let overrideNavigation = getLoadingNavigation(\n        redirectLocation,\n        submission\n      );\n      await startNavigation(redirectHistoryAction, redirectLocation, {\n        overrideNavigation,\n        // Send fetcher submissions through for shouldRevalidate\n        fetcherSubmission,\n        // Preserve these flags across redirects\n        preventScrollReset: preventScrollReset || pendingPreventScrollReset,\n        enableViewTransition: isNavigation\n          ? pendingViewTransitionEnabled\n          : undefined,\n      });\n    }\n  }\n\n  // Utility wrapper for calling dataStrategy client-side without having to\n  // pass around the manifest, mapRouteProperties, etc.\n  async function callDataStrategy(\n    type: \"loader\" | \"action\",\n    state: RouterState,\n    request: Request,\n    matchesToLoad: AgnosticDataRouteMatch[],\n    matches: AgnosticDataRouteMatch[],\n    fetcherKey: string | null\n  ): Promise<Record<string, DataResult>> {\n    let results: Record<string, DataStrategyResult>;\n    let dataResults: Record<string, DataResult> = {};\n    try {\n      results = await callDataStrategyImpl(\n        dataStrategyImpl,\n        type,\n        state,\n        request,\n        matchesToLoad,\n        matches,\n        fetcherKey,\n        manifest,\n        mapRouteProperties\n      );\n    } catch (e) {\n      // If the outer dataStrategy method throws, just return the error for all\n      // matches - and it'll naturally bubble to the root\n      matchesToLoad.forEach((m) => {\n        dataResults[m.route.id] = {\n          type: ResultType.error,\n          error: e,\n        };\n      });\n      return dataResults;\n    }\n\n    for (let [routeId, result] of Object.entries(results)) {\n      if (isRedirectDataStrategyResultResult(result)) {\n        let response = result.result as Response;\n        dataResults[routeId] = {\n          type: ResultType.redirect,\n          response: normalizeRelativeRoutingRedirectResponse(\n            response,\n            request,\n            routeId,\n            matches,\n            basename,\n            future.v7_relativeSplatPath\n          ),\n        };\n      } else {\n        dataResults[routeId] = await convertDataStrategyResultToDataResult(\n          result\n        );\n      }\n    }\n\n    return dataResults;\n  }\n\n  async function callLoadersAndMaybeResolveData(\n    state: RouterState,\n    matches: AgnosticDataRouteMatch[],\n    matchesToLoad: AgnosticDataRouteMatch[],\n    fetchersToLoad: RevalidatingFetcher[],\n    request: Request\n  ) {\n    let currentMatches = state.matches;\n\n    // Kick off loaders and fetchers in parallel\n    let loaderResultsPromise = callDataStrategy(\n      \"loader\",\n      state,\n      request,\n      matchesToLoad,\n      matches,\n      null\n    );\n\n    let fetcherResultsPromise = Promise.all(\n      fetchersToLoad.map(async (f) => {\n        if (f.matches && f.match && f.controller) {\n          let results = await callDataStrategy(\n            \"loader\",\n            state,\n            createClientSideRequest(init.history, f.path, f.controller.signal),\n            [f.match],\n            f.matches,\n            f.key\n          );\n          let result = results[f.match.route.id];\n          // Fetcher results are keyed by fetcher key from here on out, not routeId\n          return { [f.key]: result };\n        } else {\n          return Promise.resolve({\n            [f.key]: {\n              type: ResultType.error,\n              error: getInternalRouterError(404, {\n                pathname: f.path,\n              }),\n            } as ErrorResult,\n          });\n        }\n      })\n    );\n\n    let loaderResults = await loaderResultsPromise;\n    let fetcherResults = (await fetcherResultsPromise).reduce(\n      (acc, r) => Object.assign(acc, r),\n      {}\n    );\n\n    await Promise.all([\n      resolveNavigationDeferredResults(\n        matches,\n        loaderResults,\n        request.signal,\n        currentMatches,\n        state.loaderData\n      ),\n      resolveFetcherDeferredResults(matches, fetcherResults, fetchersToLoad),\n    ]);\n\n    return {\n      loaderResults,\n      fetcherResults,\n    };\n  }\n\n  function interruptActiveLoads() {\n    // Every interruption triggers a revalidation\n    isRevalidationRequired = true;\n\n    // Cancel pending route-level deferreds and mark cancelled routes for\n    // revalidation\n    cancelledDeferredRoutes.push(...cancelActiveDeferreds());\n\n    // Abort in-flight fetcher loads\n    fetchLoadMatches.forEach((_, key) => {\n      if (fetchControllers.has(key)) {\n        cancelledFetcherLoads.add(key);\n      }\n      abortFetcher(key);\n    });\n  }\n\n  function updateFetcherState(\n    key: string,\n    fetcher: Fetcher,\n    opts: { flushSync?: boolean } = {}\n  ) {\n    state.fetchers.set(key, fetcher);\n    updateState(\n      { fetchers: new Map(state.fetchers) },\n      { flushSync: (opts && opts.flushSync) === true }\n    );\n  }\n\n  function setFetcherError(\n    key: string,\n    routeId: string,\n    error: any,\n    opts: { flushSync?: boolean } = {}\n  ) {\n    let boundaryMatch = findNearestBoundary(state.matches, routeId);\n    deleteFetcher(key);\n    updateState(\n      {\n        errors: {\n          [boundaryMatch.route.id]: error,\n        },\n        fetchers: new Map(state.fetchers),\n      },\n      { flushSync: (opts && opts.flushSync) === true }\n    );\n  }\n\n  function getFetcher<TData = any>(key: string): Fetcher<TData> {\n    if (future.v7_fetcherPersist) {\n      activeFetchers.set(key, (activeFetchers.get(key) || 0) + 1);\n      // If this fetcher was previously marked for deletion, unmark it since we\n      // have a new instance\n      if (deletedFetchers.has(key)) {\n        deletedFetchers.delete(key);\n      }\n    }\n    return state.fetchers.get(key) || IDLE_FETCHER;\n  }\n\n  function deleteFetcher(key: string): void {\n    let fetcher = state.fetchers.get(key);\n    // Don't abort the controller if this is a deletion of a fetcher.submit()\n    // in it's loading phase since - we don't want to abort the corresponding\n    // revalidation and want them to complete and land\n    if (\n      fetchControllers.has(key) &&\n      !(fetcher && fetcher.state === \"loading\" && fetchReloadIds.has(key))\n    ) {\n      abortFetcher(key);\n    }\n    fetchLoadMatches.delete(key);\n    fetchReloadIds.delete(key);\n    fetchRedirectIds.delete(key);\n    deletedFetchers.delete(key);\n    cancelledFetcherLoads.delete(key);\n    state.fetchers.delete(key);\n  }\n\n  function deleteFetcherAndUpdateState(key: string): void {\n    if (future.v7_fetcherPersist) {\n      let count = (activeFetchers.get(key) || 0) - 1;\n      if (count <= 0) {\n        activeFetchers.delete(key);\n        deletedFetchers.add(key);\n      } else {\n        activeFetchers.set(key, count);\n      }\n    } else {\n      deleteFetcher(key);\n    }\n    updateState({ fetchers: new Map(state.fetchers) });\n  }\n\n  function abortFetcher(key: string) {\n    let controller = fetchControllers.get(key);\n    if (controller) {\n      controller.abort();\n      fetchControllers.delete(key);\n    }\n  }\n\n  function markFetchersDone(keys: string[]) {\n    for (let key of keys) {\n      let fetcher = getFetcher(key);\n      let doneFetcher = getDoneFetcher(fetcher.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n  }\n\n  function markFetchRedirectsDone(): boolean {\n    let doneKeys = [];\n    let updatedFetchers = false;\n    for (let key of fetchRedirectIds) {\n      let fetcher = state.fetchers.get(key);\n      invariant(fetcher, `Expected fetcher: ${key}`);\n      if (fetcher.state === \"loading\") {\n        fetchRedirectIds.delete(key);\n        doneKeys.push(key);\n        updatedFetchers = true;\n      }\n    }\n    markFetchersDone(doneKeys);\n    return updatedFetchers;\n  }\n\n  function abortStaleFetchLoads(landedId: number): boolean {\n    let yeetedKeys = [];\n    for (let [key, id] of fetchReloadIds) {\n      if (id < landedId) {\n        let fetcher = state.fetchers.get(key);\n        invariant(fetcher, `Expected fetcher: ${key}`);\n        if (fetcher.state === \"loading\") {\n          abortFetcher(key);\n          fetchReloadIds.delete(key);\n          yeetedKeys.push(key);\n        }\n      }\n    }\n    markFetchersDone(yeetedKeys);\n    return yeetedKeys.length > 0;\n  }\n\n  function getBlocker(key: string, fn: BlockerFunction) {\n    let blocker: Blocker = state.blockers.get(key) || IDLE_BLOCKER;\n\n    if (blockerFunctions.get(key) !== fn) {\n      blockerFunctions.set(key, fn);\n    }\n\n    return blocker;\n  }\n\n  function deleteBlocker(key: string) {\n    state.blockers.delete(key);\n    blockerFunctions.delete(key);\n  }\n\n  // Utility function to update blockers, ensuring valid state transitions\n  function updateBlocker(key: string, newBlocker: Blocker) {\n    let blocker = state.blockers.get(key) || IDLE_BLOCKER;\n\n    // Poor mans state machine :)\n    // https://mermaid.live/edit#pako:eNqVkc9OwzAMxl8l8nnjAYrEtDIOHEBIgwvKJTReGy3_lDpIqO27k6awMG0XcrLlnz87nwdonESogKXXBuE79rq75XZO3-yHds0RJVuv70YrPlUrCEe2HfrORS3rubqZfuhtpg5C9wk5tZ4VKcRUq88q9Z8RS0-48cE1iHJkL0ugbHuFLus9L6spZy8nX9MP2CNdomVaposqu3fGayT8T8-jJQwhepo_UtpgBQaDEUom04dZhAN1aJBDlUKJBxE1ceB2Smj0Mln-IBW5AFU2dwUiktt_2Qaq2dBfaKdEup85UV7Yd-dKjlnkabl2Pvr0DTkTreM\n    invariant(\n      (blocker.state === \"unblocked\" && newBlocker.state === \"blocked\") ||\n        (blocker.state === \"blocked\" && newBlocker.state === \"blocked\") ||\n        (blocker.state === \"blocked\" && newBlocker.state === \"proceeding\") ||\n        (blocker.state === \"blocked\" && newBlocker.state === \"unblocked\") ||\n        (blocker.state === \"proceeding\" && newBlocker.state === \"unblocked\"),\n      `Invalid blocker state transition: ${blocker.state} -> ${newBlocker.state}`\n    );\n\n    let blockers = new Map(state.blockers);\n    blockers.set(key, newBlocker);\n    updateState({ blockers });\n  }\n\n  function shouldBlockNavigation({\n    currentLocation,\n    nextLocation,\n    historyAction,\n  }: {\n    currentLocation: Location;\n    nextLocation: Location;\n    historyAction: HistoryAction;\n  }): string | undefined {\n    if (blockerFunctions.size === 0) {\n      return;\n    }\n\n    // We ony support a single active blocker at the moment since we don't have\n    // any compelling use cases for multi-blocker yet\n    if (blockerFunctions.size > 1) {\n      warning(false, \"A router only supports one blocker at a time\");\n    }\n\n    let entries = Array.from(blockerFunctions.entries());\n    let [blockerKey, blockerFunction] = entries[entries.length - 1];\n    let blocker = state.blockers.get(blockerKey);\n\n    if (blocker && blocker.state === \"proceeding\") {\n      // If the blocker is currently proceeding, we don't need to re-check\n      // it and can let this navigation continue\n      return;\n    }\n\n    // At this point, we know we're unblocked/blocked so we need to check the\n    // user-provided blocker function\n    if (blockerFunction({ currentLocation, nextLocation, historyAction })) {\n      return blockerKey;\n    }\n  }\n\n  function handleNavigational404(pathname: string) {\n    let error = getInternalRouterError(404, { pathname });\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let { matches, route } = getShortCircuitMatches(routesToUse);\n\n    // Cancel all pending deferred on 404s since we don't keep any routes\n    cancelActiveDeferreds();\n\n    return { notFoundMatches: matches, route, error };\n  }\n\n  function cancelActiveDeferreds(\n    predicate?: (routeId: string) => boolean\n  ): string[] {\n    let cancelledRouteIds: string[] = [];\n    activeDeferreds.forEach((dfd, routeId) => {\n      if (!predicate || predicate(routeId)) {\n        // Cancel the deferred - but do not remove from activeDeferreds here -\n        // we rely on the subscribers to do that so our tests can assert proper\n        // cleanup via _internalActiveDeferreds\n        dfd.cancel();\n        cancelledRouteIds.push(routeId);\n        activeDeferreds.delete(routeId);\n      }\n    });\n    return cancelledRouteIds;\n  }\n\n  // Opt in to capturing and reporting scroll positions during navigations,\n  // used by the <ScrollRestoration> component\n  function enableScrollRestoration(\n    positions: Record<string, number>,\n    getPosition: GetScrollPositionFunction,\n    getKey?: GetScrollRestorationKeyFunction\n  ) {\n    savedScrollPositions = positions;\n    getScrollPosition = getPosition;\n    getScrollRestorationKey = getKey || null;\n\n    // Perform initial hydration scroll restoration, since we miss the boat on\n    // the initial updateState() because we've not yet rendered <ScrollRestoration/>\n    // and therefore have no savedScrollPositions available\n    if (!initialScrollRestored && state.navigation === IDLE_NAVIGATION) {\n      initialScrollRestored = true;\n      let y = getSavedScrollPosition(state.location, state.matches);\n      if (y != null) {\n        updateState({ restoreScrollPosition: y });\n      }\n    }\n\n    return () => {\n      savedScrollPositions = null;\n      getScrollPosition = null;\n      getScrollRestorationKey = null;\n    };\n  }\n\n  function getScrollKey(location: Location, matches: AgnosticDataRouteMatch[]) {\n    if (getScrollRestorationKey) {\n      let key = getScrollRestorationKey(\n        location,\n        matches.map((m) => convertRouteMatchToUiMatch(m, state.loaderData))\n      );\n      return key || location.key;\n    }\n    return location.key;\n  }\n\n  function saveScrollPosition(\n    location: Location,\n    matches: AgnosticDataRouteMatch[]\n  ): void {\n    if (savedScrollPositions && getScrollPosition) {\n      let key = getScrollKey(location, matches);\n      savedScrollPositions[key] = getScrollPosition();\n    }\n  }\n\n  function getSavedScrollPosition(\n    location: Location,\n    matches: AgnosticDataRouteMatch[]\n  ): number | null {\n    if (savedScrollPositions) {\n      let key = getScrollKey(location, matches);\n      let y = savedScrollPositions[key];\n      if (typeof y === \"number\") {\n        return y;\n      }\n    }\n    return null;\n  }\n\n  function checkFogOfWar(\n    matches: AgnosticDataRouteMatch[] | null,\n    routesToUse: AgnosticDataRouteObject[],\n    pathname: string\n  ): { active: boolean; matches: AgnosticDataRouteMatch[] | null } {\n    if (patchRoutesOnNavigationImpl) {\n      if (!matches) {\n        let fogMatches = matchRoutesImpl<AgnosticDataRouteObject>(\n          routesToUse,\n          pathname,\n          basename,\n          true\n        );\n\n        return { active: true, matches: fogMatches || [] };\n      } else {\n        if (Object.keys(matches[0].params).length > 0) {\n          // If we matched a dynamic param or a splat, it might only be because\n          // we haven't yet discovered other routes that would match with a\n          // higher score.  Call patchRoutesOnNavigation just to be sure\n          let partialMatches = matchRoutesImpl<AgnosticDataRouteObject>(\n            routesToUse,\n            pathname,\n            basename,\n            true\n          );\n          return { active: true, matches: partialMatches };\n        }\n      }\n    }\n\n    return { active: false, matches: null };\n  }\n\n  type DiscoverRoutesSuccessResult = {\n    type: \"success\";\n    matches: AgnosticDataRouteMatch[] | null;\n  };\n  type DiscoverRoutesErrorResult = {\n    type: \"error\";\n    error: any;\n    partialMatches: AgnosticDataRouteMatch[];\n  };\n  type DiscoverRoutesAbortedResult = { type: \"aborted\" };\n  type DiscoverRoutesResult =\n    | DiscoverRoutesSuccessResult\n    | DiscoverRoutesErrorResult\n    | DiscoverRoutesAbortedResult;\n\n  async function discoverRoutes(\n    matches: AgnosticDataRouteMatch[],\n    pathname: string,\n    signal: AbortSignal\n  ): Promise<DiscoverRoutesResult> {\n    if (!patchRoutesOnNavigationImpl) {\n      return { type: \"success\", matches };\n    }\n\n    let partialMatches: AgnosticDataRouteMatch[] | null = matches;\n    while (true) {\n      let isNonHMR = inFlightDataRoutes == null;\n      let routesToUse = inFlightDataRoutes || dataRoutes;\n      let localManifest = manifest;\n      try {\n        await patchRoutesOnNavigationImpl({\n          path: pathname,\n          matches: partialMatches,\n          patch: (routeId, children) => {\n            if (signal.aborted) return;\n            patchRoutesImpl(\n              routeId,\n              children,\n              routesToUse,\n              localManifest,\n              mapRouteProperties\n            );\n          },\n        });\n      } catch (e) {\n        return { type: \"error\", error: e, partialMatches };\n      } finally {\n        // If we are not in the middle of an HMR revalidation and we changed the\n        // routes, provide a new identity so when we `updateState` at the end of\n        // this navigation/fetch `router.routes` will be a new identity and\n        // trigger a re-run of memoized `router.routes` dependencies.\n        // HMR will already update the identity and reflow when it lands\n        // `inFlightDataRoutes` in `completeNavigation`\n        if (isNonHMR && !signal.aborted) {\n          dataRoutes = [...dataRoutes];\n        }\n      }\n\n      if (signal.aborted) {\n        return { type: \"aborted\" };\n      }\n\n      let newMatches = matchRoutes(routesToUse, pathname, basename);\n      if (newMatches) {\n        return { type: \"success\", matches: newMatches };\n      }\n\n      let newPartialMatches = matchRoutesImpl<AgnosticDataRouteObject>(\n        routesToUse,\n        pathname,\n        basename,\n        true\n      );\n\n      // Avoid loops if the second pass results in the same partial matches\n      if (\n        !newPartialMatches ||\n        (partialMatches.length === newPartialMatches.length &&\n          partialMatches.every(\n            (m, i) => m.route.id === newPartialMatches![i].route.id\n          ))\n      ) {\n        return { type: \"success\", matches: null };\n      }\n\n      partialMatches = newPartialMatches;\n    }\n  }\n\n  function _internalSetRoutes(newRoutes: AgnosticDataRouteObject[]) {\n    manifest = {};\n    inFlightDataRoutes = convertRoutesToDataRoutes(\n      newRoutes,\n      mapRouteProperties,\n      undefined,\n      manifest\n    );\n  }\n\n  function patchRoutes(\n    routeId: string | null,\n    children: AgnosticRouteObject[]\n  ): void {\n    let isNonHMR = inFlightDataRoutes == null;\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    patchRoutesImpl(\n      routeId,\n      children,\n      routesToUse,\n      manifest,\n      mapRouteProperties\n    );\n\n    // If we are not in the middle of an HMR revalidation and we changed the\n    // routes, provide a new identity and trigger a reflow via `updateState`\n    // to re-run memoized `router.routes` dependencies.\n    // HMR will already update the identity and reflow when it lands\n    // `inFlightDataRoutes` in `completeNavigation`\n    if (isNonHMR) {\n      dataRoutes = [...dataRoutes];\n      updateState({});\n    }\n  }\n\n  router = {\n    get basename() {\n      return basename;\n    },\n    get future() {\n      return future;\n    },\n    get state() {\n      return state;\n    },\n    get routes() {\n      return dataRoutes;\n    },\n    get window() {\n      return routerWindow;\n    },\n    initialize,\n    subscribe,\n    enableScrollRestoration,\n    navigate,\n    fetch,\n    revalidate,\n    // Passthrough to history-aware createHref used by useHref so we get proper\n    // hash-aware URLs in DOM paths\n    createHref: (to: To) => init.history.createHref(to),\n    encodeLocation: (to: To) => init.history.encodeLocation(to),\n    getFetcher,\n    deleteFetcher: deleteFetcherAndUpdateState,\n    dispose,\n    getBlocker,\n    deleteBlocker,\n    patchRoutes,\n    _internalFetchControllers: fetchControllers,\n    _internalActiveDeferreds: activeDeferreds,\n    // TODO: Remove setRoutes, it's temporary to avoid dealing with\n    // updating the tree while validating the update algorithm.\n    _internalSetRoutes,\n  };\n\n  return router;\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region createStaticHandler\n////////////////////////////////////////////////////////////////////////////////\n\nexport const UNSAFE_DEFERRED_SYMBOL = Symbol(\"deferred\");\n\n/**\n * Future flags to toggle new feature behavior\n */\nexport interface StaticHandlerFutureConfig {\n  v7_relativeSplatPath: boolean;\n  v7_throwAbortReason: boolean;\n}\n\nexport interface CreateStaticHandlerOptions {\n  basename?: string;\n  /**\n   * @deprecated Use `mapRouteProperties` instead\n   */\n  detectErrorBoundary?: DetectErrorBoundaryFunction;\n  mapRouteProperties?: MapRoutePropertiesFunction;\n  future?: Partial<StaticHandlerFutureConfig>;\n}\n\nexport function createStaticHandler(\n  routes: AgnosticRouteObject[],\n  opts?: CreateStaticHandlerOptions\n): StaticHandler {\n  invariant(\n    routes.length > 0,\n    \"You must provide a non-empty routes array to createStaticHandler\"\n  );\n\n  let manifest: RouteManifest = {};\n  let basename = (opts ? opts.basename : null) || \"/\";\n  let mapRouteProperties: MapRoutePropertiesFunction;\n  if (opts?.mapRouteProperties) {\n    mapRouteProperties = opts.mapRouteProperties;\n  } else if (opts?.detectErrorBoundary) {\n    // If they are still using the deprecated version, wrap it with the new API\n    let detectErrorBoundary = opts.detectErrorBoundary;\n    mapRouteProperties = (route) => ({\n      hasErrorBoundary: detectErrorBoundary(route),\n    });\n  } else {\n    mapRouteProperties = defaultMapRouteProperties;\n  }\n  // Config driven behavior flags\n  let future: StaticHandlerFutureConfig = {\n    v7_relativeSplatPath: false,\n    v7_throwAbortReason: false,\n    ...(opts ? opts.future : null),\n  };\n\n  let dataRoutes = convertRoutesToDataRoutes(\n    routes,\n    mapRouteProperties,\n    undefined,\n    manifest\n  );\n\n  /**\n   * The query() method is intended for document requests, in which we want to\n   * call an optional action and potentially multiple loaders for all nested\n   * routes.  It returns a StaticHandlerContext object, which is very similar\n   * to the router state (location, loaderData, actionData, errors, etc.) and\n   * also adds SSR-specific information such as the statusCode and headers\n   * from action/loaders Responses.\n   *\n   * It _should_ never throw and should report all errors through the\n   * returned context.errors object, properly associating errors to their error\n   * boundary.  Additionally, it tracks _deepestRenderedBoundaryId which can be\n   * used to emulate React error boundaries during SSr by performing a second\n   * pass only down to the boundaryId.\n   *\n   * The one exception where we do not return a StaticHandlerContext is when a\n   * redirect response is returned or thrown from any action/loader.  We\n   * propagate that out and return the raw Response so the HTTP server can\n   * return it directly.\n   *\n   * - `opts.requestContext` is an optional server context that will be passed\n   *   to actions/loaders in the `context` parameter\n   * - `opts.skipLoaderErrorBubbling` is an optional parameter that will prevent\n   *   the bubbling of errors which allows single-fetch-type implementations\n   *   where the client will handle the bubbling and we may need to return data\n   *   for the handling route\n   */\n  async function query(\n    request: Request,\n    {\n      requestContext,\n      skipLoaderErrorBubbling,\n      dataStrategy,\n    }: {\n      requestContext?: unknown;\n      skipLoaderErrorBubbling?: boolean;\n      dataStrategy?: DataStrategyFunction;\n    } = {}\n  ): Promise<StaticHandlerContext | Response> {\n    let url = new URL(request.url);\n    let method = request.method;\n    let location = createLocation(\"\", createPath(url), null, \"default\");\n    let matches = matchRoutes(dataRoutes, location, basename);\n\n    // SSR supports HEAD requests while SPA doesn't\n    if (!isValidMethod(method) && method !== \"HEAD\") {\n      let error = getInternalRouterError(405, { method });\n      let { matches: methodNotAllowedMatches, route } =\n        getShortCircuitMatches(dataRoutes);\n      return {\n        basename,\n        location,\n        matches: methodNotAllowedMatches,\n        loaderData: {},\n        actionData: null,\n        errors: {\n          [route.id]: error,\n        },\n        statusCode: error.status,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null,\n      };\n    } else if (!matches) {\n      let error = getInternalRouterError(404, { pathname: location.pathname });\n      let { matches: notFoundMatches, route } =\n        getShortCircuitMatches(dataRoutes);\n      return {\n        basename,\n        location,\n        matches: notFoundMatches,\n        loaderData: {},\n        actionData: null,\n        errors: {\n          [route.id]: error,\n        },\n        statusCode: error.status,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null,\n      };\n    }\n\n    let result = await queryImpl(\n      request,\n      location,\n      matches,\n      requestContext,\n      dataStrategy || null,\n      skipLoaderErrorBubbling === true,\n      null\n    );\n    if (isResponse(result)) {\n      return result;\n    }\n\n    // When returning StaticHandlerContext, we patch back in the location here\n    // since we need it for React Context.  But this helps keep our submit and\n    // loadRouteData operating on a Request instead of a Location\n    return { location, basename, ...result };\n  }\n\n  /**\n   * The queryRoute() method is intended for targeted route requests, either\n   * for fetch ?_data requests or resource route requests.  In this case, we\n   * are only ever calling a single action or loader, and we are returning the\n   * returned value directly.  In most cases, this will be a Response returned\n   * from the action/loader, but it may be a primitive or other value as well -\n   * and in such cases the calling context should handle that accordingly.\n   *\n   * We do respect the throw/return differentiation, so if an action/loader\n   * throws, then this method will throw the value.  This is important so we\n   * can do proper boundary identification in Remix where a thrown Response\n   * must go to the Catch Boundary but a returned Response is happy-path.\n   *\n   * One thing to note is that any Router-initiated Errors that make sense\n   * to associate with a status code will be thrown as an ErrorResponse\n   * instance which include the raw Error, such that the calling context can\n   * serialize the error as they see fit while including the proper response\n   * code.  Examples here are 404 and 405 errors that occur prior to reaching\n   * any user-defined loaders.\n   *\n   * - `opts.routeId` allows you to specify the specific route handler to call.\n   *   If not provided the handler will determine the proper route by matching\n   *   against `request.url`\n   * - `opts.requestContext` is an optional server context that will be passed\n   *    to actions/loaders in the `context` parameter\n   */\n  async function queryRoute(\n    request: Request,\n    {\n      routeId,\n      requestContext,\n      dataStrategy,\n    }: {\n      requestContext?: unknown;\n      routeId?: string;\n      dataStrategy?: DataStrategyFunction;\n    } = {}\n  ): Promise<any> {\n    let url = new URL(request.url);\n    let method = request.method;\n    let location = createLocation(\"\", createPath(url), null, \"default\");\n    let matches = matchRoutes(dataRoutes, location, basename);\n\n    // SSR supports HEAD requests while SPA doesn't\n    if (!isValidMethod(method) && method !== \"HEAD\" && method !== \"OPTIONS\") {\n      throw getInternalRouterError(405, { method });\n    } else if (!matches) {\n      throw getInternalRouterError(404, { pathname: location.pathname });\n    }\n\n    let match = routeId\n      ? matches.find((m) => m.route.id === routeId)\n      : getTargetMatch(matches, location);\n\n    if (routeId && !match) {\n      throw getInternalRouterError(403, {\n        pathname: location.pathname,\n        routeId,\n      });\n    } else if (!match) {\n      // This should never hit I don't think?\n      throw getInternalRouterError(404, { pathname: location.pathname });\n    }\n\n    let result = await queryImpl(\n      request,\n      location,\n      matches,\n      requestContext,\n      dataStrategy || null,\n      false,\n      match\n    );\n\n    if (isResponse(result)) {\n      return result;\n    }\n\n    let error = result.errors ? Object.values(result.errors)[0] : undefined;\n    if (error !== undefined) {\n      // If we got back result.errors, that means the loader/action threw\n      // _something_ that wasn't a Response, but it's not guaranteed/required\n      // to be an `instanceof Error` either, so we have to use throw here to\n      // preserve the \"error\" state outside of queryImpl.\n      throw error;\n    }\n\n    // Pick off the right state value to return\n    if (result.actionData) {\n      return Object.values(result.actionData)[0];\n    }\n\n    if (result.loaderData) {\n      let data = Object.values(result.loaderData)[0];\n      if (result.activeDeferreds?.[match.route.id]) {\n        data[UNSAFE_DEFERRED_SYMBOL] = result.activeDeferreds[match.route.id];\n      }\n      return data;\n    }\n\n    return undefined;\n  }\n\n  async function queryImpl(\n    request: Request,\n    location: Location,\n    matches: AgnosticDataRouteMatch[],\n    requestContext: unknown,\n    dataStrategy: DataStrategyFunction | null,\n    skipLoaderErrorBubbling: boolean,\n    routeMatch: AgnosticDataRouteMatch | null\n  ): Promise<Omit<StaticHandlerContext, \"location\" | \"basename\"> | Response> {\n    invariant(\n      request.signal,\n      \"query()/queryRoute() requests must contain an AbortController signal\"\n    );\n\n    try {\n      if (isMutationMethod(request.method.toLowerCase())) {\n        let result = await submit(\n          request,\n          matches,\n          routeMatch || getTargetMatch(matches, location),\n          requestContext,\n          dataStrategy,\n          skipLoaderErrorBubbling,\n          routeMatch != null\n        );\n        return result;\n      }\n\n      let result = await loadRouteData(\n        request,\n        matches,\n        requestContext,\n        dataStrategy,\n        skipLoaderErrorBubbling,\n        routeMatch\n      );\n      return isResponse(result)\n        ? result\n        : {\n            ...result,\n            actionData: null,\n            actionHeaders: {},\n          };\n    } catch (e) {\n      // If the user threw/returned a Response in callLoaderOrAction for a\n      // `queryRoute` call, we throw the `DataStrategyResult` to bail out early\n      // and then return or throw the raw Response here accordingly\n      if (isDataStrategyResult(e) && isResponse(e.result)) {\n        if (e.type === ResultType.error) {\n          throw e.result;\n        }\n        return e.result;\n      }\n      // Redirects are always returned since they don't propagate to catch\n      // boundaries\n      if (isRedirectResponse(e)) {\n        return e;\n      }\n      throw e;\n    }\n  }\n\n  async function submit(\n    request: Request,\n    matches: AgnosticDataRouteMatch[],\n    actionMatch: AgnosticDataRouteMatch,\n    requestContext: unknown,\n    dataStrategy: DataStrategyFunction | null,\n    skipLoaderErrorBubbling: boolean,\n    isRouteRequest: boolean\n  ): Promise<Omit<StaticHandlerContext, \"location\" | \"basename\"> | Response> {\n    let result: DataResult;\n\n    if (!actionMatch.route.action && !actionMatch.route.lazy) {\n      let error = getInternalRouterError(405, {\n        method: request.method,\n        pathname: new URL(request.url).pathname,\n        routeId: actionMatch.route.id,\n      });\n      if (isRouteRequest) {\n        throw error;\n      }\n      result = {\n        type: ResultType.error,\n        error,\n      };\n    } else {\n      let results = await callDataStrategy(\n        \"action\",\n        request,\n        [actionMatch],\n        matches,\n        isRouteRequest,\n        requestContext,\n        dataStrategy\n      );\n      result = results[actionMatch.route.id];\n\n      if (request.signal.aborted) {\n        throwStaticHandlerAbortedError(request, isRouteRequest, future);\n      }\n    }\n\n    if (isRedirectResult(result)) {\n      // Uhhhh - this should never happen, we should always throw these from\n      // callLoaderOrAction, but the type narrowing here keeps TS happy and we\n      // can get back on the \"throw all redirect responses\" train here should\n      // this ever happen :/\n      throw new Response(null, {\n        status: result.response.status,\n        headers: {\n          Location: result.response.headers.get(\"Location\")!,\n        },\n      });\n    }\n\n    if (isDeferredResult(result)) {\n      let error = getInternalRouterError(400, { type: \"defer-action\" });\n      if (isRouteRequest) {\n        throw error;\n      }\n      result = {\n        type: ResultType.error,\n        error,\n      };\n    }\n\n    if (isRouteRequest) {\n      // Note: This should only be non-Response values if we get here, since\n      // isRouteRequest should throw any Response received in callLoaderOrAction\n      if (isErrorResult(result)) {\n        throw result.error;\n      }\n\n      return {\n        matches: [actionMatch],\n        loaderData: {},\n        actionData: { [actionMatch.route.id]: result.data },\n        errors: null,\n        // Note: statusCode + headers are unused here since queryRoute will\n        // return the raw Response or value\n        statusCode: 200,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null,\n      };\n    }\n\n    // Create a GET request for the loaders\n    let loaderRequest = new Request(request.url, {\n      headers: request.headers,\n      redirect: request.redirect,\n      signal: request.signal,\n    });\n\n    if (isErrorResult(result)) {\n      // Store off the pending error - we use it to determine which loaders\n      // to call and will commit it when we complete the navigation\n      let boundaryMatch = skipLoaderErrorBubbling\n        ? actionMatch\n        : findNearestBoundary(matches, actionMatch.route.id);\n\n      let context = await loadRouteData(\n        loaderRequest,\n        matches,\n        requestContext,\n        dataStrategy,\n        skipLoaderErrorBubbling,\n        null,\n        [boundaryMatch.route.id, result]\n      );\n\n      // action status codes take precedence over loader status codes\n      return {\n        ...context,\n        statusCode: isRouteErrorResponse(result.error)\n          ? result.error.status\n          : result.statusCode != null\n          ? result.statusCode\n          : 500,\n        actionData: null,\n        actionHeaders: {\n          ...(result.headers ? { [actionMatch.route.id]: result.headers } : {}),\n        },\n      };\n    }\n\n    let context = await loadRouteData(\n      loaderRequest,\n      matches,\n      requestContext,\n      dataStrategy,\n      skipLoaderErrorBubbling,\n      null\n    );\n\n    return {\n      ...context,\n      actionData: {\n        [actionMatch.route.id]: result.data,\n      },\n      // action status codes take precedence over loader status codes\n      ...(result.statusCode ? { statusCode: result.statusCode } : {}),\n      actionHeaders: result.headers\n        ? { [actionMatch.route.id]: result.headers }\n        : {},\n    };\n  }\n\n  async function loadRouteData(\n    request: Request,\n    matches: AgnosticDataRouteMatch[],\n    requestContext: unknown,\n    dataStrategy: DataStrategyFunction | null,\n    skipLoaderErrorBubbling: boolean,\n    routeMatch: AgnosticDataRouteMatch | null,\n    pendingActionResult?: PendingActionResult\n  ): Promise<\n    | Omit<\n        StaticHandlerContext,\n        \"location\" | \"basename\" | \"actionData\" | \"actionHeaders\"\n      >\n    | Response\n  > {\n    let isRouteRequest = routeMatch != null;\n\n    // Short circuit if we have no loaders to run (queryRoute())\n    if (\n      isRouteRequest &&\n      !routeMatch?.route.loader &&\n      !routeMatch?.route.lazy\n    ) {\n      throw getInternalRouterError(400, {\n        method: request.method,\n        pathname: new URL(request.url).pathname,\n        routeId: routeMatch?.route.id,\n      });\n    }\n\n    let requestMatches = routeMatch\n      ? [routeMatch]\n      : pendingActionResult && isErrorResult(pendingActionResult[1])\n      ? getLoaderMatchesUntilBoundary(matches, pendingActionResult[0])\n      : matches;\n    let matchesToLoad = requestMatches.filter(\n      (m) => m.route.loader || m.route.lazy\n    );\n\n    // Short circuit if we have no loaders to run (query())\n    if (matchesToLoad.length === 0) {\n      return {\n        matches,\n        // Add a null for all matched routes for proper revalidation on the client\n        loaderData: matches.reduce(\n          (acc, m) => Object.assign(acc, { [m.route.id]: null }),\n          {}\n        ),\n        errors:\n          pendingActionResult && isErrorResult(pendingActionResult[1])\n            ? {\n                [pendingActionResult[0]]: pendingActionResult[1].error,\n              }\n            : null,\n        statusCode: 200,\n        loaderHeaders: {},\n        activeDeferreds: null,\n      };\n    }\n\n    let results = await callDataStrategy(\n      \"loader\",\n      request,\n      matchesToLoad,\n      matches,\n      isRouteRequest,\n      requestContext,\n      dataStrategy\n    );\n\n    if (request.signal.aborted) {\n      throwStaticHandlerAbortedError(request, isRouteRequest, future);\n    }\n\n    // Process and commit output from loaders\n    let activeDeferreds = new Map<string, DeferredData>();\n    let context = processRouteLoaderData(\n      matches,\n      results,\n      pendingActionResult,\n      activeDeferreds,\n      skipLoaderErrorBubbling\n    );\n\n    // Add a null for any non-loader matches for proper revalidation on the client\n    let executedLoaders = new Set<string>(\n      matchesToLoad.map((match) => match.route.id)\n    );\n    matches.forEach((match) => {\n      if (!executedLoaders.has(match.route.id)) {\n        context.loaderData[match.route.id] = null;\n      }\n    });\n\n    return {\n      ...context,\n      matches,\n      activeDeferreds:\n        activeDeferreds.size > 0\n          ? Object.fromEntries(activeDeferreds.entries())\n          : null,\n    };\n  }\n\n  // Utility wrapper for calling dataStrategy server-side without having to\n  // pass around the manifest, mapRouteProperties, etc.\n  async function callDataStrategy(\n    type: \"loader\" | \"action\",\n    request: Request,\n    matchesToLoad: AgnosticDataRouteMatch[],\n    matches: AgnosticDataRouteMatch[],\n    isRouteRequest: boolean,\n    requestContext: unknown,\n    dataStrategy: DataStrategyFunction | null\n  ): Promise<Record<string, DataResult>> {\n    let results = await callDataStrategyImpl(\n      dataStrategy || defaultDataStrategy,\n      type,\n      null,\n      request,\n      matchesToLoad,\n      matches,\n      null,\n      manifest,\n      mapRouteProperties,\n      requestContext\n    );\n\n    let dataResults: Record<string, DataResult> = {};\n    await Promise.all(\n      matches.map(async (match) => {\n        if (!(match.route.id in results)) {\n          return;\n        }\n        let result = results[match.route.id];\n        if (isRedirectDataStrategyResultResult(result)) {\n          let response = result.result as Response;\n          // Throw redirects and let the server handle them with an HTTP redirect\n          throw normalizeRelativeRoutingRedirectResponse(\n            response,\n            request,\n            match.route.id,\n            matches,\n            basename,\n            future.v7_relativeSplatPath\n          );\n        }\n        if (isResponse(result.result) && isRouteRequest) {\n          // For SSR single-route requests, we want to hand Responses back\n          // directly without unwrapping\n          throw result;\n        }\n\n        dataResults[match.route.id] =\n          await convertDataStrategyResultToDataResult(result);\n      })\n    );\n    return dataResults;\n  }\n\n  return {\n    dataRoutes,\n    query,\n    queryRoute,\n  };\n}\n\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Helpers\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Given an existing StaticHandlerContext and an error thrown at render time,\n * provide an updated StaticHandlerContext suitable for a second SSR render\n */\nexport function getStaticContextFromError(\n  routes: AgnosticDataRouteObject[],\n  context: StaticHandlerContext,\n  error: any\n) {\n  let newContext: StaticHandlerContext = {\n    ...context,\n    statusCode: isRouteErrorResponse(error) ? error.status : 500,\n    errors: {\n      [context._deepestRenderedBoundaryId || routes[0].id]: error,\n    },\n  };\n  return newContext;\n}\n\nfunction throwStaticHandlerAbortedError(\n  request: Request,\n  isRouteRequest: boolean,\n  future: StaticHandlerFutureConfig\n) {\n  if (future.v7_throwAbortReason && request.signal.reason !== undefined) {\n    throw request.signal.reason;\n  }\n\n  let method = isRouteRequest ? \"queryRoute\" : \"query\";\n  throw new Error(`${method}() call aborted: ${request.method} ${request.url}`);\n}\n\nfunction isSubmissionNavigation(\n  opts: BaseNavigateOrFetchOptions\n): opts is SubmissionNavigateOptions {\n  return (\n    opts != null &&\n    ((\"formData\" in opts && opts.formData != null) ||\n      (\"body\" in opts && opts.body !== undefined))\n  );\n}\n\nfunction normalizeTo(\n  location: Path,\n  matches: AgnosticDataRouteMatch[],\n  basename: string,\n  prependBasename: boolean,\n  to: To | null,\n  v7_relativeSplatPath: boolean,\n  fromRouteId?: string,\n  relative?: RelativeRoutingType\n) {\n  let contextualMatches: AgnosticDataRouteMatch[];\n  let activeRouteMatch: AgnosticDataRouteMatch | undefined;\n  if (fromRouteId) {\n    // Grab matches up to the calling route so our route-relative logic is\n    // relative to the correct source route\n    contextualMatches = [];\n    for (let match of matches) {\n      contextualMatches.push(match);\n      if (match.route.id === fromRouteId) {\n        activeRouteMatch = match;\n        break;\n      }\n    }\n  } else {\n    contextualMatches = matches;\n    activeRouteMatch = matches[matches.length - 1];\n  }\n\n  // Resolve the relative path\n  let path = resolveTo(\n    to ? to : \".\",\n    getResolveToMatches(contextualMatches, v7_relativeSplatPath),\n    stripBasename(location.pathname, basename) || location.pathname,\n    relative === \"path\"\n  );\n\n  // When `to` is not specified we inherit search/hash from the current\n  // location, unlike when to=\".\" and we just inherit the path.\n  // See https://github.com/remix-run/remix/issues/927\n  if (to == null) {\n    path.search = location.search;\n    path.hash = location.hash;\n  }\n\n  // Account for `?index` params when routing to the current location\n  if ((to == null || to === \"\" || to === \".\") && activeRouteMatch) {\n    let nakedIndex = hasNakedIndexQuery(path.search);\n    if (activeRouteMatch.route.index && !nakedIndex) {\n      // Add one when we're targeting an index route\n      path.search = path.search\n        ? path.search.replace(/^\\?/, \"?index&\")\n        : \"?index\";\n    } else if (!activeRouteMatch.route.index && nakedIndex) {\n      // Remove existing ones when we're not\n      let params = new URLSearchParams(path.search);\n      let indexValues = params.getAll(\"index\");\n      params.delete(\"index\");\n      indexValues.filter((v) => v).forEach((v) => params.append(\"index\", v));\n      let qs = params.toString();\n      path.search = qs ? `?${qs}` : \"\";\n    }\n  }\n\n  // If we're operating within a basename, prepend it to the pathname.  If\n  // this is a root navigation, then just use the raw basename which allows\n  // the basename to have full control over the presence of a trailing slash\n  // on root actions\n  if (prependBasename && basename !== \"/\") {\n    path.pathname =\n      path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n  }\n\n  return createPath(path);\n}\n\n// Normalize navigation options by converting formMethod=GET formData objects to\n// URLSearchParams so they behave identically to links with query params\nfunction normalizeNavigateOptions(\n  normalizeFormMethod: boolean,\n  isFetcher: boolean,\n  path: string,\n  opts?: BaseNavigateOrFetchOptions\n): {\n  path: string;\n  submission?: Submission;\n  error?: ErrorResponseImpl;\n} {\n  // Return location verbatim on non-submission navigations\n  if (!opts || !isSubmissionNavigation(opts)) {\n    return { path };\n  }\n\n  if (opts.formMethod && !isValidMethod(opts.formMethod)) {\n    return {\n      path,\n      error: getInternalRouterError(405, { method: opts.formMethod }),\n    };\n  }\n\n  let getInvalidBodyError = () => ({\n    path,\n    error: getInternalRouterError(400, { type: \"invalid-body\" }),\n  });\n\n  // Create a Submission on non-GET navigations\n  let rawFormMethod = opts.formMethod || \"get\";\n  let formMethod = normalizeFormMethod\n    ? (rawFormMethod.toUpperCase() as V7_FormMethod)\n    : (rawFormMethod.toLowerCase() as FormMethod);\n  let formAction = stripHashFromPath(path);\n\n  if (opts.body !== undefined) {\n    if (opts.formEncType === \"text/plain\") {\n      // text only support POST/PUT/PATCH/DELETE submissions\n      if (!isMutationMethod(formMethod)) {\n        return getInvalidBodyError();\n      }\n\n      let text =\n        typeof opts.body === \"string\"\n          ? opts.body\n          : opts.body instanceof FormData ||\n            opts.body instanceof URLSearchParams\n          ? // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#plain-text-form-data\n            Array.from(opts.body.entries()).reduce(\n              (acc, [name, value]) => `${acc}${name}=${value}\\n`,\n              \"\"\n            )\n          : String(opts.body);\n\n      return {\n        path,\n        submission: {\n          formMethod,\n          formAction,\n          formEncType: opts.formEncType,\n          formData: undefined,\n          json: undefined,\n          text,\n        },\n      };\n    } else if (opts.formEncType === \"application/json\") {\n      // json only supports POST/PUT/PATCH/DELETE submissions\n      if (!isMutationMethod(formMethod)) {\n        return getInvalidBodyError();\n      }\n\n      try {\n        let json =\n          typeof opts.body === \"string\" ? JSON.parse(opts.body) : opts.body;\n\n        return {\n          path,\n          submission: {\n            formMethod,\n            formAction,\n            formEncType: opts.formEncType,\n            formData: undefined,\n            json,\n            text: undefined,\n          },\n        };\n      } catch (e) {\n        return getInvalidBodyError();\n      }\n    }\n  }\n\n  invariant(\n    typeof FormData === \"function\",\n    \"FormData is not available in this environment\"\n  );\n\n  let searchParams: URLSearchParams;\n  let formData: FormData;\n\n  if (opts.formData) {\n    searchParams = convertFormDataToSearchParams(opts.formData);\n    formData = opts.formData;\n  } else if (opts.body instanceof FormData) {\n    searchParams = convertFormDataToSearchParams(opts.body);\n    formData = opts.body;\n  } else if (opts.body instanceof URLSearchParams) {\n    searchParams = opts.body;\n    formData = convertSearchParamsToFormData(searchParams);\n  } else if (opts.body == null) {\n    searchParams = new URLSearchParams();\n    formData = new FormData();\n  } else {\n    try {\n      searchParams = new URLSearchParams(opts.body);\n      formData = convertSearchParamsToFormData(searchParams);\n    } catch (e) {\n      return getInvalidBodyError();\n    }\n  }\n\n  let submission: Submission = {\n    formMethod,\n    formAction,\n    formEncType:\n      (opts && opts.formEncType) || \"application/x-www-form-urlencoded\",\n    formData,\n    json: undefined,\n    text: undefined,\n  };\n\n  if (isMutationMethod(submission.formMethod)) {\n    return { path, submission };\n  }\n\n  // Flatten submission onto URLSearchParams for GET submissions\n  let parsedPath = parsePath(path);\n  // On GET navigation submissions we can drop the ?index param from the\n  // resulting location since all loaders will run.  But fetcher GET submissions\n  // only run a single loader so we need to preserve any incoming ?index params\n  if (isFetcher && parsedPath.search && hasNakedIndexQuery(parsedPath.search)) {\n    searchParams.append(\"index\", \"\");\n  }\n  parsedPath.search = `?${searchParams}`;\n\n  return { path: createPath(parsedPath), submission };\n}\n\n// Filter out all routes at/below any caught error as they aren't going to\n// render so we don't need to load them\nfunction getLoaderMatchesUntilBoundary(\n  matches: AgnosticDataRouteMatch[],\n  boundaryId: string,\n  includeBoundary = false\n) {\n  let index = matches.findIndex((m) => m.route.id === boundaryId);\n  if (index >= 0) {\n    return matches.slice(0, includeBoundary ? index + 1 : index);\n  }\n  return matches;\n}\n\nfunction getMatchesToLoad(\n  history: History,\n  state: RouterState,\n  matches: AgnosticDataRouteMatch[],\n  submission: Submission | undefined,\n  location: Location,\n  initialHydration: boolean,\n  skipActionErrorRevalidation: boolean,\n  isRevalidationRequired: boolean,\n  cancelledDeferredRoutes: string[],\n  cancelledFetcherLoads: Set<string>,\n  deletedFetchers: Set<string>,\n  fetchLoadMatches: Map<string, FetchLoadMatch>,\n  fetchRedirectIds: Set<string>,\n  routesToUse: AgnosticDataRouteObject[],\n  basename: string | undefined,\n  pendingActionResult?: PendingActionResult\n): [AgnosticDataRouteMatch[], RevalidatingFetcher[]] {\n  let actionResult = pendingActionResult\n    ? isErrorResult(pendingActionResult[1])\n      ? pendingActionResult[1].error\n      : pendingActionResult[1].data\n    : undefined;\n  let currentUrl = history.createURL(state.location);\n  let nextUrl = history.createURL(location);\n\n  // Pick navigation matches that are net-new or qualify for revalidation\n  let boundaryMatches = matches;\n  if (initialHydration && state.errors) {\n    // On initial hydration, only consider matches up to _and including_ the boundary.\n    // This is inclusive to handle cases where a server loader ran successfully,\n    // a child server loader bubbled up to this route, but this route has\n    // `clientLoader.hydrate` so we want to still run the `clientLoader` so that\n    // we have a complete version of `loaderData`\n    boundaryMatches = getLoaderMatchesUntilBoundary(\n      matches,\n      Object.keys(state.errors)[0],\n      true\n    );\n  } else if (pendingActionResult && isErrorResult(pendingActionResult[1])) {\n    // If an action threw an error, we call loaders up to, but not including the\n    // boundary\n    boundaryMatches = getLoaderMatchesUntilBoundary(\n      matches,\n      pendingActionResult[0]\n    );\n  }\n\n  // Don't revalidate loaders by default after action 4xx/5xx responses\n  // when the flag is enabled.  They can still opt-into revalidation via\n  // `shouldRevalidate` via `actionResult`\n  let actionStatus = pendingActionResult\n    ? pendingActionResult[1].statusCode\n    : undefined;\n  let shouldSkipRevalidation =\n    skipActionErrorRevalidation && actionStatus && actionStatus >= 400;\n\n  let navigationMatches = boundaryMatches.filter((match, index) => {\n    let { route } = match;\n    if (route.lazy) {\n      // We haven't loaded this route yet so we don't know if it's got a loader!\n      return true;\n    }\n\n    if (route.loader == null) {\n      return false;\n    }\n\n    if (initialHydration) {\n      return shouldLoadRouteOnHydration(route, state.loaderData, state.errors);\n    }\n\n    // Always call the loader on new route instances and pending defer cancellations\n    if (\n      isNewLoader(state.loaderData, state.matches[index], match) ||\n      cancelledDeferredRoutes.some((id) => id === match.route.id)\n    ) {\n      return true;\n    }\n\n    // This is the default implementation for when we revalidate.  If the route\n    // provides it's own implementation, then we give them full control but\n    // provide this value so they can leverage it if needed after they check\n    // their own specific use cases\n    let currentRouteMatch = state.matches[index];\n    let nextRouteMatch = match;\n\n    return shouldRevalidateLoader(match, {\n      currentUrl,\n      currentParams: currentRouteMatch.params,\n      nextUrl,\n      nextParams: nextRouteMatch.params,\n      ...submission,\n      actionResult,\n      actionStatus,\n      defaultShouldRevalidate: shouldSkipRevalidation\n        ? false\n        : // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate\n          isRevalidationRequired ||\n          currentUrl.pathname + currentUrl.search ===\n            nextUrl.pathname + nextUrl.search ||\n          // Search params affect all loaders\n          currentUrl.search !== nextUrl.search ||\n          isNewRouteInstance(currentRouteMatch, nextRouteMatch),\n    });\n  });\n\n  // Pick fetcher.loads that need to be revalidated\n  let revalidatingFetchers: RevalidatingFetcher[] = [];\n  fetchLoadMatches.forEach((f, key) => {\n    // Don't revalidate:\n    //  - on initial hydration (shouldn't be any fetchers then anyway)\n    //  - if fetcher won't be present in the subsequent render\n    //    - no longer matches the URL (v7_fetcherPersist=false)\n    //    - was unmounted but persisted due to v7_fetcherPersist=true\n    if (\n      initialHydration ||\n      !matches.some((m) => m.route.id === f.routeId) ||\n      deletedFetchers.has(key)\n    ) {\n      return;\n    }\n\n    let fetcherMatches = matchRoutes(routesToUse, f.path, basename);\n\n    // If the fetcher path no longer matches, push it in with null matches so\n    // we can trigger a 404 in callLoadersAndMaybeResolveData.  Note this is\n    // currently only a use-case for Remix HMR where the route tree can change\n    // at runtime and remove a route previously loaded via a fetcher\n    if (!fetcherMatches) {\n      revalidatingFetchers.push({\n        key,\n        routeId: f.routeId,\n        path: f.path,\n        matches: null,\n        match: null,\n        controller: null,\n      });\n      return;\n    }\n\n    // Revalidating fetchers are decoupled from the route matches since they\n    // load from a static href.  They revalidate based on explicit revalidation\n    // (submission, useRevalidator, or X-Remix-Revalidate)\n    let fetcher = state.fetchers.get(key);\n    let fetcherMatch = getTargetMatch(fetcherMatches, f.path);\n\n    let shouldRevalidate = false;\n    if (fetchRedirectIds.has(key)) {\n      // Never trigger a revalidation of an actively redirecting fetcher\n      shouldRevalidate = false;\n    } else if (cancelledFetcherLoads.has(key)) {\n      // Always mark for revalidation if the fetcher was cancelled\n      cancelledFetcherLoads.delete(key);\n      shouldRevalidate = true;\n    } else if (\n      fetcher &&\n      fetcher.state !== \"idle\" &&\n      fetcher.data === undefined\n    ) {\n      // If the fetcher hasn't ever completed loading yet, then this isn't a\n      // revalidation, it would just be a brand new load if an explicit\n      // revalidation is required\n      shouldRevalidate = isRevalidationRequired;\n    } else {\n      // Otherwise fall back on any user-defined shouldRevalidate, defaulting\n      // to explicit revalidations only\n      shouldRevalidate = shouldRevalidateLoader(fetcherMatch, {\n        currentUrl,\n        currentParams: state.matches[state.matches.length - 1].params,\n        nextUrl,\n        nextParams: matches[matches.length - 1].params,\n        ...submission,\n        actionResult,\n        actionStatus,\n        defaultShouldRevalidate: shouldSkipRevalidation\n          ? false\n          : isRevalidationRequired,\n      });\n    }\n\n    if (shouldRevalidate) {\n      revalidatingFetchers.push({\n        key,\n        routeId: f.routeId,\n        path: f.path,\n        matches: fetcherMatches,\n        match: fetcherMatch,\n        controller: new AbortController(),\n      });\n    }\n  });\n\n  return [navigationMatches, revalidatingFetchers];\n}\n\nfunction shouldLoadRouteOnHydration(\n  route: AgnosticDataRouteObject,\n  loaderData: RouteData | null | undefined,\n  errors: RouteData | null | undefined\n) {\n  // We dunno if we have a loader - gotta find out!\n  if (route.lazy) {\n    return true;\n  }\n\n  // No loader, nothing to initialize\n  if (!route.loader) {\n    return false;\n  }\n\n  let hasData = loaderData != null && loaderData[route.id] !== undefined;\n  let hasError = errors != null && errors[route.id] !== undefined;\n\n  // Don't run if we error'd during SSR\n  if (!hasData && hasError) {\n    return false;\n  }\n\n  // Explicitly opting-in to running on hydration\n  if (typeof route.loader === \"function\" && route.loader.hydrate === true) {\n    return true;\n  }\n\n  // Otherwise, run if we're not yet initialized with anything\n  return !hasData && !hasError;\n}\n\nfunction isNewLoader(\n  currentLoaderData: RouteData,\n  currentMatch: AgnosticDataRouteMatch,\n  match: AgnosticDataRouteMatch\n) {\n  let isNew =\n    // [a] -> [a, b]\n    !currentMatch ||\n    // [a, b] -> [a, c]\n    match.route.id !== currentMatch.route.id;\n\n  // Handle the case that we don't have data for a re-used route, potentially\n  // from a prior error or from a cancelled pending deferred\n  let isMissingData = currentLoaderData[match.route.id] === undefined;\n\n  // Always load if this is a net-new route or we don't yet have data\n  return isNew || isMissingData;\n}\n\nfunction isNewRouteInstance(\n  currentMatch: AgnosticDataRouteMatch,\n  match: AgnosticDataRouteMatch\n) {\n  let currentPath = currentMatch.route.path;\n  return (\n    // param change for this match, /users/123 -> /users/456\n    currentMatch.pathname !== match.pathname ||\n    // splat param changed, which is not present in match.path\n    // e.g. /files/images/avatar.jpg -> files/finances.xls\n    (currentPath != null &&\n      currentPath.endsWith(\"*\") &&\n      currentMatch.params[\"*\"] !== match.params[\"*\"])\n  );\n}\n\nfunction shouldRevalidateLoader(\n  loaderMatch: AgnosticDataRouteMatch,\n  arg: ShouldRevalidateFunctionArgs\n) {\n  if (loaderMatch.route.shouldRevalidate) {\n    let routeChoice = loaderMatch.route.shouldRevalidate(arg);\n    if (typeof routeChoice === \"boolean\") {\n      return routeChoice;\n    }\n  }\n\n  return arg.defaultShouldRevalidate;\n}\n\nfunction patchRoutesImpl(\n  routeId: string | null,\n  children: AgnosticRouteObject[],\n  routesToUse: AgnosticDataRouteObject[],\n  manifest: RouteManifest,\n  mapRouteProperties: MapRoutePropertiesFunction\n) {\n  let childrenToPatch: AgnosticDataRouteObject[];\n  if (routeId) {\n    let route = manifest[routeId];\n    invariant(\n      route,\n      `No route found to patch children into: routeId = ${routeId}`\n    );\n    if (!route.children) {\n      route.children = [];\n    }\n    childrenToPatch = route.children;\n  } else {\n    childrenToPatch = routesToUse;\n  }\n\n  // Don't patch in routes we already know about so that `patch` is idempotent\n  // to simplify user-land code. This is useful because we re-call the\n  // `patchRoutesOnNavigation` function for matched routes with params.\n  let uniqueChildren = children.filter(\n    (newRoute) =>\n      !childrenToPatch.some((existingRoute) =>\n        isSameRoute(newRoute, existingRoute)\n      )\n  );\n\n  let newRoutes = convertRoutesToDataRoutes(\n    uniqueChildren,\n    mapRouteProperties,\n    [routeId || \"_\", \"patch\", String(childrenToPatch?.length || \"0\")],\n    manifest\n  );\n\n  childrenToPatch.push(...newRoutes);\n}\n\nfunction isSameRoute(\n  newRoute: AgnosticRouteObject,\n  existingRoute: AgnosticRouteObject\n): boolean {\n  // Most optimal check is by id\n  if (\n    \"id\" in newRoute &&\n    \"id\" in existingRoute &&\n    newRoute.id === existingRoute.id\n  ) {\n    return true;\n  }\n\n  // Second is by pathing differences\n  if (\n    !(\n      newRoute.index === existingRoute.index &&\n      newRoute.path === existingRoute.path &&\n      newRoute.caseSensitive === existingRoute.caseSensitive\n    )\n  ) {\n    return false;\n  }\n\n  // Pathless layout routes are trickier since we need to check children.\n  // If they have no children then they're the same as far as we can tell\n  if (\n    (!newRoute.children || newRoute.children.length === 0) &&\n    (!existingRoute.children || existingRoute.children.length === 0)\n  ) {\n    return true;\n  }\n\n  // Otherwise, we look to see if every child in the new route is already\n  // represented in the existing route's children\n  return newRoute.children!.every((aChild, i) =>\n    existingRoute.children?.some((bChild) => isSameRoute(aChild, bChild))\n  );\n}\n\n/**\n * Execute route.lazy() methods to lazily load route modules (loader, action,\n * shouldRevalidate) and update the routeManifest in place which shares objects\n * with dataRoutes so those get updated as well.\n */\nasync function loadLazyRouteModule(\n  route: AgnosticDataRouteObject,\n  mapRouteProperties: MapRoutePropertiesFunction,\n  manifest: RouteManifest\n) {\n  if (!route.lazy) {\n    return;\n  }\n\n  let lazyRoute = await route.lazy();\n\n  // If the lazy route function was executed and removed by another parallel\n  // call then we can return - first lazy() to finish wins because the return\n  // value of lazy is expected to be static\n  if (!route.lazy) {\n    return;\n  }\n\n  let routeToUpdate = manifest[route.id];\n  invariant(routeToUpdate, \"No route found in manifest\");\n\n  // Update the route in place.  This should be safe because there's no way\n  // we could yet be sitting on this route as we can't get there without\n  // resolving lazy() first.\n  //\n  // This is different than the HMR \"update\" use-case where we may actively be\n  // on the route being updated.  The main concern boils down to \"does this\n  // mutation affect any ongoing navigations or any current state.matches\n  // values?\".  If not, it should be safe to update in place.\n  let routeUpdates: Record<string, any> = {};\n  for (let lazyRouteProperty in lazyRoute) {\n    let staticRouteValue =\n      routeToUpdate[lazyRouteProperty as keyof typeof routeToUpdate];\n\n    let isPropertyStaticallyDefined =\n      staticRouteValue !== undefined &&\n      // This property isn't static since it should always be updated based\n      // on the route updates\n      lazyRouteProperty !== \"hasErrorBoundary\";\n\n    warning(\n      !isPropertyStaticallyDefined,\n      `Route \"${routeToUpdate.id}\" has a static property \"${lazyRouteProperty}\" ` +\n        `defined but its lazy function is also returning a value for this property. ` +\n        `The lazy route property \"${lazyRouteProperty}\" will be ignored.`\n    );\n\n    if (\n      !isPropertyStaticallyDefined &&\n      !immutableRouteKeys.has(lazyRouteProperty as ImmutableRouteKey)\n    ) {\n      routeUpdates[lazyRouteProperty] =\n        lazyRoute[lazyRouteProperty as keyof typeof lazyRoute];\n    }\n  }\n\n  // Mutate the route with the provided updates.  Do this first so we pass\n  // the updated version to mapRouteProperties\n  Object.assign(routeToUpdate, routeUpdates);\n\n  // Mutate the `hasErrorBoundary` property on the route based on the route\n  // updates and remove the `lazy` function so we don't resolve the lazy\n  // route again.\n  Object.assign(routeToUpdate, {\n    // To keep things framework agnostic, we use the provided\n    // `mapRouteProperties` (or wrapped `detectErrorBoundary`) function to\n    // set the framework-aware properties (`element`/`hasErrorBoundary`) since\n    // the logic will differ between frameworks.\n    ...mapRouteProperties(routeToUpdate),\n    lazy: undefined,\n  });\n}\n\n// Default implementation of `dataStrategy` which fetches all loaders in parallel\nasync function defaultDataStrategy({\n  matches,\n}: DataStrategyFunctionArgs): ReturnType<DataStrategyFunction> {\n  let matchesToLoad = matches.filter((m) => m.shouldLoad);\n  let results = await Promise.all(matchesToLoad.map((m) => m.resolve()));\n  return results.reduce(\n    (acc, result, i) =>\n      Object.assign(acc, { [matchesToLoad[i].route.id]: result }),\n    {}\n  );\n}\n\nasync function callDataStrategyImpl(\n  dataStrategyImpl: DataStrategyFunction,\n  type: \"loader\" | \"action\",\n  state: RouterState | null,\n  request: Request,\n  matchesToLoad: AgnosticDataRouteMatch[],\n  matches: AgnosticDataRouteMatch[],\n  fetcherKey: string | null,\n  manifest: RouteManifest,\n  mapRouteProperties: MapRoutePropertiesFunction,\n  requestContext?: unknown\n): Promise<Record<string, DataStrategyResult>> {\n  let loadRouteDefinitionsPromises = matches.map((m) =>\n    m.route.lazy\n      ? loadLazyRouteModule(m.route, mapRouteProperties, manifest)\n      : undefined\n  );\n\n  let dsMatches = matches.map((match, i) => {\n    let loadRoutePromise = loadRouteDefinitionsPromises[i];\n    let shouldLoad = matchesToLoad.some((m) => m.route.id === match.route.id);\n    // `resolve` encapsulates route.lazy(), executing the loader/action,\n    // and mapping return values/thrown errors to a `DataStrategyResult`.  Users\n    // can pass a callback to take fine-grained control over the execution\n    // of the loader/action\n    let resolve: DataStrategyMatch[\"resolve\"] = async (handlerOverride) => {\n      if (\n        handlerOverride &&\n        request.method === \"GET\" &&\n        (match.route.lazy || match.route.loader)\n      ) {\n        shouldLoad = true;\n      }\n      return shouldLoad\n        ? callLoaderOrAction(\n            type,\n            request,\n            match,\n            loadRoutePromise,\n            handlerOverride,\n            requestContext\n          )\n        : Promise.resolve({ type: ResultType.data, result: undefined });\n    };\n\n    return {\n      ...match,\n      shouldLoad,\n      resolve,\n    };\n  });\n\n  // Send all matches here to allow for a middleware-type implementation.\n  // handler will be a no-op for unneeded routes and we filter those results\n  // back out below.\n  let results = await dataStrategyImpl({\n    matches: dsMatches,\n    request,\n    params: matches[0].params,\n    fetcherKey,\n    context: requestContext,\n  });\n\n  // Wait for all routes to load here but 'swallow the error since we want\n  // it to bubble up from the `await loadRoutePromise` in `callLoaderOrAction` -\n  // called from `match.resolve()`\n  try {\n    await Promise.all(loadRouteDefinitionsPromises);\n  } catch (e) {\n    // No-op\n  }\n\n  return results;\n}\n\n// Default logic for calling a loader/action is the user has no specified a dataStrategy\nasync function callLoaderOrAction(\n  type: \"loader\" | \"action\",\n  request: Request,\n  match: AgnosticDataRouteMatch,\n  loadRoutePromise: Promise<void> | undefined,\n  handlerOverride: Parameters<DataStrategyMatch[\"resolve\"]>[0],\n  staticContext?: unknown\n): Promise<DataStrategyResult> {\n  let result: DataStrategyResult;\n  let onReject: (() => void) | undefined;\n\n  let runHandler = (\n    handler: AgnosticRouteObject[\"loader\"] | AgnosticRouteObject[\"action\"]\n  ): Promise<DataStrategyResult> => {\n    // Setup a promise we can race against so that abort signals short circuit\n    let reject: () => void;\n    // This will never resolve so safe to type it as Promise<DataStrategyResult> to\n    // satisfy the function return value\n    let abortPromise = new Promise<DataStrategyResult>((_, r) => (reject = r));\n    onReject = () => reject();\n    request.signal.addEventListener(\"abort\", onReject);\n\n    let actualHandler = (ctx?: unknown) => {\n      if (typeof handler !== \"function\") {\n        return Promise.reject(\n          new Error(\n            `You cannot call the handler for a route which defines a boolean ` +\n              `\"${type}\" [routeId: ${match.route.id}]`\n          )\n        );\n      }\n      return handler(\n        {\n          request,\n          params: match.params,\n          context: staticContext,\n        },\n        ...(ctx !== undefined ? [ctx] : [])\n      );\n    };\n\n    let handlerPromise: Promise<DataStrategyResult> = (async () => {\n      try {\n        let val = await (handlerOverride\n          ? handlerOverride((ctx: unknown) => actualHandler(ctx))\n          : actualHandler());\n        return { type: \"data\", result: val };\n      } catch (e) {\n        return { type: \"error\", result: e };\n      }\n    })();\n\n    return Promise.race([handlerPromise, abortPromise]);\n  };\n\n  try {\n    let handler = match.route[type];\n\n    // If we have a route.lazy promise, await that first\n    if (loadRoutePromise) {\n      if (handler) {\n        // Run statically defined handler in parallel with lazy()\n        let handlerError;\n        let [value] = await Promise.all([\n          // If the handler throws, don't let it immediately bubble out,\n          // since we need to let the lazy() execution finish so we know if this\n          // route has a boundary that can handle the error\n          runHandler(handler).catch((e) => {\n            handlerError = e;\n          }),\n          loadRoutePromise,\n        ]);\n        if (handlerError !== undefined) {\n          throw handlerError;\n        }\n        result = value!;\n      } else {\n        // Load lazy route module, then run any returned handler\n        await loadRoutePromise;\n\n        handler = match.route[type];\n        if (handler) {\n          // Handler still runs even if we got interrupted to maintain consistency\n          // with un-abortable behavior of handler execution on non-lazy or\n          // previously-lazy-loaded routes\n          result = await runHandler(handler);\n        } else if (type === \"action\") {\n          let url = new URL(request.url);\n          let pathname = url.pathname + url.search;\n          throw getInternalRouterError(405, {\n            method: request.method,\n            pathname,\n            routeId: match.route.id,\n          });\n        } else {\n          // lazy() route has no loader to run.  Short circuit here so we don't\n          // hit the invariant below that errors on returning undefined.\n          return { type: ResultType.data, result: undefined };\n        }\n      }\n    } else if (!handler) {\n      let url = new URL(request.url);\n      let pathname = url.pathname + url.search;\n      throw getInternalRouterError(404, {\n        pathname,\n      });\n    } else {\n      result = await runHandler(handler);\n    }\n\n    invariant(\n      result.result !== undefined,\n      `You defined ${type === \"action\" ? \"an action\" : \"a loader\"} for route ` +\n        `\"${match.route.id}\" but didn't return anything from your \\`${type}\\` ` +\n        `function. Please return a value or \\`null\\`.`\n    );\n  } catch (e) {\n    // We should already be catching and converting normal handler executions to\n    // DataStrategyResults and returning them, so anything that throws here is an\n    // unexpected error we still need to wrap\n    return { type: ResultType.error, result: e };\n  } finally {\n    if (onReject) {\n      request.signal.removeEventListener(\"abort\", onReject);\n    }\n  }\n\n  return result;\n}\n\nasync function convertDataStrategyResultToDataResult(\n  dataStrategyResult: DataStrategyResult\n): Promise<DataResult> {\n  let { result, type } = dataStrategyResult;\n\n  if (isResponse(result)) {\n    let data: any;\n\n    try {\n      let contentType = result.headers.get(\"Content-Type\");\n      // Check between word boundaries instead of startsWith() due to the last\n      // paragraph of https://httpwg.org/specs/rfc9110.html#field.content-type\n      if (contentType && /\\bapplication\\/json\\b/.test(contentType)) {\n        if (result.body == null) {\n          data = null;\n        } else {\n          data = await result.json();\n        }\n      } else {\n        data = await result.text();\n      }\n    } catch (e) {\n      return { type: ResultType.error, error: e };\n    }\n\n    if (type === ResultType.error) {\n      return {\n        type: ResultType.error,\n        error: new ErrorResponseImpl(result.status, result.statusText, data),\n        statusCode: result.status,\n        headers: result.headers,\n      };\n    }\n\n    return {\n      type: ResultType.data,\n      data,\n      statusCode: result.status,\n      headers: result.headers,\n    };\n  }\n\n  if (type === ResultType.error) {\n    if (isDataWithResponseInit(result)) {\n      if (result.data instanceof Error) {\n        return {\n          type: ResultType.error,\n          error: result.data,\n          statusCode: result.init?.status,\n        };\n      }\n\n      // Convert thrown data() to ErrorResponse instances\n      result = new ErrorResponseImpl(\n        result.init?.status || 500,\n        undefined,\n        result.data\n      );\n    }\n    return {\n      type: ResultType.error,\n      error: result,\n      statusCode: isRouteErrorResponse(result) ? result.status : undefined,\n    };\n  }\n\n  if (isDeferredData(result)) {\n    return {\n      type: ResultType.deferred,\n      deferredData: result,\n      statusCode: result.init?.status,\n      headers: result.init?.headers && new Headers(result.init.headers),\n    };\n  }\n\n  if (isDataWithResponseInit(result)) {\n    return {\n      type: ResultType.data,\n      data: result.data,\n      statusCode: result.init?.status,\n      headers: result.init?.headers\n        ? new Headers(result.init.headers)\n        : undefined,\n    };\n  }\n\n  return { type: ResultType.data, data: result };\n}\n\n// Support relative routing in internal redirects\nfunction normalizeRelativeRoutingRedirectResponse(\n  response: Response,\n  request: Request,\n  routeId: string,\n  matches: AgnosticDataRouteMatch[],\n  basename: string,\n  v7_relativeSplatPath: boolean\n) {\n  let location = response.headers.get(\"Location\");\n  invariant(\n    location,\n    \"Redirects returned/thrown from loaders/actions must have a Location header\"\n  );\n\n  if (!ABSOLUTE_URL_REGEX.test(location)) {\n    let trimmedMatches = matches.slice(\n      0,\n      matches.findIndex((m) => m.route.id === routeId) + 1\n    );\n    location = normalizeTo(\n      new URL(request.url),\n      trimmedMatches,\n      basename,\n      true,\n      location,\n      v7_relativeSplatPath\n    );\n    response.headers.set(\"Location\", location);\n  }\n\n  return response;\n}\n\nfunction normalizeRedirectLocation(\n  location: string,\n  currentUrl: URL,\n  basename: string\n): string {\n  if (ABSOLUTE_URL_REGEX.test(location)) {\n    // Strip off the protocol+origin for same-origin + same-basename absolute redirects\n    let normalizedLocation = location;\n    let url = normalizedLocation.startsWith(\"//\")\n      ? new URL(currentUrl.protocol + normalizedLocation)\n      : new URL(normalizedLocation);\n    let isSameBasename = stripBasename(url.pathname, basename) != null;\n    if (url.origin === currentUrl.origin && isSameBasename) {\n      return url.pathname + url.search + url.hash;\n    }\n  }\n  return location;\n}\n\n// Utility method for creating the Request instances for loaders/actions during\n// client-side navigations and fetches.  During SSR we will always have a\n// Request instance from the static handler (query/queryRoute)\nfunction createClientSideRequest(\n  history: History,\n  location: string | Location,\n  signal: AbortSignal,\n  submission?: Submission\n): Request {\n  let url = history.createURL(stripHashFromPath(location)).toString();\n  let init: RequestInit = { signal };\n\n  if (submission && isMutationMethod(submission.formMethod)) {\n    let { formMethod, formEncType } = submission;\n    // Didn't think we needed this but it turns out unlike other methods, patch\n    // won't be properly normalized to uppercase and results in a 405 error.\n    // See: https://fetch.spec.whatwg.org/#concept-method\n    init.method = formMethod.toUpperCase();\n\n    if (formEncType === \"application/json\") {\n      init.headers = new Headers({ \"Content-Type\": formEncType });\n      init.body = JSON.stringify(submission.json);\n    } else if (formEncType === \"text/plain\") {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = submission.text;\n    } else if (\n      formEncType === \"application/x-www-form-urlencoded\" &&\n      submission.formData\n    ) {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = convertFormDataToSearchParams(submission.formData);\n    } else {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = submission.formData;\n    }\n  }\n\n  return new Request(url, init);\n}\n\nfunction convertFormDataToSearchParams(formData: FormData): URLSearchParams {\n  let searchParams = new URLSearchParams();\n\n  for (let [key, value] of formData.entries()) {\n    // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#converting-an-entry-list-to-a-list-of-name-value-pairs\n    searchParams.append(key, typeof value === \"string\" ? value : value.name);\n  }\n\n  return searchParams;\n}\n\nfunction convertSearchParamsToFormData(\n  searchParams: URLSearchParams\n): FormData {\n  let formData = new FormData();\n  for (let [key, value] of searchParams.entries()) {\n    formData.append(key, value);\n  }\n  return formData;\n}\n\nfunction processRouteLoaderData(\n  matches: AgnosticDataRouteMatch[],\n  results: Record<string, DataResult>,\n  pendingActionResult: PendingActionResult | undefined,\n  activeDeferreds: Map<string, DeferredData>,\n  skipLoaderErrorBubbling: boolean\n): {\n  loaderData: RouterState[\"loaderData\"];\n  errors: RouterState[\"errors\"] | null;\n  statusCode: number;\n  loaderHeaders: Record<string, Headers>;\n} {\n  // Fill in loaderData/errors from our loaders\n  let loaderData: RouterState[\"loaderData\"] = {};\n  let errors: RouterState[\"errors\"] | null = null;\n  let statusCode: number | undefined;\n  let foundError = false;\n  let loaderHeaders: Record<string, Headers> = {};\n  let pendingError =\n    pendingActionResult && isErrorResult(pendingActionResult[1])\n      ? pendingActionResult[1].error\n      : undefined;\n\n  // Process loader results into state.loaderData/state.errors\n  matches.forEach((match) => {\n    if (!(match.route.id in results)) {\n      return;\n    }\n    let id = match.route.id;\n    let result = results[id];\n    invariant(\n      !isRedirectResult(result),\n      \"Cannot handle redirect results in processLoaderData\"\n    );\n    if (isErrorResult(result)) {\n      let error = result.error;\n      // If we have a pending action error, we report it at the highest-route\n      // that throws a loader error, and then clear it out to indicate that\n      // it was consumed\n      if (pendingError !== undefined) {\n        error = pendingError;\n        pendingError = undefined;\n      }\n\n      errors = errors || {};\n\n      if (skipLoaderErrorBubbling) {\n        errors[id] = error;\n      } else {\n        // Look upwards from the matched route for the closest ancestor error\n        // boundary, defaulting to the root match.  Prefer higher error values\n        // if lower errors bubble to the same boundary\n        let boundaryMatch = findNearestBoundary(matches, id);\n        if (errors[boundaryMatch.route.id] == null) {\n          errors[boundaryMatch.route.id] = error;\n        }\n      }\n\n      // Clear our any prior loaderData for the throwing route\n      loaderData[id] = undefined;\n\n      // Once we find our first (highest) error, we set the status code and\n      // prevent deeper status codes from overriding\n      if (!foundError) {\n        foundError = true;\n        statusCode = isRouteErrorResponse(result.error)\n          ? result.error.status\n          : 500;\n      }\n      if (result.headers) {\n        loaderHeaders[id] = result.headers;\n      }\n    } else {\n      if (isDeferredResult(result)) {\n        activeDeferreds.set(id, result.deferredData);\n        loaderData[id] = result.deferredData.data;\n        // Error status codes always override success status codes, but if all\n        // loaders are successful we take the deepest status code.\n        if (\n          result.statusCode != null &&\n          result.statusCode !== 200 &&\n          !foundError\n        ) {\n          statusCode = result.statusCode;\n        }\n        if (result.headers) {\n          loaderHeaders[id] = result.headers;\n        }\n      } else {\n        loaderData[id] = result.data;\n        // Error status codes always override success status codes, but if all\n        // loaders are successful we take the deepest status code.\n        if (result.statusCode && result.statusCode !== 200 && !foundError) {\n          statusCode = result.statusCode;\n        }\n        if (result.headers) {\n          loaderHeaders[id] = result.headers;\n        }\n      }\n    }\n  });\n\n  // If we didn't consume the pending action error (i.e., all loaders\n  // resolved), then consume it here.  Also clear out any loaderData for the\n  // throwing route\n  if (pendingError !== undefined && pendingActionResult) {\n    errors = { [pendingActionResult[0]]: pendingError };\n    loaderData[pendingActionResult[0]] = undefined;\n  }\n\n  return {\n    loaderData,\n    errors,\n    statusCode: statusCode || 200,\n    loaderHeaders,\n  };\n}\n\nfunction processLoaderData(\n  state: RouterState,\n  matches: AgnosticDataRouteMatch[],\n  results: Record<string, DataResult>,\n  pendingActionResult: PendingActionResult | undefined,\n  revalidatingFetchers: RevalidatingFetcher[],\n  fetcherResults: Record<string, DataResult>,\n  activeDeferreds: Map<string, DeferredData>\n): {\n  loaderData: RouterState[\"loaderData\"];\n  errors?: RouterState[\"errors\"];\n} {\n  let { loaderData, errors } = processRouteLoaderData(\n    matches,\n    results,\n    pendingActionResult,\n    activeDeferreds,\n    false // This method is only called client side so we always want to bubble\n  );\n\n  // Process results from our revalidating fetchers\n  revalidatingFetchers.forEach((rf) => {\n    let { key, match, controller } = rf;\n    let result = fetcherResults[key];\n    invariant(result, \"Did not find corresponding fetcher result\");\n\n    // Process fetcher non-redirect errors\n    if (controller && controller.signal.aborted) {\n      // Nothing to do for aborted fetchers\n      return;\n    } else if (isErrorResult(result)) {\n      let boundaryMatch = findNearestBoundary(state.matches, match?.route.id);\n      if (!(errors && errors[boundaryMatch.route.id])) {\n        errors = {\n          ...errors,\n          [boundaryMatch.route.id]: result.error,\n        };\n      }\n      state.fetchers.delete(key);\n    } else if (isRedirectResult(result)) {\n      // Should never get here, redirects should get processed above, but we\n      // keep this to type narrow to a success result in the else\n      invariant(false, \"Unhandled fetcher revalidation redirect\");\n    } else if (isDeferredResult(result)) {\n      // Should never get here, deferred data should be awaited for fetchers\n      // in resolveDeferredResults\n      invariant(false, \"Unhandled fetcher deferred data\");\n    } else {\n      let doneFetcher = getDoneFetcher(result.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n  });\n\n  return { loaderData, errors };\n}\n\nfunction mergeLoaderData(\n  loaderData: RouteData,\n  newLoaderData: RouteData,\n  matches: AgnosticDataRouteMatch[],\n  errors: RouteData | null | undefined\n): RouteData {\n  let mergedLoaderData = { ...newLoaderData };\n  for (let match of matches) {\n    let id = match.route.id;\n    if (newLoaderData.hasOwnProperty(id)) {\n      if (newLoaderData[id] !== undefined) {\n        mergedLoaderData[id] = newLoaderData[id];\n      } else {\n        // No-op - this is so we ignore existing data if we have a key in the\n        // incoming object with an undefined value, which is how we unset a prior\n        // loaderData if we encounter a loader error\n      }\n    } else if (loaderData[id] !== undefined && match.route.loader) {\n      // Preserve existing keys not included in newLoaderData and where a loader\n      // wasn't removed by HMR\n      mergedLoaderData[id] = loaderData[id];\n    }\n\n    if (errors && errors.hasOwnProperty(id)) {\n      // Don't keep any loader data below the boundary\n      break;\n    }\n  }\n  return mergedLoaderData;\n}\n\nfunction getActionDataForCommit(\n  pendingActionResult: PendingActionResult | undefined\n) {\n  if (!pendingActionResult) {\n    return {};\n  }\n  return isErrorResult(pendingActionResult[1])\n    ? {\n        // Clear out prior actionData on errors\n        actionData: {},\n      }\n    : {\n        actionData: {\n          [pendingActionResult[0]]: pendingActionResult[1].data,\n        },\n      };\n}\n\n// Find the nearest error boundary, looking upwards from the leaf route (or the\n// route specified by routeId) for the closest ancestor error boundary,\n// defaulting to the root match\nfunction findNearestBoundary(\n  matches: AgnosticDataRouteMatch[],\n  routeId?: string\n): AgnosticDataRouteMatch {\n  let eligibleMatches = routeId\n    ? matches.slice(0, matches.findIndex((m) => m.route.id === routeId) + 1)\n    : [...matches];\n  return (\n    eligibleMatches.reverse().find((m) => m.route.hasErrorBoundary === true) ||\n    matches[0]\n  );\n}\n\nfunction getShortCircuitMatches(routes: AgnosticDataRouteObject[]): {\n  matches: AgnosticDataRouteMatch[];\n  route: AgnosticDataRouteObject;\n} {\n  // Prefer a root layout route if present, otherwise shim in a route object\n  let route =\n    routes.length === 1\n      ? routes[0]\n      : routes.find((r) => r.index || !r.path || r.path === \"/\") || {\n          id: `__shim-error-route__`,\n        };\n\n  return {\n    matches: [\n      {\n        params: {},\n        pathname: \"\",\n        pathnameBase: \"\",\n        route,\n      },\n    ],\n    route,\n  };\n}\n\nfunction getInternalRouterError(\n  status: number,\n  {\n    pathname,\n    routeId,\n    method,\n    type,\n    message,\n  }: {\n    pathname?: string;\n    routeId?: string;\n    method?: string;\n    type?: \"defer-action\" | \"invalid-body\";\n    message?: string;\n  } = {}\n) {\n  let statusText = \"Unknown Server Error\";\n  let errorMessage = \"Unknown @remix-run/router error\";\n\n  if (status === 400) {\n    statusText = \"Bad Request\";\n    if (method && pathname && routeId) {\n      errorMessage =\n        `You made a ${method} request to \"${pathname}\" but ` +\n        `did not provide a \\`loader\\` for route \"${routeId}\", ` +\n        `so there is no way to handle the request.`;\n    } else if (type === \"defer-action\") {\n      errorMessage = \"defer() is not supported in actions\";\n    } else if (type === \"invalid-body\") {\n      errorMessage = \"Unable to encode submission body\";\n    }\n  } else if (status === 403) {\n    statusText = \"Forbidden\";\n    errorMessage = `Route \"${routeId}\" does not match URL \"${pathname}\"`;\n  } else if (status === 404) {\n    statusText = \"Not Found\";\n    errorMessage = `No route matches URL \"${pathname}\"`;\n  } else if (status === 405) {\n    statusText = \"Method Not Allowed\";\n    if (method && pathname && routeId) {\n      errorMessage =\n        `You made a ${method.toUpperCase()} request to \"${pathname}\" but ` +\n        `did not provide an \\`action\\` for route \"${routeId}\", ` +\n        `so there is no way to handle the request.`;\n    } else if (method) {\n      errorMessage = `Invalid request method \"${method.toUpperCase()}\"`;\n    }\n  }\n\n  return new ErrorResponseImpl(\n    status || 500,\n    statusText,\n    new Error(errorMessage),\n    true\n  );\n}\n\n// Find any returned redirect errors, starting from the lowest match\nfunction findRedirect(\n  results: Record<string, DataResult>\n): { key: string; result: RedirectResult } | undefined {\n  let entries = Object.entries(results);\n  for (let i = entries.length - 1; i >= 0; i--) {\n    let [key, result] = entries[i];\n    if (isRedirectResult(result)) {\n      return { key, result };\n    }\n  }\n}\n\nfunction stripHashFromPath(path: To) {\n  let parsedPath = typeof path === \"string\" ? parsePath(path) : path;\n  return createPath({ ...parsedPath, hash: \"\" });\n}\n\nfunction isHashChangeOnly(a: Location, b: Location): boolean {\n  if (a.pathname !== b.pathname || a.search !== b.search) {\n    return false;\n  }\n\n  if (a.hash === \"\") {\n    // /page -> /page#hash\n    return b.hash !== \"\";\n  } else if (a.hash === b.hash) {\n    // /page#hash -> /page#hash\n    return true;\n  } else if (b.hash !== \"\") {\n    // /page#hash -> /page#other\n    return true;\n  }\n\n  // If the hash is removed the browser will re-perform a request to the server\n  // /page#hash -> /page\n  return false;\n}\n\nfunction isPromise<T = unknown>(val: unknown): val is Promise<T> {\n  return typeof val === \"object\" && val != null && \"then\" in val;\n}\n\nfunction isDataStrategyResult(result: unknown): result is DataStrategyResult {\n  return (\n    result != null &&\n    typeof result === \"object\" &&\n    \"type\" in result &&\n    \"result\" in result &&\n    (result.type === ResultType.data || result.type === ResultType.error)\n  );\n}\n\nfunction isRedirectDataStrategyResultResult(result: DataStrategyResult) {\n  return (\n    isResponse(result.result) && redirectStatusCodes.has(result.result.status)\n  );\n}\n\nfunction isDeferredResult(result: DataResult): result is DeferredResult {\n  return result.type === ResultType.deferred;\n}\n\nfunction isErrorResult(result: DataResult): result is ErrorResult {\n  return result.type === ResultType.error;\n}\n\nfunction isRedirectResult(result?: DataResult): result is RedirectResult {\n  return (result && result.type) === ResultType.redirect;\n}\n\nexport function isDataWithResponseInit(\n  value: any\n): value is DataWithResponseInit<unknown> {\n  return (\n    typeof value === \"object\" &&\n    value != null &&\n    \"type\" in value &&\n    \"data\" in value &&\n    \"init\" in value &&\n    value.type === \"DataWithResponseInit\"\n  );\n}\n\nexport function isDeferredData(value: any): value is DeferredData {\n  let deferred: DeferredData = value;\n  return (\n    deferred &&\n    typeof deferred === \"object\" &&\n    typeof deferred.data === \"object\" &&\n    typeof deferred.subscribe === \"function\" &&\n    typeof deferred.cancel === \"function\" &&\n    typeof deferred.resolveData === \"function\"\n  );\n}\n\nfunction isResponse(value: any): value is Response {\n  return (\n    value != null &&\n    typeof value.status === \"number\" &&\n    typeof value.statusText === \"string\" &&\n    typeof value.headers === \"object\" &&\n    typeof value.body !== \"undefined\"\n  );\n}\n\nfunction isRedirectResponse(result: any): result is Response {\n  if (!isResponse(result)) {\n    return false;\n  }\n\n  let status = result.status;\n  let location = result.headers.get(\"Location\");\n  return status >= 300 && status <= 399 && location != null;\n}\n\nfunction isValidMethod(method: string): method is FormMethod | V7_FormMethod {\n  return validRequestMethods.has(method.toLowerCase() as FormMethod);\n}\n\nfunction isMutationMethod(\n  method: string\n): method is MutationFormMethod | V7_MutationFormMethod {\n  return validMutationMethods.has(method.toLowerCase() as MutationFormMethod);\n}\n\nasync function resolveNavigationDeferredResults(\n  matches: (AgnosticDataRouteMatch | null)[],\n  results: Record<string, DataResult>,\n  signal: AbortSignal,\n  currentMatches: AgnosticDataRouteMatch[],\n  currentLoaderData: RouteData\n) {\n  let entries = Object.entries(results);\n  for (let index = 0; index < entries.length; index++) {\n    let [routeId, result] = entries[index];\n    let match = matches.find((m) => m?.route.id === routeId);\n    // If we don't have a match, then we can have a deferred result to do\n    // anything with.  This is for revalidating fetchers where the route was\n    // removed during HMR\n    if (!match) {\n      continue;\n    }\n\n    let currentMatch = currentMatches.find(\n      (m) => m.route.id === match!.route.id\n    );\n    let isRevalidatingLoader =\n      currentMatch != null &&\n      !isNewRouteInstance(currentMatch, match) &&\n      (currentLoaderData && currentLoaderData[match.route.id]) !== undefined;\n\n    if (isDeferredResult(result) && isRevalidatingLoader) {\n      // Note: we do not have to touch activeDeferreds here since we race them\n      // against the signal in resolveDeferredData and they'll get aborted\n      // there if needed\n      await resolveDeferredData(result, signal, false).then((result) => {\n        if (result) {\n          results[routeId] = result;\n        }\n      });\n    }\n  }\n}\n\nasync function resolveFetcherDeferredResults(\n  matches: (AgnosticDataRouteMatch | null)[],\n  results: Record<string, DataResult>,\n  revalidatingFetchers: RevalidatingFetcher[]\n) {\n  for (let index = 0; index < revalidatingFetchers.length; index++) {\n    let { key, routeId, controller } = revalidatingFetchers[index];\n    let result = results[key];\n    let match = matches.find((m) => m?.route.id === routeId);\n    // If we don't have a match, then we can have a deferred result to do\n    // anything with.  This is for revalidating fetchers where the route was\n    // removed during HMR\n    if (!match) {\n      continue;\n    }\n\n    if (isDeferredResult(result)) {\n      // Note: we do not have to touch activeDeferreds here since we race them\n      // against the signal in resolveDeferredData and they'll get aborted\n      // there if needed\n      invariant(\n        controller,\n        \"Expected an AbortController for revalidating fetcher deferred result\"\n      );\n      await resolveDeferredData(result, controller.signal, true).then(\n        (result) => {\n          if (result) {\n            results[key] = result;\n          }\n        }\n      );\n    }\n  }\n}\n\nasync function resolveDeferredData(\n  result: DeferredResult,\n  signal: AbortSignal,\n  unwrap = false\n): Promise<SuccessResult | ErrorResult | undefined> {\n  let aborted = await result.deferredData.resolveData(signal);\n  if (aborted) {\n    return;\n  }\n\n  if (unwrap) {\n    try {\n      return {\n        type: ResultType.data,\n        data: result.deferredData.unwrappedData,\n      };\n    } catch (e) {\n      // Handle any TrackedPromise._error values encountered while unwrapping\n      return {\n        type: ResultType.error,\n        error: e,\n      };\n    }\n  }\n\n  return {\n    type: ResultType.data,\n    data: result.deferredData.data,\n  };\n}\n\nfunction hasNakedIndexQuery(search: string): boolean {\n  return new URLSearchParams(search).getAll(\"index\").some((v) => v === \"\");\n}\n\nfunction getTargetMatch(\n  matches: AgnosticDataRouteMatch[],\n  location: Location | string\n) {\n  let search =\n    typeof location === \"string\" ? parsePath(location).search : location.search;\n  if (\n    matches[matches.length - 1].route.index &&\n    hasNakedIndexQuery(search || \"\")\n  ) {\n    // Return the leaf index route when index is present\n    return matches[matches.length - 1];\n  }\n  // Otherwise grab the deepest \"path contributing\" match (ignoring index and\n  // pathless layout routes)\n  let pathMatches = getPathContributingMatches(matches);\n  return pathMatches[pathMatches.length - 1];\n}\n\nfunction getSubmissionFromNavigation(\n  navigation: Navigation\n): Submission | undefined {\n  let { formMethod, formAction, formEncType, text, formData, json } =\n    navigation;\n  if (!formMethod || !formAction || !formEncType) {\n    return;\n  }\n\n  if (text != null) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData: undefined,\n      json: undefined,\n      text,\n    };\n  } else if (formData != null) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData,\n      json: undefined,\n      text: undefined,\n    };\n  } else if (json !== undefined) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData: undefined,\n      json,\n      text: undefined,\n    };\n  }\n}\n\nfunction getLoadingNavigation(\n  location: Location,\n  submission?: Submission\n): NavigationStates[\"Loading\"] {\n  if (submission) {\n    let navigation: NavigationStates[\"Loading\"] = {\n      state: \"loading\",\n      location,\n      formMethod: submission.formMethod,\n      formAction: submission.formAction,\n      formEncType: submission.formEncType,\n      formData: submission.formData,\n      json: submission.json,\n      text: submission.text,\n    };\n    return navigation;\n  } else {\n    let navigation: NavigationStates[\"Loading\"] = {\n      state: \"loading\",\n      location,\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined,\n      json: undefined,\n      text: undefined,\n    };\n    return navigation;\n  }\n}\n\nfunction getSubmittingNavigation(\n  location: Location,\n  submission: Submission\n): NavigationStates[\"Submitting\"] {\n  let navigation: NavigationStates[\"Submitting\"] = {\n    state: \"submitting\",\n    location,\n    formMethod: submission.formMethod,\n    formAction: submission.formAction,\n    formEncType: submission.formEncType,\n    formData: submission.formData,\n    json: submission.json,\n    text: submission.text,\n  };\n  return navigation;\n}\n\nfunction getLoadingFetcher(\n  submission?: Submission,\n  data?: Fetcher[\"data\"]\n): FetcherStates[\"Loading\"] {\n  if (submission) {\n    let fetcher: FetcherStates[\"Loading\"] = {\n      state: \"loading\",\n      formMethod: submission.formMethod,\n      formAction: submission.formAction,\n      formEncType: submission.formEncType,\n      formData: submission.formData,\n      json: submission.json,\n      text: submission.text,\n      data,\n    };\n    return fetcher;\n  } else {\n    let fetcher: FetcherStates[\"Loading\"] = {\n      state: \"loading\",\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined,\n      json: undefined,\n      text: undefined,\n      data,\n    };\n    return fetcher;\n  }\n}\n\nfunction getSubmittingFetcher(\n  submission: Submission,\n  existingFetcher?: Fetcher\n): FetcherStates[\"Submitting\"] {\n  let fetcher: FetcherStates[\"Submitting\"] = {\n    state: \"submitting\",\n    formMethod: submission.formMethod,\n    formAction: submission.formAction,\n    formEncType: submission.formEncType,\n    formData: submission.formData,\n    json: submission.json,\n    text: submission.text,\n    data: existingFetcher ? existingFetcher.data : undefined,\n  };\n  return fetcher;\n}\n\nfunction getDoneFetcher(data: Fetcher[\"data\"]): FetcherStates[\"Idle\"] {\n  let fetcher: FetcherStates[\"Idle\"] = {\n    state: \"idle\",\n    formMethod: undefined,\n    formAction: undefined,\n    formEncType: undefined,\n    formData: undefined,\n    json: undefined,\n    text: undefined,\n    data,\n  };\n  return fetcher;\n}\n\nfunction restoreAppliedTransitions(\n  _window: Window,\n  transitions: Map<string, Set<string>>\n) {\n  try {\n    let sessionPositions = _window.sessionStorage.getItem(\n      TRANSITIONS_STORAGE_KEY\n    );\n    if (sessionPositions) {\n      let json = JSON.parse(sessionPositions);\n      for (let [k, v] of Object.entries(json || {})) {\n        if (v && Array.isArray(v)) {\n          transitions.set(k, new Set(v || []));\n        }\n      }\n    }\n  } catch (e) {\n    // no-op, use default empty object\n  }\n}\n\nfunction persistAppliedTransitions(\n  _window: Window,\n  transitions: Map<string, Set<string>>\n) {\n  if (transitions.size > 0) {\n    let json: Record<string, string[]> = {};\n    for (let [k, v] of transitions) {\n      json[k] = [...v];\n    }\n    try {\n      _window.sessionStorage.setItem(\n        TRANSITIONS_STORAGE_KEY,\n        JSON.stringify(json)\n      );\n    } catch (error) {\n      warning(\n        false,\n        `Failed to save applied view transitions in sessionStorage (${error}).`\n      );\n    }\n  }\n}\n//#endregion\n","import * as React from \"react\";\nimport type {\n  AgnosticIndexRouteObject,\n  AgnosticNonIndexRouteObject,\n  AgnosticRouteMatch,\n  History,\n  LazyRouteFunction,\n  Location,\n  Action as NavigationType,\n  RelativeRoutingType,\n  Router,\n  StaticHandlerContext,\n  To,\n  TrackedPromise,\n} from \"@remix-run/router\";\n\n// Create react-specific types from the agnostic types in @remix-run/router to\n// export from react-router\nexport interface IndexRouteObject {\n  caseSensitive?: AgnosticIndexRouteObject[\"caseSensitive\"];\n  path?: AgnosticIndexRouteObject[\"path\"];\n  id?: AgnosticIndexRouteObject[\"id\"];\n  loader?: AgnosticIndexRouteObject[\"loader\"];\n  action?: AgnosticIndexRouteObject[\"action\"];\n  hasErrorBoundary?: AgnosticIndexRouteObject[\"hasErrorBoundary\"];\n  shouldRevalidate?: AgnosticIndexRouteObject[\"shouldRevalidate\"];\n  handle?: AgnosticIndexRouteObject[\"handle\"];\n  index: true;\n  children?: undefined;\n  element?: React.ReactNode | null;\n  hydrateFallbackElement?: React.ReactNode | null;\n  errorElement?: React.ReactNode | null;\n  Component?: React.ComponentType | null;\n  HydrateFallback?: React.ComponentType | null;\n  ErrorBoundary?: React.ComponentType | null;\n  lazy?: LazyRouteFunction<RouteObject>;\n}\n\nexport interface NonIndexRouteObject {\n  caseSensitive?: AgnosticNonIndexRouteObject[\"caseSensitive\"];\n  path?: AgnosticNonIndexRouteObject[\"path\"];\n  id?: AgnosticNonIndexRouteObject[\"id\"];\n  loader?: AgnosticNonIndexRouteObject[\"loader\"];\n  action?: AgnosticNonIndexRouteObject[\"action\"];\n  hasErrorBoundary?: AgnosticNonIndexRouteObject[\"hasErrorBoundary\"];\n  shouldRevalidate?: AgnosticNonIndexRouteObject[\"shouldRevalidate\"];\n  handle?: AgnosticNonIndexRouteObject[\"handle\"];\n  index?: false;\n  children?: RouteObject[];\n  element?: React.ReactNode | null;\n  hydrateFallbackElement?: React.ReactNode | null;\n  errorElement?: React.ReactNode | null;\n  Component?: React.ComponentType | null;\n  HydrateFallback?: React.ComponentType | null;\n  ErrorBoundary?: React.ComponentType | null;\n  lazy?: LazyRouteFunction<RouteObject>;\n}\n\nexport type RouteObject = IndexRouteObject | NonIndexRouteObject;\n\nexport type DataRouteObject = RouteObject & {\n  children?: DataRouteObject[];\n  id: string;\n};\n\nexport interface RouteMatch<\n  ParamKey extends string = string,\n  RouteObjectType extends RouteObject = RouteObject\n> extends AgnosticRouteMatch<ParamKey, RouteObjectType> {}\n\nexport interface DataRouteMatch extends RouteMatch<string, DataRouteObject> {}\n\nexport interface DataRouterContextObject\n  // Omit `future` since those can be pulled from the `router`\n  // `NavigationContext` needs future since it doesn't have a `router` in all cases\n  extends Omit<NavigationContextObject, \"future\"> {\n  router: Router;\n  staticContext?: StaticHandlerContext;\n}\n\nexport const DataRouterContext =\n  React.createContext<DataRouterContextObject | null>(null);\nif (__DEV__) {\n  DataRouterContext.displayName = \"DataRouter\";\n}\n\nexport const DataRouterStateContext = React.createContext<\n  Router[\"state\"] | null\n>(null);\nif (__DEV__) {\n  DataRouterStateContext.displayName = \"DataRouterState\";\n}\n\nexport const AwaitContext = React.createContext<TrackedPromise | null>(null);\nif (__DEV__) {\n  AwaitContext.displayName = \"Await\";\n}\n\nexport interface NavigateOptions {\n  replace?: boolean;\n  state?: any;\n  preventScrollReset?: boolean;\n  relative?: RelativeRoutingType;\n  flushSync?: boolean;\n  viewTransition?: boolean;\n}\n\n/**\n * A Navigator is a \"location changer\"; it's how you get to different locations.\n *\n * Every history instance conforms to the Navigator interface, but the\n * distinction is useful primarily when it comes to the low-level `<Router>` API\n * where both the location and a navigator must be provided separately in order\n * to avoid \"tearing\" that may occur in a suspense-enabled app if the action\n * and/or location were to be read directly from the history instance.\n */\nexport interface Navigator {\n  createHref: History[\"createHref\"];\n  // Optional for backwards-compat with Router/HistoryRouter usage (edge case)\n  encodeLocation?: History[\"encodeLocation\"];\n  go: History[\"go\"];\n  push(to: To, state?: any, opts?: NavigateOptions): void;\n  replace(to: To, state?: any, opts?: NavigateOptions): void;\n}\n\ninterface NavigationContextObject {\n  basename: string;\n  navigator: Navigator;\n  static: boolean;\n  future: {\n    v7_relativeSplatPath: boolean;\n  };\n}\n\nexport const NavigationContext = React.createContext<NavigationContextObject>(\n  null!\n);\n\nif (__DEV__) {\n  NavigationContext.displayName = \"Navigation\";\n}\n\ninterface LocationContextObject {\n  location: Location;\n  navigationType: NavigationType;\n}\n\nexport const LocationContext = React.createContext<LocationContextObject>(\n  null!\n);\n\nif (__DEV__) {\n  LocationContext.displayName = \"Location\";\n}\n\nexport interface RouteContextObject {\n  outlet: React.ReactElement | null;\n  matches: RouteMatch[];\n  isDataRoute: boolean;\n}\n\nexport const RouteContext = React.createContext<RouteContextObject>({\n  outlet: null,\n  matches: [],\n  isDataRoute: false,\n});\n\nif (__DEV__) {\n  RouteContext.displayName = \"Route\";\n}\n\nexport const RouteErrorContext = React.createContext<any>(null);\n\nif (__DEV__) {\n  RouteErrorContext.displayName = \"RouteError\";\n}\n","import * as React from \"react\";\nimport type {\n  Blocker,\n  BlockerFunction,\n  Location,\n  ParamParseKey,\n  Params,\n  Path,\n  PathMatch,\n  PathPattern,\n  RelativeRoutingType,\n  Router as RemixRouter,\n  RevalidationState,\n  To,\n  UIMatch,\n} from \"@remix-run/router\";\nimport {\n  IDLE_BLOCKER,\n  Action as NavigationType,\n  UNSAFE_convertRouteMatchToUiMatch as convertRouteMatchToUiMatch,\n  UNSAFE_decodePath as decodePath,\n  UNSAFE_getResolveToMatches as getResolveToMatches,\n  UNSAFE_invariant as invariant,\n  isRouteErrorResponse,\n  joinPaths,\n  matchPath,\n  matchRoutes,\n  parsePath,\n  resolveTo,\n  stripBasename,\n  UNSAFE_warning as warning,\n} from \"@remix-run/router\";\n\nimport type {\n  DataRouteMatch,\n  NavigateOptions,\n  RouteContextObject,\n  RouteMatch,\n  RouteObject,\n} from \"./context\";\nimport {\n  AwaitContext,\n  DataRouterContext,\n  DataRouterStateContext,\n  LocationContext,\n  NavigationContext,\n  RouteContext,\n  RouteErrorContext,\n} from \"./context\";\n\n/**\n * Returns the full href for the given \"to\" value. This is useful for building\n * custom links that are also accessible and preserve right-click behavior.\n *\n * @see https://reactrouter.com/v6/hooks/use-href\n */\nexport function useHref(\n  to: To,\n  { relative }: { relative?: RelativeRoutingType } = {}\n): string {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useHref() may be used only in the context of a <Router> component.`\n  );\n\n  let { basename, navigator } = React.useContext(NavigationContext);\n  let { hash, pathname, search } = useResolvedPath(to, { relative });\n\n  let joinedPathname = pathname;\n\n  // If we're operating within a basename, prepend it to the pathname prior\n  // to creating the href.  If this is a root navigation, then just use the raw\n  // basename which allows the basename to have full control over the presence\n  // of a trailing slash on root links\n  if (basename !== \"/\") {\n    joinedPathname =\n      pathname === \"/\" ? basename : joinPaths([basename, pathname]);\n  }\n\n  return navigator.createHref({ pathname: joinedPathname, search, hash });\n}\n\n/**\n * Returns true if this component is a descendant of a `<Router>`.\n *\n * @see https://reactrouter.com/v6/hooks/use-in-router-context\n */\nexport function useInRouterContext(): boolean {\n  return React.useContext(LocationContext) != null;\n}\n\n/**\n * Returns the current location object, which represents the current URL in web\n * browsers.\n *\n * Note: If you're using this it may mean you're doing some of your own\n * \"routing\" in your app, and we'd like to know what your use case is. We may\n * be able to provide something higher-level to better suit your needs.\n *\n * @see https://reactrouter.com/v6/hooks/use-location\n */\nexport function useLocation(): Location {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useLocation() may be used only in the context of a <Router> component.`\n  );\n\n  return React.useContext(LocationContext).location;\n}\n\n/**\n * Returns the current navigation action which describes how the router came to\n * the current location, either by a pop, push, or replace on the history stack.\n *\n * @see https://reactrouter.com/v6/hooks/use-navigation-type\n */\nexport function useNavigationType(): NavigationType {\n  return React.useContext(LocationContext).navigationType;\n}\n\n/**\n * Returns a PathMatch object if the given pattern matches the current URL.\n * This is useful for components that need to know \"active\" state, e.g.\n * `<NavLink>`.\n *\n * @see https://reactrouter.com/v6/hooks/use-match\n */\nexport function useMatch<\n  ParamKey extends ParamParseKey<Path>,\n  Path extends string\n>(pattern: PathPattern<Path> | Path): PathMatch<ParamKey> | null {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useMatch() may be used only in the context of a <Router> component.`\n  );\n\n  let { pathname } = useLocation();\n  return React.useMemo(\n    () => matchPath<ParamKey, Path>(pattern, decodePath(pathname)),\n    [pathname, pattern]\n  );\n}\n\n/**\n * The interface for the navigate() function returned from useNavigate().\n */\nexport interface NavigateFunction {\n  (to: To, options?: NavigateOptions): void;\n  (delta: number): void;\n}\n\nconst navigateEffectWarning =\n  `You should call navigate() in a React.useEffect(), not when ` +\n  `your component is first rendered.`;\n\n// Mute warnings for calls to useNavigate in SSR environments\nfunction useIsomorphicLayoutEffect(\n  cb: Parameters<typeof React.useLayoutEffect>[0]\n) {\n  let isStatic = React.useContext(NavigationContext).static;\n  if (!isStatic) {\n    // We should be able to get rid of this once react 18.3 is released\n    // See: https://github.com/facebook/react/pull/26395\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useLayoutEffect(cb);\n  }\n}\n\n/**\n * Returns an imperative method for changing the location. Used by `<Link>`s, but\n * may also be used by other elements to change the location.\n *\n * @see https://reactrouter.com/v6/hooks/use-navigate\n */\nexport function useNavigate(): NavigateFunction {\n  let { isDataRoute } = React.useContext(RouteContext);\n  // Conditional usage is OK here because the usage of a data router is static\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  return isDataRoute ? useNavigateStable() : useNavigateUnstable();\n}\n\nfunction useNavigateUnstable(): NavigateFunction {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useNavigate() may be used only in the context of a <Router> component.`\n  );\n\n  let dataRouterContext = React.useContext(DataRouterContext);\n  let { basename, future, navigator } = React.useContext(NavigationContext);\n  let { matches } = React.useContext(RouteContext);\n  let { pathname: locationPathname } = useLocation();\n\n  let routePathnamesJson = JSON.stringify(\n    getResolveToMatches(matches, future.v7_relativeSplatPath)\n  );\n\n  let activeRef = React.useRef(false);\n  useIsomorphicLayoutEffect(() => {\n    activeRef.current = true;\n  });\n\n  let navigate: NavigateFunction = React.useCallback(\n    (to: To | number, options: NavigateOptions = {}) => {\n      warning(activeRef.current, navigateEffectWarning);\n\n      // Short circuit here since if this happens on first render the navigate\n      // is useless because we haven't wired up our history listener yet\n      if (!activeRef.current) return;\n\n      if (typeof to === \"number\") {\n        navigator.go(to);\n        return;\n      }\n\n      let path = resolveTo(\n        to,\n        JSON.parse(routePathnamesJson),\n        locationPathname,\n        options.relative === \"path\"\n      );\n\n      // If we're operating within a basename, prepend it to the pathname prior\n      // to handing off to history (but only if we're not in a data router,\n      // otherwise it'll prepend the basename inside of the router).\n      // If this is a root navigation, then we navigate to the raw basename\n      // which allows the basename to have full control over the presence of a\n      // trailing slash on root links\n      if (dataRouterContext == null && basename !== \"/\") {\n        path.pathname =\n          path.pathname === \"/\"\n            ? basename\n            : joinPaths([basename, path.pathname]);\n      }\n\n      (!!options.replace ? navigator.replace : navigator.push)(\n        path,\n        options.state,\n        options\n      );\n    },\n    [\n      basename,\n      navigator,\n      routePathnamesJson,\n      locationPathname,\n      dataRouterContext,\n    ]\n  );\n\n  return navigate;\n}\n\nconst OutletContext = React.createContext<unknown>(null);\n\n/**\n * Returns the context (if provided) for the child route at this level of the route\n * hierarchy.\n * @see https://reactrouter.com/v6/hooks/use-outlet-context\n */\nexport function useOutletContext<Context = unknown>(): Context {\n  return React.useContext(OutletContext) as Context;\n}\n\n/**\n * Returns the element for the child route at this level of the route\n * hierarchy. Used internally by `<Outlet>` to render child routes.\n *\n * @see https://reactrouter.com/v6/hooks/use-outlet\n */\nexport function useOutlet(context?: unknown): React.ReactElement | null {\n  let outlet = React.useContext(RouteContext).outlet;\n  if (outlet) {\n    return (\n      <OutletContext.Provider value={context}>{outlet}</OutletContext.Provider>\n    );\n  }\n  return outlet;\n}\n\n/**\n * Returns an object of key/value pairs of the dynamic params from the current\n * URL that were matched by the route path.\n *\n * @see https://reactrouter.com/v6/hooks/use-params\n */\nexport function useParams<\n  ParamsOrKey extends string | Record<string, string | undefined> = string\n>(): Readonly<\n  [ParamsOrKey] extends [string] ? Params<ParamsOrKey> : Partial<ParamsOrKey>\n> {\n  let { matches } = React.useContext(RouteContext);\n  let routeMatch = matches[matches.length - 1];\n  return routeMatch ? (routeMatch.params as any) : {};\n}\n\n/**\n * Resolves the pathname of the given `to` value against the current location.\n *\n * @see https://reactrouter.com/v6/hooks/use-resolved-path\n */\nexport function useResolvedPath(\n  to: To,\n  { relative }: { relative?: RelativeRoutingType } = {}\n): Path {\n  let { future } = React.useContext(NavigationContext);\n  let { matches } = React.useContext(RouteContext);\n  let { pathname: locationPathname } = useLocation();\n  let routePathnamesJson = JSON.stringify(\n    getResolveToMatches(matches, future.v7_relativeSplatPath)\n  );\n\n  return React.useMemo(\n    () =>\n      resolveTo(\n        to,\n        JSON.parse(routePathnamesJson),\n        locationPathname,\n        relative === \"path\"\n      ),\n    [to, routePathnamesJson, locationPathname, relative]\n  );\n}\n\n/**\n * Returns the element of the route that matched the current location, prepared\n * with the correct context to render the remainder of the route tree. Route\n * elements in the tree must render an `<Outlet>` to render their child route's\n * element.\n *\n * @see https://reactrouter.com/v6/hooks/use-routes\n */\nexport function useRoutes(\n  routes: RouteObject[],\n  locationArg?: Partial<Location> | string\n): React.ReactElement | null {\n  return useRoutesImpl(routes, locationArg);\n}\n\n// Internal implementation with accept optional param for RouterProvider usage\nexport function useRoutesImpl(\n  routes: RouteObject[],\n  locationArg?: Partial<Location> | string,\n  dataRouterState?: RemixRouter[\"state\"],\n  future?: RemixRouter[\"future\"]\n): React.ReactElement | null {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useRoutes() may be used only in the context of a <Router> component.`\n  );\n\n  let { navigator } = React.useContext(NavigationContext);\n  let { matches: parentMatches } = React.useContext(RouteContext);\n  let routeMatch = parentMatches[parentMatches.length - 1];\n  let parentParams = routeMatch ? routeMatch.params : {};\n  let parentPathname = routeMatch ? routeMatch.pathname : \"/\";\n  let parentPathnameBase = routeMatch ? routeMatch.pathnameBase : \"/\";\n  let parentRoute = routeMatch && routeMatch.route;\n\n  if (__DEV__) {\n    // You won't get a warning about 2 different <Routes> under a <Route>\n    // without a trailing *, but this is a best-effort warning anyway since we\n    // cannot even give the warning unless they land at the parent route.\n    //\n    // Example:\n    //\n    // <Routes>\n    //   {/* This route path MUST end with /* because otherwise\n    //       it will never match /blog/post/123 */}\n    //   <Route path=\"blog\" element={<Blog />} />\n    //   <Route path=\"blog/feed\" element={<BlogFeed />} />\n    // </Routes>\n    //\n    // function Blog() {\n    //   return (\n    //     <Routes>\n    //       <Route path=\"post/:id\" element={<Post />} />\n    //     </Routes>\n    //   );\n    // }\n    let parentPath = (parentRoute && parentRoute.path) || \"\";\n    warningOnce(\n      parentPathname,\n      !parentRoute || parentPath.endsWith(\"*\"),\n      `You rendered descendant <Routes> (or called \\`useRoutes()\\`) at ` +\n        `\"${parentPathname}\" (under <Route path=\"${parentPath}\">) but the ` +\n        `parent route path has no trailing \"*\". This means if you navigate ` +\n        `deeper, the parent won't match anymore and therefore the child ` +\n        `routes will never render.\\n\\n` +\n        `Please change the parent <Route path=\"${parentPath}\"> to <Route ` +\n        `path=\"${parentPath === \"/\" ? \"*\" : `${parentPath}/*`}\">.`\n    );\n  }\n\n  let locationFromContext = useLocation();\n\n  let location;\n  if (locationArg) {\n    let parsedLocationArg =\n      typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n\n    invariant(\n      parentPathnameBase === \"/\" ||\n        parsedLocationArg.pathname?.startsWith(parentPathnameBase),\n      `When overriding the location using \\`<Routes location>\\` or \\`useRoutes(routes, location)\\`, ` +\n        `the location pathname must begin with the portion of the URL pathname that was ` +\n        `matched by all parent routes. The current pathname base is \"${parentPathnameBase}\" ` +\n        `but pathname \"${parsedLocationArg.pathname}\" was given in the \\`location\\` prop.`\n    );\n\n    location = parsedLocationArg;\n  } else {\n    location = locationFromContext;\n  }\n\n  let pathname = location.pathname || \"/\";\n\n  let remainingPathname = pathname;\n  if (parentPathnameBase !== \"/\") {\n    // Determine the remaining pathname by removing the # of URL segments the\n    // parentPathnameBase has, instead of removing based on character count.\n    // This is because we can't guarantee that incoming/outgoing encodings/\n    // decodings will match exactly.\n    // We decode paths before matching on a per-segment basis with\n    // decodeURIComponent(), but we re-encode pathnames via `new URL()` so they\n    // match what `window.location.pathname` would reflect.  Those don't 100%\n    // align when it comes to encoded URI characters such as % and &.\n    //\n    // So we may end up with:\n    //   pathname:           \"/descendant/a%25b/match\"\n    //   parentPathnameBase: \"/descendant/a%b\"\n    //\n    // And the direct substring removal approach won't work :/\n    let parentSegments = parentPathnameBase.replace(/^\\//, \"\").split(\"/\");\n    let segments = pathname.replace(/^\\//, \"\").split(\"/\");\n    remainingPathname = \"/\" + segments.slice(parentSegments.length).join(\"/\");\n  }\n\n  let matches = matchRoutes(routes, { pathname: remainingPathname });\n\n  if (__DEV__) {\n    warning(\n      parentRoute || matches != null,\n      `No routes matched location \"${location.pathname}${location.search}${location.hash}\" `\n    );\n\n    warning(\n      matches == null ||\n        matches[matches.length - 1].route.element !== undefined ||\n        matches[matches.length - 1].route.Component !== undefined ||\n        matches[matches.length - 1].route.lazy !== undefined,\n      `Matched leaf route at location \"${location.pathname}${location.search}${location.hash}\" ` +\n        `does not have an element or Component. This means it will render an <Outlet /> with a ` +\n        `null value by default resulting in an \"empty\" page.`\n    );\n  }\n\n  let renderedMatches = _renderMatches(\n    matches &&\n      matches.map((match) =>\n        Object.assign({}, match, {\n          params: Object.assign({}, parentParams, match.params),\n          pathname: joinPaths([\n            parentPathnameBase,\n            // Re-encode pathnames that were decoded inside matchRoutes\n            navigator.encodeLocation\n              ? navigator.encodeLocation(match.pathname).pathname\n              : match.pathname,\n          ]),\n          pathnameBase:\n            match.pathnameBase === \"/\"\n              ? parentPathnameBase\n              : joinPaths([\n                  parentPathnameBase,\n                  // Re-encode pathnames that were decoded inside matchRoutes\n                  navigator.encodeLocation\n                    ? navigator.encodeLocation(match.pathnameBase).pathname\n                    : match.pathnameBase,\n                ]),\n        })\n      ),\n    parentMatches,\n    dataRouterState,\n    future\n  );\n\n  // When a user passes in a `locationArg`, the associated routes need to\n  // be wrapped in a new `LocationContext.Provider` in order for `useLocation`\n  // to use the scoped location instead of the global location.\n  if (locationArg && renderedMatches) {\n    return (\n      <LocationContext.Provider\n        value={{\n          location: {\n            pathname: \"/\",\n            search: \"\",\n            hash: \"\",\n            state: null,\n            key: \"default\",\n            ...location,\n          },\n          navigationType: NavigationType.Pop,\n        }}\n      >\n        {renderedMatches}\n      </LocationContext.Provider>\n    );\n  }\n\n  return renderedMatches;\n}\n\nfunction DefaultErrorComponent() {\n  let error = useRouteError();\n  let message = isRouteErrorResponse(error)\n    ? `${error.status} ${error.statusText}`\n    : error instanceof Error\n    ? error.message\n    : JSON.stringify(error);\n  let stack = error instanceof Error ? error.stack : null;\n  let lightgrey = \"rgba(200,200,200, 0.5)\";\n  let preStyles = { padding: \"0.5rem\", backgroundColor: lightgrey };\n  let codeStyles = { padding: \"2px 4px\", backgroundColor: lightgrey };\n\n  let devInfo = null;\n  if (__DEV__) {\n    console.error(\n      \"Error handled by React Router default ErrorBoundary:\",\n      error\n    );\n\n    devInfo = (\n      <>\n        <p>💿 Hey developer 👋</p>\n        <p>\n          You can provide a way better UX than this when your app throws errors\n          by providing your own <code style={codeStyles}>ErrorBoundary</code> or{\" \"}\n          <code style={codeStyles}>errorElement</code> prop on your route.\n        </p>\n      </>\n    );\n  }\n\n  return (\n    <>\n      <h2>Unexpected Application Error!</h2>\n      <h3 style={{ fontStyle: \"italic\" }}>{message}</h3>\n      {stack ? <pre style={preStyles}>{stack}</pre> : null}\n      {devInfo}\n    </>\n  );\n}\n\nconst defaultErrorElement = <DefaultErrorComponent />;\n\ntype RenderErrorBoundaryProps = React.PropsWithChildren<{\n  location: Location;\n  revalidation: RevalidationState;\n  error: any;\n  component: React.ReactNode;\n  routeContext: RouteContextObject;\n}>;\n\ntype RenderErrorBoundaryState = {\n  location: Location;\n  revalidation: RevalidationState;\n  error: any;\n};\n\nexport class RenderErrorBoundary extends React.Component<\n  RenderErrorBoundaryProps,\n  RenderErrorBoundaryState\n> {\n  constructor(props: RenderErrorBoundaryProps) {\n    super(props);\n    this.state = {\n      location: props.location,\n      revalidation: props.revalidation,\n      error: props.error,\n    };\n  }\n\n  static getDerivedStateFromError(error: any) {\n    return { error: error };\n  }\n\n  static getDerivedStateFromProps(\n    props: RenderErrorBoundaryProps,\n    state: RenderErrorBoundaryState\n  ) {\n    // When we get into an error state, the user will likely click \"back\" to the\n    // previous page that didn't have an error. Because this wraps the entire\n    // application, that will have no effect--the error page continues to display.\n    // This gives us a mechanism to recover from the error when the location changes.\n    //\n    // Whether we're in an error state or not, we update the location in state\n    // so that when we are in an error state, it gets reset when a new location\n    // comes in and the user recovers from the error.\n    if (\n      state.location !== props.location ||\n      (state.revalidation !== \"idle\" && props.revalidation === \"idle\")\n    ) {\n      return {\n        error: props.error,\n        location: props.location,\n        revalidation: props.revalidation,\n      };\n    }\n\n    // If we're not changing locations, preserve the location but still surface\n    // any new errors that may come through. We retain the existing error, we do\n    // this because the error provided from the app state may be cleared without\n    // the location changing.\n    return {\n      error: props.error !== undefined ? props.error : state.error,\n      location: state.location,\n      revalidation: props.revalidation || state.revalidation,\n    };\n  }\n\n  componentDidCatch(error: any, errorInfo: any) {\n    console.error(\n      \"React Router caught the following error during render\",\n      error,\n      errorInfo\n    );\n  }\n\n  render() {\n    return this.state.error !== undefined ? (\n      <RouteContext.Provider value={this.props.routeContext}>\n        <RouteErrorContext.Provider\n          value={this.state.error}\n          children={this.props.component}\n        />\n      </RouteContext.Provider>\n    ) : (\n      this.props.children\n    );\n  }\n}\n\ninterface RenderedRouteProps {\n  routeContext: RouteContextObject;\n  match: RouteMatch<string, RouteObject>;\n  children: React.ReactNode | null;\n}\n\nfunction RenderedRoute({ routeContext, match, children }: RenderedRouteProps) {\n  let dataRouterContext = React.useContext(DataRouterContext);\n\n  // Track how deep we got in our render pass to emulate SSR componentDidCatch\n  // in a DataStaticRouter\n  if (\n    dataRouterContext &&\n    dataRouterContext.static &&\n    dataRouterContext.staticContext &&\n    (match.route.errorElement || match.route.ErrorBoundary)\n  ) {\n    dataRouterContext.staticContext._deepestRenderedBoundaryId = match.route.id;\n  }\n\n  return (\n    <RouteContext.Provider value={routeContext}>\n      {children}\n    </RouteContext.Provider>\n  );\n}\n\nexport function _renderMatches(\n  matches: RouteMatch[] | null,\n  parentMatches: RouteMatch[] = [],\n  dataRouterState: RemixRouter[\"state\"] | null = null,\n  future: RemixRouter[\"future\"] | null = null\n): React.ReactElement | null {\n  if (matches == null) {\n    if (!dataRouterState) {\n      return null;\n    }\n\n    if (dataRouterState.errors) {\n      // Don't bail if we have data router errors so we can render them in the\n      // boundary.  Use the pre-matched (or shimmed) matches\n      matches = dataRouterState.matches as DataRouteMatch[];\n    } else if (\n      future?.v7_partialHydration &&\n      parentMatches.length === 0 &&\n      !dataRouterState.initialized &&\n      dataRouterState.matches.length > 0\n    ) {\n      // Don't bail if we're initializing with partial hydration and we have\n      // router matches.  That means we're actively running `patchRoutesOnNavigation`\n      // so we should render down the partial matches to the appropriate\n      // `HydrateFallback`.  We only do this if `parentMatches` is empty so it\n      // only impacts the root matches for `RouterProvider` and no descendant\n      // `<Routes>`\n      matches = dataRouterState.matches as DataRouteMatch[];\n    } else {\n      return null;\n    }\n  }\n\n  let renderedMatches = matches;\n\n  // If we have data errors, trim matches to the highest error boundary\n  let errors = dataRouterState?.errors;\n  if (errors != null) {\n    let errorIndex = renderedMatches.findIndex(\n      (m) => m.route.id && errors?.[m.route.id] !== undefined\n    );\n    invariant(\n      errorIndex >= 0,\n      `Could not find a matching route for errors on route IDs: ${Object.keys(\n        errors\n      ).join(\",\")}`\n    );\n    renderedMatches = renderedMatches.slice(\n      0,\n      Math.min(renderedMatches.length, errorIndex + 1)\n    );\n  }\n\n  // If we're in a partial hydration mode, detect if we need to render down to\n  // a given HydrateFallback while we load the rest of the hydration data\n  let renderFallback = false;\n  let fallbackIndex = -1;\n  if (dataRouterState && future && future.v7_partialHydration) {\n    for (let i = 0; i < renderedMatches.length; i++) {\n      let match = renderedMatches[i];\n      // Track the deepest fallback up until the first route without data\n      if (match.route.HydrateFallback || match.route.hydrateFallbackElement) {\n        fallbackIndex = i;\n      }\n\n      if (match.route.id) {\n        let { loaderData, errors } = dataRouterState;\n        let needsToRunLoader =\n          match.route.loader &&\n          loaderData[match.route.id] === undefined &&\n          (!errors || errors[match.route.id] === undefined);\n        if (match.route.lazy || needsToRunLoader) {\n          // We found the first route that's not ready to render (waiting on\n          // lazy, or has a loader that hasn't run yet).  Flag that we need to\n          // render a fallback and render up until the appropriate fallback\n          renderFallback = true;\n          if (fallbackIndex >= 0) {\n            renderedMatches = renderedMatches.slice(0, fallbackIndex + 1);\n          } else {\n            renderedMatches = [renderedMatches[0]];\n          }\n          break;\n        }\n      }\n    }\n  }\n\n  return renderedMatches.reduceRight((outlet, match, index) => {\n    // Only data routers handle errors/fallbacks\n    let error: any;\n    let shouldRenderHydrateFallback = false;\n    let errorElement: React.ReactNode | null = null;\n    let hydrateFallbackElement: React.ReactNode | null = null;\n    if (dataRouterState) {\n      error = errors && match.route.id ? errors[match.route.id] : undefined;\n      errorElement = match.route.errorElement || defaultErrorElement;\n\n      if (renderFallback) {\n        if (fallbackIndex < 0 && index === 0) {\n          warningOnce(\n            \"route-fallback\",\n            false,\n            \"No `HydrateFallback` element provided to render during initial hydration\"\n          );\n          shouldRenderHydrateFallback = true;\n          hydrateFallbackElement = null;\n        } else if (fallbackIndex === index) {\n          shouldRenderHydrateFallback = true;\n          hydrateFallbackElement = match.route.hydrateFallbackElement || null;\n        }\n      }\n    }\n\n    let matches = parentMatches.concat(renderedMatches.slice(0, index + 1));\n    let getChildren = () => {\n      let children: React.ReactNode;\n      if (error) {\n        children = errorElement;\n      } else if (shouldRenderHydrateFallback) {\n        children = hydrateFallbackElement;\n      } else if (match.route.Component) {\n        // Note: This is a de-optimized path since React won't re-use the\n        // ReactElement since it's identity changes with each new\n        // React.createElement call.  We keep this so folks can use\n        // `<Route Component={...}>` in `<Routes>` but generally `Component`\n        // usage is only advised in `RouterProvider` when we can convert it to\n        // `element` ahead of time.\n        children = <match.route.Component />;\n      } else if (match.route.element) {\n        children = match.route.element;\n      } else {\n        children = outlet;\n      }\n      return (\n        <RenderedRoute\n          match={match}\n          routeContext={{\n            outlet,\n            matches,\n            isDataRoute: dataRouterState != null,\n          }}\n          children={children}\n        />\n      );\n    };\n    // Only wrap in an error boundary within data router usages when we have an\n    // ErrorBoundary/errorElement on this route.  Otherwise let it bubble up to\n    // an ancestor ErrorBoundary/errorElement\n    return dataRouterState &&\n      (match.route.ErrorBoundary || match.route.errorElement || index === 0) ? (\n      <RenderErrorBoundary\n        location={dataRouterState.location}\n        revalidation={dataRouterState.revalidation}\n        component={errorElement}\n        error={error}\n        children={getChildren()}\n        routeContext={{ outlet: null, matches, isDataRoute: true }}\n      />\n    ) : (\n      getChildren()\n    );\n  }, null as React.ReactElement | null);\n}\n\nenum DataRouterHook {\n  UseBlocker = \"useBlocker\",\n  UseRevalidator = \"useRevalidator\",\n  UseNavigateStable = \"useNavigate\",\n}\n\nenum DataRouterStateHook {\n  UseBlocker = \"useBlocker\",\n  UseLoaderData = \"useLoaderData\",\n  UseActionData = \"useActionData\",\n  UseRouteError = \"useRouteError\",\n  UseNavigation = \"useNavigation\",\n  UseRouteLoaderData = \"useRouteLoaderData\",\n  UseMatches = \"useMatches\",\n  UseRevalidator = \"useRevalidator\",\n  UseNavigateStable = \"useNavigate\",\n  UseRouteId = \"useRouteId\",\n}\n\nfunction getDataRouterConsoleError(\n  hookName: DataRouterHook | DataRouterStateHook\n) {\n  return `${hookName} must be used within a data router.  See https://reactrouter.com/v6/routers/picking-a-router.`;\n}\n\nfunction useDataRouterContext(hookName: DataRouterHook) {\n  let ctx = React.useContext(DataRouterContext);\n  invariant(ctx, getDataRouterConsoleError(hookName));\n  return ctx;\n}\n\nfunction useDataRouterState(hookName: DataRouterStateHook) {\n  let state = React.useContext(DataRouterStateContext);\n  invariant(state, getDataRouterConsoleError(hookName));\n  return state;\n}\n\nfunction useRouteContext(hookName: DataRouterStateHook) {\n  let route = React.useContext(RouteContext);\n  invariant(route, getDataRouterConsoleError(hookName));\n  return route;\n}\n\n// Internal version with hookName-aware debugging\nfunction useCurrentRouteId(hookName: DataRouterStateHook) {\n  let route = useRouteContext(hookName);\n  let thisRoute = route.matches[route.matches.length - 1];\n  invariant(\n    thisRoute.route.id,\n    `${hookName} can only be used on routes that contain a unique \"id\"`\n  );\n  return thisRoute.route.id;\n}\n\n/**\n * Returns the ID for the nearest contextual route\n */\nexport function useRouteId() {\n  return useCurrentRouteId(DataRouterStateHook.UseRouteId);\n}\n\n/**\n * Returns the current navigation, defaulting to an \"idle\" navigation when\n * no navigation is in progress\n */\nexport function useNavigation() {\n  let state = useDataRouterState(DataRouterStateHook.UseNavigation);\n  return state.navigation;\n}\n\n/**\n * Returns a revalidate function for manually triggering revalidation, as well\n * as the current state of any manual revalidations\n */\nexport function useRevalidator() {\n  let dataRouterContext = useDataRouterContext(DataRouterHook.UseRevalidator);\n  let state = useDataRouterState(DataRouterStateHook.UseRevalidator);\n  return React.useMemo(\n    () => ({\n      revalidate: dataRouterContext.router.revalidate,\n      state: state.revalidation,\n    }),\n    [dataRouterContext.router.revalidate, state.revalidation]\n  );\n}\n\n/**\n * Returns the active route matches, useful for accessing loaderData for\n * parent/child routes or the route \"handle\" property\n */\nexport function useMatches(): UIMatch[] {\n  let { matches, loaderData } = useDataRouterState(\n    DataRouterStateHook.UseMatches\n  );\n  return React.useMemo(\n    () => matches.map((m) => convertRouteMatchToUiMatch(m, loaderData)),\n    [matches, loaderData]\n  );\n}\n\n/**\n * Returns the loader data for the nearest ancestor Route loader\n */\nexport function useLoaderData(): unknown {\n  let state = useDataRouterState(DataRouterStateHook.UseLoaderData);\n  let routeId = useCurrentRouteId(DataRouterStateHook.UseLoaderData);\n\n  if (state.errors && state.errors[routeId] != null) {\n    console.error(\n      `You cannot \\`useLoaderData\\` in an errorElement (routeId: ${routeId})`\n    );\n    return undefined;\n  }\n  return state.loaderData[routeId];\n}\n\n/**\n * Returns the loaderData for the given routeId\n */\nexport function useRouteLoaderData(routeId: string): unknown {\n  let state = useDataRouterState(DataRouterStateHook.UseRouteLoaderData);\n  return state.loaderData[routeId];\n}\n\n/**\n * Returns the action data for the nearest ancestor Route action\n */\nexport function useActionData(): unknown {\n  let state = useDataRouterState(DataRouterStateHook.UseActionData);\n  let routeId = useCurrentRouteId(DataRouterStateHook.UseLoaderData);\n  return state.actionData ? state.actionData[routeId] : undefined;\n}\n\n/**\n * Returns the nearest ancestor Route error, which could be a loader/action\n * error or a render error.  This is intended to be called from your\n * ErrorBoundary/errorElement to display a proper error message.\n */\nexport function useRouteError(): unknown {\n  let error = React.useContext(RouteErrorContext);\n  let state = useDataRouterState(DataRouterStateHook.UseRouteError);\n  let routeId = useCurrentRouteId(DataRouterStateHook.UseRouteError);\n\n  // If this was a render error, we put it in a RouteError context inside\n  // of RenderErrorBoundary\n  if (error !== undefined) {\n    return error;\n  }\n\n  // Otherwise look for errors from our data router state\n  return state.errors?.[routeId];\n}\n\n/**\n * Returns the happy-path data from the nearest ancestor `<Await />` value\n */\nexport function useAsyncValue(): unknown {\n  let value = React.useContext(AwaitContext);\n  return value?._data;\n}\n\n/**\n * Returns the error from the nearest ancestor `<Await />` value\n */\nexport function useAsyncError(): unknown {\n  let value = React.useContext(AwaitContext);\n  return value?._error;\n}\n\nlet blockerId = 0;\n\n/**\n * Allow the application to block navigations within the SPA and present the\n * user a confirmation dialog to confirm the navigation.  Mostly used to avoid\n * using half-filled form data.  This does not handle hard-reloads or\n * cross-origin navigations.\n */\nexport function useBlocker(shouldBlock: boolean | BlockerFunction): Blocker {\n  let { router, basename } = useDataRouterContext(DataRouterHook.UseBlocker);\n  let state = useDataRouterState(DataRouterStateHook.UseBlocker);\n\n  let [blockerKey, setBlockerKey] = React.useState(\"\");\n  let blockerFunction = React.useCallback<BlockerFunction>(\n    (arg) => {\n      if (typeof shouldBlock !== \"function\") {\n        return !!shouldBlock;\n      }\n      if (basename === \"/\") {\n        return shouldBlock(arg);\n      }\n\n      // If they provided us a function and we've got an active basename, strip\n      // it from the locations we expose to the user to match the behavior of\n      // useLocation\n      let { currentLocation, nextLocation, historyAction } = arg;\n      return shouldBlock({\n        currentLocation: {\n          ...currentLocation,\n          pathname:\n            stripBasename(currentLocation.pathname, basename) ||\n            currentLocation.pathname,\n        },\n        nextLocation: {\n          ...nextLocation,\n          pathname:\n            stripBasename(nextLocation.pathname, basename) ||\n            nextLocation.pathname,\n        },\n        historyAction,\n      });\n    },\n    [basename, shouldBlock]\n  );\n\n  // This effect is in charge of blocker key assignment and deletion (which is\n  // tightly coupled to the key)\n  React.useEffect(() => {\n    let key = String(++blockerId);\n    setBlockerKey(key);\n    return () => router.deleteBlocker(key);\n  }, [router]);\n\n  // This effect handles assigning the blockerFunction.  This is to handle\n  // unstable blocker function identities, and happens only after the prior\n  // effect so we don't get an orphaned blockerFunction in the router with a\n  // key of \"\".  Until then we just have the IDLE_BLOCKER.\n  React.useEffect(() => {\n    if (blockerKey !== \"\") {\n      router.getBlocker(blockerKey, blockerFunction);\n    }\n  }, [router, blockerKey, blockerFunction]);\n\n  // Prefer the blocker from `state` not `router.state` since DataRouterContext\n  // is memoized so this ensures we update on blocker state updates\n  return blockerKey && state.blockers.has(blockerKey)\n    ? state.blockers.get(blockerKey)!\n    : IDLE_BLOCKER;\n}\n\n/**\n * Stable version of useNavigate that is used when we are in the context of\n * a RouterProvider.\n */\nfunction useNavigateStable(): NavigateFunction {\n  let { router } = useDataRouterContext(DataRouterHook.UseNavigateStable);\n  let id = useCurrentRouteId(DataRouterStateHook.UseNavigateStable);\n\n  let activeRef = React.useRef(false);\n  useIsomorphicLayoutEffect(() => {\n    activeRef.current = true;\n  });\n\n  let navigate: NavigateFunction = React.useCallback(\n    (to: To | number, options: NavigateOptions = {}) => {\n      warning(activeRef.current, navigateEffectWarning);\n\n      // Short circuit here since if this happens on first render the navigate\n      // is useless because we haven't wired up our router subscriber yet\n      if (!activeRef.current) return;\n\n      if (typeof to === \"number\") {\n        router.navigate(to);\n      } else {\n        router.navigate(to, { fromRouteId: id, ...options });\n      }\n    },\n    [router, id]\n  );\n\n  return navigate;\n}\n\nconst alreadyWarned: Record<string, boolean> = {};\n\nfunction warningOnce(key: string, cond: boolean, message: string) {\n  if (!cond && !alreadyWarned[key]) {\n    alreadyWarned[key] = true;\n    warning(false, message);\n  }\n}\n","import type { FutureConfig as RouterFutureConfig } from \"@remix-run/router\";\nimport type { FutureConfig as RenderFutureConfig } from \"./components\";\n\nconst alreadyWarned: { [key: string]: boolean } = {};\n\nexport function warnOnce(key: string, message: string): void {\n  if (!alreadyWarned[message]) {\n    alreadyWarned[message] = true;\n    console.warn(message);\n  }\n}\n\nconst logDeprecation = (flag: string, msg: string, link: string) =>\n  warnOnce(\n    flag,\n    `⚠️ React Router Future Flag Warning: ${msg}. ` +\n      `You can use the \\`${flag}\\` future flag to opt-in early. ` +\n      `For more information, see ${link}.`\n  );\n\nexport function logV6DeprecationWarnings(\n  renderFuture: Partial<RenderFutureConfig> | undefined,\n  routerFuture?: Omit<RouterFutureConfig, \"v7_prependBasename\">\n) {\n  if (!renderFuture?.v7_startTransition) {\n    logDeprecation(\n      \"v7_startTransition\",\n      \"React Router will begin wrapping state updates in `React.startTransition` in v7\",\n      \"https://reactrouter.com/v6/upgrading/future#v7_starttransition\"\n    );\n  }\n\n  if (\n    !renderFuture?.v7_relativeSplatPath &&\n    (!routerFuture || !routerFuture.v7_relativeSplatPath)\n  ) {\n    logDeprecation(\n      \"v7_relativeSplatPath\",\n      \"Relative route resolution within Splat routes is changing in v7\",\n      \"https://reactrouter.com/v6/upgrading/future#v7_relativesplatpath\"\n    );\n  }\n\n  if (routerFuture) {\n    if (!routerFuture.v7_fetcherPersist) {\n      logDeprecation(\n        \"v7_fetcherPersist\",\n        \"The persistence behavior of fetchers is changing in v7\",\n        \"https://reactrouter.com/v6/upgrading/future#v7_fetcherpersist\"\n      );\n    }\n\n    if (!routerFuture.v7_normalizeFormMethod) {\n      logDeprecation(\n        \"v7_normalizeFormMethod\",\n        \"Casing of `formMethod` fields is being normalized to uppercase in v7\",\n        \"https://reactrouter.com/v6/upgrading/future#v7_normalizeformmethod\"\n      );\n    }\n\n    if (!routerFuture.v7_partialHydration) {\n      logDeprecation(\n        \"v7_partialHydration\",\n        \"`RouterProvider` hydration behavior is changing in v7\",\n        \"https://reactrouter.com/v6/upgrading/future#v7_partialhydration\"\n      );\n    }\n\n    if (!routerFuture.v7_skipActionErrorRevalidation) {\n      logDeprecation(\n        \"v7_skipActionErrorRevalidation\",\n        \"The revalidation behavior after 4xx/5xx `action` responses is changing in v7\",\n        \"https://reactrouter.com/v6/upgrading/future#v7_skipactionerrorrevalidation\"\n      );\n    }\n  }\n}\n","import type {\n  InitialEntry,\n  LazyRouteFunction,\n  Location,\n  MemoryHistory,\n  RelativeRoutingType,\n  Router as RemixRouter,\n  RouterState,\n  RouterSubscriber,\n  To,\n  TrackedPromise,\n} from \"@remix-run/router\";\nimport {\n  AbortedDeferredError,\n  Action as NavigationType,\n  createMemoryHistory,\n  UNSAFE_getResolveToMatches as getResolveToMatches,\n  UNSAFE_invariant as invariant,\n  parsePath,\n  resolveTo,\n  stripBasename,\n  UNSAFE_warning as warning,\n} from \"@remix-run/router\";\nimport * as React from \"react\";\n\nimport type {\n  DataRouteObject,\n  IndexRouteObject,\n  Navigator,\n  NonIndexRouteObject,\n  RouteMatch,\n  RouteObject,\n} from \"./context\";\nimport {\n  AwaitContext,\n  DataRouterContext,\n  DataRouterStateContext,\n  LocationContext,\n  NavigationContext,\n  RouteContext,\n} from \"./context\";\nimport {\n  _renderMatches,\n  useAsyncValue,\n  useInRouterContext,\n  useLocation,\n  useNavigate,\n  useOutlet,\n  useRoutes,\n  useRoutesImpl,\n} from \"./hooks\";\nimport { logV6DeprecationWarnings } from \"./deprecations\";\n\nexport interface FutureConfig {\n  v7_relativeSplatPath: boolean;\n  v7_startTransition: boolean;\n}\n\nexport interface RouterProviderProps {\n  fallbackElement?: React.ReactNode;\n  router: RemixRouter;\n  // Only accept future flags relevant to rendering behavior\n  // routing flags should be accessed via router.future\n  future?: Partial<Pick<FutureConfig, \"v7_startTransition\">>;\n}\n\n/**\n  Webpack + React 17 fails to compile on any of the following because webpack\n  complains that `startTransition` doesn't exist in `React`:\n  * import { startTransition } from \"react\"\n  * import * as React from from \"react\";\n    \"startTransition\" in React ? React.startTransition(() => setState()) : setState()\n  * import * as React from from \"react\";\n    \"startTransition\" in React ? React[\"startTransition\"](() => setState()) : setState()\n\n  Moving it to a constant such as the following solves the Webpack/React 17 issue:\n  * import * as React from from \"react\";\n    const START_TRANSITION = \"startTransition\";\n    START_TRANSITION in React ? React[START_TRANSITION](() => setState()) : setState()\n\n  However, that introduces webpack/terser minification issues in production builds\n  in React 18 where minification/obfuscation ends up removing the call of\n  React.startTransition entirely from the first half of the ternary.  Grabbing\n  this exported reference once up front resolves that issue.\n\n  See https://github.com/remix-run/react-router/issues/10579\n*/\nconst START_TRANSITION = \"startTransition\";\nconst startTransitionImpl = React[START_TRANSITION];\n\n/**\n * Given a Remix Router instance, render the appropriate UI\n */\nexport function RouterProvider({\n  fallbackElement,\n  router,\n  future,\n}: RouterProviderProps): React.ReactElement {\n  let [state, setStateImpl] = React.useState(router.state);\n  let { v7_startTransition } = future || {};\n\n  let setState = React.useCallback<RouterSubscriber>(\n    (newState: RouterState) => {\n      if (v7_startTransition && startTransitionImpl) {\n        startTransitionImpl(() => setStateImpl(newState));\n      } else {\n        setStateImpl(newState);\n      }\n    },\n    [setStateImpl, v7_startTransition]\n  );\n\n  // Need to use a layout effect here so we are subscribed early enough to\n  // pick up on any render-driven redirects/navigations (useEffect/<Navigate>)\n  React.useLayoutEffect(() => router.subscribe(setState), [router, setState]);\n\n  React.useEffect(() => {\n    warning(\n      fallbackElement == null || !router.future.v7_partialHydration,\n      \"`<RouterProvider fallbackElement>` is deprecated when using \" +\n        \"`v7_partialHydration`, use a `HydrateFallback` component instead\"\n    );\n    // Only log this once on initial mount\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  let navigator = React.useMemo((): Navigator => {\n    return {\n      createHref: router.createHref,\n      encodeLocation: router.encodeLocation,\n      go: (n) => router.navigate(n),\n      push: (to, state, opts) =>\n        router.navigate(to, {\n          state,\n          preventScrollReset: opts?.preventScrollReset,\n        }),\n      replace: (to, state, opts) =>\n        router.navigate(to, {\n          replace: true,\n          state,\n          preventScrollReset: opts?.preventScrollReset,\n        }),\n    };\n  }, [router]);\n\n  let basename = router.basename || \"/\";\n\n  let dataRouterContext = React.useMemo(\n    () => ({\n      router,\n      navigator,\n      static: false,\n      basename,\n    }),\n    [router, navigator, basename]\n  );\n\n  React.useEffect(\n    () => logV6DeprecationWarnings(future, router.future),\n    [router, future]\n  );\n\n  // The fragment and {null} here are important!  We need them to keep React 18's\n  // useId happy when we are server-rendering since we may have a <script> here\n  // containing the hydrated server-side staticContext (from StaticRouterProvider).\n  // useId relies on the component tree structure to generate deterministic id's\n  // so we need to ensure it remains the same on the client even though\n  // we don't need the <script> tag\n  return (\n    <>\n      <DataRouterContext.Provider value={dataRouterContext}>\n        <DataRouterStateContext.Provider value={state}>\n          <Router\n            basename={basename}\n            location={state.location}\n            navigationType={state.historyAction}\n            navigator={navigator}\n            future={{\n              v7_relativeSplatPath: router.future.v7_relativeSplatPath,\n            }}\n          >\n            {state.initialized || router.future.v7_partialHydration ? (\n              <DataRoutes\n                routes={router.routes}\n                future={router.future}\n                state={state}\n              />\n            ) : (\n              fallbackElement\n            )}\n          </Router>\n        </DataRouterStateContext.Provider>\n      </DataRouterContext.Provider>\n      {null}\n    </>\n  );\n}\n\nfunction DataRoutes({\n  routes,\n  future,\n  state,\n}: {\n  routes: DataRouteObject[];\n  future: RemixRouter[\"future\"];\n  state: RouterState;\n}): React.ReactElement | null {\n  return useRoutesImpl(routes, undefined, state, future);\n}\n\nexport interface MemoryRouterProps {\n  basename?: string;\n  children?: React.ReactNode;\n  initialEntries?: InitialEntry[];\n  initialIndex?: number;\n  future?: Partial<FutureConfig>;\n}\n\n/**\n * A `<Router>` that stores all entries in memory.\n *\n * @see https://reactrouter.com/v6/router-components/memory-router\n */\nexport function MemoryRouter({\n  basename,\n  children,\n  initialEntries,\n  initialIndex,\n  future,\n}: MemoryRouterProps): React.ReactElement {\n  let historyRef = React.useRef<MemoryHistory>();\n  if (historyRef.current == null) {\n    historyRef.current = createMemoryHistory({\n      initialEntries,\n      initialIndex,\n      v5Compat: true,\n    });\n  }\n\n  let history = historyRef.current;\n  let [state, setStateImpl] = React.useState({\n    action: history.action,\n    location: history.location,\n  });\n  let { v7_startTransition } = future || {};\n  let setState = React.useCallback(\n    (newState: { action: NavigationType; location: Location }) => {\n      v7_startTransition && startTransitionImpl\n        ? startTransitionImpl(() => setStateImpl(newState))\n        : setStateImpl(newState);\n    },\n    [setStateImpl, v7_startTransition]\n  );\n\n  React.useLayoutEffect(() => history.listen(setState), [history, setState]);\n\n  React.useEffect(() => logV6DeprecationWarnings(future), [future]);\n\n  return (\n    <Router\n      basename={basename}\n      children={children}\n      location={state.location}\n      navigationType={state.action}\n      navigator={history}\n      future={future}\n    />\n  );\n}\n\nexport interface NavigateProps {\n  to: To;\n  replace?: boolean;\n  state?: any;\n  relative?: RelativeRoutingType;\n}\n\n/**\n * Changes the current location.\n *\n * Note: This API is mostly useful in React.Component subclasses that are not\n * able to use hooks. In functional components, we recommend you use the\n * `useNavigate` hook instead.\n *\n * @see https://reactrouter.com/v6/components/navigate\n */\nexport function Navigate({\n  to,\n  replace,\n  state,\n  relative,\n}: NavigateProps): null {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of\n    // the router loaded. We can help them understand how to avoid that.\n    `<Navigate> may be used only in the context of a <Router> component.`\n  );\n\n  let { future, static: isStatic } = React.useContext(NavigationContext);\n\n  warning(\n    !isStatic,\n    `<Navigate> must not be used on the initial render in a <StaticRouter>. ` +\n      `This is a no-op, but you should modify your code so the <Navigate> is ` +\n      `only ever rendered in response to some user interaction or state change.`\n  );\n\n  let { matches } = React.useContext(RouteContext);\n  let { pathname: locationPathname } = useLocation();\n  let navigate = useNavigate();\n\n  // Resolve the path outside of the effect so that when effects run twice in\n  // StrictMode they navigate to the same place\n  let path = resolveTo(\n    to,\n    getResolveToMatches(matches, future.v7_relativeSplatPath),\n    locationPathname,\n    relative === \"path\"\n  );\n  let jsonPath = JSON.stringify(path);\n\n  React.useEffect(\n    () => navigate(JSON.parse(jsonPath), { replace, state, relative }),\n    [navigate, jsonPath, relative, replace, state]\n  );\n\n  return null;\n}\n\nexport interface OutletProps {\n  context?: unknown;\n}\n\n/**\n * Renders the child route's element, if there is one.\n *\n * @see https://reactrouter.com/v6/components/outlet\n */\nexport function Outlet(props: OutletProps): React.ReactElement | null {\n  return useOutlet(props.context);\n}\n\nexport interface PathRouteProps {\n  caseSensitive?: NonIndexRouteObject[\"caseSensitive\"];\n  path?: NonIndexRouteObject[\"path\"];\n  id?: NonIndexRouteObject[\"id\"];\n  lazy?: LazyRouteFunction<NonIndexRouteObject>;\n  loader?: NonIndexRouteObject[\"loader\"];\n  action?: NonIndexRouteObject[\"action\"];\n  hasErrorBoundary?: NonIndexRouteObject[\"hasErrorBoundary\"];\n  shouldRevalidate?: NonIndexRouteObject[\"shouldRevalidate\"];\n  handle?: NonIndexRouteObject[\"handle\"];\n  index?: false;\n  children?: React.ReactNode;\n  element?: React.ReactNode | null;\n  hydrateFallbackElement?: React.ReactNode | null;\n  errorElement?: React.ReactNode | null;\n  Component?: React.ComponentType | null;\n  HydrateFallback?: React.ComponentType | null;\n  ErrorBoundary?: React.ComponentType | null;\n}\n\nexport interface LayoutRouteProps extends PathRouteProps {}\n\nexport interface IndexRouteProps {\n  caseSensitive?: IndexRouteObject[\"caseSensitive\"];\n  path?: IndexRouteObject[\"path\"];\n  id?: IndexRouteObject[\"id\"];\n  lazy?: LazyRouteFunction<IndexRouteObject>;\n  loader?: IndexRouteObject[\"loader\"];\n  action?: IndexRouteObject[\"action\"];\n  hasErrorBoundary?: IndexRouteObject[\"hasErrorBoundary\"];\n  shouldRevalidate?: IndexRouteObject[\"shouldRevalidate\"];\n  handle?: IndexRouteObject[\"handle\"];\n  index: true;\n  children?: undefined;\n  element?: React.ReactNode | null;\n  hydrateFallbackElement?: React.ReactNode | null;\n  errorElement?: React.ReactNode | null;\n  Component?: React.ComponentType | null;\n  HydrateFallback?: React.ComponentType | null;\n  ErrorBoundary?: React.ComponentType | null;\n}\n\nexport type RouteProps = PathRouteProps | LayoutRouteProps | IndexRouteProps;\n\n/**\n * Declares an element that should be rendered at a certain URL path.\n *\n * @see https://reactrouter.com/v6/components/route\n */\nexport function Route(_props: RouteProps): React.ReactElement | null {\n  invariant(\n    false,\n    `A <Route> is only ever to be used as the child of <Routes> element, ` +\n      `never rendered directly. Please wrap your <Route> in a <Routes>.`\n  );\n}\n\nexport interface RouterProps {\n  basename?: string;\n  children?: React.ReactNode;\n  location: Partial<Location> | string;\n  navigationType?: NavigationType;\n  navigator: Navigator;\n  static?: boolean;\n  future?: Partial<Pick<FutureConfig, \"v7_relativeSplatPath\">>;\n}\n\n/**\n * Provides location context for the rest of the app.\n *\n * Note: You usually won't render a `<Router>` directly. Instead, you'll render a\n * router that is more specific to your environment such as a `<BrowserRouter>`\n * in web browsers or a `<StaticRouter>` for server rendering.\n *\n * @see https://reactrouter.com/v6/router-components/router\n */\nexport function Router({\n  basename: basenameProp = \"/\",\n  children = null,\n  location: locationProp,\n  navigationType = NavigationType.Pop,\n  navigator,\n  static: staticProp = false,\n  future,\n}: RouterProps): React.ReactElement | null {\n  invariant(\n    !useInRouterContext(),\n    `You cannot render a <Router> inside another <Router>.` +\n      ` You should never have more than one in your app.`\n  );\n\n  // Preserve trailing slashes on basename, so we can let the user control\n  // the enforcement of trailing slashes throughout the app\n  let basename = basenameProp.replace(/^\\/*/, \"/\");\n  let navigationContext = React.useMemo(\n    () => ({\n      basename,\n      navigator,\n      static: staticProp,\n      future: {\n        v7_relativeSplatPath: false,\n        ...future,\n      },\n    }),\n    [basename, future, navigator, staticProp]\n  );\n\n  if (typeof locationProp === \"string\") {\n    locationProp = parsePath(locationProp);\n  }\n\n  let {\n    pathname = \"/\",\n    search = \"\",\n    hash = \"\",\n    state = null,\n    key = \"default\",\n  } = locationProp;\n\n  let locationContext = React.useMemo(() => {\n    let trailingPathname = stripBasename(pathname, basename);\n\n    if (trailingPathname == null) {\n      return null;\n    }\n\n    return {\n      location: {\n        pathname: trailingPathname,\n        search,\n        hash,\n        state,\n        key,\n      },\n      navigationType,\n    };\n  }, [basename, pathname, search, hash, state, key, navigationType]);\n\n  warning(\n    locationContext != null,\n    `<Router basename=\"${basename}\"> is not able to match the URL ` +\n      `\"${pathname}${search}${hash}\" because it does not start with the ` +\n      `basename, so the <Router> won't render anything.`\n  );\n\n  if (locationContext == null) {\n    return null;\n  }\n\n  return (\n    <NavigationContext.Provider value={navigationContext}>\n      <LocationContext.Provider children={children} value={locationContext} />\n    </NavigationContext.Provider>\n  );\n}\n\nexport interface RoutesProps {\n  children?: React.ReactNode;\n  location?: Partial<Location> | string;\n}\n\n/**\n * A container for a nested tree of `<Route>` elements that renders the branch\n * that best matches the current location.\n *\n * @see https://reactrouter.com/v6/components/routes\n */\nexport function Routes({\n  children,\n  location,\n}: RoutesProps): React.ReactElement | null {\n  return useRoutes(createRoutesFromChildren(children), location);\n}\n\nexport interface AwaitResolveRenderFunction {\n  (data: Awaited<any>): React.ReactNode;\n}\n\nexport interface AwaitProps {\n  children: React.ReactNode | AwaitResolveRenderFunction;\n  errorElement?: React.ReactNode;\n  resolve: TrackedPromise | any;\n}\n\n/**\n * Component to use for rendering lazily loaded data from returning defer()\n * in a loader function\n */\nexport function Await({ children, errorElement, resolve }: AwaitProps) {\n  return (\n    <AwaitErrorBoundary resolve={resolve} errorElement={errorElement}>\n      <ResolveAwait>{children}</ResolveAwait>\n    </AwaitErrorBoundary>\n  );\n}\n\ntype AwaitErrorBoundaryProps = React.PropsWithChildren<{\n  errorElement?: React.ReactNode;\n  resolve: TrackedPromise | any;\n}>;\n\ntype AwaitErrorBoundaryState = {\n  error: any;\n};\n\nenum AwaitRenderStatus {\n  pending,\n  success,\n  error,\n}\n\nconst neverSettledPromise = new Promise(() => {});\n\nclass AwaitErrorBoundary extends React.Component<\n  AwaitErrorBoundaryProps,\n  AwaitErrorBoundaryState\n> {\n  constructor(props: AwaitErrorBoundaryProps) {\n    super(props);\n    this.state = { error: null };\n  }\n\n  static getDerivedStateFromError(error: any) {\n    return { error };\n  }\n\n  componentDidCatch(error: any, errorInfo: any) {\n    console.error(\n      \"<Await> caught the following error during render\",\n      error,\n      errorInfo\n    );\n  }\n\n  render() {\n    let { children, errorElement, resolve } = this.props;\n\n    let promise: TrackedPromise | null = null;\n    let status: AwaitRenderStatus = AwaitRenderStatus.pending;\n\n    if (!(resolve instanceof Promise)) {\n      // Didn't get a promise - provide as a resolved promise\n      status = AwaitRenderStatus.success;\n      promise = Promise.resolve();\n      Object.defineProperty(promise, \"_tracked\", { get: () => true });\n      Object.defineProperty(promise, \"_data\", { get: () => resolve });\n    } else if (this.state.error) {\n      // Caught a render error, provide it as a rejected promise\n      status = AwaitRenderStatus.error;\n      let renderError = this.state.error;\n      promise = Promise.reject().catch(() => {}); // Avoid unhandled rejection warnings\n      Object.defineProperty(promise, \"_tracked\", { get: () => true });\n      Object.defineProperty(promise, \"_error\", { get: () => renderError });\n    } else if ((resolve as TrackedPromise)._tracked) {\n      // Already tracked promise - check contents\n      promise = resolve;\n      status =\n        \"_error\" in promise\n          ? AwaitRenderStatus.error\n          : \"_data\" in promise\n          ? AwaitRenderStatus.success\n          : AwaitRenderStatus.pending;\n    } else {\n      // Raw (untracked) promise - track it\n      status = AwaitRenderStatus.pending;\n      Object.defineProperty(resolve, \"_tracked\", { get: () => true });\n      promise = resolve.then(\n        (data: any) =>\n          Object.defineProperty(resolve, \"_data\", { get: () => data }),\n        (error: any) =>\n          Object.defineProperty(resolve, \"_error\", { get: () => error })\n      );\n    }\n\n    if (\n      status === AwaitRenderStatus.error &&\n      promise._error instanceof AbortedDeferredError\n    ) {\n      // Freeze the UI by throwing a never resolved promise\n      throw neverSettledPromise;\n    }\n\n    if (status === AwaitRenderStatus.error && !errorElement) {\n      // No errorElement, throw to the nearest route-level error boundary\n      throw promise._error;\n    }\n\n    if (status === AwaitRenderStatus.error) {\n      // Render via our errorElement\n      return <AwaitContext.Provider value={promise} children={errorElement} />;\n    }\n\n    if (status === AwaitRenderStatus.success) {\n      // Render children with resolved value\n      return <AwaitContext.Provider value={promise} children={children} />;\n    }\n\n    // Throw to the suspense boundary\n    throw promise;\n  }\n}\n\n/**\n * @private\n * Indirection to leverage useAsyncValue for a render-prop API on `<Await>`\n */\nfunction ResolveAwait({\n  children,\n}: {\n  children: React.ReactNode | AwaitResolveRenderFunction;\n}) {\n  let data = useAsyncValue();\n  let toRender = typeof children === \"function\" ? children(data) : children;\n  return <>{toRender}</>;\n}\n\n///////////////////////////////////////////////////////////////////////////////\n// UTILS\n///////////////////////////////////////////////////////////////////////////////\n\n/**\n * Creates a route config from a React \"children\" object, which is usually\n * either a `<Route>` element or an array of them. Used internally by\n * `<Routes>` to create a route config from its children.\n *\n * @see https://reactrouter.com/v6/utils/create-routes-from-children\n */\nexport function createRoutesFromChildren(\n  children: React.ReactNode,\n  parentPath: number[] = []\n): RouteObject[] {\n  let routes: RouteObject[] = [];\n\n  React.Children.forEach(children, (element, index) => {\n    if (!React.isValidElement(element)) {\n      // Ignore non-elements. This allows people to more easily inline\n      // conditionals in their route config.\n      return;\n    }\n\n    let treePath = [...parentPath, index];\n\n    if (element.type === React.Fragment) {\n      // Transparently support React.Fragment and its children.\n      routes.push.apply(\n        routes,\n        createRoutesFromChildren(element.props.children, treePath)\n      );\n      return;\n    }\n\n    invariant(\n      element.type === Route,\n      `[${\n        typeof element.type === \"string\" ? element.type : element.type.name\n      }] is not a <Route> component. All component children of <Routes> must be a <Route> or <React.Fragment>`\n    );\n\n    invariant(\n      !element.props.index || !element.props.children,\n      \"An index route cannot have child routes.\"\n    );\n\n    let route: RouteObject = {\n      id: element.props.id || treePath.join(\"-\"),\n      caseSensitive: element.props.caseSensitive,\n      element: element.props.element,\n      Component: element.props.Component,\n      index: element.props.index,\n      path: element.props.path,\n      loader: element.props.loader,\n      action: element.props.action,\n      errorElement: element.props.errorElement,\n      ErrorBoundary: element.props.ErrorBoundary,\n      hasErrorBoundary:\n        element.props.ErrorBoundary != null ||\n        element.props.errorElement != null,\n      shouldRevalidate: element.props.shouldRevalidate,\n      handle: element.props.handle,\n      lazy: element.props.lazy,\n    };\n\n    if (element.props.children) {\n      route.children = createRoutesFromChildren(\n        element.props.children,\n        treePath\n      );\n    }\n\n    routes.push(route);\n  });\n\n  return routes;\n}\n\n/**\n * Renders the result of `matchRoutes()` into a React element.\n */\nexport function renderMatches(\n  matches: RouteMatch[] | null\n): React.ReactElement | null {\n  return _renderMatches(matches);\n}\n","import type {\n  FormEncType,\n  HTMLFormMethod,\n  RelativeRoutingType,\n} from \"@remix-run/router\";\nimport { stripBasename, UNSAFE_warning as warning } from \"@remix-run/router\";\n\nexport const defaultMethod: HTMLFormMethod = \"get\";\nconst defaultEncType: FormEncType = \"application/x-www-form-urlencoded\";\n\nexport function isHtmlElement(object: any): object is HTMLElement {\n  return object != null && typeof object.tagName === \"string\";\n}\n\nexport function isButtonElement(object: any): object is HTMLButtonElement {\n  return isHtmlElement(object) && object.tagName.toLowerCase() === \"button\";\n}\n\nexport function isFormElement(object: any): object is HTMLFormElement {\n  return isHtmlElement(object) && object.tagName.toLowerCase() === \"form\";\n}\n\nexport function isInputElement(object: any): object is HTMLInputElement {\n  return isHtmlElement(object) && object.tagName.toLowerCase() === \"input\";\n}\n\ntype LimitedMouseEvent = Pick<\n  MouseEvent,\n  \"button\" | \"metaKey\" | \"altKey\" | \"ctrlKey\" | \"shiftKey\"\n>;\n\nfunction isModifiedEvent(event: LimitedMouseEvent) {\n  return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);\n}\n\nexport function shouldProcessLinkClick(\n  event: LimitedMouseEvent,\n  target?: string\n) {\n  return (\n    event.button === 0 && // Ignore everything but left clicks\n    (!target || target === \"_self\") && // Let browser handle \"target=_blank\" etc.\n    !isModifiedEvent(event) // Ignore clicks with modifier keys\n  );\n}\n\nexport type ParamKeyValuePair = [string, string];\n\nexport type URLSearchParamsInit =\n  | string\n  | ParamKeyValuePair[]\n  | Record<string, string | string[]>\n  | URLSearchParams;\n\n/**\n * Creates a URLSearchParams object using the given initializer.\n *\n * This is identical to `new URLSearchParams(init)` except it also\n * supports arrays as values in the object form of the initializer\n * instead of just strings. This is convenient when you need multiple\n * values for a given key, but don't want to use an array initializer.\n *\n * For example, instead of:\n *\n *   let searchParams = new URLSearchParams([\n *     ['sort', 'name'],\n *     ['sort', 'price']\n *   ]);\n *\n * you can do:\n *\n *   let searchParams = createSearchParams({\n *     sort: ['name', 'price']\n *   });\n */\nexport function createSearchParams(\n  init: URLSearchParamsInit = \"\"\n): URLSearchParams {\n  return new URLSearchParams(\n    typeof init === \"string\" ||\n    Array.isArray(init) ||\n    init instanceof URLSearchParams\n      ? init\n      : Object.keys(init).reduce((memo, key) => {\n          let value = init[key];\n          return memo.concat(\n            Array.isArray(value) ? value.map((v) => [key, v]) : [[key, value]]\n          );\n        }, [] as ParamKeyValuePair[])\n  );\n}\n\nexport function getSearchParamsForLocation(\n  locationSearch: string,\n  defaultSearchParams: URLSearchParams | null\n) {\n  let searchParams = createSearchParams(locationSearch);\n\n  if (defaultSearchParams) {\n    // Use `defaultSearchParams.forEach(...)` here instead of iterating of\n    // `defaultSearchParams.keys()` to work-around a bug in Firefox related to\n    // web extensions. Relevant Bugzilla tickets:\n    // https://bugzilla.mozilla.org/show_bug.cgi?id=1414602\n    // https://bugzilla.mozilla.org/show_bug.cgi?id=1023984\n    defaultSearchParams.forEach((_, key) => {\n      if (!searchParams.has(key)) {\n        defaultSearchParams.getAll(key).forEach((value) => {\n          searchParams.append(key, value);\n        });\n      }\n    });\n  }\n\n  return searchParams;\n}\n\n// Thanks https://github.com/sindresorhus/type-fest!\ntype JsonObject = { [Key in string]: JsonValue } & {\n  [Key in string]?: JsonValue | undefined;\n};\ntype JsonArray = JsonValue[] | readonly JsonValue[];\ntype JsonPrimitive = string | number | boolean | null;\ntype JsonValue = JsonPrimitive | JsonObject | JsonArray;\n\nexport type SubmitTarget =\n  | HTMLFormElement\n  | HTMLButtonElement\n  | HTMLInputElement\n  | FormData\n  | URLSearchParams\n  | JsonValue\n  | null;\n\n// One-time check for submitter support\nlet _formDataSupportsSubmitter: boolean | null = null;\n\nfunction isFormDataSubmitterSupported() {\n  if (_formDataSupportsSubmitter === null) {\n    try {\n      new FormData(\n        document.createElement(\"form\"),\n        // @ts-expect-error if FormData supports the submitter parameter, this will throw\n        0\n      );\n      _formDataSupportsSubmitter = false;\n    } catch (e) {\n      _formDataSupportsSubmitter = true;\n    }\n  }\n  return _formDataSupportsSubmitter;\n}\n\n/**\n * Submit options shared by both navigations and fetchers\n */\ninterface SharedSubmitOptions {\n  /**\n   * The HTTP method used to submit the form. Overrides `<form method>`.\n   * Defaults to \"GET\".\n   */\n  method?: HTMLFormMethod;\n\n  /**\n   * The action URL path used to submit the form. Overrides `<form action>`.\n   * Defaults to the path of the current route.\n   */\n  action?: string;\n\n  /**\n   * The encoding used to submit the form. Overrides `<form encType>`.\n   * Defaults to \"application/x-www-form-urlencoded\".\n   */\n  encType?: FormEncType;\n\n  /**\n   * Determines whether the form action is relative to the route hierarchy or\n   * the pathname.  Use this if you want to opt out of navigating the route\n   * hierarchy and want to instead route based on /-delimited URL segments\n   */\n  relative?: RelativeRoutingType;\n\n  /**\n   * In browser-based environments, prevent resetting scroll after this\n   * navigation when using the <ScrollRestoration> component\n   */\n  preventScrollReset?: boolean;\n\n  /**\n   * Enable flushSync for this submission's state updates\n   */\n  flushSync?: boolean;\n}\n\n/**\n * Submit options available to fetchers\n */\nexport interface FetcherSubmitOptions extends SharedSubmitOptions {}\n\n/**\n * Submit options available to navigations\n */\nexport interface SubmitOptions extends FetcherSubmitOptions {\n  /**\n   * Set `true` to replace the current entry in the browser's history stack\n   * instead of creating a new one (i.e. stay on \"the same page\"). Defaults\n   * to `false`.\n   */\n  replace?: boolean;\n\n  /**\n   * State object to add to the history stack entry for this navigation\n   */\n  state?: any;\n\n  /**\n   * Indicate a specific fetcherKey to use when using navigate=false\n   */\n  fetcherKey?: string;\n\n  /**\n   * navigate=false will use a fetcher instead of a navigation\n   */\n  navigate?: boolean;\n\n  /**\n   * Enable view transitions on this submission navigation\n   */\n  viewTransition?: boolean;\n}\n\nconst supportedFormEncTypes: Set<FormEncType> = new Set([\n  \"application/x-www-form-urlencoded\",\n  \"multipart/form-data\",\n  \"text/plain\",\n]);\n\nfunction getFormEncType(encType: string | null) {\n  if (encType != null && !supportedFormEncTypes.has(encType as FormEncType)) {\n    warning(\n      false,\n      `\"${encType}\" is not a valid \\`encType\\` for \\`<Form>\\`/\\`<fetcher.Form>\\` ` +\n        `and will default to \"${defaultEncType}\"`\n    );\n\n    return null;\n  }\n  return encType;\n}\n\nexport function getFormSubmissionInfo(\n  target: SubmitTarget,\n  basename: string\n): {\n  action: string | null;\n  method: string;\n  encType: string;\n  formData: FormData | undefined;\n  body: any;\n} {\n  let method: string;\n  let action: string | null;\n  let encType: string;\n  let formData: FormData | undefined;\n  let body: any;\n\n  if (isFormElement(target)) {\n    // When grabbing the action from the element, it will have had the basename\n    // prefixed to ensure non-JS scenarios work, so strip it since we'll\n    // re-prefix in the router\n    let attr = target.getAttribute(\"action\");\n    action = attr ? stripBasename(attr, basename) : null;\n    method = target.getAttribute(\"method\") || defaultMethod;\n    encType = getFormEncType(target.getAttribute(\"enctype\")) || defaultEncType;\n\n    formData = new FormData(target);\n  } else if (\n    isButtonElement(target) ||\n    (isInputElement(target) &&\n      (target.type === \"submit\" || target.type === \"image\"))\n  ) {\n    let form = target.form;\n\n    if (form == null) {\n      throw new Error(\n        `Cannot submit a <button> or <input type=\"submit\"> without a <form>`\n      );\n    }\n\n    // <button>/<input type=\"submit\"> may override attributes of <form>\n\n    // When grabbing the action from the element, it will have had the basename\n    // prefixed to ensure non-JS scenarios work, so strip it since we'll\n    // re-prefix in the router\n    let attr = target.getAttribute(\"formaction\") || form.getAttribute(\"action\");\n    action = attr ? stripBasename(attr, basename) : null;\n\n    method =\n      target.getAttribute(\"formmethod\") ||\n      form.getAttribute(\"method\") ||\n      defaultMethod;\n    encType =\n      getFormEncType(target.getAttribute(\"formenctype\")) ||\n      getFormEncType(form.getAttribute(\"enctype\")) ||\n      defaultEncType;\n\n    // Build a FormData object populated from a form and submitter\n    formData = new FormData(form, target);\n\n    // If this browser doesn't support the `FormData(el, submitter)` format,\n    // then tack on the submitter value at the end.  This is a lightweight\n    // solution that is not 100% spec compliant.  For complete support in older\n    // browsers, consider using the `formdata-submitter-polyfill` package\n    if (!isFormDataSubmitterSupported()) {\n      let { name, type, value } = target;\n      if (type === \"image\") {\n        let prefix = name ? `${name}.` : \"\";\n        formData.append(`${prefix}x`, \"0\");\n        formData.append(`${prefix}y`, \"0\");\n      } else if (name) {\n        formData.append(name, value);\n      }\n    }\n  } else if (isHtmlElement(target)) {\n    throw new Error(\n      `Cannot submit element that is not <form>, <button>, or ` +\n        `<input type=\"submit|image\">`\n    );\n  } else {\n    method = defaultMethod;\n    action = null;\n    encType = defaultEncType;\n    body = target;\n  }\n\n  // Send body for <Form encType=\"text/plain\" so we encode it into text\n  if (formData && encType === \"text/plain\") {\n    body = formData;\n    formData = undefined;\n  }\n\n  return { action, method: method.toLowerCase(), encType, formData, body };\n}\n","/**\n * NOTE: If you refactor this to split up the modules into separate files,\n * you'll need to update the rollup config for react-router-dom-v5-compat.\n */\nimport * as React from \"react\";\nimport * as ReactDOM from \"react-dom\";\nimport type {\n  DataRouteObject,\n  FutureConfig,\n  Location,\n  NavigateOptions,\n  NavigationType,\n  Navigator,\n  RelativeRoutingType,\n  RouteObject,\n  RouterProps,\n  RouterProviderProps,\n  To,\n  DataStrategyFunction,\n  PatchRoutesOnNavigationFunction,\n} from \"react-router\";\nimport {\n  Router,\n  createPath,\n  useHref,\n  useLocation,\n  useMatches,\n  useNavigate,\n  useNavigation,\n  useResolvedPath,\n  useBlocker,\n  UNSAFE_DataRouterContext as DataRouterContext,\n  UNSAFE_DataRouterStateContext as DataRouterStateContext,\n  UNSAFE_NavigationContext as NavigationContext,\n  UNSAFE_RouteContext as RouteContext,\n  UNSAFE_logV6DeprecationWarnings as logV6DeprecationWarnings,\n  UNSAFE_mapRouteProperties as mapRouteProperties,\n  UNSAFE_useRouteId as useRouteId,\n  UNSAFE_useRoutesImpl as useRoutesImpl,\n} from \"react-router\";\nimport type {\n  BrowserHistory,\n  Fetcher,\n  FormEncType,\n  FormMethod,\n  FutureConfig as RouterFutureConfig,\n  GetScrollRestorationKeyFunction,\n  HashHistory,\n  History,\n  HTMLFormMethod,\n  HydrationState,\n  Router as RemixRouter,\n  V7_FormMethod,\n  RouterState,\n  RouterSubscriber,\n  BlockerFunction,\n} from \"@remix-run/router\";\nimport {\n  createRouter,\n  createBrowserHistory,\n  createHashHistory,\n  joinPaths,\n  stripBasename,\n  UNSAFE_ErrorResponseImpl as ErrorResponseImpl,\n  UNSAFE_invariant as invariant,\n  UNSAFE_warning as warning,\n  matchPath,\n  IDLE_FETCHER,\n} from \"@remix-run/router\";\n\nimport type {\n  SubmitOptions,\n  ParamKeyValuePair,\n  URLSearchParamsInit,\n  SubmitTarget,\n  FetcherSubmitOptions,\n} from \"./dom\";\nimport {\n  createSearchParams,\n  defaultMethod,\n  getFormSubmissionInfo,\n  getSearchParamsForLocation,\n  shouldProcessLinkClick,\n} from \"./dom\";\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Re-exports\n////////////////////////////////////////////////////////////////////////////////\n\nexport type {\n  FormEncType,\n  FormMethod,\n  GetScrollRestorationKeyFunction,\n  ParamKeyValuePair,\n  SubmitOptions,\n  URLSearchParamsInit,\n  V7_FormMethod,\n};\nexport { createSearchParams, ErrorResponseImpl as UNSAFE_ErrorResponseImpl };\n\n// Note: Keep in sync with react-router exports!\nexport type {\n  ActionFunction,\n  ActionFunctionArgs,\n  AwaitProps,\n  Blocker,\n  BlockerFunction,\n  DataRouteMatch,\n  DataRouteObject,\n  DataStrategyFunction,\n  DataStrategyFunctionArgs,\n  DataStrategyMatch,\n  DataStrategyResult,\n  ErrorResponse,\n  Fetcher,\n  FutureConfig,\n  Hash,\n  IndexRouteObject,\n  IndexRouteProps,\n  JsonFunction,\n  LazyRouteFunction,\n  LayoutRouteProps,\n  LoaderFunction,\n  LoaderFunctionArgs,\n  Location,\n  MemoryRouterProps,\n  NavigateFunction,\n  NavigateOptions,\n  NavigateProps,\n  Navigation,\n  Navigator,\n  NonIndexRouteObject,\n  OutletProps,\n  Params,\n  ParamParseKey,\n  PatchRoutesOnNavigationFunction,\n  PatchRoutesOnNavigationFunctionArgs,\n  Path,\n  PathMatch,\n  Pathname,\n  PathParam,\n  PathPattern,\n  PathRouteProps,\n  RedirectFunction,\n  RelativeRoutingType,\n  RouteMatch,\n  RouteObject,\n  RouteProps,\n  RouterProps,\n  RouterProviderProps,\n  RoutesProps,\n  Search,\n  ShouldRevalidateFunction,\n  ShouldRevalidateFunctionArgs,\n  To,\n  UIMatch,\n} from \"react-router\";\nexport {\n  AbortedDeferredError,\n  Await,\n  MemoryRouter,\n  Navigate,\n  NavigationType,\n  Outlet,\n  Route,\n  Router,\n  Routes,\n  createMemoryRouter,\n  createPath,\n  createRoutesFromChildren,\n  createRoutesFromElements,\n  defer,\n  isRouteErrorResponse,\n  generatePath,\n  json,\n  matchPath,\n  matchRoutes,\n  parsePath,\n  redirect,\n  redirectDocument,\n  replace,\n  renderMatches,\n  resolvePath,\n  useActionData,\n  useAsyncError,\n  useAsyncValue,\n  useBlocker,\n  useHref,\n  useInRouterContext,\n  useLoaderData,\n  useLocation,\n  useMatch,\n  useMatches,\n  useNavigate,\n  useNavigation,\n  useNavigationType,\n  useOutlet,\n  useOutletContext,\n  useParams,\n  useResolvedPath,\n  useRevalidator,\n  useRouteError,\n  useRouteLoaderData,\n  useRoutes,\n} from \"react-router\";\n\n///////////////////////////////////////////////////////////////////////////////\n// DANGER! PLEASE READ ME!\n// We provide these exports as an escape hatch in the event that you need any\n// routing data that we don't provide an explicit API for. With that said, we\n// want to cover your use case if we can, so if you feel the need to use these\n// we want to hear from you. Let us know what you're building and we'll do our\n// best to make sure we can support you!\n//\n// We consider these exports an implementation detail and do not guarantee\n// against any breaking changes, regardless of the semver release. Use with\n// extreme caution and only if you understand the consequences. Godspeed.\n///////////////////////////////////////////////////////////////////////////////\n\n/** @internal */\nexport {\n  UNSAFE_DataRouterContext,\n  UNSAFE_DataRouterStateContext,\n  UNSAFE_NavigationContext,\n  UNSAFE_LocationContext,\n  UNSAFE_RouteContext,\n  UNSAFE_useRouteId,\n} from \"react-router\";\n//#endregion\n\ndeclare global {\n  var __staticRouterHydrationData: HydrationState | undefined;\n  var __reactRouterVersion: string;\n  interface Document {\n    startViewTransition(cb: () => Promise<void> | void): ViewTransition;\n  }\n}\n\n// HEY YOU! DON'T TOUCH THIS VARIABLE!\n//\n// It is replaced with the proper version at build time via a babel plugin in\n// the rollup config.\n//\n// Export a global property onto the window for React Router detection by the\n// Core Web Vitals Technology Report.  This way they can configure the `wappalyzer`\n// to detect and properly classify live websites as being built with React Router:\n// https://github.com/HTTPArchive/wappalyzer/blob/main/src/technologies/r.json\nconst REACT_ROUTER_VERSION = \"0\";\ntry {\n  window.__reactRouterVersion = REACT_ROUTER_VERSION;\n} catch (e) {\n  // no-op\n}\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Routers\n////////////////////////////////////////////////////////////////////////////////\n\ninterface DOMRouterOpts {\n  basename?: string;\n  future?: Partial<Omit<RouterFutureConfig, \"v7_prependBasename\">>;\n  hydrationData?: HydrationState;\n  dataStrategy?: DataStrategyFunction;\n  patchRoutesOnNavigation?: PatchRoutesOnNavigationFunction;\n  window?: Window;\n}\n\nexport function createBrowserRouter(\n  routes: RouteObject[],\n  opts?: DOMRouterOpts\n): RemixRouter {\n  return createRouter({\n    basename: opts?.basename,\n    future: {\n      ...opts?.future,\n      v7_prependBasename: true,\n    },\n    history: createBrowserHistory({ window: opts?.window }),\n    hydrationData: opts?.hydrationData || parseHydrationData(),\n    routes,\n    mapRouteProperties,\n    dataStrategy: opts?.dataStrategy,\n    patchRoutesOnNavigation: opts?.patchRoutesOnNavigation,\n    window: opts?.window,\n  }).initialize();\n}\n\nexport function createHashRouter(\n  routes: RouteObject[],\n  opts?: DOMRouterOpts\n): RemixRouter {\n  return createRouter({\n    basename: opts?.basename,\n    future: {\n      ...opts?.future,\n      v7_prependBasename: true,\n    },\n    history: createHashHistory({ window: opts?.window }),\n    hydrationData: opts?.hydrationData || parseHydrationData(),\n    routes,\n    mapRouteProperties,\n    dataStrategy: opts?.dataStrategy,\n    patchRoutesOnNavigation: opts?.patchRoutesOnNavigation,\n    window: opts?.window,\n  }).initialize();\n}\n\nfunction parseHydrationData(): HydrationState | undefined {\n  let state = window?.__staticRouterHydrationData;\n  if (state && state.errors) {\n    state = {\n      ...state,\n      errors: deserializeErrors(state.errors),\n    };\n  }\n  return state;\n}\n\nfunction deserializeErrors(\n  errors: RemixRouter[\"state\"][\"errors\"]\n): RemixRouter[\"state\"][\"errors\"] {\n  if (!errors) return null;\n  let entries = Object.entries(errors);\n  let serialized: RemixRouter[\"state\"][\"errors\"] = {};\n  for (let [key, val] of entries) {\n    // Hey you!  If you change this, please change the corresponding logic in\n    // serializeErrors in react-router-dom/server.tsx :)\n    if (val && val.__type === \"RouteErrorResponse\") {\n      serialized[key] = new ErrorResponseImpl(\n        val.status,\n        val.statusText,\n        val.data,\n        val.internal === true\n      );\n    } else if (val && val.__type === \"Error\") {\n      // Attempt to reconstruct the right type of Error (i.e., ReferenceError)\n      if (val.__subType) {\n        let ErrorConstructor = window[val.__subType];\n        if (typeof ErrorConstructor === \"function\") {\n          try {\n            // @ts-expect-error\n            let error = new ErrorConstructor(val.message);\n            // Wipe away the client-side stack trace.  Nothing to fill it in with\n            // because we don't serialize SSR stack traces for security reasons\n            error.stack = \"\";\n            serialized[key] = error;\n          } catch (e) {\n            // no-op - fall through and create a normal Error\n          }\n        }\n      }\n\n      if (serialized[key] == null) {\n        let error = new Error(val.message);\n        // Wipe away the client-side stack trace.  Nothing to fill it in with\n        // because we don't serialize SSR stack traces for security reasons\n        error.stack = \"\";\n        serialized[key] = error;\n      }\n    } else {\n      serialized[key] = val;\n    }\n  }\n  return serialized;\n}\n\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Contexts\n////////////////////////////////////////////////////////////////////////////////\n\ntype ViewTransitionContextObject =\n  | {\n      isTransitioning: false;\n    }\n  | {\n      isTransitioning: true;\n      flushSync: boolean;\n      currentLocation: Location;\n      nextLocation: Location;\n    };\n\nconst ViewTransitionContext = React.createContext<ViewTransitionContextObject>({\n  isTransitioning: false,\n});\nif (__DEV__) {\n  ViewTransitionContext.displayName = \"ViewTransition\";\n}\n\nexport { ViewTransitionContext as UNSAFE_ViewTransitionContext };\n\n// TODO: (v7) Change the useFetcher data from `any` to `unknown`\ntype FetchersContextObject = Map<string, any>;\n\nconst FetchersContext = React.createContext<FetchersContextObject>(new Map());\nif (__DEV__) {\n  FetchersContext.displayName = \"Fetchers\";\n}\n\nexport { FetchersContext as UNSAFE_FetchersContext };\n\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Components\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n  Webpack + React 17 fails to compile on any of the following because webpack\n  complains that `startTransition` doesn't exist in `React`:\n  * import { startTransition } from \"react\"\n  * import * as React from from \"react\";\n    \"startTransition\" in React ? React.startTransition(() => setState()) : setState()\n  * import * as React from from \"react\";\n    \"startTransition\" in React ? React[\"startTransition\"](() => setState()) : setState()\n\n  Moving it to a constant such as the following solves the Webpack/React 17 issue:\n  * import * as React from from \"react\";\n    const START_TRANSITION = \"startTransition\";\n    START_TRANSITION in React ? React[START_TRANSITION](() => setState()) : setState()\n\n  However, that introduces webpack/terser minification issues in production builds\n  in React 18 where minification/obfuscation ends up removing the call of\n  React.startTransition entirely from the first half of the ternary.  Grabbing\n  this exported reference once up front resolves that issue.\n\n  See https://github.com/remix-run/react-router/issues/10579\n*/\nconst START_TRANSITION = \"startTransition\";\nconst startTransitionImpl = React[START_TRANSITION];\nconst FLUSH_SYNC = \"flushSync\";\nconst flushSyncImpl = ReactDOM[FLUSH_SYNC];\nconst USE_ID = \"useId\";\nconst useIdImpl = React[USE_ID];\n\nfunction startTransitionSafe(cb: () => void) {\n  if (startTransitionImpl) {\n    startTransitionImpl(cb);\n  } else {\n    cb();\n  }\n}\n\nfunction flushSyncSafe(cb: () => void) {\n  if (flushSyncImpl) {\n    flushSyncImpl(cb);\n  } else {\n    cb();\n  }\n}\n\ninterface ViewTransition {\n  finished: Promise<void>;\n  ready: Promise<void>;\n  updateCallbackDone: Promise<void>;\n  skipTransition(): void;\n}\n\nclass Deferred<T> {\n  status: \"pending\" | \"resolved\" | \"rejected\" = \"pending\";\n  promise: Promise<T>;\n  // @ts-expect-error - no initializer\n  resolve: (value: T) => void;\n  // @ts-expect-error - no initializer\n  reject: (reason?: unknown) => void;\n  constructor() {\n    this.promise = new Promise((resolve, reject) => {\n      this.resolve = (value) => {\n        if (this.status === \"pending\") {\n          this.status = \"resolved\";\n          resolve(value);\n        }\n      };\n      this.reject = (reason) => {\n        if (this.status === \"pending\") {\n          this.status = \"rejected\";\n          reject(reason);\n        }\n      };\n    });\n  }\n}\n\n/**\n * Given a Remix Router instance, render the appropriate UI\n */\nexport function RouterProvider({\n  fallbackElement,\n  router,\n  future,\n}: RouterProviderProps): React.ReactElement {\n  let [state, setStateImpl] = React.useState(router.state);\n  let [pendingState, setPendingState] = React.useState<RouterState>();\n  let [vtContext, setVtContext] = React.useState<ViewTransitionContextObject>({\n    isTransitioning: false,\n  });\n  let [renderDfd, setRenderDfd] = React.useState<Deferred<void>>();\n  let [transition, setTransition] = React.useState<ViewTransition>();\n  let [interruption, setInterruption] = React.useState<{\n    state: RouterState;\n    currentLocation: Location;\n    nextLocation: Location;\n  }>();\n  let fetcherData = React.useRef<Map<string, any>>(new Map());\n  let { v7_startTransition } = future || {};\n\n  let optInStartTransition = React.useCallback(\n    (cb: () => void) => {\n      if (v7_startTransition) {\n        startTransitionSafe(cb);\n      } else {\n        cb();\n      }\n    },\n    [v7_startTransition]\n  );\n\n  let setState = React.useCallback<RouterSubscriber>(\n    (\n      newState: RouterState,\n      {\n        deletedFetchers,\n        flushSync: flushSync,\n        viewTransitionOpts: viewTransitionOpts,\n      }\n    ) => {\n      deletedFetchers.forEach((key) => fetcherData.current.delete(key));\n      newState.fetchers.forEach((fetcher, key) => {\n        if (fetcher.data !== undefined) {\n          fetcherData.current.set(key, fetcher.data);\n        }\n      });\n\n      let isViewTransitionUnavailable =\n        router.window == null ||\n        router.window.document == null ||\n        typeof router.window.document.startViewTransition !== \"function\";\n\n      // If this isn't a view transition or it's not available in this browser,\n      // just update and be done with it\n      if (!viewTransitionOpts || isViewTransitionUnavailable) {\n        if (flushSync) {\n          flushSyncSafe(() => setStateImpl(newState));\n        } else {\n          optInStartTransition(() => setStateImpl(newState));\n        }\n        return;\n      }\n\n      // flushSync + startViewTransition\n      if (flushSync) {\n        // Flush through the context to mark DOM elements as transition=ing\n        flushSyncSafe(() => {\n          // Cancel any pending transitions\n          if (transition) {\n            renderDfd && renderDfd.resolve();\n            transition.skipTransition();\n          }\n          setVtContext({\n            isTransitioning: true,\n            flushSync: true,\n            currentLocation: viewTransitionOpts.currentLocation,\n            nextLocation: viewTransitionOpts.nextLocation,\n          });\n        });\n\n        // Update the DOM\n        let t = router.window!.document.startViewTransition(() => {\n          flushSyncSafe(() => setStateImpl(newState));\n        });\n\n        // Clean up after the animation completes\n        t.finished.finally(() => {\n          flushSyncSafe(() => {\n            setRenderDfd(undefined);\n            setTransition(undefined);\n            setPendingState(undefined);\n            setVtContext({ isTransitioning: false });\n          });\n        });\n\n        flushSyncSafe(() => setTransition(t));\n        return;\n      }\n\n      // startTransition + startViewTransition\n      if (transition) {\n        // Interrupting an in-progress transition, cancel and let everything flush\n        // out, and then kick off a new transition from the interruption state\n        renderDfd && renderDfd.resolve();\n        transition.skipTransition();\n        setInterruption({\n          state: newState,\n          currentLocation: viewTransitionOpts.currentLocation,\n          nextLocation: viewTransitionOpts.nextLocation,\n        });\n      } else {\n        // Completed navigation update with opted-in view transitions, let 'er rip\n        setPendingState(newState);\n        setVtContext({\n          isTransitioning: true,\n          flushSync: false,\n          currentLocation: viewTransitionOpts.currentLocation,\n          nextLocation: viewTransitionOpts.nextLocation,\n        });\n      }\n    },\n    [router.window, transition, renderDfd, fetcherData, optInStartTransition]\n  );\n\n  // Need to use a layout effect here so we are subscribed early enough to\n  // pick up on any render-driven redirects/navigations (useEffect/<Navigate>)\n  React.useLayoutEffect(() => router.subscribe(setState), [router, setState]);\n\n  // When we start a view transition, create a Deferred we can use for the\n  // eventual \"completed\" render\n  React.useEffect(() => {\n    if (vtContext.isTransitioning && !vtContext.flushSync) {\n      setRenderDfd(new Deferred<void>());\n    }\n  }, [vtContext]);\n\n  // Once the deferred is created, kick off startViewTransition() to update the\n  // DOM and then wait on the Deferred to resolve (indicating the DOM update has\n  // happened)\n  React.useEffect(() => {\n    if (renderDfd && pendingState && router.window) {\n      let newState = pendingState;\n      let renderPromise = renderDfd.promise;\n      let transition = router.window.document.startViewTransition(async () => {\n        optInStartTransition(() => setStateImpl(newState));\n        await renderPromise;\n      });\n      transition.finished.finally(() => {\n        setRenderDfd(undefined);\n        setTransition(undefined);\n        setPendingState(undefined);\n        setVtContext({ isTransitioning: false });\n      });\n      setTransition(transition);\n    }\n  }, [optInStartTransition, pendingState, renderDfd, router.window]);\n\n  // When the new location finally renders and is committed to the DOM, this\n  // effect will run to resolve the transition\n  React.useEffect(() => {\n    if (\n      renderDfd &&\n      pendingState &&\n      state.location.key === pendingState.location.key\n    ) {\n      renderDfd.resolve();\n    }\n  }, [renderDfd, transition, state.location, pendingState]);\n\n  // If we get interrupted with a new navigation during a transition, we skip\n  // the active transition, let it cleanup, then kick it off again here\n  React.useEffect(() => {\n    if (!vtContext.isTransitioning && interruption) {\n      setPendingState(interruption.state);\n      setVtContext({\n        isTransitioning: true,\n        flushSync: false,\n        currentLocation: interruption.currentLocation,\n        nextLocation: interruption.nextLocation,\n      });\n      setInterruption(undefined);\n    }\n  }, [vtContext.isTransitioning, interruption]);\n\n  React.useEffect(() => {\n    warning(\n      fallbackElement == null || !router.future.v7_partialHydration,\n      \"`<RouterProvider fallbackElement>` is deprecated when using \" +\n        \"`v7_partialHydration`, use a `HydrateFallback` component instead\"\n    );\n    // Only log this once on initial mount\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  let navigator = React.useMemo((): Navigator => {\n    return {\n      createHref: router.createHref,\n      encodeLocation: router.encodeLocation,\n      go: (n) => router.navigate(n),\n      push: (to, state, opts) =>\n        router.navigate(to, {\n          state,\n          preventScrollReset: opts?.preventScrollReset,\n        }),\n      replace: (to, state, opts) =>\n        router.navigate(to, {\n          replace: true,\n          state,\n          preventScrollReset: opts?.preventScrollReset,\n        }),\n    };\n  }, [router]);\n\n  let basename = router.basename || \"/\";\n\n  let dataRouterContext = React.useMemo(\n    () => ({\n      router,\n      navigator,\n      static: false,\n      basename,\n    }),\n    [router, navigator, basename]\n  );\n\n  let routerFuture = React.useMemo<RouterProps[\"future\"]>(\n    () => ({\n      v7_relativeSplatPath: router.future.v7_relativeSplatPath,\n    }),\n    [router.future.v7_relativeSplatPath]\n  );\n\n  React.useEffect(\n    () => logV6DeprecationWarnings(future, router.future),\n    [future, router.future]\n  );\n\n  // The fragment and {null} here are important!  We need them to keep React 18's\n  // useId happy when we are server-rendering since we may have a <script> here\n  // containing the hydrated server-side staticContext (from StaticRouterProvider).\n  // useId relies on the component tree structure to generate deterministic id's\n  // so we need to ensure it remains the same on the client even though\n  // we don't need the <script> tag\n  return (\n    <>\n      <DataRouterContext.Provider value={dataRouterContext}>\n        <DataRouterStateContext.Provider value={state}>\n          <FetchersContext.Provider value={fetcherData.current}>\n            <ViewTransitionContext.Provider value={vtContext}>\n              <Router\n                basename={basename}\n                location={state.location}\n                navigationType={state.historyAction}\n                navigator={navigator}\n                future={routerFuture}\n              >\n                {state.initialized || router.future.v7_partialHydration ? (\n                  <MemoizedDataRoutes\n                    routes={router.routes}\n                    future={router.future}\n                    state={state}\n                  />\n                ) : (\n                  fallbackElement\n                )}\n              </Router>\n            </ViewTransitionContext.Provider>\n          </FetchersContext.Provider>\n        </DataRouterStateContext.Provider>\n      </DataRouterContext.Provider>\n      {null}\n    </>\n  );\n}\n\n// Memoize to avoid re-renders when updating `ViewTransitionContext`\nconst MemoizedDataRoutes = React.memo(DataRoutes);\n\nfunction DataRoutes({\n  routes,\n  future,\n  state,\n}: {\n  routes: DataRouteObject[];\n  future: RemixRouter[\"future\"];\n  state: RouterState;\n}): React.ReactElement | null {\n  return useRoutesImpl(routes, undefined, state, future);\n}\n\nexport interface BrowserRouterProps {\n  basename?: string;\n  children?: React.ReactNode;\n  future?: Partial<FutureConfig>;\n  window?: Window;\n}\n\n/**\n * A `<Router>` for use in web browsers. Provides the cleanest URLs.\n */\nexport function BrowserRouter({\n  basename,\n  children,\n  future,\n  window,\n}: BrowserRouterProps) {\n  let historyRef = React.useRef<BrowserHistory>();\n  if (historyRef.current == null) {\n    historyRef.current = createBrowserHistory({ window, v5Compat: true });\n  }\n\n  let history = historyRef.current;\n  let [state, setStateImpl] = React.useState({\n    action: history.action,\n    location: history.location,\n  });\n  let { v7_startTransition } = future || {};\n  let setState = React.useCallback(\n    (newState: { action: NavigationType; location: Location }) => {\n      v7_startTransition && startTransitionImpl\n        ? startTransitionImpl(() => setStateImpl(newState))\n        : setStateImpl(newState);\n    },\n    [setStateImpl, v7_startTransition]\n  );\n\n  React.useLayoutEffect(() => history.listen(setState), [history, setState]);\n\n  React.useEffect(() => logV6DeprecationWarnings(future), [future]);\n\n  return (\n    <Router\n      basename={basename}\n      children={children}\n      location={state.location}\n      navigationType={state.action}\n      navigator={history}\n      future={future}\n    />\n  );\n}\n\nexport interface HashRouterProps {\n  basename?: string;\n  children?: React.ReactNode;\n  future?: Partial<FutureConfig>;\n  window?: Window;\n}\n\n/**\n * A `<Router>` for use in web browsers. Stores the location in the hash\n * portion of the URL so it is not sent to the server.\n */\nexport function HashRouter({\n  basename,\n  children,\n  future,\n  window,\n}: HashRouterProps) {\n  let historyRef = React.useRef<HashHistory>();\n  if (historyRef.current == null) {\n    historyRef.current = createHashHistory({ window, v5Compat: true });\n  }\n\n  let history = historyRef.current;\n  let [state, setStateImpl] = React.useState({\n    action: history.action,\n    location: history.location,\n  });\n  let { v7_startTransition } = future || {};\n  let setState = React.useCallback(\n    (newState: { action: NavigationType; location: Location }) => {\n      v7_startTransition && startTransitionImpl\n        ? startTransitionImpl(() => setStateImpl(newState))\n        : setStateImpl(newState);\n    },\n    [setStateImpl, v7_startTransition]\n  );\n\n  React.useLayoutEffect(() => history.listen(setState), [history, setState]);\n\n  React.useEffect(() => logV6DeprecationWarnings(future), [future]);\n\n  return (\n    <Router\n      basename={basename}\n      children={children}\n      location={state.location}\n      navigationType={state.action}\n      navigator={history}\n      future={future}\n    />\n  );\n}\n\nexport interface HistoryRouterProps {\n  basename?: string;\n  children?: React.ReactNode;\n  future?: FutureConfig;\n  history: History;\n}\n\n/**\n * A `<Router>` that accepts a pre-instantiated history object. It's important\n * to note that using your own history object is highly discouraged and may add\n * two versions of the history library to your bundles unless you use the same\n * version of the history library that React Router uses internally.\n */\nfunction HistoryRouter({\n  basename,\n  children,\n  future,\n  history,\n}: HistoryRouterProps) {\n  let [state, setStateImpl] = React.useState({\n    action: history.action,\n    location: history.location,\n  });\n  let { v7_startTransition } = future || {};\n  let setState = React.useCallback(\n    (newState: { action: NavigationType; location: Location }) => {\n      v7_startTransition && startTransitionImpl\n        ? startTransitionImpl(() => setStateImpl(newState))\n        : setStateImpl(newState);\n    },\n    [setStateImpl, v7_startTransition]\n  );\n\n  React.useLayoutEffect(() => history.listen(setState), [history, setState]);\n\n  React.useEffect(() => logV6DeprecationWarnings(future), [future]);\n\n  return (\n    <Router\n      basename={basename}\n      children={children}\n      location={state.location}\n      navigationType={state.action}\n      navigator={history}\n      future={future}\n    />\n  );\n}\n\nif (__DEV__) {\n  HistoryRouter.displayName = \"unstable_HistoryRouter\";\n}\n\nexport { HistoryRouter as unstable_HistoryRouter };\n\nexport interface LinkProps\n  extends Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, \"href\"> {\n  reloadDocument?: boolean;\n  replace?: boolean;\n  state?: any;\n  preventScrollReset?: boolean;\n  relative?: RelativeRoutingType;\n  to: To;\n  viewTransition?: boolean;\n}\n\nconst isBrowser =\n  typeof window !== \"undefined\" &&\n  typeof window.document !== \"undefined\" &&\n  typeof window.document.createElement !== \"undefined\";\n\nconst ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\\/\\/)/i;\n\n/**\n * The public API for rendering a history-aware `<a>`.\n */\nexport const Link = React.forwardRef<HTMLAnchorElement, LinkProps>(\n  function LinkWithRef(\n    {\n      onClick,\n      relative,\n      reloadDocument,\n      replace,\n      state,\n      target,\n      to,\n      preventScrollReset,\n      viewTransition,\n      ...rest\n    },\n    ref\n  ) {\n    let { basename } = React.useContext(NavigationContext);\n\n    // Rendered into <a href> for absolute URLs\n    let absoluteHref;\n    let isExternal = false;\n\n    if (typeof to === \"string\" && ABSOLUTE_URL_REGEX.test(to)) {\n      // Render the absolute href server- and client-side\n      absoluteHref = to;\n\n      // Only check for external origins client-side\n      if (isBrowser) {\n        try {\n          let currentUrl = new URL(window.location.href);\n          let targetUrl = to.startsWith(\"//\")\n            ? new URL(currentUrl.protocol + to)\n            : new URL(to);\n          let path = stripBasename(targetUrl.pathname, basename);\n\n          if (targetUrl.origin === currentUrl.origin && path != null) {\n            // Strip the protocol/origin/basename for same-origin absolute URLs\n            to = path + targetUrl.search + targetUrl.hash;\n          } else {\n            isExternal = true;\n          }\n        } catch (e) {\n          // We can't do external URL detection without a valid URL\n          warning(\n            false,\n            `<Link to=\"${to}\"> contains an invalid URL which will probably break ` +\n              `when clicked - please update to a valid URL path.`\n          );\n        }\n      }\n    }\n\n    // Rendered into <a href> for relative URLs\n    let href = useHref(to, { relative });\n\n    let internalOnClick = useLinkClickHandler(to, {\n      replace,\n      state,\n      target,\n      preventScrollReset,\n      relative,\n      viewTransition,\n    });\n    function handleClick(\n      event: React.MouseEvent<HTMLAnchorElement, MouseEvent>\n    ) {\n      if (onClick) onClick(event);\n      if (!event.defaultPrevented) {\n        internalOnClick(event);\n      }\n    }\n\n    return (\n      // eslint-disable-next-line jsx-a11y/anchor-has-content\n      <a\n        {...rest}\n        href={absoluteHref || href}\n        onClick={isExternal || reloadDocument ? onClick : handleClick}\n        ref={ref}\n        target={target}\n      />\n    );\n  }\n);\n\nif (__DEV__) {\n  Link.displayName = \"Link\";\n}\n\nexport type NavLinkRenderProps = {\n  isActive: boolean;\n  isPending: boolean;\n  isTransitioning: boolean;\n};\n\nexport interface NavLinkProps\n  extends Omit<LinkProps, \"className\" | \"style\" | \"children\"> {\n  children?: React.ReactNode | ((props: NavLinkRenderProps) => React.ReactNode);\n  caseSensitive?: boolean;\n  className?: string | ((props: NavLinkRenderProps) => string | undefined);\n  end?: boolean;\n  style?:\n    | React.CSSProperties\n    | ((props: NavLinkRenderProps) => React.CSSProperties | undefined);\n}\n\n/**\n * A `<Link>` wrapper that knows if it's \"active\" or not.\n */\nexport const NavLink = React.forwardRef<HTMLAnchorElement, NavLinkProps>(\n  function NavLinkWithRef(\n    {\n      \"aria-current\": ariaCurrentProp = \"page\",\n      caseSensitive = false,\n      className: classNameProp = \"\",\n      end = false,\n      style: styleProp,\n      to,\n      viewTransition,\n      children,\n      ...rest\n    },\n    ref\n  ) {\n    let path = useResolvedPath(to, { relative: rest.relative });\n    let location = useLocation();\n    let routerState = React.useContext(DataRouterStateContext);\n    let { navigator, basename } = React.useContext(NavigationContext);\n    let isTransitioning =\n      routerState != null &&\n      // Conditional usage is OK here because the usage of a data router is static\n      // eslint-disable-next-line react-hooks/rules-of-hooks\n      useViewTransitionState(path) &&\n      viewTransition === true;\n\n    let toPathname = navigator.encodeLocation\n      ? navigator.encodeLocation(path).pathname\n      : path.pathname;\n    let locationPathname = location.pathname;\n    let nextLocationPathname =\n      routerState && routerState.navigation && routerState.navigation.location\n        ? routerState.navigation.location.pathname\n        : null;\n\n    if (!caseSensitive) {\n      locationPathname = locationPathname.toLowerCase();\n      nextLocationPathname = nextLocationPathname\n        ? nextLocationPathname.toLowerCase()\n        : null;\n      toPathname = toPathname.toLowerCase();\n    }\n\n    if (nextLocationPathname && basename) {\n      nextLocationPathname =\n        stripBasename(nextLocationPathname, basename) || nextLocationPathname;\n    }\n\n    // If the `to` has a trailing slash, look at that exact spot.  Otherwise,\n    // we're looking for a slash _after_ what's in `to`.  For example:\n    //\n    // <NavLink to=\"/users\"> and <NavLink to=\"/users/\">\n    // both want to look for a / at index 6 to match URL `/users/matt`\n    const endSlashPosition =\n      toPathname !== \"/\" && toPathname.endsWith(\"/\")\n        ? toPathname.length - 1\n        : toPathname.length;\n    let isActive =\n      locationPathname === toPathname ||\n      (!end &&\n        locationPathname.startsWith(toPathname) &&\n        locationPathname.charAt(endSlashPosition) === \"/\");\n\n    let isPending =\n      nextLocationPathname != null &&\n      (nextLocationPathname === toPathname ||\n        (!end &&\n          nextLocationPathname.startsWith(toPathname) &&\n          nextLocationPathname.charAt(toPathname.length) === \"/\"));\n\n    let renderProps = {\n      isActive,\n      isPending,\n      isTransitioning,\n    };\n\n    let ariaCurrent = isActive ? ariaCurrentProp : undefined;\n\n    let className: string | undefined;\n    if (typeof classNameProp === \"function\") {\n      className = classNameProp(renderProps);\n    } else {\n      // If the className prop is not a function, we use a default `active`\n      // class for <NavLink />s that are active. In v5 `active` was the default\n      // value for `activeClassName`, but we are removing that API and can still\n      // use the old default behavior for a cleaner upgrade path and keep the\n      // simple styling rules working as they currently do.\n      className = [\n        classNameProp,\n        isActive ? \"active\" : null,\n        isPending ? \"pending\" : null,\n        isTransitioning ? \"transitioning\" : null,\n      ]\n        .filter(Boolean)\n        .join(\" \");\n    }\n\n    let style =\n      typeof styleProp === \"function\" ? styleProp(renderProps) : styleProp;\n\n    return (\n      <Link\n        {...rest}\n        aria-current={ariaCurrent}\n        className={className}\n        ref={ref}\n        style={style}\n        to={to}\n        viewTransition={viewTransition}\n      >\n        {typeof children === \"function\" ? children(renderProps) : children}\n      </Link>\n    );\n  }\n);\n\nif (__DEV__) {\n  NavLink.displayName = \"NavLink\";\n}\n\n/**\n * Form props shared by navigations and fetchers\n */\ninterface SharedFormProps extends React.FormHTMLAttributes<HTMLFormElement> {\n  /**\n   * The HTTP verb to use when the form is submit. Supports \"get\", \"post\",\n   * \"put\", \"delete\", \"patch\".\n   */\n  method?: HTMLFormMethod;\n\n  /**\n   * `<form encType>` - enhancing beyond the normal string type and limiting\n   * to the built-in browser supported values\n   */\n  encType?:\n    | \"application/x-www-form-urlencoded\"\n    | \"multipart/form-data\"\n    | \"text/plain\";\n\n  /**\n   * Normal `<form action>` but supports React Router's relative paths.\n   */\n  action?: string;\n\n  /**\n   * Determines whether the form action is relative to the route hierarchy or\n   * the pathname.  Use this if you want to opt out of navigating the route\n   * hierarchy and want to instead route based on /-delimited URL segments\n   */\n  relative?: RelativeRoutingType;\n\n  /**\n   * Prevent the scroll position from resetting to the top of the viewport on\n   * completion of the navigation when using the <ScrollRestoration> component\n   */\n  preventScrollReset?: boolean;\n\n  /**\n   * A function to call when the form is submitted. If you call\n   * `event.preventDefault()` then this form will not do anything.\n   */\n  onSubmit?: React.FormEventHandler<HTMLFormElement>;\n}\n\n/**\n * Form props available to fetchers\n */\nexport interface FetcherFormProps extends SharedFormProps {}\n\n/**\n * Form props available to navigations\n */\nexport interface FormProps extends SharedFormProps {\n  /**\n   * Indicate a specific fetcherKey to use when using navigate=false\n   */\n  fetcherKey?: string;\n\n  /**\n   * navigate=false will use a fetcher instead of a navigation\n   */\n  navigate?: boolean;\n\n  /**\n   * Forces a full document navigation instead of a fetch.\n   */\n  reloadDocument?: boolean;\n\n  /**\n   * Replaces the current entry in the browser history stack when the form\n   * navigates. Use this if you don't want the user to be able to click \"back\"\n   * to the page with the form on it.\n   */\n  replace?: boolean;\n\n  /**\n   * State object to add to the history stack entry for this navigation\n   */\n  state?: any;\n\n  /**\n   * Enable view transitions on this Form navigation\n   */\n  viewTransition?: boolean;\n}\n\ntype HTMLSubmitEvent = React.BaseSyntheticEvent<\n  SubmitEvent,\n  Event,\n  HTMLFormElement\n>;\n\ntype HTMLFormSubmitter = HTMLButtonElement | HTMLInputElement;\n\n/**\n * A `@remix-run/router`-aware `<form>`. It behaves like a normal form except\n * that the interaction with the server is with `fetch` instead of new document\n * requests, allowing components to add nicer UX to the page as the form is\n * submitted and returns with data.\n */\nexport const Form = React.forwardRef<HTMLFormElement, FormProps>(\n  (\n    {\n      fetcherKey,\n      navigate,\n      reloadDocument,\n      replace,\n      state,\n      method = defaultMethod,\n      action,\n      onSubmit,\n      relative,\n      preventScrollReset,\n      viewTransition,\n      ...props\n    },\n    forwardedRef\n  ) => {\n    let submit = useSubmit();\n    let formAction = useFormAction(action, { relative });\n    let formMethod: HTMLFormMethod =\n      method.toLowerCase() === \"get\" ? \"get\" : \"post\";\n\n    let submitHandler: React.FormEventHandler<HTMLFormElement> = (event) => {\n      onSubmit && onSubmit(event);\n      if (event.defaultPrevented) return;\n      event.preventDefault();\n\n      let submitter = (event as unknown as HTMLSubmitEvent).nativeEvent\n        .submitter as HTMLFormSubmitter | null;\n\n      let submitMethod =\n        (submitter?.getAttribute(\"formmethod\") as HTMLFormMethod | undefined) ||\n        method;\n\n      submit(submitter || event.currentTarget, {\n        fetcherKey,\n        method: submitMethod,\n        navigate,\n        replace,\n        state,\n        relative,\n        preventScrollReset,\n        viewTransition,\n      });\n    };\n\n    return (\n      <form\n        ref={forwardedRef}\n        method={formMethod}\n        action={formAction}\n        onSubmit={reloadDocument ? onSubmit : submitHandler}\n        {...props}\n      />\n    );\n  }\n);\n\nif (__DEV__) {\n  Form.displayName = \"Form\";\n}\n\nexport interface ScrollRestorationProps {\n  getKey?: GetScrollRestorationKeyFunction;\n  storageKey?: string;\n}\n\n/**\n * This component will emulate the browser's scroll restoration on location\n * changes.\n */\nexport function ScrollRestoration({\n  getKey,\n  storageKey,\n}: ScrollRestorationProps) {\n  useScrollRestoration({ getKey, storageKey });\n  return null;\n}\n\nif (__DEV__) {\n  ScrollRestoration.displayName = \"ScrollRestoration\";\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Hooks\n////////////////////////////////////////////////////////////////////////////////\n\nenum DataRouterHook {\n  UseScrollRestoration = \"useScrollRestoration\",\n  UseSubmit = \"useSubmit\",\n  UseSubmitFetcher = \"useSubmitFetcher\",\n  UseFetcher = \"useFetcher\",\n  useViewTransitionState = \"useViewTransitionState\",\n}\n\nenum DataRouterStateHook {\n  UseFetcher = \"useFetcher\",\n  UseFetchers = \"useFetchers\",\n  UseScrollRestoration = \"useScrollRestoration\",\n}\n\n// Internal hooks\n\nfunction getDataRouterConsoleError(\n  hookName: DataRouterHook | DataRouterStateHook\n) {\n  return `${hookName} must be used within a data router.  See https://reactrouter.com/v6/routers/picking-a-router.`;\n}\n\nfunction useDataRouterContext(hookName: DataRouterHook) {\n  let ctx = React.useContext(DataRouterContext);\n  invariant(ctx, getDataRouterConsoleError(hookName));\n  return ctx;\n}\n\nfunction useDataRouterState(hookName: DataRouterStateHook) {\n  let state = React.useContext(DataRouterStateContext);\n  invariant(state, getDataRouterConsoleError(hookName));\n  return state;\n}\n\n// External hooks\n\n/**\n * Handles the click behavior for router `<Link>` components. This is useful if\n * you need to create custom `<Link>` components with the same click behavior we\n * use in our exported `<Link>`.\n */\nexport function useLinkClickHandler<E extends Element = HTMLAnchorElement>(\n  to: To,\n  {\n    target,\n    replace: replaceProp,\n    state,\n    preventScrollReset,\n    relative,\n    viewTransition,\n  }: {\n    target?: React.HTMLAttributeAnchorTarget;\n    replace?: boolean;\n    state?: any;\n    preventScrollReset?: boolean;\n    relative?: RelativeRoutingType;\n    viewTransition?: boolean;\n  } = {}\n): (event: React.MouseEvent<E, MouseEvent>) => void {\n  let navigate = useNavigate();\n  let location = useLocation();\n  let path = useResolvedPath(to, { relative });\n\n  return React.useCallback(\n    (event: React.MouseEvent<E, MouseEvent>) => {\n      if (shouldProcessLinkClick(event, target)) {\n        event.preventDefault();\n\n        // If the URL hasn't changed, a regular <a> will do a replace instead of\n        // a push, so do the same here unless the replace prop is explicitly set\n        let replace =\n          replaceProp !== undefined\n            ? replaceProp\n            : createPath(location) === createPath(path);\n\n        navigate(to, {\n          replace,\n          state,\n          preventScrollReset,\n          relative,\n          viewTransition,\n        });\n      }\n    },\n    [\n      location,\n      navigate,\n      path,\n      replaceProp,\n      state,\n      target,\n      to,\n      preventScrollReset,\n      relative,\n      viewTransition,\n    ]\n  );\n}\n\n/**\n * A convenient wrapper for reading and writing search parameters via the\n * URLSearchParams interface.\n */\nexport function useSearchParams(\n  defaultInit?: URLSearchParamsInit\n): [URLSearchParams, SetURLSearchParams] {\n  warning(\n    typeof URLSearchParams !== \"undefined\",\n    `You cannot use the \\`useSearchParams\\` hook in a browser that does not ` +\n      `support the URLSearchParams API. If you need to support Internet ` +\n      `Explorer 11, we recommend you load a polyfill such as ` +\n      `https://github.com/ungap/url-search-params.`\n  );\n\n  let defaultSearchParamsRef = React.useRef(createSearchParams(defaultInit));\n  let hasSetSearchParamsRef = React.useRef(false);\n\n  let location = useLocation();\n  let searchParams = React.useMemo(\n    () =>\n      // Only merge in the defaults if we haven't yet called setSearchParams.\n      // Once we call that we want those to take precedence, otherwise you can't\n      // remove a param with setSearchParams({}) if it has an initial value\n      getSearchParamsForLocation(\n        location.search,\n        hasSetSearchParamsRef.current ? null : defaultSearchParamsRef.current\n      ),\n    [location.search]\n  );\n\n  let navigate = useNavigate();\n  let setSearchParams = React.useCallback<SetURLSearchParams>(\n    (nextInit, navigateOptions) => {\n      const newSearchParams = createSearchParams(\n        typeof nextInit === \"function\" ? nextInit(searchParams) : nextInit\n      );\n      hasSetSearchParamsRef.current = true;\n      navigate(\"?\" + newSearchParams, navigateOptions);\n    },\n    [navigate, searchParams]\n  );\n\n  return [searchParams, setSearchParams];\n}\n\nexport type SetURLSearchParams = (\n  nextInit?:\n    | URLSearchParamsInit\n    | ((prev: URLSearchParams) => URLSearchParamsInit),\n  navigateOpts?: NavigateOptions\n) => void;\n\n/**\n * Submits a HTML `<form>` to the server without reloading the page.\n */\nexport interface SubmitFunction {\n  (\n    /**\n     * Specifies the `<form>` to be submitted to the server, a specific\n     * `<button>` or `<input type=\"submit\">` to use to submit the form, or some\n     * arbitrary data to submit.\n     *\n     * Note: When using a `<button>` its `name` and `value` will also be\n     * included in the form data that is submitted.\n     */\n    target: SubmitTarget,\n\n    /**\n     * Options that override the `<form>`'s own attributes. Required when\n     * submitting arbitrary data without a backing `<form>`.\n     */\n    options?: SubmitOptions\n  ): void;\n}\n\n/**\n * Submits a fetcher `<form>` to the server without reloading the page.\n */\nexport interface FetcherSubmitFunction {\n  (\n    target: SubmitTarget,\n    // Fetchers cannot replace or set state because they are not navigation events\n    options?: FetcherSubmitOptions\n  ): void;\n}\n\nfunction validateClientSideSubmission() {\n  if (typeof document === \"undefined\") {\n    throw new Error(\n      \"You are calling submit during the server render. \" +\n        \"Try calling submit within a `useEffect` or callback instead.\"\n    );\n  }\n}\n\nlet fetcherId = 0;\nlet getUniqueFetcherId = () => `__${String(++fetcherId)}__`;\n\n/**\n * Returns a function that may be used to programmatically submit a form (or\n * some arbitrary data) to the server.\n */\nexport function useSubmit(): SubmitFunction {\n  let { router } = useDataRouterContext(DataRouterHook.UseSubmit);\n  let { basename } = React.useContext(NavigationContext);\n  let currentRouteId = useRouteId();\n\n  return React.useCallback<SubmitFunction>(\n    (target, options = {}) => {\n      validateClientSideSubmission();\n\n      let { action, method, encType, formData, body } = getFormSubmissionInfo(\n        target,\n        basename\n      );\n\n      if (options.navigate === false) {\n        let key = options.fetcherKey || getUniqueFetcherId();\n        router.fetch(key, currentRouteId, options.action || action, {\n          preventScrollReset: options.preventScrollReset,\n          formData,\n          body,\n          formMethod: options.method || (method as HTMLFormMethod),\n          formEncType: options.encType || (encType as FormEncType),\n          flushSync: options.flushSync,\n        });\n      } else {\n        router.navigate(options.action || action, {\n          preventScrollReset: options.preventScrollReset,\n          formData,\n          body,\n          formMethod: options.method || (method as HTMLFormMethod),\n          formEncType: options.encType || (encType as FormEncType),\n          replace: options.replace,\n          state: options.state,\n          fromRouteId: currentRouteId,\n          flushSync: options.flushSync,\n          viewTransition: options.viewTransition,\n        });\n      }\n    },\n    [router, basename, currentRouteId]\n  );\n}\n\n// v7: Eventually we should deprecate this entirely in favor of using the\n// router method directly?\nexport function useFormAction(\n  action?: string,\n  { relative }: { relative?: RelativeRoutingType } = {}\n): string {\n  let { basename } = React.useContext(NavigationContext);\n  let routeContext = React.useContext(RouteContext);\n  invariant(routeContext, \"useFormAction must be used inside a RouteContext\");\n\n  let [match] = routeContext.matches.slice(-1);\n  // Shallow clone path so we can modify it below, otherwise we modify the\n  // object referenced by useMemo inside useResolvedPath\n  let path = { ...useResolvedPath(action ? action : \".\", { relative }) };\n\n  // If no action was specified, browsers will persist current search params\n  // when determining the path, so match that behavior\n  // https://github.com/remix-run/remix/issues/927\n  let location = useLocation();\n  if (action == null) {\n    // Safe to write to this directly here since if action was undefined, we\n    // would have called useResolvedPath(\".\") which will never include a search\n    path.search = location.search;\n\n    // When grabbing search params from the URL, remove any included ?index param\n    // since it might not apply to our contextual route.  We add it back based\n    // on match.route.index below\n    let params = new URLSearchParams(path.search);\n    let indexValues = params.getAll(\"index\");\n    let hasNakedIndexParam = indexValues.some((v) => v === \"\");\n    if (hasNakedIndexParam) {\n      params.delete(\"index\");\n      indexValues.filter((v) => v).forEach((v) => params.append(\"index\", v));\n      let qs = params.toString();\n      path.search = qs ? `?${qs}` : \"\";\n    }\n  }\n\n  if ((!action || action === \".\") && match.route.index) {\n    path.search = path.search\n      ? path.search.replace(/^\\?/, \"?index&\")\n      : \"?index\";\n  }\n\n  // If we're operating within a basename, prepend it to the pathname prior\n  // to creating the form action.  If this is a root navigation, then just use\n  // the raw basename which allows the basename to have full control over the\n  // presence of a trailing slash on root actions\n  if (basename !== \"/\") {\n    path.pathname =\n      path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n  }\n\n  return createPath(path);\n}\n\nexport type FetcherWithComponents<TData> = Fetcher<TData> & {\n  Form: React.ForwardRefExoticComponent<\n    FetcherFormProps & React.RefAttributes<HTMLFormElement>\n  >;\n  submit: FetcherSubmitFunction;\n  load: (href: string, opts?: { flushSync?: boolean }) => void;\n};\n\n// TODO: (v7) Change the useFetcher generic default from `any` to `unknown`\n\n/**\n * Interacts with route loaders and actions without causing a navigation. Great\n * for any interaction that stays on the same page.\n */\nexport function useFetcher<TData = any>({\n  key,\n}: { key?: string } = {}): FetcherWithComponents<TData> {\n  let { router } = useDataRouterContext(DataRouterHook.UseFetcher);\n  let state = useDataRouterState(DataRouterStateHook.UseFetcher);\n  let fetcherData = React.useContext(FetchersContext);\n  let route = React.useContext(RouteContext);\n  let routeId = route.matches[route.matches.length - 1]?.route.id;\n\n  invariant(fetcherData, `useFetcher must be used inside a FetchersContext`);\n  invariant(route, `useFetcher must be used inside a RouteContext`);\n  invariant(\n    routeId != null,\n    `useFetcher can only be used on routes that contain a unique \"id\"`\n  );\n\n  // Fetcher key handling\n  // OK to call conditionally to feature detect `useId`\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  let defaultKey = useIdImpl ? useIdImpl() : \"\";\n  let [fetcherKey, setFetcherKey] = React.useState<string>(key || defaultKey);\n  if (key && key !== fetcherKey) {\n    setFetcherKey(key);\n  } else if (!fetcherKey) {\n    // We will only fall through here when `useId` is not available\n    setFetcherKey(getUniqueFetcherId());\n  }\n\n  // Registration/cleanup\n  React.useEffect(() => {\n    router.getFetcher(fetcherKey);\n    return () => {\n      // Tell the router we've unmounted - if v7_fetcherPersist is enabled this\n      // will not delete immediately but instead queue up a delete after the\n      // fetcher returns to an `idle` state\n      router.deleteFetcher(fetcherKey);\n    };\n  }, [router, fetcherKey]);\n\n  // Fetcher additions\n  let load = React.useCallback(\n    (href: string, opts?: { flushSync?: boolean }) => {\n      invariant(routeId, \"No routeId available for fetcher.load()\");\n      router.fetch(fetcherKey, routeId, href, opts);\n    },\n    [fetcherKey, routeId, router]\n  );\n\n  let submitImpl = useSubmit();\n  let submit = React.useCallback<FetcherSubmitFunction>(\n    (target, opts) => {\n      submitImpl(target, {\n        ...opts,\n        navigate: false,\n        fetcherKey,\n      });\n    },\n    [fetcherKey, submitImpl]\n  );\n\n  let FetcherForm = React.useMemo(() => {\n    let FetcherForm = React.forwardRef<HTMLFormElement, FetcherFormProps>(\n      (props, ref) => {\n        return (\n          <Form {...props} navigate={false} fetcherKey={fetcherKey} ref={ref} />\n        );\n      }\n    );\n    if (__DEV__) {\n      FetcherForm.displayName = \"fetcher.Form\";\n    }\n    return FetcherForm;\n  }, [fetcherKey]);\n\n  // Exposed FetcherWithComponents\n  let fetcher = state.fetchers.get(fetcherKey) || IDLE_FETCHER;\n  let data = fetcherData.get(fetcherKey);\n  let fetcherWithComponents = React.useMemo(\n    () => ({\n      Form: FetcherForm,\n      submit,\n      load,\n      ...fetcher,\n      data,\n    }),\n    [FetcherForm, submit, load, fetcher, data]\n  );\n\n  return fetcherWithComponents;\n}\n\n/**\n * Provides all fetchers currently on the page. Useful for layouts and parent\n * routes that need to provide pending/optimistic UI regarding the fetch.\n */\nexport function useFetchers(): (Fetcher & { key: string })[] {\n  let state = useDataRouterState(DataRouterStateHook.UseFetchers);\n  return Array.from(state.fetchers.entries()).map(([key, fetcher]) => ({\n    ...fetcher,\n    key,\n  }));\n}\n\nconst SCROLL_RESTORATION_STORAGE_KEY = \"react-router-scroll-positions\";\nlet savedScrollPositions: Record<string, number> = {};\n\n/**\n * When rendered inside a RouterProvider, will restore scroll positions on navigations\n */\nfunction useScrollRestoration({\n  getKey,\n  storageKey,\n}: {\n  getKey?: GetScrollRestorationKeyFunction;\n  storageKey?: string;\n} = {}) {\n  let { router } = useDataRouterContext(DataRouterHook.UseScrollRestoration);\n  let { restoreScrollPosition, preventScrollReset } = useDataRouterState(\n    DataRouterStateHook.UseScrollRestoration\n  );\n  let { basename } = React.useContext(NavigationContext);\n  let location = useLocation();\n  let matches = useMatches();\n  let navigation = useNavigation();\n\n  // Trigger manual scroll restoration while we're active\n  React.useEffect(() => {\n    window.history.scrollRestoration = \"manual\";\n    return () => {\n      window.history.scrollRestoration = \"auto\";\n    };\n  }, []);\n\n  // Save positions on pagehide\n  usePageHide(\n    React.useCallback(() => {\n      if (navigation.state === \"idle\") {\n        let key = (getKey ? getKey(location, matches) : null) || location.key;\n        savedScrollPositions[key] = window.scrollY;\n      }\n      try {\n        sessionStorage.setItem(\n          storageKey || SCROLL_RESTORATION_STORAGE_KEY,\n          JSON.stringify(savedScrollPositions)\n        );\n      } catch (error) {\n        warning(\n          false,\n          `Failed to save scroll positions in sessionStorage, <ScrollRestoration /> will not work properly (${error}).`\n        );\n      }\n      window.history.scrollRestoration = \"auto\";\n    }, [storageKey, getKey, navigation.state, location, matches])\n  );\n\n  // Read in any saved scroll locations\n  if (typeof document !== \"undefined\") {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useLayoutEffect(() => {\n      try {\n        let sessionPositions = sessionStorage.getItem(\n          storageKey || SCROLL_RESTORATION_STORAGE_KEY\n        );\n        if (sessionPositions) {\n          savedScrollPositions = JSON.parse(sessionPositions);\n        }\n      } catch (e) {\n        // no-op, use default empty object\n      }\n    }, [storageKey]);\n\n    // Enable scroll restoration in the router\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useLayoutEffect(() => {\n      let getKeyWithoutBasename: GetScrollRestorationKeyFunction | undefined =\n        getKey && basename !== \"/\"\n          ? (location, matches) =>\n              getKey(\n                // Strip the basename to match useLocation()\n                {\n                  ...location,\n                  pathname:\n                    stripBasename(location.pathname, basename) ||\n                    location.pathname,\n                },\n                matches\n              )\n          : getKey;\n      let disableScrollRestoration = router?.enableScrollRestoration(\n        savedScrollPositions,\n        () => window.scrollY,\n        getKeyWithoutBasename\n      );\n      return () => disableScrollRestoration && disableScrollRestoration();\n    }, [router, basename, getKey]);\n\n    // Restore scrolling when state.restoreScrollPosition changes\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useLayoutEffect(() => {\n      // Explicit false means don't do anything (used for submissions)\n      if (restoreScrollPosition === false) {\n        return;\n      }\n\n      // been here before, scroll to it\n      if (typeof restoreScrollPosition === \"number\") {\n        window.scrollTo(0, restoreScrollPosition);\n        return;\n      }\n\n      // try to scroll to the hash\n      if (location.hash) {\n        let el = document.getElementById(\n          decodeURIComponent(location.hash.slice(1))\n        );\n        if (el) {\n          el.scrollIntoView();\n          return;\n        }\n      }\n\n      // Don't reset if this navigation opted out\n      if (preventScrollReset === true) {\n        return;\n      }\n\n      // otherwise go to the top on new locations\n      window.scrollTo(0, 0);\n    }, [location, restoreScrollPosition, preventScrollReset]);\n  }\n}\n\nexport { useScrollRestoration as UNSAFE_useScrollRestoration };\n\n/**\n * Setup a callback to be fired on the window's `beforeunload` event. This is\n * useful for saving some data to `window.localStorage` just before the page\n * refreshes.\n *\n * Note: The `callback` argument should be a function created with\n * `React.useCallback()`.\n */\nexport function useBeforeUnload(\n  callback: (event: BeforeUnloadEvent) => any,\n  options?: { capture?: boolean }\n): void {\n  let { capture } = options || {};\n  React.useEffect(() => {\n    let opts = capture != null ? { capture } : undefined;\n    window.addEventListener(\"beforeunload\", callback, opts);\n    return () => {\n      window.removeEventListener(\"beforeunload\", callback, opts);\n    };\n  }, [callback, capture]);\n}\n\n/**\n * Setup a callback to be fired on the window's `pagehide` event. This is\n * useful for saving some data to `window.localStorage` just before the page\n * refreshes.  This event is better supported than beforeunload across browsers.\n *\n * Note: The `callback` argument should be a function created with\n * `React.useCallback()`.\n */\nfunction usePageHide(\n  callback: (event: PageTransitionEvent) => any,\n  options?: { capture?: boolean }\n): void {\n  let { capture } = options || {};\n  React.useEffect(() => {\n    let opts = capture != null ? { capture } : undefined;\n    window.addEventListener(\"pagehide\", callback, opts);\n    return () => {\n      window.removeEventListener(\"pagehide\", callback, opts);\n    };\n  }, [callback, capture]);\n}\n\n/**\n * Wrapper around useBlocker to show a window.confirm prompt to users instead\n * of building a custom UI with useBlocker.\n *\n * Warning: This has *a lot of rough edges* and behaves very differently (and\n * very incorrectly in some cases) across browsers if user click addition\n * back/forward navigations while the confirm is open.  Use at your own risk.\n */\nfunction usePrompt({\n  when,\n  message,\n}: {\n  when: boolean | BlockerFunction;\n  message: string;\n}) {\n  let blocker = useBlocker(when);\n\n  React.useEffect(() => {\n    if (blocker.state === \"blocked\") {\n      let proceed = window.confirm(message);\n      if (proceed) {\n        // This timeout is needed to avoid a weird \"race\" on POP navigations\n        // between the `window.history` revert navigation and the result of\n        // `window.confirm`\n        setTimeout(blocker.proceed, 0);\n      } else {\n        blocker.reset();\n      }\n    }\n  }, [blocker, message]);\n\n  React.useEffect(() => {\n    if (blocker.state === \"blocked\" && !when) {\n      blocker.reset();\n    }\n  }, [blocker, when]);\n}\n\nexport { usePrompt as unstable_usePrompt };\n\n/**\n * Return a boolean indicating if there is an active view transition to the\n * given href.  You can use this value to render CSS classes or viewTransitionName\n * styles onto your elements\n *\n * @param href The destination href\n * @param [opts.relative] Relative routing type (\"route\" | \"path\")\n */\nfunction useViewTransitionState(\n  to: To,\n  opts: { relative?: RelativeRoutingType } = {}\n) {\n  let vtContext = React.useContext(ViewTransitionContext);\n\n  invariant(\n    vtContext != null,\n    \"`useViewTransitionState` must be used within `react-router-dom`'s `RouterProvider`.  \" +\n      \"Did you accidentally import `RouterProvider` from `react-router`?\"\n  );\n\n  let { basename } = useDataRouterContext(\n    DataRouterHook.useViewTransitionState\n  );\n  let path = useResolvedPath(to, { relative: opts.relative });\n  if (!vtContext.isTransitioning) {\n    return false;\n  }\n\n  let currentPath =\n    stripBasename(vtContext.currentLocation.pathname, basename) ||\n    vtContext.currentLocation.pathname;\n  let nextPath =\n    stripBasename(vtContext.nextLocation.pathname, basename) ||\n    vtContext.nextLocation.pathname;\n\n  // Transition is active if we're going to or coming from the indicated\n  // destination.  This ensures that other PUSH navigations that reverse\n  // an indicated transition apply.  I.e., on the list view you have:\n  //\n  //   <NavLink to=\"/details/1\" viewTransition>\n  //\n  // If you click the breadcrumb back to the list view:\n  //\n  //   <NavLink to=\"/list\" viewTransition>\n  //\n  // We should apply the transition because it's indicated as active going\n  // from /list -> /details/1 and therefore should be active on the reverse\n  // (even though this isn't strictly a POP reverse)\n  return (\n    matchPath(path.pathname, nextPath) != null ||\n    matchPath(path.pathname, currentPath) != null\n  );\n}\n\nexport { useViewTransitionState as useViewTransitionState };\n\n//#endregion\n","import * as React from 'react';\nconst SelectableContext = /*#__PURE__*/React.createContext(null);\nexport const makeEventKey = (eventKey, href = null) => {\n  if (eventKey != null) return String(eventKey);\n  return href || null;\n};\nexport default SelectableContext;","function _extends() {\n  return _extends = Object.assign ? Object.assign.bind() : function (n) {\n    for (var e = 1; e < arguments.length; e++) {\n      var t = arguments[e];\n      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);\n    }\n    return n;\n  }, _extends.apply(null, arguments);\n}\nexport { _extends as default };","function _objectWithoutPropertiesLoose(r, e) {\n  if (null == r) return {};\n  var t = {};\n  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {\n    if (e.includes(n)) continue;\n    t[n] = r[n];\n  }\n  return t;\n}\nexport { _objectWithoutPropertiesLoose as default };","import invariant from 'invariant';\n\nvar noop = function noop() {};\n\nfunction readOnlyPropType(handler, name) {\n  return function (props, propName) {\n    if (props[propName] !== undefined) {\n      if (!props[handler]) {\n        return new Error(\"You have provided a `\" + propName + \"` prop to `\" + name + \"` \" + (\"without an `\" + handler + \"` handler prop. This will render a read-only field. \") + (\"If the field should be mutable use `\" + defaultKey(propName) + \"`. \") + (\"Otherwise, set `\" + handler + \"`.\"));\n      }\n    }\n  };\n}\n\nexport function uncontrolledPropTypes(controlledValues, displayName) {\n  var propTypes = {};\n  Object.keys(controlledValues).forEach(function (prop) {\n    // add default propTypes for folks that use runtime checks\n    propTypes[defaultKey(prop)] = noop;\n\n    if (process.env.NODE_ENV !== 'production') {\n      var handler = controlledValues[prop];\n      !(typeof handler === 'string' && handler.trim().length) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Uncontrollable - [%s]: the prop `%s` needs a valid handler key name in order to make it uncontrollable', displayName, prop) : invariant(false) : void 0;\n      propTypes[prop] = readOnlyPropType(handler, displayName);\n    }\n  });\n  return propTypes;\n}\nexport function isProp(props, prop) {\n  return props[prop] !== undefined;\n}\nexport function defaultKey(key) {\n  return 'default' + key.charAt(0).toUpperCase() + key.substr(1);\n}\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n */\n\nexport function canAcceptRef(component) {\n  return !!component && (typeof component !== 'function' || component.prototype && component.prototype.isReactComponent);\n}","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\n\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return typeof key === \"symbol\" ? key : String(key); }\n\nfunction _toPrimitive(input, hint) { if (typeof input !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (typeof res !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\n\nimport { useCallback, useRef, useState } from 'react';\nimport * as Utils from './utils';\n\nfunction useUncontrolledProp(propValue, defaultValue, handler) {\n  var wasPropRef = useRef(propValue !== undefined);\n\n  var _useState = useState(defaultValue),\n      stateValue = _useState[0],\n      setState = _useState[1];\n\n  var isProp = propValue !== undefined;\n  var wasProp = wasPropRef.current;\n  wasPropRef.current = isProp;\n  /**\n   * If a prop switches from controlled to Uncontrolled\n   * reset its value to the defaultValue\n   */\n\n  if (!isProp && wasProp && stateValue !== defaultValue) {\n    setState(defaultValue);\n  }\n\n  return [isProp ? propValue : stateValue, useCallback(function (value) {\n    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      args[_key - 1] = arguments[_key];\n    }\n\n    if (handler) handler.apply(void 0, [value].concat(args));\n    setState(value);\n  }, [handler])];\n}\n\nexport { useUncontrolledProp };\nexport default function useUncontrolled(props, config) {\n  return Object.keys(config).reduce(function (result, fieldName) {\n    var _extends2;\n\n    var _ref = result,\n        defaultValue = _ref[Utils.defaultKey(fieldName)],\n        propsValue = _ref[fieldName],\n        rest = _objectWithoutPropertiesLoose(_ref, [Utils.defaultKey(fieldName), fieldName].map(_toPropertyKey));\n\n    var handlerName = config[fieldName];\n\n    var _useUncontrolledProp = useUncontrolledProp(propsValue, defaultValue, props[handlerName]),\n        value = _useUncontrolledProp[0],\n        handler = _useUncontrolledProp[1];\n\n    return _extends({}, rest, (_extends2 = {}, _extends2[fieldName] = value, _extends2[handlerName] = handler, _extends2));\n  }, props);\n}","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nfunction componentWillMount() {\n  // Call this.constructor.gDSFP to support sub-classes.\n  var state = this.constructor.getDerivedStateFromProps(this.props, this.state);\n  if (state !== null && state !== undefined) {\n    this.setState(state);\n  }\n}\n\nfunction componentWillReceiveProps(nextProps) {\n  // Call this.constructor.gDSFP to support sub-classes.\n  // Use the setState() updater to ensure state isn't stale in certain edge cases.\n  function updater(prevState) {\n    var state = this.constructor.getDerivedStateFromProps(nextProps, prevState);\n    return state !== null && state !== undefined ? state : null;\n  }\n  // Binding \"this\" is important for shallow renderer support.\n  this.setState(updater.bind(this));\n}\n\nfunction componentWillUpdate(nextProps, nextState) {\n  try {\n    var prevProps = this.props;\n    var prevState = this.state;\n    this.props = nextProps;\n    this.state = nextState;\n    this.__reactInternalSnapshotFlag = true;\n    this.__reactInternalSnapshot = this.getSnapshotBeforeUpdate(\n      prevProps,\n      prevState\n    );\n  } finally {\n    this.props = prevProps;\n    this.state = prevState;\n  }\n}\n\n// React may warn about cWM/cWRP/cWU methods being deprecated.\n// Add a flag to suppress these warnings for this special case.\ncomponentWillMount.__suppressDeprecationWarning = true;\ncomponentWillReceiveProps.__suppressDeprecationWarning = true;\ncomponentWillUpdate.__suppressDeprecationWarning = true;\n\nfunction polyfill(Component) {\n  var prototype = Component.prototype;\n\n  if (!prototype || !prototype.isReactComponent) {\n    throw new Error('Can only polyfill class components');\n  }\n\n  if (\n    typeof Component.getDerivedStateFromProps !== 'function' &&\n    typeof prototype.getSnapshotBeforeUpdate !== 'function'\n  ) {\n    return Component;\n  }\n\n  // If new component APIs are defined, \"unsafe\" lifecycles won't be called.\n  // Error if any of these lifecycles are present,\n  // Because they would work differently between older and newer (16.3+) versions of React.\n  var foundWillMountName = null;\n  var foundWillReceivePropsName = null;\n  var foundWillUpdateName = null;\n  if (typeof prototype.componentWillMount === 'function') {\n    foundWillMountName = 'componentWillMount';\n  } else if (typeof prototype.UNSAFE_componentWillMount === 'function') {\n    foundWillMountName = 'UNSAFE_componentWillMount';\n  }\n  if (typeof prototype.componentWillReceiveProps === 'function') {\n    foundWillReceivePropsName = 'componentWillReceiveProps';\n  } else if (typeof prototype.UNSAFE_componentWillReceiveProps === 'function') {\n    foundWillReceivePropsName = 'UNSAFE_componentWillReceiveProps';\n  }\n  if (typeof prototype.componentWillUpdate === 'function') {\n    foundWillUpdateName = 'componentWillUpdate';\n  } else if (typeof prototype.UNSAFE_componentWillUpdate === 'function') {\n    foundWillUpdateName = 'UNSAFE_componentWillUpdate';\n  }\n  if (\n    foundWillMountName !== null ||\n    foundWillReceivePropsName !== null ||\n    foundWillUpdateName !== null\n  ) {\n    var componentName = Component.displayName || Component.name;\n    var newApiName =\n      typeof Component.getDerivedStateFromProps === 'function'\n        ? 'getDerivedStateFromProps()'\n        : 'getSnapshotBeforeUpdate()';\n\n    throw Error(\n      'Unsafe legacy lifecycles will not be called for components using new component APIs.\\n\\n' +\n        componentName +\n        ' uses ' +\n        newApiName +\n        ' but also contains the following legacy lifecycles:' +\n        (foundWillMountName !== null ? '\\n  ' + foundWillMountName : '') +\n        (foundWillReceivePropsName !== null\n          ? '\\n  ' + foundWillReceivePropsName\n          : '') +\n        (foundWillUpdateName !== null ? '\\n  ' + foundWillUpdateName : '') +\n        '\\n\\nThe above lifecycles should be removed. Learn more about this warning here:\\n' +\n        'https://fb.me/react-async-component-lifecycle-hooks'\n    );\n  }\n\n  // React <= 16.2 does not support static getDerivedStateFromProps.\n  // As a workaround, use cWM and cWRP to invoke the new static lifecycle.\n  // Newer versions of React will ignore these lifecycles if gDSFP exists.\n  if (typeof Component.getDerivedStateFromProps === 'function') {\n    prototype.componentWillMount = componentWillMount;\n    prototype.componentWillReceiveProps = componentWillReceiveProps;\n  }\n\n  // React <= 16.2 does not support getSnapshotBeforeUpdate.\n  // As a workaround, use cWU to invoke the new lifecycle.\n  // Newer versions of React will ignore that lifecycle if gSBU exists.\n  if (typeof prototype.getSnapshotBeforeUpdate === 'function') {\n    if (typeof prototype.componentDidUpdate !== 'function') {\n      throw new Error(\n        'Cannot polyfill getSnapshotBeforeUpdate() for components that do not define componentDidUpdate() on the prototype'\n      );\n    }\n\n    prototype.componentWillUpdate = componentWillUpdate;\n\n    var componentDidUpdate = prototype.componentDidUpdate;\n\n    prototype.componentDidUpdate = function componentDidUpdatePolyfill(\n      prevProps,\n      prevState,\n      maybeSnapshot\n    ) {\n      // 16.3+ will not execute our will-update method;\n      // It will pass a snapshot value to did-update though.\n      // Older versions will require our polyfilled will-update value.\n      // We need to handle both cases, but can't just check for the presence of \"maybeSnapshot\",\n      // Because for <= 15.x versions this might be a \"prevContext\" object.\n      // We also can't just check \"__reactInternalSnapshot\",\n      // Because get-snapshot might return a falsy value.\n      // So check for the explicit __reactInternalSnapshotFlag flag to determine behavior.\n      var snapshot = this.__reactInternalSnapshotFlag\n        ? this.__reactInternalSnapshot\n        : maybeSnapshot;\n\n      componentDidUpdate.call(this, prevProps, prevState, snapshot);\n    };\n  }\n\n  return Component;\n}\n\nexport { polyfill };\n","\"use client\";\n\nimport * as React from 'react';\nimport { useContext, useMemo } from 'react';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport const DEFAULT_BREAKPOINTS = ['xxl', 'xl', 'lg', 'md', 'sm', 'xs'];\nexport const DEFAULT_MIN_BREAKPOINT = 'xs';\nconst ThemeContext = /*#__PURE__*/React.createContext({\n  prefixes: {},\n  breakpoints: DEFAULT_BREAKPOINTS,\n  minBreakpoint: DEFAULT_MIN_BREAKPOINT\n});\nconst {\n  Consumer,\n  Provider\n} = ThemeContext;\nfunction ThemeProvider({\n  prefixes = {},\n  breakpoints = DEFAULT_BREAKPOINTS,\n  minBreakpoint = DEFAULT_MIN_BREAKPOINT,\n  dir,\n  children\n}) {\n  const contextValue = useMemo(() => ({\n    prefixes: {\n      ...prefixes\n    },\n    breakpoints,\n    minBreakpoint,\n    dir\n  }), [prefixes, breakpoints, minBreakpoint, dir]);\n  return /*#__PURE__*/_jsx(Provider, {\n    value: contextValue,\n    children: children\n  });\n}\nexport function useBootstrapPrefix(prefix, defaultPrefix) {\n  const {\n    prefixes\n  } = useContext(ThemeContext);\n  return prefix || prefixes[defaultPrefix] || defaultPrefix;\n}\nexport function useBootstrapBreakpoints() {\n  const {\n    breakpoints\n  } = useContext(ThemeContext);\n  return breakpoints;\n}\nexport function useBootstrapMinBreakpoint() {\n  const {\n    minBreakpoint\n  } = useContext(ThemeContext);\n  return minBreakpoint;\n}\nexport function useIsRTL() {\n  const {\n    dir\n  } = useContext(ThemeContext);\n  return dir === 'rtl';\n}\nfunction createBootstrapComponent(Component, opts) {\n  if (typeof opts === 'string') opts = {\n    prefix: opts\n  };\n  const isClassy = Component.prototype && Component.prototype.isReactComponent;\n  // If it's a functional component make sure we don't break it with a ref\n  const {\n    prefix,\n    forwardRefAs = isClassy ? 'ref' : 'innerRef'\n  } = opts;\n  const Wrapped = /*#__PURE__*/React.forwardRef(({\n    ...props\n  }, ref) => {\n    props[forwardRefAs] = ref;\n    const bsPrefix = useBootstrapPrefix(props.bsPrefix, prefix);\n    return /*#__PURE__*/_jsx(Component, {\n      ...props,\n      bsPrefix: bsPrefix\n    });\n  });\n  Wrapped.displayName = `Bootstrap(${Component.displayName || Component.name})`;\n  return Wrapped;\n}\nexport { createBootstrapComponent, Consumer as ThemeConsumer };\nexport default ThemeProvider;","\"use client\";\n\nimport classNames from 'classnames';\nimport * as React from 'react';\nimport { useBootstrapPrefix } from './ThemeProvider';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst NavbarBrand = /*#__PURE__*/React.forwardRef(({\n  bsPrefix,\n  className,\n  as,\n  ...props\n}, ref) => {\n  bsPrefix = useBootstrapPrefix(bsPrefix, 'navbar-brand');\n  const Component = as || (props.href ? 'a' : 'span');\n  return /*#__PURE__*/_jsx(Component, {\n    ...props,\n    ref: ref,\n    className: classNames(className, bsPrefix)\n  });\n});\nNavbarBrand.displayName = 'NavbarBrand';\nexport default NavbarBrand;","/**\n * Returns the owner document of a given element.\n * \n * @param node the element\n */\nexport default function ownerDocument(node) {\n  return node && node.ownerDocument || document;\n}","import ownerWindow from './ownerWindow';\n/**\n * Returns one or all computed style properties of an element.\n * \n * @param node the element\n * @param psuedoElement the style property\n */\n\nexport default function getComputedStyle(node, psuedoElement) {\n  return ownerWindow(node).getComputedStyle(node, psuedoElement);\n}","import ownerDocument from './ownerDocument';\n/**\n * Returns the owner window of a given element.\n * \n * @param node the element\n */\n\nexport default function ownerWindow(node) {\n  var doc = ownerDocument(node);\n  return doc && doc.defaultView || window;\n}","var rUpper = /([A-Z])/g;\nexport default function hyphenate(string) {\n  return string.replace(rUpper, '-$1').toLowerCase();\n}","/**\n * Copyright 2013-2014, Facebook, Inc.\n * All rights reserved.\n * https://github.com/facebook/react/blob/2aeb8a2a6beb00617a4217f7f8284924fa2ad819/src/vendor/core/hyphenateStyleName.js\n */\nimport hyphenate from './hyphenate';\nvar msPattern = /^ms-/;\nexport default function hyphenateStyleName(string) {\n  return hyphenate(string).replace(msPattern, '-ms-');\n}","var supportedTransforms = /^((translate|rotate|scale)(X|Y|Z|3d)?|matrix(3d)?|perspective|skew(X|Y)?)$/i;\nexport default function isTransform(value) {\n  return !!(value && supportedTransforms.test(value));\n}","import getComputedStyle from './getComputedStyle';\nimport hyphenate from './hyphenateStyle';\nimport isTransform from './isTransform';\n\nfunction style(node, property) {\n  var css = '';\n  var transforms = '';\n\n  if (typeof property === 'string') {\n    return node.style.getPropertyValue(hyphenate(property)) || getComputedStyle(node).getPropertyValue(hyphenate(property));\n  }\n\n  Object.keys(property).forEach(function (key) {\n    var value = property[key];\n\n    if (!value && value !== 0) {\n      node.style.removeProperty(hyphenate(key));\n    } else if (isTransform(key)) {\n      transforms += key + \"(\" + value + \") \";\n    } else {\n      css += hyphenate(key) + \": \" + value + \";\";\n    }\n  });\n\n  if (transforms) {\n    css += \"transform: \" + transforms + \";\";\n  }\n\n  node.style.cssText += \";\" + css;\n}\n\nexport default style;","function _setPrototypeOf(t, e) {\n  return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {\n    return t.__proto__ = e, t;\n  }, _setPrototypeOf(t, e);\n}\nexport { _setPrototypeOf as default };","export default {\n  disabled: false\n};","import React from 'react';\nexport default React.createContext(null);","export var forceReflow = function forceReflow(node) {\n  return node.scrollTop;\n};","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _inheritsLoose from \"@babel/runtime/helpers/esm/inheritsLoose\";\nimport PropTypes from 'prop-types';\nimport React from 'react';\nimport ReactDOM from 'react-dom';\nimport config from './config';\nimport { timeoutsShape } from './utils/PropTypes';\nimport TransitionGroupContext from './TransitionGroupContext';\nimport { forceReflow } from './utils/reflow';\nexport var UNMOUNTED = 'unmounted';\nexport var EXITED = 'exited';\nexport var ENTERING = 'entering';\nexport var ENTERED = 'entered';\nexport var EXITING = 'exiting';\n/**\n * The Transition component lets you describe a transition from one component\n * state to another _over time_ with a simple declarative API. Most commonly\n * it's used to animate the mounting and unmounting of a component, but can also\n * be used to describe in-place transition states as well.\n *\n * ---\n *\n * **Note**: `Transition` is a platform-agnostic base component. If you're using\n * transitions in CSS, you'll probably want to use\n * [`CSSTransition`](https://reactcommunity.org/react-transition-group/css-transition)\n * instead. It inherits all the features of `Transition`, but contains\n * additional features necessary to play nice with CSS transitions (hence the\n * name of the component).\n *\n * ---\n *\n * By default the `Transition` component does not alter the behavior of the\n * component it renders, it only tracks \"enter\" and \"exit\" states for the\n * components. It's up to you to give meaning and effect to those states. For\n * example we can add styles to a component when it enters or exits:\n *\n * ```jsx\n * import { Transition } from 'react-transition-group';\n *\n * const duration = 300;\n *\n * const defaultStyle = {\n *   transition: `opacity ${duration}ms ease-in-out`,\n *   opacity: 0,\n * }\n *\n * const transitionStyles = {\n *   entering: { opacity: 1 },\n *   entered:  { opacity: 1 },\n *   exiting:  { opacity: 0 },\n *   exited:  { opacity: 0 },\n * };\n *\n * const Fade = ({ in: inProp }) => (\n *   <Transition in={inProp} timeout={duration}>\n *     {state => (\n *       <div style={{\n *         ...defaultStyle,\n *         ...transitionStyles[state]\n *       }}>\n *         I'm a fade Transition!\n *       </div>\n *     )}\n *   </Transition>\n * );\n * ```\n *\n * There are 4 main states a Transition can be in:\n *  - `'entering'`\n *  - `'entered'`\n *  - `'exiting'`\n *  - `'exited'`\n *\n * Transition state is toggled via the `in` prop. When `true` the component\n * begins the \"Enter\" stage. During this stage, the component will shift from\n * its current transition state, to `'entering'` for the duration of the\n * transition and then to the `'entered'` stage once it's complete. Let's take\n * the following example (we'll use the\n * [useState](https://reactjs.org/docs/hooks-reference.html#usestate) hook):\n *\n * ```jsx\n * function App() {\n *   const [inProp, setInProp] = useState(false);\n *   return (\n *     <div>\n *       <Transition in={inProp} timeout={500}>\n *         {state => (\n *           // ...\n *         )}\n *       </Transition>\n *       <button onClick={() => setInProp(true)}>\n *         Click to Enter\n *       </button>\n *     </div>\n *   );\n * }\n * ```\n *\n * When the button is clicked the component will shift to the `'entering'` state\n * and stay there for 500ms (the value of `timeout`) before it finally switches\n * to `'entered'`.\n *\n * When `in` is `false` the same thing happens except the state moves from\n * `'exiting'` to `'exited'`.\n */\n\nvar Transition = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(Transition, _React$Component);\n\n  function Transition(props, context) {\n    var _this;\n\n    _this = _React$Component.call(this, props, context) || this;\n    var parentGroup = context; // In the context of a TransitionGroup all enters are really appears\n\n    var appear = parentGroup && !parentGroup.isMounting ? props.enter : props.appear;\n    var initialStatus;\n    _this.appearStatus = null;\n\n    if (props.in) {\n      if (appear) {\n        initialStatus = EXITED;\n        _this.appearStatus = ENTERING;\n      } else {\n        initialStatus = ENTERED;\n      }\n    } else {\n      if (props.unmountOnExit || props.mountOnEnter) {\n        initialStatus = UNMOUNTED;\n      } else {\n        initialStatus = EXITED;\n      }\n    }\n\n    _this.state = {\n      status: initialStatus\n    };\n    _this.nextCallback = null;\n    return _this;\n  }\n\n  Transition.getDerivedStateFromProps = function getDerivedStateFromProps(_ref, prevState) {\n    var nextIn = _ref.in;\n\n    if (nextIn && prevState.status === UNMOUNTED) {\n      return {\n        status: EXITED\n      };\n    }\n\n    return null;\n  } // getSnapshotBeforeUpdate(prevProps) {\n  //   let nextStatus = null\n  //   if (prevProps !== this.props) {\n  //     const { status } = this.state\n  //     if (this.props.in) {\n  //       if (status !== ENTERING && status !== ENTERED) {\n  //         nextStatus = ENTERING\n  //       }\n  //     } else {\n  //       if (status === ENTERING || status === ENTERED) {\n  //         nextStatus = EXITING\n  //       }\n  //     }\n  //   }\n  //   return { nextStatus }\n  // }\n  ;\n\n  var _proto = Transition.prototype;\n\n  _proto.componentDidMount = function componentDidMount() {\n    this.updateStatus(true, this.appearStatus);\n  };\n\n  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {\n    var nextStatus = null;\n\n    if (prevProps !== this.props) {\n      var status = this.state.status;\n\n      if (this.props.in) {\n        if (status !== ENTERING && status !== ENTERED) {\n          nextStatus = ENTERING;\n        }\n      } else {\n        if (status === ENTERING || status === ENTERED) {\n          nextStatus = EXITING;\n        }\n      }\n    }\n\n    this.updateStatus(false, nextStatus);\n  };\n\n  _proto.componentWillUnmount = function componentWillUnmount() {\n    this.cancelNextCallback();\n  };\n\n  _proto.getTimeouts = function getTimeouts() {\n    var timeout = this.props.timeout;\n    var exit, enter, appear;\n    exit = enter = appear = timeout;\n\n    if (timeout != null && typeof timeout !== 'number') {\n      exit = timeout.exit;\n      enter = timeout.enter; // TODO: remove fallback for next major\n\n      appear = timeout.appear !== undefined ? timeout.appear : enter;\n    }\n\n    return {\n      exit: exit,\n      enter: enter,\n      appear: appear\n    };\n  };\n\n  _proto.updateStatus = function updateStatus(mounting, nextStatus) {\n    if (mounting === void 0) {\n      mounting = false;\n    }\n\n    if (nextStatus !== null) {\n      // nextStatus will always be ENTERING or EXITING.\n      this.cancelNextCallback();\n\n      if (nextStatus === ENTERING) {\n        if (this.props.unmountOnExit || this.props.mountOnEnter) {\n          var node = this.props.nodeRef ? this.props.nodeRef.current : ReactDOM.findDOMNode(this); // https://github.com/reactjs/react-transition-group/pull/749\n          // With unmountOnExit or mountOnEnter, the enter animation should happen at the transition between `exited` and `entering`.\n          // To make the animation happen,  we have to separate each rendering and avoid being processed as batched.\n\n          if (node) forceReflow(node);\n        }\n\n        this.performEnter(mounting);\n      } else {\n        this.performExit();\n      }\n    } else if (this.props.unmountOnExit && this.state.status === EXITED) {\n      this.setState({\n        status: UNMOUNTED\n      });\n    }\n  };\n\n  _proto.performEnter = function performEnter(mounting) {\n    var _this2 = this;\n\n    var enter = this.props.enter;\n    var appearing = this.context ? this.context.isMounting : mounting;\n\n    var _ref2 = this.props.nodeRef ? [appearing] : [ReactDOM.findDOMNode(this), appearing],\n        maybeNode = _ref2[0],\n        maybeAppearing = _ref2[1];\n\n    var timeouts = this.getTimeouts();\n    var enterTimeout = appearing ? timeouts.appear : timeouts.enter; // no enter animation skip right to ENTERED\n    // if we are mounting and running this it means appear _must_ be set\n\n    if (!mounting && !enter || config.disabled) {\n      this.safeSetState({\n        status: ENTERED\n      }, function () {\n        _this2.props.onEntered(maybeNode);\n      });\n      return;\n    }\n\n    this.props.onEnter(maybeNode, maybeAppearing);\n    this.safeSetState({\n      status: ENTERING\n    }, function () {\n      _this2.props.onEntering(maybeNode, maybeAppearing);\n\n      _this2.onTransitionEnd(enterTimeout, function () {\n        _this2.safeSetState({\n          status: ENTERED\n        }, function () {\n          _this2.props.onEntered(maybeNode, maybeAppearing);\n        });\n      });\n    });\n  };\n\n  _proto.performExit = function performExit() {\n    var _this3 = this;\n\n    var exit = this.props.exit;\n    var timeouts = this.getTimeouts();\n    var maybeNode = this.props.nodeRef ? undefined : ReactDOM.findDOMNode(this); // no exit animation skip right to EXITED\n\n    if (!exit || config.disabled) {\n      this.safeSetState({\n        status: EXITED\n      }, function () {\n        _this3.props.onExited(maybeNode);\n      });\n      return;\n    }\n\n    this.props.onExit(maybeNode);\n    this.safeSetState({\n      status: EXITING\n    }, function () {\n      _this3.props.onExiting(maybeNode);\n\n      _this3.onTransitionEnd(timeouts.exit, function () {\n        _this3.safeSetState({\n          status: EXITED\n        }, function () {\n          _this3.props.onExited(maybeNode);\n        });\n      });\n    });\n  };\n\n  _proto.cancelNextCallback = function cancelNextCallback() {\n    if (this.nextCallback !== null) {\n      this.nextCallback.cancel();\n      this.nextCallback = null;\n    }\n  };\n\n  _proto.safeSetState = function safeSetState(nextState, callback) {\n    // This shouldn't be necessary, but there are weird race conditions with\n    // setState callbacks and unmounting in testing, so always make sure that\n    // we can cancel any pending setState callbacks after we unmount.\n    callback = this.setNextCallback(callback);\n    this.setState(nextState, callback);\n  };\n\n  _proto.setNextCallback = function setNextCallback(callback) {\n    var _this4 = this;\n\n    var active = true;\n\n    this.nextCallback = function (event) {\n      if (active) {\n        active = false;\n        _this4.nextCallback = null;\n        callback(event);\n      }\n    };\n\n    this.nextCallback.cancel = function () {\n      active = false;\n    };\n\n    return this.nextCallback;\n  };\n\n  _proto.onTransitionEnd = function onTransitionEnd(timeout, handler) {\n    this.setNextCallback(handler);\n    var node = this.props.nodeRef ? this.props.nodeRef.current : ReactDOM.findDOMNode(this);\n    var doesNotHaveTimeoutOrListener = timeout == null && !this.props.addEndListener;\n\n    if (!node || doesNotHaveTimeoutOrListener) {\n      setTimeout(this.nextCallback, 0);\n      return;\n    }\n\n    if (this.props.addEndListener) {\n      var _ref3 = this.props.nodeRef ? [this.nextCallback] : [node, this.nextCallback],\n          maybeNode = _ref3[0],\n          maybeNextCallback = _ref3[1];\n\n      this.props.addEndListener(maybeNode, maybeNextCallback);\n    }\n\n    if (timeout != null) {\n      setTimeout(this.nextCallback, timeout);\n    }\n  };\n\n  _proto.render = function render() {\n    var status = this.state.status;\n\n    if (status === UNMOUNTED) {\n      return null;\n    }\n\n    var _this$props = this.props,\n        children = _this$props.children,\n        _in = _this$props.in,\n        _mountOnEnter = _this$props.mountOnEnter,\n        _unmountOnExit = _this$props.unmountOnExit,\n        _appear = _this$props.appear,\n        _enter = _this$props.enter,\n        _exit = _this$props.exit,\n        _timeout = _this$props.timeout,\n        _addEndListener = _this$props.addEndListener,\n        _onEnter = _this$props.onEnter,\n        _onEntering = _this$props.onEntering,\n        _onEntered = _this$props.onEntered,\n        _onExit = _this$props.onExit,\n        _onExiting = _this$props.onExiting,\n        _onExited = _this$props.onExited,\n        _nodeRef = _this$props.nodeRef,\n        childProps = _objectWithoutPropertiesLoose(_this$props, [\"children\", \"in\", \"mountOnEnter\", \"unmountOnExit\", \"appear\", \"enter\", \"exit\", \"timeout\", \"addEndListener\", \"onEnter\", \"onEntering\", \"onEntered\", \"onExit\", \"onExiting\", \"onExited\", \"nodeRef\"]);\n\n    return (\n      /*#__PURE__*/\n      // allows for nested Transitions\n      React.createElement(TransitionGroupContext.Provider, {\n        value: null\n      }, typeof children === 'function' ? children(status, childProps) : React.cloneElement(React.Children.only(children), childProps))\n    );\n  };\n\n  return Transition;\n}(React.Component);\n\nTransition.contextType = TransitionGroupContext;\nTransition.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  /**\n   * A React reference to DOM element that need to transition:\n   * https://stackoverflow.com/a/51127130/4671932\n   *\n   *   - When `nodeRef` prop is used, `node` is not passed to callback functions\n   *      (e.g. `onEnter`) because user already has direct access to the node.\n   *   - When changing `key` prop of `Transition` in a `TransitionGroup` a new\n   *     `nodeRef` need to be provided to `Transition` with changed `key` prop\n   *     (see\n   *     [test/CSSTransition-test.js](https://github.com/reactjs/react-transition-group/blob/13435f897b3ab71f6e19d724f145596f5910581c/test/CSSTransition-test.js#L362-L437)).\n   */\n  nodeRef: PropTypes.shape({\n    current: typeof Element === 'undefined' ? PropTypes.any : function (propValue, key, componentName, location, propFullName, secret) {\n      var value = propValue[key];\n      return PropTypes.instanceOf(value && 'ownerDocument' in value ? value.ownerDocument.defaultView.Element : Element)(propValue, key, componentName, location, propFullName, secret);\n    }\n  }),\n\n  /**\n   * A `function` child can be used instead of a React element. This function is\n   * called with the current transition status (`'entering'`, `'entered'`,\n   * `'exiting'`, `'exited'`), which can be used to apply context\n   * specific props to a component.\n   *\n   * ```jsx\n   * <Transition in={this.state.in} timeout={150}>\n   *   {state => (\n   *     <MyComponent className={`fade fade-${state}`} />\n   *   )}\n   * </Transition>\n   * ```\n   */\n  children: PropTypes.oneOfType([PropTypes.func.isRequired, PropTypes.element.isRequired]).isRequired,\n\n  /**\n   * Show the component; triggers the enter or exit states\n   */\n  in: PropTypes.bool,\n\n  /**\n   * By default the child component is mounted immediately along with\n   * the parent `Transition` component. If you want to \"lazy mount\" the component on the\n   * first `in={true}` you can set `mountOnEnter`. After the first enter transition the component will stay\n   * mounted, even on \"exited\", unless you also specify `unmountOnExit`.\n   */\n  mountOnEnter: PropTypes.bool,\n\n  /**\n   * By default the child component stays mounted after it reaches the `'exited'` state.\n   * Set `unmountOnExit` if you'd prefer to unmount the component after it finishes exiting.\n   */\n  unmountOnExit: PropTypes.bool,\n\n  /**\n   * By default the child component does not perform the enter transition when\n   * it first mounts, regardless of the value of `in`. If you want this\n   * behavior, set both `appear` and `in` to `true`.\n   *\n   * > **Note**: there are no special appear states like `appearing`/`appeared`, this prop\n   * > only adds an additional enter transition. However, in the\n   * > `<CSSTransition>` component that first enter transition does result in\n   * > additional `.appear-*` classes, that way you can choose to style it\n   * > differently.\n   */\n  appear: PropTypes.bool,\n\n  /**\n   * Enable or disable enter transitions.\n   */\n  enter: PropTypes.bool,\n\n  /**\n   * Enable or disable exit transitions.\n   */\n  exit: PropTypes.bool,\n\n  /**\n   * The duration of the transition, in milliseconds.\n   * Required unless `addEndListener` is provided.\n   *\n   * You may specify a single timeout for all transitions:\n   *\n   * ```jsx\n   * timeout={500}\n   * ```\n   *\n   * or individually:\n   *\n   * ```jsx\n   * timeout={{\n   *  appear: 500,\n   *  enter: 300,\n   *  exit: 500,\n   * }}\n   * ```\n   *\n   * - `appear` defaults to the value of `enter`\n   * - `enter` defaults to `0`\n   * - `exit` defaults to `0`\n   *\n   * @type {number | { enter?: number, exit?: number, appear?: number }}\n   */\n  timeout: function timeout(props) {\n    var pt = timeoutsShape;\n    if (!props.addEndListener) pt = pt.isRequired;\n\n    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      args[_key - 1] = arguments[_key];\n    }\n\n    return pt.apply(void 0, [props].concat(args));\n  },\n\n  /**\n   * Add a custom transition end trigger. Called with the transitioning\n   * DOM node and a `done` callback. Allows for more fine grained transition end\n   * logic. Timeouts are still used as a fallback if provided.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * ```jsx\n   * addEndListener={(node, done) => {\n   *   // use the css transitionend event to mark the finish of a transition\n   *   node.addEventListener('transitionend', done, false);\n   * }}\n   * ```\n   */\n  addEndListener: PropTypes.func,\n\n  /**\n   * Callback fired before the \"entering\" status is applied. An extra parameter\n   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool) -> void\n   */\n  onEnter: PropTypes.func,\n\n  /**\n   * Callback fired after the \"entering\" status is applied. An extra parameter\n   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool)\n   */\n  onEntering: PropTypes.func,\n\n  /**\n   * Callback fired after the \"entered\" status is applied. An extra parameter\n   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool) -> void\n   */\n  onEntered: PropTypes.func,\n\n  /**\n   * Callback fired before the \"exiting\" status is applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement) -> void\n   */\n  onExit: PropTypes.func,\n\n  /**\n   * Callback fired after the \"exiting\" status is applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement) -> void\n   */\n  onExiting: PropTypes.func,\n\n  /**\n   * Callback fired after the \"exited\" status is applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed\n   *\n   * @type Function(node: HtmlElement) -> void\n   */\n  onExited: PropTypes.func\n} : {}; // Name the function so it is clearer in the documentation\n\nfunction noop() {}\n\nTransition.defaultProps = {\n  in: false,\n  mountOnEnter: false,\n  unmountOnExit: false,\n  appear: false,\n  enter: true,\n  exit: true,\n  onEnter: noop,\n  onEntering: noop,\n  onEntered: noop,\n  onExit: noop,\n  onExiting: noop,\n  onExited: noop\n};\nTransition.UNMOUNTED = UNMOUNTED;\nTransition.EXITED = EXITED;\nTransition.ENTERING = ENTERING;\nTransition.ENTERED = ENTERED;\nTransition.EXITING = EXITING;\nexport default Transition;","import setPrototypeOf from \"./setPrototypeOf.js\";\nfunction _inheritsLoose(t, o) {\n  t.prototype = Object.create(o.prototype), t.prototype.constructor = t, setPrototypeOf(t, o);\n}\nexport { _inheritsLoose as default };","export default !!(typeof window !== 'undefined' && window.document && window.document.createElement);","/* eslint-disable no-return-assign */\nimport canUseDOM from './canUseDOM';\nexport var optionsSupported = false;\nexport var onceSupported = false;\n\ntry {\n  var options = {\n    get passive() {\n      return optionsSupported = true;\n    },\n\n    get once() {\n      // eslint-disable-next-line no-multi-assign\n      return onceSupported = optionsSupported = true;\n    }\n\n  };\n\n  if (canUseDOM) {\n    window.addEventListener('test', options, options);\n    window.removeEventListener('test', options, true);\n  }\n} catch (e) {\n  /* */\n}\n\n/**\n * An `addEventListener` ponyfill, supports the `once` option\n * \n * @param node the element\n * @param eventName the event name\n * @param handle the handler\n * @param options event options\n */\nfunction addEventListener(node, eventName, handler, options) {\n  if (options && typeof options !== 'boolean' && !onceSupported) {\n    var once = options.once,\n        capture = options.capture;\n    var wrappedHandler = handler;\n\n    if (!onceSupported && once) {\n      wrappedHandler = handler.__once || function onceHandler(event) {\n        this.removeEventListener(eventName, onceHandler, capture);\n        handler.call(this, event);\n      };\n\n      handler.__once = wrappedHandler;\n    }\n\n    node.addEventListener(eventName, wrappedHandler, optionsSupported ? options : capture);\n  }\n\n  node.addEventListener(eventName, handler, options);\n}\n\nexport default addEventListener;","/**\n * A `removeEventListener` ponyfill\n * \n * @param node the element\n * @param eventName the event name\n * @param handle the handler\n * @param options event options\n */\nfunction removeEventListener(node, eventName, handler, options) {\n  var capture = options && typeof options !== 'boolean' ? options.capture : options;\n  node.removeEventListener(eventName, handler, capture);\n\n  if (handler.__once) {\n    node.removeEventListener(eventName, handler.__once, capture);\n  }\n}\n\nexport default removeEventListener;","import addEventListener from './addEventListener';\nimport removeEventListener from './removeEventListener';\n\nfunction listen(node, eventName, handler, options) {\n  addEventListener(node, eventName, handler, options);\n  return function () {\n    removeEventListener(node, eventName, handler, options);\n  };\n}\n\nexport default listen;","import css from './css';\nimport listen from './listen';\nimport triggerEvent from './triggerEvent';\n\nfunction parseDuration(node) {\n  var str = css(node, 'transitionDuration') || '';\n  var mult = str.indexOf('ms') === -1 ? 1000 : 1;\n  return parseFloat(str) * mult;\n}\n\nfunction emulateTransitionEnd(element, duration, padding) {\n  if (padding === void 0) {\n    padding = 5;\n  }\n\n  var called = false;\n  var handle = setTimeout(function () {\n    if (!called) triggerEvent(element, 'transitionend', true);\n  }, duration + padding);\n  var remove = listen(element, 'transitionend', function () {\n    called = true;\n  }, {\n    once: true\n  });\n  return function () {\n    clearTimeout(handle);\n    remove();\n  };\n}\n\nexport default function transitionEnd(element, handler, duration, padding) {\n  if (duration == null) duration = parseDuration(element) || 0;\n  var removeEmulate = emulateTransitionEnd(element, duration, padding);\n  var remove = listen(element, 'transitionend', handler);\n  return function () {\n    removeEmulate();\n    remove();\n  };\n}","/**\n * Triggers an event on a given element.\n * \n * @param node the element\n * @param eventName the event name to trigger\n * @param bubbles whether the event should bubble up\n * @param cancelable whether the event should be cancelable\n */\nexport default function triggerEvent(node, eventName, bubbles, cancelable) {\n  if (bubbles === void 0) {\n    bubbles = false;\n  }\n\n  if (cancelable === void 0) {\n    cancelable = true;\n  }\n\n  if (node) {\n    var event = document.createEvent('HTMLEvents');\n    event.initEvent(eventName, bubbles, cancelable);\n    node.dispatchEvent(event);\n  }\n}","import css from 'dom-helpers/css';\nimport transitionEnd from 'dom-helpers/transitionEnd';\nfunction parseDuration(node, property) {\n  const str = css(node, property) || '';\n  const mult = str.indexOf('ms') === -1 ? 1000 : 1;\n  return parseFloat(str) * mult;\n}\nexport default function transitionEndListener(element, handler) {\n  const duration = parseDuration(element, 'transitionDuration');\n  const delay = parseDuration(element, 'transitionDelay');\n  const remove = transitionEnd(element, e => {\n    if (e.target === element) {\n      remove();\n      handler(e);\n    }\n  }, duration + delay);\n}","/**\n * Safe chained function\n *\n * Will only create a new function if needed,\n * otherwise will pass back existing functions or null.\n *\n * @param {function} functions to chain\n * @returns {function|null}\n */\nfunction createChainedFunction(...funcs) {\n  return funcs.filter(f => f != null).reduce((acc, f) => {\n    if (typeof f !== 'function') {\n      throw new Error('Invalid Argument Type, must only provide functions, undefined, or null.');\n    }\n    if (acc === null) return f;\n    return function chainedFunction(...args) {\n      // @ts-ignore\n      acc.apply(this, args);\n      // @ts-ignore\n      f.apply(this, args);\n    };\n  }, null);\n}\nexport default createChainedFunction;","// reading a dimension prop will cause the browser to recalculate,\n// which will let our animations work\nexport default function triggerBrowserReflow(node) {\n  // eslint-disable-next-line @typescript-eslint/no-unused-expressions\n  node.offsetHeight;\n}","import { useMemo } from 'react';\nconst toFnRef = ref => !ref || typeof ref === 'function' ? ref : value => {\n  ref.current = value;\n};\nexport function mergeRefs(refA, refB) {\n  const a = toFnRef(refA);\n  const b = toFnRef(refB);\n  return value => {\n    if (a) a(value);\n    if (b) b(value);\n  };\n}\n\n/**\n * Create and returns a single callback ref composed from two other Refs.\n *\n * ```tsx\n * const Button = React.forwardRef((props, ref) => {\n *   const [element, attachRef] = useCallbackRef<HTMLButtonElement>();\n *   const mergedRef = useMergedRefs(ref, attachRef);\n *\n *   return <button ref={mergedRef} {...props}/>\n * })\n * ```\n *\n * @param refA A Callback or mutable Ref\n * @param refB A Callback or mutable Ref\n * @category refs\n */\nfunction useMergedRefs(refA, refB) {\n  return useMemo(() => mergeRefs(refA, refB), [refA, refB]);\n}\nexport default useMergedRefs;","\"use client\";\n\nimport React, { useCallback, useRef } from 'react';\nimport Transition from 'react-transition-group/Transition';\nimport useMergedRefs from '@restart/hooks/useMergedRefs';\nimport safeFindDOMNode from './safeFindDOMNode';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\n// Normalizes Transition callbacks when nodeRef is used.\nconst TransitionWrapper = /*#__PURE__*/React.forwardRef(({\n  onEnter,\n  onEntering,\n  onEntered,\n  onExit,\n  onExiting,\n  onExited,\n  addEndListener,\n  children,\n  childRef,\n  ...props\n}, ref) => {\n  const nodeRef = useRef(null);\n  const mergedRef = useMergedRefs(nodeRef, childRef);\n  const attachRef = r => {\n    mergedRef(safeFindDOMNode(r));\n  };\n  const normalize = callback => param => {\n    if (callback && nodeRef.current) {\n      callback(nodeRef.current, param);\n    }\n  };\n\n  /* eslint-disable react-hooks/exhaustive-deps */\n  const handleEnter = useCallback(normalize(onEnter), [onEnter]);\n  const handleEntering = useCallback(normalize(onEntering), [onEntering]);\n  const handleEntered = useCallback(normalize(onEntered), [onEntered]);\n  const handleExit = useCallback(normalize(onExit), [onExit]);\n  const handleExiting = useCallback(normalize(onExiting), [onExiting]);\n  const handleExited = useCallback(normalize(onExited), [onExited]);\n  const handleAddEndListener = useCallback(normalize(addEndListener), [addEndListener]);\n  /* eslint-enable react-hooks/exhaustive-deps */\n\n  return /*#__PURE__*/_jsx(Transition, {\n    ref: ref,\n    ...props,\n    onEnter: handleEnter,\n    onEntered: handleEntered,\n    onEntering: handleEntering,\n    onExit: handleExit,\n    onExited: handleExited,\n    onExiting: handleExiting,\n    addEndListener: handleAddEndListener,\n    nodeRef: nodeRef,\n    children: typeof children === 'function' ? (status, innerProps) =>\n    // TODO: Types for RTG missing innerProps, so need to cast.\n    children(status, {\n      ...innerProps,\n      ref: attachRef\n    }) : /*#__PURE__*/React.cloneElement(children, {\n      ref: attachRef\n    })\n  });\n});\nexport default TransitionWrapper;","import ReactDOM from 'react-dom';\nexport default function safeFindDOMNode(componentOrElement) {\n  if (componentOrElement && 'setState' in componentOrElement) {\n    return ReactDOM.findDOMNode(componentOrElement);\n  }\n  return componentOrElement != null ? componentOrElement : null;\n}","import classNames from 'classnames';\nimport css from 'dom-helpers/css';\nimport React, { useMemo } from 'react';\nimport { ENTERED, ENTERING, EXITED, EXITING } from 'react-transition-group/Transition';\nimport transitionEndListener from './transitionEndListener';\nimport createChainedFunction from './createChainedFunction';\nimport triggerBrowserReflow from './triggerBrowserReflow';\nimport TransitionWrapper from './TransitionWrapper';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst MARGINS = {\n  height: ['marginTop', 'marginBottom'],\n  width: ['marginLeft', 'marginRight']\n};\nfunction getDefaultDimensionValue(dimension, elem) {\n  const offset = `offset${dimension[0].toUpperCase()}${dimension.slice(1)}`;\n  const value = elem[offset];\n  const margins = MARGINS[dimension];\n  return value +\n  // @ts-ignore\n  parseInt(css(elem, margins[0]), 10) +\n  // @ts-ignore\n  parseInt(css(elem, margins[1]), 10);\n}\nconst collapseStyles = {\n  [EXITED]: 'collapse',\n  [EXITING]: 'collapsing',\n  [ENTERING]: 'collapsing',\n  [ENTERED]: 'collapse show'\n};\nconst Collapse = /*#__PURE__*/React.forwardRef(({\n  onEnter,\n  onEntering,\n  onEntered,\n  onExit,\n  onExiting,\n  className,\n  children,\n  dimension = 'height',\n  in: inProp = false,\n  timeout = 300,\n  mountOnEnter = false,\n  unmountOnExit = false,\n  appear = false,\n  getDimensionValue = getDefaultDimensionValue,\n  ...props\n}, ref) => {\n  /* Compute dimension */\n  const computedDimension = typeof dimension === 'function' ? dimension() : dimension;\n\n  /* -- Expanding -- */\n  const handleEnter = useMemo(() => createChainedFunction(elem => {\n    elem.style[computedDimension] = '0';\n  }, onEnter), [computedDimension, onEnter]);\n  const handleEntering = useMemo(() => createChainedFunction(elem => {\n    const scroll = `scroll${computedDimension[0].toUpperCase()}${computedDimension.slice(1)}`;\n    elem.style[computedDimension] = `${elem[scroll]}px`;\n  }, onEntering), [computedDimension, onEntering]);\n  const handleEntered = useMemo(() => createChainedFunction(elem => {\n    elem.style[computedDimension] = null;\n  }, onEntered), [computedDimension, onEntered]);\n\n  /* -- Collapsing -- */\n  const handleExit = useMemo(() => createChainedFunction(elem => {\n    elem.style[computedDimension] = `${getDimensionValue(computedDimension, elem)}px`;\n    triggerBrowserReflow(elem);\n  }, onExit), [onExit, getDimensionValue, computedDimension]);\n  const handleExiting = useMemo(() => createChainedFunction(elem => {\n    elem.style[computedDimension] = null;\n  }, onExiting), [computedDimension, onExiting]);\n  return /*#__PURE__*/_jsx(TransitionWrapper, {\n    ref: ref,\n    addEndListener: transitionEndListener,\n    ...props,\n    \"aria-expanded\": props.role ? inProp : null,\n    onEnter: handleEnter,\n    onEntering: handleEntering,\n    onEntered: handleEntered,\n    onExit: handleExit,\n    onExiting: handleExiting,\n    childRef: children.ref,\n    in: inProp,\n    timeout: timeout,\n    mountOnEnter: mountOnEnter,\n    unmountOnExit: unmountOnExit,\n    appear: appear,\n    children: (state, innerProps) => /*#__PURE__*/React.cloneElement(children, {\n      ...innerProps,\n      className: classNames(className, children.props.className, collapseStyles[state], computedDimension === 'width' && 'collapse-horizontal')\n    })\n  });\n});\n\n// @ts-ignore\n\nexport default Collapse;","\"use client\";\n\nimport * as React from 'react';\n\n// TODO: check\n\nconst context = /*#__PURE__*/React.createContext(null);\ncontext.displayName = 'NavbarContext';\nexport default context;","\"use client\";\n\nimport * as React from 'react';\nimport { useContext } from 'react';\nimport Collapse from './Collapse';\nimport { useBootstrapPrefix } from './ThemeProvider';\nimport NavbarContext from './NavbarContext';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst NavbarCollapse = /*#__PURE__*/React.forwardRef(({\n  children,\n  bsPrefix,\n  ...props\n}, ref) => {\n  bsPrefix = useBootstrapPrefix(bsPrefix, 'navbar-collapse');\n  const context = useContext(NavbarContext);\n  return /*#__PURE__*/_jsx(Collapse, {\n    in: !!(context && context.expanded),\n    ...props,\n    children: /*#__PURE__*/_jsx(\"div\", {\n      ref: ref,\n      className: bsPrefix,\n      children: children\n    })\n  });\n});\nNavbarCollapse.displayName = 'NavbarCollapse';\nexport default NavbarCollapse;","import { useEffect, useRef } from 'react';\n\n/**\n * Creates a `Ref` whose value is updated in an effect, ensuring the most recent\n * value is the one rendered with. Generally only required for Concurrent mode usage\n * where previous work in `render()` may be discarded before being used.\n *\n * This is safe to access in an event handler.\n *\n * @param value The `Ref` value\n */\nfunction useCommittedRef(value) {\n  const ref = useRef(value);\n  useEffect(() => {\n    ref.current = value;\n  }, [value]);\n  return ref;\n}\nexport default useCommittedRef;","import { useCallback } from 'react';\nimport useCommittedRef from './useCommittedRef';\nexport default function useEventCallback(fn) {\n  const ref = useCommittedRef(fn);\n  return useCallback(function (...args) {\n    return ref.current && ref.current(...args);\n  }, [ref]);\n}","\"use client\";\n\nimport classNames from 'classnames';\nimport * as React from 'react';\nimport { useContext } from 'react';\nimport useEventCallback from '@restart/hooks/useEventCallback';\nimport { useBootstrapPrefix } from './ThemeProvider';\nimport NavbarContext from './NavbarContext';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst NavbarToggle = /*#__PURE__*/React.forwardRef(({\n  bsPrefix,\n  className,\n  children,\n  label = 'Toggle navigation',\n  // Need to define the default \"as\" during prop destructuring to be compatible with styled-components github.com/react-bootstrap/react-bootstrap/issues/3595\n  as: Component = 'button',\n  onClick,\n  ...props\n}, ref) => {\n  bsPrefix = useBootstrapPrefix(bsPrefix, 'navbar-toggler');\n  const {\n    onToggle,\n    expanded\n  } = useContext(NavbarContext) || {};\n  const handleClick = useEventCallback(e => {\n    if (onClick) onClick(e);\n    if (onToggle) onToggle();\n  });\n  if (Component === 'button') {\n    props.type = 'button';\n  }\n  return /*#__PURE__*/_jsx(Component, {\n    ...props,\n    ref: ref,\n    onClick: handleClick,\n    \"aria-label\": label,\n    className: classNames(className, bsPrefix, !expanded && 'collapsed'),\n    children: children || /*#__PURE__*/_jsx(\"span\", {\n      className: `${bsPrefix}-icon`\n    })\n  });\n});\nNavbarToggle.displayName = 'NavbarToggle';\nexport default NavbarToggle;","import { useEffect, useLayoutEffect } from 'react';\nconst isReactNative = typeof global !== 'undefined' &&\n// @ts-ignore\nglobal.navigator &&\n// @ts-ignore\nglobal.navigator.product === 'ReactNative';\nconst isDOM = typeof document !== 'undefined';\n\n/**\n * Is `useLayoutEffect` in a DOM or React Native environment, otherwise resolves to useEffect\n * Only useful to avoid the console warning.\n *\n * PREFER `useEffect` UNLESS YOU KNOW WHAT YOU ARE DOING.\n *\n * @category effects\n */\nexport default isDOM || isReactNative ? useLayoutEffect : useEffect;","import useEffect from './useIsomorphicEffect';\nimport { useState } from 'react';\nconst matchersByWindow = new WeakMap();\nconst getMatcher = (query, targetWindow) => {\n  if (!query || !targetWindow) return undefined;\n  const matchers = matchersByWindow.get(targetWindow) || new Map();\n  matchersByWindow.set(targetWindow, matchers);\n  let mql = matchers.get(query);\n  if (!mql) {\n    mql = targetWindow.matchMedia(query);\n    mql.refCount = 0;\n    matchers.set(mql.media, mql);\n  }\n  return mql;\n};\n/**\n * Match a media query and get updates as the match changes. The media string is\n * passed directly to `window.matchMedia` and run as a Layout Effect, so initial\n * matches are returned before the browser has a chance to paint.\n *\n * ```tsx\n * function Page() {\n *   const isWide = useMediaQuery('min-width: 1000px')\n *\n *   return isWide ? \"very wide\" : 'not so wide'\n * }\n * ```\n *\n * Media query lists are also reused globally, hook calls for the same query\n * will only create a matcher once under the hood.\n *\n * @param query A media query\n * @param targetWindow The window to match against, uses the globally available one as a default.\n */\nexport default function useMediaQuery(query, targetWindow = typeof window === 'undefined' ? undefined : window) {\n  const mql = getMatcher(query, targetWindow);\n  const [matches, setMatches] = useState(() => mql ? mql.matches : false);\n  useEffect(() => {\n    let mql = getMatcher(query, targetWindow);\n    if (!mql) {\n      return setMatches(false);\n    }\n    let matchers = matchersByWindow.get(targetWindow);\n    const handleChange = () => {\n      setMatches(mql.matches);\n    };\n    mql.refCount++;\n    mql.addListener(handleChange);\n    handleChange();\n    return () => {\n      mql.removeListener(handleChange);\n      mql.refCount--;\n      if (mql.refCount <= 0) {\n        matchers == null ? void 0 : matchers.delete(mql.media);\n      }\n      mql = undefined;\n    };\n  }, [query]);\n  return matches;\n}","import useMediaQuery from './useMediaQuery';\nimport { useMemo } from 'react';\n/**\n * Create a responsive hook we a set of breakpoint names and widths.\n * You can use any valid css units as well as a numbers (for pixels).\n *\n * **NOTE:** The object key order is important! it's assumed to be in order from smallest to largest\n *\n * ```ts\n * const useBreakpoint = createBreakpointHook({\n *  xs: 0,\n *  sm: 576,\n *  md: 768,\n *  lg: 992,\n *  xl: 1200,\n * })\n * ```\n *\n * **Watch out!** using string values will sometimes construct media queries using css `calc()` which\n * is NOT supported in media queries by all browsers at the moment. use numbers for\n * the widest range of browser support.\n *\n * @param breakpointValues A object hash of names to breakpoint dimensions\n */\nexport function createBreakpointHook(breakpointValues) {\n  const names = Object.keys(breakpointValues);\n  function and(query, next) {\n    if (query === next) {\n      return next;\n    }\n    return query ? `${query} and ${next}` : next;\n  }\n  function getNext(breakpoint) {\n    return names[Math.min(names.indexOf(breakpoint) + 1, names.length - 1)];\n  }\n  function getMaxQuery(breakpoint) {\n    const next = getNext(breakpoint);\n    let value = breakpointValues[next];\n    if (typeof value === 'number') value = `${value - 0.2}px`;else value = `calc(${value} - 0.2px)`;\n    return `(max-width: ${value})`;\n  }\n  function getMinQuery(breakpoint) {\n    let value = breakpointValues[breakpoint];\n    if (typeof value === 'number') {\n      value = `${value}px`;\n    }\n    return `(min-width: ${value})`;\n  }\n\n  /**\n   * Match a set of breakpoints\n   *\n   * ```tsx\n   * const MidSizeOnly = () => {\n   *   const isMid = useBreakpoint({ lg: 'down', sm: 'up' });\n   *\n   *   if (isMid) return <div>On a Reasonable sized Screen!</div>\n   *   return null;\n   * }\n   * ```\n   * @param breakpointMap An object map of breakpoints and directions, queries are constructed using \"and\" to join\n   * breakpoints together\n   * @param window Optionally specify the target window to match against (useful when rendering into iframes)\n   */\n\n  /**\n   * Match a single breakpoint exactly, up, or down.\n   *\n   * ```tsx\n   * const PhoneOnly = () => {\n   *   const isSmall = useBreakpoint('sm', 'down');\n   *\n   *   if (isSmall) return <div>On a Small Screen!</div>\n   *   return null;\n   * }\n   * ```\n   *\n   * @param breakpoint The breakpoint key\n   * @param direction A direction 'up' for a max, 'down' for min, true to match only the breakpoint\n   * @param window Optionally specify the target window to match against (useful when rendering into iframes)\n   */\n\n  function useBreakpoint(breakpointOrMap, direction, window) {\n    let breakpointMap;\n    if (typeof breakpointOrMap === 'object') {\n      breakpointMap = breakpointOrMap;\n      window = direction;\n      direction = true;\n    } else {\n      direction = direction || true;\n      breakpointMap = {\n        [breakpointOrMap]: direction\n      };\n    }\n    let query = useMemo(() => Object.entries(breakpointMap).reduce((query, [key, direction]) => {\n      if (direction === 'up' || direction === true) {\n        query = and(query, getMinQuery(key));\n      }\n      if (direction === 'down' || direction === true) {\n        query = and(query, getMaxQuery(key));\n      }\n      return query;\n    }, ''), [JSON.stringify(breakpointMap)]);\n    return useMediaQuery(query, window);\n  }\n  return useBreakpoint;\n}\nconst useBreakpoint = createBreakpointHook({\n  xs: 0,\n  sm: 576,\n  md: 768,\n  lg: 992,\n  xl: 1200,\n  xxl: 1400\n});\nexport default useBreakpoint;","import ownerDocument from './ownerDocument';\n/**\n * Returns the actively focused element safely.\n *\n * @param doc the document to check\n */\n\nexport default function activeElement(doc) {\n  if (doc === void 0) {\n    doc = ownerDocument();\n  }\n\n  // Support: IE 9 only\n  // IE9 throws an \"Unspecified error\" accessing document.activeElement from an <iframe>\n  try {\n    var active = doc.activeElement; // IE11 returns a seemingly empty object in some cases when accessing\n    // document.activeElement from an <iframe>\n\n    if (!active || !active.nodeName) return null;\n    return active;\n  } catch (e) {\n    /* ie throws if no active element */\n    return doc.body;\n  }\n}","/* eslint-disable no-bitwise, no-cond-assign */\n\n/**\n * Checks if an element contains another given element.\n * \n * @param context the context element\n * @param node the element to check\n */\nexport default function contains(context, node) {\n  // HTML DOM and SVG DOM may have different support levels,\n  // so we need to check on context instead of a document root element.\n  if (context.contains) return context.contains(node);\n  if (context.compareDocumentPosition) return context === node || !!(context.compareDocumentPosition(node) & 16);\n}","import useUpdatedRef from './useUpdatedRef';\nimport { useEffect } from 'react';\n\n/**\n * Attach a callback that fires when a component unmounts\n *\n * @param fn Handler to run when the component unmounts\n * @category effects\n */\nexport default function useWillUnmount(fn) {\n  const onUnmount = useUpdatedRef(fn);\n  useEffect(() => () => onUnmount.current(), []);\n}","import { useRef } from 'react';\n\n/**\n * Returns a ref that is immediately updated with the new value\n *\n * @param value The Ref value\n * @category refs\n */\nexport default function useUpdatedRef(value) {\n  const valueRef = useRef(value);\n  valueRef.current = value;\n  return valueRef;\n}","export const ATTRIBUTE_PREFIX = `data-rr-ui-`;\nexport const PROPERTY_PREFIX = `rrUi`;\nexport function dataAttr(property) {\n  return `${ATTRIBUTE_PREFIX}${property}`;\n}\nexport function dataProp(property) {\n  return `${PROPERTY_PREFIX}${property}`;\n}","import css from 'dom-helpers/css';\nimport { dataAttr } from './DataKey';\nimport getBodyScrollbarWidth from './getScrollbarWidth';\nexport const OPEN_DATA_ATTRIBUTE = dataAttr('modal-open');\n\n/**\n * Manages a stack of Modals as well as ensuring\n * body scrolling is is disabled and padding accounted for\n */\nclass ModalManager {\n  constructor({\n    ownerDocument,\n    handleContainerOverflow = true,\n    isRTL = false\n  } = {}) {\n    this.handleContainerOverflow = handleContainerOverflow;\n    this.isRTL = isRTL;\n    this.modals = [];\n    this.ownerDocument = ownerDocument;\n  }\n  getScrollbarWidth() {\n    return getBodyScrollbarWidth(this.ownerDocument);\n  }\n  getElement() {\n    return (this.ownerDocument || document).body;\n  }\n  setModalAttributes(_modal) {\n    // For overriding\n  }\n  removeModalAttributes(_modal) {\n    // For overriding\n  }\n  setContainerStyle(containerState) {\n    const style = {\n      overflow: 'hidden'\n    };\n\n    // we are only interested in the actual `style` here\n    // because we will override it\n    const paddingProp = this.isRTL ? 'paddingLeft' : 'paddingRight';\n    const container = this.getElement();\n    containerState.style = {\n      overflow: container.style.overflow,\n      [paddingProp]: container.style[paddingProp]\n    };\n    if (containerState.scrollBarWidth) {\n      // use computed style, here to get the real padding\n      // to add our scrollbar width\n      style[paddingProp] = `${parseInt(css(container, paddingProp) || '0', 10) + containerState.scrollBarWidth}px`;\n    }\n    container.setAttribute(OPEN_DATA_ATTRIBUTE, '');\n    css(container, style);\n  }\n  reset() {\n    [...this.modals].forEach(m => this.remove(m));\n  }\n  removeContainerStyle(containerState) {\n    const container = this.getElement();\n    container.removeAttribute(OPEN_DATA_ATTRIBUTE);\n    Object.assign(container.style, containerState.style);\n  }\n  add(modal) {\n    let modalIdx = this.modals.indexOf(modal);\n    if (modalIdx !== -1) {\n      return modalIdx;\n    }\n    modalIdx = this.modals.length;\n    this.modals.push(modal);\n    this.setModalAttributes(modal);\n    if (modalIdx !== 0) {\n      return modalIdx;\n    }\n    this.state = {\n      scrollBarWidth: this.getScrollbarWidth(),\n      style: {}\n    };\n    if (this.handleContainerOverflow) {\n      this.setContainerStyle(this.state);\n    }\n    return modalIdx;\n  }\n  remove(modal) {\n    const modalIdx = this.modals.indexOf(modal);\n    if (modalIdx === -1) {\n      return;\n    }\n    this.modals.splice(modalIdx, 1);\n\n    // if that was the last modal in a container,\n    // clean up the container\n    if (!this.modals.length && this.handleContainerOverflow) {\n      this.removeContainerStyle(this.state);\n    }\n    this.removeModalAttributes(modal);\n  }\n  isTopModal(modal) {\n    return !!this.modals.length && this.modals[this.modals.length - 1] === modal;\n  }\n}\nexport default ModalManager;","/**\n * Get the width of the vertical window scrollbar if it's visible\n */\nexport default function getBodyScrollbarWidth(ownerDocument = document) {\n  const window = ownerDocument.defaultView;\n  return Math.abs(window.innerWidth - ownerDocument.documentElement.clientWidth);\n}","import { createContext, useContext } from 'react';\nimport canUseDOM from 'dom-helpers/canUseDOM';\nconst Context = /*#__PURE__*/createContext(canUseDOM ? window : undefined);\nexport const WindowProvider = Context.Provider;\n\n/**\n * The document \"window\" placed in React context. Helpful for determining\n * SSR context, or when rendering into an iframe.\n *\n * @returns the current window\n */\nexport default function useWindow() {\n  return useContext(Context);\n}","import ownerDocument from 'dom-helpers/ownerDocument';\nimport canUseDOM from 'dom-helpers/canUseDOM';\nimport { useState, useEffect } from 'react';\nimport useWindow from './useWindow';\nexport const resolveContainerRef = (ref, document) => {\n  if (!canUseDOM) return null;\n  if (ref == null) return (document || ownerDocument()).body;\n  if (typeof ref === 'function') ref = ref();\n  if (ref && 'current' in ref) ref = ref.current;\n  if (ref && ('nodeType' in ref || ref.getBoundingClientRect)) return ref;\n  return null;\n};\nexport default function useWaitForDOMRef(ref, onResolved) {\n  const window = useWindow();\n  const [resolvedRef, setRef] = useState(() => resolveContainerRef(ref, window == null ? void 0 : window.document));\n  if (!resolvedRef) {\n    const earlyRef = resolveContainerRef(ref);\n    if (earlyRef) setRef(earlyRef);\n  }\n  useEffect(() => {\n    if (onResolved && resolvedRef) {\n      onResolved(resolvedRef);\n    }\n  }, [onResolved, resolvedRef]);\n  useEffect(() => {\n    const nextRef = resolveContainerRef(ref);\n    if (nextRef !== resolvedRef) {\n      setRef(nextRef);\n    }\n  }, [ref, resolvedRef]);\n  return resolvedRef;\n}","import useEventCallback from '@restart/hooks/useEventCallback';\nimport useMergedRefs from '@restart/hooks/useMergedRefs';\nimport { cloneElement, useEffect, useRef } from 'react';\nfunction NoopTransition({\n  children,\n  in: inProp,\n  onExited,\n  mountOnEnter,\n  unmountOnExit\n}) {\n  const ref = useRef(null);\n  const hasEnteredRef = useRef(inProp);\n  const handleExited = useEventCallback(onExited);\n  useEffect(() => {\n    if (inProp) hasEnteredRef.current = true;else {\n      handleExited(ref.current);\n    }\n  }, [inProp, handleExited]);\n  const combinedRef = useMergedRefs(ref, children.ref);\n  const child = /*#__PURE__*/cloneElement(children, {\n    ref: combinedRef\n  });\n  if (inProp) return child;\n  if (unmountOnExit) {\n    return null;\n  }\n  if (!hasEnteredRef.current && mountOnEnter) {\n    return null;\n  }\n  return child;\n}\nexport default NoopTransition;","import * as React from 'react';\nexport function isEscKey(e) {\n  return e.code === 'Escape' || e.keyCode === 27;\n}\nexport function getReactVersion() {\n  const parts = React.version.split('.');\n  return {\n    major: +parts[0],\n    minor: +parts[1],\n    patch: +parts[2]\n  };\n}","const _excluded = [\"onEnter\", \"onEntering\", \"onEntered\", \"onExit\", \"onExiting\", \"onExited\", \"addEndListener\", \"children\"];\nfunction _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (e.indexOf(n) >= 0) continue; t[n] = r[n]; } return t; }\nimport { cloneElement, useCallback, useRef } from 'react';\nimport useMergedRefs from '@restart/hooks/useMergedRefs';\nimport { getReactVersion } from './utils';\n/**\n * Normalizes RTG transition callbacks with nodeRef to better support\n * strict mode.\n *\n * @param props Transition props.\n * @returns Normalized transition props.\n */\nexport default function useRTGTransitionProps(_ref) {\n  let {\n      onEnter,\n      onEntering,\n      onEntered,\n      onExit,\n      onExiting,\n      onExited,\n      addEndListener,\n      children\n    } = _ref,\n    props = _objectWithoutPropertiesLoose(_ref, _excluded);\n  const {\n    major\n  } = getReactVersion();\n  const childRef = major >= 19 ? children.props.ref : children.ref;\n  const nodeRef = useRef(null);\n  const mergedRef = useMergedRefs(nodeRef, typeof children === 'function' ? null : childRef);\n  const normalize = callback => param => {\n    if (callback && nodeRef.current) {\n      callback(nodeRef.current, param);\n    }\n  };\n\n  /* eslint-disable react-hooks/exhaustive-deps */\n  const handleEnter = useCallback(normalize(onEnter), [onEnter]);\n  const handleEntering = useCallback(normalize(onEntering), [onEntering]);\n  const handleEntered = useCallback(normalize(onEntered), [onEntered]);\n  const handleExit = useCallback(normalize(onExit), [onExit]);\n  const handleExiting = useCallback(normalize(onExiting), [onExiting]);\n  const handleExited = useCallback(normalize(onExited), [onExited]);\n  const handleAddEndListener = useCallback(normalize(addEndListener), [addEndListener]);\n  /* eslint-enable react-hooks/exhaustive-deps */\n\n  return Object.assign({}, props, {\n    nodeRef\n  }, onEnter && {\n    onEnter: handleEnter\n  }, onEntering && {\n    onEntering: handleEntering\n  }, onEntered && {\n    onEntered: handleEntered\n  }, onExit && {\n    onExit: handleExit\n  }, onExiting && {\n    onExiting: handleExiting\n  }, onExited && {\n    onExited: handleExited\n  }, addEndListener && {\n    addEndListener: handleAddEndListener\n  }, {\n    children: typeof children === 'function' ? (status, innerProps) =>\n    // TODO: Types for RTG missing innerProps, so need to cast.\n    children(status, Object.assign({}, innerProps, {\n      ref: mergedRef\n    })) : /*#__PURE__*/cloneElement(children, {\n      ref: mergedRef\n    })\n  });\n}","const _excluded = [\"component\"];\nfunction _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (e.indexOf(n) >= 0) continue; t[n] = r[n]; } return t; }\nimport * as React from 'react';\nimport useRTGTransitionProps from './useRTGTransitionProps';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\n// Normalizes Transition callbacks when nodeRef is used.\nconst RTGTransition = /*#__PURE__*/React.forwardRef((_ref, ref) => {\n  let {\n      component: Component\n    } = _ref,\n    props = _objectWithoutPropertiesLoose(_ref, _excluded);\n  const transitionProps = useRTGTransitionProps(props);\n  return /*#__PURE__*/_jsx(Component, Object.assign({\n    ref: ref\n  }, transitionProps));\n});\nexport default RTGTransition;","import useMergedRefs from '@restart/hooks/useMergedRefs';\nimport useEventCallback from '@restart/hooks/useEventCallback';\nimport useIsomorphicEffect from '@restart/hooks/useIsomorphicEffect';\nimport React, { useRef, cloneElement, useState } from 'react';\nimport NoopTransition from './NoopTransition';\nimport RTGTransition from './RTGTransition';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport function useTransition({\n  in: inProp,\n  onTransition\n}) {\n  const ref = useRef(null);\n  const isInitialRef = useRef(true);\n  const handleTransition = useEventCallback(onTransition);\n  useIsomorphicEffect(() => {\n    if (!ref.current) {\n      return undefined;\n    }\n    let stale = false;\n    handleTransition({\n      in: inProp,\n      element: ref.current,\n      initial: isInitialRef.current,\n      isStale: () => stale\n    });\n    return () => {\n      stale = true;\n    };\n  }, [inProp, handleTransition]);\n  useIsomorphicEffect(() => {\n    isInitialRef.current = false;\n    // this is for strict mode\n    return () => {\n      isInitialRef.current = true;\n    };\n  }, []);\n  return ref;\n}\n/**\n * Adapts an imperative transition function to a subset of the RTG `<Transition>` component API.\n *\n * ImperativeTransition does not support mounting options or `appear` at the moment, meaning\n * that it always acts like: `mountOnEnter={true} unmountOnExit={true} appear={true}`\n */\nexport default function ImperativeTransition({\n  children,\n  in: inProp,\n  onExited,\n  onEntered,\n  transition\n}) {\n  const [exited, setExited] = useState(!inProp);\n\n  // TODO: I think this needs to be in an effect\n  if (inProp && exited) {\n    setExited(false);\n  }\n  const ref = useTransition({\n    in: !!inProp,\n    onTransition: options => {\n      const onFinish = () => {\n        if (options.isStale()) return;\n        if (options.in) {\n          onEntered == null ? void 0 : onEntered(options.element, options.initial);\n        } else {\n          setExited(true);\n          onExited == null ? void 0 : onExited(options.element);\n        }\n      };\n      Promise.resolve(transition(options)).then(onFinish, error => {\n        if (!options.in) setExited(true);\n        throw error;\n      });\n    }\n  });\n  const combinedRef = useMergedRefs(ref, children.ref);\n  return exited && !inProp ? null : /*#__PURE__*/cloneElement(children, {\n    ref: combinedRef\n  });\n}\nexport function renderTransition(component, runTransition, props) {\n  if (component) {\n    return /*#__PURE__*/_jsx(RTGTransition, Object.assign({}, props, {\n      component: component\n    }));\n  }\n  if (runTransition) {\n    return /*#__PURE__*/_jsx(ImperativeTransition, Object.assign({}, props, {\n      transition: runTransition\n    }));\n  }\n  return /*#__PURE__*/_jsx(NoopTransition, Object.assign({}, props));\n}","const _excluded = [\"show\", \"role\", \"className\", \"style\", \"children\", \"backdrop\", \"keyboard\", \"onBackdropClick\", \"onEscapeKeyDown\", \"transition\", \"runTransition\", \"backdropTransition\", \"runBackdropTransition\", \"autoFocus\", \"enforceFocus\", \"restoreFocus\", \"restoreFocusOptions\", \"renderDialog\", \"renderBackdrop\", \"manager\", \"container\", \"onShow\", \"onHide\", \"onExit\", \"onExited\", \"onExiting\", \"onEnter\", \"onEntering\", \"onEntered\"];\nfunction _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (e.indexOf(n) >= 0) continue; t[n] = r[n]; } return t; }\n/* eslint-disable @typescript-eslint/no-use-before-define, react/prop-types */\n\nimport activeElement from 'dom-helpers/activeElement';\nimport contains from 'dom-helpers/contains';\nimport canUseDOM from 'dom-helpers/canUseDOM';\nimport listen from 'dom-helpers/listen';\nimport { useState, useRef, useCallback, useImperativeHandle, forwardRef, useEffect } from 'react';\nimport * as React from 'react';\nimport ReactDOM from 'react-dom';\nimport useMounted from '@restart/hooks/useMounted';\nimport useWillUnmount from '@restart/hooks/useWillUnmount';\nimport usePrevious from '@restart/hooks/usePrevious';\nimport useEventCallback from '@restart/hooks/useEventCallback';\nimport ModalManager from './ModalManager';\nimport useWaitForDOMRef from './useWaitForDOMRef';\nimport useWindow from './useWindow';\nimport { renderTransition } from './ImperativeTransition';\nimport { isEscKey } from './utils';\nimport { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from \"react/jsx-runtime\";\nlet manager;\n\n/*\n  Modal props are split into a version with and without index signature so that you can fully use them in another projects\n  This is due to Typescript not playing well with index signatures e.g. when using Omit\n*/\n\nfunction getManager(window) {\n  if (!manager) manager = new ModalManager({\n    ownerDocument: window == null ? void 0 : window.document\n  });\n  return manager;\n}\nfunction useModalManager(provided) {\n  const window = useWindow();\n  const modalManager = provided || getManager(window);\n  const modal = useRef({\n    dialog: null,\n    backdrop: null\n  });\n  return Object.assign(modal.current, {\n    add: () => modalManager.add(modal.current),\n    remove: () => modalManager.remove(modal.current),\n    isTopModal: () => modalManager.isTopModal(modal.current),\n    setDialogRef: useCallback(ref => {\n      modal.current.dialog = ref;\n    }, []),\n    setBackdropRef: useCallback(ref => {\n      modal.current.backdrop = ref;\n    }, [])\n  });\n}\nconst Modal = /*#__PURE__*/forwardRef((_ref, ref) => {\n  let {\n      show = false,\n      role = 'dialog',\n      className,\n      style,\n      children,\n      backdrop = true,\n      keyboard = true,\n      onBackdropClick,\n      onEscapeKeyDown,\n      transition,\n      runTransition,\n      backdropTransition,\n      runBackdropTransition,\n      autoFocus = true,\n      enforceFocus = true,\n      restoreFocus = true,\n      restoreFocusOptions,\n      renderDialog,\n      renderBackdrop = props => /*#__PURE__*/_jsx(\"div\", Object.assign({}, props)),\n      manager: providedManager,\n      container: containerRef,\n      onShow,\n      onHide = () => {},\n      onExit,\n      onExited,\n      onExiting,\n      onEnter,\n      onEntering,\n      onEntered\n    } = _ref,\n    rest = _objectWithoutPropertiesLoose(_ref, _excluded);\n  const ownerWindow = useWindow();\n  const container = useWaitForDOMRef(containerRef);\n  const modal = useModalManager(providedManager);\n  const isMounted = useMounted();\n  const prevShow = usePrevious(show);\n  const [exited, setExited] = useState(!show);\n  const lastFocusRef = useRef(null);\n  useImperativeHandle(ref, () => modal, [modal]);\n  if (canUseDOM && !prevShow && show) {\n    lastFocusRef.current = activeElement(ownerWindow == null ? void 0 : ownerWindow.document);\n  }\n\n  // TODO: I think this needs to be in an effect\n  if (show && exited) {\n    setExited(false);\n  }\n  const handleShow = useEventCallback(() => {\n    modal.add();\n    removeKeydownListenerRef.current = listen(document, 'keydown', handleDocumentKeyDown);\n    removeFocusListenerRef.current = listen(document, 'focus',\n    // the timeout is necessary b/c this will run before the new modal is mounted\n    // and so steals focus from it\n    () => setTimeout(handleEnforceFocus), true);\n    if (onShow) {\n      onShow();\n    }\n\n    // autofocus after onShow to not trigger a focus event for previous\n    // modals before this one is shown.\n    if (autoFocus) {\n      var _modal$dialog$ownerDo, _modal$dialog;\n      const currentActiveElement = activeElement((_modal$dialog$ownerDo = (_modal$dialog = modal.dialog) == null ? void 0 : _modal$dialog.ownerDocument) != null ? _modal$dialog$ownerDo : ownerWindow == null ? void 0 : ownerWindow.document);\n      if (modal.dialog && currentActiveElement && !contains(modal.dialog, currentActiveElement)) {\n        lastFocusRef.current = currentActiveElement;\n        modal.dialog.focus();\n      }\n    }\n  });\n  const handleHide = useEventCallback(() => {\n    modal.remove();\n    removeKeydownListenerRef.current == null ? void 0 : removeKeydownListenerRef.current();\n    removeFocusListenerRef.current == null ? void 0 : removeFocusListenerRef.current();\n    if (restoreFocus) {\n      var _lastFocusRef$current;\n      // Support: <=IE11 doesn't support `focus()` on svg elements (RB: #917)\n      (_lastFocusRef$current = lastFocusRef.current) == null ? void 0 : _lastFocusRef$current.focus == null ? void 0 : _lastFocusRef$current.focus(restoreFocusOptions);\n      lastFocusRef.current = null;\n    }\n  });\n\n  // TODO: try and combine these effects: https://github.com/react-bootstrap/react-overlays/pull/794#discussion_r409954120\n\n  // Show logic when:\n  //  - show is `true` _and_ `container` has resolved\n  useEffect(() => {\n    if (!show || !container) return;\n    handleShow();\n  }, [show, container, /* should never change: */handleShow]);\n\n  // Hide cleanup logic when:\n  //  - `exited` switches to true\n  //  - component unmounts;\n  useEffect(() => {\n    if (!exited) return;\n    handleHide();\n  }, [exited, handleHide]);\n  useWillUnmount(() => {\n    handleHide();\n  });\n\n  // --------------------------------\n\n  const handleEnforceFocus = useEventCallback(() => {\n    if (!enforceFocus || !isMounted() || !modal.isTopModal()) {\n      return;\n    }\n    const currentActiveElement = activeElement(ownerWindow == null ? void 0 : ownerWindow.document);\n    if (modal.dialog && currentActiveElement && !contains(modal.dialog, currentActiveElement)) {\n      modal.dialog.focus();\n    }\n  });\n  const handleBackdropClick = useEventCallback(e => {\n    if (e.target !== e.currentTarget) {\n      return;\n    }\n    onBackdropClick == null ? void 0 : onBackdropClick(e);\n    if (backdrop === true) {\n      onHide();\n    }\n  });\n  const handleDocumentKeyDown = useEventCallback(e => {\n    if (keyboard && isEscKey(e) && modal.isTopModal()) {\n      onEscapeKeyDown == null ? void 0 : onEscapeKeyDown(e);\n      if (!e.defaultPrevented) {\n        onHide();\n      }\n    }\n  });\n  const removeFocusListenerRef = useRef();\n  const removeKeydownListenerRef = useRef();\n  const handleHidden = (...args) => {\n    setExited(true);\n    onExited == null ? void 0 : onExited(...args);\n  };\n  if (!container) {\n    return null;\n  }\n  const dialogProps = Object.assign({\n    role,\n    ref: modal.setDialogRef,\n    // apparently only works on the dialog role element\n    'aria-modal': role === 'dialog' ? true : undefined\n  }, rest, {\n    style,\n    className,\n    tabIndex: -1\n  });\n  let dialog = renderDialog ? renderDialog(dialogProps) : /*#__PURE__*/_jsx(\"div\", Object.assign({}, dialogProps, {\n    children: /*#__PURE__*/React.cloneElement(children, {\n      role: 'document'\n    })\n  }));\n  dialog = renderTransition(transition, runTransition, {\n    unmountOnExit: true,\n    mountOnEnter: true,\n    appear: true,\n    in: !!show,\n    onExit,\n    onExiting,\n    onExited: handleHidden,\n    onEnter,\n    onEntering,\n    onEntered,\n    children: dialog\n  });\n  let backdropElement = null;\n  if (backdrop) {\n    backdropElement = renderBackdrop({\n      ref: modal.setBackdropRef,\n      onClick: handleBackdropClick\n    });\n    backdropElement = renderTransition(backdropTransition, runBackdropTransition, {\n      in: !!show,\n      appear: true,\n      mountOnEnter: true,\n      unmountOnExit: true,\n      children: backdropElement\n    });\n  }\n  return /*#__PURE__*/_jsx(_Fragment, {\n    children: /*#__PURE__*/ReactDOM.createPortal( /*#__PURE__*/_jsxs(_Fragment, {\n      children: [backdropElement, dialog]\n    }), container)\n  });\n});\nModal.displayName = 'Modal';\nexport default Object.assign(Modal, {\n  Manager: ModalManager\n});","import { useRef, useEffect } from 'react';\n\n/**\n * Track whether a component is current mounted. Generally less preferable than\n * properlly canceling effects so they don't run after a component is unmounted,\n * but helpful in cases where that isn't feasible, such as a `Promise` resolution.\n *\n * @returns a function that returns the current isMounted state of the component\n *\n * ```ts\n * const [data, setData] = useState(null)\n * const isMounted = useMounted()\n *\n * useEffect(() => {\n *   fetchdata().then((newData) => {\n *      if (isMounted()) {\n *        setData(newData);\n *      }\n *   })\n * })\n * ```\n */\nexport default function useMounted() {\n  const mounted = useRef(true);\n  const isMounted = useRef(() => mounted.current);\n  useEffect(() => {\n    mounted.current = true;\n    return () => {\n      mounted.current = false;\n    };\n  }, []);\n  return isMounted.current;\n}","import { useEffect, useRef } from 'react';\n\n/**\n * Store the last of some value. Tracked via a `Ref` only updating it\n * after the component renders.\n *\n * Helpful if you need to compare a prop value to it's previous value during render.\n *\n * ```ts\n * function Component(props) {\n *   const lastProps = usePrevious(props)\n *\n *   if (lastProps.foo !== props.foo)\n *     resetValueFromProps(props.foo)\n * }\n * ```\n *\n * @param value the value to track\n */\nexport default function usePrevious(value) {\n  const ref = useRef(null);\n  useEffect(() => {\n    ref.current = value;\n  });\n  return ref.current;\n}","import classNames from 'classnames';\nimport * as React from 'react';\nimport { useCallback } from 'react';\nimport { ENTERED, ENTERING } from 'react-transition-group/Transition';\nimport { getReactVersion } from '@restart/ui/utils';\nimport transitionEndListener from './transitionEndListener';\nimport triggerBrowserReflow from './triggerBrowserReflow';\nimport TransitionWrapper from './TransitionWrapper';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst fadeStyles = {\n  [ENTERING]: 'show',\n  [ENTERED]: 'show'\n};\nconst Fade = /*#__PURE__*/React.forwardRef(({\n  className,\n  children,\n  transitionClasses = {},\n  onEnter,\n  ...rest\n}, ref) => {\n  const props = {\n    in: false,\n    timeout: 300,\n    mountOnEnter: false,\n    unmountOnExit: false,\n    appear: false,\n    ...rest\n  };\n  const handleEnter = useCallback((node, isAppearing) => {\n    triggerBrowserReflow(node);\n    onEnter == null || onEnter(node, isAppearing);\n  }, [onEnter]);\n  const {\n    major\n  } = getReactVersion();\n  const childRef = major >= 19 ? children.props.ref : children.ref;\n  return /*#__PURE__*/_jsx(TransitionWrapper, {\n    ref: ref,\n    addEndListener: transitionEndListener,\n    ...props,\n    onEnter: handleEnter,\n    childRef: childRef,\n    children: (status, innerProps) => /*#__PURE__*/React.cloneElement(children, {\n      ...innerProps,\n      className: classNames('fade', className, children.props.className, fadeStyles[status], transitionClasses[status])\n    })\n  });\n});\nFade.displayName = 'Fade';\nexport default Fade;","\"use client\";\n\nimport * as React from 'react';\nimport classNames from 'classnames';\nimport { useBootstrapPrefix } from './ThemeProvider';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst OffcanvasBody = /*#__PURE__*/React.forwardRef(({\n  className,\n  bsPrefix,\n  as: Component = 'div',\n  ...props\n}, ref) => {\n  bsPrefix = useBootstrapPrefix(bsPrefix, 'offcanvas-body');\n  return /*#__PURE__*/_jsx(Component, {\n    ref: ref,\n    className: classNames(className, bsPrefix),\n    ...props\n  });\n});\nOffcanvasBody.displayName = 'OffcanvasBody';\nexport default OffcanvasBody;","\"use client\";\n\nimport classNames from 'classnames';\nimport * as React from 'react';\nimport { ENTERED, ENTERING, EXITING } from 'react-transition-group/Transition';\nimport transitionEndListener from './transitionEndListener';\nimport TransitionWrapper from './TransitionWrapper';\nimport { useBootstrapPrefix } from './ThemeProvider';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst transitionStyles = {\n  [ENTERING]: 'show',\n  [ENTERED]: 'show'\n};\nconst OffcanvasToggling = /*#__PURE__*/React.forwardRef(({\n  bsPrefix,\n  className,\n  children,\n  in: inProp = false,\n  mountOnEnter = false,\n  unmountOnExit = false,\n  appear = false,\n  ...props\n}, ref) => {\n  bsPrefix = useBootstrapPrefix(bsPrefix, 'offcanvas');\n  return /*#__PURE__*/_jsx(TransitionWrapper, {\n    ref: ref,\n    addEndListener: transitionEndListener,\n    in: inProp,\n    mountOnEnter: mountOnEnter,\n    unmountOnExit: unmountOnExit,\n    appear: appear,\n    ...props,\n    childRef: children.ref,\n    children: (status, innerProps) => /*#__PURE__*/React.cloneElement(children, {\n      ...innerProps,\n      className: classNames(className, children.props.className, (status === ENTERING || status === EXITING) && `${bsPrefix}-toggling`, transitionStyles[status])\n    })\n  });\n});\nOffcanvasToggling.displayName = 'OffcanvasToggling';\nexport default OffcanvasToggling;","\"use client\";\n\nimport * as React from 'react';\nconst ModalContext = /*#__PURE__*/React.createContext({\n  // eslint-disable-next-line @typescript-eslint/no-empty-function\n  onHide() {}\n});\nexport default ModalContext;","import PropTypes from 'prop-types';\nimport * as React from 'react';\nimport classNames from 'classnames';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst propTypes = {\n  /** An accessible label indicating the relevant information about the Close Button. */\n  'aria-label': PropTypes.string,\n  /** A callback fired after the Close Button is clicked. */\n  onClick: PropTypes.func,\n  /**\n   * Render different color variant for the button.\n   *\n   * Omitting this will render the default dark color.\n   */\n  variant: PropTypes.oneOf(['white'])\n};\nconst CloseButton = /*#__PURE__*/React.forwardRef(({\n  className,\n  variant,\n  'aria-label': ariaLabel = 'Close',\n  ...props\n}, ref) => /*#__PURE__*/_jsx(\"button\", {\n  ref: ref,\n  type: \"button\",\n  className: classNames('btn-close', variant && `btn-close-${variant}`, className),\n  \"aria-label\": ariaLabel,\n  ...props\n}));\nCloseButton.displayName = 'CloseButton';\nCloseButton.propTypes = propTypes;\nexport default CloseButton;","\"use client\";\n\nimport * as React from 'react';\nimport { useContext } from 'react';\nimport useEventCallback from '@restart/hooks/useEventCallback';\nimport CloseButton from './CloseButton';\nimport ModalContext from './ModalContext';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nimport { jsxs as _jsxs } from \"react/jsx-runtime\";\nconst AbstractModalHeader = /*#__PURE__*/React.forwardRef(({\n  closeLabel = 'Close',\n  closeVariant,\n  closeButton = false,\n  onHide,\n  children,\n  ...props\n}, ref) => {\n  const context = useContext(ModalContext);\n  const handleClick = useEventCallback(() => {\n    context == null || context.onHide();\n    onHide == null || onHide();\n  });\n  return /*#__PURE__*/_jsxs(\"div\", {\n    ref: ref,\n    ...props,\n    children: [children, closeButton && /*#__PURE__*/_jsx(CloseButton, {\n      \"aria-label\": closeLabel,\n      variant: closeVariant,\n      onClick: handleClick\n    })]\n  });\n});\nexport default AbstractModalHeader;","\"use client\";\n\nimport classNames from 'classnames';\nimport * as React from 'react';\nimport { useBootstrapPrefix } from './ThemeProvider';\nimport AbstractModalHeader from './AbstractModalHeader';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst OffcanvasHeader = /*#__PURE__*/React.forwardRef(({\n  bsPrefix,\n  className,\n  closeLabel = 'Close',\n  closeButton = false,\n  ...props\n}, ref) => {\n  bsPrefix = useBootstrapPrefix(bsPrefix, 'offcanvas-header');\n  return /*#__PURE__*/_jsx(AbstractModalHeader, {\n    ref: ref,\n    ...props,\n    className: classNames(className, bsPrefix),\n    closeLabel: closeLabel,\n    closeButton: closeButton\n  });\n});\nOffcanvasHeader.displayName = 'OffcanvasHeader';\nexport default OffcanvasHeader;","import * as React from 'react';\nimport classNames from 'classnames';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport default (className => /*#__PURE__*/React.forwardRef((p, ref) => /*#__PURE__*/_jsx(\"div\", {\n  ...p,\n  ref: ref,\n  className: classNames(p.className, className)\n})));","\"use client\";\n\nimport * as React from 'react';\nimport classNames from 'classnames';\nimport divWithClassName from './divWithClassName';\nimport { useBootstrapPrefix } from './ThemeProvider';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst DivStyledAsH5 = divWithClassName('h5');\nconst OffcanvasTitle = /*#__PURE__*/React.forwardRef(({\n  className,\n  bsPrefix,\n  as: Component = DivStyledAsH5,\n  ...props\n}, ref) => {\n  bsPrefix = useBootstrapPrefix(bsPrefix, 'offcanvas-title');\n  return /*#__PURE__*/_jsx(Component, {\n    ref: ref,\n    className: classNames(className, bsPrefix),\n    ...props\n  });\n});\nOffcanvasTitle.displayName = 'OffcanvasTitle';\nexport default OffcanvasTitle;","var toArray = Function.prototype.bind.call(Function.prototype.call, [].slice);\n/**\n * Runs `querySelectorAll` on a given element.\n * \n * @param element the element\n * @param selector the selector\n */\n\nexport default function qsa(element, selector) {\n  return toArray(element.querySelectorAll(selector));\n}","function replaceClassName(origClass, classToRemove) {\n  return origClass.replace(new RegExp(\"(^|\\\\s)\" + classToRemove + \"(?:\\\\s|$)\", 'g'), '$1').replace(/\\s+/g, ' ').replace(/^\\s*|\\s*$/g, '');\n}\n/**\n * Removes a CSS class from a given element.\n * \n * @param element the element\n * @param className the CSS class name\n */\n\n\nexport default function removeClass(element, className) {\n  if (element.classList) {\n    element.classList.remove(className);\n  } else if (typeof element.className === 'string') {\n    element.className = replaceClassName(element.className, className);\n  } else {\n    element.setAttribute('class', replaceClassName(element.className && element.className.baseVal || '', className));\n  }\n}","import addClass from 'dom-helpers/addClass';\nimport css from 'dom-helpers/css';\nimport qsa from 'dom-helpers/querySelectorAll';\nimport removeClass from 'dom-helpers/removeClass';\nimport ModalManager from '@restart/ui/ModalManager';\nconst Selector = {\n  FIXED_CONTENT: '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top',\n  STICKY_CONTENT: '.sticky-top',\n  NAVBAR_TOGGLER: '.navbar-toggler'\n};\nclass BootstrapModalManager extends ModalManager {\n  adjustAndStore(prop, element, adjust) {\n    const actual = element.style[prop];\n    // TODO: DOMStringMap and CSSStyleDeclaration aren't strictly compatible\n    // @ts-ignore\n    element.dataset[prop] = actual;\n    css(element, {\n      [prop]: `${parseFloat(css(element, prop)) + adjust}px`\n    });\n  }\n  restore(prop, element) {\n    const value = element.dataset[prop];\n    if (value !== undefined) {\n      delete element.dataset[prop];\n      css(element, {\n        [prop]: value\n      });\n    }\n  }\n  setContainerStyle(containerState) {\n    super.setContainerStyle(containerState);\n    const container = this.getElement();\n    addClass(container, 'modal-open');\n    if (!containerState.scrollBarWidth) return;\n    const paddingProp = this.isRTL ? 'paddingLeft' : 'paddingRight';\n    const marginProp = this.isRTL ? 'marginLeft' : 'marginRight';\n    qsa(container, Selector.FIXED_CONTENT).forEach(el => this.adjustAndStore(paddingProp, el, containerState.scrollBarWidth));\n    qsa(container, Selector.STICKY_CONTENT).forEach(el => this.adjustAndStore(marginProp, el, -containerState.scrollBarWidth));\n    qsa(container, Selector.NAVBAR_TOGGLER).forEach(el => this.adjustAndStore(marginProp, el, containerState.scrollBarWidth));\n  }\n  removeContainerStyle(containerState) {\n    super.removeContainerStyle(containerState);\n    const container = this.getElement();\n    removeClass(container, 'modal-open');\n    const paddingProp = this.isRTL ? 'paddingLeft' : 'paddingRight';\n    const marginProp = this.isRTL ? 'marginLeft' : 'marginRight';\n    qsa(container, Selector.FIXED_CONTENT).forEach(el => this.restore(paddingProp, el));\n    qsa(container, Selector.STICKY_CONTENT).forEach(el => this.restore(marginProp, el));\n    qsa(container, Selector.NAVBAR_TOGGLER).forEach(el => this.restore(marginProp, el));\n  }\n}\nlet sharedManager;\nexport function getSharedManager(options) {\n  if (!sharedManager) sharedManager = new BootstrapModalManager(options);\n  return sharedManager;\n}\nexport default BootstrapModalManager;","import hasClass from './hasClass';\n/**\n * Adds a CSS class to a given element.\n * \n * @param element the element\n * @param className the CSS class name\n */\n\nexport default function addClass(element, className) {\n  if (element.classList) element.classList.add(className);else if (!hasClass(element, className)) if (typeof element.className === 'string') element.className = element.className + \" \" + className;else element.setAttribute('class', (element.className && element.className.baseVal || '') + \" \" + className);\n}","/**\n * Checks if a given element has a CSS class.\n * \n * @param element the element\n * @param className the CSS class name\n */\nexport default function hasClass(element, className) {\n  if (element.classList) return !!className && element.classList.contains(className);\n  return (\" \" + (element.className.baseVal || element.className) + \" \").indexOf(\" \" + className + \" \") !== -1;\n}","\"use client\";\n\nimport classNames from 'classnames';\nimport useBreakpoint from '@restart/hooks/useBreakpoint';\nimport useEventCallback from '@restart/hooks/useEventCallback';\nimport * as React from 'react';\nimport { useCallback, useEffect, useMemo, useRef, useState } from 'react';\nimport BaseModal from '@restart/ui/Modal';\nimport Fade from './Fade';\nimport OffcanvasBody from './OffcanvasBody';\nimport OffcanvasToggling from './OffcanvasToggling';\nimport ModalContext from './ModalContext';\nimport OffcanvasHeader from './OffcanvasHeader';\nimport OffcanvasTitle from './OffcanvasTitle';\nimport { useBootstrapPrefix } from './ThemeProvider';\nimport BootstrapModalManager, { getSharedManager } from './BootstrapModalManager';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nimport { Fragment as _Fragment } from \"react/jsx-runtime\";\nimport { jsxs as _jsxs } from \"react/jsx-runtime\";\nfunction DialogTransition(props) {\n  return /*#__PURE__*/_jsx(OffcanvasToggling, {\n    ...props\n  });\n}\nfunction BackdropTransition(props) {\n  return /*#__PURE__*/_jsx(Fade, {\n    ...props\n  });\n}\nconst Offcanvas = /*#__PURE__*/React.forwardRef(({\n  bsPrefix,\n  className,\n  children,\n  'aria-labelledby': ariaLabelledby,\n  placement = 'start',\n  responsive,\n  /* BaseModal props */\n\n  show = false,\n  backdrop = true,\n  keyboard = true,\n  scroll = false,\n  onEscapeKeyDown,\n  onShow,\n  onHide,\n  container,\n  autoFocus = true,\n  enforceFocus = true,\n  restoreFocus = true,\n  restoreFocusOptions,\n  onEntered,\n  onExit,\n  onExiting,\n  onEnter,\n  onEntering,\n  onExited,\n  backdropClassName,\n  manager: propsManager,\n  renderStaticNode = false,\n  ...props\n}, ref) => {\n  const modalManager = useRef();\n  bsPrefix = useBootstrapPrefix(bsPrefix, 'offcanvas');\n  const [showOffcanvas, setShowOffcanvas] = useState(false);\n  const handleHide = useEventCallback(onHide);\n  const hideResponsiveOffcanvas = useBreakpoint(responsive || 'xs', 'up');\n  useEffect(() => {\n    // Handles the case where screen is resized while the responsive\n    // offcanvas is shown. If `responsive` not provided, just use `show`.\n    setShowOffcanvas(responsive ? show && !hideResponsiveOffcanvas : show);\n  }, [show, responsive, hideResponsiveOffcanvas]);\n  const modalContext = useMemo(() => ({\n    onHide: handleHide\n  }), [handleHide]);\n  function getModalManager() {\n    if (propsManager) return propsManager;\n    if (scroll) {\n      // Have to use a different modal manager since the shared\n      // one handles overflow.\n      if (!modalManager.current) modalManager.current = new BootstrapModalManager({\n        handleContainerOverflow: false\n      });\n      return modalManager.current;\n    }\n    return getSharedManager();\n  }\n  const handleEnter = (node, ...args) => {\n    if (node) node.style.visibility = 'visible';\n    onEnter == null || onEnter(node, ...args);\n  };\n  const handleExited = (node, ...args) => {\n    if (node) node.style.visibility = '';\n    onExited == null || onExited(...args);\n  };\n  const renderBackdrop = useCallback(backdropProps => /*#__PURE__*/_jsx(\"div\", {\n    ...backdropProps,\n    className: classNames(`${bsPrefix}-backdrop`, backdropClassName)\n  }), [backdropClassName, bsPrefix]);\n  const renderDialog = dialogProps => /*#__PURE__*/_jsx(\"div\", {\n    ...dialogProps,\n    ...props,\n    className: classNames(className, responsive ? `${bsPrefix}-${responsive}` : bsPrefix, `${bsPrefix}-${placement}`),\n    \"aria-labelledby\": ariaLabelledby,\n    children: children\n  });\n  return /*#__PURE__*/_jsxs(_Fragment, {\n    children: [!showOffcanvas && (responsive || renderStaticNode) && renderDialog({}), /*#__PURE__*/_jsx(ModalContext.Provider, {\n      value: modalContext,\n      children: /*#__PURE__*/_jsx(BaseModal, {\n        show: showOffcanvas,\n        ref: ref,\n        backdrop: backdrop,\n        container: container,\n        keyboard: keyboard,\n        autoFocus: autoFocus,\n        enforceFocus: enforceFocus && !scroll,\n        restoreFocus: restoreFocus,\n        restoreFocusOptions: restoreFocusOptions,\n        onEscapeKeyDown: onEscapeKeyDown,\n        onShow: onShow,\n        onHide: handleHide,\n        onEnter: handleEnter,\n        onEntering: onEntering,\n        onEntered: onEntered,\n        onExit: onExit,\n        onExiting: onExiting,\n        onExited: handleExited,\n        manager: getModalManager(),\n        transition: DialogTransition,\n        backdropTransition: BackdropTransition,\n        renderBackdrop: renderBackdrop,\n        renderDialog: renderDialog\n      })\n    })]\n  });\n});\nOffcanvas.displayName = 'Offcanvas';\nexport default Object.assign(Offcanvas, {\n  Body: OffcanvasBody,\n  Header: OffcanvasHeader,\n  Title: OffcanvasTitle\n});","\"use client\";\n\nimport * as React from 'react';\nimport { useContext } from 'react';\nimport useEventCallback from '@restart/hooks/useEventCallback';\nimport Offcanvas from './Offcanvas';\nimport NavbarContext from './NavbarContext';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst NavbarOffcanvas = /*#__PURE__*/React.forwardRef(({\n  onHide,\n  ...props\n}, ref) => {\n  const context = useContext(NavbarContext);\n  const handleHide = useEventCallback(() => {\n    context == null || context.onToggle == null || context.onToggle();\n    onHide == null || onHide();\n  });\n  return /*#__PURE__*/_jsx(Offcanvas, {\n    ref: ref,\n    show: !!(context != null && context.expanded),\n    ...props,\n    renderStaticNode: true,\n    onHide: handleHide\n  });\n});\nNavbarOffcanvas.displayName = 'NavbarOffcanvas';\nexport default NavbarOffcanvas;","\"use client\";\n\nimport * as React from 'react';\nimport classNames from 'classnames';\nimport { useBootstrapPrefix } from './ThemeProvider';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst NavbarText = /*#__PURE__*/React.forwardRef(({\n  className,\n  bsPrefix,\n  as: Component = 'span',\n  ...props\n}, ref) => {\n  bsPrefix = useBootstrapPrefix(bsPrefix, 'navbar-text');\n  return /*#__PURE__*/_jsx(Component, {\n    ref: ref,\n    className: classNames(className, bsPrefix),\n    ...props\n  });\n});\nNavbarText.displayName = 'NavbarText';\nexport default NavbarText;","\"use client\";\n\nimport classNames from 'classnames';\nimport * as React from 'react';\nimport { useCallback, useMemo } from 'react';\nimport SelectableContext from '@restart/ui/SelectableContext';\nimport { useUncontrolled } from 'uncontrollable';\nimport NavbarBrand from './NavbarBrand';\nimport NavbarCollapse from './NavbarCollapse';\nimport NavbarToggle from './NavbarToggle';\nimport NavbarOffcanvas from './NavbarOffcanvas';\nimport { useBootstrapPrefix } from './ThemeProvider';\nimport NavbarContext from './NavbarContext';\nimport NavbarText from './NavbarText';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst Navbar = /*#__PURE__*/React.forwardRef((props, ref) => {\n  const {\n    bsPrefix: initialBsPrefix,\n    expand = true,\n    variant = 'light',\n    bg,\n    fixed,\n    sticky,\n    className,\n    // Need to define the default \"as\" during prop destructuring to be compatible with styled-components github.com/react-bootstrap/react-bootstrap/issues/3595\n    as: Component = 'nav',\n    expanded,\n    onToggle,\n    onSelect,\n    collapseOnSelect = false,\n    ...controlledProps\n  } = useUncontrolled(props, {\n    expanded: 'onToggle'\n  });\n  const bsPrefix = useBootstrapPrefix(initialBsPrefix, 'navbar');\n  const handleCollapse = useCallback((...args) => {\n    onSelect == null || onSelect(...args);\n    if (collapseOnSelect && expanded) {\n      onToggle == null || onToggle(false);\n    }\n  }, [onSelect, collapseOnSelect, expanded, onToggle]);\n\n  // will result in some false positives but that seems better\n  // than false negatives. strict `undefined` check allows explicit\n  // \"nulling\" of the role if the user really doesn't want one\n  if (controlledProps.role === undefined && Component !== 'nav') {\n    controlledProps.role = 'navigation';\n  }\n  let expandClass = `${bsPrefix}-expand`;\n  if (typeof expand === 'string') expandClass = `${expandClass}-${expand}`;\n  const navbarContext = useMemo(() => ({\n    onToggle: () => onToggle == null ? void 0 : onToggle(!expanded),\n    bsPrefix,\n    expanded: !!expanded,\n    expand\n  }), [bsPrefix, expanded, expand, onToggle]);\n  return /*#__PURE__*/_jsx(NavbarContext.Provider, {\n    value: navbarContext,\n    children: /*#__PURE__*/_jsx(SelectableContext.Provider, {\n      value: handleCollapse,\n      children: /*#__PURE__*/_jsx(Component, {\n        ref: ref,\n        ...controlledProps,\n        className: classNames(className, bsPrefix, expand && expandClass, variant && `${bsPrefix}-${variant}`, bg && `bg-${bg}`, sticky && `sticky-${sticky}`, fixed && `fixed-${fixed}`)\n      })\n    })\n  });\n});\nNavbar.displayName = 'Navbar';\nexport default Object.assign(Navbar, {\n  Brand: NavbarBrand,\n  Collapse: NavbarCollapse,\n  Offcanvas: NavbarOffcanvas,\n  Text: NavbarText,\n  Toggle: NavbarToggle\n});","\"use client\";\n\nimport classNames from 'classnames';\nimport * as React from 'react';\nimport { useBootstrapPrefix } from './ThemeProvider';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst Container = /*#__PURE__*/React.forwardRef(({\n  bsPrefix,\n  fluid = false,\n  // Need to define the default \"as\" during prop destructuring to be compatible with styled-components github.com/react-bootstrap/react-bootstrap/issues/3595\n  as: Component = 'div',\n  className,\n  ...props\n}, ref) => {\n  const prefix = useBootstrapPrefix(bsPrefix, 'container');\n  const suffix = typeof fluid === 'string' ? `-${fluid}` : '-fluid';\n  return /*#__PURE__*/_jsx(Component, {\n    ref: ref,\n    ...props,\n    className: classNames(className, fluid ? `${prefix}${suffix}` : prefix)\n  });\n});\nContainer.displayName = 'Container';\nexport default Container;","import * as React from 'react';\nconst NavContext = /*#__PURE__*/React.createContext(null);\nNavContext.displayName = 'NavContext';\nexport default NavContext;","import * as React from 'react';\nconst TabContext = /*#__PURE__*/React.createContext(null);\nexport default TabContext;","const _excluded = [\"as\", \"disabled\"];\nfunction _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (e.indexOf(n) >= 0) continue; t[n] = r[n]; } return t; }\nimport * as React from 'react';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport function isTrivialHref(href) {\n  return !href || href.trim() === '#';\n}\nexport function useButtonProps({\n  tagName,\n  disabled,\n  href,\n  target,\n  rel,\n  role,\n  onClick,\n  tabIndex = 0,\n  type\n}) {\n  if (!tagName) {\n    if (href != null || target != null || rel != null) {\n      tagName = 'a';\n    } else {\n      tagName = 'button';\n    }\n  }\n  const meta = {\n    tagName\n  };\n  if (tagName === 'button') {\n    return [{\n      type: type || 'button',\n      disabled\n    }, meta];\n  }\n  const handleClick = event => {\n    if (disabled || tagName === 'a' && isTrivialHref(href)) {\n      event.preventDefault();\n    }\n    if (disabled) {\n      event.stopPropagation();\n      return;\n    }\n    onClick == null ? void 0 : onClick(event);\n  };\n  const handleKeyDown = event => {\n    if (event.key === ' ') {\n      event.preventDefault();\n      handleClick(event);\n    }\n  };\n  if (tagName === 'a') {\n    // Ensure there's a href so Enter can trigger anchor button.\n    href || (href = '#');\n    if (disabled) {\n      href = undefined;\n    }\n  }\n  return [{\n    role: role != null ? role : 'button',\n    // explicitly undefined so that it overrides the props disabled in a spread\n    // e.g. <Tag {...props} {...hookProps} />\n    disabled: undefined,\n    tabIndex: disabled ? undefined : tabIndex,\n    href,\n    target: tagName === 'a' ? target : undefined,\n    'aria-disabled': !disabled ? undefined : disabled,\n    rel: tagName === 'a' ? rel : undefined,\n    onClick: handleClick,\n    onKeyDown: handleKeyDown\n  }, meta];\n}\nconst Button = /*#__PURE__*/React.forwardRef((_ref, ref) => {\n  let {\n      as: asProp,\n      disabled\n    } = _ref,\n    props = _objectWithoutPropertiesLoose(_ref, _excluded);\n  const [buttonProps, {\n    tagName: Component\n  }] = useButtonProps(Object.assign({\n    tagName: asProp,\n    disabled\n  }, props));\n  return /*#__PURE__*/_jsx(Component, Object.assign({}, props, buttonProps, {\n    ref: ref\n  }));\n});\nButton.displayName = 'Button';\nexport default Button;","const _excluded = [\"as\", \"active\", \"eventKey\"];\nfunction _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (e.indexOf(n) >= 0) continue; t[n] = r[n]; } return t; }\nimport * as React from 'react';\nimport { useContext } from 'react';\nimport useEventCallback from '@restart/hooks/useEventCallback';\nimport NavContext from './NavContext';\nimport SelectableContext, { makeEventKey } from './SelectableContext';\nimport Button from './Button';\nimport { dataAttr } from './DataKey';\nimport TabContext from './TabContext';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport function useNavItem({\n  key,\n  onClick,\n  active,\n  id,\n  role,\n  disabled\n}) {\n  const parentOnSelect = useContext(SelectableContext);\n  const navContext = useContext(NavContext);\n  const tabContext = useContext(TabContext);\n  let isActive = active;\n  const props = {\n    role\n  };\n  if (navContext) {\n    if (!role && navContext.role === 'tablist') props.role = 'tab';\n    const contextControllerId = navContext.getControllerId(key != null ? key : null);\n    const contextControlledId = navContext.getControlledId(key != null ? key : null);\n\n    // @ts-ignore\n    props[dataAttr('event-key')] = key;\n    props.id = contextControllerId || id;\n    isActive = active == null && key != null ? navContext.activeKey === key : active;\n\n    /**\n     * Simplified scenario for `mountOnEnter`.\n     *\n     * While it would make sense to keep 'aria-controls' for tabs that have been mounted at least\n     * once, it would also complicate the code quite a bit, for very little gain.\n     * The following implementation is probably good enough.\n     *\n     * @see https://github.com/react-restart/ui/pull/40#issuecomment-1009971561\n     */\n    if (isActive || !(tabContext != null && tabContext.unmountOnExit) && !(tabContext != null && tabContext.mountOnEnter)) props['aria-controls'] = contextControlledId;\n  }\n  if (props.role === 'tab') {\n    props['aria-selected'] = isActive;\n    if (!isActive) {\n      props.tabIndex = -1;\n    }\n    if (disabled) {\n      props.tabIndex = -1;\n      props['aria-disabled'] = true;\n    }\n  }\n  props.onClick = useEventCallback(e => {\n    if (disabled) return;\n    onClick == null ? void 0 : onClick(e);\n    if (key == null) {\n      return;\n    }\n    if (parentOnSelect && !e.isPropagationStopped()) {\n      parentOnSelect(key, e);\n    }\n  });\n  return [props, {\n    isActive\n  }];\n}\nconst NavItem = /*#__PURE__*/React.forwardRef((_ref, ref) => {\n  let {\n      as: Component = Button,\n      active,\n      eventKey\n    } = _ref,\n    options = _objectWithoutPropertiesLoose(_ref, _excluded);\n  const [props, meta] = useNavItem(Object.assign({\n    key: makeEventKey(eventKey, options.href),\n    active\n  }, options));\n\n  // @ts-ignore\n  props[dataAttr('active')] = meta.isActive;\n  return /*#__PURE__*/_jsx(Component, Object.assign({}, options, props, {\n    ref: ref\n  }));\n});\nNavItem.displayName = 'NavItem';\nexport default NavItem;","const _excluded = [\"as\", \"onSelect\", \"activeKey\", \"role\", \"onKeyDown\"];\nfunction _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (e.indexOf(n) >= 0) continue; t[n] = r[n]; } return t; }\nimport qsa from 'dom-helpers/querySelectorAll';\nimport * as React from 'react';\nimport { useContext, useEffect, useRef } from 'react';\nimport useForceUpdate from '@restart/hooks/useForceUpdate';\nimport useMergedRefs from '@restart/hooks/useMergedRefs';\nimport NavContext from './NavContext';\nimport SelectableContext, { makeEventKey } from './SelectableContext';\nimport TabContext from './TabContext';\nimport { dataAttr, dataProp } from './DataKey';\nimport NavItem from './NavItem';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\n// eslint-disable-next-line @typescript-eslint/no-empty-function\nconst noop = () => {};\nconst EVENT_KEY_ATTR = dataAttr('event-key');\nconst Nav = /*#__PURE__*/React.forwardRef((_ref, ref) => {\n  let {\n      // Need to define the default \"as\" during prop destructuring to be compatible with styled-components github.com/react-bootstrap/react-bootstrap/issues/3595\n      as: Component = 'div',\n      onSelect,\n      activeKey,\n      role,\n      onKeyDown\n    } = _ref,\n    props = _objectWithoutPropertiesLoose(_ref, _excluded);\n  // A ref and forceUpdate for refocus, b/c we only want to trigger when needed\n  // and don't want to reset the set in the effect\n  const forceUpdate = useForceUpdate();\n  const needsRefocusRef = useRef(false);\n  const parentOnSelect = useContext(SelectableContext);\n  const tabContext = useContext(TabContext);\n  let getControlledId, getControllerId;\n  if (tabContext) {\n    role = role || 'tablist';\n    activeKey = tabContext.activeKey;\n    // TODO: do we need to duplicate these?\n    getControlledId = tabContext.getControlledId;\n    getControllerId = tabContext.getControllerId;\n  }\n  const listNode = useRef(null);\n  const getNextActiveTab = offset => {\n    const currentListNode = listNode.current;\n    if (!currentListNode) return null;\n    const items = qsa(currentListNode, `[${EVENT_KEY_ATTR}]:not([aria-disabled=true])`);\n    const activeChild = currentListNode.querySelector('[aria-selected=true]');\n    if (!activeChild || activeChild !== document.activeElement) return null;\n    const index = items.indexOf(activeChild);\n    if (index === -1) return null;\n    let nextIndex = index + offset;\n    if (nextIndex >= items.length) nextIndex = 0;\n    if (nextIndex < 0) nextIndex = items.length - 1;\n    return items[nextIndex];\n  };\n  const handleSelect = (key, event) => {\n    if (key == null) return;\n    onSelect == null ? void 0 : onSelect(key, event);\n    parentOnSelect == null ? void 0 : parentOnSelect(key, event);\n  };\n  const handleKeyDown = event => {\n    onKeyDown == null ? void 0 : onKeyDown(event);\n    if (!tabContext) {\n      return;\n    }\n    let nextActiveChild;\n    switch (event.key) {\n      case 'ArrowLeft':\n      case 'ArrowUp':\n        nextActiveChild = getNextActiveTab(-1);\n        break;\n      case 'ArrowRight':\n      case 'ArrowDown':\n        nextActiveChild = getNextActiveTab(1);\n        break;\n      default:\n        return;\n    }\n    if (!nextActiveChild) return;\n    event.preventDefault();\n    handleSelect(nextActiveChild.dataset[dataProp('EventKey')] || null, event);\n    needsRefocusRef.current = true;\n    forceUpdate();\n  };\n  useEffect(() => {\n    if (listNode.current && needsRefocusRef.current) {\n      const activeChild = listNode.current.querySelector(`[${EVENT_KEY_ATTR}][aria-selected=true]`);\n      activeChild == null ? void 0 : activeChild.focus();\n    }\n    needsRefocusRef.current = false;\n  });\n  const mergedRef = useMergedRefs(ref, listNode);\n  return /*#__PURE__*/_jsx(SelectableContext.Provider, {\n    value: handleSelect,\n    children: /*#__PURE__*/_jsx(NavContext.Provider, {\n      value: {\n        role,\n        // used by NavLink to determine it's role\n        activeKey: makeEventKey(activeKey),\n        getControlledId: getControlledId || noop,\n        getControllerId: getControllerId || noop\n      },\n      children: /*#__PURE__*/_jsx(Component, Object.assign({}, props, {\n        onKeyDown: handleKeyDown,\n        ref: mergedRef,\n        role: role\n      }))\n    })\n  });\n});\nNav.displayName = 'Nav';\nexport default Object.assign(Nav, {\n  Item: NavItem\n});","import { useReducer } from 'react';\n\n/**\n * Returns a function that triggers a component update. the hook equivalent to\n * `this.forceUpdate()` in a class component. In most cases using a state value directly\n * is preferable but may be required in some advanced usages of refs for interop or\n * when direct DOM manipulation is required.\n *\n * ```ts\n * const forceUpdate = useForceUpdate();\n *\n * const updateOnClick = useCallback(() => {\n *  forceUpdate()\n * }, [forceUpdate])\n *\n * return <button type=\"button\" onClick={updateOnClick}>Hi there</button>\n * ```\n */\nexport default function useForceUpdate() {\n  // The toggling state value is designed to defeat React optimizations for skipping\n  // updates when they are strictly equal to the last state value\n  const [, dispatch] = useReducer(state => !state, false);\n  return dispatch;\n}","\"use client\";\n\nimport * as React from 'react';\nconst context = /*#__PURE__*/React.createContext(null);\ncontext.displayName = 'CardHeaderContext';\nexport default context;","\"use client\";\n\nimport * as React from 'react';\nimport classNames from 'classnames';\nimport { useBootstrapPrefix } from './ThemeProvider';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst NavItem = /*#__PURE__*/React.forwardRef(({\n  className,\n  bsPrefix,\n  as: Component = 'div',\n  ...props\n}, ref) => {\n  bsPrefix = useBootstrapPrefix(bsPrefix, 'nav-item');\n  return /*#__PURE__*/_jsx(Component, {\n    ref: ref,\n    className: classNames(className, bsPrefix),\n    ...props\n  });\n});\nNavItem.displayName = 'NavItem';\nexport default NavItem;","import { useState } from 'react';\nimport useEffect from './useIsomorphicEffect';\nconst targetMap = new WeakMap();\nlet resizeObserver;\nfunction getResizeObserver() {\n  // eslint-disable-next-line no-return-assign\n  return resizeObserver = resizeObserver || new window.ResizeObserver(entries => {\n    entries.forEach(entry => {\n      const handler = targetMap.get(entry.target);\n      if (handler) handler(entry.contentRect);\n    });\n  });\n}\n\n/**\n * Efficiently observe size changes on an element. Depends on the `ResizeObserver` api,\n * and polyfills are needed in older browsers.\n *\n * ```ts\n * const [ref, attachRef] = useCallbackRef(null);\n *\n * const rect = useResizeObserver(ref);\n *\n * return (\n *  <div ref={attachRef}>\n *    {JSON.stringify(rect)}\n *  </div>\n * )\n * ```\n *\n * @param element The DOM element to observe\n */\nexport default function useResizeObserver(element) {\n  const [rect, setRect] = useState(null);\n  useEffect(() => {\n    if (!element) return;\n    getResizeObserver().observe(element);\n    setRect(element.getBoundingClientRect());\n    targetMap.set(element, rect => {\n      setRect(rect);\n    });\n    return () => {\n      targetMap.delete(element);\n    };\n  }, [element]);\n  return rect;\n}","const _excluded = [\"onKeyDown\"];\nfunction _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (e.indexOf(n) >= 0) continue; t[n] = r[n]; } return t; }\n/* eslint-disable jsx-a11y/no-static-element-interactions */\n/* eslint-disable jsx-a11y/anchor-has-content */\n\nimport * as React from 'react';\nimport { useEventCallback } from '@restart/hooks';\nimport { useButtonProps } from './Button';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport function isTrivialHref(href) {\n  return !href || href.trim() === '#';\n}\n/**\n * An generic `<a>` component that covers a few A11y cases, ensuring that\n * cases where the `href` is missing or trivial like \"#\" are treated like buttons.\n */\nconst Anchor = /*#__PURE__*/React.forwardRef((_ref, ref) => {\n  let {\n      onKeyDown\n    } = _ref,\n    props = _objectWithoutPropertiesLoose(_ref, _excluded);\n  const [buttonProps] = useButtonProps(Object.assign({\n    tagName: 'a'\n  }, props));\n  const handleKeyDown = useEventCallback(e => {\n    buttonProps.onKeyDown(e);\n    onKeyDown == null ? void 0 : onKeyDown(e);\n  });\n  if (isTrivialHref(props.href) || props.role === 'button') {\n    return /*#__PURE__*/_jsx(\"a\", Object.assign({\n      ref: ref\n    }, props, buttonProps, {\n      onKeyDown: handleKeyDown\n    }));\n  }\n  return /*#__PURE__*/_jsx(\"a\", Object.assign({\n    ref: ref\n  }, props, {\n    onKeyDown: onKeyDown\n  }));\n});\nAnchor.displayName = 'Anchor';\nexport default Anchor;","\"use client\";\n\nimport classNames from 'classnames';\nimport * as React from 'react';\nimport Anchor from '@restart/ui/Anchor';\nimport { useNavItem } from '@restart/ui/NavItem';\nimport { makeEventKey } from '@restart/ui/SelectableContext';\nimport { useBootstrapPrefix } from './ThemeProvider';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst NavLink = /*#__PURE__*/React.forwardRef(({\n  bsPrefix,\n  className,\n  as: Component = Anchor,\n  active,\n  eventKey,\n  disabled = false,\n  ...props\n}, ref) => {\n  bsPrefix = useBootstrapPrefix(bsPrefix, 'nav-link');\n  const [navItemProps, meta] = useNavItem({\n    key: makeEventKey(eventKey, props.href),\n    active,\n    disabled,\n    ...props\n  });\n  return /*#__PURE__*/_jsx(Component, {\n    ...props,\n    ...navItemProps,\n    ref: ref,\n    disabled: disabled,\n    className: classNames(className, bsPrefix, disabled && 'disabled', meta.isActive && 'active')\n  });\n});\nNavLink.displayName = 'NavLink';\nexport default NavLink;","\"use client\";\n\nimport classNames from 'classnames';\nimport all from 'prop-types-extra/lib/all';\nimport * as React from 'react';\nimport { useContext } from 'react';\nimport { useUncontrolled } from 'uncontrollable';\nimport BaseNav from '@restart/ui/Nav';\nimport { useBootstrapPrefix } from './ThemeProvider';\nimport NavbarContext from './NavbarContext';\nimport CardHeaderContext from './CardHeaderContext';\nimport NavItem from './NavItem';\nimport NavLink from './NavLink';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst Nav = /*#__PURE__*/React.forwardRef((uncontrolledProps, ref) => {\n  const {\n    as = 'div',\n    bsPrefix: initialBsPrefix,\n    variant,\n    fill = false,\n    justify = false,\n    navbar,\n    navbarScroll,\n    className,\n    activeKey,\n    ...props\n  } = useUncontrolled(uncontrolledProps, {\n    activeKey: 'onSelect'\n  });\n  const bsPrefix = useBootstrapPrefix(initialBsPrefix, 'nav');\n  let navbarBsPrefix;\n  let cardHeaderBsPrefix;\n  let isNavbar = false;\n  const navbarContext = useContext(NavbarContext);\n  const cardHeaderContext = useContext(CardHeaderContext);\n  if (navbarContext) {\n    navbarBsPrefix = navbarContext.bsPrefix;\n    isNavbar = navbar == null ? true : navbar;\n  } else if (cardHeaderContext) {\n    ({\n      cardHeaderBsPrefix\n    } = cardHeaderContext);\n  }\n  return /*#__PURE__*/_jsx(BaseNav, {\n    as: as,\n    ref: ref,\n    activeKey: activeKey,\n    className: classNames(className, {\n      [bsPrefix]: !isNavbar,\n      [`${navbarBsPrefix}-nav`]: isNavbar,\n      [`${navbarBsPrefix}-nav-scroll`]: isNavbar && navbarScroll,\n      [`${cardHeaderBsPrefix}-${variant}`]: !!cardHeaderBsPrefix,\n      [`${bsPrefix}-${variant}`]: !!variant,\n      [`${bsPrefix}-fill`]: fill,\n      [`${bsPrefix}-justified`]: justify\n    }),\n    ...props\n  });\n});\nNav.displayName = 'Nav';\nexport default Object.assign(Nav, {\n  Item: NavItem,\n  Link: NavLink\n});","\"use client\";\n\nimport * as React from 'react';\nimport classNames from 'classnames';\nimport { useBootstrapPrefix } from './ThemeProvider';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst CardBody = /*#__PURE__*/React.forwardRef(({\n  className,\n  bsPrefix,\n  as: Component = 'div',\n  ...props\n}, ref) => {\n  bsPrefix = useBootstrapPrefix(bsPrefix, 'card-body');\n  return /*#__PURE__*/_jsx(Component, {\n    ref: ref,\n    className: classNames(className, bsPrefix),\n    ...props\n  });\n});\nCardBody.displayName = 'CardBody';\nexport default CardBody;","\"use client\";\n\nimport * as React from 'react';\nimport classNames from 'classnames';\nimport { useBootstrapPrefix } from './ThemeProvider';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst CardFooter = /*#__PURE__*/React.forwardRef(({\n  className,\n  bsPrefix,\n  as: Component = 'div',\n  ...props\n}, ref) => {\n  bsPrefix = useBootstrapPrefix(bsPrefix, 'card-footer');\n  return /*#__PURE__*/_jsx(Component, {\n    ref: ref,\n    className: classNames(className, bsPrefix),\n    ...props\n  });\n});\nCardFooter.displayName = 'CardFooter';\nexport default CardFooter;","\"use client\";\n\nimport classNames from 'classnames';\nimport * as React from 'react';\nimport { useMemo } from 'react';\nimport { useBootstrapPrefix } from './ThemeProvider';\nimport CardHeaderContext from './CardHeaderContext';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst CardHeader = /*#__PURE__*/React.forwardRef(({\n  bsPrefix,\n  className,\n  // Need to define the default \"as\" during prop destructuring to be compatible with styled-components github.com/react-bootstrap/react-bootstrap/issues/3595\n  as: Component = 'div',\n  ...props\n}, ref) => {\n  const prefix = useBootstrapPrefix(bsPrefix, 'card-header');\n  const contextValue = useMemo(() => ({\n    cardHeaderBsPrefix: prefix\n  }), [prefix]);\n  return /*#__PURE__*/_jsx(CardHeaderContext.Provider, {\n    value: contextValue,\n    children: /*#__PURE__*/_jsx(Component, {\n      ref: ref,\n      ...props,\n      className: classNames(className, prefix)\n    })\n  });\n});\nCardHeader.displayName = 'CardHeader';\nexport default CardHeader;","\"use client\";\n\nimport classNames from 'classnames';\nimport * as React from 'react';\nimport { useBootstrapPrefix } from './ThemeProvider';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst CardImg = /*#__PURE__*/React.forwardRef(\n// Need to define the default \"as\" during prop destructuring to be compatible with styled-components github.com/react-bootstrap/react-bootstrap/issues/3595\n({\n  bsPrefix,\n  className,\n  variant,\n  as: Component = 'img',\n  ...props\n}, ref) => {\n  const prefix = useBootstrapPrefix(bsPrefix, 'card-img');\n  return /*#__PURE__*/_jsx(Component, {\n    ref: ref,\n    className: classNames(variant ? `${prefix}-${variant}` : prefix, className),\n    ...props\n  });\n});\nCardImg.displayName = 'CardImg';\nexport default CardImg;","\"use client\";\n\nimport * as React from 'react';\nimport classNames from 'classnames';\nimport { useBootstrapPrefix } from './ThemeProvider';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst CardImgOverlay = /*#__PURE__*/React.forwardRef(({\n  className,\n  bsPrefix,\n  as: Component = 'div',\n  ...props\n}, ref) => {\n  bsPrefix = useBootstrapPrefix(bsPrefix, 'card-img-overlay');\n  return /*#__PURE__*/_jsx(Component, {\n    ref: ref,\n    className: classNames(className, bsPrefix),\n    ...props\n  });\n});\nCardImgOverlay.displayName = 'CardImgOverlay';\nexport default CardImgOverlay;","\"use client\";\n\nimport * as React from 'react';\nimport classNames from 'classnames';\nimport { useBootstrapPrefix } from './ThemeProvider';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst CardLink = /*#__PURE__*/React.forwardRef(({\n  className,\n  bsPrefix,\n  as: Component = 'a',\n  ...props\n}, ref) => {\n  bsPrefix = useBootstrapPrefix(bsPrefix, 'card-link');\n  return /*#__PURE__*/_jsx(Component, {\n    ref: ref,\n    className: classNames(className, bsPrefix),\n    ...props\n  });\n});\nCardLink.displayName = 'CardLink';\nexport default CardLink;","\"use client\";\n\nimport * as React from 'react';\nimport classNames from 'classnames';\nimport { useBootstrapPrefix } from './ThemeProvider';\nimport divWithClassName from './divWithClassName';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst DivStyledAsH6 = divWithClassName('h6');\nconst CardSubtitle = /*#__PURE__*/React.forwardRef(({\n  className,\n  bsPrefix,\n  as: Component = DivStyledAsH6,\n  ...props\n}, ref) => {\n  bsPrefix = useBootstrapPrefix(bsPrefix, 'card-subtitle');\n  return /*#__PURE__*/_jsx(Component, {\n    ref: ref,\n    className: classNames(className, bsPrefix),\n    ...props\n  });\n});\nCardSubtitle.displayName = 'CardSubtitle';\nexport default CardSubtitle;","\"use client\";\n\nimport * as React from 'react';\nimport classNames from 'classnames';\nimport { useBootstrapPrefix } from './ThemeProvider';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst CardText = /*#__PURE__*/React.forwardRef(({\n  className,\n  bsPrefix,\n  as: Component = 'p',\n  ...props\n}, ref) => {\n  bsPrefix = useBootstrapPrefix(bsPrefix, 'card-text');\n  return /*#__PURE__*/_jsx(Component, {\n    ref: ref,\n    className: classNames(className, bsPrefix),\n    ...props\n  });\n});\nCardText.displayName = 'CardText';\nexport default CardText;","\"use client\";\n\nimport * as React from 'react';\nimport classNames from 'classnames';\nimport { useBootstrapPrefix } from './ThemeProvider';\nimport divWithClassName from './divWithClassName';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst DivStyledAsH5 = divWithClassName('h5');\nconst CardTitle = /*#__PURE__*/React.forwardRef(({\n  className,\n  bsPrefix,\n  as: Component = DivStyledAsH5,\n  ...props\n}, ref) => {\n  bsPrefix = useBootstrapPrefix(bsPrefix, 'card-title');\n  return /*#__PURE__*/_jsx(Component, {\n    ref: ref,\n    className: classNames(className, bsPrefix),\n    ...props\n  });\n});\nCardTitle.displayName = 'CardTitle';\nexport default CardTitle;","\"use client\";\n\nimport classNames from 'classnames';\nimport * as React from 'react';\nimport { useBootstrapPrefix } from './ThemeProvider';\nimport CardBody from './CardBody';\nimport CardFooter from './CardFooter';\nimport CardHeader from './CardHeader';\nimport CardImg from './CardImg';\nimport CardImgOverlay from './CardImgOverlay';\nimport CardLink from './CardLink';\nimport CardSubtitle from './CardSubtitle';\nimport CardText from './CardText';\nimport CardTitle from './CardTitle';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst Card = /*#__PURE__*/React.forwardRef(({\n  bsPrefix,\n  className,\n  bg,\n  text,\n  border,\n  body = false,\n  children,\n  // Need to define the default \"as\" during prop destructuring to be compatible with styled-components github.com/react-bootstrap/react-bootstrap/issues/3595\n  as: Component = 'div',\n  ...props\n}, ref) => {\n  const prefix = useBootstrapPrefix(bsPrefix, 'card');\n  return /*#__PURE__*/_jsx(Component, {\n    ref: ref,\n    ...props,\n    className: classNames(className, prefix, bg && `bg-${bg}`, text && `text-${text}`, border && `border-${border}`),\n    children: body ? /*#__PURE__*/_jsx(CardBody, {\n      children: children\n    }) : children\n  });\n});\nCard.displayName = 'Card';\nexport default Object.assign(Card, {\n  Img: CardImg,\n  Title: CardTitle,\n  Subtitle: CardSubtitle,\n  Body: CardBody,\n  Link: CardLink,\n  Text: CardText,\n  Header: CardHeader,\n  Footer: CardFooter,\n  ImgOverlay: CardImgOverlay\n});","import React from 'react';\nimport { Container, Card } from 'react-bootstrap';\n\nexport default function About() {\n  return (\n    <Container>\n      <Card>\n        <Card.Body>\n          <Card.Title>About Page</Card.Title>\n          <Card.Text>\n            This is the about page of our application.\n          </Card.Text>\n        </Card.Body>\n      </Card>\n    </Container>\n  );\n}","export const allPosts = {\n  \"on-quadratic-complexity\": {\n    \"title\": \"On quadratic complexity\",\n    \"createdOn\": \"2022-05-29 16:33:06.774955\",\n    \"mdText\": \"## On quadratic complexity\\n\\nMany algorithms have quadratic complexity: sometimes this is necessary, but [often it's not](https://accidentallyquadratic.tumblr.com/). This and related facts are widely known but underappreciated. Quadratic complexity is a more pervasive phenomenon, and explains more other phenomena, than is generally recognized.\\n\\n#### Quadratic complexity is everywhere\\n\\nIt often happens that you need to track some pairwise relationship for all pairs of objects in some set. These situations are more easily perceived when the objects are elements of an array. Sometimes, though, the objects are the components of a software system: here, \\\"gluing\\\" those components together generates tasks that are [quadratic in the number of components you have](https://www.oreilly.com/radar/thinking-about-glue/).\\n\\nWithin a component, one often sees quadratic complexity at higher levels than arrays. This is one reason it's so important to model your domain correctly: if, for example, you make something a property of *A* when it should be a property of *B*, the penalty is often that operations that formerly required checking all the *A*s _or_ all the *B*s now require checking all the *A*s _and_ all the *B*s. You're paying a quadratic cost across a larger domain. (Also, your code tends to be harder to reason about, because it's harder for your brain to invoke some hodgepodge of intuitions about *A* and *B* than either one individually--but that's a separate issue.)\\n\\n#### Quadratic complexity can explain other things\\n\\nWe do (and ought to!) think about how fast exponential growth happens, but we sometimes forget that quadratic growth is pretty fast too. Think about an old riddle: suppose the scum on the surface of a pond doubles every day (growing exponentially), and at the end of April it covers the whole pond. When did it cover only 1/4 of the pond? April 28, two days before the end of the month.\\n\\nSuppose the scum is growing quadratically: then, on the 28th, it's about 87% full. That's way more than a quarter, but less than intuition might first suggest.\\n\\nIf you're programming, and need to keep track of all the pairwise relationships in a set of items, it matters a lot whether that set has four or five things in it: that's the difference between 6 and 10 pairwise relationships. Whatever you think of the research about [short-term memory](https://en.wikipedia.org/wiki/The_Magical_Number_Seven,_Plus_or_Minus_Two), 10 is a lot bigger than 6 as far as your \\\"active brain\\\" is concerned.\\n\\nThis can explain why getting stuck in programming can feel (i) so sudden and (ii) so intractable. At least sometimes, \\\"why is this so hard to reason about now when it wasn't a minute ago\\\" is answerable with: \\\"because those two extra things you added generated another couple dozen relations (or cases to check or failure modes).\\\"\\n\\nIf you've ever wondered why [Norris's number](https://www.johndcook.com/blog/2011/11/22/norris-number/) exists: look here, perhaps.\\n\"\n  },\n  \"whats-happening-with-data-scientists\": {\n    \"title\": \"What's happening with data scientists?\",\n    \"createdOn\": \"2022-10-14 13:15:03.163794\",\n    \"mdText\": \"## What's happening with data scientists?\\n\\nThe [most recent issue](https://www.thediff.co/p/snail-games-and-one-hit-wonders) [$] of The Diff discusses [this interviewing.io analysis](https://blog.interviewing.io/how-much-have-2022-layoffs-affected-engineers-vs-other-departments-we-dug-into-the-data-to-find-out/) of recent layoffs.\\n\\nOne finding Byrne discusses is that data scientists are being laid off at surprisingly high rates (much higher than software engineers). Byrne suggests it is because staffing data science tends to be associated with expansion. Here are some other hypotheses:\\n\\n1. At many companies, data science is used for exploratory or speculative ends. Stopping such projects can be less painful than stopping other projects--even if it's a mistake to do so. (And in some cases, stopping those projects puts more decisionmaking power with the people doing the layoffs.)\\n1. Anecdotal: some people who would have called themselves \\\"data scientists\\\" five years ago are now (maybe) calling themselves \\\"ML engineers\\\" or similar. It would be interesting to investigate whether and how the status and seniority of the \\\"data scientist\\\" title is changing. In the Stable Diffusion Era, I'd guess that people who work directly with ML models are even more eager to have \\\"ML\\\" or \\\"AI\\\" in their job titles.\\n1. Relatedly, some tasks in the traditional domain of data science are now being done in ways that look a lot more like software engineering (or the automatic behavior of software). This probably goes both ways, with data science capturing some other territory, but I'd guess that there's a net loss here. (This intersects with the point above about prestige.)\\n1. Computing power is more usable than ever (with better cloud services, M1 Macs, etc.). In my experience, this accelerates data science more than it does other kinds of software work. A lot of data scientists spend significant time waiting for calculations to finish.\\n\\nThose are all hypotheses I'd want to investigate; they are certainly not firm beliefs.\\n\"\n  },\n  \"on-conversations-with-tyler\": {\n    \"title\": \"On Conversations with Tyler\",\n    \"createdOn\": \"2022-05-29 16:33:06.778838\",\n    \"mdText\": \"## On Conversations with Tyler\\n\\nHere's my stab at the guide Tyler and his producer mentioned near the end of the [2021 retrospective show](https://conversationswithtyler.com/episodes/conversations-with-tyler-2021-retrospective/). The goal is to give the uninitiated listener essential context. (They mentioned a 10-point guide, but I only need 8.)\\n\\n1. These are not debates. Tyler will make his point and move on. He will let the interviewee do the same. Nor are they wrestling matches: one neither needs to pin down the opponent for some length of time nor see a scoreboard get incremented. (So, just because Tyler *doesn't* mark the occasion specifically, don't think he doesn't take himself to have just decisively refuted an entire Nobel Prize-winning body of research.)\\n1. Why talk as in (1)? One reason is efficiency. Never forget that this is part of [Tyler's moonshot project](https://www.mercatus.org/bridge/commentary/my-personal-moonshot), one core of which is for him to process as much information as he can. Always think of Tyler trying to maximize his own intellectual progress per minute.\\n1. Again, why talk as in (1)? Think of Tyler as committed to the view that *things have explanations* (perhaps several) and as a realist about explanations. In particular, sometimes explanations are, in fact, simple--which is not to say \\\"easy.\\\" Here I think of the way (the philosopher) David Lewis often seemed to believe things based on very short lines of argument (e.g., [here](https://www.csus.edu/indiv/m/merlinos/paradoxes%20of%20time%20travel.pdf)), or the way Reid Hoffman [values simplicity in decisionmaking](https://hbr.org/2015/03/reid-hoffmans-two-rules-for-strategy-decisions). (This is one way Tyler is working in philosophical traditions; see below.)\\n1. If you are a realist and a pluralist about explanation, you ought to care how these explanations coexist. And Tyler does. So, e.g., he [presses Robin Hanson](https://conversationswithtyler.com/episodes/robin-hanson/) on levels of explanation. And for guests with thrilling empirical results (e.g., [Raj Chetty](https://conversationswithtyler.com/episodes/raj-chetty/)), he tends to ask \\\"but what's the causal mechanism here?\\\" Such questions are deeply unfashionable in some circles these days, and it's striking how much his guests vary in the quality of their answers here.\\n1. I view Tyler as working in a Socratic/Platonic tradition. (Explanations exist; they're domain-relative; their domain-relativity does not undermine their reality; the real natures of things are very hard to understand, usually too hard for a single human mind; etc.) More generally, whether or not he resembles an academic philosopher, and whether or not *you* want to think of his work as philosophy, think of *him* [thinking of his work as philosophy](https://www.amazon.com/dp/B07G9DFC8W/ref=dp-kindle-redirect?_encoding=UTF8&btkr=1).\\n1. If you *still* don't understand why Tyler is asking something, think about comparative advantage. He views his guests as having uniquely benefited from some lifelong course of study (see (2) above) and attempts to extract as much insight as possible from the intellectual tools they've uniquely developed.\\n1. And if you still don't understand, think about cultural background. Tyler thinks that things tend to have earlier roots than is generally recognized: that includes individual people's intellectual output. He's not asking about someone's childhood to be polite or to humanize the guest: he probably suspects that their work on cancer research (or whatever) truly grows out of their being a cultural product of Topeka (or wherever).\\n1. Some, but only some, teachers-on-the-Internet (1) remember that you have pause and rewind buttons and (2) take you to know how to use them. Tyler is one of them.\\n\"\n  },\n  \"on-ranking-things\": {\n    \"title\": \"On ranking things\",\n    \"createdOn\": \"2022-05-29 16:33:06.780912\",\n    \"mdText\": \"## On ranking things\\n\\nWhy rank things? Some well-known answers are:\\n\\n1. It's a way of celebrating what you like.\\n1. It's a way to seek out excellence more generally.\\n1. It's fun.\\n1. It sparks conversation.\\n\\nTwo more answers I didn't appreciate until recently are:\\n\\n1. In the translation from deep feeling to language, much can be lost but something can also be *gained*. (Agnes Callard [on complaint](https://philosophybites.libsyn.com/agnes-callard-on-complaint) and [on prayer](https://thepointmag.com/examined-life/thoughts-and-prayers-agnes-callard/) got me thinking about this.) Rankings are an extreme version of this. They're reductive, and that can be a *good* thing.\\n1. It keeps one honest to say what you *really* like the most. Especially if you're the sort of person who goes on and on about how much there is to appreciate about so many different things.\\n\\nSo, here is a sort of [top-100 books list](100-books.html) and here's [my favorite stuff of 2022](2022-favorites.html).\\n\"\n  },\n  \"on-studying-for-your-upcoming-job-objections-and-replies\": {\n    \"title\": \"On studying for your upcoming job: objections and replies\",\n    \"createdOn\": \"2022-06-24 06:07:55.825809\",\n    \"mdText\": \"## On studying for your upcoming job: objections and replies\\n\\nHere I collect objections that arose [on Hacker News](https://news.ycombinator.com/item?id=31856512) in response to [this short argument](https://news.ycombinator.com/item?id=31856512). Thanks to everyone who replied.\\n\\n_Q1_. \\\"But of *course* studying a language is good!\\\"\\n\\n_A1_. Yes, it is. \\nMastering a language is wonderful, and being totally ignorant of the language you'll be using is bad. \\nThe question I was answering, however, is whether a given hour is more efficiently spent learning a language or a tool, supposing you want to use that hour to prepare for an upcoming job. \\nFor the reasons I lay out, and especially because it's very hard to predict which parts of a language will be used and how, studying tools is likely a better bet.\\n\\n_Q2_. \\\"Everyone should know [language *X*].\\\"\\n\\n_A2_. See _A1_. \\nAlso, here as elsewhere, you can't infer from \\\"any programmer would benefit from knowing *X*\\\" to \\\"every programmer should learn *X*.\\\" \\nThe latter requires an argument that *X* is not just good but better than anything else a programmer should be doing with that time. \\n\\n_Q3_. \\\"If you ask the hiring manager how to study the language, you'll be studying just what you need.\\\"\\n\\n_A3_. Yes, this is better than just guessing.\\nBut the hiring manager (i) might not know exactly how the language is used and (ii) often has strong incentives to oversell the quality of the existing code base.\\nThe last time I tried this, *Effective Java* was recommended to me.\\nThe Java I encountered was... not \\\"Effective.\\\"\\n\\n_Q4_. \\\"This is just your experience.\\\"\\n\\n_A4_. I should have been clearer about this. \\nAlthough I've made this mistake many times, I'm not just writing about myself but about many other people I've seen do this. \\nThe impetus for writing this up was a person asking me what they should do to learn language *X*, having accepted a job offer to work in that language. \\nSo, this doesn't come out of rigorous research. \\nBut it's definitely not just me.\\n\\n_Q5_. \\\"But in Python, there *is* only one good way to do things.\\\"\\n\\n_A5_. That's less true than people say, and less true than it used to be. \\n(Just one example: whatever else you think of [structural pattern matching](https://peps.python.org/pep-0622/), it creates more ambiguity about which is the best tool when.)\\nMore importantly, most code is not written \\\"the good way.\\\"\\nYes, be ambitious and aim to improve things.\\nBut you will be working on the code base you have, which is probably not the code base in which everything is done properly.\\n\\n_Q6_. \\\"This doesn't apply to the very basics of a language.\\\"\\n\\n_A6_. That's probably true, and I should have been clearer. \\nHaving some basic fluency in the languange will help.\\n(This is a great use of spaced repetition, by the way.)\\nBut beyond \\\"some basic fluency,\\\" the argument still applies.\\n\\n_Q7_. \\\"My team *does* use language *X* beautifully and idiomatically.\\\"\\n\\n_A7_. Great! \\nGood for you (sincerely). \\n\\n_Q8_. \\\"But the use of a tool is as idiosyncratic and unpredictable as the use of a language.\\\"\\n\\n_A8_. The premise is false. \\nThere are different ways to use various tools. \\nBut it's pretty hard to study Bazel or Splunk or Jenkins or whatever without learning things that will help you basically anywhere those tools are used. \\nDatabases are, arguably, an exception here. Those get used all sorts of ways.\\n\"\n  },\n  \"reading-notes-the-remains-of-the-day\": {\n    \"title\": \"Reading notes: The Remains of the Day\",\n    \"createdOn\": \"2022-10-20 05:49:38.246279\",\n    \"mdText\": \"## Reading notes: The Remains of the Day\\n\\n*Very mild and general spoilers ahead. I have read no other reviews or commentary about the book, so you might find these notes either obvious or badly misguided.*\\n\\n1. The use of the second person is masterful. When commentators discuss second-person fiction, they tend to say that it's rare, give Jay McInerney a B or B+ for _Bright Lights, Big City_, and move on. Although much of this book is in the first person, the second-personal elements are significant and closely connected to the central aesthetic and moral moments of the novel.\\n1. The narrator who is gradually revealed as unreliable is a more familiar device. It is executed brilliantly and, again, intensifies the book's moral climaxes. We begin with the overwhelming sense of order and decency; this is gradually undermined; and eventually the reader must import skepticism into scenes with no overt signs of misbehavior or absurdity. This effect is powerful once it occurs.\\n1. Another way to read this book is as a challenge to the reader: how good are *your* values, and how much integrity do *you* have? (See the previous point.) The reader can often be thought to stand to the narrator as the narrator, a butler, stands to the head of the house he serves. This is a familiar device, but used to much more powerful effect than usual.\\n1. Some important influences here seem to include the tradition of the detective novel (is it true that \\\"the butler did it\\\"?) and some American traditions. It brings to mind various other meditative novels about car trips (I have a hard time not comparing it to _Zen and the Art of Motorcycle Maintenance_), and the end seems to owe much to _The Great Gatsby_.\\n\\nVery highly recommended. An easy inclusion in the [top 100](100-books.html).\\n\"\n  },\n  \"a-note-on-10x-engineering\": {\n    \"title\": \"A note on 10x engineering\",\n    \"createdOn\": \"2023-04-05 14:53:24.368092\",\n    \"mdText\": \"## A note on 10x engineering\\n\\nTaylor [argues that](https://taylor.town/-10x), whereas \\\"10x engineers may be mythical, -10x engineers exist.\\\" The form of argument is: it's pretty easy to waste ten engineers' worth of time and effort. He gives a long list of ways to do this.\\n\\nIt's a good argument, and it shows more than Taylor makes explicit. If he's right that there are so many dimensions of impact along which engineers can be much better and worse than each other, then I think you have to believe one of two things:\\n\\n1. Most or all of these dimensions have unbounded downside but fairly low ceilings, or\\n1. The best engineers really *are* vastly better than average ones, because they can be better along many high-impact axes--or at least a few.\\n\\nMoreover, Taylor barely discusses system design and architecture, and then only to discuss the costs of truly bad and sloppy planning. I'd also emphasize that the difference between mediocre and good system design is very large.\\n\\nSo: I don't know how sincere Taylor was when he said that 10x engineers are mythical, but it's very hard both to accept his argument for the existence of -10x engineers and to deny that 10x engineers exist.\\n\"\n  },\n  \"listening-notes-get-ready\": {\n    \"title\": \"Listening notes: _Get Ready_\",\n    \"createdOn\": \"2023-03-22 12:41:27.488863\",\n    \"mdText\": \"## Listening notes: _Get Ready_\\n\\n1. The book is about preparation, in the most practical and pragmatic sense. If you have *X* hours to spend, and your goal is to do the best possible job at *Y*, how should you spend your *X* hours? The answer is probably not do do the most traditional, conventional sorts of practice. Buzzy has better answers.\\n1. This book should be as famous as _The Art of Learning_ in the relevant crowd. I would actually recommend _Get Ready_ over _The Art of Learning_ for most people.\\n1. I was hearted to see echoes of [my notes about preparing for coding interviews](https://www.natemeyvis.com/on-preparing-for-coding-interviews.html).\\n1. Buzzy did a great job reading the audiobook. Unlike most, it's a pleasure to listen to.\\n1. The material is very general and not just for prospective Jeopardy! contestants. (This is very clear from the book itself, but not as clear from its marketing.)\\n1. Picasso (supposedly) said that whereas when art critics get together they talk high-mindedly about art concepts, when *artists* get together they talk about where you can get cheap turpentine. This is the \\\"cheap turpentine talk\\\" of life.\\n\\nI value nuts-and-bolts / practical-advice-type books more than most people do ([proof](100-books.html)), and this is the very best one I know of in its domain.\\n\"\n  },\n  \"on-recovering\": {\n    \"title\": \"On recovering\",\n    \"createdOn\": \"2022-05-29 16:33:06.785009\",\n    \"mdText\": \"## On recovering\\n\\nThe two claims I remember most from *The Art of Learning* are:\\n\\n1. You can make a lot of progress by practicing properly, near the edge of your ability and with tight feedback loops;\\n1. It's very important to recover efficiently.\\n\\nA lot of people seem to have absorbed (1), whether or not they actually enact it. I rarely see people discuss (2), and I think that's a shame, for a few reasons:\\n\\n1. If you're not recovering very well, getting a bit better at it probably isn't very hard;\\n1. Working on recovery tends not to be as painful as working on the exertion side of things;\\n1. It's always a shame when bad infrastructure gets in the way of hard work.\\n\\nI haven't undertaken any projects that involve measuring my recovery, but anecdotally, it seems to be very important. For example, planking gets a lot harder if I so much as hold my phone between sets. (It's said that Justin Verlander doesn't raise his arm above his shoulder on his rest days; I don't know whether that's true, but I hope it is.)\\n\\nIn my most recent (abandoned) attempt at a podcast, I asked various high performers how they recover; I didn't get many good answers. The best and most entertaining was from Byrne Hobart, who says that he recovers from reading by reading different things. Mostly [I just admire the work ethic](on-reading-the-diff.html), but I also think there's something to the idea of what Ryan Holliday calls \\\"crop rotation:\\\" sometimes different kinds of work can complement each other so that you can make progress on another while recovering from one.\\n\\nBy the way, [this tweet of Byrne's](https://twitter.com/ByrneHobart/status/1510340634246365192) prompted me to write this up; please do reply to that tweet or to me (contact information is on [my home page](index.html)) with any useful reading material.\\n\\nNon-athletes should mimic athletes' regimens more than we do.\\n\"\n  },\n  \"why-dont-people-talk-about-the-shapley-value-more\": {\n    \"title\": \"Why don't people talk about the Shapley value more?\",\n    \"createdOn\": \"2022-07-14 19:41:39.595715\",\n    \"mdText\": \"## Why don't people talk about the Shapley value more?\\n\\nHere's an argument that the Shapley value is underrated:\\n\\n1. It's really important to figure out how to divide credit for the performance of a whole to the parts of that whole.\\n1. The Shapley value is, under pretty mild constraints, the uniquely best way to do that.\\n1. Those \\\"mild constraints\\\" [really are pretty mild](https://en.wikipedia.org/wiki/Shapley_value#Properties]).\\n1. Yet people barely talk about it.\\n\\nI think that last assertion is pretty obvious, but in case you want evidence, [here](https://marginalrevolution.com/?s=Shapley) is a Marginal Revolution search for \\\"Shapley.\\\" Its few results are mostly coverage of a Nobel Prize and Shapley's death. There is no direct application of the Shapley value (the closest thing is some mentions of the [Gale-Shapley algorithm](https://en.wikipedia.org/wiki/Gale\\u2013Shapley_algorithm), again mostly in the form of Nobel coverage).\\n\\nYou might think that Shapley valuation is too much of an idealization to be useful. \\nBut I don't see how the Shapley value is worse in this regard than any number of other widely used and discussed tools from economics. \\nIn many respects it's *better*! \\n(Again, because of the strength of the underlying uniqueness theorem.)\\n\\n[Here](https://kpknudson.com/my-favorite-theorem/2018/12/12/episode-32-anil-venkatesh) is an episode of My Favorite Theorem (a good podcast!) where Anil Venkatesh discusses the Shapley value and its many applications, including to the valuation of power-ups in video games.\\n\\nThere seems to be some use of the Shapley value in evaluating machine learning models ([here](https://christophm.github.io/interpretable-ml-book/shapley.html) is a blog post I find useful; a YouTube search will also turn up results).\\n\\nWhy isn't there a lot more of this? Why can't you, e.g., evaluate results in baseball games by considering observed results (of pitches, games, or whatever) as results of coalitions, and trying to determine Shapley values correspondingly?\\n\\nMy view of baseball researchers is that they'll try to apply any quantitative technique to baseball. My view of Tyler Cowen is that he'll apply any useful model, certainly over many years of blogging and speaking. What is going on here? Am I missing some fatal flaw in the Shapley value?\\n\"\n  },\n  \"on-the-scarcity-of-context\": {\n    \"title\": \"On the scarcity of context\",\n    \"createdOn\": \"2022-05-29 16:33:06.787399\",\n    \"mdText\": \"## On the scarcity of context\\n[Here is](https://marginalrevolution.com/marginalrevolution/2022/02/context-is-that-which-is-scarce-2.html) Tyler Cowen's latest and fullest explanation of \\\"Context is that which is scarce.\\\"\\n\\nA way to think about (1) and (2) in Tyler's post is: it's harder to *think in terms of* an idea than to correctly recite its definition. So, for example, students beginning collegiate math hear that the high school ways of doing things are immature and they need to master definitions and proofs. Then they advance, and discover (often brutally) that:\\n\\n1. You can memorize a definition without understanding it or being able to make any real progress on the problem set;\\n1. There's often no principled way to decide which properties of a mathematical object (the determinant, the Shapley value, whatever) *define* it, and which are consequences;\\n1. Their teachers spend less and less time discussing the details of proofs and definitions. That time is spent *demonstrating* the concepts.\\n\\nNow think about culture. You might learn a slogan, technique, essay, or whatever. Then you see some new cultural artifact related to it and discover (often brutally) that:\\n\\n1. You can recite or mimic bits of these without generating any of the production or appreciation of the initiated (think of a poetry student learning metric feet);\\n1. There are *dependencies*--historical, psychological, and conceptual--among the various aspects of a cultural phenomenon, but there's usually no principled way to arrange these into some single order. (I recently tried to teach [transformative experience](https://www.amazon.com/Transformative-Experience-L-Paul/dp/0198777310) to undergrads. There's Prof. Paul's definition, but also the traditions of Lockean personal identity; decision theory; contemporary feminism, theory of race, trans issues, etc.; logical puzzles a la Frege and Hofstadter; the metaphysics of desire and belief (I can't imagine teaching this without saying something about Socrates and Aristotle); and on and on. It's not just that all this other stuff is somehow *relevant* to the transformative experience debate. It's that you really *don't know what people are talking about* until you've grasped some critical mass of it, and the material doesn't arrange itself into any unique linear order.)\\n1. As you advance in learning about that culture, your teachers (in the broad sense) will spend less time introducing definitions and more time ostending, demonstrating, or making connections.\\n\\nWhen Tyler started repeating this maxim, I found myself wondering, in frustration, whether he meant it as a definition (\\\"what we call context *just is* the scarce aspect of a situation\\\") or an empirical claim (\\\"context tends to be the scarce or limiting input to various outputs\\\"). I now view this frustration as ironic.\\n\"\n  },\n  \"rubber-duck-text-editing\": {\n    \"title\": \"Rubber duck text editing\",\n    \"createdOn\": \"2022-06-13 20:17:10.003329\",\n    \"mdText\": \"## Rubber duck text editing\\n\\nI'm still using and loving Vim, and still believe that most advice about learning it [doesn't work very well](on-learning-vim.html).\\n\\nA few new points of disagreement:\\n\\nToo much emphasis is placed on speed. Vim is fast, and that's great, but users will feel enough pressure to go fast on their own. It's probably counterproductive to say or imply that hesitation is the sign of a weak user.\\n\\nThis is particularly true because it will push new users away from learning and toward trying to type the things they know faster. It's hard enough to communicate just how big and feature-rich it is.\\n\\nRelatedly, but conversely, `vimtutor` (which I respect and like) and other beginners' tools should do more to make beginners at least aware of tools like the jump list, the change list, marks, and the quickfix list. They probably won't use all these tools very soon. (Probably most *seasoned* Vim users don't use all of them.) But they are great tools for giving people a sense of what Vim is all about and what it can do. So, instead of introducing a complicated and metaphysically dubious notion of a \\\"grammar of Vim\\\" or similar, which can leave learners feeling like they are missing the point if they don't intuitively grasp (e.g.) which commands take a count and which don't, we could just say things like: \\\"There's this thing called the jump list; it lets you go back to the last location you jumped from, and the one before that, and so on, back and forth, as you wish.\\\"\\n\\nI suspect that the deeper mistake here is assuming that users need to be fluent in the exact definition of *X* before showing them a feature involving *X* (so, that they need to know the definition of a jump, a change, or a motion before they can be shown tools that use these concepts). It's an intuitive thought, but I think it's wrong in this case. Probably nobody knows, for every service they use that supports undo functionality, the exact rules governing how actions are chunked into units for the purposes of that functionality. They still ought to know that undo exists.\\n\\nThe best mental adjustment I've made recently as a Vim user is, when I hesitate or get a little confused, to ask myself: \\\"What do I want to do?\\\" Whether or not I'm interested in Googling to learn a new Vim thing right then, just saying it to myself tends to lead me to a good answer. (Often it's something like: \\\"Go back to that file I just had opened\\\" or \\\"put an asterisk in front of each of the next 8 lines.\\\") It's like [rubber duck debugging](https://en.wikipedia.org/wiki/Rubber_duck_debugging) but for editing text instead of coding.\\n\"\n  },\n  \"how-i-got-into-programming\": {\n    \"title\": \"How I got into programming\",\n    \"createdOn\": \"2022-05-29 16:33:06.790141\",\n    \"mdText\": \"## How I got into programming\\n\\n### My story\\n\\nIn the early 2010s I was a gradate student in philosophy. I read about [Project Euler](https://projecteuler.net/) somewhere and realized that programming was (i) interesting enough to try and (ii) would cost $0 given that I already owned a computer. Project Euler was itself fun, and (more enduringly) I fell in love with Python.\\n\\nA college friend was working for a bioinformatics startup needing a documentation writer. Needing to choose between (i) leaving Boston for a TAship in Ithaca, NY or (ii) making money some other way, I chose (ii) and got the documentation job. Everyone involved was eager for me to spend some of my time learning the details of algorithms relevant to bioinformatics, so it was a good environment to learn to code.\\n\\n(There's a familiar story among programmers: \\\"In my course work I was led to believe that programming was all about learning algorithms and data structures. When I started my career I immediately found myself using only basic algorithms; the hard part was learning tools and systems.\\\" I had something like that experience, but delayed: my first job thoroughly *reinforced* the impression that fancy algorithms were absolutely central to industrial work in programming.)\\n\\nStartups tend to be flexible places, and I took on a lot of jobs within that company, including first-order work as a programmer. Eventually I went out on my own as a consultant, then took a job at Google, then did various other things. But that's of much less interest to most people who ask me about this. The most relevant aspects of this story are:\\n\\n1. I learned from MOOCs, books, and experimentation.\\n1. I started on a lark.\\n1. It was a bit less than a year between starting my independent part-time studies and having some sort of job in software.\\n1. It was about six months after that that I was in some sense working as a programmer.\\n1. I got my first job by (i) being willing to work at a startup and (ii) having a very good personal connection at one.\\n1. And my first job was \\\"programming-adjacent.\\\"\\n\\n### Postscript\\n\\nThat is, I said, *my story*. It's true and it's what I said in all sincerity, for years, to people who asked. It's incomplete, though. I was in high school from 1997 to 2001. Some friends of mine were into computers; there were a couple computer classes available; and I carried around a programmable TI-83 calculator all day.\\n\\nI can't say how much programming I did then, but it must have been a lot: I remember spending hours programming, e.g., a simple version of craps. And I wrote a units-conversion program. The latter was my first experience releasing and versioning software: I chased down the one person who self-identified as a user of it and asked to borrow his calculator so that I could attach it to mine with a cable and give him a version of the program with a bugfix.\\n\\nIt is easy to recall many memories of myself being totally engrossed in programming. I omitted from the narrative above because I omitted it from my narrative *then*: I was a math guy, trivia geek, runner, and so on. (Or so I thought.) I never so much as considered a CS class as an undergrad and never talked about myself as a programming enthusiast.\\n\\nSo, I spent a bit over a decade paying no attention to programming. And the most relevant facts *here* are that:\\n\\n1. If you asked me about my programming background, and I told you it all started in my grad school years, I wasn't quite getting it right;\\n1. But I wasn't *lying*; I had really just not allowed that part of my youth to enter my self-concept.\\n1. The more accurate version of that first point above is: I learned from MOOCS, books, and experimentation, where \\\"experimentation\\\" includes a lot of fumbling around with TI-83 programming and BASIC in the Clinton administration.\\n1. The human capacity for self-deception is enormous.\\n\"\n  },\n  \"on-ankis-database\": {\n    \"title\": \"On Anki's database\",\n    \"createdOn\": \"2022-05-29 16:33:06.791960\",\n    \"mdText\": \"## On Anki's database\\n\\nI am a daily spaced repetition user (I describe how and why [here](on-using-anki.html) and [here](on-using-anki-again.html)). I've been working with my Anki data lately, which has meant exposing and manipulating the [Sqlite](https://www.sqlite.org/index.html) database underlying the program. (I'm grateful to the [Ankidroid project](https://github.com/ankidroid/Anki-Android/wiki/Database-Structure) and [r/anki](https://www.reddit.com/r/Anki/) for having documented so much about the .apkg format and the database itself.)\\n\\nThe database structure is fairly typical of data management in long-running projects. And, typically, some of its design looks rough to fresh eyes. When fresh eyes see rough parts of a software project, [it's important to write about it promptly](https://danluu.com/wat/), and the Anki community is large and dedicated enough that it seems worth doing that writing in public. So here's what I think could be better.\\n\\nBy the way, [It Sinks In](https://www.itsinks.in) is an attempt to address some of these issues with a user-friendly, cloud-based approach.\\n\\n#### Caveats\\n\\n1. Anki is, I think, maintained by a very small team. Some of the notes about the intelligibility of the schema matter less if there aren't many people who need to work with the database every day. You can think of the relevant notes as things that are merely suboptimal now and *would* be more damaging *if* the Anki project were to grow.\\n1. The underlying database is, I think, not (or at least not primarily) intended for direct manipulation by program users. So there's a sense in which it doesn't matter very much how intelligible I think the data management is. That said, insofar as it affects the accuracy or performance of the software, it certainly matters. And given that people turn over parts of their minds to Anki, it's especially urgent to document these things.\\n1. Anki is great and all this comes from a place of love.\\n\\n#### Principles behind these notes\\n\\nYou can think of this as a data-oriented extension of my code review reference; this is all stuff I find myself saying *a lot*. Seeing so many of these issues crop up in Anki's database was one impetus for making a case study of it.\\n\\n1. Try to name columns (or tables, or documents, or whatever) according to *what the thing is*. Not its domain, not what you want it some day to be, and not even its intended use, but what it *is*.\\n1. Unless you have a very good reason to *denormalize* your data, represent a given piece of information at most once in your database.\\n1. Unless you *really* need to optimize something, make a given column represent only one piece of information. (You know those surveys where you rank things on a 1-7 scale, but \\\"4\\\" also means \\\"not applicable\\\"? Do better than that.)\\n1. All else equal (and sometimes even if not), use consistent conventions (e.g., for naming, for delimiters, and for [UUIDs](https://en.wikipedia.org/wiki/Universally_unique_identifier)).\\n\\n#### Notes\\n\\n1. In the `cards` and `notes` tables, the `id` (primary key) field is the number of milliseconds since the epoch when it was created. There are good reasons not to have semantically meaningful information in the `id` field: in this case, it is entirely possible for several `cards` to be created at the same millisecond. (The foreseen use case is that of a single human creating cards manually, but what if the system scales to many users with many cards? What if cron jobs that go off at midnight generate new cards? What if cards are created from timestamps that only have second-, hour-, or day-level resolution?)\\n1. In the `cards` table, the `type` and `queue` columns duplicate information and both express what I'd be tempted to call a \\\"learning status\\\" (whether the card is new, is being reviewed, is buried, and so on). The database would be cleaner with these collapsed into a single column with a better name.\\n1. In the `cards` table, several columns have integers representing times or durations for which the units are different depending on some other feature of the card. For example, the `due` column is an integer representing either a number of days or a number of seconds, depending on the card status. I could imagine a case for splitting this out into separate columns. It's also worth considering not explicitly storing the data at all, because it's a function of other data (and the learning algorithm). Because most decks are not huge, it could probably could be calculated on demand (or, if it really needs to be precomputed, cached elsewhere).\\n1. The `cards` table has a `reps` column indicating its number of repetitions. This duplicates information from the `revlog` table. One could imagine a situation where information needs to be denormalized in this way, but (i) this system is clearly not designed for the sort of scale that would require that (see other notes) and (ii) if so, it would probably be better to keep \\\"source of truth\\\" `cards` data in a separate table and generate separate denormalized views or tables. Similar comments apply to the `lapses` column.\\n1. The `flags` field is only significant mod 8: mod-8 values correspond to various colors of flags or no such flag. This rules out the possibility either of a card's having several flags set or of there being more than 8 flag-states. Moreover, coders accustomed to \\\"flags\\\" fields will likely anticipate a system where bits of a binary representation correspond to flags' being set. Given that this is an integer field in either case, little would be lost and much gained by adopting a more standard system for representing flag values.\\n1. There is a `graves` table representing cards, notes, and decks that have been deleted. This is awkward. First, it combines heterogeneous data (data that are different not only in representing different categories of items but also in actually being stored in separate tables in this database when learning circumstances are different). Second, it amounts to moving data from one table to another in the case of a status change; it is usually better to simply make such a change like that in existing status fields. (I often find that solutions like this are attempted compromises by programmers who are pretty sure, but not completely sure, that data should be deleted. It is almost always better to settle that question once and for all--by literally deleting it, by leaving it, or by sending it off to some archive or backup--than to attempt this kind of compromise.)\\n1. The relationship between `notes` and tags is represented by a text column on `notes` with a list of tag names, both separated by spaces and with spaces at the end (in order to support `LIKE \\\"%tag%\\\"` queries, according to the Ankidroid documentation linked above). This is an error-prone way to represent a many-to-many relationship. I'm not an SQLite expert, but I'd imagine it's inefficient, too. More fundamentally, tags are clearly domain objects that should be properly represented (and probably need their own table). Whenever I've tried to keep track of objects like this *ad hoc* as strings--and I've tried this many times!--I've regretted it. (Do as I say, not as my past self has done.)\\n1. `flds` (representing a many-to-many relationship between `notes` and fields) is represented similarly to `tags`, but separated by `0x1f`. The comments above apply, and there's an extra bit of potential confusion because the delimiter is different here. An aside: in this case, using `flds` instead of `fields` appears to be abbreviation for abbreviation's sake, and nothing more. But I often find that abbreviations like this, especially when nearby objects are *not* abbreviated, correspond to misalignments between the abbreviated word and the data object. So, for example, `tmstp` might abbreviate \\\"timestamp\\\" but actually mean something closer to \\\"a timestamp but not really.\\\" When you read code, get in the habit of asking whether abbreviated names are subconscious (or conscious) expressions of the fact that the name isn't quite right.\\n1. The `csum` (\\\"checksum\\\") field on `notes` is (apparently) intended for uniqueness checks. (It's not clear that this is literally a checksum; see point (8).) This function would be better served by using built-in mechanisms for creating unique `id`s. (More generally, database software is pretty good at primary key management and generation. Programming is hard enough; leave this sort of thing to the software.)\\n1. In the `revlog` table, the `time` field represents a duration, is capped at 60s, and is represented in milliseconds. It's usually best not to throw away information. (Are you so sure you won't *ever* care about the difference between 65 and 75 seconds?) Moreover, this is not a time but a *duration* and should be so named. And it would probably be best simply to store the beginning and end timestamps of the review and let the calculations be done downstream: this is a subtle form of storing several pieces of information together.\\n\"\n  },\n  \"on-task-management\": {\n    \"title\": \"On task management\",\n    \"createdOn\": \"2022-05-29 16:33:06.796186\",\n    \"mdText\": \"## On task management\\n*Getting Things Done* changed my life. And I love software. So I've tried a lot of task managers, often ambitiously.\\n\\nBy \\\"ambition\\\" here I mean \\\"making my task manager most accurately reflect my tasks.\\\" Since \\\"task\\\" here means something like \\\"thing I need or want to do in light of some project or goal,\\\" making my task manager accurately reflect my *tasks* means making it a maximally complete description of my *life*.\\n\\nMaking a high-fidelity representation of one's life in task form does not tempt most people, but *does* tempt a person with certain sorts of desires. (I'm one of those people.) The problem is that there's a tradeoff between fidelity and granularity, on the one hand, and what I'll call \\\"capture efficiency\\\" on the other.\\n\\nAs you increase the detail in your task manager's digital representation of your life, affirming Aristotellian teleology with every carefully documented subtask dependency and project-task relationship, it tends to get harder to add or modify a task:\\n\\n1. The software you're using tends to be slower (in part because it needs to have enough infrastructure to support all those relationships and the features they lead to);\\n1. Things change, and the more details you have to change, the more friction there is in the life/task-manager reconciliation process.\\n\\nThe difference between using a task manager and not using a task manager is much larger than the difference between using a full-featured task manager in all its glory and using a bare-bones task manager. Friction is the biggest determinant of whether you will *actually use* your task manager (or, at least, it's the biggest determinant of whether I will use it, and similarly for basically everyone I've talked to about this). So: low friction is *the most important feature* of a task manager.\\n\\nWhat about when tasks are about fixing or improving software? Other than calling task managers \\\"bug trackers,\\\" not much changes. And, in particular, note that:\\n1. The difference between using a bug tracker and not using one is much, much greater than using a full-featured bug tracker in all its glory and using a minimal bug tracker faithfully;\\n1. The biggest practical problem with bug-tracking is getting people to use it (to file bugs, update them, close them, and append relevant information);\\n1. Full-featured bug trackers tend to have latency problems;\\n1. Whenever something significant changes on a software project, in theory something ought to be changed somewhere in a bug tracker, and the more details need to be changed, the harder that process gets (and the less likely it is to happen).\\n\\nSo that's why I use the native Reminders app both for personal task management and for (my side projects') bug-tracking.\\n\"\n  },\n  \"notes-on-a-bryan-cantrill-talk\": {\n    \"title\": \"Notes on a Bryan Cantrill talk\",\n    \"createdOn\": \"2022-05-29 16:33:06.797623\",\n    \"mdText\": \"## Notes on a Bryan Cantrill talk\\n\\nSo! Bryan Cantrill (who, it turns out, [has a Wikipedia page](https://en.wikipedia.org/wiki/Bryan_Cantrill)) gave [a talk](https://www.youtube.com/watch?v=30jNsCVLpAE) at GOTO 2017. It deserves to be seen more than a five-year-old conference talk figures to be. Some notes:\\n\\n1. For Cantrill, debugging is the process of *asking questions of a system* (and not, primarily, attempting to *fix* a system). This reminds me of Michael Feathers' view of testing as primarily about describing what a program does (and not, primarily, of enforcing its correctness).\\n1. Therefore, debuggability is the propensity of a system to have questions asked of it. I think about this in Socratic terms. When you're doing intellectual work, you of course need to have ideas to talk about. But you also need to be in the right condition to pose and answer questions in light of those ideas. That system of questioning is the more fundamental thing. (In grade school I was taught that The Scientific Method requires one to formluate hypotheses strictly before looking at data. This view seems totally archaic.)\\n1. Relatedly: suppose *X* is causing an incident in a distributed system. Given that, you'd like to have an alert for *X*. It does not follow that you should have tons of alerts all over the place! Humans are not very good at inferring from alerts to causes in the first place, and this ability degrades quickly with the number of alerts to process ([video link](https://www.youtube.com/watch?v=gO8N3L_aERg)). eThis is not quite how Cantrill puts the point.)\\n1. We can learn about distributed systems incidents by looking to history, and not just the history of computer distributed systems. (Cantrill has a useful discussion of [Three Mile Island](https://en.wikipedia.org/wiki/Three_Mile_Island_accident).)\\n\\nSome people react to intellectual challenges by reciting everything they know; others are great interlocutors. Whom would you rather be working with in an emergency?\\n\"\n  },\n  \"on-winning-auctions\": {\n    \"title\": \"On winning auctions\",\n    \"createdOn\": \"2022-05-29 16:33:06.800945\",\n    \"mdText\": \"## On winning auctions\\n\\nTyler Cowen [asks](https://marginalrevolution.com/marginalrevolution/2022/05/the-paradox-of-auction-happiness.html): \\\"If you win something at auction, even if you end up paying your full bid, you are typically quite happy, rather than just a smidgen happy. Then why didn\\u2019t you bid more in the first place?\\nIs your mistake being too happy, or is your mistake having bid too low?\\\"\\n\\nPossible explanations:\\n\\n1. Being in a position to bid sometimes suggests that you've found some inefficiency; it shouldn't be surprising that there's edge to be had in those cases.\\n1. Being in a position to bid sometimes suggests that you've made an up-front investment (cultivating a relationship, driving somewhere on a Sunday morning, babysitting an eBay listing, or whatever). Think of it as a series of non-refundable deposits followed by a final payment. It makes sense that the final payment (alone) is less than your reservation price.\\n1. It's a testament to the power of even modest barriers to entry. (Think of how important it is for many creators / sellers to access *truly huge*, rather than merely large, markets.)\\n1. Auctions are designed to make you feel good about winning. Those social mechanisms are powerful.\\n1. In some cases, the way the thing transforms from (someone else's) thing you're bidding on to a thing that you've secured is either difficult or distasteful to price into your bid. (Think of extending a social invitation by inviting someone to dinner: we conceptualize the invitee's time and attention differently when we're \\\"bidding\\\" for it and when we've secured it. It's very natural to be happy to have such an offer accepted, even when there's a relatively liquid market for the person's company and even when our motives are more transactional.)\\n1. Come on, it's just not that hard to beat the market a lot of the time.\\n\"\n  },\n  \"on-distributing-reading-time\": {\n    \"title\": \"On distributing reading time\",\n    \"createdOn\": \"2022-05-29 16:33:06.804407\",\n    \"mdText\": \"## On distributing reading time\\n\\nSuppose you've read 90% of Alice's output, 50% of Bob's, and 0% of Charlie's. You have an hour available for reading: whom should you read?\\n\\nOther things equal, I'd argue for: Alice, then Charlie, then Bob. That is: choose a T-shaped consumption strategy. I think it's broadly accepted that broad sampling in reading is a good idea: the controversial part is advocating for reading the 100th hour of Alice instead of the 30th hour of Bob. For one thing, you have less fresh material from Alice to choose from (other things equal).\\n\\nBut I find myself more and more confident in the T-shaped strategy. Some arguments:\\n\\n1. It feels to me like I get outsized value from the thinkers I read the most.\\n1. One of my favorite questions to ask impressive thinkers is: \\\"Who is the most obscure person whose output you read all of?\\\" I've *never* posed this question without getting a good answer. That is, impressive thinkers are pursuing the \\\"consume everything from at least some people\\\" strategy, and I should mimic that strategy.\\n1. There is a valuable reward, governed by a threshold, to reading enough of someone's output: you get a mental model of how they think. (Patrick McKenzie put it that way in [this interview](https://www.thinkingpoker.net/2020/12/episode-341-patrick-mckenzie/).) Moreover, it pays to invest in those models even after you cross the threshold, because that improves the model.\\n1. The Internet improves the value from both the top and the tail of the T more than it does the middle. There's more and better content to sample broadly from, while the best thinkers are becoming absolute intellectual powerhouses (in part by using the Internet to consume and reply to objections to their work).   This is obviously speculative, but I'm very confident in it.\\n1. The best thinkers are not only improving the quality of their thought but also finding more and more channels to distribute their output. It's striking to me how often I see footnotes from a generation ago that say things like: \\\"Professor X always said this and argued for it brilliantly, but she never published on it in any form;\\\" I suspect that happens less now. (There's a lot of analysis about how the newsletter renaissance is changing flows of money. That's interesting and important, but I'd love to read more about how it's improving the intellectual outputs of the people best suited to it.)\\n1. Many of [the arguments for long books](on-long-books.html) also apply to large bodies of work.\\n1. Rereading is underrated, so it's a mistake in the first place to view what you've already read as an exhausted resource. And the returns to rereading the best thinkers (best *for you*) are much higher.\\n1. Reading output from a favorite thinker tends to have both a high ceiling and a high floor, and (for me, at least) these increase my motivation to do the reading in the first place. So I'm more likely to read more if I'm reading Alice than if I'm reading Bob, and shifting the marginal time to reading from whatever else I'd be doing is probably valuable.\\n\\nNozick famously said of [Newcomb's Paradox](https://en.wikipedia.org/wiki/Newcomb%27s_paradox) that almost everyone agrees that the answer is obvious, but they disagree about what the answer *is*. I suspect this issue is similar.\\n\"\n  },\n  \"what-is-americas-epic\": {\n    \"title\": \"What is America's epic?\",\n    \"createdOn\": \"2022-10-17 10:27:55.725026\",\n    \"mdText\": \"## What is America's epic?\\n\\n[The Twitter question du jour](https://twitter.com/Isaiah545251391/status/1581434205376253954?s=20&t=seLz9j0b1chgkAgcc43moRVWVUCtxoOtsD7kibi3GO4) is: What is America's epic? That is, what is to America what the _Iliad_ is to Greece, _Ulysses_ is to Ireland, and _Don Quixote_ to Spain?\\n\\nMy first thought was _Moby-Dick_, which is a pretty common answer. But I'll take _The Scarlet Letter_ instead:\\n\\n1. It is accessible yet difficult, engaging, and deeply moral.\\n1. It's part of our explicit national consciousness in a way that _Moby-Dick_ and most other contenders are not.\\n1. More people have actually read it than _Moby-Dick_ and most other contenders. (Let me be clear that I also [have not read more than 1/5 of](on-actually-reading-the-book.html) _Moby-Dick_, but I [have read](100-books.html) many other classic American novels.)\\n1. It is, arguably, an origin story about American morals and values. (The frame of the novel is underrated.)\\n1. And it is a story about the *transmission* of values and character. A good epic should have at least one main character who is a child, right?\\n\\nI'll put _The Great Gatsby_ in second place:\\n\\n1. There are explicit visions of American values and character traits. Think of the note about American physique and sports when Gatsby is leaning out of his fancy car or the note about how \\\"Americans, while occasionally willing to be serfs, have always been obstinate about being peasantry.\\\"\\n1. It's still quite famous. Plenty of Americans have read it (though I strongly suspect that far fewer high schoolers read it these days).\\n1. It is built around a journey from the Midwest to the East and back.\\n\\nI haven't seen anyone mention _East of Eden_ yet, but I'd put it somewhere in the 5 or 10 best answers to this question.\\n\"\n  },\n  \"reading-notes-the-end-of-solitude\": {\n    \"title\": \"Reading notes: The End of Solitude\",\n    \"createdOn\": \"2022-09-04 19:47:09.194691\",\n    \"mdText\": \"## Reading notes: The End of Solitude\\n\\nRead William Deresiewicz if you care about English prose, argument, higher education, politics vis-a-vis education, or anything else he happens to be writing about.\\n\\nMisc. notes:\\n\\n1. These *really are essays*. They cohere; they have arguments. It's a joy to read someone who is, fundamentally, not a take-generation machine or some other sort of content monster. I'd group him with [Byrne Hobart](on-reading-the-diff.html) or Ian Mueller, whom Stephen Menn described as a \\\"sporadic\\\" [in the Diogenes Laertius sense](https://www.philosophie.hu-berlin.de/de/lehrbereiche/antike/mitarbeiter/menn/ian-mueller.pdf). Deresiewicz has his commitments and beliefs, but fundamentally he is an extremely active reader and intellect who synthesizes his intellectual life for the rest of us. Reading folks like this is one of the great intellectual joys in my life. It's heartening that there are (I think) more and more of them around these days.\\n1. The essays I'd read before (in most cases, roughly 10 years ago) feel very different here in 2022.  Most obviously, COVID has given new urgency and relevance to questions of what solitude is, how to do it properly, and whether we can have too much of it.  So many people have found themselves surprised by what it's like to be alone, physically or otherwise.  _The End of Solitude_ is, so far, the most important COVID book (both \\\"book that came out during COVID\\\" and \\\"book about COVID-related subjects\\\") I've read, for having the most to say about these issues.  (In case you're curious, #2 on that list is [_The Last Days of Roger Federer_](reading-notes-the-last-days-of-roger-federer.html).) \\n1. Deresiewicz writes from anti-capitalist, anti-neoliberal commitments.  I'd say that mainstream leftist politics (even those strains that get branded as \\\"extremist\\\") have moved pretty far away from Deresiewicz's views in the last decade--however much they use \\\"capitalist\\\" and \\\"neoliberal\\\" as slurs.  Sustained critiques of capitalism and neoliberalism that don't rest on identity politics or certain other prominent political stances are less common than they used to be, and this is the best in recent memory. (Deresiewicz *does*, however, have some things to say about identity politics itself: across various essays, he critiques it as the consolidation and exercise of a certain strain of elite power. Like it or not, he has a lot of argument and evidence behind the view.)\\n1. I am in the position of, on the one hand, seeing Deresiewicz as a breath of fresh air and, on the other, reading page after page about how so many of my values, goals, and ideals are delusional and/or evil. If you are similarly situation but prefer not to read many dozens of pages about how misguided you are, may I recommend [A Jane Austen Education](https://www.amazon.com/Jane-Austen-Education-Novels-Friendship-ebook/dp/B004IYIUQA)? What I actually recommend is reading it anyway, but one can't be scolded into a deep engagement with the best arguments against one's life structure and value system. That requires ethical development and the liberal arts--which brings us back to _The End of Solitude_.\\n1. There's a lot more than the headline topics in the book. Two unexpected joys were \\\"Hunting the Whale,\\\" about the novel and recent books about the novel, and \\\"A Jew in the Northwest,\\\" about being a Jew in the Pacific Northwest (including notes on Malamud and Leslie Fielder).\\n1. One metric I use to reflect on my reading is how much of my mental life a book takes up when I'm in the middle of a book but not at the moment reading it. _The End of Solitude_ scores very high here.\\n1. As I write this, it's my [second-favorite book](2022-favorites.html) of the year. I imagine Deresiewicz wincing at my tendency to rank what I read, but I'll [stand by the habit](on-ranking-things.html).\\n\\nFinally, a few striking passages:\\n\\n> Youth, now, is nothing more than a preliminary form of adulthood, and the quiet desperation of middle age has been imported backward into adolescence.\\n\\nAnd:\\n\\n> Unlike the campus protesters of the 1960s, today\\u2019s student activists are not expressing countercultural views. They are expressing the exact views of the culture in which they find themselves (a reason that administrators tend to be so ready to accede to their demands).\\n\\nAnd:\\n\\n> To put it another way, Portland does not seem to have any grown-ups. Sure, there are people in their forties and fifties and seventies, but there isn\\u2019t anyone who represents the past, and the weight of the past, like my old-timers and Italian grandmothers. There isn\\u2019t anything that represents the past.\\n\\nAnd:\\n\\n> Elite mass culture hardly even anymore pretends to be interested in art\\u2014in art, that is, as opposed to entertainment, high art as opposed to kitsch. Art is too hard, too subtle, too complex, too time-consuming, altogether too recalcitrant. The professional would rather watch Netflix; the \\u201ccultural critic\\u201d would rather pontificate about the TikTok trend. Rosenberg didn\\u2019t think that kitsch was even worth bothering to attack. Now it rules the world.\\n\\nHighly, highly recommended.\\n\"\n  },\n  \"reading-notes-how-to-fail-at-almost-everything-and-still-win-big\": {\n    \"title\": \"Reading notes: How to Fail at Almost Everything and Still Win Big\",\n    \"createdOn\": \"2022-05-29 16:33:06.807891\",\n    \"mdText\": \"## Reading notes: How to Fail at Almost Everything and Still Win Big\\n\\nBarry Greenstein once wrote that you should pay special attention to poker players who make obvious mistakes but still win: that means they're doing something very right. That comment changed my life. Absorbing it has, for example, made me vastly more likely to read books by Scott Adams.\\n\\nWhat I can't stop thinking about is how this book, despite vast differences in tone, shares so much content with, e.g., Katy Milkman's *How to Change* (\\\"modifying your environment and engineering the cues in it will have a much greater effect than one suspects\\\") and any number of coastal-elite exercise fora (\\\"do everything you can to generate positive energy in your life; the rest will follow\\\").\\n\\nOther miscellaneous notes:\\n\\n1. Adams writes: \\\"One of the most important tricks for maximizing your productivity involves matching your mental state to the task.\\\" This is essential, and I'd add that matching the available time to the task is important too. ([Have defaults](12-rules.html).)\\n1. He advocates making all your other choices to maximize your \\\"personal energy.\\\" Strategies like this are underrated, and remind me of successful companies that prioritize speed. (Dan Luu is also [excellent](https://danluu.com/productivity-velocity/) on this subject.) Investing is a useful analogy: your retirement account looks a lot better with bigger contributions and a mediocre strategy than with smaller contributions, brilliantly managed. (And if you think that compounding intellectual capital and output are underrated--they are!--shouldn't you also care a lot about your total capacity for doing stuff?)\\n1. One distillation of the book is as an extended encouragement to think of yourself as a \\\"moist robot\\\" that is *extremely* sensitive to your environment, immediate stimuli, and social connections. You can think of this as rephrasing  James Merrill's remark that if you want to know how you feel, look at the furniture. (If James Merrill were not the poet of *The Changing Light at Sandover* but someone who describes \\\"the fortified-burrito business\\\" as \\\"a way to do some good for the world that had rewarded me so handsomely.\\\")\\n1. Another distillation: it's not really too hard to elevate yourself to the top 1st to 10th percentile in a skill, so why not pick 5-10 essential skills (e.g., conversation) and elevate them? (This is an echo of [Patrick McKenzie](https://www.kalzumeus.com/2012/01/23/salary-negotiation/) asking: \\\"If I told you I would pay you a hundred thousand dollars if you did five minutes of poetry recital while standing on one foot, would you do it?\\\" His answer is \\\"Of course, so why not learn a bit about salary negotiation, even if you hate it?\\\")\\n\\nP.S.: I can't track down the James Merrill quote; all leads appreciated.\\n\"\n  },\n  \"on-viewquakes\": {\n    \"title\": \"On viewquakes\",\n    \"createdOn\": \"2022-05-31 06:42:11.288844\",\n    \"mdText\": \"## On viewquakes\\n\\nA decade or so ago, it was briefly fashionable to think in terms of \\\"[viewquakes](https://www.reddit.com/r/slatestarcodex/comments/3st7e5/what_was_your_last_great_viewquake/).\\\" These are \\\"insights that dramatically change one's worldview, making one see the world in a new way.\\\" This fashion has passed. \\\"Viewquake\\\" appears to be a Robin Hanson coinage, and you know a Robin Hanson coinage is obscure if a Marginal Revolution search for it comes up empty, as \\\"viewquake\\\" and \\\"viewquakes\\\" do as I write this.\\n\\nThe phenomenon seems to me still to be under-appreciated and under-theorized. A lot of what I think is shaped by ideas that (i) I went a long time not believing or understanding, (ii) can be stated fairly succinctly, and (iii) now work as a high-frequency cognitive tool. They're a bit like favorite movie quotes in terms of salience and propensity to jump to mind (but more intellectually useful, at least on average).\\n\\nA striking phenomenon of viewquakes is that they're non-transferable. Andrew and I would often ask guests on Thinking Poker about \\\"aha!\\\" moments or viewquake-like insights for them. Those insights seemed unremarkable, even from world-class players. More generally, how often have you been stunned by someone's \\\"single key to life\\\"?\\n\\nMy best theory for this starts with a Cowen-style emphasis on [scarcity and context](on-the-scarcity-of-context.html). A large, multi-dimensional understanding is required in order for a viewquake to register as a viewquake. (Here I'm tempted to disagree with Hanson and say that a viewquake often *results from* seeing the world in a new way, though it reinforces a different and often superior understanding.)\\n\\nHere's [a recent viewquake](viewquake-decisionmaking-is-overrated.html) of mine: \\\"Decisionmaking is overrated (because having a stream of good options matters far more).\\\" This resonated *with me* because of my background in poker (and transition into software); years of reading finance-themed newsletters and gaining a new vocabulary around options and a new understanding of variance; and because I was thinking hard about how to maximize my productivity. Such things, and many others, tend to come to mind along with that phrase. I expect a lot of readers found the sentence itself a bit underwhelming. I bet many have a longer-lasting and more intuitive grasp of the idea; perhaps others find its surface meaning uncontroversial and don't feel the impulse to see many other ideas in it; others might be left cold for different reasons.\\n\\nSo, I conjecture that viewquakes are non-transferable (as viewquakes) for roughly the same reasons that cultural and other expertise isn't transferable (that way). If you know more about this, please do [tell me](mailto:natemeyvis@gmail.com).\\n\"\n  },\n  \"on-reading-the-diff\": {\n    \"title\": \"On reading The Diff\",\n    \"createdOn\": \"2022-05-29 16:33:06.809362\",\n    \"mdText\": \"## On reading The Diff\\n\\nYesterday [Byrne](https://twitter.com/ByrneHobart) asked for testimonials. In a happy coincidence, I was already planning to write something about consuming newsletters.\\n\\nI've argued elsewhere for \\\"[T-shaped](on-distributing-reading-time.html)\\\" reading plans: it's an underrated skill, maximizing how much and well you consume what you're best at consuming. But now you need to figure out: what should it be that you consume a lot of?\\n\\nFor me, it's largely newsletter writers. The economics of this aren't fully clear to me (or anyone else, I think), but the people I'm most willing to bet chunks of my cognitive life on are, disproportionately, writing newsletters or newsletter-adjacent things.\\n\\nWhy? \\n\\n1. It makes them prolific, which fuels componding returns for a good reader (see above).\\n1. There are massive intellectual benefits to writing on the cadence a newsletter encourages, so the writers are improving most rapidly.\\n1. Various selection effects.\\n1. There are intellectual benefits to reading on the cadence a newsletter encourages, too.\\n1. It's important to have a lot of upside in your intellectual choices, and the best newsletters can improve in a basically unbounded way. (This is an aspect of (2).)\\n1. They're good influences: having newsletters in your environment surrounds you with models of hard, diligent work.\\n1. They're fairly likely to develop intellectual perspectives that aren't redundant with the rest of what's out there. (Related to (2), (3), and (5).)\\n1. They're in your email archives already, so they improve your email search results. (Less important than the others, but a nice bonus.)\\n1. And right now, [The Diff](https://www.thediff.co) is--for me, at least--the best newsletter going and the single most indispensable part of my information diet. I'm not really a finance guy--I just think of it as a student of the world sending me frequent dispatches from everywhere and about everything.\\n\\nSo, that's my testimonial. It's mostly a testimonial for newsletters, but also one for Byrne as a reliably useful (and fun!) read and a trustworthy investment decision for your intellectual effort.\\n\"\n  },\n  \"parenting\": {\n    \"title\": \"Notes on parenting\",\n    \"createdOn\": \"2022-05-29 16:33:06.810799\",\n    \"mdText\": \"## Notes on parenting\\n\\nI am not any kind of parenting expert. But I am asked for parenting advice surprisingly often, especially by fathers and especially by people expecting their first child. Because it's more efficient to write one blog post than many emails, and because I really like talking about parenting and welcome any comments about my views, here it is:\\n\\n#### General advice\\nWhen you don't know what to do and need a heuristic, consider using this one: make the choice that is less likely to lead to a big mistake or catastrophe. (If you prefer: assign each possible outcome one of two utility values, with one of the values corresponding to \\\"non-catastrophic\\\" and the other corresponding to \\\"catastrophic.\\\" Then assign probabilities and act accordingly.)\\n\\nConsider reallocating a little bit of the energy and thought you give to your child's eating to your child's sleep. Food is important, but so is sleep, a domain in which investments of planning and energy can pay off handsomely.\\n\\nYou're likely to get a lot of advice from other parents. A lot of these parents are (full of joy but also) worried, regretful, insecure, and so on. Try to be kind, even when they offend you. And remember that worry, regret, and so on make it even harder than usual to distinguish one's particular experience from the general situation. So: other parents' stories are a great way to learn what's possible but a very bad way to learn what's probable.\\n\\n#### Parenting and the medical system\\nYou're likely to deal with many medical professionals. Perhaps not all of them will guide you in ways that are both medically justified and in line with your values. (Pregnancy, childbirth, and pediatrics put you in the path of a lot of job titles. People with those jobs have varied training and value systems.) You and your family should prepare to advocate for each other.\\n\\n#### Parenting books\\nThey're underrated! Many great parents became great parents without the help of any books--and I mean that fully sincerely. But I have found books to be invaluable. If you like to learn by reading, don't be dissuaded by the fact that parenting books are in certain circles unfashionable.\\n\\nI'm struck by how many subdomains of parenting have a single book I vastly prefer. (Two conjectures: I haven't read widely enough or the genre admits diverse styles many of which I strongly disprefer.) Some of my favorites:\\n\\n*Precious Little Sleep*, by Alexis Dubief, for sleep. When people ask for a single book recommendation, this is it. (Dubief is a finance whiz who happened to learn all about sleep for young people and then made a career out of it, much to the world's benefit.) *The Happy Sleeper* is also worth considering.\\n\\n*Bringing up B\\u00e9b\\u00e9*, by Pamela Druckerman, for the importance of daily structure and emphasis on the fact that aspects of parenting can seem biologically necessary when they are in fact culturally contingent. (This book is controversial, and I'm not asserting that everything Druckerman says about French culture or good parenting is correct. For me it was a useful case study and a valuable tool for seeing Anglo dogmas about parenting for what they are.)\\n\\n*Oh, Crap!*, by Jamie Glowacki, for potty training. Not for the faint of heart, but neither is parenting. Review here.\\n\\n*Expecting Better*, Emily Oster. Not dissimilar to *Precious Little Sleep* in being (what started as) a side intellectual output of an expert information-synthesizer in a competitive domain: Oster is an economics professor at Brown. A useful synthesis of what science we know about pregnancy and infancy. *Cribsheet* and *The Family Firm* (its sequels) are great, too. I am often grateful that Emily Oster had a kid just a bit before I did, and I hope she keeps writing books about every parenting stage I'm about to get to.\\n\\n*No Bad Kids: Toddler Discipline Without Shame*, Janet Lansbury. My favorite book about toddler parenting. There's lots of situation-specific advice, and it's all grounded in a plausible, useful, and non-obvious theory of toddler psychology.\\n\"\n  },\n  \"on-improving-data-adjacent-code\": {\n    \"title\": \"On improving data-adjacent code\",\n    \"createdOn\": \"2022-05-29 16:33:06.812788\",\n    \"mdText\": \"## On improving data-adjacent code\\n\\nHere's the most stimulating bit of feedback from [the post about Anki's database](on-ankis-database.html):\\n> My impression is most databases are designed fairly haphazardly, and while tables may have fields added, the entity relationship diagram stays pretty static. My rationale is as follows: (1) A database schema requires quite a bit of thought and up-front design, which we're loathe to do in this agile world; (2) Schema migrations are hard and scary, so we avoid doing them.\\n\\n--[LAC-Tech](https://news.ycombinator.com/item?id=30439645) on Hacker News (lightly edited)\\n\\nSo: we get into the habit of defining structures on the assumption we can change them easily, but when databases are involved we *can't* change them so easily. This is an underrated problem; it's both technical and cultural. Here's how I try to mitigate it:\\n\\n1. *Think about* persistence from the beginning, but delay *actually persisting* things until later. Use in-memory / mock versions of your persistence layer until you've had a chance to learn more about your objects.\\n1. Have ready sources of test data, usually flat files but sometimes functions that make mock data. Maintain functions that transform that test data into your current object representations, so that you don't have to change the underlying test data every time you change your object representation. (It's usually a lot easier, both mechanically and psychologically, to change those functions than the underlying data.)\\n1. Make the in-memory / mock versions of your persistence layer obey the same interface as your database-facing code will. This means that other parts of your code base should not need to know or care about persistence details. (The Domain-Driven Design folks are good at this.)\\n1. Make utilities that test, for anything implementing the interface described in (3), whether the data conforms to the current schema. Dashboards are your friend: it's usually not hard to calculate and display lightweight analytics. Having a ready way to display a human-readable view of data samples is often invaluable. \\n1. Add tests that feed the data from (2) through whatever CRUD functions you're building, retrieve that data through the interface described in (3), and test the data with the utilities in (4).\\n\\nDifferent projects are different enough that these steps look different whenever you implement them. A common flow, however, is to have some utility function loop through `test/data/test_widgets.csv`, create a bunch of Widget objects, create a new widget persister and apply the current schema to it, pass the Widget objects into `widget_persister.add_widget()`, call `widget_persister.get_all_widgets()`, and run some tests on the result.\\n\\nAfter I sketch out a design, I often build out parts of it roughly the way I'd implement a sand castle: by starting to put sand wherever I want there eventually to be castle. (It's not too hard to touch things up along the way, and the best way to know what to fix is to have built something that shows me what's wrong.) Persistence-facing parts work differently: it's the part of the sand castle where you have to leave the upside-down bucket in place of the tower for a while and just built around it.\\n\\nThis can be tricky, but it has clear benefits: it forces you to focus, for a while at least, on the interface the persistence layer will obey more than its implementation. Most of us [don't think about interfaces enough](software-design.html), so this makes for great practice.\\n\"\n  },\n  \"reading-notes-the-three-body-problem\": {\n    \"title\": \"Reading notes: The Three-Body Problem\",\n    \"createdOn\": \"2022-07-02 12:30:52.786815\",\n    \"mdText\": \"## Reading notes: The Three-Body Problem\\n\\n1. It's pretty rare to feel compelled to go read the thing everyone was talking about 7 years ago. But I was, and it paid off.\\n1. This is my favorite science fiction novel ever. (Note that I am not a science fiction guy, and this still won't make the [top 100](100-books.html).)\\n1. There's almost no humor in the book (unless I'm just missing something, which could easily be the case, given how little I know about sci-fi and about Chinese literature).\\n1. Besides the overall \\\"what the heck is going on\\\" question, the narrative generally resolves one mystery while presenting another. This seems to owe something to the structure of video game narratives.\\n1. Of all the fiction I've read during my software carrer, this is the book with the most overlap in readership among my colleagues.\\n1. It's the most *recommendable* book I've read this year.\\n\"\n  },\n  \"on-talking-to-think-better\": {\n    \"title\": \"On talking to think better\",\n    \"createdOn\": \"2022-05-29 16:33:06.817279\",\n    \"mdText\": \"## On talking to think better\\n[Here's Tyler Cowen](https://marginalrevolution.com/marginalrevolution/2022/01/how-should-you-talk-to-think-better.html) wondering which habits of talking are good for your intellectual health and development.\\n\\nTaking his last question first: what's already written about this? Tyler's insinuation here is too pessimistic. I'd turn to:\\n\\n1. Negotation literature, especially *Never Split the Difference*. Negotiators are experts at talking in ways that (i) keep information coming, (ii) keep it high-quality, and (iii) make it actionable.\\n1. The Socratic legacy of communcation-as-thought and discursive hygiene.\\n1. The traditions of [radiotelephony procedure](https://en.wikipedia.org/wiki/Radiotelephony_procedure) and military communication: it is the state of the art in communicative clarity and error-avoidance.\\n\\nLet's start with the [Callardian](https://twitter.com/AgnesCallard?ref_src=twsrc%5Egoogle%7Ctwcamp%5Eserp%7Ctwgr%5Eauthor) Socrates. See, e.g., [here](https://www.youtube.com/watch?v=6yjjYq-Z-z0), [here](https://thepointmag.com/politics/persuade-or-be-persuaded-agnes-callard/), and [here](https://youtu.be/AwFI_t3YHPs) (and I expect her forthcoming book to be excellent), but also go read the dialogues! That picture of communication and intellectual development has these lessons:\\n\\n1. Talking with other people is *the fundamental manifestation of human thought*. What we do in our own minds by ourselves is a derivative form of multi-person thinking (paradigmatically, talking), not vice versa! So, yes, take talking seriously.\\n1. Talking-and-thought organizes itself into question-and-answer, conjecture-and-reply, assertion-and-refutation, call-and-response, or what have you. So (i) study [good questions](https://marginalrevolution.com/marginalrevolution/2021/06/how-do-you-ask-good-questions.html), (ii) be willing to be the respondent, and (iii) know which of the two roles you occupy at a given time.\\n\\nSarcasm, litotes, and cheap humor are enemies of intellectual development. In Socratic terms, they are all ways of dodging a question.\\n\\nDon't translate something (a question or an assertion) into other terms unless (i) you're simply correcting a mistake or (ii) you can give some concrete intellectual benefit to that translation. Some very smart people with favorite theories too often start by translating a subject into the terms of that theory.\\n\\nThe same goes for abstractions and generalizations.\\n\\nPauses (of a couple seconds) are underrated. They give the other person a chance to finish and yourself a chance to overcome an initial surge of emotion. But pauses longer than this can indicate (and over time *cause*) an unwillingness to locate exactly what is confusing or troubling you.\\n\\nSaying precisely what you mean, and resist the urge to qualify it or substitute a clich\\u00e9 or meme, is healthy and rare. Ironically, this one of the best ways to [cultivate weirdness](https://marginalrevolution.com/marginalrevolution/2019/12/what-will-you-do-to-stay-weird.html).\\n\\nInclude quantitative estimates. If, say, the population of France is relevant, say what you think it is. Perhaps you don't know, but being clear about your (implicit) assumptions is better than hiding them. And if you can't get within an order of magnitude, what does this say about what you're saying? Over time this encourages quantitative accuracy and, more generally, *learning about the world*.\\n\"\n  },\n  \"on-dependencies\": {\n    \"title\": \"On dependencies\",\n    \"createdOn\": \"2022-05-29 16:33:06.822595\",\n    \"mdText\": \"## On dependencies\\n\\nIf I could give four words of instruction to an unknown intermediate-level programmer, I'd probably go with \\\"think about dependencies more.\\\"\\n\\nIt's remarkably hard to keep track of what exactly you're thinking about when you're thinking about dependencies. There are at least three candidates:\\n\\n1. There are dependencies at the file/package/module (depending on the system you're working in) level. When your compiler (or interpreter, or whatever) complains about a circular dependency, this is the kind of dependency you start reasoning about.\\n1. There are dependencies of objects on objects. So, when you read *Architecture Patterns in Python* and you read that your domain entities should be depended on and not depend on anything else, it's this kind of relation you're thinking about. But these discussions often occur at the code level, and there is also a logical level, so that:\\n1. There are dependencies of objects on objects at the logical level. So, for example, when you make a foreign key reference in a Django model [with a string instead of the Model itself](https://docs.djangoproject.com/en/4.0/ref/models/fields/), you avoid a dependency at the code level but retain it at [the logical level](an-argument-from-jimmy-koppel.html).\\n\\nThere are a few immediate lessons here:\\n\\n1. It's easy to take yourself to be thinking about one kind of dependency and actually be thinking about another.\\n1. If you're making a dependency graph, be sure not to graph different kinds of relationships at the same time or unwittingly make the same box refer to, e.g., both a module and a logical object.\\n1. Devices that remove one sort of dependency might leave another sort of dependency, and the remaining dependency might be dangerous.\\n\"\n  },\n  \"reading-notes-theres-no-such-thing-as-bad-weather\": {\n    \"title\": \"Reading notes: There's No Such Thing as Bad Weather\",\n    \"createdOn\": \"2022-10-16 07:23:12.882059\",\n    \"mdText\": \"## Reading notes: There's No Such Thing as Bad Weather\\n\\nI found this book valuable enough to finish. Valuable enough *for me*; it's hard to *recommend* it.\\n\\n1. The central message of the book is that, along many dimentions, Sweden is different from, and preferable to, America. You don't have to believe this to benefit from the book, but there might be limits to how much of this you want to read.\\n1. The book cover promises \\\"a Scandinavian mom's secrets,\\\" but there's less of that than simple reporting of what Scandinavia is like. If I had to choose a genre for this book, I'd pick autoethnography, not advice. The bulk of the book is description and interviews.\\n1. \\\"Simple reporting\\\" of parenting cultures I haven't experienced is, however, broadening and valuable. *Bringing up Bebe* is a favorite parenting book (and in my [top 100](100-books.html)). I'd like to read more books like this.\\n1. There are many references to studies and books, but these are peppered in the text in an unsatisfying way. They're unlikely to convince you if you don't already like McGurk's point of view. (This is standard enough in pop-science and parenting books, but enough hours spent with writers who are better at this--Janet Lansbury, Jamie Glowacki, Emily Oster--will make you [expect better](https://www.amazon.com/Expecting-Better-Conventional-Pregnancy-Wisdom/dp/B08SJDP2CW/).) The discussions of sleep safety and of hygiene-related tradeoffs are two areas where a more rigorous and balanced scientific treatment would have been particularly valuable.\\n1. Some passages haunt me. I have spent many hours fussing over the details of baby food composition, environmental tradeoffs in diapering, and so on, but I would complete the prompt \\\"I know exactly what I want for this child\\\" very differently from McGurk:\\n> I know exactly what I want for this child. Natural childbirth--check. Cloth diapers in gender-neutral diapers--check. Homemade, organic baby food--check.\\n1. A valuable complement to McGurk's view of Scandinavian parenting culture is volume six of Knausgaard. But that's also a tough thing to recommend or [to expect someone to have read](on-actually-reading-the-book.html).\\n\\nSo: I have my complaints, but I'm glad I finished this book. If nothing else, I'm more eager to take my kids outside in light rain.\\n\"\n  },\n  \"listening-notes-the-pragmatic-programmer\": {\n    \"title\": \"Listening notes: The Pragmatic Programmer\",\n    \"createdOn\": \"2022-06-06 19:19:11.024455\",\n    \"mdText\": \"## Listening notes: The Pragmatic Programmer\\n\\nThe audiobook for *The Pragmatic Programmer* is everything that an audiobook, and especially everything that a *technical* audiobook, should be. I love to listen to stuff about software, but a lot of it doesn't suit the medium well. A lot of thought went into this: the narrator is excellent, some passages are read by the authors, and the code snippets are adapted to the audio format with good judgment.\\n\\nSatisfyingly, this is not just an authorial but a *programming* success; the book itself is used as a case study in how to use text as a single source of truth, how to parallelize parallel problems, and how to do the reasonable thing even if it annoys your publisher.\\n\\nIt's easily the single best technical audiobook experience of my life.\\n\\nThe content is also excellent: this is a true revision of the original. It mixes \\\"wisdom of the ancients\\\" and \\\"current expertise\\\" far better than I expected it to. (Not all rereleased classics of programming literature hold up.)\\n\\nI endorse most, by far, of what's in the book. Two quick points of disagreement:\\n\\n1. Some of their recommended \\\"descriptive names\\\" (e.g., \\\"buyer\\\" for \\\"user\\\") seem dangerous to me. I'd rather maintain a focus on what the thing *is* rather than what it's *doing right now* in your code. My stock example here: if I'm writing a program to order pizza, and I currently order pizza on all and only Thursdays, I should still name the thing in my code `pizza`, not `thing_ordered_on_thursday` or `thursday_pizza`. In the `buyer`/`user` case, I fear that the code might change so that a `buyer` is also a shipping recipient, a notification recipient, or something else. Many problems are caused by names that are not descriptive enough, but many are also caused by things named according to accidents of their original context, not their real essences.[1]\\n1. The authors repeat fairly standard advice about using the power of Unix [pipes](https://en.wikipedia.org/wiki/Pipeline_(Unix)) and generally about the power of viewing programs as extended transformations. I agree about the power of the paradigm, but I'm more skeptical about its limitations. Chaining together a ton of shell programs with pipes is almost impossible to test, and I think tests are valuable even in very small projects. Also, and relatedly, this usually requires intermediate values to be coerced into textual formats. That's often fine (or even desirable--see the chapter on \\\"The Power of Plain Text\\\"), but very often I'd rather have a program pass structured (and tested!) objects around. Finally, and at the risk of offending functional-programming acolytes, the paradigm of viewing all programs as transformations can be a Procrustean bed. But that's a longer argument.\\n\\n[1] There's a counterargument here that roughly goes: if a thing takes on other roles, it will be in a different [bounded context](https://martinfowler.com/bliki/BoundedContext.html), so the other name will be for a legitimately different object in a different context, and the original (more specific--e.g., \\\"buyer\\\") name will after all have been apt. Perhaps such an argument is correct, but that's not the argument the authors give.\\n\"\n  },\n  \"on-checklists-again\": {\n    \"title\": \"On checklists, again\",\n    \"createdOn\": \"2022-05-29 16:33:06.830688\",\n    \"mdText\": \"## On checklists, again\\n\\nA while ago [I wrote that](https://www.natemeyvis.com/writing/on-linear-scans/) checklists are (i) underrated and (ii) underrated by people who might be expected to rate them highly.\\n\\nOne further note, which perhaps states the obvious: I suspect part of the resistance here is the tension between the rigidity and algorithmic nature of a checklist and the often very different nature of the thing the checklist is about. This blinds us to the possibility of using a checklist and tempts us to reject any such list on the ground that it must be missing something. It's not easy to reply to oneself: \\\"Yes, it's surely missing something, but hopefully not too much.\\\")\\n\\nWhen you learn calculus and get to integration, it's standard to hear in the first lecture that although differentiation can be done algorithmically--with few caveats, if you learn a fixed set of techniques, you can calculate any derivative you'll see--integration cannot be done that way. In general it requires some insight. A while later, you're likely to hear that if it's tricky enough, you should really just try integrating by parts.\\n\\nAnyway, here's a list I find useful:\\n\\n### What's going on when people are persistently behaving in a way I can't figure out\\n1. They're signaling something.\\n1. There's a feeling I don't understand, or a connection I don't understand between the behavior and some feeling.\\n1. Taxes.\\n1. The obvious alternative is less good than I think it is.\\n1. The Coase theorem applies (am I conflating the formal locus of power with the practical balance of incentives?).\\n\"\n  },\n  \"15-notes-on-testing-software\": {\n    \"title\": \"15 notes on testing software\",\n    \"createdOn\": \"2022-05-29 16:33:06.831831\",\n    \"mdText\": \"## 15 notes on testing software\\n1. If there is a One True Way to test software, we can't know what it is until we know a One True Way to design software.\\n1. But we don't know such a One True Way.\\n1. So, for now, it's more productive to think about empirical, surface-level claims about testing. (That's why this list is not an essay.)\\n1. Most of the world's production software is not tested.\\n1. The difference between \\\"tested at all\\\" and \\\"not tested at all\\\" is much bigger than the difference between \\\"tested really well\\\" and \\\"tested at all.\\\"\\n1. Whereas the main practical difficulty in software is getting people to write software *well*, the main practical difficulty in software *testing* is getting people to write tests at all.\\n1. So beware of instituting any policy that could be willfully misinterpreted in a way that will cause fewer tests to be written.\\n1. And beware of responding to having poor test coverage by thinking about how ideal tests look instead of the motivational causes of proper tests' not getting written.\\n1. Bug-report templates with too many required fields discourage people from reporting bugs and distract them from communicating what's most relevant. \\n1. So optimize your bug reporting to [make capture easy](on-task-management.html).\\n1. If you're picking an aspect of discipline to develop, choose \\\"actually goes and writes the test when something fails, even in development\\\" over \\\"writes beautiful and comprehensive tests for whatever thing I'm actually writing tests for.\\\"\\n1. Pytest is great.\\n1. When there's a performance problem with tests, most of the problem usually comes from just a few tests (or a single technique for setting up a fixture).\\n1. So a little profiling can go a long way.\\n1. And \\\"I don't want to slow down the test suite\\\" is not a good reason not to write that extra test.\\n\"\n  },\n  \"listening-notes-sold-a-story\": {\n    \"title\": \"Listening notes: Sold a Story\",\n    \"createdOn\": \"2023-03-23 14:04:52.939372\",\n    \"mdText\": \"## Listening notes: Sold a Story\\n\\nI enjoyed and recommend [the series](https://features.apmreports.org/sold-a-story/), but not without qualification:\\n\\n1. It is way too long. The subject deserves a long treatment, but there is simply not enough information communicated per minute. Happily, the production is so good that it remains easy and pleasant to listen to despite this.\\n1. This has to be one of the most important issues in the country right now. Let's hope Emily Hanford is right that there is an awakening underway.\\n1. I am convinced that the science supports phonics instruction (and Hanford's views more broadly), but the listener would benefit from a thorough, reasonably complete overview of the research, early and at once. Instead, we get scattered descriptions of research and many claims (not immediately justified) that a certain view is right or wrong. Hanford is *credible* when she makes these claims, but it would be more rewarding and intelligible for the listener to get a good summary of the evidence up front.\\n1. I couldn't stop thinking about how _a priori_ implausible cueing theories are. The series did not emphasize this, perhaps because appeals to intuition, to other domains (e.g., philosophy and linguistics) seem out-of-bounds; perhaps because it would be viewed as a cheap shot; and perhaps because other people don't have the same instincts I do. Nonetheless, I think a full epistemic treatment of this issue has to address the fact that phonics, as a theory of attaining literacy, makes a lot more sense than cueing.\\n1. The notes about privilege felt tacked-on and incomplete. I wasn't sure whether the claim was that rich people can afford to hire tutors, so are less sensitive to the quality of school instruction, or that cueing theories are a(nother?) manifestation of fashionable pseudoscience-as-science among American elites.\\n\"\n  },\n  \"why-events\": {\n    \"title\": \"Why events?\",\n    \"createdOn\": \"2022-10-18 10:12:30.437276\",\n    \"mdText\": \"## Why events?\\n\\nMany applications, including applications in tutorials, use events and coordinators. Students (and professionals!) often find these confusing. Here I'll try to motivate their use.\\n\\nImagine you're programming a simulation of a soccer game. You've got the basic structure of the game coded up (a field, a ball, the score, and so on). You also have:\\n\\n1. a `Team` class;\\n1. an `AssistantReferee` class that determines whether the ball is out of bounds;\\n1. a `ThrowIn` class.\\n\\nYou don't need to worry about the specific choice of object here. For example, it doesn't much matter whether you have an `AssistantReferee` or the field itself determining whether a ball is out of bounds, or even whether the functions I'm going to describe are standalone functions or methods on objects you've defined. What's important to recognize is that you have some bits of code that are modeling causally interconnected events.\\n\\nNow you need to write code to handle the situation when a ball goes out of bounds. A first pass might be something like:\\n\\n    class AssistantReferee:\\n        def is_ball_out(self, game_conditions):\\n            # logic goes here\\n            return some_boolean_value\\n\\n        def handle_sideline_situation(self, game_conditions):\\n            if self.is_ball_out(game_conditions):\\n                team_to_award = game_conditions.team_that_did_not_touch_last()\\n                self.award(ThrowIn(team_to_award, location))\\n            else:\\n                self.maintain_good_posture()\\n\\nYou can ignore most of the details there--though note that we already need all sorts of custom objects and that, as usual, even a very coarse-grained representation of reality requires quite a lot of care to model.\\n\\nWhat's important is that:\\n\\n1. This code does *not* use any explicit notion of an event or a coordinator;\\n1. This code is bad and will be extremely brittle and will soon become an unmaintainable, failing mess;\\n1. The ways in which it is bad arise *precisely from* our decision to model this situation without events and event coordination.\\n\\nYou're likeliest to notice things going wrong when you add some further bit of detail or functionality to your soccer game. For concreteness, let's say you want to model substitutions. There are times in a game when substitutions are allowed; throw-ins are one of them. We'll be tempted to simply add this to our previous code:\\n\\n\\n    class AssistantReferee:\\n        def is_ball_out(self, game_conditions):\\n            # logic goes here\\n            return some_boolean_value\\n\\n        def handle_sideline_situation(self, game_conditions):\\n            if self.is_ball_out(game_conditions):\\n                team_to_award = game_conditions.team_that_did_not_touch_last()\\n                check_for_pending_substitutions() # Are there players who are checked in and waiting?\\n                # Do whatever else needs to be done\\n                self.award(ThrowIn(team_to_award, location))\\n            else:\\n                self.maintain_good_posture()\\n\\nNow there are two big problems--or, really, one big problem that can be described in several ways:\\n\\n1. Our `handle_sideline_situation` function is doing more things that it should be doing, and will soon become a huge unmaintainable mess;\\n1. Our `AssistantReferee` object is doing things that are not properly the job of an assistant referee.\\n1. The proper causal structure of the situation is being distorted in our code.\\n\\nWhat is really happening in the game we're trying to model is:\\n\\n1. Something has happened;\\n1. That thing causes other things;\\n1. And, in particular, it could cause *several* other things that might *themselves* have consequences. (When a substitution happens, the scorer needs to know about it and a number of remaining substitutions might need to be updated; this will go on and on.)\\n\\nTo represent this faithfully, we need to treat the ball going out of bounds as its own thing. Maybe an assistant referee will detect it; maybe video review will; maybe the referee will. Maybe it needs to cause one thing to happen; maybe several. Maybe those several things need to happen in a certain order; maybe not. (And some events require *no* downstream effects.)\\n\\nThese causal relationships inevitably change, a lot, over the life of a piece of software. Keeping track of them is *not* the `AssistantReferee`'s job. Note that in real-life soccer games, assistant referees do not, strictly speaking, award any throw-ins or make any rulings; they just send signals to referees. And referees are pretty good metaphors for coordinators: they receive events and know what those events need to be triggering. In your software as in real life, it would be a disaster to have all sorts of scorekeeping, game-management, and disciplinary judgements flowing through the assistant referee just because they happened to be the proximate agent to one part of one process.\\n\\nHere I've just tried to convince you that events and event coordination are absolutely necessary. How exactly to implement them is tricky; I recommend _Architecture Patterns with Python_ for a good overview of the subject. Good luck.\\n\"\n  },\n  \"on-estimating-the-value-of-github-copilot\": {\n    \"title\": \"On estimating the value of GitHub Copilot\",\n    \"createdOn\": \"2022-06-27 19:54:40.142051\",\n    \"mdText\": \"## On estimating the value of GitHub Copilot\\n\\nForget, for a second, whether GitHub Copilot is sustainable or not, ethical or not, and so on. \\nWhat's it *worth*? \\nThat is, supposing Copilot functions as advertised and is legal and ethical to use, how much does it help a programmer?\\n\\nI suspect this value is overstated, both in general and (especially) among people who are excited about AI. \\nThat's because people are misunderstanding the value of autocomplete. \\nMore powerful, but less predictable, autocomplete is only a good tradeoff if the \\\"more powerful\\\" is *way* more powerful and the \\\"less predictable\\\" isn't too bad:\\n\\n1. Most importantly: the way we generate value is by writing maintainable, intelligible code. The time savings of a great autocomplete are usually single-digit seconds. The time costs of having something that nobody ever properly understood in your code base are easily measured in the tens of hours. It doesn't even have to be a bug: it could be something needing changing in the ordinary course of development. This way of thinking is a crude simplification--there are more possible outcomes than these two. But when the bad outcomes are four orders of magnitude worse than the good outcomes are good, they better be *very* rare. Much rarer than Copilot's will be.\\n1. The time savings of autocomplete is less important than its ability to keep you in a flow state. Less predictable autocomplete is likelier to break your flow.\\n1. The cases where Copilot can offer the biggest savings--efficient generation of boilerplate code--are likely to be less relevant over time. Better frameworks and better development practices will (we may hope) remove more and more of these tasks. And if they don't, IDEs are likely to provide better support for boilerplate generation by traditional means. You might disagree with some of this; the broader point is that AI does not have as distinctive an edge in the case of snippet / boilerplate generation as it does in other applications.\\n1. The best users of Copilot are likely to be expert users of other autocomplete tools; this also diminishes the value Copilot provides.\\n\\nNote that the above arguments do *not* apply to DALL-E or other exciting AI / ML tools, which have very different payoffs and risks, and which replace very different kinds of workflows. My argument is not that AI *in general* is too risky to use, but rather that Copilot is fighting excellent alternatives and tackling a problem with an unfavorable cost-benefit profile for AI.\\n\"\n  },\n  \"on-excel-context-and-talent\": {\n    \"title\": \"On Excel, context, and talent\",\n    \"createdOn\": \"2022-06-24 15:16:42.008792\",\n    \"mdText\": \"## On Excel, context, and talent\\n\\nMy post on [Bryan Caplan's model](https://www.econlib.org/no-one-cared-about-my-spreadsheets/) drew a lot of feedback. \\nSome expansions and clarifications:\\n\\nWhat I most remember from [Prof. Caplan's Conversation with Tyler](https://conversationswithtyler.com/episodes/bryan-caplan/) is what you might call either an interdisciplinary tendency or a willingness to consider a question itself as opposed to the question as discussed in a single literature. \\nThis raises my confidence that he will revisit his modeling methods--or at least that he, of all people, _should_.\\n\\nYou can think of a Caplan-style Excel model in at least two ways: a traditional academic artifact or a way of making claims about the best inferences to make from the data, all things considered.\\nIf you take it to be the latter, your work will or should be judged against the state-of-the-art techniques in managing data. \\nDo you get from data to results responsibly?\\nAre the computations doing what you think you're doing? \\nCan you prove it? \\nAre your data versioned and managed responsibly? \\n\\n*Whether or not you were trained that way*, that's the pond you're swimming in.\\n\\nAside: When I worked in bioinformatics, this kind of situation came up all the time. \\nSomeone would present a model and get asked some question like: \\nWhy didn't you use machine learning? \\nWhy use the 2011 data and not the 2014 data? How did you handle edge cases? \\nWhat happens if you tweak the age cutoffs? \\nAnd there were, broadly, two kinds of answers: (1) \\\"Because that's how I made my model\\\" / \\\"Kindly go ask my grad students\\\" and (2) something that shows that those questions really do concern them. \\n(Imagine if Caplan's model needed to work on data that are eight orders of magnitude bigger.)\\n\\nThere are truly hard questions here about division of intellectual labor here. \\nIt's hard to imagine reading [Reviel Netz](https://www.amazon.com/Shaping-Deduction-Greek-Mathematics-Cognitive/dp/0521541204) but with the quantitative work not done by Reviel Netz. \\nThere will be cases where the costs of communication and synchronization across people will mean that the best solution really is for the Caplan / Netz figure to use whatever tools they know.\\n\\nWhich is another argument for T-shaped competence. If there really is no good alternative to Caplan doing the model himself (though I think there is), then the value in turning [this](https://twitter.com/detectiveenters/status/1494102721259057152) into something better is enormous. And the unit of energy Caplan spent researching the fourth-most-relevant academic discipline to his education research probably would have been better spent improving this side of things.\\n\\nAnd this is also brutal evidence for [context being that which is scarce](on-the-scarcity-of-context.html) (here this plays out very literally!). I'm not surprised at [the connection between T-shaped competence and context](on-scarcity-and-regionality.html).\\n\\nAn important lens on this episode is that of Bryan trying attract the best talent to his _Case Against Education_ project. In some respects he succeeded, but on this quantitative side of things he (by his own lights) did not. (See my original post for more on the market for attention in this domain.) This helps me understand why Tyler Cowen is thinking so deeply about context while he's also thinking about cultivating and finding talent.\\n\\nKeep in mind that part of Caplan's point is not just that nobody paid attention to his spreadsheets but that people *did* pay attention to his conclusions, and that the disparity is troubling. Surely he's right about that.\\n\\nA constant lesson of the Internet age (and the pandemic era) is that it's hard to reason about, prepare for, and adjust to growth. A lot of human capital is stored in people--basically, all of us--who in some way need to do things differently if we want to optimize our intellectual output to the current world (and the future). Whatever the right solution here is, it certainly involves a lot of kindness and intellectual charity.\\n\"\n  },\n  \"listening-notes-jason-strasser-on-the-risk-of-ruin-podcast\": {\n    \"title\": \"Listening notes: Jason Strasser on the Risk of Ruin podcast\",\n    \"createdOn\": \"2022-05-29 16:33:06.833070\",\n    \"mdText\": \"## Listening notes: Jason Strasser on the Risk of Ruin podcast\\n\\nJason [was on the Risk of Ruin podcast](https://www.buzzsprout.com/1267901/10676159-the-character-building-side-effect-of-losing?t=0) recently. He was characteristically thought-provoking and eloquent. So, for example, he notes that a lot of practical poker knowledge--or, at least, *his* practical poker knowledge--consisted in being able to describe situations to himself in real time and have a game plan for those situations. There's an art to carving up the space of possibilities in a way that's both real enough to be useful and coarse-grained enough to be intelligible. This is an underrated facet of poker thinking and also useful across disciplines.\\n\\nMostly, though, I was struck by a software parallel to something Jason said about risk.\\n\\nJason notes that risk profile by itself is meaningless, in the sense that (e.g.) the fact that a strategy wins *X* times for every *Y* times it loses says nothing about whether it is good for you to use that strategy. That is primarily because it offers no guarantee that the strategy has any edge in the first place. (It does you no good to win a lot if the losses, when they occur, are too large.)\\n\\nThis reminds me of excitement in software around type systems, formal verification, and elaborate testing principles. All of those have their place; all provide guarantees of desirable formal properties, given the existence of certain background relationships between what they are verifying and the real world; all are *silent* on the question of whether those background relationships *actually hold*. So, in software, you might have some type system and static verification system that guarantees that a system will behave \\\"correctly,\\\" in the sense of provably transforming certain inputs in certain ways.\\n\\nThat's a great guarantee to have, but only if the right correspondence holds between the code you're verifying and the world. One reason--obvious, but very important--for this is that provably well-behaved code often does not accomplish any real-world result [anyone cares to bring about](https://xkcd.com/1312/). A less obvious reason has to do with what Jimmy Koppel calls [the three levels of software](https://www.natemeyvis.com/an-argument-from-jimmy-koppel/):\\n\\nProviding some guarantee about *some implementation* of something says, in general, rather little about whether a software system *can correctly represent something over time*. Exactly how and why this disconnect happens is a tricky metaphysical question. But *that* the disconnect happens is indisputable. You can see this in a lot of codebases that use strong typing, various kinds of formal verification, or similar: the most common and obvious symptom is that all sorts of things are annotated as `Any` (or some analogoue of `Any` in the system at hand). This is usually because the system had to be modified to handle cases that the carefully constructed types could not faithfully represent. And *that* is usually because those types were not correctly representing anything at all. If you are designing a wicker cabinet shipping system, all the formal verification in the world will not help you if the objects in your code do not properly represent a wicker cabinet, a shipping container, or whatever else.\\n\\nA further analogy between Jason's comments and the software phenomena I've described is psychological. An \\\"attractive risk-reward profile\\\" (on the trading side) or heavy-duty formalism (in software) often provides a sense of entitlement. This causes people to attribute failures either to bad luck or an unfair system. They're really not so different, the gambler whose martingale strategy failed him and the software engineer lamenting that his beautiful type system was vitiated by the \\\"surprising\\\" new requirement that it be able to express the fact that not all wicker is made of bamboo or rattan.\\n\\nOf course, I love testing and use way more type annotations than most programmers who do what I do. (And Jason loves not going broke every time a trade goes wrong.) There are just a lot of ways to misuse these tools. The human capacity for error and self-delusion is always there, and it's almost never a mistake to worry about it a bit more.\\n\"\n  },\n  \"reading-notes-the-managers-path\": {\n    \"title\": \"Reading notes: The Manager's Path\",\n    \"createdOn\": \"2022-05-29 16:33:06.834907\",\n    \"mdText\": \"## Reading notes: The Manager's Path\\n\\nOn the one hand, *The Manager's Path* is pretty conventional: it reads like a business book and it's structured like a business book. On the other hand, the experience of reading it is totally unlike that of reading most other business books. Fournier is clearly writing from real experience and expertise, and--however thoroughly the book was edited after its first draft--its origins as a [Nanowrimo](https://nanowrimo.org) project show in the book's urgency. (In the best way.)\\n\\nI'm reminded of the poker world, where every so often an expert decides to transcribe a lot of their expertise in book form, usually without much regard for the traditional menu of literary forms. Fournier is a much more disciplined and skilled writer than most poker players, but I'd still put this in that category.\\n\\nMiscellaneous notes:\\n\\n1. Fournier recommends budgeting 20% of a team's time for \\\"generic sustaining engineering work.\\\" I take this as evidence for [my claim](reading-notes-a-philosophy-of-software-design.html) that Ousterhout, if anything, shot too low when he suggested 10%-20% for (roughly) analogous purposes.\\n1. She notes that \\\"a common dysfunction of technical teams is not shipping code.\\\" This is simple and profound. There are software-team-specific reasons for this, but most fundamentally, an underrated barrier to doing as much as possible is *not doing anything*. (See #6 [here](on-productivity.html).)\\n1. Here's a great sentence: \\\"Think of process as risk management.\\\"\\n1. Here's a very good clause: \\\"Code review is largely a socialization exercise...\\\"\\n\\nHighly recommended, even if you aren't particularly interested in becoming a software manager.\\n\"\n  },\n  \"new-site-design\": {\n    \"title\": \"New site design\",\n    \"createdOn\": \"2022-05-29 16:33:06.836163\",\n    \"mdText\": \"## New site design\\n\\nAbout a month ago:\\n\\n1. I was coming to realize how dangerous dependencies are...\\n1. ...even or perhaps especially [in small projects](on-dependencies-in-small-projects.html).\\n1. I wanted to be writing English prose in Vim, not a Web editor.\\n1. I wanted my effort, other things equal, to be gaining me capital (human, intellectual, or otherwise).\\n\\nSo I started writing a static site generator:\\n\\n1. It's not *that* much harder to make your own SSG than to learn an existing one.\\n1. And I can make (or at least work toward) the SSG I want. (A common criticism of projects like this is that existing projects are always going to be better than what you hand-roll. Perhaps they're better by some independent metric, but most of their features are not useful to me, and often there are a few things I want to do that require a lot of painful customization.)\\n1. As I started out, I learned that making an SSG is very different from making the sorts of things I usually make. It's been useful for separating what is true about software *generally* from what is true about the sorts of software projects I've been consumed with thus far in my career.\\n1. I've been struck by how many software or software-adjacent people I know have custom Web sites.\\n\\nThere will be rough edges for a while. Please excuse them. And [let me know](mailto: natemeyvis@gmail.com) if you have thoughts or bug reports.\\n\"\n  },\n  \"index\": {\n    \"title\": \"Nate Meyvis\",\n    \"mdText\": \"## Nate Meyvis\\n\\nI am an itinerant software developer, currently putting down roots at Amazon.\\nMy academic background is in math (undergrad) and ancient Greek philosophy ([beyond](https://philpapers.org/rec/MEYKSA)). \\nIf you're not sure whether you should email me, you [probably should](mailto:nate@natemeyvis.com).\\n\\nI make [Zippyflash](https://www.zippyflash.com), a spaced repetition system I've used every day for years. It [is ready for alpha users and I'd love to talk to you about it](zippyflash-is-ready-for-alpha-users.html).\\n\\nHere are my [100 favorite books](100-books.html).\\n\\nMy most significant post is [On Actually Reading the Book](on-actually-reading-the-book.html). I stand by it.\\n\\n### Spaced repetition and Anki\\n* [Here](on-using-anki.html) is how and why I use spaced repetition.\\n* [Here](on-using-anki-again.html) are notes on spaced repetition and personal dependency management.\\n* [Here](on-ankis-database.html) are notes on Anki's data model and database structure.\\n* [Here](on-self-experimentation-in-spaced-repetition.html) are notes on scheduling algorithms and self-experimentation.\\n\\n### Philosophy and academia\\n* I [disagree with](lawnmower.html) some influential guidelines for writing philosophy.\\n* I help academics [find non-academic jobs](nonac.html).\\n* I taught [a course at Boston College](openmind.html) (fall 2021).\\n\\n### Other stuff\\n* I co-hosted [a poker podcast](http://www.thinkingpoker.net/) for 8 years. [Here](podcasting-faq.html) is a FAQ.\\n* People ask me about parenting (whether or not they should do so!). [Here's](parenting.html) what I tell them.\\n\\n### A little more about me\\n* I did the [12 Rules for Living](12-rules.html) game.\\n* I like [to rank things](ranking.html).\",\n    \"createdOn\": \"2024-11-18 10:00:00.000000\"\n  },\n  \"reading-notes-the-inner-game-of-tennis\": {\n    \"title\": \"Reading notes: The Inner Game of Tennis\",\n    \"createdOn\": \"2022-05-29 16:33:06.839523\",\n    \"mdText\": \"## Reading notes: The Inner Game of Tennis\\n\\nThe central thesis of the book--or at least what I most associate it with--is that progress in a skill like tennis comes primarily from improving one's self-observation.\\n\\nThis isn't the way that Gallwey puts it, but: consider self-evaluation as a supply chain. Its inputs are:\\n\\n1. The willingness to observe oneself;\\n1. The ability to observe oneself;\\n1. The domain knowledge one applies to what is observed; and\\n1. The ability to use the results of that application for self-improvement.\\n\\nI read Gallwey as making the claims that (1) and (2) are badly underrated; (3) is overrated; and (4) will often happen automatically.\\n\\nPutting observation before analysis has benefited me across disciplines. In poker, I had what I consider my best World Series of Poker ever (as judged by the average quality of my play) not when my analytical skills were at their peak but when I hit my peak ability to \\\"stay in the moment\\\" and simply *describe* situations to myself as they happened. The correct betting decisions more or less emerged, unsummoned, after that. Computer people [widely acknowledge that](https://en.wikipedia.org/wiki/Rubber_duck_debugging) simply describing a bug, as precisely as possible, often makes the solution obvious. It's no coincidence that the aforementioned World Series of Poker happened after I'd started seriously training myself as a programmer.\\n\\nThe villain of *Inner Game*, besides inattention and distraction, is the wrong kind of investment in self-narratives. Here's Galway on abandoning one's preferred style:\\n\\n> The defensive player learns that he can hit winners; the aggressive one finds that he can also be stylish. I have found that when players break their habitual patterns, they can greatly extend the limits of their own style and explore subdued aspects of their personality.\\n\\nWe are over-invested in a kind of conceptual learning that is easier to identify oneself with:\\n\\n> We want to trust Self 1\\u2019s conceptual process of learning technique instead of Self 2\\u2019s learning from experience. Thinking that it was the obeying of an instruction that produced the good shot, ignoring the role that Self 2 plays, sets us up for disappointment when we give the same instruction yet the same good shot does not occur. Since we think the instruction was correct, the conclusion we come to is that not obeying it led to the error.\\n\\nIndeed, often people prefer to fail than to achieve a kind of success that feels insufficiently rooted *in oneself*:\\n\\n> Why would one go back to letting Self 1 control the show if the results were so clearly less effective? I had to search myself for the answer. I realized that there was a distinctly different kind of satisfaction gained in the two methods of hitting the ball. When you try hard to hit the ball correctly, and it goes well, you get a certain kind of ego satisfaction. You feel that you are in control, that you are master of the situation. But when you simply allow the serve to serve itself, it doesn\\u2019t seem as if you deserve the credit.\\n\\nAnd this ties in to the point that is made so often elsewhere, that when failure is too closely connected to one's sense of self, it's easy to stop trying in order to prevent damage to one's ego:\\n\\n> By not trying, they always have an alibi: \\\"I may have lost, but it doesn\\u2019t count because I really didn\\u2019t try.\\\" What is not usually admitted is the belief that if they had really tried and lost, then yes, that would count. Such a loss would be a measure of their worth. Clearly this belief is the same as that of the competitor trying to prove himself. Both are Self 1 ego trips...\\n\\nI recommend *Inner Game* not just as a book about improving specific skills but as an insightful study of self-knowledge more generally. It's also short enough that the reward per page is high.\\n\"\n  },\n  \"on-non-software-dependency-management\": {\n    \"title\": \"On (non-software) dependency management\",\n    \"createdOn\": \"2022-05-30 14:51:01.362632\",\n    \"mdText\": \"## On (non-software) dependency management\\n\\nThe distinctive cognitive strengths of a discipline are usually not what its practitioners think they are--or so I've argued. If that's right, then we should discount the whole genre of \\\"here's how being an *X* gives me the tools to give an excellent analysis of *Y*\\\" articles.\\n\\nSo, *caveat lector*, because I'm about to discuss how being a software engineer is informing how I quit coffee.\\n\\n[Edited to add: Turns out a lot of people find it easy to quit coffee. I am not one of those people. When I, e.g., accidentally made decaf instead of regular, I knew it by how sluggish and off I felt.]\\n\\nFirst, it made me worry about dependencies a lot more. This mostly came through experience, but reading Dan Luu really [crystallized my thoughts](on-dependencies-in-small-projects.html) about it. There are well-known frames of these habits both as delightful, life-affirming rituals and as draining, costly habits. In [thinking-about-dependencies](on-dependencies.html) mode, the latter is more salient.\\n\\nIt also informed *how* I'm approaching this. The following ideas are salient:\\n\\n1. When you have a dependency of *X* on *Y*, it's hard to know exactly which features of *Y* are being used by *X*, and how.\\n1. This gets more true as the system gets more complex.\\n1. And as documentation gets worse.\\n1. Migrations are easier and safer if you set up a mechanism to roll back to a pre-migration state if need be.\\n1. And it's best to go little by little.\\n1. It's particularly hard to make the first move.\\n\\nSo, here was my plan. (This is not medical advice. Please, please consult appropriate sources if you plan to address your dependence on stimulants / other substances.)\\n\\n1. Estimate how much caffeine I was consuming per day.\\n1. Take caffeine (in pill form), starting at roughly 70% of the estimate (to minimize the chance of accidentally increasing my daily dosage).\\n1. At first, take the caffeine pills with mugs of hot lemon water.\\n1. Day by day, gradually decrease both the caffeine per day and the amount of caffeine taken in conjunction with hot beverages.\\n1. Put the coffee machine in the basement (to minimize psychological triggers), but don't give it away yet.\\n\\nI'm at ~40% of my previous daily caffeine intake, with very little hot-beverage consumption.\\n\\nMany people quit things in many ways; this has been remarkably painless.\\n\"\n  },\n  \"reading-notes-the-tim-tebow-cfl-chronicles\": {\n    \"title\": \"Reading notes: The Tim Tebow CFL Chronicles\",\n    \"createdOn\": \"2022-05-29 16:33:06.841426\",\n    \"mdText\": \"## Reading notes: The Tim Tebow CFL Chronicles\\n\\nThis is a tough book to review! First, because it's arguably not a book: it's a bunch of Web pages at sbnation.com, and some of the narrative oomph comes not from words but from animated GIFs, Gmail screenshots, and the like. Second, because I learned about this book on Hacker News in [a post](https://www.residentcontrarian.com/p/nobody-will-admit-the-best-novel) that characterized it as \\\"the best novel of our generation.\\\"\\n\\nI am not an experimental fiction expert. But here are some things I think.\\n\\n1. This is a successful and striking work. I expect to remember it for the rest of my life. The premise is effective and Jon Bois is skilled at changing tones and formats in order to both challenge and relieve his readers. It's a work of fiction with a good engine and a skilled driver.\\n1. But it's not a particularly great *novel*, and emphatically not the best novel of our generation.\\n1. Sports, and specifically football, taps into feelings that very little else can. (There's a tweet I think about often--unfortunately, I can't find it--that said something like: \\\"Never forget how you felt after the first episode of Friday Night Lights.\\\")\\n1. I probably ought to consume more experimental fiction. Jon Bois specifically is pretty well-acknowledged as a good and effective storyteller by now (his reputation reminds me a bit of pre-Nobel Bob Dylan's), but there's a whole world out there I know little of.\\n\"\n  },\n  \"on-coordinating-intrapersonal-skill-levels\": {\n    \"title\": \"On coordinating intrapersonal skill levels\",\n    \"createdOn\": \"2022-05-29 16:33:06.842473\",\n    \"mdText\": \"## On coordinating intrapersonal skill levels\\n\\nA while ago I wrote that software is different from poker in that it's more often correct to get some mileage out of worse-performing versions of yourself (it's often best to quit a poker game when you're not playing well, but there's productive work you can do as a fuzzy programmer). \\n\\nJudging from my correspondence, many people disagree with this. A few thoughts:\\n\\n1. There's a distinctive skill to making progress when you're on your B- or C-game, programming-wise. This is a great time to write tests, clean up some of the easy / annoying TODOs, write scripts to do checks on data, and so on. And if some code is impenetrable when I'm tired, that's a good sign it's not clear enough *simpliciter*. It's probably the wrong time to design an interface or do really hard architectural work, but there's a lot that can get done.\\n\\n1. Small commits are a good idea generally. I rely on them even more when I know I'm not at peak performance.\\n\\n1. Recently Dan Luu [has offered some similar thoughts](https://twitter.com/danluu/status/1524068642538672130). They're characteristically excellent. (And I hope he feels well soon.)\\n\\n1. The value of learning tooling is often described in terms of raising peak performancer. Its benefits in raising *mediocre* performance might be understated. Writing tests confidently, rolling back changes, and so on--if you do these competently enough to do them when you're on your B-game--help a ton.\\n\"\n  },\n  \"on-trees-and-dimensionality\": {\n    \"title\": \"On trees and dimensionality\",\n    \"createdOn\": \"2022-10-30 14:11:48.422737\",\n    \"mdText\": \"## On trees and dimensionality\\n\\nHere's [a crisp and thorough essay](https://www.robertbeard.info/2022/03/21/subtree-matching.html) from Robert Beard thinking through the problem of finding exact matches for a subtree in a larger tree. Unsurprisingly, you can help yourself by preprocessing the larger tree.\\n\\n(I say \\\"unsurprising\\\" because there are so many graph algorithms that (i) are linear in the size of the graph, so not asymptotically more costly than simply reading the graph; (ii) straightforward to implement; and (iii) extremely informative. Tim Roughgarden calls these \\\"[for-free primitives](https://theory.stanford.edu/~tim/won1samplefinal.pdf),\\\" which is a great way to think about them.)\\n\\nThe striking part (to me) of Robert's discussion is the value of preprocessing the large tree by labeling each node with its height (distance from the nearest leaf). Once you do that, you know that any node with height smaller than the height of the smaller tree cannot be the root of a match. So you can lop off the bottom of the tree from consideration.\\n\\nEven if you're not worried about graph algorithms or interview questions, it's worth keeping in mind that most of a tree is near the bottom (if the tree is balanced or nearly so):\\n\\n1. It's the key to seeing why [a heap can be constructed in linear time](https://stackoverflow.com/questions/9755721/how-can-building-a-heap-be-on-time-complexity);\\n1. It's why one or the other of breadth-first and depth-first search can be much better than the other, even though both take linear time (sometimes solutions are more likely to be found nearer to the start);\\n1. It's why searching a game tree just a little bit farther can take a whole lot longer;\\n1. And I'm pretty sure it helps explain why [A\\\\* search](https://en.wikipedia.org/wiki/A*_search_algorithm) is so powerful in practice.\\n\\nAnd from here it's a short step to more general facts about plane and solid geometry, which I use, on average, more than once a day in the kitchen:\\n\\n1. If carrots *A* and *B* are the same shape, but *A* is twice as long as *B*, it will yield eight times as much food (as long as you peel carefully);\\n1. The cooking time of a meatball or roasted vegetable is extremely sensitive to how big the items are (so don't have much faith in listed cooking times, and if err on the side of making them small if you're in a hurry);\\n1. It's a big mistake to assume that every apple in the fridge is calorically equivalent.\\n\\nSee also the [curse of dimensionality](https://en.wikipedia.org/wiki/Curse_of_dimensionality). This all reminds me of how the Euclidean algorithm is often classified as \\\"elementary,\\\" but roughly once a year I come to believe I've never properly understood it before.\\n\"\n  },\n  \"on-accidentally-starting-a-newsletter\": {\n    \"title\": \"On accidentally starting a newsletter\",\n    \"createdOn\": \"2022-07-02 21:21:57.677562\",\n    \"mdText\": \"## On accidentally starting a newsletter\\n\\n*This was written after I migrated to Ghost. That turned out to have its own problems; I now use [a static site generator I wrote myself](notes-on-writing-a-static-site-generator.html).*\\n\\nI've struggled with my online-writing toolchain. My ideal tools would:\\n\\n1. Make writing and publishing new things easy;\\n1. Help me prevent data loss;\\n1. Make it possible to make natemeyvis.com more than a collection of writings.\\n\\nI have tried WordPress, hand-rolling my own site, and many things in between. Long story short: I tried Ghost and it stuck.\\n\\nIn my hurry to make the default design palatable, though, I didn't notice that I left in a \\\"subscribe\\\" link. And people subscribed. Hello, and thanks! I'm grateful for the chance to write for all of you (and the whole Internet).\\n\\nI plan to keep going here indefinitely, regardless of subscriber count. My views about this, I think, invert a common way of thinking about public writing.\\n\\nPeople tend to say that if an Internet writing project peters out, it's (1) a failure of the project but (2) a consequence of normal, healthy life progress. Both of those seem wrong to me here. First, I don't think that the end of a writing project is intrinsically regrettable. (Most projects are supposed to end!) I worry that valuable work goes unpublished because we don't have better infrastructure (including social infrastructure) for projects longer than an article but shorter than a \\\"forever blog.\\\"\\n\\nBut--and here I'm only talking about myself--I disagree with (2) also. Think of this site as the output of a funnel with various intellectual inputs. The funnel requires various kinds of intellectual effort; time spent refining and writing; and the desire to share the outputs.\\n\\nMany intellectual experiences will not make it out of the funnel. Sometimes essays just don't come together; many thoughts are better left private; and even more thoughts are simply not worth sharing. Yet there is no part of that pipeline that I'd want to be temporary or optional (for me, that is)--the consumption, effort, synthesis, and sharing all seem clearly better to be doing than not doing.\\n\\nSo! I'm here to stay, if all goes well. Like [Ben Thompson](https://www.stratechery.com), I'm thinking about this as a Web site that derivatively has a newsletter, but I'm humbled by the thought of people reading this in any form. As always: if you aren't sure whether to email me, you [probably should](mailto:natemeyvis.gmail.com).\\n\"\n  },\n  \"on-the-death-of-new-music\": {\n    \"title\": \"On the death of new music\",\n    \"createdOn\": \"2022-06-25 21:10:30.377600\",\n    \"mdText\": \"## On the death of new music\\n\\nTed Gioia's [Is Old Music Killing New Music?](https://tedgioia.substack.com/p/is-old-music-killing-new-music) is wonderful. \\n(And Ted Gioia is wonderful, and the newsletter is wonderful.) \\nThe best introduction to the piece is the introduction of the piece itself (it's just a click away!).\\n\\nIts main explicandum (the \\\"death\\\" of new music) is a few facts: in 2021, we collectively listened to more old music and less new music than in 2020, not only in terms of share but in absolute terms.\\n\\nTed expertly analyzes the decline of new music. \\nBut I'm interested in the title question, which he doesn't really answer. \\nIn whatever sense new music is dying, is it old music that's killing it?\\n\\nI'm tempted by this line of reasoning:\\n1. Music benefits a lot from being a focal experience (or at least from being really famous).\\n1. We have fewer focal experiences than we used to. It's harder for art to get really famous.\\n1. So you'd expect new music to get less popular.\\n1. But old things' focality doesn't go away (at least not quickly), and neither does the human desire to enjoy music that changes the world (or, at least, music that is A Big Thing).\\n1. So new music gets a bit less popular, and old music steps in to fill the void.\\n\\nMeanwhile, the difficulty of making a big cultural impact with music changes how it is supplied ([here](https://marginalrevolution.com/marginalrevolution/2022/01/a-simple-theory-of-culture.html) are some brief thoughts from Tyler Cowen on that subject).\\n\\nThere are, over time, fewer of us who lived through a certain kind of mass culture. \\nIt can feel gauche to say that one thing you want from music, at least sometimes, is the feeling that many millions of other people have also been moved by it. \\nBut a lot of us do want that. \\nOne often hears about \\\"fragmentation,\\\" algorithmic pigeonholing, and so on: mass culture is turning to shards. \\nIn analyzing the precise shapes of the shards, we can miss the simple fact that the former whole is gone.\\n\"\n  },\n  \"reading-notes-talent\": {\n    \"title\": \"Reading notes: Talent\",\n    \"createdOn\": \"2022-06-03 10:18:11.219592\",\n    \"mdText\": \"## Reading notes: Talent\\n\\nEven more than usual, this is a set of reflections and not a comprehensive review. (Although I've made a point of not reading other reviews before writing mine, I imagine it's well- and thoroughly reviewed elsewhere.)\\n\\n1. Like Tyler's books generally, this one is stylistically a little ragged--in good ways. It's pleasantly straightforward, and always reminding you that this is primarily a record of things Tyler wants to communicate and only secondarily a literary artifact. Good writing from academics often (not always!) has this feature: the reader is constantly, subtly reminded that the real project is accumulation of human capital in the writer, and that the articles and books are all downstream of that. In a book about talent, I find it to be a subtle, constant reminder of what the authors have done to cultivate their own talent.\\n1. Reading this book is strenuous and emotionally challenging--again, in a good way. How do *I* stack up? What could I be doing to cultivate talent better? It's a book about the assessment of talent and not, directly, its cultivation, but the two subjects are too closely linked for the active reader not to be considering both on every page. An important skill in reading this book properly is not letting your self-judgments and development plans distract you from the lessons about finding and cultivating talent.\\n1. The Groucho Marx effect is important: very often you need to be asking why the person wants your company. This is another way into seeing the value of being distinctive and focusing on comparative advantage as a writer. Suppose someone writes to me (I like it when this happens!) about a piece I wrote. Why were they reading, and why are they writing to, *me* instead of anyone else in the world? If you aren't doing something distinctive, the answer might not be flattering.\\n1. I've seen a lot of companies handle Groucho Marx reasoning badly specifically in software. The market for programmers is still very hot (yes, even now), and I have seen many American companies deal badly with the reality that just about anyone they can hire is someone who cannot get one of the *X* highest-tier programming jobs in America. This tends to be exacerbated by the facts that (i) the absolute compensation they are offering is still quite high and (ii) fully facing this reality tends not to reflect well on the interviewer, either. Hiring programmers is *all about* making necessary tradeoffs. There are certainly teams of \\\"the *X*+1th-best-available\\\" programmers working at very high levels and happily producing output as efficiently as teams from the most prestigious firms. But (I conjecture) this tends to be a story of managing, deploying, and retaining talent rather than finding eight programmers who all hate remote work and/or don't know that Google is hiring and prefer your firm to every other local firm.\\n1. Relatedly, for a lot of companies, I suspect that a big part of the search for software engineering talent is figuring out how to do things without using software engineers.\\n1. I don't remember any discussion of laws governing interviews in the book. I don't think the authors recommend anything illegal, but it's easy to imagine an HR department wincing at it. The gap between the Cowen/Gross picture of talent search and the reality of job interviews might have more to do with regulatory mindsets than they discuss (though I'm sure they're aware of this).\\n1. There are a lot of programming jobs where what the authors call a \\\"multiplicative model\\\" is probably correct. Consider (i) implementation accuracy, (ii) implementation efficiency, (iii) dependency management, (iv) persistence management, (v) debugging more straightforwardly logical errors, (vi) debugging data- and persistence-related errors, (vii) documentation, (viii) API construction, (ix) migration management, and (x) team communication. Many software jobs require at least 8 of these. Some require all 10. They're somewhat correlated, but less than many people think.\\n1. The discussion of cultivating talent is excellent, and something I spent the first half of the book itching to hear about. There's much more to say about this at the organizational level. Cowen and Gross discuss at some length (i) identifying talent generally, (ii) identifying talent that fits a specific need, and (iii) making organizational room for specific kinds of underappreciated talent. For human capital that grows exponentially, however (and that's the case the authors want you to shoot for), a lot of the person's ultimate output will reflect their growth *after they join you*. (Whether or not we're talking about hiring for a job or other kinds of talent search.) So there's a lot to be said about figuring out what kinds of talent you're best at nurturing.\\n\"\n  },\n  \"books-i-like-more-than-other-people-do\": {\n    \"title\": \"Books I like more than other people do\",\n    \"createdOn\": \"2022-05-29 16:33:06.843519\",\n    \"mdText\": \"## Books I like more than other people do\\nIf you take my 150 favorite books and sort them by Goodreads score, lowest to highest, here's what you get:\\n\\n1. *The Dog*, Joseph O'Neill (3.15 / 5 on Goodreads)\\n1. *The Great Fire*, Shirley Hazzard (3.45)\\n1. *A Portrait of the Artist as a Young Man*, James Joyce (3.62)\\n1. *The Biggest Game in Town*, Al Alvarez (3.71)\\n1. *Freedom*, Jonathan Franzen (3.76)\\n1. *Walden*, Henry David Thoreau (3.77)\\n1. *My \\u00c1ntonia*, Willa Cather (3.81)\\n1. *Play it As it Lays*, Joan Didion (3.88)\\n\\n(Goodreads scores as of late summer 2021.)\\n\\nAgain, these are not listed in order of my preference: they were eligible only in virtue of meeting the top-100 criterion. \\n\\nIf it's important to figure out your intellectual comparative advantage, exercises like this might be more valuable than they seem. It looks like I value sincerity more than the average reader. (But the simpler explanation might be that I like a lot of the books that people resent having been assigned.)\\n\\nNate Silver [once noted that](https://conversationswithtyler.com/episodes/nate-silver/):\\n\\n> like, every book on Amazon, in the long run, gravitates toward having four stars. A lot of 9/11 conspiracy books are rated pretty well on Amazon, because only the conspiracists bother to read them.\\n> Whereas, Othello or Macbeth or something, everyone reads, a lot of kids have to read it for homework when they don\\u2019t want to, necessarily, so they\\u2019ll leave a bad review there, potentially.\\n\\nThis gives a good conjecture for why the classics are on this list. And it's easy enough to see why a lot of people would hate *The Dog*. The most confusing entry here is *The Great Fire*. I remember reading lukewarm reviews, but I'd never have thought it would score lower than Joyce (often assigned, unfamiliar style) and Franzen (obvious).\\n\"\n  },\n  \"2022-favorites\": {\n    \"title\": \"2022 favorites to date\",\n    \"createdOn\": \"2022-05-29 16:33:06.844850\",\n    \"mdText\": \"## 2022 favorites to date\\n*Last updated 2022-12-05*\\n\\nThis is stuff I consumed in 2022, not necessarily stuff released in 2022.\\n#### Books\\n1. Mrs. Dalloway, Virginia Woolf\\n1. [The Remains of the Day](reading-notes-the-remains-of-the-day.html), Kazuo Ishiguro\\n1. [Lonesome Dove](reading-notes-lonesome-dove.html), Larry McMurtry\\n1. [The End of Solitude](reading-notes-the-end-of-solitude.html), William Deresiewicz\\n1. [Talent](reading-notes-talent.html), Tyler Cowen and Daniel Gross\\n1. [How to Change](reading-notes-how-to-change.html), Katy Milkman\\n1. The Fifties, David Halberstam\\n1. [Crossroads](reading-notes-crossroads.html), Jonathan Franzen\\n1. [From Front Porch to Back Seat](reading-notes-from-front-porch-to-back-seat.html), Beth Bailey\\n1. [A Widow for One Year](reading-notes-a-widow-for-one-year.html), John Irving\\n1. [The Last Days of Roger Federer](reading-notes-the-last-days-of-roger-federer.html), Geoff Dyer\\n1. [Of Boys and Men](reading-notes-of-boys-and-men.html), Richard Reeves\\n1. [Super-Infinite](reading-notes-super-infinite.html): The Transformations of John Donne, Katherine Rundell\\n1. [The Three-Body Problem](reading-notes-the-three-body-problem.html), Cixin Liu\\n1. The Nineties, Chuck Klosterman\\n1. The Tim Tebow CFL Chronicles, Jon Bois\\n1. [The Score Takes Care of Itself](reading-notes-the-score-takes-care-of-itself.html), Bill Walsh et al.\\n\\n#### Audiobooks\\n1. [The Pragmatic Programmer](https://www.amazon.com/Pragmatic-Programmer-Anniversary-Journey-Mastery-dp-B0833FBNHV/dp/B0833FBNHV/), Thomas & Hunt (narr. Katarina)\\n1. Software Engineering at Google, C. Titus Winters et al.\\n1. A Way With Words II: Approaches to Literature, Michael D.C. Drout\\n\\n#### Podcast / YouTube episodes\\n1. [UChicago Aims of Education 2022](https://www.youtube.com/watch?v=PwlONu13GoQ), Agnes Callard\\n1. [Two products that cannot be equal](https://www.youtube.com/watch?v=NmEVwJ_lJ1A), Timothy Gowers\\n1. [How to score 10 runs in the first inning and lose](https://www.youtube.com/watch?v=VfFn4NqQr_U)\\n1. [Roland Fryer on Educational Reform](https://www.econtalk.org/roland-fryer-on-educational-reform/), EconTalk\\n1. Doug Polk Podcast: Poker Pro to Full-Time Trading (with Jason Strasser)\\n1. Reconcilable Differences #179: I Believe in the System... Kind Of\\n1. The Morning Shakeout: Kate Grace\\n1. Causality 16: Tenerife\\n1. [Remembering Michael K. Williams](https://www.wtfpod.com/podcast/remembering-michael-k-williams), WTF with Marc Maron\\n1. Indie Hackers (various episodes)\\n1. [An Interview With Daniel Gross and Nat Friedman About the Democratization of AI](https://stratechery.com/2022/an-interview-with-daniel-gross-and-nat-friedman-about-the-democratization-of-ai/), Stratechery\\n1. Solving Wordle using Information Theory, 3Blue1Brown\\n1. Sebastian Mallaby on Venture Capital (Conversations with Tyler E143)\\n1. Lecture 3: Robert Frost (Modern Poetry, Langdon Hammer)\\n1. Living in an Internet Age (Meditations with Zohar S1E1)\\n1. Tips to be a better problem solver, 3Blue1Brown\\n1. Reconcilable Differences #173: The Chicken Project\\n1. 'See Me After Class,' with Jason Snell (The Talk Show E337)\\n1. The Moment with Brian Koppelman: Gillian Jacobs\\n1. Minimum Viable Continuous Delivery, Coding Blocks\\n1. The Tim Ferriss Show: Mark Zuckerberg\\n1. Under the Radar #241: Farewell, Feed Wrangler\\n1. The Tim Ferriss Show: Cal Newport\\n\\n#### Blog posts / articles\\n1. [Art is for Seeing Evil](https://thepointmag.com/examined-life/art-is-for-seeing-evil/), Agnes Callard\\n1. [A Simple Theory of Culture](https://marginalrevolution.com/marginalrevolution/2022/01/a-simple-theory-of-culture.html), Marginal Revolution\\n1. [Cocktail party ideas](https://danluu.com/cocktail-ideas/), Dan Luu\\n1. [On Not Drinking the Kool-Aid](https://salmagundi.skidmore.edu/articles/434-on-not-drinking-the-kool-aid), William Deresiewicz\\n1. [On the Bobos](https://salmagundi.skidmore.edu/articles/379-on-the-bobos), William Deresiewicz\\n1. [Covid 6/30/22: Vaccine Update Update](https://thezvi.substack.com/p/covid-63022-vaccine-update-update), Zvi Mowshowitz\\n1. [Why did Comedy Die?](https://kvetch.substack.com/p/why-did-comedy-die), Misha Saul\\n1. [Context is that which is scarce](https://marginalrevolution.com/marginalrevolution/2022/02/context-is-that-which-is-scarce-2.html), Marginal Revolution\\n1. [Things You're Allowed To Do](https://milan.cvitkovic.net/writing/things_youre_allowed_to_do/), Milan Cvitkovic\\n1. [Culture Shock](https://siddhesh.substack.com/p/culture-shock), Obvious Bicycle\\n1. [Digital Advertising in 2022](https://stratechery.com/2022/digital-advertising-in-2022/), Stratechery\\n1. [Is Old Music Killing New Music?](https://www.theatlantic.com/ideas/archive/2022/01/old-music-killing-new-music/621339/), Ted Gioia\\n1. [Data and Definitions](https://stratechery.com/2022/data-and-definitions/), Stratechery\\n1. [On the use of a life](https://www.daemonology.net/blog/2020-09-20-On-the-use-of-a-life.html), Colin Percival\\n1. [Academic Publishing and the Death Instinct](https://tedgioia.substack.com/p/academic-publishing-and-the-death), Ted Gioia\\n1. [Impressions of Every US State](https://siddhesh.substack.com/p/every-us-state), Obvious Bicycle\\n1. [Instilling Novel Thought Patterns and Making Your Long-Term Memory Accountable with Anki](https://guzey.com/things/software/anki/), Alexey Guzey\\n\\n#### Operas about Richard Nixon\\n1. Nixon in China, John Adams\\n\"\n  },\n  \"notes-on-tyler-cowen-on-relearning-the-internet\": {\n    \"title\": \"Notes on Tyler Cowen on relearning the Internet\",\n    \"createdOn\": \"2022-10-26 05:51:08.740051\",\n    \"mdText\": \"## Notes on Tyler Cowen on relearning the Internet\\n\\nTyler Cowen [has a new column out](https://www.bloomberg.com/opinion/articles/2022-10-25/ai-will-require-you-to-relearn-how-to-use-the-internet) about \\\"relearning how to use the Internet.\\\" As usual, the column is worth reading. Here are some reactions. (As always, I'm speaking only for myself.)\\n\\nFirst, consider Tyler's description of a possible future Twitter: \\\"Less than two years from now, maybe I will speak into a computer, outline my topics of interest, and somebody's version of AI will spit back to me a kind of Twitter remix, in a readable format and tailored to my needs.\\\" This is, structurally, very close to today's new-user flow at Twitter! You don't *speak* the topics, and some people don't find the result so readable, but I'd say that this description literally fits many people's interactions with Twitter *today*.\\n\\nAlternative ways to read this prediction, then, are (i) as a commentary on what *current* optimal use of Twitter looks like (a lot of deliberate user modification) and (ii) as a prediction that Twitter's AI will get *better*, not that it will change so fundamentally.\\n\\nSecond, I worry that Tyler is sometimes characterizing non-AI obstacles as AI obstacles. Some of his speculations involve aggregating search results across services (\\\"the current aggregators will themselves be aggregated and organized\\\") and changing the user's experience with existing services (\\\"you won't use Google, you will just ask your question to an AI and receive an answer\\\"). Here I'd note that:\\n\\n1. The changes Tyler imagines do not rest on improvements to *AI* as much as changes to UX;\\n1. Google, Amazon, and others are already working very hard to let you \\\"just ask your question to [any number of devices] and receive an answer\\\"--as a user, I think that in some cases these already work quite well;\\n1. One could imagine different or better results from combining current companies' responses to the same query, but combining these is more of a logistical and political project than an \\\"AI\\\" one;\\n\\nMore evidence for these is that many companies have already tried to build smart aggregation services on top of existing search and storage services. I am not an expert here, but I don't think that what has kept those new products from succeeding is that the meta-level AI wasn't good enough. Rather, the services resisted integration, the user experience wasn't good enough, or some single underlying component was so good that it rendered the others superfluous.\\n\\nRelatedly, some of Tyler's speculations seem to have more to do with [single-result search products](https://www.thediff.co/p/the-rise-of-single-result-search), as Byrne Hobart wrote up recently (it's a free article). This feature, returning one result instead of many, characterizes some of Tyler's central examples: two of these are using Google Maps instead of typing a query for directions into the search box and getting answers from a voice-activated question-and-answer service. Better AI doubtless makes single-result interfaces more practical. Still, returning one result instead of many, and returning it in a particularly actionable form, is fundamentally a change in the interface as opposed to a replacement of something else with AI.\\n\\nIt's also worth considering the psychological barriers to using the sorts of services Tyler describes. Consider a Google search result that includes helpful notes about Google Drive documents, your email, and various other Google services. This is, in many ways, the sort of ur-level AI-driven experience Tyler imagines. It already exists! Many people find these results unsettling or confusing. Tyler seems implicitly to believe that people will accept these new AI-driven, aggregated services. I don't disagree, but I don't think it's obvious that they will. Here as elsewhere, the changes Tyler imagines are in some ways already here. In some cases they are not really AI changes at all, or at least the quality of the AI is not what is holding them back.\\n\"\n  },\n  \"podcasting-faq\": {\n    \"title\": \"Podcasting FAQ\",\n    \"createdOn\": \"2022-05-29 16:33:06.846476\",\n    \"mdText\": \"## Podcasting FAQ\\n**Q**. How's my idea for a podcast?\\n\\nIf you're asking, it's probably too specific. Podcasts are unified, primarily, by the personalities of their hosts, not by specific subject matter. (I think I'm stealing that observation from somewhere, but I can't remember where; sorry!) When you narrow your explicit domain, the negative effects of constraining your possible topics hurt you more than the specificity helps you.\\n\\n**Q**. So, should I do the podcast?\\n\\nSure! Podcasting is rewarding and there's a lot of unexplored space, in terms of both domain and structure. And you don't need a lot of equipment.\\n\\n**Q**. What equipment should I use?\\n\\nI use a Yeti Blue happily and have heard it recommended by knowledgeable people. But I am not an audio guy, so defer to others' recommendations if you have them.\\n\\nI record interviews over Skype, use the native Skype call recording, and have a backup recorder running. There is probably a better way, but this works for me.\\n\\n**Q**. Wait, what do you mean \\\"there's a lot of unexplored space\\\"?\\n\\nPeople say that podcasting is hyper-competitive and that we're past the time when it was good to get into podcasting, but I don't hear good arguments for those claims. So, for example, people talk about \\\"longform\\\" podcasting, but we haven't seen as much real structural innovation as you would expect in a mature field.\\n\\nI believe [Ben Thompson](https://stratechery.com/) made the point that when podcasting is mature, we'll see ads for something other than mattresses and Squarespace (as usual, he was saying something much more informed and nuanced than I can remember and express in a sentence).\\n\\nAnd if you don't believe me, believe Patrick Collison and Tim Ferriss, who agreed on roughly this view [here](https://tim.blog/2018/12/24/the-tim-ferriss-show-patrick-collison/) (Collison: \\\"People keep feeling that spaces are too late when, in fact, they're not only not too late but in the first 10 percent\\\").\\n\\n**Q**. Is it hard to keep finding ideas and guests?\\n\\nNah. I can't think of any podcaster who has had a hard time keeping a show going for content reasons, except those who painted themselves in a corner by defining their shows too narrowly. After eight years of Thinking Poker, I'm much closer to thinking \\\"we barely even got started exploring that world\\\" than \\\"we were scraping the bottom of the barrel.\\\"\\n\\nI never would have guessed how high the conversion rate is when you ask people to come on a podcast. (When in doubt, send the email!)\\n\\n**Q**. How do you stay ahead of your competition?\\n\\n1. I never thought of other poker podcasts as \\\"competition.\\\" I actually suspect that poker podcasts are more complements than substitutes, and from talking to listeners I strongly suspect that, of the many reasons people have for not listening to Thinking Poker, \\\"my scarce podcast-listening time is consumed by other poker podcasts\\\" is quite rare.\\n1. We (or at least I) started the show because something was missing in poker media. We were always doing our own thing, so that (i) I didn't much care what \\\"competitors\\\" were doing and (ii) I didn't know what would even count as a \\\"competitor.\\\"\\n1. Just keep showing up.\\n\"\n  },\n  \"on-learning-vim\": {\n    \"title\": \"On learning Vim\",\n    \"createdOn\": \"2022-05-29 16:33:06.848060\",\n    \"mdText\": \"## On learning Vim\\n\\n[I use Vim](on-editing-text.html). I like Vim. But for all that's written about learning Vim, most of it is not useful.\\n\\n### Suggestions on learning Vim\\n\\n1. Do not put painful restrictions on yourself or shame yourself for using the mouse. Learn enough to get going, and when you find yourself trying to do a certain thing over and over, look up how to do it. (I think Yehuda Katz [got this basically right](https://yehudakatz.com/2010/07/29/everyone-who-tried-to-convince-me-to-use-vim-was-wrong/).)\\n1. `vimtutor` is great for learning enough to get going.\\n1. Installing a bunch of plugins is often a trap. This is especially true at the beginning, when it's more likely that the thing you're trying to accomplish is doable with vanilla Vim. Dependencies are terrible, [even or perhaps especially in contexts like this](on-dependencies-in-small-projects.html). Avoid them.\\n1. Vim is *huge*. It has more features than you think it has. Its speed and lack of a persistent menu add to this illusion. This means, among other things, that different users grow into using different subsets of the features, and come to find them fundamental. So: ignore most claims about which features of Vim are the fundamental ones.\\n1. Vim doesn't have a persistent menu, but its `:help` documentation is wonderful.\\n\\n### A note on human progress\\n\\nMuch of the best stuff in computing comes out of small communities characterized by strongly held core beliefs, cultures of learning, and strong adherence to principle. Many could be described as \\\"cult-adjacent.\\\" (The domain-driven design community has always struck me this way.) It's tricky to use artifacts from these communities, whether they be pieces of software or mental models, effectively. This is not the only case where the thing is worth learning but the dominant explanations for *how* and *why* to learn it are likely to mislead.\\n\"\n  },\n  \"notes-on-the-garrett-adelstein---robbi-jade-lew-hand\": {\n    \"title\": \"Notes on the Garrett Adelstein - Robbi Jade Lew hand\",\n    \"createdOn\": \"2022-10-02 15:01:03.274564\",\n    \"mdText\": \"## Notes on the Garrett Adelstein - Robbi Jade Lew hand\\n\\n1. I've been saying for over a decade that poker cheating is more prevalent than most poker players say it is. So my priors for claims of the form \\\"Is X cheating here?\\\" are higher than most people's.\\n1. Most of the not-cheating explanations of Lew's play don't address just *how* inconsistent with reasonable play Lew's hand is. There are many amateur archetypes: good amateur, try-harding amateur, legitimately good amateur, very casual amateur, drunk / drugged amateur, amateur hitting a breaking point against a perceived bully, and so on. Lew's turn play is not consistent with any of those. Different people play differently, and extremely unusual play is not proof of anything, but (again) it is often being mischaracterized.\\n1. Specifically, many commentators are missing the fact that Adelstein's shove was for over $100k, which was roughly twice the pot. Both as a matter of fact as as a matter of what various player types would think, this just makes it very unlikely that jack-high nothing would find a reason to call.\\n1. Relatedly, the fact that Lew was up over two previous streams is more important evidence than most analyses recognize. That is a *very* small sample, but it's a lot harder for bad players to put up those results than good ones. Suppose for simplicity that there are only two possibilities: Lew is a very competent amateur or a basically incompetent amateur. I'd guess that these results are about 2 to 4 times as likely for the former than the latter. If I were going to make a more serious study of this situation, I'd work to improve this estimate.\\n1. Less concretely, I am with Doug Polk in thinking that a lot of the footage of Lew's tanking looks like \\\"fake tanking\\\" or something more like stalling. (More than anything it reminds me of people stalling in tournaments.)\\n1. Again less concretely: the table talk and giving the money back seem more likely given scenarios where cheating is involved than given honest scenarios. I have literally never seen someone give money back in anything like this situation.\\n1. This reminds me of [POTRIPPER, the Absolute Poker superuser](https://www.reddit.com/r/poker/comments/87w8oy/potripper_the_infamous_superuser/) who (if memory serves) has roughly similar-looking hands.\\n\\nSo, cheating appears to be likely *given the evidence I know of and my priors*. I'd be grateful for information about the situation I might not know or be misjudging.\\n\"\n  },\n  \"lawnmower\": {\n    \"title\": \"The Lawnmower Essay and the Problems of Philosophy\",\n    \"createdOn\": \"2022-05-29 16:33:06.849335\",\n    \"mdText\": \"## The Lawnmower Essay and the Problems of Philosophy\\n\\nJim Pryor\\u2019s \\\"Guidelines on Writing a Philosophy Paper\\\" is the most influential course handout I know of in contemporary academic philosophy. The magnitude of its influence is not easily measured. But my first- and second-hand observation; the essay\\u2019s many glowing reviews; and the linked page\\u2019s excellent SEO combine to suggest that it has a status not unlike that of Plato\\u2019s *Apology* in many quarters: it has been received as a sort of holy text or perfect enunciation of principle. I suspect, however, that it is also like the *Apology* in that professional philosophers spend more time telling undergrads to read it than they do studying its details. Here I\\u2019ll examine some of those details and conclude that the professional obsession with \\\"Guidelines\\\" is unhealthy, or at least reflects something unhealthy about the discipline.\\n\\n\\\"Guidelines\\\" is doing a few things at once: it sets out some of Dr. Pryor\\u2019s course policies; it gives advice about the mechanics of writing; and it describes successful pieces of writing in his class. Another way of saying that last thing is: \\\"Guidelines\\\" describes a particular subgenre of a literary form. I\\u2019m going to call that form, the one Pryor is requiring the reader to use in completing course assignments, the Lawnmower Essay.\\n\\nThe Lawnmower Essay has never been described more famously or cleverly than in \\\"Guidelines,\\\" but don\\u2019t conclude that it\\u2019s Pryor- or NYU-specific. It is even more ubiquitous in analytic philosophy classrooms than the five-paragraph essay is in high-school English classes. It is a variant of the argumentative essay in which clarity, explicitness, and exposure of logical structure are dialed as high as possible. Indeed, they are dialed so high that practitioners often ignore, miss, or renounce the Lawnmower Essay\\u2019s connection to the literary form of the essay. (Pryor *never once* uses the word \\\"essay\\\" in the document.)\\n\\nI mentioned before that the Lawnmower Essay demands clarity, explicitness, and exposure of logical structure; here\\u2019s how meeting those demands can play out. In ordinary life you might write me a note: \\\"Beans need to soak overnight before they\\u2019re within an hour\\u2019s cooking of being edible, so you should soak those beans.\\\" If I\\u2019m a fair reader and a competent cook, I\\u2019ll understand what you said, but note that you\\u2019ve suppressed some premises in this note to me. You implied, but did not say, that we plan to eat those beans tomorrow and are in a position to cook them today. You made some questions about the beans in question--e.g., that they\\u2019re not lentils (which cook up just fine without soaking); that they\\u2019re not canned (in which case they\\u2019re already relevantly \\\"soaked,\\\" though good luck defining that term with Myhrvoldian precision); that you have no reason to believe they\\u2019ll resist soaking (by having too much wax, say); that by \\\"cook\\\" you don\\u2019t mean \\\"pressure-cook\\\" or some other method powerful enough to render pre-soaking unnecessary; and so on. (How long is \\\"overnight,\\\" anyway? Do we need to make sure they\\u2019re submerged, or can we just let them float in a pot of water?)\\n\\nContemporary analytic philosophers tend to be addressing questions like \\\"How much of my income must I give to charity?\\\" and \\\"What exactly does the name \\u2018Banquo\\u2019 refer to?,\\\" not \\\"Should I soak these beans tonight?.\\\" But the process above--expand, clarify, refine, expand, clarify, refine, on and on--is what the Lawnmower Essay is about. Not *all of* what it\\u2019s about: you might also present examples that are intended to convince the reader to accept one premise rather than another; you might argue that certain premises are inconsistent; and so on. Those operations are natural extensions of the fundamental work of exposing the logical structure of an argument, and are continuous with it. Our little bean soup inference, after all this work is done, would be likely to occupy 1000 or 2000 words: that\\u2019s impractical for a note left on the kitchen table, but it\\u2019s much more thorough.\\n\\nThat sort of work is what Pryor, and many other modern philosophy instructors, are looking for in a philosophy classroom. Such work is what philosophy, as they teach it, *is*. What would seem pedantic or obnoxious or unhelpful in the case of bean stew--though I do tend to want a bit more intellectual rigor in the recipes I read--is much more helpful in the subjects academic philosophy deals with. And again, helpful or not, in Dr. Pryor\\u2019s class it is mandatory. You haven\\u2019t done your work, according to \\\"Guidelines,\\\" until: you are arguing from premises that any interlocutor would agree to; you have not missed the opportunity to clarify what might need clarifying; you have given examples where examples would help; and you have laid out in plain black ink every premise and inference you need to make your argument airtight. Hence my calling it a \\\"Lawnmower Essay:\\\" you can\\u2019t miss a spot, it won\\u2019t turn out right unless you go in perfect order, and attempts at elegant flourish figure to get you nothing but blemishes. If you\\u2019re not going slow, or if an observer would have any trouble figuring out what you\\u2019re doing, you\\u2019re not doing it right.\\n\\nThat's not disparagement. I am a Lawnmower Essayist. I\\u2019m proud of the semesters I spent grading Lawnmower Essays and of the intellectual muscles I developed writing my own. The form develops the epistemic virtues of rigor and straightforwardness. Its strictness makes you develop new skills: when you can\\u2019t use elision, metaphor, or most of your vocabulary, you develop new capacities of expression. I\\u2019m grateful to have written so many Lawnmower Essays, just as I\\u2019m grateful that forms of \\\"to be\\\" were forbidden in my ninth-grade English assignments and that my undergrad poetry workshop put us through all the ordinary paces and then some (we did scansion, we wrote sonnets and sonnets and more sonnets, we wrote villanelles and sestinas, and then we were presented with new and tougher rules). Our public discourse would be healthier and more honest if we replaced some shrieking op-eds with Lawnmower Essays. It\\u2019s not just that doing the chores is good for you; there *really are* lawns out there that need mowing.\\n\\nBut, again, \\\"Guidelines\\\" is not just a record of Dr. Pryor\\u2019s course policies. It is also a statement of *what it is to do philosophy*. Sometimes Pryor speaks of \\\"this course,\\\" of his teaching assistants, and of what\\u2019s done \\\"here,\\\" but more often he simply talks about what philosophy is and what we must do to meet its norms. And the document would not be so widely reproduced, distributed, assigned, and adored if it were not taken as a description of philosophy itself.\\n\\nIn its first role, that of recording course policy, I have no fundamental beef with \\\"Guidelines,\\\" and not just because it\\u2019s not my place to tell Dr. Pryor how to run his courses. It\\u2019s because, again, mowing lawns is good for you, and the Lawnmower Essay is a perfectly good form to constrain students with, at least sometimes. I do have some non-fundamental beefs here, though; I\\u2019ll mention two.\\n\\nFirst, Pryor says that we should \\\"start from common assumptions [your audience would] agree to,\\\" and we later learn that this audience should be imagined as maximally hostile. But is this really possible? Isn\\u2019t it more accurate to say that we should make our premises as plausible as possible, and fully explicit? I think this is just loose phrasing on Pryor\\u2019s part, especially since his examples of model writing tend to involve premises being made explicit rather than completely obvious truths being enunciated. It\\u2019s an unfortunate slip, however, because there is such a great difference between \\\"start from something your opponent must agree with\\\" and \\\"start from a reasonable place while making it fully clear that\\u2019s where you\\u2019re starting from.\\\" It\\u2019s the difference between starting at the edge of the lawn and starting at the edge of the *world*.\\n\\nSecond, because Pryor is telling the reader to adhere not just to the formal and rhetorical strictures of the essay but to those of the Lawnmower Essay, an element of his FAQ--\\\"Can you write your paper as a dialogue or story?\\\"--comes off as a bit disingenuous. (The answer is, unsurprisingly, a polite \\\"no.\\\") By presenting dialogues and stories as the relevant alternatives to the form he\\u2019s laying out, he implies that the form in question is The Essay, not The Lawnmower Essay, to which the most relevant alternatives are not dialogues and stories, but other kinds of essays.[1] There plainly are many other such kinds: the essay is the form of Montaigne and Emerson and on and on, but an Emersonian essay will not satisfy Dr. Pryor\\u2019s TA, who is expecting a Lawnmower Essay. It would be more honest, or at least more informative, to openly acknowledge that the document describes a subgenre, which certain kinds of professional philosophers employ disproportionately (though not at all exclusively), and that Dr. Pryor expects his prompts to be answered in that subgenre--not with a dialogue or story, but also not with any other kind of essay.\\n\\nAgain, though, \\\"Guidelines\\\" is a very fine course handout, and these are small complaints with it in that capacity. They point the way, however, to far more serious complaints with it in the other roles in which it is routinely deployed: the professional manifesto and/or general guide to written argumentation. Here we need to recall that Dr. Pryor recommends that the Lawnmower Essayist imagine and write toward a reader who is \\\"lazy, stupid, and mean.\\\" Quickly glossed: so lazy that you need to explain everything you say, because he won\\u2019t bother to look up or recall anything; so stupid that he needs taking by the hand, inch by logical inch; and so mean that you must relentlessly disambiguate terms he might otherwise maliciously misconstrue, anticipate and parry even unpromising/sophistical objections, and otherwise cover your rhetorical behind from every direction.\\n\\nNote I said \\\"write toward,\\\" not \\\"write for.\\\" You can\\u2019t--nobody can--truly *write for* a reader who so deeply lacks the epistemic virtues necessary for proper reading. We continue to teach reading at the university level because there is, beyond the mechanics of literacy we teach in elementary school, a receptivity to good writing that requires those epistemic virtues. (Educated people sometimes speak of \\\"where they learned to read.\\\" They aren\\u2019t talking about preschool, and they also aren\\u2019t speaking loosely, though they are using a specific sense of the verb.) The audience Pryor has us imagine isn\\u2019t an audience *of readers* at all, and you can\\u2019t write for someone who\\u2019s not a reader any more than you can feed a doll. The best we can do is write *at* them, as boxers work on punching bags or children serve tea to stuffed animals.\\n\\nHere the philosopher might object: those other essayists have goals other than arguing for the truth of propositions and the correctness of explanations. So I\\u2019m wrong to have implied that the Lawnmower Essay is merely one form among many, suitable if one\\u2019s mission is as narrowly truth- / explanation-correctness-directed as the contemporary analytic philosopher\\u2019s. Making everything explicit and disambiguating wherever possible *just are* the intellectual work of clarifying claims and arguments (or so the objection would go); those other kinds of essays use methods that are strictly worse for the purposes of philosophical argument.\\n\\nThis objection doesn\\u2019t work. First, it relies on an controversial definition of philosophy; we (not just the objector and I, but very many of us, very much of the time) notoriously disagree about what philosophy is. Moreover, none of the candidate definitions carves out something the pursuit of which Lawnmower Essays are uniquely suited for. So, for example, if you think that philosophy is just about arguing for truths, or about arguing for truths about less-empirical things: don\\u2019t mathematicians do that too? Why, then, don\\u2019t mathematicians use (analogues of) the Lawnmower Essay, except in problem sets?[2]\\n\\nI think that\\u2019s enough to be done with the objection, but if you aren\\u2019t convinced yet, note that the objection admits of other refutations, too. One set of such refutations begins with the observation that the Lawnmower Essay can be very good for defending oneself rhetorically while still being very poor for communicating truths and correct explanations. Because we write essays (and sonnets, and epics, and ghazals, and jingles, and grocery lists) in order to communicate, essays--even of the most rabidly truth-seeking sort--are thus governed by norms of communication other than the maximization of self-defense. When we put things in logical order, we risk taking them out of rhetorical or epistemic order. If we keep them in rhetorical/epistemic order, and so pass up the chance to put them in logical order, we risk a wagging finger from a lazy, stupid, and/or mean reader. What should we do? If we are students of Dr. Pryor\\u2019s, and acting in that capacity, we should avoid the wagging finger and restore logical order just for the sake of logical order: for the practice of doing it, for proving we know what it is, and for proving that what we\\u2019re saying suits it well. If we\\u2019re acting as writers, though, we should write for actual readers and choose the best rhetorical order. The finger-wagging audience is terroristic and not to be negotiated with. Even if we do give in, they\\u2019ll just ask for more.\\n\\nFinally, the very norms of the Lawnmower Essay that usually lead us away from epistemic sin sometimes lead us into it. Consider, for example, the device of disambiguation: if we use a technical or possibly unfamiliar term, we are told to say exactly what we mean by it, as early as possible in the essay. But what if the term is something like \\\"consciousness\\\" or \\\"reason\\\" or \\\"rule,\\\" where the relevant paraphrase might be more confusing than the term itself? Even worse, what if all available paraphrases distort the term so badly that we end up discussing something neither we nor or readers have any intuitive grasp of or reason to care about? There are regions of lawn so gerrymandered that mowing them accomplishes nothing. The skilled philosopher will not make errors like these, but the best way to avoid them is often to abandon the Lawnmower Essay.\\n\\nTime and human attention are finite and precious. When we spend them by writing, we must remember that there are, at least potentially, readers out there waiting to spend, in turn, their finite, precious reserves on our work. We owe it to them to use the best tool for the job--the best *communicative* tool for the job. Sometimes that\\u2019s the Lawnmower Essay; often it\\u2019s not. Choose wisely.\\n\\n[1] Maybe this isn\\u2019t fair. As we\\u2019ve already noted, Pryor never uses the word \\\"essay\\\" in the document. Perhaps he thinks of The Philosophy Paper as an entirely different form, or as a kind of argument so pure it shouldn\\u2019t be thought of as having any relationship to any literary form. But I don\\u2019t think Pryor has this in mind, because (i) it would render his FAQ even more disingenuous / odd and (ii) I can\\u2019t charitably assume that Dr. Pryor believes that philosophical essays are not really essays.\\n\\n[2] A quick aside. You will sometimes hear philosophers claim that philosophical explanation is like mathematical explanation, with similar norms and techniques. [Do not believe this](https://twitter.com/NateMeyvis/status/1332469115446030341) (and certainly do not take this as permission to submit philosophy papers that obey the argumentative and stylistic norms of mathematical proofs). When you hear this, the speaker is almost always best understood as asserting one of two other claims. Either: (A) that philosophers write the way the speaker imagines mathematicians write, which in turn means: that philosophers write the way philosophers write. To the speaker\\u2019s credit, this claim is true. Or: (B) that philosophy classroom exercises (by which they mean Lawnmower Essays) are conducted the way mathematics exercises (e.g., problem sets) are. This is not tautologically true, nor is it perfectly accurate, but it\\u2019s accurate enough.\\n\"\n  },\n  \"reading-notes-crossroads\": {\n    \"title\": \"Reading notes: Crossroads\",\n    \"createdOn\": \"2022-10-30 13:13:23.453297\",\n    \"mdText\": \"## Reading notes: Crossroads\\n\\n1. _Crossroads_ is set in the '70s, but is only lightly sprinkled with period references. Almost all the diction would fit into any of Franzen's worlds.\\n1. The characters largely sit around wondering whether they're good people; what their badness consists in, if they're bad; and how to find God. This is Franzen as an American Dostoevsky. (Certainly *this* stuff isn't what ties the novel specifically to the '70s.)\\n1. The *manifestations* of those topics, though--good, evil, self-doubt, God--involve: relevations about \\\"social justice\\\" (a phrase that appears three times) and the systematic mistreatment of women by men and of non-whites by whites.\\n1. Those issues are politicized in [the Callard sense](https://www.youtube.com/watch?v=uHCNXHzMRuc): \\\"action and speech in that area must be interpreted against the backdrop of some standing debate.\\\" A 2022 reader could not read a book set in or around 2022 without immediately interpreting a remark like, e.g., \\\"the Crossroads-encouraged inflation of emotional scrapes into ambulance-worthy traumas\\\" in light of contemporary debates.\\n1. Here are two things that distinguish fiction from other forms of communication: First, there's a presumption that things happen for reasons. Those politicized subjects are presumably *necessary* in Franzen's project. Second, one's raw aesthetic reactions matter more than they do in other contexts. There are settings where we can say \\\"I know this is politicized, but let's try to just talk about _X_ here.\\\" A novel is usually not one of them.\\n1. But part of what produces that raw aesthetic reaction--that is, the reaction we have when we see a politicized topic and interpret it against the backdrop of a standing debate--is our understanding of the world in which the topic is being presented. So by setting the book in the '70s, Franzen opens up some of distance between those topics and our current debates.\\n1. Yet those topics remain thoroughly politicized *for us*, despite being less or differently politized *in the world of the book*. It's only *some* distance that gets opened up. How much distance that is depends on many things, surely including the reader.\\n1. The novel exhibits Franzen's full awareness that these issues are politicized and that some episodes in the book, in which characters do things that are presumptively OK in the world of the book, are only that way because the novel is set fifty years ago. In a climactic scene, someone says something like: \\\"This is OK; it's the seventies.\\\" It's hard for the reader not to feel called upon at that moment to compare our world to the novel's.\\n1. I suspect it's wrong to read Franzen either as longing for a world where the old norms applied or as creating distance between our world and the novel's only to give us a perch from which to feel superior. For me, at least, there was room for a fresh and valuable look at various human depravities and struggles...\\n1. ...including the struggles of religious faith, which are different for the characters (as opposed to us) because they're living in a more religious world.\\n\"\n  },\n  \"software-design\": {\n    \"title\": \"Software design\",\n    \"createdOn\": \"2022-05-29 16:33:06.853496\",\n    \"mdText\": \"## Software design\\n\\nOne traditional division of software knowledge-\\u2013into algorithms, data structures, and system design-\\u2013leaves out software design: interfaces, object definition, dependency structure, and so on. So, for example, not *which database to use* but *how to use the database*. Here are some resources on the subject.\\n\\n### To read\\n\\n* Jimmy Koppel's [essay on the three levels of software](https://www.pathsensitive.com/2018/01/the-three-levels-of-software-why-code.html). If true, this has deep consequences for how we think about creating, describing, and testing code.\\n* Here is [Adam Gordon Bell interviewing Jimmy Koppel](https://corecursive.com/036-jimmy-koppel-advanced-software-design/). I loved listening to this, and review it periodically as a way to shake up my thinking and come back focused on more important things.\\n* [A Philosophy of Software Design](https://www.amazon.com/Philosophy-Software-Design-John-Ousterhout-ebook/dp/B07N1XLQ7D/), John Osterhout. This is best paired with [Jimmy Koppel's review](https://www.pathsensitive.com/2018/10/book-review-philosophy-of-software.html). I think Koppel basically has the best of it when they disagree, but even if (if!) there are some basic conceptual mistakes floating around, Osterhout explains too much, too clearly, with too many useful examples, for a serious student to ignore this book.\\n* [Architecture Patterns in Python](https://www.amazon.com/Architecture-Patterns-Python-Domain-Driven-Microservices/dp/1492052205), Percival and Gregory. The authors describe the creation of a full (not quite production-ready, but much more than a toy example) system, pausing to explain repositories, units of work, and much more. I marvel at how much widely applicable information they fit into a medium-length book.\\n* [Working Effectively with Legacy Code](https://www.amazon.com/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052), Feathers. This is my single favorite software engineering book. One big reason it's relevant here--despite its being primarily a book about fixing, rather than designing, code--is because it's full of wonderful information about interfaces. (Also dependencies, responsibilities, and much more.)\\n* Jonathan Locke's [Coding: On Software Design Process](https://www.amazon.com/gp/product/B0042X99SA/) is a short, lovely book, roughly half of which is a series of arguments for and about thinking in terms of \\\"micro-architectures.\\\" I'm not completely convinced, but I'm glad to have the notion of a micro-architecture in my toolbox. I'd love it if more programmers wrote this sort of novella-length manifesto.\\n\\n### ...And an exercise:\\nSketch out the dependency graph for some fragment of your code base. Do this at both the \\\"logical level\\\" and the \\\"code level\\\" (as Koppel would put it), and don't conflate the two. Don't dismiss this as an elementary exercise: (i) it's rare to see it actually done (as usual, people rarely \\\"do the reading\\\") and (ii) I've never regretted taking the time to do it. Be careful not to conflate data flow with the direction of a dependency. (Ousterhout warns us against \\\"temporal decomposition,\\\" and I've found both the phrase and the warning useful.)\\n\"\n  },\n  \"an-argument-from-jimmy-koppel\": {\n    \"title\": \"An argument from Jimmy Koppel\",\n    \"createdOn\": \"2022-05-29 16:33:06.855067\",\n    \"mdText\": \"## An argument from Jimmy Koppel\\n\\nJimmy Koppel has, in various places (see [here](https://www.natemeyvis.com/software-design/)), advanced pieces of an argument that is significant enough to deserve an independent reference.\\n\\nLet an *interface* be a specification of what a given bit of software does (and not, e.g., some abstract class appearing in code).\\n\\n#### Premises\\n1. There is a many-to-many relationship between implementations and interfaces.\\n1. What the code *really is* and *really does* is determined (at least in part) by its interface. In Koppel-ese, code has [a logical level](https://www.pathsensitive.com/2018/01/the-three-levels-of-software-why-code.html).\\n\\n#### Conclusions\\n1. Specifying the behavior of an implementation cannot (entirely) specify what the code really is.\\n1. Guaranteeing (e.g., through testing) a set of implementation behaviors cannot guarantee that the code is correct.\\n1. The provable guarantees of the formalization (e.g., through a type system) of an *implementation* of an object do not *ipso facto* extend to *what the implementation represents*. The [stock Koppel example](https://www.pathsensitive.com/2018/01/the-design-of-software-is-thing-apart.html) helps here: suppose you have an object that returns True iff some internal internal field is at least 65. All the formalism in the world won't distinguish between its being an ASCII alphanumeric-character checker and its being a retirement-age checker, and therefore won't verify that it is a correct implementation of (either) an ASCII character checker or a retirement age checker.\\n\\n#### Occasionally useful alternative formulation\\nAll you can test about an implementation is a current, actual set of behaviors. But current, actual sets of behaviors implement many interfaces, in general, because interfaces also include counterfactual behavior (most commonly, behavior under future changes).\\n\\nAnd counterfactual difference matters, because code needs to be *maintained* and should also be *semantically correct*.\\n\\nSo constraining, verifying, and testing implementations in general fails to constrain, verify, and test it *as an implementation of the interface*.\\n\\n*Thanks to [Robert Beard](https://www.robertbeard.info) for helping me clarify this. As always, all mistakes and infelicities are entirely mine.*\\n\"\n  },\n  \"reading-notes-of-boys-and-men\": {\n    \"title\": \"Reading notes: Of Boys and Men\",\n    \"createdOn\": \"2022-10-17 06:29:37.854820\",\n    \"mdText\": \"## Reading notes: Of Boys and Men\\n\\nRecommended.\\n\\n1. It is a book about men, but only a shortsighted reader would miss the lessons about (specifically) Black men, Black *women*, the middle and lower classes generally, and so on. I have long suspected that intersectionality and related concepts would be used by groups concerned with men's interests. This is the first sustained effort I've read in that direction (in book form, at least).\\n1. And this is, in its way, one of the most compelling discussions of income and wealth inequality I've seen. Many of Reeves' arguments can be seen as versions of: \\\"The disproportionate money and power that flows to a small and mostly male group masks big problems *with men*, which are problems *for everyone*.\\\"\\n1. There are many and diverse citations. Evaluating them would be a major project. Reeves certainly presents a lot of reasonable-seeming evidence for his views, but might not always present the strongest evidence *against* those views.\\n1. One particularly interesting body of evidence Reeves collects is that various kinds of interventions help women more than they help men. This has [drawn some blogosophere attention](https://conversableeconomist.com/2022/10/07/why-do-so-many-interventions-help-women-but-not-men/). One explanation here is that non-male groups suffer discrimination that makes certain kinds of interventions particularly effective for them (again, I don't think one can read this book properly without thinking about how much we're doing wrong with respect to *other* groups). I hope more work is done to figure out how robust this phenomenon is and what its causes are.\\n1. Some of Reeves' policy proposals seem interesting: e.g., to work to get men into \\\"HEAL\\\" (health, education, administration, and literacy) jobs. Others seem like political and practical non-starters to such a degree that it's hard even to begin to contemplate their full impact: e.g., to fund an extra year of pre-K for (only) boys so that they can be redshirted. (This is to compensate for the features of male brain development that Reeves argues make boys less well suited to academic success if age is held constant.)\\n1. I expect a lot of low-quality commentary on this book. It's not that long, but [most people won't read it](on-actually-reading-the-book.html).\\n\"\n  },\n  \"zippyflash-is-ready-for-alpha-users\": {\n    \"title\": \"Zippyflash is ready for alpha users\",\n    \"createdOn\": \"2024-12-24 09:42:00.000000\",\n    \"mdText\": \"## Zippyflash is ready for alpha users\\n\\nI am [a longtime user of spaced repetition](https://www.natemeyvis.com/on-using-anki.html), and I built my own spaced repetition system, [Zippyflash](https://www.zippyflash.com). I've used it daily for years now. It is ready for alpha users.\\n\\n#### Who should try Zippyflash?\\n\\nZippyflash is, I hope, the best tool for someone who:\\n\\n1. Is a motivated learner (Zippyflash does not have nags or reminders, though I do plan to build a sensible, non-annoying reminder system);\\n2. Wants to retain the information indefinitely (that's what spaced repetition is for);\\n3. Wants to minimize *effort per unit of learning*, either because they have a fixed corpus they want to learn quickly or because they want to learn a lot of things;\\n\\nSome example uses that Zippyflash would be good for are:\\n\\n1. Studying SAT vocabulary in short daily sessions for the long term;\\n1. Preparing for trivia competitions;\\n1. Learning Hebrew;\\n1. Studying for an AP history exam, the NCLEX nursing exam, or some other exam;\\n1. Learning names or birthdays.\\n\\nSome example uses where Zippyflash can help, but is not ideal, are:\\n\\n1. Learning a language that is well supported by Duolingo (you should probably just use Duolingo);\\n1. Studying a subject that is best learned with video or audio prompts (Zippyflash doesn't support this yet);\\n1. \\\"Cramming\\\" for a test or studying material you don't want to retain for a long time (Zippyflash is optimized for long-term retention).\\n\\n#### What is Zippyflash good and bad at right now?\\n\\nZippyflash's comparative advantages are:\\n\\n1. It helps you create and review flashcards quickly.\\n2. Its scheduling algorithm is good, and (more importantly) it has tools to improve the algorithm over time.\\n3. Relatedly, it is smart about helping you separate reviews of similar flashcards, so that your reviews are more likely to test whether you've committed something to long-term memory.\\n4. The library of pre-madeflashcards is high-quality.\\n5. It is built in a way that will allow me to add stable, high-quality features over time. (You'll have to trust me here.)\\n1. Alpha users can use Zippyflash for free indefinitely.\\n\\nIts comparative disadvantages are:\\n\\n1. It has far fewer features than Anki and similar tools.\\n1. There might be bugs I don't know about (but I use it heavily and rely on it personally and professionally, so I am highly motivated to find and fix these).\\n1. The library of pre-made flashcards is much smaller than the Anki ecosystem's.\\n\\n#### How to try Zippyflash\\n\\nYou can just [go to Zippyflash](https://www.zippyflash.com) and start using it, but you can also [email me](mailto:hello@natemeyvis.com). I'm happy to help you get started; if there's a reasonable chance others will want to study the same thing as you, I'll even make some flashcards for you. Of course, I'll also answer any questions you have.\\n\\n\"\n  },\n  \"on-middlebrow-books\": {\n    \"title\": \"On middlebrow books\",\n    \"createdOn\": \"2022-05-29 16:33:06.856569\",\n    \"mdText\": \"## On middlebrow books\\nWhat should I make of the fact that middlebrow nonfiction tends to be so much more rewarding (for me) than middlebrow fiction?\\n\\nCandidate reactions:\\n\\n1. What distinguishes highbrow from middlebrow offers much greater rewards in fiction than in nonfiction, for intrinsic reasons. Most obviously, the bare transmission of information matters a lot more in nonfiction.\\n1. What distinguishes highbrow from middlebrow offers much greater rewards in fiction than in nonfiction, because of how highbrow nonfiction and fiction are generated. (Should I really read recent journal articles about Abraham Lincoln instead of *Abe*?)\\n1. If you read something wonderful, it's easy to classify it as \\\"middlebrow\\\" if it's fiction but tempting to elevate it to \\\"highbrow\\\" if it's fiction. (If *A Moveable Feast* weren't so wonderful, I'd probably not be tempted to think of it as highbrow.)\\n1. I'm deceived by a short-term trend. (A few years ago I read *The Dog*, *Straight Man*, and *Dear Committee Members* and am very glad I did so.)\\n1. I'm worse at selecting middlebrow fiction.\\n1. The comparative advantage of books is greater for middlebrow nonfiction than for middlebrow fiction (television and Twitter exist!).\\n\\nP.S.: The impetus here is *The Startup Wife*. It tells a basically plausible and engaging story of a business; it's funny; the writing is crisp; and it's well-paced. I devoured it. It's not always easy to make sense of the book's politics, but what matters most for its plot and aesthetic agenda--sexism, gender dynamics, and so on--seemed on point to me. But despite its being the very best middlebrow fiction book I've read in years, I'm only somewhat glad I read it instead of the next thing on my list.\\n\"\n  },\n  \"on-pokers-comparative-advantage\": {\n    \"title\": \"On poker's comparative advantage\",\n    \"createdOn\": \"2022-06-24 15:04:53.675225\",\n    \"mdText\": \"## On poker's comparative advantage\\n\\nJason Strasser gave [a great interview](https://www.youtube.com/watch?v=ObF6w8sNyJo\\\\) recently where he noted that poker players \\u00a0_think_ they outperform non-poker-players because they're fluent in calculating odds, but their comparative advantage is _actually_ in having experienced painful losses.\\n\\nThis phenomenon is more general: I've never known a field where the general wisdom about where that field's intellectual edge is tracked reality. \\n(The exception is maybe pure math, but I'm not qualified to judge.)\\nOutside the context of trading (what Jason was talking about), the comparative advantage of a training in poker is a bit broader. Here's how I see it. Note that this is _not_ \\\"what I learned from poker\\\" but \\\"what I think poker trains distinctively well\\\":\\n\\n1. How to lose, often painfully (Jason's answer).\\n1. How to _see yourself fail_ and, ideally, learn from it (this is different from #1).\\n1. How not to conflate .1%, 1%, and 4% probabilities of things (and similarly for other probabilities).\\n1. How to synthesize different _kinds_ of evidence (\\\"there are eight clubs left in the deck, he called a three-bet before the flop, and he really doesn't want to miss his dinner reservation\\\").\\n1. How to figure out where the value in a situation is really coming from (including how to avoid the [streetlight effect](https://en.wikipedia.org/wiki/Streetlight_effect) of conflating importance with salience or quantifiability).\\n\"\n  },\n  \"on-scarcity-and-regionality\": {\n    \"title\": \"On scarcity and regionality\",\n    \"createdOn\": \"2022-05-29 16:33:06.857605\",\n    \"mdText\": \"## On scarcity and regionality\\n[Tyler Cowen prompts us to ask](https://marginalrevolution.com/marginalrevolution/2022/02/friday-assorted-links-350.html) what scarcity and being \\\"a regional thinker\\\" have to do with each other. Here's a speculative answer.\\n\\nStart with an important puzzle about intellectual comparative advantage:\\n\\n1. It's driven by being *really* good at what you're best at. [Dan Luu](https://danluu.com/learn-what/) argues for this well and draws on examples from Hilbert to judo to video games. Practicing the thing you're fourth-best at is *way* overrated relative to practicing the thing you're best at. Really getting into some reading project [is also underrated](on-actually-reading-the-book.html).\\n\\n1. Yet \\\"multiplicative models\\\" of high output are also often right. Tyler has argued for this in cases like Magnus Carlsen and Elon Musk. I suspect this has something to do with [avoiding zero-output periods](on-productivity.html) or fatal flaws more generally, which (despite being the ostensible aim of so much self-help material) is underdiscussed or at least rarely discussed well. So, practicing the thing you're fourth-best at is *also* way overrated relative to practicing the thing you're *worst* at.\\n\\nIf you don't want to deny either of these, and I don't, it's best to just accept that there's something important about being \\\"T-shaped,\\\" actively sacrificing the middle for some combination of breadth and being as good as possible at what you're best at.\\n\\nHere's [my argument for T-shaped reading plans](on-distributing-reading-time.html). Analogous study in programming also works well for me: e.g., with [katas](http://codekata.com/) related to my strengths and [Anki](on-using-anki.html) cards for concepts I'm weak in. And I remember the toughest poker opponents being ones with the best strengths and no crippling weaknesses.\\n\\nLearning specific things is often analogous. Roughly once a year I think that I never before understood the Euclidean algorithm properly: something about lattice theory, abstract algebra, computational complexity, or whatever else presents itself. It's correct but misleading to say that I'm \\\"finding new connections\\\": rather, the Euclidean algorithm presents itself as a Platonic object needing further illumination from more and more fields and subfields. The \\\"T-shaped\\\" feeling comes from recognizing both the depth of the thing itself and the breadth of its connections to those fields and subfields.\\n\\nAnd now I'm repeating, in a way, [my previous notes on scarcity and context](on-the-scarcity-of-context.html): things have subtle boundaries in high-dimensional spaces. What's intellectually scarce, especially in a world where definitions and facts are easy to retrieve, is the sort of understanding that comes from understanding many presentations of an idea in light of many adjacent disciplines.\\n\\nNow: what does this have to do with regionality? If this is the shape of expertise, and more generally of intellectual distinctiveness, the question is whether regional background has some special connection to where your intellect best approximates this ideal. And there are reasons to think there is in fact such a connection:\\n\\n1. Your regional background is where you get your breadth. You did, after all, have to figure out how to *live* there!\\n1. Your regional background is where you get your depth. After all, compounding growth tends to win, and the areas you've been compounding in the longest are the ones that stretch furthest into your (regional) background.\\n\\nKnausgaard thought for decades about emotional abuse, mass culture, poetry, Naziism, masculinity, and so on. There seems to be one multifaceted thing he spends a few thousand pages articulating: *one* thing, but a *multifaceted* one. And it is totally inseparable from his being Norwegian. As I think through other cases, similar patterns emerge (though not always as tidily).\\n\\nIn short: the more one's intellectual contributions are defined by strengths, where those strengths also essentially depend on a broad base, the more your regional background is likely to shape your intellectual contributions.\\n\\nP.S.: As I read the Socrates of, e.g., Plato's *Republic* and *Theaetetus*, he argues that things (i) have *real* explanations but (ii) *domain-relative* ones, though (iii) you really need to know the neighboring domains to have full understanding of something, and (iv) knowledge is *really really* hard (godlike!). So this whole line of thought points again to my conjecture that [Tyler is a Platonist](on-conversations-with-tyler.html).\\n\"\n  },\n  \"on-bryan-caplans-spreadsheets\": {\n    \"title\": \"On Bryan Caplan's spreadsheets\",\n    \"createdOn\": \"2022-05-29 16:33:06.859786\",\n    \"mdText\": \"## On Bryan Caplan's spreadsheets\\nBryan Caplan [is complaining that](https://www.econlib.org/no-one-cared-about-my-spreadsheets/) nobody looked at the spreadsheets on which he based *The Case for Education*. Tyler Cowen comments [here](https://marginalrevolution.com/marginalrevolution/2022/02/no-one-cared-about-bryans-spreadsheets.html).\\n\\nI also did not look through Prof. Caplan's spreadsheets, and I'm probably one of the likeliest people in the world to have done it. I'm a computer programmer, quantitatively trained, and I care a *lot* about the subject.\\n\\nSo why didn't I read through the spreadsheets? Yes, I'm going to repeat some of the Excel complaints (see [the comments](https://www.econlib.org/archives/2014/06/embarrass_me_no.html)), but with more context.\\n\\nIt's almost impossible to take someone seriously who says that they care so much about the accuracy of their results when they're calculating this intricately in Excel. If you really care about maintaining a complicated set of data relationships, you write readable, testable code somewhere.\\n\\nPut another way: when you care enough that something like this is right, you test it with computers, not just people.\\n\\nI know Bryan is aware of this complaint. He says:\\n\\n> P.S. Using Excel does not count as \\u201cdemonstrable error.\\u201d  It\\u2019s my comparative advantage.\\n\\nComparative advantage at *what*? There are literally hundreds of thousands of people who are better than this at maintaining quantitative infrastructure with computers, so I don't think he's saying \\\"I have a comparative advantage at maintaining quantitative infrastructure with computers, and this is how I do it.\\\" He might be implying that there's some aspect of this reasoning that is better done with Excel than with other tools, and that he is uniquely trained to do it--but I can't think of what that would be.\\n\\n(By the way, I spent more of 2020-1 looking at work in Excel than I would have preferred to, and I suspect Bryan's Excel skills do not stack up as well as he thinks they do. But, happily, I am not really in a position to judge.)\\n\\nA few further points:\\n\\nWhen you say \\\"I have put tons of effort into ensuring the accuracy of this Excel sheet,\\\" knowledgable people will *not* infer that your work is less likely to contain errors. They will assume that you are [fighting quadratic growth](on-quadratic-complexity.html) and losing.\\n\\nCompare: \\\"I have spent *X* hours fixing my car myself this year. I have asked many neighbors to look at the car. I've issued an open invitation to the Internet also, allowing any respondent into my garage.\\\"\\n\\nFor large *X*:\\n1. Do you think that car is safe? Would you ride in it?\\n1. How much do you think that person really cares about car safety?\\n1. Are you surprised that more people did not respond to the open invitation?\\n1. Would you expect those who *did* respond to be the very best mechanics?\\n\\nCrucially, how do your answers change as *X* goes from \\\"large\\\" to \\\"*very* large\\\"? I conclude that Bryan is not giving evidence for what he thinks he's giving evidence for when he talks about how much effort (of a certain sort) went into his spreadsheets.\\n\\nFinally, remember that the attention of people who can best assess Bryan's work is *very* scarce. (Surely Bryan knows what this labor market is like?) A lot of them care very much about Bryan's work and conclusions, but the world is full of interesting data and programs to look at and make. To spend scarce time giving a professional look at these spreadsheets, I'd have to care not just more but *so much* more about this than about *any project in the world* that uses more modern tools. Elsewhere, I could use my attention at least an order of magnitude more efficiently.\\n\\nLike Bryan, I conclude with regret about state of the art in professionalized quantitative social science, but I'm much more optimistic than he seems to be about the future of quantitative work more generally. (The ironies of Prof. Caplan, in this context, citing his professional training to justify his methods, are too obvious to elaborate on--but they are amusing nonetheless.)\\n\"\n  },\n  \"amplifying-a-point-from-dan-gross\": {\n    \"title\": \"Amplifying a point from Dan Gross\",\n    \"createdOn\": \"2022-10-09 07:24:23.025886\",\n    \"mdText\": \"## Amplifying a point from Dan Gross\\n\\nDan Gross, during [Shruti Rajagopalan's excellent _Talent_ interview](https://conversationswithtyler.com/episodes/talkingtalent/), made a point worth amplifying:\\n\\n> GROSS: We\\u2019re certainly not saying that horsepower and IQ don\\u2019t matter. They certainly do, but there is a clearing bar at which point, for most roles, I think people tend to overvalue it and don\\u2019t realize the logarithmic nature of the curve and assume it\\u2019s linear. But I actually think, earlier than many people realize, you want to switch to caring about just how vigorous and how energetic that person is.\\n\\n> I think that might be because--I\\u2019d be curious if you\\u2019d agree that it\\u2019s because, for most tasks, _doing_ gleans far more information than _thinking_.\\n\\n> TYLER COWEN: Exactly.\\n\\nThe point mostly speaks for itself, but here are a few notes:\\n\\n1. When I worked in machine learning every day, I found a close analogue of this to be very true. A slightly better architecture tended to matter much less than getting better data. Or, at least, once I hit on a reasonable model architecture, I tended to do much better by cleaning and gathering more data than by optimizing the architecture.\\n1. I was reminded of this by [yesterday's issue of Byrne Hobart's newsletter](https://www.thediff.co/p/longreads-open-thread-629), specifically the bit about forecasting: \\\"The market message is '_don't forecast_'!\\\" Byrne gives what I think of as a variant of the Gross point: successful people need a good sense of what's going to happen, but spend a lot more time doing other stuff. (Or: \\\"...spend a lot more time _doing stuff_.\\\")\\n1. It's worth remembering that Gross is a startup investor, and startup investment notoriously involves the tricky balance of finding people who are (i) solid and smart, with a clear-headed and expert view of some domain, but also (ii) ahem, \\\"optimistic\\\" enough to be doing a startup. He more than most people needs to be thinking about the tradeoffs between different kinds of analytic and practical apititude.\\n1. Relatedly, there are kinds of discipline and hustle that are in many situations a good substitute for raw intelligence. Math competitions, programming interviews, and the like certainly reward studying. Reasoning under uncertainty benefits from discipline, and careful thinkers willing to do some research often do much better than top raw intellects. (This came to mind while I was writing up [this post about poker and epistemic mistakes](illustrative-epistemic-mistakes-people-made-with-the-j4-hand.html).)\\n\"\n  },\n  \"on-actually-reading-the-book\": {\n    \"title\": \"On actually reading the book\",\n    \"createdOn\": \"2022-05-29 16:33:06.861851\",\n    \"mdText\": \"## On actually reading the book\\nFirst, two conjectures:\\n\\n1. Basically nobody has read Knausgaard's *My Struggle* all the way through. My evidence: (i) it's really long; (ii) there's about 1000 pages in the middle that most people, including the author, think is substantially weaker than the rest; (iii) most commentary, even from people who talk as if they've read the whole thing, focuses on the first book or two; (iv) there is some absolutely mind-blowing, wonderful, hair-raising stuff in the sixth book. More concretely: I've heard a bunch of people describe *My Struggle* as provocative, but the evidence they give tends to come from the first 100-500 pages of the series, even though book VI gives, e.g., an argument that the ethos of modern Western day cares comes, psychoculturally, right out of Nazi values. And people claim that the series is structurally innovative, but again, the evidence for this usually comes from the beginning of the series. I've never heard someone mention that there's a c. 100-page analysis of a Paul Celan poem right in the middle of Book VI. The best explanation of all this is that people simply never got to (or even near) Book VI.\\n1. Basically nobody has read *The Mathematics of Poker* all the way through. My evidence: (i) it's long; (ii) much of it is difficult; (iii) most commentary, even from people who talk as if they've read the whole thing, focuses on the overall approach or the beginning. So, for example, the poker world is full enough of people who like to poke fun at and/or find amusing details in poker books, but I've never heard anyone other than me mention that near the end of *Mathematics of Poker* there's a page or two where every lowercase *s* is italicized (so that you read things like \\\"thi*s* i*ss*ue\\\"). And here's [a blog post from 2014](https://statmodeling.stat.columbia.edu/2014/08/25/poker-math-showdown/) in which a respectable person claims that the whole risk of ruin analysis is completely flawed. Whether or not the claim is right or wrong, the issue is (I think!) pretty serious, at least as a matter of clear communication. Again, the best explanation of why all this happens only in a few comment threads from 8 years after the book's publication date is that basically nobody ever made it to, much less seriously worked through, that part of the book.\\n\\nThis all reminds me of:\\n\\nFirst, [Warren Buffett's famous claim](https://fs.blog/the-buffett-formula/) that you should simply read a lot of relevant material because \\\"knowledge builds up, like compound interest.\\\"\\n\\nSecond, a claim from [this wonderful tweetstorm](https://twitter.com/benskuhn/status/1419281153983500290) about gaps in results from number theory:\\n\\n> Apparently it's frequently the most famous people who discover these gaps. Roommate said it was surprising the degree to which a lot of what famous people do is actually what everyone is \\\"supposed to do,\\\" e.g. deeply understanding techniques, checking things for yourself...\\n\\nAnd third, Byrne Hobart noting that that claim \\\"[generalizes across other fields](https://twitter.com/ByrneHobart/status/1419406713007001608?s=20).\\\" I can affirm it's true in philosophy, poker, and software.\\nPeople often ask what they can do to generate original contributions or comparative advantages. Usually they vastly overestimate how common it is to have gone through the basic intellectual background in a field. If you've actually read the book (actually checked the proof, actually implemented the algorithm), you're probably way ahead of the field. Much expertise is simply doing this over and over.\\n\\n*Addendum 2022-10-05*: [This note from Donald Knuth](https://www-cs-faculty.stanford.edu/~knuth/news.html) suggests that he thinks that \\\"nobody has been sufficiently motivated to check the finer points out carefully as yet.\\\" From context it seems to me that \\\"check out the finer points\\\" means \\\"actually work through properly.\\\"\\n\"\n  },\n  \"a-common-trap-for-people-entering-programming-jobs\": {\n    \"title\": \"A common trap for people entering programming jobs\",\n    \"createdOn\": \"2022-06-23 19:54:10.937231\",\n    \"mdText\": \"## A common trap for people entering programming jobs\\n\\nIn my first programming job, I was given *The C Programming Language* and told to study it. So when I got my second programming job, I figured out what language I'd be coding in and started studying up.\\n\\nThis was a mistake. Supposing you want to study for a job before you start the job, language study is almost always the wrong place to put your hours:\\n\\n1. If it's not a company-specific language, its range of use and ecosystem are probably so big that you can't know which parts of it will be used on the job.\\n1. And there will likely be specific libraries or tools that make using the language very different inside the company than outside of it.\\n1. There will often also be rules about which parts of the language you're allowed to use, and how. \\nAt my first BigCo job, I quickly realized that using C++ inside the company was more similar to using Java inside the company than it was to using C++ outside of the company.\\n1. With all respect: If you learn modern, beautiful, idiomatic use of some programming language, you're probably not going to see it on the job. \\nIt's good to know how the language is written under ideal conditions, but you'll still need to work with the code base you've got.\\n\\nMeanwhile, there *is* a likely source of confusion you *can* often address in advance: tooling. Ask about what the team uses for:\\n\\n1. Version control;\\n1. Testing;\\n1. Deployment / continuous integration;\\n1. Databases; and\\n1. Log management and search.\\n1. Metrics (thanks, [dukodk](https://news.ycombinator.com/reply?id=31858318&goto=item%3Fid%3D31856512%2331858318)!).\\n\\nSometimes these will be proprietary, and sometimes they will not exist. \\nBut often they will (exist and) be things you can read about and even practice with. \\nI have always found this sort of thing much harder to pick up than a new language.\\n\\nIf you have only ever worked on small- to medium-sized projects and are about to join a company, consider reading *Software Engineering at Google*. \\nWhether or not you're going to work at huge scale, and whether or not you like all the recommendations in the book, it's a wonderful menu of the *problems* that arise from any kind of real scale. \\nAny chapter of that book would have been more valuable to me than all the C++ prep I did back in the day.\\n\\nP.S.: This post is about what to do *if* you want to study for a job before you start it. I'm ignoring the question of whether such study is good, bad, appropriate, or whatever else.\\n\\nP.P.S.: Follow-up [here](on-studying-for-your-upcoming-job-objections-and-replies.html).\\n\"\n  },\n  \"openmind\": {\n    \"title\": \"The Ideal of the Open Mind\",\n    \"createdOn\": \"2022-05-29 16:33:06.863581\",\n    \"mdText\": \"## The Ideal of the Open Mind\\n\\n#### Nate Meyvis, Ph.D.\\n#### Boston College, Fall 2021\\n\\nWhat is it to have an open mind? Why could an open mind be an ideal? We will address these questions by looking at a broad variety of historical and contemporary ways of thinking about epistemology.\\n\\nWith thinkers from classical Greece through the American pragmatists, and by examining practices in contemporary fields including medicine and artificial intelligence, we will aim at a better understanding of epistemic ideals: When we are in our best cognitive states, what exactly do we achieve? What barriers must we overcome to get there? Different candidate answers to this question will lead to different understandings of open-mindedness and different motivations for achieving it (or not).\\n\\nIn each case, after studying ideas in epistemology and the philosophy of mind, we will  examine how they notions play out in the world of contemporary data and media. In particular, we will examine their manifestations in media and communication platforms and texts.\\n\\nPlato will be our guide: we will read his *Theaetetus* over the course of the seminar. This wide-ranging and lively text is also essential intellectual background (more and less directly) for our other readings. The course will be conducted entirely in English. Students with training in Greek and/or epistemology can use the assignments and my office hours to apply and extend that training. Students more interested in contemporary issues will be expected to read the text carefully but will be able to focus their coursework less historically.\\n\\nA few of our readings are long; many are short. Where we sacrifice depth for breadth, notes and other guidance will be available.\\n\\n#### Evaluation\\n* 10%: Attendance and participation\\n* 20%: Quizzes (see below)\\n* 45%: Three short response papers\\n* 25%: One longer final paper\\n\\n#### Quizzes\\n\\n8 to 10 classes will begin with very short quizzes evaluating retention of fundamentals of assigned readings. They are intended to reward proper preparation of the material and to allow for immediate correction of common errors. They will consist of roughly 5 questions and should take 5 minutes or less to complete.\\n\\nLow scores will be dropped. Quizzes for which a student has an excused absence will be dropped without penalty.\\n\\nQuizzes will be available online for students who are forced to participate remotely.\\n\\n#### Short response papers\\n\\nStudents will write three short papers in which the task is to clearly explain some aspect of the assigned material. Topics will be available every week. Students must turn in at least one of these papers by the fourth week of class and at least two by the eighth week of class.\\n\\n#### Other policies\\n\\n*Masks*: Please wear masks.\\n\\n*Late work*: Unexcused late work will be graded to a higher standard during its grading. The increase in standard will be roughly proportional to how late the work is.\\n\\n*Academic integrity*: Please refer to University and Communication Department policies. When you submit work, you submit that it is your work. Do not let confusion about university policy or citation procedure lead you into a breach of academic integrity. You will not be marked down for using the wrong format for a citation.\\n\\n*Zoom*: As per University policy, this is an in-person and not a hybrid course. A Zoom link will be provided for students who must attend remotely. The meeting ID is 453 323 1682. Students attending remotely must submit documentation of its necessity.\\n\\n#### Week 1: The project of defining knowledge\\n* *Theaetetus* 142a-148e6\\n* G.E. Moore, Proof of an External World\\n* William James, 'The Will to Believe'\\n* Agnes Callard, [What Was the Socratic Method](https://www.youtube.com/watch?v=6yjjYq-Z-z0)?\\n\\n#### Week 2: Socrates the epistemic midwife\\n* *Theaetetus*, 148a6-151d3\\n* [Ancient Skepticism (SEP), sections 1 and 4 only](https://plato.stanford.edu/entries/skepticism-ancient/)\\n* [Rene Descartes, First Meditation (only)](https://rintintin.colorado.edu/~vancecd/phil201/Meditations.pdf)\\n* [Bayes' Theorem, Stanford Encyclopedia of Philosophy, sections 1-2 only](https://plato.stanford.edu/entries/bayes-theorem/)\\n* [Agnes Callard on knowing oneself to be wrong: first ten minutes only](https://www.youtube.com/watch?v=Y8KKdp00gPI&list=PL2CxOv1vsZKa7IsG00e6adEcdutubbh7E&index=8)\\n* [Wikipedia: Differential Diagnosis](https://en.wikipedia.org/wiki/Differential_diagnosis)\\n* Optional: [A short description about the reception of Emily Dickinson](https://www.emilydickinsonmuseum.org/emily-dickinson/poetry/the-poet-at-work/the-posthumous-discovery-of-dickinsons-poems/)\\n* Optional: [Wikipedia's list of software bugs](https://en.wikipedia.org/wiki/List_of_software_bugs)\\n\\n#### Week 3: The claim that knowledge is perception\\n* *Theaetetus*, 151d3-160e4\\n* Agnes Callard, [Anger Management](https://thepointmag.com/examined-life/anger-management-agnes-callard/)\\n* Agnes Callard, [The Philosophy of Anger](http://bostonreview.net/forum/agnes-callard-philosophy-anger)\\n* Ludwig Wittgenstein, *Philosophical Investigations* 199\\u2013243.\\n* Clark and Chalmers, [The Extended Mind](https://www.nyu.edu/gsas/dept/philo/courses/concepts/clark.html)\\n\\n#### Week 4: The claim that knowledge is perception, continued\\n* What do we want from knowledge? What should we get from knowledge? And what does this have to do with open-mindedness?\\n* *Theaetetus* 160e4-164c2\\n* Agnes Callard, [The Emotion Police](https://thepointmag.com/examined-life/agnes-callard-the-emotion-police/)\\n* Agnes Callard, [Thoughts and Prayers](https://thepointmag.com/examined-life/thoughts-and-prayers-agnes-callard/)\\n* Rene Descartes, Second Meditation\\n* Rene Girard, \\\"The Plague in Literature and Myth\\\"\\n\\n#### Week 5: The claim that knowledge is perception and the public sphere\\n* *Theaetetus* 164c2-172b9\\n* John Locke, \\\"Essay Concerning Human Understanding\\\", Book 2, Chapter 27, sections 23 (\\\"Consciousness alone unites remote existences into one Person\\\") through 29 (the end of the chapter).\\n* L.A. Paul, *Transformative Experience* (Chapter 1 and the first section of Chapter 2)\\n* Recommended podcast episode: [L.A. Paul being interviewed about this book](https://www.econtalk.org/l-a-paul-on-vampires-life-choices-and-transformation/).\\n* Podcast episode: [Agnes Callard on aspiration](https://www.econtalk.org/agnes-callard-on-aspiration/#audio-highlights): only 38:35 and following\\n\\n#### Week 6: The inquisitive temperament\\n* *Theaetetus* 172b9 - 177c4\\n* David Hume, *A Treatise of Human Nature*, Book I, sections 6-7\\n* Walter Benjamin, \\\"[The Work of Art in the Age of Mechanical Reproduction](https://web.mit.edu/allanmc/www/benjamin.pdf)\\\"\\n* Facebook's [Widely Viewed Content Report](https://transparency.fb.com/data/widely-viewed-content-report/)\\n* Wikipedia's [List of most-retweeted tweets](https://en.wikipedia.org/wiki/List_of_most-retweeted_tweets)\\n\\n#### Week 7: The existence of authority and socially embedded knowledge\\n* *Theaetetus* 177c4 - 179d2\\n* Podcast episode: \\\"[Agnes Callard on Complaint](https://philosophybites.libsyn.com/agnes-callard-on-complaint)\\\"\\n* J.L. Austin, *How to Do Things with Words*, Lectures I and II only\\n* \\\"[The Scapegoating Machine](https://thenewinquiry.com/the-scapegoating-machine/)\\\"\\n* \\\"[How Social Media Shapes our Identity](https://www.newyorker.com/books/under-review/how-social-media-shapes-our-identity)\\\"\\n\\n#### Week 8: Open-mindedness and rationality in a world of flux:\\n* *Theaetetus* 179d2 - 191a5\\n* Agnes Callard, \\\"[Persuade or Be Persuaded](https://thepointmag.com/politics/persuade-or-be-persuaded-agnes-callard/)\\\"\\n* Agnes Callard, \\\"[Against Persuasion](https://bostonreview.net/philosophy-religion/agnes-callard-against-persuasion)\\\"\\n\\n#### Week 9: Applications to current events\\n* *Theaetetus* 191a5 - 195b8\\n* Ben Thompson, \\\"[An interview with Mark Zuckerberg about the Metaverse](https://stratechery.com/2021/an-interview-with-mark-zuckerberg-about-the-metaverse/)\\\"\\n* Ben Thompson, \\\"[Social Networking 2.0](https://stratechery.com/2020/social-networking-2-0/)\\\"\\n* Ben Thompson, \\\"[Facebook Political Problems](https://stratechery.com/2021/facebook-political-problems/)\\\" (leaked memo only; search for \\\"leaked memo\\\")\\n* In case it's useful, Wikipedia has [a useful overview](https://en.wikipedia.org/wiki/Metaverse) of the idea of a metaverse.\\n\\n#### Week 10: Applications to current events, continued\\n* *Theaetetus* 195b8 - 200d4\\n* Matthew Ball, \\\"[The Metaverse](https://www.matthewball.vc/all/themetaverse)\\\"\\n* Ben Thompson, \\\"[The End of the Beginning](https://stratechery.com/2020/the-end-of-the-beginning/)\\\"\\n* Byrne Hobart, \\\"[Meta](https://www.thediff.co/p/whats-a-ponzi-scheme-what-isnt)\\\"\\n\\n#### Week 11: Negotiating over meaning\\n* *Theaetetus* 200d4 - 201c7\\n* Plato, *Apology*, 39e to the end of the dialogue (with particular attention to the way Socrates attempts to demonstrate \\\"the meaning of what has happened to [him]\\\").\\n* [This Twitter thread](https://twitter.com/MattGlassman312/status/1323493516878766081)\\n* [This article about elections and determining meaning](https://gai.georgetown.edu/elections-matter/)\\n\\n#### Week 12: Socratic politics\\n* *Theaetetus* 201c7 - 210d3\\n* Agnes Callard, [Socratic Politics](https://youtu.be/AwFI_t3YHPs)\\n* David Foster Wallace, \\\"[Deciderization 2007: A Special Report](https://cpb-us-w2.wpmucdn.com/sites.stedwards.edu/dist/3/125/files/2012/08/DFW-Intro-to-Best-Essays-2007-23oshqv.pdf)\\\"\\n\\n#### Week 13: The meaning of life\\n* Thomas Nagel, \\\"[The Absurd](https://philosophy.as.uky.edu/sites/default/files/The%20Absurd%20-%20Thomas%20Nagel.pdf)\\\"\\n* Susan Wolf, \\\"[The Meanings of Lives](https://rintintin.colorado.edu/~vancecd/phil150/Wolf.pdf)\\\"\\n\"\n  },\n  \"a-shapley-example\": {\n    \"title\": \"A Shapley example\",\n    \"createdOn\": \"2022-07-27 16:13:11.864515\",\n    \"mdText\": \"## A Shapley example\\n\\nI've [been wondering lately](why-dont-people-talk-about-the-shapley-value-more.html) why we don't think about Shapley values more. \\nThe argument is, in brief, that whatever its flaws, it's the best algorithm we have for computing something of great interest: how to attribute the value generated by a whole to the parts of that whole.\\n\\nConsider the \\\"glove game\\\": there is one left-handed glove and two right-handed gloves. \\nA matched pair is worth one unit of value. \\nHow much does each glove contribute to that unit of value?\\n\\nIt [turns out](https://en.wikipedia.org/wiki/Shapley_value#Glove_game) that the left-handed glove is assigned 2/3 of the unit and each right-handed glove 1/6. \\nThis is already pretty surprising to me: I might have guessed 1/2-1/4-1/4 instead.\\n\\nNow let's generalize the situation: more right-handed gloves join the team, so that there is one left-handed glove and *N* right-handed gloves. \\nFiguring out the Shapley values here is a nice elementary exercise. \\nIt turns out that the left-handed glove is assigned *N*/*N*+1 and each right-handed glove is assigned 1/(*N* * (*N* + 1)).\\n\\nI would not have guessed this (at least not before I'd lived with Shapley values for a while). \\nMore concretely: if two more right-handed gloves show up, the single left-handed glove gets much more valuable: its Shapley value goes from 2/3 to 4/5.\\nAnd each of the right-handed gloves gets much less valuable: they each go from 1/6 to 1/20.\\n\\nOne more time: this isn't a claim that Shapley values are perfect. \\nBut the uniqueness claim is *so* strong. \\nInterpreting the requirements of that uniqueness claim in this application: The null player assumption requires us to assign the other (non-glove) objects in the room should get assigned values of 0. \\nThe efficiency assumption requires us to make the values add up to 1. \\nThe symmetry assumption requires us to give the same value to each right-handed glove (and similarly for left-handed gloves, if we generalize the problem to add those).\\nFor the linearity assumption, suppose we make a matching pair of gloves today and tomorrow, assigning one unit of value to each pair. \\nThe assumption requires us to give the same result if we consider these as two different value-creation events or one event that is spread out over two days. \\n(We can't restribute value by playing metaphysical tricks in individuating those events.)\\n\\nThose are very mild assumptions. And if you accept them, the Shapley assignment of values is unique.\\n\\nA few lessons jump out at me here:\\n\\n1. The left-handed glove's Shapley value gets *bigger* when more teammates show up.\\n1. Team size matters *a lot*. \\n1. Especially if you're doing highly interchangeable labor with those teammates.\\n\\nFinally, a meta note: This reminds me so much of poker, where highly simplified \\\"toy games\\\" are used as intuition builders.\\nThere's a real skill to using these toy games correctly. \\nMost players never take them seriously. \\nA few spend much too much time thinking about them. \\nFinding the right balance here is an underrated cognitive skill.\\n(My former co-host [Andrew](https://twitter.com/thinkingpoker?lang=en) is one of the best at this.)\\n\"\n  },\n  \"on-using-anki-again\": {\n    \"title\": \"On using Anki, again\",\n    \"createdOn\": \"2022-05-29 16:33:06.870776\",\n    \"mdText\": \"## On using Anki, again\\n\\nThinking in terms of dependencies is systematically underrated not just in software development but in using personal-management software. Consider this (stylized but fairly common) exchange:\\n\\nA: \\\"Where should I write arbitrary documents?\\\"\\n\\nB: \\\"Use TeX! Liberate yourself! Produce arbitrarily great documents!\\\"\\n\\nA: \\\"Sounds good! How do I change the font?\\\"\\n\\nB: \\\"Ahahahahaha no.\\\"\\n\\nThere are constraints *you* determine and choices *you* make, and some *the software* makes. These can interact in complicated ways. You set up MyFitnessPal, and then it gives you a budget. An email system forces you to think in terms of folders / VIPs / inboxes / whatever, but you determine when and what you email, whether to auto-archive, which clients use which accounts, and so on.\\n\\nThis isn't just about ergonomics: it's about *what causes what* in your life. This matters a *lot* with Anki. An anonymous reader asked me how exactly I used Anki, and in particular whether it makes sense to commit to using X minutes per day in Anki.\\n\\nI'd hate to do that, because I need Anki to sit *downstream* of my cognitive goal-setting. An underrated benefit of using Anki is that it tells me how much of my mental resources are free and available. But I want it to tell me what my capacity is, not how to use it. It's my job, not Anki's, to figure out whether to use slack immediately, or carry it forward and have some room in my memorization budget the next time some valuable fact set comes along.\\n\\n[Again](on-using-anki.html), the best argument for adopting a spaced-repetition regime is *not* that there exists an exotic, beneficial system of mental training--as much as one might be interested by such a system. It's that we all already want to remember things, and spaced repetition is the most efficient way to do that.\\n\\nFor me, Anki is a good driller but a bad personal trainer; DEVONthink is a great \\\"personal datalake\\\" but a bad life-hierarchy-describer; Goodreads is useful at ingesting data and not useful at describing that data. I've failed with these (and with much other software!) when I've let them determine something they shouldn't or gotten in the way of letting them determine something they should.\\nEach of those failures was, fundamentally, a failure to properly manage the dependency graph for my mind correctly.\\n\"\n  },\n  \"reading-notes-my-losing-season\": {\n    \"title\": \"Reading notes: My Losing Season\",\n    \"createdOn\": \"2023-03-20 10:13:07.789872\",\n    \"mdText\": \"## Reading notes: My Losing Season\\n\\nHere are two metrics for how much a book captures my imagination:\\n\\n1. How much do I think about it when I'm not reading it?\\n1. How eagerly do I abandon other leisure activities for it?\\n\\n_My Losing Season_ gets high marks on both of those. I thought about it all day. I looked for reasons to read just one more chapter. I broke my NYT crossword consecutive-days streak to read more of it.\\n\\nIf there is such a thing as a nonfiction _bildungsroman_, this is a remarkably successful one. Relatedly, it is one of the best books about masculinity I've ever read (though it is never presented as such).\\n\\nThe last portion of the book, to my ear, simply doesn't belong in it. It is a fine essay about reuniting with team members and a coach; I would have read it happily. But the end of Conroy's *season* is so powerful that these extra reminiscences are, by contrast, flat and even self-indulgent. I do want to know what middle-aged Conroy thinks about Vietnam; I didn't want to read about it *then*, when I cared so much about the world of the 22-year-old Conroy. This is an easy [top-100](100-books.html) book for me and probably would have been in the top 25 or 50 had it ended sooner.\\n\"\n  },\n  \"code-review-reference\": {\n    \"title\": \"Code review reference\",\n    \"createdOn\": \"2022-10-12 16:22:17.218569\",\n    \"mdText\": \"## Code review reference\\n\\nIf you are reading this because I've linked you here: the relevant section contains a canonical version of some shorter code review comment, and I'd be grateful if you reviewed it. Otherwise: hello and welcome to a list of things I commonly say in code reviews. (Hat tip to Eric Breck, who maintains a magnificent document in this form.)\\n\\n#### \\\"Your near-synonymous variable names suggest that something is wrong.\\\"\\n\\nIf, in the same function / file / class / whatever, you have `size` and `object_size`, `error` and `mistake`, `dimension` and `dim`, or similar, one of these problems is probably happening:\\n\\n1. Those two variables should be one. (Perhaps this is quick prototype code that hasn't been cleaned up yet.) The best fix is probably to collapse the two variables into one and adjust as appropriate.\\n1. One of those variables is misnamed.  Often, this seems to result from an unwillingness to admit that something needs to be represented at all. Perhaps you think you should have cleaned up the raw input corresponding to *X* by now but for whatever reason can't, but you don't want to say `raw_input_for_X`. The best fix--honesty being the best policy in code as elsewhere--is to rename the variables to describe accurately what they represent. You might also need to file a ticket describing the work that would need to be done to make the embarrassing thing unnecessary. (It's OK!)\\n1. Those variables represent the same underlying thing in different contexts. (Perhaps this is a system that's grown larger than planned.) The best short-term fix is, again, to be more accurate about what the variables represent, even if it's embarrassing.  In the longer term, planning in terms of [bounded contexts](https://martinfowler.com/bliki/BoundedContext.html) might help.\\n\\n#### \\\"You're using a custom type or object here and keeping the definition in your head.\\\"\\nLists, tuples, and arrays make it easy to pass around related bits of information. \\nBe careful not to rely on the sequential structure of these objects in a way that is semantically opaque. \\nThis is a common source of unnecessary coupling between components and of structure living in a programmer's head that should be living in code.\\n\\nSo, if you need to pass around an event's time and place, representing this information as [`foo_time`, `foo_place`] and making every user retrieve the time with `foo_information[0]` and the place with `foo_information[1]` creates an unnecessary burden. \\nMake an `EventCircumstances` or `EventStamp` object (using a struct, a Python dataclass, a Java @AutoValue class, or any other appropriate mechanism). If you really want to represent that data with a list, feel free to do so under the hood, so long as distant callers don't need to know that \\\"`[0]`\\\" is how you say \\\"`.place`\\\" in this context.\\n\\n#### \\\"This name is not semantically correct.\\\"\\n\\nPrefer to name things according to what they `are`, rather than the circumstances of their use. If you have an object representing a pizza, and you order pizza only on Tuesdays, name it `pizza`, not `food_we_order_on_tuesday`. Some common manifestations of this error are:\\n\\n1. Text fields. If the field is the serial number but is used by the header of the login screen, call it `serial_number`, not `login_screen_header_text`.\\n1. Exceptions. Exceptions are tricky, because you tend to want context (in a way that makes contextual information part of what the thing is), but still: If the exception arises from a failed widget validation, and that validation happens in your Jenkins CI, call it a `WidgetValidationException`, not a `JenkinsWidgetCheckException`.\\n\\n#### \\\"This layer of indirection is not permitting any useful abstraction.\\\"\\n\\nLet's say you're representing a light bulb's brightness. Right now you're representing it as a single number of lumens. If you decide to represent that as a `Brightness` with a single field: sure, let's abstract away from a single primitive data type, for all the usual reasons, including extensibility.\\n\\nNow let's say you have a `Lightbulb` object that has `LightbulbProperties` (the only one of which is the `Brightness`). Here I'd worry not only that `Lightbulb` and `LightbulbProperties` are too nearly synonymous (see above) but that the extra wrapper around this single number of lumens isn't helping.\\n\\nAnd if the `Lightbulb` has `LightbulbProperties` that has a `LightbulbBrightnessProperties` that has a `Brightness`,  you almost certainly have more indirection than actual abstraction. Remove at least one of these layers.\\n\\nThis issue commonly arises with central objects in a system, which programmers often feel (justifiedly) hesitant to create and modify directly. Jumping through the layers' definitions in an IDE can feel like watching someone put on latex glove after latex glove after latex glove in the hopes of not leaving a smudge on the vase they're about to handle. I respect the caution but would rather you be able to use your hands.\\n\\n#### \\\"I don't think this thing you're trying to formalize can be formalized.\\\"\\nSee [here](an-argument-from-jimmy-koppel.html).\\n\"\n  },\n  \"reading-notes-super-infinite\": {\n    \"title\": \"Reading notes: Super-Infinite\",\n    \"createdOn\": \"2022-11-04 08:50:00.215189\",\n    \"mdText\": \"## Reading notes: Super-Infinite\\n\\nOther reviews of this wonderful book summarize it well. You don't need to know or remember your John Donne to get a lot out of it. It's largely a portrait of London c. 1600, in all its glory and strangeness and brutality.\\n\\nA few notes:\\n\\n1. Rundell is fully convincing in arguing that the [commonplace book](https://en.wikipedia.org/wiki/Commonplace_book) is an important way into understanding Donne. I'd say that the history of the commonplace book is generally underrated.\\n1. More generally, this is a good material history. Having a sense of the actual physical transmission (or not) of the various works vivifies them. In Donne's case this is unusually interesting. It takes a lot of work, at least for me, to overcome the impression high-school anthologies give of a well-defined, pristine corpus for every major author.\\n1. Biographers often speculate about human nature in asides, but for me this book is *sui generis*. The combination of detailed analysis of Donne, British and European history, and broader psychological discussions is striking and fresh.\\n1. Donne once wrote of something that it was \\\"nature's great masterpiece\\\" and \\\"the only harmless great thing.\\\" What do you think he was talking about?\\n1. Here's a great few sentences: \\\"But his poetry never describes her clothes, or her body. Donne's metaphors are vivid, wild, evocative, and potent, but they're strikingly unspecific. It never occurred to him to tell us if she was curved at the hip, or jutted at the collar bone, or was taller than him: presumably it was not what was important. The hunger, and the body itself, were what mattered.\\\"\\n1. And, finally, a great observation from Donne: \\\"I throw myself down in my chamber, and I call in and invite God and his angels thither; and when they are there, I ignore God and his angels for the noise of a fly, for the rattling of a coach, for the whining of a door...\\\"\\n\"\n  },\n  \"my-information-diet\": {\n    \"title\": \"My information diet\",\n    \"createdOn\": \"2022-07-01 19:31:46.364543\",\n    \"mdText\": \"## My information diet\\nLast updated 2022-07-01.\\n\\nThis page exists because:\\n\\n1. People ask me about it;\\n1. It's a way to keep myself honest;\\n1. It's an efficient way to give a sense of who I am.\\n\\n#### Books\\n\\nRoughly an hour a day. Currently:\\n1. _Three Body Problem_\\n1. _The Last Days of Roger Federer_\\n1. _Pride and Prejudice_ (reread)\\n\\n(Dipping in and out of roughly a dozen other books, each of which I'm an underdog to finish, but read fine this way.)\\n\\n#### Newsletters\\n1. The Diff (Byrne Hobart), [as often as possible](on-reading-the-diff.html)\\n1. Money Stuff (Matt Levine), about half the time\\n1. Bits about Money (Patrick McKenzie), eventually\\n1. Stratechery, in podcast form (see below)\\n1. Parent Data (Emily Oster)\\n1. The Honest Broker (Ted Gioia)\\n\\n#### Blogs\\n1. Dan Luu, every word, unless I don't have time to work through technical details\\n1. Erik Bernhardsson, everything that isn't a deep dive into something that would take a lot of time for me to get up to speed on\\n1. Marginal Revolution, in the manner of a daily newspaper\\n\\n#### Podcasts\\n1. Conversations with Tyler, roughly 2/3 of the time\\n1. Accidental Tech Podcast, skipping around a lot\\n1. EconTalk, only occasionally (but the ceiling is very high)\\n1. Dithering, basically always\\n1. Stratechery, roughly 2/3 of the time (eventually)\\n1. Test & Code in Python, very frequently\\n1. Under the Radar, almost always\\n1. Invest like the Best, when I hear a compelling recommendation for a specific episode\\n1. The Talk Show, occasionally\\n1. The Tim Ferriss Show, maybe 5% of the time (but the ceiling is high)\\n1. The Rabbit Hole, maybe 1/4 of the time\\n1. Mac Power Users, maybe 1/3 of the time\\n1. Hanselminutes, almost never but the ceiling is high and I love how consistent he is\\n1. Coding Blocks, only occasionally and skipping around a lot\\n1. Robot or Not, often\\n\\n#### Social media\\n1. Twitter, almost entirely from a tightly curated list of ~25 people who respect the mental health of their readers (or, at least, whom I find informative and not gratuitously bothersome).\\n1. A little bit of Facebook\\n\\n#### Newspapers\\nThe Wall Street Journal, perhaps 15m / day\\nVarious articles I'm linked to from Twitter\\n\"\n  },\n  \"nonac\": {\n    \"title\": \"How academics can find non-academic work\",\n    \"createdOn\": \"2022-05-29 16:33:06.872946\",\n    \"mdText\": \"## How academics can find non-academic work\\n\\n*This document began its life as an email to philosophy grad students looking for non-academic work. It might be useful to you even if you are not a philosophy grad student, especially if you are looking for work in the tech industry. All feedback is welcome.*\\n\\n### My background / credentials for giving this sort of advice\\n\\nI have spent roughly a decade in and around the non-academic job market. I have done recruitment and interviewing at every company that\\u2019s employed me and for years I was responsible for recruiting and hiring at a genomics startup. It was my job not only to manage our hiring process but to study non-academic hiring processes more generally. Moreover, we recruited, interviewed, and hired many academics--mostly biologists, but also philosophers, linguists, and other humanities types. I have also looked for jobs several times and have had countless conversations with industry folks who were looking to hire people.\\n\\nMore concretely, I\\u2019ve conducted roughly 300 interviews. More than half of these were of candidates with Ph.D.s, and of those, many were people who one might describe as \\u201ctransitioning from academia\\u201d (as opposed to folks for whom there was a well-defined Ph.D.-to-industry path, and who might never have intended to stay in academia). Roughly 1/4 of those were humanities Ph.D.s, and roughly 1/3 of those were philosophy Ph.D.s.\\n\\nSo: I\\u2019ve spent a whole lot of time thinking about these issues, though my experiences are necessarily limited. The job market is a very big place; everyone\\u2019s experience is limited. I know more about the software side of things and am still closely in touch with the startup world. There are many other sides of many other things, where the advice below might not apply so well.\\n\\n### Finding jobs to apply to\\n\\nMy colleagues have often wondered how they could find a job in circumstances where they didn\\u2019t at all know what they were looking for. [This is a reasonable concern](http://www.perseus.tufts.edu/hopper/text?doc=plat.+meno+80d). We can factor the problem into two parts: learning about job-types and learning how to find specific opportunities.\\n\\nHere are some kinds of jobs that exist (mostly unknown to me ten years ago):\\n* Technical documentation writers\\n* Marketing writers\\n* Product managers (and entry-level jobs in product departments)\\n* Operations managers, recruiting managers, HR folks of various kinds\\n* Software testers (see below for more on software)\\n* Librarians / archivists\\n* Consultants\\n* \\u201cDirectors of Happiness\\u201d\\n* \\u201cBusiness Operations Specialist\\u201d (what appears to be an advanced administrative job title at IBM)\\n\\n### How to find specific jobs (also a good way to discover more job-types)\\n\\n* Pick names of companies out of a hat. Go to their Web sites. Click on \\u201cCareers.\\u201d\\n* Every month [Hacker News](https://news.ycombinator.com/), a start-up / technology link aggregator and discussion board, has a \\u201cWho\\u2019s Hiring?\\u201d thread. (A [site-restricted Google search](https://www.google.com/search?client=safari&rls=en&q=who%27s+hiring+site%3Anews.ycombinator.com&ie=UTF-8&oe=UTF-8) ought to turn up recent threads.) Many of these jobs are for coders or other folks with software experience, but plenty are not.\\n* Ask around (I know it\\u2019s obvious, but many people don\\u2019t do this enough).\\n\\n### Miscellaneous notes\\n\\nYou are likely to have a \\u201cnon-traditional\\u201d background for many of the jobs to which you will be applying. You might lack a background as an editor but be seeking an editorship, for example. Do not despair if you do not meet every desideratum listed on a job ad. Whereas academic job listings often include lists of qualifications that preferred candidates will far exceed, non-academic job listings often contain \\u201cwish lists\\u201d in the guise of hard requirements. (These generate amusing stories \\u2014 e.g., about job ads requiring N years of experience in a computer language that did not exist N years ago.) If you think you might be able to do the job, and if the application requirements aren\\u2019t onerous, give it a shot. (Update 2022-02-09:  deleted a happily obsolete joke about Interfolio.)\\n\\nYou might, of course, really be less qualified than the competition for that editorship (or writing job, or coding job, or\\u2026). It is therefore also useful to consider how to compensate in such situations. One strategy is to apply to startup companies. Such companies are often willing to take on less traditional candidates, for at least two reasons. First, they often offer somewhat lower salaries and less job security than more established companies (they generally can\\u2019t afford above-market or sometimes even at-market compensation, and there\\u2019s often no guarantee they\\u2019ll still be in business in a couple years). As a result, they often have to be willing to accept candidates who are by some traditional metrics less qualified. Second, they often need to get a small staff to handle the whole set of tasks for a company, so they need to find generalists. This sometimes leads to a desire to trade deep experience in a field for general intelligence and aptitude (and a good attitude about taking out one\\u2019s own trash, tolerating uncertainty, and so on).\\n\\n### Preparing job applications\\n\\nApplication materials vary widely, but here are some suggestions:\\n\\n* Attempt to strike a balance between emphasizing the virtues of an academic background and your non-academic preparation, your eagerness for the role at hand, etc. Nobody (or at least very few people) will blame you from expressing positive views about many subjects, even when that might appear to reveal inconsistent preferences. (For example, don\\u2019t worry about being enthusiastic about the chance to take on short-term projects that offer fast feedback even if you have previously talked about the immense value in taking on a years-long project undertaken in the pursuit of academic rigor and not an immediate market test.)\\n* Do not assume that the reader of your materials will appreciate the importance of your dissertation subject or of philosophical inquiry more generally. Again, the goal is to take appropriate pride in your work without making too many assumptions about the reader\\u2019s sense of its value or its reflection on you. In most cases, a brief expression of genuine interest in a job will matter much more than a strained claim that one\\u2019s work is relevant to the job. (People who read these materials often spend many, many hours a week reading such materials. They read a lot of strained claims that *X* is relevant to *Y*. Even if they are not as smart as you are, they have very keen noses for this sort of thing.)\\n* Your materials might be evaluated by software. Do not fail to use keywords (\\u201ceditor,\\u201d \\u201cPortuguese,\\u201d \\u201cRuby\\u201d) that truly describe your qualifications and that the software might be looking for.\\n\\n### Interviewing\\n\\nThere are more interviews and more kinds of interviews than can be usefully surveyed here. Some miscellaneous notes:\\n\\nThere is likely to be some sort of performance aspect to an interview (sample editing work; whiteboard coding; hypothetical discussions of conflict resolution; etc.). If you are rusty at some mechanical aspect of a domain, it is useful to prepare for an interview as one might brush up for a standardized test.\\n\\nYou might face implicit or explicit suggestions that being a grad student is problematically different from being a [whatever you are applying to be]. Of course, these situations need to be navigated in light of their variable particular features, but it might be useful to think through some ways in which being a grad student and writing a dissertation is apt preparation for corporate work. Here are three:\\n\\n* The most common desideratum I have read from companies looking to hire remote workers is a candidate\\u2019s experience in working remotely or independently. Having written a dissertation would (in many contexts) go a long way toward convincing a prospective employer that you\\u2019re not going to watch YouTube all day.\\n* More generally, grad students have the chance to prove that they do things and get results. Many employers are looking for people who can reliably get the project finished instead of working only on the easy parts and saving the hard parts for later (forever), fretting about feedback too much to show results to peers or supervisors, etc. Do not forget your teaching experience when you are looking for examples of situations in which you have reliably produced acceptable work on time.\\n* The ability to cope with setbacks and failure is often something an interviewer is looking for; most of us have academic experiences of this sort to talk about.\\n* Note for philosophers: It\\u2019s not easy to talk about one\\u2019s research to a non-philosophical audience. Some interviewers will be interested in your work; others will be rather hostile to the whole enterprise of academic philosophy, and especially to anything that may appear to be a merely verbal dispute. (A prominent person in biotechnology once told me about the philosopher he knew who has the stupidity and audacity to work on vagueness [\\u201cit\\u2019s just obvious it is a non-problem\\u201d].) You might just have to wing it, be honest, and hope for the best. That said, try to emphasize ways in which the problem can seem compelling to those without philosophical training; be accurate without making your interlocutor feel attacked or not heard; try to give your interviewer something to hold on to (you probably have a five-second summary of your work for the academic job market; try to produce some quick summaries that will be accessible to laypeople). Also, many people who do not like philosophy do like \\u201cfun facts.\\u201d\\n\\nMany people who might be interviewing you spend lots and lots of hours interviewing people. Their jobs are not always fun. If you can make your conversation more pleasant than the next person\\u2019s, you\\u2019ll have helped yourself \\u2014 and brightened that person\\u2019s day.\\n\\nHere and elsewhere, do not assume that your reader or interlocutor is lazy, stupid, or mean (despite [what you might have been trained into](lawnmower.html)), unless you have hard evidence that some particular person really is one of those. People generally do not wish to spend their professional lives in the company of people who make such assumptions about them. And spending too much space and time protecting yourself against vicious readers\\u2019 misreadings will prevent you from displaying the most important aspects of your background and candidacy. Interviewers will want to know whether you can function in a team and whether you will take a positive, constructive approach to your work. It may therefore be useful to keep in mind the improv maxim: begin replies, even to silly or ill-formed prompts, with \\u201cyes, and\\u2026\\u201d (At the very least, consider using \\u201cand\\u201d whenever you are tempted to reply with \\u201cbut.\\u201d)\\n\\nErr on the side of accuracy, of course, but note that the sorts of folks who end up staffing HR departments often overvalue (less-than-fully-articulated versions of) the virtues of straightforwardness, clarity, and confidence. Qualifying your claims may be interpreted as a lack of confidence or as an excess of belligerence. As always, assessing one\\u2019s interlocutor is valuable.\\n\\nYour interviewer is unlikely to know what a premium academic philosophers place on rigor and the close connections that philosophy has with technical disciplines. It might be important to correct such false impressions (gently!). If, say, your work in epistemology has led you to study representation theorems, you\\u2019ll often do well to mention those theorems.\\n\\nDo a little bit of homework. Google is your friend. A good way to differentiate yourself from others is to show that you really care about the job (this is quite a contrast from the academic job market!). Don\\u2019t appear desperate, but do appear interested. Ideally you can signal your interest in a way that can\\u2019t be faked (perhaps by reading a white paper that the company has published).\\n\\nIf they ask you if you have questions for them, reply honestly, and also consider asking about the job itself. (\\u201cWhat\\u2019s the day-to-day like? To whom does the position report? How will my success be judged?\\u201d)\\n\\n### A few miscellaneous notes\\n\\nWriting is a superpower. Many of us underestimate the effectiveness (both in general and for one\\u2019s reputation) of memos, follow-up emails, blog posts, contributions to internal documentation, and so on. Use your superpowers.\\n\\nIt\\u2019s generally OK to send a friendly note asking about the status of your application. Things sometimes go slowly or fall through the cracks. If you are polite and if your requests are reasonable, you probably won\\u2019t hurt your chances by making such inquiries.\\n\\nHiring decisions are often made by committee. What might sound like an informal guarantee that you will get an offer might only be an expression of one person\\u2019s enthusiasm (or a misguided attempt to be encouraging).\\n\\nIf you receive a job offer, do not be afraid to negotiate (politely and professionally). The norms here vary greatly from context to context, but in many situations one is expected to haggle a bit. Seek advice from a domain expert if you are in this situation. If the job is in software, [read this](https://www.kalzumeus.com/2012/01/23/salary-negotiation/). (If you think I might know something about the domain in question, feel free to email me.)\\n\\nGood luck.\\n\"\n  },\n  \"on-linear-scans\": {\n    \"title\": \"On linear scans\",\n    \"createdOn\": \"2022-05-29 16:33:06.877359\",\n    \"mdText\": \"## On linear scans\\n\\nIn certain circles, these are pretty popular:\\n\\n1. Checklists (and especially [the Gawande book](http://atulgawande.com/book/the-checklist-manifesto/));\\n1. [80-20 thinking](https://en.wikipedia.org/wiki/Pareto_principle);\\n1. Stoicism.\\n\\nIf you like these, you should probably want to have memorized (or readily available) lists of things to check for in certain situations. They're (1) checklists that (2) a Pareto thinker should think capture most of the relevant possibility space and (3) are an aspect of the human need to have (suitable, reasonable) triggered responses and algorithms at the ready.\\n\\nYou might be wondering about (3): in brief, the ancient Stoics and their skeptical counterparts spent a lot of time thinking about both specific responses to have to hand in certain situations and about formulas or algorithms for generating such responses. I think this sort of sophisticated treatment of (what we might call) cognitive triggers is an underappreciated aspect of ancient Greek philosophy.\\n\\nSome concrete examples: If a baby is crying, there's a pretty good chance it has something to do with fatigue, hunger, a diaper, a burp, some specific physical pain, or being too hot or cold. If I'm stuck on the Wordle, probably there's a repeated letter I haven't considered, I'm making some bad assumption about a vowel-consonant pattern, or I'm subvocally mispronouncing one of the letters. \\n\\nMaybe you've often read this advice or something like it a lot. (Good!) I'm still struck by both how often people over-estimate the probability that something way out of the ordinary is happening and how often people simply fail to implement this sort of linear scan of most relevant items. (So much of the value of bug-tracking systems is in forcing people to list what they've tried and in so doing realize that they've missed one of the likeliest causes.)\\n\\nThis is another set of reasons to [train with spaced repetition](on-using-anki.html).\\n\"\n  },\n  \"reading-notes-the-last-days-of-roger-federer\": {\n    \"title\": \"Reading notes: The Last Days of Roger Federer\",\n    \"createdOn\": \"2022-07-08 04:30:32.782897\",\n    \"mdText\": \"## Reading notes: The Last Days of Roger Federer\\n\\n1. Not my favorite book written during COVID--that's _The Baseball 100_--but my favorite COVID book (so far).\\n1. The central narrative decision here was to organize the book loosely. It's a lifetime of aesthetic-philosophical reflection, as it relates to various kinds of endings, organized in a meandering but satisfying way. The decision was a good one.\\n1. If this were a top-150 book for me (it narrowly misses, I think), I'd have to revise my [books I like more than other people do list](books-i-like-more-than-other-people-do.html): it would come in #3. It is not easy to come in lower than both Joyce and Franzen on Goodreads.\\n1. Nonetheless, I think this is an underrated book format. When people spend (most of) a lifetime building up human capital, I want them to share it. When I look back on good conversations, I rarely regret that they weren't more tightly focused. So too with this sort of semi-memoir.\\n1. A lot of writing about Nietzsche is inaccessible to me (or at least I don't *want* to access it). The reflections here, however, are useful and memorable--and fun.\\n\"\n  },\n  \"on-long-books\": {\n    \"title\": \"On long books\",\n    \"createdOn\": \"2022-05-29 16:33:06.880310\",\n    \"mdText\": \"## On long books\\n\\nThe books that have changed my life are, disproportionately, long. Why?\\n\\n1. It's about compounding. If there are compounding returns to what a good long book can accomplish, we should expect long books to do a lot more than medium-length ones. (Confirming evidence: my non-book information diet includes a handful of writers I try to read every word from; I think this has a compounding benefit and is, other things equal, [advisable](12-rules.html).)\\n1. It's a selection effect. As a book gets longer, it's harder to make the mistake of reading a bad one all the way through.\\n1. It's a commitment effect. The reader feels more invested.\\n1. It's a (different kind of) selection effect. Great authors tend to write really long stuff instead of medium-length stuff.\\n1. It's because we have access to so much good *short* content. Byrne Hobart points out that air travel made water transport more efficient by letting boats go slower. A better environment for learning from very short things could free up mental resources for very long things (e.g., by removing pressure for those long things to also be a stream of new intellectual stimuli). Tyler Cowen recently pointed out that, for all the talk of short attention spans, people happily sit through very long TV series these days, and it's *medium*-length material that audiences avoid.\\n1. It's a(nother different kind of) selection effect. The best content lends itself to expression at great length. Various passages in the sixth volume of *My Struggle* are among the most intense aesthetic experiences of my reading life; those effects relied on the thousands of pages that came before them.\\n\\n*Andrew Brokos, Kaushik Ghose, and others gave useful feedback on an earlier version of this post.*\\n\"\n  },\n  \"testing-decorated-functions-in-python-web-frameworks\": {\n    \"title\": \"Testing decorated functions in Python web frameworks\",\n    \"createdOn\": \"2023-04-28 14:23:56.888714\",\n    \"mdText\": \"## Testing decorated functions in Python web frameworks\\n\\nThe meaty parts of Web frameworks, the parts that determine what happens when you hit a certain URL, often have a similar structure.\\nHere's an example from Bottle, a Python framework:\\n\\n##### `hats.py`\\n```\\n@app.route('/hats')\\ndef get_hat_names():\\n    hat_names = db.connection.execute(\\\"SELECT name FROM hats\\\").fetchall()\\n    return hat_template(hat_names = hat_names)\\n```\\n\\nVery similar patterns exist in Django and Flask. \\n(Also in non-Python frameworks, but for concreteness I'll use only Python examples.)\\n\\nNow: how do you *test* `get_hat_names`?\\n\\nThe answer starts with the observation that things are not, in practice, as simple as the example above. \\nLet's make the example slightly more realistic:\\n\\n##### `hats.py`\\n```\\n# You have some imports\\n\\n# Somewhere you have a Django Router, a Flask object, or a Bottle command.\\n\\n@app.route('/hats')\\ndef show_hats(style: str = Form(...)): # In Django and other frameworks, there would be a `request` parameter here\\n    style_enum_value = Style[style].value # Style is an enum you're importing\\n    hat_names = db.connection.execute(\\\"SELECT name FROM hats WHERE style = {style_enum_value}\\\").fetchall()\\n    sale_hat_names = db.connection.execute(\\\"SELECT hat_name FROM sales WHERE status = 'active'\\\").fetchall()\\n    if not hat_names:\\n        return no_hats_template()\\n    sale_items = [hat_name for hat_name in hat_names if hat_name in sale_hat_names]\\n    return hat_template(hat_names = hat_names, sale_items = sale_items)\\n```\\n\\nThere are at least four problems that arise in testing a function like this:\\n\\n1. The function is more complicated than you'd want it to be for testing.\\n2. The function uses (closes over, if you prefer) items from the surrounding context These items often include routers, environment variables, and database connections.\\n3. You tend to need mocks: e.g., of database connections and of Django `Request` objects.\\n4. The function is decorated, and there's a lot of behavior happening in the wrapped function (but not the first-order `show_hats` function) that will interfere with your attempts to interact with it in tests.\\n\\n(Those problems are interrelated, but also multifaceted. \\nYou might say those are actually two problems or actually six. \\nNever mind.)\\n\\nHere's how I test these functions without creating an opaque wad of mocks and set-up functions.\\n\\n#### Step one: put persistence-related information behind an interface\\n\\nCreate an interface that abstracts away the details of a particular database configuration:\\n\\n##### `hat_repository.py`\\n```\\nclass HatRepository:\\n    @abstractmethod\\n    def get_hat_names(self, style_enum_value):\\n        raise NotImplementedError\\n\\n    @abstractmethod\\n    def get_sale_hat_names(self, style_enum_value):\\n        raise NotImplementedError\\n\\nclass SQLHatRepository(HatRepository):\\n    def __init__(self, db_path):\\n        # Do your database setup\\n        pass\\n\\n    def get_hat_names(self, style_enum_value):\\n        return db.connection.execute(\\\"SELECT name FROM hats WHERE style = {style_enum_value}\\\").fetchall()\\n\\n    def get_sale_hat_names(self, style_enum_value):\\n        return db.connection.execute(\\\"SELECT hat_name FROM sales WHERE status = 'active' AND style = {style_enum_value}\\\").fetchall()\\n```\\n\\nThis will help us a lot here. \\nIt will help us a lot *everywhere*, in fact: it's a powerful abstraction. \\n(_Architecture Patterns with Python_ is the best treatment I've read of the so-called \\\"repository pattern.\\\")\\n\\nThen rewrite your decorated framework functions to depend not on a raw database connection but on an instance of the repository:\\n\\n##### `hats.py`\\n```\\n# You have some imports\\n\\n# Somewhere you have a Django Router, a Flask object, or a Bottle command\\n\\nrepo = SQLHatRepository(\\\"db_path.db\\\")\\n\\n@app.route('/hats')\\ndef show_hats(style: str = Form(...)): # In Django and other frameworks, there would be a `request` parameter here\\n    style_enum_value = Style[style].value\\n    hat_names = repo.get_hat_names(style_enum_value)\\n    sale_hat_names = repo.get_sale_hat_names(style_enum_value)\\n    if not hat_names:\\n        return no_hats_template()\\n    sale_items = [hat_name for hat_name in hat_names if hat_name in sale_hat_names]\\n    return hat_template(hat_names = hat_names, sale_items = sale_items)\\n```\\n\\n#### Step two: put all substantial logic in a helper function\\n\\nIn our example, this would work like this:\\n\\n##### `hat_helpers.py`\\n\\n```\\ndef _show_hats(repo, style_enum_value):\\n    hat_names = repo.get_hat_names(style_enum_value)\\n    sale_hat_names = repo.get_sale_hat_names(style_enum_value)\\n    sale_items = [hat_name for hat_name in hat_names if hat_name in sale_hat_names]\\n    return (hat_names, sale_items)\\n```\\n\\n##### `hats.py`\\n\\n```\\n# You have some imports\\n\\n# Somewhere you have a Django Router, a Flask object, or a Bottle command\\n\\nfrom hat_helpers import _show_hats\\n\\nrepo = SQLHatRepository(\\\"db_path.db\\\")\\n\\n@app.route('/hats')\\ndef show_hats(style: str = Form(...)): # In Django and other frameworks, there would be a `request` parameter here\\n    style_enum_value = Style[style].value\\n    hat_names, sale_items = _show_hats(repo, style_enum_value)\\n    if not hat_names:\\n        return no_hats_template()\\n    return hat_template(hat_names = hat_names, sale_items = sale_items)\\n```\\n\\nThe division of work above is common:\\n\\n1. The main decorated function parses inputs, which are often require transformation from what is passed in to the function. Most commonly, this is a matter of parsing strings or extracting fields from a request.\\n1. The main decorated function feeds values into templates.\\n1. The helper function does everything else.\\n\\n#### Step three: test the helper function\\n\\nNow you have a helper function, `_show_hats`, that is perfectly testable:\\n\\n1. You can create a test-friendly subclass of `HatRepository`.\\n1. No mocks are required.\\n1. If the logic is complicated, you can (and should!) split it out and test those smaller functions separately.\\n1. You can import the helper without invoking side effects from your Web framework's router initialization, database connection, or anything else.\\n\\n\\n#### This looks like an anti-pattern, but it isn't\\n\\nYou might resist this solution: aren't these just \\\"pass-through functions\\\" of the sort John Osterhout [warns us about](reading-notes-a-philosophy-of-software-design.html)? \\nTo have a function doing little more than passing arguments through is a well-known anti-pattern. \\nWhat I'm recommending here, however, only *look* like pass-through functions. \\nThere's a lot of action happening in the decorator. \\nTo avoid pulling as much as possible out of these functions is to be deceived by syntax.\\n\"\n  },\n  \"reading-notes-a-widow-for-one-year\": {\n    \"title\": \"Reading notes: A Widow For One Year\",\n    \"createdOn\": \"2022-06-19 19:52:08.766106\",\n    \"mdText\": \"## Reading notes: A Widow For One Year\\n\\nRevealed preference matters. Whatever I say about what I do and do not like and value, I have read four John Irving novels. That puts him #2 by novel count (I've read five of Jane Austen's) and almost certainly #1 by page count. And I don't regret reading any of those 700,000 or so words.\\n\\nI am unlikely to say much that's new about the book. But:\\n\\n1. Googling suggests that the connection between _A Widow for One Year_ and _The Great Gatsby_ is insufficiently appreciated (contemplating the stars in the orbit of Manhattan, carrying a torch for a really long time, etc.). It's a good question which presents the more optimistic picture of torch-carrying.\\n1. The author's interview that came with my edition was illuminating. This is partly for the notes about how he works (diligently, and spending huge amounts of time outlining the book before literally *writing* it) and for how he embraces his reputation as a sentimentalist. I was reminded of [Josh Groban's interview with Brian Koppelman](https://shows.cadence13.com/podcast/themomentwithbriankoppelman/episodes/e82c888f-0a34-40df-a419-db26b59f49d7), where he discussed the advantages of not being \\\"cool\\\" (or aspiring to coolness, at least) in a creative profession.\\n1. It's not quite a [top-100](100-books.html) book for me, but close (probably #120 or so as I write this). The other three Irving novels all still make the cut.\\n1. Irving seems to have gone from medium-famous to very obscure, but that could be a function of my intellectual context more than anything else. (Computer people are *way* less into long, sentimental American novels than the average reader.) I remember an Owen Meany question on Jeopardy! just a couple years ago.\\n\"\n  },\n  \"reading-notes-how-to-change\": {\n    \"title\": \"Reading notes: How to Change\",\n    \"createdOn\": \"2022-05-29 16:33:06.881223\",\n    \"mdText\": \"## Reading notes: How to Change\\nRecommended. Behavior change is one of the most practically important subjects, and this is its best summary I know of. She also did [an excellent interview](https://www.econtalk.org/katy-milkman-on-how-to-change/) with Russ Roberts.\\n\\nThe book is too wordy for me, and generally conforms too closely to the airport-bookstore-pop-science genre. But it's better written than most, and others will enjoy the structure more than I did. And despite being too long, it's very short. Again, recommended.\\n\\nMisc. notes:\\n\\n1. Triggers seem to be underrated as a self-improvement tool. See the \\\"Cue-based planning\\\" in *How to Change*; [this blog post](https://www.lesswrong.com/posts/v4nNuJBZWPkMkgQRb/making-intentions-concrete-trigger-action-planning) has more detail.\\n1. *How to Change* doesn't talk much about memory, but I do wonder about the possible connection between spaced-repetition drilling (e.g., with Anki) and trigger-based behavior change. [This post](https://guzey.com/things/software/anki/) is provocative. (Hat tip to an anonymous reader.)\\n1. A hard part of reading this book is resisting the temptation to passively nod through the sections with material you've heard about before--in my case, the value of breaking goals into small chunks. I should do more to make goals small, yet it took some effort to really focus on that section because the idea seemed so familiar. A lot of the book felt like that.\\n1. The \\\"Want some advice?\\\" section recommends advice-giving in at least two ways: as more beneficial generally (for oneself) than advice-getting and as a good way to take a third-personal perspective on one's problems. I'd love to see more philosophical work on the relationship between the third-person perspective, advice-giving, and beneficial effects (or, at least, durable effects) on the person adopting that perspective.\\n\"\n  },\n  \"listening-notes-kate-grace-on-the-morning-shakeout\": {\n    \"title\": \"Listening notes: Kate Grace on The Morning Shakeout\",\n    \"createdOn\": \"2022-05-29 16:33:06.884522\",\n    \"mdText\": \"## Listening notes: Kate Grace on The Morning Shakeout\\n\\nI listen to maybe two episodes of The Morning Shakeout per year, but they're always great. Distance runners are, unsurprisingly, good at maintaining conversational pace and energy for an hour. Mario Fraioli does his homework but knows when to shut up; he's a sneaky-great interviewer.\\n\\nI wasn't familiar with [Kate Grace](https://www.instagram.com/fastkate/?hl=en), but turns out she's [good at running](https://en.wikipedia.org/wiki/Kate_Grace) and extremely insightful. [Here's the link](https://themorningshakeout.com/podcast-episode-189-with-kate-grace/). Some of many striking elements:\\n\\n1. She advocates *practicing dealing with doubts* and other psychological aspects of running. For her, this is better achieved by explicitly working through (e.g.) frustration and self-criticism *while practicing running* than by treating mental preparation as a separate activity.\\n1. Her worst doubts come roughly 1/3 of the way through a set or workout. In my own (very, very different!) workout regimen I've noticed the same thing, and a lot of what I practice is simply not indulging the part of my brain that calculates how many more repetitions I have, compares my fatigue to the fatigue I remember from analogous portions of other workouts, etc. One big mental breakthrough I had when I was training as a runner was simply to realize that I persistently confused the \\\"things are harder because I'm running uphill\\\" feeling with the \\\"my body is not performing well right now and I might not be able to finish this run\\\" feeling.\\n1. For mental preparation, she aims for a kind of level confidence, not \\\"hype\\\" (which she thinks of as overrated).\\n1. She recommends that an elite athlete choose where to live in part by how convenient the location is to a major airport.\\n1. How much of what we know about the career trajectory of an athlete is mere convention or a relic from when we didn't know as much about training and longevity? Maybe a lot. Grace is (i) specializing in the 800m and (ii) running *really, really* fast well past the age when it's traditional to do either; she speculates that we don't know as much as we thought we did about what athletes can do at various life stages.\\n1. She advocates for combining a willingness to make big decisions with (i) an ability to adjust later and (ii) less fear about whether the decision is optimal. This reminds me of Patrick Collison's belief that [decisionmaking is overrated](https://tim.blog/2018/12/24/the-tim-ferriss-show-patrick-collison/):\\n> I actually think that decision-making is probably a little bit overrated as a question or an area of study in that \\u2013 investors, obviously, this is their job, right? And that\\u2019s all they can do in some sense, invest or not. [...]\\n> But it\\u2019s not usually that. And I think that the question I would encourage people to think more about is, \\u201cHow do I get to make better decisions?\\u201d as in, \\u201cHow do I make sure the decisions I\\u2019m confronted with end up being better?\\u201d It\\u2019s not like, \\u201cHow should I choose between option A and B,\\u201d but, \\u201cHow do I make sure that both options A and B are as good as possible, and there\\u2019s also a C, D, and E, and that those options are great too?\\u201d\\n\"\n  },\n  \"listening-notes-russ-roberts-and-tyler-cowen-on-reading\": {\n    \"title\": \"Listening notes: Russ Roberts and Tyler Cowen on reading\",\n    \"createdOn\": \"2022-05-29 16:33:06.886164\",\n    \"mdText\": \"## Listening notes: Russ Roberts and Tyler Cowen on reading\\n\\nA form of confidence I would like to impart more generally is the willingness to say what you think is worth saying, without embedding it in a larger or more detailed context. [Potentially great podcasts die](podcasting-faq.html) because their hosts choose formats that are too constraining. I suspect many people think that \\\"I'm going to talk about food with reference to the geography of current events every week\\\" justifies itself in a way that \\\"Let's talk about food for a while\\\" does not. But almost any project that could be started under the first description could be started better under the second. (And if it's a podcast, \\\"I'm going to talk for a while every week, and I happen to know a lot about food\\\" is probably better yet.)\\n\\nHappily, Russ Roberts and Tyler Cowen do not lack the confidence necessary to simply get on a call and [talk about reading for a while](https://www.econtalk.org/tyler-cowen-on-reading/). Some notes from the show:\\n\\n1. Tyler's admonition to read more is important. I view it as an instance of a general fact about productivity: avoiding zero output is harder than is generally acknowledged and is a great way to increase productivity generally. This is counterintuitive, because a lot of us are focused on *maximizing* the value we get for our time. But in a domain where (i) it's easy to get zero return and (ii) it's very hard to predict where the very highest intellectual returns will come, you can often maximize your expected return by ensuring you're doing *something*. (You can think of it as power-law investing for your mind.)\\n1. I'd say rereading is better than Tyler thinks it is. This is probably related to [a broader disagreement](on-reading-canonical-literature.html), which could simply be a difference in temperament or life stage.\\n1. Related to (1) and also to confidence: it's healthy to admit that there are great books that just don't work for you. The best response by far in this situation is to put the book down and read something else. This is hard, because the book's fans are often *right* that it contains something special you won't get anywhere else. But: (i) many books are like that (more than you can read in a lifetime), so you're only sacrificing *this* special element, not your ability to consume uniquely special things in general; and (ii) trying to shame yourself into appreciating something tends to work about as well as trying to shame someone else into appreciating something. Just keep reading (something else).\\n1. Relatedly: an underrated way to grow intellectually is by learning more about your profession, or some other thing you care deeply about. Russ Roberts and Tyler Cowen don't mention this here; each of them is by now explicitly a sort of professional student of everything. But think back to Tyler's claim that [a great way to understand modern India is to study textiles](https://marginalrevolution.com/marginalrevolution/2017/12/understand-modern-india.html). I think he's right, but that it's less to do with textiles and more to do with the way in which focused study of any meaty topic will teach you a *lot*, and broadly. A lot of us have talked to strikingly well-informed people who got that way by knowing some craft and adding layers of related knowledge to it. And this gets to a point Tyler does make in this episode (and has often made over the last few years): if what you really care about is welding, don't feel bad about reading the hundredth book about welding! Reading deeply on a subject gets you super-linear returns (or [so I think](on-distributing-reading-time.html)).\\n\"\n  },\n  \"viewquake-decisionmaking-is-overrated\": {\n    \"title\": \"Viewquake: Decisionmaking is overrated\",\n    \"createdOn\": \"2022-05-31 06:42:11.355071\",\n    \"mdText\": \"## Viewquake: Decisionmaking is overrated\\n\\nPatrick Collison [said this on the Tim Ferriss Show](https://tim.blog/2018/12/24/the-tim-ferriss-show-patrick-collison/). His justification is that having a stream of high-quality options matters much more, as does being able to correct mistakes and incorporate those new high-quality options quickly.\\n\\nA similar idea arises in [Talent](https://www.amazon.com/Talent-Identify-Energizers-Creatives-Winners/dp/1250275814): Cowen and Gross emphasize that the way to make good hires is to have a stream of great candidates.\\n\\nOther notes on the subject:\\n\\n1. Back in my poker-forum days, savvy people liked to point out that the closest decisions mattered the least. (If the expected values of *A* and *B* are so close, you're not doing much better or worse by choosing the better one.)\\n1. Hiring (and other) decisions are very hard (see also the literature on NFL drafting that Cowen and Gross cite). The harder you think they are, the more you should emphasize cultivation over decisionmaking: good cultivation is more robust against human fallibility than decisionmaking is.\\n1. This is relevant to personal-management decisions, too. [I've written that](on-productivity.html) that even if your best outputs are what really matter, it's better to try to (i) avoid zero-productivity \\\"work\\\" and (ii) cultivate lots of energy and lots of output. (\\\"Trading down in the draft\\\" for productivity.)\\n1. I'm struck by how many successful companies emphasize speed and quantity of output.\\n\"\n  },\n  \"listening-notes-test-and-code-191\": {\n    \"title\": \"Listening notes: Test and Code 191\",\n    \"createdOn\": \"2022-07-01 19:31:46.382836\",\n    \"mdText\": \"## Listening notes: Test and Code 191\\n\\nEerily, [Test and Code 191](https://testandcode.com/191) echoes some of [my thoughts on writing a static site generator](notes-on-writing-a-static-site-generator.html). \\nIt's entirely possible that they were recording the show as I was writing the post.\\n\\nTest and Code is a real gem of the software podcast world. \\nIt's all steak and no sizzle. \\nAnd I can prove [I thought so](my-information-diet.html) even before I got the odd dose of flattery that is hearing one's slightly controversial beliefs affirmed on a respectable platform.\\nEpisode 191 covered, among other things, the intersection of static site generation and testing.\\n\\nMy thoughts about writing the SSG powering this site grew out of [my revised thoughts about testing](15-notes-on-testing-software.html). \\nI used to have an idealized view of testing: software breaks into atomic components; you should test all the atoms thoroughly; you should also test various relations among those atoms. \\nI'm more pragmatic now. \\nAs I find things I need to be true of my code, I write tests for it. \\nAnd when something breaks in my code, I write a test to check for that failure.\\nThe latter I think of as \\\"lazy testing,\\\" not in the psychological sense of \\\"lazy\\\" but as in \\\"lazy evaluation,\\\" \\\"lazy deletion,\\\" and the like. \\nThere are applications where finding and testing every edge case matters.\\nOften, though, a unit of testing time is better spent elsewhere.\\n\\nA surprising benefit of this approach is that it keeps me focused on the question of how I can actually make sure the software *works*.\\nThe surprising part is that we can lose focus on that question in the first place. \\nBut we can. \\nIt's all too easy to become a fanatic about testing in [the Santayana sense](https://www.google.com/search?q=santayana+fanatic+redouble+efforts+source), \\\"redoubling your efforts when you have forgotten your aim.\\\"\\n\\nRelatedly, Okken and Wisti make a point I think is underrated: learn coding by coding smoething that matters to you. \\nIf you are doing something you care about, it's easier not to forget your aim, and to avoid that sort of fanaticism. \\nThey even echo one of my examples: using Pytest to make sure links work. \\n\\nWisti seems to be on the same journey that, for me, terminated in writing my own SSG. \\n(\\\"Terminated\\\" in the sense of \\\"continuing indefinitely, but more pleasantly.\\\")\\n\"\n  },\n  \"100-books\": {\n    \"title\": \"The 100 books nearest to my heart\",\n    \"createdOn\": \"2022-05-29 16:33:06.887880\",\n    \"mdText\": \"## My top 100 books\\n\\n1. *Pride and Prejudice*, Jane Austen\\n2. *The Great Gatsby*, F. Scott Fitzgerald\\n3. *War and Peace*, Leo Tolstoy\\n4. *Crime and Punishment*, Sergei Dostoevsky\\n5. *All the Pretty Horses*, Cormac McCarthy\\n6. *My \\u00c1ntonia*, Willa Cather\\n7. *My Struggle, Book VI*, Karl Ove Knausgaard\\n8. *The Scarlet Letter*, Nathaniel Hawthorne\\n9. *The Breaks of the Game*, David Halberstam\\n10. *Getting Things Done*, David Allen\\n11. *Mrs. Dalloway*, Virginia Woolf\\n12. *East of Eden*, John Steinbeck\\n13. *The Dog*, Joseph O\\u2019Neill\\n14. *Baseball By the Rules*, Waggoner et al.\\n15. *A Prayer for Owen Meany*, John Irving\\n16. *Working Effectively with Legacy Code*, Michael Feathers\\n17. *A Moveable Feast*, Ernest Hemingway\\n18. *My Struggle, Book I*, Karl Ove Knausgaard\\n19. *Expecting Better*, Emily Oster\\n20. *The Crossing*, Cormac McCarthy\\n21. *Midnight\\u2019s Children*, Salman Rushdie\\n22. *Refactoring*, Martin Fowler\\n23. *Walden*, Henry David Thoreau\\n24. *Friday Night Lights*, Buzz Bissinger\\n25. *Oh, Crap!*, Jamie Glowacki\\n26. *The Grapes of Wrath*, John Steinbeck\\n27. *The Baseball 100*, Joe Posnanski\\n28. *Thinking, Fast and Slow*, Daniel Kahneman\\n29. *My Struggle, Book II*, Karl Ove Knausgaard\\n30. *The Biggest Game in Town*, Al Alvarez\\n31. *A Portrait of the Artist as a Young Man*, James Joyce\\n32. *Play It as It Lays*, Joan Didion\\n33. *No Bad Kids*, Janet Lansbury\\n34. *The Magician's Nephew*, C.S. Lewis\\n34. *I Was Right On Time*, Buck O\\u2019Neil\\n35. *The Cider House Rules*, John Irving\\n36. *Effective Debugging*, Diomidis Spinellis\\n37. *A Swim in a Pond in the Rain*, George Saunders\\n38. *Suttree*, Cormac McCarthy\\n39. *Ace on the River*, Barry Greenstein\\n40. *Average is Over*, Tyler Cowen\\n41. *Abe*, David S. Reynolds\\n42. *Infinite Jest*, David Foster Wallace\\n43. *Hold\\u2019Em Poker For Advanced Players*\\n44. *Designing Data-Intensive Applications*, Martin Kleppmann\\n45. *Infinite Jest*, David Foster Wallace\\n46. *Battle Cry of Freedom*\\n47. *Lonesome Dove*, Larry McMurtry\\n48. *How Music Works*, David Byrne\\n49. *Their Eyes Were Watching God*, Zora Neale Hurston\\n50. *Love in the Time of Cholera*, Gabriel Garc\\u00eda M\\u00e1rquez\\n51. *Freedom*, Jonathan Franzen\\n52. *Bringing Up B\\u00e9b\\u00e9*, Pamela Druckerman\\n53. *The Autobiography of Frederick Douglass*, Frederick Douglass\\n54. *My Struggle, Book III*, Karl Ove Knausgaard\\n55. *My Losing Season*, Pat Conroy\\n56. *Crossroads*, Jonathan Franzen\\n57. *The Artist\\u2019s Way*, Julia Cameron\\n58. *Fluent Python*, Luciano Ramalho\\n59. *A Supposedly Fun Thing I\\u2019ll Never Do Again*, David Foster Wallace\\n60. *We Are In a Book*, Mo Willems\\n61. *The Corrections*, Jonathan Franzen\\n62. *The Great Fire*, Shirley Hazzard\\n63. *But What If We\\u2019re Wrong?*, Chuck Klosterman\\n64. *Adam\\u2019s Task*, Vicki Hearne\\n65. *The World According to Garp*, John Irving\\n66. *Seven-Card Stud for Advanced Players*, David Sklansky et al.\\n67. *The Great Stagnation*, Tyler Cowen\\n68. *The Power and the Glory*, Graham Greene\\n69. *Cribsheet*, Emily Oster\\n70. *The Art of Learning*, Joshua Waitzkin\\n71. *The Fifties*, David Halberstam\\n72. *The Discovery of Things*, Wolfgang Mann\\n73. *The Pale King*, David Foster Wallace\\n74. *The Remains of the Day*, Kazuo Ishiguro\\n75. *Stoner*, John Williams\\n76. *The Complacent Class*, Tyler Cowen\\n77. *Bottom of the 33rd*, Dan Barry\\n78. *Straight Man*, Richard Russo\\n79. *The Ground Beneath Her Feet*, Salman Rushdie\\n80. *Precious Little Sleep*, Alexis Dubief\\n81. *What I Talk About When I Talk About Running*, Haruki Murakami\\n82. *1984*, George Orwell\\n83. *Programming Pearls*, Jon Bentley\\n84. *The Inner Game of Tennis*, Timothy Gallwey\\n85. *The Upside-Down World*, Benjamin Moser\\n86. *Travels with Charley*, John Steinbeck\\n87. *Philosophical Explanations*, Robert Nozick\\n88. *Brief Interviews with Hideous Men*, David Foster Wallace\\n89. *Talent*, Tyler Cowen and Daniel Gross\\n90. *The Autobiography of Benjamin Franklin*, Benjamin Franklin\\n91. *High-Low Split Poker for Advanced Players*, Ray Zee\\n92. *Meditations on First Philosophy*, Ren\\u00e9 Descartes\\n93. *On Writing Well*, William Zinsser\\n94. *Architecture Patterns with Python*, Harry Percival and Bob Gregory\\n95. *Super/System 2*, Doyle Brunson et al.\\n96. *The Last Days of Roger Federer*, Geoff Dyer\\n98. *Never Split the Difference*, Chris Voss and Tahl Raz\\n99. *From Front Porch to Back Seat*, Beth L. Bailey\\n100. *Elements of Poker*, Tommy Angelo\\n\\nHonorable mention (formerly on the list):\\n\\n- *Bad Blood*, John Carreyrou\\n- *The Family Firm*, Emily Oster\\n- *The Sea, The Sea*, Iris Murdoch\\n- *Summer of \\u201849*, David Halberstam\\n- *Super-Infinite, Katherine Rundell*\\n- *A Widow For One Year*, John Irving\\n\\nHonorable mention (never quite completed):\\n\\n1. *G\\u00f6del, Escher, Bach*, Douglas Hofstadter\\n2. *The Bill James Guide to Baseball Managers*, Bill James\"\n  },\n  \"a-quick-argument-for-naming-all-software-prototypes-after-birds\": {\n    \"title\": \"A quick argument for naming all software prototypes after birds\",\n    \"createdOn\": \"2022-05-29 16:33:06.891340\",\n    \"mdText\": \"## A quick argument for naming all software prototypes after birds\\n\\n1. Software ought to have a memorable name.\\n1. It's good if software has a name that accurately describes what it does, but it's bad if it *inaccurately* describes what it does, and the magnitude of the badness of the mis-description is usually much larger than the benefit of an apt description.\\n1. It's hard to predict how software will evolve.\\n1. So a basic expected value calculation, in light of (2) and (3), suggests that software should not be given a *descriptive* name from the start.\\n1. And it's best not to spend too much time thinking about a prototype's name.\\n1. There are lots of birds, with names that are memorable but not descriptive, and it's easy to find long lists of bird genera.\\n\\nIt's my `[\\\"foo\\\", \\\"bar\\\", \\\"baz\\\", ...]` of software naming. And note that you can pick a name that evokes the idea of what you intend the software to be, without limiting it.\\n\"\n  },\n  \"notes-on-writing-a-static-site-generator\": {\n    \"title\": \"Notes on writing a static site generator\",\n    \"createdOn\": \"2022-06-27 06:40:54.126641\",\n    \"mdText\": \"## Notes on writing a static site generator\\n\\n### Why write a static site generator?\\n\\n1. Because [dependencies in small projects](https://www.natemeyvis.com/on-dependencies-in-small-projects) are overrated.\\n1. For Marie Kondo reasons. It makes writing and maintaining my site pleasant and joyful. Other SSGs might be fine pieces of software, but they decidedly did not spark joy *for me*.\\n\\n### What have I learned?\\n\\n1. Addressing some problem you actually have remains [a great way](software-faq.html) to learn software.\\n1. Here's a testing philosophy: \\\"Test the formal correctness of smaller parts of your code with suites of small tests. Test that these parts are interoperating correctly, and handling the right data, with other tools: smoke tests, dashboards, etc.\\\" You probably don't literally believe this, but a lot of us default to something like it. The SSG has, instructively, obliterated this view. Pytest is a wonderful tool for, e.g., ensuring that all my (relative) links work.\\n1. The SSG should be able to handle tens of millions of words or tens of thousands of posts. Not more, ever. (Alas.) The *site* might need to handle unpredictable and large scale, but *its construction* won't. Utterly divorcing \\\"this is well-made software\\\" from \\\"this software can handle arbitrary scale\\\" has been instructive. Remarkably few problems go away!\\n1. In many applications, separating the logical form of data from its persisted form is essential. Here, less so. I went down a wrong path of instinctively applying some patterns to accomplish that. It was an instructive failure, both psychologically (\\\"why did I do that so reflexively?\\\") and technically (\\\"why don't I need this here?\\\").\\n1. More generally: my other work is not *at all* like writing an SSG. Taking on a *real* project with a new structure has been eye-opening. I often see advice to stay sharp by learning new languages or new tools, usually with toy projects or tutorials. I find it much more illuminating to do diverse and *real* projects--usually, but not always, with the tools I know. The cognitive benefits of tackling a real problem are (for me, at least) much greater than those of exposure to a new tool. And I find it natural and pleasant to let technical needs in real projects drive me to learn a tool, rather than vice versa.\\n\\nHowever many rough edges remain, the project is a success. I have a tool I can use and improve indefinitely. And it really hasn't taken *that* much longer than learning to use some existing SSG. I am struck by how many Web sites outgrow the software they're made from (or seem indefinitely and tragically constrained by that software). I'm pleased to eliminate that category of problems.\\n\"\n  },\n  \"reading-notes-from-front-porch-to-back-seat\": {\n    \"title\": \"Reading notes: From Front Porch to Back Seat\",\n    \"createdOn\": \"2022-05-29 16:33:06.893381\",\n    \"mdText\": \"## Reading notes: From Front Porch to Back Seat\\nThis is an extremely successful book about American social history. Bailey synthesizes a *lot* of primary material and discusses it roughly as you'd expect a trained historian to. But the book is extremely readable and sensible, and she has a keen eye for distinctions (e.g., of class as defined by culture as opposed to by money or occupation).\\n\\nIt's striking how dated the book feels, even given how quickly discussions of gender, race, and class go stale. Bailey's introductions to and contextualizations of these issues would have been considered fully considerate and broad-minded when they were published, but contemporary American readers will be struck by, e.g., the lack of focus on race and certain gender issues.\\n\\nAnd it's also striking to have written the previous paragraph about a book published only nine years ago.\\n\\nOne of the successes of *From Front Porch to Back Seat* is its treatment of mass culture: The courtship culture of the '50s and '60s (it is argued) was the first that could have been reflectively understood as such by its participants. *Focal experience is an underrated idea*, and Bailey's treatment rings true. That said, I would have preferred more nuts-and-bolts exposition of what dating in the '50s and '60s was like (on the model of her wonderful discussions of the '20s and '30s).\\n\\nI highlighted 78 passages in this book despite trying not to highlight too much. Highly recommended.\\n\"\n  },\n  \"reading-notes-the-baseball-100\": {\n    \"title\": \"Reading notes: The Baseball 100\",\n    \"createdOn\": \"2022-09-21 15:59:30.025502\",\n    \"mdText\": \"## Reading notes: The Baseball 100\\n\\nThis is my new favorite baseball book ever. (Literally.)\\n\\nIt's about the players. It's also sort of about the rankings, and sort of not. Posnanski mostly ignores methodological issues until ~90% of the way through the book. His explanations for the rankings, when they come, are steady and reasonable, but also involve a lot of shrugging his shoulders. This all reminds me of the economic/philosophical problem of interpersonal comparisons of utility: there's basically no way to do it right, but not doing it at all is also obviously not right. *The Baseball 100* gets this balance basically right, even (or perhaps especially) when the ratings look most like a cop-out.\\n\\nSo, for example, Jackie Robinson is in 42nd place; he wore number 42. How much more can be said? By career MLB WAR, he's 103rd or so among position players. By other standards, he's an easy #1. The more I think about Posnanski's approach, the more I like it: Put him in the top half, write a beautiful and insightful portrait, make it clear you're honoring the number, and get on to #41. \\n\\nA major success of the book is keeping the reader's attention on the portraits. There's a lot here about family culture and some local culture, but not many sweeping claims about American culture (no \\\"Wade Boggs was a product of the sixties\\\"). Posnanski earns your interest and focus by making the people in the book pop, and he doesn't cash it out for a cheap or boring point about politics or culture. (Of how many recent books could that be said?)\\n\\nTwo themes run through the book: parental influence and the shame of baseball's segregated past. As for the former: Posnanski writes beautifully about childhood. As for the latter: what else can he do? In a book that's at all about rankings, not talking about segregation a lot would be like talking about 2020 college football without talking about COVID a lot.\\n\\nIf anything, I think Posnanski's \\\"take the best guesses you can with all the evidence you have\\\" approach should have taken him even farther. Charlie Gehringer really comes ahead of Martin Dihigo, Cristobal Torriente, and Turkey Stearnes?\\n\\nThis book made me think often of Chuck Klosterman's *But What if We're Wrong?*, which is the best treatment I've seen of the strangeness of cultural influence. Besides the top 100 themselves, there are anecdotes involving so many long-ago MVPs and statistical standouts. Many of those players' names ring loud bells in my head and, I'm pretty sure, others'. They've kept their portions of fame. Many others are absolute blanks to me. I have no real idea what accounts for this. Posnanski, like Klosterman, does a great job laying out mysteries of influence, not just in cases like Arky Vaughan (why is such a great player so obscure?) but also in cases like Roger Clemens: Why isn't it a bigger deal that he threw a bat at Mike Piazza in the World Series? How exactly will Clemens be remembered?\\n\\nPosnanski's answers aren't always satisfying, but maybe there aren't answers to be found; maybe influence is just that deeply arbitrary. What's more important is that Posnanski has the ability to paint portraits so well and freshly that he's in a position to see those questions in the first place.\\n\"\n  },\n  \"code-correctly-by-conforming-to-the-real-world\": {\n    \"title\": \"Code correctly by conforming to the real world\",\n    \"createdOn\": \"2022-10-24 15:34:13.838120\",\n    \"mdText\": \"## Code correctly by conforming to the real world\\n\\nI [recently wrote about](why-events.html) why it makes sense to use events in many programming situations. There's more to say about the example and why events are correct there: the lesson applies more generally and will help you make good decisions about more than just event modeling.\\n\\nWe are modeling a soccer game and we have:\\n\\n1. The basic apparatus of the game: the field, the ball, players, and teams.\\n1. An assistant referee, which in the primitive state of this hypothetical application is just a mechanism for determining whether the ball is out of bounds or not.\\n1. The notion of a throw-in when a ball is out of bounds.\\n\\nThere are, broadly, a few ways to handle the mechanics of awarding a throw-in:\\n\\n1. The assistant referee, upon determining that the ball is out of bounds, examines the recent state of the game (which team touched the ball last) and instigates the throw-in (to the other team) directly.\\n1. Teams (or players) will attempt to take the throw-in, and the assistant referee will permit or deny this.\\n1. The assistant referee will perform an event. This event will be processed by some central entity (you can think of this as a `Referee` object or a more general message bus.\\n\\nThis sort of decision comes up all the time. And they're some of the most important decisions you make in programming. Important, common decisions are the best ones to study!\\n\\nIn that post I argued for the last option. Here are two further notes about making this kind of decision:\\n\\n#### Study dependency problems as dependency problems\\n\\nFirst, notice that this is *a dependency problem*. It can look like, and is often treated as, a purely mechanical problem about imports or an ergonomic problem about the convenience of methods you'll be implementing. There *are* import mechanics and ergonomics here, but those are manifestations of the fact that dependencies are being created. Worrying about dependencies *as dependencies* helps you resolve these other issues; trying to think about the issues independently of the fact that dependencies are involved leads to confusion.\\n\\nWhat are some good heuristics for determining dependency directions?\\n\\n1. Think about operations you need to do now, and choose the direction that will accommodate them most easily.\\n1. Try to anticipate possible *future* operations, and choose the direction that will be accommodate those changes most easily.\\n1. Try to anticipate possible future *modifications*, and choose the direction that will facilitate those.\\n\\nHere, by the way, are some *bad* but commonly used heuristics for making this choice:\\n\\n1. Think about the order data will flow through the system, and make the later objects depend on the earlier ones. (John Ousterhout [diagnoses \\\"temporal bias\\\" errors very well](reading-notes-a-philosophy-of-software-design.html).)\\n1. Think about your preferred database and choose the one that most intuitively fits it.\\n\\nHere, the first two options are poor because they introduce inappropriate dependencies. The `AssistantReferee` object should not be rifling through game history, communicating with players, and doing whatever else would need doing if it were doing more than simply raising events. Nor should several players (or teams, or scorekeepers) have to issue separate requests to an assistant referee in order to determine what is happening. It might not sound as bad at first, but remember that not only the assistant referee but also the head referee, the head coach, and even the scoreboard or weather (is the game over? has thunder struck?) might change the result.\\n\\nI find I make better decisions when I take the \\\"because\\\" in the previous paragraph very literally: bad decisions here are bad *because* they get the dependencies wrong. When you find yourself doing [unnecessary quadratic work](on-quadratic-complexity.html), debugging circular dependencies, or duplicating information because the alternative is too cumbersome, inappropriate dependencies are usually involved. Consider the case of quadratic work: this often happens because something is querying something else, and there are O(n) of each of those things. That, in turn, is often caused by information being stored with the latter thing instead of with the former thing. And that, in turn, is usually caused by a bad dependency.\\n\\nAnother hypothetical example in the spirit of something I've seen dozens of times: a library application is slow because every search requires a linear scan over all books, which in turn is because books are storing information about which users can check them out when. If the information were stored with the user or with some sort of neutral arbiter, this wouldn't be necessary.\\n\\nThe second note about the soccer-events example is more controversial:\\n\\n#### Worry more about what the things you're modeling *really are*\\n\\nThe previous argument attempted to establish that many problems are not only correlated with but *caused by* dependency problems. These issues become clearer when you also recognize that dependency problems (and other problems) are caused by a bad match between your code and reality. That is, your bad dependency is a bad dependency because it fails to conform to the world. In the soccer example, when we introduce events, we conform more closely to reality: the job of the head referee *really is* to be, among other things, an event broker. \\n\\nWhat about the heuristics from before? Going in turn:\\n\\n1. The operations you need to do now are very likely to be operations that have some real-world analogue. The more faithfully you model reality, the more elegantly you'll be able to implement those operations.\\n1. Same with the operations you don't need to support now but do need to support later.\\n1. And when things need to change more fundamentally in your code, it's often because something changed in the real world. The way things change in the real world are governed by their relationships in the real world. So, for example, if *X* persists even though some related *Y* changes, that's a good sign that *X* was more fundamental than *Y* and should have been modeled that way. Another common headache here is needing to do a large migration to, e.g., change a value from being treated as boolean to being treated as a member of a more robust enumeration. Almost always, the thing in the world that the value is representing never really had boolean structure. Rather, for contingent reasons there was no need to express more than two states for that value, and a bad assumption that only two states were *possible* was baked into the interface.\\n\\nEach of those heuristics works because it keeps us in touch with reality. And this is where I find myself in deep agreement with the [domain-driven design](https://en.wikipedia.org/wiki/Domain-driven_design) folks. I find the famous books in the tradition very difficult to read (except for *Architecture Patterns with Python*, which was a pleasure), and there tends to be a bit too much jargon and indoctrination there. But the core of DDD, as I understand it, is that you have to know which real-world domains you're working with, separate them cleanly, and model them correctly. This insight is valuable enough that it's worth wading through a lot of finger-wagging about [CQRS](https://en.wikipedia.org/wiki/Command\\u2013query_separation#Command_Query_Responsibility_Separation).\\n\\nThat is, each of those three heuristics (and pretty much any other reasonable heuristic you can think of) is a manifestation of a more fundamental principle. Your code will ultimately be accountable to the real world in some way, and that its success and failure will depend largely on how faithfully it models the world and how nimbly it adapts to changes in it.\\n\"\n  },\n  \"on-having-philosophy-in-your-life\": {\n    \"title\": \"On having philosophy in your life\",\n    \"createdOn\": \"2022-06-12 13:55:37.598010\",\n    \"mdText\": \"## On having philosophy in your life\\n\\n[Lots of people ask](https://twitter.com/AgnesCallard/status/1535598292427587584): \\\"I don\\u2019t want to go to grad school or become a professional philosopher, but I want more philosophy in my life.  How can I get this?\\\"\\n\\nHere's how I think about this. Fundamental aspects of having philosophy in one's life include:\\n\\n1. Recognizing philosophical questions when you encounter them;\\n1. Having some tools for addressing those questions;\\n1. Haivng some way to discuss and test what you think about them.\\n\\nTaking these in turn:\\n\\nFirst, how do you recognize philosophical questions? Life is full of them, but you'll be better off if you consume lots of high-quality stuff (any medium will do). When people ask me for philosophy recommendations, I more often want to encourage them to think about their intellectual consumption habits more broadly. (If you want lots of my opinions about this, just go to my home page and start reading; this site is full of them.)\\n\\nThe harder part is having the right receptive instincts. This is some combination of attention, energy, and a willingness not to fall back on broadly popular answers.\\n\\nSo, just last night I came across this passage:\\n\\n> \\\"What had befallen him was most unkind: the bewildering illusion that he was now in love with the daughter of the only woman he\\u2019d ever loved! But who can distinguish between falling in love and imagining falling in love? Even genuinely falling in love is an act of the imagination.\\\" ([Source](https://www.amazon.com/dp/B007Z2H3LU/).)\\n\\nThis is, I think, a perfectly good example of having philosophical questions dropped on your intellectual doorstep:\\n\\n1. What exactly is an act of the imagination?\\n1. Why would falling in love be one of those?\\n1. Why, exactly, would the fact that *X* is an act of the imagination make it difficult to distinguish between *X* and imagining-*X*?\\n1. What does any of this have to do with the fact that the object of the *imagined* love is the daughter of the object of the *actual* love?\\n\\n[Here](https://www.natemeyvis.com/openmind.html) is the output of my last attempt to organize a bunch of philosophical questions (around a theme, and under other constraints).\\n\\nSecond: how do you gain and refine tools for addressing philosophical questions? Lots of practice is essential. Having really good models is also important. I'll always recommend Platonic dialogues here, but also consider great art and following philosophers on Twitter.\\n\\nThe best way to improve your tools is also the last item on my initial list, which is to discuss and test your ideas (or the ideas you've encountered, whether or not you take yourself to have originated them). I don't have any surprising or witty advice to give about this, but note that you don't always need a single interlocutor and it doesn't need to have the surface appearance of a prototypical philosophical discussion. My maintaining this Web site is largely motivated by my wanting to test myself in generating and explaining ideas that are, broadly, philosophical. I get plenty of feedback, and I feel more pressure to be rigorous in public writing than I do in idle thoughts (which often seem interesting only until I get around to actually formulating them in a disciplined way).\\n\\nFinally, a note about academic philosophy. I adore a lot of academic philosophy, but I think most people who try to keep philosophy in their lives weight their consumption too heavily toward academic outputs. Academic philosophers have *wonderful* outputs, but a lot of their best work isn't what makes it into writing. I think the norms of (academic) philosophical writing [have gone badly wrong](lawnmower.html).\\n\\nThere are plenty of great journal articles and books, but a good heuristic is to look for things that were commissioned but weren't as much at the mercy of peer reviewers. Introductions to anthologies and conference talks (check YouTube!) are often very good and have high philosophical value per word. (My favorite output of Terence Irwin is his \\\"intellectual background\\\" chapter in the [Cambridge Companion to Plato](https://www.cambridge.org/core/books/cambridge-companion-to-plato/14A54D47BE0B03A2220BAF130B4C8F94).)\\n\"\n  },\n  \"on-editing-text\": {\n    \"title\": \"On editing text\",\n    \"createdOn\": \"2022-05-29 16:33:06.894288\",\n    \"mdText\": \"## On editing text\\n\\nHere I assemble a bunch of things I believe, and find myself repeating, about text editors.\\n\\n* Learning how to use your tools *well* is one of the two or three most underrated skills in software.\\n* It's also one of the most underrated skills in computer usage (and by extension modern life).\\n* It's very hard to learn from authority here, because (i) tool fitness is idiosyncratic, (ii) feelings get involved, and (iii) knowledge of an ecosystem is hard-earned but short-lived and often more local than one appreciates. (In this respect, advice about software tools is a lot like parenting advice.)\\n* More specifically: many people will say that you are not A Real Programmer or A Real Writer until you know [some tool]. That is not true.\\n* You can achieve large productivity gains from improving your use of a text editor.\\n* But be kind to yourself. Learn in a [backward-compatible](https://www.natemeyvis.com/writing/backward-compatible-improvements/) way. Do not shame yourself for, e.g., using a mouse even after you get a taste of the power of keyboard shortcuts.\\n* I think PyCharm is great. I used it for a long time and will probably go back to it during coding sessions when I'm likely to need advanced refactoring support.\\n* But I'm loving Vim these days for nuts-and-bolts coding--it's so *fast*.\\n* And although PyCharm, like other modern IDEs, is a wonderful language-specific coding tool, I fear I was using it as a mediocre operating system.\\n* E.g.: tab-completion doesn't work for me in its terminal. I've looked through some forums. Do I really want the burden of knowing stuff about *the PyCharm terminal*? Enough of my brain is consumed with knowledge about terminals. Once I chose not to use the integrated terminal, some fraction of PyCharm's functionality was not relevant to me. Similar things happened with the debugger, version control integration, and so on.\\n* That said, I do not intend to maintain an extensive .vimrc. The extensibility of Vim is a sneaky weakness: it tempts you to bind your knowledge of a very secure, long-lasting tool to a bundle of ephemeral, indifferently tested ones. (You know that bit in \\\"Sailing to Byzantium\\\" where the narrator notes that his soul is \\\"sick with desire / And fastened to a dying animal\\\"?)\\n* I'm increasingly convinced that the trick to choosing the right development environment is (i) not allowing learning about it to suck up too much of your time but (ii) giving yourself permission to learn progressively more about it without frustration. For a long time learning things about PyCharm felt like time well spent and learning about Vim felt like time spent badly. Now it's the opposite.\\n\"\n  },\n  \"how-to-ramp-up\": {\n    \"title\": \"How to ramp up\",\n    \"createdOn\": \"2024-12-23 09:00:00.000000\",\n    \"mdText\": \"## How to ramp up\\n\\nWhen you start work as a software engineer on a new team, you might be told to ramp up in any of these ways:\\n\\n* Read documentation\\n* Pick up a starter ticket\\n* Have a teammate explain the system to you\\n* \\\"Just look around and ask questions\\\"\\n* Shadow a new teammate\\n* Take tutorials about all the major software development tools at the company\\n\\nI've tried all of these, and both succeeded and failed at actually ramping up. I'm now convinced that the best way to ramp up is to prioritize learning your team's system, and to do that by learning your team's data and how it flows through the system.\\n\\n1. Figure out what your team's most important data is\\n\\nYour team probably processes and stores data, and this data is probably the core of what your team does. (Sometimes--e.g., for some R&D teams--this isn't true, but if you're in any kind of \\\"normal\\\" software engineering job, it probably is.) Figure out what it is.\\n\\n2. Learn how to access that data\\n\\nThis usually means figuring out which database holds that data, and how. Actually go look at the data. (Good luck with permissions, which are almost never both correctly managed and readily intelligible for a new team member.) Make sure you're looking at the real data, not an obsolete or redundant store.\\n\\nUnderstand how every important aspect of the data is stored in the database. On the happy path, there is a single database table, and every feature of the data is stored in an intelligible and consistent way in a well-named field on that table. This happy path is rarely achieved--your job is to figure out how the data *actually* looks in storage.\\n\\n3. Learn the data flow\\n\\nFind the answers to these questions:\\n\\n* Where is that data most commonly generated?\\n* Are there any other ways the data is generated? (Don't forget backfills, administrative overrides, and various kinds of triggers in workflows.)\\n* Where in the code base is the code actually written to the storage?\\n\\nIf there is a most common input source for this data, track the code from its origin to the persistence layer. If you can actually generate data in a test environment and verify that you are correct (by, e.g., inserting log lines or making trivial changes to a checked-out version of the code), that's even better.\\n\\n4. Build out your knowledge\\n\\nAt this point, you should know the very happiest path your team's data can take: the most important data, from its commonest input source, to its main data store, to its most important outputs. Think of it as the best possible skeleton. Now, build it out:\\n\\n* How is the data monitored, displayed, and alarmed on?\\n* How does the system manage scale?\\n* What *other* subsystems produce and consume this data?\\n* What *other* data is there?\\n* You probably discovered some strange features of the data's structure or storage. Why are those the way they are? (Usually it is not because someone was incompetent. Mistakes might have been made, but there were probably contextual reasons you should know about.)\\n* How is all of this documented? If you used documentation to help get this far, can you improve it?\\n* What else is there to know about all the subsystems you've seen so far?\\n\\n### Why this is better than the standard advice\\n\\nThis approach overlaps with, but is very different from, most standard advice.\\n\\n##### Why not start by reading documentation for a while?\\n\\n* The documentation is very likely to be outdated, confusing, or inaccurate.\\n* Even where the documentation is intelligible and accurate, it's very hard for someone who doesn't understand a lot of context to learn from it without learning in a more active way.\\n\\n##### Why not start by picking up a starter ticket?\\n\\n* Starter tickets are often chosen because they can be completed without knowing too much about the codebase or the data. For the same reasons, they often don't *teach*\\u00a0you much about either.\\n* Starter tickets are often drawn from peripheral parts of the system, which are less important to know.\\n\\nTo be clear: doing starter tasks is great, especially as a way to learn unfamiliar tooling for writing, submitting, and incorporating code. I recommend it. But they're overrated as a way to learn about the system you're working on, and it's deceptively easy to complete starter tickets without getting much closer to being a fully productive team member.\\n\\n##### Why not start by having a teammate explain the system to you?\\n\\nThis is a great thing to do! But:\\n\\n* It's very hard to retain a lot of this information without already having a bit of context. Several smaller whiteboarding sessions, as you start to have questions (as you track the happy path of the data), is in my experience a lot more efficient.\\n* Teammates make mistakes! This is, after all, another form of documentation, and learning from documentation has the problems I sketched above.\\n\\n### My second-favorite ramp-up method\\n\\nMy second-favorite ramp-up method, which can be done in parallel with the above, is to read *every single*\\u00a0pull request (or whatever your analogue of a pull request is) on your team. Figure out basically what is going on in the PR and why it is necessary. Knowing a little bit about where the current work is (and where the current problems are!) is likely to help you far out of proportion to the time this takes.\\n\"\n  },\n  \"on-pokers-comparative-disadvantage\": {\n    \"title\": \"On poker's comparative disadvantage\",\n    \"createdOn\": \"2022-05-29 16:33:06.897120\",\n    \"mdText\": \"## On poker's comparative disadvantage\\n\\nPoker can teach you a lot and has a bunch of comparative strengths. But it has comparative disadvantages, too. As I did with the advantages, I think that poker's *actual* comparative disadvantages diverge from what poker people *think* they are.\\n\\nHere are a few:\\n\\n1. Many real-world edges are much bigger than poker players are trained into thinking, whether for domain-specific structural reasons or because many other environments are simply less competitive. Very often you can be a lot more than 2.3% better than the baseline. This manifests itself both in not looking for large edges and not believing they're there. \\n1. It's a lot easier to know the difference between zero-sum and non-zero-sum environments than to *know how* to behave cooperatively. Yes, there are many cooperative aspects of poker, especially at high levels of the game. But to think in terms of cooperative value generation, and especially to think in terms of advancing an industry instead of beating the competition, can seem unnatural against a poker background. And actually behaving this way requires skills that might be underdeveloped.\\n1. Performing badly is so damaging to long-term poker results that successful players have necessarily developed the skill of *not performing badly*. It's very easy for the expected losses hour of unfocused play to negate the expected wins from ten to twenty (or more) hours of focused play. To have thought about this and developed these skills is great. But in other domains, mediocre performance can be valuable, or at least not damaging. When I'm tired and confused, I don't do my best programming--but the total output of my tired-and-confused work sessions so far this year is valuable. In all disciplines there are mistakes so damaging it's better to quit than to risk making them--but poker is a lot less forgiving in this respect than almost anything else. (That said, poker players who have developed the meta-skill of turning C performance into sustained B+ or A- performance will have helped themselves in almost any endeavor.)\\n\"\n  },\n  \"reading-notes-the-score-takes-care-of-itself\": {\n    \"title\": \"Reading notes: The Score Takes Care of Itself\",\n    \"createdOn\": \"2022-05-29 16:33:06.898204\",\n    \"mdText\": \"## Reading notes: The Score Takes Care of Itself\\n\\nIf you're inclined to learn from books about business and about sports management and coaching, this is a good one. (And I think those books are underrated.)\\n\\nThe sections are, happily, very short. This makes the book readable and digestible. It feels a bit like reading a blog. The largest *barrier* to the book's digestibility is its reliance on less-vivid nouns and general description. When there are examples, they vivify the material--but those examples are rare. I don't associate football coaches with the tendency to avoid specifics, and it's worth speculating why the book reads like this. Conjectures:\\n\\n1. Some high-performing people have the knack of reasoning about things at a more abstract level than the rest of us (while retaining the ability to act on that reasoning). Perhaps Walsh was one of them.\\n1. It's just how the ghostwriter writes.\\n1. The politics of football (and of a potential return to the NFL) prevented Walsh from discussing more people by name.\\n1. Walsh's grasp of those abstracta is in fact quite poor, and his success has more to do with \\\"*X*'s and *O*'s\\\" and less to do with character, management, and so on than the book describes. I strongly doubt this is the correct explanation *here*, but it's important to keep in mind when reading autobiographical material. There's a lot of autobiographical poker material, for example, in which success that actually came from doing a few basic things correctly is attributed to a profound understanding of psychological nuance, game theory, and so on.\\n\\nOther notable bits from the book:\\n\\n1. Walsh claims he might do *less* strategizing for a Super Bowl, because sticking to fundamentals becomes more important as the pressure and distractions intensify.\\n1. Part of his training of coaches was to make them practice coaching on each other.\\n1. The Walsh 49ers had a motto of \\\"Commit; explode; recover (if you're wrong)!\\\"; this is remarkably close to certain mottos of agile software development.\\n\"\n  },\n  \"the-tweetstorm-as-a-form\": {\n    \"title\": \"The tweetstorm as a form\",\n    \"createdOn\": \"2022-10-17 10:23:47.595777\",\n    \"mdText\": \"## The tweetstorm as a form\\n\\nTweetstorms give a loose, serial structure to their component tweets, but also leave those tweets largely independent both in the reader's experience and in the structure of reply chains. So they're not just a way to blast some information into public (however useful that function is); I think of them in the tradition of heroic couplets and ghazals. I'd rather read a pure list or a story on a blog or in a book, but semi-structured streams of information (like this) are great for tweetstorms.\\n\\nMy tweetstorms\\n\\nWhy I don't do poker software\\nThe lost phenomenology of poker in 2006\\n\"\n  },\n  \"reading-notes-a-philosophy-of-software-design\": {\n    \"title\": \"Reading notes: A Philosophy of Software Design\",\n    \"createdOn\": \"2022-05-29 16:33:06.902456\",\n    \"mdText\": \"## Reading notes: A Philosophy of Software Design\\nAspects of the book that have stuck with me include:\\n\\n1. His firm belief that interfaces should be small; [it's not clear he's right about this](https://www.pathsensitive.com/2018/10/book-review-philosophy-of-software.html).\\n1. Many elegant examples, both from his teaching and his engineering.\\n1. The wonderful treatment of information leakage, including some subcategorization of the problem. (Very roughly, leakage can be divided into leakage through an interface and \\\"back-door\\\" leakage. Interface-based leakages can be divided into those that result from oversized interfaces and those from inadequate defaults. Back-door leakages can be divided into those resulting from the use of structural information in several places, those resulting from there being too many objects; and those resulting from other causes.)\\n\\nThe sections below cover important topics from the book in slightly more detail:\\n\\n#### Design it twice\\n\\nBecause designing systems is hard, Ousterhout recommends considering at least two designs before choosing one; see chapter 11.\\n\\nNote that this is analogous to [standard advice in cue sports](https://www.pokernews.com/strategy/take-a-cue-from-pool-consider-your-options-poker-23665.html).\\n\\nWe can decompose this advice into (i) caring enough about getting the design right to put in a bit of extra effort and (ii) learning about something--in this case, a design--by asking \\\"if this is wrong, how is it wrong?\\\"\\n\\nRe: (1), when you're reading a book about software design, it's easy to care about getting design right. But in industry, there are so many reasons to lose sight of it. A few of these are: the pressure of short-term bug fixes, the assumption that a system will naturally optimize itself over time, the difficulty of communicating about system design, and the fact that educations in software often neglect the sort of design in question.\\n\\nRe: (2), for generality and power, that question has to be one of the most effective cognitive tools there is. (Its converse, \\\"what follows from this if this is right?,\\\" is at least as powerful and is a core of [the method of analysis](https://philpapers.org/rec/MENPAT-3).)\\n\\n#### Investment rate\\n\\nOusterhout recommends spending \\\"about 10-20% of your total development time\\\" on investments such as reconsidering class designs, improving documentation, and fixing bugs more deeply than is required to close a ticket. See sections 3.2-3.4.\\n\\nThis is a nice example of compounding returns paying off more quickly than we might suspect--and, therefore, of the more general phenomenon that people aren't good at estimating the effects of exponential growth.\\n\\nI suspect that the right number is closer to 20%--actually, I suspect that the right number is *higher* than that. My investment rate even for \\\"throwaway\\\" projects is at least 10-15%, and surely investment gets more valuable when project time is measured in weeks and years instead of hours.\\n\\nAlthough some software engineers truly don't believe that these investments are worth it, many suffer from lack of discipline either at the personal or organizational level. Here as elsewhere, modest improvements in discipline and culture can matter more than large improvements in engineering skill, narrowly construed.\\n\\n#### Pass-through methods\\n\\nA method that invokes another method, has a similar signature to it, and does not add much functionality to it. Ousterhout discusses the problem and argues that it is a red flag (see below) in section 7.1.\\n\\nI don't have much to add to Ousterhout's excellent discussion except a speculative diagnosis: constructing layers of abstraction that are only subtly different is sometimes intended (and interpreted) as a sign of care and sophistication. (My code review reference contains a brief discussion of this, under \\\"This layer of indirection...\\\") \\n\\n#### Red flags\\n\\nThese are discussed throughout the book and summarized in an appendix.\\n\\nThis might be the most valuable aspect of the book; fluency with a set of red flags is a big efficiency boost (especially in code reviews). I hope that other engineers will publish on the subject.\\n\\n#### Temporal decomposition\\n\\nThe mistake in which \\\"the structure of a system corresponds to the time order in which operations occur;\\\" see section 5.3.\\n\\nThis mistake is vastly more common and more severe than acknowledged; if anything, Ousterhout doesn't do enough to emphasize it. (But by mentioning it at all, he does more than most.)\\n\\nRelated: if what you need to be reasoning about is a dependency graph, don't confuse it with a data flow diagram. (Do not confuse the dependency relation with the data-that-used-to-be-here-is-now-there relation.)\\n\\nThis bias extends beyond software. Perhaps *some* biographies should go through the life chronologically, but far too many of them do.\\n\"\n  },\n  \"on-preparing-for-coding-interviews\": {\n    \"title\": \"On preparing for coding interviews\",\n    \"createdOn\": \"2022-05-29 16:33:06.906456\",\n    \"mdText\": \"## On preparing for coding interviews\\n*Q*: How should I prepare for coding interviews of a certain standard sort (\\\"algorithms and data structures interviews,\\\" \\\"whiteboard interviews,\\\" \\\"Leetcode interviews\\\")?\\n\\n*A*:\\nDo your best to mimic the actual environment of your interview:\\n\\n1. If possible, drill in the same IDE that you'll use in the interview.\\n1. Practice talking through the question (literally, out loud, at least sometimes).\\n1. If you won't be able to execute the code you write, don't let yourself do this as you write the code in practice.\\n1. But do go back and make sure you wrote code that actually works, whether or not you'll be allowed to run the code during the interview.\\n1. Do at least some of your practice in clothes like the ones you'll be wearing.\\n\\nChoose a few problems that (i) are a bit harder than will typically be asked and (ii) exercise a few essential skills (graph traversal, binary search, whatever). Do them repeatedly, as drills.\\n\\nLeetCode is better as a question repository and discussion forum than as a platform for testing your answers. The platform will confront you with overflow / underflow cases and other edge cases that your interviewers will overlook, guide you through, or happily leave underspecified. It's good to know about (e.g.) overflow, but it's inefficient to spend so much practice time on it.\\n\\nDefinitely try to learn all the essentials, but not at the expense of becoming more fluent in areas you know pretty well. People sometimes spend 10 to 25 hours struggling with the tricker parts of dynamic programming or XOR hacks when they would be better off using that time to absolutely nail down basic graph search algorithms.\\n\\nPractice the skill of plugging away at a problem when you're stuck, but treat it as one skill among many. So: don't spend too much time struggling when you're stuck. It's more important to learn all the basic question types.\\n\\n*Cracking the Coding Interview* is an excellent question repository (and a bit underrated as an instruction / reference book). *The Algorithm Design Manual* is a pleasant and very different sort of reference, with plenty of \\\"aha\\\" moments. But beware of the trap of substituting passive reading for active preparation.\\n\\n[Email me](mailto:nate@natemeyvis.com) if you have other questions.\\n\"\n  },\n  \"on-dependencies-in-small-projects\": {\n    \"title\": \"On dependencies in small projects\",\n    \"createdOn\": \"2022-05-29 16:33:06.907688\",\n    \"mdText\": \"## On dependencies in small projects\\n\\nDan Luu [Tweeted](https://twitter.com/danluu/status/1434282810622291970):\\n\\n> The places where I most regret taking a dependency are often very low effort projects (like the SSG for my blog), where the complexity of the dependency wasn't worth it.\\n\\nI've chewed on this for three days. It feels like a [viewquake](https://www.reddit.com/r/slatestarcodex/comments/3st7e5/what_was_your_last_great_viewquake/). Some reflections:\\n\\n1. The survivor bias in the sample of \\\"here's a thing I hacked together on a weekend\\\" is obvious but easy to overlook.\\n1. Also obvious but easy to underestimate: there are strong social norms encouraging people to exaggerate (i) how fast they've shipped small projects and (ii) how well those projects work.\\n1. A *lot* of small projects, certainly including those that rely on a dependency the way a personal site relies on a static site generator, do not survive. I have lots of first- and third-personal evidence here.\\n1. Most dependencies that are maintained well enough to avoid crippling bugs also add features regularly. Over time, and often despite maintainers' best efforts, this can make basic \\\"plug and play\\\" usage harder.\\n1. Small projects, not just in software, are harder to pull off than they seem. So here's another way to frame the point I take Dan to be making: Let's say a project seems small. You do it without taking on a dependency, and it's basically a success, but it took more effort than it seemed it should. So we have extra effort to account for, and at least two possible causes: (i) the actual intrinsic difficulty of the project and (ii) the fact that you didn't get a boost from the dependency. Because we underestimate (i), it's natural to overestimate (ii).\\n\"\n  },\n  \"on-using-a-kindle\": {\n    \"title\": \"On using a Kindle\",\n    \"createdOn\": \"2022-05-29 16:33:06.909903\",\n    \"mdText\": \"## On using a Kindle\\nA question du jour: [Has the Kindle been revolutionary](https://essayant.xyz/2021/12/09/2007-kindle-pessimism/) (and if so, how)? Whatever the macro answer is, I know it's been a revolution *for me*:\\n1. Highlighting is easier and vastly more effective than with paper books. Searchable, automatically-online highlights are invaluable, and I'm vastly more likely to retrieve useful information from something I read on my Kindle than from elsewhere.\\n1. Relatedly: Kindle + Anki is a lot more efficient than basically any other reading platform + Anki. If one of your primary goals in reading is the retention of factual information, I don't know of a better choice than the Kindle platform (whether or not you're using Kindle hardware).\\n1. I read myself to sleep most nights in a way that would not be practical otherwise (I want the lights to be off, not to be looking at my phone's screen, and not to be managing a heavy physical object). This means (i) more time for reading and (ii) fewer barriers to reading exactly what I want to read right before sleep--there are specific categories that are best for the combination of learning and sleep-readiness.\\n1. I sample *lots* of Kindle books, partly because Amazon's \\\"send a sample\\\" flow is so low-friction and partly because it's a useful reading list. I don't know of a better way to *get into* so many books efficiently. (You can't highlight without buying, but by the time I'm highlighting something, the purchasing decision is usually very easy--and, again, low-friction.)\\n1. And in the case of long technical books, often most of the content that would be intelligible to me without a serious course of study is available for free. (That was my experience, e.g., [here](https://www.amazon.com/Expected-Returns-Investors-Harvesting-Rewards/dp/1119990726).)\\n1. I often retrieve specific factual information from my e-book library, especially for parenting and software architecture information. That is, my Kindle is often the best channel to virtual versions of Emily Oster and Martin Fowler.  (Arguably this is a *failure*, indicating that I'm not good enough with DEVONthink and/or Anki yet. But as long as there are questions for which it's easy to correlate it to a specific book, and for which full-text search is useful, I expect to keep this habit.)\\n1. It's not always easy to predict what book I'll want to read at the RMV. Much better to just bring along every book. (The predictive decision is more stressful than the in-the-moment reading decision.)\\n1. I change the font size pretty often.\\n1. Speculative: my experience of a given book has much less to do with a publisher's choice of cover art or font. I don't know what effect this has, but I suspect its magnitude is large. (I think a lot about [what Jhumpa Lahiri said about covers](https://conversationswithtyler.com/episodes/jhumpa-lahiri/), and specifically about the benefits of uniform-cover systems; being a Kindle-first reader gets me more of the way to the Italian convention.)\\n\"\n  },\n  \"on-productivity\": {\n    \"title\": \"On productivity\",\n    \"createdOn\": \"2022-05-29 16:33:06.912541\",\n    \"mdText\": \"## On productivity\\n*Updated 2022-01-31.*\\n\\nLists of productivity tips tend to be notable in their omissions: There's a lot of good productivity advice out there, much of it in list form, and it shouldn't be surprising if someone's productivity formula is mostly a remix.\\n\\nMy current principles:\\n\\n1. Cultivate a desire to be productive. [This post](https://danluu.com/productivity-velocity/) of Dan Luu's is useful--and motivating! Consume media from proudly productive people.\\n1. Work on getting things like task lists out of your brain. Also work on getting other nagging thoughts out of your brain; journal if you need to. But this [doesn't require](on-task-management.html) a fancy task manager.\\n1. When you can, structure your work so that you have a natural starting point when you pick up the task (e.g., by stopping writing \\\"[just a bit before you have said everything you want to](https://marginalrevolution.com/marginalrevolution/2004/11/time_management.html)\\\").\\n1. Corollary: try to arrange your workspace the way it needs to be to get your next unit of work done *before* you leave for a meal, break, or whatever else.\\n1. Automate things, even if not many--there can be power-law-type phenomena here. A few automated text replacements (with a tool as simple as what's built into an operating system or as fancy as TextExpander / Alfred / Keyboard Maestro) can have enormous benefits. Whatever that handful of things you always find yourself doing is, there's probably a way to automate it.\\n1. Cultivate an ability to detect, without shame, when you're doing a zero-productivity activity (my canonical example is reading passively or letting one's mind wander while reading). \\\"Is my output nonzero?\\\" can be so much easier to answer than \\\"what is the absolutely optimal use of time right now?,\\\" especially when one is under stress. And minimizing zero-productivity ostensible-work time is a big part of the battle.\\n1. I [still advocate](12-rules.html) having a default mapping from lengths of time to productive uses of that length of time.\\n1. Read and watch things actively. Journal if you need to; it can make your default consumption attitudes more active. Highlight a lot, even if you don't often go back to your highlights. ([Byrne Hobart](https://www.thediff.co) does this too, if memory serves.) More generally, don't just try to get more output from your production time; there are probably efficiency gains to be found on the consumption side too.\\n\"\n  },\n  \"skills-for-academics\": {\n    \"title\": \"Skills for academics\",\n    \"createdOn\": \"2022-05-29 16:33:06.915433\",\n    \"mdText\": \"## Skills for academics\\n\\nDan Tamayo [asks about](https://twitter.com/astrodantamayo/status/1511835183510605824) resources for \\\"project management, mentoring, time management, or other important skills in academic jobs that academia doesn't necessarily train you for.\\\"\\n\\nFirst, an answer:\\n\\n1. *Getting Things Done* is my favorite book about time management and is also directly relevant to project management.\\n1. *High Output Management* is excellent on mentorship and cooperative functioning.\\n1. *The Artist's Way* is good for turning blocked writers into unblocked writers.\\n1. *Peak* is a good book about performing well at skill-intensive tasks.\\n1. *How To Change* is my favorite book about breaking bad habits.\\n\\nWhat's really hard about this question, I think, is that academia is a distinctive and special sphere, and an academic ought to take advantage of the best of it while overcoming the worst of it. What I have in mind is:\\n\\n1. Academics often have a lot of freedom in how they complete tasks, and not having barriers to the best structure for one's work is great. But having to figure out that structure for oneself can be hard.\\n1. Academics can often pursue projects without immediate pressure to prove their utility or \\\"pass a market test.\\\" That independence can be valuable. But market tests are valuable, too.\\n1. A lot of academics produce many outputs: papers, talks, research results underlying those, and fuzzier sorts of progress in mentorship, teaching, and personal development. It can be hard to prioritize these and figure out which of those are for the sake of which others.\\n\\nSome think that academics should abandon academic work styles and adopt habits like those in the (non-academic) business world. That can't be right: the whole *point* of being an academic is to benefit from a distinctive and special environment. My habits, here on the outside, might not be right for someone on the inside.\\n\\nWherever you are, however, it's worth thinking about the distinctive productivity dangers of your environment. (Programming in big tech has a ton of these; I hope to write about them some day.) Academics might consider working extra-hard to assess the long-term value of their various outputs (see #3 above) and work on abandoning less-promising projects (see #2 above).\\n\\n[Matt Might](https://matt.might.net) writes wonderfully about this subject.\\n\"\n  },\n  \"why-my-priors-about-cheating-at-poker-are-so-high\": {\n    \"title\": \"Why my priors about cheating at poker are so high\",\n    \"createdOn\": \"2022-10-05 18:32:14.761813\",\n    \"mdText\": \"## Why my priors about cheating at poker are so high\\n\\nI agree with much of the analysis of people who think that the evidence from the Robbi Jade Lew hand doesn't give strong reason to believe she was cheating. Most of my disagreement comes from the prior probability I assign to an unknown player cheating, which is higher than most.\\n\\nHere are some reasons why I maintain such high priors:\\n\\n1. There are plenty of well-publicized cheating cases.\\n1. The base rate of cheating in general (beyond poker) is quite high. ([Here](https://twitter.com/altluu/status/1576327068752965633?s=20&t=Bj91FyOO_j5sgdRc-EalCg) is a relevant Dan Luu Twitter thread.)\\n1. The infrastructure that keeps live poker safe has been eroding: for example, procedures that ensure dealers pitch the cards correctly are enforced much less rigorously than they were 10 to 20 years ago. (In many rooms they are entirely forgotten.) Whenever someone with expertise in live poker procedures came on Thinking Poker, I would ask about this, and none of them (that I can recall) disputed this view.\\n1. Many publicized cases of cheating were discovered because of greedy, shortsighted, or downright silly exploitation of the cheaters' edge. This suggests that more disciplined cheaters in analogous circumstances would not have been caught.\\n1. I have non-public knowledge of some incidents involving cheating and other very suspicious events. (And I was never the sort of prominent person who would have known lots of inside information.)\\n1. Poker players generally have an incentive to emphasize the cleanliness of the game.\\n\\nMost poker games are clean. The layperson's view (if that layperson's view of poker derives from certain kinds of movies and stories) certainly overestimates how much cheating there is. I would hate for enthusiasts to think that they should not play the Bellagio 2-5 game for fear of being cheated.\\n\\nI would like for more people to quantify their views here, understanding that a lot of estimation is involved. I have asked: what is the ratio of the probability that, in a given big pot in a high-stakes live cash game, a given player in it:\\n\\n1. Will misread their despite rechecking their cards before making an all-in call.\\n1. Had planned to cheat in that pot and attempted to execute that plan.\\n\\nI think that the first is not more than one order of magnitude more likely than the second. Misreads are common; misreads in big pots after rechecking one's cards are not. Cheating is uncommon, but (alas) not as uncommon as I'd like it to be.\\n\"\n  },\n  \"viewquake-interpreting-obvious-mistakes\": {\n    \"title\": \"Viewquake: interpreting obvious mistakes\",\n    \"createdOn\": \"2022-06-10 21:37:03.418420\",\n    \"mdText\": \"## Viewquake: interpreting obvious mistakes\\n\\nIn his poker manual _Ace on the River_, Barry Greenstein writes something like: When you see a successful player make an obvious mistake, do not dismiss them. Rather, start trying to learn *more* from them. It means that they must be compensating for the mistake--a mistake you know well enough to diagnose third-personally--by doing other things particularly well.\\n\\nA few reflections:\\n\\n1. In the poker context, this advice was a bit more relevant in an era when excellent training material was less available; scouting your opponents for implicit strategy advice was more important. This is a lot less true of poker now than it was when Barry was writing (almost 20 years ago!), but it's *very* true of software engineering.\\n1. Sometimes the person in question is directly compensating for the mistake (or seeming mistake) in a nonobvious way. The canonical poker example here is playing too loose preflop and making up for it in big-money decisions later in the hand. There are many less obvious examples involving passive play in order to entice weak players into the hand. It's more interesting, I think, when there's a real, all-things-considered mistake happening, but with offsetting skill in some other subdomain.\\n1. This advice shows up in a different way in Cowen and Gross's [Talent](reading-notes-talent.html), where they advise you to dwell on the \\\"Groucho Marx\\\" question of why a particular candidate is available to you. One of their conclusions is that an obvious defect somewhere allows for the possibility of extraordinary skill somewhere else (while remaining within the threshold of the talent you can actually get). There's also the story Ben Horowitz tells in _The Hard Thing About Hard Things_ about how he was able to hire Mark Cranney because Cranney, despite being excellent at every strategic and organizational element of sales, did not \\\"look the part\\\" and so was passed over by other firms.\\n1. I found this so insightful in part because poker players are so eager to find fault in their opponents. This is both because finding and exploiting faults is exactly how you become a winning player and because the dominant psychology of the game simply involves a strong desire to believe yourself better than other players. Other domains are a lot less like this, but I'm reminded of the philosophy literature on [disagreement](https://plato.stanford.edu/entries/disagreement/#PeerDisa), which takes up questions like: \\\"if I believe *X* and an epistemic peer believes not-*X*, must I change my belief in *X*?\\\" So much of that discussion begins (or seems to me to begin) from a place of extreme desire to hang on to one's beliefs in the face of disagreement. Not to elide tricky questions of the structure of belief, but a lot of those papers felt like stories with desperately insecure protagonists. (Why not ask \\\"what may I learn?\\\" instead of \\\"must I change?\\\".)\\n\"\n  },\n  \"on-capturing-thoughts\": {\n    \"title\": \"On capturing thoughts\",\n    \"createdOn\": \"2022-05-29 16:33:06.917878\",\n    \"mdText\": \"## On capturing thoughts\\nWhat's the most efficient way to get ideas from your head into some sort of storage? (Hat tip to [Ben Reesor](https://twitter.com/ben_reesor) for the question.)\\n\\nI'm a contrarian here, at least with respect to the productivity community. First, I advocate for domain-specific capture. If you're an expert with some software like Drafts, Notes, or Roam and have a good system for getting *anything* in there, great. But I do better putting tasks into Reminders, facts into DevonTHINK, messages directly into a messaging client, and so on. And I don't know anyone for whom a general-purpose capture system has worked better than a piecemeal system.\\n\\nThere's a line of thought according to which we should resist piecemeal capture systems, with two claims at its core:\\n\\n1. You should be able to coordinate (put into a graph structure, search over, or whatever) *all* your notes in a single system;\\n1. You should be able to capture *arbitrary* thoughts quickly, not just ones you can already classify as tasks, memories, or whatever.\\n\\nThe first of these just seems false to me. Having a single digital system that reflects as much as possible of your mind, life, and history is, for some, an appealing ideal. But why expect that tasks, memories, goals, and everything else should comprise a *single* software system? They don't feel, behave, or manifest themselves similarly in our embodied lives, so why should they do so in our software lives? More practically, domain-specific tools are so wonderful these days that I'm more eager to bet on the future of a piecemeal system than a fully integrated one.\\n\\nI'm more contrarian still with respect to the premise behind the question, though: Why think that it's *good* to capture the marginal thought? I've recently gone through a bunch of my old notes and journal entries. They're *terrible*.\\n\\nEmpirically, my note-taking is most valuable when it's tied to some long-standing line of thought or established project. This is all the more reason to keep a quick-capture system piecemeal. At least for me, the dream of being able to record arbitrary thoughts quickly is not worth pursuing: The more I've pushed myself toward a general-purpose capture system, the more I've encouraged myself to capture--and perhaps distract myself with--my worst ideas.\\n\\nThere are surely people who have much better random thoughts than I do. If you're one of them, good luck. But remember that reducing friction in the general case often increases it in specialized cases (e.g., as you need to move tasks from a general-purpose system into a task manager). Don't set a goal of reducing that friction without at least trying to assess the tradeoffs involved.\\n\"\n  },\n  \"software-faq\": {\n    \"title\": \"Software FAQ\",\n    \"createdOn\": \"2022-05-29 16:33:06.920430\",\n    \"mdText\": \"## Software FAQ\\n\\nAnd by \\\"frequently\\\" I mean either (1) asked of me enough that I'm creating a stable public reference for it or (2) not asked of me very often, but I think more people should be asking it.\\n\\n#### Should I attend a bootcamp?\\n\\nBootcamps are largely useful as a commitment device. A good portfolio project has as much signaling value as a bootcamp--much of the job-market value of the bootcamp simply is whatever project or portfolio piece you create in it--and needn't carry the negative signal a bootcamp can (pegging you as very junior).\\n\\nSo: maybe, depending on how you work best, but almost certainly not if the bootcamp isn't a very good one.\\n\\n#### What book should I read to learn programming?\\n\\nYou probably shouldn't base your learning around a book. It's more effective to pick a project (initially something very small) and try to see it through, doing Web searches for help along the way. If you need some other sort of structure around your learning, a good MOOC relevant to your interests (search \\\"MIT OpenCourseWare\\\" on YouTube) is a good option.\\n\\n#### I want to learn fundamental algorithms and data structures. What should I study?\\n\\nTim Roughgarden's MOOC (lectures available on YouTube) is a good place to start. MIT OCW (also largely available on YouTube) is usually my first YouTube search to learn about or brush up on some particular CS topic. I find it handy to have [CLRS](https://en.wikipedia.org/wiki/Introduction_to_Algorithms) around, and [Skiena's book](https://www.algorist.com/) is a nice complement to it. But you don't need any books.\\n\\n#### How did you get into programming? How did you get your first job?\\n\\nSee [here](how-i-got-into-programming.html).\\n\"\n  },\n  \"notes-on-coding-with-chatgpt\": {\n    \"title\": \"Notes on coding with ChatGPT\",\n    \"createdOn\": \"2023-04-17 05:56:30.217786\",\n    \"mdText\": \"## Notes on coding with ChatGPT\\n\\n1. This is real.\\n1. There's a sort of endurance that coding with ChatGPT uniquely requires. You have to maintain the discipline to keep asking ChatGPT where appropriate; it's tempting to plow through a problem unassisted, especially when you've just asked ChatGPT for help a half-dozen times. You have to remember that ChatGPT is not getting tired or annoyed, and that you're not keeping ChatGPT from working on something more important. There's a certain social instinct that must be slightly repressed: entering into conversation of any sort prompts us to spin up various emotional capacities. Some of these are in fact good to maintain even when the interlocutor is ChatGPT, but many stop being worth the energy when it's not a human being on the other side.\\n1. The skill of dealing with code you didn't write, which has always been an important part of software engineering, is perhaps now even *more* important, given that you won't even have written a bunch of the code that you wrote.\\n1. There's a particular skill of remembering to double-check sources that are right perhaps 95% of the time. As I get better with ChatGPT, it has been harder to catch its mistakes, because its accuracy rate is sometimes so high that it comes to seem extremely convincing. (At Google there was an absolutely magical development tool that hot-swapped fixes into a development environment as you coded. It worked perhaps 99% of the time. I tended to lose hours chasing my tail when a 1% case hit.)\\n1. If you are coding with Copilot, don't be afraid to type \\\"This is confusing because\\\" and wait for the autocomplete.\\n\"\n  },\n  \"ancient-philosophy-and-software\": {\n    \"title\": \"Ancient philosophy and software\",\n    \"createdOn\": \"2025-02-03 15:00:00.000000\",\n    \"mdText\": \"## Ancient philosophy and software\\n\\nHow does ancient philosophy inform the building of software? [Here is](https://lisielilli.medium.com/how-ancient-philosophy-informs-my-work-as-a-product-manager-in-ai-f5129e5284ca) Lisie Lillianfeld's (excellent) answer. Mine is a bit different, largely because I worked more on [Platonic metaphysics](https://philpapers.org/rec/MEYKSA) and less on Maimonides et al. So here's *my* answer.\\n\\nThis is about the connections between software and *the philosophy itself*, not *the studying of it*. So, for example, nothing like \\\"writing a big long Ph.D. prepared me for managing big long software projects.\\\" If you want to know what I think about *that*, [this document](https://www.natemeyvis.com/nonac.html) has much of it.\\n\\nMy view of software is metaphysics-heavy in that I think you can't lose focus on questions of things' structures and essences (see, e.g., [here](https://www.natemeyvis.com/code-review-reference) and [here](https://www.natemeyvis.com/code-correctly-by-conforming-to-the-real-world)). Most software involves modeling some fragment of the world in code, and I think you can't do this without an accurate sense of what that fragment of the world *is really like*:\\n* What are the relevant objects' structures?\\n* Which of their properties are essential, and which accidental?\\n* Which of their properties are mutable, and which immutable?\\n* Are these two things that seem to have all the same properties actually *one* thing, or are they two things that just happen to track each other so far?\\n\\nI like to think I'd have views like this even without my years with Plato, but who knows. Being an ancient philosopher keeps me asking *what, precisely, things are*. You're trained to ask the sorts of questions I just discussed.\\n\\nA metaphysical mindset is also helpful in thinking about dependency management, which is central to software. I'm particularly glad to have been trained into the idea that there can be many *kinds* of dependencies. The graph describing the temporal flow of data in a system is usually not the best dependency graph; temporal dependency is not the same thing as dependency of modules or objects. Of course you don't have to read Plato and Aristotle to be sensitized to that idea, but it sure helps.\\n\\nHere again, much of the benefit is simply in being able to take these questions seriously. Contemporary philosophy can be hostile to \\\"pure metaphysics;\\\" ancient Greek philosophy was, emphatically, not.\\n\\nFinally, a word on distributed systems. There were ancient debates about the structure of the soul: there are (among others) a Socratic view according to which the soul is one faculty and an Aristotelian view according to which the soul has several coordinated parts. The question is important in its own right, but studying it also teaches two broader metaphysical lessons. First, that complex structures have (so to speak) a lot of overhead, even if they don't seem at first to be very complicated. Many interfaces (so to speak) are required and much can go wrong. It is enough to make one sympathetic to the slogan that distributed systems are terrible, and to avoid them if at all possible. Second, however, that complex structures really can do a lot that simple ones can't, and if you can manage the overhead, they have tremendous power.\\n\\nI'll never pretend that spending years and years reading Plato is necessary for being a good software engineer, but it's definitely pleasant. I've come to believe that a metaphysics-friendly mindset is more useful in software than a metaphysics-hostile one, and I'm grateful for the time I spent with some of the very friendliest.\"\n  },\n  \"on-reading-canonical-literature\": {\n    \"title\": \"On reading canonical literature\",\n    \"createdOn\": \"2022-05-29 16:33:06.921455\",\n    \"mdText\": \"## On reading canonical literature\\n\\nTyler Cowen [takes up the question](https://marginalrevolution.bulletin.com/how-to-read-canonical-western-literature/) of how to read canonical Western literature. The suggestions are characteristically good (and characteristically surprising). But they miss what I take to be the most important and difficult point: Everything must be done to get yourself in a position of maximum receptivity to the text.\\n\\nTyler wants us to read very quickly the first time; to consult secondary literature along the way; and sometimes to read the first fifty pages twice before reading anything else at all. There's a place for all of these. But consider that:\\n\\n1. Many canonical works are widely misunderstood;\\n1. Many canonical works function by producing certain effects that are inseparable from their linear-temporal structure ([as George Saunders would put it](https://www.amazon.com/Swim-Pond-Rain-Russians-Writing/dp/1984856022));\\n1. Many canonical works are fundamentally strange to us now, so that it's often unknowable which parts of it one will be in a position to appreciate on a first reading.\\n\\nSome hopefully illustrative, but obviously personal, reflections:\\n1. I read *The Scarlet Letter* for the first time a couple years ago. It was, for me, totally unlike its reputation (or its reputation to me); I view it as a sort of origin-story of America. Most of what I found most moving was not the stuff about public shame, hypocrisy, and so on. I don't think I would have appreciated it as well had I followed Tyler's advice.\\n1. I have a Ph.D. in ancient Greek philosophy. The accumulated wisdom about Plato is important, sure--but when I (try to) help people read Plato, I instruct them to read linearly, to appreciate what they can, and to struggle with the arguments and observations as they encounter them. (*Then* get help.)\\n1. There's a time--hopefully, lots of time--for studying (say) Milton and Whitman in the way Tyler proposes. But if you're sitting down with them, the thing to do is just to try to focus, read as carefully as you can, and enjoy the ride. (More generally, I think Tyler's advice is a bit better for certain kinds of prose than it is for poetry and everything else.)\\n\\nWould you consume a sermon in the way Tyler suggests? (Would you commit in advance to consuming all the best sermons that way?)\\n\\nThe advice is still good, overall, though. Perhaps the correct Straussian reading of the post is that culture matters too much and is too local (we know Tyler believes this, right?) for us to really *understand* canonical Western literature any more, and this is advice for a sort of desperate second-best strategy, but laced with optimism so as not to discourage us.\\n\"\n  },\n  \"viewquake-making-meaning-after-the-fact\": {\n    \"title\": \"Viewquake: making meaning after the fact\",\n    \"createdOn\": \"2022-11-09 20:29:34.691391\",\n    \"mdText\": \"## Viewquake: making meaning after the fact\\n\\nA couple years ago I started to reckon with the idea that, whereas some meanings of events are felt immediately, and some are intrinsic to those events, others are negotiable. Here's what set me on this line of thinking:\\n\\n1. [This Tweetstorm](https://twitter.com/MattGlassman312/status/1323493514169241602?s=20&t=0RsNhicny7xi1dicm0b20Q) by Matt Glassman about elections.\\n1. [This related Glassman article](https://gai.georgetown.edu/elections-matter/) about attempts to shape public meanings of elections.\\n1. [Apology 39e and following](http://www.perseus.tufts.edu/hopper/text?doc=Perseus%3Atext%3A1999.01.0170%3Atext%3DApol.%3Asection%3D39e), when Socrates wants \\\"to show you the meaning of this which has now happened to me.\\\"\\n1. Negotiation literature, especially [Never Split The Difference](https://www.amazon.com/Never-Split-Difference-Negotiating-Depended/dp/0062407805).\\n\\nI have nothing profound to add to these here, but a lot of the world makes more sense when you see more behavior as negotiating over meaning. (And more events as mechanisms to force the negotiation over meaning.)\\n\"\n  },\n  \"notes-on-being-the-day-one-chip-leader\": {\n    \"title\": \"Notes on being the Day One chip leader\",\n    \"createdOn\": \"2022-10-10 19:06:00.995646\",\n    \"mdText\": \"## Notes on being the Day One chip leader\\n\\nSome decades ago David Sklansky published an essay called \\\"Why the First Day Chipleader at the WSOP Never Wins.\\\" \\nIt came to mind because Byrne Hobart wrote up [this essay](https://mailchi.mp/verdadcap/persistence-of-growth?utm_source=substack&utm_medium=email) about persistence. \\n(It turns out the *second* quintile of EBITDA growth does better than the first quintile according to Verdad's research.)\\n\\nIt's a fun comparison: in some situations, and not just toy examples, the best performance is correlated with worse outcomes than merely very good performance. \\n(Where else is this true?)\\n\\nThe essay is very old, by now, and does not apply directly to the modern game. \\nHere are some updates:\\n\\n1. The conclusion no longer holds: day one chipleaders do quite well. [Here](https://www.pokernews.com/news/2015/07/does-bagging-chip-lead-on-day-1-mean-success-22164.htm) is a PokerNews analysis noting that both Joe Cada and Martin Jacobson won after chipleading Day 1. \\n1. But there is not quite such a thing as \\\"*the* Day One chipleader\\\" any more, because the Main Event is held with several starting flights (with surviving players combining later).\\n1. Good tournament strategy is probably more aggressive than Sklansky foresaw.\\n1. Or, at least, excellent players are studying and implementing aggressive strategies much more often and more effectively than they were when Sklansky wrote that essay.\\n1. The Main Event is much bigger, so that the returns to having a huge stack are higher than they were when the fields were smaller. (There are roughly 10x as many entrants as there were 20 years ago.) Or, at least, the value of having a huge stack *and playing well thereafter* is much higher.\\n1. And because the field is bigger, being at the top of Day One is a bigger accomplishment.\\n1. I've only briefly checked my memory here, but I think the blinds go up more slowly than they used to, which means that large pots (especially those at the end of the day in 2022 as compared to 2002) on day one on average involve more skill than they used to.\\n1. And there are far more good players than there used to be. This means both that one of them has a better chance of coming out on top and that weak players playing manically are much more likely to get picked off at some point, even on the first day. (The previous point is relevant here too.)\\n\\nSo, Sklansky's point is still worth thinking about, but no longer straightforwardly applicable to the actual Main Event.\\n\"\n  },\n  \"12-rules-for-living\": {\n    \"title\": \"12 rules for living\",\n    \"createdOn\": \"2022-05-29 16:33:06.924711\",\n    \"mdText\": \"## 12 rules for living\\n\\nThis is my contribution to the \\\"write down twelve rules for life\\\" game as brilliantly played by, among others, [Tyler Cowen](https://marginalrevolution.com/marginalrevolution/2018/01/tyler-cowens-12-rules-life.html) and [Agnes Callard](https://twitter.com/AgnesCallard/status/1503108298349838336?s=20&t=wqblwUxYEam_eSMxJd65nQ). (Update 2022-02-09: [Lisie Lillianfeld's](https://lisielilli.medium.com/12-rules-for-life-df3593099c3f) is great.)\\n\\n1. Whenever possible, ask: \\\"should I do this same thing again and again?\\\" Getting compound returns is great. Getting diminishing returns is bad. Doing more and more of the same thing tends to get you one or the other, and figuring out which situation you\\u2019re in is often very tricky. Work at it.\\n1. Write every day.\\n1. Minimize the time you spend thinking about food. Have default meals, think twice before spending a lot of time cooking, and so on. Food is great, but the other stuff I can do with that time and energy is even better. And when it comes time to cook or dine with friends, it\\u2019s that much more enjoyable. (OK, maybe you really like food. In that case, is there something else you can cut ~80% of the time investment out of?)\\n1. Whenever possible, ask: \\\"Does the Coase Theorem apply here?\\\"\\n1. Just try to get a lot of high-quality stuff into your brain. Try to understand it, of course, but don\\u2019t worry too much about that, because getting whatever you can out of something really great is usually better than a fuller experience of something mediocre. So, for example, listen to a lot of great music even if you don\\u2019t understand music very well.\\n1. Whenever possible, ask if the causal order of things is other than it appears to be. (Really try to do this. If I don\\u2019t ask myself such questions several times a day, it\\u2019s probably because I\\u2019m being sloppy.)\\n1. Read a lot. Worry a lot about the quality of what you read, but not so much that it paralyzes you. Reread a lot (see (1), (5), and (8)).\\n1. Divide your attention so that you get a little bit of exposure to a lot of things and very deep knowledge of a few things. (See (1).)\\n1. Find some people whose thinking you appreciate, enjoy, and easily ingest. Consume everything they put out, several times if necessary, and think about it carefully. (See (1).)\\n1. When you\\u2019re thinking about a belief someone else holds, ask whether it\\u2019s a \\\"coherence belief,\\\" believed because it flows naturally from other commitments, or a \\\"portfolio belief,\\\" believed because it somehow balances out other commitments (e.g., in being more politically palatable). This is often the key to really understanding what is being expressed and what the relevant commitments are. Relatedly: Get relatively much parenting advice from books and experts and relatively little from other parents.\\n1. Have a lot of daily habits and maintain good to-do lists. Relatedly: for any length of time, have a productive default activity available for that length of time.\\n1. About common behaviors, ask: \\\"Is this mere orthodoxy, some sort of [Chesterton\\u2019s fence](https://wiki.lesswrong.com/wiki/Chesterton%27s_Fence), both, or neither?\\\" It\\u2019s *really* important and *really* hard to figure out whether you have good reason to do what everyone else is doing. And these decisions come up all the time.\\n\"\n  },\n  \"reading-notes-patterns-of-software\": {\n    \"title\": \"Reading notes: Patterns of Software\",\n    \"createdOn\": \"2022-05-29 16:33:06.928870\",\n    \"mdText\": \"## Reading notes: Patterns of Software\\n\\nI'll probably never finish Richard Gabriel's *Patterns of Software: Tales from the Software Community*. The core of the book (or at least the first 1/3 of it) is a meditation on the career of [Christopher Alexander](https://en.wikipedia.org/wiki/Christopher_Alexander) can teach us about software design.\\n\\nGabriel's turns of phrase tend not to land with me, partly because the technical discussion doesn't include examples or sufficiently precise argumentation about software. There are enough mechanical errors (at least in my edition) to distract the reader, and the structure of the book (a series of titled, related semi-essays) works against my attempts to synthesize the information.\\n\\nBut I'm glad this book exists. It reminds me of poker literature. When I studied poker most seriously, it was immature as a field of study, with an oral tradition of knowledge-transmission and enthusiastic practitioners. This led to a lot of technical and semi-technical writing that is unconstrained by traditional subgenre boundaries. Such projects don't always succeed or endure, but the practical alternative to this kind of artifact is usually not a polished, impeccably structured book but rather nothing at all.\\n\\nSo, in the case of Richard Gabriel, if someone loves software, loves architecture, and wants to write a long meditation on the connections between the ineffable qualities of great software and the career of Christopher Alexander, I really want that person to write that meditation. My life is better because [Barry Greenstein wrote something that reminds me of Seneca more than anything else](https://www.amazon.com/Ace-River-Advanced-Poker-Guide/dp/0972044221), Bob Ciaffone saw fit to publish [occasionally speculative advice](https://www.amazon.com/Improve-Your-Poker-Bob-Ciaffone/dp/0966100700) back in 1997--and because poker literature was unsaturated enough to have some room for [my own self-published speculations](https://www.amazon.com/Thinking-Tournament-Poker-Nate-Meyvis-ebook/dp/B017MTTGYC/). It's also better because I picked up this book. I just can't finish it.\\n\\nSome notes:\\n\\n1. Gabriel speaks of *habitability* in software design. Michael Feathers gives an related warning: \\\"Remember, code is your house, and you have to live in it.\\\" Feathers is talking about hygiene where Gabriel is discussing something less tangible, and the continuity of the metaphor is striking. It has infiltrated my work: every day I think of myself as *living in* the software I work on.\\n1. Gabriel says that clarity \\\"is just too rare, and it's dangerous too, in a funny way.\\\" This is nonobvious and correct (and I want to post it in every building where analytic philosophers work). Aristotle famously warns us to tailor the precision of our descriptions to the underlying subject matter: Don't settle for mere persuasion if you're discussing geometry, but also don't expect geometrical proof if you're talking about the weather. We want clarity in software, but only insofar as it's there to be achieved. Suppose an argument already has as much clarity as it's going to get. If you try to add more, something will go wrong: you'll think you're adding clarity but actually be adding something else, or you really *will* be adding clarity but *about the wrong thing*. Either way, the whole suffers. In software, this kind of misguided aim at clarity can lead to extra objects, APIs with too many parameters, and unhelpful type systems. Often the clarity comes in the wrong layer or at the wrong level: [this argument](an-argument-from-jimmy-koppel.html) is, again, relevant.\\n1. Suppose it's true that \\\"it is rarely possible for a programmer to take an arbitrary class and derive a new, useful, and correct subtype from it, unless that subtype is of a very specific [intended] kind.\\\" What would follow from that? Compare Item 18 of *Effective Java*, where Bloch claims that \\\"inheritance violates encapsulation\\\" and famously advocates for composition over inheritance.\\n1. Alexander and his group once gathered 390 requirements for \\\"what ought to be happening near\\\" a ticket booth. I have never worked on a project where the requirements were not much more extensive than my intuition initially suggested. It's safe to assume there are more requirements than you think there are. (Relevant: [this case study](https://web.eecs.utk.edu/~azh/blog/thisprojectwillonlytake.html) that recently made the rounds.)\\n\"\n  },\n  \"on-using-anki\": {\n    \"title\": \"On using Anki\",\n    \"createdOn\": \"2022-05-29 16:33:06.930837\",\n    \"mdText\": \"## On using Anki\\n\\nAnki is software that helps you remember things. It is used largely by people with idiosyncratic and extreme self-development goals. Much of what you can read about Anki therefore recommends idiosyncratic and extreme behavior.\\n\\nBut we all want to remember at least *some* facts: that thing we keep needing to look up at work, our cousins' birthdays, or whatever. And Anki is the most efficient way to remember facts. So Anki is useful for just about anyone.\\n\\nThat argument is the memory-management analogue of \\\"if you can't afford a good lawyer, you *certainly* can't afford a bad one.\\\" If you don't want to spend effort memorizing things, software that minimizes the effort per thing remembered is what you want, even if other people use the software to increase the denominator when what you want is to decrease the numerator.\\n\\n#### Miscellaneous notes\\n1. Don't worry about duplicating cards. You'll simply see each of the duplicates less often, and this will approximate there being just one card with that information. It's probably *better* to have cards duplicating information but presented slightly differently, so that your brain doesn't latch on to the presentation so easily.\\n1. All else equal, switch up the physical context in which you study cards (again, to encourage your brain to learn a connection between a prompt and a fact, not a connection between some wallpaper and a fact).\\n1. I like using fewer decks, more loosely organized, so that (i) I don't spend as much time clicking between decks and (ii) there are fewer accidental patterns in the clustering of cards I review.\\n1. When I'm reviewing a new batch of cards, I \\\"jitter\\\" the review times--e.g., by finding some to mark as \\\"easy\\\" and others not. This makes them pop back up on different days. (Adding some random variation to the review interval seems exactly like a feature Anki would already have, but I've scoured the preferences and am pretty sure it's not there.) [Update 2021-12-19: There is such a feature, and it's called \\\"fuzz factor,\\\" and [its behavior is changing](https://faqs.ankiweb.net/the-2021-scheduler.html). I still find myself needing to jitter things manually. Thanks to David Allison for the information.]\\n1. Unless you are in med school or a language learner, most publicly available decks are not as good as what you can make yourself. It's probably most time-efficient to simply roll your own. An advanced clipboard manager is your friend here (and, for that matter, everywhere).\\n1. Don't put too much information in the prompt: again, it's an invitation to form an association with an incidental pattern. This is a particular problem with automatically generated decks.\\n\"\n  },\n  \"on-self-experimentation-in-spaced-repetition\": {\n    \"title\": \"On self-experimentation in spaced repetition\",\n    \"createdOn\": \"2022-05-29 16:33:06.933153\",\n    \"mdText\": \"## On self-experimentation in spaced repetition\\n\\nI [love Anki](on-using-anki.html) but am sufficiently devoted to spaced repetition to want more control over my training. I now spend over half my memory-training time in a custom tool.\\n\\nThis tool uses a much simpler scheduling algorithm: in the case of a correct answer after an interval of length *L*, the question comes up for review *e* * *L* later, where *e* is Euler's constant. So, if I answer a prompt correctly 5 days after I last saw it, it will come due in roughly 13.6 days. (Except if *L* is very short--there's a minimum interval of one day.)\\n\\nThis is a *very* primitive system, and I'm not interested in arguing that it's better than any existing algorithm. It has these virtues, though:\\n\\n1. It's simple enough to have implemented and tested fairly quickly. Minor and even moderate flaws in the system are acceptable, but major flaws are not.\\n1. It's working surprisingly well. The reviews it schedules tend to be tougher than the ones Anki suggests on a given day.\\n1. Its flaws should be easier to fix in a natural way. I have often overlooked this feature of simpler systems. Ockham's razor is often presented as a guide to *truth*; other exhortations to simplicity are often justified in terms of *cost*. This is more a benefit of *natural diagnosis*.\\n1. It provides a benchmark against which more complicated algorithms can be tested. (This is a useful feature I associate with [Marcel](http://tangotiger.net/marcel/). If any baseball analysts are out there looking for a project, I think there's some relatively low-hanging fruit available in optimizing the various constants that appear in the Marcel system.)\\n\\nI suspect that the best systems are likely to use machine learning in some form. It took me a long time to come to believe this: existing algorithms have their roots in, for example, systems for [moving physical cards between boxes](https://en.wikipedia.org/wiki/Leitner_system). These algorithms make a certain kind of sense. Their features are each intuitively motivated, and there are enough of them to make you think that the real-world phenomenon is being captured sufficiently well.\\n\\nBut *we have computers now*. The way to work *with* the computer, rather than against it, is often to keep it very simple until it can be totally inscrutable.\\n\"\n  },\n  \"on-stop-losses\": {\n    \"title\": \"On stop-losses\",\n    \"createdOn\": \"2022-09-09 09:29:53.851740\",\n    \"mdText\": \"## On stop-losses\\n\\nByrne Hobart has [a useful analysis](https://www.thediff.co/p/stop-losses-as-intellectual-honesty) [$] of stop-losses today. It's as fun as it is useful.\\n\\nPoker players have long used (and debated, and been proud about *not* using) stop-losses. How do Byrne's points look through the poker lens?\\n\\nFirst, a big loss means that your leverage has changed. The (rough) poker translation of this is that your edge in a game *relative to your bankroll* has changed. This is strikingly absent from a lot of poker discussion. But a large loss is often at least 10% of a reasonable bankroll, and often a much bigger portion of the bankroll someone is *actually* using. Even if there's still a justification for playing the game, the decision relative to some smaller game often looks different.\\n\\nSecond, a big loss means that there's information you're missing, so persisting includes a tax on your finite attention. Sometimes this just isn't true in poker (if, e.g., your loss is due to simple bad beats). But this is more true than poker players think: game conditions when you're losing are often different than you took them to be. And even if they *weren't*, the fact of the loss itself changes them, because people play differently against opponents with losing images than with winning ones.\\n\\nThe way I've often thought about this is different still, but related to each of these. When you observe an extreme outlier, you should usually vastly reduce your credence in the model with respect to which the event counts as an outlier. In crude terms: suppose that you're 95% sure that some model of the situation is right. If you observe an event that is a four-sigma outlier according to the model but much less likely if the model is wrong, then (by Bayes' theorem) your model is almost certainly wrong. So if you were making commitments on the basis of that model, you should stop doing so.\\n\\nIn poker terms: if you're stuck that bad, it's much likelier than you thought that (i) you're on tilt, (ii) you're not as good as you think you are, (iii) you're not as good *in that game* as you think you are, (iv) you're getting cheated, or (v) something else is going on that you haven't even thought of.\\n\\nAbout a decade ago, it happened pretty often that baseball teams were making comebacks (to win divisions or make playoffs) that the preferred models suggested were 100:1 (or much worse) underdogs. It was disappointing to me how many people accepted the conclusion that they were living in an age of miracles. They would have done better to reject the models.\\n\"\n  },\n  \"illustrative-epistemic-mistakes-people-made-with-the-j4-hand\": {\n    \"title\": \"Illustrative epistemic mistakes people made with the J4 hand\",\n    \"createdOn\": \"2022-10-09 06:35:02.352195\",\n    \"mdText\": \"## Illustrative epistemic mistakes people made with the J4 hand\\n\\nThe Robbi Jade Lew / J4 episode brought out some good analysis and much bad analysis. \\nMany of the analytic mistakes were not about strategic or other specific evidential details, but structural errors in reasoning under uncertainty. \\nHere is a partial list.\\n\\n1. Ignoring base rates. (I discuss this more [here](notes-on-the-garrett-adelstein---robbi-jade-lew-hand.html) and [here](why-my-priors-about-cheating-at-poker-are-so-high.html).)\\n1. Conflating unconditional and conditional probabilities. Many people on both sides said that some piece of evidence was very unlikely given some scenario--either that there was cheating or that there was not cheating. Often, these claims were perfectly true but ignored the fact that the evidence was also very unlikely under *any* scenario. What mattered was the likelihood ratio of the evidence, not simply its likelihood given some hypothesis or other.\\n1. Ignoring correlation. (See [here](https://twitter.com/NateMeyvis/status/1578324019405025281?s=20&t=aBEiMRcuNZCrbFtZTFO8Yw).)\\n1. Ignoring the context. Expected behavior is simply different at very high stakes. I am not an expert about the nuances of high-stakes culture or the politics of getting into streamed games, but far too many people extrapolated from their own poker experience or what they see of the highest-stakes games they know a lot about. This caused people to reason poorly about, among other things, (i) the probability of a misread in a big pot, (ii) the likelihood that an honest player or a dishonest one would be given a 50% freeroll on a stake in a game, (iii) the likelihood that a weak amateur could win over two sessions against an uneven lineup including very top professionals, and (iv) the motivation to cheat. I was guilty of this in not thinking about (ii) as rigorously as I should have: although I initially thought the stake was suspicious, I mostly shrugged my shoulders and thought that very strange financial arrangements often happen in poker.\\n1. Ignoring history. This is closely related to ignoring base rates. It is irresponsible to claim that a cheater \\\"would never\\\" do something that *is in fact what cheaters have been observed doing.* As is so often the case, a bit of research is worth a lot of raw intelligence when you're trying to reason accurately.\\n\\nThere were also the usual emotional and political issues: getting stubborn, ignoring inconvenient evidence, disguising expressions of political affiliation as dispassionate analysis, and so on. But what is striking to me is the poor display of epistemic fundamentals even among people who seemed not to be suffering from those.\\n\"\n  },\n  \"on-type-safety-in-natural-language\": {\n    \"title\": \"On type safety in natural language\",\n    \"createdOn\": \"2022-06-14 13:52:33.625809\",\n    \"mdText\": \"## On type safety in natural language\\n\\nByrne Hobart has [a characteristically fun and insightful piece](https://www.thediff.co/p/type-safe-internal-communications) [$] analogizing the \\\"[four Amazon answers](https://twitter.com/nipunmehra/status/1154590521345490945)\\\" to types in programming.\\n\\nSome reactions:\\n\\n1. As [I've written](on-talking-to-think-better.html), many of us pay too little attention to military traditions and to radiotelephony conventions when we're thinking about clear, mind-improving communication. It's no coincidence Socrates obsessed over communicative \\\"rules of the dance.\\\"\\n1. But the lesson I'd draw is a bit different: what's important is often getting communicators in the right *roles*, not improving the precision of a given response. I'm [tempted to believe that](on-dependencies.html) the problem of dependency management is prior to, and harder than, the problem of improving accuracy and precision. (And that this is [less sensitive to scale](on-dependencies-in-small-projects.html) that you might think.)\\n1. This makes sense, because types are only one way, and [in practice often not a reliable one](listening-notes-jason-strasser-on-the-risk-of-ruin-podcast.html), to achieve accuracy in software. Moreover, the kind of accuracy it gets you is often misunderstood, because it's very hard to make the guarantees of a type system extend to relevant, valuable guarantees [at the logical level](an-argument-from-jimmy-koppel.html).\\n1. So, while ambition and stronger typing might be correlated, I'd be more guarded than Byrne is when he says that \\\"type-safe programs can be bigger, and the organizations that insist on them are implicitly more ambitious than the ones that don't.\\\" Programs *that have good correctness checks* can be bigger: stronger typing is one way to accomplish this, but only one. Good testing is another approach (I don't mean to imply that it's an orthogonal one). And I've seen strong typing *prevent* a code base from growing: complicated, ill-defined types can be so brittle that engineers either (i) leave the code in place, unable to change the types, or (ii) switch all those complicated types to `Any` (or some analogue of `Any`) when they need to change something.\\n1. I'm tempted to think of the Amazon approach less as a restriction *on communication* and more as a restriction *on email*. Certain questions can't be answered well, or at least felicitously, with one of the four answers (\\\"do you think that John Doe will be back to full productivity soon?\\\"). One way to think about this policy is as pressure to keep conversations off email that for legal reasons should not be conducted over email.\\n1. Further evidence for this is that many more companies than Amazon enforce similarly strong \\\"typing\\\" in other software (e.g., time estimates in JIRA). It's not clear how much this benefits them, especially if you try to control for other cultural factors.\\n1. Yet further evidence: big tech companies are famous for intellectual cross-pollination. Yet most non-Amazon FAANG employees (I'd bet) do not know about the \\\"four email answers\\\" policy, but many of them really hate and discourage email. I think this says something about what the policy's real effect and purpose is. (Is it four answers too many? Extending the typing analogy, perhaps \\\"the best code is no code at all.\\\")\\n1. People (I'm not implying Byrne is one of them) sometimes act as if the code-quality effects of strong typing are empirically proven. I do not think this belief can survive an honest encounter with [Dan Luu's literature review](https://danluu.com/empirical-pl/).\\n\"\n  },\n  \"2022-reading-review\": {\n    \"title\": \"2022 reading review\",\n    \"createdOn\": \"2022-09-22 12:52:15.475744\",\n    \"mdText\": \"## 2022 reading review\\n\\n3/4 of the way through a wonderful year of reading, I've had time to think about the books again. \\nIn many cases I think my initial thoughts, either about the book itself or its likely long-term effects on me, were wrong.\\n\\nHere are some new thoughts about various books. \\nThe most striking trend to me is that novels that I love when I read them fade from my intellectual view faster than I'd thought they would. (I didn't even bother revisiting *The Three-Body Problem*, and I haven't for a second thought about picking up either of the sequels, even though I enjoyed the book very much and think highly of it.)\\n\\n#### The Nineties\\n\\nI'd say I got this one very wrong when I first reviewed it. \\nThis is likely for two reasons: Chuck Klosterman is an excellent prose stylist and I love reading about the nineties. \\n(Actually, being a nineties kid is one of the parts of my identity I hold most deeply, but enough about that for now.) \\nBut as I review the book, I think of it as a series of fun, smart GenX takes on the nineties, with too little attention to the mass culture of the decade. \\nKlosterman doesn't mention the Macarena, the Backstreet Boys, the Kosovo War, or \\\"MmmBOP.\\\"\\nWhen he mentions the fact that _Cracked Rear View_ sold 21 million copies, he dismisses it (and related mega-hits) as \\\"historical misdirection.\\\" \\nWhat was really happening, Klosterman says, is that rock music was losing its \\\"dominance... as an ideology.\\\" \\nThat's probably true. \\nBut a lot of culture and a lot of influence happened during that shift. \\nIt accounts for a lot of what the nineties were about and felt like. \\nSo, whatever this book's merits, it's not a sustained and successful treatment of what the decade was all about.\\n\\n\\n#### Lonesome Dove ([initial review](reading-notes-lonesome-dove.html))\\n\\nI just finished this one a few weeks ago. \\nI still believe it to be a great book. \\nThe epigram seems to me to get the themes right: its significance to me is as a treatment of freedom, law, choice, and the relationship between all of those.\\n\\nIt is remarkable how unfree many of the characters seem, and not just because they might die at any moment. \\nTheir choices often seem, if not forced upon them, not the product of anything we would recognize as personal deliberation.\\n\\nThe defining image of _Lonesome Dove_ might be that of a human riding a horse, asleep on or tied to it. Perhaps they want to be there; perhaps they chose to be there (directly or indirectly, recently or long ago); perhaps not. Some combination of human, horse, and other natural forces will take them somewhere. They are quasi-free. They could really use some good institutions.\\n\\n(That epigram: \\\"All America lies at the end of the wilderness road, and our past is not a dead past, but still lives in us. \\nOur forefathers had civilization inside themselves, the wild outside. We live in the civilization they created, but within us the wilderness still lingers. \\nWhat they dreamed, we live, and what they lived, we dream.\\\")\\n\\n\\n#### Crossroads\\n\\nI think I overestimated this one, too. It's an admirable, meaningful novel, but for whatever reason it just hasn't stuck with me. \\nAn exception: the character of Russ Hildebrandt pops to mind often, and with him Franzen really hit a certain strain of semi-well-intentioned, pathetic psychology worth digging into.\\n\\nI stand my my view that the book is a sort of exploration of ethical spaces that the contemporary political landscape doesn't permit and, simultaneously, a damning critique of ethical life (especially mainstream masculine ethical life) before it was modified by contemporary political awareness.\\n\\n\\n#### How to Change ([initial review](reading-notes-how-to-change.html))\\n\\nI still think it's in the top tier of this kind of pop science / self-help book, but I'm struck by how little I retained. \\nI'll say it's my failure, not the book's.\\n\\n\\n#### From Front Porch to Back Seat ([initial review](reading-notes-from-front-porch-to-back-seat.html))\\n\\nI'll stand by my initial impressions here. \\nI'd now add that I think I have a much more nuanced view about the sociology of monogamy and the economic roots and effects of \\\"going out\\\" as a mode of dating (one among many).\\n\\n\\n#### The End of Solitude ([initial review](reading-notes-the-end-of-solitude.html))\\n\\nI read this only recently, but I don't want to revise anything I said, especially the praise. \\nOne idea from the book that's particularly stuck: that college coursework and other traditional infrastructure is a mere vestige, which few parties to those courses have much reason to care about, and onto which a certain kind of elite training is being \\\"retrofitted.\\\"\\n\\n\\n#### Talent ([initial review](reading-notes-talent.html))\\n\\nI'll stand by my initial impressions here, too. I still view this primarily as a book about cultivating and testing my own skills.\\n\\nOne broader point is that I think of *Talent*, *Crossroads*, and to some extent even *The Nineties* as books not just related to but *about* the systematic oppression of people who are not white men; if my quick tally is correct, over half of the books I've read that have been written in the last couple years fit this description. Culture is a powerful thing.\\n\\n\"\n  },\n  \"reading-notes-lonesome-dove\": {\n    \"title\": \"Reading notes: Lonesome Dove\",\n    \"createdOn\": \"2022-08-15 18:57:24.584994\",\n    \"mdText\": \"## Reading notes: Lonesome Dove\\n\\nThis is the best thing I've read in 2022, which is shaping up to be the best reading year of my adult life. Easy [top 100](100-books.html) book: probably #25 or so, though I'm historically bad at predicting the staying power of a book I just read.\\n\\nI have very little original to say about the book, except that it is more evidence about [the value of long books](on-long-books.html).\\n\\nVery highly recommended.\\n\"\n  }\n};","/**\n * @typedef Options\n *   Configuration.\n * @property {boolean | null | undefined} [jsx=false]\n *   Support JSX identifiers (default: `false`).\n */\n\nconst startRe = /[$_\\p{ID_Start}]/u\nconst contRe = /[$_\\u{200C}\\u{200D}\\p{ID_Continue}]/u\nconst contReJsx = /[-$_\\u{200C}\\u{200D}\\p{ID_Continue}]/u\nconst nameRe = /^[$_\\p{ID_Start}][$_\\u{200C}\\u{200D}\\p{ID_Continue}]*$/u\nconst nameReJsx = /^[$_\\p{ID_Start}][-$_\\u{200C}\\u{200D}\\p{ID_Continue}]*$/u\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Checks if the given code point can start an identifier.\n *\n * @param {number | undefined} code\n *   Code point to check.\n * @returns {boolean}\n *   Whether `code` can start an identifier.\n */\n// Note: `undefined` is supported so you can pass the result from `''.codePointAt`.\nexport function start(code) {\n  return code ? startRe.test(String.fromCodePoint(code)) : false\n}\n\n/**\n * Checks if the given code point can continue an identifier.\n *\n * @param {number | undefined} code\n *   Code point to check.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {boolean}\n *   Whether `code` can continue an identifier.\n */\n// Note: `undefined` is supported so you can pass the result from `''.codePointAt`.\nexport function cont(code, options) {\n  const settings = options || emptyOptions\n  const re = settings.jsx ? contReJsx : contRe\n  return code ? re.test(String.fromCodePoint(code)) : false\n}\n\n/**\n * Checks if the given value is a valid identifier name.\n *\n * @param {string} name\n *   Identifier to check.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {boolean}\n *   Whether `name` can be an identifier.\n */\nexport function name(name, options) {\n  const settings = options || emptyOptions\n  const re = settings.jsx ? nameReJsx : nameRe\n  return re.test(name)\n}\n","/**\n * @typedef {import('hast').Nodes} Nodes\n */\n\n// HTML whitespace expression.\n// See <https://infra.spec.whatwg.org/#ascii-whitespace>.\nconst re = /[ \\t\\n\\f\\r]/g\n\n/**\n * Check if the given value is *inter-element whitespace*.\n *\n * @param {Nodes | string} thing\n *   Thing to check (`Node` or `string`).\n * @returns {boolean}\n *   Whether the `value` is inter-element whitespace (`boolean`): consisting of\n *   zero or more of space, tab (`\\t`), line feed (`\\n`), carriage return\n *   (`\\r`), or form feed (`\\f`); if a node is passed it must be a `Text` node,\n *   whose `value` field is checked.\n */\nexport function whitespace(thing) {\n  return typeof thing === 'object'\n    ? thing.type === 'text'\n      ? empty(thing.value)\n      : false\n    : empty(thing)\n}\n\n/**\n * @param {string} value\n * @returns {boolean}\n */\nfunction empty(value) {\n  return value.replace(re, '') === ''\n}\n","/**\n * @typedef {import('./info.js').Info} Info\n * @typedef {Record<string, Info>} Properties\n * @typedef {Record<string, string>} Normal\n */\n\nexport class Schema {\n  /**\n   * @constructor\n   * @param {Properties} property\n   * @param {Normal} normal\n   * @param {string} [space]\n   */\n  constructor(property, normal, space) {\n    this.property = property\n    this.normal = normal\n    if (space) {\n      this.space = space\n    }\n  }\n}\n\n/** @type {Properties} */\nSchema.prototype.property = {}\n/** @type {Normal} */\nSchema.prototype.normal = {}\n/** @type {string|null} */\nSchema.prototype.space = null\n","/**\n * @typedef {import('./schema.js').Properties} Properties\n * @typedef {import('./schema.js').Normal} Normal\n */\n\nimport {Schema} from './schema.js'\n\n/**\n * @param {Schema[]} definitions\n * @param {string} [space]\n * @returns {Schema}\n */\nexport function merge(definitions, space) {\n  /** @type {Properties} */\n  const property = {}\n  /** @type {Normal} */\n  const normal = {}\n  let index = -1\n\n  while (++index < definitions.length) {\n    Object.assign(property, definitions[index].property)\n    Object.assign(normal, definitions[index].normal)\n  }\n\n  return new Schema(property, normal, space)\n}\n","/**\n * @param {string} value\n * @returns {string}\n */\nexport function normalize(value) {\n  return value.toLowerCase()\n}\n","export class Info {\n  /**\n   * @constructor\n   * @param {string} property\n   * @param {string} attribute\n   */\n  constructor(property, attribute) {\n    /** @type {string} */\n    this.property = property\n    /** @type {string} */\n    this.attribute = attribute\n  }\n}\n\n/** @type {string|null} */\nInfo.prototype.space = null\nInfo.prototype.boolean = false\nInfo.prototype.booleanish = false\nInfo.prototype.overloadedBoolean = false\nInfo.prototype.number = false\nInfo.prototype.commaSeparated = false\nInfo.prototype.spaceSeparated = false\nInfo.prototype.commaOrSpaceSeparated = false\nInfo.prototype.mustUseProperty = false\nInfo.prototype.defined = false\n","let powers = 0\n\nexport const boolean = increment()\nexport const booleanish = increment()\nexport const overloadedBoolean = increment()\nexport const number = increment()\nexport const spaceSeparated = increment()\nexport const commaSeparated = increment()\nexport const commaOrSpaceSeparated = increment()\n\nfunction increment() {\n  return 2 ** ++powers\n}\n","import {Info} from './info.js'\nimport * as types from './types.js'\n\n/** @type {Array<keyof types>} */\n// @ts-expect-error: hush.\nconst checks = Object.keys(types)\n\nexport class DefinedInfo extends Info {\n  /**\n   * @constructor\n   * @param {string} property\n   * @param {string} attribute\n   * @param {number|null} [mask]\n   * @param {string} [space]\n   */\n  constructor(property, attribute, mask, space) {\n    let index = -1\n\n    super(property, attribute)\n\n    mark(this, 'space', space)\n\n    if (typeof mask === 'number') {\n      while (++index < checks.length) {\n        const check = checks[index]\n        mark(this, checks[index], (mask & types[check]) === types[check])\n      }\n    }\n  }\n}\n\nDefinedInfo.prototype.defined = true\n\n/**\n * @param {DefinedInfo} values\n * @param {string} key\n * @param {unknown} value\n */\nfunction mark(values, key, value) {\n  if (value) {\n    // @ts-expect-error: assume `value` matches the expected value of `key`.\n    values[key] = value\n  }\n}\n","/**\n * @typedef {import('./schema.js').Properties} Properties\n * @typedef {import('./schema.js').Normal} Normal\n *\n * @typedef {Record<string, string>} Attributes\n *\n * @typedef {Object} Definition\n * @property {Record<string, number|null>} properties\n * @property {(attributes: Attributes, property: string) => string} transform\n * @property {string} [space]\n * @property {Attributes} [attributes]\n * @property {Array<string>} [mustUseProperty]\n */\n\nimport {normalize} from '../normalize.js'\nimport {Schema} from './schema.js'\nimport {DefinedInfo} from './defined-info.js'\n\nconst own = {}.hasOwnProperty\n\n/**\n * @param {Definition} definition\n * @returns {Schema}\n */\nexport function create(definition) {\n  /** @type {Properties} */\n  const property = {}\n  /** @type {Normal} */\n  const normal = {}\n  /** @type {string} */\n  let prop\n\n  for (prop in definition.properties) {\n    if (own.call(definition.properties, prop)) {\n      const value = definition.properties[prop]\n      const info = new DefinedInfo(\n        prop,\n        definition.transform(definition.attributes || {}, prop),\n        value,\n        definition.space\n      )\n\n      if (\n        definition.mustUseProperty &&\n        definition.mustUseProperty.includes(prop)\n      ) {\n        info.mustUseProperty = true\n      }\n\n      property[prop] = info\n\n      normal[normalize(prop)] = prop\n      normal[normalize(info.attribute)] = prop\n    }\n  }\n\n  return new Schema(property, normal, definition.space)\n}\n","import {create} from './util/create.js'\n\nexport const xlink = create({\n  space: 'xlink',\n  transform(_, prop) {\n    return 'xlink:' + prop.slice(5).toLowerCase()\n  },\n  properties: {\n    xLinkActuate: null,\n    xLinkArcRole: null,\n    xLinkHref: null,\n    xLinkRole: null,\n    xLinkShow: null,\n    xLinkTitle: null,\n    xLinkType: null\n  }\n})\n","import {create} from './util/create.js'\n\nexport const xml = create({\n  space: 'xml',\n  transform(_, prop) {\n    return 'xml:' + prop.slice(3).toLowerCase()\n  },\n  properties: {xmlLang: null, xmlBase: null, xmlSpace: null}\n})\n","/**\n * @param {Record<string, string>} attributes\n * @param {string} attribute\n * @returns {string}\n */\nexport function caseSensitiveTransform(attributes, attribute) {\n  return attribute in attributes ? attributes[attribute] : attribute\n}\n","import {caseSensitiveTransform} from './case-sensitive-transform.js'\n\n/**\n * @param {Record<string, string>} attributes\n * @param {string} property\n * @returns {string}\n */\nexport function caseInsensitiveTransform(attributes, property) {\n  return caseSensitiveTransform(attributes, property.toLowerCase())\n}\n","import {create} from './util/create.js'\nimport {caseInsensitiveTransform} from './util/case-insensitive-transform.js'\n\nexport const xmlns = create({\n  space: 'xmlns',\n  attributes: {xmlnsxlink: 'xmlns:xlink'},\n  transform: caseInsensitiveTransform,\n  properties: {xmlns: null, xmlnsXLink: null}\n})\n","import {booleanish, number, spaceSeparated} from './util/types.js'\nimport {create} from './util/create.js'\n\nexport const aria = create({\n  transform(_, prop) {\n    return prop === 'role' ? prop : 'aria-' + prop.slice(4).toLowerCase()\n  },\n  properties: {\n    ariaActiveDescendant: null,\n    ariaAtomic: booleanish,\n    ariaAutoComplete: null,\n    ariaBusy: booleanish,\n    ariaChecked: booleanish,\n    ariaColCount: number,\n    ariaColIndex: number,\n    ariaColSpan: number,\n    ariaControls: spaceSeparated,\n    ariaCurrent: null,\n    ariaDescribedBy: spaceSeparated,\n    ariaDetails: null,\n    ariaDisabled: booleanish,\n    ariaDropEffect: spaceSeparated,\n    ariaErrorMessage: null,\n    ariaExpanded: booleanish,\n    ariaFlowTo: spaceSeparated,\n    ariaGrabbed: booleanish,\n    ariaHasPopup: null,\n    ariaHidden: booleanish,\n    ariaInvalid: null,\n    ariaKeyShortcuts: null,\n    ariaLabel: null,\n    ariaLabelledBy: spaceSeparated,\n    ariaLevel: number,\n    ariaLive: null,\n    ariaModal: booleanish,\n    ariaMultiLine: booleanish,\n    ariaMultiSelectable: booleanish,\n    ariaOrientation: null,\n    ariaOwns: spaceSeparated,\n    ariaPlaceholder: null,\n    ariaPosInSet: number,\n    ariaPressed: booleanish,\n    ariaReadOnly: booleanish,\n    ariaRelevant: null,\n    ariaRequired: booleanish,\n    ariaRoleDescription: spaceSeparated,\n    ariaRowCount: number,\n    ariaRowIndex: number,\n    ariaRowSpan: number,\n    ariaSelected: booleanish,\n    ariaSetSize: number,\n    ariaSort: null,\n    ariaValueMax: number,\n    ariaValueMin: number,\n    ariaValueNow: number,\n    ariaValueText: null,\n    role: null\n  }\n})\n","import {\n  boolean,\n  overloadedBoolean,\n  booleanish,\n  number,\n  spaceSeparated,\n  commaSeparated\n} from './util/types.js'\nimport {create} from './util/create.js'\nimport {caseInsensitiveTransform} from './util/case-insensitive-transform.js'\n\nexport const html = create({\n  space: 'html',\n  attributes: {\n    acceptcharset: 'accept-charset',\n    classname: 'class',\n    htmlfor: 'for',\n    httpequiv: 'http-equiv'\n  },\n  transform: caseInsensitiveTransform,\n  mustUseProperty: ['checked', 'multiple', 'muted', 'selected'],\n  properties: {\n    // Standard Properties.\n    abbr: null,\n    accept: commaSeparated,\n    acceptCharset: spaceSeparated,\n    accessKey: spaceSeparated,\n    action: null,\n    allow: null,\n    allowFullScreen: boolean,\n    allowPaymentRequest: boolean,\n    allowUserMedia: boolean,\n    alt: null,\n    as: null,\n    async: boolean,\n    autoCapitalize: null,\n    autoComplete: spaceSeparated,\n    autoFocus: boolean,\n    autoPlay: boolean,\n    blocking: spaceSeparated,\n    capture: null,\n    charSet: null,\n    checked: boolean,\n    cite: null,\n    className: spaceSeparated,\n    cols: number,\n    colSpan: null,\n    content: null,\n    contentEditable: booleanish,\n    controls: boolean,\n    controlsList: spaceSeparated,\n    coords: number | commaSeparated,\n    crossOrigin: null,\n    data: null,\n    dateTime: null,\n    decoding: null,\n    default: boolean,\n    defer: boolean,\n    dir: null,\n    dirName: null,\n    disabled: boolean,\n    download: overloadedBoolean,\n    draggable: booleanish,\n    encType: null,\n    enterKeyHint: null,\n    fetchPriority: null,\n    form: null,\n    formAction: null,\n    formEncType: null,\n    formMethod: null,\n    formNoValidate: boolean,\n    formTarget: null,\n    headers: spaceSeparated,\n    height: number,\n    hidden: boolean,\n    high: number,\n    href: null,\n    hrefLang: null,\n    htmlFor: spaceSeparated,\n    httpEquiv: spaceSeparated,\n    id: null,\n    imageSizes: null,\n    imageSrcSet: null,\n    inert: boolean,\n    inputMode: null,\n    integrity: null,\n    is: null,\n    isMap: boolean,\n    itemId: null,\n    itemProp: spaceSeparated,\n    itemRef: spaceSeparated,\n    itemScope: boolean,\n    itemType: spaceSeparated,\n    kind: null,\n    label: null,\n    lang: null,\n    language: null,\n    list: null,\n    loading: null,\n    loop: boolean,\n    low: number,\n    manifest: null,\n    max: null,\n    maxLength: number,\n    media: null,\n    method: null,\n    min: null,\n    minLength: number,\n    multiple: boolean,\n    muted: boolean,\n    name: null,\n    nonce: null,\n    noModule: boolean,\n    noValidate: boolean,\n    onAbort: null,\n    onAfterPrint: null,\n    onAuxClick: null,\n    onBeforeMatch: null,\n    onBeforePrint: null,\n    onBeforeToggle: null,\n    onBeforeUnload: null,\n    onBlur: null,\n    onCancel: null,\n    onCanPlay: null,\n    onCanPlayThrough: null,\n    onChange: null,\n    onClick: null,\n    onClose: null,\n    onContextLost: null,\n    onContextMenu: null,\n    onContextRestored: null,\n    onCopy: null,\n    onCueChange: null,\n    onCut: null,\n    onDblClick: null,\n    onDrag: null,\n    onDragEnd: null,\n    onDragEnter: null,\n    onDragExit: null,\n    onDragLeave: null,\n    onDragOver: null,\n    onDragStart: null,\n    onDrop: null,\n    onDurationChange: null,\n    onEmptied: null,\n    onEnded: null,\n    onError: null,\n    onFocus: null,\n    onFormData: null,\n    onHashChange: null,\n    onInput: null,\n    onInvalid: null,\n    onKeyDown: null,\n    onKeyPress: null,\n    onKeyUp: null,\n    onLanguageChange: null,\n    onLoad: null,\n    onLoadedData: null,\n    onLoadedMetadata: null,\n    onLoadEnd: null,\n    onLoadStart: null,\n    onMessage: null,\n    onMessageError: null,\n    onMouseDown: null,\n    onMouseEnter: null,\n    onMouseLeave: null,\n    onMouseMove: null,\n    onMouseOut: null,\n    onMouseOver: null,\n    onMouseUp: null,\n    onOffline: null,\n    onOnline: null,\n    onPageHide: null,\n    onPageShow: null,\n    onPaste: null,\n    onPause: null,\n    onPlay: null,\n    onPlaying: null,\n    onPopState: null,\n    onProgress: null,\n    onRateChange: null,\n    onRejectionHandled: null,\n    onReset: null,\n    onResize: null,\n    onScroll: null,\n    onScrollEnd: null,\n    onSecurityPolicyViolation: null,\n    onSeeked: null,\n    onSeeking: null,\n    onSelect: null,\n    onSlotChange: null,\n    onStalled: null,\n    onStorage: null,\n    onSubmit: null,\n    onSuspend: null,\n    onTimeUpdate: null,\n    onToggle: null,\n    onUnhandledRejection: null,\n    onUnload: null,\n    onVolumeChange: null,\n    onWaiting: null,\n    onWheel: null,\n    open: boolean,\n    optimum: number,\n    pattern: null,\n    ping: spaceSeparated,\n    placeholder: null,\n    playsInline: boolean,\n    popover: null,\n    popoverTarget: null,\n    popoverTargetAction: null,\n    poster: null,\n    preload: null,\n    readOnly: boolean,\n    referrerPolicy: null,\n    rel: spaceSeparated,\n    required: boolean,\n    reversed: boolean,\n    rows: number,\n    rowSpan: number,\n    sandbox: spaceSeparated,\n    scope: null,\n    scoped: boolean,\n    seamless: boolean,\n    selected: boolean,\n    shadowRootClonable: boolean,\n    shadowRootDelegatesFocus: boolean,\n    shadowRootMode: null,\n    shape: null,\n    size: number,\n    sizes: null,\n    slot: null,\n    span: number,\n    spellCheck: booleanish,\n    src: null,\n    srcDoc: null,\n    srcLang: null,\n    srcSet: null,\n    start: number,\n    step: null,\n    style: null,\n    tabIndex: number,\n    target: null,\n    title: null,\n    translate: null,\n    type: null,\n    typeMustMatch: boolean,\n    useMap: null,\n    value: booleanish,\n    width: number,\n    wrap: null,\n    writingSuggestions: null,\n\n    // Legacy.\n    // See: https://html.spec.whatwg.org/#other-elements,-attributes-and-apis\n    align: null, // Several. Use CSS `text-align` instead,\n    aLink: null, // `<body>`. Use CSS `a:active {color}` instead\n    archive: spaceSeparated, // `<object>`. List of URIs to archives\n    axis: null, // `<td>` and `<th>`. Use `scope` on `<th>`\n    background: null, // `<body>`. Use CSS `background-image` instead\n    bgColor: null, // `<body>` and table elements. Use CSS `background-color` instead\n    border: number, // `<table>`. Use CSS `border-width` instead,\n    borderColor: null, // `<table>`. Use CSS `border-color` instead,\n    bottomMargin: number, // `<body>`\n    cellPadding: null, // `<table>`\n    cellSpacing: null, // `<table>`\n    char: null, // Several table elements. When `align=char`, sets the character to align on\n    charOff: null, // Several table elements. When `char`, offsets the alignment\n    classId: null, // `<object>`\n    clear: null, // `<br>`. Use CSS `clear` instead\n    code: null, // `<object>`\n    codeBase: null, // `<object>`\n    codeType: null, // `<object>`\n    color: null, // `<font>` and `<hr>`. Use CSS instead\n    compact: boolean, // Lists. Use CSS to reduce space between items instead\n    declare: boolean, // `<object>`\n    event: null, // `<script>`\n    face: null, // `<font>`. Use CSS instead\n    frame: null, // `<table>`\n    frameBorder: null, // `<iframe>`. Use CSS `border` instead\n    hSpace: number, // `<img>` and `<object>`\n    leftMargin: number, // `<body>`\n    link: null, // `<body>`. Use CSS `a:link {color: *}` instead\n    longDesc: null, // `<frame>`, `<iframe>`, and `<img>`. Use an `<a>`\n    lowSrc: null, // `<img>`. Use a `<picture>`\n    marginHeight: number, // `<body>`\n    marginWidth: number, // `<body>`\n    noResize: boolean, // `<frame>`\n    noHref: boolean, // `<area>`. Use no href instead of an explicit `nohref`\n    noShade: boolean, // `<hr>`. Use background-color and height instead of borders\n    noWrap: boolean, // `<td>` and `<th>`\n    object: null, // `<applet>`\n    profile: null, // `<head>`\n    prompt: null, // `<isindex>`\n    rev: null, // `<link>`\n    rightMargin: number, // `<body>`\n    rules: null, // `<table>`\n    scheme: null, // `<meta>`\n    scrolling: booleanish, // `<frame>`. Use overflow in the child context\n    standby: null, // `<object>`\n    summary: null, // `<table>`\n    text: null, // `<body>`. Use CSS `color` instead\n    topMargin: number, // `<body>`\n    valueType: null, // `<param>`\n    version: null, // `<html>`. Use a doctype.\n    vAlign: null, // Several. Use CSS `vertical-align` instead\n    vLink: null, // `<body>`. Use CSS `a:visited {color}` instead\n    vSpace: number, // `<img>` and `<object>`\n\n    // Non-standard Properties.\n    allowTransparency: null,\n    autoCorrect: null,\n    autoSave: null,\n    disablePictureInPicture: boolean,\n    disableRemotePlayback: boolean,\n    prefix: null,\n    property: null,\n    results: number,\n    security: null,\n    unselectable: null\n  }\n})\n","import {\n  boolean,\n  number,\n  spaceSeparated,\n  commaSeparated,\n  commaOrSpaceSeparated\n} from './util/types.js'\nimport {create} from './util/create.js'\nimport {caseSensitiveTransform} from './util/case-sensitive-transform.js'\n\nexport const svg = create({\n  space: 'svg',\n  attributes: {\n    accentHeight: 'accent-height',\n    alignmentBaseline: 'alignment-baseline',\n    arabicForm: 'arabic-form',\n    baselineShift: 'baseline-shift',\n    capHeight: 'cap-height',\n    className: 'class',\n    clipPath: 'clip-path',\n    clipRule: 'clip-rule',\n    colorInterpolation: 'color-interpolation',\n    colorInterpolationFilters: 'color-interpolation-filters',\n    colorProfile: 'color-profile',\n    colorRendering: 'color-rendering',\n    crossOrigin: 'crossorigin',\n    dataType: 'datatype',\n    dominantBaseline: 'dominant-baseline',\n    enableBackground: 'enable-background',\n    fillOpacity: 'fill-opacity',\n    fillRule: 'fill-rule',\n    floodColor: 'flood-color',\n    floodOpacity: 'flood-opacity',\n    fontFamily: 'font-family',\n    fontSize: 'font-size',\n    fontSizeAdjust: 'font-size-adjust',\n    fontStretch: 'font-stretch',\n    fontStyle: 'font-style',\n    fontVariant: 'font-variant',\n    fontWeight: 'font-weight',\n    glyphName: 'glyph-name',\n    glyphOrientationHorizontal: 'glyph-orientation-horizontal',\n    glyphOrientationVertical: 'glyph-orientation-vertical',\n    hrefLang: 'hreflang',\n    horizAdvX: 'horiz-adv-x',\n    horizOriginX: 'horiz-origin-x',\n    horizOriginY: 'horiz-origin-y',\n    imageRendering: 'image-rendering',\n    letterSpacing: 'letter-spacing',\n    lightingColor: 'lighting-color',\n    markerEnd: 'marker-end',\n    markerMid: 'marker-mid',\n    markerStart: 'marker-start',\n    navDown: 'nav-down',\n    navDownLeft: 'nav-down-left',\n    navDownRight: 'nav-down-right',\n    navLeft: 'nav-left',\n    navNext: 'nav-next',\n    navPrev: 'nav-prev',\n    navRight: 'nav-right',\n    navUp: 'nav-up',\n    navUpLeft: 'nav-up-left',\n    navUpRight: 'nav-up-right',\n    onAbort: 'onabort',\n    onActivate: 'onactivate',\n    onAfterPrint: 'onafterprint',\n    onBeforePrint: 'onbeforeprint',\n    onBegin: 'onbegin',\n    onCancel: 'oncancel',\n    onCanPlay: 'oncanplay',\n    onCanPlayThrough: 'oncanplaythrough',\n    onChange: 'onchange',\n    onClick: 'onclick',\n    onClose: 'onclose',\n    onCopy: 'oncopy',\n    onCueChange: 'oncuechange',\n    onCut: 'oncut',\n    onDblClick: 'ondblclick',\n    onDrag: 'ondrag',\n    onDragEnd: 'ondragend',\n    onDragEnter: 'ondragenter',\n    onDragExit: 'ondragexit',\n    onDragLeave: 'ondragleave',\n    onDragOver: 'ondragover',\n    onDragStart: 'ondragstart',\n    onDrop: 'ondrop',\n    onDurationChange: 'ondurationchange',\n    onEmptied: 'onemptied',\n    onEnd: 'onend',\n    onEnded: 'onended',\n    onError: 'onerror',\n    onFocus: 'onfocus',\n    onFocusIn: 'onfocusin',\n    onFocusOut: 'onfocusout',\n    onHashChange: 'onhashchange',\n    onInput: 'oninput',\n    onInvalid: 'oninvalid',\n    onKeyDown: 'onkeydown',\n    onKeyPress: 'onkeypress',\n    onKeyUp: 'onkeyup',\n    onLoad: 'onload',\n    onLoadedData: 'onloadeddata',\n    onLoadedMetadata: 'onloadedmetadata',\n    onLoadStart: 'onloadstart',\n    onMessage: 'onmessage',\n    onMouseDown: 'onmousedown',\n    onMouseEnter: 'onmouseenter',\n    onMouseLeave: 'onmouseleave',\n    onMouseMove: 'onmousemove',\n    onMouseOut: 'onmouseout',\n    onMouseOver: 'onmouseover',\n    onMouseUp: 'onmouseup',\n    onMouseWheel: 'onmousewheel',\n    onOffline: 'onoffline',\n    onOnline: 'ononline',\n    onPageHide: 'onpagehide',\n    onPageShow: 'onpageshow',\n    onPaste: 'onpaste',\n    onPause: 'onpause',\n    onPlay: 'onplay',\n    onPlaying: 'onplaying',\n    onPopState: 'onpopstate',\n    onProgress: 'onprogress',\n    onRateChange: 'onratechange',\n    onRepeat: 'onrepeat',\n    onReset: 'onreset',\n    onResize: 'onresize',\n    onScroll: 'onscroll',\n    onSeeked: 'onseeked',\n    onSeeking: 'onseeking',\n    onSelect: 'onselect',\n    onShow: 'onshow',\n    onStalled: 'onstalled',\n    onStorage: 'onstorage',\n    onSubmit: 'onsubmit',\n    onSuspend: 'onsuspend',\n    onTimeUpdate: 'ontimeupdate',\n    onToggle: 'ontoggle',\n    onUnload: 'onunload',\n    onVolumeChange: 'onvolumechange',\n    onWaiting: 'onwaiting',\n    onZoom: 'onzoom',\n    overlinePosition: 'overline-position',\n    overlineThickness: 'overline-thickness',\n    paintOrder: 'paint-order',\n    panose1: 'panose-1',\n    pointerEvents: 'pointer-events',\n    referrerPolicy: 'referrerpolicy',\n    renderingIntent: 'rendering-intent',\n    shapeRendering: 'shape-rendering',\n    stopColor: 'stop-color',\n    stopOpacity: 'stop-opacity',\n    strikethroughPosition: 'strikethrough-position',\n    strikethroughThickness: 'strikethrough-thickness',\n    strokeDashArray: 'stroke-dasharray',\n    strokeDashOffset: 'stroke-dashoffset',\n    strokeLineCap: 'stroke-linecap',\n    strokeLineJoin: 'stroke-linejoin',\n    strokeMiterLimit: 'stroke-miterlimit',\n    strokeOpacity: 'stroke-opacity',\n    strokeWidth: 'stroke-width',\n    tabIndex: 'tabindex',\n    textAnchor: 'text-anchor',\n    textDecoration: 'text-decoration',\n    textRendering: 'text-rendering',\n    transformOrigin: 'transform-origin',\n    typeOf: 'typeof',\n    underlinePosition: 'underline-position',\n    underlineThickness: 'underline-thickness',\n    unicodeBidi: 'unicode-bidi',\n    unicodeRange: 'unicode-range',\n    unitsPerEm: 'units-per-em',\n    vAlphabetic: 'v-alphabetic',\n    vHanging: 'v-hanging',\n    vIdeographic: 'v-ideographic',\n    vMathematical: 'v-mathematical',\n    vectorEffect: 'vector-effect',\n    vertAdvY: 'vert-adv-y',\n    vertOriginX: 'vert-origin-x',\n    vertOriginY: 'vert-origin-y',\n    wordSpacing: 'word-spacing',\n    writingMode: 'writing-mode',\n    xHeight: 'x-height',\n    // These were camelcased in Tiny. Now lowercased in SVG 2\n    playbackOrder: 'playbackorder',\n    timelineBegin: 'timelinebegin'\n  },\n  transform: caseSensitiveTransform,\n  properties: {\n    about: commaOrSpaceSeparated,\n    accentHeight: number,\n    accumulate: null,\n    additive: null,\n    alignmentBaseline: null,\n    alphabetic: number,\n    amplitude: number,\n    arabicForm: null,\n    ascent: number,\n    attributeName: null,\n    attributeType: null,\n    azimuth: number,\n    bandwidth: null,\n    baselineShift: null,\n    baseFrequency: null,\n    baseProfile: null,\n    bbox: null,\n    begin: null,\n    bias: number,\n    by: null,\n    calcMode: null,\n    capHeight: number,\n    className: spaceSeparated,\n    clip: null,\n    clipPath: null,\n    clipPathUnits: null,\n    clipRule: null,\n    color: null,\n    colorInterpolation: null,\n    colorInterpolationFilters: null,\n    colorProfile: null,\n    colorRendering: null,\n    content: null,\n    contentScriptType: null,\n    contentStyleType: null,\n    crossOrigin: null,\n    cursor: null,\n    cx: null,\n    cy: null,\n    d: null,\n    dataType: null,\n    defaultAction: null,\n    descent: number,\n    diffuseConstant: number,\n    direction: null,\n    display: null,\n    dur: null,\n    divisor: number,\n    dominantBaseline: null,\n    download: boolean,\n    dx: null,\n    dy: null,\n    edgeMode: null,\n    editable: null,\n    elevation: number,\n    enableBackground: null,\n    end: null,\n    event: null,\n    exponent: number,\n    externalResourcesRequired: null,\n    fill: null,\n    fillOpacity: number,\n    fillRule: null,\n    filter: null,\n    filterRes: null,\n    filterUnits: null,\n    floodColor: null,\n    floodOpacity: null,\n    focusable: null,\n    focusHighlight: null,\n    fontFamily: null,\n    fontSize: null,\n    fontSizeAdjust: null,\n    fontStretch: null,\n    fontStyle: null,\n    fontVariant: null,\n    fontWeight: null,\n    format: null,\n    fr: null,\n    from: null,\n    fx: null,\n    fy: null,\n    g1: commaSeparated,\n    g2: commaSeparated,\n    glyphName: commaSeparated,\n    glyphOrientationHorizontal: null,\n    glyphOrientationVertical: null,\n    glyphRef: null,\n    gradientTransform: null,\n    gradientUnits: null,\n    handler: null,\n    hanging: number,\n    hatchContentUnits: null,\n    hatchUnits: null,\n    height: null,\n    href: null,\n    hrefLang: null,\n    horizAdvX: number,\n    horizOriginX: number,\n    horizOriginY: number,\n    id: null,\n    ideographic: number,\n    imageRendering: null,\n    initialVisibility: null,\n    in: null,\n    in2: null,\n    intercept: number,\n    k: number,\n    k1: number,\n    k2: number,\n    k3: number,\n    k4: number,\n    kernelMatrix: commaOrSpaceSeparated,\n    kernelUnitLength: null,\n    keyPoints: null, // SEMI_COLON_SEPARATED\n    keySplines: null, // SEMI_COLON_SEPARATED\n    keyTimes: null, // SEMI_COLON_SEPARATED\n    kerning: null,\n    lang: null,\n    lengthAdjust: null,\n    letterSpacing: null,\n    lightingColor: null,\n    limitingConeAngle: number,\n    local: null,\n    markerEnd: null,\n    markerMid: null,\n    markerStart: null,\n    markerHeight: null,\n    markerUnits: null,\n    markerWidth: null,\n    mask: null,\n    maskContentUnits: null,\n    maskUnits: null,\n    mathematical: null,\n    max: null,\n    media: null,\n    mediaCharacterEncoding: null,\n    mediaContentEncodings: null,\n    mediaSize: number,\n    mediaTime: null,\n    method: null,\n    min: null,\n    mode: null,\n    name: null,\n    navDown: null,\n    navDownLeft: null,\n    navDownRight: null,\n    navLeft: null,\n    navNext: null,\n    navPrev: null,\n    navRight: null,\n    navUp: null,\n    navUpLeft: null,\n    navUpRight: null,\n    numOctaves: null,\n    observer: null,\n    offset: null,\n    onAbort: null,\n    onActivate: null,\n    onAfterPrint: null,\n    onBeforePrint: null,\n    onBegin: null,\n    onCancel: null,\n    onCanPlay: null,\n    onCanPlayThrough: null,\n    onChange: null,\n    onClick: null,\n    onClose: null,\n    onCopy: null,\n    onCueChange: null,\n    onCut: null,\n    onDblClick: null,\n    onDrag: null,\n    onDragEnd: null,\n    onDragEnter: null,\n    onDragExit: null,\n    onDragLeave: null,\n    onDragOver: null,\n    onDragStart: null,\n    onDrop: null,\n    onDurationChange: null,\n    onEmptied: null,\n    onEnd: null,\n    onEnded: null,\n    onError: null,\n    onFocus: null,\n    onFocusIn: null,\n    onFocusOut: null,\n    onHashChange: null,\n    onInput: null,\n    onInvalid: null,\n    onKeyDown: null,\n    onKeyPress: null,\n    onKeyUp: null,\n    onLoad: null,\n    onLoadedData: null,\n    onLoadedMetadata: null,\n    onLoadStart: null,\n    onMessage: null,\n    onMouseDown: null,\n    onMouseEnter: null,\n    onMouseLeave: null,\n    onMouseMove: null,\n    onMouseOut: null,\n    onMouseOver: null,\n    onMouseUp: null,\n    onMouseWheel: null,\n    onOffline: null,\n    onOnline: null,\n    onPageHide: null,\n    onPageShow: null,\n    onPaste: null,\n    onPause: null,\n    onPlay: null,\n    onPlaying: null,\n    onPopState: null,\n    onProgress: null,\n    onRateChange: null,\n    onRepeat: null,\n    onReset: null,\n    onResize: null,\n    onScroll: null,\n    onSeeked: null,\n    onSeeking: null,\n    onSelect: null,\n    onShow: null,\n    onStalled: null,\n    onStorage: null,\n    onSubmit: null,\n    onSuspend: null,\n    onTimeUpdate: null,\n    onToggle: null,\n    onUnload: null,\n    onVolumeChange: null,\n    onWaiting: null,\n    onZoom: null,\n    opacity: null,\n    operator: null,\n    order: null,\n    orient: null,\n    orientation: null,\n    origin: null,\n    overflow: null,\n    overlay: null,\n    overlinePosition: number,\n    overlineThickness: number,\n    paintOrder: null,\n    panose1: null,\n    path: null,\n    pathLength: number,\n    patternContentUnits: null,\n    patternTransform: null,\n    patternUnits: null,\n    phase: null,\n    ping: spaceSeparated,\n    pitch: null,\n    playbackOrder: null,\n    pointerEvents: null,\n    points: null,\n    pointsAtX: number,\n    pointsAtY: number,\n    pointsAtZ: number,\n    preserveAlpha: null,\n    preserveAspectRatio: null,\n    primitiveUnits: null,\n    propagate: null,\n    property: commaOrSpaceSeparated,\n    r: null,\n    radius: null,\n    referrerPolicy: null,\n    refX: null,\n    refY: null,\n    rel: commaOrSpaceSeparated,\n    rev: commaOrSpaceSeparated,\n    renderingIntent: null,\n    repeatCount: null,\n    repeatDur: null,\n    requiredExtensions: commaOrSpaceSeparated,\n    requiredFeatures: commaOrSpaceSeparated,\n    requiredFonts: commaOrSpaceSeparated,\n    requiredFormats: commaOrSpaceSeparated,\n    resource: null,\n    restart: null,\n    result: null,\n    rotate: null,\n    rx: null,\n    ry: null,\n    scale: null,\n    seed: null,\n    shapeRendering: null,\n    side: null,\n    slope: null,\n    snapshotTime: null,\n    specularConstant: number,\n    specularExponent: number,\n    spreadMethod: null,\n    spacing: null,\n    startOffset: null,\n    stdDeviation: null,\n    stemh: null,\n    stemv: null,\n    stitchTiles: null,\n    stopColor: null,\n    stopOpacity: null,\n    strikethroughPosition: number,\n    strikethroughThickness: number,\n    string: null,\n    stroke: null,\n    strokeDashArray: commaOrSpaceSeparated,\n    strokeDashOffset: null,\n    strokeLineCap: null,\n    strokeLineJoin: null,\n    strokeMiterLimit: number,\n    strokeOpacity: number,\n    strokeWidth: null,\n    style: null,\n    surfaceScale: number,\n    syncBehavior: null,\n    syncBehaviorDefault: null,\n    syncMaster: null,\n    syncTolerance: null,\n    syncToleranceDefault: null,\n    systemLanguage: commaOrSpaceSeparated,\n    tabIndex: number,\n    tableValues: null,\n    target: null,\n    targetX: number,\n    targetY: number,\n    textAnchor: null,\n    textDecoration: null,\n    textRendering: null,\n    textLength: null,\n    timelineBegin: null,\n    title: null,\n    transformBehavior: null,\n    type: null,\n    typeOf: commaOrSpaceSeparated,\n    to: null,\n    transform: null,\n    transformOrigin: null,\n    u1: null,\n    u2: null,\n    underlinePosition: number,\n    underlineThickness: number,\n    unicode: null,\n    unicodeBidi: null,\n    unicodeRange: null,\n    unitsPerEm: number,\n    values: null,\n    vAlphabetic: number,\n    vMathematical: number,\n    vectorEffect: null,\n    vHanging: number,\n    vIdeographic: number,\n    version: null,\n    vertAdvY: number,\n    vertOriginX: number,\n    vertOriginY: number,\n    viewBox: null,\n    viewTarget: null,\n    visibility: null,\n    width: null,\n    widths: null,\n    wordSpacing: null,\n    writingMode: null,\n    x: null,\n    x1: null,\n    x2: null,\n    xChannelSelector: null,\n    xHeight: number,\n    y: null,\n    y1: null,\n    y2: null,\n    yChannelSelector: null,\n    z: null,\n    zoomAndPan: null\n  }\n})\n","/**\n * @typedef {import('./lib/util/info.js').Info} Info\n * @typedef {import('./lib/util/schema.js').Schema} Schema\n */\n\nimport {merge} from './lib/util/merge.js'\nimport {xlink} from './lib/xlink.js'\nimport {xml} from './lib/xml.js'\nimport {xmlns} from './lib/xmlns.js'\nimport {aria} from './lib/aria.js'\nimport {html as htmlBase} from './lib/html.js'\nimport {svg as svgBase} from './lib/svg.js'\n\nexport {find} from './lib/find.js'\nexport {hastToReact} from './lib/hast-to-react.js'\nexport {normalize} from './lib/normalize.js'\nexport const html = merge([xml, xlink, xmlns, aria, htmlBase], 'html')\nexport const svg = merge([xml, xlink, xmlns, aria, svgBase], 'svg')\n","/**\n * @typedef {import('./util/schema.js').Schema} Schema\n */\n\nimport {normalize} from './normalize.js'\nimport {DefinedInfo} from './util/defined-info.js'\nimport {Info} from './util/info.js'\n\nconst valid = /^data[-\\w.:]+$/i\nconst dash = /-[a-z]/g\nconst cap = /[A-Z]/g\n\n/**\n * @param {Schema} schema\n * @param {string} value\n * @returns {Info}\n */\nexport function find(schema, value) {\n  const normal = normalize(value)\n  let prop = value\n  let Type = Info\n\n  if (normal in schema.normal) {\n    return schema.property[schema.normal[normal]]\n  }\n\n  if (normal.length > 4 && normal.slice(0, 4) === 'data' && valid.test(value)) {\n    // Attribute or property.\n    if (value.charAt(4) === '-') {\n      // Turn it into a property.\n      const rest = value.slice(5).replace(dash, camelcase)\n      prop = 'data' + rest.charAt(0).toUpperCase() + rest.slice(1)\n    } else {\n      // Turn it into an attribute.\n      const rest = value.slice(4)\n\n      if (!dash.test(rest)) {\n        let dashes = rest.replace(cap, kebab)\n\n        if (dashes.charAt(0) !== '-') {\n          dashes = '-' + dashes\n        }\n\n        value = 'data' + dashes\n      }\n    }\n\n    Type = DefinedInfo\n  }\n\n  return new Type(prop, value)\n}\n\n/**\n * @param {string} $0\n * @returns {string}\n */\nfunction kebab($0) {\n  return '-' + $0.toLowerCase()\n}\n\n/**\n * @param {string} $0\n * @returns {string}\n */\nfunction camelcase($0) {\n  return $0.charAt(1).toUpperCase()\n}\n","/**\n * `hast` is close to `React`, but differs in a couple of cases.\n *\n * To get a React property from a hast property, check if it is in\n * `hastToReact`, if it is, then use the corresponding value,\n * otherwise, use the hast property.\n *\n * @type {Record<string, string>}\n */\nexport const hastToReact = {\n  classId: 'classID',\n  dataType: 'datatype',\n  itemId: 'itemID',\n  strokeDashArray: 'strokeDasharray',\n  strokeDashOffset: 'strokeDashoffset',\n  strokeLineCap: 'strokeLinecap',\n  strokeLineJoin: 'strokeLinejoin',\n  strokeMiterLimit: 'strokeMiterlimit',\n  typeOf: 'typeof',\n  xLinkActuate: 'xlinkActuate',\n  xLinkArcRole: 'xlinkArcrole',\n  xLinkHref: 'xlinkHref',\n  xLinkRole: 'xlinkRole',\n  xLinkShow: 'xlinkShow',\n  xLinkTitle: 'xlinkTitle',\n  xLinkType: 'xlinkType',\n  xmlnsXLink: 'xmlnsXlink'\n}\n","import StyleToObject from '../cjs/index.js';\n\n// ensure compatibility with rollup umd build\nexport default StyleToObject.default || StyleToObject;\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Point} Point\n * @typedef {import('unist').Position} Position\n */\n\n/**\n * @typedef NodeLike\n * @property {string} type\n * @property {PositionLike | null | undefined} [position]\n *\n * @typedef PositionLike\n * @property {PointLike | null | undefined} [start]\n * @property {PointLike | null | undefined} [end]\n *\n * @typedef PointLike\n * @property {number | null | undefined} [line]\n * @property {number | null | undefined} [column]\n * @property {number | null | undefined} [offset]\n */\n\n/**\n * Get the ending point of `node`.\n *\n * @param node\n *   Node.\n * @returns\n *   Point.\n */\nexport const pointEnd = point('end')\n\n/**\n * Get the starting point of `node`.\n *\n * @param node\n *   Node.\n * @returns\n *   Point.\n */\nexport const pointStart = point('start')\n\n/**\n * Get the positional info of `node`.\n *\n * @param {'end' | 'start'} type\n *   Side.\n * @returns\n *   Getter.\n */\nfunction point(type) {\n  return point\n\n  /**\n   * Get the point info of `node` at a bound side.\n   *\n   * @param {Node | NodeLike | null | undefined} [node]\n   * @returns {Point | undefined}\n   */\n  function point(node) {\n    const point = (node && node.position && node.position[type]) || {}\n\n    if (\n      typeof point.line === 'number' &&\n      point.line > 0 &&\n      typeof point.column === 'number' &&\n      point.column > 0\n    ) {\n      return {\n        line: point.line,\n        column: point.column,\n        offset:\n          typeof point.offset === 'number' && point.offset > -1\n            ? point.offset\n            : undefined\n      }\n    }\n  }\n}\n\n/**\n * Get the positional info of `node`.\n *\n * @param {Node | NodeLike | null | undefined} [node]\n *   Node.\n * @returns {Position | undefined}\n *   Position.\n */\nexport function position(node) {\n  const start = pointStart(node)\n  const end = pointEnd(node)\n\n  if (start && end) {\n    return {start, end}\n  }\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Point} Point\n * @typedef {import('unist').Position} Position\n */\n\n/**\n * @typedef NodeLike\n * @property {string} type\n * @property {PositionLike | null | undefined} [position]\n *\n * @typedef PointLike\n * @property {number | null | undefined} [line]\n * @property {number | null | undefined} [column]\n * @property {number | null | undefined} [offset]\n *\n * @typedef PositionLike\n * @property {PointLike | null | undefined} [start]\n * @property {PointLike | null | undefined} [end]\n */\n\n/**\n * Serialize the positional info of a point, position (start and end points),\n * or node.\n *\n * @param {Node | NodeLike | Point | PointLike | Position | PositionLike | null | undefined} [value]\n *   Node, position, or point.\n * @returns {string}\n *   Pretty printed positional info of a node (`string`).\n *\n *   In the format of a range `ls:cs-le:ce` (when given `node` or `position`)\n *   or a point `l:c` (when given `point`), where `l` stands for line, `c` for\n *   column, `s` for `start`, and `e` for end.\n *   An empty string (`''`) is returned if the given value is neither `node`,\n *   `position`, nor `point`.\n */\nexport function stringifyPosition(value) {\n  // Nothing.\n  if (!value || typeof value !== 'object') {\n    return ''\n  }\n\n  // Node.\n  if ('position' in value || 'type' in value) {\n    return position(value.position)\n  }\n\n  // Position.\n  if ('start' in value || 'end' in value) {\n    return position(value)\n  }\n\n  // Point.\n  if ('line' in value || 'column' in value) {\n    return point(value)\n  }\n\n  // ?\n  return ''\n}\n\n/**\n * @param {Point | PointLike | null | undefined} point\n * @returns {string}\n */\nfunction point(point) {\n  return index(point && point.line) + ':' + index(point && point.column)\n}\n\n/**\n * @param {Position | PositionLike | null | undefined} pos\n * @returns {string}\n */\nfunction position(pos) {\n  return point(pos && pos.start) + '-' + point(pos && pos.end)\n}\n\n/**\n * @param {number | null | undefined} value\n * @returns {number}\n */\nfunction index(value) {\n  return value && typeof value === 'number' ? value : 1\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Point} Point\n * @typedef {import('unist').Position} Position\n */\n\n/**\n * @typedef {object & {type: string, position?: Position | undefined}} NodeLike\n *\n * @typedef Options\n *   Configuration.\n * @property {Array<Node> | null | undefined} [ancestors]\n *   Stack of (inclusive) ancestor nodes surrounding the message (optional).\n * @property {Error | null | undefined} [cause]\n *   Original error cause of the message (optional).\n * @property {Point | Position | null | undefined} [place]\n *   Place of message (optional).\n * @property {string | null | undefined} [ruleId]\n *   Category of message (optional, example: `'my-rule'`).\n * @property {string | null | undefined} [source]\n *   Namespace of who sent the message (optional, example: `'my-package'`).\n */\n\nimport {stringifyPosition} from 'unist-util-stringify-position'\n\n/**\n * Message.\n */\nexport class VFileMessage extends Error {\n  /**\n   * Create a message for `reason`.\n   *\n   * > 🪦 **Note**: also has obsolete signatures.\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Options | null | undefined} [options]\n   * @returns\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @overload\n   * @param {string} reason\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @param {Error | VFileMessage | string} causeOrReason\n   *   Reason for message, should use markdown.\n   * @param {Node | NodeLike | Options | Point | Position | string | null | undefined} [optionsOrParentOrPlace]\n   *   Configuration (optional).\n   * @param {string | null | undefined} [origin]\n   *   Place in code where the message originates (example:\n   *   `'my-package:my-rule'` or `'my-rule'`).\n   * @returns\n   *   Instance of `VFileMessage`.\n   */\n  // eslint-disable-next-line complexity\n  constructor(causeOrReason, optionsOrParentOrPlace, origin) {\n    super()\n\n    if (typeof optionsOrParentOrPlace === 'string') {\n      origin = optionsOrParentOrPlace\n      optionsOrParentOrPlace = undefined\n    }\n\n    /** @type {string} */\n    let reason = ''\n    /** @type {Options} */\n    let options = {}\n    let legacyCause = false\n\n    if (optionsOrParentOrPlace) {\n      // Point.\n      if (\n        'line' in optionsOrParentOrPlace &&\n        'column' in optionsOrParentOrPlace\n      ) {\n        options = {place: optionsOrParentOrPlace}\n      }\n      // Position.\n      else if (\n        'start' in optionsOrParentOrPlace &&\n        'end' in optionsOrParentOrPlace\n      ) {\n        options = {place: optionsOrParentOrPlace}\n      }\n      // Node.\n      else if ('type' in optionsOrParentOrPlace) {\n        options = {\n          ancestors: [optionsOrParentOrPlace],\n          place: optionsOrParentOrPlace.position\n        }\n      }\n      // Options.\n      else {\n        options = {...optionsOrParentOrPlace}\n      }\n    }\n\n    if (typeof causeOrReason === 'string') {\n      reason = causeOrReason\n    }\n    // Error.\n    else if (!options.cause && causeOrReason) {\n      legacyCause = true\n      reason = causeOrReason.message\n      options.cause = causeOrReason\n    }\n\n    if (!options.ruleId && !options.source && typeof origin === 'string') {\n      const index = origin.indexOf(':')\n\n      if (index === -1) {\n        options.ruleId = origin\n      } else {\n        options.source = origin.slice(0, index)\n        options.ruleId = origin.slice(index + 1)\n      }\n    }\n\n    if (!options.place && options.ancestors && options.ancestors) {\n      const parent = options.ancestors[options.ancestors.length - 1]\n\n      if (parent) {\n        options.place = parent.position\n      }\n    }\n\n    const start =\n      options.place && 'start' in options.place\n        ? options.place.start\n        : options.place\n\n    /* eslint-disable no-unused-expressions */\n    /**\n     * Stack of ancestor nodes surrounding the message.\n     *\n     * @type {Array<Node> | undefined}\n     */\n    this.ancestors = options.ancestors || undefined\n\n    /**\n     * Original error cause of the message.\n     *\n     * @type {Error | undefined}\n     */\n    this.cause = options.cause || undefined\n\n    /**\n     * Starting column of message.\n     *\n     * @type {number | undefined}\n     */\n    this.column = start ? start.column : undefined\n\n    /**\n     * State of problem.\n     *\n     * * `true` — error, file not usable\n     * * `false` — warning, change may be needed\n     * * `undefined` — change likely not needed\n     *\n     * @type {boolean | null | undefined}\n     */\n    this.fatal = undefined\n\n    /**\n     * Path of a file (used throughout the `VFile` ecosystem).\n     *\n     * @type {string | undefined}\n     */\n    this.file\n\n    // Field from `Error`.\n    /**\n     * Reason for message.\n     *\n     * @type {string}\n     */\n    this.message = reason\n\n    /**\n     * Starting line of error.\n     *\n     * @type {number | undefined}\n     */\n    this.line = start ? start.line : undefined\n\n    // Field from `Error`.\n    /**\n     * Serialized positional info of message.\n     *\n     * On normal errors, this would be something like `ParseError`, buit in\n     * `VFile` messages we use this space to show where an error happened.\n     */\n    this.name = stringifyPosition(options.place) || '1:1'\n\n    /**\n     * Place of message.\n     *\n     * @type {Point | Position | undefined}\n     */\n    this.place = options.place || undefined\n\n    /**\n     * Reason for message, should use markdown.\n     *\n     * @type {string}\n     */\n    this.reason = this.message\n\n    /**\n     * Category of message (example: `'my-rule'`).\n     *\n     * @type {string | undefined}\n     */\n    this.ruleId = options.ruleId || undefined\n\n    /**\n     * Namespace of message (example: `'my-package'`).\n     *\n     * @type {string | undefined}\n     */\n    this.source = options.source || undefined\n\n    // Field from `Error`.\n    /**\n     * Stack of message.\n     *\n     * This is used by normal errors to show where something happened in\n     * programming code, irrelevant for `VFile` messages,\n     *\n     * @type {string}\n     */\n    this.stack =\n      legacyCause && options.cause && typeof options.cause.stack === 'string'\n        ? options.cause.stack\n        : ''\n\n    // The following fields are “well known”.\n    // Not standard.\n    // Feel free to add other non-standard fields to your messages.\n\n    /**\n     * Specify the source value that’s being reported, which is deemed\n     * incorrect.\n     *\n     * @type {string | undefined}\n     */\n    this.actual\n\n    /**\n     * Suggest acceptable values that can be used instead of `actual`.\n     *\n     * @type {Array<string> | undefined}\n     */\n    this.expected\n\n    /**\n     * Long form description of the message (you should use markdown).\n     *\n     * @type {string | undefined}\n     */\n    this.note\n\n    /**\n     * Link to docs for the message.\n     *\n     * > 👉 **Note**: this must be an absolute URL that can be passed as `x`\n     * > to `new URL(x)`.\n     *\n     * @type {string | undefined}\n     */\n    this.url\n    /* eslint-enable no-unused-expressions */\n  }\n}\n\nVFileMessage.prototype.file = ''\nVFileMessage.prototype.name = ''\nVFileMessage.prototype.reason = ''\nVFileMessage.prototype.message = ''\nVFileMessage.prototype.stack = ''\nVFileMessage.prototype.column = undefined\nVFileMessage.prototype.line = undefined\nVFileMessage.prototype.ancestors = undefined\nVFileMessage.prototype.cause = undefined\nVFileMessage.prototype.fatal = undefined\nVFileMessage.prototype.place = undefined\nVFileMessage.prototype.ruleId = undefined\nVFileMessage.prototype.source = undefined\n","/**\n * @import {Identifier, Literal, MemberExpression} from 'estree'\n * @import {Jsx, JsxDev, Options, Props} from 'hast-util-to-jsx-runtime'\n * @import {Element, Nodes, Parents, Root, Text} from 'hast'\n * @import {MdxFlowExpressionHast, MdxTextExpressionHast} from 'mdast-util-mdx-expression'\n * @import {MdxJsxFlowElementHast, MdxJsxTextElementHast} from 'mdast-util-mdx-jsx'\n * @import {MdxjsEsmHast} from 'mdast-util-mdxjs-esm'\n * @import {Position} from 'unist'\n * @import {Child, Create, Field, State, Style} from './types.js'\n */\n\nimport {stringify as commas} from 'comma-separated-tokens'\nimport {ok as assert} from 'devlop'\nimport {name as isIdentifierName} from 'estree-util-is-identifier-name'\nimport {whitespace} from 'hast-util-whitespace'\nimport {find, hastToReact, html, svg} from 'property-information'\nimport {stringify as spaces} from 'space-separated-tokens'\nimport styleToObject from 'style-to-object'\nimport {pointStart} from 'unist-util-position'\nimport {VFileMessage} from 'vfile-message'\n\n// To do: next major: `Object.hasOwn`.\nconst own = {}.hasOwnProperty\n\n/** @type {Map<string, number>} */\nconst emptyMap = new Map()\n\nconst cap = /[A-Z]/g\nconst dashSomething = /-([a-z])/g\n\n// `react-dom` triggers a warning for *any* white space in tables.\n// To follow GFM, `mdast-util-to-hast` injects line endings between elements.\n// Other tools might do so too, but they don’t do here, so we remove all of\n// that.\n\n// See: <https://github.com/facebook/react/pull/7081>.\n// See: <https://github.com/facebook/react/pull/7515>.\n// See: <https://github.com/remarkjs/remark-react/issues/64>.\n// See: <https://github.com/rehypejs/rehype-react/pull/29>.\n// See: <https://github.com/rehypejs/rehype-react/pull/32>.\n// See: <https://github.com/rehypejs/rehype-react/pull/45>.\nconst tableElements = new Set(['table', 'tbody', 'thead', 'tfoot', 'tr'])\n\nconst tableCellElement = new Set(['td', 'th'])\n\nconst docs = 'https://github.com/syntax-tree/hast-util-to-jsx-runtime'\n\n/**\n * Transform a hast tree to preact, react, solid, svelte, vue, etc.,\n * with an automatic JSX runtime.\n *\n * @param {Nodes} tree\n *   Tree to transform.\n * @param {Options} options\n *   Configuration (required).\n * @returns {JSX.Element}\n *   JSX element.\n */\n\nexport function toJsxRuntime(tree, options) {\n  if (!options || options.Fragment === undefined) {\n    throw new TypeError('Expected `Fragment` in options')\n  }\n\n  const filePath = options.filePath || undefined\n  /** @type {Create} */\n  let create\n\n  if (options.development) {\n    if (typeof options.jsxDEV !== 'function') {\n      throw new TypeError(\n        'Expected `jsxDEV` in options when `development: true`'\n      )\n    }\n\n    create = developmentCreate(filePath, options.jsxDEV)\n  } else {\n    if (typeof options.jsx !== 'function') {\n      throw new TypeError('Expected `jsx` in production options')\n    }\n\n    if (typeof options.jsxs !== 'function') {\n      throw new TypeError('Expected `jsxs` in production options')\n    }\n\n    create = productionCreate(filePath, options.jsx, options.jsxs)\n  }\n\n  /** @type {State} */\n  const state = {\n    Fragment: options.Fragment,\n    ancestors: [],\n    components: options.components || {},\n    create,\n    elementAttributeNameCase: options.elementAttributeNameCase || 'react',\n    evaluater: options.createEvaluater ? options.createEvaluater() : undefined,\n    filePath,\n    ignoreInvalidStyle: options.ignoreInvalidStyle || false,\n    passKeys: options.passKeys !== false,\n    passNode: options.passNode || false,\n    schema: options.space === 'svg' ? svg : html,\n    stylePropertyNameCase: options.stylePropertyNameCase || 'dom',\n    tableCellAlignToStyle: options.tableCellAlignToStyle !== false\n  }\n\n  const result = one(state, tree, undefined)\n\n  // JSX element.\n  if (result && typeof result !== 'string') {\n    return result\n  }\n\n  // Text node or something that turned into nothing.\n  return state.create(\n    tree,\n    state.Fragment,\n    {children: result || undefined},\n    undefined\n  )\n}\n\n/**\n * Transform a node.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Nodes} node\n *   Current node.\n * @param {string | undefined} key\n *   Key.\n * @returns {Child | undefined}\n *   Child, optional.\n */\nfunction one(state, node, key) {\n  if (node.type === 'element') {\n    return element(state, node, key)\n  }\n\n  if (node.type === 'mdxFlowExpression' || node.type === 'mdxTextExpression') {\n    return mdxExpression(state, node)\n  }\n\n  if (node.type === 'mdxJsxFlowElement' || node.type === 'mdxJsxTextElement') {\n    return mdxJsxElement(state, node, key)\n  }\n\n  if (node.type === 'mdxjsEsm') {\n    return mdxEsm(state, node)\n  }\n\n  if (node.type === 'root') {\n    return root(state, node, key)\n  }\n\n  if (node.type === 'text') {\n    return text(state, node)\n  }\n}\n\n/**\n * Handle element.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Element} node\n *   Current node.\n * @param {string | undefined} key\n *   Key.\n * @returns {Child | undefined}\n *   Child, optional.\n */\nfunction element(state, node, key) {\n  const parentSchema = state.schema\n  let schema = parentSchema\n\n  if (node.tagName.toLowerCase() === 'svg' && parentSchema.space === 'html') {\n    schema = svg\n    state.schema = schema\n  }\n\n  state.ancestors.push(node)\n\n  const type = findComponentFromName(state, node.tagName, false)\n  const props = createElementProps(state, node)\n  let children = createChildren(state, node)\n\n  if (tableElements.has(node.tagName)) {\n    children = children.filter(function (child) {\n      return typeof child === 'string' ? !whitespace(child) : true\n    })\n  }\n\n  addNode(state, props, type, node)\n  addChildren(props, children)\n\n  // Restore.\n  state.ancestors.pop()\n  state.schema = parentSchema\n\n  return state.create(node, type, props, key)\n}\n\n/**\n * Handle MDX expression.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdxFlowExpressionHast | MdxTextExpressionHast} node\n *   Current node.\n * @returns {Child | undefined}\n *   Child, optional.\n */\nfunction mdxExpression(state, node) {\n  if (node.data && node.data.estree && state.evaluater) {\n    const program = node.data.estree\n    const expression = program.body[0]\n    assert(expression.type === 'ExpressionStatement')\n\n    // Assume result is a child.\n    return /** @type {Child | undefined} */ (\n      state.evaluater.evaluateExpression(expression.expression)\n    )\n  }\n\n  crashEstree(state, node.position)\n}\n\n/**\n * Handle MDX ESM.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdxjsEsmHast} node\n *   Current node.\n * @returns {Child | undefined}\n *   Child, optional.\n */\nfunction mdxEsm(state, node) {\n  if (node.data && node.data.estree && state.evaluater) {\n    // Assume result is a child.\n    return /** @type {Child | undefined} */ (\n      state.evaluater.evaluateProgram(node.data.estree)\n    )\n  }\n\n  crashEstree(state, node.position)\n}\n\n/**\n * Handle MDX JSX.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdxJsxFlowElementHast | MdxJsxTextElementHast} node\n *   Current node.\n * @param {string | undefined} key\n *   Key.\n * @returns {Child | undefined}\n *   Child, optional.\n */\nfunction mdxJsxElement(state, node, key) {\n  const parentSchema = state.schema\n  let schema = parentSchema\n\n  if (node.name === 'svg' && parentSchema.space === 'html') {\n    schema = svg\n    state.schema = schema\n  }\n\n  state.ancestors.push(node)\n\n  const type =\n    node.name === null\n      ? state.Fragment\n      : findComponentFromName(state, node.name, true)\n  const props = createJsxElementProps(state, node)\n  const children = createChildren(state, node)\n\n  addNode(state, props, type, node)\n  addChildren(props, children)\n\n  // Restore.\n  state.ancestors.pop()\n  state.schema = parentSchema\n\n  return state.create(node, type, props, key)\n}\n\n/**\n * Handle root.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Root} node\n *   Current node.\n * @param {string | undefined} key\n *   Key.\n * @returns {Child | undefined}\n *   Child, optional.\n */\nfunction root(state, node, key) {\n  /** @type {Props} */\n  const props = {}\n\n  addChildren(props, createChildren(state, node))\n\n  return state.create(node, state.Fragment, props, key)\n}\n\n/**\n * Handle text.\n *\n * @param {State} _\n *   Info passed around.\n * @param {Text} node\n *   Current node.\n * @returns {Child | undefined}\n *   Child, optional.\n */\nfunction text(_, node) {\n  return node.value\n}\n\n/**\n * Add `node` to props.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Props} props\n *   Props.\n * @param {unknown} type\n *   Type.\n * @param {Element | MdxJsxFlowElementHast | MdxJsxTextElementHast} node\n *   Node.\n * @returns {undefined}\n *   Nothing.\n */\nfunction addNode(state, props, type, node) {\n  // If this is swapped out for a component:\n  if (typeof type !== 'string' && type !== state.Fragment && state.passNode) {\n    props.node = node\n  }\n}\n\n/**\n * Add children to props.\n *\n * @param {Props} props\n *   Props.\n * @param {Array<Child>} children\n *   Children.\n * @returns {undefined}\n *   Nothing.\n */\nfunction addChildren(props, children) {\n  if (children.length > 0) {\n    const value = children.length > 1 ? children : children[0]\n\n    if (value) {\n      props.children = value\n    }\n  }\n}\n\n/**\n * @param {string | undefined} _\n *   Path to file.\n * @param {Jsx} jsx\n *   Dynamic.\n * @param {Jsx} jsxs\n *   Static.\n * @returns {Create}\n *   Create a production element.\n */\nfunction productionCreate(_, jsx, jsxs) {\n  return create\n  /** @type {Create} */\n  function create(_, type, props, key) {\n    // Only an array when there are 2 or more children.\n    const isStaticChildren = Array.isArray(props.children)\n    const fn = isStaticChildren ? jsxs : jsx\n    return key ? fn(type, props, key) : fn(type, props)\n  }\n}\n\n/**\n * @param {string | undefined} filePath\n *   Path to file.\n * @param {JsxDev} jsxDEV\n *   Development.\n * @returns {Create}\n *   Create a development element.\n */\nfunction developmentCreate(filePath, jsxDEV) {\n  return create\n  /** @type {Create} */\n  function create(node, type, props, key) {\n    // Only an array when there are 2 or more children.\n    const isStaticChildren = Array.isArray(props.children)\n    const point = pointStart(node)\n    return jsxDEV(\n      type,\n      props,\n      key,\n      isStaticChildren,\n      {\n        columnNumber: point ? point.column - 1 : undefined,\n        fileName: filePath,\n        lineNumber: point ? point.line : undefined\n      },\n      undefined\n    )\n  }\n}\n\n/**\n * Create props from an element.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Element} node\n *   Current element.\n * @returns {Props}\n *   Props.\n */\nfunction createElementProps(state, node) {\n  /** @type {Props} */\n  const props = {}\n  /** @type {string | undefined} */\n  let alignValue\n  /** @type {string} */\n  let prop\n\n  for (prop in node.properties) {\n    if (prop !== 'children' && own.call(node.properties, prop)) {\n      const result = createProperty(state, prop, node.properties[prop])\n\n      if (result) {\n        const [key, value] = result\n\n        if (\n          state.tableCellAlignToStyle &&\n          key === 'align' &&\n          typeof value === 'string' &&\n          tableCellElement.has(node.tagName)\n        ) {\n          alignValue = value\n        } else {\n          props[key] = value\n        }\n      }\n    }\n  }\n\n  if (alignValue) {\n    // Assume style is an object.\n    const style = /** @type {Style} */ (props.style || (props.style = {}))\n    style[state.stylePropertyNameCase === 'css' ? 'text-align' : 'textAlign'] =\n      alignValue\n  }\n\n  return props\n}\n\n/**\n * Create props from a JSX element.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdxJsxFlowElementHast | MdxJsxTextElementHast} node\n *   Current JSX element.\n * @returns {Props}\n *   Props.\n */\nfunction createJsxElementProps(state, node) {\n  /** @type {Props} */\n  const props = {}\n\n  for (const attribute of node.attributes) {\n    if (attribute.type === 'mdxJsxExpressionAttribute') {\n      if (attribute.data && attribute.data.estree && state.evaluater) {\n        const program = attribute.data.estree\n        const expression = program.body[0]\n        assert(expression.type === 'ExpressionStatement')\n        const objectExpression = expression.expression\n        assert(objectExpression.type === 'ObjectExpression')\n        const property = objectExpression.properties[0]\n        assert(property.type === 'SpreadElement')\n\n        Object.assign(\n          props,\n          state.evaluater.evaluateExpression(property.argument)\n        )\n      } else {\n        crashEstree(state, node.position)\n      }\n    } else {\n      // For JSX, the author is responsible of passing in the correct values.\n      const name = attribute.name\n      /** @type {unknown} */\n      let value\n\n      if (attribute.value && typeof attribute.value === 'object') {\n        if (\n          attribute.value.data &&\n          attribute.value.data.estree &&\n          state.evaluater\n        ) {\n          const program = attribute.value.data.estree\n          const expression = program.body[0]\n          assert(expression.type === 'ExpressionStatement')\n          value = state.evaluater.evaluateExpression(expression.expression)\n        } else {\n          crashEstree(state, node.position)\n        }\n      } else {\n        value = attribute.value === null ? true : attribute.value\n      }\n\n      // Assume a prop.\n      props[name] = /** @type {Props[keyof Props]} */ (value)\n    }\n  }\n\n  return props\n}\n\n/**\n * Create children.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Parents} node\n *   Current element.\n * @returns {Array<Child>}\n *   Children.\n */\nfunction createChildren(state, node) {\n  /** @type {Array<Child>} */\n  const children = []\n  let index = -1\n  /** @type {Map<string, number>} */\n  // Note: test this when Solid doesn’t want to merge my upcoming PR.\n  /* c8 ignore next */\n  const countsByName = state.passKeys ? new Map() : emptyMap\n\n  while (++index < node.children.length) {\n    const child = node.children[index]\n    /** @type {string | undefined} */\n    let key\n\n    if (state.passKeys) {\n      const name =\n        child.type === 'element'\n          ? child.tagName\n          : child.type === 'mdxJsxFlowElement' ||\n              child.type === 'mdxJsxTextElement'\n            ? child.name\n            : undefined\n\n      if (name) {\n        const count = countsByName.get(name) || 0\n        key = name + '-' + count\n        countsByName.set(name, count + 1)\n      }\n    }\n\n    const result = one(state, child, key)\n    if (result !== undefined) children.push(result)\n  }\n\n  return children\n}\n\n/**\n * Handle a property.\n *\n * @param {State} state\n *   Info passed around.\n * @param {string} prop\n *   Key.\n * @param {Array<number | string> | boolean | number | string | null | undefined} value\n *   hast property value.\n * @returns {Field | undefined}\n *   Field for runtime, optional.\n */\nfunction createProperty(state, prop, value) {\n  const info = find(state.schema, prop)\n\n  // Ignore nullish and `NaN` values.\n  if (\n    value === null ||\n    value === undefined ||\n    (typeof value === 'number' && Number.isNaN(value))\n  ) {\n    return\n  }\n\n  if (Array.isArray(value)) {\n    // Accept `array`.\n    // Most props are space-separated.\n    value = info.commaSeparated ? commas(value) : spaces(value)\n  }\n\n  // React only accepts `style` as object.\n  if (info.property === 'style') {\n    let styleObject =\n      typeof value === 'object' ? value : parseStyle(state, String(value))\n\n    if (state.stylePropertyNameCase === 'css') {\n      styleObject = transformStylesToCssCasing(styleObject)\n    }\n\n    return ['style', styleObject]\n  }\n\n  return [\n    state.elementAttributeNameCase === 'react' && info.space\n      ? hastToReact[info.property] || info.property\n      : info.attribute,\n    value\n  ]\n}\n\n/**\n * Parse a CSS declaration to an object.\n *\n * @param {State} state\n *   Info passed around.\n * @param {string} value\n *   CSS declarations.\n * @returns {Style}\n *   Properties.\n * @throws\n *   Throws `VFileMessage` when CSS cannot be parsed.\n */\nfunction parseStyle(state, value) {\n  /** @type {Style} */\n  const result = {}\n\n  try {\n    styleToObject(value, replacer)\n  } catch (error) {\n    if (!state.ignoreInvalidStyle) {\n      const cause = /** @type {Error} */ (error)\n      const message = new VFileMessage('Cannot parse `style` attribute', {\n        ancestors: state.ancestors,\n        cause,\n        ruleId: 'style',\n        source: 'hast-util-to-jsx-runtime'\n      })\n      message.file = state.filePath || undefined\n      message.url = docs + '#cannot-parse-style-attribute'\n\n      throw message\n    }\n  }\n\n  return result\n\n  /**\n   * Add a CSS property (normal, so with dashes) to `result` as a DOM CSS\n   * property.\n   *\n   * @param {string} name\n   *   Key.\n   * @param {string} value\n   *   Value\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function replacer(name, value) {\n    let key = name\n\n    if (key.slice(0, 2) !== '--') {\n      if (key.slice(0, 4) === '-ms-') key = 'ms-' + key.slice(4)\n      key = key.replace(dashSomething, toCamel)\n    }\n\n    result[key] = value\n  }\n}\n\n/**\n * Create a JSX name from a string.\n *\n * @param {State} state\n *   To do.\n * @param {string} name\n *   Name.\n * @param {boolean} allowExpression\n *   Allow member expressions and identifiers.\n * @returns {unknown}\n *   To do.\n */\nfunction findComponentFromName(state, name, allowExpression) {\n  /** @type {Identifier | Literal | MemberExpression} */\n  let result\n\n  if (!allowExpression) {\n    result = {type: 'Literal', value: name}\n  } else if (name.includes('.')) {\n    const identifiers = name.split('.')\n    let index = -1\n    /** @type {Identifier | Literal | MemberExpression | undefined} */\n    let node\n\n    while (++index < identifiers.length) {\n      /** @type {Identifier | Literal} */\n      const prop = isIdentifierName(identifiers[index])\n        ? {type: 'Identifier', name: identifiers[index]}\n        : {type: 'Literal', value: identifiers[index]}\n      node = node\n        ? {\n            type: 'MemberExpression',\n            object: node,\n            property: prop,\n            computed: Boolean(index && prop.type === 'Literal'),\n            optional: false\n          }\n        : prop\n    }\n\n    assert(node, 'always a result')\n    result = node\n  } else {\n    result =\n      isIdentifierName(name) && !/^[a-z]/.test(name)\n        ? {type: 'Identifier', name}\n        : {type: 'Literal', value: name}\n  }\n\n  // Only literals can be passed in `components` currently.\n  // No identifiers / member expressions.\n  if (result.type === 'Literal') {\n    const name = /** @type {keyof JSX.IntrinsicElements} */ (result.value)\n\n    return own.call(state.components, name) ? state.components[name] : name\n  }\n\n  // Assume component.\n  if (state.evaluater) {\n    return state.evaluater.evaluateExpression(result)\n  }\n\n  crashEstree(state)\n}\n\n/**\n * @param {State} state\n * @param {Position | undefined} [place]\n * @returns {never}\n */\nfunction crashEstree(state, place) {\n  const message = new VFileMessage(\n    'Cannot handle MDX estrees without `createEvaluater`',\n    {\n      ancestors: state.ancestors,\n      place,\n      ruleId: 'mdx-estree',\n      source: 'hast-util-to-jsx-runtime'\n    }\n  )\n  message.file = state.filePath || undefined\n  message.url = docs + '#cannot-handle-mdx-estrees-without-createevaluater'\n\n  throw message\n}\n\n/**\n * Transform a DOM casing style object to a CSS casing style object.\n *\n * @param {Style} domCasing\n * @returns {Style}\n */\nfunction transformStylesToCssCasing(domCasing) {\n  /** @type {Style} */\n  const cssCasing = {}\n  /** @type {string} */\n  let from\n\n  for (from in domCasing) {\n    if (own.call(domCasing, from)) {\n      cssCasing[transformStyleToCssCasing(from)] = domCasing[from]\n    }\n  }\n\n  return cssCasing\n}\n\n/**\n * Transform a DOM casing style field to a CSS casing style field.\n *\n * @param {string} from\n * @returns {string}\n */\nfunction transformStyleToCssCasing(from) {\n  let to = from.replace(cap, toDash)\n  // Handle `ms-xxx` -> `-ms-xxx`.\n  if (to.slice(0, 3) === 'ms-') to = '-' + to\n  return to\n}\n\n/**\n * Make `$1` capitalized.\n *\n * @param {string} _\n *   Whatever.\n * @param {string} $1\n *   Single ASCII alphabetical.\n * @returns {string}\n *   Capitalized `$1`.\n */\nfunction toCamel(_, $1) {\n  return $1.toUpperCase()\n}\n\n/**\n * Make `$0` dash cased.\n *\n * @param {string} $0\n *   Capitalized ASCII leter.\n * @returns {string}\n *   Dash and lower letter.\n */\nfunction toDash($0) {\n  return '-' + $0.toLowerCase()\n}\n","/**\n * @typedef Options\n *   Configuration for `stringify`.\n * @property {boolean} [padLeft=true]\n *   Whether to pad a space before a token.\n * @property {boolean} [padRight=false]\n *   Whether to pad a space after a token.\n */\n\n/**\n * @typedef {Options} StringifyOptions\n *   Please use `StringifyOptions` instead.\n */\n\n/**\n * Parse comma-separated tokens to an array.\n *\n * @param {string} value\n *   Comma-separated tokens.\n * @returns {Array<string>}\n *   List of tokens.\n */\nexport function parse(value) {\n  /** @type {Array<string>} */\n  const tokens = []\n  const input = String(value || '')\n  let index = input.indexOf(',')\n  let start = 0\n  /** @type {boolean} */\n  let end = false\n\n  while (!end) {\n    if (index === -1) {\n      index = input.length\n      end = true\n    }\n\n    const token = input.slice(start, index).trim()\n\n    if (token || !end) {\n      tokens.push(token)\n    }\n\n    start = index + 1\n    index = input.indexOf(',', start)\n  }\n\n  return tokens\n}\n\n/**\n * Serialize an array of strings or numbers to comma-separated tokens.\n *\n * @param {Array<string|number>} values\n *   List of tokens.\n * @param {Options} [options]\n *   Configuration for `stringify` (optional).\n * @returns {string}\n *   Comma-separated tokens.\n */\nexport function stringify(values, options) {\n  const settings = options || {}\n\n  // Ensure the last empty entry is seen.\n  const input = values[values.length - 1] === '' ? [...values, ''] : values\n\n  return input\n    .join(\n      (settings.padRight ? ' ' : '') +\n        ',' +\n        (settings.padLeft === false ? '' : ' ')\n    )\n    .trim()\n}\n","/**\n * Parse space-separated tokens to an array of strings.\n *\n * @param {string} value\n *   Space-separated tokens.\n * @returns {Array<string>}\n *   List of tokens.\n */\nexport function parse(value) {\n  const input = String(value || '').trim()\n  return input ? input.split(/[ \\t\\n\\r\\f]+/g) : []\n}\n\n/**\n * Serialize an array of strings as space separated-tokens.\n *\n * @param {Array<string|number>} values\n *   List of tokens.\n * @returns {string}\n *   Space-separated tokens.\n */\nexport function stringify(values) {\n  return values.join(' ').trim()\n}\n","/**\n * HTML URL properties.\n *\n * Each key is a property name and each value is a list of tag names it applies\n * to or `null` if it applies to all elements.\n *\n * @type {Record<string, Array<string> | null>}\n */\nexport const urlAttributes = {\n  action: ['form'],\n  cite: ['blockquote', 'del', 'ins', 'q'],\n  data: ['object'],\n  formAction: ['button', 'input'],\n  href: ['a', 'area', 'base', 'link'],\n  icon: ['menuitem'],\n  itemId: null,\n  manifest: ['html'],\n  ping: ['a', 'area'],\n  poster: ['video'],\n  src: [\n    'audio',\n    'embed',\n    'iframe',\n    'img',\n    'input',\n    'script',\n    'source',\n    'track',\n    'video'\n  ]\n}\n","/**\n * @typedef {import('mdast').Nodes} Nodes\n *\n * @typedef Options\n *   Configuration (optional).\n * @property {boolean | null | undefined} [includeImageAlt=true]\n *   Whether to use `alt` for `image`s (default: `true`).\n * @property {boolean | null | undefined} [includeHtml=true]\n *   Whether to use `value` of HTML (default: `true`).\n */\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Get the text content of a node or list of nodes.\n *\n * Prefers the node’s plain-text fields, otherwise serializes its children,\n * and if the given value is an array, serialize the nodes in it.\n *\n * @param {unknown} [value]\n *   Thing to serialize, typically `Node`.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {string}\n *   Serialized `value`.\n */\nexport function toString(value, options) {\n  const settings = options || emptyOptions\n  const includeImageAlt =\n    typeof settings.includeImageAlt === 'boolean'\n      ? settings.includeImageAlt\n      : true\n  const includeHtml =\n    typeof settings.includeHtml === 'boolean' ? settings.includeHtml : true\n\n  return one(value, includeImageAlt, includeHtml)\n}\n\n/**\n * One node or several nodes.\n *\n * @param {unknown} value\n *   Thing to serialize.\n * @param {boolean} includeImageAlt\n *   Include image `alt`s.\n * @param {boolean} includeHtml\n *   Include HTML.\n * @returns {string}\n *   Serialized node.\n */\nfunction one(value, includeImageAlt, includeHtml) {\n  if (node(value)) {\n    if ('value' in value) {\n      return value.type === 'html' && !includeHtml ? '' : value.value\n    }\n\n    if (includeImageAlt && 'alt' in value && value.alt) {\n      return value.alt\n    }\n\n    if ('children' in value) {\n      return all(value.children, includeImageAlt, includeHtml)\n    }\n  }\n\n  if (Array.isArray(value)) {\n    return all(value, includeImageAlt, includeHtml)\n  }\n\n  return ''\n}\n\n/**\n * Serialize a list of nodes.\n *\n * @param {Array<unknown>} values\n *   Thing to serialize.\n * @param {boolean} includeImageAlt\n *   Include image `alt`s.\n * @param {boolean} includeHtml\n *   Include HTML.\n * @returns {string}\n *   Serialized nodes.\n */\nfunction all(values, includeImageAlt, includeHtml) {\n  /** @type {Array<string>} */\n  const result = []\n  let index = -1\n\n  while (++index < values.length) {\n    result[index] = one(values[index], includeImageAlt, includeHtml)\n  }\n\n  return result.join('')\n}\n\n/**\n * Check if `value` looks like a node.\n *\n * @param {unknown} value\n *   Thing.\n * @returns {value is Nodes}\n *   Whether `value` is a node.\n */\nfunction node(value) {\n  return Boolean(value && typeof value === 'object')\n}\n","/**\n * Like `Array#splice`, but smarter for giant arrays.\n *\n * `Array#splice` takes all items to be inserted as individual argument which\n * causes a stack overflow in V8 when trying to insert 100k items for instance.\n *\n * Otherwise, this does not return the removed items, and takes `items` as an\n * array instead of rest parameters.\n *\n * @template {unknown} T\n *   Item type.\n * @param {Array<T>} list\n *   List to operate on.\n * @param {number} start\n *   Index to remove/insert at (can be negative).\n * @param {number} remove\n *   Number of items to remove.\n * @param {Array<T>} items\n *   Items to inject into `list`.\n * @returns {undefined}\n *   Nothing.\n */\nexport function splice(list, start, remove, items) {\n  const end = list.length;\n  let chunkStart = 0;\n  /** @type {Array<unknown>} */\n  let parameters;\n\n  // Make start between zero and `end` (included).\n  if (start < 0) {\n    start = -start > end ? 0 : end + start;\n  } else {\n    start = start > end ? end : start;\n  }\n  remove = remove > 0 ? remove : 0;\n\n  // No need to chunk the items if there’s only a couple (10k) items.\n  if (items.length < 10000) {\n    parameters = Array.from(items);\n    parameters.unshift(start, remove);\n    // @ts-expect-error Hush, it’s fine.\n    list.splice(...parameters);\n  } else {\n    // Delete `remove` items starting from `start`\n    if (remove) list.splice(start, remove);\n\n    // Insert the items in chunks to not cause stack overflows.\n    while (chunkStart < items.length) {\n      parameters = items.slice(chunkStart, chunkStart + 10000);\n      parameters.unshift(start, 0);\n      // @ts-expect-error Hush, it’s fine.\n      list.splice(...parameters);\n      chunkStart += 10000;\n      start += 10000;\n    }\n  }\n}\n\n/**\n * Append `items` (an array) at the end of `list` (another array).\n * When `list` was empty, returns `items` instead.\n *\n * This prevents a potentially expensive operation when `list` is empty,\n * and adds items in batches to prevent V8 from hanging.\n *\n * @template {unknown} T\n *   Item type.\n * @param {Array<T>} list\n *   List to operate on.\n * @param {Array<T>} items\n *   Items to add to `list`.\n * @returns {Array<T>}\n *   Either `list` or `items`.\n */\nexport function push(list, items) {\n  if (list.length > 0) {\n    splice(list, list.length, 0, items);\n    return list;\n  }\n  return items;\n}","/**\n * Some of the internal operations of micromark do lots of editing\n * operations on very large arrays. This runs into problems with two\n * properties of most circa-2020 JavaScript interpreters:\n *\n *  - Array-length modifications at the high end of an array (push/pop) are\n *    expected to be common and are implemented in (amortized) time\n *    proportional to the number of elements added or removed, whereas\n *    other operations (shift/unshift and splice) are much less efficient.\n *  - Function arguments are passed on the stack, so adding tens of thousands\n *    of elements to an array with `arr.push[...newElements]` will frequently\n *    cause stack overflows. (see <https://stackoverflow.com/questions/22123769/rangeerror-maximum-call-stack-size-exceeded-why>)\n *\n * SpliceBuffers are an implementation of gap buffers, which are a\n * generalization of the \"queue made of two stacks\" idea. The splice buffer\n * maintains a cursor, and moving the cursor has cost proportional to the\n * distance the cursor moves, but inserting, deleting, or splicing in\n * new information at the cursor is as efficient as the push/pop operation.\n * This allows for an efficient sequence of splices (or pushes, pops, shifts,\n * or unshifts) as long such edits happen at the same part of the array or\n * generally sweep through the array from the beginning to the end.\n *\n * The interface for splice buffers also supports large numbers of inputs by\n * passing a single array argument rather passing multiple arguments on the\n * function call stack.\n *\n * @template T\n *   Item type.\n */\nexport class SpliceBuffer {\n  /**\n   * @param {ReadonlyArray<T> | null | undefined} [initial]\n   *   Initial items (optional).\n   * @returns\n   *   Splice buffer.\n   */\n  constructor(initial) {\n    /** @type {Array<T>} */\n    this.left = initial ? [...initial] : [];\n    /** @type {Array<T>} */\n    this.right = [];\n  }\n\n  /**\n   * Array access;\n   * does not move the cursor.\n   *\n   * @param {number} index\n   *   Index.\n   * @return {T}\n   *   Item.\n   */\n  get(index) {\n    if (index < 0 || index >= this.left.length + this.right.length) {\n      throw new RangeError('Cannot access index `' + index + '` in a splice buffer of size `' + (this.left.length + this.right.length) + '`');\n    }\n    if (index < this.left.length) return this.left[index];\n    return this.right[this.right.length - index + this.left.length - 1];\n  }\n\n  /**\n   * The length of the splice buffer, one greater than the largest index in the\n   * array.\n   */\n  get length() {\n    return this.left.length + this.right.length;\n  }\n\n  /**\n   * Remove and return `list[0]`;\n   * moves the cursor to `0`.\n   *\n   * @returns {T | undefined}\n   *   Item, optional.\n   */\n  shift() {\n    this.setCursor(0);\n    return this.right.pop();\n  }\n\n  /**\n   * Slice the buffer to get an array;\n   * does not move the cursor.\n   *\n   * @param {number} start\n   *   Start.\n   * @param {number | null | undefined} [end]\n   *   End (optional).\n   * @returns {Array<T>}\n   *   Array of items.\n   */\n  slice(start, end) {\n    /** @type {number} */\n    const stop = end === null || end === undefined ? Number.POSITIVE_INFINITY : end;\n    if (stop < this.left.length) {\n      return this.left.slice(start, stop);\n    }\n    if (start > this.left.length) {\n      return this.right.slice(this.right.length - stop + this.left.length, this.right.length - start + this.left.length).reverse();\n    }\n    const list = this.left.slice(start);\n    list.push(...this.right.slice(this.right.length - stop + this.left.length).reverse());\n    return list;\n  }\n\n  /**\n   * Mimics the behavior of Array.prototype.splice() except for the change of\n   * interface necessary to avoid segfaults when patching in very large arrays.\n   *\n   * This operation moves cursor is moved to `start` and results in the cursor\n   * placed after any inserted items.\n   *\n   * @param {number} start\n   *   Start;\n   *   zero-based index at which to start changing the array;\n   *   negative numbers count backwards from the end of the array and values\n   *   that are out-of bounds are clamped to the appropriate end of the array.\n   * @param {number | null | undefined} [deleteCount=0]\n   *   Delete count (default: `0`);\n   *   maximum number of elements to delete, starting from start.\n   * @param {Array<T> | null | undefined} [items=[]]\n   *   Items to include in place of the deleted items (default: `[]`).\n   * @return {Array<T>}\n   *   Any removed items.\n   */\n  splice(start, deleteCount, items) {\n    /** @type {number} */\n    const count = deleteCount || 0;\n    this.setCursor(Math.trunc(start));\n    const removed = this.right.splice(this.right.length - count, Number.POSITIVE_INFINITY);\n    if (items) chunkedPush(this.left, items);\n    return removed.reverse();\n  }\n\n  /**\n   * Remove and return the highest-numbered item in the array, so\n   * `list[list.length - 1]`;\n   * Moves the cursor to `length`.\n   *\n   * @returns {T | undefined}\n   *   Item, optional.\n   */\n  pop() {\n    this.setCursor(Number.POSITIVE_INFINITY);\n    return this.left.pop();\n  }\n\n  /**\n   * Inserts a single item to the high-numbered side of the array;\n   * moves the cursor to `length`.\n   *\n   * @param {T} item\n   *   Item.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  push(item) {\n    this.setCursor(Number.POSITIVE_INFINITY);\n    this.left.push(item);\n  }\n\n  /**\n   * Inserts many items to the high-numbered side of the array.\n   * Moves the cursor to `length`.\n   *\n   * @param {Array<T>} items\n   *   Items.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  pushMany(items) {\n    this.setCursor(Number.POSITIVE_INFINITY);\n    chunkedPush(this.left, items);\n  }\n\n  /**\n   * Inserts a single item to the low-numbered side of the array;\n   * Moves the cursor to `0`.\n   *\n   * @param {T} item\n   *   Item.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  unshift(item) {\n    this.setCursor(0);\n    this.right.push(item);\n  }\n\n  /**\n   * Inserts many items to the low-numbered side of the array;\n   * moves the cursor to `0`.\n   *\n   * @param {Array<T>} items\n   *   Items.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  unshiftMany(items) {\n    this.setCursor(0);\n    chunkedPush(this.right, items.reverse());\n  }\n\n  /**\n   * Move the cursor to a specific position in the array. Requires\n   * time proportional to the distance moved.\n   *\n   * If `n < 0`, the cursor will end up at the beginning.\n   * If `n > length`, the cursor will end up at the end.\n   *\n   * @param {number} n\n   *   Position.\n   * @return {undefined}\n   *   Nothing.\n   */\n  setCursor(n) {\n    if (n === this.left.length || n > this.left.length && this.right.length === 0 || n < 0 && this.left.length === 0) return;\n    if (n < this.left.length) {\n      // Move cursor to the this.left\n      const removed = this.left.splice(n, Number.POSITIVE_INFINITY);\n      chunkedPush(this.right, removed.reverse());\n    } else {\n      // Move cursor to the this.right\n      const removed = this.right.splice(this.left.length + this.right.length - n, Number.POSITIVE_INFINITY);\n      chunkedPush(this.left, removed.reverse());\n    }\n  }\n}\n\n/**\n * Avoid stack overflow by pushing items onto the stack in segments\n *\n * @template T\n *   Item type.\n * @param {Array<T>} list\n *   List to inject into.\n * @param {ReadonlyArray<T>} right\n *   Items to inject.\n * @return {undefined}\n *   Nothing.\n */\nfunction chunkedPush(list, right) {\n  /** @type {number} */\n  let chunkStart = 0;\n  if (right.length < 10000) {\n    list.push(...right);\n  } else {\n    while (chunkStart < right.length) {\n      list.push(...right.slice(chunkStart, chunkStart + 10000));\n      chunkStart += 10000;\n    }\n  }\n}","/**\n * @import {Chunk, Event, Token} from 'micromark-util-types'\n */\n\nimport { splice } from 'micromark-util-chunked';\nimport { SpliceBuffer } from './lib/splice-buffer.js';\n\n// Hidden API exposed for testing.\nexport { SpliceBuffer } from './lib/splice-buffer.js';\n\n/**\n * Tokenize subcontent.\n *\n * @param {Array<Event>} eventsArray\n *   List of events.\n * @returns {boolean}\n *   Whether subtokens were found.\n */\n// eslint-disable-next-line complexity\nexport function subtokenize(eventsArray) {\n  /** @type {Record<string, number>} */\n  const jumps = {};\n  let index = -1;\n  /** @type {Event} */\n  let event;\n  /** @type {number | undefined} */\n  let lineIndex;\n  /** @type {number} */\n  let otherIndex;\n  /** @type {Event} */\n  let otherEvent;\n  /** @type {Array<Event>} */\n  let parameters;\n  /** @type {Array<Event>} */\n  let subevents;\n  /** @type {boolean | undefined} */\n  let more;\n  const events = new SpliceBuffer(eventsArray);\n  while (++index < events.length) {\n    while (index in jumps) {\n      index = jumps[index];\n    }\n    event = events.get(index);\n\n    // Add a hook for the GFM tasklist extension, which needs to know if text\n    // is in the first content of a list item.\n    if (index && event[1].type === \"chunkFlow\" && events.get(index - 1)[1].type === \"listItemPrefix\") {\n      subevents = event[1]._tokenizer.events;\n      otherIndex = 0;\n      if (otherIndex < subevents.length && subevents[otherIndex][1].type === \"lineEndingBlank\") {\n        otherIndex += 2;\n      }\n      if (otherIndex < subevents.length && subevents[otherIndex][1].type === \"content\") {\n        while (++otherIndex < subevents.length) {\n          if (subevents[otherIndex][1].type === \"content\") {\n            break;\n          }\n          if (subevents[otherIndex][1].type === \"chunkText\") {\n            subevents[otherIndex][1]._isInFirstContentOfListItem = true;\n            otherIndex++;\n          }\n        }\n      }\n    }\n\n    // Enter.\n    if (event[0] === 'enter') {\n      if (event[1].contentType) {\n        Object.assign(jumps, subcontent(events, index));\n        index = jumps[index];\n        more = true;\n      }\n    }\n    // Exit.\n    else if (event[1]._container) {\n      otherIndex = index;\n      lineIndex = undefined;\n      while (otherIndex--) {\n        otherEvent = events.get(otherIndex);\n        if (otherEvent[1].type === \"lineEnding\" || otherEvent[1].type === \"lineEndingBlank\") {\n          if (otherEvent[0] === 'enter') {\n            if (lineIndex) {\n              events.get(lineIndex)[1].type = \"lineEndingBlank\";\n            }\n            otherEvent[1].type = \"lineEnding\";\n            lineIndex = otherIndex;\n          }\n        } else {\n          break;\n        }\n      }\n      if (lineIndex) {\n        // Fix position.\n        event[1].end = {\n          ...events.get(lineIndex)[1].start\n        };\n\n        // Switch container exit w/ line endings.\n        parameters = events.slice(lineIndex, index);\n        parameters.unshift(event);\n        events.splice(lineIndex, index - lineIndex + 1, parameters);\n      }\n    }\n  }\n\n  // The changes to the `events` buffer must be copied back into the eventsArray\n  splice(eventsArray, 0, Number.POSITIVE_INFINITY, events.slice(0));\n  return !more;\n}\n\n/**\n * Tokenize embedded tokens.\n *\n * @param {SpliceBuffer<Event>} events\n *   Events.\n * @param {number} eventIndex\n *   Index.\n * @returns {Record<string, number>}\n *   Gaps.\n */\nfunction subcontent(events, eventIndex) {\n  const token = events.get(eventIndex)[1];\n  const context = events.get(eventIndex)[2];\n  let startPosition = eventIndex - 1;\n  /** @type {Array<number>} */\n  const startPositions = [];\n  const tokenizer = token._tokenizer || context.parser[token.contentType](token.start);\n  const childEvents = tokenizer.events;\n  /** @type {Array<[number, number]>} */\n  const jumps = [];\n  /** @type {Record<string, number>} */\n  const gaps = {};\n  /** @type {Array<Chunk>} */\n  let stream;\n  /** @type {Token | undefined} */\n  let previous;\n  let index = -1;\n  /** @type {Token | undefined} */\n  let current = token;\n  let adjust = 0;\n  let start = 0;\n  const breaks = [start];\n\n  // Loop forward through the linked tokens to pass them in order to the\n  // subtokenizer.\n  while (current) {\n    // Find the position of the event for this token.\n    while (events.get(++startPosition)[1] !== current) {\n      // Empty.\n    }\n    startPositions.push(startPosition);\n    if (!current._tokenizer) {\n      stream = context.sliceStream(current);\n      if (!current.next) {\n        stream.push(null);\n      }\n      if (previous) {\n        tokenizer.defineSkip(current.start);\n      }\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = true;\n      }\n      tokenizer.write(stream);\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = undefined;\n      }\n    }\n\n    // Unravel the next token.\n    previous = current;\n    current = current.next;\n  }\n\n  // Now, loop back through all events (and linked tokens), to figure out which\n  // parts belong where.\n  current = token;\n  while (++index < childEvents.length) {\n    if (\n    // Find a void token that includes a break.\n    childEvents[index][0] === 'exit' && childEvents[index - 1][0] === 'enter' && childEvents[index][1].type === childEvents[index - 1][1].type && childEvents[index][1].start.line !== childEvents[index][1].end.line) {\n      start = index + 1;\n      breaks.push(start);\n      // Help GC.\n      current._tokenizer = undefined;\n      current.previous = undefined;\n      current = current.next;\n    }\n  }\n\n  // Help GC.\n  tokenizer.events = [];\n\n  // If there’s one more token (which is the cases for lines that end in an\n  // EOF), that’s perfect: the last point we found starts it.\n  // If there isn’t then make sure any remaining content is added to it.\n  if (current) {\n    // Help GC.\n    current._tokenizer = undefined;\n    current.previous = undefined;\n  } else {\n    breaks.pop();\n  }\n\n  // Now splice the events from the subtokenizer into the current events,\n  // moving back to front so that splice indices aren’t affected.\n  index = breaks.length;\n  while (index--) {\n    const slice = childEvents.slice(breaks[index], breaks[index + 1]);\n    const start = startPositions.pop();\n    jumps.push([start, start + slice.length - 1]);\n    events.splice(start, 2, slice);\n  }\n  jumps.reverse();\n  index = -1;\n  while (++index < jumps.length) {\n    gaps[adjust + jumps[index][0]] = adjust + jumps[index][1];\n    adjust += jumps[index][1] - jumps[index][0] - 1;\n  }\n  return gaps;\n}","/**\n * @import {\n *   Extension,\n *   Handles,\n *   HtmlExtension,\n *   NormalizedExtension\n * } from 'micromark-util-types'\n */\n\nimport {splice} from 'micromark-util-chunked'\n\nconst hasOwnProperty = {}.hasOwnProperty\n\n/**\n * Combine multiple syntax extensions into one.\n *\n * @param {ReadonlyArray<Extension>} extensions\n *   List of syntax extensions.\n * @returns {NormalizedExtension}\n *   A single combined extension.\n */\nexport function combineExtensions(extensions) {\n  /** @type {NormalizedExtension} */\n  const all = {}\n  let index = -1\n\n  while (++index < extensions.length) {\n    syntaxExtension(all, extensions[index])\n  }\n\n  return all\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {NormalizedExtension} all\n *   Extension to merge into.\n * @param {Extension} extension\n *   Extension to merge.\n * @returns {undefined}\n *   Nothing.\n */\nfunction syntaxExtension(all, extension) {\n  /** @type {keyof Extension} */\n  let hook\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n    /** @type {Record<string, unknown>} */\n    const left = maybe || (all[hook] = {})\n    /** @type {Record<string, unknown> | undefined} */\n    const right = extension[hook]\n    /** @type {string} */\n    let code\n\n    if (right) {\n      for (code in right) {\n        if (!hasOwnProperty.call(left, code)) left[code] = []\n        const value = right[code]\n        constructs(\n          // @ts-expect-error Looks like a list.\n          left[code],\n          Array.isArray(value) ? value : value ? [value] : []\n        )\n      }\n    }\n  }\n}\n\n/**\n * Merge `list` into `existing` (both lists of constructs).\n * Mutates `existing`.\n *\n * @param {Array<unknown>} existing\n *   List of constructs to merge into.\n * @param {Array<unknown>} list\n *   List of constructs to merge.\n * @returns {undefined}\n *   Nothing.\n */\nfunction constructs(existing, list) {\n  let index = -1\n  /** @type {Array<unknown>} */\n  const before = []\n\n  while (++index < list.length) {\n    // @ts-expect-error Looks like an object.\n    ;(list[index].add === 'after' ? existing : before).push(list[index])\n  }\n\n  splice(existing, 0, 0, before)\n}\n\n/**\n * Combine multiple HTML extensions into one.\n *\n * @param {ReadonlyArray<HtmlExtension>} htmlExtensions\n *   List of HTML extensions.\n * @returns {HtmlExtension}\n *   Single combined HTML extension.\n */\nexport function combineHtmlExtensions(htmlExtensions) {\n  /** @type {HtmlExtension} */\n  const handlers = {}\n  let index = -1\n\n  while (++index < htmlExtensions.length) {\n    htmlExtension(handlers, htmlExtensions[index])\n  }\n\n  return handlers\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {HtmlExtension} all\n *   Extension to merge into.\n * @param {HtmlExtension} extension\n *   Extension to merge.\n * @returns {undefined}\n *   Nothing.\n */\nfunction htmlExtension(all, extension) {\n  /** @type {keyof HtmlExtension} */\n  let hook\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n    const left = maybe || (all[hook] = {})\n    const right = extension[hook]\n    /** @type {keyof Handles} */\n    let type\n\n    if (right) {\n      for (type in right) {\n        // @ts-expect-error assume document vs regular handler are managed correctly.\n        left[type] = right[type]\n      }\n    }\n  }\n}\n","/**\n * @import {Code} from 'micromark-util-types'\n */\n\n/**\n * Check whether the character code represents an ASCII alpha (`a` through `z`,\n * case insensitive).\n *\n * An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.\n *\n * An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)\n * to U+005A (`Z`).\n *\n * An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)\n * to U+007A (`z`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAlpha = regexCheck(/[A-Za-z]/);\n\n/**\n * Check whether the character code represents an ASCII alphanumeric (`a`\n * through `z`, case insensitive, or `0` through `9`).\n *\n * An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha\n * (see `asciiAlpha`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/);\n\n/**\n * Check whether the character code represents an ASCII atext.\n *\n * atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in\n * the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`),\n * U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F\n * SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E\n * CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE\n * (`{`) to U+007E TILDE (`~`).\n *\n * See:\n * **\\[RFC5322]**:\n * [Internet Message Format](https://tools.ietf.org/html/rfc5322).\n * P. Resnick.\n * IETF.\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/);\n\n/**\n * Check whether a character code is an ASCII control character.\n *\n * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)\n * to U+001F (US), or U+007F (DEL).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function asciiControl(code) {\n  return (\n    // Special whitespace codes (which have negative values), C0 and Control\n    // character DEL\n    code !== null && (code < 32 || code === 127)\n  );\n}\n\n/**\n * Check whether the character code represents an ASCII digit (`0` through `9`).\n *\n * An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to\n * U+0039 (`9`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiDigit = regexCheck(/\\d/);\n\n/**\n * Check whether the character code represents an ASCII hex digit (`a` through\n * `f`, case insensitive, or `0` through `9`).\n *\n * An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex\n * digit, or an ASCII lower hex digit.\n *\n * An **ASCII upper hex digit** is a character in the inclusive range U+0041\n * (`A`) to U+0046 (`F`).\n *\n * An **ASCII lower hex digit** is a character in the inclusive range U+0061\n * (`a`) to U+0066 (`f`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiHexDigit = regexCheck(/[\\dA-Fa-f]/);\n\n/**\n * Check whether the character code represents ASCII punctuation.\n *\n * An **ASCII punctuation** is a character in the inclusive ranges U+0021\n * EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT\n * SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT\n * (`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);\n\n/**\n * Check whether a character code is a markdown line ending.\n *\n * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN\n * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).\n *\n * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE\n * RETURN (CR) are replaced by these virtual characters depending on whether\n * they occurred together.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEnding(code) {\n  return code !== null && code < -2;\n}\n\n/**\n * Check whether a character code is a markdown line ending (see\n * `markdownLineEnding`) or markdown space (see `markdownSpace`).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEndingOrSpace(code) {\n  return code !== null && (code < 0 || code === 32);\n}\n\n/**\n * Check whether a character code is a markdown space.\n *\n * A **markdown space** is the concrete character U+0020 SPACE (SP) and the\n * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).\n *\n * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is\n * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL\n * SPACE (VS) characters, depending on the column at which the tab occurred.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32;\n}\n\n// Size note: removing ASCII from the regex and using `asciiPunctuation` here\n// In fact adds to the bundle size.\n/**\n * Check whether the character code represents Unicode punctuation.\n *\n * A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,\n * Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`\n * (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`\n * (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII\n * punctuation (see `asciiPunctuation`).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodePunctuation = regexCheck(/\\p{P}|\\p{S}/u);\n\n/**\n * Check whether the character code represents Unicode whitespace.\n *\n * Note that this does handle micromark specific markdown whitespace characters.\n * See `markdownLineEndingOrSpace` to check that.\n *\n * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,\n * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),\n * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\\[UNICODE]**).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodeWhitespace = regexCheck(/\\s/);\n\n/**\n * Create a code check from a regex.\n *\n * @param {RegExp} regex\n *   Expression.\n * @returns {(code: Code) => boolean}\n *   Check.\n */\nfunction regexCheck(regex) {\n  return check;\n\n  /**\n   * Check whether a code matches the bound regex.\n   *\n   * @param {Code} code\n   *   Character code.\n   * @returns {boolean}\n   *   Whether the character code matches the bound regex.\n   */\n  function check(code) {\n    return code !== null && code > -1 && regex.test(String.fromCharCode(code));\n  }\n}","/**\n * @import {Effects, State, TokenType} from 'micromark-util-types'\n */\n\nimport { markdownSpace } from 'micromark-util-character';\n\n// To do: implement `spaceOrTab`, `spaceOrTabMinMax`, `spaceOrTabWithOptions`.\n\n/**\n * Parse spaces and tabs.\n *\n * There is no `nok` parameter:\n *\n * *   spaces in markdown are often optional, in which case this factory can be\n *     used and `ok` will be switched to whether spaces were found or not\n * *   one line ending or space can be detected with `markdownSpace(code)` right\n *     before using `factorySpace`\n *\n * ###### Examples\n *\n * Where `␉` represents a tab (plus how much it expands) and `␠` represents a\n * single space.\n *\n * ```markdown\n * ␉\n * ␠␠␠␠\n * ␉␠\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {TokenType} type\n *   Type (`' \\t'`).\n * @param {number | undefined} [max=Infinity]\n *   Max (exclusive).\n * @returns {State}\n *   Start state.\n */\nexport function factorySpace(effects, ok, type, max) {\n  const limit = max ? max - 1 : Number.POSITIVE_INFINITY;\n  let size = 0;\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    if (markdownSpace(code)) {\n      effects.enter(type);\n      return prefix(code);\n    }\n    return ok(code);\n  }\n\n  /** @type {State} */\n  function prefix(code) {\n    if (markdownSpace(code) && size++ < limit) {\n      effects.consume(code);\n      return prefix;\n    }\n    effects.exit(type);\n    return ok(code);\n  }\n}","/**\n * @import {\n *   InitialConstruct,\n *   Initializer,\n *   State,\n *   TokenizeContext,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {InitialConstruct} */\nexport const content = {\n  tokenize: initializeContent\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Initializer}\n *   Content.\n */\nfunction initializeContent(effects) {\n  const contentStart = effects.attempt(this.parser.constructs.contentInitial, afterContentStartConstruct, paragraphInitial);\n  /** @type {Token} */\n  let previous;\n  return contentStart;\n\n  /** @type {State} */\n  function afterContentStartConstruct(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return factorySpace(effects, contentStart, \"linePrefix\");\n  }\n\n  /** @type {State} */\n  function paragraphInitial(code) {\n    effects.enter(\"paragraph\");\n    return lineStart(code);\n  }\n\n  /** @type {State} */\n  function lineStart(code) {\n    const token = effects.enter(\"chunkText\", {\n      contentType: \"text\",\n      previous\n    });\n    if (previous) {\n      previous.next = token;\n    }\n    previous = token;\n    return data(code);\n  }\n\n  /** @type {State} */\n  function data(code) {\n    if (code === null) {\n      effects.exit(\"chunkText\");\n      effects.exit(\"paragraph\");\n      effects.consume(code);\n      return;\n    }\n    if (markdownLineEnding(code)) {\n      effects.consume(code);\n      effects.exit(\"chunkText\");\n      return lineStart;\n    }\n\n    // Data.\n    effects.consume(code);\n    return data;\n  }\n}","/**\n * @import {\n *   Construct,\n *   ContainerState,\n *   InitialConstruct,\n *   Initializer,\n *   Point,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\n/**\n * @typedef {[Construct, ContainerState]} StackItem\n *   Construct and its state.\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\nimport { splice } from 'micromark-util-chunked';\n/** @type {InitialConstruct} */\nexport const document = {\n  tokenize: initializeDocument\n};\n\n/** @type {Construct} */\nconst containerConstruct = {\n  tokenize: tokenizeContainer\n};\n\n/**\n * @this {TokenizeContext}\n *   Self.\n * @type {Initializer}\n *   Initializer.\n */\nfunction initializeDocument(effects) {\n  const self = this;\n  /** @type {Array<StackItem>} */\n  const stack = [];\n  let continued = 0;\n  /** @type {TokenizeContext | undefined} */\n  let childFlow;\n  /** @type {Token | undefined} */\n  let childToken;\n  /** @type {number} */\n  let lineStartOffset;\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    // First we iterate through the open blocks, starting with the root\n    // document, and descending through last children down to the last open\n    // block.\n    // Each block imposes a condition that the line must satisfy if the block is\n    // to remain open.\n    // For example, a block quote requires a `>` character.\n    // A paragraph requires a non-blank line.\n    // In this phase we may match all or just some of the open blocks.\n    // But we cannot close unmatched blocks yet, because we may have a lazy\n    // continuation line.\n    if (continued < stack.length) {\n      const item = stack[continued];\n      self.containerState = item[1];\n      return effects.attempt(item[0].continuation, documentContinue, checkNewContainers)(code);\n    }\n\n    // Done.\n    return checkNewContainers(code);\n  }\n\n  /** @type {State} */\n  function documentContinue(code) {\n    continued++;\n\n    // Note: this field is called `_closeFlow` but it also closes containers.\n    // Perhaps a good idea to rename it but it’s already used in the wild by\n    // extensions.\n    if (self.containerState._closeFlow) {\n      self.containerState._closeFlow = undefined;\n      if (childFlow) {\n        closeFlow();\n      }\n\n      // Note: this algorithm for moving events around is similar to the\n      // algorithm when dealing with lazy lines in `writeToChild`.\n      const indexBeforeExits = self.events.length;\n      let indexBeforeFlow = indexBeforeExits;\n      /** @type {Point | undefined} */\n      let point;\n\n      // Find the flow chunk.\n      while (indexBeforeFlow--) {\n        if (self.events[indexBeforeFlow][0] === 'exit' && self.events[indexBeforeFlow][1].type === \"chunkFlow\") {\n          point = self.events[indexBeforeFlow][1].end;\n          break;\n        }\n      }\n      exitContainers(continued);\n\n      // Fix positions.\n      let index = indexBeforeExits;\n      while (index < self.events.length) {\n        self.events[index][1].end = {\n          ...point\n        };\n        index++;\n      }\n\n      // Inject the exits earlier (they’re still also at the end).\n      splice(self.events, indexBeforeFlow + 1, 0, self.events.slice(indexBeforeExits));\n\n      // Discard the duplicate exits.\n      self.events.length = index;\n      return checkNewContainers(code);\n    }\n    return start(code);\n  }\n\n  /** @type {State} */\n  function checkNewContainers(code) {\n    // Next, after consuming the continuation markers for existing blocks, we\n    // look for new block starts (e.g. `>` for a block quote).\n    // If we encounter a new block start, we close any blocks unmatched in\n    // step 1 before creating the new block as a child of the last matched\n    // block.\n    if (continued === stack.length) {\n      // No need to `check` whether there’s a container, of `exitContainers`\n      // would be moot.\n      // We can instead immediately `attempt` to parse one.\n      if (!childFlow) {\n        return documentContinued(code);\n      }\n\n      // If we have concrete content, such as block HTML or fenced code,\n      // we can’t have containers “pierce” into them, so we can immediately\n      // start.\n      if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {\n        return flowStart(code);\n      }\n\n      // If we do have flow, it could still be a blank line,\n      // but we’d be interrupting it w/ a new container if there’s a current\n      // construct.\n      // To do: next major: remove `_gfmTableDynamicInterruptHack` (no longer\n      // needed in micromark-extension-gfm-table@1.0.6).\n      self.interrupt = Boolean(childFlow.currentConstruct && !childFlow._gfmTableDynamicInterruptHack);\n    }\n\n    // Check if there is a new container.\n    self.containerState = {};\n    return effects.check(containerConstruct, thereIsANewContainer, thereIsNoNewContainer)(code);\n  }\n\n  /** @type {State} */\n  function thereIsANewContainer(code) {\n    if (childFlow) closeFlow();\n    exitContainers(continued);\n    return documentContinued(code);\n  }\n\n  /** @type {State} */\n  function thereIsNoNewContainer(code) {\n    self.parser.lazy[self.now().line] = continued !== stack.length;\n    lineStartOffset = self.now().offset;\n    return flowStart(code);\n  }\n\n  /** @type {State} */\n  function documentContinued(code) {\n    // Try new containers.\n    self.containerState = {};\n    return effects.attempt(containerConstruct, containerContinue, flowStart)(code);\n  }\n\n  /** @type {State} */\n  function containerContinue(code) {\n    continued++;\n    stack.push([self.currentConstruct, self.containerState]);\n    // Try another.\n    return documentContinued(code);\n  }\n\n  /** @type {State} */\n  function flowStart(code) {\n    if (code === null) {\n      if (childFlow) closeFlow();\n      exitContainers(0);\n      effects.consume(code);\n      return;\n    }\n    childFlow = childFlow || self.parser.flow(self.now());\n    effects.enter(\"chunkFlow\", {\n      _tokenizer: childFlow,\n      contentType: \"flow\",\n      previous: childToken\n    });\n    return flowContinue(code);\n  }\n\n  /** @type {State} */\n  function flowContinue(code) {\n    if (code === null) {\n      writeToChild(effects.exit(\"chunkFlow\"), true);\n      exitContainers(0);\n      effects.consume(code);\n      return;\n    }\n    if (markdownLineEnding(code)) {\n      effects.consume(code);\n      writeToChild(effects.exit(\"chunkFlow\"));\n      // Get ready for the next line.\n      continued = 0;\n      self.interrupt = undefined;\n      return start;\n    }\n    effects.consume(code);\n    return flowContinue;\n  }\n\n  /**\n   * @param {Token} token\n   *   Token.\n   * @param {boolean | undefined} [endOfFile]\n   *   Whether the token is at the end of the file (default: `false`).\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function writeToChild(token, endOfFile) {\n    const stream = self.sliceStream(token);\n    if (endOfFile) stream.push(null);\n    token.previous = childToken;\n    if (childToken) childToken.next = token;\n    childToken = token;\n    childFlow.defineSkip(token.start);\n    childFlow.write(stream);\n\n    // Alright, so we just added a lazy line:\n    //\n    // ```markdown\n    // > a\n    // b.\n    //\n    // Or:\n    //\n    // > ~~~c\n    // d\n    //\n    // Or:\n    //\n    // > | e |\n    // f\n    // ```\n    //\n    // The construct in the second example (fenced code) does not accept lazy\n    // lines, so it marked itself as done at the end of its first line, and\n    // then the content construct parses `d`.\n    // Most constructs in markdown match on the first line: if the first line\n    // forms a construct, a non-lazy line can’t “unmake” it.\n    //\n    // The construct in the third example is potentially a GFM table, and\n    // those are *weird*.\n    // It *could* be a table, from the first line, if the following line\n    // matches a condition.\n    // In this case, that second line is lazy, which “unmakes” the first line\n    // and turns the whole into one content block.\n    //\n    // We’ve now parsed the non-lazy and the lazy line, and can figure out\n    // whether the lazy line started a new flow block.\n    // If it did, we exit the current containers between the two flow blocks.\n    if (self.parser.lazy[token.start.line]) {\n      let index = childFlow.events.length;\n      while (index--) {\n        if (\n        // The token starts before the line ending…\n        childFlow.events[index][1].start.offset < lineStartOffset && (\n        // …and either is not ended yet…\n        !childFlow.events[index][1].end ||\n        // …or ends after it.\n        childFlow.events[index][1].end.offset > lineStartOffset)) {\n          // Exit: there’s still something open, which means it’s a lazy line\n          // part of something.\n          return;\n        }\n      }\n\n      // Note: this algorithm for moving events around is similar to the\n      // algorithm when closing flow in `documentContinue`.\n      const indexBeforeExits = self.events.length;\n      let indexBeforeFlow = indexBeforeExits;\n      /** @type {boolean | undefined} */\n      let seen;\n      /** @type {Point | undefined} */\n      let point;\n\n      // Find the previous chunk (the one before the lazy line).\n      while (indexBeforeFlow--) {\n        if (self.events[indexBeforeFlow][0] === 'exit' && self.events[indexBeforeFlow][1].type === \"chunkFlow\") {\n          if (seen) {\n            point = self.events[indexBeforeFlow][1].end;\n            break;\n          }\n          seen = true;\n        }\n      }\n      exitContainers(continued);\n\n      // Fix positions.\n      index = indexBeforeExits;\n      while (index < self.events.length) {\n        self.events[index][1].end = {\n          ...point\n        };\n        index++;\n      }\n\n      // Inject the exits earlier (they’re still also at the end).\n      splice(self.events, indexBeforeFlow + 1, 0, self.events.slice(indexBeforeExits));\n\n      // Discard the duplicate exits.\n      self.events.length = index;\n    }\n  }\n\n  /**\n   * @param {number} size\n   *   Size.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function exitContainers(size) {\n    let index = stack.length;\n\n    // Exit open containers.\n    while (index-- > size) {\n      const entry = stack[index];\n      self.containerState = entry[1];\n      entry[0].exit.call(self, effects);\n    }\n    stack.length = size;\n  }\n  function closeFlow() {\n    childFlow.write([null]);\n    childToken = undefined;\n    childFlow = undefined;\n    self.containerState._closeFlow = undefined;\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n *   Tokenizer.\n */\nfunction tokenizeContainer(effects, ok, nok) {\n  // Always populated by defaults.\n\n  return factorySpace(effects, effects.attempt(this.parser.constructs.document, ok, nok), \"linePrefix\", this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4);\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const blankLine = {\n  partial: true,\n  tokenize: tokenizeBlankLine\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeBlankLine(effects, ok, nok) {\n  return start;\n\n  /**\n   * Start of blank line.\n   *\n   * > 👉 **Note**: `␠` represents a space character.\n   *\n   * ```markdown\n   * > | ␠␠␊\n   *     ^\n   * > | ␊\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    return markdownSpace(code) ? factorySpace(effects, after, \"linePrefix\")(code) : after(code);\n  }\n\n  /**\n   * At eof/eol, after optional whitespace.\n   *\n   * > 👉 **Note**: `␠` represents a space character.\n   *\n   * ```markdown\n   * > | ␠␠␊\n   *       ^\n   * > | ␊\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\nimport { subtokenize } from 'micromark-util-subtokenize';\n/**\n * No name because it must not be turned off.\n * @type {Construct}\n */\nexport const content = {\n  resolve: resolveContent,\n  tokenize: tokenizeContent\n};\n\n/** @type {Construct} */\nconst continuationConstruct = {\n  partial: true,\n  tokenize: tokenizeContinuation\n};\n\n/**\n * Content is transparent: it’s parsed right now. That way, definitions are also\n * parsed right now: before text in paragraphs (specifically, media) are parsed.\n *\n * @type {Resolver}\n */\nfunction resolveContent(events) {\n  subtokenize(events);\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeContent(effects, ok) {\n  /** @type {Token | undefined} */\n  let previous;\n  return chunkStart;\n\n  /**\n   * Before a content chunk.\n   *\n   * ```markdown\n   * > | abc\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function chunkStart(code) {\n    effects.enter(\"content\");\n    previous = effects.enter(\"chunkContent\", {\n      contentType: \"content\"\n    });\n    return chunkInside(code);\n  }\n\n  /**\n   * In a content chunk.\n   *\n   * ```markdown\n   * > | abc\n   *     ^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function chunkInside(code) {\n    if (code === null) {\n      return contentEnd(code);\n    }\n\n    // To do: in `markdown-rs`, each line is parsed on its own, and everything\n    // is stitched together resolving.\n    if (markdownLineEnding(code)) {\n      return effects.check(continuationConstruct, contentContinue, contentEnd)(code);\n    }\n\n    // Data.\n    effects.consume(code);\n    return chunkInside;\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function contentEnd(code) {\n    effects.exit(\"chunkContent\");\n    effects.exit(\"content\");\n    return ok(code);\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function contentContinue(code) {\n    effects.consume(code);\n    effects.exit(\"chunkContent\");\n    previous.next = effects.enter(\"chunkContent\", {\n      contentType: \"content\",\n      previous\n    });\n    previous = previous.next;\n    return chunkInside;\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeContinuation(effects, ok, nok) {\n  const self = this;\n  return startLookahead;\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function startLookahead(code) {\n    effects.exit(\"chunkContent\");\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return factorySpace(effects, prefixed, \"linePrefix\");\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function prefixed(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code);\n    }\n\n    // Always populated by defaults.\n\n    const tail = self.events[self.events.length - 1];\n    if (!self.parser.constructs.disable.null.includes('codeIndented') && tail && tail[1].type === \"linePrefix\" && tail[2].sliceSerialize(tail[1], true).length >= 4) {\n      return ok(code);\n    }\n    return effects.interrupt(self.parser.constructs.flow, nok, ok)(code);\n  }\n}","/**\n * @import {\n *   InitialConstruct,\n *   Initializer,\n *   State,\n *   TokenizeContext\n * } from 'micromark-util-types'\n */\n\nimport { blankLine, content } from 'micromark-core-commonmark';\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {InitialConstruct} */\nexport const flow = {\n  tokenize: initializeFlow\n};\n\n/**\n * @this {TokenizeContext}\n *   Self.\n * @type {Initializer}\n *   Initializer.\n */\nfunction initializeFlow(effects) {\n  const self = this;\n  const initial = effects.attempt(\n  // Try to parse a blank line.\n  blankLine, atBlankEnding,\n  // Try to parse initial flow (essentially, only code).\n  effects.attempt(this.parser.constructs.flowInitial, afterConstruct, factorySpace(effects, effects.attempt(this.parser.constructs.flow, afterConstruct, effects.attempt(content, afterConstruct)), \"linePrefix\")));\n  return initial;\n\n  /** @type {State} */\n  function atBlankEnding(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n    effects.enter(\"lineEndingBlank\");\n    effects.consume(code);\n    effects.exit(\"lineEndingBlank\");\n    self.currentConstruct = undefined;\n    return initial;\n  }\n\n  /** @type {State} */\n  function afterConstruct(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    self.currentConstruct = undefined;\n    return initial;\n  }\n}","/**\n * @import {\n *   Code,\n *   InitialConstruct,\n *   Initializer,\n *   Resolver,\n *   State,\n *   TokenizeContext\n * } from 'micromark-util-types'\n */\n\nexport const resolver = {\n  resolveAll: createResolver()\n};\nexport const string = initializeFactory('string');\nexport const text = initializeFactory('text');\n\n/**\n * @param {'string' | 'text'} field\n *   Field.\n * @returns {InitialConstruct}\n *   Construct.\n */\nfunction initializeFactory(field) {\n  return {\n    resolveAll: createResolver(field === 'text' ? resolveAllLineSuffixes : undefined),\n    tokenize: initializeText\n  };\n\n  /**\n   * @this {TokenizeContext}\n   *   Context.\n   * @type {Initializer}\n   */\n  function initializeText(effects) {\n    const self = this;\n    const constructs = this.parser.constructs[field];\n    const text = effects.attempt(constructs, start, notText);\n    return start;\n\n    /** @type {State} */\n    function start(code) {\n      return atBreak(code) ? text(code) : notText(code);\n    }\n\n    /** @type {State} */\n    function notText(code) {\n      if (code === null) {\n        effects.consume(code);\n        return;\n      }\n      effects.enter(\"data\");\n      effects.consume(code);\n      return data;\n    }\n\n    /** @type {State} */\n    function data(code) {\n      if (atBreak(code)) {\n        effects.exit(\"data\");\n        return text(code);\n      }\n\n      // Data.\n      effects.consume(code);\n      return data;\n    }\n\n    /**\n     * @param {Code} code\n     *   Code.\n     * @returns {boolean}\n     *   Whether the code is a break.\n     */\n    function atBreak(code) {\n      if (code === null) {\n        return true;\n      }\n      const list = constructs[code];\n      let index = -1;\n      if (list) {\n        // Always populated by defaults.\n\n        while (++index < list.length) {\n          const item = list[index];\n          if (!item.previous || item.previous.call(self, self.previous)) {\n            return true;\n          }\n        }\n      }\n      return false;\n    }\n  }\n}\n\n/**\n * @param {Resolver | undefined} [extraResolver]\n *   Resolver.\n * @returns {Resolver}\n *   Resolver.\n */\nfunction createResolver(extraResolver) {\n  return resolveAllText;\n\n  /** @type {Resolver} */\n  function resolveAllText(events, context) {\n    let index = -1;\n    /** @type {number | undefined} */\n    let enter;\n\n    // A rather boring computation (to merge adjacent `data` events) which\n    // improves mm performance by 29%.\n    while (++index <= events.length) {\n      if (enter === undefined) {\n        if (events[index] && events[index][1].type === \"data\") {\n          enter = index;\n          index++;\n        }\n      } else if (!events[index] || events[index][1].type !== \"data\") {\n        // Don’t do anything if there is one data token.\n        if (index !== enter + 2) {\n          events[enter][1].end = events[index - 1][1].end;\n          events.splice(enter + 2, index - enter - 2);\n          index = enter + 2;\n        }\n        enter = undefined;\n      }\n    }\n    return extraResolver ? extraResolver(events, context) : events;\n  }\n}\n\n/**\n * A rather ugly set of instructions which again looks at chunks in the input\n * stream.\n * The reason to do this here is that it is *much* faster to parse in reverse.\n * And that we can’t hook into `null` to split the line suffix before an EOF.\n * To do: figure out if we can make this into a clean utility, or even in core.\n * As it will be useful for GFMs literal autolink extension (and maybe even\n * tables?)\n *\n * @type {Resolver}\n */\nfunction resolveAllLineSuffixes(events, context) {\n  let eventIndex = 0; // Skip first.\n\n  while (++eventIndex <= events.length) {\n    if ((eventIndex === events.length || events[eventIndex][1].type === \"lineEnding\") && events[eventIndex - 1][1].type === \"data\") {\n      const data = events[eventIndex - 1][1];\n      const chunks = context.sliceStream(data);\n      let index = chunks.length;\n      let bufferIndex = -1;\n      let size = 0;\n      /** @type {boolean | undefined} */\n      let tabs;\n      while (index--) {\n        const chunk = chunks[index];\n        if (typeof chunk === 'string') {\n          bufferIndex = chunk.length;\n          while (chunk.charCodeAt(bufferIndex - 1) === 32) {\n            size++;\n            bufferIndex--;\n          }\n          if (bufferIndex) break;\n          bufferIndex = -1;\n        }\n        // Number\n        else if (chunk === -2) {\n          tabs = true;\n          size++;\n        } else if (chunk === -1) {\n          // Empty\n        } else {\n          // Replacement character, exit.\n          index++;\n          break;\n        }\n      }\n      if (size) {\n        const token = {\n          type: eventIndex === events.length || tabs || size < 2 ? \"lineSuffix\" : \"hardBreakTrailing\",\n          start: {\n            _bufferIndex: index ? bufferIndex : data.start._bufferIndex + bufferIndex,\n            _index: data.start._index + index,\n            line: data.end.line,\n            column: data.end.column - size,\n            offset: data.end.offset - size\n          },\n          end: {\n            ...data.end\n          }\n        };\n        data.end = {\n          ...token.start\n        };\n        if (data.start.offset === data.end.offset) {\n          Object.assign(data, token);\n        } else {\n          events.splice(eventIndex, 0, ['enter', token, context], ['exit', token, context]);\n          eventIndex += 2;\n        }\n      }\n      eventIndex++;\n    }\n  }\n  return events;\n}","/**\n * @import {\n *   Code,\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const thematicBreak = {\n  name: 'thematicBreak',\n  tokenize: tokenizeThematicBreak\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeThematicBreak(effects, ok, nok) {\n  let size = 0;\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * Start of thematic break.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"thematicBreak\");\n    // To do: parse indent like `markdown-rs`.\n    return before(code);\n  }\n\n  /**\n   * After optional whitespace, at marker.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    marker = code;\n    return atBreak(code);\n  }\n\n  /**\n   * After something, before something else.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === marker) {\n      effects.enter(\"thematicBreakSequence\");\n      return sequence(code);\n    }\n    if (size >= 3 && (code === null || markdownLineEnding(code))) {\n      effects.exit(\"thematicBreak\");\n      return ok(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In sequence.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code);\n      size++;\n      return sequence;\n    }\n    effects.exit(\"thematicBreakSequence\");\n    return markdownSpace(code) ? factorySpace(effects, atBreak, \"whitespace\")(code) : atBreak(code);\n  }\n}","/**\n * @import {\n *   Code,\n *   Construct,\n *   Exiter,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { asciiDigit, markdownSpace } from 'micromark-util-character';\nimport { blankLine } from './blank-line.js';\nimport { thematicBreak } from './thematic-break.js';\n\n/** @type {Construct} */\nexport const list = {\n  continuation: {\n    tokenize: tokenizeListContinuation\n  },\n  exit: tokenizeListEnd,\n  name: 'list',\n  tokenize: tokenizeListStart\n};\n\n/** @type {Construct} */\nconst listItemPrefixWhitespaceConstruct = {\n  partial: true,\n  tokenize: tokenizeListItemPrefixWhitespace\n};\n\n/** @type {Construct} */\nconst indentConstruct = {\n  partial: true,\n  tokenize: tokenizeIndent\n};\n\n// To do: `markdown-rs` parses list items on their own and later stitches them\n// together.\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeListStart(effects, ok, nok) {\n  const self = this;\n  const tail = self.events[self.events.length - 1];\n  let initialSize = tail && tail[1].type === \"linePrefix\" ? tail[2].sliceSerialize(tail[1], true).length : 0;\n  let size = 0;\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    const kind = self.containerState.type || (code === 42 || code === 43 || code === 45 ? \"listUnordered\" : \"listOrdered\");\n    if (kind === \"listUnordered\" ? !self.containerState.marker || code === self.containerState.marker : asciiDigit(code)) {\n      if (!self.containerState.type) {\n        self.containerState.type = kind;\n        effects.enter(kind, {\n          _container: true\n        });\n      }\n      if (kind === \"listUnordered\") {\n        effects.enter(\"listItemPrefix\");\n        return code === 42 || code === 45 ? effects.check(thematicBreak, nok, atMarker)(code) : atMarker(code);\n      }\n      if (!self.interrupt || code === 49) {\n        effects.enter(\"listItemPrefix\");\n        effects.enter(\"listItemValue\");\n        return inside(code);\n      }\n    }\n    return nok(code);\n  }\n\n  /** @type {State} */\n  function inside(code) {\n    if (asciiDigit(code) && ++size < 10) {\n      effects.consume(code);\n      return inside;\n    }\n    if ((!self.interrupt || size < 2) && (self.containerState.marker ? code === self.containerState.marker : code === 41 || code === 46)) {\n      effects.exit(\"listItemValue\");\n      return atMarker(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * @type {State}\n   **/\n  function atMarker(code) {\n    effects.enter(\"listItemMarker\");\n    effects.consume(code);\n    effects.exit(\"listItemMarker\");\n    self.containerState.marker = self.containerState.marker || code;\n    return effects.check(blankLine,\n    // Can’t be empty when interrupting.\n    self.interrupt ? nok : onBlank, effects.attempt(listItemPrefixWhitespaceConstruct, endOfPrefix, otherPrefix));\n  }\n\n  /** @type {State} */\n  function onBlank(code) {\n    self.containerState.initialBlankLine = true;\n    initialSize++;\n    return endOfPrefix(code);\n  }\n\n  /** @type {State} */\n  function otherPrefix(code) {\n    if (markdownSpace(code)) {\n      effects.enter(\"listItemPrefixWhitespace\");\n      effects.consume(code);\n      effects.exit(\"listItemPrefixWhitespace\");\n      return endOfPrefix;\n    }\n    return nok(code);\n  }\n\n  /** @type {State} */\n  function endOfPrefix(code) {\n    self.containerState.size = initialSize + self.sliceSerialize(effects.exit(\"listItemPrefix\"), true).length;\n    return ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeListContinuation(effects, ok, nok) {\n  const self = this;\n  self.containerState._closeFlow = undefined;\n  return effects.check(blankLine, onBlank, notBlank);\n\n  /** @type {State} */\n  function onBlank(code) {\n    self.containerState.furtherBlankLines = self.containerState.furtherBlankLines || self.containerState.initialBlankLine;\n\n    // We have a blank line.\n    // Still, try to consume at most the items size.\n    return factorySpace(effects, ok, \"listItemIndent\", self.containerState.size + 1)(code);\n  }\n\n  /** @type {State} */\n  function notBlank(code) {\n    if (self.containerState.furtherBlankLines || !markdownSpace(code)) {\n      self.containerState.furtherBlankLines = undefined;\n      self.containerState.initialBlankLine = undefined;\n      return notInCurrentItem(code);\n    }\n    self.containerState.furtherBlankLines = undefined;\n    self.containerState.initialBlankLine = undefined;\n    return effects.attempt(indentConstruct, ok, notInCurrentItem)(code);\n  }\n\n  /** @type {State} */\n  function notInCurrentItem(code) {\n    // While we do continue, we signal that the flow should be closed.\n    self.containerState._closeFlow = true;\n    // As we’re closing flow, we’re no longer interrupting.\n    self.interrupt = undefined;\n    // Always populated by defaults.\n\n    return factorySpace(effects, effects.attempt(list, ok, nok), \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeIndent(effects, ok, nok) {\n  const self = this;\n  return factorySpace(effects, afterPrefix, \"listItemIndent\", self.containerState.size + 1);\n\n  /** @type {State} */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === \"listItemIndent\" && tail[2].sliceSerialize(tail[1], true).length === self.containerState.size ? ok(code) : nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Exiter}\n */\nfunction tokenizeListEnd(effects) {\n  effects.exit(this.containerState.type);\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeListItemPrefixWhitespace(effects, ok, nok) {\n  const self = this;\n\n  // Always populated by defaults.\n\n  return factorySpace(effects, afterPrefix, \"listItemPrefixWhitespace\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4 + 1);\n\n  /** @type {State} */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return !markdownSpace(code) && tail && tail[1].type === \"listItemPrefixWhitespace\" ? ok(code) : nok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   Exiter,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const blockQuote = {\n  continuation: {\n    tokenize: tokenizeBlockQuoteContinuation\n  },\n  exit,\n  name: 'blockQuote',\n  tokenize: tokenizeBlockQuoteStart\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeBlockQuoteStart(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of block quote.\n   *\n   * ```markdown\n   * > | > a\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === 62) {\n      const state = self.containerState;\n      if (!state.open) {\n        effects.enter(\"blockQuote\", {\n          _container: true\n        });\n        state.open = true;\n      }\n      effects.enter(\"blockQuotePrefix\");\n      effects.enter(\"blockQuoteMarker\");\n      effects.consume(code);\n      effects.exit(\"blockQuoteMarker\");\n      return after;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `>`, before optional whitespace.\n   *\n   * ```markdown\n   * > | > a\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    if (markdownSpace(code)) {\n      effects.enter(\"blockQuotePrefixWhitespace\");\n      effects.consume(code);\n      effects.exit(\"blockQuotePrefixWhitespace\");\n      effects.exit(\"blockQuotePrefix\");\n      return ok;\n    }\n    effects.exit(\"blockQuotePrefix\");\n    return ok(code);\n  }\n}\n\n/**\n * Start of block quote continuation.\n *\n * ```markdown\n *   | > a\n * > | > b\n *     ^\n * ```\n *\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeBlockQuoteContinuation(effects, ok, nok) {\n  const self = this;\n  return contStart;\n\n  /**\n   * Start of block quote continuation.\n   *\n   * Also used to parse the first block quote opening.\n   *\n   * ```markdown\n   *   | > a\n   * > | > b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function contStart(code) {\n    if (markdownSpace(code)) {\n      // Always populated by defaults.\n\n      return factorySpace(effects, contBefore, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code);\n    }\n    return contBefore(code);\n  }\n\n  /**\n   * At `>`, after optional whitespace.\n   *\n   * Also used to parse the first block quote opening.\n   *\n   * ```markdown\n   *   | > a\n   * > | > b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function contBefore(code) {\n    return effects.attempt(blockQuote, ok, nok)(code);\n  }\n}\n\n/** @type {Exiter} */\nfunction exit(effects) {\n  effects.exit(\"blockQuote\");\n}","/**\n * @import {Effects, State, TokenType} from 'micromark-util-types'\n */\n\nimport { asciiControl, markdownLineEndingOrSpace, markdownLineEnding } from 'micromark-util-character';\n/**\n * Parse destinations.\n *\n * ###### Examples\n *\n * ```markdown\n * <a>\n * <a\\>b>\n * <a b>\n * <a)>\n * a\n * a\\)b\n * a(b)c\n * a(b)\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type for whole (`<a>` or `b`).\n * @param {TokenType} literalType\n *   Type when enclosed (`<a>`).\n * @param {TokenType} literalMarkerType\n *   Type for enclosing (`<` and `>`).\n * @param {TokenType} rawType\n *   Type when not enclosed (`b`).\n * @param {TokenType} stringType\n *   Type for the value (`a` or `b`).\n * @param {number | undefined} [max=Infinity]\n *   Depth of nested parens (inclusive).\n * @returns {State}\n *   Start state.\n */\nexport function factoryDestination(effects, ok, nok, type, literalType, literalMarkerType, rawType, stringType, max) {\n  const limit = max || Number.POSITIVE_INFINITY;\n  let balance = 0;\n  return start;\n\n  /**\n   * Start of destination.\n   *\n   * ```markdown\n   * > | <aa>\n   *     ^\n   * > | aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === 60) {\n      effects.enter(type);\n      effects.enter(literalType);\n      effects.enter(literalMarkerType);\n      effects.consume(code);\n      effects.exit(literalMarkerType);\n      return enclosedBefore;\n    }\n\n    // ASCII control, space, closing paren.\n    if (code === null || code === 32 || code === 41 || asciiControl(code)) {\n      return nok(code);\n    }\n    effects.enter(type);\n    effects.enter(rawType);\n    effects.enter(stringType);\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return raw(code);\n  }\n\n  /**\n   * After `<`, at an enclosed destination.\n   *\n   * ```markdown\n   * > | <aa>\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function enclosedBefore(code) {\n    if (code === 62) {\n      effects.enter(literalMarkerType);\n      effects.consume(code);\n      effects.exit(literalMarkerType);\n      effects.exit(literalType);\n      effects.exit(type);\n      return ok;\n    }\n    effects.enter(stringType);\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return enclosed(code);\n  }\n\n  /**\n   * In enclosed destination.\n   *\n   * ```markdown\n   * > | <aa>\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function enclosed(code) {\n    if (code === 62) {\n      effects.exit(\"chunkString\");\n      effects.exit(stringType);\n      return enclosedBefore(code);\n    }\n    if (code === null || code === 60 || markdownLineEnding(code)) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return code === 92 ? enclosedEscape : enclosed;\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | <a\\*a>\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function enclosedEscape(code) {\n    if (code === 60 || code === 62 || code === 92) {\n      effects.consume(code);\n      return enclosed;\n    }\n    return enclosed(code);\n  }\n\n  /**\n   * In raw destination.\n   *\n   * ```markdown\n   * > | aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function raw(code) {\n    if (!balance && (code === null || code === 41 || markdownLineEndingOrSpace(code))) {\n      effects.exit(\"chunkString\");\n      effects.exit(stringType);\n      effects.exit(rawType);\n      effects.exit(type);\n      return ok(code);\n    }\n    if (balance < limit && code === 40) {\n      effects.consume(code);\n      balance++;\n      return raw;\n    }\n    if (code === 41) {\n      effects.consume(code);\n      balance--;\n      return raw;\n    }\n\n    // ASCII control (but *not* `\\0`) and space and `(`.\n    // Note: in `markdown-rs`, `\\0` exists in codes, in `micromark-js` it\n    // doesn’t.\n    if (code === null || code === 32 || code === 40 || asciiControl(code)) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return code === 92 ? rawEscape : raw;\n  }\n\n  /**\n   * After `\\`, at special character.\n   *\n   * ```markdown\n   * > | a\\*a\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function rawEscape(code) {\n    if (code === 40 || code === 41 || code === 92) {\n      effects.consume(code);\n      return raw;\n    }\n    return raw(code);\n  }\n}","/**\n * @import {\n *   Effects,\n *   State,\n *   TokenizeContext,\n *   TokenType\n * } from 'micromark-util-types'\n */\n\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/**\n * Parse labels.\n *\n * > 👉 **Note**: labels in markdown are capped at 999 characters in the string.\n *\n * ###### Examples\n *\n * ```markdown\n * [a]\n * [a\n * b]\n * [a\\]b]\n * ```\n *\n * @this {TokenizeContext}\n *   Tokenize context.\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type of the whole label (`[a]`).\n * @param {TokenType} markerType\n *   Type for the markers (`[` and `]`).\n * @param {TokenType} stringType\n *   Type for the identifier (`a`).\n * @returns {State}\n *   Start state.\n */\nexport function factoryLabel(effects, ok, nok, type, markerType, stringType) {\n  const self = this;\n  let size = 0;\n  /** @type {boolean} */\n  let seen;\n  return start;\n\n  /**\n   * Start of label.\n   *\n   * ```markdown\n   * > | [a]\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(type);\n    effects.enter(markerType);\n    effects.consume(code);\n    effects.exit(markerType);\n    effects.enter(stringType);\n    return atBreak;\n  }\n\n  /**\n   * In label, at something, before something else.\n   *\n   * ```markdown\n   * > | [a]\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (size > 999 || code === null || code === 91 || code === 93 && !seen ||\n    // To do: remove in the future once we’ve switched from\n    // `micromark-extension-footnote` to `micromark-extension-gfm-footnote`,\n    // which doesn’t need this.\n    // Hidden footnotes hook.\n    /* c8 ignore next 3 */\n    code === 94 && !size && '_hiddenFootnoteSupport' in self.parser.constructs) {\n      return nok(code);\n    }\n    if (code === 93) {\n      effects.exit(stringType);\n      effects.enter(markerType);\n      effects.consume(code);\n      effects.exit(markerType);\n      effects.exit(type);\n      return ok;\n    }\n\n    // To do: indent? Link chunks and EOLs together?\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return atBreak;\n    }\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return labelInside(code);\n  }\n\n  /**\n   * In label, in text.\n   *\n   * ```markdown\n   * > | [a]\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelInside(code) {\n    if (code === null || code === 91 || code === 93 || markdownLineEnding(code) || size++ > 999) {\n      effects.exit(\"chunkString\");\n      return atBreak(code);\n    }\n    effects.consume(code);\n    if (!seen) seen = !markdownSpace(code);\n    return code === 92 ? labelEscape : labelInside;\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | [a\\*a]\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code);\n      size++;\n      return labelInside;\n    }\n    return labelInside(code);\n  }\n}","/**\n * @import {\n *   Code,\n *   Effects,\n *   State,\n *   TokenType\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/**\n * Parse titles.\n *\n * ###### Examples\n *\n * ```markdown\n * \"a\"\n * 'b'\n * (c)\n * \"a\n * b\"\n * 'a\n *     b'\n * (a\\)b)\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type of the whole title (`\"a\"`, `'b'`, `(c)`).\n * @param {TokenType} markerType\n *   Type for the markers (`\"`, `'`, `(`, and `)`).\n * @param {TokenType} stringType\n *   Type for the value (`a`).\n * @returns {State}\n *   Start state.\n */\nexport function factoryTitle(effects, ok, nok, type, markerType, stringType) {\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * Start of title.\n   *\n   * ```markdown\n   * > | \"a\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      effects.enter(type);\n      effects.enter(markerType);\n      effects.consume(code);\n      effects.exit(markerType);\n      marker = code === 40 ? 41 : code;\n      return begin;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After opening marker.\n   *\n   * This is also used at the closing marker.\n   *\n   * ```markdown\n   * > | \"a\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function begin(code) {\n    if (code === marker) {\n      effects.enter(markerType);\n      effects.consume(code);\n      effects.exit(markerType);\n      effects.exit(type);\n      return ok;\n    }\n    effects.enter(stringType);\n    return atBreak(code);\n  }\n\n  /**\n   * At something, before something else.\n   *\n   * ```markdown\n   * > | \"a\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === marker) {\n      effects.exit(stringType);\n      return begin(marker);\n    }\n    if (code === null) {\n      return nok(code);\n    }\n\n    // Note: blank lines can’t exist in content.\n    if (markdownLineEnding(code)) {\n      // To do: use `space_or_tab_eol_with_options`, connect.\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return factorySpace(effects, atBreak, \"linePrefix\");\n    }\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return inside(code);\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker || code === null || markdownLineEnding(code)) {\n      effects.exit(\"chunkString\");\n      return atBreak(code);\n    }\n    effects.consume(code);\n    return code === 92 ? escape : inside;\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | \"a\\*b\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function escape(code) {\n    if (code === marker || code === 92) {\n      effects.consume(code);\n      return inside;\n    }\n    return inside(code);\n  }\n}","/**\n * @import {Effects, State} from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/**\n * Parse spaces and tabs.\n *\n * There is no `nok` parameter:\n *\n * *   line endings or spaces in markdown are often optional, in which case this\n *     factory can be used and `ok` will be switched to whether spaces were found\n *     or not\n * *   one line ending or space can be detected with\n *     `markdownLineEndingOrSpace(code)` right before using `factoryWhitespace`\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @returns {State}\n *   Start state.\n */\nexport function factoryWhitespace(effects, ok) {\n  /** @type {boolean} */\n  let seen;\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      seen = true;\n      return start;\n    }\n    if (markdownSpace(code)) {\n      return factorySpace(effects, start, seen ? \"linePrefix\" : \"lineSuffix\")(code);\n    }\n    return ok(code);\n  }\n}","/**\n * Normalize an identifier (as found in references, definitions).\n *\n * Collapses markdown whitespace, trim, and then lower- and uppercase.\n *\n * Some characters are considered “uppercase”, such as U+03F4 (`ϴ`), but if their\n * lowercase counterpart (U+03B8 (`θ`)) is uppercased will result in a different\n * uppercase character (U+0398 (`Θ`)).\n * So, to get a canonical form, we perform both lower- and uppercase.\n *\n * Using uppercase last makes sure keys will never interact with default\n * prototypal values (such as `constructor`): nothing in the prototype of\n * `Object` is uppercase.\n *\n * @param {string} value\n *   Identifier to normalize.\n * @returns {string}\n *   Normalized identifier.\n */\nexport function normalizeIdentifier(value) {\n  return value\n  // Collapse markdown whitespace.\n  .replace(/[\\t\\n\\r ]+/g, \" \")\n  // Trim.\n  .replace(/^ | $/g, '')\n  // Some characters are considered “uppercase”, but if their lowercase\n  // counterpart is uppercased will result in a different uppercase\n  // character.\n  // Hence, to get that form, we perform both lower- and uppercase.\n  // Upper case makes sure keys will not interact with default prototypal\n  // methods: no method is uppercase.\n  .toLowerCase().toUpperCase();\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factoryDestination } from 'micromark-factory-destination';\nimport { factoryLabel } from 'micromark-factory-label';\nimport { factorySpace } from 'micromark-factory-space';\nimport { factoryTitle } from 'micromark-factory-title';\nimport { factoryWhitespace } from 'micromark-factory-whitespace';\nimport { markdownLineEndingOrSpace, markdownLineEnding, markdownSpace } from 'micromark-util-character';\nimport { normalizeIdentifier } from 'micromark-util-normalize-identifier';\n/** @type {Construct} */\nexport const definition = {\n  name: 'definition',\n  tokenize: tokenizeDefinition\n};\n\n/** @type {Construct} */\nconst titleBefore = {\n  partial: true,\n  tokenize: tokenizeTitleBefore\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeDefinition(effects, ok, nok) {\n  const self = this;\n  /** @type {string} */\n  let identifier;\n  return start;\n\n  /**\n   * At start of a definition.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // Do not interrupt paragraphs (but do follow definitions).\n    // To do: do `interrupt` the way `markdown-rs` does.\n    // To do: parse whitespace the way `markdown-rs` does.\n    effects.enter(\"definition\");\n    return before(code);\n  }\n\n  /**\n   * After optional whitespace, at `[`.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    // To do: parse whitespace the way `markdown-rs` does.\n\n    return factoryLabel.call(self, effects, labelAfter,\n    // Note: we don’t need to reset the way `markdown-rs` does.\n    nok, \"definitionLabel\", \"definitionLabelMarker\", \"definitionLabelString\")(code);\n  }\n\n  /**\n   * After label.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelAfter(code) {\n    identifier = normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1));\n    if (code === 58) {\n      effects.enter(\"definitionMarker\");\n      effects.consume(code);\n      effects.exit(\"definitionMarker\");\n      return markerAfter;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After marker.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function markerAfter(code) {\n    // Note: whitespace is optional.\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, destinationBefore)(code) : destinationBefore(code);\n  }\n\n  /**\n   * Before destination.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function destinationBefore(code) {\n    return factoryDestination(effects, destinationAfter,\n    // Note: we don’t need to reset the way `markdown-rs` does.\n    nok, \"definitionDestination\", \"definitionDestinationLiteral\", \"definitionDestinationLiteralMarker\", \"definitionDestinationRaw\", \"definitionDestinationString\")(code);\n  }\n\n  /**\n   * After destination.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function destinationAfter(code) {\n    return effects.attempt(titleBefore, after, after)(code);\n  }\n\n  /**\n   * After definition.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return markdownSpace(code) ? factorySpace(effects, afterWhitespace, \"whitespace\")(code) : afterWhitespace(code);\n  }\n\n  /**\n   * After definition, after optional whitespace.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterWhitespace(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"definition\");\n\n      // Note: we don’t care about uniqueness.\n      // It’s likely that that doesn’t happen very frequently.\n      // It is more likely that it wastes precious time.\n      self.parser.defined.push(identifier);\n\n      // To do: `markdown-rs` interrupt.\n      // // You’d be interrupting.\n      // tokenizer.interrupt = true\n      return ok(code);\n    }\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeTitleBefore(effects, ok, nok) {\n  return titleBefore;\n\n  /**\n   * After destination, at whitespace.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleBefore(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, beforeMarker)(code) : nok(code);\n  }\n\n  /**\n   * At title.\n   *\n   * ```markdown\n   *   | [a]: b\n   * > | \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeMarker(code) {\n    return factoryTitle(effects, titleAfter, nok, \"definitionTitle\", \"definitionTitleMarker\", \"definitionTitleString\")(code);\n  }\n\n  /**\n   * After title.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleAfter(code) {\n    return markdownSpace(code) ? factorySpace(effects, titleAfterOptionalWhitespace, \"whitespace\")(code) : titleAfterOptionalWhitespace(code);\n  }\n\n  /**\n   * After title, after optional whitespace.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleAfterOptionalWhitespace(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const codeIndented = {\n  name: 'codeIndented',\n  tokenize: tokenizeCodeIndented\n};\n\n/** @type {Construct} */\nconst furtherStart = {\n  partial: true,\n  tokenize: tokenizeFurtherStart\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCodeIndented(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of code (indented).\n   *\n   * > **Parsing note**: it is not needed to check if this first line is a\n   * > filled line (that it has a non-whitespace character), because blank lines\n   * > are parsed already, so we never run into that.\n   *\n   * ```markdown\n   * > |     aaa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: manually check if interrupting like `markdown-rs`.\n\n    effects.enter(\"codeIndented\");\n    // To do: use an improved `space_or_tab` function like `markdown-rs`,\n    // so that we can drop the next state.\n    return factorySpace(effects, afterPrefix, \"linePrefix\", 4 + 1)(code);\n  }\n\n  /**\n   * At start, after 1 or 4 spaces.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === \"linePrefix\" && tail[2].sliceSerialize(tail[1], true).length >= 4 ? atBreak(code) : nok(code);\n  }\n\n  /**\n   * At a break.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^  ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === null) {\n      return after(code);\n    }\n    if (markdownLineEnding(code)) {\n      return effects.attempt(furtherStart, atBreak, after)(code);\n    }\n    effects.enter(\"codeFlowValue\");\n    return inside(code);\n  }\n\n  /**\n   * In code content.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"codeFlowValue\");\n      return atBreak(code);\n    }\n    effects.consume(code);\n    return inside;\n  }\n\n  /** @type {State} */\n  function after(code) {\n    effects.exit(\"codeIndented\");\n    // To do: allow interrupting like `markdown-rs`.\n    // Feel free to interrupt.\n    // tokenizer.interrupt = false\n    return ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeFurtherStart(effects, ok, nok) {\n  const self = this;\n  return furtherStart;\n\n  /**\n   * At eol, trying to parse another indent.\n   *\n   * ```markdown\n   * > |     aaa\n   *            ^\n   *   |     bbb\n   * ```\n   *\n   * @type {State}\n   */\n  function furtherStart(code) {\n    // To do: improve `lazy` / `pierce` handling.\n    // If this is a lazy line, it can’t be code.\n    if (self.parser.lazy[self.now().line]) {\n      return nok(code);\n    }\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return furtherStart;\n    }\n\n    // To do: the code here in `micromark-js` is a bit different from\n    // `markdown-rs` because there it can attempt spaces.\n    // We can’t yet.\n    //\n    // To do: use an improved `space_or_tab` function like `markdown-rs`,\n    // so that we can drop the next state.\n    return factorySpace(effects, afterPrefix, \"linePrefix\", 4 + 1)(code);\n  }\n\n  /**\n   * At start, after 1 or 4 spaces.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === \"linePrefix\" && tail[2].sliceSerialize(tail[1], true).length >= 4 ? ok(code) : markdownLineEnding(code) ? furtherStart(code) : nok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEndingOrSpace, markdownLineEnding, markdownSpace } from 'micromark-util-character';\nimport { splice } from 'micromark-util-chunked';\n/** @type {Construct} */\nexport const headingAtx = {\n  name: 'headingAtx',\n  resolve: resolveHeadingAtx,\n  tokenize: tokenizeHeadingAtx\n};\n\n/** @type {Resolver} */\nfunction resolveHeadingAtx(events, context) {\n  let contentEnd = events.length - 2;\n  let contentStart = 3;\n  /** @type {Token} */\n  let content;\n  /** @type {Token} */\n  let text;\n\n  // Prefix whitespace, part of the opening.\n  if (events[contentStart][1].type === \"whitespace\") {\n    contentStart += 2;\n  }\n\n  // Suffix whitespace, part of the closing.\n  if (contentEnd - 2 > contentStart && events[contentEnd][1].type === \"whitespace\") {\n    contentEnd -= 2;\n  }\n  if (events[contentEnd][1].type === \"atxHeadingSequence\" && (contentStart === contentEnd - 1 || contentEnd - 4 > contentStart && events[contentEnd - 2][1].type === \"whitespace\")) {\n    contentEnd -= contentStart + 1 === contentEnd ? 2 : 4;\n  }\n  if (contentEnd > contentStart) {\n    content = {\n      type: \"atxHeadingText\",\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end\n    };\n    text = {\n      type: \"chunkText\",\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end,\n      contentType: \"text\"\n    };\n    splice(events, contentStart, contentEnd - contentStart + 1, [['enter', content, context], ['enter', text, context], ['exit', text, context], ['exit', content, context]]);\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeHeadingAtx(effects, ok, nok) {\n  let size = 0;\n  return start;\n\n  /**\n   * Start of a heading (atx).\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse indent like `markdown-rs`.\n    effects.enter(\"atxHeading\");\n    return before(code);\n  }\n\n  /**\n   * After optional whitespace, at `#`.\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter(\"atxHeadingSequence\");\n    return sequenceOpen(code);\n  }\n\n  /**\n   * In opening sequence.\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === 35 && size++ < 6) {\n      effects.consume(code);\n      return sequenceOpen;\n    }\n\n    // Always at least one `#`.\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit(\"atxHeadingSequence\");\n      return atBreak(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * After something, before something else.\n   *\n   * ```markdown\n   * > | ## aa\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === 35) {\n      effects.enter(\"atxHeadingSequence\");\n      return sequenceFurther(code);\n    }\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"atxHeading\");\n      // To do: interrupt like `markdown-rs`.\n      // // Feel free to interrupt.\n      // tokenizer.interrupt = false\n      return ok(code);\n    }\n    if (markdownSpace(code)) {\n      return factorySpace(effects, atBreak, \"whitespace\")(code);\n    }\n\n    // To do: generate `data` tokens, add the `text` token later.\n    // Needs edit map, see: `markdown.rs`.\n    effects.enter(\"atxHeadingText\");\n    return data(code);\n  }\n\n  /**\n   * In further sequence (after whitespace).\n   *\n   * Could be normal “visible” hashes in the heading or a final sequence.\n   *\n   * ```markdown\n   * > | ## aa ##\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceFurther(code) {\n    if (code === 35) {\n      effects.consume(code);\n      return sequenceFurther;\n    }\n    effects.exit(\"atxHeadingSequence\");\n    return atBreak(code);\n  }\n\n  /**\n   * In text.\n   *\n   * ```markdown\n   * > | ## aa\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function data(code) {\n    if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {\n      effects.exit(\"atxHeadingText\");\n      return atBreak(code);\n    }\n    effects.consume(code);\n    return data;\n  }\n}","/**\n * @import {\n *   Code,\n *   Construct,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const setextUnderline = {\n  name: 'setextUnderline',\n  resolveTo: resolveToSetextUnderline,\n  tokenize: tokenizeSetextUnderline\n};\n\n/** @type {Resolver} */\nfunction resolveToSetextUnderline(events, context) {\n  // To do: resolve like `markdown-rs`.\n  let index = events.length;\n  /** @type {number | undefined} */\n  let content;\n  /** @type {number | undefined} */\n  let text;\n  /** @type {number | undefined} */\n  let definition;\n\n  // Find the opening of the content.\n  // It’ll always exist: we don’t tokenize if it isn’t there.\n  while (index--) {\n    if (events[index][0] === 'enter') {\n      if (events[index][1].type === \"content\") {\n        content = index;\n        break;\n      }\n      if (events[index][1].type === \"paragraph\") {\n        text = index;\n      }\n    }\n    // Exit\n    else {\n      if (events[index][1].type === \"content\") {\n        // Remove the content end (if needed we’ll add it later)\n        events.splice(index, 1);\n      }\n      if (!definition && events[index][1].type === \"definition\") {\n        definition = index;\n      }\n    }\n  }\n  const heading = {\n    type: \"setextHeading\",\n    start: {\n      ...events[text][1].start\n    },\n    end: {\n      ...events[events.length - 1][1].end\n    }\n  };\n\n  // Change the paragraph to setext heading text.\n  events[text][1].type = \"setextHeadingText\";\n\n  // If we have definitions in the content, we’ll keep on having content,\n  // but we need move it.\n  if (definition) {\n    events.splice(text, 0, ['enter', heading, context]);\n    events.splice(definition + 1, 0, ['exit', events[content][1], context]);\n    events[content][1].end = {\n      ...events[definition][1].end\n    };\n  } else {\n    events[content][1] = heading;\n  }\n\n  // Add the heading exit at the end.\n  events.push(['exit', heading, context]);\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeSetextUnderline(effects, ok, nok) {\n  const self = this;\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * At start of heading (setext) underline.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    let index = self.events.length;\n    /** @type {boolean | undefined} */\n    let paragraph;\n    // Find an opening.\n    while (index--) {\n      // Skip enter/exit of line ending, line prefix, and content.\n      // We can now either have a definition or a paragraph.\n      if (self.events[index][1].type !== \"lineEnding\" && self.events[index][1].type !== \"linePrefix\" && self.events[index][1].type !== \"content\") {\n        paragraph = self.events[index][1].type === \"paragraph\";\n        break;\n      }\n    }\n\n    // To do: handle lazy/pierce like `markdown-rs`.\n    // To do: parse indent like `markdown-rs`.\n    if (!self.parser.lazy[self.now().line] && (self.interrupt || paragraph)) {\n      effects.enter(\"setextHeadingLine\");\n      marker = code;\n      return before(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * After optional whitespace, at `-` or `=`.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter(\"setextHeadingLineSequence\");\n    return inside(code);\n  }\n\n  /**\n   * In sequence.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return inside;\n    }\n    effects.exit(\"setextHeadingLineSequence\");\n    return markdownSpace(code) ? factorySpace(effects, after, \"lineSuffix\")(code) : after(code);\n  }\n\n  /**\n   * After sequence, after optional whitespace.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"setextHeadingLine\");\n      return ok(code);\n    }\n    return nok(code);\n  }\n}","/**\n * List of lowercase HTML “block” tag names.\n *\n * The list, when parsing HTML (flow), results in more relaxed rules (condition\n * 6).\n * Because they are known blocks, the HTML-like syntax doesn’t have to be\n * strictly parsed.\n * For tag names not in this list, a more strict algorithm (condition 7) is used\n * to detect whether the HTML-like syntax is seen as HTML (flow) or not.\n *\n * This is copied from:\n * <https://spec.commonmark.org/0.30/#html-blocks>.\n *\n * > 👉 **Note**: `search` was added in `CommonMark@0.31`.\n */\nexport const htmlBlockNames = [\n  'address',\n  'article',\n  'aside',\n  'base',\n  'basefont',\n  'blockquote',\n  'body',\n  'caption',\n  'center',\n  'col',\n  'colgroup',\n  'dd',\n  'details',\n  'dialog',\n  'dir',\n  'div',\n  'dl',\n  'dt',\n  'fieldset',\n  'figcaption',\n  'figure',\n  'footer',\n  'form',\n  'frame',\n  'frameset',\n  'h1',\n  'h2',\n  'h3',\n  'h4',\n  'h5',\n  'h6',\n  'head',\n  'header',\n  'hr',\n  'html',\n  'iframe',\n  'legend',\n  'li',\n  'link',\n  'main',\n  'menu',\n  'menuitem',\n  'nav',\n  'noframes',\n  'ol',\n  'optgroup',\n  'option',\n  'p',\n  'param',\n  'search',\n  'section',\n  'summary',\n  'table',\n  'tbody',\n  'td',\n  'tfoot',\n  'th',\n  'thead',\n  'title',\n  'tr',\n  'track',\n  'ul'\n]\n\n/**\n * List of lowercase HTML “raw” tag names.\n *\n * The list, when parsing HTML (flow), results in HTML that can include lines\n * without exiting, until a closing tag also in this list is found (condition\n * 1).\n *\n * This module is copied from:\n * <https://spec.commonmark.org/0.30/#html-blocks>.\n *\n * > 👉 **Note**: `textarea` was added in `CommonMark@0.30`.\n */\nexport const htmlRawNames = ['pre', 'script', 'style', 'textarea']\n","/**\n * @import {\n *   Code,\n *   Construct,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { asciiAlphanumeric, asciiAlpha, markdownLineEndingOrSpace, markdownLineEnding, markdownSpace } from 'micromark-util-character';\nimport { htmlBlockNames, htmlRawNames } from 'micromark-util-html-tag-name';\nimport { blankLine } from './blank-line.js';\n\n/** @type {Construct} */\nexport const htmlFlow = {\n  concrete: true,\n  name: 'htmlFlow',\n  resolveTo: resolveToHtmlFlow,\n  tokenize: tokenizeHtmlFlow\n};\n\n/** @type {Construct} */\nconst blankLineBefore = {\n  partial: true,\n  tokenize: tokenizeBlankLineBefore\n};\nconst nonLazyContinuationStart = {\n  partial: true,\n  tokenize: tokenizeNonLazyContinuationStart\n};\n\n/** @type {Resolver} */\nfunction resolveToHtmlFlow(events) {\n  let index = events.length;\n  while (index--) {\n    if (events[index][0] === 'enter' && events[index][1].type === \"htmlFlow\") {\n      break;\n    }\n  }\n  if (index > 1 && events[index - 2][1].type === \"linePrefix\") {\n    // Add the prefix start to the HTML token.\n    events[index][1].start = events[index - 2][1].start;\n    // Add the prefix start to the HTML line token.\n    events[index + 1][1].start = events[index - 2][1].start;\n    // Remove the line prefix.\n    events.splice(index - 2, 2);\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeHtmlFlow(effects, ok, nok) {\n  const self = this;\n  /** @type {number} */\n  let marker;\n  /** @type {boolean} */\n  let closingTag;\n  /** @type {string} */\n  let buffer;\n  /** @type {number} */\n  let index;\n  /** @type {Code} */\n  let markerB;\n  return start;\n\n  /**\n   * Start of HTML (flow).\n   *\n   * ```markdown\n   * > | <x />\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse indent like `markdown-rs`.\n    return before(code);\n  }\n\n  /**\n   * At `<`, after optional whitespace.\n   *\n   * ```markdown\n   * > | <x />\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter(\"htmlFlow\");\n    effects.enter(\"htmlFlowData\");\n    effects.consume(code);\n    return open;\n  }\n\n  /**\n   * After `<`, at tag name or other stuff.\n   *\n   * ```markdown\n   * > | <x />\n   *      ^\n   * > | <!doctype>\n   *      ^\n   * > | <!--xxx-->\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code);\n      return declarationOpen;\n    }\n    if (code === 47) {\n      effects.consume(code);\n      closingTag = true;\n      return tagCloseStart;\n    }\n    if (code === 63) {\n      effects.consume(code);\n      marker = 3;\n      // To do:\n      // tokenizer.concrete = true\n      // To do: use `markdown-rs` style interrupt.\n      // While we’re in an instruction instead of a declaration, we’re on a `?`\n      // right now, so we do need to search for `>`, similar to declarations.\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      // Always the case.\n      effects.consume(code);\n      buffer = String.fromCharCode(code);\n      return tagName;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `<!`, at declaration, comment, or CDATA.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *       ^\n   * > | <!--xxx-->\n   *       ^\n   * > | <![CDATA[>&<]]>\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code);\n      marker = 2;\n      return commentOpenInside;\n    }\n    if (code === 91) {\n      effects.consume(code);\n      marker = 5;\n      index = 0;\n      return cdataOpenInside;\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      marker = 4;\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `<!-`, inside a comment, at another `-`.\n   *\n   * ```markdown\n   * > | <!--xxx-->\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `<![`, inside CDATA, expecting `CDATA[`.\n   *\n   * ```markdown\n   * > | <![CDATA[>&<]]>\n   *        ^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataOpenInside(code) {\n    const value = \"CDATA[\";\n    if (code === value.charCodeAt(index++)) {\n      effects.consume(code);\n      if (index === value.length) {\n        // // Do not form containers.\n        // tokenizer.concrete = true\n        return self.interrupt ? ok : continuation;\n      }\n      return cdataOpenInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `</`, in closing tag, at tag name.\n   *\n   * ```markdown\n   * > | </x>\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      // Always the case.\n      effects.consume(code);\n      buffer = String.fromCharCode(code);\n      return tagName;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In tag name.\n   *\n   * ```markdown\n   * > | <ab>\n   *      ^^\n   * > | </ab>\n   *       ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagName(code) {\n    if (code === null || code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      const slash = code === 47;\n      const name = buffer.toLowerCase();\n      if (!slash && !closingTag && htmlRawNames.includes(name)) {\n        marker = 1;\n        // // Do not form containers.\n        // tokenizer.concrete = true\n        return self.interrupt ? ok(code) : continuation(code);\n      }\n      if (htmlBlockNames.includes(buffer.toLowerCase())) {\n        marker = 6;\n        if (slash) {\n          effects.consume(code);\n          return basicSelfClosing;\n        }\n\n        // // Do not form containers.\n        // tokenizer.concrete = true\n        return self.interrupt ? ok(code) : continuation(code);\n      }\n      marker = 7;\n      // Do not support complete HTML when interrupting.\n      return self.interrupt && !self.parser.lazy[self.now().line] ? nok(code) : closingTag ? completeClosingTagAfter(code) : completeAttributeNameBefore(code);\n    }\n\n    // ASCII alphanumerical and `-`.\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      buffer += String.fromCharCode(code);\n      return tagName;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After closing slash of a basic tag name.\n   *\n   * ```markdown\n   * > | <div/>\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function basicSelfClosing(code) {\n    if (code === 62) {\n      effects.consume(code);\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return self.interrupt ? ok : continuation;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After closing slash of a complete tag name.\n   *\n   * ```markdown\n   * > | <x/>\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeClosingTagAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeClosingTagAfter;\n    }\n    return completeEnd(code);\n  }\n\n  /**\n   * At an attribute name.\n   *\n   * At first, this state is used after a complete tag name, after whitespace,\n   * where it expects optional attributes or the end of the tag.\n   * It is also reused after attributes, when expecting more optional\n   * attributes.\n   *\n   * ```markdown\n   * > | <a />\n   *        ^\n   * > | <a :b>\n   *        ^\n   * > | <a _b>\n   *        ^\n   * > | <a b>\n   *        ^\n   * > | <a >\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeNameBefore(code) {\n    if (code === 47) {\n      effects.consume(code);\n      return completeEnd;\n    }\n\n    // ASCII alphanumerical and `:` and `_`.\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code);\n      return completeAttributeName;\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeNameBefore;\n    }\n    return completeEnd(code);\n  }\n\n  /**\n   * In attribute name.\n   *\n   * ```markdown\n   * > | <a :b>\n   *         ^\n   * > | <a _b>\n   *         ^\n   * > | <a b>\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeName(code) {\n    // ASCII alphanumerical and `-`, `.`, `:`, and `_`.\n    if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return completeAttributeName;\n    }\n    return completeAttributeNameAfter(code);\n  }\n\n  /**\n   * After attribute name, at an optional initializer, the end of the tag, or\n   * whitespace.\n   *\n   * ```markdown\n   * > | <a b>\n   *         ^\n   * > | <a b=c>\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code);\n      return completeAttributeValueBefore;\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeNameAfter;\n    }\n    return completeAttributeNameBefore(code);\n  }\n\n  /**\n   * Before unquoted, double quoted, or single quoted attribute value, allowing\n   * whitespace.\n   *\n   * ```markdown\n   * > | <a b=c>\n   *          ^\n   * > | <a b=\"c\">\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueBefore(code) {\n    if (code === null || code === 60 || code === 61 || code === 62 || code === 96) {\n      return nok(code);\n    }\n    if (code === 34 || code === 39) {\n      effects.consume(code);\n      markerB = code;\n      return completeAttributeValueQuoted;\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeValueBefore;\n    }\n    return completeAttributeValueUnquoted(code);\n  }\n\n  /**\n   * In double or single quoted attribute value.\n   *\n   * ```markdown\n   * > | <a b=\"c\">\n   *           ^\n   * > | <a b='c'>\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueQuoted(code) {\n    if (code === markerB) {\n      effects.consume(code);\n      markerB = null;\n      return completeAttributeValueQuotedAfter;\n    }\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return completeAttributeValueQuoted;\n  }\n\n  /**\n   * In unquoted attribute value.\n   *\n   * ```markdown\n   * > | <a b=c>\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueUnquoted(code) {\n    if (code === null || code === 34 || code === 39 || code === 47 || code === 60 || code === 61 || code === 62 || code === 96 || markdownLineEndingOrSpace(code)) {\n      return completeAttributeNameAfter(code);\n    }\n    effects.consume(code);\n    return completeAttributeValueUnquoted;\n  }\n\n  /**\n   * After double or single quoted attribute value, before whitespace or the\n   * end of the tag.\n   *\n   * ```markdown\n   * > | <a b=\"c\">\n   *            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownSpace(code)) {\n      return completeAttributeNameBefore(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In certain circumstances of a complete tag where only an `>` is allowed.\n   *\n   * ```markdown\n   * > | <a b=\"c\">\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeEnd(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return completeAfter;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `>` in a complete tag.\n   *\n   * ```markdown\n   * > | <x>\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAfter(code) {\n    if (code === null || markdownLineEnding(code)) {\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return continuation(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAfter;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In continuation of any HTML kind.\n   *\n   * ```markdown\n   * > | <!--xxx-->\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuation(code) {\n    if (code === 45 && marker === 2) {\n      effects.consume(code);\n      return continuationCommentInside;\n    }\n    if (code === 60 && marker === 1) {\n      effects.consume(code);\n      return continuationRawTagOpen;\n    }\n    if (code === 62 && marker === 4) {\n      effects.consume(code);\n      return continuationClose;\n    }\n    if (code === 63 && marker === 3) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    if (code === 93 && marker === 5) {\n      effects.consume(code);\n      return continuationCdataInside;\n    }\n    if (markdownLineEnding(code) && (marker === 6 || marker === 7)) {\n      effects.exit(\"htmlFlowData\");\n      return effects.check(blankLineBefore, continuationAfter, continuationStart)(code);\n    }\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"htmlFlowData\");\n      return continuationStart(code);\n    }\n    effects.consume(code);\n    return continuation;\n  }\n\n  /**\n   * In continuation, at eol.\n   *\n   * ```markdown\n   * > | <x>\n   *        ^\n   *   | asd\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationStart(code) {\n    return effects.check(nonLazyContinuationStart, continuationStartNonLazy, continuationAfter)(code);\n  }\n\n  /**\n   * In continuation, at eol, before non-lazy content.\n   *\n   * ```markdown\n   * > | <x>\n   *        ^\n   *   | asd\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationStartNonLazy(code) {\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return continuationBefore;\n  }\n\n  /**\n   * In continuation, before non-lazy content.\n   *\n   * ```markdown\n   *   | <x>\n   * > | asd\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationBefore(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return continuationStart(code);\n    }\n    effects.enter(\"htmlFlowData\");\n    return continuation(code);\n  }\n\n  /**\n   * In comment continuation, after one `-`, expecting another.\n   *\n   * ```markdown\n   * > | <!--xxx-->\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationCommentInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In raw continuation, after `<`, at `/`.\n   *\n   * ```markdown\n   * > | <script>console.log(1)</script>\n   *                            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationRawTagOpen(code) {\n    if (code === 47) {\n      effects.consume(code);\n      buffer = '';\n      return continuationRawEndTag;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In raw continuation, after `</`, in a raw tag name.\n   *\n   * ```markdown\n   * > | <script>console.log(1)</script>\n   *                             ^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationRawEndTag(code) {\n    if (code === 62) {\n      const name = buffer.toLowerCase();\n      if (htmlRawNames.includes(name)) {\n        effects.consume(code);\n        return continuationClose;\n      }\n      return continuation(code);\n    }\n    if (asciiAlpha(code) && buffer.length < 8) {\n      // Always the case.\n      effects.consume(code);\n      buffer += String.fromCharCode(code);\n      return continuationRawEndTag;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In cdata continuation, after `]`, expecting `]>`.\n   *\n   * ```markdown\n   * > | <![CDATA[>&<]]>\n   *                  ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationCdataInside(code) {\n    if (code === 93) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In declaration or instruction continuation, at `>`.\n   *\n   * ```markdown\n   * > | <!-->\n   *         ^\n   * > | <?>\n   *       ^\n   * > | <!q>\n   *        ^\n   * > | <!--ab-->\n   *             ^\n   * > | <![CDATA[>&<]]>\n   *                   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationDeclarationInside(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return continuationClose;\n    }\n\n    // More dashes.\n    if (code === 45 && marker === 2) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In closed continuation: everything we get until the eol/eof is part of it.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationClose(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"htmlFlowData\");\n      return continuationAfter(code);\n    }\n    effects.consume(code);\n    return continuationClose;\n  }\n\n  /**\n   * Done.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationAfter(code) {\n    effects.exit(\"htmlFlow\");\n    // // Feel free to interrupt.\n    // tokenizer.interrupt = false\n    // // No longer concrete.\n    // tokenizer.concrete = false\n    return ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeNonLazyContinuationStart(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * At eol, before continuation.\n   *\n   * ```markdown\n   * > | * ```js\n   *            ^\n   *   | b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return after;\n    }\n    return nok(code);\n  }\n\n  /**\n   * A continuation.\n   *\n   * ```markdown\n   *   | * ```js\n   * > | b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return self.parser.lazy[self.now().line] ? nok(code) : ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeBlankLineBefore(effects, ok, nok) {\n  return start;\n\n  /**\n   * Before eol, expecting blank line.\n   *\n   * ```markdown\n   * > | <div>\n   *          ^\n   *   |\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return effects.attempt(blankLine, ok, nok);\n  }\n}","/**\n * @import {\n *   Code,\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nconst nonLazyContinuation = {\n  partial: true,\n  tokenize: tokenizeNonLazyContinuation\n};\n\n/** @type {Construct} */\nexport const codeFenced = {\n  concrete: true,\n  name: 'codeFenced',\n  tokenize: tokenizeCodeFenced\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCodeFenced(effects, ok, nok) {\n  const self = this;\n  /** @type {Construct} */\n  const closeStart = {\n    partial: true,\n    tokenize: tokenizeCloseStart\n  };\n  let initialPrefix = 0;\n  let sizeOpen = 0;\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * Start of code.\n   *\n   * ```markdown\n   * > | ~~~js\n   *     ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse whitespace like `markdown-rs`.\n    return beforeSequenceOpen(code);\n  }\n\n  /**\n   * In opening fence, after prefix, at sequence.\n   *\n   * ```markdown\n   * > | ~~~js\n   *     ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeSequenceOpen(code) {\n    const tail = self.events[self.events.length - 1];\n    initialPrefix = tail && tail[1].type === \"linePrefix\" ? tail[2].sliceSerialize(tail[1], true).length : 0;\n    marker = code;\n    effects.enter(\"codeFenced\");\n    effects.enter(\"codeFencedFence\");\n    effects.enter(\"codeFencedFenceSequence\");\n    return sequenceOpen(code);\n  }\n\n  /**\n   * In opening fence sequence.\n   *\n   * ```markdown\n   * > | ~~~js\n   *      ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === marker) {\n      sizeOpen++;\n      effects.consume(code);\n      return sequenceOpen;\n    }\n    if (sizeOpen < 3) {\n      return nok(code);\n    }\n    effects.exit(\"codeFencedFenceSequence\");\n    return markdownSpace(code) ? factorySpace(effects, infoBefore, \"whitespace\")(code) : infoBefore(code);\n  }\n\n  /**\n   * In opening fence, after the sequence (and optional whitespace), before info.\n   *\n   * ```markdown\n   * > | ~~~js\n   *        ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function infoBefore(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"codeFencedFence\");\n      return self.interrupt ? ok(code) : effects.check(nonLazyContinuation, atNonLazyBreak, after)(code);\n    }\n    effects.enter(\"codeFencedFenceInfo\");\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return info(code);\n  }\n\n  /**\n   * In info.\n   *\n   * ```markdown\n   * > | ~~~js\n   *        ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function info(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"chunkString\");\n      effects.exit(\"codeFencedFenceInfo\");\n      return infoBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.exit(\"chunkString\");\n      effects.exit(\"codeFencedFenceInfo\");\n      return factorySpace(effects, metaBefore, \"whitespace\")(code);\n    }\n    if (code === 96 && code === marker) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return info;\n  }\n\n  /**\n   * In opening fence, after info and whitespace, before meta.\n   *\n   * ```markdown\n   * > | ~~~js eval\n   *           ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function metaBefore(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return infoBefore(code);\n    }\n    effects.enter(\"codeFencedFenceMeta\");\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return meta(code);\n  }\n\n  /**\n   * In meta.\n   *\n   * ```markdown\n   * > | ~~~js eval\n   *           ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function meta(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"chunkString\");\n      effects.exit(\"codeFencedFenceMeta\");\n      return infoBefore(code);\n    }\n    if (code === 96 && code === marker) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return meta;\n  }\n\n  /**\n   * At eol/eof in code, before a non-lazy closing fence or content.\n   *\n   * ```markdown\n   * > | ~~~js\n   *          ^\n   * > | alert(1)\n   *             ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function atNonLazyBreak(code) {\n    return effects.attempt(closeStart, after, contentBefore)(code);\n  }\n\n  /**\n   * Before code content, not a closing fence, at eol.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *             ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function contentBefore(code) {\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return contentStart;\n  }\n\n  /**\n   * Before code content, not a closing fence.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *     ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function contentStart(code) {\n    return initialPrefix > 0 && markdownSpace(code) ? factorySpace(effects, beforeContentChunk, \"linePrefix\", initialPrefix + 1)(code) : beforeContentChunk(code);\n  }\n\n  /**\n   * Before code content, after optional prefix.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *     ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeContentChunk(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return effects.check(nonLazyContinuation, atNonLazyBreak, after)(code);\n    }\n    effects.enter(\"codeFlowValue\");\n    return contentChunk(code);\n  }\n\n  /**\n   * In code content.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *     ^^^^^^^^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function contentChunk(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"codeFlowValue\");\n      return beforeContentChunk(code);\n    }\n    effects.consume(code);\n    return contentChunk;\n  }\n\n  /**\n   * After code.\n   *\n   * ```markdown\n   *   | ~~~js\n   *   | alert(1)\n   * > | ~~~\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    effects.exit(\"codeFenced\");\n    return ok(code);\n  }\n\n  /**\n   * @this {TokenizeContext}\n   *   Context.\n   * @type {Tokenizer}\n   */\n  function tokenizeCloseStart(effects, ok, nok) {\n    let size = 0;\n    return startBefore;\n\n    /**\n     *\n     *\n     * @type {State}\n     */\n    function startBefore(code) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return start;\n    }\n\n    /**\n     * Before closing fence, at optional whitespace.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n    function start(code) {\n      // Always populated by defaults.\n\n      // To do: `enter` here or in next state?\n      effects.enter(\"codeFencedFence\");\n      return markdownSpace(code) ? factorySpace(effects, beforeSequenceClose, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code) : beforeSequenceClose(code);\n    }\n\n    /**\n     * In closing fence, after optional whitespace, at sequence.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n    function beforeSequenceClose(code) {\n      if (code === marker) {\n        effects.enter(\"codeFencedFenceSequence\");\n        return sequenceClose(code);\n      }\n      return nok(code);\n    }\n\n    /**\n     * In closing fence sequence.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n    function sequenceClose(code) {\n      if (code === marker) {\n        size++;\n        effects.consume(code);\n        return sequenceClose;\n      }\n      if (size >= sizeOpen) {\n        effects.exit(\"codeFencedFenceSequence\");\n        return markdownSpace(code) ? factorySpace(effects, sequenceCloseAfter, \"whitespace\")(code) : sequenceCloseAfter(code);\n      }\n      return nok(code);\n    }\n\n    /**\n     * After closing fence sequence, after optional whitespace.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *        ^\n     * ```\n     *\n     * @type {State}\n     */\n    function sequenceCloseAfter(code) {\n      if (code === null || markdownLineEnding(code)) {\n        effects.exit(\"codeFencedFence\");\n        return ok(code);\n      }\n      return nok(code);\n    }\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeNonLazyContinuation(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return lineStart;\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function lineStart(code) {\n    return self.parser.lazy[self.now().line] ? nok(code) : ok(code);\n  }\n}","/// <reference lib=\"dom\" />\n\n/* eslint-env browser */\n\nconst element = document.createElement('i')\n\n/**\n * @param {string} value\n * @returns {string|false}\n */\nexport function decodeNamedCharacterReference(value) {\n  const characterReference = '&' + value + ';'\n  element.innerHTML = characterReference\n  const char = element.textContent\n\n  // Some named character references do not require the closing semicolon\n  // (`&not`, for instance), which leads to situations where parsing the assumed\n  // named reference of `&notit;` will result in the string `¬it;`.\n  // When we encounter a trailing semicolon after parsing, and the character\n  // reference to decode was not a semicolon (`&semi;`), we can assume that the\n  // matching was not complete.\n  // @ts-expect-error: TypeScript is wrong that `textContent` on elements can\n  // yield `null`.\n  if (char.charCodeAt(char.length - 1) === 59 /* `;` */ && value !== 'semi') {\n    return false\n  }\n\n  // If the decoded string is equal to the input, the character reference was\n  // not valid.\n  // @ts-expect-error: TypeScript is wrong that `textContent` on elements can\n  // yield `null`.\n  return char === characterReference ? false : char\n}\n","/**\n * @import {\n *   Code,\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { decodeNamedCharacterReference } from 'decode-named-character-reference';\nimport { asciiAlphanumeric, asciiDigit, asciiHexDigit } from 'micromark-util-character';\n/** @type {Construct} */\nexport const characterReference = {\n  name: 'characterReference',\n  tokenize: tokenizeCharacterReference\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCharacterReference(effects, ok, nok) {\n  const self = this;\n  let size = 0;\n  /** @type {number} */\n  let max;\n  /** @type {(code: Code) => boolean} */\n  let test;\n  return start;\n\n  /**\n   * Start of character reference.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *      ^\n   * > | a&#123;b\n   *      ^\n   * > | a&#x9;b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"characterReference\");\n    effects.enter(\"characterReferenceMarker\");\n    effects.consume(code);\n    effects.exit(\"characterReferenceMarker\");\n    return open;\n  }\n\n  /**\n   * After `&`, at `#` for numeric references or alphanumeric for named\n   * references.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *       ^\n   * > | a&#123;b\n   *       ^\n   * > | a&#x9;b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 35) {\n      effects.enter(\"characterReferenceMarkerNumeric\");\n      effects.consume(code);\n      effects.exit(\"characterReferenceMarkerNumeric\");\n      return numeric;\n    }\n    effects.enter(\"characterReferenceValue\");\n    max = 31;\n    test = asciiAlphanumeric;\n    return value(code);\n  }\n\n  /**\n   * After `#`, at `x` for hexadecimals or digit for decimals.\n   *\n   * ```markdown\n   * > | a&#123;b\n   *        ^\n   * > | a&#x9;b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function numeric(code) {\n    if (code === 88 || code === 120) {\n      effects.enter(\"characterReferenceMarkerHexadecimal\");\n      effects.consume(code);\n      effects.exit(\"characterReferenceMarkerHexadecimal\");\n      effects.enter(\"characterReferenceValue\");\n      max = 6;\n      test = asciiHexDigit;\n      return value;\n    }\n    effects.enter(\"characterReferenceValue\");\n    max = 7;\n    test = asciiDigit;\n    return value(code);\n  }\n\n  /**\n   * After markers (`&#x`, `&#`, or `&`), in value, before `;`.\n   *\n   * The character reference kind defines what and how many characters are\n   * allowed.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *       ^^^\n   * > | a&#123;b\n   *        ^^^\n   * > | a&#x9;b\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function value(code) {\n    if (code === 59 && size) {\n      const token = effects.exit(\"characterReferenceValue\");\n      if (test === asciiAlphanumeric && !decodeNamedCharacterReference(self.sliceSerialize(token))) {\n        return nok(code);\n      }\n\n      // To do: `markdown-rs` uses a different name:\n      // `CharacterReferenceMarkerSemi`.\n      effects.enter(\"characterReferenceMarker\");\n      effects.consume(code);\n      effects.exit(\"characterReferenceMarker\");\n      effects.exit(\"characterReference\");\n      return ok;\n    }\n    if (test(code) && size++ < max) {\n      effects.consume(code);\n      return value;\n    }\n    return nok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { asciiPunctuation } from 'micromark-util-character';\n/** @type {Construct} */\nexport const characterEscape = {\n  name: 'characterEscape',\n  tokenize: tokenizeCharacterEscape\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCharacterEscape(effects, ok, nok) {\n  return start;\n\n  /**\n   * Start of character escape.\n   *\n   * ```markdown\n   * > | a\\*b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"characterEscape\");\n    effects.enter(\"escapeMarker\");\n    effects.consume(code);\n    effects.exit(\"escapeMarker\");\n    return inside;\n  }\n\n  /**\n   * After `\\`, at punctuation.\n   *\n   * ```markdown\n   * > | a\\*b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    // ASCII punctuation.\n    if (asciiPunctuation(code)) {\n      effects.enter(\"characterEscapeValue\");\n      effects.consume(code);\n      effects.exit(\"characterEscapeValue\");\n      effects.exit(\"characterEscape\");\n      return ok;\n    }\n    return nok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\nexport const lineEnding = {\n  name: 'lineEnding',\n  tokenize: tokenizeLineEnding\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeLineEnding(effects, ok) {\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return factorySpace(effects, ok, \"linePrefix\");\n  }\n}","/**\n * @import {Event, Resolver, TokenizeContext} from 'micromark-util-types'\n */\n\n/**\n * Call all `resolveAll`s.\n *\n * @param {ReadonlyArray<{resolveAll?: Resolver | undefined}>} constructs\n *   List of constructs, optionally with `resolveAll`s.\n * @param {Array<Event>} events\n *   List of events.\n * @param {TokenizeContext} context\n *   Context used by `tokenize`.\n * @returns {Array<Event>}\n *   Changed events.\n */\nexport function resolveAll(constructs, events, context) {\n  /** @type {Array<Resolver>} */\n  const called = []\n  let index = -1\n\n  while (++index < constructs.length) {\n    const resolve = constructs[index].resolveAll\n\n    if (resolve && !called.includes(resolve)) {\n      events = resolve(events, context)\n      called.push(resolve)\n    }\n  }\n\n  return events\n}\n","/**\n * @import {\n *   Construct,\n *   Event,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { factoryDestination } from 'micromark-factory-destination';\nimport { factoryLabel } from 'micromark-factory-label';\nimport { factoryTitle } from 'micromark-factory-title';\nimport { factoryWhitespace } from 'micromark-factory-whitespace';\nimport { markdownLineEndingOrSpace } from 'micromark-util-character';\nimport { push, splice } from 'micromark-util-chunked';\nimport { normalizeIdentifier } from 'micromark-util-normalize-identifier';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/** @type {Construct} */\nexport const labelEnd = {\n  name: 'labelEnd',\n  resolveAll: resolveAllLabelEnd,\n  resolveTo: resolveToLabelEnd,\n  tokenize: tokenizeLabelEnd\n};\n\n/** @type {Construct} */\nconst resourceConstruct = {\n  tokenize: tokenizeResource\n};\n/** @type {Construct} */\nconst referenceFullConstruct = {\n  tokenize: tokenizeReferenceFull\n};\n/** @type {Construct} */\nconst referenceCollapsedConstruct = {\n  tokenize: tokenizeReferenceCollapsed\n};\n\n/** @type {Resolver} */\nfunction resolveAllLabelEnd(events) {\n  let index = -1;\n  /** @type {Array<Event>} */\n  const newEvents = [];\n  while (++index < events.length) {\n    const token = events[index][1];\n    newEvents.push(events[index]);\n    if (token.type === \"labelImage\" || token.type === \"labelLink\" || token.type === \"labelEnd\") {\n      // Remove the marker.\n      const offset = token.type === \"labelImage\" ? 4 : 2;\n      token.type = \"data\";\n      index += offset;\n    }\n  }\n\n  // If the events are equal, we don't have to copy newEvents to events\n  if (events.length !== newEvents.length) {\n    splice(events, 0, events.length, newEvents);\n  }\n  return events;\n}\n\n/** @type {Resolver} */\nfunction resolveToLabelEnd(events, context) {\n  let index = events.length;\n  let offset = 0;\n  /** @type {Token} */\n  let token;\n  /** @type {number | undefined} */\n  let open;\n  /** @type {number | undefined} */\n  let close;\n  /** @type {Array<Event>} */\n  let media;\n\n  // Find an opening.\n  while (index--) {\n    token = events[index][1];\n    if (open) {\n      // If we see another link, or inactive link label, we’ve been here before.\n      if (token.type === \"link\" || token.type === \"labelLink\" && token._inactive) {\n        break;\n      }\n\n      // Mark other link openings as inactive, as we can’t have links in\n      // links.\n      if (events[index][0] === 'enter' && token.type === \"labelLink\") {\n        token._inactive = true;\n      }\n    } else if (close) {\n      if (events[index][0] === 'enter' && (token.type === \"labelImage\" || token.type === \"labelLink\") && !token._balanced) {\n        open = index;\n        if (token.type !== \"labelLink\") {\n          offset = 2;\n          break;\n        }\n      }\n    } else if (token.type === \"labelEnd\") {\n      close = index;\n    }\n  }\n  const group = {\n    type: events[open][1].type === \"labelLink\" ? \"link\" : \"image\",\n    start: {\n      ...events[open][1].start\n    },\n    end: {\n      ...events[events.length - 1][1].end\n    }\n  };\n  const label = {\n    type: \"label\",\n    start: {\n      ...events[open][1].start\n    },\n    end: {\n      ...events[close][1].end\n    }\n  };\n  const text = {\n    type: \"labelText\",\n    start: {\n      ...events[open + offset + 2][1].end\n    },\n    end: {\n      ...events[close - 2][1].start\n    }\n  };\n  media = [['enter', group, context], ['enter', label, context]];\n\n  // Opening marker.\n  media = push(media, events.slice(open + 1, open + offset + 3));\n\n  // Text open.\n  media = push(media, [['enter', text, context]]);\n\n  // Always populated by defaults.\n\n  // Between.\n  media = push(media, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + offset + 4, close - 3), context));\n\n  // Text close, marker close, label close.\n  media = push(media, [['exit', text, context], events[close - 2], events[close - 1], ['exit', label, context]]);\n\n  // Reference, resource, or so.\n  media = push(media, events.slice(close + 1));\n\n  // Media close.\n  media = push(media, [['exit', group, context]]);\n  splice(events, open, events.length, media);\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeLabelEnd(effects, ok, nok) {\n  const self = this;\n  let index = self.events.length;\n  /** @type {Token} */\n  let labelStart;\n  /** @type {boolean} */\n  let defined;\n\n  // Find an opening.\n  while (index--) {\n    if ((self.events[index][1].type === \"labelImage\" || self.events[index][1].type === \"labelLink\") && !self.events[index][1]._balanced) {\n      labelStart = self.events[index][1];\n      break;\n    }\n  }\n  return start;\n\n  /**\n   * Start of label end.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *       ^\n   * > | [a][b] c\n   *       ^\n   * > | [a][] b\n   *       ^\n   * > | [a] b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // If there is not an okay opening.\n    if (!labelStart) {\n      return nok(code);\n    }\n\n    // If the corresponding label (link) start is marked as inactive,\n    // it means we’d be wrapping a link, like this:\n    //\n    // ```markdown\n    // > | a [b [c](d) e](f) g.\n    //                  ^\n    // ```\n    //\n    // We can’t have that, so it’s just balanced brackets.\n    if (labelStart._inactive) {\n      return labelEndNok(code);\n    }\n    defined = self.parser.defined.includes(normalizeIdentifier(self.sliceSerialize({\n      start: labelStart.end,\n      end: self.now()\n    })));\n    effects.enter(\"labelEnd\");\n    effects.enter(\"labelMarker\");\n    effects.consume(code);\n    effects.exit(\"labelMarker\");\n    effects.exit(\"labelEnd\");\n    return after;\n  }\n\n  /**\n   * After `]`.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *       ^\n   * > | [a][b] c\n   *       ^\n   * > | [a][] b\n   *       ^\n   * > | [a] b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // Note: `markdown-rs` also parses GFM footnotes here, which for us is in\n    // an extension.\n\n    // Resource (`[asd](fgh)`)?\n    if (code === 40) {\n      return effects.attempt(resourceConstruct, labelEndOk, defined ? labelEndOk : labelEndNok)(code);\n    }\n\n    // Full (`[asd][fgh]`) or collapsed (`[asd][]`) reference?\n    if (code === 91) {\n      return effects.attempt(referenceFullConstruct, labelEndOk, defined ? referenceNotFull : labelEndNok)(code);\n    }\n\n    // Shortcut (`[asd]`) reference?\n    return defined ? labelEndOk(code) : labelEndNok(code);\n  }\n\n  /**\n   * After `]`, at `[`, but not at a full reference.\n   *\n   * > 👉 **Note**: we only get here if the label is defined.\n   *\n   * ```markdown\n   * > | [a][] b\n   *        ^\n   * > | [a] b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceNotFull(code) {\n    return effects.attempt(referenceCollapsedConstruct, labelEndOk, labelEndNok)(code);\n  }\n\n  /**\n   * Done, we found something.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *           ^\n   * > | [a][b] c\n   *           ^\n   * > | [a][] b\n   *          ^\n   * > | [a] b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEndOk(code) {\n    // Note: `markdown-rs` does a bunch of stuff here.\n    return ok(code);\n  }\n\n  /**\n   * Done, it’s nothing.\n   *\n   * There was an okay opening, but we didn’t match anything.\n   *\n   * ```markdown\n   * > | [a](b c\n   *        ^\n   * > | [a][b c\n   *        ^\n   * > | [a] b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEndNok(code) {\n    labelStart._balanced = true;\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeResource(effects, ok, nok) {\n  return resourceStart;\n\n  /**\n   * At a resource.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceStart(code) {\n    effects.enter(\"resource\");\n    effects.enter(\"resourceMarker\");\n    effects.consume(code);\n    effects.exit(\"resourceMarker\");\n    return resourceBefore;\n  }\n\n  /**\n   * In resource, after `(`, at optional whitespace.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceBefore(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceOpen)(code) : resourceOpen(code);\n  }\n\n  /**\n   * In resource, after optional whitespace, at `)` or a destination.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceOpen(code) {\n    if (code === 41) {\n      return resourceEnd(code);\n    }\n    return factoryDestination(effects, resourceDestinationAfter, resourceDestinationMissing, \"resourceDestination\", \"resourceDestinationLiteral\", \"resourceDestinationLiteralMarker\", \"resourceDestinationRaw\", \"resourceDestinationString\", 32)(code);\n  }\n\n  /**\n   * In resource, after destination, at optional whitespace.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceDestinationAfter(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceBetween)(code) : resourceEnd(code);\n  }\n\n  /**\n   * At invalid destination.\n   *\n   * ```markdown\n   * > | [a](<<) b\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceDestinationMissing(code) {\n    return nok(code);\n  }\n\n  /**\n   * In resource, after destination and whitespace, at `(` or title.\n   *\n   * ```markdown\n   * > | [a](b ) c\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceBetween(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(effects, resourceTitleAfter, nok, \"resourceTitle\", \"resourceTitleMarker\", \"resourceTitleString\")(code);\n    }\n    return resourceEnd(code);\n  }\n\n  /**\n   * In resource, after title, at optional whitespace.\n   *\n   * ```markdown\n   * > | [a](b \"c\") d\n   *              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceTitleAfter(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceEnd)(code) : resourceEnd(code);\n  }\n\n  /**\n   * In resource, at `)`.\n   *\n   * ```markdown\n   * > | [a](b) d\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceEnd(code) {\n    if (code === 41) {\n      effects.enter(\"resourceMarker\");\n      effects.consume(code);\n      effects.exit(\"resourceMarker\");\n      effects.exit(\"resource\");\n      return ok;\n    }\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeReferenceFull(effects, ok, nok) {\n  const self = this;\n  return referenceFull;\n\n  /**\n   * In a reference (full), at the `[`.\n   *\n   * ```markdown\n   * > | [a][b] d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceFull(code) {\n    return factoryLabel.call(self, effects, referenceFullAfter, referenceFullMissing, \"reference\", \"referenceMarker\", \"referenceString\")(code);\n  }\n\n  /**\n   * In a reference (full), after `]`.\n   *\n   * ```markdown\n   * > | [a][b] d\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceFullAfter(code) {\n    return self.parser.defined.includes(normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1))) ? ok(code) : nok(code);\n  }\n\n  /**\n   * In reference (full) that was missing.\n   *\n   * ```markdown\n   * > | [a][b d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceFullMissing(code) {\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeReferenceCollapsed(effects, ok, nok) {\n  return referenceCollapsedStart;\n\n  /**\n   * In reference (collapsed), at `[`.\n   *\n   * > 👉 **Note**: we only get here if the label is defined.\n   *\n   * ```markdown\n   * > | [a][] d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceCollapsedStart(code) {\n    // We only attempt a collapsed label if there’s a `[`.\n\n    effects.enter(\"reference\");\n    effects.enter(\"referenceMarker\");\n    effects.consume(code);\n    effects.exit(\"referenceMarker\");\n    return referenceCollapsedOpen;\n  }\n\n  /**\n   * In reference (collapsed), at `]`.\n   *\n   * > 👉 **Note**: we only get here if the label is defined.\n   *\n   * ```markdown\n   * > | [a][] d\n   *         ^\n   * ```\n   *\n   *  @type {State}\n   */\n  function referenceCollapsedOpen(code) {\n    if (code === 93) {\n      effects.enter(\"referenceMarker\");\n      effects.consume(code);\n      effects.exit(\"referenceMarker\");\n      effects.exit(\"reference\");\n      return ok;\n    }\n    return nok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { labelEnd } from './label-end.js';\n\n/** @type {Construct} */\nexport const labelStartImage = {\n  name: 'labelStartImage',\n  resolveAll: labelEnd.resolveAll,\n  tokenize: tokenizeLabelStartImage\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeLabelStartImage(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of label (image) start.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"labelImage\");\n    effects.enter(\"labelImageMarker\");\n    effects.consume(code);\n    effects.exit(\"labelImageMarker\");\n    return open;\n  }\n\n  /**\n   * After `!`, at `[`.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 91) {\n      effects.enter(\"labelMarker\");\n      effects.consume(code);\n      effects.exit(\"labelMarker\");\n      effects.exit(\"labelImage\");\n      return after;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `![`.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *         ^\n   * ```\n   *\n   * This is needed in because, when GFM footnotes are enabled, images never\n   * form when started with a `^`.\n   * Instead, links form:\n   *\n   * ```markdown\n   * ![^a](b)\n   *\n   * ![^a][b]\n   *\n   * [b]: c\n   * ```\n   *\n   * ```html\n   * <p>!<a href=\\\"b\\\">^a</a></p>\n   * <p>!<a href=\\\"c\\\">^a</a></p>\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // To do: use a new field to do this, this is still needed for\n    // `micromark-extension-gfm-footnote`, but the `label-start-link`\n    // behavior isn’t.\n    // Hidden footnotes hook.\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs ? nok(code) : ok(code);\n  }\n}","/**\n * @import {Code} from 'micromark-util-types'\n */\n\nimport { markdownLineEndingOrSpace, unicodePunctuation, unicodeWhitespace } from 'micromark-util-character';\n/**\n * Classify whether a code represents whitespace, punctuation, or something\n * else.\n *\n * Used for attention (emphasis, strong), whose sequences can open or close\n * based on the class of surrounding characters.\n *\n * > 👉 **Note**: eof (`null`) is seen as whitespace.\n *\n * @param {Code} code\n *   Code.\n * @returns {typeof constants.characterGroupWhitespace | typeof constants.characterGroupPunctuation | undefined}\n *   Group.\n */\nexport function classifyCharacter(code) {\n  if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {\n    return 1;\n  }\n  if (unicodePunctuation(code)) {\n    return 2;\n  }\n}","/**\n * @import {\n *   Code,\n *   Construct,\n *   Event,\n *   Point,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { push, splice } from 'micromark-util-chunked';\nimport { classifyCharacter } from 'micromark-util-classify-character';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/** @type {Construct} */\nexport const attention = {\n  name: 'attention',\n  resolveAll: resolveAllAttention,\n  tokenize: tokenizeAttention\n};\n\n/**\n * Take all events and resolve attention to emphasis or strong.\n *\n * @type {Resolver}\n */\n// eslint-disable-next-line complexity\nfunction resolveAllAttention(events, context) {\n  let index = -1;\n  /** @type {number} */\n  let open;\n  /** @type {Token} */\n  let group;\n  /** @type {Token} */\n  let text;\n  /** @type {Token} */\n  let openingSequence;\n  /** @type {Token} */\n  let closingSequence;\n  /** @type {number} */\n  let use;\n  /** @type {Array<Event>} */\n  let nextEvents;\n  /** @type {number} */\n  let offset;\n\n  // Walk through all events.\n  //\n  // Note: performance of this is fine on an mb of normal markdown, but it’s\n  // a bottleneck for malicious stuff.\n  while (++index < events.length) {\n    // Find a token that can close.\n    if (events[index][0] === 'enter' && events[index][1].type === 'attentionSequence' && events[index][1]._close) {\n      open = index;\n\n      // Now walk back to find an opener.\n      while (open--) {\n        // Find a token that can open the closer.\n        if (events[open][0] === 'exit' && events[open][1].type === 'attentionSequence' && events[open][1]._open &&\n        // If the markers are the same:\n        context.sliceSerialize(events[open][1]).charCodeAt(0) === context.sliceSerialize(events[index][1]).charCodeAt(0)) {\n          // If the opening can close or the closing can open,\n          // and the close size *is not* a multiple of three,\n          // but the sum of the opening and closing size *is* multiple of three,\n          // then don’t match.\n          if ((events[open][1]._close || events[index][1]._open) && (events[index][1].end.offset - events[index][1].start.offset) % 3 && !((events[open][1].end.offset - events[open][1].start.offset + events[index][1].end.offset - events[index][1].start.offset) % 3)) {\n            continue;\n          }\n\n          // Number of markers to use from the sequence.\n          use = events[open][1].end.offset - events[open][1].start.offset > 1 && events[index][1].end.offset - events[index][1].start.offset > 1 ? 2 : 1;\n          const start = {\n            ...events[open][1].end\n          };\n          const end = {\n            ...events[index][1].start\n          };\n          movePoint(start, -use);\n          movePoint(end, use);\n          openingSequence = {\n            type: use > 1 ? \"strongSequence\" : \"emphasisSequence\",\n            start,\n            end: {\n              ...events[open][1].end\n            }\n          };\n          closingSequence = {\n            type: use > 1 ? \"strongSequence\" : \"emphasisSequence\",\n            start: {\n              ...events[index][1].start\n            },\n            end\n          };\n          text = {\n            type: use > 1 ? \"strongText\" : \"emphasisText\",\n            start: {\n              ...events[open][1].end\n            },\n            end: {\n              ...events[index][1].start\n            }\n          };\n          group = {\n            type: use > 1 ? \"strong\" : \"emphasis\",\n            start: {\n              ...openingSequence.start\n            },\n            end: {\n              ...closingSequence.end\n            }\n          };\n          events[open][1].end = {\n            ...openingSequence.start\n          };\n          events[index][1].start = {\n            ...closingSequence.end\n          };\n          nextEvents = [];\n\n          // If there are more markers in the opening, add them before.\n          if (events[open][1].end.offset - events[open][1].start.offset) {\n            nextEvents = push(nextEvents, [['enter', events[open][1], context], ['exit', events[open][1], context]]);\n          }\n\n          // Opening.\n          nextEvents = push(nextEvents, [['enter', group, context], ['enter', openingSequence, context], ['exit', openingSequence, context], ['enter', text, context]]);\n\n          // Always populated by defaults.\n\n          // Between.\n          nextEvents = push(nextEvents, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + 1, index), context));\n\n          // Closing.\n          nextEvents = push(nextEvents, [['exit', text, context], ['enter', closingSequence, context], ['exit', closingSequence, context], ['exit', group, context]]);\n\n          // If there are more markers in the closing, add them after.\n          if (events[index][1].end.offset - events[index][1].start.offset) {\n            offset = 2;\n            nextEvents = push(nextEvents, [['enter', events[index][1], context], ['exit', events[index][1], context]]);\n          } else {\n            offset = 0;\n          }\n          splice(events, open - 1, index - open + 3, nextEvents);\n          index = open + nextEvents.length - offset - 2;\n          break;\n        }\n      }\n    }\n  }\n\n  // Remove remaining sequences.\n  index = -1;\n  while (++index < events.length) {\n    if (events[index][1].type === 'attentionSequence') {\n      events[index][1].type = 'data';\n    }\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeAttention(effects, ok) {\n  const attentionMarkers = this.parser.constructs.attentionMarkers.null;\n  const previous = this.previous;\n  const before = classifyCharacter(previous);\n\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * Before a sequence.\n   *\n   * ```markdown\n   * > | **\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    marker = code;\n    effects.enter('attentionSequence');\n    return inside(code);\n  }\n\n  /**\n   * In a sequence.\n   *\n   * ```markdown\n   * > | **\n   *     ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return inside;\n    }\n    const token = effects.exit('attentionSequence');\n\n    // To do: next major: move this to resolver, just like `markdown-rs`.\n    const after = classifyCharacter(code);\n\n    // Always populated by defaults.\n\n    const open = !after || after === 2 && before || attentionMarkers.includes(code);\n    const close = !before || before === 2 && after || attentionMarkers.includes(previous);\n    token._open = Boolean(marker === 42 ? open : open && (before || !close));\n    token._close = Boolean(marker === 42 ? close : close && (after || !open));\n    return ok(code);\n  }\n}\n\n/**\n * Move a point a bit.\n *\n * Note: `move` only works inside lines! It’s not possible to move past other\n * chunks (replacement characters, tabs, or line endings).\n *\n * @param {Point} point\n *   Point.\n * @param {number} offset\n *   Amount to move.\n * @returns {undefined}\n *   Nothing.\n */\nfunction movePoint(point, offset) {\n  point.column += offset;\n  point.offset += offset;\n  point._bufferIndex += offset;\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { asciiAlphanumeric, asciiAlpha, asciiAtext, asciiControl } from 'micromark-util-character';\n/** @type {Construct} */\nexport const autolink = {\n  name: 'autolink',\n  tokenize: tokenizeAutolink\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeAutolink(effects, ok, nok) {\n  let size = 0;\n  return start;\n\n  /**\n   * Start of an autolink.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *      ^\n   * > | a<user@example.com>b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"autolink\");\n    effects.enter(\"autolinkMarker\");\n    effects.consume(code);\n    effects.exit(\"autolinkMarker\");\n    effects.enter(\"autolinkProtocol\");\n    return open;\n  }\n\n  /**\n   * After `<`, at protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *       ^\n   * > | a<user@example.com>b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return schemeOrEmailAtext;\n    }\n    if (code === 64) {\n      return nok(code);\n    }\n    return emailAtext(code);\n  }\n\n  /**\n   * At second byte of protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *        ^\n   * > | a<user@example.com>b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function schemeOrEmailAtext(code) {\n    // ASCII alphanumeric and `+`, `-`, and `.`.\n    if (code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) {\n      // Count the previous alphabetical from `open` too.\n      size = 1;\n      return schemeInsideOrEmailAtext(code);\n    }\n    return emailAtext(code);\n  }\n\n  /**\n   * In ambiguous protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *        ^\n   * > | a<user@example.com>b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function schemeInsideOrEmailAtext(code) {\n    if (code === 58) {\n      effects.consume(code);\n      size = 0;\n      return urlInside;\n    }\n\n    // ASCII alphanumeric and `+`, `-`, and `.`.\n    if ((code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) && size++ < 32) {\n      effects.consume(code);\n      return schemeInsideOrEmailAtext;\n    }\n    size = 0;\n    return emailAtext(code);\n  }\n\n  /**\n   * After protocol, in URL.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function urlInside(code) {\n    if (code === 62) {\n      effects.exit(\"autolinkProtocol\");\n      effects.enter(\"autolinkMarker\");\n      effects.consume(code);\n      effects.exit(\"autolinkMarker\");\n      effects.exit(\"autolink\");\n      return ok;\n    }\n\n    // ASCII control, space, or `<`.\n    if (code === null || code === 32 || code === 60 || asciiControl(code)) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return urlInside;\n  }\n\n  /**\n   * In email atext.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailAtext(code) {\n    if (code === 64) {\n      effects.consume(code);\n      return emailAtSignOrDot;\n    }\n    if (asciiAtext(code)) {\n      effects.consume(code);\n      return emailAtext;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In label, after at-sign or dot.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *                 ^       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailAtSignOrDot(code) {\n    return asciiAlphanumeric(code) ? emailLabel(code) : nok(code);\n  }\n\n  /**\n   * In label, where `.` and `>` are allowed.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *                   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailLabel(code) {\n    if (code === 46) {\n      effects.consume(code);\n      size = 0;\n      return emailAtSignOrDot;\n    }\n    if (code === 62) {\n      // Exit, then change the token type.\n      effects.exit(\"autolinkProtocol\").type = \"autolinkEmail\";\n      effects.enter(\"autolinkMarker\");\n      effects.consume(code);\n      effects.exit(\"autolinkMarker\");\n      effects.exit(\"autolink\");\n      return ok;\n    }\n    return emailValue(code);\n  }\n\n  /**\n   * In label, where `.` and `>` are *not* allowed.\n   *\n   * Though, this is also used in `emailLabel` to parse other values.\n   *\n   * ```markdown\n   * > | a<user.name@ex-ample.com>b\n   *                    ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailValue(code) {\n    // ASCII alphanumeric or `-`.\n    if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) {\n      const next = code === 45 ? emailValue : emailLabel;\n      effects.consume(code);\n      return next;\n    }\n    return nok(code);\n  }\n}","/**\n * @import {\n *   Code,\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { asciiAlphanumeric, asciiAlpha, markdownLineEndingOrSpace, markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const htmlText = {\n  name: 'htmlText',\n  tokenize: tokenizeHtmlText\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeHtmlText(effects, ok, nok) {\n  const self = this;\n  /** @type {NonNullable<Code> | undefined} */\n  let marker;\n  /** @type {number} */\n  let index;\n  /** @type {State} */\n  let returnState;\n  return start;\n\n  /**\n   * Start of HTML (text).\n   *\n   * ```markdown\n   * > | a <b> c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"htmlText\");\n    effects.enter(\"htmlTextData\");\n    effects.consume(code);\n    return open;\n  }\n\n  /**\n   * After `<`, at tag name or other stuff.\n   *\n   * ```markdown\n   * > | a <b> c\n   *        ^\n   * > | a <!doctype> c\n   *        ^\n   * > | a <!--b--> c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code);\n      return declarationOpen;\n    }\n    if (code === 47) {\n      effects.consume(code);\n      return tagCloseStart;\n    }\n    if (code === 63) {\n      effects.consume(code);\n      return instruction;\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return tagOpen;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `<!`, at declaration, comment, or CDATA.\n   *\n   * ```markdown\n   * > | a <!doctype> c\n   *         ^\n   * > | a <!--b--> c\n   *         ^\n   * > | a <![CDATA[>&<]]> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentOpenInside;\n    }\n    if (code === 91) {\n      effects.consume(code);\n      index = 0;\n      return cdataOpenInside;\n    }\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return declaration;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In a comment, after `<!-`, at another `-`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentEnd;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In comment.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function comment(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    if (code === 45) {\n      effects.consume(code);\n      return commentClose;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = comment;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return comment;\n  }\n\n  /**\n   * In comment, after `-`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentClose(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentEnd;\n    }\n    return comment(code);\n  }\n\n  /**\n   * In comment, after `--`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentEnd(code) {\n    return code === 62 ? end(code) : code === 45 ? commentClose(code) : comment(code);\n  }\n\n  /**\n   * After `<![`, in CDATA, expecting `CDATA[`.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *          ^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataOpenInside(code) {\n    const value = \"CDATA[\";\n    if (code === value.charCodeAt(index++)) {\n      effects.consume(code);\n      return index === value.length ? cdata : cdataOpenInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In CDATA.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *                ^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdata(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    if (code === 93) {\n      effects.consume(code);\n      return cdataClose;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = cdata;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return cdata;\n  }\n\n  /**\n   * In CDATA, after `]`, at another `]`.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *                    ^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataClose(code) {\n    if (code === 93) {\n      effects.consume(code);\n      return cdataEnd;\n    }\n    return cdata(code);\n  }\n\n  /**\n   * In CDATA, after `]]`, at `>`.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *                     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataEnd(code) {\n    if (code === 62) {\n      return end(code);\n    }\n    if (code === 93) {\n      effects.consume(code);\n      return cdataEnd;\n    }\n    return cdata(code);\n  }\n\n  /**\n   * In declaration.\n   *\n   * ```markdown\n   * > | a <!b> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function declaration(code) {\n    if (code === null || code === 62) {\n      return end(code);\n    }\n    if (markdownLineEnding(code)) {\n      returnState = declaration;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return declaration;\n  }\n\n  /**\n   * In instruction.\n   *\n   * ```markdown\n   * > | a <?b?> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function instruction(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    if (code === 63) {\n      effects.consume(code);\n      return instructionClose;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = instruction;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return instruction;\n  }\n\n  /**\n   * In instruction, after `?`, at `>`.\n   *\n   * ```markdown\n   * > | a <?b?> c\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function instructionClose(code) {\n    return code === 62 ? end(code) : instruction(code);\n  }\n\n  /**\n   * After `</`, in closing tag, at tag name.\n   *\n   * ```markdown\n   * > | a </b> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagCloseStart(code) {\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return tagClose;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `</x`, in a tag name.\n   *\n   * ```markdown\n   * > | a </b> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagClose(code) {\n    // ASCII alphanumerical and `-`.\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagClose;\n    }\n    return tagCloseBetween(code);\n  }\n\n  /**\n   * In closing tag, after tag name.\n   *\n   * ```markdown\n   * > | a </b> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagCloseBetween(code) {\n    if (markdownLineEnding(code)) {\n      returnState = tagCloseBetween;\n      return lineEndingBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagCloseBetween;\n    }\n    return end(code);\n  }\n\n  /**\n   * After `<x`, in opening tag name.\n   *\n   * ```markdown\n   * > | a <b> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpen(code) {\n    // ASCII alphanumerical and `-`.\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagOpen;\n    }\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In opening tag, after tag name.\n   *\n   * ```markdown\n   * > | a <b> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenBetween(code) {\n    if (code === 47) {\n      effects.consume(code);\n      return end;\n    }\n\n    // ASCII alphabetical and `:` and `_`.\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code);\n      return tagOpenAttributeName;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenBetween;\n      return lineEndingBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenBetween;\n    }\n    return end(code);\n  }\n\n  /**\n   * In attribute name.\n   *\n   * ```markdown\n   * > | a <b c> d\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeName(code) {\n    // ASCII alphabetical and `-`, `.`, `:`, and `_`.\n    if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagOpenAttributeName;\n    }\n    return tagOpenAttributeNameAfter(code);\n  }\n\n  /**\n   * After attribute name, before initializer, the end of the tag, or\n   * whitespace.\n   *\n   * ```markdown\n   * > | a <b c> d\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code);\n      return tagOpenAttributeValueBefore;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeNameAfter;\n      return lineEndingBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenAttributeNameAfter;\n    }\n    return tagOpenBetween(code);\n  }\n\n  /**\n   * Before unquoted, double quoted, or single quoted attribute value, allowing\n   * whitespace.\n   *\n   * ```markdown\n   * > | a <b c=d> e\n   *            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueBefore(code) {\n    if (code === null || code === 60 || code === 61 || code === 62 || code === 96) {\n      return nok(code);\n    }\n    if (code === 34 || code === 39) {\n      effects.consume(code);\n      marker = code;\n      return tagOpenAttributeValueQuoted;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueBefore;\n      return lineEndingBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenAttributeValueBefore;\n    }\n    effects.consume(code);\n    return tagOpenAttributeValueUnquoted;\n  }\n\n  /**\n   * In double or single quoted attribute value.\n   *\n   * ```markdown\n   * > | a <b c=\"d\"> e\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code);\n      marker = undefined;\n      return tagOpenAttributeValueQuotedAfter;\n    }\n    if (code === null) {\n      return nok(code);\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueQuoted;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return tagOpenAttributeValueQuoted;\n  }\n\n  /**\n   * In unquoted attribute value.\n   *\n   * ```markdown\n   * > | a <b c=d> e\n   *            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueUnquoted(code) {\n    if (code === null || code === 34 || code === 39 || code === 60 || code === 61 || code === 96) {\n      return nok(code);\n    }\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n    effects.consume(code);\n    return tagOpenAttributeValueUnquoted;\n  }\n\n  /**\n   * After double or single quoted attribute value, before whitespace or the end\n   * of the tag.\n   *\n   * ```markdown\n   * > | a <b c=\"d\"> e\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In certain circumstances of a tag where only an `>` is allowed.\n   *\n   * ```markdown\n   * > | a <b c=\"d\"> e\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function end(code) {\n    if (code === 62) {\n      effects.consume(code);\n      effects.exit(\"htmlTextData\");\n      effects.exit(\"htmlText\");\n      return ok;\n    }\n    return nok(code);\n  }\n\n  /**\n   * At eol.\n   *\n   * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about\n   * > empty tokens.\n   *\n   * ```markdown\n   * > | a <!--a\n   *            ^\n   *   | b-->\n   * ```\n   *\n   * @type {State}\n   */\n  function lineEndingBefore(code) {\n    effects.exit(\"htmlTextData\");\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return lineEndingAfter;\n  }\n\n  /**\n   * After eol, at optional whitespace.\n   *\n   * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about\n   * > empty tokens.\n   *\n   * ```markdown\n   *   | a <!--a\n   * > | b-->\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function lineEndingAfter(code) {\n    // Always populated by defaults.\n\n    return markdownSpace(code) ? factorySpace(effects, lineEndingAfterPrefix, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code) : lineEndingAfterPrefix(code);\n  }\n\n  /**\n   * After eol, after optional whitespace.\n   *\n   * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about\n   * > empty tokens.\n   *\n   * ```markdown\n   *   | a <!--a\n   * > | b-->\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function lineEndingAfterPrefix(code) {\n    effects.enter(\"htmlTextData\");\n    return returnState(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { labelEnd } from './label-end.js';\n\n/** @type {Construct} */\nexport const labelStartLink = {\n  name: 'labelStartLink',\n  resolveAll: labelEnd.resolveAll,\n  tokenize: tokenizeLabelStartLink\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeLabelStartLink(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of label (link) start.\n   *\n   * ```markdown\n   * > | a [b] c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"labelLink\");\n    effects.enter(\"labelMarker\");\n    effects.consume(code);\n    effects.exit(\"labelMarker\");\n    effects.exit(\"labelLink\");\n    return after;\n  }\n\n  /** @type {State} */\n  function after(code) {\n    // To do: this isn’t needed in `micromark-extension-gfm-footnote`,\n    // remove.\n    // Hidden footnotes hook.\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs ? nok(code) : ok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\nexport const hardBreakEscape = {\n  name: 'hardBreakEscape',\n  tokenize: tokenizeHardBreakEscape\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeHardBreakEscape(effects, ok, nok) {\n  return start;\n\n  /**\n   * Start of a hard break (escape).\n   *\n   * ```markdown\n   * > | a\\\n   *      ^\n   *   | b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"hardBreakEscape\");\n    effects.consume(code);\n    return after;\n  }\n\n  /**\n   * After `\\`, at eol.\n   *\n   * ```markdown\n   * > | a\\\n   *       ^\n   *   | b\n   * ```\n   *\n   *  @type {State}\n   */\n  function after(code) {\n    if (markdownLineEnding(code)) {\n      effects.exit(\"hardBreakEscape\");\n      return ok(code);\n    }\n    return nok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   Previous,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\nexport const codeText = {\n  name: 'codeText',\n  previous,\n  resolve: resolveCodeText,\n  tokenize: tokenizeCodeText\n};\n\n// To do: next major: don’t resolve, like `markdown-rs`.\n/** @type {Resolver} */\nfunction resolveCodeText(events) {\n  let tailExitIndex = events.length - 4;\n  let headEnterIndex = 3;\n  /** @type {number} */\n  let index;\n  /** @type {number | undefined} */\n  let enter;\n\n  // If we start and end with an EOL or a space.\n  if ((events[headEnterIndex][1].type === \"lineEnding\" || events[headEnterIndex][1].type === 'space') && (events[tailExitIndex][1].type === \"lineEnding\" || events[tailExitIndex][1].type === 'space')) {\n    index = headEnterIndex;\n\n    // And we have data.\n    while (++index < tailExitIndex) {\n      if (events[index][1].type === \"codeTextData\") {\n        // Then we have padding.\n        events[headEnterIndex][1].type = \"codeTextPadding\";\n        events[tailExitIndex][1].type = \"codeTextPadding\";\n        headEnterIndex += 2;\n        tailExitIndex -= 2;\n        break;\n      }\n    }\n  }\n\n  // Merge adjacent spaces and data.\n  index = headEnterIndex - 1;\n  tailExitIndex++;\n  while (++index <= tailExitIndex) {\n    if (enter === undefined) {\n      if (index !== tailExitIndex && events[index][1].type !== \"lineEnding\") {\n        enter = index;\n      }\n    } else if (index === tailExitIndex || events[index][1].type === \"lineEnding\") {\n      events[enter][1].type = \"codeTextData\";\n      if (index !== enter + 2) {\n        events[enter][1].end = events[index - 1][1].end;\n        events.splice(enter + 2, index - enter - 2);\n        tailExitIndex -= index - enter - 2;\n        index = enter + 2;\n      }\n      enter = undefined;\n    }\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Previous}\n */\nfunction previous(code) {\n  // If there is a previous code, there will always be a tail.\n  return code !== 96 || this.events[this.events.length - 1][1].type === \"characterEscape\";\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCodeText(effects, ok, nok) {\n  const self = this;\n  let sizeOpen = 0;\n  /** @type {number} */\n  let size;\n  /** @type {Token} */\n  let token;\n  return start;\n\n  /**\n   * Start of code (text).\n   *\n   * ```markdown\n   * > | `a`\n   *     ^\n   * > | \\`a`\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"codeText\");\n    effects.enter(\"codeTextSequence\");\n    return sequenceOpen(code);\n  }\n\n  /**\n   * In opening sequence.\n   *\n   * ```markdown\n   * > | `a`\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === 96) {\n      effects.consume(code);\n      sizeOpen++;\n      return sequenceOpen;\n    }\n    effects.exit(\"codeTextSequence\");\n    return between(code);\n  }\n\n  /**\n   * Between something and something else.\n   *\n   * ```markdown\n   * > | `a`\n   *      ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function between(code) {\n    // EOF.\n    if (code === null) {\n      return nok(code);\n    }\n\n    // To do: next major: don’t do spaces in resolve, but when compiling,\n    // like `markdown-rs`.\n    // Tabs don’t work, and virtual spaces don’t make sense.\n    if (code === 32) {\n      effects.enter('space');\n      effects.consume(code);\n      effects.exit('space');\n      return between;\n    }\n\n    // Closing fence? Could also be data.\n    if (code === 96) {\n      token = effects.enter(\"codeTextSequence\");\n      size = 0;\n      return sequenceClose(code);\n    }\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return between;\n    }\n\n    // Data.\n    effects.enter(\"codeTextData\");\n    return data(code);\n  }\n\n  /**\n   * In data.\n   *\n   * ```markdown\n   * > | `a`\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function data(code) {\n    if (code === null || code === 32 || code === 96 || markdownLineEnding(code)) {\n      effects.exit(\"codeTextData\");\n      return between(code);\n    }\n    effects.consume(code);\n    return data;\n  }\n\n  /**\n   * In closing sequence.\n   *\n   * ```markdown\n   * > | `a`\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceClose(code) {\n    // More.\n    if (code === 96) {\n      effects.consume(code);\n      size++;\n      return sequenceClose;\n    }\n\n    // Done!\n    if (size === sizeOpen) {\n      effects.exit(\"codeTextSequence\");\n      effects.exit(\"codeText\");\n      return ok(code);\n    }\n\n    // More or less accents: mark as data.\n    token.type = \"codeTextData\";\n    return data(code);\n  }\n}","/**\n * @import {Extension} from 'micromark-util-types'\n */\n\nimport { attention, autolink, blockQuote, characterEscape, characterReference, codeFenced, codeIndented, codeText, definition, hardBreakEscape, headingAtx, htmlFlow, htmlText, labelEnd, labelStartImage, labelStartLink, lineEnding, list, setextUnderline, thematicBreak } from 'micromark-core-commonmark';\nimport { resolver as resolveText } from './initialize/text.js';\n\n/** @satisfies {Extension['document']} */\nexport const document = {\n  [42]: list,\n  [43]: list,\n  [45]: list,\n  [48]: list,\n  [49]: list,\n  [50]: list,\n  [51]: list,\n  [52]: list,\n  [53]: list,\n  [54]: list,\n  [55]: list,\n  [56]: list,\n  [57]: list,\n  [62]: blockQuote\n};\n\n/** @satisfies {Extension['contentInitial']} */\nexport const contentInitial = {\n  [91]: definition\n};\n\n/** @satisfies {Extension['flowInitial']} */\nexport const flowInitial = {\n  [-2]: codeIndented,\n  [-1]: codeIndented,\n  [32]: codeIndented\n};\n\n/** @satisfies {Extension['flow']} */\nexport const flow = {\n  [35]: headingAtx,\n  [42]: thematicBreak,\n  [45]: [setextUnderline, thematicBreak],\n  [60]: htmlFlow,\n  [61]: setextUnderline,\n  [95]: thematicBreak,\n  [96]: codeFenced,\n  [126]: codeFenced\n};\n\n/** @satisfies {Extension['string']} */\nexport const string = {\n  [38]: characterReference,\n  [92]: characterEscape\n};\n\n/** @satisfies {Extension['text']} */\nexport const text = {\n  [-5]: lineEnding,\n  [-4]: lineEnding,\n  [-3]: lineEnding,\n  [33]: labelStartImage,\n  [38]: characterReference,\n  [42]: attention,\n  [60]: [autolink, htmlText],\n  [91]: labelStartLink,\n  [92]: [hardBreakEscape, characterEscape],\n  [93]: labelEnd,\n  [95]: attention,\n  [96]: codeText\n};\n\n/** @satisfies {Extension['insideSpan']} */\nexport const insideSpan = {\n  null: [attention, resolveText]\n};\n\n/** @satisfies {Extension['attentionMarkers']} */\nexport const attentionMarkers = {\n  null: [42, 95]\n};\n\n/** @satisfies {Extension['disable']} */\nexport const disable = {\n  null: []\n};","/**\n * @import {\n *   Chunk,\n *   Code,\n *   ConstructRecord,\n *   Construct,\n *   Effects,\n *   InitialConstruct,\n *   ParseContext,\n *   Point,\n *   State,\n *   TokenizeContext,\n *   Token\n * } from 'micromark-util-types'\n */\n\n/**\n * @callback Restore\n *   Restore the state.\n * @returns {undefined}\n *   Nothing.\n *\n * @typedef Info\n *   Info.\n * @property {Restore} restore\n *   Restore.\n * @property {number} from\n *   From.\n *\n * @callback ReturnHandle\n *   Handle a successful run.\n * @param {Construct} construct\n *   Construct.\n * @param {Info} info\n *   Info.\n * @returns {undefined}\n *   Nothing.\n */\n\nimport { markdownLineEnding } from 'micromark-util-character';\nimport { push, splice } from 'micromark-util-chunked';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/**\n * Create a tokenizer.\n * Tokenizers deal with one type of data (e.g., containers, flow, text).\n * The parser is the object dealing with it all.\n * `initialize` works like other constructs, except that only its `tokenize`\n * function is used, in which case it doesn’t receive an `ok` or `nok`.\n * `from` can be given to set the point before the first character, although\n * when further lines are indented, they must be set with `defineSkip`.\n *\n * @param {ParseContext} parser\n *   Parser.\n * @param {InitialConstruct} initialize\n *   Construct.\n * @param {Omit<Point, '_bufferIndex' | '_index'> | undefined} [from]\n *   Point (optional).\n * @returns {TokenizeContext}\n *   Context.\n */\nexport function createTokenizer(parser, initialize, from) {\n  /** @type {Point} */\n  let point = {\n    _bufferIndex: -1,\n    _index: 0,\n    line: from && from.line || 1,\n    column: from && from.column || 1,\n    offset: from && from.offset || 0\n  };\n  /** @type {Record<string, number>} */\n  const columnStart = {};\n  /** @type {Array<Construct>} */\n  const resolveAllConstructs = [];\n  /** @type {Array<Chunk>} */\n  let chunks = [];\n  /** @type {Array<Token>} */\n  let stack = [];\n  /** @type {boolean | undefined} */\n  let consumed = true;\n\n  /**\n   * Tools used for tokenizing.\n   *\n   * @type {Effects}\n   */\n  const effects = {\n    attempt: constructFactory(onsuccessfulconstruct),\n    check: constructFactory(onsuccessfulcheck),\n    consume,\n    enter,\n    exit,\n    interrupt: constructFactory(onsuccessfulcheck, {\n      interrupt: true\n    })\n  };\n\n  /**\n   * State and tools for resolving and serializing.\n   *\n   * @type {TokenizeContext}\n   */\n  const context = {\n    code: null,\n    containerState: {},\n    defineSkip,\n    events: [],\n    now,\n    parser,\n    previous: null,\n    sliceSerialize,\n    sliceStream,\n    write\n  };\n\n  /**\n   * The state function.\n   *\n   * @type {State | undefined}\n   */\n  let state = initialize.tokenize.call(context, effects);\n\n  /**\n   * Track which character we expect to be consumed, to catch bugs.\n   *\n   * @type {Code}\n   */\n  let expectedCode;\n  if (initialize.resolveAll) {\n    resolveAllConstructs.push(initialize);\n  }\n  return context;\n\n  /** @type {TokenizeContext['write']} */\n  function write(slice) {\n    chunks = push(chunks, slice);\n    main();\n\n    // Exit if we’re not done, resolve might change stuff.\n    if (chunks[chunks.length - 1] !== null) {\n      return [];\n    }\n    addResult(initialize, 0);\n\n    // Otherwise, resolve, and exit.\n    context.events = resolveAll(resolveAllConstructs, context.events, context);\n    return context.events;\n  }\n\n  //\n  // Tools.\n  //\n\n  /** @type {TokenizeContext['sliceSerialize']} */\n  function sliceSerialize(token, expandTabs) {\n    return serializeChunks(sliceStream(token), expandTabs);\n  }\n\n  /** @type {TokenizeContext['sliceStream']} */\n  function sliceStream(token) {\n    return sliceChunks(chunks, token);\n  }\n\n  /** @type {TokenizeContext['now']} */\n  function now() {\n    // This is a hot path, so we clone manually instead of `Object.assign({}, point)`\n    const {\n      _bufferIndex,\n      _index,\n      line,\n      column,\n      offset\n    } = point;\n    return {\n      _bufferIndex,\n      _index,\n      line,\n      column,\n      offset\n    };\n  }\n\n  /** @type {TokenizeContext['defineSkip']} */\n  function defineSkip(value) {\n    columnStart[value.line] = value.column;\n    accountForPotentialSkip();\n  }\n\n  //\n  // State management.\n  //\n\n  /**\n   * Main loop (note that `_index` and `_bufferIndex` in `point` are modified by\n   * `consume`).\n   * Here is where we walk through the chunks, which either include strings of\n   * several characters, or numerical character codes.\n   * The reason to do this in a loop instead of a call is so the stack can\n   * drain.\n   *\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function main() {\n    /** @type {number} */\n    let chunkIndex;\n    while (point._index < chunks.length) {\n      const chunk = chunks[point._index];\n\n      // If we’re in a buffer chunk, loop through it.\n      if (typeof chunk === 'string') {\n        chunkIndex = point._index;\n        if (point._bufferIndex < 0) {\n          point._bufferIndex = 0;\n        }\n        while (point._index === chunkIndex && point._bufferIndex < chunk.length) {\n          go(chunk.charCodeAt(point._bufferIndex));\n        }\n      } else {\n        go(chunk);\n      }\n    }\n  }\n\n  /**\n   * Deal with one code.\n   *\n   * @param {Code} code\n   *   Code.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function go(code) {\n    consumed = undefined;\n    expectedCode = code;\n    state = state(code);\n  }\n\n  /** @type {Effects['consume']} */\n  function consume(code) {\n    if (markdownLineEnding(code)) {\n      point.line++;\n      point.column = 1;\n      point.offset += code === -3 ? 2 : 1;\n      accountForPotentialSkip();\n    } else if (code !== -1) {\n      point.column++;\n      point.offset++;\n    }\n\n    // Not in a string chunk.\n    if (point._bufferIndex < 0) {\n      point._index++;\n    } else {\n      point._bufferIndex++;\n\n      // At end of string chunk.\n      if (point._bufferIndex ===\n      // Points w/ non-negative `_bufferIndex` reference\n      // strings.\n      /** @type {string} */\n      chunks[point._index].length) {\n        point._bufferIndex = -1;\n        point._index++;\n      }\n    }\n\n    // Expose the previous character.\n    context.previous = code;\n\n    // Mark as consumed.\n    consumed = true;\n  }\n\n  /** @type {Effects['enter']} */\n  function enter(type, fields) {\n    /** @type {Token} */\n    // @ts-expect-error Patch instead of assign required fields to help GC.\n    const token = fields || {};\n    token.type = type;\n    token.start = now();\n    context.events.push(['enter', token, context]);\n    stack.push(token);\n    return token;\n  }\n\n  /** @type {Effects['exit']} */\n  function exit(type) {\n    const token = stack.pop();\n    token.end = now();\n    context.events.push(['exit', token, context]);\n    return token;\n  }\n\n  /**\n   * Use results.\n   *\n   * @type {ReturnHandle}\n   */\n  function onsuccessfulconstruct(construct, info) {\n    addResult(construct, info.from);\n  }\n\n  /**\n   * Discard results.\n   *\n   * @type {ReturnHandle}\n   */\n  function onsuccessfulcheck(_, info) {\n    info.restore();\n  }\n\n  /**\n   * Factory to attempt/check/interrupt.\n   *\n   * @param {ReturnHandle} onreturn\n   *   Callback.\n   * @param {{interrupt?: boolean | undefined} | undefined} [fields]\n   *   Fields.\n   */\n  function constructFactory(onreturn, fields) {\n    return hook;\n\n    /**\n     * Handle either an object mapping codes to constructs, a list of\n     * constructs, or a single construct.\n     *\n     * @param {Array<Construct> | ConstructRecord | Construct} constructs\n     *   Constructs.\n     * @param {State} returnState\n     *   State.\n     * @param {State | undefined} [bogusState]\n     *   State.\n     * @returns {State}\n     *   State.\n     */\n    function hook(constructs, returnState, bogusState) {\n      /** @type {ReadonlyArray<Construct>} */\n      let listOfConstructs;\n      /** @type {number} */\n      let constructIndex;\n      /** @type {Construct} */\n      let currentConstruct;\n      /** @type {Info} */\n      let info;\n      return Array.isArray(constructs) ? /* c8 ignore next 1 */\n      handleListOfConstructs(constructs) : 'tokenize' in constructs ?\n      // Looks like a construct.\n      handleListOfConstructs([(/** @type {Construct} */constructs)]) : handleMapOfConstructs(constructs);\n\n      /**\n       * Handle a list of construct.\n       *\n       * @param {ConstructRecord} map\n       *   Constructs.\n       * @returns {State}\n       *   State.\n       */\n      function handleMapOfConstructs(map) {\n        return start;\n\n        /** @type {State} */\n        function start(code) {\n          const left = code !== null && map[code];\n          const all = code !== null && map.null;\n          const list = [\n          // To do: add more extension tests.\n          /* c8 ignore next 2 */\n          ...(Array.isArray(left) ? left : left ? [left] : []), ...(Array.isArray(all) ? all : all ? [all] : [])];\n          return handleListOfConstructs(list)(code);\n        }\n      }\n\n      /**\n       * Handle a list of construct.\n       *\n       * @param {ReadonlyArray<Construct>} list\n       *   Constructs.\n       * @returns {State}\n       *   State.\n       */\n      function handleListOfConstructs(list) {\n        listOfConstructs = list;\n        constructIndex = 0;\n        if (list.length === 0) {\n          return bogusState;\n        }\n        return handleConstruct(list[constructIndex]);\n      }\n\n      /**\n       * Handle a single construct.\n       *\n       * @param {Construct} construct\n       *   Construct.\n       * @returns {State}\n       *   State.\n       */\n      function handleConstruct(construct) {\n        return start;\n\n        /** @type {State} */\n        function start(code) {\n          // To do: not needed to store if there is no bogus state, probably?\n          // Currently doesn’t work because `inspect` in document does a check\n          // w/o a bogus, which doesn’t make sense. But it does seem to help perf\n          // by not storing.\n          info = store();\n          currentConstruct = construct;\n          if (!construct.partial) {\n            context.currentConstruct = construct;\n          }\n\n          // Always populated by defaults.\n\n          if (construct.name && context.parser.constructs.disable.null.includes(construct.name)) {\n            return nok(code);\n          }\n          return construct.tokenize.call(\n          // If we do have fields, create an object w/ `context` as its\n          // prototype.\n          // This allows a “live binding”, which is needed for `interrupt`.\n          fields ? Object.assign(Object.create(context), fields) : context, effects, ok, nok)(code);\n        }\n      }\n\n      /** @type {State} */\n      function ok(code) {\n        consumed = true;\n        onreturn(currentConstruct, info);\n        return returnState;\n      }\n\n      /** @type {State} */\n      function nok(code) {\n        consumed = true;\n        info.restore();\n        if (++constructIndex < listOfConstructs.length) {\n          return handleConstruct(listOfConstructs[constructIndex]);\n        }\n        return bogusState;\n      }\n    }\n  }\n\n  /**\n   * @param {Construct} construct\n   *   Construct.\n   * @param {number} from\n   *   From.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function addResult(construct, from) {\n    if (construct.resolveAll && !resolveAllConstructs.includes(construct)) {\n      resolveAllConstructs.push(construct);\n    }\n    if (construct.resolve) {\n      splice(context.events, from, context.events.length - from, construct.resolve(context.events.slice(from), context));\n    }\n    if (construct.resolveTo) {\n      context.events = construct.resolveTo(context.events, context);\n    }\n  }\n\n  /**\n   * Store state.\n   *\n   * @returns {Info}\n   *   Info.\n   */\n  function store() {\n    const startPoint = now();\n    const startPrevious = context.previous;\n    const startCurrentConstruct = context.currentConstruct;\n    const startEventsIndex = context.events.length;\n    const startStack = Array.from(stack);\n    return {\n      from: startEventsIndex,\n      restore\n    };\n\n    /**\n     * Restore state.\n     *\n     * @returns {undefined}\n     *   Nothing.\n     */\n    function restore() {\n      point = startPoint;\n      context.previous = startPrevious;\n      context.currentConstruct = startCurrentConstruct;\n      context.events.length = startEventsIndex;\n      stack = startStack;\n      accountForPotentialSkip();\n    }\n  }\n\n  /**\n   * Move the current point a bit forward in the line when it’s on a column\n   * skip.\n   *\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function accountForPotentialSkip() {\n    if (point.line in columnStart && point.column < 2) {\n      point.column = columnStart[point.line];\n      point.offset += columnStart[point.line] - 1;\n    }\n  }\n}\n\n/**\n * Get the chunks from a slice of chunks in the range of a token.\n *\n * @param {ReadonlyArray<Chunk>} chunks\n *   Chunks.\n * @param {Pick<Token, 'end' | 'start'>} token\n *   Token.\n * @returns {Array<Chunk>}\n *   Chunks.\n */\nfunction sliceChunks(chunks, token) {\n  const startIndex = token.start._index;\n  const startBufferIndex = token.start._bufferIndex;\n  const endIndex = token.end._index;\n  const endBufferIndex = token.end._bufferIndex;\n  /** @type {Array<Chunk>} */\n  let view;\n  if (startIndex === endIndex) {\n    // @ts-expect-error `_bufferIndex` is used on string chunks.\n    view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)];\n  } else {\n    view = chunks.slice(startIndex, endIndex);\n    if (startBufferIndex > -1) {\n      const head = view[0];\n      if (typeof head === 'string') {\n        view[0] = head.slice(startBufferIndex);\n      } else {\n        view.shift();\n      }\n    }\n    if (endBufferIndex > 0) {\n      // @ts-expect-error `_bufferIndex` is used on string chunks.\n      view.push(chunks[endIndex].slice(0, endBufferIndex));\n    }\n  }\n  return view;\n}\n\n/**\n * Get the string value of a slice of chunks.\n *\n * @param {ReadonlyArray<Chunk>} chunks\n *   Chunks.\n * @param {boolean | undefined} [expandTabs=false]\n *   Whether to expand tabs (default: `false`).\n * @returns {string}\n *   Result.\n */\nfunction serializeChunks(chunks, expandTabs) {\n  let index = -1;\n  /** @type {Array<string>} */\n  const result = [];\n  /** @type {boolean | undefined} */\n  let atTab;\n  while (++index < chunks.length) {\n    const chunk = chunks[index];\n    /** @type {string} */\n    let value;\n    if (typeof chunk === 'string') {\n      value = chunk;\n    } else switch (chunk) {\n      case -5:\n        {\n          value = \"\\r\";\n          break;\n        }\n      case -4:\n        {\n          value = \"\\n\";\n          break;\n        }\n      case -3:\n        {\n          value = \"\\r\" + \"\\n\";\n          break;\n        }\n      case -2:\n        {\n          value = expandTabs ? \" \" : \"\\t\";\n          break;\n        }\n      case -1:\n        {\n          if (!expandTabs && atTab) continue;\n          value = \" \";\n          break;\n        }\n      default:\n        {\n          // Currently only replacement character.\n          value = String.fromCharCode(chunk);\n        }\n    }\n    atTab = chunk === -2;\n    result.push(value);\n  }\n  return result.join('');\n}","/**\n * @import {\n *   Create,\n *   FullNormalizedExtension,\n *   InitialConstruct,\n *   ParseContext,\n *   ParseOptions\n * } from 'micromark-util-types'\n */\n\nimport { combineExtensions } from 'micromark-util-combine-extensions';\nimport { content } from './initialize/content.js';\nimport { document } from './initialize/document.js';\nimport { flow } from './initialize/flow.js';\nimport { string, text } from './initialize/text.js';\nimport * as defaultConstructs from './constructs.js';\nimport { createTokenizer } from './create-tokenizer.js';\n\n/**\n * @param {ParseOptions | null | undefined} [options]\n *   Configuration (optional).\n * @returns {ParseContext}\n *   Parser.\n */\nexport function parse(options) {\n  const settings = options || {};\n  const constructs = /** @type {FullNormalizedExtension} */\n  combineExtensions([defaultConstructs, ...(settings.extensions || [])]);\n\n  /** @type {ParseContext} */\n  const parser = {\n    constructs,\n    content: create(content),\n    defined: [],\n    document: create(document),\n    flow: create(flow),\n    lazy: {},\n    string: create(string),\n    text: create(text)\n  };\n  return parser;\n\n  /**\n   * @param {InitialConstruct} initial\n   *   Construct to start with.\n   * @returns {Create}\n   *   Create a tokenizer.\n   */\n  function create(initial) {\n    return creator;\n    /** @type {Create} */\n    function creator(from) {\n      return createTokenizer(parser, initial, from);\n    }\n  }\n}","/**\n * @import {Chunk, Code, Encoding, Value} from 'micromark-util-types'\n */\n\n/**\n * @callback Preprocessor\n *   Preprocess a value.\n * @param {Value} value\n *   Value.\n * @param {Encoding | null | undefined} [encoding]\n *   Encoding when `value` is a typed array (optional).\n * @param {boolean | null | undefined} [end=false]\n *   Whether this is the last chunk (default: `false`).\n * @returns {Array<Chunk>}\n *   Chunks.\n */\n\nconst search = /[\\0\\t\\n\\r]/g;\n\n/**\n * @returns {Preprocessor}\n *   Preprocess a value.\n */\nexport function preprocess() {\n  let column = 1;\n  let buffer = '';\n  /** @type {boolean | undefined} */\n  let start = true;\n  /** @type {boolean | undefined} */\n  let atCarriageReturn;\n  return preprocessor;\n\n  /** @type {Preprocessor} */\n  // eslint-disable-next-line complexity\n  function preprocessor(value, encoding, end) {\n    /** @type {Array<Chunk>} */\n    const chunks = [];\n    /** @type {RegExpMatchArray | null} */\n    let match;\n    /** @type {number} */\n    let next;\n    /** @type {number} */\n    let startPosition;\n    /** @type {number} */\n    let endPosition;\n    /** @type {Code} */\n    let code;\n    value = buffer + (typeof value === 'string' ? value.toString() : new TextDecoder(encoding || undefined).decode(value));\n    startPosition = 0;\n    buffer = '';\n    if (start) {\n      // To do: `markdown-rs` actually parses BOMs (byte order mark).\n      if (value.charCodeAt(0) === 65279) {\n        startPosition++;\n      }\n      start = undefined;\n    }\n    while (startPosition < value.length) {\n      search.lastIndex = startPosition;\n      match = search.exec(value);\n      endPosition = match && match.index !== undefined ? match.index : value.length;\n      code = value.charCodeAt(endPosition);\n      if (!match) {\n        buffer = value.slice(startPosition);\n        break;\n      }\n      if (code === 10 && startPosition === endPosition && atCarriageReturn) {\n        chunks.push(-3);\n        atCarriageReturn = undefined;\n      } else {\n        if (atCarriageReturn) {\n          chunks.push(-5);\n          atCarriageReturn = undefined;\n        }\n        if (startPosition < endPosition) {\n          chunks.push(value.slice(startPosition, endPosition));\n          column += endPosition - startPosition;\n        }\n        switch (code) {\n          case 0:\n            {\n              chunks.push(65533);\n              column++;\n              break;\n            }\n          case 9:\n            {\n              next = Math.ceil(column / 4) * 4;\n              chunks.push(-2);\n              while (column++ < next) chunks.push(-1);\n              break;\n            }\n          case 10:\n            {\n              chunks.push(-4);\n              column = 1;\n              break;\n            }\n          default:\n            {\n              atCarriageReturn = true;\n              column = 1;\n            }\n        }\n      }\n      startPosition = endPosition + 1;\n    }\n    if (end) {\n      if (atCarriageReturn) chunks.push(-5);\n      if (buffer) chunks.push(buffer);\n      chunks.push(null);\n    }\n    return chunks;\n  }\n}","/**\n * Turn the number (in string form as either hexa- or plain decimal) coming from\n * a numeric character reference into a character.\n *\n * Sort of like `String.fromCodePoint(Number.parseInt(value, base))`, but makes\n * non-characters and control characters safe.\n *\n * @param {string} value\n *   Value to decode.\n * @param {number} base\n *   Numeric base.\n * @returns {string}\n *   Character.\n */\nexport function decodeNumericCharacterReference(value, base) {\n  const code = Number.parseInt(value, base);\n  if (\n  // C0 except for HT, LF, FF, CR, space.\n  code < 9 || code === 11 || code > 13 && code < 32 ||\n  // Control character (DEL) of C0, and C1 controls.\n  code > 126 && code < 160 ||\n  // Lone high surrogates and low surrogates.\n  code > 55_295 && code < 57_344 ||\n  // Noncharacters.\n  code > 64_975 && code < 65_008 || /* eslint-disable no-bitwise */\n  (code & 65_535) === 65_535 || (code & 65_535) === 65_534 || /* eslint-enable no-bitwise */\n  // Out of range\n  code > 1_114_111) {\n    return \"\\uFFFD\";\n  }\n  return String.fromCodePoint(code);\n}","import { decodeNamedCharacterReference } from 'decode-named-character-reference';\nimport { decodeNumericCharacterReference } from 'micromark-util-decode-numeric-character-reference';\nconst characterEscapeOrReference = /\\\\([!-/:-@[-`{-~])|&(#(?:\\d{1,7}|x[\\da-f]{1,6})|[\\da-z]{1,31});/gi;\n\n/**\n * Decode markdown strings (which occur in places such as fenced code info\n * strings, destinations, labels, and titles).\n *\n * The “string” content type allows character escapes and -references.\n * This decodes those.\n *\n * @param {string} value\n *   Value to decode.\n * @returns {string}\n *   Decoded value.\n */\nexport function decodeString(value) {\n  return value.replace(characterEscapeOrReference, decode);\n}\n\n/**\n * @param {string} $0\n *   Match.\n * @param {string} $1\n *   Character escape.\n * @param {string} $2\n *   Character reference.\n * @returns {string}\n *   Decoded value\n */\nfunction decode($0, $1, $2) {\n  if ($1) {\n    // Escape.\n    return $1;\n  }\n\n  // Reference.\n  const head = $2.charCodeAt(0);\n  if (head === 35) {\n    const head = $2.charCodeAt(1);\n    const hex = head === 120 || head === 88;\n    return decodeNumericCharacterReference($2.slice(hex ? 2 : 1), hex ? 16 : 10);\n  }\n  return decodeNamedCharacterReference($2) || $0;\n}","/**\n * @import {\n *   Break,\n *   Blockquote,\n *   Code,\n *   Definition,\n *   Emphasis,\n *   Heading,\n *   Html,\n *   Image,\n *   InlineCode,\n *   Link,\n *   ListItem,\n *   List,\n *   Nodes,\n *   Paragraph,\n *   PhrasingContent,\n *   ReferenceType,\n *   Root,\n *   Strong,\n *   Text,\n *   ThematicBreak\n * } from 'mdast'\n * @import {\n *   Encoding,\n *   Event,\n *   Token,\n *   Value\n * } from 'micromark-util-types'\n * @import {Point} from 'unist'\n * @import {\n *   CompileContext,\n *   CompileData,\n *   Config,\n *   Extension,\n *   Handle,\n *   OnEnterError,\n *   Options\n * } from './types.js'\n */\n\nimport { toString } from 'mdast-util-to-string';\nimport { parse, postprocess, preprocess } from 'micromark';\nimport { decodeNumericCharacterReference } from 'micromark-util-decode-numeric-character-reference';\nimport { decodeString } from 'micromark-util-decode-string';\nimport { normalizeIdentifier } from 'micromark-util-normalize-identifier';\nimport { decodeNamedCharacterReference } from 'decode-named-character-reference';\nimport { stringifyPosition } from 'unist-util-stringify-position';\nconst own = {}.hasOwnProperty;\n\n/**\n * Turn markdown into a syntax tree.\n *\n * @overload\n * @param {Value} value\n * @param {Encoding | null | undefined} [encoding]\n * @param {Options | null | undefined} [options]\n * @returns {Root}\n *\n * @overload\n * @param {Value} value\n * @param {Options | null | undefined} [options]\n * @returns {Root}\n *\n * @param {Value} value\n *   Markdown to parse.\n * @param {Encoding | Options | null | undefined} [encoding]\n *   Character encoding for when `value` is `Buffer`.\n * @param {Options | null | undefined} [options]\n *   Configuration.\n * @returns {Root}\n *   mdast tree.\n */\nexport function fromMarkdown(value, encoding, options) {\n  if (typeof encoding !== 'string') {\n    options = encoding;\n    encoding = undefined;\n  }\n  return compiler(options)(postprocess(parse(options).document().write(preprocess()(value, encoding, true))));\n}\n\n/**\n * Note this compiler only understand complete buffering, not streaming.\n *\n * @param {Options | null | undefined} [options]\n */\nfunction compiler(options) {\n  /** @type {Config} */\n  const config = {\n    transforms: [],\n    canContainEols: ['emphasis', 'fragment', 'heading', 'paragraph', 'strong'],\n    enter: {\n      autolink: opener(link),\n      autolinkProtocol: onenterdata,\n      autolinkEmail: onenterdata,\n      atxHeading: opener(heading),\n      blockQuote: opener(blockQuote),\n      characterEscape: onenterdata,\n      characterReference: onenterdata,\n      codeFenced: opener(codeFlow),\n      codeFencedFenceInfo: buffer,\n      codeFencedFenceMeta: buffer,\n      codeIndented: opener(codeFlow, buffer),\n      codeText: opener(codeText, buffer),\n      codeTextData: onenterdata,\n      data: onenterdata,\n      codeFlowValue: onenterdata,\n      definition: opener(definition),\n      definitionDestinationString: buffer,\n      definitionLabelString: buffer,\n      definitionTitleString: buffer,\n      emphasis: opener(emphasis),\n      hardBreakEscape: opener(hardBreak),\n      hardBreakTrailing: opener(hardBreak),\n      htmlFlow: opener(html, buffer),\n      htmlFlowData: onenterdata,\n      htmlText: opener(html, buffer),\n      htmlTextData: onenterdata,\n      image: opener(image),\n      label: buffer,\n      link: opener(link),\n      listItem: opener(listItem),\n      listItemValue: onenterlistitemvalue,\n      listOrdered: opener(list, onenterlistordered),\n      listUnordered: opener(list),\n      paragraph: opener(paragraph),\n      reference: onenterreference,\n      referenceString: buffer,\n      resourceDestinationString: buffer,\n      resourceTitleString: buffer,\n      setextHeading: opener(heading),\n      strong: opener(strong),\n      thematicBreak: opener(thematicBreak)\n    },\n    exit: {\n      atxHeading: closer(),\n      atxHeadingSequence: onexitatxheadingsequence,\n      autolink: closer(),\n      autolinkEmail: onexitautolinkemail,\n      autolinkProtocol: onexitautolinkprotocol,\n      blockQuote: closer(),\n      characterEscapeValue: onexitdata,\n      characterReferenceMarkerHexadecimal: onexitcharacterreferencemarker,\n      characterReferenceMarkerNumeric: onexitcharacterreferencemarker,\n      characterReferenceValue: onexitcharacterreferencevalue,\n      characterReference: onexitcharacterreference,\n      codeFenced: closer(onexitcodefenced),\n      codeFencedFence: onexitcodefencedfence,\n      codeFencedFenceInfo: onexitcodefencedfenceinfo,\n      codeFencedFenceMeta: onexitcodefencedfencemeta,\n      codeFlowValue: onexitdata,\n      codeIndented: closer(onexitcodeindented),\n      codeText: closer(onexitcodetext),\n      codeTextData: onexitdata,\n      data: onexitdata,\n      definition: closer(),\n      definitionDestinationString: onexitdefinitiondestinationstring,\n      definitionLabelString: onexitdefinitionlabelstring,\n      definitionTitleString: onexitdefinitiontitlestring,\n      emphasis: closer(),\n      hardBreakEscape: closer(onexithardbreak),\n      hardBreakTrailing: closer(onexithardbreak),\n      htmlFlow: closer(onexithtmlflow),\n      htmlFlowData: onexitdata,\n      htmlText: closer(onexithtmltext),\n      htmlTextData: onexitdata,\n      image: closer(onexitimage),\n      label: onexitlabel,\n      labelText: onexitlabeltext,\n      lineEnding: onexitlineending,\n      link: closer(onexitlink),\n      listItem: closer(),\n      listOrdered: closer(),\n      listUnordered: closer(),\n      paragraph: closer(),\n      referenceString: onexitreferencestring,\n      resourceDestinationString: onexitresourcedestinationstring,\n      resourceTitleString: onexitresourcetitlestring,\n      resource: onexitresource,\n      setextHeading: closer(onexitsetextheading),\n      setextHeadingLineSequence: onexitsetextheadinglinesequence,\n      setextHeadingText: onexitsetextheadingtext,\n      strong: closer(),\n      thematicBreak: closer()\n    }\n  };\n  configure(config, (options || {}).mdastExtensions || []);\n\n  /** @type {CompileData} */\n  const data = {};\n  return compile;\n\n  /**\n   * Turn micromark events into an mdast tree.\n   *\n   * @param {Array<Event>} events\n   *   Events.\n   * @returns {Root}\n   *   mdast tree.\n   */\n  function compile(events) {\n    /** @type {Root} */\n    let tree = {\n      type: 'root',\n      children: []\n    };\n    /** @type {Omit<CompileContext, 'sliceSerialize'>} */\n    const context = {\n      stack: [tree],\n      tokenStack: [],\n      config,\n      enter,\n      exit,\n      buffer,\n      resume,\n      data\n    };\n    /** @type {Array<number>} */\n    const listStack = [];\n    let index = -1;\n    while (++index < events.length) {\n      // We preprocess lists to add `listItem` tokens, and to infer whether\n      // items the list itself are spread out.\n      if (events[index][1].type === \"listOrdered\" || events[index][1].type === \"listUnordered\") {\n        if (events[index][0] === 'enter') {\n          listStack.push(index);\n        } else {\n          const tail = listStack.pop();\n          index = prepareList(events, tail, index);\n        }\n      }\n    }\n    index = -1;\n    while (++index < events.length) {\n      const handler = config[events[index][0]];\n      if (own.call(handler, events[index][1].type)) {\n        handler[events[index][1].type].call(Object.assign({\n          sliceSerialize: events[index][2].sliceSerialize\n        }, context), events[index][1]);\n      }\n    }\n\n    // Handle tokens still being open.\n    if (context.tokenStack.length > 0) {\n      const tail = context.tokenStack[context.tokenStack.length - 1];\n      const handler = tail[1] || defaultOnError;\n      handler.call(context, undefined, tail[0]);\n    }\n\n    // Figure out `root` position.\n    tree.position = {\n      start: point(events.length > 0 ? events[0][1].start : {\n        line: 1,\n        column: 1,\n        offset: 0\n      }),\n      end: point(events.length > 0 ? events[events.length - 2][1].end : {\n        line: 1,\n        column: 1,\n        offset: 0\n      })\n    };\n\n    // Call transforms.\n    index = -1;\n    while (++index < config.transforms.length) {\n      tree = config.transforms[index](tree) || tree;\n    }\n    return tree;\n  }\n\n  /**\n   * @param {Array<Event>} events\n   * @param {number} start\n   * @param {number} length\n   * @returns {number}\n   */\n  function prepareList(events, start, length) {\n    let index = start - 1;\n    let containerBalance = -1;\n    let listSpread = false;\n    /** @type {Token | undefined} */\n    let listItem;\n    /** @type {number | undefined} */\n    let lineIndex;\n    /** @type {number | undefined} */\n    let firstBlankLineIndex;\n    /** @type {boolean | undefined} */\n    let atMarker;\n    while (++index <= length) {\n      const event = events[index];\n      switch (event[1].type) {\n        case \"listUnordered\":\n        case \"listOrdered\":\n        case \"blockQuote\":\n          {\n            if (event[0] === 'enter') {\n              containerBalance++;\n            } else {\n              containerBalance--;\n            }\n            atMarker = undefined;\n            break;\n          }\n        case \"lineEndingBlank\":\n          {\n            if (event[0] === 'enter') {\n              if (listItem && !atMarker && !containerBalance && !firstBlankLineIndex) {\n                firstBlankLineIndex = index;\n              }\n              atMarker = undefined;\n            }\n            break;\n          }\n        case \"linePrefix\":\n        case \"listItemValue\":\n        case \"listItemMarker\":\n        case \"listItemPrefix\":\n        case \"listItemPrefixWhitespace\":\n          {\n            // Empty.\n\n            break;\n          }\n        default:\n          {\n            atMarker = undefined;\n          }\n      }\n      if (!containerBalance && event[0] === 'enter' && event[1].type === \"listItemPrefix\" || containerBalance === -1 && event[0] === 'exit' && (event[1].type === \"listUnordered\" || event[1].type === \"listOrdered\")) {\n        if (listItem) {\n          let tailIndex = index;\n          lineIndex = undefined;\n          while (tailIndex--) {\n            const tailEvent = events[tailIndex];\n            if (tailEvent[1].type === \"lineEnding\" || tailEvent[1].type === \"lineEndingBlank\") {\n              if (tailEvent[0] === 'exit') continue;\n              if (lineIndex) {\n                events[lineIndex][1].type = \"lineEndingBlank\";\n                listSpread = true;\n              }\n              tailEvent[1].type = \"lineEnding\";\n              lineIndex = tailIndex;\n            } else if (tailEvent[1].type === \"linePrefix\" || tailEvent[1].type === \"blockQuotePrefix\" || tailEvent[1].type === \"blockQuotePrefixWhitespace\" || tailEvent[1].type === \"blockQuoteMarker\" || tailEvent[1].type === \"listItemIndent\") {\n              // Empty\n            } else {\n              break;\n            }\n          }\n          if (firstBlankLineIndex && (!lineIndex || firstBlankLineIndex < lineIndex)) {\n            listItem._spread = true;\n          }\n\n          // Fix position.\n          listItem.end = Object.assign({}, lineIndex ? events[lineIndex][1].start : event[1].end);\n          events.splice(lineIndex || index, 0, ['exit', listItem, event[2]]);\n          index++;\n          length++;\n        }\n\n        // Create a new list item.\n        if (event[1].type === \"listItemPrefix\") {\n          /** @type {Token} */\n          const item = {\n            type: 'listItem',\n            _spread: false,\n            start: Object.assign({}, event[1].start),\n            // @ts-expect-error: we’ll add `end` in a second.\n            end: undefined\n          };\n          listItem = item;\n          events.splice(index, 0, ['enter', item, event[2]]);\n          index++;\n          length++;\n          firstBlankLineIndex = undefined;\n          atMarker = true;\n        }\n      }\n    }\n    events[start][1]._spread = listSpread;\n    return length;\n  }\n\n  /**\n   * Create an opener handle.\n   *\n   * @param {(token: Token) => Nodes} create\n   *   Create a node.\n   * @param {Handle | undefined} [and]\n   *   Optional function to also run.\n   * @returns {Handle}\n   *   Handle.\n   */\n  function opener(create, and) {\n    return open;\n\n    /**\n     * @this {CompileContext}\n     * @param {Token} token\n     * @returns {undefined}\n     */\n    function open(token) {\n      enter.call(this, create(token), token);\n      if (and) and.call(this, token);\n    }\n  }\n\n  /**\n   * @type {CompileContext['buffer']}\n   */\n  function buffer() {\n    this.stack.push({\n      type: 'fragment',\n      children: []\n    });\n  }\n\n  /**\n   * @type {CompileContext['enter']}\n   */\n  function enter(node, token, errorHandler) {\n    const parent = this.stack[this.stack.length - 1];\n    /** @type {Array<Nodes>} */\n    const siblings = parent.children;\n    siblings.push(node);\n    this.stack.push(node);\n    this.tokenStack.push([token, errorHandler || undefined]);\n    node.position = {\n      start: point(token.start),\n      // @ts-expect-error: `end` will be patched later.\n      end: undefined\n    };\n  }\n\n  /**\n   * Create a closer handle.\n   *\n   * @param {Handle | undefined} [and]\n   *   Optional function to also run.\n   * @returns {Handle}\n   *   Handle.\n   */\n  function closer(and) {\n    return close;\n\n    /**\n     * @this {CompileContext}\n     * @param {Token} token\n     * @returns {undefined}\n     */\n    function close(token) {\n      if (and) and.call(this, token);\n      exit.call(this, token);\n    }\n  }\n\n  /**\n   * @type {CompileContext['exit']}\n   */\n  function exit(token, onExitError) {\n    const node = this.stack.pop();\n    const open = this.tokenStack.pop();\n    if (!open) {\n      throw new Error('Cannot close `' + token.type + '` (' + stringifyPosition({\n        start: token.start,\n        end: token.end\n      }) + '): it’s not open');\n    } else if (open[0].type !== token.type) {\n      if (onExitError) {\n        onExitError.call(this, token, open[0]);\n      } else {\n        const handler = open[1] || defaultOnError;\n        handler.call(this, token, open[0]);\n      }\n    }\n    node.position.end = point(token.end);\n  }\n\n  /**\n   * @type {CompileContext['resume']}\n   */\n  function resume() {\n    return toString(this.stack.pop());\n  }\n\n  //\n  // Handlers.\n  //\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onenterlistordered() {\n    this.data.expectingFirstListItemValue = true;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onenterlistitemvalue(token) {\n    if (this.data.expectingFirstListItemValue) {\n      const ancestor = this.stack[this.stack.length - 2];\n      ancestor.start = Number.parseInt(this.sliceSerialize(token), 10);\n      this.data.expectingFirstListItemValue = undefined;\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefencedfenceinfo() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.lang = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefencedfencemeta() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.meta = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefencedfence() {\n    // Exit if this is the closing fence.\n    if (this.data.flowCodeInside) return;\n    this.buffer();\n    this.data.flowCodeInside = true;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefenced() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data.replace(/^(\\r?\\n|\\r)|(\\r?\\n|\\r)$/g, '');\n    this.data.flowCodeInside = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodeindented() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data.replace(/(\\r?\\n|\\r)$/g, '');\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitdefinitionlabelstring(token) {\n    const label = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.label = label;\n    node.identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitdefinitiontitlestring() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.title = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitdefinitiondestinationstring() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.url = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitatxheadingsequence(token) {\n    const node = this.stack[this.stack.length - 1];\n    if (!node.depth) {\n      const depth = this.sliceSerialize(token).length;\n      node.depth = depth;\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitsetextheadingtext() {\n    this.data.setextHeadingSlurpLineEnding = true;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitsetextheadinglinesequence(token) {\n    const node = this.stack[this.stack.length - 1];\n    node.depth = this.sliceSerialize(token).codePointAt(0) === 61 ? 1 : 2;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitsetextheading() {\n    this.data.setextHeadingSlurpLineEnding = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onenterdata(token) {\n    const node = this.stack[this.stack.length - 1];\n    /** @type {Array<Nodes>} */\n    const siblings = node.children;\n    let tail = siblings[siblings.length - 1];\n    if (!tail || tail.type !== 'text') {\n      // Add a new text node.\n      tail = text();\n      tail.position = {\n        start: point(token.start),\n        // @ts-expect-error: we’ll add `end` later.\n        end: undefined\n      };\n      siblings.push(tail);\n    }\n    this.stack.push(tail);\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitdata(token) {\n    const tail = this.stack.pop();\n    tail.value += this.sliceSerialize(token);\n    tail.position.end = point(token.end);\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlineending(token) {\n    const context = this.stack[this.stack.length - 1];\n    // If we’re at a hard break, include the line ending in there.\n    if (this.data.atHardBreak) {\n      const tail = context.children[context.children.length - 1];\n      tail.position.end = point(token.end);\n      this.data.atHardBreak = undefined;\n      return;\n    }\n    if (!this.data.setextHeadingSlurpLineEnding && config.canContainEols.includes(context.type)) {\n      onenterdata.call(this, token);\n      onexitdata.call(this, token);\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexithardbreak() {\n    this.data.atHardBreak = true;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexithtmlflow() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexithtmltext() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitcodetext() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlink() {\n    const node = this.stack[this.stack.length - 1];\n    // Note: there are also `identifier` and `label` fields on this link node!\n    // These are used / cleaned here.\n\n    // To do: clean.\n    if (this.data.inReference) {\n      /** @type {ReferenceType} */\n      const referenceType = this.data.referenceType || 'shortcut';\n      node.type += 'Reference';\n      // @ts-expect-error: mutate.\n      node.referenceType = referenceType;\n      // @ts-expect-error: mutate.\n      delete node.url;\n      delete node.title;\n    } else {\n      // @ts-expect-error: mutate.\n      delete node.identifier;\n      // @ts-expect-error: mutate.\n      delete node.label;\n    }\n    this.data.referenceType = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitimage() {\n    const node = this.stack[this.stack.length - 1];\n    // Note: there are also `identifier` and `label` fields on this link node!\n    // These are used / cleaned here.\n\n    // To do: clean.\n    if (this.data.inReference) {\n      /** @type {ReferenceType} */\n      const referenceType = this.data.referenceType || 'shortcut';\n      node.type += 'Reference';\n      // @ts-expect-error: mutate.\n      node.referenceType = referenceType;\n      // @ts-expect-error: mutate.\n      delete node.url;\n      delete node.title;\n    } else {\n      // @ts-expect-error: mutate.\n      delete node.identifier;\n      // @ts-expect-error: mutate.\n      delete node.label;\n    }\n    this.data.referenceType = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlabeltext(token) {\n    const string = this.sliceSerialize(token);\n    const ancestor = this.stack[this.stack.length - 2];\n    // @ts-expect-error: stash this on the node, as it might become a reference\n    // later.\n    ancestor.label = decodeString(string);\n    // @ts-expect-error: same as above.\n    ancestor.identifier = normalizeIdentifier(string).toLowerCase();\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlabel() {\n    const fragment = this.stack[this.stack.length - 1];\n    const value = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    // Assume a reference.\n    this.data.inReference = true;\n    if (node.type === 'link') {\n      /** @type {Array<PhrasingContent>} */\n      const children = fragment.children;\n      node.children = children;\n    } else {\n      node.alt = value;\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitresourcedestinationstring() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.url = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitresourcetitlestring() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.title = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitresource() {\n    this.data.inReference = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onenterreference() {\n    this.data.referenceType = 'collapsed';\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitreferencestring(token) {\n    const label = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    // @ts-expect-error: stash this on the node, as it might become a reference\n    // later.\n    node.label = label;\n    // @ts-expect-error: same as above.\n    node.identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();\n    this.data.referenceType = 'full';\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitcharacterreferencemarker(token) {\n    this.data.characterReferenceType = token.type;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcharacterreferencevalue(token) {\n    const data = this.sliceSerialize(token);\n    const type = this.data.characterReferenceType;\n    /** @type {string} */\n    let value;\n    if (type) {\n      value = decodeNumericCharacterReference(data, type === \"characterReferenceMarkerNumeric\" ? 10 : 16);\n      this.data.characterReferenceType = undefined;\n    } else {\n      const result = decodeNamedCharacterReference(data);\n      value = result;\n    }\n    const tail = this.stack[this.stack.length - 1];\n    tail.value += value;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcharacterreference(token) {\n    const tail = this.stack.pop();\n    tail.position.end = point(token.end);\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitautolinkprotocol(token) {\n    onexitdata.call(this, token);\n    const node = this.stack[this.stack.length - 1];\n    node.url = this.sliceSerialize(token);\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitautolinkemail(token) {\n    onexitdata.call(this, token);\n    const node = this.stack[this.stack.length - 1];\n    node.url = 'mailto:' + this.sliceSerialize(token);\n  }\n\n  //\n  // Creaters.\n  //\n\n  /** @returns {Blockquote} */\n  function blockQuote() {\n    return {\n      type: 'blockquote',\n      children: []\n    };\n  }\n\n  /** @returns {Code} */\n  function codeFlow() {\n    return {\n      type: 'code',\n      lang: null,\n      meta: null,\n      value: ''\n    };\n  }\n\n  /** @returns {InlineCode} */\n  function codeText() {\n    return {\n      type: 'inlineCode',\n      value: ''\n    };\n  }\n\n  /** @returns {Definition} */\n  function definition() {\n    return {\n      type: 'definition',\n      identifier: '',\n      label: null,\n      title: null,\n      url: ''\n    };\n  }\n\n  /** @returns {Emphasis} */\n  function emphasis() {\n    return {\n      type: 'emphasis',\n      children: []\n    };\n  }\n\n  /** @returns {Heading} */\n  function heading() {\n    return {\n      type: 'heading',\n      // @ts-expect-error `depth` will be set later.\n      depth: 0,\n      children: []\n    };\n  }\n\n  /** @returns {Break} */\n  function hardBreak() {\n    return {\n      type: 'break'\n    };\n  }\n\n  /** @returns {Html} */\n  function html() {\n    return {\n      type: 'html',\n      value: ''\n    };\n  }\n\n  /** @returns {Image} */\n  function image() {\n    return {\n      type: 'image',\n      title: null,\n      url: '',\n      alt: null\n    };\n  }\n\n  /** @returns {Link} */\n  function link() {\n    return {\n      type: 'link',\n      title: null,\n      url: '',\n      children: []\n    };\n  }\n\n  /**\n   * @param {Token} token\n   * @returns {List}\n   */\n  function list(token) {\n    return {\n      type: 'list',\n      ordered: token.type === 'listOrdered',\n      start: null,\n      spread: token._spread,\n      children: []\n    };\n  }\n\n  /**\n   * @param {Token} token\n   * @returns {ListItem}\n   */\n  function listItem(token) {\n    return {\n      type: 'listItem',\n      spread: token._spread,\n      checked: null,\n      children: []\n    };\n  }\n\n  /** @returns {Paragraph} */\n  function paragraph() {\n    return {\n      type: 'paragraph',\n      children: []\n    };\n  }\n\n  /** @returns {Strong} */\n  function strong() {\n    return {\n      type: 'strong',\n      children: []\n    };\n  }\n\n  /** @returns {Text} */\n  function text() {\n    return {\n      type: 'text',\n      value: ''\n    };\n  }\n\n  /** @returns {ThematicBreak} */\n  function thematicBreak() {\n    return {\n      type: 'thematicBreak'\n    };\n  }\n}\n\n/**\n * Copy a point-like value.\n *\n * @param {Point} d\n *   Point-like value.\n * @returns {Point}\n *   unist point.\n */\nfunction point(d) {\n  return {\n    line: d.line,\n    column: d.column,\n    offset: d.offset\n  };\n}\n\n/**\n * @param {Config} combined\n * @param {Array<Array<Extension> | Extension>} extensions\n * @returns {undefined}\n */\nfunction configure(combined, extensions) {\n  let index = -1;\n  while (++index < extensions.length) {\n    const value = extensions[index];\n    if (Array.isArray(value)) {\n      configure(combined, value);\n    } else {\n      extension(combined, value);\n    }\n  }\n}\n\n/**\n * @param {Config} combined\n * @param {Extension} extension\n * @returns {undefined}\n */\nfunction extension(combined, extension) {\n  /** @type {keyof Extension} */\n  let key;\n  for (key in extension) {\n    if (own.call(extension, key)) {\n      switch (key) {\n        case 'canContainEols':\n          {\n            const right = extension[key];\n            if (right) {\n              combined[key].push(...right);\n            }\n            break;\n          }\n        case 'transforms':\n          {\n            const right = extension[key];\n            if (right) {\n              combined[key].push(...right);\n            }\n            break;\n          }\n        case 'enter':\n        case 'exit':\n          {\n            const right = extension[key];\n            if (right) {\n              Object.assign(combined[key], right);\n            }\n            break;\n          }\n        // No default\n      }\n    }\n  }\n}\n\n/** @type {OnEnterError} */\nfunction defaultOnError(left, right) {\n  if (left) {\n    throw new Error('Cannot close `' + left.type + '` (' + stringifyPosition({\n      start: left.start,\n      end: left.end\n    }) + '): a different token (`' + right.type + '`, ' + stringifyPosition({\n      start: right.start,\n      end: right.end\n    }) + ') is open');\n  } else {\n    throw new Error('Cannot close document, a token (`' + right.type + '`, ' + stringifyPosition({\n      start: right.start,\n      end: right.end\n    }) + ') is still open');\n  }\n}","/**\n * @import {Event} from 'micromark-util-types'\n */\n\nimport { subtokenize } from 'micromark-util-subtokenize';\n\n/**\n * @param {Array<Event>} events\n *   Events.\n * @returns {Array<Event>}\n *   Events.\n */\nexport function postprocess(events) {\n  while (!subtokenize(events)) {\n    // Empty\n  }\n  return events;\n}","/**\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast-util-from-markdown').Options} FromMarkdownOptions\n * @typedef {import('unified').Parser<Root>} Parser\n * @typedef {import('unified').Processor<Root>} Processor\n */\n\n/**\n * @typedef {Omit<FromMarkdownOptions, 'extensions' | 'mdastExtensions'>} Options\n */\n\nimport {fromMarkdown} from 'mdast-util-from-markdown'\n\n/**\n * Aadd support for parsing from markdown.\n *\n * @param {Readonly<Options> | null | undefined} [options]\n *   Configuration (optional).\n * @returns {undefined}\n *   Nothing.\n */\nexport default function remarkParse(options) {\n  /** @type {Processor} */\n  // @ts-expect-error: TS in JSDoc generates wrong types if `this` is typed regularly.\n  const self = this\n\n  self.parser = parser\n\n  /**\n   * @type {Parser}\n   */\n  function parser(doc) {\n    return fromMarkdown(doc, {\n      ...self.data('settings'),\n      ...options,\n      // Note: these options are not in the readme.\n      // The goal is for them to be set by plugins on `data` instead of being\n      // passed by users.\n      extensions: self.data('micromarkExtensions') || [],\n      mdastExtensions: self.data('fromMarkdownExtensions') || []\n    })\n  }\n}\n","export const VOID       = -1;\nexport const PRIMITIVE  = 0;\nexport const ARRAY      = 1;\nexport const OBJECT     = 2;\nexport const DATE       = 3;\nexport const REGEXP     = 4;\nexport const MAP        = 5;\nexport const SET        = 6;\nexport const ERROR      = 7;\nexport const BIGINT     = 8;\n// export const SYMBOL = 9;\n","import {\n  VOID, PRIMITIVE,\n  ARRAY, OBJECT,\n  DATE, REGEXP, MAP, SET,\n  ERROR, BIGINT\n} from './types.js';\n\nconst env = typeof self === 'object' ? self : globalThis;\n\nconst deserializer = ($, _) => {\n  const as = (out, index) => {\n    $.set(index, out);\n    return out;\n  };\n\n  const unpair = index => {\n    if ($.has(index))\n      return $.get(index);\n\n    const [type, value] = _[index];\n    switch (type) {\n      case PRIMITIVE:\n      case VOID:\n        return as(value, index);\n      case ARRAY: {\n        const arr = as([], index);\n        for (const index of value)\n          arr.push(unpair(index));\n        return arr;\n      }\n      case OBJECT: {\n        const object = as({}, index);\n        for (const [key, index] of value)\n          object[unpair(key)] = unpair(index);\n        return object;\n      }\n      case DATE:\n        return as(new Date(value), index);\n      case REGEXP: {\n        const {source, flags} = value;\n        return as(new RegExp(source, flags), index);\n      }\n      case MAP: {\n        const map = as(new Map, index);\n        for (const [key, index] of value)\n          map.set(unpair(key), unpair(index));\n        return map;\n      }\n      case SET: {\n        const set = as(new Set, index);\n        for (const index of value)\n          set.add(unpair(index));\n        return set;\n      }\n      case ERROR: {\n        const {name, message} = value;\n        return as(new env[name](message), index);\n      }\n      case BIGINT:\n        return as(BigInt(value), index);\n      case 'BigInt':\n        return as(Object(BigInt(value)), index);\n    }\n    return as(new env[type](value), index);\n  };\n\n  return unpair;\n};\n\n/**\n * @typedef {Array<string,any>} Record a type representation\n */\n\n/**\n * Returns a deserialized value from a serialized array of Records.\n * @param {Record[]} serialized a previously serialized value.\n * @returns {any}\n */\nexport const deserialize = serialized => deserializer(new Map, serialized)(0);\n","import {\n  VOID, PRIMITIVE,\n  ARRAY, OBJECT,\n  DATE, REGEXP, MAP, SET,\n  ERROR, BIGINT\n} from './types.js';\n\nconst EMPTY = '';\n\nconst {toString} = {};\nconst {keys} = Object;\n\nconst typeOf = value => {\n  const type = typeof value;\n  if (type !== 'object' || !value)\n    return [PRIMITIVE, type];\n\n  const asString = toString.call(value).slice(8, -1);\n  switch (asString) {\n    case 'Array':\n      return [ARRAY, EMPTY];\n    case 'Object':\n      return [OBJECT, EMPTY];\n    case 'Date':\n      return [DATE, EMPTY];\n    case 'RegExp':\n      return [REGEXP, EMPTY];\n    case 'Map':\n      return [MAP, EMPTY];\n    case 'Set':\n      return [SET, EMPTY];\n  }\n\n  if (asString.includes('Array'))\n    return [ARRAY, asString];\n\n  if (asString.includes('Error'))\n    return [ERROR, asString];\n\n  return [OBJECT, asString];\n};\n\nconst shouldSkip = ([TYPE, type]) => (\n  TYPE === PRIMITIVE &&\n  (type === 'function' || type === 'symbol')\n);\n\nconst serializer = (strict, json, $, _) => {\n\n  const as = (out, value) => {\n    const index = _.push(out) - 1;\n    $.set(value, index);\n    return index;\n  };\n\n  const pair = value => {\n    if ($.has(value))\n      return $.get(value);\n\n    let [TYPE, type] = typeOf(value);\n    switch (TYPE) {\n      case PRIMITIVE: {\n        let entry = value;\n        switch (type) {\n          case 'bigint':\n            TYPE = BIGINT;\n            entry = value.toString();\n            break;\n          case 'function':\n          case 'symbol':\n            if (strict)\n              throw new TypeError('unable to serialize ' + type);\n            entry = null;\n            break;\n          case 'undefined':\n            return as([VOID], value);\n        }\n        return as([TYPE, entry], value);\n      }\n      case ARRAY: {\n        if (type)\n          return as([type, [...value]], value);\n  \n        const arr = [];\n        const index = as([TYPE, arr], value);\n        for (const entry of value)\n          arr.push(pair(entry));\n        return index;\n      }\n      case OBJECT: {\n        if (type) {\n          switch (type) {\n            case 'BigInt':\n              return as([type, value.toString()], value);\n            case 'Boolean':\n            case 'Number':\n            case 'String':\n              return as([type, value.valueOf()], value);\n          }\n        }\n\n        if (json && ('toJSON' in value))\n          return pair(value.toJSON());\n\n        const entries = [];\n        const index = as([TYPE, entries], value);\n        for (const key of keys(value)) {\n          if (strict || !shouldSkip(typeOf(value[key])))\n            entries.push([pair(key), pair(value[key])]);\n        }\n        return index;\n      }\n      case DATE:\n        return as([TYPE, value.toISOString()], value);\n      case REGEXP: {\n        const {source, flags} = value;\n        return as([TYPE, {source, flags}], value);\n      }\n      case MAP: {\n        const entries = [];\n        const index = as([TYPE, entries], value);\n        for (const [key, entry] of value) {\n          if (strict || !(shouldSkip(typeOf(key)) || shouldSkip(typeOf(entry))))\n            entries.push([pair(key), pair(entry)]);\n        }\n        return index;\n      }\n      case SET: {\n        const entries = [];\n        const index = as([TYPE, entries], value);\n        for (const entry of value) {\n          if (strict || !shouldSkip(typeOf(entry)))\n            entries.push(pair(entry));\n        }\n        return index;\n      }\n    }\n\n    const {message} = value;\n    return as([TYPE, {name: type, message}], value);\n  };\n\n  return pair;\n};\n\n/**\n * @typedef {Array<string,any>} Record a type representation\n */\n\n/**\n * Returns an array of serialized Records.\n * @param {any} value a serializable value.\n * @param {{json?: boolean, lossy?: boolean}?} options an object with a `lossy` or `json` property that,\n *  if `true`, will not throw errors on incompatible types, and behave more\n *  like JSON stringify would behave. Symbol and Function will be discarded.\n * @returns {Record[]}\n */\n export const serialize = (value, {json, lossy} = {}) => {\n  const _ = [];\n  return serializer(!(json || lossy), !!json, new Map, _)(value), _;\n};\n","import {deserialize} from './deserialize.js';\nimport {serialize} from './serialize.js';\n\n/**\n * @typedef {Array<string,any>} Record a type representation\n */\n\n/**\n * Returns an array of serialized Records.\n * @param {any} any a serializable value.\n * @param {{transfer?: any[], json?: boolean, lossy?: boolean}?} options an object with\n * a transfer option (ignored when polyfilled) and/or non standard fields that\n * fallback to the polyfill if present.\n * @returns {Record[]}\n */\nexport default typeof structuredClone === \"function\" ?\n  /* c8 ignore start */\n  (any, options) => (\n    options && ('json' in options || 'lossy' in options) ?\n      deserialize(serialize(any, options)) : structuredClone(any)\n  ) :\n  (any, options) => deserialize(serialize(any, options));\n  /* c8 ignore stop */\n\nexport {deserialize, serialize};\n","import { asciiAlphanumeric } from 'micromark-util-character';\nimport { encode } from 'micromark-util-encode';\n/**\n * Make a value safe for injection as a URL.\n *\n * This encodes unsafe characters with percent-encoding and skips already\n * encoded sequences (see `normalizeUri`).\n * Further unsafe characters are encoded as character references (see\n * `micromark-util-encode`).\n *\n * A regex of allowed protocols can be given, in which case the URL is\n * sanitized.\n * For example, `/^(https?|ircs?|mailto|xmpp)$/i` can be used for `a[href]`, or\n * `/^https?$/i` for `img[src]` (this is what `github.com` allows).\n * If the URL includes an unknown protocol (one not matched by `protocol`, such\n * as a dangerous example, `javascript:`), the value is ignored.\n *\n * @param {string | null | undefined} url\n *   URI to sanitize.\n * @param {RegExp | null | undefined} [protocol]\n *   Allowed protocols.\n * @returns {string}\n *   Sanitized URI.\n */\nexport function sanitizeUri(url, protocol) {\n  const value = encode(normalizeUri(url || ''));\n  if (!protocol) {\n    return value;\n  }\n  const colon = value.indexOf(':');\n  const questionMark = value.indexOf('?');\n  const numberSign = value.indexOf('#');\n  const slash = value.indexOf('/');\n  if (\n  // If there is no protocol, it’s relative.\n  colon < 0 ||\n  // If the first colon is after a `?`, `#`, or `/`, it’s not a protocol.\n  slash > -1 && colon > slash || questionMark > -1 && colon > questionMark || numberSign > -1 && colon > numberSign ||\n  // It is a protocol, it should be allowed.\n  protocol.test(value.slice(0, colon))) {\n    return value;\n  }\n  return '';\n}\n\n/**\n * Normalize a URL.\n *\n * Encode unsafe characters with percent-encoding, skipping already encoded\n * sequences.\n *\n * @param {string} value\n *   URI to normalize.\n * @returns {string}\n *   Normalized URI.\n */\nexport function normalizeUri(value) {\n  /** @type {Array<string>} */\n  const result = [];\n  let index = -1;\n  let start = 0;\n  let skip = 0;\n  while (++index < value.length) {\n    const code = value.charCodeAt(index);\n    /** @type {string} */\n    let replace = '';\n\n    // A correct percent encoded value.\n    if (code === 37 && asciiAlphanumeric(value.charCodeAt(index + 1)) && asciiAlphanumeric(value.charCodeAt(index + 2))) {\n      skip = 2;\n    }\n    // ASCII.\n    else if (code < 128) {\n      if (!/[!#$&-;=?-Z_a-z~]/.test(String.fromCharCode(code))) {\n        replace = String.fromCharCode(code);\n      }\n    }\n    // Astral.\n    else if (code > 55_295 && code < 57_344) {\n      const next = value.charCodeAt(index + 1);\n\n      // A correct surrogate pair.\n      if (code < 56_320 && next > 56_319 && next < 57_344) {\n        replace = String.fromCharCode(code, next);\n        skip = 1;\n      }\n      // Lone surrogate.\n      else {\n        replace = \"\\uFFFD\";\n      }\n    }\n    // Unicode.\n    else {\n      replace = String.fromCharCode(code);\n    }\n    if (replace) {\n      result.push(value.slice(start, index), encodeURIComponent(replace));\n      start = index + skip + 1;\n      replace = '';\n    }\n    if (skip) {\n      index += skip;\n      skip = 0;\n    }\n  }\n  return result.join('') + value.slice(start);\n}","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n *\n * @typedef {import('./state.js').State} State\n */\n\n/**\n * @callback FootnoteBackContentTemplate\n *   Generate content for the backreference dynamically.\n *\n *   For the following markdown:\n *\n *   ```markdown\n *   Alpha[^micromark], bravo[^micromark], and charlie[^remark].\n *\n *   [^remark]: things about remark\n *   [^micromark]: things about micromark\n *   ```\n *\n *   This function will be called with:\n *\n *   *  `0` and `0` for the backreference from `things about micromark` to\n *      `alpha`, as it is the first used definition, and the first call to it\n *   *  `0` and `1` for the backreference from `things about micromark` to\n *      `bravo`, as it is the first used definition, and the second call to it\n *   *  `1` and `0` for the backreference from `things about remark` to\n *      `charlie`, as it is the second used definition\n * @param {number} referenceIndex\n *   Index of the definition in the order that they are first referenced,\n *   0-indexed.\n * @param {number} rereferenceIndex\n *   Index of calls to the same definition, 0-indexed.\n * @returns {Array<ElementContent> | ElementContent | string}\n *   Content for the backreference when linking back from definitions to their\n *   reference.\n *\n * @callback FootnoteBackLabelTemplate\n *   Generate a back label dynamically.\n *\n *   For the following markdown:\n *\n *   ```markdown\n *   Alpha[^micromark], bravo[^micromark], and charlie[^remark].\n *\n *   [^remark]: things about remark\n *   [^micromark]: things about micromark\n *   ```\n *\n *   This function will be called with:\n *\n *   *  `0` and `0` for the backreference from `things about micromark` to\n *      `alpha`, as it is the first used definition, and the first call to it\n *   *  `0` and `1` for the backreference from `things about micromark` to\n *      `bravo`, as it is the first used definition, and the second call to it\n *   *  `1` and `0` for the backreference from `things about remark` to\n *      `charlie`, as it is the second used definition\n * @param {number} referenceIndex\n *   Index of the definition in the order that they are first referenced,\n *   0-indexed.\n * @param {number} rereferenceIndex\n *   Index of calls to the same definition, 0-indexed.\n * @returns {string}\n *   Back label to use when linking back from definitions to their reference.\n */\n\nimport structuredClone from '@ungap/structured-clone'\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * Generate the default content that GitHub uses on backreferences.\n *\n * @param {number} _\n *   Index of the definition in the order that they are first referenced,\n *   0-indexed.\n * @param {number} rereferenceIndex\n *   Index of calls to the same definition, 0-indexed.\n * @returns {Array<ElementContent>}\n *   Content.\n */\nexport function defaultFootnoteBackContent(_, rereferenceIndex) {\n  /** @type {Array<ElementContent>} */\n  const result = [{type: 'text', value: '↩'}]\n\n  if (rereferenceIndex > 1) {\n    result.push({\n      type: 'element',\n      tagName: 'sup',\n      properties: {},\n      children: [{type: 'text', value: String(rereferenceIndex)}]\n    })\n  }\n\n  return result\n}\n\n/**\n * Generate the default label that GitHub uses on backreferences.\n *\n * @param {number} referenceIndex\n *   Index of the definition in the order that they are first referenced,\n *   0-indexed.\n * @param {number} rereferenceIndex\n *   Index of calls to the same definition, 0-indexed.\n * @returns {string}\n *   Label.\n */\nexport function defaultFootnoteBackLabel(referenceIndex, rereferenceIndex) {\n  return (\n    'Back to reference ' +\n    (referenceIndex + 1) +\n    (rereferenceIndex > 1 ? '-' + rereferenceIndex : '')\n  )\n}\n\n/**\n * Generate a hast footer for called footnote definitions.\n *\n * @param {State} state\n *   Info passed around.\n * @returns {Element | undefined}\n *   `section` element or `undefined`.\n */\n// eslint-disable-next-line complexity\nexport function footer(state) {\n  const clobberPrefix =\n    typeof state.options.clobberPrefix === 'string'\n      ? state.options.clobberPrefix\n      : 'user-content-'\n  const footnoteBackContent =\n    state.options.footnoteBackContent || defaultFootnoteBackContent\n  const footnoteBackLabel =\n    state.options.footnoteBackLabel || defaultFootnoteBackLabel\n  const footnoteLabel = state.options.footnoteLabel || 'Footnotes'\n  const footnoteLabelTagName = state.options.footnoteLabelTagName || 'h2'\n  const footnoteLabelProperties = state.options.footnoteLabelProperties || {\n    className: ['sr-only']\n  }\n  /** @type {Array<ElementContent>} */\n  const listItems = []\n  let referenceIndex = -1\n\n  while (++referenceIndex < state.footnoteOrder.length) {\n    const definition = state.footnoteById.get(\n      state.footnoteOrder[referenceIndex]\n    )\n\n    if (!definition) {\n      continue\n    }\n\n    const content = state.all(definition)\n    const id = String(definition.identifier).toUpperCase()\n    const safeId = normalizeUri(id.toLowerCase())\n    let rereferenceIndex = 0\n    /** @type {Array<ElementContent>} */\n    const backReferences = []\n    const counts = state.footnoteCounts.get(id)\n\n    // eslint-disable-next-line no-unmodified-loop-condition\n    while (counts !== undefined && ++rereferenceIndex <= counts) {\n      if (backReferences.length > 0) {\n        backReferences.push({type: 'text', value: ' '})\n      }\n\n      let children =\n        typeof footnoteBackContent === 'string'\n          ? footnoteBackContent\n          : footnoteBackContent(referenceIndex, rereferenceIndex)\n\n      if (typeof children === 'string') {\n        children = {type: 'text', value: children}\n      }\n\n      backReferences.push({\n        type: 'element',\n        tagName: 'a',\n        properties: {\n          href:\n            '#' +\n            clobberPrefix +\n            'fnref-' +\n            safeId +\n            (rereferenceIndex > 1 ? '-' + rereferenceIndex : ''),\n          dataFootnoteBackref: '',\n          ariaLabel:\n            typeof footnoteBackLabel === 'string'\n              ? footnoteBackLabel\n              : footnoteBackLabel(referenceIndex, rereferenceIndex),\n          className: ['data-footnote-backref']\n        },\n        children: Array.isArray(children) ? children : [children]\n      })\n    }\n\n    const tail = content[content.length - 1]\n\n    if (tail && tail.type === 'element' && tail.tagName === 'p') {\n      const tailTail = tail.children[tail.children.length - 1]\n      if (tailTail && tailTail.type === 'text') {\n        tailTail.value += ' '\n      } else {\n        tail.children.push({type: 'text', value: ' '})\n      }\n\n      tail.children.push(...backReferences)\n    } else {\n      content.push(...backReferences)\n    }\n\n    /** @type {Element} */\n    const listItem = {\n      type: 'element',\n      tagName: 'li',\n      properties: {id: clobberPrefix + 'fn-' + safeId},\n      children: state.wrap(content, true)\n    }\n\n    state.patch(definition, listItem)\n\n    listItems.push(listItem)\n  }\n\n  if (listItems.length === 0) {\n    return\n  }\n\n  return {\n    type: 'element',\n    tagName: 'section',\n    properties: {dataFootnotes: true, className: ['footnotes']},\n    children: [\n      {\n        type: 'element',\n        tagName: footnoteLabelTagName,\n        properties: {\n          ...structuredClone(footnoteLabelProperties),\n          id: 'footnote-label'\n        },\n        children: [{type: 'text', value: footnoteLabel}]\n      },\n      {type: 'text', value: '\\n'},\n      {\n        type: 'element',\n        tagName: 'ol',\n        properties: {},\n        children: state.wrap(listItems, true)\n      },\n      {type: 'text', value: '\\n'}\n    ]\n  }\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n */\n\n/**\n * @template Fn\n * @template Fallback\n * @typedef {Fn extends (value: any) => value is infer Thing ? Thing : Fallback} Predicate\n */\n\n/**\n * @callback Check\n *   Check that an arbitrary value is a node.\n * @param {unknown} this\n *   The given context.\n * @param {unknown} [node]\n *   Anything (typically a node).\n * @param {number | null | undefined} [index]\n *   The node’s position in its parent.\n * @param {Parent | null | undefined} [parent]\n *   The node’s parent.\n * @returns {boolean}\n *   Whether this is a node and passes a test.\n *\n * @typedef {Record<string, unknown> | Node} Props\n *   Object to check for equivalence.\n *\n *   Note: `Node` is included as it is common but is not indexable.\n *\n * @typedef {Array<Props | TestFunction | string> | Props | TestFunction | string | null | undefined} Test\n *   Check for an arbitrary node.\n *\n * @callback TestFunction\n *   Check if a node passes a test.\n * @param {unknown} this\n *   The given context.\n * @param {Node} node\n *   A node.\n * @param {number | undefined} [index]\n *   The node’s position in its parent.\n * @param {Parent | undefined} [parent]\n *   The node’s parent.\n * @returns {boolean | undefined | void}\n *   Whether this node passes the test.\n *\n *   Note: `void` is included until TS sees no return as `undefined`.\n */\n\n/**\n * Check if `node` is a `Node` and whether it passes the given test.\n *\n * @param {unknown} node\n *   Thing to check, typically `Node`.\n * @param {Test} test\n *   A check for a specific node.\n * @param {number | null | undefined} index\n *   The node’s position in its parent.\n * @param {Parent | null | undefined} parent\n *   The node’s parent.\n * @param {unknown} context\n *   Context object (`this`) to pass to `test` functions.\n * @returns {boolean}\n *   Whether `node` is a node and passes a test.\n */\nexport const is =\n  // Note: overloads in JSDoc can’t yet use different `@template`s.\n  /**\n   * @type {(\n   *   (<Condition extends string>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition}) &\n   *   (<Condition extends Props>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Condition) &\n   *   (<Condition extends TestFunction>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Predicate<Condition, Node>) &\n   *   ((node?: null | undefined) => false) &\n   *   ((node: unknown, test?: null | undefined, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node) &\n   *   ((node: unknown, test?: Test, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => boolean)\n   * )}\n   */\n  (\n    /**\n     * @param {unknown} [node]\n     * @param {Test} [test]\n     * @param {number | null | undefined} [index]\n     * @param {Parent | null | undefined} [parent]\n     * @param {unknown} [context]\n     * @returns {boolean}\n     */\n    // eslint-disable-next-line max-params\n    function (node, test, index, parent, context) {\n      const check = convert(test)\n\n      if (\n        index !== undefined &&\n        index !== null &&\n        (typeof index !== 'number' ||\n          index < 0 ||\n          index === Number.POSITIVE_INFINITY)\n      ) {\n        throw new Error('Expected positive finite index')\n      }\n\n      if (\n        parent !== undefined &&\n        parent !== null &&\n        (!is(parent) || !parent.children)\n      ) {\n        throw new Error('Expected parent node')\n      }\n\n      if (\n        (parent === undefined || parent === null) !==\n        (index === undefined || index === null)\n      ) {\n        throw new Error('Expected both parent and index')\n      }\n\n      return looksLikeANode(node)\n        ? check.call(context, node, index, parent)\n        : false\n    }\n  )\n\n/**\n * Generate an assertion from a test.\n *\n * Useful if you’re going to test many nodes, for example when creating a\n * utility where something else passes a compatible test.\n *\n * The created function is a bit faster because it expects valid input only:\n * a `node`, `index`, and `parent`.\n *\n * @param {Test} test\n *   *   when nullish, checks if `node` is a `Node`.\n *   *   when `string`, works like passing `(node) => node.type === test`.\n *   *   when `function` checks if function passed the node is true.\n *   *   when `object`, checks that all keys in test are in node, and that they have (strictly) equal values.\n *   *   when `array`, checks if any one of the subtests pass.\n * @returns {Check}\n *   An assertion.\n */\nexport const convert =\n  // Note: overloads in JSDoc can’t yet use different `@template`s.\n  /**\n   * @type {(\n   *   (<Condition extends string>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition}) &\n   *   (<Condition extends Props>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Condition) &\n   *   (<Condition extends TestFunction>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Predicate<Condition, Node>) &\n   *   ((test?: null | undefined) => (node?: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node) &\n   *   ((test?: Test) => Check)\n   * )}\n   */\n  (\n    /**\n     * @param {Test} [test]\n     * @returns {Check}\n     */\n    function (test) {\n      if (test === null || test === undefined) {\n        return ok\n      }\n\n      if (typeof test === 'function') {\n        return castFactory(test)\n      }\n\n      if (typeof test === 'object') {\n        return Array.isArray(test) ? anyFactory(test) : propsFactory(test)\n      }\n\n      if (typeof test === 'string') {\n        return typeFactory(test)\n      }\n\n      throw new Error('Expected function, string, or object as test')\n    }\n  )\n\n/**\n * @param {Array<Props | TestFunction | string>} tests\n * @returns {Check}\n */\nfunction anyFactory(tests) {\n  /** @type {Array<Check>} */\n  const checks = []\n  let index = -1\n\n  while (++index < tests.length) {\n    checks[index] = convert(tests[index])\n  }\n\n  return castFactory(any)\n\n  /**\n   * @this {unknown}\n   * @type {TestFunction}\n   */\n  function any(...parameters) {\n    let index = -1\n\n    while (++index < checks.length) {\n      if (checks[index].apply(this, parameters)) return true\n    }\n\n    return false\n  }\n}\n\n/**\n * Turn an object into a test for a node with a certain fields.\n *\n * @param {Props} check\n * @returns {Check}\n */\nfunction propsFactory(check) {\n  const checkAsRecord = /** @type {Record<string, unknown>} */ (check)\n\n  return castFactory(all)\n\n  /**\n   * @param {Node} node\n   * @returns {boolean}\n   */\n  function all(node) {\n    const nodeAsRecord = /** @type {Record<string, unknown>} */ (\n      /** @type {unknown} */ (node)\n    )\n\n    /** @type {string} */\n    let key\n\n    for (key in check) {\n      if (nodeAsRecord[key] !== checkAsRecord[key]) return false\n    }\n\n    return true\n  }\n}\n\n/**\n * Turn a string into a test for a node with a certain type.\n *\n * @param {string} check\n * @returns {Check}\n */\nfunction typeFactory(check) {\n  return castFactory(type)\n\n  /**\n   * @param {Node} node\n   */\n  function type(node) {\n    return node && node.type === check\n  }\n}\n\n/**\n * Turn a custom test into a test for a node that passes that test.\n *\n * @param {TestFunction} testFunction\n * @returns {Check}\n */\nfunction castFactory(testFunction) {\n  return check\n\n  /**\n   * @this {unknown}\n   * @type {Check}\n   */\n  function check(value, index, parent) {\n    return Boolean(\n      looksLikeANode(value) &&\n        testFunction.call(\n          this,\n          value,\n          typeof index === 'number' ? index : undefined,\n          parent || undefined\n        )\n    )\n  }\n}\n\nfunction ok() {\n  return true\n}\n\n/**\n * @param {unknown} value\n * @returns {value is Node}\n */\nfunction looksLikeANode(value) {\n  return value !== null && typeof value === 'object' && 'type' in value\n}\n","/**\n * @typedef {import('unist').Node} UnistNode\n * @typedef {import('unist').Parent} UnistParent\n */\n\n/**\n * @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test\n *   Test from `unist-util-is`.\n *\n *   Note: we have remove and add `undefined`, because otherwise when generating\n *   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,\n *   which doesn’t work when publishing on npm.\n */\n\n/**\n * @typedef {(\n *   Fn extends (value: any) => value is infer Thing\n *   ? Thing\n *   : Fallback\n * )} Predicate\n *   Get the value of a type guard `Fn`.\n * @template Fn\n *   Value; typically function that is a type guard (such as `(x): x is Y`).\n * @template Fallback\n *   Value to yield if `Fn` is not a type guard.\n */\n\n/**\n * @typedef {(\n *   Check extends null | undefined // No test.\n *   ? Value\n *   : Value extends {type: Check} // String (type) test.\n *   ? Value\n *   : Value extends Check // Partial test.\n *   ? Value\n *   : Check extends Function // Function test.\n *   ? Predicate<Check, Value> extends Value\n *     ? Predicate<Check, Value>\n *     : never\n *   : never // Some other test?\n * )} MatchesOne\n *   Check whether a node matches a primitive check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test, but not arrays.\n */\n\n/**\n * @typedef {(\n *   Check extends Array<any>\n *   ? MatchesOne<Value, Check[keyof Check]>\n *   : MatchesOne<Value, Check>\n * )} Matches\n *   Check whether a node matches a check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test.\n */\n\n/**\n * @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint\n *   Number; capped reasonably.\n */\n\n/**\n * @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment\n *   Increment a number in the type system.\n * @template {Uint} [I=0]\n *   Index.\n */\n\n/**\n * @typedef {(\n *   Node extends UnistParent\n *   ? Node extends {children: Array<infer Children>}\n *     ? Child extends Children ? Node : never\n *     : never\n *   : never\n * )} InternalParent\n *   Collect nodes that can be parents of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {InternalParent<InclusiveDescendant<Tree>, Child>} Parent\n *   Collect nodes in `Tree` that can be parents of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Depth extends Max\n *   ? never\n *   :\n *     | InternalParent<Node, Child>\n *     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>\n * )} InternalAncestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {InternalAncestor<InclusiveDescendant<Tree>, Child>} Ancestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Tree extends UnistParent\n *     ? Depth extends Max\n *       ? Tree\n *       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>\n *     : Tree\n * )} InclusiveDescendant\n *   Collect all (inclusive) descendants of `Tree`.\n *\n *   > 👉 **Note**: for performance reasons, this seems to be the fastest way to\n *   > recurse without actually running into an infinite loop, which the\n *   > previous version did.\n *   >\n *   > Practically, a max of `2` is typically enough assuming a `Root` is\n *   > passed, but it doesn’t improve performance.\n *   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.\n *   > Using up to `10` doesn’t hurt or help either.\n * @template {UnistNode} Tree\n *   Tree type.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {'skip' | boolean} Action\n *   Union of the action types.\n *\n * @typedef {number} Index\n *   Move to the sibling at `index` next (after node itself is completely\n *   traversed).\n *\n *   Useful if mutating the tree, such as removing the node the visitor is\n *   currently on, or any of its previous siblings.\n *   Results less than 0 or greater than or equal to `children.length` stop\n *   traversing the parent.\n *\n * @typedef {[(Action | null | undefined | void)?, (Index | null | undefined)?]} ActionTuple\n *   List with one or two values, the first an action, the second an index.\n *\n * @typedef {Action | ActionTuple | Index | null | undefined | void} VisitorResult\n *   Any value that can be returned from a visitor.\n */\n\n/**\n * @callback Visitor\n *   Handle a node (matching `test`, if given).\n *\n *   Visitors are free to transform `node`.\n *   They can also transform the parent of node (the last of `ancestors`).\n *\n *   Replacing `node` itself, if `SKIP` is not returned, still causes its\n *   descendants to be walked (which is a bug).\n *\n *   When adding or removing previous siblings of `node` (or next siblings, in\n *   case of reverse), the `Visitor` should return a new `Index` to specify the\n *   sibling to traverse after `node` is traversed.\n *   Adding or removing next siblings of `node` (or previous siblings, in case\n *   of reverse) is handled as expected without needing to return a new `Index`.\n *\n *   Removing the children property of an ancestor still results in them being\n *   traversed.\n * @param {Visited} node\n *   Found node.\n * @param {Array<VisitedParents>} ancestors\n *   Ancestors of `node`.\n * @returns {VisitorResult}\n *   What to do next.\n *\n *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.\n *   An `Action` is treated as a tuple of `[Action]`.\n *\n *   Passing a tuple back only makes sense if the `Action` is `SKIP`.\n *   When the `Action` is `EXIT`, that action can be returned.\n *   When the `Action` is `CONTINUE`, `Index` can be returned.\n * @template {UnistNode} [Visited=UnistNode]\n *   Visited node type.\n * @template {UnistParent} [VisitedParents=UnistParent]\n *   Ancestor type.\n */\n\n/**\n * @typedef {Visitor<Matches<InclusiveDescendant<Tree>, Check>, Ancestor<Tree, Matches<InclusiveDescendant<Tree>, Check>>>} BuildVisitor\n *   Build a typed `Visitor` function from a tree and a test.\n *\n *   It will infer which values are passed as `node` and which as `parents`.\n * @template {UnistNode} [Tree=UnistNode]\n *   Tree type.\n * @template {Test} [Check=Test]\n *   Test type.\n */\n\nimport {convert} from 'unist-util-is'\nimport {color} from 'unist-util-visit-parents/do-not-use-color'\n\n/** @type {Readonly<ActionTuple>} */\nconst empty = []\n\n/**\n * Continue traversing as normal.\n */\nexport const CONTINUE = true\n\n/**\n * Stop traversing immediately.\n */\nexport const EXIT = false\n\n/**\n * Do not traverse this node’s children.\n */\nexport const SKIP = 'skip'\n\n/**\n * Visit nodes, with ancestral information.\n *\n * This algorithm performs *depth-first* *tree traversal* in *preorder*\n * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).\n *\n * You can choose for which nodes `visitor` is called by passing a `test`.\n * For complex tests, you should test yourself in `visitor`, as it will be\n * faster and will have improved type information.\n *\n * Walking the tree is an intensive task.\n * Make use of the return values of the visitor when possible.\n * Instead of walking a tree multiple times, walk it once, use `unist-util-is`\n * to check if a node matches, and then perform different operations.\n *\n * You can change the tree.\n * See `Visitor` for more info.\n *\n * @overload\n * @param {Tree} tree\n * @param {Check} check\n * @param {BuildVisitor<Tree, Check>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @overload\n * @param {Tree} tree\n * @param {BuildVisitor<Tree>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @param {UnistNode} tree\n *   Tree to traverse.\n * @param {Visitor | Test} test\n *   `unist-util-is`-compatible test\n * @param {Visitor | boolean | null | undefined} [visitor]\n *   Handle each node.\n * @param {boolean | null | undefined} [reverse]\n *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).\n * @returns {undefined}\n *   Nothing.\n *\n * @template {UnistNode} Tree\n *   Node type.\n * @template {Test} Check\n *   `unist-util-is`-compatible test.\n */\nexport function visitParents(tree, test, visitor, reverse) {\n  /** @type {Test} */\n  let check\n\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor\n    // @ts-expect-error no visitor given, so `visitor` is test.\n    visitor = test\n  } else {\n    // @ts-expect-error visitor given, so `test` isn’t a visitor.\n    check = test\n  }\n\n  const is = convert(check)\n  const step = reverse ? -1 : 1\n\n  factory(tree, undefined, [])()\n\n  /**\n   * @param {UnistNode} node\n   * @param {number | undefined} index\n   * @param {Array<UnistParent>} parents\n   */\n  function factory(node, index, parents) {\n    const value = /** @type {Record<string, unknown>} */ (\n      node && typeof node === 'object' ? node : {}\n    )\n\n    if (typeof value.type === 'string') {\n      const name =\n        // `hast`\n        typeof value.tagName === 'string'\n          ? value.tagName\n          : // `xast`\n          typeof value.name === 'string'\n          ? value.name\n          : undefined\n\n      Object.defineProperty(visit, 'name', {\n        value:\n          'node (' + color(node.type + (name ? '<' + name + '>' : '')) + ')'\n      })\n    }\n\n    return visit\n\n    function visit() {\n      /** @type {Readonly<ActionTuple>} */\n      let result = empty\n      /** @type {Readonly<ActionTuple>} */\n      let subresult\n      /** @type {number} */\n      let offset\n      /** @type {Array<UnistParent>} */\n      let grandparents\n\n      if (!test || is(node, index, parents[parents.length - 1] || undefined)) {\n        // @ts-expect-error: `visitor` is now a visitor.\n        result = toResult(visitor(node, parents))\n\n        if (result[0] === EXIT) {\n          return result\n        }\n      }\n\n      if ('children' in node && node.children) {\n        const nodeAsParent = /** @type {UnistParent} */ (node)\n\n        if (nodeAsParent.children && result[0] !== SKIP) {\n          offset = (reverse ? nodeAsParent.children.length : -1) + step\n          grandparents = parents.concat(nodeAsParent)\n\n          while (offset > -1 && offset < nodeAsParent.children.length) {\n            const child = nodeAsParent.children[offset]\n\n            subresult = factory(child, offset, grandparents)()\n\n            if (subresult[0] === EXIT) {\n              return subresult\n            }\n\n            offset =\n              typeof subresult[1] === 'number' ? subresult[1] : offset + step\n          }\n        }\n      }\n\n      return result\n    }\n  }\n}\n\n/**\n * Turn a return value into a clean result.\n *\n * @param {VisitorResult} value\n *   Valid return values from visitors.\n * @returns {Readonly<ActionTuple>}\n *   Clean result.\n */\nfunction toResult(value) {\n  if (Array.isArray(value)) {\n    return value\n  }\n\n  if (typeof value === 'number') {\n    return [CONTINUE, value]\n  }\n\n  return value === null || value === undefined ? empty : [value]\n}\n","/**\n * @typedef {import('unist').Node} UnistNode\n * @typedef {import('unist').Parent} UnistParent\n * @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult\n */\n\n/**\n * @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test\n *   Test from `unist-util-is`.\n *\n *   Note: we have remove and add `undefined`, because otherwise when generating\n *   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,\n *   which doesn’t work when publishing on npm.\n */\n\n// To do: use types from `unist-util-visit-parents` when it’s released.\n\n/**\n * @typedef {(\n *   Fn extends (value: any) => value is infer Thing\n *   ? Thing\n *   : Fallback\n * )} Predicate\n *   Get the value of a type guard `Fn`.\n * @template Fn\n *   Value; typically function that is a type guard (such as `(x): x is Y`).\n * @template Fallback\n *   Value to yield if `Fn` is not a type guard.\n */\n\n/**\n * @typedef {(\n *   Check extends null | undefined // No test.\n *   ? Value\n *   : Value extends {type: Check} // String (type) test.\n *   ? Value\n *   : Value extends Check // Partial test.\n *   ? Value\n *   : Check extends Function // Function test.\n *   ? Predicate<Check, Value> extends Value\n *     ? Predicate<Check, Value>\n *     : never\n *   : never // Some other test?\n * )} MatchesOne\n *   Check whether a node matches a primitive check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test, but not arrays.\n */\n\n/**\n * @typedef {(\n *   Check extends Array<any>\n *   ? MatchesOne<Value, Check[keyof Check]>\n *   : MatchesOne<Value, Check>\n * )} Matches\n *   Check whether a node matches a check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test.\n */\n\n/**\n * @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint\n *   Number; capped reasonably.\n */\n\n/**\n * @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment\n *   Increment a number in the type system.\n * @template {Uint} [I=0]\n *   Index.\n */\n\n/**\n * @typedef {(\n *   Node extends UnistParent\n *   ? Node extends {children: Array<infer Children>}\n *     ? Child extends Children ? Node : never\n *     : never\n *   : never\n * )} InternalParent\n *   Collect nodes that can be parents of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {InternalParent<InclusiveDescendant<Tree>, Child>} Parent\n *   Collect nodes in `Tree` that can be parents of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Depth extends Max\n *   ? never\n *   :\n *     | InternalParent<Node, Child>\n *     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>\n * )} InternalAncestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {(\n *   Tree extends UnistParent\n *     ? Depth extends Max\n *       ? Tree\n *       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>\n *     : Tree\n * )} InclusiveDescendant\n *   Collect all (inclusive) descendants of `Tree`.\n *\n *   > 👉 **Note**: for performance reasons, this seems to be the fastest way to\n *   > recurse without actually running into an infinite loop, which the\n *   > previous version did.\n *   >\n *   > Practically, a max of `2` is typically enough assuming a `Root` is\n *   > passed, but it doesn’t improve performance.\n *   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.\n *   > Using up to `10` doesn’t hurt or help either.\n * @template {UnistNode} Tree\n *   Tree type.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @callback Visitor\n *   Handle a node (matching `test`, if given).\n *\n *   Visitors are free to transform `node`.\n *   They can also transform `parent`.\n *\n *   Replacing `node` itself, if `SKIP` is not returned, still causes its\n *   descendants to be walked (which is a bug).\n *\n *   When adding or removing previous siblings of `node` (or next siblings, in\n *   case of reverse), the `Visitor` should return a new `Index` to specify the\n *   sibling to traverse after `node` is traversed.\n *   Adding or removing next siblings of `node` (or previous siblings, in case\n *   of reverse) is handled as expected without needing to return a new `Index`.\n *\n *   Removing the children property of `parent` still results in them being\n *   traversed.\n * @param {Visited} node\n *   Found node.\n * @param {Visited extends UnistNode ? number | undefined : never} index\n *   Index of `node` in `parent`.\n * @param {Ancestor extends UnistParent ? Ancestor | undefined : never} parent\n *   Parent of `node`.\n * @returns {VisitorResult}\n *   What to do next.\n *\n *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.\n *   An `Action` is treated as a tuple of `[Action]`.\n *\n *   Passing a tuple back only makes sense if the `Action` is `SKIP`.\n *   When the `Action` is `EXIT`, that action can be returned.\n *   When the `Action` is `CONTINUE`, `Index` can be returned.\n * @template {UnistNode} [Visited=UnistNode]\n *   Visited node type.\n * @template {UnistParent} [Ancestor=UnistParent]\n *   Ancestor type.\n */\n\n/**\n * @typedef {Visitor<Visited, Parent<Ancestor, Visited>>} BuildVisitorFromMatch\n *   Build a typed `Visitor` function from a node and all possible parents.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} Visited\n *   Node type.\n * @template {UnistParent} Ancestor\n *   Parent type.\n */\n\n/**\n * @typedef {(\n *   BuildVisitorFromMatch<\n *     Matches<Descendant, Check>,\n *     Extract<Descendant, UnistParent>\n *   >\n * )} BuildVisitorFromDescendants\n *   Build a typed `Visitor` function from a list of descendants and a test.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} Descendant\n *   Node type.\n * @template {Test} Check\n *   Test type.\n */\n\n/**\n * @typedef {(\n *   BuildVisitorFromDescendants<\n *     InclusiveDescendant<Tree>,\n *     Check\n *   >\n * )} BuildVisitor\n *   Build a typed `Visitor` function from a tree and a test.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} [Tree=UnistNode]\n *   Node type.\n * @template {Test} [Check=Test]\n *   Test type.\n */\n\nimport {visitParents} from 'unist-util-visit-parents'\n\nexport {CONTINUE, EXIT, SKIP} from 'unist-util-visit-parents'\n\n/**\n * Visit nodes.\n *\n * This algorithm performs *depth-first* *tree traversal* in *preorder*\n * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).\n *\n * You can choose for which nodes `visitor` is called by passing a `test`.\n * For complex tests, you should test yourself in `visitor`, as it will be\n * faster and will have improved type information.\n *\n * Walking the tree is an intensive task.\n * Make use of the return values of the visitor when possible.\n * Instead of walking a tree multiple times, walk it once, use `unist-util-is`\n * to check if a node matches, and then perform different operations.\n *\n * You can change the tree.\n * See `Visitor` for more info.\n *\n * @overload\n * @param {Tree} tree\n * @param {Check} check\n * @param {BuildVisitor<Tree, Check>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @overload\n * @param {Tree} tree\n * @param {BuildVisitor<Tree>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @param {UnistNode} tree\n *   Tree to traverse.\n * @param {Visitor | Test} testOrVisitor\n *   `unist-util-is`-compatible test (optional, omit to pass a visitor).\n * @param {Visitor | boolean | null | undefined} [visitorOrReverse]\n *   Handle each node (when test is omitted, pass `reverse`).\n * @param {boolean | null | undefined} [maybeReverse=false]\n *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).\n * @returns {undefined}\n *   Nothing.\n *\n * @template {UnistNode} Tree\n *   Node type.\n * @template {Test} Check\n *   `unist-util-is`-compatible test.\n */\nexport function visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) {\n  /** @type {boolean | null | undefined} */\n  let reverse\n  /** @type {Test} */\n  let test\n  /** @type {Visitor} */\n  let visitor\n\n  if (\n    typeof testOrVisitor === 'function' &&\n    typeof visitorOrReverse !== 'function'\n  ) {\n    test = undefined\n    visitor = testOrVisitor\n    reverse = visitorOrReverse\n  } else {\n    // @ts-expect-error: assume the overload with test was given.\n    test = testOrVisitor\n    // @ts-expect-error: assume the overload with test was given.\n    visitor = visitorOrReverse\n    reverse = maybeReverse\n  }\n\n  visitParents(tree, test, overload, reverse)\n\n  /**\n   * @param {UnistNode} node\n   * @param {Array<UnistParent>} parents\n   */\n  function overload(node, parents) {\n    const parent = parents[parents.length - 1]\n    const index = parent ? parent.children.indexOf(node) : undefined\n    return visitor(node, index, parent)\n  }\n}\n","/**\n * @typedef {import('hast').ElementContent} ElementContent\n *\n * @typedef {import('mdast').Nodes} Nodes\n * @typedef {import('mdast').Reference} Reference\n *\n * @typedef {import('./state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Return the content of a reference without definition as plain text.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Extract<Nodes, Reference>} node\n *   Reference node (image, link).\n * @returns {Array<ElementContent>}\n *   hast content.\n */\nexport function revert(state, node) {\n  const subtype = node.referenceType\n  let suffix = ']'\n\n  if (subtype === 'collapsed') {\n    suffix += '[]'\n  } else if (subtype === 'full') {\n    suffix += '[' + (node.label || node.identifier) + ']'\n  }\n\n  if (node.type === 'imageReference') {\n    return [{type: 'text', value: '![' + node.alt + suffix}]\n  }\n\n  const contents = state.all(node)\n  const head = contents[0]\n\n  if (head && head.type === 'text') {\n    head.value = '[' + head.value\n  } else {\n    contents.unshift({type: 'text', value: '['})\n  }\n\n  const tail = contents[contents.length - 1]\n\n  if (tail && tail.type === 'text') {\n    tail.value += suffix\n  } else {\n    contents.push({type: 'text', value: suffix})\n  }\n\n  return contents\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `listItem` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {ListItem} node\n *   mdast node.\n * @param {Parents | undefined} parent\n *   Parent of `node`.\n * @returns {Element}\n *   hast node.\n */\nexport function listItem(state, node, parent) {\n  const results = state.all(node)\n  const loose = parent ? listLoose(parent) : listItemLoose(node)\n  /** @type {Properties} */\n  const properties = {}\n  /** @type {Array<ElementContent>} */\n  const children = []\n\n  if (typeof node.checked === 'boolean') {\n    const head = results[0]\n    /** @type {Element} */\n    let paragraph\n\n    if (head && head.type === 'element' && head.tagName === 'p') {\n      paragraph = head\n    } else {\n      paragraph = {type: 'element', tagName: 'p', properties: {}, children: []}\n      results.unshift(paragraph)\n    }\n\n    if (paragraph.children.length > 0) {\n      paragraph.children.unshift({type: 'text', value: ' '})\n    }\n\n    paragraph.children.unshift({\n      type: 'element',\n      tagName: 'input',\n      properties: {type: 'checkbox', checked: node.checked, disabled: true},\n      children: []\n    })\n\n    // According to github-markdown-css, this class hides bullet.\n    // See: <https://github.com/sindresorhus/github-markdown-css>.\n    properties.className = ['task-list-item']\n  }\n\n  let index = -1\n\n  while (++index < results.length) {\n    const child = results[index]\n\n    // Add eols before nodes, except if this is a loose, first paragraph.\n    if (\n      loose ||\n      index !== 0 ||\n      child.type !== 'element' ||\n      child.tagName !== 'p'\n    ) {\n      children.push({type: 'text', value: '\\n'})\n    }\n\n    if (child.type === 'element' && child.tagName === 'p' && !loose) {\n      children.push(...child.children)\n    } else {\n      children.push(child)\n    }\n  }\n\n  const tail = results[results.length - 1]\n\n  // Add a final eol.\n  if (tail && (loose || tail.type !== 'element' || tail.tagName !== 'p')) {\n    children.push({type: 'text', value: '\\n'})\n  }\n\n  /** @type {Element} */\n  const result = {type: 'element', tagName: 'li', properties, children}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n\n/**\n * @param {Parents} node\n * @return {Boolean}\n */\nfunction listLoose(node) {\n  let loose = false\n  if (node.type === 'list') {\n    loose = node.spread || false\n    const children = node.children\n    let index = -1\n\n    while (!loose && ++index < children.length) {\n      loose = listItemLoose(children[index])\n    }\n  }\n\n  return loose\n}\n\n/**\n * @param {ListItem} node\n * @return {Boolean}\n */\nfunction listItemLoose(node) {\n  const spread = node.spread\n\n  return spread === null || spread === undefined\n    ? node.children.length > 1\n    : spread\n}\n","const tab = 9 /* `\\t` */\nconst space = 32 /* ` ` */\n\n/**\n * Remove initial and final spaces and tabs at the line breaks in `value`.\n * Does not trim initial and final spaces and tabs of the value itself.\n *\n * @param {string} value\n *   Value to trim.\n * @returns {string}\n *   Trimmed value.\n */\nexport function trimLines(value) {\n  const source = String(value)\n  const search = /\\r?\\n|\\r/g\n  let match = search.exec(source)\n  let last = 0\n  /** @type {Array<string>} */\n  const lines = []\n\n  while (match) {\n    lines.push(\n      trimLine(source.slice(last, match.index), last > 0, true),\n      match[0]\n    )\n\n    last = match.index + match[0].length\n    match = search.exec(source)\n  }\n\n  lines.push(trimLine(source.slice(last), last > 0, false))\n\n  return lines.join('')\n}\n\n/**\n * @param {string} value\n *   Line to trim.\n * @param {boolean} start\n *   Whether to trim the start of the line.\n * @param {boolean} end\n *   Whether to trim the end of the line.\n * @returns {string}\n *   Trimmed line.\n */\nfunction trimLine(value, start, end) {\n  let startIndex = 0\n  let endIndex = value.length\n\n  if (start) {\n    let code = value.codePointAt(startIndex)\n\n    while (code === tab || code === space) {\n      startIndex++\n      code = value.codePointAt(startIndex)\n    }\n  }\n\n  if (end) {\n    let code = value.codePointAt(endIndex - 1)\n\n    while (code === tab || code === space) {\n      endIndex--\n      code = value.codePointAt(endIndex - 1)\n    }\n  }\n\n  return endIndex > startIndex ? value.slice(startIndex, endIndex) : ''\n}\n","import {blockquote} from './blockquote.js'\nimport {hardBreak} from './break.js'\nimport {code} from './code.js'\nimport {strikethrough} from './delete.js'\nimport {emphasis} from './emphasis.js'\nimport {footnoteReference} from './footnote-reference.js'\nimport {heading} from './heading.js'\nimport {html} from './html.js'\nimport {imageReference} from './image-reference.js'\nimport {image} from './image.js'\nimport {inlineCode} from './inline-code.js'\nimport {linkReference} from './link-reference.js'\nimport {link} from './link.js'\nimport {listItem} from './list-item.js'\nimport {list} from './list.js'\nimport {paragraph} from './paragraph.js'\nimport {root} from './root.js'\nimport {strong} from './strong.js'\nimport {table} from './table.js'\nimport {tableRow} from './table-row.js'\nimport {tableCell} from './table-cell.js'\nimport {text} from './text.js'\nimport {thematicBreak} from './thematic-break.js'\n\n/**\n * Default handlers for nodes.\n *\n * @satisfies {import('../state.js').Handlers}\n */\nexport const handlers = {\n  blockquote,\n  break: hardBreak,\n  code,\n  delete: strikethrough,\n  emphasis,\n  footnoteReference,\n  heading,\n  html,\n  imageReference,\n  image,\n  inlineCode,\n  linkReference,\n  link,\n  listItem,\n  list,\n  paragraph,\n  // @ts-expect-error: root is different, but hard to type.\n  root,\n  strong,\n  table,\n  tableCell,\n  tableRow,\n  text,\n  thematicBreak,\n  toml: ignore,\n  yaml: ignore,\n  definition: ignore,\n  footnoteDefinition: ignore\n}\n\n// Return nothing for nodes that are ignored.\nfunction ignore() {\n  return undefined\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Blockquote} Blockquote\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `blockquote` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Blockquote} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function blockquote(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'blockquote',\n    properties: {},\n    children: state.wrap(state.all(node), true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Text} Text\n * @typedef {import('mdast').Break} Break\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `break` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Break} node\n *   mdast node.\n * @returns {Array<Element | Text>}\n *   hast element content.\n */\nexport function hardBreak(state, node) {\n  /** @type {Element} */\n  const result = {type: 'element', tagName: 'br', properties: {}, children: []}\n  state.patch(node, result)\n  return [state.applyData(node, result), {type: 'text', value: '\\n'}]\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').Code} Code\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `code` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Code} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function code(state, node) {\n  const value = node.value ? node.value + '\\n' : ''\n  /** @type {Properties} */\n  const properties = {}\n\n  if (node.lang) {\n    properties.className = ['language-' + node.lang]\n  }\n\n  // Create `<code>`.\n  /** @type {Element} */\n  let result = {\n    type: 'element',\n    tagName: 'code',\n    properties,\n    children: [{type: 'text', value}]\n  }\n\n  if (node.meta) {\n    result.data = {meta: node.meta}\n  }\n\n  state.patch(node, result)\n  result = state.applyData(node, result)\n\n  // Create `<pre>`.\n  result = {type: 'element', tagName: 'pre', properties: {}, children: [result]}\n  state.patch(node, result)\n  return result\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Delete} Delete\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `delete` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Delete} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function strikethrough(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'del',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Emphasis} Emphasis\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `emphasis` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Emphasis} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function emphasis(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'em',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').FootnoteReference} FootnoteReference\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * Turn an mdast `footnoteReference` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {FootnoteReference} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function footnoteReference(state, node) {\n  const clobberPrefix =\n    typeof state.options.clobberPrefix === 'string'\n      ? state.options.clobberPrefix\n      : 'user-content-'\n  const id = String(node.identifier).toUpperCase()\n  const safeId = normalizeUri(id.toLowerCase())\n  const index = state.footnoteOrder.indexOf(id)\n  /** @type {number} */\n  let counter\n\n  let reuseCounter = state.footnoteCounts.get(id)\n\n  if (reuseCounter === undefined) {\n    reuseCounter = 0\n    state.footnoteOrder.push(id)\n    counter = state.footnoteOrder.length\n  } else {\n    counter = index + 1\n  }\n\n  reuseCounter += 1\n  state.footnoteCounts.set(id, reuseCounter)\n\n  /** @type {Element} */\n  const link = {\n    type: 'element',\n    tagName: 'a',\n    properties: {\n      href: '#' + clobberPrefix + 'fn-' + safeId,\n      id:\n        clobberPrefix +\n        'fnref-' +\n        safeId +\n        (reuseCounter > 1 ? '-' + reuseCounter : ''),\n      dataFootnoteRef: true,\n      ariaDescribedBy: ['footnote-label']\n    },\n    children: [{type: 'text', value: String(counter)}]\n  }\n  state.patch(node, link)\n\n  /** @type {Element} */\n  const sup = {\n    type: 'element',\n    tagName: 'sup',\n    properties: {},\n    children: [link]\n  }\n  state.patch(node, sup)\n  return state.applyData(node, sup)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Heading} Heading\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `heading` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Heading} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function heading(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'h' + node.depth,\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Html} Html\n * @typedef {import('../state.js').State} State\n * @typedef {import('../../index.js').Raw} Raw\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `html` node into hast (`raw` node in dangerous mode, otherwise\n * nothing).\n *\n * @param {State} state\n *   Info passed around.\n * @param {Html} node\n *   mdast node.\n * @returns {Element | Raw | undefined}\n *   hast node.\n */\nexport function html(state, node) {\n  if (state.options.allowDangerousHtml) {\n    /** @type {Raw} */\n    const result = {type: 'raw', value: node.value}\n    state.patch(node, result)\n    return state.applyData(node, result)\n  }\n\n  return undefined\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').ImageReference} ImageReference\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\nimport {revert} from '../revert.js'\n\n/**\n * Turn an mdast `imageReference` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {ImageReference} node\n *   mdast node.\n * @returns {Array<ElementContent> | ElementContent}\n *   hast node.\n */\nexport function imageReference(state, node) {\n  const id = String(node.identifier).toUpperCase()\n  const definition = state.definitionById.get(id)\n\n  if (!definition) {\n    return revert(state, node)\n  }\n\n  /** @type {Properties} */\n  const properties = {src: normalizeUri(definition.url || ''), alt: node.alt}\n\n  if (definition.title !== null && definition.title !== undefined) {\n    properties.title = definition.title\n  }\n\n  /** @type {Element} */\n  const result = {type: 'element', tagName: 'img', properties, children: []}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').Image} Image\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * Turn an mdast `image` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Image} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function image(state, node) {\n  /** @type {Properties} */\n  const properties = {src: normalizeUri(node.url)}\n\n  if (node.alt !== null && node.alt !== undefined) {\n    properties.alt = node.alt\n  }\n\n  if (node.title !== null && node.title !== undefined) {\n    properties.title = node.title\n  }\n\n  /** @type {Element} */\n  const result = {type: 'element', tagName: 'img', properties, children: []}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Text} Text\n * @typedef {import('mdast').InlineCode} InlineCode\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `inlineCode` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {InlineCode} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function inlineCode(state, node) {\n  /** @type {Text} */\n  const text = {type: 'text', value: node.value.replace(/\\r?\\n|\\r/g, ' ')}\n  state.patch(node, text)\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'code',\n    properties: {},\n    children: [text]\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').LinkReference} LinkReference\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\nimport {revert} from '../revert.js'\n\n/**\n * Turn an mdast `linkReference` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {LinkReference} node\n *   mdast node.\n * @returns {Array<ElementContent> | ElementContent}\n *   hast node.\n */\nexport function linkReference(state, node) {\n  const id = String(node.identifier).toUpperCase()\n  const definition = state.definitionById.get(id)\n\n  if (!definition) {\n    return revert(state, node)\n  }\n\n  /** @type {Properties} */\n  const properties = {href: normalizeUri(definition.url || '')}\n\n  if (definition.title !== null && definition.title !== undefined) {\n    properties.title = definition.title\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'a',\n    properties,\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').Link} Link\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * Turn an mdast `link` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Link} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function link(state, node) {\n  /** @type {Properties} */\n  const properties = {href: normalizeUri(node.url)}\n\n  if (node.title !== null && node.title !== undefined) {\n    properties.title = node.title\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'a',\n    properties,\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').List} List\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `list` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {List} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function list(state, node) {\n  /** @type {Properties} */\n  const properties = {}\n  const results = state.all(node)\n  let index = -1\n\n  if (typeof node.start === 'number' && node.start !== 1) {\n    properties.start = node.start\n  }\n\n  // Like GitHub, add a class for custom styling.\n  while (++index < results.length) {\n    const child = results[index]\n\n    if (\n      child.type === 'element' &&\n      child.tagName === 'li' &&\n      child.properties &&\n      Array.isArray(child.properties.className) &&\n      child.properties.className.includes('task-list-item')\n    ) {\n      properties.className = ['contains-task-list']\n      break\n    }\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: node.ordered ? 'ol' : 'ul',\n    properties,\n    children: state.wrap(results, true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Paragraph} Paragraph\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `paragraph` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Paragraph} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function paragraph(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'p',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Parents} HastParents\n * @typedef {import('hast').Root} HastRoot\n * @typedef {import('mdast').Root} MdastRoot\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `root` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastRoot} node\n *   mdast node.\n * @returns {HastParents}\n *   hast node.\n */\nexport function root(state, node) {\n  /** @type {HastRoot} */\n  const result = {type: 'root', children: state.wrap(state.all(node))}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Strong} Strong\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `strong` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Strong} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function strong(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'strong',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Table} Table\n * @typedef {import('../state.js').State} State\n */\n\nimport {pointEnd, pointStart} from 'unist-util-position'\n\n/**\n * Turn an mdast `table` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Table} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function table(state, node) {\n  const rows = state.all(node)\n  const firstRow = rows.shift()\n  /** @type {Array<Element>} */\n  const tableContent = []\n\n  if (firstRow) {\n    /** @type {Element} */\n    const head = {\n      type: 'element',\n      tagName: 'thead',\n      properties: {},\n      children: state.wrap([firstRow], true)\n    }\n    state.patch(node.children[0], head)\n    tableContent.push(head)\n  }\n\n  if (rows.length > 0) {\n    /** @type {Element} */\n    const body = {\n      type: 'element',\n      tagName: 'tbody',\n      properties: {},\n      children: state.wrap(rows, true)\n    }\n\n    const start = pointStart(node.children[1])\n    const end = pointEnd(node.children[node.children.length - 1])\n    if (start && end) body.position = {start, end}\n    tableContent.push(body)\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'table',\n    properties: {},\n    children: state.wrap(tableContent, true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').TableCell} TableCell\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `tableCell` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {TableCell} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function tableCell(state, node) {\n  // Note: this function is normally not called: see `table-row` for how rows\n  // and their cells are compiled.\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'td', // Assume body cell.\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('mdast').TableRow} TableRow\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `tableRow` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {TableRow} node\n *   mdast node.\n * @param {Parents | undefined} parent\n *   Parent of `node`.\n * @returns {Element}\n *   hast node.\n */\nexport function tableRow(state, node, parent) {\n  const siblings = parent ? parent.children : undefined\n  // Generate a body row when without parent.\n  const rowIndex = siblings ? siblings.indexOf(node) : 1\n  const tagName = rowIndex === 0 ? 'th' : 'td'\n  // To do: option to use `style`?\n  const align = parent && parent.type === 'table' ? parent.align : undefined\n  const length = align ? align.length : node.children.length\n  let cellIndex = -1\n  /** @type {Array<ElementContent>} */\n  const cells = []\n\n  while (++cellIndex < length) {\n    // Note: can also be undefined.\n    const cell = node.children[cellIndex]\n    /** @type {Properties} */\n    const properties = {}\n    const alignValue = align ? align[cellIndex] : undefined\n\n    if (alignValue) {\n      properties.align = alignValue\n    }\n\n    /** @type {Element} */\n    let result = {type: 'element', tagName, properties, children: []}\n\n    if (cell) {\n      result.children = state.all(cell)\n      state.patch(cell, result)\n      result = state.applyData(cell, result)\n    }\n\n    cells.push(result)\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'tr',\n    properties: {},\n    children: state.wrap(cells, true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} HastElement\n * @typedef {import('hast').Text} HastText\n * @typedef {import('mdast').Text} MdastText\n * @typedef {import('../state.js').State} State\n */\n\nimport {trimLines} from 'trim-lines'\n\n/**\n * Turn an mdast `text` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastText} node\n *   mdast node.\n * @returns {HastElement | HastText}\n *   hast node.\n */\nexport function text(state, node) {\n  /** @type {HastText} */\n  const result = {type: 'text', value: trimLines(String(node.value))}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').ThematicBreak} ThematicBreak\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `thematicBreak` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {ThematicBreak} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function thematicBreak(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'hr',\n    properties: {},\n    children: []\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} HastElement\n * @typedef {import('hast').ElementContent} HastElementContent\n * @typedef {import('hast').Nodes} HastNodes\n * @typedef {import('hast').Properties} HastProperties\n * @typedef {import('hast').RootContent} HastRootContent\n * @typedef {import('hast').Text} HastText\n *\n * @typedef {import('mdast').Definition} MdastDefinition\n * @typedef {import('mdast').FootnoteDefinition} MdastFootnoteDefinition\n * @typedef {import('mdast').Nodes} MdastNodes\n * @typedef {import('mdast').Parents} MdastParents\n *\n * @typedef {import('vfile').VFile} VFile\n *\n * @typedef {import('./footer.js').FootnoteBackContentTemplate} FootnoteBackContentTemplate\n * @typedef {import('./footer.js').FootnoteBackLabelTemplate} FootnoteBackLabelTemplate\n */\n\n/**\n * @callback Handler\n *   Handle a node.\n * @param {State} state\n *   Info passed around.\n * @param {any} node\n *   mdast node to handle.\n * @param {MdastParents | undefined} parent\n *   Parent of `node`.\n * @returns {Array<HastElementContent> | HastElementContent | undefined}\n *   hast node.\n *\n * @typedef {Partial<Record<MdastNodes['type'], Handler>>} Handlers\n *   Handle nodes.\n *\n * @typedef Options\n *   Configuration (optional).\n * @property {boolean | null | undefined} [allowDangerousHtml=false]\n *   Whether to persist raw HTML in markdown in the hast tree (default:\n *   `false`).\n * @property {string | null | undefined} [clobberPrefix='user-content-']\n *   Prefix to use before the `id` property on footnotes to prevent them from\n *   *clobbering* (default: `'user-content-'`).\n *\n *   Pass `''` for trusted markdown and when you are careful with\n *   polyfilling.\n *   You could pass a different prefix.\n *\n *   DOM clobbering is this:\n *\n *   ```html\n *   <p id=\"x\"></p>\n *   <script>alert(x) // `x` now refers to the `p#x` DOM element</script>\n *   ```\n *\n *   The above example shows that elements are made available by browsers, by\n *   their ID, on the `window` object.\n *   This is a security risk because you might be expecting some other variable\n *   at that place.\n *   It can also break polyfills.\n *   Using a prefix solves these problems.\n * @property {VFile | null | undefined} [file]\n *   Corresponding virtual file representing the input document (optional).\n * @property {FootnoteBackContentTemplate | string | null | undefined} [footnoteBackContent]\n *   Content of the backreference back to references (default: `defaultFootnoteBackContent`).\n *\n *   The default value is:\n *\n *   ```js\n *   function defaultFootnoteBackContent(_, rereferenceIndex) {\n *     const result = [{type: 'text', value: '↩'}]\n *\n *     if (rereferenceIndex > 1) {\n *       result.push({\n *         type: 'element',\n *         tagName: 'sup',\n *         properties: {},\n *         children: [{type: 'text', value: String(rereferenceIndex)}]\n *       })\n *     }\n *\n *     return result\n *   }\n *   ```\n *\n *   This content is used in the `a` element of each backreference (the `↩`\n *   links).\n * @property {FootnoteBackLabelTemplate | string | null | undefined} [footnoteBackLabel]\n *   Label to describe the backreference back to references (default:\n *   `defaultFootnoteBackLabel`).\n *\n *   The default value is:\n *\n *   ```js\n *   function defaultFootnoteBackLabel(referenceIndex, rereferenceIndex) {\n *    return (\n *      'Back to reference ' +\n *      (referenceIndex + 1) +\n *      (rereferenceIndex > 1 ? '-' + rereferenceIndex : '')\n *    )\n *   }\n *   ```\n *\n *   Change it when the markdown is not in English.\n *\n *   This label is used in the `ariaLabel` property on each backreference\n *   (the `↩` links).\n *   It affects users of assistive technology.\n * @property {string | null | undefined} [footnoteLabel='Footnotes']\n *   Textual label to use for the footnotes section (default: `'Footnotes'`).\n *\n *   Change it when the markdown is not in English.\n *\n *   This label is typically hidden visually (assuming a `sr-only` CSS class\n *   is defined that does that) and so affects screen readers only.\n *   If you do have such a class, but want to show this section to everyone,\n *   pass different properties with the `footnoteLabelProperties` option.\n * @property {HastProperties | null | undefined} [footnoteLabelProperties={className: ['sr-only']}]\n *   Properties to use on the footnote label (default: `{className:\n *   ['sr-only']}`).\n *\n *   Change it to show the label and add other properties.\n *\n *   This label is typically hidden visually (assuming an `sr-only` CSS class\n *   is defined that does that) and so affects screen readers only.\n *   If you do have such a class, but want to show this section to everyone,\n *   pass an empty string.\n *   You can also add different properties.\n *\n *   > **Note**: `id: 'footnote-label'` is always added, because footnote\n *   > calls use it with `aria-describedby` to provide an accessible label.\n * @property {string | null | undefined} [footnoteLabelTagName='h2']\n *   HTML tag name to use for the footnote label element (default: `'h2'`).\n *\n *   Change it to match your document structure.\n *\n *   This label is typically hidden visually (assuming a `sr-only` CSS class\n *   is defined that does that) and so affects screen readers only.\n *   If you do have such a class, but want to show this section to everyone,\n *   pass different properties with the `footnoteLabelProperties` option.\n * @property {Handlers | null | undefined} [handlers]\n *   Extra handlers for nodes (optional).\n * @property {Array<MdastNodes['type']> | null | undefined} [passThrough]\n *   List of custom mdast node types to pass through (keep) in hast (note that\n *   the node itself is passed, but eventual children are transformed)\n *   (optional).\n * @property {Handler | null | undefined} [unknownHandler]\n *   Handler for all unknown nodes (optional).\n *\n * @typedef State\n *   Info passed around.\n * @property {(node: MdastNodes) => Array<HastElementContent>} all\n *   Transform the children of an mdast parent to hast.\n * @property {<Type extends HastNodes>(from: MdastNodes, to: Type) => HastElement | Type} applyData\n *   Honor the `data` of `from`, and generate an element instead of `node`.\n * @property {Map<string, MdastDefinition>} definitionById\n *   Definitions by their identifier.\n * @property {Map<string, MdastFootnoteDefinition>} footnoteById\n *   Footnote definitions by their identifier.\n * @property {Map<string, number>} footnoteCounts\n *   Counts for how often the same footnote was called.\n * @property {Array<string>} footnoteOrder\n *   Identifiers of order when footnote calls first appear in tree order.\n * @property {Handlers} handlers\n *   Applied handlers.\n * @property {(node: MdastNodes, parent: MdastParents | undefined) => Array<HastElementContent> | HastElementContent | undefined} one\n *   Transform an mdast node to hast.\n * @property {Options} options\n *   Configuration.\n * @property {(from: MdastNodes, node: HastNodes) => undefined} patch\n *   Copy a node’s positional info.\n * @property {<Type extends HastRootContent>(nodes: Array<Type>, loose?: boolean | undefined) => Array<HastText | Type>} wrap\n *   Wrap `nodes` with line endings between each node, adds initial/final line endings when `loose`.\n */\n\nimport structuredClone from '@ungap/structured-clone'\nimport {visit} from 'unist-util-visit'\nimport {position} from 'unist-util-position'\nimport {handlers as defaultHandlers} from './handlers/index.js'\n\nconst own = {}.hasOwnProperty\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Create `state` from an mdast tree.\n *\n * @param {MdastNodes} tree\n *   mdast node to transform.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {State}\n *   `state` function.\n */\nexport function createState(tree, options) {\n  const settings = options || emptyOptions\n  /** @type {Map<string, MdastDefinition>} */\n  const definitionById = new Map()\n  /** @type {Map<string, MdastFootnoteDefinition>} */\n  const footnoteById = new Map()\n  /** @type {Map<string, number>} */\n  const footnoteCounts = new Map()\n  /** @type {Handlers} */\n  // @ts-expect-error: the root handler returns a root.\n  // Hard to type.\n  const handlers = {...defaultHandlers, ...settings.handlers}\n\n  /** @type {State} */\n  const state = {\n    all,\n    applyData,\n    definitionById,\n    footnoteById,\n    footnoteCounts,\n    footnoteOrder: [],\n    handlers,\n    one,\n    options: settings,\n    patch,\n    wrap\n  }\n\n  visit(tree, function (node) {\n    if (node.type === 'definition' || node.type === 'footnoteDefinition') {\n      const map = node.type === 'definition' ? definitionById : footnoteById\n      const id = String(node.identifier).toUpperCase()\n\n      // Mimick CM behavior of link definitions.\n      // See: <https://github.com/syntax-tree/mdast-util-definitions/blob/9032189/lib/index.js#L20-L21>.\n      if (!map.has(id)) {\n        // @ts-expect-error: node type matches map.\n        map.set(id, node)\n      }\n    }\n  })\n\n  return state\n\n  /**\n   * Transform an mdast node into a hast node.\n   *\n   * @param {MdastNodes} node\n   *   mdast node.\n   * @param {MdastParents | undefined} [parent]\n   *   Parent of `node`.\n   * @returns {Array<HastElementContent> | HastElementContent | undefined}\n   *   Resulting hast node.\n   */\n  function one(node, parent) {\n    const type = node.type\n    const handle = state.handlers[type]\n\n    if (own.call(state.handlers, type) && handle) {\n      return handle(state, node, parent)\n    }\n\n    if (state.options.passThrough && state.options.passThrough.includes(type)) {\n      if ('children' in node) {\n        const {children, ...shallow} = node\n        const result = structuredClone(shallow)\n        // @ts-expect-error: TS doesn’t understand…\n        result.children = state.all(node)\n        // @ts-expect-error: TS doesn’t understand…\n        return result\n      }\n\n      // @ts-expect-error: it’s custom.\n      return structuredClone(node)\n    }\n\n    const unknown = state.options.unknownHandler || defaultUnknownHandler\n\n    return unknown(state, node, parent)\n  }\n\n  /**\n   * Transform the children of an mdast node into hast nodes.\n   *\n   * @param {MdastNodes} parent\n   *   mdast node to compile\n   * @returns {Array<HastElementContent>}\n   *   Resulting hast nodes.\n   */\n  function all(parent) {\n    /** @type {Array<HastElementContent>} */\n    const values = []\n\n    if ('children' in parent) {\n      const nodes = parent.children\n      let index = -1\n      while (++index < nodes.length) {\n        const result = state.one(nodes[index], parent)\n\n        // To do: see if we van clean this? Can we merge texts?\n        if (result) {\n          if (index && nodes[index - 1].type === 'break') {\n            if (!Array.isArray(result) && result.type === 'text') {\n              result.value = trimMarkdownSpaceStart(result.value)\n            }\n\n            if (!Array.isArray(result) && result.type === 'element') {\n              const head = result.children[0]\n\n              if (head && head.type === 'text') {\n                head.value = trimMarkdownSpaceStart(head.value)\n              }\n            }\n          }\n\n          if (Array.isArray(result)) {\n            values.push(...result)\n          } else {\n            values.push(result)\n          }\n        }\n      }\n    }\n\n    return values\n  }\n}\n\n/**\n * Copy a node’s positional info.\n *\n * @param {MdastNodes} from\n *   mdast node to copy from.\n * @param {HastNodes} to\n *   hast node to copy into.\n * @returns {undefined}\n *   Nothing.\n */\nfunction patch(from, to) {\n  if (from.position) to.position = position(from)\n}\n\n/**\n * Honor the `data` of `from` and maybe generate an element instead of `to`.\n *\n * @template {HastNodes} Type\n *   Node type.\n * @param {MdastNodes} from\n *   mdast node to use data from.\n * @param {Type} to\n *   hast node to change.\n * @returns {HastElement | Type}\n *   Nothing.\n */\nfunction applyData(from, to) {\n  /** @type {HastElement | Type} */\n  let result = to\n\n  // Handle `data.hName`, `data.hProperties, `data.hChildren`.\n  if (from && from.data) {\n    const hName = from.data.hName\n    const hChildren = from.data.hChildren\n    const hProperties = from.data.hProperties\n\n    if (typeof hName === 'string') {\n      // Transforming the node resulted in an element with a different name\n      // than wanted:\n      if (result.type === 'element') {\n        result.tagName = hName\n      }\n      // Transforming the node resulted in a non-element, which happens for\n      // raw, text, and root nodes (unless custom handlers are passed).\n      // The intent of `hName` is to create an element, but likely also to keep\n      // the content around (otherwise: pass `hChildren`).\n      else {\n        /** @type {Array<HastElementContent>} */\n        // @ts-expect-error: assume no doctypes in `root`.\n        const children = 'children' in result ? result.children : [result]\n        result = {type: 'element', tagName: hName, properties: {}, children}\n      }\n    }\n\n    if (result.type === 'element' && hProperties) {\n      Object.assign(result.properties, structuredClone(hProperties))\n    }\n\n    if (\n      'children' in result &&\n      result.children &&\n      hChildren !== null &&\n      hChildren !== undefined\n    ) {\n      result.children = hChildren\n    }\n  }\n\n  return result\n}\n\n/**\n * Transform an unknown node.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastNodes} node\n *   Unknown mdast node.\n * @returns {HastElement | HastText}\n *   Resulting hast node.\n */\nfunction defaultUnknownHandler(state, node) {\n  const data = node.data || {}\n  /** @type {HastElement | HastText} */\n  const result =\n    'value' in node &&\n    !(own.call(data, 'hProperties') || own.call(data, 'hChildren'))\n      ? {type: 'text', value: node.value}\n      : {\n          type: 'element',\n          tagName: 'div',\n          properties: {},\n          children: state.all(node)\n        }\n\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n\n/**\n * Wrap `nodes` with line endings between each node.\n *\n * @template {HastRootContent} Type\n *   Node type.\n * @param {Array<Type>} nodes\n *   List of nodes to wrap.\n * @param {boolean | undefined} [loose=false]\n *   Whether to add line endings at start and end (default: `false`).\n * @returns {Array<HastText | Type>}\n *   Wrapped nodes.\n */\nexport function wrap(nodes, loose) {\n  /** @type {Array<HastText | Type>} */\n  const result = []\n  let index = -1\n\n  if (loose) {\n    result.push({type: 'text', value: '\\n'})\n  }\n\n  while (++index < nodes.length) {\n    if (index) result.push({type: 'text', value: '\\n'})\n    result.push(nodes[index])\n  }\n\n  if (loose && nodes.length > 0) {\n    result.push({type: 'text', value: '\\n'})\n  }\n\n  return result\n}\n\n/**\n * Trim spaces and tabs at the start of `value`.\n *\n * @param {string} value\n *   Value to trim.\n * @returns {string}\n *   Result.\n */\nfunction trimMarkdownSpaceStart(value) {\n  let index = 0\n  let code = value.charCodeAt(index)\n\n  while (code === 9 || code === 32) {\n    index++\n    code = value.charCodeAt(index)\n  }\n\n  return value.slice(index)\n}\n","/**\n * @typedef {import('hast').Nodes} HastNodes\n * @typedef {import('mdast').Nodes} MdastNodes\n * @typedef {import('./state.js').Options} Options\n */\n\nimport {ok as assert} from 'devlop'\nimport {footer} from './footer.js'\nimport {createState} from './state.js'\n\n/**\n * Transform mdast to hast.\n *\n * ##### Notes\n *\n * ###### HTML\n *\n * Raw HTML is available in mdast as `html` nodes and can be embedded in hast\n * as semistandard `raw` nodes.\n * Most utilities ignore `raw` nodes but two notable ones don’t:\n *\n * *   `hast-util-to-html` also has an option `allowDangerousHtml` which will\n *     output the raw HTML.\n *     This is typically discouraged as noted by the option name but is useful\n *     if you completely trust authors\n * *   `hast-util-raw` can handle the raw embedded HTML strings by parsing them\n *     into standard hast nodes (`element`, `text`, etc).\n *     This is a heavy task as it needs a full HTML parser, but it is the only\n *     way to support untrusted content\n *\n * ###### Footnotes\n *\n * Many options supported here relate to footnotes.\n * Footnotes are not specified by CommonMark, which we follow by default.\n * They are supported by GitHub, so footnotes can be enabled in markdown with\n * `mdast-util-gfm`.\n *\n * The options `footnoteBackLabel` and `footnoteLabel` define natural language\n * that explains footnotes, which is hidden for sighted users but shown to\n * assistive technology.\n * When your page is not in English, you must define translated values.\n *\n * Back references use ARIA attributes, but the section label itself uses a\n * heading that is hidden with an `sr-only` class.\n * To show it to sighted users, define different attributes in\n * `footnoteLabelProperties`.\n *\n * ###### Clobbering\n *\n * Footnotes introduces a problem, as it links footnote calls to footnote\n * definitions on the page through `id` attributes generated from user content,\n * which results in DOM clobbering.\n *\n * DOM clobbering is this:\n *\n * ```html\n * <p id=x></p>\n * <script>alert(x) // `x` now refers to the DOM `p#x` element</script>\n * ```\n *\n * Elements by their ID are made available by browsers on the `window` object,\n * which is a security risk.\n * Using a prefix solves this problem.\n *\n * More information on how to handle clobbering and the prefix is explained in\n * Example: headings (DOM clobbering) in `rehype-sanitize`.\n *\n * ###### Unknown nodes\n *\n * Unknown nodes are nodes with a type that isn’t in `handlers` or `passThrough`.\n * The default behavior for unknown nodes is:\n *\n * *   when the node has a `value` (and doesn’t have `data.hName`,\n *     `data.hProperties`, or `data.hChildren`, see later), create a hast `text`\n *     node\n * *   otherwise, create a `<div>` element (which could be changed with\n *     `data.hName`), with its children mapped from mdast to hast as well\n *\n * This behavior can be changed by passing an `unknownHandler`.\n *\n * @param {MdastNodes} tree\n *   mdast tree.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {HastNodes}\n *   hast tree.\n */\nexport function toHast(tree, options) {\n  const state = createState(tree, options)\n  const node = state.one(tree, undefined)\n  const foot = footer(state)\n  /** @type {HastNodes} */\n  const result = Array.isArray(node)\n    ? {type: 'root', children: node}\n    : node || {type: 'root', children: []}\n\n  if (foot) {\n    // If there’s a footer, there were definitions, meaning block\n    // content.\n    // So `result` is a parent node.\n    assert('children' in result)\n    result.children.push({type: 'text', value: '\\n'}, foot)\n  }\n\n  return result\n}\n","// Include `data` fields in mdast and `raw` nodes in hast.\n/// <reference types=\"mdast-util-to-hast\" />\n\n/**\n * @import {Root as HastRoot} from 'hast'\n * @import {Root as MdastRoot} from 'mdast'\n * @import {Options as ToHastOptions} from 'mdast-util-to-hast'\n * @import {Processor} from 'unified'\n * @import {VFile} from 'vfile'\n */\n\n/**\n * @typedef {Omit<ToHastOptions, 'file'>} Options\n *\n * @callback TransformBridge\n *   Bridge-mode.\n *\n *   Runs the destination with the new hast tree.\n *   Discards result.\n * @param {MdastRoot} tree\n *   Tree.\n * @param {VFile} file\n *   File.\n * @returns {Promise<undefined>}\n *   Nothing.\n *\n * @callback TransformMutate\n *  Mutate-mode.\n *\n *  Further transformers run on the hast tree.\n * @param {MdastRoot} tree\n *   Tree.\n * @param {VFile} file\n *   File.\n * @returns {HastRoot}\n *   Tree (hast).\n */\n\nimport {toHast} from 'mdast-util-to-hast'\n\n/**\n * Turn markdown into HTML.\n *\n * ##### Notes\n *\n * ###### Signature\n *\n * *   if a processor is given, runs the (rehype) plugins used on it with a\n *     hast tree, then discards the result (*bridge mode*)\n * *   otherwise, returns a hast tree, the plugins used after `remarkRehype`\n *     are rehype plugins (*mutate mode*)\n *\n * > 👉 **Note**: It’s highly unlikely that you want to pass a `processor`.\n *\n * ###### HTML\n *\n * Raw HTML is available in mdast as `html` nodes and can be embedded in hast\n * as semistandard `raw` nodes.\n * Most plugins ignore `raw` nodes but two notable ones don’t:\n *\n * *   `rehype-stringify` also has an option `allowDangerousHtml` which will\n *     output the raw HTML.\n *     This is typically discouraged as noted by the option name but is useful if\n *     you completely trust authors\n * *   `rehype-raw` can handle the raw embedded HTML strings by parsing them\n *     into standard hast nodes (`element`, `text`, etc).\n *     This is a heavy task as it needs a full HTML parser, but it is the only way\n *     to support untrusted content\n *\n * ###### Footnotes\n *\n * Many options supported here relate to footnotes.\n * Footnotes are not specified by CommonMark, which we follow by default.\n * They are supported by GitHub, so footnotes can be enabled in markdown with\n * `remark-gfm`.\n *\n * The options `footnoteBackLabel` and `footnoteLabel` define natural language\n * that explains footnotes, which is hidden for sighted users but shown to\n * assistive technology.\n * When your page is not in English, you must define translated values.\n *\n * Back references use ARIA attributes, but the section label itself uses a\n * heading that is hidden with an `sr-only` class.\n * To show it to sighted users, define different attributes in\n * `footnoteLabelProperties`.\n *\n * ###### Clobbering\n *\n * Footnotes introduces a problem, as it links footnote calls to footnote\n * definitions on the page through `id` attributes generated from user content,\n * which results in DOM clobbering.\n *\n * DOM clobbering is this:\n *\n * ```html\n * <p id=x></p>\n * <script>alert(x) // `x` now refers to the DOM `p#x` element</script>\n * ```\n *\n * Elements by their ID are made available by browsers on the `window` object,\n * which is a security risk.\n * Using a prefix solves this problem.\n *\n * More information on how to handle clobbering and the prefix is explained in\n * *Example: headings (DOM clobbering)* in `rehype-sanitize`.\n *\n * ###### Unknown nodes\n *\n * Unknown nodes are nodes with a type that isn’t in `handlers` or `passThrough`.\n * The default behavior for unknown nodes is:\n *\n * *   when the node has a `value` (and doesn’t have `data.hName`,\n *     `data.hProperties`, or `data.hChildren`, see later), create a hast `text`\n *     node\n * *   otherwise, create a `<div>` element (which could be changed with\n *     `data.hName`), with its children mapped from mdast to hast as well\n *\n * This behavior can be changed by passing an `unknownHandler`.\n *\n * @overload\n * @param {Processor} processor\n * @param {Readonly<Options> | null | undefined} [options]\n * @returns {TransformBridge}\n *\n * @overload\n * @param {Readonly<Options> | null | undefined} [options]\n * @returns {TransformMutate}\n *\n * @param {Readonly<Options> | Processor | null | undefined} [destination]\n *   Processor or configuration (optional).\n * @param {Readonly<Options> | null | undefined} [options]\n *   When a processor was given, configuration (optional).\n * @returns {TransformBridge | TransformMutate}\n *   Transform.\n */\nexport default function remarkRehype(destination, options) {\n  if (destination && 'run' in destination) {\n    /**\n     * @type {TransformBridge}\n     */\n    return async function (tree, file) {\n      // Cast because root in -> root out.\n      const hastTree = /** @type {HastRoot} */ (\n        toHast(tree, {file, ...options})\n      )\n      await destination.run(hastTree, file)\n    }\n  }\n\n  /**\n   * @type {TransformMutate}\n   */\n  return function (tree, file) {\n    // Cast because root in -> root out.\n    // To do: in the future, disallow ` || options` fallback.\n    // With `unified-engine`, `destination` can be `undefined` but\n    // `options` will be the file set.\n    // We should not pass that as `options`.\n    return /** @type {HastRoot} */ (\n      toHast(tree, {file, ...(destination || options)})\n    )\n  }\n}\n","/**\n * Throw a given error.\n *\n * @param {Error|null|undefined} [error]\n *   Maybe error.\n * @returns {asserts error is null|undefined}\n */\nexport function bail(error) {\n  if (error) {\n    throw error\n  }\n}\n","export default function isPlainObject(value) {\n\tif (typeof value !== 'object' || value === null) {\n\t\treturn false;\n\t}\n\n\tconst prototype = Object.getPrototypeOf(value);\n\treturn (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);\n}\n","// To do: remove `void`s\n// To do: remove `null` from output of our APIs, allow it as user APIs.\n\n/**\n * @typedef {(error?: Error | null | undefined, ...output: Array<any>) => void} Callback\n *   Callback.\n *\n * @typedef {(...input: Array<any>) => any} Middleware\n *   Ware.\n *\n * @typedef Pipeline\n *   Pipeline.\n * @property {Run} run\n *   Run the pipeline.\n * @property {Use} use\n *   Add middleware.\n *\n * @typedef {(...input: Array<any>) => void} Run\n *   Call all middleware.\n *\n *   Calls `done` on completion with either an error or the output of the\n *   last middleware.\n *\n *   > 👉 **Note**: as the length of input defines whether async functions get a\n *   > `next` function,\n *   > it’s recommended to keep `input` at one value normally.\n\n *\n * @typedef {(fn: Middleware) => Pipeline} Use\n *   Add middleware.\n */\n\n/**\n * Create new middleware.\n *\n * @returns {Pipeline}\n *   Pipeline.\n */\nexport function trough() {\n  /** @type {Array<Middleware>} */\n  const fns = []\n  /** @type {Pipeline} */\n  const pipeline = {run, use}\n\n  return pipeline\n\n  /** @type {Run} */\n  function run(...values) {\n    let middlewareIndex = -1\n    /** @type {Callback} */\n    const callback = values.pop()\n\n    if (typeof callback !== 'function') {\n      throw new TypeError('Expected function as last argument, not ' + callback)\n    }\n\n    next(null, ...values)\n\n    /**\n     * Run the next `fn`, or we’re done.\n     *\n     * @param {Error | null | undefined} error\n     * @param {Array<any>} output\n     */\n    function next(error, ...output) {\n      const fn = fns[++middlewareIndex]\n      let index = -1\n\n      if (error) {\n        callback(error)\n        return\n      }\n\n      // Copy non-nullish input into values.\n      while (++index < values.length) {\n        if (output[index] === null || output[index] === undefined) {\n          output[index] = values[index]\n        }\n      }\n\n      // Save the newly created `output` for the next call.\n      values = output\n\n      // Next or done.\n      if (fn) {\n        wrap(fn, next)(...output)\n      } else {\n        callback(null, ...output)\n      }\n    }\n  }\n\n  /** @type {Use} */\n  function use(middelware) {\n    if (typeof middelware !== 'function') {\n      throw new TypeError(\n        'Expected `middelware` to be a function, not ' + middelware\n      )\n    }\n\n    fns.push(middelware)\n    return pipeline\n  }\n}\n\n/**\n * Wrap `middleware` into a uniform interface.\n *\n * You can pass all input to the resulting function.\n * `callback` is then called with the output of `middleware`.\n *\n * If `middleware` accepts more arguments than the later given in input,\n * an extra `done` function is passed to it after that input,\n * which must be called by `middleware`.\n *\n * The first value in `input` is the main input value.\n * All other input values are the rest input values.\n * The values given to `callback` are the input values,\n * merged with every non-nullish output value.\n *\n * * if `middleware` throws an error,\n *   returns a promise that is rejected,\n *   or calls the given `done` function with an error,\n *   `callback` is called with that error\n * * if `middleware` returns a value or returns a promise that is resolved,\n *   that value is the main output value\n * * if `middleware` calls `done`,\n *   all non-nullish values except for the first one (the error) overwrite the\n *   output values\n *\n * @param {Middleware} middleware\n *   Function to wrap.\n * @param {Callback} callback\n *   Callback called with the output of `middleware`.\n * @returns {Run}\n *   Wrapped middleware.\n */\nexport function wrap(middleware, callback) {\n  /** @type {boolean} */\n  let called\n\n  return wrapped\n\n  /**\n   * Call `middleware`.\n   * @this {any}\n   * @param {Array<any>} parameters\n   * @returns {void}\n   */\n  function wrapped(...parameters) {\n    const fnExpectsCallback = middleware.length > parameters.length\n    /** @type {any} */\n    let result\n\n    if (fnExpectsCallback) {\n      parameters.push(done)\n    }\n\n    try {\n      result = middleware.apply(this, parameters)\n    } catch (error) {\n      const exception = /** @type {Error} */ (error)\n\n      // Well, this is quite the pickle.\n      // `middleware` received a callback and called it synchronously, but that\n      // threw an error.\n      // The only thing left to do is to throw the thing instead.\n      if (fnExpectsCallback && called) {\n        throw exception\n      }\n\n      return done(exception)\n    }\n\n    if (!fnExpectsCallback) {\n      if (result && result.then && typeof result.then === 'function') {\n        result.then(then, done)\n      } else if (result instanceof Error) {\n        done(result)\n      } else {\n        then(result)\n      }\n    }\n  }\n\n  /**\n   * Call `callback`, only once.\n   *\n   * @type {Callback}\n   */\n  function done(error, ...output) {\n    if (!called) {\n      called = true\n      callback(error, ...output)\n    }\n  }\n\n  /**\n   * Call `done` with one value.\n   *\n   * @param {any} [value]\n   */\n  function then(value) {\n    done(null, value)\n  }\n}\n","// A derivative work based on:\n// <https://github.com/browserify/path-browserify>.\n// Which is licensed:\n//\n// MIT License\n//\n// Copyright (c) 2013 James Halliday\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy of\n// this software and associated documentation files (the \"Software\"), to deal in\n// the Software without restriction, including without limitation the rights to\n// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\n// the Software, and to permit persons to whom the Software is furnished to do so,\n// subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\n// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\n// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\n// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\n// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n// A derivative work based on:\n//\n// Parts of that are extracted from Node’s internal `path` module:\n// <https://github.com/nodejs/node/blob/master/lib/path.js>.\n// Which is licensed:\n//\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nexport const minpath = {basename, dirname, extname, join, sep: '/'}\n\n/* eslint-disable max-depth, complexity */\n\n/**\n * Get the basename from a path.\n *\n * @param {string} path\n *   File path.\n * @param {string | null | undefined} [extname]\n *   Extension to strip.\n * @returns {string}\n *   Stem or basename.\n */\nfunction basename(path, extname) {\n  if (extname !== undefined && typeof extname !== 'string') {\n    throw new TypeError('\"ext\" argument must be a string')\n  }\n\n  assertPath(path)\n  let start = 0\n  let end = -1\n  let index = path.length\n  /** @type {boolean | undefined} */\n  let seenNonSlash\n\n  if (\n    extname === undefined ||\n    extname.length === 0 ||\n    extname.length > path.length\n  ) {\n    while (index--) {\n      if (path.codePointAt(index) === 47 /* `/` */) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now.\n        if (seenNonSlash) {\n          start = index + 1\n          break\n        }\n      } else if (end < 0) {\n        // We saw the first non-path separator, mark this as the end of our\n        // path component.\n        seenNonSlash = true\n        end = index + 1\n      }\n    }\n\n    return end < 0 ? '' : path.slice(start, end)\n  }\n\n  if (extname === path) {\n    return ''\n  }\n\n  let firstNonSlashEnd = -1\n  let extnameIndex = extname.length - 1\n\n  while (index--) {\n    if (path.codePointAt(index) === 47 /* `/` */) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now.\n      if (seenNonSlash) {\n        start = index + 1\n        break\n      }\n    } else {\n      if (firstNonSlashEnd < 0) {\n        // We saw the first non-path separator, remember this index in case\n        // we need it if the extension ends up not matching.\n        seenNonSlash = true\n        firstNonSlashEnd = index + 1\n      }\n\n      if (extnameIndex > -1) {\n        // Try to match the explicit extension.\n        if (path.codePointAt(index) === extname.codePointAt(extnameIndex--)) {\n          if (extnameIndex < 0) {\n            // We matched the extension, so mark this as the end of our path\n            // component\n            end = index\n          }\n        } else {\n          // Extension does not match, so our result is the entire path\n          // component\n          extnameIndex = -1\n          end = firstNonSlashEnd\n        }\n      }\n    }\n  }\n\n  if (start === end) {\n    end = firstNonSlashEnd\n  } else if (end < 0) {\n    end = path.length\n  }\n\n  return path.slice(start, end)\n}\n\n/**\n * Get the dirname from a path.\n *\n * @param {string} path\n *   File path.\n * @returns {string}\n *   File path.\n */\nfunction dirname(path) {\n  assertPath(path)\n\n  if (path.length === 0) {\n    return '.'\n  }\n\n  let end = -1\n  let index = path.length\n  /** @type {boolean | undefined} */\n  let unmatchedSlash\n\n  // Prefix `--` is important to not run on `0`.\n  while (--index) {\n    if (path.codePointAt(index) === 47 /* `/` */) {\n      if (unmatchedSlash) {\n        end = index\n        break\n      }\n    } else if (!unmatchedSlash) {\n      // We saw the first non-path separator\n      unmatchedSlash = true\n    }\n  }\n\n  return end < 0\n    ? path.codePointAt(0) === 47 /* `/` */\n      ? '/'\n      : '.'\n    : end === 1 && path.codePointAt(0) === 47 /* `/` */\n      ? '//'\n      : path.slice(0, end)\n}\n\n/**\n * Get an extname from a path.\n *\n * @param {string} path\n *   File path.\n * @returns {string}\n *   Extname.\n */\nfunction extname(path) {\n  assertPath(path)\n\n  let index = path.length\n\n  let end = -1\n  let startPart = 0\n  let startDot = -1\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find.\n  let preDotState = 0\n  /** @type {boolean | undefined} */\n  let unmatchedSlash\n\n  while (index--) {\n    const code = path.codePointAt(index)\n\n    if (code === 47 /* `/` */) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now.\n      if (unmatchedSlash) {\n        startPart = index + 1\n        break\n      }\n\n      continue\n    }\n\n    if (end < 0) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension.\n      unmatchedSlash = true\n      end = index + 1\n    }\n\n    if (code === 46 /* `.` */) {\n      // If this is our first dot, mark it as the start of our extension.\n      if (startDot < 0) {\n        startDot = index\n      } else if (preDotState !== 1) {\n        preDotState = 1\n      }\n    } else if (startDot > -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension.\n      preDotState = -1\n    }\n  }\n\n  if (\n    startDot < 0 ||\n    end < 0 ||\n    // We saw a non-dot character immediately before the dot.\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly `..`.\n    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)\n  ) {\n    return ''\n  }\n\n  return path.slice(startDot, end)\n}\n\n/**\n * Join segments from a path.\n *\n * @param {Array<string>} segments\n *   Path segments.\n * @returns {string}\n *   File path.\n */\nfunction join(...segments) {\n  let index = -1\n  /** @type {string | undefined} */\n  let joined\n\n  while (++index < segments.length) {\n    assertPath(segments[index])\n\n    if (segments[index]) {\n      joined =\n        joined === undefined ? segments[index] : joined + '/' + segments[index]\n    }\n  }\n\n  return joined === undefined ? '.' : normalize(joined)\n}\n\n/**\n * Normalize a basic file path.\n *\n * @param {string} path\n *   File path.\n * @returns {string}\n *   File path.\n */\n// Note: `normalize` is not exposed as `path.normalize`, so some code is\n// manually removed from it.\nfunction normalize(path) {\n  assertPath(path)\n\n  const absolute = path.codePointAt(0) === 47 /* `/` */\n\n  // Normalize the path according to POSIX rules.\n  let value = normalizeString(path, !absolute)\n\n  if (value.length === 0 && !absolute) {\n    value = '.'\n  }\n\n  if (value.length > 0 && path.codePointAt(path.length - 1) === 47 /* / */) {\n    value += '/'\n  }\n\n  return absolute ? '/' + value : value\n}\n\n/**\n * Resolve `.` and `..` elements in a path with directory names.\n *\n * @param {string} path\n *   File path.\n * @param {boolean} allowAboveRoot\n *   Whether `..` can move above root.\n * @returns {string}\n *   File path.\n */\nfunction normalizeString(path, allowAboveRoot) {\n  let result = ''\n  let lastSegmentLength = 0\n  let lastSlash = -1\n  let dots = 0\n  let index = -1\n  /** @type {number | undefined} */\n  let code\n  /** @type {number} */\n  let lastSlashIndex\n\n  while (++index <= path.length) {\n    if (index < path.length) {\n      code = path.codePointAt(index)\n    } else if (code === 47 /* `/` */) {\n      break\n    } else {\n      code = 47 /* `/` */\n    }\n\n    if (code === 47 /* `/` */) {\n      if (lastSlash === index - 1 || dots === 1) {\n        // Empty.\n      } else if (lastSlash !== index - 1 && dots === 2) {\n        if (\n          result.length < 2 ||\n          lastSegmentLength !== 2 ||\n          result.codePointAt(result.length - 1) !== 46 /* `.` */ ||\n          result.codePointAt(result.length - 2) !== 46 /* `.` */\n        ) {\n          if (result.length > 2) {\n            lastSlashIndex = result.lastIndexOf('/')\n\n            if (lastSlashIndex !== result.length - 1) {\n              if (lastSlashIndex < 0) {\n                result = ''\n                lastSegmentLength = 0\n              } else {\n                result = result.slice(0, lastSlashIndex)\n                lastSegmentLength = result.length - 1 - result.lastIndexOf('/')\n              }\n\n              lastSlash = index\n              dots = 0\n              continue\n            }\n          } else if (result.length > 0) {\n            result = ''\n            lastSegmentLength = 0\n            lastSlash = index\n            dots = 0\n            continue\n          }\n        }\n\n        if (allowAboveRoot) {\n          result = result.length > 0 ? result + '/..' : '..'\n          lastSegmentLength = 2\n        }\n      } else {\n        if (result.length > 0) {\n          result += '/' + path.slice(lastSlash + 1, index)\n        } else {\n          result = path.slice(lastSlash + 1, index)\n        }\n\n        lastSegmentLength = index - lastSlash - 1\n      }\n\n      lastSlash = index\n      dots = 0\n    } else if (code === 46 /* `.` */ && dots > -1) {\n      dots++\n    } else {\n      dots = -1\n    }\n  }\n\n  return result\n}\n\n/**\n * Make sure `path` is a string.\n *\n * @param {string} path\n *   File path.\n * @returns {asserts path is string}\n *   Nothing.\n */\nfunction assertPath(path) {\n  if (typeof path !== 'string') {\n    throw new TypeError(\n      'Path must be a string. Received ' + JSON.stringify(path)\n    )\n  }\n}\n\n/* eslint-enable max-depth, complexity */\n","// Somewhat based on:\n// <https://github.com/defunctzombie/node-process/blob/master/browser.js>.\n// But I don’t think one tiny line of code can be copyrighted. 😅\nexport const minproc = {cwd}\n\nfunction cwd() {\n  return '/'\n}\n","/**\n * Checks if a value has the shape of a WHATWG URL object.\n *\n * Using a symbol or instanceof would not be able to recognize URL objects\n * coming from other implementations (e.g. in Electron), so instead we are\n * checking some well known properties for a lack of a better test.\n *\n * We use `href` and `protocol` as they are the only properties that are\n * easy to retrieve and calculate due to the lazy nature of the getters.\n *\n * We check for auth attribute to distinguish legacy url instance with\n * WHATWG URL instance.\n *\n * @param {unknown} fileUrlOrPath\n *   File path or URL.\n * @returns {fileUrlOrPath is URL}\n *   Whether it’s a URL.\n */\n// From: <https://github.com/nodejs/node/blob/6a3403c/lib/internal/url.js#L720>\nexport function isUrl(fileUrlOrPath) {\n  return Boolean(\n    fileUrlOrPath !== null &&\n      typeof fileUrlOrPath === 'object' &&\n      'href' in fileUrlOrPath &&\n      fileUrlOrPath.href &&\n      'protocol' in fileUrlOrPath &&\n      fileUrlOrPath.protocol &&\n      // @ts-expect-error: indexing is fine.\n      fileUrlOrPath.auth === undefined\n  )\n}\n","import {isUrl} from './minurl.shared.js'\n\nexport {isUrl} from './minurl.shared.js'\n\n// See: <https://github.com/nodejs/node/blob/6a3403c/lib/internal/url.js>\n\n/**\n * @param {URL | string} path\n *   File URL.\n * @returns {string}\n *   File URL.\n */\nexport function urlToPath(path) {\n  if (typeof path === 'string') {\n    path = new URL(path)\n  } else if (!isUrl(path)) {\n    /** @type {NodeJS.ErrnoException} */\n    const error = new TypeError(\n      'The \"path\" argument must be of type string or an instance of URL. Received `' +\n        path +\n        '`'\n    )\n    error.code = 'ERR_INVALID_ARG_TYPE'\n    throw error\n  }\n\n  if (path.protocol !== 'file:') {\n    /** @type {NodeJS.ErrnoException} */\n    const error = new TypeError('The URL must be of scheme file')\n    error.code = 'ERR_INVALID_URL_SCHEME'\n    throw error\n  }\n\n  return getPathFromURLPosix(path)\n}\n\n/**\n * Get a path from a POSIX URL.\n *\n * @param {URL} url\n *   URL.\n * @returns {string}\n *   File path.\n */\nfunction getPathFromURLPosix(url) {\n  if (url.hostname !== '') {\n    /** @type {NodeJS.ErrnoException} */\n    const error = new TypeError(\n      'File URL host must be \"localhost\" or empty on darwin'\n    )\n    error.code = 'ERR_INVALID_FILE_URL_HOST'\n    throw error\n  }\n\n  const pathname = url.pathname\n  let index = -1\n\n  while (++index < pathname.length) {\n    if (\n      pathname.codePointAt(index) === 37 /* `%` */ &&\n      pathname.codePointAt(index + 1) === 50 /* `2` */\n    ) {\n      const third = pathname.codePointAt(index + 2)\n      if (third === 70 /* `F` */ || third === 102 /* `f` */) {\n        /** @type {NodeJS.ErrnoException} */\n        const error = new TypeError(\n          'File URL path must not include encoded / characters'\n        )\n        error.code = 'ERR_INVALID_FILE_URL_PATH'\n        throw error\n      }\n    }\n  }\n\n  return decodeURIComponent(pathname)\n}\n","/**\n * @import {Node, Point, Position} from 'unist'\n * @import {Options as MessageOptions} from 'vfile-message'\n * @import {Compatible, Data, Map, Options, Value} from 'vfile'\n */\n\n/**\n * @typedef {object & {type: string, position?: Position | undefined}} NodeLike\n */\n\nimport {VFileMessage} from 'vfile-message'\nimport {minpath} from '#minpath'\nimport {minproc} from '#minproc'\nimport {urlToPath, isUrl} from '#minurl'\n\n/**\n * Order of setting (least specific to most), we need this because otherwise\n * `{stem: 'a', path: '~/b.js'}` would throw, as a path is needed before a\n * stem can be set.\n */\nconst order = /** @type {const} */ ([\n  'history',\n  'path',\n  'basename',\n  'stem',\n  'extname',\n  'dirname'\n])\n\nexport class VFile {\n  /**\n   * Create a new virtual file.\n   *\n   * `options` is treated as:\n   *\n   * *   `string` or `Uint8Array` — `{value: options}`\n   * *   `URL` — `{path: options}`\n   * *   `VFile` — shallow copies its data over to the new file\n   * *   `object` — all fields are shallow copied over to the new file\n   *\n   * Path related fields are set in the following order (least specific to\n   * most specific): `history`, `path`, `basename`, `stem`, `extname`,\n   * `dirname`.\n   *\n   * You cannot set `dirname` or `extname` without setting either `history`,\n   * `path`, `basename`, or `stem` too.\n   *\n   * @param {Compatible | null | undefined} [value]\n   *   File value.\n   * @returns\n   *   New instance.\n   */\n  constructor(value) {\n    /** @type {Options | VFile} */\n    let options\n\n    if (!value) {\n      options = {}\n    } else if (isUrl(value)) {\n      options = {path: value}\n    } else if (typeof value === 'string' || isUint8Array(value)) {\n      options = {value}\n    } else {\n      options = value\n    }\n\n    /* eslint-disable no-unused-expressions */\n\n    /**\n     * Base of `path` (default: `process.cwd()` or `'/'` in browsers).\n     *\n     * @type {string}\n     */\n    // Prevent calling `cwd` (which could be expensive) if it’s not needed;\n    // the empty string will be overridden in the next block.\n    this.cwd = 'cwd' in options ? '' : minproc.cwd()\n\n    /**\n     * Place to store custom info (default: `{}`).\n     *\n     * It’s OK to store custom data directly on the file but moving it to\n     * `data` is recommended.\n     *\n     * @type {Data}\n     */\n    this.data = {}\n\n    /**\n     * List of file paths the file moved between.\n     *\n     * The first is the original path and the last is the current path.\n     *\n     * @type {Array<string>}\n     */\n    this.history = []\n\n    /**\n     * List of messages associated with the file.\n     *\n     * @type {Array<VFileMessage>}\n     */\n    this.messages = []\n\n    /**\n     * Raw value.\n     *\n     * @type {Value}\n     */\n    this.value\n\n    // The below are non-standard, they are “well-known”.\n    // As in, used in several tools.\n    /**\n     * Source map.\n     *\n     * This type is equivalent to the `RawSourceMap` type from the `source-map`\n     * module.\n     *\n     * @type {Map | null | undefined}\n     */\n    this.map\n\n    /**\n     * Custom, non-string, compiled, representation.\n     *\n     * This is used by unified to store non-string results.\n     * One example is when turning markdown into React nodes.\n     *\n     * @type {unknown}\n     */\n    this.result\n\n    /**\n     * Whether a file was saved to disk.\n     *\n     * This is used by vfile reporters.\n     *\n     * @type {boolean}\n     */\n    this.stored\n    /* eslint-enable no-unused-expressions */\n\n    // Set path related properties in the correct order.\n    let index = -1\n\n    while (++index < order.length) {\n      const field = order[index]\n\n      // Note: we specifically use `in` instead of `hasOwnProperty` to accept\n      // `vfile`s too.\n      if (\n        field in options &&\n        options[field] !== undefined &&\n        options[field] !== null\n      ) {\n        // @ts-expect-error: TS doesn’t understand basic reality.\n        this[field] = field === 'history' ? [...options[field]] : options[field]\n      }\n    }\n\n    /** @type {string} */\n    let field\n\n    // Set non-path related properties.\n    for (field in options) {\n      // @ts-expect-error: fine to set other things.\n      if (!order.includes(field)) {\n        // @ts-expect-error: fine to set other things.\n        this[field] = options[field]\n      }\n    }\n  }\n\n  /**\n   * Get the basename (including extname) (example: `'index.min.js'`).\n   *\n   * @returns {string | undefined}\n   *   Basename.\n   */\n  get basename() {\n    return typeof this.path === 'string'\n      ? minpath.basename(this.path)\n      : undefined\n  }\n\n  /**\n   * Set basename (including extname) (`'index.min.js'`).\n   *\n   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n   * on windows).\n   * Cannot be nullified (use `file.path = file.dirname` instead).\n   *\n   * @param {string} basename\n   *   Basename.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  set basename(basename) {\n    assertNonEmpty(basename, 'basename')\n    assertPart(basename, 'basename')\n    this.path = minpath.join(this.dirname || '', basename)\n  }\n\n  /**\n   * Get the parent path (example: `'~'`).\n   *\n   * @returns {string | undefined}\n   *   Dirname.\n   */\n  get dirname() {\n    return typeof this.path === 'string'\n      ? minpath.dirname(this.path)\n      : undefined\n  }\n\n  /**\n   * Set the parent path (example: `'~'`).\n   *\n   * Cannot be set if there’s no `path` yet.\n   *\n   * @param {string | undefined} dirname\n   *   Dirname.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  set dirname(dirname) {\n    assertPath(this.basename, 'dirname')\n    this.path = minpath.join(dirname || '', this.basename)\n  }\n\n  /**\n   * Get the extname (including dot) (example: `'.js'`).\n   *\n   * @returns {string | undefined}\n   *   Extname.\n   */\n  get extname() {\n    return typeof this.path === 'string'\n      ? minpath.extname(this.path)\n      : undefined\n  }\n\n  /**\n   * Set the extname (including dot) (example: `'.js'`).\n   *\n   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n   * on windows).\n   * Cannot be set if there’s no `path` yet.\n   *\n   * @param {string | undefined} extname\n   *   Extname.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  set extname(extname) {\n    assertPart(extname, 'extname')\n    assertPath(this.dirname, 'extname')\n\n    if (extname) {\n      if (extname.codePointAt(0) !== 46 /* `.` */) {\n        throw new Error('`extname` must start with `.`')\n      }\n\n      if (extname.includes('.', 1)) {\n        throw new Error('`extname` cannot contain multiple dots')\n      }\n    }\n\n    this.path = minpath.join(this.dirname, this.stem + (extname || ''))\n  }\n\n  /**\n   * Get the full path (example: `'~/index.min.js'`).\n   *\n   * @returns {string}\n   *   Path.\n   */\n  get path() {\n    return this.history[this.history.length - 1]\n  }\n\n  /**\n   * Set the full path (example: `'~/index.min.js'`).\n   *\n   * Cannot be nullified.\n   * You can set a file URL (a `URL` object with a `file:` protocol) which will\n   * be turned into a path with `url.fileURLToPath`.\n   *\n   * @param {URL | string} path\n   *   Path.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  set path(path) {\n    if (isUrl(path)) {\n      path = urlToPath(path)\n    }\n\n    assertNonEmpty(path, 'path')\n\n    if (this.path !== path) {\n      this.history.push(path)\n    }\n  }\n\n  /**\n   * Get the stem (basename w/o extname) (example: `'index.min'`).\n   *\n   * @returns {string | undefined}\n   *   Stem.\n   */\n  get stem() {\n    return typeof this.path === 'string'\n      ? minpath.basename(this.path, this.extname)\n      : undefined\n  }\n\n  /**\n   * Set the stem (basename w/o extname) (example: `'index.min'`).\n   *\n   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n   * on windows).\n   * Cannot be nullified (use `file.path = file.dirname` instead).\n   *\n   * @param {string} stem\n   *   Stem.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  set stem(stem) {\n    assertNonEmpty(stem, 'stem')\n    assertPart(stem, 'stem')\n    this.path = minpath.join(this.dirname || '', stem + (this.extname || ''))\n  }\n\n  // Normal prototypal methods.\n  /**\n   * Create a fatal message for `reason` associated with the file.\n   *\n   * The `fatal` field of the message is set to `true` (error; file not usable)\n   * and the `file` field is set to the current file path.\n   * The message is added to the `messages` field on `file`.\n   *\n   * > 🪦 **Note**: also has obsolete signatures.\n   *\n   * @overload\n   * @param {string} reason\n   * @param {MessageOptions | null | undefined} [options]\n   * @returns {never}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @param {Error | VFileMessage | string} causeOrReason\n   *   Reason for message, should use markdown.\n   * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]\n   *   Configuration (optional).\n   * @param {string | null | undefined} [origin]\n   *   Place in code where the message originates (example:\n   *   `'my-package:my-rule'` or `'my-rule'`).\n   * @returns {never}\n   *   Never.\n   * @throws {VFileMessage}\n   *   Message.\n   */\n  fail(causeOrReason, optionsOrParentOrPlace, origin) {\n    // @ts-expect-error: the overloads are fine.\n    const message = this.message(causeOrReason, optionsOrParentOrPlace, origin)\n\n    message.fatal = true\n\n    throw message\n  }\n\n  /**\n   * Create an info message for `reason` associated with the file.\n   *\n   * The `fatal` field of the message is set to `undefined` (info; change\n   * likely not needed) and the `file` field is set to the current file path.\n   * The message is added to the `messages` field on `file`.\n   *\n   * > 🪦 **Note**: also has obsolete signatures.\n   *\n   * @overload\n   * @param {string} reason\n   * @param {MessageOptions | null | undefined} [options]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @param {Error | VFileMessage | string} causeOrReason\n   *   Reason for message, should use markdown.\n   * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]\n   *   Configuration (optional).\n   * @param {string | null | undefined} [origin]\n   *   Place in code where the message originates (example:\n   *   `'my-package:my-rule'` or `'my-rule'`).\n   * @returns {VFileMessage}\n   *   Message.\n   */\n  info(causeOrReason, optionsOrParentOrPlace, origin) {\n    // @ts-expect-error: the overloads are fine.\n    const message = this.message(causeOrReason, optionsOrParentOrPlace, origin)\n\n    message.fatal = undefined\n\n    return message\n  }\n\n  /**\n   * Create a message for `reason` associated with the file.\n   *\n   * The `fatal` field of the message is set to `false` (warning; change may be\n   * needed) and the `file` field is set to the current file path.\n   * The message is added to the `messages` field on `file`.\n   *\n   * > 🪦 **Note**: also has obsolete signatures.\n   *\n   * @overload\n   * @param {string} reason\n   * @param {MessageOptions | null | undefined} [options]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @param {Error | VFileMessage | string} causeOrReason\n   *   Reason for message, should use markdown.\n   * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]\n   *   Configuration (optional).\n   * @param {string | null | undefined} [origin]\n   *   Place in code where the message originates (example:\n   *   `'my-package:my-rule'` or `'my-rule'`).\n   * @returns {VFileMessage}\n   *   Message.\n   */\n  message(causeOrReason, optionsOrParentOrPlace, origin) {\n    const message = new VFileMessage(\n      // @ts-expect-error: the overloads are fine.\n      causeOrReason,\n      optionsOrParentOrPlace,\n      origin\n    )\n\n    if (this.path) {\n      message.name = this.path + ':' + message.name\n      message.file = this.path\n    }\n\n    message.fatal = false\n\n    this.messages.push(message)\n\n    return message\n  }\n\n  /**\n   * Serialize the file.\n   *\n   * > **Note**: which encodings are supported depends on the engine.\n   * > For info on Node.js, see:\n   * > <https://nodejs.org/api/util.html#whatwg-supported-encodings>.\n   *\n   * @param {string | null | undefined} [encoding='utf8']\n   *   Character encoding to understand `value` as when it’s a `Uint8Array`\n   *   (default: `'utf-8'`).\n   * @returns {string}\n   *   Serialized file.\n   */\n  toString(encoding) {\n    if (this.value === undefined) {\n      return ''\n    }\n\n    if (typeof this.value === 'string') {\n      return this.value\n    }\n\n    const decoder = new TextDecoder(encoding || undefined)\n    return decoder.decode(this.value)\n  }\n}\n\n/**\n * Assert that `part` is not a path (as in, does not contain `path.sep`).\n *\n * @param {string | null | undefined} part\n *   File path part.\n * @param {string} name\n *   Part name.\n * @returns {undefined}\n *   Nothing.\n */\nfunction assertPart(part, name) {\n  if (part && part.includes(minpath.sep)) {\n    throw new Error(\n      '`' + name + '` cannot be a path: did not expect `' + minpath.sep + '`'\n    )\n  }\n}\n\n/**\n * Assert that `part` is not empty.\n *\n * @param {string | undefined} part\n *   Thing.\n * @param {string} name\n *   Part name.\n * @returns {asserts part is string}\n *   Nothing.\n */\nfunction assertNonEmpty(part, name) {\n  if (!part) {\n    throw new Error('`' + name + '` cannot be empty')\n  }\n}\n\n/**\n * Assert `path` exists.\n *\n * @param {string | undefined} path\n *   Path.\n * @param {string} name\n *   Dependency name.\n * @returns {asserts path is string}\n *   Nothing.\n */\nfunction assertPath(path, name) {\n  if (!path) {\n    throw new Error('Setting `' + name + '` requires `path` to be set too')\n  }\n}\n\n/**\n * Assert `value` is an `Uint8Array`.\n *\n * @param {unknown} value\n *   thing.\n * @returns {value is Uint8Array}\n *   Whether `value` is an `Uint8Array`.\n */\nfunction isUint8Array(value) {\n  return Boolean(\n    value &&\n      typeof value === 'object' &&\n      'byteLength' in value &&\n      'byteOffset' in value\n  )\n}\n","export const CallableInstance =\n  /**\n   * @type {new <Parameters extends Array<unknown>, Result>(property: string | symbol) => (...parameters: Parameters) => Result}\n   */\n  (\n    /** @type {unknown} */\n    (\n      /**\n       * @this {Function}\n       * @param {string | symbol} property\n       * @returns {(...parameters: Array<unknown>) => unknown}\n       */\n      function (property) {\n        const self = this\n        const constr = self.constructor\n        const proto = /** @type {Record<string | symbol, Function>} */ (\n          // Prototypes do exist.\n          // type-coverage:ignore-next-line\n          constr.prototype\n        )\n        const value = proto[property]\n        /** @type {(...parameters: Array<unknown>) => unknown} */\n        const apply = function () {\n          return value.apply(apply, arguments)\n        }\n\n        Object.setPrototypeOf(apply, proto)\n\n        // Not needed for us in `unified`: we only call this on the `copy`\n        // function,\n        // and we don't need to add its fields (`length`, `name`)\n        // over.\n        // See also: GH-246.\n        // const names = Object.getOwnPropertyNames(value)\n        //\n        // for (const p of names) {\n        //   const descriptor = Object.getOwnPropertyDescriptor(value, p)\n        //   if (descriptor) Object.defineProperty(apply, p, descriptor)\n        // }\n\n        return apply\n      }\n    )\n  )\n","/**\n * @typedef {import('trough').Pipeline} Pipeline\n *\n * @typedef {import('unist').Node} Node\n *\n * @typedef {import('vfile').Compatible} Compatible\n * @typedef {import('vfile').Value} Value\n *\n * @typedef {import('../index.js').CompileResultMap} CompileResultMap\n * @typedef {import('../index.js').Data} Data\n * @typedef {import('../index.js').Settings} Settings\n */\n\n/**\n * @typedef {CompileResultMap[keyof CompileResultMap]} CompileResults\n *   Acceptable results from compilers.\n *\n *   To register custom results, add them to\n *   {@linkcode CompileResultMap}.\n */\n\n/**\n * @template {Node} [Tree=Node]\n *   The node that the compiler receives (default: `Node`).\n * @template {CompileResults} [Result=CompileResults]\n *   The thing that the compiler yields (default: `CompileResults`).\n * @callback Compiler\n *   A **compiler** handles the compiling of a syntax tree to something else\n *   (in most cases, text) (TypeScript type).\n *\n *   It is used in the stringify phase and called with a {@linkcode Node}\n *   and {@linkcode VFile} representation of the document to compile.\n *   It should return the textual representation of the given tree (typically\n *   `string`).\n *\n *   > **Note**: unified typically compiles by serializing: most compilers\n *   > return `string` (or `Uint8Array`).\n *   > Some compilers, such as the one configured with\n *   > [`rehype-react`][rehype-react], return other values (in this case, a\n *   > React tree).\n *   > If you’re using a compiler that doesn’t serialize, expect different\n *   > result values.\n *   >\n *   > To register custom results in TypeScript, add them to\n *   > {@linkcode CompileResultMap}.\n *\n *   [rehype-react]: https://github.com/rehypejs/rehype-react\n * @param {Tree} tree\n *   Tree to compile.\n * @param {VFile} file\n *   File associated with `tree`.\n * @returns {Result}\n *   New content: compiled text (`string` or `Uint8Array`, for `file.value`) or\n *   something else (for `file.result`).\n */\n\n/**\n * @template {Node} [Tree=Node]\n *   The node that the parser yields (default: `Node`)\n * @callback Parser\n *   A **parser** handles the parsing of text to a syntax tree.\n *\n *   It is used in the parse phase and is called with a `string` and\n *   {@linkcode VFile} of the document to parse.\n *   It must return the syntax tree representation of the given file\n *   ({@linkcode Node}).\n * @param {string} document\n *   Document to parse.\n * @param {VFile} file\n *   File associated with `document`.\n * @returns {Tree}\n *   Node representing the given file.\n */\n\n/**\n * @typedef {(\n *   Plugin<Array<any>, any, any> |\n *   PluginTuple<Array<any>, any, any> |\n *   Preset\n * )} Pluggable\n *   Union of the different ways to add plugins and settings.\n */\n\n/**\n * @typedef {Array<Pluggable>} PluggableList\n *   List of plugins and presets.\n */\n\n// Note: we can’t use `callback` yet as it messes up `this`:\n//  <https://github.com/microsoft/TypeScript/issues/55197>.\n/**\n * @template {Array<unknown>} [PluginParameters=[]]\n *   Arguments passed to the plugin (default: `[]`, the empty tuple).\n * @template {Node | string | undefined} [Input=Node]\n *   Value that is expected as input (default: `Node`).\n *\n *   *   If the plugin returns a {@linkcode Transformer}, this\n *       should be the node it expects.\n *   *   If the plugin sets a {@linkcode Parser}, this should be\n *       `string`.\n *   *   If the plugin sets a {@linkcode Compiler}, this should be the\n *       node it expects.\n * @template [Output=Input]\n *   Value that is yielded as output (default: `Input`).\n *\n *   *   If the plugin returns a {@linkcode Transformer}, this\n *       should be the node that that yields.\n *   *   If the plugin sets a {@linkcode Parser}, this should be the\n *       node that it yields.\n *   *   If the plugin sets a {@linkcode Compiler}, this should be\n *       result it yields.\n * @typedef {(\n *   (this: Processor, ...parameters: PluginParameters) =>\n *     Input extends string ? // Parser.\n *        Output extends Node | undefined ? undefined | void : never :\n *     Output extends CompileResults ? // Compiler.\n *        Input extends Node | undefined ? undefined | void : never :\n *     Transformer<\n *       Input extends Node ? Input : Node,\n *       Output extends Node ? Output : Node\n *     > | undefined | void\n * )} Plugin\n *   Single plugin.\n *\n *   Plugins configure the processors they are applied on in the following\n *   ways:\n *\n *   *   they change the processor, such as the parser, the compiler, or by\n *       configuring data\n *   *   they specify how to handle trees and files\n *\n *   In practice, they are functions that can receive options and configure the\n *   processor (`this`).\n *\n *   > **Note**: plugins are called when the processor is *frozen*, not when\n *   > they are applied.\n */\n\n/**\n * Tuple of a plugin and its configuration.\n *\n * The first item is a plugin, the rest are its parameters.\n *\n * @template {Array<unknown>} [TupleParameters=[]]\n *   Arguments passed to the plugin (default: `[]`, the empty tuple).\n * @template {Node | string | undefined} [Input=undefined]\n *   Value that is expected as input (optional).\n *\n *   *   If the plugin returns a {@linkcode Transformer}, this\n *       should be the node it expects.\n *   *   If the plugin sets a {@linkcode Parser}, this should be\n *       `string`.\n *   *   If the plugin sets a {@linkcode Compiler}, this should be the\n *       node it expects.\n * @template [Output=undefined] (optional).\n *   Value that is yielded as output.\n *\n *   *   If the plugin returns a {@linkcode Transformer}, this\n *       should be the node that that yields.\n *   *   If the plugin sets a {@linkcode Parser}, this should be the\n *       node that it yields.\n *   *   If the plugin sets a {@linkcode Compiler}, this should be\n *       result it yields.\n * @typedef {(\n *   [\n *     plugin: Plugin<TupleParameters, Input, Output>,\n *     ...parameters: TupleParameters\n *   ]\n * )} PluginTuple\n */\n\n/**\n * @typedef Preset\n *   Sharable configuration.\n *\n *   They can contain plugins and settings.\n * @property {PluggableList | undefined} [plugins]\n *   List of plugins and presets (optional).\n * @property {Settings | undefined} [settings]\n *   Shared settings for parsers and compilers (optional).\n */\n\n/**\n * @template {VFile} [File=VFile]\n *   The file that the callback receives (default: `VFile`).\n * @callback ProcessCallback\n *   Callback called when the process is done.\n *\n *   Called with either an error or a result.\n * @param {Error | undefined} [error]\n *   Fatal error (optional).\n * @param {File | undefined} [file]\n *   Processed file (optional).\n * @returns {undefined}\n *   Nothing.\n */\n\n/**\n * @template {Node} [Tree=Node]\n *   The tree that the callback receives (default: `Node`).\n * @callback RunCallback\n *   Callback called when transformers are done.\n *\n *   Called with either an error or results.\n * @param {Error | undefined} [error]\n *   Fatal error (optional).\n * @param {Tree | undefined} [tree]\n *   Transformed tree (optional).\n * @param {VFile | undefined} [file]\n *   File (optional).\n * @returns {undefined}\n *   Nothing.\n */\n\n/**\n * @template {Node} [Output=Node]\n *   Node type that the transformer yields (default: `Node`).\n * @callback TransformCallback\n *   Callback passed to transforms.\n *\n *   If the signature of a `transformer` accepts a third argument, the\n *   transformer may perform asynchronous operations, and must call it.\n * @param {Error | undefined} [error]\n *   Fatal error to stop the process (optional).\n * @param {Output | undefined} [tree]\n *   New, changed, tree (optional).\n * @param {VFile | undefined} [file]\n *   New, changed, file (optional).\n * @returns {undefined}\n *   Nothing.\n */\n\n/**\n * @template {Node} [Input=Node]\n *   Node type that the transformer expects (default: `Node`).\n * @template {Node} [Output=Input]\n *   Node type that the transformer yields (default: `Input`).\n * @callback Transformer\n *   Transformers handle syntax trees and files.\n *\n *   They are functions that are called each time a syntax tree and file are\n *   passed through the run phase.\n *   When an error occurs in them (either because it’s thrown, returned,\n *   rejected, or passed to `next`), the process stops.\n *\n *   The run phase is handled by [`trough`][trough], see its documentation for\n *   the exact semantics of these functions.\n *\n *   > **Note**: you should likely ignore `next`: don’t accept it.\n *   > it supports callback-style async work.\n *   > But promises are likely easier to reason about.\n *\n *   [trough]: https://github.com/wooorm/trough#function-fninput-next\n * @param {Input} tree\n *   Tree to handle.\n * @param {VFile} file\n *   File to handle.\n * @param {TransformCallback<Output>} next\n *   Callback.\n * @returns {(\n *   Promise<Output | undefined | void> |\n *   Promise<never> | // For some reason this is needed separately.\n *   Output |\n *   Error |\n *   undefined |\n *   void\n * )}\n *   If you accept `next`, nothing.\n *   Otherwise:\n *\n *   *   `Error` — fatal error to stop the process\n *   *   `Promise<undefined>` or `undefined` — the next transformer keeps using\n *       same tree\n *   *   `Promise<Node>` or `Node` — new, changed, tree\n */\n\n/**\n * @template {Node | undefined} ParseTree\n *   Output of `parse`.\n * @template {Node | undefined} HeadTree\n *   Input for `run`.\n * @template {Node | undefined} TailTree\n *   Output for `run`.\n * @template {Node | undefined} CompileTree\n *   Input of `stringify`.\n * @template {CompileResults | undefined} CompileResult\n *   Output of `stringify`.\n * @template {Node | string | undefined} Input\n *   Input of plugin.\n * @template Output\n *   Output of plugin (optional).\n * @typedef {(\n *   Input extends string\n *     ? Output extends Node | undefined\n *       ? // Parser.\n *         Processor<\n *           Output extends undefined ? ParseTree : Output,\n *           HeadTree,\n *           TailTree,\n *           CompileTree,\n *           CompileResult\n *         >\n *       : // Unknown.\n *         Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>\n *     : Output extends CompileResults\n *     ? Input extends Node | undefined\n *       ? // Compiler.\n *         Processor<\n *           ParseTree,\n *           HeadTree,\n *           TailTree,\n *           Input extends undefined ? CompileTree : Input,\n *           Output extends undefined ? CompileResult : Output\n *         >\n *       : // Unknown.\n *         Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>\n *     : Input extends Node | undefined\n *     ? Output extends Node | undefined\n *       ? // Transform.\n *         Processor<\n *           ParseTree,\n *           HeadTree extends undefined ? Input : HeadTree,\n *           Output extends undefined ? TailTree : Output,\n *           CompileTree,\n *           CompileResult\n *         >\n *       : // Unknown.\n *         Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>\n *     : // Unknown.\n *       Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>\n * )} UsePlugin\n *   Create a processor based on the input/output of a {@link Plugin plugin}.\n */\n\n/**\n * @template {CompileResults | undefined} Result\n *   Node type that the transformer yields.\n * @typedef {(\n *   Result extends Value | undefined ?\n *     VFile :\n *     VFile & {result: Result}\n *   )} VFileWithOutput\n *   Type to generate a {@linkcode VFile} corresponding to a compiler result.\n *\n *   If a result that is not acceptable on a `VFile` is used, that will\n *   be stored on the `result` field of {@linkcode VFile}.\n */\n\nimport {bail} from 'bail'\nimport extend from 'extend'\nimport {ok as assert} from 'devlop'\nimport isPlainObj from 'is-plain-obj'\nimport {trough} from 'trough'\nimport {VFile} from 'vfile'\nimport {CallableInstance} from './callable-instance.js'\n\n// To do: next major: drop `Compiler`, `Parser`: prefer lowercase.\n\n// To do: we could start yielding `never` in TS when a parser is missing and\n// `parse` is called.\n// Currently, we allow directly setting `processor.parser`, which is untyped.\n\nconst own = {}.hasOwnProperty\n\n/**\n * @template {Node | undefined} [ParseTree=undefined]\n *   Output of `parse` (optional).\n * @template {Node | undefined} [HeadTree=undefined]\n *   Input for `run` (optional).\n * @template {Node | undefined} [TailTree=undefined]\n *   Output for `run` (optional).\n * @template {Node | undefined} [CompileTree=undefined]\n *   Input of `stringify` (optional).\n * @template {CompileResults | undefined} [CompileResult=undefined]\n *   Output of `stringify` (optional).\n * @extends {CallableInstance<[], Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>>}\n */\nexport class Processor extends CallableInstance {\n  /**\n   * Create a processor.\n   */\n  constructor() {\n    // If `Processor()` is called (w/o new), `copy` is called instead.\n    super('copy')\n\n    /**\n     * Compiler to use (deprecated).\n     *\n     * @deprecated\n     *   Use `compiler` instead.\n     * @type {(\n     *   Compiler<\n     *     CompileTree extends undefined ? Node : CompileTree,\n     *     CompileResult extends undefined ? CompileResults : CompileResult\n     *   > |\n     *   undefined\n     * )}\n     */\n    this.Compiler = undefined\n\n    /**\n     * Parser to use (deprecated).\n     *\n     * @deprecated\n     *   Use `parser` instead.\n     * @type {(\n     *   Parser<ParseTree extends undefined ? Node : ParseTree> |\n     *   undefined\n     * )}\n     */\n    this.Parser = undefined\n\n    // Note: the following fields are considered private.\n    // However, they are needed for tests, and TSC generates an untyped\n    // `private freezeIndex` field for, which trips `type-coverage` up.\n    // Instead, we use `@deprecated` to visualize that they shouldn’t be used.\n    /**\n     * Internal list of configured plugins.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {Array<PluginTuple<Array<unknown>>>}\n     */\n    this.attachers = []\n\n    /**\n     * Compiler to use.\n     *\n     * @type {(\n     *   Compiler<\n     *     CompileTree extends undefined ? Node : CompileTree,\n     *     CompileResult extends undefined ? CompileResults : CompileResult\n     *   > |\n     *   undefined\n     * )}\n     */\n    this.compiler = undefined\n\n    /**\n     * Internal state to track where we are while freezing.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {number}\n     */\n    this.freezeIndex = -1\n\n    /**\n     * Internal state to track whether we’re frozen.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {boolean | undefined}\n     */\n    this.frozen = undefined\n\n    /**\n     * Internal state.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {Data}\n     */\n    this.namespace = {}\n\n    /**\n     * Parser to use.\n     *\n     * @type {(\n     *   Parser<ParseTree extends undefined ? Node : ParseTree> |\n     *   undefined\n     * )}\n     */\n    this.parser = undefined\n\n    /**\n     * Internal list of configured transformers.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {Pipeline}\n     */\n    this.transformers = trough()\n  }\n\n  /**\n   * Copy a processor.\n   *\n   * @deprecated\n   *   This is a private internal method and should not be used.\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *   New *unfrozen* processor ({@linkcode Processor}) that is\n   *   configured to work the same as its ancestor.\n   *   When the descendant processor is configured in the future it does not\n   *   affect the ancestral processor.\n   */\n  copy() {\n    // Cast as the type parameters will be the same after attaching.\n    const destination =\n      /** @type {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>} */ (\n        new Processor()\n      )\n    let index = -1\n\n    while (++index < this.attachers.length) {\n      const attacher = this.attachers[index]\n      destination.use(...attacher)\n    }\n\n    destination.data(extend(true, {}, this.namespace))\n\n    return destination\n  }\n\n  /**\n   * Configure the processor with info available to all plugins.\n   * Information is stored in an object.\n   *\n   * Typically, options can be given to a specific plugin, but sometimes it\n   * makes sense to have information shared with several plugins.\n   * For example, a list of HTML elements that are self-closing, which is\n   * needed during all phases.\n   *\n   * > **Note**: setting information cannot occur on *frozen* processors.\n   * > Call the processor first to create a new unfrozen processor.\n   *\n   * > **Note**: to register custom data in TypeScript, augment the\n   * > {@linkcode Data} interface.\n   *\n   * @example\n   *   This example show how to get and set info:\n   *\n   *   ```js\n   *   import {unified} from 'unified'\n   *\n   *   const processor = unified().data('alpha', 'bravo')\n   *\n   *   processor.data('alpha') // => 'bravo'\n   *\n   *   processor.data() // => {alpha: 'bravo'}\n   *\n   *   processor.data({charlie: 'delta'})\n   *\n   *   processor.data() // => {charlie: 'delta'}\n   *   ```\n   *\n   * @template {keyof Data} Key\n   *\n   * @overload\n   * @returns {Data}\n   *\n   * @overload\n   * @param {Data} dataset\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *\n   * @overload\n   * @param {Key} key\n   * @returns {Data[Key]}\n   *\n   * @overload\n   * @param {Key} key\n   * @param {Data[Key]} value\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *\n   * @param {Data | Key} [key]\n   *   Key to get or set, or entire dataset to set, or nothing to get the\n   *   entire dataset (optional).\n   * @param {Data[Key]} [value]\n   *   Value to set (optional).\n   * @returns {unknown}\n   *   The current processor when setting, the value at `key` when getting, or\n   *   the entire dataset when getting without key.\n   */\n  data(key, value) {\n    if (typeof key === 'string') {\n      // Set `key`.\n      if (arguments.length === 2) {\n        assertUnfrozen('data', this.frozen)\n        this.namespace[key] = value\n        return this\n      }\n\n      // Get `key`.\n      return (own.call(this.namespace, key) && this.namespace[key]) || undefined\n    }\n\n    // Set space.\n    if (key) {\n      assertUnfrozen('data', this.frozen)\n      this.namespace = key\n      return this\n    }\n\n    // Get space.\n    return this.namespace\n  }\n\n  /**\n   * Freeze a processor.\n   *\n   * Frozen processors are meant to be extended and not to be configured\n   * directly.\n   *\n   * When a processor is frozen it cannot be unfrozen.\n   * New processors working the same way can be created by calling the\n   * processor.\n   *\n   * It’s possible to freeze processors explicitly by calling `.freeze()`.\n   * Processors freeze automatically when `.parse()`, `.run()`, `.runSync()`,\n   * `.stringify()`, `.process()`, or `.processSync()` are called.\n   *\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *   The current processor.\n   */\n  freeze() {\n    if (this.frozen) {\n      return this\n    }\n\n    // Cast so that we can type plugins easier.\n    // Plugins are supposed to be usable on different processors, not just on\n    // this exact processor.\n    const self = /** @type {Processor} */ (/** @type {unknown} */ (this))\n\n    while (++this.freezeIndex < this.attachers.length) {\n      const [attacher, ...options] = this.attachers[this.freezeIndex]\n\n      if (options[0] === false) {\n        continue\n      }\n\n      if (options[0] === true) {\n        options[0] = undefined\n      }\n\n      const transformer = attacher.call(self, ...options)\n\n      if (typeof transformer === 'function') {\n        this.transformers.use(transformer)\n      }\n    }\n\n    this.frozen = true\n    this.freezeIndex = Number.POSITIVE_INFINITY\n\n    return this\n  }\n\n  /**\n   * Parse text to a syntax tree.\n   *\n   * > **Note**: `parse` freezes the processor if not already *frozen*.\n   *\n   * > **Note**: `parse` performs the parse phase, not the run phase or other\n   * > phases.\n   *\n   * @param {Compatible | undefined} [file]\n   *   file to parse (optional); typically `string` or `VFile`; any value\n   *   accepted as `x` in `new VFile(x)`.\n   * @returns {ParseTree extends undefined ? Node : ParseTree}\n   *   Syntax tree representing `file`.\n   */\n  parse(file) {\n    this.freeze()\n    const realFile = vfile(file)\n    const parser = this.parser || this.Parser\n    assertParser('parse', parser)\n    return parser(String(realFile), realFile)\n  }\n\n  /**\n   * Process the given file as configured on the processor.\n   *\n   * > **Note**: `process` freezes the processor if not already *frozen*.\n   *\n   * > **Note**: `process` performs the parse, run, and stringify phases.\n   *\n   * @overload\n   * @param {Compatible | undefined} file\n   * @param {ProcessCallback<VFileWithOutput<CompileResult>>} done\n   * @returns {undefined}\n   *\n   * @overload\n   * @param {Compatible | undefined} [file]\n   * @returns {Promise<VFileWithOutput<CompileResult>>}\n   *\n   * @param {Compatible | undefined} [file]\n   *   File (optional); typically `string` or `VFile`]; any value accepted as\n   *   `x` in `new VFile(x)`.\n   * @param {ProcessCallback<VFileWithOutput<CompileResult>> | undefined} [done]\n   *   Callback (optional).\n   * @returns {Promise<VFile> | undefined}\n   *   Nothing if `done` is given.\n   *   Otherwise a promise, rejected with a fatal error or resolved with the\n   *   processed file.\n   *\n   *   The parsed, transformed, and compiled value is available at\n   *   `file.value` (see note).\n   *\n   *   > **Note**: unified typically compiles by serializing: most\n   *   > compilers return `string` (or `Uint8Array`).\n   *   > Some compilers, such as the one configured with\n   *   > [`rehype-react`][rehype-react], return other values (in this case, a\n   *   > React tree).\n   *   > If you’re using a compiler that doesn’t serialize, expect different\n   *   > result values.\n   *   >\n   *   > To register custom results in TypeScript, add them to\n   *   > {@linkcode CompileResultMap}.\n   *\n   *   [rehype-react]: https://github.com/rehypejs/rehype-react\n   */\n  process(file, done) {\n    const self = this\n\n    this.freeze()\n    assertParser('process', this.parser || this.Parser)\n    assertCompiler('process', this.compiler || this.Compiler)\n\n    return done ? executor(undefined, done) : new Promise(executor)\n\n    // Note: `void`s needed for TS.\n    /**\n     * @param {((file: VFileWithOutput<CompileResult>) => undefined | void) | undefined} resolve\n     * @param {(error: Error | undefined) => undefined | void} reject\n     * @returns {undefined}\n     */\n    function executor(resolve, reject) {\n      const realFile = vfile(file)\n      // Assume `ParseTree` (the result of the parser) matches `HeadTree` (the\n      // input of the first transform).\n      const parseTree =\n        /** @type {HeadTree extends undefined ? Node : HeadTree} */ (\n          /** @type {unknown} */ (self.parse(realFile))\n        )\n\n      self.run(parseTree, realFile, function (error, tree, file) {\n        if (error || !tree || !file) {\n          return realDone(error)\n        }\n\n        // Assume `TailTree` (the output of the last transform) matches\n        // `CompileTree` (the input of the compiler).\n        const compileTree =\n          /** @type {CompileTree extends undefined ? Node : CompileTree} */ (\n            /** @type {unknown} */ (tree)\n          )\n\n        const compileResult = self.stringify(compileTree, file)\n\n        if (looksLikeAValue(compileResult)) {\n          file.value = compileResult\n        } else {\n          file.result = compileResult\n        }\n\n        realDone(error, /** @type {VFileWithOutput<CompileResult>} */ (file))\n      })\n\n      /**\n       * @param {Error | undefined} error\n       * @param {VFileWithOutput<CompileResult> | undefined} [file]\n       * @returns {undefined}\n       */\n      function realDone(error, file) {\n        if (error || !file) {\n          reject(error)\n        } else if (resolve) {\n          resolve(file)\n        } else {\n          assert(done, '`done` is defined if `resolve` is not')\n          done(undefined, file)\n        }\n      }\n    }\n  }\n\n  /**\n   * Process the given file as configured on the processor.\n   *\n   * An error is thrown if asynchronous transforms are configured.\n   *\n   * > **Note**: `processSync` freezes the processor if not already *frozen*.\n   *\n   * > **Note**: `processSync` performs the parse, run, and stringify phases.\n   *\n   * @param {Compatible | undefined} [file]\n   *   File (optional); typically `string` or `VFile`; any value accepted as\n   *   `x` in `new VFile(x)`.\n   * @returns {VFileWithOutput<CompileResult>}\n   *   The processed file.\n   *\n   *   The parsed, transformed, and compiled value is available at\n   *   `file.value` (see note).\n   *\n   *   > **Note**: unified typically compiles by serializing: most\n   *   > compilers return `string` (or `Uint8Array`).\n   *   > Some compilers, such as the one configured with\n   *   > [`rehype-react`][rehype-react], return other values (in this case, a\n   *   > React tree).\n   *   > If you’re using a compiler that doesn’t serialize, expect different\n   *   > result values.\n   *   >\n   *   > To register custom results in TypeScript, add them to\n   *   > {@linkcode CompileResultMap}.\n   *\n   *   [rehype-react]: https://github.com/rehypejs/rehype-react\n   */\n  processSync(file) {\n    /** @type {boolean} */\n    let complete = false\n    /** @type {VFileWithOutput<CompileResult> | undefined} */\n    let result\n\n    this.freeze()\n    assertParser('processSync', this.parser || this.Parser)\n    assertCompiler('processSync', this.compiler || this.Compiler)\n\n    this.process(file, realDone)\n    assertDone('processSync', 'process', complete)\n    assert(result, 'we either bailed on an error or have a tree')\n\n    return result\n\n    /**\n     * @type {ProcessCallback<VFileWithOutput<CompileResult>>}\n     */\n    function realDone(error, file) {\n      complete = true\n      bail(error)\n      result = file\n    }\n  }\n\n  /**\n   * Run *transformers* on a syntax tree.\n   *\n   * > **Note**: `run` freezes the processor if not already *frozen*.\n   *\n   * > **Note**: `run` performs the run phase, not other phases.\n   *\n   * @overload\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} done\n   * @returns {undefined}\n   *\n   * @overload\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   * @param {Compatible | undefined} file\n   * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} done\n   * @returns {undefined}\n   *\n   * @overload\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   * @param {Compatible | undefined} [file]\n   * @returns {Promise<TailTree extends undefined ? Node : TailTree>}\n   *\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   *   Tree to transform and inspect.\n   * @param {(\n   *   RunCallback<TailTree extends undefined ? Node : TailTree> |\n   *   Compatible\n   * )} [file]\n   *   File associated with `node` (optional); any value accepted as `x` in\n   *   `new VFile(x)`.\n   * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} [done]\n   *   Callback (optional).\n   * @returns {Promise<TailTree extends undefined ? Node : TailTree> | undefined}\n   *   Nothing if `done` is given.\n   *   Otherwise, a promise rejected with a fatal error or resolved with the\n   *   transformed tree.\n   */\n  run(tree, file, done) {\n    assertNode(tree)\n    this.freeze()\n\n    const transformers = this.transformers\n\n    if (!done && typeof file === 'function') {\n      done = file\n      file = undefined\n    }\n\n    return done ? executor(undefined, done) : new Promise(executor)\n\n    // Note: `void`s needed for TS.\n    /**\n     * @param {(\n     *   ((tree: TailTree extends undefined ? Node : TailTree) => undefined | void) |\n     *   undefined\n     * )} resolve\n     * @param {(error: Error) => undefined | void} reject\n     * @returns {undefined}\n     */\n    function executor(resolve, reject) {\n      assert(\n        typeof file !== 'function',\n        '`file` can’t be a `done` anymore, we checked'\n      )\n      const realFile = vfile(file)\n      transformers.run(tree, realFile, realDone)\n\n      /**\n       * @param {Error | undefined} error\n       * @param {Node} outputTree\n       * @param {VFile} file\n       * @returns {undefined}\n       */\n      function realDone(error, outputTree, file) {\n        const resultingTree =\n          /** @type {TailTree extends undefined ? Node : TailTree} */ (\n            outputTree || tree\n          )\n\n        if (error) {\n          reject(error)\n        } else if (resolve) {\n          resolve(resultingTree)\n        } else {\n          assert(done, '`done` is defined if `resolve` is not')\n          done(undefined, resultingTree, file)\n        }\n      }\n    }\n  }\n\n  /**\n   * Run *transformers* on a syntax tree.\n   *\n   * An error is thrown if asynchronous transforms are configured.\n   *\n   * > **Note**: `runSync` freezes the processor if not already *frozen*.\n   *\n   * > **Note**: `runSync` performs the run phase, not other phases.\n   *\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   *   Tree to transform and inspect.\n   * @param {Compatible | undefined} [file]\n   *   File associated with `node` (optional); any value accepted as `x` in\n   *   `new VFile(x)`.\n   * @returns {TailTree extends undefined ? Node : TailTree}\n   *   Transformed tree.\n   */\n  runSync(tree, file) {\n    /** @type {boolean} */\n    let complete = false\n    /** @type {(TailTree extends undefined ? Node : TailTree) | undefined} */\n    let result\n\n    this.run(tree, file, realDone)\n\n    assertDone('runSync', 'run', complete)\n    assert(result, 'we either bailed on an error or have a tree')\n    return result\n\n    /**\n     * @type {RunCallback<TailTree extends undefined ? Node : TailTree>}\n     */\n    function realDone(error, tree) {\n      bail(error)\n      result = tree\n      complete = true\n    }\n  }\n\n  /**\n   * Compile a syntax tree.\n   *\n   * > **Note**: `stringify` freezes the processor if not already *frozen*.\n   *\n   * > **Note**: `stringify` performs the stringify phase, not the run phase\n   * > or other phases.\n   *\n   * @param {CompileTree extends undefined ? Node : CompileTree} tree\n   *   Tree to compile.\n   * @param {Compatible | undefined} [file]\n   *   File associated with `node` (optional); any value accepted as `x` in\n   *   `new VFile(x)`.\n   * @returns {CompileResult extends undefined ? Value : CompileResult}\n   *   Textual representation of the tree (see note).\n   *\n   *   > **Note**: unified typically compiles by serializing: most compilers\n   *   > return `string` (or `Uint8Array`).\n   *   > Some compilers, such as the one configured with\n   *   > [`rehype-react`][rehype-react], return other values (in this case, a\n   *   > React tree).\n   *   > If you’re using a compiler that doesn’t serialize, expect different\n   *   > result values.\n   *   >\n   *   > To register custom results in TypeScript, add them to\n   *   > {@linkcode CompileResultMap}.\n   *\n   *   [rehype-react]: https://github.com/rehypejs/rehype-react\n   */\n  stringify(tree, file) {\n    this.freeze()\n    const realFile = vfile(file)\n    const compiler = this.compiler || this.Compiler\n    assertCompiler('stringify', compiler)\n    assertNode(tree)\n\n    return compiler(tree, realFile)\n  }\n\n  /**\n   * Configure the processor to use a plugin, a list of usable values, or a\n   * preset.\n   *\n   * If the processor is already using a plugin, the previous plugin\n   * configuration is changed based on the options that are passed in.\n   * In other words, the plugin is not added a second time.\n   *\n   * > **Note**: `use` cannot be called on *frozen* processors.\n   * > Call the processor first to create a new unfrozen processor.\n   *\n   * @example\n   *   There are many ways to pass plugins to `.use()`.\n   *   This example gives an overview:\n   *\n   *   ```js\n   *   import {unified} from 'unified'\n   *\n   *   unified()\n   *     // Plugin with options:\n   *     .use(pluginA, {x: true, y: true})\n   *     // Passing the same plugin again merges configuration (to `{x: true, y: false, z: true}`):\n   *     .use(pluginA, {y: false, z: true})\n   *     // Plugins:\n   *     .use([pluginB, pluginC])\n   *     // Two plugins, the second with options:\n   *     .use([pluginD, [pluginE, {}]])\n   *     // Preset with plugins and settings:\n   *     .use({plugins: [pluginF, [pluginG, {}]], settings: {position: false}})\n   *     // Settings only:\n   *     .use({settings: {position: false}})\n   *   ```\n   *\n   * @template {Array<unknown>} [Parameters=[]]\n   * @template {Node | string | undefined} [Input=undefined]\n   * @template [Output=Input]\n   *\n   * @overload\n   * @param {Preset | null | undefined} [preset]\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *\n   * @overload\n   * @param {PluggableList} list\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *\n   * @overload\n   * @param {Plugin<Parameters, Input, Output>} plugin\n   * @param {...(Parameters | [boolean])} parameters\n   * @returns {UsePlugin<ParseTree, HeadTree, TailTree, CompileTree, CompileResult, Input, Output>}\n   *\n   * @param {PluggableList | Plugin | Preset | null | undefined} value\n   *   Usable value.\n   * @param {...unknown} parameters\n   *   Parameters, when a plugin is given as a usable value.\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *   Current processor.\n   */\n  use(value, ...parameters) {\n    const attachers = this.attachers\n    const namespace = this.namespace\n\n    assertUnfrozen('use', this.frozen)\n\n    if (value === null || value === undefined) {\n      // Empty.\n    } else if (typeof value === 'function') {\n      addPlugin(value, parameters)\n    } else if (typeof value === 'object') {\n      if (Array.isArray(value)) {\n        addList(value)\n      } else {\n        addPreset(value)\n      }\n    } else {\n      throw new TypeError('Expected usable value, not `' + value + '`')\n    }\n\n    return this\n\n    /**\n     * @param {Pluggable} value\n     * @returns {undefined}\n     */\n    function add(value) {\n      if (typeof value === 'function') {\n        addPlugin(value, [])\n      } else if (typeof value === 'object') {\n        if (Array.isArray(value)) {\n          const [plugin, ...parameters] =\n            /** @type {PluginTuple<Array<unknown>>} */ (value)\n          addPlugin(plugin, parameters)\n        } else {\n          addPreset(value)\n        }\n      } else {\n        throw new TypeError('Expected usable value, not `' + value + '`')\n      }\n    }\n\n    /**\n     * @param {Preset} result\n     * @returns {undefined}\n     */\n    function addPreset(result) {\n      if (!('plugins' in result) && !('settings' in result)) {\n        throw new Error(\n          'Expected usable value but received an empty preset, which is probably a mistake: presets typically come with `plugins` and sometimes with `settings`, but this has neither'\n        )\n      }\n\n      addList(result.plugins)\n\n      if (result.settings) {\n        namespace.settings = extend(true, namespace.settings, result.settings)\n      }\n    }\n\n    /**\n     * @param {PluggableList | null | undefined} plugins\n     * @returns {undefined}\n     */\n    function addList(plugins) {\n      let index = -1\n\n      if (plugins === null || plugins === undefined) {\n        // Empty.\n      } else if (Array.isArray(plugins)) {\n        while (++index < plugins.length) {\n          const thing = plugins[index]\n          add(thing)\n        }\n      } else {\n        throw new TypeError('Expected a list of plugins, not `' + plugins + '`')\n      }\n    }\n\n    /**\n     * @param {Plugin} plugin\n     * @param {Array<unknown>} parameters\n     * @returns {undefined}\n     */\n    function addPlugin(plugin, parameters) {\n      let index = -1\n      let entryIndex = -1\n\n      while (++index < attachers.length) {\n        if (attachers[index][0] === plugin) {\n          entryIndex = index\n          break\n        }\n      }\n\n      if (entryIndex === -1) {\n        attachers.push([plugin, ...parameters])\n      }\n      // Only set if there was at least a `primary` value, otherwise we’d change\n      // `arguments.length`.\n      else if (parameters.length > 0) {\n        let [primary, ...rest] = parameters\n        const currentPrimary = attachers[entryIndex][1]\n        if (isPlainObj(currentPrimary) && isPlainObj(primary)) {\n          primary = extend(true, currentPrimary, primary)\n        }\n\n        attachers[entryIndex] = [plugin, primary, ...rest]\n      }\n    }\n  }\n}\n\n// Note: this returns a *callable* instance.\n// That’s why it’s documented as a function.\n/**\n * Create a new processor.\n *\n * @example\n *   This example shows how a new processor can be created (from `remark`) and linked\n *   to **stdin**(4) and **stdout**(4).\n *\n *   ```js\n *   import process from 'node:process'\n *   import concatStream from 'concat-stream'\n *   import {remark} from 'remark'\n *\n *   process.stdin.pipe(\n *     concatStream(function (buf) {\n *       process.stdout.write(String(remark().processSync(buf)))\n *     })\n *   )\n *   ```\n *\n * @returns\n *   New *unfrozen* processor (`processor`).\n *\n *   This processor is configured to work the same as its ancestor.\n *   When the descendant processor is configured in the future it does not\n *   affect the ancestral processor.\n */\nexport const unified = new Processor().freeze()\n\n/**\n * Assert a parser is available.\n *\n * @param {string} name\n * @param {unknown} value\n * @returns {asserts value is Parser}\n */\nfunction assertParser(name, value) {\n  if (typeof value !== 'function') {\n    throw new TypeError('Cannot `' + name + '` without `parser`')\n  }\n}\n\n/**\n * Assert a compiler is available.\n *\n * @param {string} name\n * @param {unknown} value\n * @returns {asserts value is Compiler}\n */\nfunction assertCompiler(name, value) {\n  if (typeof value !== 'function') {\n    throw new TypeError('Cannot `' + name + '` without `compiler`')\n  }\n}\n\n/**\n * Assert the processor is not frozen.\n *\n * @param {string} name\n * @param {unknown} frozen\n * @returns {asserts frozen is false}\n */\nfunction assertUnfrozen(name, frozen) {\n  if (frozen) {\n    throw new Error(\n      'Cannot call `' +\n        name +\n        '` on a frozen processor.\\nCreate a new processor first, by calling it: use `processor()` instead of `processor`.'\n    )\n  }\n}\n\n/**\n * Assert `node` is a unist node.\n *\n * @param {unknown} node\n * @returns {asserts node is Node}\n */\nfunction assertNode(node) {\n  // `isPlainObj` unfortunately uses `any` instead of `unknown`.\n  // type-coverage:ignore-next-line\n  if (!isPlainObj(node) || typeof node.type !== 'string') {\n    throw new TypeError('Expected node, got `' + node + '`')\n    // Fine.\n  }\n}\n\n/**\n * Assert that `complete` is `true`.\n *\n * @param {string} name\n * @param {string} asyncName\n * @param {unknown} complete\n * @returns {asserts complete is true}\n */\nfunction assertDone(name, asyncName, complete) {\n  if (!complete) {\n    throw new Error(\n      '`' + name + '` finished async. Use `' + asyncName + '` instead'\n    )\n  }\n}\n\n/**\n * @param {Compatible | undefined} [value]\n * @returns {VFile}\n */\nfunction vfile(value) {\n  return looksLikeAVFile(value) ? value : new VFile(value)\n}\n\n/**\n * @param {Compatible | undefined} [value]\n * @returns {value is VFile}\n */\nfunction looksLikeAVFile(value) {\n  return Boolean(\n    value &&\n      typeof value === 'object' &&\n      'message' in value &&\n      'messages' in value\n  )\n}\n\n/**\n * @param {unknown} [value]\n * @returns {value is Value}\n */\nfunction looksLikeAValue(value) {\n  return typeof value === 'string' || isUint8Array(value)\n}\n\n/**\n * Assert `value` is an `Uint8Array`.\n *\n * @param {unknown} value\n *   thing.\n * @returns {value is Uint8Array}\n *   Whether `value` is an `Uint8Array`.\n */\nfunction isUint8Array(value) {\n  return Boolean(\n    value &&\n      typeof value === 'object' &&\n      'byteLength' in value &&\n      'byteOffset' in value\n  )\n}\n","// Register `Raw` in tree:\n/// <reference types=\"mdast-util-to-hast\" />\n\n/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Nodes} Nodes\n * @typedef {import('hast').Parents} Parents\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast-util-to-jsx-runtime').Components} JsxRuntimeComponents\n * @typedef {import('remark-rehype').Options} RemarkRehypeOptions\n * @typedef {import('unist-util-visit').BuildVisitor<Root>} Visitor\n * @typedef {import('unified').PluggableList} PluggableList\n */\n\n/**\n * @callback AllowElement\n *   Filter elements.\n * @param {Readonly<Element>} element\n *   Element to check.\n * @param {number} index\n *   Index of `element` in `parent`.\n * @param {Readonly<Parents> | undefined} parent\n *   Parent of `element`.\n * @returns {boolean | null | undefined}\n *   Whether to allow `element` (default: `false`).\n *\n * @typedef {Partial<JsxRuntimeComponents>} Components\n *   Map tag names to components.\n *\n * @typedef Deprecation\n *   Deprecation.\n * @property {string} from\n *   Old field.\n * @property {string} id\n *   ID in readme.\n * @property {keyof Options} [to]\n *   New field.\n *\n * @typedef Options\n *   Configuration.\n * @property {AllowElement | null | undefined} [allowElement]\n *   Filter elements (optional);\n *   `allowedElements` / `disallowedElements` is used first.\n * @property {ReadonlyArray<string> | null | undefined} [allowedElements]\n *   Tag names to allow (default: all tag names);\n *   cannot combine w/ `disallowedElements`.\n * @property {string | null | undefined} [children]\n *   Markdown.\n * @property {string | null | undefined} [className]\n *   Wrap in a `div` with this class name.\n * @property {Components | null | undefined} [components]\n *   Map tag names to components.\n * @property {ReadonlyArray<string> | null | undefined} [disallowedElements]\n *   Tag names to disallow (default: `[]`);\n *   cannot combine w/ `allowedElements`.\n * @property {PluggableList | null | undefined} [rehypePlugins]\n *   List of rehype plugins to use.\n * @property {PluggableList | null | undefined} [remarkPlugins]\n *   List of remark plugins to use.\n * @property {Readonly<RemarkRehypeOptions> | null | undefined} [remarkRehypeOptions]\n *   Options to pass through to `remark-rehype`.\n * @property {boolean | null | undefined} [skipHtml=false]\n *   Ignore HTML in markdown completely (default: `false`).\n * @property {boolean | null | undefined} [unwrapDisallowed=false]\n *   Extract (unwrap) what’s in disallowed elements (default: `false`);\n *   normally when say `strong` is not allowed, it and it’s children are dropped,\n *   with `unwrapDisallowed` the element itself is replaced by its children.\n * @property {UrlTransform | null | undefined} [urlTransform]\n *   Change URLs (default: `defaultUrlTransform`)\n *\n * @callback UrlTransform\n *   Transform all URLs.\n * @param {string} url\n *   URL.\n * @param {string} key\n *   Property name (example: `'href'`).\n * @param {Readonly<Element>} node\n *   Node.\n * @returns {string | null | undefined}\n *   Transformed URL (optional).\n */\n\nimport {unreachable} from 'devlop'\nimport {toJsxRuntime} from 'hast-util-to-jsx-runtime'\nimport {urlAttributes} from 'html-url-attributes'\n// @ts-expect-error: untyped.\nimport {Fragment, jsx, jsxs} from 'react/jsx-runtime'\nimport remarkParse from 'remark-parse'\nimport remarkRehype from 'remark-rehype'\nimport {unified} from 'unified'\nimport {visit} from 'unist-util-visit'\nimport {VFile} from 'vfile'\n\nconst changelog =\n  'https://github.com/remarkjs/react-markdown/blob/main/changelog.md'\n\n/** @type {PluggableList} */\nconst emptyPlugins = []\n/** @type {Readonly<RemarkRehypeOptions>} */\nconst emptyRemarkRehypeOptions = {allowDangerousHtml: true}\nconst safeProtocol = /^(https?|ircs?|mailto|xmpp)$/i\n\n// Mutable because we `delete` any time it’s used and a message is sent.\n/** @type {ReadonlyArray<Readonly<Deprecation>>} */\nconst deprecations = [\n  {from: 'astPlugins', id: 'remove-buggy-html-in-markdown-parser'},\n  {from: 'allowDangerousHtml', id: 'remove-buggy-html-in-markdown-parser'},\n  {\n    from: 'allowNode',\n    id: 'replace-allownode-allowedtypes-and-disallowedtypes',\n    to: 'allowElement'\n  },\n  {\n    from: 'allowedTypes',\n    id: 'replace-allownode-allowedtypes-and-disallowedtypes',\n    to: 'allowedElements'\n  },\n  {\n    from: 'disallowedTypes',\n    id: 'replace-allownode-allowedtypes-and-disallowedtypes',\n    to: 'disallowedElements'\n  },\n  {from: 'escapeHtml', id: 'remove-buggy-html-in-markdown-parser'},\n  {from: 'includeElementIndex', id: '#remove-includeelementindex'},\n  {\n    from: 'includeNodeIndex',\n    id: 'change-includenodeindex-to-includeelementindex'\n  },\n  {from: 'linkTarget', id: 'remove-linktarget'},\n  {from: 'plugins', id: 'change-plugins-to-remarkplugins', to: 'remarkPlugins'},\n  {from: 'rawSourcePos', id: '#remove-rawsourcepos'},\n  {from: 'renderers', id: 'change-renderers-to-components', to: 'components'},\n  {from: 'source', id: 'change-source-to-children', to: 'children'},\n  {from: 'sourcePos', id: '#remove-sourcepos'},\n  {from: 'transformImageUri', id: '#add-urltransform', to: 'urlTransform'},\n  {from: 'transformLinkUri', id: '#add-urltransform', to: 'urlTransform'}\n]\n\n/**\n * Component to render markdown.\n *\n * @param {Readonly<Options>} options\n *   Props.\n * @returns {JSX.Element}\n *   React element.\n */\nexport function Markdown(options) {\n  const allowedElements = options.allowedElements\n  const allowElement = options.allowElement\n  const children = options.children || ''\n  const className = options.className\n  const components = options.components\n  const disallowedElements = options.disallowedElements\n  const rehypePlugins = options.rehypePlugins || emptyPlugins\n  const remarkPlugins = options.remarkPlugins || emptyPlugins\n  const remarkRehypeOptions = options.remarkRehypeOptions\n    ? {...options.remarkRehypeOptions, ...emptyRemarkRehypeOptions}\n    : emptyRemarkRehypeOptions\n  const skipHtml = options.skipHtml\n  const unwrapDisallowed = options.unwrapDisallowed\n  const urlTransform = options.urlTransform || defaultUrlTransform\n\n  const processor = unified()\n    .use(remarkParse)\n    .use(remarkPlugins)\n    .use(remarkRehype, remarkRehypeOptions)\n    .use(rehypePlugins)\n\n  const file = new VFile()\n\n  if (typeof children === 'string') {\n    file.value = children\n  } else {\n    unreachable(\n      'Unexpected value `' +\n        children +\n        '` for `children` prop, expected `string`'\n    )\n  }\n\n  if (allowedElements && disallowedElements) {\n    unreachable(\n      'Unexpected combined `allowedElements` and `disallowedElements`, expected one or the other'\n    )\n  }\n\n  for (const deprecation of deprecations) {\n    if (Object.hasOwn(options, deprecation.from)) {\n      unreachable(\n        'Unexpected `' +\n          deprecation.from +\n          '` prop, ' +\n          (deprecation.to\n            ? 'use `' + deprecation.to + '` instead'\n            : 'remove it') +\n          ' (see <' +\n          changelog +\n          '#' +\n          deprecation.id +\n          '> for more info)'\n      )\n    }\n  }\n\n  const mdastTree = processor.parse(file)\n  /** @type {Nodes} */\n  let hastTree = processor.runSync(mdastTree, file)\n\n  // Wrap in `div` if there’s a class name.\n  if (className) {\n    hastTree = {\n      type: 'element',\n      tagName: 'div',\n      properties: {className},\n      // Assume no doctypes.\n      children: /** @type {Array<ElementContent>} */ (\n        hastTree.type === 'root' ? hastTree.children : [hastTree]\n      )\n    }\n  }\n\n  visit(hastTree, transform)\n\n  return toJsxRuntime(hastTree, {\n    Fragment,\n    components,\n    ignoreInvalidStyle: true,\n    jsx,\n    jsxs,\n    passKeys: true,\n    passNode: true\n  })\n\n  /** @type {Visitor} */\n  function transform(node, index, parent) {\n    if (node.type === 'raw' && parent && typeof index === 'number') {\n      if (skipHtml) {\n        parent.children.splice(index, 1)\n      } else {\n        parent.children[index] = {type: 'text', value: node.value}\n      }\n\n      return index\n    }\n\n    if (node.type === 'element') {\n      /** @type {string} */\n      let key\n\n      for (key in urlAttributes) {\n        if (\n          Object.hasOwn(urlAttributes, key) &&\n          Object.hasOwn(node.properties, key)\n        ) {\n          const value = node.properties[key]\n          const test = urlAttributes[key]\n          if (test === null || test.includes(node.tagName)) {\n            node.properties[key] = urlTransform(String(value || ''), key, node)\n          }\n        }\n      }\n    }\n\n    if (node.type === 'element') {\n      let remove = allowedElements\n        ? !allowedElements.includes(node.tagName)\n        : disallowedElements\n        ? disallowedElements.includes(node.tagName)\n        : false\n\n      if (!remove && allowElement && typeof index === 'number') {\n        remove = !allowElement(node, index, parent)\n      }\n\n      if (remove && parent && typeof index === 'number') {\n        if (unwrapDisallowed && node.children) {\n          parent.children.splice(index, 1, ...node.children)\n        } else {\n          parent.children.splice(index, 1)\n        }\n\n        return index\n      }\n    }\n  }\n}\n\n/**\n * Make a URL safe.\n *\n * @satisfies {UrlTransform}\n * @param {string} value\n *   URL.\n * @returns {string}\n *   Safe URL.\n */\nexport function defaultUrlTransform(value) {\n  // Same as:\n  // <https://github.com/micromark/micromark/blob/929275e/packages/micromark-util-sanitize-uri/dev/index.js#L34>\n  // But without the `encode` part.\n  const colon = value.indexOf(':')\n  const questionMark = value.indexOf('?')\n  const numberSign = value.indexOf('#')\n  const slash = value.indexOf('/')\n\n  if (\n    // If there is no protocol, it’s relative.\n    colon < 0 ||\n    // If the first colon is after a `?`, `#`, or `/`, it’s not a protocol.\n    (slash > -1 && colon > slash) ||\n    (questionMark > -1 && colon > questionMark) ||\n    (numberSign > -1 && colon > numberSign) ||\n    // It is a protocol, it should be allowed.\n    safeProtocol.test(value.slice(0, colon))\n  ) {\n    return value\n  }\n\n  return ''\n}\n","import React from 'react';\nimport { useParams } from 'react-router-dom';\nimport { allPosts } from './postsDist';\nimport ReactMarkdown from 'react-markdown';\n\nconst Post: React.FC = () => {\n  const { postId } = useParams<{ postId: string }>();\n  \n  console.log(\"NWM: postId\", postId);\n\n  if (postId && allPosts[postId as keyof typeof allPosts]) {\n    const { mdText, createdOn } = allPosts[postId as keyof typeof allPosts];\n    return (\n      <div className=\"text-start\">\n        <ReactMarkdown>{mdText}</ReactMarkdown>\n        <p className=\"text-muted mt-2\" style={{ fontSize: '1em' }}>\n          {new Date(createdOn).toLocaleDateString()}\n        </p>\n      </div>\n    );\n  }\n\n  if (postId === \"\" || postId === undefined) {\n    return (\n      <div className=\"text-start\">\n        <ReactMarkdown>{allPosts[\"index\" as keyof typeof allPosts].mdText}</ReactMarkdown>\n      </div>\n    );\n  }\n\n  return <h1>Post not found</h1>;\n};\n\nexport default Post;","/* Given an object like this:\n\"on-quadratic-complexity\": {\n    \"title\": \"On quadratic complexity\",\n    \"createdOn\": \"2022-05-29 16:33:06.774955\",\n    \"mdText\": \"## On quadratic complexity\\n\\nMany algorithms have quadratic complexity: sometimes this is necessary, but [often it's not](https://accidentallyquadratic.tumblr.com/). This and related facts are widely known but underappreciated. Quadratic complexity is a more pervasive phenomenon, and explains more other phenomena, than is generally recognized.\\n\\n#### Quadratic complexity is everywhere\\n\\nIt often happens that you need to track some pairwise relationship for all pairs of objects in some set. These situations are more easily perceived when the objects are elements of an array. Sometimes, though, the objects are the components of a software system: here, \\\"gluing\\\" those components together generates tasks that are [quadratic in the number of components you have](https://www.oreilly.com/radar/thinking-about-glue/).\\n\\nWithin a component, one often sees quadratic complexity at higher levels than arrays. This is one reason it's so important to model your domain correctly: if, for example, you make something a property of *A* when it should be a property of *B*, the penalty is often that operations that formerly required checking all the *A*s _or_ all the *B*s now require checking all the *A*s _and_ all the *B*s. You're paying a quadratic cost across a larger domain. (Also, your code tends to be harder to reason about, because it's harder for your brain to invoke some hodgepodge of intuitions about *A* and *B* than either one individually--but that's a separate issue.)\\n\\n#### Quadratic complexity can explain other things\\n\\nWe do (and ought to!) think about how fast exponential growth happens, but we sometimes forget that quadratic growth is pretty fast too. Think about an old riddle: suppose the scum on the surface of a pond doubles every day (growing exponentially), and at the end of April it covers the whole pond. When did it cover only 1/4 of the pond? April 28, two days before the end of the month.\\n\\nSuppose the scum is growing quadratically: then, on the 28th, it's about 87% full. That's way more than a quarter, but less than intuition might first suggest.\\n\\nIf you're programming, and need to keep track of all the pairwise relationships in a set of items, it matters a lot whether that set has four or five things in it: that's the difference between 6 and 10 pairwise relationships. Whatever you think of the research about [short-term memory](https://en.wikipedia.org/wiki/The_Magical_Number_Seven,_Plus_or_Minus_Two), 10 is a lot bigger than 6 as far as your \\\"active brain\\\" is concerned.\\n\\nThis can explain why getting stuck in programming can feel (i) so sudden and (ii) so intractable. At least sometimes, \\\"why is this so hard to reason about now when it wasn't a minute ago\\\" is answerable with: \\\"because those two extra things you added generated another couple dozen relations (or cases to check or failure modes).\\\"\\n\\nIf you've ever wondered why [Norris's number](https://www.johndcook.com/blog/2011/11/22/norris-number/) exists: look here, perhaps.\\n\"\n  },\n  make a simple React component that displays the title and date of the post.\n  It should be a simple component that uses Bootstrap.\n*/\n\nimport React from \"react\";\nimport 'bootstrap/dist/css/bootstrap.min.css';\nimport { Post } from \"../objects/Post\";\n\nexport default function PostCard({ post, urlSuffix }: { post: Post, urlSuffix: string }) {\n  return (\n    <a href={urlSuffix} className=\"card\" style={{ width: '48rem', textDecoration: 'none', color: 'inherit' }}>\n      <div className=\"card-body\">\n        <h5 className=\"card-title\">{post.title}</h5>\n        <h6 className=\"card-subtitle mb-2 text-muted\">{new Date(post.createdOn).toLocaleDateString()}</h6>\n      </div>\n    </a>\n  );\n}\n","import React, { useState } from 'react';\nimport ReactMarkdown from 'react-markdown';\nimport { allPosts } from '../postsDist';\nimport PostCard from './PostCard';\n\nexport default function Home() {\n    const [searchTerm, setSearchTerm] = useState('');\n\n    const handleSearchChange = (event: React.ChangeEvent<HTMLInputElement>) => {\n        setSearchTerm(event.target.value);\n    };\n\n    const filteredPosts = Object.entries(allPosts).filter(([key, post]) =>\n        post.title.toLowerCase().trim().includes(searchTerm.toLowerCase().trim())\n    );\n\n    return (\n      <div className=\"text-start\">\n        <ReactMarkdown>{allPosts[\"index\"]?.mdText}</ReactMarkdown>\n        <div className=\"mb-3\">\n          <h3>All my posts</h3>\n          <label htmlFor=\"search\" className=\"form-label\">Filter by title (optional)</label>\n          <input\n            type=\"text\"\n            className=\"form-control\"\n            id=\"search\"\n            placeholder=\"Enter post title\"\n            value={searchTerm}\n            onChange={handleSearchChange}\n          />\n        </div>\n        {filteredPosts.map(([key, post], index) => (\n          <PostCard key={index} post={post} urlSuffix={`/${key}`} />\n        ))}\n      </div>\n    );\n}","import React from 'react';\nimport { BrowserRouter, Routes, Route } from 'react-router-dom';\nimport { Navbar, Nav, Container } from 'react-bootstrap';\nimport './App.css';\nimport About from './About';\nimport 'bootstrap/dist/css/bootstrap.min.css';\nimport Post from './Post';\nimport Home from './components/Home';\n\nfunction App() {\n  return (\n    <BrowserRouter>\n      <div className=\"App\">\n        <Navbar bg=\"dark\" variant=\"dark\" expand=\"lg\">\n          <Container>\n            <Navbar.Brand href=\"/\">Nate Meyvis</Navbar.Brand>\n            <Navbar.Toggle aria-controls=\"basic-navbar-nav\" />\n            <Navbar.Collapse id=\"basic-navbar-nav\">\n              <Nav className=\"me-auto\">\n                <Nav.Link href=\"/\">Home</Nav.Link>\n              </Nav>\n            </Navbar.Collapse>\n          </Container>\n        </Navbar>\n\n        <Container className=\"mt-4\">\n          <Routes>\n            <Route path=\"/\" element={<Home />} />\n            <Route path=\"/about\" element={<About />} />\n            <Route path=\"/:postId\" element={<Post />} />\n            <Route path=\"/:postId.html\" element={<Post />} />\n          </Routes>\n        </Container>\n      </div>\n    </BrowserRouter>\n  );\n}\n\nexport default App;\n","const reportWebVitals = onPerfEntry => {\n  if (onPerfEntry && onPerfEntry instanceof Function) {\n    import('web-vitals').then(({ getCLS, getFID, getFCP, getLCP, getTTFB }) => {\n      getCLS(onPerfEntry);\n      getFID(onPerfEntry);\n      getFCP(onPerfEntry);\n      getLCP(onPerfEntry);\n      getTTFB(onPerfEntry);\n    });\n  }\n};\n\nexport default reportWebVitals;\n","import React from 'react';\nimport ReactDOM from 'react-dom/client';\nimport './index.css';\nimport App from './App';\nimport reportWebVitals from './reportWebVitals';\n\nconst root = ReactDOM.createRoot(document.getElementById('root') as HTMLElement);\nroot.render(\n  <React.StrictMode>\n    <App />\n  </React.StrictMode>\n);\n\nreportWebVitals(); "],"names":["hasOwn","Object","prototype","hasOwnProperty","toStr","toString","defineProperty","gOPD","getOwnPropertyDescriptor","isArray","arr","Array","call","isPlainObject","obj","key","hasOwnConstructor","hasIsPrototypeOf","constructor","setProperty","target","options","name","enumerable","configurable","value","newValue","writable","getProperty","module","exports","extend","src","copy","copyIsArray","clone","arguments","i","length","deep","COMMENT_REGEX","NEWLINE_REGEX","WHITESPACE_REGEX","PROPERTY_REGEX","COLON_REGEX","VALUE_REGEX","SEMICOLON_REGEX","TRIM_REGEX","EMPTY_STRING","trim","str","replace","style","TypeError","lineno","column","updatePosition","lines","match","lastIndexOf","position","start","line","node","Position","whitespace","this","end","source","content","errorsList","error","msg","err","Error","reason","filename","silent","push","re","m","exec","slice","comments","rules","c","comment","pos","charAt","type","declaration","prop","val","ret","property","decl","decls","declarations","condition","format","a","b","d","e","f","undefined","args","argIndex","framesToPop","_len","validators","_key","_createChainableTypeChecker2","default","_len2","_key2","forEach","validator","result","apply","_createChainableTypeChecker","require","__esModule","validate","checkType","isRequired","props","propName","componentName","location","propFullName","componentNameSafe","propFullNameSafe","concat","chainedCheckType","bind","ReactPropTypesSecret","emptyFunction","emptyFunctionWithReset","resetWarningCache","shim","secret","getShim","ReactPropTypes","array","bigint","bool","func","number","object","string","symbol","any","arrayOf","element","elementType","instanceOf","objectOf","oneOf","oneOfType","shape","exact","checkPropTypes","PropTypes","aa","ca","p","encodeURIComponent","da","Set","ea","fa","ha","add","ia","window","document","createElement","ja","ka","la","ma","v","g","acceptsBooleans","attributeName","attributeNamespace","mustUseProperty","propertyName","sanitizeURL","removeEmptyString","z","split","toLowerCase","ra","sa","toUpperCase","ta","pa","isNaN","qa","test","oa","removeAttribute","setAttribute","setAttributeNS","xlinkHref","ua","__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED","va","Symbol","for","wa","ya","za","Aa","Ba","Ca","Da","Ea","Fa","Ga","Ha","Ia","Ja","iterator","Ka","La","A","assign","Ma","stack","Na","Oa","prepareStackTrace","set","Reflect","construct","l","h","k","displayName","includes","Pa","tag","render","Qa","$$typeof","_context","_payload","_init","Ra","Sa","Ta","nodeName","Va","_valueTracker","get","getValue","setValue","stopTracking","Ua","Wa","checked","Xa","activeElement","body","Ya","defaultChecked","defaultValue","_wrapperState","initialChecked","Za","initialValue","controlled","ab","bb","cb","db","ownerDocument","eb","fb","selected","defaultSelected","disabled","gb","dangerouslySetInnerHTML","children","hb","ib","jb","textContent","kb","lb","mb","nb","namespaceURI","innerHTML","valueOf","firstChild","removeChild","appendChild","MSApp","execUnsafeLocalFunction","ob","lastChild","nodeType","nodeValue","pb","animationIterationCount","aspectRatio","borderImageOutset","borderImageSlice","borderImageWidth","boxFlex","boxFlexGroup","boxOrdinalGroup","columnCount","columns","flex","flexGrow","flexPositive","flexShrink","flexNegative","flexOrder","gridArea","gridRow","gridRowEnd","gridRowSpan","gridRowStart","gridColumn","gridColumnEnd","gridColumnSpan","gridColumnStart","fontWeight","lineClamp","lineHeight","opacity","order","orphans","tabSize","widows","zIndex","zoom","fillOpacity","floodOpacity","stopOpacity","strokeDasharray","strokeDashoffset","strokeMiterlimit","strokeOpacity","strokeWidth","qb","rb","sb","indexOf","keys","substring","tb","menuitem","area","base","br","col","embed","hr","img","input","keygen","link","meta","param","track","wbr","ub","vb","is","wb","xb","srcElement","correspondingUseElement","parentNode","yb","zb","Ab","Bb","Cb","stateNode","Db","Eb","Fb","Gb","Hb","Ib","Jb","Kb","Lb","Mb","addEventListener","removeEventListener","Nb","onError","Ob","Pb","Qb","Rb","Sb","Tb","Vb","alternate","return","flags","Wb","memoizedState","dehydrated","Xb","Zb","child","sibling","current","Yb","$b","ac","unstable_scheduleCallback","bc","unstable_cancelCallback","cc","unstable_shouldYield","dc","unstable_requestPaint","B","unstable_now","ec","unstable_getCurrentPriorityLevel","fc","unstable_ImmediatePriority","gc","unstable_UserBlockingPriority","hc","unstable_NormalPriority","ic","unstable_LowPriority","jc","unstable_IdlePriority","kc","lc","oc","Math","clz32","pc","qc","log","LN2","rc","sc","tc","uc","pendingLanes","suspendedLanes","pingedLanes","entangledLanes","entanglements","vc","xc","yc","zc","Ac","eventTimes","Cc","C","Dc","Ec","Fc","Gc","Hc","Ic","Jc","Kc","Lc","Mc","Nc","Oc","Map","Pc","Qc","Rc","Sc","delete","pointerId","Tc","nativeEvent","blockedOn","domEventName","eventSystemFlags","targetContainers","Vc","Wc","priority","isDehydrated","containerInfo","Xc","Yc","dispatchEvent","shift","Zc","$c","ad","bd","cd","ReactCurrentBatchConfig","dd","ed","transition","fd","gd","hd","id","Uc","stopPropagation","jd","kd","ld","md","nd","od","keyCode","charCode","pd","qd","rd","_reactName","_targetInst","currentTarget","isDefaultPrevented","defaultPrevented","returnValue","isPropagationStopped","preventDefault","cancelBubble","persist","isPersistent","wd","xd","yd","sd","eventPhase","bubbles","cancelable","timeStamp","Date","now","isTrusted","td","ud","view","detail","vd","Ad","screenX","screenY","clientX","clientY","pageX","pageY","ctrlKey","shiftKey","altKey","metaKey","getModifierState","zd","button","buttons","relatedTarget","fromElement","toElement","movementX","movementY","Bd","Dd","dataTransfer","Fd","Hd","animationName","elapsedTime","pseudoElement","Id","clipboardData","Jd","Ld","data","Md","Esc","Spacebar","Left","Up","Right","Down","Del","Win","Menu","Apps","Scroll","MozPrintableKey","Nd","Od","Alt","Control","Meta","Shift","Pd","Qd","String","fromCharCode","code","repeat","locale","which","Rd","Td","width","height","pressure","tangentialPressure","tiltX","tiltY","twist","pointerType","isPrimary","Vd","touches","targetTouches","changedTouches","Xd","Yd","deltaX","wheelDeltaX","deltaY","wheelDeltaY","wheelDelta","deltaZ","deltaMode","Zd","$d","ae","be","documentMode","ce","de","ee","fe","ge","he","ie","le","color","date","datetime","email","month","password","range","search","tel","text","time","url","week","me","ne","oe","event","listeners","pe","qe","se","te","ue","ve","we","xe","ye","ze","oninput","Ae","detachEvent","Be","Ce","attachEvent","De","Ee","Fe","He","Ie","Je","Ke","offset","nextSibling","Le","contains","compareDocumentPosition","Me","HTMLIFrameElement","contentWindow","href","Ne","contentEditable","Oe","focusedElem","selectionRange","documentElement","selectionStart","selectionEnd","min","defaultView","getSelection","rangeCount","anchorNode","anchorOffset","focusNode","focusOffset","createRange","setStart","removeAllRanges","addRange","setEnd","left","scrollLeft","top","scrollTop","focus","Pe","Qe","Re","Se","Te","Ue","Ve","We","animationend","animationiteration","animationstart","transitionend","Xe","Ye","Ze","animation","$e","af","bf","cf","df","ef","ff","gf","hf","lf","mf","nf","Ub","instance","listener","D","of","has","pf","qf","rf","random","sf","capture","passive","n","t","J","x","u","w","F","tf","uf","parentWindow","vf","wf","na","xa","$a","ba","je","char","ke","unshift","xf","yf","zf","Af","Bf","Cf","Df","Ef","__html","Ff","setTimeout","Gf","clearTimeout","Hf","Promise","Jf","queueMicrotask","resolve","then","catch","If","Kf","Lf","Mf","previousSibling","Nf","Of","Pf","Qf","Rf","Sf","Tf","Uf","E","G","Vf","H","Wf","Xf","Yf","contextTypes","__reactInternalMemoizedUnmaskedChildContext","__reactInternalMemoizedMaskedChildContext","Zf","childContextTypes","$f","ag","bg","getChildContext","cg","__reactInternalMemoizedMergedChildContext","dg","eg","fg","gg","hg","jg","kg","lg","mg","ng","og","pg","qg","rg","sg","tg","ug","vg","wg","xg","yg","I","zg","Ag","Bg","deletions","Cg","pendingProps","overflow","treeContext","retryLane","Dg","mode","Eg","Fg","Gg","memoizedProps","Hg","Ig","Jg","Kg","Lg","ref","_owner","_stringRef","refs","Mg","join","Ng","Og","index","Pg","Qg","Rg","implementation","Sg","Tg","q","r","y","next","done","Ug","Vg","Wg","Xg","Yg","Zg","$g","ah","_currentValue","bh","childLanes","ch","dependencies","firstContext","lanes","dh","eh","context","memoizedValue","fh","gh","hh","interleaved","ih","jh","kh","updateQueue","baseState","firstBaseUpdate","lastBaseUpdate","shared","pending","effects","lh","mh","eventTime","lane","payload","callback","nh","K","oh","ph","qh","rh","sh","th","uh","vh","wh","xh","yh","tagName","zh","Ah","Bh","L","Ch","revealOrder","Dh","Eh","_workInProgressVersionPrimary","Fh","ReactCurrentDispatcher","Gh","Hh","M","N","O","Ih","Jh","Kh","Lh","P","Mh","Nh","Oh","Ph","Qh","Rh","Sh","Th","baseQueue","queue","Uh","Vh","Wh","lastRenderedReducer","action","hasEagerState","eagerState","lastRenderedState","dispatch","Xh","Yh","Zh","$h","ai","getSnapshot","bi","ci","Q","di","lastEffect","stores","ei","fi","gi","hi","ii","create","destroy","deps","ji","ki","li","mi","ni","oi","pi","qi","ri","si","ti","ui","vi","wi","xi","yi","zi","Ai","R","Bi","readContext","useCallback","useContext","useEffect","useImperativeHandle","useInsertionEffect","useLayoutEffect","useMemo","useReducer","useRef","useState","useDebugValue","useDeferredValue","useTransition","useMutableSource","useSyncExternalStore","useId","unstable_isNewReconciler","identifierPrefix","Ci","defaultProps","Di","Ei","isMounted","_reactInternals","enqueueSetState","enqueueReplaceState","enqueueForceUpdate","Fi","shouldComponentUpdate","isPureReactComponent","Gi","contextType","state","updater","Hi","componentWillReceiveProps","UNSAFE_componentWillReceiveProps","Ii","getDerivedStateFromProps","getSnapshotBeforeUpdate","UNSAFE_componentWillMount","componentWillMount","componentDidMount","Ji","message","digest","Ki","Li","console","Mi","WeakMap","Ni","Oi","Pi","Qi","getDerivedStateFromError","componentDidCatch","Ri","componentStack","Si","pingCache","Ti","Ui","Vi","Wi","ReactCurrentOwner","Xi","Yi","Zi","$i","aj","compare","bj","cj","dj","baseLanes","cachePool","transitions","ej","fj","gj","hj","ij","UNSAFE_componentWillUpdate","componentWillUpdate","componentDidUpdate","jj","kj","pendingContext","lj","zj","Aj","Bj","Cj","mj","nj","oj","fallback","pj","qj","sj","dataset","dgst","tj","uj","_reactRetry","rj","subtreeFlags","vj","wj","isBackwards","rendering","renderingStartTime","last","tail","tailMode","xj","Dj","S","Ej","Fj","wasMultiple","multiple","suppressHydrationWarning","onClick","onclick","size","createElementNS","autoFocus","createTextNode","T","Gj","Hj","Ij","Jj","U","Kj","WeakSet","V","Lj","W","Mj","Nj","Pj","Qj","Rj","Sj","Tj","Uj","Vj","insertBefore","_reactRootContainer","Wj","X","Xj","Yj","Zj","onCommitFiberUnmount","componentWillUnmount","ak","bk","ck","dk","ek","isHidden","fk","gk","display","hk","ik","jk","kk","__reactInternalSnapshotBeforeUpdate","Vk","lk","ceil","mk","nk","ok","Y","Z","pk","qk","rk","sk","tk","Infinity","uk","vk","wk","xk","yk","zk","Ak","Bk","Ck","Dk","callbackNode","expirationTimes","expiredLanes","wc","callbackPriority","ig","Ek","Fk","Gk","Hk","Ik","Jk","Kk","Lk","Mk","Nk","Ok","finishedWork","finishedLanes","Pk","timeoutHandle","Qk","Rk","Sk","Tk","Uk","mutableReadLanes","Bc","Oj","onCommitFiberRoot","mc","onRecoverableError","Wk","onPostCommitFiberRoot","Xk","Yk","$k","isReactComponent","pendingChildren","al","mutableSourceEagerHydrationData","bl","cache","pendingSuspenseBoundaries","dl","el","fl","gl","hl","il","yj","Zk","kl","reportError","ll","_internalRoot","ml","nl","ol","pl","rl","ql","unmount","unstable_scheduleHydration","splice","querySelectorAll","JSON","stringify","form","sl","usingClientEntryPoint","Events","tl","findFiberByHostInstance","bundleType","version","rendererPackageName","ul","rendererConfig","overrideHookState","overrideHookStateDeletePath","overrideHookStateRenamePath","overrideProps","overridePropsDeletePath","overridePropsRenamePath","setErrorHandler","setSuspenseHandler","scheduleUpdate","currentDispatcherRef","findHostInstanceByFiber","findHostInstancesForRefresh","scheduleRefresh","scheduleRoot","setRefreshHandler","getCurrentFiber","reconcilerVersion","__REACT_DEVTOOLS_GLOBAL_HOOK__","vl","isDisabled","supportsFiber","inject","createPortal","cl","createRoot","unstable_strictMode","findDOMNode","flushSync","hydrate","hydrateRoot","hydratedSources","_getVersion","_source","unmountComponentAtNode","unstable_batchedUpdates","unstable_renderSubtreeIntoContainer","checkDCE","__self","__source","Fragment","jsx","jsxs","setState","forceUpdate","escape","_status","_result","Children","map","count","toArray","only","Component","Profiler","PureComponent","StrictMode","Suspense","act","cloneElement","createContext","_currentValue2","_threadCount","Provider","Consumer","_defaultValue","_globalName","createFactory","createRef","forwardRef","isValidElement","lazy","memo","startTransition","unstable_act","pop","sortIndex","performance","setImmediate","startTime","expirationTime","priorityLevel","navigator","scheduling","isInputPending","MessageChannel","port2","port1","onmessage","postMessage","unstable_Profiling","unstable_continueExecution","unstable_forceFrameRate","floor","unstable_getFirstCallbackNode","unstable_next","unstable_pauseExecution","unstable_runWithPriority","delay","unstable_wrapCallback","styleObject","inline_style_parser_1","hasIterator","__importDefault","classNames","classes","arg","appendClass","parseValue","newClass","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","getter","leafPrototypes","getProto","getPrototypeOf","ns","def","getOwnPropertyNames","definition","o","chunkId","all","reduce","promises","miniCssF","globalThis","Function","inProgress","dataWebpackPrefix","script","needAttach","scripts","getElementsByTagName","s","getAttribute","charset","timeout","nc","onScriptComplete","prev","onerror","onload","doneFns","fn","head","toStringTag","installedChunks","j","installedChunkData","promise","reject","errorType","realSrc","request","webpackJsonpCallback","parentChunkLoadingFunction","chunkIds","moreModules","runtime","some","chunkLoadingGlobal","self","Action","PopStateEventType","invariant","warning","cond","warn","getHistoryState","usr","idx","createLocation","to","_extends","pathname","hash","parsePath","substr","createPath","_ref","path","parsedPath","hashIndex","searchIndex","getUrlBasedHistory","getLocation","createHref","validateLocation","v5Compat","globalHistory","history","Pop","getIndex","handlePop","nextIndex","delta","createURL","origin","URL","replaceState","listen","encodeLocation","Push","historyState","pushState","DOMException","Replace","go","ResultType","matchRoutes","routes","locationArg","basename","matchRoutesImpl","allowPartial","stripBasename","branches","flattenRoutes","sort","score","siblings","every","compareIndexes","routesMeta","childrenIndex","rankRouteBranches","matches","decoded","decodePath","matchRouteBranch","parentsMeta","parentPath","flattenRoute","route","relativePath","caseSensitive","startsWith","joinPaths","computeScore","_route$path","exploded","explodeOptionalSegments","segments","first","rest","isOptional","endsWith","required","restExploded","subpath","paramRe","dynamicSegmentValue","indexRouteValue","emptySegmentValue","staticSegmentValue","splatPenalty","isSplat","initialScore","filter","segment","branch","matchedParams","matchedPathname","remainingPathname","matchPath","params","pathnameBase","normalizePathname","pattern","matcher","compiledParams","regexpSource","_","paramName","RegExp","compilePath","captureGroups","splatValue","decodeURIComponent","startIndex","nextChar","paths","isRouteErrorResponse","status","statusText","internal","validMutationMethodsArr","validRequestMethodsArr","DataRouterContext","React","DataRouterStateContext","NavigationContext","LocationContext","RouteContext","outlet","isDataRoute","RouteErrorContext","useInRouterContext","useLocation","UNSAFE_invariant","useRoutesImpl","dataRouterState","future","parentMatches","routeMatch","parentParams","parentPathnameBase","locationFromContext","_parsedLocationArg$pa","parsedLocationArg","parentSegments","renderedMatches","_renderMatches","navigationType","DefaultErrorComponent","_state$errors","useDataRouterState","DataRouterStateHook","UseRouteError","routeId","useCurrentRouteId","errors","useRouteError","lightgrey","preStyles","padding","backgroundColor","fontStyle","defaultErrorElement","RenderErrorBoundary","super","revalidation","errorInfo","routeContext","component","RenderedRoute","dataRouterContext","static","staticContext","errorElement","ErrorBoundary","_deepestRenderedBoundaryId","_dataRouterState","_future","v7_partialHydration","initialized","errorIndex","findIndex","renderFallback","fallbackIndex","HydrateFallback","hydrateFallbackElement","loaderData","needsToRunLoader","loader","reduceRight","shouldRenderHydrateFallback","alreadyWarned$1","getChildren","hookName","useRouteContext","thisRoute","alreadyWarned","logDeprecation","flag","logV6DeprecationWarnings","renderFuture","routerFuture","v7_startTransition","v7_relativeSplatPath","v7_fetcherPersist","v7_normalizeFormMethod","v7_skipActionErrorRevalidation","Route","_props","Router","_ref5","basenameProp","locationProp","staticProp","navigationContext","locationContext","trailingPathname","Routes","_ref6","createRoutesFromChildren","treePath","hasErrorBoundary","shouldRevalidate","handle","__reactRouterVersion","startTransitionImpl","ReactDOM","BrowserRouter","_ref4","historyRef","createBrowserHistory","setStateImpl","newState","UNSAFE_logV6DeprecationWarnings","DataRouterHook","makeEventKey","eventKey","defaultKey","_toPropertyKey","hint","prim","toPrimitive","res","Number","_toPrimitive","useUncontrolled","config","fieldName","_extends2","Utils","propsValue","_objectWithoutPropertiesLoose","handlerName","_useUncontrolledProp","propValue","handler","wasPropRef","_useState","stateValue","isProp","wasProp","useUncontrolledProp","nextProps","prevState","nextState","prevProps","__reactInternalSnapshotFlag","__reactInternalSnapshot","__suppressDeprecationWarning","DEFAULT_BREAKPOINTS","DEFAULT_MIN_BREAKPOINT","ThemeContext","prefixes","breakpoints","minBreakpoint","useBootstrapPrefix","prefix","defaultPrefix","NavbarBrand","bsPrefix","className","as","_jsx","getComputedStyle","psuedoElement","doc","ownerWindow","rUpper","msPattern","hyphenateStyleName","hyphenate","supportedTransforms","css","transforms","getPropertyValue","isTransform","removeProperty","cssText","_setPrototypeOf","setPrototypeOf","__proto__","UNMOUNTED","EXITED","ENTERING","ENTERED","EXITING","Transition","_React$Component","_this","initialStatus","appear","isMounting","enter","appearStatus","in","unmountOnExit","mountOnEnter","nextCallback","_proto","updateStatus","nextStatus","cancelNextCallback","getTimeouts","exit","mounting","nodeRef","forceReflow","performEnter","performExit","_this2","appearing","_ref2","maybeNode","maybeAppearing","timeouts","enterTimeout","safeSetState","onEntered","onEnter","onEntering","onTransitionEnd","_this3","onExit","onExiting","onExited","cancel","setNextCallback","_this4","active","doesNotHaveTimeoutOrListener","addEndListener","_ref3","maybeNextCallback","_this$props","childProps","TransitionGroupContext","noop","propTypes","optionsSupported","onceSupported","once","canUseDOM","eventName","wrappedHandler","__once","onceHandler","emulateTransitionEnd","duration","called","createEvent","initEvent","triggerEvent","remove","transitionEnd","mult","parseFloat","parseDuration","removeEmulate","transitionEndListener","funcs","acc","triggerBrowserReflow","offsetHeight","toFnRef","refA","refB","mergeRefs","TransitionWrapper","childRef","mergedRef","useMergedRefs","attachRef","componentOrElement","normalize","handleEnter","handleEntering","handleEntered","handleExit","handleExiting","handleExited","handleAddEndListener","innerProps","MARGINS","getDefaultDimensionValue","dimension","elem","margins","parseInt","collapseStyles","inProp","getDimensionValue","computedDimension","createChainedFunction","scroll","role","NavbarCollapse","NavbarContext","Collapse","expanded","useEventCallback","useCommittedRef","NavbarToggle","label","onToggle","handleClick","isReactNative","global","product","matchersByWindow","getMatcher","query","targetWindow","matchers","mql","matchMedia","refCount","media","useMediaQuery","setMatches","handleChange","addListener","removeListener","breakpointValues","names","and","getMaxQuery","breakpoint","getNext","breakpointOrMap","direction","breakpointMap","entries","getMinQuery","createBreakpointHook","xs","sm","xl","xxl","useWillUnmount","onUnmount","valueRef","useUpdatedRef","dataAttr","OPEN_DATA_ATTRIBUTE","handleContainerOverflow","isRTL","modals","getScrollbarWidth","abs","innerWidth","clientWidth","getBodyScrollbarWidth","getElement","setModalAttributes","_modal","removeModalAttributes","setContainerStyle","containerState","paddingProp","container","scrollBarWidth","reset","removeContainerStyle","modal","modalIdx","isTopModal","Context","useWindow","resolveContainerRef","getBoundingClientRect","hasEnteredRef","combinedRef","getReactVersion","parts","major","minor","patch","_excluded","RTGTransition","transitionProps","useRTGTransitionProps","ImperativeTransition","exited","setExited","onTransition","isInitialRef","handleTransition","useIsomorphicEffect","stale","initial","isStale","onFinish","renderTransition","runTransition","NoopTransition","manager","useModalManager","provided","modalManager","ModalManager","getManager","dialog","backdrop","setDialogRef","setBackdropRef","Modal","show","keyboard","onBackdropClick","onEscapeKeyDown","backdropTransition","runBackdropTransition","enforceFocus","restoreFocus","restoreFocusOptions","renderDialog","renderBackdrop","providedManager","containerRef","onShow","onHide","onResolved","resolvedRef","setRef","earlyRef","nextRef","useWaitForDOMRef","mounted","useMounted","prevShow","usePrevious","lastFocusRef","handleShow","removeKeydownListenerRef","handleDocumentKeyDown","removeFocusListenerRef","handleEnforceFocus","_modal$dialog$ownerDo","_modal$dialog","currentActiveElement","handleHide","_lastFocusRef$current","handleBackdropClick","isEscKey","dialogProps","tabIndex","backdropElement","_Fragment","_jsxs","Manager","fadeStyles","Fade","transitionClasses","isAppearing","OffcanvasBody","transitionStyles","OffcanvasToggling","variant","CloseButton","ariaLabel","AbstractModalHeader","closeLabel","closeVariant","closeButton","ModalContext","OffcanvasHeader","DivStyledAsH5","divWithClassName","OffcanvasTitle","qsa","selector","replaceClassName","origClass","classToRemove","Selector","BootstrapModalManager","adjustAndStore","adjust","actual","restore","classList","baseVal","hasClass","marginProp","sharedManager","DialogTransition","BackdropTransition","Offcanvas","ariaLabelledby","placement","responsive","backdropClassName","propsManager","renderStaticNode","showOffcanvas","setShowOffcanvas","hideResponsiveOffcanvas","useBreakpoint","modalContext","backdropProps","BaseModal","visibility","getSharedManager","Body","Header","Title","NavbarOffcanvas","NavbarText","Navbar","initialBsPrefix","expand","fixed","sticky","onSelect","collapseOnSelect","controlledProps","handleCollapse","expandClass","navbarContext","SelectableContext","Brand","Text","Toggle","Container","fluid","suffix","NavContext","useButtonProps","rel","isTrivialHref","onKeyDown","Button","asProp","buttonProps","useNavItem","parentOnSelect","navContext","tabContext","TabContext","isActive","contextControllerId","getControllerId","contextControlledId","getControlledId","activeKey","NavItem","EVENT_KEY_ATTR","Nav","useForceUpdate","needsRefocusRef","listNode","getNextActiveTab","currentListNode","items","activeChild","querySelector","handleSelect","nextActiveChild","Item","Anchor","handleKeyDown","NavLink","navItemProps","uncontrolledProps","fill","justify","navbar","navbarScroll","navbarBsPrefix","cardHeaderBsPrefix","isNavbar","cardHeaderContext","CardHeaderContext","BaseNav","Link","CardBody","CardFooter","CardHeader","contextValue","CardImg","CardImgOverlay","CardLink","DivStyledAsH6","CardSubtitle","CardText","CardTitle","Card","border","Img","Subtitle","Footer","ImgOverlay","About","allPosts","nameRe","nameReJsx","emptyOptions","empty","Schema","normal","space","merge","definitions","Info","attribute","boolean","booleanish","overloadedBoolean","commaSeparated","spaceSeparated","commaOrSpaceSeparated","defined","powers","increment","checks","types","DefinedInfo","mask","mark","check","values","own","properties","info","transform","attributes","xlink","xLinkActuate","xLinkArcRole","xLinkHref","xLinkRole","xLinkShow","xLinkTitle","xLinkType","xml","xmlLang","xmlBase","xmlSpace","caseSensitiveTransform","caseInsensitiveTransform","xmlns","xmlnsxlink","xmlnsXLink","aria","ariaActiveDescendant","ariaAtomic","ariaAutoComplete","ariaBusy","ariaChecked","ariaColCount","ariaColIndex","ariaColSpan","ariaControls","ariaCurrent","ariaDescribedBy","ariaDetails","ariaDisabled","ariaDropEffect","ariaErrorMessage","ariaExpanded","ariaFlowTo","ariaGrabbed","ariaHasPopup","ariaHidden","ariaInvalid","ariaKeyShortcuts","ariaLabelledBy","ariaLevel","ariaLive","ariaModal","ariaMultiLine","ariaMultiSelectable","ariaOrientation","ariaOwns","ariaPlaceholder","ariaPosInSet","ariaPressed","ariaReadOnly","ariaRelevant","ariaRequired","ariaRoleDescription","ariaRowCount","ariaRowIndex","ariaRowSpan","ariaSelected","ariaSetSize","ariaSort","ariaValueMax","ariaValueMin","ariaValueNow","ariaValueText","html","acceptcharset","classname","htmlfor","httpequiv","abbr","accept","acceptCharset","accessKey","allow","allowFullScreen","allowPaymentRequest","allowUserMedia","alt","async","autoCapitalize","autoComplete","autoPlay","blocking","charSet","cite","cols","colSpan","controls","controlsList","coords","crossOrigin","dateTime","decoding","defer","dir","dirName","download","draggable","encType","enterKeyHint","fetchPriority","formAction","formEncType","formMethod","formNoValidate","formTarget","headers","hidden","high","hrefLang","htmlFor","httpEquiv","imageSizes","imageSrcSet","inert","inputMode","integrity","isMap","itemId","itemProp","itemRef","itemScope","itemType","kind","lang","language","list","loading","loop","low","manifest","max","maxLength","method","minLength","muted","nonce","noModule","noValidate","onAbort","onAfterPrint","onAuxClick","onBeforeMatch","onBeforePrint","onBeforeToggle","onBeforeUnload","onBlur","onCancel","onCanPlay","onCanPlayThrough","onChange","onClose","onContextLost","onContextMenu","onContextRestored","onCopy","onCueChange","onCut","onDblClick","onDrag","onDragEnd","onDragEnter","onDragExit","onDragLeave","onDragOver","onDragStart","onDrop","onDurationChange","onEmptied","onEnded","onFocus","onFormData","onHashChange","onInput","onInvalid","onKeyPress","onKeyUp","onLanguageChange","onLoad","onLoadedData","onLoadedMetadata","onLoadEnd","onLoadStart","onMessage","onMessageError","onMouseDown","onMouseEnter","onMouseLeave","onMouseMove","onMouseOut","onMouseOver","onMouseUp","onOffline","onOnline","onPageHide","onPageShow","onPaste","onPause","onPlay","onPlaying","onPopState","onProgress","onRateChange","onRejectionHandled","onReset","onResize","onScroll","onScrollEnd","onSecurityPolicyViolation","onSeeked","onSeeking","onSlotChange","onStalled","onStorage","onSubmit","onSuspend","onTimeUpdate","onUnhandledRejection","onUnload","onVolumeChange","onWaiting","onWheel","open","optimum","ping","placeholder","playsInline","popover","popoverTarget","popoverTargetAction","poster","preload","readOnly","referrerPolicy","reversed","rows","rowSpan","sandbox","scope","scoped","seamless","shadowRootClonable","shadowRootDelegatesFocus","shadowRootMode","sizes","slot","span","spellCheck","srcDoc","srcLang","srcSet","step","title","translate","typeMustMatch","useMap","wrap","writingSuggestions","align","aLink","archive","axis","background","bgColor","borderColor","bottomMargin","cellPadding","cellSpacing","charOff","classId","clear","codeBase","codeType","compact","declare","face","frame","frameBorder","hSpace","leftMargin","longDesc","lowSrc","marginHeight","marginWidth","noResize","noHref","noShade","noWrap","profile","prompt","rev","rightMargin","scheme","scrolling","standby","summary","topMargin","valueType","vAlign","vLink","vSpace","allowTransparency","autoCorrect","autoSave","disablePictureInPicture","disableRemotePlayback","results","security","unselectable","svg","accentHeight","alignmentBaseline","arabicForm","baselineShift","capHeight","clipPath","clipRule","colorInterpolation","colorInterpolationFilters","colorProfile","colorRendering","dataType","dominantBaseline","enableBackground","fillRule","floodColor","fontFamily","fontSize","fontSizeAdjust","fontStretch","fontVariant","glyphName","glyphOrientationHorizontal","glyphOrientationVertical","horizAdvX","horizOriginX","horizOriginY","imageRendering","letterSpacing","lightingColor","markerEnd","markerMid","markerStart","navDown","navDownLeft","navDownRight","navLeft","navNext","navPrev","navRight","navUp","navUpLeft","navUpRight","onActivate","onBegin","onEnd","onFocusIn","onFocusOut","onMouseWheel","onRepeat","onZoom","overlinePosition","overlineThickness","paintOrder","panose1","pointerEvents","renderingIntent","shapeRendering","stopColor","strikethroughPosition","strikethroughThickness","strokeDashArray","strokeDashOffset","strokeLineCap","strokeLineJoin","strokeMiterLimit","textAnchor","textDecoration","textRendering","transformOrigin","typeOf","underlinePosition","underlineThickness","unicodeBidi","unicodeRange","unitsPerEm","vAlphabetic","vHanging","vIdeographic","vMathematical","vectorEffect","vertAdvY","vertOriginX","vertOriginY","wordSpacing","writingMode","xHeight","playbackOrder","timelineBegin","about","accumulate","additive","alphabetic","amplitude","ascent","attributeType","azimuth","bandwidth","baseFrequency","baseProfile","bbox","begin","bias","by","calcMode","clip","clipPathUnits","contentScriptType","contentStyleType","cursor","cx","cy","defaultAction","descent","diffuseConstant","dur","divisor","dx","dy","edgeMode","editable","elevation","exponent","externalResourcesRequired","filterRes","filterUnits","focusable","focusHighlight","fr","from","fx","fy","g1","g2","glyphRef","gradientTransform","gradientUnits","hanging","hatchContentUnits","hatchUnits","ideographic","initialVisibility","in2","intercept","k1","k2","k3","k4","kernelMatrix","kernelUnitLength","keyPoints","keySplines","keyTimes","kerning","lengthAdjust","limitingConeAngle","local","markerHeight","markerUnits","markerWidth","maskContentUnits","maskUnits","mathematical","mediaCharacterEncoding","mediaContentEncodings","mediaSize","mediaTime","numOctaves","observer","operator","orient","orientation","overlay","pathLength","patternContentUnits","patternTransform","patternUnits","phase","pitch","points","pointsAtX","pointsAtY","pointsAtZ","preserveAlpha","preserveAspectRatio","primitiveUnits","propagate","radius","refX","refY","repeatCount","repeatDur","requiredExtensions","requiredFeatures","requiredFonts","requiredFormats","resource","restart","rotate","rx","ry","scale","seed","side","slope","snapshotTime","specularConstant","specularExponent","spreadMethod","spacing","startOffset","stdDeviation","stemh","stemv","stitchTiles","stroke","surfaceScale","syncBehavior","syncBehaviorDefault","syncMaster","syncTolerance","syncToleranceDefault","systemLanguage","tableValues","targetX","targetY","textLength","transformBehavior","u1","u2","unicode","viewBox","viewTarget","widths","x1","x2","xChannelSelector","y1","y2","yChannelSelector","zoomAndPan","htmlBase","svgBase","valid","dash","cap","kebab","$0","camelcase","hastToReact","StyleToObject","pointEnd","point","pointStart","stringifyPosition","VFileMessage","causeOrReason","optionsOrParentOrPlace","legacyCause","place","ancestors","cause","ruleId","parent","fatal","file","expected","note","emptyMap","dashSomething","tableElements","tableCellElement","docs","toJsxRuntime","tree","filePath","development","jsxDEV","isStaticChildren","columnNumber","fileName","lineNumber","developmentCreate","productionCreate","components","elementAttributeNameCase","evaluater","createEvaluater","ignoreInvalidStyle","passKeys","passNode","schema","stylePropertyNameCase","tableCellAlignToStyle","one","parentSchema","findComponentFromName","alignValue","createProperty","createElementProps","createChildren","thing","addNode","addChildren","estree","expression","evaluateExpression","crashEstree","mdxExpression","objectExpression","argument","createJsxElementProps","mdxJsxElement","evaluateProgram","mdxEsm","root","countsByName","Type","dashes","find","settings","padRight","padLeft","commas","styleToObject","replacer","toCamel","parseStyle","domCasing","cssCasing","transformStyleToCssCasing","transformStylesToCssCasing","allowExpression","identifiers","isIdentifierName","computed","Boolean","optional","toDash","$1","urlAttributes","icon","includeImageAlt","includeHtml","parameters","chunkStart","SpliceBuffer","right","RangeError","setCursor","stop","POSITIVE_INFINITY","reverse","deleteCount","trunc","removed","chunkedPush","item","pushMany","unshiftMany","subtokenize","eventsArray","jumps","lineIndex","otherIndex","otherEvent","subevents","more","events","_tokenizer","_isInFirstContentOfListItem","contentType","subcontent","_container","eventIndex","token","startPosition","startPositions","tokenizer","parser","childEvents","gaps","stream","previous","breaks","sliceStream","defineSkip","_gfmTasklistFirstContentOfListItem","write","syntaxExtension","extension","hook","constructs","existing","before","asciiAlpha","regexCheck","asciiAlphanumeric","asciiAtext","asciiControl","asciiDigit","asciiHexDigit","asciiPunctuation","markdownLineEnding","markdownLineEndingOrSpace","markdownSpace","unicodePunctuation","unicodeWhitespace","regex","factorySpace","limit","consume","tokenize","contentStart","attempt","contentInitial","lineStart","childFlow","childToken","lineStartOffset","continued","continuation","documentContinue","checkNewContainers","_closeFlow","closeFlow","indexBeforeExits","indexBeforeFlow","exitContainers","documentContinued","currentConstruct","concrete","flowStart","interrupt","_gfmTableDynamicInterruptHack","containerConstruct","thereIsANewContainer","thereIsNoNewContainer","containerContinue","flow","flowContinue","writeToChild","endOfFile","seen","entry","nok","disable","null","blankLine","partial","after","chunkInside","contentEnd","continuationConstruct","contentContinue","prefixed","sliceSerialize","flowInitial","afterConstruct","resolver","resolveAll","createResolver","initializeFactory","field","resolveAllLineSuffixes","notText","atBreak","extraResolver","chunks","tabs","bufferIndex","chunk","charCodeAt","_bufferIndex","_index","thematicBreak","marker","sequence","onBlank","notBlank","furtherBlankLines","initialBlankLine","notInCurrentItem","indentConstruct","initialSize","atMarker","inside","listItemPrefixWhitespaceConstruct","endOfPrefix","otherPrefix","blockQuote","contBefore","factoryDestination","literalType","literalMarkerType","rawType","stringType","balance","enclosedBefore","raw","enclosed","enclosedEscape","rawEscape","factoryLabel","markerType","labelInside","labelEscape","factoryTitle","factoryWhitespace","normalizeIdentifier","identifier","labelAfter","markerAfter","destinationBefore","destinationAfter","titleBefore","afterWhitespace","beforeMarker","titleAfter","titleAfterOptionalWhitespace","codeIndented","afterPrefix","furtherStart","headingAtx","sequenceOpen","sequenceFurther","setextUnderline","resolveTo","heading","paragraph","htmlBlockNames","htmlRawNames","htmlFlow","closingTag","buffer","markerB","declarationOpen","tagCloseStart","continuationDeclarationInside","commentOpenInside","cdataOpenInside","slash","basicSelfClosing","completeClosingTagAfter","completeAttributeNameBefore","completeEnd","completeAttributeName","completeAttributeNameAfter","completeAttributeValueBefore","completeAttributeValueQuoted","completeAttributeValueUnquoted","completeAttributeValueQuotedAfter","completeAfter","continuationCommentInside","continuationRawTagOpen","continuationClose","continuationCdataInside","continuationStart","blankLineBefore","continuationAfter","nonLazyContinuationStart","continuationStartNonLazy","continuationBefore","continuationRawEndTag","nonLazyContinuation","codeFenced","closeStart","startBefore","beforeSequenceClose","sequenceClose","sizeOpen","sequenceCloseAfter","initialPrefix","beforeSequenceOpen","infoBefore","atNonLazyBreak","metaBefore","contentBefore","beforeContentChunk","contentChunk","decodeNamedCharacterReference","characterReference","numeric","characterEscape","lineEnding","labelEnd","newEvents","close","_inactive","_balanced","group","insideSpan","labelStart","labelEndNok","resourceConstruct","labelEndOk","referenceFullConstruct","referenceNotFull","referenceCollapsedConstruct","resourceBefore","resourceOpen","resourceEnd","resourceDestinationAfter","resourceDestinationMissing","resourceBetween","resourceTitleAfter","referenceFullAfter","referenceFullMissing","referenceCollapsedOpen","labelStartImage","classifyCharacter","attention","openingSequence","closingSequence","use","nextEvents","_close","_open","movePoint","attentionMarkers","autolink","schemeOrEmailAtext","emailAtext","schemeInsideOrEmailAtext","urlInside","emailAtSignOrDot","emailLabel","emailValue","htmlText","returnState","instruction","tagOpen","commentEnd","commentClose","lineEndingBefore","cdata","cdataClose","cdataEnd","instructionClose","tagClose","tagCloseBetween","tagOpenBetween","tagOpenAttributeName","tagOpenAttributeNameAfter","tagOpenAttributeValueBefore","tagOpenAttributeValueQuoted","tagOpenAttributeValueUnquoted","tagOpenAttributeValueQuotedAfter","lineEndingAfter","lineEndingAfterPrefix","labelStartLink","hardBreakEscape","codeText","tailExitIndex","headEnterIndex","between","resolveText","createTokenizer","initialize","columnStart","resolveAllConstructs","consumed","constructFactory","addResult","onsuccessfulcheck","accountForPotentialSkip","fields","expandTabs","atTab","serializeChunks","main","expectedCode","startBufferIndex","endIndex","endBufferIndex","sliceChunks","chunkIndex","onreturn","bogusState","listOfConstructs","constructIndex","handleListOfConstructs","handleMapOfConstructs","handleConstruct","startPoint","startPrevious","startCurrentConstruct","startEventsIndex","startStack","store","parse","extensions","combineExtensions","defaultConstructs","decodeNumericCharacterReference","fromCodePoint","characterEscapeOrReference","decode","$2","hex","fromMarkdown","encoding","canContainEols","opener","autolinkProtocol","onenterdata","autolinkEmail","atxHeading","codeFlow","codeFencedFenceInfo","codeFencedFenceMeta","codeTextData","codeFlowValue","definitionDestinationString","definitionLabelString","definitionTitleString","emphasis","hardBreak","hardBreakTrailing","htmlFlowData","htmlTextData","image","listItem","listItemValue","onenterlistitemvalue","listOrdered","onenterlistordered","listUnordered","reference","onenterreference","referenceString","resourceDestinationString","resourceTitleString","setextHeading","strong","closer","atxHeadingSequence","onexitatxheadingsequence","onexitautolinkemail","onexitautolinkprotocol","characterEscapeValue","onexitdata","characterReferenceMarkerHexadecimal","onexitcharacterreferencemarker","characterReferenceMarkerNumeric","characterReferenceValue","onexitcharacterreferencevalue","onexitcharacterreference","onexitcodefenced","codeFencedFence","onexitcodefencedfence","onexitcodefencedfenceinfo","onexitcodefencedfencemeta","onexitcodeindented","onexitcodetext","onexitdefinitiondestinationstring","onexitdefinitionlabelstring","onexitdefinitiontitlestring","onexithardbreak","onexithtmlflow","onexithtmltext","onexitimage","onexitlabel","labelText","onexitlabeltext","onexitlineending","onexitlink","onexitreferencestring","onexitresourcedestinationstring","onexitresourcetitlestring","onexitresource","onexitsetextheading","setextHeadingLineSequence","onexitsetextheadinglinesequence","setextHeadingText","onexitsetextheadingtext","configure","mdastExtensions","compile","tokenStack","resume","listStack","prepareList","defaultOnError","firstBlankLineIndex","containerBalance","listSpread","tailIndex","tailEvent","_spread","errorHandler","onExitError","expectingFirstListItemValue","flowCodeInside","depth","setextHeadingSlurpLineEnding","codePointAt","atHardBreak","inReference","referenceType","ancestor","decodeString","fragment","characterReferenceType","ordered","spread","compiler","postprocess","atCarriageReturn","endPosition","TextDecoder","lastIndex","preprocess","combined","remarkParse","env","deserialize","serialized","deserializer","$","out","unpair","BigInt","EMPTY","asString","shouldSkip","TYPE","serialize","json","lossy","serializer","strict","pair","toJSON","toISOString","structuredClone","normalizeUri","skip","defaultFootnoteBackContent","rereferenceIndex","defaultFootnoteBackLabel","referenceIndex","convert","castFactory","tests","anyFactory","checkAsRecord","nodeAsRecord","propsFactory","typeFactory","testFunction","looksLikeANode","CONTINUE","EXIT","visitParents","visitor","factory","parents","visit","subresult","grandparents","toResult","nodeAsParent","testOrVisitor","visitorOrReverse","maybeReverse","revert","subtype","contents","listItemLoose","trimLines","trimLine","handlers","blockquote","applyData","break","footnoteReference","clobberPrefix","safeId","footnoteOrder","counter","reuseCounter","footnoteCounts","dataFootnoteRef","sup","allowDangerousHtml","imageReference","definitionById","inlineCode","linkReference","loose","listLoose","table","firstRow","tableContent","tableCell","tableRow","cellIndex","cells","cell","toml","ignore","yaml","footnoteDefinition","hName","hChildren","hProperties","defaultUnknownHandler","nodes","trimMarkdownSpaceStart","toHast","footnoteById","defaultHandlers","passThrough","shallow","unknownHandler","createState","foot","footnoteBackContent","footnoteBackLabel","footnoteLabel","footnoteLabelTagName","footnoteLabelProperties","listItems","backReferences","counts","dataFootnoteBackref","tailTail","dataFootnotes","footer","remarkRehype","destination","hastTree","run","bail","trough","fns","pipeline","middlewareIndex","output","middleware","wrapped","_len3","_key3","fnExpectsCallback","_len4","_key4","middelware","minpath","extname","assertPath","seenNonSlash","firstNonSlashEnd","extnameIndex","dirname","unmatchedSlash","startPart","startDot","preDotState","joined","absolute","allowAboveRoot","lastSlashIndex","lastSegmentLength","lastSlash","dots","normalizeString","sep","minproc","cwd","isUrl","fileUrlOrPath","protocol","auth","urlToPath","hostname","third","getPathFromURLPosix","VFile","isUint8Array","messages","stored","assertNonEmpty","assertPart","stem","fail","part","CallableInstance","proto","Processor","Compiler","Parser","attachers","freezeIndex","frozen","namespace","transformers","attacher","assertUnfrozen","freeze","transformer","realFile","vfile","assertParser","process","assertCompiler","executor","parseTree","realDone","compileTree","compileResult","processSync","complete","assertDone","assertNode","outputTree","resultingTree","runSync","addPlugin","addList","addPreset","plugin","plugins","entryIndex","primary","currentPrimary","isPlainObj","unified","asyncName","looksLikeAVFile","emptyPlugins","emptyRemarkRehypeOptions","safeProtocol","deprecations","Markdown","allowedElements","allowElement","disallowedElements","rehypePlugins","remarkPlugins","remarkRehypeOptions","skipHtml","unwrapDisallowed","urlTransform","defaultUrlTransform","processor","deprecation","mdastTree","colon","questionMark","numberSign","Post","postId","useParams","mdText","createdOn","ReactMarkdown","toLocaleDateString","PostCard","post","urlSuffix","Home","_allPosts$index","searchTerm","setSearchTerm","filteredPosts","onPerfEntry","getCLS","getFID","getFCP","getLCP","getTTFB","getElementById","App","reportWebVitals"],"sourceRoot":""}