{"version":3,"file":"static/js/2075_049dd953400afb12f4a0.js","mappings":"2OAQWA,EAUAC,EAMAC,E,YAfX,SAAWF,GACPA,EAAkBA,EAAwB,KAAI,GAAK,OACnDA,EAAkBA,EAA0B,OAAI,GAAK,SACrDA,EAAkBA,EAAyB,MAAI,GAAK,QACpDA,EAAkBA,EAAwB,KAAI,GAAK,MACtD,CALD,CAKGA,IAAsBA,EAAoB,CAAC,IAK9C,SAAWC,GACPA,EAAgBA,EAAsB,KAAI,GAAK,OAC/CA,EAAgBA,EAAwB,OAAI,GAAK,SACjDA,EAAgBA,EAAuB,MAAI,GAAK,OACnD,CAJD,CAIGA,IAAoBA,EAAkB,CAAC,IAE1C,SAAWC,GACPA,EAAwBA,EAA8B,KAAI,GAAK,OAC/DA,EAAwBA,EAA+B,MAAI,GAAK,QAChEA,EAAwBA,EAA8B,KAAI,GAAK,OAC/DA,EAAwBA,EAA8B,KAAI,GAAK,MAClE,CALD,CAKGA,IAA4BA,EAA0B,CAAC,IACnD,MAAMC,EACT,sBAAIC,GACA,OAAOC,KAAKC,qBAAuB,UAAYD,KAAKE,UACxD,CAIA,WAAAC,CAAYC,GACRJ,KAAKK,oCAAiCC,EACtCN,KAAKO,QAAUC,KAAKC,IAAI,EAAiB,EAAdL,EAAIG,SACR,YAAnBH,EAAIF,YACJF,KAAKE,WAAaF,KAAKO,QACvBP,KAAKC,sBAAuB,IAG5BD,KAAKE,WAAaM,KAAKC,IAAI,EAAoB,EAAjBL,EAAIF,YAClCF,KAAKC,sBAAuB,GAEhCD,KAAKU,aAAeC,QAAQP,EAAIM,cAChCV,KAAKY,WAA8B,EAAjBR,EAAIQ,WACtBZ,KAAKa,mBAAqBF,QAAQP,EAAIS,oBACtCb,KAAKc,+BAAiCV,EAAIU,8BAC9C,CAIA,MAAAC,CAAOC,GACH,OAAQhB,KAAKO,UAAYS,EAAMT,SACxBP,KAAKC,uBAAyBe,EAAMf,sBACpCD,KAAKE,aAAec,EAAMd,YAC1BF,KAAKU,eAAiBM,EAAMN,cAC5BV,KAAKY,aAAeI,EAAMJ,YAC1BZ,KAAKa,qBAAuBG,EAAMH,qBAClC,QAAOb,KAAKc,+BAAgCE,EAAMF,+BAC7D,CAIA,iBAAAG,CAAkBC,GACd,MAAO,CACHX,QAASP,KAAKO,UAAYW,EAAQX,QAClCL,WAAYF,KAAKE,aAAegB,EAAQhB,WACxCQ,aAAcV,KAAKU,eAAiBQ,EAAQR,aAC5CG,mBAAoBb,KAAKa,qBAAuBK,EAAQL,mBAEhE,EAEG,MAAMM,EAIT,WAAAhB,CAAYiB,EAAOC,GACfrB,KAAKsB,qBAAkBhB,EACvBN,KAAKoB,MAAQA,EACbpB,KAAKqB,QAAUA,CACnB,EAKG,SAASE,EAAgBC,GAC5B,OAAQA,GAA2B,mBAAbA,EAAIC,IAC9B,CAIO,MAAMC,EACT,WAAAvB,CAAYwB,EAAYP,EAAOQ,EAAMC,EAAkBC,EAAsBC,GACzE/B,KAAK2B,WAAaA,EAClB3B,KAAKoB,MAAQA,EACbpB,KAAK4B,KAAOA,EACZ5B,KAAK6B,iBAAmBA,EACxB7B,KAAK8B,qBAAuBA,EAC5B9B,KAAK+B,WAAaA,CACtB,EAKG,MAAMC,EACT,WAAA7B,CAAY8B,EAAOC,EAAgBC,GAC/BnC,KAAKiC,MAAQA,EACbjC,KAAKkC,eAAiBA,EACtBlC,KAAKmC,aAAeA,CACxB,EAKG,MAAMC,EACT,WAAAjC,CAAYkC,EAAcC,EAASC,GAC/BvC,KAAKqC,aAAeA,EACpBrC,KAAKsC,QAAUA,EACftC,KAAKuC,8BAAgCA,CACzC,EAKG,SAASC,EAAuBC,GACnC,OAASA,EAAMC,yBAA2BD,EAAME,iBACpD,C,iMCrHO,MAAMC,UAAyB,KAClC,iBAAAC,CAAkBC,GACd,OAAO9C,KAAK+C,SAASF,kBAAkBC,EAC3C,CACA,WAAA3C,CAAY6C,EAAWC,GAUnB,GATAC,QACAlD,KAAKgD,UAAYA,EACjBhD,KAAKiD,yBAA2BA,EAChCjD,KAAKmD,iBAAmB,IAAI,KAC5BnD,KAAKoD,iBAAmB,IAAI,KAC5BpD,KAAK+C,SAAW,IAAI,IAA8B/C,KAAKoD,iBAAkBpD,KAAKiD,0BAC9EjD,KAAKqD,YAAcrD,KAAKmD,iBAAiBG,MACzCtD,KAAKuD,0CAA4C,GACjDvD,KAAKwD,gBAAkB,GAClBR,EAAUS,aAAaC,UAMoC,IAAvDV,EAAUS,aAAaE,6BAG5B3D,KAAK4D,6BAA0BtD,EAC/BN,KAAK6D,cAAgB7D,KAAK8D,4BAA4B,QAAIxD,GAAW,KAIrEN,KAAK4D,wBAA0B5D,KAAK8D,4BAA4B,QAAIxD,GAAW,GAC/EN,KAAK6D,cAAgB7D,KAAK4D,6BAfS,CACnC,MAAMb,EAAW/C,KAAK+C,SAASgB,+BAA+B/D,KAAKgD,UAAUgB,iBACvEC,EAAY,IAAI,IAAcjE,KAAKgD,UAAUkB,WAAYnB,GAC/D/C,KAAK4D,yBAA0B,OAAcK,EAAW,QAAI3D,GAAW,GACvEN,KAAK6D,cAAgB7D,KAAK4D,uBAC9B,CAYJ,CAEA,0CAAAO,GACI,GAAgE,IAA5DnE,KAAKgD,UAAUS,aAAaE,4BAA+E,CAC3G,MAAMS,OAAgD9D,IAAjCN,KAAK4D,wBAE1B5D,KAAK4D,6BAA0BtD,EAC1B8D,GACDpE,KAAKmD,iBAAiBkB,MAE9B,CACJ,CACA,qBAAAC,EAAsB,OAAEC,IACpB,MAAMC,EAAQD,EAAOE,KAAIC,GAAK,IAAI,KAAa,QAASA,EAAEC,eAAiB,EAAG,IAAI,QAASD,EAAEE,aAAc,IAAI,QAASF,EAAEE,aAAeF,EAAEC,eAAiB,EAAG,MAC/J3E,KAAK6E,YAAYL,GAAO,GACnBxE,KAAK4D,yBACN5D,KAAKmD,iBAAiBkB,MAE9B,CACA,oBAAAS,CAAqBC,GACjB,MAAMP,EAAQ,4BAAqCO,EAAOzC,SAC1DtC,KAAK6E,YAAYL,GAAO,EAC5B,CACA,WAAAK,CAAYL,EAAOQ,GAEf,MAAMC,GAAS,EAAAC,EAAA,GAAqBlF,KAAKwD,gBAAiBgB,GAC1DxE,KAAKwD,gBAAkByB,EACnBjF,KAAK4D,0BAA4BoB,IACjChF,KAAKuD,2CAA4C,EAAA2B,EAAA,GAAqBlF,KAAKuD,0CAA2CiB,GAE9H,CAEA,UAAAW,GACQnF,KAAKwD,gBAAgB4B,OAAS,IAC9BpF,KAAK6D,cAAgB7D,KAAK8D,4BAA4B9D,KAAKwD,gBAAiBxD,KAAK6D,eAAe,GAChG7D,KAAKwD,gBAAkB,IAEvBxD,KAAKuD,0CAA0C6B,OAAS,IACpDpF,KAAK4D,0BACL5D,KAAK4D,wBAA0B5D,KAAK8D,4BAA4B9D,KAAKuD,0CAA2CvD,KAAK4D,yBAAyB,IAElJ5D,KAAKuD,0CAA4C,GAEzD,CAIA,2BAAAO,CAA4BU,EAAOa,EAAaC,GAE5C,MACMC,EAAgHF,EAChHpB,EAAY,IAAI,KAAoBjE,KAAKgD,UAAWhD,KAAK+C,UAE/D,OADe,OAAckB,EAAWO,EAAOe,EAAkBD,EAErE,CACA,kBAAAE,CAAmBpE,EAAOqE,GACtBzF,KAAKmF,aACL,MAAMO,GAAc,QAAStE,EAAMuE,gBAAkB,EAAGvE,EAAMwE,YAAc,GACtEC,GAAY,QAASzE,EAAM0E,cAAgB,EAAG1E,EAAM2E,UAAY,GACtE,OAAO,IAAI,MAAiBC,IACxB,MAAMC,EAAOjG,KAAK4D,yBAA2B5D,KAAK6D,cAClDqC,EAAgBD,EAAM,KAAYA,EAAKb,OAAQM,EAAaG,EAAWG,EAAI,EAAG,EAAG,IAAIG,IAAOV,EAAsB,GAE1H,CACA,sBAAAW,CAAuBhF,EAAOiF,GAC1BrG,KAAKmF,aACL,MAAMmB,GAAc,QAAiBlF,EAAMmF,oBACrCC,GAAY,QAAiBpF,EAAMqF,kBACzC,OAAO,IAAI,MAAiBT,IACxB,MAAMC,EAAOjG,KAAK4D,yBAA2B5D,KAAK6D,cAC5C6C,EAAU,IAAIC,EAA2BX,EAAIK,EAAuBrG,KAAKgD,WAC/E4D,EAAoBX,EAAM,KAAYA,EAAKb,OAAQkB,EAAaE,EAAWE,EAAS,EAAG,IAAIP,IAAM,GAEzG,CACA,oBAAAU,CAAqBC,GACjB9G,KAAKmF,aACL,MAAMc,EAAOjG,KAAK4D,yBAA2B5D,KAAK6D,cAClD,OAAOgD,EAAqBZ,EAAM,KAAYA,EAAKb,QAAQ,QAAiB0B,GAChF,CACA,qBAAAC,CAAsBD,GAClB9G,KAAKmF,aACL,MAAMc,EAAOjG,KAAK4D,yBAA2B5D,KAAK6D,cAClD,OAAOkD,EAAsBd,EAAM,KAAYA,EAAKb,QAAQ,QAAiB0B,GACjF,EAEJ,SAASC,EAAsBd,EAAMe,EAAiBC,EAAeH,GACjE,GAAkB,IAAdb,EAAKiB,MAAmD,IAAdjB,EAAKiB,KAAmC,CAClF,MAAMC,EAAU,GAChB,IAAK,MAAMC,KAASnB,EAAKoB,SACrBJ,GAAgB,QAAUD,EAAiBI,EAAMhC,QACjD+B,EAAQG,KAAK,CAAEN,kBAAiBC,kBAChCD,EAAkBC,EAEtB,IAAK,IAAIM,EAAIJ,EAAQ/B,OAAS,EAAGmC,GAAK,EAAGA,IAAK,CAC1C,MAAM,gBAAEP,EAAe,cAAEC,GAAkBE,EAAQI,GACnD,IAAI,QAAeP,EAAiBF,GAAW,CAC3C,MAAM7B,EAAS8B,EAAsBd,EAAKoB,SAASE,GAAIP,EAAiBC,EAAeH,GACvF,GAAI7B,EACA,OAAOA,CAEf,CACJ,CACA,OAAO,IACX,CACK,GAAkB,IAAdgB,EAAKiB,KACV,OAAO,KAEN,GAAkB,IAAdjB,EAAKiB,KAAsC,CAChD,MAAM9F,GAAQ,QAAe4F,EAAiBC,GAC9C,MAAO,CACHO,YAAavB,EAAKuB,YAClBpG,QAER,CACA,OAAO,IACX,CACA,SAASyF,EAAqBZ,EAAMe,EAAiBC,EAAeH,GAChE,GAAkB,IAAdb,EAAKiB,MAAmD,IAAdjB,EAAKiB,KAAmC,CAClF,IAAK,MAAME,KAASnB,EAAKoB,SAAU,CAE/B,GADAJ,GAAgB,QAAUD,EAAiBI,EAAMhC,SAC7C,QAAe0B,EAAUG,GAAgB,CACzC,MAAMhC,EAAS4B,EAAqBO,EAAOJ,EAAiBC,EAAeH,GAC3E,GAAI7B,EACA,OAAOA,CAEf,CACA+B,EAAkBC,CACtB,CACA,OAAO,IACX,CACK,GAAkB,IAAdhB,EAAKiB,KACV,OAAO,KAEN,GAAkB,IAAdjB,EAAKiB,KAAsC,CAChD,MAAM9F,GAAQ,QAAe4F,EAAiBC,GAC9C,MAAO,CACHO,YAAavB,EAAKuB,YAClBpG,QAER,CACA,OAAO,IACX,CACA,SAAS8E,EAAgBD,EAAMe,EAAiBC,EAAevB,EAAaG,EAAWyB,EAAMG,EAAOC,EAAgCC,EAAqBlC,EAAuBmC,GAAyB,GACrM,GAAIH,EAAQ,IACR,OAAO,EAEXI,EAAW,OACP,OAAQ5B,EAAKiB,MACT,KAAK,EAA0B,CAC3B,MAAMY,EAAa7B,EAAK8B,eACxB,IAAK,IAAIR,EAAI,EAAGA,EAAIO,EAAYP,IAAK,CACjC,MAAMH,EAAQnB,EAAK+B,SAAST,GAC5B,GAAKH,EAAL,CAIA,GADAH,GAAgB,QAAUD,EAAiBI,EAAMhC,SAC7C,QAAoB4B,EAAiBnB,KACrC,QAAuBoB,EAAevB,GAAc,CAEpD,IAD0B,QAAuBuB,EAAepB,GACzC,CAEnBI,EAAOmB,EACP,SAASS,CACb,CAEA,IADuB3B,EAAgBkB,EAAOJ,EAAiBC,EAAevB,EAAaG,EAAWyB,EAAMG,EAAO,EAAGE,EAAqBlC,GAEvI,OAAO,CAEf,CACAuB,EAAkBC,CAflB,CAgBJ,CACA,OAAO,CACX,CACA,KAAK,EAA0B,CAC3B,MAAMgB,GAAYxC,IAA0BQ,EAAKiC,gBAAkBjC,EAAKiC,eAAeV,YAAYW,gBAAgBlC,EAAKmC,eAAeZ,aACvI,IAAIa,EAAkB,EACtB,GAAIV,EAAqB,CACrB,IAAIW,EAAWX,EAAoBY,IAAItC,EAAKmC,eAAexG,WAC1CtB,IAAbgI,IACAA,EAAW,GAEfD,EAAkBC,EACdL,IACAK,IACAX,EAAoBa,IAAIvC,EAAKmC,eAAexG,KAAM0G,GAE1D,CACA,MAAMR,EAAa7B,EAAK8B,eACxB,IAAK,IAAIR,EAAI,EAAGA,EAAIO,EAAYP,IAAK,CACjC,MAAMH,EAAQnB,EAAK+B,SAAST,GAC5B,GAAKH,EAAL,CAIA,GADAH,GAAgB,QAAUD,EAAiBI,EAAMhC,SAC7C,QAAoB4B,EAAiBnB,KACrC,QAAuBoB,EAAevB,GAAc,CAEpD,IAD0B,QAAuBuB,EAAepB,IACxB,IAAfuB,EAAMF,KAAsC,CAGjEjB,EAAOmB,EACHa,GACAR,IACAC,EAAiCW,EAAkB,GAGnDX,EAAiCW,EAErC,SAASR,CACb,CACA,GAAII,GAA2B,IAAfb,EAAMF,OAAyCjB,EAAKiC,eAAgB,CAEhF,IADuBhC,EAAgBkB,EAAOJ,EAAiBC,EAAevB,EAAaG,EAAWyB,EAAMW,EAAWR,EAAQ,EAAIA,EAAOQ,EAAWI,EAAkB,EAAIA,EAAiBV,EAAqBlC,GAAwBQ,EAAKiC,gBAE1O,OAAO,CAEf,CACJ,CACAlB,EAAkBC,CAzBlB,CA0BJ,CAEA,OADAU,SAA0EA,EAAoBa,IAAIvC,EAAKmC,eAAexG,KAAMyG,IACrH,CACX,CACA,KAAK,EAA8C,CAC/C,MAAMjH,GAAQ,QAAe4F,EAAiBC,GAC9C,OAAOK,EAAK,IAAI,KAAYlG,EAAOqG,EAAQ,EAAG,GAAG,GACrD,CACA,KAAK,EAA6B,CAC9B,MAAMrG,GAAQ,QAAe4F,EAAiBC,GAC9C,OAAOK,EAAK,IAAI,KAAYlG,EAAOqG,EAAQ,EAAGC,EAAiC,EAAGE,GACtF,CACA,KAAK,EACD,OAAO,EAGvB,CACA,MAAMjB,EACF,WAAAxG,CAAYmH,EAAMjB,EAAuBrD,GACrChD,KAAKsH,KAAOA,EACZtH,KAAKqG,sBAAwBA,EAC7BrG,KAAKgD,UAAYA,CACrB,EAEJ,SAAS4D,EAAoBX,EAAMe,EAAiBC,EAAevB,EAAaG,EAAWa,EAASe,EAAOE,GACvG,IAAIc,EACJ,GAAIhB,EAAQ,IACR,OAAO,EAEX,IAAIiB,GAAiB,EACrB,GAAkB,IAAdzC,EAAKiB,KAAmC,CACxC,IAAImB,EAAkB,EACtB,GAAIV,EAAqB,CACrB,IAAIW,EAAWX,EAAoBY,IAAItC,EAAKmC,eAAexG,WAC1CtB,IAAbgI,IACAA,EAAW,GAEfD,EAAkBC,EAClBA,IACAX,EAAoBa,IAAIvC,EAAKmC,eAAexG,KAAM0G,EACtD,CACA,MAAMK,GAAoB,QAAU3B,EAAiBf,EAAKmC,eAAehD,QACzE,IAAIwD,GAAkB,EAQtB,GAPIlC,EAAQL,wBACRuC,EAAiB3C,EAAK4C,sBAAsB7B,EAAiBN,EAAQ1D,YAEzE0F,EAAiBhC,EAAQY,KAAK,IAAI,MAAkC,QAAeN,EAAiBC,IAAgB,QAAeD,EAAiB2B,GAAoB1C,EAAKiC,gBACvK,SAAe,QAAUS,GAA0C,QAArBF,EAAKxC,EAAKmB,aAA0B,IAAPqB,OAAgB,EAASA,EAAGrD,SAAW,MAAa6B,QAC/H3G,EAAWmH,EAAOY,EAAiBpC,EAAM2C,IAC/C5B,EAAkB2B,EACdD,GAAkBzC,EAAKmB,MAAO,CAC9B,MAAMA,EAAQnB,EAAKmB,MAEnB,GADAH,GAAgB,QAAUD,EAAiBI,EAAMhC,SAC7C,QAAoB4B,EAAiBnB,KACrC,QAAuBoB,EAAevB,KACtCgD,EAAiB9B,EAAoBQ,EAAOJ,EAAiBC,EAAevB,EAAaG,EAAWa,EAASe,EAAQ,EAAGE,IACnHe,GACD,OAAO,CAGnB,CACAf,SAA0EA,EAAoBa,IAAIvC,EAAKmC,eAAexG,KAAMyG,EAChI,KACK,CACD,IAAIS,EAAY9B,EAChB,IAAK,MAAMI,KAASnB,EAAKoB,SAAU,CAC/B,MAAM0B,EAAcD,EAEpB,GADAA,GAAY,QAAUA,EAAW1B,EAAMhC,SACnC,QAAoB2D,EAAalD,KACjC,QAAoBH,EAAaoD,KACjCJ,EAAiB9B,EAAoBQ,EAAO2B,EAAaD,EAAWpD,EAAaG,EAAWa,EAASe,EAAOE,IACvGe,GACD,OAAO,CAGnB,CACJ,CACA,OAAOA,CACX,CC3UO,MAAMM,UAAkC,KAC3C,eAAIC,GAEA,OAAOjJ,KAAKgD,UAAUkG,kBAD6B,GAEvD,CACA,WAAA/I,CAAY6C,EAAWmG,GACnBjG,QACAlD,KAAKgD,UAAYA,EACjBhD,KAAKmJ,6BAA+BA,EACpCnJ,KAAKoJ,iBAAmBpJ,KAAKqJ,UAAU,IAAI,MAC3CrJ,KAAKsJ,mBAAqB,IAAI,KAC9BtJ,KAAKqD,YAAcrD,KAAKsJ,mBAAmBhG,MAC3CtD,KAAKuJ,mBAAoB,EACzBvJ,KAAKqJ,UAAUrJ,KAAKmJ,6BAA6B9F,aAAYmG,IACzD,IAAIf,EACCe,EAAE1G,cAAsD,QAAtC2F,EAAKzI,KAAKoJ,iBAAiBK,aAA0B,IAAPhB,OAAgB,EAASA,EAAGiB,OAAO7G,kBAAkB2G,EAAE1G,eACxH9C,KAAKoJ,iBAAiBO,QACtB3J,KAAK4J,yBACT,IAER,CAEA,sBAAAC,CAAuBL,GACnBxJ,KAAKoJ,iBAAiBO,QACtB3J,KAAK4J,wBACT,CACA,uBAAAE,CAAwBN,GACpBxJ,KAAKoJ,iBAAiBO,QACtB3J,KAAK4J,wBACT,CACA,sBAAAG,CAAuBhF,GACnB,IAAI0D,EACmC,QAAtCA,EAAKzI,KAAKoJ,iBAAiBK,aAA0B,IAAPhB,GAAyBA,EAAGiB,OAAO5E,qBAAqBC,EAC3G,CACA,0CAAAZ,GACI,IAAIsE,EACmC,QAAtCA,EAAKzI,KAAKoJ,iBAAiBK,aAA0B,IAAPhB,GAAyBA,EAAGiB,OAAOvF,4CACtF,CACA,qBAAAG,CAAsBkF,GAClB,IAAIf,EACmC,QAAtCA,EAAKzI,KAAKoJ,iBAAiBK,aAA0B,IAAPhB,GAAyBA,EAAGiB,OAAOpF,sBAAsBkF,EAC5G,CAEA,sBAAAI,GACI,GAAI5J,KAAKuJ,mBAAqBvJ,KAAKiJ,aAC/B,IAAKjJ,KAAKoJ,iBAAiBK,MAAO,CAC9B,MAAMO,EAAQ,IAAI,KAClBhK,KAAKoJ,iBAAiBK,OA4nBTC,EA5nBqCM,EAAMC,IAAI,IAAIrH,EAAiB5C,KAAKgD,WAAYF,GACvF9C,KAAKmJ,6BAA6BlG,yBAAyBH,MA2nBjDoH,EA1nBhBF,EA2nBV,CACHN,SACAS,QAAS,IAAMD,aAA+C,EAASA,EAAWC,YA5nB1EH,EAAMC,IAAIjK,KAAKoJ,iBAAiBK,MAAMC,OAAOrG,aAAYmG,GAAKxJ,KAAKsJ,mBAAmBjF,KAAKmF,MAC3FxJ,KAAKsJ,mBAAmBjF,MAC5B,OAGIrE,KAAKoJ,iBAAiBK,QACtBzJ,KAAKoJ,iBAAiBO,QAEtB3J,KAAKsJ,mBAAmBjF,QAinBxC,IAA6BqF,EAAQQ,CA9mBjC,CAKA,sBAAA9D,CAAuBhF,GACnB,IAAIqH,EAGJ,OAFAzI,KAAKuJ,mBAAoB,EACzBvJ,KAAK4J,0BAC0C,QAAtCnB,EAAKzI,KAAKoJ,iBAAiBK,aAA0B,IAAPhB,OAAgB,EAASA,EAAGiB,OAAOtD,uBAAuBhF,GAAO,KAAW,UACvI,CACA,wCAAAgJ,CAAyChJ,GACrC,IAAIqH,EAGJ,OAFAzI,KAAKuJ,mBAAoB,EACzBvJ,KAAK4J,0BAC0C,QAAtCnB,EAAKzI,KAAKoJ,iBAAiBK,aAA0B,IAAPhB,OAAgB,EAASA,EAAGiB,OAAOtD,uBAAuBhF,GAAO,KAAU,UACtI,CACA,kBAAAoE,CAAmBpE,EAAOqE,GAAwB,GAC9C,IAAIgD,EAGJ,OAFAzI,KAAKuJ,mBAAoB,EACzBvJ,KAAK4J,0BAC0C,QAAtCnB,EAAKzI,KAAKoJ,iBAAiBK,aAA0B,IAAPhB,OAAgB,EAASA,EAAGiB,OAAOlE,mBAAmBpE,EAAOqE,KAA2B,UACnJ,CACA,qBAAA4E,CAAsBC,EAAUC,EAAWC,GACvC,MAAM1D,EAAW9G,KAAKgD,UAAUyH,iBAAiBF,GAC3CzH,EAAa9C,KAAKgD,UAAU0H,wBAAwB5D,EAAS6D,WAAY7D,EAAS8D,QACxF,GAAI5K,KAAKiJ,YAAa,CAClB,MAAM4B,EAAqB7K,KAAKmJ,6BAC3BlG,yBAAyBH,GACzBgI,YAAYC,sBAAsBT,GACvC,IAAKO,EACD,OAAO,KAEX,MAAMG,EAAchL,KAAKoG,uBAAuB,kBAAoBmE,EAAWA,IAAYU,UAAUC,GAAML,EAAmBM,OAAOD,EAAEE,sBACvI,OAAIJ,EACOA,EAAYK,oBAEhB,IACX,CACK,CAED,MAAMC,EAAUhB,EAASiB,cACnBC,EAAkBxL,KAAKmJ,6BAA6BlG,yBAAyBH,GAAYC,SAC/F,IAAKyI,EACD,OAAO,KAEX,MAAMC,EAAOD,EAAgBE,cAAcJ,GAC3C,OAAKG,EAGEE,EAA2B3L,KAAK4L,uBAAuBH,EAAM3E,EAAU+E,EAA8CrB,KAFjH,IAGf,CACJ,CACA,YAAAsB,CAAahF,EAAU0D,GACnB,GAAIxK,KAAKiJ,YAAa,CAClB,MAAM+B,EAAchL,KAAKoG,uBAAuB,kBAAoBU,EAAUA,IAAWiF,QAAQC,QAAsC1L,IAA7B0L,EAAKC,sBAC1GD,EAAKX,oBAAoBa,iBAAiBpF,IACvCkF,EAAKC,oBAAoBC,iBAAiBpF,MAAYqF,eAAc,SAAWH,GAASA,EAAKX,oBAAoBa,iBAAiBpF,GACpIkF,EAAKX,oBACLW,EAAKC,qBAAqB,+BAChC,OAAIjB,EACO,CAACA,EAAYK,oBAAqBL,EAAYiB,qBAElD,IACX,CACK,CAED,MAAMG,EAA0BP,EAA8CrB,GAC9E,OAAOxK,KAAKqM,cAAcrM,KAAKgD,UAAUyH,iBAAiB3D,GAAWsF,EACzE,CACJ,CACA,8BAAAE,CAA+BxF,EAAUyF,EAAYC,EAAcC,GAC/D,MAAMC,EAAaH,EAAWI,WACxBC,EAAoBL,EAAWvI,cAAcyI,GAEnD,IAAII,EAAoBrM,KAAKC,IAAI,EAAGqG,EAAS8D,OAAS,EAAI4B,EAAaM,kBACvE,IAAK,IAAIvF,EAAIkF,EAAa,EAAGlF,GAAK,EAAGA,IAAK,CACtC,MAAMwF,EAAiBR,EAAWS,aAAazF,GAC/C,GAAIwF,GAAkBF,EAClB,MAEJ,IAAI,QAAsBN,EAAWU,qBAAqB1F,KAAOgF,EAAWvI,cAAcuD,KAAOqF,EAAmB,CAChHC,EAAoBE,EACpB,KACJ,CACJ,CAEA,IAAIG,EAAkB1M,KAAK2M,IAAIZ,EAAWa,iBAAiBhI,OAAQ0B,EAAS8D,OAAS,EAAI4B,EAAaM,kBACtG,IAAK,IAAIvF,EAAIkF,EAAa,EAAGlF,EAAImF,EAAYnF,IAAK,CAC9C,MAAM8F,EAAmBd,EAAWe,eAAe/F,GACnD,GAAI8F,GAAoBH,EACpB,MAEJ,IAAI,QAAsBX,EAAWU,qBAAqB1F,KAAOgF,EAAWvI,cAAcuD,KAAOqF,EAAmB,CAChHM,EAAkBG,EAClB,KACJ,CACJ,CACA,MAAO,CAAER,oBAAmBK,kBAChC,CACA,aAAAb,CAAcvF,EAAUsF,GACpB,MAAMzB,EAAa7D,EAAS6D,WACtB4B,EAAavM,KAAKgD,UAAUS,aAAa8J,cAAc5C,GACvD6C,EAAWxN,KAAKgD,UAAUoK,eAAezC,GACzC8B,EAAaF,EAAWkB,uBAAuB3G,EAAS8D,OAAS,GACvE,GAAI6B,EAAa,EACb,OAAO,KAEX,MAAMiB,EAAsB1N,KAAKmJ,6BAA6BlG,yBAAyBsJ,EAAWvI,cAAcyI,IAAa1J,SAE7H,GAAI2K,KAAwB,QAAsBnB,EAAWU,qBAAqBR,IAAc,CAC5F,IAAI,kBAAEI,EAAiB,gBAAEK,GAAoBlN,KAAKsM,+BAA+BxF,EAAUyF,EAAYmB,EAAqBjB,GAGxHkB,EAAa,KACjB,OAAa,CACT,MAAMC,EAAe,4BAAqCF,EAAoBG,aAAclD,EAAY6C,EAAUX,EAAmBK,GACrI,IAAKU,EAED,MAGJ,GAAIA,EAAahI,aAAekB,EAAS8D,QAAU9D,EAAS8D,QAAUgD,EAAa7H,UAAW,CAC1F,MAAM+H,EAAmBN,EAASO,UAAUH,EAAahI,YAAc,EAAGgI,EAAa7H,UAAY,GAAGwF,cAChG7G,EAAI1E,KAAKgO,mBAAmBJ,EAAcF,EAAoBhC,cAAcoC,GAAmBJ,EAAoBO,kBAAkBH,GAAmB1B,GAC9J,GAAI1H,EAAG,CACH,GAAIA,aAAawJ,EACb,OAAO,KAEXP,EAAajJ,CACjB,CACJ,CACAmI,EAAoBe,EAAa7H,UAAY,CACjD,CACA,GAAI4H,EACA,OAAOA,CAEf,CAEA,GAAIlB,EAAa,GAAKF,EAAWe,eAAeb,KAAgB3F,EAAS8D,OAAS,EAAG,CACjF,MAAMuD,EAAiB1B,EAAa,EAC9B2B,EAAmBpO,KAAKmJ,6BAA6BlG,yBAAyBsJ,EAAWvI,cAAcmK,IAAiBpL,SAE9H,GAAIqL,KAAqB,QAAsB7B,EAAWU,qBAAqBkB,IAAkB,CAC7F,MAAM,kBAAEtB,EAAiB,gBAAEK,GAAoBlN,KAAKsM,+BAA+BxF,EAAUyF,EAAY6B,EAAkBD,GACrHP,EAAe,4BAAqCQ,EAAiBC,cAAe1D,EAAY6C,EAAUX,EAAmBK,GAEnI,GAAIU,GAAgBA,EAAahI,aAAekB,EAAS8D,QAAU9D,EAAS8D,QAAUgD,EAAa7H,UAAW,CAC1G,MAAM+H,EAAmBN,EAASO,UAAUH,EAAahI,YAAc,EAAGgI,EAAa7H,UAAY,GAAGwF,cAChG7G,EAAI1E,KAAKgO,mBAAmBJ,EAAcQ,EAAiB1C,cAAcoC,GAAmBM,EAAiBH,kBAAkBH,GAAmB1B,GACxJ,GAAI1H,EACA,OAAIA,aAAawJ,EACN,KAEJxJ,CAEf,CACJ,CACJ,CACA,OAAO,IACX,CACA,kBAAAsJ,CAAmBJ,EAAcnC,EAAM6C,EAAQlC,GAC3C,IAAKX,EACD,OAAO,KAEX,MAAM8C,EAAWD,EACXtO,KAAKwO,yBAAyB/C,EAAMmC,EAAanH,iBAAkB2F,GACnEpM,KAAK4L,uBAAuBH,EAAMmC,EAAarH,mBAAoB6F,GACzE,OAAKmC,EAGDA,aAAmBL,EACZK,EAEJ,CAACX,EAAcW,GALX,IAMf,CACA,sBAAA3C,CAAuBN,EAASxE,EAAUsF,GAEtC,MAAMtJ,EAAawI,EAAQxI,WACrB2L,EAAuBnD,EAAQ+C,cACrC,IAAIK,GAAS,EACTC,EAAiB,EACrB,MAAMC,EAAmC,CAACjE,EAAY6C,EAAUX,EAAmBK,KAC/E,OAAa,CACT,GAAId,KAA8BuC,EAAkB,KAAQ,IAAMvC,IAC9D,OAAO8B,EAAsBW,SAEjC,MAAMnK,EAAI,4BAAqC+J,EAAsB9D,EAAY6C,EAAUX,EAAmBK,GAC9G,IAAKxI,EACD,MAEJ,MAAMoK,EAAUtB,EAASO,UAAUrJ,EAAEkB,YAAc,EAAGlB,EAAEqB,UAAY,GAAGwF,cAOvE,GANID,EAAQgD,OAAOQ,GACfJ,IAEKpD,EAAQyD,QAAQD,IACrBJ,IAEU,IAAVA,EACA,OAAOhK,EAEXwI,EAAkBxI,EAAEkB,YAAc,CACtC,CACA,OAAO,IAAI,EAEf,IAAK,IAAI+E,EAAa7D,EAAS6D,WAAYA,GAAc,EAAGA,IAAc,CACtE,MAAM4B,EAAavM,KAAKgD,UAAUS,aAAa8J,cAAc5C,GACvD+B,EAAaH,EAAWI,WACxBa,EAAWxN,KAAKgD,UAAUoK,eAAezC,GAC/C,IAAI8B,EAAaC,EAAa,EAC1BG,EAAoBW,EAASpI,OAC7B8H,EAAkBM,EAASpI,OAC3BuF,IAAe7D,EAAS6D,aACxB8B,EAAaF,EAAWkB,uBAAuB3G,EAAS8D,OAAS,GACjEiC,EAAoB/F,EAAS8D,OAAS,EACtCsC,EAAkBpG,EAAS8D,OAAS,GAExC,IAAIoE,GAAoB,EACxB,KAAOvC,GAAc,EAAGA,IAAc,CAClC,MAAMwC,EAAiB1C,EAAWvI,cAAcyI,KAAgB3J,KAAe,QAAsByJ,EAAWU,qBAAqBR,IACrI,GAAIwC,EAEID,EAEAnC,EAAoBN,EAAWe,eAAeb,IAI9CI,EAAoBN,EAAWe,eAAeb,GAC9CS,EAAkBX,EAAWS,aAAaP,SAK9C,GAAIuC,GAAqBnC,IAAsBK,EAAiB,CAC5D,MAAMxI,EAAIkK,EAAiCjE,EAAY6C,EAAUX,EAAmBK,GACpF,GAAIxI,EACA,OAAOA,CAEf,CAEJsK,EAAoBC,CACxB,CACA,GAAID,GAAqBnC,IAAsBK,EAAiB,CAC5D,MAAMxI,EAAIkK,EAAiCjE,EAAY6C,EAAUX,EAAmBK,GACpF,GAAIxI,EACA,OAAOA,CAEf,CACJ,CACA,OAAO,IACX,CACA,wBAAA8J,CAAyBlD,EAASxE,EAAUsF,GAExC,MAAMtJ,EAAawI,EAAQxI,WACrBoM,EAAe5D,EAAQuC,aAC7B,IAAIa,EAAQ,EACRC,EAAiB,EACrB,MAAMQ,EAAmC,CAACxE,EAAY6C,EAAUX,EAAmBK,KAC/E,OAAa,CACT,GAAId,KAA8BuC,EAAkB,KAAQ,IAAMvC,IAC9D,OAAO8B,EAAsBW,SAEjC,MAAMnK,EAAI,4BAAqCwK,EAAcvE,EAAY6C,EAAUX,EAAmBK,GACtG,IAAKxI,EACD,MAEJ,MAAMoK,EAAUtB,EAASO,UAAUrJ,EAAEkB,YAAc,EAAGlB,EAAEqB,UAAY,GAAGwF,cAOvE,GANID,EAAQgD,OAAOQ,GACfJ,IAEKpD,EAAQyD,QAAQD,IACrBJ,IAEU,IAAVA,EACA,OAAOhK,EAEXmI,EAAoBnI,EAAEqB,UAAY,CACtC,CACA,OAAO,IAAI,EAETqJ,EAAYpP,KAAKgD,UAAUqM,eACjC,IAAK,IAAI1E,EAAa7D,EAAS6D,WAAYA,GAAcyE,EAAWzE,IAAc,CAC9E,MAAM4B,EAAavM,KAAKgD,UAAUS,aAAa8J,cAAc5C,GACvD+B,EAAaH,EAAWI,WACxBa,EAAWxN,KAAKgD,UAAUoK,eAAezC,GAC/C,IAAI8B,EAAa,EACbI,EAAoB,EACpBK,EAAkB,EAClBvC,IAAe7D,EAAS6D,aACxB8B,EAAaF,EAAWkB,uBAAuB3G,EAAS8D,OAAS,GACjEiC,EAAoB/F,EAAS8D,OAAS,EACtCsC,EAAkBpG,EAAS8D,OAAS,GAExC,IAAIoE,GAAoB,EACxB,KAAOvC,EAAaC,EAAYD,IAAc,CAC1C,MAAMwC,EAAiB1C,EAAWvI,cAAcyI,KAAgB3J,KAAe,QAAsByJ,EAAWU,qBAAqBR,IACrI,GAAIwC,EAEID,IAMAnC,EAAoBN,EAAWe,eAAeb,IAJ9CS,EAAkBX,EAAWS,aAAaP,QAU9C,GAAIuC,GAAqBnC,IAAsBK,EAAiB,CAC5D,MAAMxI,EAAIyK,EAAiCxE,EAAY6C,EAAUX,EAAmBK,GACpF,GAAIxI,EACA,OAAOA,CAEf,CAEJsK,EAAoBC,CACxB,CACA,GAAID,GAAqBnC,IAAsBK,EAAiB,CAC5D,MAAMxI,EAAIyK,EAAiCxE,EAAY6C,EAAUX,EAAmBK,GACpF,GAAIxI,EACA,OAAOA,CAEf,CACJ,CACA,OAAO,IACX,CACA,eAAA4K,CAAgB/E,GACZ,IAAI9B,EACJ,MAAM3B,EAAW9G,KAAKgD,UAAUyH,iBAAiBF,GACjD,GAAIvK,KAAKiJ,YAGL,OAFAjJ,KAAKuJ,mBAAoB,EACzBvJ,KAAK4J,0BAC0C,QAAtCnB,EAAKzI,KAAKoJ,iBAAiBK,aAA0B,IAAPhB,OAAgB,EAASA,EAAGiB,OAAO3C,sBAAsBD,KAAc,KAElI,IAAIhE,EAAa,KACb0J,EAAe,KACf+C,EAAgB,KACpB,IAAK,IAAI5E,EAAa7D,EAAS6D,WAAYA,GAAc,EAAGA,IAAc,CACtE,MAAM4B,EAAavM,KAAKgD,UAAUS,aAAa8J,cAAc5C,GACvD+B,EAAaH,EAAWI,WACxBa,EAAWxN,KAAKgD,UAAUoK,eAAezC,GAC/C,IAAI8B,EAAaC,EAAa,EAC1BG,EAAoBW,EAASpI,OAC7B8H,EAAkBM,EAASpI,OAC/B,GAAIuF,IAAe7D,EAAS6D,WAAY,CACpC8B,EAAaF,EAAWkB,uBAAuB3G,EAAS8D,OAAS,GACjEiC,EAAoB/F,EAAS8D,OAAS,EACtCsC,EAAkBpG,EAAS8D,OAAS,EACpC,MAAM4E,EAAkBjD,EAAWvI,cAAcyI,GAC7C3J,IAAe0M,IACf1M,EAAa0M,EACbhD,EAAexM,KAAKmJ,6BAA6BlG,yBAAyBH,GAAYC,SACtFwM,EAAgBvP,KAAKmJ,6BAA6BlG,yBAAyBH,GAAYgI,YAE/F,CACA,IAAIkE,GAAoB,EACxB,KAAOvC,GAAc,EAAGA,IAAc,CAClC,MAAM+C,EAAkBjD,EAAWvI,cAAcyI,GACjD,GAAI3J,IAAe0M,EAAiB,CAEhC,GAAIhD,GAAgB+C,GAAiBP,GAAqBnC,IAAsBK,EAAiB,CAC7F,MAAMxI,EAAI,4BAAqC8H,EAAa6B,cAAe1D,EAAY6C,EAAUX,EAAmBK,GACpH,GAAIxI,EACA,OAAO1E,KAAKyP,gBAAgBF,EAAe7K,GAE/CsK,GAAoB,CACxB,CACAlM,EAAa0M,EACbhD,EAAexM,KAAKmJ,6BAA6BlG,yBAAyBH,GAAYC,SACtFwM,EAAgBvP,KAAKmJ,6BAA6BlG,yBAAyBH,GAAYgI,WAC3F,CACA,MAAMmE,IAAmBzC,KAAiB,QAAsBD,EAAWU,qBAAqBR,IAChG,GAAIwC,EAEID,EAEAnC,EAAoBN,EAAWe,eAAeb,IAI9CI,EAAoBN,EAAWe,eAAeb,GAC9CS,EAAkBX,EAAWS,aAAaP,SAK9C,GAAI8C,GAAiB/C,GAAgBwC,GAAqBnC,IAAsBK,EAAiB,CAC7F,MAAMxI,EAAI,4BAAqC8H,EAAa6B,cAAe1D,EAAY6C,EAAUX,EAAmBK,GACpH,GAAIxI,EACA,OAAO1E,KAAKyP,gBAAgBF,EAAe7K,EAEnD,CAEJsK,EAAoBC,CACxB,CACA,GAAIM,GAAiB/C,GAAgBwC,GAAqBnC,IAAsBK,EAAiB,CAC7F,MAAMxI,EAAI,4BAAqC8H,EAAa6B,cAAe1D,EAAY6C,EAAUX,EAAmBK,GACpH,GAAIxI,EACA,OAAO1E,KAAKyP,gBAAgBF,EAAe7K,EAEnD,CACJ,CACA,OAAO,IACX,CACA,eAAAgL,CAAgBnF,GACZ,IAAI9B,EACJ,MAAM3B,EAAW9G,KAAKgD,UAAUyH,iBAAiBF,GACjD,GAAIvK,KAAKiJ,YAGL,OAFAjJ,KAAKuJ,mBAAoB,EACzBvJ,KAAK4J,0BAC0C,QAAtCnB,EAAKzI,KAAKoJ,iBAAiBK,aAA0B,IAAPhB,OAAgB,EAASA,EAAGiB,OAAO7C,qBAAqBC,KAAc,KAEjI,MAAMsI,EAAYpP,KAAKgD,UAAUqM,eACjC,IAAIvM,EAAa,KACb0J,EAAe,KACf+C,EAAgB,KACpB,IAAK,IAAI5E,EAAa7D,EAAS6D,WAAYA,GAAcyE,EAAWzE,IAAc,CAC9E,MAAM4B,EAAavM,KAAKgD,UAAUS,aAAa8J,cAAc5C,GACvD+B,EAAaH,EAAWI,WACxBa,EAAWxN,KAAKgD,UAAUoK,eAAezC,GAC/C,IAAI8B,EAAa,EACbI,EAAoB,EACpBK,EAAkB,EACtB,GAAIvC,IAAe7D,EAAS6D,WAAY,CACpC8B,EAAaF,EAAWkB,uBAAuB3G,EAAS8D,OAAS,GACjEiC,EAAoB/F,EAAS8D,OAAS,EACtCsC,EAAkBpG,EAAS8D,OAAS,EACpC,MAAM4E,EAAkBjD,EAAWvI,cAAcyI,GAC7C3J,IAAe0M,IACf1M,EAAa0M,EACbhD,EAAexM,KAAKmJ,6BAA6BlG,yBAAyBH,GAAYC,SACtFwM,EAAgBvP,KAAKmJ,6BAA6BlG,yBAAyBH,GAAYgI,YAE/F,CACA,IAAIkE,GAAoB,EACxB,KAAOvC,EAAaC,EAAYD,IAAc,CAC1C,MAAM+C,EAAkBjD,EAAWvI,cAAcyI,GACjD,GAAI3J,IAAe0M,EAAiB,CAEhC,GAAID,GAAiB/C,GAAgBwC,GAAqBnC,IAAsBK,EAAiB,CAC7F,MAAMxI,EAAI,4BAAqC8H,EAAaqB,aAAclD,EAAY6C,EAAUX,EAAmBK,GACnH,GAAIxI,EACA,OAAO1E,KAAKyP,gBAAgBF,EAAe7K,GAE/CsK,GAAoB,CACxB,CACAlM,EAAa0M,EACbhD,EAAexM,KAAKmJ,6BAA6BlG,yBAAyBH,GAAYC,SACtFwM,EAAgBvP,KAAKmJ,6BAA6BlG,yBAAyBH,GAAYgI,WAC3F,CACA,MAAMmE,IAAmBzC,KAAiB,QAAsBD,EAAWU,qBAAqBR,IAChG,GAAIwC,EAEID,IAMAnC,EAAoBN,EAAWe,eAAeb,IAJ9CS,EAAkBX,EAAWS,aAAaP,QAU9C,GAAI8C,GAAiB/C,GAAgBwC,GAAqBnC,IAAsBK,EAAiB,CAC7F,MAAMxI,EAAI,4BAAqC8H,EAAaqB,aAAclD,EAAY6C,EAAUX,EAAmBK,GACnH,GAAIxI,EACA,OAAO1E,KAAKyP,gBAAgBF,EAAe7K,EAEnD,CAEJsK,EAAoBC,CACxB,CACA,GAAIM,GAAiB/C,GAAgBwC,GAAqBnC,IAAsBK,EAAiB,CAC7F,MAAMxI,EAAI,4BAAqC8H,EAAaqB,aAAclD,EAAY6C,EAAUX,EAAmBK,GACnH,GAAIxI,EACA,OAAO1E,KAAKyP,gBAAgBF,EAAe7K,EAEnD,CACJ,CACA,OAAO,IACX,CACA,qBAAAiL,CAAsBpF,EAAWC,GAC7B,MAAM1D,EAAW9G,KAAKgD,UAAUyH,iBAAiBF,GACjD,GAAIvK,KAAKiJ,YAAa,CAClB,MAAM7H,EAAQ,kBAAoB0F,GAC5BkE,EAAchL,KAAKoG,uBAAuB,kBAAoBU,EAAUA,IAAWmE,UAAUe,QAAsC1L,IAA7B0L,EAAKC,qBAAqCD,EAAK5K,MAAMwO,oBAAoBxO,KACrL,OAAI4J,EACO,CAACA,EAAYK,oBAAqBL,EAAYiB,qBAElD,IACX,CACA,MAAMG,EAA0BP,EAA8CrB,GACxE4E,EAAYpP,KAAKgD,UAAUqM,eAC3BQ,EAAc,IAAI1J,IACxB,IAAI2J,EAAS,GACb,MAAMC,EAAc,CAACjN,EAAY0J,KAC7B,IAAKqD,EAAYG,IAAIlN,GAAa,CAC9B,MAAMmN,EAAM,GACZ,IAAK,IAAI1I,EAAI,EAAG2I,EAAM1D,EAAeA,EAAazJ,SAASqC,OAAS,EAAGmC,EAAI2I,EAAK3I,IAC5E0I,EAAI1I,GAAK,EAEbsI,EAAYrH,IAAI1F,EAAYmN,EAChC,CACAH,EAASD,EAAYtH,IAAIzF,EAAW,EAExC,IAAI6L,EAAiB,EACrB,MAAMwB,EAAgB,CAAC3D,EAAc7B,EAAY6C,EAAUX,EAAmBK,KAC1E,OAAa,CACT,GAAId,KAA8BuC,EAAkB,KAAQ,IAAMvC,IAC9D,OAAO8B,EAAsBW,SAEjC,MAAMnK,EAAI,4BAAqC8H,EAAaqB,aAAclD,EAAY6C,EAAUX,EAAmBK,GACnH,IAAKxI,EACD,MAEJ,MAAMoK,EAAUtB,EAASO,UAAUrJ,EAAEkB,YAAc,EAAGlB,EAAEqB,UAAY,GAAGwF,cACjED,EAAUkB,EAAad,cAAcoD,GAC3C,GAAIxD,IACIA,EAAQgD,OAAOQ,GACfgB,EAAOxE,EAAQ8E,SAEV9E,EAAQyD,QAAQD,IACrBgB,EAAOxE,EAAQ8E,UAEY,IAA3BN,EAAOxE,EAAQ8E,QACf,OAAOpQ,KAAKgO,mBAAmBtJ,EAAG4G,GAAS,EAAOc,GAG1DS,EAAoBnI,EAAEqB,UAAY,CACtC,CACA,OAAO,IAAI,EAEf,IAAIjD,EAAa,KACb0J,EAAe,KACnB,IAAK,IAAI7B,EAAa7D,EAAS6D,WAAYA,GAAcyE,EAAWzE,IAAc,CAC9E,MAAM4B,EAAavM,KAAKgD,UAAUS,aAAa8J,cAAc5C,GACvD+B,EAAaH,EAAWI,WACxBa,EAAWxN,KAAKgD,UAAUoK,eAAezC,GAC/C,IAAI8B,EAAa,EACbI,EAAoB,EACpBK,EAAkB,EACtB,GAAIvC,IAAe7D,EAAS6D,WAAY,CACpC8B,EAAaF,EAAWkB,uBAAuB3G,EAAS8D,OAAS,GACjEiC,EAAoB/F,EAAS8D,OAAS,EACtCsC,EAAkBpG,EAAS8D,OAAS,EACpC,MAAM4E,EAAkBjD,EAAWvI,cAAcyI,GAC7C3J,IAAe0M,IACf1M,EAAa0M,EACbhD,EAAexM,KAAKmJ,6BAA6BlG,yBAAyBH,GAAYC,SACtFgN,EAAYjN,EAAY0J,GAEhC,CACA,IAAIwC,GAAoB,EACxB,KAAOvC,EAAaC,EAAYD,IAAc,CAC1C,MAAM+C,EAAkBjD,EAAWvI,cAAcyI,GACjD,GAAI3J,IAAe0M,EAAiB,CAEhC,GAAIhD,GAAgBwC,GAAqBnC,IAAsBK,EAAiB,CAC5E,MAAMxI,EAAIyL,EAAc3D,EAAc7B,EAAY6C,EAAUX,EAAmBK,GAC/E,GAAIxI,EACA,OAAOiH,EAA2BjH,GAEtCsK,GAAoB,CACxB,CACAlM,EAAa0M,EACbhD,EAAexM,KAAKmJ,6BAA6BlG,yBAAyBH,GAAYC,SACtFgN,EAAYjN,EAAY0J,EAC5B,CACA,MAAMyC,IAAmBzC,KAAiB,QAAsBD,EAAWU,qBAAqBR,IAChG,GAAIwC,EAEID,IAMAnC,EAAoBN,EAAWe,eAAeb,IAJ9CS,EAAkBX,EAAWS,aAAaP,QAU9C,GAAID,GAAgBwC,GAAqBnC,IAAsBK,EAAiB,CAC5E,MAAMxI,EAAIyL,EAAc3D,EAAc7B,EAAY6C,EAAUX,EAAmBK,GAC/E,GAAIxI,EACA,OAAOiH,EAA2BjH,EAE1C,CAEJsK,EAAoBC,CACxB,CACA,GAAIzC,GAAgBwC,GAAqBnC,IAAsBK,EAAiB,CAC5E,MAAMxI,EAAIyL,EAAc3D,EAAc7B,EAAY6C,EAAUX,EAAmBK,GAC/E,GAAIxI,EACA,OAAOiH,EAA2BjH,EAE1C,CACJ,CACA,OAAO,IACX,CACA,eAAA+K,CAAgBF,EAAe7K,GAC3B,IAAKA,EACD,OAAO,KAEX,IAAI9C,EAAO5B,KAAKgD,UAAUqN,gBAAgB3L,GAC1C9C,EAAOA,EAAK2J,cACZ,MAAM/D,EAAc+H,EAAce,eAAe1O,GACjD,OAAK4F,EAGE,CACHpG,MAAOsD,EACP8C,eAJO,IAMf,EAQJ,SAASqE,EAA8CrB,GACnD,QAA2B,IAAhBA,EACP,MAAO,KAAM,EAEZ,CACD,MAAM+F,EAAYC,KAAKC,MACvB,MAAO,IACKD,KAAKC,MAAQF,GAAa/F,CAE1C,CACJ,CACA,MAAM0D,EACF,WAAA/N,GACIH,KAAK0Q,0BAAuBpQ,CAChC,EAGJ,SAASqL,EAA2B1G,GAChC,OAAIA,aAAkBiJ,EACX,KAEJjJ,CACX,CANAiJ,EAAsBW,SAAW,IAAIX,C,wHCjsBrC,MAAMyC,EAIF,UAAIvL,GACA,OAAOpF,KAAK4Q,OAChB,CACA,WAAAzQ,CAAYiF,GACRpF,KAAK4Q,QAAUxL,CACnB,EAOG,MAAMyL,UAAoBF,EAC7B,aAAOG,CAAO1I,EAAgBhB,EAAOc,GACjC,IAAI9C,EAASgD,EAAehD,OAO5B,OANIgC,IACAhC,GAAS,QAAUA,EAAQgC,EAAMhC,SAEjC8C,IACA9C,GAAS,QAAUA,EAAQ8C,EAAe9C,SAEvC,IAAIyL,EAAYzL,EAAQgD,EAAgBhB,EAAOc,EAAgBd,EAAQA,EAAM2J,yBAA2B,gBACnH,CACA,QAAI7J,GACA,OAAO,CACX,CACA,cAAI8J,GACA,OAAO,CACX,CACA,kBAAIjJ,GACA,OAAO,CACX,CACA,QAAAC,CAASiJ,GACL,OAAQA,GACJ,KAAK,EAAG,OAAOjR,KAAKoI,eACpB,KAAK,EAAG,OAAOpI,KAAKoH,MACpB,KAAK,EAAG,OAAOpH,KAAKkI,eAExB,MAAM,IAAIgJ,MAAM,sBACpB,CAIA,YAAI7J,GACA,MAAMpC,EAAS,GAQf,OAPAA,EAAOqC,KAAKtH,KAAKoI,gBACbpI,KAAKoH,OACLnC,EAAOqC,KAAKtH,KAAKoH,OAEjBpH,KAAKkI,gBACLjD,EAAOqC,KAAKtH,KAAKkI,gBAEdjD,CACX,CACA,WAAA9E,CAAYiF,EAAQgD,EAAgBhB,EAAOc,EAAgB6I,GACvD7N,MAAMkC,GACNpF,KAAKoI,eAAiBA,EACtBpI,KAAKoH,MAAQA,EACbpH,KAAKkI,eAAiBA,EACtBlI,KAAK+Q,yBAA2BA,CACpC,CACA,WAAAI,CAAYC,GACR,OAA4B,OAAxBpR,KAAKkI,iBAQLkJ,EAAeC,WAAWrR,KAAK+Q,yBAIvC,CACA,SAAAO,GACI,OAAO,IAAIT,EAAY7Q,KAAKoF,OAAQpF,KAAKoI,eAAekJ,YAAatR,KAAKoH,OAASpH,KAAKoH,MAAMkK,YAAatR,KAAKkI,gBAAkBlI,KAAKkI,eAAeoJ,YAAatR,KAAK+Q,yBAC5K,CACA,qBAAAlI,CAAsB0I,EAAQvO,GAC1B,OAAOhD,KAAKoH,MAAQpH,KAAKoH,MAAMyB,uBAAsB,QAAU0I,EAAQvR,KAAKoI,eAAehD,QAASpC,GAAawO,OAAOC,gBAC5H,EAEG,MAAMC,UAAoBf,EAI7B,eAAOgB,CAASC,EAAOC,EAAOC,EAAOxM,GAAY,GAC7C,IAAIF,EAASwM,EAAMxM,OACf2M,EAAoBH,EAAMb,yBAC9B,GAAIa,EAAMZ,aAAea,EAAMb,WAC3B,MAAM,IAAIE,MAAM,wBAIpB,GAFA9L,GAAS,QAAUA,EAAQyM,EAAMzM,QACjC2M,EAAoBA,EAAkBC,MAAMH,EAAMd,0BAC9Ce,EAAO,CACP,GAAIF,EAAMZ,aAAec,EAAMd,WAC3B,MAAM,IAAIE,MAAM,wBAEpB9L,GAAS,QAAUA,EAAQ0M,EAAM1M,QACjC2M,EAAoBA,EAAkBC,MAAMF,EAAMf,yBACtD,CACA,OAAOzL,EACD,IAAI2M,EAAuB7M,EAAQwM,EAAMZ,WAAa,EAAGY,EAAOC,EAAOC,EAAOC,GAC9E,IAAIG,EAAoB9M,EAAQwM,EAAMZ,WAAa,EAAGY,EAAOC,EAAOC,EAAOC,EACrF,CACA,eAAOI,GACH,OAAO,IAAIC,EAA0B,KAAY,EAAG,GAAI,gBAC5D,CACA,QAAIlL,GACA,OAAO,CACX,CACA,4BAAI6J,GACA,OAAO/Q,KAAKqS,yBAChB,CAIA,WAAAlS,CAAYiF,EAAQ4L,EAAYqB,GAC5BnP,MAAMkC,GACNpF,KAAKgR,WAAaA,EAClBhR,KAAKqS,0BAA4BA,EACjCrS,KAAKsS,sBAAwB,CACjC,CACA,gBAAAC,GAEA,CACA,sBAAAC,GACIxS,KAAKuS,mBACL,MAAMzK,EAAa9H,KAAK+H,eACxB,GAAmB,IAAfD,EACA,OAEJ,MAAM2K,EAAYzS,KAAKgI,SAASF,EAAa,GACvC4K,EAA6B,IAAnBD,EAAUvL,KAAoCuL,EAAUE,YAAcF,EAItF,OAHIA,IAAcC,GACd1S,KAAK4S,SAAS9K,EAAa,EAAG4K,GAE3BA,CACX,CACA,uBAAAG,GACI7S,KAAKuS,mBAEL,GAAmB,IADAvS,KAAK+H,eAEpB,OAEJ,MAAM+K,EAAa9S,KAAKgI,SAAS,GAC3B0K,EAA8B,IAApBI,EAAW5L,KAAoC4L,EAAWH,YAAcG,EAIxF,OAHIA,IAAeJ,GACf1S,KAAK4S,SAAS,EAAGF,GAEdA,CACX,CACA,WAAAvB,CAAYC,GACR,GAAIA,EAAeC,WAAWrR,KAAK+Q,0BAC/B,OAAO,EAEX,GAA4B,IAAxB/Q,KAAK+H,eAEL,OAAO,EAEX,IAAI0K,EAAYzS,KAChB,KAA0B,IAAnByS,EAAUvL,MAAmC,CAChD,MAAM6L,EAAaN,EAAU1K,eAC7B,GAAmB,IAAfgL,EAEA,MAAM,IAAI,KAEdN,EAAYA,EAAUzK,SAAS+K,EAAa,EAChD,CACA,OAAON,EAAUtB,YAAYC,EACjC,CACA,qBAAA4B,GACIhT,KAAKuS,mBACL,MAAM7D,EAAQ1O,KAAK+H,eACnB,IAAI3C,EAASpF,KAAKgI,SAAS,GAAG5C,OAC1B6N,EAAmBjT,KAAKgI,SAAS,GAAG+I,yBACxC,IAAK,IAAIxJ,EAAI,EAAGA,EAAImH,EAAOnH,IAAK,CAC5B,MAAMH,EAAQpH,KAAKgI,SAAST,GAC5BnC,GAAS,QAAUA,EAAQgC,EAAMhC,QACjC6N,EAAmBA,EAAiBjB,MAAM5K,EAAM2J,yBACpD,CACA/Q,KAAK4Q,QAAUxL,EACfpF,KAAKqS,0BAA4BY,EACjCjT,KAAKsS,sBAAwB,CACjC,CACA,qBAAAzJ,CAAsB0I,EAAQvO,GAC1B,IAAmC,IAA/BhD,KAAKsS,qBACL,OAAOtS,KAAKsS,qBAEhB,IAAI1J,EAAiB4I,OAAOC,iBACxB1I,EAAcwI,EAClB,IAAK,IAAIhK,EAAI,EAAGA,EAAIvH,KAAK+H,eAAgBR,IAAK,CAC1C,MAAMH,EAAQpH,KAAKgI,SAAST,GACxBH,IACAwB,EAAiBpI,KAAK2M,IAAIvE,EAAgBxB,EAAMyB,sBAAsBE,EAAa/F,IACnF+F,GAAc,QAAUA,EAAa3B,EAAMhC,QAEnD,CAEA,OADApF,KAAKsS,qBAAuB1J,EACrBA,CACX,EAEJ,MAAMsJ,UAA4BR,EAC9B,kBAAI3J,GACA,OAAuB,OAAhB/H,KAAKkT,OAAkB,EAAI,CACtC,CACA,QAAAlL,CAASiJ,GACL,OAAQA,GACJ,KAAK,EAAG,OAAOjR,KAAKmT,OACpB,KAAK,EAAG,OAAOnT,KAAKoT,OACpB,KAAK,EAAG,OAAOpT,KAAKkT,OAExB,MAAM,IAAIhC,MAAM,sBACpB,CACA,QAAA0B,CAAS3B,EAAKhL,GACV,OAAQgL,GACJ,KAAK,EAED,YADAjR,KAAKmT,OAASlN,GAElB,KAAK,EAED,YADAjG,KAAKoT,OAASnN,GAElB,KAAK,EAED,YADAjG,KAAKkT,OAASjN,GAGtB,MAAM,IAAIiL,MAAM,sBACpB,CACA,YAAI7J,GACA,OAAOrH,KAAKkT,OAAS,CAAClT,KAAKmT,OAAQnT,KAAKoT,OAAQpT,KAAKkT,QAAU,CAAClT,KAAKmT,OAAQnT,KAAKoT,OACtF,CACA,SAAIxB,GACA,OAAO5R,KAAKmT,MAChB,CACA,SAAItB,GACA,OAAO7R,KAAKoT,MAChB,CACA,SAAItB,GACA,OAAO9R,KAAKkT,MAChB,CACA,WAAA/S,CAAYiF,EAAQ4L,EAAYmC,EAAQC,EAAQF,EAAQnC,GACpD7N,MAAMkC,EAAQ4L,EAAYD,GAC1B/Q,KAAKmT,OAASA,EACdnT,KAAKoT,OAASA,EACdpT,KAAKkT,OAASA,CAClB,CACA,SAAA5B,GACI,OAAO,IAAIY,EAAoBlS,KAAKoF,OAAQpF,KAAKgR,WAAYhR,KAAKmT,OAAO7B,YAAatR,KAAKoT,OAAO9B,YAAatR,KAAKkT,OAASlT,KAAKkT,OAAO5B,YAAc,KAAMtR,KAAK+Q,yBACtK,CACA,uBAAAsC,CAAwBpN,GACpB,GAAIjG,KAAKkT,OACL,MAAM,IAAIhC,MAAM,2CAEpBlR,KAAKuS,mBACLvS,KAAKkT,OAASjN,EACdjG,KAAKgT,uBACT,CACA,aAAAM,GACI,IAAKtT,KAAKkT,OACN,MAAM,IAAIhC,MAAM,iDAEpBlR,KAAKuS,mBACL,MAAMtN,EAASjF,KAAKkT,OAGpB,OAFAlT,KAAKkT,OAAS,KACdlT,KAAKgT,wBACE/N,CACX,CACA,wBAAAsO,CAAyBtN,GACrB,GAAIjG,KAAKkT,OACL,MAAM,IAAIhC,MAAM,4CAEpBlR,KAAKuS,mBACLvS,KAAKkT,OAASlT,KAAKoT,OACnBpT,KAAKoT,OAASpT,KAAKmT,OACnBnT,KAAKmT,OAASlN,EACdjG,KAAKgT,uBACT,CACA,cAAAQ,GACI,IAAKxT,KAAKkT,OACN,MAAM,IAAIhC,MAAM,iDAEpBlR,KAAKuS,mBACL,MAAMtN,EAASjF,KAAKmT,OAKpB,OAJAnT,KAAKmT,OAASnT,KAAKoT,OACnBpT,KAAKoT,OAASpT,KAAKkT,OACnBlT,KAAKkT,OAAS,KACdlT,KAAKgT,wBACE/N,CACX,CACA,SAAA0N,GACI,OAAO3S,IACX,EAKJ,MAAMiS,UAA+BC,EACjC,SAAAS,GACI,OAAO,IAAIT,EAAoBlS,KAAKoF,OAAQpF,KAAKgR,WAAYhR,KAAK4R,MAAO5R,KAAK6R,MAAO7R,KAAK8R,MAAO9R,KAAK+Q,yBAC1G,CACA,gBAAAwB,GACI,MAAM,IAAIrB,MAAM,6BACpB,EAKJ,MAAMuC,UAAyB/B,EAC3B,kBAAI3J,GACA,OAAO/H,KAAK0T,UAAUtO,MAC1B,CACA,QAAA4C,CAASiJ,GACL,OAAOjR,KAAK0T,UAAUzC,EAC1B,CACA,QAAA2B,CAAS3B,EAAK7J,GACVpH,KAAK0T,UAAUzC,GAAO7J,CAC1B,CACA,YAAIC,GACA,OAAOrH,KAAK0T,SAChB,CACA,WAAAvT,CAAYiF,EAAQ4L,EAAY0C,EAAW3C,GACvC7N,MAAMkC,EAAQ4L,EAAYD,GAC1B/Q,KAAK0T,UAAYA,CACrB,CACA,SAAApC,GACI,MAAMjK,EAAW,IAAIsM,MAAM3T,KAAK0T,UAAUtO,QAC1C,IAAK,IAAImC,EAAI,EAAGA,EAAIvH,KAAK0T,UAAUtO,OAAQmC,IACvCF,EAASE,GAAKvH,KAAK0T,UAAUnM,GAAG+J,YAEpC,OAAO,IAAImC,EAAiBzT,KAAKoF,OAAQpF,KAAKgR,WAAY3J,EAAUrH,KAAK+Q,yBAC7E,CACA,uBAAAsC,CAAwBpN,GACpBjG,KAAKuS,mBACLvS,KAAK0T,UAAUpM,KAAKrB,GACpBjG,KAAKgT,uBACT,CACA,aAAAM,GACItT,KAAKuS,mBACL,MAAMvG,EAAOhM,KAAK0T,UAAUE,MAE5B,OADA5T,KAAKgT,wBACEhH,CACX,CACA,wBAAAuH,CAAyBtN,GACrBjG,KAAKuS,mBACLvS,KAAK0T,UAAUG,QAAQ5N,GACvBjG,KAAKgT,uBACT,CACA,cAAAQ,GACIxT,KAAKuS,mBACL,MAAMvG,EAAOhM,KAAK0T,UAAUI,QAE5B,OADA9T,KAAKgT,wBACEhH,CACX,CACA,SAAA2G,GACI,OAAO3S,IACX,EAKJ,MAAMoS,UAAkCqB,EACpC,SAAAd,GACI,OAAO,IAAIc,EAAiBzT,KAAKoF,OAAQpF,KAAKgR,WAAY,IAAIhR,KAAKqH,UAAWrH,KAAK+Q,yBACvF,CACA,gBAAAwB,GACI,MAAM,IAAIrB,MAAM,6BACpB,EAEJ,MAAM6C,EAAa,GACnB,MAAMC,UAA6BrD,EAC/B,cAAIK,GACA,OAAO,CACX,CACA,kBAAIjJ,GACA,OAAO,CACX,CACA,QAAAC,CAASiJ,GACL,OAAO,IACX,CACA,YAAI5J,GACA,OAAO0M,CACX,CACA,SAAAzC,GACI,OAAOtR,IACX,EAEG,MAAMiU,UAAoBD,EAC7B,QAAI9M,GACA,OAAO,CACX,CACA,4BAAI6J,GACA,OAAO,eACX,CACA,WAAAI,CAAY+C,GACR,OAAO,CACX,CACA,qBAAArL,CAAsB0I,EAAQvO,GAC1B,MAAMmR,GAAQ,QAAY5C,GAGpB5L,GAAyC,IAAtBwO,EAAMC,YAAoBD,EAAM/E,UAAY+E,EAAM/E,UAAY,GAAK,EACtFtJ,GAAgB,SAAmB,QAAUyL,EAAQvR,KAAKoF,SAAW,EAC3E,IAAIH,EAASuM,OAAOC,iBACpB,IAAK,IAAI9G,EAAahF,EAAiBgF,GAAc7E,EAAe6E,IAAc,CAC9E,MAAM0J,EAAmBrR,EAAUsR,gCAAgC3J,GAC7D4J,EAAcvR,EAAUoK,eAAezC,GAC7C,GAAyB,IAArB0J,EACA,SAEJ,MAAMG,EAAgB,4BAAsCD,EAAaF,EAAkBrR,EAAUyR,aAAalU,SAClH0E,EAASzE,KAAK2M,IAAIlI,EAAQuP,EAC9B,CACA,OAAOvP,CACX,EAEG,MAAMyP,UAAuBV,EAChC,aAAOlD,CAAO1L,EAAQoC,EAAamN,GAE/B,OADa,IAAID,EAAetP,EAAQoC,EAAamN,EAEzD,CACA,QAAIzN,GACA,OAAO,CACX,CACA,4BAAI6J,GACA,OAAO,eACX,CACA,WAAA5Q,CAAYiF,EAAQoC,EAKpBmN,GACIzR,MAAMkC,GACNpF,KAAKwH,YAAcA,EACnBxH,KAAK2U,WAAaA,CACtB,CACA,QAAI/S,GACA,OAAO5B,KAAKwH,YAAYoN,WAC5B,CACA,cAAI9R,GACA,OAAO9C,KAAKwH,YAAY1E,UAC5B,CACA,WAAAqO,CAAY+C,GAIR,OAAO,CACX,CACA,qBAAArL,CAAsB0I,EAAQvO,GAC1B,OAAOwO,OAAOC,gBAClB,EAEG,MAAMoD,UAA8Bb,EACvC,QAAI9M,GACA,OAAO,CACX,CACA,WAAA/G,CAAY2U,EAAiB1P,GACzBlC,MAAMkC,GACNpF,KAAK+Q,yBAA2B+D,CACpC,CACA,WAAA3D,CAAY4D,GACR,OAAQA,EAAiB1D,WAAWrR,KAAK+Q,yBAC7C,CACA,qBAAAlI,CAAsB0I,EAAQvO,GAC1B,OAAOwO,OAAOC,gBAClB,E,qEC1dG,MAAMuD,EACT,8BAAOC,CAAwB3S,GAM3B,OAJcA,EAAQmC,KAAIyQ,IACtB,MAAM9T,EAAQ,SAAW8T,EAAE9T,OAC3B,OAAO,IAAI4T,GAAa,QAAiB5T,EAAMmF,qBAAqB,QAAiBnF,EAAMqF,mBAAmB,QAAeyO,EAAEtT,MAAM,IACtIuT,SAEP,CACA,WAAAhV,CAAYuF,EAAaG,EAAWuP,GAChCpV,KAAK0F,YAAcA,EACnB1F,KAAK6F,UAAYA,EACjB7F,KAAKoV,UAAYA,CACrB,CACA,QAAAC,GACI,MAAO,KAAI,QAAYrV,KAAK0F,mBAAkB,QAAY1F,KAAK6F,mBAAkB,QAAY7F,KAAKoV,YACtG,EAEG,MAAME,EAIT,WAAAnV,CAAYqE,GACRxE,KAAKuV,YAAc,EACnBvV,KAAKwV,uBAAyB,EAC9BxV,KAAKyV,yBAA2B,EAChCzV,KAAK0V,mBAAqB,EAC1B1V,KAAKwE,MAAQA,EAAMC,KAAIkR,GAAQC,EAAkBC,KAAKF,IAC1D,CAIA,qBAAAG,CAAsBvE,GAElB,OADAvR,KAAK+V,eAAexE,GACbvR,KAAKgW,kBAAkBzE,EAClC,CAKA,uBAAA0E,CAAwB1E,GACpBvR,KAAK+V,eAAexE,GACpB,MAAM2E,EAAWlW,KAAKwE,MAAMxE,KAAKuV,aAC3BY,EAAmBD,EAAWlW,KAAKoW,kBAAkBF,EAASG,WAAa,KACjF,OAAyB,OAArBF,EACO,MAEJ,QAAsB5E,EAAQ4E,EACzC,CACA,iBAAAC,CAAkBE,GACd,OAAIA,EAAalH,YAAcpP,KAAK0V,mBACzB,QAASY,EAAalH,UAAYpP,KAAKwV,uBAAwBc,EAAalC,YAAcpU,KAAKyV,2BAG/F,QAASa,EAAalH,UAAYpP,KAAKwV,uBAAwBc,EAAalC,YAE3F,CACA,iBAAA4B,CAAkBO,GACd,MAAMF,GAAY,QAAYE,GAC9B,OAAIF,EAAUjH,UAAYpP,KAAKwV,yBAA2BxV,KAAK0V,mBACpD,QAASW,EAAUjH,UAAYpP,KAAKwV,uBAAwBa,EAAUjC,YAAcpU,KAAKyV,2BAGzF,QAASY,EAAUjH,UAAYpP,KAAKwV,uBAAwBa,EAAUjC,YAErF,CACA,cAAA2B,CAAexE,GACX,KAAOvR,KAAKuV,YAAcvV,KAAKwE,MAAMY,QAAQ,CACzC,MAAM8Q,EAAWlW,KAAKwE,MAAMxE,KAAKuV,aAE3BiB,EAAyBxW,KAAKoW,kBAAkBF,EAASO,mBAC/D,KAAI,QAAoBD,EAAwBjF,GAe5C,MAfqD,CAErDvR,KAAKuV,cACL,MAAMmB,GAA4B,QAAYF,GAExCG,GAAkC,QAAY3W,KAAKoW,kBAAkBF,EAASU,qBAC9EC,EAAYH,EAA0BtH,UAAYuH,EAAgCvH,UACxFpP,KAAKwV,wBAA0BqB,EAC/B,MAAMC,EAAsB9W,KAAK0V,oBAAsBQ,EAASU,mBAAmBxH,UAAYpP,KAAKyV,yBAA2B,EACzHsB,EAAcL,EAA0BtC,YAAcuC,EAAgCvC,YAC5FpU,KAAKyV,yBAA2BqB,EAAsBC,EACtD/W,KAAK0V,kBAAoBQ,EAASU,mBAAmBxH,SACzD,CAKJ,CACJ,EAEJ,MAAMwG,EACF,WAAOC,CAAKF,GACR,OAAO,IAAIC,EAAkBD,EAAKjQ,YAAaiQ,EAAK9P,UAAW8P,EAAKP,UACxE,CACA,WAAAjV,CAAYuF,EAAaG,EAAWmR,GAChChX,KAAK4W,oBAAqB,QAAY/Q,GACtC7F,KAAKyW,mBAAoB,SAAY,QAAU/Q,EAAasR,IAC5DhX,KAAKqW,WAAY,QAAY3Q,EACjC,E,8FChGG,MAAMuR,EACT,yBAAOC,CAAmBC,EAAe/T,GACrC,SAASgU,EAAM5P,GACX,OAAOpE,EAAiBiU,OAAO,GAAG7P,EAAY1E,gBAAgB0E,EAAYoN,cAC9E,CACA,MAAMnQ,EAAM,IAAI0B,IAChB,IAAK,MAAMiC,KAAkB+O,EAAcrM,YAAYwM,gBAAiB,CACpE,MAAMlS,GAAS,QAAS,EAAGgD,EAAewM,YAAYxP,QAChDmS,EAAgBH,EAAMhP,GACtBuM,EAAa,gBAA6B1K,IAAIsN,EAAe,MACnE9S,EAAI+D,IAAIJ,EAAewM,YAAa,IAAI,KAAMxP,EAAQ,EAAkCmS,EAAe5C,EAAY,YAAsBvP,EAAQgD,EAAgBuM,IACrK,CACA,IAAK,MAAMzM,KAAkBiP,EAAcrM,YAAYgK,gBAAiB,CACpE,MAAM1P,GAAS,QAAS,EAAG8C,EAAe0M,YAAYxP,QACtD,IAAIuP,EAAa,gBACjB,MAAMG,EAAkB5M,EAAesP,qBACvC,IAAK,MAAMlM,KAAWwJ,EAClBH,EAAaA,EAAW1K,IAAImN,EAAM9L,GAAU,MAEhD7G,EAAI+D,IAAIN,EAAe0M,YAAa,IAAI,KAAMxP,EAAQ,EAAkCgS,EAAMtC,EAAgB,IAAKH,EAAY,YAAsBvP,EAAQ8C,EAAgByM,IACjL,CACA,OAAO,IAAIsC,EAAcxS,EAC7B,CACA,WAAAtE,CAAYsE,GACRzE,KAAKyE,IAAMA,EACXzE,KAAKyX,WAAY,EACjBzX,KAAK0X,cAAgB,IACzB,CACA,YAAAC,GACI,GAAI3X,KAAK4X,QACL,OAAO,KAEN,CACD,MAAMC,EAAO,IAAI7X,KAAKyE,IAAIoT,QAG1B,OAFAA,EAAKC,OACLD,EAAK1C,UACE0C,EAAKpT,KAAIsT,GA6B5B,SAAiCC,GAC7B,IAAIC,GAAU,QAAuBD,GAGjC,UAAUE,KAAKF,KACfC,EAAU,MAAMA,KAEhB,UAAUC,KAAKF,KACfC,EAAU,GAAGA,QAEjB,OAAOA,CACX,CAxCiCE,CAAwBJ,KAAIK,KAAK,IAC1D,CACJ,CAIA,gBAAIC,GACA,IAAKrY,KAAKyX,UAAW,CACjB,MAAMa,EAAYtY,KAAK2X,eACvB3X,KAAK0X,cAAgBY,EAAY,IAAIC,OAAOD,EAAW,MAAQ,KAC/DtY,KAAKyX,WAAY,CACrB,CACA,OAAOzX,KAAK0X,aAChB,CACA,QAAAc,CAAS/O,GACL,OAAOzJ,KAAKyE,IAAI8D,IAAIkB,EAAM8B,cAC9B,CACA,oBAAAkN,CAAqBC,GACjB,IAAK,MAAOC,EAAaC,KAAS5Y,KAAKyE,IACnC,GAAkB,IAAdmU,EAAK1R,MAA6C0R,EAAKjE,WAAWtD,WAAWqH,GAC7E,OAAOC,CAInB,CACA,WAAIf,GACA,OAAyB,IAAlB5X,KAAKyE,IAAIoU,IACpB,EAcG,MAAMC,EACT,WAAA3Y,CAAYiD,EAAkBH,GAC1BjD,KAAKoD,iBAAmBA,EACxBpD,KAAKiD,yBAA2BA,EAChCjD,KAAK+Y,0BAA4B,IAAI5S,GACzC,CACA,iBAAAtD,CAAkBC,GAEd,OAAO9C,KAAK+Y,0BAA0B/I,IAAIlN,EAC9C,CACA,8BAAAiB,CAA+BjB,GAC3B,IAAIkW,EAA8BhZ,KAAK+Y,0BAA0BxQ,IAAIzF,GAKrE,OAJKkW,IACDA,EAA8B/B,EAAcC,mBAAmBlX,KAAKiD,yBAAyBH,GAAa9C,KAAKoD,kBAC/GpD,KAAK+Y,0BAA0BvQ,IAAI1F,EAAYkW,IAE5CA,CACX,E,wEChGG,SAAS9T,EAAqB+T,EAAmBC,GACpD,GAAiC,IAA7BD,EAAkB7T,OAClB,OAAO8T,EAEX,GAAkC,IAA9BA,EAAmB9T,OACnB,OAAO6T,EAGX,MAAME,EAAY,IAAI,KAAWC,EAAgBH,IAE3CI,EAAYD,EAAgBF,GAClCG,EAAU/R,KAAK,CAAEgS,UAAU,EAAOC,kBAAcjZ,EAAWkZ,iBAAalZ,IAExE,IAAImZ,EAAUN,EAAUO,UAIxB,SAASC,EAA4BC,GACjC,QAAiBtZ,IAAbsZ,EAAwB,CACxB,MAAMC,EAAMV,EAAUW,WAAUC,IAAK,KAAS,GAI9C,OAHIN,GACAI,EAAIhG,QAAQ4F,GAETI,CACX,CACA,MAAM5U,EAAS,GACf,KAAOwU,KAAY,QAAaG,IAAW,CACvC,MAAO5N,EAAMgO,GAAiBP,EAAQQ,QAAQL,GAC9C3U,EAAOqC,KAAK0E,GACZ4N,GAAW,QAAsB5N,EAAKwN,YAAaI,GACnDH,EAAUO,QAAqDA,EAAgBb,EAAUO,SAC7F,CAIA,OAHK,QAAaE,IACd3U,EAAOqC,KAAK,IAAI4S,GAAc,EAAON,EAAUA,IAE5C3U,CACX,CACA,MAAMA,EAAS,GACf,SAASkV,EAASzU,EAAaG,EAAWuP,GACtC,GAAInQ,EAAOG,OAAS,IAAK,QAAaH,EAAOA,EAAOG,OAAS,GAAGS,UAAWH,GAAc,CACrF,MAAM0U,EAAanV,EAAOA,EAAOG,OAAS,GAC1CH,EAAOA,EAAOG,OAAS,GAAK,IAAI,IAAagV,EAAW1U,YAAaG,GAAW,QAAUuU,EAAWhF,UAAWA,GACpH,MAEInQ,EAAOqC,KAAK,CAAE5B,cAAaG,YAAWuP,aAE9C,CACA,IAAIiF,EAAW,KACf,IAAK,MAAMC,KAAUjB,EAAW,CAC5B,MAAMF,EAAYQ,EAA4BW,EAAOf,cACrD,GAAIe,EAAOhB,SAAU,CACjB,MAAMiB,GAAW,QAAWpB,GAAWqB,GAAKA,EAAEjB,eACxCkB,GAAc,QAAUJ,EAAUE,GACxCJ,EAASE,EAAUI,EAAaH,EAAOd,aACvCa,EAAWI,CACf,MAEI,IAAK,MAAMC,KAAMvB,EAAW,CACxB,MAAMwB,EAAgBN,EACtBA,GAAW,QAAUA,EAAUK,EAAGnB,cAC9BmB,EAAGpB,UACHa,EAASQ,EAAeN,EAAUK,EAAGlB,YAE7C,CAER,CACA,OAAOvU,CACX,CACA,MAAMiV,EACF,WAAA/Z,CAIAmZ,EAAUC,EAAcC,GACpBxZ,KAAKsZ,SAAWA,EAChBtZ,KAAKuZ,aAAeA,EACpBvZ,KAAKwZ,YAAcA,CACvB,CACA,OAAAS,CAAQT,GACJ,MAAMoB,GAAuB,QAAsBpB,EAAaxZ,KAAKwZ,aACrE,OAAI,QAAaoB,EAAsB,MAC5B,CAAC5a,UAAMM,GAETN,KAAKsZ,SACH,CACH,IAAIY,EAAcla,KAAKsZ,SAAUtZ,KAAKuZ,aAAcC,GACpD,IAAIU,EAAcla,KAAKsZ,SAAU,KAAYsB,IAI1C,CACH,IAAIV,EAAcla,KAAKsZ,SAAUE,EAAaA,GAC9C,IAAIU,EAAcla,KAAKsZ,SAAUsB,EAAsBA,GAGnE,CACA,QAAAvF,GACI,MAAO,GAAGrV,KAAKsZ,SAAW,IAAM,QAAO,QAAYtZ,KAAKuZ,qBAAoB,QAAYvZ,KAAKwZ,cACjG,EAEJ,SAASJ,EAAgByB,GACrB,MAAM5V,EAAS,GACf,IAAI6V,EAAa,KACjB,IAAK,MAAMC,KAAgBF,EAAe,CACtC,MAAMG,GAAc,QAAsBF,EAAYC,EAAarV,cAC9D,QAAasV,IACd/V,EAAOqC,KAAK,IAAI4S,GAAc,EAAOc,EAAaA,IAEtD,MAAMzB,GAAe,QAAsBwB,EAAarV,YAAaqV,EAAalV,WAClFZ,EAAOqC,KAAK,IAAI4S,GAAc,EAAMX,EAAcwB,EAAa3F,YAC/D0F,EAAaC,EAAalV,SAC9B,CACA,OAAOZ,CACX,C,yNC9GO,SAASgW,EAAWC,EAAgBC,EAAkBC,EAAcC,GACvE,OAAQH,IAAmBE,EACrBE,EAASF,EAAeF,EAAgBG,GACxCC,EAAS,EAAGD,EAAiBF,EACvC,CACO,MAAMI,EAAa,EACnB,SAASC,EAAapW,GACzB,OAAkB,IAAXA,CACX,CAMA,MAAMqW,EAAS,GAAK,GAIb,SAASH,EAASlM,EAAWgF,GAKhC,OAAQhF,EAAYqM,EAASrH,CACjC,CACO,SAASsH,EAAYtW,GACxB,MAAMuW,EAAIvW,EACJgK,EAAY5O,KAAKob,MAAMD,EAAIF,GAC3BrH,EAAcuH,EAAIvM,EAAYqM,EACpC,OAAO,IAAI,IAAWrM,EAAWgF,EACrC,CACO,SAASyH,EAAmBzW,GAC/B,OAAO5E,KAAKob,MAAMxW,EAASqW,EAC/B,CAIO,SAASK,EAAoC1W,GAChD,OAAOA,CACX,CACO,SAAS2W,EAAUC,EAAIC,GAC1B,IAAIvX,EAAIsX,EAAKC,EAIb,OAHIA,GAAMR,IACN/W,GAASsX,EAAKP,GAEX/W,CACX,CACO,SAASwX,EAAWC,EAAOC,GAC9B,OAAOD,EAAME,QAAO,CAACC,EAAGpR,IAAM6Q,EAAUO,EAAGF,EAASlR,KAAKqQ,EAC7D,CACO,SAASgB,EAAaC,EAASC,GAClC,OAAOD,IAAYC,CACvB,CAIO,SAASC,EAAsBF,EAASC,GAC3C,MAAMT,EAAKQ,EACLP,EAAKQ,EAEX,GADaR,EAAKD,GACN,EAGR,OAAOT,EAEX,MAAMoB,EAAanc,KAAKob,MAAMI,EAAKP,GAC7BmB,EAAapc,KAAKob,MAAMK,EAAKR,GAC7BoB,EAAYZ,EAAKW,EAAanB,EACpC,GAAIkB,IAAeC,EAAY,CAE3B,OAAOtB,EAAS,EAAGuB,GADDb,EAAKW,EAAalB,GAExC,CAEI,OAAOH,EAASsB,EAAaD,EAAYE,EAEjD,CACO,SAASC,EAAeN,EAASC,GAEpC,OAAOD,EAAUC,CACrB,CACO,SAASM,EAAoBP,EAASC,GACzC,OAAOD,GAAWC,CACtB,CACO,SAASO,EAAuBR,EAASC,GAC5C,OAAOD,GAAWC,CACtB,CACO,SAASQ,EAAiBnW,GAC7B,OAAOwU,EAASxU,EAAS6D,WAAa,EAAG7D,EAAS8D,OAAS,EAC/D,CACO,SAASsS,EAAeC,EAAaC,GACxC,MAAMzB,EAAIwB,EACJ/N,EAAY5O,KAAKob,MAAMD,EAAIF,GAC3B4B,EAAW1B,EAAIvM,EAAYqM,EAC3BQ,EAAKmB,EACLR,EAAapc,KAAKob,MAAMK,EAAKR,GAC7BoB,EAAYZ,EAAKW,EAAanB,EACpC,OAAO,IAAI,IAAMrM,EAAY,EAAGiO,EAAW,EAAGT,EAAa,EAAGC,EAAY,EAC9E,CACO,SAASS,EAAetF,GAC3B,MAAMuF,GAAQ,QAAWvF,GACzB,OAAOsD,EAASiC,EAAMnY,OAAS,EAAGmY,EAAMA,EAAMnY,OAAS,GAAGA,OAC9D,C,mFCpDO,SAASoY,EAA0BrB,EAAOsB,GAAuB,GACpE,GAAqB,IAAjBtB,EAAM/W,OACN,OAAO,KAEX,GAAqB,IAAjB+W,EAAM/W,OACN,OAAO+W,EAAM,GAEjB,IAAI/W,EAAS+W,EAAM/W,OAEnB,KAAOA,EAAS,GAAG,CACf,MAAMgQ,EAAYhQ,GAAU,EAC5B,IAAK,IAAImC,EAAI,EAAGA,EAAI6N,EAAW7N,IAAK,CAChC,MAAMmW,EAAInW,GAAK,EACf4U,EAAM5U,GAAK,cAAqB4U,EAAMuB,GAAIvB,EAAMuB,EAAI,GAAIA,EAAI,IAAMtY,EAAS+W,EAAMuB,EAAI,GAAK,KAAMD,EACpG,CACArY,EAASgQ,CACb,CACA,OAAO,cAAqB+G,EAAM,GAAIA,EAAM,GAAI/W,GAAU,EAAI+W,EAAM,GAAK,KAAMsB,EACnF,CACA,SAASE,EAAWC,EAAOC,GACvB,OAAOrd,KAAKsd,IAAIF,EAAM5M,WAAa6M,EAAM7M,WAC7C,CACA,SAAS+M,EAAOH,EAAOC,GACnB,OAAID,EAAM5M,aAAe6M,EAAM7M,WACpB,cAAqB4M,EAAOC,EAAO,MAAM,GAE3CD,EAAM5M,WAAa6M,EAAM7M,WAYtC,SAAgBgN,EAAMC,GAElB,IAAIC,EADJF,EAAOA,EAAKrL,YAEZ,MAAMwL,EAAU,GAChB,IAAIC,EACJ,OAAa,CAET,GAAIH,EAAajN,aAAekN,EAAQlN,WAAY,CAChDoN,EAA8BH,EAC9B,KACJ,CAEA,GAAqB,IAAjBC,EAAQhX,KACR,MAAM,IAAIgK,MAAM,cAEpBiN,EAAQ7W,KAAK4W,GAEbA,EAAUA,EAAQ1L,wBACtB,CAEA,IAAK,IAAIjL,EAAI4W,EAAQ/Y,OAAS,EAAGmC,GAAK,EAAGA,IAAK,CAC1C,MAAM8W,EAASF,EAAQ5W,GACnB6W,EAEIC,EAAOtW,gBAAkB,EAIzBqW,EAA8B,cAAqBC,EAAO/K,gBAAiB8K,EAA6B,MAAM,IAG9GC,EAAOhL,wBAAwB+K,GAC/BA,OAA8B9d,GAIlC+d,EAAOrL,uBAEf,CACA,OAAIoL,EACO,cAAqBJ,EAAMI,EAA6B,MAAM,GAG9DJ,CAEf,CAvDeM,CAAOV,EAAOC,GA4D7B,SAAiBG,EAAMC,GAEnB,IAAIC,EADJF,EAAOA,EAAKrL,YAEZ,MAAMwL,EAAU,GAEhB,KAAOF,EAAajN,aAAekN,EAAQlN,YAAY,CAEnD,GAAqB,IAAjBkN,EAAQhX,KACR,MAAM,IAAIgK,MAAM,cAEpBiN,EAAQ7W,KAAK4W,GAEbA,EAAUA,EAAQrL,yBACtB,CACA,IAAI0L,EAA+BN,EAEnC,IAAK,IAAI1W,EAAI4W,EAAQ/Y,OAAS,EAAGmC,GAAK,EAAGA,IAAK,CAC1C,MAAM8W,EAASF,EAAQ5W,GACnBgX,EAEIF,EAAOtW,gBAAkB,EAIzBwW,EAA+B,cAAqBA,EAA8BF,EAAO7K,iBAAkB,MAAM,IAGjH6K,EAAO9K,yBAAyBgL,GAChCA,OAA+Bje,GAInC+d,EAAOrL,uBAEf,CACA,OAAIuL,EACO,cAAqBA,EAA8BP,EAAM,MAAM,GAG/DA,CAEf,CAlGeQ,CAAQX,EAAOD,EAE9B,CCnFO,MAAMa,EACT,WAAAte,CAAY8F,GACRjG,KAAK8a,WAAa,KAClB9a,KAAK0e,UAAY,CAACzY,GAClBjG,KAAK2e,QAAU,CAAC,MAChB3e,KAAK4e,KAAO,EAChB,CAKA,iBAAAC,CAAkBtN,EAAQuN,GACtB,IAAI,QAAevN,EAAQvR,KAAK8a,YAC5B,MAAM,IAAI5J,MAAM,kBAIpB,IAFAlR,KAAK8a,WAAavJ,IAEL,CACT,MAAM2M,EAAUa,EAAgB/e,KAAK0e,WACrC,IAAKR,EACD,OAEJ,MAAMc,EAAgBD,EAAgB/e,KAAK2e,SAC3C,IAAI,QAAepN,EAAQyN,GAGvB,OAEJ,IAAI,QAAeA,EAAezN,GAE9B,IAAI,QAAUyN,EAAed,EAAQ9Y,SAAWmM,EAE5CvR,KAAKif,2BAEJ,CAED,MAAMC,EAAeC,EAAgBjB,IACf,IAAlBgB,GAEAlf,KAAK0e,UAAUpX,KAAK4W,EAAQlW,SAASkX,IACrClf,KAAK2e,QAAQrX,KAAK0X,GAClBhf,KAAK4e,KAAKtX,KAAK4X,IAIflf,KAAKif,sBAEb,KAEC,CAED,GAAIH,EAAUZ,GAEV,OADAle,KAAKif,uBACEf,EAEN,CACD,MAAMgB,EAAeC,EAAgBjB,GAErC,IAAsB,IAAlBgB,EAGA,YADAlf,KAAKif,uBAKLjf,KAAK0e,UAAUpX,KAAK4W,EAAQlW,SAASkX,IACrClf,KAAK2e,QAAQrX,KAAK0X,GAClBhf,KAAK4e,KAAKtX,KAAK4X,EAEvB,CACJ,CACJ,CACJ,CAEA,oBAAAD,GACI,OAAa,CACT,MAAMG,EAAgBL,EAAgB/e,KAAK2e,SACrCU,EAAcN,EAAgB/e,KAAK0e,WAGzC,GAFA1e,KAAK0e,UAAU9K,MACf5T,KAAK2e,QAAQ/K,MACY,IAArB5T,KAAK4e,KAAKxZ,OAEV,MAGJ,MAAMiZ,EAASU,EAAgB/e,KAAK0e,WAC9BQ,EAAeC,EAAgBd,EAAQre,KAAK4e,KAAK5e,KAAK4e,KAAKxZ,OAAS,IAC1E,IAAsB,IAAlB8Z,EAAqB,CACrBlf,KAAK0e,UAAUpX,KAAK+W,EAAOrW,SAASkX,IACpClf,KAAK2e,QAAQrX,MAAK,QAAU8X,EAAeC,EAAYja,SACvDpF,KAAK4e,KAAK5e,KAAK4e,KAAKxZ,OAAS,GAAK8Z,EAClC,KACJ,CAEIlf,KAAK4e,KAAKhL,KAIlB,CACJ,EAEJ,SAASuL,EAAgBlZ,EAAMqZ,GAAS,GACpC,OAAa,CAET,KADAA,GACcrZ,EAAK8B,eACf,OAAQ,EAEZ,GAAI9B,EAAK+B,SAASsX,GACd,OAAOA,CAEf,CACJ,CACA,SAASP,EAAgBlF,GACrB,OAAOA,EAAIzU,OAAS,EAAIyU,EAAIA,EAAIzU,OAAS,QAAK9E,CAClD,CC9GO,SAASif,EAActb,EAAWO,EAAOgb,EAAS/B,GAErD,OADe,IAAIgC,EAAOxb,EAAWO,EAAOgb,EAAS/B,GACvC8B,eAClB,CAIA,MAAME,EACF,WAAAtf,CAAY8D,EAAWO,EAAOgb,EAAS/B,GAKnC,GAJAzd,KAAKiE,UAAYA,EACjBjE,KAAKyd,qBAAuBA,EAC5Bzd,KAAK0f,kBAAoB,EACzB1f,KAAK2f,gBAAkB,EACnBH,GAAW/B,EACX,MAAM,IAAIvM,MAAM,iBAEpBlR,KAAK4f,cAAgBJ,EAAU,IAAIf,EAAWe,QAAWlf,EACzDN,KAAK6f,eAAiB,IAAI,IAAyBrb,EACvD,CACA,aAAA+a,GACIvf,KAAK0f,kBAAoB,EACzB1f,KAAK2f,gBAAkB,EACvB,IAAI1a,EAASjF,KAAK8f,UAAU,gBAA8B,GAI1D,OAHK7a,IACDA,EAAS,iBAENA,CACX,CACA,SAAA6a,CAAU/K,EAAkBtN,GACxB,MAAM0U,EAAQ,GACd,OAAa,CACT,IAAI/U,EAAQpH,KAAK+f,sBAAsBhL,GACvC,IAAK3N,EAAO,CACR,MAAM4Y,EAAQhgB,KAAKiE,UAAUgc,OAC7B,IAAKD,GACe,IAAfA,EAAM9Y,MACH8Y,EAAMrL,WAAWtD,WAAW0D,GAChC,MAEJ3N,EAAQpH,KAAKkgB,WAAWnL,EAAkBtN,EAAQ,EACtD,CACmB,IAAfL,EAAMF,MAA8D,IAAzBE,EAAMW,gBAGrDoU,EAAM7U,KAAKF,EACf,CAEA,MAAMnC,EAASjF,KAAK4f,cFjDrB,SAAuBzD,GAC1B,GAAqB,IAAjBA,EAAM/W,OACN,OAAO,KAEX,GAAqB,IAAjB+W,EAAM/W,OACN,OAAO+W,EAAM,GAEjB,IAAI5U,EAAI,EAIR,SAAS4Y,IACL,GAAI5Y,GAAK4U,EAAM/W,OACX,OAAO,KAEX,MAAM+O,EAAQ5M,EACR6Y,EAASjE,EAAMhI,GAAOnD,WAE5B,IADAzJ,IACOA,EAAI4U,EAAM/W,QAAU+W,EAAM5U,GAAGyJ,aAAeoP,GAC/C7Y,IAEJ,OAAIA,EAAI4M,GAAS,EACNqJ,EAAoC,IAAVrJ,GAAe5M,IAAM4U,EAAM/W,OAAS+W,EAAQA,EAAMkE,MAAMlM,EAAO5M,IAAI,GAG7F4U,EAAMhI,EAErB,CAGA,IAAImM,EAAQH,IACRI,EAASJ,IACb,IAAKI,EACD,OAAOD,EAEX,IAAK,IAAItU,EAAOmU,IAAYnU,EAAMA,EAAOmU,IAEjCxC,EAAW2C,EAAOC,IAAW5C,EAAW4C,EAAQvU,IAChDsU,EAAQvC,EAAOuC,EAAOC,GACtBA,EAASvU,GAGTuU,EAASxC,EAAOwC,EAAQvU,GAIhC,OADe+R,EAAOuC,EAAOC,EAEjC,CEE4CC,CAAcrE,GAASqB,EAA0BrB,EAAOnc,KAAKyd,sBACjG,OAAOxY,CACX,CACA,qBAAA8a,CAAsBhL,GAClB,GAAI/U,KAAK4f,cAAe,CACpB,MAAMa,EAAqBzgB,KAAK6f,eAAe5J,wBAAwBjW,KAAKiE,UAAUsN,QACtF,GAA2B,OAAvBkP,KAAgC,QAAaA,GAAqB,CAClE,MAAMC,EAAa1gB,KAAK4f,cAAcf,kBAAkB7e,KAAK6f,eAAe/J,sBAAsB9V,KAAKiE,UAAUsN,SAAS2M,IAGtH,GAA2B,OAAvBuC,KAAgC,QAAevC,EAAQ9Y,OAAQqb,GAG/D,OAAO,EAGX,OADoBvC,EAAQ/M,YAAY4D,EACtB,IAEtB,GAAI2L,EAGA,OAFA1gB,KAAK2f,kBACL3f,KAAKiE,UAAU0c,KAAKD,EAAWtb,QACxBsb,CAEf,CACJ,CAEJ,CACA,UAAAR,CAAWnL,EAAkBtN,GACzBzH,KAAK0f,oBACL,MAAMM,EAAQhgB,KAAKiE,UAAUxC,OAC7B,OAAQue,EAAM9Y,MACV,KAAK,EACD,OAAO,IAAI,KAAsB8Y,EAAMrL,WAAYqL,EAAM5a,QAC7D,KAAK,EACD,OAAO4a,EAAMY,QACjB,KAAK,EAAkC,CACnC,GAAInZ,EAAQ,IAER,OAAO,IAAI,KAAYuY,EAAM5a,QAEjC,MAAMoD,EAAMuM,EAAiB/C,MAAMgO,EAAMrL,YACnCvN,EAAQpH,KAAK8f,UAAUtX,EAAKf,EAAQ,GACpCoZ,EAAY7gB,KAAKiE,UAAUgc,OACjC,OAAIY,GACmB,IAAnBA,EAAU3Z,OACT2Z,EAAUC,YAAcd,EAAMc,WAAaD,EAAUlM,WAAWtD,WAAW2O,EAAMrL,cAClF3U,KAAKiE,UAAUxC,OACR,YAAmBue,EAAMY,QAASxZ,EAAOyZ,EAAUD,UAGnD,YAAmBZ,EAAMY,QAASxZ,EAAO,KAExD,CACA,QACI,MAAM,IAAI8J,MAAM,cAE5B,E,sDChHJ,MAAM6P,EAAW,GAKV,MAAMC,EACT,aAAOlQ,CAAOqL,EAAO8E,GACjB,GAAI9E,GAAS,KAAkC,IAA3B8E,EAAgB7b,OAAc,CAE9C,IAAI8b,EAASF,EAAkBG,MAAMhF,GAKrC,OAJK+E,IACDA,EAAS,IAAIF,EAAkB7E,EAAO8E,GACtCD,EAAkBG,MAAMhF,GAAS+E,GAE9BA,CACX,CACA,OAAO,IAAIF,EAAkB7E,EAAO8E,EACxC,CACA,eAAO9O,GACH,OAAOnS,KAAKohB,KAChB,CACA,WAAAjhB,CAAYgc,EAAO8E,GACfjhB,KAAKmc,MAAQA,EACbnc,KAAKihB,gBAAkBA,CAC3B,CACA,GAAAhX,CAAIR,EAAO4X,GACP,MAAMC,EAAMD,EAAYhK,OAAO5N,GAC/B,IAAIwH,EAAMqQ,GAAO,EACjB,GAAY,IAARrQ,EAAW,CAEX,MAAMsQ,EAAW,GAAKD,EAAOthB,KAAKmc,MAClC,OAAIoF,IAAYvhB,KAAKmc,MACVnc,KAEJghB,EAAkBlQ,OAAOyQ,EAASvhB,KAAKihB,gBAClD,CACAhQ,IACA,MAAMuQ,EAAWxhB,KAAKihB,gBAAgBZ,MAAM,GAC5C,KAAOmB,EAASpc,OAAS6L,GACrBuQ,EAASla,KAAK,GAGlB,OADAka,EAASvQ,IAAQ,IAAY,GAANqQ,GAChBN,EAAkBlQ,OAAO9Q,KAAKmc,MAAOqF,EAChD,CACA,KAAAxP,CAAMhR,GACF,MAAMygB,EAASzhB,KAAKmc,MAAQnb,EAAMmb,MAClC,GAAInc,KAAKihB,kBAAoBF,GAAY/f,EAAMigB,kBAAoBF,EAE/D,OAAIU,IAAWzhB,KAAKmc,MACTnc,KAEPyhB,IAAWzgB,EAAMmb,MACVnb,EAEJggB,EAAkBlQ,OAAO2Q,EAAQV,GAG5C,MAAMS,EAAW,GACjB,IAAK,IAAIja,EAAI,EAAGA,EAAI/G,KAAKC,IAAIT,KAAKihB,gBAAgB7b,OAAQpE,EAAMigB,gBAAgB7b,QAASmC,IAAK,CAC1F,MAAMqK,EAAQ5R,KAAKihB,gBAAgB1Z,IAAM,EACnCsK,EAAQ7Q,EAAMigB,gBAAgB1Z,IAAM,EAC1Cia,EAASla,KAAKsK,EAAQC,EAC1B,CACA,OAAOmP,EAAkBlQ,OAAO2Q,EAAQD,EAC5C,CACA,UAAAnQ,CAAWrQ,GACP,GAAmC,IAA9BhB,KAAKmc,MAAQnb,EAAMmb,OACpB,OAAO,EAEX,IAAK,IAAI5U,EAAI,EAAGA,EAAI/G,KAAK2M,IAAInN,KAAKihB,gBAAgB7b,OAAQpE,EAAMigB,gBAAgB7b,QAASmC,IACrF,GAA6D,IAAxDvH,KAAKihB,gBAAgB1Z,GAAKvG,EAAMigB,gBAAgB1Z,IACjD,OAAO,EAGf,OAAO,CACX,EAEJyZ,EAAkBG,MAAQ,IAAIxN,MAAM,KACpCqN,EAAkBI,MAAQJ,EAAkBlQ,OAAO,EAAGiQ,GAC/C,MAAMW,EAAsB,CAC/BrK,OAAO5N,GACIA,GAMR,MAAMkY,EACT,WAAAxhB,GACIH,KAAKmc,MAAQ,IAAIhW,GACrB,CACA,MAAAkR,CAAO5N,GACH,IAAInB,EAAWtI,KAAKmc,MAAM5T,IAAIkB,GAK9B,YAJiBnJ,IAAbgI,IACAA,EAAWtI,KAAKmc,MAAMtD,KACtB7Y,KAAKmc,MAAM3T,IAAIiB,EAAOnB,IAEnBA,CACX,E,gHC7FG,MAAMsZ,EACT,WAAAzhB,CAAYiF,EAAQ8B,EAMpB4Z,EAMAnM,EAAYiM,GACR5gB,KAAKoF,OAASA,EACdpF,KAAKkH,KAAOA,EACZlH,KAAK8gB,UAAYA,EACjB9gB,KAAK2U,WAAaA,EAClB3U,KAAK4gB,QAAUA,CACnB,EAEG,MAAMiB,EACT,WAAA1hB,CAAY6C,EAAW8e,GACnB9hB,KAAKgD,UAAYA,EACjBhD,KAAK8hB,cAAgBA,EACrB9hB,KAAK+hB,OAAS,IAAIC,EAA+BhiB,KAAKgD,UAAWhD,KAAK8hB,eACtE9hB,KAAKiiB,QAAU,KACfjiB,KAAKkiB,SAAU,EACfliB,KAAKmiB,OAAS,KACdniB,KAAKoiB,oBAAsBpf,EAAUqM,eACrCrP,KAAKqiB,yBAA2Brf,EAAUsf,cAActiB,KAAKoiB,oBACjE,CACA,UAAI7Q,GACA,OAAOvR,KAAKiiB,OAChB,CACA,UAAI7c,GACA,OAAO,QAASpF,KAAKoiB,oBAAsB,EAAGpiB,KAAKqiB,yBACvD,CACA,IAAA1B,CAAKvb,GACDpF,KAAKkiB,SAAU,EACfliB,KAAKiiB,SAAU,QAAUjiB,KAAKiiB,QAAS7c,GACvC,MAAM5D,GAAM,QAAYxB,KAAKiiB,SAC7BjiB,KAAK+hB,OAAOQ,YAAY/gB,EAAI4N,UAAW5N,EAAI4S,YAC/C,CACA,IAAA3S,GACI,IAAIue,EAWJ,OAVIhgB,KAAKmiB,QACLniB,KAAKkiB,SAAU,EACflC,EAAQhgB,KAAKmiB,QAGbnC,EAAQhgB,KAAK+hB,OAAOtgB,OAEpBue,IACAhgB,KAAKiiB,SAAU,QAAUjiB,KAAKiiB,QAASjC,EAAM5a,SAE1C4a,CACX,CACA,IAAAC,GAKI,OAJKjgB,KAAKkiB,UACNliB,KAAKmiB,OAASniB,KAAK+hB,OAAOtgB,OAC1BzB,KAAKkiB,SAAU,GAEZliB,KAAKmiB,MAChB,EAKJ,MAAMH,EACF,WAAA7hB,CAAY6C,EAAW8e,GACnB9hB,KAAKgD,UAAYA,EACjBhD,KAAK8hB,cAAgBA,EACrB9hB,KAAKwiB,QAAU,EACfxiB,KAAKyiB,KAAO,KACZziB,KAAK0iB,eAAiB,EACtB1iB,KAAKuM,WAAa,KAClBvM,KAAK2iB,gBAAkB,EAEvB3iB,KAAK4iB,YAAc,KACnB5iB,KAAKoiB,oBAAsBpf,EAAUqM,eACrCrP,KAAKqiB,yBAA2Brf,EAAUsf,cAActiB,KAAKoiB,oBACjE,CACA,WAAAG,CAAYC,EAAS5X,GAEb4X,IAAYxiB,KAAKwiB,SACjBxiB,KAAK0iB,eAAiB9X,EACJ,OAAd5K,KAAKyiB,OACLziB,KAAK2iB,gBAA0C,IAAxB3iB,KAAK0iB,eAAuB,EAAI1iB,KAAKuM,WAAWkB,uBAAuBzN,KAAK0iB,mBAIvG1iB,KAAKwiB,QAAUA,EACfxiB,KAAK0iB,eAAiB9X,EACtB5K,KAAKyiB,KAAO,MAEhBziB,KAAK4iB,YAAc,IACvB,CACA,IAAAnhB,GACI,GAAIzB,KAAK4iB,YAAa,CAClB,MAAM5C,EAAQhgB,KAAK4iB,YAGnB,OAFA5iB,KAAK4iB,YAAc,KACnB5iB,KAAK0iB,iBAAkB,QAAoC1C,EAAM5a,QAC1D4a,CACX,CACA,GAAIhgB,KAAKwiB,QAAUxiB,KAAKoiB,oBAAsB,GAAMpiB,KAAKwiB,UAAYxiB,KAAKoiB,oBAAsB,GAAKpiB,KAAK0iB,gBAAkB1iB,KAAKqiB,yBAE7H,OAAO,KAEO,OAAdriB,KAAKyiB,OACLziB,KAAKuM,WAAavM,KAAKgD,UAAUS,aAAa8J,cAAcvN,KAAKwiB,QAAU,GAC3ExiB,KAAKyiB,KAAOziB,KAAKuM,WAAWa,iBAC5BpN,KAAK2iB,gBAA0C,IAAxB3iB,KAAK0iB,eAAuB,EAAI1iB,KAAKuM,WAAWkB,uBAAuBzN,KAAK0iB,iBAEvG,MAAMG,EAAe7iB,KAAKwiB,QACpBM,EAAsB9iB,KAAK0iB,eAGjC,IAAIK,EAAkB,EACtB,OAAa,CACT,MAAMxW,EAAavM,KAAKuM,WAClBG,EAAaH,EAAWI,WAC9B,IAAIqW,EAAqB,KACzB,GAAIhjB,KAAK2iB,gBAAkBjW,EAAY,CACnC,MAAMuW,EAAgB1W,EAAW2W,YAAYljB,KAAK2iB,iBAClD,KAAO3iB,KAAK2iB,gBAAkB,EAAIjW,GAAcuW,IAAkB1W,EAAW2W,YAAYljB,KAAK2iB,gBAAkB,IAG5G3iB,KAAK2iB,kBAET,MAAMQ,EAAwD,IAA9C,iBAA2BF,GACrCG,EAAsB,6BAAuCH,GAC7Dpd,EAAY0G,EAAWS,aAAahN,KAAK2iB,iBAE/C,GAAIS,GAAuBD,GAAWnjB,KAAK0iB,eAAiB7c,EAAW,CACnE,MAAM/C,EAAayJ,EAAWvI,cAAchE,KAAK2iB,iBAC3C/gB,EAAO5B,KAAKyiB,KAAK1U,UAAU/N,KAAK0iB,eAAgB7c,GAChD9C,EAAW/C,KAAK8hB,cAAc/d,+BAA+BjB,GAC7DugB,EAAStgB,EAASsV,aACxB,GAAIgL,EAAQ,CACRA,EAAOC,UAAY,EACnB,MAAMC,EAAQF,EAAOG,KAAK5hB,GACtB2hB,IACAP,EAAqBjgB,EAASyV,SAAS+K,EAAM,IACzCP,IAEAhjB,KAAK0iB,gBAAkBa,EAAMnT,OAGzC,CACJ,CAEA,GADA2S,GAAmBld,EAAY7F,KAAK0iB,eAChCM,EAAoB,CAEpB,GAAIH,IAAiB7iB,KAAKwiB,SAAWM,IAAwB9iB,KAAK0iB,eAAgB,CAE9E1iB,KAAK4iB,YAAcI,EACnB,KACJ,CAII,OADAhjB,KAAK0iB,iBAAkB,QAAoCM,EAAmB5d,QACvE4d,CAEf,CAGIhjB,KAAK2iB,kBACL3iB,KAAK0iB,eAAiB7c,CAE9B,KACK,CACD,GAAI7F,KAAKwiB,UAAYxiB,KAAKoiB,oBAAsB,EAC5C,MASJ,GAPApiB,KAAKwiB,UACLxiB,KAAKuM,WAAavM,KAAKgD,UAAUS,aAAa8J,cAAcvN,KAAKwiB,QAAU,GAC3ExiB,KAAK2iB,gBAAkB,EACvB3iB,KAAKyiB,KAAOziB,KAAKuM,WAAWa,iBAC5BpN,KAAK0iB,eAAiB,EACtBK,GAAmB,GAEfA,EAAkB,IAElB,KAER,CACA,GAAIA,EAAkB,KAKlB,KAER,CAIA,MAAM3d,GAAS,QAAWyd,EAAcC,EAAqB9iB,KAAKwiB,QAASxiB,KAAK0iB,gBAChF,OAAO,IAAId,EAAMxc,EAAQ,GAAyB,EAAG,gBAA8B,IAAI,KAAYA,GACvG,EAEG,MAAMqe,EACT,WAAAtjB,CAAYyB,EAAMmB,GACd/C,KAAK4B,KAAOA,EACZ5B,KAAKiiB,QAAU,KACfjiB,KAAKiR,IAAM,EACX,MAAMqH,EAAYvV,EAAS4U,eACrB0L,EAAS/K,EAAY,IAAIC,OAAOD,EAAY,MAAO,MAAQ,KAC3DoL,EAAS,GACf,IAAIH,EACAI,EAAe,EACfC,EAAsB,EACtBC,EAAqB,EACrBC,EAAmB,EACvB,MAAMC,EAAuB,GAC7B,IAAK,IAAIxc,EAAI,EAAGA,EAAI,GAAIA,IACpBwc,EAAqBzc,KAAK,IAAIsa,GAAM,QAAS,EAAGra,GAAI,GAAyB,EAAG,gBAA8B,IAAI,MAAY,QAAS,EAAGA,MAE9I,MAAMyc,EAAuB,GAC7B,IAAK,IAAIzc,EAAI,EAAGA,EAAI,GAAIA,IACpByc,EAAqB1c,KAAK,IAAIsa,GAAM,QAAS,EAAGra,GAAI,GAAyB,EAAG,gBAA8B,IAAI,MAAY,QAAS,EAAGA,MAE9I,GAAI8b,EAGA,IAFAA,EAAOC,UAAY,EAEoB,QAA/BC,EAAQF,EAAOG,KAAK5hB,KAAiB,CACzC,MAAMkH,EAAYya,EAAMnT,MAClB3G,EAAQ8Z,EAAM,GACpB,GAAc,OAAV9Z,EACAka,IACAC,EAAsB9a,EAAY,MAEjC,CACD,GAAI+a,IAAuB/a,EAAW,CAClC,IAAIkX,EACJ,GAAI8D,IAAqBH,EAAc,CACnC,MAAMtG,EAAWvU,EAAY+a,EAC7B,GAAIxG,EAAW0G,EAAqB3e,OAChC4a,EAAQ+D,EAAqB1G,OAE5B,CACD,MAAMjY,GAAS,QAAS,EAAGiY,GAC3B2C,EAAQ,IAAI4B,EAAMxc,EAAQ,GAAyB,EAAG,gBAA8B,IAAI,KAAYA,GACxG,CACJ,KACK,CACD,MAAMgK,EAAYuU,EAAeG,EAC3BzG,EAAWvU,EAAY8a,EAC7B,GAAkB,IAAdxU,GAAmBiO,EAAW2G,EAAqB5e,OACnD4a,EAAQgE,EAAqB3G,OAE5B,CACD,MAAMjY,GAAS,QAASgK,EAAWiO,GACnC2C,EAAQ,IAAI4B,EAAMxc,EAAQ,GAAyB,EAAG,gBAA8B,IAAI,KAAYA,GACxG,CACJ,CACAse,EAAOpc,KAAK0Y,EAChB,CAEA0D,EAAOpc,KAAKvE,EAASyV,SAAS/O,IAC9Boa,EAAqB/a,EAAYW,EAAMrE,OACvC0e,EAAmBH,CACvB,CACJ,CAEJ,MAAMpS,EAAS3P,EAAKwD,OACpB,GAAIye,IAAuBtS,EAAQ,CAC/B,MAAMnM,EAAU0e,IAAqBH,GAC/B,QAAS,EAAGpS,EAASsS,IACrB,QAASF,EAAeG,EAAkBvS,EAASqS,GACzDF,EAAOpc,KAAK,IAAIsa,EAAMxc,EAAQ,GAAyB,EAAG,gBAA8B,IAAI,KAAYA,IAC5G,CACApF,KAAKoF,QAAS,QAASue,EAAcpS,EAASqS,GAC9C5jB,KAAK0jB,OAASA,CAClB,CACA,UAAInS,GACA,OAAOvR,KAAKiiB,OAChB,CACA,IAAAxgB,GACI,OAAOzB,KAAK0jB,OAAO1jB,KAAKiR,QAAU,IACtC,CACA,IAAAgP,GACI,OAAOjgB,KAAK0jB,OAAO1jB,KAAKiR,MAAQ,IACpC,CACA,IAAA0P,CAAKvb,GACD,MAAM,IAAI,IACd,E,8FC/RG,MAAM6e,UAAgD,KACzD,WAAA9jB,CAAY6C,GACRE,QACAlD,KAAKgD,UAAYA,EACjBhD,KAAKkkB,cAAgB,IAAIC,EACzBnkB,KAAKsJ,mBAAqB,IAAI,KAC9BtJ,KAAKqD,YAAcrD,KAAKsJ,mBAAmBhG,MAC3CtD,KAAKokB,oBAAsBphB,EAAUyR,aAAa3T,+BAClDd,KAAKqJ,UAAUrG,EAAUqhB,aAAahhB,aAAYmG,IAC9CxJ,KAAKsJ,mBAAmBjF,MAAM,IAEtC,CAEA,sBAAAwF,CAAuBL,GACnBxJ,KAAKokB,oBAAsBpkB,KAAKgD,UAAUyR,aAAa3T,8BAC3D,CAEA,qBAAAwjB,CAAsBljB,EAAOmjB,EAASC,EAAqBC,GACvD,GAAIA,EAEA,MAAO,GAEX,QAAgBnkB,IAAZikB,EACA,MAAO,GAEX,IAAKvkB,KAAKokB,oBAAoBM,QAC1B,MAAO,GAWX,OATe1kB,KAAKgD,UAAUqhB,aAAa7e,mBAAmBpE,GAAO,GAAMqD,KAAI6G,IAAW,CACtFqZ,GAAI,UAAUrZ,EAAQlK,MAAMiU,cAAc/J,EAAQsZ,eAClDC,QAAS,CACLC,YAAa,0BACbC,gBAAiB/kB,KAAKkkB,cAAcc,mBAAmB1Z,EAAStL,KAAKokB,oBAAoBa,qCAE7FV,QAAS,EACTnjB,MAAOkK,EAAQlK,UACf8jB,SAER,CACA,iBAAAC,CAAkBZ,EAASC,GACvB,YAAgBlkB,IAAZikB,EACO,GAENvkB,KAAKokB,oBAAoBM,QAGvB1kB,KAAKskB,sBAAsB,IAAI,IAAM,EAAG,EAAGtkB,KAAKgD,UAAUqM,eAAgB,GAAIkV,EAASC,GAFnF,EAGf,EAEJ,MAAML,EACF,WAAAhkB,GACIH,KAAKolB,kCAAoC,4BAC7C,CACA,kBAAAJ,CAAmB1Z,EAAS2Z,GACxB,OAAI3Z,EAAQ+Z,UACDrlB,KAAKolB,kCAETplB,KAAKslB,0BAA0BL,EAAqC3Z,EAAQ5D,+BAAiC4D,EAAQsZ,aAChI,CACA,yBAAAU,CAA0B7d,GAGtB,MAAO,wBAAwBA,EAAQ,EAC3C,GAEJ,SAA2B,CAAC8d,EAAOC,KAC/B,MAAMC,EAAS,CACX,KACA,KACA,KACA,KACA,KACA,MAEEvB,EAAgB,IAAIC,EAC1BqB,EAAUE,QAAQ,mBAAmBxB,EAAckB,8CAA8CG,EAAMI,SAAS,YAChH,MAAMC,EAAcH,EACfhhB,KAAIyQ,GAAKqQ,EAAMI,SAASzQ,KACxBnJ,QAAQmJ,KAAQA,IAChBnJ,QAAOmJ,IAAMA,EAAE2Q,kBACpB,IAAK,IAAIpe,EAAQ,EAAGA,EAAQ,GAAIA,IAAS,CACrC,MAAMqe,EAAQF,EAAYne,EAAQme,EAAYxgB,QAC9CogB,EAAUE,QAAQ,mBAAmBxB,EAAcoB,0BAA0B7d,eAAmBqe,OACpG,I,8FCnFG,SAASC,EAAkBrC,EAAQva,GACtC,MAAM/F,EAAmB,IAAI,KACvB0e,EAAgB,IAAI,IAA8B1e,GAAmBN,GAAeqG,EAA6BlG,yBAAyBH,KAC1ImB,EAAY,IAAI,KAAoB,IAAI+hB,EAAsB,CAACtC,IAAU5B,GACzE7b,GAAO,OAAchC,EAAW,QAAI3D,GAAW,GACrD,IAAI0X,EAAM,GACV,MAAMyK,EAAOiB,EAAOtW,iBAiCpB,OAhCA,SAAS6Y,EAAYhgB,EAAMsL,GACvB,GAAkB,IAAdtL,EAAKiB,KAOL,GANA+e,EAAYhgB,EAAKmC,eAAgBmJ,GACjCA,GAAS,QAAUA,EAAQtL,EAAKmC,eAAehD,QAC3Ca,EAAKmB,QACL6e,EAAYhgB,EAAKmB,MAAOmK,GACxBA,GAAS,QAAUA,EAAQtL,EAAKmB,MAAMhC,SAEtCa,EAAKiC,eACL+d,EAAYhgB,EAAKiC,eAAgBqJ,GACjCA,GAAS,QAAUA,EAAQtL,EAAKiC,eAAe9C,YAE9C,CACD,MACM8gB,EAD0BpE,EAAc/d,+BAA+BkC,EAAKmC,eAAetF,YAChD2V,qBAAqBxS,EAAKmC,eAAeuM,YAC1FqD,GAAOkO,CACX,MAEC,GAAkB,IAAdjgB,EAAKiB,WAGT,GAAkB,IAAdjB,EAAKiB,MAAmD,IAAdjB,EAAKiB,KACpD8Q,GAAOyK,EAAK1U,WAAU,QAAoCwD,IAAS,SAAoC,QAAUA,EAAQtL,EAAKb,eAE7H,GAAkB,IAAda,EAAKiB,KACV,IAAK,MAAME,KAASnB,EAAKoB,SACrB4e,EAAY7e,EAAOmK,GACnBA,GAAS,QAAUA,EAAQnK,EAAMhC,OAG7C,CACA6gB,CAAYhgB,EAAM,MACX+R,CACX,CACA,MAAMgO,EACF,WAAA7lB,CAAYod,GACRvd,KAAKud,MAAQA,EACbvd,KAAKyD,aAAe,CAChB8J,cAAgB5C,GACL3K,KAAKud,MAAM5S,EAAa,GAG3C,CACA,YAAA0E,GACI,OAAOrP,KAAKud,MAAMnY,MACtB,CACA,aAAAkd,CAAc3X,GACV,OAAO3K,KAAKud,MAAM5S,EAAa,GAAGyC,iBAAiBhI,MACvD,E,6HCrDJ,SAAS+gB,EAAoBC,GACzB,OAAOA,EAAS/Q,UACpB,CACO,MAAMgR,EACT,aAAOvV,CAAOrO,EAAO6jB,GACjB,MAAMC,EAAuB9jB,EAAM+jB,0BAC7BC,EAAMC,EAAYjkB,GACxB,OAAO,IAAI4jB,EAAyBE,EAAsBA,EAAsBE,EAAKA,EAAKH,EAAmBA,EAAmB,GACpI,CACA,WAAAnmB,CAAYwmB,EAAiBC,EAAgBC,EAAWC,EAAUR,EAAmBS,EAAkBzkB,GACnGtC,KAAK2mB,gBAAkBA,EACvB3mB,KAAK4mB,eAAiBA,EACtB5mB,KAAK6mB,UAAYA,EACjB7mB,KAAK8mB,SAAWA,EAChB9mB,KAAKsmB,kBAAoBA,EACzBtmB,KAAK+mB,iBAAmBA,EACxB/mB,KAAKsC,QAAUA,CACnB,CACA,MAAAgc,CAAO7b,EAAOukB,EAAaF,EAAUF,EAAgBG,GAC7CC,EAAY5hB,OAAS,IACrBpF,KAAKsC,SAAU,OAA+BtC,KAAKsC,QAAS0kB,IAEhEhnB,KAAK8mB,SAAWA,EAChB9mB,KAAK4mB,eAAiBA,EACtB5mB,KAAK+mB,iBAAmBA,CAC5B,CACA,2BAAOE,CAAqBC,GACxB,OAAO,EAAI,IAASA,EAAaA,EAAW9hB,OAAS,EACzD,CACA,uBAAO+hB,CAAiBjc,EAAGgc,EAAY3V,GAGnC,GAFA,KAAqBrG,EAAIgc,EAAaA,EAAW9hB,OAAS,EAAImM,GAC9DA,GAAU,EACN2V,EACA,IAAK,MAAME,KAAaF,EACpB,KAAqBhc,EAAGkc,EAAUC,yBAA0B9V,GAC5DA,GAAU,EACV,KAAqBrG,EAAGkc,EAAUE,qBAAsB/V,GACxDA,GAAU,EACV,KAAqBrG,EAAGkc,EAAUG,mBAAoBhW,GACtDA,GAAU,EACV,KAAqBrG,EAAGkc,EAAUI,eAAgBjW,GAClDA,GAAU,EAGlB,OAAOA,CACX,CACA,sBAAOkW,CAAgBvc,EAAGqG,EAAQmW,GAC9B,MAAMhZ,EAAQ,KAAoBxD,EAAGqG,GACrCA,GAAU,EACV,IAAK,IAAIhK,EAAI,EAAGA,EAAImH,EAAOnH,IAAK,CAC5B,MAAM8f,EAA2B,KAAoBnc,EAAGqG,GACxDA,GAAU,EACV,MAAM+V,EAAuB,KAAoBpc,EAAGqG,GACpDA,GAAU,EACV,MAAMgW,EAAqB,KAAoBrc,EAAGqG,GAClDA,GAAU,EACV,MAAMiW,EAAiB,KAAoBtc,EAAGqG,GAC9CA,GAAU,EACVmW,EAAKpgB,KAAK,IAAI,IAAU+f,EAA0BC,EAAsBC,EAAoBC,GAChG,CACA,OAAOjW,CACX,CACA,SAAAoW,GACI,IAAIC,EAAiB,GAIfvB,EAAyBY,qBAAqBjnB,KAAKsmB,mBACnDD,EAAyBY,qBAAqBjnB,KAAK+mB,kBACnD,EAEN,IAAK,MAAMhiB,KAAU/E,KAAKsC,QACtBslB,GAAiB7iB,EAAO8iB,YAE5B,MAAM3c,EAAI,IAAI4c,WAAWF,GACzB,IAAIrW,EAAS,EACb,KAAqBrG,EAAGlL,KAAK2mB,gBAAiBpV,GAC9CA,GAAU,EACV,KAAqBrG,EAAGlL,KAAK4mB,eAAgBrV,GAC7CA,GAAU,EACV,KAAkBrG,EAAGlL,KAAK6mB,UAAWtV,GACrCA,GAAU,EACV,KAAkBrG,EAAGlL,KAAK8mB,SAAUvV,GACpCA,GAAU,EACVA,EAAS8U,EAAyBc,iBAAiBjc,EAAGlL,KAAKsmB,kBAAmB/U,GAC9EA,EAAS8U,EAAyBc,iBAAiBjc,EAAGlL,KAAK+mB,iBAAkBxV,GAC7E,KAAqBrG,EAAGlL,KAAKsC,QAAQ8C,OAAQmM,GAC7CA,GAAU,EACV,IAAK,MAAMxM,KAAU/E,KAAKsC,QACtBiP,EAASxM,EAAOgjB,MAAM7c,EAAGqG,GAE7B,OAAOrG,EAAE8c,MACb,CACA,kBAAOC,CAAYC,GACf,MAAMhd,EAAI,IAAI4c,WAAWI,GACzB,IAAI3W,EAAS,EACb,MAAMoV,EAAkB,KAAoBzb,EAAGqG,GAC/CA,GAAU,EACV,MAAMqV,EAAiB,KAAoB1b,EAAGqG,GAC9CA,GAAU,EACV,MAAMsV,EAAY,KAAiB3b,EAAGqG,GACtCA,GAAU,EACV,MAAMuV,EAAW,KAAiB5b,EAAGqG,GACrCA,GAAU,EACV,MAAM+U,EAAoB,GAC1B/U,EAAS8U,EAAyBoB,gBAAgBvc,EAAGqG,EAAQ+U,GAC7D,MAAMS,EAAmB,GACzBxV,EAAS8U,EAAyBoB,gBAAgBvc,EAAGqG,EAAQwV,GAC7D,MAAMoB,EAAc,KAAoBjd,EAAGqG,GAC3CA,GAAU,EACV,MAAMjP,EAAU,GAChB,IAAK,IAAIiF,EAAI,EAAGA,EAAI4gB,EAAa5gB,IAC7BgK,EAAS,SAAgBrG,EAAGqG,EAAQjP,GAExC,OAAO,IAAI+jB,EAAyBM,EAAiBC,EAAgBC,EAAWC,EAAUR,EAAmBS,EAAkBzkB,EACnI,EAEG,MAAM8lB,EACT,QAAIC,GACA,OAAO,CACX,CACA,YAAIjC,GACA,OAAI,UAAUpmB,KAAKyC,OACRzC,KAAKyC,MAETzC,KAAKyC,MAAM6lB,GACtB,CACA,WAAAnoB,CAAYooB,EAAOC,EAAM/lB,EAAO6jB,GAC5BtmB,KAAKuoB,MAAQA,EACbvoB,KAAKwoB,KAAOA,EACZxoB,KAAKyC,MAAQA,EACbzC,KAAKyoB,MAAQpC,EAAyBvV,OAAOrO,EAAO6jB,EACxD,CACA,QAAAjR,GAEI,OADcrV,KAAKyoB,iBAAiBpC,EAA2BrmB,KAAKyoB,MAAQpC,EAAyB4B,YAAYjoB,KAAKyoB,QAC1GnmB,QAAQmC,KAAIM,GAAUA,EAAOsQ,aAAY+C,KAAK,KAC9D,CACA,eAAAsQ,CAAgBtC,GAEZ,OADa,UAAUpmB,KAAKyC,OAASzC,KAAKyC,MAAQzC,KAAKyC,MAAM6lB,KACjDjT,aAAe+Q,EAAS/Q,UACxC,CACA,QAAAsT,CAASlmB,GACLzC,KAAKyC,MAAQA,CACjB,CACA,SAAAmmB,CAAUnmB,GACN,OAAQzC,KAAKyC,QAAUA,GAASzC,KAAKyoB,iBAAiBpC,CAC1D,CACA,MAAA/H,CAAO7b,EAAOukB,EAAaF,EAAUF,EAAgBG,GAC7C/mB,KAAKyoB,iBAAiBpC,GACtBrmB,KAAKyoB,MAAMnK,OAAO7b,EAAOukB,EAAaF,EAAUF,EAAgBG,EAExE,CACA,KAAA8B,GACQ7oB,KAAKyoB,iBAAiBpC,IACtBrmB,KAAKyoB,MAAQzoB,KAAKyoB,MAAMd,YAEhC,CACA,IAAAmB,GACU9oB,KAAKyoB,iBAAiBpC,IACxBrmB,KAAKyoB,MAAQpC,EAAyB4B,YAAYjoB,KAAKyoB,OAE/D,CACA,IAAAM,GACI,GAAI,UAAU/oB,KAAKyC,OAEf,MAAM,IAAIyO,MAAM,uCAEhBlR,KAAKyoB,iBAAiBpC,IACtBrmB,KAAKyoB,MAAQzoB,KAAKyoB,MAAMd,aAE5B,MAAMlc,EAAO4a,EAAyB4B,YAAYjoB,KAAKyoB,OACvDzoB,KAAKyC,MAAMumB,WAAWvd,EAAKnJ,QAASmJ,EAAKob,UAAWpb,EAAKkb,gBAAiBlb,EAAK6a,kBACnF,CACA,IAAA2C,GACI,GAAI,UAAUjpB,KAAKyC,OAEf,MAAM,IAAIyO,MAAM,uCAEhBlR,KAAKyoB,iBAAiBpC,IACtBrmB,KAAKyoB,MAAQzoB,KAAKyoB,MAAMd,aAE5B,MAAMlc,EAAO4a,EAAyB4B,YAAYjoB,KAAKyoB,OACvDzoB,KAAKyC,MAAMymB,WAAWzd,EAAKnJ,QAASmJ,EAAKqb,SAAUrb,EAAKmb,eAAgBnb,EAAKsb,iBACjF,CACA,QAAAoC,GAII,OAHInpB,KAAKyoB,iBAAiBpC,IACtBrmB,KAAKyoB,MAAQzoB,KAAKyoB,MAAMd,aAErB3nB,KAAKyoB,MAAMW,WAAa,GACnC,EAEG,MAAMC,EACT,aAAIC,GACA,OAAOtpB,KAAKupB,sBAAsB9kB,KAAI+kB,GAAoBA,EAAiBpD,UAC/E,CACA,WAAAjmB,CAAYooB,EAAOC,EAAMiB,GACrBzpB,KAAKuoB,MAAQA,EACbvoB,KAAKwoB,KAAOA,EACZxoB,KAAKqoB,KAAO,EACZroB,KAAK0pB,SAAU,EACf1pB,KAAKupB,sBAAwBE,EAAkBpJ,MAAM,GACrDrgB,KAAK2pB,sBAAwB,IAAIxjB,IACjC,IAAK,MAAMqjB,KAAoBxpB,KAAKupB,sBAAuB,CACvD,MAAMjI,EAAM6E,EAAoBqD,EAAiBpD,UACjDpmB,KAAK2pB,sBAAsBnhB,IAAI8Y,EAAKkI,EACxC,CACAxpB,KAAK4pB,UAAY,IACrB,CACA,eAAAC,GACI,GAAI7pB,KAAK4pB,UACL,OAAO5pB,KAAK4pB,UAAUC,gBAAgB7pB,KAE9C,CACA,eAAA0oB,CAAgBtC,GACZ,MAAM9E,EAAM6E,EAAoBC,GAChC,OAAQpmB,KAAK2pB,sBAAsB3Z,IAAIsR,EAC3C,CACA,QAAAqH,CAASlmB,GACL,MAAM6e,EAAM6E,EAAoB,UAAU1jB,GAASA,EAAQA,EAAM6lB,KAC7DtoB,KAAK2pB,sBAAsB3Z,IAAIsR,IAC/BthB,KAAK2pB,sBAAsBphB,IAAI+Y,GAAKqH,SAASlmB,EAErD,CACA,SAAAmmB,CAAUnmB,GACN,IAAKzC,KAAK0pB,QACN,OAAO,EAEX,MAAMpI,EAAM6E,EAAoB1jB,EAAM6lB,KACtC,GAAItoB,KAAK2pB,sBAAsB3Z,IAAIsR,GAAM,CAErC,OADyBthB,KAAK2pB,sBAAsBphB,IAAI+Y,GAChCsH,UAAUnmB,EACtC,CACA,OAAO,CACX,CACA,MAAA6b,CAAO7b,EAAOukB,EAAaF,EAAUF,EAAgBG,GACjD,MAAMzF,EAAM6E,EAAoB1jB,EAAM6lB,KACbtoB,KAAK2pB,sBAAsBphB,IAAI+Y,GACvChD,OAAO7b,EAAOukB,EAAaF,EAAUF,EAAgBG,EAC1E,CACA,KAAA8B,GACI7oB,KAAK0pB,SAAU,CACnB,CACA,IAAAZ,GAEA,CACA,IAAAC,GACI/oB,KAAK0pB,SAAU,EACf,IAAK,MAAMF,KAAoBxpB,KAAKupB,sBAChCC,EAAiBT,MAEzB,CACA,IAAAE,GACI,IAAK,MAAMO,KAAoBxpB,KAAKupB,sBAChCC,EAAiBP,MAEzB,CACA,QAAAE,CAAS/C,GACL,MAAM9E,EAAM6E,EAAoBC,GAChC,GAAIpmB,KAAK2pB,sBAAsB3Z,IAAIsR,GAAM,CAErC,OADyBthB,KAAK2pB,sBAAsBphB,IAAI+Y,GAChC6H,UAC5B,CACA,OAAO,CACX,CACA,KAAAW,GACI,OAAO9pB,KAAKupB,qBAChB,CACA,QAAAlU,GACI,MAAMpQ,EAAS,GACf,IAAK,MAAMukB,KAAoBxpB,KAAKupB,sBAChCtkB,EAAOqC,KAAK,IAAG,QAASkiB,EAAiBpD,cAAcoD,KAE3D,MAAO,IAAIvkB,EAAOmT,KAAK,QAC3B,EAEJ,SAASsO,EAAYjkB,GAEjB,MAAY,OADAA,EAAMsnB,SAEP,EAGA,CAEf,CACO,SAASC,EAAmBC,GAC/B,QAAKA,IAGIA,aAAmB7B,GAAiC6B,aAAmBZ,EACpF,CACO,MAAMa,EACT,WAAA/pB,CAAYsC,EAAO0nB,GACfnqB,KAAKoqB,OAAS3nB,EACdzC,KAAKqqB,iBAAmBF,CAC5B,CACA,gBAAAG,GACI,MAAMC,EAAcvqB,KAAKqqB,iBAAiBG,eAAexqB,KAAKoqB,OAAO9B,KACjE0B,EAAmBO,IACnBA,EAAY1B,OAEpB,CACA,eAAA4B,GACI,MAAMF,EAAcvqB,KAAKqqB,iBAAiBG,eAAexqB,KAAKoqB,OAAO9B,KACjE0B,EAAmBO,IACnBA,EAAYzB,MAEpB,CACA,KAAAnf,GACI3J,KAAKqqB,iBAAiBK,eAAe1qB,KAAKoqB,OAAO9B,IACrD,CACA,4BAAAqC,CAA6BrE,EAAmBsE,GAC5C,MAAML,EAAcvqB,KAAKqqB,iBAAiBG,eAAexqB,KAAKoqB,OAAO9B,KACrE,GAAI0B,EAAmBO,IAAgBA,EAAY3B,UAAU5oB,KAAKoqB,QAC9D,OAAOG,EAEX,MAAMM,EAAa,IAAIzC,EAA4B,KAAa,OAAQ,UAAW,0BAA2BpoB,KAAKoqB,OAAQ9D,GAE3H,OADAtmB,KAAKqqB,iBAAiBS,YAAYD,EAAYD,GACvCC,CACX,CACA,OAAAE,CAAQtE,GACJ,MAAM+C,EAAmBxpB,KAAK2qB,6BAA6B,UAAMrqB,GACjEN,KAAKoqB,OAAOY,OAAOvE,GACnB+C,EAAiBlL,OAAOte,KAAKoqB,OAAQ,GAAI1D,EAAY1mB,KAAKoqB,QAASpqB,KAAKoqB,OAAO5D,0BAA2B,KAC9G,CACA,iBAAAyE,CAAkB3E,EAAmB4E,EAAgBC,EAAqBP,GACtE,MAAMpB,EAAmBxpB,KAAK2qB,6BAA6BrE,EAAmBsE,GACxEQ,EAAwBprB,KAAKoqB,OAAOiB,WAAWH,GAAgB,GAC/DnE,EAAmBmD,EAAUoB,oBAAoBH,EAAqBC,GACtEpE,EAAcoE,EAAsB3mB,KAAI,CAAC8mB,EAAInb,KAAU,CAAGA,MAAOA,EAAOob,WAAYD,EAAGC,eAQ7F,OAPAxE,EAAYlP,MAAK,CAACwE,EAAGpR,IACboR,EAAEkP,WAAWC,cAAgBvgB,EAAEsgB,WAAWC,YACnCnP,EAAElM,MAAQlF,EAAEkF,MAEhBkM,EAAEkP,WAAWC,YAAcvgB,EAAEsgB,WAAWC,cAEnDjC,EAAiBlL,OAAOte,KAAKoqB,OAAQpD,EAAYviB,KAAI8mB,GAAMA,EAAGC,aAAa9E,EAAY1mB,KAAKoqB,QAASpqB,KAAKoqB,OAAO5D,0BAA2BO,GACrIA,CACX,CACA,0BAAOuE,CAAoBH,EAAqBC,GAC5C,IACI,OAAOD,EAAsBA,EAAoBC,GAAyB,IAC9E,CACA,MAAO5hB,GAEH,OADA,QAAkBA,GACX,IACX,CACJ,E,iDC5VG,MAAMkiB,EACT,WAAAvrB,CAAYwrB,GACR3rB,KAAK2rB,SAAWA,EAChB3rB,KAAK4rB,OAAS,EAClB,CACA,GAAArjB,CAAI6H,GACA,OAAIA,EAAQpQ,KAAK4rB,OAAOxmB,OACbpF,KAAK4rB,OAAOxb,GAEhBpQ,KAAK2rB,QAChB,CACA,GAAAnjB,CAAI4H,EAAO3G,GACP,KAAO2G,GAASpQ,KAAK4rB,OAAOxmB,QACxBpF,KAAK4rB,OAAO5rB,KAAK4rB,OAAOxmB,QAAUpF,KAAK2rB,SAE3C3rB,KAAK4rB,OAAOxb,GAAS3G,CACzB,CACA,OAAAoiB,CAAQzb,EAAO0b,EAAW1W,GACtB,GAAIhF,GAASpQ,KAAK4rB,OAAOxmB,OACrB,OAEJ,GAAkB,IAAd0mB,EAEA,YADA9rB,KAAK+rB,OAAO3b,EAAOgF,GAGlB,GAAkB,IAAdA,EAEL,YADApV,KAAKgsB,OAAO5b,EAAO0b,GAGvB,MAAMG,EAASjsB,KAAK4rB,OAAOvL,MAAM,EAAGjQ,GAC9B8b,EAAQlsB,KAAK4rB,OAAOvL,MAAMjQ,EAAQ0b,GAClCK,EAoBd,SAAmB/mB,EAAQqE,GACvB,MAAMoQ,EAAM,GACZ,IAAK,IAAItS,EAAI,EAAGA,EAAInC,EAAQmC,IACxBsS,EAAItS,GAAKkC,EAEb,OAAOoQ,CACX,CA1B0BuS,CAAUhX,EAAWpV,KAAK2rB,UAC5C3rB,KAAK4rB,OAASK,EAAOlO,OAAOoO,EAAWD,EAC3C,CACA,OAAOG,EAAaC,GACI,IAAhBA,GAAqBD,GAAersB,KAAK4rB,OAAOxmB,QAGpDpF,KAAK4rB,OAAOW,OAAOF,EAAaC,EACpC,CACA,MAAAP,CAAOS,EAAaC,GAChB,GAAoB,IAAhBA,GAAqBD,GAAexsB,KAAK4rB,OAAOxmB,OAChD,OAEJ,MAAMyU,EAAM,GACZ,IAAK,IAAItS,EAAI,EAAGA,EAAIklB,EAAallB,IAC7BsS,EAAItS,GAAKvH,KAAK2rB,SAElB3rB,KAAK4rB,QAAS,QAAY5rB,KAAK4rB,OAAQY,EAAa3S,EACxD,E,sIC9CG,MAAM6S,UAA4B,IACrC,WAAAvsB,CAAY6C,EAAWmG,GACnBjG,QACAlD,KAAKgD,UAAYA,EACjBhD,KAAKmJ,6BAA+BA,CACxC,CACA,wBAAAlG,CAAyBH,GACrB,OAAO9C,KAAKmJ,6BAA6BlG,yBAAyBH,EACtE,CACA,mBAAA6pB,CAAoBC,GAChB,OAAO,OAAmB5sB,KAAKgD,UAAUoK,eAAewf,EAAY,GAAI5sB,KAAKgD,UAAUyR,aAAalU,QACxG,CACA,oBAAAssB,CAAqBliB,EAAYmiB,EAAeC,GAC5C/sB,KAAKgtB,oBACL,MAAM5d,EAAYpP,KAAKgD,UAAUqM,eACjC,GAAI1E,EAAa,GAAKA,EAAayE,EAC/B,MAAM,IAAI,KAAmB,gCAEjC,MAAM6d,EAAejtB,KAAKiD,yBAAyBjD,KAAKgD,UAAUgB,iBAAiBipB,aAC7EC,EAAUvsB,QAAQssB,GAAgBA,EAAaC,SACrD,IAAIC,GAA4B,EAC5BC,GAA6B,EAC7BC,GAA4B,EAC5BC,GAA6B,EACjC,MAAMC,EAAqB5iB,IACvB,IAAkC,IAA9BwiB,KAC+B,IAA9BA,GACGA,EAA2BxiB,EAAa,GAAI,CAChDwiB,GAA4B,EAC5BC,GAA6B,EAE7B,IAAK,IAAIR,EAAYjiB,EAAa,EAAGiiB,GAAa,EAAGA,IAAa,CAC9D,MAAMY,EAASxtB,KAAK2sB,oBAAoBC,GACxC,GAAIY,GAAU,EAAG,CACbL,EAA2BP,EAC3BQ,EAA4BI,EAC5B,KACJ,CACJ,CACJ,CACA,IAAkC,IAA9BH,EAAiC,CACjCA,GAA4B,EAC5BC,GAA6B,EAE7B,IAAK,IAAIV,EAAYjiB,EAAYiiB,EAAYxd,EAAWwd,IAAa,CACjE,MAAMY,EAASxtB,KAAK2sB,oBAAoBC,GACxC,GAAIY,GAAU,EAAG,CACbH,EAA2BT,EAC3BU,EAA4BE,EAC5B,KACJ,CACJ,CACJ,GAEJ,IAAIC,GAA8B,EAC9BC,GAA+B,EAC/BC,GAA8B,EAC9BC,GAA+B,EACnC,MAAMC,EAAuBljB,IACzB,IAAoC,IAAhC8iB,EAAmC,CACnCA,GAA8B,EAC9BC,GAA+B,EAE/B,IAAK,IAAId,EAAYjiB,EAAa,EAAGiiB,GAAa,EAAGA,IAAa,CAC9D,MAAMY,EAASxtB,KAAK2sB,oBAAoBC,GACxC,GAAIY,GAAU,EAAG,CACbC,EAA6Bb,EAC7Bc,EAA8BF,EAC9B,KACJ,CACJ,CACJ,CACA,IAAoC,IAAhCG,KACiC,IAAhCA,GACGA,EAA6BhjB,EAAa,GAAI,CAClDgjB,GAA8B,EAC9BC,GAA+B,EAE/B,IAAK,IAAIhB,EAAYjiB,EAAYiiB,EAAYxd,EAAWwd,IAAa,CACjE,MAAMY,EAASxtB,KAAK2sB,oBAAoBC,GACxC,GAAIY,GAAU,EAAG,CACbG,EAA6Bf,EAC7BgB,EAA8BJ,EAC9B,KACJ,CACJ,CACJ,GAEJ,IAAI7nB,EAAkB,EAClBmoB,GAAO,EACPhoB,EAAgB,EAChBioB,GAAS,EACTP,EAAS,EACTQ,EAAgB,EACpB,IAAK,IAAIC,EAAW,EAAGH,GAAQC,EAAQE,IAAY,CAC/C,MAAMC,EAAevjB,EAAasjB,EAC5BE,EAAiBxjB,EAAasjB,EAChCA,EAAW,IAAMC,EAAe,GAAKA,EAAepB,KACpDgB,GAAO,GAEPG,EAAW,IACVE,EAAiB/e,GAAa+e,EAAiBpB,KAChDgB,GAAS,GAETE,EAAW,MAEXH,GAAO,EACPC,GAAS,GAEb,IAAIK,GAAqB,EACzB,GAAIN,GAAQI,GAAgB,EAAG,CAE3B,MAAMG,EAAgBruB,KAAK2sB,oBAAoBuB,EAAe,GAC1DG,GAAiB,GAGjBhB,EAA2Ba,EAAe,EAC1CZ,EAA4Be,EAC5BD,EAAoB5tB,KAAK8tB,KAAKD,EAAgBruB,KAAKgD,UAAUyR,aAAavU,cAG1EqtB,EAAkBW,GAClBE,EAAoBpuB,KAAKuuB,iCAAiCrB,EAASE,EAA2BE,GAEtG,CACA,IAAIkB,GAAuB,EAC3B,GAAIT,GAAUI,GAAkB/e,EAAW,CAEvC,MAAMif,EAAgBruB,KAAK2sB,oBAAoBwB,EAAiB,GAC5DE,GAAiB,GAGjBZ,EAA6BU,EAAiB,EAC9CT,EAA8BW,EAC9BG,EAAsBhuB,KAAK8tB,KAAKD,EAAgBruB,KAAKgD,UAAUyR,aAAavU,cAG5E2tB,EAAoBM,GACpBK,EAAsBxuB,KAAKuuB,iCAAiCrB,EAASQ,EAA6BE,GAE1G,CACA,GAAiB,IAAbK,EAAJ,CAIA,GAAiB,IAAbA,EAAgB,CAChB,GAAIE,GAAkB/e,GAClBof,GAAuB,GACvBR,EAAgB,IAAMQ,EAAqB,CAG3CV,GAAO,EACPnoB,EAAkBwoB,EAClBroB,EAAgBqoB,EAChBX,EAASgB,EACT,QACJ,CACA,GAAIN,GAAgB,GAChBE,GAAqB,GACrBA,EAAoB,IAAMJ,EAAe,CAEzCD,GAAS,EACTpoB,EAAkBuoB,EAClBpoB,EAAgBooB,EAChBV,EAASY,EACT,QACJ,CAIA,GAHAzoB,EAAkBgF,EAClB7E,EAAgB6E,EAChB6iB,EAASQ,EACM,IAAXR,EAEA,MAAO,CAAE7nB,kBAAiBG,gBAAe0nB,SAEjD,CACIM,IACIM,GAAqBZ,EACrB7nB,EAAkBuoB,EAGlBJ,GAAO,GAGXC,IACIS,GAAuBhB,EACvB1nB,EAAgBqoB,EAGhBJ,GAAS,EA5CjB,MAFIC,EAAgBI,CAiDxB,CACA,MAAO,CAAEzoB,kBAAiBG,gBAAe0nB,SAC7C,CACA,qBAAAiB,CAAsB9oB,EAAiBG,EAAe4oB,EAAgB7J,GAClE,IAAIpc,EACJ,MAAMxD,EAAS,GACf,IAAK,IAAI0F,EAAahF,EAAiBgF,GAAc7E,EAAe6E,IAChE1F,EAAOqC,KAAK,IAGhB,MACM+c,EAAerkB,KAAKgD,UAAUqhB,aAAaja,yCAAyC,IAAI,IAAMzE,EAAiB,EAAGG,EAAe9F,KAAKgD,UAAU2rB,iBAAiB7oB,KAAiBof,UACxL,IAAI0J,EACJ,GAAIF,GAAkBrK,EAAajf,OAAS,EAAG,CAC3C,MAAMypB,GAAoClpB,GAAmB+oB,EAAe/jB,YACxE+jB,EAAe/jB,YAAc7E,EAE3Bue,EACArkB,KAAKgD,UAAUqhB,aAAaje,uBAAuB,kBAAoBsoB,IAAiBxJ,WAAWnZ,QAAQ+iB,GAAO,2BAA6BA,EAAG1tB,MAAOstB,KAC/JE,EAAmK,QAAzInmB,GAAK,QAASomB,GAAmCtnB,GAThD,cASuJ,IAAPkB,OAAgB,EAASA,EAAGrH,KAC3M,CACA,MAAM6jB,EAAqCjlB,KAAKgD,UAAUyR,aAAa3T,+BAA+BmkB,mCAChGf,EAAgB,IAAI6K,EAC1B,IAAK,MAAMC,KAAQ3K,EAAc,CA2B7B,IAAK2K,EAAK/iB,oBACN,SAEJ,MAAMgjB,EAAWL,GAA0BI,EAAK5tB,MAAM8tB,YAAYN,GAClE,IAAKK,IAAapK,EAAQsK,gBACtB,SAEJ,MAAMC,EAAYlL,EAAcc,mBAAmBgK,EAAKpK,aAAcoK,EAAKtnB,+BAAgCud,IACtGJ,EAAQwK,iBAAmBJ,EACtB,IAAM/K,EAAcoL,gBACpB,IACJnb,EAAQ6a,EAAK3jB,oBAAoB9E,mBACjCgpB,EAAMP,EAAK/iB,oBAAoB1F,mBAC/BipB,EAAmB3K,EAAQ2K,mBAAqB,cAAkC3K,EAAQ2K,mBAAqB,uBAA0CP,EAC/J,GAAID,EAAK5tB,MAAMuE,kBAAoBqpB,EAAK5tB,MAAM0E,cAAe,CAC3B0pB,GAC1BvqB,EAAO+pB,EAAK5tB,MAAMuE,gBAAkBA,GAAiB2B,KAAK,IAAI,MAAa,EAAG0nB,EAAK3jB,oBAAoB5E,iBAAiBmE,OAAQwkB,EAAW,IAAI,MAA0B,EAAOG,EAAI3kB,SAAU,GAAI,IAEtM,QACJ,CACA,MAAM6kB,EAAmBzvB,KAAK0vB,6BAA6BH,GACrDI,EAAqB3vB,KAAK0vB,6BAA6BV,EAAK3jB,oBAAoB9E,oBAChFqpB,EAAqBpvB,KAAK2M,IAAIwiB,EAAoBF,EAAkBT,EAAKa,4BAA8B,GAC7G,IAAIC,GAAqC,EACjB,KAAgC9vB,KAAKgD,UAAUoK,eAAe4hB,EAAK/iB,oBAAoBtG,kBACzDqpB,EAAK/iB,oBAAoBrG,YAAc,IAEzFkqB,GAAqC,GAEzC,MAAMC,EAA8BvvB,KAAKC,IAAI0T,EAAMxJ,WAAYhF,GACzDqqB,EAA4BxvB,KAAK2M,IAAIoiB,EAAI5kB,WAAY7E,GACrDyL,EAASue,EAAqC,EAAI,EACxD,IAAK,IAAInU,EAAIoU,EAA6BpU,EAAIqU,EAA4Bze,EAAQoK,IAC9E1W,EAAO0W,EAAIhW,GAAiB2B,KAAK,IAAI,KAAYsoB,GAAqB,EAAGR,EAAW,KAAMzT,IAAMxH,EAAMxJ,WAAawJ,EAAMvJ,QAAU,EAAG+Q,IAAM4T,EAAI5kB,WAAa4kB,EAAI3kB,QAAU,IAE3K4kB,IACIrb,EAAMxJ,YAAchF,GAAmBgqB,EAAqBC,GAC5D3qB,EAAOkP,EAAMxJ,WAAahF,GAAiB2B,KAAK,IAAI,KAAYsoB,GAAqB,EAAGR,EAAW,IAAI,MAA0B,EAAOjb,EAAMvJ,SAAU,GAAI,IAE5J2kB,EAAI5kB,YAAc7E,GAAiB2pB,EAAmBG,GACtD3qB,EAAOsqB,EAAI5kB,WAAahF,GAAiB2B,KAAK,IAAI,KAAYsoB,GAAqB,EAAGR,EAAW,IAAI,MAA2BU,EAAoCP,EAAI3kB,SAAU,GAAI,IAGlM,CACA,IAAK,MAAMqlB,KAAUhrB,EACjBgrB,EAAOnY,MAAK,CAACwE,EAAGpR,IAAMoR,EAAE9H,cAAgBtJ,EAAEsJ,gBAE9C,OAAOvP,CACX,CACA,4BAAAyqB,CAA6B5oB,GACzB,OAAQ,4BAAsC9G,KAAKgD,UAAUoK,eAAetG,EAAS6D,YAAa7D,EAAS8D,OAAQ5K,KAAKgD,UAAUyR,aAAalU,SAAW,CAC9J,CACA,oBAAA2vB,CAAqBvqB,EAAiBG,GAClC9F,KAAKgtB,oBACL,MAAM5d,EAAYpP,KAAKgD,UAAUqM,eACjC,GAAI1J,EAAkB,GAAKA,EAAkByJ,EACzC,MAAM,IAAI8B,MAAM,qCAEpB,GAAIpL,EAAgB,GAAKA,EAAgBsJ,EACrC,MAAM,IAAI8B,MAAM,mCAEpB,MAAM2T,EAAU7kB,KAAKgD,UAAUyR,aACzBwY,EAAejtB,KAAKiD,yBAAyBjD,KAAKgD,UAAUgB,iBAAiBipB,aAC7EC,EAAUvsB,QAAQssB,GAAgBA,EAAaC,SAC/CjoB,EAAS,IAAI0O,MAAM7N,EAAgBH,EAAkB,GAC3D,IAAIwqB,GAAyB,EACzBC,GAA0B,EAC1BC,GAAyB,EACzBC,GAA0B,EAC9B,IAAK,IAAI3lB,EAAahF,EAAiBgF,GAAc7E,EAAe6E,IAAc,CAC9E,MAAM4lB,EAAc5lB,EAAahF,EAC3B0oB,EAAgBruB,KAAK2sB,oBAAoBhiB,EAAa,GAC5D,GAAI0jB,GAAiB,EAGjB8B,EAAwBxlB,EAAa,EACrCylB,EAAyB/B,EACzBppB,EAAOsrB,GAAe/vB,KAAK8tB,KAAKD,EAAgBxJ,EAAQ3kB,gBAL5D,CAQA,IAA+B,IAA3BiwB,EAA8B,CAC9BA,GAAyB,EACzBC,GAA0B,EAE1B,IAAK,IAAIxD,EAAYjiB,EAAa,EAAGiiB,GAAa,EAAGA,IAAa,CAC9D,MAAMY,EAASxtB,KAAK2sB,oBAAoBC,GACxC,GAAIY,GAAU,EAAG,CACb2C,EAAwBvD,EACxBwD,EAAyB5C,EACzB,KACJ,CACJ,CACJ,CACA,IAA+B,IAA3B6C,KAC4B,IAA3BA,GAAgCA,EAAwB1lB,EAAa,GAAI,CAC1E0lB,GAAyB,EACzBC,GAA0B,EAE1B,IAAK,IAAI1D,EAAYjiB,EAAYiiB,EAAYxd,EAAWwd,IAAa,CACjE,MAAMY,EAASxtB,KAAK2sB,oBAAoBC,GACxC,GAAIY,GAAU,EAAG,CACb6C,EAAwBzD,EACxB0D,EAAyB9C,EACzB,KACJ,CACJ,CACJ,CACAvoB,EAAOsrB,GAAevwB,KAAKuuB,iCAAiCrB,EAASkD,EAAwBE,EA5B7F,CA6BJ,CACA,OAAOrrB,CACX,CACA,gCAAAspB,CAAiCrB,EAASkD,EAAwBE,GAC9D,MAAMzL,EAAU7kB,KAAKgD,UAAUyR,aAC/B,OAAgC,IAA5B2b,IAA6D,IAA5BE,EAE1B,EAEFF,EAAyBE,EAEvB,EAAI9vB,KAAKob,MAAMwU,EAAyBvL,EAAQ3kB,YAElDkwB,IAA2BE,GAK5BpD,EAHG1sB,KAAK8tB,KAAKgC,EAAyBzL,EAAQ3kB,YASvC,EAAIM,KAAKob,MAAM0U,EAAyBzL,EAAQ3kB,WAGnE,EAEG,MAAM6uB,EACT,WAAA5uB,GACIH,KAAKsvB,gBAAkB,eAC3B,CACA,kBAAAtK,CAAmBJ,EAAcld,EAAgCud,GAC7D,OAAOjlB,KAAKslB,0BAA0BL,EAAqCvd,EAAiCkd,EAChH,CACA,yBAAAU,CAA0B7d,GAGtB,MAAO,4BAA4BA,EAAQ,EAC/C,E,mCC7YJ,MAAM+oB,EACF,WAAArwB,GACIH,KAAKywB,WAAa,EAClBzwB,KAAK0wB,oBAAqB,CAC9B,EAKJ,SAASD,EAAWnU,EAAGqU,EAASzlB,EAAG0lB,EAAS3rB,GAOxC,IAAIsC,EACJ,IAPAtC,EAAOwrB,WAAa,EACpBxrB,EAAOyrB,oBAAqB,EAMvBnpB,EAAI,EAAGA,EAAIopB,GAAWppB,EAAIqpB,EAASrpB,IAAK,CAGzC,GAFkB+U,EAAEuU,WAAWtpB,KACb2D,EAAE2lB,WAAWtpB,GAE3B,KAER,CACA,IAAIupB,EAAa,EAAGC,EAAa,EACjC,IAAK,IAAIrT,EAAInW,EAAGmW,EAAIiT,EAASjT,IAAK,CAEZ,KADApB,EAAEuU,WAAWnT,GAE3BoT,IAGAC,GAER,CACA,IAAIC,EAAa,EAAGC,EAAa,EACjC,IAAK,IAAIvT,EAAInW,EAAGmW,EAAIkT,EAASlT,IAAK,CAEZ,KADAxS,EAAE2lB,WAAWnT,GAE3BsT,IAGAC,GAER,CACA,GAAIH,EAAa,GAAKC,EAAa,EAC/B,OAEJ,GAAIC,EAAa,GAAKC,EAAa,EAC/B,OAEJ,MAAMC,EAAW1wB,KAAKsd,IAAIiT,EAAaE,GACjCR,EAAajwB,KAAKsd,IAAIgT,EAAaE,GACzC,GAAiB,IAAbE,EAcA,OAXAjsB,EAAOwrB,WAAaA,OAChBA,EAAa,GAAK,GAAKO,EAAa,GAAKA,EAAa,EAAI1U,EAAElX,QAAU4rB,EAAa9lB,EAAE9F,QACpD,KAA7B8F,EAAE2lB,WAAWG,IAA4E,KAAjC1U,EAAEuU,WAAWG,EAAa,IAC/C,KAA/B1U,EAAEuU,WAAWvU,EAAElX,OAAS,KAIxBH,EAAOyrB,oBAAqB,IAMxCD,EAAaS,GAAa,IAC1BjsB,EAAOwrB,WAAaA,EAAaS,EAGzC,CACO,SAASC,EAAiBjJ,EAAQkJ,EAAgBC,GAErD,MAAMC,EAAa9wB,KAAK2M,IAAI+a,EAAO7Y,eAAgB,KACnD,IAAIkiB,EAA6B,EAC7BC,EAA+B,EAC/BC,EAAmB,GACnBC,EAA0B,EAC9B,MAAMC,EAA2B,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,GAE9CC,EAAkB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,GAC3C3hB,EAAM,IAAIugB,EAChB,IAAK,IAAI7lB,EAAa,EAAGA,GAAc2mB,EAAY3mB,IAAc,CAC7D,MAAMknB,EAAoB3J,EAAO5F,cAAc3X,GACzCmnB,EAAkB5J,EAAO9a,eAAezC,GAGxConB,EAAsBF,GAAqB,MACjD,IAAIG,GAAwB,EACxBC,EAAyB,EACzBC,EAAyB,EACzBC,EAAuB,EAC3B,IAAK,IAAIzU,EAAI,EAAG0U,EAAOP,EAAmBnU,EAAI0U,EAAM1U,IAAK,CACrD,MAAM2U,EAAYN,EAAqBD,EAAgBjB,WAAWnT,GAAKwK,EAAOoK,gBAAgB3nB,EAAY+S,GAC1G,GAAiB,IAAb2U,EACAF,QAEC,IAAiB,KAAbE,EAGJ,CAEDL,GAAwB,EACxBC,EAAyBvU,EACzB,KACJ,CAPIwU,GAOJ,CACJ,CAEA,IAAKF,EACD,SASJ,GAPIG,EAAuB,EACvBZ,IAEKW,EAAyB,GAC9BV,IAEJf,EAAWgB,EAAkBC,EAAyBI,EAAiBG,EAAwBhiB,GAC3FA,EAAIygB,sBAUEW,GAAuBD,IAAmBnhB,EAAIwgB,YAChD,SAGR,MAAM8B,EAAoBtiB,EAAIwgB,WAC1B8B,GAtD2B,GAuD3BX,EAAgBW,KAEpBd,EAAmBK,EACnBJ,EAA0BO,CAC9B,CACA,IAAIvxB,EAAe2wB,EACfE,IAA+BC,IAC/B9wB,EAAgB6wB,EAA6BC,GAEjD,IAAIjxB,EAAU6wB,EAEd,GAAI1wB,EAAc,CACd,IAAI8xB,EAAgB9xB,EAAe,EAAI,GAAM4wB,EAE7CK,EAAyBc,SAASC,IAC9B,MAAMC,EAAuBf,EAAgBc,GACzCC,EAAuBH,IACvBA,EAAeG,EACfpyB,EAAUmyB,EACd,IAIY,IAAZnyB,GAAiBqxB,EAAgB,GAAK,GAAKA,EAAgB,GAAK,GAAKA,EAAgB,IAAMA,EAAgB,GAAK,IAChHrxB,EAAU,EAElB,CAKA,MAAO,CACHG,aAAcA,EACdH,QAASA,EAEjB,C,kBC3KO,SAASqyB,EAAa3sB,GACzB,OAAyB,EAAhBA,EAAK4sB,YAA4C,CAC9D,CACA,SAASC,EAAa7sB,EAAM6f,GACxB7f,EAAK4sB,SAA6B,IAAhB5sB,EAAK4sB,SAAoD/M,GAAS,CACxF,CACA,SAASiN,EAAiB9sB,GACtB,OAAyB,EAAhBA,EAAK4sB,YAAgD,GAAuC,CACzG,CACA,SAASG,EAAiB/sB,EAAMwD,GAC5BxD,EAAK4sB,SAA6B,IAAhB5sB,EAAK4sB,UAAyDppB,EAAQ,EAAI,IAAM,CACtG,CACA,SAASwpB,EAAuBhtB,GAC5B,OAAyB,EAAhBA,EAAK4sB,YAAsD,GAA6C,CACrH,CACA,SAASK,EAAuBjtB,EAAMwD,GAClCxD,EAAK4sB,SAA6B,IAAhB5sB,EAAK4sB,UAA+DppB,EAAQ,EAAI,IAAM,CAC5G,CACA,SAAS0pB,EAAuBltB,GAC5B,OAAyB,GAAhBA,EAAK4sB,YAAgD,GAAsC,CACxG,CACA,SAASO,EAAuBntB,EAAMwD,GAClCxD,EAAK4sB,SAA6B,IAAhB5sB,EAAK4sB,UAAwDppB,EAAQ,EAAI,IAAM,CACrG,CAIA,SAAS4pB,EAAmBptB,EAAMqtB,GAC9BrtB,EAAK4sB,SAA6B,IAAhB5sB,EAAK4sB,SAAyDS,GAAc,CAClG,CAIA,SAASC,EAAyBttB,EAAMwD,GACpCxD,EAAK4sB,SAA6B,IAAhB5sB,EAAK4sB,UAAqEppB,EAAQ,EAAI,IAAM,CAClH,C,oCACO,MAAM+pB,EACT,WAAArzB,CAAYwkB,EAAIxQ,EAAOob,GACnBvvB,KAAK6yB,SAAW,EAChB7yB,KAAKqe,OAASre,KACdA,KAAKyzB,KAAOzzB,KACZA,KAAK0zB,MAAQ1zB,KACb8yB,EAAa9yB,KAAM,GACnBA,KAAKmU,MAAQA,EACbnU,KAAKuvB,IAAMA,EAEXvvB,KAAK2zB,MAAQ,EACb3zB,KAAK4zB,OAASrE,EACdvvB,KAAK2kB,GAAKA,EACV3kB,KAAKukB,QAAU,EACfvkB,KAAK6kB,QAAU,KACfqO,EAAuBlzB,MAAM,GAC7BozB,EAAuBpzB,MAAM,GAC7BqzB,EAAmBrzB,KAAM,GACzBuzB,EAAyBvzB,MAAM,GAC/BA,KAAK6zB,gBAAkB,EACvB7zB,KAAK8zB,oBAAsB3f,EAC3BnU,KAAK+zB,kBAAoBxE,EACzBvvB,KAAKoB,MAAQ,KACb4xB,EAAiBhzB,MAAM,EAC3B,CACA,KAAAg0B,CAAMC,EAAW9f,EAAOob,EAAKnuB,GACzBpB,KAAKmU,MAAQA,EACbnU,KAAKuvB,IAAMA,EACXvvB,KAAK4zB,OAASrE,EACdvvB,KAAK6zB,gBAAkBI,EACvBj0B,KAAK8zB,oBAAsB3f,EAC3BnU,KAAK+zB,kBAAoBxE,EACzBvvB,KAAKoB,MAAQA,CACjB,CACA,UAAA8yB,CAAWrP,GACP7kB,KAAK6kB,QAAUA,EACf,MAAMuK,EAAYpvB,KAAK6kB,QAAQuK,UAC/B8D,EAAuBlzB,KAAqB,mBAAdovB,GACT,qBAAdA,GACc,kBAAdA,GACPgE,EAAuBpzB,KAA4C,OAAtCA,KAAK6kB,QAAQsP,sBAC1Cd,EAAmBrzB,KAAMA,KAAK6kB,QAAQyO,YACtCC,EAAyBvzB,KAAMA,KAAK6kB,QAAQuP,sBAChD,CACA,gBAAAC,CAAiBC,EAAeC,EAAaV,GACrC7zB,KAAK6zB,kBAAoBA,IACzB7zB,KAAKoB,MAAQ,MAEjBpB,KAAK6zB,gBAAkBA,EACvB7zB,KAAK8zB,oBAAsBQ,EAC3Bt0B,KAAK+zB,kBAAoBQ,CAC7B,CACA,MAAAC,GACIx0B,KAAKqe,OAAS,KACdre,KAAKyzB,KAAO,KACZzzB,KAAK0zB,MAAQ,IACjB,EAEG,MAAMe,EAAW,IAAIjB,EAAa,KAAM,EAAG,GAClDiB,EAASpW,OAASoW,EAClBA,EAAShB,KAAOgB,EAChBA,EAASf,MAAQe,EACjB3B,EAAa2B,EAAU,GAChB,MAAMC,EACT,WAAAv0B,GACIH,KAAK20B,KAAOF,EACZz0B,KAAK40B,uBAAwB,CACjC,CACA,cAAAC,CAAe1gB,EAAOob,EAAKuF,EAAetQ,EAAqBqP,EAAiBkB,GAC5E,OAAI/0B,KAAK20B,OAASF,EACP,GA4anB,SAAwBO,EAAGC,EAAeC,EAAaJ,EAAetQ,EAAqBqP,EAAiBkB,GAOxG,IAAI9uB,EAAO+uB,EAAEL,KACThB,EAAQ,EACRwB,EAAa,EACbC,EAAY,EACZC,EAAU,EACd,MAAMpwB,EAAS,GACf,IAAIqwB,EAAY,EAChB,KAAOrvB,IAASwuB,GACZ,GAAI1B,EAAiB9sB,GAEjB+sB,EAAiB/sB,EAAKwtB,MAAM,GAC5BT,EAAiB/sB,EAAKytB,OAAO,GACzBztB,IAASA,EAAKoY,OAAOqV,QACrBC,GAAS1tB,EAAKoY,OAAOsV,OAEzB1tB,EAAOA,EAAKoY,WAPhB,CAUA,IAAK0U,EAAiB9sB,EAAKwtB,MAAO,CAG9B,GADA0B,EAAaxB,EAAQ1tB,EAAK2tB,OACtBuB,EAAaF,EAAe,CAG5BjC,EAAiB/sB,GAAM,GACvB,QACJ,CACA,GAAIA,EAAKwtB,OAASgB,EAAU,CAExBxuB,EAAOA,EAAKwtB,KACZ,QACJ,CACJ,CAGA,GADA2B,EAAYzB,EAAQ1tB,EAAKkO,MACrBihB,EAAYF,EAGZlC,EAAiB/sB,GAAM,OAH3B,CAOA,GADAovB,EAAU1B,EAAQ1tB,EAAKspB,IACnB8F,GAAWJ,EAAe,CAE1BhvB,EAAKouB,iBAAiBe,EAAWC,EAASxB,GAC1C,IAAI0B,GAAU,EACVT,GAAiB7uB,EAAKse,SAAWte,EAAKse,UAAYuQ,IAClDS,GAAU,GAEV/Q,GAAuByO,EAAuBhtB,KAC9CsvB,GAAU,GAEVR,IAA0B5B,EAAuBltB,KACjDsvB,GAAU,GAEVA,IACAtwB,EAAOqwB,KAAervB,EAE9B,CACA+sB,EAAiB/sB,GAAM,GACnBA,EAAKytB,QAAUe,GAAa1B,EAAiB9sB,EAAKytB,SAElDC,GAAS1tB,EAAK0tB,MACd1tB,EAAOA,EAAKytB,MAvBhB,CAvBA,CAmDJ,OADAV,EAAiBgC,EAAEL,MAAM,GAClB1vB,CACX,CAtfe4vB,CAAe70B,KAAMmU,EAAOob,EAAKuF,EAAetQ,EAAqBqP,EAAiBkB,EACjG,CACA,MAAAS,CAAOV,EAAetQ,EAAqBqP,EAAiBkB,GACxD,OAAI/0B,KAAK20B,OAASF,EACP,GAmXnB,SAAgBO,EAAGF,EAAetQ,EAAqBqP,EAAiBkB,GACpE,IAAI9uB,EAAO+uB,EAAEL,KACThB,EAAQ,EACRyB,EAAY,EACZC,EAAU,EACd,MAAMpwB,EAAS,GACf,IAAIqwB,EAAY,EAChB,KAAOrvB,IAASwuB,GAAU,CACtB,GAAI1B,EAAiB9sB,GAAO,CAExB+sB,EAAiB/sB,EAAKwtB,MAAM,GAC5BT,EAAiB/sB,EAAKytB,OAAO,GACzBztB,IAASA,EAAKoY,OAAOqV,QACrBC,GAAS1tB,EAAKoY,OAAOsV,OAEzB1tB,EAAOA,EAAKoY,OACZ,QACJ,CACA,GAAIpY,EAAKwtB,OAASgB,IAAa1B,EAAiB9sB,EAAKwtB,MAAO,CAExDxtB,EAAOA,EAAKwtB,KACZ,QACJ,CAEA2B,EAAYzB,EAAQ1tB,EAAKkO,MACzBkhB,EAAU1B,EAAQ1tB,EAAKspB,IACvBtpB,EAAKouB,iBAAiBe,EAAWC,EAASxB,GAC1C,IAAI0B,GAAU,EACVT,GAAiB7uB,EAAKse,SAAWte,EAAKse,UAAYuQ,IAClDS,GAAU,GAEV/Q,GAAuByO,EAAuBhtB,KAC9CsvB,GAAU,GAEVR,IAA0B5B,EAAuBltB,KACjDsvB,GAAU,GAEVA,IACAtwB,EAAOqwB,KAAervB,GAE1B+sB,EAAiB/sB,GAAM,GACnBA,EAAKytB,QAAUe,GAAa1B,EAAiB9sB,EAAKytB,SAElDC,GAAS1tB,EAAK0tB,MACd1tB,EAAOA,EAAKytB,MAGpB,CAEA,OADAV,EAAiBgC,EAAEL,MAAM,GAClB1vB,CACX,CAnaeuwB,CAAOx1B,KAAM80B,EAAetQ,EAAqBqP,EAAiBkB,EAC7E,CAIA,qBAAAU,CAAsBlR,GAClB,OA+SR,SAA+ByQ,EAAGzQ,GAC9B,IAAIte,EAAO+uB,EAAEL,KACb,MAAM1vB,EAAS,GACf,IAAIqwB,EAAY,EAChB,KAAOrvB,IAASwuB,GACR1B,EAAiB9sB,IAEjB+sB,EAAiB/sB,EAAKwtB,MAAM,GAC5BT,EAAiB/sB,EAAKytB,OAAO,GAC7BztB,EAAOA,EAAKoY,QAGZpY,EAAKwtB,OAASgB,GAAa1B,EAAiB9sB,EAAKwtB,OAMjDxtB,EAAKse,UAAYA,IACjBtf,EAAOqwB,KAAervB,GAE1B+sB,EAAiB/sB,GAAM,GACnBA,EAAKytB,QAAUe,GAAa1B,EAAiB9sB,EAAKytB,SAElDztB,EAAOA,EAAKytB,QAVZztB,EAAOA,EAAKwtB,KAepB,OADAT,EAAiBgC,EAAEL,MAAM,GAClB1vB,CACX,CA7UewwB,CAAsBz1B,KAAMukB,EACvC,CAIA,qBAAAmR,GACI,OAwUR,SAA+BV,GAC3B,IAAI/uB,EAAO+uB,EAAEL,KACb,MAAM1vB,EAAS,GACf,IAAIqwB,EAAY,EAChB,KAAOrvB,IAASwuB,GACR1B,EAAiB9sB,IAEjB+sB,EAAiB/sB,EAAKwtB,MAAM,GAC5BT,EAAiB/sB,EAAKytB,OAAO,GAC7BztB,EAAOA,EAAKoY,QAGZpY,EAAKwtB,OAASgB,GAAa1B,EAAiB9sB,EAAKwtB,MAKjDxtB,EAAKytB,QAAUe,GAAa1B,EAAiB9sB,EAAKytB,QAMtDzuB,EAAOqwB,KAAervB,EACtB+sB,EAAiB/sB,GAAM,IALnBA,EAAOA,EAAKytB,MALZztB,EAAOA,EAAKwtB,KAapB,OADAT,EAAiBgC,EAAEL,MAAM,GAClB1vB,CACX,CApWeywB,CAAsB11B,KACjC,CACA,MAAA+rB,CAAO9lB,GACH0vB,EAAa31B,KAAMiG,GACnBjG,KAAK41B,4BACT,CACA,OAAO3vB,GACH4vB,EAAa71B,KAAMiG,GACnBjG,KAAK41B,4BACT,CACA,WAAAE,CAAY7vB,EAAM4tB,GACd,MAAMkC,EAAc9vB,EACpB,IAAI0tB,EAAQ,EACZ,KAAO1tB,IAASjG,KAAK20B,MACb1uB,IAASA,EAAKoY,OAAOqV,QACrBC,GAAS1tB,EAAKoY,OAAOsV,OAEzB1tB,EAAOA,EAAKoY,OAEhB,MAAM+W,EAAYW,EAAY5hB,MAAQwf,EAChC0B,EAAUU,EAAYxG,IAAMoE,EAClCoC,EAAY1B,iBAAiBe,EAAWC,EAASxB,EACrD,CACA,aAAAmC,CAAczkB,EAAQnM,EAAQ4R,EAAYnV,GAGtC,MAAMo0B,EA8Id,SAA0BjB,EAAG7gB,EAAOob,GAOhC,IAAItpB,EAAO+uB,EAAEL,KACThB,EAAQ,EACRwB,EAAa,EACbC,EAAY,EACZC,EAAU,EACd,MAAMpwB,EAAS,GACf,IAAIqwB,EAAY,EAChB,KAAOrvB,IAASwuB,GACZ,GAAI1B,EAAiB9sB,GAEjB+sB,EAAiB/sB,EAAKwtB,MAAM,GAC5BT,EAAiB/sB,EAAKytB,OAAO,GACzBztB,IAASA,EAAKoY,OAAOqV,QACrBC,GAAS1tB,EAAKoY,OAAOsV,OAEzB1tB,EAAOA,EAAKoY,WAPhB,CAUA,IAAK0U,EAAiB9sB,EAAKwtB,MAAO,CAG9B,GADA0B,EAAaxB,EAAQ1tB,EAAK2tB,OACtBuB,EAAahhB,EAAO,CAGpB6e,EAAiB/sB,GAAM,GACvB,QACJ,CACA,GAAIA,EAAKwtB,OAASgB,EAAU,CAExBxuB,EAAOA,EAAKwtB,KACZ,QACJ,CACJ,CAEA2B,EAAYzB,EAAQ1tB,EAAKkO,MACrBihB,EAAY7F,EAGZyD,EAAiB/sB,GAAM,IAG3BovB,EAAU1B,EAAQ1tB,EAAKspB,IACnB8F,GAAWlhB,IACXlO,EAAKouB,iBAAiBe,EAAWC,EAAS,GAC1CpwB,EAAOqwB,KAAervB,GAE1B+sB,EAAiB/sB,GAAM,GACnBA,EAAKytB,QAAUe,GAAa1B,EAAiB9sB,EAAKytB,SAElDC,GAAS1tB,EAAK0tB,MACd1tB,EAAOA,EAAKytB,OAjChB,CAsCJ,OADAV,EAAiBgC,EAAEL,MAAM,GAClB1vB,CACX,CA7MgCixB,CAAiBl2B,KAAMuR,EAAQA,EAASnM,GAEhE,IAAK,IAAImC,EAAI,EAAG2I,EAAM+lB,EAAgB7wB,OAAQmC,EAAI2I,EAAK3I,IAAK,CAExDsuB,EAAa71B,KADAi2B,EAAgB1uB,GAEjC,CACAvH,KAAK41B,6BAwMb,SAA0BZ,EAAG7gB,EAAOob,EAAKvY,GAOrC,IAAI/Q,EAAO+uB,EAAEL,KACThB,EAAQ,EACRwB,EAAa,EACbC,EAAY,EAChB,MAAMe,EAAanf,GAAcuY,EAAMpb,GACvC,KAAOlO,IAASwuB,GACZ,GAAI1B,EAAiB9sB,GAEjB+sB,EAAiB/sB,EAAKwtB,MAAM,GAC5BT,EAAiB/sB,EAAKytB,OAAO,GACzBztB,IAASA,EAAKoY,OAAOqV,QACrBC,GAAS1tB,EAAKoY,OAAOsV,OAEzByC,EAAgBnwB,GAChBA,EAAOA,EAAKoY,WARhB,CAWA,IAAK0U,EAAiB9sB,EAAKwtB,MAAO,CAG9B,GADA0B,EAAaxB,EAAQ1tB,EAAK2tB,OACtBuB,EAAahhB,EAAO,CAGpB6e,EAAiB/sB,GAAM,GACvB,QACJ,CACA,GAAIA,EAAKwtB,OAASgB,EAAU,CAExBxuB,EAAOA,EAAKwtB,KACZ,QACJ,CACJ,CAEA2B,EAAYzB,EAAQ1tB,EAAKkO,MACrBihB,EAAY7F,GACZtpB,EAAKkO,OAASgiB,EACdlwB,EAAKspB,KAAO4G,EACZlwB,EAAK0tB,OAASwC,GACVlwB,EAAK0tB,OAAS,YAA6C1tB,EAAK0tB,MAAQ,cACxEqB,EAAEJ,uBAAwB,GAI9B5B,EAAiB/sB,GAAM,KAG3B+sB,EAAiB/sB,GAAM,GACnBA,EAAKytB,QAAUe,GAAa1B,EAAiB9sB,EAAKytB,SAElDC,GAAS1tB,EAAK0tB,MACd1tB,EAAOA,EAAKytB,OAlChB,CAsCJV,EAAiBgC,EAAEL,MAAM,EAC7B,CApQQ0B,CAAiBr2B,KAAMuR,EAAQA,EAASnM,EAAQ4R,GAChDhX,KAAK41B,6BAEL,IAAK,IAAIruB,EAAI,EAAG2I,EAAM+lB,EAAgB7wB,OAAQmC,EAAI2I,EAAK3I,IAAK,CACxD,MAAMtB,EAAOgwB,EAAgB1uB,GAC7BtB,EAAKkO,MAAQlO,EAAK6tB,oBAClB7tB,EAAKspB,IAAMtpB,EAAK8tB,kBAChBuC,EAAerwB,EAAMsL,EAASA,EAASnM,EAAS4R,EAAYnV,GAC5DoE,EAAK2tB,OAAS3tB,EAAKspB,IACnBoG,EAAa31B,KAAMiG,EACvB,CACAjG,KAAK41B,4BACT,CACA,0BAAAA,GACS51B,KAAK40B,wBAGV50B,KAAK40B,uBAAwB,EAKrC,SAAwBI,GACpB,IAAI/uB,EAAO+uB,EAAEL,KACThB,EAAQ,EACZ,KAAO1tB,IAASwuB,GACRxuB,EAAKwtB,OAASgB,GAAa1B,EAAiB9sB,EAAKwtB,MAKjDxtB,EAAKytB,QAAUe,GAAa1B,EAAiB9sB,EAAKytB,QAOtDztB,EAAKkO,MAAQwf,EAAQ1tB,EAAKkO,MAC1BlO,EAAKspB,IAAMoE,EAAQ1tB,EAAKspB,IACxBtpB,EAAK0tB,MAAQ,EACbyC,EAAgBnwB,GAChB+sB,EAAiB/sB,GAAM,GAEvB+sB,EAAiB/sB,EAAKwtB,MAAM,GAC5BT,EAAiB/sB,EAAKytB,OAAO,GACzBztB,IAASA,EAAKoY,OAAOqV,QACrBC,GAAS1tB,EAAKoY,OAAOsV,OAEzB1tB,EAAOA,EAAKoY,SAhBRsV,GAAS1tB,EAAK0tB,MACd1tB,EAAOA,EAAKytB,OANZztB,EAAOA,EAAKwtB,KAuBpBT,EAAiBgC,EAAEL,MAAM,EAC7B,CAlCQ4B,CAAev2B,MACnB,EAkCJ,SAASw2B,EAAyBC,EAAcC,EAAgCC,EAAaC,GACzF,OAAIH,EAAeE,KAGfF,EAAeE,KAGG,IAAlBC,IAGkB,IAAlBA,GAGGF,GACX,CAKO,SAASJ,EAAerwB,EAAMkO,EAAOob,EAAKvY,EAAYnV,GACzD,MAAMg1B,EAjNV,SAA2B5wB,GACvB,OAAyB,GAAhBA,EAAK4sB,YAAkD,CACpE,CA+M2BiE,CAAkB7wB,GACnC8wB,EAAoD,IAAnBF,GACb,IAAnBA,EACDG,EAAkD,IAAnBH,GACX,IAAnBA,EACDI,EAAe1H,EAAMpb,EACrB+iB,EAAelgB,EACfmgB,EAAe32B,KAAK2M,IAAI8pB,EAAaC,GACrC9B,EAAYnvB,EAAKkO,MACvB,IAAIijB,GAAY,EAChB,MAAM/B,EAAUpvB,EAAKspB,IACrB,IAAI8H,GAAU,EACVljB,GAASihB,GAAaC,GAAW9F,GAvNzC,SAAkCtpB,GAC9B,OAAyB,GAAhBA,EAAK4sB,YAA6D,GAAmD,CAClI,CAqNgDyE,CAAyBrxB,KAGjEA,EAAKkO,MAAQA,EACbijB,GAAY,EACZnxB,EAAKspB,IAAMpb,EACXkjB,GAAU,GAEd,CACI,MAAMT,EAAgB/0B,EAAmB,EAAyCo1B,EAAc,EAAI,EAAwC,GACvIG,GAAaZ,EAAyBpB,EAAW2B,EAA+B5iB,EAAOyiB,KACxFQ,GAAY,IAEXC,GAAWb,EAAyBnB,EAAS2B,EAA6B7iB,EAAOyiB,KAClFS,GAAU,EAElB,CACA,GAAIF,EAAe,IAAMt1B,EAAkB,CACvC,MAAM+0B,EAAiBK,EAAcC,EAAe,EAAwC,GACvFE,GAAaZ,EAAyBpB,EAAW2B,EAA+B5iB,EAAQgjB,EAAcP,KACvGQ,GAAY,IAEXC,GAAWb,EAAyBnB,EAAS2B,EAA6B7iB,EAAQgjB,EAAcP,KACjGS,GAAU,EAElB,CACA,CACI,MAAMT,EAAgB/0B,EAAmB,EAAwC,GAC5Eu1B,GAAaZ,EAAyBpB,EAAW2B,EAA+BxH,EAAKqH,KACtF3wB,EAAKkO,MAAQA,EAAQ+iB,EACrBE,GAAY,IAEXC,GAAWb,EAAyBnB,EAAS2B,EAA6BzH,EAAKqH,KAChF3wB,EAAKspB,IAAMpb,EAAQ+iB,EACnBG,GAAU,EAElB,CAEA,MAAME,EAAeL,EAAeD,EAC/BG,IACDnxB,EAAKkO,MAAQ3T,KAAKC,IAAI,EAAG20B,EAAYmC,IAEpCF,IACDpxB,EAAKspB,IAAM/uB,KAAKC,IAAI,EAAG40B,EAAUkC,IAEjCtxB,EAAKkO,MAAQlO,EAAKspB,MAClBtpB,EAAKspB,IAAMtpB,EAAKkO,MAExB,CAgUA,SAASwhB,EAAaX,EAAGwC,GACrB,GAAIxC,EAAEL,OAASF,EAMX,OALA+C,EAAQnZ,OAASoW,EACjB+C,EAAQ/D,KAAOgB,EACf+C,EAAQ9D,MAAQe,EAChB3B,EAAa0E,EAAS,GACtBxC,EAAEL,KAAO6C,EACFxC,EAAEL,MA+CjB,SAAoBK,EAAGyC,GACnB,IAAI9D,EAAQ,EACR+D,EAAI1C,EAAEL,KACV,MAAMgD,EAAiBF,EAAEtjB,MACnByjB,EAAeH,EAAElI,IACvB,OAAa,CAET,GADYsI,EAAgBF,EAAgBC,EAAcF,EAAEvjB,MAAQwf,EAAO+D,EAAEnI,IAAMoE,GACzE,EAAG,CAGT,GAAI+D,EAAEjE,OAASgB,EAAU,CACrBgD,EAAEtjB,OAASwf,EACX8D,EAAElI,KAAOoE,EACT8D,EAAE7D,QAAUD,EACZ+D,EAAEjE,KAAOgE,EACT,KACJ,CAEIC,EAAIA,EAAEjE,IAEd,KACK,CAGD,GAAIiE,EAAEhE,QAAUe,EAAU,CACtBgD,EAAEtjB,OAAUwf,EAAQ+D,EAAE/D,MACtB8D,EAAElI,KAAQoE,EAAQ+D,EAAE/D,MACpB8D,EAAE7D,QAAWD,EAAQ+D,EAAE/D,MACvB+D,EAAEhE,MAAQ+D,EACV,KACJ,CAEI9D,GAAS+D,EAAE/D,MACX+D,EAAIA,EAAEhE,KAEd,CACJ,CACA+D,EAAEpZ,OAASqZ,EACXD,EAAEhE,KAAOgB,EACTgD,EAAE/D,MAAQe,EACV3B,EAAa2E,EAAG,EACpB,CAtFIK,CAAW9C,EAAGwC,GACdO,EAA0BP,EAAQnZ,QAElC,IAAIqZ,EAAIF,EACR,KAAOE,IAAM1C,EAAEL,MAAmC,IAA3B/B,EAAa8E,EAAErZ,SAClC,GAAIqZ,EAAErZ,SAAWqZ,EAAErZ,OAAOA,OAAOoV,KAAM,CACnC,MAAMuE,EAAIN,EAAErZ,OAAOA,OAAOqV,MACF,IAApBd,EAAaoF,IACblF,EAAa4E,EAAErZ,OAAQ,GACvByU,EAAakF,EAAG,GAChBlF,EAAa4E,EAAErZ,OAAOA,OAAQ,GAC9BqZ,EAAIA,EAAErZ,OAAOA,SAGTqZ,IAAMA,EAAErZ,OAAOqV,QACfgE,EAAIA,EAAErZ,OACN4Z,EAAWjD,EAAG0C,IAElB5E,EAAa4E,EAAErZ,OAAQ,GACvByU,EAAa4E,EAAErZ,OAAOA,OAAQ,GAC9B6Z,EAAYlD,EAAG0C,EAAErZ,OAAOA,QAEhC,KACK,CACD,MAAM2Z,EAAIN,EAAErZ,OAAOA,OAAOoV,KACF,IAApBb,EAAaoF,IACblF,EAAa4E,EAAErZ,OAAQ,GACvByU,EAAakF,EAAG,GAChBlF,EAAa4E,EAAErZ,OAAOA,OAAQ,GAC9BqZ,EAAIA,EAAErZ,OAAOA,SAGTqZ,IAAMA,EAAErZ,OAAOoV,OACfiE,EAAIA,EAAErZ,OACN6Z,EAAYlD,EAAG0C,IAEnB5E,EAAa4E,EAAErZ,OAAQ,GACvByU,EAAa4E,EAAErZ,OAAOA,OAAQ,GAC9B4Z,EAAWjD,EAAG0C,EAAErZ,OAAOA,QAE/B,CAGJ,OADAyU,EAAakC,EAAEL,KAAM,GACd6C,CACX,CA6CA,SAAS3B,EAAab,EAAGyC,GACrB,IAAIC,EACAM,EAqCJ,GAlCIP,EAAEhE,OAASgB,GACXiD,EAAID,EAAE/D,MACNsE,EAAIP,EAEJC,EAAE/D,OAAS8D,EAAE9D,OACT+D,EAAE/D,OAAS,YAA6C+D,EAAE/D,MAAQ,cAClEqB,EAAEJ,uBAAwB,GAE9B8C,EAAEvjB,OAASsjB,EAAE9D,MACb+D,EAAEnI,KAAOkI,EAAE9D,OAEN8D,EAAE/D,QAAUe,GACjBiD,EAAID,EAAEhE,KACNuE,EAAIP,IAGJO,EA6IR,SAAiB/xB,GACb,KAAOA,EAAKwtB,OAASgB,GACjBxuB,EAAOA,EAAKwtB,KAEhB,OAAOxtB,CACX,CAlJYkyB,CAAQV,EAAE/D,OACdgE,EAAIM,EAAEtE,MAINgE,EAAEvjB,OAAS6jB,EAAErE,MACb+D,EAAEnI,KAAOyI,EAAErE,MACX+D,EAAE/D,OAASqE,EAAErE,OACT+D,EAAE/D,OAAS,YAA6C+D,EAAE/D,MAAQ,cAClEqB,EAAEJ,uBAAwB,GAE9BoD,EAAE7jB,OAASsjB,EAAE9D,MACbqE,EAAEzI,KAAOkI,EAAE9D,MACXqE,EAAErE,MAAQ8D,EAAE9D,OACRqE,EAAErE,OAAS,YAA6CqE,EAAErE,MAAQ,cAClEqB,EAAEJ,uBAAwB,IAG9BoD,IAAMhD,EAAEL,KAOR,OANAK,EAAEL,KAAO+C,EACT5E,EAAa4E,EAAG,GAChBD,EAAEjD,SACF4D,IACAhC,EAAgBsB,QAChB1C,EAAEL,KAAKtW,OAASoW,GAGpB,MAAM4D,EAA+B,IAApBzF,EAAaoF,GAwC9B,GAvCIA,IAAMA,EAAE3Z,OAAOoV,KACfuE,EAAE3Z,OAAOoV,KAAOiE,EAGhBM,EAAE3Z,OAAOqV,MAAQgE,EAEjBM,IAAMP,EACNC,EAAErZ,OAAS2Z,EAAE3Z,QAGT2Z,EAAE3Z,SAAWoZ,EACbC,EAAErZ,OAAS2Z,EAGXN,EAAErZ,OAAS2Z,EAAE3Z,OAEjB2Z,EAAEvE,KAAOgE,EAAEhE,KACXuE,EAAEtE,MAAQ+D,EAAE/D,MACZsE,EAAE3Z,OAASoZ,EAAEpZ,OACbyU,EAAakF,EAAGpF,EAAa6E,IACzBA,IAAMzC,EAAEL,KACRK,EAAEL,KAAOqD,EAGLP,IAAMA,EAAEpZ,OAAOoV,KACfgE,EAAEpZ,OAAOoV,KAAOuE,EAGhBP,EAAEpZ,OAAOqV,MAAQsE,EAGrBA,EAAEvE,OAASgB,IACXuD,EAAEvE,KAAKpV,OAAS2Z,GAEhBA,EAAEtE,QAAUe,IACZuD,EAAEtE,MAAMrV,OAAS2Z,IAGzBP,EAAEjD,SACE6D,EAOA,OANAN,EAA0BL,EAAErZ,QACxB2Z,IAAMP,IACNM,EAA0BC,GAC1BD,EAA0BC,EAAE3Z,cAEhC+Z,IAUJ,IAAIE,EACJ,IARAP,EAA0BL,GAC1BK,EAA0BL,EAAErZ,QACxB2Z,IAAMP,IACNM,EAA0BC,GAC1BD,EAA0BC,EAAE3Z,SAIzBqZ,IAAM1C,EAAEL,MAA4B,IAApB/B,EAAa8E,IAC5BA,IAAMA,EAAErZ,OAAOoV,MACf6E,EAAIZ,EAAErZ,OAAOqV,MACW,IAApBd,EAAa0F,KACbxF,EAAawF,EAAG,GAChBxF,EAAa4E,EAAErZ,OAAQ,GACvB4Z,EAAWjD,EAAG0C,EAAErZ,QAChBia,EAAIZ,EAAErZ,OAAOqV,OAEY,IAAzBd,EAAa0F,EAAE7E,OAA+D,IAA1Bb,EAAa0F,EAAE5E,QACnEZ,EAAawF,EAAG,GAChBZ,EAAIA,EAAErZ,SAGwB,IAA1BuU,EAAa0F,EAAE5E,SACfZ,EAAawF,EAAE7E,KAAM,GACrBX,EAAawF,EAAG,GAChBJ,EAAYlD,EAAGsD,GACfA,EAAIZ,EAAErZ,OAAOqV,OAEjBZ,EAAawF,EAAG1F,EAAa8E,EAAErZ,SAC/ByU,EAAa4E,EAAErZ,OAAQ,GACvByU,EAAawF,EAAE5E,MAAO,GACtBuE,EAAWjD,EAAG0C,EAAErZ,QAChBqZ,EAAI1C,EAAEL,QAIV2D,EAAIZ,EAAErZ,OAAOoV,KACW,IAApBb,EAAa0F,KACbxF,EAAawF,EAAG,GAChBxF,EAAa4E,EAAErZ,OAAQ,GACvB6Z,EAAYlD,EAAG0C,EAAErZ,QACjBia,EAAIZ,EAAErZ,OAAOoV,MAEY,IAAzBb,EAAa0F,EAAE7E,OAA+D,IAA1Bb,EAAa0F,EAAE5E,QACnEZ,EAAawF,EAAG,GAChBZ,EAAIA,EAAErZ,SAGuB,IAAzBuU,EAAa0F,EAAE7E,QACfX,EAAawF,EAAE5E,MAAO,GACtBZ,EAAawF,EAAG,GAChBL,EAAWjD,EAAGsD,GACdA,EAAIZ,EAAErZ,OAAOoV,MAEjBX,EAAawF,EAAG1F,EAAa8E,EAAErZ,SAC/ByU,EAAa4E,EAAErZ,OAAQ,GACvByU,EAAawF,EAAE7E,KAAM,GACrByE,EAAYlD,EAAG0C,EAAErZ,QACjBqZ,EAAI1C,EAAEL,OAIlB7B,EAAa4E,EAAG,GAChBU,GACJ,CAOA,SAASA,IACL3D,EAASpW,OAASoW,EAClBA,EAASd,MAAQ,EACjBc,EAAStgB,MAAQ,EACjBsgB,EAASlF,IAAM,CACnB,CAGA,SAAS0I,EAAWjD,EAAG0C,GACnB,MAAMM,EAAIN,EAAEhE,MACZsE,EAAErE,OAAS+D,EAAE/D,OACTqE,EAAErE,OAAS,YAA6CqE,EAAErE,MAAQ,cAClEqB,EAAEJ,uBAAwB,GAE9BoD,EAAE7jB,OAASujB,EAAE/D,MACbqE,EAAEzI,KAAOmI,EAAE/D,MACX+D,EAAEhE,MAAQsE,EAAEvE,KACRuE,EAAEvE,OAASgB,IACXuD,EAAEvE,KAAKpV,OAASqZ,GAEpBM,EAAE3Z,OAASqZ,EAAErZ,OACTqZ,EAAErZ,SAAWoW,EACbO,EAAEL,KAAOqD,EAEJN,IAAMA,EAAErZ,OAAOoV,KACpBiE,EAAErZ,OAAOoV,KAAOuE,EAGhBN,EAAErZ,OAAOqV,MAAQsE,EAErBA,EAAEvE,KAAOiE,EACTA,EAAErZ,OAAS2Z,EACX5B,EAAgBsB,GAChBtB,EAAgB4B,EACpB,CACA,SAASE,EAAYlD,EAAGgD,GACpB,MAAMN,EAAIM,EAAEvE,KACZuE,EAAErE,OAAS+D,EAAE/D,OACTqE,EAAErE,OAAS,YAA6CqE,EAAErE,MAAQ,cAClEqB,EAAEJ,uBAAwB,GAE9BoD,EAAE7jB,OAASujB,EAAE/D,MACbqE,EAAEzI,KAAOmI,EAAE/D,MACXqE,EAAEvE,KAAOiE,EAAEhE,MACPgE,EAAEhE,QAAUe,IACZiD,EAAEhE,MAAMrV,OAAS2Z,GAErBN,EAAErZ,OAAS2Z,EAAE3Z,OACT2Z,EAAE3Z,SAAWoW,EACbO,EAAEL,KAAO+C,EAEJM,IAAMA,EAAE3Z,OAAOqV,MACpBsE,EAAE3Z,OAAOqV,MAAQgE,EAGjBM,EAAE3Z,OAAOoV,KAAOiE,EAEpBA,EAAEhE,MAAQsE,EACVA,EAAE3Z,OAASqZ,EACXtB,EAAgB4B,GAChB5B,EAAgBsB,EACpB,CAGA,SAASa,EAActyB,GACnB,IAAI2tB,EAAS3tB,EAAKspB,IAClB,GAAItpB,EAAKwtB,OAASgB,EAAU,CACxB,MAAM+D,EAAavyB,EAAKwtB,KAAKG,OACzB4E,EAAa5E,IACbA,EAAS4E,EAEjB,CACA,GAAIvyB,EAAKytB,QAAUe,EAAU,CACzB,MAAMgE,EAAcxyB,EAAKytB,MAAME,OAAS3tB,EAAK0tB,MACzC8E,EAAc7E,IACdA,EAAS6E,EAEjB,CACA,OAAO7E,CACX,CACO,SAASwC,EAAgBnwB,GAC5BA,EAAK2tB,OAAS2E,EAActyB,EAChC,CACA,SAAS8xB,EAA0B9xB,GAC/B,KAAOA,IAASwuB,GAAU,CACtB,MAAMb,EAAS2E,EAActyB,GAC7B,GAAIA,EAAK2tB,SAAWA,EAEhB,OAEJ3tB,EAAK2tB,OAASA,EACd3tB,EAAOA,EAAKoY,MAChB,CACJ,CAGO,SAASwZ,EAAgBa,EAAQC,EAAMC,EAAQC,GAClD,OAAIH,IAAWE,EACJD,EAAOE,EAEXH,EAASE,CACpB,C,yECx7BO,MAAME,EACT,WAAA34B,CAAY44B,EAIZC,EAKAC,EAIAC,EAA2BC,GACvBn5B,KAAK+4B,iBAAmBA,EACxB/4B,KAAKg5B,iBAAmBA,EACxBh5B,KAAKi5B,aAAeA,EACpBj5B,KAAKk5B,0BAA4BA,EACjCl5B,KAAKm5B,wBAA0BA,CACnC,CACA,kBAAAC,GACI,OAAOp5B,KAAKi5B,aAAa7zB,MAC7B,CACA,kBAAAi0B,CAAmBC,GACf,OAAIA,EAAkB,EACXt5B,KAAKm5B,wBAET,CACX,CACA,aAAA7W,CAAcgX,GAEV,MAAM5zB,EAAc4zB,EAAkB,EAAIt5B,KAAKi5B,aAAaK,EAAkB,GAAK,EAEnF,IAAIC,EADcv5B,KAAKi5B,aAAaK,GACP5zB,EAI7B,OAHI4zB,EAAkB,IAClBC,GAAcv5B,KAAKm5B,yBAEhBI,CACX,CACA,kBAAAC,CAAmBF,GACf,OAAOt5B,KAAKsiB,cAAcgX,EAC9B,CACA,sBAAAG,CAAuBH,EAAiBI,GAChCJ,EAAkB,IAClBI,EAAel5B,KAAKC,IAAI,EAAGi5B,EAAe15B,KAAKm5B,0BAGnD,IAAIQ,EADmD,IAApBL,EAAwBI,EAAe15B,KAAKi5B,aAAaK,EAAkB,GAAKI,EAEnH,GAA8B,OAA1B15B,KAAK+4B,iBACL,IAAK,IAAIxxB,EAAI,EAAGA,EAAIvH,KAAK+4B,iBAAiB3zB,QAClCu0B,EAAgB35B,KAAK+4B,iBAAiBxxB,GADIA,IAEtCoyB,EAAgB35B,KAAK+4B,iBAAiBxxB,GAAKvH,KAAKg5B,iBAAiBzxB,GAAGqyB,QAAQx0B,OAE5Eu0B,EAAgB35B,KAAK+4B,iBAAiBxxB,GAGtCoyB,GAAiB35B,KAAKg5B,iBAAiBzxB,GAAGqyB,QAAQx0B,OAQlE,OAAOu0B,CACX,CACA,yBAAAE,CAA0BC,EAAaC,EAAW,GAC9C,IAAIC,EAAkCF,EACtC,GAA8B,OAA1B95B,KAAK+4B,iBACL,IAAK,IAAIxxB,EAAI,EAAGA,EAAIvH,KAAK+4B,iBAAiB3zB,UAClC00B,EAAc95B,KAAK+4B,iBAAiBxxB,MAGvB,IAAbwyB,GAA+CD,IAAgB95B,KAAK+4B,iBAAiBxxB,IAJ3CA,IAO9CyyB,GAAmCh6B,KAAKg5B,iBAAiBzxB,GAAGqyB,QAAQx0B,OAG5E,OAAOpF,KAAKi6B,4CAA4CD,EAAiCD,EAC7F,CACA,2CAAAE,CAA4CC,EAA6BH,EAAW,GAChF,IAAII,EAAM,EACNC,EAAOp6B,KAAKi5B,aAAa7zB,OAAS,EAClCi1B,EAAM,EACNC,EAAW,EACf,KAAOH,GAAOC,GAAM,CAChBC,EAAMF,GAAQC,EAAOD,GAAO,EAAK,EACjC,MAAMI,EAAUv6B,KAAKi5B,aAAaoB,GAElC,GADAC,EAAWD,EAAM,EAAIr6B,KAAKi5B,aAAaoB,EAAM,GAAK,EACjC,IAAbN,EACA,GAAIG,GAA+BI,EAC/BF,EAAOC,EAAM,MAEZ,MAAIH,EAA8BK,GAInC,MAHAJ,EAAME,EAAM,CAIhB,MAGA,GAAIH,EAA8BI,EAC9BF,EAAOC,EAAM,MAEZ,MAAIH,GAA+BK,GAIpC,MAHAJ,EAAME,EAAM,CAIhB,CAER,CACA,IAAIX,EAAeQ,EAA8BI,EAIjD,OAHID,EAAM,IACNX,GAAgB15B,KAAKm5B,yBAElB,IAAIqB,EAAeH,EAAKX,EACnC,CACA,uBAAAe,CAAwBnB,EAAiBI,EAAcK,GACnD,GAA8B,OAA1B/5B,KAAK+4B,iBAA2B,CAChC,MAAMmB,EAA8Bl6B,KAAK06B,4CAA4CpB,EAAiBI,GAChGiB,EAAkC36B,KAAK46B,qDAAqDV,EAA6BH,GAC/H,GAAIY,IAAoCT,EAEpC,OAAOl6B,KAAKi6B,4CAA4CU,EAAiCZ,EAEjG,CACA,GAAiB,IAAbA,GACA,GAAIT,EAAkB,GAAKI,IAAiB15B,KAAKq5B,mBAAmBC,GAChE,OAAO,IAAIkB,EAAelB,EAAkB,EAAGt5B,KAAKw5B,mBAAmBF,EAAkB,SAG5F,GAAiB,IAAbS,EAA6C,CAElD,GAAIT,EADuBt5B,KAAKo5B,qBAAuB,GACXM,IAAiB15B,KAAKw5B,mBAAmBF,GACjF,OAAO,IAAIkB,EAAelB,EAAkB,EAAGt5B,KAAKq5B,mBAAmBC,EAAkB,GAEjG,CACA,OAAO,IAAIkB,EAAelB,EAAiBI,EAC/C,CACA,2CAAAgB,CAA4CpB,EAAiBI,GACrDJ,EAAkB,IAClBI,EAAel5B,KAAKC,IAAI,EAAGi5B,EAAe15B,KAAKm5B,0BAGnD,OADgBG,EAAkB,EAAIt5B,KAAKi5B,aAAaK,EAAkB,GAAK,GAAKI,CAExF,CACA,oDAAAkB,CAAqDV,EAA6BH,GAC9E,MAAMc,EAAe76B,KAAK86B,wBAAwBZ,GAClD,IAAKW,EACD,OAAOX,EAEX,GAAiB,IAAbH,EAA4C,CAC5C,GAAIG,IAAgCW,EAAaX,4BAA8BW,EAAaz1B,QACrF21B,EAAmB/6B,KAAKg5B,iBAAiB6B,EAAaG,mBAAmBC,aAC5E,OAAOJ,EAAaX,4BAA8BW,EAAaz1B,OAE9D,CACD,IAAIH,EAAS41B,EAAaX,4BAC1B,GAAIgB,EAAkBl7B,KAAKg5B,iBAAiB6B,EAAaG,mBAAmBC,aACxE,OAAOh2B,EAEX,IAAImL,EAAQyqB,EAAaG,kBAAoB,EAC7C,KAAO5qB,GAAS,GAAKpQ,KAAK+4B,iBAAiB3oB,KAAWpQ,KAAK+4B,iBAAiB8B,EAAaG,qBACjFD,EAAmB/6B,KAAKg5B,iBAAiB5oB,GAAO6qB,eAGpDh2B,GAAUjF,KAAKg5B,iBAAiB5oB,GAAOwpB,QAAQx0B,QAC3C81B,EAAkBl7B,KAAKg5B,iBAAiB5oB,GAAO6qB,eAGnD7qB,IAEJ,OAAOnL,CACX,CACJ,CACK,GAAiB,IAAb80B,GAA4D,IAAbA,EAA2D,CAC/G,IAAI90B,EAAS41B,EAAaX,4BAA8BW,EAAaz1B,OACjEgL,EAAQyqB,EAAaG,kBAEzB,KAAO5qB,EAAQ,EAAIpQ,KAAK+4B,iBAAiB3zB,QAAUpF,KAAK+4B,iBAAiB3oB,EAAQ,KAAOpQ,KAAK+4B,iBAAiB3oB,IAC1GnL,GAAUjF,KAAKg5B,iBAAiB5oB,EAAQ,GAAGwpB,QAAQx0B,OACnDgL,IAEJ,OAAOnL,CACX,CACK,GAAiB,IAAb80B,GAA2D,IAAbA,EAA0D,CAE7G,IAAI90B,EAAS41B,EAAaX,4BACtB9pB,EAAQyqB,EAAaG,kBAEzB,KAAO5qB,EAAQ,GAAK,GAAKpQ,KAAK+4B,iBAAiB3oB,EAAQ,KAAOpQ,KAAK+4B,iBAAiB3oB,IAChFnL,GAAUjF,KAAKg5B,iBAAiB5oB,EAAQ,GAAGwpB,QAAQx0B,OACnDgL,IAEJ,OAAOnL,CACX,EACA,QAAY80B,EAChB,CACA,eAAAoB,CAAgB7B,EAAiBI,GAC7B,MAAMnoB,EAASvR,KAAK06B,4CAA4CpB,EAAiBI,GAC3EmB,EAAe76B,KAAK86B,wBAAwBvpB,GAClD,OAAKspB,EAGE,CACHhW,QAAS7kB,KAAKg5B,iBAAiB6B,EAAaG,oBAHrC,IAKf,CACA,uBAAAF,CAAwBZ,GACpB,MAAMnB,EAAmB/4B,KAAK+4B,iBACxBC,EAAmBh5B,KAAKg5B,iBAC9B,GAAyB,OAArBD,EAA2B,CAC3B,IAAIqC,EAAgC,EACpC,IAAK,IAAI7zB,EAAI,EAAGA,EAAIwxB,EAAiB3zB,OAAQmC,IAAK,CAC9C,MAAMnC,EAAS4zB,EAAiBzxB,GAAGqyB,QAAQx0B,OACrCi2B,EAA+CtC,EAAiBxxB,GAAK6zB,EACrEE,EAA6CvC,EAAiBxxB,GAAK6zB,EAAgCh2B,EACzG,GAAIi2B,EAA+CnB,EAE/C,MAEJ,GAAIA,GAA+BoB,EAE/B,MAAO,CACHN,kBAAmBzzB,EACnB2yB,4BAA6BmB,EAC7Bj2B,UAGRg2B,GAAiCh2B,CACrC,CACJ,CAEJ,EAEJ,SAAS21B,EAAmBQ,GACxB,OAAIA,UAGGA,IAAe,YAAiCA,IAAe,UAC1E,CACA,SAASL,EAAkBK,GACvB,OAAIA,UAGGA,IAAe,WAAgCA,IAAe,UACzE,CAMO,MAAMf,EACT,WAAAr6B,CAAYm5B,EAAiBI,GACzB15B,KAAKs5B,gBAAkBA,EACvBt5B,KAAK05B,aAAeA,CACxB,CACA,QAAArkB,GACI,MAAO,GAAGrV,KAAKs5B,mBAAmBt5B,KAAK05B,cAC3C,CACA,UAAA8B,CAAWC,GACP,OAAO,IAAI,IAASA,EAAiBz7B,KAAKs5B,gBAAiBt5B,KAAK05B,aAAe,EACnF,E","sources":["file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/model.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/bracketPairsTree.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsImpl.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/ast.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/beforeEditPositionMapper.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/brackets.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/combineTextEditInfos.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/length.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/concat23Trees.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/nodeReader.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/parser.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/smallImmutableSet.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/tokenizer.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/model/bracketPairsTextModelPart/colorizedBracketPairsDecorationProvider.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/model/bracketPairsTextModelPart/fixBrackets.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/model/editStack.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/model/fixedArray.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/model/guidesTextModelPart.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/model/indentationGuesser.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/model/intervalTree.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/modelLineProjectionData.js"],"sourcesContent":["/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { equals } from '../../base/common/objects.js';\n/**\n * Vertical Lane in the overview ruler of the editor.\n */\nexport var OverviewRulerLane;\n(function (OverviewRulerLane) {\n    OverviewRulerLane[OverviewRulerLane[\"Left\"] = 1] = \"Left\";\n    OverviewRulerLane[OverviewRulerLane[\"Center\"] = 2] = \"Center\";\n    OverviewRulerLane[OverviewRulerLane[\"Right\"] = 4] = \"Right\";\n    OverviewRulerLane[OverviewRulerLane[\"Full\"] = 7] = \"Full\";\n})(OverviewRulerLane || (OverviewRulerLane = {}));\n/**\n * Vertical Lane in the glyph margin of the editor.\n */\nexport var GlyphMarginLane;\n(function (GlyphMarginLane) {\n    GlyphMarginLane[GlyphMarginLane[\"Left\"] = 1] = \"Left\";\n    GlyphMarginLane[GlyphMarginLane[\"Center\"] = 2] = \"Center\";\n    GlyphMarginLane[GlyphMarginLane[\"Right\"] = 3] = \"Right\";\n})(GlyphMarginLane || (GlyphMarginLane = {}));\nexport var InjectedTextCursorStops;\n(function (InjectedTextCursorStops) {\n    InjectedTextCursorStops[InjectedTextCursorStops[\"Both\"] = 0] = \"Both\";\n    InjectedTextCursorStops[InjectedTextCursorStops[\"Right\"] = 1] = \"Right\";\n    InjectedTextCursorStops[InjectedTextCursorStops[\"Left\"] = 2] = \"Left\";\n    InjectedTextCursorStops[InjectedTextCursorStops[\"None\"] = 3] = \"None\";\n})(InjectedTextCursorStops || (InjectedTextCursorStops = {}));\nexport class TextModelResolvedOptions {\n    get originalIndentSize() {\n        return this._indentSizeIsTabSize ? 'tabSize' : this.indentSize;\n    }\n    /**\n     * @internal\n     */\n    constructor(src) {\n        this._textModelResolvedOptionsBrand = undefined;\n        this.tabSize = Math.max(1, src.tabSize | 0);\n        if (src.indentSize === 'tabSize') {\n            this.indentSize = this.tabSize;\n            this._indentSizeIsTabSize = true;\n        }\n        else {\n            this.indentSize = Math.max(1, src.indentSize | 0);\n            this._indentSizeIsTabSize = false;\n        }\n        this.insertSpaces = Boolean(src.insertSpaces);\n        this.defaultEOL = src.defaultEOL | 0;\n        this.trimAutoWhitespace = Boolean(src.trimAutoWhitespace);\n        this.bracketPairColorizationOptions = src.bracketPairColorizationOptions;\n    }\n    /**\n     * @internal\n     */\n    equals(other) {\n        return (this.tabSize === other.tabSize\n            && this._indentSizeIsTabSize === other._indentSizeIsTabSize\n            && this.indentSize === other.indentSize\n            && this.insertSpaces === other.insertSpaces\n            && this.defaultEOL === other.defaultEOL\n            && this.trimAutoWhitespace === other.trimAutoWhitespace\n            && equals(this.bracketPairColorizationOptions, other.bracketPairColorizationOptions));\n    }\n    /**\n     * @internal\n     */\n    createChangeEvent(newOpts) {\n        return {\n            tabSize: this.tabSize !== newOpts.tabSize,\n            indentSize: this.indentSize !== newOpts.indentSize,\n            insertSpaces: this.insertSpaces !== newOpts.insertSpaces,\n            trimAutoWhitespace: this.trimAutoWhitespace !== newOpts.trimAutoWhitespace,\n        };\n    }\n}\nexport class FindMatch {\n    /**\n     * @internal\n     */\n    constructor(range, matches) {\n        this._findMatchBrand = undefined;\n        this.range = range;\n        this.matches = matches;\n    }\n}\n/**\n * @internal\n */\nexport function isITextSnapshot(obj) {\n    return (obj && typeof obj.read === 'function');\n}\n/**\n * @internal\n */\nexport class ValidAnnotatedEditOperation {\n    constructor(identifier, range, text, forceMoveMarkers, isAutoWhitespaceEdit, _isTracked) {\n        this.identifier = identifier;\n        this.range = range;\n        this.text = text;\n        this.forceMoveMarkers = forceMoveMarkers;\n        this.isAutoWhitespaceEdit = isAutoWhitespaceEdit;\n        this._isTracked = _isTracked;\n    }\n}\n/**\n * @internal\n */\nexport class SearchData {\n    constructor(regex, wordSeparators, simpleSearch) {\n        this.regex = regex;\n        this.wordSeparators = wordSeparators;\n        this.simpleSearch = simpleSearch;\n    }\n}\n/**\n * @internal\n */\nexport class ApplyEditsResult {\n    constructor(reverseEdits, changes, trimAutoWhitespaceLineNumbers) {\n        this.reverseEdits = reverseEdits;\n        this.changes = changes;\n        this.trimAutoWhitespaceLineNumbers = trimAutoWhitespaceLineNumbers;\n    }\n}\n/**\n * @internal\n */\nexport function shouldSynchronizeModel(model) {\n    return (!model.isTooLargeForSyncing() && !model.isForSimpleWidget);\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Emitter } from '../../../../../base/common/event.js';\nimport { Disposable } from '../../../../../base/common/lifecycle.js';\nimport { BracketInfo, BracketPairWithMinIndentationInfo } from '../../../textModelBracketPairs.js';\nimport { TextEditInfo } from './beforeEditPositionMapper.js';\nimport { LanguageAgnosticBracketTokens } from './brackets.js';\nimport { lengthAdd, lengthGreaterThanEqual, lengthLessThan, lengthLessThanEqual, lengthsToRange, lengthZero, positionToLength, toLength } from './length.js';\nimport { parseDocument } from './parser.js';\nimport { DenseKeyProvider } from './smallImmutableSet.js';\nimport { FastTokenizer, TextBufferTokenizer } from './tokenizer.js';\nimport { CallbackIterable } from '../../../../../base/common/arrays.js';\nimport { combineTextEditInfos } from './combineTextEditInfos.js';\nexport class BracketPairsTree extends Disposable {\n    didLanguageChange(languageId) {\n        return this.brackets.didLanguageChange(languageId);\n    }\n    constructor(textModel, getLanguageConfiguration) {\n        super();\n        this.textModel = textModel;\n        this.getLanguageConfiguration = getLanguageConfiguration;\n        this.didChangeEmitter = new Emitter();\n        this.denseKeyProvider = new DenseKeyProvider();\n        this.brackets = new LanguageAgnosticBracketTokens(this.denseKeyProvider, this.getLanguageConfiguration);\n        this.onDidChange = this.didChangeEmitter.event;\n        this.queuedTextEditsForInitialAstWithoutTokens = [];\n        this.queuedTextEdits = [];\n        if (!textModel.tokenization.hasTokens) {\n            const brackets = this.brackets.getSingleLanguageBracketTokens(this.textModel.getLanguageId());\n            const tokenizer = new FastTokenizer(this.textModel.getValue(), brackets);\n            this.initialAstWithoutTokens = parseDocument(tokenizer, [], undefined, true);\n            this.astWithTokens = this.initialAstWithoutTokens;\n        }\n        else if (textModel.tokenization.backgroundTokenizationState === 2 /* BackgroundTokenizationState.Completed */) {\n            // Skip the initial ast, as there is no flickering.\n            // Directly create the tree with token information.\n            this.initialAstWithoutTokens = undefined;\n            this.astWithTokens = this.parseDocumentFromTextBuffer([], undefined, false);\n        }\n        else {\n            // We missed some token changes already, so we cannot use the fast tokenizer + delta increments\n            this.initialAstWithoutTokens = this.parseDocumentFromTextBuffer([], undefined, true);\n            this.astWithTokens = this.initialAstWithoutTokens;\n        }\n    }\n    //#region TextModel events\n    handleDidChangeBackgroundTokenizationState() {\n        if (this.textModel.tokenization.backgroundTokenizationState === 2 /* BackgroundTokenizationState.Completed */) {\n            const wasUndefined = this.initialAstWithoutTokens === undefined;\n            // Clear the initial tree as we can use the tree with token information now.\n            this.initialAstWithoutTokens = undefined;\n            if (!wasUndefined) {\n                this.didChangeEmitter.fire();\n            }\n        }\n    }\n    handleDidChangeTokens({ ranges }) {\n        const edits = ranges.map(r => new TextEditInfo(toLength(r.fromLineNumber - 1, 0), toLength(r.toLineNumber, 0), toLength(r.toLineNumber - r.fromLineNumber + 1, 0)));\n        this.handleEdits(edits, true);\n        if (!this.initialAstWithoutTokens) {\n            this.didChangeEmitter.fire();\n        }\n    }\n    handleContentChanged(change) {\n        const edits = TextEditInfo.fromModelContentChanges(change.changes);\n        this.handleEdits(edits, false);\n    }\n    handleEdits(edits, tokenChange) {\n        // Lazily queue the edits and only apply them when the tree is accessed.\n        const result = combineTextEditInfos(this.queuedTextEdits, edits);\n        this.queuedTextEdits = result;\n        if (this.initialAstWithoutTokens && !tokenChange) {\n            this.queuedTextEditsForInitialAstWithoutTokens = combineTextEditInfos(this.queuedTextEditsForInitialAstWithoutTokens, edits);\n        }\n    }\n    //#endregion\n    flushQueue() {\n        if (this.queuedTextEdits.length > 0) {\n            this.astWithTokens = this.parseDocumentFromTextBuffer(this.queuedTextEdits, this.astWithTokens, false);\n            this.queuedTextEdits = [];\n        }\n        if (this.queuedTextEditsForInitialAstWithoutTokens.length > 0) {\n            if (this.initialAstWithoutTokens) {\n                this.initialAstWithoutTokens = this.parseDocumentFromTextBuffer(this.queuedTextEditsForInitialAstWithoutTokens, this.initialAstWithoutTokens, false);\n            }\n            this.queuedTextEditsForInitialAstWithoutTokens = [];\n        }\n    }\n    /**\n     * @pure (only if isPure = true)\n    */\n    parseDocumentFromTextBuffer(edits, previousAst, immutable) {\n        // Is much faster if `isPure = false`.\n        const isPure = false;\n        const previousAstClone = isPure ? previousAst === null || previousAst === void 0 ? void 0 : previousAst.deepClone() : previousAst;\n        const tokenizer = new TextBufferTokenizer(this.textModel, this.brackets);\n        const result = parseDocument(tokenizer, edits, previousAstClone, immutable);\n        return result;\n    }\n    getBracketsInRange(range, onlyColorizedBrackets) {\n        this.flushQueue();\n        const startOffset = toLength(range.startLineNumber - 1, range.startColumn - 1);\n        const endOffset = toLength(range.endLineNumber - 1, range.endColumn - 1);\n        return new CallbackIterable(cb => {\n            const node = this.initialAstWithoutTokens || this.astWithTokens;\n            collectBrackets(node, lengthZero, node.length, startOffset, endOffset, cb, 0, 0, new Map(), onlyColorizedBrackets);\n        });\n    }\n    getBracketPairsInRange(range, includeMinIndentation) {\n        this.flushQueue();\n        const startLength = positionToLength(range.getStartPosition());\n        const endLength = positionToLength(range.getEndPosition());\n        return new CallbackIterable(cb => {\n            const node = this.initialAstWithoutTokens || this.astWithTokens;\n            const context = new CollectBracketPairsContext(cb, includeMinIndentation, this.textModel);\n            collectBracketPairs(node, lengthZero, node.length, startLength, endLength, context, 0, new Map());\n        });\n    }\n    getFirstBracketAfter(position) {\n        this.flushQueue();\n        const node = this.initialAstWithoutTokens || this.astWithTokens;\n        return getFirstBracketAfter(node, lengthZero, node.length, positionToLength(position));\n    }\n    getFirstBracketBefore(position) {\n        this.flushQueue();\n        const node = this.initialAstWithoutTokens || this.astWithTokens;\n        return getFirstBracketBefore(node, lengthZero, node.length, positionToLength(position));\n    }\n}\nfunction getFirstBracketBefore(node, nodeOffsetStart, nodeOffsetEnd, position) {\n    if (node.kind === 4 /* AstNodeKind.List */ || node.kind === 2 /* AstNodeKind.Pair */) {\n        const lengths = [];\n        for (const child of node.children) {\n            nodeOffsetEnd = lengthAdd(nodeOffsetStart, child.length);\n            lengths.push({ nodeOffsetStart, nodeOffsetEnd });\n            nodeOffsetStart = nodeOffsetEnd;\n        }\n        for (let i = lengths.length - 1; i >= 0; i--) {\n            const { nodeOffsetStart, nodeOffsetEnd } = lengths[i];\n            if (lengthLessThan(nodeOffsetStart, position)) {\n                const result = getFirstBracketBefore(node.children[i], nodeOffsetStart, nodeOffsetEnd, position);\n                if (result) {\n                    return result;\n                }\n            }\n        }\n        return null;\n    }\n    else if (node.kind === 3 /* AstNodeKind.UnexpectedClosingBracket */) {\n        return null;\n    }\n    else if (node.kind === 1 /* AstNodeKind.Bracket */) {\n        const range = lengthsToRange(nodeOffsetStart, nodeOffsetEnd);\n        return {\n            bracketInfo: node.bracketInfo,\n            range\n        };\n    }\n    return null;\n}\nfunction getFirstBracketAfter(node, nodeOffsetStart, nodeOffsetEnd, position) {\n    if (node.kind === 4 /* AstNodeKind.List */ || node.kind === 2 /* AstNodeKind.Pair */) {\n        for (const child of node.children) {\n            nodeOffsetEnd = lengthAdd(nodeOffsetStart, child.length);\n            if (lengthLessThan(position, nodeOffsetEnd)) {\n                const result = getFirstBracketAfter(child, nodeOffsetStart, nodeOffsetEnd, position);\n                if (result) {\n                    return result;\n                }\n            }\n            nodeOffsetStart = nodeOffsetEnd;\n        }\n        return null;\n    }\n    else if (node.kind === 3 /* AstNodeKind.UnexpectedClosingBracket */) {\n        return null;\n    }\n    else if (node.kind === 1 /* AstNodeKind.Bracket */) {\n        const range = lengthsToRange(nodeOffsetStart, nodeOffsetEnd);\n        return {\n            bracketInfo: node.bracketInfo,\n            range\n        };\n    }\n    return null;\n}\nfunction collectBrackets(node, nodeOffsetStart, nodeOffsetEnd, startOffset, endOffset, push, level, nestingLevelOfEqualBracketType, levelPerBracketType, onlyColorizedBrackets, parentPairIsIncomplete = false) {\n    if (level > 200) {\n        return true;\n    }\n    whileLoop: while (true) {\n        switch (node.kind) {\n            case 4 /* AstNodeKind.List */: {\n                const childCount = node.childrenLength;\n                for (let i = 0; i < childCount; i++) {\n                    const child = node.getChild(i);\n                    if (!child) {\n                        continue;\n                    }\n                    nodeOffsetEnd = lengthAdd(nodeOffsetStart, child.length);\n                    if (lengthLessThanEqual(nodeOffsetStart, endOffset) &&\n                        lengthGreaterThanEqual(nodeOffsetEnd, startOffset)) {\n                        const childEndsAfterEnd = lengthGreaterThanEqual(nodeOffsetEnd, endOffset);\n                        if (childEndsAfterEnd) {\n                            // No child after this child in the requested window, don't recurse\n                            node = child;\n                            continue whileLoop;\n                        }\n                        const shouldContinue = collectBrackets(child, nodeOffsetStart, nodeOffsetEnd, startOffset, endOffset, push, level, 0, levelPerBracketType, onlyColorizedBrackets);\n                        if (!shouldContinue) {\n                            return false;\n                        }\n                    }\n                    nodeOffsetStart = nodeOffsetEnd;\n                }\n                return true;\n            }\n            case 2 /* AstNodeKind.Pair */: {\n                const colorize = !onlyColorizedBrackets || !node.closingBracket || node.closingBracket.bracketInfo.closesColorized(node.openingBracket.bracketInfo);\n                let levelPerBracket = 0;\n                if (levelPerBracketType) {\n                    let existing = levelPerBracketType.get(node.openingBracket.text);\n                    if (existing === undefined) {\n                        existing = 0;\n                    }\n                    levelPerBracket = existing;\n                    if (colorize) {\n                        existing++;\n                        levelPerBracketType.set(node.openingBracket.text, existing);\n                    }\n                }\n                const childCount = node.childrenLength;\n                for (let i = 0; i < childCount; i++) {\n                    const child = node.getChild(i);\n                    if (!child) {\n                        continue;\n                    }\n                    nodeOffsetEnd = lengthAdd(nodeOffsetStart, child.length);\n                    if (lengthLessThanEqual(nodeOffsetStart, endOffset) &&\n                        lengthGreaterThanEqual(nodeOffsetEnd, startOffset)) {\n                        const childEndsAfterEnd = lengthGreaterThanEqual(nodeOffsetEnd, endOffset);\n                        if (childEndsAfterEnd && child.kind !== 1 /* AstNodeKind.Bracket */) {\n                            // No child after this child in the requested window, don't recurse\n                            // Don't do this for brackets because of unclosed/unopened brackets\n                            node = child;\n                            if (colorize) {\n                                level++;\n                                nestingLevelOfEqualBracketType = levelPerBracket + 1;\n                            }\n                            else {\n                                nestingLevelOfEqualBracketType = levelPerBracket;\n                            }\n                            continue whileLoop;\n                        }\n                        if (colorize || child.kind !== 1 /* AstNodeKind.Bracket */ || !node.closingBracket) {\n                            const shouldContinue = collectBrackets(child, nodeOffsetStart, nodeOffsetEnd, startOffset, endOffset, push, colorize ? level + 1 : level, colorize ? levelPerBracket + 1 : levelPerBracket, levelPerBracketType, onlyColorizedBrackets, !node.closingBracket);\n                            if (!shouldContinue) {\n                                return false;\n                            }\n                        }\n                    }\n                    nodeOffsetStart = nodeOffsetEnd;\n                }\n                levelPerBracketType === null || levelPerBracketType === void 0 ? void 0 : levelPerBracketType.set(node.openingBracket.text, levelPerBracket);\n                return true;\n            }\n            case 3 /* AstNodeKind.UnexpectedClosingBracket */: {\n                const range = lengthsToRange(nodeOffsetStart, nodeOffsetEnd);\n                return push(new BracketInfo(range, level - 1, 0, true));\n            }\n            case 1 /* AstNodeKind.Bracket */: {\n                const range = lengthsToRange(nodeOffsetStart, nodeOffsetEnd);\n                return push(new BracketInfo(range, level - 1, nestingLevelOfEqualBracketType - 1, parentPairIsIncomplete));\n            }\n            case 0 /* AstNodeKind.Text */:\n                return true;\n        }\n    }\n}\nclass CollectBracketPairsContext {\n    constructor(push, includeMinIndentation, textModel) {\n        this.push = push;\n        this.includeMinIndentation = includeMinIndentation;\n        this.textModel = textModel;\n    }\n}\nfunction collectBracketPairs(node, nodeOffsetStart, nodeOffsetEnd, startOffset, endOffset, context, level, levelPerBracketType) {\n    var _a;\n    if (level > 200) {\n        return true;\n    }\n    let shouldContinue = true;\n    if (node.kind === 2 /* AstNodeKind.Pair */) {\n        let levelPerBracket = 0;\n        if (levelPerBracketType) {\n            let existing = levelPerBracketType.get(node.openingBracket.text);\n            if (existing === undefined) {\n                existing = 0;\n            }\n            levelPerBracket = existing;\n            existing++;\n            levelPerBracketType.set(node.openingBracket.text, existing);\n        }\n        const openingBracketEnd = lengthAdd(nodeOffsetStart, node.openingBracket.length);\n        let minIndentation = -1;\n        if (context.includeMinIndentation) {\n            minIndentation = node.computeMinIndentation(nodeOffsetStart, context.textModel);\n        }\n        shouldContinue = context.push(new BracketPairWithMinIndentationInfo(lengthsToRange(nodeOffsetStart, nodeOffsetEnd), lengthsToRange(nodeOffsetStart, openingBracketEnd), node.closingBracket\n            ? lengthsToRange(lengthAdd(openingBracketEnd, ((_a = node.child) === null || _a === void 0 ? void 0 : _a.length) || lengthZero), nodeOffsetEnd)\n            : undefined, level, levelPerBracket, node, minIndentation));\n        nodeOffsetStart = openingBracketEnd;\n        if (shouldContinue && node.child) {\n            const child = node.child;\n            nodeOffsetEnd = lengthAdd(nodeOffsetStart, child.length);\n            if (lengthLessThanEqual(nodeOffsetStart, endOffset) &&\n                lengthGreaterThanEqual(nodeOffsetEnd, startOffset)) {\n                shouldContinue = collectBracketPairs(child, nodeOffsetStart, nodeOffsetEnd, startOffset, endOffset, context, level + 1, levelPerBracketType);\n                if (!shouldContinue) {\n                    return false;\n                }\n            }\n        }\n        levelPerBracketType === null || levelPerBracketType === void 0 ? void 0 : levelPerBracketType.set(node.openingBracket.text, levelPerBracket);\n    }\n    else {\n        let curOffset = nodeOffsetStart;\n        for (const child of node.children) {\n            const childOffset = curOffset;\n            curOffset = lengthAdd(curOffset, child.length);\n            if (lengthLessThanEqual(childOffset, endOffset) &&\n                lengthLessThanEqual(startOffset, curOffset)) {\n                shouldContinue = collectBracketPairs(child, childOffset, curOffset, startOffset, endOffset, context, level, levelPerBracketType);\n                if (!shouldContinue) {\n                    return false;\n                }\n            }\n        }\n    }\n    return shouldContinue;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { CallbackIterable, compareBy } from '../../../../base/common/arrays.js';\nimport { Emitter } from '../../../../base/common/event.js';\nimport { Disposable, DisposableStore, MutableDisposable } from '../../../../base/common/lifecycle.js';\nimport { Range } from '../../core/range.js';\nimport { ignoreBracketsInToken } from '../../languages/supports.js';\nimport { BracketsUtils } from '../../languages/supports/richEditBrackets.js';\nimport { BracketPairsTree } from './bracketPairsTree/bracketPairsTree.js';\nexport class BracketPairsTextModelPart extends Disposable {\n    get canBuildAST() {\n        const maxSupportedDocumentLength = /* max lines */ 50000 * /* average column count */ 100;\n        return this.textModel.getValueLength() <= maxSupportedDocumentLength;\n    }\n    constructor(textModel, languageConfigurationService) {\n        super();\n        this.textModel = textModel;\n        this.languageConfigurationService = languageConfigurationService;\n        this.bracketPairsTree = this._register(new MutableDisposable());\n        this.onDidChangeEmitter = new Emitter();\n        this.onDidChange = this.onDidChangeEmitter.event;\n        this.bracketsRequested = false;\n        this._register(this.languageConfigurationService.onDidChange(e => {\n            var _a;\n            if (!e.languageId || ((_a = this.bracketPairsTree.value) === null || _a === void 0 ? void 0 : _a.object.didLanguageChange(e.languageId))) {\n                this.bracketPairsTree.clear();\n                this.updateBracketPairsTree();\n            }\n        }));\n    }\n    //#region TextModel events\n    handleDidChangeOptions(e) {\n        this.bracketPairsTree.clear();\n        this.updateBracketPairsTree();\n    }\n    handleDidChangeLanguage(e) {\n        this.bracketPairsTree.clear();\n        this.updateBracketPairsTree();\n    }\n    handleDidChangeContent(change) {\n        var _a;\n        (_a = this.bracketPairsTree.value) === null || _a === void 0 ? void 0 : _a.object.handleContentChanged(change);\n    }\n    handleDidChangeBackgroundTokenizationState() {\n        var _a;\n        (_a = this.bracketPairsTree.value) === null || _a === void 0 ? void 0 : _a.object.handleDidChangeBackgroundTokenizationState();\n    }\n    handleDidChangeTokens(e) {\n        var _a;\n        (_a = this.bracketPairsTree.value) === null || _a === void 0 ? void 0 : _a.object.handleDidChangeTokens(e);\n    }\n    //#endregion\n    updateBracketPairsTree() {\n        if (this.bracketsRequested && this.canBuildAST) {\n            if (!this.bracketPairsTree.value) {\n                const store = new DisposableStore();\n                this.bracketPairsTree.value = createDisposableRef(store.add(new BracketPairsTree(this.textModel, (languageId) => {\n                    return this.languageConfigurationService.getLanguageConfiguration(languageId);\n                })), store);\n                store.add(this.bracketPairsTree.value.object.onDidChange(e => this.onDidChangeEmitter.fire(e)));\n                this.onDidChangeEmitter.fire();\n            }\n        }\n        else {\n            if (this.bracketPairsTree.value) {\n                this.bracketPairsTree.clear();\n                // Important: Don't call fire if there was no change!\n                this.onDidChangeEmitter.fire();\n            }\n        }\n    }\n    /**\n     * Returns all bracket pairs that intersect the given range.\n     * The result is sorted by the start position.\n    */\n    getBracketPairsInRange(range) {\n        var _a;\n        this.bracketsRequested = true;\n        this.updateBracketPairsTree();\n        return ((_a = this.bracketPairsTree.value) === null || _a === void 0 ? void 0 : _a.object.getBracketPairsInRange(range, false)) || CallbackIterable.empty;\n    }\n    getBracketPairsInRangeWithMinIndentation(range) {\n        var _a;\n        this.bracketsRequested = true;\n        this.updateBracketPairsTree();\n        return ((_a = this.bracketPairsTree.value) === null || _a === void 0 ? void 0 : _a.object.getBracketPairsInRange(range, true)) || CallbackIterable.empty;\n    }\n    getBracketsInRange(range, onlyColorizedBrackets = false) {\n        var _a;\n        this.bracketsRequested = true;\n        this.updateBracketPairsTree();\n        return ((_a = this.bracketPairsTree.value) === null || _a === void 0 ? void 0 : _a.object.getBracketsInRange(range, onlyColorizedBrackets)) || CallbackIterable.empty;\n    }\n    findMatchingBracketUp(_bracket, _position, maxDuration) {\n        const position = this.textModel.validatePosition(_position);\n        const languageId = this.textModel.getLanguageIdAtPosition(position.lineNumber, position.column);\n        if (this.canBuildAST) {\n            const closingBracketInfo = this.languageConfigurationService\n                .getLanguageConfiguration(languageId)\n                .bracketsNew.getClosingBracketInfo(_bracket);\n            if (!closingBracketInfo) {\n                return null;\n            }\n            const bracketPair = this.getBracketPairsInRange(Range.fromPositions(_position, _position)).findLast((b) => closingBracketInfo.closes(b.openingBracketInfo));\n            if (bracketPair) {\n                return bracketPair.openingBracketRange;\n            }\n            return null;\n        }\n        else {\n            // Fallback to old bracket matching code:\n            const bracket = _bracket.toLowerCase();\n            const bracketsSupport = this.languageConfigurationService.getLanguageConfiguration(languageId).brackets;\n            if (!bracketsSupport) {\n                return null;\n            }\n            const data = bracketsSupport.textIsBracket[bracket];\n            if (!data) {\n                return null;\n            }\n            return stripBracketSearchCanceled(this._findMatchingBracketUp(data, position, createTimeBasedContinueBracketSearchPredicate(maxDuration)));\n        }\n    }\n    matchBracket(position, maxDuration) {\n        if (this.canBuildAST) {\n            const bracketPair = this.getBracketPairsInRange(Range.fromPositions(position, position)).filter((item) => item.closingBracketRange !== undefined &&\n                (item.openingBracketRange.containsPosition(position) ||\n                    item.closingBracketRange.containsPosition(position))).findLastMaxBy(compareBy((item) => item.openingBracketRange.containsPosition(position)\n                ? item.openingBracketRange\n                : item.closingBracketRange, Range.compareRangesUsingStarts));\n            if (bracketPair) {\n                return [bracketPair.openingBracketRange, bracketPair.closingBracketRange];\n            }\n            return null;\n        }\n        else {\n            // Fallback to old bracket matching code:\n            const continueSearchPredicate = createTimeBasedContinueBracketSearchPredicate(maxDuration);\n            return this._matchBracket(this.textModel.validatePosition(position), continueSearchPredicate);\n        }\n    }\n    _establishBracketSearchOffsets(position, lineTokens, modeBrackets, tokenIndex) {\n        const tokenCount = lineTokens.getCount();\n        const currentLanguageId = lineTokens.getLanguageId(tokenIndex);\n        // limit search to not go before `maxBracketLength`\n        let searchStartOffset = Math.max(0, position.column - 1 - modeBrackets.maxBracketLength);\n        for (let i = tokenIndex - 1; i >= 0; i--) {\n            const tokenEndOffset = lineTokens.getEndOffset(i);\n            if (tokenEndOffset <= searchStartOffset) {\n                break;\n            }\n            if (ignoreBracketsInToken(lineTokens.getStandardTokenType(i)) || lineTokens.getLanguageId(i) !== currentLanguageId) {\n                searchStartOffset = tokenEndOffset;\n                break;\n            }\n        }\n        // limit search to not go after `maxBracketLength`\n        let searchEndOffset = Math.min(lineTokens.getLineContent().length, position.column - 1 + modeBrackets.maxBracketLength);\n        for (let i = tokenIndex + 1; i < tokenCount; i++) {\n            const tokenStartOffset = lineTokens.getStartOffset(i);\n            if (tokenStartOffset >= searchEndOffset) {\n                break;\n            }\n            if (ignoreBracketsInToken(lineTokens.getStandardTokenType(i)) || lineTokens.getLanguageId(i) !== currentLanguageId) {\n                searchEndOffset = tokenStartOffset;\n                break;\n            }\n        }\n        return { searchStartOffset, searchEndOffset };\n    }\n    _matchBracket(position, continueSearchPredicate) {\n        const lineNumber = position.lineNumber;\n        const lineTokens = this.textModel.tokenization.getLineTokens(lineNumber);\n        const lineText = this.textModel.getLineContent(lineNumber);\n        const tokenIndex = lineTokens.findTokenIndexAtOffset(position.column - 1);\n        if (tokenIndex < 0) {\n            return null;\n        }\n        const currentModeBrackets = this.languageConfigurationService.getLanguageConfiguration(lineTokens.getLanguageId(tokenIndex)).brackets;\n        // check that the token is not to be ignored\n        if (currentModeBrackets && !ignoreBracketsInToken(lineTokens.getStandardTokenType(tokenIndex))) {\n            let { searchStartOffset, searchEndOffset } = this._establishBracketSearchOffsets(position, lineTokens, currentModeBrackets, tokenIndex);\n            // it might be the case that [currentTokenStart -> currentTokenEnd] contains multiple brackets\n            // `bestResult` will contain the most right-side result\n            let bestResult = null;\n            while (true) {\n                const foundBracket = BracketsUtils.findNextBracketInRange(currentModeBrackets.forwardRegex, lineNumber, lineText, searchStartOffset, searchEndOffset);\n                if (!foundBracket) {\n                    // there are no more brackets in this text\n                    break;\n                }\n                // check that we didn't hit a bracket too far away from position\n                if (foundBracket.startColumn <= position.column && position.column <= foundBracket.endColumn) {\n                    const foundBracketText = lineText.substring(foundBracket.startColumn - 1, foundBracket.endColumn - 1).toLowerCase();\n                    const r = this._matchFoundBracket(foundBracket, currentModeBrackets.textIsBracket[foundBracketText], currentModeBrackets.textIsOpenBracket[foundBracketText], continueSearchPredicate);\n                    if (r) {\n                        if (r instanceof BracketSearchCanceled) {\n                            return null;\n                        }\n                        bestResult = r;\n                    }\n                }\n                searchStartOffset = foundBracket.endColumn - 1;\n            }\n            if (bestResult) {\n                return bestResult;\n            }\n        }\n        // If position is in between two tokens, try also looking in the previous token\n        if (tokenIndex > 0 && lineTokens.getStartOffset(tokenIndex) === position.column - 1) {\n            const prevTokenIndex = tokenIndex - 1;\n            const prevModeBrackets = this.languageConfigurationService.getLanguageConfiguration(lineTokens.getLanguageId(prevTokenIndex)).brackets;\n            // check that previous token is not to be ignored\n            if (prevModeBrackets && !ignoreBracketsInToken(lineTokens.getStandardTokenType(prevTokenIndex))) {\n                const { searchStartOffset, searchEndOffset } = this._establishBracketSearchOffsets(position, lineTokens, prevModeBrackets, prevTokenIndex);\n                const foundBracket = BracketsUtils.findPrevBracketInRange(prevModeBrackets.reversedRegex, lineNumber, lineText, searchStartOffset, searchEndOffset);\n                // check that we didn't hit a bracket too far away from position\n                if (foundBracket && foundBracket.startColumn <= position.column && position.column <= foundBracket.endColumn) {\n                    const foundBracketText = lineText.substring(foundBracket.startColumn - 1, foundBracket.endColumn - 1).toLowerCase();\n                    const r = this._matchFoundBracket(foundBracket, prevModeBrackets.textIsBracket[foundBracketText], prevModeBrackets.textIsOpenBracket[foundBracketText], continueSearchPredicate);\n                    if (r) {\n                        if (r instanceof BracketSearchCanceled) {\n                            return null;\n                        }\n                        return r;\n                    }\n                }\n            }\n        }\n        return null;\n    }\n    _matchFoundBracket(foundBracket, data, isOpen, continueSearchPredicate) {\n        if (!data) {\n            return null;\n        }\n        const matched = (isOpen\n            ? this._findMatchingBracketDown(data, foundBracket.getEndPosition(), continueSearchPredicate)\n            : this._findMatchingBracketUp(data, foundBracket.getStartPosition(), continueSearchPredicate));\n        if (!matched) {\n            return null;\n        }\n        if (matched instanceof BracketSearchCanceled) {\n            return matched;\n        }\n        return [foundBracket, matched];\n    }\n    _findMatchingBracketUp(bracket, position, continueSearchPredicate) {\n        // console.log('_findMatchingBracketUp: ', 'bracket: ', JSON.stringify(bracket), 'startPosition: ', String(position));\n        const languageId = bracket.languageId;\n        const reversedBracketRegex = bracket.reversedRegex;\n        let count = -1;\n        let totalCallCount = 0;\n        const searchPrevMatchingBracketInRange = (lineNumber, lineText, searchStartOffset, searchEndOffset) => {\n            while (true) {\n                if (continueSearchPredicate && (++totalCallCount) % 100 === 0 && !continueSearchPredicate()) {\n                    return BracketSearchCanceled.INSTANCE;\n                }\n                const r = BracketsUtils.findPrevBracketInRange(reversedBracketRegex, lineNumber, lineText, searchStartOffset, searchEndOffset);\n                if (!r) {\n                    break;\n                }\n                const hitText = lineText.substring(r.startColumn - 1, r.endColumn - 1).toLowerCase();\n                if (bracket.isOpen(hitText)) {\n                    count++;\n                }\n                else if (bracket.isClose(hitText)) {\n                    count--;\n                }\n                if (count === 0) {\n                    return r;\n                }\n                searchEndOffset = r.startColumn - 1;\n            }\n            return null;\n        };\n        for (let lineNumber = position.lineNumber; lineNumber >= 1; lineNumber--) {\n            const lineTokens = this.textModel.tokenization.getLineTokens(lineNumber);\n            const tokenCount = lineTokens.getCount();\n            const lineText = this.textModel.getLineContent(lineNumber);\n            let tokenIndex = tokenCount - 1;\n            let searchStartOffset = lineText.length;\n            let searchEndOffset = lineText.length;\n            if (lineNumber === position.lineNumber) {\n                tokenIndex = lineTokens.findTokenIndexAtOffset(position.column - 1);\n                searchStartOffset = position.column - 1;\n                searchEndOffset = position.column - 1;\n            }\n            let prevSearchInToken = true;\n            for (; tokenIndex >= 0; tokenIndex--) {\n                const searchInToken = (lineTokens.getLanguageId(tokenIndex) === languageId && !ignoreBracketsInToken(lineTokens.getStandardTokenType(tokenIndex)));\n                if (searchInToken) {\n                    // this token should be searched\n                    if (prevSearchInToken) {\n                        // the previous token should be searched, simply extend searchStartOffset\n                        searchStartOffset = lineTokens.getStartOffset(tokenIndex);\n                    }\n                    else {\n                        // the previous token should not be searched\n                        searchStartOffset = lineTokens.getStartOffset(tokenIndex);\n                        searchEndOffset = lineTokens.getEndOffset(tokenIndex);\n                    }\n                }\n                else {\n                    // this token should not be searched\n                    if (prevSearchInToken && searchStartOffset !== searchEndOffset) {\n                        const r = searchPrevMatchingBracketInRange(lineNumber, lineText, searchStartOffset, searchEndOffset);\n                        if (r) {\n                            return r;\n                        }\n                    }\n                }\n                prevSearchInToken = searchInToken;\n            }\n            if (prevSearchInToken && searchStartOffset !== searchEndOffset) {\n                const r = searchPrevMatchingBracketInRange(lineNumber, lineText, searchStartOffset, searchEndOffset);\n                if (r) {\n                    return r;\n                }\n            }\n        }\n        return null;\n    }\n    _findMatchingBracketDown(bracket, position, continueSearchPredicate) {\n        // console.log('_findMatchingBracketDown: ', 'bracket: ', JSON.stringify(bracket), 'startPosition: ', String(position));\n        const languageId = bracket.languageId;\n        const bracketRegex = bracket.forwardRegex;\n        let count = 1;\n        let totalCallCount = 0;\n        const searchNextMatchingBracketInRange = (lineNumber, lineText, searchStartOffset, searchEndOffset) => {\n            while (true) {\n                if (continueSearchPredicate && (++totalCallCount) % 100 === 0 && !continueSearchPredicate()) {\n                    return BracketSearchCanceled.INSTANCE;\n                }\n                const r = BracketsUtils.findNextBracketInRange(bracketRegex, lineNumber, lineText, searchStartOffset, searchEndOffset);\n                if (!r) {\n                    break;\n                }\n                const hitText = lineText.substring(r.startColumn - 1, r.endColumn - 1).toLowerCase();\n                if (bracket.isOpen(hitText)) {\n                    count++;\n                }\n                else if (bracket.isClose(hitText)) {\n                    count--;\n                }\n                if (count === 0) {\n                    return r;\n                }\n                searchStartOffset = r.endColumn - 1;\n            }\n            return null;\n        };\n        const lineCount = this.textModel.getLineCount();\n        for (let lineNumber = position.lineNumber; lineNumber <= lineCount; lineNumber++) {\n            const lineTokens = this.textModel.tokenization.getLineTokens(lineNumber);\n            const tokenCount = lineTokens.getCount();\n            const lineText = this.textModel.getLineContent(lineNumber);\n            let tokenIndex = 0;\n            let searchStartOffset = 0;\n            let searchEndOffset = 0;\n            if (lineNumber === position.lineNumber) {\n                tokenIndex = lineTokens.findTokenIndexAtOffset(position.column - 1);\n                searchStartOffset = position.column - 1;\n                searchEndOffset = position.column - 1;\n            }\n            let prevSearchInToken = true;\n            for (; tokenIndex < tokenCount; tokenIndex++) {\n                const searchInToken = (lineTokens.getLanguageId(tokenIndex) === languageId && !ignoreBracketsInToken(lineTokens.getStandardTokenType(tokenIndex)));\n                if (searchInToken) {\n                    // this token should be searched\n                    if (prevSearchInToken) {\n                        // the previous token should be searched, simply extend searchEndOffset\n                        searchEndOffset = lineTokens.getEndOffset(tokenIndex);\n                    }\n                    else {\n                        // the previous token should not be searched\n                        searchStartOffset = lineTokens.getStartOffset(tokenIndex);\n                        searchEndOffset = lineTokens.getEndOffset(tokenIndex);\n                    }\n                }\n                else {\n                    // this token should not be searched\n                    if (prevSearchInToken && searchStartOffset !== searchEndOffset) {\n                        const r = searchNextMatchingBracketInRange(lineNumber, lineText, searchStartOffset, searchEndOffset);\n                        if (r) {\n                            return r;\n                        }\n                    }\n                }\n                prevSearchInToken = searchInToken;\n            }\n            if (prevSearchInToken && searchStartOffset !== searchEndOffset) {\n                const r = searchNextMatchingBracketInRange(lineNumber, lineText, searchStartOffset, searchEndOffset);\n                if (r) {\n                    return r;\n                }\n            }\n        }\n        return null;\n    }\n    findPrevBracket(_position) {\n        var _a;\n        const position = this.textModel.validatePosition(_position);\n        if (this.canBuildAST) {\n            this.bracketsRequested = true;\n            this.updateBracketPairsTree();\n            return ((_a = this.bracketPairsTree.value) === null || _a === void 0 ? void 0 : _a.object.getFirstBracketBefore(position)) || null;\n        }\n        let languageId = null;\n        let modeBrackets = null;\n        let bracketConfig = null;\n        for (let lineNumber = position.lineNumber; lineNumber >= 1; lineNumber--) {\n            const lineTokens = this.textModel.tokenization.getLineTokens(lineNumber);\n            const tokenCount = lineTokens.getCount();\n            const lineText = this.textModel.getLineContent(lineNumber);\n            let tokenIndex = tokenCount - 1;\n            let searchStartOffset = lineText.length;\n            let searchEndOffset = lineText.length;\n            if (lineNumber === position.lineNumber) {\n                tokenIndex = lineTokens.findTokenIndexAtOffset(position.column - 1);\n                searchStartOffset = position.column - 1;\n                searchEndOffset = position.column - 1;\n                const tokenLanguageId = lineTokens.getLanguageId(tokenIndex);\n                if (languageId !== tokenLanguageId) {\n                    languageId = tokenLanguageId;\n                    modeBrackets = this.languageConfigurationService.getLanguageConfiguration(languageId).brackets;\n                    bracketConfig = this.languageConfigurationService.getLanguageConfiguration(languageId).bracketsNew;\n                }\n            }\n            let prevSearchInToken = true;\n            for (; tokenIndex >= 0; tokenIndex--) {\n                const tokenLanguageId = lineTokens.getLanguageId(tokenIndex);\n                if (languageId !== tokenLanguageId) {\n                    // language id change!\n                    if (modeBrackets && bracketConfig && prevSearchInToken && searchStartOffset !== searchEndOffset) {\n                        const r = BracketsUtils.findPrevBracketInRange(modeBrackets.reversedRegex, lineNumber, lineText, searchStartOffset, searchEndOffset);\n                        if (r) {\n                            return this._toFoundBracket(bracketConfig, r);\n                        }\n                        prevSearchInToken = false;\n                    }\n                    languageId = tokenLanguageId;\n                    modeBrackets = this.languageConfigurationService.getLanguageConfiguration(languageId).brackets;\n                    bracketConfig = this.languageConfigurationService.getLanguageConfiguration(languageId).bracketsNew;\n                }\n                const searchInToken = (!!modeBrackets && !ignoreBracketsInToken(lineTokens.getStandardTokenType(tokenIndex)));\n                if (searchInToken) {\n                    // this token should be searched\n                    if (prevSearchInToken) {\n                        // the previous token should be searched, simply extend searchStartOffset\n                        searchStartOffset = lineTokens.getStartOffset(tokenIndex);\n                    }\n                    else {\n                        // the previous token should not be searched\n                        searchStartOffset = lineTokens.getStartOffset(tokenIndex);\n                        searchEndOffset = lineTokens.getEndOffset(tokenIndex);\n                    }\n                }\n                else {\n                    // this token should not be searched\n                    if (bracketConfig && modeBrackets && prevSearchInToken && searchStartOffset !== searchEndOffset) {\n                        const r = BracketsUtils.findPrevBracketInRange(modeBrackets.reversedRegex, lineNumber, lineText, searchStartOffset, searchEndOffset);\n                        if (r) {\n                            return this._toFoundBracket(bracketConfig, r);\n                        }\n                    }\n                }\n                prevSearchInToken = searchInToken;\n            }\n            if (bracketConfig && modeBrackets && prevSearchInToken && searchStartOffset !== searchEndOffset) {\n                const r = BracketsUtils.findPrevBracketInRange(modeBrackets.reversedRegex, lineNumber, lineText, searchStartOffset, searchEndOffset);\n                if (r) {\n                    return this._toFoundBracket(bracketConfig, r);\n                }\n            }\n        }\n        return null;\n    }\n    findNextBracket(_position) {\n        var _a;\n        const position = this.textModel.validatePosition(_position);\n        if (this.canBuildAST) {\n            this.bracketsRequested = true;\n            this.updateBracketPairsTree();\n            return ((_a = this.bracketPairsTree.value) === null || _a === void 0 ? void 0 : _a.object.getFirstBracketAfter(position)) || null;\n        }\n        const lineCount = this.textModel.getLineCount();\n        let languageId = null;\n        let modeBrackets = null;\n        let bracketConfig = null;\n        for (let lineNumber = position.lineNumber; lineNumber <= lineCount; lineNumber++) {\n            const lineTokens = this.textModel.tokenization.getLineTokens(lineNumber);\n            const tokenCount = lineTokens.getCount();\n            const lineText = this.textModel.getLineContent(lineNumber);\n            let tokenIndex = 0;\n            let searchStartOffset = 0;\n            let searchEndOffset = 0;\n            if (lineNumber === position.lineNumber) {\n                tokenIndex = lineTokens.findTokenIndexAtOffset(position.column - 1);\n                searchStartOffset = position.column - 1;\n                searchEndOffset = position.column - 1;\n                const tokenLanguageId = lineTokens.getLanguageId(tokenIndex);\n                if (languageId !== tokenLanguageId) {\n                    languageId = tokenLanguageId;\n                    modeBrackets = this.languageConfigurationService.getLanguageConfiguration(languageId).brackets;\n                    bracketConfig = this.languageConfigurationService.getLanguageConfiguration(languageId).bracketsNew;\n                }\n            }\n            let prevSearchInToken = true;\n            for (; tokenIndex < tokenCount; tokenIndex++) {\n                const tokenLanguageId = lineTokens.getLanguageId(tokenIndex);\n                if (languageId !== tokenLanguageId) {\n                    // language id change!\n                    if (bracketConfig && modeBrackets && prevSearchInToken && searchStartOffset !== searchEndOffset) {\n                        const r = BracketsUtils.findNextBracketInRange(modeBrackets.forwardRegex, lineNumber, lineText, searchStartOffset, searchEndOffset);\n                        if (r) {\n                            return this._toFoundBracket(bracketConfig, r);\n                        }\n                        prevSearchInToken = false;\n                    }\n                    languageId = tokenLanguageId;\n                    modeBrackets = this.languageConfigurationService.getLanguageConfiguration(languageId).brackets;\n                    bracketConfig = this.languageConfigurationService.getLanguageConfiguration(languageId).bracketsNew;\n                }\n                const searchInToken = (!!modeBrackets && !ignoreBracketsInToken(lineTokens.getStandardTokenType(tokenIndex)));\n                if (searchInToken) {\n                    // this token should be searched\n                    if (prevSearchInToken) {\n                        // the previous token should be searched, simply extend searchEndOffset\n                        searchEndOffset = lineTokens.getEndOffset(tokenIndex);\n                    }\n                    else {\n                        // the previous token should not be searched\n                        searchStartOffset = lineTokens.getStartOffset(tokenIndex);\n                        searchEndOffset = lineTokens.getEndOffset(tokenIndex);\n                    }\n                }\n                else {\n                    // this token should not be searched\n                    if (bracketConfig && modeBrackets && prevSearchInToken && searchStartOffset !== searchEndOffset) {\n                        const r = BracketsUtils.findNextBracketInRange(modeBrackets.forwardRegex, lineNumber, lineText, searchStartOffset, searchEndOffset);\n                        if (r) {\n                            return this._toFoundBracket(bracketConfig, r);\n                        }\n                    }\n                }\n                prevSearchInToken = searchInToken;\n            }\n            if (bracketConfig && modeBrackets && prevSearchInToken && searchStartOffset !== searchEndOffset) {\n                const r = BracketsUtils.findNextBracketInRange(modeBrackets.forwardRegex, lineNumber, lineText, searchStartOffset, searchEndOffset);\n                if (r) {\n                    return this._toFoundBracket(bracketConfig, r);\n                }\n            }\n        }\n        return null;\n    }\n    findEnclosingBrackets(_position, maxDuration) {\n        const position = this.textModel.validatePosition(_position);\n        if (this.canBuildAST) {\n            const range = Range.fromPositions(position);\n            const bracketPair = this.getBracketPairsInRange(Range.fromPositions(position, position)).findLast((item) => item.closingBracketRange !== undefined && item.range.strictContainsRange(range));\n            if (bracketPair) {\n                return [bracketPair.openingBracketRange, bracketPair.closingBracketRange];\n            }\n            return null;\n        }\n        const continueSearchPredicate = createTimeBasedContinueBracketSearchPredicate(maxDuration);\n        const lineCount = this.textModel.getLineCount();\n        const savedCounts = new Map();\n        let counts = [];\n        const resetCounts = (languageId, modeBrackets) => {\n            if (!savedCounts.has(languageId)) {\n                const tmp = [];\n                for (let i = 0, len = modeBrackets ? modeBrackets.brackets.length : 0; i < len; i++) {\n                    tmp[i] = 0;\n                }\n                savedCounts.set(languageId, tmp);\n            }\n            counts = savedCounts.get(languageId);\n        };\n        let totalCallCount = 0;\n        const searchInRange = (modeBrackets, lineNumber, lineText, searchStartOffset, searchEndOffset) => {\n            while (true) {\n                if (continueSearchPredicate && (++totalCallCount) % 100 === 0 && !continueSearchPredicate()) {\n                    return BracketSearchCanceled.INSTANCE;\n                }\n                const r = BracketsUtils.findNextBracketInRange(modeBrackets.forwardRegex, lineNumber, lineText, searchStartOffset, searchEndOffset);\n                if (!r) {\n                    break;\n                }\n                const hitText = lineText.substring(r.startColumn - 1, r.endColumn - 1).toLowerCase();\n                const bracket = modeBrackets.textIsBracket[hitText];\n                if (bracket) {\n                    if (bracket.isOpen(hitText)) {\n                        counts[bracket.index]++;\n                    }\n                    else if (bracket.isClose(hitText)) {\n                        counts[bracket.index]--;\n                    }\n                    if (counts[bracket.index] === -1) {\n                        return this._matchFoundBracket(r, bracket, false, continueSearchPredicate);\n                    }\n                }\n                searchStartOffset = r.endColumn - 1;\n            }\n            return null;\n        };\n        let languageId = null;\n        let modeBrackets = null;\n        for (let lineNumber = position.lineNumber; lineNumber <= lineCount; lineNumber++) {\n            const lineTokens = this.textModel.tokenization.getLineTokens(lineNumber);\n            const tokenCount = lineTokens.getCount();\n            const lineText = this.textModel.getLineContent(lineNumber);\n            let tokenIndex = 0;\n            let searchStartOffset = 0;\n            let searchEndOffset = 0;\n            if (lineNumber === position.lineNumber) {\n                tokenIndex = lineTokens.findTokenIndexAtOffset(position.column - 1);\n                searchStartOffset = position.column - 1;\n                searchEndOffset = position.column - 1;\n                const tokenLanguageId = lineTokens.getLanguageId(tokenIndex);\n                if (languageId !== tokenLanguageId) {\n                    languageId = tokenLanguageId;\n                    modeBrackets = this.languageConfigurationService.getLanguageConfiguration(languageId).brackets;\n                    resetCounts(languageId, modeBrackets);\n                }\n            }\n            let prevSearchInToken = true;\n            for (; tokenIndex < tokenCount; tokenIndex++) {\n                const tokenLanguageId = lineTokens.getLanguageId(tokenIndex);\n                if (languageId !== tokenLanguageId) {\n                    // language id change!\n                    if (modeBrackets && prevSearchInToken && searchStartOffset !== searchEndOffset) {\n                        const r = searchInRange(modeBrackets, lineNumber, lineText, searchStartOffset, searchEndOffset);\n                        if (r) {\n                            return stripBracketSearchCanceled(r);\n                        }\n                        prevSearchInToken = false;\n                    }\n                    languageId = tokenLanguageId;\n                    modeBrackets = this.languageConfigurationService.getLanguageConfiguration(languageId).brackets;\n                    resetCounts(languageId, modeBrackets);\n                }\n                const searchInToken = (!!modeBrackets && !ignoreBracketsInToken(lineTokens.getStandardTokenType(tokenIndex)));\n                if (searchInToken) {\n                    // this token should be searched\n                    if (prevSearchInToken) {\n                        // the previous token should be searched, simply extend searchEndOffset\n                        searchEndOffset = lineTokens.getEndOffset(tokenIndex);\n                    }\n                    else {\n                        // the previous token should not be searched\n                        searchStartOffset = lineTokens.getStartOffset(tokenIndex);\n                        searchEndOffset = lineTokens.getEndOffset(tokenIndex);\n                    }\n                }\n                else {\n                    // this token should not be searched\n                    if (modeBrackets && prevSearchInToken && searchStartOffset !== searchEndOffset) {\n                        const r = searchInRange(modeBrackets, lineNumber, lineText, searchStartOffset, searchEndOffset);\n                        if (r) {\n                            return stripBracketSearchCanceled(r);\n                        }\n                    }\n                }\n                prevSearchInToken = searchInToken;\n            }\n            if (modeBrackets && prevSearchInToken && searchStartOffset !== searchEndOffset) {\n                const r = searchInRange(modeBrackets, lineNumber, lineText, searchStartOffset, searchEndOffset);\n                if (r) {\n                    return stripBracketSearchCanceled(r);\n                }\n            }\n        }\n        return null;\n    }\n    _toFoundBracket(bracketConfig, r) {\n        if (!r) {\n            return null;\n        }\n        let text = this.textModel.getValueInRange(r);\n        text = text.toLowerCase();\n        const bracketInfo = bracketConfig.getBracketInfo(text);\n        if (!bracketInfo) {\n            return null;\n        }\n        return {\n            range: r,\n            bracketInfo\n        };\n    }\n}\nfunction createDisposableRef(object, disposable) {\n    return {\n        object,\n        dispose: () => disposable === null || disposable === void 0 ? void 0 : disposable.dispose(),\n    };\n}\nfunction createTimeBasedContinueBracketSearchPredicate(maxDuration) {\n    if (typeof maxDuration === 'undefined') {\n        return () => true;\n    }\n    else {\n        const startTime = Date.now();\n        return () => {\n            return (Date.now() - startTime <= maxDuration);\n        };\n    }\n}\nclass BracketSearchCanceled {\n    constructor() {\n        this._searchCanceledBrand = undefined;\n    }\n}\nBracketSearchCanceled.INSTANCE = new BracketSearchCanceled();\nfunction stripBracketSearchCanceled(result) {\n    if (result instanceof BracketSearchCanceled) {\n        return null;\n    }\n    return result;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { BugIndicatingError } from '../../../../../base/common/errors.js';\nimport { CursorColumns } from '../../../core/cursorColumns.js';\nimport { lengthAdd, lengthGetLineCount, lengthToObj, lengthZero } from './length.js';\nimport { SmallImmutableSet } from './smallImmutableSet.js';\n/**\n * The base implementation for all AST nodes.\n*/\nclass BaseAstNode {\n    /**\n     * The length of the entire node, which should equal the sum of lengths of all children.\n    */\n    get length() {\n        return this._length;\n    }\n    constructor(length) {\n        this._length = length;\n    }\n}\n/**\n * Represents a bracket pair including its child (e.g. `{ ... }`).\n * Might be unclosed.\n * Immutable, if all children are immutable.\n*/\nexport class PairAstNode extends BaseAstNode {\n    static create(openingBracket, child, closingBracket) {\n        let length = openingBracket.length;\n        if (child) {\n            length = lengthAdd(length, child.length);\n        }\n        if (closingBracket) {\n            length = lengthAdd(length, closingBracket.length);\n        }\n        return new PairAstNode(length, openingBracket, child, closingBracket, child ? child.missingOpeningBracketIds : SmallImmutableSet.getEmpty());\n    }\n    get kind() {\n        return 2 /* AstNodeKind.Pair */;\n    }\n    get listHeight() {\n        return 0;\n    }\n    get childrenLength() {\n        return 3;\n    }\n    getChild(idx) {\n        switch (idx) {\n            case 0: return this.openingBracket;\n            case 1: return this.child;\n            case 2: return this.closingBracket;\n        }\n        throw new Error('Invalid child index');\n    }\n    /**\n     * Avoid using this property, it allocates an array!\n    */\n    get children() {\n        const result = [];\n        result.push(this.openingBracket);\n        if (this.child) {\n            result.push(this.child);\n        }\n        if (this.closingBracket) {\n            result.push(this.closingBracket);\n        }\n        return result;\n    }\n    constructor(length, openingBracket, child, closingBracket, missingOpeningBracketIds) {\n        super(length);\n        this.openingBracket = openingBracket;\n        this.child = child;\n        this.closingBracket = closingBracket;\n        this.missingOpeningBracketIds = missingOpeningBracketIds;\n    }\n    canBeReused(openBracketIds) {\n        if (this.closingBracket === null) {\n            // Unclosed pair ast nodes only\n            // end at the end of the document\n            // or when a parent node is closed.\n            // This could be improved:\n            // Only return false if some next token is neither \"undefined\" nor a bracket that closes a parent.\n            return false;\n        }\n        if (openBracketIds.intersects(this.missingOpeningBracketIds)) {\n            return false;\n        }\n        return true;\n    }\n    deepClone() {\n        return new PairAstNode(this.length, this.openingBracket.deepClone(), this.child && this.child.deepClone(), this.closingBracket && this.closingBracket.deepClone(), this.missingOpeningBracketIds);\n    }\n    computeMinIndentation(offset, textModel) {\n        return this.child ? this.child.computeMinIndentation(lengthAdd(offset, this.openingBracket.length), textModel) : Number.MAX_SAFE_INTEGER;\n    }\n}\nexport class ListAstNode extends BaseAstNode {\n    /**\n     * This method uses more memory-efficient list nodes that can only store 2 or 3 children.\n    */\n    static create23(item1, item2, item3, immutable = false) {\n        let length = item1.length;\n        let missingBracketIds = item1.missingOpeningBracketIds;\n        if (item1.listHeight !== item2.listHeight) {\n            throw new Error('Invalid list heights');\n        }\n        length = lengthAdd(length, item2.length);\n        missingBracketIds = missingBracketIds.merge(item2.missingOpeningBracketIds);\n        if (item3) {\n            if (item1.listHeight !== item3.listHeight) {\n                throw new Error('Invalid list heights');\n            }\n            length = lengthAdd(length, item3.length);\n            missingBracketIds = missingBracketIds.merge(item3.missingOpeningBracketIds);\n        }\n        return immutable\n            ? new Immutable23ListAstNode(length, item1.listHeight + 1, item1, item2, item3, missingBracketIds)\n            : new TwoThreeListAstNode(length, item1.listHeight + 1, item1, item2, item3, missingBracketIds);\n    }\n    static getEmpty() {\n        return new ImmutableArrayListAstNode(lengthZero, 0, [], SmallImmutableSet.getEmpty());\n    }\n    get kind() {\n        return 4 /* AstNodeKind.List */;\n    }\n    get missingOpeningBracketIds() {\n        return this._missingOpeningBracketIds;\n    }\n    /**\n     * Use ListAstNode.create.\n    */\n    constructor(length, listHeight, _missingOpeningBracketIds) {\n        super(length);\n        this.listHeight = listHeight;\n        this._missingOpeningBracketIds = _missingOpeningBracketIds;\n        this.cachedMinIndentation = -1;\n    }\n    throwIfImmutable() {\n        // NOOP\n    }\n    makeLastElementMutable() {\n        this.throwIfImmutable();\n        const childCount = this.childrenLength;\n        if (childCount === 0) {\n            return undefined;\n        }\n        const lastChild = this.getChild(childCount - 1);\n        const mutable = lastChild.kind === 4 /* AstNodeKind.List */ ? lastChild.toMutable() : lastChild;\n        if (lastChild !== mutable) {\n            this.setChild(childCount - 1, mutable);\n        }\n        return mutable;\n    }\n    makeFirstElementMutable() {\n        this.throwIfImmutable();\n        const childCount = this.childrenLength;\n        if (childCount === 0) {\n            return undefined;\n        }\n        const firstChild = this.getChild(0);\n        const mutable = firstChild.kind === 4 /* AstNodeKind.List */ ? firstChild.toMutable() : firstChild;\n        if (firstChild !== mutable) {\n            this.setChild(0, mutable);\n        }\n        return mutable;\n    }\n    canBeReused(openBracketIds) {\n        if (openBracketIds.intersects(this.missingOpeningBracketIds)) {\n            return false;\n        }\n        if (this.childrenLength === 0) {\n            // Don't reuse empty lists.\n            return false;\n        }\n        let lastChild = this;\n        while (lastChild.kind === 4 /* AstNodeKind.List */) {\n            const lastLength = lastChild.childrenLength;\n            if (lastLength === 0) {\n                // Empty lists should never be contained in other lists.\n                throw new BugIndicatingError();\n            }\n            lastChild = lastChild.getChild(lastLength - 1);\n        }\n        return lastChild.canBeReused(openBracketIds);\n    }\n    handleChildrenChanged() {\n        this.throwIfImmutable();\n        const count = this.childrenLength;\n        let length = this.getChild(0).length;\n        let unopenedBrackets = this.getChild(0).missingOpeningBracketIds;\n        for (let i = 1; i < count; i++) {\n            const child = this.getChild(i);\n            length = lengthAdd(length, child.length);\n            unopenedBrackets = unopenedBrackets.merge(child.missingOpeningBracketIds);\n        }\n        this._length = length;\n        this._missingOpeningBracketIds = unopenedBrackets;\n        this.cachedMinIndentation = -1;\n    }\n    computeMinIndentation(offset, textModel) {\n        if (this.cachedMinIndentation !== -1) {\n            return this.cachedMinIndentation;\n        }\n        let minIndentation = Number.MAX_SAFE_INTEGER;\n        let childOffset = offset;\n        for (let i = 0; i < this.childrenLength; i++) {\n            const child = this.getChild(i);\n            if (child) {\n                minIndentation = Math.min(minIndentation, child.computeMinIndentation(childOffset, textModel));\n                childOffset = lengthAdd(childOffset, child.length);\n            }\n        }\n        this.cachedMinIndentation = minIndentation;\n        return minIndentation;\n    }\n}\nclass TwoThreeListAstNode extends ListAstNode {\n    get childrenLength() {\n        return this._item3 !== null ? 3 : 2;\n    }\n    getChild(idx) {\n        switch (idx) {\n            case 0: return this._item1;\n            case 1: return this._item2;\n            case 2: return this._item3;\n        }\n        throw new Error('Invalid child index');\n    }\n    setChild(idx, node) {\n        switch (idx) {\n            case 0:\n                this._item1 = node;\n                return;\n            case 1:\n                this._item2 = node;\n                return;\n            case 2:\n                this._item3 = node;\n                return;\n        }\n        throw new Error('Invalid child index');\n    }\n    get children() {\n        return this._item3 ? [this._item1, this._item2, this._item3] : [this._item1, this._item2];\n    }\n    get item1() {\n        return this._item1;\n    }\n    get item2() {\n        return this._item2;\n    }\n    get item3() {\n        return this._item3;\n    }\n    constructor(length, listHeight, _item1, _item2, _item3, missingOpeningBracketIds) {\n        super(length, listHeight, missingOpeningBracketIds);\n        this._item1 = _item1;\n        this._item2 = _item2;\n        this._item3 = _item3;\n    }\n    deepClone() {\n        return new TwoThreeListAstNode(this.length, this.listHeight, this._item1.deepClone(), this._item2.deepClone(), this._item3 ? this._item3.deepClone() : null, this.missingOpeningBracketIds);\n    }\n    appendChildOfSameHeight(node) {\n        if (this._item3) {\n            throw new Error('Cannot append to a full (2,3) tree node');\n        }\n        this.throwIfImmutable();\n        this._item3 = node;\n        this.handleChildrenChanged();\n    }\n    unappendChild() {\n        if (!this._item3) {\n            throw new Error('Cannot remove from a non-full (2,3) tree node');\n        }\n        this.throwIfImmutable();\n        const result = this._item3;\n        this._item3 = null;\n        this.handleChildrenChanged();\n        return result;\n    }\n    prependChildOfSameHeight(node) {\n        if (this._item3) {\n            throw new Error('Cannot prepend to a full (2,3) tree node');\n        }\n        this.throwIfImmutable();\n        this._item3 = this._item2;\n        this._item2 = this._item1;\n        this._item1 = node;\n        this.handleChildrenChanged();\n    }\n    unprependChild() {\n        if (!this._item3) {\n            throw new Error('Cannot remove from a non-full (2,3) tree node');\n        }\n        this.throwIfImmutable();\n        const result = this._item1;\n        this._item1 = this._item2;\n        this._item2 = this._item3;\n        this._item3 = null;\n        this.handleChildrenChanged();\n        return result;\n    }\n    toMutable() {\n        return this;\n    }\n}\n/**\n * Immutable, if all children are immutable.\n*/\nclass Immutable23ListAstNode extends TwoThreeListAstNode {\n    toMutable() {\n        return new TwoThreeListAstNode(this.length, this.listHeight, this.item1, this.item2, this.item3, this.missingOpeningBracketIds);\n    }\n    throwIfImmutable() {\n        throw new Error('this instance is immutable');\n    }\n}\n/**\n * For debugging.\n*/\nclass ArrayListAstNode extends ListAstNode {\n    get childrenLength() {\n        return this._children.length;\n    }\n    getChild(idx) {\n        return this._children[idx];\n    }\n    setChild(idx, child) {\n        this._children[idx] = child;\n    }\n    get children() {\n        return this._children;\n    }\n    constructor(length, listHeight, _children, missingOpeningBracketIds) {\n        super(length, listHeight, missingOpeningBracketIds);\n        this._children = _children;\n    }\n    deepClone() {\n        const children = new Array(this._children.length);\n        for (let i = 0; i < this._children.length; i++) {\n            children[i] = this._children[i].deepClone();\n        }\n        return new ArrayListAstNode(this.length, this.listHeight, children, this.missingOpeningBracketIds);\n    }\n    appendChildOfSameHeight(node) {\n        this.throwIfImmutable();\n        this._children.push(node);\n        this.handleChildrenChanged();\n    }\n    unappendChild() {\n        this.throwIfImmutable();\n        const item = this._children.pop();\n        this.handleChildrenChanged();\n        return item;\n    }\n    prependChildOfSameHeight(node) {\n        this.throwIfImmutable();\n        this._children.unshift(node);\n        this.handleChildrenChanged();\n    }\n    unprependChild() {\n        this.throwIfImmutable();\n        const item = this._children.shift();\n        this.handleChildrenChanged();\n        return item;\n    }\n    toMutable() {\n        return this;\n    }\n}\n/**\n * Immutable, if all children are immutable.\n*/\nclass ImmutableArrayListAstNode extends ArrayListAstNode {\n    toMutable() {\n        return new ArrayListAstNode(this.length, this.listHeight, [...this.children], this.missingOpeningBracketIds);\n    }\n    throwIfImmutable() {\n        throw new Error('this instance is immutable');\n    }\n}\nconst emptyArray = [];\nclass ImmutableLeafAstNode extends BaseAstNode {\n    get listHeight() {\n        return 0;\n    }\n    get childrenLength() {\n        return 0;\n    }\n    getChild(idx) {\n        return null;\n    }\n    get children() {\n        return emptyArray;\n    }\n    deepClone() {\n        return this;\n    }\n}\nexport class TextAstNode extends ImmutableLeafAstNode {\n    get kind() {\n        return 0 /* AstNodeKind.Text */;\n    }\n    get missingOpeningBracketIds() {\n        return SmallImmutableSet.getEmpty();\n    }\n    canBeReused(_openedBracketIds) {\n        return true;\n    }\n    computeMinIndentation(offset, textModel) {\n        const start = lengthToObj(offset);\n        // Text ast nodes don't have partial indentation (ensured by the tokenizer).\n        // Thus, if this text node does not start at column 0, the first line cannot have any indentation at all.\n        const startLineNumber = (start.columnCount === 0 ? start.lineCount : start.lineCount + 1) + 1;\n        const endLineNumber = lengthGetLineCount(lengthAdd(offset, this.length)) + 1;\n        let result = Number.MAX_SAFE_INTEGER;\n        for (let lineNumber = startLineNumber; lineNumber <= endLineNumber; lineNumber++) {\n            const firstNonWsColumn = textModel.getLineFirstNonWhitespaceColumn(lineNumber);\n            const lineContent = textModel.getLineContent(lineNumber);\n            if (firstNonWsColumn === 0) {\n                continue;\n            }\n            const visibleColumn = CursorColumns.visibleColumnFromColumn(lineContent, firstNonWsColumn, textModel.getOptions().tabSize);\n            result = Math.min(result, visibleColumn);\n        }\n        return result;\n    }\n}\nexport class BracketAstNode extends ImmutableLeafAstNode {\n    static create(length, bracketInfo, bracketIds) {\n        const node = new BracketAstNode(length, bracketInfo, bracketIds);\n        return node;\n    }\n    get kind() {\n        return 1 /* AstNodeKind.Bracket */;\n    }\n    get missingOpeningBracketIds() {\n        return SmallImmutableSet.getEmpty();\n    }\n    constructor(length, bracketInfo, \n    /**\n     * In case of a opening bracket, this is the id of the opening bracket.\n     * In case of a closing bracket, this contains the ids of all opening brackets it can close.\n    */\n    bracketIds) {\n        super(length);\n        this.bracketInfo = bracketInfo;\n        this.bracketIds = bracketIds;\n    }\n    get text() {\n        return this.bracketInfo.bracketText;\n    }\n    get languageId() {\n        return this.bracketInfo.languageId;\n    }\n    canBeReused(_openedBracketIds) {\n        // These nodes could be reused,\n        // but not in a general way.\n        // Their parent may be reused.\n        return false;\n    }\n    computeMinIndentation(offset, textModel) {\n        return Number.MAX_SAFE_INTEGER;\n    }\n}\nexport class InvalidBracketAstNode extends ImmutableLeafAstNode {\n    get kind() {\n        return 3 /* AstNodeKind.UnexpectedClosingBracket */;\n    }\n    constructor(closingBrackets, length) {\n        super(length);\n        this.missingOpeningBracketIds = closingBrackets;\n    }\n    canBeReused(openedBracketIds) {\n        return !openedBracketIds.intersects(this.missingOpeningBracketIds);\n    }\n    computeMinIndentation(offset, textModel) {\n        return Number.MAX_SAFE_INTEGER;\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Range } from '../../../core/range.js';\nimport { lengthAdd, lengthDiffNonNegative, lengthLessThanEqual, lengthOfString, lengthToObj, positionToLength, toLength } from './length.js';\nexport class TextEditInfo {\n    static fromModelContentChanges(changes) {\n        // Must be sorted in ascending order\n        const edits = changes.map(c => {\n            const range = Range.lift(c.range);\n            return new TextEditInfo(positionToLength(range.getStartPosition()), positionToLength(range.getEndPosition()), lengthOfString(c.text));\n        }).reverse();\n        return edits;\n    }\n    constructor(startOffset, endOffset, newLength) {\n        this.startOffset = startOffset;\n        this.endOffset = endOffset;\n        this.newLength = newLength;\n    }\n    toString() {\n        return `[${lengthToObj(this.startOffset)}...${lengthToObj(this.endOffset)}) -> ${lengthToObj(this.newLength)}`;\n    }\n}\nexport class BeforeEditPositionMapper {\n    /**\n     * @param edits Must be sorted by offset in ascending order.\n    */\n    constructor(edits) {\n        this.nextEditIdx = 0;\n        this.deltaOldToNewLineCount = 0;\n        this.deltaOldToNewColumnCount = 0;\n        this.deltaLineIdxInOld = -1;\n        this.edits = edits.map(edit => TextEditInfoCache.from(edit));\n    }\n    /**\n     * @param offset Must be equal to or greater than the last offset this method has been called with.\n    */\n    getOffsetBeforeChange(offset) {\n        this.adjustNextEdit(offset);\n        return this.translateCurToOld(offset);\n    }\n    /**\n     * @param offset Must be equal to or greater than the last offset this method has been called with.\n     * Returns null if there is no edit anymore.\n    */\n    getDistanceToNextChange(offset) {\n        this.adjustNextEdit(offset);\n        const nextEdit = this.edits[this.nextEditIdx];\n        const nextChangeOffset = nextEdit ? this.translateOldToCur(nextEdit.offsetObj) : null;\n        if (nextChangeOffset === null) {\n            return null;\n        }\n        return lengthDiffNonNegative(offset, nextChangeOffset);\n    }\n    translateOldToCur(oldOffsetObj) {\n        if (oldOffsetObj.lineCount === this.deltaLineIdxInOld) {\n            return toLength(oldOffsetObj.lineCount + this.deltaOldToNewLineCount, oldOffsetObj.columnCount + this.deltaOldToNewColumnCount);\n        }\n        else {\n            return toLength(oldOffsetObj.lineCount + this.deltaOldToNewLineCount, oldOffsetObj.columnCount);\n        }\n    }\n    translateCurToOld(newOffset) {\n        const offsetObj = lengthToObj(newOffset);\n        if (offsetObj.lineCount - this.deltaOldToNewLineCount === this.deltaLineIdxInOld) {\n            return toLength(offsetObj.lineCount - this.deltaOldToNewLineCount, offsetObj.columnCount - this.deltaOldToNewColumnCount);\n        }\n        else {\n            return toLength(offsetObj.lineCount - this.deltaOldToNewLineCount, offsetObj.columnCount);\n        }\n    }\n    adjustNextEdit(offset) {\n        while (this.nextEditIdx < this.edits.length) {\n            const nextEdit = this.edits[this.nextEditIdx];\n            // After applying the edit, what is its end offset (considering all previous edits)?\n            const nextEditEndOffsetInCur = this.translateOldToCur(nextEdit.endOffsetAfterObj);\n            if (lengthLessThanEqual(nextEditEndOffsetInCur, offset)) {\n                // We are after the edit, skip it\n                this.nextEditIdx++;\n                const nextEditEndOffsetInCurObj = lengthToObj(nextEditEndOffsetInCur);\n                // Before applying the edit, what is its end offset (considering all previous edits)?\n                const nextEditEndOffsetBeforeInCurObj = lengthToObj(this.translateOldToCur(nextEdit.endOffsetBeforeObj));\n                const lineDelta = nextEditEndOffsetInCurObj.lineCount - nextEditEndOffsetBeforeInCurObj.lineCount;\n                this.deltaOldToNewLineCount += lineDelta;\n                const previousColumnDelta = this.deltaLineIdxInOld === nextEdit.endOffsetBeforeObj.lineCount ? this.deltaOldToNewColumnCount : 0;\n                const columnDelta = nextEditEndOffsetInCurObj.columnCount - nextEditEndOffsetBeforeInCurObj.columnCount;\n                this.deltaOldToNewColumnCount = previousColumnDelta + columnDelta;\n                this.deltaLineIdxInOld = nextEdit.endOffsetBeforeObj.lineCount;\n            }\n            else {\n                // We are in or before the edit.\n                break;\n            }\n        }\n    }\n}\nclass TextEditInfoCache {\n    static from(edit) {\n        return new TextEditInfoCache(edit.startOffset, edit.endOffset, edit.newLength);\n    }\n    constructor(startOffset, endOffset, textLength) {\n        this.endOffsetBeforeObj = lengthToObj(endOffset);\n        this.endOffsetAfterObj = lengthToObj(lengthAdd(startOffset, textLength));\n        this.offsetObj = lengthToObj(startOffset);\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { escapeRegExpCharacters } from '../../../../../base/common/strings.js';\nimport { BracketAstNode } from './ast.js';\nimport { toLength } from './length.js';\nimport { identityKeyProvider, SmallImmutableSet } from './smallImmutableSet.js';\nimport { Token } from './tokenizer.js';\nexport class BracketTokens {\n    static createFromLanguage(configuration, denseKeyProvider) {\n        function getId(bracketInfo) {\n            return denseKeyProvider.getKey(`${bracketInfo.languageId}:::${bracketInfo.bracketText}`);\n        }\n        const map = new Map();\n        for (const openingBracket of configuration.bracketsNew.openingBrackets) {\n            const length = toLength(0, openingBracket.bracketText.length);\n            const openingTextId = getId(openingBracket);\n            const bracketIds = SmallImmutableSet.getEmpty().add(openingTextId, identityKeyProvider);\n            map.set(openingBracket.bracketText, new Token(length, 1 /* TokenKind.OpeningBracket */, openingTextId, bracketIds, BracketAstNode.create(length, openingBracket, bracketIds)));\n        }\n        for (const closingBracket of configuration.bracketsNew.closingBrackets) {\n            const length = toLength(0, closingBracket.bracketText.length);\n            let bracketIds = SmallImmutableSet.getEmpty();\n            const closingBrackets = closingBracket.getOpeningBrackets();\n            for (const bracket of closingBrackets) {\n                bracketIds = bracketIds.add(getId(bracket), identityKeyProvider);\n            }\n            map.set(closingBracket.bracketText, new Token(length, 2 /* TokenKind.ClosingBracket */, getId(closingBrackets[0]), bracketIds, BracketAstNode.create(length, closingBracket, bracketIds)));\n        }\n        return new BracketTokens(map);\n    }\n    constructor(map) {\n        this.map = map;\n        this.hasRegExp = false;\n        this._regExpGlobal = null;\n    }\n    getRegExpStr() {\n        if (this.isEmpty) {\n            return null;\n        }\n        else {\n            const keys = [...this.map.keys()];\n            keys.sort();\n            keys.reverse();\n            return keys.map(k => prepareBracketForRegExp(k)).join('|');\n        }\n    }\n    /**\n     * Returns null if there is no such regexp (because there are no brackets).\n    */\n    get regExpGlobal() {\n        if (!this.hasRegExp) {\n            const regExpStr = this.getRegExpStr();\n            this._regExpGlobal = regExpStr ? new RegExp(regExpStr, 'gi') : null;\n            this.hasRegExp = true;\n        }\n        return this._regExpGlobal;\n    }\n    getToken(value) {\n        return this.map.get(value.toLowerCase());\n    }\n    findClosingTokenText(openingBracketIds) {\n        for (const [closingText, info] of this.map) {\n            if (info.kind === 2 /* TokenKind.ClosingBracket */ && info.bracketIds.intersects(openingBracketIds)) {\n                return closingText;\n            }\n        }\n        return undefined;\n    }\n    get isEmpty() {\n        return this.map.size === 0;\n    }\n}\nfunction prepareBracketForRegExp(str) {\n    let escaped = escapeRegExpCharacters(str);\n    // These bracket pair delimiters start or end with letters\n    // see https://github.com/microsoft/vscode/issues/132162 https://github.com/microsoft/vscode/issues/150440\n    if (/^[\\w ]+/.test(str)) {\n        escaped = `\\\\b${escaped}`;\n    }\n    if (/[\\w ]+$/.test(str)) {\n        escaped = `${escaped}\\\\b`;\n    }\n    return escaped;\n}\nexport class LanguageAgnosticBracketTokens {\n    constructor(denseKeyProvider, getLanguageConfiguration) {\n        this.denseKeyProvider = denseKeyProvider;\n        this.getLanguageConfiguration = getLanguageConfiguration;\n        this.languageIdToBracketTokens = new Map();\n    }\n    didLanguageChange(languageId) {\n        // Report a change whenever the language configuration updates.\n        return this.languageIdToBracketTokens.has(languageId);\n    }\n    getSingleLanguageBracketTokens(languageId) {\n        let singleLanguageBracketTokens = this.languageIdToBracketTokens.get(languageId);\n        if (!singleLanguageBracketTokens) {\n            singleLanguageBracketTokens = BracketTokens.createFromLanguage(this.getLanguageConfiguration(languageId), this.denseKeyProvider);\n            this.languageIdToBracketTokens.set(languageId, singleLanguageBracketTokens);\n        }\n        return singleLanguageBracketTokens;\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { ArrayQueue } from '../../../../../base/common/arrays.js';\nimport { TextEditInfo } from './beforeEditPositionMapper.js';\nimport { lengthAdd, lengthDiffNonNegative, lengthEquals, lengthIsZero, lengthToObj, lengthZero, sumLengths } from './length.js';\nexport function combineTextEditInfos(textEditInfoFirst, textEditInfoSecond) {\n    if (textEditInfoFirst.length === 0) {\n        return textEditInfoSecond;\n    }\n    if (textEditInfoSecond.length === 0) {\n        return textEditInfoFirst;\n    }\n    // s0: State before any edits\n    const s0ToS1Map = new ArrayQueue(toLengthMapping(textEditInfoFirst));\n    // s1: State after first edit, but before second edit\n    const s1ToS2Map = toLengthMapping(textEditInfoSecond);\n    s1ToS2Map.push({ modified: false, lengthBefore: undefined, lengthAfter: undefined }); // Copy everything from old to new\n    // s2: State after both edits\n    let curItem = s0ToS1Map.dequeue();\n    /**\n     * @param s1Length Use undefined for length \"infinity\"\n     */\n    function nextS0ToS1MapWithS1LengthOf(s1Length) {\n        if (s1Length === undefined) {\n            const arr = s0ToS1Map.takeWhile(v => true) || [];\n            if (curItem) {\n                arr.unshift(curItem);\n            }\n            return arr;\n        }\n        const result = [];\n        while (curItem && !lengthIsZero(s1Length)) {\n            const [item, remainingItem] = curItem.splitAt(s1Length);\n            result.push(item);\n            s1Length = lengthDiffNonNegative(item.lengthAfter, s1Length);\n            curItem = remainingItem !== null && remainingItem !== void 0 ? remainingItem : s0ToS1Map.dequeue();\n        }\n        if (!lengthIsZero(s1Length)) {\n            result.push(new LengthMapping(false, s1Length, s1Length));\n        }\n        return result;\n    }\n    const result = [];\n    function pushEdit(startOffset, endOffset, newLength) {\n        if (result.length > 0 && lengthEquals(result[result.length - 1].endOffset, startOffset)) {\n            const lastResult = result[result.length - 1];\n            result[result.length - 1] = new TextEditInfo(lastResult.startOffset, endOffset, lengthAdd(lastResult.newLength, newLength));\n        }\n        else {\n            result.push({ startOffset, endOffset, newLength });\n        }\n    }\n    let s0offset = lengthZero;\n    for (const s1ToS2 of s1ToS2Map) {\n        const s0ToS1Map = nextS0ToS1MapWithS1LengthOf(s1ToS2.lengthBefore);\n        if (s1ToS2.modified) {\n            const s0Length = sumLengths(s0ToS1Map, s => s.lengthBefore);\n            const s0EndOffset = lengthAdd(s0offset, s0Length);\n            pushEdit(s0offset, s0EndOffset, s1ToS2.lengthAfter);\n            s0offset = s0EndOffset;\n        }\n        else {\n            for (const s1 of s0ToS1Map) {\n                const s0startOffset = s0offset;\n                s0offset = lengthAdd(s0offset, s1.lengthBefore);\n                if (s1.modified) {\n                    pushEdit(s0startOffset, s0offset, s1.lengthAfter);\n                }\n            }\n        }\n    }\n    return result;\n}\nclass LengthMapping {\n    constructor(\n    /**\n     * If false, length before and length after equal.\n     */\n    modified, lengthBefore, lengthAfter) {\n        this.modified = modified;\n        this.lengthBefore = lengthBefore;\n        this.lengthAfter = lengthAfter;\n    }\n    splitAt(lengthAfter) {\n        const remainingLengthAfter = lengthDiffNonNegative(lengthAfter, this.lengthAfter);\n        if (lengthEquals(remainingLengthAfter, lengthZero)) {\n            return [this, undefined];\n        }\n        else if (this.modified) {\n            return [\n                new LengthMapping(this.modified, this.lengthBefore, lengthAfter),\n                new LengthMapping(this.modified, lengthZero, remainingLengthAfter)\n            ];\n        }\n        else {\n            return [\n                new LengthMapping(this.modified, lengthAfter, lengthAfter),\n                new LengthMapping(this.modified, remainingLengthAfter, remainingLengthAfter)\n            ];\n        }\n    }\n    toString() {\n        return `${this.modified ? 'M' : 'U'}:${lengthToObj(this.lengthBefore)} -> ${lengthToObj(this.lengthAfter)}`;\n    }\n}\nfunction toLengthMapping(textEditInfos) {\n    const result = [];\n    let lastOffset = lengthZero;\n    for (const textEditInfo of textEditInfos) {\n        const spaceLength = lengthDiffNonNegative(lastOffset, textEditInfo.startOffset);\n        if (!lengthIsZero(spaceLength)) {\n            result.push(new LengthMapping(false, spaceLength, spaceLength));\n        }\n        const lengthBefore = lengthDiffNonNegative(textEditInfo.startOffset, textEditInfo.endOffset);\n        result.push(new LengthMapping(true, lengthBefore, textEditInfo.newLength));\n        lastOffset = textEditInfo.endOffset;\n    }\n    return result;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { splitLines } from '../../../../../base/common/strings.js';\nimport { Range } from '../../../core/range.js';\nimport { TextLength } from '../../../core/textLength.js';\n/**\n * The end must be greater than or equal to the start.\n*/\nexport function lengthDiff(startLineCount, startColumnCount, endLineCount, endColumnCount) {\n    return (startLineCount !== endLineCount)\n        ? toLength(endLineCount - startLineCount, endColumnCount)\n        : toLength(0, endColumnCount - startColumnCount);\n}\nexport const lengthZero = 0;\nexport function lengthIsZero(length) {\n    return length === 0;\n}\n/*\n * We have 52 bits available in a JS number.\n * We use the upper 26 bits to store the line and the lower 26 bits to store the column.\n */\n///*\nconst factor = 2 ** 26;\n/*/\nconst factor = 1000000;\n// */\nexport function toLength(lineCount, columnCount) {\n    // llllllllllllllllllllllllllcccccccccccccccccccccccccc (52 bits)\n    //       line count (26 bits)    column count (26 bits)\n    // If there is no overflow (all values/sums below 2^26 = 67108864),\n    // we have `toLength(lns1, cols1) + toLength(lns2, cols2) = toLength(lns1 + lns2, cols1 + cols2)`.\n    return (lineCount * factor + columnCount);\n}\nexport function lengthToObj(length) {\n    const l = length;\n    const lineCount = Math.floor(l / factor);\n    const columnCount = l - lineCount * factor;\n    return new TextLength(lineCount, columnCount);\n}\nexport function lengthGetLineCount(length) {\n    return Math.floor(length / factor);\n}\n/**\n * Returns the amount of columns of the given length, assuming that it does not span any line.\n*/\nexport function lengthGetColumnCountIfZeroLineCount(length) {\n    return length;\n}\nexport function lengthAdd(l1, l2) {\n    let r = l1 + l2;\n    if (l2 >= factor) {\n        r = r - (l1 % factor);\n    }\n    return r;\n}\nexport function sumLengths(items, lengthFn) {\n    return items.reduce((a, b) => lengthAdd(a, lengthFn(b)), lengthZero);\n}\nexport function lengthEquals(length1, length2) {\n    return length1 === length2;\n}\n/**\n * Returns a non negative length `result` such that `lengthAdd(length1, result) = length2`, or zero if such length does not exist.\n */\nexport function lengthDiffNonNegative(length1, length2) {\n    const l1 = length1;\n    const l2 = length2;\n    const diff = l2 - l1;\n    if (diff <= 0) {\n        // line-count of length1 is higher than line-count of length2\n        // or they are equal and column-count of length1 is higher than column-count of length2\n        return lengthZero;\n    }\n    const lineCount1 = Math.floor(l1 / factor);\n    const lineCount2 = Math.floor(l2 / factor);\n    const colCount2 = l2 - lineCount2 * factor;\n    if (lineCount1 === lineCount2) {\n        const colCount1 = l1 - lineCount1 * factor;\n        return toLength(0, colCount2 - colCount1);\n    }\n    else {\n        return toLength(lineCount2 - lineCount1, colCount2);\n    }\n}\nexport function lengthLessThan(length1, length2) {\n    // First, compare line counts, then column counts.\n    return length1 < length2;\n}\nexport function lengthLessThanEqual(length1, length2) {\n    return length1 <= length2;\n}\nexport function lengthGreaterThanEqual(length1, length2) {\n    return length1 >= length2;\n}\nexport function positionToLength(position) {\n    return toLength(position.lineNumber - 1, position.column - 1);\n}\nexport function lengthsToRange(lengthStart, lengthEnd) {\n    const l = lengthStart;\n    const lineCount = Math.floor(l / factor);\n    const colCount = l - lineCount * factor;\n    const l2 = lengthEnd;\n    const lineCount2 = Math.floor(l2 / factor);\n    const colCount2 = l2 - lineCount2 * factor;\n    return new Range(lineCount + 1, colCount + 1, lineCount2 + 1, colCount2 + 1);\n}\nexport function lengthOfString(str) {\n    const lines = splitLines(str);\n    return toLength(lines.length - 1, lines[lines.length - 1].length);\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { ListAstNode } from './ast.js';\n/**\n * Concatenates a list of (2,3) AstNode's into a single (2,3) AstNode.\n * This mutates the items of the input array!\n * If all items have the same height, this method has runtime O(items.length).\n * Otherwise, it has runtime O(items.length * max(log(items.length), items.max(i => i.height))).\n*/\nexport function concat23Trees(items) {\n    if (items.length === 0) {\n        return null;\n    }\n    if (items.length === 1) {\n        return items[0];\n    }\n    let i = 0;\n    /**\n     * Reads nodes of same height and concatenates them to a single node.\n    */\n    function readNode() {\n        if (i >= items.length) {\n            return null;\n        }\n        const start = i;\n        const height = items[start].listHeight;\n        i++;\n        while (i < items.length && items[i].listHeight === height) {\n            i++;\n        }\n        if (i - start >= 2) {\n            return concat23TreesOfSameHeight(start === 0 && i === items.length ? items : items.slice(start, i), false);\n        }\n        else {\n            return items[start];\n        }\n    }\n    // The items might not have the same height.\n    // We merge all items by using a binary concat operator.\n    let first = readNode(); // There must be a first item\n    let second = readNode();\n    if (!second) {\n        return first;\n    }\n    for (let item = readNode(); item; item = readNode()) {\n        // Prefer concatenating smaller trees, as the runtime of concat depends on the tree height.\n        if (heightDiff(first, second) <= heightDiff(second, item)) {\n            first = concat(first, second);\n            second = item;\n        }\n        else {\n            second = concat(second, item);\n        }\n    }\n    const result = concat(first, second);\n    return result;\n}\nexport function concat23TreesOfSameHeight(items, createImmutableLists = false) {\n    if (items.length === 0) {\n        return null;\n    }\n    if (items.length === 1) {\n        return items[0];\n    }\n    let length = items.length;\n    // All trees have same height, just create parent nodes.\n    while (length > 3) {\n        const newLength = length >> 1;\n        for (let i = 0; i < newLength; i++) {\n            const j = i << 1;\n            items[i] = ListAstNode.create23(items[j], items[j + 1], j + 3 === length ? items[j + 2] : null, createImmutableLists);\n        }\n        length = newLength;\n    }\n    return ListAstNode.create23(items[0], items[1], length >= 3 ? items[2] : null, createImmutableLists);\n}\nfunction heightDiff(node1, node2) {\n    return Math.abs(node1.listHeight - node2.listHeight);\n}\nfunction concat(node1, node2) {\n    if (node1.listHeight === node2.listHeight) {\n        return ListAstNode.create23(node1, node2, null, false);\n    }\n    else if (node1.listHeight > node2.listHeight) {\n        // node1 is the tree we want to insert into\n        return append(node1, node2);\n    }\n    else {\n        return prepend(node2, node1);\n    }\n}\n/**\n * Appends the given node to the end of this (2,3) tree.\n * Returns the new root.\n*/\nfunction append(list, nodeToAppend) {\n    list = list.toMutable();\n    let curNode = list;\n    const parents = [];\n    let nodeToAppendOfCorrectHeight;\n    while (true) {\n        // assert nodeToInsert.listHeight <= curNode.listHeight\n        if (nodeToAppend.listHeight === curNode.listHeight) {\n            nodeToAppendOfCorrectHeight = nodeToAppend;\n            break;\n        }\n        // assert 0 <= nodeToInsert.listHeight < curNode.listHeight\n        if (curNode.kind !== 4 /* AstNodeKind.List */) {\n            throw new Error('unexpected');\n        }\n        parents.push(curNode);\n        // assert 2 <= curNode.childrenLength <= 3\n        curNode = curNode.makeLastElementMutable();\n    }\n    // assert nodeToAppendOfCorrectHeight!.listHeight === curNode.listHeight\n    for (let i = parents.length - 1; i >= 0; i--) {\n        const parent = parents[i];\n        if (nodeToAppendOfCorrectHeight) {\n            // Can we take the element?\n            if (parent.childrenLength >= 3) {\n                // assert parent.childrenLength === 3 && parent.listHeight === nodeToAppendOfCorrectHeight.listHeight + 1\n                // we need to split to maintain (2,3)-tree property.\n                // Send the third element + the new element to the parent.\n                nodeToAppendOfCorrectHeight = ListAstNode.create23(parent.unappendChild(), nodeToAppendOfCorrectHeight, null, false);\n            }\n            else {\n                parent.appendChildOfSameHeight(nodeToAppendOfCorrectHeight);\n                nodeToAppendOfCorrectHeight = undefined;\n            }\n        }\n        else {\n            parent.handleChildrenChanged();\n        }\n    }\n    if (nodeToAppendOfCorrectHeight) {\n        return ListAstNode.create23(list, nodeToAppendOfCorrectHeight, null, false);\n    }\n    else {\n        return list;\n    }\n}\n/**\n * Prepends the given node to the end of this (2,3) tree.\n * Returns the new root.\n*/\nfunction prepend(list, nodeToAppend) {\n    list = list.toMutable();\n    let curNode = list;\n    const parents = [];\n    // assert nodeToInsert.listHeight <= curNode.listHeight\n    while (nodeToAppend.listHeight !== curNode.listHeight) {\n        // assert 0 <= nodeToInsert.listHeight < curNode.listHeight\n        if (curNode.kind !== 4 /* AstNodeKind.List */) {\n            throw new Error('unexpected');\n        }\n        parents.push(curNode);\n        // assert 2 <= curNode.childrenFast.length <= 3\n        curNode = curNode.makeFirstElementMutable();\n    }\n    let nodeToPrependOfCorrectHeight = nodeToAppend;\n    // assert nodeToAppendOfCorrectHeight!.listHeight === curNode.listHeight\n    for (let i = parents.length - 1; i >= 0; i--) {\n        const parent = parents[i];\n        if (nodeToPrependOfCorrectHeight) {\n            // Can we take the element?\n            if (parent.childrenLength >= 3) {\n                // assert parent.childrenLength === 3 && parent.listHeight === nodeToAppendOfCorrectHeight.listHeight + 1\n                // we need to split to maintain (2,3)-tree property.\n                // Send the third element + the new element to the parent.\n                nodeToPrependOfCorrectHeight = ListAstNode.create23(nodeToPrependOfCorrectHeight, parent.unprependChild(), null, false);\n            }\n            else {\n                parent.prependChildOfSameHeight(nodeToPrependOfCorrectHeight);\n                nodeToPrependOfCorrectHeight = undefined;\n            }\n        }\n        else {\n            parent.handleChildrenChanged();\n        }\n    }\n    if (nodeToPrependOfCorrectHeight) {\n        return ListAstNode.create23(nodeToPrependOfCorrectHeight, list, null, false);\n    }\n    else {\n        return list;\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { lengthAdd, lengthZero, lengthLessThan } from './length.js';\n/**\n * Allows to efficiently find a longest child at a given offset in a fixed node.\n * The requested offsets must increase monotonously.\n*/\nexport class NodeReader {\n    constructor(node) {\n        this.lastOffset = lengthZero;\n        this.nextNodes = [node];\n        this.offsets = [lengthZero];\n        this.idxs = [];\n    }\n    /**\n     * Returns the longest node at `offset` that satisfies the predicate.\n     * @param offset must be greater than or equal to the last offset this method has been called with!\n    */\n    readLongestNodeAt(offset, predicate) {\n        if (lengthLessThan(offset, this.lastOffset)) {\n            throw new Error('Invalid offset');\n        }\n        this.lastOffset = offset;\n        // Find the longest node of all those that are closest to the current offset.\n        while (true) {\n            const curNode = lastOrUndefined(this.nextNodes);\n            if (!curNode) {\n                return undefined;\n            }\n            const curNodeOffset = lastOrUndefined(this.offsets);\n            if (lengthLessThan(offset, curNodeOffset)) {\n                // The next best node is not here yet.\n                // The reader must advance before a cached node is hit.\n                return undefined;\n            }\n            if (lengthLessThan(curNodeOffset, offset)) {\n                // The reader is ahead of the current node.\n                if (lengthAdd(curNodeOffset, curNode.length) <= offset) {\n                    // The reader is after the end of the current node.\n                    this.nextNodeAfterCurrent();\n                }\n                else {\n                    // The reader is somewhere in the current node.\n                    const nextChildIdx = getNextChildIdx(curNode);\n                    if (nextChildIdx !== -1) {\n                        // Go to the first child and repeat.\n                        this.nextNodes.push(curNode.getChild(nextChildIdx));\n                        this.offsets.push(curNodeOffset);\n                        this.idxs.push(nextChildIdx);\n                    }\n                    else {\n                        // We don't have children\n                        this.nextNodeAfterCurrent();\n                    }\n                }\n            }\n            else {\n                // readerOffsetBeforeChange === curNodeOffset\n                if (predicate(curNode)) {\n                    this.nextNodeAfterCurrent();\n                    return curNode;\n                }\n                else {\n                    const nextChildIdx = getNextChildIdx(curNode);\n                    // look for shorter node\n                    if (nextChildIdx === -1) {\n                        // There is no shorter node.\n                        this.nextNodeAfterCurrent();\n                        return undefined;\n                    }\n                    else {\n                        // Descend into first child & repeat.\n                        this.nextNodes.push(curNode.getChild(nextChildIdx));\n                        this.offsets.push(curNodeOffset);\n                        this.idxs.push(nextChildIdx);\n                    }\n                }\n            }\n        }\n    }\n    // Navigates to the longest node that continues after the current node.\n    nextNodeAfterCurrent() {\n        while (true) {\n            const currentOffset = lastOrUndefined(this.offsets);\n            const currentNode = lastOrUndefined(this.nextNodes);\n            this.nextNodes.pop();\n            this.offsets.pop();\n            if (this.idxs.length === 0) {\n                // We just popped the root node, there is no next node.\n                break;\n            }\n            // Parent is not undefined, because idxs is not empty\n            const parent = lastOrUndefined(this.nextNodes);\n            const nextChildIdx = getNextChildIdx(parent, this.idxs[this.idxs.length - 1]);\n            if (nextChildIdx !== -1) {\n                this.nextNodes.push(parent.getChild(nextChildIdx));\n                this.offsets.push(lengthAdd(currentOffset, currentNode.length));\n                this.idxs[this.idxs.length - 1] = nextChildIdx;\n                break;\n            }\n            else {\n                this.idxs.pop();\n            }\n            // We fully consumed the parent.\n            // Current node is now parent, so call nextNodeAfterCurrent again\n        }\n    }\n}\nfunction getNextChildIdx(node, curIdx = -1) {\n    while (true) {\n        curIdx++;\n        if (curIdx >= node.childrenLength) {\n            return -1;\n        }\n        if (node.getChild(curIdx)) {\n            return curIdx;\n        }\n    }\n}\nfunction lastOrUndefined(arr) {\n    return arr.length > 0 ? arr[arr.length - 1] : undefined;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { InvalidBracketAstNode, ListAstNode, PairAstNode, TextAstNode } from './ast.js';\nimport { BeforeEditPositionMapper } from './beforeEditPositionMapper.js';\nimport { SmallImmutableSet } from './smallImmutableSet.js';\nimport { lengthIsZero, lengthLessThan } from './length.js';\nimport { concat23Trees, concat23TreesOfSameHeight } from './concat23Trees.js';\nimport { NodeReader } from './nodeReader.js';\n/**\n * Non incrementally built ASTs are immutable.\n*/\nexport function parseDocument(tokenizer, edits, oldNode, createImmutableLists) {\n    const parser = new Parser(tokenizer, edits, oldNode, createImmutableLists);\n    return parser.parseDocument();\n}\n/**\n * Non incrementally built ASTs are immutable.\n*/\nclass Parser {\n    constructor(tokenizer, edits, oldNode, createImmutableLists) {\n        this.tokenizer = tokenizer;\n        this.createImmutableLists = createImmutableLists;\n        this._itemsConstructed = 0;\n        this._itemsFromCache = 0;\n        if (oldNode && createImmutableLists) {\n            throw new Error('Not supported');\n        }\n        this.oldNodeReader = oldNode ? new NodeReader(oldNode) : undefined;\n        this.positionMapper = new BeforeEditPositionMapper(edits);\n    }\n    parseDocument() {\n        this._itemsConstructed = 0;\n        this._itemsFromCache = 0;\n        let result = this.parseList(SmallImmutableSet.getEmpty(), 0);\n        if (!result) {\n            result = ListAstNode.getEmpty();\n        }\n        return result;\n    }\n    parseList(openedBracketIds, level) {\n        const items = [];\n        while (true) {\n            let child = this.tryReadChildFromCache(openedBracketIds);\n            if (!child) {\n                const token = this.tokenizer.peek();\n                if (!token ||\n                    (token.kind === 2 /* TokenKind.ClosingBracket */ &&\n                        token.bracketIds.intersects(openedBracketIds))) {\n                    break;\n                }\n                child = this.parseChild(openedBracketIds, level + 1);\n            }\n            if (child.kind === 4 /* AstNodeKind.List */ && child.childrenLength === 0) {\n                continue;\n            }\n            items.push(child);\n        }\n        // When there is no oldNodeReader, all items are created from scratch and must have the same height.\n        const result = this.oldNodeReader ? concat23Trees(items) : concat23TreesOfSameHeight(items, this.createImmutableLists);\n        return result;\n    }\n    tryReadChildFromCache(openedBracketIds) {\n        if (this.oldNodeReader) {\n            const maxCacheableLength = this.positionMapper.getDistanceToNextChange(this.tokenizer.offset);\n            if (maxCacheableLength === null || !lengthIsZero(maxCacheableLength)) {\n                const cachedNode = this.oldNodeReader.readLongestNodeAt(this.positionMapper.getOffsetBeforeChange(this.tokenizer.offset), curNode => {\n                    // The edit could extend the ending token, thus we cannot re-use nodes that touch the edit.\n                    // If there is no edit anymore, we can re-use the node in any case.\n                    if (maxCacheableLength !== null && !lengthLessThan(curNode.length, maxCacheableLength)) {\n                        // Either the node contains edited text or touches edited text.\n                        // In the latter case, brackets might have been extended (`end` -> `ending`), so even touching nodes cannot be reused.\n                        return false;\n                    }\n                    const canBeReused = curNode.canBeReused(openedBracketIds);\n                    return canBeReused;\n                });\n                if (cachedNode) {\n                    this._itemsFromCache++;\n                    this.tokenizer.skip(cachedNode.length);\n                    return cachedNode;\n                }\n            }\n        }\n        return undefined;\n    }\n    parseChild(openedBracketIds, level) {\n        this._itemsConstructed++;\n        const token = this.tokenizer.read();\n        switch (token.kind) {\n            case 2 /* TokenKind.ClosingBracket */:\n                return new InvalidBracketAstNode(token.bracketIds, token.length);\n            case 0 /* TokenKind.Text */:\n                return token.astNode;\n            case 1 /* TokenKind.OpeningBracket */: {\n                if (level > 300) {\n                    // To prevent stack overflows\n                    return new TextAstNode(token.length);\n                }\n                const set = openedBracketIds.merge(token.bracketIds);\n                const child = this.parseList(set, level + 1);\n                const nextToken = this.tokenizer.peek();\n                if (nextToken &&\n                    nextToken.kind === 2 /* TokenKind.ClosingBracket */ &&\n                    (nextToken.bracketId === token.bracketId || nextToken.bracketIds.intersects(token.bracketIds))) {\n                    this.tokenizer.read();\n                    return PairAstNode.create(token.astNode, child, nextToken.astNode);\n                }\n                else {\n                    return PairAstNode.create(token.astNode, child, null);\n                }\n            }\n            default:\n                throw new Error('unexpected');\n        }\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nconst emptyArr = [];\n/**\n * Represents an immutable set that works best for a small number of elements (less than 32).\n * It uses bits to encode element membership efficiently.\n*/\nexport class SmallImmutableSet {\n    static create(items, additionalItems) {\n        if (items <= 128 && additionalItems.length === 0) {\n            // We create a cache of 128=2^7 elements to cover all sets with up to 7 (dense) elements.\n            let cached = SmallImmutableSet.cache[items];\n            if (!cached) {\n                cached = new SmallImmutableSet(items, additionalItems);\n                SmallImmutableSet.cache[items] = cached;\n            }\n            return cached;\n        }\n        return new SmallImmutableSet(items, additionalItems);\n    }\n    static getEmpty() {\n        return this.empty;\n    }\n    constructor(items, additionalItems) {\n        this.items = items;\n        this.additionalItems = additionalItems;\n    }\n    add(value, keyProvider) {\n        const key = keyProvider.getKey(value);\n        let idx = key >> 5; // divided by 32\n        if (idx === 0) {\n            // fast path\n            const newItem = (1 << key) | this.items;\n            if (newItem === this.items) {\n                return this;\n            }\n            return SmallImmutableSet.create(newItem, this.additionalItems);\n        }\n        idx--;\n        const newItems = this.additionalItems.slice(0);\n        while (newItems.length < idx) {\n            newItems.push(0);\n        }\n        newItems[idx] |= 1 << (key & 31);\n        return SmallImmutableSet.create(this.items, newItems);\n    }\n    merge(other) {\n        const merged = this.items | other.items;\n        if (this.additionalItems === emptyArr && other.additionalItems === emptyArr) {\n            // fast path\n            if (merged === this.items) {\n                return this;\n            }\n            if (merged === other.items) {\n                return other;\n            }\n            return SmallImmutableSet.create(merged, emptyArr);\n        }\n        // This can be optimized, but it's not a common case\n        const newItems = [];\n        for (let i = 0; i < Math.max(this.additionalItems.length, other.additionalItems.length); i++) {\n            const item1 = this.additionalItems[i] || 0;\n            const item2 = other.additionalItems[i] || 0;\n            newItems.push(item1 | item2);\n        }\n        return SmallImmutableSet.create(merged, newItems);\n    }\n    intersects(other) {\n        if ((this.items & other.items) !== 0) {\n            return true;\n        }\n        for (let i = 0; i < Math.min(this.additionalItems.length, other.additionalItems.length); i++) {\n            if ((this.additionalItems[i] & other.additionalItems[i]) !== 0) {\n                return true;\n            }\n        }\n        return false;\n    }\n}\nSmallImmutableSet.cache = new Array(129);\nSmallImmutableSet.empty = SmallImmutableSet.create(0, emptyArr);\nexport const identityKeyProvider = {\n    getKey(value) {\n        return value;\n    }\n};\n/**\n * Assigns values a unique incrementing key.\n*/\nexport class DenseKeyProvider {\n    constructor() {\n        this.items = new Map();\n    }\n    getKey(value) {\n        let existing = this.items.get(value);\n        if (existing === undefined) {\n            existing = this.items.size;\n            this.items.set(value, existing);\n        }\n        return existing;\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { NotSupportedError } from '../../../../../base/common/errors.js';\nimport { TokenMetadata } from '../../../encodedTokenAttributes.js';\nimport { TextAstNode } from './ast.js';\nimport { lengthAdd, lengthDiff, lengthGetColumnCountIfZeroLineCount, lengthToObj, lengthZero, toLength } from './length.js';\nimport { SmallImmutableSet } from './smallImmutableSet.js';\nexport class Token {\n    constructor(length, kind, \n    /**\n     * If this token is an opening bracket, this is the id of the opening bracket.\n     * If this token is a closing bracket, this is the id of the first opening bracket that is closed by this bracket.\n     * Otherwise, it is -1.\n     */\n    bracketId, \n    /**\n     * If this token is an opening bracket, this just contains `bracketId`.\n     * If this token is a closing bracket, this lists all opening bracket ids, that it closes.\n     * Otherwise, it is empty.\n     */\n    bracketIds, astNode) {\n        this.length = length;\n        this.kind = kind;\n        this.bracketId = bracketId;\n        this.bracketIds = bracketIds;\n        this.astNode = astNode;\n    }\n}\nexport class TextBufferTokenizer {\n    constructor(textModel, bracketTokens) {\n        this.textModel = textModel;\n        this.bracketTokens = bracketTokens;\n        this.reader = new NonPeekableTextBufferTokenizer(this.textModel, this.bracketTokens);\n        this._offset = lengthZero;\n        this.didPeek = false;\n        this.peeked = null;\n        this.textBufferLineCount = textModel.getLineCount();\n        this.textBufferLastLineLength = textModel.getLineLength(this.textBufferLineCount);\n    }\n    get offset() {\n        return this._offset;\n    }\n    get length() {\n        return toLength(this.textBufferLineCount - 1, this.textBufferLastLineLength);\n    }\n    skip(length) {\n        this.didPeek = false;\n        this._offset = lengthAdd(this._offset, length);\n        const obj = lengthToObj(this._offset);\n        this.reader.setPosition(obj.lineCount, obj.columnCount);\n    }\n    read() {\n        let token;\n        if (this.peeked) {\n            this.didPeek = false;\n            token = this.peeked;\n        }\n        else {\n            token = this.reader.read();\n        }\n        if (token) {\n            this._offset = lengthAdd(this._offset, token.length);\n        }\n        return token;\n    }\n    peek() {\n        if (!this.didPeek) {\n            this.peeked = this.reader.read();\n            this.didPeek = true;\n        }\n        return this.peeked;\n    }\n}\n/**\n * Does not support peek.\n*/\nclass NonPeekableTextBufferTokenizer {\n    constructor(textModel, bracketTokens) {\n        this.textModel = textModel;\n        this.bracketTokens = bracketTokens;\n        this.lineIdx = 0;\n        this.line = null;\n        this.lineCharOffset = 0;\n        this.lineTokens = null;\n        this.lineTokenOffset = 0;\n        /** Must be a zero line token. The end of the document cannot be peeked. */\n        this.peekedToken = null;\n        this.textBufferLineCount = textModel.getLineCount();\n        this.textBufferLastLineLength = textModel.getLineLength(this.textBufferLineCount);\n    }\n    setPosition(lineIdx, column) {\n        // We must not jump into a token!\n        if (lineIdx === this.lineIdx) {\n            this.lineCharOffset = column;\n            if (this.line !== null) {\n                this.lineTokenOffset = this.lineCharOffset === 0 ? 0 : this.lineTokens.findTokenIndexAtOffset(this.lineCharOffset);\n            }\n        }\n        else {\n            this.lineIdx = lineIdx;\n            this.lineCharOffset = column;\n            this.line = null;\n        }\n        this.peekedToken = null;\n    }\n    read() {\n        if (this.peekedToken) {\n            const token = this.peekedToken;\n            this.peekedToken = null;\n            this.lineCharOffset += lengthGetColumnCountIfZeroLineCount(token.length);\n            return token;\n        }\n        if (this.lineIdx > this.textBufferLineCount - 1 || (this.lineIdx === this.textBufferLineCount - 1 && this.lineCharOffset >= this.textBufferLastLineLength)) {\n            // We are after the end\n            return null;\n        }\n        if (this.line === null) {\n            this.lineTokens = this.textModel.tokenization.getLineTokens(this.lineIdx + 1);\n            this.line = this.lineTokens.getLineContent();\n            this.lineTokenOffset = this.lineCharOffset === 0 ? 0 : this.lineTokens.findTokenIndexAtOffset(this.lineCharOffset);\n        }\n        const startLineIdx = this.lineIdx;\n        const startLineCharOffset = this.lineCharOffset;\n        // limits the length of text tokens.\n        // If text tokens get too long, incremental updates will be slow\n        let lengthHeuristic = 0;\n        while (true) {\n            const lineTokens = this.lineTokens;\n            const tokenCount = lineTokens.getCount();\n            let peekedBracketToken = null;\n            if (this.lineTokenOffset < tokenCount) {\n                const tokenMetadata = lineTokens.getMetadata(this.lineTokenOffset);\n                while (this.lineTokenOffset + 1 < tokenCount && tokenMetadata === lineTokens.getMetadata(this.lineTokenOffset + 1)) {\n                    // Skip tokens that are identical.\n                    // Sometimes, (bracket) identifiers are split up into multiple tokens.\n                    this.lineTokenOffset++;\n                }\n                const isOther = TokenMetadata.getTokenType(tokenMetadata) === 0 /* StandardTokenType.Other */;\n                const containsBracketType = TokenMetadata.containsBalancedBrackets(tokenMetadata);\n                const endOffset = lineTokens.getEndOffset(this.lineTokenOffset);\n                // Is there a bracket token next? Only consume text.\n                if (containsBracketType && isOther && this.lineCharOffset < endOffset) {\n                    const languageId = lineTokens.getLanguageId(this.lineTokenOffset);\n                    const text = this.line.substring(this.lineCharOffset, endOffset);\n                    const brackets = this.bracketTokens.getSingleLanguageBracketTokens(languageId);\n                    const regexp = brackets.regExpGlobal;\n                    if (regexp) {\n                        regexp.lastIndex = 0;\n                        const match = regexp.exec(text);\n                        if (match) {\n                            peekedBracketToken = brackets.getToken(match[0]);\n                            if (peekedBracketToken) {\n                                // Consume leading text of the token\n                                this.lineCharOffset += match.index;\n                            }\n                        }\n                    }\n                }\n                lengthHeuristic += endOffset - this.lineCharOffset;\n                if (peekedBracketToken) {\n                    // Don't skip the entire token, as a single token could contain multiple brackets.\n                    if (startLineIdx !== this.lineIdx || startLineCharOffset !== this.lineCharOffset) {\n                        // There is text before the bracket\n                        this.peekedToken = peekedBracketToken;\n                        break;\n                    }\n                    else {\n                        // Consume the peeked token\n                        this.lineCharOffset += lengthGetColumnCountIfZeroLineCount(peekedBracketToken.length);\n                        return peekedBracketToken;\n                    }\n                }\n                else {\n                    // Skip the entire token, as the token contains no brackets at all.\n                    this.lineTokenOffset++;\n                    this.lineCharOffset = endOffset;\n                }\n            }\n            else {\n                if (this.lineIdx === this.textBufferLineCount - 1) {\n                    break;\n                }\n                this.lineIdx++;\n                this.lineTokens = this.textModel.tokenization.getLineTokens(this.lineIdx + 1);\n                this.lineTokenOffset = 0;\n                this.line = this.lineTokens.getLineContent();\n                this.lineCharOffset = 0;\n                lengthHeuristic += 33; // max 1000/33 = 30 lines\n                // This limits the amount of work to recompute min-indentation\n                if (lengthHeuristic > 1000) {\n                    // only break (automatically) at the end of line.\n                    break;\n                }\n            }\n            if (lengthHeuristic > 1500) {\n                // Eventually break regardless of the line length so that\n                // very long lines do not cause bad performance.\n                // This effective limits max indentation to 500, as\n                // indentation is not computed across multiple text nodes.\n                break;\n            }\n        }\n        // If a token contains some proper indentation, it also contains \\n{INDENTATION+}(?!{INDENTATION}),\n        // unless the line is too long.\n        // Thus, the min indentation of the document is the minimum min indentation of every text node.\n        const length = lengthDiff(startLineIdx, startLineCharOffset, this.lineIdx, this.lineCharOffset);\n        return new Token(length, 0 /* TokenKind.Text */, -1, SmallImmutableSet.getEmpty(), new TextAstNode(length));\n    }\n}\nexport class FastTokenizer {\n    constructor(text, brackets) {\n        this.text = text;\n        this._offset = lengthZero;\n        this.idx = 0;\n        const regExpStr = brackets.getRegExpStr();\n        const regexp = regExpStr ? new RegExp(regExpStr + '|\\n', 'gi') : null;\n        const tokens = [];\n        let match;\n        let curLineCount = 0;\n        let lastLineBreakOffset = 0;\n        let lastTokenEndOffset = 0;\n        let lastTokenEndLine = 0;\n        const smallTextTokens0Line = [];\n        for (let i = 0; i < 60; i++) {\n            smallTextTokens0Line.push(new Token(toLength(0, i), 0 /* TokenKind.Text */, -1, SmallImmutableSet.getEmpty(), new TextAstNode(toLength(0, i))));\n        }\n        const smallTextTokens1Line = [];\n        for (let i = 0; i < 60; i++) {\n            smallTextTokens1Line.push(new Token(toLength(1, i), 0 /* TokenKind.Text */, -1, SmallImmutableSet.getEmpty(), new TextAstNode(toLength(1, i))));\n        }\n        if (regexp) {\n            regexp.lastIndex = 0;\n            // If a token contains indentation, it also contains \\n{INDENTATION+}(?!{INDENTATION})\n            while ((match = regexp.exec(text)) !== null) {\n                const curOffset = match.index;\n                const value = match[0];\n                if (value === '\\n') {\n                    curLineCount++;\n                    lastLineBreakOffset = curOffset + 1;\n                }\n                else {\n                    if (lastTokenEndOffset !== curOffset) {\n                        let token;\n                        if (lastTokenEndLine === curLineCount) {\n                            const colCount = curOffset - lastTokenEndOffset;\n                            if (colCount < smallTextTokens0Line.length) {\n                                token = smallTextTokens0Line[colCount];\n                            }\n                            else {\n                                const length = toLength(0, colCount);\n                                token = new Token(length, 0 /* TokenKind.Text */, -1, SmallImmutableSet.getEmpty(), new TextAstNode(length));\n                            }\n                        }\n                        else {\n                            const lineCount = curLineCount - lastTokenEndLine;\n                            const colCount = curOffset - lastLineBreakOffset;\n                            if (lineCount === 1 && colCount < smallTextTokens1Line.length) {\n                                token = smallTextTokens1Line[colCount];\n                            }\n                            else {\n                                const length = toLength(lineCount, colCount);\n                                token = new Token(length, 0 /* TokenKind.Text */, -1, SmallImmutableSet.getEmpty(), new TextAstNode(length));\n                            }\n                        }\n                        tokens.push(token);\n                    }\n                    // value is matched by regexp, so the token must exist\n                    tokens.push(brackets.getToken(value));\n                    lastTokenEndOffset = curOffset + value.length;\n                    lastTokenEndLine = curLineCount;\n                }\n            }\n        }\n        const offset = text.length;\n        if (lastTokenEndOffset !== offset) {\n            const length = (lastTokenEndLine === curLineCount)\n                ? toLength(0, offset - lastTokenEndOffset)\n                : toLength(curLineCount - lastTokenEndLine, offset - lastLineBreakOffset);\n            tokens.push(new Token(length, 0 /* TokenKind.Text */, -1, SmallImmutableSet.getEmpty(), new TextAstNode(length)));\n        }\n        this.length = toLength(curLineCount, offset - lastLineBreakOffset);\n        this.tokens = tokens;\n    }\n    get offset() {\n        return this._offset;\n    }\n    read() {\n        return this.tokens[this.idx++] || null;\n    }\n    peek() {\n        return this.tokens[this.idx] || null;\n    }\n    skip(length) {\n        throw new NotSupportedError();\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Emitter } from '../../../../base/common/event.js';\nimport { Disposable } from '../../../../base/common/lifecycle.js';\nimport { Range } from '../../core/range.js';\nimport { editorBracketHighlightingForeground1, editorBracketHighlightingForeground2, editorBracketHighlightingForeground3, editorBracketHighlightingForeground4, editorBracketHighlightingForeground5, editorBracketHighlightingForeground6, editorBracketHighlightingUnexpectedBracketForeground } from '../../core/editorColorRegistry.js';\nimport { registerThemingParticipant } from '../../../../platform/theme/common/themeService.js';\nexport class ColorizedBracketPairsDecorationProvider extends Disposable {\n    constructor(textModel) {\n        super();\n        this.textModel = textModel;\n        this.colorProvider = new ColorProvider();\n        this.onDidChangeEmitter = new Emitter();\n        this.onDidChange = this.onDidChangeEmitter.event;\n        this.colorizationOptions = textModel.getOptions().bracketPairColorizationOptions;\n        this._register(textModel.bracketPairs.onDidChange(e => {\n            this.onDidChangeEmitter.fire();\n        }));\n    }\n    //#region TextModel events\n    handleDidChangeOptions(e) {\n        this.colorizationOptions = this.textModel.getOptions().bracketPairColorizationOptions;\n    }\n    //#endregion\n    getDecorationsInRange(range, ownerId, filterOutValidation, onlyMinimapDecorations) {\n        if (onlyMinimapDecorations) {\n            // Bracket pair colorization decorations are not rendered in the minimap\n            return [];\n        }\n        if (ownerId === undefined) {\n            return [];\n        }\n        if (!this.colorizationOptions.enabled) {\n            return [];\n        }\n        const result = this.textModel.bracketPairs.getBracketsInRange(range, true).map(bracket => ({\n            id: `bracket${bracket.range.toString()}-${bracket.nestingLevel}`,\n            options: {\n                description: 'BracketPairColorization',\n                inlineClassName: this.colorProvider.getInlineClassName(bracket, this.colorizationOptions.independentColorPoolPerBracketType),\n            },\n            ownerId: 0,\n            range: bracket.range,\n        })).toArray();\n        return result;\n    }\n    getAllDecorations(ownerId, filterOutValidation) {\n        if (ownerId === undefined) {\n            return [];\n        }\n        if (!this.colorizationOptions.enabled) {\n            return [];\n        }\n        return this.getDecorationsInRange(new Range(1, 1, this.textModel.getLineCount(), 1), ownerId, filterOutValidation);\n    }\n}\nclass ColorProvider {\n    constructor() {\n        this.unexpectedClosingBracketClassName = 'unexpected-closing-bracket';\n    }\n    getInlineClassName(bracket, independentColorPoolPerBracketType) {\n        if (bracket.isInvalid) {\n            return this.unexpectedClosingBracketClassName;\n        }\n        return this.getInlineClassNameOfLevel(independentColorPoolPerBracketType ? bracket.nestingLevelOfEqualBracketType : bracket.nestingLevel);\n    }\n    getInlineClassNameOfLevel(level) {\n        // To support a dynamic amount of colors up to 6 colors,\n        // we use a number that is a lcm of all numbers from 1 to 6.\n        return `bracket-highlighting-${level % 30}`;\n    }\n}\nregisterThemingParticipant((theme, collector) => {\n    const colors = [\n        editorBracketHighlightingForeground1,\n        editorBracketHighlightingForeground2,\n        editorBracketHighlightingForeground3,\n        editorBracketHighlightingForeground4,\n        editorBracketHighlightingForeground5,\n        editorBracketHighlightingForeground6\n    ];\n    const colorProvider = new ColorProvider();\n    collector.addRule(`.monaco-editor .${colorProvider.unexpectedClosingBracketClassName} { color: ${theme.getColor(editorBracketHighlightingUnexpectedBracketForeground)}; }`);\n    const colorValues = colors\n        .map(c => theme.getColor(c))\n        .filter((c) => !!c)\n        .filter(c => !c.isTransparent());\n    for (let level = 0; level < 30; level++) {\n        const color = colorValues[level % colorValues.length];\n        collector.addRule(`.monaco-editor .${colorProvider.getInlineClassNameOfLevel(level)} { color: ${color}; }`);\n    }\n});\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { LanguageAgnosticBracketTokens } from './bracketPairsTree/brackets.js';\nimport { lengthAdd, lengthGetColumnCountIfZeroLineCount, lengthZero } from './bracketPairsTree/length.js';\nimport { parseDocument } from './bracketPairsTree/parser.js';\nimport { DenseKeyProvider } from './bracketPairsTree/smallImmutableSet.js';\nimport { TextBufferTokenizer } from './bracketPairsTree/tokenizer.js';\nexport function fixBracketsInLine(tokens, languageConfigurationService) {\n    const denseKeyProvider = new DenseKeyProvider();\n    const bracketTokens = new LanguageAgnosticBracketTokens(denseKeyProvider, (languageId) => languageConfigurationService.getLanguageConfiguration(languageId));\n    const tokenizer = new TextBufferTokenizer(new StaticTokenizerSource([tokens]), bracketTokens);\n    const node = parseDocument(tokenizer, [], undefined, true);\n    let str = '';\n    const line = tokens.getLineContent();\n    function processNode(node, offset) {\n        if (node.kind === 2 /* AstNodeKind.Pair */) {\n            processNode(node.openingBracket, offset);\n            offset = lengthAdd(offset, node.openingBracket.length);\n            if (node.child) {\n                processNode(node.child, offset);\n                offset = lengthAdd(offset, node.child.length);\n            }\n            if (node.closingBracket) {\n                processNode(node.closingBracket, offset);\n                offset = lengthAdd(offset, node.closingBracket.length);\n            }\n            else {\n                const singleLangBracketTokens = bracketTokens.getSingleLanguageBracketTokens(node.openingBracket.languageId);\n                const closingTokenText = singleLangBracketTokens.findClosingTokenText(node.openingBracket.bracketIds);\n                str += closingTokenText;\n            }\n        }\n        else if (node.kind === 3 /* AstNodeKind.UnexpectedClosingBracket */) {\n            // remove the bracket\n        }\n        else if (node.kind === 0 /* AstNodeKind.Text */ || node.kind === 1 /* AstNodeKind.Bracket */) {\n            str += line.substring(lengthGetColumnCountIfZeroLineCount(offset), lengthGetColumnCountIfZeroLineCount(lengthAdd(offset, node.length)));\n        }\n        else if (node.kind === 4 /* AstNodeKind.List */) {\n            for (const child of node.children) {\n                processNode(child, offset);\n                offset = lengthAdd(offset, child.length);\n            }\n        }\n    }\n    processNode(node, lengthZero);\n    return str;\n}\nclass StaticTokenizerSource {\n    constructor(lines) {\n        this.lines = lines;\n        this.tokenization = {\n            getLineTokens: (lineNumber) => {\n                return this.lines[lineNumber - 1];\n            }\n        };\n    }\n    getLineCount() {\n        return this.lines.length;\n    }\n    getLineLength(lineNumber) {\n        return this.lines[lineNumber - 1].getLineContent().length;\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport * as nls from '../../../nls.js';\nimport { onUnexpectedError } from '../../../base/common/errors.js';\nimport { Selection } from '../core/selection.js';\nimport { URI } from '../../../base/common/uri.js';\nimport { TextChange, compressConsecutiveTextChanges } from '../core/textChange.js';\nimport * as buffer from '../../../base/common/buffer.js';\nimport { basename } from '../../../base/common/resources.js';\nfunction uriGetComparisonKey(resource) {\n    return resource.toString();\n}\nexport class SingleModelEditStackData {\n    static create(model, beforeCursorState) {\n        const alternativeVersionId = model.getAlternativeVersionId();\n        const eol = getModelEOL(model);\n        return new SingleModelEditStackData(alternativeVersionId, alternativeVersionId, eol, eol, beforeCursorState, beforeCursorState, []);\n    }\n    constructor(beforeVersionId, afterVersionId, beforeEOL, afterEOL, beforeCursorState, afterCursorState, changes) {\n        this.beforeVersionId = beforeVersionId;\n        this.afterVersionId = afterVersionId;\n        this.beforeEOL = beforeEOL;\n        this.afterEOL = afterEOL;\n        this.beforeCursorState = beforeCursorState;\n        this.afterCursorState = afterCursorState;\n        this.changes = changes;\n    }\n    append(model, textChanges, afterEOL, afterVersionId, afterCursorState) {\n        if (textChanges.length > 0) {\n            this.changes = compressConsecutiveTextChanges(this.changes, textChanges);\n        }\n        this.afterEOL = afterEOL;\n        this.afterVersionId = afterVersionId;\n        this.afterCursorState = afterCursorState;\n    }\n    static _writeSelectionsSize(selections) {\n        return 4 + 4 * 4 * (selections ? selections.length : 0);\n    }\n    static _writeSelections(b, selections, offset) {\n        buffer.writeUInt32BE(b, (selections ? selections.length : 0), offset);\n        offset += 4;\n        if (selections) {\n            for (const selection of selections) {\n                buffer.writeUInt32BE(b, selection.selectionStartLineNumber, offset);\n                offset += 4;\n                buffer.writeUInt32BE(b, selection.selectionStartColumn, offset);\n                offset += 4;\n                buffer.writeUInt32BE(b, selection.positionLineNumber, offset);\n                offset += 4;\n                buffer.writeUInt32BE(b, selection.positionColumn, offset);\n                offset += 4;\n            }\n        }\n        return offset;\n    }\n    static _readSelections(b, offset, dest) {\n        const count = buffer.readUInt32BE(b, offset);\n        offset += 4;\n        for (let i = 0; i < count; i++) {\n            const selectionStartLineNumber = buffer.readUInt32BE(b, offset);\n            offset += 4;\n            const selectionStartColumn = buffer.readUInt32BE(b, offset);\n            offset += 4;\n            const positionLineNumber = buffer.readUInt32BE(b, offset);\n            offset += 4;\n            const positionColumn = buffer.readUInt32BE(b, offset);\n            offset += 4;\n            dest.push(new Selection(selectionStartLineNumber, selectionStartColumn, positionLineNumber, positionColumn));\n        }\n        return offset;\n    }\n    serialize() {\n        let necessarySize = (+4 // beforeVersionId\n            + 4 // afterVersionId\n            + 1 // beforeEOL\n            + 1 // afterEOL\n            + SingleModelEditStackData._writeSelectionsSize(this.beforeCursorState)\n            + SingleModelEditStackData._writeSelectionsSize(this.afterCursorState)\n            + 4 // change count\n        );\n        for (const change of this.changes) {\n            necessarySize += change.writeSize();\n        }\n        const b = new Uint8Array(necessarySize);\n        let offset = 0;\n        buffer.writeUInt32BE(b, this.beforeVersionId, offset);\n        offset += 4;\n        buffer.writeUInt32BE(b, this.afterVersionId, offset);\n        offset += 4;\n        buffer.writeUInt8(b, this.beforeEOL, offset);\n        offset += 1;\n        buffer.writeUInt8(b, this.afterEOL, offset);\n        offset += 1;\n        offset = SingleModelEditStackData._writeSelections(b, this.beforeCursorState, offset);\n        offset = SingleModelEditStackData._writeSelections(b, this.afterCursorState, offset);\n        buffer.writeUInt32BE(b, this.changes.length, offset);\n        offset += 4;\n        for (const change of this.changes) {\n            offset = change.write(b, offset);\n        }\n        return b.buffer;\n    }\n    static deserialize(source) {\n        const b = new Uint8Array(source);\n        let offset = 0;\n        const beforeVersionId = buffer.readUInt32BE(b, offset);\n        offset += 4;\n        const afterVersionId = buffer.readUInt32BE(b, offset);\n        offset += 4;\n        const beforeEOL = buffer.readUInt8(b, offset);\n        offset += 1;\n        const afterEOL = buffer.readUInt8(b, offset);\n        offset += 1;\n        const beforeCursorState = [];\n        offset = SingleModelEditStackData._readSelections(b, offset, beforeCursorState);\n        const afterCursorState = [];\n        offset = SingleModelEditStackData._readSelections(b, offset, afterCursorState);\n        const changeCount = buffer.readUInt32BE(b, offset);\n        offset += 4;\n        const changes = [];\n        for (let i = 0; i < changeCount; i++) {\n            offset = TextChange.read(b, offset, changes);\n        }\n        return new SingleModelEditStackData(beforeVersionId, afterVersionId, beforeEOL, afterEOL, beforeCursorState, afterCursorState, changes);\n    }\n}\nexport class SingleModelEditStackElement {\n    get type() {\n        return 0 /* UndoRedoElementType.Resource */;\n    }\n    get resource() {\n        if (URI.isUri(this.model)) {\n            return this.model;\n        }\n        return this.model.uri;\n    }\n    constructor(label, code, model, beforeCursorState) {\n        this.label = label;\n        this.code = code;\n        this.model = model;\n        this._data = SingleModelEditStackData.create(model, beforeCursorState);\n    }\n    toString() {\n        const data = (this._data instanceof SingleModelEditStackData ? this._data : SingleModelEditStackData.deserialize(this._data));\n        return data.changes.map(change => change.toString()).join(', ');\n    }\n    matchesResource(resource) {\n        const uri = (URI.isUri(this.model) ? this.model : this.model.uri);\n        return (uri.toString() === resource.toString());\n    }\n    setModel(model) {\n        this.model = model;\n    }\n    canAppend(model) {\n        return (this.model === model && this._data instanceof SingleModelEditStackData);\n    }\n    append(model, textChanges, afterEOL, afterVersionId, afterCursorState) {\n        if (this._data instanceof SingleModelEditStackData) {\n            this._data.append(model, textChanges, afterEOL, afterVersionId, afterCursorState);\n        }\n    }\n    close() {\n        if (this._data instanceof SingleModelEditStackData) {\n            this._data = this._data.serialize();\n        }\n    }\n    open() {\n        if (!(this._data instanceof SingleModelEditStackData)) {\n            this._data = SingleModelEditStackData.deserialize(this._data);\n        }\n    }\n    undo() {\n        if (URI.isUri(this.model)) {\n            // don't have a model\n            throw new Error(`Invalid SingleModelEditStackElement`);\n        }\n        if (this._data instanceof SingleModelEditStackData) {\n            this._data = this._data.serialize();\n        }\n        const data = SingleModelEditStackData.deserialize(this._data);\n        this.model._applyUndo(data.changes, data.beforeEOL, data.beforeVersionId, data.beforeCursorState);\n    }\n    redo() {\n        if (URI.isUri(this.model)) {\n            // don't have a model\n            throw new Error(`Invalid SingleModelEditStackElement`);\n        }\n        if (this._data instanceof SingleModelEditStackData) {\n            this._data = this._data.serialize();\n        }\n        const data = SingleModelEditStackData.deserialize(this._data);\n        this.model._applyRedo(data.changes, data.afterEOL, data.afterVersionId, data.afterCursorState);\n    }\n    heapSize() {\n        if (this._data instanceof SingleModelEditStackData) {\n            this._data = this._data.serialize();\n        }\n        return this._data.byteLength + 168 /*heap overhead*/;\n    }\n}\nexport class MultiModelEditStackElement {\n    get resources() {\n        return this._editStackElementsArr.map(editStackElement => editStackElement.resource);\n    }\n    constructor(label, code, editStackElements) {\n        this.label = label;\n        this.code = code;\n        this.type = 1 /* UndoRedoElementType.Workspace */;\n        this._isOpen = true;\n        this._editStackElementsArr = editStackElements.slice(0);\n        this._editStackElementsMap = new Map();\n        for (const editStackElement of this._editStackElementsArr) {\n            const key = uriGetComparisonKey(editStackElement.resource);\n            this._editStackElementsMap.set(key, editStackElement);\n        }\n        this._delegate = null;\n    }\n    prepareUndoRedo() {\n        if (this._delegate) {\n            return this._delegate.prepareUndoRedo(this);\n        }\n    }\n    matchesResource(resource) {\n        const key = uriGetComparisonKey(resource);\n        return (this._editStackElementsMap.has(key));\n    }\n    setModel(model) {\n        const key = uriGetComparisonKey(URI.isUri(model) ? model : model.uri);\n        if (this._editStackElementsMap.has(key)) {\n            this._editStackElementsMap.get(key).setModel(model);\n        }\n    }\n    canAppend(model) {\n        if (!this._isOpen) {\n            return false;\n        }\n        const key = uriGetComparisonKey(model.uri);\n        if (this._editStackElementsMap.has(key)) {\n            const editStackElement = this._editStackElementsMap.get(key);\n            return editStackElement.canAppend(model);\n        }\n        return false;\n    }\n    append(model, textChanges, afterEOL, afterVersionId, afterCursorState) {\n        const key = uriGetComparisonKey(model.uri);\n        const editStackElement = this._editStackElementsMap.get(key);\n        editStackElement.append(model, textChanges, afterEOL, afterVersionId, afterCursorState);\n    }\n    close() {\n        this._isOpen = false;\n    }\n    open() {\n        // cannot reopen\n    }\n    undo() {\n        this._isOpen = false;\n        for (const editStackElement of this._editStackElementsArr) {\n            editStackElement.undo();\n        }\n    }\n    redo() {\n        for (const editStackElement of this._editStackElementsArr) {\n            editStackElement.redo();\n        }\n    }\n    heapSize(resource) {\n        const key = uriGetComparisonKey(resource);\n        if (this._editStackElementsMap.has(key)) {\n            const editStackElement = this._editStackElementsMap.get(key);\n            return editStackElement.heapSize();\n        }\n        return 0;\n    }\n    split() {\n        return this._editStackElementsArr;\n    }\n    toString() {\n        const result = [];\n        for (const editStackElement of this._editStackElementsArr) {\n            result.push(`${basename(editStackElement.resource)}: ${editStackElement}`);\n        }\n        return `{${result.join(', ')}}`;\n    }\n}\nfunction getModelEOL(model) {\n    const eol = model.getEOL();\n    if (eol === '\\n') {\n        return 0 /* EndOfLineSequence.LF */;\n    }\n    else {\n        return 1 /* EndOfLineSequence.CRLF */;\n    }\n}\nexport function isEditStackElement(element) {\n    if (!element) {\n        return false;\n    }\n    return ((element instanceof SingleModelEditStackElement) || (element instanceof MultiModelEditStackElement));\n}\nexport class EditStack {\n    constructor(model, undoRedoService) {\n        this._model = model;\n        this._undoRedoService = undoRedoService;\n    }\n    pushStackElement() {\n        const lastElement = this._undoRedoService.getLastElement(this._model.uri);\n        if (isEditStackElement(lastElement)) {\n            lastElement.close();\n        }\n    }\n    popStackElement() {\n        const lastElement = this._undoRedoService.getLastElement(this._model.uri);\n        if (isEditStackElement(lastElement)) {\n            lastElement.open();\n        }\n    }\n    clear() {\n        this._undoRedoService.removeElements(this._model.uri);\n    }\n    _getOrCreateEditStackElement(beforeCursorState, group) {\n        const lastElement = this._undoRedoService.getLastElement(this._model.uri);\n        if (isEditStackElement(lastElement) && lastElement.canAppend(this._model)) {\n            return lastElement;\n        }\n        const newElement = new SingleModelEditStackElement(nls.localize('edit', \"Typing\"), 'undoredo.textBufferEdit', this._model, beforeCursorState);\n        this._undoRedoService.pushElement(newElement, group);\n        return newElement;\n    }\n    pushEOL(eol) {\n        const editStackElement = this._getOrCreateEditStackElement(null, undefined);\n        this._model.setEOL(eol);\n        editStackElement.append(this._model, [], getModelEOL(this._model), this._model.getAlternativeVersionId(), null);\n    }\n    pushEditOperation(beforeCursorState, editOperations, cursorStateComputer, group) {\n        const editStackElement = this._getOrCreateEditStackElement(beforeCursorState, group);\n        const inverseEditOperations = this._model.applyEdits(editOperations, true);\n        const afterCursorState = EditStack._computeCursorState(cursorStateComputer, inverseEditOperations);\n        const textChanges = inverseEditOperations.map((op, index) => ({ index: index, textChange: op.textChange }));\n        textChanges.sort((a, b) => {\n            if (a.textChange.oldPosition === b.textChange.oldPosition) {\n                return a.index - b.index;\n            }\n            return a.textChange.oldPosition - b.textChange.oldPosition;\n        });\n        editStackElement.append(this._model, textChanges.map(op => op.textChange), getModelEOL(this._model), this._model.getAlternativeVersionId(), afterCursorState);\n        return afterCursorState;\n    }\n    static _computeCursorState(cursorStateComputer, inverseEditOperations) {\n        try {\n            return cursorStateComputer ? cursorStateComputer(inverseEditOperations) : null;\n        }\n        catch (e) {\n            onUnexpectedError(e);\n            return null;\n        }\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { arrayInsert } from '../../../base/common/arrays.js';\n/**\n * An array that avoids being sparse by always\n * filling up unused indices with a default value.\n */\nexport class FixedArray {\n    constructor(_default) {\n        this._default = _default;\n        this._store = [];\n    }\n    get(index) {\n        if (index < this._store.length) {\n            return this._store[index];\n        }\n        return this._default;\n    }\n    set(index, value) {\n        while (index >= this._store.length) {\n            this._store[this._store.length] = this._default;\n        }\n        this._store[index] = value;\n    }\n    replace(index, oldLength, newLength) {\n        if (index >= this._store.length) {\n            return;\n        }\n        if (oldLength === 0) {\n            this.insert(index, newLength);\n            return;\n        }\n        else if (newLength === 0) {\n            this.delete(index, oldLength);\n            return;\n        }\n        const before = this._store.slice(0, index);\n        const after = this._store.slice(index + oldLength);\n        const insertArr = arrayFill(newLength, this._default);\n        this._store = before.concat(insertArr, after);\n    }\n    delete(deleteIndex, deleteCount) {\n        if (deleteCount === 0 || deleteIndex >= this._store.length) {\n            return;\n        }\n        this._store.splice(deleteIndex, deleteCount);\n    }\n    insert(insertIndex, insertCount) {\n        if (insertCount === 0 || insertIndex >= this._store.length) {\n            return;\n        }\n        const arr = [];\n        for (let i = 0; i < insertCount; i++) {\n            arr[i] = this._default;\n        }\n        this._store = arrayInsert(this._store, insertIndex, arr);\n    }\n}\nfunction arrayFill(length, value) {\n    const arr = [];\n    for (let i = 0; i < length; i++) {\n        arr[i] = value;\n    }\n    return arr;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { findLast } from '../../../base/common/arraysFind.js';\nimport * as strings from '../../../base/common/strings.js';\nimport { CursorColumns } from '../core/cursorColumns.js';\nimport { Range } from '../core/range.js';\nimport { TextModelPart } from './textModelPart.js';\nimport { computeIndentLevel } from './utils.js';\nimport { HorizontalGuidesState, IndentGuide, IndentGuideHorizontalLine } from '../textModelGuides.js';\nimport { BugIndicatingError } from '../../../base/common/errors.js';\nexport class GuidesTextModelPart extends TextModelPart {\n    constructor(textModel, languageConfigurationService) {\n        super();\n        this.textModel = textModel;\n        this.languageConfigurationService = languageConfigurationService;\n    }\n    getLanguageConfiguration(languageId) {\n        return this.languageConfigurationService.getLanguageConfiguration(languageId);\n    }\n    _computeIndentLevel(lineIndex) {\n        return computeIndentLevel(this.textModel.getLineContent(lineIndex + 1), this.textModel.getOptions().tabSize);\n    }\n    getActiveIndentGuide(lineNumber, minLineNumber, maxLineNumber) {\n        this.assertNotDisposed();\n        const lineCount = this.textModel.getLineCount();\n        if (lineNumber < 1 || lineNumber > lineCount) {\n            throw new BugIndicatingError('Illegal value for lineNumber');\n        }\n        const foldingRules = this.getLanguageConfiguration(this.textModel.getLanguageId()).foldingRules;\n        const offSide = Boolean(foldingRules && foldingRules.offSide);\n        let up_aboveContentLineIndex = -2; /* -2 is a marker for not having computed it */\n        let up_aboveContentLineIndent = -1;\n        let up_belowContentLineIndex = -2; /* -2 is a marker for not having computed it */\n        let up_belowContentLineIndent = -1;\n        const up_resolveIndents = (lineNumber) => {\n            if (up_aboveContentLineIndex !== -1 &&\n                (up_aboveContentLineIndex === -2 ||\n                    up_aboveContentLineIndex > lineNumber - 1)) {\n                up_aboveContentLineIndex = -1;\n                up_aboveContentLineIndent = -1;\n                // must find previous line with content\n                for (let lineIndex = lineNumber - 2; lineIndex >= 0; lineIndex--) {\n                    const indent = this._computeIndentLevel(lineIndex);\n                    if (indent >= 0) {\n                        up_aboveContentLineIndex = lineIndex;\n                        up_aboveContentLineIndent = indent;\n                        break;\n                    }\n                }\n            }\n            if (up_belowContentLineIndex === -2) {\n                up_belowContentLineIndex = -1;\n                up_belowContentLineIndent = -1;\n                // must find next line with content\n                for (let lineIndex = lineNumber; lineIndex < lineCount; lineIndex++) {\n                    const indent = this._computeIndentLevel(lineIndex);\n                    if (indent >= 0) {\n                        up_belowContentLineIndex = lineIndex;\n                        up_belowContentLineIndent = indent;\n                        break;\n                    }\n                }\n            }\n        };\n        let down_aboveContentLineIndex = -2; /* -2 is a marker for not having computed it */\n        let down_aboveContentLineIndent = -1;\n        let down_belowContentLineIndex = -2; /* -2 is a marker for not having computed it */\n        let down_belowContentLineIndent = -1;\n        const down_resolveIndents = (lineNumber) => {\n            if (down_aboveContentLineIndex === -2) {\n                down_aboveContentLineIndex = -1;\n                down_aboveContentLineIndent = -1;\n                // must find previous line with content\n                for (let lineIndex = lineNumber - 2; lineIndex >= 0; lineIndex--) {\n                    const indent = this._computeIndentLevel(lineIndex);\n                    if (indent >= 0) {\n                        down_aboveContentLineIndex = lineIndex;\n                        down_aboveContentLineIndent = indent;\n                        break;\n                    }\n                }\n            }\n            if (down_belowContentLineIndex !== -1 &&\n                (down_belowContentLineIndex === -2 ||\n                    down_belowContentLineIndex < lineNumber - 1)) {\n                down_belowContentLineIndex = -1;\n                down_belowContentLineIndent = -1;\n                // must find next line with content\n                for (let lineIndex = lineNumber; lineIndex < lineCount; lineIndex++) {\n                    const indent = this._computeIndentLevel(lineIndex);\n                    if (indent >= 0) {\n                        down_belowContentLineIndex = lineIndex;\n                        down_belowContentLineIndent = indent;\n                        break;\n                    }\n                }\n            }\n        };\n        let startLineNumber = 0;\n        let goUp = true;\n        let endLineNumber = 0;\n        let goDown = true;\n        let indent = 0;\n        let initialIndent = 0;\n        for (let distance = 0; goUp || goDown; distance++) {\n            const upLineNumber = lineNumber - distance;\n            const downLineNumber = lineNumber + distance;\n            if (distance > 1 && (upLineNumber < 1 || upLineNumber < minLineNumber)) {\n                goUp = false;\n            }\n            if (distance > 1 &&\n                (downLineNumber > lineCount || downLineNumber > maxLineNumber)) {\n                goDown = false;\n            }\n            if (distance > 50000) {\n                // stop processing\n                goUp = false;\n                goDown = false;\n            }\n            let upLineIndentLevel = -1;\n            if (goUp && upLineNumber >= 1) {\n                // compute indent level going up\n                const currentIndent = this._computeIndentLevel(upLineNumber - 1);\n                if (currentIndent >= 0) {\n                    // This line has content (besides whitespace)\n                    // Use the line's indent\n                    up_belowContentLineIndex = upLineNumber - 1;\n                    up_belowContentLineIndent = currentIndent;\n                    upLineIndentLevel = Math.ceil(currentIndent / this.textModel.getOptions().indentSize);\n                }\n                else {\n                    up_resolveIndents(upLineNumber);\n                    upLineIndentLevel = this._getIndentLevelForWhitespaceLine(offSide, up_aboveContentLineIndent, up_belowContentLineIndent);\n                }\n            }\n            let downLineIndentLevel = -1;\n            if (goDown && downLineNumber <= lineCount) {\n                // compute indent level going down\n                const currentIndent = this._computeIndentLevel(downLineNumber - 1);\n                if (currentIndent >= 0) {\n                    // This line has content (besides whitespace)\n                    // Use the line's indent\n                    down_aboveContentLineIndex = downLineNumber - 1;\n                    down_aboveContentLineIndent = currentIndent;\n                    downLineIndentLevel = Math.ceil(currentIndent / this.textModel.getOptions().indentSize);\n                }\n                else {\n                    down_resolveIndents(downLineNumber);\n                    downLineIndentLevel = this._getIndentLevelForWhitespaceLine(offSide, down_aboveContentLineIndent, down_belowContentLineIndent);\n                }\n            }\n            if (distance === 0) {\n                initialIndent = upLineIndentLevel;\n                continue;\n            }\n            if (distance === 1) {\n                if (downLineNumber <= lineCount &&\n                    downLineIndentLevel >= 0 &&\n                    initialIndent + 1 === downLineIndentLevel) {\n                    // This is the beginning of a scope, we have special handling here, since we want the\n                    // child scope indent to be active, not the parent scope\n                    goUp = false;\n                    startLineNumber = downLineNumber;\n                    endLineNumber = downLineNumber;\n                    indent = downLineIndentLevel;\n                    continue;\n                }\n                if (upLineNumber >= 1 &&\n                    upLineIndentLevel >= 0 &&\n                    upLineIndentLevel - 1 === initialIndent) {\n                    // This is the end of a scope, just like above\n                    goDown = false;\n                    startLineNumber = upLineNumber;\n                    endLineNumber = upLineNumber;\n                    indent = upLineIndentLevel;\n                    continue;\n                }\n                startLineNumber = lineNumber;\n                endLineNumber = lineNumber;\n                indent = initialIndent;\n                if (indent === 0) {\n                    // No need to continue\n                    return { startLineNumber, endLineNumber, indent };\n                }\n            }\n            if (goUp) {\n                if (upLineIndentLevel >= indent) {\n                    startLineNumber = upLineNumber;\n                }\n                else {\n                    goUp = false;\n                }\n            }\n            if (goDown) {\n                if (downLineIndentLevel >= indent) {\n                    endLineNumber = downLineNumber;\n                }\n                else {\n                    goDown = false;\n                }\n            }\n        }\n        return { startLineNumber, endLineNumber, indent };\n    }\n    getLinesBracketGuides(startLineNumber, endLineNumber, activePosition, options) {\n        var _a;\n        const result = [];\n        for (let lineNumber = startLineNumber; lineNumber <= endLineNumber; lineNumber++) {\n            result.push([]);\n        }\n        // If requested, this could be made configurable.\n        const includeSingleLinePairs = true;\n        const bracketPairs = this.textModel.bracketPairs.getBracketPairsInRangeWithMinIndentation(new Range(startLineNumber, 1, endLineNumber, this.textModel.getLineMaxColumn(endLineNumber))).toArray();\n        let activeBracketPairRange = undefined;\n        if (activePosition && bracketPairs.length > 0) {\n            const bracketsContainingActivePosition = (startLineNumber <= activePosition.lineNumber &&\n                activePosition.lineNumber <= endLineNumber\n                // We don't need to query the brackets again if the cursor is in the viewport\n                ? bracketPairs\n                : this.textModel.bracketPairs.getBracketPairsInRange(Range.fromPositions(activePosition)).toArray()).filter((bp) => Range.strictContainsPosition(bp.range, activePosition));\n            activeBracketPairRange = (_a = findLast(bracketsContainingActivePosition, (i) => includeSingleLinePairs || i.range.startLineNumber !== i.range.endLineNumber)) === null || _a === void 0 ? void 0 : _a.range;\n        }\n        const independentColorPoolPerBracketType = this.textModel.getOptions().bracketPairColorizationOptions.independentColorPoolPerBracketType;\n        const colorProvider = new BracketPairGuidesClassNames();\n        for (const pair of bracketPairs) {\n            /*\n\n\n                    {\n                    |\n                    }\n\n                    {\n                    |\n                    ----}\n\n                ____{\n                |test\n                ----}\n\n                renderHorizontalEndLineAtTheBottom:\n                    {\n                    |\n                    |x}\n                    --\n                renderHorizontalEndLineAtTheBottom:\n                ____{\n                |test\n                | x }\n                ----\n            */\n            if (!pair.closingBracketRange) {\n                continue;\n            }\n            const isActive = activeBracketPairRange && pair.range.equalsRange(activeBracketPairRange);\n            if (!isActive && !options.includeInactive) {\n                continue;\n            }\n            const className = colorProvider.getInlineClassName(pair.nestingLevel, pair.nestingLevelOfEqualBracketType, independentColorPoolPerBracketType) +\n                (options.highlightActive && isActive\n                    ? ' ' + colorProvider.activeClassName\n                    : '');\n            const start = pair.openingBracketRange.getStartPosition();\n            const end = pair.closingBracketRange.getStartPosition();\n            const horizontalGuides = options.horizontalGuides === HorizontalGuidesState.Enabled || (options.horizontalGuides === HorizontalGuidesState.EnabledForActive && isActive);\n            if (pair.range.startLineNumber === pair.range.endLineNumber) {\n                if (includeSingleLinePairs && horizontalGuides) {\n                    result[pair.range.startLineNumber - startLineNumber].push(new IndentGuide(-1, pair.openingBracketRange.getEndPosition().column, className, new IndentGuideHorizontalLine(false, end.column), -1, -1));\n                }\n                continue;\n            }\n            const endVisibleColumn = this.getVisibleColumnFromPosition(end);\n            const startVisibleColumn = this.getVisibleColumnFromPosition(pair.openingBracketRange.getStartPosition());\n            const guideVisibleColumn = Math.min(startVisibleColumn, endVisibleColumn, pair.minVisibleColumnIndentation + 1);\n            let renderHorizontalEndLineAtTheBottom = false;\n            const firstNonWsIndex = strings.firstNonWhitespaceIndex(this.textModel.getLineContent(pair.closingBracketRange.startLineNumber));\n            const hasTextBeforeClosingBracket = firstNonWsIndex < pair.closingBracketRange.startColumn - 1;\n            if (hasTextBeforeClosingBracket) {\n                renderHorizontalEndLineAtTheBottom = true;\n            }\n            const visibleGuideStartLineNumber = Math.max(start.lineNumber, startLineNumber);\n            const visibleGuideEndLineNumber = Math.min(end.lineNumber, endLineNumber);\n            const offset = renderHorizontalEndLineAtTheBottom ? 1 : 0;\n            for (let l = visibleGuideStartLineNumber; l < visibleGuideEndLineNumber + offset; l++) {\n                result[l - startLineNumber].push(new IndentGuide(guideVisibleColumn, -1, className, null, l === start.lineNumber ? start.column : -1, l === end.lineNumber ? end.column : -1));\n            }\n            if (horizontalGuides) {\n                if (start.lineNumber >= startLineNumber && startVisibleColumn > guideVisibleColumn) {\n                    result[start.lineNumber - startLineNumber].push(new IndentGuide(guideVisibleColumn, -1, className, new IndentGuideHorizontalLine(false, start.column), -1, -1));\n                }\n                if (end.lineNumber <= endLineNumber && endVisibleColumn > guideVisibleColumn) {\n                    result[end.lineNumber - startLineNumber].push(new IndentGuide(guideVisibleColumn, -1, className, new IndentGuideHorizontalLine(!renderHorizontalEndLineAtTheBottom, end.column), -1, -1));\n                }\n            }\n        }\n        for (const guides of result) {\n            guides.sort((a, b) => a.visibleColumn - b.visibleColumn);\n        }\n        return result;\n    }\n    getVisibleColumnFromPosition(position) {\n        return (CursorColumns.visibleColumnFromColumn(this.textModel.getLineContent(position.lineNumber), position.column, this.textModel.getOptions().tabSize) + 1);\n    }\n    getLinesIndentGuides(startLineNumber, endLineNumber) {\n        this.assertNotDisposed();\n        const lineCount = this.textModel.getLineCount();\n        if (startLineNumber < 1 || startLineNumber > lineCount) {\n            throw new Error('Illegal value for startLineNumber');\n        }\n        if (endLineNumber < 1 || endLineNumber > lineCount) {\n            throw new Error('Illegal value for endLineNumber');\n        }\n        const options = this.textModel.getOptions();\n        const foldingRules = this.getLanguageConfiguration(this.textModel.getLanguageId()).foldingRules;\n        const offSide = Boolean(foldingRules && foldingRules.offSide);\n        const result = new Array(endLineNumber - startLineNumber + 1);\n        let aboveContentLineIndex = -2; /* -2 is a marker for not having computed it */\n        let aboveContentLineIndent = -1;\n        let belowContentLineIndex = -2; /* -2 is a marker for not having computed it */\n        let belowContentLineIndent = -1;\n        for (let lineNumber = startLineNumber; lineNumber <= endLineNumber; lineNumber++) {\n            const resultIndex = lineNumber - startLineNumber;\n            const currentIndent = this._computeIndentLevel(lineNumber - 1);\n            if (currentIndent >= 0) {\n                // This line has content (besides whitespace)\n                // Use the line's indent\n                aboveContentLineIndex = lineNumber - 1;\n                aboveContentLineIndent = currentIndent;\n                result[resultIndex] = Math.ceil(currentIndent / options.indentSize);\n                continue;\n            }\n            if (aboveContentLineIndex === -2) {\n                aboveContentLineIndex = -1;\n                aboveContentLineIndent = -1;\n                // must find previous line with content\n                for (let lineIndex = lineNumber - 2; lineIndex >= 0; lineIndex--) {\n                    const indent = this._computeIndentLevel(lineIndex);\n                    if (indent >= 0) {\n                        aboveContentLineIndex = lineIndex;\n                        aboveContentLineIndent = indent;\n                        break;\n                    }\n                }\n            }\n            if (belowContentLineIndex !== -1 &&\n                (belowContentLineIndex === -2 || belowContentLineIndex < lineNumber - 1)) {\n                belowContentLineIndex = -1;\n                belowContentLineIndent = -1;\n                // must find next line with content\n                for (let lineIndex = lineNumber; lineIndex < lineCount; lineIndex++) {\n                    const indent = this._computeIndentLevel(lineIndex);\n                    if (indent >= 0) {\n                        belowContentLineIndex = lineIndex;\n                        belowContentLineIndent = indent;\n                        break;\n                    }\n                }\n            }\n            result[resultIndex] = this._getIndentLevelForWhitespaceLine(offSide, aboveContentLineIndent, belowContentLineIndent);\n        }\n        return result;\n    }\n    _getIndentLevelForWhitespaceLine(offSide, aboveContentLineIndent, belowContentLineIndent) {\n        const options = this.textModel.getOptions();\n        if (aboveContentLineIndent === -1 || belowContentLineIndent === -1) {\n            // At the top or bottom of the file\n            return 0;\n        }\n        else if (aboveContentLineIndent < belowContentLineIndent) {\n            // we are inside the region above\n            return 1 + Math.floor(aboveContentLineIndent / options.indentSize);\n        }\n        else if (aboveContentLineIndent === belowContentLineIndent) {\n            // we are in between two regions\n            return Math.ceil(belowContentLineIndent / options.indentSize);\n        }\n        else {\n            if (offSide) {\n                // same level as region below\n                return Math.ceil(belowContentLineIndent / options.indentSize);\n            }\n            else {\n                // we are inside the region that ends below\n                return 1 + Math.floor(belowContentLineIndent / options.indentSize);\n            }\n        }\n    }\n}\nexport class BracketPairGuidesClassNames {\n    constructor() {\n        this.activeClassName = 'indent-active';\n    }\n    getInlineClassName(nestingLevel, nestingLevelOfEqualBracketType, independentColorPoolPerBracketType) {\n        return this.getInlineClassNameOfLevel(independentColorPoolPerBracketType ? nestingLevelOfEqualBracketType : nestingLevel);\n    }\n    getInlineClassNameOfLevel(level) {\n        // To support a dynamic amount of colors up to 6 colors,\n        // we use a number that is a lcm of all numbers from 1 to 6.\n        return `bracket-indent-guide lvl-${level % 30}`;\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nclass SpacesDiffResult {\n    constructor() {\n        this.spacesDiff = 0;\n        this.looksLikeAlignment = false;\n    }\n}\n/**\n * Compute the diff in spaces between two line's indentation.\n */\nfunction spacesDiff(a, aLength, b, bLength, result) {\n    result.spacesDiff = 0;\n    result.looksLikeAlignment = false;\n    // This can go both ways (e.g.):\n    //  - a: \"\\t\"\n    //  - b: \"\\t    \"\n    //  => This should count 1 tab and 4 spaces\n    let i;\n    for (i = 0; i < aLength && i < bLength; i++) {\n        const aCharCode = a.charCodeAt(i);\n        const bCharCode = b.charCodeAt(i);\n        if (aCharCode !== bCharCode) {\n            break;\n        }\n    }\n    let aSpacesCnt = 0, aTabsCount = 0;\n    for (let j = i; j < aLength; j++) {\n        const aCharCode = a.charCodeAt(j);\n        if (aCharCode === 32 /* CharCode.Space */) {\n            aSpacesCnt++;\n        }\n        else {\n            aTabsCount++;\n        }\n    }\n    let bSpacesCnt = 0, bTabsCount = 0;\n    for (let j = i; j < bLength; j++) {\n        const bCharCode = b.charCodeAt(j);\n        if (bCharCode === 32 /* CharCode.Space */) {\n            bSpacesCnt++;\n        }\n        else {\n            bTabsCount++;\n        }\n    }\n    if (aSpacesCnt > 0 && aTabsCount > 0) {\n        return;\n    }\n    if (bSpacesCnt > 0 && bTabsCount > 0) {\n        return;\n    }\n    const tabsDiff = Math.abs(aTabsCount - bTabsCount);\n    const spacesDiff = Math.abs(aSpacesCnt - bSpacesCnt);\n    if (tabsDiff === 0) {\n        // check if the indentation difference might be caused by alignment reasons\n        // sometime folks like to align their code, but this should not be used as a hint\n        result.spacesDiff = spacesDiff;\n        if (spacesDiff > 0 && 0 <= bSpacesCnt - 1 && bSpacesCnt - 1 < a.length && bSpacesCnt < b.length) {\n            if (b.charCodeAt(bSpacesCnt) !== 32 /* CharCode.Space */ && a.charCodeAt(bSpacesCnt - 1) === 32 /* CharCode.Space */) {\n                if (a.charCodeAt(a.length - 1) === 44 /* CharCode.Comma */) {\n                    // This looks like an alignment desire: e.g.\n                    // const a = b + c,\n                    //       d = b - c;\n                    result.looksLikeAlignment = true;\n                }\n            }\n        }\n        return;\n    }\n    if (spacesDiff % tabsDiff === 0) {\n        result.spacesDiff = spacesDiff / tabsDiff;\n        return;\n    }\n}\nexport function guessIndentation(source, defaultTabSize, defaultInsertSpaces) {\n    // Look at most at the first 10k lines\n    const linesCount = Math.min(source.getLineCount(), 10000);\n    let linesIndentedWithTabsCount = 0; // number of lines that contain at least one tab in indentation\n    let linesIndentedWithSpacesCount = 0; // number of lines that contain only spaces in indentation\n    let previousLineText = ''; // content of latest line that contained non-whitespace chars\n    let previousLineIndentation = 0; // index at which latest line contained the first non-whitespace char\n    const ALLOWED_TAB_SIZE_GUESSES = [2, 4, 6, 8, 3, 5, 7]; // prefer even guesses for `tabSize`, limit to [2, 8].\n    const MAX_ALLOWED_TAB_SIZE_GUESS = 8; // max(ALLOWED_TAB_SIZE_GUESSES) = 8\n    const spacesDiffCount = [0, 0, 0, 0, 0, 0, 0, 0, 0]; // `tabSize` scores\n    const tmp = new SpacesDiffResult();\n    for (let lineNumber = 1; lineNumber <= linesCount; lineNumber++) {\n        const currentLineLength = source.getLineLength(lineNumber);\n        const currentLineText = source.getLineContent(lineNumber);\n        // if the text buffer is chunk based, so long lines are cons-string, v8 will flattern the string when we check charCode.\n        // checking charCode on chunks directly is cheaper.\n        const useCurrentLineText = (currentLineLength <= 65536);\n        let currentLineHasContent = false; // does `currentLineText` contain non-whitespace chars\n        let currentLineIndentation = 0; // index at which `currentLineText` contains the first non-whitespace char\n        let currentLineSpacesCount = 0; // count of spaces found in `currentLineText` indentation\n        let currentLineTabsCount = 0; // count of tabs found in `currentLineText` indentation\n        for (let j = 0, lenJ = currentLineLength; j < lenJ; j++) {\n            const charCode = (useCurrentLineText ? currentLineText.charCodeAt(j) : source.getLineCharCode(lineNumber, j));\n            if (charCode === 9 /* CharCode.Tab */) {\n                currentLineTabsCount++;\n            }\n            else if (charCode === 32 /* CharCode.Space */) {\n                currentLineSpacesCount++;\n            }\n            else {\n                // Hit non whitespace character on this line\n                currentLineHasContent = true;\n                currentLineIndentation = j;\n                break;\n            }\n        }\n        // Ignore empty or only whitespace lines\n        if (!currentLineHasContent) {\n            continue;\n        }\n        if (currentLineTabsCount > 0) {\n            linesIndentedWithTabsCount++;\n        }\n        else if (currentLineSpacesCount > 1) {\n            linesIndentedWithSpacesCount++;\n        }\n        spacesDiff(previousLineText, previousLineIndentation, currentLineText, currentLineIndentation, tmp);\n        if (tmp.looksLikeAlignment) {\n            // if defaultInsertSpaces === true && the spaces count == tabSize, we may want to count it as valid indentation\n            //\n            // - item1\n            //   - item2\n            //\n            // otherwise skip this line entirely\n            //\n            // const a = 1,\n            //       b = 2;\n            if (!(defaultInsertSpaces && defaultTabSize === tmp.spacesDiff)) {\n                continue;\n            }\n        }\n        const currentSpacesDiff = tmp.spacesDiff;\n        if (currentSpacesDiff <= MAX_ALLOWED_TAB_SIZE_GUESS) {\n            spacesDiffCount[currentSpacesDiff]++;\n        }\n        previousLineText = currentLineText;\n        previousLineIndentation = currentLineIndentation;\n    }\n    let insertSpaces = defaultInsertSpaces;\n    if (linesIndentedWithTabsCount !== linesIndentedWithSpacesCount) {\n        insertSpaces = (linesIndentedWithTabsCount < linesIndentedWithSpacesCount);\n    }\n    let tabSize = defaultTabSize;\n    // Guess tabSize only if inserting spaces...\n    if (insertSpaces) {\n        let tabSizeScore = (insertSpaces ? 0 : 0.1 * linesCount);\n        // console.log(\"score threshold: \" + tabSizeScore);\n        ALLOWED_TAB_SIZE_GUESSES.forEach((possibleTabSize) => {\n            const possibleTabSizeScore = spacesDiffCount[possibleTabSize];\n            if (possibleTabSizeScore > tabSizeScore) {\n                tabSizeScore = possibleTabSizeScore;\n                tabSize = possibleTabSize;\n            }\n        });\n        // Let a tabSize of 2 win even if it is not the maximum\n        // (only in case 4 was guessed)\n        if (tabSize === 4 && spacesDiffCount[4] > 0 && spacesDiffCount[2] > 0 && spacesDiffCount[2] >= spacesDiffCount[4] / 2) {\n            tabSize = 2;\n        }\n    }\n    // console.log('--------------------------');\n    // console.log('linesIndentedWithTabsCount: ' + linesIndentedWithTabsCount + ', linesIndentedWithSpacesCount: ' + linesIndentedWithSpacesCount);\n    // console.log('spacesDiffCount: ' + spacesDiffCount);\n    // console.log('tabSize: ' + tabSize + ', tabSizeScore: ' + tabSizeScore);\n    return {\n        insertSpaces: insertSpaces,\n        tabSize: tabSize\n    };\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport function getNodeColor(node) {\n    return ((node.metadata & 1 /* Constants.ColorMask */) >>> 0 /* Constants.ColorOffset */);\n}\nfunction setNodeColor(node, color) {\n    node.metadata = ((node.metadata & 254 /* Constants.ColorMaskInverse */) | (color << 0 /* Constants.ColorOffset */));\n}\nfunction getNodeIsVisited(node) {\n    return ((node.metadata & 2 /* Constants.IsVisitedMask */) >>> 1 /* Constants.IsVisitedOffset */) === 1;\n}\nfunction setNodeIsVisited(node, value) {\n    node.metadata = ((node.metadata & 253 /* Constants.IsVisitedMaskInverse */) | ((value ? 1 : 0) << 1 /* Constants.IsVisitedOffset */));\n}\nfunction getNodeIsForValidation(node) {\n    return ((node.metadata & 4 /* Constants.IsForValidationMask */) >>> 2 /* Constants.IsForValidationOffset */) === 1;\n}\nfunction setNodeIsForValidation(node, value) {\n    node.metadata = ((node.metadata & 251 /* Constants.IsForValidationMaskInverse */) | ((value ? 1 : 0) << 2 /* Constants.IsForValidationOffset */));\n}\nfunction getNodeIsInGlyphMargin(node) {\n    return ((node.metadata & 64 /* Constants.IsMarginMask */) >>> 6 /* Constants.IsMarginOffset */) === 1;\n}\nfunction setNodeIsInGlyphMargin(node, value) {\n    node.metadata = ((node.metadata & 191 /* Constants.IsMarginMaskInverse */) | ((value ? 1 : 0) << 6 /* Constants.IsMarginOffset */));\n}\nfunction getNodeStickiness(node) {\n    return ((node.metadata & 24 /* Constants.StickinessMask */) >>> 3 /* Constants.StickinessOffset */);\n}\nfunction _setNodeStickiness(node, stickiness) {\n    node.metadata = ((node.metadata & 231 /* Constants.StickinessMaskInverse */) | (stickiness << 3 /* Constants.StickinessOffset */));\n}\nfunction getCollapseOnReplaceEdit(node) {\n    return ((node.metadata & 32 /* Constants.CollapseOnReplaceEditMask */) >>> 5 /* Constants.CollapseOnReplaceEditOffset */) === 1;\n}\nfunction setCollapseOnReplaceEdit(node, value) {\n    node.metadata = ((node.metadata & 223 /* Constants.CollapseOnReplaceEditMaskInverse */) | ((value ? 1 : 0) << 5 /* Constants.CollapseOnReplaceEditOffset */));\n}\nexport class IntervalNode {\n    constructor(id, start, end) {\n        this.metadata = 0;\n        this.parent = this;\n        this.left = this;\n        this.right = this;\n        setNodeColor(this, 1 /* NodeColor.Red */);\n        this.start = start;\n        this.end = end;\n        // FORCE_OVERFLOWING_TEST: this.delta = start;\n        this.delta = 0;\n        this.maxEnd = end;\n        this.id = id;\n        this.ownerId = 0;\n        this.options = null;\n        setNodeIsForValidation(this, false);\n        setNodeIsInGlyphMargin(this, false);\n        _setNodeStickiness(this, 1 /* TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges */);\n        setCollapseOnReplaceEdit(this, false);\n        this.cachedVersionId = 0;\n        this.cachedAbsoluteStart = start;\n        this.cachedAbsoluteEnd = end;\n        this.range = null;\n        setNodeIsVisited(this, false);\n    }\n    reset(versionId, start, end, range) {\n        this.start = start;\n        this.end = end;\n        this.maxEnd = end;\n        this.cachedVersionId = versionId;\n        this.cachedAbsoluteStart = start;\n        this.cachedAbsoluteEnd = end;\n        this.range = range;\n    }\n    setOptions(options) {\n        this.options = options;\n        const className = this.options.className;\n        setNodeIsForValidation(this, (className === \"squiggly-error\" /* ClassName.EditorErrorDecoration */\n            || className === \"squiggly-warning\" /* ClassName.EditorWarningDecoration */\n            || className === \"squiggly-info\" /* ClassName.EditorInfoDecoration */));\n        setNodeIsInGlyphMargin(this, this.options.glyphMarginClassName !== null);\n        _setNodeStickiness(this, this.options.stickiness);\n        setCollapseOnReplaceEdit(this, this.options.collapseOnReplaceEdit);\n    }\n    setCachedOffsets(absoluteStart, absoluteEnd, cachedVersionId) {\n        if (this.cachedVersionId !== cachedVersionId) {\n            this.range = null;\n        }\n        this.cachedVersionId = cachedVersionId;\n        this.cachedAbsoluteStart = absoluteStart;\n        this.cachedAbsoluteEnd = absoluteEnd;\n    }\n    detach() {\n        this.parent = null;\n        this.left = null;\n        this.right = null;\n    }\n}\nexport const SENTINEL = new IntervalNode(null, 0, 0);\nSENTINEL.parent = SENTINEL;\nSENTINEL.left = SENTINEL;\nSENTINEL.right = SENTINEL;\nsetNodeColor(SENTINEL, 0 /* NodeColor.Black */);\nexport class IntervalTree {\n    constructor() {\n        this.root = SENTINEL;\n        this.requestNormalizeDelta = false;\n    }\n    intervalSearch(start, end, filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations) {\n        if (this.root === SENTINEL) {\n            return [];\n        }\n        return intervalSearch(this, start, end, filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations);\n    }\n    search(filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations) {\n        if (this.root === SENTINEL) {\n            return [];\n        }\n        return search(this, filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations);\n    }\n    /**\n     * Will not set `cachedAbsoluteStart` nor `cachedAbsoluteEnd` on the returned nodes!\n     */\n    collectNodesFromOwner(ownerId) {\n        return collectNodesFromOwner(this, ownerId);\n    }\n    /**\n     * Will not set `cachedAbsoluteStart` nor `cachedAbsoluteEnd` on the returned nodes!\n     */\n    collectNodesPostOrder() {\n        return collectNodesPostOrder(this);\n    }\n    insert(node) {\n        rbTreeInsert(this, node);\n        this._normalizeDeltaIfNecessary();\n    }\n    delete(node) {\n        rbTreeDelete(this, node);\n        this._normalizeDeltaIfNecessary();\n    }\n    resolveNode(node, cachedVersionId) {\n        const initialNode = node;\n        let delta = 0;\n        while (node !== this.root) {\n            if (node === node.parent.right) {\n                delta += node.parent.delta;\n            }\n            node = node.parent;\n        }\n        const nodeStart = initialNode.start + delta;\n        const nodeEnd = initialNode.end + delta;\n        initialNode.setCachedOffsets(nodeStart, nodeEnd, cachedVersionId);\n    }\n    acceptReplace(offset, length, textLength, forceMoveMarkers) {\n        // Our strategy is to remove all directly impacted nodes, and then add them back to the tree.\n        // (1) collect all nodes that are intersecting this edit as nodes of interest\n        const nodesOfInterest = searchForEditing(this, offset, offset + length);\n        // (2) remove all nodes that are intersecting this edit\n        for (let i = 0, len = nodesOfInterest.length; i < len; i++) {\n            const node = nodesOfInterest[i];\n            rbTreeDelete(this, node);\n        }\n        this._normalizeDeltaIfNecessary();\n        // (3) edit all tree nodes except the nodes of interest\n        noOverlapReplace(this, offset, offset + length, textLength);\n        this._normalizeDeltaIfNecessary();\n        // (4) edit the nodes of interest and insert them back in the tree\n        for (let i = 0, len = nodesOfInterest.length; i < len; i++) {\n            const node = nodesOfInterest[i];\n            node.start = node.cachedAbsoluteStart;\n            node.end = node.cachedAbsoluteEnd;\n            nodeAcceptEdit(node, offset, (offset + length), textLength, forceMoveMarkers);\n            node.maxEnd = node.end;\n            rbTreeInsert(this, node);\n        }\n        this._normalizeDeltaIfNecessary();\n    }\n    _normalizeDeltaIfNecessary() {\n        if (!this.requestNormalizeDelta) {\n            return;\n        }\n        this.requestNormalizeDelta = false;\n        normalizeDelta(this);\n    }\n}\n//#region Delta Normalization\nfunction normalizeDelta(T) {\n    let node = T.root;\n    let delta = 0;\n    while (node !== SENTINEL) {\n        if (node.left !== SENTINEL && !getNodeIsVisited(node.left)) {\n            // go left\n            node = node.left;\n            continue;\n        }\n        if (node.right !== SENTINEL && !getNodeIsVisited(node.right)) {\n            // go right\n            delta += node.delta;\n            node = node.right;\n            continue;\n        }\n        // handle current node\n        node.start = delta + node.start;\n        node.end = delta + node.end;\n        node.delta = 0;\n        recomputeMaxEnd(node);\n        setNodeIsVisited(node, true);\n        // going up from this node\n        setNodeIsVisited(node.left, false);\n        setNodeIsVisited(node.right, false);\n        if (node === node.parent.right) {\n            delta -= node.parent.delta;\n        }\n        node = node.parent;\n    }\n    setNodeIsVisited(T.root, false);\n}\nfunction adjustMarkerBeforeColumn(markerOffset, markerStickToPreviousCharacter, checkOffset, moveSemantics) {\n    if (markerOffset < checkOffset) {\n        return true;\n    }\n    if (markerOffset > checkOffset) {\n        return false;\n    }\n    if (moveSemantics === 1 /* MarkerMoveSemantics.ForceMove */) {\n        return false;\n    }\n    if (moveSemantics === 2 /* MarkerMoveSemantics.ForceStay */) {\n        return true;\n    }\n    return markerStickToPreviousCharacter;\n}\n/**\n * This is a lot more complicated than strictly necessary to maintain the same behaviour\n * as when decorations were implemented using two markers.\n */\nexport function nodeAcceptEdit(node, start, end, textLength, forceMoveMarkers) {\n    const nodeStickiness = getNodeStickiness(node);\n    const startStickToPreviousCharacter = (nodeStickiness === 0 /* TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges */\n        || nodeStickiness === 2 /* TrackedRangeStickiness.GrowsOnlyWhenTypingBefore */);\n    const endStickToPreviousCharacter = (nodeStickiness === 1 /* TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges */\n        || nodeStickiness === 2 /* TrackedRangeStickiness.GrowsOnlyWhenTypingBefore */);\n    const deletingCnt = (end - start);\n    const insertingCnt = textLength;\n    const commonLength = Math.min(deletingCnt, insertingCnt);\n    const nodeStart = node.start;\n    let startDone = false;\n    const nodeEnd = node.end;\n    let endDone = false;\n    if (start <= nodeStart && nodeEnd <= end && getCollapseOnReplaceEdit(node)) {\n        // This edit encompasses the entire decoration range\n        // and the decoration has asked to become collapsed\n        node.start = start;\n        startDone = true;\n        node.end = start;\n        endDone = true;\n    }\n    {\n        const moveSemantics = forceMoveMarkers ? 1 /* MarkerMoveSemantics.ForceMove */ : (deletingCnt > 0 ? 2 /* MarkerMoveSemantics.ForceStay */ : 0 /* MarkerMoveSemantics.MarkerDefined */);\n        if (!startDone && adjustMarkerBeforeColumn(nodeStart, startStickToPreviousCharacter, start, moveSemantics)) {\n            startDone = true;\n        }\n        if (!endDone && adjustMarkerBeforeColumn(nodeEnd, endStickToPreviousCharacter, start, moveSemantics)) {\n            endDone = true;\n        }\n    }\n    if (commonLength > 0 && !forceMoveMarkers) {\n        const moveSemantics = (deletingCnt > insertingCnt ? 2 /* MarkerMoveSemantics.ForceStay */ : 0 /* MarkerMoveSemantics.MarkerDefined */);\n        if (!startDone && adjustMarkerBeforeColumn(nodeStart, startStickToPreviousCharacter, start + commonLength, moveSemantics)) {\n            startDone = true;\n        }\n        if (!endDone && adjustMarkerBeforeColumn(nodeEnd, endStickToPreviousCharacter, start + commonLength, moveSemantics)) {\n            endDone = true;\n        }\n    }\n    {\n        const moveSemantics = forceMoveMarkers ? 1 /* MarkerMoveSemantics.ForceMove */ : 0 /* MarkerMoveSemantics.MarkerDefined */;\n        if (!startDone && adjustMarkerBeforeColumn(nodeStart, startStickToPreviousCharacter, end, moveSemantics)) {\n            node.start = start + insertingCnt;\n            startDone = true;\n        }\n        if (!endDone && adjustMarkerBeforeColumn(nodeEnd, endStickToPreviousCharacter, end, moveSemantics)) {\n            node.end = start + insertingCnt;\n            endDone = true;\n        }\n    }\n    // Finish\n    const deltaColumn = (insertingCnt - deletingCnt);\n    if (!startDone) {\n        node.start = Math.max(0, nodeStart + deltaColumn);\n    }\n    if (!endDone) {\n        node.end = Math.max(0, nodeEnd + deltaColumn);\n    }\n    if (node.start > node.end) {\n        node.end = node.start;\n    }\n}\nfunction searchForEditing(T, start, end) {\n    // https://en.wikipedia.org/wiki/Interval_tree#Augmented_tree\n    // Now, it is known that two intervals A and B overlap only when both\n    // A.low <= B.high and A.high >= B.low. When searching the trees for\n    // nodes overlapping with a given interval, you can immediately skip:\n    //  a) all nodes to the right of nodes whose low value is past the end of the given interval.\n    //  b) all nodes that have their maximum 'high' value below the start of the given interval.\n    let node = T.root;\n    let delta = 0;\n    let nodeMaxEnd = 0;\n    let nodeStart = 0;\n    let nodeEnd = 0;\n    const result = [];\n    let resultLen = 0;\n    while (node !== SENTINEL) {\n        if (getNodeIsVisited(node)) {\n            // going up from this node\n            setNodeIsVisited(node.left, false);\n            setNodeIsVisited(node.right, false);\n            if (node === node.parent.right) {\n                delta -= node.parent.delta;\n            }\n            node = node.parent;\n            continue;\n        }\n        if (!getNodeIsVisited(node.left)) {\n            // first time seeing this node\n            nodeMaxEnd = delta + node.maxEnd;\n            if (nodeMaxEnd < start) {\n                // cover case b) from above\n                // there is no need to search this node or its children\n                setNodeIsVisited(node, true);\n                continue;\n            }\n            if (node.left !== SENTINEL) {\n                // go left\n                node = node.left;\n                continue;\n            }\n        }\n        // handle current node\n        nodeStart = delta + node.start;\n        if (nodeStart > end) {\n            // cover case a) from above\n            // there is no need to search this node or its right subtree\n            setNodeIsVisited(node, true);\n            continue;\n        }\n        nodeEnd = delta + node.end;\n        if (nodeEnd >= start) {\n            node.setCachedOffsets(nodeStart, nodeEnd, 0);\n            result[resultLen++] = node;\n        }\n        setNodeIsVisited(node, true);\n        if (node.right !== SENTINEL && !getNodeIsVisited(node.right)) {\n            // go right\n            delta += node.delta;\n            node = node.right;\n            continue;\n        }\n    }\n    setNodeIsVisited(T.root, false);\n    return result;\n}\nfunction noOverlapReplace(T, start, end, textLength) {\n    // https://en.wikipedia.org/wiki/Interval_tree#Augmented_tree\n    // Now, it is known that two intervals A and B overlap only when both\n    // A.low <= B.high and A.high >= B.low. When searching the trees for\n    // nodes overlapping with a given interval, you can immediately skip:\n    //  a) all nodes to the right of nodes whose low value is past the end of the given interval.\n    //  b) all nodes that have their maximum 'high' value below the start of the given interval.\n    let node = T.root;\n    let delta = 0;\n    let nodeMaxEnd = 0;\n    let nodeStart = 0;\n    const editDelta = (textLength - (end - start));\n    while (node !== SENTINEL) {\n        if (getNodeIsVisited(node)) {\n            // going up from this node\n            setNodeIsVisited(node.left, false);\n            setNodeIsVisited(node.right, false);\n            if (node === node.parent.right) {\n                delta -= node.parent.delta;\n            }\n            recomputeMaxEnd(node);\n            node = node.parent;\n            continue;\n        }\n        if (!getNodeIsVisited(node.left)) {\n            // first time seeing this node\n            nodeMaxEnd = delta + node.maxEnd;\n            if (nodeMaxEnd < start) {\n                // cover case b) from above\n                // there is no need to search this node or its children\n                setNodeIsVisited(node, true);\n                continue;\n            }\n            if (node.left !== SENTINEL) {\n                // go left\n                node = node.left;\n                continue;\n            }\n        }\n        // handle current node\n        nodeStart = delta + node.start;\n        if (nodeStart > end) {\n            node.start += editDelta;\n            node.end += editDelta;\n            node.delta += editDelta;\n            if (node.delta < -1073741824 /* Constants.MIN_SAFE_DELTA */ || node.delta > 1073741824 /* Constants.MAX_SAFE_DELTA */) {\n                T.requestNormalizeDelta = true;\n            }\n            // cover case a) from above\n            // there is no need to search this node or its right subtree\n            setNodeIsVisited(node, true);\n            continue;\n        }\n        setNodeIsVisited(node, true);\n        if (node.right !== SENTINEL && !getNodeIsVisited(node.right)) {\n            // go right\n            delta += node.delta;\n            node = node.right;\n            continue;\n        }\n    }\n    setNodeIsVisited(T.root, false);\n}\n//#endregion\n//#region Searching\nfunction collectNodesFromOwner(T, ownerId) {\n    let node = T.root;\n    const result = [];\n    let resultLen = 0;\n    while (node !== SENTINEL) {\n        if (getNodeIsVisited(node)) {\n            // going up from this node\n            setNodeIsVisited(node.left, false);\n            setNodeIsVisited(node.right, false);\n            node = node.parent;\n            continue;\n        }\n        if (node.left !== SENTINEL && !getNodeIsVisited(node.left)) {\n            // go left\n            node = node.left;\n            continue;\n        }\n        // handle current node\n        if (node.ownerId === ownerId) {\n            result[resultLen++] = node;\n        }\n        setNodeIsVisited(node, true);\n        if (node.right !== SENTINEL && !getNodeIsVisited(node.right)) {\n            // go right\n            node = node.right;\n            continue;\n        }\n    }\n    setNodeIsVisited(T.root, false);\n    return result;\n}\nfunction collectNodesPostOrder(T) {\n    let node = T.root;\n    const result = [];\n    let resultLen = 0;\n    while (node !== SENTINEL) {\n        if (getNodeIsVisited(node)) {\n            // going up from this node\n            setNodeIsVisited(node.left, false);\n            setNodeIsVisited(node.right, false);\n            node = node.parent;\n            continue;\n        }\n        if (node.left !== SENTINEL && !getNodeIsVisited(node.left)) {\n            // go left\n            node = node.left;\n            continue;\n        }\n        if (node.right !== SENTINEL && !getNodeIsVisited(node.right)) {\n            // go right\n            node = node.right;\n            continue;\n        }\n        // handle current node\n        result[resultLen++] = node;\n        setNodeIsVisited(node, true);\n    }\n    setNodeIsVisited(T.root, false);\n    return result;\n}\nfunction search(T, filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations) {\n    let node = T.root;\n    let delta = 0;\n    let nodeStart = 0;\n    let nodeEnd = 0;\n    const result = [];\n    let resultLen = 0;\n    while (node !== SENTINEL) {\n        if (getNodeIsVisited(node)) {\n            // going up from this node\n            setNodeIsVisited(node.left, false);\n            setNodeIsVisited(node.right, false);\n            if (node === node.parent.right) {\n                delta -= node.parent.delta;\n            }\n            node = node.parent;\n            continue;\n        }\n        if (node.left !== SENTINEL && !getNodeIsVisited(node.left)) {\n            // go left\n            node = node.left;\n            continue;\n        }\n        // handle current node\n        nodeStart = delta + node.start;\n        nodeEnd = delta + node.end;\n        node.setCachedOffsets(nodeStart, nodeEnd, cachedVersionId);\n        let include = true;\n        if (filterOwnerId && node.ownerId && node.ownerId !== filterOwnerId) {\n            include = false;\n        }\n        if (filterOutValidation && getNodeIsForValidation(node)) {\n            include = false;\n        }\n        if (onlyMarginDecorations && !getNodeIsInGlyphMargin(node)) {\n            include = false;\n        }\n        if (include) {\n            result[resultLen++] = node;\n        }\n        setNodeIsVisited(node, true);\n        if (node.right !== SENTINEL && !getNodeIsVisited(node.right)) {\n            // go right\n            delta += node.delta;\n            node = node.right;\n            continue;\n        }\n    }\n    setNodeIsVisited(T.root, false);\n    return result;\n}\nfunction intervalSearch(T, intervalStart, intervalEnd, filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations) {\n    // https://en.wikipedia.org/wiki/Interval_tree#Augmented_tree\n    // Now, it is known that two intervals A and B overlap only when both\n    // A.low <= B.high and A.high >= B.low. When searching the trees for\n    // nodes overlapping with a given interval, you can immediately skip:\n    //  a) all nodes to the right of nodes whose low value is past the end of the given interval.\n    //  b) all nodes that have their maximum 'high' value below the start of the given interval.\n    let node = T.root;\n    let delta = 0;\n    let nodeMaxEnd = 0;\n    let nodeStart = 0;\n    let nodeEnd = 0;\n    const result = [];\n    let resultLen = 0;\n    while (node !== SENTINEL) {\n        if (getNodeIsVisited(node)) {\n            // going up from this node\n            setNodeIsVisited(node.left, false);\n            setNodeIsVisited(node.right, false);\n            if (node === node.parent.right) {\n                delta -= node.parent.delta;\n            }\n            node = node.parent;\n            continue;\n        }\n        if (!getNodeIsVisited(node.left)) {\n            // first time seeing this node\n            nodeMaxEnd = delta + node.maxEnd;\n            if (nodeMaxEnd < intervalStart) {\n                // cover case b) from above\n                // there is no need to search this node or its children\n                setNodeIsVisited(node, true);\n                continue;\n            }\n            if (node.left !== SENTINEL) {\n                // go left\n                node = node.left;\n                continue;\n            }\n        }\n        // handle current node\n        nodeStart = delta + node.start;\n        if (nodeStart > intervalEnd) {\n            // cover case a) from above\n            // there is no need to search this node or its right subtree\n            setNodeIsVisited(node, true);\n            continue;\n        }\n        nodeEnd = delta + node.end;\n        if (nodeEnd >= intervalStart) {\n            // There is overlap\n            node.setCachedOffsets(nodeStart, nodeEnd, cachedVersionId);\n            let include = true;\n            if (filterOwnerId && node.ownerId && node.ownerId !== filterOwnerId) {\n                include = false;\n            }\n            if (filterOutValidation && getNodeIsForValidation(node)) {\n                include = false;\n            }\n            if (onlyMarginDecorations && !getNodeIsInGlyphMargin(node)) {\n                include = false;\n            }\n            if (include) {\n                result[resultLen++] = node;\n            }\n        }\n        setNodeIsVisited(node, true);\n        if (node.right !== SENTINEL && !getNodeIsVisited(node.right)) {\n            // go right\n            delta += node.delta;\n            node = node.right;\n            continue;\n        }\n    }\n    setNodeIsVisited(T.root, false);\n    return result;\n}\n//#endregion\n//#region Insertion\nfunction rbTreeInsert(T, newNode) {\n    if (T.root === SENTINEL) {\n        newNode.parent = SENTINEL;\n        newNode.left = SENTINEL;\n        newNode.right = SENTINEL;\n        setNodeColor(newNode, 0 /* NodeColor.Black */);\n        T.root = newNode;\n        return T.root;\n    }\n    treeInsert(T, newNode);\n    recomputeMaxEndWalkToRoot(newNode.parent);\n    // repair tree\n    let x = newNode;\n    while (x !== T.root && getNodeColor(x.parent) === 1 /* NodeColor.Red */) {\n        if (x.parent === x.parent.parent.left) {\n            const y = x.parent.parent.right;\n            if (getNodeColor(y) === 1 /* NodeColor.Red */) {\n                setNodeColor(x.parent, 0 /* NodeColor.Black */);\n                setNodeColor(y, 0 /* NodeColor.Black */);\n                setNodeColor(x.parent.parent, 1 /* NodeColor.Red */);\n                x = x.parent.parent;\n            }\n            else {\n                if (x === x.parent.right) {\n                    x = x.parent;\n                    leftRotate(T, x);\n                }\n                setNodeColor(x.parent, 0 /* NodeColor.Black */);\n                setNodeColor(x.parent.parent, 1 /* NodeColor.Red */);\n                rightRotate(T, x.parent.parent);\n            }\n        }\n        else {\n            const y = x.parent.parent.left;\n            if (getNodeColor(y) === 1 /* NodeColor.Red */) {\n                setNodeColor(x.parent, 0 /* NodeColor.Black */);\n                setNodeColor(y, 0 /* NodeColor.Black */);\n                setNodeColor(x.parent.parent, 1 /* NodeColor.Red */);\n                x = x.parent.parent;\n            }\n            else {\n                if (x === x.parent.left) {\n                    x = x.parent;\n                    rightRotate(T, x);\n                }\n                setNodeColor(x.parent, 0 /* NodeColor.Black */);\n                setNodeColor(x.parent.parent, 1 /* NodeColor.Red */);\n                leftRotate(T, x.parent.parent);\n            }\n        }\n    }\n    setNodeColor(T.root, 0 /* NodeColor.Black */);\n    return newNode;\n}\nfunction treeInsert(T, z) {\n    let delta = 0;\n    let x = T.root;\n    const zAbsoluteStart = z.start;\n    const zAbsoluteEnd = z.end;\n    while (true) {\n        const cmp = intervalCompare(zAbsoluteStart, zAbsoluteEnd, x.start + delta, x.end + delta);\n        if (cmp < 0) {\n            // this node should be inserted to the left\n            // => it is not affected by the node's delta\n            if (x.left === SENTINEL) {\n                z.start -= delta;\n                z.end -= delta;\n                z.maxEnd -= delta;\n                x.left = z;\n                break;\n            }\n            else {\n                x = x.left;\n            }\n        }\n        else {\n            // this node should be inserted to the right\n            // => it is not affected by the node's delta\n            if (x.right === SENTINEL) {\n                z.start -= (delta + x.delta);\n                z.end -= (delta + x.delta);\n                z.maxEnd -= (delta + x.delta);\n                x.right = z;\n                break;\n            }\n            else {\n                delta += x.delta;\n                x = x.right;\n            }\n        }\n    }\n    z.parent = x;\n    z.left = SENTINEL;\n    z.right = SENTINEL;\n    setNodeColor(z, 1 /* NodeColor.Red */);\n}\n//#endregion\n//#region Deletion\nfunction rbTreeDelete(T, z) {\n    let x;\n    let y;\n    // RB-DELETE except we don't swap z and y in case c)\n    // i.e. we always delete what's pointed at by z.\n    if (z.left === SENTINEL) {\n        x = z.right;\n        y = z;\n        // x's delta is no longer influenced by z's delta\n        x.delta += z.delta;\n        if (x.delta < -1073741824 /* Constants.MIN_SAFE_DELTA */ || x.delta > 1073741824 /* Constants.MAX_SAFE_DELTA */) {\n            T.requestNormalizeDelta = true;\n        }\n        x.start += z.delta;\n        x.end += z.delta;\n    }\n    else if (z.right === SENTINEL) {\n        x = z.left;\n        y = z;\n    }\n    else {\n        y = leftest(z.right);\n        x = y.right;\n        // y's delta is no longer influenced by z's delta,\n        // but we don't want to walk the entire right-hand-side subtree of x.\n        // we therefore maintain z's delta in y, and adjust only x\n        x.start += y.delta;\n        x.end += y.delta;\n        x.delta += y.delta;\n        if (x.delta < -1073741824 /* Constants.MIN_SAFE_DELTA */ || x.delta > 1073741824 /* Constants.MAX_SAFE_DELTA */) {\n            T.requestNormalizeDelta = true;\n        }\n        y.start += z.delta;\n        y.end += z.delta;\n        y.delta = z.delta;\n        if (y.delta < -1073741824 /* Constants.MIN_SAFE_DELTA */ || y.delta > 1073741824 /* Constants.MAX_SAFE_DELTA */) {\n            T.requestNormalizeDelta = true;\n        }\n    }\n    if (y === T.root) {\n        T.root = x;\n        setNodeColor(x, 0 /* NodeColor.Black */);\n        z.detach();\n        resetSentinel();\n        recomputeMaxEnd(x);\n        T.root.parent = SENTINEL;\n        return;\n    }\n    const yWasRed = (getNodeColor(y) === 1 /* NodeColor.Red */);\n    if (y === y.parent.left) {\n        y.parent.left = x;\n    }\n    else {\n        y.parent.right = x;\n    }\n    if (y === z) {\n        x.parent = y.parent;\n    }\n    else {\n        if (y.parent === z) {\n            x.parent = y;\n        }\n        else {\n            x.parent = y.parent;\n        }\n        y.left = z.left;\n        y.right = z.right;\n        y.parent = z.parent;\n        setNodeColor(y, getNodeColor(z));\n        if (z === T.root) {\n            T.root = y;\n        }\n        else {\n            if (z === z.parent.left) {\n                z.parent.left = y;\n            }\n            else {\n                z.parent.right = y;\n            }\n        }\n        if (y.left !== SENTINEL) {\n            y.left.parent = y;\n        }\n        if (y.right !== SENTINEL) {\n            y.right.parent = y;\n        }\n    }\n    z.detach();\n    if (yWasRed) {\n        recomputeMaxEndWalkToRoot(x.parent);\n        if (y !== z) {\n            recomputeMaxEndWalkToRoot(y);\n            recomputeMaxEndWalkToRoot(y.parent);\n        }\n        resetSentinel();\n        return;\n    }\n    recomputeMaxEndWalkToRoot(x);\n    recomputeMaxEndWalkToRoot(x.parent);\n    if (y !== z) {\n        recomputeMaxEndWalkToRoot(y);\n        recomputeMaxEndWalkToRoot(y.parent);\n    }\n    // RB-DELETE-FIXUP\n    let w;\n    while (x !== T.root && getNodeColor(x) === 0 /* NodeColor.Black */) {\n        if (x === x.parent.left) {\n            w = x.parent.right;\n            if (getNodeColor(w) === 1 /* NodeColor.Red */) {\n                setNodeColor(w, 0 /* NodeColor.Black */);\n                setNodeColor(x.parent, 1 /* NodeColor.Red */);\n                leftRotate(T, x.parent);\n                w = x.parent.right;\n            }\n            if (getNodeColor(w.left) === 0 /* NodeColor.Black */ && getNodeColor(w.right) === 0 /* NodeColor.Black */) {\n                setNodeColor(w, 1 /* NodeColor.Red */);\n                x = x.parent;\n            }\n            else {\n                if (getNodeColor(w.right) === 0 /* NodeColor.Black */) {\n                    setNodeColor(w.left, 0 /* NodeColor.Black */);\n                    setNodeColor(w, 1 /* NodeColor.Red */);\n                    rightRotate(T, w);\n                    w = x.parent.right;\n                }\n                setNodeColor(w, getNodeColor(x.parent));\n                setNodeColor(x.parent, 0 /* NodeColor.Black */);\n                setNodeColor(w.right, 0 /* NodeColor.Black */);\n                leftRotate(T, x.parent);\n                x = T.root;\n            }\n        }\n        else {\n            w = x.parent.left;\n            if (getNodeColor(w) === 1 /* NodeColor.Red */) {\n                setNodeColor(w, 0 /* NodeColor.Black */);\n                setNodeColor(x.parent, 1 /* NodeColor.Red */);\n                rightRotate(T, x.parent);\n                w = x.parent.left;\n            }\n            if (getNodeColor(w.left) === 0 /* NodeColor.Black */ && getNodeColor(w.right) === 0 /* NodeColor.Black */) {\n                setNodeColor(w, 1 /* NodeColor.Red */);\n                x = x.parent;\n            }\n            else {\n                if (getNodeColor(w.left) === 0 /* NodeColor.Black */) {\n                    setNodeColor(w.right, 0 /* NodeColor.Black */);\n                    setNodeColor(w, 1 /* NodeColor.Red */);\n                    leftRotate(T, w);\n                    w = x.parent.left;\n                }\n                setNodeColor(w, getNodeColor(x.parent));\n                setNodeColor(x.parent, 0 /* NodeColor.Black */);\n                setNodeColor(w.left, 0 /* NodeColor.Black */);\n                rightRotate(T, x.parent);\n                x = T.root;\n            }\n        }\n    }\n    setNodeColor(x, 0 /* NodeColor.Black */);\n    resetSentinel();\n}\nfunction leftest(node) {\n    while (node.left !== SENTINEL) {\n        node = node.left;\n    }\n    return node;\n}\nfunction resetSentinel() {\n    SENTINEL.parent = SENTINEL;\n    SENTINEL.delta = 0; // optional\n    SENTINEL.start = 0; // optional\n    SENTINEL.end = 0; // optional\n}\n//#endregion\n//#region Rotations\nfunction leftRotate(T, x) {\n    const y = x.right; // set y.\n    y.delta += x.delta; // y's delta is no longer influenced by x's delta\n    if (y.delta < -1073741824 /* Constants.MIN_SAFE_DELTA */ || y.delta > 1073741824 /* Constants.MAX_SAFE_DELTA */) {\n        T.requestNormalizeDelta = true;\n    }\n    y.start += x.delta;\n    y.end += x.delta;\n    x.right = y.left; // turn y's left subtree into x's right subtree.\n    if (y.left !== SENTINEL) {\n        y.left.parent = x;\n    }\n    y.parent = x.parent; // link x's parent to y.\n    if (x.parent === SENTINEL) {\n        T.root = y;\n    }\n    else if (x === x.parent.left) {\n        x.parent.left = y;\n    }\n    else {\n        x.parent.right = y;\n    }\n    y.left = x; // put x on y's left.\n    x.parent = y;\n    recomputeMaxEnd(x);\n    recomputeMaxEnd(y);\n}\nfunction rightRotate(T, y) {\n    const x = y.left;\n    y.delta -= x.delta;\n    if (y.delta < -1073741824 /* Constants.MIN_SAFE_DELTA */ || y.delta > 1073741824 /* Constants.MAX_SAFE_DELTA */) {\n        T.requestNormalizeDelta = true;\n    }\n    y.start -= x.delta;\n    y.end -= x.delta;\n    y.left = x.right;\n    if (x.right !== SENTINEL) {\n        x.right.parent = y;\n    }\n    x.parent = y.parent;\n    if (y.parent === SENTINEL) {\n        T.root = x;\n    }\n    else if (y === y.parent.right) {\n        y.parent.right = x;\n    }\n    else {\n        y.parent.left = x;\n    }\n    x.right = y;\n    y.parent = x;\n    recomputeMaxEnd(y);\n    recomputeMaxEnd(x);\n}\n//#endregion\n//#region max end computation\nfunction computeMaxEnd(node) {\n    let maxEnd = node.end;\n    if (node.left !== SENTINEL) {\n        const leftMaxEnd = node.left.maxEnd;\n        if (leftMaxEnd > maxEnd) {\n            maxEnd = leftMaxEnd;\n        }\n    }\n    if (node.right !== SENTINEL) {\n        const rightMaxEnd = node.right.maxEnd + node.delta;\n        if (rightMaxEnd > maxEnd) {\n            maxEnd = rightMaxEnd;\n        }\n    }\n    return maxEnd;\n}\nexport function recomputeMaxEnd(node) {\n    node.maxEnd = computeMaxEnd(node);\n}\nfunction recomputeMaxEndWalkToRoot(node) {\n    while (node !== SENTINEL) {\n        const maxEnd = computeMaxEnd(node);\n        if (node.maxEnd === maxEnd) {\n            // no need to go further\n            return;\n        }\n        node.maxEnd = maxEnd;\n        node = node.parent;\n    }\n}\n//#endregion\n//#region utils\nexport function intervalCompare(aStart, aEnd, bStart, bEnd) {\n    if (aStart === bStart) {\n        return aEnd - bEnd;\n    }\n    return aStart - bStart;\n}\n//#endregion\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { assertNever } from '../../base/common/assert.js';\nimport { Position } from './core/position.js';\nimport { InjectedTextCursorStops } from './model.js';\n/**\n * *input*:\n * ```\n * xxxxxxxxxxxxxxxxxxxxxxxxxxx\n * ```\n *\n * -> Applying injections `[i...i]`, *inputWithInjections*:\n * ```\n * xxxxxx[iiiiiiiiii]xxxxxxxxxxxxxxxxx[ii]xxxx\n * ```\n *\n * -> breaking at offsets `|` in `xxxxxx[iiiiiii|iii]xxxxxxxxxxx|xxxxxx[ii]xxxx|`:\n * ```\n * xxxxxx[iiiiiii\n * iii]xxxxxxxxxxx\n * xxxxxx[ii]xxxx\n * ```\n *\n * -> applying wrappedTextIndentLength, *output*:\n * ```\n * xxxxxx[iiiiiii\n *    iii]xxxxxxxxxxx\n *    xxxxxx[ii]xxxx\n * ```\n */\nexport class ModelLineProjectionData {\n    constructor(injectionOffsets, \n    /**\n     * `injectionOptions.length` must equal `injectionOffsets.length`\n     */\n    injectionOptions, \n    /**\n     * Refers to offsets after applying injections to the source.\n     * The last break offset indicates the length of the source after applying injections.\n     */\n    breakOffsets, \n    /**\n     * Refers to offsets after applying injections\n     */\n    breakOffsetsVisibleColumn, wrappedTextIndentLength) {\n        this.injectionOffsets = injectionOffsets;\n        this.injectionOptions = injectionOptions;\n        this.breakOffsets = breakOffsets;\n        this.breakOffsetsVisibleColumn = breakOffsetsVisibleColumn;\n        this.wrappedTextIndentLength = wrappedTextIndentLength;\n    }\n    getOutputLineCount() {\n        return this.breakOffsets.length;\n    }\n    getMinOutputOffset(outputLineIndex) {\n        if (outputLineIndex > 0) {\n            return this.wrappedTextIndentLength;\n        }\n        return 0;\n    }\n    getLineLength(outputLineIndex) {\n        // These offsets refer to model text with injected text.\n        const startOffset = outputLineIndex > 0 ? this.breakOffsets[outputLineIndex - 1] : 0;\n        const endOffset = this.breakOffsets[outputLineIndex];\n        let lineLength = endOffset - startOffset;\n        if (outputLineIndex > 0) {\n            lineLength += this.wrappedTextIndentLength;\n        }\n        return lineLength;\n    }\n    getMaxOutputOffset(outputLineIndex) {\n        return this.getLineLength(outputLineIndex);\n    }\n    translateToInputOffset(outputLineIndex, outputOffset) {\n        if (outputLineIndex > 0) {\n            outputOffset = Math.max(0, outputOffset - this.wrappedTextIndentLength);\n        }\n        const offsetInInputWithInjection = outputLineIndex === 0 ? outputOffset : this.breakOffsets[outputLineIndex - 1] + outputOffset;\n        let offsetInInput = offsetInInputWithInjection;\n        if (this.injectionOffsets !== null) {\n            for (let i = 0; i < this.injectionOffsets.length; i++) {\n                if (offsetInInput > this.injectionOffsets[i]) {\n                    if (offsetInInput < this.injectionOffsets[i] + this.injectionOptions[i].content.length) {\n                        // `inputOffset` is within injected text\n                        offsetInInput = this.injectionOffsets[i];\n                    }\n                    else {\n                        offsetInInput -= this.injectionOptions[i].content.length;\n                    }\n                }\n                else {\n                    break;\n                }\n            }\n        }\n        return offsetInInput;\n    }\n    translateToOutputPosition(inputOffset, affinity = 2 /* PositionAffinity.None */) {\n        let inputOffsetInInputWithInjection = inputOffset;\n        if (this.injectionOffsets !== null) {\n            for (let i = 0; i < this.injectionOffsets.length; i++) {\n                if (inputOffset < this.injectionOffsets[i]) {\n                    break;\n                }\n                if (affinity !== 1 /* PositionAffinity.Right */ && inputOffset === this.injectionOffsets[i]) {\n                    break;\n                }\n                inputOffsetInInputWithInjection += this.injectionOptions[i].content.length;\n            }\n        }\n        return this.offsetInInputWithInjectionsToOutputPosition(inputOffsetInInputWithInjection, affinity);\n    }\n    offsetInInputWithInjectionsToOutputPosition(offsetInInputWithInjections, affinity = 2 /* PositionAffinity.None */) {\n        let low = 0;\n        let high = this.breakOffsets.length - 1;\n        let mid = 0;\n        let midStart = 0;\n        while (low <= high) {\n            mid = low + ((high - low) / 2) | 0;\n            const midStop = this.breakOffsets[mid];\n            midStart = mid > 0 ? this.breakOffsets[mid - 1] : 0;\n            if (affinity === 0 /* PositionAffinity.Left */) {\n                if (offsetInInputWithInjections <= midStart) {\n                    high = mid - 1;\n                }\n                else if (offsetInInputWithInjections > midStop) {\n                    low = mid + 1;\n                }\n                else {\n                    break;\n                }\n            }\n            else {\n                if (offsetInInputWithInjections < midStart) {\n                    high = mid - 1;\n                }\n                else if (offsetInInputWithInjections >= midStop) {\n                    low = mid + 1;\n                }\n                else {\n                    break;\n                }\n            }\n        }\n        let outputOffset = offsetInInputWithInjections - midStart;\n        if (mid > 0) {\n            outputOffset += this.wrappedTextIndentLength;\n        }\n        return new OutputPosition(mid, outputOffset);\n    }\n    normalizeOutputPosition(outputLineIndex, outputOffset, affinity) {\n        if (this.injectionOffsets !== null) {\n            const offsetInInputWithInjections = this.outputPositionToOffsetInInputWithInjections(outputLineIndex, outputOffset);\n            const normalizedOffsetInUnwrappedLine = this.normalizeOffsetInInputWithInjectionsAroundInjections(offsetInInputWithInjections, affinity);\n            if (normalizedOffsetInUnwrappedLine !== offsetInInputWithInjections) {\n                // injected text caused a change\n                return this.offsetInInputWithInjectionsToOutputPosition(normalizedOffsetInUnwrappedLine, affinity);\n            }\n        }\n        if (affinity === 0 /* PositionAffinity.Left */) {\n            if (outputLineIndex > 0 && outputOffset === this.getMinOutputOffset(outputLineIndex)) {\n                return new OutputPosition(outputLineIndex - 1, this.getMaxOutputOffset(outputLineIndex - 1));\n            }\n        }\n        else if (affinity === 1 /* PositionAffinity.Right */) {\n            const maxOutputLineIndex = this.getOutputLineCount() - 1;\n            if (outputLineIndex < maxOutputLineIndex && outputOffset === this.getMaxOutputOffset(outputLineIndex)) {\n                return new OutputPosition(outputLineIndex + 1, this.getMinOutputOffset(outputLineIndex + 1));\n            }\n        }\n        return new OutputPosition(outputLineIndex, outputOffset);\n    }\n    outputPositionToOffsetInInputWithInjections(outputLineIndex, outputOffset) {\n        if (outputLineIndex > 0) {\n            outputOffset = Math.max(0, outputOffset - this.wrappedTextIndentLength);\n        }\n        const result = (outputLineIndex > 0 ? this.breakOffsets[outputLineIndex - 1] : 0) + outputOffset;\n        return result;\n    }\n    normalizeOffsetInInputWithInjectionsAroundInjections(offsetInInputWithInjections, affinity) {\n        const injectedText = this.getInjectedTextAtOffset(offsetInInputWithInjections);\n        if (!injectedText) {\n            return offsetInInputWithInjections;\n        }\n        if (affinity === 2 /* PositionAffinity.None */) {\n            if (offsetInInputWithInjections === injectedText.offsetInInputWithInjections + injectedText.length\n                && hasRightCursorStop(this.injectionOptions[injectedText.injectedTextIndex].cursorStops)) {\n                return injectedText.offsetInInputWithInjections + injectedText.length;\n            }\n            else {\n                let result = injectedText.offsetInInputWithInjections;\n                if (hasLeftCursorStop(this.injectionOptions[injectedText.injectedTextIndex].cursorStops)) {\n                    return result;\n                }\n                let index = injectedText.injectedTextIndex - 1;\n                while (index >= 0 && this.injectionOffsets[index] === this.injectionOffsets[injectedText.injectedTextIndex]) {\n                    if (hasRightCursorStop(this.injectionOptions[index].cursorStops)) {\n                        break;\n                    }\n                    result -= this.injectionOptions[index].content.length;\n                    if (hasLeftCursorStop(this.injectionOptions[index].cursorStops)) {\n                        break;\n                    }\n                    index--;\n                }\n                return result;\n            }\n        }\n        else if (affinity === 1 /* PositionAffinity.Right */ || affinity === 4 /* PositionAffinity.RightOfInjectedText */) {\n            let result = injectedText.offsetInInputWithInjections + injectedText.length;\n            let index = injectedText.injectedTextIndex;\n            // traverse all injected text that touch each other\n            while (index + 1 < this.injectionOffsets.length && this.injectionOffsets[index + 1] === this.injectionOffsets[index]) {\n                result += this.injectionOptions[index + 1].content.length;\n                index++;\n            }\n            return result;\n        }\n        else if (affinity === 0 /* PositionAffinity.Left */ || affinity === 3 /* PositionAffinity.LeftOfInjectedText */) {\n            // affinity is left\n            let result = injectedText.offsetInInputWithInjections;\n            let index = injectedText.injectedTextIndex;\n            // traverse all injected text that touch each other\n            while (index - 1 >= 0 && this.injectionOffsets[index - 1] === this.injectionOffsets[index]) {\n                result -= this.injectionOptions[index - 1].content.length;\n                index--;\n            }\n            return result;\n        }\n        assertNever(affinity);\n    }\n    getInjectedText(outputLineIndex, outputOffset) {\n        const offset = this.outputPositionToOffsetInInputWithInjections(outputLineIndex, outputOffset);\n        const injectedText = this.getInjectedTextAtOffset(offset);\n        if (!injectedText) {\n            return null;\n        }\n        return {\n            options: this.injectionOptions[injectedText.injectedTextIndex]\n        };\n    }\n    getInjectedTextAtOffset(offsetInInputWithInjections) {\n        const injectionOffsets = this.injectionOffsets;\n        const injectionOptions = this.injectionOptions;\n        if (injectionOffsets !== null) {\n            let totalInjectedTextLengthBefore = 0;\n            for (let i = 0; i < injectionOffsets.length; i++) {\n                const length = injectionOptions[i].content.length;\n                const injectedTextStartOffsetInInputWithInjections = injectionOffsets[i] + totalInjectedTextLengthBefore;\n                const injectedTextEndOffsetInInputWithInjections = injectionOffsets[i] + totalInjectedTextLengthBefore + length;\n                if (injectedTextStartOffsetInInputWithInjections > offsetInInputWithInjections) {\n                    // Injected text starts later.\n                    break; // All later injected texts have an even larger offset.\n                }\n                if (offsetInInputWithInjections <= injectedTextEndOffsetInInputWithInjections) {\n                    // Injected text ends after or with the given position (but also starts with or before it).\n                    return {\n                        injectedTextIndex: i,\n                        offsetInInputWithInjections: injectedTextStartOffsetInInputWithInjections,\n                        length\n                    };\n                }\n                totalInjectedTextLengthBefore += length;\n            }\n        }\n        return undefined;\n    }\n}\nfunction hasRightCursorStop(cursorStop) {\n    if (cursorStop === null || cursorStop === undefined) {\n        return true;\n    }\n    return cursorStop === InjectedTextCursorStops.Right || cursorStop === InjectedTextCursorStops.Both;\n}\nfunction hasLeftCursorStop(cursorStop) {\n    if (cursorStop === null || cursorStop === undefined) {\n        return true;\n    }\n    return cursorStop === InjectedTextCursorStops.Left || cursorStop === InjectedTextCursorStops.Both;\n}\nexport class InjectedText {\n    constructor(options) {\n        this.options = options;\n    }\n}\nexport class OutputPosition {\n    constructor(outputLineIndex, outputOffset) {\n        this.outputLineIndex = outputLineIndex;\n        this.outputOffset = outputOffset;\n    }\n    toString() {\n        return `${this.outputLineIndex}:${this.outputOffset}`;\n    }\n    toPosition(baseLineNumber) {\n        return new Position(baseLineNumber + this.outputLineIndex, this.outputOffset + 1);\n    }\n}\n"],"names":["OverviewRulerLane","GlyphMarginLane","InjectedTextCursorStops","TextModelResolvedOptions","originalIndentSize","this","_indentSizeIsTabSize","indentSize","constructor","src","_textModelResolvedOptionsBrand","undefined","tabSize","Math","max","insertSpaces","Boolean","defaultEOL","trimAutoWhitespace","bracketPairColorizationOptions","equals","other","createChangeEvent","newOpts","FindMatch","range","matches","_findMatchBrand","isITextSnapshot","obj","read","ValidAnnotatedEditOperation","identifier","text","forceMoveMarkers","isAutoWhitespaceEdit","_isTracked","SearchData","regex","wordSeparators","simpleSearch","ApplyEditsResult","reverseEdits","changes","trimAutoWhitespaceLineNumbers","shouldSynchronizeModel","model","isTooLargeForSyncing","isForSimpleWidget","BracketPairsTree","didLanguageChange","languageId","brackets","textModel","getLanguageConfiguration","super","didChangeEmitter","denseKeyProvider","onDidChange","event","queuedTextEditsForInitialAstWithoutTokens","queuedTextEdits","tokenization","hasTokens","backgroundTokenizationState","initialAstWithoutTokens","astWithTokens","parseDocumentFromTextBuffer","getSingleLanguageBracketTokens","getLanguageId","tokenizer","getValue","handleDidChangeBackgroundTokenizationState","wasUndefined","fire","handleDidChangeTokens","ranges","edits","map","r","fromLineNumber","toLineNumber","handleEdits","handleContentChanged","change","tokenChange","result","combineTextEditInfos","flushQueue","length","previousAst","immutable","previousAstClone","getBracketsInRange","onlyColorizedBrackets","startOffset","startLineNumber","startColumn","endOffset","endLineNumber","endColumn","cb","node","collectBrackets","Map","getBracketPairsInRange","includeMinIndentation","startLength","getStartPosition","endLength","getEndPosition","context","CollectBracketPairsContext","collectBracketPairs","getFirstBracketAfter","position","getFirstBracketBefore","nodeOffsetStart","nodeOffsetEnd","kind","lengths","child","children","push","i","bracketInfo","level","nestingLevelOfEqualBracketType","levelPerBracketType","parentPairIsIncomplete","whileLoop","childCount","childrenLength","getChild","colorize","closingBracket","closesColorized","openingBracket","levelPerBracket","existing","get","set","_a","shouldContinue","openingBracketEnd","minIndentation","computeMinIndentation","curOffset","childOffset","BracketPairsTextModelPart","canBuildAST","getValueLength","languageConfigurationService","bracketPairsTree","_register","onDidChangeEmitter","bracketsRequested","e","value","object","clear","updateBracketPairsTree","handleDidChangeOptions","handleDidChangeLanguage","handleDidChangeContent","store","add","disposable","dispose","getBracketPairsInRangeWithMinIndentation","findMatchingBracketUp","_bracket","_position","maxDuration","validatePosition","getLanguageIdAtPosition","lineNumber","column","closingBracketInfo","bracketsNew","getClosingBracketInfo","bracketPair","findLast","b","closes","openingBracketInfo","openingBracketRange","bracket","toLowerCase","bracketsSupport","data","textIsBracket","stripBracketSearchCanceled","_findMatchingBracketUp","createTimeBasedContinueBracketSearchPredicate","matchBracket","filter","item","closingBracketRange","containsPosition","findLastMaxBy","continueSearchPredicate","_matchBracket","_establishBracketSearchOffsets","lineTokens","modeBrackets","tokenIndex","tokenCount","getCount","currentLanguageId","searchStartOffset","maxBracketLength","tokenEndOffset","getEndOffset","getStandardTokenType","searchEndOffset","min","getLineContent","tokenStartOffset","getStartOffset","getLineTokens","lineText","findTokenIndexAtOffset","currentModeBrackets","bestResult","foundBracket","forwardRegex","foundBracketText","substring","_matchFoundBracket","textIsOpenBracket","BracketSearchCanceled","prevTokenIndex","prevModeBrackets","reversedRegex","isOpen","matched","_findMatchingBracketDown","reversedBracketRegex","count","totalCallCount","searchPrevMatchingBracketInRange","INSTANCE","hitText","isClose","prevSearchInToken","searchInToken","bracketRegex","searchNextMatchingBracketInRange","lineCount","getLineCount","findPrevBracket","bracketConfig","tokenLanguageId","_toFoundBracket","findNextBracket","findEnclosingBrackets","strictContainsRange","savedCounts","counts","resetCounts","has","tmp","len","searchInRange","index","getValueInRange","getBracketInfo","startTime","Date","now","_searchCanceledBrand","BaseAstNode","_length","PairAstNode","create","missingOpeningBracketIds","listHeight","idx","Error","canBeReused","openBracketIds","intersects","deepClone","offset","Number","MAX_SAFE_INTEGER","ListAstNode","create23","item1","item2","item3","missingBracketIds","merge","Immutable23ListAstNode","TwoThreeListAstNode","getEmpty","ImmutableArrayListAstNode","_missingOpeningBracketIds","cachedMinIndentation","throwIfImmutable","makeLastElementMutable","lastChild","mutable","toMutable","setChild","makeFirstElementMutable","firstChild","lastLength","handleChildrenChanged","unopenedBrackets","_item3","_item1","_item2","appendChildOfSameHeight","unappendChild","prependChildOfSameHeight","unprependChild","ArrayListAstNode","_children","Array","pop","unshift","shift","emptyArray","ImmutableLeafAstNode","TextAstNode","_openedBracketIds","start","columnCount","firstNonWsColumn","getLineFirstNonWhitespaceColumn","lineContent","visibleColumn","getOptions","BracketAstNode","bracketIds","bracketText","InvalidBracketAstNode","closingBrackets","openedBracketIds","TextEditInfo","fromModelContentChanges","c","reverse","newLength","toString","BeforeEditPositionMapper","nextEditIdx","deltaOldToNewLineCount","deltaOldToNewColumnCount","deltaLineIdxInOld","edit","TextEditInfoCache","from","getOffsetBeforeChange","adjustNextEdit","translateCurToOld","getDistanceToNextChange","nextEdit","nextChangeOffset","translateOldToCur","offsetObj","oldOffsetObj","newOffset","nextEditEndOffsetInCur","endOffsetAfterObj","nextEditEndOffsetInCurObj","nextEditEndOffsetBeforeInCurObj","endOffsetBeforeObj","lineDelta","previousColumnDelta","columnDelta","textLength","BracketTokens","createFromLanguage","configuration","getId","getKey","openingBrackets","openingTextId","getOpeningBrackets","hasRegExp","_regExpGlobal","getRegExpStr","isEmpty","keys","sort","k","str","escaped","test","prepareBracketForRegExp","join","regExpGlobal","regExpStr","RegExp","getToken","findClosingTokenText","openingBracketIds","closingText","info","size","LanguageAgnosticBracketTokens","languageIdToBracketTokens","singleLanguageBracketTokens","textEditInfoFirst","textEditInfoSecond","s0ToS1Map","toLengthMapping","s1ToS2Map","modified","lengthBefore","lengthAfter","curItem","dequeue","nextS0ToS1MapWithS1LengthOf","s1Length","arr","takeWhile","v","remainingItem","splitAt","LengthMapping","pushEdit","lastResult","s0offset","s1ToS2","s0Length","s","s0EndOffset","s1","s0startOffset","remainingLengthAfter","textEditInfos","lastOffset","textEditInfo","spaceLength","lengthDiff","startLineCount","startColumnCount","endLineCount","endColumnCount","toLength","lengthZero","lengthIsZero","factor","lengthToObj","l","floor","lengthGetLineCount","lengthGetColumnCountIfZeroLineCount","lengthAdd","l1","l2","sumLengths","items","lengthFn","reduce","a","lengthEquals","length1","length2","lengthDiffNonNegative","lineCount1","lineCount2","colCount2","lengthLessThan","lengthLessThanEqual","lengthGreaterThanEqual","positionToLength","lengthsToRange","lengthStart","lengthEnd","colCount","lengthOfString","lines","concat23TreesOfSameHeight","createImmutableLists","j","heightDiff","node1","node2","abs","concat","list","nodeToAppend","curNode","parents","nodeToAppendOfCorrectHeight","parent","append","nodeToPrependOfCorrectHeight","prepend","NodeReader","nextNodes","offsets","idxs","readLongestNodeAt","predicate","lastOrUndefined","curNodeOffset","nextNodeAfterCurrent","nextChildIdx","getNextChildIdx","currentOffset","currentNode","curIdx","parseDocument","oldNode","Parser","_itemsConstructed","_itemsFromCache","oldNodeReader","positionMapper","parseList","tryReadChildFromCache","token","peek","parseChild","readNode","height","slice","first","second","concat23Trees","maxCacheableLength","cachedNode","skip","astNode","nextToken","bracketId","emptyArr","SmallImmutableSet","additionalItems","cached","cache","empty","keyProvider","key","newItem","newItems","merged","identityKeyProvider","DenseKeyProvider","Token","TextBufferTokenizer","bracketTokens","reader","NonPeekableTextBufferTokenizer","_offset","didPeek","peeked","textBufferLineCount","textBufferLastLineLength","getLineLength","setPosition","lineIdx","line","lineCharOffset","lineTokenOffset","peekedToken","startLineIdx","startLineCharOffset","lengthHeuristic","peekedBracketToken","tokenMetadata","getMetadata","isOther","containsBracketType","regexp","lastIndex","match","exec","FastTokenizer","tokens","curLineCount","lastLineBreakOffset","lastTokenEndOffset","lastTokenEndLine","smallTextTokens0Line","smallTextTokens1Line","ColorizedBracketPairsDecorationProvider","colorProvider","ColorProvider","colorizationOptions","bracketPairs","getDecorationsInRange","ownerId","filterOutValidation","onlyMinimapDecorations","enabled","id","nestingLevel","options","description","inlineClassName","getInlineClassName","independentColorPoolPerBracketType","toArray","getAllDecorations","unexpectedClosingBracketClassName","isInvalid","getInlineClassNameOfLevel","theme","collector","colors","addRule","getColor","colorValues","isTransparent","color","fixBracketsInLine","StaticTokenizerSource","processNode","closingTokenText","uriGetComparisonKey","resource","SingleModelEditStackData","beforeCursorState","alternativeVersionId","getAlternativeVersionId","eol","getModelEOL","beforeVersionId","afterVersionId","beforeEOL","afterEOL","afterCursorState","textChanges","_writeSelectionsSize","selections","_writeSelections","selection","selectionStartLineNumber","selectionStartColumn","positionLineNumber","positionColumn","_readSelections","dest","serialize","necessarySize","writeSize","Uint8Array","write","buffer","deserialize","source","changeCount","SingleModelEditStackElement","type","uri","label","code","_data","matchesResource","setModel","canAppend","close","open","undo","_applyUndo","redo","_applyRedo","heapSize","byteLength","MultiModelEditStackElement","resources","_editStackElementsArr","editStackElement","editStackElements","_isOpen","_editStackElementsMap","_delegate","prepareUndoRedo","split","getEOL","isEditStackElement","element","EditStack","undoRedoService","_model","_undoRedoService","pushStackElement","lastElement","getLastElement","popStackElement","removeElements","_getOrCreateEditStackElement","group","newElement","pushElement","pushEOL","setEOL","pushEditOperation","editOperations","cursorStateComputer","inverseEditOperations","applyEdits","_computeCursorState","op","textChange","oldPosition","FixedArray","_default","_store","replace","oldLength","insert","delete","before","after","insertArr","arrayFill","deleteIndex","deleteCount","splice","insertIndex","insertCount","GuidesTextModelPart","_computeIndentLevel","lineIndex","getActiveIndentGuide","minLineNumber","maxLineNumber","assertNotDisposed","foldingRules","offSide","up_aboveContentLineIndex","up_aboveContentLineIndent","up_belowContentLineIndex","up_belowContentLineIndent","up_resolveIndents","indent","down_aboveContentLineIndex","down_aboveContentLineIndent","down_belowContentLineIndex","down_belowContentLineIndent","down_resolveIndents","goUp","goDown","initialIndent","distance","upLineNumber","downLineNumber","upLineIndentLevel","currentIndent","ceil","_getIndentLevelForWhitespaceLine","downLineIndentLevel","getLinesBracketGuides","activePosition","getLineMaxColumn","activeBracketPairRange","bracketsContainingActivePosition","bp","BracketPairGuidesClassNames","pair","isActive","equalsRange","includeInactive","className","highlightActive","activeClassName","end","horizontalGuides","endVisibleColumn","getVisibleColumnFromPosition","startVisibleColumn","guideVisibleColumn","minVisibleColumnIndentation","renderHorizontalEndLineAtTheBottom","visibleGuideStartLineNumber","visibleGuideEndLineNumber","guides","getLinesIndentGuides","aboveContentLineIndex","aboveContentLineIndent","belowContentLineIndex","belowContentLineIndent","resultIndex","SpacesDiffResult","spacesDiff","looksLikeAlignment","aLength","bLength","charCodeAt","aSpacesCnt","aTabsCount","bSpacesCnt","bTabsCount","tabsDiff","guessIndentation","defaultTabSize","defaultInsertSpaces","linesCount","linesIndentedWithTabsCount","linesIndentedWithSpacesCount","previousLineText","previousLineIndentation","ALLOWED_TAB_SIZE_GUESSES","spacesDiffCount","currentLineLength","currentLineText","useCurrentLineText","currentLineHasContent","currentLineIndentation","currentLineSpacesCount","currentLineTabsCount","lenJ","charCode","getLineCharCode","currentSpacesDiff","tabSizeScore","forEach","possibleTabSize","possibleTabSizeScore","getNodeColor","metadata","setNodeColor","getNodeIsVisited","setNodeIsVisited","getNodeIsForValidation","setNodeIsForValidation","getNodeIsInGlyphMargin","setNodeIsInGlyphMargin","_setNodeStickiness","stickiness","setCollapseOnReplaceEdit","IntervalNode","left","right","delta","maxEnd","cachedVersionId","cachedAbsoluteStart","cachedAbsoluteEnd","reset","versionId","setOptions","glyphMarginClassName","collapseOnReplaceEdit","setCachedOffsets","absoluteStart","absoluteEnd","detach","SENTINEL","IntervalTree","root","requestNormalizeDelta","intervalSearch","filterOwnerId","onlyMarginDecorations","T","intervalStart","intervalEnd","nodeMaxEnd","nodeStart","nodeEnd","resultLen","include","search","collectNodesFromOwner","collectNodesPostOrder","rbTreeInsert","_normalizeDeltaIfNecessary","rbTreeDelete","resolveNode","initialNode","acceptReplace","nodesOfInterest","searchForEditing","editDelta","recomputeMaxEnd","noOverlapReplace","nodeAcceptEdit","normalizeDelta","adjustMarkerBeforeColumn","markerOffset","markerStickToPreviousCharacter","checkOffset","moveSemantics","nodeStickiness","getNodeStickiness","startStickToPreviousCharacter","endStickToPreviousCharacter","deletingCnt","insertingCnt","commonLength","startDone","endDone","getCollapseOnReplaceEdit","deltaColumn","newNode","z","x","zAbsoluteStart","zAbsoluteEnd","intervalCompare","treeInsert","recomputeMaxEndWalkToRoot","y","leftRotate","rightRotate","leftest","resetSentinel","yWasRed","w","computeMaxEnd","leftMaxEnd","rightMaxEnd","aStart","aEnd","bStart","bEnd","ModelLineProjectionData","injectionOffsets","injectionOptions","breakOffsets","breakOffsetsVisibleColumn","wrappedTextIndentLength","getOutputLineCount","getMinOutputOffset","outputLineIndex","lineLength","getMaxOutputOffset","translateToInputOffset","outputOffset","offsetInInput","content","translateToOutputPosition","inputOffset","affinity","inputOffsetInInputWithInjection","offsetInInputWithInjectionsToOutputPosition","offsetInInputWithInjections","low","high","mid","midStart","midStop","OutputPosition","normalizeOutputPosition","outputPositionToOffsetInInputWithInjections","normalizedOffsetInUnwrappedLine","normalizeOffsetInInputWithInjectionsAroundInjections","injectedText","getInjectedTextAtOffset","hasRightCursorStop","injectedTextIndex","cursorStops","hasLeftCursorStop","getInjectedText","totalInjectedTextLengthBefore","injectedTextStartOffsetInInputWithInjections","injectedTextEndOffsetInInputWithInjections","cursorStop","toPosition","baseLineNumber"],"sourceRoot":""}