{"version":3,"file":"static/chunks/7514-43eba92bcdf2d2c9.js","mappings":"uGAEIA,EAAyB,EAAQ,OAKrCC,EAAQ,OAAU,EAElB,IAAIC,EAAiBF,EAAuB,EAAQ,QAEhDG,EAAc,EAAQ,OAEtBC,GAAW,EAAIF,EAAeG,UAAuB,EAAIF,EAAYG,KAAK,OAAQ,CACpFC,EAAG,sDACD,SAEJN,EAAQ,EAAUG,G,uCCfdJ,EAAyB,EAAQ,OAKrCC,EAAQ,OAAU,EAElB,IAAIC,EAAiBF,EAAuB,EAAQ,QAEhDG,EAAc,EAAQ,OAEtBC,GAAW,EAAIF,EAAeG,UAAuB,EAAIF,EAAYG,KAAK,OAAQ,CACpFC,EAAG,uEACD,UAEJN,EAAQ,EAAUG,G,uCCfdJ,EAAyB,EAAQ,OAKrCC,EAAQ,OAAU,EAElB,IAAIC,EAAiBF,EAAuB,EAAQ,QAEhDG,EAAc,EAAQ,OAEtBC,GAAW,EAAIF,EAAeG,UAAuB,EAAIF,EAAYG,KAAK,OAAQ,CACpFC,EAAG,yJACD,QAEJN,EAAQ,EAAUG,G,uCCfdJ,EAAyB,EAAQ,OAKrCC,EAAQ,OAAU,EAElB,IAAIC,EAAiBF,EAAuB,EAAQ,QAEhDG,EAAc,EAAQ,OAEtBC,GAAW,EAAIF,EAAeG,UAAuB,EAAIF,EAAYG,KAAK,OAAQ,CACpFC,EAAG,kDACD,cAEJN,EAAQ,EAAUG,G,uCCfdJ,EAAyB,EAAQ,OAKrCC,EAAQ,OAAU,EAElB,IAAIC,EAAiBF,EAAuB,EAAQ,QAEhDG,EAAc,EAAQ,OAEtBC,GAAW,EAAIF,EAAeG,UAAuB,EAAIF,EAAYG,KAAK,OAAQ,CACpFC,EAAG,iDACD,cAEJN,EAAQ,EAAUG,G,qCCfdJ,EAAyB,EAAQ,OAKrCC,EAAQ,OAAU,EAElB,IAAIC,EAAiBF,EAAuB,EAAQ,QAEhDG,EAAc,EAAQ,OAEtBC,GAAW,EAAIF,EAAeG,UAAuB,EAAIF,EAAYG,KAAK,OAAQ,CACpFC,EAAG,kDACD,QAEJN,EAAQ,EAAUG,G,uCCfdJ,EAAyB,EAAQ,OAKrCC,EAAQ,OAAU,EAElB,IAAIC,EAAiBF,EAAuB,EAAQ,QAEhDG,EAAc,EAAQ,OAEtBC,GAAW,EAAIF,EAAeG,SAAS,EAAc,EAAIF,EAAYG,KAAK,OAAQ,CACpFC,EAAG,yYACF,MAAmB,EAAIJ,EAAYG,KAAK,OAAQ,CACjDC,EAAG,uVACF,MAAO,YAEVN,EAAQ,EAAUG,G,6DCjBlB,KAAe,QAA4B,SAAK,OAAQ,CACtDG,EAAG,wCACD,Q,6DCFJ,KAAe,QAA4B,SAAK,OAAQ,CACtDA,EAAG,yHACD,gB,6DCFJ,KAAe,QAA4B,SAAK,OAAQ,CACtDA,EAAG,yJACD,S,6DCFJ,KAAe,QAA4B,SAAK,OAAQ,CACtDA,EAAG,kDACD,e,sECDJ,KAAe,QAA4B,SAAK,OAAQ,CACtDA,EAAG,4WACD,a,6DCHJ,KAAe,QAA4B,SAAK,OAAQ,CACtDA,EAAG,sJACD,a,6DCFJ,KAAe,QAA4B,SAAK,OAAQ,CACtDA,EAAG,uDACD,Y,6DCFJ,KAAe,QAA4B,SAAK,OAAQ,CACtDA,EAAG,4JACD,S,0KCGJ,GAAe,EAAAC,EAAA,IAA4B,SAAK,OAAQ,CACtDD,EAAG,kHACD,U,WCPJ,MAAME,EAAY,CAAC,MAAO,WAAY,YAAa,YAAa,WAAY,QAAS,MAAO,SAAU,WAyBhGC,GAAa,EAAAC,EAAA,IAAO,MAAO,CAC/BC,KAAM,YACNC,KAAM,OACNC,kBAAmB,CAACC,EAAOC,KACzB,MAAM,WACJC,GACEF,EACJ,MAAO,CAACC,EAAOE,KAAMF,EAAOC,EAAWE,SAAUF,EAAWG,cAAgBJ,EAAOI,gBAPpE,EAShB,EACDC,QACAJ,iBACI,OAAS,CACbK,SAAU,WACVC,QAAS,OACTC,WAAY,SACZC,eAAgB,SAChBC,WAAY,EACZC,MAAO,GACPC,OAAQ,GACRC,WAAYR,EAAMS,WAAWD,WAC7BE,SAAUV,EAAMS,WAAWE,QAAQ,IACnCC,WAAY,EACZC,aAAc,MACdC,SAAU,SACVC,WAAY,QACY,YAAvBnB,EAAWE,SAAyB,CACrCe,aAAcb,EAAMgB,MAAMH,cACF,WAAvBjB,EAAWE,SAAwB,CACpCe,aAAc,GACbjB,EAAWG,cAAgB,CAC5BkB,MAAOjB,EAAMkB,QAAQC,WAAWnC,QAChCoC,gBAAwC,UAAvBpB,EAAMkB,QAAQG,KAAmBrB,EAAMkB,QAAQI,KAAK,KAAOtB,EAAMkB,QAAQI,KAAK,SAE3FC,GAAY,EAAAjC,EAAA,IAAO,MAAO,CAC9BC,KAAM,YACNC,KAAM,MACNC,kBAAmB,CAACC,EAAOC,IAAWA,EAAO6B,KAH7B,CAIf,CACDlB,MAAO,OACPC,OAAQ,OACRkB,UAAW,SAEXC,UAAW,QAEXT,MAAO,cAEPU,WAAY,MAERC,GAAiB,EAAAtC,EAAA,IAAOuC,EAAQ,CACpCtC,KAAM,YACNC,KAAM,WACNC,kBAAmB,CAACC,EAAOC,IAAWA,EAAOmC,UAHxB,CAIpB,CACDxB,MAAO,MACPC,OAAQ,QAyLV,MAvI4B,cAAiB,SAAgBwB,EAASC,GACpE,MAAMtC,GAAQ,EAAAuC,EAAA,GAAc,CAC1BvC,MAAOqC,EACPxC,KAAM,eAGF,IACJ2C,EACAC,SAAUC,EAAY,UACtBC,EAAS,UACTC,EAAY,MAAK,SACjBC,EAAQ,MACRC,EAAK,IACLC,EAAG,OACHC,EAAM,QACN5C,EAAU,YACRJ,EACEiD,GAAQ,OAA8BjD,EAAON,GAEnD,IAAI+C,EAAW,KAEf,MAAMS,EApER,UAAmB,YACjBC,EAAW,eACXC,EAAc,IACdL,EAAG,OACHC,IAEA,MAAOE,EAAQG,GAAa,YAAe,GAsC3C,OArCA,aAAgB,KACd,IAAKN,IAAQC,EACX,OAGFK,GAAU,GACV,IAAIC,GAAS,EACb,MAAMC,EAAQ,IAAIC,MA0BlB,OAxBAD,EAAME,OAAS,KACRH,GAILD,EAAU,WAGZE,EAAMG,QAAU,KACTJ,GAILD,EAAU,UAGZE,EAAMJ,YAAcA,EACpBI,EAAMH,eAAiBA,EACvBG,EAAMR,IAAMA,EAERC,IACFO,EAAMI,OAASX,GAGV,KACLM,GAAS,KAEV,CAACH,EAAaC,EAAgBL,EAAKC,IAC/BE,EAwBQU,EAAU,OAAS,GAAIf,EAAU,CAC9CE,MACAC,YAEIa,EAASd,GAAOC,EAChBc,EAAmBD,GAAqB,UAAXX,EAE7BhD,GAAa,OAAS,GAAIF,EAAO,CACrCK,cAAeyD,EACflB,YACAxC,YAGI2D,EAzJkB7D,KACxB,MAAM,QACJ6D,EAAO,QACP3D,EAAO,aACPC,GACEH,EACE8D,EAAQ,CACZ7D,KAAM,CAAC,OAAQC,EAASC,GAAgB,gBACxCyB,IAAK,CAAC,OACNM,SAAU,CAAC,aAEb,OAAO,EAAA6B,EAAA,GAAeD,EAAO,IAAuBD,IA8IpCG,CAAkBhE,GAqBlC,OAlBEuC,EADEqB,GACsB,SAAKjC,GAAW,OAAS,CAC/CW,IAAKA,EACLO,IAAKA,EACLC,OAAQA,EACRF,MAAOA,EACP5C,WAAYA,EACZyC,UAAWoB,EAAQjC,KAClBe,IACsB,MAAhBH,EACEA,EACFmB,GAAUrB,EACRA,EAAI,IAES,SAAKN,EAAgB,CAC3CS,UAAWoB,EAAQ3B,YAIH,SAAKzC,GAAY,OAAS,CAC5CwE,GAAIvB,EACJ1C,WAAYA,EACZyC,WAAW,OAAKoB,EAAQ5D,KAAMwC,GAC9BL,IAAKA,GACJW,EAAO,CACRR,SAAUA,S,kFChMP,SAAS2B,EAAsBtE,GACpC,OAAO,OAAqB,YAAaA,GAE3C,MAAMuE,GAAgB,E,QAAA,GAAuB,YAAa,CAAC,OAAQ,eAAgB,WAAY,UAAW,SAAU,MAAO,aAC3H,O,gMCJO,SAASC,EAA2BxE,GACzC,OAAO,EAAAyE,EAAA,GAAqB,iBAAkBzE,GAGhD,OAD2B,E,QAAA,GAAuB,iBAAkB,CAAC,OAAQ,W,WCF7E,MAAMJ,EAAY,CAAC,WAAY,YAAa,kBAAmB,MAAO,UAAW,QAAS,WAYpF8E,EAAW,CACfC,OAAQ,GACRC,OAAQ,MAcJC,GAAkB,EAAA/E,EAAA,IAAO,MAAO,CACpCC,KAAM,iBACNC,KAAM,OACNC,kBAAmB,CAACC,EAAOC,KAAW,OAAS,CAC7C,CAAC,MAAM,EAAA2E,UAA8B3E,EAAO2E,QAC3C3E,EAAOE,OALY,EAMrB,EACDG,YACI,CACJ,CAAC,MAAM+D,EAAA,UAAuB,CAC5BQ,OAAQ,cAAcvE,EAAMwE,MAAQxE,GAAOkB,QAAQC,WAAWnC,UAC9DyF,UAAW,cACXC,YAAa,EACb,eAAgB,CACdA,WAAY,IAGhBxE,QAAS,OACTyE,cAAe,kBAEXC,GAAoB,EAAAtF,EAAA,IAAOuF,EAAA,EAAQ,CACvCtF,KAAM,iBACNC,KAAM,SACNC,kBAAmB,CAACC,EAAOC,IAAWA,EAAO2E,QAHrB,EAIvB,EACDtE,YACI,CACJuE,OAAQ,cAAcvE,EAAMwE,MAAQxE,GAAOkB,QAAQC,WAAWnC,UAC9DyF,UAAW,cACXC,YAAa,EACb,eAAgB,CACdA,WAAY,OAiJhB,MA9IiC,cAAiB,SAAqB3C,EAASC,GAC9E,IAAI8C,EAAuBC,EAE3B,MAAMrF,GAAQ,EAAAuC,EAAA,GAAc,CAC1BvC,MAAOqC,EACPxC,KAAM,oBAIN4C,SAAUC,EAAY,UACtBC,EAAS,gBACT2C,EAAkB,GAAE,IACpBC,EAAM,EAAC,QACPC,EAAU,SAAQ,MAClBC,EAAK,QACLrF,EAAU,YACRJ,EACEiD,GAAQ,OAA8BjD,EAAON,GAEnD,IAAIgG,EAAaH,EAAM,EAAI,EAAIA,EAE/B,MAAMrF,GAAa,OAAS,GAAIF,EAAO,CACrCuF,MACAC,UACApF,YAGI2D,EAxEkB7D,KACxB,MAAM,QACJ6D,GACE7D,EAKJ,OAAO,EAAA+D,EAAA,GAJO,CACZ9D,KAAM,CAAC,QACPyE,OAAQ,CAAC,WAEkBN,EAA4BP,IAgEzCG,CAAkBhE,GAC5BuC,EAAW,mBAAuBC,GAAciD,QAAOC,GAOvC,iBAAqBA,KAErCC,EAAeJ,GAAShD,EAASqD,OAEnCD,IAAiBH,IACnBA,GAAc,GAGhBA,EAAaK,KAAKC,IAAIH,EAAe,EAAGH,GACxC,MAAMO,EAAaF,KAAKC,IAAIvD,EAASqD,OAAQJ,EAAa,GACpDQ,EAAeH,KAAKR,IAAIM,EAAeH,EAAYG,EAAeI,EAAY,GAC9EjB,EAAaQ,QAAiCW,IAAtB3B,EAASgB,GAAyBhB,EAASgB,IAAYA,EACrF,OAAoB,UAAMb,GAAiB,OAAS,CAClDzE,WAAYA,EACZyC,WAAW,OAAKoB,EAAQ5D,KAAMwC,GAC9BL,IAAKA,GACJW,EAAO,CACRR,SAAU,CAACyD,GAA4B,UAAMhB,GAAmB,OAAS,CACvEhF,WAAYA,EACZE,QAASA,GACRkF,EAAgBc,iBAAkB,CACnCzD,WAAW,OAAKoB,EAAQa,OAAsE,OAA7DQ,EAAwBE,EAAgBc,uBAA4B,EAAShB,EAAsBzC,WACpI0D,OAAO,OAAS,CACdrB,cACgE,OAA9DK,EAAyBC,EAAgBc,uBAA4B,EAASf,EAAuBgB,OACzG5D,SAAU,CAAC,IAAKyD,MACZ,KAAMzD,EAAS6D,MAAM,EAAGL,GAAYM,UAAUC,KAAI,CAACZ,EAAOa,IAC1C,eAAmBb,EAAO,CAC5CjD,WAAW,OAAKiD,EAAM5F,MAAM2C,UAAWoB,EAAQa,QAC/CyB,OAAO,OAAS,CAGdrB,WAAYyB,IAAUR,EAAa,OAAIE,EAAYnB,GAClDY,EAAM5F,MAAMqG,OACfjG,QAASwF,EAAM5F,MAAMI,SAAWA,c,+JCpIjC,SAASsG,EAAyB5G,GACvC,OAAO,EAAAyE,EAAA,GAAqB,eAAgBzE,IAErB,E,QAAA,GAAuB,eAAgB,CAAC,OAAQ,QAAS,QAClF,I,WCHA,MAAMJ,EAAY,CAAC,WAAY,YAAa,YAAa,QAAS,MAAO,SAuBnEiH,GAAgB,EAAA/G,EAAA,IAAO,MAAO,CAClCC,KAAM,eACNC,KAAM,OACNC,kBAAmB,CAACC,EAAOC,KACzB,MAAM,WACJC,GACEF,GACE,iBACJ4G,EAAgB,iBAChBC,GACE3G,EACJ,MAAO,CAACD,EAAOE,KAAMyG,GAAoB3G,EAAO6G,MAAOD,GAAoB5G,EAAO6B,OAXhE,EAanB,EACD5B,iBACI,OAAS,CACbM,QAAS,QACTuG,eAAgB,QAChBC,iBAAkB,YAClBC,mBAAoB,UACnB/G,EAAW0G,kBAAoB,CAChChG,MAAO,QACNV,EAAW2G,kBAAoB,CAEhC7E,UAAW,YAEPkF,EAAmB,CAAC,QAAS,QAAS,UAAW,SAAU,OAC3DC,EAAmB,CAAC,UAAW,OAoGrC,MAnG+B,cAAiB,SAAmB9E,EAASC,GAC1E,MAAMtC,GAAQ,EAAAuC,EAAA,GAAc,CAC1BvC,MAAOqC,EACPxC,KAAM,kBAGF,SACJ4C,EAAQ,UACRE,EAAS,UACTC,EAAY,MAAK,MACjBW,EAAK,IACLR,EAAG,MACHsD,GACErG,EACEiD,GAAQ,OAA8BjD,EAAON,GAE7CkH,GAA4D,IAAzCM,EAAiBE,QAAQxE,GAC5CyE,GAAiBT,GAAoBrD,GAAQ,OAAS,CAC1D+D,gBAAiB,QAAQ/D,OACxB8C,GAASA,EAENnG,GAAa,OAAS,GAAIF,EAAO,CACrC4C,YACAgE,mBACAC,kBAA2D,IAAzCM,EAAiBC,QAAQxE,KAGvCmB,EAnEkB7D,KACxB,MAAM,QACJ6D,EAAO,iBACP6C,EAAgB,iBAChBC,GACE3G,EACE8D,EAAQ,CACZ7D,KAAM,CAAC,OAAQyG,GAAoB,QAASC,GAAoB,QAElE,OAAO,EAAA5C,EAAA,GAAeD,EAAO0C,EAA0B3C,IA0DvCG,CAAkBhE,GAClC,OAAoB,SAAKyG,GAAe,OAAS,CAC/ChE,WAAW,OAAKoB,EAAQ5D,KAAMwC,GAC9BwB,GAAIvB,EACJ2E,MAAOX,GAAoBrD,EAAQ,WAAQ4C,EAC3C7D,IAAKA,EACL+D,MAAOgB,EACPnH,WAAYA,EACZ6C,IAAK6D,EAAmBrD,GAASR,OAAMoD,GACtClD,EAAO,CACRR,SAAUA,S,+JCzFP,SAAS+E,EAAyB1H,GACvC,OAAO,EAAAyE,EAAA,GAAqB,eAAgBzE,IAErB,E,QAAA,GAAuB,eAAgB,CAAC,OAAQ,MAAO,UAChF,I,iCCHA,MAAMJ,EAAY,CAAC,YAAa,OAwB1B+H,GAAgB,EAAA7H,EAAA,IAAO,MAAO,CAClCC,KAAM,eACNC,KAAM,OACNC,kBAAmB,CAACC,EAAOC,KACzB,MAAM,WACJC,GACEF,EACJ,MAAO,CAACC,EAAOE,KAAMD,EAAWwH,KAAOzH,EAAOyH,OAP5B,EASnB,EACDxH,iBACI,OAAS,CACbM,QAAS,OACTyE,cAAe,SACf0C,SAAU,QACTzH,EAAWwH,KAAO,CACnBzC,cAAe,UAyEjB,MAjE+B,cAAiB,SAAmB5C,EAASC,GAC1E,MAAMtC,GAAQ,EAAAuC,EAAA,GAAc,CAC1BvC,MAAOqC,EACPxC,KAAM,kBAGF,UACJ8C,EAAS,IACT+E,GAAM,GACJ1H,EACEiD,GAAQ,OAA8BjD,EAAON,GAE7CkI,GAAiB,EAAAC,EAAA,KACjBC,GAAM,EAAAC,EAAA,GAAiB,CAC3B/H,QACA4H,iBACAI,OAAQ,CAAC,WAGL9H,GAAa,OAAS,GAAIF,EAAO,CACrC0H,MACAO,MAAOH,EAAIG,QAGPlE,EA5DkB7D,KACxB,MAAM,QACJ6D,EAAO,IACP2D,EAAG,MACHO,GACE/H,EACE8D,EAAQ,CACZ7D,KAAM,CAAC,OAAQuH,GAAO,MAAOO,GAAS,UAExC,OAAO,EAAAhE,EAAA,GAAeD,EAAOwD,EAA0BzD,IAmDvCG,CAAkBhE,GAClC,OAAoB,SAAKuH,GAAe,OAAS,CAC/C9E,WAAW,OAAKoB,EAAQ5D,KAAMwC,GAC9BzC,WAAYA,EACZoC,IAAKA,GACJW,Q,gMC9EE,SAASiF,EAA8BpI,GAC5C,OAAO,EAAAyE,EAAA,GAAqB,oBAAqBzE,GAGnD,ICFIqI,EDEJ,GAD8B,E,QAAA,GAAuB,oBAAqB,CAAC,OAAQ,SAAU,WAAY,WAAY,gBAAiB,cAAe,uBAAwB,cAAe,c,sBCC5L,MAAMzI,EAAY,CAAC,WAAY,YAAa,YAAa,uBAAwB,oBAAqB,WAAY,WAqC5G0I,GAAqB,EAAAxI,EAAA,IAAO,MAAO,CACvCC,KAAM,oBACNC,KAAM,OACNC,kBAzBwB,CAACC,EAAOC,KAChC,MAAM,WACJC,GACEF,EACJ,MAAO,CAACC,EAAOE,KAAMF,EAAO,YAAW,EAAAoI,EAAA,GAAWnI,EAAWK,cAAkD,IAApCL,EAAWoI,sBAAiCrI,EAAOqI,qBAAsBrI,EAAOC,EAAWE,YAkB7I,EAIxB,EACDE,QACAJ,iBACI,OAAS,CACbM,QAAS,OACTK,OAAQ,SAER0H,UAAW,MACX9H,WAAY,SACZ+H,WAAY,SACZjH,OAAQjB,EAAMwE,MAAQxE,GAAOkB,QAAQiH,OAAOnF,QACpB,WAAvBpD,EAAWE,SAAwB,CAEpC,CAAC,KAAK,yBAA6C,kBAAuC,CACxFsI,UAAW,KAEY,UAAxBxI,EAAWK,UAAwB,CAEpCoI,YAAa,GACY,QAAxBzI,EAAWK,UAAsB,CAElCyE,WAAY,IACyB,IAApC9E,EAAWoI,sBAAiC,CAE7CM,cAAe,WA4HjB,MA1HoC,cAAiB,SAAwBvG,EAASC,GACpF,MAAMtC,GAAQ,EAAAuC,EAAA,GAAc,CAC1BvC,MAAOqC,EACPxC,KAAM,uBAGF,SACJ4C,EAAQ,UACRE,EAAS,UACTC,EAAY,MAAK,qBACjB0F,GAAuB,EAAK,kBAC5BO,GAAoB,EAAK,SACzBtI,EACAH,QAAS0I,GACP9I,EACEiD,GAAQ,OAA8BjD,EAAON,GAE7CkI,GAAiB,EAAAC,EAAA,MAAoB,GAC3C,IAAIzH,EAAU0I,EAEVA,GAAelB,EAAexH,QAQ9BwH,IAAmBxH,IACrBA,EAAUwH,EAAexH,SAG3B,MAAMF,GAAa,OAAS,GAAIF,EAAO,CACrC+I,YAAanB,EAAemB,YAC5BC,KAAMpB,EAAeoB,KACrBV,uBACA/H,WACAH,YAGI2D,EArFkB7D,KACxB,MAAM,QACJ6D,EAAO,qBACPuE,EAAoB,YACpBS,EAAW,SACXxI,EAAQ,KACRyI,EAAI,QACJ5I,GACEF,EACE8D,EAAQ,CACZ7D,KAAM,CAAC,OAAQmI,GAAwB,uBAAwB/H,GAAY,YAAW,EAAA8H,EAAA,GAAW9H,KAAaH,EAAS2I,GAAe,cAAeC,GAAQ,QAAO,EAAAX,EAAA,GAAWW,OAEjL,OAAO,EAAA/E,EAAA,GAAeD,EAAOkE,EAA+BnE,IAyE5CG,CAAkBhE,GAClC,OAAoB,SAAK+I,EAAA,WAA6B,CACpDC,MAAO,KACPzG,UAAuB,SAAK2F,GAAoB,OAAS,CACvDjE,GAAIvB,EACJ1C,WAAYA,EACZyC,WAAW,OAAKoB,EAAQ5D,KAAMwC,GAC9BL,IAAKA,GACJW,EAAO,CACRR,SAA8B,kBAAbA,GAA0BoG,GAGzB,UAAM,WAAgB,CACtCpG,SAAU,CAAc,UAAblC,EAEX4H,IAAUA,GAAqB,SAAK,OAAQ,CAC1CxF,UAAW,cACXF,SAAU,YACN,KAAMA,MAT8D,SAAK0G,EAAA,EAAY,CAC3F5H,MAAO,iBACPkB,SAAUA,a,qLCzHlB,MAAM/C,EAAY,CAAC,YAAa,QAAS,QAAS,cAAe,WAEjE,IACI0J,EACAC,EACAC,EACAC,EACAC,EACAC,EANAC,EAAIC,GAAKA,EAoBb,MAEMC,GAAyB,QAAUR,IAAOA,EAAKM,CAAC;;;;;;;;;;;;;;;IAgBhDG,GAAyB,QAAUR,IAAQA,EAAMK,CAAC;;;;;;;;;;;;;;;IAgBlDI,GAAiB,QAAUR,IAAQA,EAAMI,CAAC;;;;;;;;;;;;;;;IAgC1CK,EAAgB,CAACzJ,EAAOiB,IACd,YAAVA,EACK,eAGqB,UAAvBjB,EAAMkB,QAAQG,MAAmB,QAAQrB,EAAMkB,QAAQD,GAAOyI,KAAM,MAAQ,QAAO1J,EAAMkB,QAAQD,GAAOyI,KAAM,IAGjHC,GAAqB,QAAO,OAAQ,CACxCpK,KAAM,oBACNC,KAAM,OACNC,kBAAmB,CAACC,EAAOC,KACzB,MAAM,WACJC,GACEF,EACJ,MAAO,CAACC,EAAOE,KAAMF,EAAO,SAAQ,OAAWC,EAAWqB,UAAWtB,EAAOC,EAAWE,YAPhE,EASxB,EACDF,aACAI,YACI,OAAS,CACbC,SAAU,WACVa,SAAU,SACVZ,QAAS,QACTK,OAAQ,EACRqJ,OAAQ,EAER,eAAgB,CACdC,YAAa,SAEfzI,gBAAiBqI,EAAczJ,EAAOJ,EAAWqB,QAC3B,YAArBrB,EAAWqB,OAA8C,WAAvBrB,EAAWE,SAAwB,CACtEsB,gBAAiB,OACjB,YAAa,CACX0I,QAAS,KACT7J,SAAU,WACV8J,KAAM,EACNC,IAAK,EACLC,MAAO,EACPC,OAAQ,EACR9I,gBAAiB,eACjB+I,QAAS,KAEa,WAAvBvK,EAAWE,SAAwB,CACpCsB,gBAAiB,eACO,UAAvBxB,EAAWE,SAAuB,CACnCsK,UAAW,qBAEPC,GAAuB,QAAO,OAAQ,CAC1C9K,KAAM,oBACNC,KAAM,SACNC,kBAAmB,CAACC,EAAOC,KACzB,MAAM,WACJC,GACEF,EACJ,MAAO,CAACC,EAAO2K,OAAQ3K,EAAO,eAAc,OAAWC,EAAWqB,aAPzC,EAS1B,EACDrB,aACAI,YAEA,MAAMoB,EAAkBqI,EAAczJ,EAAOJ,EAAWqB,OACxD,OAAO,OAAS,CACdhB,SAAU,WACVmI,UAAW,EACX7H,OAAQ,OACRD,MAAO,QACe,YAArBV,EAAWqB,OAAuB,CACnCkJ,QAAS,IACR,CACDnD,gBAAiB,mBAAmB5F,SAAuBA,0BAC3DqF,eAAgB,YAChBE,mBAAoB,eAErB,QAAIsC,IAAQA,EAAMG,CAAC;iBACL;KACXI,IACAe,GAAqB,QAAO,OAAQ,CACxChL,KAAM,oBACNC,KAAM,OACNC,kBAAmB,CAACC,EAAOC,KACzB,MAAM,WACJC,GACEF,EACJ,MAAO,CAACC,EAAO6K,IAAK7K,EAAO,YAAW,OAAWC,EAAWqB,WAAmC,kBAAvBrB,EAAWE,SAAsD,UAAvBF,EAAWE,UAAwBH,EAAO8K,kBAA0C,gBAAvB7K,EAAWE,SAA6BH,EAAO+K,gBAAwC,WAAvB9K,EAAWE,SAAwBH,EAAOgL,cAPlQ,EASxB,EACD/K,aACAI,YACI,OAAS,CACbM,MAAO,OACPL,SAAU,WACV8J,KAAM,EACNG,OAAQ,EACRF,IAAK,EACLY,WAAY,wBACZC,gBAAiB,OACjBzJ,gBAAsC,YAArBxB,EAAWqB,MAAsB,eAAiBjB,EAAMkB,QAAQtB,EAAWqB,OAAOyI,MAC3E,gBAAvB9J,EAAWE,SAA6B,CACzC8K,WAAY,wBACY,WAAvBhL,EAAWE,SAAwB,CACpC8J,OAAQ,EACRgB,WAAY,2BACV,EACFhL,iBAC4B,kBAAvBA,EAAWE,SAAsD,UAAvBF,EAAWE,WAAwB,QAAIoJ,IAAQA,EAAME,CAAC;;mBAEpF;OACXE,KACFwB,GAAqB,QAAO,OAAQ,CACxCvL,KAAM,oBACNC,KAAM,OACNC,kBAAmB,CAACC,EAAOC,KACzB,MAAM,WACJC,GACEF,EACJ,MAAO,CAACC,EAAO6K,IAAK7K,EAAO,YAAW,OAAWC,EAAWqB,WAAmC,kBAAvBrB,EAAWE,SAAsD,UAAvBF,EAAWE,UAAwBH,EAAOoL,kBAA0C,WAAvBnL,EAAWE,SAAwBH,EAAOqL,cAPlM,EASxB,EACDpL,aACAI,YACI,OAAS,CACbM,MAAO,OACPL,SAAU,WACV8J,KAAM,EACNG,OAAQ,EACRF,IAAK,EACLY,WAAY,wBACZC,gBAAiB,QACO,WAAvBjL,EAAWE,SAAwB,CACpCsB,gBAAsC,YAArBxB,EAAWqB,MAAsB,eAAiBjB,EAAMkB,QAAQtB,EAAWqB,OAAOyI,MAC7E,YAArB9J,EAAWqB,OAAuB,CACnCkJ,QAAS,IACe,WAAvBvK,EAAWE,SAAwB,CACpCsB,gBAAiBqI,EAAczJ,EAAOJ,EAAWqB,OACjD2J,WAAY,2BACV,EACFhL,iBAC4B,kBAAvBA,EAAWE,SAAsD,UAAvBF,EAAWE,WAAwB,QAAIqJ,IAAQA,EAAMC,CAAC;;mBAEpF;OACXG,KASF0B,EAA8B,cAAiB,SAAwBlJ,EAASC,GACpF,MAAMtC,GAAQ,OAAc,CAC1BA,MAAOqC,EACPxC,KAAM,uBAGF,UACJ8C,EAAS,MACTpB,EAAQ,UAAS,MACjB2H,EAAK,YACLsC,EAAW,QACXpL,EAAU,iBACRJ,EACEiD,GAAQ,OAA8BjD,EAAON,GAE7CQ,GAAa,OAAS,GAAIF,EAAO,CACrCuB,QACAnB,YAGI2D,EAzLkB7D,KACxB,MAAM,QACJ6D,EAAO,QACP3D,EAAO,MACPmB,GACErB,EACE8D,EAAQ,CACZ7D,KAAM,CAAC,OAAQ,SAAQ,OAAWoB,KAAUnB,GAC5CwK,OAAQ,CAAC,SAAU,eAAc,OAAWrJ,MAC5CkK,KAAM,CAAC,MAAO,YAAW,OAAWlK,MAAuB,kBAAZnB,GAA2C,UAAZA,IAAwB,oBAAiC,gBAAZA,GAA6B,kBAA+B,WAAZA,GAAwB,cACnMsL,KAAM,CAAC,MAAmB,WAAZtL,GAAwB,YAAW,OAAWmB,KAAsB,WAAZnB,GAAwB,SAAQ,OAAWmB,MAAuB,kBAAZnB,GAA2C,UAAZA,IAAwB,oBAAiC,WAAZA,GAAwB,eAElO,OAAO,OAAe4D,EAAO,IAA+BD,IA6K5CG,CAAkBhE,GAC5BI,GAAQ,SACRqL,EAAY,GACZC,EAAe,CACnBH,KAAM,GACNC,KAAM,IAGR,GAAgB,gBAAZtL,GAAyC,WAAZA,EAC/B,QAAc+F,IAAV+C,EAAqB,CACvByC,EAAU,iBAAmB5F,KAAK8F,MAAM3C,GACxCyC,EAAU,iBAAmB,EAC7BA,EAAU,iBAAmB,IAC7B,IAAIjB,EAAYxB,EAAQ,IAEA,QAApB5I,EAAMwL,YACRpB,GAAaA,GAGfkB,EAAaH,KAAKf,UAAY,cAAcA,WACnC,EAKb,GAAgB,WAAZtK,EACF,QAAoB+F,IAAhBqF,EAA2B,CAC7B,IAAId,GAAac,GAAe,GAAK,IAEb,QAApBlL,EAAMwL,YACRpB,GAAaA,GAGfkB,EAAaF,KAAKhB,UAAY,cAAcA,WACnC,EAKb,OAAoB,UAAMT,GAAoB,OAAS,CACrDtH,WAAW,OAAKoB,EAAQ5D,KAAMwC,GAC9BzC,WAAYA,EACZqH,KAAM,eACLoE,EAAW,CACZrJ,IAAKA,GACJW,EAAO,CACRR,SAAU,CAAa,WAAZrC,GAAoC,SAAKuK,EAAsB,CACxEhI,UAAWoB,EAAQ6G,OACnB1K,WAAYA,IACT,MAAmB,SAAK2K,EAAoB,CAC/ClI,UAAWoB,EAAQ0H,KACnBvL,WAAYA,EACZmG,MAAOuF,EAAaH,OACN,gBAAZrL,EAA4B,MAAoB,SAAKgL,EAAoB,CAC3EzI,UAAWoB,EAAQ2H,KACnBxL,WAAYA,EACZmG,MAAOuF,EAAaF,cAwD1B,O,kFCnXO,SAASK,EAA8BjM,GAC5C,OAAO,OAAqB,oBAAqBA,GAEnD,MAAMkM,GAAwB,E,QAAA,GAAuB,oBAAqB,CAAC,OAAQ,eAAgB,iBAAkB,cAAe,gBAAiB,SAAU,QAAS,SAAU,qBAAsB,uBAAwB,MAAO,kBAAmB,oBAAqB,oBAAqB,kBAAmB,aAAc,oBAAqB,eAC1V,O,qLCJO,SAASC,EAAmBnM,GACjC,OAAO,EAAAyE,EAAA,GAAqB,SAAUzE,GAGxC,OADmB,E,QAAA,GAAuB,SAAU,CAAC,OAAQ,YAAa,mBAAoB,mBAAoB,qBAAsB,WAAY,WAAY,YAAa,UAAW,gB,WCFxL,MAAMJ,EAAY,CAAC,YAAa,WAAY,qBAAsB,YAAa,OAAQ,eAAgB,YAAa,QAAS,WAAY,UAAW,UAAW,WAAY,wBAAyB,YAAa,QAAS,WA+BpNwM,GAAU,EAAAtM,EAAA,IAAOuM,EAAA,EAAY,CACjCtM,KAAM,SACNC,KAAM,OACNC,kBAAmB,CAACC,EAAOC,KACzB,MAAM,WACJC,GACEF,EACJ,MAAO,CAACC,EAAOE,KAAMD,EAAWkM,OAASlM,EAAWmM,MAAQpM,EAAOqM,UAAWrM,EAAO,aAAY,EAAAoI,EAAA,GAAWnI,EAAWqM,cAAerM,EAAWsM,WAAavM,EAAOuM,UAAWtM,EAAWuM,SAAWxM,EAAOwM,WAPjM,EASb,EACDnM,QACAJ,iBACI,OAAS,GAAII,EAAMS,WAAW2L,OAAQ,CAC1CC,SAAU,IACVC,SAAU,GACVrM,SAAU,WACVsM,UAAW,GACXlM,WAAY,EACZmM,QAAS,YACT1L,SAAU,SACVoH,WAAY,SACZzG,UAAW,UACV7B,EAAWkM,OAAS,CACrBnH,cAA2C,QAA5B/E,EAAW6M,cAAsD,WAA5B7M,EAAW6M,aAA4B,SAAW,OACrG,CACD7L,WAAY,MACXhB,EAAWmM,MAAQnM,EAAWkM,OAAS,CACxCS,UAAW,GACXG,WAAY,EACZC,cAAe,EACf,CAAC,QAAQ,kBAA2B,OAAS,GAAgC,QAA5B/M,EAAW6M,cAA0B,CACpFG,aAAc,GACe,WAA5BhN,EAAW6M,cAA6B,CACzCrE,UAAW,GACkB,UAA5BxI,EAAW6M,cAA4B,CACxCpE,YAAarI,EAAMkF,QAAQ,IACE,QAA5BtF,EAAW6M,cAA0B,CACtC/H,WAAY1E,EAAMkF,QAAQ,MAEF,YAAzBtF,EAAWqM,WAA2B,CACvChL,MAAO,UACPkJ,QAAS,GAET,CAAC,KAAK,cAAwB,CAC5BA,QAAS,GAEX,CAAC,KAAK,cAAwB,CAC5BA,SAAUnK,EAAMwE,MAAQxE,GAAOkB,QAAQiH,OAAO0E,kBAEtB,YAAzBjN,EAAWqM,WAA2B,CACvChL,OAAQjB,EAAMwE,MAAQxE,GAAOkB,QAAQ4L,KAAKC,UAC1C,CAAC,KAAK,cAAwB,CAC5B9L,OAAQjB,EAAMwE,MAAQxE,GAAOkB,QAAQ8L,QAAQtD,MAE/C,CAAC,KAAK,cAAwB,CAC5BzI,OAAQjB,EAAMwE,MAAQxE,GAAOkB,QAAQ4L,KAAKG,WAElB,cAAzBrN,EAAWqM,WAA6B,CACzChL,OAAQjB,EAAMwE,MAAQxE,GAAOkB,QAAQ4L,KAAKC,UAC1C,CAAC,KAAK,cAAwB,CAC5B9L,OAAQjB,EAAMwE,MAAQxE,GAAOkB,QAAQ6L,UAAUrD,MAEjD,CAAC,KAAK,cAAwB,CAC5BzI,OAAQjB,EAAMwE,MAAQxE,GAAOkB,QAAQ4L,KAAKG,WAE3CrN,EAAWsM,WAAa,CACzB7L,WAAY,EACZ6M,SAAU,EACVC,UAAW,EACXd,SAAU,QACTzM,EAAWuM,SAAW,CACvBzL,SAAUV,EAAMS,WAAWE,QAAQ,QAsLrC,MApLyB,cAAiB,SAAaoB,EAASC,GAC9D,MAAMtC,GAAQ,EAAAuC,EAAA,GAAc,CAC1BvC,MAAOqC,EACPxC,KAAM,YAGF,UACJ8C,EAAS,SACT4K,GAAW,EAAK,mBAChBG,GAAqB,EAAK,UAE1BlB,EACAH,KAAMsB,EAAQ,aACdZ,EAAe,MAAK,UAEpBa,EAAS,MACTxB,EAAK,SACLyB,EAAQ,QACRC,EAAO,QACPC,EAAO,SAEPC,EAAQ,sBAERC,EAAqB,UAErB1B,EAAY,UAAS,MACrBrD,EAAK,QACLuD,GAAU,GACRzM,EACEiD,GAAQ,OAA8BjD,EAAON,GAE7CQ,GAAa,OAAS,GAAIF,EAAO,CACrCuN,WACAG,qBACAM,WACA3B,OAAQsB,EACRZ,eACAX,QAASA,EACTI,YACAD,YACAE,YAGI1I,EAtIkB7D,KACxB,MAAM,QACJ6D,EAAO,UACPwI,EAAS,UACTC,EAAS,QACTC,EAAO,KACPJ,EAAI,MACJD,EAAK,SACL4B,EAAQ,SACRT,GACErN,EACE8D,EAAQ,CACZ7D,KAAM,CAAC,OAAQkM,GAAQD,GAAS,YAAa,aAAY,EAAA/D,EAAA,GAAWkE,KAAcC,GAAa,YAAaC,GAAW,UAAWuB,GAAY,WAAYT,GAAY,YACtKW,YAAa,CAAC,gBAEhB,OAAO,EAAAjK,EAAA,GAAeD,EAAOiI,EAAoBlI,IAuHjCG,CAAkBhE,GAC5BmM,EAAOsB,GAAYvB,GAAsB,iBAAqBuB,GAAyB,eAAmBA,EAAU,CACxHhL,WAAW,OAAKoB,EAAQmK,YAAaP,EAAS3N,MAAM2C,aACjDgL,EAsBL,OAAoB,UAAMzB,GAAS,OAAS,CAC1CiC,aAAcT,EACd/K,WAAW,OAAKoB,EAAQ5D,KAAMwC,GAC9BL,IAAKA,EACLiF,KAAM,MACN,gBAAiByG,EACjBT,SAAUA,EACVO,QA3BkBM,KACbJ,GAAYH,GACfA,EAASO,EAAOlF,GAGd4E,GACFA,EAAQM,IAsBVL,QAlBkBK,IACdH,IAA0BD,GAAYH,GACxCA,EAASO,EAAOlF,GAGd6E,GACFA,EAAQK,IAaVlO,WAAYA,EACZmO,SAAUL,EAAW,GAAK,GACzB/K,EAAO,CACRR,SAAU,CAAkB,QAAjBsK,GAA2C,UAAjBA,GAAwC,UAAM,WAAgB,CACjGtK,SAAU,CAAC4J,EAAMD,MACD,UAAM,WAAgB,CACtC3J,SAAU,CAAC2J,EAAOC,KAChBuB,U,mCC5LR,MAAMU,GAAM,E,SAAA,KAyBZ,O,kBC3BoEC,EAAOrP,QAAkI,WAAY,aAAa,IAAIyK,EAAE,IAAI6E,EAAE,IAAIC,EAAE,KAAKC,EAAE,cAAcC,EAAE,SAASC,EAAE,SAASC,EAAE,OAAOC,EAAE,MAAMC,EAAE,OAAOC,EAAE,QAAQC,EAAE,UAAUC,EAAE,OAAO1P,EAAE,OAAO2P,EAAE,eAAeC,EAAE,6FAA6FC,EAAE,sFAAsFC,EAAE,CAACzP,KAAK,KAAK0P,SAAS,2DAA2DC,MAAM,KAAKC,OAAO,wFAAwFD,MAAM,MAAME,EAAE,SAAS/F,EAAE6E,EAAEC,GAAG,IAAIC,EAAEiB,OAAOhG,GAAG,OAAO+E,GAAGA,EAAE5I,QAAQ0I,EAAE7E,EAAE,GAAGiG,MAAMpB,EAAE,EAAEE,EAAE5I,QAAQ+J,KAAKpB,GAAG9E,GAAGmG,EAAE,CAAClB,EAAEc,EAAEK,EAAE,SAASpG,GAAG,IAAI6E,GAAG7E,EAAEqG,YAAYvB,EAAE1I,KAAKkK,IAAIzB,GAAGE,EAAE3I,KAAKmK,MAAMzB,EAAE,IAAIE,EAAEF,EAAE,GAAG,OAAOD,GAAG,EAAE,IAAI,KAAKkB,EAAEhB,EAAE,EAAE,KAAK,IAAIgB,EAAEf,EAAE,EAAE,MAAMe,EAAE,SAAS/F,EAAE6E,EAAEC,GAAG,GAAGD,EAAE2B,OAAO1B,EAAE0B,OAAO,OAAOxG,EAAE8E,EAAED,GAAG,IAAIE,EAAE,IAAID,EAAE2B,OAAO5B,EAAE4B,SAAS3B,EAAE4B,QAAQ7B,EAAE6B,SAAS1B,EAAEH,EAAE8B,QAAQC,IAAI7B,EAAEM,GAAGJ,EAAEH,EAAEE,EAAE,EAAEE,EAAEL,EAAE8B,QAAQC,IAAI7B,GAAGE,GAAG,EAAE,GAAGI,GAAG,UAAUN,GAAGD,EAAEE,IAAIC,EAAED,EAAEE,EAAEA,EAAEF,KAAK,IAAIG,EAAE,SAASnF,GAAG,OAAOA,EAAE,EAAE5D,KAAKyK,KAAK7G,IAAI,EAAE5D,KAAKmK,MAAMvG,IAAI8G,EAAE,SAAS9G,GAAG,MAAM,CAAC2F,EAAEN,EAAEK,EAAEH,EAAEwB,EAAE3B,EAAEvP,EAAEsP,EAAE6B,EAAEnR,EAAEyP,EAAEJ,EAAEa,EAAEd,EAAEA,EAAED,EAAEiC,GAAGlC,EAAEmC,EAAE5B,GAAGtF,IAAIgG,OAAOhG,GAAG,IAAImH,cAAcC,QAAQ,KAAK,KAAKlC,EAAE,SAASlF,GAAG,YAAO,IAASA,IAAIqH,EAAE,KAAKL,EAAE,GAAGA,EAAEK,GAAG1B,EAAE,IAAImB,EAAE,SAAS9G,GAAG,OAAOA,aAAaD,GAAGuH,EAAE,SAAStH,EAAE6E,EAAEC,EAAEC,GAAG,IAAIC,EAAE,IAAIH,EAAE,OAAOwC,EAAE,GAAG,iBAAiBxC,EAAE,CAAC,IAAII,EAAEJ,EAAEsC,cAAcH,EAAE/B,KAAKD,EAAEC,GAAGH,IAAIkC,EAAE/B,GAAGH,EAAEE,EAAEC,GAAG,IAAIC,EAAEL,EAAEgB,MAAM,KAAK,IAAIb,GAAGE,EAAE/I,OAAO,EAAE,OAAO6D,EAAEkF,EAAE,QAAQ,CAAC,IAAIC,EAAEN,EAAE3O,KAAK8Q,EAAE7B,GAAGN,EAAEG,EAAEG,EAAE,OAAOJ,GAAGC,IAAIqC,EAAErC,GAAGA,IAAID,GAAGsC,GAAGN,EAAE,SAAS/G,EAAE6E,GAAG,GAAGiC,EAAE9G,GAAG,OAAOA,EAAE2G,QAAQ,IAAI7B,EAAE,iBAAiBD,EAAEA,EAAE,GAAG,OAAOC,EAAE0B,KAAKxG,EAAE8E,EAAEyC,KAAKC,UAAU,IAAIzH,EAAE+E,IAAI2C,EAAEtB,EAAEsB,EAAEhC,EAAE6B,EAAEG,EAAEzC,EAAE8B,EAAEW,EAAEV,EAAE,SAAS/G,EAAE6E,GAAG,OAAOkC,EAAE/G,EAAE,CAAC0H,OAAO7C,EAAE8C,GAAGC,IAAI/C,EAAEgD,GAAGC,EAAEjD,EAAEkD,GAAGC,QAAQnD,EAAEmD,WAAW,IAAIjI,EAAE,WAAW,SAAS4F,EAAE3F,GAAGiI,KAAKN,GAAGL,EAAEtH,EAAE0H,OAAO,MAAK,GAAIO,KAAKC,MAAMlI,GAAG,IAAI+F,EAAEJ,EAAEwC,UAAU,OAAOpC,EAAEmC,MAAM,SAASlI,GAAGiI,KAAKG,GAAG,SAASpI,GAAG,IAAI6E,EAAE7E,EAAEwG,KAAK1B,EAAE9E,EAAE4H,IAAI,GAAG,OAAO/C,EAAE,OAAO,IAAIwD,KAAKC,KAAK,GAAGb,EAAEvC,EAAEL,GAAG,OAAO,IAAIwD,KAAK,GAAGxD,aAAawD,KAAK,OAAO,IAAIA,KAAKxD,GAAG,GAAG,iBAAiBA,IAAI,MAAM0D,KAAK1D,GAAG,CAAC,IAAIE,EAAEF,EAAE2D,MAAM/C,GAAG,GAAGV,EAAE,CAAC,IAAIC,EAAED,EAAE,GAAG,GAAG,EAAEE,GAAGF,EAAE,IAAI,KAAK0D,UAAU,EAAE,GAAG,OAAO3D,EAAE,IAAIuD,KAAKA,KAAKK,IAAI3D,EAAE,GAAGC,EAAED,EAAE,IAAI,EAAEA,EAAE,IAAI,EAAEA,EAAE,IAAI,EAAEA,EAAE,IAAI,EAAEE,IAAI,IAAIoD,KAAKtD,EAAE,GAAGC,EAAED,EAAE,IAAI,EAAEA,EAAE,IAAI,EAAEA,EAAE,IAAI,EAAEA,EAAE,IAAI,EAAEE,IAAI,OAAO,IAAIoD,KAAKxD,GAAzX,CAA6X7E,GAAGiI,KAAKF,GAAG/H,EAAE8H,GAAG,GAAGG,KAAKU,QAAQ5C,EAAE4C,KAAK,WAAW,IAAI3I,EAAEiI,KAAKG,GAAGH,KAAKW,GAAG5I,EAAE6I,cAAcZ,KAAKa,GAAG9I,EAAE+I,WAAWd,KAAKe,GAAGhJ,EAAEiJ,UAAUhB,KAAKiB,GAAGlJ,EAAEmJ,SAASlB,KAAKmB,GAAGpJ,EAAEqJ,WAAWpB,KAAKqB,GAAGtJ,EAAEuJ,aAAatB,KAAKuB,GAAGxJ,EAAEyJ,aAAaxB,KAAKyB,IAAI1J,EAAE2J,mBAAmB5D,EAAE6D,OAAO,WAAW,OAAOnC,GAAG1B,EAAE8D,QAAQ,WAAW,QAAQ5B,KAAKG,GAAG0B,aAAatE,IAAIO,EAAEgE,OAAO,SAAS/J,EAAE6E,GAAG,IAAIC,EAAEiC,EAAE/G,GAAG,OAAOiI,KAAK+B,QAAQnF,IAAIC,GAAGA,GAAGmD,KAAKgC,MAAMpF,IAAIkB,EAAEmE,QAAQ,SAASlK,EAAE6E,GAAG,OAAOkC,EAAE/G,GAAGiI,KAAK+B,QAAQnF,IAAIkB,EAAEoE,SAAS,SAASnK,EAAE6E,GAAG,OAAOoD,KAAKgC,MAAMpF,GAAGkC,EAAE/G,IAAI+F,EAAEqE,GAAG,SAASpK,EAAE6E,EAAEC,GAAG,OAAO2C,EAAEvC,EAAElF,GAAGiI,KAAKpD,GAAGoD,KAAKoC,IAAIvF,EAAE9E,IAAI+F,EAAEuE,KAAK,WAAW,OAAOlO,KAAKmK,MAAM0B,KAAKsC,UAAU,MAAMxE,EAAEwE,QAAQ,WAAW,OAAOtC,KAAKG,GAAGoC,WAAWzE,EAAEiE,QAAQ,SAAShK,EAAE6E,GAAG,IAAIC,EAAEmD,KAAKlD,IAAI0C,EAAEvC,EAAEL,IAAIA,EAAES,EAAEmC,EAAEX,EAAE9G,GAAGwF,EAAE,SAASxF,EAAE6E,GAAG,IAAIG,EAAEyC,EAAEV,EAAEjC,EAAE+C,GAAGQ,KAAKK,IAAI5D,EAAE8D,GAAG/D,EAAE7E,GAAG,IAAIqI,KAAKvD,EAAE8D,GAAG/D,EAAE7E,GAAG8E,GAAG,OAAOC,EAAEC,EAAEA,EAAEiF,MAAM9E,IAAIM,EAAE,SAASzF,EAAE6E,GAAG,OAAO4C,EAAEV,EAAEjC,EAAE2F,SAASzK,GAAG0K,MAAM5F,EAAE2F,OAAO,MAAM1F,EAAE,CAAC,EAAE,EAAE,EAAE,GAAG,CAAC,GAAG,GAAG,GAAG,MAAMpI,MAAMkI,IAAIC,IAAIY,EAAEuC,KAAKiB,GAAGvD,EAAEsC,KAAKa,GAAG/C,EAAEkC,KAAKe,GAAG7C,EAAE,OAAO8B,KAAKJ,GAAG,MAAM,IAAI,OAAOvC,GAAG,KAAKC,EAAE,OAAOR,EAAES,EAAE,EAAE,GAAGA,EAAE,GAAG,IAAI,KAAKH,EAAE,OAAON,EAAES,EAAE,EAAEG,GAAGH,EAAE,EAAEG,EAAE,GAAG,KAAKP,EAAE,IAAIiC,EAAEY,KAAK0C,UAAUC,WAAW,EAAE5D,GAAGtB,EAAE2B,EAAE3B,EAAE,EAAEA,GAAG2B,EAAE,OAAO7B,EAAET,EAAEgB,EAAEiB,EAAEjB,GAAG,EAAEiB,GAAGrB,GAAG,KAAKR,EAAE,KAAKtP,EAAE,OAAO4P,EAAEU,EAAE,QAAQ,GAAG,KAAKjB,EAAE,OAAOO,EAAEU,EAAE,UAAU,GAAG,KAAKlB,EAAE,OAAOQ,EAAEU,EAAE,UAAU,GAAG,KAAKnB,EAAE,OAAOS,EAAEU,EAAE,eAAe,GAAG,QAAQ,OAAO8B,KAAKtB,UAAUZ,EAAEkE,MAAM,SAASjK,GAAG,OAAOiI,KAAK+B,QAAQhK,GAAE,IAAK+F,EAAE8E,KAAK,SAAS7K,EAAE6E,GAAG,IAAIC,EAAEM,EAAEqC,EAAEX,EAAE9G,GAAGsF,EAAE,OAAO2C,KAAKJ,GAAG,MAAM,IAAIrC,GAAGV,EAAE,GAAGA,EAAEK,GAAGG,EAAE,OAAOR,EAAEjP,GAAGyP,EAAE,OAAOR,EAAEO,GAAGC,EAAE,QAAQR,EAAES,GAAGD,EAAE,WAAWR,EAAEI,GAAGI,EAAE,QAAQR,EAAEG,GAAGK,EAAE,UAAUR,EAAEE,GAAGM,EAAE,UAAUR,EAAEC,GAAGO,EAAE,eAAeR,GAAGM,GAAGK,EAAEL,IAAID,EAAE8C,KAAKe,IAAInE,EAAEoD,KAAKiB,IAAIrE,EAAE,GAAGO,IAAIC,GAAGD,IAAIG,EAAE,CAAC,IAAIG,EAAEuC,KAAKtB,QAAQ0D,IAAIxU,EAAE,GAAG6P,EAAE0C,GAAG5C,GAAGC,GAAGC,EAAEiD,OAAOV,KAAKG,GAAG1C,EAAE2E,IAAIxU,EAAEuG,KAAKC,IAAI4L,KAAKe,GAAGtD,EAAEoF,gBAAgB1C,QAAQ5C,GAAGyC,KAAKG,GAAG5C,GAAGC,GAAG,OAAOwC,KAAKU,OAAOV,MAAMlC,EAAEsE,IAAI,SAASrK,EAAE6E,GAAG,OAAOoD,KAAKtB,QAAQkE,KAAK7K,EAAE6E,IAAIkB,EAAEgF,IAAI,SAAS/K,GAAG,OAAOiI,KAAKR,EAAEX,EAAE9G,OAAO+F,EAAEa,IAAI,SAAS7B,EAAEO,GAAG,IAAIzP,EAAE2P,EAAEyC,KAAKlD,EAAEiG,OAAOjG,GAAG,IAAIU,EAAEgC,EAAEX,EAAExB,GAAGI,EAAE,SAAS1F,GAAG,IAAI6E,EAAEkC,EAAEvB,GAAG,OAAOiC,EAAEV,EAAElC,EAAE2B,KAAK3B,EAAE2B,OAAOpK,KAAK8F,MAAMlC,EAAE+E,IAAIS,IAAI,GAAGC,IAAIJ,EAAE,OAAO4C,KAAKoC,IAAIhF,EAAE4C,KAAKa,GAAG/D,GAAG,GAAGU,IAAIF,EAAE,OAAO0C,KAAKoC,IAAI9E,EAAE0C,KAAKW,GAAG7D,GAAG,GAAGU,IAAIN,EAAE,OAAOO,EAAE,GAAG,GAAGD,IAAIL,EAAE,OAAOM,EAAE,GAAG,IAAIC,GAAG9P,EAAE,GAAGA,EAAEoP,GAAGJ,EAAEhP,EAAEqP,GAAGJ,EAAEjP,EAAEmP,GAAGhF,EAAEnK,GAAG4P,IAAI,EAAEM,EAAEkC,KAAKG,GAAGoC,UAAUzF,EAAEY,EAAE,OAAO8B,EAAEV,EAAEhB,EAAEkC,OAAOlC,EAAEkF,SAAS,SAASjL,EAAE6E,GAAG,OAAOoD,KAAKrB,KAAK,EAAE5G,EAAE6E,IAAIkB,EAAEmF,OAAO,SAASlL,GAAG,IAAI6E,EAAEoD,KAAKnD,EAAEmD,KAAK0C,UAAU,IAAI1C,KAAK4B,UAAU,OAAO/E,EAAEqG,aAAa3F,EAAE,IAAIT,EAAE/E,GAAG,uBAAuBgF,EAAEyC,EAAErB,EAAE6B,MAAMhD,EAAEgD,KAAKmB,GAAGlE,EAAE+C,KAAKqB,GAAGnE,EAAE8C,KAAKa,GAAG1D,EAAEN,EAAEc,SAASP,EAAEP,EAAEgB,OAAOR,EAAE,SAAStF,EAAE8E,EAAEE,EAAEC,GAAG,OAAOjF,IAAIA,EAAE8E,IAAI9E,EAAE6E,EAAEE,KAAKC,EAAEF,GAAGnI,MAAM,EAAEsI,IAAIM,EAAE,SAASvF,GAAG,OAAOyH,EAAExC,EAAEA,EAAE,IAAI,GAAGjF,EAAE,MAAMnK,EAAEiP,EAAEsG,UAAU,SAASpL,EAAE6E,EAAEC,GAAG,IAAIC,EAAE/E,EAAE,GAAG,KAAK,KAAK,OAAO8E,EAAEC,EAAEoC,cAAcpC,GAAGU,EAAE,CAAC4F,GAAGrF,OAAOiC,KAAKW,IAAIjM,OAAO,GAAG2O,KAAKrD,KAAKW,GAAGjD,EAAER,EAAE,EAAEoG,GAAG9D,EAAExC,EAAEE,EAAE,EAAE,EAAE,KAAKqG,IAAIlG,EAAER,EAAE2G,YAAYtG,EAAEE,EAAE,GAAGqG,KAAKpG,EAAED,EAAEF,GAAG6B,EAAEiB,KAAKe,GAAG2C,GAAGlE,EAAExC,EAAEgD,KAAKe,GAAG,EAAE,KAAKnT,EAAEmQ,OAAOiC,KAAKiB,IAAI0C,GAAGtG,EAAER,EAAE+G,YAAY5D,KAAKiB,GAAG9D,EAAE,GAAG0G,IAAIxG,EAAER,EAAEiH,cAAc9D,KAAKiB,GAAG9D,EAAE,GAAG4G,KAAK5G,EAAE6C,KAAKiB,IAAI+C,EAAEjG,OAAOf,GAAGiH,GAAGzE,EAAExC,EAAEA,EAAE,EAAE,KAAKK,EAAEC,EAAE,GAAG4G,GAAG5G,EAAE,GAAGJ,EAAEtP,EAAEoP,EAAEC,GAAE,GAAIkH,EAAEvW,EAAEoP,EAAEC,GAAE,GAAIa,EAAEC,OAAOd,GAAGmH,GAAG5E,EAAExC,EAAEC,EAAE,EAAE,KAAKD,EAAEe,OAAOiC,KAAKuB,IAAI8C,GAAG7E,EAAExC,EAAEgD,KAAKuB,GAAG,EAAE,KAAK+C,IAAI9E,EAAExC,EAAEgD,KAAKyB,IAAI,EAAE,KAAK8C,EAAExH,GAAG,OAAOD,EAAEqC,QAAQ1B,GAAE,SAAU1F,EAAE6E,GAAG,OAAOA,GAAGY,EAAEzF,IAAIgF,EAAEoC,QAAQ,IAAI,QAAQrB,EAAEM,UAAU,WAAW,OAAO,IAAIjK,KAAK8F,MAAM+F,KAAKG,GAAGqE,oBAAoB,KAAK1G,EAAE2G,KAAK,SAAS3H,EAAElP,EAAE2P,GAAG,IAAIC,EAAEC,EAAE+B,EAAEX,EAAEjR,GAAG8P,EAAEoB,EAAEhC,GAAGgB,GAAGJ,EAAEU,YAAY4B,KAAK5B,aAAaxB,EAAEsB,EAAE8B,KAAKtC,EAAE0B,EAAEI,EAAE1B,EAAEkC,KAAKtC,GAAG,OAAO0B,GAAG5B,EAAE,GAAGA,EAAEF,GAAG8B,EAAE,GAAG5B,EAAEJ,GAAGgC,EAAE5B,EAAEH,GAAG+B,EAAE,EAAE5B,EAAEL,IAAIe,EAAEJ,GAAG,OAAON,EAAEN,IAAIgB,EAAEJ,GAAG,MAAMN,EAAEP,GAAGiB,EAAErB,EAAEW,EAAER,GAAGkB,EAAEtB,EAAEY,EAAET,GAAGmB,EAAEnG,EAAEyF,GAAGC,IAAIS,EAAEX,EAAE6B,EAAEI,EAAEtC,EAAEkC,IAAItB,EAAE+E,YAAY,WAAW,OAAO7C,KAAKgC,MAAM5E,GAAG2D,IAAIjD,EAAE4E,QAAQ,WAAW,OAAO3D,EAAEiB,KAAKN,KAAK5B,EAAE2B,OAAO,SAAS1H,EAAE6E,GAAG,IAAI7E,EAAE,OAAOiI,KAAKN,GAAG,IAAI7C,EAAEmD,KAAKtB,QAAQ5B,EAAEuC,EAAEtH,EAAE6E,GAAE,GAAI,OAAOE,IAAID,EAAE6C,GAAG5C,GAAGD,GAAGiB,EAAEY,MAAM,WAAW,OAAOc,EAAEV,EAAEkB,KAAKG,GAAGH,OAAOlC,EAAE0E,OAAO,WAAW,OAAO,IAAIpC,KAAKJ,KAAKsC,YAAYxE,EAAE4G,OAAO,WAAW,OAAO1E,KAAK4B,UAAU5B,KAAK2E,cAAc,MAAM7G,EAAE6G,YAAY,WAAW,OAAO3E,KAAKG,GAAGwE,eAAe7G,EAAE+D,SAAS,WAAW,OAAO7B,KAAKG,GAAGyE,eAAelH,EAArwI,GAA0wImH,EAAE/M,EAAEoI,UAAU,OAAOpB,EAAEoB,UAAU2E,EAAE,CAAC,CAAC,MAAM/H,GAAG,CAAC,KAAKC,GAAG,CAAC,KAAKC,GAAG,CAAC,KAAKC,GAAG,CAAC,KAAKC,GAAG,CAAC,KAAKE,GAAG,CAAC,KAAKE,GAAG,CAAC,KAAK1P,IAAIkX,SAAQ,SAAU/M,GAAG8M,EAAE9M,EAAE,IAAI,SAAS6E,GAAG,OAAOoD,KAAKmC,GAAGvF,EAAE7E,EAAE,GAAGA,EAAE,QAAQ+G,EAAEiG,OAAO,SAAShN,EAAE6E,GAAG,OAAO7E,EAAEiN,KAAKjN,EAAE6E,EAAE9E,EAAEgH,GAAG/G,EAAEiN,IAAG,GAAIlG,GAAGA,EAAEW,OAAOJ,EAAEP,EAAEmG,QAAQpG,EAAEC,EAAEuD,KAAK,SAAStK,GAAG,OAAO+G,EAAE,IAAI/G,IAAI+G,EAAEoG,GAAGnG,EAAEK,GAAGN,EAAEqG,GAAGpG,EAAED,EAAED,EAAE,GAAGC,EAAl1MlC,I,iBCAfD,EAAOrP,QAAkJ,WAAY,aAAa,IAAIyK,EAAEiF,EAAEH,EAAE,IAAIE,EAAE,IAAIH,EAAE,KAAKE,EAAE,MAAMK,EAAE,sFAAsFF,EAAE,QAAQI,EAAE,OAAOH,EAAE,sKAAsKtP,EAAE,CAACwX,MAAMnI,EAAEY,OAAOR,EAAEgI,KAAKvI,EAAEwI,MAAM1I,EAAE2I,QAAQxI,EAAEyI,QAAQ3I,EAAE4I,aAAa,EAAEC,MAAM,QAAQpI,EAAE,SAASvF,GAAG,OAAOA,aAAa8G,GAAGzB,EAAE,SAASrF,EAAEiF,EAAEH,GAAG,OAAO,IAAIgC,EAAE9G,EAAE8E,EAAEG,EAAE2I,KAAK7H,EAAE,SAAS/F,GAAG,OAAOiF,EAAE6B,EAAE9G,GAAG,KAAKyF,EAAE,SAASzF,GAAG,OAAOA,EAAE,GAAGwF,EAAE,SAASxF,GAAG,OAAOyF,EAAEzF,GAAG5D,KAAKyK,KAAK7G,GAAG5D,KAAKmK,MAAMvG,IAAI0F,EAAE,SAAS1F,GAAG,OAAO5D,KAAKkK,IAAItG,IAAImG,EAAE,SAASnG,EAAEiF,GAAG,OAAOjF,EAAEyF,EAAEzF,GAAG,CAAC6N,UAAS,EAAG3C,OAAO,GAAGxF,EAAE1F,GAAGiF,GAAG,CAAC4I,UAAS,EAAG3C,OAAO,GAAGlL,EAAEiF,GAAG,CAAC4I,UAAS,EAAG3C,OAAO,KAAKpE,EAAE,WAAW,SAASrB,EAAEzF,EAAEiF,EAAEH,GAAG,IAAIE,EAAEiD,KAAK,GAAGA,KAAKG,GAAG,GAAGH,KAAK2F,GAAG9I,OAAE,IAAS9E,IAAIiI,KAAKyB,IAAI,EAAEzB,KAAK6F,yBAAyB7I,EAAE,OAAOI,EAAErF,EAAEnK,EAAEkQ,EAAEd,IAAIgD,MAAM,GAAG,iBAAiBjI,EAAE,OAAOiI,KAAKyB,IAAI1J,EAAEiI,KAAK6F,wBAAwB7F,KAAK,GAAG,iBAAiBjI,EAAE,OAAO+N,OAAOC,KAAKhO,GAAG+M,SAAQ,SAAU9H,GAAGD,EAAEoD,GAAGrC,EAAEd,IAAIjF,EAAEiF,MAAMgD,KAAKgG,kBAAkBhG,KAAK,GAAG,iBAAiBjI,EAAE,CAAC,IAAI6E,EAAE7E,EAAEwI,MAAMrD,GAAG,GAAGN,EAAE,CAAC,IAAIE,EAAEF,EAAElI,MAAM,GAAGE,KAAI,SAAUmD,GAAG,OAAO,MAAMA,EAAEgL,OAAOhL,GAAG,KAAK,OAAOiI,KAAKG,GAAGiF,MAAMtI,EAAE,GAAGkD,KAAKG,GAAGtC,OAAOf,EAAE,GAAGkD,KAAKG,GAAGuF,MAAM5I,EAAE,GAAGkD,KAAKG,GAAGkF,KAAKvI,EAAE,GAAGkD,KAAKG,GAAGmF,MAAMxI,EAAE,GAAGkD,KAAKG,GAAGoF,QAAQzI,EAAE,GAAGkD,KAAKG,GAAGqF,QAAQ1I,EAAE,GAAGkD,KAAKgG,kBAAkBhG,MAAM,OAAOA,KAAK,IAAIvC,EAAED,EAAE0C,UAAU,OAAOzC,EAAEuI,gBAAgB,WAAW,IAAIjO,EAAEiI,KAAKA,KAAKyB,IAAIqE,OAAOC,KAAK/F,KAAKG,IAAI8F,QAAO,SAAUjJ,EAAEH,GAAG,OAAOG,GAAGjF,EAAEoI,GAAGtD,IAAI,GAAGjP,EAAEiP,KAAK,IAAIY,EAAEoI,sBAAsB,WAAW,IAAI9N,EAAEiI,KAAKyB,IAAIzB,KAAKG,GAAGiF,MAAM7H,EAAExF,EAAEkF,GAAGlF,GAAGkF,EAAE+C,KAAKG,GAAGtC,OAAON,EAAExF,EAAEsF,GAAGtF,GAAGsF,EAAE2C,KAAKG,GAAGkF,KAAK9H,EAAExF,EAAE+E,GAAG/E,GAAG+E,EAAEkD,KAAKG,GAAGmF,MAAM/H,EAAExF,EAAE6E,GAAG7E,GAAG6E,EAAEoD,KAAKG,GAAGoF,QAAQhI,EAAExF,EAAEgF,GAAGhF,GAAGgF,EAAEiD,KAAKG,GAAGqF,QAAQjI,EAAExF,EAAE8E,GAAG9E,GAAG8E,EAAEmD,KAAKG,GAAGsF,aAAa1N,GAAG0F,EAAEkH,YAAY,WAAW,IAAI5M,EAAEmG,EAAE8B,KAAKG,GAAGiF,MAAM,KAAKpI,EAAEkB,EAAE8B,KAAKG,GAAGtC,OAAO,KAAKhB,GAAGmD,KAAKG,GAAGkF,MAAM,EAAErF,KAAKG,GAAGuF,QAAQ7I,GAAG,EAAEmD,KAAKG,GAAGuF,OAAO,IAAI3I,EAAEmB,EAAErB,EAAE,KAAKD,EAAEsB,EAAE8B,KAAKG,GAAGmF,MAAM,KAAKxI,EAAEoB,EAAE8B,KAAKG,GAAGoF,QAAQ,KAAKpI,EAAE6C,KAAKG,GAAGqF,SAAS,EAAExF,KAAKG,GAAGsF,eAAetI,GAAG6C,KAAKG,GAAGsF,aAAa,KAAK,IAAIxI,EAAEiB,EAAEf,EAAE,KAAKE,EAAEtF,EAAE6N,UAAU5I,EAAE4I,UAAU7I,EAAE6I,UAAUhJ,EAAEgJ,UAAU9I,EAAE8I,UAAU3I,EAAE2I,SAAS1I,EAAEN,EAAEqG,QAAQnG,EAAEmG,QAAQhG,EAAEgG,OAAO,IAAI,GAAGrV,GAAGyP,EAAE,IAAI,IAAI,IAAItF,EAAEkL,OAAOjG,EAAEiG,OAAOlG,EAAEkG,OAAO/F,EAAEN,EAAEqG,OAAOnG,EAAEmG,OAAOhG,EAAEgG,OAAO,MAAM,MAAMrV,GAAG,OAAOA,EAAE,MAAMA,GAAG6P,EAAEiH,OAAO,WAAW,OAAO1E,KAAK2E,eAAelH,EAAEwF,OAAO,SAASlL,GAAG,IAAI8E,EAAE9E,GAAG,sBAAsBgF,EAAE,CAACmJ,EAAElG,KAAKG,GAAGiF,MAAMhC,GAAGpG,EAAEA,EAAEgD,KAAKG,GAAGiF,MAAM,EAAE,KAAK/B,KAAKrG,EAAEA,EAAEgD,KAAKG,GAAGiF,MAAM,EAAE,KAAK1H,EAAEsC,KAAKG,GAAGtC,OAAOyF,GAAGtG,EAAEA,EAAEgD,KAAKG,GAAGtC,OAAO,EAAE,KAAKkB,EAAEiB,KAAKG,GAAGkF,KAAK3B,GAAG1G,EAAEA,EAAEgD,KAAKG,GAAGkF,KAAK,EAAE,KAAKrB,EAAEhE,KAAKG,GAAGmF,MAAMrB,GAAGjH,EAAEA,EAAEgD,KAAKG,GAAGmF,MAAM,EAAE,KAAKxH,EAAEkC,KAAKG,GAAGoF,QAAQnB,GAAGpH,EAAEA,EAAEgD,KAAKG,GAAGoF,QAAQ,EAAE,KAAKvI,EAAEgD,KAAKG,GAAGqF,QAAQnB,GAAGrH,EAAEA,EAAEgD,KAAKG,GAAGqF,QAAQ,EAAE,KAAKlB,IAAItH,EAAEA,EAAEgD,KAAKG,GAAGsF,aAAa,EAAE,MAAM,OAAO5I,EAAEsC,QAAQhC,GAAE,SAAUpF,EAAEiF,GAAG,OAAOA,GAAGe,OAAOhB,EAAEhF,QAAQ0F,EAAElL,GAAG,SAASwF,GAAG,OAAOiI,KAAKyB,IAAI7T,EAAEkQ,EAAE/F,KAAK0F,EAAEqF,IAAI,SAAS/K,GAAG,IAAIiF,EAAEgD,KAAKyB,IAAI5E,EAAEiB,EAAE/F,GAAG,MAAM,iBAAiB8E,EAAEG,GAAG,IAAIA,EAAE,UAAUH,EAAEU,EAAEP,EAAEpP,EAAEiP,IAAImD,KAAKG,GAAGtD,GAAG,IAAIG,EAAE,EAAEA,GAAGS,EAAEkB,IAAI,SAAS5G,EAAEiF,EAAEH,GAAG,IAAIE,EAAE,OAAOA,EAAEC,EAAEjF,EAAEnK,EAAEkQ,EAAEd,IAAIM,EAAEvF,GAAGA,EAAE0J,IAAIrE,EAAErF,EAAEiI,MAAMyB,IAAIrE,EAAE4C,KAAKyB,IAAI1E,GAAGF,GAAG,EAAE,GAAGmD,OAAOvC,EAAEuF,SAAS,SAASjL,EAAEiF,GAAG,OAAOgD,KAAKrB,IAAI5G,EAAEiF,GAAE,IAAKS,EAAEgC,OAAO,SAAS1H,GAAG,IAAIiF,EAAEgD,KAAKtB,QAAQ,OAAO1B,EAAE2I,GAAG5N,EAAEiF,GAAGS,EAAEiB,MAAM,WAAW,OAAOtB,EAAE4C,KAAKyB,IAAIzB,OAAOvC,EAAE0I,SAAS,SAASnJ,GAAG,OAAOjF,IAAI4G,IAAIqB,KAAKyB,IAAI,MAAMhC,OAAOO,KAAK2F,IAAIS,SAASpJ,IAAIS,EAAEgI,aAAa,WAAW,OAAOzF,KAAK8C,IAAI,iBAAiBrF,EAAE4I,eAAe,WAAW,OAAOrG,KAAKzN,GAAG,iBAAiBkL,EAAE+H,QAAQ,WAAW,OAAOxF,KAAK8C,IAAI,YAAYrF,EAAE6I,UAAU,WAAW,OAAOtG,KAAKzN,GAAG,YAAYkL,EAAE8H,QAAQ,WAAW,OAAOvF,KAAK8C,IAAI,YAAYrF,EAAE8I,UAAU,WAAW,OAAOvG,KAAKzN,GAAG,YAAYkL,EAAE6H,MAAM,WAAW,OAAOtF,KAAK8C,IAAI,UAAUrF,EAAE+I,QAAQ,WAAW,OAAOxG,KAAKzN,GAAG,UAAUkL,EAAE4H,KAAK,WAAW,OAAOrF,KAAK8C,IAAI,SAASrF,EAAEgJ,OAAO,WAAW,OAAOzG,KAAKzN,GAAG,SAASkL,EAAEiI,MAAM,WAAW,OAAO1F,KAAK8C,IAAI,UAAUrF,EAAEiJ,QAAQ,WAAW,OAAO1G,KAAKzN,GAAG,UAAUkL,EAAEI,OAAO,WAAW,OAAOmC,KAAK8C,IAAI,WAAWrF,EAAEkJ,SAAS,WAAW,OAAO3G,KAAKzN,GAAG,WAAWkL,EAAE2H,MAAM,WAAW,OAAOpF,KAAK8C,IAAI,UAAUrF,EAAEmJ,QAAQ,WAAW,OAAO5G,KAAKzN,GAAG,UAAUiL,EAA/sG,GAAotG,OAAO,SAASX,EAAEE,EAAEH,GAAG7E,EAAE6E,EAAEI,EAAEJ,IAAI+E,SAAS/E,EAAEiK,SAAS,SAAS9O,EAAEiF,GAAG,IAAIH,EAAED,EAAE6C,SAAS,OAAOrC,EAAErF,EAAE,CAAC4N,GAAG9I,GAAGG,IAAIJ,EAAEkK,WAAWxJ,EAAE,IAAIR,EAAEC,EAAEmD,UAAUvB,IAAIxB,EAAEJ,EAAEmD,UAAU8C,SAASjG,EAAEmD,UAAUvB,IAAI,SAAS5G,EAAEiF,GAAG,OAAOM,EAAEvF,KAAKA,EAAEA,EAAEsO,kBAAkBvJ,EAAEiK,KAAK/G,KAAPlD,CAAa/E,EAAEiF,IAAID,EAAEmD,UAAU8C,SAAS,SAASjL,EAAEiF,GAAG,OAAOM,EAAEvF,KAAKA,EAAEA,EAAEsO,kBAAkBlJ,EAAE4J,KAAK/G,KAAP7C,CAAapF,EAAEiF,KAAx6IA,I,+BCEnF,IAAIgK,EAASlB,OAAO5F,UAAU+G,eAC1BC,EAAQpB,OAAO5F,UAAU2B,SACzBsF,EAAiBrB,OAAOqB,eACxBC,EAAOtB,OAAOuB,yBAEdC,EAAU,SAAiBC,GAC9B,MAA6B,oBAAlBvJ,MAAMsJ,QACTtJ,MAAMsJ,QAAQC,GAGK,mBAApBL,EAAMM,KAAKD,IAGfE,EAAgB,SAAuBC,GAC1C,IAAKA,GAA2B,oBAApBR,EAAMM,KAAKE,GACtB,OAAO,EAGR,IASIC,EATAC,EAAoBZ,EAAOQ,KAAKE,EAAK,eACrCG,EAAmBH,EAAII,aAAeJ,EAAII,YAAY5H,WAAa8G,EAAOQ,KAAKE,EAAII,YAAY5H,UAAW,iBAE9G,GAAIwH,EAAII,cAAgBF,IAAsBC,EAC7C,OAAO,EAMR,IAAKF,KAAOD,GAEZ,MAAsB,qBAARC,GAAuBX,EAAOQ,KAAKE,EAAKC,IAInDI,EAAc,SAAqBC,EAAQC,GAC1Cd,GAAmC,cAAjBc,EAAQha,KAC7BkZ,EAAea,EAAQC,EAAQha,KAAM,CACpCia,YAAY,EACZC,cAAc,EACd7Q,MAAO2Q,EAAQG,SACfC,UAAU,IAGXL,EAAOC,EAAQha,MAAQga,EAAQG,UAK7BE,EAAc,SAAqBZ,EAAKzZ,GAC3C,GAAa,cAATA,EAAsB,CACzB,IAAK+Y,EAAOQ,KAAKE,EAAKzZ,GACrB,OACM,GAAImZ,EAGV,OAAOA,EAAKM,EAAKzZ,GAAMqJ,MAIzB,OAAOoQ,EAAIzZ,IAGZ0O,EAAOrP,QAAU,SAASyX,IACzB,IAAIkD,EAASha,EAAMkD,EAAKoX,EAAMC,EAAa9J,EACvCsJ,EAASzI,UAAU,GACnBxC,EAAI,EACJ7I,EAASqL,UAAUrL,OACnBuU,GAAO,EAaX,IAVsB,mBAAXT,IACVS,EAAOT,EACPA,EAASzI,UAAU,IAAM,GAEzBxC,EAAI,IAES,MAAViL,GAAqC,kBAAXA,GAAyC,oBAAXA,KAC3DA,EAAS,IAGHjL,EAAI7I,IAAU6I,EAGpB,GAAe,OAFfkL,EAAU1I,UAAUxC,IAInB,IAAK9O,KAAQga,EACZ9W,EAAMmX,EAAYN,EAAQ/Z,GAItB+Z,KAHJO,EAAOD,EAAYL,EAASha,MAKvBwa,GAAQF,IAASd,EAAcc,KAAUC,EAAclB,EAAQiB,MAC9DC,GACHA,GAAc,EACd9J,EAAQvN,GAAOmW,EAAQnW,GAAOA,EAAM,IAEpCuN,EAAQvN,GAAOsW,EAActW,GAAOA,EAAM,GAI3C4W,EAAYC,EAAQ,CAAE/Z,KAAMA,EAAMma,SAAUrD,EAAO0D,EAAM/J,EAAO6J,MAGtC,qBAATA,GACjBR,EAAYC,EAAQ,CAAE/Z,KAAMA,EAAMma,SAAUG,KAQjD,OAAOP,I,kBCjHR,IAAIU,EAAgB,kCAEhBC,EAAgB,MAChBC,EAAmB,OAGnBC,EAAiB,yCACjBC,EAAc,QACdC,EAAc,uDACdC,EAAkB,UAGlBC,EAAa,aAMbC,EAAe,GA8OnB,SAASC,EAAKC,GACZ,OAAOA,EAAMA,EAAIjK,QAAQ8J,EAAYC,GAAgBA,EAlOvDvM,EAAOrP,QAAU,SAASmH,EAAOwT,GAC/B,GAAqB,kBAAVxT,EACT,MAAM,IAAI4U,UAAU,mCAGtB,IAAK5U,EAAO,MAAO,GAEnBwT,EAAUA,GAAW,GAKrB,IAAIqB,EAAS,EACTC,EAAS,EAOb,SAASC,EAAeJ,GACtB,IAAIK,EAAQL,EAAI7I,MAAMoI,GAClBc,IAAOH,GAAUG,EAAMvV,QAC3B,IAAI6I,EAAIqM,EAAIM,YAvCF,MAwCVH,GAAUxM,EAAIqM,EAAIlV,OAAS6I,EAAIwM,EAASH,EAAIlV,OAQ9C,SAASvF,IACP,IAAIgb,EAAQ,CAAEC,KAAMN,EAAQC,OAAQA,GACpC,OAAO,SAASM,GAGd,OAFAA,EAAKlb,SAAW,IAAImb,EAASH,GAC7BI,IACOF,GAYX,SAASC,EAASH,GAChB3J,KAAK2J,MAAQA,EACb3J,KAAKgK,IAAM,CAAEJ,KAAMN,EAAQC,OAAQA,GACnCvJ,KAAKiK,OAAShC,EAAQgC,OAMxBH,EAAS5J,UAAU1H,QAAU/D,EAE7B,IAAIyV,EAAa,GAQjB,SAAS7T,EAAM8T,GACb,IAAIC,EAAM,IAAIC,MACZpC,EAAQgC,OAAS,IAAMX,EAAS,IAAMC,EAAS,KAAOY,GAQxD,GANAC,EAAIE,OAASH,EACbC,EAAIG,SAAWtC,EAAQgC,OACvBG,EAAIR,KAAON,EACXc,EAAIb,OAASA,EACba,EAAIH,OAASxV,GAETwT,EAAQuC,OAGV,MAAMJ,EAFNF,EAAWO,KAAKL,GAYpB,SAAS7J,EAAMmK,GACb,IAAI5M,EAAI4M,EAAGC,KAAKlW,GAChB,GAAKqJ,EAAL,CACA,IAAIsL,EAAMtL,EAAE,GAGZ,OAFA0L,EAAeJ,GACf3U,EAAQA,EAAMC,MAAM0U,EAAIlV,QACjB4J,GAMT,SAASiM,IACPxJ,EAAMqI,GASR,SAASgC,EAASC,GAChB,IAAIvN,EAEJ,IADAuN,EAAQA,GAAS,GACTvN,EAAIwN,MACA,IAANxN,GACFuN,EAAMJ,KAAKnN,GAGf,OAAOuN,EAST,SAASC,IACP,IAAIC,EAAMpc,IACV,GAnJgB,KAmJK8F,EAAMuW,OAAO,IAlJvB,KAkJyCvW,EAAMuW,OAAO,GAAjE,CAGA,IADA,IAAIjO,EAAI,EAENmM,GAAgBzU,EAAMuW,OAAOjO,KAtJpB,KAuJItI,EAAMuW,OAAOjO,IAxJZ,KAwJmCtI,EAAMuW,OAAOjO,EAAI,OAEhEA,EAIJ,GAFAA,GAAK,EAEDmM,IAAiBzU,EAAMuW,OAAOjO,EAAI,GACpC,OAAO1G,EAAM,0BAGf,IAAI+S,EAAM3U,EAAMC,MAAM,EAAGqI,EAAI,GAM7B,OALAwM,GAAU,EACVC,EAAeJ,GACf3U,EAAQA,EAAMC,MAAMqI,GACpBwM,GAAU,EAEHwB,EAAI,CACTE,KApKa,UAqKbH,QAAS1B,KAUb,SAAS8B,IACP,IAAIH,EAAMpc,IAGNwc,EAAO5K,EAAMsI,GACjB,GAAKsC,EAAL,CAIA,GAHAL,KAGKvK,EAAMuI,GAAc,OAAOzS,EAAM,wBAGtC,IAAI+U,EAAM7K,EAAMwI,GAEZsC,EAAMN,EAAI,CACZE,KA7LiB,cA8LjBK,SAAUnC,EAAKgC,EAAK,GAAGhM,QAAQuJ,EAAeQ,IAC9C5R,MAAO8T,EACHjC,EAAKiC,EAAI,GAAGjM,QAAQuJ,EAAeQ,IACnCA,IAMN,OAFA3I,EAAMyI,GAECqC,GA0BT,OADAtB,IAjBA,WACE,IAKIwB,EALAC,EAAQ,GAMZ,IAJAZ,EAASY,GAIDD,EAAOL,MACA,IAATK,IACFC,EAAMf,KAAKc,GACXX,EAASY,IAIb,OAAOA,EAIFC,K,kBClPT9O,EAAOrP,QAAU,SAAmBoa,GAClC,OAAc,MAAPA,GAAkC,MAAnBA,EAAII,aACY,oBAA7BJ,EAAII,YAAY4D,UAA2BhE,EAAII,YAAY4D,SAAShE,K,mCCA/E,IAAIiE,EAAuB,EAAQ,OAEnC,SAASC,KACT,SAASC,KACTA,EAAuBC,kBAAoBF,EAE3CjP,EAAOrP,QAAU,WACf,SAASye,EAAK3d,EAAO4d,EAAUC,EAAeC,EAAUC,EAAcC,GACpE,GAAIA,IAAWT,EAAf,CAIA,IAAIvB,EAAM,IAAIC,MACZ,mLAKF,MADAD,EAAInc,KAAO,sBACLmc,GAGR,SAASiC,IACP,OAAON,EAFTA,EAAKO,WAAaP,EAMlB,IAAIQ,EAAiB,CACnBC,MAAOT,EACPU,OAAQV,EACRW,KAAMX,EACNY,KAAMZ,EACNa,OAAQb,EACRc,OAAQd,EACRe,OAAQf,EACRgB,OAAQhB,EAERiB,IAAKjB,EACLkB,QAASZ,EACTa,QAASnB,EACToB,YAAapB,EACbqB,WAAYf,EACZxC,KAAMkC,EACNsB,SAAUhB,EACViB,MAAOjB,EACPkB,UAAWlB,EACX3c,MAAO2c,EACPmB,MAAOnB,EAEPoB,eAAgB5B,EAChBC,kBAAmBF,GAKrB,OAFAW,EAAemB,UAAYnB,EAEpBA,I,sBC9CP5P,EAAOrP,QAAU,EAAQ,MAAR,I,+BCNnBqP,EAAOrP,QAFoB,gD,iCCAd,IAA4b2P,EAAxb0Q,EAAEC,OAAOC,IAAI,iBAAiBvQ,EAAEsQ,OAAOC,IAAI,gBAAgBjgB,EAAEggB,OAAOC,IAAI,kBAAkBjR,EAAEgR,OAAOC,IAAI,qBAAqBzQ,EAAEwQ,OAAOC,IAAI,kBAAkB3P,EAAE0P,OAAOC,IAAI,kBAAkBxQ,EAAEuQ,OAAOC,IAAI,iBAAiBC,EAAEF,OAAOC,IAAI,wBAAwBrQ,EAAEoQ,OAAOC,IAAI,qBAAqB/P,EAAE8P,OAAOC,IAAI,kBAAkBhR,EAAE+Q,OAAOC,IAAI,uBAAuBhP,EAAE+O,OAAOC,IAAI,cAAcE,EAAEH,OAAOC,IAAI,cAAc9V,EAAE6V,OAAOC,IAAI,mBACtb,SAASzO,EAAElC,GAAG,GAAG,kBAAkBA,GAAG,OAAOA,EAAE,CAAC,IAAIJ,EAAEI,EAAE8Q,SAAS,OAAOlR,GAAG,KAAK6Q,EAAE,OAAOzQ,EAAEA,EAAE+N,MAAQ,KAAKrd,EAAE,KAAKwP,EAAE,KAAKR,EAAE,KAAKkB,EAAE,KAAKjB,EAAE,OAAOK,EAAE,QAAQ,OAAOA,EAAEA,GAAGA,EAAE8Q,UAAY,KAAKF,EAAE,KAAKzQ,EAAE,KAAKG,EAAE,KAAKuQ,EAAE,KAAKlP,EAAE,KAAKX,EAAE,OAAOhB,EAAE,QAAQ,OAAOJ,GAAG,KAAKQ,EAAE,OAAOR,IADqMG,EAAE2Q,OAAOC,IAAI,0BAC9MvgB,EAAQ2gB,gBAAgB5Q,EAAE/P,EAAQ4gB,gBAAgBhQ,EAAE5Q,EAAQ6gB,QAAQR,EAAErgB,EAAQ8gB,WAAW5Q,EAAElQ,EAAQ+gB,SAASzgB,EAAEN,EAAQghB,KAAKP,EAAEzgB,EAAQihB,KAAK1P,EAAEvR,EAAQkhB,OAAOlR,EAAEhQ,EAAQmhB,SAASrR,EAAE9P,EAAQohB,WAAW9R,EAAEtP,EAAQqhB,SAAS7Q,EAChexQ,EAAQshB,aAAa/R,EAAEvP,EAAQuhB,YAAY,WAAW,OAAM,GAAIvhB,EAAQwhB,iBAAiB,WAAW,OAAM,GAAIxhB,EAAQyhB,kBAAkB,SAAS7R,GAAG,OAAOkC,EAAElC,KAAKG,GAAG/P,EAAQ0hB,kBAAkB,SAAS9R,GAAG,OAAOkC,EAAElC,KAAKgB,GAAG5Q,EAAQ2hB,UAAU,SAAS/R,GAAG,MAAM,kBAAkBA,GAAG,OAAOA,GAAGA,EAAE8Q,WAAWL,GAAGrgB,EAAQ4hB,aAAa,SAAShS,GAAG,OAAOkC,EAAElC,KAAKM,GAAGlQ,EAAQ6hB,WAAW,SAASjS,GAAG,OAAOkC,EAAElC,KAAKtP,GAAGN,EAAQ8hB,OAAO,SAASlS,GAAG,OAAOkC,EAAElC,KAAK6Q,GAAGzgB,EAAQ+hB,OAAO,SAASnS,GAAG,OAAOkC,EAAElC,KAAK2B,GACtevR,EAAQgiB,SAAS,SAASpS,GAAG,OAAOkC,EAAElC,KAAKI,GAAGhQ,EAAQiiB,WAAW,SAASrS,GAAG,OAAOkC,EAAElC,KAAKE,GAAG9P,EAAQkiB,aAAa,SAAStS,GAAG,OAAOkC,EAAElC,KAAKN,GAAGtP,EAAQmiB,WAAW,SAASvS,GAAG,OAAOkC,EAAElC,KAAKY,GAAGxQ,EAAQoiB,eAAe,SAASxS,GAAG,OAAOkC,EAAElC,KAAKL,GACjPvP,EAAQqiB,mBAAmB,SAASzS,GAAG,MAAM,kBAAkBA,GAAG,oBAAoBA,GAAGA,IAAItP,GAAGsP,IAAIE,GAAGF,IAAIN,GAAGM,IAAIY,GAAGZ,IAAIL,GAAGK,IAAInF,GAAG,kBAAkBmF,GAAG,OAAOA,IAAIA,EAAE8Q,WAAWD,GAAG7Q,EAAE8Q,WAAWnP,GAAG3B,EAAE8Q,WAAW9P,GAAGhB,EAAE8Q,WAAW3Q,GAAGH,EAAE8Q,WAAWxQ,GAAGN,EAAE8Q,WAAW/Q,QAAG,IAASC,EAAE0S,cAAoBtiB,EAAQuiB,OAAOzQ,G,mCCV/SzC,EAAOrP,QAAU,EAAjB,Q,sBCHF,IAAI2S,EAAQ,EAAQ,OAyCpBtD,EAAOrP,QA5BP,SAAuBmH,EAAOqb,GAC5B,IAKI5E,EALA6E,EAAS,KACb,IAAKtb,GAA0B,kBAAVA,EACnB,OAAOsb,EAST,IALA,IAEIzE,EACAhU,EAHAmU,EAAexL,EAAMxL,GACrBub,EAAkC,oBAAbF,EAIhB/S,EAAI,EAAGkT,EAAMxE,EAAavX,OAAQ6I,EAAIkT,EAAKlT,IAElDuO,GADAJ,EAAcO,EAAa1O,IACJuO,SACvBhU,EAAQ4T,EAAY5T,MAEhB0Y,EACFF,EAASxE,EAAUhU,EAAO4T,GACjB5T,IACTyY,IAAWA,EAAS,IACpBA,EAAOzE,GAAYhU,GAIvB,OAAOyY,I,yqBCxBF,SAASG,EAAkB5Y,GAEhC,OAAKA,GAA0B,kBAAVA,EAKjB,aAAcA,GAAS,SAAUA,EAC5B3I,EAAS2I,EAAM3I,UAIpB,UAAW2I,GAAS,QAASA,EACxB3I,EAAS2I,GAId,SAAUA,GAAS,WAAYA,EAC1B6Y,EAAM7Y,GAIR,GAnBE,GA0BX,SAAS6Y,EAAMA,GACb,OAAOtb,EAAMsb,GAASA,EAAMvG,MAAQ,IAAM/U,EAAMsb,GAASA,EAAM5G,QAOjE,SAAS5a,EAASoc,GAChB,OAAOoF,EAAMpF,GAAOA,EAAIpB,OAAS,IAAMwG,EAAMpF,GAAOA,EAAIf,KAO1D,SAASnV,EAAMyC,GACb,OAAOA,GAA0B,kBAAVA,EAAqBA,EAAQ,ECnD/C,MAAM8Y,UAAqB/F,MAShCvC,YAAYwC,EAAQ+F,EAAOC,GAEzB,MAAMC,EAAQ,CAAC,KAAM,MAErB,IAAI5hB,EAAW,CAEbgb,MAAO,CAACC,KAAM,KAAML,OAAQ,MAE5BS,IAAK,CAACJ,KAAM,KAAML,OAAQ,OAU5B,GAPAiH,QAEqB,kBAAVH,IACTC,EAASD,EACTA,OAAQ9b,GAGY,kBAAX+b,EAAqB,CAC9B,MAAMzb,EAAQyb,EAAO9a,QAAQ,MAEd,IAAXX,EACF0b,EAAM,GAAKD,GAEXC,EAAM,GAAKD,EAAO5b,MAAM,EAAGG,GAC3B0b,EAAM,GAAKD,EAAO5b,MAAMG,EAAQ,IAIhCwb,IAEE,SAAUA,GAAS,aAAcA,EAC/BA,EAAM1hB,WACRA,EAAW0hB,EAAM1hB,UAIZ,UAAW0hB,GAAS,QAASA,EACpC1hB,EAAW0hB,GAGJ,SAAUA,GAAS,WAAYA,KACtC1hB,EAASgb,MAAQ0G,IAKrBrQ,KAAK/R,KAAOiiB,EAAkBG,IAAU,MACxCrQ,KAAKyQ,QAA4B,kBAAXnG,EAAsBA,EAAOmG,QAAUnG,EAC7DtK,KAAK0Q,MAA0B,kBAAXpG,EAAsBA,EAAOoG,MAAQ,GAMzD1Q,KAAKsK,OAAStK,KAAKyQ,QAMnBzQ,KAAK2Q,MAKL3Q,KAAK4J,KAAOjb,EAASgb,MAAMC,KAK3B5J,KAAKuJ,OAAS5a,EAASgb,MAAMJ,OAK7BvJ,KAAKiK,OAASsG,EAAM,GAKpBvQ,KAAK4Q,OAASL,EAAM,GAMpBvQ,KAAKrR,SAAWA,EAYhBqR,KAAK6Q,OAML7Q,KAAK8Q,SAKL9Q,KAAK+Q,KAKL/Q,KAAKgR,IAKLhR,KAAKiR,MAKTb,EAAalQ,UAAU6Q,KAAO,GAC9BX,EAAalQ,UAAUjS,KAAO,GAC9BmiB,EAAalQ,UAAUoK,OAAS,GAChC8F,EAAalQ,UAAUuQ,QAAU,GACjCL,EAAalQ,UAAUwQ,MAAQ,GAC/BN,EAAalQ,UAAUyQ,MAAQ,KAC/BP,EAAalQ,UAAUqJ,OAAS,KAChC6G,EAAalQ,UAAU0J,KAAO,KAC9BwG,EAAalQ,UAAU+J,OAAS,KAChCmG,EAAalQ,UAAU0Q,OAAS,KAChCR,EAAalQ,UAAUvR,SAAW,KCtG3B,MAAMuiB,EAAO,CAACC,SASrB,SAAkBD,EAAME,GACtB,QAAY7c,IAAR6c,GAAoC,kBAARA,EAC9B,MAAM,IAAI/H,UAAU,mCAGtBgI,EAAWH,GACX,IAIII,EAJA3H,EAAQ,EACRK,GAAO,EACPnV,EAAQqc,EAAKhd,OAIjB,QAAYK,IAAR6c,GAAoC,IAAfA,EAAIld,QAAgBkd,EAAIld,OAASgd,EAAKhd,OAAQ,CACrE,KAAOW,KACL,GAA+B,KAA3Bqc,EAAKK,WAAW1c,IAGlB,GAAIyc,EAAc,CAChB3H,EAAQ9U,EAAQ,EAChB,YAEOmV,EAAM,IAGfsH,GAAe,EACftH,EAAMnV,EAAQ,GAIlB,OAAOmV,EAAM,EAAI,GAAKkH,EAAKxc,MAAMiV,EAAOK,GAG1C,GAAIoH,IAAQF,EACV,MAAO,GAGT,IAAIM,GAAoB,EACpBC,EAAWL,EAAIld,OAAS,EAE5B,KAAOW,KACL,GAA+B,KAA3Bqc,EAAKK,WAAW1c,IAGlB,GAAIyc,EAAc,CAChB3H,EAAQ9U,EAAQ,EAChB,YAGE2c,EAAmB,IAGrBF,GAAe,EACfE,EAAmB3c,EAAQ,GAGzB4c,GAAY,IAEVP,EAAKK,WAAW1c,KAAWuc,EAAIG,WAAWE,KACxCA,EAAW,IAGbzH,EAAMnV,IAKR4c,GAAY,EACZzH,EAAMwH,IAMV7H,IAAUK,EACZA,EAAMwH,EACGxH,EAAM,IACfA,EAAMkH,EAAKhd,QAGb,OAAOgd,EAAKxc,MAAMiV,EAAOK,IAxFI0H,QA+F/B,SAAiBR,GAGf,GAFAG,EAAWH,GAES,IAAhBA,EAAKhd,OACP,MAAO,IAGT,IAGIyd,EAHA3H,GAAO,EACPnV,EAAQqc,EAAKhd,OAKjB,OAASW,GACP,GAA+B,KAA3Bqc,EAAKK,WAAW1c,IAClB,GAAI8c,EAAgB,CAClB3H,EAAMnV,EACN,YAEQ8c,IAEVA,GAAiB,GAIrB,OAAO3H,EAAM,EACc,KAAvBkH,EAAKK,WAAW,GACd,IACA,IACM,IAARvH,GAAoC,KAAvBkH,EAAKK,WAAW,GAC7B,KACAL,EAAKxc,MAAM,EAAGsV,IA9HoB4H,QAqIxC,SAAiBV,GACfG,EAAWH,GAEX,IASIS,EATA9c,EAAQqc,EAAKhd,OAEb8V,GAAO,EACP6H,EAAY,EACZC,GAAY,EAGZC,EAAc,EAIlB,KAAOld,KAAS,CACd,MAAMmd,EAAOd,EAAKK,WAAW1c,GAE7B,GAAa,KAATmd,EAWAhI,EAAM,IAGR2H,GAAiB,EACjB3H,EAAMnV,EAAQ,GAGH,KAATmd,EAEEF,EAAW,EACbA,EAAWjd,EACc,IAAhBkd,IACTA,EAAc,GAEPD,GAAY,IAGrBC,GAAe,QAzBf,GAAIJ,EAAgB,CAClBE,EAAYhd,EAAQ,EACpB,OA2BN,GACEid,EAAW,GACX9H,EAAM,GAEU,IAAhB+H,GAEiB,IAAhBA,GAAqBD,IAAa9H,EAAM,GAAK8H,IAAaD,EAAY,EAEvE,MAAO,GAGT,OAAOX,EAAKxc,MAAMod,EAAU9H,IAjMmB/L,KAwMjD,YAAiBgU,GACf,IAEIC,EAFArd,GAAS,EAIb,OAASA,EAAQod,EAAS/d,QACxBmd,EAAWY,EAASpd,IAEhBod,EAASpd,KACXqd,OACa3d,IAAX2d,EAAuBD,EAASpd,GAASqd,EAAS,IAAMD,EAASpd,IAIvE,YAAkBN,IAAX2d,EAAuB,IAUhC,SAAmBhB,GACjBG,EAAWH,GAEX,MAAMiB,EAAkC,KAAvBjB,EAAKK,WAAW,GAGjC,IAAIja,EAoBN,SAAyB4Z,EAAMkB,GAC7B,IAMIJ,EAEAK,EARAC,EAAS,GACTC,EAAoB,EACpBC,GAAa,EACbC,EAAO,EACP5d,GAAS,EAMb,OAASA,GAASqc,EAAKhd,QAAQ,CAC7B,GAAIW,EAAQqc,EAAKhd,OACf8d,EAAOd,EAAKK,WAAW1c,OAClB,IAAa,KAATmd,EACT,MAEAA,EAAO,GAGT,GAAa,KAATA,EAAuB,CACzB,GAAIQ,IAAc3d,EAAQ,GAAc,IAAT4d,QAExB,GAAID,IAAc3d,EAAQ,GAAc,IAAT4d,EAAY,CAChD,GACEH,EAAOpe,OAAS,GACM,IAAtBqe,GACyC,KAAzCD,EAAOf,WAAWe,EAAOpe,OAAS,IACO,KAAzCoe,EAAOf,WAAWe,EAAOpe,OAAS,GAElC,GAAIoe,EAAOpe,OAAS,GAGlB,GAFAme,EAAiBC,EAAO5I,YAAY,KAEhC2I,IAAmBC,EAAOpe,OAAS,EAAG,CACpCme,EAAiB,GACnBC,EAAS,GACTC,EAAoB,IAEpBD,EAASA,EAAO5d,MAAM,EAAG2d,GACzBE,EAAoBD,EAAOpe,OAAS,EAAIoe,EAAO5I,YAAY,MAG7D8I,EAAY3d,EACZ4d,EAAO,EACP,eAEG,GAAIH,EAAOpe,OAAS,EAAG,CAC5Boe,EAAS,GACTC,EAAoB,EACpBC,EAAY3d,EACZ4d,EAAO,EACP,SAIAL,IACFE,EAASA,EAAOpe,OAAS,EAAIoe,EAAS,MAAQ,KAC9CC,EAAoB,QAGlBD,EAAOpe,OAAS,EAClBoe,GAAU,IAAMpB,EAAKxc,MAAM8d,EAAY,EAAG3d,GAE1Cyd,EAASpB,EAAKxc,MAAM8d,EAAY,EAAG3d,GAGrC0d,EAAoB1d,EAAQ2d,EAAY,EAG1CA,EAAY3d,EACZ4d,EAAO,OACW,KAATT,GAAyBS,GAAQ,EAC1CA,IAEAA,GAAQ,EAIZ,OAAOH,EAlGKI,CAAgBxB,GAAOiB,GAEd,IAAjB7a,EAAMpD,QAAiBie,IACzB7a,EAAQ,KAGNA,EAAMpD,OAAS,GAA0C,KAArCgd,EAAKK,WAAWL,EAAKhd,OAAS,KACpDoD,GAAS,KAGX,OAAO6a,EAAW,IAAM7a,EAAQA,EA1BIqb,CAAUT,IAtNOU,IAAK,KA8U5D,SAASvB,EAAWH,GAClB,GAAoB,kBAATA,EACT,MAAM,IAAI7H,UACR,mCAAqCwJ,KAAKC,UAAU5B,ICjYnD,MAAM6B,EAAO,CAACC,IAErB,WACE,MAAO,MCiBF,SAASC,EAAMC,GACpB,OACoB,OAAlBA,GACyB,kBAAlBA,GAEPA,EAAcC,MAEdD,EAAc5C,OCrBX,SAAS8C,EAAUlC,GACxB,GAAoB,kBAATA,EACTA,EAAO,IAAImC,IAAInC,QACV,IAAK+B,EAAM/B,GAAO,CAEvB,MAAM7a,EAAQ,IAAIgT,UAChB,+EACE6H,EACA,KAGJ,MADA7a,EAAM2b,KAAO,uBACP3b,EAGR,GAAsB,UAAlB6a,EAAKoC,SAAsB,CAE7B,MAAMjd,EAAQ,IAAIgT,UAAU,kCAE5B,MADAhT,EAAM2b,KAAO,yBACP3b,EAGR,OAMF,SAA6B2a,GAC3B,GAAqB,KAAjBA,EAAIuC,SAAiB,CAEvB,MAAMld,EAAQ,IAAIgT,UAChB,wDAGF,MADAhT,EAAM2b,KAAO,4BACP3b,EAGR,MAAMmd,EAAWxC,EAAIwC,SACrB,IAAI3e,GAAS,EAEb,OAASA,EAAQ2e,EAAStf,QACxB,GACiC,KAA/Bsf,EAASjC,WAAW1c,IACe,KAAnC2e,EAASjC,WAAW1c,EAAQ,GAC5B,CACA,MAAM4e,EAAQD,EAASjC,WAAW1c,EAAQ,GAC1C,GAAc,KAAV4e,GAAoC,MAAVA,EAAyB,CAErD,MAAMpd,EAAQ,IAAIgT,UAChB,uDAGF,MADAhT,EAAM2b,KAAO,4BACP3b,GAKZ,OAAOqd,mBAAmBF,GApCnBG,CAAoBzC,GC2B7B,MAAM0C,EAAQ,CAAC,UAAW,OAAQ,WAAY,OAAQ,UAAW,WAE1D,MAAMC,EAkBX/L,YAAYxQ,GAEV,IAAI2Q,EAMFA,EAJG3Q,EAEuB,kBAAVA,GAAsB,EAAOA,GAEnC,CAACA,SACF2b,EAAM3b,GACL,CAAC4Z,KAAM5Z,GAGPA,EARA,GAiBZ0I,KAAK8T,KAAO,GAMZ9T,KAAK+T,SAAW,GAOhB/T,KAAKgU,QAAU,GAMfhU,KAAKgT,IAAMD,EAAKC,MAOhBhT,KAAK1I,MAUL0I,KAAKiU,OASLjU,KAAKsS,OASLtS,KAAKpL,IAIL,IAcIuW,EAdAtW,GAAS,EAEb,OAASA,EAAQ+e,EAAM1f,QAAQ,CAC7B,MAAMiX,EAAOyI,EAAM/e,GAIfsW,KAAQlD,QAA6B1T,IAAlB0T,EAAQkD,KAE7BnL,KAAKmL,GAAiB,YAATA,EAAqB,IAAIlD,EAAQkD,IAASlD,EAAQkD,IAQnE,IAAKA,KAAQlD,EAEN2L,EAAMM,SAAS/I,KAAOnL,KAAKmL,GAAQlD,EAAQkD,IAQhD+F,WACF,OAAOlR,KAAKgU,QAAQhU,KAAKgU,QAAQ9f,OAAS,GAUxCgd,SAAKA,GACH+B,EAAM/B,KACRA,EAAOkC,EAAUlC,IAGnBiD,EAAejD,EAAM,QAEjBlR,KAAKkR,OAASA,GAChBlR,KAAKgU,QAAQvJ,KAAKyG,GAOlBQ,cACF,MAA4B,kBAAd1R,KAAKkR,KAAoBA,EAAKQ,QAAQ1R,KAAKkR,WAAQ3c,EAO/Dmd,YAAQA,GACV,EAAW1R,KAAKmR,SAAU,WAC1BnR,KAAKkR,KAAOA,EAAKjT,KAAKyT,GAAW,GAAI1R,KAAKmR,UAMxCA,eACF,MAA4B,kBAAdnR,KAAKkR,KAAoBA,EAAKC,SAASnR,KAAKkR,WAAQ3c,EAShE4c,aAASA,GACXgD,EAAehD,EAAU,YACzBiD,EAAWjD,EAAU,YACrBnR,KAAKkR,KAAOA,EAAKjT,KAAK+B,KAAK0R,SAAW,GAAIP,GAMxCS,cACF,MAA4B,kBAAd5R,KAAKkR,KAAoBA,EAAKU,QAAQ5R,KAAKkR,WAAQ3c,EAS/Dqd,YAAQA,GAIV,GAHAwC,EAAWxC,EAAS,WACpB,EAAW5R,KAAK0R,QAAS,WAErBE,EAAS,CACX,GAA8B,KAA1BA,EAAQL,WAAW,GACrB,MAAM,IAAIlH,MAAM,iCAGlB,GAAIuH,EAAQsC,SAAS,IAAK,GACxB,MAAM,IAAI7J,MAAM,0CAIpBrK,KAAKkR,KAAOA,EAAKjT,KAAK+B,KAAK0R,QAAS1R,KAAKqU,MAAQzC,GAAW,KAM1DyC,WACF,MAA4B,kBAAdrU,KAAKkR,KACfA,EAAKC,SAASnR,KAAKkR,KAAMlR,KAAK4R,cAC9Brd,EASF8f,SAAKA,GACPF,EAAeE,EAAM,QACrBD,EAAWC,EAAM,QACjBrU,KAAKkR,KAAOA,EAAKjT,KAAK+B,KAAK0R,SAAW,GAAI2C,GAAQrU,KAAK4R,SAAW,KAYpE/P,SAASyS,GACP,OAAQtU,KAAK1I,OAAS,IAAIuK,SAASyS,GAiBrC7D,QAAQnG,EAAQ+F,EAAOC,GACrB,MAAMG,EAAU,IAAIL,EAAa9F,EAAQ+F,EAAOC,GAWhD,OATItQ,KAAKkR,OACPT,EAAQxiB,KAAO+R,KAAKkR,KAAO,IAAMT,EAAQxiB,KACzCwiB,EAAQM,KAAO/Q,KAAKkR,MAGtBT,EAAQE,OAAQ,EAEhB3Q,KAAK+T,SAAStJ,KAAKgG,GAEZA,EAgBT8D,KAAKjK,EAAQ+F,EAAOC,GAClB,MAAMG,EAAUzQ,KAAKyQ,QAAQnG,EAAQ+F,EAAOC,GAI5C,OAFAG,EAAQE,MAAQ,KAETF,EAkBT+D,KAAKlK,EAAQ+F,EAAOC,GAClB,MAAMG,EAAUzQ,KAAKyQ,QAAQnG,EAAQ+F,EAAOC,GAI5C,MAFAG,EAAQE,OAAQ,EAEVF,GAWV,SAAS2D,EAAWK,EAAMxmB,GACxB,GAAIwmB,GAAQA,EAAKP,SAAShD,EAAK0B,KAC7B,MAAM,IAAIvI,MACR,IAAMpc,EAAO,uCAAyCijB,EAAK0B,IAAM,KAYvE,SAASuB,EAAeM,EAAMxmB,GAC5B,IAAKwmB,EACH,MAAM,IAAIpK,MAAM,IAAMpc,EAAO,qBAWjC,SAAS,EAAWijB,EAAMjjB,GACxB,IAAKijB,EACH,MAAM,IAAI7G,MAAM,YAAcpc,EAAO,mCC1ZlC,SAASymB,EAAKre,GACnB,GAAIA,EACF,MAAMA,E,eCTK,SAASoR,EAAcnQ,GACrC,GAAqB,kBAAVA,GAAgC,OAAVA,EAChC,OAAO,EAGR,MAAM4I,EAAY4F,OAAO6O,eAAerd,GACxC,OAAsB,OAAd4I,GAAsBA,IAAc4F,OAAO5F,WAAkD,OAArC4F,OAAO6O,eAAezU,OAA0B0N,OAAOgH,eAAetd,MAAYsW,OAAOkC,YAAYxY,GCW/J,SAASud,IAEd,MAAMC,EAAM,GAENC,EAAW,CAACC,IAKlB,YAAgBC,GACd,IAAIC,GAAmB,EAEvB,MAAMC,EAAWF,EAAOG,MAExB,GAAwB,oBAAbD,EACT,MAAM,IAAI9L,UAAU,2CAA6C8L,IAWnE,SAASE,EAAKhf,KAAU0Z,GACtB,MAAMuF,EAAKR,IAAMI,GACjB,IAAIrgB,GAAS,EAEb,GAAIwB,EACF8e,EAAS9e,OADX,CAMA,OAASxB,EAAQogB,EAAO/gB,QACA,OAAlB6b,EAAOlb,SAAqCN,IAAlBwb,EAAOlb,KACnCkb,EAAOlb,GAASogB,EAAOpgB,IAK3BogB,EAASlF,EAGLuF,EA6BH,SAAcC,EAAYJ,GAE/B,IAAIK,EAEJ,OAAO3a,EAQP,SAASA,KAAW4a,GAClB,MAAMC,EAAoBH,EAAWrhB,OAASuhB,EAAWvhB,OAEzD,IAAIoe,EAEAoD,GACFD,EAAWhL,KAAKkL,GAGlB,IACErD,EAASiD,EAAW9S,MAAMzC,KAAMyV,GAChC,MAAOpf,GACP,MAAMuf,EAAiC,EAMvC,GAAIF,GAAqBF,EACvB,MAAMI,EAGR,OAAOD,EAAKC,GAGTF,IACCpD,aAAkBuD,QACpBvD,EAAOwD,KAAKA,EAAMH,GACTrD,aAAkBjI,MAC3BsL,EAAKrD,GAELwD,EAAKxD,IASX,SAASqD,EAAKtf,KAAU0Z,GACjByF,IACHA,GAAS,EACTL,EAAS9e,KAAU0Z,IASvB,SAAS+F,EAAKxe,GACZqe,EAAK,KAAMre,IA7FPye,CAAKT,EAAID,EAATU,IAAkBhG,GAElBoF,EAAS,QAASpF,IA/BtBsF,CAAK,QAASJ,IAdOe,IAmDvB,SAAaC,GACX,GAA0B,oBAAfA,EACT,MAAM,IAAI5M,UACR,+CAAiD4M,GAKrD,OADAnB,EAAIrK,KAAKwL,GACFlB,IAzDT,OAAOA,ECKF,MAAMmB,EAQb,SAASC,IACP,MAAMC,EAAevB,IAEfwB,EAAY,GAElB,IAEIC,EAFAC,EAAY,GAGZC,GAAe,EA2BnB,OAvBAC,EAAU3C,KA6CV,SAAcnM,EAAKrQ,GACjB,GAAmB,kBAARqQ,EAET,OAAyB,IAArBpI,UAAUrL,QACZwiB,EAAe,OAAQJ,GACvBC,EAAU5O,GAAOrQ,EACVmf,GAIDE,EAAInP,KAAK+O,EAAW5O,IAAQ4O,EAAU5O,IAAS,KAIzD,GAAIA,EAGF,OAFA+O,EAAe,OAAQJ,GACvBC,EAAY5O,EACL8O,EAIT,OAAOF,GAjETE,EAAUG,YAASriB,EACnBkiB,EAAUI,cAAWtiB,EAGrBkiB,EAAUK,OAiEV,WACE,GAAIR,EACF,OAAOG,EAGT,OAASD,EAAcH,EAAUniB,QAAQ,CACvC,MAAO6iB,KAAa9O,GAAWoO,EAAUG,GAEzC,IAAmB,IAAfvO,EAAQ,GACV,UAGiB,IAAfA,EAAQ,KACVA,EAAQ,QAAK1T,GAIf,MAAMyiB,EAAcD,EAASvP,KAAKiP,KAAcxO,GAErB,oBAAhB+O,GACTZ,EAAaJ,IAAIgB,GAOrB,OAHAV,GAAS,EACTE,EAAczT,OAAOkU,kBAEdR,GAzFTA,EAAUJ,UAAYA,EAEtBI,EAAUT,IA+FV,SAAa1e,KAAU2Q,GAErB,IAAIiP,EAIJ,GAFAR,EAAe,MAAOJ,GAER,OAAVhf,QAA4B/C,IAAV+C,QAEf,GAAqB,oBAAVA,EAChB6f,EAAU7f,KAAU2Q,OACf,IAAqB,kBAAV3Q,EAOhB,MAAM,IAAI+R,UAAU,+BAAiC/R,EAAQ,KANzD0G,MAAMsJ,QAAQhQ,GAChB8f,EAAQ9f,GAER+f,EAAU/f,GAMV4f,IACFX,EAAUW,SAAWpR,OAAOwR,OAAOf,EAAUW,UAAY,GAAIA,IAG/D,OAAOT,EAMP,SAAS9X,EAAIrH,GACX,GAAqB,oBAAVA,EACT6f,EAAU7f,OACL,IAAqB,kBAAVA,EAQhB,MAAM,IAAI+R,UAAU,+BAAiC/R,EAAQ,KAP7D,GAAI0G,MAAMsJ,QAAQhQ,GAAQ,CACxB,MAAOigB,KAAWtP,GAAW3Q,EAC7B6f,EAAUI,KAAWtP,QAErBoP,EAAU/f,IAWhB,SAAS+f,EAAU/E,GACjB8E,EAAQ9E,EAAOkF,SAEXlF,EAAO4E,WACTA,EAAWpR,OAAOwR,OAAOJ,GAAY,GAAI5E,EAAO4E,WAQpD,SAASE,EAAQI,GACf,IAAI3iB,GAAS,EAEb,GAAgB,OAAZ2iB,QAAgCjjB,IAAZijB,OAEjB,KAAIxZ,MAAMsJ,QAAQkQ,GAMvB,MAAM,IAAInO,UAAU,oCAAsCmO,EAAU,KALpE,OAAS3iB,EAAQ2iB,EAAQtjB,QAAQ,CAE/ByK,EADc6Y,EAAQ3iB,MAa5B,SAASsiB,EAAUI,EAAQjgB,GACzB,IAEImgB,EAFA5iB,GAAS,EAIb,OAASA,EAAQwhB,EAAUniB,QACzB,GAAImiB,EAAUxhB,GAAO,KAAO0iB,EAAQ,CAClCE,EAAQpB,EAAUxhB,GAClB,MAIA4iB,GACE,EAAWA,EAAM,KAAO,EAAWngB,KACrCA,EAAQyN,GAAO,EAAM0S,EAAM,GAAIngB,IAGjCmgB,EAAM,GAAKngB,GAGX+e,EAAU5L,KAAK,IAAIlL,cAjMzBkX,EAAUxW,MAuMV,SAAeyX,GACbjB,EAAUK,SACV,MAAM/F,EAAO4G,EAAMD,GACbd,EAASH,EAAUG,OAGzB,GAFAgB,EAAa,QAAShB,GAElBiB,EAAQjB,EAAQ,SAElB,OAAO,IAAIA,EAAO7Y,OAAOgT,GAAOA,GAAM9Q,QAIxC,OAAO2W,EAAO7Y,OAAOgT,GAAOA,IAlN9B0F,EAAU3D,UAsNV,SAAmBjJ,EAAM6N,GACvBjB,EAAUK,SACV,MAAM/F,EAAO4G,EAAMD,GACbb,EAAWJ,EAAUI,SAI3B,GAHAiB,EAAe,YAAajB,GAC5BkB,EAAWlO,GAEPgO,EAAQhB,EAAU,WAEpB,OAAO,IAAIA,EAAShN,EAAMkH,GAAMiH,UAIlC,OAAOnB,EAAShN,EAAMkH,IAjOxB0F,EAAUzB,IA0OV,SAAanL,EAAM6N,EAAKvC,GACtB4C,EAAWlO,GACX4M,EAAUK,SAEL3B,GAA2B,oBAARuC,IACtBvC,EAAWuC,EACXA,OAAMnjB,GAGR,IAAK4gB,EACH,OAAO,IAAIU,QAAQoC,GAUrB,SAASA,EAASC,EAASC,GAUzB,SAASxC,EAAKtf,EAAO+hB,EAAMrH,GACzBqH,EAAOA,GAAQvO,EACXxT,EACF8hB,EAAO9hB,GACE6hB,EACTA,EAAQE,GAGRjD,EAAS,KAAMiD,EAAMrH,GAhBzBqF,EAAapB,IAAInL,EAAM8N,EAAMD,GAAM/B,GATrCsC,EAAS,KAAM9C,IAtPjBsB,EAAU4B,QAsRV,SAAiBxO,EAAMkH,GAErB,IAAIuB,EAEAgG,EAOJ,OALA7B,EAAUzB,IAAInL,EAAMkH,EAAM4E,GAE1B4C,EAAW,UAAW,MAAOD,GAGtBhG,EAOP,SAASqD,EAAKtf,EAAO+hB,GACnB1D,EAAKre,GACLic,EAAS8F,EACTE,GAAW,IAzSf7B,EAAU+B,QAkTV,SAAiBd,EAAKvC,GAKpB,GAJAsB,EAAUK,SACVc,EAAa,UAAWnB,EAAUG,QAClCkB,EAAe,UAAWrB,EAAUI,WAE/B1B,EACH,OAAO,IAAIU,QAAQoC,GAUrB,SAASA,EAASC,EAASC,GACzB,MAAMpH,EAAO4G,EAAMD,GA0BnB,SAAS/B,EAAKtf,EAAO0a,GACf1a,IAAU0a,EACZoH,EAAO9hB,GACE6hB,EACTA,EAAQnH,GAGRoE,EAAS,KAAMpE,GA/BnB0F,EAAUzB,IAAIyB,EAAUxW,MAAM8Q,GAAOA,GAAM,CAAC1a,EAAO+hB,EAAMrH,KACvD,IAAI1a,GAAU+hB,GAASrH,EAEhB,CAEL,MAAMuB,EAASmE,EAAU3D,UAAUsF,EAAMrH,QAE1Bxc,IAAX+d,GAAmC,OAAXA,IAsMZ,kBADIhb,EAnMYgb,IAoMJ,EAAShb,GAnMnCyZ,EAAKzZ,MAAQgb,EAEbvB,EAAKuB,OAASA,GAGhBqD,EAAKtf,EAAO0a,QAbZ4E,EAAKtf,GA0Mf,IAA8BiB,KAtN1B2gB,EAAS,KAAM9C,IA1TjBsB,EAAUgC,YA0WV,SAAqBf,GAEnB,IAAIY,EAEJ7B,EAAUK,SACVc,EAAa,cAAenB,EAAUG,QACtCkB,EAAe,cAAerB,EAAUI,UAExC,MAAM9F,EAAO4G,EAAMD,GAMnB,OAJAjB,EAAU+B,QAAQzH,EAAM4E,GAExB4C,EAAW,cAAe,UAAWD,GAE9BvH,EAMP,SAAS4E,EAAKtf,GACZiiB,GAAW,EACX5D,EAAKre,KA7XFogB,EAIP,SAASA,IACP,MAAMiC,EAAcvC,IACpB,IAAIthB,GAAS,EAEb,OAASA,EAAQwhB,EAAUniB,QACzBwkB,EAAY1C,OAAOK,EAAUxhB,IAK/B,OAFA6jB,EAAY5E,KAAK/O,GAAO,EAAM,GAAIwR,IAE3BmC,GAzDYvC,GAAOW,SAExBH,EAAM,GAAG1P,eAkbf,SAAS4Q,EAAQvgB,EAAOrJ,GACtB,MACmB,oBAAVqJ,GAGPA,EAAM4I,YAeV,SAAc5I,GAEZ,IAAIqQ,EAEJ,IAAKA,KAAOrQ,EACV,GAAIqf,EAAInP,KAAKlQ,EAAOqQ,GAClB,OAAO,EAIX,OAAO,EApBJ5B,CAAKzO,EAAM4I,YAAcjS,KAAQqJ,EAAM4I,WA8B5C,SAAS0X,EAAa3pB,EAAMqJ,GAC1B,GAAqB,oBAAVA,EACT,MAAM,IAAI+R,UAAU,WAAapb,EAAO,sBAW5C,SAAS6pB,EAAe7pB,EAAMqJ,GAC5B,GAAqB,oBAAVA,EACT,MAAM,IAAI+R,UAAU,WAAapb,EAAO,wBAW5C,SAASyoB,EAAezoB,EAAMqoB,GAC5B,GAAIA,EACF,MAAM,IAAIjM,MACR,gBACEpc,EACA,oHAWR,SAAS8pB,EAAWlO,GAGlB,IAAK,EAAWA,IAA8B,kBAAdA,EAAKoB,KACnC,MAAM,IAAI5B,UAAU,uBAAyBQ,EAAO,KAaxD,SAAS0O,EAAWtqB,EAAM0qB,EAAWL,GACnC,IAAKA,EACH,MAAM,IAAIjO,MACR,IAAMpc,EAAO,0BAA4B0qB,EAAY,aAS3D,SAAShB,EAAMrgB,GACb,OAOF,SAAyBA,GACvB,OAAOshB,QACLthB,GACmB,kBAAVA,GACP,YAAaA,GACb,aAAcA,GAZXuhB,CAAgBvhB,GAASA,EAAQ,IAAIuc,EAAMvc,GCxiBpD,SAASwhB,EAAIjP,EAAMkP,GACjB,OACGlP,GACiB,kBAATA,IAENA,EAAKvS,QAEHyhB,EAAkBlP,EAAKjZ,IAAM,KAE7B,aAAciZ,GAAQ,EAAIA,EAAKhZ,SAAUkoB,IACzC/a,MAAMsJ,QAAQuC,IAAS,EAAIA,EAAMkP,KACtC,GASJ,SAAS,EAAI9D,EAAQ8D,GAKnB,IAHA,IAAIzG,EAAS,GACTzd,GAAS,IAEJA,EAAQogB,EAAO/gB,QACtBoe,EAAOzd,GAASikB,EAAI7D,EAAOpgB,GAAQkkB,GAGrC,OAAOzG,EAAOrU,KAAK,ICrCd,SAAS+a,EAAOC,EAAMtP,EAAOuP,EAAQC,GAC1C,MAAMnP,EAAMiP,EAAK/kB,OACjB,IAGIuhB,EAHA2D,EAAa,EAajB,GAPEzP,EADEA,EAAQ,GACDA,EAAQK,EAAM,EAAIA,EAAML,EAEzBA,EAAQK,EAAMA,EAAML,EAG9BuP,EAASA,EAAS,EAAIA,EAAS,EAE3BC,EAAMjlB,OAAS,IACjBuhB,EAAazX,MAAMqb,KAAKF,GACxB1D,EAAW6D,QAAQ3P,EAAOuP,GACzB,GAAGF,OAAOvW,MAAMwW,EAAMxD,QAKvB,IAFIyD,GAAQ,GAAGF,OAAOvW,MAAMwW,EAAM,CAACtP,EAAOuP,IAEnCE,EAAaD,EAAMjlB,QACxBuhB,EAAa0D,EAAMzkB,MAAM0kB,EAAYA,EAAa,KAClD3D,EAAW6D,QAAQ3P,EAAO,GACzB,GAAGqP,OAAOvW,MAAMwW,EAAMxD,GACvB2D,GAAc,IACdzP,GAAS,IAiBR,SAASc,EAAKwO,EAAME,GACzB,OAAIF,EAAK/kB,OAAS,GAChB8kB,EAAOC,EAAMA,EAAK/kB,OAAQ,EAAGilB,GACtBF,GAGFE,EC1DT,MAAM,EAAiB,GAAGlS,eA2B1B,SAASsS,EAAgBC,EAAKC,GAE5B,IAAIC,EAEJ,IAAKA,KAAQD,EAAW,CACtB,MACMhhB,GADQ,EAAe+O,KAAKgS,EAAKE,GAAQF,EAAIE,QAAQnlB,KACpCilB,EAAIE,GAAQ,IAC7B/gB,EAAQ8gB,EAAUC,GAExB,IAAI1H,EAEJ,IAAKA,KAAQrZ,EAAO,CACb,EAAe6O,KAAK/O,EAAMuZ,KAAOvZ,EAAKuZ,GAAQ,IACnD,MAAM1a,EAAQqB,EAAMqZ,GACpB2H,EAEElhB,EAAKuZ,GACLhU,MAAMsJ,QAAQhQ,GAASA,EAAQA,EAAQ,CAACA,GAAS,MAczD,SAASqiB,EAAWC,EAAUX,GAC5B,IAAIpkB,GAAS,EAEb,MAAMglB,EAAS,GAEf,OAAShlB,EAAQokB,EAAK/kB,SAEE,UAApB+kB,EAAKpkB,GAAO8J,IAAkBib,EAAWC,GAAQpP,KAAKwO,EAAKpkB,IAG/DmkB,EAAOY,EAAU,EAAG,EAAGC,GCvElB,MCWMC,EAAaC,GAAW,YAQxBC,EAAaD,GAAW,MAexBE,EAAgBF,GAAW,cAS3BG,EAAoBH,GAAW,cAU/BI,EAAmBJ,GAAW,kBAkB9BK,EAAaL,GAAW,uBAW9B,SAASM,EAAarI,GAC3B,OAGW,OAATA,IAAkBA,EAAO,IAAe,MAATA,GAW5B,SAASsI,EAA0BtI,GACxC,OAAgB,OAATA,IAAkBA,EAAO,GAAc,KAATA,GAgBhC,SAASuI,EAAmBvI,GACjC,OAAgB,OAATA,GAAiBA,GAAQ,EAgB3B,SAASwI,EAAcxI,GAC5B,OAAiB,IAAVA,IAAyB,IAAVA,GAAwB,KAATA,EAkBhC,MAAMyI,EAAoBV,GAAW,MAkB/BW,EAAqBX,GDvKhC,+vCC+KF,SAASA,GAAWY,GAClB,OAQA,SAAe3I,GACb,OAAgB,OAATA,GAAiB2I,EAAMra,KAAKvC,OAAO6c,aAAa5I,KCnLpD,SAAS6I,GAAaC,EAASC,EAAI9P,EAAMtX,GAC9C,MAAMqnB,EAAQrnB,EAAMA,EAAM,EAAIoP,OAAOkU,kBACrC,IAAI7f,EAAO,EACX,OAGA,SAAe4a,GACb,GAAIwI,EAAcxI,GAEhB,OADA8I,EAAQG,MAAMhQ,GACPiQ,EAAOlJ,GAGhB,OAAO+I,EAAG/I,IAIZ,SAASkJ,EAAOlJ,GACd,OAAIwI,EAAcxI,IAAS5a,IAAS4jB,GAClCF,EAAQK,QAAQnJ,GACTkJ,IAGTJ,EAAQM,KAAKnQ,GACN8P,EAAG/I,KC1BP,MAAMxZ,GAAU,CACrB6iB,SAIF,SAA2BP,GACzB,MAAMQ,EAAeR,EAAQS,QAC3Bvb,KAAKwb,OAAO7B,WAAW8B,gBAUzB,SAAoCzJ,GAClC,GAAa,OAATA,EAEF,YADA8I,EAAQK,QAAQnJ,GAOlB,OAHA8I,EAAQG,MAAM,cACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,cACNP,GAAaC,EAASQ,EAAc,iBAI7C,SAA0BtJ,GAExB,OADA8I,EAAQG,MAAM,aACPS,EAAU1J,MAnBnB,IAAI2J,EACJ,OAAOL,EAsBP,SAASI,EAAU1J,GACjB,MAAM4J,EAAQd,EAAQG,MAAM,YAAa,CACvCY,YAAa,OACbF,aAQF,OALIA,IACFA,EAAStG,KAAOuG,GAGlBD,EAAWC,EACJ9H,EAAK9B,GAId,SAAS8B,EAAK9B,GACZ,OAAa,OAATA,GACF8I,EAAQM,KAAK,aACbN,EAAQM,KAAK,kBACbN,EAAQK,QAAQnJ,IAIduI,EAAmBvI,IACrB8I,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,aACNM,IAGTZ,EAAQK,QAAQnJ,GACT8B,MCxDJ,MAAM,GAAW,CACtBuH,SASF,SAA4BP,GAC1B,MAAMgB,EAAO9b,KAGP0Q,EAAQ,GACd,IAGIqL,EAGAC,EAGAC,EATAC,EAAY,EAUhB,OAAOvS,EAGP,SAASA,EAAMqI,GAWb,GAAIkK,EAAYxL,EAAMxc,OAAQ,CAC5B,MAAMioB,EAAOzL,EAAMwL,GAEnB,OADAJ,EAAKM,eAAiBD,EAAK,GACpBrB,EAAQS,QACbY,EAAK,GAAGE,aACRC,EACAC,EAHKzB,CAIL9I,GAGJ,OAAOuK,EAAmBvK,GAI5B,SAASsK,EAAiBtK,GAKxB,GAJAkK,IAIIJ,EAAKM,eAAeI,WAAY,CAClCV,EAAKM,eAAeI,gBAAajoB,EAE7BwnB,GACFU,IAIF,MAAMC,EAAmBZ,EAAKa,OAAOzoB,OACrC,IAGIic,EAHAyM,EAAkBF,EAKtB,KAAOE,KACL,GACsC,SAApCd,EAAKa,OAAOC,GAAiB,IACY,cAAzCd,EAAKa,OAAOC,GAAiB,GAAG3R,KAChC,CACAkF,EAAQ2L,EAAKa,OAAOC,GAAiB,GAAG5S,IACxC,MAIJ6S,EAAeX,GAEf,IAAIrnB,EAAQ6nB,EAEZ,KAAO7nB,EAAQinB,EAAKa,OAAOzoB,QACzB4nB,EAAKa,OAAO9nB,GAAO,GAAGmV,IAAMlE,OAAOwR,OAAO,GAAInH,GAC9Ctb,IAWF,OARAmkB,EACE8C,EAAKa,OACLC,EAAkB,EAClB,EACAd,EAAKa,OAAOjoB,MAAMgoB,IAGpBZ,EAAKa,OAAOzoB,OAASW,EACd0nB,EAAmBvK,GAG5B,OAAOrI,EAAMqI,GAIf,SAASuK,EAAmBvK,GAM1B,GAAIkK,IAAcxL,EAAMxc,OAAQ,CAI9B,IAAK6nB,EACH,OAAOe,EAAkB9K,GAK3B,GAAI+J,EAAUgB,kBAAoBhB,EAAUgB,iBAAiBC,SAC3D,OAAOC,EAAUjL,GAKnB8J,EAAKoB,UAAYtE,QACfmD,EAAUgB,mBAAqBhB,EAAUoB,+BAK7C,OADArB,EAAKM,eAAiB,GACftB,EAAQsC,MACbC,GACAC,EACAC,EAHKzC,CAIL9I,GAIJ,SAASsL,EAAqBtL,GAG5B,OAFI+J,GAAWU,IACfI,EAAeX,GACRY,EAAkB9K,GAI3B,SAASuL,EAAsBvL,GAG7B,OAFA8J,EAAKN,OAAOgC,KAAK1B,EAAK2B,MAAM7T,MAAQsS,IAAcxL,EAAMxc,OACxD+nB,EAAkBH,EAAK2B,MAAMC,OACtBT,EAAUjL,GAInB,SAAS8K,EAAkB9K,GAGzB,OADA8J,EAAKM,eAAiB,GACftB,EAAQS,QACb8B,GACAM,EACAV,EAHKnC,CAIL9I,GAIJ,SAAS2L,EAAkB3L,GAIzB,OAHAkK,IACAxL,EAAMjG,KAAK,CAACqR,EAAKiB,iBAAkBjB,EAAKM,iBAEjCU,EAAkB9K,GAI3B,SAASiL,EAAUjL,GACjB,OAAa,OAATA,GACE+J,GAAWU,IACfI,EAAe,QACf/B,EAAQK,QAAQnJ,KAIlB+J,EAAYA,GAAaD,EAAKN,OAAOoC,KAAK9B,EAAK2B,OAC/C3C,EAAQG,MAAM,YAAa,CACzBY,YAAa,OACbF,SAAUK,EACV6B,WAAY9B,IAEP+B,EAAa9L,IAItB,SAAS8L,EAAa9L,GACpB,OAAa,OAATA,GACF+L,EAAajD,EAAQM,KAAK,cAAc,GACxCyB,EAAe,QACf/B,EAAQK,QAAQnJ,IAIduI,EAAmBvI,IACrB8I,EAAQK,QAAQnJ,GAChB+L,EAAajD,EAAQM,KAAK,cAE1Bc,EAAY,EACZJ,EAAKoB,eAAY3oB,EACVoV,IAGTmR,EAAQK,QAAQnJ,GACT8L,GAQT,SAASC,EAAanC,EAAOoC,GAC3B,MAAMC,EAASnC,EAAKoC,YAAYtC,GAwChC,GAvCIoC,GAAKC,EAAOxT,KAAK,MACrBmR,EAAMD,SAAWK,EACbA,IAAYA,EAAW3G,KAAOuG,GAClCI,EAAaJ,EACbG,EAAUoC,WAAWvC,EAAMjS,OAC3BoS,EAAUqC,MAAMH,GAkCZnC,EAAKN,OAAOgC,KAAK5B,EAAMjS,MAAMC,MAAO,CACtC,IAAI/U,EAAQknB,EAAUY,OAAOzoB,OAE7B,KAAOW,KACL,GAEEknB,EAAUY,OAAO9nB,GAAO,GAAG8U,MAAM+T,OAASzB,KACxCF,EAAUY,OAAO9nB,GAAO,GAAGmV,KAC3B+R,EAAUY,OAAO9nB,GAAO,GAAGmV,IAAI0T,OAASzB,GAI1C,OAKJ,MAAMS,EAAmBZ,EAAKa,OAAOzoB,OACrC,IAGImqB,EAGAlO,EANAyM,EAAkBF,EAQtB,KAAOE,KACL,GACsC,SAApCd,EAAKa,OAAOC,GAAiB,IACY,cAAzCd,EAAKa,OAAOC,GAAiB,GAAG3R,KAChC,CACA,GAAIoT,EAAM,CACRlO,EAAQ2L,EAAKa,OAAOC,GAAiB,GAAG5S,IACxC,MAGFqU,GAAO,EAQX,IAJAxB,EAAeX,GAEfrnB,EAAQ6nB,EAED7nB,EAAQinB,EAAKa,OAAOzoB,QACzB4nB,EAAKa,OAAO9nB,GAAO,GAAGmV,IAAMlE,OAAOwR,OAAO,GAAInH,GAC9Ctb,IAGFmkB,EACE8C,EAAKa,OACLC,EAAkB,EAClB,EACAd,EAAKa,OAAOjoB,MAAMgoB,IAGpBZ,EAAKa,OAAOzoB,OAASW,GAQzB,SAASgoB,EAAezlB,GACtB,IAAIvC,EAAQ6b,EAAMxc,OAElB,KAAOW,KAAUuC,GAAM,CACrB,MAAMqgB,EAAQ/G,EAAM7b,GACpBinB,EAAKM,eAAiB3E,EAAM,GAC5BA,EAAM,GAAG2D,KAAK5T,KAAKsU,EAAMhB,GAG3BpK,EAAMxc,OAASkD,EAGjB,SAASqlB,IACPV,EAAUqC,MAAM,CAAC,OACjBpC,OAAaznB,EACbwnB,OAAYxnB,EACZunB,EAAKM,eAAeI,gBAAajoB,KA/U/B8oB,GAAqB,CACzBhC,SAmVF,SAA2BP,EAASC,EAAIuD,GACtC,OAAOzD,GACLC,EACAA,EAAQS,QAAQvb,KAAKwb,OAAO7B,WAAW4E,SAAUxD,EAAIuD,GACrD,aACAte,KAAKwb,OAAO7B,WAAW6E,QAAQC,KAAKvK,SAAS,qBAAkB3f,EAAY,KCzWxE,MAAMmqB,GAAY,CACvBrD,SAKF,SAA2BP,EAASC,EAAIuD,GACtC,OAAOzD,GAAaC,GAGpB,SAAyB9I,GACvB,OAAgB,OAATA,GAAiBuI,EAAmBvI,GAAQ+I,EAAG/I,GAAQsM,EAAItM,KAJtB,eAL9C2M,SAAS,GCEJ,SAASC,GAAYjC,GAE1B,MAAMkC,EAAQ,GACd,IAGIriB,EAGAsiB,EAGAC,EAGAC,EAGAvJ,EAGAwJ,EAGAC,EArBArqB,GAAS,EAuBb,OAASA,EAAQ8nB,EAAOzoB,QAAQ,CAC9B,KAAOW,KAASgqB,GACdhqB,EAAQgqB,EAAMhqB,GAMhB,GAHA2H,EAAQmgB,EAAO9nB,GAIbA,GACkB,cAAlB2H,EAAM,GAAGyO,MACqB,mBAA9B0R,EAAO9nB,EAAQ,GAAG,GAAGoW,OAErBgU,EAAYziB,EAAM,GAAGqhB,WAAWlB,OAChCoC,EAAa,EAGXA,EAAaE,EAAU/qB,QACW,oBAAlC+qB,EAAUF,GAAY,GAAG9T,OAEzB8T,GAAc,GAIdA,EAAaE,EAAU/qB,QACW,YAAlC+qB,EAAUF,GAAY,GAAG9T,MAEzB,OAAS8T,EAAaE,EAAU/qB,QACQ,YAAlC+qB,EAAUF,GAAY,GAAG9T,MAIS,cAAlCgU,EAAUF,GAAY,GAAG9T,OAC3BgU,EAAUF,GAAY,GAAGI,6BAA8B,EACvDJ,KAMR,GAAiB,UAAbviB,EAAM,GACJA,EAAM,GAAGqf,cACX/V,OAAOwR,OAAOuH,EAAOO,GAAWzC,EAAQ9nB,IACxCA,EAAQgqB,EAAMhqB,GACdqqB,GAAO,QAGN,GAAI1iB,EAAM,GAAG6iB,WAAY,CAI5B,IAHAN,EAAalqB,EACbiqB,OAAYvqB,EAELwqB,MACLC,EAAarC,EAAOoC,GAGK,eAAvBC,EAAW,GAAG/T,MACS,oBAAvB+T,EAAW,GAAG/T,OAEQ,UAAlB+T,EAAW,KACTF,IACFnC,EAAOmC,GAAW,GAAG7T,KAAO,mBAG9B+T,EAAW,GAAG/T,KAAO,aACrB6T,EAAYC,GAOdD,IAEFtiB,EAAM,GAAGwN,IAAMlE,OAAOwR,OAAO,GAAIqF,EAAOmC,GAAW,GAAGnV,OAEtD8L,EAAakH,EAAOjoB,MAAMoqB,EAAWjqB,GACrC4gB,EAAW6D,QAAQ9c,GACnBwc,EAAO2D,EAAQmC,EAAWjqB,EAAQiqB,EAAY,EAAGrJ,KAKvD,OAAQyJ,EAUV,SAASE,GAAWzC,EAAQ2C,GAC1B,MAAM1D,EAAQe,EAAO2C,GAAY,GAC3BC,EAAU5C,EAAO2C,GAAY,GACnC,IAAIE,EAAgBF,EAAa,EAGjC,MAAMG,EAAiB,GACjBC,EACJ9D,EAAMiC,YAAc0B,EAAQ/D,OAAOI,EAAMC,aAAaD,EAAMjS,OACxDgW,EAAcD,EAAU/C,OAGxBkC,EAAQ,GAGRe,EAAO,GAGb,IAAI3B,EAGAtC,EACA9mB,GAAS,EAGTgrB,EAAUjE,EACVkE,EAAS,EACTnW,EAAQ,EACZ,MAAMoW,EAAS,CAACpW,GAGhB,KAAOkW,GAAS,CAEd,KAAOlD,IAAS6C,GAAe,KAAOK,IAItCJ,EAAehV,KAAK+U,GAEfK,EAAQhC,aACXI,EAASsB,EAAQrB,YAAY2B,GAExBA,EAAQxK,MACX4I,EAAOxT,KAAK,MAGVkR,GACF+D,EAAUvB,WAAW0B,EAAQlW,OAG3BkW,EAAQV,8BACVO,EAAUM,oCAAqC,GAGjDN,EAAUtB,MAAMH,GAEZ4B,EAAQV,8BACVO,EAAUM,wCAAqCzrB,IAInDonB,EAAWkE,EACXA,EAAUA,EAAQxK,KAMpB,IAFAwK,EAAUjE,IAED/mB,EAAQ8qB,EAAYzrB,QAGC,SAA1ByrB,EAAY9qB,GAAO,IACW,UAA9B8qB,EAAY9qB,EAAQ,GAAG,IACvB8qB,EAAY9qB,GAAO,GAAGoW,OAAS0U,EAAY9qB,EAAQ,GAAG,GAAGoW,MACzD0U,EAAY9qB,GAAO,GAAG8U,MAAMC,OAAS+V,EAAY9qB,GAAO,GAAGmV,IAAIJ,OAE/DD,EAAQ9U,EAAQ,EAChBkrB,EAAOtV,KAAKd,GAEZkW,EAAQhC,gBAAatpB,EACrBsrB,EAAQlE,cAAWpnB,EACnBsrB,EAAUA,EAAQxK,MAmBtB,IAfAqK,EAAU/C,OAAS,GAIfkD,GAEFA,EAAQhC,gBAAatpB,EACrBsrB,EAAQlE,cAAWpnB,GAEnBwrB,EAAO3K,MAITvgB,EAAQkrB,EAAO7rB,OAERW,KAAS,CACd,MAAMH,EAAQirB,EAAYjrB,MAAMqrB,EAAOlrB,GAAQkrB,EAAOlrB,EAAQ,IACxD8U,EAAQ8V,EAAerK,MAC7ByJ,EAAMvF,QAAQ,CAAC3P,EAAOA,EAAQjV,EAAMR,OAAS,IAC7C8kB,EAAO2D,EAAQhT,EAAO,EAAGjV,GAK3B,IAFAG,GAAS,IAEAA,EAAQgqB,EAAM3qB,QACrB0rB,EAAKE,EAASjB,EAAMhqB,GAAO,IAAMirB,EAASjB,EAAMhqB,GAAO,GACvDirB,GAAUjB,EAAMhqB,GAAO,GAAKgqB,EAAMhqB,GAAO,GAAK,EAGhD,OAAO+qB,ECtOF,MAAM,GAAU,CACrBvE,SAsBF,SAAyBP,EAASC,GAEhC,IAAIY,EACJ,OAGA,SAAe3J,GAKb,OAJA8I,EAAQG,MAAM,WACdU,EAAWb,EAAQG,MAAM,eAAgB,CACvCY,YAAa,YAER/H,EAAK9B,IAId,SAAS8B,EAAK9B,GACZ,OAAa,OAATA,EACKiO,EAAWjO,GAGhBuI,EAAmBvI,GACd8I,EAAQsC,MACb8C,GACAC,EACAF,EAHKnF,CAIL9I,IAGJ8I,EAAQK,QAAQnJ,GACT8B,GAIT,SAASmM,EAAWjO,GAGlB,OAFA8I,EAAQM,KAAK,gBACbN,EAAQM,KAAK,WACNL,EAAG/I,GAIZ,SAASmO,EAAgBnO,GAQvB,OAPA8I,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,gBACbO,EAAStG,KAAOyF,EAAQG,MAAM,eAAgB,CAC5CY,YAAa,UACbF,aAEFA,EAAWA,EAAStG,KACbvB,IArEToE,QAeF,SAAwByE,GAEtB,OADAiC,GAAYjC,GACLA,IAbHuD,GAAwB,CAC5B7E,SAqEF,SAA8BP,EAASC,EAAIuD,GACzC,MAAMxC,EAAO9b,KACb,OAGA,SAAwBgS,GAKtB,OAJA8I,EAAQM,KAAK,gBACbN,EAAQG,MAAM,cACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,cACNP,GAAaC,EAASsF,EAAU,eAIzC,SAASA,EAASpO,GAChB,GAAa,OAATA,GAAiBuI,EAAmBvI,GACtC,OAAOsM,EAAItM,GAGb,MAAMqO,EAAOvE,EAAKa,OAAOb,EAAKa,OAAOzoB,OAAS,GAE9C,OACG4nB,EAAKN,OAAO7B,WAAW6E,QAAQC,KAAKvK,SAAS,iBAC9CmM,GACiB,eAAjBA,EAAK,GAAGpV,MACRoV,EAAK,GAAGC,eAAeD,EAAK,IAAI,GAAMnsB,QAAU,EAEzC6mB,EAAG/I,GAGL8I,EAAQoC,UAAUpB,EAAKN,OAAO7B,WAAWiE,KAAMU,EAAKvD,EAApDD,CAAwD9I,KAlGjE2M,SAAS,GCbJ,MAAMf,GAAO,CAClBvC,SAIF,SAAwBP,GACtB,MAAMgB,EAAO9b,KACPugB,EAAUzF,EAAQS,QAEtBmD,IAmBF,SAAuB1M,GACrB,GAAa,OAATA,EAEF,YADA8I,EAAQK,QAAQnJ,GAQlB,OAJA8I,EAAQG,MAAM,mBACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,mBACbU,EAAKiB,sBAAmBxoB,EACjBgsB,IA3BPzF,EAAQS,QACNvb,KAAKwb,OAAO7B,WAAW6G,YACvBC,EACA5F,GACEC,EACAA,EAAQS,QACNvb,KAAKwb,OAAO7B,WAAWiE,KACvB6C,EACA3F,EAAQS,QAAQ,GAASkF,IAE3B,gBAIN,OAAOF,EAiBP,SAASE,EAAezO,GACtB,GAAa,OAATA,EASJ,OAJA8I,EAAQG,MAAM,cACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,cACbU,EAAKiB,sBAAmBxoB,EACjBgsB,EARLzF,EAAQK,QAAQnJ,MC9Cf,MAAM0O,GAAW,CACtBC,WAAYC,MAED9T,GAAS+T,GAAkB,UAC3B,GAAOA,GAAkB,QAMtC,SAASA,GAAkBC,GACzB,MAAO,CACLzF,SAOF,SAAwBP,GACtB,MAAMgB,EAAO9b,KACP2Z,EAAa3Z,KAAKwb,OAAO7B,WAAWmH,GACpCtlB,EAAOsf,EAAQS,QAAQ5B,EAAYhQ,EAAOoX,GAChD,OAAOpX,EAGP,SAASA,EAAMqI,GACb,OAAOgP,EAAQhP,GAAQxW,EAAKwW,GAAQ+O,EAAQ/O,GAI9C,SAAS+O,EAAQ/O,GACf,GAAa,OAATA,EAOJ,OAFA8I,EAAQG,MAAM,QACdH,EAAQK,QAAQnJ,GACT8B,EANLgH,EAAQK,QAAQnJ,GAUpB,SAAS8B,EAAK9B,GACZ,OAAIgP,EAAQhP,IACV8I,EAAQM,KAAK,QACN5f,EAAKwW,KAGd8I,EAAQK,QAAQnJ,GACT8B,GAOT,SAASkN,EAAQhP,GACf,GAAa,OAATA,EACF,OAAO,EAGT,MAAMiH,EAAOU,EAAW3H,GACxB,IAAInd,GAAS,EAEb,GAAIokB,EACF,OAASpkB,EAAQokB,EAAK/kB,QAAQ,CAC5B,MAAMioB,EAAOlD,EAAKpkB,GAElB,IAAKsnB,EAAKR,UAAYQ,EAAKR,SAASnU,KAAKsU,EAAMA,EAAKH,UAClD,OAAO,EAKb,OAAO,IA9DTgF,WAAYC,GACA,SAAVE,EAAmBG,QAAyB1sB,IAsElD,SAASqsB,GAAeM,GACtB,OAGA,SAAwBvE,EAAQ4C,GAC9B,IAGItE,EAHApmB,GAAS,EAMb,OAASA,GAAS8nB,EAAOzoB,aACTK,IAAV0mB,EACE0B,EAAO9nB,IAAoC,SAA1B8nB,EAAO9nB,GAAO,GAAGoW,OACpCgQ,EAAQpmB,EACRA,KAEQ8nB,EAAO9nB,IAAoC,SAA1B8nB,EAAO9nB,GAAO,GAAGoW,OAExCpW,IAAUomB,EAAQ,IACpB0B,EAAO1B,GAAO,GAAGjR,IAAM2S,EAAO9nB,EAAQ,GAAG,GAAGmV,IAC5C2S,EAAO3D,OAAOiC,EAAQ,EAAGpmB,EAAQomB,EAAQ,GACzCpmB,EAAQomB,EAAQ,GAGlBA,OAAQ1mB,GAIZ,OAAO2sB,EAAgBA,EAAcvE,EAAQ4C,GAAW5C,GAe5D,SAASsE,GAAuBtE,EAAQ4C,GACtC,IAAID,EAAa,EAEjB,OAASA,GAAc3C,EAAOzoB,QAC5B,IACGorB,IAAe3C,EAAOzoB,QACU,eAA/ByoB,EAAO2C,GAAY,GAAGrU,OACW,SAAnC0R,EAAO2C,EAAa,GAAG,GAAGrU,KAC1B,CACA,MAAM6I,EAAO6I,EAAO2C,EAAa,GAAG,GAC9B6B,EAAS5B,EAAQrB,YAAYpK,GACnC,IAKIsN,EALAvsB,EAAQssB,EAAOjtB,OACfmtB,GAAe,EACfjqB,EAAO,EAKX,KAAOvC,KAAS,CACd,MAAMysB,EAAQH,EAAOtsB,GAErB,GAAqB,kBAAVysB,EAAoB,CAG7B,IAFAD,EAAcC,EAAMptB,OAEyB,KAAtCotB,EAAM/P,WAAW8P,EAAc,IACpCjqB,IACAiqB,IAGF,GAAIA,EAAa,MACjBA,GAAe,OAEZ,IAAe,IAAXC,EACPF,GAAO,EACPhqB,SACK,IAAe,IAAXkqB,EAEJ,CAELzsB,IACA,OAIJ,GAAIuC,EAAM,CACR,MAAMwkB,EAAQ,CACZ3Q,KACEqU,IAAe3C,EAAOzoB,QAAUktB,GAAQhqB,EAAO,EAC3C,aACA,oBACNuS,MAAO,CACLC,KAAMkK,EAAK9J,IAAIJ,KACfL,OAAQuK,EAAK9J,IAAIT,OAASnS,EAC1BsmB,OAAQ5J,EAAK9J,IAAI0T,OAAStmB,EAC1BmqB,OAAQzN,EAAKnK,MAAM4X,OAAS1sB,EAC5B2sB,aAAc3sB,EACVwsB,EACAvN,EAAKnK,MAAM6X,aAAeH,GAEhCrX,IAAKlE,OAAOwR,OAAO,GAAIxD,EAAK9J,MAE9B8J,EAAK9J,IAAMlE,OAAOwR,OAAO,GAAIsE,EAAMjS,OAE/BmK,EAAKnK,MAAM+T,SAAW5J,EAAK9J,IAAI0T,OACjC5X,OAAOwR,OAAOxD,EAAM8H,IAEpBe,EAAO3D,OACLsG,EACA,EACA,CAAC,QAAS1D,EAAO2D,GACjB,CAAC,OAAQ3D,EAAO2D,IAElBD,GAAc,GAIlBA,IAIJ,OAAO3C,EC1MF,SAASgE,GAAWhH,EAAYgD,EAAQ4C,GAE7C,MAAM/J,EAAS,GACf,IAAI3gB,GAAS,EAEb,OAASA,EAAQ8kB,EAAWzlB,QAAQ,CAClC,MAAMgkB,EAAUyB,EAAW9kB,GAAO8rB,WAE9BzI,IAAY1C,EAAOtB,SAASgE,KAC9ByE,EAASzE,EAAQyE,EAAQ4C,GACzB/J,EAAO/K,KAAKyN,IAIhB,OAAOyE,ECeF,SAAS8E,GAAgBjG,EAAQkG,EAAYrI,GAElD,IAAIlJ,EAAQrK,OAAOwR,OACjB+B,EACIvT,OAAOwR,OAAO,GAAI+B,GAClB,CACEzP,KAAM,EACNL,OAAQ,EACRmU,OAAQ,GAEd,CACE6D,OAAQ,EACRC,cAAe,IAKnB,MAAMG,EAAc,GAGdC,EAAuB,GAG7B,IAAIT,EAAS,GAGTzQ,EAAQ,GAGRmR,GAAW,EAOf,MAAM/G,EAAU,CACdK,QA2IF,SAAiBnJ,GACXuI,EAAmBvI,IACrB7B,EAAMvG,OACNuG,EAAM5G,OAAS,EACf4G,EAAMuN,SAAoB,IAAV1L,EAAc,EAAI,EAClC8P,MACmB,IAAV9P,IACT7B,EAAM5G,SACN4G,EAAMuN,UAGJvN,EAAMqR,aAAe,EACvBrR,EAAMoR,UAENpR,EAAMqR,eAIFrR,EAAMqR,eAAiBL,EAAOhR,EAAMoR,QAAQrtB,SAC9Cic,EAAMqR,cAAgB,EACtBrR,EAAMoR,WAIVhC,EAAQ5D,SAAW3J,EAEnB6P,GAAW,GApKX5G,MAwKF,SAAehQ,EAAM8W,GAGnB,MAAMnG,EAAQmG,GAAU,GAKxB,OAJAnG,EAAM3Q,KAAOA,EACb2Q,EAAMjS,MAAQ8T,IACd8B,EAAQ5C,OAAOlS,KAAK,CAAC,QAASmR,EAAO2D,IACrC7O,EAAMjG,KAAKmR,GACJA,GA/KPR,KAmLF,SAAcnQ,GACZ,MAAM2Q,EAAQlL,EAAM0E,MAGpB,OAFAwG,EAAM5R,IAAMyT,IACZ8B,EAAQ5C,OAAOlS,KAAK,CAAC,OAAQmR,EAAO2D,IAC7B3D,GAtLPL,QAASyG,GA8LX,SAA+BC,EAAW1N,GACxC2N,EAAUD,EAAW1N,EAAK8E,SA9L1B+D,MAAO4E,EAAiBG,GACxBjF,UAAW8E,EAAiBG,EAAmB,CAC7CjF,WAAW,KASTqC,EAAU,CACd5D,SAAU,KACV3J,KAAM,KACNoK,eAAgB,GAChBO,OAAQ,GACRnB,SACA0C,cACAoC,eA6CF,SAAwB1E,EAAOwG,GAC7B,OAsYJ,SAAyBjB,EAAQiB,GAC/B,IAAIvtB,GAAS,EAGb,MAAMyd,EAAS,GAGf,IAAI+P,EAEJ,OAASxtB,EAAQssB,EAAOjtB,QAAQ,CAC9B,MAAMotB,EAAQH,EAAOtsB,GAGrB,IAAIyC,EAEJ,GAAqB,kBAAVgqB,EACThqB,EAAQgqB,OAER,OAAQA,GACN,KAAM,EACJhqB,EAAQ,KACR,MAGF,KAAM,EACJA,EAAQ,KACR,MAGF,KAAM,EACJA,EAAQ,OACR,MAGF,KAAM,EACJA,EAAQ8qB,EAAa,IAAM,KAC3B,MAGF,KAAM,EACJ,IAAKA,GAAcC,EAAO,SAC1B/qB,EAAQ,IACR,MAGF,QAEEA,EAAQyG,OAAO6c,aAAa0G,GAIlCe,GAAmB,IAAXf,EACRhP,EAAO7H,KAAKnT,GAGd,OAAOgb,EAAOrU,KAAK,IA7bVqkB,CAAgBpE,EAAYtC,GAAQwG,IA7C3C3E,MACAU,WA0DF,SAAoB7mB,GAClBqqB,EAAYrqB,EAAMsS,MAAQtS,EAAMiS,OAChCuY,KA3DA1D,MAwBF,SAAe1pB,GAIb,GAHAysB,EAAS1W,EAAK0W,EAAQzsB,GACtB0D,IAEkC,OAA9B+oB,EAAOA,EAAOjtB,OAAS,GACzB,MAAO,GAMT,OAHAguB,EAAUR,EAAY,GAEtBnC,EAAQ5C,OAASgE,GAAWiB,EAAsBrC,EAAQ5C,OAAQ4C,GAC3DA,EAAQ5C,SA3BjB,IAOI4F,EAPAC,EAAQd,EAAWrG,SAAS7T,KAAK+X,EAASzE,GAa9C,OAJI4G,EAAWf,YACbiB,EAAqBnX,KAAKiX,GAGrBnC,EA0BP,SAASrB,EAAYtC,GACnB,OA6VJ,SAAqBuF,EAAQvF,GAC3B,MAAM6G,EAAa7G,EAAMjS,MAAM4X,OACzBmB,EAAmB9G,EAAMjS,MAAM6X,aAC/BmB,EAAW/G,EAAM5R,IAAIuX,OACrBqB,EAAiBhH,EAAM5R,IAAIwX,aAGjC,IAAIqB,EAEAJ,IAAeE,EAEjBE,EAAO,CAAC1B,EAAOsB,GAAY/tB,MAAMguB,EAAkBE,KAEnDC,EAAO1B,EAAOzsB,MAAM+tB,EAAYE,GAE5BD,GAAoB,IAEtBG,EAAK,GAAKA,EAAK,GAAGnuB,MAAMguB,IAGtBE,EAAiB,GAEnBC,EAAKpY,KAAK0W,EAAOwB,GAAUjuB,MAAM,EAAGkuB,KAIxC,OAAOC,EAvXEC,CAAY3B,EAAQvF,GAI7B,SAAS6B,IACP,OAAO3X,OAAOwR,OAAO,GAAInH,GAsB3B,SAAS/X,IAEP,IAAI2qB,EAEJ,KAAO5S,EAAMoR,OAASJ,EAAOjtB,QAAQ,CACnC,MAAMotB,EAAQH,EAAOhR,EAAMoR,QAE3B,GAAqB,kBAAVD,EAOT,IANAyB,EAAa5S,EAAMoR,OAEfpR,EAAMqR,aAAe,IACvBrR,EAAMqR,aAAe,GAIrBrR,EAAMoR,SAAWwB,GACjB5S,EAAMqR,aAAeF,EAAMptB,QAE3B8uB,EAAG1B,EAAM/P,WAAWpB,EAAMqR,oBAG5BwB,EAAG1B,IAWT,SAAS0B,EAAGhR,GACV6P,OAAWttB,EACXguB,EAAevQ,EACfwQ,EAAQA,EAAMxQ,GAmEhB,SAASmQ,EAAkBrqB,EAAGyc,GAC5BA,EAAK0O,UASP,SAASjB,EAAiBkB,EAAUnB,GAClC,OAWA,SAAcpI,EAAYwJ,EAAaC,GAErC,IAAIC,EAGAC,EAGAvG,EAGAxI,EACJ,OAAOvW,MAAMsJ,QAAQqS,GAEjB4J,EAAuB5J,GACvB,aAAcA,EACd4J,EAAuB,CAAC5J,IAS5B,SAA+B/kB,GAC7B,OAAO+U,EAGP,SAASA,EAAMqI,GACb,MAAMwR,EAAe,OAATxR,GAAiBpd,EAAIod,GAC3BwH,EAAe,OAATxH,GAAiBpd,EAAI6pB,KAQjC,OAAO8E,EAPM,IAIPvlB,MAAMsJ,QAAQkc,GAAOA,EAAMA,EAAM,CAACA,GAAO,MACzCxlB,MAAMsJ,QAAQkS,GAAOA,EAAMA,EAAM,CAACA,GAAO,IAExC+J,CAA6BvR,IAtBpCyR,CAAsB9J,GAgC1B,SAAS4J,EAAuBtK,GAI9B,OAHAoK,EAAmBpK,EACnBqK,EAAiB,EAEG,IAAhBrK,EAAK/kB,OACAkvB,EAGFM,EAAgBzK,EAAKqK,IAS9B,SAASI,EAAgBzB,GACvB,OAGA,SAAejQ,GAKbuC,EA4ER,WACE,MAAMoP,EAAalG,IACbmG,EAAgBrE,EAAQ5D,SACxBkI,EAAwBtE,EAAQxC,iBAChC+G,EAAmBvE,EAAQ5C,OAAOzoB,OAClC6vB,EAAa/lB,MAAMqb,KAAK3I,GAC9B,MAAO,CACLuS,UACA5J,KAAMyK,GAQR,SAASb,IACP9S,EAAQwT,EACRpE,EAAQ5D,SAAWiI,EACnBrE,EAAQxC,iBAAmB8G,EAC3BtE,EAAQ5C,OAAOzoB,OAAS4vB,EACxBpT,EAAQqT,EACRjC,KAlGWkC,GACPjH,EAAmBkF,EAEdA,EAAUtD,UACbY,EAAQxC,iBAAmBkF,GAG7B,GACEA,EAAUh0B,MACVsxB,EAAQ/D,OAAO7B,WAAW6E,QAAQC,KAAKvK,SAAS+N,EAAUh0B,MAE1D,OAAOqwB,EAAItM,GAGb,OAAOiQ,EAAU5G,SAAS7T,KAIxBua,EAASjc,OAAOwR,OAAOxR,OAAOme,OAAO1E,GAAUwC,GAAUxC,EACzDzE,EACAC,EACAuD,EAPK2D,CAQLjQ,IAKN,SAAS+I,EAAG/I,GAGV,OAFA6P,GAAW,EACXqB,EAASnG,EAAkBxI,GACpB4O,EAIT,SAAS7E,EAAItM,GAIX,OAHA6P,GAAW,EACXtN,EAAK0O,YAECK,EAAiBD,EAAiBnvB,OAC/BwvB,EAAgBL,EAAiBC,IAGnCF,IAUb,SAASlB,EAAUD,EAAW5I,GACxB4I,EAAUtB,aAAeiB,EAAqB1N,SAAS+N,IACzDL,EAAqBnX,KAAKwX,GAGxBA,EAAU/J,SACZc,EACEuG,EAAQ5C,OACRtD,EACAkG,EAAQ5C,OAAOzoB,OAASmlB,EACxB4I,EAAU/J,QAAQqH,EAAQ5C,OAAOjoB,MAAM2kB,GAAOkG,IAI9C0C,EAAUiC,YACZ3E,EAAQ5C,OAASsF,EAAUiC,UAAU3E,EAAQ5C,OAAQ4C,IAyCzD,SAASuC,IACH3R,EAAMvG,QAAQ+X,GAAexR,EAAM5G,OAAS,IAC9C4G,EAAM5G,OAASoY,EAAYxR,EAAMvG,MACjCuG,EAAMuN,QAAUiE,EAAYxR,EAAMvG,MAAQ,IChezC,MAAMua,GAAgB,CAC3Bl2B,KAAM,gBACNotB,SAIF,SAA+BP,EAASC,EAAIuD,GAC1C,IAGI8F,EAHAhtB,EAAO,EAIX,OAGA,SAAe4a,GAGb,OAFA8I,EAAQG,MAAM,iBACdmJ,EAASpS,EACFgP,EAAQhP,IAIjB,SAASgP,EAAQhP,GACf,OAAIA,IAASoS,GACXtJ,EAAQG,MAAM,yBACPoJ,EAASrS,IAGdwI,EAAcxI,GACT6I,GAAaC,EAASkG,EAAS,aAA/BnG,CAA6C7I,GAGlD5a,EAAO,GAAe,OAAT4a,IAAkBuI,EAAmBvI,GAC7CsM,EAAItM,IAGb8I,EAAQM,KAAK,iBACNL,EAAG/I,IAIZ,SAASqS,EAASrS,GAChB,OAAIA,IAASoS,GACXtJ,EAAQK,QAAQnJ,GAChB5a,IACOitB,IAGTvJ,EAAQM,KAAK,yBACN4F,EAAQhP,OCvCZ,MAAMiH,GAAO,CAClBhrB,KAAM,OACNotB,SAuBF,SAA2BP,EAASC,EAAIuD,GACtC,MAAMxC,EAAO9b,KACPqgB,EAAOvE,EAAKa,OAAOb,EAAKa,OAAOzoB,OAAS,GAC9C,IAAIowB,EACFjE,GAAyB,eAAjBA,EAAK,GAAGpV,KACZoV,EAAK,GAAGC,eAAeD,EAAK,IAAI,GAAMnsB,OACtC,EACFkD,EAAO,EACX,OAGA,SAAe4a,GACb,MAAMuS,EACJzI,EAAKM,eAAenR,OACV,KAAT+G,GAAwB,KAATA,GAAwB,KAATA,EAC3B,gBACA,eAEN,GACW,kBAATuS,GACKzI,EAAKM,eAAegI,QAAUpS,IAAS8J,EAAKM,eAAegI,OAC5DpK,EAAWhI,GACf,CAQA,GAPK8J,EAAKM,eAAenR,OACvB6Q,EAAKM,eAAenR,KAAOsZ,EAC3BzJ,EAAQG,MAAMsJ,EAAM,CAClBlF,YAAY,KAIH,kBAATkF,EAEF,OADAzJ,EAAQG,MAAM,kBACE,KAATjJ,GAAwB,KAATA,EAClB8I,EAAQsC,MAAM+G,GAAe7F,EAAKkG,EAAlC1J,CAA4C9I,GAC5CwS,EAASxS,GAGf,IAAK8J,EAAKoB,WAAsB,KAATlL,EAGrB,OAFA8I,EAAQG,MAAM,kBACdH,EAAQG,MAAM,iBACPwJ,EAAOzS,GAIlB,OAAOsM,EAAItM,IAIb,SAASyS,EAAOzS,GACd,OAAIgI,EAAWhI,MAAW5a,EAAO,IAC/B0jB,EAAQK,QAAQnJ,GACTyS,KAIL3I,EAAKoB,WAAa9lB,EAAO,KAC1B0kB,EAAKM,eAAegI,OACjBpS,IAAS8J,EAAKM,eAAegI,OACpB,KAATpS,GAAwB,KAATA,IAEnB8I,EAAQM,KAAK,iBACNoJ,EAASxS,IAGXsM,EAAItM,GAMb,SAASwS,EAASxS,GAKhB,OAJA8I,EAAQG,MAAM,kBACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,kBACbU,EAAKM,eAAegI,OAAStI,EAAKM,eAAegI,QAAUpS,EACpD8I,EAAQsC,MACbsB,GACA5C,EAAKoB,UAAYoB,EAAMoG,EACvB5J,EAAQS,QACNoJ,GACAC,EACAC,IAMN,SAASH,EAAQ1S,GAGf,OAFA8J,EAAKM,eAAe0I,kBAAmB,EACvCR,IACOM,EAAY5S,GAIrB,SAAS6S,EAAY7S,GACnB,OAAIwI,EAAcxI,IAChB8I,EAAQG,MAAM,4BACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,4BACNwJ,GAGFtG,EAAItM,GAIb,SAAS4S,EAAY5S,GAInB,OAHA8J,EAAKM,eAAehlB,KAClBktB,EACAxI,EAAKwE,eAAexF,EAAQM,KAAK,mBAAmB,GAAMlnB,OACrD6mB,EAAG/I,KApIZqK,aAAc,CACZhB,SA2IJ,SAAkCP,EAASC,EAAIuD,GAC7C,MAAMxC,EAAO9b,KAEb,OADA8b,EAAKM,eAAeI,gBAAajoB,EAC1BumB,EAAQsC,MAAMsB,GAAWgG,EAASK,GAGzC,SAASL,EAAQ1S,GAMf,OALA8J,EAAKM,eAAe4I,kBAClBlJ,EAAKM,eAAe4I,mBACpBlJ,EAAKM,eAAe0I,iBAGfjK,GACLC,EACAC,EACA,iBACAe,EAAKM,eAAehlB,KAAO,EAJtByjB,CAKL7I,GAIJ,SAAS+S,EAAS/S,GAChB,OAAI8J,EAAKM,eAAe4I,oBAAsBxK,EAAcxI,IAC1D8J,EAAKM,eAAe4I,uBAAoBzwB,EACxCunB,EAAKM,eAAe0I,sBAAmBvwB,EAChC0wB,EAAiBjT,KAG1B8J,EAAKM,eAAe4I,uBAAoBzwB,EACxCunB,EAAKM,eAAe0I,sBAAmBvwB,EAChCumB,EAAQS,QAAQ2J,GAAiBnK,EAAIkK,EAArCnK,CAAuD9I,IAIhE,SAASiT,EAAiBjT,GAKxB,OAHA8J,EAAKM,eAAeI,YAAa,EAEjCV,EAAKoB,eAAY3oB,EACVsmB,GACLC,EACAA,EAAQS,QAAQtC,GAAM8B,EAAIuD,GAC1B,aACAxC,EAAKN,OAAO7B,WAAW6E,QAAQC,KAAKvK,SAAS,qBACzC3f,EACA,EANCsmB,CAOL7I,MAvLJoJ,KAuNF,SAAyBN,GACvBA,EAAQM,KAAKpb,KAAKoc,eAAenR,QApN7B0Z,GAAoC,CACxCtJ,SA0NF,SAA0CP,EAASC,EAAIuD,GACrD,MAAMxC,EAAO9b,KACb,OAAO6a,GACLC,GASF,SAAqB9I,GACnB,MAAMqO,EAAOvE,EAAKa,OAAOb,EAAKa,OAAOzoB,OAAS,GAC9C,OAAQsmB,EAAcxI,IACpBqO,GACiB,6BAAjBA,EAAK,GAAGpV,KACN8P,EAAG/I,GACHsM,EAAItM,KAbR,2BACA8J,EAAKN,OAAO7B,WAAW6E,QAAQC,KAAKvK,SAAS,qBACzC3f,EACA,IAjONoqB,SAAS,GAILuG,GAAkB,CACtB7J,SAoLF,SAAwBP,EAASC,EAAIuD,GACnC,MAAMxC,EAAO9b,KACb,OAAO6a,GACLC,GAOF,SAAqB9I,GACnB,MAAMqO,EAAOvE,EAAKa,OAAOb,EAAKa,OAAOzoB,OAAS,GAC9C,OAAOmsB,GACY,mBAAjBA,EAAK,GAAGpV,MACRoV,EAAK,GAAGC,eAAeD,EAAK,IAAI,GAAMnsB,SAAW4nB,EAAKM,eAAehlB,KACnE2jB,EAAG/I,GACHsM,EAAItM,KAXR,iBACA8J,EAAKM,eAAehlB,KAAO,IAzL7BunB,SAAS,GC3BJ,MAAMwG,GAAa,CACxBl3B,KAAM,aACNotB,SAQF,SAAiCP,EAASC,EAAIuD,GAC5C,MAAMxC,EAAO9b,KACb,OAGA,SAAegS,GACb,GAAa,KAATA,EAAa,CACf,MAAMwQ,EAAQ1G,EAAKM,eAanB,OAXKoG,EAAM4C,OACTtK,EAAQG,MAAM,aAAc,CAC1BoE,YAAY,IAEdmD,EAAM4C,MAAO,GAGftK,EAAQG,MAAM,oBACdH,EAAQG,MAAM,oBACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,oBACNiK,EAGT,OAAO/G,EAAItM,IAIb,SAASqT,EAAMrT,GACb,OAAIwI,EAAcxI,IAChB8I,EAAQG,MAAM,8BACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,8BACbN,EAAQM,KAAK,oBACNL,IAGTD,EAAQM,KAAK,oBACNL,EAAG/I,MA5CZqK,aAAc,CACZhB,SAgDJ,SAAwCP,EAASC,EAAIuD,GACnD,OAAOzD,GACLC,EACAA,EAAQS,QAAQ4J,GAAYpK,EAAIuD,GAChC,aACAte,KAAKwb,OAAO7B,WAAW6E,QAAQC,KAAKvK,SAAS,qBAAkB3f,EAAY,KAnD7E6mB,KAwDF,SAAcN,GACZA,EAAQM,KAAK,gBClDR,SAASkK,GACdxK,EACAC,EACAuD,EACArT,EACAsa,EACAC,EACAC,EACAC,EACA/xB,GAEA,MAAMqnB,EAAQrnB,GAAOoP,OAAOkU,kBAC5B,IAAI0O,EAAU,EACd,OAGA,SAAe3T,GACb,GAAa,KAATA,EAMF,OALA8I,EAAQG,MAAMhQ,GACd6P,EAAQG,MAAMsK,GACdzK,EAAQG,MAAMuK,GACd1K,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAKoK,GACNI,EAGT,GAAa,OAAT5T,GAA0B,KAATA,GAAeqI,EAAarI,GAC/C,OAAOsM,EAAItM,GASb,OANA8I,EAAQG,MAAMhQ,GACd6P,EAAQG,MAAMwK,GACd3K,EAAQG,MAAMyK,GACd5K,EAAQG,MAAM,cAAe,CAC3BY,YAAa,WAERgK,EAAe7T,IAIxB,SAAS4T,EAA0B5T,GACjC,OAAa,KAATA,GACF8I,EAAQG,MAAMuK,GACd1K,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAKoK,GACb1K,EAAQM,KAAKmK,GACbzK,EAAQM,KAAKnQ,GACN8P,IAGTD,EAAQG,MAAMyK,GACd5K,EAAQG,MAAM,cAAe,CAC3BY,YAAa,WAERiK,EAAoB9T,IAI7B,SAAS8T,EAAoB9T,GAC3B,OAAa,KAATA,GACF8I,EAAQM,KAAK,eACbN,EAAQM,KAAKsK,GACNE,EAA0B5T,IAGtB,OAATA,GAA0B,KAATA,GAAeuI,EAAmBvI,GAC9CsM,EAAItM,IAGb8I,EAAQK,QAAQnJ,GACA,KAATA,EAAc+T,EAA4BD,GAInD,SAASC,EAA0B/T,GACjC,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAChC8I,EAAQK,QAAQnJ,GACT8T,GAGFA,EAAoB9T,GAI7B,SAAS6T,EAAe7T,GACtB,OAAa,KAATA,IACI2T,EAAU3K,EAAcsD,EAAItM,IAClC8I,EAAQK,QAAQnJ,GACT6T,GAGI,KAAT7T,EACG2T,KAQL7K,EAAQK,QAAQnJ,GACT6T,IARL/K,EAAQM,KAAK,eACbN,EAAQM,KAAKsK,GACb5K,EAAQM,KAAKqK,GACb3K,EAAQM,KAAKnQ,GACN8P,EAAG/I,IAOD,OAATA,GAAiBsI,EAA0BtI,GACzC2T,EAAgBrH,EAAItM,IACxB8I,EAAQM,KAAK,eACbN,EAAQM,KAAKsK,GACb5K,EAAQM,KAAKqK,GACb3K,EAAQM,KAAKnQ,GACN8P,EAAG/I,IAGRqI,EAAarI,GAAcsM,EAAItM,IACnC8I,EAAQK,QAAQnJ,GACA,KAATA,EAAcgU,EAAuBH,GAI9C,SAASG,EAAqBhU,GAC5B,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAChC8I,EAAQK,QAAQnJ,GACT6T,GAGFA,EAAe7T,IClInB,SAASiU,GAAanL,EAASC,EAAIuD,EAAKrT,EAAMib,EAAYR,GAC/D,MAAM5J,EAAO9b,KACb,IAGI8T,EAHA1c,EAAO,EAIX,OAGA,SAAe4a,GAMb,OALA8I,EAAQG,MAAMhQ,GACd6P,EAAQG,MAAMiL,GACdpL,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK8K,GACbpL,EAAQG,MAAMyK,GACP1E,GAIT,SAASA,EAAQhP,GACf,OACW,OAATA,GACS,KAATA,GACU,KAATA,IAAgB8B,GAQP,KAAT9B,IACE5a,GACD,2BAA4B0kB,EAAKN,OAAO7B,YAC1CviB,EAAO,IAEAknB,EAAItM,GAGA,KAATA,GACF8I,EAAQM,KAAKsK,GACb5K,EAAQG,MAAMiL,GACdpL,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK8K,GACbpL,EAAQM,KAAKnQ,GACN8P,GAGLR,EAAmBvI,IACrB8I,EAAQG,MAAM,cACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,cACN4F,IAGTlG,EAAQG,MAAM,cAAe,CAC3BY,YAAa,WAERrhB,EAAMwX,IAIf,SAASxX,EAAMwX,GACb,OACW,OAATA,GACS,KAATA,GACS,KAATA,GACAuI,EAAmBvI,IACnB5a,IAAS,KAET0jB,EAAQM,KAAK,eACN4F,EAAQhP,KAGjB8I,EAAQK,QAAQnJ,GAChB8B,EAAOA,IAAS0G,EAAcxI,GACd,KAATA,EAAcmU,EAAc3rB,GAIrC,SAAS2rB,EAAYnU,GACnB,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAChC8I,EAAQK,QAAQnJ,GAChB5a,IACOoD,GAGFA,EAAMwX,ICvFV,SAASoU,GAAatL,EAASC,EAAIuD,EAAKrT,EAAMib,EAAYR,GAE/D,IAAItB,EACJ,OAGA,SAAepS,GAMb,OALA8I,EAAQG,MAAMhQ,GACd6P,EAAQG,MAAMiL,GACdpL,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK8K,GACb9B,EAAkB,KAATpS,EAAc,GAAKA,EACrBqU,GAIT,SAASA,EAAkBrU,GACzB,OAAIA,IAASoS,GACXtJ,EAAQG,MAAMiL,GACdpL,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK8K,GACbpL,EAAQM,KAAKnQ,GACN8P,IAGTD,EAAQG,MAAMyK,GACPY,EAAatU,IAItB,SAASsU,EAAatU,GACpB,OAAIA,IAASoS,GACXtJ,EAAQM,KAAKsK,GACNW,EAAkBjC,IAGd,OAATpS,EACKsM,EAAItM,GAGTuI,EAAmBvI,IACrB8I,EAAQG,MAAM,cACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,cACNP,GAAaC,EAASwL,EAAc,gBAG7CxL,EAAQG,MAAM,cAAe,CAC3BY,YAAa,WAER0K,EAAMvU,IAIf,SAASuU,EAAMvU,GACb,OAAIA,IAASoS,GAAmB,OAATpS,GAAiBuI,EAAmBvI,IACzD8I,EAAQM,KAAK,eACNkL,EAAatU,KAGtB8I,EAAQK,QAAQnJ,GACA,KAATA,EAAcwU,EAAcD,GAIrC,SAASC,EAAYxU,GACnB,OAAIA,IAASoS,GAAmB,KAATpS,GACrB8I,EAAQK,QAAQnJ,GACTuU,GAGFA,EAAMvU,IC9EV,SAASyU,GAAkB3L,EAASC,GAEzC,IAAIsD,EACJ,OAGA,SAAS1U,EAAMqI,GACb,GAAIuI,EAAmBvI,GAKrB,OAJA8I,EAAQG,MAAM,cACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,cACbiD,GAAO,EACA1U,EAGT,GAAI6Q,EAAcxI,GAChB,OAAO6I,GACLC,EACAnR,EACA0U,EAAO,aAAe,aAHjBxD,CAIL7I,GAGJ,OAAO+I,EAAG/I,IC5BP,SAAS0U,GAAoBpvB,GAClC,OACEA,EACG6H,QAAQ,cAAe,KACvBA,QAAQ,SAAU,IAMlBD,cACAynB,cCAA,MAAMC,GAAa,CACxB34B,KAAM,aACNotB,SAUF,SAA4BP,EAASC,EAAIuD,GACvC,MAAMxC,EAAO9b,KAGb,IAAI6mB,EACJ,OAGA,SAAe7U,GAEb,OADA8I,EAAQG,MAAM,cACPgL,GAAaze,KAClBsU,EACAhB,EACAgM,EACAxI,EACA,kBACA,wBACA,wBAPK2H,CAQLjU,IAIJ,SAAS8U,EAAW9U,GAKlB,OAJA6U,EAAaH,GACX5K,EAAKwE,eAAexE,EAAKa,OAAOb,EAAKa,OAAOzoB,OAAS,GAAG,IAAIQ,MAAM,GAAI,IAG3D,KAATsd,GACF8I,EAAQG,MAAM,oBACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,oBAENqL,GACL3L,EACAwK,GACExK,EACAA,EAAQS,QACNwL,GACAlM,GAAaC,EAASuK,EAAO,cAC7BxK,GAAaC,EAASuK,EAAO,eAE/B/G,EACA,wBACA,+BACA,qCACA,2BACA,iCAKCA,EAAItM,GAIb,SAASqT,EAAMrT,GACb,OAAa,OAATA,GAAiBuI,EAAmBvI,IACtC8I,EAAQM,KAAK,cAERU,EAAKN,OAAOwL,QAAQ9S,SAAS2S,IAChC/K,EAAKN,OAAOwL,QAAQvc,KAAKoc,GAGpB9L,EAAG/I,IAGLsM,EAAItM,MAxET+U,GAAiB,CACrB1L,SA4EF,SAAuBP,EAASC,EAAIuD,GAClC,OAGA,SAAetM,GACb,OAAOsI,EAA0BtI,GAC7ByU,GAAkB3L,EAASjB,EAA3B4M,CAAmCzU,GACnCsM,EAAItM,IAIV,SAAS6H,EAAO7H,GACd,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,EACzBoU,GACLtL,EACAD,GAAaC,EAASuK,EAAO,cAC7B/G,EACA,kBACA,wBACA,wBANK8H,CAOLpU,GAGGsM,EAAItM,GAIb,SAASqT,EAAMrT,GACb,OAAgB,OAATA,GAAiBuI,EAAmBvI,GAAQ+I,EAAG/I,GAAQsM,EAAItM,KAvGpE2M,SAAS,GCdJ,MAAMsI,GAAe,CAC1Bh5B,KAAM,eACNotB,SAUF,SAA8BP,EAASC,EAAIuD,GACzC,MAAMxC,EAAO9b,KACb,OAGA,SAAegS,GAEb,OADA8I,EAAQG,MAAM,gBACPJ,GAAaC,EAASoM,EAAkB,aAAc,EAAtDrM,CAA6D7I,IAItE,SAASkV,EAAiBlV,GACxB,MAAMqO,EAAOvE,EAAKa,OAAOb,EAAKa,OAAOzoB,OAAS,GAC9C,OAAOmsB,GACY,eAAjBA,EAAK,GAAGpV,MACRoV,EAAK,GAAGC,eAAeD,EAAK,IAAI,GAAMnsB,QAAU,EAC9CizB,EAAYnV,GACZsM,EAAItM,GAIV,SAASmV,EAAYnV,GACnB,OAAa,OAATA,EACKqT,EAAMrT,GAGXuI,EAAmBvI,GACd8I,EAAQS,QAAQ6L,GAAiBD,EAAa9B,EAA9CvK,CAAqD9I,IAG9D8I,EAAQG,MAAM,iBACPziB,EAAQwZ,IAIjB,SAASxZ,EAAQwZ,GACf,OAAa,OAATA,GAAiBuI,EAAmBvI,IACtC8I,EAAQM,KAAK,iBACN+L,EAAYnV,KAGrB8I,EAAQK,QAAQnJ,GACTxZ,GAIT,SAAS6sB,EAAMrT,GAEb,OADA8I,EAAQM,KAAK,gBACNL,EAAG/I,MAtDRoV,GAAkB,CACtB/L,SA0DF,SAAiCP,EAASC,EAAIuD,GAC5C,MAAMxC,EAAO9b,KACb,OAAO2J,EAGP,SAASA,EAAMqI,GAEb,OAAI8J,EAAKN,OAAOgC,KAAK1B,EAAK2B,MAAM7T,MACvB0U,EAAItM,GAGTuI,EAAmBvI,IACrB8I,EAAQG,MAAM,cACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,cACNzR,GAGFkR,GAAaC,EAASqM,EAAa,aAAc,EAAjDtM,CAAwD7I,GAIjE,SAASmV,EAAYnV,GACnB,MAAMqO,EAAOvE,EAAKa,OAAOb,EAAKa,OAAOzoB,OAAS,GAC9C,OAAOmsB,GACY,eAAjBA,EAAK,GAAGpV,MACRoV,EAAK,GAAGC,eAAeD,EAAK,IAAI,GAAMnsB,QAAU,EAC9C6mB,EAAG/I,GACHuI,EAAmBvI,GACnBrI,EAAMqI,GACNsM,EAAItM,KAvFV2M,SAAS,GCHJ,MAAM0I,GAAa,CACxBp5B,KAAM,aACNotB,SA4DF,SAA4BP,EAASC,EAAIuD,GACvC,MAAMxC,EAAO9b,KACb,IAAI5I,EAAO,EACX,OAGA,SAAe4a,GAGb,OAFA8I,EAAQG,MAAM,cACdH,EAAQG,MAAM,sBACPqM,EAAgBtV,IAIzB,SAASsV,EAAgBtV,GACvB,OAAa,KAATA,GAAe5a,IAAS,GAC1B0jB,EAAQK,QAAQnJ,GACTsV,GAGI,OAATtV,GAAiBsI,EAA0BtI,IAC7C8I,EAAQM,KAAK,sBACNU,EAAKoB,UAAYnC,EAAG/I,GAAQuV,EAAavV,IAG3CsM,EAAItM,GAIb,SAASuV,EAAavV,GACpB,OAAa,KAATA,GACF8I,EAAQG,MAAM,sBACPoJ,EAASrS,IAGL,OAATA,GAAiBuI,EAAmBvI,IACtC8I,EAAQM,KAAK,cACNL,EAAG/I,IAGRwI,EAAcxI,GACT6I,GAAaC,EAASyM,EAAc,aAApC1M,CAAkD7I,IAG3D8I,EAAQG,MAAM,kBACPnH,EAAK9B,IAId,SAASqS,EAASrS,GAChB,OAAa,KAATA,GACF8I,EAAQK,QAAQnJ,GACTqS,IAGTvJ,EAAQM,KAAK,sBACNmM,EAAavV,IAItB,SAAS8B,EAAK9B,GACZ,OAAa,OAATA,GAA0B,KAATA,GAAesI,EAA0BtI,IAC5D8I,EAAQM,KAAK,kBACNmM,EAAavV,KAGtB8I,EAAQK,QAAQnJ,GACT8B,KA7HToE,QAIF,SAA2ByE,EAAQ4C,GACjC,IAII/mB,EAGAgD,EAPAykB,EAAatD,EAAOzoB,OAAS,EAC7BonB,EAAe,EAQkB,eAAjCqB,EAAOrB,GAAc,GAAGrQ,OAC1BqQ,GAAgB,GAIhB2E,EAAa,EAAI3E,GACc,eAA/BqB,EAAOsD,GAAY,GAAGhV,OAEtBgV,GAAc,GAIiB,uBAA/BtD,EAAOsD,GAAY,GAAGhV,OACrBqQ,IAAiB2E,EAAa,GAC5BA,EAAa,EAAI3E,GACmB,eAAnCqB,EAAOsD,EAAa,GAAG,GAAGhV,QAE9BgV,GAAc3E,EAAe,IAAM2E,EAAa,EAAI,GAGlDA,EAAa3E,IACf9iB,EAAU,CACRyS,KAAM,iBACNtB,MAAOgT,EAAOrB,GAAc,GAAG3R,MAC/BK,IAAK2S,EAAOsD,GAAY,GAAGjW,KAE7BxO,EAAO,CACLyP,KAAM,YACNtB,MAAOgT,EAAOrB,GAAc,GAAG3R,MAC/BK,IAAK2S,EAAOsD,GAAY,GAAGjW,IAE3B6R,YAAa,QAEf7C,EAAO2D,EAAQrB,EAAc2E,EAAa3E,EAAe,EAAG,CAC1D,CAAC,QAAS9iB,EAAS+mB,GACnB,CAAC,QAAS/jB,EAAM+jB,GAChB,CAAC,OAAQ/jB,EAAM+jB,GACf,CAAC,OAAQ/mB,EAAS+mB,MAItB,OAAO5C,IC/DF,MAAM6K,GAAkB,CAC7Bv5B,KAAM,kBACNotB,SA+DF,SAAiCP,EAASC,EAAIuD,GAC5C,MAAMxC,EAAO9b,KACb,IAGIokB,EAGAqD,EANA5yB,EAAQinB,EAAKa,OAAOzoB,OAQxB,KAAOW,KAGL,GACiC,eAA/BinB,EAAKa,OAAO9nB,GAAO,GAAGoW,MACS,eAA/B6Q,EAAKa,OAAO9nB,GAAO,GAAGoW,MACS,YAA/B6Q,EAAKa,OAAO9nB,GAAO,GAAGoW,KACtB,CACAwc,EAA2C,cAA/B3L,EAAKa,OAAO9nB,GAAO,GAAGoW,KAClC,MAIJ,OAGA,SAAe+G,GACb,IAAK8J,EAAKN,OAAOgC,KAAK1B,EAAK2B,MAAM7T,QAAUkS,EAAKoB,WAAauK,GAI3D,OAHA3M,EAAQG,MAAM,qBACdH,EAAQG,MAAM,6BACdmJ,EAASpS,EACF0V,EAAgB1V,GAGzB,OAAOsM,EAAItM,IAIb,SAAS0V,EAAgB1V,GACvB,OAAIA,IAASoS,GACXtJ,EAAQK,QAAQnJ,GACT0V,IAGT5M,EAAQM,KAAK,6BACNP,GAAaC,EAAS6M,EAAoB,aAA1C9M,CAAwD7I,IAIjE,SAAS2V,EAAmB3V,GAC1B,OAAa,OAATA,GAAiBuI,EAAmBvI,IACtC8I,EAAQM,KAAK,qBACNL,EAAG/I,IAGLsM,EAAItM,KArHbkS,UAIF,SAAkCvH,EAAQ4C,GACxC,IAGI/mB,EAGAgD,EAGAorB,EATA/xB,EAAQ8nB,EAAOzoB,OAYnB,KAAOW,KACL,GAAyB,UAArB8nB,EAAO9nB,GAAO,GAAgB,CAChC,GAA8B,YAA1B8nB,EAAO9nB,GAAO,GAAGoW,KAAoB,CACvCzS,EAAU3D,EACV,MAG4B,cAA1B8nB,EAAO9nB,GAAO,GAAGoW,OACnBzP,EAAO3G,OAIqB,YAA1B8nB,EAAO9nB,GAAO,GAAGoW,MAEnB0R,EAAO3D,OAAOnkB,EAAO,GAGlB+xB,GAAwC,eAA1BjK,EAAO9nB,GAAO,GAAGoW,OAClC2b,EAAa/xB,GAKnB,MAAM+yB,EAAU,CACd3c,KAAM,gBACNtB,MAAO7D,OAAOwR,OAAO,GAAIqF,EAAOnhB,GAAM,GAAGmO,OACzCK,IAAKlE,OAAOwR,OAAO,GAAIqF,EAAOA,EAAOzoB,OAAS,GAAG,GAAG8V,MAGtD2S,EAAOnhB,GAAM,GAAGyP,KAAO,oBAGnB2b,GACFjK,EAAO3D,OAAOxd,EAAM,EAAG,CAAC,QAASosB,EAASrI,IAC1C5C,EAAO3D,OAAO4N,EAAa,EAAG,EAAG,CAAC,OAAQjK,EAAOnkB,GAAS,GAAI+mB,IAC9D5C,EAAOnkB,GAAS,GAAGwR,IAAMlE,OAAOwR,OAAO,GAAIqF,EAAOiK,GAAY,GAAG5c,MAEjE2S,EAAOnkB,GAAS,GAAKovB,EAIvB,OADAjL,EAAOlS,KAAK,CAAC,OAAQmd,EAASrI,IACvB5C,IC9DF,MAAMkL,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,UACA,UACA,QACA,QACA,KACA,QACA,KACA,QACA,QACA,KACA,QACA,MAaWC,GAAe,CAAC,MAAO,SAAU,QAAS,YClE1CC,GAAW,CACtB95B,KAAM,WACNotB,SAkCF,SAA0BP,EAASC,EAAIuD,GACrC,MAAMxC,EAAO9b,KAGb,IAAIukB,EAGAyD,EAGAC,EAGApzB,EAGAuvB,EACJ,OAGA,SAAepS,GAIb,OAHA8I,EAAQG,MAAM,YACdH,EAAQG,MAAM,gBACdH,EAAQK,QAAQnJ,GACToT,GAIT,SAASA,EAAKpT,GACZ,OAAa,KAATA,GACF8I,EAAQK,QAAQnJ,GACTkW,GAGI,KAATlW,GACF8I,EAAQK,QAAQnJ,GACTmW,GAGI,KAATnW,GACF8I,EAAQK,QAAQnJ,GAChBuS,EAAO,EAGAzI,EAAKoB,UAAYnC,EAAKqN,GAG3BtO,EAAW9H,IACb8I,EAAQK,QAAQnJ,GAChBiW,EAASlqB,OAAO6c,aAAa5I,GAC7BgW,GAAW,EACJK,GAGF/J,EAAItM,GAIb,SAASkW,EAAiBlW,GACxB,OAAa,KAATA,GACF8I,EAAQK,QAAQnJ,GAChBuS,EAAO,EACA+D,GAGI,KAATtW,GACF8I,EAAQK,QAAQnJ,GAChBuS,EAAO,EACP0D,EAAS,SACTpzB,EAAQ,EACD0zB,GAGLzO,EAAW9H,IACb8I,EAAQK,QAAQnJ,GAChBuS,EAAO,EACAzI,EAAKoB,UAAYnC,EAAKqN,GAGxB9J,EAAItM,GAIb,SAASsW,EAAkBtW,GACzB,OAAa,KAATA,GACF8I,EAAQK,QAAQnJ,GACT8J,EAAKoB,UAAYnC,EAAKqN,GAGxB9J,EAAItM,GAIb,SAASuW,EAAgBvW,GACvB,OAAIA,IAASiW,EAAO1W,WAAW1c,MAC7BimB,EAAQK,QAAQnJ,GACTnd,IAAUozB,EAAO/zB,OACpB4nB,EAAKoB,UACHnC,EACAsB,EACFkM,GAGCjK,EAAItM,GAIb,SAASmW,EAAcnW,GACrB,OAAI8H,EAAW9H,IACb8I,EAAQK,QAAQnJ,GAChBiW,EAASlqB,OAAO6c,aAAa5I,GACtBqW,GAGF/J,EAAItM,GAIb,SAASqW,EAAQrW,GACf,OACW,OAATA,GACS,KAATA,GACS,KAATA,GACAsI,EAA0BtI,GAGf,KAATA,GACAgW,GACAF,GAAa5T,SAAS+T,EAAO/oB,gBAE7BqlB,EAAO,EACAzI,EAAKoB,UAAYnC,EAAG/I,GAAQqK,EAAarK,IAG9C6V,GAAe3T,SAAS+T,EAAO/oB,gBACjCqlB,EAAO,EAEM,KAATvS,GACF8I,EAAQK,QAAQnJ,GACTwW,GAGF1M,EAAKoB,UAAYnC,EAAG/I,GAAQqK,EAAarK,KAGlDuS,EAAO,EAEAzI,EAAKoB,YAAcpB,EAAKN,OAAOgC,KAAK1B,EAAK2B,MAAM7T,MAClD0U,EAAItM,GACJgW,EACAS,EAA4BzW,GAC5B0W,EAAwB1W,IAGjB,KAATA,GAAekI,EAAkBlI,IACnC8I,EAAQK,QAAQnJ,GAChBiW,GAAUlqB,OAAO6c,aAAa5I,GACvBqW,GAGF/J,EAAItM,GAIb,SAASwW,EAAiBxW,GACxB,OAAa,KAATA,GACF8I,EAAQK,QAAQnJ,GACT8J,EAAKoB,UAAYnC,EAAKsB,GAGxBiC,EAAItM,GAIb,SAAS0W,EAAwB1W,GAC/B,OAAIwI,EAAcxI,IAChB8I,EAAQK,QAAQnJ,GACT0W,GAGFC,EAAY3W,GAIrB,SAASyW,EAA4BzW,GACnC,OAAa,KAATA,GACF8I,EAAQK,QAAQnJ,GACT2W,GAGI,KAAT3W,GAAwB,KAATA,GAAe8H,EAAW9H,IAC3C8I,EAAQK,QAAQnJ,GACT4W,GAGLpO,EAAcxI,IAChB8I,EAAQK,QAAQnJ,GACTyW,GAGFE,EAAY3W,GAIrB,SAAS4W,EAAsB5W,GAC7B,OACW,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACAkI,EAAkBlI,IAElB8I,EAAQK,QAAQnJ,GACT4W,GAGFC,EAA2B7W,GAIpC,SAAS6W,EAA2B7W,GAClC,OAAa,KAATA,GACF8I,EAAQK,QAAQnJ,GACT8W,GAGLtO,EAAcxI,IAChB8I,EAAQK,QAAQnJ,GACT6W,GAGFJ,EAA4BzW,GAIrC,SAAS8W,EAA6B9W,GACpC,OACW,OAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,EAEOsM,EAAItM,GAGA,KAATA,GAAwB,KAATA,GACjB8I,EAAQK,QAAQnJ,GAChBoS,EAASpS,EACF+W,GAGLvO,EAAcxI,IAChB8I,EAAQK,QAAQnJ,GACT8W,IAGT1E,EAAS,KACF4E,EAA+BhX,IAIxC,SAAS+W,EAA6B/W,GACpC,OAAa,OAATA,GAAiBuI,EAAmBvI,GAC/BsM,EAAItM,GAGTA,IAASoS,GACXtJ,EAAQK,QAAQnJ,GACTiX,IAGTnO,EAAQK,QAAQnJ,GACT+W,GAIT,SAASC,EAA+BhX,GACtC,OACW,OAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACAsI,EAA0BtI,GAEnB6W,EAA2B7W,IAGpC8I,EAAQK,QAAQnJ,GACTgX,GAIT,SAASC,EAAkCjX,GACzC,OAAa,KAATA,GAAwB,KAATA,GAAewI,EAAcxI,GACvCyW,EAA4BzW,GAG9BsM,EAAItM,GAIb,SAAS2W,EAAY3W,GACnB,OAAa,KAATA,GACF8I,EAAQK,QAAQnJ,GACTkX,GAGF5K,EAAItM,GAIb,SAASkX,EAAclX,GACrB,OAAIwI,EAAcxI,IAChB8I,EAAQK,QAAQnJ,GACTkX,GAGO,OAATlX,GAAiBuI,EAAmBvI,GACvCqK,EAAarK,GACbsM,EAAItM,GAIV,SAASqK,EAAarK,GACpB,OAAa,KAATA,GAAwB,IAATuS,GACjBzJ,EAAQK,QAAQnJ,GACTmX,GAGI,KAATnX,GAAwB,IAATuS,GACjBzJ,EAAQK,QAAQnJ,GACToX,GAGI,KAATpX,GAAwB,IAATuS,GACjBzJ,EAAQK,QAAQnJ,GACTqX,GAGI,KAATrX,GAAwB,IAATuS,GACjBzJ,EAAQK,QAAQnJ,GACToW,GAGI,KAATpW,GAAwB,IAATuS,GACjBzJ,EAAQK,QAAQnJ,GACTsX,IAGL/O,EAAmBvI,IAAmB,IAATuS,GAAuB,IAATA,EAQlC,OAATvS,GAAiBuI,EAAmBvI,GAC/BuX,EAAyBvX,IAGlC8I,EAAQK,QAAQnJ,GACTqK,GAZEvB,EAAQsC,MACboM,GACAH,EACAE,EAHKzO,CAIL9I,GAYN,SAASuX,EAAyBvX,GAEhC,OADA8I,EAAQM,KAAK,gBACNqO,EAAkBzX,GAI3B,SAASyX,EAAkBzX,GACzB,OAAa,OAATA,EACK2D,EAAK3D,GAGVuI,EAAmBvI,GACd8I,EAAQS,QACb,CACEF,SAAUqO,EACV/K,SAAS,GAEX8K,EACA9T,EANKmF,CAOL9I,IAGJ8I,EAAQG,MAAM,gBACPoB,EAAarK,IAItB,SAAS0X,EAAY5O,EAASC,EAAIuD,GAChC,OAGA,SAAetM,GAIb,OAHA8I,EAAQG,MAAM,cACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,cACNM,GAIT,SAASA,EAAU1J,GACjB,OAAO8J,EAAKN,OAAOgC,KAAK1B,EAAK2B,MAAM7T,MAAQ0U,EAAItM,GAAQ+I,EAAG/I,IAK9D,SAASmX,EAA0BnX,GACjC,OAAa,KAATA,GACF8I,EAAQK,QAAQnJ,GACToW,GAGF/L,EAAarK,GAItB,SAASoX,EAAuBpX,GAC9B,OAAa,KAATA,GACF8I,EAAQK,QAAQnJ,GAChBiW,EAAS,GACF0B,GAGFtN,EAAarK,GAItB,SAAS2X,EAAsB3X,GAC7B,OAAa,KAATA,GAAe8V,GAAa5T,SAAS+T,EAAO/oB,gBAC9C4b,EAAQK,QAAQnJ,GACTqX,GAGLvP,EAAW9H,IAASiW,EAAO/zB,OAAS,GACtC4mB,EAAQK,QAAQnJ,GAChBiW,GAAUlqB,OAAO6c,aAAa5I,GACvB2X,GAGFtN,EAAarK,GAItB,SAASsX,EAAgCtX,GACvC,OAAa,KAATA,GACF8I,EAAQK,QAAQnJ,GACToW,GAGF/L,EAAarK,GAItB,SAASoW,EAA8BpW,GACrC,OAAa,KAATA,GACF8I,EAAQK,QAAQnJ,GACTqX,GAGI,KAATrX,GAAwB,IAATuS,GACjBzJ,EAAQK,QAAQnJ,GACToW,GAGF/L,EAAarK,GAItB,SAASqX,EAAkBrX,GACzB,OAAa,OAATA,GAAiBuI,EAAmBvI,IACtC8I,EAAQM,KAAK,gBACNzF,EAAK3D,KAGd8I,EAAQK,QAAQnJ,GACTqX,GAIT,SAAS1T,EAAK3D,GAEZ,OADA8I,EAAQM,KAAK,YACNL,EAAG/I,KA3gBZkS,UAWF,SAA2BvH,GACzB,IAAI9nB,EAAQ8nB,EAAOzoB,OAEnB,KAAOW,MACoB,UAArB8nB,EAAO9nB,GAAO,IAA4C,aAA1B8nB,EAAO9nB,GAAO,GAAGoW,QAKnDpW,EAAQ,GAAmC,eAA9B8nB,EAAO9nB,EAAQ,GAAG,GAAGoW,OAEpC0R,EAAO9nB,GAAO,GAAG8U,MAAQgT,EAAO9nB,EAAQ,GAAG,GAAG8U,MAE9CgT,EAAO9nB,EAAQ,GAAG,GAAG8U,MAAQgT,EAAO9nB,EAAQ,GAAG,GAAG8U,MAElDgT,EAAO3D,OAAOnkB,EAAQ,EAAG,IAG3B,OAAO8nB,GA5BPK,UAAU,GAINwM,GAAqB,CACzBnO,SA0gBF,SAA2BP,EAASC,EAAIuD,GACtC,OAGA,SAAetM,GAKb,OAJA8I,EAAQM,KAAK,gBACbN,EAAQG,MAAM,mBACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,mBACNN,EAAQS,QAAQmD,GAAW3D,EAAIuD,KAlhBxCK,SAAS,GCfJ,MAAMiL,GAAa,CACxB37B,KAAM,aACNotB,SAKF,SAA4BP,EAASC,EAAIuD,GACvC,MAAMxC,EAAO9b,KAGP6pB,EAAwB,CAC5BxO,SAuKF,SAA8BP,EAASC,EAAIuD,GACzC,IAAIlnB,EAAO,EACX,OAAOyjB,GACLC,EACAgP,EACA,aACA9pB,KAAKwb,OAAO7B,WAAW6E,QAAQC,KAAKvK,SAAS,qBACzC3f,EACA,GAIN,SAASu1B,EAAqB9X,GAG5B,OAFA8I,EAAQG,MAAM,mBACdH,EAAQG,MAAM,2BACPyM,EAAgB1V,GAIzB,SAAS0V,EAAgB1V,GACvB,OAAIA,IAASoS,GACXtJ,EAAQK,QAAQnJ,GAChB5a,IACOswB,GAGLtwB,EAAO2yB,EAAiBzL,EAAItM,IAChC8I,EAAQM,KAAK,2BACNP,GAAaC,EAAS6M,EAAoB,aAA1C9M,CAAwD7I,IAIjE,SAAS2V,EAAmB3V,GAC1B,OAAa,OAATA,GAAiBuI,EAAmBvI,IACtC8I,EAAQM,KAAK,mBACNL,EAAG/I,IAGLsM,EAAItM,KA5Mb2M,SAAS,GAILqL,EAAc,CAClB3O,SA8IF,SAA6BP,EAASC,EAAIuD,GACxC,MAAMxC,EAAO9b,KACb,OAAO2J,EAGP,SAASA,EAAMqI,GAIb,OAHA8I,EAAQG,MAAM,cACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,cACNM,EAIT,SAASA,EAAU1J,GACjB,OAAO8J,EAAKN,OAAOgC,KAAK1B,EAAK2B,MAAM7T,MAAQ0U,EAAItM,GAAQ+I,EAAG/I,KA3J5D2M,SAAS,GAEL0B,EAAOrgB,KAAK2c,OAAO3c,KAAK2c,OAAOzoB,OAAS,GACxC+1B,EACJ5J,GAAyB,eAAjBA,EAAK,GAAGpV,KACZoV,EAAK,GAAGC,eAAeD,EAAK,IAAI,GAAMnsB,OACtC,EACN,IAGIkwB,EAHA2F,EAAW,EAIf,OAGA,SAAe/X,GAKb,OAJA8I,EAAQG,MAAM,cACdH,EAAQG,MAAM,mBACdH,EAAQG,MAAM,2BACdmJ,EAASpS,EACFkY,EAAalY,IAItB,SAASkY,EAAalY,GACpB,OAAIA,IAASoS,GACXtJ,EAAQK,QAAQnJ,GAChB+X,IACOG,IAGTpP,EAAQM,KAAK,2BACN2O,EAAW,EACdzL,EAAItM,GACJ6I,GAAaC,EAASqP,EAAU,aAAhCtP,CAA8C7I,IAIpD,SAASmY,EAASnY,GAChB,OAAa,OAATA,GAAiBuI,EAAmBvI,GAC/BoY,EAAUpY,IAGnB8I,EAAQG,MAAM,uBACdH,EAAQG,MAAM,cAAe,CAC3BY,YAAa,WAERtH,EAAKvC,IAId,SAASuC,EAAKvC,GACZ,OAAa,OAATA,GAAiBsI,EAA0BtI,IAC7C8I,EAAQM,KAAK,eACbN,EAAQM,KAAK,uBACNP,GAAaC,EAASuP,EAAW,aAAjCxP,CAA+C7I,IAG3C,KAATA,GAAeA,IAASoS,EAAe9F,EAAItM,IAC/C8I,EAAQK,QAAQnJ,GACTuC,GAIT,SAAS8V,EAAUrY,GACjB,OAAa,OAATA,GAAiBuI,EAAmBvI,GAC/BoY,EAAUpY,IAGnB8I,EAAQG,MAAM,uBACdH,EAAQG,MAAM,cAAe,CAC3BY,YAAa,WAERyO,EAAKtY,IAId,SAASsY,EAAKtY,GACZ,OAAa,OAATA,GAAiBuI,EAAmBvI,IACtC8I,EAAQM,KAAK,eACbN,EAAQM,KAAK,uBACNgP,EAAUpY,IAGN,KAATA,GAAeA,IAASoS,EAAe9F,EAAItM,IAC/C8I,EAAQK,QAAQnJ,GACTsY,GAIT,SAASF,EAAUpY,GAEjB,OADA8I,EAAQM,KAAK,mBACNU,EAAKoB,UAAYnC,EAAG/I,GAAQsJ,EAAatJ,GAIlD,SAASsJ,EAAatJ,GACpB,OAAa,OAATA,EACKqT,EAAMrT,GAGXuI,EAAmBvI,GACd8I,EAAQS,QACbyO,EACAlP,EAAQS,QACNsO,EACAxE,EACA4E,EACIpP,GACEC,EACAQ,EACA,aACA2O,EAAgB,GAElB3O,GAEN+J,EAdKvK,CAeL9I,IAGJ8I,EAAQG,MAAM,iBACPkF,EAAgBnO,IAIzB,SAASmO,EAAgBnO,GACvB,OAAa,OAATA,GAAiBuI,EAAmBvI,IACtC8I,EAAQM,KAAK,iBACNE,EAAatJ,KAGtB8I,EAAQK,QAAQnJ,GACTmO,GAIT,SAASkF,EAAMrT,GAEb,OADA8I,EAAQM,KAAK,cACNL,EAAG/I,KAzJZgL,UAAU,GCZZ,MAAM,GAAUuB,SAASgM,cAAc,KAMhC,SAASC,GAA8BlzB,GAC5C,MAAMmzB,EAAqB,IAAMnzB,EAAQ,IACzC,GAAQozB,UAAYD,EACpB,MAAME,EAAO,GAAQC,YAUrB,OAAyC,KAArCD,EAAKpZ,WAAWoZ,EAAKz2B,OAAS,IAAiC,SAAVoD,KAQlDqzB,IAASF,GAA6BE,GChBxC,MAAMF,GAAqB,CAChCx8B,KAAM,qBACNotB,SAIF,SAAoCP,EAASC,EAAIuD,GAC/C,MAAMxC,EAAO9b,KACb,IAGIrM,EAGA2M,EANAlJ,EAAO,EAOX,OAGA,SAAe4a,GAKb,OAJA8I,EAAQG,MAAM,sBACdH,EAAQG,MAAM,4BACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,4BACNgK,GAIT,SAASA,EAAKpT,GACZ,OAAa,KAATA,GACF8I,EAAQG,MAAM,mCACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,mCACNyP,IAGT/P,EAAQG,MAAM,2BACdtnB,EAAM,GACN2M,EAAO4Z,EACA5iB,EAAM0a,IAIf,SAAS6Y,EAAQ7Y,GACf,OAAa,KAATA,GAAwB,MAATA,GACjB8I,EAAQG,MAAM,uCACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,uCACbN,EAAQG,MAAM,2BACdtnB,EAAM,EACN2M,EAAO2Z,EACA3iB,IAGTwjB,EAAQG,MAAM,2BACdtnB,EAAM,EACN2M,EAAO0Z,EACA1iB,EAAM0a,IAIf,SAAS1a,EAAM0a,GAEb,IAAI4J,EAEJ,OAAa,KAAT5J,GAAe5a,GACjBwkB,EAAQd,EAAQM,KAAK,2BAGnB9a,IAAS4Z,GACRsQ,GAA8B1O,EAAKwE,eAAe1E,KAKrDd,EAAQG,MAAM,4BACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,4BACbN,EAAQM,KAAK,sBACNL,GAPEuD,EAAItM,IAUX1R,EAAK0R,IAAS5a,IAASzD,GACzBmnB,EAAQK,QAAQnJ,GACT1a,GAGFgnB,EAAItM,MC7FR,MAAM8Y,GAAkB,CAC7B78B,KAAM,kBACNotB,SAIF,SAAiCP,EAASC,EAAIuD,GAC5C,OAGA,SAAetM,GAKb,OAJA8I,EAAQG,MAAM,mBACdH,EAAQG,MAAM,gBACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,gBACNgK,GAIT,SAASA,EAAKpT,GACZ,OAAImI,EAAiBnI,IACnB8I,EAAQG,MAAM,wBACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,wBACbN,EAAQM,KAAK,mBACNL,GAGFuD,EAAItM,MC3BR,MAAM+Y,GAAa,CACxB98B,KAAM,aACNotB,SAIF,SAA4BP,EAASC,GACnC,OAGA,SAAe/I,GAIb,OAHA8I,EAAQG,MAAM,cACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,cACNP,GAAaC,EAASC,EAAI,iBCJ9B,MAAMiQ,GAAW,CACtB/8B,KAAM,WACNotB,SAgJF,SAA0BP,EAASC,EAAIuD,GACrC,MAAMxC,EAAO9b,KACb,IAGIirB,EAGAjE,EANAnyB,EAAQinB,EAAKa,OAAOzoB,OAQxB,KAAOW,KACL,IACkC,eAA/BinB,EAAKa,OAAO9nB,GAAO,GAAGoW,MACU,cAA/B6Q,EAAKa,OAAO9nB,GAAO,GAAGoW,QACvB6Q,EAAKa,OAAO9nB,GAAO,GAAGq2B,UACvB,CACAD,EAAanP,EAAKa,OAAO9nB,GAAO,GAChC,MAIJ,OAGA,SAAemd,GACb,IAAKiZ,EACH,OAAO3M,EAAItM,GAGb,OAAIiZ,EAAWE,UAAkBC,EAASpZ,IAC1CgV,EAAUlL,EAAKN,OAAOwL,QAAQ9S,SAC5BwS,GACE5K,EAAKwE,eAAe,CAClB3W,MAAOshB,EAAWjhB,IAClBA,IAAK8R,EAAK2B,UAIhB3C,EAAQG,MAAM,YACdH,EAAQG,MAAM,eACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,eACbN,EAAQM,KAAK,YACNiQ,IAIT,SAASA,EAAcrZ,GAErB,OAAa,KAATA,EACK8I,EAAQS,QACb+P,GACAvQ,EACAiM,EAAUjM,EAAKqQ,EAHVtQ,CAIL9I,GAGS,KAATA,EACK8I,EAAQS,QACbgQ,GACAxQ,EACAiM,EACIlM,EAAQS,QAAQiQ,GAA6BzQ,EAAIqQ,GACjDA,EALCtQ,CAML9I,GAGGgV,EAAUjM,EAAG/I,GAAQoZ,EAASpZ,GAIvC,SAASoZ,EAASpZ,GAEhB,OADAiZ,EAAWC,WAAY,EAChB5M,EAAItM,KAxNbkS,UA6CF,SAA2BvH,EAAQ4C,GACjC,IAII3D,EAGAwJ,EAGAqG,EAGAv2B,EAbAL,EAAQ8nB,EAAOzoB,OACfwpB,EAAS,EAcb,KAAO7oB,KAGL,GAFA+mB,EAAQe,EAAO9nB,GAAO,GAElBuwB,EAAM,CAER,GACiB,SAAfxJ,EAAM3Q,MACU,cAAf2Q,EAAM3Q,MAAwB2Q,EAAMuP,UAErC,MAIuB,UAArBxO,EAAO9nB,GAAO,IAAiC,cAAf+mB,EAAM3Q,OACxC2Q,EAAMuP,WAAY,QAEf,GAAIM,GACT,GACuB,UAArB9O,EAAO9nB,GAAO,KACE,eAAf+mB,EAAM3Q,MAAwC,cAAf2Q,EAAM3Q,QACrC2Q,EAAMsP,YAEP9F,EAAOvwB,EAEY,cAAf+mB,EAAM3Q,MAAsB,CAC9ByS,EAAS,EACT,WAGoB,aAAf9B,EAAM3Q,OACfwgB,EAAQ52B,GAIZ,MAAM62B,EAAQ,CACZzgB,KAA+B,cAAzB0R,EAAOyI,GAAM,GAAGna,KAAuB,OAAS,QACtDtB,MAAO7D,OAAOwR,OAAO,GAAIqF,EAAOyI,GAAM,GAAGzb,OACzCK,IAAKlE,OAAOwR,OAAO,GAAIqF,EAAOA,EAAOzoB,OAAS,GAAG,GAAG8V,MAEhDxP,EAAQ,CACZyQ,KAAM,QACNtB,MAAO7D,OAAOwR,OAAO,GAAIqF,EAAOyI,GAAM,GAAGzb,OACzCK,IAAKlE,OAAOwR,OAAO,GAAIqF,EAAO8O,GAAO,GAAGzhB,MAEpCxO,EAAO,CACXyP,KAAM,YACNtB,MAAO7D,OAAOwR,OAAO,GAAIqF,EAAOyI,EAAO1H,EAAS,GAAG,GAAG1T,KACtDA,IAAKlE,OAAOwR,OAAO,GAAIqF,EAAO8O,EAAQ,GAAG,GAAG9hB,QA+B9C,OA7BAzU,EAAQ,CACN,CAAC,QAASw2B,EAAOnM,GACjB,CAAC,QAAS/kB,EAAO+kB,IAGnBrqB,EAAQuV,EAAKvV,EAAOynB,EAAOjoB,MAAM0wB,EAAO,EAAGA,EAAO1H,EAAS,IAE3DxoB,EAAQuV,EAAKvV,EAAO,CAAC,CAAC,QAASsG,EAAM+jB,KAErCrqB,EAAQuV,EACNvV,EACAyrB,GACEpB,EAAQ/D,OAAO7B,WAAWgS,WAAWlN,KACrC9B,EAAOjoB,MAAM0wB,EAAO1H,EAAS,EAAG+N,EAAQ,GACxClM,IAIJrqB,EAAQuV,EAAKvV,EAAO,CAClB,CAAC,OAAQsG,EAAM+jB,GACf5C,EAAO8O,EAAQ,GACf9O,EAAO8O,EAAQ,GACf,CAAC,OAAQjxB,EAAO+kB,KAGlBrqB,EAAQuV,EAAKvV,EAAOynB,EAAOjoB,MAAM+2B,EAAQ,IAEzCv2B,EAAQuV,EAAKvV,EAAO,CAAC,CAAC,OAAQw2B,EAAOnM,KACrCvG,EAAO2D,EAAQyI,EAAMzI,EAAOzoB,OAAQgB,GAC7BynB,GA1IPgE,WAmBF,SAA4BhE,GAC1B,IAGIf,EAHA/mB,GAAS,EAKb,OAASA,EAAQ8nB,EAAOzoB,QACtB0nB,EAAQe,EAAO9nB,GAAO,GAGL,eAAf+mB,EAAM3Q,MACS,cAAf2Q,EAAM3Q,MACS,aAAf2Q,EAAM3Q,OAGN0R,EAAO3D,OAAOnkB,EAAQ,EAAkB,eAAf+mB,EAAM3Q,KAAwB,EAAI,GAC3D2Q,EAAM3Q,KAAO,OACbpW,KAIJ,OAAO8nB,IApCH2O,GAAoB,CACxBjQ,SAuNF,SAA0BP,EAASC,EAAIuD,GACrC,OAGA,SAAetM,GAKb,OAJA8I,EAAQG,MAAM,YACdH,EAAQG,MAAM,kBACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,kBACNqL,GAAkB3L,EAASsK,IAIpC,SAASA,EAAKpT,GACZ,OAAa,KAATA,EACKhI,EAAIgI,GAGNsT,GACLxK,EACA8Q,EACAtN,EACA,sBACA,6BACA,mCACA,yBACA,4BACA,GATKgH,CAULtT,GAIJ,SAAS4Z,EAAiB5Z,GACxB,OAAOsI,EAA0BtI,GAC7ByU,GAAkB3L,EAAS+Q,EAA3BpF,CAAoCzU,GACpChI,EAAIgI,GAIV,SAAS6Z,EAAQ7Z,GACf,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,EACzBoU,GACLtL,EACA2L,GAAkB3L,EAAS9Q,GAC3BsU,EACA,gBACA,sBACA,sBANK8H,CAOLpU,GAGGhI,EAAIgI,GAIb,SAAShI,EAAIgI,GACX,OAAa,KAATA,GACF8I,EAAQG,MAAM,kBACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,kBACbN,EAAQM,KAAK,YACNL,GAGFuD,EAAItM,MAnRTuZ,GAAyB,CAC7BlQ,SAuRF,SAA+BP,EAASC,EAAIuD,GAC1C,MAAMxC,EAAO9b,KACb,OAGA,SAAegS,GACb,OAAOiU,GAAaze,KAClBsU,EACAhB,EACAgR,EACAxN,EACA,YACA,kBACA,kBAPK2H,CAQLjU,IAIJ,SAAS8Z,EAAW9Z,GAClB,OAAO8J,EAAKN,OAAOwL,QAAQ9S,SACzBwS,GACE5K,EAAKwE,eAAexE,EAAKa,OAAOb,EAAKa,OAAOzoB,OAAS,GAAG,IAAIQ,MAAM,GAAI,KAGtEqmB,EAAG/I,GACHsM,EAAItM,MA5SNwZ,GAA8B,CAClCnQ,SAgTF,SAAoCP,EAASC,EAAIuD,GAC/C,OAGA,SAAetM,GAKb,OAJA8I,EAAQG,MAAM,aACdH,EAAQG,MAAM,mBACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,mBACNgK,GAIT,SAASA,EAAKpT,GACZ,OAAa,KAATA,GACF8I,EAAQG,MAAM,mBACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,mBACbN,EAAQM,KAAK,aACNL,GAGFuD,EAAItM,MCpWR,MAAM+Z,GAAkB,CAC7B99B,KAAM,kBACNotB,SAKF,SAAiCP,EAASC,EAAIuD,GAC5C,MAAMxC,EAAO9b,KACb,OAGA,SAAegS,GAKb,OAJA8I,EAAQG,MAAM,cACdH,EAAQG,MAAM,oBACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,oBACNgK,GAIT,SAASA,EAAKpT,GACZ,OAAa,KAATA,GACF8I,EAAQG,MAAM,eACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,eACbN,EAAQM,KAAK,cACNiK,GAGF/G,EAAItM,GAIb,SAASqT,EAAMrT,GAQb,OAAgB,KAATA,GAAe,2BAA4B8J,EAAKN,OAAO7B,WAC1D2E,EAAItM,GACJ+I,EAAG/I,KAzCT2O,WAAYqK,GAASrK,YCUhB,SAASqL,GAAkBha,GAChC,OACW,OAATA,GACAsI,EAA0BtI,IAC1ByI,EAAkBzI,GAEX,EAGL0I,EAAmB1I,GACd,OADT,ECfK,MAAMia,GAAY,CACvBh+B,KAAM,YACNotB,SAwKF,SAA2BP,EAASC,GAClC,MAAMmR,EAAmBlsB,KAAKwb,OAAO7B,WAAWuS,iBAAiBzN,KAC3D9C,EAAW3b,KAAK2b,SAChB9B,EAASmS,GAAkBrQ,GAGjC,IAAIyI,EACJ,OAGA,SAAepS,GAGb,OAFA8I,EAAQG,MAAM,qBACdmJ,EAASpS,EACFqS,EAASrS,IAIlB,SAASqS,EAASrS,GAChB,GAAIA,IAASoS,EAEX,OADAtJ,EAAQK,QAAQnJ,GACTqS,EAGT,MAAMzI,EAAQd,EAAQM,KAAK,qBACrBiK,EAAQ2G,GAAkBha,GAC1BoT,GACHC,GAAoB,IAAVA,GAAexL,GAAWqS,EAAiBhY,SAASlC,GAC3DyZ,GACH5R,GAAsB,IAAXA,GAAgBwL,GAAU6G,EAAiBhY,SAASyH,GAGlE,OAFAC,EAAMuQ,MAAQvT,QAAmB,KAAXwL,EAAgBgB,EAAOA,IAASvL,IAAW4R,IACjE7P,EAAMwQ,OAASxT,QAAmB,KAAXwL,EAAgBqH,EAAQA,IAAUpG,IAAUD,IAC5DrK,EAAG/I,KAtMZ2O,WAQF,SAA6BhE,EAAQ4C,GACnC,IAGI6F,EAGAsG,EAGAlwB,EAGA6wB,EAGA3E,EAGA1R,EAGAsW,EAGA5O,EAxBA7oB,GAAS,EA6Bb,OAASA,EAAQ8nB,EAAOzoB,QAEtB,GACuB,UAArByoB,EAAO9nB,GAAO,IACY,sBAA1B8nB,EAAO9nB,GAAO,GAAGoW,MACjB0R,EAAO9nB,GAAO,GAAGu3B,OAIjB,IAFAhH,EAAOvwB,EAEAuwB,KAEL,GACsB,SAApBzI,EAAOyI,GAAM,IACY,sBAAzBzI,EAAOyI,GAAM,GAAGna,MAChB0R,EAAOyI,GAAM,GAAG+G,OAChB5M,EAAQe,eAAe3D,EAAOyI,GAAM,IAAI7T,WAAW,KACjDgO,EAAQe,eAAe3D,EAAO9nB,GAAO,IAAI0c,WAAW,GACtD,CAKA,IACGoL,EAAOyI,GAAM,GAAGgH,QAAUzP,EAAO9nB,GAAO,GAAGs3B,SAC3CxP,EAAO9nB,GAAO,GAAGmV,IAAI0T,OAASf,EAAO9nB,GAAO,GAAG8U,MAAM+T,QAAU,MAE7Df,EAAOyI,GAAM,GAAGpb,IAAI0T,OACnBf,EAAOyI,GAAM,GAAGzb,MAAM+T,OACtBf,EAAO9nB,GAAO,GAAGmV,IAAI0T,OACrBf,EAAO9nB,GAAO,GAAG8U,MAAM+T,QACzB,GAGF,SAGF1H,EACE2G,EAAOyI,GAAM,GAAGpb,IAAI0T,OAASf,EAAOyI,GAAM,GAAGzb,MAAM+T,OAAS,GAC5Df,EAAO9nB,GAAO,GAAGmV,IAAI0T,OAASf,EAAO9nB,GAAO,GAAG8U,MAAM+T,OAAS,EAC1D,EACA,EACN,MAAM/T,EAAQ7D,OAAOwR,OAAO,GAAIqF,EAAOyI,GAAM,GAAGpb,KAC1CA,EAAMlE,OAAOwR,OAAO,GAAIqF,EAAO9nB,GAAO,GAAG8U,OAC/C4iB,GAAU5iB,GAAQqM,GAClBuW,GAAUviB,EAAKgM,GACfqW,EAAkB,CAChBphB,KAAM+K,EAAM,EAAI,iBAAmB,mBACnCrM,QACAK,IAAKlE,OAAOwR,OAAO,GAAIqF,EAAOyI,GAAM,GAAGpb,MAEzC0d,EAAkB,CAChBzc,KAAM+K,EAAM,EAAI,iBAAmB,mBACnCrM,MAAO7D,OAAOwR,OAAO,GAAIqF,EAAO9nB,GAAO,GAAG8U,OAC1CK,OAEFxO,EAAO,CACLyP,KAAM+K,EAAM,EAAI,aAAe,eAC/BrM,MAAO7D,OAAOwR,OAAO,GAAIqF,EAAOyI,GAAM,GAAGpb,KACzCA,IAAKlE,OAAOwR,OAAO,GAAIqF,EAAO9nB,GAAO,GAAG8U,QAE1C+hB,EAAQ,CACNzgB,KAAM+K,EAAM,EAAI,SAAW,WAC3BrM,MAAO7D,OAAOwR,OAAO,GAAI+U,EAAgB1iB,OACzCK,IAAKlE,OAAOwR,OAAO,GAAIoQ,EAAgB1d,MAEzC2S,EAAOyI,GAAM,GAAGpb,IAAMlE,OAAOwR,OAAO,GAAI+U,EAAgB1iB,OACxDgT,EAAO9nB,GAAO,GAAG8U,MAAQ7D,OAAOwR,OAAO,GAAIoQ,EAAgB1d,KAC3DsiB,EAAa,GAET3P,EAAOyI,GAAM,GAAGpb,IAAI0T,OAASf,EAAOyI,GAAM,GAAGzb,MAAM+T,SACrD4O,EAAa7hB,EAAK6hB,EAAY,CAC5B,CAAC,QAAS3P,EAAOyI,GAAM,GAAI7F,GAC3B,CAAC,OAAQ5C,EAAOyI,GAAM,GAAI7F,MAI9B+M,EAAa7hB,EAAK6hB,EAAY,CAC5B,CAAC,QAASZ,EAAOnM,GACjB,CAAC,QAAS8M,EAAiB9M,GAC3B,CAAC,OAAQ8M,EAAiB9M,GAC1B,CAAC,QAAS/jB,EAAM+jB,KAGlB+M,EAAa7hB,EACX6hB,EACA3L,GACEpB,EAAQ/D,OAAO7B,WAAWgS,WAAWlN,KACrC9B,EAAOjoB,MAAM0wB,EAAO,EAAGvwB,GACvB0qB,IAIJ+M,EAAa7hB,EAAK6hB,EAAY,CAC5B,CAAC,OAAQ9wB,EAAM+jB,GACf,CAAC,QAASmI,EAAiBnI,GAC3B,CAAC,OAAQmI,EAAiBnI,GAC1B,CAAC,OAAQmM,EAAOnM,KAGd5C,EAAO9nB,GAAO,GAAGmV,IAAI0T,OAASf,EAAO9nB,GAAO,GAAG8U,MAAM+T,QACvDA,EAAS,EACT4O,EAAa7hB,EAAK6hB,EAAY,CAC5B,CAAC,QAAS3P,EAAO9nB,GAAO,GAAI0qB,GAC5B,CAAC,OAAQ5C,EAAO9nB,GAAO,GAAI0qB,MAG7B7B,EAAS,EAGX1E,EAAO2D,EAAQyI,EAAO,EAAGvwB,EAAQuwB,EAAO,EAAGkH,GAC3Cz3B,EAAQuwB,EAAOkH,EAAWp4B,OAASwpB,EAAS,EAC5C,MAMR7oB,GAAS,EAET,OAASA,EAAQ8nB,EAAOzoB,QACQ,sBAA1ByoB,EAAO9nB,GAAO,GAAGoW,OACnB0R,EAAO9nB,GAAO,GAAGoW,KAAO,QAI5B,OAAO0R,IAiDT,SAAS4P,GAAUpc,EAAOuN,GACxBvN,EAAM5G,QAAUmU,EAChBvN,EAAMuN,QAAUA,EAChBvN,EAAMqR,cAAgB9D,EC5NjB,MAAM8O,GAAW,CACtBv+B,KAAM,WACNotB,SAIF,SAA0BP,EAASC,EAAIuD,GACrC,IAAIlnB,EAAO,EACX,OAGA,SAAe4a,GAMb,OALA8I,EAAQG,MAAM,YACdH,EAAQG,MAAM,kBACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,kBACbN,EAAQG,MAAM,oBACPmK,GAIT,SAASA,EAAKpT,GACZ,OAAI8H,EAAW9H,IACb8I,EAAQK,QAAQnJ,GACTya,GAGFrS,EAAWpI,GAAQ0a,EAAW1a,GAAQsM,EAAItM,GAInD,SAASya,EAAmBza,GAC1B,OAAgB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAekI,EAAkBlI,GAClE2a,EAAyB3a,GACzB0a,EAAW1a,GAIjB,SAAS2a,EAAyB3a,GAChC,OAAa,KAATA,GACF8I,EAAQK,QAAQnJ,GACT4a,IAIG,KAAT5a,GAAwB,KAATA,GAAwB,KAATA,GAAekI,EAAkBlI,KAChE5a,IAAS,IAET0jB,EAAQK,QAAQnJ,GACT2a,GAGFD,EAAW1a,GAIpB,SAAS4a,EAAU5a,GACjB,OAAa,KAATA,GACF8I,EAAQM,KAAK,oBACNpR,EAAIgI,IAGA,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAeqI,EAAarI,GACvDsM,EAAItM,IAGb8I,EAAQK,QAAQnJ,GACT4a,GAIT,SAASF,EAAW1a,GAClB,OAAa,KAATA,GACF8I,EAAQK,QAAQnJ,GAChB5a,EAAO,EACAy1B,GAGLzS,EAAWpI,IACb8I,EAAQK,QAAQnJ,GACT0a,GAGFpO,EAAItM,GAIb,SAAS6a,EAAiB7a,GACxB,OAAOkI,EAAkBlI,GAAQ8a,EAAW9a,GAAQsM,EAAItM,GAI1D,SAAS8a,EAAW9a,GAClB,OAAa,KAATA,GACF8I,EAAQK,QAAQnJ,GAChB5a,EAAO,EACAy1B,GAGI,KAAT7a,GAEF8I,EAAQM,KAAK,oBAAoBnQ,KAAO,gBACjCjB,EAAIgI,IAGN+a,EAAW/a,GAIpB,SAAS+a,EAAW/a,GAClB,OAAc,KAATA,GAAekI,EAAkBlI,KAAU5a,IAAS,IACvD0jB,EAAQK,QAAQnJ,GACA,KAATA,EAAc+a,EAAaD,GAG7BxO,EAAItM,GAIb,SAAShI,EAAIgI,GAKX,OAJA8I,EAAQG,MAAM,kBACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,kBACbN,EAAQM,KAAK,YACNL,KCzHJ,MAAMiS,GAAW,CACtB/+B,KAAM,WACNotB,SAIF,SAA0BP,EAASC,EAAIuD,GACrC,MAAMxC,EAAO9b,KAGb,IAAIokB,EAGA6D,EAGApzB,EAGAsuB,EACJ,OAGA,SAAenR,GAIb,OAHA8I,EAAQG,MAAM,YACdH,EAAQG,MAAM,gBACdH,EAAQK,QAAQnJ,GACToT,GAIT,SAASA,EAAKpT,GACZ,OAAa,KAATA,GACF8I,EAAQK,QAAQnJ,GACTib,GAGI,KAATjb,GACF8I,EAAQK,QAAQnJ,GACTmW,GAGI,KAATnW,GACF8I,EAAQK,QAAQnJ,GACTkb,GAGLpT,EAAW9H,IACb8I,EAAQK,QAAQnJ,GACTmb,GAGF7O,EAAItM,GAIb,SAASib,EAAgBjb,GACvB,OAAa,KAATA,GACF8I,EAAQK,QAAQnJ,GACTob,GAGI,KAATpb,GACF8I,EAAQK,QAAQnJ,GAChBiW,EAAS,SACTpzB,EAAQ,EACDw4B,GAGLvT,EAAW9H,IACb8I,EAAQK,QAAQnJ,GACT9G,GAGFoT,EAAItM,GAIb,SAASob,EAAYpb,GACnB,OAAa,KAATA,GACF8I,EAAQK,QAAQnJ,GACTsb,GAGFhP,EAAItM,GAIb,SAASsb,EAAatb,GACpB,OAAa,OAATA,GAA0B,KAATA,EACZsM,EAAItM,GAGA,KAATA,GACF8I,EAAQK,QAAQnJ,GACTub,GAGFziB,EAAQkH,GAIjB,SAASub,EAAiBvb,GACxB,OAAa,OAATA,GAA0B,KAATA,EACZsM,EAAItM,GAGNlH,EAAQkH,GAIjB,SAASlH,EAAQkH,GACf,OAAa,OAATA,EACKsM,EAAItM,GAGA,KAATA,GACF8I,EAAQK,QAAQnJ,GACTwb,GAGLjT,EAAmBvI,IACrBmR,EAAcrY,EACP2iB,EAAazb,KAGtB8I,EAAQK,QAAQnJ,GACTlH,GAIT,SAAS0iB,EAAaxb,GACpB,OAAa,KAATA,GACF8I,EAAQK,QAAQnJ,GACThI,GAGFc,EAAQkH,GAIjB,SAASqb,EAAUrb,GACjB,OAAIA,IAASiW,EAAO1W,WAAW1c,MAC7BimB,EAAQK,QAAQnJ,GACTnd,IAAUozB,EAAO/zB,OAASw5B,EAAQL,GAGpC/O,EAAItM,GAIb,SAAS0b,EAAM1b,GACb,OAAa,OAATA,EACKsM,EAAItM,GAGA,KAATA,GACF8I,EAAQK,QAAQnJ,GACT2b,GAGLpT,EAAmBvI,IACrBmR,EAAcuK,EACPD,EAAazb,KAGtB8I,EAAQK,QAAQnJ,GACT0b,GAIT,SAASC,EAAW3b,GAClB,OAAa,KAATA,GACF8I,EAAQK,QAAQnJ,GACT4b,GAGFF,EAAM1b,GAIf,SAAS4b,EAAS5b,GAChB,OAAa,KAATA,EACKhI,EAAIgI,GAGA,KAATA,GACF8I,EAAQK,QAAQnJ,GACT4b,GAGFF,EAAM1b,GAIf,SAAS9G,EAAY8G,GACnB,OAAa,OAATA,GAA0B,KAATA,EACZhI,EAAIgI,GAGTuI,EAAmBvI,IACrBmR,EAAcjY,EACPuiB,EAAazb,KAGtB8I,EAAQK,QAAQnJ,GACT9G,GAIT,SAASgiB,EAAYlb,GACnB,OAAa,OAATA,EACKsM,EAAItM,GAGA,KAATA,GACF8I,EAAQK,QAAQnJ,GACT6b,GAGLtT,EAAmBvI,IACrBmR,EAAc+J,EACPO,EAAazb,KAGtB8I,EAAQK,QAAQnJ,GACTkb,GAIT,SAASW,EAAiB7b,GACxB,OAAgB,KAATA,EAAchI,EAAIgI,GAAQkb,EAAYlb,GAI/C,SAASmW,EAAcnW,GACrB,OAAI8H,EAAW9H,IACb8I,EAAQK,QAAQnJ,GACT8b,GAGFxP,EAAItM,GAIb,SAAS8b,EAAS9b,GAChB,OAAa,KAATA,GAAekI,EAAkBlI,IACnC8I,EAAQK,QAAQnJ,GACT8b,GAGFC,EAAgB/b,GAIzB,SAAS+b,EAAgB/b,GACvB,OAAIuI,EAAmBvI,IACrBmR,EAAc4K,EACPN,EAAazb,IAGlBwI,EAAcxI,IAChB8I,EAAQK,QAAQnJ,GACT+b,GAGF/jB,EAAIgI,GAIb,SAASmb,EAAQnb,GACf,OAAa,KAATA,GAAekI,EAAkBlI,IACnC8I,EAAQK,QAAQnJ,GACTmb,GAGI,KAATnb,GAAwB,KAATA,GAAesI,EAA0BtI,GACnDgc,EAAehc,GAGjBsM,EAAItM,GAIb,SAASgc,EAAehc,GACtB,OAAa,KAATA,GACF8I,EAAQK,QAAQnJ,GACThI,GAGI,KAATgI,GAAwB,KAATA,GAAe8H,EAAW9H,IAC3C8I,EAAQK,QAAQnJ,GACTic,GAGL1T,EAAmBvI,IACrBmR,EAAc6K,EACPP,EAAazb,IAGlBwI,EAAcxI,IAChB8I,EAAQK,QAAQnJ,GACTgc,GAGFhkB,EAAIgI,GAIb,SAASic,EAAqBjc,GAC5B,OACW,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACAkI,EAAkBlI,IAElB8I,EAAQK,QAAQnJ,GACTic,GAGFC,EAA0Blc,GAInC,SAASkc,EAA0Blc,GACjC,OAAa,KAATA,GACF8I,EAAQK,QAAQnJ,GACTmc,GAGL5T,EAAmBvI,IACrBmR,EAAc+K,EACPT,EAAazb,IAGlBwI,EAAcxI,IAChB8I,EAAQK,QAAQnJ,GACTkc,GAGFF,EAAehc,GAIxB,SAASmc,EAA4Bnc,GACnC,OACW,OAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,EAEOsM,EAAItM,GAGA,KAATA,GAAwB,KAATA,GACjB8I,EAAQK,QAAQnJ,GAChBoS,EAASpS,EACFoc,GAGL7T,EAAmBvI,IACrBmR,EAAcgL,EACPV,EAAazb,IAGlBwI,EAAcxI,IAChB8I,EAAQK,QAAQnJ,GACTmc,IAGTrT,EAAQK,QAAQnJ,GAChBoS,OAAS7vB,EACF85B,GAIT,SAASD,EAA4Bpc,GACnC,OAAIA,IAASoS,GACXtJ,EAAQK,QAAQnJ,GACTsc,GAGI,OAATtc,EACKsM,EAAItM,GAGTuI,EAAmBvI,IACrBmR,EAAciL,EACPX,EAAazb,KAGtB8I,EAAQK,QAAQnJ,GACToc,GAIT,SAASE,EAAiCtc,GACxC,OAAa,KAATA,GAAwB,KAATA,GAAesI,EAA0BtI,GACnDgc,EAAehc,GAGjBsM,EAAItM,GAIb,SAASqc,EAA8Brc,GACrC,OACW,OAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,EAEOsM,EAAItM,GAGA,KAATA,GAAesI,EAA0BtI,GACpCgc,EAAehc,IAGxB8I,EAAQK,QAAQnJ,GACTqc,GAMT,SAASZ,EAAazb,GAKpB,OAJA8I,EAAQM,KAAK,gBACbN,EAAQG,MAAM,cACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,cACNP,GACLC,EACAqM,EACA,aACArL,EAAKN,OAAO7B,WAAW6E,QAAQC,KAAKvK,SAAS,qBACzC3f,EACA,GAKR,SAAS4yB,EAAYnV,GAEnB,OADA8I,EAAQG,MAAM,gBACPkI,EAAYnR,GAIrB,SAAShI,EAAIgI,GACX,OAAa,KAATA,GACF8I,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,gBACbN,EAAQM,KAAK,YACNL,GAGFuD,EAAItM,MCpdR,MAAMuc,GAAiB,CAC5BtgC,KAAM,iBACNotB,SAKF,SAAgCP,EAASC,EAAIuD,GAC3C,MAAMxC,EAAO9b,KACb,OAGA,SAAegS,GAMb,OALA8I,EAAQG,MAAM,aACdH,EAAQG,MAAM,eACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,eACbN,EAAQM,KAAK,aACNiK,GAIT,SAASA,EAAMrT,GAQb,OAAgB,KAATA,GAAe,2BAA4B8J,EAAKN,OAAO7B,WAC1D2E,EAAItM,GACJ+I,EAAG/I,KA7BT2O,WAAYqK,GAASrK,YCHhB,MAAM6N,GAAkB,CAC7BvgC,KAAM,kBACNotB,SAIF,SAAiCP,EAASC,EAAIuD,GAC5C,OAGA,SAAetM,GAIb,OAHA8I,EAAQG,MAAM,mBACdH,EAAQG,MAAM,gBACdH,EAAQK,QAAQnJ,GACToT,GAIT,SAASA,EAAKpT,GACZ,OAAIuI,EAAmBvI,IACrB8I,EAAQM,KAAK,gBACbN,EAAQM,KAAK,mBACNL,EAAG/I,IAGLsM,EAAItM,MCtBR,MAAMyc,GAAW,CACtBxgC,KAAM,WACNotB,SA0EF,SAA0BP,EAASC,EAAIuD,GAErC,IAGIlnB,EAGAwkB,EANAmO,EAAW,EAOf,OAGA,SAAe/X,GAGb,OAFA8I,EAAQG,MAAM,YACdH,EAAQG,MAAM,oBACPoR,EAAgBra,IAIzB,SAASqa,EAAgBra,GACvB,OAAa,KAATA,GACF8I,EAAQK,QAAQnJ,GAChB+X,IACOsC,IAGTvR,EAAQM,KAAK,oBACNsT,EAAI1c,IAIb,SAAS0c,EAAI1c,GAEX,OAAa,OAATA,EACKsM,EAAItM,GAIA,KAATA,GACF4J,EAAQd,EAAQG,MAAM,oBACtB7jB,EAAO,EACAswB,EAAgB1V,IAGZ,KAATA,GACF8I,EAAQG,MAAM,SACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,SACNsT,GAGLnU,EAAmBvI,IACrB8I,EAAQG,MAAM,cACdH,EAAQK,QAAQnJ,GAChB8I,EAAQM,KAAK,cACNsT,IAGT5T,EAAQG,MAAM,gBACPnH,EAAK9B,IAKd,SAAS8B,EAAK9B,GACZ,OACW,OAATA,GACS,KAATA,GACS,KAATA,GACAuI,EAAmBvI,IAEnB8I,EAAQM,KAAK,gBACNsT,EAAI1c,KAGb8I,EAAQK,QAAQnJ,GACT8B,GAKT,SAAS4T,EAAgB1V,GAEvB,OAAa,KAATA,GACF8I,EAAQK,QAAQnJ,GAChB5a,IACOswB,GAGLtwB,IAAS2yB,GACXjP,EAAQM,KAAK,oBACbN,EAAQM,KAAK,YACNL,EAAG/I,KAGZ4J,EAAM3Q,KAAO,eACN6I,EAAK9B,MAzKdkG,QAKF,SAAyByE,GACvB,IAII9nB,EAGAomB,EAPA0T,EAAgBhS,EAAOzoB,OAAS,EAChC06B,EAAiB,EAQrB,IACsC,eAAnCjS,EAAOiS,GAAgB,GAAG3jB,MACU,UAAnC0R,EAAOiS,GAAgB,GAAG3jB,QACO,eAAlC0R,EAAOgS,GAAe,GAAG1jB,MACU,UAAlC0R,EAAOgS,GAAe,GAAG1jB,MAI3B,IAFApW,EAAQ+5B,IAEC/5B,EAAQ85B,GACf,GAA8B,iBAA1BhS,EAAO9nB,GAAO,GAAGoW,KAAyB,CAE5C0R,EAAOiS,GAAgB,GAAG3jB,KAAO,kBACjC0R,EAAOgS,GAAe,GAAG1jB,KAAO,kBAChC2jB,GAAkB,EAClBD,GAAiB,EACjB,MAKN95B,EAAQ+5B,EAAiB,EACzBD,IAEA,OAAS95B,GAAS85B,QACFp6B,IAAV0mB,EACEpmB,IAAU85B,GAA2C,eAA1BhS,EAAO9nB,GAAO,GAAGoW,OAC9CgQ,EAAQpmB,GAGVA,IAAU85B,GACgB,eAA1BhS,EAAO9nB,GAAO,GAAGoW,OAEjB0R,EAAO1B,GAAO,GAAGhQ,KAAO,eAEpBpW,IAAUomB,EAAQ,IACpB0B,EAAO1B,GAAO,GAAGjR,IAAM2S,EAAO9nB,EAAQ,GAAG,GAAGmV,IAC5C2S,EAAO3D,OAAOiC,EAAQ,EAAGpmB,EAAQomB,EAAQ,GACzC0T,GAAiB95B,EAAQomB,EAAQ,EACjCpmB,EAAQomB,EAAQ,GAGlBA,OAAQ1mB,GAIZ,OAAOooB,GA3DPhB,SA+DF,SAAkB3J,GAEhB,OACW,KAATA,GACgD,oBAAhDhS,KAAK2c,OAAO3c,KAAK2c,OAAOzoB,OAAS,GAAG,GAAG+W,OCtDpC,MAAM,GAAW,CACtB,GAAMgO,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,GAAMkM,IAIK1J,GAAiB,CAC5B,GAAMmL,IAIKpG,GAAc,CACzB,EAAE,GAAIyG,GACN,EAAE,GAAIA,GACN,GAAMA,IAIK,GAAO,CAClB,GAAMI,GACN,GAAMlD,GACN,GAAM,CAACqD,GAAiBrD,IACxB,GAAM4D,GACN,GAAMP,GACN,GAAMrD,GACN,GAAMyF,GACN,IAAOA,IAII,GAAS,CACpB,GAAMa,GACN,GAAMK,IAIK,GAAO,CAClB,EAAE,GAAIC,GACN,EAAE,GAAIA,GACN,EAAE,GAAIA,GACN,GAAMgB,GACN,GAAMtB,GACN,GAAMwB,GACN,GAAM,CAACO,GAAUQ,IACjB,GAAMuB,GACN,GAAM,CAACC,GAAiB1D,IACxB,GAAME,GACN,GAAMiB,GACN,GAAMwC,IAIK9C,GAAa,CACxBlN,KAAM,CAACwN,GAAW,KAIPC,GAAmB,CAC9BzN,KAAM,CAAC,GAAI,KAIAD,GAAU,CACrBC,KAAM,ICpFD,SAASxe,GAAMgI,EAAU,IAG9B,MAAM0R,E1CLD,SAA2BkV,GAEhC,MAAMrV,EAAM,GACZ,IAAI3kB,GAAS,EAEb,OAASA,EAAQg6B,EAAW36B,QAC1BqlB,EAAgBC,EAAKqV,EAAWh6B,IAGlC,OAAO2kB,E0CJYsV,CAEjB,CAAC,GAAmBC,OAAO9mB,EAAQ4mB,YAAc,KAI7CrT,EAAS,CACbwL,QAAS,GACTxJ,KAAM,GACN7D,aACAnhB,QAASyrB,EAAOzrB,IAChB+lB,SAAU0F,EAAO,IACjBrG,KAAMqG,EAAOrG,IACb9Q,OAAQmX,EAAOnX,IACftR,KAAMyoB,EAAO,KAEf,OAAOzI,EAKP,SAASyI,EAAO1D,GACd,OAGA,SAAiBlH,GACf,OAAOoI,GAAgBjG,EAAQ+E,EAASlH,KClC9C,MAAM2V,GAAS,cCJR,SAASC,GAAgC33B,EAAO6e,GACrD,MAAMnE,EAAOjP,OAAOmsB,SAAS53B,EAAO6e,GAEpC,OAEEnE,EAAO,GACE,KAATA,GACCA,EAAO,IAAMA,EAAO,IACpBA,EAAO,KAAOA,EAAO,KACrBA,EAAO,OAASA,EAAO,OACvBA,EAAO,OAASA,EAAO,OACL,SAAX,MAAPA,IACkB,SAAX,MAAPA,IACDA,EAAO,QAEA,SAGFjU,OAAO6c,aAAa5I,GC1B7B,MAAMmd,GACJ,oEAqBF,SAASC,GAAOC,EAAIC,EAAIC,GACtB,GAAID,EAEF,OAAOA,EAKT,GAAa,KAFAC,EAAGhe,WAAW,GAEV,CACf,MAAMie,EAAOD,EAAGhe,WAAW,GACrBke,EAAe,MAATD,GAAyB,KAATA,EAC5B,OAAOP,GAAgCM,EAAG76B,MAAM+6B,EAAM,EAAI,GAAIA,EAAM,GAAK,IAG3E,OAAOjF,GAA8B+E,IAAOF,ECsD9C,MAAM,GAAM,GAAGpoB,eAOFyoB,GAcX,SAAUp4B,EAAOgd,EAAUrM,GAMzB,MALwB,kBAAbqM,IACTrM,EAAUqM,EACVA,OAAW/f,GAejB,SAAkB0T,EAAU,IAG1B,MAAM0nB,EAASC,GACb,CACEC,WAAY,GACZC,eAAgB,CACd,WACA,WACA,UACA,YACA,UAEF7U,MAAO,CACLuR,SAAUuD,EAAOC,IACjBC,iBAAkBC,EAClBC,cAAeD,EACfE,WAAYL,EAAOnI,IACnBzC,WAAY4K,EAAO5K,GACnB2F,gBAAiBoF,EACjBzF,mBAAoByF,EACpBtG,WAAYmG,EAAOM,GACnBC,oBAAqBrI,EACrBsI,oBAAqBtI,EACrBhB,aAAc8I,EAAOM,EAAUpI,GAC/BwG,SAAUsB,EAAOtB,EAAUxG,GAC3BuI,aAAcN,EACdpc,KAAMoc,EACNO,cAAeP,EACftJ,WAAYmJ,EAAOnJ,GACnB8J,4BAA6BzI,EAC7B0I,sBAAuB1I,EACvB2I,sBAAuB3I,EACvB4I,SAAUd,EAAOc,IACjBrC,gBAAiBuB,EAAOe,IACxBC,kBAAmBhB,EAAOe,IAC1B/I,SAAUgI,EAAOiB,GAAM/I,GACvBgJ,aAAcf,EACdlD,SAAU+C,EAAOiB,GAAM/I,GACvBiJ,aAAchB,EACdv+B,MAAOo+B,EAAOp+B,IACd6I,MAAOytB,EACP+H,KAAMD,EAAOC,IACbmB,SAAUpB,EAAOoB,IACjBC,cAAeC,EACfC,YAAavB,EAAO9W,GAAMsY,GAC1BC,cAAezB,EAAO9W,IACtBwO,UAAWsI,EAAOtI,IAClBgK,UAAWC,EACXC,gBAAiB1J,EACjB2J,0BAA2B3J,EAC3B4J,oBAAqB5J,EACrB6J,cAAe/B,EAAOnI,IACtBmK,OAAQhC,EAAOgC,IACf5N,cAAe4L,EAAO5L,KAExB/I,KAAM,CACJgV,WAAY4B,IACZC,mBAAoBC,EACpB1F,SAAUwF,IACV7B,cAAegC,EACflC,iBAAkBmC,EAClBjN,WAAY6M,IACZK,qBAAsBC,EACtBC,oCAAqCC,EACrCC,gCAAiCD,EACjCE,wBAAyBC,EACzB/I,WAAYoI,EAAOY,GACnBC,gBAAiBC,EACjBxC,oBAAqByC,EACrBxC,oBAAqByC,EACrBvC,cAAe6B,EACfrL,aAAc+K,EAAOiB,GACrBxE,SAAUuD,EAAOkB,GACjB1C,aAAc8B,EACdxe,KAAMwe,EACN1L,WAAYoL,IACZtB,4BAA6ByC,EAC7BxC,sBAAuByC,EACvBxC,sBAAuByC,EACvBxC,SAAUmB,IACVxD,gBAAiBwD,EAAOsB,GACxBvC,kBAAmBiB,EAAOsB,GAC1BvL,SAAUiK,EAAOuB,GACjBtC,aAAcqB,EACdtF,SAAUgF,EAAOwB,GACjBtC,aAAcoB,EACd3gC,MAAOqgC,EAAOyB,GACdj5B,MAAOk5B,EACPC,UAAWC,EACX7I,WAAY8I,EACZ7D,KAAMgC,EAAO8B,GACb3C,SAAUa,IACVV,YAAaU,IACbR,cAAeQ,IACfvK,UAAWuK,IACXL,gBAAiBoC,EACjBnC,0BAA2BoC,EAC3BnC,oBAAqBoC,EACrBC,SAAUC,EACVrC,cAAeE,EAAOoC,GACtBC,0BAA2BC,EAC3BC,kBAAmBC,EACnBzC,OAAQC,IACR7N,cAAe6N,MAGnB/pB,EAAQwsB,iBAAmB,IAIvB3gB,EAAO,GACb,OAAOkE,EAMP,SAASA,EAAQ2E,GAEf,IAAIvE,EAAO,CACTnN,KAAM,OACNpa,SAAU,IAIZ,MAGM6jC,EAAa,GAGbC,EAAY,GAGZpV,EAAU,CACd7O,MAVY,CAAC0H,GAWbsc,aACA/E,SACA1U,QACAG,OACA6M,SACA2M,SACAC,UACAC,WAEF,IAAIjgC,GAAS,EAEb,OAASA,EAAQ8nB,EAAOzoB,QAGtB,GAC4B,gBAA1ByoB,EAAO9nB,GAAO,GAAGoW,MACS,kBAA1B0R,EAAO9nB,GAAO,GAAGoW,KAEjB,GAAyB,UAArB0R,EAAO9nB,GAAO,GAChB8/B,EAAUlqB,KAAK5V,OACV,CAELA,EAAQkgC,EAAYpY,EADPgY,EAAUvf,MACWvgB,GAOxC,IAFAA,GAAS,IAEAA,EAAQ8nB,EAAOzoB,QAAQ,CAC9B,MAAM8gC,EAAUrF,EAAOhT,EAAO9nB,GAAO,IAEjC,GAAI2S,KAAKwtB,EAASrY,EAAO9nB,GAAO,GAAGoW,OACrC+pB,EAAQrY,EAAO9nB,GAAO,GAAGoW,MAAMzD,KAC7B1B,OAAOwR,OACL,CACEgJ,eAAgB3D,EAAO9nB,GAAO,GAAGyrB,gBAEnCf,GAEF5C,EAAO9nB,GAAO,IAKpB,GAAI6/B,EAAWxgC,OAAS,EAAG,CACzB,MAAMmsB,EAAOqU,EAAWA,EAAWxgC,OAAS,IAC5BmsB,EAAK,IAAM4U,IACnBztB,KAAK+X,OAAShrB,EAAW8rB,EAAK,IAyBxC,IAtBAjI,EAAKzpB,SAAW,CACdgb,MAAOwG,EACLwM,EAAOzoB,OAAS,EACZyoB,EAAO,GAAG,GAAGhT,MACb,CACEC,KAAM,EACNL,OAAQ,EACRmU,OAAQ,IAGhB1T,IAAKmG,EACHwM,EAAOzoB,OAAS,EACZyoB,EAAOA,EAAOzoB,OAAS,GAAG,GAAG8V,IAC7B,CACEJ,KAAM,EACNL,OAAQ,EACRmU,OAAQ,KAIlB7oB,GAAS,IAEAA,EAAQ86B,EAAOE,WAAW37B,QACjCkkB,EAAOuX,EAAOE,WAAWh7B,GAAOujB,IAASA,EAG3C,OAAOA,EAST,SAAS2c,EAAYpY,EAAQhT,EAAOzV,GAClC,IAKIi9B,EAGArS,EAGAoW,EAGA1Q,EAdA3vB,EAAQ8U,EAAQ,EAChBwrB,GAAoB,EACpBC,GAAa,EAcjB,OAASvgC,GAASX,GAAQ,CACxB,MAAMsI,EAAQmgB,EAAO9nB,GAuCrB,GApCoB,kBAAlB2H,EAAM,GAAGyO,MACS,gBAAlBzO,EAAM,GAAGyO,MACS,eAAlBzO,EAAM,GAAGyO,MAEQ,UAAbzO,EAAM,GACR24B,IAEAA,IAGF3Q,OAAWjwB,GACgB,oBAAlBiI,EAAM,GAAGyO,KACD,UAAbzO,EAAM,MAEN20B,GACC3M,GACA2Q,GACAD,IAEDA,EAAsBrgC,GAGxB2vB,OAAWjwB,GAGK,eAAlBiI,EAAM,GAAGyO,MACS,kBAAlBzO,EAAM,GAAGyO,MACS,mBAAlBzO,EAAM,GAAGyO,MACS,mBAAlBzO,EAAM,GAAGyO,MACS,6BAAlBzO,EAAM,GAAGyO,OAITuZ,OAAWjwB,IAIT4gC,GACa,UAAb34B,EAAM,IACY,mBAAlBA,EAAM,GAAGyO,OACY,IAAtBkqB,GACc,SAAb34B,EAAM,KACa,kBAAlBA,EAAM,GAAGyO,MACU,gBAAlBzO,EAAM,GAAGyO,MACb,CACA,GAAIkmB,EAAU,CACZ,IAAIkE,EAAYxgC,EAGhB,IAFAiqB,OAAYvqB,EAEL8gC,KAAa,CAClB,MAAMC,EAAY3Y,EAAO0Y,GAEzB,GACwB,eAAtBC,EAAU,GAAGrqB,MACS,oBAAtBqqB,EAAU,GAAGrqB,KACb,CACA,GAAqB,SAAjBqqB,EAAU,GAAe,SAEzBxW,IACFnC,EAAOmC,GAAW,GAAG7T,KAAO,kBAC5BmqB,GAAa,GAGfE,EAAU,GAAGrqB,KAAO,aACpB6T,EAAYuW,OACP,GACiB,eAAtBC,EAAU,GAAGrqB,MACS,qBAAtBqqB,EAAU,GAAGrqB,MACS,+BAAtBqqB,EAAU,GAAGrqB,MACS,qBAAtBqqB,EAAU,GAAGrqB,MACS,mBAAtBqqB,EAAU,GAAGrqB,KAIb,MAKFiqB,KACEpW,GAAaoW,EAAsBpW,KAGrCqS,EAASoE,SAAU,GAGrBpE,EAASnnB,IAAMlE,OAAOwR,OACpB,GACAwH,EAAYnC,EAAOmC,GAAW,GAAGnV,MAAQnN,EAAM,GAAGwN,KAEpD2S,EAAO3D,OAAO8F,GAAajqB,EAAO,EAAG,CAAC,OAAQs8B,EAAU30B,EAAM,KAC9D3H,IACAX,IAGoB,mBAAlBsI,EAAM,GAAGyO,OACXkmB,EAAW,CACTlmB,KAAM,WAENsqB,SAAS,EACT5rB,MAAO7D,OAAOwR,OAAO,GAAI9a,EAAM,GAAGmN,QAGpCgT,EAAO3D,OAAOnkB,EAAO,EAAG,CAAC,QAASs8B,EAAU30B,EAAM,KAClD3H,IACAX,IACAghC,OAAsB3gC,EACtBiwB,GAAW,IAMjB,OADA7H,EAAOhT,GAAO,GAAG4rB,QAAUH,EACpBlhC,EAOT,SAAS2gC,EAAQltB,EAAKrQ,GACpBwc,EAAKnM,GAAOrQ,EASd,SAASw9B,EAAQntB,GACf,OAAOmM,EAAKnM,GAOd,SAASwI,EAAMviB,GACb,MAAO,CACLgc,KAAMhc,EAAEgc,KACRL,OAAQ3b,EAAE2b,OACVmU,OAAQ9vB,EAAE8vB,QASd,SAASqS,EAAO9L,EAAQuR,GACtB,OAAOpQ,EAOP,SAASA,EAAKxJ,GACZX,EAAMzT,KAAKxH,KAAMikB,EAAOrI,GAAQA,GAC5B4Z,GAAKA,EAAIhuB,KAAKxH,KAAM4b,IAK5B,SAASqM,IACPjoB,KAAK0Q,MAAMjG,KAAK,CACdQ,KAAM,WACNpa,SAAU,KAad,SAASoqB,EAAMpR,EAAM+R,EAAO6Z,GAU1B,OATez1B,KAAK0Q,MAAM1Q,KAAK0Q,MAAMxc,OAAS,GAEvCrD,SAAS4Z,KAAKZ,GACrB7J,KAAK0Q,MAAMjG,KAAKZ,GAChB7J,KAAK00B,WAAWjqB,KAAK,CAACmR,EAAO6Z,IAE7B5rB,EAAKlb,SAAW,CACdgb,MAAOwG,EAAMyL,EAAMjS,QAEdE,EAOT,SAASmoB,EAAOwD,GACd,OAAO/J,EAOP,SAASA,EAAM7P,GACT4Z,GAAKA,EAAIhuB,KAAKxH,KAAM4b,GACxBR,EAAK5T,KAAKxH,KAAM4b,IAWpB,SAASR,EAAKQ,EAAO8Z,GACnB,MAAM7rB,EAAO7J,KAAK0Q,MAAM0E,MAClBgQ,EAAOplB,KAAK00B,WAAWtf,MAE7B,IAAKgQ,EACH,MAAM,IAAI/a,MACR,iBACEuR,EAAM3Q,KACN,MACAiF,EAAkB,CAChBvG,MAAOiS,EAAMjS,MACbK,IAAK4R,EAAM5R,MAEb,yBAEC,GAAIob,EAAK,GAAGna,OAAS2Q,EAAM3Q,KAChC,GAAIyqB,EACFA,EAAYluB,KAAKxH,KAAM4b,EAAOwJ,EAAK,QAC9B,EACWA,EAAK,IAAM6P,IACnBztB,KAAKxH,KAAM4b,EAAOwJ,EAAK,IAKnC,OADAvb,EAAKlb,SAASqb,IAAMmG,EAAMyL,EAAM5R,KACzBH,EAOT,SAAS+qB,IACP,OhDtmBG,SAAkB/qB,EAAM5B,GAC7B,IAAI,gBAAC8Q,GAAkB,GAAQ9Q,GAAW,GAC1C,OAAO6Q,EAAIjP,EAAMkP,GgDomBR,CAAS/Y,KAAK0Q,MAAM0E,OAO7B,SAASmc,IACPsD,EAAQ,+BAA+B,GAIzC,SAASxD,EAAqBzV,GAC5B,GAAIkZ,EAAQ,+BAAgC,CAGxC90B,KAAK0Q,MAAM1Q,KAAK0Q,MAAMxc,OAAS,GACxByV,MAAQ5G,OAAOmsB,SAASlvB,KAAKsgB,eAAe1E,GAAQ,IAC7DiZ,EAAQ,gCAKZ,SAAS9B,IACP,MAAMjf,EAAO9T,KAAK40B,SAGhB50B,KAAK0Q,MAAM1Q,KAAK0Q,MAAMxc,OAAS,GAC5ByhC,KAAO7hB,EAId,SAASkf,IACP,MAAMlf,EAAO9T,KAAK40B,SAGhB50B,KAAK0Q,MAAM1Q,KAAK0Q,MAAMxc,OAAS,GAC5Bo2B,KAAOxW,EAId,SAASgf,IAEHgC,EAAQ,oBACZ90B,KAAKioB,SACL4M,EAAQ,kBAAkB,IAI5B,SAASjC,IACP,MAAM9e,EAAO9T,KAAK40B,SAGhB50B,KAAK0Q,MAAM1Q,KAAK0Q,MAAMxc,OAAS,GAC5BoD,MAAQwc,EAAK3U,QAAQ,2BAA4B,IACtD01B,EAAQ,kBAIV,SAAS5B,IACP,MAAMnf,EAAO9T,KAAK40B,SAGhB50B,KAAK0Q,MAAM1Q,KAAK0Q,MAAMxc,OAAS,GAC5BoD,MAAQwc,EAAK3U,QAAQ,eAAgB,IAI5C,SAASi0B,EAA4BxX,GAEnC,MAAMphB,EAAQwF,KAAK40B,SACb/qB,EAEJ7J,KAAK0Q,MAAM1Q,KAAK0Q,MAAMxc,OAAS,GACjC2V,EAAKrP,MAAQA,EACbqP,EAAKgd,WAAaH,GAChB1mB,KAAKsgB,eAAe1E,IACpB1c,cAIJ,SAASm0B,IACP,MAAMvf,EAAO9T,KAAK40B,SAGhB50B,KAAK0Q,MAAM1Q,KAAK0Q,MAAMxc,OAAS,GAC5BqyB,MAAQzS,EAIf,SAASqf,IACP,MAAMrf,EAAO9T,KAAK40B,SAGhB50B,KAAK0Q,MAAM1Q,KAAK0Q,MAAMxc,OAAS,GAC5B8c,IAAM8C,EAIb,SAASoe,EAAyBtW,GAChC,MAAM/R,EAEJ7J,KAAK0Q,MAAM1Q,KAAK0Q,MAAMxc,OAAS,GAEjC,IAAK2V,EAAK+rB,MAAO,CACf,MAAMA,EAAQ51B,KAAKsgB,eAAe1E,GAAO1nB,OACzC2V,EAAK+rB,MAAQA,GAKjB,SAASpB,IACPK,EAAQ,gCAAgC,GAI1C,SAASP,EAAgC1Y,GAGrC5b,KAAK0Q,MAAM1Q,KAAK0Q,MAAMxc,OAAS,GAC5B0hC,MAAqD,KAA7C51B,KAAKsgB,eAAe1E,GAAOrK,WAAW,GAAY,EAAI,EAIrE,SAAS6iB,IACPS,EAAQ,gCAIV,SAAS3E,EAAYtU,GACnB,MAAMia,EAEJ71B,KAAK0Q,MAAM1Q,KAAK0Q,MAAMxc,OAAS,GAGjC,IAAImsB,EAAOwV,EAAOhlC,SAASglC,EAAOhlC,SAASqD,OAAS,GAE/CmsB,GAAsB,SAAdA,EAAKpV,OAEhBoV,EAAO7kB,KAEP6kB,EAAK1xB,SAAW,CACdgb,MAAOwG,EAAMyL,EAAMjS,QAGrBksB,EAAOhlC,SAAS4Z,KAAK4V,IAGvBrgB,KAAK0Q,MAAMjG,KAAK4V,GAIlB,SAASiS,EAAW1W,GAClB,MAAMyE,EAAOrgB,KAAK0Q,MAAM0E,MACxBiL,EAAK/oB,OAAS0I,KAAKsgB,eAAe1E,GAClCyE,EAAK1xB,SAASqb,IAAMmG,EAAMyL,EAAM5R,KAIlC,SAAS6pB,EAAiBjY,GACxB,MAAM2D,EAAUvf,KAAK0Q,MAAM1Q,KAAK0Q,MAAMxc,OAAS,GAG/C,GAAI4gC,EAAQ,eAAgB,CAI1B,OAHavV,EAAQ1uB,SAAS0uB,EAAQ1uB,SAASqD,OAAS,GACnDvF,SAASqb,IAAMmG,EAAMyL,EAAM5R,UAChC6qB,EAAQ,gBAKPC,EAAQ,iCACTnF,EAAOG,eAAe5b,SAASqL,EAAQtU,QAEvCilB,EAAY1oB,KAAKxH,KAAM4b,GACvB0W,EAAW9qB,KAAKxH,KAAM4b,IAK1B,SAAS0X,IACPuB,EAAQ,eAAe,GAIzB,SAAStB,IACP,MAAMzf,EAAO9T,KAAK40B,SAGhB50B,KAAK0Q,MAAM1Q,KAAK0Q,MAAMxc,OAAS,GAC5BoD,MAAQwc,EAIf,SAAS0f,IACP,MAAM1f,EAAO9T,KAAK40B,SAGhB50B,KAAK0Q,MAAM1Q,KAAK0Q,MAAMxc,OAAS,GAC5BoD,MAAQwc,EAIf,SAASof,IACP,MAAMpf,EAAO9T,KAAK40B,SAGhB50B,KAAK0Q,MAAM1Q,KAAK0Q,MAAMxc,OAAS,GAC5BoD,MAAQwc,EAIf,SAASggB,IACP,MAAMvU,EAEJvf,KAAK0Q,MAAM1Q,KAAK0Q,MAAMxc,OAAS,GAE7B4gC,EAAQ,gBACVvV,EAAQtU,MAAQ,YAEhBsU,EAAQuW,cAAgBhB,EAAQ,kBAAoB,kBAE7CvV,EAAQvO,WACRuO,EAAQgH,eAGRhH,EAAQsH,kBAERtH,EAAQ/kB,OAGjBq6B,EAAQ,iBAIV,SAASpB,IACP,MAAMlU,EAEJvf,KAAK0Q,MAAM1Q,KAAK0Q,MAAMxc,OAAS,GAE7B4gC,EAAQ,gBACVvV,EAAQtU,MAAQ,YAEhBsU,EAAQuW,cAAgBhB,EAAQ,kBAAoB,kBAE7CvV,EAAQvO,WACRuO,EAAQgH,eAGRhH,EAAQsH,kBAERtH,EAAQ/kB,OAGjBq6B,EAAQ,iBAIV,SAASjB,EAAgBhY,GACvB,MAAMma,EAEJ/1B,KAAK0Q,MAAM1Q,KAAK0Q,MAAMxc,OAAS,GAC3B4Y,EAAS9M,KAAKsgB,eAAe1E,GACnCma,EAASv7B,MD72BN,SAAsBlD,GAC3B,OAAOA,EAAM6H,QAAQgwB,GAA4BC,IC42B9B4G,CAAalpB,GAC9BipB,EAASlP,WAAaH,GAAoB5Z,GAAQ5N,cAIpD,SAASw0B,IACP,MAAMuC,EAEJj2B,KAAK0Q,MAAM1Q,KAAK0Q,MAAMxc,OAAS,GAC3BoD,EAAQ0I,KAAK40B,SACb/qB,EAEJ7J,KAAK0Q,MAAM1Q,KAAK0Q,MAAMxc,OAAS,GAEjC2gC,EAAQ,eAAe,GAEL,SAAdhrB,EAAKoB,KAEPpB,EAAKhZ,SAAWolC,EAASplC,SAEzBgZ,EAAKjZ,IAAM0G,EAKf,SAAS08B,IACP,MAAMlgB,EAAO9T,KAAK40B,SAGhB50B,KAAK0Q,MAAM1Q,KAAK0Q,MAAMxc,OAAS,GAC5B8c,IAAM8C,EAIb,SAASmgB,IACP,MAAMngB,EAAO9T,KAAK40B,SAGhB50B,KAAK0Q,MAAM1Q,KAAK0Q,MAAMxc,OAAS,GAC5BqyB,MAAQzS,EAIf,SAASqgB,IACPU,EAAQ,eAIV,SAASnD,IACPmD,EAAQ,gBAAiB,aAI3B,SAASd,EAAsBnY,GAC7B,MAAMphB,EAAQwF,KAAK40B,SACb/qB,EAEJ7J,KAAK0Q,MAAM1Q,KAAK0Q,MAAMxc,OAAS,GACjC2V,EAAKrP,MAAQA,EACbqP,EAAKgd,WAAaH,GAChB1mB,KAAKsgB,eAAe1E,IACpB1c,cACF21B,EAAQ,gBAAiB,QAI3B,SAASrC,EAA+B5W,GACtCiZ,EAAQ,yBAA0BjZ,EAAM3Q,MAI1C,SAAS0nB,EAA8B/W,GACrC,MAAM9H,EAAO9T,KAAKsgB,eAAe1E,GAC3B3Q,EAAO6pB,EAAQ,0BAGrB,IAAIx9B,EAEA2T,GACF3T,EAAQ23B,GACNnb,EACS,oCAAT7I,EAA6C,GAAK,IAEpD4pB,EAAQ,2BAKRv9B,EAAQkzB,GAA8B1W,GAGxC,MAAMuM,EAAOrgB,KAAK0Q,MAAM0E,MACxBiL,EAAK/oB,OAASA,EACd+oB,EAAK1xB,SAASqb,IAAMmG,EAAMyL,EAAM5R,KAIlC,SAASooB,EAAuBxW,GAC9B0W,EAAW9qB,KAAKxH,KAAM4b,GAGpB5b,KAAK0Q,MAAM1Q,KAAK0Q,MAAMxc,OAAS,GAC5B8c,IAAMhR,KAAKsgB,eAAe1E,GAIjC,SAASuW,EAAoBvW,GAC3B0W,EAAW9qB,KAAKxH,KAAM4b,GAGpB5b,KAAK0Q,MAAM1Q,KAAK0Q,MAAMxc,OAAS,GAC5B8c,IAAM,UAAYhR,KAAKsgB,eAAe1E,GAO7C,SAASuJ,IACP,MAAO,CACLla,KAAM,aACNpa,SAAU,IAKd,SAASw/B,IACP,MAAO,CACLplB,KAAM,OACN0qB,KAAM,KACNrL,KAAM,KACNhzB,MAAO,IAKX,SAASm3B,IACP,MAAO,CACLxjB,KAAM,aACN3T,MAAO,IAKX,SAASsvB,IACP,MAAO,CACL3b,KAAM,aACN4b,WAAY,GACZrsB,MAAO,KACP+rB,MAAO,KACPvV,IAAK,IAKT,SAAS6f,KACP,MAAO,CACL5lB,KAAM,WACNpa,SAAU,IAKd,SAAS+2B,KAEP,MAAO,CACL3c,KAAM,UACN2qB,WAAOrhC,EACP1D,SAAU,IAKd,SAASigC,KACP,MAAO,CACL7lB,KAAM,SAKV,SAAS+lB,KACP,MAAO,CACL/lB,KAAM,OACN3T,MAAO,IAKX,SAAS3F,KACP,MAAO,CACLsZ,KAAM,QACNsb,MAAO,KACPvV,IAAK,GACLpgB,IAAK,MAKT,SAASo/B,KACP,MAAO,CACL/kB,KAAM,OACNsb,MAAO,KACPvV,IAAK,GACLngB,SAAU,IAQd,SAASooB,GAAK2C,GACZ,MAAO,CACL3Q,KAAM,OACNirB,QAAwB,gBAAfta,EAAM3Q,KACftB,MAAO,KAEPwsB,OAAQva,EAAM2Z,QACd1kC,SAAU,IAQd,SAASsgC,GAASvV,GAChB,MAAO,CACL3Q,KAAM,WAENkrB,OAAQva,EAAM2Z,QACda,QAAS,KACTvlC,SAAU,IAKd,SAAS42B,KACP,MAAO,CACLxc,KAAM,YACNpa,SAAU,IAKd,SAASkhC,KACP,MAAO,CACL9mB,KAAM,SACNpa,SAAU,IAKd,SAAS2K,KACP,MAAO,CACLyP,KAAM,OACN3T,MAAO,IAKX,SAAS6sB,KACP,MAAO,CACLlZ,KAAM,kBA3gCDorB,CAASpuB,EAATouB,CC9GJ,SAAqB1Z,GAC1B,MAAQiC,GAAYjC,KAIpB,OAAOA,ED0GH2Z,CACEr2B,GAAMgI,GAASsW,WAAWH,MHtG3B,WACL,IAOImY,EAPAhtB,EAAS,EACT0e,EAAS,GAGTte,GAAQ,EAIZ,OAGA,SAAsBrS,EAAOgd,EAAUtK,GAErC,MAAMmX,EAAS,GAGf,IAAI5gB,EAGA8U,EAGAmK,EAGAgX,EAGAxkB,EAcJ,IAZA1a,EAAQ2wB,EAAS3wB,EAAMuK,SAASyS,GAChCkL,EAAgB,EAChByI,EAAS,GAELte,IAC0B,QAAxBrS,EAAMia,WAAW,IACnBiO,IAGF7V,OAAQpV,GAGHirB,EAAgBloB,EAAMpD,QAAQ,CAOnC,GANA86B,GAAOyH,UAAYjX,EACnBjf,EAAQyuB,GAAOrkB,KAAKrT,GACpBk/B,EACEj2B,QAAyBhM,IAAhBgM,EAAM1L,MAAsB0L,EAAM1L,MAAQyC,EAAMpD,OAC3D8d,EAAO1a,EAAMia,WAAWilB,IAEnBj2B,EAAO,CACV0nB,EAAS3wB,EAAM5C,MAAM8qB,GACrB,MAGF,GAAa,KAATxN,GAAewN,IAAkBgX,GAAeD,EAClDpV,EAAO1W,MAAM,GACb8rB,OAAmBhiC,OAYnB,OAVIgiC,IACFpV,EAAO1W,MAAM,GACb8rB,OAAmBhiC,GAGjBirB,EAAgBgX,IAClBrV,EAAO1W,KAAKnT,EAAM5C,MAAM8qB,EAAegX,IACvCjtB,GAAUitB,EAAchX,GAGlBxN,GACN,KAAK,EACHmP,EAAO1W,KAAK,OACZlB,IACA,MAGF,KAAK,EAIH,IAHA8L,EAA+B,EAAxBlhB,KAAKyK,KAAK2K,EAAS,GAC1B4X,EAAO1W,MAAM,GAENlB,IAAW8L,GAAM8L,EAAO1W,MAAM,GAErC,MAGF,KAAK,GACH0W,EAAO1W,MAAM,GACblB,EAAS,EACT,MAGF,QACEgtB,GAAmB,EACnBhtB,EAAS,EAKfiW,EAAgBgX,EAAc,EAShC,OANIxsB,IACEusB,GAAkBpV,EAAO1W,MAAM,GAC/Bwd,GAAQ9G,EAAO1W,KAAKwd,GACxB9G,EAAO1W,KAAK,OAGP0W,GGL6BuV,GAAap/B,EAAOgd,GAAU,OAmhCtE,SAASsb,GAAU+G,EAAU9H,GAC3B,IAAIh6B,GAAS,EAEb,OAASA,EAAQg6B,EAAW36B,QAAQ,CAClC,MAAMoD,EAAQu3B,EAAWh6B,GAErBmJ,MAAMsJ,QAAQhQ,GAChBs4B,GAAU+G,EAAUr/B,GAEpBmiB,GAAUkd,EAAUr/B,GAIxB,OAAOq/B,EAQT,SAASld,GAAUkd,EAAUld,GAE3B,IAAI9R,EAEJ,IAAKA,KAAO8R,EACV,GAAI,GAAIjS,KAAKiS,EAAW9R,GAAM,CAC5B,MAAMsR,EAAe,mBAARtR,GAAoC,eAARA,EAInClP,GAHQ,GAAI+O,KAAKmvB,EAAUhvB,GAAOgvB,EAAShvB,QAAOpT,KAGjCoiC,EAAShvB,GAAOsR,EAAO,GAAK,IAC7CtgB,EAAQ8gB,EAAU9R,GAEpBhP,IACEsgB,EAEF0d,EAAShvB,GAAO,IAAIlP,KAASE,GAE7BmN,OAAOwR,OAAO7e,EAAME,KAQ9B,SAASs8B,GAAex8B,EAAME,GAC5B,MAAIF,EACI,IAAI4R,MACR,iBACE5R,EAAKwS,KACL,MACAiF,EAAkB,CAChBvG,MAAOlR,EAAKkR,MACZK,IAAKvR,EAAKuR,MAEZ,0BACArR,EAAMsS,KACN,MACAiF,EAAkB,CAChBvG,MAAOhR,EAAMgR,MACbK,IAAKrR,EAAMqR,MAEb,aAGE,IAAIK,MACR,oCACE1R,EAAMsS,KACN,MACAiF,EAAkB,CAChBvG,MAAOhR,EAAMgR,MACbK,IAAKrR,EAAMqR,MAEb,mBErtCR,OCMe,SAAqB/B,GAkBlCnC,OAAOwR,OAAOtX,KAAM,CAAC4W,OAhBLc,IAEd,MAAMR,EAAmClX,KAAK8T,KAAK,YAEnD,OAAO4b,GACLhY,EACA5R,OAAOwR,OAAO,GAAIJ,EAAUjP,EAAS,CAInC4mB,WAAY7uB,KAAK8T,KAAK,wBAA0B,GAChD2gB,gBAAiBz0B,KAAK8T,KAAK,2BAA6B,UCNrD7W,GAEP,SAOQgO,EAAM7c,EAAOkJ,GAErB,IAAIuS,EAAO,CAACoB,KAAMlN,OAAOkN,IAiBzB,YAda1W,IAAV+C,GAAiC,OAAVA,GACN,kBAAVlJ,IAAsB4P,MAAMsJ,QAAQlZ,GAI5C0X,OAAOwR,OAAOzN,EAAMzb,GAFpBkJ,EAAQlJ,EAKN4P,MAAMsJ,QAAQhQ,GAChBuS,EAAKhZ,SAAWyG,OACG/C,IAAV+C,GAAiC,OAAVA,IAChCuS,EAAKvS,MAAQyG,OAAOzG,IAGfuS,GCOJ,MA+DM+sB,GAOX,SAWYt2B,GACR,QAAa/L,IAAT+L,GAA+B,OAATA,EACxB,OAAOya,GAGT,GAAoB,kBAATza,EACT,OA+ER,SAAqB8c,GACnB,OAAOyZ,GAAY5rB,GAKnB,SAASA,EAAKpB,GACZ,OAAOA,GAAQA,EAAKoB,OAASmS,GAtFlB0Z,CAAYx2B,GAGrB,GAAoB,kBAATA,EACT,OAAOtC,MAAMsJ,QAAQhH,GAc7B,SAAoBy2B,GAElB,MAAMC,EAAS,GACf,IAAIniC,GAAS,EAEb,OAASA,EAAQkiC,EAAM7iC,QACrB8iC,EAAOniC,GAAS+hC,GAAQG,EAAMliC,IAGhC,OAAOgiC,GAAY7pB,GAOnB,SAASA,KAAOyI,GACd,IAAI5gB,GAAS,EAEb,OAASA,EAAQmiC,EAAO9iC,QACtB,GAAI8iC,EAAOniC,GAAO2S,KAAKxH,QAASyV,GAAa,OAAO,EAGtD,OAAO,GArC0BwhB,CAAW32B,GAgDhD,SAAsB8c,GACpB,OAAOyZ,GAAYrd,GAMnB,SAASA,EAAI3P,GAEX,IAAIlC,EAEJ,IAAKA,KAAOyV,EAEV,GAAIvT,EAAKlC,KAASyV,EAAMzV,GAAM,OAAO,EAGvC,OAAO,GAhE6CuvB,CAAa52B,GAG/D,GAAoB,oBAATA,EACT,OAAOu2B,GAAYv2B,GAGrB,MAAM,IAAI+J,MAAM,iDAqFtB,SAASwsB,GAAYzZ,GACnB,OAOA,YAAsB3H,GAEpB,OAAOmD,QAAQwE,EAAM5V,KAAKxH,QAASyV,KAKvC,SAASsF,KACP,OAAO,ECxOF,MAsBMoc,GAOX,SAOY/e,EAAM9X,EAAM82B,EAASziC,GACT,oBAAT2L,GAA0C,oBAAZ82B,IACvCziC,EAAUyiC,EAEVA,EAAU92B,EACVA,EAAO,MAGT,MAAM+2B,EAAKT,GAAQt2B,GACbg3B,EAAO3iC,GAAW,EAAI,GAS5B,SAAS4iC,EAAQ1tB,EAAMhV,EAAO2iC,GAG5B,MAAMlgC,EAAwB,kBAATuS,GAA8B,OAATA,EAAgBA,EAAO,GAEjE,IAAI5b,EAEsB,kBAAfqJ,EAAM2T,OACfhd,EAC2B,kBAAlBqJ,EAAM+wB,QACT/wB,EAAM+wB,QACgB,kBAAf/wB,EAAMrJ,KACbqJ,EAAMrJ,UACNsG,EAENuR,OAAOqB,eAAeswB,EAAO,OAAQ,CACnCngC,MACE,SACMA,EAAM2T,MAAQhd,EAAO,IAAMA,EAAO,IAAM,IAC9C,OAIN,OAAOwpC,EAEP,SAASA,IAEP,IAEIC,EAEAha,EAEAia,EANArlB,EAAS,GAQb,KAAKhS,GAAQ+2B,EAAGxtB,EAAMhV,EAAO2iC,EAAQA,EAAQtjC,OAAS,IAAM,SAC1Doe,EAsCZ,SAAkBhb,GAChB,GAAI0G,MAAMsJ,QAAQhQ,GAChB,OAAOA,EAGT,GAAqB,kBAAVA,EACT,MAAO,CAtIa,KAsIFA,GAGpB,MAAO,CAACA,GA/CWsgC,CAASR,EAAQvtB,EAAM2tB,IAlFxB,QAoFJllB,EAAO,IACT,OAAOA,EAKX,GAAIzI,EAAKhZ,UA9FC,SA8FWyhB,EAAO,GAO1B,IALAoL,GAAU/oB,EAAUkV,EAAKhZ,SAASqD,QAAU,GAAKojC,EAEjDK,EAAeH,EAAQzI,OAAOllB,GAGvB6T,GAAU,GAAKA,EAAS7T,EAAKhZ,SAASqD,QAAQ,CAInD,GAFAwjC,EAAYH,EAAQ1tB,EAAKhZ,SAAS6sB,GAASA,EAAQia,EAAvCJ,GAnGN,QAqGFG,EAAU,GACZ,OAAOA,EAGTha,EAC0B,kBAAjBga,EAAU,GAAkBA,EAAU,GAAKha,EAAS4Z,EAIjE,OAAOhlB,GAvEXilB,CAAQnf,EAAM,KAAM,GAApBmf,IC1CC,MAAME,GAOX,SAOYrf,EAAM9X,EAAM82B,EAASziC,GACT,oBAAT2L,GAA0C,oBAAZ82B,IACvCziC,EAAUyiC,EACVA,EAAU92B,EACVA,EAAO,MAGT62B,GAAa/e,EAAM9X,GAMnB,SAAkBuJ,EAAM2tB,GACtB,MAAM3B,EAAS2B,EAAQA,EAAQtjC,OAAS,GACxC,OAAOkjC,EACLvtB,EACAgsB,EAASA,EAAOhlC,SAAS2E,QAAQqU,GAAQ,KACzCgsB,KAX+BlhC,IC9B5BkjC,GAAa,GAAM,SACnBC,GAAW,GAAM,OAiB9B,SAAS,GAAM7sB,GACb,OAQA,SAAepB,GACb,MAAMsG,EAAStG,GAAQA,EAAKlb,UAAYkb,EAAKlb,SAASsc,IAAU,GAEhE,MAAO,CACLrB,KAAMuG,EAAMvG,MAAQ,KACpBL,OAAQ4G,EAAM5G,QAAU,KACxBmU,OAAQvN,EAAMuN,QAAU,EAAIvN,EAAMuN,OAAS,OCvCjD,MAAM,GAAM,GAAGzW,eA0Cf,SAAS8wB,GAAMzgC,GACb,OAAOyG,OAAOzG,GAAS,IAAIqvB,cCzC7B,MAAM,GAAM,GAAG1f,eAOf,SAAS+wB,GAAQ36B,EAAGwM,GAClB,MAAMiK,EAAOjK,EAAKiK,MAAQ,GAE1B,MACE,UAAWjK,KAET,GAAIrC,KAAKsM,EAAM,UACf,GAAItM,KAAKsM,EAAM,gBACf,GAAItM,KAAKsM,EAAM,cAGVzW,EAAE46B,QAAQpuB,EAAM5M,GAAE,OAAQ4M,EAAKvS,QAGjC+F,EAAEwM,EAAM,MAAO,GAAIxM,EAAGwM,IAOxB,SAAS,GAAIxM,EAAGwM,EAAMgsB,GAC3B,MAAM5qB,EAAOpB,GAAQA,EAAKoB,KAE1B,IAAIqK,EAGJ,IAAKrK,EACH,MAAM,IAAIZ,MAAM,uBAAyBR,EAAO,KAWlD,OAPEyL,EADE,GAAI9N,KAAKnK,EAAE66B,SAAUjtB,GAClB5N,EAAE66B,SAASjtB,GACP5N,EAAE86B,aAAe96B,EAAE86B,YAAYjkB,SAASjJ,GAC5CmtB,GAEA/6B,EAAEg7B,gBAGa,oBAAP/iB,EAAoBA,EAAK0iB,IAAS36B,EAAGwM,EAAMgsB,GAO5D,SAASuC,GAAW/6B,EAAGwM,GAErB,MAAO,aAAcA,EAAO,IAAIA,EAAMhZ,SAAU,GAAIwM,EAAGwM,IAASA,EAO3D,SAAS,GAAIxM,EAAGw4B,GAErB,MAAM5gB,EAAS,GAEf,GAAI,aAAc4gB,EAAQ,CACxB,MAAMyC,EAAQzC,EAAOhlC,SACrB,IAAIgE,GAAS,EAEb,OAASA,EAAQyjC,EAAMpkC,QAAQ,CAC7B,MAAMoe,EAAS,GAAIjV,EAAGi7B,EAAMzjC,GAAQghC,GAEpC,GAAIvjB,EAAQ,CACV,GAAIzd,GAAmC,UAA1ByjC,EAAMzjC,EAAQ,GAAGoW,OACvBjN,MAAMsJ,QAAQgL,IAA2B,SAAhBA,EAAOrH,OACnCqH,EAAOhb,MAAQgb,EAAOhb,MAAM6H,QAAQ,OAAQ,MAGzCnB,MAAMsJ,QAAQgL,IAA2B,YAAhBA,EAAOrH,MAAoB,CACvD,MAAMukB,EAAOld,EAAOzhB,SAAS,GAEzB2+B,GAAsB,SAAdA,EAAKvkB,OACfukB,EAAKl4B,MAAQk4B,EAAKl4B,MAAM6H,QAAQ,OAAQ,KAK1CnB,MAAMsJ,QAAQgL,GAChB2C,EAAOxK,QAAQ6H,GAEf2C,EAAOxK,KAAK6H,KAMpB,OAAO2C,ECjDF,SAASsjB,GAAajhC,GAE3B,MAAMgb,EAAS,GACf,IAAIzd,GAAS,EACT8U,EAAQ,EACR6uB,EAAO,EAEX,OAAS3jC,EAAQyC,EAAMpD,QAAQ,CAC7B,MAAM8d,EAAO1a,EAAMia,WAAW1c,GAG9B,IAAIsK,EAAU,GAEd,GACW,KAAT6S,GACAkI,EAAkB5iB,EAAMia,WAAW1c,EAAQ,KAC3CqlB,EAAkB5iB,EAAMia,WAAW1c,EAAQ,IAE3C2jC,EAAO,OAEJ,GAAIxmB,EAAO,IACT,oBAAoB1R,KAAKvC,OAAO6c,aAAa5I,MAChD7S,EAAUpB,OAAO6c,aAAa5I,SAG7B,GAAIA,EAAO,OAASA,EAAO,MAAO,CACrC,MAAMqD,EAAO/d,EAAMia,WAAW1c,EAAQ,GAElCmd,EAAO,OAASqD,EAAO,OAASA,EAAO,OACzClW,EAAUpB,OAAO6c,aAAa5I,EAAMqD,GACpCmjB,EAAO,GAGPr5B,EAAU,cAIZA,EAAUpB,OAAO6c,aAAa5I,GAG5B7S,IACFmT,EAAO7H,KAAKnT,EAAM5C,MAAMiV,EAAO9U,GAAQ4jC,mBAAmBt5B,IAC1DwK,EAAQ9U,EAAQ2jC,EAAO,EACvBr5B,EAAU,IAGRq5B,IACF3jC,GAAS2jC,EACTA,EAAO,GAIX,OAAOlmB,EAAOrU,KAAK,IAAM3G,EAAM5C,MAAMiV,GC/FhC,SAAS,GAAK2uB,EAAOI,GAE1B,MAAMpmB,EAAS,GACf,IAAIzd,GAAS,EAMb,IAJI6jC,GACFpmB,EAAO7H,KAAKxN,GAAE,OAAQ,SAGfpI,EAAQyjC,EAAMpkC,QACjBW,GAAOyd,EAAO7H,KAAKxN,GAAE,OAAQ,OACjCqV,EAAO7H,KAAK6tB,EAAMzjC,IAOpB,OAJI6jC,GAASJ,EAAMpkC,OAAS,GAC1Boe,EAAO7H,KAAKxN,GAAE,OAAQ,OAGjBqV,ECpBF,SAASqmB,GAAkBt7B,EAAGwM,GACnC,MAAM+uB,EAAK76B,OAAO8L,EAAKgd,YACjBgS,EAASN,GAAaK,EAAG15B,eACzBrK,EAAQwI,EAAEy7B,cAActjC,QAAQojC,GAEtC,IAAIG,GAEW,IAAXlkC,GACFwI,EAAEy7B,cAAcruB,KAAKmuB,GACrBv7B,EAAE27B,eAAeJ,GAAM,EACvBG,EAAU17B,EAAEy7B,cAAc5kC,SAE1BmJ,EAAE27B,eAAeJ,KACjBG,EAAUlkC,EAAQ,GAGpB,MAAMokC,EAAe57B,EAAE27B,eAAeJ,GAEtC,OAAOv7B,EAAEwM,EAAM,MAAO,CACpBxM,EACEwM,EAAKlb,SACL,IACA,CACEwkB,KAAM,IAAM9V,EAAE67B,cAAgB,MAAQL,EACtCD,GACEv7B,EAAE67B,cACF,SACAL,GACCI,EAAe,EAAI,IAAMA,EAAe,IAC3CE,iBAAiB,EACjBC,gBAAiB,kBAEnB,CAACn8B,GAAE,OAAQc,OAAOg7B,QC3BjB,SAASM,GAAOh8B,EAAGwM,GACxB,MAAMyvB,EAAUzvB,EAAKisB,cACrB,IAAIyD,EAAS,IAQb,GANgB,cAAZD,EACFC,GAAU,KACW,SAAZD,IACTC,GAAU,KAAO1vB,EAAKrP,OAASqP,EAAKgd,YAAc,KAGlC,mBAAdhd,EAAKoB,KACP,OAAOhO,GAAE,OAAQ,KAAO4M,EAAKjZ,IAAM2oC,GAGrC,MAAMC,EAAW,GAAIn8B,EAAGwM,GAClB2lB,EAAOgK,EAAS,GAElBhK,GAAsB,SAAdA,EAAKvkB,KACfukB,EAAKl4B,MAAQ,IAAMk4B,EAAKl4B,MAExBkiC,EAASlgB,QAAQrc,GAAE,OAAQ,MAG7B,MAAMojB,EAAOmZ,EAASA,EAAStlC,OAAS,GAQxC,OANImsB,GAAsB,SAAdA,EAAKpV,KACfoV,EAAK/oB,OAASiiC,EAEdC,EAAS/uB,KAAKxN,GAAE,OAAQs8B,IAGnBC,EC6DT,SAASC,GAAc5vB,GACrB,MAAMssB,EAAStsB,EAAKssB,OAEpB,YAAkB5hC,IAAX4hC,GAAmC,OAAXA,EAC3BtsB,EAAKhZ,SAASqD,OAAS,EACvBiiC,ECrEN,SAASuD,GAASpiC,EAAOqS,EAAOK,GAC9B,IAAIyY,EAAa,EACbE,EAAWrrB,EAAMpD,OAErB,GAAIyV,EAAO,CACT,IAAIqI,EAAO1a,EAAMqiC,YAAYlX,GAE7B,KApDQ,IAoDDzQ,GAnDG,KAmDaA,GACrByQ,IACAzQ,EAAO1a,EAAMqiC,YAAYlX,GAI7B,GAAIzY,EAAK,CACP,IAAIgI,EAAO1a,EAAMqiC,YAAYhX,EAAW,GAExC,KA7DQ,IA6DD3Q,GA5DG,KA4DaA,GACrB2Q,IACA3Q,EAAO1a,EAAMqiC,YAAYhX,EAAW,GAIxC,OAAOA,EAAWF,EAAanrB,EAAM5C,MAAM+tB,EAAYE,GAAY,GC5C9D,MAAMuV,GAAW,CACtB0B,WCZK,SAAoBv8B,EAAGwM,GAC5B,OAAOxM,EAAEwM,EAAM,aAAc,GAAK,GAAIxM,EAAGwM,IAAO,KDYhDgwB,MEXK,SAAmBx8B,EAAGwM,GAC3B,MAAO,CAACxM,EAAEwM,EAAM,MAAO5M,GAAE,OAAQ,QFWjC+U,KGdK,SAAc3U,EAAGwM,GACtB,MAAMvS,EAAQuS,EAAKvS,MAAQuS,EAAKvS,MAAQ,KAAO,GAGzCq+B,EAAO9rB,EAAK8rB,MAAQ9rB,EAAK8rB,KAAKp1B,MAAM,uBAEpCnS,EAAQ,GAEVunC,IACFvnC,EAAM2C,UAAY,CAAC,YAAc4kC,IAGnC,MAAM3jB,EAAO3U,EAAEwM,EAAM,OAAQzb,EAAO,CAAC6O,GAAE,OAAQ3F,KAM/C,OAJIuS,EAAKygB,OACPtY,EAAK8B,KAAO,CAACwW,KAAMzgB,EAAKygB,OAGnBjtB,EAAEwM,EAAKlb,SAAU,MAAO,CAACqjB,KHHhC8nB,OIhBK,SAAuBz8B,EAAGwM,GAC/B,OAAOxM,EAAEwM,EAAM,MAAO,GAAIxM,EAAGwM,KJgB7BgnB,SKjBK,SAAkBxzB,EAAGwM,GAC1B,OAAOxM,EAAEwM,EAAM,KAAM,GAAIxM,EAAGwM,KLiB5B8uB,kBAAiB,GACjBoB,SMZK,SAAkB18B,EAAGwM,GAC1B,MAAMmwB,EAAe38B,EAAE28B,aACvB,IAAIC,EAAK,EAET,KAAOA,KAAMD,GAAcC,IAE3B,MAAMpT,EAAa9oB,OAAOk8B,GAS1B,OAPAD,EAAanT,GAAc,CACzB5b,KAAM,qBACN4b,aACAh2B,SAAU,CAAC,CAACoa,KAAM,YAAapa,SAAUgZ,EAAKhZ,WAC9ClC,SAAUkb,EAAKlb,UAGVgqC,GAAkBt7B,EAAG,CAC1B4N,KAAM,oBACN4b,aACAl4B,SAAUkb,EAAKlb,YNLjBi5B,QOpBK,SAAiBvqB,EAAGwM,GACzB,OAAOxM,EAAEwM,EAAM,IAAMA,EAAK+rB,MAAO,GAAIv4B,EAAGwM,KPoBxCmnB,KQnBK,SAAc3zB,EAAGwM,GACtB,OAAOxM,EAAE68B,UAAY78B,EAAE46B,QAAQpuB,EAAM5M,GAAE,MAAO4M,EAAKvS,QAAU,MRmB7D6iC,eSpBK,SAAwB98B,EAAGwM,GAChC,MAAM2Z,EAAMnmB,EAAEupB,WAAW/c,EAAKgd,YAE9B,IAAKrD,EACH,OAAO6V,GAAOh8B,EAAGwM,GAInB,MAAMzb,EAAQ,CAAC+C,IAAKonC,GAAa/U,EAAIxS,KAAO,IAAKpgB,IAAKiZ,EAAKjZ,KAM3D,OAJkB,OAAd4yB,EAAI+C,YAAgChyB,IAAdivB,EAAI+C,QAC5Bn4B,EAAMm4B,MAAQ/C,EAAI+C,OAGblpB,EAAEwM,EAAM,MAAOzb,ITOtBuD,MUtBK,SAAe0L,EAAGwM,GAEvB,MAAMzb,EAAQ,CAAC+C,IAAKonC,GAAa1uB,EAAKmH,KAAMpgB,IAAKiZ,EAAKjZ,KAMtD,OAJmB,OAAfiZ,EAAK0c,YAAiChyB,IAAfsV,EAAK0c,QAC9Bn4B,EAAMm4B,MAAQ1c,EAAK0c,OAGdlpB,EAAEwM,EAAM,MAAOzb,IVetBgsC,WWxBK,SAAoB/8B,EAAGwM,GAC5B,OAAOxM,EAAEwM,EAAM,OAAQ,CAAC5M,GAAE,OAAQ4M,EAAKvS,MAAM6H,QAAQ,YAAa,SXwBlEk7B,cYtBK,SAAuBh9B,EAAGwM,GAC/B,MAAM2Z,EAAMnmB,EAAEupB,WAAW/c,EAAKgd,YAE9B,IAAKrD,EACH,OAAO6V,GAAOh8B,EAAGwM,GAInB,MAAMzb,EAAQ,CAAC+kB,KAAMolB,GAAa/U,EAAIxS,KAAO,KAM7C,OAJkB,OAAdwS,EAAI+C,YAAgChyB,IAAdivB,EAAI+C,QAC5Bn4B,EAAMm4B,MAAQ/C,EAAI+C,OAGblpB,EAAEwM,EAAM,IAAKzb,EAAO,GAAIiP,EAAGwM,KZSlCmmB,KaxBK,SAAc3yB,EAAGwM,GAEtB,MAAMzb,EAAQ,CAAC+kB,KAAMolB,GAAa1uB,EAAKmH,MAMvC,OAJmB,OAAfnH,EAAK0c,YAAiChyB,IAAfsV,EAAK0c,QAC9Bn4B,EAAMm4B,MAAQ1c,EAAK0c,OAGdlpB,EAAEwM,EAAM,IAAKzb,EAAO,GAAIiP,EAAGwM,KbiBlCsnB,SFrBK,SAAkB9zB,EAAGwM,EAAMgsB,GAChC,MAAMvjB,EAAS,GAAIjV,EAAGwM,GAChB6uB,EAAQ7C,EA0EhB,SAAmBhsB,GACjB,IAAI6uB,EAAQ7uB,EAAKssB,OACjB,MAAMtlC,EAAWgZ,EAAKhZ,SACtB,IAAIgE,GAAS,EAEb,MAAQ6jC,KAAW7jC,EAAQhE,EAASqD,QAClCwkC,EAAQe,GAAc5oC,EAASgE,IAGjC,OAAO+jB,QAAQ8f,GAnFQ4B,CAAUzE,GAAU4D,GAAc5vB,GAEnDzb,EAAQ,GAERyM,EAAU,GAEhB,GAA4B,mBAAjBgP,EAAKusB,QAAuB,CAErC,IAAI3O,EAGFnV,EAAO,IACY,YAAnBA,EAAO,GAAGrH,MACY,MAAtBqH,EAAO,GAAG+V,QAEVZ,EAAYnV,EAAO,IAEnBmV,EAAYpqB,EAAE,KAAM,IAAK,IACzBiV,EAAOgH,QAAQmO,IAGbA,EAAU52B,SAASqD,OAAS,GAC9BuzB,EAAU52B,SAASyoB,QAAQrc,GAAE,OAAQ,MAGvCwqB,EAAU52B,SAASyoB,QACjBjc,EAAE,KAAM,QAAS,CACf4N,KAAM,WACNmrB,QAASvsB,EAAKusB,QACdz6B,UAAU,KAMdvN,EAAM2C,UAAY,CAAC,kBAGrB,IAAI8D,GAAS,EAEb,OAASA,EAAQyd,EAAOpe,QAAQ,CAC9B,MAAMF,EAAQse,EAAOzd,IAInB6jC,GACU,IAAV7jC,GACe,YAAfb,EAAMiX,MACY,MAAlBjX,EAAMq0B,UAENxtB,EAAQ4P,KAAKxN,GAAE,OAAQ,OAGN,YAAfjJ,EAAMiX,MAAwC,MAAlBjX,EAAMq0B,SAAoBqQ,EAGxD79B,EAAQ4P,KAAKzW,GAFb6G,EAAQ4P,QAAQzW,EAAMnD,UAM1B,MAAMwvB,EAAO/N,EAAOA,EAAOpe,OAAS,GAOpC,OAJImsB,IAASqY,GAAW,YAAarY,GAA0B,MAAjBA,EAAKgI,SACjDxtB,EAAQ4P,KAAKxN,GAAE,OAAQ,OAGlBI,EAAEwM,EAAM,KAAMzb,EAAOyM,IE/C5Boe,KcxBK,SAAc5b,EAAGwM,GAEtB,MAAMzb,EAAQ,GACRH,EAAO4b,EAAKqsB,QAAU,KAAO,KAC7B/c,EAAQ,GAAI9b,EAAGwM,GACrB,IAAIhV,GAAS,EAOb,IAL0B,kBAAfgV,EAAKF,OAAqC,IAAfE,EAAKF,QACzCvb,EAAMub,MAAQE,EAAKF,SAIZ9U,EAAQskB,EAAMjlB,QAAQ,CAC7B,MAAMioB,EAAOhD,EAAMtkB,GAEnB,GACgB,YAAdsnB,EAAKlR,MACY,OAAjBkR,EAAKkM,SACLlM,EAAKoe,YACLv8B,MAAMsJ,QAAQ6U,EAAKoe,WAAWxpC,YAC9BorB,EAAKoe,WAAWxpC,UAAUmjB,SAAS,kBACnC,CACA9lB,EAAM2C,UAAY,CAAC,sBACnB,OAIJ,OAAOsM,EAAEwM,EAAM5b,EAAMG,EAAO,GAAK+qB,GAAO,KdFxCsO,Ue7BK,SAAmBpqB,EAAGwM,GAC3B,OAAOxM,EAAEwM,EAAM,IAAK,GAAIxM,EAAGwM,Kf6B3Btb,KgB5BK,SAAc8O,EAAGwM,GAEtB,OAAOxM,EAAE46B,QAAQpuB,EAAM5M,GAAE,OAAQ,GAAK,GAAII,EAAGwM,OhB2B7CkoB,OiB/BK,SAAgB10B,EAAGwM,GACxB,OAAOxM,EAAEwM,EAAM,SAAU,GAAIxM,EAAGwM,KjB+BhC2wB,MkB5BK,SAAen9B,EAAGwM,GACvB,MAAM4wB,EAAO5wB,EAAKhZ,SAClB,IAAIgE,GAAS,EACb,MAAM6lC,EAAQ7wB,EAAK6wB,OAAS,GAEtBpoB,EAAS,GAEf,OAASzd,EAAQ4lC,EAAKvmC,QAAQ,CAC5B,MAAM4B,EAAM2kC,EAAK5lC,GAAOhE,SAClB5C,EAAiB,IAAV4G,EAAc,KAAO,KAE5B8lC,EAAM,GACZ,IAAIC,GAAa,EACjB,MAAM1mC,EAAS2V,EAAK6wB,MAAQA,EAAMxmC,OAAS4B,EAAI5B,OAE/C,OAAS0mC,EAAY1mC,GAAQ,CAC3B,MAAM2mC,EAAO/kC,EAAI8kC,GACjBD,EAAIlwB,KACFpN,EAAEw9B,EAAM5sC,EAAM,CAACysC,MAAOA,EAAME,IAAaC,EAAO,GAAIx9B,EAAGw9B,GAAQ,KAInEvoB,EAAOzd,GAASwI,EAAEo9B,EAAK5lC,GAAQ,KAAM,GAAK8lC,GAAK,IAGjD,OAAOt9B,EACLwM,EACA,QACA,GACE,CAACxM,EAAEiV,EAAO,GAAG3jB,SAAU,QAAS,GAAK,CAAC2jB,EAAO,KAAK,KAAQyc,OACxDzc,EAAO,GACHjV,EACE,CACEsM,MAAOkuB,GAAWvlB,EAAO,IACzBtI,IAAK8tB,GAASxlB,EAAOA,EAAOpe,OAAS,KAEvC,QACA,GAAKoe,EAAO5d,MAAM,IAAI,IAExB,KAEN,KlBZJ8G,KmBhCK,SAAc6B,EAAGwM,GACtB,OAAOxM,EAAE46B,QAAQpuB,EAAM5M,GAAE,OpBDpB,SAAmB3F,GACxB,MAAM2S,EAASlM,OAAOzG,GAChB03B,EAAS,YACf,IAAIzuB,EAAQyuB,EAAOrkB,KAAKV,GACpB6wB,EAAO,EAEX,MAAMrxB,EAAQ,GAEd,KAAOlJ,GACLkJ,EAAMgB,KACJivB,GAASzvB,EAAOvV,MAAMomC,EAAMv6B,EAAM1L,OAAQimC,EAAO,GAAG,GACpDv6B,EAAM,IAGRu6B,EAAOv6B,EAAM1L,MAAQ0L,EAAM,GAAGrM,OAC9BqM,EAAQyuB,EAAOrkB,KAAKV,GAKtB,OAFAR,EAAMgB,KAAKivB,GAASzvB,EAAOvV,MAAMomC,GAAOA,EAAO,GAAG,IAE3CrxB,EAAMxL,KAAK,IoBnBe88B,CAAUh9B,OAAO8L,EAAKvS,WnBgCvD6sB,coBlCK,SAAuB9mB,EAAGwM,GAC/B,OAAOxM,EAAEwM,EAAM,OpBkCfmxB,KAAMC,GACNC,KAAMD,GACNrU,WAAYqU,GACZE,mBAAoBF,IAItB,SAASA,KACP,OAAO,KqBuFT,MAAM,GAAM,GAAGh0B,eAYf,SAASswB,GAAQnf,EAAMnQ,GACrB,MAAMiP,EAAWjP,GAAW,GACtBiyB,EAAYhjB,EAASkkB,qBAAsB,EAE3CpB,EAAe,GAmCrB,OAjCA38B,EAAE68B,UAAYA,EACd78B,EAAE67B,mBAC2B3kC,IAA3B2iB,EAASgiB,eAA0D,OAA3BhiB,EAASgiB,cAC7C,gBACAhiB,EAASgiB,cACf77B,EAAEg+B,cAAgBnkB,EAASmkB,eAAiB,YAC5Ch+B,EAAEi+B,qBAAuBpkB,EAASokB,sBAAwB,KAC1Dj+B,EAAEk+B,wBAA0BrkB,EAASqkB,yBAA2B,CAC9DxqC,UAAW,CAAC,YAEdsM,EAAEm+B,kBAAoBtkB,EAASskB,mBAAqB,kBACpDn+B,EAAEupB,W7B1JG,SAAqB/c,GAE1B,MAAM4xB,EAAQ31B,OAAOme,OAAO,MAE5B,IAAKpa,IAASA,EAAKoB,KACjB,MAAM,IAAIZ,MAAM,wCAUlB,OAPAotB,GAAM5tB,EAAM,cAAe+c,IACzB,MAAMgS,EAAKb,GAAMnR,EAAWC,YACxB+R,IAAO,GAAIpxB,KAAKi0B,EAAO7C,KACzB6C,EAAM7C,GAAMhS,MAYhB,SAAoBC,GAClB,MAAM+R,EAAKb,GAAMlR,GACjB,OAAO+R,GAAM,GAAIpxB,KAAKi0B,EAAO7C,GAAM6C,EAAM7C,GAAM,M6BiIlC8C,CAAYtjB,GAC3B/a,EAAE28B,aAAeA,EAEjB38B,EAAEy7B,cAAgB,GAElBz7B,EAAE27B,eAAiB,GACnB37B,EAAE46B,QAAUA,EACZ56B,EAAE66B,SAAW,IAAIA,MAAahhB,EAASghB,UACvC76B,EAAEg7B,eAAiBnhB,EAASmhB,eAC5Bh7B,EAAE86B,YAAcjhB,EAASihB,YAEzBV,GAAMrf,EAAM,sBAAuBwO,IACjC,MAAMgS,EAAK76B,OAAO6oB,EAAWC,YAAYF,cAIpC,GAAInf,KAAKwyB,EAAcpB,KAC1BoB,EAAapB,GAAMhS,MAKhBvpB,EASP,SAAS46B,EAAQx/B,EAAME,GAErB,GAAIF,GAAQ,SAAUA,GAAQA,EAAKqb,KAAM,CAEvC,MAAMA,EAAOrb,EAAKqb,KAEdA,EAAK6nB,QACY,YAAfhjC,EAAMsS,OACRtS,EAAQ,CACNsS,KAAM,UACNod,QAAS,GACTkS,WAAY,GACZ1pC,SAAU,KAId8H,EAAM0vB,QAAUvU,EAAK6nB,OAGJ,YAAfhjC,EAAMsS,MAAsB6I,EAAK8nB,cACnCjjC,EAAM4hC,WAAa,IAAI5hC,EAAM4hC,cAAezmB,EAAK8nB,cAG/C,aAAcjjC,GAASA,EAAM9H,UAAYijB,EAAK+nB,YAChDljC,EAAM9H,SAAWijB,EAAK+nB,WAI1B,GAAIpjC,EAAM,CACR,MAAMqjC,EAAM,SAAUrjC,EAAOA,EAAO,CAAC9J,SAAU8J,IClN3BoR,EDoNLiyB,ICjNhBjyB,EAAKlb,UACLkb,EAAKlb,SAASgb,OACdE,EAAKlb,SAASgb,MAAMC,MACpBC,EAAKlb,SAASgb,MAAMJ,QACpBM,EAAKlb,SAASqb,KACdH,EAAKlb,SAASqb,IAAIJ,MAClBC,EAAKlb,SAASqb,IAAIT,SD6Mf5Q,EAAMhK,SAAW,CAACgb,MAAOkuB,GAAWiE,GAAM9xB,IAAK8tB,GAASgE,KCtNzD,IAAmBjyB,ED0NtB,OAAOlR,EAQT,SAAS0E,EAAEwM,EAAMwe,EAASj6B,EAAOyC,GAO/B,OANImN,MAAMsJ,QAAQlZ,KAChByC,EAAWzC,EACXA,EAAQ,IAIH6pC,EAAQpuB,EAAM,CACnBoB,KAAM,UACNod,UACAkS,WAAYnsC,GAAS,GACrByC,SAAUA,GAAY,MAYrB,SAASkrC,GAAO3jB,EAAMnQ,GAC3B,MAAM5K,EAAIk6B,GAAQnf,EAAMnQ,GAClB4B,EAAO,GAAIxM,EAAG+a,EAAM,MACpB4jB,EEjQD,SAAgB3+B,GACrB,IAAIxI,GAAS,EAEb,MAAMonC,EAAY,GAElB,OAASpnC,EAAQwI,EAAEy7B,cAAc5kC,QAAQ,CACvC,MAAMsvB,EAAMnmB,EAAE28B,aAAa38B,EAAEy7B,cAAcjkC,GAAO8xB,eAElD,IAAKnD,EACH,SAGF,MAAMhrB,EAAU,GAAI6E,EAAGmmB,GACjBoV,EAAK76B,OAAOylB,EAAIqD,YAChBgS,EAASN,GAAaK,EAAG15B,eAC/B,IAAIg9B,EAAiB,EAErB,MAAMC,EAAiB,GAEvB,OAASD,GAAkB7+B,EAAE27B,eAAeJ,IAAK,CAE/C,MAAMwD,EAAgB,CACpBnxB,KAAM,UACNod,QAAS,IACTkS,WAAY,CACVpnB,KACE,IACA9V,EAAE67B,cACF,SACAL,GACCqD,EAAiB,EAAI,IAAMA,EAAiB,IAC/CG,qBAAqB,EACrBtrC,UAAW,CAAC,yBACZurC,UAAWj/B,EAAEm+B,mBAEf3qC,SAAU,CAAC,CAACoa,KAAM,OAAQ3T,MAAO,YAG/B4kC,EAAiB,GACnBE,EAAcvrC,SAAS4Z,KAAK,CAC1BQ,KAAM,UACNod,QAAS,MACTx3B,SAAU,CAAC,CAACoa,KAAM,OAAQ3T,MAAOyG,OAAOm+B,OAIxCC,EAAejoC,OAAS,GAC1BioC,EAAe1xB,KAAK,CAACQ,KAAM,OAAQ3T,MAAO,MAG5C6kC,EAAe1xB,KAAK2xB,GAGtB,MAAM/b,EAAO7nB,EAAQA,EAAQtE,OAAS,GAEtC,GAAImsB,GAAsB,YAAdA,EAAKpV,MAAuC,MAAjBoV,EAAKgI,QAAiB,CAC3D,MAAMkU,EAAWlc,EAAKxvB,SAASwvB,EAAKxvB,SAASqD,OAAS,GAClDqoC,GAA8B,SAAlBA,EAAStxB,KACvBsxB,EAASjlC,OAAS,IAElB+oB,EAAKxvB,SAAS4Z,KAAK,CAACQ,KAAM,OAAQ3T,MAAO,MAG3C+oB,EAAKxvB,SAAS4Z,QAAQ0xB,QAEtB3jC,EAAQiS,QAAQ0xB,GAIlB,MAAMhL,EAAW,CACflmB,KAAM,UACNod,QAAS,KACTkS,WAAY,CAAC3B,GAAIv7B,EAAE67B,cAAgB,MAAQL,GAC3ChoC,SAAU,GAAK2H,GAAS,IAGtBgrB,EAAI70B,WACNwiC,EAASxiC,SAAW60B,EAAI70B,UAG1BstC,EAAUxxB,KAAK0mB,GAGjB,OAAyB,IAArB8K,EAAU/nC,OACL,KAGF,CACL+W,KAAM,UACNod,QAAS,UACTkS,WAAY,CAACiC,eAAe,EAAMzrC,UAAW,CAAC,cAC9CF,SAAU,CACR,CACEoa,KAAM,UACNod,QAAShrB,EAAEi+B,qBACXf,WAAY,IACP1nB,KAAK5S,MAAM4S,KAAKC,UAAUzV,EAAEk+B,0BAC/B3C,GAAI,kBAEN/nC,SAAU,CAACoM,GAAE,OAAQI,EAAEg+B,iBAEzB,CAACpwB,KAAM,OAAQ3T,MAAO,MACtB,CACE2T,KAAM,UACNod,QAAS,KACTkS,WAAY,GACZ1pC,SAAU,GAAKorC,GAAW,IAE5B,CAAChxB,KAAM,OAAQ3T,MAAO,QFqJbmlC,CAAOp/B,GASpB,OAPI2+B,GAIFnyB,EAAKhZ,SAAS4Z,KAAKxN,GAAE,OAAQ,MAAO++B,GAG/Bh+B,MAAMsJ,QAAQuC,GAAQ,CAACoB,KAAM,OAAQpa,SAAUgZ,GAAQA,EG5OhE,OARE,SACY6O,EAAazQ,GACrB,OAAOyQ,GAAe,QAASA,EAcrC,SAAgBA,EAAazQ,GAC3B,MAAO,CAAC4B,EAAMkH,EAAMsE,KAClBqD,EAAY1D,IAAI+mB,GAAOlyB,EAAM5B,GAAU8I,GAAO1a,IAC5Cgf,EAAKhf,OAhBDqmC,CAAOhkB,EAAazQ,GA2B9B,SAAgBA,GAEd,OAAQ4B,GAASkyB,GAAOlyB,EAAM5B,GA5BtB00B,CAAOjkB,GAAezQ,I,gBCnCzB,MAAM20B,GAOX90B,YAAYwD,EAAUuxB,EAAQC,GAC5B98B,KAAKsL,SAAWA,EAChBtL,KAAK68B,OAASA,EACVC,IACF98B,KAAK88B,MAAQA,ICLZ,SAASC,GAAMrB,EAAaoB,GAEjC,MAAMxxB,EAAW,GAEXuxB,EAAS,GACf,IAAIhoC,GAAS,EAEb,OAASA,EAAQ6mC,EAAYxnC,QAC3B4R,OAAOwR,OAAOhM,EAAUowB,EAAY7mC,GAAOyW,UAC3CxF,OAAOwR,OAAOulB,EAAQnB,EAAY7mC,GAAOgoC,QAG3C,OAAO,IAAID,GAAOtxB,EAAUuxB,EAAQC,GCpB/B,SAAS,GAAUxlC,GACxB,OAAOA,EAAM4H,cFkBf09B,GAAO18B,UAAUoL,SAAW,GAE5BsxB,GAAO18B,UAAU28B,OAAS,GAE1BD,GAAO18B,UAAU48B,MAAQ,KG3BlB,MAAME,GAMXl1B,YAAYwD,EAAU2xB,GAEpBj9B,KAAKsL,SAAWA,EAEhBtL,KAAKi9B,UAAYA,GAKrBD,GAAK98B,UAAU48B,MAAQ,KACvBE,GAAK98B,UAAUg9B,SAAU,EACzBF,GAAK98B,UAAUi9B,YAAa,EAC5BH,GAAK98B,UAAUk9B,mBAAoB,EACnCJ,GAAK98B,UAAU0M,QAAS,EACxBowB,GAAK98B,UAAUm9B,gBAAiB,EAChCL,GAAK98B,UAAUo9B,gBAAiB,EAChCN,GAAK98B,UAAUq9B,uBAAwB,EACvCP,GAAK98B,UAAUs9B,iBAAkB,EACjCR,GAAK98B,UAAU8mB,SAAU,ECxBzB,IAAIyW,GAAS,EAEN,MAAM,GAAUC,KACVP,GAAaO,KACbN,GAAoBM,KACpB9wB,GAAS8wB,KACTJ,GAAiBI,KACjBL,GAAiBK,KACjBH,GAAwBG,KAErC,SAASA,KACP,OAAO,KAAOD,GCNhB,MAAMzG,GAASlxB,OAAOC,KAAK,GAEpB,MAAM43B,WAAoBX,GAQ/Bl1B,YAAYwD,EAAU2xB,EAAWW,EAAMd,GACrC,IAAIjoC,GAAS,EAMb,GAJA2b,MAAMlF,EAAU2xB,GAEhBY,GAAK79B,KAAM,QAAS88B,GAEA,kBAATc,EACT,OAAS/oC,EAAQmiC,GAAO9iC,QAAQ,CAC9B,MAAMkpB,EAAQ4Z,GAAOniC,GACrBgpC,GAAK79B,KAAMg3B,GAAOniC,IAAS+oC,EAAO,EAAMxgB,MAAY,EAAMA,MAalE,SAASygB,GAAK5oB,EAAQtN,EAAKrQ,GACrBA,IAEF2d,EAAOtN,GAAOrQ,GAVlBqmC,GAAYz9B,UAAU8mB,SAAU,ECbhC,MAAM,GAAM,GAAG/f,eAMR,SAASgd,GAAO2C,GAErB,MAAMtb,EAAW,GAEXuxB,EAAS,GAEf,IAAI1xB,EAEJ,IAAKA,KAAQyb,EAAW2T,WACtB,GAAI,GAAI/yB,KAAKof,EAAW2T,WAAYpvB,GAAO,CACzC,MAAM7T,EAAQsvB,EAAW2T,WAAWpvB,GAC9BoJ,EAAO,IAAIopB,GACfxyB,EACAyb,EAAW9tB,UAAU8tB,EAAWkX,YAAc,GAAI3yB,GAClD7T,EACAsvB,EAAWkW,OAIXlW,EAAW4W,iBACX5W,EAAW4W,gBAAgBtpB,SAAS/I,KAEpCoJ,EAAKipB,iBAAkB,GAGzBlyB,EAASH,GAAQoJ,EAEjBsoB,EAAO,GAAU1xB,IAASA,EAC1B0xB,EAAO,GAAUtoB,EAAK0oB,YAAc9xB,EAIxC,OAAO,IAAIyxB,GAAOtxB,EAAUuxB,EAAQjW,EAAWkW,OCtD1C,MAAMiB,GAAQ9Z,GAAO,CAC1B6Y,MAAO,QACPhkC,UAAS,CAAChB,EAAGqT,IACJ,SAAWA,EAAKzW,MAAM,GAAGwK,cAElCq7B,WAAY,CACVyD,aAAc,KACdC,aAAc,KACdC,UAAW,KACXC,UAAW,KACXC,UAAW,KACXC,WAAY,KACZC,UAAW,QCZFC,GAAMta,GAAO,CACxB6Y,MAAO,MACPhkC,UAAS,CAAChB,EAAGqT,IACJ,OAASA,EAAKzW,MAAM,GAAGwK,cAEhCq7B,WAAY,CAACiE,QAAS,KAAMC,QAAS,KAAMC,SAAU,QCFhD,SAASC,GAAuBb,EAAYb,GACjD,OAAOA,KAAaa,EAAaA,EAAWb,GAAaA,ECCpD,SAAS2B,GAAyBd,EAAYxyB,GACnD,OAAOqzB,GAAuBb,EAAYxyB,EAASpM,eCL9C,MAAM2/B,GAAQ5a,GAAO,CAC1B6Y,MAAO,QACPgB,WAAY,CAACgB,WAAY,eACzBhmC,UAAW8lC,GACXrE,WAAY,CAACsE,MAAO,KAAME,WAAY,QCJ3BC,GAAO/a,GAAO,CACzBnrB,UAAS,CAAChB,EAAGqT,IACK,SAATA,EAAkBA,EAAO,QAAUA,EAAKzW,MAAM,GAAGwK,cAE1Dq7B,WAAY,CACV0E,qBAAsB,KACtBC,WAAY/B,GACZgC,iBAAkB,KAClBC,SAAUjC,GACVkC,YAAalC,GACbmC,aAAc1yB,GACd2yB,aAAc3yB,GACd4yB,YAAa5yB,GACb6yB,aAAcnC,GACdoC,YAAa,KACbtG,gBAAiBkE,GACjBqC,YAAa,KACbC,aAAczC,GACd0C,eAAgBvC,GAChBwC,iBAAkB,KAClBC,aAAc5C,GACd6C,WAAY1C,GACZ2C,YAAa9C,GACb+C,aAAc,KACdC,WAAYhD,GACZiD,YAAa,KACbC,iBAAkB,KAClB/D,UAAW,KACXgE,eAAgBhD,GAChBiD,UAAW3zB,GACX4zB,SAAU,KACVC,UAAWtD,GACXuD,cAAevD,GACfwD,oBAAqBxD,GACrByD,gBAAiB,KACjBC,SAAUvD,GACVwD,gBAAiB,KACjBC,aAAcn0B,GACdo0B,YAAa7D,GACb8D,aAAc9D,GACd+D,aAAc,KACdC,aAAchE,GACdiE,oBAAqB9D,GACrB+D,aAAcz0B,GACd00B,aAAc10B,GACd20B,YAAa30B,GACb40B,aAAcrE,GACdsE,YAAa70B,GACb80B,SAAU,KACVC,aAAc/0B,GACdg1B,aAAch1B,GACdi1B,aAAcj1B,GACdk1B,cAAe,KACfnsC,KAAM,QC7CG,GAAOsuB,GAAO,CACzB6Y,MAAO,OACPgB,WAAY,CACViE,cAAe,iBACfC,UAAW,QACXC,QAAS,MACTC,UAAW,cAEbppC,UAAW8lC,GACXpB,gBAAiB,CAAC,UAAW,WAAY,QAAS,YAClDjD,WAAY,CAEV4H,KAAM,KACNC,OAAQ/E,GACRgF,cAAe/E,GACfgF,UAAWhF,GACXzmC,OAAQ,KACR0rC,MAAO,KACPC,gBAAiB,GACjBC,oBAAqB,GACrBC,eAAgB,GAChB9xC,IAAK,KACL2B,GAAI,KACJowC,MAAO,GACPC,eAAgB,KAChBC,aAAcvF,GACdwF,UAAW,GACXC,SAAU,GACVC,QAAS,GACTC,QAAS,KACT7M,QAAS,GACT8M,KAAM,KACNnyC,UAAWusC,GACX6F,KAAMv2B,GACNw2B,QAAS,KACT5qC,QAAS,KACT6qC,gBAAiBlG,GACjBmG,SAAU,GACVC,aAAcjG,GACdkG,OAAQ52B,GAASywB,GACjB9rC,YAAa,KACbuiB,KAAM,KACN2vB,SAAU,KACVC,SAAU,KACVh2C,QAAS,GACTi2C,MAAO,GACPC,IAAK,KACLC,QAAS,KACTloC,SAAU,GACVmoC,SAAU1G,GACV2G,UAAW5G,GACX6G,QAAS,KACTC,aAAc,KACdC,KAAM,KACNC,WAAY,KACZC,YAAa,KACbC,WAAY,KACZC,eAAgB,GAChBC,WAAY,KACZC,QAASlH,GACTruC,OAAQ2d,GACR63B,OAAQ,GACRC,KAAM93B,GACNuG,KAAM,KACNwxB,SAAU,KACVC,QAAStH,GACTuH,UAAWvH,GACX1E,GAAI,KACJkM,WAAY,KACZC,YAAa,KACbC,UAAW,KACXC,UAAW,KACX5N,GAAI,KACJ6N,MAAO,GACPC,OAAQ,KACRC,SAAU9H,GACV+H,QAAS/H,GACTgI,UAAW,GACXC,SAAUjI,GACV/Y,KAAM,KACN/pB,MAAO,KACPm7B,KAAM,KACN6P,SAAU,KACVvsB,KAAM,KACNwsB,QAAS,KACTC,KAAM,GACNC,IAAK/4B,GACLg5B,SAAU,KACVjyC,IAAK,KACLkyC,UAAWj5B,GACX1X,MAAO,KACP4wC,OAAQ,KACR1xC,IAAK,KACL2xC,UAAWn5B,GACXo5B,SAAU,GACVC,MAAO,GACPh4C,KAAM,KACNi4C,MAAO,KACPC,SAAU,GACVC,WAAY,GACZC,QAAS,KACTC,aAAc,KACdC,WAAY,KACZC,cAAe,KACfC,eAAgB,KAChBC,OAAQ,KACRC,SAAU,KACVC,UAAW,KACXC,iBAAkB,KAClB5qC,SAAU,KACVC,QAAS,KACT4qC,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,KACTC,QAAS,KACT9rC,QAAS,KACT+rC,WAAY,KACZC,aAAc,KACdC,QAAS,KACTC,UAAW,KACXC,UAAW,KACXC,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,0BAA2B,KAC3BC,SAAU,KACVC,UAAW,KACXC,SAAU,KACVC,aAAc,KACdC,UAAW,KACXC,UAAW,KACXC,SAAU,KACVC,UAAW,KACXC,aAAc,KACdC,SAAU,KACVC,qBAAsB,KACtBC,SAAU,KACVC,eAAgB,KAChBC,UAAW,KACXC,QAAS,KACTlmB,KAAM,GACNmmB,QAAS3+B,GACT4+B,QAAS,KACTC,KAAMnO,GACNoO,YAAa,KACbC,YAAa,GACbC,OAAQ,KACRC,QAAS,KACTC,SAAU,GACVt6C,eAAgB,KAChBu6C,IAAKzO,GACL0O,SAAU,GACVC,SAAU,GACVxR,KAAM7tB,GACNs/B,QAASt/B,GACTu/B,QAAS7O,GACT8O,MAAO,KACPC,OAAQ,GACRC,SAAU,GACVlwC,SAAU,GACV1M,MAAO,KACP0H,KAAMwV,GACN1b,MAAO,KACPhD,KAAM,KACNq+C,KAAM3/B,GACN4/B,WAAYrP,GACZhsC,IAAK,KACLs7C,OAAQ,KACRC,QAAS,KACTt7C,OAAQ,KACRuY,MAAOiD,GACP0qB,KAAM,KACN7iC,MAAO,KACPgI,SAAUmQ,GACV5E,OAAQ,KACRue,MAAO,KACPomB,UAAW,KACX1hC,KAAM,KACN2hC,cAAe,GACfC,OAAQ,KACRv1C,MAAO6lC,GACPnuC,MAAO4d,GACPmJ,KAAM,KAIN2kB,MAAO,KACPoS,MAAO,KACPC,QAASzP,GACT0P,KAAM,KACNn9C,WAAY,KACZo9C,QAAS,KACTh6C,OAAQ2Z,GACRsgC,YAAa,KACbC,aAAcvgC,GACdwgC,YAAa,KACbC,YAAa,KACb1iB,KAAM,KACN2iB,QAAS,KACTC,QAAS,KACTC,MAAO,KACPx7B,KAAM,KACNy7B,SAAU,KACVC,SAAU,KACV/9C,MAAO,KACPg+C,QAAS,GACTC,QAAS,GACTpxC,MAAO,KACPqxC,KAAM,KACNC,MAAO,KACPC,YAAa,KACbC,OAAQphC,GACRqhC,WAAYrhC,GACZojB,KAAM,KACNke,SAAU,KACVC,OAAQ,KACRC,aAAcxhC,GACdyhC,YAAazhC,GACb0hC,SAAU,GACVC,OAAQ,GACRC,QAAS,GACTC,OAAQ,GACR5hC,OAAQ,KACR6hC,QAAS,KACTC,OAAQ,KACRC,IAAK,KACLC,YAAajiC,GACb/B,MAAO,KACPikC,OAAQ,KACRC,UAAW5R,GACX6R,QAAS,KACTC,QAAS,KACTzzC,KAAM,KACN0zC,UAAWtiC,GACXuiC,UAAW,KACXC,QAAS,KACTC,OAAQ,KACRC,MAAO,KACPC,OAAQ3iC,GAGR4iC,kBAAmB,KACnBC,YAAa,KACbC,SAAU,KACVC,wBAAyB,GACzBC,sBAAuB,GACvB10B,OAAQ,KACR5P,SAAU,KACVukC,QAASjjC,GACTkjC,SAAU,KACVC,aAAc,QCxSLC,GAAM/rB,GAAO,CACxB6Y,MAAO,MACPgB,WAAY,CACVmS,aAAc,gBACdC,kBAAmB,qBACnBC,WAAY,cACZC,cAAe,iBACfC,UAAW,aACXt/C,UAAW,QACXu/C,SAAU,YACVC,SAAU,YACVC,mBAAoB,sBACpBC,0BAA2B,8BAC3BC,aAAc,gBACdC,eAAgB,kBAChBp/C,YAAa,cACbq/C,SAAU,WACVC,iBAAkB,oBAClBC,iBAAkB,oBAClBC,YAAa,eACbC,SAAU,YACVC,WAAY,cACZC,aAAc,gBACdhiD,WAAY,cACZE,SAAU,YACV+hD,eAAgB,mBAChBC,YAAa,eACbC,UAAW,aACXC,YAAa,eACbC,WAAY,cACZC,UAAW,aACXC,2BAA4B,+BAC5BC,yBAA0B,6BAC1B/M,SAAU,WACVgN,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,eACZxM,QAAS,UACTyM,WAAY,aACZxM,aAAc,eACdE,cAAe,gBACfuM,QAAS,UACTpM,SAAU,WACVC,UAAW,YACXC,iBAAkB,mBAClB5qC,SAAU,WACVC,QAAS,UACT4qC,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,YACXiL,MAAO,QACPhL,QAAS,UACTC,QAAS,UACT9rC,QAAS,UACT82C,UAAW,YACXC,WAAY,aACZ/K,aAAc,eACdC,QAAS,UACTC,UAAW,YACXC,UAAW,YACXC,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,YACX4J,aAAc,eACd3J,UAAW,YACXC,SAAU,WACVC,WAAY,aACZC,WAAY,aACZC,QAAS,UACTC,QAAS,UACTC,OAAQ,SACRC,UAAW,YACXC,WAAY,aACZC,WAAY,aACZC,aAAc,eACdkJ,SAAU,WACVhJ,QAAS,UACTC,SAAU,WACVC,SAAU,WACVE,SAAU,WACVC,UAAW,YACXC,SAAU,WACV2I,OAAQ,SACRzI,UAAW,YACXC,UAAW,YACXC,SAAU,WACVC,UAAW,YACXC,aAAc,eACdC,SAAU,WACVE,SAAU,WACVC,eAAgB,iBAChBC,UAAW,YACXiI,OAAQ,SACRC,iBAAkB,oBAClBC,kBAAmB,qBACnBC,WAAY,cACZC,QAAS,WACT18C,cAAe,iBACfxF,eAAgB,iBAChBmiD,gBAAiB,mBACjBC,eAAgB,kBAChBC,UAAW,aACXC,YAAa,eACbC,sBAAuB,yBACvBC,uBAAwB,0BACxBC,gBAAiB,mBACjBC,iBAAkB,oBAClBC,cAAe,iBACfC,eAAgB,kBAChBC,iBAAkB,oBAClBC,cAAe,iBACfC,YAAa,eACb93C,SAAU,WACV+3C,WAAY,cACZC,eAAgB,kBAChBC,cAAe,iBACf7kC,OAAQ,SACR8kC,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,iBAEjB98C,UAAW6lC,GACXpE,WAAY,CACVsb,MAAOtY,GACP0S,aAAcrjC,GACdkpC,WAAY,KACZC,SAAU,KACV7F,kBAAmB,KACnB8F,WAAYppC,GACZqpC,UAAWrpC,GACXujC,WAAY,KACZ+F,OAAQtpC,GACRupC,cAAe,KACfC,cAAe,KACfC,QAASzpC,GACT0pC,UAAW,KACXlG,cAAe,KACfmG,cAAe,KACfC,YAAa,KACbC,KAAM,KACNC,MAAO,KACPC,KAAM/pC,GACNgqC,GAAI,KACJC,SAAU,KACVxG,UAAWzjC,GACX7b,UAAWusC,GACXwZ,KAAM,KACNxG,SAAU,KACVyG,cAAe,KACfxG,SAAU,KACV5gD,MAAO,KACP6gD,mBAAoB,KACpBC,0BAA2B,KAC3BC,aAAc,KACdC,eAAgB,KAChBn4C,QAAS,KACTw+C,kBAAmB,KACnBC,iBAAkB,KAClB1lD,YAAa,KACb2lD,OAAQ,KACRC,GAAI,KACJC,GAAI,KACJxpD,EAAG,KACHgjD,SAAU,KACVyG,cAAe,KACfC,QAAS1qC,GACT2qC,gBAAiB3qC,GACjB1S,UAAW,KACXtL,QAAS,KACT4oD,IAAK,KACLC,QAAS7qC,GACTikC,iBAAkB,KAClB/M,SAAU,GACV4T,GAAI,KACJC,GAAI,KACJC,SAAU,KACVC,SAAU,KACVC,UAAWlrC,GACXkkC,iBAAkB,KAClB9mC,IAAK,KACLxN,MAAO,KACPu7C,SAAUnrC,GACVorC,0BAA2B,KAC3BC,KAAM,KACNlH,YAAankC,GACbokC,SAAU,KACVj9C,OAAQ,KACRmkD,UAAW,KACXC,YAAa,KACblH,WAAY,KACZC,aAAc,KACdkH,UAAW,KACXC,eAAgB,KAChBnpD,WAAY,KACZE,SAAU,KACV+hD,eAAgB,KAChBC,YAAa,KACbC,UAAW,KACXC,YAAa,KACbC,WAAY,KACZtuC,OAAQ,KACRq1C,GAAI,KACJj/B,KAAM,KACNk/B,GAAI,KACJC,GAAI,KACJC,GAAIpb,GACJqb,GAAIrb,GACJmU,UAAWnU,GACXoU,2BAA4B,KAC5BC,yBAA0B,KAC1BiH,SAAU,KACVC,kBAAmB,KACnBC,cAAe,KACf7jB,QAAS,KACT8jB,QAASlsC,GACTmsC,kBAAmB,KACnBC,WAAY,KACZ/pD,OAAQ,KACRkkB,KAAM,KACNwxB,SAAU,KACVgN,UAAW/kC,GACXglC,aAAchlC,GACdilC,aAAcjlC,GACdgsB,GAAI,KACJqgB,YAAarsC,GACbklC,eAAgB,KAChBoH,kBAAmB,KACnBC,GAAI,KACJC,IAAK,KACLC,UAAWzsC,GACXkB,EAAGlB,GACH0sC,GAAI1sC,GACJ2sC,GAAI3sC,GACJ4sC,GAAI5sC,GACJ6sC,GAAI7sC,GACJ8sC,aAAcnc,GACdoc,iBAAkB,KAClBC,UAAW,KACXC,WAAY,KACZC,SAAU,KACVC,QAAS,KACTpkB,KAAM,KACNqkB,aAAc,KACdjI,cAAe,KACfC,cAAe,KACfiI,kBAAmBrtC,GACnBstC,MAAO,KACPjI,UAAW,KACXC,UAAW,KACXC,YAAa,KACbgI,aAAc,KACdC,YAAa,KACbC,YAAa,KACbzc,KAAM,KACN0c,iBAAkB,KAClBC,UAAW,KACXC,aAAc,KACd7mD,IAAK,KACLuB,MAAO,KACPulD,uBAAwB,KACxBC,sBAAuB,KACvBC,UAAW/tC,GACXguC,UAAW,KACX9U,OAAQ,KACR1xC,IAAK,KACLrE,KAAM,KACN9B,KAAM,KACNmkD,QAAS,KACTC,YAAa,KACbC,aAAc,KACdC,QAAS,KACTC,QAAS,KACTC,QAAS,KACTC,SAAU,KACVC,MAAO,KACPC,UAAW,KACXC,WAAY,KACZgI,WAAY,KACZC,SAAU,KACVp9B,OAAQ,KACR2oB,QAAS,KACTyM,WAAY,KACZxM,aAAc,KACdE,cAAe,KACfuM,QAAS,KACTpM,SAAU,KACVC,UAAW,KACXC,iBAAkB,KAClB5qC,SAAU,KACVC,QAAS,KACT4qC,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,KACXiL,MAAO,KACPhL,QAAS,KACTC,QAAS,KACT9rC,QAAS,KACT82C,UAAW,KACXC,WAAY,KACZ/K,aAAc,KACdC,QAAS,KACTC,UAAW,KACXC,UAAW,KACXC,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,KACX4J,aAAc,KACd3J,UAAW,KACXC,SAAU,KACVC,WAAY,KACZC,WAAY,KACZC,QAAS,KACTC,QAAS,KACTC,OAAQ,KACRC,UAAW,KACXC,WAAY,KACZC,WAAY,KACZC,aAAc,KACdkJ,SAAU,KACVhJ,QAAS,KACTC,SAAU,KACVC,SAAU,KACVE,SAAU,KACVC,UAAW,KACXC,SAAU,KACV2I,OAAQ,KACRzI,UAAW,KACXC,UAAW,KACXC,SAAU,KACVC,UAAW,KACXC,aAAc,KACdC,SAAU,KACVE,SAAU,KACVC,eAAgB,KAChBC,UAAW,KACXiI,OAAQ,KACRz6C,QAAS,KACTkiD,SAAU,KACVnnC,MAAO,KACPonC,OAAQ,KACRC,YAAa,KACb3qC,OAAQ,KACR9gB,SAAU,KACV0rD,QAAS,KACT3H,iBAAkB3mC,GAClB4mC,kBAAmB5mC,GACnB6mC,WAAY,KACZC,QAAS,KACTxiC,KAAM,KACNiqC,WAAYvuC,GACZwuC,oBAAqB,KACrBC,iBAAkB,KAClBC,aAAc,KACdC,MAAO,KACP9P,KAAMnO,GACNke,MAAO,KACP7F,cAAe,KACf3+C,cAAe,KACfykD,OAAQ,KACRC,UAAW9uC,GACX+uC,UAAW/uC,GACXgvC,UAAWhvC,GACXivC,cAAe,KACfC,oBAAqB,KACrBC,eAAgB,KAChBC,UAAW,KACX1wC,SAAUiyB,GACVzgC,EAAG,KACHm/C,OAAQ,KACRzqD,eAAgB,KAChB0qD,KAAM,KACNC,KAAM,KACNpQ,IAAKxO,GACLqR,IAAKrR,GACLoW,gBAAiB,KACjByI,YAAa,KACbC,UAAW,KACXC,mBAAoB/e,GACpBgf,iBAAkBhf,GAClBif,cAAejf,GACfkf,gBAAiBlf,GACjBrJ,SAAU,KACVwoB,QAAS,KACTpqC,OAAQ,KACRqqC,OAAQ,KACRC,GAAI,KACJC,GAAI,KACJC,MAAO,KACPC,KAAM,KACNnJ,eAAgB,KAChBoJ,KAAM,KACNC,MAAO,KACPC,aAAc,KACdC,iBAAkBvwC,GAClBwwC,iBAAkBxwC,GAClBywC,aAAc,KACdzpD,QAAS,KACT0pD,YAAa,KACbC,aAAc,KACdC,MAAO,KACPC,MAAO,KACPC,YAAa,KACb7J,UAAW,KACXC,YAAa,KACbC,sBAAuBnnC,GACvBonC,uBAAwBpnC,GACxBE,OAAQ,KACR6wC,OAAQ,KACR1J,gBAAiB1W,GACjB2W,iBAAkB,KAClBC,cAAe,KACfC,eAAgB,KAChBC,iBAAkBznC,GAClB0nC,cAAe1nC,GACf2nC,YAAa,KACb9/C,MAAO,KACPmpD,aAAchxC,GACdixC,aAAc,KACdC,oBAAqB,KACrBC,WAAY,KACZC,cAAe,KACfC,qBAAsB,KACtBC,eAAgB3gB,GAChB9gC,SAAUmQ,GACVuxC,YAAa,KACbn2C,OAAQ,KACRo2C,QAASxxC,GACTyxC,QAASzxC,GACT4nC,WAAY,KACZC,eAAgB,KAChBC,cAAe,KACf4J,WAAY,KACZ1I,cAAe,KACfrvB,MAAO,KACPg4B,kBAAmB,KACnBtzC,KAAM,KACN4E,OAAQ0tB,GACRihB,GAAI,KACJ1lD,UAAW,KACX2lD,GAAI,KACJC,GAAI,KACJ/J,kBAAmB/nC,GACnBgoC,mBAAoBhoC,GACpB+xC,QAAS,KACT9J,YAAa,KACbC,aAAc,KACdC,WAAYnoC,GACZqI,OAAQ,KACR+/B,YAAapoC,GACbuoC,cAAevoC,GACfwoC,aAAc,KACdH,SAAUroC,GACVsoC,aAActoC,GACdwiC,QAAS,KACTiG,SAAUzoC,GACV0oC,YAAa1oC,GACb2oC,YAAa3oC,GACbgyC,QAAS,KACTC,WAAY,KACZC,WAAY,KACZ9vD,MAAO,KACP+vD,OAAQ,KACRvJ,YAAa,KACbC,YAAa,KACb51C,EAAG,KACHm/C,GAAI,KACJC,GAAI,KACJC,iBAAkB,KAClBxJ,QAAS9oC,GACTnP,EAAG,KACH0hD,GAAI,KACJC,GAAI,KACJC,iBAAkB,KAClBlhD,EAAG,KACHmhD,WAAY,QCliBH,GAAOviB,GAAM,CAACwB,GAAKR,GAAOc,GAAOG,GAAM,IAAW,QAClD,GAAMjC,GAAM,CAACwB,GAAKR,GAAOc,GAAOG,GAAMgR,IAAU,OCM9C,SAASuP,GAAat3C,GACnC,GAAIA,EAAQu3C,iBAAmBv3C,EAAQw3C,mBACrC,MAAM,IAAIp2C,UACR,4EAIJ,GACEpB,EAAQu3C,iBACRv3C,EAAQw3C,oBACRx3C,EAAQy3C,aAER,OAAQtnC,IACNqf,GAAMrf,EAAM,WAAW,CAACvO,EAAMhV,EAAO8qD,KACnC,MAAM9pB,EAAqC,EAE3C,IAAI3c,EAYJ,GAVIjR,EAAQu3C,gBACVtmC,GAAUjR,EAAQu3C,gBAAgBtrC,SAASrK,EAAKwe,SACvCpgB,EAAQw3C,qBACjBvmC,EAASjR,EAAQw3C,mBAAmBvrC,SAASrK,EAAKwe,WAG/CnP,GAAUjR,EAAQy3C,cAAiC,kBAAV7qD,IAC5CqkB,GAAUjR,EAAQy3C,aAAa71C,EAAMhV,EAAOghC,IAG1C3c,GAA2B,kBAAVrkB,EAOnB,OANIoT,EAAQ23C,kBAAoB/1C,EAAKhZ,SACnCglC,EAAOhlC,SAASmoB,OAAOnkB,EAAO,KAAMgV,EAAKhZ,UAEzCglC,EAAOhlC,SAASmoB,OAAOnkB,EAAO,GAGzBA,MC1DjB,MAAMgrD,GAAY,CAAC,OAAQ,QAAS,SAAU,O,gBCIvC,SAAS91C,GAAW+1C,GAEzB,IAAIxoD,EAEFwoD,GAA0B,kBAAVA,GAAqC,SAAfA,EAAM70C,KAExC60C,EAAMxoD,OAAS,GACfwoD,EAIN,MAAwB,kBAAVxoD,GAA4D,KAAtCA,EAAM6H,QAAQ,eAAgB,ICPpE,MAAM4gD,GAAQ,kBACRC,GAAO,UACPC,GAAM,SA+CZ,SAASC,GAAM7wB,GACb,MAAO,IAAMA,EAAGnwB,cAOlB,SAASihD,GAAU9wB,GACjB,OAAOA,EAAGrkB,OAAO,GAAG2b,cClEf,MAAMy5B,GAAc,CACzB7S,QAAS,UACTqD,SAAU,WACVzL,OAAQ,SACR8O,gBAAiB,kBACjBC,iBAAkB,mBAClBC,cAAe,gBACfC,eAAgB,iBAChBC,iBAAkB,mBAClBxkC,OAAQ,SACRmuB,aAAc,eACdC,aAAc,eACdC,UAAW,YACXC,UAAW,YACXC,UAAW,YACXC,WAAY,aACZC,UAAW,YACXS,WAAY,c,gBC2Fd,MAAM,GAAM,GAAG93B,eAITo5C,GAAgB,IAAIC,IAAI,CAAC,QAAS,QAAS,QAAS,QAAS,OAM5D,SAASC,GAAgBhhC,EAAS1V,GAEvC,MAAMhZ,EAAW,GACjB,IAEImD,EAFAwsD,GAAc,EAIlB,OAASA,EAAa32C,EAAKhZ,SAASqD,QAClCF,EAAQ6V,EAAKhZ,SAAS2vD,GAEH,YAAfxsD,EAAMiX,KACRpa,EAAS4Z,KAAKg2C,GAAQlhC,EAASvrB,EAAOwsD,EAAY32C,IAC1B,SAAf7V,EAAMiX,KASC,YAAdpB,EAAKoB,MACJo1C,GAAcK,IAAI72C,EAAKwe,UACvBte,GAAW/V,IAEZnD,EAAS4Z,KAAKzW,EAAMsD,OAEE,QAAftD,EAAMiX,MAAmBsU,EAAQtX,QAAQ04C,UAElD9vD,EAAS4Z,KAAKzW,EAAMsD,OAIxB,OAAOzG,EAST,SAAS4vD,GAAQlhC,EAAS1V,EAAMhV,EAAOghC,GACrC,MAAM5tB,EAAUsX,EAAQtX,QAClB24C,EAAerhC,EAAQshC,OAGvB5yD,EAAO4b,EAAKwe,QAEZkS,EAAa,GACnB,IAEIjvB,EAFAu1C,EAASD,EASb,GAL2B,SAAvBA,EAAa9jB,OAA6B,QAAT7uC,IACnC4yD,EAAS,GACTthC,EAAQshC,OAASA,GAGfh3C,EAAK0wB,WACP,IAAKjvB,KAAYzB,EAAK0wB,WAChB,GAAI/yB,KAAKqC,EAAK0wB,WAAYjvB,IAC5Bw1C,GAAYvmB,EAAYjvB,EAAUzB,EAAK0wB,WAAWjvB,GAAWiU,GAKtD,OAATtxB,GAA0B,OAATA,GACnBsxB,EAAQwhC,YAGV,MAAMlwD,EAAW0vD,GAAgBhhC,EAAS1V,GAE7B,OAAT5b,GAA0B,OAATA,GACnBsxB,EAAQwhC,YAIVxhC,EAAQshC,OAASD,EAIjB,MAAMjyD,EAAWkb,EAAKlb,UAAY,CAChCgb,MAAO,CAACC,KAAM,KAAML,OAAQ,KAAMmU,OAAQ,MAC1C1T,IAAK,CAACJ,KAAM,KAAML,OAAQ,KAAMmU,OAAQ,OAEpC1sB,EACJiX,EAAQ+4C,YAAc,GAAIx5C,KAAKS,EAAQ+4C,WAAY/yD,GAC/Cga,EAAQ+4C,WAAW/yD,GACnBA,EACAgzD,EAA6B,kBAAdjwD,GAA0BA,IAAc,WAE7D,IAAK,sBAA2BA,GAC9B,MAAM,IAAIqY,UACR,wBAAwBpb,wCA2D5B,GAvDAssC,EAAW5yB,IAAM,CACf1Z,EACAU,EAASgb,MAAMC,KACfjb,EAASgb,MAAMJ,OACf1U,GACAoJ,KAAK,KAEM,MAAThQ,GAAgBga,EAAQi5C,aAC1B3mB,EAAWvyB,OACqB,oBAAvBC,EAAQi5C,WACXj5C,EAAQi5C,WACNnjD,OAAOw8B,EAAWpnB,MAAQ,IAC1BtJ,EAAKhZ,SACuB,kBAArB0pC,EAAWhU,MAAqBgU,EAAWhU,MAAQ,MAE5Dte,EAAQi5C,YAGH,MAATjzD,GAAgBga,EAAQk5C,mBAC1B5mB,EAAWpnB,KAAOlL,EAAQk5C,iBACxBpjD,OAAOw8B,EAAWpnB,MAAQ,IAC1BtJ,EAAKhZ,SACuB,kBAArB0pC,EAAWhU,MAAqBgU,EAAWhU,MAAQ,OAK3D06B,GACQ,SAAThzD,GACgB,YAAhB4nC,EAAO5qB,MACY,QAAnB4qB,EAAOxN,UAEPkS,EAAW6mB,QAAS,GAInBH,GACS,OAAThzD,GACU,OAATA,GACS,OAATA,GACS,OAATA,GACS,OAATA,GACS,OAATA,IAEFssC,EAAW8mB,MAAQt+C,OAAOmsB,SAASjhC,EAAK+c,OAAO,GAAI,KAGxC,QAAT/c,GAAkBga,EAAQq5C,oBAC5B/mB,EAAWppC,IAAM8W,EAAQq5C,kBACvBvjD,OAAOw8B,EAAWppC,KAAO,IACzB4M,OAAOw8B,EAAW3pC,KAAO,IACG,kBAArB2pC,EAAWhU,MAAqBgU,EAAWhU,MAAQ,QAIzD06B,GAAkB,OAAThzD,GAAiC,YAAhB4nC,EAAO5qB,KAAoB,CACxD,MAAMs2C,EA0DV,SAAyB13C,GACvB,IAAIhV,GAAS,EAEb,OAASA,EAAQgV,EAAKhZ,SAASqD,QAAQ,CACrC,MAAMF,EAAQ6V,EAAKhZ,SAASgE,GAE5B,GAAmB,YAAfb,EAAMiX,MAAwC,UAAlBjX,EAAMq0B,QACpC,OAAOr0B,EAIX,OAAO,KArESwtD,CAAgB33C,GAC9B0wB,EAAWnE,QACTmrB,GAASA,EAAMhnB,WAAa3hB,QAAQ2oC,EAAMhnB,WAAWnE,SAAW,KAClEmE,EAAW1lC,MAAQ4sD,GAAuB5rB,EAAQhsB,GAClD0wB,EAAWrE,QAA6B,OAAnBL,EAAOxN,QAgKhC,IAAyBtd,EAnHvB,OA1CKk2C,GAAmB,OAAThzD,GAA0B,OAATA,IAC9BssC,EAAWrE,QAAmB,OAATjoC,EACrBssC,EAAW3E,MAAQrW,EAAQwhC,WAGhB,OAAT9yD,GAA0B,OAATA,IACfssC,EAAWG,QACRH,EAAW9lC,QAAO8lC,EAAW9lC,MAAQ,IAE1C8lC,EAAW9lC,MAAMtE,UAAYoqC,EAAWG,aACjCH,EAAWG,OAGfumB,IACH1mB,EAAWmnB,SAAoB,OAATzzD,IAIrBgzD,GAAkB,OAAThzD,GAAiC,YAAhB4nC,EAAO5qB,OACpCsvB,EAAWmnB,SAAW9oC,QAA2B,UAAnBid,EAAOxN,UAInCpgB,EAAQ05C,YACVpnB,EAAW,kBAsIN,EADgBxvB,EArI0Bpc,GAuI3Cgb,MAAMC,KACV,IACAmB,EAAIpB,MAAMJ,OACV,IACAwB,EAAIf,IAAIJ,KACR,IACAmB,EAAIf,IAAIT,QAEP3U,KAAKhH,GAAMmQ,OAAOnQ,KAClBqQ,KAAK,MA7IHgjD,GAASh5C,EAAQ25C,eACpBrnB,EAAWsnB,eAAiBh4C,EAAKlb,WAI9BsyD,GAASh5C,EAAQ65C,sBACpBvnB,EAAW1lC,MAAQ4sD,GAAuB5rB,EAAQhsB,GAClD0wB,EAAWwnB,aAAeN,GAAuB5rB,IAG9CorB,IACH1mB,EAAW1wB,KAAOA,GAIbhZ,EAASqD,OAAS,EACrB,gBAAoBlD,EAAWupC,EAAY1pC,GAC3C,gBAAoBG,EAAWupC,GA0BrC,SAASknB,GAAuB5rB,EAAQhsB,GACtC,IAAIhV,GAAS,EACTmtD,EAAQ,EAEZ,OAASntD,EAAQghC,EAAOhlC,SAASqD,QAC3B2hC,EAAOhlC,SAASgE,KAAWgV,GACK,YAAhCgsB,EAAOhlC,SAASgE,GAAOoW,MAAoB+2C,IAGjD,OAAOA,EAST,SAASlB,GAAY1yD,EAAO+c,EAAM7T,EAAOwkC,GACvC,MAAMvnB,EF/VD,SAAcssC,EAAQvpD,GAC3B,MAAMulC,EAAS,GAAUvlC,GACzB,IAAI6T,EAAO7T,EACP2qD,EAAOjlB,GAEX,GAAIH,KAAUgkB,EAAOhkB,OACnB,OAAOgkB,EAAOv1C,SAASu1C,EAAOhkB,OAAOA,IAGvC,GAAIA,EAAO3oC,OAAS,GAA4B,SAAvB2oC,EAAOnoC,MAAM,EAAG,IAAiBqrD,GAAMz/C,KAAKhJ,GAAQ,CAE3E,GAAwB,MAApBA,EAAM0T,OAAO,GAAY,CAE3B,MAAMk3C,EAAO5qD,EAAM5C,MAAM,GAAGyK,QAAQ6gD,GAAMG,IAC1Ch1C,EAAO,OAAS+2C,EAAKl3C,OAAO,GAAG2b,cAAgBu7B,EAAKxtD,MAAM,OACrD,CAEL,MAAMwtD,EAAO5qD,EAAM5C,MAAM,GAEzB,IAAKsrD,GAAK1/C,KAAK4hD,GAAO,CACpB,IAAIC,EAASD,EAAK/iD,QAAQ8gD,GAAKC,IAEN,MAArBiC,EAAOn3C,OAAO,KAChBm3C,EAAS,IAAMA,GAGjB7qD,EAAQ,OAAS6qD,GAIrBF,EAAOtkB,GAGT,OAAO,IAAIskB,EAAK92C,EAAM7T,GE8TT8qD,CAAKtmB,EAAI+kB,OAAQ11C,GAC9B,IAAImH,EAAShb,EAIE,OAAXgb,QAA8B/d,IAAX+d,GAAwBA,IAAWA,IAMtDtU,MAAMsJ,QAAQgL,KAChBA,EAASiC,EAAK8oB,eC3UX,SAAmBpoB,EAAQhN,GAChC,IAAIiP,EAAWjP,GAAW,GAO1B,MAJkC,KAA9BgN,EAAOA,EAAO/gB,OAAS,KACzB+gB,EAASA,EAAO8Z,OAAO,KAGlB9Z,EACJhX,MACEiZ,EAASmrC,SAAW,IAAM,IACzB,MACsB,IAArBnrC,EAASorC,QAAoB,GAAK,MAEtCn5C,OD6T8B,CAAOmJ,GAAiBA,EE1W3CrU,KAAK,KAAKkL,QF6WF,UAAlBoL,EAAKjJ,UAA0C,kBAAXgH,IACtCA,EAkBJ,SAAoBhb,GAElB,MAAMgb,EAAS,GAEf,IACE,GAAMhb,EAAOwY,GACb,OAIF,OAAOwC,EAMP,SAASxC,EAAS7hB,EAAMmR,GACtB,MAAM0O,EAAyB,SAArB7f,EAAKyG,MAAM,EAAG,GAAgB,MAAMzG,EAAKyG,MAAM,KAAOzG,EAChEqkB,EAAOxE,EAAE3O,QAAQ,YAAaojD,KAAkBnjD,GApCvCojD,CAAWlwC,IAGlBiC,EAAKuoB,OAASvoB,EAAKjJ,SACrBld,EACE,GAAIoZ,KAAK44C,GAAa7rC,EAAKjJ,UACvB80C,GAAY7rC,EAAKjJ,UACjBiJ,EAAKjJ,UACPgH,EACKiC,EAAK0oB,YACd7uC,EAAMmmB,EAAK0oB,WAAa3qB,IAkC5B,SAASiwC,GAAczqD,EAAGw3B,GACxB,OAAOA,EAAG3I,cGxYZ,MAAM,GAAM,GAAG1f,eAKTw7C,GAAa,CACjBjrC,QAAS,CAACgnC,GAAI,UAAW5lB,GAAI,mCAC7B8pB,UAAW,CAAClE,GAAI,aAAc5lB,GAAI,kCAClC+pB,WAAY,CAAC/pB,GAAI,wCACjBwC,mBAAoB,CAACxC,GAAI,wCACzBgqB,WAAY,CAAChqB,GAAI,wCACjB3uB,OAAQ,CAACu0C,GAAI,WAAY5lB,GAAI,6BAC7BiqB,UAAW,CACTrE,GAAI,eACJ5lB,GAAI,sDAENkqB,aAAc,CACZtE,GAAI,kBACJ5lB,GAAI,sDAENmqB,gBAAiB,CACfvE,GAAI,qBACJ5lB,GAAI,sDAENoqB,iBAAkB,CAChBxE,GAAI,sBACJ5lB,GAAI,mDAUD,SAASqqB,GAAch7C,GAC5B,IAAK,MAAMN,KAAO86C,GAChB,GAAI,GAAIj7C,KAAKi7C,GAAY96C,IAAQ,GAAIH,KAAKS,EAASN,GAAM,CACvD,MAAMu7C,EAAcT,GAAW96C,GAC/Bw7C,QAAQC,KACN,oCACEF,EAAY1E,GAAK,SAAS0E,EAAY1E,kBAAoB,cACtD72C,+EAA4Bu7C,EAAYtqB,6BAEzC6pB,GAAW96C,GAItB,MAAM8O,EAAYP,IACfF,IAAI,IACJA,IAAI/N,EAAQo7C,eAAiB,IAC7BrtC,IAAI,GAAc,IACd/N,EAAQq7C,oBACXloB,oBAAoB,IAErBplB,IAAI/N,EAAQs7C,eAAiB,IAC7BvtC,IAAIupC,GAAct3C,GAEf8I,EAAO,IAAI8C,EAEe,kBAArB5L,EAAQpX,SACjBkgB,EAAKzZ,MAAQ2Q,EAAQpX,cACS0D,IAArB0T,EAAQpX,UAA+C,OAArBoX,EAAQpX,UACnDsyD,QAAQC,KACN,0EAA0En7C,EAAQpX,eAItF,MAAM2yD,EAAW/sC,EAAU4B,QAAQ5B,EAAUxW,MAAM8Q,GAAOA,GAE1D,GAAsB,SAAlByyC,EAASv4C,KACX,MAAM,IAAI5B,UAAU,0BAItB,IAAIiJ,EAAS,gBACX,WACA,GACAiuC,GAAgB,CAACt4C,UAAS44C,OAAQ,GAAME,UAAW,GAAIyC,IAOzD,OAJIv7C,EAAQlX,YACVuhB,EAAS,gBAAoB,MAAO,CAACvhB,UAAWkX,EAAQlX,WAAYuhB,IAG/DA,EAGT2wC,GAAcQ,aAAe,CAACtC,iBPxHvB,SAAwBuC,GAC7B,MAAM1yC,GAAO0yC,GAAO,IAAIv6C,OAClBw6C,EAAQ3yC,EAAIhG,OAAO,GAEzB,GAAc,MAAV24C,GAA2B,MAAVA,EACnB,OAAO3yC,EAGT,MAAM4yC,EAAQ5yC,EAAIxb,QAAQ,KAC1B,IAAe,IAAXouD,EACF,OAAO5yC,EAGT,IAAInc,GAAS,EAEb,OAASA,EAAQgrD,GAAU3rD,QAAQ,CACjC,MAAMof,EAAWusC,GAAUhrD,GAE3B,GACE+uD,IAAUtwC,EAASpf,QACnB8c,EAAItc,MAAM,EAAG4e,EAASpf,QAAQgL,gBAAkBoU,EAEhD,OAAOtC,EAKX,OADAnc,EAAQmc,EAAIxb,QAAQ,MACL,IAAXX,GAAgB+uD,EAAQ/uD,EACnBmc,GAGTnc,EAAQmc,EAAIxb,QAAQ,MACL,IAAXX,GAAgB+uD,EAAQ/uD,EACnBmc,EAIF,wBOqFTiyC,GAAcY,UAAY,CAExBhzD,SAAU,UAEVE,UAAW,UAEX2uD,aAAc,QACdF,gBAAiB,WAAkB,WACnCC,mBAAoB,WAAkB,WACtCG,iBAAkB,QAElByD,cAAe,WACb,aAAoB,CAClB,UACA,QACA,WACE,aAAoB,CAClB,QACA,UACA,UACA,QACA,WAGE,cAMVE,cAAe,WACb,aAAoB,CAClB,UACA,QACA,WACE,aAAoB,CAClB,QACA,UACA,UACA,QACA,WAGE,cAOV5B,UAAW,QACXC,aAAc,QACdjB,SAAU,QACVmB,oBAAqB,QACrBX,iBAAkB,aAAoB,CAAC,QAAgB,UACvDD,WAAY,aAAoB,CAAC,QAAgB,YACjDI,kBAAmB,QACnBN,WAAY","sources":["webpack://_N_E/./node_modules/@mui/icons-material/Check.js","webpack://_N_E/./node_modules/@mui/icons-material/Circle.js","webpack://_N_E/./node_modules/@mui/icons-material/Edit.js","webpack://_N_E/./node_modules/@mui/icons-material/ExpandLess.js","webpack://_N_E/./node_modules/@mui/icons-material/ExpandMore.js","webpack://_N_E/./node_modules/@mui/icons-material/Menu.js","webpack://_N_E/./node_modules/@mui/icons-material/MenuBook.js","webpack://_N_E/./node_modules/@mui/icons-material/esm/Add.js","webpack://_N_E/./node_modules/@mui/icons-material/esm/CheckCircle.js","webpack://_N_E/./node_modules/@mui/icons-material/esm/Edit.js","webpack://_N_E/./node_modules/@mui/icons-material/esm/ExpandLess.js","webpack://_N_E/./node_modules/@mui/icons-material/esm/LinkedIn.js","webpack://_N_E/./node_modules/@mui/icons-material/esm/MoreVert.js","webpack://_N_E/./node_modules/@mui/icons-material/esm/Warning.js","webpack://_N_E/./node_modules/@mui/icons-material/esm/Work.js","webpack://_N_E/./node_modules/@mui/material/internal/svg-icons/Person.js","webpack://_N_E/./node_modules/@mui/material/Avatar/Avatar.js","webpack://_N_E/./node_modules/@mui/material/Avatar/avatarClasses.js","webpack://_N_E/./node_modules/@mui/material/AvatarGroup/avatarGroupClasses.js","webpack://_N_E/./node_modules/@mui/material/AvatarGroup/AvatarGroup.js","webpack://_N_E/./node_modules/@mui/material/CardMedia/cardMediaClasses.js","webpack://_N_E/./node_modules/@mui/material/CardMedia/CardMedia.js","webpack://_N_E/./node_modules/@mui/material/FormGroup/formGroupClasses.js","webpack://_N_E/./node_modules/@mui/material/FormGroup/FormGroup.js","webpack://_N_E/./node_modules/@mui/material/InputAdornment/inputAdornmentClasses.js","webpack://_N_E/./node_modules/@mui/material/InputAdornment/InputAdornment.js","webpack://_N_E/./node_modules/@mui/material/LinearProgress/LinearProgress.js","webpack://_N_E/./node_modules/@mui/material/LinearProgress/linearProgressClasses.js","webpack://_N_E/./node_modules/@mui/material/Tab/tabClasses.js","webpack://_N_E/./node_modules/@mui/material/Tab/Tab.js","webpack://_N_E/./node_modules/@mui/system/esm/Box/Box.js","webpack://_N_E/./node_modules/dayjs/dayjs.min.js","webpack://_N_E/./node_modules/dayjs/plugin/duration.js","webpack://_N_E/./node_modules/extend/index.js","webpack://_N_E/./node_modules/inline-style-parser/index.js","webpack://_N_E/./node_modules/is-buffer/index.js","webpack://_N_E/./node_modules/prop-types/factoryWithThrowingShims.js","webpack://_N_E/./node_modules/prop-types/index.js","webpack://_N_E/./node_modules/prop-types/lib/ReactPropTypesSecret.js","webpack://_N_E/./node_modules/react-markdown/node_modules/react-is/cjs/react-is.production.min.js","webpack://_N_E/./node_modules/react-markdown/node_modules/react-is/index.js","webpack://_N_E/./node_modules/style-to-object/index.js","webpack://_N_E/./node_modules/unist-util-stringify-position/index.js","webpack://_N_E/./node_modules/vfile-message/index.js","webpack://_N_E/./node_modules/vfile/lib/minpath.browser.js","webpack://_N_E/./node_modules/vfile/lib/minproc.browser.js","webpack://_N_E/./node_modules/vfile/lib/minurl.shared.js","webpack://_N_E/./node_modules/vfile/lib/minurl.browser.js","webpack://_N_E/./node_modules/vfile/lib/index.js","webpack://_N_E/./node_modules/bail/index.js","webpack://_N_E/./node_modules/is-plain-obj/index.js","webpack://_N_E/./node_modules/trough/index.js","webpack://_N_E/./node_modules/unified/lib/index.js","webpack://_N_E/./node_modules/mdast-util-to-string/index.js","webpack://_N_E/./node_modules/micromark-util-chunked/index.js","webpack://_N_E/./node_modules/micromark-util-combine-extensions/index.js","webpack://_N_E/./node_modules/micromark-util-character/lib/unicode-punctuation-regex.js","webpack://_N_E/./node_modules/micromark-util-character/index.js","webpack://_N_E/./node_modules/micromark-factory-space/index.js","webpack://_N_E/./node_modules/micromark/lib/initialize/content.js","webpack://_N_E/./node_modules/micromark/lib/initialize/document.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/blank-line.js","webpack://_N_E/./node_modules/micromark-util-subtokenize/index.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/content.js","webpack://_N_E/./node_modules/micromark/lib/initialize/flow.js","webpack://_N_E/./node_modules/micromark/lib/initialize/text.js","webpack://_N_E/./node_modules/micromark-util-resolve-all/index.js","webpack://_N_E/./node_modules/micromark/lib/create-tokenizer.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/thematic-break.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/list.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/block-quote.js","webpack://_N_E/./node_modules/micromark-factory-destination/index.js","webpack://_N_E/./node_modules/micromark-factory-label/index.js","webpack://_N_E/./node_modules/micromark-factory-title/index.js","webpack://_N_E/./node_modules/micromark-factory-whitespace/index.js","webpack://_N_E/./node_modules/micromark-util-normalize-identifier/index.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/definition.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/code-indented.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/heading-atx.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/setext-underline.js","webpack://_N_E/./node_modules/micromark-util-html-tag-name/index.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/html-flow.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/code-fenced.js","webpack://_N_E/./node_modules/decode-named-character-reference/index.dom.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/character-reference.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/character-escape.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/line-ending.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/label-end.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/label-start-image.js","webpack://_N_E/./node_modules/micromark-util-classify-character/index.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/attention.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/autolink.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/html-text.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/label-start-link.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/hard-break-escape.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/code-text.js","webpack://_N_E/./node_modules/micromark/lib/constructs.js","webpack://_N_E/./node_modules/micromark/lib/parse.js","webpack://_N_E/./node_modules/micromark/lib/preprocess.js","webpack://_N_E/./node_modules/micromark-util-decode-numeric-character-reference/index.js","webpack://_N_E/./node_modules/micromark-util-decode-string/index.js","webpack://_N_E/./node_modules/mdast-util-from-markdown/lib/index.js","webpack://_N_E/./node_modules/micromark/lib/postprocess.js","webpack://_N_E/./node_modules/remark-parse/index.js","webpack://_N_E/./node_modules/remark-parse/lib/index.js","webpack://_N_E/./node_modules/unist-builder/index.js","webpack://_N_E/./node_modules/unist-util-is/index.js","webpack://_N_E/./node_modules/unist-util-visit-parents/index.js","webpack://_N_E/./node_modules/unist-util-visit/index.js","webpack://_N_E/./node_modules/unist-util-position/index.js","webpack://_N_E/./node_modules/mdast-util-definitions/index.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/traverse.js","webpack://_N_E/./node_modules/micromark-util-sanitize-uri/index.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/wrap.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/footnote-reference.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/revert.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/list-item.js","webpack://_N_E/./node_modules/trim-lines/index.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/index.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/blockquote.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/break.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/code.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/delete.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/emphasis.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/footnote.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/heading.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/html.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/image-reference.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/image.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/inline-code.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/link-reference.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/link.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/list.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/paragraph.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/root.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/strong.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/table.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/text.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/thematic-break.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/index.js","webpack://_N_E/./node_modules/unist-util-generated/index.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/footer.js","webpack://_N_E/./node_modules/remark-rehype/lib/index.js","webpack://_N_E/./node_modules/property-information/lib/util/schema.js","webpack://_N_E/./node_modules/property-information/lib/util/merge.js","webpack://_N_E/./node_modules/property-information/lib/normalize.js","webpack://_N_E/./node_modules/property-information/lib/util/info.js","webpack://_N_E/./node_modules/property-information/lib/util/types.js","webpack://_N_E/./node_modules/property-information/lib/util/defined-info.js","webpack://_N_E/./node_modules/property-information/lib/util/create.js","webpack://_N_E/./node_modules/property-information/lib/xlink.js","webpack://_N_E/./node_modules/property-information/lib/xml.js","webpack://_N_E/./node_modules/property-information/lib/util/case-sensitive-transform.js","webpack://_N_E/./node_modules/property-information/lib/util/case-insensitive-transform.js","webpack://_N_E/./node_modules/property-information/lib/xmlns.js","webpack://_N_E/./node_modules/property-information/lib/aria.js","webpack://_N_E/./node_modules/property-information/lib/html.js","webpack://_N_E/./node_modules/property-information/lib/svg.js","webpack://_N_E/./node_modules/property-information/index.js","webpack://_N_E/./node_modules/react-markdown/lib/rehype-filter.js","webpack://_N_E/./node_modules/react-markdown/lib/uri-transformer.js","webpack://_N_E/./node_modules/hast-util-whitespace/index.js","webpack://_N_E/./node_modules/property-information/lib/find.js","webpack://_N_E/./node_modules/property-information/lib/hast-to-react.js","webpack://_N_E/./node_modules/react-markdown/lib/ast-to-react.js","webpack://_N_E/./node_modules/comma-separated-tokens/index.js","webpack://_N_E/./node_modules/space-separated-tokens/index.js","webpack://_N_E/./node_modules/react-markdown/lib/react-markdown.js"],"sourcesContent":["\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\nvar _createSvgIcon = _interopRequireDefault(require(\"./utils/createSvgIcon\"));\n\nvar _jsxRuntime = require(\"react/jsx-runtime\");\n\nvar _default = (0, _createSvgIcon.default)( /*#__PURE__*/(0, _jsxRuntime.jsx)(\"path\", {\n  d: \"M9 16.17 4.83 12l-1.42 1.41L9 19 21 7l-1.41-1.41z\"\n}), 'Check');\n\nexports.default = _default;","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\nvar _createSvgIcon = _interopRequireDefault(require(\"./utils/createSvgIcon\"));\n\nvar _jsxRuntime = require(\"react/jsx-runtime\");\n\nvar _default = (0, _createSvgIcon.default)( /*#__PURE__*/(0, _jsxRuntime.jsx)(\"path\", {\n  d: \"M12 2C6.47 2 2 6.47 2 12s4.47 10 10 10 10-4.47 10-10S17.53 2 12 2z\"\n}), 'Circle');\n\nexports.default = _default;","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\nvar _createSvgIcon = _interopRequireDefault(require(\"./utils/createSvgIcon\"));\n\nvar _jsxRuntime = require(\"react/jsx-runtime\");\n\nvar _default = (0, _createSvgIcon.default)( /*#__PURE__*/(0, _jsxRuntime.jsx)(\"path\", {\n  d: \"M3 17.25V21h3.75L17.81 9.94l-3.75-3.75L3 17.25zM20.71 7.04c.39-.39.39-1.02 0-1.41l-2.34-2.34a.9959.9959 0 0 0-1.41 0l-1.83 1.83 3.75 3.75 1.83-1.83z\"\n}), 'Edit');\n\nexports.default = _default;","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\nvar _createSvgIcon = _interopRequireDefault(require(\"./utils/createSvgIcon\"));\n\nvar _jsxRuntime = require(\"react/jsx-runtime\");\n\nvar _default = (0, _createSvgIcon.default)( /*#__PURE__*/(0, _jsxRuntime.jsx)(\"path\", {\n  d: \"m12 8-6 6 1.41 1.41L12 10.83l4.59 4.58L18 14z\"\n}), 'ExpandLess');\n\nexports.default = _default;","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\nvar _createSvgIcon = _interopRequireDefault(require(\"./utils/createSvgIcon\"));\n\nvar _jsxRuntime = require(\"react/jsx-runtime\");\n\nvar _default = (0, _createSvgIcon.default)( /*#__PURE__*/(0, _jsxRuntime.jsx)(\"path\", {\n  d: \"M16.59 8.59 12 13.17 7.41 8.59 6 10l6 6 6-6z\"\n}), 'ExpandMore');\n\nexports.default = _default;","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\nvar _createSvgIcon = _interopRequireDefault(require(\"./utils/createSvgIcon\"));\n\nvar _jsxRuntime = require(\"react/jsx-runtime\");\n\nvar _default = (0, _createSvgIcon.default)( /*#__PURE__*/(0, _jsxRuntime.jsx)(\"path\", {\n  d: \"M3 18h18v-2H3v2zm0-5h18v-2H3v2zm0-7v2h18V6H3z\"\n}), 'Menu');\n\nexports.default = _default;","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\nvar _createSvgIcon = _interopRequireDefault(require(\"./utils/createSvgIcon\"));\n\nvar _jsxRuntime = require(\"react/jsx-runtime\");\n\nvar _default = (0, _createSvgIcon.default)([/*#__PURE__*/(0, _jsxRuntime.jsx)(\"path\", {\n  d: \"M21 5c-1.11-.35-2.33-.5-3.5-.5-1.95 0-4.05.4-5.5 1.5-1.45-1.1-3.55-1.5-5.5-1.5S2.45 4.9 1 6v14.65c0 .25.25.5.5.5.1 0 .15-.05.25-.05C3.1 20.45 5.05 20 6.5 20c1.95 0 4.05.4 5.5 1.5 1.35-.85 3.8-1.5 5.5-1.5 1.65 0 3.35.3 4.75 1.05.1.05.15.05.25.05.25 0 .5-.25.5-.5V6c-.6-.45-1.25-.75-2-1zm0 13.5c-1.1-.35-2.3-.5-3.5-.5-1.7 0-4.15.65-5.5 1.5V8c1.35-.85 3.8-1.5 5.5-1.5 1.2 0 2.4.15 3.5.5v11.5z\"\n}, \"0\"), /*#__PURE__*/(0, _jsxRuntime.jsx)(\"path\", {\n  d: \"M17.5 10.5c.88 0 1.73.09 2.5.26V9.24c-.79-.15-1.64-.24-2.5-.24-1.7 0-3.24.29-4.5.83v1.66c1.13-.64 2.7-.99 4.5-.99zM13 12.49v1.66c1.13-.64 2.7-.99 4.5-.99.88 0 1.73.09 2.5.26V11.9c-.79-.15-1.64-.24-2.5-.24-1.7 0-3.24.3-4.5.83zm4.5 1.84c-1.7 0-3.24.29-4.5.83v1.66c1.13-.64 2.7-.99 4.5-.99.88 0 1.73.09 2.5.26v-1.52c-.79-.16-1.64-.24-2.5-.24z\"\n}, \"1\")], 'MenuBook');\n\nexports.default = _default;","import createSvgIcon from './utils/createSvgIcon';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport default createSvgIcon( /*#__PURE__*/_jsx(\"path\", {\n  d: \"M19 13h-6v6h-2v-6H5v-2h6V5h2v6h6v2z\"\n}), 'Add');","import createSvgIcon from './utils/createSvgIcon';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport default createSvgIcon( /*#__PURE__*/_jsx(\"path\", {\n  d: \"M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm-2 15-5-5 1.41-1.41L10 14.17l7.59-7.59L19 8l-9 9z\"\n}), 'CheckCircle');","import createSvgIcon from './utils/createSvgIcon';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport default createSvgIcon( /*#__PURE__*/_jsx(\"path\", {\n  d: \"M3 17.25V21h3.75L17.81 9.94l-3.75-3.75L3 17.25zM20.71 7.04c.39-.39.39-1.02 0-1.41l-2.34-2.34a.9959.9959 0 0 0-1.41 0l-1.83 1.83 3.75 3.75 1.83-1.83z\"\n}), 'Edit');","import createSvgIcon from './utils/createSvgIcon';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport default createSvgIcon( /*#__PURE__*/_jsx(\"path\", {\n  d: \"m12 8-6 6 1.41 1.41L12 10.83l4.59 4.58L18 14z\"\n}), 'ExpandLess');","import * as React from 'react';\nimport createSvgIcon from './utils/createSvgIcon';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport default createSvgIcon( /*#__PURE__*/_jsx(\"path\", {\n  d: \"M19 3a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14m-.5 15.5v-5.3a3.26 3.26 0 0 0-3.26-3.26c-.85 0-1.84.52-2.32 1.3v-1.11h-2.79v8.37h2.79v-4.93c0-.77.62-1.4 1.39-1.4a1.4 1.4 0 0 1 1.4 1.4v4.93h2.79M6.88 8.56a1.68 1.68 0 0 0 1.68-1.68c0-.93-.75-1.69-1.68-1.69a1.69 1.69 0 0 0-1.69 1.69c0 .93.76 1.68 1.69 1.68m1.39 9.94v-8.37H5.5v8.37h2.77z\"\n}), 'LinkedIn');","import createSvgIcon from './utils/createSvgIcon';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport default createSvgIcon( /*#__PURE__*/_jsx(\"path\", {\n  d: \"M12 8c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm0 2c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm0 6c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z\"\n}), 'MoreVert');","import createSvgIcon from './utils/createSvgIcon';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport default createSvgIcon( /*#__PURE__*/_jsx(\"path\", {\n  d: \"M1 21h22L12 2 1 21zm12-3h-2v-2h2v2zm0-4h-2v-4h2v4z\"\n}), 'Warning');","import createSvgIcon from './utils/createSvgIcon';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport default createSvgIcon( /*#__PURE__*/_jsx(\"path\", {\n  d: \"M20 6h-4V4c0-1.11-.89-2-2-2h-4c-1.11 0-2 .89-2 2v2H4c-1.11 0-1.99.89-1.99 2L2 19c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V8c0-1.11-.89-2-2-2zm-6 0h-4V4h4v2z\"\n}), 'Work');","import * as React from 'react';\nimport createSvgIcon from '../../utils/createSvgIcon';\n/**\n * @ignore - internal component.\n */\n\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport default createSvgIcon( /*#__PURE__*/_jsx(\"path\", {\n  d: \"M12 12c2.21 0 4-1.79 4-4s-1.79-4-4-4-4 1.79-4 4 1.79 4 4 4zm0 2c-2.67 0-8 1.34-8 4v2h16v-2c0-2.66-5.33-4-8-4z\"\n}), 'Person');","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nconst _excluded = [\"alt\", \"children\", \"className\", \"component\", \"imgProps\", \"sizes\", \"src\", \"srcSet\", \"variant\"];\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport clsx from 'clsx';\nimport { unstable_composeClasses as composeClasses } from '@mui/base';\nimport styled from '../styles/styled';\nimport useThemeProps from '../styles/useThemeProps';\nimport Person from '../internal/svg-icons/Person';\nimport { getAvatarUtilityClass } from './avatarClasses';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\n\nconst useUtilityClasses = ownerState => {\n  const {\n    classes,\n    variant,\n    colorDefault\n  } = ownerState;\n  const slots = {\n    root: ['root', variant, colorDefault && 'colorDefault'],\n    img: ['img'],\n    fallback: ['fallback']\n  };\n  return composeClasses(slots, getAvatarUtilityClass, classes);\n};\n\nconst AvatarRoot = styled('div', {\n  name: 'MuiAvatar',\n  slot: 'Root',\n  overridesResolver: (props, styles) => {\n    const {\n      ownerState\n    } = props;\n    return [styles.root, styles[ownerState.variant], ownerState.colorDefault && styles.colorDefault];\n  }\n})(({\n  theme,\n  ownerState\n}) => _extends({\n  position: 'relative',\n  display: 'flex',\n  alignItems: 'center',\n  justifyContent: 'center',\n  flexShrink: 0,\n  width: 40,\n  height: 40,\n  fontFamily: theme.typography.fontFamily,\n  fontSize: theme.typography.pxToRem(20),\n  lineHeight: 1,\n  borderRadius: '50%',\n  overflow: 'hidden',\n  userSelect: 'none'\n}, ownerState.variant === 'rounded' && {\n  borderRadius: theme.shape.borderRadius\n}, ownerState.variant === 'square' && {\n  borderRadius: 0\n}, ownerState.colorDefault && {\n  color: theme.palette.background.default,\n  backgroundColor: theme.palette.mode === 'light' ? theme.palette.grey[400] : theme.palette.grey[600]\n}));\nconst AvatarImg = styled('img', {\n  name: 'MuiAvatar',\n  slot: 'Img',\n  overridesResolver: (props, styles) => styles.img\n})({\n  width: '100%',\n  height: '100%',\n  textAlign: 'center',\n  // Handle non-square image. The property isn't supported by IE11.\n  objectFit: 'cover',\n  // Hide alt text.\n  color: 'transparent',\n  // Hide the image broken icon, only works on Chrome.\n  textIndent: 10000\n});\nconst AvatarFallback = styled(Person, {\n  name: 'MuiAvatar',\n  slot: 'Fallback',\n  overridesResolver: (props, styles) => styles.fallback\n})({\n  width: '75%',\n  height: '75%'\n});\n\nfunction useLoaded({\n  crossOrigin,\n  referrerPolicy,\n  src,\n  srcSet\n}) {\n  const [loaded, setLoaded] = React.useState(false);\n  React.useEffect(() => {\n    if (!src && !srcSet) {\n      return undefined;\n    }\n\n    setLoaded(false);\n    let active = true;\n    const image = new Image();\n\n    image.onload = () => {\n      if (!active) {\n        return;\n      }\n\n      setLoaded('loaded');\n    };\n\n    image.onerror = () => {\n      if (!active) {\n        return;\n      }\n\n      setLoaded('error');\n    };\n\n    image.crossOrigin = crossOrigin;\n    image.referrerPolicy = referrerPolicy;\n    image.src = src;\n\n    if (srcSet) {\n      image.srcset = srcSet;\n    }\n\n    return () => {\n      active = false;\n    };\n  }, [crossOrigin, referrerPolicy, src, srcSet]);\n  return loaded;\n}\n\nconst Avatar = /*#__PURE__*/React.forwardRef(function Avatar(inProps, ref) {\n  const props = useThemeProps({\n    props: inProps,\n    name: 'MuiAvatar'\n  });\n\n  const {\n    alt,\n    children: childrenProp,\n    className,\n    component = 'div',\n    imgProps,\n    sizes,\n    src,\n    srcSet,\n    variant = 'circular'\n  } = props,\n        other = _objectWithoutPropertiesLoose(props, _excluded);\n\n  let children = null; // Use a hook instead of onError on the img element to support server-side rendering.\n\n  const loaded = useLoaded(_extends({}, imgProps, {\n    src,\n    srcSet\n  }));\n  const hasImg = src || srcSet;\n  const hasImgNotFailing = hasImg && loaded !== 'error';\n\n  const ownerState = _extends({}, props, {\n    colorDefault: !hasImgNotFailing,\n    component,\n    variant\n  });\n\n  const classes = useUtilityClasses(ownerState);\n\n  if (hasImgNotFailing) {\n    children = /*#__PURE__*/_jsx(AvatarImg, _extends({\n      alt: alt,\n      src: src,\n      srcSet: srcSet,\n      sizes: sizes,\n      ownerState: ownerState,\n      className: classes.img\n    }, imgProps));\n  } else if (childrenProp != null) {\n    children = childrenProp;\n  } else if (hasImg && alt) {\n    children = alt[0];\n  } else {\n    children = /*#__PURE__*/_jsx(AvatarFallback, {\n      className: classes.fallback\n    });\n  }\n\n  return /*#__PURE__*/_jsx(AvatarRoot, _extends({\n    as: component,\n    ownerState: ownerState,\n    className: clsx(classes.root, className),\n    ref: ref\n  }, other, {\n    children: children\n  }));\n});\nprocess.env.NODE_ENV !== \"production\" ? Avatar.propTypes\n/* remove-proptypes */\n= {\n  // ----------------------------- Warning --------------------------------\n  // | These PropTypes are generated from the TypeScript type definitions |\n  // |     To update them edit the d.ts file and run \"yarn proptypes\"     |\n  // ----------------------------------------------------------------------\n\n  /**\n   * Used in combination with `src` or `srcSet` to\n   * provide an alt attribute for the rendered `img` element.\n   */\n  alt: PropTypes.string,\n\n  /**\n   * Used to render icon or text elements inside the Avatar if `src` is not set.\n   * This can be an element, or just a string.\n   */\n  children: PropTypes.node,\n\n  /**\n   * Override or extend the styles applied to the component.\n   */\n  classes: PropTypes.object,\n\n  /**\n   * @ignore\n   */\n  className: PropTypes.string,\n\n  /**\n   * The component used for the root node.\n   * Either a string to use a HTML element or a component.\n   */\n  component: PropTypes.elementType,\n\n  /**\n   * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/img#attributes) applied to the `img` element if the component is used to display an image.\n   * It can be used to listen for the loading error event.\n   */\n  imgProps: PropTypes.object,\n\n  /**\n   * The `sizes` attribute for the `img` element.\n   */\n  sizes: PropTypes.string,\n\n  /**\n   * The `src` attribute for the `img` element.\n   */\n  src: PropTypes.string,\n\n  /**\n   * The `srcSet` attribute for the `img` element.\n   * Use this attribute for responsive image display.\n   */\n  srcSet: PropTypes.string,\n\n  /**\n   * The system prop that allows defining system overrides as well as additional CSS styles.\n   */\n  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),\n\n  /**\n   * The shape of the avatar.\n   * @default 'circular'\n   */\n  variant: PropTypes\n  /* @typescript-to-proptypes-ignore */\n  .oneOfType([PropTypes.oneOf(['circular', 'rounded', 'square']), PropTypes.string])\n} : void 0;\nexport default Avatar;","import { generateUtilityClass, generateUtilityClasses } from '@mui/base';\nexport function getAvatarUtilityClass(slot) {\n  return generateUtilityClass('MuiAvatar', slot);\n}\nconst avatarClasses = generateUtilityClasses('MuiAvatar', ['root', 'colorDefault', 'circular', 'rounded', 'square', 'img', 'fallback']);\nexport default avatarClasses;","import { generateUtilityClass, generateUtilityClasses } from '@mui/base';\nexport function getAvatarGroupUtilityClass(slot) {\n  return generateUtilityClass('MuiAvatarGroup', slot);\n}\nconst avatarGroupClasses = generateUtilityClasses('MuiAvatarGroup', ['root', 'avatar']);\nexport default avatarGroupClasses;","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nconst _excluded = [\"children\", \"className\", \"componentsProps\", \"max\", \"spacing\", \"total\", \"variant\"];\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { isFragment } from 'react-is';\nimport clsx from 'clsx';\nimport { chainPropTypes } from '@mui/utils';\nimport { unstable_composeClasses as composeClasses } from '@mui/base';\nimport styled from '../styles/styled';\nimport useThemeProps from '../styles/useThemeProps';\nimport Avatar, { avatarClasses } from '../Avatar';\nimport avatarGroupClasses, { getAvatarGroupUtilityClass } from './avatarGroupClasses';\nimport { jsxs as _jsxs } from \"react/jsx-runtime\";\nconst SPACINGS = {\n  small: -16,\n  medium: null\n};\n\nconst useUtilityClasses = ownerState => {\n  const {\n    classes\n  } = ownerState;\n  const slots = {\n    root: ['root'],\n    avatar: ['avatar']\n  };\n  return composeClasses(slots, getAvatarGroupUtilityClass, classes);\n};\n\nconst AvatarGroupRoot = styled('div', {\n  name: 'MuiAvatarGroup',\n  slot: 'Root',\n  overridesResolver: (props, styles) => _extends({\n    [`& .${avatarGroupClasses.avatar}`]: styles.avatar\n  }, styles.root)\n})(({\n  theme\n}) => ({\n  [`& .${avatarClasses.root}`]: {\n    border: `2px solid ${(theme.vars || theme).palette.background.default}`,\n    boxSizing: 'content-box',\n    marginLeft: -8,\n    '&:last-child': {\n      marginLeft: 0\n    }\n  },\n  display: 'flex',\n  flexDirection: 'row-reverse'\n}));\nconst AvatarGroupAvatar = styled(Avatar, {\n  name: 'MuiAvatarGroup',\n  slot: 'Avatar',\n  overridesResolver: (props, styles) => styles.avatar\n})(({\n  theme\n}) => ({\n  border: `2px solid ${(theme.vars || theme).palette.background.default}`,\n  boxSizing: 'content-box',\n  marginLeft: -8,\n  '&:last-child': {\n    marginLeft: 0\n  }\n}));\nconst AvatarGroup = /*#__PURE__*/React.forwardRef(function AvatarGroup(inProps, ref) {\n  var _componentsProps$addi, _componentsProps$addi2;\n\n  const props = useThemeProps({\n    props: inProps,\n    name: 'MuiAvatarGroup'\n  });\n\n  const {\n    children: childrenProp,\n    className,\n    componentsProps = {},\n    max = 5,\n    spacing = 'medium',\n    total,\n    variant = 'circular'\n  } = props,\n        other = _objectWithoutPropertiesLoose(props, _excluded);\n\n  let clampedMax = max < 2 ? 2 : max;\n\n  const ownerState = _extends({}, props, {\n    max,\n    spacing,\n    variant\n  });\n\n  const classes = useUtilityClasses(ownerState);\n  const children = React.Children.toArray(childrenProp).filter(child => {\n    if (process.env.NODE_ENV !== 'production') {\n      if (isFragment(child)) {\n        console.error([\"MUI: The AvatarGroup component doesn't accept a Fragment as a child.\", 'Consider providing an array instead.'].join('\\n'));\n      }\n    }\n\n    return /*#__PURE__*/React.isValidElement(child);\n  });\n  const totalAvatars = total || children.length;\n\n  if (totalAvatars === clampedMax) {\n    clampedMax += 1;\n  }\n\n  clampedMax = Math.min(totalAvatars + 1, clampedMax);\n  const maxAvatars = Math.min(children.length, clampedMax - 1);\n  const extraAvatars = Math.max(totalAvatars - clampedMax, totalAvatars - maxAvatars, 0);\n  const marginLeft = spacing && SPACINGS[spacing] !== undefined ? SPACINGS[spacing] : -spacing;\n  return /*#__PURE__*/_jsxs(AvatarGroupRoot, _extends({\n    ownerState: ownerState,\n    className: clsx(classes.root, className),\n    ref: ref\n  }, other, {\n    children: [extraAvatars ? /*#__PURE__*/_jsxs(AvatarGroupAvatar, _extends({\n      ownerState: ownerState,\n      variant: variant\n    }, componentsProps.additionalAvatar, {\n      className: clsx(classes.avatar, (_componentsProps$addi = componentsProps.additionalAvatar) == null ? void 0 : _componentsProps$addi.className),\n      style: _extends({\n        marginLeft\n      }, (_componentsProps$addi2 = componentsProps.additionalAvatar) == null ? void 0 : _componentsProps$addi2.style),\n      children: [\"+\", extraAvatars]\n    })) : null, children.slice(0, maxAvatars).reverse().map((child, index) => {\n      return /*#__PURE__*/React.cloneElement(child, {\n        className: clsx(child.props.className, classes.avatar),\n        style: _extends({\n          // Consistent with \"&:last-child\" styling for the default spacing,\n          // we do not apply custom marginLeft spacing on the last child\n          marginLeft: index === maxAvatars - 1 ? undefined : marginLeft\n        }, child.props.style),\n        variant: child.props.variant || variant\n      });\n    })]\n  }));\n});\nprocess.env.NODE_ENV !== \"production\" ? AvatarGroup.propTypes\n/* remove-proptypes */\n= {\n  // ----------------------------- Warning --------------------------------\n  // | These PropTypes are generated from the TypeScript type definitions |\n  // |     To update them edit the d.ts file and run \"yarn proptypes\"     |\n  // ----------------------------------------------------------------------\n\n  /**\n   * The avatars to stack.\n   */\n  children: PropTypes.node,\n\n  /**\n   * Override or extend the styles applied to the component.\n   */\n  classes: PropTypes.object,\n\n  /**\n   * @ignore\n   */\n  className: PropTypes.string,\n\n  /**\n   * The props used for each slot inside the AvatarGroup.\n   * @default {}\n   */\n  componentsProps: PropTypes.shape({\n    additionalAvatar: PropTypes.object\n  }),\n\n  /**\n   * Max avatars to show before +x.\n   * @default 5\n   */\n  max: chainPropTypes(PropTypes.number, props => {\n    if (props.max < 2) {\n      return new Error(['MUI: The prop `max` should be equal to 2 or above.', 'A value below is clamped to 2.'].join('\\n'));\n    }\n\n    return null;\n  }),\n\n  /**\n   * Spacing between avatars.\n   * @default 'medium'\n   */\n  spacing: PropTypes.oneOfType([PropTypes.oneOf(['medium', 'small']), PropTypes.number]),\n\n  /**\n   * The system prop that allows defining system overrides as well as additional CSS styles.\n   */\n  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),\n\n  /**\n   * The total number of avatars. Used for calculating the number of extra avatars.\n   * @default children.length\n   */\n  total: PropTypes.number,\n\n  /**\n   * The variant to use.\n   * @default 'circular'\n   */\n  variant: PropTypes\n  /* @typescript-to-proptypes-ignore */\n  .oneOfType([PropTypes.oneOf(['circular', 'rounded', 'square']), PropTypes.string])\n} : void 0;\nexport default AvatarGroup;","import { generateUtilityClass, generateUtilityClasses } from '@mui/base';\nexport function getCardMediaUtilityClass(slot) {\n  return generateUtilityClass('MuiCardMedia', slot);\n}\nconst cardMediaClasses = generateUtilityClasses('MuiCardMedia', ['root', 'media', 'img']);\nexport default cardMediaClasses;","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nconst _excluded = [\"children\", \"className\", \"component\", \"image\", \"src\", \"style\"];\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport clsx from 'clsx';\nimport { chainPropTypes } from '@mui/utils';\nimport { unstable_composeClasses as composeClasses } from '@mui/base';\nimport useThemeProps from '../styles/useThemeProps';\nimport styled from '../styles/styled';\nimport { getCardMediaUtilityClass } from './cardMediaClasses';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\n\nconst useUtilityClasses = ownerState => {\n  const {\n    classes,\n    isMediaComponent,\n    isImageComponent\n  } = ownerState;\n  const slots = {\n    root: ['root', isMediaComponent && 'media', isImageComponent && 'img']\n  };\n  return composeClasses(slots, getCardMediaUtilityClass, classes);\n};\n\nconst CardMediaRoot = styled('div', {\n  name: 'MuiCardMedia',\n  slot: 'Root',\n  overridesResolver: (props, styles) => {\n    const {\n      ownerState\n    } = props;\n    const {\n      isMediaComponent,\n      isImageComponent\n    } = ownerState;\n    return [styles.root, isMediaComponent && styles.media, isImageComponent && styles.img];\n  }\n})(({\n  ownerState\n}) => _extends({\n  display: 'block',\n  backgroundSize: 'cover',\n  backgroundRepeat: 'no-repeat',\n  backgroundPosition: 'center'\n}, ownerState.isMediaComponent && {\n  width: '100%'\n}, ownerState.isImageComponent && {\n  // ⚠️ object-fit is not supported by IE11.\n  objectFit: 'cover'\n}));\nconst MEDIA_COMPONENTS = ['video', 'audio', 'picture', 'iframe', 'img'];\nconst IMAGE_COMPONENTS = ['picture', 'img'];\nconst CardMedia = /*#__PURE__*/React.forwardRef(function CardMedia(inProps, ref) {\n  const props = useThemeProps({\n    props: inProps,\n    name: 'MuiCardMedia'\n  });\n\n  const {\n    children,\n    className,\n    component = 'div',\n    image,\n    src,\n    style\n  } = props,\n        other = _objectWithoutPropertiesLoose(props, _excluded);\n\n  const isMediaComponent = MEDIA_COMPONENTS.indexOf(component) !== -1;\n  const composedStyle = !isMediaComponent && image ? _extends({\n    backgroundImage: `url(\"${image}\")`\n  }, style) : style;\n\n  const ownerState = _extends({}, props, {\n    component,\n    isMediaComponent,\n    isImageComponent: IMAGE_COMPONENTS.indexOf(component) !== -1\n  });\n\n  const classes = useUtilityClasses(ownerState);\n  return /*#__PURE__*/_jsx(CardMediaRoot, _extends({\n    className: clsx(classes.root, className),\n    as: component,\n    role: !isMediaComponent && image ? 'img' : undefined,\n    ref: ref,\n    style: composedStyle,\n    ownerState: ownerState,\n    src: isMediaComponent ? image || src : undefined\n  }, other, {\n    children: children\n  }));\n});\nprocess.env.NODE_ENV !== \"production\" ? CardMedia.propTypes\n/* remove-proptypes */\n= {\n  // ----------------------------- Warning --------------------------------\n  // | These PropTypes are generated from the TypeScript type definitions |\n  // |     To update them edit the d.ts file and run \"yarn proptypes\"     |\n  // ----------------------------------------------------------------------\n\n  /**\n   * The content of the component.\n   */\n  children: chainPropTypes(PropTypes.node, props => {\n    if (!props.children && !props.image && !props.src && !props.component) {\n      return new Error('MUI: Either `children`, `image`, `src` or `component` prop must be specified.');\n    }\n\n    return null;\n  }),\n\n  /**\n   * Override or extend the styles applied to the component.\n   */\n  classes: PropTypes.object,\n\n  /**\n   * @ignore\n   */\n  className: PropTypes.string,\n\n  /**\n   * The component used for the root node.\n   * Either a string to use a HTML element or a component.\n   */\n  component: PropTypes.elementType,\n\n  /**\n   * Image to be displayed as a background image.\n   * Either `image` or `src` prop must be specified.\n   * Note that caller must specify height otherwise the image will not be visible.\n   */\n  image: PropTypes.string,\n\n  /**\n   * An alias for `image` property.\n   * Available only with media components.\n   * Media components: `video`, `audio`, `picture`, `iframe`, `img`.\n   */\n  src: PropTypes.string,\n\n  /**\n   * @ignore\n   */\n  style: PropTypes.object,\n\n  /**\n   * The system prop that allows defining system overrides as well as additional CSS styles.\n   */\n  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])\n} : void 0;\nexport default CardMedia;","import { generateUtilityClass, generateUtilityClasses } from '@mui/base';\nexport function getFormGroupUtilityClass(slot) {\n  return generateUtilityClass('MuiFormGroup', slot);\n}\nconst formGroupClasses = generateUtilityClasses('MuiFormGroup', ['root', 'row', 'error']);\nexport default formGroupClasses;","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nconst _excluded = [\"className\", \"row\"];\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport clsx from 'clsx';\nimport { unstable_composeClasses as composeClasses } from '@mui/base';\nimport styled from '../styles/styled';\nimport useThemeProps from '../styles/useThemeProps';\nimport { getFormGroupUtilityClass } from './formGroupClasses';\nimport useFormControl from '../FormControl/useFormControl';\nimport formControlState from '../FormControl/formControlState';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\n\nconst useUtilityClasses = ownerState => {\n  const {\n    classes,\n    row,\n    error\n  } = ownerState;\n  const slots = {\n    root: ['root', row && 'row', error && 'error']\n  };\n  return composeClasses(slots, getFormGroupUtilityClass, classes);\n};\n\nconst FormGroupRoot = styled('div', {\n  name: 'MuiFormGroup',\n  slot: 'Root',\n  overridesResolver: (props, styles) => {\n    const {\n      ownerState\n    } = props;\n    return [styles.root, ownerState.row && styles.row];\n  }\n})(({\n  ownerState\n}) => _extends({\n  display: 'flex',\n  flexDirection: 'column',\n  flexWrap: 'wrap'\n}, ownerState.row && {\n  flexDirection: 'row'\n}));\n/**\n * `FormGroup` wraps controls such as `Checkbox` and `Switch`.\n * It provides compact row layout.\n * For the `Radio`, you should be using the `RadioGroup` component instead of this one.\n */\n\nconst FormGroup = /*#__PURE__*/React.forwardRef(function FormGroup(inProps, ref) {\n  const props = useThemeProps({\n    props: inProps,\n    name: 'MuiFormGroup'\n  });\n\n  const {\n    className,\n    row = false\n  } = props,\n        other = _objectWithoutPropertiesLoose(props, _excluded);\n\n  const muiFormControl = useFormControl();\n  const fcs = formControlState({\n    props,\n    muiFormControl,\n    states: ['error']\n  });\n\n  const ownerState = _extends({}, props, {\n    row,\n    error: fcs.error\n  });\n\n  const classes = useUtilityClasses(ownerState);\n  return /*#__PURE__*/_jsx(FormGroupRoot, _extends({\n    className: clsx(classes.root, className),\n    ownerState: ownerState,\n    ref: ref\n  }, other));\n});\nprocess.env.NODE_ENV !== \"production\" ? FormGroup.propTypes\n/* remove-proptypes */\n= {\n  // ----------------------------- Warning --------------------------------\n  // | These PropTypes are generated from the TypeScript type definitions |\n  // |     To update them edit the d.ts file and run \"yarn proptypes\"     |\n  // ----------------------------------------------------------------------\n\n  /**\n   * The content of the component.\n   */\n  children: PropTypes.node,\n\n  /**\n   * Override or extend the styles applied to the component.\n   */\n  classes: PropTypes.object,\n\n  /**\n   * @ignore\n   */\n  className: PropTypes.string,\n\n  /**\n   * Display group of elements in a compact row.\n   * @default false\n   */\n  row: PropTypes.bool,\n\n  /**\n   * The system prop that allows defining system overrides as well as additional CSS styles.\n   */\n  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])\n} : void 0;\nexport default FormGroup;","import { generateUtilityClass, generateUtilityClasses } from '@mui/base';\nexport function getInputAdornmentUtilityClass(slot) {\n  return generateUtilityClass('MuiInputAdornment', slot);\n}\nconst inputAdornmentClasses = generateUtilityClasses('MuiInputAdornment', ['root', 'filled', 'standard', 'outlined', 'positionStart', 'positionEnd', 'disablePointerEvents', 'hiddenLabel', 'sizeSmall']);\nexport default inputAdornmentClasses;","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\n\nvar _span;\n\nconst _excluded = [\"children\", \"className\", \"component\", \"disablePointerEvents\", \"disableTypography\", \"position\", \"variant\"];\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport clsx from 'clsx';\nimport { unstable_composeClasses as composeClasses } from '@mui/base';\nimport capitalize from '../utils/capitalize';\nimport Typography from '../Typography';\nimport FormControlContext from '../FormControl/FormControlContext';\nimport useFormControl from '../FormControl/useFormControl';\nimport styled from '../styles/styled';\nimport inputAdornmentClasses, { getInputAdornmentUtilityClass } from './inputAdornmentClasses';\nimport useThemeProps from '../styles/useThemeProps';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nimport { jsxs as _jsxs } from \"react/jsx-runtime\";\n\nconst overridesResolver = (props, styles) => {\n  const {\n    ownerState\n  } = props;\n  return [styles.root, styles[`position${capitalize(ownerState.position)}`], ownerState.disablePointerEvents === true && styles.disablePointerEvents, styles[ownerState.variant]];\n};\n\nconst useUtilityClasses = ownerState => {\n  const {\n    classes,\n    disablePointerEvents,\n    hiddenLabel,\n    position,\n    size,\n    variant\n  } = ownerState;\n  const slots = {\n    root: ['root', disablePointerEvents && 'disablePointerEvents', position && `position${capitalize(position)}`, variant, hiddenLabel && 'hiddenLabel', size && `size${capitalize(size)}`]\n  };\n  return composeClasses(slots, getInputAdornmentUtilityClass, classes);\n};\n\nconst InputAdornmentRoot = styled('div', {\n  name: 'MuiInputAdornment',\n  slot: 'Root',\n  overridesResolver\n})(({\n  theme,\n  ownerState\n}) => _extends({\n  display: 'flex',\n  height: '0.01em',\n  // Fix IE11 flexbox alignment. To remove at some point.\n  maxHeight: '2em',\n  alignItems: 'center',\n  whiteSpace: 'nowrap',\n  color: (theme.vars || theme).palette.action.active\n}, ownerState.variant === 'filled' && {\n  // Styles applied to the root element if `variant=\"filled\"`.\n  [`&.${inputAdornmentClasses.positionStart}&:not(.${inputAdornmentClasses.hiddenLabel})`]: {\n    marginTop: 16\n  }\n}, ownerState.position === 'start' && {\n  // Styles applied to the root element if `position=\"start\"`.\n  marginRight: 8\n}, ownerState.position === 'end' && {\n  // Styles applied to the root element if `position=\"end\"`.\n  marginLeft: 8\n}, ownerState.disablePointerEvents === true && {\n  // Styles applied to the root element if `disablePointerEvents={true}`.\n  pointerEvents: 'none'\n}));\nconst InputAdornment = /*#__PURE__*/React.forwardRef(function InputAdornment(inProps, ref) {\n  const props = useThemeProps({\n    props: inProps,\n    name: 'MuiInputAdornment'\n  });\n\n  const {\n    children,\n    className,\n    component = 'div',\n    disablePointerEvents = false,\n    disableTypography = false,\n    position,\n    variant: variantProp\n  } = props,\n        other = _objectWithoutPropertiesLoose(props, _excluded);\n\n  const muiFormControl = useFormControl() || {};\n  let variant = variantProp;\n\n  if (variantProp && muiFormControl.variant) {\n    if (process.env.NODE_ENV !== 'production') {\n      if (variantProp === muiFormControl.variant) {\n        console.error('MUI: The `InputAdornment` variant infers the variant prop ' + 'you do not have to provide one.');\n      }\n    }\n  }\n\n  if (muiFormControl && !variant) {\n    variant = muiFormControl.variant;\n  }\n\n  const ownerState = _extends({}, props, {\n    hiddenLabel: muiFormControl.hiddenLabel,\n    size: muiFormControl.size,\n    disablePointerEvents,\n    position,\n    variant\n  });\n\n  const classes = useUtilityClasses(ownerState);\n  return /*#__PURE__*/_jsx(FormControlContext.Provider, {\n    value: null,\n    children: /*#__PURE__*/_jsx(InputAdornmentRoot, _extends({\n      as: component,\n      ownerState: ownerState,\n      className: clsx(classes.root, className),\n      ref: ref\n    }, other, {\n      children: typeof children === 'string' && !disableTypography ? /*#__PURE__*/_jsx(Typography, {\n        color: \"text.secondary\",\n        children: children\n      }) : /*#__PURE__*/_jsxs(React.Fragment, {\n        children: [position === 'start' ?\n        /* notranslate needed while Google Translate will not fix zero-width space issue */\n        _span || (_span = /*#__PURE__*/_jsx(\"span\", {\n          className: \"notranslate\",\n          children: \"\\u200B\"\n        })) : null, children]\n      })\n    }))\n  });\n});\nprocess.env.NODE_ENV !== \"production\" ? InputAdornment.propTypes\n/* remove-proptypes */\n= {\n  // ----------------------------- Warning --------------------------------\n  // | These PropTypes are generated from the TypeScript type definitions |\n  // |     To update them edit the d.ts file and run \"yarn proptypes\"     |\n  // ----------------------------------------------------------------------\n\n  /**\n   * The content of the component, normally an `IconButton` or string.\n   */\n  children: PropTypes.node,\n\n  /**\n   * Override or extend the styles applied to the component.\n   */\n  classes: PropTypes.object,\n\n  /**\n   * @ignore\n   */\n  className: PropTypes.string,\n\n  /**\n   * The component used for the root node.\n   * Either a string to use a HTML element or a component.\n   */\n  component: PropTypes.elementType,\n\n  /**\n   * Disable pointer events on the root.\n   * This allows for the content of the adornment to focus the `input` on click.\n   * @default false\n   */\n  disablePointerEvents: PropTypes.bool,\n\n  /**\n   * If children is a string then disable wrapping in a Typography component.\n   * @default false\n   */\n  disableTypography: PropTypes.bool,\n\n  /**\n   * The position this adornment should appear relative to the `Input`.\n   */\n  position: PropTypes.oneOf(['end', 'start']).isRequired,\n\n  /**\n   * The system prop that allows defining system overrides as well as additional CSS styles.\n   */\n  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),\n\n  /**\n   * The variant to use.\n   * Note: If you are using the `TextField` component or the `FormControl` component\n   * you do not have to set this manually.\n   */\n  variant: PropTypes.oneOf(['filled', 'outlined', 'standard'])\n} : void 0;\nexport default InputAdornment;","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nconst _excluded = [\"className\", \"color\", \"value\", \"valueBuffer\", \"variant\"];\n\nlet _ = t => t,\n    _t,\n    _t2,\n    _t3,\n    _t4,\n    _t5,\n    _t6;\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport clsx from 'clsx';\nimport { unstable_composeClasses as composeClasses } from '@mui/base';\nimport { keyframes, css, darken, lighten } from '@mui/system';\nimport capitalize from '../utils/capitalize';\nimport useTheme from '../styles/useTheme';\nimport styled from '../styles/styled';\nimport useThemeProps from '../styles/useThemeProps';\nimport { getLinearProgressUtilityClass } from './linearProgressClasses';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nimport { jsxs as _jsxs } from \"react/jsx-runtime\";\nconst TRANSITION_DURATION = 4; // seconds\n\nconst indeterminate1Keyframe = keyframes(_t || (_t = _`\n  0% {\n    left: -35%;\n    right: 100%;\n  }\n\n  60% {\n    left: 100%;\n    right: -90%;\n  }\n\n  100% {\n    left: 100%;\n    right: -90%;\n  }\n`));\nconst indeterminate2Keyframe = keyframes(_t2 || (_t2 = _`\n  0% {\n    left: -200%;\n    right: 100%;\n  }\n\n  60% {\n    left: 107%;\n    right: -8%;\n  }\n\n  100% {\n    left: 107%;\n    right: -8%;\n  }\n`));\nconst bufferKeyframe = keyframes(_t3 || (_t3 = _`\n  0% {\n    opacity: 1;\n    background-position: 0 -23px;\n  }\n\n  60% {\n    opacity: 0;\n    background-position: 0 -23px;\n  }\n\n  100% {\n    opacity: 1;\n    background-position: -200px -23px;\n  }\n`));\n\nconst useUtilityClasses = ownerState => {\n  const {\n    classes,\n    variant,\n    color\n  } = ownerState;\n  const slots = {\n    root: ['root', `color${capitalize(color)}`, variant],\n    dashed: ['dashed', `dashedColor${capitalize(color)}`],\n    bar1: ['bar', `barColor${capitalize(color)}`, (variant === 'indeterminate' || variant === 'query') && 'bar1Indeterminate', variant === 'determinate' && 'bar1Determinate', variant === 'buffer' && 'bar1Buffer'],\n    bar2: ['bar', variant !== 'buffer' && `barColor${capitalize(color)}`, variant === 'buffer' && `color${capitalize(color)}`, (variant === 'indeterminate' || variant === 'query') && 'bar2Indeterminate', variant === 'buffer' && 'bar2Buffer']\n  };\n  return composeClasses(slots, getLinearProgressUtilityClass, classes);\n};\n\nconst getColorShade = (theme, color) => {\n  if (color === 'inherit') {\n    return 'currentColor';\n  }\n\n  return theme.palette.mode === 'light' ? lighten(theme.palette[color].main, 0.62) : darken(theme.palette[color].main, 0.5);\n};\n\nconst LinearProgressRoot = styled('span', {\n  name: 'MuiLinearProgress',\n  slot: 'Root',\n  overridesResolver: (props, styles) => {\n    const {\n      ownerState\n    } = props;\n    return [styles.root, styles[`color${capitalize(ownerState.color)}`], styles[ownerState.variant]];\n  }\n})(({\n  ownerState,\n  theme\n}) => _extends({\n  position: 'relative',\n  overflow: 'hidden',\n  display: 'block',\n  height: 4,\n  zIndex: 0,\n  // Fix Safari's bug during composition of different paint.\n  '@media print': {\n    colorAdjust: 'exact'\n  },\n  backgroundColor: getColorShade(theme, ownerState.color)\n}, ownerState.color === 'inherit' && ownerState.variant !== 'buffer' && {\n  backgroundColor: 'none',\n  '&::before': {\n    content: '\"\"',\n    position: 'absolute',\n    left: 0,\n    top: 0,\n    right: 0,\n    bottom: 0,\n    backgroundColor: 'currentColor',\n    opacity: 0.3\n  }\n}, ownerState.variant === 'buffer' && {\n  backgroundColor: 'transparent'\n}, ownerState.variant === 'query' && {\n  transform: 'rotate(180deg)'\n}));\nconst LinearProgressDashed = styled('span', {\n  name: 'MuiLinearProgress',\n  slot: 'Dashed',\n  overridesResolver: (props, styles) => {\n    const {\n      ownerState\n    } = props;\n    return [styles.dashed, styles[`dashedColor${capitalize(ownerState.color)}`]];\n  }\n})(({\n  ownerState,\n  theme\n}) => {\n  const backgroundColor = getColorShade(theme, ownerState.color);\n  return _extends({\n    position: 'absolute',\n    marginTop: 0,\n    height: '100%',\n    width: '100%'\n  }, ownerState.color === 'inherit' && {\n    opacity: 0.3\n  }, {\n    backgroundImage: `radial-gradient(${backgroundColor} 0%, ${backgroundColor} 16%, transparent 42%)`,\n    backgroundSize: '10px 10px',\n    backgroundPosition: '0 -23px'\n  });\n}, css(_t4 || (_t4 = _`\n    animation: ${0} 3s infinite linear;\n  `), bufferKeyframe));\nconst LinearProgressBar1 = styled('span', {\n  name: 'MuiLinearProgress',\n  slot: 'Bar1',\n  overridesResolver: (props, styles) => {\n    const {\n      ownerState\n    } = props;\n    return [styles.bar, styles[`barColor${capitalize(ownerState.color)}`], (ownerState.variant === 'indeterminate' || ownerState.variant === 'query') && styles.bar1Indeterminate, ownerState.variant === 'determinate' && styles.bar1Determinate, ownerState.variant === 'buffer' && styles.bar1Buffer];\n  }\n})(({\n  ownerState,\n  theme\n}) => _extends({\n  width: '100%',\n  position: 'absolute',\n  left: 0,\n  bottom: 0,\n  top: 0,\n  transition: 'transform 0.2s linear',\n  transformOrigin: 'left',\n  backgroundColor: ownerState.color === 'inherit' ? 'currentColor' : theme.palette[ownerState.color].main\n}, ownerState.variant === 'determinate' && {\n  transition: `transform .${TRANSITION_DURATION}s linear`\n}, ownerState.variant === 'buffer' && {\n  zIndex: 1,\n  transition: `transform .${TRANSITION_DURATION}s linear`\n}), ({\n  ownerState\n}) => (ownerState.variant === 'indeterminate' || ownerState.variant === 'query') && css(_t5 || (_t5 = _`\n      width: auto;\n      animation: ${0} 2.1s cubic-bezier(0.65, 0.815, 0.735, 0.395) infinite;\n    `), indeterminate1Keyframe));\nconst LinearProgressBar2 = styled('span', {\n  name: 'MuiLinearProgress',\n  slot: 'Bar2',\n  overridesResolver: (props, styles) => {\n    const {\n      ownerState\n    } = props;\n    return [styles.bar, styles[`barColor${capitalize(ownerState.color)}`], (ownerState.variant === 'indeterminate' || ownerState.variant === 'query') && styles.bar2Indeterminate, ownerState.variant === 'buffer' && styles.bar2Buffer];\n  }\n})(({\n  ownerState,\n  theme\n}) => _extends({\n  width: '100%',\n  position: 'absolute',\n  left: 0,\n  bottom: 0,\n  top: 0,\n  transition: 'transform 0.2s linear',\n  transformOrigin: 'left'\n}, ownerState.variant !== 'buffer' && {\n  backgroundColor: ownerState.color === 'inherit' ? 'currentColor' : theme.palette[ownerState.color].main\n}, ownerState.color === 'inherit' && {\n  opacity: 0.3\n}, ownerState.variant === 'buffer' && {\n  backgroundColor: getColorShade(theme, ownerState.color),\n  transition: `transform .${TRANSITION_DURATION}s linear`\n}), ({\n  ownerState\n}) => (ownerState.variant === 'indeterminate' || ownerState.variant === 'query') && css(_t6 || (_t6 = _`\n      width: auto;\n      animation: ${0} 2.1s cubic-bezier(0.165, 0.84, 0.44, 1) 1.15s infinite;\n    `), indeterminate2Keyframe));\n/**\n * ## ARIA\n *\n * If the progress bar is describing the loading progress of a particular region of a page,\n * you should use `aria-describedby` to point to the progress bar, and set the `aria-busy`\n * attribute to `true` on that region until it has finished loading.\n */\n\nconst LinearProgress = /*#__PURE__*/React.forwardRef(function LinearProgress(inProps, ref) {\n  const props = useThemeProps({\n    props: inProps,\n    name: 'MuiLinearProgress'\n  });\n\n  const {\n    className,\n    color = 'primary',\n    value,\n    valueBuffer,\n    variant = 'indeterminate'\n  } = props,\n        other = _objectWithoutPropertiesLoose(props, _excluded);\n\n  const ownerState = _extends({}, props, {\n    color,\n    variant\n  });\n\n  const classes = useUtilityClasses(ownerState);\n  const theme = useTheme();\n  const rootProps = {};\n  const inlineStyles = {\n    bar1: {},\n    bar2: {}\n  };\n\n  if (variant === 'determinate' || variant === 'buffer') {\n    if (value !== undefined) {\n      rootProps['aria-valuenow'] = Math.round(value);\n      rootProps['aria-valuemin'] = 0;\n      rootProps['aria-valuemax'] = 100;\n      let transform = value - 100;\n\n      if (theme.direction === 'rtl') {\n        transform = -transform;\n      }\n\n      inlineStyles.bar1.transform = `translateX(${transform}%)`;\n    } else if (process.env.NODE_ENV !== 'production') {\n      console.error('MUI: You need to provide a value prop ' + 'when using the determinate or buffer variant of LinearProgress .');\n    }\n  }\n\n  if (variant === 'buffer') {\n    if (valueBuffer !== undefined) {\n      let transform = (valueBuffer || 0) - 100;\n\n      if (theme.direction === 'rtl') {\n        transform = -transform;\n      }\n\n      inlineStyles.bar2.transform = `translateX(${transform}%)`;\n    } else if (process.env.NODE_ENV !== 'production') {\n      console.error('MUI: You need to provide a valueBuffer prop ' + 'when using the buffer variant of LinearProgress.');\n    }\n  }\n\n  return /*#__PURE__*/_jsxs(LinearProgressRoot, _extends({\n    className: clsx(classes.root, className),\n    ownerState: ownerState,\n    role: \"progressbar\"\n  }, rootProps, {\n    ref: ref\n  }, other, {\n    children: [variant === 'buffer' ? /*#__PURE__*/_jsx(LinearProgressDashed, {\n      className: classes.dashed,\n      ownerState: ownerState\n    }) : null, /*#__PURE__*/_jsx(LinearProgressBar1, {\n      className: classes.bar1,\n      ownerState: ownerState,\n      style: inlineStyles.bar1\n    }), variant === 'determinate' ? null : /*#__PURE__*/_jsx(LinearProgressBar2, {\n      className: classes.bar2,\n      ownerState: ownerState,\n      style: inlineStyles.bar2\n    })]\n  }));\n});\nprocess.env.NODE_ENV !== \"production\" ? LinearProgress.propTypes\n/* remove-proptypes */\n= {\n  // ----------------------------- Warning --------------------------------\n  // | These PropTypes are generated from the TypeScript type definitions |\n  // |     To update them edit the d.ts file and run \"yarn proptypes\"     |\n  // ----------------------------------------------------------------------\n\n  /**\n   * Override or extend the styles applied to the component.\n   */\n  classes: PropTypes.object,\n\n  /**\n   * @ignore\n   */\n  className: PropTypes.string,\n\n  /**\n   * The color of the component.\n   * It supports both default and custom theme colors, which can be added as shown in the\n   * [palette customization guide](https://mui.com/material-ui/customization/palette/#adding-new-colors).\n   * @default 'primary'\n   */\n  color: PropTypes\n  /* @typescript-to-proptypes-ignore */\n  .oneOfType([PropTypes.oneOf(['inherit', 'primary', 'secondary']), PropTypes.string]),\n\n  /**\n   * The system prop that allows defining system overrides as well as additional CSS styles.\n   */\n  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),\n\n  /**\n   * The value of the progress indicator for the determinate and buffer variants.\n   * Value between 0 and 100.\n   */\n  value: PropTypes.number,\n\n  /**\n   * The value for the buffer variant.\n   * Value between 0 and 100.\n   */\n  valueBuffer: PropTypes.number,\n\n  /**\n   * The variant to use.\n   * Use indeterminate or query when there is no progress value.\n   * @default 'indeterminate'\n   */\n  variant: PropTypes.oneOf(['buffer', 'determinate', 'indeterminate', 'query'])\n} : void 0;\nexport default LinearProgress;","import { generateUtilityClass, generateUtilityClasses } from '@mui/base';\nexport function getLinearProgressUtilityClass(slot) {\n  return generateUtilityClass('MuiLinearProgress', slot);\n}\nconst linearProgressClasses = generateUtilityClasses('MuiLinearProgress', ['root', 'colorPrimary', 'colorSecondary', 'determinate', 'indeterminate', 'buffer', 'query', 'dashed', 'dashedColorPrimary', 'dashedColorSecondary', 'bar', 'barColorPrimary', 'barColorSecondary', 'bar1Indeterminate', 'bar1Determinate', 'bar1Buffer', 'bar2Indeterminate', 'bar2Buffer']);\nexport default linearProgressClasses;","import { generateUtilityClass, generateUtilityClasses } from '@mui/base';\nexport function getTabUtilityClass(slot) {\n  return generateUtilityClass('MuiTab', slot);\n}\nconst tabClasses = generateUtilityClasses('MuiTab', ['root', 'labelIcon', 'textColorInherit', 'textColorPrimary', 'textColorSecondary', 'selected', 'disabled', 'fullWidth', 'wrapped', 'iconWrapper']);\nexport default tabClasses;","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nconst _excluded = [\"className\", \"disabled\", \"disableFocusRipple\", \"fullWidth\", \"icon\", \"iconPosition\", \"indicator\", \"label\", \"onChange\", \"onClick\", \"onFocus\", \"selected\", \"selectionFollowsFocus\", \"textColor\", \"value\", \"wrapped\"];\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport clsx from 'clsx';\nimport { unstable_composeClasses as composeClasses } from '@mui/base';\nimport ButtonBase from '../ButtonBase';\nimport capitalize from '../utils/capitalize';\nimport useThemeProps from '../styles/useThemeProps';\nimport styled from '../styles/styled';\nimport unsupportedProp from '../utils/unsupportedProp';\nimport tabClasses, { getTabUtilityClass } from './tabClasses';\nimport { jsxs as _jsxs } from \"react/jsx-runtime\";\n\nconst useUtilityClasses = ownerState => {\n  const {\n    classes,\n    textColor,\n    fullWidth,\n    wrapped,\n    icon,\n    label,\n    selected,\n    disabled\n  } = ownerState;\n  const slots = {\n    root: ['root', icon && label && 'labelIcon', `textColor${capitalize(textColor)}`, fullWidth && 'fullWidth', wrapped && 'wrapped', selected && 'selected', disabled && 'disabled'],\n    iconWrapper: ['iconWrapper']\n  };\n  return composeClasses(slots, getTabUtilityClass, classes);\n};\n\nconst TabRoot = styled(ButtonBase, {\n  name: 'MuiTab',\n  slot: 'Root',\n  overridesResolver: (props, styles) => {\n    const {\n      ownerState\n    } = props;\n    return [styles.root, ownerState.label && ownerState.icon && styles.labelIcon, styles[`textColor${capitalize(ownerState.textColor)}`], ownerState.fullWidth && styles.fullWidth, ownerState.wrapped && styles.wrapped];\n  }\n})(({\n  theme,\n  ownerState\n}) => _extends({}, theme.typography.button, {\n  maxWidth: 360,\n  minWidth: 90,\n  position: 'relative',\n  minHeight: 48,\n  flexShrink: 0,\n  padding: '12px 16px',\n  overflow: 'hidden',\n  whiteSpace: 'normal',\n  textAlign: 'center'\n}, ownerState.label && {\n  flexDirection: ownerState.iconPosition === 'top' || ownerState.iconPosition === 'bottom' ? 'column' : 'row'\n}, {\n  lineHeight: 1.25\n}, ownerState.icon && ownerState.label && {\n  minHeight: 72,\n  paddingTop: 9,\n  paddingBottom: 9,\n  [`& > .${tabClasses.iconWrapper}`]: _extends({}, ownerState.iconPosition === 'top' && {\n    marginBottom: 6\n  }, ownerState.iconPosition === 'bottom' && {\n    marginTop: 6\n  }, ownerState.iconPosition === 'start' && {\n    marginRight: theme.spacing(1)\n  }, ownerState.iconPosition === 'end' && {\n    marginLeft: theme.spacing(1)\n  })\n}, ownerState.textColor === 'inherit' && {\n  color: 'inherit',\n  opacity: 0.6,\n  // same opacity as theme.palette.text.secondary\n  [`&.${tabClasses.selected}`]: {\n    opacity: 1\n  },\n  [`&.${tabClasses.disabled}`]: {\n    opacity: (theme.vars || theme).palette.action.disabledOpacity\n  }\n}, ownerState.textColor === 'primary' && {\n  color: (theme.vars || theme).palette.text.secondary,\n  [`&.${tabClasses.selected}`]: {\n    color: (theme.vars || theme).palette.primary.main\n  },\n  [`&.${tabClasses.disabled}`]: {\n    color: (theme.vars || theme).palette.text.disabled\n  }\n}, ownerState.textColor === 'secondary' && {\n  color: (theme.vars || theme).palette.text.secondary,\n  [`&.${tabClasses.selected}`]: {\n    color: (theme.vars || theme).palette.secondary.main\n  },\n  [`&.${tabClasses.disabled}`]: {\n    color: (theme.vars || theme).palette.text.disabled\n  }\n}, ownerState.fullWidth && {\n  flexShrink: 1,\n  flexGrow: 1,\n  flexBasis: 0,\n  maxWidth: 'none'\n}, ownerState.wrapped && {\n  fontSize: theme.typography.pxToRem(12)\n}));\nconst Tab = /*#__PURE__*/React.forwardRef(function Tab(inProps, ref) {\n  const props = useThemeProps({\n    props: inProps,\n    name: 'MuiTab'\n  });\n\n  const {\n    className,\n    disabled = false,\n    disableFocusRipple = false,\n    // eslint-disable-next-line react/prop-types\n    fullWidth,\n    icon: iconProp,\n    iconPosition = 'top',\n    // eslint-disable-next-line react/prop-types\n    indicator,\n    label,\n    onChange,\n    onClick,\n    onFocus,\n    // eslint-disable-next-line react/prop-types\n    selected,\n    // eslint-disable-next-line react/prop-types\n    selectionFollowsFocus,\n    // eslint-disable-next-line react/prop-types\n    textColor = 'inherit',\n    value,\n    wrapped = false\n  } = props,\n        other = _objectWithoutPropertiesLoose(props, _excluded);\n\n  const ownerState = _extends({}, props, {\n    disabled,\n    disableFocusRipple,\n    selected,\n    icon: !!iconProp,\n    iconPosition,\n    label: !!label,\n    fullWidth,\n    textColor,\n    wrapped\n  });\n\n  const classes = useUtilityClasses(ownerState);\n  const icon = iconProp && label && /*#__PURE__*/React.isValidElement(iconProp) ? /*#__PURE__*/React.cloneElement(iconProp, {\n    className: clsx(classes.iconWrapper, iconProp.props.className)\n  }) : iconProp;\n\n  const handleClick = event => {\n    if (!selected && onChange) {\n      onChange(event, value);\n    }\n\n    if (onClick) {\n      onClick(event);\n    }\n  };\n\n  const handleFocus = event => {\n    if (selectionFollowsFocus && !selected && onChange) {\n      onChange(event, value);\n    }\n\n    if (onFocus) {\n      onFocus(event);\n    }\n  };\n\n  return /*#__PURE__*/_jsxs(TabRoot, _extends({\n    focusRipple: !disableFocusRipple,\n    className: clsx(classes.root, className),\n    ref: ref,\n    role: \"tab\",\n    \"aria-selected\": selected,\n    disabled: disabled,\n    onClick: handleClick,\n    onFocus: handleFocus,\n    ownerState: ownerState,\n    tabIndex: selected ? 0 : -1\n  }, other, {\n    children: [iconPosition === 'top' || iconPosition === 'start' ? /*#__PURE__*/_jsxs(React.Fragment, {\n      children: [icon, label]\n    }) : /*#__PURE__*/_jsxs(React.Fragment, {\n      children: [label, icon]\n    }), indicator]\n  }));\n});\nprocess.env.NODE_ENV !== \"production\" ? Tab.propTypes\n/* remove-proptypes */\n= {\n  // ----------------------------- Warning --------------------------------\n  // | These PropTypes are generated from the TypeScript type definitions |\n  // |     To update them edit the d.ts file and run \"yarn proptypes\"     |\n  // ----------------------------------------------------------------------\n\n  /**\n   * This prop isn't supported.\n   * Use the `component` prop if you need to change the children structure.\n   */\n  children: unsupportedProp,\n\n  /**\n   * Override or extend the styles applied to the component.\n   */\n  classes: PropTypes.object,\n\n  /**\n   * @ignore\n   */\n  className: PropTypes.string,\n\n  /**\n   * If `true`, the component is disabled.\n   * @default false\n   */\n  disabled: PropTypes.bool,\n\n  /**\n   * If `true`, the  keyboard focus ripple is disabled.\n   * @default false\n   */\n  disableFocusRipple: PropTypes.bool,\n\n  /**\n   * If `true`, the ripple effect is disabled.\n   *\n   * ⚠️ Without a ripple there is no styling for :focus-visible by default. Be sure\n   * to highlight the element by applying separate styles with the `.Mui-focusVisible` class.\n   * @default false\n   */\n  disableRipple: PropTypes.bool,\n\n  /**\n   * The icon to display.\n   */\n  icon: PropTypes.oneOfType([PropTypes.element, PropTypes.string]),\n\n  /**\n   * The position of the icon relative to the label.\n   * @default 'top'\n   */\n  iconPosition: PropTypes.oneOf(['bottom', 'end', 'start', 'top']),\n\n  /**\n   * The label element.\n   */\n  label: PropTypes.node,\n\n  /**\n   * @ignore\n   */\n  onChange: PropTypes.func,\n\n  /**\n   * @ignore\n   */\n  onClick: PropTypes.func,\n\n  /**\n   * @ignore\n   */\n  onFocus: PropTypes.func,\n\n  /**\n   * The system prop that allows defining system overrides as well as additional CSS styles.\n   */\n  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),\n\n  /**\n   * You can provide your own value. Otherwise, we fallback to the child position index.\n   */\n  value: PropTypes.any,\n\n  /**\n   * Tab labels appear in a single row.\n   * They can use a second line if needed.\n   * @default false\n   */\n  wrapped: PropTypes.bool\n} : void 0;\nexport default Tab;","import PropTypes from 'prop-types';\nimport createBox from '../createBox';\nconst Box = createBox();\nprocess.env.NODE_ENV !== \"production\" ? Box.propTypes\n/* remove-proptypes */\n= {\n  // ----------------------------- Warning --------------------------------\n  // | These PropTypes are generated from the TypeScript type definitions |\n  // |     To update them edit the d.ts file and run \"yarn proptypes\"     |\n  // ----------------------------------------------------------------------\n\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n\n  /**\n   * The component used for the root node.\n   * Either a string to use a HTML element or a component.\n   */\n  component: PropTypes.elementType,\n\n  /**\n   * The system prop that allows defining system overrides as well as additional CSS styles.\n   */\n  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])\n} : void 0;\nexport default Box;","!function(t,e){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=e():\"function\"==typeof define&&define.amd?define(e):(t=\"undefined\"!=typeof globalThis?globalThis:t||self).dayjs=e()}(this,(function(){\"use strict\";var t=1e3,e=6e4,n=36e5,r=\"millisecond\",i=\"second\",s=\"minute\",u=\"hour\",a=\"day\",o=\"week\",f=\"month\",h=\"quarter\",c=\"year\",d=\"date\",$=\"Invalid Date\",l=/^(\\d{4})[-/]?(\\d{1,2})?[-/]?(\\d{0,2})[Tt\\s]*(\\d{1,2})?:?(\\d{1,2})?:?(\\d{1,2})?[.:]?(\\d+)?$/,y=/\\[([^\\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g,M={name:\"en\",weekdays:\"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday\".split(\"_\"),months:\"January_February_March_April_May_June_July_August_September_October_November_December\".split(\"_\")},m=function(t,e,n){var r=String(t);return!r||r.length>=e?t:\"\"+Array(e+1-r.length).join(n)+t},g={s:m,z:function(t){var e=-t.utcOffset(),n=Math.abs(e),r=Math.floor(n/60),i=n%60;return(e<=0?\"+\":\"-\")+m(r,2,\"0\")+\":\"+m(i,2,\"0\")},m:function t(e,n){if(e.date()<n.date())return-t(n,e);var r=12*(n.year()-e.year())+(n.month()-e.month()),i=e.clone().add(r,f),s=n-i<0,u=e.clone().add(r+(s?-1:1),f);return+(-(r+(n-i)/(s?i-u:u-i))||0)},a:function(t){return t<0?Math.ceil(t)||0:Math.floor(t)},p:function(t){return{M:f,y:c,w:o,d:a,D:d,h:u,m:s,s:i,ms:r,Q:h}[t]||String(t||\"\").toLowerCase().replace(/s$/,\"\")},u:function(t){return void 0===t}},v=\"en\",D={};D[v]=M;var p=function(t){return t instanceof _},S=function t(e,n,r){var i;if(!e)return v;if(\"string\"==typeof e){var s=e.toLowerCase();D[s]&&(i=s),n&&(D[s]=n,i=s);var u=e.split(\"-\");if(!i&&u.length>1)return t(u[0])}else{var a=e.name;D[a]=e,i=a}return!r&&i&&(v=i),i||!r&&v},w=function(t,e){if(p(t))return t.clone();var n=\"object\"==typeof e?e:{};return n.date=t,n.args=arguments,new _(n)},O=g;O.l=S,O.i=p,O.w=function(t,e){return w(t,{locale:e.$L,utc:e.$u,x:e.$x,$offset:e.$offset})};var _=function(){function M(t){this.$L=S(t.locale,null,!0),this.parse(t)}var m=M.prototype;return m.parse=function(t){this.$d=function(t){var e=t.date,n=t.utc;if(null===e)return new Date(NaN);if(O.u(e))return new Date;if(e instanceof Date)return new Date(e);if(\"string\"==typeof e&&!/Z$/i.test(e)){var r=e.match(l);if(r){var i=r[2]-1||0,s=(r[7]||\"0\").substring(0,3);return n?new Date(Date.UTC(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)):new Date(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)}}return new Date(e)}(t),this.$x=t.x||{},this.init()},m.init=function(){var t=this.$d;this.$y=t.getFullYear(),this.$M=t.getMonth(),this.$D=t.getDate(),this.$W=t.getDay(),this.$H=t.getHours(),this.$m=t.getMinutes(),this.$s=t.getSeconds(),this.$ms=t.getMilliseconds()},m.$utils=function(){return O},m.isValid=function(){return!(this.$d.toString()===$)},m.isSame=function(t,e){var n=w(t);return this.startOf(e)<=n&&n<=this.endOf(e)},m.isAfter=function(t,e){return w(t)<this.startOf(e)},m.isBefore=function(t,e){return this.endOf(e)<w(t)},m.$g=function(t,e,n){return O.u(t)?this[e]:this.set(n,t)},m.unix=function(){return Math.floor(this.valueOf()/1e3)},m.valueOf=function(){return this.$d.getTime()},m.startOf=function(t,e){var n=this,r=!!O.u(e)||e,h=O.p(t),$=function(t,e){var i=O.w(n.$u?Date.UTC(n.$y,e,t):new Date(n.$y,e,t),n);return r?i:i.endOf(a)},l=function(t,e){return O.w(n.toDate()[t].apply(n.toDate(\"s\"),(r?[0,0,0,0]:[23,59,59,999]).slice(e)),n)},y=this.$W,M=this.$M,m=this.$D,g=\"set\"+(this.$u?\"UTC\":\"\");switch(h){case c:return r?$(1,0):$(31,11);case f:return r?$(1,M):$(0,M+1);case o:var v=this.$locale().weekStart||0,D=(y<v?y+7:y)-v;return $(r?m-D:m+(6-D),M);case a:case d:return l(g+\"Hours\",0);case u:return l(g+\"Minutes\",1);case s:return l(g+\"Seconds\",2);case i:return l(g+\"Milliseconds\",3);default:return this.clone()}},m.endOf=function(t){return this.startOf(t,!1)},m.$set=function(t,e){var n,o=O.p(t),h=\"set\"+(this.$u?\"UTC\":\"\"),$=(n={},n[a]=h+\"Date\",n[d]=h+\"Date\",n[f]=h+\"Month\",n[c]=h+\"FullYear\",n[u]=h+\"Hours\",n[s]=h+\"Minutes\",n[i]=h+\"Seconds\",n[r]=h+\"Milliseconds\",n)[o],l=o===a?this.$D+(e-this.$W):e;if(o===f||o===c){var y=this.clone().set(d,1);y.$d[$](l),y.init(),this.$d=y.set(d,Math.min(this.$D,y.daysInMonth())).$d}else $&&this.$d[$](l);return this.init(),this},m.set=function(t,e){return this.clone().$set(t,e)},m.get=function(t){return this[O.p(t)]()},m.add=function(r,h){var d,$=this;r=Number(r);var l=O.p(h),y=function(t){var e=w($);return O.w(e.date(e.date()+Math.round(t*r)),$)};if(l===f)return this.set(f,this.$M+r);if(l===c)return this.set(c,this.$y+r);if(l===a)return y(1);if(l===o)return y(7);var M=(d={},d[s]=e,d[u]=n,d[i]=t,d)[l]||1,m=this.$d.getTime()+r*M;return O.w(m,this)},m.subtract=function(t,e){return this.add(-1*t,e)},m.format=function(t){var e=this,n=this.$locale();if(!this.isValid())return n.invalidDate||$;var r=t||\"YYYY-MM-DDTHH:mm:ssZ\",i=O.z(this),s=this.$H,u=this.$m,a=this.$M,o=n.weekdays,f=n.months,h=function(t,n,i,s){return t&&(t[n]||t(e,r))||i[n].slice(0,s)},c=function(t){return O.s(s%12||12,t,\"0\")},d=n.meridiem||function(t,e,n){var r=t<12?\"AM\":\"PM\";return n?r.toLowerCase():r},l={YY:String(this.$y).slice(-2),YYYY:this.$y,M:a+1,MM:O.s(a+1,2,\"0\"),MMM:h(n.monthsShort,a,f,3),MMMM:h(f,a),D:this.$D,DD:O.s(this.$D,2,\"0\"),d:String(this.$W),dd:h(n.weekdaysMin,this.$W,o,2),ddd:h(n.weekdaysShort,this.$W,o,3),dddd:o[this.$W],H:String(s),HH:O.s(s,2,\"0\"),h:c(1),hh:c(2),a:d(s,u,!0),A:d(s,u,!1),m:String(u),mm:O.s(u,2,\"0\"),s:String(this.$s),ss:O.s(this.$s,2,\"0\"),SSS:O.s(this.$ms,3,\"0\"),Z:i};return r.replace(y,(function(t,e){return e||l[t]||i.replace(\":\",\"\")}))},m.utcOffset=function(){return 15*-Math.round(this.$d.getTimezoneOffset()/15)},m.diff=function(r,d,$){var l,y=O.p(d),M=w(r),m=(M.utcOffset()-this.utcOffset())*e,g=this-M,v=O.m(this,M);return v=(l={},l[c]=v/12,l[f]=v,l[h]=v/3,l[o]=(g-m)/6048e5,l[a]=(g-m)/864e5,l[u]=g/n,l[s]=g/e,l[i]=g/t,l)[y]||g,$?v:O.a(v)},m.daysInMonth=function(){return this.endOf(f).$D},m.$locale=function(){return D[this.$L]},m.locale=function(t,e){if(!t)return this.$L;var n=this.clone(),r=S(t,e,!0);return r&&(n.$L=r),n},m.clone=function(){return O.w(this.$d,this)},m.toDate=function(){return new Date(this.valueOf())},m.toJSON=function(){return this.isValid()?this.toISOString():null},m.toISOString=function(){return this.$d.toISOString()},m.toString=function(){return this.$d.toUTCString()},M}(),T=_.prototype;return w.prototype=T,[[\"$ms\",r],[\"$s\",i],[\"$m\",s],[\"$H\",u],[\"$W\",a],[\"$M\",f],[\"$y\",c],[\"$D\",d]].forEach((function(t){T[t[1]]=function(e){return this.$g(e,t[0],t[1])}})),w.extend=function(t,e){return t.$i||(t(e,_,w),t.$i=!0),w},w.locale=S,w.isDayjs=p,w.unix=function(t){return w(1e3*t)},w.en=D[v],w.Ls=D,w.p={},w}));","!function(t,s){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=s():\"function\"==typeof define&&define.amd?define(s):(t=\"undefined\"!=typeof globalThis?globalThis:t||self).dayjs_plugin_duration=s()}(this,(function(){\"use strict\";var t,s,n=1e3,i=6e4,e=36e5,r=864e5,o=/\\[([^\\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g,u=31536e6,h=2592e6,a=/^(-|\\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/,d={years:u,months:h,days:r,hours:e,minutes:i,seconds:n,milliseconds:1,weeks:6048e5},c=function(t){return t instanceof p},f=function(t,s,n){return new p(t,n,s.$l)},m=function(t){return s.p(t)+\"s\"},l=function(t){return t<0},$=function(t){return l(t)?Math.ceil(t):Math.floor(t)},y=function(t){return Math.abs(t)},g=function(t,s){return t?l(t)?{negative:!0,format:\"\"+y(t)+s}:{negative:!1,format:\"\"+t+s}:{negative:!1,format:\"\"}},p=function(){function l(t,s,n){var i=this;if(this.$d={},this.$l=n,void 0===t&&(this.$ms=0,this.parseFromMilliseconds()),s)return f(t*d[m(s)],this);if(\"number\"==typeof t)return this.$ms=t,this.parseFromMilliseconds(),this;if(\"object\"==typeof t)return Object.keys(t).forEach((function(s){i.$d[m(s)]=t[s]})),this.calMilliseconds(),this;if(\"string\"==typeof t){var e=t.match(a);if(e){var r=e.slice(2).map((function(t){return null!=t?Number(t):0}));return this.$d.years=r[0],this.$d.months=r[1],this.$d.weeks=r[2],this.$d.days=r[3],this.$d.hours=r[4],this.$d.minutes=r[5],this.$d.seconds=r[6],this.calMilliseconds(),this}}return this}var y=l.prototype;return y.calMilliseconds=function(){var t=this;this.$ms=Object.keys(this.$d).reduce((function(s,n){return s+(t.$d[n]||0)*d[n]}),0)},y.parseFromMilliseconds=function(){var t=this.$ms;this.$d.years=$(t/u),t%=u,this.$d.months=$(t/h),t%=h,this.$d.days=$(t/r),t%=r,this.$d.hours=$(t/e),t%=e,this.$d.minutes=$(t/i),t%=i,this.$d.seconds=$(t/n),t%=n,this.$d.milliseconds=t},y.toISOString=function(){var t=g(this.$d.years,\"Y\"),s=g(this.$d.months,\"M\"),n=+this.$d.days||0;this.$d.weeks&&(n+=7*this.$d.weeks);var i=g(n,\"D\"),e=g(this.$d.hours,\"H\"),r=g(this.$d.minutes,\"M\"),o=this.$d.seconds||0;this.$d.milliseconds&&(o+=this.$d.milliseconds/1e3);var u=g(o,\"S\"),h=t.negative||s.negative||i.negative||e.negative||r.negative||u.negative,a=e.format||r.format||u.format?\"T\":\"\",d=(h?\"-\":\"\")+\"P\"+t.format+s.format+i.format+a+e.format+r.format+u.format;return\"P\"===d||\"-P\"===d?\"P0D\":d},y.toJSON=function(){return this.toISOString()},y.format=function(t){var n=t||\"YYYY-MM-DDTHH:mm:ss\",i={Y:this.$d.years,YY:s.s(this.$d.years,2,\"0\"),YYYY:s.s(this.$d.years,4,\"0\"),M:this.$d.months,MM:s.s(this.$d.months,2,\"0\"),D:this.$d.days,DD:s.s(this.$d.days,2,\"0\"),H:this.$d.hours,HH:s.s(this.$d.hours,2,\"0\"),m:this.$d.minutes,mm:s.s(this.$d.minutes,2,\"0\"),s:this.$d.seconds,ss:s.s(this.$d.seconds,2,\"0\"),SSS:s.s(this.$d.milliseconds,3,\"0\")};return n.replace(o,(function(t,s){return s||String(i[t])}))},y.as=function(t){return this.$ms/d[m(t)]},y.get=function(t){var s=this.$ms,n=m(t);return\"milliseconds\"===n?s%=1e3:s=\"weeks\"===n?$(s/d[n]):this.$d[n],0===s?0:s},y.add=function(t,s,n){var i;return i=s?t*d[m(s)]:c(t)?t.$ms:f(t,this).$ms,f(this.$ms+i*(n?-1:1),this)},y.subtract=function(t,s){return this.add(t,s,!0)},y.locale=function(t){var s=this.clone();return s.$l=t,s},y.clone=function(){return f(this.$ms,this)},y.humanize=function(s){return t().add(this.$ms,\"ms\").locale(this.$l).fromNow(!s)},y.milliseconds=function(){return this.get(\"milliseconds\")},y.asMilliseconds=function(){return this.as(\"milliseconds\")},y.seconds=function(){return this.get(\"seconds\")},y.asSeconds=function(){return this.as(\"seconds\")},y.minutes=function(){return this.get(\"minutes\")},y.asMinutes=function(){return this.as(\"minutes\")},y.hours=function(){return this.get(\"hours\")},y.asHours=function(){return this.as(\"hours\")},y.days=function(){return this.get(\"days\")},y.asDays=function(){return this.as(\"days\")},y.weeks=function(){return this.get(\"weeks\")},y.asWeeks=function(){return this.as(\"weeks\")},y.months=function(){return this.get(\"months\")},y.asMonths=function(){return this.as(\"months\")},y.years=function(){return this.get(\"years\")},y.asYears=function(){return this.as(\"years\")},l}();return function(n,i,e){t=e,s=e().$utils(),e.duration=function(t,s){var n=e.locale();return f(t,{$l:n},s)},e.isDuration=c;var r=i.prototype.add,o=i.prototype.subtract;i.prototype.add=function(t,s){return c(t)&&(t=t.asMilliseconds()),r.bind(this)(t,s)},i.prototype.subtract=function(t,s){return c(t)&&(t=t.asMilliseconds()),o.bind(this)(t,s)}}}));","'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 * Determine if an object is a Buffer\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */\n\nmodule.exports = function isBuffer (obj) {\n  return obj != null && obj.constructor != null &&\n    typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)\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 = 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-is.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 b=Symbol.for(\"react.element\"),c=Symbol.for(\"react.portal\"),d=Symbol.for(\"react.fragment\"),e=Symbol.for(\"react.strict_mode\"),f=Symbol.for(\"react.profiler\"),g=Symbol.for(\"react.provider\"),h=Symbol.for(\"react.context\"),k=Symbol.for(\"react.server_context\"),l=Symbol.for(\"react.forward_ref\"),m=Symbol.for(\"react.suspense\"),n=Symbol.for(\"react.suspense_list\"),p=Symbol.for(\"react.memo\"),q=Symbol.for(\"react.lazy\"),t=Symbol.for(\"react.offscreen\"),u;u=Symbol.for(\"react.module.reference\");\nfunction v(a){if(\"object\"===typeof a&&null!==a){var r=a.$$typeof;switch(r){case b:switch(a=a.type,a){case d:case f:case e:case m:case n:return a;default:switch(a=a&&a.$$typeof,a){case k:case h:case l:case q:case p:case g:return a;default:return r}}case c:return r}}}exports.ContextConsumer=h;exports.ContextProvider=g;exports.Element=b;exports.ForwardRef=l;exports.Fragment=d;exports.Lazy=q;exports.Memo=p;exports.Portal=c;exports.Profiler=f;exports.StrictMode=e;exports.Suspense=m;\nexports.SuspenseList=n;exports.isAsyncMode=function(){return!1};exports.isConcurrentMode=function(){return!1};exports.isContextConsumer=function(a){return v(a)===h};exports.isContextProvider=function(a){return v(a)===g};exports.isElement=function(a){return\"object\"===typeof a&&null!==a&&a.$$typeof===b};exports.isForwardRef=function(a){return v(a)===l};exports.isFragment=function(a){return v(a)===d};exports.isLazy=function(a){return v(a)===q};exports.isMemo=function(a){return v(a)===p};\nexports.isPortal=function(a){return v(a)===c};exports.isProfiler=function(a){return v(a)===f};exports.isStrictMode=function(a){return v(a)===e};exports.isSuspense=function(a){return v(a)===m};exports.isSuspenseList=function(a){return v(a)===n};\nexports.isValidElementType=function(a){return\"string\"===typeof a||\"function\"===typeof a||a===d||a===f||a===e||a===m||a===n||a===t||\"object\"===typeof a&&null!==a&&(a.$$typeof===q||a.$$typeof===p||a.$$typeof===g||a.$$typeof===h||a.$$typeof===l||a.$$typeof===u||void 0!==a.getModuleId)?!0:!1};exports.typeOf=v;\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react-is.production.min.js');\n} else {\n  module.exports = require('./cjs/react-is.development.js');\n}\n","var parse = require('inline-style-parser');\n\n/**\n * Parses inline style to object.\n *\n * @example\n * // returns { 'line-height': '42' }\n * StyleToObject('line-height: 42;');\n *\n * @param  {String}      style      - The inline style.\n * @param  {Function}    [iterator] - The iterator function.\n * @return {null|Object}\n */\nfunction StyleToObject(style, iterator) {\n  var output = null;\n  if (!style || typeof style !== 'string') {\n    return output;\n  }\n\n  var declaration;\n  var declarations = parse(style);\n  var hasIterator = typeof iterator === 'function';\n  var property;\n  var value;\n\n  for (var i = 0, len = declarations.length; i < len; i++) {\n    declaration = declarations[i];\n    property = declaration.property;\n    value = declaration.value;\n\n    if (hasIterator) {\n      iterator(property, value, declaration);\n    } else if (value) {\n      output || (output = {});\n      output[property] = value;\n    }\n  }\n\n  return output;\n}\n\nmodule.exports = StyleToObject;\n","/**\n * @typedef {import('unist').Point} Point\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Position} Position\n * @typedef {object & {type: string, position?: Position|undefined}} NodeLike\n */\n\n/**\n * Stringify one point, a position (start and end points), or a node’s\n * positional information.\n *\n * @param {Node|NodeLike|Position|Point|null} [value]\n * @returns {string}\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|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|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|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').Position} Position\n * @typedef {import('unist').Point} Point\n * @typedef {object & {type: string, position?: Position|undefined}} NodeLike\n */\n\nimport {stringifyPosition} from 'unist-util-stringify-position'\n\nexport class VFileMessage extends Error {\n  /**\n   * Constructor of a message for `reason` at `place` from `origin`.\n   * When an error is passed in as `reason`, copies the `stack`.\n   *\n   * @param {string|Error} reason Reason for message (`string` or `Error`). Uses the stack and message of the error if given.\n   * @param {Node|NodeLike|Position|Point} [place] Place at which the message occurred in a file (`Node`, `Position`, or `Point`, optional).\n   * @param {string} [origin] Place in code the message originates from (`string`, optional).\n   */\n  constructor(reason, place, origin) {\n    /** @type {[string|null, string|null]} */\n    const parts = [null, null]\n    /** @type {Position} */\n    let position = {\n      // @ts-expect-error: we always follows the structure of `position`.\n      start: {line: null, column: null},\n      // @ts-expect-error: \"\n      end: {line: null, column: null}\n    }\n\n    super()\n\n    if (typeof place === 'string') {\n      origin = place\n      place = undefined\n    }\n\n    if (typeof origin === 'string') {\n      const index = origin.indexOf(':')\n\n      if (index === -1) {\n        parts[1] = origin\n      } else {\n        parts[0] = origin.slice(0, index)\n        parts[1] = origin.slice(index + 1)\n      }\n    }\n\n    if (place) {\n      // Node.\n      if ('type' in place || 'position' in place) {\n        if (place.position) {\n          position = place.position\n        }\n      }\n      // Position.\n      else if ('start' in place || 'end' in place) {\n        position = place\n      }\n      // Point.\n      else if ('line' in place || 'column' in place) {\n        position.start = place\n      }\n    }\n\n    // Fields from `Error`\n    this.name = stringifyPosition(place) || '1:1'\n    this.message = typeof reason === 'object' ? reason.message : reason\n    this.stack = typeof reason === 'object' ? reason.stack : ''\n\n    /**\n     * Reason for message.\n     * @type {string}\n     */\n    this.reason = this.message\n    /**\n     * If true, marks associated file as no longer processable.\n     * @type {boolean?}\n     */\n    // eslint-disable-next-line no-unused-expressions\n    this.fatal\n    /**\n     * Starting line of error.\n     * @type {number?}\n     */\n    this.line = position.start.line\n    /**\n     * Starting column of error.\n     * @type {number?}\n     */\n    this.column = position.start.column\n    /**\n     * Namespace of warning.\n     * @type {string?}\n     */\n    this.source = parts[0]\n    /**\n     * Category of message.\n     * @type {string?}\n     */\n    this.ruleId = parts[1]\n    /**\n     * Full range information, when available.\n     * Has start and end properties, both set to an object with line and column, set to number?.\n     * @type {Position?}\n     */\n    this.position = position\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    /* eslint-disable no-unused-expressions */\n    /**\n     * You can use this to specify the source value that’s being reported, which\n     * is deemed incorrect.\n     * @type {string?}\n     */\n    this.actual\n    /**\n     * You can use this to suggest values that should be used instead of\n     * `actual`, one or more values that are deemed as acceptable.\n     * @type {Array<string>?}\n     */\n    this.expected\n    /**\n     * You may add a file property with a path of a file (used throughout the VFile ecosystem).\n     * @type {string?}\n     */\n    this.file\n    /**\n     * You may add a url property with a link to documentation for the message.\n     * @type {string?}\n     */\n    this.url\n    /**\n     * You may add a note property with a long form description of the message (supported by vfile-reporter).\n     * @type {string?}\n     */\n    this.note\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.fatal = null\nVFileMessage.prototype.column = null\nVFileMessage.prototype.line = null\nVFileMessage.prototype.source = null\nVFileMessage.prototype.ruleId = null\nVFileMessage.prototype.position = null\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 path = {basename, dirname, extname, join, sep: '/'}\n\n/* eslint-disable max-depth, complexity */\n\n/**\n * @param {string} path\n * @param {string} [ext]\n * @returns {string}\n */\nfunction basename(path, ext) {\n  if (ext !== undefined && typeof ext !== '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 (ext === undefined || ext.length === 0 || ext.length > path.length) {\n    while (index--) {\n      if (path.charCodeAt(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 (ext === path) {\n    return ''\n  }\n\n  let firstNonSlashEnd = -1\n  let extIndex = ext.length - 1\n\n  while (index--) {\n    if (path.charCodeAt(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 (extIndex > -1) {\n        // Try to match the explicit extension.\n        if (path.charCodeAt(index) === ext.charCodeAt(extIndex--)) {\n          if (extIndex < 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          extIndex = -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 * @param {string} path\n * @returns {string}\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.charCodeAt(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.charCodeAt(0) === 47 /* `/` */\n      ? '/'\n      : '.'\n    : end === 1 && path.charCodeAt(0) === 47 /* `/` */\n    ? '//'\n    : path.slice(0, end)\n}\n\n/**\n * @param {string} path\n * @returns {string}\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.charCodeAt(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 * @param {Array<string>} segments\n * @returns {string}\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 * Note: `normalize` is not exposed as `path.normalize`, so some code is\n * manually removed from it.\n *\n * @param {string} path\n * @returns {string}\n */\nfunction normalize(path) {\n  assertPath(path)\n\n  const absolute = path.charCodeAt(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.charCodeAt(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 * @param {boolean} allowAboveRoot\n * @returns {string}\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.charCodeAt(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.charCodeAt(result.length - 1) !== 46 /* `.` */ ||\n          result.charCodeAt(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 * @param {string} path\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 proc = {cwd}\n\nfunction cwd() {\n  return '/'\n}\n","/**\n * @typedef URL\n * @property {string} hash\n * @property {string} host\n * @property {string} hostname\n * @property {string} href\n * @property {string} origin\n * @property {string} password\n * @property {string} pathname\n * @property {string} port\n * @property {string} protocol\n * @property {string} search\n * @property {any} searchParams\n * @property {string} username\n * @property {() => string} toString\n * @property {() => string} toJSON\n */\n\n/**\n * @param {unknown} fileURLOrPath\n * @returns {fileURLOrPath is URL}\n */\n// From: <https://github.com/nodejs/node/blob/fcf8ba4/lib/internal/url.js#L1501>\nexport function isUrl(fileURLOrPath) {\n  return (\n    fileURLOrPath !== null &&\n    typeof fileURLOrPath === 'object' &&\n    // @ts-expect-error: indexable.\n    fileURLOrPath.href &&\n    // @ts-expect-error: indexable.\n    fileURLOrPath.origin\n  )\n}\n","/// <reference lib=\"dom\" />\n\nimport {isUrl} from './minurl.shared.js'\n\n// See: <https://github.com/nodejs/node/blob/fcf8ba4/lib/internal/url.js>\n\n/**\n * @param {string|URL} path\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 * @param {URL} url\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.charCodeAt(index) === 37 /* `%` */ &&\n      pathname.charCodeAt(index + 1) === 50 /* `2` */\n    ) {\n      const third = pathname.charCodeAt(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\nexport {isUrl} from './minurl.shared.js'\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Position} Position\n * @typedef {import('unist').Point} Point\n * @typedef {Record<string, unknown> & {type: string, position?: Position|undefined}} NodeLike\n * @typedef {import('./minurl.shared.js').URL} URL\n * @typedef {import('../index.js').Data} Data\n * @typedef {import('../index.js').Value} Value\n *\n * @typedef {'ascii'|'utf8'|'utf-8'|'utf16le'|'ucs2'|'ucs-2'|'base64'|'base64url'|'latin1'|'binary'|'hex'} BufferEncoding\n *   Encodings supported by the buffer class.\n *   This is a copy of the typing from Node, copied to prevent Node globals from\n *   being needed.\n *   Copied from: <https://github.com/DefinitelyTyped/DefinitelyTyped/blob/90a4ec8/types/node/buffer.d.ts#L170>\n *\n * @typedef {Value|Options|VFile|URL} Compatible\n *   Things that can be passed to the constructor.\n *\n * @typedef VFileCoreOptions\n * @property {Value} [value]\n * @property {string} [cwd]\n * @property {Array<string>} [history]\n * @property {string|URL} [path]\n * @property {string} [basename]\n * @property {string} [stem]\n * @property {string} [extname]\n * @property {string} [dirname]\n * @property {Data} [data]\n *\n * @typedef Map\n *   Raw source map, see:\n *   <https://github.com/mozilla/source-map/blob/58819f0/source-map.d.ts#L15-L23>.\n * @property {number} version\n * @property {Array<string>} sources\n * @property {Array<string>} names\n * @property {string|undefined} [sourceRoot]\n * @property {Array<string>|undefined} [sourcesContent]\n * @property {string} mappings\n * @property {string} file\n *\n * @typedef {{[key: string]: unknown} & VFileCoreOptions} Options\n *   Configuration: a bunch of keys that will be shallow copied over to the new\n *   file.\n *\n * @typedef {Record<string, unknown>} ReporterSettings\n * @typedef {<T = ReporterSettings>(files: Array<VFile>, options: T) => string} Reporter\n */\n\nimport buffer from 'is-buffer'\nimport {VFileMessage} from 'vfile-message'\nimport {path} from './minpath.js'\nimport {proc} from './minproc.js'\nimport {urlToPath, isUrl} from './minurl.js'\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.\nconst order = ['history', 'path', 'basename', 'stem', 'extname', 'dirname']\n\nexport class VFile {\n  /**\n   * Create a new virtual file.\n   *\n   * If `options` is `string` or `Buffer`, it’s treated as `{value: options}`.\n   * If `options` is a `URL`, it’s treated as `{path: options}`.\n   * If `options` is a `VFile`, shallow copies its data over to the new file.\n   * All fields in `options` are set on the newly created `VFile`.\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   * It’s not possible to set either `dirname` or `extname` without setting\n   * either `history`, `path`, `basename`, or `stem` as well.\n   *\n   * @param {Compatible} [value]\n   */\n  constructor(value) {\n    /** @type {Options} */\n    let options\n\n    if (!value) {\n      options = {}\n    } else if (typeof value === 'string' || buffer(value)) {\n      // @ts-expect-error Looks like a buffer.\n      options = {value}\n    } else if (isUrl(value)) {\n      options = {path: value}\n    } else {\n      // @ts-expect-error Looks like file or options.\n      options = value\n    }\n\n    /**\n     * Place to store custom information (default: `{}`).\n     * It’s OK to store custom data directly on the file but moving it to\n     * `data` is recommended.\n     * @type {Data}\n     */\n    this.data = {}\n\n    /**\n     * List of messages associated with the file.\n     * @type {Array<VFileMessage>}\n     */\n    this.messages = []\n\n    /**\n     * List of filepaths the file moved between.\n     * The first is the original path and the last is the current path.\n     * @type {Array<string>}\n     */\n    this.history = []\n\n    /**\n     * Base of `path` (default: `process.cwd()` or `'/'` in browsers).\n     * @type {string}\n     */\n    this.cwd = proc.cwd()\n\n    /* eslint-disable no-unused-expressions */\n    /**\n     * Raw value.\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    /**\n     * Whether a file was saved to disk.\n     * This is used by vfile reporters.\n     * @type {boolean}\n     */\n    this.stored\n\n    /**\n     * Sometimes files have a non-string, compiled, representation.\n     * This can be stored in the `result` field.\n     * One example is when turning markdown into React nodes.\n     * This is used by unified to store non-string results.\n     * @type {unknown}\n     */\n    this.result\n\n    /**\n     * Sometimes files have a source map associated with them.\n     * This can be stored in the `map` field.\n     * This should be a `Map` type, which is equivalent to the `RawSourceMap`\n     * type from the `source-map` module.\n     * @type {Map|undefined}\n     */\n    this.map\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 prop = order[index]\n\n      // Note: we specifically use `in` instead of `hasOwnProperty` to accept\n      // `vfile`s too.\n      if (prop in options && options[prop] !== undefined) {\n        // @ts-expect-error: TS is confused by the different types for `history`.\n        this[prop] = prop === 'history' ? [...options[prop]] : options[prop]\n      }\n    }\n\n    /** @type {string} */\n    let prop\n\n    // Set non-path related properties.\n    for (prop in options) {\n      // @ts-expect-error: fine to set other things.\n      if (!order.includes(prop)) this[prop] = options[prop]\n    }\n  }\n\n  /**\n   * Get the full path (example: `'~/index.min.js'`).\n   * @returns {string}\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   * 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   * @param {string|URL} path\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 parent path (example: `'~'`).\n   */\n  get dirname() {\n    return typeof this.path === 'string' ? path.dirname(this.path) : undefined\n  }\n\n  /**\n   * Set the parent path (example: `'~'`).\n   * Cannot be set if there’s no `path` yet.\n   */\n  set dirname(dirname) {\n    assertPath(this.basename, 'dirname')\n    this.path = path.join(dirname || '', this.basename)\n  }\n\n  /**\n   * Get the basename (including extname) (example: `'index.min.js'`).\n   */\n  get basename() {\n    return typeof this.path === 'string' ? path.basename(this.path) : undefined\n  }\n\n  /**\n   * Set basename (including extname) (`'index.min.js'`).\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  set basename(basename) {\n    assertNonEmpty(basename, 'basename')\n    assertPart(basename, 'basename')\n    this.path = path.join(this.dirname || '', basename)\n  }\n\n  /**\n   * Get the extname (including dot) (example: `'.js'`).\n   */\n  get extname() {\n    return typeof this.path === 'string' ? path.extname(this.path) : undefined\n  }\n\n  /**\n   * Set the extname (including dot) (example: `'.js'`).\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  set extname(extname) {\n    assertPart(extname, 'extname')\n    assertPath(this.dirname, 'extname')\n\n    if (extname) {\n      if (extname.charCodeAt(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 = path.join(this.dirname, this.stem + (extname || ''))\n  }\n\n  /**\n   * Get the stem (basename w/o extname) (example: `'index.min'`).\n   */\n  get stem() {\n    return typeof this.path === 'string'\n      ? path.basename(this.path, this.extname)\n      : undefined\n  }\n\n  /**\n   * Set the stem (basename w/o extname) (example: `'index.min'`).\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  set stem(stem) {\n    assertNonEmpty(stem, 'stem')\n    assertPart(stem, 'stem')\n    this.path = path.join(this.dirname || '', stem + (this.extname || ''))\n  }\n\n  /**\n   * Serialize the file.\n   *\n   * @param {BufferEncoding} [encoding='utf8']\n   *   When `value` is a `Buffer`, `encoding` is a character encoding to\n   *   understand it as (default: `'utf8'`).\n   * @returns {string}\n   *   Serialized file.\n   */\n  toString(encoding) {\n    return (this.value || '').toString(encoding)\n  }\n\n  /**\n   * Constructs a new `VFileMessage`, where `fatal` is set to `false`, and\n   * associates it with the file by adding it to `vfile.messages` and setting\n   * `message.file` to the current filepath.\n   *\n   * @param {string|Error} reason\n   *   Human readable reason for the message, uses the stack and message of the error if given.\n   * @param {Node|NodeLike|Position|Point} [place]\n   *   Place where the message occurred in the file.\n   * @param {string} [origin]\n   *   Computer readable reason for the message\n   * @returns {VFileMessage}\n   *   Message.\n   */\n  message(reason, place, origin) {\n    const message = new VFileMessage(reason, place, origin)\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   * Like `VFile#message()`, but associates an informational message where\n   * `fatal` is set to `null`.\n   *\n   * @param {string|Error} reason\n   *   Human readable reason for the message, uses the stack and message of the error if given.\n   * @param {Node|NodeLike|Position|Point} [place]\n   *   Place where the message occurred in the file.\n   * @param {string} [origin]\n   *   Computer readable reason for the message\n   * @returns {VFileMessage}\n   *   Message.\n   */\n  info(reason, place, origin) {\n    const message = this.message(reason, place, origin)\n\n    message.fatal = null\n\n    return message\n  }\n\n  /**\n   * Like `VFile#message()`, but associates a fatal message where `fatal` is\n   * set to `true`, and then immediately throws it.\n   *\n   * > 👉 **Note**: a fatal error means that a file is no longer processable.\n   *\n   * @param {string|Error} reason\n   *   Human readable reason for the message, uses the stack and message of the error if given.\n   * @param {Node|NodeLike|Position|Point} [place]\n   *   Place where the message occurred in the file.\n   * @param {string} [origin]\n   *   Computer readable reason for the message\n   * @returns {never}\n   *   Message.\n   */\n  fail(reason, place, origin) {\n    const message = this.message(reason, place, origin)\n\n    message.fatal = true\n\n    throw message\n  }\n}\n\n/**\n * Assert that `part` is not a path (as in, does not contain `path.sep`).\n *\n * @param {string|undefined} part\n * @param {string} name\n * @returns {void}\n */\nfunction assertPart(part, name) {\n  if (part && part.includes(path.sep)) {\n    throw new Error(\n      '`' + name + '` cannot be a path: did not expect `' + path.sep + '`'\n    )\n  }\n}\n\n/**\n * Assert that `part` is not empty.\n *\n * @param {string|undefined} part\n * @param {string} name\n * @returns {asserts part is string}\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 * @param {string} name\n * @returns {asserts path is string}\n */\nfunction assertPath(path, name) {\n  if (!path) {\n    throw new Error('Setting `' + name + '` requires `path` to be set too')\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","/**\n * @typedef {(error?: Error|null|undefined, ...output: Array<any>) => void} Callback\n * @typedef {(...input: Array<any>) => any} Middleware\n *\n * @typedef {(...input: Array<any>) => void} Run\n *   Call all middleware.\n * @typedef {(fn: Middleware) => Pipeline} Use\n *   Add `fn` (middleware) to the list.\n * @typedef {{run: Run, use: Use}} Pipeline\n *   Middleware.\n */\n\n/**\n * Create new middleware.\n *\n * @returns {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`.\n * Can be sync or async; return a promise, receive a callback, or return new\n * values and errors.\n *\n * @param {Middleware} middleware\n * @param {Callback} callback\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 instanceof Promise) {\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   * @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","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('vfile').VFileCompatible} VFileCompatible\n * @typedef {import('vfile').VFileValue} VFileValue\n * @typedef {import('..').Processor} Processor\n * @typedef {import('..').Plugin} Plugin\n * @typedef {import('..').Preset} Preset\n * @typedef {import('..').Pluggable} Pluggable\n * @typedef {import('..').PluggableList} PluggableList\n * @typedef {import('..').Transformer} Transformer\n * @typedef {import('..').Parser} Parser\n * @typedef {import('..').Compiler} Compiler\n * @typedef {import('..').RunCallback} RunCallback\n * @typedef {import('..').ProcessCallback} ProcessCallback\n *\n * @typedef Context\n * @property {Node} tree\n * @property {VFile} file\n */\n\nimport {bail} from 'bail'\nimport isBuffer from 'is-buffer'\nimport extend from 'extend'\nimport isPlainObj from 'is-plain-obj'\nimport {trough} from 'trough'\nimport {VFile} from 'vfile'\n\n// Expose a frozen processor.\nexport const unified = base().freeze()\n\nconst own = {}.hasOwnProperty\n\n// Function to create the first processor.\n/**\n * @returns {Processor}\n */\nfunction base() {\n  const transformers = trough()\n  /** @type {Processor['attachers']} */\n  const attachers = []\n  /** @type {Record<string, unknown>} */\n  let namespace = {}\n  /** @type {boolean|undefined} */\n  let frozen\n  let freezeIndex = -1\n\n  // Data management.\n  // @ts-expect-error: overloads are handled.\n  processor.data = data\n  processor.Parser = undefined\n  processor.Compiler = undefined\n\n  // Lock.\n  processor.freeze = freeze\n\n  // Plugins.\n  processor.attachers = attachers\n  // @ts-expect-error: overloads are handled.\n  processor.use = use\n\n  // API.\n  processor.parse = parse\n  processor.stringify = stringify\n  // @ts-expect-error: overloads are handled.\n  processor.run = run\n  processor.runSync = runSync\n  // @ts-expect-error: overloads are handled.\n  processor.process = process\n  processor.processSync = processSync\n\n  // Expose.\n  return processor\n\n  // Create a new processor based on the processor in the current scope.\n  /** @type {Processor} */\n  function processor() {\n    const destination = base()\n    let index = -1\n\n    while (++index < attachers.length) {\n      destination.use(...attachers[index])\n    }\n\n    destination.data(extend(true, {}, namespace))\n\n    return destination\n  }\n\n  /**\n   * @param {string|Record<string, unknown>} [key]\n   * @param {unknown} [value]\n   * @returns {unknown}\n   */\n  function data(key, value) {\n    if (typeof key === 'string') {\n      // Set `key`.\n      if (arguments.length === 2) {\n        assertUnfrozen('data', frozen)\n        namespace[key] = value\n        return processor\n      }\n\n      // Get `key`.\n      return (own.call(namespace, key) && namespace[key]) || null\n    }\n\n    // Set space.\n    if (key) {\n      assertUnfrozen('data', frozen)\n      namespace = key\n      return processor\n    }\n\n    // Get space.\n    return namespace\n  }\n\n  /** @type {Processor['freeze']} */\n  function freeze() {\n    if (frozen) {\n      return processor\n    }\n\n    while (++freezeIndex < attachers.length) {\n      const [attacher, ...options] = attachers[freezeIndex]\n\n      if (options[0] === false) {\n        continue\n      }\n\n      if (options[0] === true) {\n        options[0] = undefined\n      }\n\n      /** @type {Transformer|void} */\n      const transformer = attacher.call(processor, ...options)\n\n      if (typeof transformer === 'function') {\n        transformers.use(transformer)\n      }\n    }\n\n    frozen = true\n    freezeIndex = Number.POSITIVE_INFINITY\n\n    return processor\n  }\n\n  /**\n   * @param {Pluggable|null|undefined} [value]\n   * @param {...unknown} options\n   * @returns {Processor}\n   */\n  function use(value, ...options) {\n    /** @type {Record<string, unknown>|undefined} */\n    let settings\n\n    assertUnfrozen('use', frozen)\n\n    if (value === null || value === undefined) {\n      // Empty.\n    } else if (typeof value === 'function') {\n      addPlugin(value, ...options)\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    if (settings) {\n      namespace.settings = Object.assign(namespace.settings || {}, settings)\n    }\n\n    return processor\n\n    /**\n     * @param {import('..').Pluggable<unknown[]>} value\n     * @returns {void}\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, ...options] = value\n          addPlugin(plugin, ...options)\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 {void}\n     */\n    function addPreset(result) {\n      addList(result.plugins)\n\n      if (result.settings) {\n        settings = Object.assign(settings || {}, result.settings)\n      }\n    }\n\n    /**\n     * @param {PluggableList|null|undefined} [plugins]\n     * @returns {void}\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 {...unknown} [value]\n     * @returns {void}\n     */\n    function addPlugin(plugin, value) {\n      let index = -1\n      /** @type {Processor['attachers'][number]|undefined} */\n      let entry\n\n      while (++index < attachers.length) {\n        if (attachers[index][0] === plugin) {\n          entry = attachers[index]\n          break\n        }\n      }\n\n      if (entry) {\n        if (isPlainObj(entry[1]) && isPlainObj(value)) {\n          value = extend(true, entry[1], value)\n        }\n\n        entry[1] = value\n      } else {\n        // @ts-expect-error: fine.\n        attachers.push([...arguments])\n      }\n    }\n  }\n\n  /** @type {Processor['parse']} */\n  function parse(doc) {\n    processor.freeze()\n    const file = vfile(doc)\n    const Parser = processor.Parser\n    assertParser('parse', Parser)\n\n    if (newable(Parser, 'parse')) {\n      // @ts-expect-error: `newable` checks this.\n      return new Parser(String(file), file).parse()\n    }\n\n    // @ts-expect-error: `newable` checks this.\n    return Parser(String(file), file) // eslint-disable-line new-cap\n  }\n\n  /** @type {Processor['stringify']} */\n  function stringify(node, doc) {\n    processor.freeze()\n    const file = vfile(doc)\n    const Compiler = processor.Compiler\n    assertCompiler('stringify', Compiler)\n    assertNode(node)\n\n    if (newable(Compiler, 'compile')) {\n      // @ts-expect-error: `newable` checks this.\n      return new Compiler(node, file).compile()\n    }\n\n    // @ts-expect-error: `newable` checks this.\n    return Compiler(node, file) // eslint-disable-line new-cap\n  }\n\n  /**\n   * @param {Node} node\n   * @param {VFileCompatible|RunCallback} [doc]\n   * @param {RunCallback} [callback]\n   * @returns {Promise<Node>|void}\n   */\n  function run(node, doc, callback) {\n    assertNode(node)\n    processor.freeze()\n\n    if (!callback && typeof doc === 'function') {\n      callback = doc\n      doc = undefined\n    }\n\n    if (!callback) {\n      return new Promise(executor)\n    }\n\n    executor(null, callback)\n\n    /**\n     * @param {null|((node: Node) => void)} resolve\n     * @param {(error: Error) => void} reject\n     * @returns {void}\n     */\n    function executor(resolve, reject) {\n      // @ts-expect-error: `doc` can’t be a callback anymore, we checked.\n      transformers.run(node, vfile(doc), done)\n\n      /**\n       * @param {Error|null} error\n       * @param {Node} tree\n       * @param {VFile} file\n       * @returns {void}\n       */\n      function done(error, tree, file) {\n        tree = tree || node\n        if (error) {\n          reject(error)\n        } else if (resolve) {\n          resolve(tree)\n        } else {\n          // @ts-expect-error: `callback` is defined if `resolve` is not.\n          callback(null, tree, file)\n        }\n      }\n    }\n  }\n\n  /** @type {Processor['runSync']} */\n  function runSync(node, file) {\n    /** @type {Node|undefined} */\n    let result\n    /** @type {boolean|undefined} */\n    let complete\n\n    processor.run(node, file, done)\n\n    assertDone('runSync', 'run', complete)\n\n    // @ts-expect-error: we either bailed on an error or have a tree.\n    return result\n\n    /**\n     * @param {Error|null} [error]\n     * @param {Node} [tree]\n     * @returns {void}\n     */\n    function done(error, tree) {\n      bail(error)\n      result = tree\n      complete = true\n    }\n  }\n\n  /**\n   * @param {VFileCompatible} doc\n   * @param {ProcessCallback} [callback]\n   * @returns {Promise<VFile>|undefined}\n   */\n  function process(doc, callback) {\n    processor.freeze()\n    assertParser('process', processor.Parser)\n    assertCompiler('process', processor.Compiler)\n\n    if (!callback) {\n      return new Promise(executor)\n    }\n\n    executor(null, callback)\n\n    /**\n     * @param {null|((file: VFile) => void)} resolve\n     * @param {(error?: Error|null|undefined) => void} reject\n     * @returns {void}\n     */\n    function executor(resolve, reject) {\n      const file = vfile(doc)\n\n      processor.run(processor.parse(file), file, (error, tree, file) => {\n        if (error || !tree || !file) {\n          done(error)\n        } else {\n          /** @type {unknown} */\n          const result = processor.stringify(tree, file)\n\n          if (result === undefined || result === null) {\n            // Empty.\n          } else if (looksLikeAVFileValue(result)) {\n            file.value = result\n          } else {\n            file.result = result\n          }\n\n          done(error, file)\n        }\n      })\n\n      /**\n       * @param {Error|null|undefined} [error]\n       * @param {VFile|undefined} [file]\n       * @returns {void}\n       */\n      function done(error, file) {\n        if (error || !file) {\n          reject(error)\n        } else if (resolve) {\n          resolve(file)\n        } else {\n          // @ts-expect-error: `callback` is defined if `resolve` is not.\n          callback(null, file)\n        }\n      }\n    }\n  }\n\n  /** @type {Processor['processSync']} */\n  function processSync(doc) {\n    /** @type {boolean|undefined} */\n    let complete\n\n    processor.freeze()\n    assertParser('processSync', processor.Parser)\n    assertCompiler('processSync', processor.Compiler)\n\n    const file = vfile(doc)\n\n    processor.process(file, done)\n\n    assertDone('processSync', 'process', complete)\n\n    return file\n\n    /**\n     * @param {Error|null|undefined} [error]\n     * @returns {void}\n     */\n    function done(error) {\n      complete = true\n      bail(error)\n    }\n  }\n}\n\n/**\n * Check if `value` is a constructor.\n *\n * @param {unknown} value\n * @param {string} name\n * @returns {boolean}\n */\nfunction newable(value, name) {\n  return (\n    typeof value === 'function' &&\n    // Prototypes do exist.\n    // type-coverage:ignore-next-line\n    value.prototype &&\n    // A function with keys in its prototype is probably a constructor.\n    // Classes’ prototype methods are not enumerable, so we check if some value\n    // exists in the prototype.\n    // type-coverage:ignore-next-line\n    (keys(value.prototype) || name in value.prototype)\n  )\n}\n\n/**\n * Check if `value` is an object with keys.\n *\n * @param {Record<string, unknown>} value\n * @returns {boolean}\n */\nfunction keys(value) {\n  /** @type {string} */\n  let key\n\n  for (key in value) {\n    if (own.call(value, key)) {\n      return true\n    }\n  }\n\n  return false\n}\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 {VFileCompatible} [value]\n * @returns {VFile}\n */\nfunction vfile(value) {\n  return looksLikeAVFile(value) ? value : new VFile(value)\n}\n\n/**\n * @param {VFileCompatible} [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 VFileValue}\n */\nfunction looksLikeAVFileValue(value) {\n  return typeof value === 'string' || isBuffer(value)\n}\n","/**\n * @typedef Options\n * @property {boolean} [includeImageAlt=true]\n */\n\n/**\n * Get the text content of a node.\n * Prefer the node’s plain-text fields, otherwise serialize its children,\n * and if the given value is an array, serialize the nodes in it.\n *\n * @param {unknown} node\n * @param {Options} [options]\n * @returns {string}\n */\nexport function toString(node, options) {\n  var {includeImageAlt = true} = options || {}\n  return one(node, includeImageAlt)\n}\n\n/**\n * @param {unknown} node\n * @param {boolean} includeImageAlt\n * @returns {string}\n */\nfunction one(node, includeImageAlt) {\n  return (\n    (node &&\n      typeof node === 'object' &&\n      // @ts-ignore looks like a literal.\n      (node.value ||\n        // @ts-ignore looks like an image.\n        (includeImageAlt ? node.alt : '') ||\n        // @ts-ignore looks like a parent.\n        ('children' in node && all(node.children, includeImageAlt)) ||\n        (Array.isArray(node) && all(node, includeImageAlt)))) ||\n    ''\n  )\n}\n\n/**\n * @param {Array.<unknown>} values\n * @param {boolean} includeImageAlt\n * @returns {string}\n */\nfunction all(values, includeImageAlt) {\n  /** @type {Array.<string>} */\n  var result = []\n  var index = -1\n\n  while (++index < values.length) {\n    result[index] = one(values[index], includeImageAlt)\n  }\n\n  return result.join('')\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 * @param {T[]} list\n * @param {number} start\n * @param {number} remove\n * @param {T[]} items\n * @returns {void}\n */\nexport function splice(list, start, remove, items) {\n  const end = list.length\n  let chunkStart = 0\n  /** @type {unknown[]} */\n\n  let parameters // Make start between zero and `end` (included).\n\n  if (start < 0) {\n    start = -start > end ? 0 : end + start\n  } else {\n    start = start > end ? end : start\n  }\n\n  remove = remove > 0 ? remove : 0 // No need to chunk the items if there’s only a couple (10k) items.\n\n  if (items.length < 10000) {\n    parameters = Array.from(items)\n    parameters.unshift(start, remove) // @ts-expect-error Hush, it’s fine.\n    ;[].splice.apply(list, parameters)\n  } else {\n    // Delete `remove` items starting from `start`\n    if (remove) [].splice.apply(list, [start, remove]) // Insert the items in chunks to not cause stack overflows.\n\n    while (chunkStart < items.length) {\n      parameters = items.slice(chunkStart, chunkStart + 10000)\n      parameters.unshift(start, 0) // @ts-expect-error Hush, it’s fine.\n      ;[].splice.apply(list, parameters)\n      chunkStart += 10000\n      start += 10000\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 * @param {T[]} list\n * @param {T[]} items\n * @returns {T[]}\n */\n\nexport function push(list, items) {\n  if (list.length > 0) {\n    splice(list, list.length, 0, items)\n    return list\n  }\n\n  return items\n}\n","/**\n * @typedef {import('micromark-util-types').NormalizedExtension} NormalizedExtension\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension\n */\n\nimport {splice} from 'micromark-util-chunked'\n\nconst hasOwnProperty = {}.hasOwnProperty\n\n/**\n * Combine several syntax extensions into one.\n *\n * @param {Extension[]} extensions List of syntax extensions.\n * @returns {NormalizedExtension} 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 Extension to merge into.\n * @param {Extension} extension Extension to merge.\n * @returns {void}\n */\nfunction syntaxExtension(all, extension) {\n  /** @type {string} */\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 {string} */\n    let code\n\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 * Merge `list` into `existing` (both lists of constructs).\n * Mutates `existing`.\n *\n * @param {unknown[]} existing\n * @param {unknown[]} list\n * @returns {void}\n */\nfunction constructs(existing, list) {\n  let index = -1\n  /** @type {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 several HTML extensions into one.\n *\n * @param {HtmlExtension[]} htmlExtensions List of HTML extensions.\n * @returns {HtmlExtension} A single combined 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 Extension to merge into.\n * @param {HtmlExtension} extension Extension to merge.\n * @returns {void}\n */\nfunction htmlExtension(all, extension) {\n  /** @type {string} */\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 {string} */\n    let type\n\n    if (right) {\n      for (type in right) {\n        left[type] = right[type]\n      }\n    }\n  }\n}\n","// This module is generated by `script/`.\n//\n// CommonMark handles attention (emphasis, strong) markers based on what comes\n// before or after them.\n// One such difference is if those characters are Unicode punctuation.\n// This script is generated from the Unicode data.\nexport const unicodePunctuationRegex =\n  /[!-/:-@[-`{-~\\u00A1\\u00A7\\u00AB\\u00B6\\u00B7\\u00BB\\u00BF\\u037E\\u0387\\u055A-\\u055F\\u0589\\u058A\\u05BE\\u05C0\\u05C3\\u05C6\\u05F3\\u05F4\\u0609\\u060A\\u060C\\u060D\\u061B\\u061E\\u061F\\u066A-\\u066D\\u06D4\\u0700-\\u070D\\u07F7-\\u07F9\\u0830-\\u083E\\u085E\\u0964\\u0965\\u0970\\u09FD\\u0A76\\u0AF0\\u0C77\\u0C84\\u0DF4\\u0E4F\\u0E5A\\u0E5B\\u0F04-\\u0F12\\u0F14\\u0F3A-\\u0F3D\\u0F85\\u0FD0-\\u0FD4\\u0FD9\\u0FDA\\u104A-\\u104F\\u10FB\\u1360-\\u1368\\u1400\\u166E\\u169B\\u169C\\u16EB-\\u16ED\\u1735\\u1736\\u17D4-\\u17D6\\u17D8-\\u17DA\\u1800-\\u180A\\u1944\\u1945\\u1A1E\\u1A1F\\u1AA0-\\u1AA6\\u1AA8-\\u1AAD\\u1B5A-\\u1B60\\u1BFC-\\u1BFF\\u1C3B-\\u1C3F\\u1C7E\\u1C7F\\u1CC0-\\u1CC7\\u1CD3\\u2010-\\u2027\\u2030-\\u2043\\u2045-\\u2051\\u2053-\\u205E\\u207D\\u207E\\u208D\\u208E\\u2308-\\u230B\\u2329\\u232A\\u2768-\\u2775\\u27C5\\u27C6\\u27E6-\\u27EF\\u2983-\\u2998\\u29D8-\\u29DB\\u29FC\\u29FD\\u2CF9-\\u2CFC\\u2CFE\\u2CFF\\u2D70\\u2E00-\\u2E2E\\u2E30-\\u2E4F\\u2E52\\u3001-\\u3003\\u3008-\\u3011\\u3014-\\u301F\\u3030\\u303D\\u30A0\\u30FB\\uA4FE\\uA4FF\\uA60D-\\uA60F\\uA673\\uA67E\\uA6F2-\\uA6F7\\uA874-\\uA877\\uA8CE\\uA8CF\\uA8F8-\\uA8FA\\uA8FC\\uA92E\\uA92F\\uA95F\\uA9C1-\\uA9CD\\uA9DE\\uA9DF\\uAA5C-\\uAA5F\\uAADE\\uAADF\\uAAF0\\uAAF1\\uABEB\\uFD3E\\uFD3F\\uFE10-\\uFE19\\uFE30-\\uFE52\\uFE54-\\uFE61\\uFE63\\uFE68\\uFE6A\\uFE6B\\uFF01-\\uFF03\\uFF05-\\uFF0A\\uFF0C-\\uFF0F\\uFF1A\\uFF1B\\uFF1F\\uFF20\\uFF3B-\\uFF3D\\uFF3F\\uFF5B\\uFF5D\\uFF5F-\\uFF65]/\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {unicodePunctuationRegex} from './lib/unicode-punctuation-regex.js'\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\nexport const asciiAlpha = regexCheck(/[A-Za-z]/)\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\nexport const asciiDigit = regexCheck(/\\d/)\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\nexport const asciiHexDigit = regexCheck(/[\\dA-Fa-f]/)\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\nexport const asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/)\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\nexport const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/)\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\nexport const asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/)\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 * @returns {code is number}\n */\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 * Check whether a character code is a markdown line ending (see\n * `markdownLineEnding`) or markdown space (see `markdownSpace`).\n *\n * @param {Code} code\n * @returns {code is number}\n */\n\nexport function markdownLineEndingOrSpace(code) {\n  return code !== null && (code < 0 || code === 32)\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 * @returns {code is number}\n */\n\nexport function markdownLineEnding(code) {\n  return code !== null && code < -2\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 * @returns {code is number}\n */\n\nexport function markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32\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\nexport const unicodeWhitespace = regexCheck(/\\s/)\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// Size note: removing ASCII from the regex and using `asciiPunctuation` here\n// In fact adds to the bundle size.\n\nexport const unicodePunctuation = regexCheck(unicodePunctuationRegex)\n/**\n * Create a code check from a regex.\n *\n * @param {RegExp} regex\n * @returns {(code: Code) => code is number}\n */\n\nfunction regexCheck(regex) {\n  return check\n  /**\n   * Check whether a code matches the bound regex.\n   *\n   * @param {Code} code Character code\n   * @returns {code is number} Whether the character code matches the bound regex\n   */\n\n  function check(code) {\n    return code !== null && regex.test(String.fromCharCode(code))\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n */\nimport {markdownSpace} from 'micromark-util-character'\n/**\n * @param {Effects} effects\n * @param {State} ok\n * @param {string} type\n * @param {number} [max=Infinity]\n * @returns {State}\n */\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  /** @type {State} */\n\n  function start(code) {\n    if (markdownSpace(code)) {\n      effects.enter(type)\n      return prefix(code)\n    }\n\n    return ok(code)\n  }\n  /** @type {State} */\n\n  function prefix(code) {\n    if (markdownSpace(code) && size++ < limit) {\n      effects.consume(code)\n      return prefix\n    }\n\n    effects.exit(type)\n    return ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {InitialConstruct} */\nexport const content = {\n  tokenize: initializeContent\n}\n/** @type {Initializer} */\n\nfunction initializeContent(effects) {\n  const contentStart = effects.attempt(\n    this.parser.constructs.contentInitial,\n    afterContentStartConstruct,\n    paragraphInitial\n  )\n  /** @type {Token} */\n\n  let previous\n  return contentStart\n  /** @type {State} */\n\n  function afterContentStartConstruct(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\n    }\n\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(effects, contentStart, 'linePrefix')\n  }\n  /** @type {State} */\n\n  function paragraphInitial(code) {\n    effects.enter('paragraph')\n    return lineStart(code)\n  }\n  /** @type {State} */\n\n  function lineStart(code) {\n    const token = effects.enter('chunkText', {\n      contentType: 'text',\n      previous\n    })\n\n    if (previous) {\n      previous.next = token\n    }\n\n    previous = token\n    return data(code)\n  }\n  /** @type {State} */\n\n  function data(code) {\n    if (code === null) {\n      effects.exit('chunkText')\n      effects.exit('paragraph')\n      effects.consume(code)\n      return\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.consume(code)\n      effects.exit('chunkText')\n      return lineStart\n    } // Data.\n\n    effects.consume(code)\n    return data\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Point} Point\n */\n\n/**\n * @typedef {Record<string, unknown>} StackState\n * @typedef {[Construct, StackState]} StackItem\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\nimport {splice} from 'micromark-util-chunked'\n/** @type {InitialConstruct} */\n\nexport const document = {\n  tokenize: initializeDocument\n}\n/** @type {Construct} */\n\nconst containerConstruct = {\n  tokenize: tokenizeContainer\n}\n/** @type {Initializer} */\n\nfunction initializeDocument(effects) {\n  const self = this\n  /** @type {StackItem[]} */\n\n  const stack = []\n  let continued = 0\n  /** @type {TokenizeContext|undefined} */\n\n  let childFlow\n  /** @type {Token|undefined} */\n\n  let childToken\n  /** @type {number} */\n\n  let lineStartOffset\n  return start\n  /** @type {State} */\n\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(\n        item[0].continuation,\n        documentContinue,\n        checkNewContainers\n      )(code)\n    } // Done.\n\n    return checkNewContainers(code)\n  }\n  /** @type {State} */\n\n  function documentContinue(code) {\n    continued++ // 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\n    if (self.containerState._closeFlow) {\n      self.containerState._closeFlow = undefined\n\n      if (childFlow) {\n        closeFlow()\n      } // Note: this algorithm for moving events around is similar to the\n      // algorithm when dealing with lazy lines in `writeToChild`.\n\n      const indexBeforeExits = self.events.length\n      let indexBeforeFlow = indexBeforeExits\n      /** @type {Point|undefined} */\n\n      let point // Find the flow chunk.\n\n      while (indexBeforeFlow--) {\n        if (\n          self.events[indexBeforeFlow][0] === 'exit' &&\n          self.events[indexBeforeFlow][1].type === 'chunkFlow'\n        ) {\n          point = self.events[indexBeforeFlow][1].end\n          break\n        }\n      }\n\n      exitContainers(continued) // Fix positions.\n\n      let index = indexBeforeExits\n\n      while (index < self.events.length) {\n        self.events[index][1].end = Object.assign({}, point)\n        index++\n      } // Inject the exits earlier (they’re still also at the end).\n\n      splice(\n        self.events,\n        indexBeforeFlow + 1,\n        0,\n        self.events.slice(indexBeforeExits)\n      ) // Discard the duplicate exits.\n\n      self.events.length = index\n      return checkNewContainers(code)\n    }\n\n    return start(code)\n  }\n  /** @type {State} */\n\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      } // 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\n      if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {\n        return flowStart(code)\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\n      self.interrupt = Boolean(\n        childFlow.currentConstruct && !childFlow._gfmTableDynamicInterruptHack\n      )\n    } // Check if there is a new container.\n\n    self.containerState = {}\n    return effects.check(\n      containerConstruct,\n      thereIsANewContainer,\n      thereIsNoNewContainer\n    )(code)\n  }\n  /** @type {State} */\n\n  function thereIsANewContainer(code) {\n    if (childFlow) closeFlow()\n    exitContainers(continued)\n    return documentContinued(code)\n  }\n  /** @type {State} */\n\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  /** @type {State} */\n\n  function documentContinued(code) {\n    // Try new containers.\n    self.containerState = {}\n    return effects.attempt(\n      containerConstruct,\n      containerContinue,\n      flowStart\n    )(code)\n  }\n  /** @type {State} */\n\n  function containerContinue(code) {\n    continued++\n    stack.push([self.currentConstruct, self.containerState]) // Try another.\n\n    return documentContinued(code)\n  }\n  /** @type {State} */\n\n  function flowStart(code) {\n    if (code === null) {\n      if (childFlow) closeFlow()\n      exitContainers(0)\n      effects.consume(code)\n      return\n    }\n\n    childFlow = childFlow || self.parser.flow(self.now())\n    effects.enter('chunkFlow', {\n      contentType: 'flow',\n      previous: childToken,\n      _tokenizer: childFlow\n    })\n    return flowContinue(code)\n  }\n  /** @type {State} */\n\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\n    if (markdownLineEnding(code)) {\n      effects.consume(code)\n      writeToChild(effects.exit('chunkFlow')) // Get ready for the next line.\n\n      continued = 0\n      self.interrupt = undefined\n      return start\n    }\n\n    effects.consume(code)\n    return flowContinue\n  }\n  /**\n   * @param {Token} token\n   * @param {boolean} [eof]\n   * @returns {void}\n   */\n\n  function writeToChild(token, eof) {\n    const stream = self.sliceStream(token)\n    if (eof) 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) // 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\n    if (self.parser.lazy[token.start.line]) {\n      let index = childFlow.events.length\n\n      while (index--) {\n        if (\n          // The token starts before the line ending…\n          childFlow.events[index][1].start.offset < lineStartOffset && // …and either is not ended yet…\n          (!childFlow.events[index][1].end || // …or ends after it.\n            childFlow.events[index][1].end.offset > lineStartOffset)\n        ) {\n          // Exit: there’s still something open, which means it’s a lazy line\n          // part of something.\n          return\n        }\n      } // Note: this algorithm for moving events around is similar to the\n      // algorithm when closing flow in `documentContinue`.\n\n      const indexBeforeExits = self.events.length\n      let indexBeforeFlow = indexBeforeExits\n      /** @type {boolean|undefined} */\n\n      let seen\n      /** @type {Point|undefined} */\n\n      let point // Find the previous chunk (the one before the lazy line).\n\n      while (indexBeforeFlow--) {\n        if (\n          self.events[indexBeforeFlow][0] === 'exit' &&\n          self.events[indexBeforeFlow][1].type === 'chunkFlow'\n        ) {\n          if (seen) {\n            point = self.events[indexBeforeFlow][1].end\n            break\n          }\n\n          seen = true\n        }\n      }\n\n      exitContainers(continued) // Fix positions.\n\n      index = indexBeforeExits\n\n      while (index < self.events.length) {\n        self.events[index][1].end = Object.assign({}, point)\n        index++\n      } // Inject the exits earlier (they’re still also at the end).\n\n      splice(\n        self.events,\n        indexBeforeFlow + 1,\n        0,\n        self.events.slice(indexBeforeExits)\n      ) // Discard the duplicate exits.\n\n      self.events.length = index\n    }\n  }\n  /**\n   * @param {number} size\n   * @returns {void}\n   */\n\n  function exitContainers(size) {\n    let index = stack.length // Exit open containers.\n\n    while (index-- > size) {\n      const entry = stack[index]\n      self.containerState = entry[1]\n      entry[0].exit.call(self, effects)\n    }\n\n    stack.length = size\n  }\n\n  function closeFlow() {\n    childFlow.write([null])\n    childToken = undefined\n    childFlow = undefined\n    self.containerState._closeFlow = undefined\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeContainer(effects, ok, nok) {\n  return factorySpace(\n    effects,\n    effects.attempt(this.parser.constructs.document, ok, nok),\n    'linePrefix',\n    this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4\n  )\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const blankLine = {\n  tokenize: tokenizeBlankLine,\n  partial: true\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeBlankLine(effects, ok, nok) {\n  return factorySpace(effects, afterWhitespace, 'linePrefix')\n  /** @type {State} */\n\n  function afterWhitespace(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Event} Event\n */\nimport {splice} from 'micromark-util-chunked'\n\n/**\n * Tokenize subcontent.\n *\n * @param {Event[]} events\n * @returns {boolean}\n */\nexport function subtokenize(events) {\n  /** @type {Record<string, number>} */\n  const jumps = {}\n  let index = -1\n  /** @type {Event} */\n\n  let event\n  /** @type {number|undefined} */\n\n  let lineIndex\n  /** @type {number} */\n\n  let otherIndex\n  /** @type {Event} */\n\n  let otherEvent\n  /** @type {Event[]} */\n\n  let parameters\n  /** @type {Event[]} */\n\n  let subevents\n  /** @type {boolean|undefined} */\n\n  let more\n\n  while (++index < events.length) {\n    while (index in jumps) {\n      index = jumps[index]\n    }\n\n    event = events[index] // 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\n    if (\n      index &&\n      event[1].type === 'chunkFlow' &&\n      events[index - 1][1].type === 'listItemPrefix'\n    ) {\n      subevents = event[1]._tokenizer.events\n      otherIndex = 0\n\n      if (\n        otherIndex < subevents.length &&\n        subevents[otherIndex][1].type === 'lineEndingBlank'\n      ) {\n        otherIndex += 2\n      }\n\n      if (\n        otherIndex < subevents.length &&\n        subevents[otherIndex][1].type === 'content'\n      ) {\n        while (++otherIndex < subevents.length) {\n          if (subevents[otherIndex][1].type === 'content') {\n            break\n          }\n\n          if (subevents[otherIndex][1].type === 'chunkText') {\n            subevents[otherIndex][1]._isInFirstContentOfListItem = true\n            otherIndex++\n          }\n        }\n      }\n    } // Enter.\n\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    } // Exit.\n    else if (event[1]._container) {\n      otherIndex = index\n      lineIndex = undefined\n\n      while (otherIndex--) {\n        otherEvent = events[otherIndex]\n\n        if (\n          otherEvent[1].type === 'lineEnding' ||\n          otherEvent[1].type === 'lineEndingBlank'\n        ) {\n          if (otherEvent[0] === 'enter') {\n            if (lineIndex) {\n              events[lineIndex][1].type = 'lineEndingBlank'\n            }\n\n            otherEvent[1].type = 'lineEnding'\n            lineIndex = otherIndex\n          }\n        } else {\n          break\n        }\n      }\n\n      if (lineIndex) {\n        // Fix position.\n        event[1].end = Object.assign({}, events[lineIndex][1].start) // Switch container exit w/ line endings.\n\n        parameters = events.slice(lineIndex, index)\n        parameters.unshift(event)\n        splice(events, lineIndex, index - lineIndex + 1, parameters)\n      }\n    }\n  }\n\n  return !more\n}\n/**\n * Tokenize embedded tokens.\n *\n * @param {Event[]} events\n * @param {number} eventIndex\n * @returns {Record<string, number>}\n */\n\nfunction subcontent(events, eventIndex) {\n  const token = events[eventIndex][1]\n  const context = events[eventIndex][2]\n  let startPosition = eventIndex - 1\n  /** @type {number[]} */\n\n  const startPositions = []\n  const tokenizer =\n    token._tokenizer || context.parser[token.contentType](token.start)\n  const childEvents = tokenizer.events\n  /** @type {[number, number][]} */\n\n  const jumps = []\n  /** @type {Record<string, number>} */\n\n  const gaps = {}\n  /** @type {Chunk[]} */\n\n  let stream\n  /** @type {Token|undefined} */\n\n  let previous\n  let index = -1\n  /** @type {Token|undefined} */\n\n  let current = token\n  let adjust = 0\n  let start = 0\n  const breaks = [start] // Loop forward through the linked tokens to pass them in order to the\n  // subtokenizer.\n\n  while (current) {\n    // Find the position of the event for this token.\n    while (events[++startPosition][1] !== current) {\n      // Empty.\n    }\n\n    startPositions.push(startPosition)\n\n    if (!current._tokenizer) {\n      stream = context.sliceStream(current)\n\n      if (!current.next) {\n        stream.push(null)\n      }\n\n      if (previous) {\n        tokenizer.defineSkip(current.start)\n      }\n\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = true\n      }\n\n      tokenizer.write(stream)\n\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = undefined\n      }\n    } // Unravel the next token.\n\n    previous = current\n    current = current.next\n  } // Now, loop back through all events (and linked tokens), to figure out which\n  // parts belong where.\n\n  current = token\n\n  while (++index < childEvents.length) {\n    if (\n      // Find a void token that includes a break.\n      childEvents[index][0] === 'exit' &&\n      childEvents[index - 1][0] === 'enter' &&\n      childEvents[index][1].type === childEvents[index - 1][1].type &&\n      childEvents[index][1].start.line !== childEvents[index][1].end.line\n    ) {\n      start = index + 1\n      breaks.push(start) // Help GC.\n\n      current._tokenizer = undefined\n      current.previous = undefined\n      current = current.next\n    }\n  } // Help GC.\n\n  tokenizer.events = [] // 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\n  if (current) {\n    // Help GC.\n    current._tokenizer = undefined\n    current.previous = undefined\n  } else {\n    breaks.pop()\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\n  index = breaks.length\n\n  while (index--) {\n    const slice = childEvents.slice(breaks[index], breaks[index + 1])\n    const start = startPositions.pop()\n    jumps.unshift([start, start + slice.length - 1])\n    splice(events, start, 2, slice)\n  }\n\n  index = -1\n\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\n  return gaps\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\nimport {subtokenize} from 'micromark-util-subtokenize'\n\n/**\n * No name because it must not be turned off.\n * @type {Construct}\n */\nexport const content = {\n  tokenize: tokenizeContent,\n  resolve: resolveContent\n}\n/** @type {Construct} */\n\nconst continuationConstruct = {\n  tokenize: tokenizeContinuation,\n  partial: true\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 */\n\nfunction resolveContent(events) {\n  subtokenize(events)\n  return events\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeContent(effects, ok) {\n  /** @type {Token} */\n  let previous\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('content')\n    previous = effects.enter('chunkContent', {\n      contentType: 'content'\n    })\n    return data(code)\n  }\n  /** @type {State} */\n\n  function data(code) {\n    if (code === null) {\n      return contentEnd(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.check(\n        continuationConstruct,\n        contentContinue,\n        contentEnd\n      )(code)\n    } // Data.\n\n    effects.consume(code)\n    return data\n  }\n  /** @type {State} */\n\n  function contentEnd(code) {\n    effects.exit('chunkContent')\n    effects.exit('content')\n    return ok(code)\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 data\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeContinuation(effects, ok, nok) {\n  const self = this\n  return startLookahead\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  /** @type {State} */\n\n  function prefixed(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code)\n    }\n\n    const tail = self.events[self.events.length - 1]\n\n    if (\n      !self.parser.constructs.disable.null.includes('codeIndented') &&\n      tail &&\n      tail[1].type === 'linePrefix' &&\n      tail[2].sliceSerialize(tail[1], true).length >= 4\n    ) {\n      return ok(code)\n    }\n\n    return effects.interrupt(self.parser.constructs.flow, nok, ok)(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {blankLine, content} from 'micromark-core-commonmark'\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {InitialConstruct} */\nexport const flow = {\n  tokenize: initializeFlow\n}\n/** @type {Initializer} */\n\nfunction initializeFlow(effects) {\n  const self = this\n  const initial = effects.attempt(\n    // Try to parse a blank line.\n    blankLine,\n    atBlankEnding, // Try to parse initial flow (essentially, only code).\n    effects.attempt(\n      this.parser.constructs.flowInitial,\n      afterConstruct,\n      factorySpace(\n        effects,\n        effects.attempt(\n          this.parser.constructs.flow,\n          afterConstruct,\n          effects.attempt(content, afterConstruct)\n        ),\n        'linePrefix'\n      )\n    )\n  )\n  return initial\n  /** @type {State} */\n\n  function atBlankEnding(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\n    }\n\n    effects.enter('lineEndingBlank')\n    effects.consume(code)\n    effects.exit('lineEndingBlank')\n    self.currentConstruct = undefined\n    return initial\n  }\n  /** @type {State} */\n\n  function afterConstruct(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\n    }\n\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    self.currentConstruct = undefined\n    return initial\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nexport const resolver = {\n  resolveAll: createResolver()\n}\nexport const string = initializeFactory('string')\nexport const text = initializeFactory('text')\n/**\n * @param {'string'|'text'} field\n * @returns {InitialConstruct}\n */\n\nfunction initializeFactory(field) {\n  return {\n    tokenize: initializeText,\n    resolveAll: createResolver(\n      field === 'text' ? resolveAllLineSuffixes : undefined\n    )\n  }\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    /** @type {State} */\n\n    function start(code) {\n      return atBreak(code) ? text(code) : notText(code)\n    }\n    /** @type {State} */\n\n    function notText(code) {\n      if (code === null) {\n        effects.consume(code)\n        return\n      }\n\n      effects.enter('data')\n      effects.consume(code)\n      return data\n    }\n    /** @type {State} */\n\n    function data(code) {\n      if (atBreak(code)) {\n        effects.exit('data')\n        return text(code)\n      } // Data.\n\n      effects.consume(code)\n      return data\n    }\n    /**\n     * @param {Code} code\n     * @returns {boolean}\n     */\n\n    function atBreak(code) {\n      if (code === null) {\n        return true\n      }\n\n      const list = constructs[code]\n      let index = -1\n\n      if (list) {\n        while (++index < list.length) {\n          const item = list[index]\n\n          if (!item.previous || item.previous.call(self, self.previous)) {\n            return true\n          }\n        }\n      }\n\n      return false\n    }\n  }\n}\n/**\n * @param {Resolver} [extraResolver]\n * @returns {Resolver}\n */\n\nfunction createResolver(extraResolver) {\n  return resolveAllText\n  /** @type {Resolver} */\n\n  function resolveAllText(events, context) {\n    let index = -1\n    /** @type {number|undefined} */\n\n    let enter // A rather boring computation (to merge adjacent `data` events) which\n    // improves mm performance by 29%.\n\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\n        enter = undefined\n      }\n    }\n\n    return extraResolver ? extraResolver(events, context) : events\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 */\n\nfunction resolveAllLineSuffixes(events, context) {\n  let eventIndex = 0 // Skip first.\n\n  while (++eventIndex <= events.length) {\n    if (\n      (eventIndex === events.length ||\n        events[eventIndex][1].type === 'lineEnding') &&\n      events[eventIndex - 1][1].type === 'data'\n    ) {\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\n      let tabs\n\n      while (index--) {\n        const chunk = chunks[index]\n\n        if (typeof chunk === 'string') {\n          bufferIndex = chunk.length\n\n          while (chunk.charCodeAt(bufferIndex - 1) === 32) {\n            size++\n            bufferIndex--\n          }\n\n          if (bufferIndex) break\n          bufferIndex = -1\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\n      if (size) {\n        const token = {\n          type:\n            eventIndex === events.length || tabs || size < 2\n              ? 'lineSuffix'\n              : 'hardBreakTrailing',\n          start: {\n            line: data.end.line,\n            column: data.end.column - size,\n            offset: data.end.offset - size,\n            _index: data.start._index + index,\n            _bufferIndex: index\n              ? bufferIndex\n              : data.start._bufferIndex + bufferIndex\n          },\n          end: Object.assign({}, data.end)\n        }\n        data.end = Object.assign({}, token.start)\n\n        if (data.start.offset === data.end.offset) {\n          Object.assign(data, token)\n        } else {\n          events.splice(\n            eventIndex,\n            0,\n            ['enter', token, context],\n            ['exit', token, context]\n          )\n          eventIndex += 2\n        }\n      }\n\n      eventIndex++\n    }\n  }\n\n  return events\n}\n","/**\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Resolver} Resolver\n */\n\n/**\n * Call all `resolveAll`s.\n *\n * @param {{resolveAll?: Resolver}[]} constructs\n * @param {Event[]} events\n * @param {TokenizeContext} context\n * @returns {Event[]}\n */\nexport function resolveAll(constructs, events, context) {\n  /** @type {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 * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Point} Point\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').ConstructRecord} ConstructRecord\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').ParseContext} ParseContext\n */\n\n/**\n * @typedef Info\n * @property {() => void} restore\n * @property {number} from\n *\n * @callback ReturnHandle\n *   Handle a successful run.\n * @param {Construct} construct\n * @param {Info} info\n * @returns {void}\n */\nimport {markdownLineEnding} from 'micromark-util-character'\nimport {push, splice} from 'micromark-util-chunked'\nimport {resolveAll} from 'micromark-util-resolve-all'\n\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 * @param {InitialConstruct} initialize\n * @param {Omit<Point, '_index'|'_bufferIndex'>} [from]\n * @returns {TokenizeContext}\n */\nexport function createTokenizer(parser, initialize, from) {\n  /** @type {Point} */\n  let point = Object.assign(\n    from\n      ? Object.assign({}, from)\n      : {\n          line: 1,\n          column: 1,\n          offset: 0\n        },\n    {\n      _index: 0,\n      _bufferIndex: -1\n    }\n  )\n  /** @type {Record<string, number>} */\n\n  const columnStart = {}\n  /** @type {Construct[]} */\n\n  const resolveAllConstructs = []\n  /** @type {Chunk[]} */\n\n  let chunks = []\n  /** @type {Token[]} */\n\n  let stack = []\n  /** @type {boolean|undefined} */\n\n  let consumed = true\n  /**\n   * Tools used for tokenizing.\n   *\n   * @type {Effects}\n   */\n\n  const effects = {\n    consume,\n    enter,\n    exit,\n    attempt: constructFactory(onsuccessfulconstruct),\n    check: constructFactory(onsuccessfulcheck),\n    interrupt: constructFactory(onsuccessfulcheck, {\n      interrupt: true\n    })\n  }\n  /**\n   * State and tools for resolving and serializing.\n   *\n   * @type {TokenizeContext}\n   */\n\n  const context = {\n    previous: null,\n    code: null,\n    containerState: {},\n    events: [],\n    parser,\n    sliceStream,\n    sliceSerialize,\n    now,\n    defineSkip,\n    write\n  }\n  /**\n   * The state function.\n   *\n   * @type {State|void}\n   */\n\n  let state = initialize.tokenize.call(context, effects)\n  /**\n   * Track which character we expect to be consumed, to catch bugs.\n   *\n   * @type {Code}\n   */\n\n  let expectedCode\n\n  if (initialize.resolveAll) {\n    resolveAllConstructs.push(initialize)\n  }\n\n  return context\n  /** @type {TokenizeContext['write']} */\n\n  function write(slice) {\n    chunks = push(chunks, slice)\n    main() // Exit if we’re not done, resolve might change stuff.\n\n    if (chunks[chunks.length - 1] !== null) {\n      return []\n    }\n\n    addResult(initialize, 0) // Otherwise, resolve, and exit.\n\n    context.events = resolveAll(resolveAllConstructs, context.events, context)\n    return context.events\n  } //\n  // Tools.\n  //\n\n  /** @type {TokenizeContext['sliceSerialize']} */\n\n  function sliceSerialize(token, expandTabs) {\n    return serializeChunks(sliceStream(token), expandTabs)\n  }\n  /** @type {TokenizeContext['sliceStream']} */\n\n  function sliceStream(token) {\n    return sliceChunks(chunks, token)\n  }\n  /** @type {TokenizeContext['now']} */\n\n  function now() {\n    return Object.assign({}, point)\n  }\n  /** @type {TokenizeContext['defineSkip']} */\n\n  function defineSkip(value) {\n    columnStart[value.line] = value.column\n    accountForPotentialSkip()\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 {void}\n   */\n\n  function main() {\n    /** @type {number} */\n    let chunkIndex\n\n    while (point._index < chunks.length) {\n      const chunk = chunks[point._index] // If we’re in a buffer chunk, loop through it.\n\n      if (typeof chunk === 'string') {\n        chunkIndex = point._index\n\n        if (point._bufferIndex < 0) {\n          point._bufferIndex = 0\n        }\n\n        while (\n          point._index === chunkIndex &&\n          point._bufferIndex < chunk.length\n        ) {\n          go(chunk.charCodeAt(point._bufferIndex))\n        }\n      } else {\n        go(chunk)\n      }\n    }\n  }\n  /**\n   * Deal with one code.\n   *\n   * @param {Code} code\n   * @returns {void}\n   */\n\n  function go(code) {\n    consumed = undefined\n    expectedCode = code\n    state = state(code)\n  }\n  /** @type {Effects['consume']} */\n\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    } // Not in a string chunk.\n\n    if (point._bufferIndex < 0) {\n      point._index++\n    } else {\n      point._bufferIndex++ // At end of string chunk.\n      // @ts-expect-error Points w/ non-negative `_bufferIndex` reference\n      // strings.\n\n      if (point._bufferIndex === chunks[point._index].length) {\n        point._bufferIndex = -1\n        point._index++\n      }\n    } // Expose the previous character.\n\n    context.previous = code // Mark as consumed.\n\n    consumed = true\n  }\n  /** @type {Effects['enter']} */\n\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  /** @type {Effects['exit']} */\n\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   * Use results.\n   *\n   * @type {ReturnHandle}\n   */\n\n  function onsuccessfulconstruct(construct, info) {\n    addResult(construct, info.from)\n  }\n  /**\n   * Discard results.\n   *\n   * @type {ReturnHandle}\n   */\n\n  function onsuccessfulcheck(_, info) {\n    info.restore()\n  }\n  /**\n   * Factory to attempt/check/interrupt.\n   *\n   * @param {ReturnHandle} onreturn\n   * @param {Record<string, unknown>} [fields]\n   */\n\n  function constructFactory(onreturn, fields) {\n    return hook\n    /**\n     * Handle either an object mapping codes to constructs, a list of\n     * constructs, or a single construct.\n     *\n     * @param {Construct|Construct[]|ConstructRecord} constructs\n     * @param {State} returnState\n     * @param {State} [bogusState]\n     * @returns {State}\n     */\n\n    function hook(constructs, returnState, bogusState) {\n      /** @type {Construct[]} */\n      let listOfConstructs\n      /** @type {number} */\n\n      let constructIndex\n      /** @type {Construct} */\n\n      let currentConstruct\n      /** @type {Info} */\n\n      let info\n      return Array.isArray(constructs)\n        ? /* c8 ignore next 1 */\n          handleListOfConstructs(constructs)\n        : 'tokenize' in constructs // @ts-expect-error Looks like a construct.\n        ? handleListOfConstructs([constructs])\n        : handleMapOfConstructs(constructs)\n      /**\n       * Handle a list of construct.\n       *\n       * @param {ConstructRecord} map\n       * @returns {State}\n       */\n\n      function handleMapOfConstructs(map) {\n        return start\n        /** @type {State} */\n\n        function start(code) {\n          const def = code !== null && map[code]\n          const all = code !== null && map.null\n          const list = [\n            // To do: add more extension tests.\n\n            /* c8 ignore next 2 */\n            ...(Array.isArray(def) ? def : def ? [def] : []),\n            ...(Array.isArray(all) ? all : all ? [all] : [])\n          ]\n          return handleListOfConstructs(list)(code)\n        }\n      }\n      /**\n       * Handle a list of construct.\n       *\n       * @param {Construct[]} list\n       * @returns {State}\n       */\n\n      function handleListOfConstructs(list) {\n        listOfConstructs = list\n        constructIndex = 0\n\n        if (list.length === 0) {\n          return bogusState\n        }\n\n        return handleConstruct(list[constructIndex])\n      }\n      /**\n       * Handle a single construct.\n       *\n       * @param {Construct} construct\n       * @returns {State}\n       */\n\n      function handleConstruct(construct) {\n        return start\n        /** @type {State} */\n\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\n          if (!construct.partial) {\n            context.currentConstruct = construct\n          }\n\n          if (\n            construct.name &&\n            context.parser.constructs.disable.null.includes(construct.name)\n          ) {\n            return nok(code)\n          }\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,\n            effects,\n            ok,\n            nok\n          )(code)\n        }\n      }\n      /** @type {State} */\n\n      function ok(code) {\n        consumed = true\n        onreturn(currentConstruct, info)\n        return returnState\n      }\n      /** @type {State} */\n\n      function nok(code) {\n        consumed = true\n        info.restore()\n\n        if (++constructIndex < listOfConstructs.length) {\n          return handleConstruct(listOfConstructs[constructIndex])\n        }\n\n        return bogusState\n      }\n    }\n  }\n  /**\n   * @param {Construct} construct\n   * @param {number} from\n   * @returns {void}\n   */\n\n  function addResult(construct, from) {\n    if (construct.resolveAll && !resolveAllConstructs.includes(construct)) {\n      resolveAllConstructs.push(construct)\n    }\n\n    if (construct.resolve) {\n      splice(\n        context.events,\n        from,\n        context.events.length - from,\n        construct.resolve(context.events.slice(from), context)\n      )\n    }\n\n    if (construct.resolveTo) {\n      context.events = construct.resolveTo(context.events, context)\n    }\n  }\n  /**\n   * Store state.\n   *\n   * @returns {Info}\n   */\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      restore,\n      from: startEventsIndex\n    }\n    /**\n     * Restore state.\n     *\n     * @returns {void}\n     */\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   * Move the current point a bit forward in the line when it’s on a column\n   * skip.\n   *\n   * @returns {void}\n   */\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 * Get the chunks from a slice of chunks in the range of a token.\n *\n * @param {Chunk[]} chunks\n * @param {Pick<Token, 'start'|'end'>} token\n * @returns {Chunk[]}\n */\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 {Chunk[]} */\n\n  let view\n\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\n    if (startBufferIndex > -1) {\n      // @ts-expect-error `_bufferIndex` is used on string chunks.\n      view[0] = view[0].slice(startBufferIndex)\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\n  return view\n}\n/**\n * Get the string value of a slice of chunks.\n *\n * @param {Chunk[]} chunks\n * @param {boolean} [expandTabs=false]\n * @returns {string}\n */\n\nfunction serializeChunks(chunks, expandTabs) {\n  let index = -1\n  /** @type {string[]} */\n\n  const result = []\n  /** @type {boolean|undefined} */\n\n  let atTab\n\n  while (++index < chunks.length) {\n    const chunk = chunks[index]\n    /** @type {string} */\n\n    let value\n\n    if (typeof chunk === 'string') {\n      value = chunk\n    } else\n      switch (chunk) {\n        case -5: {\n          value = '\\r'\n          break\n        }\n\n        case -4: {\n          value = '\\n'\n          break\n        }\n\n        case -3: {\n          value = '\\r' + '\\n'\n          break\n        }\n\n        case -2: {\n          value = expandTabs ? ' ' : '\\t'\n          break\n        }\n\n        case -1: {\n          if (!expandTabs && atTab) continue\n          value = ' '\n          break\n        }\n\n        default: {\n          // Currently only replacement character.\n          value = String.fromCharCode(chunk)\n        }\n      }\n\n    atTab = chunk === -2\n    result.push(value)\n  }\n\n  return result.join('')\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const thematicBreak = {\n  name: 'thematicBreak',\n  tokenize: tokenizeThematicBreak\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeThematicBreak(effects, ok, nok) {\n  let size = 0\n  /** @type {NonNullable<Code>} */\n\n  let marker\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('thematicBreak')\n    marker = code\n    return atBreak(code)\n  }\n  /** @type {State} */\n\n  function atBreak(code) {\n    if (code === marker) {\n      effects.enter('thematicBreakSequence')\n      return sequence(code)\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(effects, atBreak, 'whitespace')(code)\n    }\n\n    if (size < 3 || (code !== null && !markdownLineEnding(code))) {\n      return nok(code)\n    }\n\n    effects.exit('thematicBreak')\n    return ok(code)\n  }\n  /** @type {State} */\n\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code)\n      size++\n      return sequence\n    }\n\n    effects.exit('thematicBreakSequence')\n    return atBreak(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Exiter} Exiter\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\n\n/**\n * @typedef {Record<string, unknown> & {marker: Code, type: string, size: number}} ListContainerState\n * @typedef {TokenizeContext & {containerState: ListContainerState}} TokenizeContextWithState\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/** @type {Construct} */\n\nexport const list = {\n  name: 'list',\n  tokenize: tokenizeListStart,\n  continuation: {\n    tokenize: tokenizeListContinuation\n  },\n  exit: tokenizeListEnd\n}\n/** @type {Construct} */\n\nconst listItemPrefixWhitespaceConstruct = {\n  tokenize: tokenizeListItemPrefixWhitespace,\n  partial: true\n}\n/** @type {Construct} */\n\nconst indentConstruct = {\n  tokenize: tokenizeIndent,\n  partial: true\n}\n/**\n * @type {Tokenizer}\n * @this {TokenizeContextWithState}\n */\n\nfunction tokenizeListStart(effects, ok, nok) {\n  const self = this\n  const tail = self.events[self.events.length - 1]\n  let initialSize =\n    tail && tail[1].type === 'linePrefix'\n      ? tail[2].sliceSerialize(tail[1], true).length\n      : 0\n  let size = 0\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    const kind =\n      self.containerState.type ||\n      (code === 42 || code === 43 || code === 45\n        ? 'listUnordered'\n        : 'listOrdered')\n\n    if (\n      kind === 'listUnordered'\n        ? !self.containerState.marker || code === self.containerState.marker\n        : asciiDigit(code)\n    ) {\n      if (!self.containerState.type) {\n        self.containerState.type = kind\n        effects.enter(kind, {\n          _container: true\n        })\n      }\n\n      if (kind === 'listUnordered') {\n        effects.enter('listItemPrefix')\n        return code === 42 || code === 45\n          ? effects.check(thematicBreak, nok, atMarker)(code)\n          : atMarker(code)\n      }\n\n      if (!self.interrupt || code === 49) {\n        effects.enter('listItemPrefix')\n        effects.enter('listItemValue')\n        return inside(code)\n      }\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function inside(code) {\n    if (asciiDigit(code) && ++size < 10) {\n      effects.consume(code)\n      return inside\n    }\n\n    if (\n      (!self.interrupt || size < 2) &&\n      (self.containerState.marker\n        ? code === self.containerState.marker\n        : code === 41 || code === 46)\n    ) {\n      effects.exit('listItemValue')\n      return atMarker(code)\n    }\n\n    return nok(code)\n  }\n  /**\n   * @type {State}\n   **/\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(\n      blankLine, // Can’t be empty when interrupting.\n      self.interrupt ? nok : onBlank,\n      effects.attempt(\n        listItemPrefixWhitespaceConstruct,\n        endOfPrefix,\n        otherPrefix\n      )\n    )\n  }\n  /** @type {State} */\n\n  function onBlank(code) {\n    self.containerState.initialBlankLine = true\n    initialSize++\n    return endOfPrefix(code)\n  }\n  /** @type {State} */\n\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\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function endOfPrefix(code) {\n    self.containerState.size =\n      initialSize +\n      self.sliceSerialize(effects.exit('listItemPrefix'), true).length\n    return ok(code)\n  }\n}\n/**\n * @type {Tokenizer}\n * @this {TokenizeContextWithState}\n */\n\nfunction tokenizeListContinuation(effects, ok, nok) {\n  const self = this\n  self.containerState._closeFlow = undefined\n  return effects.check(blankLine, onBlank, notBlank)\n  /** @type {State} */\n\n  function onBlank(code) {\n    self.containerState.furtherBlankLines =\n      self.containerState.furtherBlankLines ||\n      self.containerState.initialBlankLine // We have a blank line.\n    // Still, try to consume at most the items size.\n\n    return factorySpace(\n      effects,\n      ok,\n      'listItemIndent',\n      self.containerState.size + 1\n    )(code)\n  }\n  /** @type {State} */\n\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\n    self.containerState.furtherBlankLines = undefined\n    self.containerState.initialBlankLine = undefined\n    return effects.attempt(indentConstruct, ok, notInCurrentItem)(code)\n  }\n  /** @type {State} */\n\n  function notInCurrentItem(code) {\n    // While we do continue, we signal that the flow should be closed.\n    self.containerState._closeFlow = true // As we’re closing flow, we’re no longer interrupting.\n\n    self.interrupt = undefined\n    return factorySpace(\n      effects,\n      effects.attempt(list, ok, nok),\n      'linePrefix',\n      self.parser.constructs.disable.null.includes('codeIndented')\n        ? undefined\n        : 4\n    )(code)\n  }\n}\n/**\n * @type {Tokenizer}\n * @this {TokenizeContextWithState}\n */\n\nfunction tokenizeIndent(effects, ok, nok) {\n  const self = this\n  return factorySpace(\n    effects,\n    afterPrefix,\n    'listItemIndent',\n    self.containerState.size + 1\n  )\n  /** @type {State} */\n\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return tail &&\n      tail[1].type === 'listItemIndent' &&\n      tail[2].sliceSerialize(tail[1], true).length === self.containerState.size\n      ? ok(code)\n      : nok(code)\n  }\n}\n/**\n * @type {Exiter}\n * @this {TokenizeContextWithState}\n */\n\nfunction tokenizeListEnd(effects) {\n  effects.exit(this.containerState.type)\n}\n/**\n * @type {Tokenizer}\n * @this {TokenizeContextWithState}\n */\n\nfunction tokenizeListItemPrefixWhitespace(effects, ok, nok) {\n  const self = this\n  return factorySpace(\n    effects,\n    afterPrefix,\n    'listItemPrefixWhitespace',\n    self.parser.constructs.disable.null.includes('codeIndented')\n      ? undefined\n      : 4 + 1\n  )\n  /** @type {State} */\n\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return !markdownSpace(code) &&\n      tail &&\n      tail[1].type === 'listItemPrefixWhitespace'\n      ? ok(code)\n      : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Exiter} Exiter\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownSpace} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const blockQuote = {\n  name: 'blockQuote',\n  tokenize: tokenizeBlockQuoteStart,\n  continuation: {\n    tokenize: tokenizeBlockQuoteContinuation\n  },\n  exit\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeBlockQuoteStart(effects, ok, nok) {\n  const self = this\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    if (code === 62) {\n      const state = self.containerState\n\n      if (!state.open) {\n        effects.enter('blockQuote', {\n          _container: true\n        })\n        state.open = true\n      }\n\n      effects.enter('blockQuotePrefix')\n      effects.enter('blockQuoteMarker')\n      effects.consume(code)\n      effects.exit('blockQuoteMarker')\n      return after\n    }\n\n    return nok(code)\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\n    effects.exit('blockQuotePrefix')\n    return ok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeBlockQuoteContinuation(effects, ok, nok) {\n  return factorySpace(\n    effects,\n    effects.attempt(blockQuote, ok, nok),\n    'linePrefix',\n    this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4\n  )\n}\n/** @type {Exiter} */\n\nfunction exit(effects) {\n  effects.exit('blockQuote')\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n */\nimport {\n  asciiControl,\n  markdownLineEndingOrSpace,\n  markdownLineEnding\n} from 'micromark-util-character'\n\n/**\n * @param {Effects} effects\n * @param {State} ok\n * @param {State} nok\n * @param {string} type\n * @param {string} literalType\n * @param {string} literalMarkerType\n * @param {string} rawType\n * @param {string} stringType\n * @param {number} [max=Infinity]\n * @returns {State}\n */\n// eslint-disable-next-line max-params\nexport function factoryDestination(\n  effects,\n  ok,\n  nok,\n  type,\n  literalType,\n  literalMarkerType,\n  rawType,\n  stringType,\n  max\n) {\n  const limit = max || Number.POSITIVE_INFINITY\n  let balance = 0\n  return start\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 destinationEnclosedBefore\n    }\n\n    if (code === null || code === 41 || asciiControl(code)) {\n      return nok(code)\n    }\n\n    effects.enter(type)\n    effects.enter(rawType)\n    effects.enter(stringType)\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return destinationRaw(code)\n  }\n  /** @type {State} */\n\n  function destinationEnclosedBefore(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\n    effects.enter(stringType)\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return destinationEnclosed(code)\n  }\n  /** @type {State} */\n\n  function destinationEnclosed(code) {\n    if (code === 62) {\n      effects.exit('chunkString')\n      effects.exit(stringType)\n      return destinationEnclosedBefore(code)\n    }\n\n    if (code === null || code === 60 || markdownLineEnding(code)) {\n      return nok(code)\n    }\n\n    effects.consume(code)\n    return code === 92 ? destinationEnclosedEscape : destinationEnclosed\n  }\n  /** @type {State} */\n\n  function destinationEnclosedEscape(code) {\n    if (code === 60 || code === 62 || code === 92) {\n      effects.consume(code)\n      return destinationEnclosed\n    }\n\n    return destinationEnclosed(code)\n  }\n  /** @type {State} */\n\n  function destinationRaw(code) {\n    if (code === 40) {\n      if (++balance > limit) return nok(code)\n      effects.consume(code)\n      return destinationRaw\n    }\n\n    if (code === 41) {\n      if (!balance--) {\n        effects.exit('chunkString')\n        effects.exit(stringType)\n        effects.exit(rawType)\n        effects.exit(type)\n        return ok(code)\n      }\n\n      effects.consume(code)\n      return destinationRaw\n    }\n\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      if (balance) return nok(code)\n      effects.exit('chunkString')\n      effects.exit(stringType)\n      effects.exit(rawType)\n      effects.exit(type)\n      return ok(code)\n    }\n\n    if (asciiControl(code)) return nok(code)\n    effects.consume(code)\n    return code === 92 ? destinationRawEscape : destinationRaw\n  }\n  /** @type {State} */\n\n  function destinationRawEscape(code) {\n    if (code === 40 || code === 41 || code === 92) {\n      effects.consume(code)\n      return destinationRaw\n    }\n\n    return destinationRaw(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').State} State\n */\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n\n/**\n * @this {TokenizeContext}\n * @param {Effects} effects\n * @param {State} ok\n * @param {State} nok\n * @param {string} type\n * @param {string} markerType\n * @param {string} stringType\n * @returns {State}\n */\n// eslint-disable-next-line max-params\nexport function factoryLabel(effects, ok, nok, type, markerType, stringType) {\n  const self = this\n  let size = 0\n  /** @type {boolean} */\n\n  let data\n  return start\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  /** @type {State} */\n\n  function atBreak(code) {\n    if (\n      code === null ||\n      code === 91 ||\n      (code === 93 && !data) ||\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\n      /* Hidden footnotes hook */\n\n      /* c8 ignore next 3 */\n      (code === 94 &&\n        !size &&\n        '_hiddenFootnoteSupport' in self.parser.constructs) ||\n      size > 999\n    ) {\n      return nok(code)\n    }\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    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return atBreak\n    }\n\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return label(code)\n  }\n  /** @type {State} */\n\n  function label(code) {\n    if (\n      code === null ||\n      code === 91 ||\n      code === 93 ||\n      markdownLineEnding(code) ||\n      size++ > 999\n    ) {\n      effects.exit('chunkString')\n      return atBreak(code)\n    }\n\n    effects.consume(code)\n    data = data || !markdownSpace(code)\n    return code === 92 ? labelEscape : label\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 label\n    }\n\n    return label(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/**\n * @param {Effects} effects\n * @param {State} ok\n * @param {State} nok\n * @param {string} type\n * @param {string} markerType\n * @param {string} stringType\n * @returns {State}\n */\n// eslint-disable-next-line max-params\nexport function factoryTitle(effects, ok, nok, type, markerType, stringType) {\n  /** @type {NonNullable<Code>} */\n  let marker\n  return start\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    marker = code === 40 ? 41 : code\n    return atFirstTitleBreak\n  }\n  /** @type {State} */\n\n  function atFirstTitleBreak(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\n    effects.enter(stringType)\n    return atTitleBreak(code)\n  }\n  /** @type {State} */\n\n  function atTitleBreak(code) {\n    if (code === marker) {\n      effects.exit(stringType)\n      return atFirstTitleBreak(marker)\n    }\n\n    if (code === null) {\n      return nok(code)\n    } // Note: blank lines can’t exist in content.\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return factorySpace(effects, atTitleBreak, 'linePrefix')\n    }\n\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return title(code)\n  }\n  /** @type {State} */\n\n  function title(code) {\n    if (code === marker || code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString')\n      return atTitleBreak(code)\n    }\n\n    effects.consume(code)\n    return code === 92 ? titleEscape : title\n  }\n  /** @type {State} */\n\n  function titleEscape(code) {\n    if (code === marker || code === 92) {\n      effects.consume(code)\n      return title\n    }\n\n    return title(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n\n/**\n * @param {Effects} effects\n * @param {State} ok\n */\nexport function factoryWhitespace(effects, ok) {\n  /** @type {boolean} */\n  let seen\n  return start\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      seen = true\n      return start\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(\n        effects,\n        start,\n        seen ? 'linePrefix' : 'lineSuffix'\n      )(code)\n    }\n\n    return ok(code)\n  }\n}\n","/**\n * Normalize an identifier (such as used in definitions).\n *\n * @param {string} value\n * @returns {string}\n */\nexport function normalizeIdentifier(value) {\n  return (\n    value // Collapse Markdown whitespace.\n      .replace(/[\\t\\n\\r ]+/g, ' ') // Trim.\n      .replace(/^ | $/g, '') // 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()\n      .toUpperCase()\n  )\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\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 {normalizeIdentifier} from 'micromark-util-normalize-identifier'\nimport {\n  markdownLineEnding,\n  markdownLineEndingOrSpace\n} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const definition = {\n  name: 'definition',\n  tokenize: tokenizeDefinition\n}\n/** @type {Construct} */\n\nconst titleConstruct = {\n  tokenize: tokenizeTitle,\n  partial: true\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeDefinition(effects, ok, nok) {\n  const self = this\n  /** @type {string} */\n\n  let identifier\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('definition')\n    return factoryLabel.call(\n      self,\n      effects,\n      labelAfter,\n      nok,\n      'definitionLabel',\n      'definitionLabelMarker',\n      'definitionLabelString'\n    )(code)\n  }\n  /** @type {State} */\n\n  function labelAfter(code) {\n    identifier = normalizeIdentifier(\n      self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)\n    )\n\n    if (code === 58) {\n      effects.enter('definitionMarker')\n      effects.consume(code)\n      effects.exit('definitionMarker') // Note: blank lines can’t exist in content.\n\n      return factoryWhitespace(\n        effects,\n        factoryDestination(\n          effects,\n          effects.attempt(\n            titleConstruct,\n            factorySpace(effects, after, 'whitespace'),\n            factorySpace(effects, after, 'whitespace')\n          ),\n          nok,\n          'definitionDestination',\n          'definitionDestinationLiteral',\n          'definitionDestinationLiteralMarker',\n          'definitionDestinationRaw',\n          'definitionDestinationString'\n        )\n      )\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function after(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('definition')\n\n      if (!self.parser.defined.includes(identifier)) {\n        self.parser.defined.push(identifier)\n      }\n\n      return ok(code)\n    }\n\n    return nok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeTitle(effects, ok, nok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    return markdownLineEndingOrSpace(code)\n      ? factoryWhitespace(effects, before)(code)\n      : nok(code)\n  }\n  /** @type {State} */\n\n  function before(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(\n        effects,\n        factorySpace(effects, after, 'whitespace'),\n        nok,\n        'definitionTitle',\n        'definitionTitleMarker',\n        'definitionTitleString'\n      )(code)\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function after(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const codeIndented = {\n  name: 'codeIndented',\n  tokenize: tokenizeCodeIndented\n}\n/** @type {Construct} */\n\nconst indentedContent = {\n  tokenize: tokenizeIndentedContent,\n  partial: true\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeCodeIndented(effects, ok, nok) {\n  const self = this\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('codeIndented')\n    return factorySpace(effects, afterStartPrefix, 'linePrefix', 4 + 1)(code)\n  }\n  /** @type {State} */\n\n  function afterStartPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return tail &&\n      tail[1].type === 'linePrefix' &&\n      tail[2].sliceSerialize(tail[1], true).length >= 4\n      ? afterPrefix(code)\n      : nok(code)\n  }\n  /** @type {State} */\n\n  function afterPrefix(code) {\n    if (code === null) {\n      return after(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.attempt(indentedContent, afterPrefix, after)(code)\n    }\n\n    effects.enter('codeFlowValue')\n    return content(code)\n  }\n  /** @type {State} */\n\n  function content(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue')\n      return afterPrefix(code)\n    }\n\n    effects.consume(code)\n    return content\n  }\n  /** @type {State} */\n\n  function after(code) {\n    effects.exit('codeIndented')\n    return ok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeIndentedContent(effects, ok, nok) {\n  const self = this\n  return start\n  /** @type {State} */\n\n  function start(code) {\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\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return start\n    }\n\n    return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1)(code)\n  }\n  /** @type {State} */\n\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return tail &&\n      tail[1].type === 'linePrefix' &&\n      tail[2].sliceSerialize(tail[1], true).length >= 4\n      ? ok(code)\n      : markdownLineEnding(code)\n      ? start(code)\n      : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {\n  markdownLineEnding,\n  markdownLineEndingOrSpace,\n  markdownSpace\n} from 'micromark-util-character'\nimport {splice} from 'micromark-util-chunked'\n\n/** @type {Construct} */\nexport const headingAtx = {\n  name: 'headingAtx',\n  tokenize: tokenizeHeadingAtx,\n  resolve: resolveHeadingAtx\n}\n/** @type {Resolver} */\n\nfunction resolveHeadingAtx(events, context) {\n  let contentEnd = events.length - 2\n  let contentStart = 3\n  /** @type {Token} */\n\n  let content\n  /** @type {Token} */\n\n  let text // Prefix whitespace, part of the opening.\n\n  if (events[contentStart][1].type === 'whitespace') {\n    contentStart += 2\n  } // Suffix whitespace, part of the closing.\n\n  if (\n    contentEnd - 2 > contentStart &&\n    events[contentEnd][1].type === 'whitespace'\n  ) {\n    contentEnd -= 2\n  }\n\n  if (\n    events[contentEnd][1].type === 'atxHeadingSequence' &&\n    (contentStart === contentEnd - 1 ||\n      (contentEnd - 4 > contentStart &&\n        events[contentEnd - 2][1].type === 'whitespace'))\n  ) {\n    contentEnd -= contentStart + 1 === contentEnd ? 2 : 4\n  }\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      // @ts-expect-error Constants are fine to assign.\n      contentType: 'text'\n    }\n    splice(events, contentStart, contentEnd - contentStart + 1, [\n      ['enter', content, context],\n      ['enter', text, context],\n      ['exit', text, context],\n      ['exit', content, context]\n    ])\n  }\n\n  return events\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeHeadingAtx(effects, ok, nok) {\n  const self = this\n  let size = 0\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('atxHeading')\n    effects.enter('atxHeadingSequence')\n    return fenceOpenInside(code)\n  }\n  /** @type {State} */\n\n  function fenceOpenInside(code) {\n    if (code === 35 && size++ < 6) {\n      effects.consume(code)\n      return fenceOpenInside\n    }\n\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingSequence')\n      return self.interrupt ? ok(code) : headingBreak(code)\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function headingBreak(code) {\n    if (code === 35) {\n      effects.enter('atxHeadingSequence')\n      return sequence(code)\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('atxHeading')\n      return ok(code)\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(effects, headingBreak, 'whitespace')(code)\n    }\n\n    effects.enter('atxHeadingText')\n    return data(code)\n  }\n  /** @type {State} */\n\n  function sequence(code) {\n    if (code === 35) {\n      effects.consume(code)\n      return sequence\n    }\n\n    effects.exit('atxHeadingSequence')\n    return headingBreak(code)\n  }\n  /** @type {State} */\n\n  function data(code) {\n    if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingText')\n      return headingBreak(code)\n    }\n\n    effects.consume(code)\n    return data\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const setextUnderline = {\n  name: 'setextUnderline',\n  tokenize: tokenizeSetextUnderline,\n  resolveTo: resolveToSetextUnderline\n}\n/** @type {Resolver} */\n\nfunction resolveToSetextUnderline(events, context) {\n  let index = events.length\n  /** @type {number|undefined} */\n\n  let content\n  /** @type {number|undefined} */\n\n  let text\n  /** @type {number|undefined} */\n\n  let definition // Find the opening of the content.\n  // It’ll always exist: we don’t tokenize if it isn’t there.\n\n  while (index--) {\n    if (events[index][0] === 'enter') {\n      if (events[index][1].type === 'content') {\n        content = index\n        break\n      }\n\n      if (events[index][1].type === 'paragraph') {\n        text = index\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\n      if (!definition && events[index][1].type === 'definition') {\n        definition = index\n      }\n    }\n  }\n\n  const heading = {\n    type: 'setextHeading',\n    start: Object.assign({}, events[text][1].start),\n    end: Object.assign({}, events[events.length - 1][1].end)\n  } // Change the paragraph to setext heading text.\n\n  events[text][1].type = 'setextHeadingText' // If we have definitions in the content, we’ll keep on having content,\n  // but we need move it.\n\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 = Object.assign({}, events[definition][1].end)\n  } else {\n    events[content][1] = heading\n  } // Add the heading exit at the end.\n\n  events.push(['exit', heading, context])\n  return events\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeSetextUnderline(effects, ok, nok) {\n  const self = this\n  let index = self.events.length\n  /** @type {NonNullable<Code>} */\n\n  let marker\n  /** @type {boolean} */\n\n  let paragraph // Find an opening.\n\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 (\n      self.events[index][1].type !== 'lineEnding' &&\n      self.events[index][1].type !== 'linePrefix' &&\n      self.events[index][1].type !== 'content'\n    ) {\n      paragraph = self.events[index][1].type === 'paragraph'\n      break\n    }\n  }\n\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    if (!self.parser.lazy[self.now().line] && (self.interrupt || paragraph)) {\n      effects.enter('setextHeadingLine')\n      effects.enter('setextHeadingLineSequence')\n      marker = code\n      return closingSequence(code)\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function closingSequence(code) {\n    if (code === marker) {\n      effects.consume(code)\n      return closingSequence\n    }\n\n    effects.exit('setextHeadingLineSequence')\n    return factorySpace(effects, closingSequenceEnd, 'lineSuffix')(code)\n  }\n  /** @type {State} */\n\n  function closingSequenceEnd(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('setextHeadingLine')\n      return ok(code)\n    }\n\n    return nok(code)\n  }\n}\n","/**\n * List of lowercase HTML tag names which when parsing HTML (flow), result\n * in more relaxed rules (condition 6): because they are known blocks, the\n * HTML-like syntax doesn’t have to be 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 */\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  '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 tag names which when parsing HTML (flow), result in\n * HTML that can include lines w/o exiting, until a closing tag also in this\n * list is found (condition 1).\n *\n * This module is copied from:\n * <https://spec.commonmark.org/0.30/#html-blocks>.\n *\n * Note that `textarea` was added in `CommonMark@0.30`.\n */\nexport const htmlRawNames = ['pre', 'script', 'style', 'textarea']\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {\n  asciiAlpha,\n  asciiAlphanumeric,\n  markdownLineEnding,\n  markdownLineEndingOrSpace,\n  markdownSpace\n} from 'micromark-util-character'\nimport {htmlBlockNames, htmlRawNames} from 'micromark-util-html-tag-name'\nimport {blankLine} from './blank-line.js'\n/** @type {Construct} */\n\nexport const htmlFlow = {\n  name: 'htmlFlow',\n  tokenize: tokenizeHtmlFlow,\n  resolveTo: resolveToHtmlFlow,\n  concrete: true\n}\n/** @type {Construct} */\n\nconst nextBlankConstruct = {\n  tokenize: tokenizeNextBlank,\n  partial: true\n}\n/** @type {Resolver} */\n\nfunction resolveToHtmlFlow(events) {\n  let index = events.length\n\n  while (index--) {\n    if (events[index][0] === 'enter' && events[index][1].type === 'htmlFlow') {\n      break\n    }\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 // Add the prefix start to the HTML line token.\n\n    events[index + 1][1].start = events[index - 2][1].start // Remove the line prefix.\n\n    events.splice(index - 2, 2)\n  }\n\n  return events\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeHtmlFlow(effects, ok, nok) {\n  const self = this\n  /** @type {number} */\n\n  let kind\n  /** @type {boolean} */\n\n  let startTag\n  /** @type {string} */\n\n  let buffer\n  /** @type {number} */\n\n  let index\n  /** @type {Code} */\n\n  let marker\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('htmlFlow')\n    effects.enter('htmlFlowData')\n    effects.consume(code)\n    return open\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code)\n      return declarationStart\n    }\n\n    if (code === 47) {\n      effects.consume(code)\n      return tagCloseStart\n    }\n\n    if (code === 63) {\n      effects.consume(code)\n      kind = 3 // 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\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      buffer = String.fromCharCode(code)\n      startTag = true\n      return tagName\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function declarationStart(code) {\n    if (code === 45) {\n      effects.consume(code)\n      kind = 2\n      return commentOpenInside\n    }\n\n    if (code === 91) {\n      effects.consume(code)\n      kind = 5\n      buffer = 'CDATA['\n      index = 0\n      return cdataOpenInside\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      kind = 4\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function cdataOpenInside(code) {\n    if (code === buffer.charCodeAt(index++)) {\n      effects.consume(code)\n      return index === buffer.length\n        ? self.interrupt\n          ? ok\n          : continuation\n        : cdataOpenInside\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      buffer = String.fromCharCode(code)\n      return tagName\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function tagName(code) {\n    if (\n      code === null ||\n      code === 47 ||\n      code === 62 ||\n      markdownLineEndingOrSpace(code)\n    ) {\n      if (\n        code !== 47 &&\n        startTag &&\n        htmlRawNames.includes(buffer.toLowerCase())\n      ) {\n        kind = 1\n        return self.interrupt ? ok(code) : continuation(code)\n      }\n\n      if (htmlBlockNames.includes(buffer.toLowerCase())) {\n        kind = 6\n\n        if (code === 47) {\n          effects.consume(code)\n          return basicSelfClosing\n        }\n\n        return self.interrupt ? ok(code) : continuation(code)\n      }\n\n      kind = 7 // Do not support complete HTML when interrupting\n\n      return self.interrupt && !self.parser.lazy[self.now().line]\n        ? nok(code)\n        : startTag\n        ? completeAttributeNameBefore(code)\n        : completeClosingTagAfter(code)\n    }\n\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code)\n      buffer += String.fromCharCode(code)\n      return tagName\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function basicSelfClosing(code) {\n    if (code === 62) {\n      effects.consume(code)\n      return self.interrupt ? ok : continuation\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function completeClosingTagAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeClosingTagAfter\n    }\n\n    return completeEnd(code)\n  }\n  /** @type {State} */\n\n  function completeAttributeNameBefore(code) {\n    if (code === 47) {\n      effects.consume(code)\n      return completeEnd\n    }\n\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code)\n      return completeAttributeName\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAttributeNameBefore\n    }\n\n    return completeEnd(code)\n  }\n  /** @type {State} */\n\n  function completeAttributeName(code) {\n    if (\n      code === 45 ||\n      code === 46 ||\n      code === 58 ||\n      code === 95 ||\n      asciiAlphanumeric(code)\n    ) {\n      effects.consume(code)\n      return completeAttributeName\n    }\n\n    return completeAttributeNameAfter(code)\n  }\n  /** @type {State} */\n\n  function completeAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code)\n      return completeAttributeValueBefore\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAttributeNameAfter\n    }\n\n    return completeAttributeNameBefore(code)\n  }\n  /** @type {State} */\n\n  function completeAttributeValueBefore(code) {\n    if (\n      code === null ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96\n    ) {\n      return nok(code)\n    }\n\n    if (code === 34 || code === 39) {\n      effects.consume(code)\n      marker = code\n      return completeAttributeValueQuoted\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAttributeValueBefore\n    }\n\n    marker = null\n    return completeAttributeValueUnquoted(code)\n  }\n  /** @type {State} */\n\n  function completeAttributeValueQuoted(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code)\n    }\n\n    if (code === marker) {\n      effects.consume(code)\n      return completeAttributeValueQuotedAfter\n    }\n\n    effects.consume(code)\n    return completeAttributeValueQuoted\n  }\n  /** @type {State} */\n\n  function completeAttributeValueUnquoted(code) {\n    if (\n      code === null ||\n      code === 34 ||\n      code === 39 ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96 ||\n      markdownLineEndingOrSpace(code)\n    ) {\n      return completeAttributeNameAfter(code)\n    }\n\n    effects.consume(code)\n    return completeAttributeValueUnquoted\n  }\n  /** @type {State} */\n\n  function completeAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownSpace(code)) {\n      return completeAttributeNameBefore(code)\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function completeEnd(code) {\n    if (code === 62) {\n      effects.consume(code)\n      return completeAfter\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function completeAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAfter\n    }\n\n    return code === null || markdownLineEnding(code)\n      ? continuation(code)\n      : nok(code)\n  }\n  /** @type {State} */\n\n  function continuation(code) {\n    if (code === 45 && kind === 2) {\n      effects.consume(code)\n      return continuationCommentInside\n    }\n\n    if (code === 60 && kind === 1) {\n      effects.consume(code)\n      return continuationRawTagOpen\n    }\n\n    if (code === 62 && kind === 4) {\n      effects.consume(code)\n      return continuationClose\n    }\n\n    if (code === 63 && kind === 3) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n\n    if (code === 93 && kind === 5) {\n      effects.consume(code)\n      return continuationCharacterDataInside\n    }\n\n    if (markdownLineEnding(code) && (kind === 6 || kind === 7)) {\n      return effects.check(\n        nextBlankConstruct,\n        continuationClose,\n        continuationAtLineEnding\n      )(code)\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      return continuationAtLineEnding(code)\n    }\n\n    effects.consume(code)\n    return continuation\n  }\n  /** @type {State} */\n\n  function continuationAtLineEnding(code) {\n    effects.exit('htmlFlowData')\n    return htmlContinueStart(code)\n  }\n  /** @type {State} */\n\n  function htmlContinueStart(code) {\n    if (code === null) {\n      return done(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.attempt(\n        {\n          tokenize: htmlLineEnd,\n          partial: true\n        },\n        htmlContinueStart,\n        done\n      )(code)\n    }\n\n    effects.enter('htmlFlowData')\n    return continuation(code)\n  }\n  /** @type {Tokenizer} */\n\n  function htmlLineEnd(effects, ok, nok) {\n    return start\n    /** @type {State} */\n\n    function start(code) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return lineStart\n    }\n    /** @type {State} */\n\n    function lineStart(code) {\n      return self.parser.lazy[self.now().line] ? nok(code) : ok(code)\n    }\n  }\n  /** @type {State} */\n\n  function continuationCommentInside(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n\n    return continuation(code)\n  }\n  /** @type {State} */\n\n  function continuationRawTagOpen(code) {\n    if (code === 47) {\n      effects.consume(code)\n      buffer = ''\n      return continuationRawEndTag\n    }\n\n    return continuation(code)\n  }\n  /** @type {State} */\n\n  function continuationRawEndTag(code) {\n    if (code === 62 && htmlRawNames.includes(buffer.toLowerCase())) {\n      effects.consume(code)\n      return continuationClose\n    }\n\n    if (asciiAlpha(code) && buffer.length < 8) {\n      effects.consume(code)\n      buffer += String.fromCharCode(code)\n      return continuationRawEndTag\n    }\n\n    return continuation(code)\n  }\n  /** @type {State} */\n\n  function continuationCharacterDataInside(code) {\n    if (code === 93) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n\n    return continuation(code)\n  }\n  /** @type {State} */\n\n  function continuationDeclarationInside(code) {\n    if (code === 62) {\n      effects.consume(code)\n      return continuationClose\n    } // More dashes.\n\n    if (code === 45 && kind === 2) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n\n    return continuation(code)\n  }\n  /** @type {State} */\n\n  function continuationClose(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('htmlFlowData')\n      return done(code)\n    }\n\n    effects.consume(code)\n    return continuationClose\n  }\n  /** @type {State} */\n\n  function done(code) {\n    effects.exit('htmlFlow')\n    return ok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeNextBlank(effects, ok, nok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.exit('htmlFlowData')\n    effects.enter('lineEndingBlank')\n    effects.consume(code)\n    effects.exit('lineEndingBlank')\n    return effects.attempt(blankLine, ok, nok)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {\n  markdownLineEnding,\n  markdownLineEndingOrSpace\n} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const codeFenced = {\n  name: 'codeFenced',\n  tokenize: tokenizeCodeFenced,\n  concrete: true\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeCodeFenced(effects, ok, nok) {\n  const self = this\n  /** @type {Construct} */\n\n  const closingFenceConstruct = {\n    tokenize: tokenizeClosingFence,\n    partial: true\n  }\n  /** @type {Construct} */\n\n  const nonLazyLine = {\n    tokenize: tokenizeNonLazyLine,\n    partial: true\n  }\n  const tail = this.events[this.events.length - 1]\n  const initialPrefix =\n    tail && tail[1].type === 'linePrefix'\n      ? tail[2].sliceSerialize(tail[1], true).length\n      : 0\n  let sizeOpen = 0\n  /** @type {NonNullable<Code>} */\n\n  let marker\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('codeFenced')\n    effects.enter('codeFencedFence')\n    effects.enter('codeFencedFenceSequence')\n    marker = code\n    return sequenceOpen(code)\n  }\n  /** @type {State} */\n\n  function sequenceOpen(code) {\n    if (code === marker) {\n      effects.consume(code)\n      sizeOpen++\n      return sequenceOpen\n    }\n\n    effects.exit('codeFencedFenceSequence')\n    return sizeOpen < 3\n      ? nok(code)\n      : factorySpace(effects, infoOpen, 'whitespace')(code)\n  }\n  /** @type {State} */\n\n  function infoOpen(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return openAfter(code)\n    }\n\n    effects.enter('codeFencedFenceInfo')\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return info(code)\n  }\n  /** @type {State} */\n\n  function info(code) {\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit('chunkString')\n      effects.exit('codeFencedFenceInfo')\n      return factorySpace(effects, infoAfter, 'whitespace')(code)\n    }\n\n    if (code === 96 && code === marker) return nok(code)\n    effects.consume(code)\n    return info\n  }\n  /** @type {State} */\n\n  function infoAfter(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return openAfter(code)\n    }\n\n    effects.enter('codeFencedFenceMeta')\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return meta(code)\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 openAfter(code)\n    }\n\n    if (code === 96 && code === marker) return nok(code)\n    effects.consume(code)\n    return meta\n  }\n  /** @type {State} */\n\n  function openAfter(code) {\n    effects.exit('codeFencedFence')\n    return self.interrupt ? ok(code) : contentStart(code)\n  }\n  /** @type {State} */\n\n  function contentStart(code) {\n    if (code === null) {\n      return after(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.attempt(\n        nonLazyLine,\n        effects.attempt(\n          closingFenceConstruct,\n          after,\n          initialPrefix\n            ? factorySpace(\n                effects,\n                contentStart,\n                'linePrefix',\n                initialPrefix + 1\n              )\n            : contentStart\n        ),\n        after\n      )(code)\n    }\n\n    effects.enter('codeFlowValue')\n    return contentContinue(code)\n  }\n  /** @type {State} */\n\n  function contentContinue(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue')\n      return contentStart(code)\n    }\n\n    effects.consume(code)\n    return contentContinue\n  }\n  /** @type {State} */\n\n  function after(code) {\n    effects.exit('codeFenced')\n    return ok(code)\n  }\n  /** @type {Tokenizer} */\n\n  function tokenizeNonLazyLine(effects, ok, nok) {\n    const self = this\n    return start\n    /** @type {State} */\n\n    function start(code) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return lineStart\n    }\n    /** @type {State} */\n\n    function lineStart(code) {\n      return self.parser.lazy[self.now().line] ? nok(code) : ok(code)\n    }\n  }\n  /** @type {Tokenizer} */\n\n  function tokenizeClosingFence(effects, ok, nok) {\n    let size = 0\n    return factorySpace(\n      effects,\n      closingSequenceStart,\n      'linePrefix',\n      this.parser.constructs.disable.null.includes('codeIndented')\n        ? undefined\n        : 4\n    )\n    /** @type {State} */\n\n    function closingSequenceStart(code) {\n      effects.enter('codeFencedFence')\n      effects.enter('codeFencedFenceSequence')\n      return closingSequence(code)\n    }\n    /** @type {State} */\n\n    function closingSequence(code) {\n      if (code === marker) {\n        effects.consume(code)\n        size++\n        return closingSequence\n      }\n\n      if (size < sizeOpen) return nok(code)\n      effects.exit('codeFencedFenceSequence')\n      return factorySpace(effects, closingSequenceEnd, 'whitespace')(code)\n    }\n    /** @type {State} */\n\n    function closingSequenceEnd(code) {\n      if (code === null || markdownLineEnding(code)) {\n        effects.exit('codeFencedFence')\n        return ok(code)\n      }\n\n      return nok(code)\n    }\n  }\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 * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {decodeNamedCharacterReference} from 'decode-named-character-reference'\nimport {\n  asciiAlphanumeric,\n  asciiDigit,\n  asciiHexDigit\n} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const characterReference = {\n  name: 'characterReference',\n  tokenize: tokenizeCharacterReference\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeCharacterReference(effects, ok, nok) {\n  const self = this\n  let size = 0\n  /** @type {number} */\n\n  let max\n  /** @type {(code: Code) => code is number} */\n\n  let test\n  return start\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  /** @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\n    effects.enter('characterReferenceValue')\n    max = 31\n    test = asciiAlphanumeric\n    return value(code)\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\n    effects.enter('characterReferenceValue')\n    max = 7\n    test = asciiDigit\n    return value(code)\n  }\n  /** @type {State} */\n\n  function value(code) {\n    /** @type {Token} */\n    let token\n\n    if (code === 59 && size) {\n      token = effects.exit('characterReferenceValue')\n\n      if (\n        test === asciiAlphanumeric &&\n        !decodeNamedCharacterReference(self.sliceSerialize(token))\n      ) {\n        return nok(code)\n      }\n\n      effects.enter('characterReferenceMarker')\n      effects.consume(code)\n      effects.exit('characterReferenceMarker')\n      effects.exit('characterReference')\n      return ok\n    }\n\n    if (test(code) && size++ < max) {\n      effects.consume(code)\n      return value\n    }\n\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {asciiPunctuation} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const characterEscape = {\n  name: 'characterEscape',\n  tokenize: tokenizeCharacterEscape\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeCharacterEscape(effects, ok, nok) {\n  return start\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 open\n  }\n  /** @type {State} */\n\n  function open(code) {\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\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const lineEnding = {\n  name: 'lineEnding',\n  tokenize: tokenizeLineEnding\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeLineEnding(effects, ok) {\n  return start\n  /** @type {State} */\n\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","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\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\n/** @type {Construct} */\nexport const labelEnd = {\n  name: 'labelEnd',\n  tokenize: tokenizeLabelEnd,\n  resolveTo: resolveToLabelEnd,\n  resolveAll: resolveAllLabelEnd\n}\n/** @type {Construct} */\n\nconst resourceConstruct = {\n  tokenize: tokenizeResource\n}\n/** @type {Construct} */\n\nconst fullReferenceConstruct = {\n  tokenize: tokenizeFullReference\n}\n/** @type {Construct} */\n\nconst collapsedReferenceConstruct = {\n  tokenize: tokenizeCollapsedReference\n}\n/** @type {Resolver} */\n\nfunction resolveAllLabelEnd(events) {\n  let index = -1\n  /** @type {Token} */\n\n  let token\n\n  while (++index < events.length) {\n    token = events[index][1]\n\n    if (\n      token.type === 'labelImage' ||\n      token.type === 'labelLink' ||\n      token.type === 'labelEnd'\n    ) {\n      // Remove the marker.\n      events.splice(index + 1, token.type === 'labelImage' ? 4 : 2)\n      token.type = 'data'\n      index++\n    }\n  }\n\n  return events\n}\n/** @type {Resolver} */\n\nfunction resolveToLabelEnd(events, context) {\n  let index = events.length\n  let offset = 0\n  /** @type {Token} */\n\n  let token\n  /** @type {number|undefined} */\n\n  let open\n  /** @type {number|undefined} */\n\n  let close\n  /** @type {Event[]} */\n\n  let media // Find an opening.\n\n  while (index--) {\n    token = events[index][1]\n\n    if (open) {\n      // If we see another link, or inactive link label, we’ve been here before.\n      if (\n        token.type === 'link' ||\n        (token.type === 'labelLink' && token._inactive)\n      ) {\n        break\n      } // Mark other link openings as inactive, as we can’t have links in\n      // links.\n\n      if (events[index][0] === 'enter' && token.type === 'labelLink') {\n        token._inactive = true\n      }\n    } else if (close) {\n      if (\n        events[index][0] === 'enter' &&\n        (token.type === 'labelImage' || token.type === 'labelLink') &&\n        !token._balanced\n      ) {\n        open = index\n\n        if (token.type !== 'labelLink') {\n          offset = 2\n          break\n        }\n      }\n    } else if (token.type === 'labelEnd') {\n      close = index\n    }\n  }\n\n  const group = {\n    type: events[open][1].type === 'labelLink' ? 'link' : 'image',\n    start: Object.assign({}, events[open][1].start),\n    end: Object.assign({}, events[events.length - 1][1].end)\n  }\n  const label = {\n    type: 'label',\n    start: Object.assign({}, events[open][1].start),\n    end: Object.assign({}, events[close][1].end)\n  }\n  const text = {\n    type: 'labelText',\n    start: Object.assign({}, events[open + offset + 2][1].end),\n    end: Object.assign({}, events[close - 2][1].start)\n  }\n  media = [\n    ['enter', group, context],\n    ['enter', label, context]\n  ] // Opening marker.\n\n  media = push(media, events.slice(open + 1, open + offset + 3)) // Text open.\n\n  media = push(media, [['enter', text, context]]) // Between.\n\n  media = push(\n    media,\n    resolveAll(\n      context.parser.constructs.insideSpan.null,\n      events.slice(open + offset + 4, close - 3),\n      context\n    )\n  ) // Text close, marker close, label close.\n\n  media = push(media, [\n    ['exit', text, context],\n    events[close - 2],\n    events[close - 1],\n    ['exit', label, context]\n  ]) // Reference, resource, or so.\n\n  media = push(media, events.slice(close + 1)) // Media close.\n\n  media = push(media, [['exit', group, context]])\n  splice(events, open, events.length, media)\n  return events\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeLabelEnd(effects, ok, nok) {\n  const self = this\n  let index = self.events.length\n  /** @type {Token} */\n\n  let labelStart\n  /** @type {boolean} */\n\n  let defined // Find an opening.\n\n  while (index--) {\n    if (\n      (self.events[index][1].type === 'labelImage' ||\n        self.events[index][1].type === 'labelLink') &&\n      !self.events[index][1]._balanced\n    ) {\n      labelStart = self.events[index][1]\n      break\n    }\n  }\n\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    if (!labelStart) {\n      return nok(code)\n    } // It’s a balanced bracket, but contains a link.\n\n    if (labelStart._inactive) return balanced(code)\n    defined = self.parser.defined.includes(\n      normalizeIdentifier(\n        self.sliceSerialize({\n          start: labelStart.end,\n          end: self.now()\n        })\n      )\n    )\n    effects.enter('labelEnd')\n    effects.enter('labelMarker')\n    effects.consume(code)\n    effects.exit('labelMarker')\n    effects.exit('labelEnd')\n    return afterLabelEnd\n  }\n  /** @type {State} */\n\n  function afterLabelEnd(code) {\n    // Resource: `[asd](fgh)`.\n    if (code === 40) {\n      return effects.attempt(\n        resourceConstruct,\n        ok,\n        defined ? ok : balanced\n      )(code)\n    } // Collapsed (`[asd][]`) or full (`[asd][fgh]`) reference?\n\n    if (code === 91) {\n      return effects.attempt(\n        fullReferenceConstruct,\n        ok,\n        defined\n          ? effects.attempt(collapsedReferenceConstruct, ok, balanced)\n          : balanced\n      )(code)\n    } // Shortcut reference: `[asd]`?\n\n    return defined ? ok(code) : balanced(code)\n  }\n  /** @type {State} */\n\n  function balanced(code) {\n    labelStart._balanced = true\n    return nok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeResource(effects, ok, nok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('resource')\n    effects.enter('resourceMarker')\n    effects.consume(code)\n    effects.exit('resourceMarker')\n    return factoryWhitespace(effects, open)\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (code === 41) {\n      return end(code)\n    }\n\n    return factoryDestination(\n      effects,\n      destinationAfter,\n      nok,\n      'resourceDestination',\n      'resourceDestinationLiteral',\n      'resourceDestinationLiteralMarker',\n      'resourceDestinationRaw',\n      'resourceDestinationString',\n      32\n    )(code)\n  }\n  /** @type {State} */\n\n  function destinationAfter(code) {\n    return markdownLineEndingOrSpace(code)\n      ? factoryWhitespace(effects, between)(code)\n      : end(code)\n  }\n  /** @type {State} */\n\n  function between(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(\n        effects,\n        factoryWhitespace(effects, end),\n        nok,\n        'resourceTitle',\n        'resourceTitleMarker',\n        'resourceTitleString'\n      )(code)\n    }\n\n    return end(code)\n  }\n  /** @type {State} */\n\n  function end(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\n    return nok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeFullReference(effects, ok, nok) {\n  const self = this\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    return factoryLabel.call(\n      self,\n      effects,\n      afterLabel,\n      nok,\n      'reference',\n      'referenceMarker',\n      'referenceString'\n    )(code)\n  }\n  /** @type {State} */\n\n  function afterLabel(code) {\n    return self.parser.defined.includes(\n      normalizeIdentifier(\n        self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)\n      )\n    )\n      ? ok(code)\n      : nok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeCollapsedReference(effects, ok, nok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('reference')\n    effects.enter('referenceMarker')\n    effects.consume(code)\n    effects.exit('referenceMarker')\n    return open\n  }\n  /** @type {State} */\n\n  function open(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\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {labelEnd} from './label-end.js'\n/** @type {Construct} */\n\nexport const labelStartImage = {\n  name: 'labelStartImage',\n  tokenize: tokenizeLabelStartImage,\n  resolveAll: labelEnd.resolveAll\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeLabelStartImage(effects, ok, nok) {\n  const self = this\n  return start\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  /** @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\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function after(code) {\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\n    /* Hidden footnotes hook */\n\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs\n      ? nok(code)\n      : ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {\n  markdownLineEndingOrSpace,\n  unicodePunctuation,\n  unicodeWhitespace\n} from 'micromark-util-character'\n\n/**\n * Classify whether a character code represents whitespace, punctuation, or\n * something 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 that eof (`null`) is seen as whitespace.\n *\n * @param {Code} code\n * @returns {number|undefined}\n */\nexport function classifyCharacter(code) {\n  if (\n    code === null ||\n    markdownLineEndingOrSpace(code) ||\n    unicodeWhitespace(code)\n  ) {\n    return 1\n  }\n\n  if (unicodePunctuation(code)) {\n    return 2\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Point} Point\n */\nimport {push, splice} from 'micromark-util-chunked'\nimport {classifyCharacter} from 'micromark-util-classify-character'\nimport {resolveAll} from 'micromark-util-resolve-all'\n\n/** @type {Construct} */\nexport const attention = {\n  name: 'attention',\n  tokenize: tokenizeAttention,\n  resolveAll: resolveAllAttention\n}\n/**\n * Take all events and resolve attention to emphasis or strong.\n *\n * @type {Resolver}\n */\n\nfunction resolveAllAttention(events, context) {\n  let index = -1\n  /** @type {number} */\n\n  let open\n  /** @type {Token} */\n\n  let group\n  /** @type {Token} */\n\n  let text\n  /** @type {Token} */\n\n  let openingSequence\n  /** @type {Token} */\n\n  let closingSequence\n  /** @type {number} */\n\n  let use\n  /** @type {Event[]} */\n\n  let nextEvents\n  /** @type {number} */\n\n  let offset // 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\n  while (++index < events.length) {\n    // Find a token that can close.\n    if (\n      events[index][0] === 'enter' &&\n      events[index][1].type === 'attentionSequence' &&\n      events[index][1]._close\n    ) {\n      open = index // Now walk back to find an opener.\n\n      while (open--) {\n        // Find a token that can open the closer.\n        if (\n          events[open][0] === 'exit' &&\n          events[open][1].type === 'attentionSequence' &&\n          events[open][1]._open && // If the markers are the same:\n          context.sliceSerialize(events[open][1]).charCodeAt(0) ===\n            context.sliceSerialize(events[index][1]).charCodeAt(0)\n        ) {\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 (\n            (events[open][1]._close || events[index][1]._open) &&\n            (events[index][1].end.offset - events[index][1].start.offset) % 3 &&\n            !(\n              (events[open][1].end.offset -\n                events[open][1].start.offset +\n                events[index][1].end.offset -\n                events[index][1].start.offset) %\n              3\n            )\n          ) {\n            continue\n          } // Number of markers to use from the sequence.\n\n          use =\n            events[open][1].end.offset - events[open][1].start.offset > 1 &&\n            events[index][1].end.offset - events[index][1].start.offset > 1\n              ? 2\n              : 1\n          const start = Object.assign({}, events[open][1].end)\n          const end = Object.assign({}, events[index][1].start)\n          movePoint(start, -use)\n          movePoint(end, use)\n          openingSequence = {\n            type: use > 1 ? 'strongSequence' : 'emphasisSequence',\n            start,\n            end: Object.assign({}, events[open][1].end)\n          }\n          closingSequence = {\n            type: use > 1 ? 'strongSequence' : 'emphasisSequence',\n            start: Object.assign({}, events[index][1].start),\n            end\n          }\n          text = {\n            type: use > 1 ? 'strongText' : 'emphasisText',\n            start: Object.assign({}, events[open][1].end),\n            end: Object.assign({}, events[index][1].start)\n          }\n          group = {\n            type: use > 1 ? 'strong' : 'emphasis',\n            start: Object.assign({}, openingSequence.start),\n            end: Object.assign({}, closingSequence.end)\n          }\n          events[open][1].end = Object.assign({}, openingSequence.start)\n          events[index][1].start = Object.assign({}, closingSequence.end)\n          nextEvents = [] // If there are more markers in the opening, add them before.\n\n          if (events[open][1].end.offset - events[open][1].start.offset) {\n            nextEvents = push(nextEvents, [\n              ['enter', events[open][1], context],\n              ['exit', events[open][1], context]\n            ])\n          } // Opening.\n\n          nextEvents = push(nextEvents, [\n            ['enter', group, context],\n            ['enter', openingSequence, context],\n            ['exit', openingSequence, context],\n            ['enter', text, context]\n          ]) // Between.\n\n          nextEvents = push(\n            nextEvents,\n            resolveAll(\n              context.parser.constructs.insideSpan.null,\n              events.slice(open + 1, index),\n              context\n            )\n          ) // Closing.\n\n          nextEvents = push(nextEvents, [\n            ['exit', text, context],\n            ['enter', closingSequence, context],\n            ['exit', closingSequence, context],\n            ['exit', group, context]\n          ]) // If there are more markers in the closing, add them after.\n\n          if (events[index][1].end.offset - events[index][1].start.offset) {\n            offset = 2\n            nextEvents = push(nextEvents, [\n              ['enter', events[index][1], context],\n              ['exit', events[index][1], context]\n            ])\n          } else {\n            offset = 0\n          }\n\n          splice(events, open - 1, index - open + 3, nextEvents)\n          index = open + nextEvents.length - offset - 2\n          break\n        }\n      }\n    }\n  } // Remove remaining sequences.\n\n  index = -1\n\n  while (++index < events.length) {\n    if (events[index][1].type === 'attentionSequence') {\n      events[index][1].type = 'data'\n    }\n  }\n\n  return events\n}\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  /** @type {NonNullable<Code>} */\n\n  let marker\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('attentionSequence')\n    marker = code\n    return sequence(code)\n  }\n  /** @type {State} */\n\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code)\n      return sequence\n    }\n\n    const token = effects.exit('attentionSequence')\n    const after = classifyCharacter(code)\n    const open =\n      !after || (after === 2 && before) || attentionMarkers.includes(code)\n    const close =\n      !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 * 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 * @param {number} offset\n * @returns {void}\n */\n\nfunction movePoint(point, offset) {\n  point.column += offset\n  point.offset += offset\n  point._bufferIndex += offset\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {\n  asciiAlpha,\n  asciiAlphanumeric,\n  asciiAtext,\n  asciiControl\n} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const autolink = {\n  name: 'autolink',\n  tokenize: tokenizeAutolink\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeAutolink(effects, ok, nok) {\n  let size = 1\n  return start\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  /** @type {State} */\n\n  function open(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return schemeOrEmailAtext\n    }\n\n    return asciiAtext(code) ? emailAtext(code) : nok(code)\n  }\n  /** @type {State} */\n\n  function schemeOrEmailAtext(code) {\n    return code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)\n      ? schemeInsideOrEmailAtext(code)\n      : emailAtext(code)\n  }\n  /** @type {State} */\n\n  function schemeInsideOrEmailAtext(code) {\n    if (code === 58) {\n      effects.consume(code)\n      return urlInside\n    }\n\n    if (\n      (code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) &&\n      size++ < 32\n    ) {\n      effects.consume(code)\n      return schemeInsideOrEmailAtext\n    }\n\n    return emailAtext(code)\n  }\n  /** @type {State} */\n\n  function urlInside(code) {\n    if (code === 62) {\n      effects.exit('autolinkProtocol')\n      return end(code)\n    }\n\n    if (code === null || code === 32 || code === 60 || asciiControl(code)) {\n      return nok(code)\n    }\n\n    effects.consume(code)\n    return urlInside\n  }\n  /** @type {State} */\n\n  function emailAtext(code) {\n    if (code === 64) {\n      effects.consume(code)\n      size = 0\n      return emailAtSignOrDot\n    }\n\n    if (asciiAtext(code)) {\n      effects.consume(code)\n      return emailAtext\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function emailAtSignOrDot(code) {\n    return asciiAlphanumeric(code) ? emailLabel(code) : nok(code)\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\n    if (code === 62) {\n      // Exit, then change the type.\n      effects.exit('autolinkProtocol').type = 'autolinkEmail'\n      return end(code)\n    }\n\n    return emailValue(code)\n  }\n  /** @type {State} */\n\n  function emailValue(code) {\n    if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) {\n      effects.consume(code)\n      return code === 45 ? emailValue : emailLabel\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function end(code) {\n    effects.enter('autolinkMarker')\n    effects.consume(code)\n    effects.exit('autolinkMarker')\n    effects.exit('autolink')\n    return ok\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {\n  asciiAlpha,\n  asciiAlphanumeric,\n  markdownLineEnding,\n  markdownLineEndingOrSpace,\n  markdownSpace\n} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const htmlText = {\n  name: 'htmlText',\n  tokenize: tokenizeHtmlText\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeHtmlText(effects, ok, nok) {\n  const self = this\n  /** @type {NonNullable<Code>|undefined} */\n\n  let marker\n  /** @type {string} */\n\n  let buffer\n  /** @type {number} */\n\n  let index\n  /** @type {State} */\n\n  let returnState\n  return start\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  /** @type {State} */\n\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code)\n      return declarationOpen\n    }\n\n    if (code === 47) {\n      effects.consume(code)\n      return tagCloseStart\n    }\n\n    if (code === 63) {\n      effects.consume(code)\n      return instruction\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return tagOpen\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return commentOpen\n    }\n\n    if (code === 91) {\n      effects.consume(code)\n      buffer = 'CDATA['\n      index = 0\n      return cdataOpen\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return declaration\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function commentOpen(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return commentStart\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function commentStart(code) {\n    if (code === null || code === 62) {\n      return nok(code)\n    }\n\n    if (code === 45) {\n      effects.consume(code)\n      return commentStartDash\n    }\n\n    return comment(code)\n  }\n  /** @type {State} */\n\n  function commentStartDash(code) {\n    if (code === null || code === 62) {\n      return nok(code)\n    }\n\n    return comment(code)\n  }\n  /** @type {State} */\n\n  function comment(code) {\n    if (code === null) {\n      return nok(code)\n    }\n\n    if (code === 45) {\n      effects.consume(code)\n      return commentClose\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = comment\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return comment\n  }\n  /** @type {State} */\n\n  function commentClose(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return end\n    }\n\n    return comment(code)\n  }\n  /** @type {State} */\n\n  function cdataOpen(code) {\n    if (code === buffer.charCodeAt(index++)) {\n      effects.consume(code)\n      return index === buffer.length ? cdata : cdataOpen\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function cdata(code) {\n    if (code === null) {\n      return nok(code)\n    }\n\n    if (code === 93) {\n      effects.consume(code)\n      return cdataClose\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = cdata\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return cdata\n  }\n  /** @type {State} */\n\n  function cdataClose(code) {\n    if (code === 93) {\n      effects.consume(code)\n      return cdataEnd\n    }\n\n    return cdata(code)\n  }\n  /** @type {State} */\n\n  function cdataEnd(code) {\n    if (code === 62) {\n      return end(code)\n    }\n\n    if (code === 93) {\n      effects.consume(code)\n      return cdataEnd\n    }\n\n    return cdata(code)\n  }\n  /** @type {State} */\n\n  function declaration(code) {\n    if (code === null || code === 62) {\n      return end(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = declaration\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return declaration\n  }\n  /** @type {State} */\n\n  function instruction(code) {\n    if (code === null) {\n      return nok(code)\n    }\n\n    if (code === 63) {\n      effects.consume(code)\n      return instructionClose\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = instruction\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return instruction\n  }\n  /** @type {State} */\n\n  function instructionClose(code) {\n    return code === 62 ? end(code) : instruction(code)\n  }\n  /** @type {State} */\n\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return tagClose\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function tagClose(code) {\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code)\n      return tagClose\n    }\n\n    return tagCloseBetween(code)\n  }\n  /** @type {State} */\n\n  function tagCloseBetween(code) {\n    if (markdownLineEnding(code)) {\n      returnState = tagCloseBetween\n      return atLineEnding(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagCloseBetween\n    }\n\n    return end(code)\n  }\n  /** @type {State} */\n\n  function tagOpen(code) {\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code)\n      return tagOpen\n    }\n\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code)\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function tagOpenBetween(code) {\n    if (code === 47) {\n      effects.consume(code)\n      return end\n    }\n\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code)\n      return tagOpenAttributeName\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenBetween\n      return atLineEnding(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagOpenBetween\n    }\n\n    return end(code)\n  }\n  /** @type {State} */\n\n  function tagOpenAttributeName(code) {\n    if (\n      code === 45 ||\n      code === 46 ||\n      code === 58 ||\n      code === 95 ||\n      asciiAlphanumeric(code)\n    ) {\n      effects.consume(code)\n      return tagOpenAttributeName\n    }\n\n    return tagOpenAttributeNameAfter(code)\n  }\n  /** @type {State} */\n\n  function tagOpenAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code)\n      return tagOpenAttributeValueBefore\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeNameAfter\n      return atLineEnding(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagOpenAttributeNameAfter\n    }\n\n    return tagOpenBetween(code)\n  }\n  /** @type {State} */\n\n  function tagOpenAttributeValueBefore(code) {\n    if (\n      code === null ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96\n    ) {\n      return nok(code)\n    }\n\n    if (code === 34 || code === 39) {\n      effects.consume(code)\n      marker = code\n      return tagOpenAttributeValueQuoted\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueBefore\n      return atLineEnding(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagOpenAttributeValueBefore\n    }\n\n    effects.consume(code)\n    marker = undefined\n    return tagOpenAttributeValueUnquoted\n  }\n  /** @type {State} */\n\n  function tagOpenAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code)\n      return tagOpenAttributeValueQuotedAfter\n    }\n\n    if (code === null) {\n      return nok(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueQuoted\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return tagOpenAttributeValueQuoted\n  }\n  /** @type {State} */\n\n  function tagOpenAttributeValueQuotedAfter(code) {\n    if (code === 62 || code === 47 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code)\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function tagOpenAttributeValueUnquoted(code) {\n    if (\n      code === null ||\n      code === 34 ||\n      code === 39 ||\n      code === 60 ||\n      code === 61 ||\n      code === 96\n    ) {\n      return nok(code)\n    }\n\n    if (code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code)\n    }\n\n    effects.consume(code)\n    return tagOpenAttributeValueUnquoted\n  } // We can’t have blank lines in content, so no need to worry about empty\n  // tokens.\n\n  /** @type {State} */\n\n  function atLineEnding(code) {\n    effects.exit('htmlTextData')\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(\n      effects,\n      afterPrefix,\n      'linePrefix',\n      self.parser.constructs.disable.null.includes('codeIndented')\n        ? undefined\n        : 4\n    )\n  }\n  /** @type {State} */\n\n  function afterPrefix(code) {\n    effects.enter('htmlTextData')\n    return returnState(code)\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\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {labelEnd} from './label-end.js'\n/** @type {Construct} */\n\nexport const labelStartLink = {\n  name: 'labelStartLink',\n  tokenize: tokenizeLabelStartLink,\n  resolveAll: labelEnd.resolveAll\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeLabelStartLink(effects, ok, nok) {\n  const self = this\n  return start\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  /** @type {State} */\n\n  function after(code) {\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\n    /* Hidden footnotes hook. */\n\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs\n      ? nok(code)\n      : ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const hardBreakEscape = {\n  name: 'hardBreakEscape',\n  tokenize: tokenizeHardBreakEscape\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeHardBreakEscape(effects, ok, nok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('hardBreakEscape')\n    effects.enter('escapeMarker')\n    effects.consume(code)\n    return open\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (markdownLineEnding(code)) {\n      effects.exit('escapeMarker')\n      effects.exit('hardBreakEscape')\n      return ok(code)\n    }\n\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Previous} Previous\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n */\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const codeText = {\n  name: 'codeText',\n  tokenize: tokenizeCodeText,\n  resolve: resolveCodeText,\n  previous\n}\n/** @type {Resolver} */\n\nfunction resolveCodeText(events) {\n  let tailExitIndex = events.length - 4\n  let headEnterIndex = 3\n  /** @type {number} */\n\n  let index\n  /** @type {number|undefined} */\n\n  let enter // If we start and end with an EOL or a space.\n\n  if (\n    (events[headEnterIndex][1].type === 'lineEnding' ||\n      events[headEnterIndex][1].type === 'space') &&\n    (events[tailExitIndex][1].type === 'lineEnding' ||\n      events[tailExitIndex][1].type === 'space')\n  ) {\n    index = headEnterIndex // And we have data.\n\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  } // Merge adjacent spaces and data.\n\n  index = headEnterIndex - 1\n  tailExitIndex++\n\n  while (++index <= tailExitIndex) {\n    if (enter === undefined) {\n      if (index !== tailExitIndex && events[index][1].type !== 'lineEnding') {\n        enter = index\n      }\n    } else if (\n      index === tailExitIndex ||\n      events[index][1].type === 'lineEnding'\n    ) {\n      events[enter][1].type = 'codeTextData'\n\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\n      enter = undefined\n    }\n  }\n\n  return events\n}\n/** @type {Previous} */\n\nfunction previous(code) {\n  // If there is a previous code, there will always be a tail.\n  return (\n    code !== 96 ||\n    this.events[this.events.length - 1][1].type === 'characterEscape'\n  )\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeCodeText(effects, ok, nok) {\n  const self = this\n  let sizeOpen = 0\n  /** @type {number} */\n\n  let size\n  /** @type {Token} */\n\n  let token\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('codeText')\n    effects.enter('codeTextSequence')\n    return openingSequence(code)\n  }\n  /** @type {State} */\n\n  function openingSequence(code) {\n    if (code === 96) {\n      effects.consume(code)\n      sizeOpen++\n      return openingSequence\n    }\n\n    effects.exit('codeTextSequence')\n    return gap(code)\n  }\n  /** @type {State} */\n\n  function gap(code) {\n    // EOF.\n    if (code === null) {\n      return nok(code)\n    } // Closing fence?\n    // Could also be data.\n\n    if (code === 96) {\n      token = effects.enter('codeTextSequence')\n      size = 0\n      return closingSequence(code)\n    } // Tabs don’t work, and virtual spaces don’t make sense.\n\n    if (code === 32) {\n      effects.enter('space')\n      effects.consume(code)\n      effects.exit('space')\n      return gap\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return gap\n    } // Data.\n\n    effects.enter('codeTextData')\n    return data(code)\n  } // In code.\n\n  /** @type {State} */\n\n  function data(code) {\n    if (\n      code === null ||\n      code === 32 ||\n      code === 96 ||\n      markdownLineEnding(code)\n    ) {\n      effects.exit('codeTextData')\n      return gap(code)\n    }\n\n    effects.consume(code)\n    return data\n  } // Closing fence.\n\n  /** @type {State} */\n\n  function closingSequence(code) {\n    // More.\n    if (code === 96) {\n      effects.consume(code)\n      size++\n      return closingSequence\n    } // Done!\n\n    if (size === sizeOpen) {\n      effects.exit('codeTextSequence')\n      effects.exit('codeText')\n      return ok(code)\n    } // More or less accents: mark as data.\n\n    token.type = 'codeTextData'\n    return data(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Extension} Extension\n */\nimport {\n  attention,\n  autolink,\n  blockQuote,\n  characterEscape,\n  characterReference,\n  codeFenced,\n  codeIndented,\n  codeText,\n  definition,\n  hardBreakEscape,\n  headingAtx,\n  htmlFlow,\n  htmlText,\n  labelEnd,\n  labelStartImage,\n  labelStartLink,\n  lineEnding,\n  list,\n  setextUnderline,\n  thematicBreak\n} from 'micromark-core-commonmark'\nimport {resolver as resolveText} from './initialize/text.js'\n/** @type {Extension['document']} */\n\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/** @type {Extension['contentInitial']} */\n\nexport const contentInitial = {\n  [91]: definition\n}\n/** @type {Extension['flowInitial']} */\n\nexport const flowInitial = {\n  [-2]: codeIndented,\n  [-1]: codeIndented,\n  [32]: codeIndented\n}\n/** @type {Extension['flow']} */\n\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/** @type {Extension['string']} */\n\nexport const string = {\n  [38]: characterReference,\n  [92]: characterEscape\n}\n/** @type {Extension['text']} */\n\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/** @type {Extension['insideSpan']} */\n\nexport const insideSpan = {\n  null: [attention, resolveText]\n}\n/** @type {Extension['attentionMarkers']} */\n\nexport const attentionMarkers = {\n  null: [42, 95]\n}\n/** @type {Extension['disable']} */\n\nexport const disable = {\n  null: []\n}\n","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').FullNormalizedExtension} FullNormalizedExtension\n * @typedef {import('micromark-util-types').ParseOptions} ParseOptions\n * @typedef {import('micromark-util-types').ParseContext} ParseContext\n * @typedef {import('micromark-util-types').Create} Create\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 {text, string} from './initialize/text.js'\nimport {createTokenizer} from './create-tokenizer.js'\nimport * as defaultConstructs from './constructs.js'\n/**\n * @param {ParseOptions} [options]\n * @returns {ParseContext}\n */\n\nexport function parse(options = {}) {\n  /** @type {FullNormalizedExtension} */\n  // @ts-expect-error `defaultConstructs` is full, so the result will be too.\n  const constructs = combineExtensions(\n    // @ts-expect-error Same as above.\n    [defaultConstructs].concat(options.extensions || [])\n  )\n  /** @type {ParseContext} */\n\n  const parser = {\n    defined: [],\n    lazy: {},\n    constructs,\n    content: create(content),\n    document: create(document),\n    flow: create(flow),\n    string: create(string),\n    text: create(text)\n  }\n  return parser\n  /**\n   * @param {InitialConstruct} initial\n   */\n\n  function create(initial) {\n    return creator\n    /** @type {Create} */\n\n    function creator(from) {\n      return createTokenizer(parser, initial, from)\n    }\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Encoding} Encoding\n * @typedef {import('micromark-util-types').Value} Value\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Code} Code\n */\n\n/**\n * @callback Preprocessor\n * @param {Value} value\n * @param {Encoding} [encoding]\n * @param {boolean} [end=false]\n * @returns {Chunk[]}\n */\nconst search = /[\\0\\t\\n\\r]/g\n/**\n * @returns {Preprocessor}\n */\n\nexport function preprocess() {\n  let column = 1\n  let buffer = ''\n  /** @type {boolean|undefined} */\n\n  let start = true\n  /** @type {boolean|undefined} */\n\n  let atCarriageReturn\n  return preprocessor\n  /** @type {Preprocessor} */\n\n  function preprocessor(value, encoding, end) {\n    /** @type {Chunk[]} */\n    const chunks = []\n    /** @type {RegExpMatchArray|null} */\n\n    let match\n    /** @type {number} */\n\n    let next\n    /** @type {number} */\n\n    let startPosition\n    /** @type {number} */\n\n    let endPosition\n    /** @type {Code} */\n\n    let code // @ts-expect-error `Buffer` does allow an encoding.\n\n    value = buffer + value.toString(encoding)\n    startPosition = 0\n    buffer = ''\n\n    if (start) {\n      if (value.charCodeAt(0) === 65279) {\n        startPosition++\n      }\n\n      start = undefined\n    }\n\n    while (startPosition < value.length) {\n      search.lastIndex = startPosition\n      match = search.exec(value)\n      endPosition =\n        match && match.index !== undefined ? match.index : value.length\n      code = value.charCodeAt(endPosition)\n\n      if (!match) {\n        buffer = value.slice(startPosition)\n        break\n      }\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\n        if (startPosition < endPosition) {\n          chunks.push(value.slice(startPosition, endPosition))\n          column += endPosition - startPosition\n        }\n\n        switch (code) {\n          case 0: {\n            chunks.push(65533)\n            column++\n            break\n          }\n\n          case 9: {\n            next = Math.ceil(column / 4) * 4\n            chunks.push(-2)\n\n            while (column++ < next) chunks.push(-1)\n\n            break\n          }\n\n          case 10: {\n            chunks.push(-4)\n            column = 1\n            break\n          }\n\n          default: {\n            atCarriageReturn = true\n            column = 1\n          }\n        }\n      }\n\n      startPosition = endPosition + 1\n    }\n\n    if (end) {\n      if (atCarriageReturn) chunks.push(-5)\n      if (buffer) chunks.push(buffer)\n      chunks.push(null)\n    }\n\n    return chunks\n  }\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 * @param {string} value\n *   Value to decode.\n * @param {number} base\n *   Numeric base.\n * @returns {string}\n */\nexport function decodeNumericCharacterReference(value, base) {\n  const code = Number.parseInt(value, base)\n\n  if (\n    // C0 except for HT, LF, FF, CR, space\n    code < 9 ||\n    code === 11 ||\n    (code > 13 && code < 32) || // Control character (DEL) of the basic block and C1 controls.\n    (code > 126 && code < 160) || // Lone high surrogates and low surrogates.\n    (code > 55295 && code < 57344) || // Noncharacters.\n    (code > 64975 && code < 65008) ||\n    (code & 65535) === 65535 ||\n    (code & 65535) === 65534 || // Out of range\n    code > 1114111\n  ) {\n    return '\\uFFFD'\n  }\n\n  return String.fromCharCode(code)\n}\n","import {decodeNamedCharacterReference} from 'decode-named-character-reference'\nimport {decodeNumericCharacterReference} from 'micromark-util-decode-numeric-character-reference'\nconst characterEscapeOrReference =\n  /\\\\([!-/:-@[-`{-~])|&(#(?:\\d{1,7}|x[\\da-f]{1,6})|[\\da-z]{1,31});/gi\n/**\n * Utility to decode markdown strings (which occur in places such as fenced\n * code info strings, destinations, labels, and titles).\n * The “string” content type allows character escapes and -references.\n * This decodes those.\n *\n * @param {string} value\n * @returns {string}\n */\n\nexport function decodeString(value) {\n  return value.replace(characterEscapeOrReference, decode)\n}\n/**\n * @param {string} $0\n * @param {string} $1\n * @param {string} $2\n * @returns {string}\n */\n\nfunction decode($0, $1, $2) {\n  if ($1) {\n    // Escape.\n    return $1\n  } // Reference.\n\n  const head = $2.charCodeAt(0)\n\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\n  return decodeNamedCharacterReference($2) || $0\n}\n","/**\n * @typedef {import('micromark-util-types').Encoding} Encoding\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').ParseOptions} ParseOptions\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Value} Value\n * @typedef {import('unist').Parent} UnistParent\n * @typedef {import('unist').Point} Point\n * @typedef {import('mdast').PhrasingContent} PhrasingContent\n * @typedef {import('mdast').Content} Content\n * @typedef {Root|Content} Node\n * @typedef {Extract<Node, UnistParent>} Parent\n * @typedef {import('mdast').Break} Break\n * @typedef {import('mdast').Blockquote} Blockquote\n * @typedef {import('mdast').Code} Code\n * @typedef {import('mdast').Definition} Definition\n * @typedef {import('mdast').Emphasis} Emphasis\n * @typedef {import('mdast').Heading} Heading\n * @typedef {import('mdast').HTML} HTML\n * @typedef {import('mdast').Image} Image\n * @typedef {import('mdast').ImageReference} ImageReference\n * @typedef {import('mdast').InlineCode} InlineCode\n * @typedef {import('mdast').Link} Link\n * @typedef {import('mdast').LinkReference} LinkReference\n * @typedef {import('mdast').List} List\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').Paragraph} Paragraph\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast').Strong} Strong\n * @typedef {import('mdast').Text} Text\n * @typedef {import('mdast').ThematicBreak} ThematicBreak\n *\n * @typedef {UnistParent & {type: 'fragment', children: Array<PhrasingContent>}} Fragment\n */\n\n/**\n * @typedef _CompileDataFields\n * @property {boolean|undefined} expectingFirstListItemValue\n * @property {boolean|undefined} flowCodeInside\n * @property {boolean|undefined} setextHeadingSlurpLineEnding\n * @property {boolean|undefined} atHardBreak\n * @property {'collapsed'|'full'} referenceType\n * @property {boolean|undefined} inReference\n * @property {'characterReferenceMarkerHexadecimal'|'characterReferenceMarkerNumeric'} characterReferenceType\n *\n * @typedef {Record<string, unknown> & Partial<_CompileDataFields>} CompileData\n *\n * @typedef {(tree: Root) => Root|void} Transform\n * @typedef {(this: CompileContext, token: Token) => void} Handle\n * @typedef {Record<string, Handle>} Handles\n *   Token types mapping to handles\n * @typedef {Record<string, Record<string, unknown>|Array<unknown>> & {canContainEols: Array<string>, transforms: Array<Transform>, enter: Handles, exit: Handles}} NormalizedExtension\n * @typedef {Partial<NormalizedExtension>} Extension\n *   An mdast extension changes how markdown tokens are turned into mdast.\n *\n * @typedef {(this: Omit<CompileContext, 'sliceSerialize'>, left: Token|undefined, right: Token) => void} OnEnterError\n * @typedef {(this: Omit<CompileContext, 'sliceSerialize'>, left: Token, right: Token) => void} OnExitError\n *\n * @typedef CompileContext\n *   mdast compiler context\n * @property {Array<Node | Fragment>} stack\n * @property {Array<[Token, OnEnterError|undefined]>} tokenStack\n * @property {(key: string, value?: unknown) => void} setData\n *   Set data into the key-value store.\n * @property {<K extends string>(key: K) => CompileData[K]} getData\n *   Get data from the key-value store.\n * @property {(this: CompileContext) => void} buffer\n *   Capture some of the output data.\n * @property {(this: CompileContext) => string} resume\n *   Stop capturing and access the output data.\n * @property {<N extends Node>(this: CompileContext, node: N, token: Token, onError?: OnEnterError) => N} enter\n *   Enter a token.\n * @property {(this: CompileContext, token: Token, onError?: OnExitError) => Node} exit\n *   Exit a token.\n * @property {TokenizeContext['sliceSerialize']} sliceSerialize\n *   Get the string value of a token.\n * @property {NormalizedExtension} config\n *   Configuration.\n *\n * @typedef {{mdastExtensions?: Array<Extension|Array<Extension>>}} FromMarkdownOptions\n * @typedef {ParseOptions & FromMarkdownOptions} Options\n */\nimport {toString} from 'mdast-util-to-string'\nimport {parse} from 'micromark/lib/parse.js'\nimport {preprocess} from 'micromark/lib/preprocess.js'\nimport {postprocess} from 'micromark/lib/postprocess.js'\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 * @param value Markdown to parse (`string` or `Buffer`).\n * @param [encoding] Character encoding to understand `value` as when it’s a `Buffer` (`string`, default: `'utf8'`).\n * @param [options] Configuration\n */\n\nexport const fromMarkdown =\n  /**\n   * @type {(\n   *   ((value: Value, encoding: Encoding, options?: Options) => Root) &\n   *   ((value: Value, options?: Options) => Root)\n   * )}\n   */\n\n  /**\n   * @param {Value} value\n   * @param {Encoding} [encoding]\n   * @param {Options} [options]\n   * @returns {Root}\n   */\n  function (value, encoding, options) {\n    if (typeof encoding !== 'string') {\n      options = encoding\n      encoding = undefined\n    }\n\n    return compiler(options)(\n      postprocess(\n        parse(options).document().write(preprocess()(value, encoding, true))\n      )\n    )\n  }\n/**\n * Note this compiler only understand complete buffering, not streaming.\n *\n * @param {Options} [options]\n */\n\nfunction compiler(options = {}) {\n  /** @type {NormalizedExtension} */\n  // @ts-expect-error: our base has all required fields, so the result will too.\n  const config = configure(\n    {\n      transforms: [],\n      canContainEols: [\n        'emphasis',\n        'fragment',\n        'heading',\n        'paragraph',\n        'strong'\n      ],\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        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    options.mdastExtensions || []\n  )\n  /** @type {CompileData} */\n\n  const data = {}\n  return compile\n  /**\n   * @param {Array<Event>} events\n   * @returns {Root}\n   */\n\n  function compile(events) {\n    /** @type {Root} */\n    let tree = {\n      type: 'root',\n      children: []\n    }\n    /** @type {CompileContext['stack']} */\n\n    const stack = [tree]\n    /** @type {CompileContext['tokenStack']} */\n\n    const tokenStack = []\n    /** @type {Array<number>} */\n\n    const listStack = []\n    /** @type {Omit<CompileContext, 'sliceSerialize'>} */\n\n    const context = {\n      stack,\n      tokenStack,\n      config,\n      enter,\n      exit,\n      buffer,\n      resume,\n      setData,\n      getData\n    }\n    let index = -1\n\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 (\n        events[index][1].type === 'listOrdered' ||\n        events[index][1].type === 'listUnordered'\n      ) {\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\n    index = -1\n\n    while (++index < events.length) {\n      const handler = config[events[index][0]]\n\n      if (own.call(handler, events[index][1].type)) {\n        handler[events[index][1].type].call(\n          Object.assign(\n            {\n              sliceSerialize: events[index][2].sliceSerialize\n            },\n            context\n          ),\n          events[index][1]\n        )\n      }\n    }\n\n    if (tokenStack.length > 0) {\n      const tail = tokenStack[tokenStack.length - 1]\n      const handler = tail[1] || defaultOnError\n      handler.call(context, undefined, tail[0])\n    } // Figure out `root` position.\n\n    tree.position = {\n      start: point(\n        events.length > 0\n          ? events[0][1].start\n          : {\n              line: 1,\n              column: 1,\n              offset: 0\n            }\n      ),\n      end: point(\n        events.length > 0\n          ? events[events.length - 2][1].end\n          : {\n              line: 1,\n              column: 1,\n              offset: 0\n            }\n      )\n    }\n    index = -1\n\n    while (++index < config.transforms.length) {\n      tree = config.transforms[index](tree) || tree\n    }\n\n    return tree\n  }\n  /**\n   * @param {Array<Event>} events\n   * @param {number} start\n   * @param {number} length\n   * @returns {number}\n   */\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\n    let listItem\n    /** @type {number|undefined} */\n\n    let lineIndex\n    /** @type {number|undefined} */\n\n    let firstBlankLineIndex\n    /** @type {boolean|undefined} */\n\n    let atMarker\n\n    while (++index <= length) {\n      const event = events[index]\n\n      if (\n        event[1].type === 'listUnordered' ||\n        event[1].type === 'listOrdered' ||\n        event[1].type === 'blockQuote'\n      ) {\n        if (event[0] === 'enter') {\n          containerBalance++\n        } else {\n          containerBalance--\n        }\n\n        atMarker = undefined\n      } else if (event[1].type === 'lineEndingBlank') {\n        if (event[0] === 'enter') {\n          if (\n            listItem &&\n            !atMarker &&\n            !containerBalance &&\n            !firstBlankLineIndex\n          ) {\n            firstBlankLineIndex = index\n          }\n\n          atMarker = undefined\n        }\n      } else if (\n        event[1].type === 'linePrefix' ||\n        event[1].type === 'listItemValue' ||\n        event[1].type === 'listItemMarker' ||\n        event[1].type === 'listItemPrefix' ||\n        event[1].type === 'listItemPrefixWhitespace'\n      ) {\n        // Empty.\n      } else {\n        atMarker = undefined\n      }\n\n      if (\n        (!containerBalance &&\n          event[0] === 'enter' &&\n          event[1].type === 'listItemPrefix') ||\n        (containerBalance === -1 &&\n          event[0] === 'exit' &&\n          (event[1].type === 'listUnordered' ||\n            event[1].type === 'listOrdered'))\n      ) {\n        if (listItem) {\n          let tailIndex = index\n          lineIndex = undefined\n\n          while (tailIndex--) {\n            const tailEvent = events[tailIndex]\n\n            if (\n              tailEvent[1].type === 'lineEnding' ||\n              tailEvent[1].type === 'lineEndingBlank'\n            ) {\n              if (tailEvent[0] === 'exit') continue\n\n              if (lineIndex) {\n                events[lineIndex][1].type = 'lineEndingBlank'\n                listSpread = true\n              }\n\n              tailEvent[1].type = 'lineEnding'\n              lineIndex = tailIndex\n            } else if (\n              tailEvent[1].type === 'linePrefix' ||\n              tailEvent[1].type === 'blockQuotePrefix' ||\n              tailEvent[1].type === 'blockQuotePrefixWhitespace' ||\n              tailEvent[1].type === 'blockQuoteMarker' ||\n              tailEvent[1].type === 'listItemIndent'\n            ) {\n              // Empty\n            } else {\n              break\n            }\n          }\n\n          if (\n            firstBlankLineIndex &&\n            (!lineIndex || firstBlankLineIndex < lineIndex)\n          ) {\n            // @ts-expect-error Patched.\n            listItem._spread = true\n          } // Fix position.\n\n          listItem.end = Object.assign(\n            {},\n            lineIndex ? events[lineIndex][1].start : event[1].end\n          )\n          events.splice(lineIndex || index, 0, ['exit', listItem, event[2]])\n          index++\n          length++\n        } // Create a new list item.\n\n        if (event[1].type === 'listItemPrefix') {\n          listItem = {\n            type: 'listItem',\n            // @ts-expect-error Patched\n            _spread: false,\n            start: Object.assign({}, event[1].start)\n          } // @ts-expect-error: `listItem` is most definitely defined, TS...\n\n          events.splice(index, 0, ['enter', listItem, event[2]])\n          index++\n          length++\n          firstBlankLineIndex = undefined\n          atMarker = true\n        }\n      }\n    } // @ts-expect-error Patched.\n\n    events[start][1]._spread = listSpread\n    return length\n  }\n  /**\n   * @type {CompileContext['setData']}\n   * @param [value]\n   */\n\n  function setData(key, value) {\n    data[key] = value\n  }\n  /**\n   * @type {CompileContext['getData']}\n   * @template {string} K\n   * @param {K} key\n   * @returns {CompileData[K]}\n   */\n\n  function getData(key) {\n    return data[key]\n  }\n  /**\n   * @param {Point} d\n   * @returns {Point}\n   */\n\n  function point(d) {\n    return {\n      line: d.line,\n      column: d.column,\n      offset: d.offset\n    }\n  }\n  /**\n   * @param {(token: Token) => Node} create\n   * @param {Handle} [and]\n   * @returns {Handle}\n   */\n\n  function opener(create, and) {\n    return open\n    /**\n     * @this {CompileContext}\n     * @param {Token} token\n     * @returns {void}\n     */\n\n    function open(token) {\n      enter.call(this, create(token), token)\n      if (and) and.call(this, token)\n    }\n  }\n  /** @type {CompileContext['buffer']} */\n\n  function buffer() {\n    this.stack.push({\n      type: 'fragment',\n      children: []\n    })\n  }\n  /**\n   * @type {CompileContext['enter']}\n   * @template {Node} N\n   * @this {CompileContext}\n   * @param {N} node\n   * @param {Token} token\n   * @param {OnEnterError} [errorHandler]\n   * @returns {N}\n   */\n\n  function enter(node, token, errorHandler) {\n    const parent = this.stack[this.stack.length - 1]\n    // @ts-expect-error: Assume `Node` can exist as a child of `parent`.\n    parent.children.push(node)\n    this.stack.push(node)\n    this.tokenStack.push([token, errorHandler]) // @ts-expect-error: `end` will be patched later.\n\n    node.position = {\n      start: point(token.start)\n    }\n    return node\n  }\n  /**\n   * @param {Handle} [and]\n   * @returns {Handle}\n   */\n\n  function closer(and) {\n    return close\n    /**\n     * @this {CompileContext}\n     * @param {Token} token\n     * @returns {void}\n     */\n\n    function close(token) {\n      if (and) and.call(this, token)\n      exit.call(this, token)\n    }\n  }\n  /**\n   * @type {CompileContext['exit']}\n   * @this {CompileContext}\n   * @param {Token} token\n   * @param {OnExitError} [onExitError]\n   * @returns {Node}\n   */\n\n  function exit(token, onExitError) {\n    const node = this.stack.pop()\n    const open = this.tokenStack.pop()\n\n    if (!open) {\n      throw new Error(\n        'Cannot close `' +\n          token.type +\n          '` (' +\n          stringifyPosition({\n            start: token.start,\n            end: token.end\n          }) +\n          '): it’s not open'\n      )\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\n    node.position.end = point(token.end)\n    return node\n  }\n  /**\n   * @this {CompileContext}\n   * @returns {string}\n   */\n\n  function resume() {\n    return toString(this.stack.pop())\n  } //\n  // Handlers.\n  //\n\n  /** @type {Handle} */\n\n  function onenterlistordered() {\n    setData('expectingFirstListItemValue', true)\n  }\n  /** @type {Handle} */\n\n  function onenterlistitemvalue(token) {\n    if (getData('expectingFirstListItemValue')) {\n      const ancestor =\n        /** @type {List} */\n        this.stack[this.stack.length - 2]\n      ancestor.start = Number.parseInt(this.sliceSerialize(token), 10)\n      setData('expectingFirstListItemValue')\n    }\n  }\n  /** @type {Handle} */\n\n  function onexitcodefencedfenceinfo() {\n    const data = this.resume()\n    const node =\n      /** @type {Code} */\n      this.stack[this.stack.length - 1]\n    node.lang = data\n  }\n  /** @type {Handle} */\n\n  function onexitcodefencedfencemeta() {\n    const data = this.resume()\n    const node =\n      /** @type {Code} */\n      this.stack[this.stack.length - 1]\n    node.meta = data\n  }\n  /** @type {Handle} */\n\n  function onexitcodefencedfence() {\n    // Exit if this is the closing fence.\n    if (getData('flowCodeInside')) return\n    this.buffer()\n    setData('flowCodeInside', true)\n  }\n  /** @type {Handle} */\n\n  function onexitcodefenced() {\n    const data = this.resume()\n    const node =\n      /** @type {Code} */\n      this.stack[this.stack.length - 1]\n    node.value = data.replace(/^(\\r?\\n|\\r)|(\\r?\\n|\\r)$/g, '')\n    setData('flowCodeInside')\n  }\n  /** @type {Handle} */\n\n  function onexitcodeindented() {\n    const data = this.resume()\n    const node =\n      /** @type {Code} */\n      this.stack[this.stack.length - 1]\n    node.value = data.replace(/(\\r?\\n|\\r)$/g, '')\n  }\n  /** @type {Handle} */\n\n  function onexitdefinitionlabelstring(token) {\n    // Discard label, use the source content instead.\n    const label = this.resume()\n    const node =\n      /** @type {Definition} */\n      this.stack[this.stack.length - 1]\n    node.label = label\n    node.identifier = normalizeIdentifier(\n      this.sliceSerialize(token)\n    ).toLowerCase()\n  }\n  /** @type {Handle} */\n\n  function onexitdefinitiontitlestring() {\n    const data = this.resume()\n    const node =\n      /** @type {Definition} */\n      this.stack[this.stack.length - 1]\n    node.title = data\n  }\n  /** @type {Handle} */\n\n  function onexitdefinitiondestinationstring() {\n    const data = this.resume()\n    const node =\n      /** @type {Definition} */\n      this.stack[this.stack.length - 1]\n    node.url = data\n  }\n  /** @type {Handle} */\n\n  function onexitatxheadingsequence(token) {\n    const node =\n      /** @type {Heading} */\n      this.stack[this.stack.length - 1]\n\n    if (!node.depth) {\n      const depth = this.sliceSerialize(token).length\n      node.depth = depth\n    }\n  }\n  /** @type {Handle} */\n\n  function onexitsetextheadingtext() {\n    setData('setextHeadingSlurpLineEnding', true)\n  }\n  /** @type {Handle} */\n\n  function onexitsetextheadinglinesequence(token) {\n    const node =\n      /** @type {Heading} */\n      this.stack[this.stack.length - 1]\n    node.depth = this.sliceSerialize(token).charCodeAt(0) === 61 ? 1 : 2\n  }\n  /** @type {Handle} */\n\n  function onexitsetextheading() {\n    setData('setextHeadingSlurpLineEnding')\n  }\n  /** @type {Handle} */\n\n  function onenterdata(token) {\n    const parent =\n      /** @type {Parent} */\n      this.stack[this.stack.length - 1]\n    /** @type {Node} */\n\n    let tail = parent.children[parent.children.length - 1]\n\n    if (!tail || tail.type !== 'text') {\n      // Add a new text node.\n      tail = text() // @ts-expect-error: we’ll add `end` later.\n\n      tail.position = {\n        start: point(token.start)\n      } // @ts-expect-error: Assume `parent` accepts `text`.\n\n      parent.children.push(tail)\n    }\n\n    this.stack.push(tail)\n  }\n  /** @type {Handle} */\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  /** @type {Handle} */\n\n  function onexitlineending(token) {\n    const context = this.stack[this.stack.length - 1]\n\n    // If we’re at a hard break, include the line ending in there.\n    if (getData('atHardBreak')) {\n      const tail = context.children[context.children.length - 1]\n      tail.position.end = point(token.end)\n      setData('atHardBreak')\n      return\n    }\n\n    if (\n      !getData('setextHeadingSlurpLineEnding') &&\n      config.canContainEols.includes(context.type)\n    ) {\n      onenterdata.call(this, token)\n      onexitdata.call(this, token)\n    }\n  }\n  /** @type {Handle} */\n\n  function onexithardbreak() {\n    setData('atHardBreak', true)\n  }\n  /** @type {Handle} */\n\n  function onexithtmlflow() {\n    const data = this.resume()\n    const node =\n      /** @type {HTML} */\n      this.stack[this.stack.length - 1]\n    node.value = data\n  }\n  /** @type {Handle} */\n\n  function onexithtmltext() {\n    const data = this.resume()\n    const node =\n      /** @type {HTML} */\n      this.stack[this.stack.length - 1]\n    node.value = data\n  }\n  /** @type {Handle} */\n\n  function onexitcodetext() {\n    const data = this.resume()\n    const node =\n      /** @type {InlineCode} */\n      this.stack[this.stack.length - 1]\n    node.value = data\n  }\n  /** @type {Handle} */\n\n  function onexitlink() {\n    const context =\n      /** @type {Link & {identifier: string, label: string}} */\n      this.stack[this.stack.length - 1] // To do: clean.\n\n    if (getData('inReference')) {\n      context.type += 'Reference' // @ts-expect-error: mutate.\n\n      context.referenceType = getData('referenceType') || 'shortcut' // @ts-expect-error: mutate.\n\n      delete context.url\n      delete context.title\n    } else {\n      // @ts-expect-error: mutate.\n      delete context.identifier // @ts-expect-error: mutate.\n\n      delete context.label\n    }\n\n    setData('referenceType')\n  }\n  /** @type {Handle} */\n\n  function onexitimage() {\n    const context =\n      /** @type {Image & {identifier: string, label: string}} */\n      this.stack[this.stack.length - 1] // To do: clean.\n\n    if (getData('inReference')) {\n      context.type += 'Reference' // @ts-expect-error: mutate.\n\n      context.referenceType = getData('referenceType') || 'shortcut' // @ts-expect-error: mutate.\n\n      delete context.url\n      delete context.title\n    } else {\n      // @ts-expect-error: mutate.\n      delete context.identifier // @ts-expect-error: mutate.\n\n      delete context.label\n    }\n\n    setData('referenceType')\n  }\n  /** @type {Handle} */\n\n  function onexitlabeltext(token) {\n    const ancestor =\n      /** @type {(Link|Image) & {identifier: string, label: string}} */\n      this.stack[this.stack.length - 2]\n    const string = this.sliceSerialize(token)\n    ancestor.label = decodeString(string)\n    ancestor.identifier = normalizeIdentifier(string).toLowerCase()\n  }\n  /** @type {Handle} */\n\n  function onexitlabel() {\n    const fragment =\n      /** @type {Fragment} */\n      this.stack[this.stack.length - 1]\n    const value = this.resume()\n    const node =\n      /** @type {(Link|Image) & {identifier: string, label: string}} */\n      this.stack[this.stack.length - 1] // Assume a reference.\n\n    setData('inReference', true)\n\n    if (node.type === 'link') {\n      // @ts-expect-error: Assume static phrasing content.\n      node.children = fragment.children\n    } else {\n      node.alt = value\n    }\n  }\n  /** @type {Handle} */\n\n  function onexitresourcedestinationstring() {\n    const data = this.resume()\n    const node =\n      /** @type {Link|Image} */\n      this.stack[this.stack.length - 1]\n    node.url = data\n  }\n  /** @type {Handle} */\n\n  function onexitresourcetitlestring() {\n    const data = this.resume()\n    const node =\n      /** @type {Link|Image} */\n      this.stack[this.stack.length - 1]\n    node.title = data\n  }\n  /** @type {Handle} */\n\n  function onexitresource() {\n    setData('inReference')\n  }\n  /** @type {Handle} */\n\n  function onenterreference() {\n    setData('referenceType', 'collapsed')\n  }\n  /** @type {Handle} */\n\n  function onexitreferencestring(token) {\n    const label = this.resume()\n    const node =\n      /** @type {LinkReference|ImageReference} */\n      this.stack[this.stack.length - 1]\n    node.label = label\n    node.identifier = normalizeIdentifier(\n      this.sliceSerialize(token)\n    ).toLowerCase()\n    setData('referenceType', 'full')\n  }\n  /** @type {Handle} */\n\n  function onexitcharacterreferencemarker(token) {\n    setData('characterReferenceType', token.type)\n  }\n  /** @type {Handle} */\n\n  function onexitcharacterreferencevalue(token) {\n    const data = this.sliceSerialize(token)\n    const type = getData('characterReferenceType')\n    /** @type {string} */\n\n    let value\n\n    if (type) {\n      value = decodeNumericCharacterReference(\n        data,\n        type === 'characterReferenceMarkerNumeric' ? 10 : 16\n      )\n      setData('characterReferenceType')\n    } else {\n      // @ts-expect-error `decodeNamedCharacterReference` can return false for\n      // invalid named character references, but everything we’ve tokenized is\n      // valid.\n      value = decodeNamedCharacterReference(data)\n    }\n\n    const tail = this.stack.pop()\n    tail.value += value\n    tail.position.end = point(token.end)\n  }\n  /** @type {Handle} */\n\n  function onexitautolinkprotocol(token) {\n    onexitdata.call(this, token)\n    const node =\n      /** @type {Link} */\n      this.stack[this.stack.length - 1]\n    node.url = this.sliceSerialize(token)\n  }\n  /** @type {Handle} */\n\n  function onexitautolinkemail(token) {\n    onexitdata.call(this, token)\n    const node =\n      /** @type {Link} */\n      this.stack[this.stack.length - 1]\n    node.url = 'mailto:' + this.sliceSerialize(token)\n  } //\n  // Creaters.\n  //\n\n  /** @returns {Blockquote} */\n\n  function blockQuote() {\n    return {\n      type: 'blockquote',\n      children: []\n    }\n  }\n  /** @returns {Code} */\n\n  function codeFlow() {\n    return {\n      type: 'code',\n      lang: null,\n      meta: null,\n      value: ''\n    }\n  }\n  /** @returns {InlineCode} */\n\n  function codeText() {\n    return {\n      type: 'inlineCode',\n      value: ''\n    }\n  }\n  /** @returns {Definition} */\n\n  function definition() {\n    return {\n      type: 'definition',\n      identifier: '',\n      label: null,\n      title: null,\n      url: ''\n    }\n  }\n  /** @returns {Emphasis} */\n\n  function emphasis() {\n    return {\n      type: 'emphasis',\n      children: []\n    }\n  }\n  /** @returns {Heading} */\n\n  function heading() {\n    // @ts-expect-error `depth` will be set later.\n    return {\n      type: 'heading',\n      depth: undefined,\n      children: []\n    }\n  }\n  /** @returns {Break} */\n\n  function hardBreak() {\n    return {\n      type: 'break'\n    }\n  }\n  /** @returns {HTML} */\n\n  function html() {\n    return {\n      type: 'html',\n      value: ''\n    }\n  }\n  /** @returns {Image} */\n\n  function image() {\n    return {\n      type: 'image',\n      title: null,\n      url: '',\n      alt: null\n    }\n  }\n  /** @returns {Link} */\n\n  function link() {\n    return {\n      type: 'link',\n      title: null,\n      url: '',\n      children: []\n    }\n  }\n  /**\n   * @param {Token} token\n   * @returns {List}\n   */\n\n  function list(token) {\n    return {\n      type: 'list',\n      ordered: token.type === 'listOrdered',\n      start: null,\n      // @ts-expect-error Patched.\n      spread: token._spread,\n      children: []\n    }\n  }\n  /**\n   * @param {Token} token\n   * @returns {ListItem}\n   */\n\n  function listItem(token) {\n    return {\n      type: 'listItem',\n      // @ts-expect-error Patched.\n      spread: token._spread,\n      checked: null,\n      children: []\n    }\n  }\n  /** @returns {Paragraph} */\n\n  function paragraph() {\n    return {\n      type: 'paragraph',\n      children: []\n    }\n  }\n  /** @returns {Strong} */\n\n  function strong() {\n    return {\n      type: 'strong',\n      children: []\n    }\n  }\n  /** @returns {Text} */\n\n  function text() {\n    return {\n      type: 'text',\n      value: ''\n    }\n  }\n  /** @returns {ThematicBreak} */\n\n  function thematicBreak() {\n    return {\n      type: 'thematicBreak'\n    }\n  }\n}\n/**\n * @param {Extension} combined\n * @param {Array<Extension|Array<Extension>>} extensions\n * @returns {Extension}\n */\n\nfunction configure(combined, extensions) {\n  let index = -1\n\n  while (++index < extensions.length) {\n    const value = extensions[index]\n\n    if (Array.isArray(value)) {\n      configure(combined, value)\n    } else {\n      extension(combined, value)\n    }\n  }\n\n  return combined\n}\n/**\n * @param {Extension} combined\n * @param {Extension} extension\n * @returns {void}\n */\n\nfunction extension(combined, extension) {\n  /** @type {string} */\n  let key\n\n  for (key in extension) {\n    if (own.call(extension, key)) {\n      const list = key === 'canContainEols' || key === 'transforms'\n      const maybe = own.call(combined, key) ? combined[key] : undefined\n      /* c8 ignore next */\n\n      const left = maybe || (combined[key] = list ? [] : {})\n      const right = extension[key]\n\n      if (right) {\n        if (list) {\n          // @ts-expect-error: `left` is an array.\n          combined[key] = [...left, ...right]\n        } else {\n          Object.assign(left, right)\n        }\n      }\n    }\n  }\n}\n/** @type {OnEnterError} */\n\nfunction defaultOnError(left, right) {\n  if (left) {\n    throw new Error(\n      'Cannot close `' +\n        left.type +\n        '` (' +\n        stringifyPosition({\n          start: left.start,\n          end: left.end\n        }) +\n        '): a different token (`' +\n        right.type +\n        '`, ' +\n        stringifyPosition({\n          start: right.start,\n          end: right.end\n        }) +\n        ') is open'\n    )\n  } else {\n    throw new Error(\n      'Cannot close document, a token (`' +\n        right.type +\n        '`, ' +\n        stringifyPosition({\n          start: right.start,\n          end: right.end\n        }) +\n        ') is still open'\n    )\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Event} Event\n */\nimport {subtokenize} from 'micromark-util-subtokenize'\n/**\n * @param {Event[]} events\n * @returns {Event[]}\n */\n\nexport function postprocess(events) {\n  while (!subtokenize(events)) {\n    // Empty\n  }\n\n  return events\n}\n","import remarkParse from './lib/index.js'\n\nexport default remarkParse\n","/**\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast-util-from-markdown').Options} Options\n */\n\nimport {fromMarkdown} from 'mdast-util-from-markdown'\n\n/** @type {import('unified').Plugin<[Options?] | void[], string, Root>} */\nexport default function remarkParse(options) {\n  /** @type {import('unified').ParserFunction<Root>} */\n  const parser = (doc) => {\n    // Assume options.\n    const settings = /** @type {Options} */ (this.data('settings'))\n\n    return fromMarkdown(\n      doc,\n      Object.assign({}, settings, 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: this.data('micromarkExtensions') || [],\n        mdastExtensions: this.data('fromMarkdownExtensions') || []\n      })\n    )\n  }\n\n  Object.assign(this, {Parser: parser})\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n * @typedef {import('unist').Literal} Literal\n * @typedef {Object.<string, unknown>} Props\n * @typedef {Array.<Node>|string} ChildrenOrValue\n *\n * @typedef {(<T extends string, P extends Record<string, unknown>, C extends Node[]>(type: T, props: P, children: C) => {type: T, children: C} & P)} BuildParentWithProps\n * @typedef {(<T extends string, P extends Record<string, unknown>>(type: T, props: P, value: string) => {type: T, value: string} & P)} BuildLiteralWithProps\n * @typedef {(<T extends string, P extends Record<string, unknown>>(type: T, props: P) => {type: T} & P)} BuildVoidWithProps\n * @typedef {(<T extends string, C extends Node[]>(type: T, children: C) => {type: T, children: C})} BuildParent\n * @typedef {(<T extends string>(type: T, value: string) => {type: T, value: string})} BuildLiteral\n * @typedef {(<T extends string>(type: T) => {type: T})} BuildVoid\n */\n\nexport var u = /**\n * @type {BuildVoid & BuildVoidWithProps & BuildLiteral & BuildLiteralWithProps & BuildParent & BuildParentWithProps}\n */ (\n  /**\n   * @param {string} type Type of node\n   * @param {Props|ChildrenOrValue} [props] Additional properties for node (or `children` or `value`)\n   * @param {ChildrenOrValue} [value] `children` or `value` of node\n   * @returns {Node}\n   */\n  function (type, props, value) {\n    /** @type {Node} */\n    var node = {type: String(type)}\n\n    if (\n      (value === undefined || value === null) &&\n      (typeof props === 'string' || Array.isArray(props))\n    ) {\n      value = props\n    } else {\n      Object.assign(node, props)\n    }\n\n    if (Array.isArray(value)) {\n      node.children = value\n    } else if (value !== undefined && value !== null) {\n      node.value = String(value)\n    }\n\n    return node\n  }\n)\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n *\n * @typedef {string} Type\n * @typedef {Object<string, unknown>} Props\n *\n * @typedef {null|undefined|Type|Props|TestFunctionAnything|Array.<Type|Props|TestFunctionAnything>} Test\n */\n\n/**\n * Check if a node passes a test\n *\n * @callback TestFunctionAnything\n * @param {Node} node\n * @param {number|null|undefined} [index]\n * @param {Parent|null|undefined} [parent]\n * @returns {boolean|void}\n */\n\n/**\n * Check if a node passes a certain node test\n *\n * @template {Node} X\n * @callback TestFunctionPredicate\n * @param {Node} node\n * @param {number|null|undefined} [index]\n * @param {Parent|null|undefined} [parent]\n * @returns {node is X}\n */\n\n/**\n * @callback AssertAnything\n * @param {unknown} [node]\n * @param {number|null|undefined} [index]\n * @param {Parent|null|undefined} [parent]\n * @returns {boolean}\n */\n\n/**\n * Check if a node passes a certain node test\n *\n * @template {Node} Y\n * @callback AssertPredicate\n * @param {unknown} [node]\n * @param {number|null|undefined} [index]\n * @param {Parent|null|undefined} [parent]\n * @returns {node is Y}\n */\n\nexport const is =\n  /**\n   * Check if a node passes a test.\n   * When a `parent` node is known the `index` of node should also be given.\n   *\n   * @type {(\n   *   (<T extends Node>(node: unknown, test: T['type']|Partial<T>|TestFunctionPredicate<T>|Array.<T['type']|Partial<T>|TestFunctionPredicate<T>>, index?: number|null|undefined, parent?: Parent|null|undefined, context?: unknown) => node is T) &\n   *   ((node?: unknown, test?: Test, index?: number|null|undefined, parent?: Parent|null|undefined, context?: unknown) => boolean)\n   * )}\n   */\n  (\n    /**\n     * Check if a node passes a test.\n     * When a `parent` node is known the `index` of node should also be given.\n     *\n     * @param {unknown} [node] Node to check\n     * @param {Test} [test]\n     * When nullish, checks if `node` is a `Node`.\n     * When `string`, works like passing `function (node) {return 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 any one of the subtests pass.\n     * @param {number|null|undefined} [index] Position of `node` in `parent`\n     * @param {Parent|null|undefined} [parent] Parent of `node`\n     * @param {unknown} [context] Context object to invoke `test` with\n     * @returns {boolean} Whether test passed and `node` is a `Node` (object with `type` set to non-empty `string`).\n     */\n    // eslint-disable-next-line max-params\n    function is(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      // @ts-expect-error Looks like a node.\n      return node && node.type && typeof node.type === 'string'\n        ? Boolean(check.call(context, node, index, parent))\n        : false\n    }\n  )\n\nexport const convert =\n  /**\n   * @type {(\n   *   (<T extends Node>(test: T['type']|Partial<T>|TestFunctionPredicate<T>) => AssertPredicate<T>) &\n   *   ((test?: Test) => AssertAnything)\n   * )}\n   */\n  (\n    /**\n     * Generate an assertion from a check.\n     * @param {Test} [test]\n     * When nullish, checks if `node` is a `Node`.\n     * When `string`, works like passing `function (node) {return 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 any one of the subtests pass.\n     * @returns {AssertAnything}\n     */\n    function (test) {\n      if (test === undefined || test === null) {\n        return ok\n      }\n\n      if (typeof test === 'string') {\n        return typeFactory(test)\n      }\n\n      if (typeof test === 'object') {\n        return Array.isArray(test) ? anyFactory(test) : propsFactory(test)\n      }\n\n      if (typeof test === 'function') {\n        return castFactory(test)\n      }\n\n      throw new Error('Expected function, string, or object as test')\n    }\n  )\n/**\n * @param {Array.<Type|Props|TestFunctionAnything>} tests\n * @returns {AssertAnything}\n */\nfunction anyFactory(tests) {\n  /** @type {Array.<AssertAnything>} */\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   * @param {unknown[]} parameters\n   * @returns {boolean}\n   */\n  function any(...parameters) {\n    let index = -1\n\n    while (++index < checks.length) {\n      if (checks[index].call(this, ...parameters)) return true\n    }\n\n    return false\n  }\n}\n\n/**\n * Utility to assert each property in `test` is represented in `node`, and each\n * values are strictly equal.\n *\n * @param {Props} check\n * @returns {AssertAnything}\n */\nfunction propsFactory(check) {\n  return castFactory(all)\n\n  /**\n   * @param {Node} node\n   * @returns {boolean}\n   */\n  function all(node) {\n    /** @type {string} */\n    let key\n\n    for (key in check) {\n      // @ts-expect-error: hush, it sure works as an index.\n      if (node[key] !== check[key]) return false\n    }\n\n    return true\n  }\n}\n\n/**\n * Utility to convert a string into a function which checks a given node’s type\n * for said string.\n *\n * @param {Type} check\n * @returns {AssertAnything}\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 * Utility to convert a string into a function which checks a given node’s type\n * for said string.\n * @param {TestFunctionAnything} check\n * @returns {AssertAnything}\n */\nfunction castFactory(check) {\n  return assertion\n\n  /**\n   * @this {unknown}\n   * @param {Array.<unknown>} parameters\n   * @returns {boolean}\n   */\n  function assertion(...parameters) {\n    // @ts-expect-error: spreading is fine.\n    return Boolean(check.call(this, ...parameters))\n  }\n}\n\n// Utility to return true.\nfunction ok() {\n  return true\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n * @typedef {import('unist-util-is').Test} Test\n * @typedef {import('./complex-types.js').Action} Action\n * @typedef {import('./complex-types.js').Index} Index\n * @typedef {import('./complex-types.js').ActionTuple} ActionTuple\n * @typedef {import('./complex-types.js').VisitorResult} VisitorResult\n * @typedef {import('./complex-types.js').Visitor} Visitor\n */\n\nimport {convert} from 'unist-util-is'\nimport {color} from './color.js'\n\n/**\n * Continue traversing as normal\n */\nexport const CONTINUE = true\n/**\n * Do not traverse this node’s children\n */\nexport const SKIP = 'skip'\n/**\n * Stop traversing immediately\n */\nexport const EXIT = false\n\n/**\n * Visit children of tree which pass test.\n *\n * @param tree\n *   Tree to walk\n * @param [test]\n *   `unist-util-is`-compatible test\n * @param visitor\n *   Function called for nodes that pass `test`.\n * @param [reverse=false]\n *   Traverse in reverse preorder (NRL) instead of preorder (NLR) (default).\n */\nexport const visitParents =\n  /**\n   * @type {(\n   *   (<Tree extends Node, Check extends Test>(tree: Tree, test: Check, visitor: import('./complex-types.js').BuildVisitor<Tree, Check>, reverse?: boolean) => void) &\n   *   (<Tree extends Node>(tree: Tree, visitor: import('./complex-types.js').BuildVisitor<Tree>, reverse?: boolean) => void)\n   * )}\n   */\n  (\n    /**\n     * @param {Node} tree\n     * @param {Test} test\n     * @param {import('./complex-types.js').Visitor<Node>} visitor\n     * @param {boolean} [reverse=false]\n     */\n    function (tree, test, visitor, reverse) {\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        test = null\n      }\n\n      const is = convert(test)\n      const step = reverse ? -1 : 1\n\n      factory(tree, null, [])()\n\n      /**\n       * @param {Node} node\n       * @param {number?} index\n       * @param {Array<Parent>} parents\n       */\n      function factory(node, index, parents) {\n        /** @type {Record<string, unknown>} */\n        // @ts-expect-error: hush\n        const value = typeof node === 'object' && node !== null ? node : {}\n        /** @type {string|undefined} */\n        let name\n\n        if (typeof value.type === 'string') {\n          name =\n            typeof value.tagName === 'string'\n              ? value.tagName\n              : typeof value.name === 'string'\n              ? value.name\n              : undefined\n\n          Object.defineProperty(visit, 'name', {\n            value:\n              'node (' +\n              color(value.type + (name ? '<' + name + '>' : '')) +\n              ')'\n          })\n        }\n\n        return visit\n\n        function visit() {\n          /** @type {ActionTuple} */\n          let result = []\n          /** @type {ActionTuple} */\n          let subresult\n          /** @type {number} */\n          let offset\n          /** @type {Array<Parent>} */\n          let grandparents\n\n          if (!test || is(node, index, parents[parents.length - 1] || null)) {\n            result = toResult(visitor(node, parents))\n\n            if (result[0] === EXIT) {\n              return result\n            }\n          }\n\n          // @ts-expect-error looks like a parent.\n          if (node.children && result[0] !== SKIP) {\n            // @ts-expect-error looks like a parent.\n            offset = (reverse ? node.children.length : -1) + step\n            // @ts-expect-error looks like a parent.\n            grandparents = parents.concat(node)\n\n            // @ts-expect-error looks like a parent.\n            while (offset > -1 && offset < node.children.length) {\n              // @ts-expect-error looks like a parent.\n              subresult = factory(node.children[offset], 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          return result\n        }\n      }\n    }\n  )\n\n/**\n * @param {VisitorResult} value\n * @returns {ActionTuple}\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]\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n * @typedef {import('unist-util-is').Test} Test\n * @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult\n * @typedef {import('./complex-types.js').Visitor} Visitor\n */\n\nimport {visitParents} from 'unist-util-visit-parents'\n\n/**\n * Visit children of tree which pass test.\n *\n * @param tree\n *   Tree to walk\n * @param [test]\n *   `unist-util-is`-compatible test\n * @param visitor\n *   Function called for nodes that pass `test`.\n * @param reverse\n *   Traverse in reverse preorder (NRL) instead of preorder (NLR) (default).\n */\nexport const visit =\n  /**\n   * @type {(\n   *   (<Tree extends Node, Check extends Test>(tree: Tree, test: Check, visitor: import('./complex-types.js').BuildVisitor<Tree, Check>, reverse?: boolean) => void) &\n   *   (<Tree extends Node>(tree: Tree, visitor: import('./complex-types.js').BuildVisitor<Tree>, reverse?: boolean) => void)\n   * )}\n   */\n  (\n    /**\n     * @param {Node} tree\n     * @param {Test} test\n     * @param {import('./complex-types.js').Visitor} visitor\n     * @param {boolean} [reverse]\n     */\n    function (tree, test, visitor, reverse) {\n      if (typeof test === 'function' && typeof visitor !== 'function') {\n        reverse = visitor\n        visitor = test\n        test = null\n      }\n\n      visitParents(tree, test, overload, reverse)\n\n      /**\n       * @param {Node} node\n       * @param {Array<Parent>} parents\n       */\n      function overload(node, parents) {\n        const parent = parents[parents.length - 1]\n        return visitor(\n          node,\n          parent ? parent.children.indexOf(node) : null,\n          parent\n        )\n      }\n    }\n  )\n\nexport {CONTINUE, EXIT, SKIP} from 'unist-util-visit-parents'\n","/**\n * @typedef {import('unist').Position} Position\n * @typedef {import('unist').Node} Node\n * @typedef {Record<string, unknown> & {type: string, position?: PositionLike|undefined}} NodeLike\n * @typedef {import('unist').Point} Point\n *\n * @typedef {Partial<Point>} PointLike\n *\n * @typedef PositionLike\n * @property {PointLike} [start]\n * @property {PointLike} [end]\n */\n\nexport const pointStart = point('start')\nexport const pointEnd = point('end')\n\n/**\n * Get the positional info of `node`.\n *\n * @param {NodeLike|Node} [node]\n * @returns {Position}\n */\nexport function position(node) {\n  return {start: pointStart(node), end: pointEnd(node)}\n}\n\n/**\n * Get the positional info of `node`.\n *\n * @param {'start'|'end'} type\n */\nfunction point(type) {\n  return point\n\n  /**\n   * Get the positional info of `node`.\n   *\n   * @param {NodeLike|Node} [node]\n   * @returns {Point}\n   */\n  function point(node) {\n    const point = (node && node.position && node.position[type]) || {}\n\n    return {\n      line: point.line || null,\n      column: point.column || null,\n      offset: point.offset > -1 ? point.offset : null\n    }\n  }\n}\n","/**\n * @typedef {import('mdast').Root|import('mdast').Content} Node\n * @typedef {import('mdast').Definition} Definition\n */\n\nimport {visit} from 'unist-util-visit'\n\nconst own = {}.hasOwnProperty\n\n/**\n * Find definitions in `node`.\n * Uses CommonMark precedence, which means that earlier definitions are\n * preferred over duplicate later definitions.\n *\n * @param {Node} node\n */\nexport function definitions(node) {\n  /** @type {Record<string, Definition>} */\n  const cache = Object.create(null)\n\n  if (!node || !node.type) {\n    throw new Error('mdast-util-definitions expected node')\n  }\n\n  visit(node, 'definition', (definition) => {\n    const id = clean(definition.identifier)\n    if (id && !own.call(cache, id)) {\n      cache[id] = definition\n    }\n  })\n\n  return definition\n\n  /**\n   * Get a node from the bound definition cache.\n   *\n   * @param {string} identifier\n   * @returns {Definition|null}\n   */\n  function definition(identifier) {\n    const id = clean(identifier)\n    return id && own.call(cache, id) ? cache[id] : null\n  }\n}\n\n/**\n * @param {string} [value]\n * @returns {string}\n */\nfunction clean(value) {\n  return String(value || '').toUpperCase()\n}\n","/**\n * @typedef {import('mdast').Root|import('mdast').Parent['children'][number]} MdastNode\n * @typedef {import('./index.js').H} H\n * @typedef {import('./index.js').Handler} Handler\n * @typedef {import('./index.js').Content} Content\n */\n\nimport {u} from 'unist-builder'\n\nconst own = {}.hasOwnProperty\n\n/**\n * Transform an unknown node.\n * @type {Handler}\n * @param {MdastNode} node\n */\nfunction unknown(h, node) {\n  const data = node.data || {}\n\n  if (\n    'value' in node &&\n    !(\n      own.call(data, 'hName') ||\n      own.call(data, 'hProperties') ||\n      own.call(data, 'hChildren')\n    )\n  ) {\n    return h.augment(node, u('text', node.value))\n  }\n\n  return h(node, 'div', all(h, node))\n}\n\n/**\n * @type {Handler}\n * @param {MdastNode} node\n */\nexport function one(h, node, parent) {\n  const type = node && node.type\n  /** @type {Handler} */\n  let fn\n\n  // Fail on non-nodes.\n  if (!type) {\n    throw new Error('Expected node, got `' + node + '`')\n  }\n\n  if (own.call(h.handlers, type)) {\n    fn = h.handlers[type]\n  } else if (h.passThrough && h.passThrough.includes(type)) {\n    fn = returnNode\n  } else {\n    fn = h.unknownHandler\n  }\n\n  return (typeof fn === 'function' ? fn : unknown)(h, node, parent)\n}\n\n/**\n * @type {Handler}\n * @param {MdastNode} node\n */\nfunction returnNode(h, node) {\n  // @ts-expect-error: Pass through custom node.\n  return 'children' in node ? {...node, children: all(h, node)} : node\n}\n\n/**\n * @param {H} h\n * @param {MdastNode} parent\n */\nexport function all(h, parent) {\n  /** @type {Array<Content>} */\n  const values = []\n\n  if ('children' in parent) {\n    const nodes = parent.children\n    let index = -1\n\n    while (++index < nodes.length) {\n      const result = one(h, nodes[index], parent)\n\n      if (result) {\n        if (index && nodes[index - 1].type === 'break') {\n          if (!Array.isArray(result) && result.type === 'text') {\n            result.value = result.value.replace(/^\\s+/, '')\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 = head.value.replace(/^\\s+/, '')\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","import {asciiAlphanumeric} from 'micromark-util-character'\nimport {encode} from 'micromark-util-encode'\n\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` below).\n * Further unsafe characters are encoded as character references (see\n * `micromark-util-encode`).\n *\n * Then, 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]`,\n * or `/^https?$/i` for `img[src]`.\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|undefined} url\n * @param {RegExp} [protocol]\n * @returns {string}\n */\nexport function sanitizeUri(url, protocol) {\n  const value = encode(normalizeUri(url || ''))\n\n  if (!protocol) {\n    return value\n  }\n\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 || // 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) || // It is a protocol, it should be allowed.\n    protocol.test(value.slice(0, colon))\n  ) {\n    return value\n  }\n\n  return ''\n}\n/**\n * Normalize a URL (such as used in definitions).\n *\n * Encode unsafe characters with percent-encoding, skipping already encoded\n * sequences.\n *\n * @param {string} value\n * @returns {string}\n */\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\n  while (++index < value.length) {\n    const code = value.charCodeAt(index)\n    /** @type {string} */\n\n    let replace = '' // A correct percent encoded value.\n\n    if (\n      code === 37 &&\n      asciiAlphanumeric(value.charCodeAt(index + 1)) &&\n      asciiAlphanumeric(value.charCodeAt(index + 2))\n    ) {\n      skip = 2\n    } // ASCII.\n    else if (code < 128) {\n      if (!/[!#$&-;=?-Z_a-z~]/.test(String.fromCharCode(code))) {\n        replace = String.fromCharCode(code)\n      }\n    } // Astral.\n    else if (code > 55295 && code < 57344) {\n      const next = value.charCodeAt(index + 1) // A correct surrogate pair.\n\n      if (code < 56320 && next > 56319 && next < 57344) {\n        replace = String.fromCharCode(code, next)\n        skip = 1\n      } // Lone surrogate.\n      else {\n        replace = '\\uFFFD'\n      }\n    } // Unicode.\n    else {\n      replace = String.fromCharCode(code)\n    }\n\n    if (replace) {\n      result.push(value.slice(start, index), encodeURIComponent(replace))\n      start = index + skip + 1\n      replace = ''\n    }\n\n    if (skip) {\n      index += skip\n      skip = 0\n    }\n  }\n\n  return result.join('') + value.slice(start)\n}\n","/**\n * @typedef {import('./index.js').Content} Content\n */\n\nimport {u} from 'unist-builder'\n\n/**\n * Wrap `nodes` with line feeds between each entry.\n * Optionally adds line feeds at the start and end.\n *\n * @param {Array<Content>} nodes\n * @param {boolean} [loose=false]\n * @returns {Array<Content>}\n */\nexport function wrap(nodes, loose) {\n  /** @type {Array<Content>} */\n  const result = []\n  let index = -1\n\n  if (loose) {\n    result.push(u('text', '\\n'))\n  }\n\n  while (++index < nodes.length) {\n    if (index) result.push(u('text', '\\n'))\n    result.push(nodes[index])\n  }\n\n  if (loose && nodes.length > 0) {\n    result.push(u('text', '\\n'))\n  }\n\n  return result\n}\n","/**\n * @typedef {import('mdast').FootnoteReference} FootnoteReference\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\nimport {u} from 'unist-builder'\n\n/**\n * @type {Handler}\n * @param {FootnoteReference} node\n */\nexport function footnoteReference(h, node) {\n  const id = String(node.identifier)\n  const safeId = normalizeUri(id.toLowerCase())\n  const index = h.footnoteOrder.indexOf(id)\n  /** @type {number} */\n  let counter\n\n  if (index === -1) {\n    h.footnoteOrder.push(id)\n    h.footnoteCounts[id] = 1\n    counter = h.footnoteOrder.length\n  } else {\n    h.footnoteCounts[id]++\n    counter = index + 1\n  }\n\n  const reuseCounter = h.footnoteCounts[id]\n\n  return h(node, 'sup', [\n    h(\n      node.position,\n      'a',\n      {\n        href: '#' + h.clobberPrefix + 'fn-' + safeId,\n        id:\n          h.clobberPrefix +\n          'fnref-' +\n          safeId +\n          (reuseCounter > 1 ? '-' + reuseCounter : ''),\n        dataFootnoteRef: true,\n        ariaDescribedBy: 'footnote-label'\n      },\n      [u('text', String(counter))]\n    )\n  ])\n}\n","/**\n * @typedef {import('mdast').LinkReference} LinkReference\n * @typedef {import('mdast').ImageReference} ImageReference\n * @typedef {import('./index.js').Handler} Handler\n * @typedef {import('./index.js').Content} Content\n */\n\nimport {u} from 'unist-builder'\nimport {all} from './traverse.js'\n\n/**\n * Return the content of a reference without definition as plain text.\n *\n * @type {Handler}\n * @param {ImageReference|LinkReference} node\n * @returns {Content|Array<Content>}\n */\nexport function revert(h, 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 u('text', '![' + node.alt + suffix)\n  }\n\n  const contents = all(h, node)\n  const head = contents[0]\n\n  if (head && head.type === 'text') {\n    head.value = '[' + head.value\n  } else {\n    contents.unshift(u('text', '['))\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(u('text', suffix))\n  }\n\n  return contents\n}\n","/**\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').List} List\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('hast').Element} Element\n * @typedef {import('../index.js').Handler} Handler\n * @typedef {import('../index.js').Content} Content\n */\n\nimport {u} from 'unist-builder'\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {ListItem} node\n * @param {List} parent\n */\nexport function listItem(h, node, parent) {\n  const result = all(h, node)\n  const loose = parent ? listLoose(parent) : listItemLoose(node)\n  /** @type {Properties} */\n  const props = {}\n  /** @type {Array<Content>} */\n  const wrapped = []\n\n  if (typeof node.checked === 'boolean') {\n    /** @type {Element} */\n    let paragraph\n\n    if (\n      result[0] &&\n      result[0].type === 'element' &&\n      result[0].tagName === 'p'\n    ) {\n      paragraph = result[0]\n    } else {\n      paragraph = h(null, 'p', [])\n      result.unshift(paragraph)\n    }\n\n    if (paragraph.children.length > 0) {\n      paragraph.children.unshift(u('text', ' '))\n    }\n\n    paragraph.children.unshift(\n      h(null, 'input', {\n        type: 'checkbox',\n        checked: node.checked,\n        disabled: true\n      })\n    )\n\n    // According to github-markdown-css, this class hides bullet.\n    // See: <https://github.com/sindresorhus/github-markdown-css>.\n    props.className = ['task-list-item']\n  }\n\n  let index = -1\n\n  while (++index < result.length) {\n    const child = result[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      wrapped.push(u('text', '\\n'))\n    }\n\n    if (child.type === 'element' && child.tagName === 'p' && !loose) {\n      wrapped.push(...child.children)\n    } else {\n      wrapped.push(child)\n    }\n  }\n\n  const tail = result[result.length - 1]\n\n  // Add a final eol.\n  if (tail && (loose || !('tagName' in tail) || tail.tagName !== 'p')) {\n    wrapped.push(u('text', '\\n'))\n  }\n\n  return h(node, 'li', props, wrapped)\n}\n\n/**\n * @param {List} node\n * @return {Boolean}\n */\nfunction listLoose(node) {\n  let loose = node.spread\n  const children = node.children\n  let index = -1\n\n  while (!loose && ++index < children.length) {\n    loose = listItemLoose(children[index])\n  }\n\n  return Boolean(loose)\n}\n\n/**\n * @param {ListItem} node\n * @return {Boolean}\n */\nfunction listItemLoose(node) {\n  const spread = node.spread\n\n  return spread === undefined || spread === null\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 {footnote} from './footnote.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 {text} from './text.js'\nimport {thematicBreak} from './thematic-break.js'\n\nexport const handlers = {\n  blockquote,\n  break: hardBreak,\n  code,\n  delete: strikethrough,\n  emphasis,\n  footnoteReference,\n  footnote,\n  heading,\n  html,\n  imageReference,\n  image,\n  inlineCode,\n  linkReference,\n  link,\n  listItem,\n  list,\n  paragraph,\n  root,\n  strong,\n  table,\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 null\n}\n","/**\n * @typedef {import('mdast').Blockquote} Blockquote\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {wrap} from '../wrap.js'\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {Blockquote} node\n */\nexport function blockquote(h, node) {\n  return h(node, 'blockquote', wrap(all(h, node), true))\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Text} Text\n * @typedef {import('mdast').Break} Break\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {u} from 'unist-builder'\n\n/**\n * @type {Handler}\n * @param {Break} node\n * @returns {Array<Element|Text>}\n */\nexport function hardBreak(h, node) {\n  return [h(node, 'br'), u('text', '\\n')]\n}\n","/**\n * @typedef {import('mdast').Code} Code\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {u} from 'unist-builder'\n\n/**\n * @type {Handler}\n * @param {Code} node\n */\nexport function code(h, node) {\n  const value = node.value ? node.value + '\\n' : ''\n  // To do: next major, use `node.lang` w/o regex, the splitting’s been going\n  // on for years in remark now.\n  const lang = node.lang && node.lang.match(/^[^ \\t]+(?=[ \\t]|$)/)\n  /** @type {Properties} */\n  const props = {}\n\n  if (lang) {\n    props.className = ['language-' + lang]\n  }\n\n  const code = h(node, 'code', props, [u('text', value)])\n\n  if (node.meta) {\n    code.data = {meta: node.meta}\n  }\n\n  return h(node.position, 'pre', [code])\n}\n","/**\n * @typedef {import('mdast').Delete} Delete\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {Delete} node\n */\nexport function strikethrough(h, node) {\n  return h(node, 'del', all(h, node))\n}\n","/**\n * @typedef {import('mdast').Emphasis} Emphasis\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {Emphasis} node\n */\nexport function emphasis(h, node) {\n  return h(node, 'em', all(h, node))\n}\n","/**\n * @typedef {import('mdast').Footnote} Footnote\n * @typedef {import('../index.js').Handler} Handler\n *\n * @todo\n *   `footnote` (or “inline note”) are a pandoc footnotes feature (`^[a note]`)\n *   that does not exist in GFM.\n *   We still have support for it, so that things remain working with\n *   `micromark-extension-footnote` and `mdast-util-footnote`, but in the future\n *   we might be able to remove it?\n */\n\nimport {footnoteReference} from './footnote-reference.js'\n\n/**\n * @type {Handler}\n * @param {Footnote} node\n */\nexport function footnote(h, node) {\n  const footnoteById = h.footnoteById\n  let no = 1\n\n  while (no in footnoteById) no++\n\n  const identifier = String(no)\n\n  footnoteById[identifier] = {\n    type: 'footnoteDefinition',\n    identifier,\n    children: [{type: 'paragraph', children: node.children}],\n    position: node.position\n  }\n\n  return footnoteReference(h, {\n    type: 'footnoteReference',\n    identifier,\n    position: node.position\n  })\n}\n","/**\n * @typedef {import('mdast').Heading} Heading\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {Heading} node\n */\nexport function heading(h, node) {\n  return h(node, 'h' + node.depth, all(h, node))\n}\n","/**\n * @typedef {import('mdast').HTML} HTML\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {u} from 'unist-builder'\n\n/**\n * Return either a `raw` node in dangerous mode, otherwise nothing.\n *\n * @type {Handler}\n * @param {HTML} node\n */\nexport function html(h, node) {\n  return h.dangerous ? h.augment(node, u('raw', node.value)) : null\n}\n","/**\n * @typedef {import('mdast').ImageReference} ImageReference\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\nimport {revert} from '../revert.js'\n\n/**\n * @type {Handler}\n * @param {ImageReference} node\n */\nexport function imageReference(h, node) {\n  const def = h.definition(node.identifier)\n\n  if (!def) {\n    return revert(h, node)\n  }\n\n  /** @type {Properties} */\n  const props = {src: normalizeUri(def.url || ''), alt: node.alt}\n\n  if (def.title !== null && def.title !== undefined) {\n    props.title = def.title\n  }\n\n  return h(node, 'img', props)\n}\n","/**\n * @typedef {import('mdast').Image} Image\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * @type {Handler}\n * @param {Image} node\n */\nexport function image(h, node) {\n  /** @type {Properties} */\n  const props = {src: normalizeUri(node.url), alt: node.alt}\n\n  if (node.title !== null && node.title !== undefined) {\n    props.title = node.title\n  }\n\n  return h(node, 'img', props)\n}\n","/**\n * @typedef {import('mdast').InlineCode} InlineCode\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {u} from 'unist-builder'\n\n/**\n * @type {Handler}\n * @param {InlineCode} node\n */\nexport function inlineCode(h, node) {\n  return h(node, 'code', [u('text', node.value.replace(/\\r?\\n|\\r/g, ' '))])\n}\n","/**\n * @typedef {import('mdast').LinkReference} LinkReference\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\nimport {revert} from '../revert.js'\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {LinkReference} node\n */\nexport function linkReference(h, node) {\n  const def = h.definition(node.identifier)\n\n  if (!def) {\n    return revert(h, node)\n  }\n\n  /** @type {Properties} */\n  const props = {href: normalizeUri(def.url || '')}\n\n  if (def.title !== null && def.title !== undefined) {\n    props.title = def.title\n  }\n\n  return h(node, 'a', props, all(h, node))\n}\n","/**\n * @typedef {import('mdast').Link} Link\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {Link} node\n */\nexport function link(h, node) {\n  /** @type {Properties} */\n  const props = {href: normalizeUri(node.url)}\n\n  if (node.title !== null && node.title !== undefined) {\n    props.title = node.title\n  }\n\n  return h(node, 'a', props, all(h, node))\n}\n","/**\n * @typedef {import('mdast').List} List\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {wrap} from '../wrap.js'\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {List} node\n * @returns {Element}\n */\nexport function list(h, node) {\n  /** @type {Properties} */\n  const props = {}\n  const name = node.ordered ? 'ol' : 'ul'\n  const items = all(h, node)\n  let index = -1\n\n  if (typeof node.start === 'number' && node.start !== 1) {\n    props.start = node.start\n  }\n\n  // Like GitHub, add a class for custom styling.\n  while (++index < items.length) {\n    const item = items[index]\n\n    if (\n      item.type === 'element' &&\n      item.tagName === 'li' &&\n      item.properties &&\n      Array.isArray(item.properties.className) &&\n      item.properties.className.includes('task-list-item')\n    ) {\n      props.className = ['contains-task-list']\n      break\n    }\n  }\n\n  return h(node, name, props, wrap(items, true))\n}\n","/**\n * @typedef {import('mdast').Paragraph} Paragraph\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {Paragraph} node\n */\nexport function paragraph(h, node) {\n  return h(node, 'p', all(h, node))\n}\n","/**\n * @typedef {import('mdast').Root} Root\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {u} from 'unist-builder'\nimport {all} from '../traverse.js'\nimport {wrap} from '../wrap.js'\n\n/**\n * @type {Handler}\n * @param {Root} node\n */\nexport function root(h, node) {\n  // @ts-expect-error `root`s are also fine.\n  return h.augment(node, u('root', wrap(all(h, node))))\n}\n","/**\n * @typedef {import('mdast').Strong} Strong\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {Strong} node\n */\nexport function strong(h, node) {\n  return h(node, 'strong', all(h, node))\n}\n","/**\n * @typedef {import('mdast').Table} Table\n * @typedef {import('hast').Element} Element\n * @typedef {import('../index.js').Handler} Handler\n * @typedef {import('../index.js').Content} Content\n */\n\nimport {pointStart, pointEnd} from 'unist-util-position'\nimport {wrap} from '../wrap.js'\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {Table} node\n */\nexport function table(h, node) {\n  const rows = node.children\n  let index = -1\n  const align = node.align || []\n  /** @type {Array<Element>} */\n  const result = []\n\n  while (++index < rows.length) {\n    const row = rows[index].children\n    const name = index === 0 ? 'th' : 'td'\n    /** @type {Array<Content>} */\n    const out = []\n    let cellIndex = -1\n    const length = node.align ? align.length : row.length\n\n    while (++cellIndex < length) {\n      const cell = row[cellIndex]\n      out.push(\n        h(cell, name, {align: align[cellIndex]}, cell ? all(h, cell) : [])\n      )\n    }\n\n    result[index] = h(rows[index], 'tr', wrap(out, true))\n  }\n\n  return h(\n    node,\n    'table',\n    wrap(\n      [h(result[0].position, 'thead', wrap([result[0]], true))].concat(\n        result[1]\n          ? h(\n              {\n                start: pointStart(result[1]),\n                end: pointEnd(result[result.length - 1])\n              },\n              'tbody',\n              wrap(result.slice(1), true)\n            )\n          : []\n      ),\n      true\n    )\n  )\n}\n","/**\n * @typedef {import('mdast').Text} Text\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {trimLines} from 'trim-lines'\nimport {u} from 'unist-builder'\n\n/**\n * @type {Handler}\n * @param {Text} node\n */\nexport function text(h, node) {\n  return h.augment(node, u('text', trimLines(String(node.value))))\n}\n","/**\n * @typedef {import('mdast').ThematicBreak} ThematicBreak\n * @typedef {import('hast').Element} Element\n * @typedef {import('../index.js').Handler} Handler\n */\n\n/**\n * @type {Handler}\n * @param {ThematicBreak} [node]\n * @returns {Element}\n */\nexport function thematicBreak(h, node) {\n  return h(node, 'hr')\n}\n","/**\n * @typedef {import('mdast').Root|import('mdast').Parent['children'][number]} MdastNode\n * @typedef {import('hast').Root|import('hast').Parent['children'][number]} HastNode\n * @typedef {import('mdast').Parent} Parent\n * @typedef {import('mdast').Definition} Definition\n * @typedef {import('mdast').FootnoteDefinition} FootnoteDefinition\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} Content\n * @typedef {import('unist-util-position').PositionLike} PositionLike\n *\n * @typedef EmbeddedHastFields\n * @property {string} [hName]\n *   Defines the tag name of an element.\n * @property {Properties} [hProperties]\n *   Defines the properties of an element.\n * @property {Array<Content>} [hChildren]\n *   Defines the (hast) children of an element.\n *\n * @typedef {Record<string, unknown> & EmbeddedHastFields} Data\n *   unist data with embedded hast fields.\n *\n * @typedef {MdastNode & {data?: Data}} NodeWithData\n *   unist node with embedded hast data.\n *\n * @callback Handler\n *   Handle a node.\n * @param {H} h\n *   Handle context.\n * @param {any} node\n *   mdast node to handle.\n * @param {Parent|null} parent\n *   Parent of `node`.\n * @returns {Content|Array<Content>|null|undefined}\n *   hast node.\n *\n * @callback HFunctionProps\n * @param {MdastNode|PositionLike|null|undefined} node\n *   mdast node or unist position.\n * @param {string} tagName\n *   HTML tag name.\n * @param {Properties} props\n *   Properties.\n * @param {Array<Content>?} [children]\n *   hast content.\n * @returns {Element}\n *   Compiled element.\n *\n * @callback HFunctionNoProps\n * @param {MdastNode|PositionLike|null|undefined} node\n *   mdast node or unist position.\n * @param {string} tagName\n *   HTML tag name.\n * @param {Array<Content>?} [children]\n *   hast content\n * @returns {Element}\n *   Compiled element.\n *\n * @typedef HFields\n * @property {boolean} dangerous\n *   Whether HTML is allowed.\n * @property {string} clobberPrefix\n *   Prefix to use to prevent DOM clobbering.\n * @property {string} footnoteLabel\n *   Label to use to introduce the footnote section.\n * @property {string} footnoteLabelTagName\n *   HTML used for the footnote label.\n * @property {Properties} footnoteLabelProperties\n *   Properties on the HTML tag used for the footnote label.\n * @property {string} footnoteBackLabel\n *   Label to use to go back to a footnote call from the footnote section.\n * @property {(identifier: string) => Definition|null} definition\n *   Definition cache.\n * @property {Record<string, FootnoteDefinition>} footnoteById\n *   Footnote cache.\n * @property {Array<string>} footnoteOrder\n *   Order in which footnotes occur.\n * @property {Record<string, number>} footnoteCounts\n *   Counts the same footnote was used.\n * @property {Handlers} handlers\n *   Applied handlers.\n * @property {Handler} unknownHandler\n *   Handler for any none not in `passThrough` or otherwise handled.\n * @property {(left: NodeWithData|PositionLike|null|undefined, right: Content) => Content} augment\n *   Like `h` but lower-level and usable on non-elements.\n * @property {Array<string>} passThrough\n *   List of node types to pass through untouched (except for their children).\n *\n * @typedef Options\n *   Configuration (optional).\n * @property {boolean} [allowDangerousHtml=false]\n *   Whether to allow `html` nodes and inject them as `raw` HTML.\n * @property {string} [clobberPrefix='user-content-']\n *   Prefix to use before the `id` attribute to prevent it from *clobbering*.\n *   attributes.\n *   DOM clobbering is this:\n *\n *   ```html\n *   <p id=x></p>\n *   <script>alert(x)</script>\n *   ```\n *\n *   Elements by their ID are made available in browsers on the `window` object.\n *   Using a prefix prevents this from being a problem.\n * @property {string} [footnoteLabel='Footnotes']\n *   Label to use for the footnotes section.\n *   Affects screen reader users.\n *   Change it if you’re authoring in a different language.\n * @property {string} [footnoteLabelTagName='h2']\n *   HTML tag to use for the footnote label.\n *   Can be changed to match your document structure and play well with your choice of css.\n * @property {Properties} [footnoteLabelProperties={className: ['sr-only']}]\n *   Properties to use on the footnote label.\n *   A 'sr-only' class is added by default to hide this from sighted users.\n *   Change it to make the label visible, or add classes for other purposes.\n * @property {string} [footnoteBackLabel='Back to content']\n *   Label to use from backreferences back to their footnote call.\n *   Affects screen reader users.\n *   Change it if you’re authoring in a different language.\n * @property {Handlers} [handlers]\n *   Object mapping mdast nodes to functions handling them\n * @property {Array<string>} [passThrough]\n *   List of custom mdast node types to pass through (keep) in hast\n * @property {Handler} [unknownHandler]\n *   Handler for all unknown nodes.\n *\n * @typedef {Record<string, Handler>} Handlers\n *   Map of node types to handlers\n * @typedef {HFunctionProps & HFunctionNoProps & HFields} H\n *   Handle context\n */\n\nimport {u} from 'unist-builder'\nimport {visit} from 'unist-util-visit'\nimport {pointStart, pointEnd} from 'unist-util-position'\nimport {generated} from 'unist-util-generated'\nimport {definitions} from 'mdast-util-definitions'\nimport {one} from './traverse.js'\nimport {footer} from './footer.js'\nimport {handlers} from './handlers/index.js'\n\nconst own = {}.hasOwnProperty\n\n/**\n * Turn mdast into hast.\n *\n * @param {MdastNode} tree\n *   mdast node.\n * @param {Options} [options]\n *   Configuration (optional).\n * @returns {H}\n *   `h` function.\n */\nfunction factory(tree, options) {\n  const settings = options || {}\n  const dangerous = settings.allowDangerousHtml || false\n  /** @type {Record<string, FootnoteDefinition>} */\n  const footnoteById = {}\n\n  h.dangerous = dangerous\n  h.clobberPrefix =\n    settings.clobberPrefix === undefined || settings.clobberPrefix === null\n      ? 'user-content-'\n      : settings.clobberPrefix\n  h.footnoteLabel = settings.footnoteLabel || 'Footnotes'\n  h.footnoteLabelTagName = settings.footnoteLabelTagName || 'h2'\n  h.footnoteLabelProperties = settings.footnoteLabelProperties || {\n    className: ['sr-only']\n  }\n  h.footnoteBackLabel = settings.footnoteBackLabel || 'Back to content'\n  h.definition = definitions(tree)\n  h.footnoteById = footnoteById\n  /** @type {Array<string>} */\n  h.footnoteOrder = []\n  /** @type {Record<string, number>} */\n  h.footnoteCounts = {}\n  h.augment = augment\n  h.handlers = {...handlers, ...settings.handlers}\n  h.unknownHandler = settings.unknownHandler\n  h.passThrough = settings.passThrough\n\n  visit(tree, 'footnoteDefinition', (definition) => {\n    const id = String(definition.identifier).toUpperCase()\n\n    // Mimick CM behavior of link definitions.\n    // See: <https://github.com/syntax-tree/mdast-util-definitions/blob/8290999/index.js#L26>.\n    if (!own.call(footnoteById, id)) {\n      footnoteById[id] = definition\n    }\n  })\n\n  // @ts-expect-error Hush, it’s fine!\n  return h\n\n  /**\n   * Finalise the created `right`, a hast node, from `left`, an mdast node.\n   *\n   * @param {(NodeWithData|PositionLike)?} left\n   * @param {Content} right\n   * @returns {Content}\n   */\n  function augment(left, right) {\n    // Handle `data.hName`, `data.hProperties, `data.hChildren`.\n    if (left && 'data' in left && left.data) {\n      /** @type {Data} */\n      const data = left.data\n\n      if (data.hName) {\n        if (right.type !== 'element') {\n          right = {\n            type: 'element',\n            tagName: '',\n            properties: {},\n            children: []\n          }\n        }\n\n        right.tagName = data.hName\n      }\n\n      if (right.type === 'element' && data.hProperties) {\n        right.properties = {...right.properties, ...data.hProperties}\n      }\n\n      if ('children' in right && right.children && data.hChildren) {\n        right.children = data.hChildren\n      }\n    }\n\n    if (left) {\n      const ctx = 'type' in left ? left : {position: left}\n\n      if (!generated(ctx)) {\n        // @ts-expect-error: fine.\n        right.position = {start: pointStart(ctx), end: pointEnd(ctx)}\n      }\n    }\n\n    return right\n  }\n\n  /**\n   * Create an element for `node`.\n   *\n   * @type {HFunctionProps}\n   */\n  function h(node, tagName, props, children) {\n    if (Array.isArray(props)) {\n      children = props\n      props = {}\n    }\n\n    // @ts-expect-error augmenting an element yields an element.\n    return augment(node, {\n      type: 'element',\n      tagName,\n      properties: props || {},\n      children: children || []\n    })\n  }\n}\n\n/**\n * Transform `tree` (an mdast node) to a hast node.\n *\n * @param {MdastNode} tree mdast node\n * @param {Options} [options] Configuration\n * @returns {HastNode|null|undefined} hast node\n */\nexport function toHast(tree, options) {\n  const h = factory(tree, options)\n  const node = one(h, tree, null)\n  const foot = footer(h)\n\n  if (foot) {\n    // @ts-expect-error If there’s a footer, there were definitions, meaning block\n    // content.\n    // So assume `node` is a parent node.\n    node.children.push(u('text', '\\n'), foot)\n  }\n\n  return Array.isArray(node) ? {type: 'root', children: node} : node\n}\n\nexport {handlers as defaultHandlers} from './handlers/index.js'\n","/**\n * @typedef {Object} PointLike\n * @property {number} [line]\n * @property {number} [column]\n * @property {number} [offset]\n *\n * @typedef {Object} PositionLike\n * @property {PointLike} [start]\n * @property {PointLike} [end]\n *\n * @typedef {Object} NodeLike\n * @property {PositionLike} [position]\n */\n\n/**\n * Check if `node` is *generated*.\n *\n * @param {NodeLike} [node]\n * @returns {boolean}\n */\nexport function generated(node) {\n  return (\n    !node ||\n    !node.position ||\n    !node.position.start ||\n    !node.position.start.line ||\n    !node.position.start.column ||\n    !node.position.end ||\n    !node.position.end.line ||\n    !node.position.end.column\n  )\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('./index.js').H} H\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\nimport {u} from 'unist-builder'\nimport {all} from './traverse.js'\nimport {wrap} from './wrap.js'\n\n/**\n * @param {H} h\n * @returns {Element|null}\n */\nexport function footer(h) {\n  let index = -1\n  /** @type {Array<ElementContent>} */\n  const listItems = []\n\n  while (++index < h.footnoteOrder.length) {\n    const def = h.footnoteById[h.footnoteOrder[index].toUpperCase()]\n\n    if (!def) {\n      continue\n    }\n\n    const content = all(h, def)\n    const id = String(def.identifier)\n    const safeId = normalizeUri(id.toLowerCase())\n    let referenceIndex = 0\n    /** @type {Array<ElementContent>} */\n    const backReferences = []\n\n    while (++referenceIndex <= h.footnoteCounts[id]) {\n      /** @type {Element} */\n      const backReference = {\n        type: 'element',\n        tagName: 'a',\n        properties: {\n          href:\n            '#' +\n            h.clobberPrefix +\n            'fnref-' +\n            safeId +\n            (referenceIndex > 1 ? '-' + referenceIndex : ''),\n          dataFootnoteBackref: true,\n          className: ['data-footnote-backref'],\n          ariaLabel: h.footnoteBackLabel\n        },\n        children: [{type: 'text', value: '↩'}]\n      }\n\n      if (referenceIndex > 1) {\n        backReference.children.push({\n          type: 'element',\n          tagName: 'sup',\n          children: [{type: 'text', value: String(referenceIndex)}]\n        })\n      }\n\n      if (backReferences.length > 0) {\n        backReferences.push({type: 'text', value: ' '})\n      }\n\n      backReferences.push(backReference)\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: h.clobberPrefix + 'fn-' + safeId},\n      children: wrap(content, true)\n    }\n\n    if (def.position) {\n      listItem.position = def.position\n    }\n\n    listItems.push(listItem)\n  }\n\n  if (listItems.length === 0) {\n    return null\n  }\n\n  return {\n    type: 'element',\n    tagName: 'section',\n    properties: {dataFootnotes: true, className: ['footnotes']},\n    children: [\n      {\n        type: 'element',\n        tagName: h.footnoteLabelTagName,\n        properties: {\n          ...JSON.parse(JSON.stringify(h.footnoteLabelProperties)),\n          id: 'footnote-label'\n        },\n        children: [u('text', h.footnoteLabel)]\n      },\n      {type: 'text', value: '\\n'},\n      {\n        type: 'element',\n        tagName: 'ol',\n        properties: {},\n        children: wrap(listItems, true)\n      },\n      {type: 'text', value: '\\n'}\n    ]\n  }\n}\n","/**\n * @typedef {import('hast').Root} HastRoot\n * @typedef {import('mdast').Root} MdastRoot\n * @typedef {import('mdast-util-to-hast').Options} Options\n * @typedef {import('unified').Processor<any, any, any, any>} Processor\n *\n * @typedef {import('mdast-util-to-hast')} DoNotTouchAsThisImportIncludesRawInTree\n */\n\nimport {toHast} from 'mdast-util-to-hast'\n\n// Note: the `<MdastRoot, HastRoot>` overload doesn’t seem to work :'(\n\n/**\n * Plugin that turns markdown into HTML to support rehype.\n *\n * *   If a destination processor is given, that processor runs with a new HTML\n *     (hast) tree (bridge-mode).\n *     As the given processor runs with a hast tree, and rehype plugins support\n *     hast, that means rehype plugins can be used with the given processor.\n *     The hast tree is discarded in the end.\n *     It’s highly unlikely that you want to do this.\n * *   The common case is to not pass a destination processor, in which case the\n *     current processor continues running with a new HTML (hast) tree\n *     (mutate-mode).\n *     As the current processor continues with a hast tree, and rehype plugins\n *     support hast, that means rehype plugins can be used after\n *     `remark-rehype`.\n *     It’s likely that this is what you want to do.\n *\n * @param destination\n *   Optional unified processor.\n * @param options\n *   Options passed to `mdast-util-to-hast`.\n */\nconst remarkRehype =\n  /** @type {(import('unified').Plugin<[Processor, Options?]|[null|undefined, Options?]|[Options]|[], MdastRoot>)} */\n  (\n    function (destination, options) {\n      return destination && 'run' in destination\n        ? bridge(destination, options)\n        : mutate(destination || options)\n    }\n  )\n\nexport default remarkRehype\n\n/**\n * Bridge-mode.\n * Runs the destination with the new hast tree.\n *\n * @type {import('unified').Plugin<[Processor, Options?], MdastRoot>}\n */\nfunction bridge(destination, options) {\n  return (node, file, next) => {\n    destination.run(toHast(node, options), file, (error) => {\n      next(error)\n    })\n  }\n}\n\n/**\n * Mutate-mode.\n * Further plugins run on the hast tree.\n *\n * @type {import('unified').Plugin<[Options?]|void[], MdastRoot, HastRoot>}\n */\nfunction mutate(options) {\n  // @ts-expect-error: assume a corresponding node is returned by `toHast`.\n  return (node) => toHast(node, options)\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    capture: boolean,\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    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    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    onBeforePrint: 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    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    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    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\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    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    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","import {visit} from 'unist-util-visit'\n\n/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').Element} Element\n *\n * @callback AllowElement\n * @param {Element} element\n * @param {number} index\n * @param {Element|Root} parent\n * @returns {boolean|undefined}\n *\n * @typedef Options\n * @property {Array<string>} [allowedElements]\n * @property {Array<string>} [disallowedElements=[]]\n * @property {AllowElement} [allowElement]\n * @property {boolean} [unwrapDisallowed=false]\n */\n\n/**\n * @type {import('unified').Plugin<[Options], Root>}\n */\nexport default function rehypeFilter(options) {\n  if (options.allowedElements && options.disallowedElements) {\n    throw new TypeError(\n      'Only one of `allowedElements` and `disallowedElements` should be defined'\n    )\n  }\n\n  if (\n    options.allowedElements ||\n    options.disallowedElements ||\n    options.allowElement\n  ) {\n    return (tree) => {\n      visit(tree, 'element', (node, index, parent_) => {\n        const parent = /** @type {Element|Root} */ (parent_)\n        /** @type {boolean|undefined} */\n        let remove\n\n        if (options.allowedElements) {\n          remove = !options.allowedElements.includes(node.tagName)\n        } else if (options.disallowedElements) {\n          remove = options.disallowedElements.includes(node.tagName)\n        }\n\n        if (!remove && options.allowElement && typeof index === 'number') {\n          remove = !options.allowElement(node, index, parent)\n        }\n\n        if (remove && typeof index === 'number') {\n          if (options.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        return undefined\n      })\n    }\n  }\n}\n","const protocols = ['http', 'https', 'mailto', 'tel']\n\n/**\n * @param {string} uri\n * @returns {string}\n */\nexport function uriTransformer(uri) {\n  const url = (uri || '').trim()\n  const first = url.charAt(0)\n\n  if (first === '#' || first === '/') {\n    return url\n  }\n\n  const colon = url.indexOf(':')\n  if (colon === -1) {\n    return url\n  }\n\n  let index = -1\n\n  while (++index < protocols.length) {\n    const protocol = protocols[index]\n\n    if (\n      colon === protocol.length &&\n      url.slice(0, protocol.length).toLowerCase() === protocol\n    ) {\n      return url\n    }\n  }\n\n  index = url.indexOf('?')\n  if (index !== -1 && colon > index) {\n    return url\n  }\n\n  index = url.indexOf('#')\n  if (index !== -1 && colon > index) {\n    return url\n  }\n\n  // eslint-disable-next-line no-script-url\n  return 'javascript:void(0)'\n}\n","/**\n * @param {unknown} thing\n * @returns {boolean}\n */\nexport function whitespace(thing) {\n  /** @type {string} */\n  var value =\n    // @ts-ignore looks like a node.\n    thing && typeof thing === 'object' && thing.type === 'text'\n      ? // @ts-ignore looks like a text.\n        thing.value || ''\n      : thing\n\n  // HTML whitespace expression.\n  // See <https://html.spec.whatwg.org/#space-character>.\n  return typeof value === 'string' && value.replace(/[ \\t\\n\\f\\r]/g, '') === ''\n}\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","export 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","/**\n * @template T\n * @typedef {import('react').ComponentType<T>} ComponentType<T>\n */\n\n/**\n * @template T\n * @typedef {import('react').ComponentPropsWithoutRef<T>} ComponentPropsWithoutRef<T>\n */\n\n/**\n * @typedef {import('react').ReactNode} ReactNode\n * @typedef {import('unist').Position} Position\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').Text} Text\n * @typedef {import('hast').Comment} Comment\n * @typedef {import('hast').DocType} Doctype\n * @typedef {import('property-information').Info} Info\n * @typedef {import('property-information').Schema} Schema\n * @typedef {import('./complex-types').ReactMarkdownProps} ReactMarkdownProps\n *\n * @typedef Raw\n * @property {'raw'} type\n * @property {string} value\n *\n * @typedef Context\n * @property {Options} options\n * @property {Schema} schema\n * @property {number} listDepth\n *\n * @callback TransformLink\n * @param {string} href\n * @param {Array<ElementContent>} children\n * @param {string?} title\n * @returns {string}\n *\n * @callback TransformImage\n * @param {string} src\n * @param {string} alt\n * @param {string?} title\n * @returns {string}\n *\n * @typedef {import('react').HTMLAttributeAnchorTarget} TransformLinkTargetType\n *\n * @callback TransformLinkTarget\n * @param {string} href\n * @param {Array<ElementContent>} children\n * @param {string?} title\n * @returns {TransformLinkTargetType|undefined}\n *\n * @typedef {keyof JSX.IntrinsicElements} ReactMarkdownNames\n *\n * To do: is `data-sourcepos` typeable?\n *\n * @typedef {ComponentPropsWithoutRef<'code'> & ReactMarkdownProps & {inline?: boolean}} CodeProps\n * @typedef {ComponentPropsWithoutRef<'h1'> & ReactMarkdownProps & {level: number}} HeadingProps\n * @typedef {ComponentPropsWithoutRef<'li'> & ReactMarkdownProps & {checked: boolean|null, index: number, ordered: boolean}} LiProps\n * @typedef {ComponentPropsWithoutRef<'ol'> & ReactMarkdownProps & {depth: number, ordered: true}} OrderedListProps\n * @typedef {ComponentPropsWithoutRef<'table'> & ReactMarkdownProps & {style?: Record<string, unknown>, isHeader: boolean}} TableCellProps\n * @typedef {ComponentPropsWithoutRef<'tr'> & ReactMarkdownProps & {isHeader: boolean}} TableRowProps\n * @typedef {ComponentPropsWithoutRef<'ul'> & ReactMarkdownProps & {depth: number, ordered: false}} UnorderedListProps\n *\n * @typedef {ComponentType<CodeProps>} CodeComponent\n * @typedef {ComponentType<HeadingProps>} HeadingComponent\n * @typedef {ComponentType<LiProps>} LiComponent\n * @typedef {ComponentType<OrderedListProps>} OrderedListComponent\n * @typedef {ComponentType<TableCellProps>} TableCellComponent\n * @typedef {ComponentType<TableRowProps>} TableRowComponent\n * @typedef {ComponentType<UnorderedListProps>} UnorderedListComponent\n *\n * @typedef SpecialComponents\n * @property {CodeComponent|ReactMarkdownNames} code\n * @property {HeadingComponent|ReactMarkdownNames} h1\n * @property {HeadingComponent|ReactMarkdownNames} h2\n * @property {HeadingComponent|ReactMarkdownNames} h3\n * @property {HeadingComponent|ReactMarkdownNames} h4\n * @property {HeadingComponent|ReactMarkdownNames} h5\n * @property {HeadingComponent|ReactMarkdownNames} h6\n * @property {LiComponent|ReactMarkdownNames} li\n * @property {OrderedListComponent|ReactMarkdownNames} ol\n * @property {TableCellComponent|ReactMarkdownNames} td\n * @property {TableCellComponent|ReactMarkdownNames} th\n * @property {TableRowComponent|ReactMarkdownNames} tr\n * @property {UnorderedListComponent|ReactMarkdownNames} ul\n *\n * @typedef {Partial<Omit<import('./complex-types').NormalComponents, keyof SpecialComponents> & SpecialComponents>} Components\n *\n * @typedef Options\n * @property {boolean} [sourcePos=false]\n * @property {boolean} [rawSourcePos=false]\n * @property {boolean} [skipHtml=false]\n * @property {boolean} [includeElementIndex=false]\n * @property {null|false|TransformLink} [transformLinkUri]\n * @property {TransformImage} [transformImageUri]\n * @property {TransformLinkTargetType|TransformLinkTarget} [linkTarget]\n * @property {Components} [components]\n */\n\nimport React from 'react'\nimport ReactIs from 'react-is'\nimport {whitespace} from 'hast-util-whitespace'\nimport {svg, find, hastToReact} from 'property-information'\nimport {stringify as spaces} from 'space-separated-tokens'\nimport {stringify as commas} from 'comma-separated-tokens'\nimport style from 'style-to-object'\n\nconst own = {}.hasOwnProperty\n\n// The table-related elements that must not contain whitespace text according\n// to React.\nconst tableElements = new Set(['table', 'thead', 'tbody', 'tfoot', 'tr'])\n\n/**\n * @param {Context} context\n * @param {Element|Root} node\n */\nexport function childrenToReact(context, node) {\n  /** @type {Array<ReactNode>} */\n  const children = []\n  let childIndex = -1\n  /** @type {Comment|Doctype|Element|Raw|Text} */\n  let child\n\n  while (++childIndex < node.children.length) {\n    child = node.children[childIndex]\n\n    if (child.type === 'element') {\n      children.push(toReact(context, child, childIndex, node))\n    } else if (child.type === 'text') {\n      // Currently, a warning is triggered by react for *any* white space in\n      // tables.\n      // So we drop it.\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/remarkjs/react-markdown/issues/576>.\n      if (\n        node.type !== 'element' ||\n        !tableElements.has(node.tagName) ||\n        !whitespace(child)\n      ) {\n        children.push(child.value)\n      }\n    } else if (child.type === 'raw' && !context.options.skipHtml) {\n      // Default behavior is to show (encoded) HTML.\n      children.push(child.value)\n    }\n  }\n\n  return children\n}\n\n/**\n * @param {Context} context\n * @param {Element} node\n * @param {number} index\n * @param {Element|Root} parent\n */\nfunction toReact(context, node, index, parent) {\n  const options = context.options\n  const parentSchema = context.schema\n  /** @type {ReactMarkdownNames} */\n  // @ts-expect-error assume a known HTML/SVG element.\n  const name = node.tagName\n  /** @type {Record<string, unknown>} */\n  const properties = {}\n  let schema = parentSchema\n  /** @type {string} */\n  let property\n\n  if (parentSchema.space === 'html' && name === 'svg') {\n    schema = svg\n    context.schema = schema\n  }\n\n  if (node.properties) {\n    for (property in node.properties) {\n      if (own.call(node.properties, property)) {\n        addProperty(properties, property, node.properties[property], context)\n      }\n    }\n  }\n\n  if (name === 'ol' || name === 'ul') {\n    context.listDepth++\n  }\n\n  const children = childrenToReact(context, node)\n\n  if (name === 'ol' || name === 'ul') {\n    context.listDepth--\n  }\n\n  // Restore parent schema.\n  context.schema = parentSchema\n\n  // Nodes created by plugins do not have positional info, in which case we use\n  // an object that matches the position interface.\n  const position = node.position || {\n    start: {line: null, column: null, offset: null},\n    end: {line: null, column: null, offset: null}\n  }\n  const component =\n    options.components && own.call(options.components, name)\n      ? options.components[name]\n      : name\n  const basic = typeof component === 'string' || component === React.Fragment\n\n  if (!ReactIs.isValidElementType(component)) {\n    throw new TypeError(\n      `Component for name \\`${name}\\` not defined or is not renderable`\n    )\n  }\n\n  properties.key = [\n    name,\n    position.start.line,\n    position.start.column,\n    index\n  ].join('-')\n\n  if (name === 'a' && options.linkTarget) {\n    properties.target =\n      typeof options.linkTarget === 'function'\n        ? options.linkTarget(\n            String(properties.href || ''),\n            node.children,\n            typeof properties.title === 'string' ? properties.title : null\n          )\n        : options.linkTarget\n  }\n\n  if (name === 'a' && options.transformLinkUri) {\n    properties.href = options.transformLinkUri(\n      String(properties.href || ''),\n      node.children,\n      typeof properties.title === 'string' ? properties.title : null\n    )\n  }\n\n  if (\n    !basic &&\n    name === 'code' &&\n    parent.type === 'element' &&\n    parent.tagName !== 'pre'\n  ) {\n    properties.inline = true\n  }\n\n  if (\n    !basic &&\n    (name === 'h1' ||\n      name === 'h2' ||\n      name === 'h3' ||\n      name === 'h4' ||\n      name === 'h5' ||\n      name === 'h6')\n  ) {\n    properties.level = Number.parseInt(name.charAt(1), 10)\n  }\n\n  if (name === 'img' && options.transformImageUri) {\n    properties.src = options.transformImageUri(\n      String(properties.src || ''),\n      String(properties.alt || ''),\n      typeof properties.title === 'string' ? properties.title : null\n    )\n  }\n\n  if (!basic && name === 'li' && parent.type === 'element') {\n    const input = getInputElement(node)\n    properties.checked =\n      input && input.properties ? Boolean(input.properties.checked) : null\n    properties.index = getElementsBeforeCount(parent, node)\n    properties.ordered = parent.tagName === 'ol'\n  }\n\n  if (!basic && (name === 'ol' || name === 'ul')) {\n    properties.ordered = name === 'ol'\n    properties.depth = context.listDepth\n  }\n\n  if (name === 'td' || name === 'th') {\n    if (properties.align) {\n      if (!properties.style) properties.style = {}\n      // @ts-expect-error assume `style` is an object\n      properties.style.textAlign = properties.align\n      delete properties.align\n    }\n\n    if (!basic) {\n      properties.isHeader = name === 'th'\n    }\n  }\n\n  if (!basic && name === 'tr' && parent.type === 'element') {\n    properties.isHeader = Boolean(parent.tagName === 'thead')\n  }\n\n  // If `sourcePos` is given, pass source information (line/column info from markdown source).\n  if (options.sourcePos) {\n    properties['data-sourcepos'] = flattenPosition(position)\n  }\n\n  if (!basic && options.rawSourcePos) {\n    properties.sourcePosition = node.position\n  }\n\n  // If `includeElementIndex` is given, pass node index info to components.\n  if (!basic && options.includeElementIndex) {\n    properties.index = getElementsBeforeCount(parent, node)\n    properties.siblingCount = getElementsBeforeCount(parent)\n  }\n\n  if (!basic) {\n    properties.node = node\n  }\n\n  // Ensure no React warnings are emitted for void elements w/ children.\n  return children.length > 0\n    ? React.createElement(component, properties, children)\n    : React.createElement(component, properties)\n}\n\n/**\n * @param {Element|Root} node\n * @returns {Element?}\n */\nfunction getInputElement(node) {\n  let index = -1\n\n  while (++index < node.children.length) {\n    const child = node.children[index]\n\n    if (child.type === 'element' && child.tagName === 'input') {\n      return child\n    }\n  }\n\n  return null\n}\n\n/**\n * @param {Element|Root} parent\n * @param {Element} [node]\n * @returns {number}\n */\nfunction getElementsBeforeCount(parent, node) {\n  let index = -1\n  let count = 0\n\n  while (++index < parent.children.length) {\n    if (parent.children[index] === node) break\n    if (parent.children[index].type === 'element') count++\n  }\n\n  return count\n}\n\n/**\n * @param {Record<string, unknown>} props\n * @param {string} prop\n * @param {unknown} value\n * @param {Context} ctx\n */\nfunction addProperty(props, prop, value, ctx) {\n  const info = find(ctx.schema, prop)\n  let result = value\n\n  // Ignore nullish and `NaN` values.\n  // eslint-disable-next-line no-self-compare\n  if (result === null || result === undefined || result !== result) {\n    return\n  }\n\n  // Accept `array`.\n  // Most props are space-separated.\n  if (Array.isArray(result)) {\n    result = info.commaSeparated ? commas(result) : spaces(result)\n  }\n\n  if (info.property === 'style' && typeof result === 'string') {\n    result = parseStyle(result)\n  }\n\n  if (info.space && info.property) {\n    props[\n      own.call(hastToReact, info.property)\n        ? hastToReact[info.property]\n        : info.property\n    ] = result\n  } else if (info.attribute) {\n    props[info.attribute] = result\n  }\n}\n\n/**\n * @param {string} value\n * @returns {Record<string, string>}\n */\nfunction parseStyle(value) {\n  /** @type {Record<string, string>} */\n  const result = {}\n\n  try {\n    style(value, iterator)\n  } catch {\n    // Silent.\n  }\n\n  return result\n\n  /**\n   * @param {string} name\n   * @param {string} v\n   */\n  function iterator(name, v) {\n    const k = name.slice(0, 4) === '-ms-' ? `ms-${name.slice(4)}` : name\n    result[k.replace(/-([a-z])/g, styleReplacer)] = v\n  }\n}\n\n/**\n * @param {unknown} _\n * @param {string} $1\n */\nfunction styleReplacer(_, $1) {\n  return $1.toUpperCase()\n}\n\n/**\n * @param {Position|{start: {line: null, column: null, offset: null}, end: {line: null, column: null, offset: null}}} pos\n * @returns {string}\n */\nfunction flattenPosition(pos) {\n  return [\n    pos.start.line,\n    ':',\n    pos.start.column,\n    '-',\n    pos.end.line,\n    ':',\n    pos.end.column\n  ]\n    .map((d) => String(d))\n    .join('')\n}\n","/**\n * @typedef {Object} StringifyOptions\n * @property {boolean} [padLeft=true] Whether to pad a space before a token (`boolean`, default: `true`).\n * @property {boolean} [padRight=false] Whether to pad a space after a token (`boolean`, default: `false`).\n */\n\n/**\n * Parse comma separated tokens to an array.\n *\n * @param {string} value\n * @returns {Array.<string>}\n */\nexport function parse(value) {\n  /** @type {Array.<string>} */\n  var tokens = []\n  var input = String(value || '')\n  var index = input.indexOf(',')\n  var start = 0\n  /** @type {boolean} */\n  var end\n  /** @type {string} */\n  var token\n\n  while (!end) {\n    if (index === -1) {\n      index = input.length\n      end = true\n    }\n\n    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 to comma separated tokens.\n *\n * @param {Array.<string|number>} values\n * @param {StringifyOptions} [options]\n * @returns {string}\n */\nexport function stringify(values, options) {\n  var settings = options || {}\n\n  // Ensure the last empty entry is seen.\n  if (values[values.length - 1] === '') {\n    values = values.concat('')\n  }\n\n  return values\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 Space separated tokens\n * @returns {Array.<string>} 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 Tokens\n * @returns {string} Space separated tokens\n */\nexport function stringify(values) {\n  return values.join(' ').trim()\n}\n","/**\n * @typedef {import('react').ReactNode} ReactNode\n * @typedef {import('react').ReactElement<{}>} ReactElement\n * @typedef {import('unified').PluggableList} PluggableList\n * @typedef {import('hast').Root} Root\n * @typedef {import('./rehype-filter.js').Options} FilterOptions\n * @typedef {import('./ast-to-react.js').Options} TransformOptions\n *\n * @typedef CoreOptions\n * @property {string} children\n *\n * @typedef PluginOptions\n * @property {PluggableList} [remarkPlugins=[]]\n * @property {PluggableList} [rehypePlugins=[]]\n * @property {import('remark-rehype').Options | undefined} [remarkRehypeOptions={}]\n *\n * @typedef LayoutOptions\n * @property {string} [className]\n *\n * @typedef {CoreOptions & PluginOptions & LayoutOptions & FilterOptions & TransformOptions} ReactMarkdownOptions\n *\n * @typedef Deprecation\n * @property {string} id\n * @property {string} [to]\n */\n\nimport React from 'react'\nimport {VFile} from 'vfile'\nimport {unified} from 'unified'\nimport remarkParse from 'remark-parse'\nimport remarkRehype from 'remark-rehype'\nimport PropTypes from 'prop-types'\nimport {html} from 'property-information'\nimport rehypeFilter from './rehype-filter.js'\nimport {uriTransformer} from './uri-transformer.js'\nimport {childrenToReact} from './ast-to-react.js'\n\nconst own = {}.hasOwnProperty\nconst changelog =\n  'https://github.com/remarkjs/react-markdown/blob/main/changelog.md'\n\n/** @type {Record<string, Deprecation>} */\nconst deprecated = {\n  plugins: {to: 'plugins', id: 'change-plugins-to-remarkplugins'},\n  renderers: {to: 'components', id: 'change-renderers-to-components'},\n  astPlugins: {id: 'remove-buggy-html-in-markdown-parser'},\n  allowDangerousHtml: {id: 'remove-buggy-html-in-markdown-parser'},\n  escapeHtml: {id: 'remove-buggy-html-in-markdown-parser'},\n  source: {to: 'children', id: 'change-source-to-children'},\n  allowNode: {\n    to: 'allowElement',\n    id: 'replace-allownode-allowedtypes-and-disallowedtypes'\n  },\n  allowedTypes: {\n    to: 'allowedElements',\n    id: 'replace-allownode-allowedtypes-and-disallowedtypes'\n  },\n  disallowedTypes: {\n    to: 'disallowedElements',\n    id: 'replace-allownode-allowedtypes-and-disallowedtypes'\n  },\n  includeNodeIndex: {\n    to: 'includeElementIndex',\n    id: 'change-includenodeindex-to-includeelementindex'\n  }\n}\n\n/**\n * React component to render markdown.\n *\n * @param {ReactMarkdownOptions} options\n * @returns {ReactElement}\n */\nexport function ReactMarkdown(options) {\n  for (const key in deprecated) {\n    if (own.call(deprecated, key) && own.call(options, key)) {\n      const deprecation = deprecated[key]\n      console.warn(\n        `[react-markdown] Warning: please ${\n          deprecation.to ? `use \\`${deprecation.to}\\` instead of` : 'remove'\n        } \\`${key}\\` (see <${changelog}#${deprecation.id}> for more info)`\n      )\n      delete deprecated[key]\n    }\n  }\n\n  const processor = unified()\n    .use(remarkParse)\n    .use(options.remarkPlugins || [])\n    .use(remarkRehype, {\n      ...options.remarkRehypeOptions,\n      allowDangerousHtml: true\n    })\n    .use(options.rehypePlugins || [])\n    .use(rehypeFilter, options)\n\n  const file = new VFile()\n\n  if (typeof options.children === 'string') {\n    file.value = options.children\n  } else if (options.children !== undefined && options.children !== null) {\n    console.warn(\n      `[react-markdown] Warning: please pass a string as \\`children\\` (not: \\`${options.children}\\`)`\n    )\n  }\n\n  const hastNode = processor.runSync(processor.parse(file), file)\n\n  if (hastNode.type !== 'root') {\n    throw new TypeError('Expected a `root` node')\n  }\n\n  /** @type {ReactElement} */\n  let result = React.createElement(\n    React.Fragment,\n    {},\n    childrenToReact({options, schema: html, listDepth: 0}, hastNode)\n  )\n\n  if (options.className) {\n    result = React.createElement('div', {className: options.className}, result)\n  }\n\n  return result\n}\n\nReactMarkdown.defaultProps = {transformLinkUri: uriTransformer}\n\nReactMarkdown.propTypes = {\n  // Core options:\n  children: PropTypes.string,\n  // Layout options:\n  className: PropTypes.string,\n  // Filter options:\n  allowElement: PropTypes.func,\n  allowedElements: PropTypes.arrayOf(PropTypes.string),\n  disallowedElements: PropTypes.arrayOf(PropTypes.string),\n  unwrapDisallowed: PropTypes.bool,\n  // Plugin options:\n  remarkPlugins: PropTypes.arrayOf(\n    PropTypes.oneOfType([\n      PropTypes.object,\n      PropTypes.func,\n      PropTypes.arrayOf(\n        PropTypes.oneOfType([\n          PropTypes.bool,\n          PropTypes.string,\n          PropTypes.object,\n          PropTypes.func,\n          PropTypes.arrayOf(\n            // prettier-ignore\n            // type-coverage:ignore-next-line\n            PropTypes.any\n          )\n        ])\n      )\n    ])\n  ),\n  rehypePlugins: PropTypes.arrayOf(\n    PropTypes.oneOfType([\n      PropTypes.object,\n      PropTypes.func,\n      PropTypes.arrayOf(\n        PropTypes.oneOfType([\n          PropTypes.bool,\n          PropTypes.string,\n          PropTypes.object,\n          PropTypes.func,\n          PropTypes.arrayOf(\n            // prettier-ignore\n            // type-coverage:ignore-next-line\n            PropTypes.any\n          )\n        ])\n      )\n    ])\n  ),\n  // Transform options:\n  sourcePos: PropTypes.bool,\n  rawSourcePos: PropTypes.bool,\n  skipHtml: PropTypes.bool,\n  includeElementIndex: PropTypes.bool,\n  transformLinkUri: PropTypes.oneOfType([PropTypes.func, PropTypes.bool]),\n  linkTarget: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  transformImageUri: PropTypes.func,\n  components: PropTypes.object\n}\n"],"names":["_interopRequireDefault","exports","_createSvgIcon","_jsxRuntime","_default","default","jsx","d","createSvgIcon","_excluded","AvatarRoot","styled","name","slot","overridesResolver","props","styles","ownerState","root","variant","colorDefault","theme","position","display","alignItems","justifyContent","flexShrink","width","height","fontFamily","typography","fontSize","pxToRem","lineHeight","borderRadius","overflow","userSelect","shape","color","palette","background","backgroundColor","mode","grey","AvatarImg","img","textAlign","objectFit","textIndent","AvatarFallback","Person","fallback","inProps","ref","useThemeProps","alt","children","childrenProp","className","component","imgProps","sizes","src","srcSet","other","loaded","crossOrigin","referrerPolicy","setLoaded","active","image","Image","onload","onerror","srcset","useLoaded","hasImg","hasImgNotFailing","classes","slots","composeClasses","useUtilityClasses","as","getAvatarUtilityClass","avatarClasses","getAvatarGroupUtilityClass","generateUtilityClass","SPACINGS","small","medium","AvatarGroupRoot","avatar","border","vars","boxSizing","marginLeft","flexDirection","AvatarGroupAvatar","Avatar","_componentsProps$addi","_componentsProps$addi2","componentsProps","max","spacing","total","clampedMax","filter","child","totalAvatars","length","Math","min","maxAvatars","extraAvatars","undefined","additionalAvatar","style","slice","reverse","map","index","getCardMediaUtilityClass","CardMediaRoot","isMediaComponent","isImageComponent","media","backgroundSize","backgroundRepeat","backgroundPosition","MEDIA_COMPONENTS","IMAGE_COMPONENTS","indexOf","composedStyle","backgroundImage","role","getFormGroupUtilityClass","FormGroupRoot","row","flexWrap","muiFormControl","useFormControl","fcs","formControlState","states","error","getInputAdornmentUtilityClass","_span","InputAdornmentRoot","capitalize","disablePointerEvents","maxHeight","whiteSpace","action","marginTop","marginRight","pointerEvents","disableTypography","variantProp","hiddenLabel","size","FormControlContext","value","Typography","_t","_t2","_t3","_t4","_t5","_t6","_","t","indeterminate1Keyframe","indeterminate2Keyframe","bufferKeyframe","getColorShade","main","LinearProgressRoot","zIndex","colorAdjust","content","left","top","right","bottom","opacity","transform","LinearProgressDashed","dashed","LinearProgressBar1","bar","bar1Indeterminate","bar1Determinate","bar1Buffer","transition","transformOrigin","LinearProgressBar2","bar2Indeterminate","bar2Buffer","LinearProgress","valueBuffer","bar1","bar2","rootProps","inlineStyles","round","direction","getLinearProgressUtilityClass","linearProgressClasses","getTabUtilityClass","TabRoot","ButtonBase","label","icon","labelIcon","textColor","fullWidth","wrapped","button","maxWidth","minWidth","minHeight","padding","iconPosition","paddingTop","paddingBottom","marginBottom","disabledOpacity","text","secondary","primary","disabled","flexGrow","flexBasis","disableFocusRipple","iconProp","indicator","onChange","onClick","onFocus","selected","selectionFollowsFocus","iconWrapper","focusRipple","event","tabIndex","Box","module","e","n","r","i","s","u","a","o","f","h","c","$","l","y","M","weekdays","split","months","m","String","Array","join","g","z","utcOffset","abs","floor","date","year","month","clone","add","ceil","p","w","D","ms","Q","toLowerCase","replace","v","S","args","arguments","O","locale","$L","utc","$u","x","$x","$offset","this","parse","prototype","$d","Date","NaN","test","match","substring","UTC","init","$y","getFullYear","$M","getMonth","$D","getDate","$W","getDay","$H","getHours","$m","getMinutes","$s","getSeconds","$ms","getMilliseconds","$utils","isValid","toString","isSame","startOf","endOf","isAfter","isBefore","$g","set","unix","valueOf","getTime","toDate","apply","$locale","weekStart","$set","daysInMonth","get","Number","subtract","format","invalidDate","meridiem","YY","YYYY","MM","MMM","monthsShort","MMMM","DD","dd","weekdaysMin","ddd","weekdaysShort","dddd","H","HH","hh","A","mm","ss","SSS","Z","getTimezoneOffset","diff","toJSON","toISOString","toUTCString","T","forEach","extend","$i","isDayjs","en","Ls","years","days","hours","minutes","seconds","milliseconds","weeks","$l","negative","parseFromMilliseconds","Object","keys","calMilliseconds","reduce","Y","humanize","fromNow","asMilliseconds","asSeconds","asMinutes","asHours","asDays","asWeeks","asMonths","asYears","duration","isDuration","bind","hasOwn","hasOwnProperty","toStr","defineProperty","gOPD","getOwnPropertyDescriptor","isArray","arr","call","isPlainObject","obj","key","hasOwnConstructor","hasIsPrototypeOf","constructor","setProperty","target","options","enumerable","configurable","newValue","writable","getProperty","copy","copyIsArray","deep","COMMENT_REGEX","NEWLINE_REGEX","WHITESPACE_REGEX","PROPERTY_REGEX","COLON_REGEX","VALUE_REGEX","SEMICOLON_REGEX","TRIM_REGEX","EMPTY_STRING","trim","str","TypeError","lineno","column","updatePosition","lines","lastIndexOf","start","line","node","Position","whitespace","end","source","errorsList","msg","err","Error","reason","filename","silent","push","re","exec","comments","rules","comment","pos","charAt","type","declaration","prop","val","ret","property","decl","decls","declarations","isBuffer","ReactPropTypesSecret","emptyFunction","emptyFunctionWithReset","resetWarningCache","shim","propName","componentName","location","propFullName","secret","getShim","isRequired","ReactPropTypes","array","bigint","bool","func","number","object","string","symbol","any","arrayOf","element","elementType","instanceOf","objectOf","oneOf","oneOfType","exact","checkPropTypes","PropTypes","b","Symbol","for","k","q","$$typeof","ContextConsumer","ContextProvider","Element","ForwardRef","Fragment","Lazy","Memo","Portal","Profiler","StrictMode","Suspense","SuspenseList","isAsyncMode","isConcurrentMode","isContextConsumer","isContextProvider","isElement","isForwardRef","isFragment","isLazy","isMemo","isPortal","isProfiler","isStrictMode","isSuspense","isSuspenseList","isValidElementType","getModuleId","typeOf","iterator","output","hasIterator","len","stringifyPosition","point","VFileMessage","place","origin","parts","super","message","stack","fatal","ruleId","actual","expected","file","url","note","path","basename","ext","assertPath","seenNonSlash","charCodeAt","firstNonSlashEnd","extIndex","dirname","unmatchedSlash","extname","startPart","startDot","preDotState","code","segments","joined","absolute","allowAboveRoot","lastSlashIndex","result","lastSegmentLength","lastSlash","dots","normalizeString","normalize","sep","JSON","stringify","proc","cwd","isUrl","fileURLOrPath","href","urlToPath","URL","protocol","hostname","pathname","third","decodeURIComponent","getPathFromURLPosix","order","VFile","data","messages","history","stored","includes","assertNonEmpty","assertPart","stem","encoding","info","fail","part","bail","getPrototypeOf","toStringTag","trough","fns","pipeline","run","values","middlewareIndex","callback","pop","next","fn","middleware","called","parameters","fnExpectsCallback","done","exception","Promise","then","wrap","use","middelware","unified","base","transformers","attachers","frozen","namespace","freezeIndex","processor","assertUnfrozen","own","Parser","Compiler","freeze","attacher","transformer","POSITIVE_INFINITY","settings","addPlugin","addList","addPreset","assign","plugin","plugins","entry","doc","vfile","assertParser","newable","assertCompiler","assertNode","compile","executor","resolve","reject","tree","runSync","complete","assertDone","process","processSync","destination","asyncName","Boolean","looksLikeAVFile","one","includeImageAlt","splice","list","remove","items","chunkStart","from","unshift","syntaxExtension","all","extension","hook","constructs","existing","before","asciiAlpha","regexCheck","asciiDigit","asciiHexDigit","asciiAlphanumeric","asciiPunctuation","asciiAtext","asciiControl","markdownLineEndingOrSpace","markdownLineEnding","markdownSpace","unicodeWhitespace","unicodePunctuation","regex","fromCharCode","factorySpace","effects","ok","limit","enter","prefix","consume","exit","tokenize","contentStart","attempt","parser","contentInitial","lineStart","previous","token","contentType","self","childFlow","childToken","lineStartOffset","continued","item","containerState","continuation","documentContinue","checkNewContainers","_closeFlow","closeFlow","indexBeforeExits","events","indexBeforeFlow","exitContainers","documentContinued","currentConstruct","concrete","flowStart","interrupt","_gfmTableDynamicInterruptHack","check","containerConstruct","thereIsANewContainer","thereIsNoNewContainer","lazy","now","offset","containerContinue","flow","_tokenizer","flowContinue","writeToChild","eof","stream","sliceStream","defineSkip","write","seen","nok","document","disable","null","blankLine","partial","subtokenize","jumps","lineIndex","otherIndex","otherEvent","subevents","more","_isInFirstContentOfListItem","subcontent","_container","eventIndex","context","startPosition","startPositions","tokenizer","childEvents","gaps","current","adjust","breaks","_gfmTasklistFirstContentOfListItem","contentEnd","continuationConstruct","contentContinue","prefixed","tail","sliceSerialize","initial","flowInitial","afterConstruct","resolver","resolveAll","createResolver","initializeFactory","field","notText","atBreak","resolveAllLineSuffixes","extraResolver","chunks","tabs","bufferIndex","chunk","_index","_bufferIndex","createTokenizer","initialize","columnStart","resolveAllConstructs","consumed","accountForPotentialSkip","fields","constructFactory","construct","addResult","onsuccessfulcheck","expandTabs","atTab","serializeChunks","expectedCode","state","startIndex","startBufferIndex","endIndex","endBufferIndex","view","sliceChunks","chunkIndex","go","restore","onreturn","returnState","bogusState","listOfConstructs","constructIndex","handleListOfConstructs","def","handleMapOfConstructs","handleConstruct","startPoint","startPrevious","startCurrentConstruct","startEventsIndex","startStack","store","create","resolveTo","thematicBreak","marker","sequence","initialSize","kind","atMarker","inside","onBlank","listItemPrefixWhitespaceConstruct","endOfPrefix","otherPrefix","initialBlankLine","notBlank","furtherBlankLines","notInCurrentItem","indentConstruct","blockQuote","open","after","factoryDestination","literalType","literalMarkerType","rawType","stringType","balance","destinationEnclosedBefore","destinationRaw","destinationEnclosed","destinationEnclosedEscape","destinationRawEscape","factoryLabel","markerType","labelEscape","factoryTitle","atFirstTitleBreak","atTitleBreak","title","titleEscape","factoryWhitespace","normalizeIdentifier","toUpperCase","definition","identifier","labelAfter","titleConstruct","defined","codeIndented","afterStartPrefix","afterPrefix","indentedContent","headingAtx","fenceOpenInside","headingBreak","setextUnderline","paragraph","closingSequence","closingSequenceEnd","heading","htmlBlockNames","htmlRawNames","htmlFlow","startTag","buffer","declarationStart","tagCloseStart","continuationDeclarationInside","tagName","commentOpenInside","cdataOpenInside","basicSelfClosing","completeAttributeNameBefore","completeClosingTagAfter","completeEnd","completeAttributeName","completeAttributeNameAfter","completeAttributeValueBefore","completeAttributeValueQuoted","completeAttributeValueUnquoted","completeAttributeValueQuotedAfter","completeAfter","continuationCommentInside","continuationRawTagOpen","continuationClose","continuationCharacterDataInside","continuationAtLineEnding","nextBlankConstruct","htmlContinueStart","htmlLineEnd","continuationRawEndTag","codeFenced","closingFenceConstruct","closingSequenceStart","sizeOpen","nonLazyLine","initialPrefix","sequenceOpen","infoOpen","openAfter","infoAfter","meta","createElement","decodeNamedCharacterReference","characterReference","innerHTML","char","textContent","numeric","characterEscape","lineEnding","labelEnd","labelStart","_balanced","_inactive","balanced","afterLabelEnd","resourceConstruct","fullReferenceConstruct","collapsedReferenceConstruct","close","group","insideSpan","destinationAfter","between","afterLabel","labelStartImage","classifyCharacter","attention","attentionMarkers","_open","_close","openingSequence","nextEvents","movePoint","autolink","schemeOrEmailAtext","emailAtext","schemeInsideOrEmailAtext","urlInside","emailAtSignOrDot","emailLabel","emailValue","htmlText","declarationOpen","instruction","tagOpen","commentOpen","cdataOpen","commentStart","commentStartDash","commentClose","atLineEnding","cdata","cdataClose","cdataEnd","instructionClose","tagClose","tagCloseBetween","tagOpenBetween","tagOpenAttributeName","tagOpenAttributeNameAfter","tagOpenAttributeValueBefore","tagOpenAttributeValueQuoted","tagOpenAttributeValueUnquoted","tagOpenAttributeValueQuotedAfter","labelStartLink","hardBreakEscape","codeText","gap","tailExitIndex","headEnterIndex","extensions","combineExtensions","concat","search","decodeNumericCharacterReference","parseInt","characterEscapeOrReference","decode","$0","$1","$2","head","hex","fromMarkdown","config","configure","transforms","canContainEols","opener","link","autolinkProtocol","onenterdata","autolinkEmail","atxHeading","codeFlow","codeFencedFenceInfo","codeFencedFenceMeta","codeTextData","codeFlowValue","definitionDestinationString","definitionLabelString","definitionTitleString","emphasis","hardBreak","hardBreakTrailing","html","htmlFlowData","htmlTextData","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","onexitcodefenced","codeFencedFence","onexitcodefencedfence","onexitcodefencedfenceinfo","onexitcodefencedfencemeta","onexitcodeindented","onexitcodetext","onexitdefinitiondestinationstring","onexitdefinitionlabelstring","onexitdefinitiontitlestring","onexithardbreak","onexithtmlflow","onexithtmltext","onexitimage","onexitlabel","labelText","onexitlabeltext","onexitlineending","onexitlink","onexitreferencestring","onexitresourcedestinationstring","onexitresourcetitlestring","resource","onexitresource","onexitsetextheading","setextHeadingLineSequence","onexitsetextheadinglinesequence","setextHeadingText","onexitsetextheadingtext","mdastExtensions","tokenStack","listStack","resume","setData","getData","prepareList","handler","defaultOnError","firstBlankLineIndex","containerBalance","listSpread","tailIndex","tailEvent","_spread","and","errorHandler","onExitError","lang","depth","parent","referenceType","ancestor","decodeString","fragment","ordered","spread","checked","compiler","postprocess","atCarriageReturn","endPosition","lastIndex","preprocess","combined","convert","castFactory","typeFactory","tests","checks","anyFactory","propsFactory","visitParents","visitor","is","step","factory","parents","visit","subresult","grandparents","toResult","pointStart","pointEnd","clean","unknown","augment","handlers","passThrough","returnNode","unknownHandler","nodes","normalizeUri","skip","encodeURIComponent","loose","footnoteReference","id","safeId","footnoteOrder","counter","footnoteCounts","reuseCounter","clobberPrefix","dataFootnoteRef","ariaDescribedBy","revert","subtype","suffix","contents","listItemLoose","trimLine","codePointAt","blockquote","break","delete","footnote","footnoteById","no","dangerous","imageReference","inlineCode","linkReference","listLoose","properties","table","rows","align","out","cellIndex","cell","last","trimLines","toml","ignore","yaml","footnoteDefinition","allowDangerousHtml","footnoteLabel","footnoteLabelTagName","footnoteLabelProperties","footnoteBackLabel","cache","definitions","hName","hProperties","hChildren","ctx","toHast","foot","listItems","referenceIndex","backReferences","backReference","dataFootnoteBackref","ariaLabel","tailTail","dataFootnotes","footer","bridge","mutate","Schema","normal","space","merge","Info","attribute","boolean","booleanish","overloadedBoolean","commaSeparated","spaceSeparated","commaOrSpaceSeparated","mustUseProperty","powers","increment","DefinedInfo","mask","mark","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","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","acceptcharset","classname","htmlfor","httpequiv","abbr","accept","acceptCharset","accessKey","allow","allowFullScreen","allowPaymentRequest","allowUserMedia","async","autoCapitalize","autoComplete","autoFocus","autoPlay","capture","charSet","cite","cols","colSpan","contentEditable","controls","controlsList","coords","dateTime","decoding","defer","dir","dirName","download","draggable","encType","enterKeyHint","form","formAction","formEncType","formMethod","formNoValidate","formTarget","headers","hidden","high","hrefLang","htmlFor","httpEquiv","imageSizes","imageSrcSet","inputMode","integrity","isMap","itemId","itemProp","itemRef","itemScope","itemType","language","loading","loop","low","manifest","maxLength","method","minLength","multiple","muted","nonce","noModule","noValidate","onAbort","onAfterPrint","onAuxClick","onBeforePrint","onBeforeUnload","onBlur","onCancel","onCanPlay","onCanPlayThrough","onClose","onContextLost","onContextMenu","onContextRestored","onCopy","onCueChange","onCut","onDblClick","onDrag","onDragEnd","onDragEnter","onDragExit","onDragLeave","onDragOver","onDragStart","onDrop","onDurationChange","onEmptied","onEnded","onError","onFormData","onHashChange","onInput","onInvalid","onKeyDown","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","onSecurityPolicyViolation","onSeeked","onSeeking","onSelect","onSlotChange","onStalled","onStorage","onSubmit","onSuspend","onTimeUpdate","onToggle","onUnhandledRejection","onUnload","onVolumeChange","onWaiting","onWheel","optimum","pattern","ping","placeholder","playsInline","poster","preload","readOnly","rel","required","reversed","rowSpan","sandbox","scope","scoped","seamless","span","spellCheck","srcDoc","srcLang","translate","typeMustMatch","useMap","aLink","archive","axis","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","version","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","fillOpacity","fillRule","floodColor","floodOpacity","fontSizeAdjust","fontStretch","fontStyle","fontVariant","fontWeight","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","onShow","onZoom","overlinePosition","overlineThickness","paintOrder","panose1","renderingIntent","shapeRendering","stopColor","stopOpacity","strikethroughPosition","strikethroughThickness","strokeDashArray","strokeDashOffset","strokeLineCap","strokeLineJoin","strokeMiterLimit","strokeOpacity","strokeWidth","textAnchor","textDecoration","textRendering","underlinePosition","underlineThickness","unicodeBidi","unicodeRange","unitsPerEm","vAlphabetic","vHanging","vIdeographic","vMathematical","vectorEffect","vertAdvY","vertOriginX","vertOriginY","wordSpacing","writingMode","xHeight","playbackOrder","timelineBegin","about","accumulate","additive","alphabetic","amplitude","ascent","attributeName","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","fill","filterRes","filterUnits","focusable","focusHighlight","fr","fx","fy","g1","g2","glyphRef","gradientTransform","gradientUnits","hanging","hatchContentUnits","hatchUnits","ideographic","initialVisibility","in","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","restart","rotate","rx","ry","scale","seed","side","slope","snapshotTime","specularConstant","specularExponent","spreadMethod","startOffset","stdDeviation","stemh","stemv","stitchTiles","stroke","surfaceScale","syncBehavior","syncBehaviorDefault","syncMaster","syncTolerance","syncToleranceDefault","systemLanguage","tableValues","targetX","targetY","textLength","transformBehavior","to","u1","u2","unicode","viewBox","viewTarget","visibility","widths","x1","x2","xChannelSelector","y1","y2","yChannelSelector","zoomAndPan","rehypeFilter","allowedElements","disallowedElements","allowElement","parent_","unwrapDisallowed","protocols","thing","valid","dash","cap","kebab","camelcase","hastToReact","tableElements","Set","childrenToReact","childIndex","toReact","has","skipHtml","parentSchema","schema","addProperty","listDepth","components","basic","linkTarget","transformLinkUri","inline","level","transformImageUri","input","getInputElement","getElementsBeforeCount","isHeader","sourcePos","rawSourcePos","sourcePosition","includeElementIndex","siblingCount","count","Type","rest","dashes","find","padRight","padLeft","styleReplacer","parseStyle","deprecated","renderers","astPlugins","escapeHtml","allowNode","allowedTypes","disallowedTypes","includeNodeIndex","ReactMarkdown","deprecation","console","warn","remarkPlugins","remarkRehypeOptions","rehypePlugins","hastNode","defaultProps","uri","first","colon","propTypes"],"sourceRoot":""}