notations 1.0.2 → 1.0.4

package/dist/notations.umd.min.js.map

@@ -1 +1 @@
-{"version":3,"file":"notations.umd.min.js","mappings":";CAAA,SAA2CA,EAAMC,GAC1B,iBAAZC,SAA0C,iBAAXC,OACxCA,OAAOD,QAAUD,IACQ,mBAAXG,QAAyBA,OAAOC,IAC9CD,OAAO,GAAIH,GACe,iBAAZC,QACdA,QAAmB,UAAID,IAEvBD,EAAgB,UAAIC,GACrB,CATD,CASGK,KAAM,I,wBCRTJ,EAAQK,KAAO,SAAUC,EAAQC,EAAQC,EAAMC,EAAMC,GACnD,IAAIC,EAAGC,EACHC,EAAiB,EAATH,EAAcD,EAAO,EAC7BK,GAAQ,GAAKD,GAAQ,EACrBE,EAAQD,GAAQ,EAChBE,GAAS,EACTC,EAAIT,EAAQE,EAAS,EAAK,EAC1BQ,EAAIV,GAAQ,EAAI,EAChBW,EAAIb,EAAOC,EAASU,GAOxB,IALAA,GAAKC,EAELP,EAAIQ,GAAM,IAAOH,GAAU,EAC3BG,KAAQH,EACRA,GAASH,EACFG,EAAQ,EAAGL,EAAS,IAAJA,EAAWL,EAAOC,EAASU,GAAIA,GAAKC,EAAGF,GAAS,GAKvE,IAHAJ,EAAID,GAAM,IAAOK,GAAU,EAC3BL,KAAQK,EACRA,GAASP,EACFO,EAAQ,EAAGJ,EAAS,IAAJA,EAAWN,EAAOC,EAASU,GAAIA,GAAKC,EAAGF,GAAS,GAEvE,GAAU,IAANL,EACFA,EAAI,EAAII,MACH,IAAIJ,IAAMG,EACf,OAAOF,EAAIQ,IAAsBC,KAAdF,GAAK,EAAI,GAE5BP,GAAQU,KAAKC,IAAI,EAAGd,GACpBE,GAAQI,CACV,CACA,OAAQI,GAAK,EAAI,GAAKP,EAAIU,KAAKC,IAAI,EAAGZ,EAAIF,EAC5C,EAEAT,EAAQwB,MAAQ,SAAUlB,EAAQmB,EAAOlB,EAAQC,EAAMC,EAAMC,GAC3D,IAAIC,EAAGC,EAAGc,EACNb,EAAiB,EAATH,EAAcD,EAAO,EAC7BK,GAAQ,GAAKD,GAAQ,EACrBE,EAAQD,GAAQ,EAChBa,EAAe,KAATlB,EAAca,KAAKC,IAAI,GAAI,IAAMD,KAAKC,IAAI,GAAI,IAAM,EAC1DN,EAAIT,EAAO,EAAKE,EAAS,EACzBQ,EAAIV,EAAO,GAAK,EAChBW,EAAIM,EAAQ,GAAgB,IAAVA,GAAe,EAAIA,EAAQ,EAAK,EAAI,EAmC1D,IAjCAA,EAAQH,KAAKM,IAAIH,GAEbI,MAAMJ,IAAUA,IAAUJ,KAC5BT,EAAIiB,MAAMJ,GAAS,EAAI,EACvBd,EAAIG,IAEJH,EAAIW,KAAKQ,MAAMR,KAAKS,IAAIN,GAASH,KAAKU,KAClCP,GAASC,EAAIJ,KAAKC,IAAI,GAAIZ,IAAM,IAClCA,IACAe,GAAK,IAGLD,GADEd,EAAII,GAAS,EACNY,EAAKD,EAELC,EAAKL,KAAKC,IAAI,EAAG,EAAIR,IAEpBW,GAAK,IACff,IACAe,GAAK,GAGHf,EAAII,GAASD,GACfF,EAAI,EACJD,EAAIG,GACKH,EAAII,GAAS,GACtBH,GAAMa,EAAQC,EAAK,GAAKJ,KAAKC,IAAI,EAAGd,GACpCE,GAAQI,IAERH,EAAIa,EAAQH,KAAKC,IAAI,EAAGR,EAAQ,GAAKO,KAAKC,IAAI,EAAGd,GACjDE,EAAI,IAIDF,GAAQ,EAAGH,EAAOC,EAASU,GAAS,IAAJL,EAAUK,GAAKC,EAAGN,GAAK,IAAKH,GAAQ,GAI3E,IAFAE,EAAKA,GAAKF,EAAQG,EAClBC,GAAQJ,EACDI,EAAO,EAAGP,EAAOC,EAASU,GAAS,IAAJN,EAAUM,GAAKC,EAAGP,GAAK,IAAKE,GAAQ,GAE1EP,EAAOC,EAASU,EAAIC,IAAU,IAAJC,CAC5B,C,4CC3Ee,SAASc,EAAKC,EAAIC,GAC/B,OAAO,WACL,OAAOD,EAAGE,MAAMD,EAASE,UAC7B,CACA,CCPA,MAAM,SAACC,GAAYC,OAAOC,WACpB,eAACC,GAAkBF,QACnB,SAACG,EAAQ,YAAEC,GAAeC,OAE1BC,GAAUC,EAGbP,OAAOQ,OAAO,MAHQC,IACrB,MAAMC,EAAMX,EAASY,KAAKF,GAC1B,OAAOF,EAAMG,KAASH,EAAMG,GAAOA,EAAIE,MAAM,GAAI,GAAGC,iBAFzC,IAACN,EAKhB,MAAMO,EAAcC,IAClBA,EAAOA,EAAKF,cACJJ,GAAUH,EAAOG,KAAWM,GAGhCC,EAAaD,GAAQN,UAAgBA,IAAUM,GAS/C,QAACE,GAAWC,MASZC,EAAcH,EAAW,aAS/B,SAASI,EAASC,GAChB,OAAe,OAARA,IAAiBF,EAAYE,IAA4B,OAApBA,EAAIC,cAAyBH,EAAYE,EAAIC,cACpFC,EAAWF,EAAIC,YAAYF,WAAaC,EAAIC,YAAYF,SAASC,EACxE,CASA,MAAMG,EAAgBV,EAAW,eA2B3BW,EAAWT,EAAW,UAQtBO,EAAaP,EAAW,YASxBU,EAAWV,EAAW,UAStBW,EAAYlB,GAAoB,OAAVA,GAAmC,iBAAVA,EAiB/CmB,EAAiBP,IACrB,GAAoB,WAAhBf,EAAOe,GACT,OAAO,EAGT,MAAMpB,EAAYC,EAAemB,GACjC,QAAsB,OAAdpB,GAAsBA,IAAcD,OAAOC,WAAkD,OAArCD,OAAOE,eAAeD,IAA0BG,KAAeiB,GAAUlB,KAAYkB,IA+BjJQ,EAASf,EAAW,QASpBgB,EAAShB,EAAW,QASpBiB,EAASjB,EAAW,QASpBkB,EAAalB,EAAW,YAsCxBmB,EAAoBnB,EAAW,oBAE9BoB,EAAkBC,EAAWC,EAAYC,GAAa,CAAC,iBAAkB,UAAW,WAAY,WAAWC,IAAIxB,GA2BtH,SAASyB,EAAQC,EAAK7C,GAAI,WAAC8C,GAAa,GAAS,CAAC,GAEhD,GAAID,QACF,OAGF,IAAI9D,EACAgE,EAQJ,GALmB,iBAARF,IAETA,EAAM,CAACA,IAGLvB,EAAQuB,GAEV,IAAK9D,EAAI,EAAGgE,EAAIF,EAAIG,OAAQjE,EAAIgE,EAAGhE,IACjCiB,EAAGgB,KAAK,KAAM6B,EAAI9D,GAAIA,EAAG8D,OAEtB,CAEL,GAAIpB,EAASoB,GACX,OAIF,MAAMI,EAAOH,EAAazC,OAAO6C,oBAAoBL,GAAOxC,OAAO4C,KAAKJ,GAClEM,EAAMF,EAAKD,OACjB,IAAII,EAEJ,IAAKrE,EAAI,EAAGA,EAAIoE,EAAKpE,IACnBqE,EAAMH,EAAKlE,GACXiB,EAAGgB,KAAK,KAAM6B,EAAIO,GAAMA,EAAKP,EAEnC,CACA,CAEA,SAASQ,EAAQR,EAAKO,GACpB,GAAI3B,EAASoB,GACX,OAAO,KAGTO,EAAMA,EAAIlC,cACV,MAAM+B,EAAO5C,OAAO4C,KAAKJ,GACzB,IACIS,EADAvE,EAAIkE,EAAKD,OAEb,KAAOjE,KAAM,GAEX,GADAuE,EAAOL,EAAKlE,GACRqE,IAAQE,EAAKpC,cACf,OAAOoC,EAGX,OAAO,IACT,CAEA,MAAMC,EAEsB,oBAAfC,WAAmCA,WACvB,oBAATC,KAAuBA,KAA0B,oBAAXC,OAAyBA,OAASC,EAAAA,EAGlFC,EAAoBC,IAAarC,EAAYqC,IAAYA,IAAYN,EAkLrEO,GAAgBC,EAKG,oBAAfC,YAA8BzD,EAAeyD,YAH9ClD,GACEiD,GAAcjD,aAAiBiD,GAHrB,IAACA,EAetB,MAiCME,EAAa9C,EAAW,mBAWxB+C,EAAiB,GAAGA,oBAAoB,CAACrB,EAAKsB,IAASD,EAAelD,KAAK6B,EAAKsB,GAA/D,CAAsE9D,OAAOC,WAS9F8D,EAAWjD,EAAW,UAEtBkD,EAAoBA,CAACxB,EAAKyB,KAC9B,MAAMC,EAAclE,OAAOmE,0BAA0B3B,GAC/C4B,EAAqB,CAAC,EAE5B7B,EAAQ2B,EAAa,CAACG,EAAYC,KAChC,IAAIC,GAC2C,KAA1CA,EAAMN,EAAQI,EAAYC,EAAM9B,MACnC4B,EAAmBE,GAAQC,GAAOF,KAItCrE,OAAOwE,iBAAiBhC,EAAK4B,IAuGzBK,EAAY3D,EAAW,iBAQvB4D,GAAkBC,EAkBE,mBAAjBC,aAlBsCC,EAmB7CtD,EAAW2B,EAAQ4B,aAlBfH,EACKC,aAGFC,GAAyBE,EAW7B,SAAShG,KAAKiG,WAXsBC,EAWV,GAV3B/B,EAAQgC,iBAAiB,UAAW,EAAEC,SAAQC,WACxCD,IAAWjC,GAAWkC,IAASL,GACjCE,EAAUtC,QAAUsC,EAAUI,OAAVJ,KAErB,GAEKK,IACNL,EAAUM,KAAKD,GACfpC,EAAQ4B,YAAYC,EAAO,OAEKO,GAAOE,WAAWF,IAhBlC,IAAEX,EAAuBE,EAKbE,EAAOE,EAiBzC,MAAMQ,EAAiC,oBAAnBC,eAClBA,eAAehG,KAAKwD,GAAgC,oBAAZyC,SAA2BA,QAAQC,UAAYlB,EAQzF,IAAAmB,EAAe,CACb5E,UACAO,gBACAJ,WACA0E,WApgBkBrF,IAClB,IAAIsF,EACJ,OAAOtF,IACgB,mBAAbuF,UAA2BvF,aAAiBuF,UAClDzE,EAAWd,EAAMwF,UACY,cAA1BF,EAAOzF,EAAOG,KAEL,WAATsF,GAAqBxE,EAAWd,EAAMV,WAAkC,sBAArBU,EAAMV,cA8fhEmG,kBAnpBF,SAA2B7E,GACzB,IAAI8E,EAMJ,OAJEA,EAD0B,oBAAhBC,aAAiCA,YAAYC,OAC9CD,YAAYC,OAAOhF,GAElBA,GAASA,EAAItD,QAAYyD,EAAcH,EAAItD,QAEhDoI,CACT,EA4oBE1E,WACAC,WACA4E,UAnmBgB7F,IAAmB,IAAVA,IAA4B,IAAVA,EAomB3CkB,WACAC,gBACA2E,cA7kBqBlF,IAErB,IAAKM,EAASN,IAAQD,EAASC,GAC7B,OAAO,EAGT,IACE,OAAmC,IAA5BrB,OAAO4C,KAAKvB,GAAKsB,QAAgB3C,OAAOE,eAAemB,KAASrB,OAAOC,SAClF,CAAI,MAAO7B,GAEP,OAAO,CACX,GAmkBE8D,mBACAC,YACAC,aACAC,YACAlB,cACAU,SACAC,SACAC,SACAgC,WACFyC,WAAEjF,EACAkF,SA/hBgBpF,GAAQM,EAASN,IAAQE,EAAWF,EAAIqF,MAgiBxDzE,oBACAwB,eACAzB,aACAO,UACAoE,MAxZF,SAASA,IACP,MAAM,SAACC,EAAQ,cAAEC,GAAiBtD,EAAiB1F,OAASA,MAAQ,CAAC,EAC/DsI,EAAS,CAAC,EACVW,EAAcA,CAACzF,EAAK0B,KACxB,MAAMgE,EAAYH,GAAY5D,EAAQmD,EAAQpD,IAAQA,EAClDnB,EAAcuE,EAAOY,KAAenF,EAAcP,GACpD8E,EAAOY,GAAaJ,EAAMR,EAAOY,GAAY1F,GACpCO,EAAcP,GACvB8E,EAAOY,GAAaJ,EAAM,CAAC,EAAGtF,GACrBJ,EAAQI,GACjB8E,EAAOY,GAAa1F,EAAIT,QACdiG,GAAkB1F,EAAYE,KACxC8E,EAAOY,GAAa1F,IAIxB,IAAK,IAAI3C,EAAI,EAAGgE,EAAI5C,UAAU6C,OAAQjE,EAAIgE,EAAGhE,IAC3CoB,UAAUpB,IAAM6D,EAAQzC,UAAUpB,GAAIoI,GAExC,OAAOX,CACT,EAqYEa,OAzXaA,CAACC,EAAGC,EAAGtH,GAAU6C,cAAa,CAAC,KAC5CF,EAAQ2E,EAAG,CAAC7F,EAAK0B,KACXnD,GAAW2B,EAAWF,GACxB4F,EAAElE,GAAOrD,EAAK2B,EAAKzB,GAEnBqH,EAAElE,GAAO1B,GAEV,CAACoB,eACGwE,GAkXPE,KA9fYzG,GAAQA,EAAIyG,KACxBzG,EAAIyG,OAASzG,EAAI0G,QAAQ,qCAAsC,IA8f/DC,SAzWgBC,IACc,QAA1BA,EAAQC,WAAW,KACrBD,EAAUA,EAAQ1G,MAAM,IAEnB0G,GAsWPE,SA1VeA,CAAClG,EAAamG,EAAkBC,EAAOxD,KACtD5C,EAAYrB,UAAYD,OAAOQ,OAAOiH,EAAiBxH,UAAWiE,GAClE5C,EAAYrB,UAAUqB,YAAcA,EACpCtB,OAAO2H,eAAerG,EAAa,QAAS,CAC1CpC,MAAOuI,EAAiBxH,YAE1ByH,GAAS1H,OAAO4H,OAAOtG,EAAYrB,UAAWyH,IAqV9CG,aAzUmBA,CAACC,EAAWC,EAASC,EAAQC,KAChD,IAAIP,EACAhJ,EACAoF,EACJ,MAAMoE,EAAS,CAAC,EAIhB,GAFAH,EAAUA,GAAW,CAAC,EAEL,MAAbD,EAAmB,OAAOC,EAE9B,EAAG,CAGD,IAFAL,EAAQ1H,OAAO6C,oBAAoBiF,GACnCpJ,EAAIgJ,EAAM/E,OACHjE,KAAM,GACXoF,EAAO4D,EAAMhJ,GACPuJ,IAAcA,EAAWnE,EAAMgE,EAAWC,IAAcG,EAAOpE,KACnEiE,EAAQjE,GAAQgE,EAAUhE,GAC1BoE,EAAOpE,IAAQ,GAGnBgE,GAAuB,IAAXE,GAAoB9H,EAAe4H,EACnD,OAAWA,KAAeE,GAAUA,EAAOF,EAAWC,KAAaD,IAAc9H,OAAOC,WAEtF,OAAO8H,GAmTPzH,SACAQ,aACAqH,SAzSeA,CAACzH,EAAK0H,EAAcC,KACnC3H,EAAM4H,OAAO5H,SACI6H,IAAbF,GAA0BA,EAAW3H,EAAIiC,UAC3C0F,EAAW3H,EAAIiC,QAEjB0F,GAAYD,EAAazF,OACzB,MAAM6F,EAAY9H,EAAI+H,QAAQL,EAAcC,GAC5C,OAAsB,IAAfG,GAAoBA,IAAcH,GAmSzCK,QAxRejI,IACf,IAAKA,EAAO,OAAO,KACnB,GAAIQ,EAAQR,GAAQ,OAAOA,EAC3B,IAAI/B,EAAI+B,EAAMkC,OACd,IAAKjB,EAAShD,GAAI,OAAO,KACzB,MAAMiK,EAAM,IAAIzH,MAAMxC,GACtB,KAAOA,KAAM,GACXiK,EAAIjK,GAAK+B,EAAM/B,GAEjB,OAAOiK,GAgRPC,aArPmBA,CAACpG,EAAK7C,KACzB,MAEMkJ,GAFYrG,GAAOA,EAAIrC,IAEDQ,KAAK6B,GAEjC,IAAI2D,EAEJ,MAAQA,EAAS0C,EAAUC,UAAY3C,EAAO4C,MAAM,CAClD,MAAMC,EAAO7C,EAAOjH,MACpBS,EAAGgB,KAAK6B,EAAKwG,EAAK,GAAIA,EAAK,GAC/B,GA4OEC,SAjOeA,CAACC,EAAQxI,KACxB,IAAIyI,EACJ,MAAMR,EAAM,GAEZ,KAAwC,QAAhCQ,EAAUD,EAAOE,KAAK1I,KAC5BiI,EAAIpD,KAAK4D,GAGX,OAAOR,GA0NP/E,aACAC,iBACAwF,WAAYxF,EACZG,oBACAsF,cAjLqB9G,IACrBwB,EAAkBxB,EAAK,CAAC6B,EAAYC,KAElC,GAAI/C,EAAWiB,KAA6D,IAArD,CAAC,YAAa,SAAU,UAAUiG,QAAQnE,GAC/D,OAAO,EAGT,MAAMpF,EAAQsD,EAAI8B,GAEb/C,EAAWrC,KAEhBmF,EAAWkF,YAAa,EAEpB,aAAclF,EAChBA,EAAWmF,UAAW,EAInBnF,EAAWoF,MACdpF,EAAWoF,IAAM,KACf,MAAMC,MAAM,qCAAwCpF,EAAO,WA8JjEqF,YAxJkBA,CAACC,EAAeC,KAClC,MAAMrH,EAAM,CAAC,EAEP7E,EAAUgL,IACdA,EAAIpG,QAAQrD,IACVsD,EAAItD,IAAS,KAMjB,OAFA+B,EAAQ2I,GAAiBjM,EAAOiM,GAAiBjM,EAAO2K,OAAOsB,GAAeE,MAAMD,IAE7ErH,GA8IPuH,YA1NkBrJ,GACXA,EAAIG,cAAcuG,QAAQ,wBAC/B,SAAkB/I,EAAG2L,EAAIC,GACvB,OAAOD,EAAGE,cAAgBD,CAChC,GAuNEE,KA5IWA,OA6IXC,eA3IqBA,CAAClL,EAAOmL,IACb,MAATnL,GAAiBoL,OAAOC,SAASrL,GAASA,GAASA,EAAQmL,EA2IlErH,UACAM,OAAQJ,EACRK,mBACAiH,oBAlIF,SAA6B/J,GAC3B,SAAUA,GAASc,EAAWd,EAAMwF,SAAkC,aAAvBxF,EAAML,IAA+BK,EAAMN,GAC5F,EAiIEsK,aA/HoBjI,IACpB,MAAMkI,EAAQ,IAAIxJ,MAAM,IAElByJ,EAAQA,CAACxF,EAAQzG,KAErB,GAAIiD,EAASwD,GAAS,CACpB,GAAIuF,EAAMjC,QAAQtD,IAAW,EAC3B,OAIF,GAAI/D,EAAS+D,GACX,OAAOA,EAGT,KAAK,WAAYA,GAAS,CACxBuF,EAAMhM,GAAKyG,EACX,MAAMyF,EAAS3J,EAAQkE,GAAU,GAAK,CAAC,EASvC,OAPA5C,EAAQ4C,EAAQ,CAACjG,EAAO6D,KACtB,MAAM8H,EAAeF,EAAMzL,EAAOR,EAAI,IACrCyC,EAAY0J,KAAkBD,EAAO7H,GAAO8H,KAG/CH,EAAMhM,QAAK6J,EAEJqC,CACf,CACA,CAEI,OAAOzF,GAGT,OAAOwF,EAAMnI,EAAK,IA+FlBiC,YACAqG,WA3FkBrK,GAClBA,IAAUkB,EAASlB,IAAUc,EAAWd,KAAWc,EAAWd,EAAMsK,OAASxJ,EAAWd,EAAMuK,OA2F9FpG,aAAcF,EACde,OACAwF,WA5DkBxK,GAAmB,MAATA,GAAiBc,EAAWd,EAAMN,KCjsBhE,SAAS+K,EAAWC,EAASC,EAAMC,EAAQC,EAASC,GAClD7B,MAAM/I,KAAK9C,MAEP6L,MAAM8B,kBACR9B,MAAM8B,kBAAkB3N,KAAMA,KAAKyD,aAEnCzD,KAAK6M,OAAS,IAAIhB,OAASgB,MAG7B7M,KAAKsN,QAAUA,EACftN,KAAKyG,KAAO,aACZ8G,IAASvN,KAAKuN,KAAOA,GACrBC,IAAWxN,KAAKwN,OAASA,GACzBC,IAAYzN,KAAKyN,QAAUA,GACvBC,IACF1N,KAAK0N,SAAWA,EAChB1N,KAAK4N,OAASF,EAASE,OAASF,EAASE,OAAS,KAEtD,CAEA5F,EAAM2B,SAAS0D,EAAYxB,MAAO,CAChCgC,OAAQ,WACN,MAAO,CAELP,QAAStN,KAAKsN,QACd7G,KAAMzG,KAAKyG,KAEXqH,YAAa9N,KAAK8N,YAClBC,OAAQ/N,KAAK+N,OAEbC,SAAUhO,KAAKgO,SACfC,WAAYjO,KAAKiO,WACjBC,aAAclO,KAAKkO,aACnBrB,MAAO7M,KAAK6M,MAEZW,OAAQxF,EAAM4E,aAAa5M,KAAKwN,QAChCD,KAAMvN,KAAKuN,KACXK,OAAQ5N,KAAK4N,OAEnB,IAGA,MAAMO,EAAYd,EAAWjL,UACvBiE,EAAc,CAAC,EC5CrB,SAAS+H,EAAYxL,GACnB,OAAOoF,EAAMjE,cAAcnB,IAAUoF,EAAM5E,QAAQR,EACrD,CASA,SAASyL,EAAenJ,GACtB,OAAO8C,EAAMsC,SAASpF,EAAK,MAAQA,EAAInC,MAAM,GAAI,GAAKmC,CACxD,CAWA,SAASoJ,GAAUC,EAAMrJ,EAAKsJ,GAC5B,OAAKD,EACEA,EAAKE,OAAOvJ,GAAKT,IAAI,SAAcyC,EAAOrG,GAG/C,OADAqG,EAAQmH,EAAenH,IACfsH,GAAQ3N,EAAI,IAAMqG,EAAQ,IAAMA,CAC5C,GAAKwH,KAAKF,EAAO,IAAM,IALHtJ,CAMpB,CDeA,CACE,uBACA,iBACA,eACA,YACA,cACA,4BACA,iBACA,mBACA,kBACA,eACA,kBACA,mBAEAR,QAAQ6I,IACRlH,EAAYkH,GAAQ,CAAClM,MAAOkM,KAG9BpL,OAAOwE,iBAAiB0G,EAAYhH,GACpClE,OAAO2H,eAAeqE,EAAW,eAAgB,CAAC9M,OAAO,IAGzDgM,EAAWsB,KAAO,CAACC,EAAOrB,EAAMC,EAAQC,EAASC,EAAUmB,KACzD,MAAMC,EAAa3M,OAAOQ,OAAOwL,GAEjCnG,EAAMgC,aAAa4E,EAAOE,EAAY,SAAgBnK,GACpD,OAAOA,IAAQkH,MAAMzJ,SACzB,EAAK6D,GACe,iBAATA,GAGT,MAAM8I,EAAMH,GAASA,EAAMtB,QAAUsB,EAAMtB,QAAU,QAG/C0B,EAAkB,MAARzB,GAAgBqB,EAAQA,EAAMrB,KAAOA,EAYrD,OAXAF,EAAWvK,KAAKgM,EAAYC,EAAKC,EAASxB,EAAQC,EAASC,GAGvDkB,GAA6B,MAApBE,EAAWG,OACtB9M,OAAO2H,eAAegF,EAAY,QAAS,CAAEzN,MAAOuN,EAAOM,cAAc,IAG3EJ,EAAWrI,KAAQmI,GAASA,EAAMnI,MAAS,QAE3CoI,GAAe1M,OAAO4H,OAAO+E,EAAYD,GAElCC,GChDT,MAAMK,GAAanH,EAAMgC,aAAahC,EAAO,CAAC,EAAG,KAAM,SAAgB/B,GACrE,MAAO,WAAWmJ,KAAKnJ,EACzB,GAyBA,SAASoJ,GAAW1K,EAAK2K,EAAUC,GACjC,IAAKvH,EAAMlE,SAASa,GAClB,MAAM,IAAI6K,UAAU,4BAItBF,EAAWA,GAAY,IAAyBnH,SAYhD,MAAMsH,GATNF,EAAUvH,EAAMgC,aAAauF,EAAS,CACpCE,YAAY,EACZjB,MAAM,EACNkB,SAAS,IACR,EAAO,SAAiBC,EAAQrI,GAEjC,OAAQU,EAAM1E,YAAYgE,EAAOqI,GACrC,IAE6BF,WAErBG,EAAUL,EAAQK,SAAWC,EAC7BrB,EAAOe,EAAQf,KACfkB,EAAUH,EAAQG,QAElBI,GADQP,EAAQQ,MAAwB,oBAATA,MAAwBA,OACpC/H,EAAM2E,oBAAoB2C,GAEnD,IAAKtH,EAAMW,WAAWiH,GACpB,MAAM,IAAIJ,UAAU,8BAGtB,SAASQ,EAAa3O,GACpB,GAAc,OAAVA,EAAgB,MAAO,GAE3B,GAAI2G,EAAMhE,OAAO3C,GACf,OAAOA,EAAM4O,cAGf,GAAIjI,EAAMS,UAAUpH,GAClB,OAAOA,EAAMa,WAGf,IAAK4N,GAAW9H,EAAM9D,OAAO7C,GAC3B,MAAM,IAAIgM,EAAW,gDAGvB,OAAIrF,EAAMrE,cAActC,IAAU2G,EAAMpC,aAAavE,GAC5CyO,GAA2B,mBAATC,KAAsB,IAAIA,KAAK,CAAC1O,IAAU6O,EAAOvB,KAAKtN,GAG1EA,CACX,CAYE,SAASwO,EAAexO,EAAO6D,EAAKqJ,GAClC,IAAIzD,EAAMzJ,EAEV,GAAIA,IAAUkN,GAAyB,iBAAVlN,EAC3B,GAAI2G,EAAMsC,SAASpF,EAAK,MAEtBA,EAAMuK,EAAavK,EAAMA,EAAInC,MAAM,GAAI,GAEvC1B,EAAQ8O,KAAKC,UAAU/O,QAClB,GACJ2G,EAAM5E,QAAQ/B,IAvGvB,SAAqByJ,GACnB,OAAO9C,EAAM5E,QAAQ0H,KAASA,EAAIuF,KAAKjC,EACzC,CAqGiCkC,CAAYjP,KACnC2G,EAAM7D,WAAW9C,IAAU2G,EAAMsC,SAASpF,EAAK,SAAW4F,EAAM9C,EAAM6C,QAAQxJ,IAYhF,OATA6D,EAAMmJ,EAAenJ,GAErB4F,EAAIpG,QAAQ,SAAc6L,EAAIC,IAC1BxI,EAAM1E,YAAYiN,IAAc,OAAPA,GAAgBjB,EAASlH,QAEtC,IAAZsH,EAAmBpB,GAAU,CAACpJ,GAAMsL,EAAOhC,GAAqB,OAAZkB,EAAmBxK,EAAMA,EAAM,KACnF8K,EAAaO,GAEzB,IACe,EAIX,QAAInC,EAAY/M,KAIhBiO,EAASlH,OAAOkG,GAAUC,EAAMrJ,EAAKsJ,GAAOwB,EAAa3O,KAElD,EACX,CAEE,MAAMwL,EAAQ,GAER4D,EAAiBtO,OAAO4H,OAAOoF,GAAY,CAC/CU,iBACAG,eACA5B,gBAyBF,IAAKpG,EAAMlE,SAASa,GAClB,MAAM,IAAI6K,UAAU,0BAKtB,OA5BA,SAASkB,EAAMrP,EAAOkN,GACpB,IAAIvG,EAAM1E,YAAYjC,GAAtB,CAEA,IAA8B,IAA1BwL,EAAMjC,QAAQvJ,GAChB,MAAMwK,MAAM,kCAAoC0C,EAAKG,KAAK,MAG5D7B,EAAMnF,KAAKrG,GAEX2G,EAAMtD,QAAQrD,EAAO,SAAckP,EAAIrL,IAKtB,OAJE8C,EAAM1E,YAAYiN,IAAc,OAAPA,IAAgBX,EAAQ9M,KAChEwM,EAAUiB,EAAIvI,EAAMpE,SAASsB,GAAOA,EAAIoE,OAASpE,EAAKqJ,EAAMkC,KAI5DC,EAAMH,EAAIhC,EAAOA,EAAKE,OAAOvJ,GAAO,CAACA,GAE7C,GAEI2H,EAAM8D,KAlB8B,CAmBxC,CAMED,CAAM/L,GAEC2K,CACT,CChNA,SAASsB,GAAO/N,GACd,MAAMgO,EAAU,CACd,IAAK,MACL,IAAK,MACL,IAAK,MACL,IAAK,MACL,IAAK,MACL,MAAO,IACP,MAAO,MAET,OAAOC,mBAAmBjO,GAAK0G,QAAQ,mBAAoB,SAAkBwH,GAC3E,OAAOF,EAAQE,EACnB,EACA,CAUA,SAASC,GAAqBC,EAAQ1B,GACpCvP,KAAKkR,OAAS,GAEdD,GAAU5B,GAAW4B,EAAQjR,KAAMuP,EACrC,CAEA,MAAMnN,GAAY4O,GAAqB5O,UC5BvC,SAAS+O,GAAO3N,GACd,OAAOsN,mBAAmBtN,GACxB+F,QAAQ,QAAS,KACjBA,QAAQ,OAAQ,KAChBA,QAAQ,QAAS,KACjBA,QAAQ,OAAQ,IACpB,CAWe,SAAS6H,GAASC,EAAKJ,EAAQ1B,GAE5C,IAAK0B,EACH,OAAOI,EAGT,MAAMC,EAAU/B,GAAWA,EAAQ4B,QAAUA,GAEzCnJ,EAAMW,WAAW4G,KACnBA,EAAU,CACRgC,UAAWhC,IAIf,MAAMiC,EAAcjC,GAAWA,EAAQgC,UAEvC,IAAIE,EAUJ,GAPEA,EADED,EACiBA,EAAYP,EAAQ1B,GAEpBvH,EAAM5D,kBAAkB6M,GACzCA,EAAO/O,WACP,IAAI8O,GAAqBC,EAAQ1B,GAASrN,SAASoP,GAGnDG,EAAkB,CACpB,MAAMC,EAAgBL,EAAIzG,QAAQ,MAEX,IAAnB8G,IACFL,EAAMA,EAAItO,MAAM,EAAG2O,IAErBL,KAA8B,IAAtBA,EAAIzG,QAAQ,KAAc,IAAM,KAAO6G,CACnD,CAEE,OAAOJ,CACT,CDvBAjP,GAAUgG,OAAS,SAAgB3B,EAAMpF,GACvCrB,KAAKkR,OAAOxJ,KAAK,CAACjB,EAAMpF,GAC1B,EAEAe,GAAUF,SAAW,SAAkByP,GACrC,MAAML,EAAUK,EAAU,SAAStQ,GACjC,OAAOsQ,EAAQ7O,KAAK9C,KAAMqB,EAAOuP,GACrC,EAAMA,GAEJ,OAAO5Q,KAAKkR,OAAOzM,IAAI,SAAc0G,GACnC,OAAOmG,EAAQnG,EAAK,IAAM,IAAMmG,EAAQnG,EAAK,GACjD,EAAK,IAAIuD,KAAK,IACd,EEeA,IAAAkD,GAlEA,MACEnO,WAAAA,GACEzD,KAAK6R,SAAW,EACpB,CAUEC,GAAAA,CAAIC,EAAWC,EAAUzC,GAOvB,OANAvP,KAAK6R,SAASnK,KAAK,CACjBqK,YACAC,WACAC,cAAa1C,GAAUA,EAAQ0C,YAC/BC,QAAS3C,EAAUA,EAAQ2C,QAAU,OAEhClS,KAAK6R,SAAS/M,OAAS,CAClC,CASEqN,KAAAA,CAAMC,GACApS,KAAK6R,SAASO,KAChBpS,KAAK6R,SAASO,GAAM,KAE1B,CAOEC,KAAAA,GACMrS,KAAK6R,WACP7R,KAAK6R,SAAW,GAEtB,CAYEnN,OAAAA,CAAQ5C,GACNkG,EAAMtD,QAAQ1E,KAAK6R,SAAU,SAAwBS,GACzC,OAANA,GACFxQ,EAAGwQ,EAEX,EACA,GCjEAC,GAAe,CACbC,mBAAmB,EACnBC,mBAAmB,EACnBC,qBAAqB,GCDvBC,GAAe,CACbC,WAAW,EACXC,QAAS,CACXC,gBCJ0C,oBAApBA,gBAAkCA,gBAAkB9B,GDK1E7I,SENmC,oBAAbA,SAA2BA,SAAW,KFO5D4H,KGP+B,oBAATA,KAAuBA,KAAO,MHSlDgD,UAAW,CAAC,OAAQ,QAAS,OAAQ,OAAQ,MAAO,SIXtD,MAAMC,GAAkC,oBAAXxN,QAA8C,oBAAbyN,SAExDC,GAAkC,iBAAdC,WAA0BA,gBAAazI,EAmB3D0I,GAAwBJ,MAC1BE,IAAc,CAAC,cAAe,eAAgB,MAAMtI,QAAQsI,GAAWG,SAAW,GAWhFC,GAE2B,oBAAtBC,mBAEPhO,gBAAgBgO,mBACc,mBAAvBhO,KAAKiO,cAIVC,GAAST,IAAiBxN,OAAOkO,SAASC,MAAQ,mB,ICvCxDC,GAAe,I,sIAEVjB,IC2CL,SAASkB,GAAevE,GACtB,SAASwE,EAAUvF,EAAMlN,EAAO0L,EAAQyD,GACtC,IAAI/J,EAAO8H,EAAKiC,KAEhB,GAAa,cAAT/J,EAAsB,OAAO,EAEjC,MAAMsN,EAAetH,OAAOC,UAAUjG,GAChCuN,EAASxD,GAASjC,EAAKzJ,OAG7B,OAFA2B,GAAQA,GAAQuB,EAAM5E,QAAQ2J,GAAUA,EAAOjI,OAAS2B,EAEpDuN,GACEhM,EAAMwD,WAAWuB,EAAQtG,GAC3BsG,EAAOtG,GAAQ,CAACsG,EAAOtG,GAAOpF,GAE9B0L,EAAOtG,GAAQpF,GAGT0S,IAGLhH,EAAOtG,IAAUuB,EAAMlE,SAASiJ,EAAOtG,MAC1CsG,EAAOtG,GAAQ,IAGFqN,EAAUvF,EAAMlN,EAAO0L,EAAOtG,GAAO+J,IAEtCxI,EAAM5E,QAAQ2J,EAAOtG,MACjCsG,EAAOtG,GA/Cb,SAAuBqE,GACrB,MAAMnG,EAAM,CAAC,EACPI,EAAO5C,OAAO4C,KAAK+F,GACzB,IAAIjK,EACJ,MAAMoE,EAAMF,EAAKD,OACjB,IAAII,EACJ,IAAKrE,EAAI,EAAGA,EAAIoE,EAAKpE,IACnBqE,EAAMH,EAAKlE,GACX8D,EAAIO,GAAO4F,EAAI5F,GAEjB,OAAOP,CACT,CAoCqBsP,CAAclH,EAAOtG,MAG9BsN,EACZ,CAEE,GAAI/L,EAAMC,WAAWqH,IAAatH,EAAMW,WAAW2G,EAAS4E,SAAU,CACpE,MAAMvP,EAAM,CAAC,EAMb,OAJAqD,EAAM+C,aAAauE,EAAU,CAAC7I,EAAMpF,KAClCyS,EA1EN,SAAuBrN,GAKrB,OAAOuB,EAAMoD,SAAS,gBAAiB3E,GAAMhC,IAAIsM,GAC3B,OAAbA,EAAM,GAAc,GAAKA,EAAM,IAAMA,EAAM,GAEtD,CAkEgBoD,CAAc1N,GAAOpF,EAAOsD,EAAK,KAGtCA,CACX,CAEE,OAAO,IACT,CCzDA,MAAMyP,GAAW,CAEfC,aAAc9B,GAEd+B,QAAS,CAAC,MAAO,OAAQ,SAEzBC,iBAAkB,CAAC,SAA0BhN,EAAMiN,GACjD,MAAMC,EAAcD,EAAQE,kBAAoB,GAC1CC,EAAqBF,EAAY7J,QAAQ,qBAAuB,EAChEgK,EAAkB5M,EAAMlE,SAASyD,GAQvC,GANIqN,GAAmB5M,EAAMjC,WAAWwB,KACtCA,EAAO,IAAIY,SAASZ,IAGHS,EAAMC,WAAWV,GAGlC,OAAOoN,EAAqBxE,KAAKC,UAAUyD,GAAetM,IAASA,EAGrE,GAAIS,EAAMrE,cAAc4D,IACtBS,EAAMzE,SAASgE,IACfS,EAAMY,SAASrB,IACfS,EAAM/D,OAAOsD,IACbS,EAAM9D,OAAOqD,IACbS,EAAM3D,iBAAiBkD,GAEvB,OAAOA,EAET,GAAIS,EAAMK,kBAAkBd,GAC1B,OAAOA,EAAKrH,OAEd,GAAI8H,EAAM5D,kBAAkBmD,GAE1B,OADAiN,EAAQK,eAAe,mDAAmD,GACnEtN,EAAKrF,WAGd,IAAIiC,EAEJ,GAAIyQ,EAAiB,CACnB,GAAIH,EAAY7J,QAAQ,sCAAwC,EAC9D,OCvEO,SAA0BrD,EAAMgI,GAC7C,OAAOF,GAAW9H,EAAM,IAAIqM,GAASf,QAAQC,gBAAmB,CAC9DlD,QAAS,SAASvO,EAAO6D,EAAKqJ,EAAMuG,GAClC,OAAIlB,GAASmB,QAAU/M,EAAMzE,SAASlC,IACpCrB,KAAKoI,OAAOlD,EAAK7D,EAAMa,SAAS,YACzB,GAGF4S,EAAQjF,eAAe7N,MAAMhC,KAAMiC,UAChD,KACOsN,GAEP,CD2DeyF,CAAiBzN,EAAMvH,KAAKiV,gBAAgB/S,WAGrD,IAAKiC,EAAa6D,EAAM7D,WAAWoD,KAAUkN,EAAY7J,QAAQ,wBAA0B,EAAG,CAC5F,MAAMsK,EAAYlV,KAAKmV,KAAOnV,KAAKmV,IAAIhN,SAEvC,OAAOkH,GACLlL,EAAa,CAAC,UAAWoD,GAAQA,EACjC2N,GAAa,IAAIA,EACjBlV,KAAKiV,eAEf,CACA,CAEI,OAAIL,GAAmBD,GACrBH,EAAQK,eAAe,oBAAoB,GAxEjD,SAAyBO,GACvB,GAAIpN,EAAMpE,SAASwR,GACjB,IAEE,OADA,EAAWjF,KAAKkF,OAAOD,GAChBpN,EAAMsB,KAAK8L,EACxB,CAAM,MAAO7U,GACP,GAAe,gBAAXA,EAAEkG,KACJ,MAAMlG,CAEd,CAGE,OAAO,EAAY4P,KAAKC,WAAWgF,EACrC,CA4DaE,CAAgB/N,IAGlBA,CACX,GAEEgO,kBAAmB,CAAC,SAA2BhO,GAC7C,MAAM8M,EAAerU,KAAKqU,cAAgBD,GAASC,aAC7C5B,EAAoB4B,GAAgBA,EAAa5B,kBACjD+C,EAAsC,SAAtBxV,KAAKyV,aAE3B,GAAIzN,EAAMzD,WAAWgD,IAASS,EAAM3D,iBAAiBkD,GACnD,OAAOA,EAGT,GAAIA,GAAQS,EAAMpE,SAAS2D,KAAWkL,IAAsBzS,KAAKyV,cAAiBD,GAAgB,CAChG,MACME,IADoBrB,GAAgBA,EAAa7B,oBACPgD,EAEhD,IACE,OAAOrF,KAAKkF,MAAM9N,EAAMvH,KAAK2V,aACrC,CAAQ,MAAOpV,GACP,GAAImV,EAAmB,CACrB,GAAe,gBAAXnV,EAAEkG,KACJ,MAAM4G,EAAWsB,KAAKpO,EAAG8M,EAAWuI,iBAAkB5V,KAAM,KAAMA,KAAK0N,UAEzE,MAAMnN,CAChB,CACA,CACA,CAEI,OAAOgH,CACX,GAMEsO,QAAS,EAETC,eAAgB,aAChBC,eAAgB,eAEhBC,kBAAmB,EACnBC,eAAgB,EAEhBd,IAAK,CACHhN,SAAUyL,GAASf,QAAQ1K,SAC3B4H,KAAM6D,GAASf,QAAQ9C,MAGzBmG,eAAgB,SAAwBtI,GACtC,OAAOA,GAAU,KAAOA,EAAS,GACrC,EAEE4G,QAAS,CACP2B,OAAQ,CACN,OAAU,oCACV,oBAAgBzL,KAKtB1C,EAAMtD,QAAQ,CAAC,SAAU,MAAO,OAAQ,OAAQ,MAAO,SAAW0R,IAChEhC,GAASI,QAAQ4B,GAAU,CAAC,IAG9B,IAAAC,GAAejC,GE1Jf,MAAMkC,GAAoBtO,EAAM8D,YAAY,CAC1C,MAAO,gBAAiB,iBAAkB,eAAgB,OAC1D,UAAW,OAAQ,OAAQ,oBAAqB,sBAChD,gBAAiB,WAAY,eAAgB,sBAC7C,UAAW,cAAe,eCLtByK,GAAa/T,OAAO,aAE1B,SAASgU,GAAgBC,GACvB,OAAOA,GAAUhM,OAAOgM,GAAQnN,OAAOtG,aACzC,CAEA,SAAS0T,GAAerV,GACtB,OAAc,IAAVA,GAA4B,MAATA,EACdA,EAGF2G,EAAM5E,QAAQ/B,GAASA,EAAMoD,IAAIiS,IAAkBjM,OAAOpJ,EACnE,CAgBA,SAASsV,GAAiBhR,EAAStE,EAAOoV,EAAQtM,EAAQyM,GACxD,OAAI5O,EAAMW,WAAWwB,GACZA,EAAOrH,KAAK9C,KAAMqB,EAAOoV,IAG9BG,IACFvV,EAAQoV,GAGLzO,EAAMpE,SAASvC,GAEhB2G,EAAMpE,SAASuG,IACiB,IAA3B9I,EAAMuJ,QAAQT,GAGnBnC,EAAM9B,SAASiE,GACVA,EAAOiF,KAAK/N,QADrB,OANA,EASF,CAsBA,MAAMwV,GACJpT,WAAAA,CAAY+Q,GACVA,GAAWxU,KAAK4L,IAAI4I,EACxB,CAEE5I,GAAAA,CAAI6K,EAAQK,EAAgBC,GAC1B,MAAMxR,EAAOvF,KAEb,SAASgX,EAAUC,EAAQC,EAASC,GAClC,MAAMC,EAAUZ,GAAgBU,GAEhC,IAAKE,EACH,MAAM,IAAIvL,MAAM,0CAGlB,MAAM3G,EAAM8C,EAAM7C,QAAQI,EAAM6R,KAE5BlS,QAAqBwF,IAAdnF,EAAKL,KAAmC,IAAbiS,QAAmCzM,IAAbyM,IAAwC,IAAd5R,EAAKL,MACzFK,EAAKL,GAAOgS,GAAWR,GAAeO,GAE9C,CAEI,MAAMI,EAAaA,CAAC7C,EAAS2C,IAC3BnP,EAAMtD,QAAQ8P,EAAS,CAACyC,EAAQC,IAAYF,EAAUC,EAAQC,EAASC,IAEzE,GAAInP,EAAMjE,cAAc0S,IAAWA,aAAkBzW,KAAKyD,YACxD4T,EAAWZ,EAAQK,QACd,GAAG9O,EAAMpE,SAAS6S,KAAYA,EAASA,EAAOnN,UArEtB,iCAAiC8F,KAqEmBqH,EArEVnN,QAsEvE+N,ED1ESC,KACb,MAAMC,EAAS,CAAC,EAChB,IAAIrS,EACA1B,EACA3C,EAsBJ,OApBAyW,GAAcA,EAAWrL,MAAM,MAAMvH,QAAQ,SAAgB8S,GAC3D3W,EAAI2W,EAAK5M,QAAQ,KACjB1F,EAAMsS,EAAKC,UAAU,EAAG5W,GAAGyI,OAAOtG,cAClCQ,EAAMgU,EAAKC,UAAU5W,EAAI,GAAGyI,QAEvBpE,GAAQqS,EAAOrS,IAAQoR,GAAkBpR,KAIlC,eAARA,EACEqS,EAAOrS,GACTqS,EAAOrS,GAAKwC,KAAKlE,GAEjB+T,EAAOrS,GAAO,CAAC1B,GAGjB+T,EAAOrS,GAAOqS,EAAOrS,GAAOqS,EAAOrS,GAAO,KAAO1B,EAAMA,EAE7D,GAES+T,GCgDQG,CAAajB,GAASK,QAC5B,GAAI9O,EAAMlE,SAAS2S,IAAWzO,EAAMoF,WAAWqJ,GAAS,CAC7D,IAAckB,EAAMzS,EAAhBP,EAAM,CAAC,EACX,IAAK,MAAMiT,KAASnB,EAAQ,CAC1B,IAAKzO,EAAM5E,QAAQwU,GACjB,MAAMpI,UAAU,gDAGlB7K,EAAIO,EAAM0S,EAAM,KAAOD,EAAOhT,EAAIO,IAC/B8C,EAAM5E,QAAQuU,GAAQ,IAAIA,EAAMC,EAAM,IAAM,CAACD,EAAMC,EAAM,IAAOA,EAAM,EACjF,CAEMP,EAAW1S,EAAKmS,EACtB,MACgB,MAAVL,GAAkBO,EAAUF,EAAgBL,EAAQM,GAGtD,OAAO/W,IACX,CAEE6X,GAAAA,CAAIpB,EAAQqB,GAGV,GAFArB,EAASD,GAAgBC,GAEb,CACV,MAAMvR,EAAM8C,EAAM7C,QAAQnF,KAAMyW,GAEhC,GAAIvR,EAAK,CACP,MAAM7D,EAAQrB,KAAKkF,GAEnB,IAAK4S,EACH,OAAOzW,EAGT,IAAe,IAAXyW,EACF,OApHV,SAAqBjV,GACnB,MAAMkV,EAAS5V,OAAOQ,OAAO,MACvBqV,EAAW,mCACjB,IAAIjH,EAEJ,KAAQA,EAAQiH,EAASzM,KAAK1I,IAC5BkV,EAAOhH,EAAM,IAAMA,EAAM,GAG3B,OAAOgH,CACT,CA0GiBE,CAAY5W,GAGrB,GAAI2G,EAAMW,WAAWmP,GACnB,OAAOA,EAAOhV,KAAK9C,KAAMqB,EAAO6D,GAGlC,GAAI8C,EAAM9B,SAAS4R,GACjB,OAAOA,EAAOvM,KAAKlK,GAGrB,MAAM,IAAImO,UAAU,yCAC5B,CACA,CACA,CAEE0I,GAAAA,CAAIzB,EAAQ0B,GAGV,GAFA1B,EAASD,GAAgBC,GAEb,CACV,MAAMvR,EAAM8C,EAAM7C,QAAQnF,KAAMyW,GAEhC,SAAUvR,QAAqBwF,IAAd1K,KAAKkF,IAAwBiT,IAAWxB,GAAiB3W,EAAMA,KAAKkF,GAAMA,EAAKiT,GACtG,CAEI,OAAO,CACX,CAEEC,OAAO3B,EAAQ0B,GACb,MAAM5S,EAAOvF,KACb,IAAIqY,GAAU,EAEd,SAASC,EAAapB,GAGpB,GAFAA,EAAUV,GAAgBU,GAEb,CACX,MAAMhS,EAAM8C,EAAM7C,QAAQI,EAAM2R,IAE5BhS,GAASiT,IAAWxB,GAAiBpR,EAAMA,EAAKL,GAAMA,EAAKiT,YACtD5S,EAAKL,GAEZmT,GAAU,EAEpB,CACA,CAQI,OANIrQ,EAAM5E,QAAQqT,GAChBA,EAAO/R,QAAQ4T,GAEfA,EAAa7B,GAGR4B,CACX,CAEEhG,KAAAA,CAAM8F,GACJ,MAAMpT,EAAO5C,OAAO4C,KAAK/E,MACzB,IAAIa,EAAIkE,EAAKD,OACTuT,GAAU,EAEd,KAAOxX,KAAK,CACV,MAAMqE,EAAMH,EAAKlE,GACbsX,IAAWxB,GAAiB3W,EAAMA,KAAKkF,GAAMA,EAAKiT,GAAS,YACtDnY,KAAKkF,GACZmT,GAAU,EAElB,CAEI,OAAOA,CACX,CAEEE,SAAAA,CAAUC,GACR,MAAMjT,EAAOvF,KACPwU,EAAU,CAAC,EAsBjB,OApBAxM,EAAMtD,QAAQ1E,KAAM,CAACqB,EAAOoV,KAC1B,MAAMvR,EAAM8C,EAAM7C,QAAQqP,EAASiC,GAEnC,GAAIvR,EAGF,OAFAK,EAAKL,GAAOwR,GAAerV,eACpBkE,EAAKkR,GAId,MAAMgC,EAAaD,EAtKzB,SAAsB/B,GACpB,OAAOA,EAAOnN,OACXtG,cAAcuG,QAAQ,kBAAmB,CAACmP,EAAGC,EAAM9V,IAC3C8V,EAAKtM,cAAgBxJ,EAElC,CAiKkC+V,CAAanC,GAAUhM,OAAOgM,GAAQnN,OAE9DmP,IAAehC,UACVlR,EAAKkR,GAGdlR,EAAKkT,GAAc/B,GAAerV,GAElCmT,EAAQiE,IAAc,IAGjBzY,IACX,CAEEyO,MAAAA,IAAUoK,GACR,OAAO7Y,KAAKyD,YAAYgL,OAAOzO,QAAS6Y,EAC5C,CAEEhL,MAAAA,CAAOiL,GACL,MAAMnU,EAAMxC,OAAOQ,OAAO,MAM1B,OAJAqF,EAAMtD,QAAQ1E,KAAM,CAACqB,EAAOoV,KACjB,MAATpV,IAA2B,IAAVA,IAAoBsD,EAAI8R,GAAUqC,GAAa9Q,EAAM5E,QAAQ/B,GAASA,EAAMqN,KAAK,MAAQrN,KAGrGsD,CACX,CAEE,CAACnC,OAAOF,YACN,OAAOH,OAAO+R,QAAQlU,KAAK6N,UAAUrL,OAAOF,WAChD,CAEEJ,QAAAA,GACE,OAAOC,OAAO+R,QAAQlU,KAAK6N,UAAUpJ,IAAI,EAAEgS,EAAQpV,KAAWoV,EAAS,KAAOpV,GAAOqN,KAAK,KAC9F,CAEEqK,YAAAA,GACE,OAAO/Y,KAAK6X,IAAI,eAAiB,EACrC,CAEE,IAAKrV,OAAOD,eACV,MAAO,cACX,CAEE,WAAOoM,CAAK/L,GACV,OAAOA,aAAiB5C,KAAO4C,EAAQ,IAAI5C,KAAK4C,EACpD,CAEE,aAAO6L,CAAOuK,KAAUH,GACtB,MAAMI,EAAW,IAAIjZ,KAAKgZ,GAI1B,OAFAH,EAAQnU,QAASqI,GAAWkM,EAASrN,IAAImB,IAElCkM,CACX,CAEE,eAAOC,CAASzC,GACd,MAIM0C,GAJYnZ,KAAKuW,IAAevW,KAAKuW,IAAc,CACvD4C,UAAW,CAAC,IAGcA,UACtB/W,EAAYpC,KAAKoC,UAEvB,SAASgX,EAAelC,GACtB,MAAME,EAAUZ,GAAgBU,GAE3BiC,EAAU/B,KAlOrB,SAAwBzS,EAAK8R,GAC3B,MAAM4C,EAAerR,EAAMkE,YAAY,IAAMuK,GAE7C,CAAC,MAAO,MAAO,OAAO/R,QAAQ4U,IAC5BnX,OAAO2H,eAAenF,EAAK2U,EAAaD,EAAc,CACpDhY,MAAO,SAASkY,EAAMC,EAAMC,GAC1B,OAAOzZ,KAAKsZ,GAAYxW,KAAK9C,KAAMyW,EAAQ8C,EAAMC,EAAMC,EAC/D,EACMvK,cAAc,KAGpB,CAwNQwK,CAAetX,EAAW8U,GAC1BiC,EAAU/B,IAAW,EAE7B,CAII,OAFApP,EAAM5E,QAAQqT,GAAUA,EAAO/R,QAAQ0U,GAAkBA,EAAe3C,GAEjEzW,IACX,EAGA6W,GAAaqC,SAAS,CAAC,eAAgB,iBAAkB,SAAU,kBAAmB,aAAc,kBAGpGlR,EAAM7B,kBAAkB0Q,GAAazU,UAAW,EAAEf,SAAQ6D,KACxD,IAAIyU,EAASzU,EAAI,GAAGmH,cAAgBnH,EAAInC,MAAM,GAC9C,MAAO,CACL8U,IAAKA,IAAMxW,EACXuK,GAAAA,CAAIgO,GACF5Z,KAAK2Z,GAAUC,CACrB,KAIA5R,EAAMyD,cAAcoL,IAEpB,IAAAgD,GAAehD,GC3SA,SAASiD,GAAcC,EAAKrM,GACzC,MAAMF,EAASxN,MAAQqW,GACjB1Q,EAAU+H,GAAYF,EACtBgH,EAAUqF,GAAalL,KAAKhJ,EAAQ6O,SAC1C,IAAIjN,EAAO5B,EAAQ4B,KAQnB,OANAS,EAAMtD,QAAQqV,EAAK,SAAmBjY,GACpCyF,EAAOzF,EAAGgB,KAAK0K,EAAQjG,EAAMiN,EAAQ+D,YAAa7K,EAAWA,EAASE,YAASlD,EACnF,GAEE8J,EAAQ+D,YAEDhR,CACT,CCzBe,SAASyS,GAAS3Y,GAC/B,SAAUA,IAASA,EAAM4Y,WAC3B,CCUA,SAASC,GAAc5M,EAASE,EAAQC,GAEtCJ,EAAWvK,KAAK9C,KAAiB,MAAXsN,EAAkB,WAAaA,EAASD,EAAW8M,aAAc3M,EAAQC,GAC/FzN,KAAKyG,KAAO,eACd,CCLe,SAAS2T,GAAOC,EAASC,EAAQ5M,GAC9C,MAAMwI,EAAiBxI,EAASF,OAAO0I,eAClCxI,EAASE,QAAWsI,IAAkBA,EAAexI,EAASE,QAGjE0M,EAAO,IAAIjN,EACT,mCAAqCK,EAASE,OAC9C,CAACP,EAAWkN,gBAAiBlN,EAAWuI,kBAAkB1U,KAAKQ,MAAMgM,EAASE,OAAS,KAAO,GAC9FF,EAASF,OACTE,EAASD,QACTC,IAPF2M,EAAQ3M,EAUZ,CDNA1F,EAAM2B,SAASuQ,GAAe7M,EAAY,CACxC4M,YAAY,IEjBP,MAAMO,GAAuBA,CAACC,EAAUC,EAAkBC,EAAO,KACtE,IAAIC,EAAgB,EACpB,MAAMC,ECER,SAAqBC,EAAcC,GACjCD,EAAeA,GAAgB,GAC/B,MAAME,EAAQ,IAAI3X,MAAMyX,GAClBG,EAAa,IAAI5X,MAAMyX,GAC7B,IAEII,EAFAC,EAAO,EACPC,EAAO,EAKX,OAFAL,OAAcrQ,IAARqQ,EAAoBA,EAAM,IAEzB,SAAcM,GACnB,MAAMC,EAAMC,KAAKD,MAEXE,EAAYP,EAAWG,GAExBF,IACHA,EAAgBI,GAGlBN,EAAMG,GAAQE,EACdJ,EAAWE,GAAQG,EAEnB,IAAIza,EAAIua,EACJK,EAAa,EAEjB,KAAO5a,IAAMsa,GACXM,GAAcT,EAAMna,KACpBA,GAAQia,EASV,GANAK,GAAQA,EAAO,GAAKL,EAEhBK,IAASC,IACXA,GAAQA,EAAO,GAAKN,GAGlBQ,EAAMJ,EAAgBH,EACxB,OAGF,MAAMW,EAASF,GAAaF,EAAME,EAElC,OAAOE,EAASxa,KAAKya,MAAmB,IAAbF,EAAoBC,QAAUhR,CAC7D,CACA,CD9CuBkR,CAAY,GAAI,KAErC,OEFF,SAAkB9Z,EAAI6Y,GACpB,IAEIkB,EACAC,EAHAC,EAAY,EACZC,EAAY,IAAOrB,EAIvB,MAAMsB,EAASA,CAACC,EAAMZ,EAAMC,KAAKD,SAC/BS,EAAYT,EACZO,EAAW,KACPC,IACFK,aAAaL,GACbA,EAAQ,MFTIvb,KACd,MAAM6b,EAAS7b,EAAE6b,OACXC,EAAQ9b,EAAE+b,iBAAmB/b,EAAE8b,WAAQ3R,EACvC6R,EAAgBH,EAASxB,EACzB4B,EAAO3B,EAAa0B,GAG1B3B,EAAgBwB,EAchB3B,EAZa,CACX2B,SACAC,QACAI,SAAUJ,EAASD,EAASC,OAAS3R,EACrCsQ,MAAOuB,EACPC,KAAMA,QAAc9R,EACpBgS,UAAWF,GAAQH,GAVLD,GAAUC,GAUeA,EAAQD,GAAUI,OAAO9R,EAChEiS,MAAOpc,EACP+b,iBAA2B,MAATD,EAClB,CAAC3B,EAAmB,WAAa,WAAW,KEP9C5Y,IAAMoa,IAqBR,MAAO,CAlBWU,IAAIV,KACpB,MAAMZ,EAAMC,KAAKD,MACXI,EAASJ,EAAMS,EAChBL,GAAUM,EACbC,EAAOC,EAAMZ,IAEbO,EAAWK,EACNJ,IACHA,EAAQnU,WAAW,KACjBmU,EAAQ,KACRG,EAAOJ,IACNG,EAAYN,MAKPmB,IAAMhB,GAAYI,EAAOJ,GAGzC,CFjCSiB,CAASvc,EAsBboa,IAGQoC,GAAyBA,CAACV,EAAOO,KAC5C,MAAMN,EAA4B,MAATD,EAEzB,MAAO,CAAED,GAAWQ,EAAU,GAAG,CAC/BN,mBACAD,QACAD,WACEQ,EAAU,KAGHI,GAAkBlb,GAAO,IAAIoa,IAASlU,EAAMJ,KAAK,IAAM9F,KAAMoa,IGzC1E,IAAAe,GAAerJ,GAASR,sBAAwB,EAAEK,EAAQyJ,IAAY7L,IACpEA,EAAM,IAAI8L,IAAI9L,EAAKuC,GAASH,QAG1BA,EAAO2J,WAAa/L,EAAI+L,UACxB3J,EAAO4J,OAAShM,EAAIgM,OACnBH,GAAUzJ,EAAO6J,OAASjM,EAAIiM,OANa,CAS9C,IAAIH,IAAIvJ,GAASH,QACjBG,GAAST,WAAa,kBAAkB/D,KAAKwE,GAAST,UAAUoK,YAC9D,KAAM,ECVVC,GAAe5J,GAASR,sBAGtB,CACEhS,KAAAA,CAAMqF,EAAMpF,EAAOoc,EAASlP,EAAMmP,EAAQC,EAAQC,GAChD,GAAwB,oBAAb3K,SAA0B,OAErC,MAAM4K,EAAS,CAAC,GAAGpX,KAAQqK,mBAAmBzP,MAE1C2G,EAAMnE,SAAS4Z,IACjBI,EAAOnW,KAAK,WAAW,IAAI6T,KAAKkC,GAASK,iBAEvC9V,EAAMpE,SAAS2K,IACjBsP,EAAOnW,KAAK,QAAQ6G,KAElBvG,EAAMpE,SAAS8Z,IACjBG,EAAOnW,KAAK,UAAUgW,MAET,IAAXC,GACFE,EAAOnW,KAAK,UAEVM,EAAMpE,SAASga,IACjBC,EAAOnW,KAAK,YAAYkW,KAG1B3K,SAAS4K,OAASA,EAAOnP,KAAK,KACpC,EAEIzO,IAAAA,CAAKwG,GACH,GAAwB,oBAAbwM,SAA0B,OAAO,KAC5C,MAAMlC,EAAQkC,SAAS4K,OAAO9M,MAAM,IAAIgN,OAAO,WAAatX,EAAO,aACnE,OAAOsK,EAAQiN,mBAAmBjN,EAAM,IAAM,IACpD,EAEIkN,MAAAA,CAAOxX,GACLzG,KAAKoB,MAAMqF,EAAM,GAAI8U,KAAKD,MAAQ,MAAU,IAClD,GAME,CACEla,KAAAA,GAAS,EACTnB,KAAIA,IACK,KAETge,MAAAA,GAAU,GCnCC,SAASC,GAAcC,EAASC,EAAcC,GAC3D,IAAIC,GCHG,8BAA8BlP,KDGFgP,GACnC,OAAID,IAAYG,GAAsC,GAArBD,GEPpB,SAAqBF,EAASI,GAC3C,OAAOA,EACHJ,EAAQ5U,QAAQ,SAAU,IAAM,IAAMgV,EAAYhV,QAAQ,OAAQ,IAClE4U,CACN,CFIWK,CAAYL,EAASC,GAEvBA,CACT,CGhBA,MAAMK,GAAmB7b,GAAUA,aAAiBiX,GAAe,IAAKjX,GAAUA,EAWnE,SAAS8b,GAAYC,EAASC,GAE3CA,EAAUA,GAAW,CAAC,EACtB,MAAMpR,EAAS,CAAC,EAEhB,SAASqR,EAAe9R,EAAQzF,EAAQrB,EAAM8C,GAC5C,OAAIf,EAAMjE,cAAcgJ,IAAW/E,EAAMjE,cAAcuD,GAC9CU,EAAMc,MAAMhG,KAAK,CAACiG,YAAWgE,EAAQzF,GACnCU,EAAMjE,cAAcuD,GACtBU,EAAMc,MAAM,CAAC,EAAGxB,GACdU,EAAM5E,QAAQkE,GAChBA,EAAOvE,QAETuE,CACX,CAGE,SAASwX,EAAoB1V,EAAGC,EAAGpD,EAAM8C,GACvC,OAAKf,EAAM1E,YAAY+F,GAEXrB,EAAM1E,YAAY8F,QAAvB,EACEyV,OAAenU,EAAWtB,EAAGnD,EAAM8C,GAFnC8V,EAAezV,EAAGC,EAAGpD,EAAM8C,EAIxC,CAGE,SAASgW,EAAiB3V,EAAGC,GAC3B,IAAKrB,EAAM1E,YAAY+F,GACrB,OAAOwV,OAAenU,EAAWrB,EAEvC,CAGE,SAAS2V,EAAiB5V,EAAGC,GAC3B,OAAKrB,EAAM1E,YAAY+F,GAEXrB,EAAM1E,YAAY8F,QAAvB,EACEyV,OAAenU,EAAWtB,GAF1ByV,OAAenU,EAAWrB,EAIvC,CAGE,SAAS4V,EAAgB7V,EAAGC,EAAGpD,GAC7B,OAAIA,KAAQ2Y,EACHC,EAAezV,EAAGC,GAChBpD,KAAQ0Y,EACVE,OAAenU,EAAWtB,QAD5B,CAGX,CAEE,MAAM8V,EAAW,CACf7N,IAAK0N,EACL3I,OAAQ2I,EACRxX,KAAMwX,EACNZ,QAASa,EACTzK,iBAAkByK,EAClBzJ,kBAAmByJ,EACnBG,iBAAkBH,EAClBnJ,QAASmJ,EACTI,eAAgBJ,EAChBK,gBAAiBL,EACjBM,cAAeN,EACf1K,QAAS0K,EACTvJ,aAAcuJ,EACdlJ,eAAgBkJ,EAChBjJ,eAAgBiJ,EAChBO,iBAAkBP,EAClBQ,mBAAoBR,EACpBS,WAAYT,EACZhJ,iBAAkBgJ,EAClB/I,cAAe+I,EACfU,eAAgBV,EAChBW,UAAWX,EACXY,UAAWZ,EACXa,WAAYb,EACZc,YAAad,EACbe,WAAYf,EACZgB,iBAAkBhB,EAClB9I,eAAgB+I,EAChBzK,QAASA,CAACpL,EAAGC,EAAGpD,IAAS6Y,EAAoBL,GAAgBrV,GAAIqV,GAAgBpV,GAAIpD,GAAM,IAS7F,OANA+B,EAAMtD,QAAQvC,OAAO4C,KAAK,IAAI4Z,KAAYC,IAAW,SAA4B3Y,GAC/E,MAAM6C,EAAQoW,EAASjZ,IAAS6Y,EAC1BmB,EAAcnX,EAAM6V,EAAQ1Y,GAAO2Y,EAAQ3Y,GAAOA,GACvD+B,EAAM1E,YAAY2c,IAAgBnX,IAAUmW,IAAqBzR,EAAOvH,GAAQga,EACrF,GAESzS,CACT,CChGA,IAAA0S,GAAgB1S,IACd,MAAM2S,EAAYzB,GAAY,CAAC,EAAGlR,GAElC,IAAI,KAAEjG,EAAI,cAAE+X,EAAa,eAAEvJ,EAAc,eAAED,EAAc,QAAEtB,EAAO,KAAE4L,GAASD,EAa7E,GAXAA,EAAU3L,QAAUA,EAAUqF,GAAalL,KAAK6F,GAEhD2L,EAAU9O,IAAMD,GAAS8M,GAAciC,EAAUhC,QAASgC,EAAU9O,IAAK8O,EAAU9B,mBAAoB7Q,EAAOyD,OAAQzD,EAAO2R,kBAGzHiB,GACF5L,EAAQ5I,IAAI,gBAAiB,SAC3ByU,MAAMD,EAAKE,UAAY,IAAM,KAAOF,EAAKG,SAAWC,SAAS1P,mBAAmBsP,EAAKG,WAAa,MAIlGvY,EAAMC,WAAWV,GACnB,GAAIqM,GAASR,uBAAyBQ,GAASN,+BAC7CkB,EAAQK,oBAAenK,QAClB,GAAI1C,EAAMW,WAAWpB,EAAKkZ,YAAa,CAE5C,MAAMC,EAAcnZ,EAAKkZ,aAEnBE,EAAiB,CAAC,eAAgB,kBACxCxe,OAAO+R,QAAQwM,GAAahc,QAAQ,EAAEQ,EAAK1B,MACrCmd,EAAeC,SAAS1b,EAAIlC,gBAC9BwR,EAAQ5I,IAAI1G,EAAK1B,IAG3B,CAOE,GAAIoQ,GAASR,wBACXkM,GAAiBtX,EAAMW,WAAW2W,KAAmBA,EAAgBA,EAAca,IAE/Eb,IAAoC,IAAlBA,GAA2BrC,GAAgBkD,EAAU9O,MAAO,CAEhF,MAAMwP,EAAY9K,GAAkBD,GAAkB0H,GAAQvd,KAAK6V,GAE/D+K,GACFrM,EAAQ5I,IAAImK,EAAgB8K,EAEpC,CAGE,OAAOV,GC7CTW,GAFwD,oBAAnBC,gBAEG,SAAUvT,GAChD,OAAO,IAAIwT,QAAQ,SAA4B3G,EAASC,GACtD,MAAM2G,EAAUf,GAAc1S,GAC9B,IAAI0T,EAAcD,EAAQ1Z,KAC1B,MAAM4Z,EAAiBtH,GAAalL,KAAKsS,EAAQzM,SAAS+D,YAC1D,IACI6I,EACAC,EAAiBC,EACjBC,EAAaC,GAHb,aAAC/L,EAAY,iBAAE8J,EAAgB,mBAAEC,GAAsByB,EAK3D,SAAS/V,IACPqW,GAAeA,IACfC,GAAiBA,IAEjBP,EAAQnB,aAAemB,EAAQnB,YAAY2B,YAAYL,GAEvDH,EAAQS,QAAUT,EAAQS,OAAOC,oBAAoB,QAASP,EACpE,CAEI,IAAI3T,EAAU,IAAIsT,eAOlB,SAASa,IACP,IAAKnU,EACH,OAGF,MAAMoU,EAAkBhI,GAAalL,KACnC,0BAA2BlB,GAAWA,EAAQqU,yBAahD1H,GAAO,SAAkB/Y,GACvBgZ,EAAQhZ,GACR6J,GACR,EAAS,SAAiB6W,GAClBzH,EAAOyH,GACP7W,GACR,EAfuB,CACf3D,KAHoBkO,GAAiC,SAAjBA,GAA4C,SAAjBA,EACxChI,EAAQC,SAA/BD,EAAQuU,aAGRpU,OAAQH,EAAQG,OAChBqU,WAAYxU,EAAQwU,WACpBzN,QAASqN,EACTrU,SACAC,YAYFA,EAAU,IAChB,CAlCIA,EAAQyU,KAAKjB,EAAQ7K,OAAO/J,cAAe4U,EAAQ5P,KAAK,GAGxD5D,EAAQoI,QAAUoL,EAAQpL,QAiCtB,cAAepI,EAEjBA,EAAQmU,UAAYA,EAGpBnU,EAAQ0U,mBAAqB,WACtB1U,GAAkC,IAAvBA,EAAQ2U,aAQD,IAAnB3U,EAAQG,QAAkBH,EAAQ4U,aAAwD,IAAzC5U,EAAQ4U,YAAYzX,QAAQ,WAKjFjD,WAAWia,EACnB,EAIInU,EAAQ6U,QAAU,WACX7U,IAIL6M,EAAO,IAAIjN,EAAW,kBAAmBA,EAAWkV,aAAc/U,EAAQC,IAG1EA,EAAU,KAChB,EAGEA,EAAQ+U,QAAU,SAAqB7F,GAIlC,MACMoF,EAAM,IAAI1U,EADJsP,GAASA,EAAMrP,QAAUqP,EAAMrP,QAAU,gBACrBD,EAAWoV,YAAajV,EAAQC,GAEhEsU,EAAIpF,MAAQA,GAAS,KACrBrC,EAAOyH,GACPtU,EAAU,IACjB,EAGIA,EAAQiV,UAAY,WAClB,IAAIC,EAAsB1B,EAAQpL,QAAU,cAAgBoL,EAAQpL,QAAU,cAAgB,mBAC9F,MAAMxB,EAAe4M,EAAQ5M,cAAgB9B,GACzC0O,EAAQ0B,sBACVA,EAAsB1B,EAAQ0B,qBAEhCrI,EAAO,IAAIjN,EACTsV,EACAtO,EAAa3B,oBAAsBrF,EAAWuV,UAAYvV,EAAWkV,aACrE/U,EACAC,IAGFA,EAAU,IAChB,OAGoB/C,IAAhBwW,GAA6BC,EAAetM,eAAe,MAGvD,qBAAsBpH,GACxBzF,EAAMtD,QAAQyc,EAAetT,SAAU,SAA0BrK,EAAK0B,GACpEuI,EAAQoV,iBAAiB3d,EAAK1B,EACtC,GAISwE,EAAM1E,YAAY2d,EAAQ5B,mBAC7B5R,EAAQ4R,kBAAoB4B,EAAQ5B,iBAIlC5J,GAAiC,SAAjBA,IAClBhI,EAAQgI,aAAewL,EAAQxL,cAI7B+J,KACA8B,EAAmBE,GAAiBhH,GAAqBgF,GAAoB,GAC/E/R,EAAQpG,iBAAiB,WAAYia,IAInC/B,GAAoB9R,EAAQqV,UAC5BzB,EAAiBE,GAAe/G,GAAqB+E,GAEvD9R,EAAQqV,OAAOzb,iBAAiB,WAAYga,GAE5C5T,EAAQqV,OAAOzb,iBAAiB,UAAWka,KAGzCN,EAAQnB,aAAemB,EAAQS,UAGjCN,EAAa2B,IACNtV,IAGL6M,GAAQyI,GAAUA,EAAO7f,KAAO,IAAIgX,GAAc,KAAM1M,EAAQC,GAAWsV,GAC3EtV,EAAQuV,QACRvV,EAAU,OAGZwT,EAAQnB,aAAemB,EAAQnB,YAAYmD,UAAU7B,GACjDH,EAAQS,SACVT,EAAQS,OAAOwB,QAAU9B,IAAeH,EAAQS,OAAOra,iBAAiB,QAAS+Z,KAIrF,MAAMhE,EC1LK,SAAuB/L,GACpC,MAAMN,EAAQ,4BAA4BxF,KAAK8F,GAC/C,OAAON,GAASA,EAAM,IAAM,EAC9B,CDuLqBoS,CAAclC,EAAQ5P,KAEnC+L,IAAsD,IAA1CxJ,GAASb,UAAUnI,QAAQwS,GACzC9C,EAAO,IAAIjN,EAAW,wBAA0B+P,EAAW,IAAK/P,EAAWkN,gBAAiB/M,IAM9FC,EAAQ2V,KAAKlC,GAAe,KAChC,EACA,EExJAmC,GA3CuBC,CAACC,EAAS1N,KAC/B,MAAM,OAAC/Q,GAAWye,EAAUA,EAAUA,EAAQpZ,OAAOqZ,SAAW,GAEhE,GAAI3N,GAAW/Q,EAAQ,CACrB,IAEIoe,EAFAO,EAAa,IAAIC,gBAIrB,MAAMpB,EAAU,SAAUqB,GACxB,IAAKT,EAAS,CACZA,GAAU,EACVzB,IACA,MAAMM,EAAM4B,aAAkB9X,MAAQ8X,EAAS3jB,KAAK2jB,OACpDF,EAAWT,MAAMjB,aAAe1U,EAAa0U,EAAM,IAAI7H,GAAc6H,aAAelW,MAAQkW,EAAIzU,QAAUyU,GAClH,CACA,EAEI,IAAIjG,EAAQjG,GAAWlO,WAAW,KAChCmU,EAAQ,KACRwG,EAAQ,IAAIjV,EAAW,WAAWwI,mBAA0BxI,EAAWuV,aACtE/M,GAEH,MAAM4L,EAAcA,KACd8B,IACFzH,GAASK,aAAaL,GACtBA,EAAQ,KACRyH,EAAQ7e,QAAQgd,IACdA,EAAOD,YAAcC,EAAOD,YAAYa,GAAWZ,EAAOC,oBAAoB,QAASW,KAEzFiB,EAAU,OAIdA,EAAQ7e,QAASgd,GAAWA,EAAOra,iBAAiB,QAASib,IAE7D,MAAM,OAACZ,GAAU+B,EAIjB,OAFA/B,EAAOD,YAAc,IAAMzZ,EAAMJ,KAAK6Z,GAE/BC,CACX,GC3CO,MAAMkC,GAAc,UAAWC,EAAOC,GAC3C,IAAI7e,EAAM4e,EAAME,WAEhB,IAAKD,GAAa7e,EAAM6e,EAEtB,kBADMD,GAIR,IACIG,EADAC,EAAM,EAGV,KAAOA,EAAMhf,GACX+e,EAAMC,EAAMH,QACND,EAAM9gB,MAAMkhB,EAAKD,GACvBC,EAAMD,CAEV,EA4BaE,GAAcA,CAACC,EAAQL,EAAWM,EAAYC,KACzD,MAAM/hB,EA3BiBgiB,gBAAiBC,EAAUT,GAClD,UAAW,MAAMD,KAKAS,gBAAiBH,GAClC,GAAIA,EAAO3hB,OAAOgiB,eAEhB,kBADOL,GAIT,MAAMM,EAASN,EAAOO,YACtB,IACE,OAAS,CACP,MAAM,KAACxZ,EAAI,MAAE7J,SAAeojB,EAAOxkB,OACnC,GAAIiL,EACF,YAEI7J,CACZ,CACA,CAAI,cACMojB,EAAO1B,QACjB,CACA,CAvB4B4B,CAAWJ,SAC5BX,GAAYC,EAAOC,EAE9B,CAuBmBc,CAAUT,EAAQL,GAEnC,IACI5Y,EADA8P,EAAQ,EAER6J,EAAatkB,IACV2K,IACHA,GAAO,EACPmZ,GAAYA,EAAS9jB,KAIzB,OAAO,IAAIukB,eAAe,CACxB,UAAMC,CAAKtB,GACT,IACE,MAAM,KAACvY,EAAI,MAAE7J,SAAeiB,EAAS2I,OAErC,GAAIC,EAGF,OAFD2Z,SACCpB,EAAWuB,QAIb,IAAI/f,EAAM5D,EAAM0iB,WAChB,GAAIK,EAAY,CACd,IAAIa,EAAcjK,GAAS/V,EAC3Bmf,EAAWa,EACrB,CACQxB,EAAWyB,QAAQ,IAAIpf,WAAWzE,GAC1C,CAAQ,MAAO0gB,GAEP,MADA8C,EAAU9C,GACJA,CACd,CACA,EACIgB,OAAOY,IACLkB,EAAUlB,GACHrhB,EAAS6iB,WAEjB,CACDC,cAAe,MCxEb,WAACzc,IAAcX,EAEfqd,GAAiB,GAAGC,UAASC,eAAc,CAC/CD,UAASC,aADY,CAEnBvd,EAAMvC,SAGVqf,eAAEU,GAAc,YAAEC,IACdzd,EAAMvC,OAGJ2J,GAAOA,CAACtN,KAAOoa,KACnB,IACE,QAASpa,KAAMoa,EACnB,CAAI,MAAO3b,GACP,OAAO,CACX,GAGMZ,GAAWwV,IACfA,EAAMnN,EAAMc,MAAMhG,KAAK,CACrBkG,eAAe,GACdqc,GAAgBlQ,GAEnB,MAAOuQ,MAAOC,EAAQ,QAAEL,EAAO,SAAEC,GAAYpQ,EACvCyQ,EAAmBD,EAAWhd,GAAWgd,GAA6B,mBAAVD,MAC5DG,EAAqBld,GAAW2c,GAChCQ,EAAsBnd,GAAW4c,GAEvC,IAAKK,EACH,OAAO,EAGT,MAAMG,EAA4BH,GAAoBjd,GAAW6c,IAE3DQ,EAAaJ,IAA4C,mBAAhBH,IACzC9T,EAA0C,IAAI8T,GAAjC5iB,GAAQ8O,EAAQR,OAAOtO,IACtCyhB,SAAe,IAAIxe,iBAAiB,IAAIwf,EAAQziB,GAAKojB,gBADrD,IAAEtU,EAIN,MAAMuU,EAAwBL,GAAsBE,GAA6B3W,GAAK,KACpF,IAAI+W,GAAiB,EAErB,MAAMC,EAAiB,IAAId,EAAQ1R,GAASH,OAAQ,CAClD4S,KAAM,IAAIb,GACVpP,OAAQ,OACR,UAAIkQ,GAEF,OADAH,GAAiB,EACV,MACf,IACO3R,QAAQ0D,IAAI,gBAEf,OAAOiO,IAAmBC,IAGtBG,EAAyBT,GAAuBC,GACpD3W,GAAK,IAAMpH,EAAM3D,iBAAiB,IAAIkhB,EAAS,IAAIc,OAE/CG,EAAY,CAChBrC,OAAQoC,GAA0B,CAAEE,GAAQA,EAAIJ,OAGlDT,GACE,CAAC,OAAQ,cAAe,OAAQ,WAAY,UAAUlhB,QAAQxB,KAC3DsjB,EAAUtjB,KAAUsjB,EAAUtjB,GAAQ,CAACujB,EAAKjZ,KAC3C,IAAI4I,EAASqQ,GAAOA,EAAIvjB,GAExB,GAAIkT,EACF,OAAOA,EAAOtT,KAAK2jB,GAGrB,MAAM,IAAIpZ,EAAW,kBAAkBnK,sBAA0BmK,EAAWqZ,gBAAiBlZ,OAyCnG,OAAO8W,UACL,IAAI,IACFjT,EAAG,OACH+E,EAAM,KACN7O,EAAI,OACJma,EAAM,YACN5B,EAAW,QACXjK,EAAO,mBACP2J,EAAkB,iBAClBD,EAAgB,aAChB9J,EAAY,QACZjB,EAAO,gBACP6K,EAAkB,cAAa,aAC/BsH,GACEzG,GAAc1S,GAEdoZ,EAASjB,GAAYD,MAEzBjQ,EAAeA,GAAgBA,EAAe,IAAIzS,cAAgB,OAElE,IAAI6jB,EAAiBxD,GAAe,CAAC3B,EAAQ5B,GAAeA,EAAYgH,iBAAkBjR,GAEtFpI,EAAU,KAEd,MAAMgU,EAAcoF,GAAkBA,EAAepF,aAAe,MAClEoF,EAAepF,aAChB,GAED,IAAIsF,EAEJ,IACE,GACExH,GAAoB2G,GAAoC,QAAX9P,GAA+B,SAAXA,GACG,KAAnE2Q,OAvCmBzC,OAAO9P,EAAS6R,KACxC,MAAMvhB,EAASkD,EAAMuE,eAAeiI,EAAQwS,oBAE5C,OAAiB,MAAVliB,EAjCawf,WACpB,GAAY,MAAR+B,EACF,OAAO,EAGT,GAAIre,EAAM9D,OAAOmiB,GACf,OAAOA,EAAKY,KAGd,GAAIjf,EAAM2E,oBAAoB0Z,GAAO,CACnC,MAAMa,EAAW,IAAI5B,EAAQ1R,GAASH,OAAQ,CAC5C2C,OAAQ,OACRiQ,SAEF,aAAca,EAASjB,eAAelC,UAC5C,CAEI,OAAI/b,EAAMK,kBAAkBge,IAASre,EAAMrE,cAAc0iB,GAChDA,EAAKtC,YAGV/b,EAAM5D,kBAAkBiiB,KAC1BA,GAAc,IAGZre,EAAMpE,SAASyiB,UACHL,EAAWK,IAAOtC,gBADlC,IAQwBoD,CAAcd,GAAQvhB,GAoCZsiB,CAAkB5S,EAASjN,IACzD,CACA,IAMI8f,EANAH,EAAW,IAAI5B,EAAQjU,EAAK,CAC9B+E,OAAQ,OACRiQ,KAAM9e,EACN+e,OAAQ,SASV,GAJIte,EAAMC,WAAWV,KAAU8f,EAAoBH,EAAS1S,QAAQqD,IAAI,kBACtErD,EAAQK,eAAewS,GAGrBH,EAASb,KAAM,CACjB,MAAOjC,EAAYvH,GAASE,GAC1BgK,EACAvM,GAAqBwC,GAAeuC,KAGtChY,EAAO2c,GAAYgD,EAASb,KAvKX,MAuKqCjC,EAAYvH,EAC5E,CACA,CAEW7U,EAAMpE,SAASyb,KAClBA,EAAkBA,EAAkB,UAAY,QAKlD,MAAMiI,EAAyBzB,GAAsB,gBAAiBP,EAAQljB,UAExEmlB,EAAkB,IACnBZ,EACHjF,OAAQmF,EACRzQ,OAAQA,EAAO/J,cACfmI,QAASA,EAAQ+D,YAAY1K,SAC7BwY,KAAM9e,EACN+e,OAAQ,OACRkB,YAAaF,EAAyBjI,OAAkB3U,GAG1D+C,EAAUoY,GAAsB,IAAIP,EAAQjU,EAAKkW,GAEjD,IAAI7Z,QAAkBmY,EAAqBe,EAAOnZ,EAASkZ,GAAgBC,EAAOvV,EAAKkW,IAEvF,MAAME,EAAmBlB,IAA4C,WAAjB9Q,GAA8C,aAAjBA,GAEjF,GAAI8Q,IAA2B/G,GAAuBiI,GAAoBhG,GAAe,CACvF,MAAMlS,EAAU,CAAC,EAEjB,CAAC,SAAU,aAAc,WAAW7K,QAAQuB,IAC1CsJ,EAAQtJ,GAAQyH,EAASzH,KAG3B,MAAMyhB,EAAwB1f,EAAMuE,eAAemB,EAAS8G,QAAQqD,IAAI,oBAEjEuM,EAAYvH,GAAS2C,GAAsBzC,GAChD2K,EACAlN,GAAqBwC,GAAewC,IAAqB,KACtD,GAEL9R,EAAW,IAAI6X,EACbrB,GAAYxW,EAAS2Y,KAlNJ,MAkN8BjC,EAAY,KACzDvH,GAASA,IACT4E,GAAeA,MAEjBlS,EAEV,CAEMkG,EAAeA,GAAgB,OAE/B,IAAIkS,QAAqBnB,EAAUxe,EAAM7C,QAAQqhB,EAAW/Q,IAAiB,QAAQ/H,EAAUF,GAI/F,OAFCia,GAAoBhG,GAAeA,UAEvB,IAAIT,QAAQ,CAAC3G,EAASC,KACjCF,GAAOC,EAASC,EAAQ,CACtB/S,KAAMogB,EACNnT,QAASqF,GAAalL,KAAKjB,EAAS8G,SACpC5G,OAAQF,EAASE,OACjBqU,WAAYvU,EAASuU,WACrBzU,SACAC,aAGV,CAAM,MAAOsU,GAGP,GAFAN,GAAeA,IAEXM,GAAoB,cAAbA,EAAItb,MAAwB,qBAAqB2I,KAAK2S,EAAIzU,SACnE,MAAMnL,OAAO4H,OACX,IAAIsD,EAAW,gBAAiBA,EAAWoV,YAAajV,EAAQC,GAChE,CACEwB,MAAO8S,EAAI9S,OAAS8S,IAK1B,MAAM1U,EAAWsB,KAAKoT,EAAKA,GAAOA,EAAIxU,KAAMC,EAAQC,EAC1D,IAIMma,GAAY,IAAIC,IAETC,GAAYta,IACvB,IAAI2H,EAAO3H,GAAUA,EAAO2H,KAAQ,CAAC,EACrC,MAAM,MAACuQ,EAAK,QAAEJ,EAAO,SAAEC,GAAYpQ,EAC7B4S,EAAQ,CACZzC,EAASC,EAAUG,GAGrB,IACEsC,EAAMjb,EADgBlM,EAAdknB,EAAMjjB,OACAL,EAAMmjB,GAEtB,KAAO/mB,KACLmnB,EAAOD,EAAMlnB,GACbkM,EAAStI,EAAIoT,IAAImQ,QAENtd,IAAXqC,GAAwBtI,EAAImH,IAAIoc,EAAMjb,EAAUlM,EAAI,IAAIgnB,IAAQloB,GAAQwV,IAExE1Q,EAAMsI,EAGR,OAAOA,GAGO+a,KC9QhB,MAAMG,GAAgB,CACpBC,KCfa,KDgBbC,IAAKrH,GACL4E,MAAO,CACL7N,IAAKiQ,KAKT9f,EAAMtD,QAAQujB,GAAe,CAACnmB,EAAIT,KAChC,GAAIS,EAAI,CACN,IACEK,OAAO2H,eAAehI,EAAI,OAAQ,CAAET,SAC1C,CAAM,MAAOd,GACb,CAEI4B,OAAO2H,eAAehI,EAAI,cAAe,CAAET,SAC/C,IASA,MAAM+mB,GAAgBzE,GAAW,KAAKA,IAQhC0E,GAAoB/T,GAAYtM,EAAMW,WAAW2L,IAAwB,OAAZA,IAAgC,IAAZA,EAgEvF,IAAAgU,GApDA,SAAoBA,EAAU9a,GAC5B8a,EAAWtgB,EAAM5E,QAAQklB,GAAYA,EAAW,CAACA,GAEjD,MAAM,OAAExjB,GAAWwjB,EACnB,IAAIC,EACAjU,EAEJ,MAAMkU,EAAkB,CAAC,EAEzB,IAAK,IAAI3nB,EAAI,EAAGA,EAAIiE,EAAQjE,IAAK,CAE/B,IAAIuR,EAIJ,GALAmW,EAAgBD,EAASznB,GAGzByT,EAAUiU,GAELF,GAAiBE,KACpBjU,EAAU2T,IAAe7V,EAAK3H,OAAO8d,IAAgBvlB,oBAErC0H,IAAZ4J,GACF,MAAM,IAAIjH,EAAW,oBAAoB+E,MAI7C,GAAIkC,IAAYtM,EAAMW,WAAW2L,KAAaA,EAAUA,EAAQuD,IAAIrK,KAClE,MAGFgb,EAAgBpW,GAAM,IAAMvR,GAAKyT,CACrC,CAEE,IAAKA,EAAS,CACZ,MAAMmU,EAAUtmB,OAAO+R,QAAQsU,GAC5B/jB,IAAI,EAAE2N,EAAIsW,KAAW,WAAWtW,OACpB,IAAVsW,EAAkB,sCAAwC,kCAO/D,MAAM,IAAIrb,EACR,yDALMvI,EACL2jB,EAAQ3jB,OAAS,EAAI,YAAc2jB,EAAQhkB,IAAI2jB,IAAc1Z,KAAK,MAAQ,IAAM0Z,GAAaK,EAAQ,IACtG,2BAIA,kBAEN,CAEE,OAAOnU,CACT,EE5FA,SAASqU,GAA6Bnb,GAKpC,GAJIA,EAAOsS,aACTtS,EAAOsS,YAAY8I,mBAGjBpb,EAAOkU,QAAUlU,EAAOkU,OAAOwB,QACjC,MAAM,IAAIhJ,GAAc,KAAM1M,EAElC,CASe,SAASqb,GAAgBrb,GAiBtC,OAhBAmb,GAA6Bnb,GAE7BA,EAAOgH,QAAUqF,GAAalL,KAAKnB,EAAOgH,SAG1ChH,EAAOjG,KAAOuS,GAAchX,KAC1B0K,EACAA,EAAO+G,mBAGgD,IAArD,CAAC,OAAQ,MAAO,SAAS3J,QAAQ4C,EAAO4I,SAC1C5I,EAAOgH,QAAQK,eAAe,qCAAqC,GAGrDyT,GAAoB9a,EAAO8G,SAAW+B,GAAS/B,QAAS9G,EAEjE8G,CAAQ9G,GAAQN,KAAK,SAA6BQ,GAYvD,OAXAib,GAA6Bnb,GAG7BE,EAASnG,KAAOuS,GAAchX,KAC5B0K,EACAA,EAAO+H,kBACP7H,GAGFA,EAAS8G,QAAUqF,GAAalL,KAAKjB,EAAS8G,SAEvC9G,CACX,EAAK,SAA4BiW,GAe7B,OAdK3J,GAAS2J,KACZgF,GAA6Bnb,GAGzBmW,GAAUA,EAAOjW,WACnBiW,EAAOjW,SAASnG,KAAOuS,GAAchX,KACnC0K,EACAA,EAAO+H,kBACPoO,EAAOjW,UAETiW,EAAOjW,SAAS8G,QAAUqF,GAAalL,KAAKgV,EAAOjW,SAAS8G,WAIzDwM,QAAQ1G,OAAOqJ,EAC1B,EACA,CChFO,MAAMmF,GAAU,SCKjBC,GAAa,CAAC,EAGpB,CAAC,SAAU,UAAW,SAAU,WAAY,SAAU,UAAUrkB,QAAQ,CAACxB,EAAMrC,KAC7EkoB,GAAW7lB,GAAQ,SAAmBN,GACpC,cAAcA,IAAUM,GAAQ,KAAOrC,EAAI,EAAI,KAAO,KAAOqC,CACjE,IAGA,MAAM8lB,GAAqB,CAAC,EAW5BD,GAAW1U,aAAe,SAAsB4U,EAAWC,EAAS5b,GAClE,SAAS6b,EAAcC,EAAKC,GAC1B,MAAO,WAAaP,GAAU,0BAA6BM,EAAM,IAAOC,GAAQ/b,EAAU,KAAOA,EAAU,GAC/G,CAGE,MAAO,CAACjM,EAAO+nB,EAAKE,KAClB,IAAkB,IAAdL,EACF,MAAM,IAAI5b,EACR8b,EAAcC,EAAK,qBAAuBF,EAAU,OAASA,EAAU,KACvE7b,EAAWkc,gBAef,OAXIL,IAAYF,GAAmBI,KACjCJ,GAAmBI,IAAO,EAE1BI,QAAQC,KACNN,EACEC,EACA,+BAAiCF,EAAU,8CAK1CD,GAAYA,EAAU5nB,EAAO+nB,EAAKE,GAE7C,EAEAP,GAAWW,SAAW,SAAkBC,GACtC,MAAO,CAACtoB,EAAO+nB,KAEbI,QAAQC,KAAK,GAAGL,gCAAkCO,MAC3C,EAEX,EAmCA,IAAAV,GAAe,CACbW,cAxBF,SAAuBra,EAASsa,EAAQC,GACtC,GAAuB,iBAAZva,EACT,MAAM,IAAIlC,EAAW,4BAA6BA,EAAW0c,sBAE/D,MAAMhlB,EAAO5C,OAAO4C,KAAKwK,GACzB,IAAI1O,EAAIkE,EAAKD,OACb,KAAOjE,KAAM,GAAG,CACd,MAAMuoB,EAAMrkB,EAAKlE,GACXooB,EAAYY,EAAOT,GACzB,GAAIH,EAAW,CACb,MAAM5nB,EAAQkO,EAAQ6Z,GAChB9gB,OAAmBoC,IAAVrJ,GAAuB4nB,EAAU5nB,EAAO+nB,EAAK7Z,GAC5D,IAAe,IAAXjH,EACF,MAAM,IAAI+E,EAAW,UAAY+b,EAAM,YAAc9gB,EAAQ+E,EAAW0c,sBAE1E,QACN,CACI,IAAqB,IAAjBD,EACF,MAAM,IAAIzc,EAAW,kBAAoB+b,EAAK/b,EAAW2c,eAE/D,CACA,EAIAC,WAAElB,ICtFF,MAAMkB,GAAahB,GAAUgB,WAS7B,MAAMC,GACJzmB,WAAAA,CAAY0mB,GACVnqB,KAAKoU,SAAW+V,GAAkB,CAAC,EACnCnqB,KAAKoqB,aAAe,CAClB3c,QAAS,IAAImE,GACblE,SAAU,IAAIkE,GAEpB,CAUE,aAAMnE,CAAQ4c,EAAa7c,GACzB,IACE,aAAaxN,KAAKknB,SAASmD,EAAa7c,EAC9C,CAAM,MAAOuU,GACP,GAAIA,aAAelW,MAAO,CACxB,IAAIye,EAAQ,CAAC,EAEbze,MAAM8B,kBAAoB9B,MAAM8B,kBAAkB2c,GAAUA,EAAQ,IAAIze,MAGxE,MAAMgB,EAAQyd,EAAMzd,MAAQyd,EAAMzd,MAAMtD,QAAQ,QAAS,IAAM,GAC/D,IACOwY,EAAIlV,MAGEA,IAAUpC,OAAOsX,EAAIlV,OAAOvC,SAASuC,EAAMtD,QAAQ,YAAa,OACzEwY,EAAIlV,OAAS,KAAOA,GAHpBkV,EAAIlV,MAAQA,CAKxB,CAAU,MAAOtM,GACjB,CAEA,CAEM,MAAMwhB,CACZ,CACA,CAEEmF,QAAAA,CAASmD,EAAa7c,GAGO,iBAAhB6c,GACT7c,EAASA,GAAU,CAAC,GACb6D,IAAMgZ,EAEb7c,EAAS6c,GAAe,CAAC,EAG3B7c,EAASkR,GAAY1e,KAAKoU,SAAU5G,GAEpC,MAAM,aAAC6G,EAAY,iBAAE8K,EAAgB,QAAE3K,GAAWhH,OAE7B9C,IAAjB2J,GACF4U,GAAUW,cAAcvV,EAAc,CACpC7B,kBAAmByX,GAAW5V,aAAa4V,GAAWM,SACtD9X,kBAAmBwX,GAAW5V,aAAa4V,GAAWM,SACtD7X,oBAAqBuX,GAAW5V,aAAa4V,GAAWM,WACvD,GAGmB,MAApBpL,IACEnX,EAAMW,WAAWwW,GACnB3R,EAAO2R,iBAAmB,CACxB5N,UAAW4N,GAGb8J,GAAUW,cAAczK,EAAkB,CACxChO,OAAQ8Y,GAAWO,SACnBjZ,UAAW0Y,GAAWO,WACrB,SAK0B9f,IAA7B8C,EAAO6Q,yBAEoC3T,IAApC1K,KAAKoU,SAASiK,kBACvB7Q,EAAO6Q,kBAAoBre,KAAKoU,SAASiK,kBAEzC7Q,EAAO6Q,mBAAoB,GAG7B4K,GAAUW,cAAcpc,EAAQ,CAC9Bid,QAASR,GAAWP,SAAS,WAC7BgB,cAAeT,GAAWP,SAAS,mBAClC,GAGHlc,EAAO4I,QAAU5I,EAAO4I,QAAUpW,KAAKoU,SAASgC,QAAU,OAAOpT,cAGjE,IAAI2nB,EAAiBnW,GAAWxM,EAAMc,MACpC0L,EAAQ2B,OACR3B,EAAQhH,EAAO4I,SAGjB5B,GAAWxM,EAAMtD,QACf,CAAC,SAAU,MAAO,OAAQ,OAAQ,MAAO,QAAS,UACjD0R,WACQ5B,EAAQ4B,KAInB5I,EAAOgH,QAAUqF,GAAapL,OAAOkc,EAAgBnW,GAGrD,MAAMoW,EAA0B,GAChC,IAAIC,GAAiC,EACrC7qB,KAAKoqB,aAAa3c,QAAQ/I,QAAQ,SAAoComB,GACjC,mBAAxBA,EAAY5Y,UAA0D,IAAhC4Y,EAAY5Y,QAAQ1E,KAIrEqd,EAAiCA,GAAkCC,EAAY7Y,YAE/E2Y,EAAwBG,QAAQD,EAAY/Y,UAAW+Y,EAAY9Y,UACzE,GAEI,MAAMgZ,EAA2B,GAKjC,IAAIC,EAJJjrB,KAAKoqB,aAAa1c,SAAShJ,QAAQ,SAAkComB,GACnEE,EAAyBtjB,KAAKojB,EAAY/Y,UAAW+Y,EAAY9Y,SACvE,GAGI,IACI/M,EADApE,EAAI,EAGR,IAAKgqB,EAAgC,CACnC,MAAMK,EAAQ,CAACrC,GAAgBhnB,KAAK7B,WAAO0K,GAO3C,IANAwgB,EAAMH,WAAWH,GACjBM,EAAMxjB,QAAQsjB,GACd/lB,EAAMimB,EAAMpmB,OAEZmmB,EAAUjK,QAAQ3G,QAAQ7M,GAEnB3M,EAAIoE,GACTgmB,EAAUA,EAAQ/d,KAAKge,EAAMrqB,KAAMqqB,EAAMrqB,MAG3C,OAAOoqB,CACb,CAEIhmB,EAAM2lB,EAAwB9lB,OAE9B,IAAIqb,EAAY3S,EAEhB,KAAO3M,EAAIoE,GAAK,CACd,MAAMkmB,EAAcP,EAAwB/pB,KACtCuqB,EAAaR,EAAwB/pB,KAC3C,IACEsf,EAAYgL,EAAYhL,EAChC,CAAQ,MAAOvR,GACPwc,EAAWtoB,KAAK9C,KAAM4O,GACtB,KACR,CACA,CAEI,IACEqc,EAAUpC,GAAgB/lB,KAAK9C,KAAMmgB,EAC3C,CAAM,MAAOvR,GACP,OAAOoS,QAAQ1G,OAAO1L,EAC5B,CAKI,IAHA/N,EAAI,EACJoE,EAAM+lB,EAAyBlmB,OAExBjE,EAAIoE,GACTgmB,EAAUA,EAAQ/d,KAAK8d,EAAyBnqB,KAAMmqB,EAAyBnqB,MAGjF,OAAOoqB,CACX,CAEEI,MAAAA,CAAO7d,GAGL,OAAO4D,GADU8M,IADjB1Q,EAASkR,GAAY1e,KAAKoU,SAAU5G,IACE2Q,QAAS3Q,EAAO6D,IAAK7D,EAAO6Q,mBACxC7Q,EAAOyD,OAAQzD,EAAO2R,iBACpD,EAIAnX,EAAMtD,QAAQ,CAAC,SAAU,MAAO,OAAQ,WAAY,SAA6B0R,GAE/E8T,GAAM9nB,UAAUgU,GAAU,SAAS/E,EAAK7D,GACtC,OAAOxN,KAAKyN,QAAQiR,GAAYlR,GAAU,CAAC,EAAG,CAC5C4I,SACA/E,MACA9J,MAAOiG,GAAU,CAAC,GAAGjG,OAE3B,CACA,GAEAS,EAAMtD,QAAQ,CAAC,OAAQ,MAAO,SAAU,SAA+B0R,GAGrE,SAASkV,EAAmBC,GAC1B,OAAO,SAAoBla,EAAK9J,EAAMiG,GACpC,OAAOxN,KAAKyN,QAAQiR,GAAYlR,GAAU,CAAC,EAAG,CAC5C4I,SACA5B,QAAS+W,EAAS,CAChB,eAAgB,uBACd,CAAC,EACLla,MACA9J,SAER,CACA,CAEE2iB,GAAM9nB,UAAUgU,GAAUkV,IAE1BpB,GAAM9nB,UAAUgU,EAAS,QAAUkV,GAAmB,EACxD,GAEA,IAAAE,GAAetB,GCpOf,MAAMuB,GACJhoB,WAAAA,CAAYioB,GACV,GAAwB,mBAAbA,EACT,MAAM,IAAIlc,UAAU,gCAGtB,IAAImc,EAEJ3rB,KAAKirB,QAAU,IAAIjK,QAAQ,SAAyB3G,GAClDsR,EAAiBtR,CACvB,GAEI,MAAMnT,EAAQlH,KAGdA,KAAKirB,QAAQ/d,KAAK6V,IAChB,IAAK7b,EAAM0kB,WAAY,OAEvB,IAAI/qB,EAAIqG,EAAM0kB,WAAW9mB,OAEzB,KAAOjE,KAAM,GACXqG,EAAM0kB,WAAW/qB,GAAGkiB,GAEtB7b,EAAM0kB,WAAa,OAIrB5rB,KAAKirB,QAAQ/d,KAAO2e,IAClB,IAAIC,EAEJ,MAAMb,EAAU,IAAIjK,QAAQ3G,IAC1BnT,EAAM+b,UAAU5I,GAChByR,EAAWzR,IACVnN,KAAK2e,GAMR,OAJAZ,EAAQlI,OAAS,WACf7b,EAAMua,YAAYqK,EAC1B,EAEab,GAGTS,EAAS,SAAgBpe,EAASE,EAAQC,GACpCvG,EAAMyc,SAKVzc,EAAMyc,OAAS,IAAIzJ,GAAc5M,EAASE,EAAQC,GAClDke,EAAezkB,EAAMyc,QAC3B,EACA,CAKEiF,gBAAAA,GACE,GAAI5oB,KAAK2jB,OACP,MAAM3jB,KAAK2jB,MAEjB,CAMEV,SAAAA,CAAUxI,GACJza,KAAK2jB,OACPlJ,EAASza,KAAK2jB,QAIZ3jB,KAAK4rB,WACP5rB,KAAK4rB,WAAWlkB,KAAK+S,GAErBza,KAAK4rB,WAAa,CAACnR,EAEzB,CAMEgH,WAAAA,CAAYhH,GACV,IAAKza,KAAK4rB,WACR,OAEF,MAAMpb,EAAQxQ,KAAK4rB,WAAWhhB,QAAQ6P,IACvB,IAAXjK,GACFxQ,KAAK4rB,WAAWG,OAAOvb,EAAO,EAEpC,CAEEsW,aAAAA,GACE,MAAMrD,EAAa,IAAIC,gBAEjBV,EAASjB,IACb0B,EAAWT,MAAMjB,IAOnB,OAJA/hB,KAAKijB,UAAUD,GAEfS,EAAW/B,OAAOD,YAAc,IAAMzhB,KAAKyhB,YAAYuB,GAEhDS,EAAW/B,MACtB,CAME,aAAOpa,GACL,IAAIyb,EAIJ,MAAO,CACL7b,MAJY,IAAIukB,GAAY,SAAkBnqB,GAC9CyhB,EAASzhB,CACf,GAGMyhB,SAEN,EAGA,IAAAiJ,GAAeP,GCtIf,MAAMQ,GAAiB,CACrBC,SAAU,IACVC,mBAAoB,IACpBC,WAAY,IACZC,WAAY,IACZC,GAAI,IACJC,QAAS,IACTC,SAAU,IACVC,4BAA6B,IAC7BC,UAAW,IACXC,aAAc,IACdC,eAAgB,IAChBC,YAAa,IACbC,gBAAiB,IACjBC,OAAQ,IACRC,gBAAiB,IACjBC,iBAAkB,IAClBC,MAAO,IACPC,SAAU,IACVC,YAAa,IACbC,SAAU,IACVC,OAAQ,IACRC,kBAAmB,IACnBC,kBAAmB,IACnBC,WAAY,IACZC,aAAc,IACdC,gBAAiB,IACjBC,UAAW,IACXC,SAAU,IACVC,iBAAkB,IAClBC,cAAe,IACfC,4BAA6B,IAC7BC,eAAgB,IAChBC,SAAU,IACVC,KAAM,IACNC,eAAgB,IAChBC,mBAAoB,IACpBC,gBAAiB,IACjBC,WAAY,IACZC,qBAAsB,IACtBC,oBAAqB,IACrBC,kBAAmB,IACnBC,UAAW,IACXC,mBAAoB,IACpBC,oBAAqB,IACrBC,OAAQ,IACRC,iBAAkB,IAClBC,SAAU,IACVC,gBAAiB,IACjBC,qBAAsB,IACtBC,gBAAiB,IACjBC,4BAA6B,IAC7BC,2BAA4B,IAC5BC,oBAAqB,IACrBC,eAAgB,IAChBC,WAAY,IACZC,mBAAoB,IACpBC,eAAgB,IAChBC,wBAAyB,IACzBC,sBAAuB,IACvBC,oBAAqB,IACrBC,aAAc,IACdC,YAAa,IACbC,8BAA+B,IAC/BC,gBAAiB,IACjBC,mBAAoB,IACpBC,oBAAqB,IACrBC,gBAAiB,IACjBC,mBAAoB,IACpBC,sBAAuB,KAGzBnuB,OAAO+R,QAAQ+X,IAAgBvnB,QAAQ,EAAEQ,EAAK7D,MAC5C4qB,GAAe5qB,GAAS6D,IAG1B,IAAAqrB,GAAetE,GC9BV,MAACuE,GAnBN,SAASC,EAAeC,GACtB,MAAM/qB,EAAU,IAAI6lB,GAAMkF,GACpBC,EAAW9uB,EAAK2pB,GAAMppB,UAAUqL,QAAS9H,GAa/C,OAVAqC,EAAMmB,OAAOwnB,EAAUnF,GAAMppB,UAAWuD,EAAS,CAACf,YAAY,IAG9DoD,EAAMmB,OAAOwnB,EAAUhrB,EAAS,KAAM,CAACf,YAAY,IAGnD+rB,EAAShuB,OAAS,SAAgBwnB,GAChC,OAAOsG,EAAe/R,GAAYgS,EAAevG,GACrD,EAESwG,CACT,CAGcF,CAAepa,IAG7Bma,GAAMtG,MAAQsB,GAGdgF,GAAMtW,cAAgBA,GACtBsW,GAAM/E,YAAcO,GACpBwE,GAAMxW,SAAWA,GACjBwW,GAAM1H,QAAUA,GAChB0H,GAAMnhB,WAAaA,GAGnBmhB,GAAMnjB,WAAaA,EAGnBmjB,GAAMI,OAASJ,GAAMtW,cAGrBsW,GAAMK,IAAM,SAAaC,GACvB,OAAO9P,QAAQ6P,IAAIC,EACrB,EAEAN,GAAMO,OC9CS,SAAgBC,GAC7B,OAAO,SAAclmB,GACnB,OAAOkmB,EAAShvB,MAAM,KAAM8I,EAChC,CACA,ED6CA0lB,GAAMS,aE7DS,SAAsBC,GACnC,OAAOlpB,EAAMlE,SAASotB,KAAsC,IAAzBA,EAAQD,YAC7C,EF8DAT,GAAM9R,YAAcA,GAEpB8R,GAAM3Z,aAAegD,GAErB2W,GAAMW,WAAavuB,GAASiR,GAAe7L,EAAMjC,WAAWnD,GAAS,IAAIuF,SAASvF,GAASA,GAE3F4tB,GAAMY,WAAa9I,GAEnBkI,GAAMvE,eAAiBsE,GAEvBC,GAAMa,QAAUb,G,6CG3EZc,EAASC,EAAQ,KACjBC,EAAUD,EAAQ,IAEtB3xB,EAAQ,GAASsQ,EAEjBtQ,EAAQ,GAAoB,GAE5B,IAAI6xB,EAAe,WAsDnB,SAASC,EAAc5sB,GACrB,GAAIA,EAAS2sB,EACX,MAAM,IAAIE,WAAW,cAAgB7sB,EAAS,kCAGhD,IAAI8sB,EAAM,IAAI9rB,WAAWhB,GAEzB,OADA8sB,EAAIC,UAAY3hB,EAAO9N,UAChBwvB,CACT,CAYA,SAAS1hB,EAAQ4hB,EAAKC,EAAkBjtB,GAEtC,GAAmB,iBAARgtB,EAAkB,CAC3B,GAAgC,iBAArBC,EACT,MAAM,IAAIviB,UACR,sEAGJ,OAAOwiB,EAAYF,EACrB,CACA,OAAOnjB,EAAKmjB,EAAKC,EAAkBjtB,EACrC,CAeA,SAAS6J,EAAMtN,EAAO0wB,EAAkBjtB,GACtC,GAAqB,iBAAVzD,EACT,OAiHJ,SAAqB4wB,EAAQC,GAK3B,GAJwB,iBAAbA,GAAsC,KAAbA,IAClCA,EAAW,SAGRhiB,EAAOiiB,WAAWD,GACrB,MAAM,IAAI1iB,UAAU,qBAAuB0iB,GAG7C,IAAIptB,EAAwC,EAA/Bif,EAAWkO,EAAQC,GAC5BN,EAAMF,EAAa5sB,GAEnBstB,EAASR,EAAIxwB,MAAM6wB,EAAQC,GAS/B,OAPIE,IAAWttB,IAIb8sB,EAAMA,EAAI7uB,MAAM,EAAGqvB,IAGdR,CACT,CAvIWS,CAAWhxB,EAAO0wB,GAG3B,GAAIxpB,YAAYC,OAAOnH,GACrB,OAAOixB,EAAcjxB,GAGvB,GAAa,MAATA,EACF,MAAMmO,UACJ,yHACiDnO,GAIrD,GAAIkxB,EAAWlxB,EAAOkH,cACjBlH,GAASkxB,EAAWlxB,EAAMnB,OAAQqI,aACrC,OAkIJ,SAA0BiqB,EAAOC,EAAY3tB,GAC3C,GAAI2tB,EAAa,GAAKD,EAAMzO,WAAa0O,EACvC,MAAM,IAAId,WAAW,wCAGvB,GAAIa,EAAMzO,WAAa0O,GAAc3tB,GAAU,GAC7C,MAAM,IAAI6sB,WAAW,wCAGvB,IAAIC,EAWJ,OATEA,OADiBlnB,IAAf+nB,QAAuC/nB,IAAX5F,EACxB,IAAIgB,WAAW0sB,QACD9nB,IAAX5F,EACH,IAAIgB,WAAW0sB,EAAOC,GAEtB,IAAI3sB,WAAW0sB,EAAOC,EAAY3tB,IAItC+sB,UAAY3hB,EAAO9N,UAChBwvB,CACT,CAvJWc,CAAgBrxB,EAAO0wB,EAAkBjtB,GAGlD,GAAqB,iBAAVzD,EACT,MAAM,IAAImO,UACR,yEAIJ,IAAImjB,EAAUtxB,EAAMsxB,SAAWtxB,EAAMsxB,UACrC,GAAe,MAAXA,GAAmBA,IAAYtxB,EACjC,OAAO6O,EAAOvB,KAAKgkB,EAASZ,EAAkBjtB,GAGhD,IAAIuE,EA2IN,SAAqB1E,GACnB,GAAIuL,EAAO3M,SAASoB,GAAM,CACxB,IAAIM,EAA4B,EAAtB2tB,EAAQjuB,EAAIG,QAClB8sB,EAAMF,EAAazsB,GAEvB,OAAmB,IAAf2sB,EAAI9sB,QAIRH,EAAIkuB,KAAKjB,EAAK,EAAG,EAAG3sB,GAHX2sB,CAKX,CAEA,YAAmBlnB,IAAf/F,EAAIG,OACoB,iBAAfH,EAAIG,QAAuBguB,EAAYnuB,EAAIG,QAC7C4sB,EAAa,GAEfY,EAAc3tB,GAGN,WAAbA,EAAIzB,MAAqBG,MAAMD,QAAQuB,EAAI4C,MACtC+qB,EAAc3tB,EAAI4C,WAD3B,CAGF,CAlKUwrB,CAAW1xB,GACnB,GAAIgI,EAAG,OAAOA,EAEd,GAAsB,oBAAX7G,QAAgD,MAAtBA,OAAOwwB,aACH,mBAA9B3xB,EAAMmB,OAAOwwB,aACtB,OAAO9iB,EAAOvB,KACZtN,EAAMmB,OAAOwwB,aAAa,UAAWjB,EAAkBjtB,GAI3D,MAAM,IAAI0K,UACR,yHACiDnO,EAErD,CAmBA,SAAS4xB,EAAYhM,GACnB,GAAoB,iBAATA,EACT,MAAM,IAAIzX,UAAU,0CACf,GAAIyX,EAAO,EAChB,MAAM,IAAI0K,WAAW,cAAgB1K,EAAO,iCAEhD,CA0BA,SAAS+K,EAAa/K,GAEpB,OADAgM,EAAWhM,GACJyK,EAAazK,EAAO,EAAI,EAAoB,EAAhB2L,EAAQ3L,GAC7C,CAuCA,SAASqL,EAAeE,GAGtB,IAFA,IAAI1tB,EAAS0tB,EAAM1tB,OAAS,EAAI,EAA4B,EAAxB8tB,EAAQJ,EAAM1tB,QAC9C8sB,EAAMF,EAAa5sB,GACdjE,EAAI,EAAGA,EAAIiE,EAAQjE,GAAK,EAC/B+wB,EAAI/wB,GAAgB,IAAX2xB,EAAM3xB,GAEjB,OAAO+wB,CACT,CAkDA,SAASgB,EAAS9tB,GAGhB,GAAIA,GAAU2sB,EACZ,MAAM,IAAIE,WAAW,0DACaF,EAAavvB,SAAS,IAAM,UAEhE,OAAgB,EAAT4C,CACT,CA6FA,SAASif,EAAYkO,EAAQC,GAC3B,GAAIhiB,EAAO3M,SAAS0uB,GAClB,OAAOA,EAAOntB,OAEhB,GAAIyD,YAAYC,OAAOypB,IAAWM,EAAWN,EAAQ1pB,aACnD,OAAO0pB,EAAOlO,WAEhB,GAAsB,iBAAXkO,EACT,MAAM,IAAIziB,UACR,kGAC0ByiB,GAI9B,IAAIhtB,EAAMgtB,EAAOntB,OACbouB,EAAajxB,UAAU6C,OAAS,IAAsB,IAAjB7C,UAAU,GACnD,IAAKixB,GAAqB,IAARjuB,EAAW,OAAO,EAIpC,IADA,IAAIkuB,GAAc,IAEhB,OAAQjB,GACN,IAAK,QACL,IAAK,SACL,IAAK,SACH,OAAOjtB,EACT,IAAK,OACL,IAAK,QACH,OAAOmuB,EAAYnB,GAAQntB,OAC7B,IAAK,OACL,IAAK,QACL,IAAK,UACL,IAAK,WACH,OAAa,EAANG,EACT,IAAK,MACH,OAAOA,IAAQ,EACjB,IAAK,SACH,OAAOouB,EAAcpB,GAAQntB,OAC/B,QACE,GAAIquB,EACF,OAAOD,GAAa,EAAIE,EAAYnB,GAAQntB,OAE9CotB,GAAY,GAAKA,GAAUlvB,cAC3BmwB,GAAc,EAGtB,CAGA,SAASG,EAAcpB,EAAUqB,EAAOvP,GACtC,IAAImP,GAAc,EAclB,SALczoB,IAAV6oB,GAAuBA,EAAQ,KACjCA,EAAQ,GAINA,EAAQvzB,KAAK8E,OACf,MAAO,GAOT,SAJY4F,IAARsZ,GAAqBA,EAAMhkB,KAAK8E,UAClCkf,EAAMhkB,KAAK8E,QAGTkf,GAAO,EACT,MAAO,GAOT,IAHAA,KAAS,KACTuP,KAAW,GAGT,MAAO,GAKT,IAFKrB,IAAUA,EAAW,UAGxB,OAAQA,GACN,IAAK,MACH,OAAOsB,EAASxzB,KAAMuzB,EAAOvP,GAE/B,IAAK,OACL,IAAK,QACH,OAAOyP,EAAUzzB,KAAMuzB,EAAOvP,GAEhC,IAAK,QACH,OAAO0P,EAAW1zB,KAAMuzB,EAAOvP,GAEjC,IAAK,SACL,IAAK,SACH,OAAO2P,EAAY3zB,KAAMuzB,EAAOvP,GAElC,IAAK,SACH,OAAO4P,EAAY5zB,KAAMuzB,EAAOvP,GAElC,IAAK,OACL,IAAK,QACL,IAAK,UACL,IAAK,WACH,OAAO6P,EAAa7zB,KAAMuzB,EAAOvP,GAEnC,QACE,GAAImP,EAAa,MAAM,IAAI3jB,UAAU,qBAAuB0iB,GAC5DA,GAAYA,EAAW,IAAIlvB,cAC3BmwB,GAAc,EAGtB,CAUA,SAASW,EAAMzqB,EAAG0qB,EAAGvzB,GACnB,IAAIK,EAAIwI,EAAE0qB,GACV1qB,EAAE0qB,GAAK1qB,EAAE7I,GACT6I,EAAE7I,GAAKK,CACT,CAwIA,SAASmzB,EAAsB9zB,EAAQsD,EAAKivB,EAAYP,EAAU+B,GAEhE,GAAsB,IAAlB/zB,EAAO4E,OAAc,OAAQ,EAmBjC,GAhB0B,iBAAf2tB,GACTP,EAAWO,EACXA,EAAa,GACJA,EAAa,WACtBA,EAAa,WACJA,GAAc,aACvBA,GAAc,YAGZK,EADJL,GAAcA,KAGZA,EAAawB,EAAM,EAAK/zB,EAAO4E,OAAS,GAItC2tB,EAAa,IAAGA,EAAavyB,EAAO4E,OAAS2tB,GAC7CA,GAAcvyB,EAAO4E,OAAQ,CAC/B,GAAImvB,EAAK,OAAQ,EACZxB,EAAavyB,EAAO4E,OAAS,CACpC,MAAO,GAAI2tB,EAAa,EAAG,CACzB,IAAIwB,EACC,OAAQ,EADJxB,EAAa,CAExB,CAQA,GALmB,iBAARjvB,IACTA,EAAM0M,EAAOvB,KAAKnL,EAAK0uB,IAIrBhiB,EAAO3M,SAASC,GAElB,OAAmB,IAAfA,EAAIsB,QACE,EAEHovB,EAAah0B,EAAQsD,EAAKivB,EAAYP,EAAU+B,GAClD,GAAmB,iBAARzwB,EAEhB,OADAA,GAAY,IACgC,mBAAjCsC,WAAW1D,UAAUwI,QAC1BqpB,EACKnuB,WAAW1D,UAAUwI,QAAQ9H,KAAK5C,EAAQsD,EAAKivB,GAE/C3sB,WAAW1D,UAAU+xB,YAAYrxB,KAAK5C,EAAQsD,EAAKivB,GAGvDyB,EAAah0B,EAAQ,CAAEsD,GAAOivB,EAAYP,EAAU+B,GAG7D,MAAM,IAAIzkB,UAAU,uCACtB,CAEA,SAAS0kB,EAAcppB,EAAKtH,EAAKivB,EAAYP,EAAU+B,GACrD,IA0BIpzB,EA1BAuzB,EAAY,EACZC,EAAYvpB,EAAIhG,OAChBwvB,EAAY9wB,EAAIsB,OAEpB,QAAiB4F,IAAbwnB,IAEe,UADjBA,EAAWznB,OAAOynB,GAAUlvB,gBACY,UAAbkvB,GACV,YAAbA,GAAuC,aAAbA,GAAyB,CACrD,GAAIpnB,EAAIhG,OAAS,GAAKtB,EAAIsB,OAAS,EACjC,OAAQ,EAEVsvB,EAAY,EACZC,GAAa,EACbC,GAAa,EACb7B,GAAc,CAChB,CAGF,SAASxyB,EAAM2xB,EAAK/wB,GAClB,OAAkB,IAAduzB,EACKxC,EAAI/wB,GAEJ+wB,EAAI2C,aAAa1zB,EAAIuzB,EAEhC,CAGA,GAAIH,EAAK,CACP,IAAIO,GAAc,EAClB,IAAK3zB,EAAI4xB,EAAY5xB,EAAIwzB,EAAWxzB,IAClC,GAAIZ,EAAK6K,EAAKjK,KAAOZ,EAAKuD,GAAqB,IAAhBgxB,EAAoB,EAAI3zB,EAAI2zB,IAEzD,IADoB,IAAhBA,IAAmBA,EAAa3zB,GAChCA,EAAI2zB,EAAa,IAAMF,EAAW,OAAOE,EAAaJ,OAEtC,IAAhBI,IAAmB3zB,GAAKA,EAAI2zB,GAChCA,GAAc,CAGpB,MAEE,IADI/B,EAAa6B,EAAYD,IAAW5B,EAAa4B,EAAYC,GAC5DzzB,EAAI4xB,EAAY5xB,GAAK,EAAGA,IAAK,CAEhC,IADA,IAAI4zB,GAAQ,EACHC,EAAI,EAAGA,EAAIJ,EAAWI,IAC7B,GAAIz0B,EAAK6K,EAAKjK,EAAI6zB,KAAOz0B,EAAKuD,EAAKkxB,GAAI,CACrCD,GAAQ,EACR,KACF,CAEF,GAAIA,EAAO,OAAO5zB,CACpB,CAGF,OAAQ,CACV,CAcA,SAAS8zB,EAAU/C,EAAKK,EAAQ9xB,EAAQ2E,GACtC3E,EAASsM,OAAOtM,IAAW,EAC3B,IAAIy0B,EAAYhD,EAAI9sB,OAAS3E,EACxB2E,GAGHA,EAAS2H,OAAO3H,IACH8vB,IACX9vB,EAAS8vB,GAJX9vB,EAAS8vB,EAQX,IAAIC,EAAS5C,EAAOntB,OAEhBA,EAAS+vB,EAAS,IACpB/vB,EAAS+vB,EAAS,GAEpB,IAAK,IAAIh0B,EAAI,EAAGA,EAAIiE,IAAUjE,EAAG,CAC/B,IAAI0W,EAASud,SAAS7C,EAAO8C,OAAW,EAAJl0B,EAAO,GAAI,IAC/C,GAAIiyB,EAAYvb,GAAS,OAAO1W,EAChC+wB,EAAIzxB,EAASU,GAAK0W,CACpB,CACA,OAAO1W,CACT,CAEA,SAASm0B,EAAWpD,EAAKK,EAAQ9xB,EAAQ2E,GACvC,OAAOmwB,EAAW7B,EAAYnB,EAAQL,EAAI9sB,OAAS3E,GAASyxB,EAAKzxB,EAAQ2E,EAC3E,CAEA,SAASowB,EAAYtD,EAAKK,EAAQ9xB,EAAQ2E,GACxC,OAAOmwB,EA63BT,SAAuBpyB,GAErB,IADA,IAAIsyB,EAAY,GACPt0B,EAAI,EAAGA,EAAIgC,EAAIiC,SAAUjE,EAEhCs0B,EAAUztB,KAAyB,IAApB7E,EAAI6G,WAAW7I,IAEhC,OAAOs0B,CACT,CAp4BoBC,CAAanD,GAASL,EAAKzxB,EAAQ2E,EACvD,CAEA,SAASuwB,EAAazD,EAAKK,EAAQ9xB,EAAQ2E,GACzC,OAAOowB,EAAWtD,EAAKK,EAAQ9xB,EAAQ2E,EACzC,CAEA,SAASwwB,EAAa1D,EAAKK,EAAQ9xB,EAAQ2E,GACzC,OAAOmwB,EAAW5B,EAAcpB,GAASL,EAAKzxB,EAAQ2E,EACxD,CAEA,SAASywB,EAAW3D,EAAKK,EAAQ9xB,EAAQ2E,GACvC,OAAOmwB,EA03BT,SAAyBpyB,EAAK2yB,GAG5B,IAFA,IAAIl0B,EAAGm0B,EAAIC,EACPP,EAAY,GACPt0B,EAAI,EAAGA,EAAIgC,EAAIiC,WACjB0wB,GAAS,GAAK,KADa30B,EAIhC40B,GADAn0B,EAAIuB,EAAI6G,WAAW7I,KACT,EACV60B,EAAKp0B,EAAI,IACT6zB,EAAUztB,KAAKguB,GACfP,EAAUztB,KAAK+tB,GAGjB,OAAON,CACT,CAx4BoBQ,CAAe1D,EAAQL,EAAI9sB,OAAS3E,GAASyxB,EAAKzxB,EAAQ2E,EAC9E,CAgFA,SAAS8uB,EAAahC,EAAK2B,EAAOvP,GAChC,OAAc,IAAVuP,GAAevP,IAAQ4N,EAAI9sB,OACtBwsB,EAAOsE,cAAchE,GAErBN,EAAOsE,cAAchE,EAAI7uB,MAAMwwB,EAAOvP,GAEjD,CAEA,SAASyP,EAAW7B,EAAK2B,EAAOvP,GAC9BA,EAAM9iB,KAAK6Z,IAAI6W,EAAI9sB,OAAQkf,GAI3B,IAHA,IAAIyC,EAAM,GAEN5lB,EAAI0yB,EACD1yB,EAAImjB,GAAK,CACd,IAQM6R,EAAYC,EAAWC,EAAYC,EARrCC,EAAYrE,EAAI/wB,GAChBq1B,EAAY,KACZC,EAAoBF,EAAY,IAAQ,EACvCA,EAAY,IAAQ,EAClBA,EAAY,IAAQ,EACnB,EAER,GAAIp1B,EAAIs1B,GAAoBnS,EAG1B,OAAQmS,GACN,KAAK,EACCF,EAAY,MACdC,EAAYD,GAEd,MACF,KAAK,EAEyB,MAAV,KADlBJ,EAAajE,EAAI/wB,EAAI,OAEnBm1B,GAA6B,GAAZC,IAAqB,EAAoB,GAAbJ,GACzB,MAClBK,EAAYF,GAGhB,MACF,KAAK,EACHH,EAAajE,EAAI/wB,EAAI,GACrBi1B,EAAYlE,EAAI/wB,EAAI,GACQ,MAAV,IAAbg1B,IAAsD,MAAV,IAAZC,KACnCE,GAA6B,GAAZC,IAAoB,IAAoB,GAAbJ,IAAsB,EAAmB,GAAZC,GACrD,OAAUE,EAAgB,OAAUA,EAAgB,SACtEE,EAAYF,GAGhB,MACF,KAAK,EACHH,EAAajE,EAAI/wB,EAAI,GACrBi1B,EAAYlE,EAAI/wB,EAAI,GACpBk1B,EAAanE,EAAI/wB,EAAI,GACO,MAAV,IAAbg1B,IAAsD,MAAV,IAAZC,IAAsD,MAAV,IAAbC,KAClEC,GAA6B,GAAZC,IAAoB,IAAqB,GAAbJ,IAAsB,IAAmB,GAAZC,IAAqB,EAAoB,GAAbC,GAClF,OAAUC,EAAgB,UAC5CE,EAAYF,GAMJ,OAAdE,GAGFA,EAAY,MACZC,EAAmB,GACVD,EAAY,QAErBA,GAAa,MACbzP,EAAI/e,KAAKwuB,IAAc,GAAK,KAAQ,OACpCA,EAAY,MAAqB,KAAZA,GAGvBzP,EAAI/e,KAAKwuB,GACTr1B,GAAKs1B,CACP,CAEA,OAQF,SAAgCC,GAC9B,IAAInxB,EAAMmxB,EAAWtxB,OACrB,GAAIG,GAAOoxB,EACT,OAAO5rB,OAAO6rB,aAAat0B,MAAMyI,OAAQ2rB,GAM3C,IAFA,IAAI3P,EAAM,GACN5lB,EAAI,EACDA,EAAIoE,GACTwhB,GAAOhc,OAAO6rB,aAAat0B,MACzByI,OACA2rB,EAAWrzB,MAAMlC,EAAGA,GAAKw1B,IAG7B,OAAO5P,CACT,CAxBS8P,CAAsB9P,EAC/B,CA78BAvW,EAAOsmB,oBAUP,WAEE,IACE,IAAI1rB,EAAM,IAAIhF,WAAW,GAEzB,OADAgF,EAAI+mB,UAAY,CAAEA,UAAW/rB,WAAW1D,UAAWq0B,IAAK,WAAc,OAAO,EAAG,GAC3D,KAAd3rB,EAAI2rB,KACb,CAAE,MAAOl2B,GACP,OAAO,CACT,CACF,CAnB6Bm2B,GAExBxmB,EAAOsmB,qBAA0C,oBAAZhN,SACb,mBAAlBA,QAAQ5a,OACjB4a,QAAQ5a,MACN,iJAgBJzM,OAAO2H,eAAeoG,EAAO9N,UAAW,SAAU,CAChDsJ,YAAY,EACZmM,IAAK,WACH,GAAK3H,EAAO3M,SAASvD,MACrB,OAAOA,KAAKE,MACd,IAGFiC,OAAO2H,eAAeoG,EAAO9N,UAAW,SAAU,CAChDsJ,YAAY,EACZmM,IAAK,WACH,GAAK3H,EAAO3M,SAASvD,MACrB,OAAOA,KAAKyyB,UACd,IAqCoB,oBAAXjwB,QAA4C,MAAlBA,OAAOm0B,SACxCzmB,EAAO1N,OAAOm0B,WAAazmB,GAC7B/N,OAAO2H,eAAeoG,EAAQ1N,OAAOm0B,QAAS,CAC5Ct1B,MAAO,KACP6N,cAAc,EACdxD,YAAY,EACZC,UAAU,IAIduE,EAAO0mB,SAAW,KA0DlB1mB,EAAOvB,KAAO,SAAUtN,EAAO0wB,EAAkBjtB,GAC/C,OAAO6J,EAAKtN,EAAO0wB,EAAkBjtB,EACvC,EAIAoL,EAAO9N,UAAUyvB,UAAY/rB,WAAW1D,UACxC8N,EAAO2hB,UAAY/rB,WA8BnBoK,EAAO2mB,MAAQ,SAAU5P,EAAM6P,EAAM5E,GACnC,OArBF,SAAgBjL,EAAM6P,EAAM5E,GAE1B,OADAe,EAAWhM,GACPA,GAAQ,EACHyK,EAAazK,QAETvc,IAATosB,EAIyB,iBAAb5E,EACVR,EAAazK,GAAM6P,KAAKA,EAAM5E,GAC9BR,EAAazK,GAAM6P,KAAKA,GAEvBpF,EAAazK,EACtB,CAOS4P,CAAM5P,EAAM6P,EAAM5E,EAC3B,EAUAhiB,EAAO8hB,YAAc,SAAU/K,GAC7B,OAAO+K,EAAY/K,EACrB,EAIA/W,EAAO6mB,gBAAkB,SAAU9P,GACjC,OAAO+K,EAAY/K,EACrB,EAoGA/W,EAAO3M,SAAW,SAAmB8F,GACnC,OAAY,MAALA,IAA6B,IAAhBA,EAAE2tB,WACpB3tB,IAAM6G,EAAO9N,SACjB,EAEA8N,EAAO+mB,QAAU,SAAkB7tB,EAAGC,GAGpC,GAFIkpB,EAAWnpB,EAAGtD,cAAasD,EAAI8G,EAAOvB,KAAKvF,EAAGA,EAAEjJ,OAAQiJ,EAAE2a,aAC1DwO,EAAWlpB,EAAGvD,cAAauD,EAAI6G,EAAOvB,KAAKtF,EAAGA,EAAElJ,OAAQkJ,EAAE0a,cACzD7T,EAAO3M,SAAS6F,KAAO8G,EAAO3M,SAAS8F,GAC1C,MAAM,IAAImG,UACR,yEAIJ,GAAIpG,IAAMC,EAAG,OAAO,EAKpB,IAHA,IAAI6tB,EAAI9tB,EAAEtE,OACNqyB,EAAI9tB,EAAEvE,OAEDjE,EAAI,EAAGoE,EAAM/D,KAAK6Z,IAAImc,EAAGC,GAAIt2B,EAAIoE,IAAOpE,EAC/C,GAAIuI,EAAEvI,KAAOwI,EAAExI,GAAI,CACjBq2B,EAAI9tB,EAAEvI,GACNs2B,EAAI9tB,EAAExI,GACN,KACF,CAGF,OAAIq2B,EAAIC,GAAW,EACfA,EAAID,EAAU,EACX,CACT,EAEAhnB,EAAOiiB,WAAa,SAAqBD,GACvC,OAAQznB,OAAOynB,GAAUlvB,eACvB,IAAK,MACL,IAAK,OACL,IAAK,QACL,IAAK,QACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,OACL,IAAK,QACL,IAAK,UACL,IAAK,WACH,OAAO,EACT,QACE,OAAO,EAEb,EAEAkN,EAAOzB,OAAS,SAAiB2oB,EAAMtyB,GACrC,IAAKzB,MAAMD,QAAQg0B,GACjB,MAAM,IAAI5nB,UAAU,+CAGtB,GAAoB,IAAhB4nB,EAAKtyB,OACP,OAAOoL,EAAO2mB,MAAM,GAGtB,IAAIh2B,EACJ,QAAe6J,IAAX5F,EAEF,IADAA,EAAS,EACJjE,EAAI,EAAGA,EAAIu2B,EAAKtyB,SAAUjE,EAC7BiE,GAAUsyB,EAAKv2B,GAAGiE,OAItB,IAAI5E,EAASgQ,EAAO8hB,YAAYltB,GAC5Bmf,EAAM,EACV,IAAKpjB,EAAI,EAAGA,EAAIu2B,EAAKtyB,SAAUjE,EAAG,CAChC,IAAI+wB,EAAMwF,EAAKv2B,GAIf,GAHI0xB,EAAWX,EAAK9rB,cAClB8rB,EAAM1hB,EAAOvB,KAAKijB,KAEf1hB,EAAO3M,SAASquB,GACnB,MAAM,IAAIpiB,UAAU,+CAEtBoiB,EAAIiB,KAAK3yB,EAAQ+jB,GACjBA,GAAO2N,EAAI9sB,MACb,CACA,OAAO5E,CACT,EAiDAgQ,EAAO6T,WAAaA,EA8EpB7T,EAAO9N,UAAU40B,WAAY,EAQ7B9mB,EAAO9N,UAAUi1B,OAAS,WACxB,IAAIpyB,EAAMjF,KAAK8E,OACf,GAAIG,EAAM,GAAM,EACd,MAAM,IAAI0sB,WAAW,6CAEvB,IAAK,IAAI9wB,EAAI,EAAGA,EAAIoE,EAAKpE,GAAK,EAC5BizB,EAAK9zB,KAAMa,EAAGA,EAAI,GAEpB,OAAOb,IACT,EAEAkQ,EAAO9N,UAAUk1B,OAAS,WACxB,IAAIryB,EAAMjF,KAAK8E,OACf,GAAIG,EAAM,GAAM,EACd,MAAM,IAAI0sB,WAAW,6CAEvB,IAAK,IAAI9wB,EAAI,EAAGA,EAAIoE,EAAKpE,GAAK,EAC5BizB,EAAK9zB,KAAMa,EAAGA,EAAI,GAClBizB,EAAK9zB,KAAMa,EAAI,EAAGA,EAAI,GAExB,OAAOb,IACT,EAEAkQ,EAAO9N,UAAUm1B,OAAS,WACxB,IAAItyB,EAAMjF,KAAK8E,OACf,GAAIG,EAAM,GAAM,EACd,MAAM,IAAI0sB,WAAW,6CAEvB,IAAK,IAAI9wB,EAAI,EAAGA,EAAIoE,EAAKpE,GAAK,EAC5BizB,EAAK9zB,KAAMa,EAAGA,EAAI,GAClBizB,EAAK9zB,KAAMa,EAAI,EAAGA,EAAI,GACtBizB,EAAK9zB,KAAMa,EAAI,EAAGA,EAAI,GACtBizB,EAAK9zB,KAAMa,EAAI,EAAGA,EAAI,GAExB,OAAOb,IACT,EAEAkQ,EAAO9N,UAAUF,SAAW,WAC1B,IAAI4C,EAAS9E,KAAK8E,OAClB,OAAe,IAAXA,EAAqB,GACA,IAArB7C,UAAU6C,OAAqB2uB,EAAUzzB,KAAM,EAAG8E,GAC/CwuB,EAAatxB,MAAMhC,KAAMiC,UAClC,EAEAiO,EAAO9N,UAAUo1B,eAAiBtnB,EAAO9N,UAAUF,SAEnDgO,EAAO9N,UAAUq1B,OAAS,SAAiBpuB,GACzC,IAAK6G,EAAO3M,SAAS8F,GAAI,MAAM,IAAImG,UAAU,6BAC7C,OAAIxP,OAASqJ,GACsB,IAA5B6G,EAAO+mB,QAAQj3B,KAAMqJ,EAC9B,EAEA6G,EAAO9N,UAAUs1B,QAAU,WACzB,IAAI70B,EAAM,GACN80B,EAAM/3B,EAAQ,GAGlB,OAFAiD,EAAM7C,KAAKkC,SAAS,MAAO,EAAGy1B,GAAKpuB,QAAQ,UAAW,OAAOD,OACzDtJ,KAAK8E,OAAS6yB,IAAK90B,GAAO,SACvB,WAAaA,EAAM,GAC5B,EAEAqN,EAAO9N,UAAU60B,QAAU,SAAkBlqB,EAAQwmB,EAAOvP,EAAK4T,EAAWC,GAI1E,GAHItF,EAAWxlB,EAAQjH,cACrBiH,EAASmD,EAAOvB,KAAK5B,EAAQA,EAAO5M,OAAQ4M,EAAOgX,cAEhD7T,EAAO3M,SAASwJ,GACnB,MAAM,IAAIyC,UACR,wFAC2BzC,GAiB/B,QAbcrC,IAAV6oB,IACFA,EAAQ,QAEE7oB,IAARsZ,IACFA,EAAMjX,EAASA,EAAOjI,OAAS,QAEf4F,IAAdktB,IACFA,EAAY,QAEEltB,IAAZmtB,IACFA,EAAU73B,KAAK8E,QAGbyuB,EAAQ,GAAKvP,EAAMjX,EAAOjI,QAAU8yB,EAAY,GAAKC,EAAU73B,KAAK8E,OACtE,MAAM,IAAI6sB,WAAW,sBAGvB,GAAIiG,GAAaC,GAAWtE,GAASvP,EACnC,OAAO,EAET,GAAI4T,GAAaC,EACf,OAAQ,EAEV,GAAItE,GAASvP,EACX,OAAO,EAQT,GAAIhkB,OAAS+M,EAAQ,OAAO,EAS5B,IAPA,IAAImqB,GAJJW,KAAa,IADbD,KAAe,GAMXT,GAPJnT,KAAS,IADTuP,KAAW,GASPtuB,EAAM/D,KAAK6Z,IAAImc,EAAGC,GAElBW,EAAW93B,KAAK+C,MAAM60B,EAAWC,GACjCE,EAAahrB,EAAOhK,MAAMwwB,EAAOvP,GAE5BnjB,EAAI,EAAGA,EAAIoE,IAAOpE,EACzB,GAAIi3B,EAASj3B,KAAOk3B,EAAWl3B,GAAI,CACjCq2B,EAAIY,EAASj3B,GACbs2B,EAAIY,EAAWl3B,GACf,KACF,CAGF,OAAIq2B,EAAIC,GAAW,EACfA,EAAID,EAAU,EACX,CACT,EA2HAhnB,EAAO9N,UAAUwe,SAAW,SAAmBpd,EAAKivB,EAAYP,GAC9D,OAAoD,IAA7ClyB,KAAK4K,QAAQpH,EAAKivB,EAAYP,EACvC,EAEAhiB,EAAO9N,UAAUwI,QAAU,SAAkBpH,EAAKivB,EAAYP,GAC5D,OAAO8B,EAAqBh0B,KAAMwD,EAAKivB,EAAYP,GAAU,EAC/D,EAEAhiB,EAAO9N,UAAU+xB,YAAc,SAAsB3wB,EAAKivB,EAAYP,GACpE,OAAO8B,EAAqBh0B,KAAMwD,EAAKivB,EAAYP,GAAU,EAC/D,EA+CAhiB,EAAO9N,UAAUhB,MAAQ,SAAgB6wB,EAAQ9xB,EAAQ2E,EAAQotB,GAE/D,QAAexnB,IAAXvK,EACF+xB,EAAW,OACXptB,EAAS9E,KAAK8E,OACd3E,EAAS,OAEJ,QAAeuK,IAAX5F,GAA0C,iBAAX3E,EACxC+xB,EAAW/xB,EACX2E,EAAS9E,KAAK8E,OACd3E,EAAS,MAEJ,KAAIuM,SAASvM,GAUlB,MAAM,IAAI0L,MACR,2EAVF1L,KAAoB,EAChBuM,SAAS5H,IACXA,KAAoB,OACH4F,IAAbwnB,IAAwBA,EAAW,UAEvCA,EAAWptB,EACXA,OAAS4F,EAMb,CAEA,IAAIkqB,EAAY50B,KAAK8E,OAAS3E,EAG9B,SAFeuK,IAAX5F,GAAwBA,EAAS8vB,KAAW9vB,EAAS8vB,GAEpD3C,EAAOntB,OAAS,IAAMA,EAAS,GAAK3E,EAAS,IAAOA,EAASH,KAAK8E,OACrE,MAAM,IAAI6sB,WAAW,0CAGlBO,IAAUA,EAAW,QAG1B,IADA,IAAIiB,GAAc,IAEhB,OAAQjB,GACN,IAAK,MACH,OAAOyC,EAAS30B,KAAMiyB,EAAQ9xB,EAAQ2E,GAExC,IAAK,OACL,IAAK,QACH,OAAOkwB,EAAUh1B,KAAMiyB,EAAQ9xB,EAAQ2E,GAEzC,IAAK,QACH,OAAOowB,EAAWl1B,KAAMiyB,EAAQ9xB,EAAQ2E,GAE1C,IAAK,SACL,IAAK,SACH,OAAOuwB,EAAYr1B,KAAMiyB,EAAQ9xB,EAAQ2E,GAE3C,IAAK,SAEH,OAAOwwB,EAAYt1B,KAAMiyB,EAAQ9xB,EAAQ2E,GAE3C,IAAK,OACL,IAAK,QACL,IAAK,UACL,IAAK,WACH,OAAOywB,EAAUv1B,KAAMiyB,EAAQ9xB,EAAQ2E,GAEzC,QACE,GAAIquB,EAAa,MAAM,IAAI3jB,UAAU,qBAAuB0iB,GAC5DA,GAAY,GAAKA,GAAUlvB,cAC3BmwB,GAAc,EAGtB,EAEAjjB,EAAO9N,UAAUyL,OAAS,WACxB,MAAO,CACL3K,KAAM,SACNqE,KAAMlE,MAAMjB,UAAUW,MAAMD,KAAK9C,KAAKg4B,MAAQh4B,KAAM,GAExD,EAsFA,IAAIq2B,EAAuB,KAoB3B,SAAS3C,EAAY9B,EAAK2B,EAAOvP,GAC/B,IAAItd,EAAM,GACVsd,EAAM9iB,KAAK6Z,IAAI6W,EAAI9sB,OAAQkf,GAE3B,IAAK,IAAInjB,EAAI0yB,EAAO1yB,EAAImjB,IAAOnjB,EAC7B6F,GAAO+D,OAAO6rB,aAAsB,IAAT1E,EAAI/wB,IAEjC,OAAO6F,CACT,CAEA,SAASitB,EAAa/B,EAAK2B,EAAOvP,GAChC,IAAItd,EAAM,GACVsd,EAAM9iB,KAAK6Z,IAAI6W,EAAI9sB,OAAQkf,GAE3B,IAAK,IAAInjB,EAAI0yB,EAAO1yB,EAAImjB,IAAOnjB,EAC7B6F,GAAO+D,OAAO6rB,aAAa1E,EAAI/wB,IAEjC,OAAO6F,CACT,CAEA,SAAS8sB,EAAU5B,EAAK2B,EAAOvP,GAC7B,IAAI/e,EAAM2sB,EAAI9sB,SAETyuB,GAASA,EAAQ,KAAGA,EAAQ,KAC5BvP,GAAOA,EAAM,GAAKA,EAAM/e,KAAK+e,EAAM/e,GAGxC,IADA,IAAIgzB,EAAM,GACDp3B,EAAI0yB,EAAO1yB,EAAImjB,IAAOnjB,EAC7Bo3B,GAAOC,EAAMtG,EAAI/wB,IAEnB,OAAOo3B,CACT,CAEA,SAASpE,EAAcjC,EAAK2B,EAAOvP,GAGjC,IAFA,IAAIhJ,EAAQ4W,EAAI7uB,MAAMwwB,EAAOvP,GACzByC,EAAM,GACD5lB,EAAI,EAAGA,EAAIma,EAAMlW,OAAQjE,GAAK,EACrC4lB,GAAOhc,OAAO6rB,aAAatb,EAAMna,GAAqB,IAAfma,EAAMna,EAAI,IAEnD,OAAO4lB,CACT,CAgCA,SAAS0R,EAAah4B,EAAQi4B,EAAKtzB,GACjC,GAAK3E,EAAS,GAAO,GAAKA,EAAS,EAAG,MAAM,IAAIwxB,WAAW,sBAC3D,GAAIxxB,EAASi4B,EAAMtzB,EAAQ,MAAM,IAAI6sB,WAAW,wCAClD,CA4KA,SAAS0G,EAAUzG,EAAKvwB,EAAOlB,EAAQi4B,EAAKT,EAAK5c,GAC/C,IAAK7K,EAAO3M,SAASquB,GAAM,MAAM,IAAIpiB,UAAU,+CAC/C,GAAInO,EAAQs2B,GAAOt2B,EAAQ0Z,EAAK,MAAM,IAAI4W,WAAW,qCACrD,GAAIxxB,EAASi4B,EAAMxG,EAAI9sB,OAAQ,MAAM,IAAI6sB,WAAW,qBACtD,CAwLA,SAAS2G,EAAc1G,EAAKvwB,EAAOlB,EAAQi4B,EAAKT,EAAK5c,GACnD,GAAI5a,EAASi4B,EAAMxG,EAAI9sB,OAAQ,MAAM,IAAI6sB,WAAW,sBACpD,GAAIxxB,EAAS,EAAG,MAAM,IAAIwxB,WAAW,qBACvC,CAEA,SAAS4G,EAAY3G,EAAKvwB,EAAOlB,EAAQq4B,EAAcC,GAOrD,OANAp3B,GAASA,EACTlB,KAAoB,EACfs4B,GACHH,EAAa1G,EAAKvwB,EAAOlB,EAAQ,GAEnCqxB,EAAQpwB,MAAMwwB,EAAKvwB,EAAOlB,EAAQq4B,EAAc,GAAI,GAC7Cr4B,EAAS,CAClB,CAUA,SAASu4B,EAAa9G,EAAKvwB,EAAOlB,EAAQq4B,EAAcC,GAOtD,OANAp3B,GAASA,EACTlB,KAAoB,EACfs4B,GACHH,EAAa1G,EAAKvwB,EAAOlB,EAAQ,GAEnCqxB,EAAQpwB,MAAMwwB,EAAKvwB,EAAOlB,EAAQq4B,EAAc,GAAI,GAC7Cr4B,EAAS,CAClB,CAxaA+P,EAAO9N,UAAUW,MAAQ,SAAgBwwB,EAAOvP,GAC9C,IAAI/e,EAAMjF,KAAK8E,QACfyuB,IAAUA,GAGE,GACVA,GAAStuB,GACG,IAAGsuB,EAAQ,GACdA,EAAQtuB,IACjBsuB,EAAQtuB,IANV+e,OAActZ,IAARsZ,EAAoB/e,IAAQ+e,GASxB,GACRA,GAAO/e,GACG,IAAG+e,EAAM,GACVA,EAAM/e,IACf+e,EAAM/e,GAGJ+e,EAAMuP,IAAOvP,EAAMuP,GAEvB,IAAIoF,EAAS34B,KAAK44B,SAASrF,EAAOvP,GAGlC,OADA2U,EAAO9G,UAAY3hB,EAAO9N,UACnBu2B,CACT,EAUAzoB,EAAO9N,UAAUy2B,WAAa,SAAqB14B,EAAQ4jB,EAAY0U,GACrEt4B,KAAoB,EACpB4jB,KAA4B,EACvB0U,GAAUN,EAAYh4B,EAAQ4jB,EAAY/jB,KAAK8E,QAKpD,IAHA,IAAItB,EAAMxD,KAAKG,GACX24B,EAAM,EACNj4B,EAAI,IACCA,EAAIkjB,IAAe+U,GAAO,MACjCt1B,GAAOxD,KAAKG,EAASU,GAAKi4B,EAG5B,OAAOt1B,CACT,EAEA0M,EAAO9N,UAAU22B,WAAa,SAAqB54B,EAAQ4jB,EAAY0U,GACrEt4B,KAAoB,EACpB4jB,KAA4B,EACvB0U,GACHN,EAAYh4B,EAAQ4jB,EAAY/jB,KAAK8E,QAKvC,IAFA,IAAItB,EAAMxD,KAAKG,IAAW4jB,GACtB+U,EAAM,EACH/U,EAAa,IAAM+U,GAAO,MAC/Bt1B,GAAOxD,KAAKG,IAAW4jB,GAAc+U,EAGvC,OAAOt1B,CACT,EAEA0M,EAAO9N,UAAU42B,UAAY,SAAoB74B,EAAQs4B,GAGvD,OAFAt4B,KAAoB,EACfs4B,GAAUN,EAAYh4B,EAAQ,EAAGH,KAAK8E,QACpC9E,KAAKG,EACd,EAEA+P,EAAO9N,UAAU62B,aAAe,SAAuB94B,EAAQs4B,GAG7D,OAFAt4B,KAAoB,EACfs4B,GAAUN,EAAYh4B,EAAQ,EAAGH,KAAK8E,QACpC9E,KAAKG,GAAWH,KAAKG,EAAS,IAAM,CAC7C,EAEA+P,EAAO9N,UAAUmyB,aAAe,SAAuBp0B,EAAQs4B,GAG7D,OAFAt4B,KAAoB,EACfs4B,GAAUN,EAAYh4B,EAAQ,EAAGH,KAAK8E,QACnC9E,KAAKG,IAAW,EAAKH,KAAKG,EAAS,EAC7C,EAEA+P,EAAO9N,UAAU82B,aAAe,SAAuB/4B,EAAQs4B,GAI7D,OAHAt4B,KAAoB,EACfs4B,GAAUN,EAAYh4B,EAAQ,EAAGH,KAAK8E,SAElC9E,KAAKG,GACTH,KAAKG,EAAS,IAAM,EACpBH,KAAKG,EAAS,IAAM,IACD,SAAnBH,KAAKG,EAAS,EACrB,EAEA+P,EAAO9N,UAAU+2B,aAAe,SAAuBh5B,EAAQs4B,GAI7D,OAHAt4B,KAAoB,EACfs4B,GAAUN,EAAYh4B,EAAQ,EAAGH,KAAK8E,QAEpB,SAAf9E,KAAKG,IACTH,KAAKG,EAAS,IAAM,GACrBH,KAAKG,EAAS,IAAM,EACrBH,KAAKG,EAAS,GAClB,EAEA+P,EAAO9N,UAAUg3B,UAAY,SAAoBj5B,EAAQ4jB,EAAY0U,GACnEt4B,KAAoB,EACpB4jB,KAA4B,EACvB0U,GAAUN,EAAYh4B,EAAQ4jB,EAAY/jB,KAAK8E,QAKpD,IAHA,IAAItB,EAAMxD,KAAKG,GACX24B,EAAM,EACNj4B,EAAI,IACCA,EAAIkjB,IAAe+U,GAAO,MACjCt1B,GAAOxD,KAAKG,EAASU,GAAKi4B,EAM5B,OAFIt1B,IAFJs1B,GAAO,OAESt1B,GAAOtC,KAAKC,IAAI,EAAG,EAAI4iB,IAEhCvgB,CACT,EAEA0M,EAAO9N,UAAUi3B,UAAY,SAAoBl5B,EAAQ4jB,EAAY0U,GACnEt4B,KAAoB,EACpB4jB,KAA4B,EACvB0U,GAAUN,EAAYh4B,EAAQ4jB,EAAY/jB,KAAK8E,QAKpD,IAHA,IAAIjE,EAAIkjB,EACJ+U,EAAM,EACNt1B,EAAMxD,KAAKG,IAAWU,GACnBA,EAAI,IAAMi4B,GAAO,MACtBt1B,GAAOxD,KAAKG,IAAWU,GAAKi4B,EAM9B,OAFIt1B,IAFJs1B,GAAO,OAESt1B,GAAOtC,KAAKC,IAAI,EAAG,EAAI4iB,IAEhCvgB,CACT,EAEA0M,EAAO9N,UAAUk3B,SAAW,SAAmBn5B,EAAQs4B,GAGrD,OAFAt4B,KAAoB,EACfs4B,GAAUN,EAAYh4B,EAAQ,EAAGH,KAAK8E,QACtB,IAAf9E,KAAKG,IAC0B,GAA5B,IAAOH,KAAKG,GAAU,GADKH,KAAKG,EAE3C,EAEA+P,EAAO9N,UAAUm3B,YAAc,SAAsBp5B,EAAQs4B,GAC3Dt4B,KAAoB,EACfs4B,GAAUN,EAAYh4B,EAAQ,EAAGH,KAAK8E,QAC3C,IAAItB,EAAMxD,KAAKG,GAAWH,KAAKG,EAAS,IAAM,EAC9C,OAAc,MAANqD,EAAsB,WAANA,EAAmBA,CAC7C,EAEA0M,EAAO9N,UAAUo3B,YAAc,SAAsBr5B,EAAQs4B,GAC3Dt4B,KAAoB,EACfs4B,GAAUN,EAAYh4B,EAAQ,EAAGH,KAAK8E,QAC3C,IAAItB,EAAMxD,KAAKG,EAAS,GAAMH,KAAKG,IAAW,EAC9C,OAAc,MAANqD,EAAsB,WAANA,EAAmBA,CAC7C,EAEA0M,EAAO9N,UAAUq3B,YAAc,SAAsBt5B,EAAQs4B,GAI3D,OAHAt4B,KAAoB,EACfs4B,GAAUN,EAAYh4B,EAAQ,EAAGH,KAAK8E,QAEnC9E,KAAKG,GACVH,KAAKG,EAAS,IAAM,EACpBH,KAAKG,EAAS,IAAM,GACpBH,KAAKG,EAAS,IAAM,EACzB,EAEA+P,EAAO9N,UAAUs3B,YAAc,SAAsBv5B,EAAQs4B,GAI3D,OAHAt4B,KAAoB,EACfs4B,GAAUN,EAAYh4B,EAAQ,EAAGH,KAAK8E,QAEnC9E,KAAKG,IAAW,GACrBH,KAAKG,EAAS,IAAM,GACpBH,KAAKG,EAAS,IAAM,EACpBH,KAAKG,EAAS,EACnB,EAEA+P,EAAO9N,UAAUu3B,YAAc,SAAsBx5B,EAAQs4B,GAG3D,OAFAt4B,KAAoB,EACfs4B,GAAUN,EAAYh4B,EAAQ,EAAGH,KAAK8E,QACpC0sB,EAAQvxB,KAAKD,KAAMG,GAAQ,EAAM,GAAI,EAC9C,EAEA+P,EAAO9N,UAAUw3B,YAAc,SAAsBz5B,EAAQs4B,GAG3D,OAFAt4B,KAAoB,EACfs4B,GAAUN,EAAYh4B,EAAQ,EAAGH,KAAK8E,QACpC0sB,EAAQvxB,KAAKD,KAAMG,GAAQ,EAAO,GAAI,EAC/C,EAEA+P,EAAO9N,UAAUy3B,aAAe,SAAuB15B,EAAQs4B,GAG7D,OAFAt4B,KAAoB,EACfs4B,GAAUN,EAAYh4B,EAAQ,EAAGH,KAAK8E,QACpC0sB,EAAQvxB,KAAKD,KAAMG,GAAQ,EAAM,GAAI,EAC9C,EAEA+P,EAAO9N,UAAU03B,aAAe,SAAuB35B,EAAQs4B,GAG7D,OAFAt4B,KAAoB,EACfs4B,GAAUN,EAAYh4B,EAAQ,EAAGH,KAAK8E,QACpC0sB,EAAQvxB,KAAKD,KAAMG,GAAQ,EAAO,GAAI,EAC/C,EAQA+P,EAAO9N,UAAU23B,YAAc,SAAsB14B,EAAOlB,EAAQ4jB,EAAY0U,GAC9Ep3B,GAASA,EACTlB,KAAoB,EACpB4jB,KAA4B,EACvB0U,GAEHJ,EAASr4B,KAAMqB,EAAOlB,EAAQ4jB,EADf7iB,KAAKC,IAAI,EAAG,EAAI4iB,GAAc,EACO,GAGtD,IAAI+U,EAAM,EACNj4B,EAAI,EAER,IADAb,KAAKG,GAAkB,IAARkB,IACNR,EAAIkjB,IAAe+U,GAAO,MACjC94B,KAAKG,EAASU,GAAMQ,EAAQy3B,EAAO,IAGrC,OAAO34B,EAAS4jB,CAClB,EAEA7T,EAAO9N,UAAU43B,YAAc,SAAsB34B,EAAOlB,EAAQ4jB,EAAY0U,GAC9Ep3B,GAASA,EACTlB,KAAoB,EACpB4jB,KAA4B,EACvB0U,GAEHJ,EAASr4B,KAAMqB,EAAOlB,EAAQ4jB,EADf7iB,KAAKC,IAAI,EAAG,EAAI4iB,GAAc,EACO,GAGtD,IAAIljB,EAAIkjB,EAAa,EACjB+U,EAAM,EAEV,IADA94B,KAAKG,EAASU,GAAa,IAARQ,IACVR,GAAK,IAAMi4B,GAAO,MACzB94B,KAAKG,EAASU,GAAMQ,EAAQy3B,EAAO,IAGrC,OAAO34B,EAAS4jB,CAClB,EAEA7T,EAAO9N,UAAU63B,WAAa,SAAqB54B,EAAOlB,EAAQs4B,GAKhE,OAJAp3B,GAASA,EACTlB,KAAoB,EACfs4B,GAAUJ,EAASr4B,KAAMqB,EAAOlB,EAAQ,EAAG,IAAM,GACtDH,KAAKG,GAAmB,IAARkB,EACTlB,EAAS,CAClB,EAEA+P,EAAO9N,UAAU83B,cAAgB,SAAwB74B,EAAOlB,EAAQs4B,GAMtE,OALAp3B,GAASA,EACTlB,KAAoB,EACfs4B,GAAUJ,EAASr4B,KAAMqB,EAAOlB,EAAQ,EAAG,MAAQ,GACxDH,KAAKG,GAAmB,IAARkB,EAChBrB,KAAKG,EAAS,GAAMkB,IAAU,EACvBlB,EAAS,CAClB,EAEA+P,EAAO9N,UAAU+3B,cAAgB,SAAwB94B,EAAOlB,EAAQs4B,GAMtE,OALAp3B,GAASA,EACTlB,KAAoB,EACfs4B,GAAUJ,EAASr4B,KAAMqB,EAAOlB,EAAQ,EAAG,MAAQ,GACxDH,KAAKG,GAAWkB,IAAU,EAC1BrB,KAAKG,EAAS,GAAc,IAARkB,EACblB,EAAS,CAClB,EAEA+P,EAAO9N,UAAUg4B,cAAgB,SAAwB/4B,EAAOlB,EAAQs4B,GAQtE,OAPAp3B,GAASA,EACTlB,KAAoB,EACfs4B,GAAUJ,EAASr4B,KAAMqB,EAAOlB,EAAQ,EAAG,WAAY,GAC5DH,KAAKG,EAAS,GAAMkB,IAAU,GAC9BrB,KAAKG,EAAS,GAAMkB,IAAU,GAC9BrB,KAAKG,EAAS,GAAMkB,IAAU,EAC9BrB,KAAKG,GAAmB,IAARkB,EACTlB,EAAS,CAClB,EAEA+P,EAAO9N,UAAUi4B,cAAgB,SAAwBh5B,EAAOlB,EAAQs4B,GAQtE,OAPAp3B,GAASA,EACTlB,KAAoB,EACfs4B,GAAUJ,EAASr4B,KAAMqB,EAAOlB,EAAQ,EAAG,WAAY,GAC5DH,KAAKG,GAAWkB,IAAU,GAC1BrB,KAAKG,EAAS,GAAMkB,IAAU,GAC9BrB,KAAKG,EAAS,GAAMkB,IAAU,EAC9BrB,KAAKG,EAAS,GAAc,IAARkB,EACblB,EAAS,CAClB,EAEA+P,EAAO9N,UAAUk4B,WAAa,SAAqBj5B,EAAOlB,EAAQ4jB,EAAY0U,GAG5E,GAFAp3B,GAASA,EACTlB,KAAoB,GACfs4B,EAAU,CACb,IAAI8B,EAAQr5B,KAAKC,IAAI,EAAI,EAAI4iB,EAAc,GAE3CsU,EAASr4B,KAAMqB,EAAOlB,EAAQ4jB,EAAYwW,EAAQ,GAAIA,EACxD,CAEA,IAAI15B,EAAI,EACJi4B,EAAM,EACN0B,EAAM,EAEV,IADAx6B,KAAKG,GAAkB,IAARkB,IACNR,EAAIkjB,IAAe+U,GAAO,MAC7Bz3B,EAAQ,GAAa,IAARm5B,GAAsC,IAAzBx6B,KAAKG,EAASU,EAAI,KAC9C25B,EAAM,GAERx6B,KAAKG,EAASU,IAAOQ,EAAQy3B,EAAQ,GAAK0B,EAAM,IAGlD,OAAOr6B,EAAS4jB,CAClB,EAEA7T,EAAO9N,UAAUq4B,WAAa,SAAqBp5B,EAAOlB,EAAQ4jB,EAAY0U,GAG5E,GAFAp3B,GAASA,EACTlB,KAAoB,GACfs4B,EAAU,CACb,IAAI8B,EAAQr5B,KAAKC,IAAI,EAAI,EAAI4iB,EAAc,GAE3CsU,EAASr4B,KAAMqB,EAAOlB,EAAQ4jB,EAAYwW,EAAQ,GAAIA,EACxD,CAEA,IAAI15B,EAAIkjB,EAAa,EACjB+U,EAAM,EACN0B,EAAM,EAEV,IADAx6B,KAAKG,EAASU,GAAa,IAARQ,IACVR,GAAK,IAAMi4B,GAAO,MACrBz3B,EAAQ,GAAa,IAARm5B,GAAsC,IAAzBx6B,KAAKG,EAASU,EAAI,KAC9C25B,EAAM,GAERx6B,KAAKG,EAASU,IAAOQ,EAAQy3B,EAAQ,GAAK0B,EAAM,IAGlD,OAAOr6B,EAAS4jB,CAClB,EAEA7T,EAAO9N,UAAUs4B,UAAY,SAAoBr5B,EAAOlB,EAAQs4B,GAM9D,OALAp3B,GAASA,EACTlB,KAAoB,EACfs4B,GAAUJ,EAASr4B,KAAMqB,EAAOlB,EAAQ,EAAG,KAAO,KACnDkB,EAAQ,IAAGA,EAAQ,IAAOA,EAAQ,GACtCrB,KAAKG,GAAmB,IAARkB,EACTlB,EAAS,CAClB,EAEA+P,EAAO9N,UAAUu4B,aAAe,SAAuBt5B,EAAOlB,EAAQs4B,GAMpE,OALAp3B,GAASA,EACTlB,KAAoB,EACfs4B,GAAUJ,EAASr4B,KAAMqB,EAAOlB,EAAQ,EAAG,OAAS,OACzDH,KAAKG,GAAmB,IAARkB,EAChBrB,KAAKG,EAAS,GAAMkB,IAAU,EACvBlB,EAAS,CAClB,EAEA+P,EAAO9N,UAAUw4B,aAAe,SAAuBv5B,EAAOlB,EAAQs4B,GAMpE,OALAp3B,GAASA,EACTlB,KAAoB,EACfs4B,GAAUJ,EAASr4B,KAAMqB,EAAOlB,EAAQ,EAAG,OAAS,OACzDH,KAAKG,GAAWkB,IAAU,EAC1BrB,KAAKG,EAAS,GAAc,IAARkB,EACblB,EAAS,CAClB,EAEA+P,EAAO9N,UAAUy4B,aAAe,SAAuBx5B,EAAOlB,EAAQs4B,GAQpE,OAPAp3B,GAASA,EACTlB,KAAoB,EACfs4B,GAAUJ,EAASr4B,KAAMqB,EAAOlB,EAAQ,EAAG,YAAa,YAC7DH,KAAKG,GAAmB,IAARkB,EAChBrB,KAAKG,EAAS,GAAMkB,IAAU,EAC9BrB,KAAKG,EAAS,GAAMkB,IAAU,GAC9BrB,KAAKG,EAAS,GAAMkB,IAAU,GACvBlB,EAAS,CAClB,EAEA+P,EAAO9N,UAAU04B,aAAe,SAAuBz5B,EAAOlB,EAAQs4B,GASpE,OARAp3B,GAASA,EACTlB,KAAoB,EACfs4B,GAAUJ,EAASr4B,KAAMqB,EAAOlB,EAAQ,EAAG,YAAa,YACzDkB,EAAQ,IAAGA,EAAQ,WAAaA,EAAQ,GAC5CrB,KAAKG,GAAWkB,IAAU,GAC1BrB,KAAKG,EAAS,GAAMkB,IAAU,GAC9BrB,KAAKG,EAAS,GAAMkB,IAAU,EAC9BrB,KAAKG,EAAS,GAAc,IAARkB,EACblB,EAAS,CAClB,EAiBA+P,EAAO9N,UAAU24B,aAAe,SAAuB15B,EAAOlB,EAAQs4B,GACpE,OAAOF,EAAWv4B,KAAMqB,EAAOlB,GAAQ,EAAMs4B,EAC/C,EAEAvoB,EAAO9N,UAAU44B,aAAe,SAAuB35B,EAAOlB,EAAQs4B,GACpE,OAAOF,EAAWv4B,KAAMqB,EAAOlB,GAAQ,EAAOs4B,EAChD,EAYAvoB,EAAO9N,UAAU64B,cAAgB,SAAwB55B,EAAOlB,EAAQs4B,GACtE,OAAOC,EAAY14B,KAAMqB,EAAOlB,GAAQ,EAAMs4B,EAChD,EAEAvoB,EAAO9N,UAAU84B,cAAgB,SAAwB75B,EAAOlB,EAAQs4B,GACtE,OAAOC,EAAY14B,KAAMqB,EAAOlB,GAAQ,EAAOs4B,EACjD,EAGAvoB,EAAO9N,UAAUywB,KAAO,SAAe9lB,EAAQouB,EAAa5H,EAAOvP,GACjE,IAAK9T,EAAO3M,SAASwJ,GAAS,MAAM,IAAIyC,UAAU,+BAQlD,GAPK+jB,IAAOA,EAAQ,GACfvP,GAAe,IAARA,IAAWA,EAAMhkB,KAAK8E,QAC9Bq2B,GAAepuB,EAAOjI,SAAQq2B,EAAcpuB,EAAOjI,QAClDq2B,IAAaA,EAAc,GAC5BnX,EAAM,GAAKA,EAAMuP,IAAOvP,EAAMuP,GAG9BvP,IAAQuP,EAAO,OAAO,EAC1B,GAAsB,IAAlBxmB,EAAOjI,QAAgC,IAAhB9E,KAAK8E,OAAc,OAAO,EAGrD,GAAIq2B,EAAc,EAChB,MAAM,IAAIxJ,WAAW,6BAEvB,GAAI4B,EAAQ,GAAKA,GAASvzB,KAAK8E,OAAQ,MAAM,IAAI6sB,WAAW,sBAC5D,GAAI3N,EAAM,EAAG,MAAM,IAAI2N,WAAW,2BAG9B3N,EAAMhkB,KAAK8E,SAAQkf,EAAMhkB,KAAK8E,QAC9BiI,EAAOjI,OAASq2B,EAAcnX,EAAMuP,IACtCvP,EAAMjX,EAAOjI,OAASq2B,EAAc5H,GAGtC,IAAItuB,EAAM+e,EAAMuP,EAEhB,GAAIvzB,OAAS+M,GAAqD,mBAApCjH,WAAW1D,UAAUg5B,WAEjDp7B,KAAKo7B,WAAWD,EAAa5H,EAAOvP,QAC/B,GAAIhkB,OAAS+M,GAAUwmB,EAAQ4H,GAAeA,EAAcnX,EAEjE,IAAK,IAAInjB,EAAIoE,EAAM,EAAGpE,GAAK,IAAKA,EAC9BkM,EAAOlM,EAAIs6B,GAAen7B,KAAKa,EAAI0yB,QAGrCztB,WAAW1D,UAAUwJ,IAAI9I,KACvBiK,EACA/M,KAAK44B,SAASrF,EAAOvP,GACrBmX,GAIJ,OAAOl2B,CACT,EAMAiL,EAAO9N,UAAU00B,KAAO,SAAetzB,EAAK+vB,EAAOvP,EAAKkO,GAEtD,GAAmB,iBAAR1uB,EAAkB,CAS3B,GARqB,iBAAV+vB,GACTrB,EAAWqB,EACXA,EAAQ,EACRvP,EAAMhkB,KAAK8E,QACa,iBAARkf,IAChBkO,EAAWlO,EACXA,EAAMhkB,KAAK8E,aAEI4F,IAAbwnB,GAA8C,iBAAbA,EACnC,MAAM,IAAI1iB,UAAU,6BAEtB,GAAwB,iBAAb0iB,IAA0BhiB,EAAOiiB,WAAWD,GACrD,MAAM,IAAI1iB,UAAU,qBAAuB0iB,GAE7C,GAAmB,IAAf1uB,EAAIsB,OAAc,CACpB,IAAIyI,EAAO/J,EAAIkG,WAAW,IACR,SAAbwoB,GAAuB3kB,EAAO,KAClB,WAAb2kB,KAEF1uB,EAAM+J,EAEV,CACF,KAA0B,iBAAR/J,IAChBA,GAAY,KAId,GAAI+vB,EAAQ,GAAKvzB,KAAK8E,OAASyuB,GAASvzB,KAAK8E,OAASkf,EACpD,MAAM,IAAI2N,WAAW,sBAGvB,GAAI3N,GAAOuP,EACT,OAAOvzB,KAQT,IAAIa,EACJ,GANA0yB,KAAkB,EAClBvP,OAActZ,IAARsZ,EAAoBhkB,KAAK8E,OAASkf,IAAQ,EAE3CxgB,IAAKA,EAAM,GAGG,iBAARA,EACT,IAAK3C,EAAI0yB,EAAO1yB,EAAImjB,IAAOnjB,EACzBb,KAAKa,GAAK2C,MAEP,CACL,IAAIwX,EAAQ9K,EAAO3M,SAASC,GACxBA,EACA0M,EAAOvB,KAAKnL,EAAK0uB,GACjBjtB,EAAM+V,EAAMlW,OAChB,GAAY,IAARG,EACF,MAAM,IAAIuK,UAAU,cAAgBhM,EAClC,qCAEJ,IAAK3C,EAAI,EAAGA,EAAImjB,EAAMuP,IAAS1yB,EAC7Bb,KAAKa,EAAI0yB,GAASvY,EAAMna,EAAIoE,EAEhC,CAEA,OAAOjF,IACT,EAKA,IAAIq7B,EAAoB,oBAgBxB,SAASnD,EAAOnE,GACd,OAAIA,EAAI,GAAW,IAAMA,EAAE7xB,SAAS,IAC7B6xB,EAAE7xB,SAAS,GACpB,CAEA,SAASkxB,EAAanB,EAAQuD,GAE5B,IAAIU,EADJV,EAAQA,GAASv0B,IAMjB,IAJA,IAAI6D,EAASmtB,EAAOntB,OAChBw2B,EAAgB,KAChBtgB,EAAQ,GAEHna,EAAI,EAAGA,EAAIiE,IAAUjE,EAAG,CAI/B,IAHAq1B,EAAYjE,EAAOvoB,WAAW7I,IAGd,OAAUq1B,EAAY,MAAQ,CAE5C,IAAKoF,EAAe,CAElB,GAAIpF,EAAY,MAAQ,EAEjBV,GAAS,IAAM,GAAGxa,EAAMtT,KAAK,IAAM,IAAM,KAC9C,QACF,CAAO,GAAI7G,EAAI,IAAMiE,EAAQ,EAEtB0wB,GAAS,IAAM,GAAGxa,EAAMtT,KAAK,IAAM,IAAM,KAC9C,QACF,CAGA4zB,EAAgBpF,EAEhB,QACF,CAGA,GAAIA,EAAY,MAAQ,EACjBV,GAAS,IAAM,GAAGxa,EAAMtT,KAAK,IAAM,IAAM,KAC9C4zB,EAAgBpF,EAChB,QACF,CAGAA,EAAkE,OAArDoF,EAAgB,OAAU,GAAKpF,EAAY,MAC1D,MAAWoF,IAEJ9F,GAAS,IAAM,GAAGxa,EAAMtT,KAAK,IAAM,IAAM,KAMhD,GAHA4zB,EAAgB,KAGZpF,EAAY,IAAM,CACpB,IAAKV,GAAS,GAAK,EAAG,MACtBxa,EAAMtT,KAAKwuB,EACb,MAAO,GAAIA,EAAY,KAAO,CAC5B,IAAKV,GAAS,GAAK,EAAG,MACtBxa,EAAMtT,KACJwuB,GAAa,EAAM,IACP,GAAZA,EAAmB,IAEvB,MAAO,GAAIA,EAAY,MAAS,CAC9B,IAAKV,GAAS,GAAK,EAAG,MACtBxa,EAAMtT,KACJwuB,GAAa,GAAM,IACnBA,GAAa,EAAM,GAAO,IACd,GAAZA,EAAmB,IAEvB,KAAO,MAAIA,EAAY,SASrB,MAAM,IAAIrqB,MAAM,sBARhB,IAAK2pB,GAAS,GAAK,EAAG,MACtBxa,EAAMtT,KACJwuB,GAAa,GAAO,IACpBA,GAAa,GAAM,GAAO,IAC1BA,GAAa,EAAM,GAAO,IACd,GAAZA,EAAmB,IAIvB,CACF,CAEA,OAAOlb,CACT,CA2BA,SAASqY,EAAexwB,GACtB,OAAOyuB,EAAOiK,YA7HhB,SAAsB14B,GAMpB,IAFAA,GAFAA,EAAMA,EAAIoJ,MAAM,KAAK,IAEX3C,OAAOC,QAAQ8xB,EAAmB,KAEpCv2B,OAAS,EAAG,MAAO,GAE3B,KAAOjC,EAAIiC,OAAS,GAAM,GACxBjC,GAAY,IAEd,OAAOA,CACT,CAiH4B24B,CAAY34B,GACxC,CAEA,SAASoyB,EAAYwG,EAAKC,EAAKv7B,EAAQ2E,GACrC,IAAK,IAAIjE,EAAI,EAAGA,EAAIiE,KACbjE,EAAIV,GAAUu7B,EAAI52B,QAAYjE,GAAK46B,EAAI32B,UADhBjE,EAE5B66B,EAAI76B,EAAIV,GAAUs7B,EAAI56B,GAExB,OAAOA,CACT,CAKA,SAAS0xB,EAAY5tB,EAAKzB,GACxB,OAAOyB,aAAezB,GACZ,MAAPyB,GAAkC,MAAnBA,EAAIlB,aAA+C,MAAxBkB,EAAIlB,YAAYgD,MACzD9B,EAAIlB,YAAYgD,OAASvD,EAAKuD,IACpC,CACA,SAASqsB,EAAanuB,GAEpB,OAAOA,GAAQA,CACjB,C,2BC9uDA/E,EAAQmkB,WAuCR,SAAqB4X,GACnB,IAAIC,EAAOC,EAAQF,GACfG,EAAWF,EAAK,GAChBG,EAAkBH,EAAK,GAC3B,OAAuC,GAA9BE,EAAWC,GAAuB,EAAKA,CAClD,EA3CAn8B,EAAQ27B,YAiDR,SAAsBI,GACpB,IAAIK,EAcAn7B,EAbA+6B,EAAOC,EAAQF,GACfG,EAAWF,EAAK,GAChBG,EAAkBH,EAAK,GAEvB9wB,EAAM,IAAImxB,EAVhB,SAAsBN,EAAKG,EAAUC,GACnC,OAAuC,GAA9BD,EAAWC,GAAuB,EAAKA,CAClD,CAQoBG,CAAYP,EAAKG,EAAUC,IAEzCI,EAAU,EAGVl3B,EAAM82B,EAAkB,EACxBD,EAAW,EACXA,EAGJ,IAAKj7B,EAAI,EAAGA,EAAIoE,EAAKpE,GAAK,EACxBm7B,EACGI,EAAUT,EAAIjyB,WAAW7I,KAAO,GAChCu7B,EAAUT,EAAIjyB,WAAW7I,EAAI,KAAO,GACpCu7B,EAAUT,EAAIjyB,WAAW7I,EAAI,KAAO,EACrCu7B,EAAUT,EAAIjyB,WAAW7I,EAAI,IAC/BiK,EAAIqxB,KAAcH,GAAO,GAAM,IAC/BlxB,EAAIqxB,KAAcH,GAAO,EAAK,IAC9BlxB,EAAIqxB,KAAmB,IAANH,EAmBnB,OAhBwB,IAApBD,IACFC,EACGI,EAAUT,EAAIjyB,WAAW7I,KAAO,EAChCu7B,EAAUT,EAAIjyB,WAAW7I,EAAI,KAAO,EACvCiK,EAAIqxB,KAAmB,IAANH,GAGK,IAApBD,IACFC,EACGI,EAAUT,EAAIjyB,WAAW7I,KAAO,GAChCu7B,EAAUT,EAAIjyB,WAAW7I,EAAI,KAAO,EACpCu7B,EAAUT,EAAIjyB,WAAW7I,EAAI,KAAO,EACvCiK,EAAIqxB,KAAcH,GAAO,EAAK,IAC9BlxB,EAAIqxB,KAAmB,IAANH,GAGZlxB,CACT,EA5FAlL,EAAQg2B,cAkHR,SAAwByG,GAQtB,IAPA,IAAIL,EACA/2B,EAAMo3B,EAAMv3B,OACZw3B,EAAar3B,EAAM,EACnBs3B,EAAQ,GACRC,EAAiB,MAGZ37B,EAAI,EAAG47B,EAAOx3B,EAAMq3B,EAAYz7B,EAAI47B,EAAM57B,GAAK27B,EACtDD,EAAM70B,KAAKg1B,EAAYL,EAAOx7B,EAAIA,EAAI27B,EAAkBC,EAAOA,EAAQ57B,EAAI27B,IAqB7E,OAjBmB,IAAfF,GACFN,EAAMK,EAAMp3B,EAAM,GAClBs3B,EAAM70B,KACJi1B,EAAOX,GAAO,GACdW,EAAQX,GAAO,EAAK,IACpB,OAEsB,IAAfM,IACTN,GAAOK,EAAMp3B,EAAM,IAAM,GAAKo3B,EAAMp3B,EAAM,GAC1Cs3B,EAAM70B,KACJi1B,EAAOX,GAAO,IACdW,EAAQX,GAAO,EAAK,IACpBW,EAAQX,GAAO,EAAK,IACpB,MAIGO,EAAM7tB,KAAK,GACpB,EA1IA,IALA,IAAIiuB,EAAS,GACTP,EAAY,GACZH,EAA4B,oBAAfn2B,WAA6BA,WAAazC,MAEvDkK,EAAO,mEACF1M,EAAI,EAAsBA,EAAb0M,KAAwB1M,EAC5C87B,EAAO97B,GAAK0M,EAAK1M,GACjBu7B,EAAU7uB,EAAK7D,WAAW7I,IAAMA,EAQlC,SAASg7B,EAASF,GAChB,IAAI12B,EAAM02B,EAAI72B,OAEd,GAAIG,EAAM,EAAI,EACZ,MAAM,IAAI4G,MAAM,kDAKlB,IAAIiwB,EAAWH,EAAI/wB,QAAQ,KAO3B,OANkB,IAAdkxB,IAAiBA,EAAW72B,GAMzB,CAAC62B,EAJcA,IAAa72B,EAC/B,EACA,EAAK62B,EAAW,EAGtB,CA4DA,SAASc,EAAiBC,GACxB,OAAOF,EAAOE,GAAO,GAAK,IACxBF,EAAOE,GAAO,GAAK,IACnBF,EAAOE,GAAO,EAAI,IAClBF,EAAa,GAANE,EACX,CAEA,SAASH,EAAaL,EAAO9I,EAAOvP,GAGlC,IAFA,IAAIgY,EACAc,EAAS,GACJj8B,EAAI0yB,EAAO1yB,EAAImjB,EAAKnjB,GAAK,EAChCm7B,GACIK,EAAMx7B,IAAM,GAAM,WAClBw7B,EAAMx7B,EAAI,IAAM,EAAK,QACP,IAAfw7B,EAAMx7B,EAAI,IACbi8B,EAAOp1B,KAAKk1B,EAAgBZ,IAE9B,OAAOc,EAAOpuB,KAAK,GACrB,CAlGA0tB,EAAU,IAAI1yB,WAAW,IAAM,GAC/B0yB,EAAU,IAAI1yB,WAAW,IAAM,E,GClB3BqzB,EAA2B,CAAC,EAGhC,SAASC,EAAoBC,GAE5B,IAAIC,EAAeH,EAAyBE,GAC5C,QAAqBvyB,IAAjBwyB,EACH,OAAOA,EAAat9B,QAGrB,IAAIC,EAASk9B,EAAyBE,GAAY,CAGjDr9B,QAAS,CAAC,GAOX,OAHAu9B,EAAoBF,GAAUp9B,EAAQA,EAAOD,QAASo9B,GAG/Cn9B,EAAOD,OACf,CCrBAo9B,EAAoBl8B,EAAI,CAAClB,EAASw9B,KACjC,IAAI,IAAIl4B,KAAOk4B,EACXJ,EAAoBK,EAAED,EAAYl4B,KAAS83B,EAAoBK,EAAEz9B,EAASsF,IAC5E/C,OAAO2H,eAAelK,EAASsF,EAAK,CAAEwG,YAAY,EAAMmM,IAAKulB,EAAWl4B,MCJ3E83B,EAAoBM,EAAI,WACvB,GAA0B,iBAAfh4B,WAAyB,OAAOA,WAC3C,IACC,OAAOtF,MAAQ,IAAIu9B,SAAS,cAAb,EAChB,CAAE,MAAOh9B,GACR,GAAsB,iBAAXiF,OAAqB,OAAOA,MACxC,CACA,CAPuB,GCAxBw3B,EAAoBK,EAAI,CAAC14B,EAAKsB,IAAU9D,OAAOC,UAAU4D,eAAelD,KAAK6B,EAAKsB,G,6DCW5E,MAAOu3B,EAaX/5B,WAAAA,CAAY+J,EAAc,MAExB,GAdO,KAAAiwB,KAAe,SAIf,KAAAC,KAAOF,EAAOG,UAEb,KAAAC,QAAgC,MAOxCpwB,EAASA,GAAU,CAAC,GACTqwB,SAAU,MAAM,IAAIhyB,MAAM,qCACvC,CAKA,UAAIiyB,GACF,OAAO99B,KAAK49B,OACd,CAMAG,SAAAA,CAAUD,GACR99B,KAAK49B,QAAUE,CACjB,CAOAE,UAAAA,GACE,MAAO,CAAE96B,KAAMlD,KAAKy9B,KACtB,CAMAv7B,QAAAA,GACE,MAAO,eAAelC,KAAK09B,OAC7B,CAQAjG,MAAAA,CAAOwG,EAAeC,GAAS,GAC7B,OAAIl+B,KAAKy9B,MAAQQ,EAAQR,IAE3B,CAUAU,KAAAA,GACE,MAAMlG,EAAMj4B,KAAKo+B,cAEjB,OADAp+B,KAAKq+B,OAAOpG,GACLA,CACT,CAMAoG,MAAAA,CAAOJ,GAEP,CAMUG,WAAAA,GACR,OAAO,IAAKp+B,KAAKyD,WACnB,EAtFe+5B,EAAAG,QAAU,EA6FrB,MAAgBW,UAAoBd,EAA1C/5B,WAAAA,G,oBACW,KAAAg6B,KAAe,aAgB1B,CAHEhG,MAAAA,CAAOwG,GACL,OAAOM,MAAM9G,OAAOwG,IAAYj+B,KAAKw+B,SAAS/G,OAAOwG,EAAQO,SAC/D,EClHI,SAAUC,EAAOC,EAAoB3vB,GACzC,IAAK2vB,EACH,MAAM,IAAI7yB,MAAMkD,EAEpB,CCZcwiB,EAAAA,IAAAA,QCDP,MACMoN,EAAUz9B,KAAAC,IAAA,EAAK,IACJD,KAAAC,IAAA,EAAK,ICGvB,MAAOy9B,EAiDXn7B,WAAAA,CAAYgD,EAAca,EAAa4pB,GA9C9B,KAAAwM,KAAOkB,EAAOjB,UAKb,KAAAkB,aAA+B,KAgBzC,KAAAC,YAAmB,KAUnB,KAAAC,WAAY,EAKZ,KAAAC,WAAwB,EAQxB,KAAAC,SAAqB,GAGnBj/B,KAAKyG,KAAOA,EACZzG,KAAKsH,OAASA,EACdtH,KAAKkxB,QAAUA,CACjB,CAEA,eAAIgO,GACF,OAAOl/B,KAAK6+B,YACd,CAEUM,cAAAA,CAAepwB,GACvB/O,KAAK6+B,aAAe9vB,EACH/O,KAAKo/B,WAAX,MAAPrwB,EAA+B/O,KACZ+O,EAAIswB,SAC7B,CAEAC,KAAAA,CAAM74B,EAAca,EAAa4pB,GAC/B,MAAMqO,EAAQ,IAAIX,EAAOn4B,EAAMa,EAAQ4pB,GAGvC,OAFAqO,EAAMJ,eAAen/B,MACrBA,KAAKi/B,SAASv3B,KAAK63B,GACZA,CACT,CAOA,aAAIF,GACF,OAAOr/B,KAAKo/B,UACd,EA7EeR,EAAAjB,QAAU,EAgFrB,MAAO6B,EAAb/7B,WAAAA,GAEE,KAAAg8B,UAAiB,KACR,KAAArtB,GAAKotB,EAAM7B,SAatB,CAXE,QAAIl3B,GACF,OAAOzG,KAAKyD,YAAYgD,IAC1B,CAEAi5B,KAAAA,CAAMn4B,GACJvH,KAAKy/B,UAAYl4B,CACnB,CAEAo4B,MAAAA,CAAOhjB,GAEP,EAde6iB,EAAA7B,QAAU,EAmBrB,MAAOiC,EAEXn8B,WAAAA,GACEzD,KAAK6/B,UAAY,IAAIC,CACvB,CACA,YAAIC,GACF,OAAO//B,KAAK6/B,SACd,CACA,YAAIE,CAASC,GACX,MAAMC,EAASjgC,KAAK6/B,UACpB7/B,KAAK6/B,UAAYG,EACjBhgC,KAAKkgC,gBAAgBD,EACvB,CACUC,eAAAA,CAAgBD,GAExBzW,QAAQ7nB,IAAI,uDAAwD3B,KAAKyD,YAAYgD,KACvF,EAGI,MAAOq5B,EAAbr8B,WAAAA,GACU,KAAA08B,UAAqD,CAAC,EA+DpD,KAAAC,QAAoB,GACpB,KAAAC,cAAe,CAkB3B,CAhFEC,EAAAA,CAAGC,EAA+BvP,GAChC,OAAOhxB,KAAKwgC,YAAYD,EAAOvgC,KAAKmgC,UAAWnP,EACjD,CAEAyP,QAAAA,CAASF,EAA+BvP,GACtC,OAAOhxB,KAAK0gC,eAAeH,EAAOvgC,KAAKmgC,UAAWnP,EACpD,CAEA2P,cAAAA,CAAeJ,GAIb,MAHqB,iBAAVA,IACTA,EAASA,EAAiBt0B,MAAM,MAE3Bs0B,EAAM97B,IAAI,SAAUm8B,GACzB,OAAOA,EAAEt3B,MACX,EACF,CAEAk3B,WAAAA,CAAeD,EAA+BM,EAA0CC,GAKtF,OAJA9gC,KAAK2gC,eAAeJ,GAAO77B,QAAQ,SAAU+B,GAC3Co6B,EAAYp6B,GAAQo6B,EAAYp6B,IAAS,GACzCo6B,EAAYp6B,GAAMiB,KAAKo5B,EACzB,GACO9gC,IACT,CAEA0gC,cAAAA,CAAkBH,EAA+BM,EAA0CC,GAUzF,OATA9gC,KAAK2gC,eAAeJ,GAAO77B,QAAQ,SAAU+B,GAC3C,MAAMs6B,EAAaF,EAAYp6B,IAAS,GACxC,IAAK,IAAI5F,EAAI,EAAGA,EAAIkgC,EAAWj8B,OAAQjE,IACrC,GAAIkgC,EAAWlgC,IAAMigC,EAAS,CAC5BC,EAAWhV,OAAOlrB,EAAG,GACrB,KACF,CAEJ,GACOb,IACT,CAEAghC,IAAAA,CAAKv6B,EAAca,EAAa4pB,GAC9B,MAAM+P,EAAM,IAAIrC,EAAOn4B,EAAMa,EAAQ4pB,GACrC,OAAIlxB,KAAKqgC,cACPrgC,KAAKogC,QAAQ14B,KAAKu5B,IACX,GAEAjhC,KAAKkhC,cAAcD,EAE9B,CAEAC,aAAAA,CAAcvkB,GACZ,MAAMwkB,EAAenhC,KAAKmgC,UAAUxjB,EAAMlW,OAAS,GACnD,IAAK,MAAMuqB,KAAYmQ,EAErB,GADAnQ,EAASrU,GACLA,EAAMoiB,UAAW,OAAO,EAE9B,OAAO,CACT,CAQAqC,cAAAA,GAIE,OAHKphC,KAAKqgC,eACRrgC,KAAKqgC,cAAe,GAEfrgC,IACT,CAEAqhC,WAAAA,GACErhC,KAAKqgC,cAAe,EACpBrgC,KAAKogC,QAAU,EACjB,CAEAkB,WAAAA,GACEthC,KAAKqgC,cAAe,EACpBrgC,KAAKghC,KAAKlB,EAASyB,aAAcvhC,KAAMA,KAAKogC,SAC5CpgC,KAAKogC,QAAU,EACjB,EAnBcN,EAAAyB,aAAe,cC5KzB,MAAOC,EAKX/9B,WAAAA,IAAeg+B,GAJL,KAAAC,YAA2B,KAC3B,KAAAC,WAA0B,KAC1B,KAAAC,MAAQ,EAGhB,IAAK,MAAMhB,KAAKa,EAAQzhC,KAAK6hC,SAASjB,EACxC,CAEA/yB,MAAAA,GACE,OAAOxK,MAAMsL,KAAK3O,KAAKyhC,SACzB,CAEA/8B,OAAAA,CAAQ0R,GACN,IAAI4lB,EAAgBh8B,KAAK0hC,YACrBI,EAAQ,EACZ,KAAc,MAAP9F,GACc,GAAf5lB,EAAO4lB,IAGX8F,IACA9F,EAAMA,EAAI+F,YAEZ,OAAOD,CACT,CAEArK,MAAAA,CAAOwG,EAAuB+D,GAC5B,GAAIhiC,KAAKinB,MAAQgX,EAAQhX,KAAM,OAAO,EACtC,IAAI+U,EAAMh8B,KAAKgZ,MACXipB,EAAOhE,EAAQjlB,MACnB,KAAc,MAAPgjB,GAAuB,MAARiG,EAAcjG,EAAMA,EAAI+F,YAAaE,EAAOA,EAAKF,YACrE,IAAKC,EAAQhG,EAAKiG,GAChB,OAAO,EAGX,OAAc,MAAPjG,GAAuB,MAARiG,CACxB,CAEA,WAAIC,GACF,OAAqB,GAAdliC,KAAK4hC,KACd,CAEA,QAAI3a,GACF,OAAOjnB,KAAK4hC,KACd,CAEA,SAAI5oB,GACF,OAAOhZ,KAAK0hC,WACd,CAEA,QAAIS,GACF,OAAOniC,KAAK2hC,UACd,CAKA,eAACS,GACC,IAAIpG,EAAMh8B,KAAK2hC,WACf,KAAc,MAAP3F,SACCA,EACNA,EAAMA,EAAIqG,WAEd,CAKA,OAACZ,GACC,IAAIzF,EAAMh8B,KAAK0hC,YACf,KAAc,MAAP1F,SACCA,EACNA,EAAMA,EAAI+F,WAEd,CAEAO,GAAAA,CAAI/C,EAAUgD,EAAsB,MAElC,GAAyB,MAArBhD,EAAMwC,aAA4C,MAArBxC,EAAM8C,YACrC,MAAM,IAAIx2B,MAAM,sDAIlB,GAFA0zB,EAAMwC,YAAcxC,EAAM8C,YAAc,KACxCriC,KAAK4hC,QACmB,MAApB5hC,KAAK0hC,aAA0C,MAAnB1hC,KAAK2hC,WACnC3hC,KAAK0hC,YAAc1hC,KAAK2hC,WAAapC,OAChC,GAAc,MAAVgD,EACThD,EAAM8C,YAAcriC,KAAK2hC,WACzBpC,EAAMwC,YAAc,KACpB/hC,KAAK2hC,WAAWI,YAAcxC,EAC9Bv/B,KAAK2hC,WAAapC,OACb,GAAIgD,GAAUviC,KAAK0hC,YACxBnC,EAAMwC,YAAcQ,EACpBhD,EAAM8C,YAAc,KACpBriC,KAAK0hC,YAAYW,YAAc9C,EAC/Bv/B,KAAK0hC,YAAcnC,MACd,CACL,MAAMiD,EAAOD,EAAOF,YACpB9C,EAAMwC,YAAcQ,EACpBA,EAAOF,YAAc9C,EACrBA,EAAM8C,YAAcG,EACR,MAARA,IACFA,EAAKT,YAAcxC,EAEvB,CACA,OAAOv/B,IACT,CAEAyiC,SAAAA,CAAUphC,GACR,OAAOrB,KAAKsiC,IAAIjhC,EAAOrB,KAAK0hC,YAC9B,CAEAG,QAAAA,CAASxgC,GACP,OAAOrB,KAAKsiC,IAAIjhC,EAClB,CAQA4c,MAAAA,CAAOshB,GACL,MAAMt0B,EAAOs0B,EAAMwC,YACbS,EAAOjD,EAAM8C,YAmBnB,OAjBY,MAARp3B,GACFjL,KAAK2hC,WAAaa,EACN,MAARA,IAAcxiC,KAAK0hC,YAAc,OAErCz2B,EAAKo3B,YAAcG,EAGT,MAARA,GACFxiC,KAAK0hC,YAAcz2B,EACP,MAARA,IAAcjL,KAAK2hC,WAAa,OAEpCa,EAAKT,YAAc92B,EAGrBjL,KAAK4hC,QAELrC,EAAM8C,YAAc9C,EAAMwC,YAAc,KACjC/hC,IACT,CAEA0iC,OAAAA,GACE,GAAuB,MAAnB1iC,KAAK2hC,WACP,MAAM,IAAI91B,MAAM,eAElB,MAAMosB,EAAMj4B,KAAK2hC,WAEjB,OADA3hC,KAAKie,OAAOga,GACLA,CACT,CAEA0K,QAAAA,GACE,GAAwB,MAApB3iC,KAAK0hC,YACP,MAAM,IAAI71B,MAAM,eAElB,MAAMosB,EAAMj4B,KAAK0hC,YAEjB,OADA1hC,KAAKie,OAAOga,GACLA,CACT,ECjLI,MAAO2K,GC8BP,SAAUC,EAAM3L,EAAWC,GAG/B,IAFAD,EAAIh2B,KAAKM,IAAI01B,GACbC,EAAIj2B,KAAKM,IAAI21B,GACNA,EAAI,GAAG,CACZ,MAAM2L,EAAI3L,EACVA,EAAID,EAAIC,EACRD,EAAI4L,CACN,CACA,OAAO5L,CACT,CDtCS0L,EAAAG,YAAc,IAAM5vB,WAAaA,UAAUoK,UAAU3S,QAAQ,SAAW,EACxEg4B,EAAAI,WAAa,IAAM7vB,WAAaA,UAAUoK,UAAU3S,QAAQ,YAAc,EAC1Eg4B,EAAAK,SAAW,IAAM9vB,WAAaA,UAAUoK,UAAUva,cAAc4H,QAAQ,OAAS,EAEvEg4B,EAAAM,YAAc,IAAM/vB,WAAaA,UAAUoK,UAAU3S,QAAQ,WAAa,EAC1Eg4B,EAAAO,YAAc,IAAMhwB,WAAaA,UAAUoK,UAAU3S,QAAQ,WAAa,EACpFg4B,EAAAQ,UAAY,IAAMjwB,WAAayvB,EAAQO,iBAAmBP,EAAQM,gBAAkBN,EAAQO,eAC5FP,EAAAS,UAAY,IAAMlwB,WAAayvB,EAAQM,iBAAmBN,EAAQM,gBAAkBN,EAAQK,YCiC/F,MAAOK,EAQX7/B,WAAAA,CAAYo5B,EAAM,EAAG0G,EAAM,EAAGC,GAAa,GACzC,GAAI/hC,MAAMo7B,IAAQp7B,MAAM8hC,GACtB,MAAM,IAAI13B,MAAM,qBAAqBgxB,oBAAsB0G,MAE7D,GAAIC,EAAY,CACd,MAAMC,EAAMZ,EAAMhG,EAAK0G,GACvB1G,GAAO4G,EACPF,GAAOE,CACT,CACAzjC,KAAK68B,IAAMA,EACX78B,KAAKujC,IAAMA,CACb,CAEA,YAAOluB,CAAM7R,EAAaggC,GAAa,GACrC,MAAMjH,EAAQ/4B,EACX8F,OACA2C,MAAM,KACNxH,IAAKyyB,GAAMA,EAAE5tB,QAChB,IAAIuzB,EAAM,EACN0G,EAAM,EACV,GAAoB,GAAhBhH,EAAMz3B,OAAa+3B,EAAM/H,SAASyH,EAAM,QACvC,IAAoB,GAAhBA,EAAMz3B,OACb,MAAM,IAAI+G,MAAM,4BAA8BrI,GAE1C+4B,EAAM,GAAGz3B,OAAS,IACpB+3B,EAAM/H,SAASyH,EAAM,KAEnBA,EAAM,GAAGz3B,OAAS,IACpBy+B,EAAMzO,SAASyH,EAAM,IAEzB,CACA,GAAI96B,MAAMo7B,IAAQp7B,MAAM8hC,GACtB,MAAM,IAAI13B,MAAM,4BAA8BrI,GAEhD,OAAO,IAAI8/B,EAASzG,EAAK0G,EAAKC,EAChC,CAEA,WAAIE,GACF,OAAO1jC,KAAK68B,IAAM78B,KAAKujC,KAAO,CAChC,CAEA,UAAII,GACF,OAAmB,GAAZ3jC,KAAK68B,GACd,CAEA,cAAI+G,GACF,OAAmB,GAAZ5jC,KAAKujC,GACd,CAEA,SAAIM,GACF,OAAO7jC,KAAK68B,KAAO78B,KAAKujC,GAC1B,CAEA,QAAIO,GACF,OAAI9jC,KAAK68B,IAAM78B,KAAKujC,KAAO,EAClBvjC,KAAK68B,IAAM78B,KAAKujC,IAEhB,EAAIriC,KAAKQ,MAAM1B,KAAK68B,IAAM78B,KAAKujC,IAE1C,CAEA,SAAI7hC,GACF,OAAI1B,KAAK68B,IAAM78B,KAAKujC,KAAO,EAClBvjC,KAAK68B,IAAM78B,KAAKujC,IAEhBriC,KAAKQ,MAAM1B,KAAK68B,IAAM78B,KAAKujC,IAEtC,CAEAQ,IAAAA,CAAK9F,EAAmBuF,GAAa,GACnC,OAAO,IAAIF,EAAStjC,KAAK68B,IAAMoB,EAAQsF,IAAMvjC,KAAKujC,IAAMtF,EAAQpB,IAAK78B,KAAKujC,IAAMtF,EAAQsF,IAAKC,EAC/F,CAEAQ,OAAAA,CAAQ/F,EAAiBuF,GAAa,GACpC,OAAO,IAAIF,EAAStjC,KAAK68B,IAAM78B,KAAKujC,IAAMtF,EAASj+B,KAAKujC,IAAKC,EAC/D,CAEAS,KAAAA,CAAMhG,EAAmBuF,GAAa,GACpC,OAAO,IAAIF,EAAStjC,KAAK68B,IAAMoB,EAAQsF,IAAMvjC,KAAKujC,IAAMtF,EAAQpB,IAAK78B,KAAKujC,IAAMtF,EAAQsF,IAAKC,EAC/F,CAEAU,QAAAA,CAASjG,EAAiBuF,GAAa,GACrC,OAAO,IAAIF,EAAStjC,KAAK68B,IAAM78B,KAAKujC,IAAMtF,EAASj+B,KAAKujC,IAAKC,EAC/D,CAEAW,KAAAA,CAAMlG,EAAmBuF,GAAa,GACpC,OAAO,IAAIF,EAAStjC,KAAK68B,IAAMoB,EAAQpB,IAAK78B,KAAKujC,IAAMtF,EAAQsF,IAAKC,EACtE,CAEAY,QAAAA,CAASnG,EAAiBuF,GAAa,GACrC,OAAO,IAAIF,EAAStjC,KAAK68B,IAAMoB,EAASj+B,KAAKujC,IAAKC,EACpD,CAEAa,KAAAA,CAAMpG,EAAmBuF,GAAa,GACpC,OAAO,IAAIF,EAAStjC,KAAK68B,IAAMoB,EAAQsF,IAAKvjC,KAAKujC,IAAMtF,EAAQpB,IAAK2G,EACtE,CAEAc,QAAAA,CAASrG,EAAiBuF,GAAa,GACrC,OAAO,IAAIF,EAAStjC,KAAK68B,IAAK78B,KAAKujC,IAAMtF,EAASuF,EACpD,CAKAe,QAAAA,CAAStG,EAAiBuF,GAAa,GACrC,OAAO,IAAIF,EAAStjC,KAAKujC,IAAMtF,EAASj+B,KAAK68B,IAAK2G,EACpD,CAKAgB,GAAAA,CAAIvG,GAEF,MAAMn9B,EAAId,KAAKqkC,MAAMpG,GACfwG,EAAWvjC,KAAKQ,MAAMZ,EAAE+7B,IAAM/7B,EAAEyiC,KACtC,OAAOvjC,KAAKikC,MAAMhG,EAAQmG,SAASK,GACrC,CAKAC,MAAAA,CAAOzG,GAEL,MAAMn9B,EAAId,KAAKskC,SAASrG,GAClBwG,EAAWvjC,KAAKQ,MAAMZ,EAAE+7B,IAAM/7B,EAAEyiC,KACtC,OAAOvjC,KAAKkkC,SAASjG,EAAUwG,EACjC,CAEA,WAAIE,GACF,OAAO,IAAIrB,EAAStjC,KAAKujC,IAAKvjC,KAAK68B,IACrC,CAEA,cAAI2G,GACF,MAAMC,EAAMZ,EAAM7iC,KAAK68B,IAAK78B,KAAKujC,KACjC,OAAO,IAAID,EAAStjC,KAAK68B,IAAM4G,EAAKzjC,KAAKujC,IAAME,EACjD,CAEAhM,MAAAA,CAAOwG,GACL,OAAOj+B,KAAK68B,IAAMoB,EAAQsF,KAAOvjC,KAAKujC,IAAMtF,EAAQpB,GACtD,CAEA+H,SAAAA,CAAU3G,GACR,OAAOj+B,KAAK68B,KAAO78B,KAAKujC,IAAMtF,CAChC,CAEA4G,GAAAA,CAAI5G,GACF,OAAOj+B,KAAK68B,IAAMoB,EAAQsF,IAAMvjC,KAAKujC,IAAMtF,EAAQpB,GACrD,CAEAiI,MAAAA,CAAO7G,GACL,OAAOj+B,KAAK68B,IAAM78B,KAAKujC,IAAMtF,CAC/B,CAEA8G,IAAAA,CAAK9G,GACH,OAAOj+B,KAAK6kC,IAAI5G,GAAW,CAC7B,CAEA+G,KAAAA,CAAM/G,GACJ,OAAOj+B,KAAK6kC,IAAI5G,IAAY,CAC9B,CAEAgH,OAAAA,CAAQhH,GACN,OAAOj+B,KAAK8kC,OAAO7G,GAAW,CAChC,CAEAiH,QAAAA,CAASjH,GACP,OAAOj+B,KAAK8kC,OAAO7G,IAAY,CACjC,CAEAkH,IAAAA,CAAKlH,GACH,OAAOj+B,KAAK6kC,IAAI5G,GAAW,CAC7B,CAEAmH,KAAAA,CAAMnH,GACJ,OAAOj+B,KAAK6kC,IAAI5G,IAAY,CAC9B,CAEAoH,OAAAA,CAAQpH,GACN,OAAOj+B,KAAK8kC,OAAO7G,GAAW,CAChC,CAEAqH,QAAAA,CAASrH,GACP,OAAOj+B,KAAK8kC,OAAO7G,IAAY,CACjC,CAEA/7B,QAAAA,GACE,OAAOlC,KAAK68B,IAAM,IAAM78B,KAAKujC,GAC/B,CAEA,UAAO5L,CAAI4N,EAAcC,GACvB,OAAOD,EAAGV,IAAIW,GAAM,EAAID,EAAKC,CAC/B,CAEA,UAAOzqB,CAAIwqB,EAAcC,GACvB,OAAOD,EAAGV,IAAIW,GAAM,EAAID,EAAKC,CAC/B,EAvMgBlC,EAAAmC,KAAO,IAAInC,EACXA,EAAAoC,IAAM,IAAIpC,EAAS,EAAG,GACtBA,EAAAqC,SAAW,IAAIrC,EAAS,EAAG,GAyMtC,MAAMsC,EAAOA,CAACx8B,EAAI,EAAGC,EAAI,EAAGm6B,GAAa,IAAoB,IAAIF,EAASl6B,EAAGC,EAAGm6B,GC/OjFiC,EAAOI,EAAiBJ,KAClBI,EAAiBH,IAMvB,MAAOI,EAQXriC,WAAAA,CACkBsiC,EACTC,EAAW,EACXC,EAAY,EACZtV,EAAW,GAHF,KAAAoV,MAAAA,EACT,KAAAC,SAAAA,EACA,KAAAC,UAAAA,EACA,KAAAtV,SAAAA,CACN,CAMH,QAAI1lB,GACF,MAAMi7B,EAAUlmC,KAAK+lC,MAAMI,KAAKnmC,KAAKgmC,UAC/B19B,EAAoC,CACxC,CAACtI,KAAKgmC,SAAUhmC,KAAKimC,UAAWjmC,KAAK2wB,UACrCuV,EAAQE,YAAYpmC,KAAKimC,YAc3B,OAZAjmC,KAAK2wB,aACAuV,EAAQG,WAAWrmC,KAAKimC,YAAcjmC,KAAK2wB,UAAYuV,EAAQG,WAAWrmC,KAAKimC,cAClFjmC,KAAK2wB,SAAW,EAChB3wB,KAAKimC,YACDjmC,KAAKimC,WAAaC,EAAQE,YAAYthC,SACxC9E,KAAKimC,UAAY,EACjBjmC,KAAKgmC,WACDhmC,KAAKgmC,UAAYhmC,KAAK+lC,MAAMI,KAAKrhC,SACnC9E,KAAKgmC,SAAW,KAIf19B,CACT,CAMA,QAAIk6B,GACF,MAAM0D,EAAUlmC,KAAK+lC,MAAMI,KAAKnmC,KAAKgmC,UAC/B19B,EAAoC,CACxC,CAACtI,KAAKgmC,SAAUhmC,KAAKimC,UAAWjmC,KAAK2wB,UACrCuV,EAAQE,YAAYpmC,KAAKimC,YAgB3B,OAZAjmC,KAAK2wB,WACD3wB,KAAK2wB,SAAW,IAClB3wB,KAAKimC,YACDjmC,KAAKimC,UAAY,IACnBjmC,KAAKgmC,WACDhmC,KAAKgmC,SAAW,IAClBhmC,KAAKgmC,SAAWhmC,KAAK+lC,MAAMI,KAAKrhC,OAAS,GAE3C9E,KAAKimC,UAAYjmC,KAAK+lC,MAAMI,KAAKnmC,KAAKgmC,UAAUM,UAAY,GAE9DtmC,KAAK2wB,UAAY3wB,KAAK+lC,MAAMI,KAAKnmC,KAAKgmC,UAAUK,WAAWrmC,KAAKimC,YAAc,GAAK,GAE9E39B,CACT,EAOI,MAAOi+B,UAAYjI,EAgBvB76B,WAAAA,CAAY+J,EAAc,MACxB+wB,MAAO/wB,EAASA,GAAU,CAAC,GAhBpB,KAAAiwB,KAAe,MAMxB,KAAA2I,YAA0B,GAG1B,KAAAC,WAAuB,GAQrBrmC,KAAKyG,KAAO+G,EAAO/G,MAAQ,GAC3B,IAAK,MAAM+/B,KAAMh5B,EAAO44B,aAAe,GACnB,iBAAPI,EACTxmC,KAAKomC,YAAY1+B,KAAKm+B,EAAaW,IAEnCxmC,KAAKomC,YAAY1+B,KAAK8+B,GAG1B,IAAK,MAAMC,KAAMj5B,EAAO64B,YAAc,GACpCrmC,KAAKqmC,WAAW3+B,KAAK++B,GAEvB,KAAOzmC,KAAKqmC,WAAWvhC,OAAS9E,KAAKomC,YAAYthC,QAC/C9E,KAAKqmC,WAAW3+B,KAAK,EAEzB,CAMAs2B,UAAAA,GACE,OAAA77B,OAAA4H,OAAA5H,OAAA4H,OAAA,GAAYw0B,MAAMP,cAAY,CAAEv3B,KAAY2/B,YAAapmC,KAAKomC,aAChE,CAOA3O,MAAAA,CAAOwG,GACL,IAAKM,MAAM9G,OAAOwG,GAAU,OAAO,EACnC,GAAIj+B,KAAKomC,YAAYthC,QAAUm5B,EAAQmI,YAAYthC,OAAQ,OAAO,EAClE,GAAI9E,KAAKqmC,WAAWvhC,QAAUm5B,EAAQoI,WAAWvhC,OAAQ,OAAO,EAChE,IAAK,IAAIjE,EAAI,EAAGA,EAAIb,KAAKomC,YAAYthC,OAAQjE,IAC3C,IAAKb,KAAKomC,YAAYvlC,GAAG42B,OAAOwG,EAAQmI,YAAYvlC,IAAK,OAAO,EAElE,IAAK,IAAIA,EAAI,EAAGA,EAAIb,KAAKqmC,WAAWvhC,OAAQjE,IAC1C,GAAIb,KAAKqmC,WAAWxlC,IAAMo9B,EAAQoI,WAAWxlC,GAAI,OAAO,EAE1D,OAAO,CACT,CAMAw9B,MAAAA,CAAOJ,GACLM,MAAMF,OAAOJ,GACbA,EAAQx3B,KAAOzG,KAAKyG,KACpBw3B,EAAQmI,YAAc,IAAIpmC,KAAKomC,aAC/BnI,EAAQoI,WAAa,IAAIrmC,KAAKqmC,WAChC,CAOAK,aAAAA,CAAcT,GACZ,OAAIA,EAAYjmC,KAAKqmC,WAAWvhC,OAEvB,EAEA9E,KAAKqmC,WAAWJ,EAE3B,CAKA,aAAIK,GACF,OAAOtmC,KAAKomC,YAAYthC,MAC1B,CAKA,kBAAI6hC,GACF,IAAI1O,EAAM,EACV,IAAK,IAAIp3B,EAAI,EAAGA,EAAIb,KAAKomC,YAAYthC,OAAQjE,IAC3Co3B,GAAOj4B,KAAKqmC,WAAWxlC,IAAM,EAE/B,OAAOo3B,CACT,CAKA,YAAIuG,GACF,IAAIniB,EAAQopB,EACZ,IAAK,IAAI5kC,EAAI,EAAGA,EAAIb,KAAKomC,YAAYthC,OAAQjE,IAC3Cwb,EAAQA,EAAM0nB,KAAK/jC,KAAKomC,YAAYvlC,GAAGujC,SAASpkC,KAAKqmC,WAAWxlC,IAAM,IAExE,OAAOwb,CACT,EAOI,MAAOuqB,UAActI,EAyBzB76B,WAAAA,CAAY+J,EAAiD,MAC3D+wB,MAAO/wB,EAASA,GAAU,CAAC,GAzBpB,KAAAiwB,KAAe,QA0BtBz9B,KAAKyG,KAAO+G,EAAO/G,MAAQ,GAC3BzG,KAAKmmC,KAAO34B,EAAO24B,MAAQ,EAC7B,CAMAnI,UAAAA,GACE,OAAA77B,OAAA4H,OAAA5H,OAAA4H,OAAA,GAAYw0B,MAAMP,cAAY,CAAEv3B,KAAY0/B,KAAMnmC,KAAKmmC,KAAK1hC,IAAKoiC,GAAMA,EAAE7I,eAC3E,CAMAiB,QAAAA,GACE,OAAOj/B,KAAKmmC,IACd,CAOA1O,MAAAA,CAAOwG,GACL,IAAKM,MAAM9G,OAAOwG,GAChB,OAAO,EAET,GAAIj+B,KAAKmmC,KAAKrhC,QAAUm5B,EAAQkI,KAAKrhC,OAAQ,OAAO,EACpD,IAAK,IAAIjE,EAAI,EAAGA,EAAIb,KAAKmmC,KAAKrhC,OAAQjE,IACpC,IAAKb,KAAKmmC,KAAKtlC,GAAG42B,OAAOwG,EAAQkI,KAAKtlC,IAAK,OAAO,EAEpD,OAAO,CACT,CAWAimC,UAAAA,CAAWC,GACT,IAAIhB,EAAQ,EACZ,KAAOgB,EAAc,GACnBA,GAAe/mC,KAAK2mC,eACpBZ,IAEEgB,GAAe/mC,KAAK2mC,iBACtBZ,EAAQ7kC,KAAKQ,MAAMqlC,EAAc/mC,KAAK2mC,iBAExCI,GAA4B/mC,KAAK2mC,eACjC,IAAIxmC,EAASslC,EACb,IAAK,IAAIO,EAAW,EAAGA,EAAWhmC,KAAKmmC,KAAKrhC,OAAQkhC,IAAY,CAC9D,MAAMgB,EAAMhnC,KAAKmmC,KAAKH,GACtB,GAAIe,GAAeC,EAAIL,eACrBI,GAAeC,EAAIL,eACnBxmC,EAASA,EAAO4jC,KAAKiD,EAAIxI,eAGzB,IAAK,IAAIyH,EAAY,EAAGA,EAAYe,EAAIV,UAAWL,IAAa,CAC9D,MAAMgB,EAAaD,EAAIZ,YAAYH,GAC7BK,EAAYU,EAAIX,WAAWJ,IAAc,EAC/C,KAAIc,GAAeT,GAGZ,CAEL,MAAM3V,EAAWoW,EACjB,MAAO,CAAChB,EAAO,CAACC,EAAUC,EAAWtV,GAAWxwB,EAAO4jC,KAAKkD,EAAW7C,SAASzT,IAClF,CANEoW,GAAeT,EACfnmC,EAASA,EAAO4jC,KAAKkD,EAAW7C,SAASkC,GAM7C,CAEJ,CACA,MAAM,IAAIz6B,MAAM,sBAClB,CAYAq7B,WAAAA,CAAYC,GACV,MAAM3I,EAAWx+B,KAAKw+B,SACtB,IAAI4I,EAAW,EACf,GAAID,EAAapC,KAAKU,GACpB,KAAO0B,EAAapC,KAAKU,IACvB2B,IACAD,EAAeA,EAAapD,KAAKvF,QAE9B,GAAI2I,EAAa/B,MAAM5G,GAAW,CACvC,MAAM6I,EAAaF,EAAa3C,IAAIhG,GAEpCqH,GADAsB,EAAeA,EAAalD,MAAMoD,GAAYhD,MAAM7F,IAC5BkF,SACxB0D,EAAWD,EAAazlC,MACxBylC,EAAeE,CACjB,CAGA,IAAIN,EAAc,EAClB,IAAK,IAAIf,EAAW,EAAGA,EAAWhmC,KAAKmmC,KAAKrhC,OAAQkhC,IAAY,CAC9D,MAAMgB,EAAMhnC,KAAKmmC,KAAKH,GAChBsB,EAAcN,EAAIxI,SACxB,GAAI2I,EAAa/B,MAAMkC,GACrBH,EAAeA,EAAalD,MAAMqD,QAGlC,IAAK,IAAIrB,EAAY,EAAGA,EAAYe,EAAIV,UAAWL,IAAa,CAC9D,MAAMgB,EAAaD,EAAIZ,YAAYH,GAC7BK,EAAYU,EAAIX,WAAWJ,IAAc,EAC/C,IAAK,IAAItV,EAAW,EAAGA,EAAW2V,EAAW3V,IAAYoW,IAAe,CACtE,IAAII,EAAa/B,MAAM6B,GAIrB,MAAO,CAACG,EAAU,CAACpB,EAAUC,EAAWtV,GAAWwW,EAAcJ,GAHjEI,EAAeA,EAAalD,MAAMgD,EAKtC,CACF,CAEFF,GAAeC,EAAIL,cACrB,CAEA,MAAM,IAAI96B,MAAM,sBAClB,CAUA,aAAC07B,CAAaC,EAAW,EAAGC,EAAY,EAAGC,EAAgB,GACzD,IAAI1B,EAAWwB,EACXvB,EAAYwB,EACZE,EAAgBD,EACpB,OAAa,CACX,MAAMxB,EAAUlmC,KAAKmmC,KAAKH,QACpB,CAAC,CAACA,EAAUC,EAAW0B,GAAgBzB,EAAQE,YAAYH,IACjE0B,MACKzB,EAAQG,WAAWJ,IAAc0B,GAAiBzB,EAAQG,WAAWJ,MACxE0B,EAAgB,EAChB1B,IACIA,GAAaC,EAAQE,YAAYthC,SACnCmhC,EAAY,EACZD,IACIA,GAAYhmC,KAAKmmC,KAAKrhC,SACxBkhC,EAAW,IAInB,CACF,CAMA3H,MAAAA,CAAOJ,GACLM,MAAMF,OAAOJ,GACbA,EAAQx3B,KAAOzG,KAAKyG,KACpBw3B,EAAQkI,KAAOnmC,KAAKmmC,KAAK1hC,IAAKyyB,GAAMA,EAAEiH,QACxC,CAKA,aAAImI,GACF,IAAIrO,EAAM,EACV,IAAK,MAAM+O,KAAOhnC,KAAKmmC,KAAMlO,GAAO+O,EAAIV,UACxC,OAAOrO,CACT,CAKA,kBAAI0O,GACF,IAAI1O,EAAM,EACV,IAAK,MAAM+O,KAAOhnC,KAAKmmC,KAAMlO,GAAO+O,EAAIL,eACxC,OAAO1O,CACT,CAKA,YAAIuG,GACF,OAAOx+B,KAAKmmC,KAAKyB,OAAO,CAAC1Q,EAAGC,IAAMD,EAAE6M,KAAK5M,EAAEqH,UAAWiH,EACxD,EApNgBmB,EAAAiB,QAAU,IAAIjB,EAAM,CAClCngC,KAAM,aACN0/B,KAAM,CACJ,IAAII,EAAI,CAAE9/B,KAAM,QAAS2/B,YAAa,CAAC,EAAG,EAAG,EAAG,KAChD,IAAIG,EAAI,CAAE9/B,KAAM,UAAW2/B,YAAa,CAAC,EAAG,KAC5C,IAAIG,EAAI,CAAE9/B,KAAM,UAAW2/B,YAAa,CAAC,EAAG,QCzN3C,MAAMX,EAAOI,EAAiBJ,KACxBC,EAAMG,EAAiBH,IAO7B,IAAKoC,EAAAA,KAAAA,IAAAA,EAAQ,KAClB,YACAA,EAAA,kBACAA,EAAA,oBACAA,EAAA,cACAA,EAAA,cACAA,EAAA,cACAA,EAAA,YACAA,EAAA,gBAOI,MAAgBC,UAAazJ,EAsBjC76B,WAAAA,CAAY+6B,EAAWkH,GACrBnH,QAtBO,KAAAd,KAAe,OAQxB,KAAAsE,YAAkC,KAElC,KAAAM,YAAkC,KAElC,KAAA2F,YAAmC,KAGnC,KAAAC,gBAAiB,EAQfjoC,KAAKkoC,UAAY1J,GAAYkH,CAC/B,CAaA1H,UAAAA,GACE,MAAM/F,EAAMsG,MAAMP,aAalB,OAZKh+B,KAAKw+B,SAASqF,QACjB5L,EAAIuG,SAAWx+B,KAAKw+B,SAASgF,WAAWthC,YAEtClC,KAAKioC,iBACPhQ,EAAIgQ,gBAAiB,IAElBjoC,KAAKmoC,eAAiB,IAAIrjC,OAAS,IACtCmzB,EAAImQ,KAAOpoC,KAAKmoC,cAAc1jC,IAAKjE,GAAMA,EAAEw9B,gBAExCh+B,KAAKqoC,cAAgB,IAAIvjC,OAAS,IACrCmzB,EAAIqQ,KAAOtoC,KAAKqoC,aAAa5jC,IAAKjE,GAAMA,EAAEw9B,eAErC/F,CACT,CAMAoG,MAAAA,CAAOJ,GACLM,MAAMF,OAAOJ,GACbA,EAAQiK,UAAY,IAAIrC,EAAiB7lC,KAAKw+B,SAAS3B,IAAK78B,KAAKw+B,SAAS+E,IAC5E,CAKA,YAAI/E,GACF,OAAOx+B,KAAKkoC,SACd,CAKA,YAAI1J,CAAS19B,GACXd,KAAKkoC,UAAYpnC,CACnB,EAOI,MAAgBynC,UAAiBR,EAAvCtkC,WAAAA,G,oBACW,KAAAg6B,KAAe,WAGxB,KAAA+K,YAAa,CAqCf,CA3BEC,OAAAA,CAAQjK,GACN,GAAIx+B,KAAKw+B,SAASqG,IAAIrG,GAAY,EAAG,CACnC,MAAMkK,EAAY1oC,KAAK2oC,qBAAqB3oC,KAAKw+B,SAASyF,MAAMzF,IAIhE,OAHAkK,EAAUT,gBAAiB,EAC3BjoC,KAAKw+B,SAAWA,EAETkK,CACT,CACA,OAAO,IACT,CAOUC,oBAAAA,CAAqBnK,GAC7B,OAAO,IAAIoK,EAAMpK,EACnB,CAMAR,UAAAA,GACE,OAAOh+B,KAAKwoC,WAAYrmC,OAAA4H,OAAA5H,OAAA4H,OAAA,GAAMw0B,MAAMP,cAAY,CAAEwK,YAAY,IAASjK,MAAMP,YAC/E,EAOI,MAAO6K,UAAerL,EAQ1B/5B,WAAAA,CACSqlC,EACAC,GAAW,GAElBxK,QAHO,KAAAuK,KAAAA,EACA,KAAAC,SAAAA,EATA,KAAAtL,KAAO,QAYhB,CAMAO,UAAAA,GACE,OAAA77B,OAAA4H,OAAA5H,OAAA4H,OAAA,GAAYw0B,MAAMP,cAAY,CAAE8K,KAAM9oC,KAAK8oC,KAAMvG,OAAQviC,KAAK+oC,UAChE,CAMA7mC,QAAAA,GACE,MAAO,UAAUlC,KAAK8oC,QAAQ9oC,KAAK+oC,WACrC,EAuBI,MAAOH,UAAcL,EAazB9kC,WAAAA,CAAY+6B,EAAWkH,EAAKsD,GAAW,GACrCzK,MAAMC,GAbC,KAAAf,KAAO,QAKhB,KAAAuL,UAAW,EASThpC,KAAKgpC,SAAWA,CAClB,CAMAhL,UAAAA,GACE,OAAA77B,OAAA4H,OAAA5H,OAAA4H,OAAA,GAAYw0B,MAAMP,cAAY,CAAEgL,SAAUhpC,KAAKgpC,UACjD,CAMA9mC,QAAAA,GACE,MAAO,SAASlC,KAAKw+B,YAAYx+B,KAAKgpC,WACxC,CAMA3K,MAAAA,CAAOJ,GACLM,MAAMF,OAAOJ,GACbA,EAAQ+K,SAAWhpC,KAAKgpC,QAC1B,CAOAvR,MAAAA,CAAOwG,GACL,OAAOM,MAAM9G,OAAOwG,IAAYj+B,KAAKgpC,UAAY/K,EAAQ+K,QAC3D,CAOUL,oBAAAA,CAAqBnK,GAC7B,MAAMvG,EAAMsG,MAAMoK,qBAAqBnK,GAEvC,OADAvG,EAAI+Q,SAAWhpC,KAAKgpC,SACb/Q,CACT,EAOI,MAAOgR,UAAgBV,EAa3B9kC,WAAAA,CACSpC,EACPm9B,EAAWkH,GAEXnH,MAAMC,GAHC,KAAAn9B,MAAAA,EAbA,KAAAo8B,KAAe,UAKxB,KAAAyL,cAAuB,EAYvB,CAMAlL,UAAAA,GACE,MAAM/F,EAAG91B,OAAA4H,OAAA5H,OAAA4H,OAAA,GAAQw0B,MAAMP,cAAY,CAAE38B,MAAOrB,KAAKqB,QAIjD,OAHIrB,KAAKkpC,cAAcpkC,OAAS,IAC9BmzB,EAAIkR,KAAOnpC,KAAKkpC,cAAczkC,IAAKlE,GAAO,eAAgBA,EAAIA,EAAEy9B,aAAez9B,IAE1E03B,CACT,CAMA/1B,QAAAA,GACE,MAAO,OAAOlC,KAAKw+B,YAAYx+B,KAAKqB,QACtC,CAOAo2B,MAAAA,CAAOwG,GACL,OAAOM,MAAM9G,OAAOwG,IAAYj+B,KAAKqB,OAAS48B,EAAQ58B,KACxD,CAMAg9B,MAAAA,CAAOJ,GACLM,MAAMF,OAAOJ,GACbA,EAAQ58B,MAAQrB,KAAKqB,KACvB,EAoCI,MAAO+nC,UAAaH,EAoBxBxlC,WAAAA,CAAYpC,EAAem9B,EAAWkH,EAAK2D,EAAS,EAAG7hC,EAAQ,GAC7D+2B,MAAMl9B,EAAOm9B,GApBN,KAAAf,KAAO,OAKhB,KAAA4L,OAAS,EAKT,KAAA7hC,MAA0B,EAWxBxH,KAAKqpC,OAASA,EACdrpC,KAAKwH,MAAQA,CACf,CAOA,cAAO8hC,CAAQC,GACb,GAAIA,EAAI9L,MAAQqK,EAAS0B,KAAM,OAAOD,EACtC,MAAMtR,EAAM,IAAImR,EAAKG,EAAIloC,MAAOkoC,EAAI/K,UAGpC,OAFAvG,EAAIiR,cAAgBK,EAAIL,cACxBjR,EAAIuQ,WAAae,EAAIf,WACdvQ,CACT,CAMA+F,UAAAA,GACE,MAAM/F,EAAG91B,OAAA4H,OAAA,GAAQw0B,MAAMP,cAGvB,OAFmB,GAAfh+B,KAAKqpC,SAAapR,EAAIoR,OAASrpC,KAAKqpC,QACtB,GAAdrpC,KAAKwH,QAAYywB,EAAIzwB,MAAQxH,KAAKwH,OAC/BywB,CACT,CAMA/1B,QAAAA,GACE,MAAO,QAAQlC,KAAKw+B,YAAYx+B,KAAKqB,SAASrB,KAAKqpC,SACrD,CAOA5R,MAAAA,CAAOwG,GACL,OAAOM,MAAM9G,OAAOwG,IAAYj+B,KAAKqpC,QAAUpL,EAAQoL,QAAUrpC,KAAKwH,OAASy2B,EAAQz2B,KACzF,CAMA62B,MAAAA,CAAOJ,GACLM,MAAMF,OAAOJ,GACbA,EAAQoL,OAASrpC,KAAKqpC,OACtBpL,EAAQz2B,MAAQxH,KAAKwH,KACvB,EAOI,MAAOiiC,UAAc1B,EAmBzBtkC,WAAAA,IAAeimC,GACbnL,MAAsB,GAAhBmL,EAAM5kC,OAAc2gC,EAAOC,GAnB1B,KAAAjI,KAAO,QAOhB,KAAAkM,sBAAuB,EAKd,KAAAD,MAAQ,IAAI7D,EAQnB7lC,KAAK4pC,UAAS,KAAUF,EAC1B,CAQAjS,MAAAA,CAAOwG,EAAeC,GAAS,GAC7B,QAAKK,MAAM9G,OAAOwG,IACXj+B,KAAK0pC,MAAMjS,OAAOwG,EAAQyL,MAAO,CAACG,EAAIC,IAAOD,EAAGpS,OAAOqS,GAChE,CAMAzL,MAAAA,CAAOJ,GACLM,MAAMF,OAAOJ,GACbA,EAAQ0L,qBAAuB3pC,KAAK2pC,qBACpC3pC,KAAK0pC,MAAMhlC,QAASqlC,GAAS9L,EAAQyL,MAAMpH,IAAIyH,EAAK5L,SACtD,CAOA,YAAIK,GACF,OAAIx+B,KAAK2pC,qBACA3pC,KAAKgqC,mBAAmB3F,MAAMrkC,KAAKkoC,WAEnCloC,KAAKkoC,SAEhB,CAOA+B,uBAAAA,CAAwBC,GAAe,GAErC,OADAlqC,KAAK2pC,qBAAuBO,EACrBlqC,IACT,CAQAmqC,WAAAA,CAAYrpC,EAAaopC,GAAe,GAGtC,OAFAlqC,KAAKkoC,UAAYpnC,EACjBd,KAAK2pC,qBAAuBO,EACrBlqC,IACT,CAMAg+B,UAAAA,GACE,MAAM/F,EAAG91B,OAAA4H,OAAA5H,OAAA4H,OAAA,GAAQw0B,MAAMP,cAAY,CAAE0L,MAAOrmC,MAAMsL,KAAK3O,KAAK0pC,MAAMjI,SAAWr4B,GAAMA,EAAE40B,gBAErF,OADIh+B,KAAK2pC,uBAAsB1R,EAAI0R,sBAAuB,GACnD1R,CACT,CAUAwQ,OAAAA,CAAQ2B,GACN,GAAIpqC,KAAKw+B,SAASwG,MAAMoF,IAAqBA,EAAiBpF,MAAMS,GAClE,OAAO,KAET,MAAM4E,EAAc,IAAIZ,EACpBzpC,KAAK2pC,uBACPU,EAAYV,sBAAuB,EACnCU,EAAYnC,UAAYloC,KAAKkoC,WAG/B,IAAIoC,EAAetqC,KAAKw+B,SACxB,MAAMwL,EAAqBhqC,KAAKgqC,mBAC1BO,EAAiBvqC,KAAK2pC,qBACxBjE,EAAIrB,MAAMrkC,KAAKkoC,WACfloC,KAAKkoC,UAAU7D,MAAM2F,GAAoB,GAC7C,KAAOM,EAAanF,KAAKiF,IAAqBpqC,KAAK0pC,MAAMvH,MAAM,CAC7D,MAAMqI,EAAYxqC,KAAK0pC,MAAMvH,KASvBsI,EAAgBD,EAAUhM,SAAS2F,MAAMoG,GACzCG,EAAcJ,EAAarG,MAAMwG,GACvC,IAAIC,EAAYtF,MAAMgF,GASf,CAYL,MAAMO,EAAiBP,EAAiBnG,MAAMyG,GAAa,GAAMrG,MAAMkG,GAAgB,GAGjF7B,EAAY8B,EAAU/B,QAAQkC,GACpC,GAAiB,MAAbjC,EACF,MAAM,IAAI78B,MAAM,kCAElB,GAAK7L,KAAK2pC,sBAIR,GAAI3pC,KAAKkoC,UAAUvE,OAAQ,MAAM,IAAI93B,MAAM,yBAF3C7L,KAAKkoC,UAAYkC,EAOnB,OAHA1B,EAAUT,gBAAiB,EAE3BoC,EAAYO,cAAcP,EAAYX,MAAM1wB,OAAO,EAAM0vB,GAClD2B,CACT,CAjCE,GAFArqC,KAAK6qC,aAAY,EAAML,GACvBH,EAAYO,cAAcP,EAAYX,MAAM1wB,OAAO,EAAMwxB,GACrDE,EAAYjT,OAAO2S,GAErB,OAAOC,EAgCXC,EAAeI,CACjB,CACA,OAAOL,CACT,CAMA,sBAAIL,GACF,IAAI/R,EAAMwN,EAEV,OADAzlC,KAAK0pC,MAAMhlC,QAASqlC,GAAU9R,EAAMA,EAAI8L,KAAKgG,EAAKvL,WAC3CvG,CACT,CAWA2S,aAAAA,CAAcE,EAAgCC,GAAiB,KAAUrB,GAEvE,MAAMsB,GADND,EAAiBA,IAAmB/qC,KAAK2pC,sBACC3pC,KAAKgqC,mBAAqBtE,EAEpE,IAAK,MAAMqE,KAAQL,EAAO,CACxB,GAAwB,MAApBK,EAAK/B,YAAqB,CAC5B,GAAI+B,EAAK/B,aAAehoC,KACtB,MAAM,IAAI6L,MAAM,mDAElBk+B,EAAK/B,YAAY6C,aAAY,EAAOd,EACtC,CACA,GAAIA,EAAKtM,MAAQqK,EAASmD,KAAM,CAC9B,MAAM9I,EAAOniC,KAAK0pC,MAAMvH,KACpBA,GAAQA,EAAK1E,MAAQqK,EAASoD,OAAS/I,EAAK1E,MAAQqK,EAASqD,QAC9DhJ,EAAkBqG,YAAa,EAEpC,MACEuB,EAAK/B,YAAchoC,KACnBA,KAAK0pC,MAAMpH,IAAIyH,EAAMe,EAEzB,CACA,GAAIC,EACF,GAAI/qC,KAAKkoC,UAAUvE,OAAQ,CACzB,GAAI3jC,KAAK2pC,qBAAsB,MAAM,IAAI99B,MAAM,oBAC/C7L,KAAKkoC,UAAYloC,KAAKgqC,kBACxB,KAAO,CACL,MAAMoB,EAAcprC,KAAKgqC,mBAAmB3F,MAAM2G,GAClDhrC,KAAKkoC,UAAYloC,KAAKkoC,UAAU/D,MAAMiH,GAAa,EACrD,CAEF,OAAOprC,IACT,CASA4pC,QAAAA,CAASmB,GAAiB,KAAUrB,GAClC,OAAO1pC,KAAK4qC,cAAc,KAAMG,KAAmBrB,EACrD,CASAmB,WAAAA,CAAYE,GAAiB,KAAUrB,GAErC,MAAMsB,GADND,EAAiBA,IAAmB/qC,KAAK2pC,sBACC3pC,KAAKgqC,mBAAqBtE,EACpE,IAAK,MAAMqE,KAAQL,EACjB,GAAIK,EAAK/B,aAAehoC,KACtBA,KAAK0pC,MAAMzrB,OAAO8rB,GAClBA,EAAK/B,YAAc,UACd,GAAwB,MAApB+B,EAAK/B,YACd,MAAM,IAAIn8B,MAAM,8DAGpB,GAAIk/B,EACF,GAAI/qC,KAAKkoC,UAAUvE,OAAQ,CACzB,GAAI3jC,KAAK2pC,qBAAsB,MAAM,IAAI99B,MAAM,oBAC/C7L,KAAKkoC,UAAYloC,KAAKgqC,kBACxB,KAAO,CACL,MAAMoB,EAAcprC,KAAKgqC,mBAAmB3F,MAAM2G,GAClDhrC,KAAKkoC,UAAYloC,KAAKkoC,UAAU/D,MAAMiH,GAAa,EACrD,CAEF,OAAOprC,IACT,ECvsBF,MAAMylC,EAAOI,EAAiBJ,KAOxB,MAAO4F,EAoCX5nC,WAAAA,CAAY+J,GAjCH,KAAAkwB,KAAO2N,EAAa1N,UAkC3BnwB,EAASA,GAAU,CAAC,EACpBxN,KAAKsrC,aAAe99B,EAAO89B,cAAgB,EACvC,UAAW99B,IAAQxN,KAAK+lC,MAAQv4B,EAAOu4B,OACtC/lC,KAAK+lC,QAAS/lC,KAAK+lC,MAAMvH,SAASmF,SACrC3jC,KAAK+lC,MAAQa,EAAMiB,SAGrB7nC,KAAKurC,iBAAmB,GACxBvrC,KAAKwrC,eAAiB,GACtBxrC,KAAKyrC,cAAgB,GACrBzrC,KAAK0rC,qBAAuBjG,EAC5BzlC,KAAK2rC,YAAc,EACnB3rC,KAAK4rC,aAAe,GACpB5rC,KAAK6rC,WAAar+B,EAAOq+B,YAAcr+B,EAAOs+B,QAAU,EAC1D,CAOArU,MAAAA,CAAOwG,GACL,OAEEj+B,KAAKsrC,cAAgBrN,EAAQqN,cAC7BtrC,KAAK+lC,MAAMtO,OAAOwG,EAAQ8H,QAC1B/lC,KAAK+rC,gBAAgB9N,EAAQ+N,YAEjC,CAOAD,eAAAA,CAAgB9N,GACd,OAAOj+B,KAAKgsC,YAAYlnC,QAAUm5B,EAAQn5B,QAAU9E,KAAKgsC,YAAYC,MAAM,CAAC/U,EAAGr2B,IAAMq2B,GAAK+G,EAAQp9B,GACpG,CAMAm9B,UAAAA,G,MACE,MAAO,CAEL+H,MAAiB,QAAVmG,EAAAlsC,KAAK+lC,aAAK,IAAAmG,OAAA,EAAAA,EAAElO,aACnBsN,aAActrC,KAAKsrC,aACnBO,WAAY7rC,KAAKgsC,YAErB,CAgBAG,eAAAA,CAAgBC,GA6Cd,MAAMC,EAAWD,EAAK57B,MAAQxQ,KAAKssC,WACnC,IAAIjwB,EAAQ,EACZ,IAAK,IAAIxb,EAAI,EAAGA,EAAIb,KAAKgsC,YAAYlnC,OAAQjE,IAAK,CAChD,GAAIwrC,EAAWhwB,EAAQrc,KAAKgsC,YAAYnrC,GAAI,CAE1C,IAAIV,EAASslC,EACb,GAAI4G,EAAWhwB,EAAO,CACpB,MAAMkwB,EAAS,IAAIzG,EAAY9lC,KAAK+lC,MAAOqG,EAAKpG,SAAUoG,EAAKnG,UAAWmG,EAAKzb,UAC/E,IAAK,CAAE6N,GAAY+N,EAAO/J,KAC1B,IAAK,IAAI3hC,EAAIwb,EAAOxb,EAAIwrC,EAAUxrC,KAC/B,CAAE29B,GAAY+N,EAAO/J,KACtBriC,EAASA,EAAO4jC,KAAKvF,EAAS4F,SAASpkC,KAAKsrC,cAEhD,CACA,MAAO,CAACzqC,EAAGwrC,EAAWhwB,EAAOlc,EAC/B,CACAkc,GAASrc,KAAKgsC,YAAYnrC,EAC5B,CACA,MAAM,IAAIgL,MAAM,uBAAyBugC,EAAK57B,MAEhD,CAWA,cAAIq7B,GAKF,OAJK7rC,KAAKgsC,aAA0C,GAA3BhsC,KAAKgsC,YAAYlnC,SAExC9E,KAAK6rC,WAAa,CAAC7rC,KAAK+lC,MAAMO,YAEzBtmC,KAAKgsC,WACd,CAKA,cAAIH,CAAWroC,GACbxD,KAAKgsC,YAAcxoC,EACnBxD,KAAKwsC,eACP,CAMA,eAAIC,GAIF,QAHKzsC,KAAK4rC,cAAgB5rC,KAAK4rC,aAAa9mC,OAAS9E,KAAK6rC,WAAW/mC,SACnE9E,KAAKwsC,gBAEAxsC,KAAK4rC,YACd,CAKA,cAAIU,GAEF,OADAtsC,KAAKysC,YACEzsC,KAAK2rC,WACd,CAKA,uBAAIe,GAEF,OADA1sC,KAAKysC,YACEzsC,KAAK0rC,oBACd,CAMUc,aAAAA,GACR,MAAMG,EAAY3sC,KAAK+lC,MAAMwB,eACvBqF,EAAM5sC,KAAKsrC,aACjBtrC,KAAK4rC,aAAe5rC,KAAK6rC,WAAWpnC,IAAI,CAACooC,EAAUr8B,KACjD,MAAMs8B,EAAqC,GAE3C,IAAK,IAAIjsC,EAAI,EAAGA,EAAIgsC,EAAUhsC,IAAK,CACjC,MAAMksC,EAASJ,EAAU1hC,OAAO5J,MAChC0rC,EAAO,GAAKA,EAAO,GAAG3I,SAASwI,GAC/BE,EAAMplC,KAAKqlC,EACb,CACA,OAAOD,IAET9sC,KAAK2rC,YAAc3rC,KAAK6rC,WAAWjE,OAAO,CAACx+B,EAAGC,IAAMD,EAAIC,EAAG,GAC3DrJ,KAAKyrC,cAAgBzrC,KAAK4rC,aAAannC,IAAKqoC,GAAUA,EAAMlF,OAAO,CAAC1Q,EAAGC,IAAMD,EAAE6M,KAAK5M,EAAE,IAAKsO,IAC3FzlC,KAAKyrC,cAAc/mC,QAAQ,CAACsoC,EAAIx8B,KAC9BxQ,KAAKurC,iBAAiB/6B,GAAkB,GAATA,EAAai1B,EAAOzlC,KAAKurC,iBAAiB/6B,EAAQ,GAAGuzB,KAAKiJ,KAE3FhtC,KAAKwrC,eAAiBxrC,KAAKyrC,cAAchnC,IAAI,CAACuoC,EAAIx8B,IACzCxQ,KAAKurC,iBAAiB/6B,GAAOuzB,KAAKiJ,IAE3ChtC,KAAK0rC,qBAAuB1rC,KAAKyrC,cAAc7D,OAAO,CAAC1Q,EAAGC,IAAMD,EAAE6M,KAAK5M,GAAIsO,EAC7E,EAvPe4F,EAAA1N,QAAU,ECsBrB,MAAOsP,UAAkBpH,EAA/BpiC,WAAAA,G,oBAEW,KAAAi6B,KAAOuP,EAAUC,YAE1B,KAAAC,cAAgB,EAGhB,KAAAC,KAAkB,GAElB,KAAAC,UAAY,IAAIxlB,IAEhB,KAAAylB,UAAY,IAAIzlB,GA2KlB,CArKEmW,UAAAA,GAKE,MAJY,CACVoP,KAAMptC,KAAKotC,KAAK3oC,IAAK8oC,GAAMA,EAAEvP,cAC7BmP,cAAentC,KAAKmtC,cAGxB,CAMA,YAAIK,GACF,IAAK,MAAMC,KAAMztC,KAAKotC,KACpB,GAAIK,EAAGC,SAAW,EAAG,OAAOD,EAAGE,SAEjC,OAAQ,CACV,CAMA,YAAIC,GACF,IAAIC,GAAU,EACd,IAAK,MAAMJ,KAAMztC,KAAKotC,KAAM,CAC1B,MAAMU,EAAKL,EAAGG,SACVE,GAAM,IACJD,EAAS,GAAKC,EAAKD,KACrBA,EAASC,EAGf,CACA,OAAOD,CACT,CAOAE,UAAAA,CAAWC,GACT,MAAM/V,EAAM,GACNwV,EAAKztC,KAAKotC,KAAKY,GACrB,GAAIP,EACF,IAAK,MAAMQ,KAAQR,EAAGS,OAChBD,aAAI,EAAJA,EAAM5sC,QAAO42B,EAAIvwB,KAAKumC,GAG9B,OAAOhW,CACT,CAOAkW,UAAAA,CAAWC,GACT,MAAMnW,EAAM,GACZ,IAAK,MAAMwV,KAAMztC,KAAKotC,KAAM,CAC1B,MAAMa,EAAOR,EAAGY,OAAOD,IACnBH,aAAI,EAAJA,EAAM5sC,QAAO42B,EAAIvwB,KAAKumC,EAC5B,CACA,OAAOhW,CACT,CAMAqW,WAAAA,CAAYC,GACVvuC,KAAKqtC,UAAUzhC,IAAI2iC,EAAM7Q,KAAM6Q,EACjC,CAMAC,WAAAA,CAAYD,GACVvuC,KAAKstC,UAAU1hC,IAAI2iC,EAAM7Q,KAAM6Q,EACjC,CAQAE,OAAAA,CAAQC,GAAe,EAAIC,EAAU,GAC/BD,EAAe,IACjBA,EAAe1uC,KAAKotC,KAAKtoC,QAE3B,IAAImG,EAAOjL,KAAKotC,KAAKsB,IAAiB,KACtC,MAAMlM,EAAOxiC,KAAKotC,KAAKsB,EAAe,IAAM,KAC5C,IAAK,IAAI7tC,EAAI8tC,EAAU,EAAG9tC,GAAK,EAAGA,IAAK,CACrC,MAAM+tC,EAAS,IAAIC,EAAQ7uC,KAAM0uC,EAAe7tC,GAChDb,KAAKotC,KAAKrhB,OAAO2iB,EAAc,EAAGE,GACtB,MAAR3jC,GACF2jC,EAAOE,gBAAgBC,aAAa9jC,EAAK6jC,iBAElC,GAALjuC,GAAU6tC,EAAe,GAC3BlM,EAAKsM,gBAAgBC,aAAaH,EAAOE,iBAE3C7jC,EAAO2jC,CACT,CACA,IAAK,IAAI/tC,EAAI6tC,EAAeC,EAAS9tC,EAAIb,KAAKotC,KAAKtoC,OAAQjE,IACzDb,KAAKotC,KAAKvsC,GAAG8sC,UAAYgB,EAE3B,OAAO3uC,IACT,CAOAgvC,MAAAA,CAAOhB,GAIL,OAHIA,GAAOhuC,KAAKotC,KAAKtoC,QACnB9E,KAAKyuC,SAAS,EAAG,EAAIT,EAAMhuC,KAAKotC,KAAKtoC,QAEhC9E,KAAKotC,KAAKY,EACnB,CAUAiB,QAAAA,CAASjB,EAAaI,EAAa/sC,EAAY6tC,G,QAC7C,MAAMC,EAAOnvC,KAAKgvC,OAAOhB,GAMzB,GALKkB,IACHA,EAAcA,CAAClB,EAAcI,IACpB,IAAIgB,EAASpB,EAAKI,IAGhB,MAAT/sC,EAAe,CACjB,MAAM42B,EAAMkX,EAAKE,YAAYjB,GAM7B,OALW,MAAPnW,IACW,QAAbiU,EAAAlsC,KAAK+/B,gBAAQ,IAAAmM,GAAAA,EAAElL,KAAKsO,EAAcC,QAASvvC,KAAM,CAC/CwvC,IAAKvX,EAAIvkB,YAGNukB,CACT,CAAO,CACL,MAAMgW,EAAOkB,EAAKd,OAAOD,EAAKc,GACxBO,EAAWxB,EAAK5sC,MAOtB,OANa,QAAbquC,EAAA1vC,KAAK+/B,gBAAQ,IAAA2P,GAAAA,EAAE1O,KAAKsO,EAAcK,QAAS3vC,KAAM,CAC/CwvC,IAAKvB,EAAKv6B,SACVu6B,KAAMA,EACNwB,SAAUxB,EAAK5sC,QAEjB4sC,EAAK5sC,MAAQA,EACNouC,CACT,CACF,CAKUvP,eAAAA,GACR1W,QAAQ7nB,IAAI,kCACd,EAiDK,IAAK2tC,EArOKrC,EAAAC,UAAY,EAqO7B,SAAYoC,GACVA,EAAA,kBACAA,EAAA,sBACAA,EAAA,sBACAA,EAAA,sBACAA,EAAA,iBACD,CAND,CAAYA,IAAAA,EAAa,KAYnB,MAAOF,EAcX3rC,WAAAA,CACSmsC,EACAC,EACAxuC,EAAa,MAFb,KAAAuuC,QAAAA,EACA,KAAAC,SAAAA,EACA,KAAAxuC,MAAAA,EAfA,KAAAq8B,KAAO0R,EAASlC,YAiBvBltC,KAAK8vC,SAAWF,EAAQd,eAC1B,CAKA,YAAIgB,GACF,OAAO9vC,KAAK+vC,SACd,CAKA,YAAID,CAAStsC,GACXA,EAAIwsC,QAAQhwC,MACZA,KAAK+vC,UAAYvsC,CACnB,CAKA,YAAIysC,GACF,OAAOjwC,KAAKkwC,SACd,CAKA,YAAID,CAASzsC,GACXA,EAAIwsC,QAAQhwC,MACZA,KAAKkwC,UAAY1sC,CACnB,CAKA,YAAIkQ,GACF,OAAO1T,KAAK4vC,QAAQjC,SAAW,IAAM3tC,KAAK6vC,QAC5C,CAKA,QAAIM,GACF,OAAOnwC,KAAK4vC,QAAQO,IACtB,CAKA,YAAIxC,GACF,OAAO3tC,KAAK4vC,QAAQjC,QACtB,CAMA3P,UAAAA,GACE,MAAM/F,EAAM,CACVsV,EAAGvtC,KAAK4vC,QAAQjC,SAChBrsC,EAAGtB,KAAK6vC,SACRxuC,MAAOrB,KAAKqB,MACZ81B,EAAGn3B,KAAK8vC,SAASM,YACjB99B,EAAGtS,KAAK8vC,SAASO,WAMnB,OAJIrwC,KAAKiwC,WACPhY,EAAIf,EAAIl3B,KAAKiwC,SAASG,YACtBnY,EAAIvf,EAAI1Y,KAAKiwC,SAASI,WAEjBpY,CACT,EAzFemX,EAAAlC,UAAY,EA+FvB,MAAO2B,EAWXprC,WAAAA,CACS0sC,EACAxC,GADA,KAAAwC,KAAAA,EACA,KAAAxC,SAAAA,EAXT,KAAAO,MAA6B,GAa3BluC,KAAK8uC,gBAAkB,IAAIwB,EAC3BtwC,KAAKmwC,KAAK7B,YAAYtuC,KAAK8uC,gBAC7B,CAKA,YAAIlB,G,MACF,IAAK,IAAI/sC,EAAI,EAAGA,EAAIb,KAAKkuC,MAAMppC,OAAQjE,IACrC,GAAiB,QAAbqrC,EAAAlsC,KAAKkuC,MAAMrtC,UAAE,IAAAqrC,OAAA,EAAAA,EAAE7qC,MACjB,OAAOR,EAGX,OAAQ,CACV,CAKA,WAAI0vC,GACF,OAAOvwC,KAAKkuC,MAAMppC,MACpB,CAKA,YAAI4oC,GACF,IAAI7sC,EAAI,EACR,IAAK,MAAMotC,KAAQjuC,KAAKkuC,MACV,MAARD,GAA8B,MAAdA,EAAK5sC,OAAeR,IAE1C,OAAOA,CACT,CAQAwtC,MAAAA,CAAOD,EAAaoC,GAClB,IAAIvY,EAAMj4B,KAAKkuC,MAAME,IAAQ,KAY7B,OAXKnW,GAAOuY,IACVxwC,KAAKkuC,MAAME,GAAOnW,EAAMuY,EAAQxwC,KAAMouC,GACtCnW,EAAI2X,QAAU5vC,KACdi4B,EAAI4X,SAAWzB,EACXnW,EAAI6X,UACN9vC,KAAKmwC,KAAK7B,YAAYrW,EAAI6X,UAExB7X,EAAIgY,UACNjwC,KAAKmwC,KAAK3B,YAAYvW,EAAIgY,WAGvBhY,CACT,CASAoX,WAAAA,CAAYjB,GACV,MAAMnW,EAAMj4B,KAAKkuC,MAAME,IAAQ,KAI/B,OAHInW,IACFj4B,KAAKkuC,MAAME,GAAO,MAEbnW,CACT,CAMA+F,UAAAA,GACE,MAAO,CACLuP,EAAGvtC,KAAK2tC,SACRO,MAAOluC,KAAKkuC,MAAM/jC,OAAQ7I,GAAMA,GAAGmD,IAAKnD,GAAMA,aAAC,EAADA,EAAG08B,cAErD,EAOI,MAAgByS,EAAtBhtC,WAAAA,GAEW,KAAAi6B,KAAO+S,EAAYvD,YAE5B,KAAAwD,aAAc,EAEJ,KAAAC,aAAe,EAEf,KAAAC,WAAa,EAEvB,KAAAC,cAAgB,EAEhB,KAAAC,aAAe,EAEf,KAAA5C,MAAoB,GAmGpB,KAAA6C,UAAY,GAEZ,KAAAC,UAAY,EAuCd,CAxHE,eAAIZ,GACF,OAAOpwC,KAAK2wC,YACd,CAKA,aAAIN,GACF,OAAOrwC,KAAK4wC,WAAa5wC,KAAK6wC,cAAgB7wC,KAAK8wC,YACrD,CAMAG,YAAAA,CAAansC,GACX9E,KAAK4wC,WAAa9rC,CACpB,CAOAosC,UAAAA,CAAW3O,EAAgB4O,GACrB5O,GAAU,IACZviC,KAAK6wC,cAAgBtO,GAEnB4O,GAAS,IACXnxC,KAAK8wC,aAAeK,EAExB,CAOAnB,OAAAA,CAAQ/B,GAIN,OAHIjuC,KAAKoxC,iBAAiBnD,IACxBjuC,KAAKkuC,MAAMxmC,KAAKumC,GAEXjuC,IACT,CAcAqxC,UAAAA,CAAWpD,GACT,GAAIjuC,KAAKsxC,mBAAmBrD,GAC1B,IAAK,IAAIptC,EAAI,EAAGA,EAAIb,KAAKkuC,MAAMppC,OAAQjE,IACrC,GAAIb,KAAKkuC,MAAMrtC,GAAG68B,MAAQuQ,EAAKvQ,KAAM,CACnC19B,KAAKkuC,MAAMniB,OAAOlrB,EAAG,GACrB,KACF,CAGJ,OAAOb,IACT,CAoBA+uC,YAAAA,CAAa9jC,GAGX,IAAK,MAAM3J,KAAKtB,KAAKgxC,UACnB,GAAI1vC,GAAK2J,EAAM,OAEjBjL,KAAKgxC,UAAUtpC,KAAKuD,GACpBA,EAAK8lC,UAAUrpC,KAAK1H,KACtB,EAhIeywC,EAAAvD,UAAY,EA8NvB,MAAOoD,UAAiBG,EAK5Bc,SAAAA,CAAU/tC,GACRxD,KAAK2wC,aAAentC,EACpB,IAAK,MAAMyqC,KAAQjuC,KAAKkuC,MACtB,GAAID,EAAK5sC,MAAO,CACd,MAAMmwC,EAAWxxC,KAAKyxC,YAAYxD,GAC9BjuC,KAAK4wC,YAAc,GAErB5wC,KAAK0xC,gBAEPF,EAASG,UAAU,KAAMnuC,EAAK,KAAMxD,KAAKqwC,WAAW,EACtD,CAEJ,CAOAqB,aAAAA,CAAcE,EAA2B,IACvC5xC,KAAK4wC,WAAa,EAClB,IAAK,MAAM3C,KAAQjuC,KAAKkuC,MACtB,GAAID,EAAK5sC,MAAO,CACd,MAAMmwC,EAAWxxC,KAAKyxC,YAAYxD,GAClCjuC,KAAK4wC,WAAa1vC,KAAKy2B,IAAI6Z,EAASK,QAAQC,OAAQ9xC,KAAK4wC,WAC3D,CAEF,OAAO5wC,KAAK4wC,UACd,CAOUQ,gBAAAA,CAAiBnD,GAIzB,OAHIA,EAAK6B,UAAY7B,EAAK6B,UAAY9vC,MACpCiuC,EAAK6B,SAASuB,WAAWpD,GAEpBA,EAAK6B,UAAY9vC,IAC1B,CAOAsxC,kBAAAA,CAAmBrD,GACjB,OAAOA,EAAK6B,UAAY9vC,IAC1B,ECtuBW6lC,EAAiBJ,KAA9B,MACMC,EAAMG,EAAiBH,IAMvB,MAAOqM,EAqBXtuC,WAAAA,CACkB+M,EACAwhC,EACA7xC,EACAq+B,EACAwH,EACAC,EACAtV,EACAshB,EACTC,GARS,KAAA1hC,MAAAA,EACA,KAAAwhC,KAAAA,EACA,KAAA7xC,OAAAA,EACA,KAAAq+B,SAAAA,EACA,KAAAwH,SAAAA,EACA,KAAAC,UAAAA,EACA,KAAAtV,SAAAA,EACA,KAAAshB,SAAAA,EACT,KAAAC,SAAAA,EA5BA,KAAAxU,KAAOqU,EAAK7E,YAKX,KAAAiF,mBAAoB,CAwB3B,CAMHnU,UAAAA,GACE,MAAO,CACLxtB,MAAOxQ,KAAKwQ,MACZwhC,KAAMhyC,KAAKgyC,KAAKvrC,KAChBtG,OAAQH,KAAKG,OAAO+B,WACpBs8B,SAAUx+B,KAAKw+B,SAASt8B,WACxB8jC,SAAUhmC,KAAKgmC,SACfC,UAAWjmC,KAAKimC,UAChBtV,SAAU3wB,KAAK2wB,SACfoZ,KAAM/pC,KAAK+pC,KAAK/L,aAEpB,CAKA,aAAIoU,GACF,OAAOpyC,KAAKG,OAAO4jC,KAAK/jC,KAAKw+B,SAC/B,CAKA,UAAI6T,GACF,OAAOryC,KAAK40B,UAAU+O,MACxB,CAKA,aAAI/O,GACF,OAAO50B,KAAK+pC,KAAO/pC,KAAKw+B,SAASyF,MAAMjkC,KAAK+pC,KAAKvL,UAAU,GAAQx+B,KAAKw+B,QAC1E,CAOA8D,GAAAA,CAAIyH,GACF,QAAI/pC,KAAK40B,UAAUiQ,IAAIkF,EAAKvL,UAAY,IAGnCx+B,KAAK+pC,MAGH/pC,KAAKmyC,oBACRnyC,KAAKmyC,mBAAoB,EACzBnyC,KAAK+pC,KAAO,IAAIN,EAAMzpC,KAAK+pC,MAAMI,YAAYzE,GAAK,IAEnD1lC,KAAK+pC,KAAeH,UAAS,EAAMG,IANpC/pC,KAAK+pC,KAAOA,EAQP,GACT,CAMA,cAAIuI,GACF,MAAMra,EAAM,GACZ,IAAIsa,EAAoBvyC,KAAK+pC,KAC7B,KAAe,MAARwI,GAAc,CACnB,IAAK,MAAMC,KAAUD,EAAKpK,eAAiB,GACzClQ,EAAIvwB,KAAK8qC,GAGTD,EADEA,EAAK9U,MAAQqK,EAASoD,MAChBqH,EAAe7I,MAAM1wB,MAEtB,IAEX,CACA,OAAOif,CACT,CAMA,eAAIwa,GACF,MAAMxa,EAAM,GACZ,IAAIsa,EAAoBvyC,KAAK+pC,KAC7B,KAAe,MAARwI,GACLta,EAAIlM,OAAO,EAAG,KAAOwmB,EAAKlK,cAAgB,IAExCkK,EADEA,EAAK9U,MAAQqK,EAASoD,MAChBqH,EAAe7I,MAAMvH,KAEtB,KAGX,OAAOlK,CACT,EA/He8Z,EAAA7E,UAAY,E,4wBCXvB,SAAUwF,EACdC,EACAC,EACAC,GAGA,IAAMC,EAA0B,GAC1BC,EAAW,CAAC,EA+BlB,OA9BAJ,EAAMjuC,QAAQ,SAACsuC,G,QAEb,KAAMJ,EAAOI,KAASD,GAIpB,IAHA,IAAME,EAAYD,EACZE,EAAU,CAAC,EACbC,EAAgC,CAAC,CAACH,EAAM,KACrCG,EAAMruC,OAAS,GAAG,CAEvB,IADA,IAAMsuC,EAAmC,GAChCvyC,EAAI,EAAGA,EAAIsyC,EAAMruC,OAAQjE,IAAK,CAC/B,IAAA6uC,EAAA2D,EAAYF,EAAMtyC,GAAE,GAAnByyC,EAAI5D,EAAA,GAAEpuC,EAACouC,EAAA,GACd7J,EAAmB,MAARyN,GACX,IAAM/yC,EAAIsyC,EAAMS,GACZvN,EAAKwN,EAAA,GAAAF,EAAO/xC,IAAC,G,IACjB,IAAmC,IAAAkyC,GAAAC,OAAA,EAAAC,EAAAnzC,IAACozC,EAAAH,EAAAvoC,QAAA0oC,EAAAzoC,KAAAyoC,EAAAH,EAAAvoC,OAAE,CAA3B,IAAA2oC,EAAAP,EAAAM,EAAAtyC,MAAA,GAACwyC,EAAQD,EAAA,GAAEE,EAAQF,EAAA,GACxBC,GAAYZ,GAEdlN,EAAMr+B,KAAK,CAACosC,EAAUD,IACtB9N,EAAMrhC,QAAQ,SAACwnC,EAAQrrC,G,IAAR6uC,EAAA2D,EAAAnH,EAAA,GAAInY,GAAF2b,EAAA,GAAGA,EAAA,IAAS,OAACqD,EAAShf,IAAK,CAAf,GAC7B+e,EAAOprC,KAAK,CAACurC,EAAWlN,IACxBA,EAAQA,EAAMhjC,MAAM,EAAGgjC,EAAMjhC,OAAS,IAC3B8tC,EAAOiB,KAAaX,IAC/BA,EAAQN,EAAOiB,KAAa,EAC5BT,EAAS1rC,KAAK,CAACmsC,EAAQN,EAAAA,EAAA,GAAAF,EAAMtN,IAAK,IAAE,CAAC+N,EAAUD,KAAS,K,oGAI9DV,EAAQC,C,CAGd,GACON,CACT,C,MC7CYiB,E,ygCCONC,EAAiB,SAAC9c,GAAW,OAAAA,EAAEhyB,GAAF,EAkCnC+uC,GAhCA,WAIE,SAAAC,EAAYC,GAFH,KAAAz0C,KAAoB,IAAIu0C,EAG/Bj0C,KAAKm0C,QAAUA,CACjB,CAEAD,EAAA9xC,UAAAkgC,IAAA,SAAIb,EAAa2S,QAAA,IAAAA,IAAAA,EAAA,GAGf,IADA,IAAI7B,EAAOvyC,KAAKN,KACPmB,EAAIuzC,EAAWvzC,EAAI4gC,EAAO38B,OAAQjE,IAAK,CAC9C,IAAMqE,EAAMlF,KAAKm0C,QAAQ1S,EAAO5gC,IAChC,GAAI0xC,EAAKtT,SAAS/mB,IAAIhT,GACpBqtC,EAAOA,EAAKtT,SAASpnB,IAAI3S,OACpB,CACL,IAAMmvC,EAAU,IAAIJ,EACpBI,EAAQhzC,MAAQogC,EAAO5gC,GACvBwzC,EAAQvW,OAASyU,EACjBA,EAAKtT,SAASrzB,IAAI1G,EAAKmvC,GACvB9B,EAAO8B,C,EAIX,OADA9B,EAAK+B,QAAS,EACP/B,CACT,EAEApwC,OAAA2H,eAAIoqC,EAAA9xC,UAAA,aAAU,C,IAAd,WACE,OAAOpC,KAAKN,KAAKs+B,UACnB,E,+BACF,CA9BA,GAgCA,oBAAAiW,IACE,KAAAK,QAAS,EACT,KAAAjzC,MAAqB,KACrB,KAAAy8B,OAAgC,KAChC,KAAAmB,SAAW,IAAIpX,GAUjB,QARE1lB,OAAA2H,eAAImqC,EAAA7xC,UAAA,aAAU,C,IAAd,W,QACQ61B,EAAM,CAAE52B,MAAOrB,KAAKqB,MAAO49B,SAAU,CAAC,GACxCj/B,KAAKs0C,SAAQrc,EAAY,QAAI,G,IACjC,IAA2B,IAAAyX,EAAAgE,EAAA1zC,KAAKi/B,SAAS/qB,WAAS0/B,EAAAlE,EAAAzkC,QAAA2oC,EAAA1oC,KAAA0oC,EAAAlE,EAAAzkC,OAAE,CAAzC,IAAAspC,EAAAlB,EAAAO,EAAAvyC,MAAA,GAAC6D,EAAGqvC,EAAA,GAAElzC,EAAKkzC,EAAA,GACpBtc,EAAIgH,SAAS/5B,GAAO7D,EAAM28B,U,mGAE5B,OAAO/F,CACT,E,gCACFgc,CAAA,CAdA,IAgBAO,EAAA,WAKE,SAAAA,EAAYL,QAAA,IAAAA,IAAAA,EAAAH,GAJF,KAAAS,SAAgB,GAChB,KAAAC,cAA8B,CAAC,EAIvC10C,KAAKm0C,QAAUA,CACjB,CA8DF,OA5DEK,EAAApyC,UAAAiQ,MAAA,WACErS,KAAKy0C,SAAW,GAChBz0C,KAAK00C,cAAgB,CAAC,CACxB,EAKAF,EAAApyC,UAAA6b,OAAA,SAAO02B,GACL,IAAMC,EAAU,GAChB50C,KAAK00C,cAAgB,CAAC,EAEtB,IADA,IAAIG,GAAW,EACNhwC,EAAI,EAAGA,EAAI7E,KAAKy0C,SAAS3vC,OAAQD,IAAK,CAC7C,IAAMtE,EAAIP,KAAKy0C,SAAS5vC,GACnB8vC,EAAUp0C,GAMbs0C,GAAW,GAJXt0C,EAAE6R,GAAKwiC,EAAG9vC,OACV8vC,EAAGltC,KAAKnH,GACRP,KAAK00C,cAAc10C,KAAKm0C,QAAQ5zC,IAAMA,E,CAM1C,OADAP,KAAKy0C,SAAWG,EACTC,CACT,EAEA1yC,OAAA2H,eAAI0qC,EAAApyC,UAAA,UAAO,C,IAAX,WACE,OAAOpC,KAAKy0C,QACd,E,gCAEAD,EAAApyC,UAAAyV,IAAA,SAAIzF,GAEF,OADAyzB,EAAWzzB,GAAM,GAAKA,EAAKpS,KAAKy0C,SAAS3vC,QAClC9E,KAAKy0C,SAASriC,EACvB,EAEAoiC,EAAApyC,UAAA0yC,SAAA,SAAS5vC,GACP,OAAOlF,KAAK00C,cAAcxvC,IAAQ,IACpC,EAEAsvC,EAAApyC,UAAA2yC,OAAA,SAAOn9B,EAAUo9B,GAEf,QAFe,IAAAA,IAAAA,GAAA,GAEXh1C,KAAKkY,IAAIN,GAAQ,CACnB,GAAIo9B,EAAe,MAAM,IAAInpC,MAAM,SAAA4C,OAASzO,KAAKm0C,QAAQv8B,GAAM,oBAC/D,OAAO5X,KAAK00C,cAAc10C,KAAKm0C,QAAQv8B,G,CAKvC,OAHA5X,KAAK00C,cAAc10C,KAAKm0C,QAAQv8B,IAAUA,EAC1CA,EAAMxF,GAAKpS,KAAKy0C,SAAS3vC,OACzB9E,KAAKy0C,SAAS/sC,KAAKkQ,GACZA,CAEX,EAEA48B,EAAApyC,UAAA8V,IAAA,SAAIN,GACF,OAAO5X,KAAKm0C,QAAQv8B,KAAU5X,KAAK00C,aACrC,EAEAvyC,OAAA2H,eAAI0qC,EAAApyC,UAAA,OAAI,C,IAAR,WACE,OAAOpC,KAAKy0C,SAAS3vC,MACvB,E,gCACF0vC,CAAA,CArEA,GAuEAS,EAAA,WAME,SAAAA,EAAYC,EAAkBC,QAAA,IAAAA,IAAAA,GAAA,GAH9B,KAAAjhC,QAAU,IAAIkhC,IACd,KAAAC,SAAU,EAGRr1C,KAAKk1C,QAAUA,EACfl1C,KAAKm1C,kBAAoBA,CAC3B,CAoDF,OAlDEhzC,OAAA2H,eAAImrC,EAAA7yC,UAAA,cAAW,C,IAAf,WACE,MAAO,IAAMpC,KAAKs1C,SAASC,OAAO7mC,KAAK,MAAQ,GACjD,E,gCAEAumC,EAAA7yC,UAAAkzC,OAAA,SAAOE,G,aAAA,IAAAA,IAAAA,GAAA,GACL,IAAMvd,EAAgB,G,IACtB,IAAgB,IAAAyX,EAAAgE,EAAA1zC,KAAKkU,SAAO0/B,EAAAlE,EAAAzkC,QAAA2oC,EAAA1oC,KAAA0oC,EAAAlE,EAAAzkC,OAAE,CAAzB,IAAMpK,EAAC+yC,EAAAvyC,MACJo0C,EAAMz1C,KAAKk1C,QAAQQ,WAAW70C,GACpCglC,EAAkB,MAAP4P,GACND,GAAYC,EAAIE,aAAa1d,EAAIvwB,KAAK+tC,EAAIG,M,mGAGjD,OADI51C,KAAKq1C,SAASpd,EAAIvwB,KAAK,IACpBuwB,CACT,EAEAgd,EAAA7yC,UAAAyzC,QAAA,SAAQ5X,EAAoB6X,GAC1B,YAD0B,IAAAA,IAAAA,GAAA,GACnB7X,EAAQ8X,MAAM/1C,KAAM81C,EAC7B,EAEAb,EAAA7yC,UAAA2zC,MAAA,SAAM9X,EAAoB6X,G,aAAA,IAAAA,IAAAA,GAAA,GACxB,IAAMvT,EAAStE,EAAQ/pB,QAAQ+S,K,IAC/B,IAAqB,IAAAyoB,EAAAgE,EAAA1zC,KAAKkU,SAAO0/B,EAAAlE,EAAAzkC,QAAA2oC,EAAA1oC,KAAA0oC,EAAAlE,EAAAzkC,OAAE,CAA9B,IAAM+qC,EAAMpC,EAAAvyC,MACf48B,EAAQ/pB,QAAQouB,IAAI0T,E,mGAKtB,OAHIF,IACF7X,EAAQoX,QAAUr1C,KAAKq1C,SAAWpX,EAAQoX,SAErCpX,EAAQ/pB,QAAQ+S,KAAOsb,CAChC,EAEA0S,EAAA7yC,UAAA8V,IAAA,SAAI+9B,GACF,OAAOj2C,KAAKkU,QAAQgE,IAAI+9B,EAAK7jC,GAC/B,EAEA6iC,EAAA7yC,UAAAkgC,IAAA,SAAI2T,GAMF,OALApQ,EAC4B,MAA1B7lC,KAAKm1C,mBAA6Bn1C,KAAKm1C,mBAAqBc,EAAKC,WACjE,kCAAAznC,OAAkCzO,KAAKm1C,oBAEzCn1C,KAAKkU,QAAQouB,IAAI2T,EAAK7jC,IACfpS,IACT,EAEAi1C,EAAA7yC,UAAAgW,OAAA,SAAO69B,GACL,OAAOj2C,KAAKkU,QAAQkE,OAAO69B,EAAK7jC,GAClC,EAEAjQ,OAAA2H,eAAImrC,EAAA7yC,UAAA,OAAI,C,IAAR,WACE,OAAOpC,KAAKkU,QAAQ+S,MAAQjnB,KAAKq1C,QAAU,EAAI,EACjD,E,gCACFJ,CAAA,CA7DA,GAkEAkB,EAAA,WAKE,SAAAA,EAAYjB,GACVl1C,KAAKk1C,QAAUA,EACfl1C,KAAKo2C,SACP,CAqDF,OAnDEj0C,OAAA2H,eAAIqsC,EAAA/zC,UAAA,WAAQ,C,IAAZ,eAAAi0C,EAAA,KACQpe,EAAa,GAMnB,OALAj4B,KAAKkU,QAAQxP,QAAQ,SAAC0N,GACpB,IAAM7R,EAAI81C,EAAKnB,QAAQQ,WAAWtjC,GAClCyzB,EAAgB,MAALtlC,IAAcA,EAAE21C,YAC3Bje,EAAIvwB,KAAKnH,EACX,GACO03B,CACT,E,gCAEAke,EAAA/zC,UAAAg0C,QAAA,eAAAC,EAAA,KAEEr2C,KAAKkU,QAAU,IAAIkhC,IACnBp1C,KAAKkzC,QAAU,CAAC,EAEhB,IAAIoD,EAAc,EAClB,GACEA,EAAct2C,KAAKkU,QAAQ+S,KAC3BjnB,KAAKk1C,QAAQqB,gBAAgB7xC,QAAQ,SAAC8xC,GAAO,OAAAH,EAAKvpC,MAAM0pC,EAAX,SACtCF,GAAet2C,KAAKkU,QAAQ+S,KACvC,EAEUkvB,EAAA/zC,UAAA0K,MAAV,SAAgB0pC,G,YACd,IAAmB,IAAA9G,EAAAgE,EAAA1zC,KAAKk1C,QAAQuB,WAAWD,IAAG5C,EAAAlE,EAAAzkC,QAAA2oC,EAAA1oC,KAAA0oC,EAAAlE,EAAAzkC,OAAE,CAA3C,IAAMyrC,EAAI9C,EAAAvyC,MACb,GAAIrB,KAAK22C,cAAcD,EAAKE,KAAM,CAChC52C,KAAKsiC,IAAIkU,GACT,K,oGAGN,EAEAL,EAAA/zC,UAAAy0C,WAAA,SAAWL,GACT,OAAQA,EAAGN,YAAcl2C,KAAKkU,QAAQgE,IAAIs+B,EAAGpkC,GAC/C,EAEA+jC,EAAA/zC,UAAAu0C,cAAA,SAAc9zC,EAAUuxC,EAAe0C,QAAf,IAAA1C,IAAAA,EAAA,QAAe,IAAA0C,IAAAA,EAAA,MACtB,MAAXA,IACFA,EAAUj0C,EAAIiC,OAAS,GAEzB,IAAK,IAAIjE,EAAIuzC,EAAWvzC,GAAKi2C,EAASj2C,IACpC,IAAKb,KAAK62C,WAAWh0C,EAAIk0C,KAAKl2C,IAC5B,OAAO,EAGX,OAAO,CACT,EAEAs1C,EAAA/zC,UAAAkgC,IAAA,SAAIkU,GACF3Q,GAAY2Q,EAAGN,YACfl2C,KAAKkU,QAAQouB,IAAIkU,EAAGpkC,GACtB,EACF+jC,CAAA,CA7DA,GA+DAa,GAAA,WAKE,SAAAA,EAAY9B,GAHZ,KAAAhhC,QAA6B,CAAC,EACtB,KAAA+iC,OAAS,EAGfj3C,KAAKk1C,QAAUA,CACjB,CA2EF,OAzEE8B,EAAA50C,UAAAg0C,QAAA,WACEp2C,KAAKkU,QAAU,CAAC,EAChBlU,KAAKi3C,OAAS,CAChB,EAEAD,EAAA50C,UAAA80C,YAAA,SAAYV,EAAS5mC,GAArB,IAAAymC,EAAA,KACQniC,EAAUlU,KAAKm3C,WAAWX,GAChCtiC,EAAQA,QAAQxP,QAAQ,SAACwyB,GACvB,IAAM+e,EAAOI,EAAKnB,QAAQQ,WAAWxe,GACrC2O,EAAmB,MAARoQ,GAAgBA,EAAKC,YAChCtmC,EAAQqmC,EACV,GACI/hC,EAAQmhC,SAASzlC,EAAQ,KAC/B,EAEAzN,OAAA2H,eAAIktC,EAAA50C,UAAA,aAAU,C,IAAd,WACE,IAAM61B,EAAM,CAAC,EACb,IAAK,IAAMf,KAAKl3B,KAAKkU,QAAS+jB,EAAIj4B,KAAKk1C,QAAQQ,WAAWxe,GAAW0e,OAAS51C,KAAKkU,QAAQgjB,GAAGkgB,YAC9F,OAAOnf,CACT,E,gCAEA91B,OAAA2H,eAAIktC,EAAA50C,UAAA,QAAK,C,IAAT,WACE,IAAId,EAAI,EACR,IAAK,IAAM41B,KAAKl3B,KAAKkU,QAAS5S,GAAKtB,KAAKkU,QAAQgjB,GAAGjQ,KACnD,OAAO3lB,CAGT,E,gCAEA01C,EAAA50C,UAAA+0C,WAAA,SAAWE,GACT,GAAIA,EAAIjlC,MAAMpS,KAAKkU,QACjB,OAAOlU,KAAKkU,QAAQmjC,EAAIjlC,IAExB,IAAM6lB,EAAM,IAAIgd,EAAUj1C,KAAKk1C,SAE/B,OADAl1C,KAAKkU,QAAQmjC,EAAIjlC,IAAM6lB,EAChBA,CAEX,EAKA+e,EAAA50C,UAAAk1C,QAAA,SAAQd,GACN,IAAMtiC,EAAUlU,KAAKm3C,WAAWX,GAChC,OAAItiC,EAAQmhC,UACZnhC,EAAQmhC,SAAU,GACX,EACT,EAQA2B,EAAA50C,UAAAkgC,IAAA,SAAIkU,EAASlvC,EAAawuC,QAAA,IAAAA,IAAAA,GAAA,GACpBU,EAAGN,YACLrQ,GAAW,EAAO,sBAEpB,IAAM3xB,EAAUlU,KAAKm3C,WAAWX,GAChC,GAAIlvC,EAAO4uC,WAAY,CACrB,GAAIhiC,EAAQgE,IAAI5Q,GAAS,OAAO,EAEhC4M,EAAQouB,IAAIh7B,GACZtH,KAAKi3C,Q,KACA,CACL,IAAMM,EAAav3C,KAAKm3C,WAAW7vC,GAC7BkwC,EAAcx3C,KAAKm3C,WAAWX,GAC9B1U,EAAQyV,EAAWxB,MAAMyB,EAAa1B,GAC5C91C,KAAKi3C,QAAUnV,C,CAEjB,OAAO,CACT,EACFkV,CAAA,CAlFA,GAwFAS,GAAA,SAAAC,GAGE,SAAAD,EAAYvC,EAAkByC,GAA9B,IAAAtB,EACEqB,EAAA50C,KAAA,KAAMoyC,IAAQ,K,OACTyC,IACHA,EAAY,IAAIxB,EAAYjB,IAE9BmB,EAAKsB,UAAYA,EACjBtB,EAAKD,U,CACP,CAiEF,OA3E+BwB,EAAAH,EAAAC,GAgB7BD,EAAAr1C,UAAAy1C,cAAA,SAAch1C,EAAUuxC,EAAexkC,QAAf,IAAAwkC,IAAAA,EAAA,GAKtB,IAHA,IAAM2C,EAAOl0C,EAAIk0C,KACX7D,EAAU,CAAC,EACb4E,GAAc,EACTpjB,EAAI0f,EAAW0D,GAAepjB,EAAIqiB,EAAKjyC,OAAQ4vB,IAAK,CAC3D,IAAMqjB,EAAOhB,EAAKriB,GAClB,GAAIqjB,EAAK7B,WACPtmC,EAAQmoC,GACRD,GAAc,MACT,CACL,IAAMtB,EAAKuB,EACX/3C,KAAKk3C,YAAYV,EAAI,SAACP,GACR,MAARA,GAAkBA,EAAK7jC,MAAM8gC,IAC/BA,EAAQ+C,EAAK7jC,KAAM,EACnBxC,EAAQqmC,GAEZ,GACKj2C,KAAK23C,UAAUd,WAAWkB,KAC7BD,GAAc,E,EAIhBA,GAAaloC,EAAQ,KAC3B,EAMA6nC,EAAAr1C,UAAAg0C,QAAA,eAAAC,EAAA,KACEqB,EAAAt1C,UAAMg0C,QAAOtzC,KAAC,MAGd,IAAIwzC,EAAc,EAClB,GACEA,EAAct2C,KAAK8hC,MACnB9hC,KAAKk1C,QAAQ8C,YAAY,KAAM,SAACtB,GAC9BL,EAAK4B,YAAYvB,EACnB,SACOJ,GAAet2C,KAAK8hC,MAC/B,EAEA2V,EAAAr1C,UAAA61C,YAAA,SAAYvB,G,QACJiB,EAAY33C,KAAK23C,UACnBG,GAAc,E,IAClB,IAAgB,IAAApI,EAAAgE,EAAAgD,EAAKE,IAAIG,MAAInD,EAAAlE,EAAAzkC,QAAA2oC,EAAA1oC,KAAA0oC,EAAAlE,EAAAzkC,OAAE,CAA1B,IAAMlK,EAAC6yC,EAAAvyC,MAIV,GADArB,KAAKsiC,IAAIoU,EAAKF,GAAIz1C,GAAG,GACjBA,EAAEm1C,aAAeyB,EAAUd,WAAW91C,GAAW,CAGnD+2C,GAAc,EACd,K,oGAGAA,GAAa93C,KAAKs3C,QAAQZ,EAAKF,GACrC,EACFiB,CAAA,CA3EA,CAA+BT,IAiF/BkB,GAAA,SAAAR,GAGE,SAAAQ,EAAYhD,EAAkBiD,GAA9B,IAAA9B,EACEqB,EAAA50C,KAAA,KAAMoyC,IAAQ,K,OACdmB,EAAK8B,UAAYA,GAAa,IAAIV,GAAUvC,GAC5CmB,EAAKD,U,CACP,CAgEF,OAvEgCwB,EAAAM,EAAAR,GAS9Bv1C,OAAA2H,eAAIouC,EAAA91C,UAAA,YAAS,C,IAAb,WACE,OAAOpC,KAAKm4C,UAAUR,SACxB,E,gCAOAO,EAAA91C,UAAAg0C,QAAA,eAAAC,EAAA,KACEqB,EAAAt1C,UAAMg0C,QAAOtzC,KAAC,MACd,IAAMw6B,EAAIt9B,KAAKk1C,QACfrP,EAA4B,MAAjBvI,EAAE8a,YAAqB,sCAClCp4C,KAAKsiC,IAAIhF,EAAE8a,YAAa9a,EAAE+a,KAE1B,IAAI/B,EAAc,EAClB,GACEA,EAAct2C,KAAK8hC,MACnB9hC,KAAKk1C,QAAQ8C,YAAY,KAAM,SAACtB,GAAS,OAAAL,EAAK4B,YAAYvB,EAAjB,SAClCJ,GAAet2C,KAAK8hC,MAC/B,EAKAoW,EAAA91C,UAAA61C,YAAA,SAAYvB,GAQV,IARF,IAAAL,EAAA,KACQU,EAAOL,EAAKE,IAAIG,KAChBoB,EAAYn4C,KAAKm4C,UACjBR,EAAY33C,KAAKm4C,UAAUR,U,WAKxB92C,GACP,IAAMw2C,EAAMN,EAAKl2C,GACjB,GAAIw2C,EAAInB,W,iBACRiC,EAAUN,cAAcnB,EAAKE,IAAK/1C,EAAI,EAAG,SAACo1C,GAC5B,MAARA,GAAcI,EAAK/T,IAAI+U,EAAKpB,EAClC,E,EALOp1C,EAAI,EAAGA,EAAIk2C,EAAKjyC,OAAQjE,I,EAAxBA,GAYT,IAASA,EAAIk2C,EAAKjyC,OAAS,EAAGjE,GAAK,EAAGA,IACpC,IAAIk2C,EAAKl2C,GAAGq1C,WAAZ,CAIA,IADA,IAAI4B,GAAc,EACTpjB,EAAI7zB,EAAI,EAAG6zB,EAAIqiB,EAAKjyC,OAAQ4vB,IAAK,CACxC,IAAMqjB,EAAOhB,EAAKriB,GAClB,GAAIqjB,EAAK7B,aAAeyB,EAAUd,WAAWkB,GAAc,CACzDD,GAAc,EACd,K,EAGAA,GACF93C,KAAKsiC,IAAIyU,EAAKl2C,GAAI61C,EAAKF,GAZO,CAepC,EACF0B,CAAA,CAvEA,CAAgClB,I,2wBCxZhCsB,GAAA,WA2BE,SAAAA,EACkBpD,EACAU,EACTM,EACP9jC,QAAA,IAAAA,IAAAA,EAAA,MAHgB,KAAA8iC,QAAAA,EACA,KAAAU,MAAAA,EACT,KAAAM,WAAAA,EA7BT,KAAAP,aAAc,EACd,KAAA4C,QAAyB,KACzB,KAAAC,WAAa,EACb,KAAAC,WAAY,EAOZ,KAAAC,YAAc,EAsBZ14C,KAAKk2C,WAAaA,EAClBl2C,KAAK41C,MAAQA,EAEX51C,KAAKoS,GADG,MAANA,EACQkmC,EAAIpL,YAEJ96B,CAEd,CAaF,OAXEkmC,EAAAl2C,UAAAu2C,UAAA,SAAU1a,GACR,OAAOj+B,KAAK41C,MAAMgD,cAAc3a,EAAQ2X,MAC1C,EAEA0C,EAAAl2C,UAAAq1B,OAAA,SAAOwG,GACL,OAAOj+B,KAAK41C,OAAS3X,EAAQ2X,KAC/B,EAEA0C,EAAAl2C,UAAAF,SAAA,WACE,OAAOlC,KAAK41C,KACd,EA9Ce0C,EAAApL,WAAa,EA+C9BoL,C,CArDA,GAuDAO,GAAA,WAGE,SAAAA,I,IAAY,IAAA9B,EAAA,GAAA+B,EAAA,EAAAA,EAAA72C,UAAA6C,OAAAg0C,IAAA/B,EAAA+B,GAAA72C,UAAA62C,GACV94C,KAAK+2C,KAAOA,GAAQ,EACtB,CAqEF,OAnEE8B,EAAAz2C,UAAAgG,OAAA,W,YAAO2wC,EAAA,GAAAD,EAAA,EAAAA,EAAA72C,UAAA6C,OAAAg0C,IAAAC,EAAAD,GAAA72C,UAAA62C,G,IACL,IAAgB,IAAAE,EAAAtF,GAAAqF,GAAIE,EAAAD,EAAA/tC,QAAAguC,EAAA/tC,KAAA+tC,EAAAD,EAAA/tC,OAAA,CAAf,IAAMpG,EAACo0C,EAAA53C,MAAUrB,KAAK+2C,KAAKrvC,KAAK7C,E,mGACrC,OAAO7E,IACT,EAEA64C,EAAAz2C,UAAA+G,OAAA,W,YAAO+vC,EAAA,GAAAJ,EAAA,EAAAA,EAAA72C,UAAA6C,OAAAg0C,IAAAI,EAAAJ,GAAA72C,UAAA62C,G,IACL,IAAgB,IAAAK,EAAAzF,GAAAwF,GAAIE,EAAAD,EAAAluC,QAAAmuC,EAAAluC,KAAAkuC,EAAAD,EAAAluC,OAAA,CAAf,IAAMlK,EAACq4C,EAAA/3C,MAAUrB,KAAKoI,OAAMpG,MAAXhC,KAAIuzC,GAAA,GAAAF,GAAWtyC,EAAEg2C,OAAI,G,mGAC3C,OAAO/2C,IACT,EAEA64C,EAAAz2C,UAAAywB,KAAA,WACE,OAAO,IAAIgmB,EAAGh3C,KAAAG,MAAH62C,EAAGtF,GAAC,MAAD,GAAAF,GAAIrzC,KAAK+2C,OAAI,IAC7B,EAEA8B,EAAAz2C,UAAAkgC,IAAA,SAAIiH,GACFvpC,KAAK+2C,KAAKrvC,KAAK6hC,EACjB,EAEAsP,EAAAz2C,UAAA8zC,WAAA,SAAW1lC,GACT,OAAOxQ,KAAK+2C,KAAKvmC,GAAO0lC,UAC1B,EAEA/zC,OAAA2H,eAAI+uC,EAAAz2C,UAAA,SAAM,C,IAAV,WACE,OAAOpC,KAAK+2C,KAAKjyC,MACnB,E,gCAEA+zC,EAAAz2C,UAAAF,SAAA,WACE,OAAOlC,KAAK+2C,KAAKtyC,IAAI,SAAC1D,GAAM,OAAAA,EAAEmB,UAAF,GAAcwM,KAAK,IACjD,EAEAmqC,EAAAz2C,UAAAW,MAAA,SAAMs2C,EAAoBC,GACxB,OAAO,IAAIT,EAAGh3C,KAAAG,MAAH62C,EAAGtF,GAAC,MAAD,GAAAF,GAAIrzC,KAAK+2C,KAAKh0C,MAAMs2C,EAAYC,KAAS,IACzD,EAEAT,EAAAz2C,UAAA2pB,OAAA,SAAOvb,EAAe+oC,G,UAAqBC,EAAA,GAAAV,EAAA,EAAAA,EAAA72C,UAAA6C,OAAAg0C,IAAAU,EAAAV,EAAA,GAAA72C,UAAA62C,GAEzC,OADA5M,EAAAlsC,KAAK+2C,MAAKhrB,OAAM/pB,MAAAkqC,EAAAqH,GAAC,CAAA/iC,EAAO+oC,GAAWlG,GAAKmG,IAAU,IAC3Cx5C,IACT,EAEA64C,EAAAz2C,UAAAu2C,UAAA,SAAU1a,GACR,IAAK,IAAIp9B,EAAI,EAAGA,EAAIb,KAAK+2C,KAAKjyC,QAAUjE,EAAIo9B,EAAQ8Y,KAAKjyC,OAAQjE,IAAK,CACpE,IAAM44C,EAAOz5C,KAAK+2C,KAAKl2C,GAAG83C,UAAU1a,EAAQ8Y,KAAKl2C,IACjD,GAAY,GAAR44C,EAAW,OAAOA,C,CAExB,OAAOz5C,KAAK+2C,KAAKjyC,OAASm5B,EAAQ8Y,KAAKjyC,MACzC,EAEA+zC,EAAAz2C,UAAAq1B,OAAA,SAAOwG,GACL,OAAkC,GAA3Bj+B,KAAK24C,UAAU1a,EACxB,EAMA4a,EAAAz2C,UAAAs3C,WAAA,SAAWv5C,EAAgB89B,GAEzB,IADA,IAAIp9B,EAAI,EACDA,EAAIo9B,EAAQn5B,QAAU3E,EAASU,EAAIb,KAAK+2C,KAAKjyC,OAAQjE,IAC1D,IAAKb,KAAK+2C,KAAK52C,EAASU,GAAG42B,OAAOwG,EAAQ8Y,KAAKl2C,IAAK,OAAO,EAG7D,OAAOA,GAAKo9B,EAAQn5B,MACtB,EAEA3C,OAAA2H,eAAI+uC,EAAAz2C,UAAA,cAAW,C,IAAf,WACE,OAAOpC,KAAK+2C,KAAKtyC,IAAI,SAAC8kC,GAAQ,OAAAA,EAAIqM,KAAJ,GAAWlnC,KAAK,IAChD,E,gCACFmqC,CAAA,CA1EA,GA4EAc,GAAA,WACE,SAAAA,EAAmBt4C,GAAA,KAAAA,MAAAA,CAAyB,CAS9C,OAPEc,OAAA2H,eAAI6vC,EAAAv3C,UAAA,aAAU,C,IAAd,WACE,MAA6B,iBAAfpC,KAAKqB,KACrB,E,gCAEAc,OAAA2H,eAAI6vC,EAAAv3C,UAAA,kBAAe,C,IAAnB,WACE,MAA6B,iBAAfpC,KAAKqB,KACrB,E,gCACFs4C,CAAA,CAVA,GAYAC,GAAA,WAEE,SAAAA,EAAmBpD,EAAgBI,EAAiBiD,GAClD,QADkD,IAAAA,IAAAA,EAAA,MAAjC,KAAArD,GAAAA,EAAgB,KAAAI,IAAAA,EAAiB,KAAAiD,OAAAA,EAC9CrD,EAAGN,WACL,MAAM,IAAIrqC,MAAM,iCAEpB,CAkBF,OAhBE1J,OAAA2H,eAAI8vC,EAAAx3C,UAAA,cAAW,C,IAAf,WACE,MAAO,GAAAqM,OAAGzO,KAAKw2C,GAAGZ,MAAK,QAAAnnC,OAAOzO,KAAK42C,IAAIQ,YACzC,E,gCAEAwC,EAAAx3C,UAAAq1B,OAAA,SAAOwG,GACL,OAAkC,GAA3Bj+B,KAAK24C,UAAU1a,EACxB,EAEA2b,EAAAx3C,UAAAu2C,UAAA,SAAU1a,GACR4H,GAAYpkC,MAAMzB,KAAKoS,KACvB,IAAMqnC,EAAOz5C,KAAKw2C,GAAGmC,UAAU1a,EAAQuY,IAIvC,OAHY,GAARiD,GACFz5C,KAAK42C,IAAI+B,UAAU1a,EAAQ2Y,KAEtB6C,CACT,EACFG,CAAA,CAxBA,GA0BAE,GAAA,WA2BE,SAAAA,EAAYtsC,GA1BL,KAAA4qC,YAA6B,KACpC,KAAAvD,UAAW,EACD,KAAAkF,UAAY,IAAIvF,EAAW,SAACzzC,GAAM,OAAAA,EAAE60C,KAAF,GAClC,KAAAoE,SAAmB,GACnB,KAAAC,YAA2C,KAC3C,KAAAC,YAAoC,KAUtC,KAAAC,UAAW,EA6dT,KAAAC,WAAa,EAjdrB5sC,EAASA,GAAU,CAAC,EACpBxN,KAAKq6C,YAAc7sC,EAAO6sC,aAAe,IACzCr6C,KAAKs6C,KAAOt6C,KAAKu6C,QAAQ,IACzBv6C,KAAKq4C,IAAMr4C,KAAKu6C,QAAQ,OAC1B,CA+nBF,OA1oBST,EAAAU,KAAP,SAAYxpB,GACV,IAAMsM,EAAI,IAAIwc,EAEd,OADA9oB,EAASsM,GACFA,CACT,EASAwc,EAAA13C,UAAAq0C,WAAA,SAAWD,G,QAET,GADA3Q,GAAY2Q,EAAGN,YACS,MAApBl2C,KAAKi6C,YAAqB,CAC5Bj6C,KAAKi6C,YAAc,CAAC,E,IACpB,IAAmB,IAAAvK,EAAAgE,GAAA1zC,KAAKg6C,UAAQpG,EAAAlE,EAAAzkC,QAAA2oC,EAAA1oC,KAAA0oC,EAAAlE,EAAAzkC,OAAE,CAA7B,IAAMyrC,EAAI9C,EAAAvyC,MACPq1C,EAAKF,GAAGZ,SAAS51C,KAAKi6C,cAC1Bj6C,KAAKi6C,YAAYvD,EAAKF,GAAGZ,OAAS,IAEpC51C,KAAKi6C,YAAYvD,EAAKF,GAAGZ,OAAOluC,KAAKgvC,E,oGAMzC,OAHMF,EAAGZ,SAAS51C,KAAKi6C,cACrBj6C,KAAKi6C,YAAYzD,EAAGZ,OAAS,IAExB51C,KAAKi6C,YAAYzD,EAAGZ,MAC7B,EAEAzzC,OAAA2H,eAAIgwC,EAAA13C,UAAA,YAAS,C,IAAb,WACE,OAAOpC,KAAKm4C,UAAUR,SACxB,E,gCAEAx1C,OAAA2H,eAAIgwC,EAAA13C,UAAA,YAAS,C,IAAb,WACE,OAAOpC,KAAKy6C,WAAWtC,SACzB,E,gCAEAh2C,OAAA2H,eAAIgwC,EAAA13C,UAAA,aAAU,C,IAAd,WAKE,OAJIpC,KAAK60C,UAAgC,MAApB70C,KAAKk6C,cACxBl6C,KAAKo2C,UAEPvQ,EAA+B,MAApB7lC,KAAKk6C,aACTl6C,KAAKk6C,WACd,E,gCAEA/3C,OAAA2H,eAAIgwC,EAAA13C,UAAA,eAAY,C,IAAhB,WACE,OAAOpC,KAAK06C,aACd,E,gCAEAZ,EAAA13C,UAAAu4C,mBAAA,SAAmB/E,QAAA,IAAAA,IAAAA,EAAA,WACjB/P,EAAiC,MAAtB7lC,KAAK06C,cAAuB,mDACvC7U,EAA+B,MAApB7lC,KAAKo4C,YAAqB,4BACrC,IAAMwC,EAAS56C,KAAK66C,MAAMjF,GAG1B,OAFA51C,KAAK06C,cAAgB,IAAId,GAAKgB,EAAQ,IAAI/B,GAAI74C,KAAKo4C,cACnDp4C,KAAK86C,QAAQ96C,KAAK06C,cAAe,GAC1B16C,IACT,EAEA85C,EAAA13C,UAAAg0C,QAAA,WAQE,OAPAp2C,KAAK+5C,UAAU7lC,QAAQxP,QAAQ,SAAC3D,EAAGF,GAAM,OAACE,EAAEqR,GAAKvR,CAAR,GACzCb,KAAKi6C,YAAc,KACnBj6C,KAAKg6C,SAASt1C,QAAQ,SAACgyC,EAAM71C,GAC3B61C,EAAKtkC,GAAKvR,CACZ,GACAb,KAAKk6C,YAAc,IAAIhC,GAAWl4C,MAClCA,KAAK60C,UAAW,EACT70C,IACT,EAEA85C,EAAA13C,UAAA24C,aAAA,W,YAAaC,EAAA,GAAAlC,EAAA,EAAAA,EAAA72C,UAAA6C,OAAAg0C,IAAAkC,EAAAlC,GAAA72C,UAAA62C,G,IACX,IAAgB,IAAAmC,EAAAvH,GAAAsH,GAASE,EAAAD,EAAAhwC,QAAAiwC,EAAAhwC,KAAAgwC,EAAAD,EAAAhwC,OAAE,CAAtB,IAAM63B,EAACoY,EAAA75C,MACVrB,KAAKu6C,QAAQzX,E,mGAEjB,EAEA3gC,OAAA2H,eAAIgwC,EAAA13C,UAAA,YAAS,C,IAAb,WACE,OAAOpC,KAAK+5C,UAAU7lC,QAAQ/J,OAAO,SAAC+sB,GAAM,OAAAA,EAAEgf,UAAF,EAC9C,E,gCAEA/zC,OAAA2H,eAAIgwC,EAAA13C,UAAA,kBAAe,C,IAAnB,WACE,OAAOpC,KAAK+5C,UAAU7lC,QAAQ/J,OAAO,SAAC+sB,GAAM,OAACA,EAAEgf,UAAH,EAC9C,E,gCAEA/zC,OAAA2H,eAAIgwC,EAAA13C,UAAA,eAAY,C,IAAhB,WACE,OAAOpC,KAAK+5C,UAAU7lC,QAAQ/J,OAAO,SAAC+sB,GAAM,OAACA,EAAEgf,aAAehf,EAAEye,WAApB,EAC9C,E,gCAEAxzC,OAAA2H,eAAIgwC,EAAA13C,UAAA,kBAAe,C,IAAnB,WACE,OAAOpC,KAAK+5C,UAAU7lC,QAAQ/J,OAAO,SAAC+sB,GAAM,OAAAA,EAAEye,WAAF,EAC9C,E,gCAEAxzC,OAAA2H,eAAIgwC,EAAA13C,UAAA,aAAU,C,IAAd,WACE,OAAOpC,KAAK+5C,UAAU7lC,OACxB,E,gCAKA4lC,EAAA13C,UAAA+4C,UAAA,SAAUvrC,G,YACR,IAAkB,IAAA8/B,EAAAgE,GAAA1zC,KAAK+5C,UAAU7lC,SAAO0/B,EAAAlE,EAAAzkC,QAAA2oC,EAAA1oC,KAAA0oC,EAAAlE,EAAAzkC,OAAE,CAArC,IAAMosC,EAAGzD,EAAAvyC,MACZ,IAAIg2C,EAAInB,YACY,GAAhBtmC,EAAQynC,GAAe,M,mGAE/B,EAQAyC,EAAA13C,UAAA41C,YAAA,SAAYxB,EAAmB5mC,GAE7B,IADA,IAAMwrC,EAAc,MAAN5E,EAAax2C,KAAKg6C,SAAWh6C,KAAKy2C,WAAWD,IAAO,GACzD31C,EAAI,EAAGA,EAAIu6C,EAAMt2C,OAAQjE,IAChC,GAA4B,GAAxB+O,EAAQwrC,EAAMv6C,GAAIA,GAAa,OAAO,EAE5C,OAAO,CACT,EAEAi5C,EAAA13C,UAAAi5C,QAAA,SAAQ7E,EAAkBhmC,GAGxB,MAFkB,iBAAPgmC,IAAiBA,EAAKx2C,KAAKs7C,OAAO9E,IAC7C3Q,EAAiB,MAAN2Q,GACJx2C,KAAKy2C,WAAWD,GAAIhmC,EAC7B,EAKAspC,EAAA13C,UAAAm5C,SAAA,SAAS/E,EAASgF,GAChB,OAAOx7C,KAAKy2C,WAAWD,GAAIiF,UAAU,SAAClO,GAAM,OAAAA,EAAEiJ,IAAMA,GAAMjJ,EAAEqJ,IAAInf,OAAO+jB,EAA3B,EAC9C,EAUA1B,EAAA13C,UAAAkgC,IAAA,SAAIkU,EAAkBgF,EAAiB3B,QAAA,IAAAA,IAAAA,EAAA,MACrC,IAAI6B,EAAyB,KAU7B,MATkB,iBAAPlF,EAEM,OADfkF,EAAU17C,KAAKs7C,OAAO9E,MAGpBkF,EAAU17C,KAAK66C,MAAMrE,IAGvBkF,EAAU17C,KAAK27C,UAAUnF,GAEpBx2C,KAAK86C,QAAQ,IAAIlB,GAAK8B,EAASF,EAAY3B,GACpD,EAKAC,EAAA13C,UAAA04C,QAAA,SAAQpE,EAAYlmC,GAClB,QADkB,IAAAA,IAAAA,GAAS,GACvBxQ,KAAKu7C,SAAS7E,EAAKF,GAAIE,EAAKE,MAAQ,EACtC,MAAM,IAAI/qC,MAAM,mBAAqB6qC,EAAKU,aAY5C,OAVAV,EAAKtkC,GAAKpS,KAAKg6C,SAASl1C,OACD,GAAnB4xC,EAAKE,IAAI9xC,SAAa9E,KAAKm6C,UAAW,GACtC3pC,EAAQ,EACVxQ,KAAKg6C,SAAStyC,KAAKgvC,GAEnB12C,KAAKg6C,SAASjuB,OAAOvb,EAAO,EAAGkmC,GAEjC12C,KAAKi6C,YAAc,KAEnBj6C,KAAK60C,UAAW,EACT6B,CACT,EAKAoD,EAAA13C,UAAAw5C,YAAA,SAAYC,GAIV,OAHA77C,KAAKg6C,SAAWh6C,KAAKg6C,SAAS7vC,OAAO,SAACojC,GAAM,OAACsO,EAAKtO,EAAN,GAC5CvtC,KAAKi6C,YAAc,KACnBj6C,KAAK60C,UAAW,GACT,CACT,EAMAiF,EAAA13C,UAAA05C,cAAA,SAAcD,GACZ,IAAIhH,GAAW,EACTkH,EAAmB,GAiBzB,OAhBA/7C,KAAKg6C,SAASt1C,QAAQ,SAAC6oC,GACrB,IAAIsO,EAAKtO,EAAEiJ,IAEX,GAAoB,GAAhBjJ,EAAEqJ,IAAI9xC,OACRi3C,EAASr0C,KAAK6lC,OACT,CACL,IAAMyO,EAAS,IAAInD,GAAGh3C,KAAAG,MAAH62C,GAAGtF,GAAC,MAAD,GAAAF,GAAI9F,EAAEqJ,IAAIG,KAAK5sC,OAAO,SAACpJ,GAAM,OAAC86C,EAAK96C,EAAN,KAAS,KAC5D8zC,EAAWA,GAAYtH,EAAEqJ,IAAI9xC,QAAUk3C,EAAOl3C,OAC1Ck3C,EAAOl3C,OAAS,GAClBi3C,EAASr0C,KAAK,IAAIkyC,GAAKrM,EAAEiJ,GAAIwF,G,CAGnC,GACAh8C,KAAKg6C,SAAW+B,EAChBlH,EAAW70C,KAAK+5C,UAAU97B,OAAO49B,IAAShH,EAC1C70C,KAAK60C,SAAW70C,KAAK60C,UAAYA,EAC1BA,CACT,EAWAiF,EAAA13C,UAAAszC,WAAA,SAAWtjC,GAIT,OAAOpS,KAAK+5C,UAAUliC,IAAIzF,EAC5B,EAEA0nC,EAAA13C,UAAAk5C,OAAA,SAAO1F,GAEL,OAAO51C,KAAK+5C,UAAUjF,SAASc,EACjC,EAEAkE,EAAA13C,UAAAu5C,UAAA,SAAUtE,EAAUrC,QAAA,IAAAA,IAAAA,GAAA,GAClB,IAAMiH,EAAOj8C,KAAK+5C,UAAUhF,OAAOsC,EAAKrC,GAQxC,OAPIqC,GAAO4E,EACLA,EAAKvD,WAAa,IACpBuD,EAAKvD,WAAa14C,KAAK+5C,UAAU9yB,MAGnC4e,GAAYmP,EAAe,oCAEtBiH,CACT,EAYAnC,EAAA13C,UAAA85C,EAAA,SAAEtG,EAAeZ,QAAA,IAAAA,IAAAA,GAAA,GACf,IAAIlS,EAAI9iC,KAAKs7C,OAAO1F,GACpB,GAAS,MAAL9S,EAAW,CACb,GAAIkS,EAAe,MAAM,IAAInpC,MAAM,YAAA4C,OAAYmnC,EAAK,uBACpD,IAAK9S,EAAEoT,WAAY,MAAM,IAAIrqC,MAAM,WAAA4C,OAAWmnC,EAAK,sC,MAEnD9S,EAAI,IAAIwV,GAAIt4C,KAAM41C,GAAO,GACzB9S,EAAI9iC,KAAK27C,UAAU7Y,GAAG,GAExB,OAAOA,CACT,EAYAgX,EAAA13C,UAAA+5C,GAAA,SAAGvG,EAAeD,EAAqBX,QAArB,IAAAW,IAAAA,GAAA,QAAqB,IAAAX,IAAAA,GAAA,GACrC,IAAIwB,EAAKx2C,KAAKs7C,OAAO1F,GACrB,GAAU,MAANY,EAAY,CACd,GAAIxB,EAAe,MAAM,IAAInpC,MAAM,gBAAA4C,OAAgBmnC,EAAK,uBACxD,GAAIY,EAAGN,WAAY,MAAM,IAAIrqC,MAAM,WAAA4C,OAAWmnC,EAAK,kC,MAEnDY,EAAK,IAAI8B,GAAIt4C,KAAM41C,GAAO,IACvBD,YAAcA,EACjBa,EAAKx2C,KAAK27C,UAAUnF,GAAI,GACnBb,GAAmC,MAApB31C,KAAKo4C,cACvBp4C,KAAKo4C,YAAc5B,GAGvB,OAAOA,CACT,EAMAsD,EAAA13C,UAAAm4C,QAAA,SAAQ3E,GACN,OAAO51C,KAAKk8C,EAAEtG,GAAO,EACvB,EAMAkE,EAAA13C,UAAAy4C,MAAA,SAAMjF,EAAeD,GACnB,YADmB,IAAAA,IAAAA,GAAA,GACZ31C,KAAKm8C,GAAGvG,EAAOD,GAAa,EACrC,EAKAmE,EAAA13C,UAAA8zC,WAAA,SAAWN,GACT,IAAM9S,EAAI9iC,KAAKs7C,OAAO1F,GACtB,OAAY,MAAL9S,GAAaA,EAAEoT,UACxB,EAKA4D,EAAA13C,UAAAg6C,KAAA,SAAKxG,GACH,IAAM9S,EAAI9iC,KAAKs7C,OAAO1F,GACtB,OAAY,MAAL9S,IAAcA,EAAEoT,aAAepT,EAAE6S,WAC1C,EAKAmE,EAAA13C,UAAAi6C,QAAA,SAAQzG,GACN,IAAM9S,EAAI9iC,KAAKs7C,OAAO1F,GACtB,OAAY,MAAL9S,IAAcA,EAAEoT,YAAcpT,EAAE6S,WACzC,EAEAmE,EAAA13C,UAAAk6C,IAAA,W,YAAIC,EAAA,GAAAzD,EAAA,EAAAA,EAAA72C,UAAA6C,OAAAg0C,IAAAyD,EAAAzD,GAAA72C,UAAA62C,GACF,GAAmB,GAAfyD,EAAKz3C,OACP,OAAO9E,KAAKw8C,cAAcD,EAAK,IAE/B,IAAMtkB,EAAM,IAAI4gB,G,IAChB,IAAgB,IAAA4D,EAAA/I,GAAA6I,GAAIG,EAAAD,EAAAxxC,QAAAyxC,EAAAxxC,KAAAwxC,EAAAD,EAAAxxC,OAIlB,IAJG,IAAM1K,EAACm8C,EAAAr7C,MACJN,EAAIf,KAAKw8C,cAAcj8C,GAGpBM,EAAI,EAAGA,EAAIE,EAAE+D,OAAQjE,IAE5Bo3B,EAAIqK,IAAIvhC,EAAEg2C,KAAKl2C,G,kGAGnB,OAAOo3B,CAEX,EASA6hB,EAAA13C,UAAAu6C,MAAA,W,IAAA,IAAAtG,EAAA,KAAM+E,EAAA,GAAAtC,EAAA,EAAAA,EAAA72C,UAAA6C,OAAAg0C,IAAAsC,EAAAtC,GAAA72C,UAAA62C,GACJ,OAAoB,GAAhBsC,EAAMt2C,OACD9E,KAAKw8C,cAAcpB,EAAM,IAKzB,IAAIvC,GAAI74C,KAAK48C,YAAW56C,MAAhBhC,KAAIuzC,GAAA,GAAAF,GAAgB+H,EAAM32C,IAAI,SAAC8oC,GAAM,OAAA8I,EAAKmG,cAAcjP,EAAnB,KAAsB,IAE9E,EAEAuM,EAAA13C,UAAAgnB,IAAA,SAAIqsB,GAEF,IAAMxd,EAAMj4B,KAAK28C,MAAMlH,EAAK,IAAIoD,IAC1BrC,EAAKve,EAAI8e,KAAK,GAGpB,OAFAlR,EAA8B,GAAnB5N,EAAI8e,KAAKjyC,QAAe0xC,EAAGb,YAAa,kCACnDa,EAAG+B,QAAU,MACNtgB,CACT,EAEA6hB,EAAA13C,UAAAy6C,SAAA,SAASpH,EAAmBqH,GAA5B,IAAAzG,EAAA,UAA4B,IAAAyG,IAAAA,GAAA,GAC1B,IAAM/7C,EAAIf,KAAKw8C,cAAc/G,GAKzBsH,EAAQ/8C,KAAKg9C,UAAU,SAACD,GAC1B,IAAM3B,EAAQ/E,EAAKI,WAAWsG,GAC9B,GAAoB,GAAhB3B,EAAMt2C,OAAa,OAAO,EAE9B,IAAIm4C,EAAQ,EACZ,GAA2B,GAAvB7B,EAAM,GAAGxE,IAAI9xC,OACfm4C,EAAQ,MACH,IAA2B,GAAvB7B,EAAM,GAAGxE,IAAI9xC,OAGtB,OAAO,EAFPm4C,EAAQ,C,CAKV,IAAMvG,EAAO0E,EAAM6B,GAAOrG,IAC1B,OAAIF,EAAK5xC,QAAU,EAAI2wC,EAAI3wC,SACvB4xC,EAAKK,KAAK,GAAGtf,OAAOslB,GACfrG,EAAKgD,WAAW,EAAG34C,KACjB21C,EAAKK,KAAKL,EAAK5xC,OAAS,GAAG2yB,OAAOslB,IACpCrG,EAAKgD,WAAW,EAAG34C,GAG9B,GAWA,OAVa,MAATg8C,KACFA,EAAQ/8C,KAAKk9C,YACP3E,QAAUuE,EAAU,gBAAkB,WAC5C98C,KAAKsiC,IAAIya,EAAO,IAAIlE,IAChBiE,EACF98C,KAAKsiC,IAAIya,EAAO,IAAIlE,GAAIkE,GAAO5zC,OAAOpI,IAEtCf,KAAKsiC,IAAIya,EAAOh8C,EAAE8xB,OAAOzqB,OAAO20C,KAG7B,IAAIlE,GAAIkE,EACjB,EAEAjD,EAAA13C,UAAA+6C,SAAA,SAAS1H,EAAmBqH,GAA5B,IAAAzG,EAAA,UAA4B,IAAAyG,IAAAA,GAAA,GAC1B,IAAM/7C,EAAIf,KAAKw8C,cAAc/G,GAKzBsH,EAAQ/8C,KAAKg9C,UAAU,SAACD,GAC1B,IAAM3B,EAAQ/E,EAAKI,WAAWsG,GAC9B,GAAoB,GAAhB3B,EAAMt2C,OAAa,OAAO,EAE9B,IAAIm4C,EAAQ,EACZ,GAAI7B,EAAM,GAAGxE,IAAInf,OAAO12B,GACtBk8C,EAAQ,MACH,KAAI7B,EAAM,GAAGxE,IAAInf,OAAO12B,GAG7B,OAAO,EAFPk8C,EAAQ,C,CAKV,IAAMvG,EAAO0E,EAAM6B,GAAOrG,IAC1B,OAAIF,EAAK5xC,QAAU,EAAI2wC,EAAI3wC,SACvB4xC,EAAKK,KAAK,GAAGtf,OAAOslB,GACfrG,EAAKgD,WAAW,EAAG34C,KACjB21C,EAAKK,KAAKL,EAAK5xC,OAAS,GAAG2yB,OAAOslB,IACpCrG,EAAKgD,WAAW,EAAG34C,GAG9B,GAWA,OAVa,MAATg8C,KACFA,EAAQ/8C,KAAKk9C,YACP3E,QAAUuE,EAAU,gBAAkB,WAC5C98C,KAAKsiC,IAAIya,EAAOh8C,GACZ+7C,EACF98C,KAAKsiC,IAAIya,EAAO,IAAIlE,GAAIkE,GAAO5zC,OAAOpI,IAEtCf,KAAKsiC,IAAIya,EAAOh8C,EAAE8xB,OAAOzqB,OAAO20C,KAG7B,IAAIlE,GAAIkE,EACjB,EAEAjD,EAAA13C,UAAAo6C,cAAA,SAAc/G,GACZ,GAAmB,iBAARA,EAAkB,CAC3B,IAAMlM,EAAMvpC,KAAKs7C,OAAO7F,GACxB,GAAW,MAAPlM,EAAa,MAAM,IAAI19B,MAAM,oBAAA4C,OAAoBgnC,EAAG,MACxD,OAAO,IAAIoD,GAAItP,E,CAIf,OAAOkM,CAEX,EAIUqE,EAAA13C,UAAAg7C,aAAV,WACE,OAAOp9C,KAAKq6C,YAAcr6C,KAAKo6C,YACjC,EAEAN,EAAA13C,UAAA86C,SAAA,SAASz2C,GAEP,YAFO,IAAAA,IAAAA,EAAA,IACK,IAARA,IAAYA,EAAOzG,KAAKo9C,gBACrBp9C,KAAK66C,MAAMp0C,GAAM,EAC1B,EAEAqzC,EAAA13C,UAAAw6C,YAAA,W,YAAYxB,EAAA,GAAAtC,EAAA,EAAAA,EAAA72C,UAAA6C,OAAAg0C,IAAAsC,EAAAtC,GAAA72C,UAAA62C,GACV,IAAItC,EAAKx2C,KAAKq9C,iBAAgBr7C,MAArBhC,KAAIuzC,GAAA,GAAAF,GAAqB+H,IAAK,IACvC,GAAU,MAAN5E,EAAY,EACdA,EAAKx2C,KAAKk9C,YACP3E,QAAU,Q,IACb,IAAmB,IAAA+E,EAAA5J,GAAA0H,GAAKmC,EAAAD,EAAAryC,QAAAsyC,EAAAryC,KAAAqyC,EAAAD,EAAAryC,OAAA,CAAnB,IAAMyrC,EAAI6G,EAAAl8C,MAAWrB,KAAKsiC,IAAIkU,EAAIE,E,oGAEzC,OAAOF,CACT,EAOAsD,EAAA13C,UAAA46C,UAAA,SAAU7yC,G,YACR,IAAoB,IAAAulC,EAAAgE,GAAA1zC,KAAK+5C,UAAU7lC,SAAO0/B,EAAAlE,EAAAzkC,QAAA2oC,EAAA1oC,KAAA0oC,EAAAlE,EAAAzkC,OAAE,CAAvC,IAAM8xC,EAAKnJ,EAAAvyC,MACd,GAAK07C,EAAMpH,aACPxrC,EAAO4yC,GAAQ,OAAOA,C,mGAE5B,OAAO,IACT,EAEAjD,EAAA13C,UAAAi7C,iBAAA,W,IAAA,IAAAhH,EAAA,KAAiB+E,EAAA,GAAAtC,EAAA,EAAAA,EAAA72C,UAAA6C,OAAAg0C,IAAAsC,EAAAtC,GAAA72C,UAAA62C,GACf,OAAO94C,KAAKg9C,UAAU,SAACD,GACrB,IAAMS,EAAUnH,EAAKI,WAAWsG,GAChC,GAAIS,EAAQ14C,QAAUs2C,EAAMt2C,OAAQ,OAAO,EAC3C,IAAK,IAAIjE,EAAI,EAAGA,EAAI28C,EAAQ14C,OAAQjE,IAClC,IAAK28C,EAAQ38C,GAAG+1C,IAAInf,OAAO2jB,EAAMv6C,IAAK,OAAO,EAE/C,OAAO,CACT,EACF,EAEAi5C,EAAA13C,UAAAq7C,MAAA,SAAMluC,QAAA,IAAAA,IAAAA,EAAA,MAEJ,IAAMmuC,GADNnuC,EAAUA,GAAW,CAAC,GACEmuC,SAAW,KAC7BC,EAAmBpuC,EAAQouC,mBAAoB,EAC/CC,EAAeruC,EAAQquC,cAAgB,GACvC3lB,EAAgB,GAQtB,OAPAj4B,KAAKg4C,YAAY,KAAM,SAACtB,EAAYlmC,GAClC,IAAI+8B,EAAI,GAAA9+B,OAAGioC,EAAKF,GAAGZ,MAAK,KAAAnnC,OAAIivC,EAAO,KAC/BhH,EAAKE,IAAI9xC,OAAS,EAAGyoC,GAAKmJ,EAAKE,IAAIQ,YAClC7J,GAAKqQ,EACND,IAAkBpQ,GAAK,MAC3BtV,EAAIvwB,KAAK6lC,EACX,GACOtV,CACT,EAKA91B,OAAA2H,eAAIgwC,EAAA13C,UAAA,aAAU,C,IAAd,WACE,IAAM61B,EAAgB,GAItB,OAHAj4B,KAAKg4C,YAAY,KAAM,SAACtB,EAAYlmC,GAClCynB,EAAIvwB,KAAK,GAAA+G,OAAGioC,EAAKF,GAAGZ,MAAK,QAAAnnC,OAAOioC,EAAKE,IAAIQ,aAC3C,GACOnf,CACT,E,gCAKA91B,OAAA2H,eAAIgwC,EAAA13C,UAAA,0BAAuB,C,IAA3B,WAIE,I,YAHM61B,EAAM,IAAIgd,EAAUj1C,KAAM,MAC5B69C,GAAU,EACVC,GAAY,EACC,GAAVD,GAAa,CAClBA,EAAS,E,IACT,IAAmB,IAAAjK,GAAAmK,OAAA,EAAArK,GAAA1zC,KAAKg6C,WAAQzF,EAAAX,EAAA3oC,QAAAspC,EAAArpC,KAAAqpC,EAAAX,EAAA3oC,OAAE,CAA7B,IAAMyrC,EAAInC,EAAAlzC,MACby8C,GAAY,E,IACZ,IAAkB,IAAAE,GAAAC,OAAA,EAAAvK,GAAAgD,EAAKE,IAAIG,OAAImH,EAAAF,EAAA/yC,QAAAizC,EAAAhzC,KAAAgzC,EAAAF,EAAA/yC,OAAE,CAA5B,IAAMosC,EAAG6G,EAAA78C,MACP42B,EAAI/f,IAAIm/B,KACPA,EAAInB,YACNje,EAAIqK,IAAI+U,GACRwG,KAEAC,GAAY,E,mGAIdA,IAAc7lB,EAAI/f,IAAIw+B,EAAKF,MAC7Bve,EAAIqK,IAAIoU,EAAKF,IACbqH,I,oGAIN,OAAO5lB,CACT,E,gCAMA6hB,EAAA13C,UAAA+7C,iBAAA,SAAiBC,G,qBAAA,IAAAA,IAAAA,EAAA,MACG,MAAdA,IACFA,EAAap+C,KAAK06C,cAAgB16C,KAAK06C,cAAclE,GAAKx2C,KAAKo4C,aAEjEvS,EAAyB,MAAduY,EAAoB,+BAG/B,IAFA,IAAMC,EAAY,IAAIpJ,EAAUj1C,MAAM,GAAOsiC,IAAI8b,GAC7CjL,EAAe,CAACiL,GACbjL,EAAMruC,OAAS,GAAG,CACvB,IAAMsuC,EAAkB,G,IACxB,IAAmB,IAAAkL,GAAAC,OAAA,EAAA7K,GAAAP,IAAKqL,EAAAF,EAAArzC,QAAAuzC,EAAAtzC,KAAAszC,EAAAF,EAAArzC,OAAE,CAArB,IAAMsnC,EAAIiM,EAAAn9C,M,IACb,IAAmB,IAAAkzC,GAAAkK,OAAA,EAAA/K,GAAA1zC,KAAKy2C,WAAWlE,KAAKyL,EAAAzJ,EAAAtpC,QAAA+yC,EAAA9yC,KAAA8yC,EAAAzJ,EAAAtpC,OAAE,CAArC,IAAMyrC,EAAIsH,EAAA38C,M,IACb,IAAkB,IAAA68C,GAAAQ,OAAA,EAAAhL,GAAAgD,EAAKE,IAAIG,OAAI4H,EAAAT,EAAAjzC,QAAA0zC,EAAAzzC,KAAAyzC,EAAAT,EAAAjzC,OAAE,CAA5B,IAAMosC,EAAGsH,EAAAt9C,MACPg2C,EAAInB,YAAemI,EAAUnmC,IAAIm/B,KACpCjE,EAAS1rC,KAAK2vC,GACdgH,EAAU/b,IAAI+U,G,ySAKtBlE,EAAQC,C,CAEV,OAAOiL,CACT,EAKAl8C,OAAA2H,eAAIgwC,EAAA13C,UAAA,SAAM,C,IAAV,eAAAi0C,EAAA,KAwBE,OAAO3D,EAAiB1yC,KAAKu2C,gBAAiB,SAAC/yC,GAAa,OAAAA,EAAIoyC,KAAJ,EAZxC,SAAC5C,GACnB,IAAM/a,EAAoB,GAS1B,OARAoe,EAAK2B,YAAYhF,EAAM,SAAC0D,EAAMkI,GAC5BlI,EAAKE,IAAIG,KAAKryC,QAAQ,SAAC3D,EAAG2zB,GACpB3zB,EAAEm1C,YACFG,EAAKsB,UAAUhB,cAAcD,EAAKE,IAAK,EAAGliB,EAAI,IAAM2hB,EAAKsB,UAAUhB,cAAcD,EAAKE,IAAKliB,EAAI,IACjGuD,EAAIvwB,KAAK,CAAC3G,EAAG,CAACiyC,EAAM4L,IAExB,EACF,GACO3mB,CACT,EAEF,E,gCAMA91B,OAAA2H,eAAIgwC,EAAA13C,UAAA,gBAAa,C,IAAjB,eAAAi0C,EAAA,KAaE,OAAO3D,EAAiB1yC,KAAKu2C,gBAAiB,SAAC/yC,GAAa,OAAAA,EAAI4O,EAAJ,EAZxC,SAAC4gC,GACnB,IAAM/a,EAAoB,GAS1B,OARAoe,EAAK2B,YAAYhF,EAAM,SAAC0D,EAAMkI,GAC5BlI,EAAKE,IAAIG,KAAKryC,QAAQ,SAAC3D,EAAG2zB,GACxB,IAAI3zB,EAAEm1C,WAGN,OAFAje,EAAIvwB,KAAK,CAAC3G,EAAG69C,IAENvI,EAAKsB,UAAUd,WAAW91C,EACnC,EACF,GACOk3B,CACT,EAEF,E,gCACF6hB,CAAA,CA/pBA,G,4dF3LA,SAAY/F,GACVA,EAAAA,EAAA,yBACAA,EAAAA,EAAA,mBACAA,EAAAA,EAAA,kBACD,CAJD,CAAYA,IAAAA,EAAa,KAMzB,IGNY8K,GAuGAC,GHjGNrZ,GAAO,IAAI/7B,WAAW,GACtBq1C,GAAO,IAAIr1C,WAAW,GACtBs1C,GAAK,IAAIt1C,WAAW,GACpBu1C,GAAK,IAAIv1C,WAAW,GACpBw1C,GAAK,IAAIx1C,WAAW,GACpBy1C,GAAK,IAAIz1C,WAAW,GACpB01C,GAAS,IAAI11C,WAAW,GAQ9B21C,GAAA,oBAAAA,IAOA,QANEA,EAAAj9C,UAAAkJ,QAAA,SAAQg0C,EAAkBC,GACxB,IAAM94B,EAAMzmB,KAAK+Q,MAAMuuC,GACvB,OAAOC,GAAO94B,EAAMA,CACtB,EAGF44B,CAAA,CAPA,GAgBAG,GAAA,SAAA9H,GAAA,SAAA8H,I,8CAaA,QAb4B5H,GAAA4H,EAAA9H,GAC1B8H,EAAAp9C,UAAA2O,MAAA,SAAMuuC,GAEJ,GAAIA,GAAY,MAAUA,GAAY,KAAQ,OAAO,EACrD,IAAK,IAAIz+C,EAAI,EAAGA,EAAI4+C,GAAmB5+C,IACrC,GAZa,qCAYE6I,WAAW7I,IAAMy+C,EAAU,OAAO,EAEnD,OAAO,CACT,EAEAE,EAAAp9C,UAAAs9C,SAAA,SAASH,GACP,OAAOA,EAAM,MAAQ,KACvB,EACFC,CAAA,CAbA,CAA4BH,IAkB5BM,GAAA,SAAAjI,GAAA,SAAAiI,I,8CAQA,QAR2B/H,GAAA+H,EAAAjI,GACzBiI,EAAAv9C,UAAA2O,MAAA,SAAMuuC,GACJ,OAAOA,GAAY7Z,IAAQ6Z,GAAYP,EACzC,EAEAY,EAAAv9C,UAAAs9C,SAAA,SAASH,GACP,OAAOA,EAAM,MAAQ,KACvB,EACFI,CAAA,CARA,CAA2BN,IA6BdO,GAAmD,CAAC,IAhBjE,SAAAlI,GAAA,SAAAmI,I,8CAcA,QAd8BjI,GAAAiI,EAAAnI,GAC5BmI,EAAAz9C,UAAA2O,MAAA,SAAMuuC,GACJ,OACEA,GAAYF,IACXE,GAAY7Z,IAAQ6Z,GAAYP,IAChCO,GAAYN,IAAMM,GAAYL,IAC9BK,GAAYJ,IAAMI,GAAYH,EAGnC,EAEAU,EAAAz9C,UAAAs9C,SAAA,SAASH,GACP,OAAOA,EAAM,MAAQ,KACvB,EACFM,CAAA,CAdA,CAA8BR,KAgBmD,IAAIM,GAAS,IAAIH,KGnFlG,SAAYX,GAEVA,EAAAA,EAAA,WACAA,EAAAA,EAAA,uCACAA,EAAAA,EAAA,WACAA,EAAAA,EAAA,mBACAA,EAAAA,EAAA,aACAA,EAAAA,EAAA,uCAGAA,EAAAA,EAAA,aACAA,EAAAA,EAAA,iBACAA,EAAAA,EAAA,eACAA,EAAAA,EAAA,qCACAA,EAAAA,EAAA,iBACAA,EAAAA,EAAA,2BACAA,EAAAA,EAAA,mBACAA,EAAAA,EAAA,iCACAA,EAAAA,EAAA,mBACAA,EAAAA,EAAA,+BACAA,EAAAA,EAAA,WACAA,EAAAA,EAAA,mCACAA,EAAAA,EAAA,kBACAA,EAAAA,EAAA,gBACAA,EAAAA,EAAA,sDACAA,EAAAA,EAAA,gBACAA,EAAAA,EAAA,sDACAA,EAAAA,EAAA,cACAA,EAAAA,EAAA,sDACAA,EAAAA,EAAA,kBACAA,EAAAA,EAAA,gEACAA,EAAAA,EAAA,cACAA,EAAAA,EAAA,sDACAA,EAAAA,EAAA,cACAA,EAAAA,EAAA,sDACAA,EAAAA,EAAA,gBACAA,EAAAA,EAAA,YACAA,EAAAA,EAAA,gEACAA,EAAAA,EAAA,cACAA,EAAAA,EAAA,4BACAA,EAAAA,EAAA,cACAA,EAAAA,EAAA,0BACAA,EAAAA,EAAA,kBACAA,EAAAA,EAAA,sCACAA,EAAAA,EAAA,oCACAA,EAAAA,EAAA,8CACAA,EAAAA,EAAA,4CACAA,EAAAA,EAAA,cACAA,EAAAA,EAAA,wBACAA,EAAAA,EAAA,sBACAA,EAAAA,EAAA,kCACAA,EAAAA,EAAA,oBACAA,EAAAA,EAAA,sCACAA,EAAAA,EAAA,cACAA,EAAAA,EAAA,0BACAA,EAAAA,EAAA,gBACAA,EAAAA,EAAA,8CACAA,EAAAA,EAAA,gBACAA,EAAAA,EAAA,gDACAA,EAAAA,EAAA,cACAA,EAAAA,EAAA,8BACAA,EAAAA,EAAA,cACAA,EAAAA,EAAA,wBACAA,EAAAA,EAAA,gBACAA,EAAAA,EAAA,8BACAA,EAAAA,EAAA,oBACAA,EAAAA,EAAA,gCACAA,EAAAA,EAAA,cACAA,EAAAA,EAAA,sDACAA,EAAAA,EAAA,kBACAA,EAAAA,EAAA,0BACAA,EAAAA,EAAA,gBACAA,EAAAA,EAAA,kBACAA,EAAAA,EAAA,sDACAA,EAAAA,EAAA,sBACAA,EAAAA,EAAA,oCACAA,EAAAA,EAAA,oBACAA,EAAAA,EAAA,8CACAA,EAAAA,EAAA,kBACAA,EAAAA,EAAA,oCACAA,EAAAA,EAAA,sBACAA,EAAAA,EAAA,YACAA,EAAAA,EAAA,4CACAA,EAAAA,EAAA,kBACAA,EAAAA,EAAA,0CACAA,EAAAA,EAAA,YACAA,EAAAA,EAAA,8BACAA,EAAAA,EAAA,gBACAA,EAAAA,EAAA,gDACAA,EAAAA,EAAA,kBACAA,EAAAA,EAAA,0CACAA,EAAAA,EAAA,kBACAA,EAAAA,EAAA,0BACAA,EAAAA,EAAA,YACAA,EAAAA,EAAA,4CACAA,EAAAA,EAAA,kBACAA,EAAAA,EAAA,8BACAA,EAAAA,EAAA,gBACAA,EAAAA,EAAA,gCACAA,EAAAA,EAAA,gBACAA,EAAAA,EAAA,yBACD,CArGD,CAAYA,KAAAA,GAAY,KAuGxB,SAAYC,GAEVA,EAAAA,EAAA,WACAA,EAAAA,EAAA,+BACAA,EAAAA,EAAA,WACAA,EAAAA,EAAA,yCACAA,EAAAA,EAAA,WACAA,EAAAA,EAAA,iDACAA,EAAAA,EAAA,WACAA,EAAAA,EAAA,iBACAA,EAAAA,EAAA,qBACAA,EAAAA,EAAA,WACAA,EAAAA,EAAA,qCACAA,EAAAA,EAAA,WACAA,EAAAA,EAAA,uCACAA,EAAAA,EAAA,WACAA,EAAAA,EAAA,iBACAA,EAAAA,EAAA,mCACAA,EAAAA,EAAA,WACAA,EAAAA,EAAA,mCACAA,EAAAA,EAAA,WACAA,EAAAA,EAAA,yCACAA,EAAAA,EAAA,WACAA,EAAAA,EAAA,mBACAA,EAAAA,EAAA,YACAA,EAAAA,EAAA,8CACAA,EAAAA,EAAA,UACAA,EAAAA,EAAA,oBACAA,EAAAA,EAAA,YACAA,EAAAA,EAAA,kCACAA,EAAAA,EAAA,YACAA,EAAAA,EAAA,oCACAA,EAAAA,EAAA,YACAA,EAAAA,EAAA,wCACAA,EAAAA,EAAA,UACAA,EAAAA,EAAA,oCACAA,EAAAA,EAAA,gBACAA,EAAAA,EAAA,YACAA,EAAAA,EAAA,8BACAA,EAAAA,EAAA,YACAA,EAAAA,EAAA,sCACAA,EAAAA,EAAA,YACAA,EAAAA,EAAA,sCACAA,EAAAA,EAAA,YACAA,EAAAA,EAAA,sCACAA,EAAAA,EAAA,UACAA,EAAAA,EAAA,oBACAA,EAAAA,EAAA,YACAA,EAAAA,EAAA,wCACAA,EAAAA,EAAA,UACAA,EAAAA,EAAA,kBACAA,EAAAA,EAAA,YACAA,EAAAA,EAAA,gCACAA,EAAAA,EAAA,YACAA,EAAAA,EAAA,gCACAA,EAAAA,EAAA,YACAA,EAAAA,EAAA,0CACAA,EAAAA,EAAA,YACAA,EAAAA,EAAA,gCACAA,EAAAA,EAAA,YACAA,EAAAA,EAAA,8CACAA,EAAAA,EAAA,YACAA,EAAAA,EAAA,8BACAA,EAAAA,EAAA,UACAA,EAAAA,EAAA,kBACAA,EAAAA,EAAA,8BACAA,EAAAA,EAAA,UACAA,EAAAA,EAAA,0BACAA,EAAAA,EAAA,YACAA,EAAAA,EAAA,sCACAA,EAAAA,EAAA,YACAA,EAAAA,EAAA,gCACAA,EAAAA,EAAA,YACAA,EAAAA,EAAA,0BACAA,EAAAA,EAAA,UACAA,EAAAA,EAAA,oBACAA,EAAAA,EAAA,YACAA,EAAAA,EAAA,wCACAA,EAAAA,EAAA,YACAA,EAAAA,EAAA,4BACAA,EAAAA,EAAA,YACAA,EAAAA,EAAA,uCAED,CAnFD,CAAYA,KAAAA,GAAa,K,IRnGbgB,G,07CAAZ,SAAYA,GACVA,EAAAA,EAAA,mCACAA,EAAAA,EAAA,+BACAA,EAAAA,EAAA,iCACAA,EAAAA,EAAA,6BACAA,EAAAA,EAAA,iBACAA,EAAAA,EAAA,aACAA,EAAAA,EAAA,aACAA,EAAAA,EAAA,mCACAA,EAAAA,EAAA,+BACAA,EAAAA,EAAA,iBACAA,EAAAA,EAAA,4BACAA,EAAAA,EAAA,0BAEAA,EAAAA,EAAA,eACD,CAfD,CAAYA,KAAAA,GAAS,KA8BrB,IAkVYC,GAlVZC,GAAA,oBAAAA,IAEE,KAAAliB,OAA8B,KACpB,KAAA4hB,SAAW,KAGrB,KAAAO,YAAc,EAGd,KAAAC,UAAkC,KAElC,KAAAC,eAAgB,EAQhB,KAAAC,WAA6B,KAM7B,KAAAC,OAAyB,KAOzB,KAAAC,UAA4B,IAgD9B,QA9CEN,EAAA59C,UAAAm+C,WAAA,SAAWhxC,GAKT,MAJI,WAAYA,IAAS,KAAK8wC,OAAS9wC,EAAQ8wC,QAC3C,eAAgB9wC,IAAS,KAAK6wC,WAAa7wC,EAAQ6wC,YACnD,eAAgB7wC,IAAS,KAAK0wC,WAAa1wC,EAAQ0wC,YACnD,cAAe1wC,IAAS,KAAK+wC,UAAY/wC,EAAQ+wC,WAC9C,IACT,EAEAN,EAAA59C,UAAA47B,WAAA,WACE,IAAM/F,EAAM,GAKZ,OAJI,KAAKooB,SAAQpoB,EAAIooB,QAAS,GAC1B,KAAKD,aAAYnoB,EAAImoB,YAAa,GAClC,KAAKE,YAAWroB,EAAIqoB,WAAY,GAChC,KAAKL,YAAc,IAAGhoB,EAAIgoB,WAAa,KAAKA,YACzChoB,CACT,EAIA91B,OAAA2H,eAAIk2C,EAAA59C,UAAA,aAAU,C,IAAd,WACE,OAAO,CACT,E,gCAMAD,OAAA2H,eAAIk2C,EAAA59C,UAAA,WAAQ,C,IAAZ,WAIE,OAHqB,MAAjB,KAAKs9C,WACP,KAAKA,SAAW,KAAKc,gBAEhBxgD,KAAK0/C,QACd,E,gCAMAv9C,OAAA2H,eAAIk2C,EAAA59C,UAAA,YAAS,C,IAAb,WACE,IAAIoiC,EAAM,GAKV,OAJI,KAAK6b,SAAQ7b,GAAO,KACpB,KAAK4b,aAAY5b,GAAO,KACxB,KAAK8b,YAAW9b,GAAO,KACvB,KAAKyb,YAAc,IAAGzb,GAAO,KAAO,KAAKyb,YACxB,GAAdzb,EAAI1/B,OAAc0/B,EAAM,IAAMA,EAAM,GAC7C,E,gCACFwb,CAAA,CAhFA,GAkFAS,GAAA,SAAA/I,GAAA,SAAA+I,IAAA,IAAApK,EAAA,OAAAqB,GAAAA,EAAA11C,MAAA,KAAAC,YAAA,K,OACWo0C,EAAAqK,IAAiBZ,GAAUa,e,CAUtC,QAXkC/I,GAAA6I,EAAA/I,GAEhC+I,EAAAr+C,UAAA47B,WAAA,WACE,MAAO,GACT,EACAyiB,EAAAr+C,UAAAw+C,QAAA,WACE,OAAO,IACT,EACUH,EAAAr+C,UAAAo+C,aAAV,WACE,MAAO,GACT,EACFC,CAAA,CAXA,CAAkCT,IAalCa,GAAA,SAAAnJ,GAAA,SAAAmJ,IAAA,IAAAxK,EAAA,OAAAqB,GAAAA,EAAA11C,MAAA,KAAAC,YAAA,K,OACWo0C,EAAAqK,IAAiBZ,GAAUgB,a,CAUtC,QAXgClJ,GAAAiJ,EAAAnJ,GAE9BmJ,EAAAz+C,UAAA47B,WAAA,WACE,MAAO,GACT,EACU6iB,EAAAz+C,UAAAo+C,aAAV,WACE,MAAO,GACT,EACAK,EAAAz+C,UAAAw+C,QAAA,WACE,OAAO,IACT,EACFC,CAAA,CAXA,CAAgCb,IAuChCe,IA1BA,SAAArJ,GAAA,SAAAsJ,IAAA,IAAA3K,EAAA,OAAAqB,GAAAA,EAAA11C,MAAA,KAAAC,YAAA,K,OACWo0C,EAAAqK,IAAiBZ,GAAUmB,c,CAUtC,CAXiCrJ,GAAAoJ,EAAAtJ,GAE/BsJ,EAAA5+C,UAAA47B,WAAA,WACE,MAAO,KACT,EACAgjB,EAAA5+C,UAAAw+C,QAAA,WACE,OAAO,IACT,EACUI,EAAA5+C,UAAAo+C,aAAV,WACE,MAAO,KACT,CACF,CAXA,CAAiCR,IAajC,SAAAtI,GAAA,SAAAwJ,IAAA,IAAA7K,EAAA,OAAAqB,GAAAA,EAAA11C,MAAA,KAAAC,YAAA,K,OACWo0C,EAAAqK,IAAiBZ,GAAUqB,Y,CAUtC,CAX+BvJ,GAAAsJ,EAAAxJ,GAE7BwJ,EAAA9+C,UAAA47B,WAAA,WACE,MAAO,KACT,EACAkjB,EAAA9+C,UAAAw+C,QAAA,WACE,OAAO,IACT,EACUM,EAAA9+C,UAAAo+C,aAAV,WACE,MAAO,KACT,CACF,CAXA,CAA+BR,IAa/B,SAAAtI,GAOE,SAAAqJ,EAA4BK,EAA6BC,EAA6BC,QAAA,IAAAA,IAAAA,GAAA,GAAtF,IAAAjL,EACEqB,EAAA50C,KAAA,OAAO,K,OADmBuzC,EAAA+K,KAAAA,EAA6B/K,EAAAgL,KAAAA,EAA6BhL,EAAAiL,OAAAA,E,CAEtF,CACF,OAViC1J,GAAAmJ,EAAArJ,GAUjCqJ,CAAA,CAVA,CAAiCf,KAYjCuB,GAAA,SAAA7J,GAAA,SAAA6J,IAAA,IAAAlL,EAAA,OAAAqB,GAAAA,EAAA11C,MAAA,KAAAC,YAAA,K,OACWo0C,EAAAqK,IAAiBZ,GAAU0B,W,CAqBtC,QAtB+B5J,GAAA2J,EAAA7J,GAGnB6J,EAAAn/C,UAAAo+C,aAAV,WACE,MAAO,GAAA/xC,OAAG,KAAK2yC,KAAKl/C,SAAQ,MAAAuM,OAAK,KAAK6yC,OAAS,IAAM,KAAG7yC,OAAG,KAAK4yC,KAAKn/C,SAAQ,IAC/E,EAEAq/C,EAAAn/C,UAAA47B,WAAA,WACE,MAAO,CACL,Y,SAEK0Z,EAAAt1C,UAAM47B,WAAUl7B,KAAA,OAAE,CACrBw+C,OAAQ,KAAKA,OACbF,KAAM,KAAKA,KAAKpjB,aAChBqjB,KAAM,KAAKA,KAAKrjB,eAGtB,EAEAujB,EAAAn/C,UAAAw+C,QAAA,WACE,OAAO,IAAIa,GAAS,KAAKL,KAAKR,UAAW,KAAKS,KAAKT,UAAW,KAAKU,OACrE,EACFC,CAAA,CAtBA,CAA+BR,IAwB/BU,GAAA,SAAA/J,GAAA,SAAA+J,IAAA,IAAApL,EAAA,OAAAqB,GAAAA,EAAA11C,MAAA,KAAAC,YAAA,K,OACWo0C,EAAAqK,IAAiBZ,GAAU4B,U,CAqBtC,QAtB8B9J,GAAA6J,EAAA/J,GAGlB+J,EAAAr/C,UAAAo+C,aAAV,WACE,MAAO,MAAA/xC,OAAM,KAAK6yC,OAAS,IAAM,KAAG7yC,OAAG,KAAK4yC,KAAKn/C,SAAQ,KAAAuM,OAAI,KAAK2yC,KAAKl/C,SACzE,EAEAu/C,EAAAr/C,UAAA47B,WAAA,WACE,MAAO,CACL,W,SAEK0Z,EAAAt1C,UAAM47B,WAAUl7B,KAAA,OAAE,CACrBw+C,OAAQ,KAAKA,OACbF,KAAM,KAAKA,KAAKpjB,aAChBqjB,KAAM,KAAKA,KAAKrjB,eAGtB,EAEAyjB,EAAAr/C,UAAAw+C,QAAA,WACE,OAAO,IAAIW,GAAU,KAAKH,KAAKR,UAAW,KAAKS,KAAKT,UAAW,KAAKU,OACtE,EACFG,CAAA,CAtBA,CAA8BV,IAwB9BY,GAAA,SAAAjK,GAEE,SAAAiK,EAAmBP,EAAoBQ,EAAqBC,EAAqBC,QAA1C,IAAAF,IAAAA,EAAA,QAAqB,IAAAC,IAAAA,EAAA,QAAqB,IAAAC,IAAAA,GAAA,GAAjF,IAAAzL,EACEqB,EAAA50C,KAAA,OAAO,K,OADUuzC,EAAA+K,KAAAA,EAAoB/K,EAAAuL,SAAAA,EAAqBvL,EAAAwL,SAAAA,EAAqBxL,EAAAyL,OAAAA,EADxEzL,EAAAqK,IAAiBZ,GAAUiC,M,CAGpC,CA6CF,OAjD2BnK,GAAA+J,EAAAjK,GAMzBv1C,OAAA2H,eAAI63C,EAAAv/C,UAAA,cAAW,C,IAAf,WACE,OAAO,KAAKy/C,SAAW,GAAK,KAAKA,UAAYhc,CAC/C,E,gCAIA1jC,OAAA2H,eAAI63C,EAAAv/C,UAAA,aAAU,C,IAAd,WACE,OAAO,KAAKw/C,UAAY,KAAKC,WAAa,KAAKT,KAAKY,UACtD,E,gCAEAL,EAAAv/C,UAAAw+C,QAAA,WACE,OAAO,IAAIe,EAAM,KAAKP,KAAKR,UAAW,KAAKgB,SAAU,KAAKC,SAAU,KAAKC,OAC3E,EAEUH,EAAAv/C,UAAAo+C,aAAV,WACE,IAAIyB,EAAQ,IAWZ,OAVqB,GAAjB,KAAKL,UAAiB,KAAKM,YAAaD,EAAQ,IAC1B,GAAjB,KAAKL,UAAiB,KAAKM,YAAaD,EAAQ,IAC/B,GAAjB,KAAKL,UAAkC,GAAjB,KAAKC,SAAeI,EAAQ,IACjC,GAAjB,KAAKL,UAAkC,GAAjB,KAAKC,WAEhCI,EADE,KAAKL,UAAY,KAAKC,SAChB,IAAApzC,OAAI,KAAKmzC,SAAQ,KAEjB,IAAAnzC,OAAI,KAAKmzC,SAAQ,KAAAnzC,OAAI,KAAKyzC,YAAc,GAAK,KAAKL,SAAQ,MAG/D,GAAApzC,OAAG,KAAK2yC,KAAKl/C,UAAQuM,OAAGwzC,EACjC,EAEAN,EAAAv/C,UAAA47B,WAAA,WACE,IAAIikB,EAAQ,IAWZ,OAVqB,GAAjB,KAAKL,UAAiB,KAAKM,YAAaD,EAAQ,KAAKH,OAAS,KAAO,IAC/C,GAAjB,KAAKF,UAAiB,KAAKM,YAAaD,EAAQ,KAAKH,OAAS,KAAO,IACpD,GAAjB,KAAKF,UAAkC,GAAjB,KAAKC,SAAeI,EAAQ,KAAKH,OAAS,KAAO,IACtD,GAAjB,KAAKF,UAAkC,GAAjB,KAAKC,WAEhCI,EADE,KAAKL,UAAY,KAAKC,SAChB,IAAApzC,OAAI,KAAKmzC,SAAQ,MAAO,KAAKE,OAAS,IAAM,IAE5C,IAAArzC,OAAI,KAAKmzC,SAAQ,KAAAnzC,OAAI,KAAKozC,SAAQ,MAAO,KAAKC,OAAS,IAAM,KAGlE,CAACG,EAAOvK,EAAAt1C,UAAM47B,WAAUl7B,KAAA,MAAI,KAAKs+C,KAAKpjB,aAC/C,EACF2jB,CAAA,CAjDA,CAA2B3B,IAmD3BmC,GAAA,SAAAzK,GAGE,SAAAyK,I,YAAYljB,EAAA,GAAA6Z,EAAA,EAAAA,EAAA72C,UAAA6C,OAAAg0C,IAAA7Z,EAAA6Z,GAAA72C,UAAA62C,GAAZ,IAAAzC,EACEqB,EAAA50C,KAAA,OAAO,KAHAuzC,EAAAqK,IAAiBZ,GAAUsC,IAIlC/L,EAAKpX,SAAW,G,IAChB,IAAoB,IAAAojB,EAAA3O,GAAAzU,GAAQqjB,EAAAD,EAAAp3C,QAAAq3C,EAAAp3C,KAAAo3C,EAAAD,EAAAp3C,OAAE,CAAzB,IAAMs0B,EAAK+iB,EAAAjhD,MACdg1C,EAAK/T,IAAI/C,E,2GAEb,CAkCF,OA3CyBqY,GAAAuK,EAAAzK,GAWvBv1C,OAAA2H,eAAIq4C,EAAA//C,UAAA,aAAU,C,IAAd,W,YACE,IAAoB,IAAAstC,EAAAgE,GAAA,KAAKzU,UAAQ2U,EAAAlE,EAAAzkC,QAAA2oC,EAAA1oC,KAAA0oC,EAAAlE,EAAAzkC,OAC/B,GADc2oC,EAAAvyC,MACJ2gD,WAAY,OAAO,C,kGAE/B,OAAO,CACT,E,gCAEUG,EAAA//C,UAAAo+C,aAAV,WACE,IAAMvoB,EAAM,KAAKgH,SAASx6B,IAAI,SAACnD,GAAM,OAAAA,EAAEY,QAAF,GAAYwM,KAAK,IACtD,OAAO,KAAKuwB,SAASn6B,OAAS,EAAI,IAAMmzB,EAAM,IAAMA,CACtD,EAEAkqB,EAAA//C,UAAAw+C,QAAA,WACE,IAAM3oB,EAAM,KAAKgH,SAASx6B,IAAI,SAACnD,GAAM,OAAAA,EAAEs/C,SAAF,GAErC,OADA3oB,EAAI2oB,UACJ,IAAWuB,EAAGtgD,KAAAG,MAAHmgD,EAAG5O,GAAA,SAAAF,GAAIpb,IAAG,IACvB,EAEAkqB,EAAA//C,UAAAkgC,IAAA,SAAI/C,G,QACF,GAAIA,EAAMmhB,KAAOZ,GAAUsC,KAAO7iB,EAAM0gB,YAAc,EACpD,KAAKhhB,SAASv3B,KAAK63B,Q,IAEnB,IAAkB,IAAAmQ,EAAAgE,GAACnU,EAAcN,UAAQ2U,EAAAlE,EAAAzkC,QAAA2oC,EAAA1oC,KAAA0oC,EAAAlE,EAAAzkC,OAAE,CAAtC,IAAMme,EAAGwqB,EAAAvyC,MACZ,KAAKihC,IAAIlZ,E,mGAGb,OAAO,IACT,EAEA+4B,EAAA//C,UAAA47B,WAAA,WACE,MAAO,CAAC,MAAKukB,GAAA,GAAO7K,EAAAt1C,UAAM47B,WAAUl7B,KAAA,OAAM,KAAKm8B,SAASx6B,IAAI,SAACnD,GAAM,OAAAA,EAAE08B,YAAF,GACrE,EACFmkB,CAAA,CA3CA,CAAyBnC,IA6CzBwC,GAAA,SAAA9K,GAGE,SAAA8K,I,YAAYjzC,EAAA,GAAAupC,EAAA,EAAAA,EAAA72C,UAAA6C,OAAAg0C,IAAAvpC,EAAAupC,GAAA72C,UAAA62C,GAAZ,IAAAzC,EACEqB,EAAA50C,KAAA,OAAO,KAHAuzC,EAAAqK,IAAiBZ,GAAU2C,MAIlCpM,EAAK9mC,QAAU,G,IACf,IAAqB,IAAAmzC,EAAAhP,GAAAnkC,GAAOozC,EAAAD,EAAAz3C,QAAA03C,EAAAz3C,KAAAy3C,EAAAD,EAAAz3C,OAAE,CAAzB,IAAM0E,EAAMgzC,EAAAthD,MACfg1C,EAAK/T,IAAI3yB,E,2GAEb,CAiCF,OA1C2BioC,GAAA4K,EAAA9K,GAWzBv1C,OAAA2H,eAAI04C,EAAApgD,UAAA,aAAU,C,IAAd,W,YACE,IAAoB,IAAAstC,EAAAgE,GAAA,KAAKnkC,SAAOqkC,EAAAlE,EAAAzkC,QAAA2oC,EAAA1oC,KAAA0oC,EAAAlE,EAAAzkC,OAC9B,GADc2oC,EAAAvyC,MACJ2gD,WAAY,OAAO,C,kGAE/B,OAAO,CACT,E,gCAEUQ,EAAApgD,UAAAo+C,aAAV,WACE,IAAMvoB,EAAM,KAAK1oB,QAAQ9K,IAAI,SAACnD,GAAM,OAAAA,EAAEY,QAAF,GAAYwM,KAAK,KACrD,OAAO,KAAKa,QAAQzK,OAAS,EAAI,IAAMmzB,EAAM,IAAMA,CACrD,EAEAuqB,EAAApgD,UAAAw+C,QAAA,WACE,IAAM3oB,EAAM,KAAK1oB,QAAQ9K,IAAI,SAACnD,GAAM,OAAAA,EAAEs/C,SAAF,GACpC,WAAW4B,EAAK3gD,KAAAG,MAALwgD,EAAKjP,GAAA,SAAAF,GAAIpb,IAAG,IACzB,EAEAuqB,EAAApgD,UAAAkgC,IAAA,SAAI3yB,G,QACF,GAAIA,EAAO+wC,KAAOZ,GAAU2C,OAAS9yC,EAAOswC,YAAc,EACxD,KAAK1wC,QAAQ7H,KAAKiI,Q,IAElB,IAAkB,IAAA+/B,EAAAgE,GAAC/jC,EAAiBJ,SAAOqkC,EAAAlE,EAAAzkC,QAAA2oC,EAAA1oC,KAAA0oC,EAAAlE,EAAAzkC,OAAE,CAAxC,IAAMme,EAAGwqB,EAAAvyC,MACZ,KAAKihC,IAAIlZ,E,mGAGb,OAAO,IACT,EAEAo5B,EAAApgD,UAAA47B,WAAA,WACE,MAAO,CAAC,QAAOukB,GAAA,GAAO7K,EAAAt1C,UAAM47B,WAAUl7B,KAAA,OAAM,KAAKyM,QAAQ9K,IAAI,SAACnD,GAAM,OAAAA,EAAE08B,YAAF,GACtE,EACFwkB,CAAA,CA1CA,CAA2BxC,KAgD3B,SAAYD,GACVA,EAAAA,EAAA,qBACAA,EAAAA,EAAA,2BACAA,EAAAA,EAAA,yBACAA,EAAAA,EAAA,mCACAA,EAAAA,EAAA,yBACAA,EAAAA,EAAA,iBACAA,EAAAA,EAAA,8BACD,CARD,CAAYA,KAAAA,GAAQ,KAapB,IAAA6C,GAAA,SAAAlL,GAIE,SAAAkL,EAAsCC,EAA8BtD,QAAA,IAAAA,IAAAA,GAAA,GAApE,IAAAlJ,EACEqB,EAAA50C,KAAA,OAAO,K,OAD6BuzC,EAAAwM,GAAAA,EAA8BxM,EAAAkJ,IAAAA,EAH3DlJ,EAAAqK,IAAiBZ,GAAUgD,K,CAKpC,CAmBF,OAzBmClL,GAAAgL,EAAAlL,GAQjCkL,EAAAxgD,UAAA2O,MAAA,SAAMgyC,GACJ,IAAMz6C,EAAS,KAAK06C,UAAUD,GAC9B,OAAQz6C,IAAW,KAAKi3C,KAAS,KAAKA,MAAQj3C,CAEhD,EAMAs6C,EAAAxgD,UAAAw+C,QAAA,WACE,OAAO,IACT,EAEAgC,EAAAxgD,UAAA47B,WAAA,WACE,OAAO,KAAK97B,SAAW,KAAK+gD,SAC9B,EACFL,CAAA,CAzBA,CAAmC5C,IA2BnCkD,GAAA,SAAAxL,GACE,SAAAwL,EAAsCL,EAA8BtD,EAAsBrjC,QAAtB,IAAAqjC,IAAAA,GAAA,QAAsB,IAAArjC,IAAAA,EAAA,IAA1F,IAAAm6B,EACEqB,EAAA50C,KAAA,KAAM+/C,EAAItD,IAAI,K,OADsBlJ,EAAAwM,GAAAA,EAA8BxM,EAAAkJ,IAAAA,EAAsBlJ,EAAAn6B,KAAAA,E,CAE1F,CA6DF,OAhE8B07B,GAAAsL,EAAAxL,GAKrBwL,EAAAC,IAAP,SAAW5D,GACT,YADS,IAAAA,IAAAA,GAAG,GACL,IAAI2D,EAASnD,GAASqD,QAAS7D,EACxC,EAEO2D,EAAAG,MAAP,SAAaC,EAA0B/D,GACrC,YADqC,IAAAA,IAAAA,GAAA,GAC9B,IAAI2D,EAASnD,GAASwD,UAAWhE,EAAK,CAAC+D,GAChD,EAEOJ,EAAAM,OAAP,SAAcT,EAAqBxD,GAIjC,YAJiC,IAAAA,IAAAA,GAAA,GACf,iBAAPwD,IACTA,EAAKA,EAAGr5C,WAAW,IAEd,IAAIw5C,EAASnD,GAAS0D,WAAYlE,EAAK,CAACwD,GACjD,EAEOG,EAAAQ,eAAP,SAAsBC,EAA+BC,EAAgCrE,GAGnF,YAHmF,IAAAA,IAAAA,GAAA,GACvD,iBAAjBoE,IAA2BA,EQrPpC,SAA0BtiD,GAE9B,MADAA,EAAQA,EAAMiI,UACCu1C,IACb,MAAM,IAAIgF,YAAY,0BAA4BxiD,GAEpD,OAAQw9C,GAAqBx9C,EAC/B,CR+OyDyiD,CAAgCH,IACxD,iBAAlBC,IAA4BA,EQ9OrC,SAA2BviD,GAE/B,MADAA,EAAQA,EAAMiI,UACCw1C,IACb,MAAM,IAAI+E,YAAY,2BAA6BxiD,GAErD,OAAQy9C,GAAsBz9C,EAChC,CRwO2DyiD,CAAiCF,IACjF,IAAIV,EAASnD,GAAS2D,eAAgBnE,EAAK,CAACoE,EAAcC,GACnE,EAEAV,EAAA9gD,UAAA4gD,UAAA,SAAUD,GACR,IAAM7mC,EAAO,KAAKA,KAClB,OAAQ,KAAK2mC,IACX,KAAK9C,GAAS0D,WACZ,OAAOV,GAAM,KAAK7mC,KAAK,GACzB,KAAK6jC,GAASwD,UACZ,OAAO3D,GAAiB1jC,EAAK,IAAI5Q,QAAQy3C,GAAI,GAC/C,KAAKhD,GAAS2D,eACZ,MAAM,IAAI73C,MAAM,kCAClB,QACE,MAAM,IAAIA,MAAM,yBAA2B,KAAKg3C,IAEpD,OAAO,CACT,EAEAK,EAAA9gD,UAAAu2C,UAAA,SAAU1a,GACR,GAAI,KAAK4kB,IAAM5kB,EAAQ4kB,GAAI,OAAO,KAAKA,GAAK5kB,EAAQ4kB,GACpD,IAAK,IAAIhiD,EAAI,EAAGA,EAAI,KAAKqb,KAAKpX,QAAUjE,EAAIo9B,EAAQ/hB,KAAKpX,OAAQjE,IAC/D,GAAI,KAAKqb,KAAKrb,IAAMo9B,EAAQ/hB,KAAKrb,GAAI,OAAO,KAAKqb,KAAKrb,GAAKo9B,EAAQ/hB,KAAKrb,GAE1E,OAAO,KAAKqb,KAAKpX,OAASm5B,EAAQ/hB,KAAKpX,MACzC,EAEUo+C,EAAA9gD,UAAAo+C,aAAV,WACE,OAAI,KAAKqC,IAAM9C,GAASqD,QACf,IACE,KAAKP,IAAM9C,GAAS0D,YA3bhBV,EA4bI,KAAK7mC,KAAK,GA3bxBzR,OAAO6rB,aAAaysB,GACxBx5C,QAAQ,KAAM,OACdA,QAAQ,KAAM,OACdA,QAAQ,KAAM,OACdA,QAAQ,KAAM,OACdA,QAAQ,KAAM,OACdA,QAAQ,KAAM,QAsbJ,KAAKs5C,IAAM9C,GAASwD,UACtB3D,GAAiB,KAAK1jC,KAAK,IAAIwjC,SAAS,KAAKH,KAC3C,KAAKsD,IAAM9C,GAAS2D,eACtB,KAAKnE,IAAM,OAAS,QAKtB,UAAY,KAAKrjC,KAAKxN,KAAK,KArctC,IAAmBq0C,CAscjB,EACFG,CAAA,CAhEA,CAA8BN,IAkE9BmB,GAAA,SAAArM,GACE,SAAAqM,EAAsClB,EAA8BtD,EAAsByE,QAAtB,IAAAzE,IAAAA,GAAA,QAAsB,IAAAyE,IAAAA,EAAA,IAA1F,IAAA3N,EACEqB,EAAA50C,KAAA,KAAM+/C,EAAItD,IAAI,K,OADsBlJ,EAAAwM,GAAAA,EAA8BxM,EAAAkJ,IAAAA,EAAsBlJ,EAAA2N,MAAAA,E,CAE1F,CAyDF,OA5D+BpM,GAAAmM,EAAArM,GAK7BqM,EAAA3hD,UAAAu2C,UAAA,SAAU1a,GACR,GAAI,KAAK4kB,IAAM5kB,EAAQ4kB,GAAI,OAAO,KAAKA,GAAK5kB,EAAQ4kB,GACpD,IAAK,IAAIhiD,EAAI,EAAGA,EAAI,KAAKmjD,MAAMl/C,QAAUjE,EAAIo9B,EAAQ+lB,MAAMl/C,OAAQjE,IAAK,CACtE,IAAMC,EAAI,KAAKkjD,MAAMnjD,GAAG83C,UAAU1a,EAAQ+lB,MAAMnjD,IAChD,GAAS,GAALC,EAAQ,OAAOA,C,CAErB,OAAO,KAAKkjD,MAAMl/C,OAASm5B,EAAQ+lB,MAAMl/C,MAC3C,EAEAi/C,EAAA3hD,UAAA4gD,UAAA,SAAUD,GACR,IAAMiB,EAAQ,KAAKA,MACnB,OAAQ,KAAKnB,IACX,KAAK9C,GAASkE,UACZ,OAAOlB,GAAOiB,EAAM,GAAgB9nC,KAAK,IAAM6mC,GAAOiB,EAAM,GAAgB9nC,KAAK,GACnF,KAAK6jC,GAASyC,MACZ,IAAK,IAAI3hD,EAAI,EAAGA,EAAImjD,EAAMl/C,OAAQjE,IAChC,GAAImjD,EAAMnjD,GAAGkQ,MAAMgyC,GAAK,OAAO,EAEjC,OAAO,EAET,KAAKhD,GAASmE,aACZ,IAASrjD,EAAI,EAAGA,EAAImjD,EAAMl/C,OAAQjE,IAChC,IAAKmjD,EAAMnjD,GAAGkQ,MAAMgyC,GAAK,OAAO,EAElC,OAAO,EAET,QACE,MAAM,IAAIl3C,MAAM,6BAA+B,KAAKg3C,IAExD,OAAO,CACT,EAEUkB,EAAA3hD,UAAAo+C,aAAV,WACE,IAAMvoB,EAAM,KAAK+rB,MAAMv/C,IAAI,SAACs+C,GAAO,OAAAA,EAAG/kB,YAAH,GAAiBtvB,KAAK,IACzD,OAAI,KAAKm0C,IAAM9C,GAASkE,UACf,GAAAx1C,OAAG,KAAKu1C,MAAM,GAAG9hD,SAAQ,KAAAuM,OAAI,KAAKu1C,MAAM,GAAG9hD,UACzC,KAAK2gD,IAAM9C,GAASyC,OAEpB,KAAKK,IAAM9C,GAASmE,aADtBjsB,EAAInzB,OAAS,GAAK,KAAKy6C,IAAM,KAAO,KAAOtnB,EAAM,IAAMA,EAIzD,UAAY,KAAK+rB,MAAMt1C,KAAK,IACrC,EAEOq1C,EAAAI,MAAP,SAAa5wB,EAAiBvP,EAAeu7B,GAC3C,YAD2C,IAAAA,IAAAA,GAAA,GACpC,IAAIwE,EAAUhE,GAASkE,UAAW1E,EAAK,CAAChsB,EAAOvP,GACxD,EAEO+/B,EAAAvB,MAAP,SAAajD,EAAayE,GACxB,YADW,IAAAzE,IAAAA,GAAA,GACJ,IAAIwE,EAAUhE,GAASyC,MAAOjD,EAAKyE,EAC5C,EAEOD,EAAAG,aAAP,SAAoB3E,EAAayE,GAC/B,YADkB,IAAAzE,IAAAA,GAAA,GACX,IAAIwE,EAAUhE,GAASmE,aAAc3E,EAAKyE,EACnD,EACFD,CAAA,CA5DA,CAA+BnB,IAiE/BwB,GAAA,SAAA1M,GAEE,SAAA0M,EAA4B39C,EAA8B49C,QAAA,IAAAA,IAAAA,GAAA,GAA1D,IAAAhO,EACEqB,EAAA50C,KAAA,OAAO,K,OADmBuzC,EAAA5vC,KAAAA,EAA8B4vC,EAAAgO,SAAAA,EADjDhO,EAAAqK,IAAiBZ,GAAUwE,I,CAGpC,CAaF,OAjByB1M,GAAAwM,EAAA1M,GAMvB0M,EAAAhiD,UAAAw+C,QAAA,WACE,OAAO,IAAIwD,EAAI,KAAK39C,MAAO,KAAK49C,SAClC,EAEUD,EAAAhiD,UAAAo+C,aAAV,WACE,MAAO,IAAM,KAAK/5C,KAAO,GAC3B,EAEA29C,EAAAhiD,UAAA47B,WAAA,WACE,MAAO,CAAC,KAAO,KAAKv3B,KAAI87C,GAAA,GAAO7K,EAAAt1C,UAAM47B,WAAUl7B,KAAA,OACjD,EACFshD,CAAA,CAjBA,CAAyBpE,IAsBzBuE,GAAA,SAAA7M,GAEE,SAAA6M,EAA4B99C,EAA8B49C,QAAA,IAAAA,IAAAA,GAAA,GAA1D,IAAAhO,EACEqB,EAAA50C,KAAA,OAAO,K,OADmBuzC,EAAA5vC,KAAAA,EAA8B4vC,EAAAgO,SAAAA,EADjDhO,EAAAqK,IAAiBZ,GAAU0E,e,CAGpC,CAaF,OAjBkC5M,GAAA2M,EAAA7M,GAMhC6M,EAAAniD,UAAAw+C,QAAA,WACE,OAAO,IAAI2D,EAAa,KAAK99C,MAAO,KAAK49C,SAC3C,EAEUE,EAAAniD,UAAAo+C,aAAV,WACE,MAAO,OAAS,KAAK/5C,KAAO,GAC9B,EAEA89C,EAAAniD,UAAA47B,WAAA,WACE,OAAAukB,GAAAA,GAAA,GAAY7K,EAAAt1C,UAAM47B,YAAU,CAAEymB,QAAS,KAAKh+C,MAC9C,EACF89C,CAAA,CAjBA,CAAkCvE,IAsBlC0E,GAAA,SAAAhN,GAEE,SAAAgN,EAA4B7nB,EAA6BwnB,QAAA,IAAAA,IAAAA,GAAA,GAAzD,IAAAhO,EACEqB,EAAA50C,KAAA,OAAO,K,OADmBuzC,EAAAxZ,IAAAA,EAA6BwZ,EAAAgO,SAAAA,EADhDhO,EAAAqK,IAAiBZ,GAAU6E,a,CAGpC,CAaF,OAjBgC/M,GAAA8M,EAAAhN,GAM9BgN,EAAAtiD,UAAAw+C,QAAA,WACE,OAAO,IAAI8D,EAAW,KAAK7nB,KAAM,KAAKwnB,SACxC,EAEUK,EAAAtiD,UAAAo+C,aAAV,WACE,MAAO,KAAO,KAAK3jB,GACrB,EAEA6nB,EAAAtiD,UAAA47B,WAAA,WACE,MAAO,KAAO,KAAKnB,GACrB,EACF6nB,CAAA,CAjBA,CAAgC1E,IA0DhCpG,GAAA,WAkDE,SAAAA,EAAmBwH,EAAa5zC,GAAb,KAAA4zC,KAAAA,EAjBnB,KAAAwD,MAAO,EAkBLp3C,EAASA,GAAW,GACpB,KAAKkzC,IAAMlzC,EAAOkzC,KAAO,KACF,GAAnBlzC,EAAOq3C,SACT,KAAKA,SAAW,EAEhB,KAAKA,SAAWr3C,EAAOq3C,UAAY,GAEZ,GAArBr3C,EAAOs3C,WACT,KAAKA,WAAa,EAElB,KAAKA,WAAat3C,EAAOs3C,aAAe,EAE1C,KAAKF,KAAOp3C,EAAOo3C,OAAQ,EAC3B,KAAKG,aAAev3C,EAAOu3C,cAAgB,IAC7C,CAiBF,OAZEnL,EAAAx3C,UAAA4iD,iBAAA,SAAiBt8B,GACf,OACuB,MAArB,KAAKq8B,cACqB,GAA1B,KAAKA,aAAa99B,MAClB,KAAK89B,aAAa7sC,IAAI,MACtB,KAAK6sC,aAAa7sC,IAAIwQ,EAE1B,EAEAvmB,OAAA2H,eAAI8vC,EAAAx3C,UAAA,sBAAmB,C,IAAvB,WACE,OAA4B,MAArB,KAAK2iD,cAAwB,KAAKA,aAAa99B,KAAO,IAAM,KAAK89B,aAAa7sC,IAAI,IAC3F,E,gCACF0hC,CAAA,CAlFA,G,irBSjoBA,SAASqL,GAAclC,GACrB,MAAa,MAANA,GAAoB,MAANA,GAAoB,UAANA,GAAwB,UAANA,CACvD,CAEA,IAMYmC,GANZC,GAGE,SAAmBN,EAAsBC,EAAwBvxB,EAAmBvP,QAAjE,IAAA6gC,IAAAA,EAAA,SAAsB,IAAAC,IAAAA,GAAc,QAAU,IAAAvxB,IAAAA,GAAS,QAAU,IAAAvP,IAAAA,GAAO,GAAxE,KAAA6gC,SAAAA,EAAsB,KAAAC,WAAAA,EAAwB,KAAAvxB,MAAAA,EAAmB,KAAAvP,IAAAA,EAFpF,KAAAohC,OAA6B,GAC7B,KAAAC,UAAsB,EACyE,GAGjG,SAAYH,GAEVA,EAAAA,EAAA,aAEAA,EAAAA,EAAA,uBAEAA,EAAAA,EAAA,eACAA,EAAAA,EAAA,mBAKAA,EAAAA,EAAA,iBACAA,EAAAA,EAAA,eACAA,EAAAA,EAAA,eACAA,EAAAA,EAAA,iBACAA,EAAAA,EAAA,eACAA,EAAAA,EAAA,iBACAA,EAAAA,EAAA,oBACAA,EAAAA,EAAA,cAIAA,EAAAA,EAAA,gCACAA,EAAAA,EAAA,4BAEAA,EAAAA,EAAA,oCACAA,EAAAA,EAAA,gCACAA,EAAAA,EAAA,8BACAA,EAAAA,EAAA,0BACAA,EAAAA,EAAA,4BACAA,EAAAA,EAAA,wBAGAA,EAAAA,EAAA,6BACD,CAnCD,CAAYA,KAAAA,GAAM,KAqClB,IAAAI,GAAA,WAIE,SAAAA,EAA4BC,EAA4CC,QAA5C,IAAAD,IAAAA,EAAA,gBAA4C,IAAAC,IAAAA,GAAA,GAA5C,KAAAD,eAAAA,EAA4C,KAAAC,cAAAA,EAHxE,KAAAC,OAAkB,GAIhBzlD,KAAK0lD,aAAe,IAAI79B,IACxB7nB,KAAK2lD,cAAc,WACnB3lD,KAAK2lD,cAAcJ,EACrB,CAuCF,OArCEpjD,OAAA2H,eAAIw7C,EAAAljD,UAAA,SAAM,C,IAAV,WACE,OAAOpC,KAAKylD,OAAO3gD,MACrB,E,gCAKAwgD,EAAAljD,UAAAujD,cAAA,SAAcj9B,GAIZ,OAHK1oB,KAAK0lD,aAAaxtC,IAAIwQ,IACzB1oB,KAAK0lD,aAAa95C,IAAI8c,EAAO1oB,KAAK0lD,aAAaz+B,MAE1CjnB,KAAK0lD,aAAa7tC,IAAI6Q,KAAW,CAC1C,EAEA48B,EAAAljD,UAAAkgC,IAAA,SAAIsjB,EAAajtC,G,WAAA,IAAAA,IAAAA,EAAA,M,IAA0B,IAAAuD,EAAA,GAAA48B,EAAA,EAAAA,EAAA72C,UAAA6C,OAAAg0C,IAAA58B,EAAA48B,EAAA,GAAA72C,UAAA62C,GACzC,IAAM7gB,GAAMiU,EAAA,IAAI2Z,GAAMD,EAAQjtC,IAAM2pB,IAAGtgC,MAAAkqC,EAAAqH,GAAC,GAADF,GAAIn3B,IAAI,IAG/C,OAFA+b,EAAI93B,OAASH,KAAKylD,OAAO3gD,OACzB9E,KAAKylD,OAAO/9C,KAAKuwB,GACVA,CACT,EAEOqtB,EAAAQ,KAAP,SAAYC,GACV,IAAM9tB,EAAM,IAAIqtB,EAEhB,OADAS,EAAY9tB,GACLA,CACT,EAEAqtB,EAAAljD,UAAA47B,WAAA,SAAWgoB,GACT,YADS,IAAAA,IAAAA,EAAAC,IACLD,EACKhmD,KAAKylD,OAAOhhD,IAAI,SAACyhD,EAAO11C,GAC7B,OAAI01C,EAAMC,QAAQ78C,OAAOxE,OAAS,EAAU,IAAA2J,OAAI+B,EAAK,MAAA/B,OAAKu3C,EAAgBE,GAAM,WAAAz3C,OAAUy3C,EAAMC,SACpF,IAAA13C,OAAI+B,EAAK,MAAA/B,OAAKu3C,EAAgBE,GAC5C,GAEOlmD,KAAKylD,OAAOhhD,IAAI,SAACyhD,EAAO11C,GAAU,UAAA/B,OAAI+B,EAAK,MAAA/B,OAAKy3C,EAAMloB,WAApB,EAE7C,EACFsnB,CAAA,CA/CA,GAiDAO,GAAA,WAKE,SAAAA,EAA4BD,EAAoBjtC,QAAA,IAAAA,IAAAA,EAAA,MAApB,KAAAitC,OAAAA,EAAoB,KAAAjtC,KAAAA,EAJhD,KAAAxY,OAAS,EACT,KAAAgmD,QAAU,GACV,KAAAjqC,KAAiB,GAGflc,KAAK2Y,KAAOA,CACd,CAYF,OAVEktC,EAAAzjD,UAAAkgC,IAAA,W,UAAIpmB,EAAA,GAAA48B,EAAA,EAAAA,EAAA72C,UAAA6C,OAAAg0C,IAAA58B,EAAA48B,GAAA72C,UAAA62C,GAEF,OADA5M,EAAAlsC,KAAKkc,MAAKxU,KAAI1F,MAAAkqC,EAAAqH,GAAC,GAADF,GAAIn3B,IAAI,IACflc,IACT,EAEAmC,OAAA2H,eAAI+7C,EAAAzjD,UAAA,aAAU,C,IAAd,WACE,IAAId,EAAItB,KAAKmmD,QAAQ78C,OAErB,OADIhI,EAAEwD,OAAS,IAAGxD,EAAI,SAAWA,GAC1B,GAAAmN,OAAGzO,KAAK4lD,OAAM,KAAAn3C,OAAIzO,KAAKkc,KAAKxN,KAAK,KAAI,QAAAD,OAAOzO,KAAK2Y,MAAQ,GAAE,OAAAlK,OAAMnN,EAC1E,E,gCACFukD,CAAA,CAnBA,GAwBAO,GAAA,WAeE,SAAAA,EAA4BjmD,EAAoCkmD,QAApC,IAAAlmD,IAAAA,EAAA,QAAoC,IAAAkmD,IAAAA,EAAA,GAApC,KAAAlmD,OAAAA,EAAoC,KAAAkmD,IAAAA,EAdhE,KAAAC,UAAY,EACZ,KAAAl0C,GAAK,EACL,KAAAyyC,SAAW,EAKX,KAAAO,OAA6B,GAC7B,KAAAC,UAAsB,GACtB,KAAAkB,UAAgC,CAAC,CAKiD,CA6BpF,OA3BEH,EAAAhkD,UAAAokD,QAAA,SAAQC,GACN,KAAMA,KAASzmD,KAAKumD,WAClB,MAAM,IAAI16C,MAAM,sBAAA4C,OAAsBg4C,EAAK,gBAE7CzmD,KAAKumD,UAAUE,IACjB,EAEAL,EAAAhkD,UAAAskD,WAAA,SAAWD,GACT,GAAIA,KAASzmD,KAAKumD,UAChB,MAAM,IAAI16C,MAAM,sBAAA4C,OAAsBg4C,EAAK,yCAE7CzmD,KAAKumD,UAAUE,GAAS,CAC1B,EAEAL,EAAAhkD,UAAAukD,WAAA,SAAWF,GACT,KAAMA,KAASzmD,KAAKumD,WAClB,MAAM,IAAI16C,MAAM,sBAAA4C,OAAsBg4C,EAAK,uBAEtCzmD,KAAKumD,UAAUE,EACxB,EAEAL,EAAAhkD,UAAAwkD,SAAA,SAASH,GACP,KAAMA,KAASzmD,KAAKumD,WAClB,MAAM,IAAI16C,MAAM,sBAAA4C,OAAsBg4C,EAAK,gBAE7C,OAAOzmD,KAAKumD,UAAUE,EACxB,EACFL,CAAA,CA5CA,GAoDAS,GAAA,WA2BE,SAAAA,EACkBC,EACAvzB,EACAvP,EACA+iC,EAChBC,QAHgB,IAAAzzB,IAAAA,EAAA,QACA,IAAAvP,IAAAA,GAAO,QACP,IAAA+iC,IAAAA,GAAA,QAChB,IAAAC,IAAAA,EAAA,IAJgB,KAAAF,KAAAA,EACA,KAAAvzB,MAAAA,EACA,KAAAvP,IAAAA,EACA,KAAA+iC,QAAAA,EArBR,KAAAE,cAAgB,EAChB,KAAAC,YAAwB,GACxB,KAAAC,YAAwB,GACxB,KAAAC,SAAW,EAEX,KAAAC,UAAY,EAEZ,KAAAhB,IAAM,EAON,KAAAiB,aAAmC,CAAC,EAUxCtjC,EAAM,IACRA,EAAM8iC,EAAKhiD,OAAS,GAEtB9E,KAAKgkB,IAAMA,CACb,CAuXF,OArXE6iC,EAAAzkD,UAAAmlD,aAAA,SAAaC,EAAgBvjC,EAAawjC,GACxC,KAAOD,EAAOnC,UAAUvgD,QAAUmf,GAAKujC,EAAOnC,UAAU39C,MAAM,GAC9D8/C,EAAOnC,UAAUphC,GAAOwjC,CAC1B,EAEAZ,EAAAzkD,UAAAslD,OAAA,SAAOF,EAAgBG,GACrB,YADqB,IAAAA,IAAAA,EAAA,GACd3nD,KAAK4nD,OAAOJ,EAAQA,EAAOrnD,OAASwnD,EAC7C,EAEAd,EAAAzkD,UAAAwlD,OAAA,SAAOJ,EAAgBK,GAKrB,IAAM5vB,EAAM,IAAImuB,GAAOyB,EAAW7nD,KAAKqmD,KAOvC,OANApuB,EAAI7lB,GAAKo1C,EAAOp1C,GAChB6lB,EAAIquB,SAAWkB,EAAOlB,SACtBruB,EAAI4sB,SAAW2C,EAAO3C,SACtB5sB,EAAIotB,UAAYmC,EAAOnC,UACvBptB,EAAImtB,OAASoC,EAAOpC,OACpBntB,EAAIsuB,UAAYiB,EAAOjB,UAChBtuB,CACT,EAEA4uB,EAAAzkD,UAAA0lD,OAAA,SAAON,EAAgBK,GACrB,IAAM5vB,EAAM,IAAImuB,GAAOyB,EAAW7nD,KAAKqmD,KAOvC,OANApuB,EAAI7lB,KAAOpS,KAAKinD,cAChBhvB,EAAIquB,SAAWkB,EAAOp1C,GACtB6lB,EAAI4sB,SAAW2C,EAAO3C,SACtB5sB,EAAIotB,UAAS9R,GAAA,GAAAF,GAAOmU,EAAOnC,YAAS,GACpCptB,EAAImtB,OAAM7R,GAAA,GAAAF,GAAOmU,EAAOpC,SAAM,GAC9BntB,EAAIsuB,UAAShE,GAAA,GAAQiF,EAAOjB,WACrBtuB,CACT,EAEA4uB,EAAAzkD,UAAA2lD,WAAA,SAAWP,EAAgBvH,EAAoBwH,GAC7C,IAAMO,EAAYhoD,KAAK8nD,OAAON,EAAQA,EAAOrnD,OAAS,GAEtD,OADA6nD,EAAU5C,OAAO19C,KAAK,CAACu4C,EAAYwH,IAC5BO,CACT,EAEAnB,EAAAzkD,UAAA6lD,SAAA,SAAST,EAAgBvH,EAAoBwH,GAC3C,IAAMO,EAAYhoD,KAAK8nD,OAAON,EAAQA,EAAOrnD,OAAS,GAEtD,OADA6nD,EAAU5C,OAAO19C,KAAK,EAAEu4C,EAAYwH,IAC7BO,CACT,EAEAnB,EAAAzkD,UAAA8lD,UAAA,SAAUV,EAAgBpwB,EAAgB+wB,EAAYR,G,QACpD,QADoD,IAAAA,IAAAA,EAAA,KAElDH,EAAOrnD,OAASH,KAAKuzB,OACrBi0B,EAAOrnD,OAASH,KAAKgkB,KACrBhkB,KAAKsnD,aAAaE,EAAOrnD,OAASH,KAAKuzB,QAAUvzB,KAAKqmD,KAHxD,CAQArmD,KAAKsnD,aAAaE,EAAOrnD,OAASH,KAAKuzB,OAASvzB,KAAKqmD,IACrD,IACI+B,EACAC,EACAL,EAHE9B,EAAQlmD,KAAK8mD,KAAKrB,OAAO+B,EAAOrnD,QAKhCylD,EAASM,EAAMN,OACrB,OAAQA,GACN,KAAKV,GAAOoD,KACVN,EAAYhoD,KAAK4nD,OAAOJ,EAAQtB,EAAMhqC,KAAK,IAC3Clc,KAAKkoD,UAAUF,EAAW5wB,EAAM+wB,EAAMR,GACtC,MACF,KAAKzC,GAAOqD,MACV,IAAK,IAAI7zB,EAAI,EAAGA,EAAIwxB,EAAMhqC,KAAKpX,OAAQ4vB,IAAK,CAC1C,IAAM8zB,EAAStC,EAAMhqC,KAAKwY,GAEpB+zB,EAAiB,GAAL/zB,EAAS10B,KAAK4nD,OAAOJ,EAAQgB,GAAUxoD,KAAK8nD,OAAON,EAAQgB,GAC7ExoD,KAAKkoD,UAAUO,EAAWrxB,EAAM+wB,EAAMR,E,CAExC,MACF,KAAKzC,GAAOwD,KACVV,EAAYhoD,KAAK4nD,OAAOJ,EAAQA,EAAOrnD,OAAS,GAChDH,KAAKunD,aAAaS,EAAW9B,EAAMhqC,KAAK,GAAIisC,EAAK33C,MAAQm3C,GACrD3nD,KAAK2oD,QAAQ3oD,KAAK2oD,OAAOC,aAAapB,EAAQW,EAAK33C,MAAQm3C,GAC/D3nD,KAAKkoD,UAAUF,EAAW5wB,EAAM+wB,EAAMR,GACtC,MACF,KAAKzC,GAAO2D,WACVb,EAAYhoD,KAAK+nD,WAAWP,EAAQtB,EAAMhqC,KAAK,GAAIisC,EAAK33C,MAAQm3C,GAC5D3nD,KAAK2oD,QAAQ3oD,KAAK2oD,OAAOC,aAAapB,EAAQW,EAAK33C,MAAQm3C,GAC/D3nD,KAAKkoD,UAAUF,EAAW5wB,EAAM+wB,EAAMR,GACtC,MACF,KAAKzC,GAAO4D,SACVd,EAAYhoD,KAAKioD,SAAST,EAAQtB,EAAMhqC,KAAK,GAAIisC,EAAK33C,MAAQm3C,GAC1D3nD,KAAK2oD,QAAQ3oD,KAAK2oD,OAAOC,aAAapB,EAAQW,EAAK33C,MAAQm3C,GAC/D3nD,KAAKkoD,UAAUF,EAAW5wB,EAAM+wB,EAAMR,GACtC,MACF,KAAKzC,GAAO6D,aACZ,KAAK7D,GAAO8D,eAEVX,EAASroD,KAAKipD,OAAOd,IACH,GAAdA,EAAK33C,OAAeo1C,GAAUV,GAAO8D,gBAAkB/D,GAAcoD,KAGvEroD,KAAKkoD,UAAUloD,KAAK0nD,OAAOF,EAAQ,GAAIpwB,EAAM+wB,EAAMR,GAErD,MACF,KAAKzC,GAAOgE,WACZ,KAAKhE,GAAOiE,cAKI,KADdf,EAASpoD,KAAKooD,OAAOD,KACAvC,GAAUV,GAAOiE,cAAgBlE,GAAcmD,KAClEpoD,KAAKkoD,UAAUloD,KAAK0nD,OAAOF,EAAQ,GAAIpwB,EAAM+wB,EAAMR,GAErD,MACF,KAAKzC,GAAOlE,YAWZ,KAAKkE,GAAOhE,UAUV,MACF,KAAKgE,GAAOkE,OAEF,IAAA1Z,EAAA2D,GAA4B6S,EAAMhqC,KAAI,GAArC+jC,EAAUvQ,EAAA,GAAE2Z,EAAM3Z,EAAA,GAAE4Z,EAAG5Z,EAAA,GACxBzrB,EAAyB,GAAlB,EAAIg8B,GACXsJ,EAAa/B,EAAOnC,UAAUphC,GAC9B2vB,EAAAP,GAA2BrzC,KAAKwpD,aACpCrB,EACAoB,EAAa,EACbrD,EAAM/lD,OAAS,EACfmpD,GACA,EACU,GAAVD,GACD,GAPMI,EAAY7V,EAAA,GAAUA,EAAA,GAQzB6V,GAGFzpD,KAAKkoD,UAAUloD,KAAK4nD,OAAOJ,EAAQ8B,EAAM,GAAIlyB,EAAM+wB,EAAMR,GAG7D,MACF,KAAKzC,GAAOwE,MAKJ,IAAAnV,EAAAlB,GAAyB6S,EAAMhqC,KAAI,GAAlCytC,EAAOpV,EAAA,GAAE+M,EAAM/M,EAAA,GAAEvwB,EAAGuwB,EAAA,GAC3B,GAAe,GAAXoV,EAGE3pD,KAAK2oD,QAAQ3oD,KAAK2oD,OAAOC,aAAapB,EAAQW,EAAK33C,OACvD4mB,EAAK1vB,KAAK8/C,OACL,CACC,IAAAxJ,EAAA3K,GAA2BrzC,KAAKwpD,aACpCrB,EACAA,EAAK33C,MAAQ,EACb01C,EAAM/lD,OAAS,EACf6jB,GACA,EACU,GAAVs9B,GACD,GAPMmI,EAAYzL,EAAA,GAAUA,EAAA,GAQzByL,GAGFzpD,KAAKkoD,UAAUloD,KAAK4nD,OAAOJ,EAAQxjC,EAAM,GAAIoT,EAAM+wB,EAAMR,E,CAG7D,MACF,KAAKzC,GAAO0E,YACV,IAAMC,EAAS3D,EAAMhqC,K,IACrB,IAAoB,IAAA4tC,E,ySAAApW,CAAAmW,GAAME,EAAAD,EAAA7+C,QAAA8+C,EAAA7+C,KAAA6+C,EAAAD,EAAA7+C,OAAE,CAAvB,IAAMyd,EAAKqhC,EAAA1oD,MACd,GAAIrB,KAAKqnD,WAAa3+B,EAAO,CAC3B1oB,KAAKkoD,UAAUloD,KAAK0nD,OAAOF,EAAQ,GAAIpwB,EAAM+wB,EAAMR,GACnD,K,oGAGJ,MACF,QACM3nD,KAAK2oD,QAAQ3oD,KAAK2oD,OAAOC,aAAapB,EAAQW,EAAK33C,OACvD4mB,EAAK1vB,KAAK8/C,G,CAGhB,EAEAX,EAAAzkD,UAAA4nD,aAAA,SAAa7B,EAAYxvC,EAAYynC,GACnC,YADmC,IAAAA,IAAAA,GAAA,GAC/BA,EACKznC,EAAK5H,MAAMo3C,EAAK8B,kBAAoBtxC,EAAK5H,MAAMo3C,EAAK+B,iBAEpDvxC,EAAK5H,MAAMo3C,EAAKgC,WAE3B,EAEUtD,EAAAzkD,UAAAgoD,QAAV,SAAkBjC,GAChB,OAAOnoD,KAAK+mD,QAAUoB,EAAKiC,QAAUjC,EAAK33C,OAAS,CACrD,EAEUq2C,EAAAzkD,UAAAgmD,OAAV,SAAiBD,GACf,IAAMl9C,EAAOk9C,EAAK33C,OAASxQ,KAAK+mD,QAAU,GAAK,GAC/C,OAAOoB,EAAKkC,OAAOp/C,EAGrB,EAEU47C,EAAAzkD,UAAA6mD,OAAV,SAAiBd,GACf,OAAOA,EAAKkC,OAAOlC,EAAK33C,OAASxQ,KAAK+mD,QAAU,GAAK,GAEvD,EAMAF,EAAAzkD,UAAA2O,MAAA,SAAMo3C,GAEJ,GAAInoD,KAAKgkB,IAAMhkB,KAAKuzB,MAAO,OAAO,KAClCvzB,KAAKsqD,cAAcnC,GAEnB,IADA,IAAIoC,EAAiC,KAC9BvqD,KAAKknD,YAAYpiD,OAAS,GAC/BylD,EAAYvqD,KAAKwqD,SAASrC,EAAMoC,GAIlC,OADiB,MAAbA,IAAmBpC,EAAK33C,MAAQ+5C,EAAUvmC,KACvCumC,CACT,EAEA1D,EAAAzkD,UAAAonD,aAAA,SACErB,EACAV,EACAgD,EACArY,EACA2U,EACAzF,QADA,IAAAyF,IAAAA,GAAA,QACA,IAAAzF,IAAAA,GAAA,GAEA,IAAMoJ,EAAWvC,EAAK33C,MACtB,IAAK23C,EAAKwC,WAAW5D,EAAU,GAAK,GAAI,MAAO,CAACzF,GAAS,GACzD6G,EAAK33C,MAAQi3C,EAEb,IACM12C,EADK,IAAI81C,EAAG7mD,KAAK8mD,KAAM2D,EAAarY,EAAW2U,GACpCh2C,MAAMo3C,GACjByC,EAASzC,EAAK33C,MAEpB,OADA23C,EAAK33C,MAAQk6C,EACN,CAAW,MAAT35C,IAAkBuwC,GAAqB,MAATvwC,GAAiBuwC,EAASsJ,EACnE,EAEA/D,EAAAzkD,UAAAkoD,cAAA,SAAcnC,GACZnoD,KAAKknD,YAAc,GACnBlnD,KAAKmnD,YAAc,GACnBnnD,KAAKqmD,MACLrmD,KAAKkoD,UAAU,IAAI9B,GAAOpmD,KAAKuzB,MAAOvzB,KAAKqmD,KAAMrmD,KAAKknD,YAAaiB,GAGnEnoD,KAAKonD,SAAWe,EAAK33C,KACvB,EAEAq2C,EAAAzkD,UAAAooD,SAAA,SAASrC,EAAY0C,QAAA,IAAAA,IAAAA,EAAA,MAEnB7qD,KAAKqmD,MAEL,IAAK,IAAIxlD,EAAI,EAAGA,EAAIb,KAAKknD,YAAYpiD,OAAQjE,IAAK,CAChD,IAAM2mD,EAASxnD,KAAKknD,YAAYrmD,GAE1BiqD,EAAY9qD,KAAK+qD,WAAW5C,EAAMX,GACxC,GAAiB,MAAbsD,IAEa,MAAbD,GACAC,EAAUjG,SAAWgG,EAAUhG,UAC9BiG,EAAUjG,UAAYgG,EAAUhG,UAAYiG,EAAU9mC,IAAM6mC,EAAU7mC,KACvE,CACA6mC,EAAYC,EACZ,K,EAaN,OALI9qD,KAAKoqD,QAAQjC,IACfA,EAAK6C,QAAQhrD,KAAK+mD,QAAU,GAAK,GAEnC/mD,KAAKknD,YAAclnD,KAAKmnD,YACxBnnD,KAAKmnD,YAAc,GACZ0D,CACT,EAEAhE,EAAAzkD,UAAA2oD,WAAA,SAAW5C,EAAYX,GACjBxnD,KAAK2oD,QAAQ3oD,KAAK2oD,OAAOsC,cAAczD,EAAQW,EAAK33C,MAAOxQ,KAAKqmD,KACpE,IAAIwE,EAAiC,KAE/B3E,EADSlmD,KAAK8mD,KAAKrB,OACJ+B,EAAOrnD,QACtBylD,EAASM,EAAMN,OAEf+B,GADOzB,EAAMhqC,KACLlc,KAAK+mD,QAAU,GAAK,GAE9BmE,GAAc,EAElB,OAAQtF,GACN,KAAKV,GAAOkE,OACV,MAAM,IAAIv9C,MAAM,gEAElB,KAAKq5C,GAAOwE,MACJ,IAAAxd,EAAAmH,GAAyB6S,EAAMhqC,KAAI,GAAlCytC,EAAOzd,EAAA,GAAEoV,EAAMpV,EAAA,GAAEloB,EAAGkoB,EAAA,GAC3BrG,EAAsB,GAAX8jB,EAAc,kCACnB,IAAAja,EAAA2D,GAA2BrzC,KAAKwpD,aAAarB,EAAMA,EAAK33C,MAAO01C,EAAM/lD,OAAS,EAAG6jB,GAAK,EAAgB,GAAVs9B,GAAY,GAAvGmI,EAAY/Z,EAAA,GAAUA,EAAA,GACzB+Z,GAIFzpD,KAAKkoD,UAAUloD,KAAK4nD,OAAOJ,EAAQxjC,EAAM,GAAIhkB,KAAKmnD,YAAagB,GAEjE,MACF,KAAKjD,GAAOiG,IAEV,IAAMlzB,EAAM,IAAIktB,IAAO,GAAI,EAAGnlD,KAAKonD,SAAUe,EAAK33C,OAGlD,OAFAynB,EAAImtB,OAASoC,EAAOpC,OACpBntB,EAAIotB,UAAYmC,EAAOnC,UAChBptB,EAET,KAAKitB,GAAOC,MAIV,GAAIgD,EAAK33C,MAAQxQ,KAAKonD,SAAU,CAC9B,IAAMgE,EAAelF,EAAMhqC,KAAK,GAC1B4oC,EAAaoB,EAAMhqC,KAAK,IAC9B2uC,EAAY,IAAI1F,IACN5xB,MAAQvzB,KAAKonD,SACvByD,EAAU7mC,IAAMmkC,EAAK33C,MACrBq6C,EAAUhG,SAAWuG,EACrBP,EAAU/F,WAAaA,EACvB+F,EAAUzF,OAASoC,EAAOpC,OAC1ByF,EAAUxF,UAAYmC,EAAOnC,S,CAE/B,MACF,KAAKH,GAAOtC,KACZ,KAAKsC,GAAOmG,OACNrrD,KAAKoqD,QAAQjC,KACf+C,EAAclrD,KAAKgqD,aAAa7B,EAAMjC,EAAMvtC,KAAOitC,GAAUV,GAAOmG,SAEtE,MASF,KAAKnG,GAAOoG,SACZ,KAAKpG,GAAO/B,IACNnjD,KAAKoqD,QAAQjC,KACf+C,EAActF,GAAUV,GAAO/B,MAAQ8B,GAAckD,EAAKoD,SAOhE,OAHIL,GACFlrD,KAAKkoD,UAAUloD,KAAK0nD,OAAOF,EAAQ,GAAIxnD,KAAKmnD,YAAagB,EAAMR,GAE1DkD,CACT,EACFhE,CAAA,CA7ZA,GA+ZM,SAAUZ,GAAgBC,GAC9B,OAAQA,EAAMN,QACZ,KAAKV,GAAOC,MACV,MAAO,SAAA12C,OAASy3C,EAAMhqC,KAAK,GAAE,KAAAzN,OAAIy3C,EAAMhqC,KAAK,IAG9C,KAAKgpC,GAAOtC,KACZ,KAAKsC,GAAOmG,OAKV,MAJU,GAAA58C,OAAGy2C,GAAOgB,EAAMN,QAAQ1jD,WAAU,KAGrC,GAAAuM,OAAGy3C,EAAMvtC,KAAMqlB,cAGxB,KAAKknB,GAAO/B,IACV,MAAO,IACT,KAAK+B,GAAOoG,SACV,MAAO,MACT,KAAKpG,GAAO6D,aACV,MAAO,IACT,KAAK7D,GAAO8D,eACV,MAAO,MACT,KAAK9D,GAAOgE,WACV,MAAO,MACT,KAAKhE,GAAOiE,aACV,MAAO,gBACT,KAAKjE,GAAOwD,KACV,MAAO,QAAAj6C,OAAQy3C,EAAMhqC,KAAK,IAC5B,KAAKgpC,GAAO2D,WACV,MAAO,cAAAp6C,OAAcy3C,EAAMhqC,KAAK,IAClC,KAAKgpC,GAAO4D,SACV,MAAO,YAAAr6C,OAAYy3C,EAAMhqC,KAAK,IAChC,KAAKgpC,GAAOqD,MACV,MAAO,SAAA95C,OAASy3C,EAAMhqC,KAAKxN,KAAK,OAClC,KAAKw2C,GAAOoD,KACV,MAAO,QAAA75C,OAAQy3C,EAAMhqC,KAAK,IAC5B,KAAKgpC,GAAOwE,MACV,MAAO,SAAAj7C,OAASy3C,EAAMhqC,KAAKxN,KAAK,MAClC,KAAKw2C,GAAOkE,OACV,MAAO,UAAA36C,OAAUy3C,EAAMhqC,KAAKxN,KAAK,MACnC,KAAKw2C,GAAOiG,IACV,MAAO,OAAA18C,OAAOy3C,EAAMhqC,KAAKxN,KAAK,MAChC,KAAKw2C,GAAO0E,YACV,MAAO,eAAAn7C,OAAey3C,EAAMhqC,KAAKxN,KAAK,MACxC,QACE,MAAM,IAAI7C,MAAM,mBAAqBq6C,EAAMN,QAEjD,C,iTCpmBA4F,GAAA,WAGE,SAAAA,EACSC,EACAhxC,QAAA,IAAAA,IAAAA,EAAA,MADA,KAAAgxC,cAAAA,EACA,KAAAhxC,SAAAA,EAJT,KAAAixC,YAAa,EACb,KAAAC,cAAe,CAIZ,CAsRL,OApREH,EAAAppD,UAAAwpD,QAAA,SAAQxQ,GAAR,IAAA/E,EAAA,KAEQpe,EAAM,IAAIqtB,GAEVr5C,EAAemvC,EAAMt2C,QAAU,EAAI,IAAI+gD,GAAMX,GAAOqD,OAAStwB,EAAIqK,IAAI4iB,GAAOqD,MAAO,MAgBzF,OAfAnN,EAAM12C,QAAQ,SAACgyC,EAAM71C,GACnBoL,EAAMq2B,IAAIrK,EAAIwtB,OAAO3gD,QACrB,IAAMs7C,EAAqC,MAAxB1J,EAAK0K,KAAKhB,YAA6B1J,EAAK0K,KAAKhB,WAC9DC,EAA6B,MAApB3J,EAAK0K,KAAKf,QAAwB3J,EAAK0K,KAAKf,OACrDC,EAAmC,MAAvB5J,EAAK0K,KAAKd,WAA2B5J,EAAK0K,KAAKd,UACjE,GAAI5J,EAAKmV,qBAA4C,MAArBnV,EAAKqO,aAAsB,CACzD,IAAM+G,EAAc7zB,EAAIqK,IAAI4iB,GAAO0E,YAAa,MAChDlT,EAAKqO,aAAargD,QAAQ,SAACgkB,GACzB,IAAMqjC,EAAM9zB,EAAI0tB,cAAcj9B,GAC9BojC,EAAYxpB,IAAIypB,EAClB,E,CAEF1V,EAAK2V,YAAYtV,EAAK0K,KAAMnpB,EAAKmoB,EAAYC,EAAQC,GACrDroB,EAAIqK,IAAI4iB,GAAOC,MAAO,MAAM7iB,IAAIoU,EAAKmO,SAAUnO,EAAKoO,YAAc,EAAIpO,EAAKoO,WAAajkD,EAC1F,GACOo3B,CACT,EAKUuzB,EAAAppD,UAAA4pD,YAAV,SAAsB5K,EAAa0F,EAAY1G,EAAqBC,EAAiBC,GACnF,IAAM/sB,EAAQuzB,EAAKhiD,OACbmnD,EAAanF,EAAKhiD,OAKxB,GAJIs8C,EAAKnB,YAAc,IACjBjgD,KAAK2rD,cAAc7E,EAAKxkB,IAAI4iB,GAAOwD,MAAMpmB,IAA4B,GAAvB,EAAI8e,EAAKnB,aACvDjgD,KAAK0rD,YAAY5E,EAAKxkB,IAAI4iB,GAAO2D,YAAYvmB,IAAI,EAAI8e,EAAKnB,aAE5DmB,EAAKV,KAAOZ,GAAUgD,KACxB9iD,KAAKksD,YAAY9K,EAAc0F,EAAM1G,EAAYC,EAAQC,QACpD,GAAIc,EAAKV,KAAOZ,GAAUa,eAAgB,CAC/C,IAAMwL,EAAuB,MAAlB/K,EAAKd,UAAoBA,EAAYc,EAAKd,UACrDwG,EAAKxkB,IAAI6pB,EAAKjH,GAAO8D,eAAiB9D,GAAO6D,a,MACxC,GAAI3H,EAAKV,KAAOZ,GAAUgB,aACzBqL,EAAuB,MAAlB/K,EAAKd,UAAoBA,EAAYc,EAAKd,UACrDwG,EAAKxkB,IAAI6pB,EAAKjH,GAAOiE,aAAejE,GAAOgE,iBACtC,GAAI9H,EAAKV,KAAOZ,GAAUmB,cAC/B6F,EAAKxkB,IAAI4iB,GAAOlE,kBACX,GAAII,EAAKV,KAAOZ,GAAUqB,YAC/B2F,EAAKxkB,IAAI4iB,GAAOhE,gBACX,GAAIE,EAAKV,KAAOZ,GAAUsC,IAC/BpiD,KAAKosD,WAAWhL,EAAa0F,EAAM1G,EAAYC,EAAQC,QAClD,GAAIc,EAAKV,KAAOZ,GAAU2C,MAC/BziD,KAAKqsD,aAAajL,EAAe0F,EAAM1G,EAAYC,EAAQC,QACtD,GAAIc,EAAKV,KAAOZ,GAAUiC,MAC/B/hD,KAAKssD,aAAalL,EAAe0F,EAAM1G,EAAYC,EAAQC,QACtD,GAAIc,EAAKV,KAAOZ,GAAUwE,IAC/BtkD,KAAKusD,WAAWnL,EAAa0F,EAAM1G,EAAYC,EAAQC,QAClD,GAAIc,EAAKV,KAAOZ,GAAU0E,eAC/BxkD,KAAKwsD,oBAAoBpL,EAAsB0F,EAAM1G,EAAYC,EAAQC,QACpE,GAAIc,EAAKV,KAAOZ,GAAU6E,aAC/B3kD,KAAKysD,kBAAkBrL,EAAoB0F,EAAM1G,EAAYC,EAAQC,QAEhE,GAAIc,EAAKV,KAAOZ,GAAU0B,WAC/BxhD,KAAK0sD,iBAAiBtL,EAAmB0F,EAAM1G,EAAYC,EAAQC,OAC9D,IAAIc,EAAKV,KAAOZ,GAAU4B,UAG/B,MAAM,IAAI71C,MAAM,iCAAmCu1C,EAAKV,KAFxD1gD,KAAK2sD,gBAAgBvL,EAAkB0F,EAAM1G,EAAYC,EAAQC,E,CAWnE,OAPIc,EAAKnB,YAAc,IACjBjgD,KAAK0rD,YAAY5E,EAAKxkB,IAAI4iB,GAAO4D,UAAUxmB,IAAI,EAAI8e,EAAKnB,YACxDjgD,KAAK2rD,cAAc7E,EAAKxkB,IAAI4iB,GAAOwD,MAAMpmB,IAA4B,GAAvB,EAAI8e,EAAKnB,YAAkB,IAE3EjgD,KAAKya,UAAYqsC,EAAKhiD,OAASmnD,GACjCjsD,KAAKya,SAAS2mC,EAAM0F,EAAMmF,EAAYnF,EAAKhiD,OAASmnD,GAE/CnF,EAAKhiD,OAASyuB,CACvB,EAEUi4B,EAAAppD,UAAA8pD,YAAV,SAAsBvzC,EAAYmuC,EAAY1G,EAAqBC,EAAiBC,GAC9E3nC,EAAKkqC,IAAM9C,GAASqD,QAEtB0D,EAAKxkB,IAAI+d,EAAS6E,GAAO/B,IAAM+B,GAAOoG,UAExBxE,EAAKxkB,IAAI8d,EAAa8E,GAAOmG,OAASnG,GAAOtC,MACrDjqC,KAAOA,CAYjB,EAEU6yC,EAAAppD,UAAAgqD,WAAV,SAAqBQ,EAAU9F,EAAY1G,EAAqBC,EAAiBC,G,YAC/E,IAAoB,IAAA5Q,EAAAgE,GAAAkZ,EAAI3tB,UAAQ2U,EAAAlE,EAAAzkC,QAAA2oC,EAAA1oC,KAAA0oC,EAAAlE,EAAAzkC,OAAE,CAA7B,IAAMs0B,EAAKqU,EAAAvyC,MACdrB,KAAKgsD,YAAYzsB,EAAOunB,EAAM1G,EAAYC,EAAQC,E,mGAEtD,EAEUkL,EAAAppD,UAAAqqD,kBAAV,SACEI,EACA/F,EACA1G,EACAC,EACAC,GAKA,MAAM,IAAIz0C,MAAM,6BAClB,EAEU2/C,EAAAppD,UAAAoqD,oBAAV,SACEK,EACA/F,EACA1G,EACAC,EACAC,GAKA,MAAM,IAAIz0C,MAAM,8BAClB,EAEU2/C,EAAAppD,UAAAmqD,WAAV,SAAqB3rB,EAAQkmB,EAAY1G,EAAqBC,EAAiBC,GAC7E,IAAM75C,EAAOm6B,EAAEn6B,KAAK6C,OACd83C,EAAOphD,KAAKyrD,cAAgBzrD,KAAKyrD,cAAchlD,GAAQ,KAC7D,GAAY,MAAR26C,EACF,MAAM,IAAIv1C,MAAM,2BAAA4C,OAA2BhI,IAE7CzG,KAAKgsD,YAAY5K,EAAM0F,EAAM1G,EAAYC,EAAQC,EACnD,EAEUkL,EAAAppD,UAAAiqD,aAAV,SAAuBS,EAAchG,EAAY1G,EAAqBC,EAAiBC,GAIrF,I,QAHMr0C,EAAQ66C,EAAKxkB,IAAI4iB,GAAOqD,OACxBwE,EAAiB,GAEdlsD,EAAI,EAAGA,EAAIisD,EAAMv9C,QAAQzK,OAAQjE,IACxCoL,EAAMq2B,IAAIwkB,EAAKhiD,QACf9E,KAAKgsD,YAAYc,EAAMv9C,QAAQ1O,GAAIimD,EAAM1G,EAAYC,EAAQC,GACzDz/C,EAAIisD,EAAMv9C,QAAQzK,OAAS,GAC7BioD,EAAMrlD,KAAKo/C,EAAKxkB,IAAI4iB,GAAOoD,O,IAG/B,IAAkB,IAAA0E,EAAAtZ,GAAAqZ,GAAKE,EAAAD,EAAA/hD,QAAAgiD,EAAA/hD,KAAA+hD,EAAAD,EAAA/hD,OAATgiD,EAAA5rD,MACRihC,IAAIwkB,EAAKhiD,O,kGAEjB,EAMU0mD,EAAAppD,UAAAkqD,aAAV,SAAuBrK,EAAc6E,EAAY1G,EAAqBC,EAAiBC,GAErF,GAAsB,GAAlB2B,EAAML,UAAiBK,EAAMJ,UAAYhc,EAE3C7lC,KAAKktD,gBAAgBjL,EAAMb,KAAM0F,EAAM7E,EAAMH,OAAQ1B,EAAYC,EAAQC,QACpE,GAAsB,GAAlB2B,EAAML,UAAiBK,EAAMJ,UAAYhc,EAElD7lC,KAAKmtD,gBAAgBlL,EAAMb,KAAM0F,EAAM7E,EAAMH,OAAQ1B,EAAYC,EAAQC,QACpE,GAAsB,GAAlB2B,EAAML,UAAmC,GAAlBK,EAAMJ,SAEtC7hD,KAAKotD,gBAAgBnL,EAAMb,KAAM0F,EAAM7E,EAAMH,OAAQ1B,EAAYC,EAAQC,OACpE,CAIL,IAAK,IAAIz/C,EAAI,EAAGA,EAAIohD,EAAML,SAAU/gD,IAClCb,KAAKgsD,YAAY/J,EAAMb,KAAM0F,EAAM1G,EAAYC,EAAQC,GAGzD,GAAI2B,EAAMC,YAERliD,KAAKktD,gBAAgBjL,EAAMb,KAAM0F,EAAM7E,EAAMH,OAAQ1B,EAAYC,EAAQC,QAEzE,IAASz/C,EAAIohD,EAAML,SAAU/gD,EAAIohD,EAAMJ,SAAUhhD,IAC/Cb,KAAKotD,gBAAgBnL,EAAMb,KAAM0F,EAAM7E,EAAMH,OAAQ1B,EAAYC,EAAQC,E,CAIjF,EAEUkL,EAAAppD,UAAA+qD,gBAAV,SACE/L,EACA0F,EACAhF,EACA1B,EACAC,EACAC,QAHA,IAAAwB,IAAAA,GAAA,GAKA,IAAMuL,EAAKvG,EAAKhiD,OAChB9E,KAAKgsD,YAAY5K,EAAM0F,EAAM1G,EAAYC,EAAQC,GACjD,IAAMr0C,EAAQ66C,EAAKxkB,IAAI4iB,GAAOqD,OACxB+E,EAAKxG,EAAKhiD,OACZg9C,EACF71C,EAAMq2B,IAAI+qB,EAAIC,GAEdrhD,EAAMq2B,IAAIgrB,EAAID,EAElB,EAEU7B,EAAAppD,UAAA8qD,gBAAV,SACE9L,EACA0F,EACAhF,EACA1B,EACAC,EACAC,GAEA,IAAMr0C,EAAQ66C,EAAKxkB,IAAI4iB,GAAOqD,OACxB8E,EAAKphD,EAAM9L,OACXotD,EAAKzG,EAAKhiD,OAChB9E,KAAKgsD,YAAY5K,EAAM0F,EAAM1G,EAAYC,EAAQC,GACjDwG,EAAKxkB,IAAI4iB,GAAOoD,MAAMhmB,IAAI+qB,GAC1B,IAAMC,EAAKxG,EAAKhiD,OACZg9C,EACF71C,EAAMq2B,IAAIirB,EAAID,GAEdrhD,EAAMq2B,IAAIgrB,EAAIC,EAElB,EAEU/B,EAAAppD,UAAAgrD,gBAAV,SACEhM,EACA0F,EACAhF,EACA1B,EACAC,EACAC,GAEA,IAAMr0C,EAAQ66C,EAAKxkB,IAAI4iB,GAAOqD,OACxB8E,EAAKvG,EAAKhiD,OAChB9E,KAAKgsD,YAAY5K,EAAM0F,EAAM1G,EAAYC,EAAQC,GACjD,IAAMiN,EAAKzG,EAAKhiD,OACZg9C,EACF71C,EAAMq2B,IAAI+qB,EAAIE,GAEdthD,EAAMq2B,IAAIirB,EAAIF,EAElB,EAKU7B,EAAAppD,UAAAsqD,iBAAV,SACEc,EACA1G,EACA1G,EACAC,EACAC,GAIAtgD,KAAKgsD,YAAYwB,EAAGpM,KAAM0F,EAAM1G,EAAYC,EAAQC,GACpD,IAAMmN,EAAQ3G,EAAKxkB,IAAI4iB,GAAOwE,OAAOpnB,IAAI,EAAGkrB,EAAGlM,OAAS,EAAI,GAC5DthD,KAAKgsD,YAAYwB,EAAGnM,KAAMyF,EAAM1G,EAAYC,EAAQC,GACpD,IAAMt8B,EAAM8iC,EAAKxkB,IAAI4iB,GAAOiG,KAAK7oB,IAAImrB,EAAMttD,QAC3CstD,EAAMnrB,IAAIte,EAAI7jB,OAChB,EAKUqrD,EAAAppD,UAAAuqD,gBAAV,SAA0Be,EAAc5G,EAAY1G,EAAqBC,EAAiBC,GAExFtgD,KAAKgsD,YAAY0B,EAAGtM,KAAM0F,EAAM1G,EAAYC,EAAQC,GACpDza,EAAW6nB,EAAGtM,KAAKnB,YAAc,EAAG,gEACpC,IAAMwN,EAAQ3G,EAAKxkB,IAAI4iB,GAAOkE,QAAQ9mB,IAAIorB,EAAGtM,KAAKnB,WAAYyN,EAAGpM,OAAS,EAAI,GAC9EthD,KAAKgsD,YAAY0B,EAAGrM,KAAKT,UAAWkG,EAAM1G,EAAYC,EAAQC,GAC9D,IAAMt8B,EAAM8iC,EAAKxkB,IAAI4iB,GAAOiG,KAAK7oB,IAAImrB,EAAMttD,QAC3CstD,EAAMnrB,IAAIte,EAAI7jB,OAChB,EACFqrD,CAAA,CA5RA,G,2dCvBAmC,GAAA,SAAAjW,GAGE,SAAAiW,EACErgD,EACOnN,EACA2E,EACA5B,EACA7B,QAAA,IAAAA,IAAAA,EAAA,M,uBALTg1C,EAOEqB,EAAA50C,KAAA,KAAMwK,IAAQ,K,OALP+oC,EAAAl2C,OAAAA,EACAk2C,EAAAvxC,OAAAA,EACAuxC,EAAAnzC,KAAAA,EACAmzC,EAAAh1C,MAAAA,EAPAg1C,EAAA5vC,KAAe,iBAUtBtE,OAAOyrD,eAAevX,EAAMwX,EAAWzrD,W,CACzC,CACF,OAboCw1C,GAAA+V,EAAAjW,GAapCiW,CAAA,CAbA,CAAoC9hD,OAepCiiD,GAAA,SAAApW,GAIE,SAAAoW,EAAmBC,G,IAAiC,IAAAC,EAAA,GAAAlV,EAAA,EAAAA,EAAA72C,UAAA6C,OAAAg0C,IAAAkV,EAAAlV,EAAA,GAAA72C,UAAA62C,GAApD,IAAAzC,EACEqB,EAAA50C,KAAA,KACE,gBAAA2L,QAAgBs/C,aAAU,EAAVA,EAAYrN,MAAO,MAAK,MAAAjyC,QAAKs/C,aAAU,EAAVA,EAAY1sD,QAAS,GAAE,iBAAAoN,OAAgBu/C,EAAet/C,KAAK,SACzG,K,OAHgB2nC,EAAA0X,WAAAA,EAHV1X,EAAA5vC,KAAe,uBAOtB4vC,EAAK2X,eAAiBA,E,CACxB,CACF,OAV0CpW,GAAAkW,EAAApW,GAU1CoW,CAAA,CAVA,CAA0CjiD,O,y7BC0D1CoiD,GAAA,SAAAvW,GAIE,SAAAuW,EAAYC,EAAsBnH,QAAA,IAAAA,IAAAA,GAAA,GAAlC,IAAA1Q,EACEqB,EAAA50C,KAAA,KAAMikD,IAAQ,K,OADkB1Q,EAAA0Q,QAAAA,EAEhC1Q,EAAK8X,UAAYD,EACjB7X,EAAK6X,MAAK3a,GAAA,GAAAF,GAAO6a,IAAK,G,CACxB,CAoBF,OA5B0BtW,GAAAqW,EAAAvW,GAUxBuW,EAAA7rD,UAAAsF,KAAA,SAAK+B,G,MACHzJ,KAAKmuD,WAAa1kD,GAClByiC,EAAAlsC,KAAKkuD,OAAMxmD,KAAI1F,MAAAkqC,EAAAqH,GAAC,GAADF,GAAI5pC,IAAO,GAC5B,EAEAwkD,EAAA7rD,UAAAqV,UAAA,SAAU4hC,EAAoBC,GAC5B,OAAOt5C,KAAKmuD,UAAU12C,UAAU4hC,EAAYC,EAE9C,EAEA2U,EAAA7rD,UAAAgsD,SAAA,SAAS59C,GACP,OAAOA,GAAS,GAAKA,EAAQxQ,KAAKkuD,MAAMppD,MAC1C,EAEAmpD,EAAA7rD,UAAAioD,OAAA,SAAO75C,GACL,OAAIA,EAAQ,GAAKA,GAASxQ,KAAKkuD,MAAMppD,OAAe,GAC7C9E,KAAKkuD,MAAM19C,EACpB,EACFy9C,CAAA,CA5BA,CA5EA,WAME,SAAAI,EAAmBtH,QAAA,IAAAA,IAAAA,GAAA,QAAAA,QAAAA,EALnB,KAAAv2C,MAAQ,CAK4B,CA+DtC,OA7DE69C,EAAAjsD,UAAA4oD,QAAA,SAAQrD,QAAA,IAAAA,IAAAA,EAAA,GACN,IAAM18C,EAAOjL,KAAK+mD,QAAU/mD,KAAKwQ,MAAQm3C,EAAQ3nD,KAAKwQ,MAAQm3C,EAG9D,OADA3nD,KAAKwQ,MAAQvF,GACN,CACT,EAEAojD,EAAAjsD,UAAAuoD,WAAA,SAAWhD,QAAA,IAAAA,IAAAA,EAAA,GACT,IAAM18C,EAAOjL,KAAK+mD,QAAU/mD,KAAKwQ,MAAQm3C,EAAQ3nD,KAAKwQ,MAAQm3C,EAC9D,OAAO3nD,KAAKouD,SAASnjD,EACvB,EAEA9I,OAAA2H,eAAIukD,EAAAjsD,UAAA,UAAO,C,IAAX,WACE,IAAM6I,EAAOjL,KAAK+mD,QAAU/mD,KAAKwQ,MAAQxQ,KAAKwQ,MAAQ,EACtD,OAAOxQ,KAAKouD,SAASnjD,EAEvB,E,gCAEA9I,OAAA2H,eAAIukD,EAAAjsD,UAAA,SAAM,C,IAAV,WACE,OAAOpC,KAAKqqD,OAAOrqD,KAAKwQ,MAC1B,E,gCAEArO,OAAA2H,eAAIukD,EAAAjsD,UAAA,SAAM,C,IAAV,WACE,OAAOpC,KAAKqqD,OAAOrqD,KAAKwQ,OAASxQ,KAAK+mD,QAAU,GAAK,GACvD,E,gCAEA5kD,OAAA2H,eAAIukD,EAAAjsD,UAAA,SAAM,C,IAAV,WACE,IAAM6I,EAAOjL,KAAKwQ,OAASxQ,KAAK+mD,QAAU,GAAK,GAC/C,OAAO/mD,KAAKqqD,OAAOp/C,EACrB,E,gCAEA9I,OAAA2H,eAAIukD,EAAAjsD,UAAA,aAAU,C,IAAd,WACE,OAAKpC,KAAKoqD,QACHpqD,KAAKurD,OAAO7hD,WAAW,IADH,CAG7B,E,gCAEAvH,OAAA2H,eAAIukD,EAAAjsD,UAAA,kBAAe,C,IAAnB,WACE,OAAKpC,KAAKoqD,QACHpqD,KAAKurD,OAAOvoD,cAAc0G,WAAW,IADjB,CAE7B,E,gCAEAvH,OAAA2H,eAAIukD,EAAAjsD,UAAA,kBAAe,C,IAAnB,WACE,OAAKpC,KAAKoqD,QACHpqD,KAAKurD,OAAOl/C,cAAc3C,WAAW,IADjB,CAE7B,E,gCAEA2kD,EAAAjsD,UAAAsH,WAAA,SAAW8G,GACT,OAAKxQ,KAAKouD,SAAS59C,GACZxQ,KAAKqqD,OAAO75C,GAAO9G,WAAW,IADF,CAErC,EAEA2kD,EAAAjsD,UAAAksD,gBAAA,SAAgB99C,GACd,OAAKxQ,KAAKouD,SAAS59C,GACZxQ,KAAKqqD,OAAO75C,GAAOxN,cAAc0G,WAAW,IADhB,CAErC,EAEA2kD,EAAAjsD,UAAAmsD,gBAAA,SAAgB/9C,GACd,OAAKxQ,KAAKouD,SAAS59C,GACZxQ,KAAKqqD,OAAO75C,GAAOnE,cAAc3C,WAAW,IADhB,CAErC,EACF2kD,CAAA,CArEA,IA0GAG,GAAA,oBAAAA,IAiEA,QA5DSA,EAAAC,aAAP,SAAoBtG,EAAqBuG,EAAiBC,QAAA,IAAAA,IAAAA,GAAA,GACxD,IAAI1qC,EAAMuqC,EAAWI,UAAUzG,EAAMuG,EAASC,GAK9C,OAJI1qC,GAAO,IACTA,GAAOyqC,EAAQ5pD,OACfqjD,EAAK33C,MAAQyT,GAERA,CACT,EAQOuqC,EAAAI,UAAP,SAAiBzG,EAAqBuG,EAAiBC,QAAA,IAAAA,IAAAA,GAAA,GAErD,IADA,IAAMhkD,EAAYw9C,EAAK33C,MAChB23C,EAAKiC,SAAS,CACnB,IAAMyE,EAAY1G,EAAK33C,MACvB,GAAIg+C,EAAWljD,QAAQ68C,EAAMuG,GAAU,CACrC,IAAMpV,EAAW6O,EAAK33C,MACtB23C,EAAK33C,MAAQq+C,EACb,IAAIC,EAAa,EACjB,GAAIH,EACF,IAAK,IAAI9tD,EAAIy4C,EAAW,EAAGz4C,GAAK,GACR,MAAlBsnD,EAAKkC,OAAOxpD,GADiBA,IACLiuD,IAIhC,GAAIA,EAAa,GAAK,EACpB,OAAO3G,EAAK33C,K,CAGhB23C,EAAK6C,QAAQ,E,CAGf,MADA7C,EAAK33C,MAAQ7F,EACP,IAAIkB,MAAM,mCAAA4C,OAAmCigD,EAAO,KAE5D,EAKOF,EAAAljD,QAAP,SAAe68C,EAAqB4G,EAAgB/D,QAAA,IAAAA,IAAAA,GAAA,GAIlD,IAHA,IAAMrgD,EAAYw9C,EAAK33C,MACnB3P,EAAI,EACJmuD,GAAU,EACPnuD,EAAIkuD,EAAOjqD,OAAQjE,IAAK,CAC7B,GAAIkuD,EAAOluD,IAAMsnD,EAAKoD,OAAQ,CAC5ByD,GAAU,EACV,K,CAEF7G,EAAK6C,QAAQ,E,CAMf,OAHKA,GAAYgE,IACf7G,EAAK33C,MAAQ7F,GAERqkD,CACT,EACFR,CAAA,CAjEA,G,2wBCpGAS,GAAA,WAOE,SAAAA,EAAmBvO,EAAgCoE,EAA2BvxB,EAAsBvP,GAAjF,KAAA08B,IAAAA,EAAgC,KAAAoE,WAAAA,EAA2B,KAAAvxB,MAAAA,EAAsB,KAAAvP,IAAAA,EAJpG,KAAA5R,GAAK68C,EAAM/hB,YACX,KAAA7rC,MAAa,KACb,KAAA+jD,OAA+B,CAAC,EAChC,KAAAC,UAA0C,CAAC,CACuE,CAUpH,OARE4J,EAAA7sD,UAAA8sD,QAAA,W,YAAQC,EAAA,GAAArW,EAAA,EAAAA,EAAA72C,UAAA6C,OAAAg0C,IAAAqW,EAAArW,GAAA72C,UAAA62C,G,IACN,IAAkB,IAAAsW,EAAA1b,GAAAyb,GAAQE,EAAAD,EAAAnkD,QAAAokD,EAAAnkD,KAAAmkD,EAAAD,EAAAnkD,OAAE,CAAvB,IAAMqkD,EAAGD,EAAAhuD,MACZ,GAAIrB,KAAK0gD,KAAO4O,EACd,OAAO,C,mGAGX,OAAO,CACT,EAfeL,EAAA/hB,UAAY,EAgB7B+hB,C,CAjBA,GAyBAM,GAAA,WAGE,SAAAA,EAA4BC,EAAiCC,GAAjC,KAAAD,UAAAA,EAAiC,KAAAC,iBAAAA,EAF7D,KAAAvvD,OAAkB,EAEmE,CA0EvF,OAxEEqvD,EAAAntD,UAAA6I,KAAA,SAAKk9C,GACH,IAAMlwB,EAAMj4B,KAAK0vD,KAAKvH,GAItB,OAHW,MAAPlwB,GACFj4B,KAAK2pD,UAEA1xB,CACT,EAKAs3B,EAAAntD,UAAAstD,KAAA,SAAKvH,EAAYwH,GACf,SADe,IAAAA,IAAAA,EAAA,GACR3vD,KAAKE,OAAO4E,QAAU6qD,GAAK,CAChC,IAAML,EAAMtvD,KAAKwvD,UAAUrH,EAAMnoD,KAAKyvD,kBACtC,GAAW,MAAPH,EAAa,OAAO,KACxBtvD,KAAKE,OAAOwH,KAAK4nD,E,CAEnB,OAAOtvD,KAAKE,OAAOyvD,EACrB,EAEAJ,EAAAntD,UAAA2O,MAAA,SACEo3C,EACAyH,EACA7a,EACA4U,EACAkG,QAFA,IAAA9a,IAAAA,GAAA,QACA,IAAA4U,IAAAA,GAAA,GAGA,IAAMziD,EAAQlH,KAAK0vD,KAAKvH,GACxB,GAAa,MAATjhD,EAAe,CACjB,IAAI0oD,EAAU1oD,GAOP,IAAI6tC,EAET,MAAM,IAAI+Y,GAAqB5mD,GAE/B,OAAO,I,CAVH2oD,GAA4B,MAAdA,GAChBA,EAAW3oD,GAETyiD,GACF3pD,KAAK2pD,S,MAQJ,GAAI5U,EACT,MAAM,IAAI4Y,GAAe,2BAA4B,EAAG,EAAG,wBAE7D,OAAOzmD,CACT,EAEAqoD,EAAAntD,UAAAunD,QAAA,WACE3pD,KAAKE,OAAO6rB,OAAO,EAAG,EACxB,EAEAwjC,EAAAntD,UAAA0tD,UAAA,SAAU3H,G,IAAY,IAAAgH,EAAA,GAAArW,EAAA,EAAAA,EAAA72C,UAAA6C,OAAAg0C,IAAAqW,EAAArW,EAAA,GAAA72C,UAAA62C,GACpB,OAAO94C,KAAK+Q,MAAMo3C,EAAM,SAACrlB,GAAM,OAAAA,EAAEosB,QAAOltD,MAAT8gC,EAACyQ,GAAA,GAAAF,GAAY8b,IAAQ,GAArB,EACjC,EAEAI,EAAAntD,UAAA2tD,YAAA,SAAY5H,G,IAAY,IAAAgH,EAAA,GAAArW,EAAA,EAAAA,EAAA72C,UAAA6C,OAAAg0C,IAAAqW,EAAArW,EAAA,GAAA72C,UAAA62C,GACtB,OAAO94C,KAAK+Q,MAAMo3C,EAAM,SAACrlB,GAAM,OAAAA,EAAEosB,QAAOltD,MAAT8gC,EAACyQ,GAAA,GAAAF,GAAY8b,IAAW,GAAxB,GAAwB,GAAM,EAC/D,EAEAI,EAAAntD,UAAA4tD,YAAA,SAAY7H,G,IAAY,IAAAgH,EAAA,GAAArW,EAAA,EAAAA,EAAA72C,UAAA6C,OAAAg0C,IAAAqW,EAAArW,EAAA,GAAA72C,UAAA62C,GACtB,OAAO94C,KAAK+Q,MAAMo3C,EAAM,SAACrlB,GAAM,OAAAA,EAAEosB,QAAOltD,MAAT8gC,EAACyQ,GAAA,GAAAF,GAAY8b,IAAW,GAAxB,GAAwB,GAAM,EAC/D,EAEAI,EAAAntD,UAAA6tD,YAAA,SAAY9H,G,YAAYgH,EAAA,GAAArW,EAAA,EAAAA,EAAA72C,UAAA6C,OAAAg0C,IAAAqW,EAAArW,EAAA,GAAA72C,UAAA62C,GACtB,IAAM5xC,EAAQlH,KAAK0vD,KAAKvH,GACxB,GAAa,MAATjhD,EAAe,OAAO,K,IAC1B,IAAkB,IAAAgpD,EAAAxc,GAAAyb,GAAQgB,EAAAD,EAAAjlD,QAAAklD,EAAAjlD,KAAAilD,EAAAD,EAAAjlD,OAAE,CAAvB,IAAMqkD,EAAGa,EAAA9uD,MACZ,GAAI6F,EAAMw5C,KAAO4O,EAAK,OAAOpoD,C,mGAE/B,OAAO,IACT,EACFqoD,CAAA,CA7EA,GC/BAa,GAAA,oBAAAA,IACE,KAAA/uD,OAAS,CAOX,QANE+uD,EAAAhuD,UAAA6I,KAAA,WACE,QAASjL,KAAKqB,KAChB,EACAc,OAAA2H,eAAIsmD,EAAAhuD,UAAA,UAAO,C,IAAX,WACE,OAAOpC,KAAKqB,KACd,E,gCACF+uD,CAAA,CARA,GAUM,SAAUC,GAAQtN,GACtB,MAAa,KAANA,GAAmB,MAANA,GAAoB,MAANA,GAAoB,MAANA,CAClD,C,keCcAuN,GAAA,WAOE,SAAAA,EAA4B5B,EAAiBlhD,GAAjB,KAAAkhD,QAAAA,EAC1B1uD,KAAK29B,QAAU,IAAIyyB,GACnBpwD,KAAKuwD,SAAU/iD,aAAM,EAANA,EAAQ+iD,WAAW,CACpC,CAgbF,OA9aYD,EAAAluD,UAAAouD,WAAV,SAAqB3jD,GACnB,IAAM0gC,EAAoB,GAAhB1gC,EAAM/H,OAAc+H,EAAM,GAAI,IAAKs1C,GAAGtgD,KAAAG,MAAHmgD,GAAG5O,GAAC,MAAD,GAAAF,GAAIxmC,IAAK,KAGzD,OADAA,EAAMkf,OAAO,GACNwhB,CACT,EAEU+iB,EAAAluD,UAAAquD,WAAV,SAAqB1hD,GACnB,MAAM,IAAI80C,YAAY,mBAAAp1C,OAAmBzO,KAAK0uD,QAAO,OAAAjgD,OAAMM,GAC7D,EAKAuhD,EAAAluD,UAAAiT,MAAA,SAAMk9B,EAAUvuB,QAAV,IAAAuuB,IAAAA,EAAA,QAAU,IAAAvuB,IAAAA,GAAO,GACrB,IAAM0qC,EAAU1uD,KAAK0uD,QACf7hD,EAAiB,GAEvB,IADImX,EAAM,IAAGA,EAAM0qC,EAAQ5pD,OAAS,GAC7BytC,GAAQvuB,GAAK,CAClB,IAAMunC,EAASmD,EAAQnc,GAEvB,GAAc,KAAVgZ,EACF1+C,EAAMnF,KAAKw7C,GAASC,OACpB5Q,SACK,GAAc,MAAVgZ,GAAkBmD,EAAQnc,EAAO,IAAM,KAAOmc,EAAQnc,EAAO,IAAM,IAAK,CAEjFA,IAEA,IADA,IAAI1V,EAAM,GACH0V,GAAQvuB,GAAO0qC,EAAQnc,IAAS,KAAOmc,EAAQnc,IAAS,KAC7D1V,GAAY6xB,EAAQnc,KAEtB,IAAMme,EAAS57B,SAAS+H,GACpB6zB,EAAS1wD,KAAK29B,QAAQgzB,QAAU,GAClC3wD,KAAKywD,WAAW,sBAAwBC,GAE1C7jD,EAAMnF,KAAK,IAAIg9C,GAAWgM,G,MACrB,GAAc,MAAVnF,GAAuC,KAArBmD,EAAQnc,EAAO,IAAkC,KAArBmc,EAAQnc,EAAO,GAAW,CAIjF,IADA,IAAIqe,EADJre,GAAQ,EAEDqe,GAAS5sC,GAAyB,KAAlB0qC,EAAQkC,IAAeA,IAC1CA,EAAQ5sC,GAAKhkB,KAAKywD,WAAW,0BACjC,IAAMI,EAAOnC,EAAQj3C,UAAU86B,EAAMqe,GAClB,IAAfC,EAAKvnD,QACPtJ,KAAKywD,WAAW,iBAElB5jD,EAAMnF,KAAK,IAAI68C,GAAasM,IAC5Bte,EAAOqe,EAAQ,C,MACV,GAAc,KAAVrF,EAAe,CAGxB,IADA,IAAIuF,EAAQve,EAAO,EACZue,GAAS9sC,GAAyB,KAAlB0qC,EAAQoC,IACP,MAAlBpC,EAAQoC,IAAgBA,IAC5BA,IAEEA,EAAQ9sC,GAAKhkB,KAAKywD,WAAW,0BACjC5jD,EAAMnF,KAAK1H,KAAK+wD,eAAexe,EAAO,EAAGue,EAAQ,IACjDve,EAAOue,EAAQ,C,MACV,GAAc,KAAVvF,EACT1+C,EAAMnF,KAAK,IAAI+4C,IACflO,SACK,GAAc,KAAVgZ,EACT1+C,EAAMnF,KAAK,IAAIm5C,IACftO,SACK,GAAc,KAAVgZ,EAAe,CACxB,GAAIhZ,EAAO,GAAKvuB,EAAK,CAEnB,IAAMwe,EAAOxiC,KAAKwwD,WAAW3jD,GAEvBmkD,EAAOhxD,KAAKqV,MAAMk9B,EAAO,EAAGvuB,GAClC,OAAO,IAAIw+B,GAAMhgB,EAAMwuB,E,CAEzBze,EAAOvuB,EAAM,C,MACR,GAAc,KAAVunC,EACThZ,EAAOvyC,KAAKixD,WAAWpkD,EAAO0lC,EAAMvuB,QAC/B,GAAc,KAAVunC,GAA2B,KAAVA,GAA2B,KAAVA,EAC3CvrD,KAAKywD,WAAW,aAAAhiD,OAAa88C,EAAM,mBAAA98C,OAAkB88C,SAChD,GAAqB,KAAjBmD,EAAQnc,IAAiC,KAAjBmc,EAAQnc,IAAiC,KAAjBmc,EAAQnc,IAAiC,KAAjBmc,EAAQnc,GACzFA,EAAOvyC,KAAKkxD,WAAWrkD,EAAO0lC,EAAMvuB,OAC/B,CAEC,IAAAkoB,EAAAmH,GAAmBrzC,KAAKmxD,UAAU5e,EAAMvuB,GAAI,GAA3C1b,EAAM4jC,EAAA,GAAEklB,EAAMllB,EAAA,GACrBr/B,EAAMnF,KAAKY,GACXiqC,GAAQ6e,C,EAMZ,OAHIvkD,EAAM/H,OAGU,GAAhB+H,EAAM/H,OAAoB+H,EAAM,GAC7B,IAAIs1C,GAAGtgD,KAAAG,MAAHmgD,GAAG5O,GAAC,MAAD,GAAAF,GAAIxmC,IAAK,IACzB,EAEUyjD,EAAAluD,UAAA6uD,WAAV,SAAqBpkD,EAAgB0lC,EAAcvuB,GAKjD,IAHA,IAAI8sC,EAAQve,EAAO,EACf8e,EAAQ,EACN3C,EAAU1uD,KAAK0uD,QACdoC,GAAS9sC,IAA0B,KAAlB0qC,EAAQoC,IAAiBO,EAAQ,IACjC,KAAlB3C,EAAQoC,GAAeO,IACA,KAAlB3C,EAAQoC,IAAeO,IACV,MAAlB3C,EAAQoC,IAAgBA,IAC5BA,IA0DA,IAMIQ,EA3DN,GAHIR,EAAQ9sC,GAAKhkB,KAAKywD,WAAW,0BAGZ,KAAjB/B,IADJnc,GAIE,GAAqB,KAAjBmc,IADJnc,GAGE1lC,EAAMnF,KAAK1H,KAAKqV,MAAMk9B,EAAO,EAAGue,EAAQ,SACnC,GAAqB,KAAjBpC,EAAQnc,IAAqC,KAArBmc,EAAQnc,EAAO,IAAkC,KAArBmc,EAAQnc,EAAO,GAAW,CAMvF,IAJA,IAAM0N,EAAajgD,KAAK29B,QAAQ1yB,OAC5Bi1C,EAAY,GAEZ0Q,EAAQre,EAAO,EACZqe,GAAS5sC,GAAyB,KAAlB0qC,EAAQkC,IAC7B1Q,GAAawO,EAAQkC,GACrBA,KAEIU,EAAUtxD,KAAKqV,MAAMu7C,EAAQ,EAAGE,EAAQ,IACtC7Q,WAAaA,EACjBC,EAAUp7C,OAAS,IAAGwsD,EAAQpR,UAAYA,E,KACzC,CAEL,IAAI/O,GAAQ,EACS,KAAjBud,EAAQnc,KACVA,IACApB,GAAQ,GAEV,IAAMoO,EAAyB,KAAnBmP,EAAQnc,KACd8O,EAAOrhD,KAAKqV,MAAMk9B,EAAMue,EAAQ,GACtC,IAAI3f,EASG,CAKL,IAAM6f,EAAOhxD,KAAKqV,MAAMy7C,EAAQ,EAAG9sC,GAMnC,OALIgtC,EAAK/Q,WAAa,IACpB+Q,EAAK/Q,WAAajgD,KAAK29B,QAAQ1yB,OAC/B+lD,EAAK7Q,eAAgB,GAEvBtzC,EAAMnF,KAAK,IAAI+5C,GAASuP,EAAM3P,EAAM9B,IAC7Bv7B,EAAM,C,CAlBTnX,EAAM/H,OAKV,IAAMs8C,EAAO,IAAIG,GAAUvhD,KAAKwwD,WAAW3jD,GAAQw0C,EAAM9B,GACzD1yC,EAAMnF,KAAK05C,E,MAiBTnB,EAAajgD,KAAK29B,QAAQ1yB,OAC5Bs0C,GAAM,EACW,KAAjBmP,EAAQnc,KACVgN,GAAM,EACNhN,MAEE+e,EAAUtxD,KAAKqV,MAAMk9B,EAAMue,EAAQ,IAI3B7Q,YAAc,IAExBqR,EAAU,IAAInP,GAAImP,IAEpBA,EAAQrR,WAAaA,EACrBpzC,EAAMnF,KAAK4pD,GAEb,OAAOR,EAAQ,CACjB,EAEUR,EAAAluD,UAAA2uD,eAAV,SAAyBxe,EAAcvuB,GACrC,IAAMiU,EAAc,GAEhBp3B,EAAI0xC,EACJgN,GAAM,EACJmP,EAAU1uD,KAAK0uD,QAKrB,IAJkB,KAAdA,EAAQ7tD,KACV0+C,GAAM,EACN1+C,KAEKA,GAAKmjB,GAAO,CACX,IAAAkoB,EAAAmH,GAAmBrzC,KAAKmxD,UAAUtwD,EAAGmjB,GAAI,GAAxCutC,EAAMrlB,EAAA,GAEb,IADArrC,GADqBqrC,EAAA,IAEbwiB,EAAQ5pD,QAAwB,KAAd4pD,EAAQ7tD,GAGhC,GAAkB,KAAd6tD,IAFJ7tD,IAEuC,KAAd6tD,EAAQ7tD,GAG/Bo3B,EAAIvwB,KAAK6pD,GACTt5B,EAAIvwB,KAAKw7C,GAASM,OAAO,WACpB,GAAI3iD,GAAKmjB,EAAK,CACb,IAAA0rB,EAAA2D,GAAkBrzC,KAAKmxD,UAAUtwD,EAAGmjB,GAAI,GAAvCwtC,EAAK9hB,EAAA,GAAE+hB,EAAM/hB,EAAA,GAChB6hB,EAAO1O,IAAM9C,GAAS0D,YAAc+N,EAAM3O,IAAM9C,GAAS0D,YAC3DzjD,KAAKywD,WAAW,kDAEde,EAAMt1C,KAAK,GAAKq1C,EAAOr1C,KAAK,IAC9Blc,KAAKywD,WAAW,iCAElBx4B,EAAIvwB,KAAKq8C,GAAUI,MAAMoN,EAAQC,IACjC3wD,GAAK4wD,C,MAELzxD,KAAKywD,WAAW,gCAGlBx4B,EAAIvwB,KAAK6pD,E,CAGb,OAAOxN,GAAUvB,MAAMjD,EAAKtnB,EAC9B,EAEUq4B,EAAAluD,UAAA+uD,UAAV,SAAoB3gD,EAAWwT,GAC7B,YADkB,IAAAxT,IAAAA,EAAA,QAAW,IAAAwT,IAAAA,EAAA,GACF,MAAvBhkB,KAAK0uD,QAAQl+C,GACRxQ,KAAK0xD,gBAAgBlhD,EAAOwT,GAE5BhkB,KAAK2xD,gBAAgBnhD,EAAOwT,EAEvC,EAEUssC,EAAAluD,UAAAuvD,gBAAV,SAA0BnhD,EAAWwT,QAAX,IAAAxT,IAAAA,EAAA,QAAW,IAAAwT,IAAAA,EAAA,GAEnC,IAAM++B,EAAK/iD,KAAK0uD,QAAQhlD,WAAW8G,GACnC,MAAO,CAAC0yC,GAASM,OAAOT,GAAK,EAC/B,EAEUuN,EAAAluD,UAAAwvD,oBAAV,SAA8BphD,EAAWwT,QAAX,IAAAxT,IAAAA,EAAA,QAAW,IAAAwT,IAAAA,EAAA,GACvC,IAAM0qC,EAAU1uD,KAAK0uD,QACjBA,EAAQl+C,GAAS,GAAK,KACxBxQ,KAAKywD,WAAW,2BAKlB,IAFA,IAAIoB,EADJrhD,GAAS,EAELshD,GAAS,EACND,GAAS7tC,GAAyB,KAAlB0qC,EAAQmD,IACP,KAAlBnD,EAAQmD,KAAeC,EAAQD,GACnCA,IAEEA,EAAQ7tC,GACVhkB,KAAKywD,WAAW,2BAGlB,IAAMsB,EAAUrD,EAAQj3C,UAAUjH,EAAOqhD,GACrCG,EAAW,mBACXC,EAAYF,EAChB,GAAID,GAAS,EAAG,CACd,IAAMv1B,EAAQw1B,EAAQ9lD,MAAM,KACR,GAAhBswB,EAAMz3B,QAAa9E,KAAKywD,WAAW,2BACvCuB,EAAWz1B,EAAM,GAAGjzB,OACpB2oD,EAAY11B,EAAM,GAAGjzB,M,CAEvB,MAAO,CAAC45C,GAASQ,eAAesO,EAAUC,GAAY,EAAIJ,EAAQ,EAAIrhD,EACxE,EAEU8/C,EAAAluD,UAAAsvD,gBAAV,SAA0BlhD,EAAWwT,QAAX,IAAAxT,IAAAA,EAAA,QAAW,IAAAwT,IAAAA,EAAA,GACnC,IAAM0qC,EAAU1uD,KAAK0uD,QACrB7oB,EAA6B,MAAlB6oB,EAAQl+C,GAAgB,mBAEnCA,EACYwT,GACVhkB,KAAKywD,WAAW,8CAElB,IAAM1N,EAAK2L,EAAQl+C,GACnB,GAAKxQ,KAAKuwD,SAAiB,KAANxN,GAAoB,KAANA,EAEjC,OAAO/iD,KAAK4xD,oBAAoBphD,EAAOwT,GAEzC,OAAQ++B,GAEN,IAAK,IACH,MAAO,CAACG,GAASG,MAAMtP,EAAcme,WAAY,GACnD,IAAK,IACH,MAAO,CAAChP,GAASG,MAAMtP,EAAcme,WAAW,GAAO,GACzD,IAAK,IACH,MAAO,CAAChP,GAASG,MAAMtP,EAAcoe,QAAS,GAChD,IAAK,IACH,MAAO,CAACjP,GAASG,MAAMtP,EAAcoe,QAAQ,GAAO,GACtD,IAAK,IACH,MAAO,CAACjP,GAASG,MAAMtP,EAAcqe,QAAS,GAChD,IAAK,IACH,MAAO,CAAClP,GAASG,MAAMtP,EAAcqe,QAAQ,GAAO,GACtD,IAAK,IAIH,OAHI1D,EAAQl+C,EAAQ,IAAM,KAAOk+C,EAAQl+C,EAAQ,IAAM,KAAOxQ,KAAKuwD,SACjEvwD,KAAKywD,WAAW,0BAEX,CAACvN,GAASM,OAAO,MAAO,GACjC,IAAK,IACH,MAAO,CAACN,GAASM,OAAO,MAAO,GACjC,IAAK,IACH,MAAO,CAACN,GAASM,OAAO,MAAO,GACjC,IAAK,IACH,MAAO,CAACN,GAASM,OAAO,MAAO,GACjC,IAAK,IACH,MAAO,CAACN,GAASM,OAAO,MAAO,GACjC,IAAK,IACH,MAAO,CAACN,GAASM,OAAO,MAAO,GACjC,IAAK,IACH,MAAO,CAACN,GAASM,OAAO,MAAO,GACjC,IAAK,KAGCxjD,KAAKuwD,SAAW//C,GAASwT,IAC3BhkB,KAAKywD,WAAW,4BAAAhiD,OAA4B+B,EAAK,MAAA/B,OAAKuV,IAExD,IAAM/Y,EAAOyjD,EAAQhlD,WAAW8G,EAAQ,GAAK,GAC7C,MAAO,CAAC0yC,GAASM,OAAOv4C,GAAO,GACjC,IAAK,MAEHuF,GACawT,GACXhkB,KAAKywD,WAAW,2BAAAhiD,OAA2B+B,EAAK,MAAA/B,OAAKuV,IAEvD,IAAMquC,EAAS3D,EAAQj3C,UAAUjH,EAAOA,EAAQ,GAC1C8hD,EAASx9B,SAASu9B,EAAQ,IAEhC,OADAxsB,GAAYpkC,MAAM6wD,GAAS,0BAAA7jD,OAA0B4jD,EAAM,MACpD,CAACnP,GAASM,OAAO8O,GAAS,GACnC,IAAK,MACH9hD,EAEYwT,EAAM,GAChBhkB,KAAKywD,WAAW,+BAAAhiD,OAA+B+B,IAEjD,IAAM+hD,EAAW7D,EAAQj3C,UAAUjH,EAAOA,EAAQ,GAC5CgiD,EAAW19B,SAASy9B,EAAU,IAIpC,OAHI9wD,MAAM+wD,IACRxyD,KAAKywD,WAAW,8BAAAhiD,OAA8B8jD,EAAQ,MAEjD,CAACrP,GAASM,OAAOgP,GAAW,GACrC,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,KACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACH,MAAO,CAACtP,GAASM,OAAOT,GAAK,GAC/B,QAEE,OADI/iD,KAAKuwD,SAASvwD,KAAKywD,WAAW,6BAA+B1N,GAC1D,CAACG,GAASM,OAAOT,GAAK,GAEnC,EAEUuN,EAAAluD,UAAA8uD,WAAV,SAAqBrkD,EAAgB0lC,EAAcvuB,GACjD,IAAM0qC,EAAU1uD,KAAK0uD,QACfrG,EAASqG,EAAQnc,EAAO,GAC1BqP,EAAW,EACbC,EAAW,EACb,GAAqB,KAAjB6M,EAAQnc,GACVqP,EAAW,EACXC,EAAWhc,OACN,GAAqB,KAAjB6oB,EAAQnc,GACjBqP,EAAW1gD,KAAK6Z,IAAI6mC,EAAU,GAC9BC,EAAWhc,OACN,GAAqB,KAAjB6oB,EAAQnc,GACjBqP,EAAW,EACXC,EAAW3gD,KAAKy2B,IAAIkqB,EAAU,OACzB,IAAqB,KAAjB6M,EAAQnc,GA6BjB,MAAM,IAAI1mC,MAAM,SA3BhB,IAAMilD,EAAQpC,EAAQ9jD,QAAQ,IAAK2nC,EAAO,IACtCue,GAASve,GAAQue,EAAQ9sC,IAC3BhkB,KAAKywD,WAAW,iDAElB,IAAMj2B,EAAMk0B,EAAQj3C,UAAU86B,EAAO,EAAGue,GAAOxnD,OACzCizB,EAAQ/B,EAAIvuB,MAAM,KAAKxH,IAAI,SAACyyB,GAAM,OAAApC,SAASoC,EAAE5tB,OAAX,GAExC,GADAipC,EAAOue,EACa,GAAhBv0B,EAAMz3B,OAAa,CACrB,GAAIrD,MAAM86B,EAAM,IAAK,CACnB,GAAI/B,EAAIlxB,OAAOxE,OAAS,EAEtB,OADA+H,EAAMnF,KAAK,IAAI08C,GAAI5pB,EAAIlxB,SAChBipC,EAAO,EAEdvyC,KAAKywD,WAAW,wBAAAhiD,OAAwB+rB,EAAG,K,CAG/ConB,EAAWC,EAAWtlB,EAAM,E,MACH,GAAhBA,EAAMz3B,QACf88C,EAAWngD,MAAM86B,EAAM,IAAM,EAAIA,EAAM,KACvCslB,EAAWpgD,MAAM86B,EAAM,IAAMsJ,EAAwBtJ,EAAM,KAEzDv8B,KAAKywD,WAAW,kBAAAhiD,OAAkB+rB,EAAG,0BAE9B+B,EAAMz3B,OAAS,GACxB9E,KAAKywD,WAAW,8BAAAhiD,OAA8B+rB,EAAG,M,CAMjD3tB,EAAM/H,QAAU,GAClB9E,KAAKywD,WAAW,iDAIlB,IAAMtuB,EAAOt1B,EAAMA,EAAM/H,OAAS,GAC9Bq9B,EAAKue,KAAOZ,GAAUiC,OAAoB,KAAVsG,GAA2B,KAAVA,GAA2B,KAAVA,GAA2B,KAAVA,GACrFroD,KAAKywD,WAAW,sBAEdzwD,KAAKuwD,SAAYpuB,EAAKue,KAAOZ,GAAU0B,YAAcrf,EAAKue,KAAOZ,GAAU4B,WAC7E1hD,KAAKywD,WAAW,uDAElB,IAAMxO,EAASp1C,EAAMA,EAAM/H,OAAS,GAAK,IAAI68C,GAAMxf,GASnD,OARA8f,EAAML,SAAWA,EACjBK,EAAMJ,SAAWA,IAEjBtP,GACYvuB,GAAwB,KAAjB0qC,EAAQnc,IAAgB0P,EAAMH,SAC/CvP,IACA0P,EAAMH,QAAS,GAEVvP,CACT,EACF+d,CAAA,CA1bA,G,8dCNA,SAASmC,GAAUtK,EAAYpF,GAE7B,IADA,IAAM9+B,EAAMkkC,EAAK33C,MACR3P,EAAI,EAAGA,EAAIkiD,EAAGj+C,OAAQjE,IAAK,CAClC,GAAIsnD,EAAKoD,QAAUxI,EAAGsH,OAAOxpD,GAE3B,OADAsnD,EAAK33C,MAAQyT,GACN,EAETkkC,EAAK6C,QAAQ,E,CAEf,OAAO,CACT,CAMA,IAAAsF,GAAA,oBAAAA,IACY,KAAA3yB,QAAwB,IAAIyyB,EAiXxC,QA/WEE,EAAAluD,UAAAiT,MAAA,SAAMq5C,EAAegE,EAAsBC,QAAtB,IAAAD,IAAAA,GAAA,QAAsB,IAAAC,IAAAA,EAAA,GAGzC,IAFA,IAAM9lD,EAAiB,GAEhB6hD,EAAQtE,SAAS,CACtB,IAAMmB,EAASmD,EAAQnD,OAEvB,GAAIkH,GAAU/D,EAAS,KACrB7hD,EAAMnF,KAAKw7C,GAASC,YACf,GAAIsP,GAAU/D,EAAS,MACtBx3B,EAAI,IAAIupB,IACZH,WAAY,EACdzzC,EAAMnF,KAAKwvB,QACN,GAAIu7B,GAAU/D,EAAS,KAAM,CAClC,IAAMx3B,KAAI,IAAI2pB,IACZP,WAAY,EACdzzC,EAAMnF,KAAKwvB,E,KACN,IAAIu7B,GAAU/D,EAAS,KAAM,CAElC,IAAMlsB,EAAOxiC,KAAKwwD,WAAW3jD,GAEvBmkD,EAAOhxD,KAAKqV,MAAMq5C,EAASgE,EAAcC,GAC/C,OAAO,IAAInQ,GAAMhgB,EAAMwuB,E,CAClB,GAAc,KAAVzF,EACT1+C,EAAMnF,KAAK1H,KAAK+wD,eAAerC,SAC1B,GAAc,KAAVnD,GAA2B,KAAVA,GAA2B,KAAVA,GAA2B,KAAVA,EAC5DvrD,KAAKkxD,WAAWxC,EAAS7hD,QACpB,GAAI6lD,GAAgBrC,GAAQ9E,GAEjCmD,EAAQ1D,QAAQ,QACX,GAAI0H,GAAgBD,GAAU/D,EAAS,MAAO,CAEnD,KAAyB,KAAlBA,EAAQnD,QAAmC,KAAlBmD,EAAQtG,QACjCsG,EAAQtE,SACXpqD,KAAKywD,WAAW/B,EAAS,wBAE3BA,EAAQ1D,QAAQ,GAElB0D,EAAQ1D,QAAQ,E,KAEX,IAAIyH,GAAU/D,EAAS,OAE5B,MAAM,IAAI7iD,MAAM,kCACX,GAAI4mD,GAAU/D,EAAS,OAE5B,MAAM,IAAI7iD,MAAM,2BACX,GAAI4mD,GAAU/D,EAAS,KAC5B,GAAI+D,GAAU/D,EAAS,KACrB,GAAI+D,GAAU/D,EAAS,KAAM,CAC3B,KAAOA,EAAQtE,SAA6B,KAAlBsE,EAAQnD,QAAemD,EAAQ1D,QAAQ,GACjEnlB,EAAW4sB,GAAU/D,EAAS,KAAM,e,KAC/B,CAML,IAJA,IAAItO,GAAa,EACbC,GAAS,EACTuS,EAAgBF,EAChBnT,GAAM,EACHmP,EAAQtE,SAA6B,KAAlBsE,EAAQnD,QACV,KAAlBmD,EAAQnD,OACVnL,GAAab,EACc,KAAlBmP,EAAQnD,OACjBlL,GAASd,EACkB,KAAlBmP,EAAQnD,OACjBqH,GAAgBrT,EACW,KAAlBmP,EAAQnD,SACjBhM,GAAM,GAERmP,EAAQ1D,QAAQ,GAElBnlB,EAAW4sB,GAAU/D,EAAS,KAAM,gBACpC,IAAMzO,EAAajgD,KAAK29B,QAAQ1yB,QAC5BqmD,EAAUtxD,KAAKqV,MAAMq5C,EAASkE,EAAeD,EAAU,IAC/C1S,YAAc,IAExBqR,EAAU,IAAInP,GAAImP,IAEpBA,EAAQjR,OAASA,EACjBiR,EAAQlR,WAAaA,EACrBkR,EAAQrR,WAAaA,EACrBpzC,EAAMnF,KAAK4pD,GACXzrB,EAAW4sB,GAAU/D,EAAS,KAAM,e,KAEjC,CAEL,IACI4C,EADErR,EAAajgD,KAAK29B,QAAQ1yB,QAC5BqmD,EAAUtxD,KAAKqV,MAAMq5C,EAASgE,EAAcC,EAAU,IAC9C1S,YAAc,IAExBqR,EAAU,IAAInP,GAAImP,IAEpBA,EAAQrR,WAAaA,EACrBpzC,EAAMnF,KAAK4pD,GACXzrB,EAAW4sB,GAAU/D,EAAS,KAAM,e,KAEjC,IAAc,KAAVnD,EAAe,CACT,GAAXoH,GACF3yD,KAAKywD,WAAW/B,EAAS,aAAAjgD,OAAa88C,EAAM,mBAAA98C,OAAkB88C,IAGhE,K,CACK,GAAc,KAAVA,GAA2B,KAAVA,EAC1BvrD,KAAKywD,WAAW/B,EAAS,aAAAjgD,OAAa88C,EAAM,mBAAA98C,OAAkB88C,QACzD,IAAIkH,GAAU/D,EAAS,KAK5B,OAHMlsB,EAAOxiC,KAAKwwD,WAAW3jD,GAEvBmkD,EAAOhxD,KAAKqV,MAAMq5C,EAASgE,EAAcC,GACxC,IAAIpR,GAAU/e,EAAMwuB,GAAM,GAC5B,GAAIyB,GAAU/D,EAAS,KAAM,CAElC,KAAyB,KAAlBA,EAAQnD,QACRmD,EAAQtE,SACXpqD,KAAKywD,WAAW/B,EAAS,uBAE3B7hD,EAAMnF,KAAK1H,KAAKmxD,UAAUzC,IAE5BA,EAAQ1D,QAAQ,E,MAGhBn+C,EAAMnF,KAAK1H,KAAKmxD,UAAUzC,G,KAG9B,OAAoB,GAAhB7hD,EAAM/H,OAAoB+H,EAAM,GAC7B,IAAIs1C,GAAGtgD,KAAAG,MAAHmgD,GAAG5O,GAAC,MAAD,GAAAF,GAAIxmC,IAAK,IACzB,EAEUyjD,EAAAluD,UAAA8uD,WAAV,SAAqBxC,EAAe7hD,GAClC,IAAI+0C,EAAW,EACbC,EAAW,EACb,GAAI4Q,GAAU/D,EAAS,KACrB9M,EAAW,EACXC,EAAWhc,OACN,GAAI4sB,GAAU/D,EAAS,KAC5B9M,EAAW1gD,KAAK6Z,IAAI6mC,EAAU,GAC9BC,EAAWhc,OACN,GAAI4sB,GAAU/D,EAAS,KAC5B9M,EAAW,EACXC,EAAW3gD,KAAKy2B,IAAIkqB,EAAU,QACzB,GAAI4Q,GAAU/D,EAAS,KAAM,CAIlC,IAHA,IAAImE,GAAa,EACb1mD,EAAK,GACLC,EAAK,GACFsiD,EAAQtE,SAA6B,KAAlBsE,EAAQnD,QACV,KAAlBmD,EAAQnD,OAAesH,GAAa,EAEjCA,EACAzmD,GAAMsiD,EAAQnD,OADFp/C,GAAMuiD,EAAQnD,OAGjCmD,EAAQ1D,QAAQ,GAEb0D,EAAQtE,SACXpqD,KAAKywD,WAAW/B,EAAS,2BAG3BviD,EAAKA,EAAG7C,OACR8C,EAAKA,EAAG9C,OAERolD,EAAQ1D,QAAQ,GAEhB,IAAM8H,EAAQh+B,SAAS3oB,GACjB4mD,EAAQj+B,SAAS1oB,GACvB,GAAIymD,GACFjR,EAAWngD,MAAMqxD,GAAS,EAAIA,IAC9BjR,EAAWpgD,MAAMsxD,GAASltB,EAAwBktB,IAEhD/yD,KAAKywD,WAAW/B,EAAS,kBAAAjgD,OAAkBtC,EAAE,KAAAsC,OAAIrC,EAAE,+BAGrD,GAAI3K,MAAMqxD,GAAQ,CAChB,GAAI3mD,EAAGrH,OAAS,EAGd,YAFA+H,EAAMnF,KAAK,IAAI08C,GAAIj4C,IAInBnM,KAAKywD,WAAW/B,EAAS,wBAAAjgD,OAAwBtC,EAAE,MAErDy1C,EAAWC,EAAW,C,MAEtBD,EAAWC,EAAWiR,C,MAI1B9yD,KAAKywD,WAAW/B,EAAS,yCAA2CA,EAAQnD,QAG1E1+C,EAAM/H,QAAU,GAClB9E,KAAKywD,WAAW/B,EAAS,iDAI3B,IACIzM,EADE9f,EAAOt1B,EAAMA,EAAM/H,OAAS,GAE9Bq9B,EAAKue,KAAOZ,GAAUiC,OAAS5f,EAAK8d,WAAa,IAEnDgC,EAAQ9f,GACFyf,SAAW1gD,KAAK6Z,IAAI6mC,EAAUK,EAAML,UAC1CK,EAAMJ,SAAW3gD,KAAKy2B,IAAIkqB,EAAUI,EAAMJ,aAE1CI,EAAQp1C,EAAMA,EAAM/H,OAAS,GAAK,IAAI68C,GAAMxf,IACtCyf,SAAWA,EACjBK,EAAMJ,SAAWA,GAGfI,EAAMH,QAAU2Q,GAAU/D,EAAS,OACrCzM,EAAMH,QAAS,EAEnB,EAEUwO,EAAAluD,UAAA2uD,eAAV,SAAyBrC,GACvB,IAAMz2B,EAAc,GACpB4N,EAAW4sB,GAAU/D,EAAS,KAAM,gBAGpC,IADA,IAAMnP,EAAMkT,GAAU/D,EAAS,KACN,KAAlBA,EAAQnD,QAAe,CAC5B,IAAMgG,EAASvxD,KAAKmxD,UAAUzC,GAC9B,GAAI+D,GAAU/D,EAAS,KACrB,GAAIA,EAAQtE,QAEV,GAAsB,KAAlBsE,EAAQnD,QAAmC,KAAlBmD,EAAQnD,OAGnCtzB,EAAIvwB,KAAK6pD,GACTt5B,EAAIvwB,KAAKw7C,GAASM,OAAO,UACpB,CACL,IAAMgO,EAAQxxD,KAAKmxD,UAAUzC,GACzB6C,EAAO1O,IAAM9C,GAAS0D,YAAc+N,EAAM3O,IAAM9C,GAAS0D,YAC3DzjD,KAAKywD,WAAW/B,EAAS,kDAEvB8C,EAAMt1C,KAAK,GAAKq1C,EAAOr1C,KAAK,IAC9Blc,KAAKywD,WAAW/B,EAAS,iCAG3Bz2B,EAAIvwB,KAAKq8C,GAAUI,MAAMoN,EAAQC,G,MAGnCxxD,KAAKywD,WAAW/B,EAAS,gCAG3Bz2B,EAAIvwB,KAAK6pD,E,CAIb,OADA1rB,EAAW4sB,GAAU/D,EAAS,KAAM,gBAC7B3K,GAAUvB,MAAMjD,EAAKtnB,EAC9B,EAEUq4B,EAAAluD,UAAA+uD,UAAV,SAAoBzC,GAClB,MAAsB,MAAlBA,EAAQnD,OACHvrD,KAAK0xD,gBAAgBhD,GAErB1uD,KAAK2xD,gBAAgBjD,EAEhC,EAEU4B,EAAAluD,UAAAuvD,gBAAV,SAA0BjD,GAExB,IAAM3L,EAAK2L,EAAQnD,OAEnB,OADAmD,EAAQ1D,QAAQ,GACT9H,GAASM,OAAOT,EACzB,EAEUuN,EAAAluD,UAAAwvD,oBAAV,SAA8BlD,GAC5B7oB,EAAW4sB,GAAU/D,EAAS,OAAQ,2BACtCA,EAAQ1D,QAAQ,GAIhB,IAHA,IAAIgI,GAAU,EACVhB,EAAW,GACXC,EAAY,GACTvD,EAAQtE,SAA6B,KAAlBsE,EAAQnD,QACV,KAAlBmD,EAAQnD,OAAeyH,GAAU,EAE9BA,EACAf,GAAavD,EAAQnD,OADZyG,GAAYtD,EAAQnD,OAGpCmD,EAAQ1D,QAAQ,GAclB,OAZK0D,EAAQtE,SACXpqD,KAAKywD,WAAW/B,EAAS,2BAG3BsD,EAAWA,EAAS1oD,OACpB2oD,EAAYA,EAAU3oD,OACjB0pD,IACHf,EAAYD,EACZA,EAAW,oBAGbtD,EAAQ1D,QAAQ,GACT9H,GAASQ,eAAesO,EAAUC,EAC3C,EAEU3B,EAAAluD,UAAAsvD,gBAAV,SAA0BhD,GAMxB,GALA7oB,EAAW4sB,GAAU/D,EAAS,MAAO,iBAEhCA,EAAQtE,SACXpqD,KAAKywD,WAAW/B,EAAS,8CAEvB+D,GAAU/D,EAAS,KACrB,OAAOxL,GAASG,MAAMtP,EAAcme,WAC/B,GAAIO,GAAU/D,EAAS,KAC5B,OAAOxL,GAASG,MAAMtP,EAAcme,WAAW,GAC1C,GAAIO,GAAU/D,EAAS,KAC5B,OAAOxL,GAASG,MAAMtP,EAAcoe,QAC/B,GAAIM,GAAU/D,EAAS,KAC5B,OAAOxL,GAASG,MAAMtP,EAAcoe,QAAQ,GACvC,GAAIM,GAAU/D,EAAS,KAC5B,OAAOxL,GAASG,MAAMtP,EAAcqe,QAC/B,GAAIK,GAAU/D,EAAS,KAC5B,OAAOxL,GAASG,MAAMtP,EAAcqe,QAAQ,GACvC,GAAIK,GAAU/D,EAAS,KAC5B,OAAOxL,GAASM,OAAO,MAClB,GAAIiP,GAAU/D,EAAS,KAC5B,OAAOxL,GAASM,OAAO,MAClB,GAAIiP,GAAU/D,EAAS,KAC5B,OAAOxL,GAASM,OAAO,MAClB,GAAIiP,GAAU/D,EAAS,KAC5B,OAAOxL,GAASM,OAAO,MAClB,GAAIiP,GAAU/D,EAAS,KAC5B,OAAOxL,GAASM,OAAO,MAClB,GAAIiP,GAAU/D,EAAS,KAC5B,OAAOxL,GAASM,OAAO,MAClB,GAAIiP,GAAU/D,EAAS,KAC5B,OAAOxL,GAASM,OAAO,MAClB,GAAIiP,GAAU/D,EAAS,MAC5B,OAAOxL,GAASM,OAAO,MAClB,GAAIiP,GAAU/D,EAAS,KAC5B,OAAOxL,GAASM,OAAO,KAClB,GAAIiP,GAAU/D,EAAS,KAC5B,OAAOxL,GAASM,OAAO,KAClB,GAAIiP,GAAU/D,EAAS,KAAM,CAE7BA,EAAQtE,SACXpqD,KAAKywD,WAAW/B,EAAS,2BAAAjgD,OAA2BigD,EAAQl+C,QAE9D,IAAM6hD,EAAS3D,EAAQnD,OAASmD,EAAQtG,OAClCkK,EAASx9B,SAASu9B,EAAQ,IAGhC,OAFAxsB,GAAYpkC,MAAM6wD,GAAS,0BAAA7jD,OAA0B4jD,EAAM,MAC3D3D,EAAQ1D,QAAQ,GACT9H,GAASM,OAAO8O,E,CAClB,GAAIG,GAAU/D,EAAS,KAAM,CAE7BA,EAAQ/D,WAAW,IAEtB3qD,KAAKywD,WAAW/B,EAAS,+BAAAjgD,OAA+BigD,EAAQl+C,QAElE,IAAM+hD,EAAW7D,EAAQj3C,UAAUi3C,EAAQl+C,MAAOk+C,EAAQl+C,MAAQ,GAC5DgiD,EAAW19B,SAASy9B,EAAU,IAKpC,OAJI9wD,MAAM+wD,IACRxyD,KAAKywD,WAAW/B,EAAS,8BAAAjgD,OAA8B8jD,EAAQ,MAEjE7D,EAAQ1D,QAAQ,GACT9H,GAASM,OAAOgP,E,CAGzB,IAAMzP,EAAK2L,EAAQnD,OAEnB,OADAmD,EAAQ1D,QAAQ,GACT9H,GAASM,OAAOT,EACzB,EAEUuN,EAAAluD,UAAAouD,WAAV,SAAqB3jD,GACnB,IAAM0gC,EAAoB,GAAhB1gC,EAAM/H,OAAc+H,EAAM,GAAI,IAAKs1C,GAAGtgD,KAAAG,MAAHmgD,GAAG5O,GAAC,MAAD,GAAAF,GAAIxmC,IAAK,KAGzD,OADAA,EAAMkf,OAAO,GACNwhB,CACT,EAEU+iB,EAAAluD,UAAAquD,WAAV,SAAqB/B,EAAe3/C,GAClC,MAAM,IAAIlD,MAAMkD,EAElB,EACFuhD,CAAA,CAlXA,GCvBM,SAAU5/C,GAAMg+C,EAAkClhD,GAEpD,IAIMkpC,EALR,MAAuB,iBAAZgY,IACHhY,EAAO,IAAIkD,GAAKqZ,GAAavE,EAASlhD,GAASA,IAChDkhD,QAAUA,EACRhY,GAC8B,UAA5BgY,EAAQjrD,YAAYgD,OACvBiwC,EAAO,IAAIkD,GAAKqZ,GAAavE,EAAmBlhD,GAASA,IAC1DkhD,QAAWA,EAAmBpnD,OAC5BovC,GAGA,IAAIkD,GAAK8U,EAAkBlhD,EAEtC,CAmDM,SAAU0lD,GAAexE,GAC7B,IAAM52C,EAAS,IAAIq7C,GACnB,IACE,IAAM/R,EAAOtpC,EAAOzC,MAAM,IAAI44C,GAAKS,IAInC,OAFmB,MAAftN,EAAKf,SAAgBe,EAAKf,QAAS,GACjB,MAAlBe,EAAKd,YAAmBc,EAAKd,WAAY,GACtCc,C,CACP,MAAOxyC,GAEP,MADA4a,QAAQ7nB,IAAI,qBAAsB+sD,GAC5B9/C,C,CAEV,CAKM,SAAUqkD,GAAaG,EAAqB5lD,GAChDA,EAASA,GAAU,CAAC,EACpB,IAAMtH,EAAyB,iBAAPktD,EAClB1E,EAAwB,iBAAP0E,EAAkBA,EAAKA,EAAG9rD,OAC7CpB,IAAUsH,EAAO+iD,QAAW6C,EAAc7C,SAC9C,IAAMnP,EAAO,IAAIiS,GAAW3E,EAASlhD,GAAQ6H,QAM7C,MALkB,iBAAP+9C,IACThS,EAAKf,OAAS+S,EAAG/S,OACjBe,EAAKhB,WAAagT,EAAGhT,WACrBgB,EAAKd,UAAY8S,EAAG9S,WAEfc,CACT,CAcM,SAAUkS,GAAOC,G,IAA+B,IAAAxuD,EAAA,GAAA+zC,EAAA,EAAAA,EAAA72C,UAAA6C,OAAAg0C,IAAA/zC,EAAA+zC,EAAA,GAAA72C,UAAA62C,GAEpD,OAAOoa,GADQzoD,OAAO+oD,IAAGxxD,MAAVyI,O,+LAAM8oC,CAAA,CAAKggB,G,uRAAOlgB,CAAKtuC,IAAI,IAE5C,C,gBChHY0uD,GAmLAC,G,svBCrCZC,GAAA,SAAAjc,GAAA,SAAAic,IAAA,IAAAtd,EAAA,OAAAqB,GAAAA,EAAA11C,MAAA,KAAAC,YAAA,K,OACEo0C,EAAAnJ,UAAY,E,CAwEd,QAzE+B0K,GAAA+b,EAAAjc,GAE7Bic,EAAAvxD,UAAA6I,KAAA,SAAKk9C,EAAYyL,GACf,IAAKzL,EAAKiC,QACR,OAAO,KAET,IAAM/Q,EAAa8O,EAAK33C,MAClBqjD,EAAY1L,EAAKoD,OACjB/qD,EAAIR,KAAK8zD,GAAG/iD,MAAMo3C,GACxB,GAAS,MAAL3nD,EAAW,CAEb,IAAIuhB,EAAoB,KAcxB,GAZEA,EADEomC,EAAK33C,OAAS6oC,EAAa,EACvB,IAAIsU,GAAe,yBAAAl/C,OAAyBolD,GAAaxa,EAAY,EAAG,sBAAuBwa,GAE/F,IAAIlG,GACR,sBAAAl/C,OAAsB05C,EAAK1wC,UAAU4hC,EAAY8O,EAAK33C,QACtD6oC,EACA8O,EAAK33C,MAAQ6oC,EACb,oBAGAr5C,KAAK+zD,UACPhyC,EAAM/hB,KAAK+zD,QAAQhyC,EAAKomC,EAAM9O,IAErB,MAAPt3B,EACF,MAAMA,EAGN,OAAO/hB,KAAKiL,KAAKk9C,EAAMyL,E,CAG3B,IAAMld,EAAO12C,KAAKg6C,SAASx5C,EAAEskD,YACzB59C,EA9KF,SAAkBw5C,EAAgBlgD,EAAU2nD,GAEhD,I,QADMlwB,EAAM,IAAIg3B,GAAMvO,EAAKlgD,EAAEskD,WAAYtkD,EAAE+yB,MAAO/yB,EAAEwjB,KAC3CnjB,EAAI,EAAGA,EAAIL,EAAE6kD,UAAUvgD,OAAQjE,GAAK,EACvCL,EAAE6kD,UAAUxkD,IAAM,IACpBo3B,EAAIotB,UAAUnkD,KAAKQ,MAAMb,EAAI,IAAM,CAACL,EAAE6kD,UAAUxkD,GAAIL,EAAE6kD,UAAUxkD,EAAI,K,IAGxE,IAAsC,IAAA6uC,E,ySAAAgE,CAAAlzC,EAAE4kD,QAAMxR,EAAAlE,EAAAzkC,QAAA2oC,EAAA1oC,KAAA0oC,EAAAlE,EAAAzkC,OAAE,CAArC,IAAAspC,EAAAlB,GAAAO,EAAAvyC,MAAA,GAAC4+C,EAAU1L,EAAA,GAAEkT,EAASlT,EAAA,GACzByf,EAAK9yD,KAAKM,IAAIy+C,GACd+T,KAAM/7B,EAAImtB,SACdntB,EAAImtB,OAAO4O,GAAM,IAEnB/7B,EAAImtB,OAAO4O,GAAItsD,KAAK+/C,E,mGAGtB,OADY,MAARU,IAAclwB,EAAI52B,MAAQ8mD,EAAK1wC,UAAUjX,EAAE+yB,MAAO/yB,EAAEwjB,MACjDiU,CACT,CA8JgBg8B,CAAQvd,EAAKgK,IAAKlgD,EAAG2nD,GACjCjhD,EAAMkL,GAAKpS,KAAKktC,YAChB,IAAIgnB,EAAUl0D,KAAKm0D,gBAAgB3zD,EAAEskD,YAIrC,GAHKoP,IACHA,EAAUl0D,KAAKo0D,qBAAqB1d,EAAKgK,MAEvCwT,GAEF,GAAa,OADbhtD,EAAQgtD,EAAQxd,EAAMyR,EAAMjhD,EAAO0sD,IAGjC,OAAO5zD,KAAKiL,KAAKk9C,EAAMyL,QAEpB,GAAIld,EAAKkO,KACd,OAAO5kD,KAAKiL,KAAKk9C,EAAMyL,GAEzB,OAAO1sD,CACT,EAEAysD,EAAAvxD,UAAAiyD,SAAA,SAASlM,EAAqByL,QAAA,IAAAA,IAAAA,EAAA,MAC5B,IAAM77C,EAAS,GACK,iBAATowC,IACTA,EAAO,IAAImM,GAAYnM,IAGzB,IADA,IAAIl9C,EAAOjL,KAAKiL,KAAKk9C,EAAMyL,GACpB3oD,GAAM,CACX8M,EAAOrQ,KAAKuD,GACZ,IACEA,EAAOjL,KAAKiL,KAAKk9C,EAAMyL,E,CACvB,MAAO7xC,GACPhK,EAAOrQ,KAAK,CACVg5C,IAAK,QACLntB,MAAOxR,EAAI5hB,OACX6jB,IAAKjC,EAAI5hB,OAAS4hB,EAAIjd,OACtBzD,MAAO0gB,EAAIzU,UAEb,K,EAGJ,OAAOyK,CACT,EACF47C,CAAA,CAzEA,CA3HA,oBAAAY,IAAA,IAAAle,EAAA,KACY,KAAAme,MAAqB,KACrB,KAAAC,IAAiB,KAW3B,KAAAV,QAAwC,KAIxC,KAAA/Z,SAAmB,GACnB,KAAAma,gBAA+C,GAC/C,KAAAC,qBAA4B,CAAC,EAC7B,KAAAM,UAAY,IAAI7sC,IAChB,KAAA8sC,SAAqB,IAAInJ,GAAS,SAAC/kD,G,MAC7BwxB,EAAMoe,EAAKqe,UAAU78C,IAAIpR,IAAS,KAEtC,GADW,MAAPwxB,IAAaA,GAAgC,QAA1BiU,EAAAmK,EAAKue,gBAAgBnuD,UAAK,IAAAylC,OAAA,EAAAA,EAAEkV,OAAQ,MAChD,MAAPnpB,EAAa,MAAM,IAAIpsB,MAAM,4BAAA4C,OAA4BhI,IAC7D,OAAOwxB,CACT,EA4FF,QA1FEs8B,EAAAnyD,UAAAyyD,OAAA,SAAOpuD,GACL,OAAOzG,KAAK00D,UAAU78C,IAAIpR,IAAS,IACrC,EAEA8tD,EAAAnyD,UAAA0yD,OAAA,SAAOruD,EAAcsuD,GACnB,IAAIC,EAAYh1D,KAAK00D,UAAU78C,IAAIpR,IAAS,KAO5C,OALEuuD,EADe,MAAbA,EACUD,EAEA,IAAIvS,GAAMwS,EAAWD,GAEnC/0D,KAAK00D,UAAU9oD,IAAInF,EAAMsuD,GAClB/0D,IACT,EAEAu0D,EAAAnyD,UAAAwyD,gBAAA,SAAgBvzD,GACd,OAAOrB,KAAKg6C,SAASib,KAAK,SAAC1nB,GAAM,OAAAA,EAAEmT,KAAOr/C,CAAT,IAAmB,IACtD,EAYAkzD,EAAAnyD,UAAAkgC,IAAA,SACEosB,EACAlhD,EACA0mD,GAMA,YANA,IAAAA,IAAAA,EAAA,MAEsB,mBAAX1mD,IACT0mD,EAAU1mD,EACVA,EAAS,MAEJxN,KAAK86C,QAAQoa,GAAcxG,EAASlhD,GAAS0mD,EACtD,EAUAK,EAAAnyD,UAAA04C,QAAA,SAAQpE,EAAYwd,GAMlB,YANkB,IAAAA,IAAAA,EAAA,MAClBxd,EAAKoO,WAAa9kD,KAAKg6C,SAASl1C,OAChC9E,KAAKg6C,SAAStyC,KAAKgvC,GACnB12C,KAAKm0D,gBAAgBzsD,KAAKwsD,GAC1Bl0D,KAAKw0D,MAAQ,KACbx0D,KAAKy0D,IAAM,KACJz0D,IACT,EAKAu0D,EAAAnyD,UAAAk+B,GAAA,SAAGogB,EAAUwT,GAEX,OADAl0D,KAAKo0D,qBAAqB1T,GAAOwT,EAC1Bl0D,IACT,EAEAmC,OAAA2H,eAAIyqD,EAAAnyD,UAAA,OAAI,C,IAAR,WACE,GAAkB,MAAdpC,KAAKw0D,MAAe,CACtB,IAAMW,EAAcn1D,KAAKo1D,YACzBp1D,KAAKw0D,MAAQx0D,KAAK20D,SAAS/I,QAAQuJ,E,CAErC,OAAOn1D,KAAKw0D,KACd,E,gCAEAryD,OAAA2H,eAAIyqD,EAAAnyD,UAAA,KAAE,C,IAAN,WAIE,OAHgB,MAAZpC,KAAKy0D,MACPz0D,KAAKy0D,IAAM,IAAI5N,GAAG7mD,KAAK8mD,OAElB9mD,KAAKy0D,GACd,E,gCAEUF,EAAAnyD,UAAAgzD,UAAV,WAEE,IAAMD,EAAsBn1D,KAAKg6C,SAASv1C,IAAI,SAACiyC,GAAS,OAAAA,CAAA,GAKxD,OAJAye,EAAY5f,KAAK,SAAC8f,EAAIC,GACpB,OAAID,EAAGxQ,UAAYyQ,EAAGzQ,SAAiByQ,EAAGzQ,SAAWwQ,EAAGxQ,SACjDwQ,EAAGvQ,WAAawQ,EAAGxQ,UAC5B,GACOqQ,CACT,EACFZ,CAAA,CAtHA,I,+RCrBA,WAOE,SAAAgB,EAAYpN,GANJ,KAAAqN,YAAmC,KAG3C,KAAAC,SAAkC,GAClC,KAAAC,SAAsC,GAGhB,iBAATvN,IACTA,EAAO,IAAI8F,GAAK9F,IAElBnoD,KAAKmoD,KAAOA,CACd,CAEAoN,EAAAnzD,UAAAuzD,WAAA,SAAWx9C,EAAuBysC,GAEhC,YAFgC,IAAAA,IAAAA,GAAA,GAChC5kD,KAAK01D,SAAShuD,KAAK,CAACyQ,EAASysC,IACtB5kD,IACT,EAEAu1D,EAAAnzD,UAAAwzD,WAAA,SAAWrsB,EAAassB,GACtB,IAAMrlD,EAAQxQ,KAAKy1D,SAASha,UAAU,SAACqa,GAAM,OAAAA,EAAE,IAAMvsB,CAAR,GAC7C,GAAI/4B,EAAQ,EAEV,OADAxQ,KAAKy1D,SAAS/tD,KAAK,CAAC6hC,EAAKssB,IAClB71D,KAAKy1D,SAAS3wD,OAAS,EAE9B,GAAI9E,KAAKy1D,SAASjlD,GAAO,IAAMqlD,EAC7B,MAAM,IAAIhqD,MAAM,YAAA4C,OAAY86B,EAAG,4BAAA96B,OAA2BonD,IAE5D,OAAOrlD,CAEX,EAQA+kD,EAAAnzD,UAAAotD,UAAA,WAEE,IAAKxvD,KAAKmoD,KAAKiC,QAAS,OAAO,KAI/B,IAHA,IAAMnmC,EAAMjkB,KAAKmoD,KAAK33C,MAGb3P,EAAI,EAAGA,EAAIb,KAAKy1D,SAAS3wD,OAAQjE,IAAK,CACvC,IAAAqrC,EAAAmH,GAAiBrzC,KAAKy1D,SAAS50D,GAAE,GAAhCk1D,EAAG7pB,EAAA,GAAE8pB,EAAO9pB,EAAA,GACnB,GAAIsiB,GAAWljD,QAAQtL,KAAKmoD,KAAM4N,GAAM,CACtC,IAAM99B,EAAM,IAAIg3B,GAAM+G,EAASn1D,EAAGojB,EAAKjkB,KAAKmoD,KAAK33C,OAEjD,OADAynB,EAAI52B,MAAQ00D,EACL99B,C,EAGX,IAASp3B,EAAI,EAAGA,EAAIb,KAAK01D,SAAS5wD,OAAQjE,IAAK,CACvC,IAAA6uC,EAAA2D,GAAkBrzC,KAAK01D,SAAS70D,GAAE,GAAjCsX,EAAOu3B,EAAA,GAAEkV,EAAIlV,EAAA,GACdxoC,EAAQiR,EAAQnY,KAAKmoD,KAAMlkC,GACjC,GAAa,MAAT/c,EACF,OAAI09C,EACK5kD,KAAKwvD,aAEZtoD,EAAMqsB,MAAQtP,EACd/c,EAAM8c,IAAMhkB,KAAKmoD,KAAK33C,MACftJ,E,CAMb,MAAM,IAAIymD,GAAe,oBAAqB3tD,KAAKmoD,KAAK33C,MAAO,EAAG,mBAAoBxQ,KAAKmoD,KAAKoD,OAClG,CACF,CArEA,G,gGCPa0K,GAAsB3C,GAAM4C,KAAAA,GAAAC,GAAA,yEAC5BC,GAAsB9C,GAAM+C,KAAAA,GAAAF,GAAA,yEAG5BG,IADsB7rD,OAAO+oD,IAAG+C,KAAAA,GAAAJ,GAAA,iEACrB1rD,OAAO+oD,IAAGgD,KAAAA,GAAAL,GAAA,8D,irBHA5BM,GAAY,SAAC11D,GACjB,MAAiB,iBAANA,EAAuB,GAAKA,EAChCA,EAAEwI,QAAQ,sCAAuC,OAC1D,GAEA,SAAYkqD,GACVA,EAAA,gBACAA,EAAA,cACAA,EAAA,gBACAA,EAAA,gBACAA,EAAA,cACAA,EAAA,sBACAA,EAAA,YACAA,EAAA,YACAA,EAAA,cACAA,EAAA,YACAA,EAAA,wBACAA,EAAA,4BACAA,EAAA,wBACAA,EAAA,0BACAA,EAAA,wBACAA,EAAA,0BACAA,EAAA,kBACAA,EAAA,oBACAA,EAAA,kBACAA,EAAA,cACAA,EAAA,4BACAA,EAAA,cACAA,EAAA,uBACD,CAxBD,CAAYA,KAAAA,GAAS,KAmLrB,SAAYC,GACVA,EAAA,kBACAA,EAAA,YACAA,EAAA,YACAA,EAAA,sBACAA,EAAA,oBACAA,EAAA,wBACAA,EAAA,sBACAA,EAAA,0BACAA,EAAA,oBACAA,EAAA,wBACAA,EAAA,sBACAA,EAAA,sBACAA,EAAA,8BACAA,EAAA,cACAA,EAAA,cACAA,EAAA,iBACD,CAjBD,CAAYA,KAAAA,GAAQ,KA+CpB,IAAAgD,GAAA,WA0BE,SAAAA,EAAYxI,EAAe1gD,GAvBnB,KAAAmpD,eAAgB,EACf,KAAAC,mBAAqC,IAAIC,GAoB1C,KAAAC,YAAc,KAGpBtpD,EAASA,GAAW,CAAC,EACrBxN,KAAK+2D,eAAiB,CAAC,EACvB/2D,KAAKk1C,QAAU1nC,EAAO0nC,SAAW,IAAI4E,GACrC95C,KAAK22D,gBAAgB,kBAAmBnpD,IAASA,EAAOmpD,gBAAiB,EACzE32D,KAAKg3D,kBAAoBxpD,EAAOwpD,mBAAqB,KACrDh3D,KAAKi3D,cAAgBzpD,EAAOypD,eAAiB,CAAC,EAC9Cj3D,KAAKqV,MAAM64C,EACb,CA+SF,OApSEwI,EAAAt0D,UAAA80D,eAAA,SAAethB,GACb,OAAO51C,KAAK+2D,eAAenhB,IAAU,IACvC,EAKA8gB,EAAAt0D,UAAA+0D,eAAA,SAAevhB,EAAeyB,GAC5BxR,IAAa+P,KAAS51C,KAAK+2D,gBAAiB,GAAAtoD,OAAGmnC,EAAK,2BACpD51C,KAAK+2D,eAAenhB,GAASyB,CAC/B,EAMAqf,EAAAt0D,UAAAg1D,aAAA,SAAaxhB,EAAeyhB,GAC1B,IAAIC,EAAUt3D,KAAKk3D,eAAethB,GAElC,OAAe,MAAX0hB,IACKt3D,KAAKg3D,oBAEZM,EAAUt3D,KAAKg3D,kBAAkBphB,EAAOyhB,IAAoB,MAE/C,MAAXC,IAEAA,EADED,EACQr3D,KAAKk1C,QAAQqF,QAAQ3E,GAErB51C,KAAKk1C,QAAQ2F,MAAMjF,IAIjC51C,KAAKm3D,eAAevhB,EAAO0hB,IAbCA,CAe9B,EAEAZ,EAAAt0D,UAAAiT,MAAA,SAAM64C,GAAN,IAnLMqJ,EAmLNlhB,EAAA,KACQmhB,IApLFD,EAAQ,IAAIV,IACZv0B,IAAI,KAAM,CAAEoe,IAAK+S,GAAUgE,QACjCF,EAAMj1B,IAAI,KAAM,CAAEoe,IAAK+S,GAAUiE,UACjCH,EAAMj1B,IAAI,KAAM,CAAEoe,IAAK+S,GAAUkE,WACjCJ,EAAMj1B,IAAI,KAAM,CAAEoe,IAAK+S,GAAUmE,aACjCL,EAAMj1B,IAAI,KAAM,CAAEoe,IAAK+S,GAAUoE,cACjCN,EAAMj1B,IAAI,KAAM,CAAEoe,IAAK+S,GAAUqE,aACjCP,EAAMj1B,IAAI,KAAM,CAAEoe,IAAK+S,GAAUsE,cACjCR,EAAMj1B,IAAI,KAAM,CAAEoe,IAAK+S,GAAUuE,OACjCT,EAAMj1B,IAAI,KAAM,CAAEoe,IAAK+S,GAAUwE,OACjCV,EAAMj1B,IAAI,KAAM,CAAEoe,IAAK+S,GAAUyE,QACjCX,EAAMj1B,IAAI,IAAK,CAAEoe,IAAK+S,GAAU0E,aAChCZ,EAAMj1B,IAAI,IAAK,CAAEoe,IAAK+S,GAAU2E,QAChCb,EAAMj1B,IAAI,KAAM,CAAEoe,IAAK+S,GAAU4E,OACjCd,EAAMj1B,IAAI,OAAQ,CAAEoe,IAAK+S,GAAUrB,QAAU,WAAM,cACnDmF,EAAMj1B,IAAI,eAAgB,CAAEoe,IAAK+S,GAAU6E,SAAW,WAAM,cAC5Df,EAAMj1B,IAAI,WAAY,CAAEoe,IAAK+S,GAAU6E,SAAW,WAAM,cACxDf,EAAMj1B,IAAIu0B,GAAkC,CAAEnW,IAAK+S,GAAU8E,QAAU,SAAC7hB,EAAMyR,EAAMjhD,GAElF,OADAA,EAAM7F,MAAQ8mD,EAAK1wC,UAAUvQ,EAAMqsB,MAAQ,EAAGrsB,EAAM8c,IAAM,GACnD9c,CACT,GACAqwD,EAAMj1B,IAAIu0B,GAAkC,CAAEnW,IAAK+S,GAAU8E,QAAU,SAAC7hB,EAAMyR,EAAMjhD,GAElF,OADAA,EAAM7F,MAAQ8mD,EAAK1wC,UAAUvQ,EAAMqsB,MAAQ,EAAGrsB,EAAM8c,IAAM,GACnD9c,CACT,GACAqwD,EAAMj1B,IAAIu0B,GAAuB,CAAEnW,IAAK+S,GAAU+E,OAAS,SAAC9hB,EAAMyR,EAAMjhD,GACtE,IAAMwnD,EAAUvG,EAAK1wC,UAAUvQ,EAAMm+C,UAAU,GAAG,GAAIn+C,EAAMm+C,UAAU,GAAG,IACnEoT,EAAQtQ,EAAK1wC,UAAUvQ,EAAMm+C,UAAU,GAAG,GAAIn+C,EAAMm+C,UAAU,GAAG,IAEvE,OADAn+C,EAAM7F,MAAQ,CAACqtD,EAAS+J,GACjBvxD,CACT,GACAqwD,EAAMj1B,IAAI,MAAO,CAAEoe,IAAK+S,GAAUiF,QAAU,SAAChiB,EAAMyR,EAAMjhD,GAEvD,OADAA,EAAM7F,MAAQyzB,SAASqzB,EAAK1wC,UAAUvQ,EAAMqsB,MAAOrsB,EAAM8c,MAClD9c,CACT,GACAqwD,EAAMj1B,IAAI,kBAAmB,CAAEoe,IAAK+S,GAAUkF,WAAa,SAACjiB,EAAMyR,EAAMjhD,GAEtE,OADAA,EAAM7F,MAAQ8mD,EAAK1wC,UAAUvQ,EAAMqsB,MAAQ,EAAGrsB,EAAM8c,KAC7C9c,CACT,GACAqwD,EAAMj1B,IAAI,QAAS,CAAEoe,IAAK+S,GAAUmF,YAAc,SAACliB,EAAMyR,EAAMjhD,GAE7D,OADAA,EAAM7F,MAAQyzB,SAASqzB,EAAK1wC,UAAUvQ,EAAMqsB,MAAQ,EAAGrsB,EAAM8c,MACtD9c,CACT,GACAqwD,EAAMj1B,IAAI,mBAAoB,CAAEoe,IAAK+S,GAAUoF,cAAgB,SAACniB,EAAMyR,EAAMjhD,GAE1E,OADAA,EAAM7F,MAAQ8mD,EAAK1wC,UAAUvQ,EAAMqsB,MAAQ,EAAGrsB,EAAM8c,KAC7C9c,CACT,GACAqwD,EAAMj1B,IAAI,eAAgB,CAAEoe,IAAK+S,GAAUqF,QACpCvB,GAyILv3D,KAAK+4D,UAAY,IAAIlC,GAJN,SAAC1O,EAAYyL,GAE1B,OADY4D,EAAGvsD,KAAKk9C,EAAM9R,EAE5B,EAC8Cr2C,MAC9CA,KAAKg5D,aAAa,IAAInC,GAAU3I,GAClC,EAEAwI,EAAAt0D,UAAA62D,WAAA,SAAW9Q,EAA0BzH,EAAcmE,EAAcqU,GAE/D,QAFiD,IAAArU,IAAAA,EAAA,QAAc,IAAAqU,IAAAA,EAAA,IACjD,IAAVA,IAAcA,EAASl5D,KAAK82D,aAClB,MAAVoC,EAAgB,CAClB,IAAMC,EAAan5D,KAAK+4D,UAAUhJ,YAAY5H,EAAMsL,GAAU8E,OAAQ9E,GAAUiF,OAAQjF,GAAU+E,OAC9F9hB,OAAI,EAIR,GAHKgK,GAAqB,GAAdA,EAAI57C,SACd47C,EAAM,IAAMyY,EAAW93D,MAAM,GAAK,IAAM83D,EAAW93D,MAAM,IAEvD83D,EAAWzY,KAAO+S,GAAU8E,QAAUY,EAAWzY,KAAO+S,GAAUiF,OAEpEhiB,EAAOmgB,GADSJ,GAAU0C,EAAW93D,OACF,CAAEq/C,IAAKA,EAAKmE,SAAUA,EAAW,SAC/D,IAAIsU,EAAWzY,KAAO+S,GAAU+E,MAQrC,MAAM,IAAI3B,GAA0BsC,GAPpC,IAAI/F,EAAK+F,EAAW93D,MAAM,GACtB83D,EAAW93D,MAAM,GAAGyD,OAAS,IAE/BsuD,EAAK,IAAIr1C,OAAOo7C,EAAW93D,MAAM,GAAI83D,EAAW93D,MAAM,KAExDq1C,EAAOmgB,GAAmBzD,EAAI,CAAE1S,IAAKA,EAAKmE,SAAUA,EAAW,I,CAIjE,OAAOnO,C,CAIP,IADA,IAAI0iB,EAAa,GACVjR,EAAKiC,SAA0B,MAAfjC,EAAKoD,QAC1B6N,GAAcjR,EAAKoD,OACnBpD,EAAK6C,UAMP,OAJAoO,EAAaA,EAAW9vD,OACnBo3C,GAAqB,GAAdA,EAAI57C,SACd47C,EAAM,IAAM0Y,EAAa,KAEpB,IAAIvC,GAAUA,GAA4BuC,GAAa,CAAE1Y,IAAKA,EAAKmE,SAAUA,GAExF,EAEA6R,EAAAt0D,UAAA42D,aAAA,SAAa7Q,GAEX,IADA,IAAIkR,EAASr5D,KAAK+4D,UAAUrJ,KAAKvH,GAChB,MAAVkR,GAAgB,CACrB,GAAIA,EAAO3Y,KAAO+S,GAAUqF,MAE1B94D,KAAKs5D,UAAUnR,OACV,IAAIkR,EAAO3Y,KAAO+S,GAAUkF,UAIjC,MAAM,IAAI9U,YAAY,4DAAAp1C,OAA4D4qD,EAAOh4D,MAAK,eAH9FrB,KAAK+4D,UAAU9tD,KAAKk9C,GACpBnoD,KAAKu5D,eAAepR,EAAMkR,EAAOh4D,M,CAInCg4D,EAASr5D,KAAK+4D,UAAUrJ,KAAKvH,E,CAEjC,EAEAuO,EAAAt0D,UAAAm3D,eAAA,SAAepR,EAA0BqR,GAAzC,IAAAnjB,EAAA,KACE,GAAiB,SAAbmjB,EAAsB,CAExB,IAAMvuD,EAAOjL,KAAK+4D,UAAUhJ,YAAY5H,EAAMsL,GAAUqF,OACxD94D,KAAKk1C,QAAQkD,YAAcp4C,KAAKo3D,aAAansD,EAAK5J,OAAiB,E,MAC9D,GAAiB,YAAbm4D,EAAyB,CAGlC,GAAkB,OADZvuD,EAAOjL,KAAK+4D,UAAUhJ,YAAY5H,EAAMsL,GAAUqF,QAC/Cz3D,OAA+B,QAAd4J,EAAK5J,MAC7B,MAAM,IAAIwiD,YAAY,yBAA2B54C,EAAK5J,OAExDrB,KAAK82D,YAAc7rD,EAAK5J,K,MACnB,GAAIm4D,EAAUC,WAAW,QAAS,CACvC,IAAM/iB,EAAO12C,KAAKi5D,WAAW9Q,EAAM,GAAI,GAAIqR,EAAUlvD,SAAS,QAAU,OAAS,IAC3EovD,EAAe15D,KAAK25D,kBAAkBxR,GACxCuR,EACF15D,KAAK42D,mBAAmB9b,QAAQpE,EAAM,SAACA,EAAMyR,EAAMjhD,GAEjD,OADAwyD,EAAahjB,EAAMyR,EAAMjhD,EAAOmvC,GACzB,IACT,GAEAr2C,KAAK42D,mBAAmB9b,QAAQpE,EAAM,WAAM,a,KAEzC,KAAI8iB,EAAUC,WAAW,WAAYD,EAAUC,WAAW,UAmB/D,MAAM,IAAI5tD,MAAM,sBAAwB2tD,GAlBxC,IAAMI,EAAQJ,EAAUC,WAAW,UAC7BI,EAAU75D,KAAK+4D,UAAUhJ,YAAY5H,EAAMsL,GAAUqF,MAAOrF,GAAU8E,QACxE3iB,EAAQikB,EAAQx4D,MAKpB,GAJIw4D,EAAQnZ,KAAO+S,GAAU8E,QAAUsB,EAAQnZ,KAAO+S,GAAUiF,SAC9D9iB,EAAQ,IAAAnnC,OAAIorD,EAAQx4D,MAAK,MAErBq1C,EAAO12C,KAAKi5D,WAAW9Q,EAAMvS,EAAO,EAAG4jB,EAAUlvD,SAAS,QAAU,OAAS,IAC/EsvD,EAEF55D,KAAK42D,mBAAmB9B,OAAOlf,EAAOc,EAAK0K,UACtC,CACL,IAAM0Y,EAAe95D,KAAK25D,kBAAkBxR,GAE5CnoD,KAAK42D,mBAAmB9b,QAAQpE,EAAMojB,GAEtC95D,KAAKo3D,aAAaxhB,GAAO,E,EAK/B,EAEA8gB,EAAAt0D,UAAAu3D,kBAAA,SAAkBxR,GAAlB,IAAA9R,EAAA,KACE,IAAKr2C,KAAK+4D,UAAUjJ,UAAU3H,EAAMsL,GAAUqE,YAC5C,OAAO,KAGT,IAAMiC,EAAW/5D,KAAK+4D,UAAUhJ,YAAY5H,EAAMsL,GAAUqF,OAW5D,OADA94D,KAAK+4D,UAAUhJ,YAAY5H,EAAMsL,GAAUsE,aAP/B,SAACrhB,EAAiByR,EAAYjhD,EAAY0sD,GACpD,IAAM9yB,EAAUuV,EAAK4gB,cAAc8C,EAAS14D,OAC5C,IAAKy/B,EAAS,MAAM,IAAIj1B,MAAM,6BAA+BkuD,EAAS14D,OAEtE,OADQy/B,EAAQ55B,EAAOihD,EAAMyL,EAE/B,CAIF,EAEA8C,EAAAt0D,UAAAk3D,UAAA,SAAUnR,G,QACF6R,EAAQh6D,KAAK+4D,UAAUhJ,YAAY5H,EAAMsL,GAAUqF,OACzD,GAAI94D,KAAK+4D,UAAUjJ,UAAU3H,EAAMsL,GAAUgE,MAAOhE,GAAU2E,OAAQ,CACpE,IAAM5hB,EAAKx2C,KAAKo3D,aAAa4C,EAAM34D,OAAiB,GACpD,GAAIm1C,EAAGN,WAGLM,EAAGN,YAAa,OACX,GAAIM,EAAGb,YACZ,MAAM,IAAI9pC,MAAM,iD,IAElB,IAA4B,IAAA6jC,E,ySAAAgE,CAAA1zC,KAAKi6D,iBAAiB9R,EAAMnoD,KAAKk1C,QAASsB,IAAG5C,EAAAlE,EAAAzkC,QAAA2oC,EAAA1oC,KAAA0oC,EAAAlE,EAAAzkC,OAA9D,KAAAspC,EAAAlB,GAAAO,EAAAvyC,MAAA,GAACu1C,EAAGrC,EAAA,GAAEsF,EAAMtF,EAAA,GACRv0C,KAAKk1C,QAAQ5S,IAAIkU,EAAII,EAAKiD,EADlB,C,kGAGvB75C,KAAK+4D,UAAUhJ,YAAY5H,EAAMsL,GAAU0E,W,CAE/C,EAEAzB,EAAAt0D,UAAA63D,iBAAA,SAAiB9R,EAAYjT,EAAkBsB,GAE7C,IADA,IAAMve,EAAkC,GACJ,MAA7Bj4B,KAAK+4D,UAAUrJ,KAAKvH,IAAe,CACxC,IAAMzR,EAAO12C,KAAKk6D,UAAU/R,EAAMjT,GAElC,GADAjd,EAAIvwB,KAAKgvC,IACL12C,KAAK+4D,UAAUjJ,UAAU3H,EAAMsL,GAAU4E,OAElCr4D,KAAK+4D,UAAU9I,YAAY9H,EAAMsL,GAAUkE,SAAUlE,GAAUoE,YAAapE,GAAU0E,YAC/F,K,CAGJ,OAAOlgC,CACT,EAEAy+B,EAAAt0D,UAAA83D,UAAA,SAAU/R,EAAYjT,GAEpB,IADA,IAAMjd,EAAM,IAAI4gB,IAKZ74C,KAAK+4D,UAAU9I,YACb9H,EACAsL,GAAUoE,YACVpE,GAAUkE,SACVlE,GAAU0E,WACV1E,GAAU4E,KACV5E,GAAUqE,aAVH,CAiBX,IAAIvlB,EAA0B,KAC9B,GAAIvyC,KAAK+4D,UAAUjJ,UAAU3H,EAAMsL,GAAUmE,YAEvB,IADdxc,EAAQp7C,KAAKi6D,iBAAiB9R,EAAMjT,EAAS,OACzCpwC,SAIRytC,EAFyB,GAAhB6I,EAAMt2C,OAERs2C,EAAM,GAAG,GAITlG,EAAQyH,MAAK36C,MAAbkzC,EAAO3B,GAAA,GAAAF,GAAU+H,EAAM32C,IAAI,SAAC8oC,GAAM,OAAAA,EAAE,EAAF,KAAK,KAEhDvtC,KAAK+4D,UAAUhJ,YAAY5H,EAAMsL,GAAUoE,kBACtC,GAAI73D,KAAK+4D,UAAUjJ,UAAU3H,EAAMsL,GAAUiE,SAAU,CAC5D,IAAMtc,EACc,IADdA,EAAQp7C,KAAKi6D,iBAAiB9R,EAAMjT,EAAS,OACzCpwC,SAIRytC,EAFyB,GAAhB6I,EAAMt2C,OAERowC,EAAQ9rB,IAAIgyB,EAAM,GAAG,IAIrBlG,EAAQ9rB,IAAI8rB,EAAQyH,MAAK36C,MAAbkzC,EAAO3B,GAAA,GAAAF,GAAU+H,EAAM32C,IAAI,SAAC8oC,GAAM,OAAAA,EAAE,EAAF,KAAK,MAE5DvtC,KAAK+4D,UAAUhJ,YAAY5H,EAAMsL,GAAUkE,S,KACtC,KACL33D,KAAK+4D,UAAU9I,YAAY9H,EAAMsL,GAAUqF,MAAOrF,GAAU8E,OAAQ9E,GAAUiF,OAAQjF,GAAU+E,OAyBhG,MAAM,IAAI3B,GAA0B72D,KAAK+4D,UAAUrJ,KAAKvH,IAvBxD,IAAMjhD,EAAQlH,KAAK+4D,UAAU9tD,KAAKk9C,GAC9BvS,EAAQ1uC,EAAM7F,MAClB,GAAI6F,EAAMw5C,KAAO+S,GAAU8E,QAAUrxD,EAAMw5C,KAAO+S,GAAUiF,OAAQ,CAClE9iB,EAAQ,IAAAnnC,OAAIvH,EAAM7F,MAAK,KACvB,IACMq1C,EAAOmgB,GADGJ,GAAUvvD,EAAM7F,OACS,CAAEq/C,IAAK9K,EAAOiP,SAAU,KACjE7kD,KAAK42D,mBAAmB9b,QAAQpE,E,MAC3B,GAAIxvC,EAAMw5C,KAAO+S,GAAU+E,MAAO,CACvC5iB,EAAQ,IAAM1uC,EAAM7F,MAAM,GAAK,IAAM6F,EAAM7F,MAAM,GACjD,IAAI+xD,EAAKlsD,EAAM7F,MAAM,GACjB6F,EAAM7F,MAAM,GAAGyD,OAAS,IAE1BsuD,EAAK,IAAIr1C,OAAO7W,EAAM7F,MAAM,GAAI6F,EAAM7F,MAAM,KAExCq1C,EAAOmgB,GAAmBzD,EAAI,CAAE1S,IAAK9K,EAAOiP,SAAU,KAC5D7kD,KAAK42D,mBAAmB9b,QAAQpE,E,CAKlC,IAAM4gB,EAAUt3D,KAAKo3D,aAAaxhB,GAAO,GACzCrD,EAAO,IAAIsG,GAAIye,E,CAKjB,GAAY,MAAR/kB,EACF,MAAM,IAAI1mC,MAAM,4BAGd7L,KAAK+4D,UAAUjJ,UAAU3H,EAAMsL,GAAUuE,MAC3CzlB,EAAO2C,EAAQ2H,SAAStK,EAAMvyC,KAAK22D,eAC1B32D,KAAK+4D,UAAUjJ,UAAU3H,EAAMsL,GAAUwE,MAClD1lB,EAAO2C,EAAQiI,SAAS5K,EAAMvyC,KAAK22D,eAC1B32D,KAAK+4D,UAAUjJ,UAAU3H,EAAMsL,GAAUyE,SAClD3lB,EAAO2C,EAAQ9rB,IAAImpB,IAErBta,EAAI9uB,OAAOopC,E,CAEb,IAAIsH,EAA4B,KAChC,GAAI75C,KAAK+4D,UAAUjJ,UAAU3H,EAAMsL,GAAUqE,YAAa,CACxD,IAAM7sD,EAAOjL,KAAK+4D,UAAUhJ,YAAY5H,EAAMsL,GAAUmF,WAAYnF,GAAUqF,OAC9Ejf,EAAS,IAAIF,GAAW1uC,EAAK5J,OAC7BrB,KAAK+4D,UAAUhJ,YAAY5H,EAAMsL,GAAUsE,Y,CAE7C,MAAO,CAAC9/B,EAAK4hB,EACf,EACF6c,CAAA,CAjVA,G,y7BI3IAyD,GAAA,SAAAziB,GAAA,SAAAyiB,IAAA,IAAA9jB,EAAA,OAAAqB,GAAAA,EAAA11C,MAAA,KAAAC,YAAA,K,OACEo0C,EAAAvY,OAA2B,K,CAY7B,QAb4B8Z,GAAAuiB,EAAAziB,GAG1ByiB,EAAA/3D,UAAAkgC,IAAA,SAAI0Q,EAAYxiC,GAGd,YAHc,IAAAA,IAAAA,GAAS,GACvBknC,EAAAt1C,UAAMkgC,IAAGx/B,KAAC,KAAAkwC,EAAMxiC,GAChBwiC,EAAKlV,OAAS99B,KACPA,IACT,EAEAm6D,EAAA/3D,UAAA2pB,OAAA,SAAOvb,EAAe+oC,G,YAAqB5G,EAAA,GAAAmG,EAAA,EAAAA,EAAA72C,UAAA6C,OAAAg0C,IAAAnG,EAAAmG,EAAA,GAAA72C,UAAA62C,G,IACzC,IAAmB,IAAAshB,E,ySAAA1mB,CAAAf,GAAK0nB,EAAAD,EAAAnvD,QAAAovD,EAAAnvD,KAAAmvD,EAAAD,EAAAnvD,OAATovD,EAAAh5D,MAAgBy8B,OAAS99B,I,kGACxC,OAAO03C,EAAAt1C,UAAM2pB,OAAM/pB,MAAC,KAADuxC,GAAC,CAAA/iC,EAAO+oC,GAAWlG,GAAKV,IAAK,GAClD,EACFwnB,CAAA,CAbA,CA9DA,WAEE,SAAAG,EAA4BloD,EAA4BilC,EAAiBh2C,G,IAAY,IAAA49B,EAAA,GAAA6Z,EAAA,EAAAA,EAAA72C,UAAA6C,OAAAg0C,IAAA7Z,EAAA6Z,EAAA,GAAA72C,UAAA62C,GAAzD,KAAA1mC,GAAAA,EAA4B,KAAAilC,IAAAA,EAAiB,KAAAh2C,MAAAA,EADzE,KAAA49B,SAAmB,GAEjBj/B,KAAKi/B,SAAYA,GAAuB,EAC1C,CAwDF,OAtDE98B,OAAA2H,eAAIwwD,EAAAl4D,UAAA,aAAU,C,IAAd,WACE,OAAOpC,KAAKi/B,SAASn6B,MACvB,E,gCAEAw1D,EAAAl4D,UAAAm4D,QAAA,SAAQ/pD,GACN,OAAIA,EAAQ,EAAUxQ,KAAKi/B,SAASj/B,KAAKi/B,SAASn6B,OAAS0L,GACpDxQ,KAAKi/B,SAASzuB,EACvB,EAEArO,OAAA2H,eAAIwwD,EAAAl4D,UAAA,aAAU,C,IAAd,WACE,OAAOpC,KAAKq3C,IAAInB,UAClB,E,gCAEAokB,EAAAl4D,UAAAkgC,IAAA,SAAI0Q,EAAYxiC,GACd,QADc,IAAAA,IAAAA,GAAS,GACnBxQ,KAAKk2C,WACP,MAAM,IAAIrqC,MAAM,wBAAA4C,OAAwBukC,EAAKqE,IAAIzB,MAAK,0BAAAnnC,OAAyBzO,KAAKq3C,IAAIzB,QAO1F,OALIplC,EAAQ,EACVxQ,KAAKi/B,SAASv3B,KAAKsrC,GAEnBhzC,KAAKi/B,SAASlT,OAAOvb,EAAO,EAAGwiC,GAE1BhzC,IACT,EAEAs6D,EAAAl4D,UAAA2pB,OAAA,SAAOvb,EAAe+oC,G,UAAqB5G,EAAA,GAAAmG,EAAA,EAAAA,EAAA72C,UAAA6C,OAAAg0C,IAAAnG,EAAAmG,EAAA,GAAA72C,UAAA62C,GAEzC,OADA5M,EAAAlsC,KAAKi/B,UAASlT,OAAM/pB,MAAAkqC,EAAAqH,GAAC,CAAA/iC,EAAO+oC,GAAWlG,GAAKV,IAAK,IAC1C3yC,IACT,EAEAmC,OAAA2H,eAAIwwD,EAAAl4D,UAAA,aAAU,C,IAAd,WAOE,OAAOpC,KAAKg+B,YAAW,GAAOtvB,KAAK,KACrC,E,gCAEA4rD,EAAAl4D,UAAA47B,WAAA,SAAWw1B,GACT,QADS,IAAAA,IAAAA,GAAA,GACLA,EAAK,CACP,IAAMv7B,EAAW,CAACj4B,KAAKq3C,IAAIzB,OAG3B,OAFI51C,KAAKqB,OAAO42B,EAAIvwB,KAAK1H,KAAKqB,OAC1BrB,KAAKi/B,SAASn6B,OAAS,GAAGmzB,EAAIvwB,KAAK1H,KAAKi/B,SAASx6B,IAAI,SAACnD,GAAM,OAAAA,EAAE08B,WAAWw1B,EAAb,IACzDv7B,C,CAEP,IAAMuiC,EAAa,GAInB,OAHcx6D,KAAKqB,MACnBm5D,EAAI9yD,KAAmB,MAAd1H,KAAKqB,MAAgBrB,KAAKq3C,IAAIzB,MAAQ51C,KAAKq3C,IAAIzB,MAAQ,MAAQ51C,KAAKqB,OAC7ErB,KAAKi/B,SAASv6B,QAAQ,SAACsuC,GAAS,OAACA,EAAKhV,WAAWw1B,GAAkB9uD,QAAQ,SAACG,GAAM,OAAA21D,EAAI9yD,KAAK,KAAO7C,EAAhB,EAAlD,GACzB21D,CAEX,EACFF,CAAA,CA5DA,IA6EAG,GAAA,oBAAAA,IAoBA,QAjBEA,EAAAr4D,UAAAs4D,aAAA,SAAa3B,GAEX,OADA/4D,KAAK26D,YAAc,IAAI9D,GAAiBkC,EAAW,MAC5C/4D,IACT,EAOAy6D,EAAAr4D,UAAAk5C,OAAA,SAAOp0C,GACL,IAAM+wB,EAAMj4B,KAAKk1C,QAAQoG,OAAOp0C,EAAMw5C,KACtC,GAAW,MAAPzoB,EACF,MAAM,IAAIpsB,MAAM,sBAAwB3E,EAAMw5C,IAAM,YAAcx5C,EAAM7F,OAE1E,OAAO42B,CACT,EACFwiC,CAAA,CApBA,GAsBAG,GAAA,SAAAljB,GAAA,SAAAkjB,I,8CAYA,QAZ2ChjB,GAAAgjB,EAAAljB,GACzCkjB,EAAAx4D,UAAAiT,MAAA,SAAM64C,EAA2B2M,GAI/B,YAJ+B,IAAAA,IAAAA,EAAA,MACV,iBAAV3M,IACTA,EAAQ,IAAI2I,GAAU3I,IAEjBluD,KAAK86D,WAAW5M,EAAO2M,EAChC,EAMFD,CAAA,CAZA,CAA2CH,IRlGrC,SAAUM,GAAUz9B,EAAYoZ,EAAWskB,GAC/C,YAD+C,IAAAA,IAAAA,GAAA,GACxCtkB,EAAKU,WACd,EQ8GA,SAAAM,GAAA,SAAAujB,I,8CAYA,CAZ6CrjB,GAAAqjB,EAAAvjB,GAC3CujB,EAAA74D,UAAAiT,MAAA,SAAM64C,EAA2B2M,GAI/B,YAJ+B,IAAAA,IAAAA,EAAA,MACV,iBAAV3M,IACTA,EAAQ,IAAI2I,GAAU3I,IAEjBluD,KAAK86D,WAAW5M,EAAO2M,EAChC,CAMF,CAZA,CAA6CJ,I,ICrIjCS,GAAAA,G,miCC0GZC,IAjHA,WAIE,SAAAC,EAAYlmB,GACVl1C,KAAKk1C,QAAUA,EACfl1C,KAAKo2C,SACP,CAEAglB,EAAAh5D,UAAAg0C,QAAA,eAAAC,EAAA,KASE,OARAr2C,KAAKkU,QAAU,IAAI2T,IACnB7nB,KAAKk1C,QAAQuF,WAAWrE,UACxBp2C,KAAKk1C,QAAQ8C,YAAY,KAAM,SAACtB,EAAMlmC,GACpC6lC,EAAK4B,YAAYvB,EAAMlmC,EACzB,GVpBE,SAAuB8sB,EAAY09B,QAAA,IAAAA,IAAAA,GAAA,GACvC,IAAI/iC,EAAM,GACVqF,EAAE6d,UAAU,SAAC3E,GACNwkB,GAAYxkB,EAAGb,cAClB1d,GAAOue,EAAGZ,MAAQ,OAClB3d,GAMA,SAAqBqF,EAAY8d,EAAe4f,QAAA,IAAAA,IAAAA,GAAA,GAIpD,IAFA,IAAI/iC,EAAM,GACJojC,EAAY,OACTx6D,EAAI,EAAGA,EAAIu6C,EAAMt2C,OAAQjE,IAE5BA,EAAI,IACDm6D,IACH/iC,GAAO,KACPA,GAAOojC,GAETpjC,GAAO,OAETA,GAAO8iC,GAAUz9B,EARJ8d,EAAMv6C,GAQM+1C,IAAKokB,GAOhC,OALKA,IACH/iC,GAAO,KACPA,GAAOojC,GAETpjC,EAAO,IAET,CA3BaqjC,CAAWh+B,EAAGA,EAAEmZ,WAAWD,GAAKwkB,GAAW,OAEtD,EAEF,CUYoBO,CAAav7D,KAAKk1C,SAAS,GAChCl1C,KAAKk1C,QAAQpC,OACb9yC,KAAKk1C,QAAQsmB,cACjBx7D,IACT,EAEAmC,OAAA2H,eAAIsxD,EAAAh5D,UAAA,QAAK,C,IAAT,W,YACMd,EAAI,E,IACR,IAAiB,IAAAsyC,EAAAF,GAAA1zC,KAAKkU,QAAQutB,UAAQ8S,EAAAX,EAAA3oC,QAAAspC,EAAArpC,KAAAqpC,EAAAX,EAAA3oC,OAAE,CAAnC,IAAMurC,EAAEjC,EAAAlzC,M,IACX,IAAmB,IAAA28C,GAAAxK,OAAA,EAAAE,GAAA8C,EAAG/U,WAAQyc,EAAAF,EAAA/yC,QAAAizC,EAAAhzC,KAAAgzC,EAAAF,EAAA/yC,OAC5B3J,GADa48C,EAAA78C,MACHyD,M,qMAGd,OAAOxD,CACT,E,gCAEA85D,EAAAh5D,UAAAq5D,YAAA,SAAYjlB,EAASP,GACnBpQ,GAAY2Q,EAAGN,YAAcD,EAAKC,YAClC,IAAIwlB,EAAe17D,KAAKkU,QAAQ2D,IAAI2+B,EAAGpkC,IAClCspD,IACHA,EAAe,IAAI7zC,IACnB7nB,KAAKkU,QAAQtI,IAAI4qC,EAAGpkC,GAAIspD,IAE1B,IAAIxnD,EAAUwnD,EAAa7jD,IAAIo+B,EAAK7jC,IAKpC,OAJK8B,IACHA,EAAU,GACVwnD,EAAa9vD,IAAIqqC,EAAK7jC,GAAI8B,IAErBA,CACT,EAEAknD,EAAAh5D,UAAAkgC,IAAA,SAAIkU,EAASP,EAAWr+B,GACtB,IAAM1D,EAAUlU,KAAKy7D,YAAYjlB,EAAIP,GAIrC,OAHI/hC,EAAQunC,UAAU,SAACl7C,GAAM,OAAAA,EAAEk3B,OAAO7f,EAAT,GAAmB,GAC9C1D,EAAQxM,KAAKkQ,GAEU,GAAlB1D,EAAQpP,MACjB,EAEAs2D,EAAAh5D,UAAAyV,IAAA,SAAI2+B,EAASP,GACX,OAAOj2C,KAAKy7D,YAAYjlB,EAAIP,EAC9B,EAEAmlB,EAAAh5D,UAAA2I,aAAA,SAAa6E,G,gBACX,IAAmB,IAAAgkC,EAAAF,GAAA1zC,KAAKkU,QAAQnP,QAAMwvC,EAAAX,EAAA3oC,QAAAspC,EAAArpC,KAAAqpC,EAAAX,EAAA3oC,OAAE,CAAnC,IAAM0wD,EAAIpnB,EAAAlzC,MACPu6D,EAAQ57D,KAAKkU,QAAQ2D,IAAI8jD,IAAS,KACxC91B,EAAoB,MAAT+1B,GACX,IAAMlgB,EAAU17C,KAAKk1C,QAAQQ,WAAWimB,GACxC91B,EAAsB,MAAX6V,G,IACX,IAAqB,IAAAsC,GAAA6d,OAAA,EAAAnoB,GAAAkoB,EAAM72D,SAAMm5C,EAAAF,EAAA/yC,QAAAizC,EAAAhzC,KAAAgzC,EAAAF,EAAA/yC,OAAE,CAA9B,IAAM6wD,EAAM5d,EAAA78C,MACT40C,EAAOj2C,KAAKk1C,QAAQQ,WAAWomB,GAGrC,GAFAj2B,EAAmB,MAARoQ,GAE0B,GAAjCrmC,EAAQ8rC,EAASzF,EADP2lB,EAAM/jD,IAAIikD,IAAW,IACS,M,sMAGlD,EAEA35D,OAAA2H,eAAIsxD,EAAAh5D,UAAA,aAAU,C,IAAd,WACE,IAAM61B,EAAsC,CAAC,EAS7C,OARAj4B,KAAK+K,aAAa,SAACyrC,EAAIP,EAAM8lB,G,QAC3B9jC,EAAIue,EAAGZ,OAAS3d,EAAIue,EAAGZ,QAAU,CAAC,EAClC3d,EAAIue,EAAGZ,OAAOK,EAAKL,OAAS3d,EAAIue,EAAGZ,OAAOK,EAAKL,QAAU,GACzD,IAAM1hC,EAAU+jB,EAAIue,EAAGZ,OAAOK,EAAKL,O,IACnC,IAAmB,IAAAomB,EAAAtoB,GAAAqoB,GAAKE,EAAAD,EAAA/wD,QAAAgxD,EAAA/wD,KAAA+wD,EAAAD,EAAA/wD,OAAE,CAArB,IAAMixD,EAAID,EAAA56D,MACb6S,EAAQxM,KAAKw0D,EAAK9kB,Y,mGAEtB,GACOnf,CACT,E,gCAEAmjC,EAAAh5D,UAAA61C,YAAA,SAAYvB,EAAYlmC,GAAxB,IAAA6lC,EAAA,KACQ8B,EAAYn4C,KAAKk1C,QAAQiD,UAG3BgkB,GAAiB,EACrBhkB,EAAUN,cAAcnB,EAAKE,IAAK,EAAG,SAACX,GACxB,MAARA,EACFkmB,GAAiB,EAEjB9lB,EAAK/T,IAAIoU,EAAKF,GAAIP,EAAMS,EAE5B,GAOIylB,GACFn8D,KAAKk1C,QAAQuF,WAAWvD,YAAYR,EAAKF,GAAI,SAACP,GAC5CpQ,EAAmB,MAARoQ,EAAc,gCACzBI,EAAK/T,IAAIoU,EAAKF,GAAIP,EAAMS,EAC1B,EAEJ,CACF,CA/GA,GAiHA,WAME,SAAAykB,EAAYiB,GADF,KAAAlvB,UAAY,EAEpBltC,KAAKo8D,WAAaA,EAClBp8D,KAAK6M,MAAQ,GACb,IAAMywB,EAAI8+B,EAAWlnB,QACrBrP,EAA4B,MAAjBvI,EAAE8a,YAAqB,6BAClCp4C,KAAKq8D,QAAUr8D,KAAK0H,KAAK41B,EAAE+a,IAAK,IAAI8hB,GAAOn6D,KAAKktC,YAAa,IAAIoL,GAAIhb,EAAG,SAAS,GAAQ,OACzFt9B,KAAKs8D,SAAWt8D,KAAK0H,KAAK41B,EAAE8a,aAC5Bp4C,KAAKq8D,QAAQ/5B,IAAItiC,KAAKs8D,SACxB,CA0BF,OAxBEn6D,OAAA2H,eAAIqxD,EAAA/4D,UAAA,cAAW,C,IAAf,WACE,MAAO,WAAapC,KAAK6M,MAAMpI,IAAI,SAACyyB,GAAM,OAAAA,EAAE,GAAG0e,KAAL,GAAYlnC,KAAK,MAAQ,GACrE,E,gCAEAysD,EAAA/4D,UAAAsF,KAAA,SAAK2vC,EAAUrE,GAGb,YAHa,IAAAA,IAAAA,EAAA,MACRA,IAAMA,EAAO,IAAImnB,GAAOn6D,KAAKktC,YAAamK,EAAK,OACpDr3C,KAAK6M,MAAMnF,KAAK,CAAC2vC,EAAKrE,IACfA,CACT,EAEAmoB,EAAA/4D,UAAAm6D,IAAA,WACE,OAAOv8D,KAAK6M,MAAM7M,KAAK6M,MAAM/H,OAAS,EACxC,EAEAq2D,EAAA/4D,UAAAuO,IAAA,WAIE,OAHyB,GAArB3Q,KAAK6M,MAAM/H,QACb+gC,GAAW,EAAO,oBAEb7lC,KAAK6M,MAAM8D,KACpB,EAEAxO,OAAA2H,eAAIqxD,EAAA/4D,UAAA,UAAO,C,IAAX,WACE,OAA4B,GAArBpC,KAAK6M,MAAM/H,MACpB,E,gCACFq2D,CAAA,CAxCA,I,IA0CA,SAAAzjB,GAGE,SAAA8kB,EAA4BJ,GAA5B,IAAA/lB,EACEqB,EAAA50C,KAAA,OAAO,K,OADmBuzC,EAAA+lB,WAAAA,EAE1Bv2B,EAA6C,MAAlCu2B,EAAWlnB,QAAQkD,YAAqB,6B,CACrD,CAN0BR,GAAA4kB,EAAA9kB,GAQ1Bv1C,OAAA2H,eAAI0yD,EAAAp6D,UAAA,UAAO,C,IAAX,WACE,OAAOpC,KAAKo8D,WAAWlnB,OACzB,E,gCAKUsnB,EAAAp6D,UAAA04D,WAAV,SAAqB5M,EAAkB2M,G,aAAA,IAAAA,IAAAA,EAAA,MACrC76D,KAAK6M,MAAQ,IAAIsuD,GAAWn7D,KAAKo8D,YACjC,IAGIl1D,EACAu1D,EACAC,EALE/B,EAAc36D,KAAK26D,YACnB9tD,EAAQ7M,KAAK6M,MACbywB,EAAIt9B,KAAKk1C,QAIf,EAAG,CACDhuC,EAAQyzD,EAAYjL,KAAKxB,GACxBuO,GAADvwB,EAAAmH,GAAqBxmC,EAAM0vD,MAAK,IAAxB,GAAEG,EAAOxwB,EAAA,GACjB,IAAMywB,EAAmB,MAATz1D,EAAgBo2B,EAAE+a,IAAMr4C,KAAKs7C,OAAOp0C,GAC9C01D,EAAqB,MAAT11D,EAAgB,KAAOA,EAAM7F,MAC/C,GAAIo7D,EAAQvmB,WACNumB,GAAWE,EAGb38D,KAAK68D,mBAAmB3O,EAAOyO,EAASz1D,GAExClH,KAAK88D,oBAAoBH,EAASz1D,OAE/B,CACL,IAAMgN,EAAUlU,KAAKo8D,WAAWvkD,IAAI4kD,EAASE,GAC7C,GAAsB,GAAlBzoD,EAAQpP,OACV0kB,QAAQ7nB,IAAI,YAAa86D,GACzBjzC,QAAQ7nB,IAAI,YAAag7D,GACzB38D,KAAK+8D,yBAAyBL,EAASD,EAASE,EAASC,EAAW1oD,OAC/D,CACC,IAAA0/B,EAAAP,GAAgBrzC,KAAK6M,MAAM8D,MAAK,GAA/B0mC,EAAGzD,EAAA,GAAEopB,EAAMppB,EAAA,GAClB/N,EAAWm3B,GAAUN,GACrB72B,EAAWwR,GAAOnjC,EAAQ,GAAGsiC,IAC7B3Q,EAAWm3B,EAAO3lB,KAAOA,GACzBr3C,KAAKi9D,kBAAkBD,EAAQ9oD,EAAQ,G,EAG1CuoD,GAAD/sB,EAAA2D,GAAqBxmC,EAAM0vD,MAAK,IAAxB,GAAEG,EAAOhtB,EAAA,E,OACV+sB,GAAWn/B,EAAE+a,KACtB,OAAOxrC,EAAMyvD,QACf,EAEAE,EAAAp6D,UAAA66D,kBAAA,SAAkBC,EAAoBxmB,GAEpC,IAAK,IAAI71C,EAAI61C,EAAKE,IAAIG,KAAKjyC,OAAS,EAAGjE,GAAK,EAAGA,IAAK,CAClD,IAAMw2C,EAAMX,EAAKE,IAAIG,KAAKl2C,GACpBmyC,EAAOhzC,KAAK6M,MAAMnF,KAAK2vC,GAC7B6lB,EAAW56B,IAAI0Q,EAAM,E,CAEzB,EACAwpB,EAAAp6D,UAAAy6D,mBAAA,SAAmB1U,EAAiBwU,EAAcnN,GAC1C,IAAAtjB,EAAAmH,GAAgBrzC,KAAK6M,MAAM0vD,MAAK,GAA/BllB,EAAGnL,EAAA,GAAE8wB,EAAM9wB,EAAA,GAClBrG,EAAWwR,GAAOslB,GAClB92B,EAAWm3B,EAAO3lB,KAAOslB,GACzBK,EAAO37D,MAAQmuD,EAAUnuD,MACzBrB,KAAK26D,YAAY1vD,KAAKk9C,GACtBnoD,KAAK6M,MAAM8D,KACb,EAEA6rD,EAAAp6D,UAAA06D,oBAAA,SAAoBH,EAAcC,GAChC,MAAM,IAAI/wD,MAAM,kBAAoB8wD,EAAQ/mB,MAE9C,EAEA4mB,EAAAp6D,UAAA26D,yBAAA,SAAyBL,EAAiBpF,EAAcqF,EAAcC,EAAgB1oD,GACpF,MAAM,IAAIrI,MAAM,wBAAA4C,OAAwByF,EAAQpP,OAAM,WAAA2J,OAAU6oD,EAAQ1hB,MAAK,QAAAnnC,OAAOkuD,EAAQ/mB,OAE9F,CACF,CAjFA,CAA4B6kB,I,ydbpK5B0C,GAAA,SAAAzlB,GACE,SAAAylB,EAAY7vD,EAAwBpK,EAAqB7B,QAAA,IAAAA,IAAAA,EAAA,M,uBAAzDg1C,EACEqB,EAAA50C,KAAA,KAAMwK,IAAQ,K,OADoB+oC,EAAAnzC,KAAAA,EAAqBmzC,EAAAh1C,MAAAA,EAEvDc,OAAOyrD,eAAevX,EAAMwX,EAAWzrD,W,CACzC,CAKF,OATgCw1C,GAAAulB,EAAAzlB,GAM9Bv1C,OAAA2H,eAAIqzD,EAAA/6D,UAAA,OAAI,C,IAAR,WACE,OAAO,KAAKqB,YAAYgD,IAC1B,E,gCACF02D,CAAA,CATA,CAAgCtxD,O,uuCYgBpBqvD,GAAAA,KAAAA,GAAY,KACtBA,GAAA,mBACAA,GAAAA,GAAA,iBACAA,GAAAA,GAAA,mBACAA,GAAAA,GAAA,eAGF,IAAAkC,GAAA,oBAAAA,IAKE,KAAAC,UAA8B,KAG9B,KAAA3mB,KAAuB,IA2CzB,QAzCE0mB,EAAAh7D,UAAAF,SAAA,WACE,OAAIlC,KAAK0gD,KAAOwa,GAAaoC,OAAe,MACnCt9D,KAAK0gD,KAAOwa,GAAaqC,MACzB,IAAMv9D,KAAKq9D,UACTr9D,KAAK0gD,KAAOwa,GAAasC,OAC3B,KAAOx9D,KAAK02C,KAAMtkC,GAElB,GAAKpS,KAAKq9D,SAErB,EAEAD,EAAAh7D,UAAAq1B,OAAA,SAAOwG,GACL,OAAOj+B,KAAK0gD,KAAOziB,EAAQyiB,KAAO1gD,KAAKq9D,WAAap/B,EAAQo/B,WAAar9D,KAAK02C,MAAQzY,EAAQyY,IAChG,EAEO0mB,EAAAK,MAAP,SAAaC,GACX,IAAMzlC,EAAM,IAAImlC,EAGhB,OAFAnlC,EAAIyoB,IAAMwa,GAAaqC,MACvBtlC,EAAIolC,UAAYK,EACTzlC,CACT,EAEOmlC,EAAAO,OAAP,SAAcjnB,GACZ,IAAMze,EAAM,IAAImlC,EAGhB,OAFAnlC,EAAIyoB,IAAMwa,GAAasC,OACvBvlC,EAAIye,KAAOA,EACJze,CACT,EAEOmlC,EAAAQ,KAAP,SAAYP,GACV,IAAMplC,EAAM,IAAImlC,EAGhB,OAFAnlC,EAAIyoB,IAAMwa,GAAa2C,KACvB5lC,EAAIolC,UAAYA,EACTplC,CACT,EAEOmlC,EAAAU,OAAP,WACE,IAAM7lC,EAAM,IAAImlC,EAEhB,OADAnlC,EAAIyoB,IAAMwa,GAAaoC,OAChBrlC,CACT,EACFmlC,CAAA,CAnDA,GAwDAhC,GAAA,WASE,SAAAA,EAA4BlmB,GAAA,KAAAA,QAAAA,EAP5B,KAAA6oB,gBAA8C,CAAC,EAK/C,KAAAC,QAAsC,CAAC,CAEQ,CAqDjD,OAnDE77D,OAAA2H,eAAIsxD,EAAAh5D,UAAA,eAAY,C,IAAhB,WACE,OAAOD,OAAO4C,KAAK/E,KAAK+9D,iBAAiBj5D,OAAS,CACpD,E,gCAKAs2D,EAAAh5D,UAAA67D,WAAA,SAAWC,EAAiBjzD,EAAW8pC,GACrC,IAAIsY,EACJ,QAFqC,IAAAtY,IAAAA,GAAA,GAEjCmpB,KAAWl+D,KAAKg+D,QAClB3Q,EAAKrtD,KAAKg+D,QAAQE,OACb,KAAInpB,EAGT,MAAO,GAFPsY,EAAKrtD,KAAKg+D,QAAQE,GAAW,CAAC,C,CAKhC,OAAIjzD,EAAKmH,MAAMi7C,EACNA,EAAGpiD,EAAKmH,IACN2iC,EACDsY,EAAGpiD,EAAKmH,IAAM,GAEjB,EACT,EAEAgpD,EAAAh5D,UAAA+7D,UAAA,SAAUD,EAAiBjzD,EAAW4uC,GACpC,IAAMmkB,EAAUh+D,KAAKi+D,WAAWC,EAASjzD,GAAM,GAQ/C,OAPI+yD,EAAQviB,UAAU,SAAC2iB,GAAO,OAAAA,EAAG3mC,OAAOoiB,EAAV,GAAqB,GACjDmkB,EAAQt2D,KAAKmyC,GAEXmkB,EAAQl5D,OAAS,IACnB9E,KAAK+9D,gBAAgBG,GAAWl+D,KAAK+9D,gBAAgBG,IAAY,CAAC,EAClEl+D,KAAK+9D,gBAAgBG,GAASjzD,EAAK2qC,QAAS,GAEvC51C,IACT,EAEAmC,OAAA2H,eAAIsxD,EAAAh5D,UAAA,aAAU,C,IAAd,WACE,IAAM61B,EAAW,CAAC,EAClB,IAAK,IAAMomC,KAAUr+D,KAAKg+D,QAExB,IAAK,IAAMM,KADXrmC,EAAIomC,GAAU,CAAC,EACKr+D,KAAKg+D,QAAQK,GAAS,CACxC,IAAMhnB,EAAMr3C,KAAKk1C,QAAQQ,WAAW4oB,GAC9BN,EAAUh+D,KAAKg+D,QAAQK,GAAQhnB,EAAIjlC,KAAO,GAC5C4rD,EAAQl5D,OAAS,IACnBmzB,EAAIomC,GAAQhnB,EAAIzB,OAASooB,EAAQv5D,IAAI,SAAC2E,GAAM,OAAAA,EAAElH,UAAF,G,CAIlD,OAAO+1B,CACT,E,gCACFmjC,CAAA,CA9DA,GAgEAD,GAAA,oBAAAA,IAIW,KAAAoD,WAAuB,GACvB,KAAAC,UAAsB,EAiCjC,QA/BErD,EAAA/4D,UAAAsF,KAAA,SAAKghB,EAAesqB,GAClBhzC,KAAKu+D,WAAW72D,KAAKghB,GACrB1oB,KAAKw+D,UAAU92D,KAAKsrC,EACtB,EAKAmoB,EAAA/4D,UAAAm6D,IAAA,SAAI5M,GACF,YADE,IAAAA,IAAAA,EAAA,GACK,CAAC3vD,KAAKu+D,WAAWv+D,KAAKu+D,WAAWz5D,OAAS,EAAI6qD,GAAM3vD,KAAKw+D,UAAUx+D,KAAKw+D,UAAU15D,OAAS,EAAI6qD,GACxG,EAEAwL,EAAA/4D,UAAAuO,IAAA,WACE,IAAMsnB,EAAMj4B,KAAKu8D,MAGjB,OAFAv8D,KAAKu+D,WAAW5tD,MAChB3Q,KAAKw+D,UAAU7tD,MACRsnB,CACT,EAKAkjC,EAAA/4D,UAAAq8D,KAAA,SAAK1qC,QAAA,IAAAA,IAAAA,EAAA,GACH,IAAM2qC,EAAI1+D,KAAKu+D,WAAWz5D,OAC1B9E,KAAKu+D,WAAWxyC,OAAO2yC,EAAI3qC,EAAGA,GAC9B/zB,KAAKw+D,UAAUzyC,OAAO2yC,EAAI3qC,EAAGA,EAC/B,EAEA5xB,OAAA2H,eAAIqxD,EAAA/4D,UAAA,UAAO,C,IAAX,WACE,OAAiC,GAA1BpC,KAAKu+D,WAAWz5D,QAAwC,GAAzB9E,KAAKw+D,UAAU15D,MACvD,E,gCACFq2D,CAAA,CAtCA,GAgEAqB,GAAA,SAAA9kB,GACE,SAAA8kB,EAA4BJ,EAAwB5uD,QAAA,IAAAA,IAAAA,EAAA,IAApD,IAAA6oC,EACEqB,EAAA50C,KAAA,OAAO,K,OADmBuzC,EAAA+lB,WAAAA,E,CAE5B,CAwLF,OA3L4BxkB,GAAA4kB,EAAA9kB,GAK1Bv1C,OAAA2H,eAAI0yD,EAAAp6D,UAAA,UAAO,C,IAAX,WACE,OAAOpC,KAAKo8D,WAAWlnB,OACzB,E,gCAKUsnB,EAAAp6D,UAAA04D,WAAV,SAAqB5M,EAAkBvoD,G,UACrCA,EAAUA,GAAY,CAAC,EAEvB3F,KAAK26D,YAAYlL,iBAAmB9pD,EAAQ8pD,iBACd,GAA1B9pD,EAAQg5D,iBAAyBh5D,EAAQg5D,gBAAiB,GAC/B,GAA3Bh5D,EAAQi5D,kBAA0Bj5D,EAAQi5D,iBAAkB,GAChE,IAAI1xB,EAAY,EACVrgC,EAAQ,IAAIsuD,GAClBtuD,EAAMnF,KAAK,EAAG,IAAIyyD,GAAOjtB,IAAaltC,KAAKk1C,QAAQ2pB,aAAaroB,GAAI,OACpE,IAAMmkB,EAAc36D,KAAK26D,YACnBr9B,EAAIt9B,KAAKk1C,QACXpY,EAA2B,KAM/B,SAASgiC,EAAed,GACtB,GAAIr4D,aAAO,EAAPA,EAASo5D,eACX,OAAOp5D,EAAQo5D,eAAef,EAASnxD,EAAO8tD,GAE9C,GAAIqD,EAAQl5D,OAAS,EACnB,MAAM,IAAI+G,MAAM,2BAElB,OAAOmyD,EAAQ,EAEnB,CAEA,SAASxO,IACP,IACE,OAAOmL,EAAYjL,KAAKxB,E,CACxB,MAAOnsC,GACP,KAAKpc,aAAO,EAAPA,EAASq5D,iBAAiBr5D,aAAO,EAAPA,EAASq5D,aAAaj9C,EAA4BmsC,IAE/E,MAAMnsC,EAKR,OAAOytC,G,CAEX,CAEA,OAAa,CAEX,IAAItoD,EAAQsoD,IACZ,GAAa,MAATtoD,GACF,GAAI2F,EAAMq1B,QAER,WAEOv8B,EAAQs5D,cACjB/3D,EAAQvB,EAAQs5D,YAAY/3D,IAE9B,IAAMy1D,EAAmB,MAATz1D,EAAgBo2B,EAAE+a,IAAMr4C,KAAKs7C,OAAOp0C,GAC9C01D,EAAqB,MAAT11D,EAAgB,KAAOA,EAAM7F,MAC3CuyC,EAAAP,GAAsBxmC,EAAM0vD,MAAK,GAAhC2C,EAAQtrB,EAAA,GACPoqB,GADgBpqB,EAAA,GACN5zC,KAAKo8D,WAAW6B,WAAWiB,EAAUvC,IACrD,GAAe,MAAXqB,GAAqC,GAAlBA,EAAQl5D,OAE7B,MAAM,IAAIq4D,GAAW,sBAAA1uD,OAAsBkuD,EAAQ/mB,MAAK,KAAK,kBAAmB,CAC9EltB,MAAOw2C,EACPh4D,MAAOA,EACPy1D,QAASA,IAIb,IAAM9iB,EAASilB,EAAed,GAC9B,GAAInkB,EAAO6G,KAAOwa,GAAaoC,OAC7B,MACK,GAAIzjB,EAAO6G,KAAOwa,GAAaqC,MAAO,CAC3C5C,EAAY1vD,KAAKijD,GACjB,IAAM7Z,EAAU,IAAI8lB,GAAOjtB,IAAayvB,EAASC,GACjD/vD,EAAMnF,KAAKmyC,EAAOwjB,UAAYhpB,E,KACzB,CAELxO,EAA0B,MAAfgU,EAAOnD,KAAc,iEAChC,IAAMyoB,EAAUtlB,EAAOnD,KAAKE,IAAI9xC,OA8ChC,GA3CIuvC,EAAU,IAAI8lB,GAAOjtB,IAAa2M,EAAOnD,KAAKF,GAAI,MA2ClD7wC,EAAQg5D,eACV,IAAK,IAAI99D,EAAIs+D,EAAU,EAAGt+D,GAAK,EAAGA,IAAK,CACrC,IAAMu+D,EAAkCvyD,EAAM0vD,IAAI17D,GAAG,GACrD,GAAI8E,EAAQ05D,sB,IACV,IAAmB,IAAA9qB,GAAAd,OAAA,EAAAC,GAAA/tC,EAAQ05D,sBAAsBhrB,EAAS+qB,KAAUphB,EAAAzJ,EAAAtpC,QAAA+yC,EAAA9yC,KAAA8yC,EAAAzJ,EAAAtpC,OAAE,CAAjE,IAAM+nC,EAAIgL,EAAA38C,MACbgzC,EAAQ/R,IAAI0Q,E,wGAEQ,MAAbosB,GACT/qB,EAAQ/R,IAAI88B,E,CAKlB,GAAIvlB,EAAOnD,KAAKmD,OAEd,GAAIA,EAAOnD,KAAKmD,OAAOlxC,WAAY,CAEjC,IAAM22D,EAAczlB,EAAOnD,KAAKmD,OAAOx4C,MACjCy/B,EAAUn7B,EAAQ45D,aAAcD,GACtC,IAAKx+B,EAAS,MAAM,IAAIj1B,MAAM,6BAA+ByzD,GAM7DjrB,EAAQhzC,MAAQy/B,EAAO9+B,WAAC,EAADuxC,GAAC,CAAAsG,EAAOnD,KAAMrC,GAAOhB,GAAKgB,EAAQpV,WAAQ,G,MAGjEoV,EAAQhzC,MAAQgzC,EAAQpV,SAAU4a,EAAOnD,KAAKmD,OAAOx4C,MAAmB,GAAGA,WAEpEsE,EAAQ65D,YAEjBnrB,EAAU1uC,EAAQ65D,YAAYnrB,EAASwF,EAAOnD,MACV,GAA3BrC,EAAQpV,SAASn6B,QAAea,EAAQi5D,kBAGjDvqB,EAAQhzC,MAAQgzC,EAAQpV,SAAS,GAAG59B,OAKtCwL,EAAM4xD,KAAKU,GACVD,GAADxvB,EAAA2D,GAAsBxmC,EAAM0vD,MAAK,IAAxB,GAAS7sB,EAAA,GAClB,IAAM+vB,EAAYX,EAAe9+D,KAAKo8D,WAAW6B,WAAWiB,EAAUrlB,EAAOnD,KAAKF,KAClF3Q,EAAwB,MAAb45B,GAA4C,MAAvBA,EAAUpC,UAAmB,qCAC7DxwD,EAAMnF,KAAK+3D,EAAUpC,UAAWhpB,GAChCvX,EAASuX,C,EAIb,OAAOvX,CACT,EACF0/B,CAAA,CA3LA,CAA4B/B,I,y7CExM5BiF,GAAA,WAIE,SAAAA,EAAYhpB,EAAYlsC,QAAA,IAAAA,IAAAA,EAAA,GAHxB,KAAA4H,GAAK,EAIHpS,KAAK02C,KAAOA,EACZ12C,KAAKwK,SAAWA,CAClB,CA4CF,OA1CEk1D,EAAAt9D,UAAA4oD,QAAA,WAEE,OADAnlB,EAAW7lC,KAAKwK,SAAWxK,KAAK02C,KAAKE,IAAI9xC,QAClC,IAAI46D,EAAO1/D,KAAK02C,KAAM12C,KAAKwK,SAAW,EAC/C,EAEAk1D,EAAAt9D,UAAAywB,KAAA,WACE,OAAO,IAAI6sC,EAAO1/D,KAAK02C,KAAM12C,KAAKwK,SACpC,EAaArI,OAAA2H,eAAI41D,EAAAt9D,UAAA,MAAG,C,IAAP,WAEE,OADAyjC,GAAYpkC,MAAMzB,KAAK02C,KAAKtkC,IAAK,6BAC1BpS,KAAK02C,KAAKtkC,GAAK,IAAMpS,KAAKwK,QACnC,E,gCAEAk1D,EAAAt9D,UAAAu2C,UAAA,SAAU1a,GACR,IAAIwb,EAAOz5C,KAAK02C,KAAKtkC,GAAK6rB,EAAQyY,KAAKtkC,GAEvC,OADY,GAARqnC,IAAWA,EAAOz5C,KAAKwK,SAAWyzB,EAAQzzB,UACvCivC,CACT,EAEAimB,EAAAt9D,UAAAq1B,OAAA,SAAOwG,GACL,OAAkC,GAA3Bj+B,KAAK24C,UAAU1a,EACxB,EAEA97B,OAAA2H,eAAI41D,EAAAt9D,UAAA,cAAW,C,IAAf,WACE,IAAMs0C,EAAO12C,KAAK02C,KACZzyB,EAAMjkB,KAAKwK,SACXm1D,EAAMjpB,EAAKE,IAAIG,KAAKh0C,MAAM,EAAGkhB,GAAKvV,KAAK,KACvCkxD,EAAOlpB,EAAKE,IAAIG,KAAKh0C,MAAMkhB,GAAKvV,KAAK,KAC3C,MAAO,GAAAD,OAAGioC,EAAKtkC,GAAE,SAAA3D,OAAQioC,EAAKF,GAAE,QAAA/nC,OAAOkxD,EAAG,OAAAlxD,OAAMmxD,EAClD,E,gCACFF,CAAA,CAnDA,GAqDAG,GAAA,WAQE,SAAAA,EAAYC,G,IAAiB,IAAA5rD,EAAA,GAAA4kC,EAAA,EAAAA,EAAA72C,UAAA6C,OAAAg0C,IAAA5kC,EAAA4kC,EAAA,GAAA72C,UAAA62C,GAP7B,KAAA1mC,GAAK,EAEK,KAAAhN,KAAyB,KAEzB,KAAA26D,YAA6B,CAAC,EAC9B,KAAAC,gBAAiB,EAGzBhgE,KAAKigE,UAAYH,EACjB9/D,KAAKyhC,OAASvtB,CAChB,CA8GF,OA5GE2rD,EAAAz9D,UAAAywB,KAAA,WACE,IAAMoF,EAAM,IAAI4nC,EAASh+D,KAAAG,MAAT69D,EAAStsB,GAAC,MAAD,EAACvzC,KAAKigE,WAAS5sB,GAAKrzC,KAAKyhC,SAAM,KAGxD,OAFAxJ,EAAI8nC,YAAWxd,GAAA,GAAQviD,KAAK+/D,aAC5B9nC,EAAI+nC,eAAiBhgE,KAAKggE,eACnB/nC,CACT,EAKA4nC,EAAAz9D,UAAA89D,aAAA,SAAahE,EAAc7kB,G,QACnB6kB,EAAK9pD,MAAMpS,KAAK+/D,cACpB//D,KAAK+/D,YAAY7D,EAAK9pD,IAAM,I,IAE9B,IAAgB,IAAAs9B,EAAAgE,GAAA1zC,KAAK+/D,YAAY7D,EAAK9pD,KAAGwhC,EAAAlE,EAAAzkC,QAAA2oC,EAAA1oC,KAAA0oC,EAAAlE,EAAAzkC,OAAE,GAA/B2oC,EAAAvyC,OAAwCg2C,EAAK,OAAO,C,kGAKhE,OAJAr3C,KAAKggE,gBAAiB,EACtBhgE,KAAKoF,KAAO,KACZpF,KAAK+/D,YAAY7D,EAAK9pD,IAAI1K,KAAK2vC,GAC/Br3C,KAAK+/D,YAAY7D,EAAK9pD,IAAImjC,KAAK,SAAC4qB,EAAIC,GAAO,OAAAD,EAAG/tD,GAAKguD,EAAGhuD,EAAX,IACpC,CACT,EAKAytD,EAAAz9D,UAAAi+D,gBAAA,WACErgE,KAAK+/D,YAAc,CAAC,CACtB,EAKAF,EAAAz9D,UAAAk+D,cAAA,SAAcpE,GACZ,OAAOl8D,KAAK+/D,YAAY7D,EAAK9pD,KAAO,EACtC,EAIAjQ,OAAA2H,eAAI+1D,EAAAz9D,UAAA,MAAG,C,IAAP,WAIE,OAHiB,MAAbpC,KAAKoF,OACPpF,KAAKoF,KAAOpF,KAAKugE,YAEZvgE,KAAKoF,IACd,E,gCAEUy6D,EAAAz9D,UAAAm+D,SAAV,eAAAlqB,EAAA,KACE,OAAIr2C,KAAKwgE,eACPxgE,KAAKyhC,OAAO8T,OACLv1C,KAAKyhC,OACTh9B,IAAI,SAACg8D,GAEJ,OAAOA,EAAS,KADLpqB,EAAK0pB,YAAYU,IAAW,IACdh8D,IAAI,SAAC1D,GAAM,OAAAA,EAAEqR,EAAF,GAAM1D,KAAK,KAAO,GACxD,GACCA,KAAK,OAER1O,KAAKyhC,OAAO8T,OACLv1C,KAAKyhC,OAAO/yB,KAAK,KAE5B,EAEAmxD,EAAAz9D,UAAA8V,IAAA,SAAIuoD,GACF,OAAOzgE,KAAKyhC,OAAO72B,QAAQ61D,IAAW,CACxC,EAEAZ,EAAAz9D,UAAAq1B,OAAA,SAAOwG,GACL,OAAOj+B,KAAKkF,KAAO+4B,EAAQ/4B,GAC7B,EAEA26D,EAAAz9D,UAAAkgC,IAAA,SAAIm+B,GAKF,OAJKzgE,KAAKkY,IAAIuoD,KACZzgE,KAAKyhC,OAAO/5B,KAAK+4D,GACjBzgE,KAAKoF,KAAO,MAEPpF,IACT,EAEAmC,OAAA2H,eAAI+1D,EAAAz9D,UAAA,OAAI,C,IAAR,WACE,OAAOpC,KAAKyhC,OAAO38B,MACrB,E,gCAEA3C,OAAA2H,eAAI+1D,EAAAz9D,UAAA,cAAW,C,IAAf,WACE,OAAOpC,KAAKg+B,WAAWtvB,KAAK,KAC9B,E,gCAEAvM,OAAA2H,eAAI+1D,EAAAz9D,UAAA,gBAAa,C,IAAjB,WACE,OAAOpC,KAAKggE,cACd,E,gCAEA79D,OAAA2H,eAAI+1D,EAAAz9D,UAAA,aAAU,C,IAAd,eAcU25D,EAdV1lB,EAAA,KACE,OAAIr2C,KAAKwgE,gBACDzE,EAAQ/7D,KAAKyhC,OAAOh9B,IAAI,SAACm8B,GAAc,OAAAyV,EAAK4pB,UAAUlE,MAAMlkD,IAAI+oB,EAAzB,IAEvC2U,KAAK,SAACmrB,EAAIC,GAAO,OAAAD,EAAG/nB,UAAUgoB,EAAb,GAEhB5E,EAAMt3D,IAAI,SAACy3D,GAChB,IAAM0E,EAAMvqB,EAAKiqB,cAAcpE,GAC5Bz3D,IAAI,SAAC1D,GAAM,OAAAA,EAAE60C,KAAF,GACXL,KAAK,SAAC4qB,EAAIC,GAAO,OAAAD,EAAGvnB,cAAcwnB,EAAjB,GACjB1xD,KAAK,MACR,OAAOkyD,EAAI97D,OAAS,EAAI,GAAA2J,OAAGytD,EAAK9kB,YAAW,SAAA3oC,OAAQmyD,EAAG,MAAO1E,EAAK9kB,WACpE,MAEM2kB,EAAQ/7D,KAAKyhC,OAAOh9B,IAAI,SAACm8B,GAAc,OAAAyV,EAAK4pB,UAAUlE,MAAMlkD,IAAI+oB,EAAzB,IAEvC2U,KAAK,SAACmrB,EAAIC,GAAO,OAAAD,EAAG/nB,UAAUgoB,EAAb,GAChB5E,EAAMt3D,IAAI,SAAC5D,GAAM,OAAAA,EAAEu2C,WAAF,GAE5B,E,gCACFyoB,CAAA,CAzHA,GA2HAgB,GAAA,WAoBE,SAAAA,EAA4B3rB,GAAA,KAAAA,QAAAA,EAL5B,KAAA4rB,SAAsC,CAAC,EAMrC9gE,KAAK+7D,MAAQ,IAAIvnB,EACjBx0C,KAAK+gE,SAAW,IAAIvsB,CACtB,CA6HF,OA3HYqsB,EAAAz+D,UAAA4+D,UAAV,WAIE,OAFAn7B,EAA0B,MADN7lC,KAAKk1C,QAAQkD,YACD,4BAChCvS,EAAkD,OAAtC7lC,KAAKk1C,QAAQ2pB,cAAgB,MAAe,4BACjD7+D,KAAK+7D,MAAMhnB,OAAO,IAAI2qB,GAAO1/D,KAAKk1C,QAAQ2pB,cACnD,EAEAgC,EAAAz+D,UAAA6+D,MAAA,WACEjhE,KAAKk1C,QAAQkB,UACbp2C,KAAK8gE,SAAW,CAAC,EACjB9gE,KAAK+7D,MAAM1pD,QACXrS,KAAK+gE,SAAS1uD,QACdrS,KAAKkhE,UACP,EAEAL,EAAAz+D,UAAAg0C,QAAA,WAIE,OAHAp2C,KAAKihE,QACLjhE,KAAKk1C,QAAQkB,UACbp2C,KAAKmhE,eACEnhE,IACT,EAKU6gE,EAAAz+D,UAAA++D,aAAV,WAEE,I,QADMlpC,EAAMj4B,KAAK+gE,SACRlgE,EAAI,EAAGA,EAAIo3B,EAAIhR,KAAMpmB,IAAK,CACjC,IAAMugE,EAAUnpC,EAAIpgB,IAAIhX,G,IAGxB,IAAkB,IAAA6uC,GAAA8D,OAAA,EAAAE,GAAA1zC,KAAKk1C,QAAQmsB,aAAUztB,EAAAlE,EAAAzkC,QAAA2oC,EAAA1oC,KAAA0oC,EAAAlE,EAAAzkC,OAAE,CAAtC,IAAMosC,EAAGzD,EAAAvyC,MACZ,GAAIg2C,GAAOr3C,KAAKk1C,QAAQoF,KAAM,CAC5B,IAAMgnB,EAAUthE,KAAK09D,KAAK0D,EAAS/pB,GAC/BiqB,EAAQr6C,KAAO,GACjBjnB,KAAKuhE,QAAQH,EAAS/pB,EAAKiqB,E,qGAKrC,EAMAT,EAAAz+D,UAAAs7D,KAAA,SAAK8D,EAAoBnqB,G,QACjBpf,EAAMj4B,KAAKyhE,a,IACjB,IAAqB,IAAA/xB,EAAAgE,GAAA8tB,EAAQ//B,QAAMmS,EAAAlE,EAAAzkC,QAAA2oC,EAAA1oC,KAAA0oC,EAAAlE,EAAAzkC,OAAE,CAAhC,IAAMw1D,EAAM7sB,EAAAvyC,MACT66D,EAAOl8D,KAAK+7D,MAAMlkD,IAAI4oD,GAEtB/pB,EAAOwlB,EAAKxlB,KACdwlB,EAAK1xD,SAAWksC,EAAKE,IAAI9xC,QACvB4xC,EAAKE,IAAIG,KAAKmlB,EAAK1xD,WAAa6sC,GAElCr3C,KAAK0hE,kBAAkBxF,EAAMsF,EAASvpC,E,mGAK5C,OAAOj4B,KAAK2hE,QAAQ1pC,EACtB,EAEU4oC,EAAAz+D,UAAAs/D,kBAAV,SAA4BE,EAAuBC,EAAwBC,G,QACnEC,EAAU/hE,KAAK+7D,MAAMhnB,OAAO6sB,EAAc5W,WAChD8W,EAAUx/B,IAAIy/B,EAAQ3vD,I,IAEtB,IAAoB,IAAAs9B,EAAAgE,GAAAmuB,EAAYvB,cAAcsB,IAAchuB,EAAAlE,EAAAzkC,QAAA2oC,EAAA1oC,KAAA0oC,EAAAlE,EAAAzkC,OAAE,CAAzD,IAAM+2D,EAAKpuB,EAAAvyC,MACdygE,EAAU5B,aAAa6B,EAASC,E,mGAEpC,EAEUnB,EAAAz+D,UAAAq/D,WAAV,W,IAAqB,IAAA1F,EAAA,GAAAjjB,EAAA,EAAAA,EAAA72C,UAAA6C,OAAAg0C,IAAAijB,EAAAjjB,GAAA72C,UAAA62C,GACnB,OAAO,IAAI+mB,GAASh+D,KAAAG,MAAT69D,GAAStsB,GAAC,MAAD,EAACvzC,MAAIqzC,GAAK0oB,EAAMt3D,IAAI,SAACy3D,GAAS,OAAAA,EAAK9pD,EAAL,KAAQ,IAC5D,EAEAjQ,OAAA2H,eAAI+2D,EAAAz+D,UAAA,OAAI,C,IAAR,WACE,OAAOpC,KAAK+gE,SAAS95C,IACvB,E,gCAEU45C,EAAAz+D,UAAA6/D,cAAV,SAAwBC,GAItB,OAHMA,EAAQ9vD,MAAMpS,KAAK8gE,WACvB9gE,KAAK8gE,SAASoB,EAAQ9vD,IAAM,CAAC,GAExBpS,KAAK8gE,SAASoB,EAAQ9vD,GAC/B,EAEAyuD,EAAAz+D,UAAAm/D,QAAA,SAAQW,EAAoB7qB,EAAU8qB,GACpBniE,KAAKiiE,cAAcC,GAC3B7qB,EAAIjlC,IAAM+vD,CACpB,EAEAtB,EAAAz+D,UAAAggE,QAAA,SAAQF,EAAoB7qB,GAC1B,OAAQr3C,KAAK8gE,SAASoB,EAAQ9vD,KAAO,CAAC,GAAGilC,EAAIjlC,KAAO,IACtD,EAEAyuD,EAAAz+D,UAAAigE,YAAA,SAAYb,EAAoB5xD,GAC9B,IAAM0xD,EAAUthE,KAAK8gE,SAASU,EAAQpvD,KAAO,CAAC,EAC9C,IAAK,IAAMkwD,KAAShB,EAGlB,GAA0B,GAAtB1xD,EAFQ5P,KAAKk1C,QAAQQ,WAAW4sB,GACvBhB,EAAQgB,IACY,KAErC,EAEAzB,EAAAz+D,UAAAmgE,WAAA,SAAWf,GACT,OAAOxhE,KAAK8gE,SAASU,EAAQpvD,KAAO,CAAC,CACvC,EAEAjQ,OAAA2H,eAAI+2D,EAAAz+D,UAAA,aAAU,C,IAAd,eAAAi0C,EAAA,KACQpe,EAAM,CAAC,EAWb,OAVAj4B,KAAK+gE,SAAS7sD,QAAQxP,QAAQ,SAAC89D,GAC7BvqC,EAAIuqC,EAAKpwD,IAAM,CAAE2pD,MAAO,GAAI2B,KAAM,CAAC,GACnCzlC,EAAIuqC,EAAKpwD,IAAW,MAAIowD,EAAKxkC,WAC7B,IAAMV,EAAI+Y,EAAKyqB,SAAS0B,EAAKpwD,IAC7B,IAAK,IAAMkwD,KAAShlC,EAAG,CACrB,IAAM+Z,EAAMhB,EAAKnB,QAAQQ,WAAW4sB,GACpCrqC,EAAIuqC,EAAKpwD,IAAU,KAAI6lB,EAAIuqC,EAAKpwD,IAAU,MAAK,CAAC,EAChD6lB,EAAIuqC,EAAKpwD,IAAU,KAAEilC,EAAIzB,OAAStY,EAAEglC,GAAOlwD,E,CAE/C,GACO6lB,CACT,E,gCACF4oC,CAAA,CApJA,GAsJA4B,GAAA,SAAA/qB,GAAA,SAAA+qB,I,8CAsCA,QAtCkC7qB,GAAA6qB,EAAA/qB,GAQhC+qB,EAAArgE,UAAA8+D,SAAA,WACE,IAAMF,EAAYhhE,KAAKghE,YACjB0B,EAAS1iE,KAAKyhE,WAAWT,GAC/B,OAAOhhE,KAAK2hE,QAAQe,EACtB,EAMAD,EAAArgE,UAAAu/D,QAAA,SAAQH,GAEN,I,QADMvpC,EAAM,IAAI4nC,GAASh+D,KAAAG,MAAT69D,GAAStsB,GAAC,MAAD,EAACvzC,MAAIqzC,GAAKmuB,EAAQ//B,SAAM,KACxC5gC,EAAI,EAAGA,EAAIo3B,EAAIwJ,OAAO38B,OAAQjE,IAAK,CAC1C,IAAM4/D,EAASxoC,EAAIwJ,OAAO5gC,GACpBq7D,EAAOl8D,KAAK+7D,MAAMlkD,IAAI4oD,GACtB/pB,EAAOwlB,EAAKxlB,KAGlB,GAAIwlB,EAAK1xD,SAAWksC,EAAKE,IAAI9xC,OAAQ,CACnC,IAAMuyC,EAAMX,EAAKE,IAAIG,KAAKmlB,EAAK1xD,UAC/B,IAAK6sC,EAAInB,W,IACP,IAAmB,IAAAxG,GAAAizB,OAAA,EAAAjvB,GAAA1zC,KAAKk1C,QAAQuB,WAAWY,KAAIzD,EAAAlE,EAAAzkC,QAAA2oC,EAAA1oC,KAAA0oC,EAAAlE,EAAAzkC,OAAE,CAA5C,IAAM23D,EAAIhvB,EAAAvyC,MACP0gE,EAAU/hE,KAAK+7D,MAAMhnB,OAAO,IAAI2qB,GAAOkD,EAAM,IACnD3qC,EAAIqK,IAAIy/B,EAAQ3vD,G,qGAKxB,OAAmB,GAAZ6lB,EAAIhR,KAAYgR,EAAMj4B,KAAK+gE,SAAShsB,OAAO9c,EACpD,EACFwqC,CAAA,CAtCA,CAAkC5B,IAwClCgC,GAAA,SAAAnrB,GAAA,SAAAmrB,I,8CA+CA,QA/CkCjrB,GAAAirB,EAAAnrB,GAMhCmrB,EAAAzgE,UAAA8+D,SAAA,WACE,IAAMF,EAAYhhE,KAAKghE,YACjB0B,EAAS1iE,KAAKyhE,WAAWT,GAE/B,OADA0B,EAAOxC,aAAac,EAAWhhE,KAAKk1C,QAAQmD,KACrCr4C,KAAK2hE,QAAQe,EACtB,EAMAG,EAAAzgE,UAAAu/D,QAAA,SAAQH,GAEN,IAFF,IAAAnrB,EAAA,KACQpe,EAAMupC,EAAQ3uC,O,WACXhyB,G,QACD4/D,EAASxoC,EAAIwJ,OAAO5gC,GACpBq7D,EAAO4G,EAAK/G,MAAMlkD,IAAI4oD,GAG5B,GAAIvE,EAAK1xD,UAAY0xD,EAAKxlB,KAAKE,IAAI9xC,O,iBACnC,IAAM8xC,EAAMslB,EAAKxlB,KAAKE,IAChBmsB,EAAInsB,EAAIG,KAAKmlB,EAAK1xD,UACxB,GAAIu4D,EAAE7sB,W,qBAEN,IAAwB,IAAAxG,GAAAszB,OAAA,EAAAtvB,GAAAzb,EAAIqoC,cAAcpE,KAAKtoB,EAAAlE,EAAAzkC,QAAA2oC,EAAA1oC,KAAA0oC,EAAAlE,EAAAzkC,OAAE,CAA5C,IAAMg4D,EAASrvB,EAAAvyC,MACZ6hE,EAAStsB,EAAI/jB,OAAOzqB,OAAO66D,GACjCH,EAAK5tB,QAAQiD,UAAUN,cAAcqrB,EAAQhH,EAAK1xD,SAAW,EAAG,SAACyrC,G,QAC/D,GAAY,MAARA,EAAc,CAGhB,IAAMktB,EAAS9sB,EAAKnB,QAAQuB,WAAWssB,G,IACvC,IAAiB,IAAAK,GAAAC,OAAA,EAAA3vB,GAAAyvB,IAAMG,EAAAF,EAAAn4D,QAAAq4D,EAAAp4D,KAAAo4D,EAAAF,EAAAn4D,OAAE,CAApB,IAAMs4D,EAAED,EAAAjiE,MACL0gE,EAAU1rB,EAAK0lB,MAAMhnB,OAAO,IAAI2qB,GAAO6D,EAAI,IACjDtrC,EAAIqK,IAAIy/B,EAAQ3vD,IAChB6lB,EAAIioC,aAAa6B,EAAS9rB,E,oGAGhC,E,4GAvBKp1C,EAAI,EAAGA,EAAIo3B,EAAIwJ,OAAO38B,OAAQjE,I,EAA9BA,GA0BT,OAAmB,GAAZo3B,EAAIhR,KAAYgR,EAAMj4B,KAAK+gE,SAAShsB,OAAO9c,EACpD,EACF4qC,CAAA,CA/CA,CAAkChC,I,wkBC/W5B,SAAU2C,GAAelmC,EAAYp6B,GACzC,YADyC,IAAAA,IAAAA,EAAA,OACjCA,GACN,IAAK,MACH,MA2DG,CADYugE,GADb3D,EAAK,IAAI+C,GADgB3tB,EAxDH5X,GAyDS8Y,UACOlB,GACxB4qB,GA1DlB,IAAK,OACH,OAgEA,SAA6B5qB,GAE3B,IAAAhJ,EAAAmH,GAAmBqwB,GAAkBxuB,GAAQ,GAA5CknB,EAAUlwB,EAAA,GAAE4zB,EAAE5zB,EAAA,GAErB,IAAKkwB,EAAWuH,aACd,MAAO,CAACvH,EAAY0D,GAQtB,IAAM8D,EAgLF,SAAkC9D,EAAkBxiC,GACxD,IAAMsmC,EAAK,IAAI9pB,GAEf,SAAS+pB,EAAYC,EAAYzsB,GAC/B,IAAM0sB,EAAc,IAAAt1D,OAAIq1D,EAAE,KAAAr1D,OAAI4oC,EAAIzB,MAAK,KACjCouB,EAASJ,EAAGjoB,UAAU,IAAIrD,GAAIsrB,EAAIG,EAAa1sB,EAAInB,aAAa,GAItE,OAHU,GAAN4tB,GAAWxmC,EAAE8a,aAAef,GAAO/Z,EAAE8a,aAAe4rB,GAAW3sB,EAAInB,aACrE0tB,EAAGxrB,YAAc4rB,GAEZA,CACT,CAGA,IAAK,IAAMC,KAAcnE,EAAGgB,SAAU,CAEpC,IAAMoD,EAAqCpE,EAAGgB,SAASmD,GACvD,IAAK,IAAM3F,KAAS4F,EAAa,CAC/B,IAAM7sB,EAAM/Z,EAAEoY,WAAW4oB,GACzBuF,EAAYI,EAA6B5sB,E,EAI7C,SAAS8sB,EAAcjD,EAAkBkD,EAAQ1tB,GAG/C,IAAIotB,EAAK5C,EACHmD,EAAU3tB,EAAKE,IAAIG,KAAKtyC,IAAI,SAAC6/D,EAAI9zD,GACrC,IAAMmsD,EAAUkH,EAAYC,EAAIQ,GAE1BC,EADqCzE,EAAGgB,SAASgD,GAC3BQ,EAAGlyD,KAAO,KAGtC,OAFAyzB,EAAsB,MAAX0+B,EAAiB,uCAC5BT,EAAKS,EAAQnyD,GACNuqD,CACT,GACA,OAAO,IAAI9jB,GAAGh3C,KAAAG,MAAH62C,G,+LAAGtF,CAAC,MAAD,GAAAF,GAAIgxB,IAAO,IAC3B,CAEA,IAAK,IAAMJ,KAAcnE,EAAGgB,SAAU,CAK9BoD,EAAqCpE,EAAGgB,SAASmD,GAAvD,I,WACW3F,GACT,IAAMkG,EAAWlnC,EAAEoY,WAAW4oB,GACxBnyD,EAAK83D,EACX,IAAKO,EAAStuB,WAAY,CACxB,IAAMuuB,EAAOZ,EAAY13D,EAAIq4D,GAC7BlnC,EAAE0a,YAAYwsB,EAAU,SAAC9tB,EAAMlmC,GAC7B,IAAMk0D,EAASP,EAAch4D,EAAIq4D,EAAU9tB,GACrCiuB,EAAU,IAAI/qB,GAAK6qB,EAAMC,GAC/Bd,EAAG9oB,QAAQ6pB,EACb,E,GATJ,IAAK,IAAMrG,KAAS4F,E,EAAT5F,E,CAcb,OAAOsF,CACT,CA1OagB,CAAwB9E,EAAI5qB,GAGjC2vB,EAAgD,CAAC,EAEvD,IAAK,IAAMZ,KAAcnE,EAAGgB,SAC1B,IAAK,IAAMxC,KAASwB,EAAGgB,SAASmD,GAAa,CAC3C,IAAMM,EAAUzE,EAAGgB,SAASmD,GAAY3F,GAClCiG,EAAQnyD,MAAMyyD,IAClBA,EAASN,EAAQnyD,IAAM,CAAC,GAEpBksD,KAASuG,EAASN,EAAQnyD,MAC9ByyD,EAASN,EAAQnyD,IAAIksD,GAAS,IAAIlpB,KAEpCyvB,EAASN,EAAQnyD,IAAIksD,GAAOh8B,IAAI2hC,E,CAOpC,IAAK,IAAMA,KAAc7H,EAAW2B,gBAAiB,CAInD,IAAMyD,EAAU1B,EAAGiB,SAASlpD,IAAIosD,GAChCa,GAAsB5vB,EAAS0uB,EAAI9D,EAAI0B,EAASqD,E,CAKlD,MAAO,CAACpB,GAAqB3D,EAAI5qB,GAAU4qB,EAC7C,CA7GaiF,CAAmBznC,GAsD1B,IAA2B4X,EACzB4qB,EArDN,OAAO4D,GAAkBpmC,EAC3B,CAKM,SAAUomC,GAAkBxuB,GAChC,IAAM4qB,EAIF,SAA2B5qB,G,QACzB4qB,EAAK,IAAI2C,GAAavtB,GAASkB,U,IACrC,IAAsB,IAAA1G,EAAAgE,GAAAosB,EAAGiB,SAAS7sD,SAAO0/B,EAAAlE,EAAAzkC,QAAA2oC,EAAA1oC,KAAA0oC,EAAAlE,EAAAzkC,OACvC+5D,GAAqB9vB,EAAS4qB,EADdlsB,EAAAvyC,M,kGAGlB,OAAOy+D,CACT,CAVamF,CAAiB/vB,GAC5B,MAAO,CAACuuB,GAAqB3D,EAAI5qB,GAAU4qB,EAC7C,CAsBM,SAAUkF,GAAqB9vB,EAAkB4qB,EAAiB0B,G,mBAE3Df,GACT,IAAMvE,EAAO4D,EAAG/D,MAAMlkD,IAAI4oD,GACpB/pB,EAAOwlB,EAAKxlB,KACdwlB,EAAK1xD,UAAYksC,EAAKE,IAAI9xC,QAG5BowC,EAAQuF,WAAWvD,YAAYR,EAAKF,GAAI,SAACP,GAC3B,MAARA,IACFpQ,EAAWoQ,EAAKC,YAChBsrB,EAAQtB,aAAahE,EAAMjmB,GAE/B,E,MAXJ,IAAqB,IAAAvG,EAAAgE,GAAA8tB,EAAQ//B,QAAMmS,EAAAlE,EAAAzkC,QAAA2oC,EAAA1oC,KAAA0oC,EAAAlE,EAAAzkC,O,EAAlB2oC,EAAAvyC,M,kGAcnB,CAkEM,SAAUoiE,GAAqB3D,EAAiB5qB,G,QAC9CknB,EAAa,IAAIhB,GAAWlmB,G,WACvBssB,G,gBAET,IAAqB,IAAAtjB,GAAA2d,OAAA,EAAAnoB,GAAA8tB,EAAQ//B,SAAMkd,EAAAT,EAAAjzC,QAAA0zC,EAAAzzC,KAAAyzC,EAAAT,EAAAjzC,OAAE,CAAhC,IAAMw1D,EAAM9hB,EAAAt9C,MACT66D,EAAO4D,EAAG/D,MAAMlkD,IAAI4oD,GACpB/pB,EAAOwlB,EAAKxlB,KAClB,GAAIwlB,EAAK1xD,SAAWksC,EAAKE,IAAI9xC,OAAQ,CAEnC,IAAMuyC,EAAMX,EAAKE,IAAIG,KAAKmlB,EAAK1xD,UAC/B,GAAI6sC,EAAInB,WAAY,CAClB,IAAMquB,EAAUzE,EAAGsC,QAAQZ,EAASnqB,GAChCktB,GACFnI,EAAW+B,UAAUqD,EAAQpvD,GAAIilC,EAAK+lB,GAASK,MAAM8G,EAAQnyD,I,OAG5D,IAAKskC,EAAKF,GAAG/e,OAAOyd,EAAQ2pB,aAAaroB,IAAK,CAInD,IAAM0uB,EAAa1D,EAAQlB,cAAcpE,G,IACzC,IAAwB,IAAAiJ,GAAAxC,OAAA,EAAAjvB,GAAAwxB,IAAUE,EAAAD,EAAAl6D,QAAAm6D,EAAAl6D,KAAAk6D,EAAAD,EAAAl6D,OAAE,CAA/B,IAAMg4D,EAASmC,EAAA/jE,MAClB+6D,EAAW+B,UAAUqD,EAAQpvD,GAAI6wD,EAAW7F,GAASO,OAAOjnB,G,uMAMlEopB,EAAGuC,YAAYb,EAAS,SAACnqB,EAAKpsC,GACjB,MAAPosC,GAAgBA,EAAInB,YACtBkmB,EAAW+B,UAAUqD,EAAQpvD,GAAIilC,EAAK+lB,GAASQ,KAAK3yD,EAAKmH,IAE7D,GAIA,IAAMizD,EAAUvF,EAAG/D,MAAMhnB,OAAO,IAAI2qB,GAAOxqB,EAAQ2pB,aAAc,IACjE2C,EAAQtB,aAAamF,EAASnwB,EAAQmD,KAClCmpB,EAAQtpD,IAAImtD,EAAQjzD,KACtBgqD,EAAW+B,UAAUqD,EAAQpvD,GAAI8iC,EAAQmD,IAAK+kB,GAASU,S,MArC3D,IAAsB,IAAApuB,EAAAgE,GAAAosB,EAAGiB,SAAS7sD,SAAO0/B,EAAAlE,EAAAzkC,QAAA2oC,EAAA1oC,KAAA0oC,EAAAlE,EAAAzkC,O,EAAvB2oC,EAAAvyC,M,kGAwClB,OAAO+6D,CACT,CAwBM,SAAU0I,GACd5vB,EACAowB,EACAxF,EACA0B,EACAqD,G,QAGA,SAASU,EAAM7uB,EAAY71C,EAAWwmD,EAAmBwC,GACvD,GAAIhpD,EAAI,EAINglC,EAAgD,OADLi6B,EAAGgB,SAASzZ,GAC/B3Q,EAAKF,GAAGpkC,KAAO,MAAe,kDACtDy3C,EAAOvnB,IAAI+kB,OACN,CACL,IAAMhQ,EAAMX,EAAKE,IAAIG,KAAKl2C,GACpB2kE,EAAaX,EAASxd,GAAWhQ,EAAIjlC,KAAO,KAClDyzB,EAAyB,MAAd2/B,EAAoB,+BAC/BA,EAAW9gE,QAAQ,SAAC+gE,GAAc,OAAAF,EAAM7uB,EAAM71C,EAAI,EAAG4kE,EAAW5b,EAA9B,E,CAEtC,CAEA2X,EAAQnB,kB,eAEGI,GACT,IAAMvE,EAAO4D,EAAG/D,MAAMlkD,IAAI4oD,GACpB/pB,EAAOwlB,EAAKxlB,KAClB,GAAIwlB,EAAK1xD,UAAYksC,EAAKE,IAAI9xC,OAAQ,CAMpC,IAAM4gE,EAAO,IAAItwB,IACjBmwB,EAAM7uB,EAAMA,EAAKE,IAAI9xC,OAAS,EAAG08D,EAAQpvD,GAAIszD,GAC7CA,EAAKhhE,QAAQ,SAACmiC,GAEZ,IAAM8+B,EAAU,IAAAl3D,OAAIo4B,EAAC,KAAAp4B,OAAIioC,EAAKF,GAAGZ,MAAK,KAChCgwB,EAAKN,EAAWhqB,OAAOqqB,GAC7B9/B,EAAiB,MAAN+/B,EAAY,4CACvBN,EAAW7qB,WAAWvD,YAAY0uB,EAAI,SAAC3vB,GACrC,GAAY,MAARA,GAAgBA,GAAQqvB,EAAWjtB,IAAK,CAC1CxS,EAAWoQ,EAAKC,YAGhB,IAAMN,EAAQK,EAAKL,MAAMn+B,UAAUw+B,EAAKL,MAAMhrC,QAAQ,KAAO,EAAGqrC,EAAKL,MAAM9wC,OAAS,GAAGwE,OACjF4yC,EAAIhH,EAAQoG,OAAO1F,GACzB/P,EAAgB,MAALqW,EAAW,MAAAztC,OAAMmnC,EAAK,8BACjC4rB,EAAQtB,aAAahE,EAAMhgB,E,CAE/B,EACF,E,OA3BJ,IAAqB,IAAAxM,EAAAgE,GAAA8tB,EAAQ//B,QAAMmS,EAAAlE,EAAAzkC,QAAA2oC,EAAA1oC,KAAA0oC,EAAAlE,EAAAzkC,O,EAAlB2oC,EAAAvyC,M,kGA8BnB,C,+RCxPA,MAAMwkE,GAAQrjE,OAAOsjE,IAAI,cACnBC,GAAMvjE,OAAOsjE,IAAI,iBACjBE,GAAMxjE,OAAOsjE,IAAI,YACjBG,GAAOzjE,OAAOsjE,IAAI,aAClBI,GAAS1jE,OAAOsjE,IAAI,eACpBK,GAAM3jE,OAAOsjE,IAAI,YACjBM,GAAY5jE,OAAOsjE,IAAI,kBACvBO,GAAWrzB,KAAWA,GAAwB,iBAATA,GAAqBA,EAAKozB,MAAeP,GAC9ES,GAActzB,KAAWA,GAAwB,iBAATA,GAAqBA,EAAKozB,MAAeL,GACjFQ,GAASvzB,KAAWA,GAAwB,iBAATA,GAAqBA,EAAKozB,MAAeJ,GAC5EQ,GAAUxzB,KAAWA,GAAwB,iBAATA,GAAqBA,EAAKozB,MAAeH,GAC7EQ,GAAYzzB,KAAWA,GAAwB,iBAATA,GAAqBA,EAAKozB,MAAeF,GAC/EQ,GAAS1zB,KAAWA,GAAwB,iBAATA,GAAqBA,EAAKozB,MAAeD,GAClF,SAASQ,GAAa3zB,GAClB,GAAIA,GAAwB,iBAATA,EACf,OAAQA,EAAKozB,KACT,KAAKJ,GACL,KAAKG,GACD,OAAO,EAEnB,OAAO,CACX,CACA,SAASpxD,GAAOi+B,GACZ,GAAIA,GAAwB,iBAATA,EACf,OAAQA,EAAKozB,KACT,KAAKP,GACL,KAAKG,GACL,KAAKE,GACL,KAAKC,GACD,OAAO,EAEnB,OAAO,CACX,CACA,MAAMS,GAAa5zB,IAAUyzB,GAASzzB,IAAS2zB,GAAa3zB,OAAYA,EAAK6zB,OC/BvEC,GAAQtkE,OAAO,eACfukE,GAAOvkE,OAAO,iBACdwkE,GAASxkE,OAAO,eA+BtB,SAASsK,GAAMkmC,EAAMpjC,GACjB,MAAMq3D,EAAWC,GAAYt3D,GACzB02D,GAAWtzB,GACAm0B,GAAO,KAAMn0B,EAAKo0B,SAAUH,EAAU9kE,OAAOklE,OAAO,CAACr0B,OACrDg0B,KACPh0B,EAAKo0B,SAAW,MAGpBD,GAAO,KAAMn0B,EAAMi0B,EAAU9kE,OAAOklE,OAAO,IACnD,CAUA,SAASF,GAAOjiE,EAAK8tC,EAAMpjC,EAASrB,GAChC,MAAM+4D,EAAOC,GAAYriE,EAAK8tC,EAAMpjC,EAASrB,GAC7C,GAAIwG,GAAOuyD,IAASd,GAAOc,GAEvB,OADAE,GAAYtiE,EAAKqJ,EAAM+4D,GAChBH,GAAOjiE,EAAKoiE,EAAM13D,EAASrB,GAEtC,GAAoB,iBAAT+4D,EACP,GAAIX,GAAa3zB,GAAO,CACpBzkC,EAAOpM,OAAOklE,OAAO94D,EAAKE,OAAOukC,IACjC,IAAK,IAAInyC,EAAI,EAAGA,EAAImyC,EAAK+oB,MAAMj3D,SAAUjE,EAAG,CACxC,MAAM4mE,EAAKN,GAAOtmE,EAAGmyC,EAAK+oB,MAAMl7D,GAAI+O,EAASrB,GAC7C,GAAkB,iBAAPk5D,EACP5mE,EAAI4mE,EAAK,MACR,IAAIA,IAAOX,GACZ,OAAOA,GACFW,IAAOT,KACZh0B,EAAK+oB,MAAMhwC,OAAOlrB,EAAG,GACrBA,GAAK,EACT,CACJ,CACJ,MACK,GAAI2lE,GAAOxzB,GAAO,CACnBzkC,EAAOpM,OAAOklE,OAAO94D,EAAKE,OAAOukC,IACjC,MAAM00B,EAAKP,GAAO,MAAOn0B,EAAK9tC,IAAK0K,EAASrB,GAC5C,GAAIm5D,IAAOZ,GACP,OAAOA,GACFY,IAAOV,KACZh0B,EAAK9tC,IAAM,MACf,MAAMyiE,EAAKR,GAAO,QAASn0B,EAAK3xC,MAAOuO,EAASrB,GAChD,GAAIo5D,IAAOb,GACP,OAAOA,GACFa,IAAOX,KACZh0B,EAAK3xC,MAAQ,KACrB,CAEJ,OAAOimE,CACX,CAgCAhjD,eAAesjD,GAAW50B,EAAMpjC,GAC5B,MAAMq3D,EAAWC,GAAYt3D,GACzB02D,GAAWtzB,SACM60B,GAAY,KAAM70B,EAAKo0B,SAAUH,EAAU9kE,OAAOklE,OAAO,CAACr0B,OAChEg0B,KACPh0B,EAAKo0B,SAAW,YAGdS,GAAY,KAAM70B,EAAMi0B,EAAU9kE,OAAOklE,OAAO,IAC9D,CAUA/iD,eAAeujD,GAAY3iE,EAAK8tC,EAAMpjC,EAASrB,GAC3C,MAAM+4D,QAAaC,GAAYriE,EAAK8tC,EAAMpjC,EAASrB,GACnD,GAAIwG,GAAOuyD,IAASd,GAAOc,GAEvB,OADAE,GAAYtiE,EAAKqJ,EAAM+4D,GAChBO,GAAY3iE,EAAKoiE,EAAM13D,EAASrB,GAE3C,GAAoB,iBAAT+4D,EACP,GAAIX,GAAa3zB,GAAO,CACpBzkC,EAAOpM,OAAOklE,OAAO94D,EAAKE,OAAOukC,IACjC,IAAK,IAAInyC,EAAI,EAAGA,EAAImyC,EAAK+oB,MAAMj3D,SAAUjE,EAAG,CACxC,MAAM4mE,QAAWI,GAAYhnE,EAAGmyC,EAAK+oB,MAAMl7D,GAAI+O,EAASrB,GACxD,GAAkB,iBAAPk5D,EACP5mE,EAAI4mE,EAAK,MACR,IAAIA,IAAOX,GACZ,OAAOA,GACFW,IAAOT,KACZh0B,EAAK+oB,MAAMhwC,OAAOlrB,EAAG,GACrBA,GAAK,EACT,CACJ,CACJ,MACK,GAAI2lE,GAAOxzB,GAAO,CACnBzkC,EAAOpM,OAAOklE,OAAO94D,EAAKE,OAAOukC,IACjC,MAAM00B,QAAWG,GAAY,MAAO70B,EAAK9tC,IAAK0K,EAASrB,GACvD,GAAIm5D,IAAOZ,GACP,OAAOA,GACFY,IAAOV,KACZh0B,EAAK9tC,IAAM,MACf,MAAMyiE,QAAWE,GAAY,QAAS70B,EAAK3xC,MAAOuO,EAASrB,GAC3D,GAAIo5D,IAAOb,GACP,OAAOA,GACFa,IAAOX,KACZh0B,EAAK3xC,MAAQ,KACrB,CAEJ,OAAOimE,CACX,CACA,SAASJ,GAAYt3D,GACjB,MAAuB,iBAAZA,IACNA,EAAQk4D,YAAcl4D,EAAQm4D,MAAQn4D,EAAQo4D,OACxC7lE,OAAO4H,OAAO,CACjBk+D,MAAOr4D,EAAQm4D,KACflgD,IAAKjY,EAAQm4D,KACbG,OAAQt4D,EAAQm4D,KAChBI,IAAKv4D,EAAQm4D,MACdn4D,EAAQo4D,OAAS,CAChBngD,IAAKjY,EAAQo4D,MACbE,OAAQt4D,EAAQo4D,MAChBG,IAAKv4D,EAAQo4D,OACdp4D,EAAQk4D,YAAc,CACrBjgD,IAAKjY,EAAQk4D,WACbK,IAAKv4D,EAAQk4D,YACdl4D,GAEAA,CACX,CACA,SAAS23D,GAAYriE,EAAK8tC,EAAMpjC,EAASrB,GACrC,MAAuB,mBAAZqB,EACAA,EAAQ1K,EAAK8tC,EAAMzkC,GAC1Bg4D,GAAMvzB,GACCpjC,EAAQiY,MAAM3iB,EAAK8tC,EAAMzkC,GAChCm4D,GAAM1zB,GACCpjC,EAAQu4D,MAAMjjE,EAAK8tC,EAAMzkC,GAChCi4D,GAAOxzB,GACApjC,EAAQw4D,OAAOljE,EAAK8tC,EAAMzkC,GACjCk4D,GAASzzB,GACFpjC,EAAQs4D,SAAShjE,EAAK8tC,EAAMzkC,GACnC83D,GAAQrzB,GACDpjC,EAAQq4D,QAAQ/iE,EAAK8tC,EAAMzkC,QADtC,CAGJ,CACA,SAASi5D,GAAYtiE,EAAKqJ,EAAMykC,GAC5B,MAAMlV,EAASvvB,EAAKA,EAAKzJ,OAAS,GAClC,GAAI6hE,GAAa7oC,GACbA,EAAOi+B,MAAM72D,GAAO8tC,OAEnB,GAAIwzB,GAAO1oC,GACA,QAAR54B,EACA44B,EAAO54B,IAAM8tC,EAEblV,EAAOz8B,MAAQ2xC,MAElB,KAAIszB,GAAWxoC,GAGf,CACD,MAAMuqC,EAAKhC,GAAQvoC,GAAU,QAAU,SACvC,MAAM,IAAIjyB,MAAM,4BAA4Bw8D,WAChD,CALIvqC,EAAOspC,SAAWp0B,CAKtB,CACJ,CArLAlmC,GAAMg6D,MAAQA,GAEdh6D,GAAMi6D,KAAOA,GAEbj6D,GAAMk6D,OAASA,GAmFfY,GAAWd,MAAQA,GAEnBc,GAAWb,KAAOA,GAElBa,GAAWZ,OAASA,GCzIpB,MAAMsB,GAAc,CAChB,IAAK,MACL,IAAK,MACL,IAAK,MACL,IAAK,MACL,IAAK,MACL,IAAK,OAEHC,GAAiBC,GAAOA,EAAGj/D,QAAQ,aAAcw5C,GAAMulB,GAAYvlB,IACzE,MAAM0lB,GACFhlE,WAAAA,CAAYilE,EAAMC,GAKd3oE,KAAK4oE,SAAW,KAEhB5oE,KAAK6oE,QAAS,EACd7oE,KAAK0oE,KAAOvmE,OAAO4H,OAAO,CAAC,EAAG0+D,GAAWK,YAAaJ,GACtD1oE,KAAK2oE,KAAOxmE,OAAO4H,OAAO,CAAC,EAAG0+D,GAAWM,YAAaJ,EAC1D,CACAxqC,KAAAA,GACI,MAAMtL,EAAO,IAAI41C,GAAWzoE,KAAK0oE,KAAM1oE,KAAK2oE,MAE5C,OADA91C,EAAK+1C,SAAW5oE,KAAK4oE,SACd/1C,CACX,CAKAm2C,UAAAA,GACI,MAAMviD,EAAM,IAAIgiD,GAAWzoE,KAAK0oE,KAAM1oE,KAAK2oE,MAC3C,OAAQ3oE,KAAK0oE,KAAKx/C,SACd,IAAK,MACDlpB,KAAKipE,gBAAiB,EACtB,MACJ,IAAK,MACDjpE,KAAKipE,gBAAiB,EACtBjpE,KAAK0oE,KAAO,CACRQ,SAAUT,GAAWK,YAAYI,SACjChgD,QAAS,OAEblpB,KAAK2oE,KAAOxmE,OAAO4H,OAAO,CAAC,EAAG0+D,GAAWM,aAGjD,OAAOtiD,CACX,CAKA6b,GAAAA,CAAI9qB,EAAMu8C,GACF/zD,KAAKipE,iBACLjpE,KAAK0oE,KAAO,CAAEQ,SAAUT,GAAWK,YAAYI,SAAUhgD,QAAS,OAClElpB,KAAK2oE,KAAOxmE,OAAO4H,OAAO,CAAC,EAAG0+D,GAAWM,aACzC/oE,KAAKipE,gBAAiB,GAE1B,MAAM1sC,EAAQ/kB,EAAKlO,OAAO2C,MAAM,UAC1BxF,EAAO81B,EAAM/0B,QACnB,OAAQf,GACJ,IAAK,OAAQ,CACT,GAAqB,IAAjB81B,EAAMz3B,SACNivD,EAAQ,EAAG,mDACPx3B,EAAMz3B,OAAS,GACf,OAAO,EAEf,MAAO66B,EAAQovB,GAAUxyB,EAEzB,OADAv8B,KAAK2oE,KAAKhpC,GAAUovB,GACb,CACX,CACA,IAAK,QAAS,CAEV,GADA/uD,KAAK0oE,KAAKQ,UAAW,EACA,IAAjB3sC,EAAMz3B,OAEN,OADAivD,EAAQ,EAAG,oDACJ,EAEX,MAAO7qC,GAAWqT,EAClB,MAAgB,QAAZrT,GAAiC,QAAZA,GACrBlpB,KAAK0oE,KAAKx/C,QAAUA,GACb,IAIP6qC,EAAQ,EAAG,4BAA4B7qC,IADvB,aAAa9Z,KAAK8Z,KAE3B,EAEf,CACA,QAEI,OADA6qC,EAAQ,EAAG,qBAAqBttD,KAAQ,IACjC,EAEnB,CAOA0iE,OAAAA,CAAQ7hE,EAAQysD,GACZ,GAAe,MAAXzsD,EACA,MAAO,IACX,GAAkB,MAAdA,EAAO,GAEP,OADAysD,EAAQ,oBAAoBzsD,KACrB,KAEX,GAAkB,MAAdA,EAAO,GAAY,CACnB,MAAM8hE,EAAW9hE,EAAOvE,MAAM,GAAI,GAClC,MAAiB,MAAbqmE,GAAiC,OAAbA,GACpBrV,EAAQ,qCAAqCzsD,iBACtC,OAEuB,MAA9BA,EAAOA,EAAOxC,OAAS,IACvBivD,EAAQ,mCACLqV,EACX,CACA,MAAO,CAAEzpC,EAAQujC,GAAU57D,EAAOyJ,MAAM,mBACnCmyD,GACDnP,EAAQ,OAAOzsD,uBACnB,MAAMynD,EAAS/uD,KAAK2oE,KAAKhpC,GACzB,GAAIovB,EACA,IACI,OAAOA,EAAS/wC,mBAAmBklD,EACvC,CACA,MAAOt0D,GAEH,OADAmlD,EAAQtpD,OAAOmE,IACR,IACX,CAEJ,MAAe,MAAX+wB,EACOr4B,GACXysD,EAAQ,0BAA0BzsD,KAC3B,KACX,CAKA+hE,SAAAA,CAAU3oB,GACN,IAAK,MAAO/gB,EAAQovB,KAAW5sD,OAAO+R,QAAQlU,KAAK2oE,MAC/C,GAAIjoB,EAAI+Y,WAAW1K,GACf,OAAOpvB,EAAS4oC,GAAc7nB,EAAIjpC,UAAUs3C,EAAOjqD,SAE3D,MAAkB,MAAX47C,EAAI,GAAaA,EAAM,KAAKA,IACvC,CACAx+C,QAAAA,CAASonE,GACL,MAAMC,EAAQvpE,KAAK0oE,KAAKQ,SAClB,CAAC,SAASlpE,KAAK0oE,KAAKx/C,SAAW,SAC/B,GACAsgD,EAAarnE,OAAO+R,QAAQlU,KAAK2oE,MACvC,IAAIc,EACJ,GAAIH,GAAOE,EAAW1kE,OAAS,GAAKiQ,GAAOu0D,EAAIlC,UAAW,CACtD,MAAMuB,EAAO,CAAC,EACd77D,GAAMw8D,EAAIlC,SAAU,CAAChiE,EAAM4tC,KACnBj+B,GAAOi+B,IAASA,EAAK0N,MACrBioB,EAAK31B,EAAK0N,MAAO,KAEzB+oB,EAAWtnE,OAAO4C,KAAK4jE,EAC3B,MAEIc,EAAW,GACf,IAAK,MAAO9pC,EAAQovB,KAAWya,EACZ,OAAX7pC,GAA8B,uBAAXovB,GAElBua,IAAOG,EAASp5D,KAAKm4D,GAAMA,EAAG/O,WAAW1K,KAC1Cwa,EAAM7hE,KAAK,QAAQi4B,KAAUovB,KAErC,OAAOwa,EAAM76D,KAAK,KACtB,EClKJ,SAASg7D,GAAc7C,GACnB,GAAI,sBAAsBz3D,KAAKy3D,GAAS,CACpC,MAAM8C,EAAKx5D,KAAKC,UAAUy2D,GAE1B,MAAM,IAAIh7D,MADE,6DAA6D89D,IAE7E,CACA,OAAO,CACX,CCRA,SAASC,GAAaC,EAASllE,EAAKO,EAAK1B,GACrC,GAAIA,GAAsB,iBAARA,EACd,GAAIH,MAAMD,QAAQI,GACd,IAAK,IAAI3C,EAAI,EAAGoE,EAAMzB,EAAIsB,OAAQjE,EAAIoE,IAAOpE,EAAG,CAC5C,MAAMipE,EAAKtmE,EAAI3C,GACTkpE,EAAKH,GAAaC,EAASrmE,EAAKiH,OAAO5J,GAAIipE,QAEtCp/D,IAAPq/D,SACOvmE,EAAI3C,GACNkpE,IAAOD,IACZtmE,EAAI3C,GAAKkpE,EACjB,MAEC,GAAIvmE,aAAeqkB,IACpB,IAAK,MAAMiuC,KAAKzyD,MAAMsL,KAAKnL,EAAIuB,QAAS,CACpC,MAAM+kE,EAAKtmE,EAAIqU,IAAIi+C,GACbiU,EAAKH,GAAaC,EAASrmE,EAAKsyD,EAAGgU,QAC9Bp/D,IAAPq/D,EACAvmE,EAAI4U,OAAO09C,GACNiU,IAAOD,GACZtmE,EAAIoI,IAAIkqD,EAAGiU,EACnB,MAEC,GAAIvmE,aAAe4xC,IACpB,IAAK,MAAM00B,KAAMzmE,MAAMsL,KAAKnL,GAAM,CAC9B,MAAMumE,EAAKH,GAAaC,EAASrmE,EAAKsmE,EAAIA,QAC/Bp/D,IAAPq/D,EACAvmE,EAAI4U,OAAO0xD,GACNC,IAAOD,IACZtmE,EAAI4U,OAAO0xD,GACXtmE,EAAI8+B,IAAIynC,GAEhB,MAGA,IAAK,MAAOjU,EAAGgU,KAAO3nE,OAAO+R,QAAQ1Q,GAAM,CACvC,MAAMumE,EAAKH,GAAaC,EAASrmE,EAAKsyD,EAAGgU,QAC9Bp/D,IAAPq/D,SACOvmE,EAAIsyD,GACNiU,IAAOD,IACZtmE,EAAIsyD,GAAKiU,EACjB,CAGR,OAAOF,EAAQ/mE,KAAK6B,EAAKO,EAAK1B,EAClC,CCxCA,SAASwmE,GAAK3oE,EAAOywB,EAAKm4C,GAEtB,GAAI5mE,MAAMD,QAAQ/B,GACd,OAAOA,EAAMoD,IAAI,CAACm8B,EAAG//B,IAAMmpE,GAAKppC,EAAGn2B,OAAO5J,GAAIopE,IAClD,GAAI5oE,GAAiC,mBAAjBA,EAAMwM,OAAuB,CAE7C,IAAKo8D,IAAQrD,GAAUvlE,GACnB,OAAOA,EAAMwM,OAAOikB,EAAKm4C,GAC7B,MAAM1iE,EAAO,CAAE2iE,WAAY,EAAGpoC,MAAO,EAAGrb,SAAK/b,GAC7Cu/D,EAAIE,QAAQv+D,IAAIvK,EAAOkG,GACvB0iE,EAAIG,SAAW3jD,IACXlf,EAAKkf,IAAMA,SACJwjD,EAAIG,UAEf,MAAM3jD,EAAMplB,EAAMwM,OAAOikB,EAAKm4C,GAG9B,OAFIA,EAAIG,UACJH,EAAIG,SAAS3jD,GACVA,CACX,CACA,MAAqB,iBAAVplB,GAAuB4oE,GAAKI,KAEhChpE,EADIoL,OAAOpL,EAEtB,CH0IAonE,GAAWK,YAAc,CAAEI,UAAU,EAAOhgD,QAAS,OACrDu/C,GAAWM,YAAc,CAAE,KAAM,sBIzKjC,MAAMuB,GACF7mE,WAAAA,CAAYP,GACRf,OAAO2H,eAAe9J,KAAMomE,GAAW,CAAE/kE,MAAO6B,GACpD,CAEAi7B,KAAAA,GACI,MAAMtL,EAAO1wB,OAAOQ,OAAOR,OAAOE,eAAerC,MAAOmC,OAAOmE,0BAA0BtG,OAGzF,OAFIA,KAAKuqE,QACL13C,EAAK03C,MAAQvqE,KAAKuqE,MAAMxnE,SACrB8vB,CACX,CAEAm3C,IAAAA,CAAKV,GAAK,SAAEkB,EAAQ,cAAEC,EAAa,SAAEC,EAAQ,QAAEb,GAAY,CAAC,GACxD,IAAKvD,GAAWgD,GACZ,MAAM,IAAI95D,UAAU,mCACxB,MAAMy6D,EAAM,CACRE,QAAS,IAAItiD,IACbyhD,MACAe,MAAM,EACNG,UAAuB,IAAbA,EACVG,cAAc,EACdF,cAAwC,iBAAlBA,EAA6BA,EAAgB,KAEjEhkD,EAAMujD,GAAKhqE,KAAM,GAAIiqE,GAC3B,GAAwB,mBAAbS,EACP,IAAK,MAAM,MAAE5oC,EAAK,IAAErb,KAASwjD,EAAIE,QAAQ1oC,SACrCipC,EAASjkD,EAAKqb,GACtB,MAA0B,mBAAZ+nC,EACRD,GAAaC,EAAS,CAAE,GAAIpjD,GAAO,GAAIA,GACvCA,CACV,EC5BJ,MAAMwhD,WAAcqC,GAChB7mE,WAAAA,CAAY6D,GACRi3B,MAAMsnC,IACN7lE,KAAKsH,OAASA,EACdnF,OAAO2H,eAAe9J,KAAM,MAAO,CAC/B4L,GAAAA,GACI,MAAM,IAAIC,MAAM,+BACpB,GAER,CAKAwO,OAAAA,CAAQivD,EAAKW,GACT,IAAIt3B,EAeAle,EAdAw1C,GAAKW,kBACLj4B,EAAQs3B,EAAIW,mBAGZj4B,EAAQ,GACR7lC,GAAMw8D,EAAK,CACPvB,KAAMA,CAAC3iE,EAAM4tC,MACLqzB,GAAQrzB,IAAS4zB,GAAU5zB,KAC3BL,EAAMjrC,KAAKsrC,MAGnBi3B,IACAA,EAAIW,kBAAoBj4B,IAGhC,IAAK,MAAMK,KAAQL,EAAO,CACtB,GAAIK,IAAShzC,KACT,MACAgzC,EAAK6zB,SAAW7mE,KAAKsH,SACrBmtB,EAAQue,EAChB,CACA,OAAOve,CACX,CACA5mB,MAAAA,CAAOg9D,EAAMZ,GACT,IAAKA,EACD,MAAO,CAAE3iE,OAAQtH,KAAKsH,QAC1B,MAAM,QAAE6iE,EAAO,IAAEb,EAAG,cAAEmB,GAAkBR,EAClC3iE,EAAStH,KAAKqa,QAAQivD,EAAKW,GACjC,IAAK3iE,EAAQ,CACT,MAAMyH,EAAM,+DAA+D/O,KAAKsH,SAChF,MAAM,IAAIwjE,eAAe/7D,EAC7B,CACA,IAAIxH,EAAO4iE,EAAQtyD,IAAIvQ,GAOvB,GANKC,IAEDyiE,GAAK1iE,EAAQ,KAAM2iE,GACnB1iE,EAAO4iE,EAAQtyD,IAAIvQ,SAGLoD,IAAdnD,GAAMkf,IAEN,MAAM,IAAIqkD,eADE,0DAGhB,GAAIL,GAAiB,IACjBljE,EAAKu6B,OAAS,EACU,IAApBv6B,EAAK2iE,aACL3iE,EAAK2iE,WAAaa,GAAczB,EAAKhiE,EAAQ6iE,IAC7C5iE,EAAKu6B,MAAQv6B,EAAK2iE,WAAaO,GAE/B,MAAM,IAAIK,eADE,gEAIpB,OAAOvjE,EAAKkf,GAChB,CACAvkB,QAAAA,CAAS+nE,EAAKe,EAAYC,GACtB,MAAMxvC,EAAM,IAAIz7B,KAAKsH,SACrB,GAAI2iE,EAAK,CAEL,GADAP,GAAc1pE,KAAKsH,QACf2iE,EAAI16D,QAAQ27D,mBAAqBjB,EAAIE,QAAQjyD,IAAIlY,KAAKsH,QAAS,CAC/D,MAAMyH,EAAM,+DAA+D/O,KAAKsH,SAChF,MAAM,IAAIuE,MAAMkD,EACpB,CACA,GAAIk7D,EAAIkB,YACJ,MAAO,GAAG1vC,IAClB,CACA,OAAOA,CACX,EAEJ,SAASsvC,GAAczB,EAAKt2B,EAAMm3B,GAC9B,GAAI9D,GAAQrzB,GAAO,CACf,MAAM1rC,EAAS0rC,EAAK34B,QAAQivD,GACtBzC,EAASsD,GAAW7iE,GAAU6iE,EAAQtyD,IAAIvQ,GAChD,OAAOu/D,EAASA,EAAO/kC,MAAQ+kC,EAAOqD,WAAa,CACvD,CACK,GAAIvD,GAAa3zB,GAAO,CACzB,IAAIlR,EAAQ,EACZ,IAAK,MAAMo6B,KAAQlpB,EAAK+oB,MAAO,CAC3B,MAAMz6D,EAAIypE,GAAczB,EAAKpN,EAAMiO,GAC/B7oE,EAAIwgC,IACJA,EAAQxgC,EAChB,CACA,OAAOwgC,CACX,CACK,GAAI0kC,GAAOxzB,GAAO,CACnB,MAAMo4B,EAAKL,GAAczB,EAAKt2B,EAAK9tC,IAAKilE,GAClCkB,EAAKN,GAAczB,EAAKt2B,EAAK3xC,MAAO8oE,GAC1C,OAAOjpE,KAAKy2B,IAAIyzC,EAAIC,EACxB,CACA,OAAO,CACX,CC3GA,MAAMC,GAAiBjqE,IAAWA,GAA2B,mBAAVA,GAAyC,iBAAVA,EAClF,MAAM6mE,WAAeoC,GACjB7mE,WAAAA,CAAYpC,GACRk9B,MAAM2nC,IACNlmE,KAAKqB,MAAQA,CACjB,CACAwM,MAAAA,CAAOikB,EAAKm4C,GACR,OAAOA,GAAKI,KAAOrqE,KAAKqB,MAAQ2oE,GAAKhqE,KAAKqB,MAAOywB,EAAKm4C,EAC1D,CACA/nE,QAAAA,GACI,OAAOuI,OAAOzK,KAAKqB,MACvB,ECAJ,SAASkqE,GAAWlqE,EAAO8nE,EAASc,GAGhC,GAFI3D,GAAWjlE,KACXA,EAAQA,EAAM+lE,UACdryD,GAAO1T,GACP,OAAOA,EACX,GAAImlE,GAAOnlE,GAAQ,CACf,MAAMoD,EAAMwlE,EAAIpgD,OAAOm8C,IAAKuF,aAAatB,EAAIpgD,OAAQ,KAAMogD,GAE3D,OADAxlE,EAAIs3D,MAAMr0D,KAAKrG,GACRoD,CACX,EACIpD,aAAiBoJ,QACjBpJ,aAAiBoL,QACjBpL,aAAiBmiB,SACE,oBAAXgoD,QAA0BnqE,aAAiBmqE,UAGnDnqE,EAAQA,EAAMsxB,WAElB,MAAM,sBAAE84C,EAAqB,SAAEf,EAAQ,SAAEgB,EAAQ,OAAE7hD,EAAM,cAAE8hD,GAAkB1B,EAG7E,IAAI2B,EACJ,GAAIH,GAAyBpqE,GAA0B,iBAAVA,EAAoB,CAE7D,GADAuqE,EAAMD,EAAc9zD,IAAIxW,GACpBuqE,EAEA,OADAA,EAAI/E,SAAW+E,EAAI/E,OAAS6D,EAASrpE,IAC9B,IAAI4mE,GAAM2D,EAAI/E,QAGrB+E,EAAM,CAAE/E,OAAQ,KAAM7zB,KAAM,MAC5B24B,EAAc//D,IAAIvK,EAAOuqE,EAEjC,CACIzC,GAAS1P,WAAW,QACpB0P,EA7CiB,qBA6CYA,EAAQpmE,MAAM,IAC/C,IAAI8oE,EA7CR,SAAuBxqE,EAAO8nE,EAASR,GACnC,GAAIQ,EAAS,CACT,MAAMp4D,EAAQ43D,EAAKx+D,OAAO24B,GAAKA,EAAE4d,MAAQyoB,GACnC0C,EAAS96D,EAAMkkD,KAAKnyB,IAAMA,EAAEtqB,SAAWzH,EAAM,GACnD,IAAK86D,EACD,MAAM,IAAIhgE,MAAM,OAAOs9D,eAC3B,OAAO0C,CACX,CACA,OAAOlD,EAAK1T,KAAKnyB,GAAKA,EAAEgpC,WAAWzqE,KAAWyhC,EAAEtqB,OACpD,CAoCiBuzD,CAAc1qE,EAAO8nE,EAASt/C,EAAO8+C,MAClD,IAAKkD,EAAQ,CAKT,GAJIxqE,GAAiC,mBAAjBA,EAAMwM,SAEtBxM,EAAQA,EAAMwM,WAEbxM,GAA0B,iBAAVA,EAAoB,CACrC,MAAM2xC,EAAO,IAAIk1B,GAAO7mE,GAGxB,OAFIuqE,IACAA,EAAI54B,KAAOA,GACRA,CACX,CACA64B,EACIxqE,aAAiBwmB,IACXgC,EAAOm8C,IACPxjE,OAAOF,YAAYH,OAAOd,GACtBwoB,EAAOs8C,IACPt8C,EAAOm8C,GACzB,CACI0F,IACAA,EAASG,UACF5B,EAAIyB,UAEf,MAAM14B,EAAO64B,GAAQN,WACfM,EAAON,WAAWtB,EAAIpgD,OAAQxoB,EAAO4oE,GACF,mBAA5B4B,GAAQG,WAAWr9D,KACtBk9D,EAAOG,UAAUr9D,KAAKs7D,EAAIpgD,OAAQxoB,EAAO4oE,GACzC,IAAI/B,GAAO7mE,GAOrB,OANI8nE,EACAn2B,EAAK0N,IAAMyoB,EACL0C,EAAOx6C,UACb2hB,EAAK0N,IAAMmrB,EAAOnrB,KAClBkrB,IACAA,EAAI54B,KAAOA,GACRA,CACX,CCjFA,SAASi5B,GAAmBpiD,EAAQtb,EAAMlN,GACtC,IAAIu/B,EAAIv/B,EACR,IAAK,IAAIR,EAAI0N,EAAKzJ,OAAS,EAAGjE,GAAK,IAAKA,EAAG,CACvC,MAAMi1D,EAAIvnD,EAAK1N,GACf,GAAiB,iBAANi1D,GAAkBrpD,OAAOy/D,UAAUpW,IAAMA,GAAK,EAAG,CACxD,MAAM1sD,EAAI,GACVA,EAAE0sD,GAAKl1B,EACPA,EAAIx3B,CACR,MAEIw3B,EAAI,IAAI/Y,IAAI,CAAC,CAACiuC,EAAGl1B,IAEzB,CACA,OAAO2qC,GAAW3qC,OAAGl2B,EAAW,CAC5B+gE,uBAAuB,EACvBU,eAAe,EACfzB,SAAUA,KACN,MAAM,IAAI7+D,MAAM,iDAEpBge,SACA8hD,cAAe,IAAI9jD,KAE3B,CFTAqgD,GAAOkE,aAAe,eACtBlE,GAAOmE,cAAgB,gBACvBnE,GAAOoE,MAAQ,QACfpE,GAAOqE,aAAe,eACtBrE,GAAOsE,aAAe,eEUtB,MAAM1E,WAAmBwC,GACrB7mE,WAAAA,CAAYP,EAAM2mB,GACd0U,MAAMr7B,GACNf,OAAO2H,eAAe9J,KAAM,SAAU,CAClCqB,MAAOwoB,EACP3a,cAAc,EACdxD,YAAY,EACZC,UAAU,GAElB,CAMAwyB,KAAAA,CAAMtU,GACF,MAAMgJ,EAAO1wB,OAAOQ,OAAOR,OAAOE,eAAerC,MAAOmC,OAAOmE,0BAA0BtG,OAMzF,OALI6pB,IACAgJ,EAAKhJ,OAASA,GAClBgJ,EAAKkpC,MAAQlpC,EAAKkpC,MAAMt3D,IAAIgoE,GAAM13D,GAAO03D,IAAOjG,GAAOiG,GAAMA,EAAGtuC,MAAMtU,GAAU4iD,GAC5EzsE,KAAKuqE,QACL13C,EAAK03C,MAAQvqE,KAAKuqE,MAAMxnE,SACrB8vB,CACX,CAMA65C,KAAAA,CAAMn+D,EAAMlN,GACR,GAhCakN,IAAiB,MAARA,GACT,iBAATA,KAAuBA,EAAK/L,OAAOF,YAAY2I,OAAOC,KA+BtDyhE,CAAYp+D,GACZvO,KAAKsiC,IAAIjhC,OACR,CACD,MAAO6D,KAAQ8rD,GAAQziD,EACjBykC,EAAOhzC,KAAK6X,IAAI3S,GAAK,GAC3B,GAAIyhE,GAAa3zB,GACbA,EAAK05B,MAAM1b,EAAM3vD,OAChB,SAAaqJ,IAATsoC,IAAsBhzC,KAAK6pB,OAGhC,MAAM,IAAIhe,MAAM,+BAA+B3G,sBAAwB8rD,KAFvEhxD,KAAK4L,IAAI1G,EAAK+mE,GAAmBjsE,KAAK6pB,OAAQmnC,EAAM3vD,GAE0B,CACtF,CACJ,CAKAurE,QAAAA,CAASr+D,GACL,MAAOrJ,KAAQ8rD,GAAQziD,EACvB,GAAoB,IAAhByiD,EAAKlsD,OACL,OAAO9E,KAAKoY,OAAOlT,GACvB,MAAM8tC,EAAOhzC,KAAK6X,IAAI3S,GAAK,GAC3B,GAAIyhE,GAAa3zB,GACb,OAAOA,EAAK45B,SAAS5b,GAErB,MAAM,IAAInlD,MAAM,+BAA+B3G,sBAAwB8rD,IAC/E,CAMA6b,KAAAA,CAAMt+D,EAAMu+D,GACR,MAAO5nE,KAAQ8rD,GAAQziD,EACjBykC,EAAOhzC,KAAK6X,IAAI3S,GAAK,GAC3B,OAAoB,IAAhB8rD,EAAKlsD,QACGgoE,GAAcrG,GAASzzB,GAAQA,EAAK3xC,MAAQ2xC,EAE7C2zB,GAAa3zB,GAAQA,EAAK65B,MAAM7b,EAAM8b,QAAcpiE,CACnE,CACAqiE,gBAAAA,CAAiBC,GACb,OAAOhtE,KAAK+7D,MAAM9vB,MAAM+G,IACpB,IAAKwzB,GAAOxzB,GACR,OAAO,EACX,MAAMjf,EAAIif,EAAK3xC,MACf,OAAa,MAAL0yB,GACHi5C,GACGvG,GAAS1yC,IACE,MAAXA,EAAE1yB,QACD0yB,EAAEk5C,gBACFl5C,EAAEoyB,UACFpyB,EAAE2sB,KAEnB,CAIAwsB,KAAAA,CAAM3+D,GACF,MAAOrJ,KAAQ8rD,GAAQziD,EACvB,GAAoB,IAAhByiD,EAAKlsD,OACL,OAAO9E,KAAKkY,IAAIhT,GACpB,MAAM8tC,EAAOhzC,KAAK6X,IAAI3S,GAAK,GAC3B,QAAOyhE,GAAa3zB,IAAQA,EAAKk6B,MAAMlc,EAC3C,CAKAmc,KAAAA,CAAM5+D,EAAMlN,GACR,MAAO6D,KAAQ8rD,GAAQziD,EACvB,GAAoB,IAAhByiD,EAAKlsD,OACL9E,KAAK4L,IAAI1G,EAAK7D,OAEb,CACD,MAAM2xC,EAAOhzC,KAAK6X,IAAI3S,GAAK,GAC3B,GAAIyhE,GAAa3zB,GACbA,EAAKm6B,MAAMnc,EAAM3vD,OAChB,SAAaqJ,IAATsoC,IAAsBhzC,KAAK6pB,OAGhC,MAAM,IAAIhe,MAAM,+BAA+B3G,sBAAwB8rD,KAFvEhxD,KAAK4L,IAAI1G,EAAK+mE,GAAmBjsE,KAAK6pB,OAAQmnC,EAAM3vD,GAE0B,CACtF,CACJ,ECxIJ,MAAM+rE,GAAoBvqE,GAAQA,EAAI0G,QAAQ,kBAAmB,KACjE,SAAS8jE,GAAclnB,EAASmnB,GAC5B,MAAI,QAAQl+D,KAAK+2C,GACNA,EAAQ1uC,UAAU,GACtB61D,EAASnnB,EAAQ58C,QAAQ,aAAc+jE,GAAUnnB,CAC5D,CACA,MAAMonB,GAAcA,CAAC1qE,EAAKyqE,EAAQnnB,IAAYtjD,EAAIyH,SAAS,MACrD+iE,GAAclnB,EAASmnB,GACvBnnB,EAAQvlC,SAAS,MACb,KAAOysD,GAAclnB,EAASmnB,IAC7BzqE,EAAIyH,SAAS,KAAO,GAAK,KAAO67C,ECjBrCqnB,GAAY,OACZC,GAAa,QACbC,GAAc,SAMpB,SAASC,GAAc7kC,EAAMwkC,EAAQM,EAAO,QAAQ,cAAEC,EAAa,UAAEC,EAAY,GAAE,gBAAEC,EAAkB,GAAE,OAAEC,EAAM,WAAEC,GAAe,CAAC,GAC/H,IAAKH,GAAaA,EAAY,EAC1B,OAAOhlC,EACPglC,EAAYC,IACZA,EAAkB,GACtB,MAAMG,EAAUhtE,KAAKy2B,IAAI,EAAIo2C,EAAiB,EAAID,EAAYR,EAAOxoE,QACrE,GAAIgkC,EAAKhkC,QAAUopE,EACf,OAAOplC,EACX,MAAMqlC,EAAQ,GACRC,EAAe,CAAC,EACtB,IAOIniE,EACAu2B,EARAxe,EAAM8pD,EAAYR,EAAOxoE,OACA,iBAAlB+oE,IACHA,EAAgBC,EAAY5sE,KAAKy2B,IAAI,EAAGo2C,GACxCI,EAAMzmE,KAAK,GAEXsc,EAAM8pD,EAAYD,GAI1B,IAAIQ,GAAW,EACXxtE,GAAK,EACLytE,GAAY,EACZC,GAAU,EACVX,IAASH,KACT5sE,EAAI2tE,GAAyB1lC,EAAMjoC,EAAGysE,EAAOxoE,SAClC,IAAPjE,IACAmjB,EAAMnjB,EAAIqtE,IAElB,IAAK,IAAInrB,EAAKA,EAAKja,EAAMjoC,GAAK,IAAO,CACjC,GAAI+sE,IAASF,IAAsB,OAAP3qB,EAAa,CAErC,OADAurB,EAAWztE,EACHioC,EAAKjoC,EAAI,IACb,IAAK,IACDA,GAAK,EACL,MACJ,IAAK,IACDA,GAAK,EACL,MACJ,IAAK,IACDA,GAAK,EACL,MACJ,QACIA,GAAK,EAEb0tE,EAAS1tE,CACb,CACA,GAAW,OAAPkiD,EACI6qB,IAASH,KACT5sE,EAAI2tE,GAAyB1lC,EAAMjoC,EAAGysE,EAAOxoE,SACjDkf,EAAMnjB,EAAIysE,EAAOxoE,OAASopE,EAC1BjiE,OAAQvB,MAEP,CACD,GAAW,MAAPq4C,GACAvgB,GACS,MAATA,GACS,OAATA,GACS,OAATA,EAAe,CAEf,MAAMv3B,EAAO69B,EAAKjoC,EAAI,GAClBoK,GAAiB,MAATA,GAAyB,OAATA,GAA0B,OAATA,IACzCgB,EAAQpL,EAChB,CACA,GAAIA,GAAKmjB,EACL,GAAI/X,EACAkiE,EAAMzmE,KAAKuE,GACX+X,EAAM/X,EAAQiiE,EACdjiE,OAAQvB,OAEP,GAAIkjE,IAASF,GAAa,CAE3B,KAAgB,MAATlrC,GAAyB,OAATA,GACnBA,EAAOugB,EACPA,EAAKja,EAAMjoC,GAAK,GAChBwtE,GAAW,EAGf,MAAM35C,EAAI7zB,EAAI0tE,EAAS,EAAI1tE,EAAI,EAAIytE,EAAW,EAE9C,GAAIF,EAAa15C,GACb,OAAOoU,EACXqlC,EAAMzmE,KAAKgtB,GACX05C,EAAa15C,IAAK,EAClB1Q,EAAM0Q,EAAIw5C,EACVjiE,OAAQvB,CACZ,MAEI2jE,GAAW,CAGvB,CACA7rC,EAAOugB,CACX,CAGA,GAFIsrB,GAAYJ,GACZA,IACiB,IAAjBE,EAAMrpE,OACN,OAAOgkC,EACPklC,GACAA,IACJ,IAAIvnD,EAAMqiB,EAAK/lC,MAAM,EAAGorE,EAAM,IAC9B,IAAK,IAAIttE,EAAI,EAAGA,EAAIstE,EAAMrpE,SAAUjE,EAAG,CACnC,MAAM4tE,EAAON,EAAMttE,GACbmjB,EAAMmqD,EAAMttE,EAAI,IAAMioC,EAAKhkC,OACpB,IAAT2pE,EACAhoD,EAAM,KAAK6mD,IAASxkC,EAAK/lC,MAAM,EAAGihB,MAE9B4pD,IAASF,IAAeU,EAAaK,KACrChoD,GAAO,GAAGqiB,EAAK2lC,QACnBhoD,GAAO,KAAK6mD,IAASxkC,EAAK/lC,MAAM0rE,EAAO,EAAGzqD,KAElD,CACA,OAAOyC,CACX,CAKA,SAAS+nD,GAAyB1lC,EAAMjoC,EAAGysE,GACvC,IAAItpD,EAAMnjB,EACN0yB,EAAQ1yB,EAAI,EACZkiD,EAAKja,EAAKvV,GACd,KAAc,MAAPwvB,GAAqB,OAAPA,GACjB,GAAIliD,EAAI0yB,EAAQ+5C,EACZvqB,EAAKja,IAAOjoC,OAEX,CACD,GACIkiD,EAAKja,IAAOjoC,SACPkiD,GAAa,OAAPA,GACf/+B,EAAMnjB,EACN0yB,EAAQ1yB,EAAI,EACZkiD,EAAKja,EAAKvV,EACd,CAEJ,OAAOvP,CACX,CC5IA,MAAM0qD,GAAiBA,CAACzE,EAAK0E,KAAY,CACrCd,cAAec,EAAU1E,EAAIqD,OAAOxoE,OAASmlE,EAAI4D,cACjDC,UAAW7D,EAAI16D,QAAQu+D,UACvBC,gBAAiB9D,EAAI16D,QAAQw+D,kBAI3Ba,GAA0B/rE,GAAQ,mBAAmBuM,KAAKvM,GAmBhE,SAASgsE,GAAmBxtE,EAAO4oE,GAC/B,MAAM6E,EAAO3+D,KAAKC,UAAU/O,GAC5B,GAAI4oE,EAAI16D,QAAQw/D,mBACZ,OAAOD,EACX,MAAM,YAAE3D,GAAgBlB,EAClB+E,EAAqB/E,EAAI16D,QAAQ0/D,+BACjC3B,EAASrD,EAAIqD,SAAWsB,GAAuBvtE,GAAS,KAAO,IACrE,IAAIwB,EAAM,GACN0wB,EAAQ,EACZ,IAAK,IAAI1yB,EAAI,EAAGkiD,EAAK+rB,EAAKjuE,GAAIkiD,EAAIA,EAAK+rB,IAAOjuE,GAQ1C,GAPW,MAAPkiD,GAA8B,OAAhB+rB,EAAKjuE,EAAI,IAA+B,MAAhBiuE,EAAKjuE,EAAI,KAE/CgC,GAAOisE,EAAK/rE,MAAMwwB,EAAO1yB,GAAK,MAC9BA,GAAK,EACL0yB,EAAQ1yB,EACRkiD,EAAK,MAEE,OAAPA,EACA,OAAQ+rB,EAAKjuE,EAAI,IACb,IAAK,IACD,CACIgC,GAAOisE,EAAK/rE,MAAMwwB,EAAO1yB,GACzB,MAAM0M,EAAOuhE,EAAK/5C,OAAOl0B,EAAI,EAAG,GAChC,OAAQ0M,GACJ,IAAK,OACD1K,GAAO,MACP,MACJ,IAAK,OACDA,GAAO,MACP,MACJ,IAAK,OACDA,GAAO,MACP,MACJ,IAAK,OACDA,GAAO,MACP,MACJ,IAAK,OACDA,GAAO,MACP,MACJ,IAAK,OACDA,GAAO,MACP,MACJ,IAAK,OACDA,GAAO,MACP,MACJ,IAAK,OACDA,GAAO,MACP,MACJ,QAC8B,OAAtB0K,EAAKwnB,OAAO,EAAG,GACflyB,GAAO,MAAQ0K,EAAKwnB,OAAO,GAE3BlyB,GAAOisE,EAAK/5C,OAAOl0B,EAAG,GAElCA,GAAK,EACL0yB,EAAQ1yB,EAAI,CAChB,CACA,MACJ,IAAK,IACD,GAAIsqE,GACgB,MAAhB2D,EAAKjuE,EAAI,IACTiuE,EAAKhqE,OAASkqE,EACdnuE,GAAK,MAEJ,CAGD,IADAgC,GAAOisE,EAAK/rE,MAAMwwB,EAAO1yB,GAAK,OACP,OAAhBiuE,EAAKjuE,EAAI,IACI,MAAhBiuE,EAAKjuE,EAAI,IACO,MAAhBiuE,EAAKjuE,EAAI,IACTgC,GAAO,KACPhC,GAAK,EAETgC,GAAOyqE,EAEa,MAAhBwB,EAAKjuE,EAAI,KACTgC,GAAO,MACXhC,GAAK,EACL0yB,EAAQ1yB,EAAI,CAChB,CACA,MACJ,QACIA,GAAK,EAIrB,OADAgC,EAAM0wB,EAAQ1wB,EAAMisE,EAAK/rE,MAAMwwB,GAASu7C,EACjC3D,EACDtoE,EACA8qE,GAAc9qE,EAAKyqE,EAAQI,GAAagB,GAAezE,GAAK,GACtE,CACA,SAASiF,GAAmB7tE,EAAO4oE,GAC/B,IAAgC,IAA5BA,EAAI16D,QAAQ4/D,aACXlF,EAAIkB,aAAe9pE,EAAMuf,SAAS,OACnC,kBAAkBxR,KAAK/N,GAEvB,OAAOwtE,GAAmBxtE,EAAO4oE,GACrC,MAAMqD,EAASrD,EAAIqD,SAAWsB,GAAuBvtE,GAAS,KAAO,IAC/DolB,EAAM,IAAMplB,EAAMkI,QAAQ,KAAM,MAAMA,QAAQ,OAAQ,OAAO+jE,KAAY,IAC/E,OAAOrD,EAAIkB,YACL1kD,EACAknD,GAAclnD,EAAK6mD,EAAQE,GAAWkB,GAAezE,GAAK,GACpE,CACA,SAASmF,GAAa/tE,EAAO4oE,GACzB,MAAM,YAAEkF,GAAgBlF,EAAI16D,QAC5B,IAAI8/D,EACJ,IAAoB,IAAhBF,EACAE,EAAKR,OACJ,CACD,MAAMS,EAAYjuE,EAAMuf,SAAS,KAC3B2uD,EAAYluE,EAAMuf,SAAS,KAE7ByuD,EADAC,IAAcC,EACTL,GACAK,IAAcD,EACdT,GAEAM,EAAcD,GAAqBL,EAChD,CACA,OAAOQ,EAAGhuE,EAAO4oE,EACrB,CAGA,IAAIuF,GACJ,IACIA,GAAmB,IAAIzxD,OAAO,yBAA0B,IAC5D,CACA,MACIyxD,GAAmB,cACvB,CACA,SAASC,IAAY,QAAEtpB,EAAO,KAAEjjD,EAAI,MAAE7B,GAAS4oE,EAAKyF,EAAWC,GAC3D,MAAM,WAAEC,EAAU,cAAEC,EAAa,UAAE/B,GAAc7D,EAAI16D,QAGrD,IAAKqgE,GAAc,YAAYxgE,KAAK/N,GAChC,OAAO+tE,GAAa/tE,EAAO4oE,GAE/B,MAAMqD,EAASrD,EAAIqD,SACdrD,EAAI6F,kBAAoBlB,GAAuBvtE,GAAS,KAAO,IAC9D0uE,EAAyB,YAAfH,GAEK,WAAfA,GAA2B1sE,IAASglE,GAAOkE,eAEvClpE,IAASglE,GAAOmE,gBA/J9B,SAA6BxpE,EAAKirE,EAAWkC,GACzC,IAAKlC,GAAaA,EAAY,EAC1B,OAAO,EACX,MAAMvzC,EAAQuzC,EAAYkC,EACpBn7C,EAAShyB,EAAIiC,OACnB,GAAI+vB,GAAU0F,EACV,OAAO,EACX,IAAK,IAAI15B,EAAI,EAAG0yB,EAAQ,EAAG1yB,EAAIg0B,IAAUh0B,EACrC,GAAe,OAAXgC,EAAIhC,GAAa,CACjB,GAAIA,EAAI0yB,EAAQgH,EACZ,OAAO,EAEX,GADAhH,EAAQ1yB,EAAI,EACRg0B,EAAStB,GAASgH,EAClB,OAAO,CACf,CAEJ,OAAO,CACX,CAgJmB01C,CAAoB5uE,EAAOysE,EAAWR,EAAOxoE,SAC5D,IAAKzD,EACD,OAAO0uE,EAAU,MAAQ,MAE7B,IAAIG,EACAC,EACJ,IAAKA,EAAW9uE,EAAMyD,OAAQqrE,EAAW,IAAKA,EAAU,CACpD,MAAMptB,EAAK1hD,EAAM8uE,EAAW,GAC5B,GAAW,OAAPptB,GAAsB,OAAPA,GAAsB,MAAPA,EAC9B,KACR,CACA,IAAI/+B,EAAM3iB,EAAMoW,UAAU04D,GAC1B,MAAMC,EAAWpsD,EAAIpZ,QAAQ,OACX,IAAdwlE,EACAF,EAAQ,IAEH7uE,IAAU2iB,GAAOosD,IAAapsD,EAAIlf,OAAS,GAChDorE,EAAQ,IACJP,GACAA,KAGJO,EAAQ,GAERlsD,IACA3iB,EAAQA,EAAM0B,MAAM,GAAIihB,EAAIlf,QACA,OAAxBkf,EAAIA,EAAIlf,OAAS,KACjBkf,EAAMA,EAAIjhB,MAAM,GAAI,IACxBihB,EAAMA,EAAIza,QAAQimE,GAAkB,KAAKlC,MAG7C,IACI+C,EADAC,GAAiB,EAEjBC,GAAc,EAClB,IAAKF,EAAW,EAAGA,EAAWhvE,EAAMyD,SAAUurE,EAAU,CACpD,MAAMttB,EAAK1hD,EAAMgvE,GACjB,GAAW,MAAPttB,EACAutB,GAAiB,MAChB,IAAW,OAAPvtB,EAGL,MAFAwtB,EAAaF,CAER,CACb,CACA,IAAI98C,EAAQlyB,EAAMoW,UAAU,EAAG84D,EAAaF,EAAWE,EAAa,EAAIF,GACpE98C,IACAlyB,EAAQA,EAAMoW,UAAU8b,EAAMzuB,QAC9ByuB,EAAQA,EAAMhqB,QAAQ,OAAQ,KAAK+jE,MAIvC,IAAI72D,GAAU65D,EAFKhD,EAAS,IAAM,IAEU,IAAM4C,EAMlD,GALI/pB,IACA1vC,GAAU,IAAMo5D,EAAc1pB,EAAQ58C,QAAQ,aAAc,MACxDmmE,GACAA,MAEHK,EAAS,CACV,MAAMS,EAAcnvE,EACfkI,QAAQ,OAAQ,QAChBA,QAAQ,iDAAkD,QAE1DA,QAAQ,OAAQ,KAAK+jE,KAC1B,IAAImD,GAAkB,EACtB,MAAMC,EAAchC,GAAezE,GAAK,GACrB,WAAf2F,GAA2B1sE,IAASglE,GAAOkE,eAC3CsE,EAAYzC,WAAa,KACrBwC,GAAkB,IAG1B,MAAMpqD,EAAOsnD,GAAc,GAAGp6C,IAAQi9C,IAAcxsD,IAAOspD,EAAQG,GAAYiD,GAC/E,IAAKD,EACD,MAAO,IAAIh6D,MAAW62D,IAASjnD,GACvC,CAEA,MAAO,IAAI5P,MAAW62D,IAAS/5C,IAD/BlyB,EAAQA,EAAMkI,QAAQ,OAAQ,KAAK+jE,OACYtpD,GACnD,CAiDA,SAAS2sD,GAAgBzU,EAAM+N,EAAKyF,EAAWC,GAC3C,MAAM,YAAExE,EAAW,OAAEyF,GAAW3G,EAC1B4G,EAA2B,iBAAf3U,EAAK76D,MACjB66D,EACA/5D,OAAO4H,OAAO,CAAC,EAAGmyD,EAAM,CAAE76D,MAAOoJ,OAAOyxD,EAAK76D,SACnD,IAAI,KAAE6B,GAASg5D,EACXh5D,IAASglE,GAAOqE,cAEZ,kDAAkDn9D,KAAKyhE,EAAGxvE,SAC1D6B,EAAOglE,GAAOqE,cAEtB,MAAMuE,EAAcC,IAChB,OAAQA,GACJ,KAAK7I,GAAOkE,aACZ,KAAKlE,GAAOmE,cACR,OAAOlB,GAAeyF,EAChBxB,GAAayB,EAAGxvE,MAAO4oE,GACvBwF,GAAYoB,EAAI5G,EAAKyF,EAAWC,GAC1C,KAAKzH,GAAOqE,aACR,OAAOsC,GAAmBgC,EAAGxvE,MAAO4oE,GACxC,KAAK/B,GAAOsE,aACR,OAAO0C,GAAmB2B,EAAGxvE,MAAO4oE,GACxC,KAAK/B,GAAOoE,MACR,OAvEhB,SAAqBpQ,EAAM+N,EAAKyF,EAAWC,GACvC,MAAM,KAAEzsE,EAAI,MAAE7B,GAAU66D,GAClB,aAAE8U,EAAY,YAAE7F,EAAW,OAAEmC,EAAM,WAAE2D,EAAU,OAAEL,GAAW3G,EAClE,GAAKkB,GAAe9pE,EAAMuf,SAAS,OAC9BgwD,GAAU,WAAWxhE,KAAK/N,GAC3B,OAAO+tE,GAAa/tE,EAAO4oE,GAE/B,GAAI,oFAAoF76D,KAAK/N,GAOzF,OAAO8pE,GAAeyF,IAAWvvE,EAAMuf,SAAS,MAC1CwuD,GAAa/tE,EAAO4oE,GACpBwF,GAAYvT,EAAM+N,EAAKyF,EAAWC,GAE5C,IAAKxE,IACAyF,GACD1tE,IAASglE,GAAOoE,OAChBjrE,EAAMuf,SAAS,MAEf,OAAO6uD,GAAYvT,EAAM+N,EAAKyF,EAAWC,GAE7C,GAAIf,GAAuBvtE,GAAQ,CAC/B,GAAe,KAAXisE,EAEA,OADArD,EAAI6F,kBAAmB,EAChBL,GAAYvT,EAAM+N,EAAKyF,EAAWC,GAExC,GAAIxE,GAAemC,IAAW2D,EAC/B,OAAO7B,GAAa/tE,EAAO4oE,EAEnC,CACA,MAAMpnE,EAAMxB,EAAMkI,QAAQ,OAAQ,OAAO+jE,KAIzC,GAAI0D,EAAc,CACd,MAAM5hE,EAAQsxC,GAAQA,EAAIrvB,SAAuB,0BAAZqvB,EAAIA,KAAmCA,EAAItxC,MAAMA,KAAKvM,IACrF,OAAEquE,EAAM,KAAEvI,GAASsB,EAAIX,IAAIz/C,OACjC,GAAI8+C,EAAKt4D,KAAKjB,IAAS8hE,GAAQ7gE,KAAKjB,GAChC,OAAOggE,GAAa/tE,EAAO4oE,EACnC,CACA,OAAOkB,EACDtoE,EACA8qE,GAAc9qE,EAAKyqE,EAAQE,GAAWkB,GAAezE,GAAK,GACpE,CAwBuBkH,CAAYN,EAAI5G,EAAKyF,EAAWC,GAC3C,QACI,OAAO,OAGnB,IAAIlpD,EAAMqqD,EAAW5tE,GACrB,GAAY,OAARujB,EAAc,CACd,MAAM,eAAE2qD,EAAc,kBAAEC,GAAsBpH,EAAI16D,QAC5CuzB,EAAKqoC,GAAeiG,GAAmBC,EAE7C,GADA5qD,EAAMqqD,EAAWhuC,GACL,OAARrc,EACA,MAAM,IAAI5a,MAAM,mCAAmCi3B,IAC3D,CACA,OAAOrc,CACX,CCnPA,SAASrW,GAAU8rD,EAAM+N,EAAKyF,EAAWC,GACrC,GAAInJ,GAAOtK,GACP,OAAOA,EAAKh6D,SAAS+nE,EAAKyF,EAAWC,GACzC,GAAItJ,GAAQnK,GAAO,CACf,GAAI+N,EAAIX,IAAIgI,WACR,OAAOpV,EAAKh6D,SAAS+nE,GACzB,GAAIA,EAAIsH,iBAAiBr5D,IAAIgkD,GACzB,MAAM,IAAI1sD,UAAU,2DAGhBy6D,EAAIsH,gBACJtH,EAAIsH,gBAAgBjvC,IAAI45B,GAExB+N,EAAIsH,gBAAkB,IAAIn8B,IAAI,CAAC8mB,IACnCA,EAAOA,EAAK7hD,QAAQ4vD,EAAIX,IAEhC,CACA,IAAIuC,EACJ,MAAM74B,EAAOj+B,GAAOmnD,GACdA,EACA+N,EAAIX,IAAIiC,WAAWrP,EAAM,CAAEwP,SAAUruC,GAAMwuC,EAASxuC,IAC1DwuC,IAAWA,EAjEf,SAAsBlD,EAAMzM,GACxB,GAAIA,EAAKxb,IAAK,CACV,MAAM3vC,EAAQ43D,EAAKx+D,OAAO24B,GAAKA,EAAE4d,MAAQwb,EAAKxb,KAC9C,GAAI3vC,EAAMjM,OAAS,EACf,OAAOiM,EAAMkkD,KAAKnyB,GAAKA,EAAEtqB,SAAW0jD,EAAK1jD,SAAWzH,EAAM,EAClE,CACA,IAAI86D,EACAlnE,EACJ,GAAI8hE,GAASvK,GAAO,CAChBv3D,EAAMu3D,EAAK76D,MACX,IAAI0P,EAAQ43D,EAAKx+D,OAAO24B,GAAKA,EAAEgpC,WAAWnnE,IAC1C,GAAIoM,EAAMjM,OAAS,EAAG,CAClB,MAAM0sE,EAAYzgE,EAAM5G,OAAO24B,GAAKA,EAAE1zB,MAClCoiE,EAAU1sE,OAAS,IACnBiM,EAAQygE,EAChB,CACA3F,EACI96D,EAAMkkD,KAAKnyB,GAAKA,EAAEtqB,SAAW0jD,EAAK1jD,SAAWzH,EAAMkkD,KAAKnyB,IAAMA,EAAEtqB,OACxE,MAEI7T,EAAMu3D,EACN2P,EAASlD,EAAK1T,KAAKnyB,GAAKA,EAAEkpC,WAAarnE,aAAem+B,EAAEkpC,WAE5D,IAAKH,EAED,MAAM,IAAIhgE,MAAM,wBADHlH,GAAKlB,aAAagD,OAAiB,OAAR9B,EAAe,cAAgBA,YAG3E,OAAOknE,CACX,CAqCwB4F,CAAaxH,EAAIX,IAAIz/C,OAAO8+C,KAAM31B,IACtD,MAAMnpC,EApCV,SAAwBmpC,EAAM64B,GAAQ,QAAE1B,EAAO,IAAEb,IAC7C,IAAKA,EAAIgI,WACL,MAAO,GACX,MAAMznE,EAAQ,GACRg9D,GAAUJ,GAASzzB,IAAS2zB,GAAa3zB,KAAUA,EAAK6zB,OAC1DA,GAAU6C,GAAc7C,KACxBsD,EAAQ7nC,IAAIukC,GACZh9D,EAAMnC,KAAK,IAAIm/D,MAEnB,MAAMnmB,EAAM1N,EAAK0N,MAAQmrB,EAAOx6C,QAAU,KAAOw6C,EAAOnrB,KAGxD,OAFIA,GACA72C,EAAMnC,KAAK4hE,EAAIgI,WAAWjI,UAAU3oB,IACjC72C,EAAM6E,KAAK,IACtB,CAuBkBgjE,CAAe1+B,EAAM64B,EAAQ5B,GACvCpgE,EAAM/E,OAAS,IACfmlE,EAAI4D,eAAiB5D,EAAI4D,eAAiB,GAAKhkE,EAAM/E,OAAS,GAClE,MAAMjC,EAAkC,mBAArBgpE,EAAOz7D,UACpBy7D,EAAOz7D,UAAU4iC,EAAMi3B,EAAKyF,EAAWC,GACvClJ,GAASzzB,GACL29B,GAAgB39B,EAAMi3B,EAAKyF,EAAWC,GACtC38B,EAAK9wC,SAAS+nE,EAAKyF,EAAWC,GACxC,OAAK9lE,EAEE48D,GAASzzB,IAAoB,MAAXnwC,EAAI,IAAyB,MAAXA,EAAI,GACzC,GAAGgH,KAAShH,IACZ,GAAGgH,MAAUogE,EAAIqD,SAASzqE,IAHrBA,CAIf,CCnHA,MAAM8uE,GAAY,KACZ7oE,GAAQ,CACVgjE,SAAUzqE,GAASA,IAAUswE,IACP,iBAAVtwE,GAAsBA,EAAMyM,cAAgB6jE,GACxDtgD,QAAS,MACTqvB,IAAK,0BACLtxC,KAAM,OACNiL,QAASA,IAAMlY,OAAO4H,OAAO,IAAIm+D,GAAO1lE,OAAOmvE,KAAa,CACxDC,WAAYC,KAEhBzhE,UAAWA,IAAMuhE,IAOrB,SAASE,GAAgB5H,EAAKxlE,EAAKpD,GAE/B,GADAA,EAAQ4oE,GAAO5D,GAAQhlE,GAASA,EAAMgZ,QAAQ4vD,EAAIX,KAAOjoE,EACrDqlE,GAAMrlE,GACN,IAAK,MAAMorE,KAAMprE,EAAM06D,MACnB+V,GAAW7H,EAAKxlE,EAAKgoE,QACxB,GAAIppE,MAAMD,QAAQ/B,GACnB,IAAK,MAAMorE,KAAMprE,EACbywE,GAAW7H,EAAKxlE,EAAKgoE,QAEzBqF,GAAW7H,EAAKxlE,EAAKpD,EAC7B,CACA,SAASywE,GAAW7H,EAAKxlE,EAAKpD,GAC1B,MAAMiG,EAAS2iE,GAAO5D,GAAQhlE,GAASA,EAAMgZ,QAAQ4vD,EAAIX,KAAOjoE,EAChE,IAAKklE,GAAMj/D,GACP,MAAM,IAAIuE,MAAM,6CACpB,MAAMkmE,EAASzqE,EAAOuG,OAAO,KAAMo8D,EAAKpiD,KACxC,IAAK,MAAO3iB,EAAK7D,KAAU0wE,EACnBttE,aAAeojB,IACVpjB,EAAIyT,IAAIhT,IACTT,EAAImH,IAAI1G,EAAK7D,GAEZoD,aAAe2wC,IACpB3wC,EAAI69B,IAAIp9B,GAEF/C,OAAOC,UAAU4D,eAAelD,KAAK2B,EAAKS,IAChD/C,OAAO2H,eAAerF,EAAKS,EAAK,CAC5B7D,QACAsK,UAAU,EACVD,YAAY,EACZwD,cAAc,IAI1B,OAAOzK,CACX,CCvDA,SAASutE,GAAe/H,EAAKxlE,GAAK,IAAES,EAAG,MAAE7D,IACrC,GAAI0T,GAAO7P,IAAQA,EAAI0sE,WACnB1sE,EAAI0sE,WAAW3H,EAAKxlE,EAAKpD,QAExB,GDYU4wE,EAAChI,EAAK/kE,KAAS4D,GAAMgjE,SAAS5mE,IAC5CuhE,GAASvhE,MACJA,EAAIhC,MAAQgC,EAAIhC,OAASglE,GAAOoE,QAClCxjE,GAAMgjE,SAAS5mE,EAAI7D,SACvB4oE,GAAKX,IAAIz/C,OAAO8+C,KAAKt4D,KAAKqwC,GAAOA,EAAIA,MAAQ53C,GAAM43C,KAAOA,EAAIrvB,SChBrD4gD,CAAWhI,EAAK/kE,GACrB2sE,GAAgB5H,EAAKxlE,EAAKpD,OACzB,CACD,MAAM6wE,EAAQlI,GAAK9kE,EAAK,GAAI+kE,GAC5B,GAAIxlE,aAAeojB,IACfpjB,EAAImH,IAAIsmE,EAAOlI,GAAK3oE,EAAO6wE,EAAOjI,SAEjC,GAAIxlE,aAAe2wC,IACpB3wC,EAAI69B,IAAI4vC,OAEP,CACD,MAAMC,EAelB,SAAsBjtE,EAAKgtE,EAAOjI,GAC9B,GAAc,OAAViI,EACA,MAAO,GAEX,GAAqB,iBAAVA,EACP,OAAOznE,OAAOynE,GAClB,GAAIn9D,GAAO7P,IAAQ+kE,GAAKX,IAAK,CACzB,MAAM8I,EFtCd,SAAgC9I,GAC5B,MAAMlgD,EAAMjnB,OAAO4H,OAAO,CACtB6lE,YAAY,EACZC,cAAezC,GACfgE,eAAgB,KAChBC,kBAAmB,QACnBC,WAAY,KACZvC,oBAAoB,EACpBE,+BAAgC,GAChCoD,SAAU,QACVC,uBAAuB,EACvBC,WAAW,EACXzE,UAAW,GACXC,gBAAiB,GACjByE,QAAS,OACTC,YAAY,EACZtD,YAAa,KACbuD,QAAS,OACTxH,kBAAkB,GACnB5B,EAAIz/C,OAAO8oD,gBEmBqC,CAAC,GFlBpD,IAAI/B,EACJ,OAAQxnD,EAAIwpD,iBACR,IAAK,QACDhC,GAAS,EACT,MACJ,IAAK,OACDA,GAAS,EACT,MACJ,QACIA,EAAS,KAEjB,MAAO,CACHzG,QAAS,IAAI/0B,IACbk0B,MACAgJ,sBAAuBlpD,EAAIkpD,sBAAwB,IAAM,GACzDhF,OAAQ,GACR2D,WAAkC,iBAAf7nD,EAAIkkD,OAAsB,IAAIuF,OAAOzpD,EAAIkkD,QAAU,KACtEsD,SACArhE,QAAS6Z,EAEjB,CEFuB0pD,CAAuB7I,EAAIX,KAC1C8I,EAAOjI,QAAU,IAAI/0B,IACrB,IAAK,MAAMpC,KAAQi3B,EAAIE,QAAQplE,OAC3BqtE,EAAOjI,QAAQ7nC,IAAI0Q,EAAK6zB,QAC5BuL,EAAOxB,QAAS,EAChBwB,EAAOW,gBAAiB,EACxB,MAAMC,EAAS9tE,EAAIhD,SAASkwE,GAC5B,IAAKnI,EAAIU,aAAc,CACnB,IAAIsI,EAAU9iE,KAAKC,UAAU4iE,GACzBC,EAAQnuE,OAAS,KACjBmuE,EAAUA,EAAQx7D,UAAU,EAAG,IAAM,QCjD7By7D,EDkDmB,kFAAkFD,4CCjDxG,WADPE,EDkDGlJ,EAAIX,IAAI/5D,QAAQ4jE,WCjDY,SAAbA,GACxB3pD,QAAQC,KAAKypD,GDiDTjJ,EAAIU,cAAe,CACvB,CACA,OAAOqI,CACX,CCtDJ,IAAcG,EAAUD,EDuDpB,OAAO/iE,KAAKC,UAAU8hE,EAC1B,CAvC8BkB,CAAaluE,EAAKgtE,EAAOjI,GACrCoJ,EAAUrJ,GAAK3oE,EAAO8wE,EAAWlI,GACnCkI,KAAa1tE,EACbtC,OAAO2H,eAAerF,EAAK0tE,EAAW,CAClC9wE,MAAOgyE,EACP1nE,UAAU,EACVD,YAAY,EACZwD,cAAc,IAGlBzK,EAAI0tE,GAAakB,CACzB,CACJ,CACA,OAAO5uE,CACX,CE9BA,SAAS6uE,GAAWpuE,EAAK7D,EAAO4oE,GAC5B,MAAMnU,EAAIyV,GAAWrmE,OAAKwF,EAAWu/D,GAC/BrpC,EAAI2qC,GAAWlqE,OAAOqJ,EAAWu/D,GACvC,OAAO,IAAI7B,GAAKtS,EAAGl1B,EACvB,CACA,MAAMwnC,GACF3kE,WAAAA,CAAYyB,EAAK7D,EAAQ,MACrBc,OAAO2H,eAAe9J,KAAMomE,GAAW,CAAE/kE,MAAO4kE,KAChDjmE,KAAKkF,IAAMA,EACXlF,KAAKqB,MAAQA,CACjB,CACA88B,KAAAA,CAAMtU,GACF,IAAI,IAAE3kB,EAAG,MAAE7D,GAAUrB,KAKrB,OAJI+U,GAAO7P,KACPA,EAAMA,EAAIi5B,MAAMtU,IAChB9U,GAAO1T,KACPA,EAAQA,EAAM88B,MAAMtU,IACjB,IAAIu+C,GAAKljE,EAAK7D,EACzB,CACAwM,MAAAA,CAAO0lE,EAAGtJ,GAEN,OAAO+H,GAAe/H,EADTA,GAAKO,SAAW,IAAI3iD,IAAQ,CAAC,EACT7nB,KACrC,CACAkC,QAAAA,CAAS+nE,EAAKyF,EAAWC,GACrB,OAAO1F,GAAKX,ICxBpB,UAAuB,IAAEpkE,EAAG,MAAE7D,GAAS4oE,EAAKyF,EAAWC,GACnD,MAAM,cAAE6D,EAAa,IAAElK,EAAG,OAAEgE,EAAM,WAAE2D,EAAY1hE,SAAS,cAAEsgE,EAAa,UAAE0C,EAAS,WAAEE,IAAiBxI,EACtG,IAAIwJ,EAAc1+D,GAAO7P,IAAQA,EAAIihD,SAAY,KACjD,GAAIssB,EAAY,CACZ,GAAIgB,EACA,MAAM,IAAI5nE,MAAM,oDAEpB,GAAI86D,GAAazhE,KAAU6P,GAAO7P,IAAuB,iBAARA,EAE7C,MAAM,IAAI2G,MADE,6DAGpB,CACA,IAAI6nE,GAAejB,KACbvtE,GACGuuE,GAAuB,MAATpyE,IAAkB4oE,EAAI2G,QACrCjK,GAAazhE,KACZuhE,GAASvhE,GACJA,EAAIhC,OAASglE,GAAOkE,cAAgBlnE,EAAIhC,OAASglE,GAAOmE,cACzC,iBAARnnE,IACrB+kE,EAAM9nE,OAAO4H,OAAO,CAAC,EAAGkgE,EAAK,CACzBuJ,eAAe,EACfrI,aAAcuI,IAAgBjB,IAAee,GAC7ClG,OAAQA,EAAS2D,IAErB,IAoCI0C,EAAKC,EAAKC,EApCVC,GAAiB,EACjBC,GAAY,EACZlxE,EAAMuN,GAAUlL,EAAK+kE,EAAK,IAAO6J,GAAiB,EAAO,IAAOC,GAAY,GAChF,IAAKL,IAAgBzJ,EAAI2G,QAAU/tE,EAAIiC,OAAS,KAAM,CAClD,GAAI2tE,EACA,MAAM,IAAI5mE,MAAM,gFACpB6nE,GAAc,CAClB,CACA,GAAIzJ,EAAI2G,QACJ,GAAI4C,GAA0B,MAATnyE,EAGjB,OAFIyyE,GAAkBpE,GAClBA,IACW,KAAR7sE,EAAa,IAAM6wE,EAAc,KAAK7wE,IAAQA,OAGxD,GAAK2wE,IAAkBf,GAAyB,MAATpxE,GAAiBqyE,EAOzD,OANA7wE,EAAM,KAAKA,IACP4wE,IAAeK,EACfjxE,GAAO0qE,GAAY1qE,EAAKonE,EAAIqD,OAAQuC,EAAc4D,IAE7CM,GAAapE,GAClBA,IACG9sE,EAEPixE,IACAL,EAAa,MACbC,GACID,IACA5wE,GAAO0qE,GAAY1qE,EAAKonE,EAAIqD,OAAQuC,EAAc4D,KACtD5wE,EAAM,KAAKA,MAAQyqE,OAGnBzqE,EAAM,GAAGA,KACL4wE,IACA5wE,GAAO0qE,GAAY1qE,EAAKonE,EAAIqD,OAAQuC,EAAc4D,MAGtD1+D,GAAO1T,IACPsyE,IAAQtyE,EAAM2yE,YACdJ,EAAMvyE,EAAM4rE,cACZ4G,EAAexyE,EAAM8kD,UAGrBwtB,GAAM,EACNC,EAAM,KACNC,EAAe,KACXxyE,GAA0B,iBAAVA,IAChBA,EAAQioE,EAAIiC,WAAWlqE,KAE/B4oE,EAAIkB,aAAc,EACbuI,GAAgBD,IAAchN,GAASplE,KACxC4oE,EAAI4D,cAAgBhrE,EAAIiC,OAAS,GACrCivE,GAAY,EACPxB,KACDtB,EAAWnsE,QAAU,IACpBmlE,EAAI2G,QACJ8C,IACDhN,GAAMrlE,IACLA,EAAM4yE,MACN5yE,EAAMq/C,KACNr/C,EAAMwlE,SAEPoD,EAAIqD,OAASrD,EAAIqD,OAAO71D,UAAU,IAEtC,IAAIy8D,GAAmB,EACvB,MAAMC,EAAW/jE,GAAU/O,EAAO4oE,EAAK,IAAOiK,GAAmB,EAAO,IAAOH,GAAY,GAC3F,IAAIK,EAAK,IACT,GAAIX,GAAcE,GAAOC,EACrBQ,EAAKT,EAAM,KAAO,GACdC,IAEAQ,GAAM,KAAK/G,GADAwC,EAAc+D,GACI3J,EAAIqD,WAEpB,KAAb6G,GAAoBlK,EAAI2G,OAKxBwD,GAAM,KAAKnK,EAAIqD,SAJJ,OAAP8G,GAAeP,IACfO,EAAK,aAMZ,IAAKV,GAAe/M,GAAatlE,GAAQ,CAC1C,MAAMgzE,EAAMF,EAAS,GACfG,EAAMH,EAASvpE,QAAQ,MACvB2pE,GAAsB,IAATD,EACbL,EAAOhK,EAAI2G,QAAUvvE,EAAM4yE,MAA+B,IAAvB5yE,EAAM06D,MAAMj3D,OACrD,GAAIyvE,IAAeN,EAAM,CACrB,IAAIO,GAAe,EACnB,GAAID,IAAuB,MAARF,GAAuB,MAARA,GAAc,CAC5C,IAAII,EAAMN,EAASvpE,QAAQ,KACf,MAARypE,IACS,IAATI,GACAA,EAAMH,GACgB,MAAtBH,EAASM,EAAM,KACfA,EAAMN,EAASvpE,QAAQ,IAAK6pE,EAAM,MAEzB,IAATA,GAAcH,EAAMG,KACpBD,GAAe,EACvB,CACKA,IACDJ,EAAK,KAAKnK,EAAIqD,SACtB,CACJ,KACsB,KAAb6G,GAAmC,OAAhBA,EAAS,KACjCC,EAAK,IAaT,OAXAvxE,GAAOuxE,EAAKD,EACRlK,EAAI2G,OACAsD,GAAoBxE,GACpBA,IAECmE,IAAiBK,EACtBrxE,GAAO0qE,GAAY1qE,EAAKonE,EAAIqD,OAAQuC,EAAcgE,IAE7CE,GAAapE,GAClBA,IAEG9sE,CACX,CDrHc6xE,CAAc10E,KAAMiqE,EAAKyF,EAAWC,GACpCx/D,KAAKC,UAAUpQ,KACzB,EE5BJ,SAAS20E,GAAoBC,EAAY3K,EAAK16D,GAG1C,OAFa06D,EAAI2G,QAAUgE,EAAWX,KACbY,GAA0BC,IAClCF,EAAY3K,EAAK16D,EACtC,CACA,SAASulE,IAAyB,QAAE3uB,EAAO,MAAE4V,GAASkO,GAAK,gBAAE8K,EAAe,UAAEC,EAAS,WAAEC,EAAU,YAAEtF,EAAW,UAAED,IAC9G,MAAM,OAAEpC,EAAQ/9D,SAAS,cAAEsgE,IAAoB5F,EACzCiL,EAAU/yE,OAAO4H,OAAO,CAAC,EAAGkgE,EAAK,CAAEqD,OAAQ2H,EAAY/xE,KAAM,OACnE,IAAI6wE,GAAY,EAChB,MAAMxK,EAAQ,GACd,IAAK,IAAI1oE,EAAI,EAAGA,EAAIk7D,EAAMj3D,SAAUjE,EAAG,CACnC,MAAMq7D,EAAOH,EAAMl7D,GACnB,IAAIslD,EAAU,KACd,GAAIpxC,GAAOmnD,IACF6X,GAAa7X,EAAK8X,aACnBzK,EAAM7hE,KAAK,IACfytE,GAAiBlL,EAAKV,EAAOrN,EAAK+Q,cAAe8G,GAC7C7X,EAAK/V,UACLA,EAAU+V,EAAK/V,cAElB,GAAIqgB,GAAOtK,GAAO,CACnB,MAAMkZ,EAAKrgE,GAAOmnD,EAAKh3D,KAAOg3D,EAAKh3D,IAAM,KACrCkwE,KACKrB,GAAaqB,EAAGpB,aACjBzK,EAAM7hE,KAAK,IACfytE,GAAiBlL,EAAKV,EAAO6L,EAAGnI,cAAe8G,GAEvD,CACAA,GAAY,EACZ,IAAIlxE,EAAMuN,GAAU8rD,EAAMgZ,EAAS,IAAO/uB,EAAU,KAAO,IAAO4tB,GAAY,GAC1E5tB,IACAtjD,GAAO0qE,GAAY1qE,EAAKoyE,EAAYpF,EAAc1pB,KAClD4tB,GAAa5tB,IACb4tB,GAAY,GAChBxK,EAAM7hE,KAAKqtE,EAAkBlyE,EACjC,CACA,IAAIA,EACJ,GAAqB,IAAjB0mE,EAAMzkE,OACNjC,EAAMmyE,EAAUzhD,MAAQyhD,EAAUhxD,QAEjC,CACDnhB,EAAM0mE,EAAM,GACZ,IAAK,IAAI1oE,EAAI,EAAGA,EAAI0oE,EAAMzkE,SAAUjE,EAAG,CACnC,MAAM2W,EAAO+xD,EAAM1oE,GACnBgC,GAAO2U,EAAO,KAAK81D,IAAS91D,IAAS,IACzC,CACJ,CAQA,OAPI2uC,GACAtjD,GAAO,KAAOwqE,GAAcwC,EAAc1pB,GAAUmnB,GAChDoC,GACAA,KAECqE,GAAapE,GAClBA,IACG9sE,CACX,CACA,SAASgyE,IAAwB,MAAE9Y,GAASkO,GAAK,UAAE+K,EAAS,WAAEC,IAC1D,MAAM,OAAE3H,EAAM,WAAE2D,EAAYqB,sBAAuB+C,EAAW9lE,SAAS,cAAEsgE,IAAoB5F,EAC7FgL,GAAchE,EACd,MAAMiE,EAAU/yE,OAAO4H,OAAO,CAAC,EAAGkgE,EAAK,CACnCqD,OAAQ2H,EACRrE,QAAQ,EACR1tE,KAAM,OAEV,IAAIoyE,GAAa,EACbC,EAAe,EACnB,MAAMhM,EAAQ,GACd,IAAK,IAAI1oE,EAAI,EAAGA,EAAIk7D,EAAMj3D,SAAUjE,EAAG,CACnC,MAAMq7D,EAAOH,EAAMl7D,GACnB,IAAIslD,EAAU,KACd,GAAIpxC,GAAOmnD,GACHA,EAAK8X,aACLzK,EAAM7hE,KAAK,IACfytE,GAAiBlL,EAAKV,EAAOrN,EAAK+Q,eAAe,GAC7C/Q,EAAK/V,UACLA,EAAU+V,EAAK/V,cAElB,GAAIqgB,GAAOtK,GAAO,CACnB,MAAMkZ,EAAKrgE,GAAOmnD,EAAKh3D,KAAOg3D,EAAKh3D,IAAM,KACrCkwE,IACIA,EAAGpB,aACHzK,EAAM7hE,KAAK,IACfytE,GAAiBlL,EAAKV,EAAO6L,EAAGnI,eAAe,GAC3CmI,EAAGjvB,UACHmvB,GAAa,IAErB,MAAME,EAAKzgE,GAAOmnD,EAAK76D,OAAS66D,EAAK76D,MAAQ,KACzCm0E,GACIA,EAAGrvB,UACHA,EAAUqvB,EAAGrvB,SACbqvB,EAAGvI,gBACHqI,GAAa,IAEE,MAAdpZ,EAAK76D,OAAiB+zE,GAAIjvB,UAC/BA,EAAUivB,EAAGjvB,QAErB,CACIA,IACAmvB,GAAa,GACjB,IAAIzyE,EAAMuN,GAAU8rD,EAAMgZ,EAAS,IAAO/uB,EAAU,MAChDtlD,EAAIk7D,EAAMj3D,OAAS,IACnBjC,GAAO,KACPsjD,IACAtjD,GAAO0qE,GAAY1qE,EAAKoyE,EAAYpF,EAAc1pB,MACjDmvB,IAAe/L,EAAMzkE,OAASywE,GAAgB1yE,EAAI+d,SAAS,SAC5D00D,GAAa,GACjB/L,EAAM7hE,KAAK7E,GACX0yE,EAAehM,EAAMzkE,MACzB,CACA,MAAM,MAAEyuB,EAAK,IAAEvP,GAAQgxD,EACvB,GAAqB,IAAjBzL,EAAMzkE,OACN,OAAOyuB,EAAQvP,EAGf,IAAKsxD,EAAY,CACb,MAAMrwE,EAAMskE,EAAM3hC,OAAO,CAAC6tC,EAAKj+D,IAASi+D,EAAMj+D,EAAK1S,OAAS,EAAG,GAC/DwwE,EAAarL,EAAI16D,QAAQu+D,UAAY,GAAK7oE,EAAMglE,EAAI16D,QAAQu+D,SAChE,CACA,GAAIwH,EAAY,CACZ,IAAIzyE,EAAM0wB,EACV,IAAK,MAAM/b,KAAQ+xD,EACf1mE,GAAO2U,EAAO,KAAKy5D,IAAa3D,IAAS91D,IAAS,KACtD,MAAO,GAAG3U,MAAQyqE,IAAStpD,GAC/B,CAEI,MAAO,GAAGuP,IAAQ8hD,IAAY9L,EAAM76D,KAAK,OAAO2mE,IAAYrxD,GAGxE,CACA,SAASmxD,IAAiB,OAAE7H,EAAQ/9D,SAAS,cAAEsgE,IAAmBtG,EAAOpjB,EAAS4tB,GAG9E,GAFI5tB,GAAW4tB,IACX5tB,EAAUA,EAAQ58C,QAAQ,OAAQ,KAClC48C,EAAS,CACT,MAAMuvB,EAAKrI,GAAcwC,EAAc1pB,GAAUmnB,GACjD/D,EAAM7hE,KAAKguE,EAAGC,YAClB,CACJ,CCrIA,SAASC,GAAS7Z,EAAO72D,GACrB,MAAM4wD,EAAI2Q,GAASvhE,GAAOA,EAAI7D,MAAQ6D,EACtC,IAAK,MAAMunE,KAAM1Q,EACb,GAAIyK,GAAOiG,GAAK,CACZ,GAAIA,EAAGvnE,MAAQA,GAAOunE,EAAGvnE,MAAQ4wD,EAC7B,OAAO2W,EACX,GAAIhG,GAASgG,EAAGvnE,MAAQunE,EAAGvnE,IAAI7D,QAAUy0D,EACrC,OAAO2W,CACf,CAGR,CACA,MAAMoJ,WAAgB/N,GAClB,kBAAWqB,GACP,MAAO,uBACX,CACA1lE,WAAAA,CAAYomB,GACR0U,MAAMynC,GAAKn8C,GACX7pB,KAAK+7D,MAAQ,EACjB,CAKA,WAAOptD,CAAKkb,EAAQllB,EAAKslE,GACrB,MAAM,cAAEkC,EAAa,SAAE2J,GAAa7L,EAC9BxlE,EAAM,IAAIzE,KAAK6pB,GACfyY,EAAMA,CAACp9B,EAAK7D,KACd,GAAwB,mBAAby0E,EACPz0E,EAAQy0E,EAAShzE,KAAK6B,EAAKO,EAAK7D,QAC/B,GAAIgC,MAAMD,QAAQ0yE,KAAcA,EAASl1D,SAAS1b,GACnD,aACUwF,IAAVrJ,GAAuB8qE,IACvB1nE,EAAIs3D,MAAMr0D,KAAK4rE,GAAWpuE,EAAK7D,EAAO4oE,KAE9C,GAAItlE,aAAekjB,IACf,IAAK,MAAO3iB,EAAK7D,KAAUsD,EACvB29B,EAAIp9B,EAAK7D,QAEZ,GAAIsD,GAAsB,iBAARA,EACnB,IAAK,MAAMO,KAAO/C,OAAO4C,KAAKJ,GAC1B29B,EAAIp9B,EAAKP,EAAIO,IAKrB,MAHqC,mBAA1B2kB,EAAOksD,gBACdtxE,EAAIs3D,MAAMxmB,KAAK1rB,EAAOksD,gBAEnBtxE,CACX,CAOA69B,GAAAA,CAAIn3B,EAAM6qE,GACN,IAAIC,EAEAA,EADAzP,GAAOr7D,GACCA,EACFA,GAAwB,iBAATA,GAAuB,QAASA,EAK7C,IAAIi9D,GAAKj9D,EAAKjG,IAAKiG,EAAK9J,OAHxB,IAAI+mE,GAAKj9D,EAAMA,GAAM9J,OAIjC,MAAMmhC,EAAOozC,GAAS51E,KAAK+7D,MAAOka,EAAM/wE,KAClCgxE,EAAcl2E,KAAK6pB,QAAQksD,eACjC,GAAIvzC,EAAM,CACN,IAAKwzC,EACD,MAAM,IAAInqE,MAAM,OAAOoqE,EAAM/wE,mBAE7BuhE,GAASjkC,EAAKnhC,QAAUiqE,GAAc2K,EAAM50E,OAC5CmhC,EAAKnhC,MAAMA,MAAQ40E,EAAM50E,MAEzBmhC,EAAKnhC,MAAQ40E,EAAM50E,KAC3B,MACK,GAAI60E,EAAa,CAClB,MAAMr1E,EAAIb,KAAK+7D,MAAMtgB,UAAUygB,GAAQga,EAAYD,EAAO/Z,GAAQ,IACvD,IAAPr7D,EACAb,KAAK+7D,MAAMr0D,KAAKuuE,GAEhBj2E,KAAK+7D,MAAMhwC,OAAOlrB,EAAG,EAAGo1E,EAChC,MAEIj2E,KAAK+7D,MAAMr0D,KAAKuuE,EAExB,CACA79D,OAAOlT,GACH,MAAMunE,EAAKmJ,GAAS51E,KAAK+7D,MAAO72D,GAChC,QAAKunE,GAEOzsE,KAAK+7D,MAAMhwC,OAAO/rB,KAAK+7D,MAAMnxD,QAAQ6hE,GAAK,GAC3C3nE,OAAS,CACxB,CACA+S,GAAAA,CAAI3S,EAAK4nE,GACL,MAAML,EAAKmJ,GAAS51E,KAAK+7D,MAAO72D,GAC1B8tC,EAAOy5B,GAAIprE,MACjB,QAASyrE,GAAcrG,GAASzzB,GAAQA,EAAK3xC,MAAQ2xC,SAAStoC,CAClE,CACAwN,GAAAA,CAAIhT,GACA,QAAS0wE,GAAS51E,KAAK+7D,MAAO72D,EAClC,CACA0G,GAAAA,CAAI1G,EAAK7D,GACLrB,KAAKsiC,IAAI,IAAI8lC,GAAKljE,EAAK7D,IAAQ,EACnC,CAMAwM,MAAAA,CAAO0lE,EAAGtJ,EAAKkM,GACX,MAAM1xE,EAAM0xE,EAAO,IAAIA,EAASlM,GAAKO,SAAW,IAAI3iD,IAAQ,CAAC,EACzDoiD,GAAKG,UACLH,EAAIG,SAAS3lE,GACjB,IAAK,MAAMy3D,KAAQl8D,KAAK+7D,MACpBiW,GAAe/H,EAAKxlE,EAAKy3D,GAC7B,OAAOz3D,CACX,CACAvC,QAAAA,CAAS+nE,EAAKyF,EAAWC,GACrB,IAAK1F,EACD,OAAO95D,KAAKC,UAAUpQ,MAC1B,IAAK,MAAMk8D,KAAQl8D,KAAK+7D,MACpB,IAAKyK,GAAOtK,GACR,MAAM,IAAIrwD,MAAM,sCAAsCsE,KAAKC,UAAU8rD,cAI7E,OAFK+N,EAAIuJ,eAAiBxzE,KAAK+sE,kBAAiB,KAC5C9C,EAAM9nE,OAAO4H,OAAO,CAAC,EAAGkgE,EAAK,CAAEuJ,eAAe,KAC3CmB,GAAoB30E,KAAMiqE,EAAK,CAClC8K,gBAAiB,GACjBC,UAAW,CAAEzhD,MAAO,IAAKvP,IAAK,KAC9BixD,WAAYhL,EAAIqD,QAAU,GAC1BqC,cACAD,aAER,ECzIJ,MAAMjrE,GAAM,CACRmwE,WAAY,MACZvjD,SAAS,EACT26C,UAAW6J,GACXn1B,IAAK,wBACLrmC,QAAOA,CAAC5V,EAAKsvD,KACJwS,GAAM9hE,IACPsvD,EAAQ,mCACLtvD,GAEX8mE,WAAYA,CAAC1hD,EAAQllB,EAAKslE,IAAQ4L,GAAQlnE,KAAKkb,EAAQllB,EAAKslE,ICNhE,MAAMmM,WAAgBtO,GAClB,kBAAWqB,GACP,MAAO,uBACX,CACA1lE,WAAAA,CAAYomB,GACR0U,MAAM4nC,GAAKt8C,GACX7pB,KAAK+7D,MAAQ,EACjB,CACAz5B,GAAAA,CAAIjhC,GACArB,KAAK+7D,MAAMr0D,KAAKrG,EACpB,CASA+W,OAAOlT,GACH,MAAMmxE,EAAMC,GAAYpxE,GACxB,MAAmB,iBAARmxE,GAECr2E,KAAK+7D,MAAMhwC,OAAOsqD,EAAK,GACxBvxE,OAAS,CACxB,CACA+S,GAAAA,CAAI3S,EAAK4nE,GACL,MAAMuJ,EAAMC,GAAYpxE,GACxB,GAAmB,iBAARmxE,EACP,OACJ,MAAM5J,EAAKzsE,KAAK+7D,MAAMsa,GACtB,OAAQvJ,GAAcrG,GAASgG,GAAMA,EAAGprE,MAAQorE,CACpD,CAOAv0D,GAAAA,CAAIhT,GACA,MAAMmxE,EAAMC,GAAYpxE,GACxB,MAAsB,iBAARmxE,GAAoBA,EAAMr2E,KAAK+7D,MAAMj3D,MACvD,CAQA8G,GAAAA,CAAI1G,EAAK7D,GACL,MAAMg1E,EAAMC,GAAYpxE,GACxB,GAAmB,iBAARmxE,EACP,MAAM,IAAIxqE,MAAM,+BAA+B3G,MACnD,MAAMs9B,EAAOxiC,KAAK+7D,MAAMsa,GACpB5P,GAASjkC,IAAS8oC,GAAcjqE,GAChCmhC,EAAKnhC,MAAQA,EAEbrB,KAAK+7D,MAAMsa,GAAOh1E,CAC1B,CACAwM,MAAAA,CAAO0lE,EAAGtJ,GACN,MAAM3tB,EAAM,GACR2tB,GAAKG,UACLH,EAAIG,SAAS9tB,GACjB,IAAIz7C,EAAI,EACR,IAAK,MAAMq7D,KAAQl8D,KAAK+7D,MACpBzf,EAAI50C,KAAKsiE,GAAK9N,EAAMzxD,OAAO5J,KAAMopE,IACrC,OAAO3tB,CACX,CACAp6C,QAAAA,CAAS+nE,EAAKyF,EAAWC,GACrB,OAAK1F,EAEE0K,GAAoB30E,KAAMiqE,EAAK,CAClC8K,gBAAiB,KACjBC,UAAW,CAAEzhD,MAAO,IAAKvP,IAAK,KAC9BixD,YAAahL,EAAIqD,QAAU,IAAM,KACjCqC,cACAD,cANOv/D,KAAKC,UAAUpQ,KAQ9B,CACA,WAAO2O,CAAKkb,EAAQllB,EAAKslE,GACrB,MAAM,SAAE6L,GAAa7L,EACf3tB,EAAM,IAAIt8C,KAAK6pB,GACrB,GAAIllB,GAAOnC,OAAOF,YAAYH,OAAOwC,GAAM,CACvC,IAAI9D,EAAI,EACR,IAAK,IAAI4rE,KAAM9nE,EAAK,CAChB,GAAwB,mBAAbmxE,EAAyB,CAChC,MAAM5wE,EAAMP,aAAeywC,IAAMq3B,EAAKhiE,OAAO5J,KAC7C4rE,EAAKqJ,EAAShzE,KAAK6B,EAAKO,EAAKunE,EACjC,CACAnwB,EAAIyf,MAAMr0D,KAAK6jE,GAAWkB,OAAI/hE,EAAWu/D,GAC7C,CACJ,CACA,OAAO3tB,CACX,EAEJ,SAASg6B,GAAYpxE,GACjB,IAAImxE,EAAM5P,GAASvhE,GAAOA,EAAI7D,MAAQ6D,EAGtC,OAFImxE,GAAsB,iBAARA,IACdA,EAAM5pE,OAAO4pE,IACK,iBAARA,GAAoB5pE,OAAOy/D,UAAUmK,IAAQA,GAAO,EAC5DA,EACA,IACV,CC3GA,MAAM/5B,GAAM,CACRs4B,WAAY,MACZvjD,SAAS,EACT26C,UAAWoK,GACX11B,IAAK,wBACLrmC,QAAOA,CAACiiC,EAAKyX,KACJ2S,GAAMpqB,IACPyX,EAAQ,oCACLzX,GAEXivB,WAAYA,CAAC1hD,EAAQllB,EAAKslE,IAAQmM,GAAQznE,KAAKkb,EAAQllB,EAAKslE,ICX1Dh4C,GAAS,CACX65C,SAAUzqE,GAA0B,iBAAVA,EAC1BgwB,SAAS,EACTqvB,IAAK,wBACLrmC,QAASxX,GAAOA,EAChBuN,UAASA,CAAC8rD,EAAM+N,EAAKyF,EAAWC,IAErBgB,GAAgBzU,EADvB+N,EAAM9nE,OAAO4H,OAAO,CAAEinE,cAAc,GAAQ/G,GACVyF,EAAWC,ICP/C4G,GAAU,CACZzK,SAAUzqE,GAAkB,MAATA,EACnBkqE,WAAYA,IAAM,IAAIrD,GAAO,MAC7B72C,SAAS,EACTqvB,IAAK,yBACLtxC,KAAM,wBACNiL,QAASA,IAAM,IAAI6tD,GAAO,MAC1B93D,UAAWA,EAAG9I,UAAU2iE,IAA0B,iBAAX3iE,GAAuBivE,GAAQnnE,KAAKA,KAAK9H,GAC1EA,EACA2iE,EAAI16D,QAAQijE,SCThBgE,GAAU,CACZ1K,SAAUzqE,GAA0B,kBAAVA,EAC1BgwB,SAAS,EACTqvB,IAAK,yBACLtxC,KAAM,oCACNiL,QAASxX,GAAO,IAAIqlE,GAAkB,MAAXrlE,EAAI,IAAyB,MAAXA,EAAI,IACjDuN,UAASA,EAAC,OAAE9I,EAAM,MAAEjG,GAAS4oE,IACrB3iE,GAAUkvE,GAAQpnE,KAAKA,KAAK9H,IAExBjG,KADqB,MAAdiG,EAAO,IAA4B,MAAdA,EAAO,IAE5BA,EAERjG,EAAQ4oE,EAAI16D,QAAQmjE,QAAUzI,EAAI16D,QAAQ8iE,UCdzD,SAASoE,IAAgB,OAAEj+D,EAAM,kBAAEk+D,EAAiB,IAAEh2B,EAAG,MAAEr/C,IACvD,GAAqB,iBAAVA,EACP,OAAOoJ,OAAOpJ,GAClB,MAAMw7B,EAAuB,iBAAVx7B,EAAqBA,EAAQoL,OAAOpL,GACvD,IAAKqL,SAASmwB,GACV,OAAOp7B,MAAMo7B,GAAO,OAASA,EAAM,EAAI,QAAU,OACrD,IAAI9I,EAAI5xB,OAAOw0E,GAAGt1E,GAAQ,GAAK,KAAO8O,KAAKC,UAAU/O,GACrD,IAAKmX,GACDk+D,KACEh2B,GAAe,4BAARA,IACT,MAAMtxC,KAAK2kB,GAAI,CACf,IAAIlzB,EAAIkzB,EAAEnpB,QAAQ,KACd/J,EAAI,IACJA,EAAIkzB,EAAEjvB,OACNivB,GAAK,KAET,IAAIjzB,EAAI41E,GAAqB3iD,EAAEjvB,OAASjE,EAAI,GAC5C,KAAOC,KAAM,GACTizB,GAAK,GACb,CACA,OAAOA,CACX,CClBA,MAAM6iD,GAAW,CACb9K,SAAUzqE,GAA0B,iBAAVA,EAC1BgwB,SAAS,EACTqvB,IAAK,0BACLtxC,KAAM,iDACNiL,QAASxX,GAAuC,QAAhCA,EAAIE,OAAO,GAAGC,cACxBhC,IACW,MAAX6B,EAAI,GACA4J,OAAOoqE,kBACPpqE,OAAOqqE,kBACjB1mE,UAAWqmE,IAETM,GAAW,CACbjL,SAAUzqE,GAA0B,iBAAVA,EAC1BgwB,SAAS,EACTqvB,IAAK,0BACLloC,OAAQ,MACRpJ,KAAM,yDACNiL,QAASxX,GAAOm0E,WAAWn0E,GAC3BuN,SAAAA,CAAU4iC,GACN,MAAMnW,EAAMpwB,OAAOumC,EAAK3xC,OACxB,OAAOqL,SAASmwB,GAAOA,EAAIo6C,gBAAkBR,GAAgBzjC,EACjE,GCvBEkkC,GAAe71E,GAA2B,iBAAVA,GAAsBoL,OAAOy/D,UAAU7qE,GACvE81E,GAAaA,CAACt0E,EAAK1C,EAAQi3E,GAASC,iBAAmBA,EAAc7L,OAAO3oE,GAAOiyB,SAASjyB,EAAI4U,UAAUtX,GAASi3E,GACzH,SAASE,GAAatkC,EAAMokC,EAAOroB,GAC/B,MAAM,MAAE1tD,GAAU2xC,EAClB,OAAIkkC,GAAY71E,IAAUA,GAAS,EACxB0tD,EAAS1tD,EAAMa,SAASk1E,GAC5BX,GAAgBzjC,EAC3B,CACA,MCFMnpB,GAAS,CACXplB,GACA63C,GACArqB,GACAskD,GACAC,GDHW,CACX1K,SAAUzqE,GAAS61E,GAAY71E,IAAUA,GAAS,EAClDgwB,SAAS,EACTqvB,IAAK,wBACLloC,OAAQ,MACRpJ,KAAM,aACNiL,QAASA,CAACxX,EAAK00E,EAAUnuD,IAAQ+tD,GAAWt0E,EAAK,EAAG,EAAGumB,GACvDhZ,UAAW4iC,GAAQskC,GAAatkC,EAAM,EAAG,OAEjC,CACR84B,SAAUoL,GACV7lD,SAAS,EACTqvB,IAAK,wBACLtxC,KAAM,gBACNiL,QAASA,CAACxX,EAAK00E,EAAUnuD,IAAQ+tD,GAAWt0E,EAAK,EAAG,GAAIumB,GACxDhZ,UAAWqmE,IAEA,CACX3K,SAAUzqE,GAAS61E,GAAY71E,IAAUA,GAAS,EAClDgwB,SAAS,EACTqvB,IAAK,wBACLloC,OAAQ,MACRpJ,KAAM,mBACNiL,QAASA,CAACxX,EAAK00E,EAAUnuD,IAAQ+tD,GAAWt0E,EAAK,EAAG,GAAIumB,GACxDhZ,UAAW4iC,GAAQskC,GAAatkC,EAAM,GAAI,OCjB1C4jC,GACAG,GFSU,CACVjL,SAAUzqE,GAA0B,iBAAVA,EAC1BgwB,SAAS,EACTqvB,IAAK,0BACLtxC,KAAM,qCACNiL,OAAAA,CAAQxX,GACJ,MAAMmwC,EAAO,IAAIk1B,GAAO8O,WAAWn0E,IAC7B20E,EAAM30E,EAAI+H,QAAQ,KAGxB,OAFa,IAAT4sE,GAAsC,MAAxB30E,EAAIA,EAAIiC,OAAS,KAC/BkuC,EAAK0jC,kBAAoB7zE,EAAIiC,OAAS0yE,EAAM,GACzCxkC,CACX,EACA5iC,UAAWqmE,KGnCf,SAASS,GAAY71E,GACjB,MAAwB,iBAAVA,GAAsBoL,OAAOy/D,UAAU7qE,EACzD,CACA,MAAMo2E,GAAgBA,EAAGp2E,WAAY8O,KAAKC,UAAU/O,GAoD9CwoB,GAAS,CAACplB,GAAK63C,IAAK7tC,OAnDN,CAChB,CACIq9D,SAAUzqE,GAA0B,iBAAVA,EAC1BgwB,SAAS,EACTqvB,IAAK,wBACLrmC,QAASxX,GAAOA,EAChBuN,UAAWqnE,IAEf,CACI3L,SAAUzqE,GAAkB,MAATA,EACnBkqE,WAAYA,IAAM,IAAIrD,GAAO,MAC7B72C,SAAS,EACTqvB,IAAK,yBACLtxC,KAAM,SACNiL,QAASA,IAAM,KACfjK,UAAWqnE,IAEf,CACI3L,SAAUzqE,GAA0B,kBAAVA,EAC1BgwB,SAAS,EACTqvB,IAAK,yBACLtxC,KAAM,iBACNiL,QAASxX,GAAe,SAARA,EAChBuN,UAAWqnE,IAEf,CACI3L,SAAUoL,GACV7lD,SAAS,EACTqvB,IAAK,wBACLtxC,KAAM,wBACNiL,QAASA,CAACxX,EAAK00E,GAAYF,iBAAkBA,EAAc7L,OAAO3oE,GAAOiyB,SAASjyB,EAAK,IACvFuN,UAAWA,EAAG/O,WAAY61E,GAAY71E,GAASA,EAAMa,WAAaiO,KAAKC,UAAU/O,IAErF,CACIyqE,SAAUzqE,GAA0B,iBAAVA,EAC1BgwB,SAAS,EACTqvB,IAAK,0BACLtxC,KAAM,yDACNiL,QAASxX,GAAOm0E,WAAWn0E,GAC3BuN,UAAWqnE,KAGD,CACdpmD,SAAS,EACTqvB,IAAK,GACLtxC,KAAM,IACNiL,QAAOA,CAACxX,EAAKkxD,KACTA,EAAQ,2BAA2B5jD,KAAKC,UAAUvN,MAC3CA,KCrDT60E,GAAS,CACX5L,SAAUzqE,GAASA,aAAiByE,WACpCurB,SAAS,EACTqvB,IAAK,2BASLrmC,OAAAA,CAAQohB,EAAKs4B,GACT,GAAoB,mBAAT4jB,KAAqB,CAE5B,MAAM90E,EAAM80E,KAAKl8C,EAAIlyB,QAAQ,UAAW,KAClCrJ,EAAS,IAAI4F,WAAWjD,EAAIiC,QAClC,IAAK,IAAIjE,EAAI,EAAGA,EAAIgC,EAAIiC,SAAUjE,EAC9BX,EAAOW,GAAKgC,EAAI6G,WAAW7I,GAC/B,OAAOX,CACX,CAGI,OADA6zD,EAAQ,4FACDt4B,CAEf,EACArrB,SAAAA,EAAU,QAAE+1C,EAAO,KAAEjjD,EAAI,MAAE7B,GAAS4oE,EAAKyF,EAAWC,GAChD,IAAKtuE,EACD,MAAO,GACX,MAAMuwB,EAAMvwB,EACZ,IAAIwB,EACJ,GAAoB,mBAATwd,KAOP,MAAM,IAAIxU,MAAM,4FAPY,CAC5B,IAAI9K,EAAI,GACR,IAAK,IAAIF,EAAI,EAAGA,EAAI+wB,EAAI9sB,SAAUjE,EAC9BE,GAAK0J,OAAO6rB,aAAa1E,EAAI/wB,IACjCgC,EAAMwd,KAAKtf,EACf,CAKA,GADAmC,IAASA,EAAOglE,GAAOmE,eACnBnpE,IAASglE,GAAOqE,aAAc,CAC9B,MAAMuB,EAAY5sE,KAAKy2B,IAAIsyC,EAAI16D,QAAQu+D,UAAY7D,EAAIqD,OAAOxoE,OAAQmlE,EAAI16D,QAAQw+D,iBAC5Eh6C,EAAI7yB,KAAK4iC,KAAKjhC,EAAIiC,OAASgpE,GAC3BvE,EAAQ,IAAIlmE,MAAM0wB,GACxB,IAAK,IAAIlzB,EAAI,EAAGw8B,EAAI,EAAGx8B,EAAIkzB,IAAKlzB,EAAGw8B,GAAKywC,EACpCvE,EAAM1oE,GAAKgC,EAAIkyB,OAAOsI,EAAGywC,GAE7BjrE,EAAM0mE,EAAM76D,KAAKxL,IAASglE,GAAOmE,cAAgB,KAAO,IAC5D,CACA,OAAOsE,GAAgB,CAAExqB,UAASjjD,OAAM7B,MAAOwB,GAAOonE,EAAKyF,EAAWC,EAC1E,GCjDJ,SAASiI,GAAat7B,EAAKyX,GACvB,GAAI2S,GAAMpqB,GACN,IAAK,IAAIz7C,EAAI,EAAGA,EAAIy7C,EAAIyf,MAAMj3D,SAAUjE,EAAG,CACvC,IAAIq7D,EAAO5f,EAAIyf,MAAMl7D,GACrB,IAAI2lE,GAAOtK,GAAX,CAEK,GAAIqK,GAAMrK,GAAO,CACdA,EAAKH,MAAMj3D,OAAS,GACpBivD,EAAQ,kDACZ,MAAM5oD,EAAO+wD,EAAKH,MAAM,IAAM,IAAIqM,GAAK,IAAIF,GAAO,OAKlD,GAJIhM,EAAK+Q,gBACL9hE,EAAKjG,IAAI+nE,cAAgB9hE,EAAKjG,IAAI+nE,cAC5B,GAAG/Q,EAAK+Q,kBAAkB9hE,EAAKjG,IAAI+nE,gBACnC/Q,EAAK+Q,eACX/Q,EAAK/V,QAAS,CACd,MAAM0xB,EAAK1sE,EAAK9J,OAAS8J,EAAKjG,IAC9B2yE,EAAG1xB,QAAU0xB,EAAG1xB,QACV,GAAG+V,EAAK/V,YAAY0xB,EAAG1xB,UACvB+V,EAAK/V,OACf,CACA+V,EAAO/wD,CACX,CACAmxC,EAAIyf,MAAMl7D,GAAK2lE,GAAOtK,GAAQA,EAAO,IAAIkM,GAAKlM,EAD9C,CAEJ,MAGAnI,EAAQ,oCACZ,OAAOzX,CACX,CACA,SAASw7B,GAAYjuD,EAAQtF,EAAU0lD,GACnC,MAAM,SAAE6L,GAAa7L,EACf8N,EAAQ,IAAI3B,GAAQvsD,GAC1BkuD,EAAMr3B,IAAM,0BACZ,IAAI7/C,EAAI,EACR,GAAI0jB,GAAY/hB,OAAOF,YAAYH,OAAOoiB,GACtC,IAAK,IAAIkoD,KAAMloD,EAAU,CAGrB,IAAIrf,EAAK7D,EACT,GAHwB,mBAAby0E,IACPrJ,EAAKqJ,EAAShzE,KAAKyhB,EAAU9Z,OAAO5J,KAAM4rE,IAE1CppE,MAAMD,QAAQqpE,GAAK,CACnB,GAAkB,IAAdA,EAAG3nE,OAKH,MAAM,IAAI0K,UAAU,gCAAgCi9D,KAJpDvnE,EAAMunE,EAAG,GACTprE,EAAQorE,EAAG,EAInB,MACK,GAAIA,GAAMA,aAActqE,OAAQ,CACjC,MAAM4C,EAAO5C,OAAO4C,KAAK0nE,GACzB,GAAoB,IAAhB1nE,EAAKD,OAKL,MAAM,IAAI0K,UAAU,oCAAoCzK,EAAKD,eAJ7DI,EAAMH,EAAK,GACX1D,EAAQorE,EAAGvnE,EAKnB,MAEIA,EAAMunE,EAEVsL,EAAMhc,MAAMr0D,KAAK4rE,GAAWpuE,EAAK7D,EAAO4oE,GAC5C,CACJ,OAAO8N,CACX,CACA,MAAMA,GAAQ,CACVnD,WAAY,MACZvjD,SAAS,EACTqvB,IAAK,0BACLrmC,QAASu9D,GACTrM,WAAYuM,ICpEhB,MAAME,WAAiB5B,GACnB3yE,WAAAA,GACI86B,QACAv+B,KAAKsiC,IAAMuzC,GAAQzzE,UAAUkgC,IAAIzgC,KAAK7B,MACtCA,KAAKoY,OAASy9D,GAAQzzE,UAAUgW,OAAOvW,KAAK7B,MAC5CA,KAAK6X,IAAMg+D,GAAQzzE,UAAUyV,IAAIhW,KAAK7B,MACtCA,KAAKkY,IAAM29D,GAAQzzE,UAAU8V,IAAIrW,KAAK7B,MACtCA,KAAK4L,IAAMiqE,GAAQzzE,UAAUwJ,IAAI/J,KAAK7B,MACtCA,KAAK0gD,IAAMs3B,GAASt3B,GACxB,CAKA7yC,MAAAA,CAAO0lE,EAAGtJ,GACN,IAAKA,EACD,OAAO1rC,MAAM1wB,OAAO0lE,GACxB,MAAM9uE,EAAM,IAAIojB,IACZoiD,GAAKG,UACLH,EAAIG,SAAS3lE,GACjB,IAAK,MAAM0G,KAAQnL,KAAK+7D,MAAO,CAC3B,IAAI72D,EAAK7D,EAQT,GAPImlE,GAAOr7D,IACPjG,EAAM8kE,GAAK7+D,EAAKjG,IAAK,GAAI+kE,GACzB5oE,EAAQ2oE,GAAK7+D,EAAK9J,MAAO6D,EAAK+kE,IAG9B/kE,EAAM8kE,GAAK7+D,EAAM,GAAI8+D,GAErBxlE,EAAIyT,IAAIhT,GACR,MAAM,IAAI2G,MAAM,gDACpBpH,EAAImH,IAAI1G,EAAK7D,EACjB,CACA,OAAOoD,CACX,CACA,WAAOkK,CAAKkb,EAAQtF,EAAU0lD,GAC1B,MAAM8N,EAAQD,GAAYjuD,EAAQtF,EAAU0lD,GACtCgO,EAAO,IAAIj4E,KAEjB,OADAi4E,EAAKlc,MAAQgc,EAAMhc,MACZkc,CACX,EAEJD,GAASt3B,IAAM,yBACf,MAAMu3B,GAAO,CACTrD,WAAY,MACZ9I,SAAUzqE,GAASA,aAAiBwmB,IACpCmkD,UAAWgM,GACX3mD,SAAS,EACTqvB,IAAK,yBACLrmC,OAAAA,CAAQiiC,EAAKyX,GACT,MAAMgkB,EAAQH,GAAat7B,EAAKyX,GAC1BmkB,EAAW,GACjB,IAAK,MAAM,IAAEhzE,KAAS6yE,EAAMhc,MACpB0K,GAASvhE,KACLgzE,EAASt3D,SAAS1b,EAAI7D,OACtB0yD,EAAQ,iDAAiD7uD,EAAI7D,SAG7D62E,EAASxwE,KAAKxC,EAAI7D,QAI9B,OAAOc,OAAO4H,OAAO,IAAIiuE,GAAYD,EACzC,EACAxM,WAAYA,CAAC1hD,EAAQtF,EAAU0lD,IAAQ+N,GAASrpE,KAAKkb,EAAQtF,EAAU0lD,ICpE3E,SAASkO,IAAc,MAAE92E,EAAK,OAAEiG,GAAU2iE,GAEtC,OAAI3iE,IADYjG,EAAQ+2E,GAAUC,IACZjpE,KAAKA,KAAK9H,GACrBA,EACJjG,EAAQ4oE,EAAI16D,QAAQmjE,QAAUzI,EAAI16D,QAAQ8iE,QACrD,CACA,MAAM+F,GAAU,CACZtM,SAAUzqE,IAAmB,IAAVA,EACnBgwB,SAAS,EACTqvB,IAAK,yBACLtxC,KAAM,6CACNiL,QAASA,IAAM,IAAI6tD,IAAO,GAC1B93D,UAAW+nE,IAETE,GAAW,CACbvM,SAAUzqE,IAAmB,IAAVA,EACnBgwB,SAAS,EACTqvB,IAAK,yBACLtxC,KAAM,+CACNiL,QAASA,IAAM,IAAI6tD,IAAO,GAC1B93D,UAAW+nE,ICnBTvB,GAAW,CACb9K,SAAUzqE,GAA0B,iBAAVA,EAC1BgwB,SAAS,EACTqvB,IAAK,0BACLtxC,KAAM,iDACNiL,QAAUxX,GAAwC,QAAhCA,EAAIE,OAAO,GAAGC,cAC1BhC,IACW,MAAX6B,EAAI,GACA4J,OAAOoqE,kBACPpqE,OAAOqqE,kBACjB1mE,UAAWqmE,IAETM,GAAW,CACbjL,SAAUzqE,GAA0B,iBAAVA,EAC1BgwB,SAAS,EACTqvB,IAAK,0BACLloC,OAAQ,MACRpJ,KAAM,wDACNiL,QAAUxX,GAAQm0E,WAAWn0E,EAAI0G,QAAQ,KAAM,KAC/C6G,SAAAA,CAAU4iC,GACN,MAAMnW,EAAMpwB,OAAOumC,EAAK3xC,OACxB,OAAOqL,SAASmwB,GAAOA,EAAIo6C,gBAAkBR,GAAgBzjC,EACjE,GAEEslC,GAAQ,CACVxM,SAAUzqE,GAA0B,iBAAVA,EAC1BgwB,SAAS,EACTqvB,IAAK,0BACLtxC,KAAM,oCACNiL,OAAAA,CAAQxX,GACJ,MAAMmwC,EAAO,IAAIk1B,GAAO8O,WAAWn0E,EAAI0G,QAAQ,KAAM,MAC/CiuE,EAAM30E,EAAI+H,QAAQ,KACxB,IAAa,IAAT4sE,EAAY,CACZ,MAAMe,EAAI11E,EAAI4U,UAAU+/D,EAAM,GAAGjuE,QAAQ,KAAM,IACvB,MAApBgvE,EAAEA,EAAEzzE,OAAS,KACbkuC,EAAK0jC,kBAAoB6B,EAAEzzE,OACnC,CACA,OAAOkuC,CACX,EACA5iC,UAAWqmE,ICxCTS,GAAe71E,GAA2B,iBAAVA,GAAsBoL,OAAOy/D,UAAU7qE,GAC7E,SAAS81E,GAAWt0E,EAAK1C,EAAQi3E,GAAO,YAAEC,IACtC,MAAMmB,EAAO31E,EAAI,GAIjB,GAHa,MAAT21E,GAAyB,MAATA,IAChBr4E,GAAU,GACd0C,EAAMA,EAAI4U,UAAUtX,GAAQoJ,QAAQ,KAAM,IACtC8tE,EAAa,CACb,OAAQD,GACJ,KAAK,EACDv0E,EAAM,KAAKA,IACX,MACJ,KAAK,EACDA,EAAM,KAAKA,IACX,MACJ,KAAK,GACDA,EAAM,KAAKA,IAGnB,MAAMkxB,EAAIy3C,OAAO3oE,GACjB,MAAgB,MAAT21E,EAAehN,QAAQ,GAAKz3C,EAAIA,CAC3C,CACA,MAAMA,EAAIe,SAASjyB,EAAKu0E,GACxB,MAAgB,MAAToB,GAAgB,EAAIzkD,EAAIA,CACnC,CACA,SAASujD,GAAatkC,EAAMokC,EAAOroB,GAC/B,MAAM,MAAE1tD,GAAU2xC,EAClB,GAAIkkC,GAAY71E,GAAQ,CACpB,MAAMwB,EAAMxB,EAAMa,SAASk1E,GAC3B,OAAO/1E,EAAQ,EAAI,IAAM0tD,EAASlsD,EAAIkyB,OAAO,GAAKg6B,EAASlsD,CAC/D,CACA,OAAO4zE,GAAgBzjC,EAC3B,CACA,MAAMylC,GAAS,CACX3M,SAAUoL,GACV7lD,SAAS,EACTqvB,IAAK,wBACLloC,OAAQ,MACRpJ,KAAM,mBACNiL,QAASA,CAACxX,EAAK00E,EAAUnuD,IAAQ+tD,GAAWt0E,EAAK,EAAG,EAAGumB,GACvDhZ,UAAW4iC,GAAQskC,GAAatkC,EAAM,EAAG,OAEvC0lC,GAAS,CACX5M,SAAUoL,GACV7lD,SAAS,EACTqvB,IAAK,wBACLloC,OAAQ,MACRpJ,KAAM,kBACNiL,QAASA,CAACxX,EAAK00E,EAAUnuD,IAAQ+tD,GAAWt0E,EAAK,EAAG,EAAGumB,GACvDhZ,UAAW4iC,GAAQskC,GAAatkC,EAAM,EAAG,MAEvC2lC,GAAM,CACR7M,SAAUoL,GACV7lD,SAAS,EACTqvB,IAAK,wBACLtxC,KAAM,sBACNiL,QAASA,CAACxX,EAAK00E,EAAUnuD,IAAQ+tD,GAAWt0E,EAAK,EAAG,GAAIumB,GACxDhZ,UAAWqmE,IAETmC,GAAS,CACX9M,SAAUoL,GACV7lD,SAAS,EACTqvB,IAAK,wBACLloC,OAAQ,MACRpJ,KAAM,yBACNiL,QAASA,CAACxX,EAAK00E,EAAUnuD,IAAQ+tD,GAAWt0E,EAAK,EAAG,GAAIumB,GACxDhZ,UAAW4iC,GAAQskC,GAAatkC,EAAM,GAAI,OC/D9C,MAAM6lC,WAAgBhD,GAClBpyE,WAAAA,CAAYomB,GACR0U,MAAM1U,GACN7pB,KAAK0gD,IAAMm4B,GAAQn4B,GACvB,CACApe,GAAAA,CAAIp9B,GACA,IAAIiG,EAEAA,EADAq7D,GAAOthE,GACAA,EACFA,GACU,iBAARA,GACP,QAASA,GACT,UAAWA,GACG,OAAdA,EAAI7D,MACG,IAAI+mE,GAAKljE,EAAIA,IAAK,MAElB,IAAIkjE,GAAKljE,EAAK,MACZ0wE,GAAS51E,KAAK+7D,MAAO5wD,EAAKjG,MAEnClF,KAAK+7D,MAAMr0D,KAAKyD,EACxB,CAKA0M,GAAAA,CAAI3S,EAAK4zE,GACL,MAAM3tE,EAAOyqE,GAAS51E,KAAK+7D,MAAO72D,GAClC,OAAQ4zE,GAAYtS,GAAOr7D,GACrBs7D,GAASt7D,EAAKjG,KACViG,EAAKjG,IAAI7D,MACT8J,EAAKjG,IACTiG,CACV,CACAS,GAAAA,CAAI1G,EAAK7D,GACL,GAAqB,kBAAVA,EACP,MAAM,IAAIwK,MAAM,wEAAwExK,GAC5F,MAAMmhC,EAAOozC,GAAS51E,KAAK+7D,MAAO72D,GAC9Bs9B,IAASnhC,EACTrB,KAAK+7D,MAAMhwC,OAAO/rB,KAAK+7D,MAAMnxD,QAAQ43B,GAAO,IAEtCA,GAAQnhC,GACdrB,KAAK+7D,MAAMr0D,KAAK,IAAI0gE,GAAKljE,GAEjC,CACA2I,MAAAA,CAAO0lE,EAAGtJ,GACN,OAAO1rC,MAAM1wB,OAAO0lE,EAAGtJ,EAAK70B,IAChC,CACAlzC,QAAAA,CAAS+nE,EAAKyF,EAAWC,GACrB,IAAK1F,EACD,OAAO95D,KAAKC,UAAUpQ,MAC1B,GAAIA,KAAK+sE,kBAAiB,GACtB,OAAOxuC,MAAMr8B,SAASC,OAAO4H,OAAO,CAAC,EAAGkgE,EAAK,CAAEuJ,eAAe,IAAS9D,EAAWC,GAElF,MAAM,IAAI9jE,MAAM,sCACxB,CACA,WAAO8C,CAAKkb,EAAQtF,EAAU0lD,GAC1B,MAAM,SAAE6L,GAAa7L,EACfr+D,EAAM,IAAI5L,KAAK6pB,GACrB,GAAItF,GAAY/hB,OAAOF,YAAYH,OAAOoiB,GACtC,IAAK,IAAIljB,KAASkjB,EACU,mBAAbuxD,IACPz0E,EAAQy0E,EAAShzE,KAAKyhB,EAAUljB,EAAOA,IAC3CuK,EAAImwD,MAAMr0D,KAAK4rE,GAAWjyE,EAAO,KAAM4oE,IAE/C,OAAOr+D,CACX,EAEJitE,GAAQn4B,IAAM,wBACd,MAAM90C,GAAM,CACRgpE,WAAY,MACZ9I,SAAUzqE,GAASA,aAAiB+zC,IACpC42B,UAAW6M,GACXxnD,SAAS,EACTqvB,IAAK,wBACL6qB,WAAYA,CAAC1hD,EAAQtF,EAAU0lD,IAAQ4O,GAAQlqE,KAAKkb,EAAQtF,EAAU0lD,GACtE5vD,OAAAA,CAAQ5V,EAAKsvD,GACT,GAAIwS,GAAM9hE,GAAM,CACZ,GAAIA,EAAIsoE,kBAAiB,GACrB,OAAO5qE,OAAO4H,OAAO,IAAI8uE,GAAWp0E,GAEpCsvD,EAAQ,sCAChB,MAEIA,EAAQ,mCACZ,OAAOtvD,CACX,GCtFJ,SAASs0E,GAAiBl2E,EAAKm2E,GAC3B,MAAMR,EAAO31E,EAAI,GACX05B,EAAiB,MAATi8C,GAAyB,MAATA,EAAe31E,EAAI4U,UAAU,GAAK5U,EAC1Dg6B,EAAO9I,GAAMilD,EAAWxN,OAAOz3C,GAAKtnB,OAAOsnB,GAC3CtN,EAAM8V,EACPhzB,QAAQ,KAAM,IACd0C,MAAM,KACN27B,OAAO,CAACnhB,EAAKogB,IAAMpgB,EAAMoW,EAAI,IAAMA,EAAIgK,GAAIhK,EAAI,IACpD,MAAiB,MAAT27C,EAAe37C,GAAK,GAAKpW,EAAMA,CAC3C,CAMA,SAASwyD,GAAqBjmC,GAC1B,IAAI,MAAE3xC,GAAU2xC,EACZnW,EAAO9I,GAAMA,EACjB,GAAqB,iBAAV1yB,EACPw7B,EAAM9I,GAAKy3C,OAAOz3C,QACjB,GAAItyB,MAAMJ,KAAWqL,SAASrL,GAC/B,OAAOo1E,GAAgBzjC,GAC3B,IAAIwlC,EAAO,GACPn3E,EAAQ,IACRm3E,EAAO,IACPn3E,GAASw7B,GAAK,IAElB,MAAMq8C,EAAMr8C,EAAI,IACVN,EAAQ,CAACl7B,EAAQ63E,GAYvB,OAXI73E,EAAQ,GACRk7B,EAAMxR,QAAQ,IAGd1pB,GAASA,EAAQk7B,EAAM,IAAM28C,EAC7B38C,EAAMxR,QAAQ1pB,EAAQ63E,GAClB73E,GAAS,KACTA,GAASA,EAAQk7B,EAAM,IAAM28C,EAC7B38C,EAAMxR,QAAQ1pB,KAGdm3E,EACJj8C,EACK93B,IAAIsvB,GAAKtpB,OAAOspB,GAAGolD,SAAS,EAAG,MAC/BzqE,KAAK,KACLnF,QAAQ,aAAc,GAEnC,CACA,MAAM6vE,GAAU,CACZtN,SAAUzqE,GAA0B,iBAAVA,GAAsBoL,OAAOy/D,UAAU7qE,GACjEgwB,SAAS,EACTqvB,IAAK,wBACLloC,OAAQ,OACRpJ,KAAM,uCACNiL,QAASA,CAACxX,EAAK00E,GAAYF,iBAAkB0B,GAAiBl2E,EAAKw0E,GACnEjnE,UAAW6oE,IAETI,GAAY,CACdvN,SAAUzqE,GAA0B,iBAAVA,EAC1BgwB,SAAS,EACTqvB,IAAK,0BACLloC,OAAQ,OACRpJ,KAAM,gDACNiL,QAASxX,GAAOk2E,GAAiBl2E,GAAK,GACtCuN,UAAW6oE,IAETl9D,GAAY,CACd+vD,SAAUzqE,GAASA,aAAiBka,KACpC8V,SAAS,EACTqvB,IAAK,8BAILtxC,KAAM2O,OAAO,6JAMb1D,OAAAA,CAAQxX,GACJ,MAAMkO,EAAQlO,EAAIkO,MAAMgL,GAAU3M,MAClC,IAAK2B,EACD,MAAM,IAAIlF,MAAM,wDACpB,MAAO,CAAEytE,EAAMC,EAAOC,EAAKC,EAAMC,EAAQC,GAAU5oE,EAAMtM,IAAIgI,QACvDmtE,EAAW7oE,EAAM,GAAKtE,QAAQsE,EAAM,GAAK,MAAMgkB,OAAO,EAAG,IAAM,EACrE,IAAI8kD,EAAOt+D,KAAKu+D,IAAIR,EAAMC,EAAQ,EAAGC,EAAKC,GAAQ,EAAGC,GAAU,EAAGC,GAAU,EAAGC,GAC/E,MAAMG,EAAKhpE,EAAM,GACjB,GAAIgpE,GAAa,MAAPA,EAAY,CAClB,IAAIj5E,EAAIi4E,GAAiBgB,GAAI,GACzB74E,KAAKM,IAAIV,GAAK,KACdA,GAAK,IACT+4E,GAAQ,IAAQ/4E,CACpB,CACA,OAAO,IAAIya,KAAKs+D,EACpB,EACAzpE,UAAWA,EAAG/O,WAAYA,GAAO4O,cAAc1G,QAAQ,sBAAuB,KAAO,ICnFnFsgB,GAAS,CACXplB,GACA63C,GACArqB,GACAskD,GACA6B,GACAC,GACAI,GACAC,GACAC,GACAC,GACAhC,GACAG,GACAuB,GACAZ,GACA5uE,GACAmvE,GACAF,GACAnsE,GACAwtE,GACAC,GACAt9D,IClBY,IAAI8L,IAAI,CACpB,CAAC,OAAQgC,IACT,CAAC,WAAY,CAACplB,GAAK63C,GAAKrqB,KACxB,CAAC,OAAQ+nD,IACT,CAAC,SAAUC,IACX,CAAC,WAAYA,MCtBOpuE,MCAxB,MAAMi7D,GAAQtkE,OAAO,eACfukE,GAAOvkE,OAAO,iBACdwkE,GAASxkE,OAAO,eA6BtB,SAASsK,GAAMotE,EAAKtqE,GACZ,SAAUsqE,GAAoB,aAAbA,EAAIh3E,OACrBg3E,EAAM,CAAE3mD,MAAO2mD,EAAI3mD,MAAOlyB,MAAO64E,EAAI74E,QACzC84E,GAAOh4E,OAAOklE,OAAO,IAAK6S,EAAKtqE,EACnC,CAoCA,SAASuqE,GAAO5rE,EAAM2tD,EAAMtsD,GACxB,IAAI03D,EAAO13D,EAAQssD,EAAM3tD,GACzB,GAAoB,iBAAT+4D,EACP,OAAOA,EACX,IAAK,MAAM8S,IAAS,CAAC,MAAO,SAAU,CAClC,MAAMlzE,EAAQg1D,EAAKke,GACnB,GAAIlzE,GAAS,UAAWA,EAAO,CAC3B,IAAK,IAAIrG,EAAI,EAAGA,EAAIqG,EAAM60D,MAAMj3D,SAAUjE,EAAG,CACzC,MAAM4mE,EAAK0S,GAAOh4E,OAAOklE,OAAO94D,EAAKE,OAAO,CAAC,CAAC2rE,EAAOv5E,MAAOqG,EAAM60D,MAAMl7D,GAAI+O,GAC5E,GAAkB,iBAAP63D,EACP5mE,EAAI4mE,EAAK,MACR,IAAIA,IAAOX,GACZ,OAAOA,GACFW,IAAOT,KACZ9/D,EAAM60D,MAAMhwC,OAAOlrB,EAAG,GACtBA,GAAK,EACT,CACJ,CACoB,mBAATymE,GAAiC,QAAV8S,IAC9B9S,EAAOA,EAAKpL,EAAM3tD,GAC1B,CACJ,CACA,MAAuB,mBAAT+4D,EAAsBA,EAAKpL,EAAM3tD,GAAQ+4D,CAC3D,CC5FO,IAAK+S,GDsCZvtE,GAAMg6D,MAAQA,GAEdh6D,GAAMi6D,KAAOA,GAEbj6D,GAAMk6D,OAASA,GAEfl6D,GAAMwtE,WAAa,CAACJ,EAAK3rE,KACrB,IAAI2tD,EAAOge,EACX,IAAK,MAAOE,EAAO5pE,KAAUjC,EAAM,CAC/B,MAAM+gD,EAAM4M,IAAOke,GACnB,IAAI9qB,KAAO,UAAWA,GAIlB,OAHA4M,EAAO5M,EAAIyM,MAAMvrD,EAIzB,CACA,OAAO0rD,GAOXpvD,GAAMytE,iBAAmB,CAACL,EAAK3rE,KAC3B,MAAMuvB,EAAShxB,GAAMwtE,WAAWJ,EAAK3rE,EAAKxL,MAAM,GAAI,IAC9Cq3E,EAAQ7rE,EAAKA,EAAKzJ,OAAS,GAAG,GAC9B01E,EAAO18C,IAASs8C,GACtB,GAAII,GAAQ,UAAWA,EACnB,OAAOA,EACX,MAAM,IAAI3uE,MAAM,gCEYF,IAAIupC,IAAI,0BACT,IAAIA,IAAI,qFACE,IAAIA,IAAI,SACR,IAAIA,IAAI,gB3DjFvBvP,EAAiBH,I0DD7B,SAAY20C,GAGVA,EAAA,sBAGAA,EAAA,cAGAA,EAAA,sBAGAA,EAAA,8BAGAA,EAAA,uBAIAA,EAAA,6BAGAA,EAAA,cAOAA,EAAA,kBAGAA,EAAA,yBAGAA,EAAA,2BAIAA,EAAA,iBACD,CAxCD,CAAYA,KAAAA,GAAU,KEQhB,MAAgBI,GAAtBh3E,WAAAA,GAEW,KAAAi3E,QAAkBD,GAAMvtC,YASvB,KAAAytC,GAAoB,KACpB,KAAAC,GAAoB,KACpB,KAAAC,OAAwB,KACxB,KAAAC,QAAyB,KAGzB,KAAAC,YAA4B,KAEtC,KAAA97C,SAAoB,EAmPtB,CA7OE,QAAI+7C,GAIF,OAHKh7E,KAAKi7E,QACRj7E,KAAKi7E,MAAQj7E,KAAKk7E,eAEbl7E,KAAKi7E,KACd,CAMA,WAAIppC,GAIF,OAHK7xC,KAAKm7E,WACRn7E,KAAKm7E,SAAWn7E,KAAKo7E,kBAEhBp7E,KAAKm7E,QACd,CAmCAE,gBAAAA,GACEr7E,KAAKm7E,SAAW,KAChBn7E,KAAKi7E,MAAQ,IACf,CAgBAtpC,SAAAA,CACEza,EACAC,EACAze,EACApG,EACAgpE,GAAc,GAEL,MAALpkD,IACEz1B,MAAMy1B,GACRl3B,KAAK26E,GAAK,KAEV36E,KAAK26E,GAAKzjD,GAGL,MAALC,IACE11B,MAAM01B,GACRn3B,KAAK46E,GAAK,KAEV56E,KAAK46E,GAAKzjD,GAGL,MAALze,IACEjX,MAAMiX,GACR1Y,KAAK66E,OAAS,KAEd76E,KAAK66E,OAASniE,GAGT,MAALpG,IACE7Q,MAAM6Q,GACRtS,KAAK86E,QAAU,KAEf96E,KAAK86E,QAAUxoE,GAGnB,MAAOipE,EAAIC,EAAIC,EAAIC,GAAM17E,KAAK27E,aAAazkD,EAAGC,EAAGze,EAAGpG,GA+BpD,OA9BU,MAANipE,IACE95E,MAAM85E,GACRv7E,KAAK26E,GAAK,KAEV36E,KAAK26E,GAAKY,GAGJ,MAANC,IACE/5E,MAAM+5E,GACRx7E,KAAK46E,GAAK,KAEV56E,KAAK46E,GAAKY,GAGJ,MAANC,IACEh6E,MAAMg6E,GACRz7E,KAAK66E,OAAS,KAEd76E,KAAK66E,OAASY,GAGR,MAANC,IACEj6E,MAAMi6E,GACR17E,KAAK86E,QAAU,KAEf96E,KAAK86E,QAAUY,GAGfJ,GAAat7E,KAAKwsC,gBAEf,CAAC+uC,EAAIC,EAAIC,EAAIC,EACtB,CAKA,QAAIE,GACF,OAAkB,MAAX57E,KAAK26E,KAAel5E,MAAMzB,KAAK26E,GACxC,CAKA,QAAIkB,GACF,OAAkB,MAAX77E,KAAK46E,KAAen5E,MAAMzB,KAAK46E,GACxC,CAKA,YAAIkB,GACF,OAAsB,MAAf97E,KAAK66E,SAAmBp5E,MAAMzB,KAAK66E,OAC5C,CAKA,aAAIkB,GACF,OAAuB,MAAhB/7E,KAAK86E,UAAoBr5E,MAAMzB,KAAK86E,QAC7C,CAKA,KAAI5jD,GACF,OAAOl3B,KAAK26E,IAAM,CACpB,CAKA,KAAIzjD,CAAEA,GAIJl3B,KAAK2xC,UAAe,MAALza,EAAYl2B,IAAMk2B,EAAG,KAAM,KAAM,KAClD,CAKA,KAAIC,GACF,OAAe,MAAXn3B,KAAK46E,GAAmB56E,KAAK46E,GAC1B,CACT,CAKA,KAAIzjD,CAAEA,GACJn3B,KAAK2xC,UAAU,KAAW,MAALxa,EAAYn2B,IAAMm2B,EAAG,KAAM,KAClD,CAKA,SAAI6kD,GACF,OAAmB,MAAfh8E,KAAK66E,OAAuB76E,KAAK66E,OAC9B,CACT,CAKA,SAAImB,CAAMtjE,GACR1Y,KAAK2xC,UAAU,KAAM,KAAW,MAALj5B,EAAY1X,IAAM0X,EAAG,KAClD,CAKA,UAAIo5B,GACF,OAAoB,MAAhB9xC,KAAK86E,QAAwB96E,KAAK86E,QAC/B,CACT,CAKA,UAAIhpC,CAAOx/B,GACTtS,KAAK2xC,UAAU,KAAM,KAAM,KAAW,MAALr/B,EAAYtR,IAAMsR,EACrD,CAOAk6B,aAAAA,GAEA,EApQeiuC,GAAAvtC,UAAY,EpDa7B,MAAMxH,GAAMG,EAAiBH,KAYtB5tB,KAXK4tB,GAAItB,SAAS,GqDfnB,SAAsB8pB,EAAej9C,QAAA,IAAAA,IAAAA,EAAA,MACnC,IAAAi7B,EAAAmH,GAYF,SAAwB6a,EAAej9C,QAAA,IAAAA,IAAAA,EAAA,MAErC,IAAAi7B,EAAAmH,GzD0BF,SAAe6a,EAAej9C,GAElC,IAAMqsB,EAAI,IAAIwc,IADd7oC,EAASA,GAAW,CAAC,GACQikC,SAAW,CAAC,GACnC+mC,EAAU,IAAIvlB,GAAOxI,EAAK3L,GAAAA,GAAA,GAAOtxC,GAAM,CAAEikC,QAAS5X,KAElD4+C,EAAYD,EAAQrlB,mBAAmB3rD,KAAKpJ,KAAKo6E,EAAQrlB,oBAK/D,OAJc3lD,EAAOkrE,OAAS,IACpBlwE,MAAM,KAAKwvC,UAAU,SAAC5U,GAAc,MAAK,OAALA,GAAmB,SAALA,CAAd,IAA+B,GAC3Erd,QAAQ7nB,IAAI,WAAY,GAAA8M,OAAGwtE,EAAQrlB,mBAAmB9C,GAAGhN,KAAK9oB,aAAatvB,KAAK,QAE3E,CAAC4uB,EAAG4+C,EACb,CyDrCyBE,CAAYluB,EADnCj9C,EAASA,GAAU,CAAC,GAC6B,GAA1CqsB,EAAC4O,EAAA,GAAEgwC,EAAShwC,EAAA,GACnB5O,EAAEqd,qBACI,IAAAjL,EAAA2D,GAAsBmwB,GAAelmC,EAAGrsB,EAAO/N,MAAK,GAC1D,MAAO,CADMwsC,EAAA,GACGwsC,EADQxsC,EAAA,GAE1B,CAlByC2sC,CAAcnuB,EAAOj9C,GAAO,GAA5DqrE,EAAMpwC,EAAA,GAAEgwC,EAAShwC,EAAA,GAAE+zB,EAAS/zB,EAAA,GAC7Bp0B,EAAS,IAAI0kD,GAAO8f,GAQ1B,OAPIrrE,EAAO8nD,WAAamjB,IACtBpkE,EAAO4iD,aAAazpD,EAAO8nD,WAAamjB,IAE5BjrE,EAAOkrE,OAAS,IACpBlwE,MAAM,KAAKwvC,UAAU,SAAC5U,GAAc,MAAK,OAALA,GAAmB,UAALA,CAAd,IAAgC,GCd1E,SAAyB/uB,EAAgBmoD,GAC7C,IAAM3iC,EAAIxlB,EAAOo9B,QACXonC,EAASxkE,EAAOskD,WACtB5yC,QAAQ7nB,IACN,4DACA27B,EAAEU,WAAWv5B,IAAI,SAACyyB,EAAGr2B,GAAM,SAAA4N,OAAG5N,EAAI,EAAC,UAAA4N,OAASyoB,EAAjB,GAC3B,0DACAoG,EAAEU,WAAWv5B,IAAI,SAACyyB,EAAGr2B,GAAM,SAAA4N,OAAGyoB,EAAE3tB,QAAQ,KAAM,KAAI,QAAvB,GAAgCmF,KAAK,IAChE,kDACAyB,KAAKC,UAMH,SAA2BksE,EAAoBrc,GACnD,IAAM51D,EAAS,CAAC,EACVkyE,EAASD,EAAOt+C,WAChBw+C,EAAOvc,aAAS,EAATA,EAAWjiC,WACxB,IAAK,IAAMkgC,KAAWqe,EAAQ,CAC5B,IAAMve,EAAUue,EAAOre,GACvB,GAAI+B,EAAW,CACb,IAAMlE,EAAQygB,EAAKte,GACnB7zD,EAAO6zD,GAAW,CAAEnC,MAAOA,EAAa,MAAGiC,QAASA,EAASN,KAAM3B,EAAY,K,MAE/E1xD,EAAO6zD,GAAWF,C,CAGtB,OAAO3zD,CACT,CApBmBoyE,CAAiBH,EAAQrc,GAAY,KAAM,GAC1D,iDACAqc,EAAOve,gBAEX,CDEI2e,CAAe5kE,EAAQmoD,GAElB,CAACnoD,EAAQokE,EAAWjc,EAC7B,CrDe+B0c,CAC7BlyE,OAAO+oD,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAmHV,CACEopB,oBAAoB,EACpBT,MAAO,GACPj5E,KAAM,OACN+zD,cAAe,CACb4lB,eAAgBA,CAAC31E,EAAmBihD,EAAiByL,KACnD,MAAOkpB,EAAKnd,GAAO/L,EAAMmpB,kBAAkB71E,EAAM7F,OACjD,OAAW,MAAPy7E,GACFtzD,QAAQ7nB,IAAI,0BAA2BuF,EAAM7F,OAC7CuyD,EAAMopB,OAAOt1E,KACX,IAAImvD,GACF,yBAAyB3vD,EAAM7F,QAC/B6F,EAAMqsB,MACN,EAAIrsB,EAAM8c,IAAM9c,EAAMqsB,MACtB,sBACArsB,EAAM7F,QAGH,OAET6F,EAAM7F,MAAQy7E,EACd51E,EAAMw5C,IAAMif,EAAM,UAAY,WACvBz4D,IAET+1E,cAAeA,CAAC/1E,EAAmBg2E,EAAkBC,KACnDj2E,EAAM7F,MAAQ6F,EAAM7F,MAAMoW,UAAU,GAC7BvQ,GAETk2E,UAAWA,CAACl2E,EAAmBg2E,EAAkBC,KAC/Cj2E,EAAM7F,MAAuB,QAAf6F,EAAM7F,MACb6F,GAETm2E,SAAUA,CAACn2E,EAAmBg2E,EAAkBC,KAC9Cj2E,EAAM7F,MAAQyzB,SAAS5tB,EAAM7F,OACtB6F,GAEThF,SAAUA,CAACgF,EAAmBg2E,EAAkBC,KAC9Cj2E,EAAM7F,MAAQ6F,EAAM7F,MAAMoW,UAAU,EAAGvQ,EAAM7F,MAAMyD,OAAS,GACrDoC,GAETo2E,SAAUA,CAACp2E,EAAmBg2E,EAAkBC,KAC9C,GAAiB,cAAbj2E,EAAMw5C,KAAoC,eAAbx5C,EAAMw5C,IACrC,MAAM,IAAI70C,MAAM,yCAA2C3E,EAAMw5C,KAEnE,MAAM3X,EAAwB,cAAb7hC,EAAMw5C,IACjB68B,EAAax0C,EACf7hC,EAAM7F,MAAMoW,UAAU,EAAGvQ,EAAM7F,MAAMyD,OAAS,GAC9CoC,EAAM7F,MAAMoW,UAAU,EAAGvQ,EAAM7F,MAAMyD,OAAS,GAIlD,OADAoC,EAAM7F,MAAQ,IAAIwnC,EAAO00C,EAAYx0C,GAC9B7hC,GAETs2E,cAAeA,CAACt2E,EAAmBg2E,EAAkBC,KACnD,GAAiB,cAAbj2E,EAAMw5C,IAAqB,CAC7B,MAAMrX,EAASniC,EAAMm+C,UAAU,GAAG,GAAKn+C,EAAMm+C,UAAU,GAAG,GACpDo4B,EAAOv2E,EAAM7F,MAAMoW,UAAU4xB,GACnCniC,EAAM7F,MAAQ,IAAI+nC,EAAKq0C,EAAM/3C,IAAM2D,EACrC,KAAO,IAAiB,cAAbniC,EAAMw5C,IAKf,MAAM,IAAI70C,MAAM,yCAA2C3E,EAAMw5C,KAL7B,CACpC,MAAMrX,EAASniC,EAAMm+C,UAAU,GAAG,GAAKn+C,EAAMm+C,UAAU,GAAG,GACpDo4B,EAAOv2E,EAAM7F,MAAMoW,UAAU,EAAGvQ,EAAM7F,MAAMyD,OAASukC,GAC3DniC,EAAM7F,MAAQ,IAAI+nC,EAAKq0C,EAAM/3C,GAAK2D,EACpC,CAEA,CACA,OAAOniC,GAETw2E,eAAgBA,CAACx2E,EAAmBg2E,EAAkBC,KACpDj2E,EAAM7F,MAAQ6F,EAAM7F,MAAMoW,UAAU,EAAGvQ,EAAM7F,MAAMyD,OAAS,GACrDoC,GAETy2E,iBAAkBA,CAACz2E,EAAmBg2E,EAAkBC,KAEtDj2E,EAAM7F,MAAQ6F,EAAM7F,MAAMoW,UAAU,GAC7BvQ,GAET02E,sBAAuBA,CAAC12E,EAAmBg2E,EAAkBC,KAE3Dj2E,EAAM7F,MAAQ6F,EAAM7F,MAAMoW,UAAU,GAC7BvQ,GAET22E,qBAAsBA,CAAC32E,EAAmBihD,EAAiBg1B,KAEzD,MACMW,EAAS,IADA31B,EAAK1wC,UAAUvQ,EAAMm+C,UAAU,GAAG,GAAIn+C,EAAMm+C,UAAU,GAAG,IAElE+B,EAAWe,EAAK33C,MAChButE,EAASlnB,GAAgBpI,aAAatG,EAAM21B,GAAUA,EAAOh5E,OACnE,GAAIi5E,EAAS,EACX,MAAM,IAAIlyE,MAAM,0DAA4DiyE,EAAS,KAGvF,OADA52E,EAAM7F,MAAQ8mD,EAAK1wC,UAAU2vC,EAAU22B,GAChC72E,GAET82E,cAAeA,CAAC92E,EAAmBihD,EAAiBg1B,KAElD,MACM/1B,EAAWe,EAAK33C,MAChButE,EAASlnB,GAAgBpI,aAAatG,EAF7B,SAE6C21B,EAC5D,GAAIC,EAAS,EACX,MAAM,IAAIlyE,MAAM,kDAIlB,OAFA3E,EAAM7F,MAAQ8mD,EAAK1wC,UAAU2vC,EAAU22B,GAEhC72E,M","sources":["webpack://Notations/webpack/universalModuleDefinition","webpack://Notations/./node_modules/ieee754/index.js","webpack://Notations/../../lib/helpers/bind.js","webpack://Notations/../../lib/utils.js","webpack://Notations/../../lib/core/AxiosError.js","webpack://Notations/../../lib/helpers/toFormData.js","webpack://Notations/../../lib/helpers/AxiosURLSearchParams.js","webpack://Notations/../../lib/helpers/buildURL.js","webpack://Notations/../../lib/core/InterceptorManager.js","webpack://Notations/../../lib/defaults/transitional.js","webpack://Notations/../../lib/platform/browser/index.js","webpack://Notations/../../lib/platform/browser/classes/URLSearchParams.js","webpack://Notations/../../lib/platform/browser/classes/FormData.js","webpack://Notations/../../lib/platform/browser/classes/Blob.js","webpack://Notations/../../lib/platform/common/utils.js","webpack://Notations/../../lib/platform/index.js","webpack://Notations/../../lib/helpers/formDataToJSON.js","webpack://Notations/../../lib/defaults/index.js","webpack://Notations/../../lib/helpers/toURLEncodedForm.js","webpack://Notations/../../lib/helpers/parseHeaders.js","webpack://Notations/../../lib/core/AxiosHeaders.js","webpack://Notations/../../lib/core/transformData.js","webpack://Notations/../../lib/cancel/isCancel.js","webpack://Notations/../../lib/cancel/CanceledError.js","webpack://Notations/../../lib/core/settle.js","webpack://Notations/../../lib/helpers/progressEventReducer.js","webpack://Notations/../../lib/helpers/speedometer.js","webpack://Notations/../../lib/helpers/throttle.js","webpack://Notations/../../lib/helpers/isURLSameOrigin.js","webpack://Notations/../../lib/helpers/cookies.js","webpack://Notations/../../lib/core/buildFullPath.js","webpack://Notations/../../lib/helpers/isAbsoluteURL.js","webpack://Notations/../../lib/helpers/combineURLs.js","webpack://Notations/../../lib/core/mergeConfig.js","webpack://Notations/../../lib/helpers/resolveConfig.js","webpack://Notations/../../lib/adapters/xhr.js","webpack://Notations/../../lib/helpers/parseProtocol.js","webpack://Notations/../../lib/helpers/composeSignals.js","webpack://Notations/../../lib/helpers/trackStream.js","webpack://Notations/../../lib/adapters/fetch.js","webpack://Notations/../../lib/adapters/adapters.js","webpack://Notations/../../lib/helpers/null.js","webpack://Notations/../../lib/core/dispatchRequest.js","webpack://Notations/../../lib/env/data.js","webpack://Notations/../../lib/helpers/validator.js","webpack://Notations/../../lib/core/Axios.js","webpack://Notations/../../lib/cancel/CancelToken.js","webpack://Notations/../../lib/helpers/HttpStatusCode.js","webpack://Notations/../../lib/axios.js","webpack://Notations/../../lib/helpers/spread.js","webpack://Notations/../../lib/helpers/isAxiosError.js","webpack://Notations/./node_modules/buffer/index.js","webpack://Notations/./node_modules/base64-js/index.js","webpack://Notations/webpack/bootstrap","webpack://Notations/webpack/runtime/define property getters","webpack://Notations/webpack/runtime/global","webpack://Notations/webpack/runtime/hasOwnProperty shorthand","webpack://Notations/../../src/entity.ts","webpack://Notations/../../src/types.ts","webpack://Notations/../../../src/apis/promiseapis.ts","webpack://Notations/../../src/constants.ts","webpack://Notations/../../../src/comms/events.ts","webpack://Notations/../../src/list.ts","webpack://Notations/../../src/browser.ts","webpack://Notations/../../src/numberutils.ts","webpack://Notations/../../src/cycle.ts","webpack://Notations/../../src/core.ts","webpack://Notations/../../src/layouts.ts","webpack://Notations/../../src/grids.ts","webpack://Notations/../../src/beats.ts","webpack://Notations/../../src/graph.ts","webpack://Notations/../../src/charclasses.ts","webpack://Notations/../../src/sets.ts","webpack://Notations/../../src/grammar.ts","webpack://Notations/../../src/propertyescapes.ts","webpack://Notations/../../src/vm.ts","webpack://Notations/../../src/compiler.ts","webpack://Notations/../../src/errors.ts","webpack://Notations/../../src/tape.ts","webpack://Notations/../../src/token.ts","webpack://Notations/../../src/utils.ts","webpack://Notations/../../src/jsparser.ts","webpack://Notations/../../src/flexparser.ts","webpack://Notations/../../src/builder.ts","webpack://Notations/../../src/dsl.ts","webpack://Notations/../../src/tokenizer.ts","webpack://Notations/../../src/helpers.ts","webpack://Notations/../../src/samples.ts","webpack://Notations/../../src/parser.ts","webpack://Notations/../../src/lr.ts","webpack://Notations/../../src/ll.ts","webpack://Notations/../../src/lritems.ts","webpack://Notations/../../src/ptables.ts","webpack://Notations/./node_modules/yaml/browser/dist/nodes/identity.js","webpack://Notations/./node_modules/yaml/browser/dist/visit.js","webpack://Notations/./node_modules/yaml/browser/dist/doc/directives.js","webpack://Notations/./node_modules/yaml/browser/dist/doc/anchors.js","webpack://Notations/./node_modules/yaml/browser/dist/doc/applyReviver.js","webpack://Notations/./node_modules/yaml/browser/dist/nodes/toJS.js","webpack://Notations/./node_modules/yaml/browser/dist/nodes/Node.js","webpack://Notations/./node_modules/yaml/browser/dist/nodes/Alias.js","webpack://Notations/./node_modules/yaml/browser/dist/nodes/Scalar.js","webpack://Notations/./node_modules/yaml/browser/dist/doc/createNode.js","webpack://Notations/./node_modules/yaml/browser/dist/nodes/Collection.js","webpack://Notations/./node_modules/yaml/browser/dist/stringify/stringifyComment.js","webpack://Notations/./node_modules/yaml/browser/dist/stringify/foldFlowLines.js","webpack://Notations/./node_modules/yaml/browser/dist/stringify/stringifyString.js","webpack://Notations/./node_modules/yaml/browser/dist/stringify/stringify.js","webpack://Notations/./node_modules/yaml/browser/dist/schema/yaml-1.1/merge.js","webpack://Notations/./node_modules/yaml/browser/dist/nodes/addPairToJSMap.js","webpack://Notations/./node_modules/yaml/browser/dist/log.js","webpack://Notations/./node_modules/yaml/browser/dist/nodes/Pair.js","webpack://Notations/./node_modules/yaml/browser/dist/stringify/stringifyPair.js","webpack://Notations/./node_modules/yaml/browser/dist/stringify/stringifyCollection.js","webpack://Notations/./node_modules/yaml/browser/dist/nodes/YAMLMap.js","webpack://Notations/./node_modules/yaml/browser/dist/schema/common/map.js","webpack://Notations/./node_modules/yaml/browser/dist/nodes/YAMLSeq.js","webpack://Notations/./node_modules/yaml/browser/dist/schema/common/seq.js","webpack://Notations/./node_modules/yaml/browser/dist/schema/common/string.js","webpack://Notations/./node_modules/yaml/browser/dist/schema/common/null.js","webpack://Notations/./node_modules/yaml/browser/dist/schema/core/bool.js","webpack://Notations/./node_modules/yaml/browser/dist/stringify/stringifyNumber.js","webpack://Notations/./node_modules/yaml/browser/dist/schema/core/float.js","webpack://Notations/./node_modules/yaml/browser/dist/schema/core/int.js","webpack://Notations/./node_modules/yaml/browser/dist/schema/core/schema.js","webpack://Notations/./node_modules/yaml/browser/dist/schema/json/schema.js","webpack://Notations/./node_modules/yaml/browser/dist/schema/yaml-1.1/binary.js","webpack://Notations/./node_modules/yaml/browser/dist/schema/yaml-1.1/pairs.js","webpack://Notations/./node_modules/yaml/browser/dist/schema/yaml-1.1/omap.js","webpack://Notations/./node_modules/yaml/browser/dist/schema/yaml-1.1/bool.js","webpack://Notations/./node_modules/yaml/browser/dist/schema/yaml-1.1/float.js","webpack://Notations/./node_modules/yaml/browser/dist/schema/yaml-1.1/int.js","webpack://Notations/./node_modules/yaml/browser/dist/schema/yaml-1.1/set.js","webpack://Notations/./node_modules/yaml/browser/dist/schema/yaml-1.1/timestamp.js","webpack://Notations/./node_modules/yaml/browser/dist/schema/yaml-1.1/schema.js","webpack://Notations/./node_modules/yaml/browser/dist/schema/tags.js","webpack://Notations/./node_modules/yaml/browser/dist/errors.js","webpack://Notations/./node_modules/yaml/browser/dist/parse/cst-visit.js","webpack://Notations/../../../src/carnatic/gamakas.ts","webpack://Notations/./node_modules/yaml/browser/dist/parse/lexer.js","webpack://Notations/../../src/shapes.ts","webpack://Notations/../../src/factory.ts","webpack://Notations/../../src/debug.ts"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"Notations\"] = factory();\n\telse\n\t\troot[\"Notations\"] = factory();\n})(this, () => {\nreturn ","/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */\nexports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","'use strict';\n\n/**\n * Create a bound version of a function with a specified `this` context\n *\n * @param {Function} fn - The function to bind\n * @param {*} thisArg - The value to be passed as the `this` parameter\n * @returns {Function} A new function that will call the original function with the specified `this` context\n */\nexport default function bind(fn, thisArg) {\n  return function wrap() {\n    return fn.apply(thisArg, arguments);\n  };\n}\n","'use strict';\n\nimport bind from './helpers/bind.js';\n\n// utils is a library of generic helper functions non-specific to axios\n\nconst {toString} = Object.prototype;\nconst {getPrototypeOf} = Object;\nconst {iterator, toStringTag} = Symbol;\n\nconst kindOf = (cache => thing => {\n    const str = toString.call(thing);\n    return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());\n})(Object.create(null));\n\nconst kindOfTest = (type) => {\n  type = type.toLowerCase();\n  return (thing) => kindOf(thing) === type\n}\n\nconst typeOfTest = type => thing => typeof thing === type;\n\n/**\n * Determine if a value is an Array\n *\n * @param {Object} val The value to test\n *\n * @returns {boolean} True if value is an Array, otherwise false\n */\nconst {isArray} = Array;\n\n/**\n * Determine if a value is undefined\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if the value is undefined, otherwise false\n */\nconst isUndefined = typeOfTest('undefined');\n\n/**\n * Determine if a value is a Buffer\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a Buffer, otherwise false\n */\nfunction isBuffer(val) {\n  return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor)\n    && isFunction(val.constructor.isBuffer) && val.constructor.isBuffer(val);\n}\n\n/**\n * Determine if a value is an ArrayBuffer\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is an ArrayBuffer, otherwise false\n */\nconst isArrayBuffer = kindOfTest('ArrayBuffer');\n\n\n/**\n * Determine if a value is a view on an ArrayBuffer\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false\n */\nfunction isArrayBufferView(val) {\n  let result;\n  if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {\n    result = ArrayBuffer.isView(val);\n  } else {\n    result = (val) && (val.buffer) && (isArrayBuffer(val.buffer));\n  }\n  return result;\n}\n\n/**\n * Determine if a value is a String\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a String, otherwise false\n */\nconst isString = typeOfTest('string');\n\n/**\n * Determine if a value is a Function\n *\n * @param {*} val The value to test\n * @returns {boolean} True if value is a Function, otherwise false\n */\nconst isFunction = typeOfTest('function');\n\n/**\n * Determine if a value is a Number\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a Number, otherwise false\n */\nconst isNumber = typeOfTest('number');\n\n/**\n * Determine if a value is an Object\n *\n * @param {*} thing The value to test\n *\n * @returns {boolean} True if value is an Object, otherwise false\n */\nconst isObject = (thing) => thing !== null && typeof thing === 'object';\n\n/**\n * Determine if a value is a Boolean\n *\n * @param {*} thing The value to test\n * @returns {boolean} True if value is a Boolean, otherwise false\n */\nconst isBoolean = thing => thing === true || thing === false;\n\n/**\n * Determine if a value is a plain Object\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a plain Object, otherwise false\n */\nconst isPlainObject = (val) => {\n  if (kindOf(val) !== 'object') {\n    return false;\n  }\n\n  const prototype = getPrototypeOf(val);\n  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(toStringTag in val) && !(iterator in val);\n}\n\n/**\n * Determine if a value is an empty object (safely handles Buffers)\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is an empty object, otherwise false\n */\nconst isEmptyObject = (val) => {\n  // Early return for non-objects or Buffers to prevent RangeError\n  if (!isObject(val) || isBuffer(val)) {\n    return false;\n  }\n\n  try {\n    return Object.keys(val).length === 0 && Object.getPrototypeOf(val) === Object.prototype;\n  } catch (e) {\n    // Fallback for any other objects that might cause RangeError with Object.keys()\n    return false;\n  }\n}\n\n/**\n * Determine if a value is a Date\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a Date, otherwise false\n */\nconst isDate = kindOfTest('Date');\n\n/**\n * Determine if a value is a File\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a File, otherwise false\n */\nconst isFile = kindOfTest('File');\n\n/**\n * Determine if a value is a Blob\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a Blob, otherwise false\n */\nconst isBlob = kindOfTest('Blob');\n\n/**\n * Determine if a value is a FileList\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a File, otherwise false\n */\nconst isFileList = kindOfTest('FileList');\n\n/**\n * Determine if a value is a Stream\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a Stream, otherwise false\n */\nconst isStream = (val) => isObject(val) && isFunction(val.pipe);\n\n/**\n * Determine if a value is a FormData\n *\n * @param {*} thing The value to test\n *\n * @returns {boolean} True if value is an FormData, otherwise false\n */\nconst isFormData = (thing) => {\n  let kind;\n  return thing && (\n    (typeof FormData === 'function' && thing instanceof FormData) || (\n      isFunction(thing.append) && (\n        (kind = kindOf(thing)) === 'formdata' ||\n        // detect form-data instance\n        (kind === 'object' && isFunction(thing.toString) && thing.toString() === '[object FormData]')\n      )\n    )\n  )\n}\n\n/**\n * Determine if a value is a URLSearchParams object\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a URLSearchParams object, otherwise false\n */\nconst isURLSearchParams = kindOfTest('URLSearchParams');\n\nconst [isReadableStream, isRequest, isResponse, isHeaders] = ['ReadableStream', 'Request', 'Response', 'Headers'].map(kindOfTest);\n\n/**\n * Trim excess whitespace off the beginning and end of a string\n *\n * @param {String} str The String to trim\n *\n * @returns {String} The String freed of excess whitespace\n */\nconst trim = (str) => str.trim ?\n  str.trim() : str.replace(/^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g, '');\n\n/**\n * Iterate over an Array or an Object invoking a function for each item.\n *\n * If `obj` is an Array callback will be called passing\n * the value, index, and complete array for each item.\n *\n * If 'obj' is an Object callback will be called passing\n * the value, key, and complete object for each property.\n *\n * @param {Object|Array} obj The object to iterate\n * @param {Function} fn The callback to invoke for each item\n *\n * @param {Boolean} [allOwnKeys = false]\n * @returns {any}\n */\nfunction forEach(obj, fn, {allOwnKeys = false} = {}) {\n  // Don't bother if no value provided\n  if (obj === null || typeof obj === 'undefined') {\n    return;\n  }\n\n  let i;\n  let l;\n\n  // Force an array if not already something iterable\n  if (typeof obj !== 'object') {\n    /*eslint no-param-reassign:0*/\n    obj = [obj];\n  }\n\n  if (isArray(obj)) {\n    // Iterate over array values\n    for (i = 0, l = obj.length; i < l; i++) {\n      fn.call(null, obj[i], i, obj);\n    }\n  } else {\n    // Buffer check\n    if (isBuffer(obj)) {\n      return;\n    }\n\n    // Iterate over object keys\n    const keys = allOwnKeys ? Object.getOwnPropertyNames(obj) : Object.keys(obj);\n    const len = keys.length;\n    let key;\n\n    for (i = 0; i < len; i++) {\n      key = keys[i];\n      fn.call(null, obj[key], key, obj);\n    }\n  }\n}\n\nfunction findKey(obj, key) {\n  if (isBuffer(obj)){\n    return null;\n  }\n\n  key = key.toLowerCase();\n  const keys = Object.keys(obj);\n  let i = keys.length;\n  let _key;\n  while (i-- > 0) {\n    _key = keys[i];\n    if (key === _key.toLowerCase()) {\n      return _key;\n    }\n  }\n  return null;\n}\n\nconst _global = (() => {\n  /*eslint no-undef:0*/\n  if (typeof globalThis !== \"undefined\") return globalThis;\n  return typeof self !== \"undefined\" ? self : (typeof window !== 'undefined' ? window : global)\n})();\n\nconst isContextDefined = (context) => !isUndefined(context) && context !== _global;\n\n/**\n * Accepts varargs expecting each argument to be an object, then\n * immutably merges the properties of each object and returns result.\n *\n * When multiple objects contain the same key the later object in\n * the arguments list will take precedence.\n *\n * Example:\n *\n * ```js\n * var result = merge({foo: 123}, {foo: 456});\n * console.log(result.foo); // outputs 456\n * ```\n *\n * @param {Object} obj1 Object to merge\n *\n * @returns {Object} Result of all merge properties\n */\nfunction merge(/* obj1, obj2, obj3, ... */) {\n  const {caseless, skipUndefined} = isContextDefined(this) && this || {};\n  const result = {};\n  const assignValue = (val, key) => {\n    const targetKey = caseless && findKey(result, key) || key;\n    if (isPlainObject(result[targetKey]) && isPlainObject(val)) {\n      result[targetKey] = merge(result[targetKey], val);\n    } else if (isPlainObject(val)) {\n      result[targetKey] = merge({}, val);\n    } else if (isArray(val)) {\n      result[targetKey] = val.slice();\n    } else if (!skipUndefined || !isUndefined(val)) {\n      result[targetKey] = val;\n    }\n  }\n\n  for (let i = 0, l = arguments.length; i < l; i++) {\n    arguments[i] && forEach(arguments[i], assignValue);\n  }\n  return result;\n}\n\n/**\n * Extends object a by mutably adding to it the properties of object b.\n *\n * @param {Object} a The object to be extended\n * @param {Object} b The object to copy properties from\n * @param {Object} thisArg The object to bind function to\n *\n * @param {Boolean} [allOwnKeys]\n * @returns {Object} The resulting value of object a\n */\nconst extend = (a, b, thisArg, {allOwnKeys}= {}) => {\n  forEach(b, (val, key) => {\n    if (thisArg && isFunction(val)) {\n      a[key] = bind(val, thisArg);\n    } else {\n      a[key] = val;\n    }\n  }, {allOwnKeys});\n  return a;\n}\n\n/**\n * Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)\n *\n * @param {string} content with BOM\n *\n * @returns {string} content value without BOM\n */\nconst stripBOM = (content) => {\n  if (content.charCodeAt(0) === 0xFEFF) {\n    content = content.slice(1);\n  }\n  return content;\n}\n\n/**\n * Inherit the prototype methods from one constructor into another\n * @param {function} constructor\n * @param {function} superConstructor\n * @param {object} [props]\n * @param {object} [descriptors]\n *\n * @returns {void}\n */\nconst inherits = (constructor, superConstructor, props, descriptors) => {\n  constructor.prototype = Object.create(superConstructor.prototype, descriptors);\n  constructor.prototype.constructor = constructor;\n  Object.defineProperty(constructor, 'super', {\n    value: superConstructor.prototype\n  });\n  props && Object.assign(constructor.prototype, props);\n}\n\n/**\n * Resolve object with deep prototype chain to a flat object\n * @param {Object} sourceObj source object\n * @param {Object} [destObj]\n * @param {Function|Boolean} [filter]\n * @param {Function} [propFilter]\n *\n * @returns {Object}\n */\nconst toFlatObject = (sourceObj, destObj, filter, propFilter) => {\n  let props;\n  let i;\n  let prop;\n  const merged = {};\n\n  destObj = destObj || {};\n  // eslint-disable-next-line no-eq-null,eqeqeq\n  if (sourceObj == null) return destObj;\n\n  do {\n    props = Object.getOwnPropertyNames(sourceObj);\n    i = props.length;\n    while (i-- > 0) {\n      prop = props[i];\n      if ((!propFilter || propFilter(prop, sourceObj, destObj)) && !merged[prop]) {\n        destObj[prop] = sourceObj[prop];\n        merged[prop] = true;\n      }\n    }\n    sourceObj = filter !== false && getPrototypeOf(sourceObj);\n  } while (sourceObj && (!filter || filter(sourceObj, destObj)) && sourceObj !== Object.prototype);\n\n  return destObj;\n}\n\n/**\n * Determines whether a string ends with the characters of a specified string\n *\n * @param {String} str\n * @param {String} searchString\n * @param {Number} [position= 0]\n *\n * @returns {boolean}\n */\nconst endsWith = (str, searchString, position) => {\n  str = String(str);\n  if (position === undefined || position > str.length) {\n    position = str.length;\n  }\n  position -= searchString.length;\n  const lastIndex = str.indexOf(searchString, position);\n  return lastIndex !== -1 && lastIndex === position;\n}\n\n\n/**\n * Returns new array from array like object or null if failed\n *\n * @param {*} [thing]\n *\n * @returns {?Array}\n */\nconst toArray = (thing) => {\n  if (!thing) return null;\n  if (isArray(thing)) return thing;\n  let i = thing.length;\n  if (!isNumber(i)) return null;\n  const arr = new Array(i);\n  while (i-- > 0) {\n    arr[i] = thing[i];\n  }\n  return arr;\n}\n\n/**\n * Checking if the Uint8Array exists and if it does, it returns a function that checks if the\n * thing passed in is an instance of Uint8Array\n *\n * @param {TypedArray}\n *\n * @returns {Array}\n */\n// eslint-disable-next-line func-names\nconst isTypedArray = (TypedArray => {\n  // eslint-disable-next-line func-names\n  return thing => {\n    return TypedArray && thing instanceof TypedArray;\n  };\n})(typeof Uint8Array !== 'undefined' && getPrototypeOf(Uint8Array));\n\n/**\n * For each entry in the object, call the function with the key and value.\n *\n * @param {Object<any, any>} obj - The object to iterate over.\n * @param {Function} fn - The function to call for each entry.\n *\n * @returns {void}\n */\nconst forEachEntry = (obj, fn) => {\n  const generator = obj && obj[iterator];\n\n  const _iterator = generator.call(obj);\n\n  let result;\n\n  while ((result = _iterator.next()) && !result.done) {\n    const pair = result.value;\n    fn.call(obj, pair[0], pair[1]);\n  }\n}\n\n/**\n * It takes a regular expression and a string, and returns an array of all the matches\n *\n * @param {string} regExp - The regular expression to match against.\n * @param {string} str - The string to search.\n *\n * @returns {Array<boolean>}\n */\nconst matchAll = (regExp, str) => {\n  let matches;\n  const arr = [];\n\n  while ((matches = regExp.exec(str)) !== null) {\n    arr.push(matches);\n  }\n\n  return arr;\n}\n\n/* Checking if the kindOfTest function returns true when passed an HTMLFormElement. */\nconst isHTMLForm = kindOfTest('HTMLFormElement');\n\nconst toCamelCase = str => {\n  return str.toLowerCase().replace(/[-_\\s]([a-z\\d])(\\w*)/g,\n    function replacer(m, p1, p2) {\n      return p1.toUpperCase() + p2;\n    }\n  );\n};\n\n/* Creating a function that will check if an object has a property. */\nconst hasOwnProperty = (({hasOwnProperty}) => (obj, prop) => hasOwnProperty.call(obj, prop))(Object.prototype);\n\n/**\n * Determine if a value is a RegExp object\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a RegExp object, otherwise false\n */\nconst isRegExp = kindOfTest('RegExp');\n\nconst reduceDescriptors = (obj, reducer) => {\n  const descriptors = Object.getOwnPropertyDescriptors(obj);\n  const reducedDescriptors = {};\n\n  forEach(descriptors, (descriptor, name) => {\n    let ret;\n    if ((ret = reducer(descriptor, name, obj)) !== false) {\n      reducedDescriptors[name] = ret || descriptor;\n    }\n  });\n\n  Object.defineProperties(obj, reducedDescriptors);\n}\n\n/**\n * Makes all methods read-only\n * @param {Object} obj\n */\n\nconst freezeMethods = (obj) => {\n  reduceDescriptors(obj, (descriptor, name) => {\n    // skip restricted props in strict mode\n    if (isFunction(obj) && ['arguments', 'caller', 'callee'].indexOf(name) !== -1) {\n      return false;\n    }\n\n    const value = obj[name];\n\n    if (!isFunction(value)) return;\n\n    descriptor.enumerable = false;\n\n    if ('writable' in descriptor) {\n      descriptor.writable = false;\n      return;\n    }\n\n    if (!descriptor.set) {\n      descriptor.set = () => {\n        throw Error('Can not rewrite read-only method \\'' + name + '\\'');\n      };\n    }\n  });\n}\n\nconst toObjectSet = (arrayOrString, delimiter) => {\n  const obj = {};\n\n  const define = (arr) => {\n    arr.forEach(value => {\n      obj[value] = true;\n    });\n  }\n\n  isArray(arrayOrString) ? define(arrayOrString) : define(String(arrayOrString).split(delimiter));\n\n  return obj;\n}\n\nconst noop = () => {}\n\nconst toFiniteNumber = (value, defaultValue) => {\n  return value != null && Number.isFinite(value = +value) ? value : defaultValue;\n}\n\n\n\n/**\n * If the thing is a FormData object, return true, otherwise return false.\n *\n * @param {unknown} thing - The thing to check.\n *\n * @returns {boolean}\n */\nfunction isSpecCompliantForm(thing) {\n  return !!(thing && isFunction(thing.append) && thing[toStringTag] === 'FormData' && thing[iterator]);\n}\n\nconst toJSONObject = (obj) => {\n  const stack = new Array(10);\n\n  const visit = (source, i) => {\n\n    if (isObject(source)) {\n      if (stack.indexOf(source) >= 0) {\n        return;\n      }\n\n      //Buffer check\n      if (isBuffer(source)) {\n        return source;\n      }\n\n      if(!('toJSON' in source)) {\n        stack[i] = source;\n        const target = isArray(source) ? [] : {};\n\n        forEach(source, (value, key) => {\n          const reducedValue = visit(value, i + 1);\n          !isUndefined(reducedValue) && (target[key] = reducedValue);\n        });\n\n        stack[i] = undefined;\n\n        return target;\n      }\n    }\n\n    return source;\n  }\n\n  return visit(obj, 0);\n}\n\nconst isAsyncFn = kindOfTest('AsyncFunction');\n\nconst isThenable = (thing) =>\n  thing && (isObject(thing) || isFunction(thing)) && isFunction(thing.then) && isFunction(thing.catch);\n\n// original code\n// https://github.com/DigitalBrainJS/AxiosPromise/blob/16deab13710ec09779922131f3fa5954320f83ab/lib/utils.js#L11-L34\n\nconst _setImmediate = ((setImmediateSupported, postMessageSupported) => {\n  if (setImmediateSupported) {\n    return setImmediate;\n  }\n\n  return postMessageSupported ? ((token, callbacks) => {\n    _global.addEventListener(\"message\", ({source, data}) => {\n      if (source === _global && data === token) {\n        callbacks.length && callbacks.shift()();\n      }\n    }, false);\n\n    return (cb) => {\n      callbacks.push(cb);\n      _global.postMessage(token, \"*\");\n    }\n  })(`axios@${Math.random()}`, []) : (cb) => setTimeout(cb);\n})(\n  typeof setImmediate === 'function',\n  isFunction(_global.postMessage)\n);\n\nconst asap = typeof queueMicrotask !== 'undefined' ?\n  queueMicrotask.bind(_global) : ( typeof process !== 'undefined' && process.nextTick || _setImmediate);\n\n// *********************\n\n\nconst isIterable = (thing) => thing != null && isFunction(thing[iterator]);\n\n\nexport default {\n  isArray,\n  isArrayBuffer,\n  isBuffer,\n  isFormData,\n  isArrayBufferView,\n  isString,\n  isNumber,\n  isBoolean,\n  isObject,\n  isPlainObject,\n  isEmptyObject,\n  isReadableStream,\n  isRequest,\n  isResponse,\n  isHeaders,\n  isUndefined,\n  isDate,\n  isFile,\n  isBlob,\n  isRegExp,\n  isFunction,\n  isStream,\n  isURLSearchParams,\n  isTypedArray,\n  isFileList,\n  forEach,\n  merge,\n  extend,\n  trim,\n  stripBOM,\n  inherits,\n  toFlatObject,\n  kindOf,\n  kindOfTest,\n  endsWith,\n  toArray,\n  forEachEntry,\n  matchAll,\n  isHTMLForm,\n  hasOwnProperty,\n  hasOwnProp: hasOwnProperty, // an alias to avoid ESLint no-prototype-builtins detection\n  reduceDescriptors,\n  freezeMethods,\n  toObjectSet,\n  toCamelCase,\n  noop,\n  toFiniteNumber,\n  findKey,\n  global: _global,\n  isContextDefined,\n  isSpecCompliantForm,\n  toJSONObject,\n  isAsyncFn,\n  isThenable,\n  setImmediate: _setImmediate,\n  asap,\n  isIterable\n};\n","'use strict';\n\nimport utils from '../utils.js';\n\n/**\n * Create an Error with the specified message, config, error code, request and response.\n *\n * @param {string} message The error message.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n * @param {Object} [config] The config.\n * @param {Object} [request] The request.\n * @param {Object} [response] The response.\n *\n * @returns {Error} The created error.\n */\nfunction AxiosError(message, code, config, request, response) {\n  Error.call(this);\n\n  if (Error.captureStackTrace) {\n    Error.captureStackTrace(this, this.constructor);\n  } else {\n    this.stack = (new Error()).stack;\n  }\n\n  this.message = message;\n  this.name = 'AxiosError';\n  code && (this.code = code);\n  config && (this.config = config);\n  request && (this.request = request);\n  if (response) {\n    this.response = response;\n    this.status = response.status ? response.status : null;\n  }\n}\n\nutils.inherits(AxiosError, Error, {\n  toJSON: function toJSON() {\n    return {\n      // Standard\n      message: this.message,\n      name: this.name,\n      // Microsoft\n      description: this.description,\n      number: this.number,\n      // Mozilla\n      fileName: this.fileName,\n      lineNumber: this.lineNumber,\n      columnNumber: this.columnNumber,\n      stack: this.stack,\n      // Axios\n      config: utils.toJSONObject(this.config),\n      code: this.code,\n      status: this.status\n    };\n  }\n});\n\nconst prototype = AxiosError.prototype;\nconst descriptors = {};\n\n[\n  'ERR_BAD_OPTION_VALUE',\n  'ERR_BAD_OPTION',\n  'ECONNABORTED',\n  'ETIMEDOUT',\n  'ERR_NETWORK',\n  'ERR_FR_TOO_MANY_REDIRECTS',\n  'ERR_DEPRECATED',\n  'ERR_BAD_RESPONSE',\n  'ERR_BAD_REQUEST',\n  'ERR_CANCELED',\n  'ERR_NOT_SUPPORT',\n  'ERR_INVALID_URL'\n// eslint-disable-next-line func-names\n].forEach(code => {\n  descriptors[code] = {value: code};\n});\n\nObject.defineProperties(AxiosError, descriptors);\nObject.defineProperty(prototype, 'isAxiosError', {value: true});\n\n// eslint-disable-next-line func-names\nAxiosError.from = (error, code, config, request, response, customProps) => {\n  const axiosError = Object.create(prototype);\n\n  utils.toFlatObject(error, axiosError, function filter(obj) {\n    return obj !== Error.prototype;\n  }, prop => {\n    return prop !== 'isAxiosError';\n  });\n\n  const msg = error && error.message ? error.message : 'Error';\n\n  // Prefer explicit code; otherwise copy the low-level error's code (e.g. ECONNREFUSED)\n  const errCode = code == null && error ? error.code : code;\n  AxiosError.call(axiosError, msg, errCode, config, request, response);\n\n  // Chain the original error on the standard field; non-enumerable to avoid JSON noise\n  if (error && axiosError.cause == null) {\n    Object.defineProperty(axiosError, 'cause', { value: error, configurable: true });\n  }\n\n  axiosError.name = (error && error.name) || 'Error';\n\n  customProps && Object.assign(axiosError, customProps);\n\n  return axiosError;\n};\n\nexport default AxiosError;\n","'use strict';\n\nimport utils from '../utils.js';\nimport AxiosError from '../core/AxiosError.js';\n// temporary hotfix to avoid circular references until AxiosURLSearchParams is refactored\nimport PlatformFormData from '../platform/node/classes/FormData.js';\n\n/**\n * Determines if the given thing is a array or js object.\n *\n * @param {string} thing - The object or array to be visited.\n *\n * @returns {boolean}\n */\nfunction isVisitable(thing) {\n  return utils.isPlainObject(thing) || utils.isArray(thing);\n}\n\n/**\n * It removes the brackets from the end of a string\n *\n * @param {string} key - The key of the parameter.\n *\n * @returns {string} the key without the brackets.\n */\nfunction removeBrackets(key) {\n  return utils.endsWith(key, '[]') ? key.slice(0, -2) : key;\n}\n\n/**\n * It takes a path, a key, and a boolean, and returns a string\n *\n * @param {string} path - The path to the current key.\n * @param {string} key - The key of the current object being iterated over.\n * @param {string} dots - If true, the key will be rendered with dots instead of brackets.\n *\n * @returns {string} The path to the current key.\n */\nfunction renderKey(path, key, dots) {\n  if (!path) return key;\n  return path.concat(key).map(function each(token, i) {\n    // eslint-disable-next-line no-param-reassign\n    token = removeBrackets(token);\n    return !dots && i ? '[' + token + ']' : token;\n  }).join(dots ? '.' : '');\n}\n\n/**\n * If the array is an array and none of its elements are visitable, then it's a flat array.\n *\n * @param {Array<any>} arr - The array to check\n *\n * @returns {boolean}\n */\nfunction isFlatArray(arr) {\n  return utils.isArray(arr) && !arr.some(isVisitable);\n}\n\nconst predicates = utils.toFlatObject(utils, {}, null, function filter(prop) {\n  return /^is[A-Z]/.test(prop);\n});\n\n/**\n * Convert a data object to FormData\n *\n * @param {Object} obj\n * @param {?Object} [formData]\n * @param {?Object} [options]\n * @param {Function} [options.visitor]\n * @param {Boolean} [options.metaTokens = true]\n * @param {Boolean} [options.dots = false]\n * @param {?Boolean} [options.indexes = false]\n *\n * @returns {Object}\n **/\n\n/**\n * It converts an object into a FormData object\n *\n * @param {Object<any, any>} obj - The object to convert to form data.\n * @param {string} formData - The FormData object to append to.\n * @param {Object<string, any>} options\n *\n * @returns\n */\nfunction toFormData(obj, formData, options) {\n  if (!utils.isObject(obj)) {\n    throw new TypeError('target must be an object');\n  }\n\n  // eslint-disable-next-line no-param-reassign\n  formData = formData || new (PlatformFormData || FormData)();\n\n  // eslint-disable-next-line no-param-reassign\n  options = utils.toFlatObject(options, {\n    metaTokens: true,\n    dots: false,\n    indexes: false\n  }, false, function defined(option, source) {\n    // eslint-disable-next-line no-eq-null,eqeqeq\n    return !utils.isUndefined(source[option]);\n  });\n\n  const metaTokens = options.metaTokens;\n  // eslint-disable-next-line no-use-before-define\n  const visitor = options.visitor || defaultVisitor;\n  const dots = options.dots;\n  const indexes = options.indexes;\n  const _Blob = options.Blob || typeof Blob !== 'undefined' && Blob;\n  const useBlob = _Blob && utils.isSpecCompliantForm(formData);\n\n  if (!utils.isFunction(visitor)) {\n    throw new TypeError('visitor must be a function');\n  }\n\n  function convertValue(value) {\n    if (value === null) return '';\n\n    if (utils.isDate(value)) {\n      return value.toISOString();\n    }\n\n    if (utils.isBoolean(value)) {\n      return value.toString();\n    }\n\n    if (!useBlob && utils.isBlob(value)) {\n      throw new AxiosError('Blob is not supported. Use a Buffer instead.');\n    }\n\n    if (utils.isArrayBuffer(value) || utils.isTypedArray(value)) {\n      return useBlob && typeof Blob === 'function' ? new Blob([value]) : Buffer.from(value);\n    }\n\n    return value;\n  }\n\n  /**\n   * Default visitor.\n   *\n   * @param {*} value\n   * @param {String|Number} key\n   * @param {Array<String|Number>} path\n   * @this {FormData}\n   *\n   * @returns {boolean} return true to visit the each prop of the value recursively\n   */\n  function defaultVisitor(value, key, path) {\n    let arr = value;\n\n    if (value && !path && typeof value === 'object') {\n      if (utils.endsWith(key, '{}')) {\n        // eslint-disable-next-line no-param-reassign\n        key = metaTokens ? key : key.slice(0, -2);\n        // eslint-disable-next-line no-param-reassign\n        value = JSON.stringify(value);\n      } else if (\n        (utils.isArray(value) && isFlatArray(value)) ||\n        ((utils.isFileList(value) || utils.endsWith(key, '[]')) && (arr = utils.toArray(value))\n        )) {\n        // eslint-disable-next-line no-param-reassign\n        key = removeBrackets(key);\n\n        arr.forEach(function each(el, index) {\n          !(utils.isUndefined(el) || el === null) && formData.append(\n            // eslint-disable-next-line no-nested-ternary\n            indexes === true ? renderKey([key], index, dots) : (indexes === null ? key : key + '[]'),\n            convertValue(el)\n          );\n        });\n        return false;\n      }\n    }\n\n    if (isVisitable(value)) {\n      return true;\n    }\n\n    formData.append(renderKey(path, key, dots), convertValue(value));\n\n    return false;\n  }\n\n  const stack = [];\n\n  const exposedHelpers = Object.assign(predicates, {\n    defaultVisitor,\n    convertValue,\n    isVisitable\n  });\n\n  function build(value, path) {\n    if (utils.isUndefined(value)) return;\n\n    if (stack.indexOf(value) !== -1) {\n      throw Error('Circular reference detected in ' + path.join('.'));\n    }\n\n    stack.push(value);\n\n    utils.forEach(value, function each(el, key) {\n      const result = !(utils.isUndefined(el) || el === null) && visitor.call(\n        formData, el, utils.isString(key) ? key.trim() : key, path, exposedHelpers\n      );\n\n      if (result === true) {\n        build(el, path ? path.concat(key) : [key]);\n      }\n    });\n\n    stack.pop();\n  }\n\n  if (!utils.isObject(obj)) {\n    throw new TypeError('data must be an object');\n  }\n\n  build(obj);\n\n  return formData;\n}\n\nexport default toFormData;\n","'use strict';\n\nimport toFormData from './toFormData.js';\n\n/**\n * It encodes a string by replacing all characters that are not in the unreserved set with\n * their percent-encoded equivalents\n *\n * @param {string} str - The string to encode.\n *\n * @returns {string} The encoded string.\n */\nfunction encode(str) {\n  const charMap = {\n    '!': '%21',\n    \"'\": '%27',\n    '(': '%28',\n    ')': '%29',\n    '~': '%7E',\n    '%20': '+',\n    '%00': '\\x00'\n  };\n  return encodeURIComponent(str).replace(/[!'()~]|%20|%00/g, function replacer(match) {\n    return charMap[match];\n  });\n}\n\n/**\n * It takes a params object and converts it to a FormData object\n *\n * @param {Object<string, any>} params - The parameters to be converted to a FormData object.\n * @param {Object<string, any>} options - The options object passed to the Axios constructor.\n *\n * @returns {void}\n */\nfunction AxiosURLSearchParams(params, options) {\n  this._pairs = [];\n\n  params && toFormData(params, this, options);\n}\n\nconst prototype = AxiosURLSearchParams.prototype;\n\nprototype.append = function append(name, value) {\n  this._pairs.push([name, value]);\n};\n\nprototype.toString = function toString(encoder) {\n  const _encode = encoder ? function(value) {\n    return encoder.call(this, value, encode);\n  } : encode;\n\n  return this._pairs.map(function each(pair) {\n    return _encode(pair[0]) + '=' + _encode(pair[1]);\n  }, '').join('&');\n};\n\nexport default AxiosURLSearchParams;\n","'use strict';\n\nimport utils from '../utils.js';\nimport AxiosURLSearchParams from '../helpers/AxiosURLSearchParams.js';\n\n/**\n * It replaces all instances of the characters `:`, `$`, `,`, `+`, `[`, and `]` with their\n * URI encoded counterparts\n *\n * @param {string} val The value to be encoded.\n *\n * @returns {string} The encoded value.\n */\nfunction encode(val) {\n  return encodeURIComponent(val).\n    replace(/%3A/gi, ':').\n    replace(/%24/g, '$').\n    replace(/%2C/gi, ',').\n    replace(/%20/g, '+');\n}\n\n/**\n * Build a URL by appending params to the end\n *\n * @param {string} url The base of the url (e.g., http://www.google.com)\n * @param {object} [params] The params to be appended\n * @param {?(object|Function)} options\n *\n * @returns {string} The formatted url\n */\nexport default function buildURL(url, params, options) {\n  /*eslint no-param-reassign:0*/\n  if (!params) {\n    return url;\n  }\n  \n  const _encode = options && options.encode || encode;\n\n  if (utils.isFunction(options)) {\n    options = {\n      serialize: options\n    };\n  } \n\n  const serializeFn = options && options.serialize;\n\n  let serializedParams;\n\n  if (serializeFn) {\n    serializedParams = serializeFn(params, options);\n  } else {\n    serializedParams = utils.isURLSearchParams(params) ?\n      params.toString() :\n      new AxiosURLSearchParams(params, options).toString(_encode);\n  }\n\n  if (serializedParams) {\n    const hashmarkIndex = url.indexOf(\"#\");\n\n    if (hashmarkIndex !== -1) {\n      url = url.slice(0, hashmarkIndex);\n    }\n    url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;\n  }\n\n  return url;\n}\n","'use strict';\n\nimport utils from './../utils.js';\n\nclass InterceptorManager {\n  constructor() {\n    this.handlers = [];\n  }\n\n  /**\n   * Add a new interceptor to the stack\n   *\n   * @param {Function} fulfilled The function to handle `then` for a `Promise`\n   * @param {Function} rejected The function to handle `reject` for a `Promise`\n   *\n   * @return {Number} An ID used to remove interceptor later\n   */\n  use(fulfilled, rejected, options) {\n    this.handlers.push({\n      fulfilled,\n      rejected,\n      synchronous: options ? options.synchronous : false,\n      runWhen: options ? options.runWhen : null\n    });\n    return this.handlers.length - 1;\n  }\n\n  /**\n   * Remove an interceptor from the stack\n   *\n   * @param {Number} id The ID that was returned by `use`\n   *\n   * @returns {void}\n   */\n  eject(id) {\n    if (this.handlers[id]) {\n      this.handlers[id] = null;\n    }\n  }\n\n  /**\n   * Clear all interceptors from the stack\n   *\n   * @returns {void}\n   */\n  clear() {\n    if (this.handlers) {\n      this.handlers = [];\n    }\n  }\n\n  /**\n   * Iterate over all the registered interceptors\n   *\n   * This method is particularly useful for skipping over any\n   * interceptors that may have become `null` calling `eject`.\n   *\n   * @param {Function} fn The function to call for each interceptor\n   *\n   * @returns {void}\n   */\n  forEach(fn) {\n    utils.forEach(this.handlers, function forEachHandler(h) {\n      if (h !== null) {\n        fn(h);\n      }\n    });\n  }\n}\n\nexport default InterceptorManager;\n","'use strict';\n\nexport default {\n  silentJSONParsing: true,\n  forcedJSONParsing: true,\n  clarifyTimeoutError: false\n};\n","import URLSearchParams from './classes/URLSearchParams.js'\nimport FormData from './classes/FormData.js'\nimport Blob from './classes/Blob.js'\n\nexport default {\n  isBrowser: true,\n  classes: {\n    URLSearchParams,\n    FormData,\n    Blob\n  },\n  protocols: ['http', 'https', 'file', 'blob', 'url', 'data']\n};\n","'use strict';\n\nimport AxiosURLSearchParams from '../../../helpers/AxiosURLSearchParams.js';\nexport default typeof URLSearchParams !== 'undefined' ? URLSearchParams : AxiosURLSearchParams;\n","'use strict';\n\nexport default typeof FormData !== 'undefined' ? FormData : null;\n","'use strict'\n\nexport default typeof Blob !== 'undefined' ? Blob : null\n","const hasBrowserEnv = typeof window !== 'undefined' && typeof document !== 'undefined';\n\nconst _navigator = typeof navigator === 'object' && navigator || undefined;\n\n/**\n * Determine if we're running in a standard browser environment\n *\n * This allows axios to run in a web worker, and react-native.\n * Both environments support XMLHttpRequest, but not fully standard globals.\n *\n * web workers:\n *  typeof window -> undefined\n *  typeof document -> undefined\n *\n * react-native:\n *  navigator.product -> 'ReactNative'\n * nativescript\n *  navigator.product -> 'NativeScript' or 'NS'\n *\n * @returns {boolean}\n */\nconst hasStandardBrowserEnv = hasBrowserEnv &&\n  (!_navigator || ['ReactNative', 'NativeScript', 'NS'].indexOf(_navigator.product) < 0);\n\n/**\n * Determine if we're running in a standard browser webWorker environment\n *\n * Although the `isStandardBrowserEnv` method indicates that\n * `allows axios to run in a web worker`, the WebWorker will still be\n * filtered out due to its judgment standard\n * `typeof window !== 'undefined' && typeof document !== 'undefined'`.\n * This leads to a problem when axios post `FormData` in webWorker\n */\nconst hasStandardBrowserWebWorkerEnv = (() => {\n  return (\n    typeof WorkerGlobalScope !== 'undefined' &&\n    // eslint-disable-next-line no-undef\n    self instanceof WorkerGlobalScope &&\n    typeof self.importScripts === 'function'\n  );\n})();\n\nconst origin = hasBrowserEnv && window.location.href || 'http://localhost';\n\nexport {\n  hasBrowserEnv,\n  hasStandardBrowserWebWorkerEnv,\n  hasStandardBrowserEnv,\n  _navigator as navigator,\n  origin\n}\n","import platform from './node/index.js';\nimport * as utils from './common/utils.js';\n\nexport default {\n  ...utils,\n  ...platform\n}\n","'use strict';\n\nimport utils from '../utils.js';\n\n/**\n * It takes a string like `foo[x][y][z]` and returns an array like `['foo', 'x', 'y', 'z']\n *\n * @param {string} name - The name of the property to get.\n *\n * @returns An array of strings.\n */\nfunction parsePropPath(name) {\n  // foo[x][y][z]\n  // foo.x.y.z\n  // foo-x-y-z\n  // foo x y z\n  return utils.matchAll(/\\w+|\\[(\\w*)]/g, name).map(match => {\n    return match[0] === '[]' ? '' : match[1] || match[0];\n  });\n}\n\n/**\n * Convert an array to an object.\n *\n * @param {Array<any>} arr - The array to convert to an object.\n *\n * @returns An object with the same keys and values as the array.\n */\nfunction arrayToObject(arr) {\n  const obj = {};\n  const keys = Object.keys(arr);\n  let i;\n  const len = keys.length;\n  let key;\n  for (i = 0; i < len; i++) {\n    key = keys[i];\n    obj[key] = arr[key];\n  }\n  return obj;\n}\n\n/**\n * It takes a FormData object and returns a JavaScript object\n *\n * @param {string} formData The FormData object to convert to JSON.\n *\n * @returns {Object<string, any> | null} The converted object.\n */\nfunction formDataToJSON(formData) {\n  function buildPath(path, value, target, index) {\n    let name = path[index++];\n\n    if (name === '__proto__') return true;\n\n    const isNumericKey = Number.isFinite(+name);\n    const isLast = index >= path.length;\n    name = !name && utils.isArray(target) ? target.length : name;\n\n    if (isLast) {\n      if (utils.hasOwnProp(target, name)) {\n        target[name] = [target[name], value];\n      } else {\n        target[name] = value;\n      }\n\n      return !isNumericKey;\n    }\n\n    if (!target[name] || !utils.isObject(target[name])) {\n      target[name] = [];\n    }\n\n    const result = buildPath(path, value, target[name], index);\n\n    if (result && utils.isArray(target[name])) {\n      target[name] = arrayToObject(target[name]);\n    }\n\n    return !isNumericKey;\n  }\n\n  if (utils.isFormData(formData) && utils.isFunction(formData.entries)) {\n    const obj = {};\n\n    utils.forEachEntry(formData, (name, value) => {\n      buildPath(parsePropPath(name), value, obj, 0);\n    });\n\n    return obj;\n  }\n\n  return null;\n}\n\nexport default formDataToJSON;\n","'use strict';\n\nimport utils from '../utils.js';\nimport AxiosError from '../core/AxiosError.js';\nimport transitionalDefaults from './transitional.js';\nimport toFormData from '../helpers/toFormData.js';\nimport toURLEncodedForm from '../helpers/toURLEncodedForm.js';\nimport platform from '../platform/index.js';\nimport formDataToJSON from '../helpers/formDataToJSON.js';\n\n/**\n * It takes a string, tries to parse it, and if it fails, it returns the stringified version\n * of the input\n *\n * @param {any} rawValue - The value to be stringified.\n * @param {Function} parser - A function that parses a string into a JavaScript object.\n * @param {Function} encoder - A function that takes a value and returns a string.\n *\n * @returns {string} A stringified version of the rawValue.\n */\nfunction stringifySafely(rawValue, parser, encoder) {\n  if (utils.isString(rawValue)) {\n    try {\n      (parser || JSON.parse)(rawValue);\n      return utils.trim(rawValue);\n    } catch (e) {\n      if (e.name !== 'SyntaxError') {\n        throw e;\n      }\n    }\n  }\n\n  return (encoder || JSON.stringify)(rawValue);\n}\n\nconst defaults = {\n\n  transitional: transitionalDefaults,\n\n  adapter: ['xhr', 'http', 'fetch'],\n\n  transformRequest: [function transformRequest(data, headers) {\n    const contentType = headers.getContentType() || '';\n    const hasJSONContentType = contentType.indexOf('application/json') > -1;\n    const isObjectPayload = utils.isObject(data);\n\n    if (isObjectPayload && utils.isHTMLForm(data)) {\n      data = new FormData(data);\n    }\n\n    const isFormData = utils.isFormData(data);\n\n    if (isFormData) {\n      return hasJSONContentType ? JSON.stringify(formDataToJSON(data)) : data;\n    }\n\n    if (utils.isArrayBuffer(data) ||\n      utils.isBuffer(data) ||\n      utils.isStream(data) ||\n      utils.isFile(data) ||\n      utils.isBlob(data) ||\n      utils.isReadableStream(data)\n    ) {\n      return data;\n    }\n    if (utils.isArrayBufferView(data)) {\n      return data.buffer;\n    }\n    if (utils.isURLSearchParams(data)) {\n      headers.setContentType('application/x-www-form-urlencoded;charset=utf-8', false);\n      return data.toString();\n    }\n\n    let isFileList;\n\n    if (isObjectPayload) {\n      if (contentType.indexOf('application/x-www-form-urlencoded') > -1) {\n        return toURLEncodedForm(data, this.formSerializer).toString();\n      }\n\n      if ((isFileList = utils.isFileList(data)) || contentType.indexOf('multipart/form-data') > -1) {\n        const _FormData = this.env && this.env.FormData;\n\n        return toFormData(\n          isFileList ? {'files[]': data} : data,\n          _FormData && new _FormData(),\n          this.formSerializer\n        );\n      }\n    }\n\n    if (isObjectPayload || hasJSONContentType ) {\n      headers.setContentType('application/json', false);\n      return stringifySafely(data);\n    }\n\n    return data;\n  }],\n\n  transformResponse: [function transformResponse(data) {\n    const transitional = this.transitional || defaults.transitional;\n    const forcedJSONParsing = transitional && transitional.forcedJSONParsing;\n    const JSONRequested = this.responseType === 'json';\n\n    if (utils.isResponse(data) || utils.isReadableStream(data)) {\n      return data;\n    }\n\n    if (data && utils.isString(data) && ((forcedJSONParsing && !this.responseType) || JSONRequested)) {\n      const silentJSONParsing = transitional && transitional.silentJSONParsing;\n      const strictJSONParsing = !silentJSONParsing && JSONRequested;\n\n      try {\n        return JSON.parse(data, this.parseReviver);\n      } catch (e) {\n        if (strictJSONParsing) {\n          if (e.name === 'SyntaxError') {\n            throw AxiosError.from(e, AxiosError.ERR_BAD_RESPONSE, this, null, this.response);\n          }\n          throw e;\n        }\n      }\n    }\n\n    return data;\n  }],\n\n  /**\n   * A timeout in milliseconds to abort a request. If set to 0 (default) a\n   * timeout is not created.\n   */\n  timeout: 0,\n\n  xsrfCookieName: 'XSRF-TOKEN',\n  xsrfHeaderName: 'X-XSRF-TOKEN',\n\n  maxContentLength: -1,\n  maxBodyLength: -1,\n\n  env: {\n    FormData: platform.classes.FormData,\n    Blob: platform.classes.Blob\n  },\n\n  validateStatus: function validateStatus(status) {\n    return status >= 200 && status < 300;\n  },\n\n  headers: {\n    common: {\n      'Accept': 'application/json, text/plain, */*',\n      'Content-Type': undefined\n    }\n  }\n};\n\nutils.forEach(['delete', 'get', 'head', 'post', 'put', 'patch'], (method) => {\n  defaults.headers[method] = {};\n});\n\nexport default defaults;\n","'use strict';\n\nimport utils from '../utils.js';\nimport toFormData from './toFormData.js';\nimport platform from '../platform/index.js';\n\nexport default function toURLEncodedForm(data, options) {\n  return toFormData(data, new platform.classes.URLSearchParams(), {\n    visitor: function(value, key, path, helpers) {\n      if (platform.isNode && utils.isBuffer(value)) {\n        this.append(key, value.toString('base64'));\n        return false;\n      }\n\n      return helpers.defaultVisitor.apply(this, arguments);\n    },\n    ...options\n  });\n}\n","'use strict';\n\nimport utils from './../utils.js';\n\n// RawAxiosHeaders whose duplicates are ignored by node\n// c.f. https://nodejs.org/api/http.html#http_message_headers\nconst ignoreDuplicateOf = utils.toObjectSet([\n  'age', 'authorization', 'content-length', 'content-type', 'etag',\n  'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since',\n  'last-modified', 'location', 'max-forwards', 'proxy-authorization',\n  'referer', 'retry-after', 'user-agent'\n]);\n\n/**\n * Parse headers into an object\n *\n * ```\n * Date: Wed, 27 Aug 2014 08:58:49 GMT\n * Content-Type: application/json\n * Connection: keep-alive\n * Transfer-Encoding: chunked\n * ```\n *\n * @param {String} rawHeaders Headers needing to be parsed\n *\n * @returns {Object} Headers parsed into an object\n */\nexport default rawHeaders => {\n  const parsed = {};\n  let key;\n  let val;\n  let i;\n\n  rawHeaders && rawHeaders.split('\\n').forEach(function parser(line) {\n    i = line.indexOf(':');\n    key = line.substring(0, i).trim().toLowerCase();\n    val = line.substring(i + 1).trim();\n\n    if (!key || (parsed[key] && ignoreDuplicateOf[key])) {\n      return;\n    }\n\n    if (key === 'set-cookie') {\n      if (parsed[key]) {\n        parsed[key].push(val);\n      } else {\n        parsed[key] = [val];\n      }\n    } else {\n      parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;\n    }\n  });\n\n  return parsed;\n};\n","'use strict';\n\nimport utils from '../utils.js';\nimport parseHeaders from '../helpers/parseHeaders.js';\n\nconst $internals = Symbol('internals');\n\nfunction normalizeHeader(header) {\n  return header && String(header).trim().toLowerCase();\n}\n\nfunction normalizeValue(value) {\n  if (value === false || value == null) {\n    return value;\n  }\n\n  return utils.isArray(value) ? value.map(normalizeValue) : String(value);\n}\n\nfunction parseTokens(str) {\n  const tokens = Object.create(null);\n  const tokensRE = /([^\\s,;=]+)\\s*(?:=\\s*([^,;]+))?/g;\n  let match;\n\n  while ((match = tokensRE.exec(str))) {\n    tokens[match[1]] = match[2];\n  }\n\n  return tokens;\n}\n\nconst isValidHeaderName = (str) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim());\n\nfunction matchHeaderValue(context, value, header, filter, isHeaderNameFilter) {\n  if (utils.isFunction(filter)) {\n    return filter.call(this, value, header);\n  }\n\n  if (isHeaderNameFilter) {\n    value = header;\n  }\n\n  if (!utils.isString(value)) return;\n\n  if (utils.isString(filter)) {\n    return value.indexOf(filter) !== -1;\n  }\n\n  if (utils.isRegExp(filter)) {\n    return filter.test(value);\n  }\n}\n\nfunction formatHeader(header) {\n  return header.trim()\n    .toLowerCase().replace(/([a-z\\d])(\\w*)/g, (w, char, str) => {\n      return char.toUpperCase() + str;\n    });\n}\n\nfunction buildAccessors(obj, header) {\n  const accessorName = utils.toCamelCase(' ' + header);\n\n  ['get', 'set', 'has'].forEach(methodName => {\n    Object.defineProperty(obj, methodName + accessorName, {\n      value: function(arg1, arg2, arg3) {\n        return this[methodName].call(this, header, arg1, arg2, arg3);\n      },\n      configurable: true\n    });\n  });\n}\n\nclass AxiosHeaders {\n  constructor(headers) {\n    headers && this.set(headers);\n  }\n\n  set(header, valueOrRewrite, rewrite) {\n    const self = this;\n\n    function setHeader(_value, _header, _rewrite) {\n      const lHeader = normalizeHeader(_header);\n\n      if (!lHeader) {\n        throw new Error('header name must be a non-empty string');\n      }\n\n      const key = utils.findKey(self, lHeader);\n\n      if(!key || self[key] === undefined || _rewrite === true || (_rewrite === undefined && self[key] !== false)) {\n        self[key || _header] = normalizeValue(_value);\n      }\n    }\n\n    const setHeaders = (headers, _rewrite) =>\n      utils.forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite));\n\n    if (utils.isPlainObject(header) || header instanceof this.constructor) {\n      setHeaders(header, valueOrRewrite)\n    } else if(utils.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {\n      setHeaders(parseHeaders(header), valueOrRewrite);\n    } else if (utils.isObject(header) && utils.isIterable(header)) {\n      let obj = {}, dest, key;\n      for (const entry of header) {\n        if (!utils.isArray(entry)) {\n          throw TypeError('Object iterator must return a key-value pair');\n        }\n\n        obj[key = entry[0]] = (dest = obj[key]) ?\n          (utils.isArray(dest) ? [...dest, entry[1]] : [dest, entry[1]]) : entry[1];\n      }\n\n      setHeaders(obj, valueOrRewrite)\n    } else {\n      header != null && setHeader(valueOrRewrite, header, rewrite);\n    }\n\n    return this;\n  }\n\n  get(header, parser) {\n    header = normalizeHeader(header);\n\n    if (header) {\n      const key = utils.findKey(this, header);\n\n      if (key) {\n        const value = this[key];\n\n        if (!parser) {\n          return value;\n        }\n\n        if (parser === true) {\n          return parseTokens(value);\n        }\n\n        if (utils.isFunction(parser)) {\n          return parser.call(this, value, key);\n        }\n\n        if (utils.isRegExp(parser)) {\n          return parser.exec(value);\n        }\n\n        throw new TypeError('parser must be boolean|regexp|function');\n      }\n    }\n  }\n\n  has(header, matcher) {\n    header = normalizeHeader(header);\n\n    if (header) {\n      const key = utils.findKey(this, header);\n\n      return !!(key && this[key] !== undefined && (!matcher || matchHeaderValue(this, this[key], key, matcher)));\n    }\n\n    return false;\n  }\n\n  delete(header, matcher) {\n    const self = this;\n    let deleted = false;\n\n    function deleteHeader(_header) {\n      _header = normalizeHeader(_header);\n\n      if (_header) {\n        const key = utils.findKey(self, _header);\n\n        if (key && (!matcher || matchHeaderValue(self, self[key], key, matcher))) {\n          delete self[key];\n\n          deleted = true;\n        }\n      }\n    }\n\n    if (utils.isArray(header)) {\n      header.forEach(deleteHeader);\n    } else {\n      deleteHeader(header);\n    }\n\n    return deleted;\n  }\n\n  clear(matcher) {\n    const keys = Object.keys(this);\n    let i = keys.length;\n    let deleted = false;\n\n    while (i--) {\n      const key = keys[i];\n      if(!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {\n        delete this[key];\n        deleted = true;\n      }\n    }\n\n    return deleted;\n  }\n\n  normalize(format) {\n    const self = this;\n    const headers = {};\n\n    utils.forEach(this, (value, header) => {\n      const key = utils.findKey(headers, header);\n\n      if (key) {\n        self[key] = normalizeValue(value);\n        delete self[header];\n        return;\n      }\n\n      const normalized = format ? formatHeader(header) : String(header).trim();\n\n      if (normalized !== header) {\n        delete self[header];\n      }\n\n      self[normalized] = normalizeValue(value);\n\n      headers[normalized] = true;\n    });\n\n    return this;\n  }\n\n  concat(...targets) {\n    return this.constructor.concat(this, ...targets);\n  }\n\n  toJSON(asStrings) {\n    const obj = Object.create(null);\n\n    utils.forEach(this, (value, header) => {\n      value != null && value !== false && (obj[header] = asStrings && utils.isArray(value) ? value.join(', ') : value);\n    });\n\n    return obj;\n  }\n\n  [Symbol.iterator]() {\n    return Object.entries(this.toJSON())[Symbol.iterator]();\n  }\n\n  toString() {\n    return Object.entries(this.toJSON()).map(([header, value]) => header + ': ' + value).join('\\n');\n  }\n\n  getSetCookie() {\n    return this.get(\"set-cookie\") || [];\n  }\n\n  get [Symbol.toStringTag]() {\n    return 'AxiosHeaders';\n  }\n\n  static from(thing) {\n    return thing instanceof this ? thing : new this(thing);\n  }\n\n  static concat(first, ...targets) {\n    const computed = new this(first);\n\n    targets.forEach((target) => computed.set(target));\n\n    return computed;\n  }\n\n  static accessor(header) {\n    const internals = this[$internals] = (this[$internals] = {\n      accessors: {}\n    });\n\n    const accessors = internals.accessors;\n    const prototype = this.prototype;\n\n    function defineAccessor(_header) {\n      const lHeader = normalizeHeader(_header);\n\n      if (!accessors[lHeader]) {\n        buildAccessors(prototype, _header);\n        accessors[lHeader] = true;\n      }\n    }\n\n    utils.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);\n\n    return this;\n  }\n}\n\nAxiosHeaders.accessor(['Content-Type', 'Content-Length', 'Accept', 'Accept-Encoding', 'User-Agent', 'Authorization']);\n\n// reserved names hotfix\nutils.reduceDescriptors(AxiosHeaders.prototype, ({value}, key) => {\n  let mapped = key[0].toUpperCase() + key.slice(1); // map `set` => `Set`\n  return {\n    get: () => value,\n    set(headerValue) {\n      this[mapped] = headerValue;\n    }\n  }\n});\n\nutils.freezeMethods(AxiosHeaders);\n\nexport default AxiosHeaders;\n","'use strict';\n\nimport utils from './../utils.js';\nimport defaults from '../defaults/index.js';\nimport AxiosHeaders from '../core/AxiosHeaders.js';\n\n/**\n * Transform the data for a request or a response\n *\n * @param {Array|Function} fns A single function or Array of functions\n * @param {?Object} response The response object\n *\n * @returns {*} The resulting transformed data\n */\nexport default function transformData(fns, response) {\n  const config = this || defaults;\n  const context = response || config;\n  const headers = AxiosHeaders.from(context.headers);\n  let data = context.data;\n\n  utils.forEach(fns, function transform(fn) {\n    data = fn.call(config, data, headers.normalize(), response ? response.status : undefined);\n  });\n\n  headers.normalize();\n\n  return data;\n}\n","'use strict';\n\nexport default function isCancel(value) {\n  return !!(value && value.__CANCEL__);\n}\n","'use strict';\n\nimport AxiosError from '../core/AxiosError.js';\nimport utils from '../utils.js';\n\n/**\n * A `CanceledError` is an object that is thrown when an operation is canceled.\n *\n * @param {string=} message The message.\n * @param {Object=} config The config.\n * @param {Object=} request The request.\n *\n * @returns {CanceledError} The created error.\n */\nfunction CanceledError(message, config, request) {\n  // eslint-disable-next-line no-eq-null,eqeqeq\n  AxiosError.call(this, message == null ? 'canceled' : message, AxiosError.ERR_CANCELED, config, request);\n  this.name = 'CanceledError';\n}\n\nutils.inherits(CanceledError, AxiosError, {\n  __CANCEL__: true\n});\n\nexport default CanceledError;\n","'use strict';\n\nimport AxiosError from './AxiosError.js';\n\n/**\n * Resolve or reject a Promise based on response status.\n *\n * @param {Function} resolve A function that resolves the promise.\n * @param {Function} reject A function that rejects the promise.\n * @param {object} response The response.\n *\n * @returns {object} The response.\n */\nexport default function settle(resolve, reject, response) {\n  const validateStatus = response.config.validateStatus;\n  if (!response.status || !validateStatus || validateStatus(response.status)) {\n    resolve(response);\n  } else {\n    reject(new AxiosError(\n      'Request failed with status code ' + response.status,\n      [AxiosError.ERR_BAD_REQUEST, AxiosError.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4],\n      response.config,\n      response.request,\n      response\n    ));\n  }\n}\n","import speedometer from \"./speedometer.js\";\nimport throttle from \"./throttle.js\";\nimport utils from \"../utils.js\";\n\nexport const progressEventReducer = (listener, isDownloadStream, freq = 3) => {\n  let bytesNotified = 0;\n  const _speedometer = speedometer(50, 250);\n\n  return throttle(e => {\n    const loaded = e.loaded;\n    const total = e.lengthComputable ? e.total : undefined;\n    const progressBytes = loaded - bytesNotified;\n    const rate = _speedometer(progressBytes);\n    const inRange = loaded <= total;\n\n    bytesNotified = loaded;\n\n    const data = {\n      loaded,\n      total,\n      progress: total ? (loaded / total) : undefined,\n      bytes: progressBytes,\n      rate: rate ? rate : undefined,\n      estimated: rate && total && inRange ? (total - loaded) / rate : undefined,\n      event: e,\n      lengthComputable: total != null,\n      [isDownloadStream ? 'download' : 'upload']: true\n    };\n\n    listener(data);\n  }, freq);\n}\n\nexport const progressEventDecorator = (total, throttled) => {\n  const lengthComputable = total != null;\n\n  return [(loaded) => throttled[0]({\n    lengthComputable,\n    total,\n    loaded\n  }), throttled[1]];\n}\n\nexport const asyncDecorator = (fn) => (...args) => utils.asap(() => fn(...args));\n","'use strict';\n\n/**\n * Calculate data maxRate\n * @param {Number} [samplesCount= 10]\n * @param {Number} [min= 1000]\n * @returns {Function}\n */\nfunction speedometer(samplesCount, min) {\n  samplesCount = samplesCount || 10;\n  const bytes = new Array(samplesCount);\n  const timestamps = new Array(samplesCount);\n  let head = 0;\n  let tail = 0;\n  let firstSampleTS;\n\n  min = min !== undefined ? min : 1000;\n\n  return function push(chunkLength) {\n    const now = Date.now();\n\n    const startedAt = timestamps[tail];\n\n    if (!firstSampleTS) {\n      firstSampleTS = now;\n    }\n\n    bytes[head] = chunkLength;\n    timestamps[head] = now;\n\n    let i = tail;\n    let bytesCount = 0;\n\n    while (i !== head) {\n      bytesCount += bytes[i++];\n      i = i % samplesCount;\n    }\n\n    head = (head + 1) % samplesCount;\n\n    if (head === tail) {\n      tail = (tail + 1) % samplesCount;\n    }\n\n    if (now - firstSampleTS < min) {\n      return;\n    }\n\n    const passed = startedAt && now - startedAt;\n\n    return passed ? Math.round(bytesCount * 1000 / passed) : undefined;\n  };\n}\n\nexport default speedometer;\n","/**\n * Throttle decorator\n * @param {Function} fn\n * @param {Number} freq\n * @return {Function}\n */\nfunction throttle(fn, freq) {\n  let timestamp = 0;\n  let threshold = 1000 / freq;\n  let lastArgs;\n  let timer;\n\n  const invoke = (args, now = Date.now()) => {\n    timestamp = now;\n    lastArgs = null;\n    if (timer) {\n      clearTimeout(timer);\n      timer = null;\n    }\n    fn(...args);\n  }\n\n  const throttled = (...args) => {\n    const now = Date.now();\n    const passed = now - timestamp;\n    if ( passed >= threshold) {\n      invoke(args, now);\n    } else {\n      lastArgs = args;\n      if (!timer) {\n        timer = setTimeout(() => {\n          timer = null;\n          invoke(lastArgs)\n        }, threshold - passed);\n      }\n    }\n  }\n\n  const flush = () => lastArgs && invoke(lastArgs);\n\n  return [throttled, flush];\n}\n\nexport default throttle;\n","import platform from '../platform/index.js';\n\nexport default platform.hasStandardBrowserEnv ? ((origin, isMSIE) => (url) => {\n  url = new URL(url, platform.origin);\n\n  return (\n    origin.protocol === url.protocol &&\n    origin.host === url.host &&\n    (isMSIE || origin.port === url.port)\n  );\n})(\n  new URL(platform.origin),\n  platform.navigator && /(msie|trident)/i.test(platform.navigator.userAgent)\n) : () => true;\n","import utils from './../utils.js';\nimport platform from '../platform/index.js';\n\nexport default platform.hasStandardBrowserEnv ?\n\n  // Standard browser envs support document.cookie\n  {\n    write(name, value, expires, path, domain, secure, sameSite) {\n      if (typeof document === 'undefined') return;\n\n      const cookie = [`${name}=${encodeURIComponent(value)}`];\n\n      if (utils.isNumber(expires)) {\n        cookie.push(`expires=${new Date(expires).toUTCString()}`);\n      }\n      if (utils.isString(path)) {\n        cookie.push(`path=${path}`);\n      }\n      if (utils.isString(domain)) {\n        cookie.push(`domain=${domain}`);\n      }\n      if (secure === true) {\n        cookie.push('secure');\n      }\n      if (utils.isString(sameSite)) {\n        cookie.push(`SameSite=${sameSite}`);\n      }\n\n      document.cookie = cookie.join('; ');\n    },\n\n    read(name) {\n      if (typeof document === 'undefined') return null;\n      const match = document.cookie.match(new RegExp('(?:^|; )' + name + '=([^;]*)'));\n      return match ? decodeURIComponent(match[1]) : null;\n    },\n\n    remove(name) {\n      this.write(name, '', Date.now() - 86400000, '/');\n    }\n  }\n\n  :\n\n  // Non-standard browser env (web workers, react-native) lack needed support.\n  {\n    write() {},\n    read() {\n      return null;\n    },\n    remove() {}\n  };\n\n","'use strict';\n\nimport isAbsoluteURL from '../helpers/isAbsoluteURL.js';\nimport combineURLs from '../helpers/combineURLs.js';\n\n/**\n * Creates a new URL by combining the baseURL with the requestedURL,\n * only when the requestedURL is not already an absolute URL.\n * If the requestURL is absolute, this function returns the requestedURL untouched.\n *\n * @param {string} baseURL The base URL\n * @param {string} requestedURL Absolute or relative URL to combine\n *\n * @returns {string} The combined full path\n */\nexport default function buildFullPath(baseURL, requestedURL, allowAbsoluteUrls) {\n  let isRelativeUrl = !isAbsoluteURL(requestedURL);\n  if (baseURL && (isRelativeUrl || allowAbsoluteUrls == false)) {\n    return combineURLs(baseURL, requestedURL);\n  }\n  return requestedURL;\n}\n","'use strict';\n\n/**\n * Determines whether the specified URL is absolute\n *\n * @param {string} url The URL to test\n *\n * @returns {boolean} True if the specified URL is absolute, otherwise false\n */\nexport default function isAbsoluteURL(url) {\n  // A URL is considered absolute if it begins with \"<scheme>://\" or \"//\" (protocol-relative URL).\n  // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed\n  // by any combination of letters, digits, plus, period, or hyphen.\n  return /^([a-z][a-z\\d+\\-.]*:)?\\/\\//i.test(url);\n}\n","'use strict';\n\n/**\n * Creates a new URL by combining the specified URLs\n *\n * @param {string} baseURL The base URL\n * @param {string} relativeURL The relative URL\n *\n * @returns {string} The combined URL\n */\nexport default function combineURLs(baseURL, relativeURL) {\n  return relativeURL\n    ? baseURL.replace(/\\/?\\/$/, '') + '/' + relativeURL.replace(/^\\/+/, '')\n    : baseURL;\n}\n","'use strict';\n\nimport utils from '../utils.js';\nimport AxiosHeaders from \"./AxiosHeaders.js\";\n\nconst headersToObject = (thing) => thing instanceof AxiosHeaders ? { ...thing } : thing;\n\n/**\n * Config-specific merge-function which creates a new config-object\n * by merging two configuration objects together.\n *\n * @param {Object} config1\n * @param {Object} config2\n *\n * @returns {Object} New object resulting from merging config2 to config1\n */\nexport default function mergeConfig(config1, config2) {\n  // eslint-disable-next-line no-param-reassign\n  config2 = config2 || {};\n  const config = {};\n\n  function getMergedValue(target, source, prop, caseless) {\n    if (utils.isPlainObject(target) && utils.isPlainObject(source)) {\n      return utils.merge.call({caseless}, target, source);\n    } else if (utils.isPlainObject(source)) {\n      return utils.merge({}, source);\n    } else if (utils.isArray(source)) {\n      return source.slice();\n    }\n    return source;\n  }\n\n  // eslint-disable-next-line consistent-return\n  function mergeDeepProperties(a, b, prop, caseless) {\n    if (!utils.isUndefined(b)) {\n      return getMergedValue(a, b, prop, caseless);\n    } else if (!utils.isUndefined(a)) {\n      return getMergedValue(undefined, a, prop, caseless);\n    }\n  }\n\n  // eslint-disable-next-line consistent-return\n  function valueFromConfig2(a, b) {\n    if (!utils.isUndefined(b)) {\n      return getMergedValue(undefined, b);\n    }\n  }\n\n  // eslint-disable-next-line consistent-return\n  function defaultToConfig2(a, b) {\n    if (!utils.isUndefined(b)) {\n      return getMergedValue(undefined, b);\n    } else if (!utils.isUndefined(a)) {\n      return getMergedValue(undefined, a);\n    }\n  }\n\n  // eslint-disable-next-line consistent-return\n  function mergeDirectKeys(a, b, prop) {\n    if (prop in config2) {\n      return getMergedValue(a, b);\n    } else if (prop in config1) {\n      return getMergedValue(undefined, a);\n    }\n  }\n\n  const mergeMap = {\n    url: valueFromConfig2,\n    method: valueFromConfig2,\n    data: valueFromConfig2,\n    baseURL: defaultToConfig2,\n    transformRequest: defaultToConfig2,\n    transformResponse: defaultToConfig2,\n    paramsSerializer: defaultToConfig2,\n    timeout: defaultToConfig2,\n    timeoutMessage: defaultToConfig2,\n    withCredentials: defaultToConfig2,\n    withXSRFToken: defaultToConfig2,\n    adapter: defaultToConfig2,\n    responseType: defaultToConfig2,\n    xsrfCookieName: defaultToConfig2,\n    xsrfHeaderName: defaultToConfig2,\n    onUploadProgress: defaultToConfig2,\n    onDownloadProgress: defaultToConfig2,\n    decompress: defaultToConfig2,\n    maxContentLength: defaultToConfig2,\n    maxBodyLength: defaultToConfig2,\n    beforeRedirect: defaultToConfig2,\n    transport: defaultToConfig2,\n    httpAgent: defaultToConfig2,\n    httpsAgent: defaultToConfig2,\n    cancelToken: defaultToConfig2,\n    socketPath: defaultToConfig2,\n    responseEncoding: defaultToConfig2,\n    validateStatus: mergeDirectKeys,\n    headers: (a, b, prop) => mergeDeepProperties(headersToObject(a), headersToObject(b), prop, true)\n  };\n\n  utils.forEach(Object.keys({...config1, ...config2}), function computeConfigValue(prop) {\n    const merge = mergeMap[prop] || mergeDeepProperties;\n    const configValue = merge(config1[prop], config2[prop], prop);\n    (utils.isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue);\n  });\n\n  return config;\n}\n","import platform from \"../platform/index.js\";\nimport utils from \"../utils.js\";\nimport isURLSameOrigin from \"./isURLSameOrigin.js\";\nimport cookies from \"./cookies.js\";\nimport buildFullPath from \"../core/buildFullPath.js\";\nimport mergeConfig from \"../core/mergeConfig.js\";\nimport AxiosHeaders from \"../core/AxiosHeaders.js\";\nimport buildURL from \"./buildURL.js\";\n\nexport default (config) => {\n  const newConfig = mergeConfig({}, config);\n\n  let { data, withXSRFToken, xsrfHeaderName, xsrfCookieName, headers, auth } = newConfig;\n\n  newConfig.headers = headers = AxiosHeaders.from(headers);\n\n  newConfig.url = buildURL(buildFullPath(newConfig.baseURL, newConfig.url, newConfig.allowAbsoluteUrls), config.params, config.paramsSerializer);\n\n  // HTTP basic authentication\n  if (auth) {\n    headers.set('Authorization', 'Basic ' +\n      btoa((auth.username || '') + ':' + (auth.password ? unescape(encodeURIComponent(auth.password)) : ''))\n    );\n  }\n\n  if (utils.isFormData(data)) {\n    if (platform.hasStandardBrowserEnv || platform.hasStandardBrowserWebWorkerEnv) {\n      headers.setContentType(undefined); // browser handles it\n    } else if (utils.isFunction(data.getHeaders)) {\n      // Node.js FormData (like form-data package)\n      const formHeaders = data.getHeaders();\n      // Only set safe headers to avoid overwriting security headers\n      const allowedHeaders = ['content-type', 'content-length'];\n      Object.entries(formHeaders).forEach(([key, val]) => {\n        if (allowedHeaders.includes(key.toLowerCase())) {\n          headers.set(key, val);\n        }\n      });\n    }\n  }  \n\n  // Add xsrf header\n  // This is only done if running in a standard browser environment.\n  // Specifically not if we're in a web worker, or react-native.\n\n  if (platform.hasStandardBrowserEnv) {\n    withXSRFToken && utils.isFunction(withXSRFToken) && (withXSRFToken = withXSRFToken(newConfig));\n\n    if (withXSRFToken || (withXSRFToken !== false && isURLSameOrigin(newConfig.url))) {\n      // Add xsrf header\n      const xsrfValue = xsrfHeaderName && xsrfCookieName && cookies.read(xsrfCookieName);\n\n      if (xsrfValue) {\n        headers.set(xsrfHeaderName, xsrfValue);\n      }\n    }\n  }\n\n  return newConfig;\n}\n\n","import utils from './../utils.js';\nimport settle from './../core/settle.js';\nimport transitionalDefaults from '../defaults/transitional.js';\nimport AxiosError from '../core/AxiosError.js';\nimport CanceledError from '../cancel/CanceledError.js';\nimport parseProtocol from '../helpers/parseProtocol.js';\nimport platform from '../platform/index.js';\nimport AxiosHeaders from '../core/AxiosHeaders.js';\nimport {progressEventReducer} from '../helpers/progressEventReducer.js';\nimport resolveConfig from \"../helpers/resolveConfig.js\";\n\nconst isXHRAdapterSupported = typeof XMLHttpRequest !== 'undefined';\n\nexport default isXHRAdapterSupported && function (config) {\n  return new Promise(function dispatchXhrRequest(resolve, reject) {\n    const _config = resolveConfig(config);\n    let requestData = _config.data;\n    const requestHeaders = AxiosHeaders.from(_config.headers).normalize();\n    let {responseType, onUploadProgress, onDownloadProgress} = _config;\n    let onCanceled;\n    let uploadThrottled, downloadThrottled;\n    let flushUpload, flushDownload;\n\n    function done() {\n      flushUpload && flushUpload(); // flush events\n      flushDownload && flushDownload(); // flush events\n\n      _config.cancelToken && _config.cancelToken.unsubscribe(onCanceled);\n\n      _config.signal && _config.signal.removeEventListener('abort', onCanceled);\n    }\n\n    let request = new XMLHttpRequest();\n\n    request.open(_config.method.toUpperCase(), _config.url, true);\n\n    // Set the request timeout in MS\n    request.timeout = _config.timeout;\n\n    function onloadend() {\n      if (!request) {\n        return;\n      }\n      // Prepare the response\n      const responseHeaders = AxiosHeaders.from(\n        'getAllResponseHeaders' in request && request.getAllResponseHeaders()\n      );\n      const responseData = !responseType || responseType === 'text' || responseType === 'json' ?\n        request.responseText : request.response;\n      const response = {\n        data: responseData,\n        status: request.status,\n        statusText: request.statusText,\n        headers: responseHeaders,\n        config,\n        request\n      };\n\n      settle(function _resolve(value) {\n        resolve(value);\n        done();\n      }, function _reject(err) {\n        reject(err);\n        done();\n      }, response);\n\n      // Clean up request\n      request = null;\n    }\n\n    if ('onloadend' in request) {\n      // Use onloadend if available\n      request.onloadend = onloadend;\n    } else {\n      // Listen for ready state to emulate onloadend\n      request.onreadystatechange = function handleLoad() {\n        if (!request || request.readyState !== 4) {\n          return;\n        }\n\n        // The request errored out and we didn't get a response, this will be\n        // handled by onerror instead\n        // With one exception: request that using file: protocol, most browsers\n        // will return status as 0 even though it's a successful request\n        if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {\n          return;\n        }\n        // readystate handler is calling before onerror or ontimeout handlers,\n        // so we should call onloadend on the next 'tick'\n        setTimeout(onloadend);\n      };\n    }\n\n    // Handle browser request cancellation (as opposed to a manual cancellation)\n    request.onabort = function handleAbort() {\n      if (!request) {\n        return;\n      }\n\n      reject(new AxiosError('Request aborted', AxiosError.ECONNABORTED, config, request));\n\n      // Clean up request\n      request = null;\n    };\n\n    // Handle low level network errors\n  request.onerror = function handleError(event) {\n       // Browsers deliver a ProgressEvent in XHR onerror\n       // (message may be empty; when present, surface it)\n       // See https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/error_event\n       const msg = event && event.message ? event.message : 'Network Error';\n       const err = new AxiosError(msg, AxiosError.ERR_NETWORK, config, request);\n       // attach the underlying event for consumers who want details\n       err.event = event || null;\n       reject(err);\n       request = null;\n    };\n    \n    // Handle timeout\n    request.ontimeout = function handleTimeout() {\n      let timeoutErrorMessage = _config.timeout ? 'timeout of ' + _config.timeout + 'ms exceeded' : 'timeout exceeded';\n      const transitional = _config.transitional || transitionalDefaults;\n      if (_config.timeoutErrorMessage) {\n        timeoutErrorMessage = _config.timeoutErrorMessage;\n      }\n      reject(new AxiosError(\n        timeoutErrorMessage,\n        transitional.clarifyTimeoutError ? AxiosError.ETIMEDOUT : AxiosError.ECONNABORTED,\n        config,\n        request));\n\n      // Clean up request\n      request = null;\n    };\n\n    // Remove Content-Type if data is undefined\n    requestData === undefined && requestHeaders.setContentType(null);\n\n    // Add headers to the request\n    if ('setRequestHeader' in request) {\n      utils.forEach(requestHeaders.toJSON(), function setRequestHeader(val, key) {\n        request.setRequestHeader(key, val);\n      });\n    }\n\n    // Add withCredentials to request if needed\n    if (!utils.isUndefined(_config.withCredentials)) {\n      request.withCredentials = !!_config.withCredentials;\n    }\n\n    // Add responseType to request if needed\n    if (responseType && responseType !== 'json') {\n      request.responseType = _config.responseType;\n    }\n\n    // Handle progress if needed\n    if (onDownloadProgress) {\n      ([downloadThrottled, flushDownload] = progressEventReducer(onDownloadProgress, true));\n      request.addEventListener('progress', downloadThrottled);\n    }\n\n    // Not all browsers support upload events\n    if (onUploadProgress && request.upload) {\n      ([uploadThrottled, flushUpload] = progressEventReducer(onUploadProgress));\n\n      request.upload.addEventListener('progress', uploadThrottled);\n\n      request.upload.addEventListener('loadend', flushUpload);\n    }\n\n    if (_config.cancelToken || _config.signal) {\n      // Handle cancellation\n      // eslint-disable-next-line func-names\n      onCanceled = cancel => {\n        if (!request) {\n          return;\n        }\n        reject(!cancel || cancel.type ? new CanceledError(null, config, request) : cancel);\n        request.abort();\n        request = null;\n      };\n\n      _config.cancelToken && _config.cancelToken.subscribe(onCanceled);\n      if (_config.signal) {\n        _config.signal.aborted ? onCanceled() : _config.signal.addEventListener('abort', onCanceled);\n      }\n    }\n\n    const protocol = parseProtocol(_config.url);\n\n    if (protocol && platform.protocols.indexOf(protocol) === -1) {\n      reject(new AxiosError('Unsupported protocol ' + protocol + ':', AxiosError.ERR_BAD_REQUEST, config));\n      return;\n    }\n\n\n    // Send the request\n    request.send(requestData || null);\n  });\n}\n","'use strict';\n\nexport default function parseProtocol(url) {\n  const match = /^([-+\\w]{1,25})(:?\\/\\/|:)/.exec(url);\n  return match && match[1] || '';\n}\n","import CanceledError from \"../cancel/CanceledError.js\";\nimport AxiosError from \"../core/AxiosError.js\";\nimport utils from '../utils.js';\n\nconst composeSignals = (signals, timeout) => {\n  const {length} = (signals = signals ? signals.filter(Boolean) : []);\n\n  if (timeout || length) {\n    let controller = new AbortController();\n\n    let aborted;\n\n    const onabort = function (reason) {\n      if (!aborted) {\n        aborted = true;\n        unsubscribe();\n        const err = reason instanceof Error ? reason : this.reason;\n        controller.abort(err instanceof AxiosError ? err : new CanceledError(err instanceof Error ? err.message : err));\n      }\n    }\n\n    let timer = timeout && setTimeout(() => {\n      timer = null;\n      onabort(new AxiosError(`timeout ${timeout} of ms exceeded`, AxiosError.ETIMEDOUT))\n    }, timeout)\n\n    const unsubscribe = () => {\n      if (signals) {\n        timer && clearTimeout(timer);\n        timer = null;\n        signals.forEach(signal => {\n          signal.unsubscribe ? signal.unsubscribe(onabort) : signal.removeEventListener('abort', onabort);\n        });\n        signals = null;\n      }\n    }\n\n    signals.forEach((signal) => signal.addEventListener('abort', onabort));\n\n    const {signal} = controller;\n\n    signal.unsubscribe = () => utils.asap(unsubscribe);\n\n    return signal;\n  }\n}\n\nexport default composeSignals;\n","\nexport const streamChunk = function* (chunk, chunkSize) {\n  let len = chunk.byteLength;\n\n  if (!chunkSize || len < chunkSize) {\n    yield chunk;\n    return;\n  }\n\n  let pos = 0;\n  let end;\n\n  while (pos < len) {\n    end = pos + chunkSize;\n    yield chunk.slice(pos, end);\n    pos = end;\n  }\n}\n\nexport const readBytes = async function* (iterable, chunkSize) {\n  for await (const chunk of readStream(iterable)) {\n    yield* streamChunk(chunk, chunkSize);\n  }\n}\n\nconst readStream = async function* (stream) {\n  if (stream[Symbol.asyncIterator]) {\n    yield* stream;\n    return;\n  }\n\n  const reader = stream.getReader();\n  try {\n    for (;;) {\n      const {done, value} = await reader.read();\n      if (done) {\n        break;\n      }\n      yield value;\n    }\n  } finally {\n    await reader.cancel();\n  }\n}\n\nexport const trackStream = (stream, chunkSize, onProgress, onFinish) => {\n  const iterator = readBytes(stream, chunkSize);\n\n  let bytes = 0;\n  let done;\n  let _onFinish = (e) => {\n    if (!done) {\n      done = true;\n      onFinish && onFinish(e);\n    }\n  }\n\n  return new ReadableStream({\n    async pull(controller) {\n      try {\n        const {done, value} = await iterator.next();\n\n        if (done) {\n         _onFinish();\n          controller.close();\n          return;\n        }\n\n        let len = value.byteLength;\n        if (onProgress) {\n          let loadedBytes = bytes += len;\n          onProgress(loadedBytes);\n        }\n        controller.enqueue(new Uint8Array(value));\n      } catch (err) {\n        _onFinish(err);\n        throw err;\n      }\n    },\n    cancel(reason) {\n      _onFinish(reason);\n      return iterator.return();\n    }\n  }, {\n    highWaterMark: 2\n  })\n}\n","import platform from \"../platform/index.js\";\nimport utils from \"../utils.js\";\nimport AxiosError from \"../core/AxiosError.js\";\nimport composeSignals from \"../helpers/composeSignals.js\";\nimport {trackStream} from \"../helpers/trackStream.js\";\nimport AxiosHeaders from \"../core/AxiosHeaders.js\";\nimport {progressEventReducer, progressEventDecorator, asyncDecorator} from \"../helpers/progressEventReducer.js\";\nimport resolveConfig from \"../helpers/resolveConfig.js\";\nimport settle from \"../core/settle.js\";\n\nconst DEFAULT_CHUNK_SIZE = 64 * 1024;\n\nconst {isFunction} = utils;\n\nconst globalFetchAPI = (({Request, Response}) => ({\n  Request, Response\n}))(utils.global);\n\nconst {\n  ReadableStream, TextEncoder\n} = utils.global;\n\n\nconst test = (fn, ...args) => {\n  try {\n    return !!fn(...args);\n  } catch (e) {\n    return false\n  }\n}\n\nconst factory = (env) => {\n  env = utils.merge.call({\n    skipUndefined: true\n  }, globalFetchAPI, env);\n\n  const {fetch: envFetch, Request, Response} = env;\n  const isFetchSupported = envFetch ? isFunction(envFetch) : typeof fetch === 'function';\n  const isRequestSupported = isFunction(Request);\n  const isResponseSupported = isFunction(Response);\n\n  if (!isFetchSupported) {\n    return false;\n  }\n\n  const isReadableStreamSupported = isFetchSupported && isFunction(ReadableStream);\n\n  const encodeText = isFetchSupported && (typeof TextEncoder === 'function' ?\n      ((encoder) => (str) => encoder.encode(str))(new TextEncoder()) :\n      async (str) => new Uint8Array(await new Request(str).arrayBuffer())\n  );\n\n  const supportsRequestStream = isRequestSupported && isReadableStreamSupported && test(() => {\n    let duplexAccessed = false;\n\n    const hasContentType = new Request(platform.origin, {\n      body: new ReadableStream(),\n      method: 'POST',\n      get duplex() {\n        duplexAccessed = true;\n        return 'half';\n      },\n    }).headers.has('Content-Type');\n\n    return duplexAccessed && !hasContentType;\n  });\n\n  const supportsResponseStream = isResponseSupported && isReadableStreamSupported &&\n    test(() => utils.isReadableStream(new Response('').body));\n\n  const resolvers = {\n    stream: supportsResponseStream && ((res) => res.body)\n  };\n\n  isFetchSupported && ((() => {\n    ['text', 'arrayBuffer', 'blob', 'formData', 'stream'].forEach(type => {\n      !resolvers[type] && (resolvers[type] = (res, config) => {\n        let method = res && res[type];\n\n        if (method) {\n          return method.call(res);\n        }\n\n        throw new AxiosError(`Response type '${type}' is not supported`, AxiosError.ERR_NOT_SUPPORT, config);\n      })\n    });\n  })());\n\n  const getBodyLength = async (body) => {\n    if (body == null) {\n      return 0;\n    }\n\n    if (utils.isBlob(body)) {\n      return body.size;\n    }\n\n    if (utils.isSpecCompliantForm(body)) {\n      const _request = new Request(platform.origin, {\n        method: 'POST',\n        body,\n      });\n      return (await _request.arrayBuffer()).byteLength;\n    }\n\n    if (utils.isArrayBufferView(body) || utils.isArrayBuffer(body)) {\n      return body.byteLength;\n    }\n\n    if (utils.isURLSearchParams(body)) {\n      body = body + '';\n    }\n\n    if (utils.isString(body)) {\n      return (await encodeText(body)).byteLength;\n    }\n  }\n\n  const resolveBodyLength = async (headers, body) => {\n    const length = utils.toFiniteNumber(headers.getContentLength());\n\n    return length == null ? getBodyLength(body) : length;\n  }\n\n  return async (config) => {\n    let {\n      url,\n      method,\n      data,\n      signal,\n      cancelToken,\n      timeout,\n      onDownloadProgress,\n      onUploadProgress,\n      responseType,\n      headers,\n      withCredentials = 'same-origin',\n      fetchOptions\n    } = resolveConfig(config);\n\n    let _fetch = envFetch || fetch;\n\n    responseType = responseType ? (responseType + '').toLowerCase() : 'text';\n\n    let composedSignal = composeSignals([signal, cancelToken && cancelToken.toAbortSignal()], timeout);\n\n    let request = null;\n\n    const unsubscribe = composedSignal && composedSignal.unsubscribe && (() => {\n      composedSignal.unsubscribe();\n    });\n\n    let requestContentLength;\n\n    try {\n      if (\n        onUploadProgress && supportsRequestStream && method !== 'get' && method !== 'head' &&\n        (requestContentLength = await resolveBodyLength(headers, data)) !== 0\n      ) {\n        let _request = new Request(url, {\n          method: 'POST',\n          body: data,\n          duplex: \"half\"\n        });\n\n        let contentTypeHeader;\n\n        if (utils.isFormData(data) && (contentTypeHeader = _request.headers.get('content-type'))) {\n          headers.setContentType(contentTypeHeader)\n        }\n\n        if (_request.body) {\n          const [onProgress, flush] = progressEventDecorator(\n            requestContentLength,\n            progressEventReducer(asyncDecorator(onUploadProgress))\n          );\n\n          data = trackStream(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush);\n        }\n      }\n\n      if (!utils.isString(withCredentials)) {\n        withCredentials = withCredentials ? 'include' : 'omit';\n      }\n\n      // Cloudflare Workers throws when credentials are defined\n      // see https://github.com/cloudflare/workerd/issues/902\n      const isCredentialsSupported = isRequestSupported && \"credentials\" in Request.prototype;\n\n      const resolvedOptions = {\n        ...fetchOptions,\n        signal: composedSignal,\n        method: method.toUpperCase(),\n        headers: headers.normalize().toJSON(),\n        body: data,\n        duplex: \"half\",\n        credentials: isCredentialsSupported ? withCredentials : undefined\n      };\n\n      request = isRequestSupported && new Request(url, resolvedOptions);\n\n      let response = await (isRequestSupported ? _fetch(request, fetchOptions) : _fetch(url, resolvedOptions));\n\n      const isStreamResponse = supportsResponseStream && (responseType === 'stream' || responseType === 'response');\n\n      if (supportsResponseStream && (onDownloadProgress || (isStreamResponse && unsubscribe))) {\n        const options = {};\n\n        ['status', 'statusText', 'headers'].forEach(prop => {\n          options[prop] = response[prop];\n        });\n\n        const responseContentLength = utils.toFiniteNumber(response.headers.get('content-length'));\n\n        const [onProgress, flush] = onDownloadProgress && progressEventDecorator(\n          responseContentLength,\n          progressEventReducer(asyncDecorator(onDownloadProgress), true)\n        ) || [];\n\n        response = new Response(\n          trackStream(response.body, DEFAULT_CHUNK_SIZE, onProgress, () => {\n            flush && flush();\n            unsubscribe && unsubscribe();\n          }),\n          options\n        );\n      }\n\n      responseType = responseType || 'text';\n\n      let responseData = await resolvers[utils.findKey(resolvers, responseType) || 'text'](response, config);\n\n      !isStreamResponse && unsubscribe && unsubscribe();\n\n      return await new Promise((resolve, reject) => {\n        settle(resolve, reject, {\n          data: responseData,\n          headers: AxiosHeaders.from(response.headers),\n          status: response.status,\n          statusText: response.statusText,\n          config,\n          request\n        })\n      })\n    } catch (err) {\n      unsubscribe && unsubscribe();\n\n      if (err && err.name === 'TypeError' && /Load failed|fetch/i.test(err.message)) {\n        throw Object.assign(\n          new AxiosError('Network Error', AxiosError.ERR_NETWORK, config, request),\n          {\n            cause: err.cause || err\n          }\n        )\n      }\n\n      throw AxiosError.from(err, err && err.code, config, request);\n    }\n  }\n}\n\nconst seedCache = new Map();\n\nexport const getFetch = (config) => {\n  let env = (config && config.env) || {};\n  const {fetch, Request, Response} = env;\n  const seeds = [\n    Request, Response, fetch\n  ];\n\n  let len = seeds.length, i = len,\n    seed, target, map = seedCache;\n\n  while (i--) {\n    seed = seeds[i];\n    target = map.get(seed);\n\n    target === undefined && map.set(seed, target = (i ? new Map() : factory(env)))\n\n    map = target;\n  }\n\n  return target;\n};\n\nconst adapter = getFetch();\n\nexport default adapter;\n","import utils from '../utils.js';\nimport httpAdapter from './http.js';\nimport xhrAdapter from './xhr.js';\nimport * as fetchAdapter from './fetch.js';\nimport AxiosError from \"../core/AxiosError.js\";\n\n/**\n * Known adapters mapping.\n * Provides environment-specific adapters for Axios:\n * - `http` for Node.js\n * - `xhr` for browsers\n * - `fetch` for fetch API-based requests\n * \n * @type {Object<string, Function|Object>}\n */\nconst knownAdapters = {\n  http: httpAdapter,\n  xhr: xhrAdapter,\n  fetch: {\n    get: fetchAdapter.getFetch,\n  }\n};\n\n// Assign adapter names for easier debugging and identification\nutils.forEach(knownAdapters, (fn, value) => {\n  if (fn) {\n    try {\n      Object.defineProperty(fn, 'name', { value });\n    } catch (e) {\n      // eslint-disable-next-line no-empty\n    }\n    Object.defineProperty(fn, 'adapterName', { value });\n  }\n});\n\n/**\n * Render a rejection reason string for unknown or unsupported adapters\n * \n * @param {string} reason\n * @returns {string}\n */\nconst renderReason = (reason) => `- ${reason}`;\n\n/**\n * Check if the adapter is resolved (function, null, or false)\n * \n * @param {Function|null|false} adapter\n * @returns {boolean}\n */\nconst isResolvedHandle = (adapter) => utils.isFunction(adapter) || adapter === null || adapter === false;\n\n/**\n * Get the first suitable adapter from the provided list.\n * Tries each adapter in order until a supported one is found.\n * Throws an AxiosError if no adapter is suitable.\n * \n * @param {Array<string|Function>|string|Function} adapters - Adapter(s) by name or function.\n * @param {Object} config - Axios request configuration\n * @throws {AxiosError} If no suitable adapter is available\n * @returns {Function} The resolved adapter function\n */\nfunction getAdapter(adapters, config) {\n  adapters = utils.isArray(adapters) ? adapters : [adapters];\n\n  const { length } = adapters;\n  let nameOrAdapter;\n  let adapter;\n\n  const rejectedReasons = {};\n\n  for (let i = 0; i < length; i++) {\n    nameOrAdapter = adapters[i];\n    let id;\n\n    adapter = nameOrAdapter;\n\n    if (!isResolvedHandle(nameOrAdapter)) {\n      adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];\n\n      if (adapter === undefined) {\n        throw new AxiosError(`Unknown adapter '${id}'`);\n      }\n    }\n\n    if (adapter && (utils.isFunction(adapter) || (adapter = adapter.get(config)))) {\n      break;\n    }\n\n    rejectedReasons[id || '#' + i] = adapter;\n  }\n\n  if (!adapter) {\n    const reasons = Object.entries(rejectedReasons)\n      .map(([id, state]) => `adapter ${id} ` +\n        (state === false ? 'is not supported by the environment' : 'is not available in the build')\n      );\n\n    let s = length ?\n      (reasons.length > 1 ? 'since :\\n' + reasons.map(renderReason).join('\\n') : ' ' + renderReason(reasons[0])) :\n      'as no adapter specified';\n\n    throw new AxiosError(\n      `There is no suitable adapter to dispatch the request ` + s,\n      'ERR_NOT_SUPPORT'\n    );\n  }\n\n  return adapter;\n}\n\n/**\n * Exports Axios adapters and utility to resolve an adapter\n */\nexport default {\n  /**\n   * Resolve an adapter from a list of adapter names or functions.\n   * @type {Function}\n   */\n  getAdapter,\n\n  /**\n   * Exposes all known adapters\n   * @type {Object<string, Function|Object>}\n   */\n  adapters: knownAdapters\n};\n","// eslint-disable-next-line strict\nexport default null;\n","'use strict';\n\nimport transformData from './transformData.js';\nimport isCancel from '../cancel/isCancel.js';\nimport defaults from '../defaults/index.js';\nimport CanceledError from '../cancel/CanceledError.js';\nimport AxiosHeaders from '../core/AxiosHeaders.js';\nimport adapters from \"../adapters/adapters.js\";\n\n/**\n * Throws a `CanceledError` if cancellation has been requested.\n *\n * @param {Object} config The config that is to be used for the request\n *\n * @returns {void}\n */\nfunction throwIfCancellationRequested(config) {\n  if (config.cancelToken) {\n    config.cancelToken.throwIfRequested();\n  }\n\n  if (config.signal && config.signal.aborted) {\n    throw new CanceledError(null, config);\n  }\n}\n\n/**\n * Dispatch a request to the server using the configured adapter.\n *\n * @param {object} config The config that is to be used for the request\n *\n * @returns {Promise} The Promise to be fulfilled\n */\nexport default function dispatchRequest(config) {\n  throwIfCancellationRequested(config);\n\n  config.headers = AxiosHeaders.from(config.headers);\n\n  // Transform request data\n  config.data = transformData.call(\n    config,\n    config.transformRequest\n  );\n\n  if (['post', 'put', 'patch'].indexOf(config.method) !== -1) {\n    config.headers.setContentType('application/x-www-form-urlencoded', false);\n  }\n\n  const adapter = adapters.getAdapter(config.adapter || defaults.adapter, config);\n\n  return adapter(config).then(function onAdapterResolution(response) {\n    throwIfCancellationRequested(config);\n\n    // Transform response data\n    response.data = transformData.call(\n      config,\n      config.transformResponse,\n      response\n    );\n\n    response.headers = AxiosHeaders.from(response.headers);\n\n    return response;\n  }, function onAdapterRejection(reason) {\n    if (!isCancel(reason)) {\n      throwIfCancellationRequested(config);\n\n      // Transform response data\n      if (reason && reason.response) {\n        reason.response.data = transformData.call(\n          config,\n          config.transformResponse,\n          reason.response\n        );\n        reason.response.headers = AxiosHeaders.from(reason.response.headers);\n      }\n    }\n\n    return Promise.reject(reason);\n  });\n}\n","export const VERSION = \"1.13.2\";","'use strict';\n\nimport {VERSION} from '../env/data.js';\nimport AxiosError from '../core/AxiosError.js';\n\nconst validators = {};\n\n// eslint-disable-next-line func-names\n['object', 'boolean', 'number', 'function', 'string', 'symbol'].forEach((type, i) => {\n  validators[type] = function validator(thing) {\n    return typeof thing === type || 'a' + (i < 1 ? 'n ' : ' ') + type;\n  };\n});\n\nconst deprecatedWarnings = {};\n\n/**\n * Transitional option validator\n *\n * @param {function|boolean?} validator - set to false if the transitional option has been removed\n * @param {string?} version - deprecated version / removed since version\n * @param {string?} message - some message with additional info\n *\n * @returns {function}\n */\nvalidators.transitional = function transitional(validator, version, message) {\n  function formatMessage(opt, desc) {\n    return '[Axios v' + VERSION + '] Transitional option \\'' + opt + '\\'' + desc + (message ? '. ' + message : '');\n  }\n\n  // eslint-disable-next-line func-names\n  return (value, opt, opts) => {\n    if (validator === false) {\n      throw new AxiosError(\n        formatMessage(opt, ' has been removed' + (version ? ' in ' + version : '')),\n        AxiosError.ERR_DEPRECATED\n      );\n    }\n\n    if (version && !deprecatedWarnings[opt]) {\n      deprecatedWarnings[opt] = true;\n      // eslint-disable-next-line no-console\n      console.warn(\n        formatMessage(\n          opt,\n          ' has been deprecated since v' + version + ' and will be removed in the near future'\n        )\n      );\n    }\n\n    return validator ? validator(value, opt, opts) : true;\n  };\n};\n\nvalidators.spelling = function spelling(correctSpelling) {\n  return (value, opt) => {\n    // eslint-disable-next-line no-console\n    console.warn(`${opt} is likely a misspelling of ${correctSpelling}`);\n    return true;\n  }\n};\n\n/**\n * Assert object's properties type\n *\n * @param {object} options\n * @param {object} schema\n * @param {boolean?} allowUnknown\n *\n * @returns {object}\n */\n\nfunction assertOptions(options, schema, allowUnknown) {\n  if (typeof options !== 'object') {\n    throw new AxiosError('options must be an object', AxiosError.ERR_BAD_OPTION_VALUE);\n  }\n  const keys = Object.keys(options);\n  let i = keys.length;\n  while (i-- > 0) {\n    const opt = keys[i];\n    const validator = schema[opt];\n    if (validator) {\n      const value = options[opt];\n      const result = value === undefined || validator(value, opt, options);\n      if (result !== true) {\n        throw new AxiosError('option ' + opt + ' must be ' + result, AxiosError.ERR_BAD_OPTION_VALUE);\n      }\n      continue;\n    }\n    if (allowUnknown !== true) {\n      throw new AxiosError('Unknown option ' + opt, AxiosError.ERR_BAD_OPTION);\n    }\n  }\n}\n\nexport default {\n  assertOptions,\n  validators\n};\n","'use strict';\n\nimport utils from './../utils.js';\nimport buildURL from '../helpers/buildURL.js';\nimport InterceptorManager from './InterceptorManager.js';\nimport dispatchRequest from './dispatchRequest.js';\nimport mergeConfig from './mergeConfig.js';\nimport buildFullPath from './buildFullPath.js';\nimport validator from '../helpers/validator.js';\nimport AxiosHeaders from './AxiosHeaders.js';\n\nconst validators = validator.validators;\n\n/**\n * Create a new instance of Axios\n *\n * @param {Object} instanceConfig The default config for the instance\n *\n * @return {Axios} A new instance of Axios\n */\nclass Axios {\n  constructor(instanceConfig) {\n    this.defaults = instanceConfig || {};\n    this.interceptors = {\n      request: new InterceptorManager(),\n      response: new InterceptorManager()\n    };\n  }\n\n  /**\n   * Dispatch a request\n   *\n   * @param {String|Object} configOrUrl The config specific for this request (merged with this.defaults)\n   * @param {?Object} config\n   *\n   * @returns {Promise} The Promise to be fulfilled\n   */\n  async request(configOrUrl, config) {\n    try {\n      return await this._request(configOrUrl, config);\n    } catch (err) {\n      if (err instanceof Error) {\n        let dummy = {};\n\n        Error.captureStackTrace ? Error.captureStackTrace(dummy) : (dummy = new Error());\n\n        // slice off the Error: ... line\n        const stack = dummy.stack ? dummy.stack.replace(/^.+\\n/, '') : '';\n        try {\n          if (!err.stack) {\n            err.stack = stack;\n            // match without the 2 top stack lines\n          } else if (stack && !String(err.stack).endsWith(stack.replace(/^.+\\n.+\\n/, ''))) {\n            err.stack += '\\n' + stack\n          }\n        } catch (e) {\n          // ignore the case where \"stack\" is an un-writable property\n        }\n      }\n\n      throw err;\n    }\n  }\n\n  _request(configOrUrl, config) {\n    /*eslint no-param-reassign:0*/\n    // Allow for axios('example/url'[, config]) a la fetch API\n    if (typeof configOrUrl === 'string') {\n      config = config || {};\n      config.url = configOrUrl;\n    } else {\n      config = configOrUrl || {};\n    }\n\n    config = mergeConfig(this.defaults, config);\n\n    const {transitional, paramsSerializer, headers} = config;\n\n    if (transitional !== undefined) {\n      validator.assertOptions(transitional, {\n        silentJSONParsing: validators.transitional(validators.boolean),\n        forcedJSONParsing: validators.transitional(validators.boolean),\n        clarifyTimeoutError: validators.transitional(validators.boolean)\n      }, false);\n    }\n\n    if (paramsSerializer != null) {\n      if (utils.isFunction(paramsSerializer)) {\n        config.paramsSerializer = {\n          serialize: paramsSerializer\n        }\n      } else {\n        validator.assertOptions(paramsSerializer, {\n          encode: validators.function,\n          serialize: validators.function\n        }, true);\n      }\n    }\n\n    // Set config.allowAbsoluteUrls\n    if (config.allowAbsoluteUrls !== undefined) {\n      // do nothing\n    } else if (this.defaults.allowAbsoluteUrls !== undefined) {\n      config.allowAbsoluteUrls = this.defaults.allowAbsoluteUrls;\n    } else {\n      config.allowAbsoluteUrls = true;\n    }\n\n    validator.assertOptions(config, {\n      baseUrl: validators.spelling('baseURL'),\n      withXsrfToken: validators.spelling('withXSRFToken')\n    }, true);\n\n    // Set config.method\n    config.method = (config.method || this.defaults.method || 'get').toLowerCase();\n\n    // Flatten headers\n    let contextHeaders = headers && utils.merge(\n      headers.common,\n      headers[config.method]\n    );\n\n    headers && utils.forEach(\n      ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],\n      (method) => {\n        delete headers[method];\n      }\n    );\n\n    config.headers = AxiosHeaders.concat(contextHeaders, headers);\n\n    // filter out skipped interceptors\n    const requestInterceptorChain = [];\n    let synchronousRequestInterceptors = true;\n    this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {\n      if (typeof interceptor.runWhen === 'function' && interceptor.runWhen(config) === false) {\n        return;\n      }\n\n      synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;\n\n      requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);\n    });\n\n    const responseInterceptorChain = [];\n    this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {\n      responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);\n    });\n\n    let promise;\n    let i = 0;\n    let len;\n\n    if (!synchronousRequestInterceptors) {\n      const chain = [dispatchRequest.bind(this), undefined];\n      chain.unshift(...requestInterceptorChain);\n      chain.push(...responseInterceptorChain);\n      len = chain.length;\n\n      promise = Promise.resolve(config);\n\n      while (i < len) {\n        promise = promise.then(chain[i++], chain[i++]);\n      }\n\n      return promise;\n    }\n\n    len = requestInterceptorChain.length;\n\n    let newConfig = config;\n\n    while (i < len) {\n      const onFulfilled = requestInterceptorChain[i++];\n      const onRejected = requestInterceptorChain[i++];\n      try {\n        newConfig = onFulfilled(newConfig);\n      } catch (error) {\n        onRejected.call(this, error);\n        break;\n      }\n    }\n\n    try {\n      promise = dispatchRequest.call(this, newConfig);\n    } catch (error) {\n      return Promise.reject(error);\n    }\n\n    i = 0;\n    len = responseInterceptorChain.length;\n\n    while (i < len) {\n      promise = promise.then(responseInterceptorChain[i++], responseInterceptorChain[i++]);\n    }\n\n    return promise;\n  }\n\n  getUri(config) {\n    config = mergeConfig(this.defaults, config);\n    const fullPath = buildFullPath(config.baseURL, config.url, config.allowAbsoluteUrls);\n    return buildURL(fullPath, config.params, config.paramsSerializer);\n  }\n}\n\n// Provide aliases for supported request methods\nutils.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) {\n  /*eslint func-names:0*/\n  Axios.prototype[method] = function(url, config) {\n    return this.request(mergeConfig(config || {}, {\n      method,\n      url,\n      data: (config || {}).data\n    }));\n  };\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n  /*eslint func-names:0*/\n\n  function generateHTTPMethod(isForm) {\n    return function httpMethod(url, data, config) {\n      return this.request(mergeConfig(config || {}, {\n        method,\n        headers: isForm ? {\n          'Content-Type': 'multipart/form-data'\n        } : {},\n        url,\n        data\n      }));\n    };\n  }\n\n  Axios.prototype[method] = generateHTTPMethod();\n\n  Axios.prototype[method + 'Form'] = generateHTTPMethod(true);\n});\n\nexport default Axios;\n","'use strict';\n\nimport CanceledError from './CanceledError.js';\n\n/**\n * A `CancelToken` is an object that can be used to request cancellation of an operation.\n *\n * @param {Function} executor The executor function.\n *\n * @returns {CancelToken}\n */\nclass CancelToken {\n  constructor(executor) {\n    if (typeof executor !== 'function') {\n      throw new TypeError('executor must be a function.');\n    }\n\n    let resolvePromise;\n\n    this.promise = new Promise(function promiseExecutor(resolve) {\n      resolvePromise = resolve;\n    });\n\n    const token = this;\n\n    // eslint-disable-next-line func-names\n    this.promise.then(cancel => {\n      if (!token._listeners) return;\n\n      let i = token._listeners.length;\n\n      while (i-- > 0) {\n        token._listeners[i](cancel);\n      }\n      token._listeners = null;\n    });\n\n    // eslint-disable-next-line func-names\n    this.promise.then = onfulfilled => {\n      let _resolve;\n      // eslint-disable-next-line func-names\n      const promise = new Promise(resolve => {\n        token.subscribe(resolve);\n        _resolve = resolve;\n      }).then(onfulfilled);\n\n      promise.cancel = function reject() {\n        token.unsubscribe(_resolve);\n      };\n\n      return promise;\n    };\n\n    executor(function cancel(message, config, request) {\n      if (token.reason) {\n        // Cancellation has already been requested\n        return;\n      }\n\n      token.reason = new CanceledError(message, config, request);\n      resolvePromise(token.reason);\n    });\n  }\n\n  /**\n   * Throws a `CanceledError` if cancellation has been requested.\n   */\n  throwIfRequested() {\n    if (this.reason) {\n      throw this.reason;\n    }\n  }\n\n  /**\n   * Subscribe to the cancel signal\n   */\n\n  subscribe(listener) {\n    if (this.reason) {\n      listener(this.reason);\n      return;\n    }\n\n    if (this._listeners) {\n      this._listeners.push(listener);\n    } else {\n      this._listeners = [listener];\n    }\n  }\n\n  /**\n   * Unsubscribe from the cancel signal\n   */\n\n  unsubscribe(listener) {\n    if (!this._listeners) {\n      return;\n    }\n    const index = this._listeners.indexOf(listener);\n    if (index !== -1) {\n      this._listeners.splice(index, 1);\n    }\n  }\n\n  toAbortSignal() {\n    const controller = new AbortController();\n\n    const abort = (err) => {\n      controller.abort(err);\n    };\n\n    this.subscribe(abort);\n\n    controller.signal.unsubscribe = () => this.unsubscribe(abort);\n\n    return controller.signal;\n  }\n\n  /**\n   * Returns an object that contains a new `CancelToken` and a function that, when called,\n   * cancels the `CancelToken`.\n   */\n  static source() {\n    let cancel;\n    const token = new CancelToken(function executor(c) {\n      cancel = c;\n    });\n    return {\n      token,\n      cancel\n    };\n  }\n}\n\nexport default CancelToken;\n","const HttpStatusCode = {\n  Continue: 100,\n  SwitchingProtocols: 101,\n  Processing: 102,\n  EarlyHints: 103,\n  Ok: 200,\n  Created: 201,\n  Accepted: 202,\n  NonAuthoritativeInformation: 203,\n  NoContent: 204,\n  ResetContent: 205,\n  PartialContent: 206,\n  MultiStatus: 207,\n  AlreadyReported: 208,\n  ImUsed: 226,\n  MultipleChoices: 300,\n  MovedPermanently: 301,\n  Found: 302,\n  SeeOther: 303,\n  NotModified: 304,\n  UseProxy: 305,\n  Unused: 306,\n  TemporaryRedirect: 307,\n  PermanentRedirect: 308,\n  BadRequest: 400,\n  Unauthorized: 401,\n  PaymentRequired: 402,\n  Forbidden: 403,\n  NotFound: 404,\n  MethodNotAllowed: 405,\n  NotAcceptable: 406,\n  ProxyAuthenticationRequired: 407,\n  RequestTimeout: 408,\n  Conflict: 409,\n  Gone: 410,\n  LengthRequired: 411,\n  PreconditionFailed: 412,\n  PayloadTooLarge: 413,\n  UriTooLong: 414,\n  UnsupportedMediaType: 415,\n  RangeNotSatisfiable: 416,\n  ExpectationFailed: 417,\n  ImATeapot: 418,\n  MisdirectedRequest: 421,\n  UnprocessableEntity: 422,\n  Locked: 423,\n  FailedDependency: 424,\n  TooEarly: 425,\n  UpgradeRequired: 426,\n  PreconditionRequired: 428,\n  TooManyRequests: 429,\n  RequestHeaderFieldsTooLarge: 431,\n  UnavailableForLegalReasons: 451,\n  InternalServerError: 500,\n  NotImplemented: 501,\n  BadGateway: 502,\n  ServiceUnavailable: 503,\n  GatewayTimeout: 504,\n  HttpVersionNotSupported: 505,\n  VariantAlsoNegotiates: 506,\n  InsufficientStorage: 507,\n  LoopDetected: 508,\n  NotExtended: 510,\n  NetworkAuthenticationRequired: 511,\n  WebServerIsDown: 521,\n  ConnectionTimedOut: 522,\n  OriginIsUnreachable: 523,\n  TimeoutOccurred: 524,\n  SslHandshakeFailed: 525,\n  InvalidSslCertificate: 526,\n};\n\nObject.entries(HttpStatusCode).forEach(([key, value]) => {\n  HttpStatusCode[value] = key;\n});\n\nexport default HttpStatusCode;\n","'use strict';\n\nimport utils from './utils.js';\nimport bind from './helpers/bind.js';\nimport Axios from './core/Axios.js';\nimport mergeConfig from './core/mergeConfig.js';\nimport defaults from './defaults/index.js';\nimport formDataToJSON from './helpers/formDataToJSON.js';\nimport CanceledError from './cancel/CanceledError.js';\nimport CancelToken from './cancel/CancelToken.js';\nimport isCancel from './cancel/isCancel.js';\nimport {VERSION} from './env/data.js';\nimport toFormData from './helpers/toFormData.js';\nimport AxiosError from './core/AxiosError.js';\nimport spread from './helpers/spread.js';\nimport isAxiosError from './helpers/isAxiosError.js';\nimport AxiosHeaders from \"./core/AxiosHeaders.js\";\nimport adapters from './adapters/adapters.js';\nimport HttpStatusCode from './helpers/HttpStatusCode.js';\n\n/**\n * Create an instance of Axios\n *\n * @param {Object} defaultConfig The default config for the instance\n *\n * @returns {Axios} A new instance of Axios\n */\nfunction createInstance(defaultConfig) {\n  const context = new Axios(defaultConfig);\n  const instance = bind(Axios.prototype.request, context);\n\n  // Copy axios.prototype to instance\n  utils.extend(instance, Axios.prototype, context, {allOwnKeys: true});\n\n  // Copy context to instance\n  utils.extend(instance, context, null, {allOwnKeys: true});\n\n  // Factory for creating new instances\n  instance.create = function create(instanceConfig) {\n    return createInstance(mergeConfig(defaultConfig, instanceConfig));\n  };\n\n  return instance;\n}\n\n// Create the default instance to be exported\nconst axios = createInstance(defaults);\n\n// Expose Axios class to allow class inheritance\naxios.Axios = Axios;\n\n// Expose Cancel & CancelToken\naxios.CanceledError = CanceledError;\naxios.CancelToken = CancelToken;\naxios.isCancel = isCancel;\naxios.VERSION = VERSION;\naxios.toFormData = toFormData;\n\n// Expose AxiosError class\naxios.AxiosError = AxiosError;\n\n// alias for CanceledError for backward compatibility\naxios.Cancel = axios.CanceledError;\n\n// Expose all/spread\naxios.all = function all(promises) {\n  return Promise.all(promises);\n};\n\naxios.spread = spread;\n\n// Expose isAxiosError\naxios.isAxiosError = isAxiosError;\n\n// Expose mergeConfig\naxios.mergeConfig = mergeConfig;\n\naxios.AxiosHeaders = AxiosHeaders;\n\naxios.formToJSON = thing => formDataToJSON(utils.isHTMLForm(thing) ? new FormData(thing) : thing);\n\naxios.getAdapter = adapters.getAdapter;\n\naxios.HttpStatusCode = HttpStatusCode;\n\naxios.default = axios;\n\n// this module should only have a default export\nexport default axios\n","'use strict';\n\n/**\n * Syntactic sugar for invoking a function and expanding an array for arguments.\n *\n * Common use case would be to use `Function.prototype.apply`.\n *\n *  ```js\n *  function f(x, y, z) {}\n *  var args = [1, 2, 3];\n *  f.apply(null, args);\n *  ```\n *\n * With `spread` this example can be re-written.\n *\n *  ```js\n *  spread(function(x, y, z) {})([1, 2, 3]);\n *  ```\n *\n * @param {Function} callback\n *\n * @returns {Function}\n */\nexport default function spread(callback) {\n  return function wrap(arr) {\n    return callback.apply(null, arr);\n  };\n}\n","'use strict';\n\nimport utils from './../utils.js';\n\n/**\n * Determines whether the payload is an error thrown by Axios\n *\n * @param {*} payload The value to test\n *\n * @returns {boolean} True if the payload is an error thrown by Axios, otherwise false\n */\nexport default function isAxiosError(payload) {\n  return utils.isObject(payload) && (payload.isAxiosError === true);\n}\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\nvar K_MAX_LENGTH = 0x7fffffff\nexports.kMaxLength = K_MAX_LENGTH\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Print warning and recommend using `buffer` v4.x which has an Object\n *               implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * We report that the browser does not support typed arrays if the are not subclassable\n * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`\n * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support\n * for __proto__ and has a buggy typed array implementation.\n */\nBuffer.TYPED_ARRAY_SUPPORT = typedArraySupport()\n\nif (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&\n    typeof console.error === 'function') {\n  console.error(\n    'This browser lacks typed array (Uint8Array) support which is required by ' +\n    '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'\n  )\n}\n\nfunction typedArraySupport () {\n  // Can typed array instances can be augmented?\n  try {\n    var arr = new Uint8Array(1)\n    arr.__proto__ = { __proto__: Uint8Array.prototype, foo: function () { return 42 } }\n    return arr.foo() === 42\n  } catch (e) {\n    return false\n  }\n}\n\nObject.defineProperty(Buffer.prototype, 'parent', {\n  enumerable: true,\n  get: function () {\n    if (!Buffer.isBuffer(this)) return undefined\n    return this.buffer\n  }\n})\n\nObject.defineProperty(Buffer.prototype, 'offset', {\n  enumerable: true,\n  get: function () {\n    if (!Buffer.isBuffer(this)) return undefined\n    return this.byteOffset\n  }\n})\n\nfunction createBuffer (length) {\n  if (length > K_MAX_LENGTH) {\n    throw new RangeError('The value \"' + length + '\" is invalid for option \"size\"')\n  }\n  // Return an augmented `Uint8Array` instance\n  var buf = new Uint8Array(length)\n  buf.__proto__ = Buffer.prototype\n  return buf\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new TypeError(\n        'The \"string\" argument must be of type string. Received type number'\n      )\n    }\n    return allocUnsafe(arg)\n  }\n  return from(arg, encodingOrOffset, length)\n}\n\n// Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\nif (typeof Symbol !== 'undefined' && Symbol.species != null &&\n    Buffer[Symbol.species] === Buffer) {\n  Object.defineProperty(Buffer, Symbol.species, {\n    value: null,\n    configurable: true,\n    enumerable: false,\n    writable: false\n  })\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\nfunction from (value, encodingOrOffset, length) {\n  if (typeof value === 'string') {\n    return fromString(value, encodingOrOffset)\n  }\n\n  if (ArrayBuffer.isView(value)) {\n    return fromArrayLike(value)\n  }\n\n  if (value == null) {\n    throw TypeError(\n      'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\n      'or Array-like Object. Received type ' + (typeof value)\n    )\n  }\n\n  if (isInstance(value, ArrayBuffer) ||\n      (value && isInstance(value.buffer, ArrayBuffer))) {\n    return fromArrayBuffer(value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'number') {\n    throw new TypeError(\n      'The \"value\" argument must not be of type number. Received type number'\n    )\n  }\n\n  var valueOf = value.valueOf && value.valueOf()\n  if (valueOf != null && valueOf !== value) {\n    return Buffer.from(valueOf, encodingOrOffset, length)\n  }\n\n  var b = fromObject(value)\n  if (b) return b\n\n  if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&\n      typeof value[Symbol.toPrimitive] === 'function') {\n    return Buffer.from(\n      value[Symbol.toPrimitive]('string'), encodingOrOffset, length\n    )\n  }\n\n  throw new TypeError(\n    'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\n    'or Array-like Object. Received type ' + (typeof value)\n  )\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(value, encodingOrOffset, length)\n}\n\n// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:\n// https://github.com/feross/buffer/pull/148\nBuffer.prototype.__proto__ = Uint8Array.prototype\nBuffer.__proto__ = Uint8Array\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be of type number')\n  } else if (size < 0) {\n    throw new RangeError('The value \"' + size + '\" is invalid for option \"size\"')\n  }\n}\n\nfunction alloc (size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(size).fill(fill, encoding)\n      : createBuffer(size).fill(fill)\n  }\n  return createBuffer(size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(size, fill, encoding)\n}\n\nfunction allocUnsafe (size) {\n  assertSize(size)\n  return createBuffer(size < 0 ? 0 : checked(size) | 0)\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(size)\n}\n\nfunction fromString (string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('Unknown encoding: ' + encoding)\n  }\n\n  var length = byteLength(string, encoding) | 0\n  var buf = createBuffer(length)\n\n  var actual = buf.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    buf = buf.slice(0, actual)\n  }\n\n  return buf\n}\n\nfunction fromArrayLike (array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  var buf = createBuffer(length)\n  for (var i = 0; i < length; i += 1) {\n    buf[i] = array[i] & 255\n  }\n  return buf\n}\n\nfunction fromArrayBuffer (array, byteOffset, length) {\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\"offset\" is outside of buffer bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\"length\" is outside of buffer bounds')\n  }\n\n  var buf\n  if (byteOffset === undefined && length === undefined) {\n    buf = new Uint8Array(array)\n  } else if (length === undefined) {\n    buf = new Uint8Array(array, byteOffset)\n  } else {\n    buf = new Uint8Array(array, byteOffset, length)\n  }\n\n  // Return an augmented `Uint8Array` instance\n  buf.__proto__ = Buffer.prototype\n  return buf\n}\n\nfunction fromObject (obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    var buf = createBuffer(len)\n\n    if (buf.length === 0) {\n      return buf\n    }\n\n    obj.copy(buf, 0, 0, len)\n    return buf\n  }\n\n  if (obj.length !== undefined) {\n    if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {\n      return createBuffer(0)\n    }\n    return fromArrayLike(obj)\n  }\n\n  if (obj.type === 'Buffer' && Array.isArray(obj.data)) {\n    return fromArrayLike(obj.data)\n  }\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < K_MAX_LENGTH` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= K_MAX_LENGTH) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return b != null && b._isBuffer === true &&\n    b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false\n}\n\nBuffer.compare = function compare (a, b) {\n  if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)\n  if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError(\n      'The \"buf1\", \"buf2\" arguments must be one of type Buffer or Uint8Array'\n    )\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!Array.isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length)\n  var pos = 0\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i]\n    if (isInstance(buf, Uint8Array)) {\n      buf = Buffer.from(buf)\n    }\n    if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    }\n    buf.copy(buffer, pos)\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    throw new TypeError(\n      'The \"string\" argument must be one of type string, Buffer, or ArrayBuffer. ' +\n      'Received type ' + typeof string\n    )\n  }\n\n  var len = string.length\n  var mustMatch = (arguments.length > 2 && arguments[2] === true)\n  if (!mustMatch && len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) {\n          return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8\n        }\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)\n// to detect a Buffer instance. It's not possible to use `instanceof Buffer`\n// reliably in a browserify context because there could be multiple different\n// copies of the 'buffer' package in use. This method works even for Buffer\n// instances that were created from another copy of the `buffer` package.\n// See: https://github.com/feross/buffer/issues/154\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  var i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  var len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  var len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  var len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.toLocaleString = Buffer.prototype.toString\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()\n  if (this.length > max) str += ' ... '\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (isInstance(target, Uint8Array)) {\n    target = Buffer.from(target, target.offset, target.byteLength)\n  }\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError(\n      'The \"target\" argument must be one of type Buffer or Uint8Array. ' +\n      'Received type ' + (typeof target)\n    )\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  var x = thisEnd - thisStart\n  var y = end - start\n  var len = Math.min(x, y)\n\n  var thisCopy = this.slice(thisStart, thisEnd)\n  var targetCopy = target.slice(start, end)\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset // Coerce to Number.\n  if (numberIsNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1\n  var arrLength = arr.length\n  var valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  var i\n  if (dir) {\n    var foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  var strLen = string.length\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (numberIsNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset >>> 0\n    if (isFinite(length)) {\n      length = length >>> 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n        : (firstByte > 0xBF) ? 2\n          : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256))\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf = this.subarray(start, end)\n  // Return an augmented `Uint8Array` instance\n  newBuf.__proto__ = Buffer.prototype\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  this[offset] = (value >>> 8)\n  this[offset + 1] = (value & 0xff)\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  this[offset + 3] = (value >>> 24)\n  this[offset + 2] = (value >>> 16)\n  this[offset + 1] = (value >>> 8)\n  this[offset] = (value & 0xff)\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  this[offset] = (value >>> 24)\n  this[offset + 1] = (value >>> 16)\n  this[offset + 2] = (value >>> 8)\n  this[offset + 3] = (value & 0xff)\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    var limit = Math.pow(2, (8 * byteLength) - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    var limit = Math.pow(2, (8 * byteLength) - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  this[offset] = (value >>> 8)\n  this[offset + 1] = (value & 0xff)\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\n  this[offset + 2] = (value >>> 16)\n  this[offset + 3] = (value >>> 24)\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  this[offset] = (value >>> 24)\n  this[offset + 1] = (value >>> 16)\n  this[offset + 2] = (value >>> 8)\n  this[offset + 3] = (value & 0xff)\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('Index out of range')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n\n  if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {\n    // Use built-in when available, missing from IE11\n    this.copyWithin(targetStart, start, end)\n  } else if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (var i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, end),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if ((encoding === 'utf8' && code < 128) ||\n          encoding === 'latin1') {\n        // Fast path: If `val` fits into a single byte, use that numeric value.\n        val = code\n      }\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  var i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val)\n      ? val\n      : Buffer.from(val, encoding)\n    var len = bytes.length\n    if (len === 0) {\n      throw new TypeError('The value \"' + val +\n        '\" is invalid for argument \"value\"')\n    }\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node takes equal signs as end of the Base64 encoding\n  str = str.split('=')[0]\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = str.trim().replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\n// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass\n// the `instanceof` check but they should be treated as of that type.\n// See: https://github.com/feross/buffer/issues/166\nfunction isInstance (obj, type) {\n  return obj instanceof type ||\n    (obj != null && obj.constructor != null && obj.constructor.name != null &&\n      obj.constructor.name === type.name)\n}\nfunction numberIsNaN (obj) {\n  // For IE11 support\n  return obj !== obj // eslint-disable-line no-self-compare\n}\n","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n  var validLen = b64.indexOf('=')\n  if (validLen === -1) validLen = len\n\n  var placeHoldersLen = validLen === len\n    ? 0\n    : 4 - (validLen % 4)\n\n  return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n  var tmp\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n  var curByte = 0\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  var len = placeHoldersLen > 0\n    ? validLen - 4\n    : validLen\n\n  var i\n  for (i = 0; i < len; i += 4) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 18) |\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n      revLookup[b64.charCodeAt(i + 3)]\n    arr[curByte++] = (tmp >> 16) & 0xFF\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 2) |\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 10) |\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] +\n    lookup[num >> 12 & 0x3F] +\n    lookup[num >> 6 & 0x3F] +\n    lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp =\n      ((uint8[i] << 16) & 0xFF0000) +\n      ((uint8[i + 1] << 8) & 0xFF00) +\n      (uint8[i + 2] & 0xFF)\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 2] +\n      lookup[(tmp << 4) & 0x3F] +\n      '=='\n    )\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 10] +\n      lookup[(tmp >> 4) & 0x3F] +\n      lookup[(tmp << 2) & 0x3F] +\n      '='\n    )\n  }\n\n  return parts.join('')\n}\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","import * as TSU from \"@panyam/tsutils\";\n\n/**\n * A common Entity base class with support for unique IDs, parent references,\n * copying, and debug info. This serves as the foundation for all entities\n * in the notation system.\n *\n * Note: Child management is intentionally NOT included here. Each container type\n * (BlockContainer, Line, Group, etc.) defines its own child management with\n * appropriate types.\n */\nexport class Entity {\n  readonly TYPE: string = \"Entity\";\n\n  private static counter = 0;\n  /** Unique identifier for this entity */\n  readonly uuid = Entity.counter++;\n  /** Parent entity in the tree hierarchy */\n  protected _parent: TSU.Nullable<Entity> = null;\n\n  /**\n   * Creates a new Entity.\n   * @param config Optional configuration object\n   */\n  constructor(config: any = null) {\n    config = config || {};\n    if (config.metadata) throw new Error(\"See where metadata is being passed\");\n  }\n\n  /**\n   * Gets the parent entity.\n   */\n  get parent(): TSU.Nullable<Entity> {\n    return this._parent;\n  }\n\n  /**\n   * Sets the parent entity.\n   * @param parent The parent entity to set\n   */\n  setParent(parent: TSU.Nullable<Entity>): void {\n    this._parent = parent;\n  }\n\n  /**\n   * Returns a debug-friendly representation of this entity.\n   * Usually overridden by children to add more debug info.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return { type: this.TYPE };\n  }\n\n  /**\n   * Returns a simple string representation of this Entity.\n   * @returns A string representation\n   */\n  toString(): string {\n    return `Entity(id = ${this.uuid})`;\n  }\n\n  /**\n   * Checks if this Entity is equal to another Entity.\n   * @param another The Entity to compare with\n   * @param expect Optional parameter\n   * @returns True if the Entities are equal, false otherwise\n   */\n  equals(another: this, expect = false): boolean {\n    if (this.TYPE != another.TYPE) return false;\n    return true;\n  }\n\n  /**\n   * Creates a clone of this entity.\n   * Cloning is a two-part process:\n   * 1. Creation of a new instance via this.newInstance()\n   * 2. Copying of data into the new instance via this.copyTo()\n   *\n   * @returns A new instance of the same type with the same properties\n   */\n  clone(): this {\n    const out = this.newInstance();\n    this.copyTo(out);\n    return out;\n  }\n\n  /**\n   * Copies information about this instance into another instance of the same type.\n   * @param another The target instance to copy properties to\n   */\n  copyTo(another: this): void {\n    // Subclasses override to copy their specific properties\n  }\n\n  /**\n   * First part of the cloning process where the instance is created.\n   * @returns A new instance of the same type\n   */\n  protected newInstance(): this {\n    return new (this.constructor as any)();\n  }\n}\n\n/**\n * Music is all about timing! TimedEntities are base of all entities that\n * have a duration. This is an abstract class that all timed entities inherit from.\n */\nexport abstract class TimedEntity extends Entity {\n  readonly TYPE: string = \"TimedEntity\";\n\n  /**\n   * Gets the duration of this entity in terms of beats.\n   * By default, entity durations are readonly.\n   */\n  abstract get duration(): TSU.Num.Fraction;\n\n  /**\n   * Checks if this TimedEntity is equal to another TimedEntity.\n   * @param another The TimedEntity to compare with\n   * @returns True if the TimedEntities are equal, false otherwise\n   */\n  equals(another: this): boolean {\n    return super.equals(another) && this.duration.equals(another.duration);\n  }\n}\n","export type Timestamp = number;\nexport type NumberRange = [number, number];\n\nexport type StringMap<T> = { [key: string]: T };\nexport type NumMap<T> = { [key: number]: T };\nexport type Nullable<T> = T | null;\n\nexport type Undefined<T> = T | undefined | void;\n\nexport function assert(condition: boolean, msg?: string): asserts condition {\n  if (!condition) {\n    throw new Error(msg);\n  }\n}\n","import { StringMap, Nullable } from \"../types\";\nconst axios = require(\"axios\").default;\n\nexport abstract class ResourceApi<ResType> {\n  abstract urlForGet(resId: string, params: any): string;\n  abstract urlForBatchGet(resIds: string[]): string;\n  abstract urlForDelete(resId: string, params: any): string;\n  abstract urlForUpdate(resId: string, params: any): string;\n  abstract urlForList(params: any): string;\n  abstract urlForCreate(params: any): string;\n\n  abstract processListResponse(response: Response): ResType[];\n  abstract processBatchGetResponse(response: Response): StringMap<ResType>;\n  abstract processGetResponse(response: Response): Nullable<ResType>;\n  abstract processDeleteResponse(response: Response): boolean;\n  abstract processUpdateResponse(response: Response): ResType;\n  abstract processCreateResponse(response: Response): ResType;\n  abstract processUpdateParams(params: any): any;\n  abstract processCreateParams(params: any): any;\n\n  async create(params: any): Promise<ResType> {\n    const url = this.urlForCreate(params);\n    const response = await axios.post(url, this.processCreateParams(params));\n    return this.processCreateResponse(response);\n  }\n\n  async batchGet(...resIds: string[]): Promise<StringMap<ResType>> {\n    const url = this.urlForBatchGet(resIds);\n    const response = await axios.get(url);\n    return this.processBatchGetResponse(response);\n  }\n\n  async get(resId: string, params: any): Promise<Nullable<ResType>> {\n    const url = this.urlForGet(resId, params);\n    const response = await axios.get(url);\n    return this.processGetResponse(response);\n  }\n\n  async list(params: any): Promise<ResType[]> {\n    const url = this.urlForList(params);\n    const response = await axios.get(url);\n    return this.processListResponse(response);\n  }\n\n  async update(resId: string, params: any): Promise<ResType> {\n    const url = this.urlForUpdate(resId, params);\n    const response = await axios.put(url, this.processUpdateParams(params));\n    return this.processUpdateResponse(response);\n  }\n\n  async delete(resId: string, params: any): Promise<boolean> {\n    const url = this.urlForDelete(resId, params);\n    const response = await axios({ method: \"delete\", url: url });\n    return this.processDeleteResponse(response);\n  }\n}\n","export const INFINITY = 1e48;\nexport const MAX_INT = 2 ** 32;\nexport const MAX_LONG = 2 ** 64;\n","import { Nullable, Timestamp } from \"../types\";\n\n/**\n * Super class of all Events.\n */\nexport class TEvent {\n  // Globally unique ID for all events.\n  private static counter = 0;\n  readonly uuid = TEvent.counter++;\n\n  /**\n   * The event this event was spawned from (if any).\n   */\n  protected _spawnedFrom: Nullable<this> = null;\n\n  /**\n   * Name of the event.\n   */\n  readonly name: string;\n\n  /**\n   * Source from which this event is originating.\n   */\n  readonly source: any;\n\n  /**\n   * Source state that is set by the source of the event only\n   * *it* can use.\n   */\n  sourceState: any = null;\n\n  /**\n   * Event specific payload.\n   */\n  payload: any;\n\n  /**\n   * Whether the event was cancelled.\n   */\n  cancelled = false;\n\n  /**\n   * Timestamp of the event - optional.\n   */\n  timeStamp: Timestamp = -1;\n\n  /**\n   * All child events that were spawned from this Event.\n   * The parent/spawnedFrom and child event references help us\n   * form a call tree/trace of a events as it traverses\n   * the system.\n   */\n  children: TEvent[] = [];\n\n  constructor(name: string, source: any, payload?: any) {\n    this.name = name;\n    this.source = source;\n    this.payload = payload;\n  }\n\n  get spawnedFrom(): Nullable<this> {\n    return this._spawnedFrom;\n  }\n\n  protected setSpawnedFrom(msg: Nullable<this>): void {\n    this._spawnedFrom = msg;\n    if (msg == null) this._rootEvent = this;\n    else this._rootEvent = msg.rootEvent;\n  }\n\n  spawn(name: string, source: any, payload?: any): TEvent {\n    const child = new TEvent(name, source, payload);\n    child.setSpawnedFrom(this);\n    this.children.push(child);\n    return child;\n  }\n\n  /**\n   * The first/root message in the forward chain.\n   */\n  private _rootEvent: this;\n\n  get rootEvent(): this {\n    return this._rootEvent as this;\n  }\n}\n\nexport class State {\n  private static counter = 0;\n  stateData: any = null;\n  readonly id = State.counter++;\n\n  get name(): string {\n    return this.constructor.name;\n  }\n\n  enter(data: any): void {\n    this.stateData = data;\n  }\n\n  handle(event: TEvent): void {\n    // todo\n  }\n}\n\nexport type EventCallback = ((event: TEvent) => void) | ((event: TEvent) => Promise<void>);\n\nexport class EventEmitter {\n  protected _eventHub: EventHub | null;\n  constructor() {\n    this._eventHub = new EventHub();\n  }\n  get eventHub(): EventHub | null {\n    return this._eventHub;\n  }\n  set eventHub(hub: EventHub | null) {\n    const oldHub = this._eventHub;\n    this._eventHub = hub;\n    this.eventHubChanged(oldHub);\n  }\n  protected eventHubChanged(oldHub: EventHub | null): void {\n    // Do nothing\n    console.log(\"WARNING - EventHub Change Listener not implemented: \", this.constructor.name);\n  }\n}\n\nexport class EventHub {\n  private _handlers: { [key: string]: Array<EventCallback> } = {};\n\n  on(names: Array<string> | string, callback: EventCallback): this {\n    return this._addHandler(names, this._handlers, callback);\n  }\n\n  removeOn(names: Array<string> | string, callback: EventCallback): this {\n    return this._removeHandler(names, this._handlers, callback);\n  }\n\n  _ensurestrings(names: Array<string> | string): string[] {\n    if (typeof names === \"string\") {\n      names = (names as string).split(\",\");\n    }\n    return names.map(function (v) {\n      return v.trim();\n    });\n  }\n\n  _addHandler<T>(names: Array<string> | string, handlerlist: { [key: string]: Array<T> }, handler: T): this {\n    this._ensurestrings(names).forEach(function (name) {\n      handlerlist[name] = handlerlist[name] || [];\n      handlerlist[name].push(handler);\n    });\n    return this;\n  }\n\n  _removeHandler<T>(names: Array<string> | string, handlerlist: { [key: string]: Array<T> }, handler: T): this {\n    this._ensurestrings(names).forEach(function (name) {\n      const evHandlers = handlerlist[name] || [];\n      for (let i = 0; i < evHandlers.length; i++) {\n        if (evHandlers[i] == handler) {\n          evHandlers.splice(i, 1);\n          break;\n        }\n      }\n    });\n    return this;\n  }\n\n  emit(name: string, source: any, payload?: any): boolean {\n    const evt = new TEvent(name, source, payload);\n    if (this._inBatchMode) {\n      this._events.push(evt);\n      return true;\n    } else {\n      return this.dispatchEvent(evt);\n    }\n  }\n\n  dispatchEvent(event: TEvent): boolean {\n    const evtCallbacks = this._handlers[event.name] || [];\n    for (const callback of evtCallbacks) {\n      callback(event);\n      if (event.cancelled) return false;\n    }\n    return true;\n  }\n\n  // Support for transactional/batch event handling, where\n  // the user can allow a bunch of events to first collect\n  // before triggering a batch dispatch\n  public static BATCH_EVENTS = \"BatchEvents\";\n  protected _events: TEvent[] = [];\n  protected _inBatchMode = false;\n  startBatchMode(): this {\n    if (!this._inBatchMode) {\n      this._inBatchMode = true;\n    }\n    return this;\n  }\n\n  cancelBatch(): void {\n    this._inBatchMode = false;\n    this._events = [];\n  }\n\n  commitBatch(): void {\n    this._inBatchMode = false;\n    this.emit(EventHub.BATCH_EVENTS, this, this._events);\n    this._events = [];\n  }\n}\n\n/**\n * StateMachines allow declarative and stateful chaining of events.\n */\nexport class StateMachine {\n  private _states: { [key: string]: State } = {};\n  private _rootState: Nullable<State> = null;\n  private _currentState: Nullable<State> = null;\n  constructor() {\n    this._states = {};\n    this._rootState = null;\n    this._currentState = null;\n  }\n\n  /**\n   * The starting/root state of the machine.\n   *\n   * @param {String} name  Name of the default/root state.\n   */\n  set rootState(name: string) {\n    this._rootState = this.getState(name);\n    if (this._currentState == null) {\n      this._currentState = this._rootState;\n    }\n  }\n\n  /**\n   * Exits the current state (if any) and enters a new state.\n   *\n   * @param {String}   state   Name of the new state to enter.\n   * @param {Object}   data    State specific data for the state handler to use for the new state.\n   */\n  enter(state: string, data: any = null): void {\n    if (state == \"\") {\n      this._currentState = this._rootState;\n    } else {\n      this._currentState = this.getState(state);\n    }\n    if (this._currentState != null) {\n      this._currentState.enter(data);\n    }\n  }\n\n  /**\n   * Get the state by name.\n   *\n   * @param {String} name  Name of the state being queried.\n   * @returns {State} State object associated with the name.\n   */\n  getState(name: string): State {\n    if (!(name in this._states)) {\n      throw Error(\"State '\" + name + \"' not yet registered.\");\n    }\n    return this._states[name];\n  }\n\n  /**\n   * Register a new state in the state machine.\n   *\n   * @param {State} state  State being registered.  If another State with\n   * the same name exists, then a {DuplicateError} is thrown.\n   * @param {Bool} isRoot  Whether the new state is a root state.\n   */\n  registerState(state: State, isRoot = false): void {\n    const name = state.name;\n    if (name in this._states) {\n      throw Error(\"State '\" + name + \"' already registered.\");\n    }\n    this._states[name] = state;\n    if (isRoot || false) {\n      this.rootState = state.name;\n    }\n  }\n\n  /**\n   * Handles an event from the current state in the state machine possibly resulting in a state transition.\n   *\n   * @param {Object} name    Type of event being sent.\n   * @param {EventSource} source  The source generating the event.\n   * @param {Object} data    The event specific data.\n   */\n  handle(event: TEvent): void {\n    if (this._currentState == null) return;\n\n    const nextState: any = this._currentState.handle(event);\n    if (nextState != null) {\n      if (nextState == \"\") {\n        if (this._rootState != null) {\n          this.enter(this._rootState.name);\n        } else {\n          throw new Error(\"Root state has not been set\");\n        }\n      } else {\n        this.enter(nextState);\n      }\n    }\n  }\n}\n","import { Nullable } from \"./types\";\n\nexport interface ListNode<V> {\n  nextSibling: Nullable<V>;\n  prevSibling: Nullable<V>;\n}\n\nclass MutableListNode<V> implements ListNode<MutableListNode<V>> {\n  nextSibling: Nullable<MutableListNode<V>> = null;\n  prevSibling: Nullable<MutableListNode<V>> = null;\n  constructor(public value: V) {}\n}\n\n/**\n * A list implementation where the value itself contains next and prev pointers\n * so we do not need to create wrapper classes.\n */\nexport class ValueList<V extends ListNode<V>> {\n  protected _firstChild: Nullable<V> = null;\n  protected _lastChild: Nullable<V> = null;\n  protected _size = 0;\n\n  constructor(...values: V[]) {\n    for (const v of values) this.pushBack(v);\n  }\n\n  toJSON(): V[] {\n    return Array.from(this.values());\n  }\n\n  forEach(method: (val: V) => boolean | any): number {\n    let tmp: V | null = this._firstChild;\n    let count = 0;\n    while (tmp != null) {\n      if (method(tmp) == false) {\n        break;\n      }\n      count++;\n      tmp = tmp.nextSibling;\n    }\n    return count;\n  }\n\n  equals(another: ValueList<V>, eqlFunc: (val1: V, val2: V) => boolean): boolean {\n    if (this.size != another.size) return false;\n    let tmp = this.first;\n    let tmp2 = another.first;\n    for (; tmp != null && tmp2 != null; tmp = tmp.nextSibling, tmp2 = tmp2.nextSibling) {\n      if (!eqlFunc(tmp, tmp2)) {\n        return false;\n      }\n    }\n    return tmp == null && tmp2 == null;\n  }\n\n  get isEmpty(): boolean {\n    return this._size == 0;\n  }\n\n  get size(): number {\n    return this._size;\n  }\n\n  get first(): Nullable<V> {\n    return this._firstChild;\n  }\n\n  get last(): Nullable<V> {\n    return this._lastChild;\n  }\n\n  /**\n   * Generator of values in reverse order.\n   */\n  *reversedValues(): Generator<V> {\n    let tmp = this._lastChild;\n    while (tmp != null) {\n      yield tmp;\n      tmp = tmp.prevSibling;\n    }\n  }\n\n  /**\n   * Generator of values in forward order.\n   */\n  *values(): Generator<V> {\n    let tmp = this._firstChild;\n    while (tmp != null) {\n      yield tmp;\n      tmp = tmp.nextSibling;\n    }\n  }\n\n  add(child: V, before: Nullable<V> = null): this {\n    // Ensure that this node is not added anywhere else\n    if (child.nextSibling != null || child.prevSibling != null) {\n      throw new Error(\"New node already added to a list.  Remove it first\");\n    }\n    child.nextSibling = child.prevSibling = null;\n    this._size++;\n    if (this._firstChild == null || this._lastChild == null) {\n      this._firstChild = this._lastChild = child;\n    } else if (before == null) {\n      child.prevSibling = this._lastChild;\n      child.nextSibling = null;\n      this._lastChild.nextSibling = child;\n      this._lastChild = child;\n    } else if (before == this._firstChild) {\n      child.nextSibling = before;\n      child.prevSibling = null;\n      this._firstChild.prevSibling = child;\n      this._firstChild = child;\n    } else {\n      const prev = before.prevSibling;\n      child.nextSibling = before;\n      before.prevSibling = child;\n      child.prevSibling = prev;\n      if (prev != null) {\n        prev.nextSibling = child;\n      }\n    }\n    return this;\n  }\n\n  pushFront(value: V): this {\n    return this.add(value, this._firstChild);\n  }\n\n  pushBack(value: V): this {\n    return this.add(value);\n  }\n\n  /**\n   * Removes a child node from this list.\n   * It is upto the caller to ensure that this node indeed belongs\n   * to this list otherwise deletion of a non belonging node could result\n   * in undefined behaviour.\n   */\n  remove(child: V): this {\n    const next = child.nextSibling;\n    const prev = child.prevSibling;\n\n    if (next == null) {\n      this._lastChild = prev;\n      if (prev == null) this._firstChild = null;\n    } else {\n      next.prevSibling = prev;\n    }\n\n    if (prev == null) {\n      this._firstChild = next;\n      if (next == null) this._lastChild = null;\n    } else {\n      prev.nextSibling = next;\n    }\n\n    this._size--;\n\n    child.prevSibling = child.nextSibling = null;\n    return this;\n  }\n\n  popBack(): V {\n    if (this._lastChild == null) {\n      throw new Error(\"No children\");\n    }\n    const out = this._lastChild;\n    this.remove(out);\n    return out;\n  }\n\n  popFront(): V {\n    if (this._firstChild == null) {\n      throw new Error(\"No children\");\n    }\n    const out = this._firstChild;\n    this.remove(out);\n    return out;\n  }\n}\n\n/**\n * A list implementation where the values themselves need to be wrapper in a list node.\n * If values already have sibling node properties they can be direclty used\n * via ValueLists.\n */\nexport class List<V> {\n  private container: ValueList<MutableListNode<V>>;\n\n  constructor(...values: V[]) {\n    this.container = new ValueList<MutableListNode<V>>();\n    for (const v of values) this.push(v);\n  }\n\n  toJSON(): V[] {\n    return Array.from(this.values());\n  }\n\n  forEach(method: (val: V) => boolean | any): number {\n    return this.container.forEach((v) => method(v.value));\n  }\n\n  equals(another: List<V>, eqlFunc: (val1: V, val2: V) => boolean): boolean {\n    return this.container.equals(another.container, (a, b) => eqlFunc(a.value, b.value));\n  }\n\n  find(target: V): Nullable<MutableListNode<V>> {\n    for (const v of this.container.values()) {\n      if (target == v.value) {\n        return v;\n      }\n    }\n    return null;\n  }\n\n  get isEmpty(): boolean {\n    return this.container.isEmpty;\n  }\n\n  get size(): number {\n    return this.container.size;\n  }\n\n  get first(): Nullable<MutableListNode<V>> {\n    return this.container.first;\n  }\n\n  get last(): Nullable<MutableListNode<V>> {\n    return this.container.last;\n  }\n\n  /**\n   * Generator of values in reverse order.\n   */\n  *reversedValues(): Generator<V> {\n    for (const v of this.container.reversedValues()) yield v.value;\n  }\n\n  /**\n   * Generator of values in forward order.\n   */\n  *values(): Generator<V> {\n    for (const v of this.container.values()) yield v.value;\n  }\n\n  popBack(): V {\n    return this.container.popBack().value;\n  }\n\n  popFront(): V {\n    return this.container.popFront().value;\n  }\n\n  pushFront(value: V): this {\n    return this.add(value, this.container.first);\n  }\n\n  push(value: V): this {\n    return this.add(value);\n  }\n\n  add(child: V, before: Nullable<MutableListNode<V>> = null): this {\n    this.container.add(new MutableListNode(child), before);\n    return this;\n  }\n}\n","declare let navigator: any;\nexport class Browser {\n  static IS_EXPLORER = () => navigator && navigator.userAgent.indexOf(\"MSIE\") > -1;\n  static IS_FIREFOX = () => navigator && navigator.userAgent.indexOf(\"Firefox\") > -1;\n  static IS_OPERA = () => navigator && navigator.userAgent.toLowerCase().indexOf(\"op\") > -1;\n\n  protected static UAHasChrome = () => navigator && navigator.userAgent.indexOf(\"Chrome\") > -1;\n  protected static UAHasSafari = () => navigator && navigator.userAgent.indexOf(\"Safari\") > -1;\n  static IS_SAFARI = () => navigator && Browser.UAHasSafari() && (!Browser.UAHasChrome() || !Browser.UAHasSafari());\n  static IS_CHROME = () => navigator && Browser.UAHasChrome() && (!Browser.UAHasChrome() || !Browser.IS_OPERA());\n}\n","import { Nullable } from \"./types\";\n\nexport function range(start: number, end: Nullable<number> = null, incr: Nullable<number> = 1): number[] {\n  if (end == null) {\n    const absStart = Math.abs(start);\n    const arr = Array.from({ length: absStart });\n    if (start >= 0) {\n      return arr.map((x, i) => i);\n    } else {\n      return arr.map((x, i) => i - (absStart - 1));\n    }\n  }\n  const out: number[] = [];\n  if (incr == null) {\n    incr = 1;\n  }\n  incr = Math.abs(incr);\n  if (start !== end) {\n    if (start < end) {\n      for (let i = start; i <= end; i += incr) {\n        out.push(i);\n      }\n    } else {\n      for (let i = start; i >= end; i -= incr) {\n        out.push(i);\n      }\n    }\n  }\n  return out;\n}\n\nexport function gcdof(x: number, y: number): number {\n  x = Math.abs(x);\n  y = Math.abs(y);\n  while (y > 0) {\n    const t = y;\n    y = x % y;\n    x = t;\n  }\n  return x;\n}\n\nexport class Fraction {\n  readonly num: number;\n  readonly den: number;\n\n  static readonly ZERO = new Fraction();\n  static readonly ONE = new Fraction(1, 1);\n  static readonly INFINITY = new Fraction(1, 0);\n\n  constructor(num = 0, den = 1, factorized = false) {\n    if (isNaN(num) || isNaN(den)) {\n      throw new Error(`Invalid numerator(${num}) or denminator(${den})`);\n    }\n    if (factorized) {\n      const gcd = gcdof(num, den);\n      num /= gcd;\n      den /= gcd;\n    }\n    this.num = num;\n    this.den = den;\n  }\n\n  static parse(val: string, factorized = false): Fraction {\n    const parts = val\n      .trim()\n      .split(\"/\")\n      .map((x) => x.trim());\n    let num = 1;\n    let den = 1;\n    if (parts.length == 1) num = parseInt(parts[0]);\n    else if (parts.length != 2) {\n      throw new Error(\"Invalid fraction string: \" + val);\n    } else {\n      if (parts[0].length > 0) {\n        num = parseInt(parts[0]);\n      }\n      if (parts[1].length > 0) {\n        den = parseInt(parts[1]);\n      }\n    }\n    if (isNaN(num) || isNaN(den)) {\n      throw new Error(\"Invalid fraction string: \" + val);\n    }\n    return new Fraction(num, den, factorized);\n  }\n\n  get isWhole(): boolean {\n    return this.num % this.den == 0;\n  }\n\n  get isZero(): boolean {\n    return this.num == 0;\n  }\n\n  get isInfinity(): boolean {\n    return this.den == 0;\n  }\n\n  get isOne(): boolean {\n    return this.num == this.den;\n  }\n\n  get ceil(): number {\n    if (this.num % this.den == 0) {\n      return this.num / this.den;\n    } else {\n      return 1 + Math.floor(this.num / this.den);\n    }\n  }\n\n  get floor(): number {\n    if (this.num % this.den == 0) {\n      return this.num / this.den;\n    } else {\n      return Math.floor(this.num / this.den);\n    }\n  }\n\n  plus(another: Fraction, factorized = false): Fraction {\n    return new Fraction(this.num * another.den + this.den * another.num, this.den * another.den, factorized);\n  }\n\n  plusNum(another: number, factorized = false): Fraction {\n    return new Fraction(this.num + this.den * another, this.den, factorized);\n  }\n\n  minus(another: Fraction, factorized = false): Fraction {\n    return new Fraction(this.num * another.den - this.den * another.num, this.den * another.den, factorized);\n  }\n\n  minusNum(another: number, factorized = false): Fraction {\n    return new Fraction(this.num - this.den * another, this.den, factorized);\n  }\n\n  times(another: Fraction, factorized = false): Fraction {\n    return new Fraction(this.num * another.num, this.den * another.den, factorized);\n  }\n\n  timesNum(another: number, factorized = false): Fraction {\n    return new Fraction(this.num * another, this.den, factorized);\n  }\n\n  divby(another: Fraction, factorized = false): Fraction {\n    return new Fraction(this.num * another.den, this.den * another.num, factorized);\n  }\n\n  divbyNum(another: number, factorized = false): Fraction {\n    return new Fraction(this.num, this.den * another, factorized);\n  }\n\n  /**\n   * Returns another / this.\n   */\n  numDivby(another: number, factorized = false): Fraction {\n    return new Fraction(this.den * another, this.num, factorized);\n  }\n\n  /**\n   * Returns this % another\n   */\n  mod(another: Fraction): Fraction {\n    // a (mod b) = a − b ⌊a / b⌋\n    const d = this.divby(another);\n    const floorOfD = Math.floor(d.num / d.den);\n    return this.minus(another.timesNum(floorOfD));\n  }\n\n  /*\n   * Returns this % another\n   */\n  modNum(another: number): Fraction {\n    // a (mod b) = a − b ⌊a / b⌋\n    const d = this.divbyNum(another);\n    const floorOfD = Math.floor(d.num / d.den);\n    return this.minusNum(another * floorOfD);\n  }\n\n  get inverse(): Fraction {\n    return new Fraction(this.den, this.num);\n  }\n\n  get factorized(): Fraction {\n    const gcd = gcdof(this.num, this.den);\n    return new Fraction(this.num / gcd, this.den / gcd);\n  }\n\n  equals(another: Fraction): boolean {\n    return this.num * another.den == this.den * another.num;\n  }\n\n  equalsNum(another: number): boolean {\n    return this.num == this.den * another;\n  }\n\n  cmp(another: Fraction): number {\n    return this.num * another.den - this.den * another.num;\n  }\n\n  cmpNum(another: number): number {\n    return this.num - this.den * another;\n  }\n\n  isLT(another: Fraction): boolean {\n    return this.cmp(another) < 0;\n  }\n\n  isLTE(another: Fraction): boolean {\n    return this.cmp(another) <= 0;\n  }\n\n  isLTNum(another: number): boolean {\n    return this.cmpNum(another) < 0;\n  }\n\n  isLTENum(another: number): boolean {\n    return this.cmpNum(another) <= 0;\n  }\n\n  isGT(another: Fraction): boolean {\n    return this.cmp(another) > 0;\n  }\n\n  isGTE(another: Fraction): boolean {\n    return this.cmp(another) >= 0;\n  }\n\n  isGTNum(another: number): boolean {\n    return this.cmpNum(another) > 0;\n  }\n\n  isGTENum(another: number): boolean {\n    return this.cmpNum(another) >= 0;\n  }\n\n  toString(): string {\n    return this.num + \"/\" + this.den;\n  }\n\n  static max(f1: Fraction, f2: Fraction): Fraction {\n    return f1.cmp(f2) > 0 ? f1 : f2;\n  }\n\n  static min(f1: Fraction, f2: Fraction): Fraction {\n    return f1.cmp(f2) < 0 ? f1 : f2;\n  }\n}\n\n// Shortcut helper\nexport const Frac = (a = 0, b = 1, factorized = false): Fraction => new Fraction(a, b, factorized);\n","import * as TSU from \"@panyam/tsutils\";\nimport { Entity, TimedEntity } from \"./entity\";\n\n/**\n * Alias to TSU.Num.Fraction in tsutils.\n */\ntype Fraction = TSU.Num.Fraction;\nexport type CyclePosition = [number, number, number];\nexport type CycleIterator = Generator<[CyclePosition, Fraction]>;\n\nconst ZERO = TSU.Num.Fraction.ZERO;\nconst ONE = TSU.Num.Fraction.ONE;\n\n/**\n * A cursor that traverses through a Cycle's beats in a controlled manner.\n * Allows forward and backward navigation through the cycle.\n */\nexport class CycleCursor {\n  /**\n   * Creates a new CycleCursor.\n   * @param cycle The Cycle to traverse\n   * @param barIndex The starting bar index, defaults to 0\n   * @param beatIndex The starting beat index within the bar, defaults to 0\n   * @param instance The starting instance index within the beat, defaults to 0\n   */\n  constructor(\n    public readonly cycle: Cycle,\n    public barIndex = 0,\n    public beatIndex = 0,\n    public instance = 0,\n  ) {}\n\n  /**\n   * Advances the cursor to the next beat and returns the current position and beat length.\n   * @returns A tuple containing the current position and beat length\n   */\n  get next(): [CyclePosition, Fraction] {\n    const currBar = this.cycle.bars[this.barIndex];\n    const result: [CyclePosition, Fraction] = [\n      [this.barIndex, this.beatIndex, this.instance],\n      currBar.beatLengths[this.beatIndex],\n    ];\n    this.instance++;\n    if (!currBar.beatCounts[this.beatIndex] || this.instance >= currBar.beatCounts[this.beatIndex]) {\n      this.instance = 0;\n      this.beatIndex++;\n      if (this.beatIndex >= currBar.beatLengths.length) {\n        this.beatIndex = 0;\n        this.barIndex++;\n        if (this.barIndex >= this.cycle.bars.length) {\n          this.barIndex = 0;\n        }\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Moves the cursor to the previous beat and returns the current position and beat length.\n   * @returns A tuple containing the current position and beat length\n   */\n  get prev(): [CyclePosition, Fraction] {\n    const currBar = this.cycle.bars[this.barIndex];\n    const result: [CyclePosition, Fraction] = [\n      [this.barIndex, this.beatIndex, this.instance],\n      currBar.beatLengths[this.beatIndex],\n    ];\n    // TODO - result should be set *after* decrementing if we had already\n    // done a \"next\" before this otherwise user may have to do a prev twice\n    this.instance--;\n    if (this.instance < 0) {\n      this.beatIndex--;\n      if (this.beatIndex < 0) {\n        this.barIndex--;\n        if (this.barIndex < 0) {\n          this.barIndex = this.cycle.bars.length - 1;\n        }\n        this.beatIndex = this.cycle.bars[this.barIndex].beatCount - 1;\n      }\n      this.instance = (this.cycle.bars[this.barIndex].beatCounts[this.beatIndex] || 1) - 1;\n    }\n    return result;\n  }\n}\n\n/**\n * Represents a bar in a musical cycle.\n * A bar consists of beats with specific lengths and counts.\n */\nexport class Bar extends TimedEntity {\n  readonly TYPE: string = \"Bar\";\n\n  /** Name of the bar (e.g., \"Laghu\", \"Dhrutam\") */\n  name: string;\n\n  /** Length/Duration of each beat in the bar */\n  beatLengths: Fraction[] = [];\n\n  /** How many times each beat should be repeated (the Kalai) */\n  beatCounts: number[] = [];\n\n  /**\n   * Creates a new Bar.\n   * @param config Configuration object containing name, beatLengths, and beatCounts\n   */\n  constructor(config: any = null) {\n    super((config = config || {}));\n    this.name = config.name || \"\";\n    for (const bl of config.beatLengths || []) {\n      if (typeof bl === \"number\") {\n        this.beatLengths.push(TSU.Num.Frac(bl));\n      } else {\n        this.beatLengths.push(bl);\n      }\n    }\n    for (const bc of config.beatCounts || []) {\n      this.beatCounts.push(bc);\n    }\n    while (this.beatCounts.length < this.beatLengths.length) {\n      this.beatCounts.push(1);\n    }\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Bar.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return { ...super.debugValue(), name: name, beatLengths: this.beatLengths };\n  }\n\n  /**\n   * Checks if this Bar is equal to another Bar.\n   * @param another The Bar to compare with\n   * @returns True if the Bars are equal, false otherwise\n   */\n  equals(another: this): boolean {\n    if (!super.equals(another)) return false;\n    if (this.beatLengths.length != another.beatLengths.length) return false;\n    if (this.beatCounts.length != another.beatCounts.length) return false;\n    for (let i = 0; i < this.beatLengths.length; i++) {\n      if (!this.beatLengths[i].equals(another.beatLengths[i])) return false;\n    }\n    for (let i = 0; i < this.beatCounts.length; i++) {\n      if (this.beatCounts[i] != another.beatCounts[i]) return false;\n    }\n    return true;\n  }\n\n  /**\n   * Copies the properties of this Bar to another Bar.\n   * @param another The target Bar to copy properties to\n   */\n  copyTo(another: this): void {\n    super.copyTo(another);\n    another.name = this.name;\n    another.beatLengths = [...this.beatLengths];\n    another.beatCounts = [...this.beatCounts];\n  }\n\n  /**\n   * Gets the instance count for a specific beat in the bar.\n   * @param beatIndex The index of the beat\n   * @returns The number of instances for the specified beat\n   */\n  instanceCount(beatIndex: number): number {\n    if (beatIndex > this.beatCounts.length) {\n      // by default each beat has 1 instance?\n      return 1;\n    } else {\n      return this.beatCounts[beatIndex];\n    }\n  }\n\n  /**\n   * Gets the number of unique beats in this bar (irrespective of instances).\n   */\n  get beatCount(): number {\n    return this.beatLengths.length;\n  }\n\n  /**\n   * Gets the total number of beat instances in this bar.\n   */\n  get totalBeatCount(): number {\n    let out = 0;\n    for (let i = 0; i < this.beatLengths.length; i++) {\n      out += this.beatCounts[i] || 1;\n    }\n    return out;\n  }\n\n  /**\n   * Gets the total duration of time across all beats in this bar.\n   */\n  get duration(): Fraction {\n    let total = ZERO;\n    for (let i = 0; i < this.beatLengths.length; i++) {\n      total = total.plus(this.beatLengths[i].timesNum(this.beatCounts[i] || 1));\n    }\n    return total;\n  }\n}\n\n/**\n * Represents a complete rhythmic cycle pattern composed of bars.\n * In carnatic music, this typically represents a tala.\n */\nexport class Cycle extends TimedEntity {\n  readonly TYPE: string = \"Cycle\";\n\n  /** Name of the cycle (e.g., \"Adi Thalam\") */\n  name: string;\n\n  /** The bars that make up this cycle */\n  bars: Bar[];\n\n  /**\n   * Default cycle representing Adi Thalam (4+2+2 structure).\n   */\n  static readonly DEFAULT = new Cycle({\n    name: \"Adi Thalam\",\n    bars: [\n      new Bar({ name: \"Laghu\", beatLengths: [1, 1, 1, 1] }),\n      new Bar({ name: \"Dhrutam\", beatLengths: [1, 1] }),\n      new Bar({ name: \"Dhrutam\", beatLengths: [1, 1] }),\n    ],\n  });\n\n  /**\n   * Creates a new Cycle.\n   * @param config Configuration object containing name and bars\n   */\n  constructor(config: null | { name?: string; bars?: Bar[] } = null) {\n    super((config = config || {}));\n    this.name = config.name || \"\";\n    this.bars = config.bars || [];\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Cycle.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return { ...super.debugValue(), name: name, bars: this.bars.map((p) => p.debugValue()) };\n  }\n\n  /**\n   * Gets all child entities of this Cycle.\n   * @returns An array of child entities (bars)\n   */\n  children(): Entity[] {\n    return this.bars;\n  }\n\n  /**\n   * Checks if this Cycle is equal to another Cycle.\n   * @param another The Cycle to compare with\n   * @returns True if the Cycles are equal, false otherwise\n   */\n  equals(another: this): boolean {\n    if (!super.equals(another)) {\n      return false;\n    }\n    if (this.bars.length != another.bars.length) return false;\n    for (let i = 0; i < this.bars.length; i++) {\n      if (!this.bars[i].equals(another.bars[i])) return false;\n    }\n    return true;\n  }\n\n  /**\n   * Given a global beat index, returns the position within the cycle.\n   *\n   * @param globalIndex The global beat index\n   * @returns A tuple containing [cycle number, position, start offset]\n   *         - cycle: The nth cycle in which the beat lies\n   *         - position: [barIndex, beatIndex, instance] within the cycle\n   *         - startOffset: Offset of the beat at this global index\n   */\n  getAtIndex(globalIndex: number): [number, CyclePosition, Fraction] {\n    let cycle = 0;\n    while (globalIndex < 0) {\n      globalIndex += this.totalBeatCount;\n      cycle--;\n    }\n    if (globalIndex >= this.totalBeatCount) {\n      cycle = Math.floor(globalIndex / this.totalBeatCount);\n    }\n    globalIndex = globalIndex % this.totalBeatCount;\n    let offset = ZERO;\n    for (let barIndex = 0; barIndex < this.bars.length; barIndex++) {\n      const bar = this.bars[barIndex];\n      if (globalIndex >= bar.totalBeatCount) {\n        globalIndex -= bar.totalBeatCount;\n        offset = offset.plus(bar.duration);\n      } else {\n        // this is the bar!\n        for (let beatIndex = 0; beatIndex < bar.beatCount; beatIndex++) {\n          const beatLength = bar.beatLengths[beatIndex];\n          const beatCount = bar.beatCounts[beatIndex] || 1;\n          if (globalIndex >= beatCount) {\n            globalIndex -= beatCount;\n            offset = offset.plus(beatLength.timesNum(beatCount));\n          } else {\n            // this is it\n            const instance = globalIndex;\n            return [cycle, [barIndex, beatIndex, instance], offset.plus(beatLength.timesNum(instance))];\n          }\n        }\n      }\n    }\n    throw new Error(\"Should not be here!\");\n  }\n\n  /**\n   * Given a global offset, returns the position within the cycle.\n   *\n   * @param globalOffset The global time offset\n   * @returns A tuple containing [cycle number, position, note offset, global index]\n   *         - cycle: The nth cycle in which the offset lies\n   *         - position: [barIndex, beatIndex, instance] within the cycle\n   *         - startOffset: The note offset within the beat\n   *         - globalIndex: The beat index within the entire cycle\n   */\n  getPosition(globalOffset: Fraction): [number, CyclePosition, Fraction, number] {\n    const duration = this.duration;\n    let cycleNum = 0;\n    if (globalOffset.isLT(ZERO)) {\n      while (globalOffset.isLT(ZERO)) {\n        cycleNum--;\n        globalOffset = globalOffset.plus(duration);\n      }\n    } else if (globalOffset.isGTE(duration)) {\n      const realOffset = globalOffset.mod(duration);\n      globalOffset = globalOffset.minus(realOffset).divby(duration);\n      TSU.assert(globalOffset.isWhole);\n      cycleNum = globalOffset.floor;\n      globalOffset = realOffset;\n    }\n\n    // here globalOffset is positive and >= 0 and < this.duration\n    let globalIndex = 0;\n    for (let barIndex = 0; barIndex < this.bars.length; barIndex++) {\n      const bar = this.bars[barIndex];\n      const barDuration = bar.duration;\n      if (globalOffset.isGTE(barDuration)) {\n        globalOffset = globalOffset.minus(barDuration);\n      } else {\n        // this is the bar!\n        for (let beatIndex = 0; beatIndex < bar.beatCount; beatIndex++) {\n          const beatLength = bar.beatLengths[beatIndex];\n          const beatCount = bar.beatCounts[beatIndex] || 1;\n          for (let instance = 0; instance < beatCount; instance++, globalIndex++) {\n            if (globalOffset.isGTE(beatLength)) {\n              globalOffset = globalOffset.minus(beatLength);\n            } else {\n              // this is it\n              return [cycleNum, [barIndex, beatIndex, instance], globalOffset, globalIndex];\n            }\n          }\n        }\n      }\n      globalIndex += bar.totalBeatCount;\n    }\n\n    throw new Error(\"Should not be here!\");\n  }\n\n  /**\n   * Creates an iterator that yields beats in sequence from a starting position.\n   *\n   * @param startBar The starting bar index, defaults to 0\n   * @param startBeat The starting beat index, defaults to 0\n   * @param startInstance The starting instance index, defaults to 0\n   * @returns A generator that yields [position, beat length] pairs\n   */\n  *iterateBeats(startBar = 0, startBeat = 0, startInstance = 0): CycleIterator {\n    let barIndex = startBar;\n    let beatIndex = startBeat;\n    let instanceIndex = startInstance;\n    while (true) {\n      const currBar = this.bars[barIndex];\n      yield [[barIndex, beatIndex, instanceIndex], currBar.beatLengths[beatIndex]];\n      instanceIndex++;\n      if (!currBar.beatCounts[beatIndex] || instanceIndex >= currBar.beatCounts[beatIndex]) {\n        instanceIndex = 0;\n        beatIndex++;\n        if (beatIndex >= currBar.beatLengths.length) {\n          beatIndex = 0;\n          barIndex++;\n          if (barIndex >= this.bars.length) {\n            barIndex = 0;\n          }\n        }\n      }\n    }\n  }\n\n  /**\n   * Copies the properties of this Cycle to another Cycle.\n   * @param another The target Cycle to copy properties to\n   */\n  copyTo(another: this): void {\n    super.copyTo(another);\n    another.name = this.name;\n    another.bars = this.bars.map((x) => x.clone());\n  }\n\n  /**\n   * Gets the number of unique beats in this cycle (irrespective of instances).\n   */\n  get beatCount(): number {\n    let out = 0;\n    for (const bar of this.bars) out += bar.beatCount;\n    return out;\n  }\n\n  /**\n   * Gets the total number of beat instances in this cycle.\n   */\n  get totalBeatCount(): number {\n    let out = 0;\n    for (const bar of this.bars) out += bar.totalBeatCount;\n    return out;\n  }\n\n  /**\n   * Gets the total duration of time across all bars in this cycle.\n   */\n  get duration(): Fraction {\n    return this.bars.reduce((x, y) => x.plus(y.duration), ZERO);\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { Entity, TimedEntity } from \"./entity\";\nimport { LayoutParams } from \"./layouts\";\n\n/**\n * Alias to TSU.Num.Fraction in tsutils.\n */\ntype Fraction = TSU.Num.Fraction;\nexport const ZERO = TSU.Num.Fraction.ZERO;\nexport const ONE = TSU.Num.Fraction.ONE;\n\n/**\n * AtomType enums are used to denote specific Atoms\n * Each type represents a specific musical or notational element.\n * @enum\n */\nexport enum AtomType {\n  NOTE = \"Note\",\n  LITERAL = \"Literal\",\n  SYLLABLE = \"Syllable\",\n  SPACE = \"Space\",\n  GROUP = \"Group\",\n  LABEL = \"Label\",\n  REST = \"Rest\",\n  MARKER = \"Marker\",\n}\n\n/**\n * Atoms are the base class for all timed entities that can appear in a Notation.\n * An Atom represents the fundamental building block of the notation system.\n */\nexport abstract class Atom extends TimedEntity {\n  readonly TYPE: string = \"Atom\";\n\n  protected _duration: Fraction;\n  /** Markers to be displayed before this atom */\n  markersBefore: Marker[];\n  /** Markers to be displayed after this atom */\n  markersAfter: Marker[];\n  /** Next atom in the sequence */\n  nextSibling: TSU.Nullable<Atom> = null;\n  /** Previous atom in the sequence */\n  prevSibling: TSU.Nullable<Atom> = null;\n  /** The Group this Atom belongs to, if any */\n  parentGroup: TSU.Nullable<Group> = null;\n\n  /** Indicates if this Atom is a continuation from a previous atom */\n  isContinuation = false;\n\n  /**\n   * Creates a new Atom with the specified duration.\n   * @param duration The duration of the atom, defaults to ONE (1/1)\n   */\n  constructor(duration = ONE) {\n    super();\n    this._duration = duration || ONE;\n  }\n\n  /**\n   * Splits this atom at the specified duration.\n   * @param requiredDuration The duration at which to split the atom\n   * @returns A new atom representing the portion beyond the split point, or null if no split is needed\n   */\n  abstract splitAt(requiredDuration: Fraction): TSU.Nullable<Atom>;\n\n  /**\n   * Returns a debug-friendly representation of this Atom.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    const out = super.debugValue();\n    if (!this.duration.isOne) {\n      out.duration = this.duration.factorized.toString();\n    }\n    if (this.isContinuation) {\n      out.isContinuation = true;\n    }\n    if ((this.markersBefore || []).length > 0) {\n      out.mbef = this.markersBefore.map((m) => m.debugValue());\n    }\n    if ((this.markersAfter || []).length > 0) {\n      out.maft = this.markersAfter.map((m) => m.debugValue());\n    }\n    return out;\n  }\n\n  /**\n   * Copies the properties of this atom to another atom.\n   * @param another The target atom to copy properties to\n   */\n  copyTo(another: this): void {\n    super.copyTo(another);\n    another._duration = new TSU.Num.Fraction(this.duration.num, this.duration.den);\n  }\n\n  /**\n   * Gets the duration of this atom.\n   */\n  get duration(): Fraction {\n    return this._duration;\n  }\n\n  /**\n   * Sets the duration of this atom.\n   */\n  set duration(d: Fraction) {\n    this._duration = d;\n  }\n}\n\n/**\n * Base class for atoms that cannot contain other atoms.\n * LeafAtom represents atomic elements that can't be further subdivided.\n */\nexport abstract class LeafAtom extends Atom {\n  readonly TYPE: string = \"LeafAtom\";\n\n  /** Indicates if this atom is followed by a rest */\n  beforeRest = false;\n\n  /**\n   * Splits this atom at a certain duration.\n   * If this atom's duration is longer than the given duration, it's truncated\n   * to the given duration and a continuation space is returned.\n   *\n   * @param duration The duration at which to split the atom\n   * @returns A new Space atom representing the spillover if needed, otherwise null\n   */\n  splitAt(duration: Fraction): TSU.Nullable<Atom> {\n    if (this.duration.cmp(duration) > 0) {\n      const spillOver = this.createSpilloverSpace(this.duration.minus(duration));\n      spillOver.isContinuation = true;\n      this.duration = duration;\n      // TODO - Here we need to move the markersAfter to the spill-over as it doesnt belong to this any more\n      return spillOver;\n    }\n    return null;\n  }\n\n  /**\n   * Creates a Space atom to represent spillover duration when splitting.\n   * @param duration The duration of the spillover\n   * @returns A new Space atom\n   */\n  protected createSpilloverSpace(duration: Fraction): Space {\n    return new Space(duration);\n  }\n\n  /**\n   * Returns a debug-friendly representation of this LeafAtom.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return this.beforeRest ? { ...super.debugValue(), beforeRest: true } : super.debugValue();\n  }\n}\n\n/**\n * Represents a marker or annotation in the notation.\n * Markers can be placed before or after atoms to provide additional context.\n */\nexport class Marker extends Entity {\n  readonly TYPE = \"Marker\";\n\n  /**\n   * Creates a new Marker with the specified text.\n   * @param text The text content of the marker\n   * @param isBefore Whether the marker should appear before (true) or after (false) its associated atom\n   */\n  constructor(\n    public text: string,\n    public isBefore = true,\n  ) {\n    super();\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Marker.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return { ...super.debugValue(), text: this.text, before: this.isBefore };\n  }\n\n  /**\n   * Returns a string representation of this Marker.\n   * @returns A string representation\n   */\n  toString(): string {\n    return `Marker(${this.text}-${this.isBefore})`;\n  }\n}\n\n/**\n * Represents a rest (silence) in the notation.\n * Rests are zero-length atoms that indicate a pause.\n */\nexport class Rest extends LeafAtom {\n  readonly TYPE = \"Rest\";\n\n  /**\n   * Creates a new Rest.\n   * Rests are zero length by default.\n   */\n  constructor() {\n    super(ZERO);\n  }\n}\n\n/**\n * Represents a space or silence in the notation.\n * Spaces can be used to denote either silence or continuations of previous notes.\n */\nexport class Space extends LeafAtom {\n  readonly TYPE = \"Space\";\n\n  /**\n   * Indicates whether this is a silent space or a continuation of the previous note.\n   */\n  isSilent = false;\n\n  /**\n   * Creates a new Space with the specified duration and silence property.\n   * @param duration The duration of the space, defaults to ONE (1/1)\n   * @param isSilent Whether the space represents silence (true) or a continuation (false)\n   */\n  constructor(duration = ONE, isSilent = false) {\n    super(duration);\n    this.isSilent = isSilent;\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Space.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return { ...super.debugValue(), isSilent: this.isSilent };\n  }\n\n  /**\n   * Returns a string representation of this Space.\n   * @returns A string representation\n   */\n  toString(): string {\n    return `Space(${this.duration}-${this.isSilent})`;\n  }\n\n  /**\n   * Copies the properties of this Space to another Space.\n   * @param another The target Space to copy properties to\n   */\n  copyTo(another: this): void {\n    super.copyTo(another);\n    another.isSilent = this.isSilent;\n  }\n\n  /**\n   * Checks if this Space is equal to another Space.\n   * @param another The Space to compare with\n   * @returns True if the Spaces are equal, false otherwise\n   */\n  equals(another: this): boolean {\n    return super.equals(another) && this.isSilent == another.isSilent;\n  }\n\n  /**\n   * Creates a Space atom to represent spillover duration when splitting.\n   * @param duration The duration of the spillover\n   * @returns A new Space atom with the same silence property as this Space\n   */\n  protected createSpilloverSpace(duration: Fraction): Space {\n    const out = super.createSpilloverSpace(duration);\n    out.isSilent = this.isSilent;\n    return out;\n  }\n}\n\n/**\n * Represents a literal value in the notation.\n * Literals are the basic building blocks for notes and syllables.\n */\nexport class Literal extends LeafAtom {\n  readonly TYPE: string = \"Literal\";\n\n  /**\n   * The embellishments applied to this Literal.\n   */\n  embelishments: any[] = [];\n\n  /**\n   * Creates a new Literal with the specified value and duration.\n   * @param value The string value of the literal\n   * @param duration The duration of the literal, defaults to ONE (1/1)\n   */\n  constructor(\n    public value: string,\n    duration = ONE,\n  ) {\n    super(duration);\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Literal.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    const out = { ...super.debugValue(), value: this.value };\n    if (this.embelishments.length > 0) {\n      out.embs = this.embelishments.map((e) => (\"debugValue\" in e ? e.debugValue() : e));\n    }\n    return out;\n  }\n\n  /**\n   * Returns a string representation of this Literal.\n   * @returns A string representation\n   */\n  toString(): string {\n    return `Lit(${this.duration}-${this.value})`;\n  }\n\n  /**\n   * Checks if this Literal is equal to another Literal.\n   * @param another The Literal to compare with\n   * @returns True if the Literals are equal, false otherwise\n   */\n  equals(another: this): boolean {\n    return super.equals(another) && this.value == another.value;\n  }\n\n  /**\n   * Copies the properties of this Literal to another Literal.\n   * @param another The target Literal to copy properties to\n   */\n  copyTo(another: this): void {\n    super.copyTo(another);\n    another.value = this.value;\n  }\n}\n\n/**\n * Represents a syllable in lyrics or text to be sung.\n * Extends Literal to provide specialized handling for sung text.\n */\nexport class Syllable extends Literal {\n  readonly TYPE = \"Syllable\";\n\n  /**\n   * Creates a Syllable from a Literal.\n   * @param lit The Literal to convert to a Syllable\n   * @returns A new Syllable with the properties of the Literal\n   */\n  static fromLit(lit: Literal): Syllable {\n    if (lit.TYPE == AtomType.SYLLABLE) return lit as Syllable;\n    const out = new Syllable(lit.value, lit.duration);\n    out.embelishments = lit.embelishments;\n    out.beforeRest = lit.beforeRest;\n    return out;\n  }\n\n  /**\n   * Returns a string representation of this Syllable.\n   * @returns A string representation\n   */\n  toString(): string {\n    return `Syll(${this.duration}-${this.value})`;\n  }\n}\n\n/**\n * Represents a musical note in the notation.\n * Extends Literal to add properties specific to musical notes.\n */\nexport class Note extends Literal {\n  readonly TYPE = \"Note\";\n\n  /**\n   * Which octave the note is in. Can be positive or negative to indicate higher or lower octaves.\n   */\n  octave = 0;\n\n  /**\n   * How the note is shifted - i.e., shifted towards major or minor by # of semi-tones.\n   */\n  shift: number | boolean = 0;\n\n  /**\n   * Creates a new Note with the specified properties.\n   * @param value The string value of the note\n   * @param duration The duration of the note, defaults to ONE (1/1)\n   * @param octave The octave of the note, defaults to 0\n   * @param shift The shift of the note, defaults to 0\n   */\n  constructor(value: string, duration = ONE, octave = 0, shift = 0) {\n    super(value, duration);\n    this.octave = octave;\n    this.shift = shift;\n  }\n\n  /**\n   * Creates a Note from a Literal.\n   * @param lit The Literal to convert to a Note\n   * @returns A new Note with the properties of the Literal\n   */\n  static fromLit(lit: Literal): Note {\n    if (lit.TYPE == AtomType.NOTE) return lit as Note;\n    const out = new Note(lit.value, lit.duration);\n    out.embelishments = lit.embelishments;\n    out.beforeRest = lit.beforeRest;\n    return out;\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Note.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    const out = { ...super.debugValue() };\n    if (this.octave != 0) out.octave = this.octave;\n    if (this.shift != 0) out.shift = this.shift;\n    return out;\n  }\n\n  /**\n   * Returns a string representation of this Note.\n   * @returns A string representation\n   */\n  toString(): string {\n    return `Note(${this.duration}-${this.value}-${this.octave})`;\n  }\n\n  /**\n   * Checks if this Note is equal to another Note.\n   * @param another The Note to compare with\n   * @returns True if the Notes are equal, false otherwise\n   */\n  equals(another: this): boolean {\n    return super.equals(another) && this.octave == another.octave && this.shift == another.shift;\n  }\n\n  /**\n   * Copies the properties of this Note to another Note.\n   * @param another The target Note to copy properties to\n   */\n  copyTo(another: this): void {\n    super.copyTo(another);\n    another.octave = this.octave;\n    another.shift = this.shift;\n  }\n}\n\n/**\n * Represents a group of atoms that are treated as a single unit.\n * Groups can contain any number of atoms, including other groups.\n */\nexport class Group extends Atom {\n  readonly TYPE = \"Group\";\n\n  /**\n   * Indicates whether the duration is static or linear to the number of atoms in this group.\n   * When true, the duration is used as a multiplier for the total child duration.\n   * When false, the duration is absolute.\n   */\n  durationIsMultiplier = false;\n\n  /**\n   * The list of atoms in this group.\n   */\n  readonly atoms = new TSU.Lists.ValueList<Atom>();\n\n  /**\n   * Creates a new Group containing the specified atoms.\n   * @param atoms The atoms to include in this group\n   */\n  constructor(...atoms: Atom[]) {\n    super(atoms.length == 0 ? ZERO : ONE);\n    this.addAtoms(false, ...atoms);\n  }\n\n  /**\n   * Checks if this Group is equal to another Group.\n   * @param another The Group to compare with\n   * @param expect Optional parameter\n   * @returns True if the Groups are equal, false otherwise\n   */\n  equals(another: this, expect = false): boolean {\n    if (!super.equals(another)) return false;\n    return this.atoms.equals(another.atoms, (a1, a2) => a1.equals(a2));\n  }\n\n  /**\n   * Copies the properties of this Group to another Group.\n   * @param another The target Group to copy properties to\n   */\n  copyTo(another: this): void {\n    super.copyTo(another);\n    another.durationIsMultiplier = this.durationIsMultiplier;\n    this.atoms.forEach((atom) => another.atoms.add(atom.clone()));\n  }\n\n  /**\n   * Gets the duration of this group.\n   * If durationIsMultiplier is true, returns the total child duration divided by the multiplier.\n   * Otherwise, returns the absolute duration.\n   */\n  get duration(): Fraction {\n    if (this.durationIsMultiplier) {\n      return this.totalChildDuration.divby(this._duration);\n    } else {\n      return this._duration;\n    }\n  }\n\n  /**\n   * Sets this group to use a multiplier for duration calculations.\n   * @param asMultiplier Whether to use the duration as a multiplier\n   * @returns This Group instance for method chaining\n   */\n  setDurationAsMultiplier(asMultiplier = true): this {\n    this.durationIsMultiplier = asMultiplier;\n    return this;\n  }\n\n  /**\n   * Sets the duration of this group.\n   * @param d The new duration\n   * @param asMultiplier Whether to use the duration as a multiplier\n   * @returns This Group instance for method chaining\n   */\n  setDuration(d: Fraction, asMultiplier = false): this {\n    this._duration = d;\n    this.durationIsMultiplier = asMultiplier;\n    return this;\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Group.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    const out = { ...super.debugValue(), atoms: Array.from(this.atoms.values(), (a) => a.debugValue()) };\n    if (this.durationIsMultiplier) out.durationIsMultiplier = true;\n    return out;\n  }\n\n  /**\n   * Splits this group into two parts.\n   * The first part (this group) fits within the given duration and everything else\n   * longer than the given duration is returned as a new Group.\n   *\n   * @param requiredDuration The duration at which to split the group\n   * @returns A new Group containing the atoms beyond the split point, or null if no split is needed\n   */\n  splitAt(requiredDuration: Fraction): TSU.Nullable<Group> {\n    if (this.duration.isLTE(requiredDuration) || requiredDuration.isLTE(ZERO)) {\n      return null;\n    }\n    const targetGroup = new Group();\n    if (this.durationIsMultiplier) {\n      targetGroup.durationIsMultiplier = true;\n      targetGroup._duration = this._duration;\n    }\n\n    let remainingDur = this.duration;\n    const totalChildDuration = this.totalChildDuration;\n    const durationFactor = this.durationIsMultiplier\n      ? ONE.divby(this._duration)\n      : this._duration.divby(totalChildDuration, true);\n    while (remainingDur.isGT(requiredDuration) && this.atoms.last) {\n      const lastChild = this.atoms.last;\n      // Child's duration is absolute in its own \"system\"\n      // Its duration within the parent (this) group's frame of reference depends\n      // on whether the parent's duration is absolute or as a multiplier\n      //\n      // realChildDuration = case (group.durationIsMultiper) {\n      //  | true  => child.duration / this._duration\n      //  | false => child.duration * this._duration / total child duration\n      //  }\n      const childDuration = lastChild.duration.times(durationFactor);\n      const newDuration = remainingDur.minus(childDuration);\n      if (newDuration.isGTE(requiredDuration)) {\n        // remove ourselves and add to target\n        // in both cases duration will be adjusted if need be\n        this.removeAtoms(true, lastChild);\n        targetGroup.insertAtomsAt(targetGroup.atoms.first, true, lastChild);\n        if (newDuration.equals(requiredDuration)) {\n          // we have reached the end so return\n          return targetGroup;\n        }\n      } else {\n        // our scenario is now this:\n        //\n        // totalParentDuration = 10\n        // required = 8\n        // lastChildDuration (relative to parent) is 5\n        //\n        // durWithoutLast = 10 - 5\n        // newRequired = requiredDur - durWithoutLast = 3\n        //\n        // However 3 is a duration in the parent's frame of reference\n        // this has to be converted back to the child's FoR\n        const newRequiredDur = requiredDuration.minus(newDuration, true).divby(durationFactor, true);\n        // console.log( \"newRequiredDur: \", newRequiredDur, \"requiedDur: \", requiredDuration, \"remainingDur: \", remainingDur,);\n        // then the last item needs to be split, and by how much?\n        const spillOver = lastChild.splitAt(newRequiredDur);\n        if (spillOver == null) {\n          throw new Error(\"Spill over cannot be null here\");\n        }\n        if (!this.durationIsMultiplier) {\n          // Our own duration has also now changed\n          this._duration = requiredDuration;\n        } else {\n          if (this._duration.isZero) throw new Error(\"How can this be?\");\n        }\n        spillOver.isContinuation = true;\n        // Add spill over to the target\n        targetGroup.insertAtomsAt(targetGroup.atoms.first, true, spillOver);\n        return targetGroup;\n      }\n      remainingDur = newDuration;\n    }\n    return targetGroup;\n  }\n\n  /**\n   * Gets the total duration of all child atoms.\n   * @returns The sum of durations of all atoms in this group\n   */\n  get totalChildDuration(): Fraction {\n    let out = ZERO;\n    this.atoms.forEach((atom) => (out = out.plus(atom.duration)));\n    return out;\n  }\n\n  /**\n   * Inserts atoms before a given cursor atom.\n   * If the cursor atom is null, the atoms are appended at the end.\n   *\n   * @param beforeAtom The atom before which to insert the new atoms, or null to append\n   * @param adjustDuration Whether to adjust this group's duration based on the new atoms\n   * @param atoms The atoms to insert\n   * @returns This Group instance for method chaining\n   */\n  insertAtomsAt(beforeAtom: TSU.Nullable<Atom>, adjustDuration = false, ...atoms: Atom[]): this {\n    adjustDuration = adjustDuration && !this.durationIsMultiplier;\n    const oldChildDuration = adjustDuration ? this.totalChildDuration : ONE;\n    // First form a chain of the given atoms\n    for (const atom of atoms) {\n      if (atom.parentGroup != null) {\n        if (atom.parentGroup != this) {\n          throw new Error(\"Atom belongs to another parent. Remove it first\");\n        }\n        atom.parentGroup.removeAtoms(false, atom);\n      }\n      if (atom.TYPE == AtomType.REST) {\n        const last = this.atoms.last;\n        if (last && last.TYPE != AtomType.GROUP && last.TYPE != AtomType.LABEL) {\n          (last as LeafAtom).beforeRest = true;\n        }\n      } else {\n        atom.parentGroup = this;\n        this.atoms.add(atom, beforeAtom);\n      }\n    }\n    if (adjustDuration) {\n      if (this._duration.isZero) {\n        if (this.durationIsMultiplier) throw new Error(\"How can this be?\");\n        this._duration = this.totalChildDuration;\n      } else {\n        const scaleFactor = this.totalChildDuration.divby(oldChildDuration);\n        this._duration = this._duration.times(scaleFactor, true);\n      }\n    }\n    return this;\n  }\n\n  /**\n   * Adds atoms to the end of this group's atom list.\n   *\n   * @param adjustDuration Whether to adjust this group's duration based on the new atoms\n   * @param atoms The atoms to add\n   * @returns This Group instance for method chaining\n   */\n  addAtoms(adjustDuration = false, ...atoms: Atom[]): this {\n    return this.insertAtomsAt(null, adjustDuration, ...atoms);\n  }\n\n  /**\n   * Removes atoms from this group's child list.\n   *\n   * @param adjustDuration Whether to adjust this group's duration after removing atoms\n   * @param atoms The atoms to remove\n   * @returns This Group instance for method chaining\n   */\n  removeAtoms(adjustDuration = false, ...atoms: Atom[]): this {\n    adjustDuration = adjustDuration && !this.durationIsMultiplier;\n    const oldChildDuration = adjustDuration ? this.totalChildDuration : ONE;\n    for (const atom of atoms) {\n      if (atom.parentGroup == this) {\n        this.atoms.remove(atom);\n        atom.parentGroup = null;\n      } else if (atom.parentGroup != null) {\n        throw new Error(\"Atom cannot be removed as it does not belong to this group\");\n      }\n    }\n    if (adjustDuration) {\n      if (this._duration.isZero) {\n        if (this.durationIsMultiplier) throw new Error(\"How can this be?\");\n        this._duration = this.totalChildDuration;\n      } else {\n        const scaleFactor = this.totalChildDuration.divby(oldChildDuration);\n        this._duration = this._duration.times(scaleFactor, true);\n      }\n    }\n    return this;\n  }\n}\n\n/**\n * Represents a line of notation containing multiple roles.\n * A line can have atoms starting before or after the cycle.\n */\nexport class Line extends Entity {\n  readonly TYPE: string = \"Line\";\n\n  /**\n   * Offset tells how many notes before or after the cycle this line's atoms start at.\n   */\n  offset: Fraction = ZERO;\n\n  /**\n   * The roles contained in this line.\n   */\n  roles: Role[] = [];\n\n  /**\n   * Text to be displayed in the margin of the line.\n   * This is a hacky solution to doing left side pre-margin text typically\n   * found in notations - e.g., line X of a pallavi has this. This makes vertical\n   * space less wasteful.\n   *\n   * A better solution is inter-beat annotation but it is very complex for now.\n   */\n  marginText = \"\";\n\n  /**\n   * The LayoutParams associated with this line.\n   */\n  layoutParams: LayoutParams;\n\n  /**\n   * Finds the index of a role with the given name.\n   * @param name The name of the role to find\n   * @returns The index of the role, or -1 if not found\n   */\n  indexOfRole(name: string): number {\n    for (let i = 0; i < this.roles.length; i++) {\n      if (this.roles[i].name == name) return i;\n    }\n    return -1;\n  }\n\n  /**\n   * Checks if this line is empty (has no content in any role).\n   */\n  get isEmpty(): boolean {\n    for (const r of this.roles) if (!r.isEmpty) return false;\n    return true;\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Line.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    const out = {\n      ...super.debugValue(),\n      roles: this.roles.map((r) => r.debugValue()),\n    };\n    if (!this.offset.isZero) {\n      out.offset = this.offset.toString();\n    }\n    return out;\n  }\n\n  /**\n   * Copies the properties of this Line to another Line.\n   * @param another The target Line to copy properties to\n   */\n  copyTo(another: this): void {\n    super.copyTo(another);\n    another.roles = this.roles.map((r) => r.clone());\n  }\n\n  /**\n   * Adds atoms to a role in this line.\n   * @param roleName The name of the role to add atoms to\n   * @param defaultToNotes Whether to default to notes for this role\n   * @param atoms The atoms to add\n   * @returns This Line instance for method chaining\n   */\n  addAtoms(roleName: string, defaultToNotes: boolean, ...atoms: Atom[]): this {\n    const role = this.ensureRole(roleName, defaultToNotes);\n    role.addAtoms(...atoms);\n    return this;\n  }\n\n  /**\n   * Ensures a role with the given name exists in this line, creating it if needed.\n   * @param roleName The name of the role to ensure\n   * @param defaultToNotes Whether to default to notes for this role\n   * @returns The role with the specified name\n   */\n  ensureRole(roleName: string, defaultToNotes: boolean): Role {\n    // Ensure we have this many roles\n    let ri = this.roles.findIndex((r) => r.name == roleName);\n    if (ri < 0) {\n      ri = this.roles.length;\n      const role = new Role(this, roleName);\n      role.defaultToNotes = defaultToNotes;\n      this.roles.push(role);\n    }\n    return this.roles[ri];\n  }\n\n  /**\n   * Gets the maximum duration across all roles in this line.\n   */\n  get duration(): Fraction {\n    let max = ZERO;\n    for (const role of this.roles) {\n      max = TSU.Num.Fraction.max(role.duration, max);\n    }\n    return max;\n  }\n}\n\n/**\n * Represents a specific role or voice in a line of notation.\n * Each role contains a sequence of atoms.\n */\nexport class Role extends Entity {\n  readonly TYPE = \"Role\";\n\n  /**\n   * Whether this role represents notes by default.\n   */\n  defaultToNotes = true;\n\n  /**\n   * The atoms in this role.\n   */\n  atoms: Atom[] = [];\n\n  /**\n   * Creates a new Role with the specified line and name.\n   * @param line The line this role belongs to\n   * @param name The name of the role\n   */\n  constructor(\n    public readonly line: Line,\n    public readonly name: string,\n  ) {\n    super();\n  }\n\n  /**\n   * Checks if this role is empty (has no atoms).\n   */\n  get isEmpty(): boolean {\n    return this.atoms.length == 0;\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Role.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return { name: this.name, atoms: this.atoms.map((a) => a.debugValue()) };\n  }\n\n  /**\n   * Adds atoms to this role.\n   * @param atoms The atoms to add\n   */\n  addAtoms(...atoms: Atom[]): void {\n    let last: null | Atom = null;\n    for (const atom of atoms) {\n      if (atom.TYPE == AtomType.REST) {\n        if (last && last.TYPE != AtomType.GROUP && last.TYPE != AtomType.LABEL) {\n          (last as LeafAtom).beforeRest = true;\n        }\n      } else {\n        this.atoms.push(atom);\n      }\n      last = atom;\n    }\n  }\n\n  /**\n   * Copies the properties of this Role to another Role.\n   * @param another The target Role to copy properties to\n   */\n  copyTo(another: Role): void {\n    another.addAtoms(...this.atoms);\n  }\n\n  /**\n   * Gets the total duration of all atoms in this role.\n   */\n  get duration(): Fraction {\n    return this.atoms.reduce((a, b) => a.plus(b.duration), ZERO);\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { Cycle, CyclePosition, CycleCursor } from \"./cycle\";\n\ntype Fraction = TSU.Num.Fraction;\nconst ZERO = TSU.Num.Fraction.ZERO;\n\n/**\n * Manages layout parameters for arranging beats and notes in the notation.\n * LayoutParams determines how beats are organized into lines and rows based on\n * cycle patterns and line breaks.\n */\nexport class LayoutParams {\n  private static counter = 0;\n  /** Unique identifier for this layout parameters instance */\n  readonly uuid = LayoutParams.counter++;\n\n  /** Duration of a single beat (multiplier for beat lengths) */\n  beatDuration: number;\n\n  /** The cycle pattern to use for this layout */\n  cycle: Cycle;\n\n  /** The pattern of line breaks to apply */\n  protected _lineBreaks: number[];\n\n  /** Cache of row start offsets */\n  private _rowStartOffsets: Fraction[];\n\n  /** Cache of row end offsets */\n  private _rowEndOffsets: Fraction[];\n\n  /** Cache of row durations */\n  private _rowDurations: Fraction[];\n\n  /** Total duration of the layout pattern */\n  private _totalLayoutDuration;\n\n  /** Cached beat layout information */\n  private _beatLayouts: [CyclePosition, Fraction][][];\n\n  /** Total number of beats across all layout lines */\n  private _totalBeats: number;\n\n  /**\n   * Creates a new LayoutParams instance.\n   * @param config Configuration object containing beatDuration, cycle, and lineBreaks\n   */\n  constructor(config?: any) {\n    config = config || {};\n    this.beatDuration = config.beatDuration || 1;\n    if (\"cycle\" in config) this.cycle = config.cycle;\n    if (!this.cycle || this.cycle.duration.isZero) {\n      this.cycle = Cycle.DEFAULT;\n    }\n\n    this._rowStartOffsets = [];\n    this._rowEndOffsets = [];\n    this._rowDurations = [];\n    this._totalLayoutDuration = ZERO;\n    this._totalBeats = 0;\n    this._beatLayouts = [];\n    this.lineBreaks = config.lineBreaks || config.layout || [];\n  }\n\n  /**\n   * Checks if this LayoutParams is equal to another LayoutParams.\n   * @param another The LayoutParams to compare with\n   * @returns True if the LayoutParams are equal, false otherwise\n   */\n  equals(another: this): boolean {\n    return (\n      // super.equals(another) &&\n      this.beatDuration == another.beatDuration &&\n      this.cycle.equals(another.cycle) &&\n      this.lineBreaksEqual(another._lineBreaks)\n    );\n  }\n\n  /**\n   * Checks if the line breaks pattern is equal to another pattern.\n   * @param another The line breaks pattern to compare with\n   * @returns True if the patterns are equal, false otherwise\n   */\n  lineBreaksEqual(another: number[]): boolean {\n    return this._lineBreaks.length == another.length && this._lineBreaks.every((x, i) => x == another[i]);\n  }\n\n  /**\n   * Returns a debug-friendly representation of this LayoutParams.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return {\n      // ...super.debugValue(),\n      cycle: this.cycle?.debugValue(),\n      beatDuration: this.beatDuration,\n      lineBreaks: this._lineBreaks,\n    };\n  }\n\n  /**\n   * Returns the \"location\" of a beat within a layout.\n   *\n   * Lines are broken into beats of notes and those beats are aligned as per\n   * the specs in the LayoutParams (breaks). For example if the breaks param\n   * stipulates [5, 5, 4] then we have 5 beats in the first 2 lines and 4 in\n   * the last line.\n   *\n   * @param beat The beat to locate\n   * @returns A tuple containing [layoutLine, layoutColumn, rowOffset]\n   *         - layoutLine: The line in the layout break spec this beat falls in\n   *         - layoutColumn: The column within the layoutLine\n   *         - rowOffset: The offset of the beat from the start of the row/line\n   */\n  getBeatLocation(beat: {\n    index: number;\n    barIndex: number;\n    beatIndex: number;\n    instance: number;\n  }): [number, number, Fraction] {\n    //\n    // If a line contains say 50 beats (B1 - B50), then it is laid out as:\n    //\n    //      C0  C1  C2  C3  C4\n    //    ---------------------\n    // L0 | B1  B2  B3  B4  B5\n    // L1 | B6  B7  B8  B9  B10\n    // L2 | B11 B12 B13 B14\n    // L0 | B15 B16 B17 B18 B19\n    // L1 | B20 B21 B22 B23 B24\n    // L2 | B25 B26 B27 B28\n    // L0 | B29 B30 B31 B32 B33\n    // L1 | B34 B35 B36 B37 B38\n    // L2 | B39 B40 B41 B42\n    // L0 | B43 B44 B45 B46 B47\n    // L1 | B48 B49 B50\n    //\n    // This methods returns the triple: [layoutLine, layoutColumn, rowOffset]\n    // where\n    //\n    //  layoutLine: The particular line in the layout break spec this index falls in.\n    //              *Note*: Since lines can start with negative offsets, we can\n    //              even return a layoutLine that is towards the end and then go\n    //              back to 0, eg 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4 ...\n    //              (eg returns L0 or L1 ... Ln)\n    //  layoutColumn: The column within the layoutLine line where this beat falls.\n    //                (eg C0 - C4 above - or depending on how many columns exist\n    //                in the particular layout line).\n    //  rowOffset: The note offset of the beat from the start of the row/line\n    //             (not from the start of the cycle).\n    //\n    // Note the beatIndex can also be negative so we can return a beat\n    // starting from before the cycle starting point.\n    //\n    //  To calculate the \"real\" line globally simply do:\n    //\n    //    realLine = lineBreaks.length  // Math.floor(beatIndex / this.totalBeats) + layoutLine;\n    //\n    // Some examples here are (using B1-B50 above):\n    const modIndex = beat.index % this.totalBeats;\n    let total = 0;\n    for (let i = 0; i < this._lineBreaks.length; i++) {\n      if (modIndex < total + this._lineBreaks[i]) {\n        // TODO: What is the right offset here?\n        let offset = ZERO;\n        if (modIndex > total) {\n          const cursor = new CycleCursor(this.cycle, beat.barIndex, beat.beatIndex, beat.instance);\n          let [, duration] = cursor.prev;\n          for (let i = total; i < modIndex; i++) {\n            [, duration] = cursor.prev;\n            offset = offset.plus(duration.timesNum(this.beatDuration));\n          }\n        }\n        return [i, modIndex - total, offset];\n      }\n      total += this._lineBreaks[i];\n    }\n    throw new Error(\"Invalid beat index: \" + beat.index);\n    return [-1, -1, ZERO];\n  }\n\n  /**\n   * Gets the line layout pattern - i.e., number of beats in each line - as a\n   * repeating pattern.\n   *\n   * For example 4,2,4 indicates that the notes in our song should be\n   * laid out 4 beats in line 1, 2 beats in line 2, 4 beats in line 3 and\n   * 4 beats in line 4 and so on as long as there are more notes available\n   * in this line.\n   */\n  get lineBreaks(): number[] {\n    if (!this._lineBreaks || this._lineBreaks.length == 0) {\n      // trigger a refresh\n      this.lineBreaks = [this.cycle.beatCount];\n    }\n    return this._lineBreaks;\n  }\n\n  /**\n   * Sets the line layout pattern.\n   */\n  set lineBreaks(val: number[]) {\n    this._lineBreaks = val;\n    this.refreshLayout();\n  }\n\n  /**\n   * Returns the number of beats in each line based on the line layout\n   * after taking beatDuration into account.\n   */\n  get beatLayouts(): ReadonlyArray<ReadonlyArray<[CyclePosition, Fraction]>> {\n    if (!this._beatLayouts || this._beatLayouts.length < this.lineBreaks.length) {\n      this.refreshLayout();\n    }\n    return this._beatLayouts;\n  }\n\n  /**\n   * Gets the total number of beats across all lines in the layout pattern.\n   */\n  get totalBeats(): number {\n    this.beatLayouts;\n    return this._totalBeats;\n  }\n\n  /**\n   * Gets the total duration of all beats across all lines in the layout pattern.\n   */\n  get totalLayoutDuration(): Fraction {\n    this.beatLayouts;\n    return this._totalLayoutDuration;\n  }\n\n  /**\n   * Refreshes the layout calculations based on the current cycle and line breaks.\n   * This rebuilds the beat layouts, row durations, and offset information.\n   */\n  protected refreshLayout(): void {\n    const cycleIter = this.cycle.iterateBeats();\n    const akb = this.beatDuration;\n    this._beatLayouts = this.lineBreaks.map((numBeats, index) => {\n      const beats: [CyclePosition, Fraction][] = [];\n      // see what the beat lengths are here\n      for (let i = 0; i < numBeats; i++) {\n        const nextCP = cycleIter.next().value;\n        nextCP[1] = nextCP[1].timesNum(akb);\n        beats.push(nextCP);\n      }\n      return beats;\n    });\n    this._totalBeats = this.lineBreaks.reduce((a, b) => a + b, 0);\n    this._rowDurations = this._beatLayouts.map((beats) => beats.reduce((x, y) => x.plus(y[1]), ZERO));\n    this._rowDurations.forEach((rd, index) => {\n      this._rowStartOffsets[index] = index == 0 ? ZERO : this._rowStartOffsets[index - 1].plus(rd);\n    });\n    this._rowEndOffsets = this._rowDurations.map((rd, index) => {\n      return this._rowStartOffsets[index].plus(rd);\n    });\n    this._totalLayoutDuration = this._rowDurations.reduce((x, y) => x.plus(y), ZERO);\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\n// import * as kiwi from \"@lume/kiwi\";\n\n/**\n * Event emitted when layout changes occur in a GridLayoutGroup.\n * Subscribers can use this to update their views incrementally.\n */\nexport interface LayoutChangeEvent {\n  /** The range of rows affected by the change */\n  affectedRowRange: { start: number; end: number } | null;\n  /** The range of columns affected by the change */\n  affectedColRange: { start: number; end: number } | null;\n  /** Whether column widths changed (requires horizontal re-layout) */\n  columnWidthsChanged: boolean;\n  /** Whether row heights changed (requires vertical re-layout) */\n  rowHeightsChanged: boolean;\n  /** The grid models that were affected */\n  affectedGridModels: GridModel[];\n}\n\n/**\n * Callback type for layout change subscribers.\n */\nexport type LayoutChangeCallback = (event: LayoutChangeEvent) => void;\n\n/**\n * A generic grid layout system for hosting child views (similar to GridBagLayout).\n * This provides a framework for hosting BeatViews in a structured grid arrangement,\n * with support for rows, columns, and alignment.\n *\n * Grid \"cells\" can be referred to by cell indexes. Additionally, grid rows and\n * columns can have names (like in spreadsheets) so that even when rows and columns\n * are inserted, though indexes may change, the \"addresses\" remain fixed and immovable.\n */\nexport class GridModel extends TSU.Events.EventEmitter {\n  private static idCounter = 0;\n  readonly uuid = GridModel.idCounter++;\n  /** Timestamp of the last update to this grid */\n  lastUpdatedAt = 0;\n  // cells = new SparseArray<SparseArray<GridCell>>();\n  /** The rows in this grid */\n  rows: GridRow[] = [];\n  /** Mapping of row indices to row alignment objects */\n  rowAligns = new Map<number, RowAlign>();\n  /** Mapping of column indices to column alignment objects */\n  colAligns = new Map<number, ColAlign>();\n\n  /**\n   * Returns a debug-friendly representation of this GridModel.\n   * @returns An object containing debug information\n   */\n  debugValue() {\n    const out = {\n      rows: this.rows.map((r) => r.debugValue()),\n      lastUpdatedAt: this.lastUpdatedAt,\n    } as any;\n    return out;\n  }\n\n  /**\n   * Gets the index of the first non-empty row.\n   * @returns The index of the first row containing cells, or -1 if none\n   */\n  get firstRow(): number {\n    for (const gr of this.rows) {\n      if (gr.numCells > 0) return gr.rowIndex;\n    }\n    return -1;\n  }\n\n  /**\n   * Gets the index of the leftmost column containing cells.\n   * @returns The index of the first column containing cells, or -1 if none\n   */\n  get firstCol(): number {\n    let minCol = -1;\n    for (const gr of this.rows) {\n      const fc = gr.firstCol;\n      if (fc >= 0) {\n        if (minCol < 0 || fc < minCol) {\n          minCol = fc;\n        }\n      }\n    }\n    return minCol;\n  }\n\n  /**\n   * Gets all non-empty cells in a specific row.\n   * @param row The index of the row\n   * @returns An array of cells in the row\n   */\n  cellsInRow(row: number): GridCell[] {\n    const out = [] as GridCell[];\n    const gr = this.rows[row];\n    if (gr) {\n      for (const cell of gr.cells) {\n        if (cell?.value) out.push(cell);\n      }\n    }\n    return out;\n  }\n\n  /**\n   * Gets all non-empty cells in a specific column.\n   * @param col The index of the column\n   * @returns An array of cells in the column\n   */\n  cellsInCol(col: number): GridCell[] {\n    const out = [] as GridCell[];\n    for (const gr of this.rows) {\n      const cell = gr.cellAt(col);\n      if (cell?.value) out.push(cell);\n    }\n    return out;\n  }\n\n  /**\n   * Adds a row alignment object to the grid.\n   * @param align The row alignment to add\n   */\n  addRowAlign(align: RowAlign): void {\n    this.rowAligns.set(align.uuid, align);\n  }\n\n  /**\n   * Adds a column alignment object to the grid.\n   * @param align The column alignment to add\n   */\n  addColAlign(align: ColAlign): void {\n    this.colAligns.set(align.uuid, align);\n  }\n\n  /**\n   * Adds rows to the grid.\n   * @param insertBefore The index before which to insert the rows, or -1 to append\n   * @param numRows The number of rows to add\n   * @returns This grid instance for method chaining\n   */\n  addRows(insertBefore = -1, numRows = 1): this {\n    if (insertBefore < 0) {\n      insertBefore = this.rows.length;\n    }\n    let next = this.rows[insertBefore] || null;\n    const prev = this.rows[insertBefore - 1] || null;\n    for (let i = numRows - 1; i >= 0; i--) {\n      const newRow = new GridRow(this, insertBefore + i);\n      this.rows.splice(insertBefore, 0, newRow);\n      if (next != null) {\n        newRow.defaultRowAlign.addSuccessor(next.defaultRowAlign);\n      }\n      if (i == 0 && insertBefore > 0) {\n        prev.defaultRowAlign.addSuccessor(newRow.defaultRowAlign);\n      }\n      next = newRow;\n    }\n    for (let i = insertBefore + numRows; i < this.rows.length; i++) {\n      this.rows[i].rowIndex += numRows;\n    }\n    return this;\n  }\n\n  /**\n   * Gets a row at the specified index, creating it if necessary.\n   * @param row The index of the row to get\n   * @returns The row at the specified index\n   */\n  getRow(row: number): GridRow {\n    if (row >= this.rows.length) {\n      this.addRows(-1, 1 + row - this.rows.length);\n    }\n    return this.rows[row];\n  }\n\n  /**\n   * Sets a value in a cell at the specified row and column.\n   * @param row The row index\n   * @param col The column index\n   * @param value The value to set\n   * @param cellCreator Optional function to create a custom cell\n   * @returns The previous value of the cell\n   */\n  setValue(row: number, col: number, value: any, cellCreator?: (row: GridRow, col: number) => GridCell): any {\n    const grow = this.getRow(row);\n    if (!cellCreator) {\n      cellCreator = (row: GridRow, col: number) => {\n        return new GridCell(row, col);\n      };\n    }\n    if (value == null) {\n      const out = grow.clearCellAt(col);\n      if (out != null) {\n        this.eventHub?.emit(GridCellEvent.CLEARED, this, {\n          loc: out.location,\n        });\n      }\n      return out;\n    } else {\n      const cell = grow.cellAt(col, cellCreator) as GridCell;\n      const oldValue = cell.value;\n      this.eventHub?.emit(GridCellEvent.UPDATED, this, {\n        loc: cell.location,\n        cell: cell,\n        oldValue: cell.value,\n      });\n      cell.value = value;\n      return oldValue;\n    }\n  }\n\n  /**\n   * Handles changes to the event hub.\n   */\n  protected eventHubChanged(): void {\n    console.log(\"Event Hub Changed for GridModel\");\n  }\n}\n\n/**\n * Interface for a view associated with a grid cell.\n * GridCellView defines the contract for views that can be placed in grid cells.\n */\nexport interface GridCellView {\n  /** The grid cell this view is associated with */\n  readonly cell: GridCell;\n  /** X-coordinate of the view */\n  x: number;\n  /** Y-coordinate of the view */\n  y: number;\n  /** Width of the view */\n  width: number;\n  /** Height of the view */\n  height: number;\n\n  /**\n   * Sets the bounds of the view.\n   * @param x New x-coordinate, or null to keep current value\n   * @param y New y-coordinate, or null to keep current value\n   * @param w New width, or null to keep current value\n   * @param h New height, or null to keep current value\n   * @param applyLayout Whether to apply layout immediately\n   * @returns The new bounds values\n   */\n  setBounds(\n    x: number | null,\n    y: number | null,\n    w: number | null,\n    h: number | null,\n    applyLayout: boolean,\n  ): [number | null, number | null, number | null, number | null];\n\n  /** Whether this view needs layout */\n  readonly needsLayout: boolean;\n\n  /** The minimum size this view requires */\n  readonly minSize: TSU.Geom.Size;\n\n  /** The bounding box of this view */\n  readonly bbox: TSU.Geom.Rect;\n}\n\n/**\n * Enum defining the events that can occur on grid cells.\n */\nexport enum GridCellEvent {\n  ADDED = \"CellAdded\",\n  CLEARED = \"CellCleared\",\n  REMOVED = \"CellRemoved\",\n  UPDATED = \"CellUpdated\",\n  MOVED = \"CellMoved\",\n}\n\n/**\n * Represents a cell in the grid.\n * GridCell holds a value and manages alignment with rows and columns.\n */\nexport class GridCell {\n  private static idCounter = 0;\n  readonly uuid = GridCell.idCounter++;\n  /** The view associated with this cell */\n  cellView: GridCellView | null;\n  private _rowAlign: RowAlign;\n  private _colAlign: ColAlign;\n\n  /**\n   * Creates a new GridCell.\n   * @param gridRow The row this cell belongs to\n   * @param colIndex The column index of this cell\n   * @param value Optional initial value for the cell\n   */\n  constructor(\n    public gridRow: GridRow,\n    public colIndex: number,\n    public value: any = null,\n  ) {\n    this.rowAlign = gridRow.defaultRowAlign;\n  }\n\n  /**\n   * Gets the row alignment for this cell.\n   */\n  get rowAlign(): RowAlign {\n    return this._rowAlign;\n  }\n\n  /**\n   * Sets the row alignment for this cell.\n   */\n  set rowAlign(val: RowAlign) {\n    val.addCell(this);\n    this._rowAlign = val;\n  }\n\n  /**\n   * Gets the column alignment for this cell.\n   */\n  get colAlign(): ColAlign {\n    return this._colAlign;\n  }\n\n  /**\n   * Sets the column alignment for this cell.\n   */\n  set colAlign(val: ColAlign) {\n    val.addCell(this);\n    this._colAlign = val;\n  }\n\n  /**\n   * Gets the location string for this cell (rowIndex:colIndex).\n   */\n  get location(): string {\n    return this.gridRow.rowIndex + \":\" + this.colIndex;\n  }\n\n  /**\n   * Gets the grid this cell belongs to.\n   */\n  get grid(): GridModel {\n    return this.gridRow.grid;\n  }\n\n  /**\n   * Gets the row index of this cell.\n   */\n  get rowIndex(): number {\n    return this.gridRow.rowIndex;\n  }\n\n  /**\n   * Returns a debug-friendly representation of this GridCell.\n   * @returns An object containing debug information\n   */\n  debugValue() {\n    const out = {\n      r: this.gridRow.rowIndex,\n      c: this.colIndex,\n      value: this.value,\n      y: this.rowAlign.coordOffset,\n      h: this.rowAlign.maxLength,\n    } as any;\n    if (this.colAlign) {\n      out.x = this.colAlign.coordOffset;\n      out.w = this.colAlign.maxLength;\n    }\n    return out;\n  }\n}\n\n/**\n * Represents a row of grid cells in a GridModel.\n */\nexport class GridRow {\n  /** The cells in this row */\n  cells: (null | GridCell)[] = [];\n  /** The default vertical alignment for all cells in this row */\n  defaultRowAlign: RowAlign;\n\n  /**\n   * Creates a new GridRow.\n   * @param grid The grid this row belongs to\n   * @param rowIndex The index of this row\n   */\n  constructor(\n    public grid: GridModel,\n    public rowIndex: number,\n  ) {\n    this.defaultRowAlign = new RowAlign();\n    this.grid.addRowAlign(this.defaultRowAlign);\n  }\n\n  /**\n   * Gets the index of the first non-empty column in this row.\n   */\n  get firstCol() {\n    for (let i = 0; i < this.cells.length; i++) {\n      if (this.cells[i]?.value) {\n        return i;\n      }\n    }\n    return -1;\n  }\n\n  /**\n   * Gets the number of columns in this row.\n   */\n  get numCols() {\n    return this.cells.length;\n  }\n\n  /**\n   * Gets the number of cells that contain values.\n   */\n  get numCells() {\n    let i = 0;\n    for (const cell of this.cells) {\n      if (cell != null && cell.value != null) i++;\n    }\n    return i;\n  }\n\n  /**\n   * Gets the cell at the specified column index, optionally creating it if it doesn't exist.\n   * @param col The column index\n   * @param creator Optional function to create the cell if it doesn't exist\n   * @returns The cell at the specified index, or null if it doesn't exist and no creator was provided\n   */\n  cellAt(col: number, creator?: (row: GridRow, col: number) => GridCell): GridCell | null {\n    let out = this.cells[col] || null;\n    if (!out && creator) {\n      this.cells[col] = out = creator(this, col);\n      out.gridRow = this;\n      out.colIndex = col;\n      if (out.rowAlign) {\n        this.grid.addRowAlign(out.rowAlign);\n      }\n      if (out.colAlign) {\n        this.grid.addColAlign(out.colAlign);\n      }\n    }\n    return out;\n  }\n\n  /**\n   * Clears the cell at the given column.\n   * Note this is not the same as \"removing\" a cell.\n   * Removing a cell would require all cells to the \"right\" to be shifted left.\n   * @param col The column index\n   * @returns The cell that was cleared, or null if none existed\n   */\n  clearCellAt(col: number): GridCell | null {\n    const out = this.cells[col] || null;\n    if (out) {\n      this.cells[col] = null;\n    }\n    return out;\n  }\n\n  /**\n   * Returns a debug-friendly representation of this GridRow.\n   * @returns An object containing debug information\n   */\n  debugValue() {\n    return {\n      r: this.rowIndex,\n      cells: this.cells.filter((c) => c).map((c) => c?.debugValue()),\n    };\n  }\n}\n\n/**\n * Base class for row and column alignment objects.\n * AlignedLine manages the alignment of cells along a line (row or column).\n */\nexport abstract class AlignedLine {\n  private static idCounter = 0;\n  readonly uuid = AlignedLine.idCounter++;\n  /** Whether this line needs layout */\n  needsLayout = false;\n  /** The coordinate offset of this line */\n  protected _coordOffset = 0;\n  /** The maximum length of this line */\n  protected _maxLength = 0;\n  /** Padding before this line */\n  paddingBefore = 5;\n  /** Padding after this line */\n  paddingAfter = 5;\n  /** The cells that belong to this line */\n  cells: GridCell[] = [];\n  /** Function to get a view for a cell value */\n  getCellView: (value: any) => GridCellView;\n\n  /**\n   * Sets the offset of this line.\n   * @param val The new offset value\n   */\n  abstract setOffset(val: number): void;\n\n  /**\n   * Evaluates the maximum length required for this line.\n   * @param changedCells Cells that have changed and need re-evaluation\n   * @returns The maximum length\n   */\n  abstract evalMaxLength(changedCells: GridCell[]): number;\n\n  /**\n   * Gets the coordinate offset of this line.\n   */\n  get coordOffset(): number {\n    return this._coordOffset;\n  }\n\n  /**\n   * Gets the maximum length of this line, including padding.\n   */\n  get maxLength(): number {\n    return this._maxLength + this.paddingBefore + this.paddingAfter;\n  }\n\n  /**\n   * Sets the maximum length of this line.\n   * @param length The new maximum length\n   */\n  setMaxLength(length: number) {\n    this._maxLength = length;\n  }\n\n  /**\n   * Sets the padding before and after this line.\n   * @param before Padding before the line\n   * @param after Padding after the line\n   */\n  setPadding(before: number, after: number): void {\n    if (before >= 0) {\n      this.paddingBefore = before;\n    }\n    if (after >= 0) {\n      this.paddingAfter = after;\n    }\n  }\n\n  /**\n   * Adds a cell to this line.\n   * @param cell The cell to add\n   * @returns This line instance for method chaining\n   */\n  addCell(cell: GridCell): this {\n    if (this.beforeAddingCell(cell)) {\n      this.cells.push(cell);\n    }\n    return this;\n  }\n\n  /**\n   * Called before adding a cell to perform validation or preparation.\n   * @param cell The cell to be added\n   * @returns Whether the cell should be added\n   */\n  protected abstract beforeAddingCell(cell: GridCell): boolean;\n\n  /**\n   * Removes a cell from this line.\n   * @param cell The cell to remove\n   * @returns This line instance for method chaining\n   */\n  removeCell(cell: GridCell): this {\n    if (this.beforeRemovingCell(cell)) {\n      for (let i = 0; i < this.cells.length; i++) {\n        if (this.cells[i].uuid == cell.uuid) {\n          this.cells.splice(i, 1);\n          break;\n        }\n      }\n    }\n    return this;\n  }\n\n  /**\n   * Called before removing a cell to perform validation.\n   * @param cell The cell to be removed\n   * @returns Whether the cell should be removed\n   */\n  protected abstract beforeRemovingCell(cell: GridCell): boolean;\n\n  // The \"neighboring\" lines that depend on this line to be placed\n  // before they are placed\n  /** Lines that must be positioned before this line */\n  prevLines = [] as this[];\n  /** Lines that must be positioned after this line */\n  nextLines = [] as this[];\n\n  /**\n   * Adds a successor line to this line.\n   * @param next The line to add as a successor\n   */\n  addSuccessor(next: this): void {\n    // Set nextCol as a successor of this col\n    // TODO - Ensure no cycles\n    for (const c of this.nextLines) {\n      if (c == next) return;\n    }\n    this.nextLines.push(next);\n    next.prevLines.push(this);\n  }\n\n  /* TODO: Disabling only to improve test coverage as this method is\n   * not used.\n   * When we have mutable grids where we can insert/remove neighbors\n   * we can enable this again.\n   */\n  /*\n  removeSuccessor(next: this): void {\n    // Set nextCol as a successor of this col\n    // TODO - Ensure no cycles\n    for (let i = 0; i < this.nextLines.length; i++) {\n      if (this.nextLines[i] == next) {\n        this.nextLines.splice(i, 1);\n        break;\n      }\n    }\n    for (let i = 0; i < next.prevLines.length; i++) {\n      if (next.prevLines[i] == this) {\n        next.prevLines.splice(i, 1);\n        break;\n      }\n    }\n  }\n  */\n}\n\n/**\n * Manages the alignment of cells in a column.\n */\nexport class ColAlign extends AlignedLine {\n  paddingBefore = 10;\n  /** Padding after this line */\n  paddingAfter = 10;\n\n  /**\n   * Sets the offset of this column and updates all associated cells.\n   * @param val The new offset value\n   */\n  setOffset(val: number): void {\n    this._coordOffset = val;\n    for (const cell of this.cells) {\n      if (cell.value) {\n        const cellView = this.getCellView(cell);\n        if (this._maxLength <= 0) {\n          // this hasnt been evaluated yet so do it!\n          this.evalMaxLength();\n        }\n        cellView.setBounds(val, null, this.maxLength, null, true);\n      }\n    }\n  }\n\n  /**\n   * Evaluates the maximum width required for this column.\n   * @param changedCells Cells that have changed and need re-evaluation\n   * @returns The maximum width\n   */\n  evalMaxLength(changedCells: GridCell[] = []): number {\n    this._maxLength = 0;\n    for (const cell of this.cells) {\n      if (cell.value) {\n        const cellView = this.getCellView(cell);\n        this._maxLength = Math.max(cellView.minSize.width, this._maxLength);\n      }\n    }\n    return this._maxLength;\n  }\n\n  /**\n   * Called before adding a cell to perform validation or preparation.\n   * @param cell The cell to be added\n   * @returns Whether the cell should be added\n   */\n  protected beforeAddingCell(cell: GridCell): boolean {\n    if (cell.colAlign && cell.colAlign != this) {\n      cell.colAlign.removeCell(cell);\n    }\n    return cell.colAlign != this;\n  }\n\n  /**\n   * Called before removing a cell to perform validation.\n   * @param cell The cell to be removed\n   * @returns Whether the cell should be removed\n   */\n  beforeRemovingCell(cell: GridCell): boolean {\n    return cell.colAlign == this;\n  }\n}\n\n/**\n * Manages the alignment of cells in a row.\n */\nexport class RowAlign extends AlignedLine {\n  /**\n   * Sets the Y coordinate of all cells in this row.\n   * @param val The new Y coordinate\n   */\n  setOffset(val: number): void {\n    this._coordOffset = val;\n    for (const cell of this.cells) {\n      if (cell.value) {\n        const cellView = this.getCellView(cell);\n        if (this._maxLength <= 0) {\n          // this hasnt been evaluated yet so do it!\n          this.evalMaxLength();\n        }\n        cellView.setBounds(null, val, null, this.maxLength, true);\n      }\n    }\n  }\n\n  /**\n   * Evaluates the maximum height required for this row.\n   * @param changedCells Cells that have changed and need re-evaluation\n   * @returns The maximum height\n   */\n  evalMaxLength(changedCells: GridCell[] = []): number {\n    this._maxLength = 0;\n    for (const cell of this.cells) {\n      if (cell.value) {\n        const cellView = this.getCellView(cell);\n        this._maxLength = Math.max(cellView.minSize.height, this._maxLength);\n      }\n    }\n    return this._maxLength;\n  }\n\n  /**\n   * Called before adding a cell to perform validation or preparation.\n   * @param cell The cell to be added\n   * @returns Whether the cell should be added\n   */\n  protected beforeAddingCell(cell: GridCell): boolean {\n    if (cell.rowAlign && cell.rowAlign != this) {\n      cell.rowAlign.removeCell(cell);\n    }\n    return cell.rowAlign != this;\n  }\n\n  /**\n   * Called before removing a cell to perform validation.\n   * @param cell The cell to be removed\n   * @returns Whether the cell should be removed\n   */\n  beforeRemovingCell(cell: GridCell): boolean {\n    return cell.rowAlign == this;\n  }\n}\n\n/**\n * The layout manager for a collection of GridViews bound by common alignment objects.\n * Manages the layout of multiple grid models, ensuring proper alignment between them.\n */\nexport class GridLayoutGroup {\n  // rowAligns = new Map<number, RowAlign>();\n  // colAligns = new Map<number, ColAlign>();\n  /** The grid models managed by this layout group */\n  gridModels = [] as GridModel[];\n\n  /** Subscribers to layout change events */\n  private layoutChangeSubscribers = new Set<LayoutChangeCallback>();\n\n  /** Previous column widths by ColAlign uuid - for detecting actual changes */\n  private previousColumnWidths = new Map<number, number>();\n\n  /** Previous row heights by RowAlign uuid - for detecting actual changes */\n  private previousRowHeights = new Map<number, number>();\n\n  /**\n   * Subscribes to layout change events.\n   * @param callback Function to call when layout changes\n   * @returns Unsubscribe function\n   */\n  onLayoutChange(callback: LayoutChangeCallback): () => void {\n    this.layoutChangeSubscribers.add(callback);\n    return () => {\n      this.layoutChangeSubscribers.delete(callback);\n    };\n  }\n\n  /**\n   * Notifies all subscribers of a layout change.\n   * @param event The layout change event\n   */\n  protected notifyLayoutChange(event: LayoutChangeEvent): void {\n    for (const callback of this.layoutChangeSubscribers) {\n      try {\n        callback(event);\n      } catch (e) {\n        console.error(\"Error in layout change callback:\", e);\n      }\n    }\n  }\n\n  /**\n   * Gets the number of layout change subscribers.\n   */\n  get subscriberCount(): number {\n    return this.layoutChangeSubscribers.size;\n  }\n\n  /**\n   * Event handler for processing events from grid models.\n   */\n  private eventHandler = (event: TSU.Events.TEvent) => {\n    this.applyModelEvents(event.payload);\n  };\n\n  /**\n   * Adds a grid model to this layout group.\n   * @param gridModel The grid model to add\n   * @returns True if the model was added successfully\n   */\n  addGridModel(gridModel: GridModel): boolean {\n    gridModel.eventHub?.on(TSU.Events.EventHub.BATCH_EVENTS, this.eventHandler);\n    this.gridModels.push(gridModel);\n    return true;\n  }\n\n  /**\n   * Gets all row alignment objects that have no predecessors.\n   * @returns An array of starting row alignments\n   */\n  startingRowAligns(): RowAlign[] {\n    const out = [] as RowAlign[];\n    const visited = {} as any;\n    for (const gm of this.gridModels) {\n      for (const cell of gm.cellsInRow(gm.firstRow)) {\n        if (cell.rowAlign && !visited[cell.rowAlign.uuid]) {\n          visited[cell.rowAlign.uuid] = true;\n          out.push(cell.rowAlign);\n        }\n      }\n    }\n    return out;\n  }\n\n  /**\n   * Gets all column alignment objects that have no predecessors.\n   * @returns An array of starting column alignments\n   */\n  startingColAligns(): ColAlign[] {\n    const out = [] as ColAlign[];\n    const visited = {} as any;\n    for (const gm of this.gridModels) {\n      for (const cell of gm.cellsInCol(gm.firstCol)) {\n        if (cell.colAlign && !visited[cell.colAlign.uuid]) {\n          visited[cell.colAlign.uuid] = true;\n          out.push(cell.colAlign);\n        }\n      }\n    }\n    return out;\n  }\n\n  /**\n   * Removes a grid model from this layout group.\n   * @param gridModel The grid model to remove\n   */\n  removeGridModel(gridModel: GridModel): void {\n    gridModel.eventHub?.removeOn(TSU.Events.EventHub.BATCH_EVENTS, this.eventHandler);\n  }\n\n  /**\n   * Function to get a view for a cell value.\n   */\n  getCellView: (cell: GridCell) => GridCellView;\n\n  /**\n   * Gets the starting row alignments.\n   */\n  get startingRows(): RowAlign[] {\n    return this.startingRowAligns();\n  }\n\n  /**\n   * Gets the starting column alignments.\n   */\n  get startingCols(): ColAlign[] {\n    return this.startingColAligns();\n  }\n\n  /**\n   * Forces a full refresh of the layout.\n   * This recalculates all row and column sizes and positions.\n   * @param notify Whether to notify subscribers of the change (default: true)\n   */\n  refreshLayout(notify = true): void {\n    const changedRowAligns = {} as any;\n    const changedColAligns = {} as any;\n\n    for (const rowAlign of this.startingRowAligns()) {\n      if (!(rowAlign.uuid in changedRowAligns)) {\n        changedRowAligns[rowAlign.uuid] = {\n          align: rowAlign,\n          cells: [],\n        };\n      }\n    }\n\n    for (const colAlign of this.startingColAligns()) {\n      if (!(colAlign.uuid in changedColAligns)) {\n        changedColAligns[colAlign.uuid] = {\n          align: colAlign,\n          cells: [],\n        };\n      }\n    }\n\n    // Pass the previous dimension maps for O(1) inline change detection\n    const rowHeightsChanged = this.doBfsLayout(this.startingRows, changedRowAligns, this.previousRowHeights);\n    const columnWidthsChanged = this.doBfsLayout(this.startingCols, changedColAligns, this.previousColumnWidths);\n\n    // Notify subscribers of full refresh\n    if (notify && this.layoutChangeSubscribers.size > 0) {\n      this.notifyLayoutChange({\n        affectedRowRange: null, // null means all rows\n        affectedColRange: null, // null means all columns\n        columnWidthsChanged,\n        rowHeightsChanged,\n        affectedGridModels: this.gridModels,\n      });\n    }\n  }\n\n  /**\n   * Applies model events to update the layout.\n   * @param events The events to process\n   */\n  protected applyModelEvents(events: TSU.Events.TEvent[]): void {\n    // As the grid model changes (cell content changed, cleared etc) we need\n    // to refresh our layout based on this.\n    // As a first step the new height and width of all changed cells is\n    // evaluted to see which rows and/or columns are affected (and need to be\n    // resized/repositioned).\n    const [changedRowAligns, changedColAligns, affectedGridModels] = this.changesForEvents(events);\n    const hadRowChanges = Object.keys(changedRowAligns).length > 0;\n    const hadColChanges = Object.keys(changedColAligns).length > 0;\n\n    // Pass the previous dimension maps for O(1) inline change detection\n    const rowHeightsChanged = this.doBfsLayout(this.startingRows, changedRowAligns, this.previousRowHeights);\n    const columnWidthsChanged = this.doBfsLayout(this.startingCols, changedColAligns, this.previousColumnWidths);\n\n    // Notify subscribers of incremental changes\n    if (this.layoutChangeSubscribers.size > 0 && (hadRowChanges || hadColChanges)) {\n      // Calculate affected ranges from the changed alignments\n      const affectedRowRange = this.calculateAffectedRowRange(changedRowAligns);\n      const affectedColRange = this.calculateAffectedColRange(changedColAligns);\n\n      this.notifyLayoutChange({\n        affectedRowRange,\n        affectedColRange,\n        columnWidthsChanged,\n        rowHeightsChanged,\n        affectedGridModels: affectedGridModels,\n      });\n    }\n  }\n\n  /**\n   * Calculates the range of affected rows from changed row alignments.\n   * Returns null if no rows changed or range cannot be determined.\n   */\n  protected calculateAffectedRowRange(changedRowAligns: any): { start: number; end: number } | null {\n    let minRow = Infinity;\n    let maxRow = -Infinity;\n\n    for (const alignId in changedRowAligns) {\n      const { cells } = changedRowAligns[alignId];\n      for (const cell of cells) {\n        const rowIndex = cell.gridRow.rowIndex;\n        minRow = Math.min(minRow, rowIndex);\n        maxRow = Math.max(maxRow, rowIndex);\n      }\n    }\n\n    if (minRow === Infinity) return null;\n    return { start: minRow, end: maxRow };\n  }\n\n  /**\n   * Calculates the range of affected columns from changed column alignments.\n   * Returns null if no columns changed or range cannot be determined.\n   */\n  protected calculateAffectedColRange(changedColAligns: any): { start: number; end: number } | null {\n    let minCol = Infinity;\n    let maxCol = -Infinity;\n\n    for (const alignId in changedColAligns) {\n      const { cells } = changedColAligns[alignId];\n      for (const cell of cells) {\n        const colIndex = cell.colIndex;\n        minCol = Math.min(minCol, colIndex);\n        maxCol = Math.max(maxCol, colIndex);\n      }\n    }\n\n    if (minCol === Infinity) return null;\n    return { start: minCol, end: maxCol };\n  }\n\n  /**\n   * Checks if an alignment's maxLength changed from previous value.\n   * Updates the stored previous value. O(1) cost.\n   * @param align The alignment to check\n   * @param previousMap Map storing previous lengths\n   * @returns true if length changed (or is new)\n   */\n  private checkAndUpdateLength<T extends AlignedLine>(align: T, previousMap: Map<number, number>): boolean {\n    const previous = previousMap.get(align.uuid);\n    const current = align.maxLength;\n    previousMap.set(align.uuid, current);\n    return previous === undefined || previous !== current;\n  }\n\n  /**\n   * Determines which rows and columns need to be updated based on events.\n   * @param events The events to process\n   * @returns A tuple containing the changed row alignments, column alignments, and affected grid models\n   */\n  protected changesForEvents(events: TSU.Events.TEvent[]): [any, any, GridModel[]] {\n    // Step 1 - topologically sort RowAligns of changed cells\n    // Step 2 - topologically sort ColAligns of changed cells\n    // Step 3 -\n    const cellVisited = {} as any;\n    const changedRowAligns = {} as any;\n    const changedColAligns = {} as any;\n    const affectedGridModelsSet = new Set<GridModel>();\n    // Going in reverse means we only get the latest event affecting a cell\n    // instead of going through every change.\n    // Later on we can revisit this if the events are edge triggered instead\n    // of level triggered\n    for (let i = events.length - 1; i >= 0; i--) {\n      const event = events[i];\n      const loc = event.payload.loc;\n      if (cellVisited[loc]) continue;\n      cellVisited[loc] = true;\n      const [row, col] = loc.split(\":\").map((x: string) => parseInt(x));\n      const gridModel = event.source as GridModel;\n      affectedGridModelsSet.add(gridModel);\n      const cell = gridModel.getRow(row).cellAt(col);\n      if (cell) {\n        // TODO - For now we are marking both row and col as having\n        // changed for a cell.  We can optimize this to only row or\n        // col based on whether height or width has changed.\n        if (!(cell.rowAlign.uuid in changedRowAligns)) {\n          changedRowAligns[cell.rowAlign.uuid] = {\n            align: cell.rowAlign,\n            cells: [],\n          };\n        }\n        changedRowAligns[cell.rowAlign.uuid][\"cells\"].push(cell);\n\n        if (!(cell.colAlign.uuid in changedColAligns)) {\n          changedColAligns[cell.colAlign.uuid] = {\n            align: cell.colAlign,\n            cells: [],\n          };\n        }\n        changedColAligns[cell.colAlign.uuid][\"cells\"].push(cell);\n      }\n    }\n    return [changedRowAligns, changedColAligns, Array.from(affectedGridModelsSet)];\n  }\n\n  /**\n   * Ensures that a cell view getter function is available for an alignment.\n   * @param align The alignment to check\n   * @returns The cell view getter function\n   */\n  protected ensureGetCellView(align: AlignedLine) {\n    if (!align.getCellView) {\n      if (!this.getCellView) {\n        return null;\n      }\n      align.getCellView = this.getCellView;\n    }\n    return align.getCellView;\n  }\n\n  /**\n   * Performs a breadth-first layout of aligned lines.\n   * @param startingLines The lines to start from\n   * @param changedAligns Map of alignment IDs to changed alignments\n   * @param previousLengths Map to track previous lengths for change detection\n   * @returns true if any dimension (width/height) actually changed\n   */\n  protected doBfsLayout<T extends AlignedLine>(\n    startingLines: T[],\n    changedAligns: any,\n    previousLengths?: Map<number, number>,\n  ): boolean {\n    // 1. start from the starting lines and do a BF traversal\n    // 2. If a line not visited (ie laid out):\n    //      if it is in the changedAlign list then reval its length (w/h)\n    //      set its offset and length if either width or offset has changed\n    //      offset can be thought of changed if the preceding line's offset has changed\n    // first do above for rows\n    if (!this.getCellView) return false;\n    let anyDimensionChanged = false;\n\n    for (const alignId in changedAligns) {\n      const val = changedAligns[alignId];\n      this.ensureGetCellView(val.align);\n      val.align.evalMaxLength(val.cells);\n\n      // Check if this alignment's length actually changed (O(1))\n      if (previousLengths && this.checkAndUpdateLength(val.align, previousLengths)) {\n        anyDimensionChanged = true;\n      }\n    }\n\n    let lineQueue = [] as [null | T, T][];\n    const visitedLines = {} as any;\n    for (const line of startingLines) lineQueue.push([null, line]);\n    const lineOffsetChanged = {} as any;\n    while (lineQueue.length > 0) {\n      const nextQueue = [] as [null | T, T][];\n      for (let i = 0; i < lineQueue.length; i++) {\n        const [prevLineAlign, lineAlign] = lineQueue[i];\n        visitedLines[lineAlign.uuid] = true;\n        let newOffset = lineAlign.coordOffset;\n        let lineChanged = lineAlign.uuid in changedAligns;\n        if (prevLineAlign) {\n          if (lineOffsetChanged[prevLineAlign.uuid]) {\n            newOffset = prevLineAlign.coordOffset + prevLineAlign.maxLength;\n            lineChanged = true;\n          }\n        }\n        if (lineChanged) {\n          this.ensureGetCellView(lineAlign);\n          lineAlign.setOffset(newOffset);\n          lineOffsetChanged[lineAlign.uuid] = true;\n        }\n\n        // Add next neighbors now\n        for (const next of lineAlign.nextLines) {\n          if (!visitedLines[next.uuid]) {\n            nextQueue.push([lineAlign, next]);\n          }\n        }\n      }\n      lineQueue = nextQueue;\n    }\n\n    return anyDimensionChanged;\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { AtomType, Marker, Group, Line, Atom, Space, Role } from \"./\";\nimport { CycleIterator, CyclePosition } from \"./cycle\";\nimport { WindowIterator } from \"./iterators\";\nimport { LayoutParams } from \"./layouts\";\nimport { GridModel, GridRow, GridCell, ColAlign, GridLayoutGroup } from \"./grids\";\nimport { Block, BlockItem, isLine, isBlock } from \"./notation\";\n\ntype Fraction = TSU.Num.Fraction;\nconst ZERO = TSU.Num.Fraction.ZERO;\nconst ONE = TSU.Num.Fraction.ONE;\n\n/**\n * Represents a single beat in the notation.\n * A beat contains one or more atoms and has a specific position in a bar.\n */\nexport class Beat {\n  private static idCounter = 0;\n  readonly uuid = Beat.idCounter++;\n  // Should this be as flat Atoms or should we keep it as atoms and breakdown later?\n\n  /** The atom contained in this beat */\n  atom: Atom;\n  protected atomIsPlaceholder = false;\n\n  /**\n   * Creates a new Beat.\n   * @param index The index of this beat in the sequence\n   * @param role The role this beat belongs to\n   * @param offset The time offset of this beat from the start\n   * @param duration The duration of this beat\n   * @param barIndex The index of the bar containing this beat\n   * @param beatIndex The index of this beat within its bar\n   * @param instance The instance number of this beat\n   * @param prevBeat The previous beat in the sequence, if any\n   * @param nextBeat The next beat in the sequence, if any\n   */\n  constructor(\n    public readonly index: number,\n    public readonly role: Role,\n    public readonly offset: Fraction,\n    public readonly duration: Fraction,\n    public readonly barIndex: number,\n    public readonly beatIndex: number,\n    public readonly instance: number,\n    public readonly prevBeat: null | Beat,\n    public nextBeat: null | Beat,\n  ) {}\n\n  /**\n   * Returns a debug-friendly representation of this Beat.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return {\n      index: this.index,\n      role: this.role.name,\n      offset: this.offset.toString(),\n      duration: this.duration.toString(),\n      barIndex: this.barIndex,\n      beatIndex: this.beatIndex,\n      instance: this.instance,\n      atom: this.atom.debugValue(),\n    };\n  }\n\n  /**\n   * Gets the end offset of this beat (offset + duration).\n   */\n  get endOffset(): Fraction {\n    return this.offset.plus(this.duration);\n  }\n\n  /**\n   * Checks if this beat is filled completely (no remaining space).\n   */\n  get filled(): boolean {\n    return this.remaining.isZero;\n  }\n\n  /**\n   * Gets the remaining duration available in this beat.\n   */\n  get remaining(): Fraction {\n    return this.atom ? this.duration.minus(this.atom.duration, true) : this.duration;\n  }\n\n  /**\n   * Adds an atom to this beat.\n   * @param atom The atom to add\n   * @returns True if the atom was added successfully, false if there's not enough space\n   */\n  add(atom: Atom): boolean {\n    if (this.remaining.cmp(atom.duration) < 0) {\n      return false;\n    }\n    if (!this.atom) {\n      this.atom = atom;\n    } else {\n      if (!this.atomIsPlaceholder) {\n        this.atomIsPlaceholder = true;\n        this.atom = new Group(this.atom).setDuration(ONE, true);\n      }\n      (this.atom as Group).addAtoms(true, atom);\n    }\n    return true;\n  }\n\n  /**\n   * Gets all markers that should be displayed before this beat.\n   * @returns An array of Marker objects\n   */\n  get preMarkers(): Marker[] {\n    const out = [] as Marker[];\n    let curr: Atom | null = this.atom;\n    while (curr != null) {\n      for (const marker of curr.markersBefore || []) {\n        out.push(marker);\n      }\n      if (curr.TYPE == AtomType.GROUP) {\n        curr = (curr as Group).atoms.first;\n      } else {\n        curr = null;\n      }\n    }\n    return out;\n  }\n\n  /**\n   * Gets all markers that should be displayed after this beat.\n   * @returns An array of Marker objects\n   */\n  get postMarkers(): Marker[] {\n    const out = [] as Marker[];\n    let curr: Atom | null = this.atom;\n    while (curr != null) {\n      out.splice(0, 0, ...(curr.markersAfter || []));\n      if (curr.TYPE == AtomType.GROUP) {\n        curr = (curr as Group).atoms.last;\n      } else {\n        curr = null;\n      }\n    }\n    return out;\n  }\n}\n\n/**\n * Builds a sequence of beats from atoms according to layout parameters.\n * Used to convert a flat sequence of atoms into structured beats for display.\n */\nexport class BeatsBuilder {\n  /** All atoms divided into beats */\n  readonly beats: Beat[] = [];\n  readonly startIndex: number;\n  readonly beatOffset: Fraction;\n  cycleIter: CycleIterator;\n  windowIter: WindowIterator;\n\n  /** Callback for when an atom is added to this role */\n  onAtomAdded: (atom: Atom, beat: Beat) => void;\n\n  /** Callback for when a new beat is added */\n  onBeatAdded: (beat: Beat) => void;\n\n  /** Callback for when a beat has been filled */\n  onBeatFilled: (beat: Beat) => void;\n\n  /**\n   * Creates a new BeatsBuilder.\n   * @param role The role containing the atoms\n   * @param layoutParams Layout parameters for structuring beats\n   * @param startOffset The starting offset for the first beat, defaults to ZERO\n   * @param atoms Initial atoms to add to the beats\n   */\n  constructor(\n    public readonly role: Role,\n    public readonly layoutParams: LayoutParams,\n    public readonly startOffset: Fraction = ZERO,\n    ...atoms: Atom[]\n  ) {\n    const [, [bar, beat, instance], beatOffset, index] = layoutParams.cycle.getPosition(startOffset);\n    this.cycleIter = layoutParams.cycle.iterateBeats(bar, beat, instance);\n    this.windowIter = new WindowIterator();\n    this.beatOffset = beatOffset;\n\n    // evaluate the start beatindex - typically it would be 0 if things start\n    // at beginning of a cycle.  But if the start offset is < 0 then the\n    // startIndex should also shift accordingly\n    this.startIndex = index;\n    this.addAtoms(...atoms);\n  }\n\n  /**\n   * Adds atoms to be processed into beats.\n   * @param atoms The atoms to add\n   */\n  addAtoms(...atoms: Atom[]): void {\n    // First add all atoms to the atom Iterator so we can\n    // fetch them as FlatAtoms.  This is needed because atoms\n    // passed here could be unflatted (via groups) or much larger\n    // than what can fit in the given role/bar etc.  So this\n    // flattening and windowing is needed before we add them\n    // to the views - and this is done by the durationIterators.\n    this.windowIter.push(...atoms);\n    while (this.windowIter.hasMore) {\n      // get the last/current row and add a new one if it is full\n      let currBeat = this.beats[this.beats.length - 1];\n\n      // First add a row if last row is filled\n      if (this.beats.length == 0 || currBeat.filled) {\n        // what should be the beatlengths be here?\n        currBeat = this.addBeat();\n      }\n\n      // For this beat get symbols in all roles\n      const [remAtoms, filled] = this.windowIter.get(currBeat.remaining);\n      TSU.assert(remAtoms.length > 0, \"Atleast one element should have been available here\");\n      // render the atoms now\n      for (const atom of remAtoms) {\n        // console.log(\"Adding FA: \", flatAtom.debugValue(), flatAtom.atom);\n        TSU.assert(currBeat.add(atom), \"Should return true as we are already using a duration iterator here\");\n        if (this.onAtomAdded) this.onAtomAdded(atom, currBeat);\n      }\n      if (currBeat.filled) {\n        if (this.onBeatFilled) this.onBeatFilled(currBeat);\n      }\n    }\n  }\n\n  /**\n   * Adds a new beat to the sequence.\n   * @returns The newly created beat\n   */\n  protected addBeat(): Beat {\n    const numBeats = this.beats.length;\n    const lastBeat = numBeats == 0 ? null : this.beats[numBeats - 1];\n    const nextCP: [CyclePosition, Fraction] = this.cycleIter.next().value;\n    const apb = this.layoutParams.beatDuration;\n    const newBeat = new Beat(\n      lastBeat == null ? this.startIndex : lastBeat.index + 1,\n      this.role,\n      lastBeat == null ? this.startOffset.minus(this.beatOffset).timesNum(apb, true) : lastBeat.endOffset,\n      nextCP[1].timesNum(apb),\n      nextCP[0][0],\n      nextCP[0][1],\n      nextCP[0][2],\n      lastBeat,\n      null,\n    );\n    if (lastBeat == null && this.beatOffset.isGT(ZERO)) {\n      // Add spaces to fill up empty beats\n      newBeat.add(new Space(this.beatOffset.timesNum(apb)));\n    }\n    if (lastBeat) lastBeat.nextBeat = newBeat;\n    this.beats.push(newBeat);\n    if (this.onBeatAdded) this.onBeatAdded(newBeat);\n    return newBeat;\n  }\n}\n\n/**\n * Represents a column of beats in a layout grid.\n * Used for aligning beats vertically in the notation.\n */\nexport class BeatColumn extends ColAlign {\n  /** Spacing between atoms in this column */\n  atomSpacing = 5;\n  /** Unique key for this column */\n  readonly key: string;\n\n  /**\n   * Creates a new BeatColumn.\n   * @param offset The starting offset of this column\n   * @param endOffset The ending offset of this column\n   * @param markerType The type of marker for this column (negative: before, positive: after, zero: normal)\n   */\n  constructor(\n    public readonly offset: Fraction,\n    public readonly endOffset: Fraction,\n    public readonly markerType: number,\n  ) {\n    super();\n    offset = offset.factorized;\n    endOffset = endOffset.factorized;\n    this.key = BeatColumn.keyFor(offset, endOffset, markerType);\n  }\n\n  /**\n   * Generates a key for identifying columns with the same offsets and marker type.\n   * @param offset The starting offset\n   * @param endOffset The ending offset\n   * @param markerType The type of marker (negative: before, positive: after, zero: normal)\n   * @returns A string key\n   */\n  static keyFor(offset: Fraction, endOffset: Fraction, markerType = 0): string {\n    offset = offset.factorized;\n    endOffset = endOffset.factorized;\n    if (markerType < 0) {\n      // return the column for the marker \"before\" this col\n      // int his case only the \"start offset\" is needed and length doesnt matter\n      return \":\" + offset.toString();\n    } else if (markerType > 0) {\n      // return the column for the marker \"after\" this col\n      // in this case only thd end offset matters\n      return endOffset.toString() + \":\";\n    } else {\n      return offset.toString() + \":\" + endOffset.toString();\n    }\n  }\n}\n\n/**\n * Manages the organization of beats into columns based on their offsets.\n * Used to create a directed acyclic graph (DAG) of beat columns for layout purposes.\n *\n * Grouping of beats by their column based on the layout params.\n * The confusion is we have beats broken up and saved in columns\n * but we are loosing how a line is supposed to access it in its own way\n * we have beatsByRole for getting all beats for a role (in a line)\n * sequentially we have beatColumns for getting all beats in a particular\n * column across all lines and roles globally.\n *\n * What we want here is for a given line get all roles, their beats\n * in zipped way.  eg for a Line with 3 roles and say 10 beats each\n * (with the breaks of 4, 1) we need:\n *\n * R1 B1 R1 B2 R1 B3 R1 B4\n * R2 B1 R2 B2 R2 B3 R2 B4\n * R3 B1 R3 B2 R3 B3 R3 B4\n *\n * R1 B5\n * R2 B5\n * R3 B5\n *\n * R1 B6 R1 B7 R1 B8 R1 B9\n * R2 B6 R2 B7 R2 B8 R2 B9\n * R3 B6 R3 B7 R3 B8 R3 B9\n *\n * R1 B10\n * R2 B10\n * R3 B10\n *\n *\n * Here we have 5 distinct beat columns:\n *\n * 1: R1B1, R2B1, R3B1, R1B6, R2B6, R3B6,\n * 2: R1B2, R2B2, R3B2, R1B7, R2B7, R3B7,\n * 3: R1B3, R2B3, R3B3, R1B8, R2B8, R3B8,\n * 4: R1B4, R2B4, R3B4, R1B9, R2B9, R3B9,\n * 5: R1B5, R2B5, R3B5, R1B10, R2B10, R3B10,\n *\n */\nexport class BeatColDAG {\n  /** Map of column keys to BeatColumn objects */\n  beatColumns = new Map<string, BeatColumn>();\n\n  /**\n   * Creates a new BeatColDAG.\n   * @param layoutGroup The layout group to associate with this DAG\n   */\n  constructor(public readonly layoutGroup: GridLayoutGroup) {\n    //\n  }\n\n  /**\n   * Gets the beat column for a given duration at the specified offset.\n   * Creates a new column if none exists.\n   * @param offset The starting offset\n   * @param endOffset The ending offset\n   * @param markerType The type of marker\n   * @returns The BeatColumn for the specified parameters\n   */\n  getBeatColumn(offset: Fraction, endOffset: Fraction, markerType = 0): BeatColumn {\n    const [bcol, newcreated] = this.ensureBeatColumn(offset, endOffset, markerType);\n    if (newcreated) {\n      if (markerType == 0) {\n        const [prevcol] = this.ensureBeatColumn(offset, endOffset, -1);\n        const [nextcol] = this.ensureBeatColumn(offset, endOffset, 1);\n        prevcol.addSuccessor(bcol);\n        bcol.addSuccessor(nextcol);\n        for (const other of this.beatColumns.values()) {\n          // only join the \"marker\" columns\n          if (other.markerType == -1 && endOffset.equals(other.offset)) {\n            // our next col is a preecessor of other\n            nextcol.addSuccessor(other);\n          } else if (other.markerType == 1 && other.endOffset.equals(offset)) {\n            // our prev col is a predecessor of other\n            other.addSuccessor(prevcol);\n          }\n        }\n      }\n    }\n    return bcol;\n  }\n\n  /**\n   * Ensures a beat column exists for the given parameters.\n   * @param offset The starting offset\n   * @param endOffset The ending offset\n   * @param markerType The type of marker\n   * @returns A tuple containing the column and whether it was newly created\n   */\n  protected ensureBeatColumn(offset: Fraction, endOffset: Fraction, markerType = 0): [BeatColumn, boolean] {\n    const key = BeatColumn.keyFor(offset, endOffset, markerType);\n    let bcol = this.beatColumns.get(key) || null;\n    const newcreated = bcol == null;\n    if (!bcol) {\n      bcol = new BeatColumn(offset, endOffset, markerType);\n      this.beatColumns.set(key, bcol);\n    }\n    return [bcol, newcreated];\n  }\n}\n\n/** Type alias for line IDs */\ntype LineId = number;\n/** Type alias for layout parameter IDs */\ntype LPID = number;\n\n/**\n * Manages the beat layouts for all lines in a notation.\n * Handles the creation of grid models, positioning of beats, and alignment of beats across lines.\n */\nexport class GlobalBeatLayout {\n  /** Map of line IDs to grid models */\n  gridModelsForLine = new Map<LineId, GridModel>();\n  /** Map of line IDs to arrays of beats for each role */\n  roleBeatsForLine = new Map<LineId, Beat[][]>();\n  /** Map of layout parameter IDs to beat column DAGs */\n  beatColDAGsByLP = new Map<LPID, BeatColDAG>();\n  /** The global layout group for all grid models */\n  readonly gridLayoutGroup: GridLayoutGroup;\n\n  /**\n   * Creates a new GlobalBeatLayout.\n   * @param sharedGridLayoutGroup Optional shared GridLayoutGroup for column alignment across multiple views.\n   *                               If not provided, a new GridLayoutGroup is created internally.\n   */\n  constructor(sharedGridLayoutGroup?: GridLayoutGroup) {\n    this.gridLayoutGroup = sharedGridLayoutGroup ?? new GridLayoutGroup();\n  }\n\n  /**\n   * Gets the GridModel associated with a particular line, creating one if it doesn't exist.\n   * @param lineid The ID of the line\n   * @returns The GridModel for the line\n   */\n  getGridModelForLine(lineid: LineId): GridModel {\n    let out = this.gridModelsForLine.get(lineid) || null;\n    if (!out) {\n      out = new GridModel();\n      this.gridLayoutGroup.addGridModel(out);\n      this.gridModelsForLine.set(lineid, out);\n    }\n    return out;\n  }\n\n  /**\n   * Gets the BeatColDAG for a specific layout parameter ID, creating one if it doesn't exist.\n   * @param lpid The layout parameter ID\n   * @returns The BeatColDAG for the layout parameters\n   */\n  protected beatColDAGForLP(lpid: LPID): BeatColDAG {\n    let out = this.beatColDAGsByLP.get(lpid) || null;\n    if (!out) {\n      out = new BeatColDAG(this.gridLayoutGroup);\n      this.beatColDAGsByLP.set(lpid, out);\n    }\n    return out;\n  }\n\n  /**\n   * Adds a line to the beat layout.\n   * This ensures that a line is broken down into beats and added into a dedicated GridModel.\n   *\n   * A line must also be given the layout params by which the beat breakdown will happen.\n   * This LayoutParams object does not have to be unique per line (this non-constraint allows\n   * beats to be aligned across lines).\n   *\n   * @param line The line to add\n   */\n  addLine(line: Line): void {\n    const gridModel = this.getGridModelForLine(line.uuid) as GridModel;\n    gridModel.eventHub?.startBatchMode();\n    this.lineToRoleBeats(line, gridModel);\n    gridModel.eventHub?.commitBatch();\n  }\n\n  /**\n   * Recursively processes a block and its children to build beat layouts.\n   * Uses block.children() to get expanded children (e.g., RepeatBlock expands to N copies).\n   *\n   * @param block The block to process\n   */\n  processBlock(block: Block): void {\n    for (const child of block.children()) {\n      this.processBlockItem(child);\n    }\n  }\n\n  /**\n   * Processes a single block item (Block, Line, or RawBlock).\n   *\n   * @param item The item to process\n   */\n  protected processBlockItem(item: BlockItem): void {\n    if (isLine(item)) {\n      const line = item as Line;\n      if (!line.isEmpty && line.layoutParams != null) {\n        this.addLine(line);\n      }\n    } else if (isBlock(item)) {\n      this.processBlock(item as Block);\n    }\n    // RawBlocks are ignored (no beat layout for raw content)\n  }\n\n  /**\n   * Converts a line into a series of beats for each role.\n   * @param line The line to convert\n   * @param gridModel The grid model to use\n   * @returns Arrays of beats for each role\n   */\n  protected lineToRoleBeats(line: Line, gridModel: GridModel): Beat[][] {\n    const lp = line.layoutParams;\n    const roleBeats = [] as Beat[][];\n    this.roleBeatsForLine.set(line.uuid, roleBeats);\n    const lineOffset = line.offset.divbyNum(lp.beatDuration);\n    for (const role of line.roles) {\n      const bb = new BeatsBuilder(role, lp, lineOffset, ...role.atoms);\n      roleBeats.push(bb.beats);\n\n      // Add these to the beat layout too\n      for (const beat of bb.beats) {\n        // beat.ensureUniformSpaces(layoutParams.beatDuration);\n        this.addBeat(beat, gridModel);\n      }\n    }\n    return roleBeats;\n  }\n\n  /**\n   * Adds a beat to the layout.\n   * @param beat The beat to add\n   * @param gridModel The grid model to add the beat to\n   * @returns The grid cell containing the beat\n   */\n  protected addBeat(beat: Beat, gridModel: GridModel): GridCell {\n    // Get the beat column at this index (and line) and add to it.\n    const line = beat.role.line;\n    const lp = line.layoutParams;\n    const beatColDAG = this.beatColDAGForLP(lp.uuid);\n    const [layoutLine, layoutColumn, rowOffset] = lp.getBeatLocation(beat);\n    const colEnd = rowOffset.plus(beat.duration, true);\n    const bcol = beatColDAG.getBeatColumn(rowOffset, colEnd, 0);\n\n    // Since a beat's column has a \"pre\" and \"post\" col to, each\n    // beat has 3 columns for it\n    const roleIndex = beat.role.line.indexOfRole(beat.role.name);\n    const nthLine = Math.floor(beat.index / lp.totalBeats);\n    const realLine = lp.lineBreaks.length * nthLine + layoutLine;\n    const realRow = line.roles.length * realLine + roleIndex;\n    // pre marker goes on realCol - 1, post marker goes on realCol + 1\n    const realCol = 1 + layoutColumn * 3;\n    const preMarkers = beat.preMarkers;\n    if (preMarkers.length > 0) {\n      const val = {\n        beat: beat,\n        markers: preMarkers,\n      };\n      const precol = beatColDAG.getBeatColumn(rowOffset, colEnd, -1);\n      gridModel.setValue(realRow, realCol - 1, val, (gridRow: GridRow, col: number) => {\n        const cell = new GridCell(gridRow, col);\n        cell.colAlign = precol;\n        return cell;\n      });\n    }\n    const postMarkers = beat.postMarkers;\n    if (postMarkers.length > 0) {\n      const val = {\n        beat: beat,\n        markers: postMarkers,\n      };\n      const postcol = beatColDAG.getBeatColumn(rowOffset, colEnd, 1);\n      gridModel.setValue(realRow, realCol + 1, val, (gridRow: GridRow, col: number) => {\n        const cell = new GridCell(gridRow, col);\n        cell.colAlign = postcol;\n        return cell;\n      });\n    }\n    return gridModel.setValue(realRow, realCol, beat, (gridRow: GridRow, col: number) => {\n      const cell = new GridCell(gridRow, col);\n      cell.colAlign = bcol;\n      return cell;\n    });\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\n\ntype EdgeData = any;\ntype EdgeFunctor<T> = (node: T) => ReadonlyArray<[T, EdgeData]>;\ntype IDFunc<T> = (t: T) => number | string;\n\nexport function allMinimalCycles<T>(\n  nodes: ReadonlyArray<T>,\n  idFunc: IDFunc<T>,\n  edges: EdgeFunctor<T>,\n): ReadonlyArray<[T, EdgeData]> {\n  // Tells which cycle a node is assigned to if any\n  const cycles: [T, EdgeData][] = [];\n  const inACycle = {} as any;\n  nodes.forEach((node) => {\n    // start from node and do a BFS to see what cycle a node appears in\n    if (!(idFunc(node) in inACycle)) {\n      const startNode = node;\n      const visited = {} as any;\n      let queue: [T, [EdgeData, T][]][] = [[node, []]];\n      while (queue.length > 0) {\n        const newQueue: [T, [EdgeData, T][]][] = [];\n        for (let i = 0; i < queue.length; i++) {\n          const [node, c] = queue[i];\n          TSU.assert(node != null);\n          const e = edges(node);\n          let cycle = [...c];\n          for (const [nextNode, edgeData] of e) {\n            if (nextNode == startNode) {\n              // we have a cycle\n              cycle.push([edgeData, nextNode]);\n              cycle.forEach(([e, n], i) => (inACycle[n] = true));\n              cycles.push([startNode, cycle]);\n              cycle = cycle.slice(0, cycle.length - 1);\n            } else if (!(idFunc(nextNode) in visited)) {\n              visited[idFunc(nextNode)] = true;\n              newQueue.push([nextNode, [...cycle, [edgeData, nextNode]]]);\n            }\n          }\n        }\n        queue = newQueue;\n      }\n    }\n  });\n  return cycles;\n}\n\nexport function digraph(): void {\n  //\n}\n","export enum CharClassType {\n  WORD_CHAR,\n  DIGITS,\n  SPACES,\n}\n\nconst ZERO = \"0\".charCodeAt(0);\nconst NINE = \"9\".charCodeAt(0);\nconst lA = \"a\".charCodeAt(0);\nconst lZ = \"z\".charCodeAt(0);\nconst uA = \"A\".charCodeAt(0);\nconst uZ = \"Z\".charCodeAt(0);\nconst USCORE = \"_\".charCodeAt(0);\n\n/**\n * An abstract class to be implemented for enabling different types of char classes.\n * Char classes are a form of \"short codes\" to identify characters.  eg SPACES, DIGITS etc.\n * Char classes are only shortcuts.  One can get away without using them and instead explicitly\n * construct the underlying state machine or regex (eg DIGIT could be replaced with [0-9]).\n */\nexport abstract class CharClassHelper {\n  matches(charCode: number, neg: boolean): boolean {\n    const res = this.match(charCode);\n    return neg ? !res : res;\n  }\n  protected abstract match(charCode: number): boolean;\n  abstract reString(neg: boolean): string;\n}\n\nconst spaceChars = \" \\f\\n\\r\\t\\v\\u00a0\\u1680\\u2028\\u2029\\u202f\\u205f\\u3000\\ufeff\";\n\n/**\n * Spaces - \\s => [ \\b\\c\\u00a0\\t\\r\\n\\u2028\\u2029<BOM><USP>]\n * BOM = \\uFEFF\n * USP = Other unicode space separator\n */\nexport class Spaces extends CharClassHelper {\n  match(charCode: number): boolean {\n    // if (charCode == 0x180e) return true;\n    if (charCode >= 0x2000 && charCode <= 0x200a) return true;\n    for (let i = 0; i < spaceChars.length; i++) {\n      if (spaceChars.charCodeAt(i) == charCode) return true;\n    }\n    return false;\n  }\n\n  reString(neg: boolean): string {\n    return neg ? \"\\\\S\" : \"\\\\s\";\n  }\n}\n\n/**\n * Char class for denoting a digit - [0-9].\n */\nexport class Digit extends CharClassHelper {\n  match(charCode: number): boolean {\n    return charCode >= ZERO && charCode <= NINE;\n  }\n\n  reString(neg: boolean): string {\n    return neg ? \"\\\\D\" : \"\\\\d\";\n  }\n}\n\n/**\n * Char class for denoting \"\\\\w\" - ie any WordChar\n */\nexport class WordChar extends CharClassHelper {\n  match(charCode: number): boolean {\n    return (\n      charCode == USCORE ||\n      (charCode >= ZERO && charCode <= NINE) ||\n      (charCode >= lA && charCode <= lZ) ||\n      (charCode >= uA && charCode <= uZ)\n    );\n    return true;\n  }\n\n  reString(neg: boolean): string {\n    return neg ? \"\\\\W\" : \"\\\\w\";\n  }\n}\n\nexport const CharClassHelpers: ReadonlyArray<CharClassHelper> = [new WordChar(), new Digit(), new Spaces()];\n","import * as TSU from \"@panyam/tsutils\";\nimport { Grammar, Sym, Str, Rule } from \"./grammar\";\n\ntype NumMap<T> = TSU.NumMap<T>;\ntype StringMap<T> = TSU.StringMap<T>;\ntype Nullable<T> = TSU.Nullable<T>;\n\nconst defaultKeyFunc = (x: any) => x.key;\n\nexport class Trie<T> {\n  protected keyFunc: (t: T) => string;\n  readonly root: TrieNode<T> = new TrieNode();\n\n  constructor(keyFunc: (t: T) => string) {\n    this.keyFunc = keyFunc;\n  }\n\n  add(values: T[], fromIndex = 0): TrieNode<T> {\n    // we are at the bottom\n    let curr = this.root;\n    for (let i = fromIndex; i < values.length; i++) {\n      const key = this.keyFunc(values[i]);\n      if (curr.children.has(key)) {\n        curr = curr.children.get(key)!;\n      } else {\n        const newNode = new TrieNode<T>();\n        newNode.value = values[i];\n        newNode.parent = curr;\n        curr.children.set(key, newNode);\n        curr = newNode;\n      }\n    }\n    curr.isLeaf = true;\n    return curr;\n  }\n\n  get debugValue(): any {\n    return this.root.debugValue;\n  }\n}\n\nexport class TrieNode<T> {\n  isLeaf = false;\n  value: Nullable<T> = null;\n  parent: Nullable<TrieNode<T>> = null;\n  children = new Map<string, TrieNode<T>>();\n\n  get debugValue(): any {\n    const out = { value: this.value, children: {} as any } as any;\n    if (this.isLeaf) out[\"isLeaf\"] = true;\n    for (const [key, value] of this.children.entries()) {\n      out.children[key] = value.debugValue;\n    }\n    return out;\n  }\n}\n\nexport class IDSet<T extends { id: number }> {\n  protected _entries: T[] = [];\n  protected _entriesByKey: StringMap<T> = {};\n  protected keyFunc: (t: T) => string;\n\n  constructor(keyFunc: (t: T) => string = defaultKeyFunc) {\n    this.keyFunc = keyFunc;\n  }\n\n  clear(): void {\n    this._entries = [];\n    this._entriesByKey = {};\n  }\n\n  /**\n   * Removes all entries that match a predict.\n   */\n  remove(predicate: (t: T) => boolean): boolean {\n    const e2: T[] = [];\n    this._entriesByKey = {};\n    let modified = false;\n    for (let l = 0; l < this._entries.length; l++) {\n      const e = this._entries[l];\n      if (!predicate(e)) {\n        // keep it if predicate failes\n        e.id = e2.length;\n        e2.push(e);\n        this._entriesByKey[this.keyFunc(e)] = e;\n      } else {\n        modified = true;\n      }\n    }\n    this._entries = e2;\n    return modified;\n  }\n\n  get entries(): ReadonlyArray<T> {\n    return this._entries;\n  }\n\n  get(id: number): T {\n    TSU.assert(id >= 0 && id < this._entries.length);\n    return this._entries[id];\n  }\n\n  getByKey(key: string): Nullable<T> {\n    return this._entriesByKey[key] || null;\n  }\n\n  ensure(entry: T, throwIfExists = false): T {\n    // see if this itemset exists\n    if (this.has(entry)) {\n      if (throwIfExists) throw new Error(`Entry ${this.keyFunc(entry)} already exists`);\n      return this._entriesByKey[this.keyFunc(entry)];\n    } else {\n      this._entriesByKey[this.keyFunc(entry)] = entry;\n      entry.id = this._entries.length;\n      this._entries.push(entry);\n      return entry;\n    }\n  }\n\n  has(entry: T): boolean {\n    return this.keyFunc(entry) in this._entriesByKey;\n  }\n\n  get size(): number {\n    return this._entries.length;\n  }\n}\n\nexport class SymbolSet {\n  readonly grammar: Grammar;\n  readonly enforceSymbolType: Nullable<boolean>;\n  entries = new Set<number>();\n  hasNull = false;\n\n  constructor(grammar: Grammar, enforceSymbolType: Nullable<boolean> = true) {\n    this.grammar = grammar;\n    this.enforceSymbolType = enforceSymbolType;\n  }\n\n  get debugString(): string {\n    return \"<\" + this.labels().sort().join(\", \") + \">\";\n  }\n\n  labels(skipAux = false): string[] {\n    const out: string[] = [];\n    for (const i of this.entries) {\n      const exp = this.grammar.getSymById(i);\n      TSU.assert(exp != null);\n      if (!skipAux || !exp.isAuxiliary) out.push(exp.label);\n    }\n    if (this.hasNull) out.push(\"\");\n    return out;\n  }\n\n  addFrom(another: SymbolSet, includeNull = true): number {\n    return another.addTo(this, includeNull);\n  }\n\n  addTo(another: SymbolSet, includeNull = true): number {\n    const before = another.entries.size;\n    for (const termid of this.entries) {\n      another.entries.add(termid);\n    }\n    if (includeNull) {\n      another.hasNull = this.hasNull || another.hasNull;\n    }\n    return another.entries.size - before;\n  }\n\n  has(term: Sym): boolean {\n    return this.entries.has(term.id);\n  }\n\n  add(term: Sym): this {\n    TSU.assert(\n      this.enforceSymbolType == null || this.enforceSymbolType == term.isTerminal,\n      `Terminal types being enforced: ${this.enforceSymbolType}`,\n    );\n    this.entries.add(term.id);\n    return this;\n  }\n\n  delete(term: Sym): boolean {\n    return this.entries.delete(term.id);\n  }\n\n  get size(): number {\n    return this.entries.size + (this.hasNull ? 1 : 0);\n  }\n}\n\n/**\n * Tells which non terminals are nullables.\n */\nexport class NullableSet {\n  readonly grammar: Grammar;\n  entries: Set<number>;\n  private visited: any;\n\n  constructor(grammar: Grammar) {\n    this.grammar = grammar;\n    this.refresh();\n  }\n\n  get nonterms(): Sym[] {\n    const out: Sym[] = [];\n    this.entries.forEach((id) => {\n      const e = this.grammar.getSymById(id);\n      TSU.assert(e != null && !e.isTerminal);\n      out.push(e);\n    });\n    return out;\n  }\n\n  refresh(): void {\n    // Nuke entries cache.  Will force isNullable to recompute.\n    this.entries = new Set();\n    this.visited = {};\n\n    let beforeCount = 0;\n    do {\n      beforeCount = this.entries.size;\n      this.grammar.allNonTerminals.forEach((nt) => this.visit(nt));\n    } while (beforeCount != this.entries.size);\n  }\n\n  protected visit(nt: Sym): void {\n    for (const rule of this.grammar.rulesForNT(nt)) {\n      if (this.isStrNullable(rule.rhs)) {\n        this.add(nt);\n        break;\n      }\n    }\n  }\n\n  isNullable(nt: Sym): boolean {\n    return !nt.isTerminal && this.entries.has(nt.id);\n  }\n\n  isStrNullable(str: Str, fromIndex = 0, toIndex: Nullable<number> = null): boolean {\n    if (toIndex == null) {\n      toIndex = str.length - 1;\n    }\n    for (let i = fromIndex; i <= toIndex; i++) {\n      if (!this.isNullable(str.syms[i])) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  add(nt: Sym): void {\n    TSU.assert(!nt.isTerminal);\n    this.entries.add(nt.id);\n  }\n}\n\nclass SymSymbolSets {\n  readonly grammar: Grammar;\n  entries: NumMap<SymbolSet> = {};\n  private _count = 0;\n\n  constructor(grammar: Grammar) {\n    this.grammar = grammar;\n  }\n\n  refresh(): void {\n    this.entries = {};\n    this._count = 0;\n  }\n\n  forEachTerm(nt: Sym, visitor: (x: Nullable<Sym>) => boolean | void): void {\n    const entries = this.entriesFor(nt);\n    entries.entries.forEach((x) => {\n      const term = this.grammar.getSymById(x);\n      TSU.assert(term != null && term.isTerminal);\n      visitor(term);\n    });\n    if (entries.hasNull) visitor(null);\n  }\n\n  get debugValue(): any {\n    const out = {} as any;\n    for (const x in this.entries) out[this.grammar.getSymById(x as any)!.label] = this.entries[x].debugString;\n    return out;\n  }\n\n  get count(): number {\n    let c = 0;\n    for (const x in this.entries) c += this.entries[x].size;\n    return c;\n    // TSU.assert(c == this._count, \"Count mismatch\")\n    // return this._count;\n  }\n\n  entriesFor(sym: Sym): SymbolSet {\n    if (sym.id in this.entries) {\n      return this.entries[sym.id];\n    } else {\n      const out = new SymbolSet(this.grammar);\n      this.entries[sym.id] = out;\n      return out;\n    }\n  }\n\n  /**\n   * Add the null symbol into this set of terminals for a given expression.\n   */\n  addNull(nt: Sym): boolean {\n    const entries = this.entriesFor(nt);\n    if (entries.hasNull) return false;\n    entries.hasNull = true;\n    return true;\n  }\n\n  /**\n   * Add a Null, term or another expression to the set of terminals\n   * for a given expression.  If source is an expression then all\n   * of the source expression's terminal symbosl are added to exp's\n   * term set.\n   */\n  add(nt: Sym, source: Sym, includeNull = true): boolean {\n    if (nt.isTerminal) {\n      TSU.assert(false, \"Should not be here\");\n    }\n    const entries = this.entriesFor(nt);\n    if (source.isTerminal) {\n      if (entries.has(source)) return false;\n      // console.log(`Adding Term(${term.label}) to Set of ${exp.id}`);\n      entries.add(source);\n      this._count++;\n    } else {\n      const srcEntries = this.entriesFor(source);\n      const destEntries = this.entriesFor(nt);\n      const count = srcEntries.addTo(destEntries, includeNull);\n      this._count += count;\n    }\n    return true;\n  }\n}\n\n/**\n * For each symbol maps its label to a list of terminals that\n * start that non terminal.\n */\nexport class FirstSets extends SymSymbolSets {\n  readonly nullables: NullableSet;\n\n  constructor(grammar: Grammar, nullables?: NullableSet) {\n    super(grammar);\n    if (!nullables) {\n      nullables = new NullableSet(grammar);\n    }\n    this.nullables = nullables;\n    this.refresh();\n  }\n\n  /**\n   * For a given string return the first(str) starting at a given index.\n   * Including eps if it exists.\n   */\n  forEachTermIn(str: Str, fromIndex = 0, visitor: (term: Nullable<Sym>) => void): void {\n    // This needs to be memoized by exp.id + index\n    const syms = str.syms;\n    const visited = {} as any;\n    let allNullable = true;\n    for (let j = fromIndex; allNullable && j < syms.length; j++) {\n      const symj = syms[j];\n      if (symj.isTerminal) {\n        visitor(symj);\n        allNullable = false;\n      } else {\n        const nt = symj as Sym;\n        this.forEachTerm(nt, (term) => {\n          if (term != null && !(term.id in visited)) {\n            visited[term.id] = true;\n            visitor(term);\n          }\n        });\n        if (!this.nullables.isNullable(symj as Sym)) {\n          allNullable = false;\n        }\n      }\n    }\n    if (allNullable) visitor(null);\n  }\n\n  /**\n   * Reevaluates the first sets of a grammar.\n   * This method assumes that the grammar's nullables are fresh.\n   */\n  refresh(): void {\n    super.refresh();\n    // this.grammar.terminals.forEach((t) => this.add(t, t));\n\n    let beforeCount = 0;\n    do {\n      beforeCount = this.count;\n      this.grammar.forEachRule(null, (rule) => {\n        this.processRule(rule);\n      });\n    } while (beforeCount != this.count);\n  }\n\n  processRule(rule: Rule): void {\n    const nullables = this.nullables;\n    let allNullable = true;\n    for (const s of rule.rhs.syms) {\n      // First(s) - null will be in First(nonterm)\n      // Null will onlybe added if all symbols are nullable\n      this.add(rule.nt, s, false);\n      if (s.isTerminal || !nullables.isNullable(s as Sym)) {\n        // since s is not nullable the next rule's first set\n        // cannot affect nonterm's firs set\n        allNullable = false;\n        break;\n      }\n    }\n    if (allNullable) this.addNull(rule.nt);\n  }\n}\n\n/**\n * For each symbol maps its label to a list of terminals that\n * start that non terminal.\n */\nexport class FollowSets extends SymSymbolSets {\n  readonly firstSets: FirstSets;\n\n  constructor(grammar: Grammar, firstSets?: FirstSets) {\n    super(grammar);\n    this.firstSets = firstSets || new FirstSets(grammar);\n    this.refresh();\n  }\n\n  get nullables(): NullableSet {\n    return this.firstSets.nullables;\n  }\n\n  /**\n   * Reevaluates the follow sets of each expression in our grammar.\n   * This method assumes that the grammar's nullables and firstSets are\n   * up-to-date.\n   */\n  refresh(): void {\n    super.refresh();\n    const g = this.grammar;\n    TSU.assert(g.startSymbol != null, \"Select start symbol of the grammar\");\n    this.add(g.startSymbol, g.Eof);\n\n    let beforeCount = 0;\n    do {\n      beforeCount = this.count;\n      this.grammar.forEachRule(null, (rule) => this.processRule(rule));\n    } while (beforeCount != this.count);\n  }\n\n  /**\n   * Add Follows[source] into Follows[dest] recursively.\n   */\n  processRule(rule: Rule): void {\n    const syms = rule.rhs.syms;\n    const firstSets = this.firstSets;\n    const nullables = this.firstSets.nullables;\n\n    // Rule 1:\n    //  If A -> aBb1b2b3..bn:\n    //    Follow(B) = Follow(B) U { First(b1b2b3...bn) - eps }\n    for (let i = 0; i < syms.length; i++) {\n      const sym = syms[i];\n      if (sym.isTerminal) continue;\n      firstSets.forEachTermIn(rule.rhs, i + 1, (term) => {\n        if (term != null) this.add(sym, term);\n      });\n    }\n\n    // Rule 2:\n    //  If A -> aBb1b2b3..bn:\n    //    if Nullable(b1b2b3...bn):\n    //      Follow(B) = Follow(B) U Follow(N)\n    for (let i = syms.length - 1; i >= 0; i--) {\n      if (syms[i].isTerminal) continue;\n\n      // This needs to be memoized??\n      let allNullable = true;\n      for (let j = i + 1; j < syms.length; j++) {\n        const symj = syms[j];\n        if (symj.isTerminal || !nullables.isNullable(symj as Sym)) {\n          allNullable = false;\n          break;\n        }\n      }\n      if (allNullable) {\n        this.add(syms[i], rule.nt);\n      }\n    }\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { allMinimalCycles } from \"./graph\";\nimport { IDSet, SymbolSet, FirstSets, FollowSets, NullableSet } from \"./sets\";\n\ntype StringMap<T> = TSU.StringMap<T>;\ntype Nullable<T> = TSU.Nullable<T>;\n\n/**\n * Symbols represent both terminals and non-terminals in our system.\n * Chosing a convention of using a single class to represent both instead\n * of a base class with Term and NonTerm children has the following effects:\n * 1. We can change the type of a literal when doing things like reading\n *    a grammar DSL when we dont konw if a symbol is a term or non-term\n *    until *all* the declarations have been read and parsed.\n * 2. The down side of this we would need more explicit isTerm checks\n *    but we would have done that anyway by calling getTerm and getNT\n *    verions of the getSym method.\n */\nexport class Sym {\n  isAuxiliary = false;\n  auxType: string | null = null;\n  precedence = 1;\n  assocLeft = true;\n\n  private static idCounter = -1;\n\n  /**\n   * An ID assigned to indicate order of \"creation\" of this symbol in the grammar.\n   */\n  creationId = -1;\n\n  /**\n   * ID unique across all expression within the grammar.\n   */\n  id: number;\n\n  /**\n   * Creates a new symbol in the grammar.\n   *\n   * @param   grammar     Grammar this symbol belongs to.\n   * @param   label       Label for the symbol.\n   * @param   isTerminal  Whether the symbol is a terminal or not.\n   * @param   id          ID unique across all expression within the\n   *                      grammar.\n   */\n  constructor(\n    public readonly grammar: Grammar,\n    public readonly label: string,\n    public isTerminal: boolean,\n    id: Nullable<number> = null,\n  ) {\n    this.isTerminal = isTerminal;\n    this.label = label;\n    if (id == null) {\n      this.id = Sym.idCounter--;\n    } else {\n      this.id = id;\n    }\n  }\n\n  compareTo(another: this): number {\n    return this.label.localeCompare(another.label);\n  }\n\n  equals(another: this): boolean {\n    return this.label == another.label;\n  }\n\n  toString(): string {\n    return this.label;\n  }\n}\n\nexport class Str {\n  syms: Sym[];\n\n  constructor(...syms: Sym[]) {\n    this.syms = syms || [];\n  }\n\n  append(...lits: Sym[]): this {\n    for (const l of lits) this.syms.push(l);\n    return this;\n  }\n\n  extend(...strs: Str[]): this {\n    for (const s of strs) this.append(...s.syms);\n    return this;\n  }\n\n  copy(): Str {\n    return new Str(...this.syms);\n  }\n\n  add(lit: Sym): void {\n    this.syms.push(lit);\n  }\n\n  isTerminal(index: number): boolean {\n    return this.syms[index].isTerminal;\n  }\n\n  get length(): number {\n    return this.syms.length;\n  }\n\n  toString(): string {\n    return this.syms.map((s) => s.toString()).join(\" \");\n  }\n\n  slice(startIndex: number, endIndex: number): Str {\n    return new Str(...this.syms.slice(startIndex, endIndex));\n  }\n\n  splice(index: number, numToDelete: number, ...itemsToAdd: Sym[]): Str {\n    this.syms.splice(index, numToDelete, ...itemsToAdd);\n    return this;\n  }\n\n  compareTo(another: this): number {\n    for (let i = 0; i < this.syms.length && i < another.syms.length; i++) {\n      const diff = this.syms[i].compareTo(another.syms[i]);\n      if (diff != 0) return diff;\n    }\n    return this.syms.length - another.syms.length;\n  }\n\n  equals(another: this): boolean {\n    return this.compareTo(another) == 0;\n  }\n\n  /**\n   * Returns true if another string is a substring within\n   * this string at the given offset.\n   */\n  containsAt(offset: number, another: Str): boolean {\n    let i = 0;\n    for (; i < another.length && offset + i < this.syms.length; i++) {\n      if (!this.syms[offset + i].equals(another.syms[i])) return false;\n      // if (this.cardinalities[i] != another.cardinalities[i]) return false;\n    }\n    return i == another.length;\n  }\n\n  get debugString(): string {\n    return this.syms.map((lit) => lit.label).join(\" \");\n  }\n}\n\nexport class RuleAction {\n  constructor(public value: string | number) {}\n\n  get isFunction(): boolean {\n    return typeof this.value === \"string\";\n  }\n\n  get isChildPosition(): boolean {\n    return typeof this.value === \"number\";\n  }\n}\n\nexport class Rule {\n  id: number;\n  constructor(public nt: Sym, public rhs: Str, public action: RuleAction | null = null) {\n    if (nt.isTerminal) {\n      throw new Error(\"Cannot add rules to a terminal\");\n    }\n  }\n\n  get debugString(): string {\n    return `${this.nt.label} -> ${this.rhs.debugString}`;\n  }\n\n  equals(another: this): boolean {\n    return this.compareTo(another) == 0;\n  }\n\n  compareTo(another: this): number {\n    TSU.assert(!isNaN(this.id));\n    const diff = this.nt.compareTo(another.nt);\n    if (diff == 0) {\n      this.rhs.compareTo(another.rhs);\n    }\n    return diff;\n  }\n}\n\nexport class Grammar {\n  public startSymbol: Nullable<Sym> = null;\n  modified = true;\n  protected symbolSet = new IDSet<Sym>((s) => s.label);\n  protected allRules: Rule[] = [];\n  protected _rulesForNT: Nullable<StringMap<Rule[]>> = null;\n  protected _followSets: Nullable<FollowSets> = null;\n\n  /**\n   * Prefix used for auxiliary symbols.\n   */\n  auxNTPrefix: string;\n\n  readonly Null: Sym;\n  readonly Eof: Sym;\n  private _AugStartRule: Rule;\n  private _hasNull = false;\n\n  /**\n   * A way of creating Grammars with a \"single expresssion\".\n   */\n  static make(callback: (g: Grammar) => void): Grammar {\n    const g = new Grammar();\n    callback(g);\n    return g;\n  }\n\n  constructor(config?: any) {\n    config = config || {};\n    this.auxNTPrefix = config.auxNTPrefix || \"$\";\n    this.Null = this.newTerm(\"\");\n    this.Eof = this.newTerm(\"$end\");\n  }\n\n  rulesForNT(nt: Sym): Rule[] {\n    TSU.assert(!nt.isTerminal);\n    if (this._rulesForNT == null) {\n      this._rulesForNT = {};\n      for (const rule of this.allRules) {\n        if (!(rule.nt.label in this._rulesForNT)) {\n          this._rulesForNT[rule.nt.label] = [];\n        }\n        this._rulesForNT[rule.nt.label].push(rule);\n      }\n    }\n    if (!(nt.label in this._rulesForNT)) {\n      this._rulesForNT[nt.label] = [];\n    }\n    return this._rulesForNT[nt.label];\n  }\n\n  get nullables(): NullableSet {\n    return this.firstSets.nullables;\n  }\n\n  get firstSets(): FirstSets {\n    return this.followSets.firstSets;\n  }\n\n  get followSets(): FollowSets {\n    if (this.modified || this._followSets == null) {\n      this.refresh();\n    }\n    TSU.assert(this._followSets != null);\n    return this._followSets;\n  }\n\n  get augStartRule(): Rule {\n    return this._AugStartRule;\n  }\n\n  augmentStartSymbol(label = \"$accept\"): this {\n    TSU.assert(this._AugStartRule == null, \"Ensure this grammar has not yet been augmented.\");\n    TSU.assert(this.startSymbol != null, \"Start symbol not yet set\");\n    const augSym = this.newNT(label);\n    this._AugStartRule = new Rule(augSym, new Str(this.startSymbol));\n    this.addRule(this._AugStartRule, 0);\n    return this;\n  }\n\n  refresh(): this {\n    this.symbolSet.entries.forEach((s, i) => (s.id = i));\n    this._rulesForNT = null;\n    this.allRules.forEach((rule, i) => {\n      rule.id = i;\n    });\n    this._followSets = new FollowSets(this);\n    this.modified = false;\n    return this;\n  }\n\n  addTerminals(...terminals: string[]): void {\n    for (const t of terminals) {\n      this.newTerm(t);\n    }\n  }\n\n  get terminals(): ReadonlyArray<Sym> {\n    return this.symbolSet.entries.filter((x) => x.isTerminal);\n  }\n\n  get allNonTerminals(): ReadonlyArray<Sym> {\n    return this.symbolSet.entries.filter((x) => !x.isTerminal);\n  }\n\n  get nonTerminals(): ReadonlyArray<Sym> {\n    return this.symbolSet.entries.filter((x) => !x.isTerminal && !x.isAuxiliary);\n  }\n\n  get auxNonTerminals(): ReadonlyArray<Sym> {\n    return this.symbolSet.entries.filter((x) => x.isAuxiliary);\n  }\n\n  get allSymbols(): ReadonlyArray<Sym> {\n    return this.symbolSet.entries;\n  }\n\n  /**\n   * A way to quickly iterate through all non-terminals.\n   */\n  forEachNT(visitor: (nt: Sym) => void | boolean | undefined | null): void {\n    for (const sym of this.symbolSet.entries) {\n      if (sym.isTerminal) continue;\n      if (visitor(sym) == false) return;\n    }\n  }\n\n  /**\n   * A iterator across all the rules for either all non terminals in this grammar\n   * for a single non terminal (if the nt value is non null).\n   *\n   * @param visitor\n   */\n  forEachRule(nt: Nullable<Sym>, visitor: (rule: Rule, index: number) => void | boolean | undefined | null): boolean {\n    const rules = nt == null ? this.allRules : this.rulesForNT(nt) || [];\n    for (let i = 0; i < rules.length; i++) {\n      if (visitor(rules[i], i) == false) return false;\n    }\n    return true;\n  }\n\n  getRule(nt: string | Sym, index: number): Rule {\n    if (typeof nt === \"string\") nt = this.getSym(nt)!;\n    TSU.assert(nt != null);\n    return this.rulesForNT(nt)[index];\n  }\n\n  /**\n   * Return the the index of a rule if it already exists to prevent duplicates.\n   */\n  findRule(nt: Sym, production: Str): number {\n    return this.rulesForNT(nt).findIndex((r) => r.nt == nt && r.rhs.equals(production));\n  }\n\n  /**\n   * Adds a new rule to a particular non terminal of the grammar\n   * Each rule represents a production of the form:\n   *\n   * name -> A B C D;\n   *\n   * Null production can be represented with an empty exps list.\n   */\n  add(nt: string | Sym, production: Str, action: RuleAction | null = null): Rule {\n    let nonterm: Nullable<Sym> = null;\n    if (typeof nt === \"string\") {\n      nonterm = this.getSym(nt);\n      if (nonterm == null) {\n        // create it\n        nonterm = this.newNT(nt);\n      }\n    } else {\n      nonterm = this.ensureSym(nt);\n    }\n    return this.addRule(new Rule(nonterm, production, action));\n  }\n\n  /**\n   * Add a rule directly.\n   */\n  addRule(rule: Rule, index = -1): Rule {\n    if (this.findRule(rule.nt, rule.rhs) >= 0) {\n      throw new Error(\"Duplicate rule: \" + rule.debugString);\n    }\n    rule.id = this.allRules.length;\n    if (rule.rhs.length == 0) this._hasNull = true;\n    if (index < 0) {\n      this.allRules.push(rule);\n    } else {\n      this.allRules.splice(index, 0, rule);\n    }\n    this._rulesForNT = null;\n    // this.rulesForNT(rule.nt).push(rule);\n    this.modified = true;\n    return rule;\n  }\n\n  /**\n   * Removes all rules from the grammar which match the given predicate.\n   */\n  removeRules(pred: (r: Rule) => boolean): boolean {\n    this.allRules = this.allRules.filter((r) => !pred(r));\n    this._rulesForNT = null;\n    this.modified = true;\n    return true;\n  }\n\n  /**\n   * Removes all symbols from the grammar and all of its productions which match\n   * a particular predicate.\n   */\n  removeSymbols(pred: (s: Sym) => boolean): boolean {\n    let modified = false;\n    const newRules: Rule[] = [];\n    this.allRules.forEach((r) => {\n      if (pred(r.nt)) return;\n      // if it was already a null production then leave it\n      if (r.rhs.length == 0) {\n        newRules.push(r);\n      } else {\n        const newRhs = new Str(...r.rhs.syms.filter((s) => !pred(s)));\n        modified = modified || r.rhs.length != newRhs.length;\n        if (newRhs.length > 0) {\n          newRules.push(new Rule(r.nt, newRhs));\n        }\n      }\n    });\n    this.allRules = newRules;\n    modified = this.symbolSet.remove(pred) || modified;\n    this.modified = this.modified || modified;\n    return modified;\n  }\n\n  /**\n   * Gets or creates a terminal with the given label.\n   * The grammar acts as a factory for terminal symbols\n   * so that we can reuse symbols instead of having\n   * users create new symbols each time.\n   *\n   * This also ensures that users are not able mix terminal\n   * and non terminal labels.\n   */\n  getSymById(id: number): Nullable<Sym> {\n    // if (id == Grammar.AUG_SYM_ID) return this._AugStartRule?.nt || null;\n    // else if (id == this.Eof.id) return this.Eof;\n    // else if (id == this.Null.id) return this.Null;\n    return this.symbolSet.get(id);\n  }\n\n  getSym(label: string): Nullable<Sym> {\n    // if (this._AugStartRule && label == this._AugStartRule.nt.label) return this._AugStartRule.nt;\n    return this.symbolSet.getByKey(label);\n  }\n\n  ensureSym(sym: Sym, throwIfExists = false): Sym {\n    const sym2 = this.symbolSet.ensure(sym, throwIfExists);\n    if (sym == sym2) {\n      if (sym2.creationId < 0) {\n        sym2.creationId = this.symbolSet.size;\n      }\n    } else {\n      TSU.assert(!throwIfExists, \"Should have already thrown error\");\n    }\n    return sym2;\n  }\n\n  /**\n   * Ensures that a terminal by a given name exists (creating if\n   * necessary).  If a terminal already exists by this label then\n   * an error is thrown.\n   *\n   * The grammar acts as a factory for terminal and non terminal symbols\n   * so that we can reuse symbols instead of having users create new\n   * symbols each time.  This also ensures that users are not able mix\n   * terminal and non terminal labels.\n   */\n  T(label: string, throwIfExists = false): Sym {\n    let t = this.getSym(label);\n    if (t != null) {\n      if (throwIfExists) throw new Error(`Terminal ${label} is already exists`);\n      if (!t.isTerminal) throw new Error(`Symbol (${label}) already exists as a non-terminal`);\n    } else {\n      t = new Sym(this, label, true);\n      t = this.ensureSym(t, true);\n    }\n    return t;\n  }\n\n  /**\n   * Ensures that a non term by a given name exists (creating if\n   * necessary).  If a terminal already exists by this label then\n   * an error is thrown.\n   *\n   * The grammar acts as a factory for terminal and non terminal symbols\n   * so that we can reuse symbols instead of having users create new\n   * symbols each time.  This also ensures that users are not able mix\n   * terminal and non terminal labels.\n   */\n  NT(label: string, isAuxiliary = false, throwIfExists = false): Sym {\n    let nt = this.getSym(label);\n    if (nt != null) {\n      if (throwIfExists) throw new Error(`Non-terminal ${label} is already exists`);\n      if (nt.isTerminal) throw new Error(`Symbol (${label}) already exists as a terminal`);\n    } else {\n      nt = new Sym(this, label, false);\n      nt.isAuxiliary = isAuxiliary;\n      nt = this.ensureSym(nt, true);\n      if (!isAuxiliary && this.startSymbol == null) {\n        this.startSymbol = nt;\n      }\n    }\n    return nt;\n  }\n\n  /**\n   * Creates a terminal with the given label if one does not\n   * already exist.\n   */\n  newTerm(label: string): Sym {\n    return this.T(label, true);\n  }\n\n  /**\n   * Creates a non terminal with the given label if it does not\n   * already exist.\n   */\n  newNT(label: string, isAuxiliary = false): Sym {\n    return this.NT(label, isAuxiliary, true);\n  }\n\n  /**\n   * Checks if a given label is a terminal.\n   */\n  isTerminal(label: string): boolean {\n    const t = this.getSym(label);\n    return t != null && t.isTerminal;\n  }\n\n  /**\n   * Checks if a given label is a non-terminal.\n   */\n  isNT(label: string): boolean {\n    const t = this.getSym(label);\n    return t != null && !t.isTerminal && !t.isAuxiliary;\n  }\n\n  /**\n   * Checks if a given label is an auxiliary non-terminal.\n   */\n  isAuxNT(label: string): boolean {\n    const t = this.getSym(label);\n    return t != null && !t.isTerminal && t.isAuxiliary;\n  }\n\n  seq(...exps: (Str | string)[]): Str {\n    if (exps.length == 1) {\n      return this.normalizeRule(exps[0]);\n    } else {\n      const out = new Str();\n      for (const e of exps) {\n        const s = this.normalizeRule(e);\n        // insert string here inline\n        // A ( B C D ) => A B C D\n        for (let i = 0; i < s.length; i++) {\n          // out.add(s.syms[i], s.cardinalities[i]);\n          out.add(s.syms[i]);\n        }\n      }\n      return out;\n    }\n  }\n\n  /**\n   * Provides a union rule:\n   *\n   * (A | B | C | D)\n   *\n   * Each of A, B, C or D themselves could be strings or literals.\n   */\n  anyof(...rules: (Str | string)[]): Str {\n    if (rules.length == 1) {\n      return this.normalizeRule(rules[0]);\n    } else {\n      // see if there is already NT with the exact set of rules\n      // reuse if it exists.  That would make this method\n      // Idempotent (which it needs to be).\n      return new Str(this.ensureAuxNT(...rules.map((r) => this.normalizeRule(r))));\n    }\n  }\n\n  opt(exp: Str | string): Str {\n    // convert to aux rule\n    const out = this.anyof(exp, new Str());\n    const nt = out.syms[0];\n    TSU.assert(out.syms.length == 1 && nt.isAuxiliary, \"NT must be an auxiliary symbol\");\n    nt.auxType = \"opt\";\n    return out;\n  }\n\n  atleast0(exp: Str | string, leftRec = true): Str {\n    const s = this.normalizeRule(exp);\n    // We want to find another auxiliary NT that has the following rules:\n    //    X -> exp X | ;    # if leftRec = true\n    //\n    //    X -> X exp | ;    # otherwise:\n    let auxNT = this.findAuxNT((auxNT) => {\n      const rules = this.rulesForNT(auxNT);\n      if (rules.length != 2) return false;\n\n      let which = 0;\n      if (rules[0].rhs.length == 0) {\n        which = 1;\n      } else if (rules[1].rhs.length == 0) {\n        which = 0;\n      } else {\n        return false;\n      }\n\n      const rule = rules[which].rhs;\n      if (rule.length != 1 + exp.length) return false;\n      if (rule.syms[0].equals(auxNT)) {\n        return rule.containsAt(1, s);\n      } else if (rule.syms[rule.length - 1].equals(auxNT)) {\n        return rule.containsAt(0, s);\n      }\n      return false;\n    });\n    if (auxNT == null) {\n      auxNT = this.newAuxNT();\n      auxNT.auxType = leftRec ? \"atleast0:left\" : \"atleast0\";\n      this.add(auxNT, new Str());\n      if (leftRec) {\n        this.add(auxNT, new Str(auxNT).extend(s));\n      } else {\n        this.add(auxNT, s.copy().append(auxNT));\n      }\n    }\n    return new Str(auxNT);\n  }\n\n  atleast1(exp: Str | string, leftRec = true): Str {\n    const s = this.normalizeRule(exp);\n    // We want to find another auxiliary NT that has the following rules:\n    //    X -> exp X | exp ;    # if leftRec = true\n    //\n    //    X -> X exp | exp ;    # otherwise:\n    let auxNT = this.findAuxNT((auxNT) => {\n      const rules = this.rulesForNT(auxNT);\n      if (rules.length != 2) return false;\n\n      let which = 0;\n      if (rules[0].rhs.equals(s)) {\n        which = 1;\n      } else if (rules[1].rhs.equals(s)) {\n        which = 0;\n      } else {\n        return false;\n      }\n\n      const rule = rules[which].rhs;\n      if (rule.length != 1 + exp.length) return false;\n      if (rule.syms[0].equals(auxNT)) {\n        return rule.containsAt(1, s);\n      } else if (rule.syms[rule.length - 1].equals(auxNT)) {\n        return rule.containsAt(0, s);\n      }\n      return false;\n    });\n    if (auxNT == null) {\n      auxNT = this.newAuxNT();\n      auxNT.auxType = leftRec ? \"atleast1:left\" : \"atleast1\";\n      this.add(auxNT, s);\n      if (leftRec) {\n        this.add(auxNT, new Str(auxNT).extend(s));\n      } else {\n        this.add(auxNT, s.copy().append(auxNT));\n      }\n    }\n    return new Str(auxNT);\n  }\n\n  normalizeRule(exp: Str | string): Str {\n    if (typeof exp === \"string\") {\n      const lit = this.getSym(exp);\n      if (lit == null) throw new Error(`Invalid symbol: '${exp}'`);\n      return new Str(lit);\n    } else {\n      // We have an expression that needs to be fronted by an\n      // auxiliarry non-terminal\n      return exp;\n    }\n  }\n\n  // Override this to have a different\n  protected auxNTCount = 0;\n  protected newAuxNTName(): string {\n    return this.auxNTPrefix + this.auxNTCount++;\n  }\n\n  newAuxNT(name = \"\"): Sym {\n    if (name == \"\") name = this.newAuxNTName();\n    return this.newNT(name, true);\n  }\n\n  ensureAuxNT(...rules: Str[]): Sym {\n    let nt = this.findAuxNTByRules(...rules);\n    if (nt == null) {\n      nt = this.newAuxNT();\n      nt.auxType = \"anyof\";\n      for (const rule of rules) this.add(nt, rule);\n    }\n    return nt;\n  }\n\n  /**\n   * Find an auxiliary rule that has the same rules as the ones here.\n   * This can be used to ensure duplicate rules are not created for\n   * union expressions.\n   */\n  findAuxNT(filter: (nt: Sym) => boolean): Nullable<Sym> {\n    for (const auxNT of this.symbolSet.entries) {\n      if (!auxNT.isAuxiliary) continue;\n      if (filter(auxNT)) return auxNT;\n    }\n    return null;\n  }\n\n  findAuxNTByRules(...rules: Str[]): Nullable<Sym> {\n    return this.findAuxNT((auxNT) => {\n      const ntRules = this.rulesForNT(auxNT);\n      if (ntRules.length != rules.length) return false;\n      for (let i = 0; i < ntRules.length; i++) {\n        if (!ntRules[i].rhs.equals(rules[i])) return false;\n      }\n      return true;\n    });\n  }\n\n  print(options: any = null): string[] {\n    options = options || {};\n    const ruleSep = options.ruleSep || \"->\";\n    const includeSemiColon = options.includeSemiColon || false;\n    const lambdaSymbol = options.lambdaSymbol || \"\";\n    const out: string[] = [];\n    this.forEachRule(null, (rule: Rule, index: number) => {\n      let r = `${rule.nt.label} ${ruleSep} `;\n      if (rule.rhs.length > 0) r += rule.rhs.debugString;\n      else r += lambdaSymbol;\n      if (includeSemiColon) r += \" ;\";\n      out.push(r);\n    });\n    return out;\n  }\n\n  /**\n   * Returns a flat list of all productions in a single list.\n   */\n  get debugValue(): string[] {\n    const out: string[] = [];\n    this.forEachRule(null, (rule: Rule, index: number) => {\n      out.push(`${rule.nt.label} -> ${rule.rhs.debugString}`);\n    });\n    return out;\n  }\n\n  /**\n   * Returns all non terminals that can derive terminals.\n   */\n  get terminalDerivingSymbols(): SymbolSet {\n    const out = new SymbolSet(this, null);\n    let nadded = -1;\n    let allDerive = true;\n    while (nadded != 0) {\n      nadded = 0;\n      for (const rule of this.allRules) {\n        allDerive = true;\n        for (const sym of rule.rhs.syms) {\n          if (!out.has(sym)) {\n            if (sym.isTerminal) {\n              out.add(sym);\n              nadded++;\n            } else {\n              allDerive = false;\n            }\n          }\n        }\n        if (allDerive && !out.has(rule.nt)) {\n          out.add(rule.nt);\n          nadded++;\n        }\n      }\n    }\n    return out;\n  }\n\n  /*\n   * Returns all non terminal that are reachable from a given symbol.\n   * If the FROM symbol is omitted then the start symbol is used.\n   */\n  reachableSymbols(fromSymbol: Nullable<Sym> = null): SymbolSet {\n    if (fromSymbol == null) {\n      fromSymbol = this._AugStartRule ? this._AugStartRule.nt : this.startSymbol;\n    }\n    TSU.assert(fromSymbol != null, \"Start symbol does not exist\");\n    const reachable = new SymbolSet(this, false).add(fromSymbol);\n    let queue: Sym[] = [fromSymbol];\n    while (queue.length > 0) {\n      const newQueue: Sym[] = [];\n      for (const curr of queue) {\n        for (const rule of this.rulesForNT(curr)) {\n          for (const sym of rule.rhs.syms) {\n            if (!sym.isTerminal && !reachable.has(sym)) {\n              newQueue.push(sym);\n              reachable.add(sym);\n            }\n          }\n        }\n      }\n      queue = newQueue;\n    }\n    return reachable;\n  }\n\n  /**\n   * Returns all cycles in this grammar.\n   */\n  get cycles(): ReadonlyArray<[Sym, any]> {\n    /*\n     * Returns the edge of the given nonterm\n     * For a nt such that:\n     *             S -> alpha1 X1 beta1 |\n     *                  alpha2 X2 beta2 |\n     *                  ...\n     *                  alphaN XN betaN |\n     *\n     * S's neighbouring nodes would be Xk if all of alphak is optional\n     * AND all of betak is optional\n     */\n    const edgeFunctor = (node: Sym): [Sym, any][] => {\n      const out: [Sym, any][] = [];\n      this.forEachRule(node, (rule, ruleIndex) => {\n        rule.rhs.syms.forEach((s, j) => {\n          if (s.isTerminal) return;\n          if (this.nullables.isStrNullable(rule.rhs, 0, j - 1) && this.nullables.isStrNullable(rule.rhs, j + 1)) {\n            out.push([s, [node, ruleIndex]]);\n          }\n        });\n      });\n      return out;\n    };\n    return allMinimalCycles(this.allNonTerminals, (val: Sym) => val.label, edgeFunctor);\n  }\n\n  /**\n   * Returns a set of \"Starting\" non terminals which have atleast\n   * one production containing left recursion.\n   */\n  get leftRecursion(): any {\n    const edgeFunctor = (node: Sym): [Sym, any][] => {\n      const out: [Sym, any][] = [];\n      this.forEachRule(node, (rule, ruleIndex) => {\n        rule.rhs.syms.forEach((s, j) => {\n          if (s.isTerminal) return;\n          out.push([s, ruleIndex]);\n          // If this is symbol is not nullable then we can stop here\n          return this.nullables.isNullable(s);\n        });\n      });\n      return out;\n    };\n    return allMinimalCycles(this.allNonTerminals, (val: Sym) => val.id, edgeFunctor);\n  }\n}\n","export enum PropertyName {\n  // Binary Property Names\n  gc,\n  General_Category = gc,\n  sc,\n  Script = sc,\n  scx,\n  Script_Extension = scx,\n\n  // Non binary property names\n  Any,\n  ASCII,\n  AHex,\n  ASCII_Hex_Digit = AHex,\n  Alpha,\n  Alphabetic = Alpha,\n  Bidi_M,\n  Bidi_Mirrored = Bidi_M,\n  Bidi_C,\n  Bidi_Control = Bidi_C,\n  CI,\n  Case_Ignorable = CI,\n  Cased,\n  CWCF,\n  Changes_When_Casefolded = CWCF,\n  CWCM,\n  Changes_When_Casemapped = CWCM,\n  CWL,\n  Changes_When_Lowercased = CWL,\n  CWKCF,\n  Changes_When_NFKC_Casefolded = CWKCF,\n  CWT,\n  Changes_When_Titlecased = CWT,\n  CWU,\n  Changes_When_Uppercased = CWU,\n  Dash,\n  DI,\n  Default_Ignorable_Code_Point = DI,\n  Dep,\n  Deprecated = Dep,\n  Dia,\n  Diacritic = Dia,\n  Emoji,\n  Emoji_Component,\n  Emoji_Modifier,\n  Emoji_Modifier_Base,\n  Emoji_Presentation,\n  Ext,\n  Extender = Ext,\n  Gr_Base,\n  Grapheme_Base = Gr_Base,\n  Gr_Ext,\n  Grapheme_Extend = Gr_Ext,\n  Hex,\n  Hex_Digit = Hex,\n  IDSB,\n  IDS_Binary_Operator = IDSB,\n  IDST,\n  IDS_Trinary_Operator = IDST,\n  IDC,\n  ID_Continue = IDC,\n  IDS,\n  ID_Start = IDS,\n  Ideo,\n  Ideographic = Ideo,\n  Join_C,\n  Join_Control = Join_C,\n  LOE,\n  Logical_Order_Exception = LOE,\n  Lower,\n  Lowercase = Lower,\n  Math,\n  NChar,\n  Noncharacter_Code_Point = NChar,\n  Pat_Syn,\n  Pattern_Syntax = Pat_Syn,\n  Pat_WS,\n  Pattern_White_Space = Pat_WS,\n  QMark,\n  Quotation_Mark = QMark,\n  Radical,\n  RI,\n  Regional_Indicator = RI,\n  STerm,\n  Sentence_Terminal = STerm,\n  SD,\n  Soft_Dotted = SD,\n  Term,\n  Terminal_Punctuation = Term,\n  UIdeo,\n  Unified_Ideograph = UIdeo,\n  Upper,\n  Uppercase = Upper,\n  VS,\n  Variation_Selector = VS,\n  space,\n  White_Space = space,\n  XIDC,\n  XID_Continue = XIDC,\n  XIDS,\n  XID_Start = XIDS,\n}\n\nexport enum PropertyValue {\n  // General Category proeprty values\n  LC,\n  Cased_Letter = LC,\n  Pe,\n  Close_Punctuation = Pe,\n  Pc,\n  Connector_Punctuation = Pc,\n  Cc,\n  cntrl = Cc,\n  Control = Cc,\n  Sc,\n  Currency_Symbol = Sc,\n  Pd,\n  Dash_Punctuation = Pd,\n  Nd,\n  digit = Nd,\n  Decimal_Number = digit,\n  Me,\n  Enclosing_Mark = Me,\n  Pf,\n  Final_Punctuation = Pf,\n  Cf,\n  Format = Cf,\n  Pi,\n  Initial_Punctuation = Pi,\n  L,\n  Letter = L,\n  Nl,\n  Letter_Number = Nl,\n  Zl,\n  Line_Separator = Zl,\n  Ll,\n  Lowercase_Letter = Ll,\n  M,\n  Combining_Mark = M,\n  Mark,\n  Sm,\n  Math_Symbol = Sm,\n  Lm,\n  Modifier_Letter = Lm,\n  Sk,\n  Modifier_Symbol = Sk,\n  Mn,\n  Nonspacing_Mark = Mn,\n  N,\n  Number = N,\n  Ps,\n  Open_Punctuation = Ps,\n  C,\n  Other = C,\n  Lo,\n  Other_Letter = Lo,\n  No,\n  Other_Number = No,\n  Po,\n  Other_Punctuation = Po,\n  So,\n  Other_Symbol = So,\n  Zp,\n  Paragraph_Separator = Zp,\n  Co,\n  Private_Use = Co,\n  P,\n  punct = P,\n  Punctuation = P,\n  Z,\n  Separator = Z,\n  Zs,\n  Space_Separator = Zs,\n  Mc,\n  Spacing_Mark = Mc,\n  Cs,\n  Surrogate = Cs,\n  S,\n  Symbol = S,\n  Lt,\n  Titlecase_Letter = Lt,\n  Cn,\n  Unassigned = Cn,\n  Lu,\n  Uppercase_Letter = Lu,\n  // Script and Script Extension proeprty values\n}\n\nexport function propertyNameFor(value: string): PropertyName {\n  value = value.trim();\n  if (!(value in PropertyName)) {\n    throw new SyntaxError(\"Invalid property name: \" + value);\n  }\n  return (PropertyName as any)[value];\n}\n\nexport function propertyValueFor(value: string): PropertyValue {\n  value = value.trim();\n  if (!(value in PropertyValue)) {\n    throw new SyntaxError(\"Invalid property value: \" + value);\n  }\n  return (PropertyValue as any)[value];\n}\n\nexport function propertyNameString(value: number): string {\n  if (!(value in PropertyName)) {\n    throw new Error(\"Invalid property name: \" + value);\n  }\n  return PropertyName[value];\n}\n\nexport function propertyValueString(value: number): string {\n  if (!(value in PropertyValue)) {\n    throw new Error(\"Invalid property value: \" + value);\n  }\n  return PropertyValue[value];\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { TapeInterface as Tape } from \"./tape\";\nimport { Char } from \"./core\";\n\nfunction isNewLineChar(ch: string): boolean {\n  return ch == \"\\r\" || ch == \"\\n\" || ch == \"\\u2028\" || ch == \"\\u2029\";\n}\n\nexport class Match {\n  groups: [number, number][] = [];\n  positions: number[] = [];\n  constructor(public priority = 10, public matchIndex = -1, public start = -1, public end = -1) {}\n}\n\nexport enum OpCode {\n  // Any character\n  Any,\n  // Any character not including a new line\n  AnyNonNL,\n  // Char and CI Chars\n  Char,\n  CIChar,\n  // NegChar,\n  // NegCIChar,\n\n  // Non char opcodes\n  Match,\n  Noop,\n  Save,\n  Split,\n  Jump,\n  Begin, // Forward lookahead matches\n  RBegin, // Reverse lookahead matches\n  End,\n\n  // Look ahead and Look back matchers\n  // ^ and $ that are not activated on newlines\n  StartingChar,\n  EndingChar,\n  // ^ and $ that are activated on newlines as well\n  MLStartingChar,\n  MLEndingChar,\n  StartOfWord,\n  EndOfWord,\n  GroupStart,\n  GroupEnd,\n\n  // Stops the thread if state does not match\n  EnsureState,\n}\n\nexport class Prog {\n  instrs: Instr[] = [];\n  stateMapping: Map<string, number>;\n\n  constructor(public readonly startCondition = \"INITIAL\", public readonly scIsInclusive = true) {\n    this.stateMapping = new Map<string, number>();\n    this.registerState(\"INITIAL\");\n    this.registerState(startCondition);\n  }\n\n  get length(): number {\n    return this.instrs.length;\n  }\n\n  /**\n   * Adds a state to our program and returns the state's index.\n   */\n  registerState(state: string): number {\n    if (!this.stateMapping.has(state)) {\n      this.stateMapping.set(state, this.stateMapping.size);\n    }\n    return this.stateMapping.get(state) || -1;\n  }\n\n  add(opcode: any, char: null | Char = null, ...args: number[]): Instr {\n    const out = new Instr(opcode, char).add(...args);\n    out.offset = this.instrs.length;\n    this.instrs.push(out);\n    return out;\n  }\n\n  static with(initializer: (prog: Prog) => void): Prog {\n    const out = new Prog();\n    initializer(out);\n    return out;\n  }\n\n  debugValue(instrDebugValue: (instr: Instr) => string = InstrDebugValue): any {\n    if (instrDebugValue) {\n      return this.instrs.map((instr, index) => {\n        if (instr.comment.trim().length > 0) return `L${index}: ${instrDebugValue(instr)}     # ${instr.comment}`;\n        else return `L${index}: ${instrDebugValue(instr)}`;\n      });\n    } else {\n      return this.instrs.map((instr, index) => `L${index}: ${instr.debugValue}`);\n    }\n  }\n}\n\nexport class Instr {\n  offset = 0;\n  comment = \"\";\n  args: number[] = [];\n  // used for char match instructions - if opcode == Char or CIChar\n  constructor(public readonly opcode: any, public char: null | Char = null) {\n    this.char = char;\n  }\n\n  add(...args: number[]): this {\n    this.args.push(...args);\n    return this;\n  }\n\n  get debugValue(): any {\n    let c = this.comment.trim();\n    if (c.length > 0) c = \"    # \" + c;\n    return `${this.opcode} ${this.args.join(\" \")}    ${this.char || \"\"}   ${c}`;\n  }\n}\n\n/**\n * A thread that is performing an execution of the regex VM.\n */\nexport class Thread {\n  parentId = -1;\n  id = 0;\n  priority = 0;\n  /**\n   * Saved positions into the input stream for the purpose of\n   * partial and custom matches.\n   */\n  groups: [number, number][] = [];\n  positions: number[] = [];\n  registers: TSU.NumMap<number> = {};\n\n  /**\n   * Create a thread at the given offset\n   */\n  constructor(public readonly offset: number = 0, public readonly gen: number = 0) {}\n\n  regIncr(regId: number): void {\n    if (!(regId in this.registers)) {\n      throw new Error(`Register at offset ${regId} is invalid`);\n    }\n    this.registers[regId]++;\n  }\n\n  regAcquire(regId: number): void {\n    if (regId in this.registers) {\n      throw new Error(`Register at offset ${regId} already acquired.  Release it first`);\n    }\n    this.registers[regId] = 0;\n  }\n\n  regRelease(regId: number): void {\n    if (!(regId in this.registers)) {\n      throw new Error(`Register at offset ${regId} is invalid`);\n    }\n    delete this.registers[regId];\n  }\n\n  regValue(regId: number): number {\n    if (!(regId in this.registers)) {\n      throw new Error(`Register at offset ${regId} is invalid`);\n    }\n    return this.registers[regId];\n  }\n}\n\nexport interface VMTracer {\n  threadDequeued(thread: Thread, tapeIndex: number): void;\n  threadStepped(thread: Thread, tapeIndex: number, gen: number): void;\n  threadQueued(thread: Thread, tapeIndex: number): void;\n}\n\nexport class VM {\n  // TODO - To prevent excessive heap activity and GC\n  // create a pool of threads and just have a cap on\n  // match sizes\n  // To eve simplify each Thread could just be something like:\n  // number[] where\n  //  number[0] == offset\n  //  number[1-2*MaxSubs] = Substitutions\n  //  number[2*MaxSubs - 2*MaxSubs + M] = Registers\n  //      where M = Max number of NewReg instructions\n  protected threadCounter = 0;\n  protected currThreads: Thread[] = [];\n  protected nextThreads: Thread[] = [];\n  protected startPos = 0; // Where the match is beginning from - this will be set to tape.index when match is called\n  // Initial state is always 0\n  protected currState = 0;\n\n  protected gen = 0;\n  // Records which \"generation\" of the match a particular\n  // offset is in.  If a thread is added at a particular\n  // offset the generation number is used to see if the\n  // thread is a duplicate (and avoided if so).  This\n  // ensures that are linearly bounded on the number of\n  // number threads as we match.\n  protected genForOffset: TSU.NumMap<number> = {};\n\n  tracer: VMTracer;\n  constructor(\n    public readonly prog: Prog,\n    public readonly start = 0,\n    public readonly end = -1,\n    public readonly forward = true,\n    configs: any = {},\n  ) {\n    if (end < 0) {\n      end = prog.length - 1;\n    }\n    this.end = end;\n  }\n\n  savePosition(thread: Thread, pos: number, tapeIndex: number): void {\n    while (thread.positions.length <= pos) thread.positions.push(-1);\n    thread.positions[pos] = tapeIndex;\n  }\n\n  jumpBy(thread: Thread, delta = 1): Thread {\n    return this.jumpTo(thread, thread.offset + delta);\n  }\n\n  jumpTo(thread: Thread, newOffset: number): Thread {\n    // TODO - Why create new thread here - investigate if we can\n    // return the same thread with the offset updated?\n    // if we really want a \"history\" we could jsut keep prev offsets\n    // in a list so we can keep a trace\n    const out = new Thread(newOffset, this.gen);\n    out.id = thread.id;\n    out.parentId = thread.parentId;\n    out.priority = thread.priority;\n    out.positions = thread.positions;\n    out.groups = thread.groups;\n    out.registers = thread.registers;\n    return out;\n  }\n\n  forkTo(thread: Thread, newOffset: number): Thread {\n    const out = new Thread(newOffset, this.gen);\n    out.id = ++this.threadCounter;\n    out.parentId = thread.id;\n    out.priority = thread.priority;\n    out.positions = [...thread.positions];\n    out.groups = [...thread.groups];\n    out.registers = { ...thread.registers };\n    return out;\n  }\n\n  startGroup(thread: Thread, groupIndex: number, tapeIndex: number): Thread {\n    const newThread = this.forkTo(thread, thread.offset + 1);\n    newThread.groups.push([groupIndex, tapeIndex]);\n    return newThread;\n  }\n\n  endGroup(thread: Thread, groupIndex: number, tapeIndex: number): Thread {\n    const newThread = this.forkTo(thread, thread.offset + 1);\n    newThread.groups.push([-groupIndex, tapeIndex]);\n    return newThread;\n  }\n\n  addThread(thread: Thread, list: Thread[], tape: Tape, delta = 0): void {\n    if (\n      thread.offset < this.start ||\n      thread.offset > this.end ||\n      this.genForOffset[thread.offset - this.start] == this.gen\n    ) {\n      // duplicate\n      return;\n    }\n    this.genForOffset[thread.offset - this.start] = this.gen;\n    const instr = this.prog.instrs[thread.offset];\n    let nextCh: string;\n    let lastCh: string;\n    let newThread: Thread;\n    // if (this.tracer) this.tracer.threadStepped(thread, tape.index, this.gen);\n    const opcode = instr.opcode;\n    switch (opcode) {\n      case OpCode.Jump:\n        newThread = this.jumpTo(thread, instr.args[0]);\n        this.addThread(newThread, list, tape, delta);\n        break;\n      case OpCode.Split:\n        for (let j = 0; j < instr.args.length; j++) {\n          const newOff = instr.args[j];\n          // TODO - only fork on position/group write instead of always forking on a split\n          const newThread = j == 0 ? this.jumpTo(thread, newOff) : this.forkTo(thread, newOff);\n          this.addThread(newThread, list, tape, delta);\n        }\n        break;\n      case OpCode.Save:\n        newThread = this.jumpTo(thread, thread.offset + 1);\n        this.savePosition(newThread, instr.args[0], tape.index + delta);\n        if (this.tracer) this.tracer.threadQueued(thread, tape.index + delta);\n        this.addThread(newThread, list, tape, delta);\n        break;\n      case OpCode.GroupStart:\n        newThread = this.startGroup(thread, instr.args[0], tape.index + delta);\n        if (this.tracer) this.tracer.threadQueued(thread, tape.index + delta);\n        this.addThread(newThread, list, tape, delta);\n        break;\n      case OpCode.GroupEnd:\n        newThread = this.endGroup(thread, instr.args[0], tape.index + delta);\n        if (this.tracer) this.tracer.threadQueued(thread, tape.index + delta);\n        this.addThread(newThread, list, tape, delta);\n        break;\n      case OpCode.StartingChar:\n      case OpCode.MLStartingChar:\n        // only proceed further if prev was a newline or start\n        lastCh = this.prevCh(tape);\n        if (tape.index == 0 || (opcode == OpCode.MLStartingChar && isNewLineChar(lastCh))) {\n          // have a match so can go forwrd but dont advance tape on\n          // the same generation\n          this.addThread(this.jumpBy(thread, 1), list, tape, delta);\n        }\n        break;\n      case OpCode.EndingChar:\n      case OpCode.MLEndingChar:\n        // On end of input we dont advance tape but thread moves on\n        // if at end of line boundary\n        // check if next is end of input\n        nextCh = this.nextCh(tape);\n        if (nextCh == \"\" || (opcode == OpCode.MLEndingChar && isNewLineChar(nextCh))) {\n          this.addThread(this.jumpBy(thread, 1), list, tape, delta);\n        }\n        break;\n      case OpCode.StartOfWord:\n        // only proceed further if prev was a newline or start\n        /*\n        lastCh = this.prevCh(tape);\n        if (tape.index == 0 || (this.multiline && (isNewLineChar(lastCh) || isSpaceChar(lastCh)))) {\n          // have a match so can go forwrd but dont advance tape on\n          // the same generation\n          this.addThread(this.jumpBy(thread, 1), list, tape, delta);\n        }\n       */\n        break;\n      case OpCode.EndOfWord:\n        // On end of input we dont advance tape but thread moves on\n        // if at end of line boundary\n        // check if next is end of input\n        /*\n        nextCh = this.nextCh(tape);\n        if (nextCh == \"\" || (this.multiline && (isNewLineChar(nextCh) || isSpaceChar(nextCh)))) {\n          this.addThread(this.jumpBy(thread, 1), list, tape, delta);\n        }\n       */\n        break;\n      case OpCode.RBegin:\n        {\n          const [groupIndex, negate, end] = instr.args;\n          const pos = (1 + groupIndex) * 2;\n          const groupStart = thread.positions[pos];\n          const [matchSuccess, matchEnd] = this.recurseMatch(\n            tape,\n            groupStart - 1,\n            instr.offset + 1,\n            end,\n            false,\n            negate == 1,\n          );\n          if (matchSuccess) {\n            // TODO - Consider using a DFA for this case so we can mitigate\n            // pathological cases with an exponential blowup on a success\n            this.addThread(this.jumpTo(thread, end + 1), list, tape, delta);\n          }\n        }\n        break;\n      case OpCode.Begin:\n        // This results in a new VM being created for this sub program and\n        // kicking off a backtracking execution - Making these as explicit\n        // constructs for the user to use means the user can make this choice\n        // on their own voilition\n        const [consume, negate, end] = instr.args;\n        if (consume == 1) {\n          // since this results in the consumption of a character (similar to \"Char\")\n          // defer this to the list\n          if (this.tracer) this.tracer.threadQueued(thread, tape.index);\n          list.push(thread);\n        } else {\n          const [matchSuccess, matchEnd] = this.recurseMatch(\n            tape,\n            tape.index + 1,\n            instr.offset + 1,\n            end,\n            true,\n            negate == 1,\n          );\n          if (matchSuccess) {\n            // TODO - Consider using a DFA for this case so we can mitigate\n            // pathological cases with an exponential blowup on a success\n            this.addThread(this.jumpTo(thread, end + 1), list, tape, delta);\n          }\n        }\n        break;\n      case OpCode.EnsureState:\n        const states = instr.args;\n        for (const state of states) {\n          if (this.currState == state) {\n            this.addThread(this.jumpBy(thread, 1), list, tape, delta);\n            break;\n          }\n        }\n        break;\n      default:\n        if (this.tracer) this.tracer.threadQueued(thread, tape.index);\n        list.push(thread);\n        break;\n    }\n  }\n\n  matchCurrPos(tape: Tape, char: Char, ignoreCase = false): boolean {\n    if (ignoreCase) {\n      return char.match(tape.currChCodeLower) || char.match(tape.currChCodeUpper);\n    } else {\n      return char.match(tape.currChCode);\n    }\n  }\n\n  protected hasMore(tape: Tape): boolean {\n    return this.forward ? tape.hasMore : tape.index >= 0;\n  }\n\n  protected nextCh(tape: Tape): string {\n    const next = tape.index + (this.forward ? 1 : -1);\n    return tape.charAt(next);\n    // if (next < 0 || next >= tape.input.length) return \"\";\n    // return tape.input[next];\n  }\n\n  protected prevCh(tape: Tape): string {\n    return tape.charAt(tape.index - (this.forward ? 1 : -1));\n    // return tape.input[tape.index - (this.forward ? 1 : -1)];\n  }\n\n  /**\n   * Runs the given instructions and returns a triple:\n   * [matchId, matchStart, matchEnd]\n   */\n  match(tape: Tape): Match | null {\n    // this.gen = 0; this.genForOffset = {};\n    if (this.end < this.start) return null;\n    this.startMatching(tape);\n    let bestMatch: TSU.Nullable<Match> = null;\n    while (this.currThreads.length > 0) {\n      bestMatch = this.stepChar(tape, bestMatch);\n    }\n    // ensure tape is rewound to end of last match\n    if (bestMatch != null) tape.index = bestMatch.end;\n    return bestMatch;\n  }\n\n  recurseMatch(\n    tape: Tape,\n    tapeIndex: number,\n    startOffset: number,\n    endOffset: number,\n    forward = true,\n    negate = false,\n  ): [boolean, number] {\n    const savedPos = tape.index;\n    if (!tape.canAdvance(forward ? 1 : -1)) return [negate, -1];\n    tape.index = tapeIndex;\n    // tape.advance(forward ? 1 : -1);\n    const vm = new VM(this.prog, startOffset, endOffset, forward);\n    const match = vm.match(tape);\n    const newPos = tape.index;\n    tape.index = savedPos; // always restore it first and let caller use it\n    return [(match != null && !negate) || (match == null && negate), newPos];\n  }\n\n  startMatching(tape: Tape): void {\n    this.currThreads = [];\n    this.nextThreads = [];\n    this.gen++;\n    this.addThread(new Thread(this.start, this.gen), this.currThreads, tape);\n    // let largestMatchEnd = -1;\n    // let lastMatchIndex = -1;\n    this.startPos = tape.index;\n  }\n\n  stepChar(tape: Tape, currMatch: TSU.Nullable<Match> = null): TSU.Nullable<Match> {\n    // At this point all our threads are point to the next \"transition\" or \"match\" action.\n    this.gen++;\n    // console.log(`Ch (@${tape.index}): ${tape.currChCode}, Gen (${this.gen})`);\n    for (let i = 0; i < this.currThreads.length; i++) {\n      const thread = this.currThreads[i];\n      // console.log(`   Thread (${i}): ${thread.offset}(${thread.gen})`);\n      const nextMatch = this.stepThread(tape, thread);\n      if (nextMatch != null) {\n        if (\n          currMatch == null ||\n          nextMatch.priority > currMatch.priority ||\n          (nextMatch.priority == currMatch.priority && nextMatch.end > currMatch.end)\n        ) {\n          currMatch = nextMatch;\n          break;\n        } else if (currMatch != nextMatch) {\n          // Since we kill of lower priority matches becuase of matchedInGen\n          // we should not be here\n          // TSU.assert(false, \"Should not be here\");\n        }\n      }\n    }\n    if (this.hasMore(tape)) {\n      tape.advance(this.forward ? 1 : -1);\n    }\n    this.currThreads = this.nextThreads;\n    this.nextThreads = [];\n    return currMatch;\n  }\n\n  stepThread(tape: Tape, thread: Thread): TSU.Nullable<Match> {\n    if (this.tracer) this.tracer.threadStepped(thread, tape.index, this.gen);\n    let currMatch: TSU.Nullable<Match> = null;\n    const instrs = this.prog.instrs;\n    const instr = instrs[thread.offset];\n    const opcode = instr.opcode;\n    const args = instr.args;\n    const delta = this.forward ? 1 : -1;\n    // Do char match based actions\n    let advanceTape = false;\n    let ch: number;\n    switch (opcode) {\n      case OpCode.RBegin:\n        throw new Error(\"Invalid state.  Reverse matches must be handled in addThread\");\n        break;\n      case OpCode.Begin:\n        const [consume, negate, end] = instr.args;\n        TSU.assert(consume == 1, \"Plain lookahead cannot be here\");\n        const [matchSuccess, matchEnd] = this.recurseMatch(tape, tape.index, instr.offset + 1, end, true, negate == 1);\n        if (matchSuccess) {\n          // TODO - Consider using a DFA for this case so we can mitigate\n          // pathological cases with an exponential blowup\n          // on a success we have a few options\n          this.addThread(this.jumpTo(thread, end + 1), this.nextThreads, tape);\n        }\n        break;\n      case OpCode.End:\n        // Return back to calling VM - very similar to a match\n        const out = new Match(-1, -1, this.startPos, tape.index);\n        out.groups = thread.groups;\n        out.positions = thread.positions;\n        return out;\n        break;\n      case OpCode.Match:\n        // we have a match on this thread so return it\n        // Update the match if we are a higher prioirty or longer match\n        // than what was already found (if any)\n        if (tape.index > this.startPos) {\n          const currPriority = instr.args[0];\n          const matchIndex = instr.args[1];\n          currMatch = new Match();\n          currMatch.start = this.startPos;\n          currMatch.end = tape.index;\n          currMatch.priority = currPriority;\n          currMatch.matchIndex = matchIndex;\n          currMatch.groups = thread.groups;\n          currMatch.positions = thread.positions;\n        }\n        break;\n      case OpCode.Char:\n      case OpCode.CIChar:\n        if (this.hasMore(tape)) {\n          advanceTape = this.matchCurrPos(tape, instr.char!, opcode == OpCode.CIChar);\n        }\n        break;\n      /*\n      case OpCode.NegChar:\n      case OpCode.NegCIChar:\n        if (this.hasMore(tape)) {\n          advanceTape = !this.matchCurrPos(tape, args, opcode == OpCode.NegCIChar);\n        }\n        break;\n      */\n      case OpCode.AnyNonNL:\n      case OpCode.Any:\n        if (this.hasMore(tape)) {\n          advanceTape = opcode == OpCode.Any || !isNewLineChar(tape.currCh);\n        }\n        break;\n    }\n    if (advanceTape /* && this.hasMore(tape) */) {\n      this.addThread(this.jumpBy(thread, 1), this.nextThreads, tape, delta);\n    }\n    return currMatch;\n  }\n}\n\nexport function InstrDebugValue(instr: Instr): string {\n  switch (instr.opcode) {\n    case OpCode.Match:\n      return `Match ${instr.args[0]} ${instr.args[1]}`;\n    // case OpCode.NegChar:\n    // case OpCode.NegCIChar:\n    case OpCode.Char:\n    case OpCode.CIChar: {\n      let out = `${OpCode[instr.opcode].toString()} `;\n      // out += `${CharType[instr.args[0]]}`;\n      // for (let i = 1; i < instr.args.length; i++) out += \" \" + instr.args[i];\n      out += `${instr.char!.debugValue()}`;\n      return out;\n    }\n    case OpCode.Any:\n      return \".\";\n    case OpCode.AnyNonNL:\n      return \"NL.\";\n    case OpCode.StartingChar:\n      return \"^\";\n    case OpCode.MLStartingChar:\n      return \"NL^\";\n    case OpCode.EndingChar:\n      return \"$NL\";\n    case OpCode.MLEndingChar:\n      return \"$NL_MultiLine\";\n    case OpCode.Save:\n      return `Save ${instr.args[0]}`;\n    case OpCode.GroupStart:\n      return `GroupStart ${instr.args[0]}`;\n    case OpCode.GroupEnd:\n      return `GroupEnd ${instr.args[0]}`;\n    case OpCode.Split:\n      return `Split ${instr.args.join(\", \")}`;\n    case OpCode.Jump:\n      return `Jump ${instr.args[0]}`;\n    case OpCode.Begin:\n      return `Begin ${instr.args.join(\" \")}`;\n    case OpCode.RBegin:\n      return `RBegin ${instr.args.join(\" \")}`;\n    case OpCode.End:\n      return `End ${instr.args.join(\" \")}`;\n    case OpCode.EnsureState:\n      return `EnsureState ${instr.args.join(\" \")}`;\n    default:\n      throw new Error(\"Invalid Opcode: \" + instr.opcode);\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\n\nimport {\n  Rule,\n  RegexType,\n  Quant,\n  Regex,\n  Cat,\n  Char,\n  CharType,\n  Var,\n  BackNumRef,\n  BackNamedRef,\n  LookAhead,\n  LookBack,\n  Union,\n} from \"./core\";\nimport { OpCode, Prog, Instr } from \"./vm\";\n\nexport type RegexResolver = (name: string) => Regex;\nexport type CompilerListener = (expr: Regex, prog: Prog, start: number, length: number) => void;\n\n/**\n * The regex Compiler compiles a parsed regular expression tree into bytecode that is\n * executed by the VM.\n */\nexport class Compiler {\n  emitGroups = false;\n  emitPosition = true;\n  constructor(\n    public regexResolver: TSU.Nullable<RegexResolver>,\n    public listener: TSU.Nullable<CompilerListener> = null,\n  ) {}\n\n  compile(rules: Rule[]): Prog {\n    // Split across each of our expressions\n    const out = new Prog();\n    // only add the split instruction if we have more than one rule\n    const split: Instr = rules.length <= 1 ? new Instr(OpCode.Split) : out.add(OpCode.Split, null);\n    rules.forEach((rule, i) => {\n      split.add(out.instrs.length);\n      const ignoreCase = rule.expr.ignoreCase == null ? false : rule.expr.ignoreCase;\n      const dotAll = rule.expr.dotAll == null ? true : rule.expr.dotAll;\n      const multiline = rule.expr.multiline == null ? true : rule.expr.multiline;\n      if (rule.needsSpecificStates && rule.activeStates != null) {\n        const ensureInstr = out.add(OpCode.EnsureState, null);\n        rule.activeStates.forEach((state) => {\n          const ind = out.registerState(state);\n          ensureInstr.add(ind);\n        });\n      }\n      this.compileExpr(rule.expr, out, ignoreCase, dotAll, multiline);\n      out.add(OpCode.Match, null).add(rule.priority, rule.matchIndex >= 0 ? rule.matchIndex : i);\n    });\n    return out;\n  }\n\n  /**\n   * Compile a given expression into a set of instructions.\n   */\n  protected compileExpr(expr: Regex, prog: Prog, ignoreCase: boolean, dotAll: boolean, multiline: boolean): number {\n    const start = prog.length;\n    const currOffset = prog.length;\n    if (expr.groupIndex >= 0) {\n      if (this.emitPosition) prog.add(OpCode.Save).add((1 + expr.groupIndex) * 2);\n      if (this.emitGroups) prog.add(OpCode.GroupStart).add(1 + expr.groupIndex);\n    }\n    if (expr.tag == RegexType.CHAR) {\n      this.compileChar(expr as Char, prog, ignoreCase, dotAll, multiline);\n    } else if (expr.tag == RegexType.START_OF_INPUT) {\n      const ml = expr.multiline == null ? multiline : expr.multiline;\n      prog.add(ml ? OpCode.MLStartingChar : OpCode.StartingChar);\n    } else if (expr.tag == RegexType.END_OF_INPUT) {\n      const ml = expr.multiline == null ? multiline : expr.multiline;\n      prog.add(ml ? OpCode.MLEndingChar : OpCode.EndingChar);\n    } else if (expr.tag == RegexType.START_OF_WORD) {\n      prog.add(OpCode.StartOfWord);\n    } else if (expr.tag == RegexType.END_OF_WORD) {\n      prog.add(OpCode.EndOfWord);\n    } else if (expr.tag == RegexType.CAT) {\n      this.compileCat(expr as Cat, prog, ignoreCase, dotAll, multiline);\n    } else if (expr.tag == RegexType.UNION) {\n      this.compileUnion(expr as Union, prog, ignoreCase, dotAll, multiline);\n    } else if (expr.tag == RegexType.QUANT) {\n      this.compileQuant(expr as Quant, prog, ignoreCase, dotAll, multiline);\n    } else if (expr.tag == RegexType.VAR) {\n      this.compileVar(expr as Var, prog, ignoreCase, dotAll, multiline);\n    } else if (expr.tag == RegexType.BACK_NAMED_REF) {\n      this.compileBackNamedRef(expr as BackNamedRef, prog, ignoreCase, dotAll, multiline);\n    } else if (expr.tag == RegexType.BACK_NUM_REF) {\n      this.compileBackNumRef(expr as BackNumRef, prog, ignoreCase, dotAll, multiline);\n      // } else if (expr.tag == RegexType.NEG) { this.compileNeg(expr as Neg, prog);\n    } else if (expr.tag == RegexType.LOOK_AHEAD) {\n      this.compileLookAhead(expr as LookAhead, prog, ignoreCase, dotAll, multiline);\n    } else if (expr.tag == RegexType.LOOK_BACK) {\n      this.compileLookBack(expr as LookBack, prog, ignoreCase, dotAll, multiline);\n    } else {\n      throw new Error(\"Regex Type not yet supported: \" + expr.tag);\n    }\n    if (expr.groupIndex >= 0) {\n      if (this.emitGroups) prog.add(OpCode.GroupEnd).add(1 + expr.groupIndex);\n      if (this.emitPosition) prog.add(OpCode.Save).add((1 + expr.groupIndex) * 2 + 1);\n    }\n    if (this.listener && prog.length > currOffset) {\n      this.listener(expr, prog, currOffset, prog.length - currOffset);\n    }\n    return prog.length - start;\n  }\n\n  protected compileChar(char: Char, prog: Prog, ignoreCase: boolean, dotAll: boolean, multiline: boolean): void {\n    if (char.op == CharType.AnyChar) {\n      // TODO - Should neg be ignored?\n      prog.add(dotAll ? OpCode.Any : OpCode.AnyNonNL);\n    } else {\n      const instr = prog.add(ignoreCase ? OpCode.CIChar : OpCode.Char);\n      instr.char = char;\n      /*\n      // We have Neg or not, CI or not\n      const instr = prog.add(\n        ignoreCase ? (char.neg ? OpCode.NegCIChar : OpCode.CIChar) : char.neg ? OpCode.NegChar : OpCode.Char,\n      );\n      instr.add(char.op);\n\n      // And now the arguments\n      for (const arg of char.args) instr.add(arg);\n      */\n    }\n  }\n\n  protected compileCat(cat: Cat, prog: Prog, ignoreCase: boolean, dotAll: boolean, multiline: boolean): void {\n    for (const child of cat.children) {\n      this.compileExpr(child, prog, ignoreCase, dotAll, multiline);\n    }\n  }\n\n  protected compileBackNumRef(\n    ne: BackNumRef,\n    prog: Prog,\n    ignoreCase: boolean,\n    dotAll: boolean,\n    multiline: boolean,\n  ): void {\n    // TODO - This may need a resolution at \"runtime\" so the instruction\n    // should reflect as such?\n    // See compiler.spec.ts - \"Test Back Named Groups\"\n    throw new Error(\"BackNumRef Not Implemented\");\n  }\n\n  protected compileBackNamedRef(\n    ne: BackNamedRef,\n    prog: Prog,\n    ignoreCase: boolean,\n    dotAll: boolean,\n    multiline: boolean,\n  ): void {\n    // TODO - This may need a resolution at \"runtime\" so the instruction\n    // should reflect as such?\n    // See compiler.spec.ts - \"Test Back Named Groups\"\n    throw new Error(\"BackNameRef Not Implemented\");\n  }\n\n  protected compileVar(v: Var, prog: Prog, ignoreCase: boolean, dotAll: boolean, multiline: boolean): void {\n    const name = v.name.trim();\n    const expr = this.regexResolver ? this.regexResolver(name) : null;\n    if (expr == null) {\n      throw new Error(`Cannot find expression: ${name}`);\n    }\n    this.compileExpr(expr, prog, ignoreCase, dotAll, multiline);\n  }\n\n  protected compileUnion(union: Union, prog: Prog, ignoreCase: boolean, dotAll: boolean, multiline: boolean): void {\n    const split = prog.add(OpCode.Split);\n    const jumps: Instr[] = [];\n\n    for (let i = 0; i < union.options.length; i++) {\n      split.add(prog.length);\n      this.compileExpr(union.options[i], prog, ignoreCase, dotAll, multiline);\n      if (i < union.options.length - 1) {\n        jumps.push(prog.add(OpCode.Jump));\n      }\n    }\n    for (const jmp of jumps) {\n      jmp.add(prog.length);\n    }\n  }\n\n  /**\n   * Compiles a repetition (with quantifiers) into its instructions.  This explicitly expands\n   * a rule of the form x\\{a,b\\} to xx... (a) times followed by x? (b - a) times\n   */\n  protected compileQuant(quant: Quant, prog: Prog, ignoreCase: boolean, dotAll: boolean, multiline: boolean): void {\n    // optimize the special cases of *, ? and +\n    if (quant.minCount == 0 && quant.maxCount == TSU.Constants.MAX_INT) {\n      // *\n      this.compileAtleast0(quant.expr, prog, quant.greedy, ignoreCase, dotAll, multiline);\n    } else if (quant.minCount == 1 && quant.maxCount == TSU.Constants.MAX_INT) {\n      // +\n      this.compileAtleast1(quant.expr, prog, quant.greedy, ignoreCase, dotAll, multiline);\n    } else if (quant.minCount == 0 && quant.maxCount == 1) {\n      // ?\n      this.compileOptional(quant.expr, prog, quant.greedy, ignoreCase, dotAll, multiline);\n    } else {\n      // general case - Currently going with Option 1\n      //\n      // - convert x{a,b} to xxxxxx (a) times followed by x? b - a times\n      for (let i = 0; i < quant.minCount; i++) {\n        this.compileExpr(quant.expr, prog, ignoreCase, dotAll, multiline);\n      }\n      // generate x? b - a times\n      if (quant.isUnlimited) {\n        // then generate a a* here\n        this.compileAtleast0(quant.expr, prog, quant.greedy, ignoreCase, dotAll, multiline);\n      } else {\n        for (let i = quant.minCount; i < quant.maxCount; i++) {\n          this.compileOptional(quant.expr, prog, quant.greedy, ignoreCase, dotAll, multiline);\n        }\n      }\n    }\n  }\n\n  protected compileAtleast1(\n    expr: Regex,\n    prog: Prog,\n    greedy = true,\n    ignoreCase: boolean,\n    dotAll: boolean,\n    multiline: boolean,\n  ): void {\n    const l1 = prog.length;\n    this.compileExpr(expr, prog, ignoreCase, dotAll, multiline);\n    const split = prog.add(OpCode.Split);\n    const l3 = prog.length;\n    if (greedy) {\n      split.add(l1, l3);\n    } else {\n      split.add(l3, l1);\n    }\n  }\n\n  protected compileAtleast0(\n    expr: Regex,\n    prog: Prog,\n    greedy: boolean,\n    ignoreCase: boolean,\n    dotAll: boolean,\n    multiline: boolean,\n  ): void {\n    const split = prog.add(OpCode.Split);\n    const l1 = split.offset;\n    const l2 = prog.length;\n    this.compileExpr(expr, prog, ignoreCase, dotAll, multiline);\n    prog.add(OpCode.Jump).add(l1);\n    const l3 = prog.length;\n    if (greedy) {\n      split.add(l2, l3);\n    } else {\n      split.add(l3, l2);\n    }\n  }\n\n  protected compileOptional(\n    expr: Regex,\n    prog: Prog,\n    greedy: boolean,\n    ignoreCase: boolean,\n    dotAll: boolean,\n    multiline: boolean,\n  ): void {\n    const split = prog.add(OpCode.Split);\n    const l1 = prog.length;\n    this.compileExpr(expr, prog, ignoreCase, dotAll, multiline);\n    const l2 = prog.length;\n    if (greedy) {\n      split.add(l1, l2);\n    } else {\n      split.add(l2, l1);\n    }\n  }\n\n  /**\n   * Compiles lookahead assertions\n   */\n  protected compileLookAhead(\n    la: LookAhead,\n    prog: Prog,\n    ignoreCase: boolean,\n    dotAll: boolean,\n    multiline: boolean,\n  ): void {\n    // how should this work?\n    // Ensure that assertion matches first before continuing with the expression\n    this.compileExpr(la.expr, prog, ignoreCase, dotAll, multiline);\n    const begin = prog.add(OpCode.Begin).add(0, la.negate ? 1 : 0); // negate if needed\n    this.compileExpr(la.cond, prog, ignoreCase, dotAll, multiline);\n    const end = prog.add(OpCode.End).add(begin.offset);\n    begin.add(end.offset);\n  }\n\n  /**\n   * Compiles lookback assertions\n   */\n  protected compileLookBack(lb: LookBack, prog: Prog, ignoreCase: boolean, dotAll: boolean, multiline: boolean): void {\n    // Ensure that assertion matches first before continuing with the expression\n    this.compileExpr(lb.expr, prog, ignoreCase, dotAll, multiline);\n    TSU.assert(lb.expr.groupIndex >= 0, \"LookBack Assertion requires expression to have a group Index\");\n    const begin = prog.add(OpCode.RBegin).add(lb.expr.groupIndex, lb.negate ? 1 : 0); // negate if needed\n    this.compileExpr(lb.cond.reverse(), prog, ignoreCase, dotAll, multiline);\n    const end = prog.add(OpCode.End).add(begin.offset);\n    begin.add(end.offset);\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { Token } from \"./token\";\n\nexport class TokenizerError extends Error {\n  readonly name: string = \"TokenizerError\";\n\n  constructor(\n    message: string,\n    public offset: number,\n    public length: number,\n    public type: string,\n    public value: any = null,\n  ) {\n    super(message);\n    Object.setPrototypeOf(this, new.target.prototype);\n  }\n}\n\nexport class UnexpectedTokenError extends Error {\n  readonly name: string = \"UnexpectedTokenError\";\n  expectedTokens: Token[];\n\n  constructor(public foundToken: TSU.Nullable<Token>, ...expectedTokens: Token[]) {\n    super(\n      `Found Token: ${foundToken?.tag || \"EOF\"} (${foundToken?.value || \"\"}), Expected: ${expectedTokens.join(\", \")}`,\n    );\n    this.expectedTokens = expectedTokens;\n  }\n}\n","export abstract class TapeInterface {\n  index = 0;\n  abstract charAt(index: number): string;\n  abstract hasIndex(index: number): boolean;\n  abstract substring(startIndex: number, endIndex: number): string;\n\n  constructor(public forward = true) {}\n\n  advance(delta = 1): boolean {\n    const next = this.forward ? this.index + delta : this.index - delta;\n    // if (!this.hasIndex(next)) return false;\n    this.index = next;\n    return true;\n  }\n\n  canAdvance(delta = 1): boolean {\n    const next = this.forward ? this.index + delta : this.index - delta;\n    return this.hasIndex(next);\n  }\n\n  get hasMore(): boolean {\n    const next = this.forward ? this.index : this.index - 1;\n    return this.hasIndex(next);\n    // return this.forward ? this.index < this.input.length : this.index > 0;\n  }\n\n  get currCh(): string {\n    return this.charAt(this.index);\n  }\n\n  get prevCh(): string {\n    return this.charAt(this.index - (this.forward ? 1 : -1));\n  }\n\n  get nextCh(): string {\n    const next = this.index + (this.forward ? 1 : -1);\n    return this.charAt(next);\n  }\n\n  get currChCode(): number {\n    if (!this.hasMore) return -1;\n    return this.currCh.charCodeAt(0);\n    // return this.input.charCodeAt(this.index);\n  }\n\n  get currChCodeLower(): number {\n    if (!this.hasMore) return -1;\n    return this.currCh.toLowerCase().charCodeAt(0);\n  }\n\n  get currChCodeUpper(): number {\n    if (!this.hasMore) return -1;\n    return this.currCh.toUpperCase().charCodeAt(0);\n  }\n\n  charCodeAt(index: number): number {\n    if (!this.hasIndex(index)) return -1;\n    return this.charAt(index).charCodeAt(0);\n  }\n\n  charCodeAtLower(index: number): number {\n    if (!this.hasIndex(index)) return -1;\n    return this.charAt(index).toLowerCase().charCodeAt(0);\n  }\n\n  charCodeAtUpper(index: number): number {\n    if (!this.hasIndex(index)) return -1;\n    return this.charAt(index).toUpperCase().charCodeAt(0);\n  }\n}\n\n/**\n * A Tape of characters we would read with some extra helpers like rewinding\n * forwarding and prefix checking that is fed into the different tokenizers\n * used by the scannerless parsers.\n */\nexport class Tape extends TapeInterface {\n  protected _rawInput: string;\n  readonly input: string[];\n\n  constructor(input: string, public forward = true) {\n    super(forward);\n    this._rawInput = input;\n    this.input = [...input];\n  }\n\n  push(content: string): void {\n    this._rawInput += content;\n    this.input.push(...content);\n  }\n\n  substring(startIndex: number, endIndex: number): string {\n    return this._rawInput.substring(startIndex, endIndex);\n    // return this.input.slice(startIndex, endIndex).join(\"\");\n  }\n\n  hasIndex(index: number): boolean {\n    return index >= 0 && index < this.input.length;\n  }\n\n  charAt(index: number): string {\n    if (index < 0 || index >= this.input.length) return \"\";\n    return this.input[index];\n  }\n}\n\nexport class TapeHelper {\n  /**\n   * Advances the tape to the end of the first occurence of\n   * the given pattern.\n   */\n  static advanceAfter(tape: TapeInterface, pattern: string, ensureNoPrefixSlash = true): number {\n    let pos = TapeHelper.advanceTo(tape, pattern, ensureNoPrefixSlash);\n    if (pos >= 0) {\n      pos += pattern.length;\n      tape.index = pos;\n    }\n    return pos;\n  }\n\n  /**\n   * Advances the tape till the start of a given pattern.\n   * This is not the most optimal implementation and just does a brute\n   * force search at each index.  Instead using the Regex interface\n   * directly will be faster.\n   */\n  static advanceTo(tape: TapeInterface, pattern: string, ensureNoPrefixSlash = true): number {\n    const lastIndex = tape.index;\n    while (tape.hasMore) {\n      const currStart = tape.index;\n      if (TapeHelper.matches(tape, pattern)) {\n        const endIndex = tape.index;\n        tape.index = currStart;\n        let numSlashes = 0;\n        if (ensureNoPrefixSlash) {\n          for (let i = endIndex - 1; i >= 0; i--) {\n            if (tape.charAt(i) == \"\\\\\") numSlashes++;\n            else break;\n          }\n        }\n        if (numSlashes % 2 == 0) {\n          return tape.index;\n        }\n      }\n      tape.advance(1);\n    }\n    tape.index = lastIndex;\n    throw new Error(`Unexpected end of input before (${pattern})`);\n    return -1;\n  }\n\n  /**\n   * Tells if the given prefix is matche at the current position of the tokenizer.\n   */\n  static matches(tape: TapeInterface, prefix: string, advance = true): boolean {\n    const lastIndex = tape.index;\n    let i = 0;\n    let success = true;\n    for (; i < prefix.length; i++) {\n      if (prefix[i] != tape.currCh) {\n        success = false;\n        break;\n      }\n      tape.advance(1);\n    }\n    // Reset pointers if we are only peeking or match failed\n    if (!advance || !success) {\n      tape.index = lastIndex;\n    }\n    return success;\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { TapeInterface as Tape } from \"./tape\";\nimport { TokenizerError, UnexpectedTokenError } from \"./errors\";\n\nexport type TokenType = number | string;\n\nexport class Token {\n  private static idCounter = 0;\n  // ID for uniquely identifying tokens if needed for shallow equality\n  id = Token.idCounter++;\n  value: any = null;\n  groups: TSU.NumMap<number[]> = {};\n  positions: TSU.NumMap<[number, number]> = {};\n  constructor(public tag: TokenType, public readonly matchIndex: number, public start: number, public end: number) {}\n\n  isOneOf(...expected: any[]): boolean {\n    for (const tok of expected) {\n      if (this.tag == tok) {\n        return true;\n      }\n    }\n    return false;\n  }\n}\n\nexport type NextTokenFunc = (tape: Tape, owner: any) => TSU.Nullable<Token>;\n\n/**\n * A wrapper on a tokenizer for providing features like k-lookahead, token\n * insertion, rewinding, expectation enforcement etc.\n */\nexport class TokenBuffer {\n  buffer: Token[] = [];\n\n  constructor(public readonly nextToken: NextTokenFunc, public tokenizerContext: any) {}\n\n  next(tape: Tape): TSU.Nullable<Token> {\n    const out = this.peek(tape);\n    if (out != null) {\n      this.consume();\n    }\n    return out;\n  }\n\n  /**\n   * Peek at the nth token in the token stream.\n   */\n  peek(tape: Tape, nth = 0): TSU.Nullable<Token> {\n    while (this.buffer.length <= nth) {\n      const tok = this.nextToken(tape, this.tokenizerContext);\n      if (tok == null) return null;\n      this.buffer.push(tok);\n    }\n    return this.buffer[nth];\n  }\n\n  match(\n    tape: Tape,\n    matchFunc: (token: Token) => boolean,\n    ensure = false,\n    consume = true,\n    nextAction?: (token: Token) => boolean | undefined,\n  ): TSU.Nullable<Token> {\n    const token = this.peek(tape);\n    if (token != null) {\n      if (matchFunc(token)) {\n        if (nextAction && nextAction != null) {\n          nextAction(token);\n        }\n        if (consume) {\n          this.consume();\n        }\n      } else if (ensure) {\n        // Should we throw an error?\n        throw new UnexpectedTokenError(token);\n      } else {\n        return null;\n      }\n    } else if (ensure) {\n      throw new TokenizerError(\"Unexpected end of input\", -1, 0, \"UnexpectedEndOfInput\");\n    }\n    return token;\n  }\n\n  consume(): void {\n    this.buffer.splice(0, 1);\n  }\n\n  consumeIf(tape: Tape, ...expected: TokenType[]): TSU.Nullable<Token> {\n    return this.match(tape, (t) => t.isOneOf(...expected));\n  }\n\n  expectToken(tape: Tape, ...expected: TokenType[]): Token {\n    return this.match(tape, (t) => t.isOneOf(...expected), true, true) as Token;\n  }\n\n  ensureToken(tape: Tape, ...expected: TokenType[]): Token {\n    return this.match(tape, (t) => t.isOneOf(...expected), true, false) as Token;\n  }\n\n  nextMatches(tape: Tape, ...expected: TokenType[]): TSU.Nullable<Token> {\n    const token = this.peek(tape);\n    if (token == null) return null;\n    for (const tok of expected) {\n      if (token.tag == tok) return token;\n    }\n    return null;\n  }\n}\n","export class GroupCounter {\n  value = -1;\n  next(): number {\n    return ++this.value;\n  }\n  get current(): number {\n    return this.value;\n  }\n}\n\nexport function isSpace(ch: string): boolean {\n  return ch == \" \" || ch == \"\\t\" || ch == \"\\n\" || ch == \"\\r\";\n}\n\n// function isSpaceChar(ch: string): boolean { return ch == \" \" || ch == \"\\t\"; }\n","import * as TSU from \"@panyam/tsutils\";\nimport {\n  Quant,\n  RegexType,\n  StartOfInput,\n  EndOfInput,\n  Regex,\n  Cat,\n  Char,\n  LeafChar,\n  CharGroup,\n  CharType,\n  Var,\n  BackNamedRef,\n  BackNumRef,\n  LookAhead,\n  LookBack,\n  Union,\n} from \"./core\";\nimport { CharClassType } from \"./charclasses\";\nimport { GroupCounter } from \"./utils\";\n\n/**\n * A RegexParser for parsing regex strings in JS RegExp format.\n * This class will seldom have to be used directly.  Instead use one of the methods in {@link Builder}\n */\nexport class RegexParser {\n  protected unicode: boolean;\n  protected counter: GroupCounter;\n  /**\n   * @param pattern The pattern string being parsed.\n   * @param config  Configs for the regex to include whether parsing is unicode or plain ASCII.\n   */\n  constructor(public readonly pattern: string, config?: { unicode?: boolean }) {\n    this.counter = new GroupCounter();\n    this.unicode = config?.unicode || false;\n  }\n\n  protected reduceLeft(stack: Regex[]): Regex {\n    const r = stack.length == 1 ? stack[0] : new Cat(...stack);\n    // remove all elements on stack\n    stack.splice(0);\n    return r;\n  }\n\n  protected throwError(msg: string): void {\n    throw new SyntaxError(`Error in JS RE '${this.pattern}': ${msg}`);\n  }\n\n  /**\n   * Creates a regex tree given a string\n   */\n  parse(curr = 0, end = -1): Regex {\n    const pattern = this.pattern;\n    const stack: Regex[] = [];\n    if (end < 0) end = pattern.length - 1;\n    while (curr <= end) {\n      const currCh = pattern[curr];\n      // see if we have groups so they get highest preference\n      if (currCh == \".\") {\n        stack.push(LeafChar.Any());\n        curr++;\n      } else if (currCh == \"\\\\\" && pattern[curr + 1] >= \"1\" && pattern[curr + 1] <= \"9\") {\n        // Numeric references\n        curr++;\n        let num = \"\";\n        while (curr <= end && pattern[curr] >= \"0\" && pattern[curr] <= \"9\") {\n          num = num + pattern[curr++];\n        }\n        const refNum = parseInt(num);\n        if (refNum > this.counter.current + 1) {\n          this.throwError(\"Invalid reference: \" + refNum);\n        }\n        stack.push(new BackNumRef(refNum));\n      } else if (currCh == \"\\\\\" && pattern[curr + 1] == \"k\" && pattern[curr + 2] == \"<\") {\n        // Named references\n        curr += 3;\n        let gtPos = curr;\n        while (gtPos <= end && pattern[gtPos] != \">\") gtPos++;\n        if (gtPos > end) this.throwError(\"Expected '>' found EOI\");\n        const name = pattern.substring(curr, gtPos);\n        if (name.trim() == \"\") {\n          this.throwError(\"Expected name\");\n        }\n        stack.push(new BackNamedRef(name));\n        curr = gtPos + 1;\n      } else if (currCh == \"[\") {\n        // character ranges\n        let clPos = curr + 1;\n        while (clPos <= end && pattern[clPos] != \"]\") {\n          if (pattern[clPos] == \"\\\\\") clPos++;\n          clPos++;\n        }\n        if (clPos > end) this.throwError(\"Expected ']' found EOI\");\n        stack.push(this.parseCharGroup(curr + 1, clPos - 1));\n        curr = clPos + 1;\n      } else if (currCh == \"^\") {\n        stack.push(new StartOfInput());\n        curr++;\n      } else if (currCh == \"$\") {\n        stack.push(new EndOfInput());\n        curr++;\n      } else if (currCh == \"|\") {\n        if (curr + 1 <= end) {\n          // reduce everything \"until now\" and THEN apply\n          const prev = this.reduceLeft(stack);\n          // this.parse everything to the right\n          const rest = this.parse(curr + 1, end);\n          return new Union(prev, rest);\n        }\n        curr = end + 1;\n      } else if (currCh == \"(\") {\n        curr = this.parseGroup(stack, curr, end);\n      } else if (currCh == \")\" || currCh == \"]\" || currCh == \"}\") {\n        this.throwError(`Unmatched ${currCh}.  Try using \\\\${currCh}`);\n      } else if (pattern[curr] == \"*\" || pattern[curr] == \"?\" || pattern[curr] == \"+\" || pattern[curr] == \"{\") {\n        curr = this.parseQuant(stack, curr, end);\n      } else {\n        // plain old alphabets\n        const [result, nchars] = this.parseChar(curr, end);\n        stack.push(result);\n        curr += nchars;\n      }\n    }\n    if (stack.length <= 0) {\n      // this.throwError(`Invalid Regex (${curr} - ${end}): ${pattern}`);\n    }\n    if (stack.length == 1) return stack[0];\n    return new Cat(...stack);\n  }\n\n  protected parseGroup(stack: Regex[], curr: number, end: number): number {\n    // we have a grouping or an assertion\n    let clPos = curr + 1;\n    let depth = 0;\n    const pattern = this.pattern;\n    while (clPos <= end && (pattern[clPos] != \")\" || depth > 0)) {\n      if (pattern[clPos] == \"(\") depth++;\n      else if (pattern[clPos] == \")\") depth--;\n      if (pattern[clPos] == \"\\\\\") clPos++;\n      clPos++;\n    }\n    if (clPos > end) this.throwError(\"Expected ')' found EOI\");\n\n    curr++;\n    if (pattern[curr] == \"?\") {\n      // assertions\n      curr++; // skip the \"?\"\n      if (pattern[curr] == \":\") {\n        // A non capturing\n        stack.push(this.parse(curr + 1, clPos - 1));\n      } else if (pattern[curr] == \"<\" && pattern[curr + 1] != \"!\" && pattern[curr + 1] != \"=\") {\n        // Named capture group\n        const groupIndex = this.counter.next();\n        let groupName = \"\";\n        // get name of this group\n        let gtPos = curr + 1;\n        while (gtPos <= end && pattern[gtPos] != \">\") {\n          groupName += pattern[gtPos];\n          gtPos++;\n        }\n        const subExpr = this.parse(gtPos + 1, clPos - 1);\n        subExpr.groupIndex = groupIndex;\n        if (groupName.length > 0) subExpr.groupName = groupName;\n      } else {\n        // We have lookback/ahead assertions\n        let after = true;\n        if (pattern[curr] == \"<\") {\n          curr++;\n          after = false;\n        }\n        const neg = pattern[curr++] == \"!\";\n        const cond = this.parse(curr, clPos - 1);\n        if (after) {\n          // reduce everything \"until now\" and THEN apply\n          if (stack.length == 0) {\n            // this.throwError(\"LookAhead condition cannot be before empty rule\");\n          }\n          // const endIndex = stack.length - 1;\n          // stack[endIndex] = new LookAhead(stack[endIndex], cond, neg);\n          const expr = new LookAhead(this.reduceLeft(stack), cond, neg);\n          stack.push(expr);\n        } else {\n          // Lookbacks are interesting, we have something like:\n          // (?<!...)abcde\n          // clPos points to \")\" We need abcde also parsed\n          // and then lookback applied to it\n          const rest = this.parse(clPos + 1, end);\n          if (rest.groupIndex < 0) {\n            rest.groupIndex = this.counter.next();\n            rest.groupIsSilent = true;\n          }\n          stack.push(new LookBack(rest, cond, neg));\n          return end + 1;\n        }\n      }\n    } else {\n      // plain old grouping of the form (xyz)\n      const groupIndex = this.counter.next();\n      let neg = false;\n      if (pattern[curr] == \"^\") {\n        neg = true;\n        curr++;\n      }\n      let subExpr = this.parse(curr, clPos - 1);\n      // if (neg) subExpr = new Neg(subExpr);\n      // Do the next before the previous call if we want group\n      // index to match outer brackets first\n      if (subExpr.groupIndex >= 0) {\n        // Already set so create cat\n        subExpr = new Cat(subExpr);\n      }\n      subExpr.groupIndex = groupIndex;\n      stack.push(subExpr);\n    }\n    return clPos + 1;\n  }\n\n  protected parseCharGroup(curr: number, end: number): Char {\n    const out: Char[] = [];\n    // first see which characters are in this (until the end)\n    let i = curr;\n    let neg = false;\n    const pattern = this.pattern;\n    if (pattern[i] == \"^\") {\n      neg = true;\n      i++;\n    }\n    for (; i <= end; ) {\n      const [currch, nchars] = this.parseChar(i, end);\n      i += nchars;\n      if (i < pattern.length && pattern[i] == \"-\") {\n        i++;\n        // TODO - Should this be for all such \"operator\" charactors?\n        if (pattern[i] == \"]\" || pattern[i] == \"[\") {\n          // Special case for something like:\n          // [....x-] or [.....x-[:alpha:]]\n          out.push(currch);\n          out.push(LeafChar.Single(\"-\"));\n        } else if (i <= end) {\n          const [endch, nchars] = this.parseChar(i, end);\n          if (currch.op != CharType.SingleChar || endch.op != CharType.SingleChar) {\n            this.throwError(\"Char range cannot start or end in a char class\");\n          }\n          if (endch.args[0] < currch.args[0]) {\n            this.throwError(\"End cannot be less than start\");\n          }\n          out.push(CharGroup.Range(currch, endch));\n          i += nchars;\n        } else {\n          this.throwError(\"Unterminated char class\");\n        }\n      } else {\n        out.push(currch);\n      }\n    }\n    return CharGroup.Union(neg, out);\n  }\n\n  protected parseChar(index = 0, end = 0): [LeafChar, number] {\n    if (this.pattern[index] == \"\\\\\") {\n      return this.parseEscapeChar(index, end);\n    } else {\n      return this.parseSingleChar(index, end);\n    }\n  }\n\n  protected parseSingleChar(index = 0, end = 0): [LeafChar, number] {\n    // single char\n    const ch = this.pattern.charCodeAt(index);\n    return [LeafChar.Single(ch), 1];\n  }\n\n  protected parsePropertyEscape(index = 0, end = 0): [LeafChar, number] {\n    const pattern = this.pattern;\n    if (pattern[index] + 1 != \"{\") {\n      this.throwError(\"Invalid property escape\");\n    }\n    index += 2;\n    let clEnd = index;\n    let eqPos = -1;\n    while (clEnd <= end && pattern[clEnd] != \"}\") {\n      if (pattern[clEnd] == \"=\") eqPos = clEnd;\n      clEnd++;\n    }\n    if (clEnd > end) {\n      this.throwError(\"Invalid property escape\");\n    }\n    // see if this is a lone property escape\n    const propStr = pattern.substring(index, clEnd);\n    let propName = \"General_Category\";\n    let propValue = propStr;\n    if (eqPos >= 0) {\n      const parts = propStr.split(\"=\");\n      if (parts.length != 2) this.throwError(\"Invalid property escape\");\n      propName = parts[0].trim();\n      propValue = parts[1].trim();\n    }\n    return [LeafChar.PropertyEscape(propName, propValue), 2 + clEnd + 1 - index];\n  }\n\n  protected parseEscapeChar(index = 0, end = 0): [LeafChar, number] {\n    const pattern = this.pattern;\n    TSU.assert(pattern[index] == \"\\\\\", \"Expected '\\\\'\");\n    // escape char\n    index++;\n    if (index > end) {\n      this.throwError(\"Encounted unexpected end of input after \\\\\");\n    }\n    const ch = pattern[index];\n    if ((this.unicode && ch == \"p\") || ch == \"P\") {\n      // property escapes\n      return this.parsePropertyEscape(index, end);\n    }\n    switch (ch) {\n      // char classes\n      case \"w\":\n        return [LeafChar.Class(CharClassType.WORD_CHAR), 2];\n      case \"W\":\n        return [LeafChar.Class(CharClassType.WORD_CHAR, true), 2];\n      case \"d\":\n        return [LeafChar.Class(CharClassType.DIGITS), 2];\n      case \"D\":\n        return [LeafChar.Class(CharClassType.DIGITS, true), 2];\n      case \"s\":\n        return [LeafChar.Class(CharClassType.SPACES), 2];\n      case \"S\":\n        return [LeafChar.Class(CharClassType.SPACES, true), 2];\n      case \"0\":\n        if (pattern[index + 1] >= \"0\" && pattern[index + 1] <= \"9\" && this.unicode) {\n          this.throwError(\"Invalid decimal escape\");\n        }\n        return [LeafChar.Single(\"\\0\"), 2];\n      case \"r\":\n        return [LeafChar.Single(\"\\r\"), 2];\n      case \"n\":\n        return [LeafChar.Single(\"\\n\"), 2];\n      case \"f\":\n        return [LeafChar.Single(\"\\f\"), 2];\n      case \"b\":\n        return [LeafChar.Single(\"\\b\"), 2];\n      case \"v\":\n        return [LeafChar.Single(\"\\v\"), 2];\n      case \"t\":\n        return [LeafChar.Single(\"\\t\"), 2];\n      case \"c\":\n        // ControlEscape:\n        // https://262.ecma-international.org/5.1/#sec-15.10.2.10\n        if (this.unicode || index >= end) {\n          this.throwError(`Invalid char sequence at ${index}, ${end}`);\n        }\n        const next = pattern.charCodeAt(index + 1) % 32;\n        return [LeafChar.Single(next), 3];\n      case \"x\":\n        // 2 digit hex digits\n        index++;\n        if (index >= end) {\n          this.throwError(`Invalid hex sequence at ${index}, ${end}`);\n        }\n        const hexSeq = pattern.substring(index, index + 2);\n        const hexVal = parseInt(hexSeq, 16);\n        TSU.assert(!isNaN(hexVal), `Invalid hex sequence: '${hexSeq}'`);\n        return [LeafChar.Single(hexVal), 4];\n      case \"u\": // this could \\uABCD or \\u{ABCDEF}\n        index++;\n        // 4 digit hex digits for unicode\n        if (index > end - 3) {\n          this.throwError(`Invalid unicode sequence at ${index}`);\n        }\n        const ucodeSeq = pattern.substring(index, index + 4);\n        const ucodeVal = parseInt(ucodeSeq, 16);\n        if (isNaN(ucodeVal)) {\n          this.throwError(`Invalid unicode sequence: '${ucodeSeq}'`);\n        }\n        return [LeafChar.Single(ucodeVal), 6];\n      case \"^\": // List of special operators that need to be escaped\n      case \"$\":\n      case \".\":\n      case \"*\":\n      case \"+\":\n      case \"?\":\n      case \"\\\\\":\n      case \"'\":\n      case '\"':\n      case \"(\":\n      case \")\":\n      case \"[\":\n      case \"]\":\n      case \"{\":\n      case \"}\":\n      case \"|\":\n      case \"/\":\n        return [LeafChar.Single(ch), 2];\n      default:\n        if (this.unicode) this.throwError(\"Invalid escape character: \" + ch);\n        return [LeafChar.Single(ch), 2];\n    }\n  }\n\n  protected parseQuant(stack: Regex[], curr: number, end: number): number {\n    const pattern = this.pattern;\n    const lastCh = pattern[curr - 1];\n    let minCount = 1,\n      maxCount = 1;\n    if (pattern[curr] == \"*\") {\n      minCount = 0;\n      maxCount = TSU.Constants.MAX_INT;\n    } else if (pattern[curr] == \"+\") {\n      minCount = Math.min(minCount, 1);\n      maxCount = TSU.Constants.MAX_INT;\n    } else if (pattern[curr] == \"?\") {\n      minCount = 0;\n      maxCount = Math.max(maxCount, 1);\n    } else if (pattern[curr] == \"{\") {\n      // find the next \"}\"\n      const clPos = pattern.indexOf(\"}\", curr + 1);\n      if (clPos <= curr || clPos > end) {\n        this.throwError(\"Unexpected end of input while looking for '}'\");\n      }\n      const sub = pattern.substring(curr + 1, clPos).trim();\n      const parts = sub.split(\",\").map((x) => parseInt(x.trim()));\n      curr = clPos;\n      if (parts.length == 1) {\n        if (isNaN(parts[0])) {\n          if (sub.trim().length > 0) {\n            stack.push(new Var(sub.trim()));\n            return curr + 1;\n          } else {\n            this.throwError(`Invalid quantifier: /${sub}/`);\n          }\n        }\n        minCount = maxCount = parts[0];\n      } else if (parts.length == 2) {\n        minCount = isNaN(parts[0]) ? 0 : parts[0];\n        maxCount = isNaN(parts[1]) ? TSU.Constants.MAX_INT : parts[1];\n        if (minCount > maxCount) {\n          this.throwError(`Invalid Quant /${sub}/: Min must be <= Max`);\n        }\n      } else if (parts.length > 2) {\n        this.throwError(`Invalid quantifier spec: \"{${sub}}\"`);\n      }\n    } else {\n      throw new Error(\"Here?\");\n    }\n    // Quantifiers\n    if (stack.length <= 0) {\n      this.throwError(\"Quantifier cannot appear before an expression\");\n    }\n    // no optimizations - convert the last one into a Quantifier\n    // and we will start to fill in the quantities and greediness\n    const last = stack[stack.length - 1];\n    if (last.tag == RegexType.QUANT && (lastCh == \"*\" || lastCh == \"?\" || lastCh == \"+\" || lastCh == \"}\")) {\n      this.throwError(\"Nothing to repeat\");\n    }\n    if (this.unicode && (last.tag == RegexType.LOOK_AHEAD || last.tag == RegexType.LOOK_BACK)) {\n      this.throwError(\"Cannot have quantifier on assertion in unicode mode\");\n    }\n    const quant = (stack[stack.length - 1] = new Quant(last));\n    quant.minCount = minCount;\n    quant.maxCount = maxCount;\n    // check if there is an extra lazy quantifier\n    curr++;\n    if (curr <= end && pattern[curr] == \"?\" && quant.greedy) {\n      curr++;\n      quant.greedy = false;\n    }\n    return curr;\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { TapeInterface as Tape } from \"./tape\";\nimport {\n  LookAhead,\n  Quant,\n  RegexType,\n  StartOfInput,\n  EndOfInput,\n  Regex,\n  Cat,\n  CharType,\n  Char,\n  LeafChar,\n  CharGroup,\n  Var,\n  Union,\n} from \"./core\";\nimport { CharClassType } from \"./charclasses\";\nimport { GroupCounter, isSpace } from \"./utils\";\n\nfunction advanceIf(tape: Tape, ch: string): boolean {\n  const pos = tape.index;\n  for (let i = 0; i < ch.length; i++) {\n    if (tape.currCh != ch.charAt(i)) {\n      tape.index = pos;\n      return false;\n    }\n    tape.advance(1);\n  }\n  return true;\n}\n\n/**\n * A RegexParser for parsing regex strings in Flex RE format.\n * This class will seldom have to be used directly.  Instead use one of the methods in {@link Builder}\n */\nexport class RegexParser {\n  protected counter: GroupCounter = new GroupCounter();\n\n  parse(pattern: Tape, ignoreSpaces = false, obCount = 0): Regex {\n    const stack: Regex[] = [];\n\n    while (pattern.hasMore) {\n      const currCh = pattern.currCh;\n      // see if we have groups so they get highest preference\n      if (advanceIf(pattern, \".\")) {\n        stack.push(LeafChar.Any());\n      } else if (advanceIf(pattern, \"^\")) {\n        const x = new StartOfInput();\n        x.multiline = true;\n        stack.push(x);\n      } else if (advanceIf(pattern, \"$\")) {\n        const x = new EndOfInput();\n        x.multiline = true;\n        stack.push(x);\n      } else if (advanceIf(pattern, \"|\")) {\n        // reduce everything \"until now\" and THEN apply\n        const prev = this.reduceLeft(stack);\n        // this.parse everything to the right\n        const rest = this.parse(pattern, ignoreSpaces, obCount);\n        return new Union(prev, rest);\n      } else if (currCh == \"[\") {\n        stack.push(this.parseCharGroup(pattern));\n      } else if (currCh == \"*\" || currCh == \"?\" || currCh == \"+\" || currCh == \"{\") {\n        this.parseQuant(pattern, stack);\n      } else if (ignoreSpaces && isSpace(currCh)) {\n        // do nothing\n        pattern.advance(1);\n      } else if (ignoreSpaces && advanceIf(pattern, \"/*\")) {\n        // Read everything until a */\n        while (pattern.currCh != \"*\" || pattern.nextCh != \"/\") {\n          if (!pattern.hasMore) {\n            this.throwError(pattern, \"Unterminated comment\");\n          }\n          pattern.advance(1);\n        }\n        pattern.advance(2);\n        // now do nothing\n      } else if (advanceIf(pattern, \"{-}\")) {\n        // char class intersection\n        throw new Error(\"Intersection Not yet supported\");\n      } else if (advanceIf(pattern, \"{+}\")) {\n        // char class union\n        throw new Error(\"Union Not yet supported\");\n      } else if (advanceIf(pattern, \"(\")) {\n        if (advanceIf(pattern, \"?\")) {\n          if (advanceIf(pattern, \"#\")) {\n            while (pattern.hasMore && pattern.currCh != \")\") pattern.advance(1);\n            TSU.assert(advanceIf(pattern, \")\"), \"Expected ')'\");\n          } else {\n            // pattern of the form (?r-s:pattern)\n            let ignoreCase = false;\n            let dotAll = false;\n            let ignoreSpaces2 = ignoreSpaces as boolean;\n            let neg = false;\n            while (pattern.hasMore && pattern.currCh != \":\") {\n              if (pattern.currCh == \"i\") {\n                ignoreCase = neg ? false : true;\n              } else if (pattern.currCh == \"s\") {\n                dotAll = neg ? false : true;\n              } else if (pattern.currCh == \"x\") {\n                ignoreSpaces2 = neg ? false : true;\n              } else if (pattern.currCh == \"-\") {\n                neg = true;\n              }\n              pattern.advance(1);\n            }\n            TSU.assert(advanceIf(pattern, \":\"), \"Expected ':'\");\n            const groupIndex = this.counter.next();\n            let subExpr = this.parse(pattern, ignoreSpaces2, obCount + 1);\n            if (subExpr.groupIndex >= 0) {\n              // Already set so create cat\n              subExpr = new Cat(subExpr);\n            }\n            subExpr.dotAll = dotAll;\n            subExpr.ignoreCase = ignoreCase;\n            subExpr.groupIndex = groupIndex;\n            stack.push(subExpr);\n            TSU.assert(advanceIf(pattern, \")\"), \"Expected ')'\");\n          }\n        } else {\n          // parse the subgroup and give it a group number\n          const groupIndex = this.counter.next();\n          let subExpr = this.parse(pattern, ignoreSpaces, obCount + 1);\n          if (subExpr.groupIndex >= 0) {\n            // Already set so create cat\n            subExpr = new Cat(subExpr);\n          }\n          subExpr.groupIndex = groupIndex;\n          stack.push(subExpr);\n          TSU.assert(advanceIf(pattern, \")\"), \"Expected ')'\");\n        }\n      } else if (currCh == \")\") {\n        if (obCount == 0) {\n          this.throwError(pattern, `Unmatched ${currCh}.  Try using \\\\${currCh}`);\n        }\n        // stop here so we can recurse up\n        break;\n      } else if (currCh == \"]\" || currCh == \"}\") {\n        this.throwError(pattern, `Unmatched ${currCh}.  Try using \\\\${currCh}`);\n      } else if (advanceIf(pattern, \"/\")) {\n        // LookAheads\n        const prev = this.reduceLeft(stack);\n        // this.parse everything to the right\n        const rest = this.parse(pattern, ignoreSpaces, obCount);\n        return new LookAhead(prev, rest, false);\n      } else if (advanceIf(pattern, '\"')) {\n        // raw string\n        while (pattern.currCh != '\"') {\n          if (!pattern.hasMore) {\n            this.throwError(pattern, \"Unterminated string\");\n          }\n          stack.push(this.parseChar(pattern));\n        }\n        pattern.advance(1);\n      } else {\n        // plain old alphabets\n        stack.push(this.parseChar(pattern));\n      }\n    }\n    if (stack.length == 1) return stack[0];\n    return new Cat(...stack);\n  }\n\n  protected parseQuant(pattern: Tape, stack: Regex[]): void {\n    let minCount = 1,\n      maxCount = 1;\n    if (advanceIf(pattern, \"*\")) {\n      minCount = 0;\n      maxCount = TSU.Constants.MAX_INT;\n    } else if (advanceIf(pattern, \"+\")) {\n      minCount = Math.min(minCount, 1);\n      maxCount = TSU.Constants.MAX_INT;\n    } else if (advanceIf(pattern, \"?\")) {\n      minCount = 0;\n      maxCount = Math.max(maxCount, 1);\n    } else if (advanceIf(pattern, \"{\")) {\n      let foundComma = false;\n      let p1 = \"\";\n      let p2 = \"\";\n      while (pattern.hasMore && pattern.currCh != \"}\") {\n        if (pattern.currCh == \",\") foundComma = true;\n        else {\n          if (!foundComma) p1 += pattern.currCh;\n          else p2 += pattern.currCh;\n        }\n        pattern.advance(1);\n      }\n      if (!pattern.hasMore) {\n        this.throwError(pattern, \"Invalid property escape\");\n      }\n      // see if this is a lone property escape\n      p1 = p1.trim();\n      p2 = p2.trim();\n      // advance over the \"}\"\n      pattern.advance(1);\n\n      const part1 = parseInt(p1);\n      const part2 = parseInt(p2);\n      if (foundComma) {\n        minCount = isNaN(part1) ? 0 : part1;\n        maxCount = isNaN(part2) ? TSU.Constants.MAX_INT : part2;\n        if (minCount > maxCount) {\n          this.throwError(pattern, `Invalid Quant /${p1},${p2}/: Min must be <= Max`);\n        }\n      } else {\n        if (isNaN(part1)) {\n          if (p1.length > 0) {\n            stack.push(new Var(p1));\n            // nothing more\n            return;\n          } else {\n            this.throwError(pattern, `Invalid quantifier: /${p1}/`);\n          }\n          minCount = maxCount = 1;\n        } else {\n          minCount = maxCount = part1;\n        }\n      }\n    } else {\n      this.throwError(pattern, \"Expected '{', '*', '?' or '+', Found: \" + pattern.currCh);\n    }\n    // Quantifiers\n    if (stack.length <= 0) {\n      this.throwError(pattern, \"Quantifier cannot appear before an expression\");\n    }\n    // no optimizations - convert the last one into a Quantifier\n    // and we will start to fill in the quantities and greediness\n    const last = stack[stack.length - 1];\n    let quant: Quant;\n    if (last.tag == RegexType.QUANT && last.groupIndex < 0) {\n      // Fold repeated quants unless they are not in a group\n      quant = last as Quant;\n      quant.minCount = Math.min(minCount, quant.minCount);\n      quant.maxCount = Math.max(maxCount, quant.maxCount);\n    } else {\n      quant = stack[stack.length - 1] = new Quant(last);\n      quant.minCount = minCount;\n      quant.maxCount = maxCount;\n    }\n    // check if there is an extra lazy quantifier\n    if (quant.greedy && advanceIf(pattern, \"?\")) {\n      quant.greedy = false;\n    }\n  }\n\n  protected parseCharGroup(pattern: Tape): Char {\n    const out: Char[] = [];\n    TSU.assert(advanceIf(pattern, \"[\"), \"Expected '['\");\n    // first see which characters are in this (until the end)\n    const neg = advanceIf(pattern, \"^\");\n    while (pattern.currCh != \"]\") {\n      const currch = this.parseChar(pattern);\n      if (advanceIf(pattern, \"-\")) {\n        if (pattern.hasMore) {\n          // TODO - Should this be for all such \"operator\" charactors?\n          if (pattern.currCh == \"]\" || pattern.currCh == \"[\") {\n            // Special case for something like:\n            // [....x-] or [.....x-[:alpha:]]\n            out.push(currch);\n            out.push(LeafChar.Single(\"-\"));\n          } else {\n            const endch = this.parseChar(pattern);\n            if (currch.op != CharType.SingleChar || endch.op != CharType.SingleChar) {\n              this.throwError(pattern, \"Char range cannot start or end in a char class\");\n            }\n            if (endch.args[0] < currch.args[0]) {\n              this.throwError(pattern, \"End cannot be less than start\");\n            }\n            // currch.end = endch.start;\n            out.push(CharGroup.Range(currch, endch));\n          }\n        } else {\n          this.throwError(pattern, \"Unterminated char class\");\n        }\n      } else {\n        out.push(currch);\n      }\n    }\n    TSU.assert(advanceIf(pattern, \"]\"), \"']' expected\");\n    return CharGroup.Union(neg, out);\n  }\n\n  protected parseChar(pattern: Tape): LeafChar {\n    if (pattern.currCh == \"\\\\\") {\n      return this.parseEscapeChar(pattern);\n    } else {\n      return this.parseSingleChar(pattern);\n    }\n  }\n\n  protected parseSingleChar(pattern: Tape): LeafChar {\n    // single char\n    const ch = pattern.currCh;\n    pattern.advance(1);\n    return LeafChar.Single(ch);\n  }\n\n  protected parsePropertyEscape(pattern: Tape): LeafChar {\n    TSU.assert(advanceIf(pattern, \"\\\\{\"), \"Invalid property escape\");\n    pattern.advance(2);\n    let foundEq = false;\n    let propName = \"\";\n    let propValue = \"\";\n    while (pattern.hasMore && pattern.currCh != \"}\") {\n      if (pattern.currCh == \"=\") foundEq = true;\n      else {\n        if (!foundEq) propName += pattern.currCh;\n        else propValue += pattern.currCh;\n      }\n      pattern.advance(1);\n    }\n    if (!pattern.hasMore) {\n      this.throwError(pattern, \"Invalid property escape\");\n    }\n    // see if this is a lone property escape\n    propName = propName.trim();\n    propValue = propValue.trim();\n    if (!foundEq) {\n      propValue = propName;\n      propName = \"General_Category\";\n    }\n    // advance over the \"}\"\n    pattern.advance(1);\n    return LeafChar.PropertyEscape(propName, propValue);\n  }\n\n  protected parseEscapeChar(pattern: Tape): LeafChar {\n    TSU.assert(advanceIf(pattern, \"\\\\\"), \"Expected '\\\\'\");\n    // escape char\n    if (!pattern.hasMore) {\n      this.throwError(pattern, \"Encounted unexpected end of input after \\\\\");\n    }\n    if (advanceIf(pattern, \"w\")) {\n      return LeafChar.Class(CharClassType.WORD_CHAR);\n    } else if (advanceIf(pattern, \"W\")) {\n      return LeafChar.Class(CharClassType.WORD_CHAR, true);\n    } else if (advanceIf(pattern, \"d\")) {\n      return LeafChar.Class(CharClassType.DIGITS);\n    } else if (advanceIf(pattern, \"D\")) {\n      return LeafChar.Class(CharClassType.DIGITS, true);\n    } else if (advanceIf(pattern, \"s\")) {\n      return LeafChar.Class(CharClassType.SPACES);\n    } else if (advanceIf(pattern, \"S\")) {\n      return LeafChar.Class(CharClassType.SPACES, true);\n    } else if (advanceIf(pattern, \"0\")) {\n      return LeafChar.Single(\"\\0\");\n    } else if (advanceIf(pattern, \"r\")) {\n      return LeafChar.Single(\"\\r\");\n    } else if (advanceIf(pattern, \"n\")) {\n      return LeafChar.Single(\"\\n\");\n    } else if (advanceIf(pattern, \"f\")) {\n      return LeafChar.Single(\"\\f\");\n    } else if (advanceIf(pattern, \"b\")) {\n      return LeafChar.Single(\"\\b\");\n    } else if (advanceIf(pattern, \"v\")) {\n      return LeafChar.Single(\"\\v\");\n    } else if (advanceIf(pattern, \"t\")) {\n      return LeafChar.Single(\"\\t\");\n    } else if (advanceIf(pattern, \"\\\\\")) {\n      return LeafChar.Single(\"\\\\\");\n    } else if (advanceIf(pattern, \"'\")) {\n      return LeafChar.Single(\"'\");\n    } else if (advanceIf(pattern, '\"')) {\n      return LeafChar.Single('\"');\n    } else if (advanceIf(pattern, \"x\")) {\n      // 2 digit hex digits\n      if (!pattern.hasMore) {\n        this.throwError(pattern, `Invalid hex sequence at ${pattern.index}`);\n      }\n      const hexSeq = pattern.currCh + pattern.nextCh;\n      const hexVal = parseInt(hexSeq, 16);\n      TSU.assert(!isNaN(hexVal), `Invalid hex sequence: '${hexSeq}'`);\n      pattern.advance(2);\n      return LeafChar.Single(hexVal);\n    } else if (advanceIf(pattern, \"u\")) {\n      // 4 digit hex digits for unicode\n      if (!pattern.canAdvance(3)) {\n        // index >= pattern.input.length - 3) {\n        this.throwError(pattern, `Invalid unicode sequence at ${pattern.index}`);\n      }\n      const ucodeSeq = pattern.substring(pattern.index, pattern.index + 4);\n      const ucodeVal = parseInt(ucodeSeq, 16);\n      if (isNaN(ucodeVal)) {\n        this.throwError(pattern, `Invalid unicode sequence: '${ucodeSeq}'`);\n      }\n      pattern.advance(4);\n      return LeafChar.Single(ucodeVal);\n    }\n    // default\n    const ch = pattern.currCh;\n    pattern.advance(1);\n    return LeafChar.Single(ch);\n  }\n\n  protected reduceLeft(stack: Regex[]): Regex {\n    const r = stack.length == 1 ? stack[0] : new Cat(...stack);\n    // remove all elements on stack\n    stack.splice(0);\n    return r;\n  }\n\n  protected throwError(pattern: Tape, msg: string): void {\n    throw new Error(msg);\n    // this.throwError(pattern, `Error in Flex RE '${pattern.input}': ${msg}`);\n  }\n}\n","import { Rule, Regex, REPatternType } from \"./core\";\nimport { RegexParser as JSREParser } from \"./jsparser\";\nimport { RegexParser as FlexREParser } from \"./flexparser\";\nimport { Tape } from \"./tape\";\n\n/**\n * Uber method to build a Regex given either a regex string or a JS regex.\n *\n * @param pattern   Either a regex pattern, a JS RegExp object, or an already parsed Regex object.\n * @param config    TBD\n *\n * @return A {@link Rule} object that contains the pattern as well as its normalized regex tree.\n */\nexport function build(pattern: string | RegExp | Regex, config?: any): Rule {\n  if (typeof pattern === \"string\") {\n    const rule = new Rule(exprFromJSRE(pattern, config), config);\n    rule.pattern = pattern;\n    return rule;\n  } else if (pattern.constructor.name == \"RegExp\") {\n    const rule = new Rule(exprFromJSRE(pattern as RegExp, config), config);\n    rule.pattern = (pattern as RegExp).source;\n    return rule;\n  } else {\n    // Already compiled expression\n    return new Rule(pattern as Regex, config);\n  }\n}\n\n/*\nexport function fromRE(pattern: string, config?: any): Rule {\n  const expr = new JSREParser(pattern, config).parse();\n  const rule = new Rule(expr, config);\n  rule.pattern = pattern;\n  return rule;\n}\n\nexport function fromJSRE(re: RegExp, config?: any): Rule {\n  const expr = exprFromJSRE(re);\n  const rule = new Rule(expr, config);\n  rule.pattern = re.source;\n  return rule;\n}\n\nexport function fromFlexRE(re: string, config?: any): Rule {\n  const expr = exprFromFlexRE(re);\n  const rule = new Rule(expr, config);\n  rule.pattern = re;\n  return rule;\n}\n*/\n\n/**\n * \"Flattens\" either a single REPatternType or a list of REPatternTypes into a flat list of all\n * REPatternTypes at the leaf levels.\n */\nexport function flatten(re: REPatternType | REPatternType[], index = 0, rules?: Rule[]): Rule[] {\n  rules = rules || [];\n  if (typeof re === \"string\") {\n    rules.push(build(re, { tag: index }));\n  } else if (re.constructor == RegExp) {\n    rules.push(build(re, { tag: index }));\n  } else if (re.constructor == Rule) {\n    rules.push(re as Rule);\n  } else if (re.constructor == Regex) {\n    rules.push(new Rule(re as Regex));\n  } else {\n    const res = re as (RegExp | Rule | string)[];\n    for (let i = 0; i < res.length; i++) {\n      flatten(res[i], i, rules);\n    }\n  }\n  return rules;\n}\n\n/**\n * Takes a string assumed to be in Flex RE format and parses the Regex expression out of it.\n */\nexport function exprFromFlexRE(pattern: string): Regex {\n  const parser = new FlexREParser();\n  try {\n    const expr = parser.parse(new Tape(pattern));\n    // if not specified default to false\n    if (expr.dotAll == null) expr.dotAll = false;\n    if (expr.multiline == null) expr.multiline = false;\n    return expr;\n  } catch (error) {\n    console.log(\"Error in FLEX RE: \", pattern);\n    throw error;\n  }\n}\n\n/**\n * Takes a string assumed to be in JS RE format and parses the Regex expression out of it.\n */\nexport function exprFromJSRE(re: string | RegExp, config?: any): Regex {\n  config = config || {};\n  const isRegExp = typeof re !== \"string\";\n  const pattern = typeof re === \"string\" ? re : re.source;\n  if (isRegExp) config.unicode = (re as RegExp).unicode;\n  const expr = new JSREParser(pattern, config).parse();\n  if (typeof re !== \"string\") {\n    expr.dotAll = re.dotAll;\n    expr.ignoreCase = re.ignoreCase;\n    expr.multiline = re.multiline;\n  }\n  return expr;\n}\n\n/**\n * A way to build a JS RE from a string literal, eg: jsRE`a*b+`\n */\nexport function jsRE(strings: TemplateStringsArray, ...keys: any[]): Regex {\n  // what we have is the raw value of this template and this can be parsed by our parser\n  const merged = String.raw(strings, ...keys);\n  return exprFromJSRE(merged);\n}\n\n/**\n * A way to build a Flex RE from a string literal, eg: flexRE`a*b+`\n */\nexport function flexRE(strings: TemplateStringsArray, ...keys: any[]): Regex {\n  const merged = String.raw(strings, ...keys);\n  return exprFromFlexRE(merged);\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport * as TLEX from \"tlex\";\nimport { Sym, Grammar, Str, Rule, RuleAction } from \"./grammar\";\n\ntype Tape = TLEX.TapeInterface;\n\nconst str2regex = (s: string | number): string => {\n  if (typeof s === \"number\") return \"\" + s;\n  return s.replace(/[\\-\\[\\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\\\\\^\\$\\|]/g, \"\\\\$&\");\n};\n\nexport enum TokenType {\n  STRING = \"STRING\",\n  REGEX = \"REGEX\",\n  NUMBER = \"NUMBER\",\n  SPACES = \"SPACES\",\n  IDENT = \"IDENT\",\n  PCT_IDENT = \"PCT_IDENT\",\n  STAR = \"STAR\",\n  PLUS = \"PLUS\",\n  QMARK = \"QMARK\",\n  PIPE = \"PIPE\",\n  DOLLAR_NUM = \"DOLLAR_NUM\",\n  DOLLAR_IDENT = \"DOLLAR_IDENT\",\n  OPEN_PAREN = \"OPEN_PAREN\",\n  CLOSE_PAREN = \"CLOSE_PAREN\",\n  OPEN_BRACE = \"OPEN_BRACE\",\n  CLOSE_BRACE = \"CLOSE_BRACE\",\n  OPEN_SQ = \"OPEN_SQ\",\n  CLOSE_SQ = \"CLOSE_SQ\",\n  COMMENT = \"COMMENT\",\n  ARROW = \"ARROW\",\n  COLCOLHYPHEN = \"COLCOLHYPHEN\",\n  COLON = \"COLON\",\n  SEMI_COLON = \"SEMI_COLON\",\n}\n\nexport type NewSymbolCallback = TSU.Nullable<(label: string, assumedTerminal: boolean) => Sym | void>;\nexport type TokenHandler = (token: TLEX.Token, tape: TLEX.TapeInterface, owner: any) => TLEX.Token;\n\nexport interface LoaderConfig {\n  grammar?: Grammar;\n  leftRecursive?: boolean;\n  newSymbolCallback?: NewSymbolCallback;\n  tokenHandlers: TSU.StringMap<TokenHandler>;\n  debug?: string;\n}\n\n/**\n * Entry point in loading a grammar from a DSL spec.\n */\nexport function load(input: string, params?: LoaderConfig): [Grammar, null | TLEX.NextTokenFunc] {\n  params = params || ({} as LoaderConfig);\n  const g = new Grammar(params.grammar || {});\n  const eparser = new Loader(input, { ...params, grammar: g });\n  // g.augmentStartSymbol();\n  const tokenFunc = eparser.generatedTokenizer.next.bind(eparser.generatedTokenizer);\n  const debug = params.debug || \"\";\n  if (debug.split(\"|\").findIndex((p: string) => p == \"all\" || p == \"lexer\") >= 0) {\n    console.log(\"Prog: \\n\", `${eparser.generatedTokenizer.vm.prog.debugValue().join(\"\\n\")}`);\n  }\n  return [g, tokenFunc];\n}\n\n/**\n * The SemanticHandler is the bridge between the DSL, the Grammar, the Parser\n * and the caller of the parser.\n * In the DSL semantic actions can be added to tokenizer and grammar specs.\n * However the problem how to invoke them during runtime.\n *\n * For example in the grammar:\n *\n * E -> E + E { add($1, $3) }\n *\n * declares that when this rule is reduced the \"add\" function (in user land) is\n * invoked with the results of the right hand side values.\n *\n * This parsing however is done by the DSL loader and at this time the \"add\" method\n * is not declared anywhere.   In fact the the declaration is only  used by the parser\n * driver (after the parse tables have been constructed and parsing is started on\n * a real input).   The parser here needs to supply the definition for \"add\" method.\n * Note only this only the parser can call what is needed to kick off the \"add\" method\n * to be invoked.\n *\n * So the parser will need something like:\n *\n * while (input) {\n *    ....\n *    reduceRule(Nt, E1, E2, E3 ..., \"action\")\n * }\n *\n * the \"action\" will be part of the SemanticHandler\n *\n * reduceRule(Nt...., \"action\") {\n *  Nt.value = semanticHandler.getAction(\"action\").apply(E1, E2...., En);\n * }\n *\n * Similarly the caller of the \"parse\" method could populate the actions, eg:\n *\n * semanticHandler.register(\"action\", (a, b, c) => {\n *    return ....;\n * });\n *\n * The DSL loader in turn returns a semanticHandler instance just the way it\n * creates a tokenizer.\n *\n * There are a couple of options here.\n *\n * 1. Keep actions simple and store action IDs and let the caller do all the work, eg:\n *\n * E -> E + E { add $1 $3 }\n *\n * 2. Provide a stronger expression syntax:\n *\n * Or we could add a slightly more functional syntax so that a proper interpreter like setup is possible, eg:\n *\n * E -> E + E { add(halve($1), double($3)) }\n *\n * Here instead of calling an action \"add\" we could actually store expression trees and call an interpreter\n * with attribute value bindings.\n *\n * For now we will go with (1) as it is simpler and we can always build up (2) if doing (1) alone is too verbose.\n *\n * With (1), syntax for semantic actions is:\n *\n *  SemAction -> \"{\" ActionSpec \"}\" ;\n *\n *  ActionSpec -> DOLLAR_NUM\n *              | IDENT ( IDENT | DOLLAR_NUM | NUM | STRING | BOOLEAN | NULL ) *\n *              ;\n *\n * 3. There is an evern simpler third option.  Instead of the parser trying to martial parameters etc it could just\n * let the handler do the work of martialling/extracting parameters from children.  This is effective and easy\n *\n * In this mode all child nodes are passed as is to the handler and it is upto the handler to return the semantic\n * value of the production.\n */\n\nexport function Tokenizer(): TLEX.Tokenizer {\n  const lexer = new TLEX.Tokenizer();\n  lexer.add(/->/, { tag: TokenType.ARROW });\n  lexer.add(/\\[/, { tag: TokenType.OPEN_SQ });\n  lexer.add(/\\]/, { tag: TokenType.CLOSE_SQ });\n  lexer.add(/\\(/, { tag: TokenType.OPEN_PAREN });\n  lexer.add(/\\)/, { tag: TokenType.CLOSE_PAREN });\n  lexer.add(/\\{/, { tag: TokenType.OPEN_BRACE });\n  lexer.add(/\\}/, { tag: TokenType.CLOSE_BRACE });\n  lexer.add(/\\*/, { tag: TokenType.STAR });\n  lexer.add(/\\+/, { tag: TokenType.PLUS });\n  lexer.add(/\\?/, { tag: TokenType.QMARK });\n  lexer.add(/;/, { tag: TokenType.SEMI_COLON });\n  lexer.add(/:/, { tag: TokenType.COLON });\n  lexer.add(/\\|/, { tag: TokenType.PIPE });\n  lexer.add(/\\s+/m, { tag: TokenType.SPACES }, () => null);\n  lexer.add(/\\/\\*.*?\\*\\//s, { tag: TokenType.COMMENT }, () => null);\n  lexer.add(/\\/\\/.*$/m, { tag: TokenType.COMMENT }, () => null);\n  lexer.add(TLEX.Samples.DOUBLE_QUOTE_STRING, { tag: TokenType.STRING }, (rule, tape, token) => {\n    token.value = tape.substring(token.start + 1, token.end - 1);\n    return token;\n  });\n  lexer.add(TLEX.Samples.SINGLE_QUOTE_STRING, { tag: TokenType.STRING }, (rule, tape, token) => {\n    token.value = tape.substring(token.start + 1, token.end - 1);\n    return token;\n  });\n  lexer.add(TLEX.Samples.JS_REGEX, { tag: TokenType.REGEX }, (rule, tape, token) => {\n    const pattern = tape.substring(token.positions[1][0], token.positions[1][1]);\n    const flags = tape.substring(token.positions[3][0], token.positions[3][1]);\n    token.value = [pattern, flags];\n    return token;\n  });\n  lexer.add(/\\d+/, { tag: TokenType.NUMBER }, (rule, tape, token) => {\n    token.value = parseInt(tape.substring(token.start, token.end));\n    return token;\n  });\n  lexer.add(/%([\\w][\\w\\d_]*)/, { tag: TokenType.PCT_IDENT }, (rule, tape, token) => {\n    token.value = tape.substring(token.start + 1, token.end);\n    return token;\n  });\n  lexer.add(/\\$\\d+/, { tag: TokenType.DOLLAR_NUM }, (rule, tape, token) => {\n    token.value = parseInt(tape.substring(token.start + 1, token.end));\n    return token;\n  });\n  lexer.add(/\\$([\\w][\\w\\d_]*)/, { tag: TokenType.DOLLAR_IDENT }, (rule, tape, token) => {\n    token.value = tape.substring(token.start + 1, token.end);\n    return token;\n  });\n  lexer.add(/[\\w][\\w\\d_]*/, { tag: TokenType.IDENT });\n  return lexer;\n}\n\nexport enum NodeType {\n  GRAMMAR = \"GRAMMAR\",\n  DECL = \"DECL\",\n  RULE = \"RULE\",\n  PROD_NULL = \"PROD_NULL\",\n  PROD_STR = \"PROD_STR\",\n  PROD_UNION = \"PROD_UNION\",\n  PROD_NAME = \"PROD_NAME\",\n  PROD_STRING = \"PROD_STRING\",\n  PROD_NUM = \"PROD_NUM\",\n  PROD_IDENT = \"PROD_IDENT\",\n  PROD_STAR = \"PROD_STAR\",\n  PROD_PLUS = \"PROD_PLUS\",\n  PROD_OPTIONAL = \"PROD_OPTIONAL\",\n  IDENT = \"IDENT\",\n  ERROR = \"ERROR\",\n  COMMENT = \"COMMENT\",\n}\n\n/**\n * EBNF Grammar:\n *\n * grammar -> rules;\n *\n * decl -> rule ;\n *\n * rules -> rule | rule rules ;\n *\n * rule -> IDENT \"->\" top_productions \";\" ;\n *\n * top_productions -> ( actionSpec ) ?\n *                |   prod ( actionSpec ) ? top_productions\n *                ;\n *\n * productions ->\n *              | prod  \"|\" productions\n *              ;\n *\n * prod -> ( prod_group | optional_prod | IDENT ( \":\" name ) ? | STRING ) ( \"*\" | \"+\" | \"?\" ) ?\n *      ;\n *\n * prod_group -> \"(\" productions \")\"  ;\n *\n * optional_prod -> \"[\" productions \"]\"  ;\n *\n * actionSpec := \"{\" IDENT \"(\" IDENT ( \",\" IDENT ) * \")\" \"}\"\n */\nexport class Loader {\n  readonly grammar: Grammar;\n  private tokenizer: TLEX.TokenBuffer;\n  private leftRecursive = false;\n  readonly generatedTokenizer: TLEX.Tokenizer = new TLEX.Tokenizer();\n  tokenHandlers: TSU.StringMap<TokenHandler>;\n\n  /*\n   * The newSymbol callback provided to the contructor is a way for the client to\n   * be given a chance to create a symbol given a new label that is encountered.\n   * The client can either return a null to let this parser define the Symbol\n   * or return a Symbol which will be associated with the given label going\n   * forward.\n   *\n   * The newSymbol callback will ONLY be called once for each new label\n   * encountered by the parser.   If the client returns a duplicte symbol\n   * then parsing fails.\n   */\n  private newSymbolCallback: NewSymbolCallback;\n  private symbolsByLabel: TSU.StringMap<Sym>;\n\n  /**\n   * Allowed regex syntaxes - js or flex\n   */\n  private regexSyntax = \"js\";\n\n  constructor(input: string, config?: LoaderConfig) {\n    config = config || ({} as LoaderConfig);\n    this.symbolsByLabel = {};\n    this.grammar = config.grammar || new Grammar();\n    this.leftRecursive = \"leftRecursive\" in config ? config.leftRecursive || false : true;\n    this.newSymbolCallback = config.newSymbolCallback || null;\n    this.tokenHandlers = config.tokenHandlers || {};\n    this.parse(input);\n  }\n\n  /**\n   * As the parser creates encounters a new literal or an identifier (hinting at\n   * either a terminal or a non terminal), it needs to know which symbol to associate\n   * with this lit/ident going forward.\n   *\n   * All symbols created for the grammar, since they are either created\n   * by this parser or by the client (invokved by this parser), are\n   * stored locally to be returned in this method.\n   */\n  symbolForLabel(label: string): TSU.Nullable<Sym> {\n    return this.symbolsByLabel[label] || null;\n  }\n\n  /**\n   * Registers a symbol for a given label.\n   */\n  registerSymbol(label: string, sym: Sym): void {\n    TSU.assert(!(label in this.symbolsByLabel), `${label} is already registered`);\n    this.symbolsByLabel[label] = sym;\n  }\n\n  /**\n   * Ensures that a symbol exists for a given label (as found in the parser spec)\n   * to be used through out the grammar.\n   */\n  ensureSymbol(label: string, assumedTerminal: boolean): Sym {\n    let currSym = this.symbolForLabel(label);\n\n    if (currSym != null) return currSym;\n    else if (this.newSymbolCallback) {\n      // then give the user a chance to create a symbol for this\n      currSym = this.newSymbolCallback(label, assumedTerminal) || null;\n    }\n    if (currSym == null) {\n      if (assumedTerminal) {\n        currSym = this.grammar.newTerm(label);\n      } else {\n        currSym = this.grammar.newNT(label);\n      }\n    }\n    // then register it so it is used going forward\n    this.registerSymbol(label, currSym);\n    return currSym;\n  }\n\n  parse(input: string): void {\n    const et = Tokenizer();\n    const ntFunc = (tape: Tape, owner: any) => {\n      const out = et.next(tape, this);\n      return out;\n    };\n    this.tokenizer = new TLEX.TokenBuffer(ntFunc, this);\n    this.parseGrammar(new TLEX.Tape(input));\n  }\n\n  parseRegex(tape: TLEX.TapeInterface, tag?: string, priority = 0, syntax = \"\"): TLEX.Rule {\n    if (syntax == \"\") syntax = this.regexSyntax;\n    if (syntax == \"js\") {\n      const tokPattern = this.tokenizer.expectToken(tape, TokenType.STRING, TokenType.NUMBER, TokenType.REGEX);\n      let rule: TLEX.Rule;\n      if (!tag || tag.length == 0) {\n        tag = \"/\" + tokPattern.value[0] + \"/\" + tokPattern.value[1];\n      }\n      if (tokPattern.tag == TokenType.STRING || tokPattern.tag == TokenType.NUMBER) {\n        const pattern = str2regex(tokPattern.value);\n        rule = TLEX.Builder.build(pattern, { tag: tag, priority: priority + 20 });\n      } else if (tokPattern.tag == TokenType.REGEX) {\n        let re = tokPattern.value[0];\n        if (tokPattern.value[1].length > 0) {\n          // Flags given so create\n          re = new RegExp(tokPattern.value[0], tokPattern.value[1]);\n        }\n        rule = TLEX.Builder.build(re, { tag: tag, priority: priority + 10 });\n      } else {\n        throw new TLEX.UnexpectedTokenError(tokPattern);\n      }\n      return rule;\n    } else {\n      // Flex style RE - no delimiters - just read until end of line and strip spaces\n      let patternStr = \"\";\n      while (tape.hasMore && tape.currCh != \"\\n\") {\n        patternStr += tape.currCh;\n        tape.advance();\n      }\n      patternStr = patternStr.trim();\n      if (!tag || tag.length == 0) {\n        tag = \"/\" + patternStr + \"/\";\n      }\n      return new TLEX.Rule(TLEX.Builder.exprFromFlexRE(patternStr), { tag: tag, priority: priority });\n    }\n  }\n\n  parseGrammar(tape: TLEX.Tape): void {\n    let peeked = this.tokenizer.peek(tape);\n    while (peeked != null) {\n      if (peeked.tag == TokenType.IDENT) {\n        // declaration\n        this.parseDecl(tape);\n      } else if (peeked.tag == TokenType.PCT_IDENT) {\n        this.tokenizer.next(tape);\n        this.parseDirective(tape, peeked.value);\n      } else {\n        throw new SyntaxError(`Declaration must start with IDENT or PCT_IDENT.  Found: '${peeked.value}' instead.`);\n      }\n      peeked = this.tokenizer.peek(tape);\n    }\n  }\n\n  parseDirective(tape: TLEX.TapeInterface, directive: string): void {\n    if (directive == \"start\") {\n      // override start directive\n      const next = this.tokenizer.expectToken(tape, TokenType.IDENT);\n      this.grammar.startSymbol = this.ensureSymbol(next.value as string, false);\n    } else if (directive == \"resyntax\") {\n      // override start directive\n      const next = this.tokenizer.expectToken(tape, TokenType.IDENT);\n      if (next.value != \"js\" && next.value != \"flex\") {\n        throw new SyntaxError(\"Invalid regex syntax: \" + next.value);\n      }\n      this.regexSyntax = next.value;\n    } else if (directive.startsWith(\"skip\")) {\n      const rule = this.parseRegex(tape, \"\", 30, directive.endsWith(\"flex\") ? \"flex\" : \"\");\n      const tokenHandler = this.parseTokenHandler(tape);\n      if (tokenHandler) {\n        this.generatedTokenizer.addRule(rule, (rule, tape, token) => {\n          tokenHandler(rule, tape, token, this);\n          return null;\n        });\n      } else {\n        this.generatedTokenizer.addRule(rule, () => null);\n      }\n    } else if (directive.startsWith(\"token\") || directive.startsWith(\"define\")) {\n      const isDef = directive.startsWith(\"define\");\n      const tokName = this.tokenizer.expectToken(tape, TokenType.IDENT, TokenType.STRING);\n      let label = tokName.value as string;\n      if (tokName.tag == TokenType.STRING || tokName.tag == TokenType.NUMBER) {\n        label = `\"${tokName.value}\"`;\n      }\n      const rule = this.parseRegex(tape, label, 0, directive.endsWith(\"flex\") ? \"flex\" : \"\");\n      if (isDef) {\n        // Define a \"reusable\" regex that is not a token on its own\n        this.generatedTokenizer.addVar(label, rule.expr);\n      } else {\n        const tokenHandler = this.parseTokenHandler(tape);\n        // see if we have a handler function here\n        this.generatedTokenizer.addRule(rule, tokenHandler);\n        // register it\n        this.ensureSymbol(label, true);\n      }\n    } else {\n      throw new Error(\"Invalid directive: \" + directive);\n    }\n  }\n\n  parseTokenHandler(tape: Tape): TLEX.RuleMatchHandler | null {\n    if (!this.tokenizer.consumeIf(tape, TokenType.OPEN_BRACE)) {\n      return null;\n    }\n\n    const funcName = this.tokenizer.expectToken(tape, TokenType.IDENT);\n\n    // how do we use the funcName to\n    const out = (rule: TLEX.Rule, tape: Tape, token: any, owner: any) => {\n      const handler = this.tokenHandlers[funcName.value];\n      if (!handler) throw new Error(\"Handler method not found: \" + funcName.value);\n      token = handler(token, tape, owner);\n      return token;\n    };\n\n    this.tokenizer.expectToken(tape, TokenType.CLOSE_BRACE);\n    return out;\n  }\n\n  parseDecl(tape: Tape): void {\n    const ident = this.tokenizer.expectToken(tape, TokenType.IDENT);\n    if (this.tokenizer.consumeIf(tape, TokenType.ARROW, TokenType.COLON)) {\n      const nt = this.ensureSymbol(ident.value as string, false);\n      if (nt.isTerminal) {\n        // it is a terminal so mark it as a non-term now that we\n        // know there is a declaration for it.\n        nt.isTerminal = false;\n      } else if (nt.isAuxiliary) {\n        throw new Error(\"NT is already auxiliary and cannot be reused.\");\n      }\n      for (const [rhs, action] of this.parseProductions(tape, this.grammar, nt)) {\n        const rule = this.grammar.add(nt, rhs, action);\n      }\n      this.tokenizer.expectToken(tape, TokenType.SEMI_COLON);\n    }\n  }\n\n  parseProductions(tape: Tape, grammar: Grammar, nt: TSU.Nullable<Sym>): [Str, RuleAction | null][] {\n    const out: [Str, RuleAction | null][] = [];\n    while (this.tokenizer.peek(tape) != null) {\n      const rule = this.parseProd(tape, grammar);\n      out.push(rule);\n      if (this.tokenizer.consumeIf(tape, TokenType.PIPE)) {\n        continue;\n      } else if (this.tokenizer.nextMatches(tape, TokenType.CLOSE_SQ, TokenType.CLOSE_PAREN, TokenType.SEMI_COLON)) {\n        break;\n      }\n    }\n    return out;\n  }\n\n  parseProd(tape: Tape, grammar: Grammar): [Str, null | RuleAction] {\n    const out = new Str();\n    while (true) {\n      // if we are starting with a FOLLOW symbol then return as it marks\n      // the end of this production\n      if (\n        this.tokenizer.nextMatches(\n          tape,\n          TokenType.CLOSE_PAREN,\n          TokenType.CLOSE_SQ,\n          TokenType.SEMI_COLON,\n          TokenType.PIPE,\n          TokenType.OPEN_BRACE,\n        )\n      ) {\n        break;\n        // return [out, null];\n      }\n\n      let curr: TSU.Nullable<Str> = null;\n      if (this.tokenizer.consumeIf(tape, TokenType.OPEN_PAREN)) {\n        const rules = this.parseProductions(tape, grammar, null);\n        if (rules.length == 0) {\n          // nothing\n        } else if (rules.length == 1) {\n          // TODO: Consider actions in non top level rules\n          curr = rules[0][0];\n        } else {\n          // create a new NT over this\n          // TODO: Consider actions in non top level rules\n          curr = grammar.anyof(...rules.map((r) => r[0]));\n        }\n        this.tokenizer.expectToken(tape, TokenType.CLOSE_PAREN);\n      } else if (this.tokenizer.consumeIf(tape, TokenType.OPEN_SQ)) {\n        const rules = this.parseProductions(tape, grammar, null);\n        if (rules.length == 0) {\n          // nothing\n        } else if (rules.length == 1) {\n          // TODO: Consider actions in non top level rules\n          curr = grammar.opt(rules[0][0]);\n        } else {\n          // create a new NT over this\n          // TODO: Consider actions in non top level rules\n          curr = grammar.opt(grammar.anyof(...rules.map((r) => r[0])));\n        }\n        this.tokenizer.expectToken(tape, TokenType.CLOSE_SQ);\n      } else if (\n        this.tokenizer.nextMatches(tape, TokenType.IDENT, TokenType.STRING, TokenType.NUMBER, TokenType.REGEX)\n      ) {\n        const token = this.tokenizer.next(tape) as TLEX.Token;\n        let label = token.value as string;\n        if (token.tag == TokenType.STRING || token.tag == TokenType.NUMBER) {\n          label = `\"${token.value}\"`;\n          const pattern = str2regex(token.value);\n          const rule = TLEX.Builder.build(pattern, { tag: label, priority: 20 });\n          this.generatedTokenizer.addRule(rule);\n        } else if (token.tag == TokenType.REGEX) {\n          label = \"/\" + token.value[0] + \"/\" + token.value[1];\n          let re = token.value[0];\n          if (token.value[1].length > 0) {\n            // Flags given so create\n            re = new RegExp(token.value[0], token.value[1]);\n          }\n          const rule = TLEX.Builder.build(re, { tag: label, priority: 10 });\n          this.generatedTokenizer.addRule(rule);\n        } else {\n          // Normal\n        }\n        // See if this symbol is already registered\n        const currSym = this.ensureSymbol(label, true);\n        curr = new Str(currSym);\n      } else {\n        throw new TLEX.UnexpectedTokenError(this.tokenizer.peek(tape));\n      }\n\n      if (curr == null) {\n        throw new Error(\"Could not determine node\");\n      }\n\n      if (this.tokenizer.consumeIf(tape, TokenType.STAR)) {\n        curr = grammar.atleast0(curr, this.leftRecursive);\n      } else if (this.tokenizer.consumeIf(tape, TokenType.PLUS)) {\n        curr = grammar.atleast1(curr, this.leftRecursive);\n      } else if (this.tokenizer.consumeIf(tape, TokenType.QMARK)) {\n        curr = grammar.opt(curr);\n      }\n      out.extend(curr);\n    }\n    let action: RuleAction | null = null;\n    if (this.tokenizer.consumeIf(tape, TokenType.OPEN_BRACE)) {\n      const next = this.tokenizer.expectToken(tape, TokenType.DOLLAR_NUM, TokenType.IDENT);\n      action = new RuleAction(next.value);\n      this.tokenizer.expectToken(tape, TokenType.CLOSE_BRACE);\n    }\n    return [out, action];\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { Regex, Union, Rule, RuleConfig } from \"./core\";\nimport { Prog, Match, VM } from \"./vm\";\nimport { Compiler } from \"./compiler\";\nimport { TapeInterface as Tape, Tape as DefaultTape } from \"./tape\";\nimport { TokenizerError } from \"./errors\";\nimport * as Builder from \"./builder\";\nimport { Token, TokenType } from \"./token\";\n\nexport type RuleMatchHandler = (rule: Rule, tape: Tape, token: Token, owner: any) => any;\nexport type TokenizerErrorHandler = (error: Error, tape: Tape, startIndex: number) => Error | null;\n\nexport function toToken(tag: TokenType, m: Match, tape: Tape | null): Token {\n  const out = new Token(tag, m.matchIndex, m.start, m.end);\n  for (let i = 0; i < m.positions.length; i += 2) {\n    if (m.positions[i] >= 0) {\n      out.positions[Math.floor(i / 2)] = [m.positions[i], m.positions[i + 1]];\n    }\n  }\n  for (const [groupIndex, tapeIndex] of m.groups) {\n    const gi = Math.abs(groupIndex);\n    if (!(gi in out.groups)) {\n      out.groups[gi] = [];\n    }\n    out.groups[gi].push(tapeIndex);\n  }\n  if (tape != null) out.value = tape.substring(m.start, m.end);\n  return out;\n}\n\nexport class BaseTokenizer {\n  protected _prog: Prog | null = null;\n  protected _vm: VM | null = null;\n\n  /**\n   * Error handler called when an invalid character or lexeme is encountered.\n   * If this method returns back an error then the tokenization stops otherwise\n   * (if a null is returned) then tokenization continues.\n   *\n   * @param error       The error currently caught and being handled.\n   * @param tape        The tape currently being tokenized.\n   * @param startIndex  The start index when the tokenization began resulting in the error.\n   */\n  onError: TokenizerErrorHandler | null = null;\n\n  // Stores named rules\n  // Rules are a \"regex\", whether literal or not\n  allRules: Rule[] = [];\n  onMatchHandlers: (RuleMatchHandler | null)[] = [];\n  matchHandlersByValue: any = {};\n  variables = new Map<string, Regex>();\n  compiler: Compiler = new Compiler((name) => {\n    let out = this.variables.get(name) || null;\n    if (out == null) out = this.findRuleByValue(name)?.expr || null;\n    if (out == null) throw new Error(`Invalid regex reference: ${name}`);\n    return out;\n  });\n\n  getVar(name: string): Regex | null {\n    return this.variables.get(name) || null;\n  }\n\n  addVar(name: string, regex: Regex): this {\n    let currValue = this.variables.get(name) || null;\n    if (currValue == null) {\n      currValue = regex;\n    } else {\n      currValue = new Union(currValue, regex);\n    }\n    this.variables.set(name, regex);\n    return this;\n  }\n\n  findRuleByValue(value: any): Rule | null {\n    return this.allRules.find((r) => r.tag == value) || null;\n  }\n\n  /**\n   * Helper method over the addRule method that converts the pattern to its normalized expression form\n   * and adds a rule to the tokenizer.\n   *\n   * @param pattern     A raw string or a JS RegExp, or parsed Regex expression\n   *                    (either from JS or Flex RE syntax).\n   * @param config      Rule configs to control priority and other aspects of rules to be used during\n   *                    the match stage.\n   * @param onMatch     A callback method called when the rule is matched.\n   */\n  add(\n    pattern: string | RegExp | Regex,\n    config?: RuleConfig | RuleMatchHandler | null,\n    onMatch: RuleMatchHandler | null = null,\n  ): this {\n    if (typeof config === \"function\") {\n      onMatch = config;\n      config = null;\n    }\n    return this.addRule(Builder.build(pattern, config), onMatch);\n  }\n\n  /**\n   * Helper method over the addRule method that converts the pattern to its normalized expression form\n   * and adds a rule to the tokenizer.\n   *\n   * @param rule        A normalized Rule object that contains both the pattern as well as rule configs\n   *                    to be used during the match and afterwards (if successfully matched).\n   * @param onMatch     A callback method called when the rule is matched.\n   */\n  addRule(rule: Rule, onMatch: null | RuleMatchHandler = null): this {\n    rule.matchIndex = this.allRules.length;\n    this.allRules.push(rule);\n    this.onMatchHandlers.push(onMatch);\n    this._prog = null;\n    this._vm = null;\n    return this;\n  }\n\n  /**\n   * Add a token match callback by value.\n   */\n  on(tag: any, onMatch: RuleMatchHandler): this {\n    this.matchHandlersByValue[tag] = onMatch;\n    return this;\n  }\n\n  get prog(): Prog {\n    if (this._prog == null) {\n      const sortedRules = this.sortRules();\n      this._prog = this.compiler.compile(sortedRules);\n    }\n    return this._prog;\n  }\n\n  get vm(): VM {\n    if (this._vm == null) {\n      this._vm = new VM(this.prog);\n    }\n    return this._vm;\n  }\n\n  protected sortRules(): Rule[] {\n    // Sort rules so high priority ones appear first\n    const sortedRules: Rule[] = this.allRules.map((rule) => rule);\n    sortedRules.sort((r1, r2) => {\n      if (r1.priority != r2.priority) return r2.priority - r1.priority;\n      return r1.matchIndex - r2.matchIndex;\n    });\n    return sortedRules;\n  }\n}\n\n/**\n * A batch tokenizer.\n */\nexport class Tokenizer extends BaseTokenizer {\n  idCounter = 0;\n  next(tape: Tape, owner: any): Token | null {\n    if (!tape.hasMore) {\n      return null;\n    }\n    const startIndex = tape.index;\n    const startChar = tape.currCh;\n    const m = this.vm.match(tape);\n    if (m == null) {\n      // no match so we have an error\n      let err: Error | null = null;\n      if (tape.index == startIndex + 1) {\n        err = new TokenizerError(`Unexpected Character: ${startChar}`, startIndex, 1, \"UnexpectedCharacter\", startChar);\n      } else {\n        err = new TokenizerError(\n          `Unexpected Symbol: ${tape.substring(startIndex, tape.index)}`,\n          startIndex,\n          tape.index - startIndex,\n          \"UnexpectedLexeme\",\n        );\n      }\n      if (this.onError) {\n        err = this.onError(err, tape, startIndex);\n      }\n      if (err != null) {\n        throw err;\n      } else {\n        // err has been ocnsumed so we can restart tokenizer at the current position\n        return this.next(tape, owner);\n      }\n    }\n    const rule = this.allRules[m.matchIndex];\n    let token = toToken(rule.tag, m, tape);\n    token.id = this.idCounter++;\n    let onMatch = this.onMatchHandlers[m.matchIndex];\n    if (!onMatch) {\n      onMatch = this.matchHandlersByValue[rule.tag];\n    }\n    if (onMatch) {\n      token = onMatch(rule, tape, token, owner);\n      if (token == null) {\n        // null is returned by onMatch to skip tokens\n        return this.next(tape, owner);\n      }\n    } else if (rule.skip) {\n      return this.next(tape, owner);\n    }\n    return token;\n  }\n\n  tokenize(tape: string | Tape, owner: any = null): Token[] {\n    const tokens = [] as Token[];\n    if (typeof tape === \"string\") {\n      tape = new DefaultTape(tape);\n    }\n    let next = this.next(tape, owner);\n    while (next) {\n      tokens.push(next);\n      try {\n        next = this.next(tape, owner);\n      } catch (err: any) {\n        tokens.push({\n          tag: \"ERROR\",\n          start: err.offset,\n          end: err.offset + err.length,\n          value: err.message,\n        } as Token);\n        break;\n      }\n    }\n    return tokens;\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { Tape, TapeHelper } from \"./tape\";\nimport { Token, TokenType } from \"./token\";\nimport { TokenizerError } from \"./errors\";\n\n/**\n * A simple tokenize that matches the input to a set of matchers one by one.\n */\nexport type TokenMatcher = (_: Tape, pos: number) => TSU.Nullable<Token>;\nexport class SimpleTokenizer {\n  private peekedToken: TSU.Nullable<Token> = null;\n  tape: Tape;\n  // TODO  - convert literals into a trie\n  literals: [string, TokenType][] = [];\n  matchers: [TokenMatcher, boolean][] = [];\n\n  constructor(tape: string | Tape) {\n    if (typeof tape === \"string\") {\n      tape = new Tape(tape);\n    }\n    this.tape = tape;\n  }\n\n  addMatcher(matcher: TokenMatcher, skip = false): this {\n    this.matchers.push([matcher, skip]);\n    return this;\n  }\n\n  addLiteral(lit: string, tokType: TokenType): number {\n    const index = this.literals.findIndex((k) => k[0] == lit);\n    if (index < 0) {\n      this.literals.push([lit, tokType]);\n      return this.literals.length - 1;\n    } else {\n      if (this.literals[index][1] != tokType) {\n        throw new Error(`Literal '${lit}' already registered as ${tokType}`);\n      }\n      return index;\n    }\n  }\n\n  /**\n   * Performs the real work of extracting the next token from\n   * the tape based on the current state of the tokenizer.\n   * This can be overridden to do any other matchings to be prioritized first.\n   * Returns NULL if end of input reached.\n   */\n  nextToken(): TSU.Nullable<Token> {\n    // go through all literals first\n    if (!this.tape.hasMore) return null;\n    const pos = this.tape.index;\n    // const line = this.tape.currLine;\n    // const col = this.tape.currCol;\n    for (let i = 0; i < this.literals.length; i++) {\n      const [kwd, toktype] = this.literals[i];\n      if (TapeHelper.matches(this.tape, kwd)) {\n        const out = new Token(toktype, i, pos, this.tape.index);\n        out.value = kwd;\n        return out;\n      }\n    }\n    for (let i = 0; i < this.matchers.length; i++) {\n      const [matcher, skip] = this.matchers[i];\n      const token = matcher(this.tape, pos);\n      if (token != null) {\n        if (skip) {\n          return this.nextToken();\n        } else {\n          token.start = pos;\n          token.end = this.tape.index;\n          return token;\n        }\n      }\n    }\n    // Fall through - error char found\n    // throw new Error(`Line ${this.tape.currLine}, Col ${this.tape.currCol} - Invalid character: ${this.tape.currCh}`);\n    throw new TokenizerError(\"Invalid Character\", this.tape.index, 1, \"InvalidCharacter\", this.tape.currCh);\n  }\n}\n","import { flexRE } from \"./builder\";\n\nexport const SINGLE_QUOTE_STRING = flexRE`[\"]([^\"\\\\\\n]|\\\\.|\\\\\\n)*[\"]`;\nexport const DOUBLE_QUOTE_STRING = flexRE`[']([^'\\\\\\n]|\\\\.|\\\\\\n)*[']`;\nexport const SIMPLE_JS_STRING = '\"(.*?(?<!\\\\\\\\))\"';\nexport const JS_REGEX_WITHOUT_LB = String.raw`/([^\\\\/]|\\\\.)*/([imus]*)`;\nexport const JS_REGEX = String.raw`/(.+?(?<!\\\\))/([imus]*)`;\n","import * as TSU from \"@panyam/tsutils\";\nimport * as TLEX from \"tlex\";\nimport { Sym, Grammar, Rule } from \"./grammar\";\n\ntype Nullable<T> = TSU.Nullable<T>;\n\n/**\n * As the parse tree is built, nodes are created and added to parents bottom up.\n * This method is called before a child node is added to its parent.  The\n * node's left-most siblings have already been added this point.\n *\n * This method is an opportunity to filter or transfor the node or even adding\n * other nodes to the parent's child list.  Note that at this point the parent\n * has *NOT* been added to its parent.\n *\n * In order to filter out the node, return null.  Otherwise return a\n * PTNode instance for the actual node to be added to the parent.\n */\nexport type BeforeAddingChildCallback = (parent: PTNode, child: PTNode) => PTNode[];\n\n/**\n * This method is called when after a rule has been reduced.  At this time\n * all the children have already been reduced (and called with this method).\n * Now is the opportunity for the parent node reduction to perform custom\n * actions.  Note that this method cannot modify the stack.  It can only be\n * used to perform things like AST building or logging etc.\n */\nexport type RuleReductionCallback = (node: PTNode, rule: Rule) => PTNode;\n\n/**\n * This method is called as soon as the next token is received from the tokenizer.\n * This allows one to filter out tokens or even transform them based on any other\n * context being maintained.\n */\nexport type NextTokenCallback = (token: TLEX.Token) => TSU.Nullable<TLEX.Token>;\n\nexport class PFNode {\n  children: this[] = [];\n  constructor(public readonly id: number, public readonly sym: Sym, public value: any, ...children: PFNode[]) {\n    this.children = (children as this[]) || [];\n  }\n\n  get childCount(): number {\n    return this.children.length;\n  }\n\n  childAt(index: number): this {\n    if (index < 0) return this.children[this.children.length + index] as this;\n    return this.children[index] as this;\n  }\n\n  get isTerminal(): boolean {\n    return this.sym.isTerminal;\n  }\n\n  add(node: this, index = -1): this {\n    if (this.isTerminal) {\n      throw new Error(`Cannot add children (${node.sym.label}) to a terminal node: ${this.sym.label}`);\n    }\n    if (index < 0) {\n      this.children.push(node);\n    } else {\n      this.children.splice(index, 0, node);\n    }\n    return this;\n  }\n\n  splice(index: number, numToDelete: number, ...nodes: this[]): this {\n    this.children.splice(index, numToDelete, ...nodes);\n    return this;\n  }\n\n  get reprString(): string {\n    /*\n    let out = `Node(${this.sym.label}, {this.value}`;\n    if (this.children.length > 0) out += \", \" + this.children.map((c) => c.reprString).join(\", \");\n    out += \")\";\n    return out;\n    */\n    return this.debugValue(false).join(\"\\n\");\n  }\n\n  debugValue(raw = true): any {\n    if (raw) {\n      const out: any = [this.sym.label];\n      if (this.value) out.push(this.value);\n      if (this.children.length > 0) out.push(this.children.map((c) => c.debugValue(raw)));\n      return out;\n    } else {\n      const out: any[] = [];\n      const value = this.value;\n      out.push(this.value == null ? this.sym.label : this.sym.label + \" - \" + this.value);\n      this.children.forEach((node) => (node.debugValue(raw) as string[]).forEach((l) => out.push(\"  \" + l)));\n      return out;\n    }\n  }\n}\n\nexport class PTNode extends PFNode {\n  parent: Nullable<PTNode> = null;\n\n  add(node: this, index = -1): this {\n    super.add(node, index);\n    node.parent = this;\n    return this;\n  }\n\n  splice(index: number, numToDelete: number, ...nodes: this[]): this {\n    for (const node of nodes) node.parent = this;\n    return super.splice(index, numToDelete, ...nodes);\n  }\n}\n\nexport abstract class ParserBase {\n  tokenbuffer: TLEX.TokenBuffer;\n\n  setTokenizer(tokenizer: TLEX.NextTokenFunc): this {\n    this.tokenbuffer = new TLEX.TokenBuffer(tokenizer, null);\n    return this;\n  }\n\n  abstract get grammar(): Grammar;\n\n  /**\n   * Converts the token to a Terminal based on the tag value.\n   */\n  getSym(token: TLEX.Token): Sym {\n    const out = this.grammar.getSym(token.tag as string);\n    if (out == null) {\n      throw new Error(\"Invalid token tag: \" + token.tag + \", Value: \" + token.value);\n    }\n    return out;\n  }\n}\n\nexport abstract class SimpleParser extends ParserBase {\n  parse(input: string | TLEX.Tape, delegate: any = null): Nullable<PTNode> {\n    if (typeof input === \"string\") {\n      input = new TLEX.Tape(input);\n    }\n    return this.parseInput(input, delegate);\n  }\n\n  /**\n   * Parses the input and returns the resulting root Parse Tree node.\n   */\n  protected abstract parseInput(input: TLEX.Tape, delegate: any): Nullable<PTNode>;\n}\n\nexport abstract class ParallelParser extends ParserBase {\n  parse(input: string | TLEX.Tape, delegate: any = null): PFNode[] {\n    if (typeof input === \"string\") {\n      input = new TLEX.Tape(input);\n    }\n    return this.parseInput(input, delegate);\n  }\n\n  /**\n   * Parses the input and returns the resulting root Parse Tree node.\n   */\n  protected abstract parseInput(input: TLEX.Tape, delegate: any): PFNode[];\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport * as TLEX from \"tlex\";\nimport { Sym, Grammar, Rule } from \"./grammar\";\nimport {\n  PTNode,\n  SimpleParser as ParserBase,\n  BeforeAddingChildCallback,\n  RuleReductionCallback,\n  NextTokenCallback,\n} from \"./parser\";\nimport { ParseError } from \"./errors\";\n\ntype Nullable<T> = TSU.Nullable<T>;\ntype NumMap<T> = TSU.NumMap<T>;\ntype StringMap<T> = TSU.StringMap<T>;\n\nexport enum LRActionType {\n  ACCEPT,\n  SHIFT,\n  REDUCE,\n  GOTO, // can *ONLY* be valid for non-terms\n}\n\nexport class LRAction {\n  // Type of action\n  tag: LRActionType;\n\n  // Next state to go to after performing the action (if valid).\n  gotoState: Nullable<number> = null;\n\n  // The rule to be used for a reduce action\n  rule: Nullable<Rule> = null;\n\n  toString(): string {\n    if (this.tag == LRActionType.ACCEPT) return \"Acc\";\n    else if (this.tag == LRActionType.SHIFT) {\n      return \"S\" + this.gotoState!;\n    } else if (this.tag == LRActionType.REDUCE) {\n      return \"R \" + this.rule!.id;\n    } else {\n      return \"\" + this.gotoState!;\n    }\n  }\n\n  equals(another: LRAction): boolean {\n    return this.tag == another.tag && this.gotoState == another.gotoState && this.rule == another.rule;\n  }\n\n  static Shift(goto: number): LRAction {\n    const out = new LRAction();\n    out.tag = LRActionType.SHIFT;\n    out.gotoState = goto;\n    return out;\n  }\n\n  static Reduce(rule: Rule): LRAction {\n    const out = new LRAction();\n    out.tag = LRActionType.REDUCE;\n    out.rule = rule;\n    return out;\n  }\n\n  static Goto(gotoState: number): LRAction {\n    const out = new LRAction();\n    out.tag = LRActionType.GOTO;\n    out.gotoState = gotoState;\n    return out;\n  }\n\n  static Accept(): LRAction {\n    const out = new LRAction();\n    out.tag = LRActionType.ACCEPT;\n    return out;\n  }\n}\n\n/**\n * A parsing table for LR parsers.\n */\nexport class ParseTable {\n  // Records which actions have conflicts\n  conflictActions: NumMap<StringMap<boolean>> = {};\n\n  /**\n   * Maps symbol (by id) to the action;\n   */\n  actions: NumMap<NumMap<LRAction[]>> = {};\n\n  constructor(public readonly grammar: Grammar) {}\n\n  get hasConflicts(): boolean {\n    return Object.keys(this.conflictActions).length > 0;\n  }\n\n  /**\n   * Gets the action for a given sym from a given state.\n   */\n  getActions(stateId: number, next: Sym, ensure = false): LRAction[] {\n    let l1: NumMap<LRAction[]>;\n    if (stateId in this.actions) {\n      l1 = this.actions[stateId];\n    } else if (ensure) {\n      l1 = this.actions[stateId] = {};\n    } else {\n      return [];\n    }\n\n    if (next.id in l1) {\n      return l1[next.id];\n    } else if (ensure) {\n      return (l1[next.id] = []);\n    }\n    return [];\n  }\n\n  addAction(stateId: number, next: Sym, action: LRAction): this {\n    const actions = this.getActions(stateId, next, true);\n    if (actions.findIndex((ac) => ac.equals(action)) < 0) {\n      actions.push(action);\n    }\n    if (actions.length > 1) {\n      this.conflictActions[stateId] = this.conflictActions[stateId] || {};\n      this.conflictActions[stateId][next.label] = true;\n    }\n    return this;\n  }\n\n  get debugValue(): any {\n    const out: any = {};\n    for (const fromId in this.actions) {\n      out[fromId] = {};\n      for (const symId in this.actions[fromId]) {\n        const sym = this.grammar.getSymById(symId as any)!;\n        const actions = this.actions[fromId][sym.id] || [];\n        if (actions.length > 0) {\n          out[fromId][sym.label] = actions.map((a) => a.toString());\n        }\n      }\n    }\n    return out;\n  }\n}\n\nexport class ParseStack {\n  // A way of marking the kind of item that is on the stack\n  // true => isStateId\n  // false => isSymbolId\n  readonly stateStack: number[] = [];\n  readonly nodeStack: PTNode[] = [];\n\n  push(state: number, node: PTNode): void {\n    this.stateStack.push(state);\n    this.nodeStack.push(node);\n  }\n\n  /**\n   * Gets the nth item from the top of the stack.\n   */\n  top(nth = 0): [number, PTNode] {\n    return [this.stateStack[this.stateStack.length - 1 - nth], this.nodeStack[this.nodeStack.length - 1 - nth]];\n  }\n\n  pop(): [number, PTNode] {\n    const out = this.top();\n    this.stateStack.pop();\n    this.nodeStack.pop();\n    return out;\n  }\n\n  /**\n   * Pop N items from the stack.\n   */\n  popN(n = 1): void {\n    const L = this.stateStack.length;\n    this.stateStack.splice(L - n, n);\n    this.nodeStack.splice(L - n, n);\n  }\n\n  get isEmpty(): boolean {\n    return this.stateStack.length == 0 || this.nodeStack.length == 0;\n  }\n}\n\nexport type ActionResolverCallback = (\n  actions: LRAction[],\n  stack: ParseStack,\n  tokenbuffer: TLEX.TokenBuffer,\n) => LRAction;\n\nexport type RuleActionHandler = (rule: Rule, parent: PTNode, ...children: PTNode[]) => any;\n\nexport type TokenErrorCallback = (err: TLEX.TokenizerError, input: TLEX.Tape) => boolean;\n\nexport interface ParserContext {\n  buildParseTree?: boolean;\n  copySingleChild?: boolean;\n  ruleHandlers: TSU.StringMap<RuleActionHandler>;\n  beforeAddingChildNode?: BeforeAddingChildCallback;\n  onReduction?: RuleReductionCallback;\n  onNextToken?: NextTokenCallback;\n  actionResolver?: ActionResolverCallback;\n  onTokenError?: TokenErrorCallback;\n  // The owner used for tokenizer to get an insight into the context\n  // (to allow context sensitive scanning - aka \"scanner hacks\").\n  tokenizerContext: any;\n}\n\nexport class Parser extends ParserBase {\n  constructor(public readonly parseTable: ParseTable, config: any = {}) {\n    super();\n  }\n\n  get grammar(): Grammar {\n    return this.parseTable.grammar;\n  }\n\n  /**\n   * Parses the input and returns the resulting root Parse Tree node.\n   */\n  protected parseInput(input: TLEX.Tape, context?: ParserContext): Nullable<PTNode> {\n    context = context || ({} as ParserContext);\n    // Set default values for missing values\n    this.tokenbuffer.tokenizerContext = context.tokenizerContext;\n    if (context.buildParseTree != false) context.buildParseTree = true;\n    if (context.copySingleChild != false) context.copySingleChild = true;\n    let idCounter = 0;\n    const stack = new ParseStack();\n    stack.push(0, new PTNode(idCounter++, this.grammar.augStartRule.nt, null));\n    const tokenbuffer = this.tokenbuffer;\n    const g = this.grammar;\n    let output: Nullable<PTNode> = null;\n\n    /**\n     * Pick an action among several actions based on several factors (eg\n     * curr parse stack, tokenbuffer etc).\n     */\n    function resolveActions(actions: LRAction[]): LRAction {\n      if (context?.actionResolver) {\n        return context.actionResolver(actions, stack, tokenbuffer);\n      } else {\n        if (actions.length > 1) {\n          throw new Error(\"Multiple actions found.\");\n        }\n        return actions[0];\n      }\n    }\n\n    function nextToken(): TLEX.Token | null {\n      try {\n        return tokenbuffer.peek(input);\n      } catch (err /* InvalidCharacterException */) {\n        if (!context?.onTokenError || !context?.onTokenError(err as TLEX.TokenizerError, input)) {\n          // no handler or handler could do nothing so throw it up again\n          throw err;\n        }\n\n        // Handler managed to do \"something\" so retry again\n        // TODO - Check offsets were modified?\n        return nextToken();\n      }\n    }\n\n    while (true) {\n      // while (tokenbuffer.peek(input) != null || !stack.isEmpty) {\n      let token = nextToken();\n      if (token == null) {\n        if (stack.isEmpty) {\n          // no more to do\n          break;\n        }\n      } else if (context.onNextToken) {\n        token = context.onNextToken(token);\n      }\n      const nextSym = token == null ? g.Eof : this.getSym(token);\n      const nextValue = token == null ? null : token.value;\n      let [topState, topNode] = stack.top();\n      const actions = this.parseTable.getActions(topState, nextSym);\n      if (actions == null || actions.length == 0) {\n        // TODO - use a error handler here\n        throw new ParseError(`Unexpected Token: '${nextSym.label}'`, \"UnexpectedToken\", {\n          state: topState,\n          token: token,\n          nextSym: nextSym,\n        });\n      }\n\n      const action = resolveActions(actions);\n      if (action.tag == LRActionType.ACCEPT) {\n        break;\n      } else if (action.tag == LRActionType.SHIFT) {\n        tokenbuffer.next(input);\n        const newNode = new PTNode(idCounter++, nextSym, nextValue);\n        stack.push(action.gotoState!, newNode);\n      } else {\n        // reduce\n        TSU.assert(action.rule != null, \"Nonterm and ruleindex must be provided for a reduction action\");\n        const ruleLen = action.rule.rhs.length;\n\n        // here see if a rule handler exists - if it does use it\n        let newNode = new PTNode(idCounter++, action.rule.nt, null);\n        // Begin the reduction here. We are breaking the reduction into\n        // two parts:\n        //\n        // 1. Adding child nodes into the parent (reduced) node. Here\n        // the beforeAddingChildNode callback is used to modify children\n        // being added.\n        // 2. After all children have been added to give the caller a chance\n        // to handle/post-process the reduction - eg to build the semantic value.\n        //\n        // Our onReduction is a catch all to perform semantic actions.  Instead\n        // we could do rule specific ones by using the rule.action (if it exists)\n        // and only invoke the onReduction if a rule specific action does not exist.\n        //\n        // Are these \"double steps\" needed?  Can we just build parse tree, filter out\n        // child nodes and eval semantic value with a single action?\n        //\n        // Can semanticHandler do this?\n        //\n        // eg with\n        //\n        // E -> E + E { add }\n        //\n        // we could have our stack looking like;\n        //\n        // .... s1 E s2 E\n        //\n        // to be reduced and add could be called with:\n        //\n        // add(E1, E2) - as the child nodes themselves.\n        //\n        // the add handler could now do a few things:\n        //\n        // 1. Ensure all nodes are added to E as is (resulting in 3 nodes - \"E\", \"+\", \"E\")\n        // 2. Not add any nodes\n        // 3. Computing the value of E and E and the sum of those and put it in the parent E.\n        // 4. or all of the above.\n        //\n        // Doing filtering seems like a very premature usecase.  In the case of incremental\n        // parsing we may need all nodes to exist and filtering out can get in the way of that.\n        //\n        // But let us leave it for now and make any semantic handling happen *after* parse tree\n        // child node filter/transformation\n        if (context.buildParseTree) {\n          for (let i = ruleLen - 1; i >= 0; i--) {\n            const childNode: TSU.Nullable<PTNode> = stack.top(i)[1];\n            if (context.beforeAddingChildNode) {\n              for (const node of context.beforeAddingChildNode(newNode, childNode)) {\n                newNode.add(node);\n              }\n            } else if (childNode != null) {\n              newNode.add(childNode);\n            }\n          }\n        }\n        // Now apply the semantic handler if it exists\n        if (action.rule.action) {\n          // call it\n          if (action.rule.action.isFunction) {\n            // find the function associated with\n            const handlerName = action.rule.action.value;\n            const handler = context.ruleHandlers![handlerName];\n            if (!handler) throw new Error(\"Action handler not found: \" + handlerName);\n            // TODO - Replace the handler signature to take an\n            // interface that returns the nth child node (directly from\n            // the parse stack) instead of all children - this way we\n            // can even avoid building a parse tree if need be and\n            // decouple semantic actions from parse tree building\n            newNode.value = handler(action.rule, newNode, ...newNode.children);\n          } else {\n            // setting value as a child's value, eg $1, $2 etc\n            newNode.value = newNode.children[(action.rule.action.value as number) - 1].value;\n          }\n        } else if (context.onReduction) {\n          // fallback to default reduction handler\n          newNode = context.onReduction(newNode, action.rule);\n        } else if (newNode.children.length == 1 && context.copySingleChild) {\n          // If we have only 1 child set the semantic value to be child's value\n          // ie values \"bubble up\"\n          newNode.value = newNode.children[0].value;\n        }\n\n        // Perform the action reduction by popping ruleLen number of items off the stack\n        // and replace the top with our newNode\n        stack.popN(ruleLen);\n        [topState, topNode] = stack.top();\n        const newAction = resolveActions(this.parseTable.getActions(topState, action.rule.nt));\n        TSU.assert(newAction != null && newAction.gotoState != null, \"Top item does not have an action.\");\n        stack.push(newAction.gotoState, newNode);\n        output = newNode;\n      }\n    }\n    // It is possible that here no reductions have been done!\n    return output;\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport * as TLEX from \"tlex\";\nimport { Sym, Grammar, Rule } from \"./grammar\";\nimport { PTNode, SimpleParser as ParserBase } from \"./parser\";\nimport { printGrammar } from \"./utils\";\n\ntype StringMap<T> = TSU.StringMap<T>;\ntype Nullable<T> = TSU.Nullable<T>;\n\nexport class ParseTable {\n  readonly grammar: Grammar;\n  protected entries: Map<number, Map<number, Rule[]>>;\n\n  constructor(grammar: Grammar) {\n    this.grammar = grammar;\n    this.refresh();\n  }\n\n  refresh(): this {\n    this.entries = new Map();\n    this.grammar.followSets.refresh();\n    this.grammar.forEachRule(null, (rule, index) => {\n      this.processRule(rule, index);\n    });\n    const printed = printGrammar(this.grammar, false);\n    const t1 = this.grammar.cycles;\n    const t2 = this.grammar.leftRecursion;\n    return this;\n  }\n\n  get count(): number {\n    let c = 0;\n    for (const nt of this.entries.values()) {\n      for (const term of nt.values()) {\n        c += term.length;\n      }\n    }\n    return c;\n  }\n\n  ensureEntry(nt: Sym, term: Sym): Rule[] {\n    TSU.assert(!nt.isTerminal && term.isTerminal);\n    let entriesForNT = this.entries.get(nt.id) as Map<number, Rule[]>;\n    if (!entriesForNT) {\n      entriesForNT = new Map();\n      this.entries.set(nt.id, entriesForNT);\n    }\n    let entries = entriesForNT.get(term.id) as Rule[];\n    if (!entries) {\n      entries = [];\n      entriesForNT.set(term.id, entries);\n    }\n    return entries;\n  }\n\n  add(nt: Sym, term: Sym, entry: Rule): boolean {\n    const entries = this.ensureEntry(nt, term);\n    if (entries.findIndex((e) => e.equals(entry)) < 0) {\n      entries.push(entry);\n    }\n    return entries.length == 1;\n  }\n\n  get(nt: Sym, term: Sym): Rule[] {\n    return this.ensureEntry(nt, term);\n  }\n\n  forEachEntry(visitor: (nonterm: Sym, term: Sym, items: Rule[]) => boolean | void): void {\n    for (const ntId of this.entries.keys()) {\n      const ntMap = this.entries.get(ntId) || null;\n      TSU.assert(ntMap != null);\n      const nonterm = this.grammar.getSymById(ntId);\n      TSU.assert(nonterm != null);\n      for (const termId of ntMap.keys()) {\n        const term = this.grammar.getSymById(termId);\n        TSU.assert(term != null);\n        const items = ntMap.get(termId) || [];\n        if (visitor(nonterm, term, items) == false) return;\n      }\n    }\n  }\n\n  get debugValue(): StringMap<StringMap<string[]>> {\n    const out: StringMap<StringMap<string[]>> = {};\n    this.forEachEntry((nt, term, items) => {\n      out[nt.label] = out[nt.label] || {};\n      out[nt.label][term.label] = out[nt.label][term.label] || [];\n      const entries = out[nt.label][term.label];\n      for (const item of items) {\n        entries.push(item.debugString);\n      }\n    });\n    return out;\n  }\n\n  processRule(rule: Rule, index: number): void {\n    const firstSets = this.grammar.firstSets;\n    // Rule 1\n    // For each a in First(rule) add A -> rule to M[A,a]\n    let ruleIsNullable = false;\n    firstSets.forEachTermIn(rule.rhs, 0, (term) => {\n      if (term == null) {\n        ruleIsNullable = true;\n      } else {\n        this.add(rule.nt, term, rule);\n      }\n    });\n\n    // Rule 2\n    // if rule is nullable then A -> rule to M[A,b] for each b in Follow(A)\n    // Also if EOF in Follow(A) then add A -> Rule to M[A,Eof]\n    // const nullables = this.followSets.nullables;\n    // const nullable = rule.isString ? nullables.isStrNullable(rule as Str) : nullables.isNullable((rule as Sym).value);\n    if (ruleIsNullable) {\n      this.grammar.followSets.forEachTerm(rule.nt, (term) => {\n        TSU.assert(term != null, \"Follow sets cannot have null\");\n        this.add(rule.nt, term, rule);\n      });\n    }\n  }\n}\n\nexport class ParseStack {\n  readonly parseTable: ParseTable;\n  readonly stack: [Sym, PTNode][];\n  readonly docNode: PTNode;\n  readonly rootNode: PTNode;\n  protected idCounter = 0;\n  constructor(parseTable: ParseTable) {\n    this.parseTable = parseTable;\n    this.stack = [];\n    const g = parseTable.grammar;\n    TSU.assert(g.startSymbol != null, \"Start symbol not selected\");\n    this.docNode = this.push(g.Eof, new PTNode(this.idCounter++, new Sym(g, \"<DOC>\", false), null));\n    this.rootNode = this.push(g.startSymbol);\n    this.docNode.add(this.rootNode);\n  }\n\n  get debugString(): string {\n    return \"Stack: [\" + this.stack.map((x) => x[0].label).join(\", \") + \"]\";\n  }\n\n  push(sym: Sym, node: Nullable<PTNode> = null): PTNode {\n    if (!node) node = new PTNode(this.idCounter++, sym, null);\n    this.stack.push([sym, node]);\n    return node;\n  }\n\n  top(): [Sym, PTNode] {\n    return this.stack[this.stack.length - 1];\n  }\n\n  pop(): [Sym, PTNode] {\n    if (this.stack.length == 0) {\n      TSU.assert(false, \"Stacks are empty\");\n    }\n    return this.stack.pop()!;\n  }\n\n  get isEmpty(): boolean {\n    return this.stack.length == 0;\n  }\n}\n\nexport class Parser extends ParserBase {\n  stack: ParseStack;\n\n  constructor(public readonly parseTable: ParseTable) {\n    super();\n    TSU.assert(parseTable.grammar.startSymbol != null, \"Start symbol not selected\");\n  }\n\n  get grammar(): Grammar {\n    return this.parseTable.grammar;\n  }\n\n  /**\n   * Parses the input and returns the resulting root Parse Tree node.\n   */\n  protected parseInput(input: TLEX.Tape, delegate: any = null): Nullable<PTNode> {\n    this.stack = new ParseStack(this.parseTable);\n    const tokenbuffer = this.tokenbuffer;\n    const stack = this.stack;\n    const g = this.grammar;\n    let token: Nullable<TLEX.Token>;\n    let topItem: Sym;\n    let topNode: PTNode;\n    do {\n      token = tokenbuffer.peek(input);\n      [topItem, topNode] = stack.top();\n      const nextSym = token == null ? g.Eof : this.getSym(token);\n      const nextValue = token == null ? null : token.value;\n      if (topItem.isTerminal) {\n        if (topItem == nextSym) {\n          // Something must happen here to stack symbol to build\n          // the parse tree\n          this.consumeTokenAndPop(input, nextSym, token!);\n        } else {\n          this.processInvalidToken(nextSym, token);\n        }\n      } else {\n        const entries = this.parseTable.get(topItem, nextSym);\n        if (entries.length != 1) {\n          console.log(\"TopItem: \", topItem);\n          console.log(\"nextSym: \", nextSym);\n          this.processInvalidReductions(topNode, topItem, nextSym, nextValue, entries);\n        } else {\n          const [sym, ptnode] = this.stack.pop();\n          TSU.assert(ptnode == topNode);\n          TSU.assert(sym == entries[0].nt);\n          TSU.assert(ptnode.sym == sym);\n          this.popSymAndPushRule(ptnode, entries[0]);\n        }\n      }\n      [topItem, topNode] = stack.top(); // Update top pointer\n    } while (topItem != g.Eof); // !stack.isEmpty);\n    return stack.rootNode;\n  }\n\n  popSymAndPushRule(parentNode: PTNode, rule: Rule): void {\n    // This needs to match so we can push its children\n    for (let i = rule.rhs.syms.length - 1; i >= 0; i--) {\n      const sym = rule.rhs.syms[i];\n      const node = this.stack.push(sym);\n      parentNode.add(node, 0);\n    }\n  }\n  consumeTokenAndPop(tape: TLEX.Tape, nextSym: Sym, nextToken: TLEX.Token): void {\n    const [sym, ptnode] = this.stack.top();\n    TSU.assert(sym == nextSym);\n    TSU.assert(ptnode.sym == nextSym);\n    ptnode.value = nextToken.value;\n    this.tokenbuffer.next(tape);\n    this.stack.pop();\n  }\n\n  processInvalidToken(nextSym: Sym, nextValue: any): boolean {\n    throw new Error(\"Invalid token: \" + nextSym.label);\n    return true;\n  }\n\n  processInvalidReductions(topNode: PTNode, currSym: Sym, nextSym: Sym, nextValue: any, entries: Rule[]): boolean {\n    throw new Error(`Invalid # reductions ${entries.length} found ${currSym.label} -> ${nextSym.label}`);\n    return true;\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { Sym, Grammar, Rule } from \"./grammar\";\nimport { IDSet } from \"./sets\";\n\ntype Nullable<T> = TSU.Nullable<T>;\ntype NumMap<T> = TSU.NumMap<T>;\n\nexport class LRItem {\n  id = 0;\n  readonly rule: Rule;\n  readonly position: number;\n  constructor(rule: Rule, position = 0) {\n    this.rule = rule;\n    this.position = position;\n  }\n\n  advance(): LRItem {\n    TSU.assert(this.position < this.rule.rhs.length);\n    return new LRItem(this.rule, this.position + 1);\n  }\n\n  copy(): LRItem {\n    return new LRItem(this.rule, this.position);\n  }\n\n  /**\n   * TODO - Instead of using strings as keys, can we use a unique ID?\n   * If we assume a max limit on number of non terminals in our grammar\n   * and a max limit on the number of rules per non terminal and a\n   * max limit on the size of each rule then we can uniquely identify\n   * a rule and position for a non-terminal by a single (64 bit) number\n   *\n   * We can use the following bitpacking to nominate this:\n   *\n   * <padding 16 bits><nt id 16 bits><ruleIndex 16 bits><position 16 bits>\n   */\n  get key(): string {\n    TSU.assert(!isNaN(this.rule.id), \"Rule's ID is not yet set.\");\n    return this.rule.id + \":\" + this.position;\n  }\n\n  compareTo(another: this): number {\n    let diff = this.rule.id - another.rule.id;\n    if (diff == 0) diff = this.position - another.position;\n    return diff;\n  }\n\n  equals(another: this): boolean {\n    return this.compareTo(another) == 0;\n  }\n\n  get debugString(): string {\n    const rule = this.rule;\n    const pos = this.position;\n    const pre = rule.rhs.syms.slice(0, pos).join(\" \");\n    const post = rule.rhs.syms.slice(pos).join(\" \");\n    return `${rule.id}  -  ${rule.nt} -> ${pre} • ${post}`;\n  }\n}\n\nexport class LRItemSet {\n  id = 0;\n  readonly itemGraph: LRItemGraph;\n  protected _key: Nullable<string> = null;\n  readonly values: number[];\n  protected _lookaheads: NumMap<Sym[]> = {};\n  protected _hasLookAheads = false;\n\n  constructor(ig: LRItemGraph, ...entries: number[]) {\n    this.itemGraph = ig;\n    this.values = entries;\n  }\n\n  copy(): LRItemSet {\n    const out = new LRItemSet(this.itemGraph, ...this.values);\n    out._lookaheads = { ...this._lookaheads };\n    out._hasLookAheads = this._hasLookAheads;\n    return out;\n  }\n\n  /**\n   * Adds a new look ahead symbol for a given item.\n   */\n  addLookAhead(item: LRItem, sym: Sym): boolean {\n    if (!(item.id in this._lookaheads)) {\n      this._lookaheads[item.id] = [];\n    }\n    for (const s of this._lookaheads[item.id]) if (s == sym) return false;\n    this._hasLookAheads = true;\n    this._key = null;\n    this._lookaheads[item.id].push(sym);\n    this._lookaheads[item.id].sort((s1, s2) => s1.id - s2.id);\n    return true;\n  }\n\n  /**\n   * Clears all lookaheads from this itemset.\n   */\n  clearLookAheads(): void {\n    this._lookaheads = {};\n  }\n\n  /**\n   * Gets the lookahead symbols for a given item.\n   */\n  getLookAheads(item: LRItem): ReadonlyArray<Sym> {\n    return this._lookaheads[item.id] || [];\n  }\n\n  // A way to cache the key of this item set.\n  // Keys help make the comparison of two sets easy.\n  get key(): string {\n    if (this._key == null) {\n      this._key = this.revalKey();\n    }\n    return this._key;\n  }\n\n  protected revalKey(): string {\n    if (this.hasLookAheads) {\n      this.values.sort();\n      return this.values\n        .map((itemId) => {\n          const la = this._lookaheads[itemId] || [];\n          return itemId + \"[\" + la.map((s) => s.id).join(\",\") + \"]\";\n        })\n        .join(\"/\");\n    } else {\n      this.values.sort();\n      return this.values.join(\"/\");\n    }\n  }\n\n  has(itemId: number): boolean {\n    return this.values.indexOf(itemId) >= 0;\n  }\n\n  equals(another: LRItemSet): boolean {\n    return this.key == another.key;\n  }\n\n  add(itemId: number): this {\n    if (!this.has(itemId)) {\n      this.values.push(itemId);\n      this._key = null;\n    }\n    return this;\n  }\n\n  get size(): number {\n    return this.values.length;\n  }\n\n  get debugString(): string {\n    return this.debugValue.join(\"\\n\");\n  }\n\n  get hasLookAheads(): boolean {\n    return this._hasLookAheads;\n  }\n\n  get debugValue(): any {\n    if (this.hasLookAheads) {\n      const items = this.values.map((v: number) => this.itemGraph.items.get(v));\n      // sort them by rule\n      items.sort((i1, i2) => i1.compareTo(i2));\n      // then append the look aheads\n      return items.map((item) => {\n        const las = this.getLookAheads(item)\n          .map((s) => s.label)\n          .sort((s1, s2) => s1.localeCompare(s2))\n          .join(\", \");\n        return las.length > 0 ? `${item.debugString} / ( ${las} )` : item.debugString;\n      });\n    } else {\n      const items = this.values.map((v: number) => this.itemGraph.items.get(v));\n      // sort them by rule\n      items.sort((i1, i2) => i1.compareTo(i2));\n      return items.map((i) => i.debugString);\n    }\n  }\n}\n\nexport abstract class LRItemGraph {\n  // List of all unique LRItems that can be used in this item graph.\n  // Note that since the same Item can reside in multiple sets only\n  // one is created via the newItem method and it is referred\n  // everwhere it is needed.\n\n  /**\n   * Using IDed sets of Items and ItemSets.\n   * This ensures that only one copy of an item exists\n   * \"by value\".\n   */\n  items: IDSet<LRItem>;\n  itemSets: IDSet<LRItemSet>;\n\n  // Goto sets for a set and a given transition out of it\n  gotoSets: NumMap<NumMap<LRItemSet>> = {};\n\n  abstract closure(itemSet: LRItemSet): LRItemSet;\n  abstract startSet(): LRItemSet;\n\n  constructor(public readonly grammar: Grammar) {\n    this.items = new IDSet();\n    this.itemSets = new IDSet();\n  }\n\n  protected startItem(): LRItem {\n    const startSymbol = this.grammar.startSymbol;\n    TSU.assert(startSymbol != null, \"Start symbol must be set\");\n    TSU.assert((this.grammar.augStartRule || null) != null, \"Grammar is not augmented\");\n    return this.items.ensure(new LRItem(this.grammar.augStartRule));\n  }\n\n  reset(): void {\n    this.grammar.refresh();\n    this.gotoSets = {};\n    this.items.clear();\n    this.itemSets.clear();\n    this.startSet();\n  }\n\n  refresh(): this {\n    this.reset();\n    this.grammar.refresh();\n    this.evalGotoSets();\n    return this;\n  }\n\n  /**\n   * Computes all the goto sets used to create the graph of items.\n   */\n  protected evalGotoSets(): void {\n    const out = this.itemSets;\n    for (let i = 0; i < out.size; i++) {\n      const currSet = out.get(i);\n      // This will also include the null symbol since Grammar\n      // adds Null and Eof symbols automatically\n      for (const sym of this.grammar.allSymbols) {\n        if (sym != this.grammar.Null) {\n          const gotoSet = this.goto(currSet, sym);\n          if (gotoSet.size > 0) {\n            this.setGoto(currSet, sym, gotoSet);\n          }\n        }\n      }\n    }\n  }\n\n  /**\n   * Computes the GOTO set of this ItemSet for a particular symbol transitioning\n   * out of this item set.\n   */\n  goto(itemSet: LRItemSet, sym: Sym): LRItemSet {\n    const out = this.newItemSet();\n    for (const itemId of itemSet.values) {\n      const item = this.items.get(itemId);\n      // see if item.position points to \"sym\" in its rule\n      const rule = item.rule;\n      if (item.position < rule.rhs.length) {\n        if (rule.rhs.syms[item.position] == sym) {\n          // advance the item and add it\n          this.advanceItemAndAdd(item, itemSet, out);\n        }\n      }\n    }\n    // compute the closure of the new set\n    return this.closure(out);\n  }\n\n  protected advanceItemAndAdd(itemToAdvance: LRItem, fromItemSet: LRItemSet, toItemSet: LRItemSet): void {\n    const newItem = this.items.ensure(itemToAdvance.advance());\n    toItemSet.add(newItem.id);\n    // copy over the look aheads\n    for (const laSym of fromItemSet.getLookAheads(itemToAdvance)) {\n      toItemSet.addLookAhead(newItem, laSym);\n    }\n  }\n\n  protected newItemSet(...items: LRItem[]): LRItemSet {\n    return new LRItemSet(this, ...items.map((item) => item.id));\n  }\n\n  get size(): number {\n    return this.itemSets.size;\n  }\n\n  protected ensureGotoSet(fromSet: LRItemSet): NumMap<LRItemSet> {\n    if (!(fromSet.id in this.gotoSets)) {\n      this.gotoSets[fromSet.id] = {};\n    }\n    return this.gotoSets[fromSet.id];\n  }\n\n  setGoto(fromSet: LRItemSet, sym: Sym, toSet: LRItemSet): void {\n    const entries = this.ensureGotoSet(fromSet);\n    entries[sym.id] = toSet;\n  }\n\n  getGoto(fromSet: LRItemSet, sym: Sym): Nullable<LRItemSet> {\n    return (this.gotoSets[fromSet.id] || {})[sym.id] || null;\n  }\n\n  forEachGoto(itemSet: LRItemSet, visitor: (sym: Sym, nextSet: LRItemSet) => boolean | void): void {\n    const gotoSet = this.gotoSets[itemSet.id] || {};\n    for (const symid in gotoSet) {\n      const sym = this.grammar.getSymById(symid as any) as Sym;\n      const next = gotoSet[symid];\n      if (visitor(sym, next) == false) break;\n    }\n  }\n\n  gotoSetFor(itemSet: LRItemSet): NumMap<LRItemSet> {\n    return this.gotoSets[itemSet.id] || {};\n  }\n\n  get debugValue(): any {\n    const out = {} as any;\n    this.itemSets.entries.forEach((iset) => {\n      out[iset.id] = { items: [], goto: {} };\n      out[iset.id][\"items\"] = iset.debugValue;\n      const g = this.gotoSets[iset.id];\n      for (const symid in g) {\n        const sym = this.grammar.getSymById(symid as any)!;\n        out[iset.id][\"goto\"] = out[iset.id][\"goto\"] || {};\n        out[iset.id][\"goto\"][sym.label] = g[symid].id;\n      }\n    });\n    return out;\n  }\n}\n\nexport class LR0ItemGraph extends LRItemGraph {\n  /**\n   * Creates the set for the grammar.  This is done by creating an\n   * augmented rule of the form S' -> S (where S is the start symbol of\n   * the grammar) and creating the closure of this starting rule, ie:\n   *\n   * StartSet = closure({S' -> . S})\n   */\n  startSet(): LRItemSet {\n    const startItem = this.startItem();\n    const newset = this.newItemSet(startItem);\n    return this.closure(newset);\n  }\n\n  /**\n   * Computes the closure of a given item set and returns a new\n   * item set.\n   */\n  closure(itemSet: LRItemSet): LRItemSet {\n    const out = new LRItemSet(this, ...itemSet.values);\n    for (let i = 0; i < out.values.length; i++) {\n      const itemId = out.values[i];\n      const item = this.items.get(itemId)!;\n      const rule = item.rule;\n      // Evaluate the closure\n      // Cannot do anything past the end\n      if (item.position < rule.rhs.length) {\n        const sym = rule.rhs.syms[item.position];\n        if (!sym.isTerminal) {\n          for (const rule of this.grammar.rulesForNT(sym)) {\n            const newItem = this.items.ensure(new LRItem(rule, 0));\n            out.add(newItem.id);\n          }\n        }\n      }\n    }\n    return out.size == 0 ? out : this.itemSets.ensure(out);\n  }\n}\n\nexport class LR1ItemGraph extends LRItemGraph {\n  /**\n   * Overridden to include the EOF marker as the lookahead for the start state\n   *\n   * StartSet = closure({S' -> . S, $})\n   */\n  startSet(): LRItemSet {\n    const startItem = this.startItem();\n    const newset = this.newItemSet(startItem);\n    newset.addLookAhead(startItem, this.grammar.Eof);\n    return this.closure(newset);\n  }\n\n  /**\n   * Computes the closure of this item set and returns a new\n   * item set.\n   */\n  closure(itemSet: LRItemSet): LRItemSet {\n    const out = itemSet.copy();\n    for (let i = 0; i < out.values.length; i++) {\n      const itemId = out.values[i];\n      const item = this.items.get(itemId) as LRItem;\n      // Evaluate the closure\n      // Cannot do anything past the end\n      if (item.position >= item.rule.rhs.length) continue;\n      const rhs = item.rule.rhs;\n      const B = rhs.syms[item.position];\n      if (B.isTerminal) continue;\n\n      for (const lookahead of out.getLookAheads(item)) {\n        const suffix = rhs.copy().append(lookahead);\n        this.grammar.firstSets.forEachTermIn(suffix, item.position + 1, (term) => {\n          if (term != null) {\n            // For each rule [ B -> beta, term ] add it to\n            // our list of items if it doesnt already exist\n            const bRules = this.grammar.rulesForNT(B);\n            for (const br of bRules) {\n              const newItem = this.items.ensure(new LRItem(br, 0));\n              out.add(newItem.id);\n              out.addLookAhead(newItem, term);\n            }\n          }\n        });\n      }\n    }\n    return out.size == 0 ? out : this.itemSets.ensure(out);\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { Grammar, Str, Sym, Rule } from \"./grammar\";\nimport { LRAction, ParseTable } from \"./lr\";\nimport { LRItem, LRItemSet, LRItemGraph, LR0ItemGraph, LR1ItemGraph } from \"./lritems\";\nimport { Goto } from \"./tests/utils\";\n\nexport function makeParseTable(g: Grammar, type = \"lr1\"): [ParseTable, LRItemGraph] {\n  switch (type) {\n    case \"lr1\":\n      return makeLRParseTable(g);\n    case \"lalr\":\n      return makeLALRParseTable(g);\n  }\n  return makeSLRParseTable(g);\n}\n\n/**\n * A SLR parse table maker.\n */\nexport function makeSLRParseTable(grammar: Grammar): [ParseTable, LRItemGraph] {\n  const ig = makeSLRAutomaton(grammar);\n  return [makeParseTableFromLA(ig, grammar), ig];\n}\n\nexport function makeSLRAutomaton(grammar: Grammar): LRItemGraph {\n  const ig = new LR0ItemGraph(grammar).refresh();\n  for (const itemSet of ig.itemSets.entries) {\n    evalLASetsForSLRItem(grammar, ig, itemSet);\n  }\n  return ig;\n}\n\n/**\n * For a given LR(0) Item in the LR0 automaton evaluates the lookahead set\n * for an SLR1 parse table.\n *\n * The SLR lookahead is:\n *\n *    SLRLA(q, A -> w) = Follow(A)\n *\n * @param grammar\n * @param ig\n * @param itemSet\n */\nexport function evalLASetsForSLRItem(grammar: Grammar, ig: LRItemGraph, itemSet: LRItemSet): void {\n  // Look for transitions from this set\n  for (const itemId of itemSet.values) {\n    const item = ig.items.get(itemId);\n    const rule = item.rule;\n    if (item.position >= rule.rhs.length) {\n      // if sym is in follows(nt) then add the rule\n      // Reduce nt -> rule for all sym in follows(nt)\n      grammar.followSets.forEachTerm(rule.nt, (term) => {\n        if (term != null) {\n          TSU.assert(term.isTerminal);\n          itemSet.addLookAhead(item, term);\n        }\n      });\n    }\n  }\n}\n\n/**\n * A canonical LR1 parse table maker.\n */\nexport function makeLRParseTable(grammar: Grammar): [ParseTable, LRItemGraph] {\n  const ig = new LR1ItemGraph(grammar).refresh();\n  const parseTable = makeParseTableFromLA(ig, grammar);\n  return [parseTable, ig];\n}\n\n/**\n * A LALR(1) parse table maker using Bermudez and Logothetis' (1989)\n *  \"Simple computation of LALR(1) lookahead sets\" method.\n */\nexport function makeLALRParseTable(grammar: Grammar): [ParseTable, LRItemGraph] {\n  // const [parseTable, ig] = makeSLRParseTable(grammar);\n  const [parseTable, ig] = makeSLRParseTable(grammar);\n\n  if (!parseTable.hasConflicts) {\n    return [parseTable, ig];\n  }\n\n  // This is a really simple method compared to DeRemer and Penello's method\n  // (based on relations).\n  //\n  // 1. First transform the grammar G into G' that is based on around the LR0\n  // item graph\n  const g2 = grammarFromLR0ItemGraph(ig, grammar);\n\n  // Reverse of goto sets in the LR automaton to track predecessor states.\n  const prevSets: TSU.NumMap<TSU.NumMap<Set<number>>> = {};\n\n  for (const startState in ig.gotoSets) {\n    for (const symId in ig.gotoSets[startState]) {\n      const nextSet = ig.gotoSets[startState][symId];\n      if (!(nextSet.id in prevSets)) {\n        prevSets[nextSet.id] = {};\n      }\n      if (!(symId in prevSets[nextSet.id])) {\n        prevSets[nextSet.id][symId] = new Set();\n      }\n      prevSets[nextSet.id][symId].add(startState as any as number);\n    }\n  }\n\n  // For conflict states upgrade lookahead sets based on union of follow\n  // sets of G2 for the corresponding sets\n  // LALRLA(q, A -> w) =\n  for (const startState in parseTable.conflictActions) {\n    // So here we have a startState where a symbol was extraneously added\n    // into the look ahead set.   So here recompute the lookahead set\n    // for this state\n    const itemSet = ig.itemSets.get(startState as any as number);\n    evalLASetsForLALRItem(grammar, g2, ig, itemSet, prevSets);\n  }\n\n  // Now that all look aheads have been recomputed - recreate\n  // the parse table\n  return [makeParseTableFromLA(ig, grammar), ig];\n}\n\n/**\n * Shared parse table creator for SLR/LR/LALR grammars that have lookahead\n * in the LR0 automaton.\n */\nexport function makeParseTableFromLA(ig: LRItemGraph, grammar: Grammar): ParseTable {\n  const parseTable = new ParseTable(grammar);\n  for (const itemSet of ig.itemSets.entries) {\n    // Look for transitions from this set\n    for (const itemId of itemSet.values) {\n      const item = ig.items.get(itemId);\n      const rule = item.rule;\n      if (item.position < rule.rhs.length) {\n        // possibilities of shift\n        const sym = rule.rhs.syms[item.position];\n        if (sym.isTerminal) {\n          const nextSet = ig.getGoto(itemSet, sym);\n          if (nextSet) {\n            parseTable.addAction(itemSet.id, sym, LRAction.Shift(nextSet.id));\n          }\n        }\n      } else if (!rule.nt.equals(grammar.augStartRule.nt)) {\n        // We have nt -> rule DOT / t\n        // AND nt != S'\n        // Reduce nt -> rule for t\n        const lookaheads = itemSet.getLookAheads(item);\n        for (const lookahead of lookaheads) {\n          parseTable.addAction(itemSet.id, lookahead, LRAction.Reduce(rule));\n        }\n      }\n    }\n\n    // Now create GOTO entries for (State,X) where X is a non-term\n    ig.forEachGoto(itemSet, (sym, next) => {\n      if (sym != null && !sym.isTerminal) {\n        parseTable.addAction(itemSet.id, sym, LRAction.Goto(next.id));\n      }\n    });\n\n    // If this state contains the augmented item, S' -> S . / $\n    // then add accept\n    const lr1Item = ig.items.ensure(new LRItem(grammar.augStartRule, 1));\n    itemSet.addLookAhead(lr1Item, grammar.Eof);\n    if (itemSet.has(lr1Item.id)) {\n      parseTable.addAction(itemSet.id, grammar.Eof, LRAction.Accept());\n    }\n  }\n  return parseTable;\n}\n\n/**\n * For a given LR(0) Item in the LR0 automaton evaluates the lookahead set\n * for an LALR1 parse table.\n *\n * The LALR lookahead is:\n *\n *    LALRLA(q, A -> w) = {t | [r:t] in Follow[p: A], Go[p: w] = q }\n *\n * Here [r: t] refers to a state in the augmented grammar transformed from the original\n * grammar where the nonterminals and terminals are based on the transitions in the\n * LR(0) automaton.  This augmented grammar is also passed in as a parameter.\n *\n * @param grammar     - Original grammar\n * @param augGrammar  - Augmented grammar\n * @param ig          - LR0 Automaton\n * @param itemSet     - The item set in the automaton (ie a particular state)\n *                      for which lookahead sets are to be computed.\n * @param prevSets    - A mapping where prevSets[stateI][symId] is a list of\n *                      states X1,X2...Xn where where the transition\n *                      X1[symId] = stateI, X2[symId] = stateI ...\n *                      Xn[symId] = stateI\n */\nexport function evalLASetsForLALRItem(\n  grammar: Grammar,\n  augGrammar: Grammar,\n  ig: LRItemGraph,\n  itemSet: LRItemSet,\n  prevSets: TSU.NumMap<TSU.NumMap<Set<number>>>,\n): void {\n  // find p going backwards from q spelling w\n  function findP(rule: Rule, i: number, currState: number, states: Set<number>): void {\n    if (i < 0) {\n      // we have reached the end - currState is P\n      // Ensure there is a transition from currState on rule.nt\n      const transitions: TSU.NumMap<LRItemSet> = ig.gotoSets[currState];\n      TSU.assert((transitions[rule.nt.id] || null) != null, \"Transition on rule.nt missing from start state\");\n      states.add(currState);\n    } else {\n      const sym = rule.rhs.syms[i];\n      const prevStates = prevSets[currState][sym.id] || null;\n      TSU.assert(prevStates != null, \"Prev set should not be null\");\n      prevStates.forEach((nextState) => findP(rule, i - 1, nextState, states));\n    }\n  }\n\n  itemSet.clearLookAheads();\n  // Look for transitions from this set\n  for (const itemId of itemSet.values) {\n    const item = ig.items.get(itemId);\n    const rule = item.rule;\n    if (item.position >= rule.rhs.length) {\n      // Here we have rule of the form A -> w in state q\n      //\n      // For this state we compute LALR lookaheads as:\n      //\n      // LALRLA(q, A -> w) = {t | [r:t] in Follow[p: A], Go[p: w] = q }\n      const pSet = new Set<number>();\n      findP(rule, rule.rhs.length - 1, itemSet.id, pSet);\n      pSet.forEach((p) => {\n        // Now find the NT [p: A] in the augmented grammar\n        const pALabel = `[${p}:${rule.nt.label}]`;\n        const pA = augGrammar.getSym(pALabel);\n        TSU.assert(pA != null, \"Augmented grammar symbol [p:A] not found\");\n        augGrammar.followSets.forEachTerm(pA, (term) => {\n          if (term != null && term != augGrammar.Eof) {\n            TSU.assert(term.isTerminal);\n            // This term is in the form [r: T] in the augmented grammar.\n            // Get the T from this and add to the look ahead set\n            const label = term.label.substring(term.label.indexOf(\":\") + 1, term.label.length - 1).trim();\n            const T = grammar.getSym(label);\n            TSU.assert(T != null, `T (${label}) in [r:T] cannot be null`);\n            itemSet.addLookAhead(item, T);\n          }\n        });\n      });\n    }\n  }\n}\n\n/**\n * For a grammar G and its LR0 ItemGraph, IG, returns a transformed grammar G'\n * that is based along the transitions of IG.\n *\n * For this new Grammar G' we have:\n *\n * NonTerminals N' =  { [p: A] | if Go[p: A] is defined },\n * Terminals T' =  { [p: t] | if Go[p: t] is defined },\n * Start Symbol S' = [ Start : S ]\n * Productions P' =  { [p1 : A ] -> [p1 : X1][p2 : X2]...[pn : Xn], if\n *                            [p1 : A] is in N'         AND\n *                            [pi : Xi] is in N' U T'   AND\n *                            A -> X1 X2 .. An is in P (of original grammar G)\n */\nexport function grammarFromLR0ItemGraph(ig: LR0ItemGraph, g: Grammar): Grammar {\n  const g2 = new Grammar();\n\n  function ensureG2Sym(pi: number, sym: Sym): Sym {\n    const newSymLabel = `[${pi}:${sym.label}]`;\n    const newSym = g2.ensureSym(new Sym(g2, newSymLabel, sym.isTerminal), false);\n    if (pi == 0 && g.startSymbol == sym && g.startSymbol != newSym && !sym.isTerminal) {\n      g2.startSymbol = newSym;\n    }\n    return newSym;\n  }\n\n  // Create N', T' and S'\n  for (const startState in ig.gotoSets) {\n    // transitions is a Map of symId -> ItemSet\n    const transitions: TSU.NumMap<LRItemSet> = ig.gotoSets[startState];\n    for (const symId in transitions) {\n      const sym = g.getSymById(symId as any as number)!;\n      ensureG2Sym(startState as any as number, sym);\n    }\n  }\n\n  function buildRuleFrom(startSet: number, A: Sym, rule: Rule): Str {\n    // Str to be built up for the production in the transformed grammar\n    //    -   [P1:X1][P2:X2]...[Pn:Xn]\n    let pi = startSet;\n    const newSyms = rule.rhs.syms.map((xi, index) => {\n      const nextSym = ensureG2Sym(pi, xi);\n      const transitions: TSU.NumMap<LRItemSet> = ig.gotoSets[pi];\n      const nextSet = transitions[xi.id] || null;\n      TSU.assert(nextSet != null, \"Next set transition *must* be valid\");\n      pi = nextSet.id;\n      return nextSym;\n    });\n    return new Str(...newSyms);\n  }\n\n  for (const startState in ig.gotoSets) {\n    // from P1 - for every transition that is a non terminal A\n    // find an equivalent chain of transition starting from P1 where we have\n    // [P1:X1][P2:X2]...[Pn:Xn]\n    // for All A -> X1X2...Xn in G\n    const transitions: TSU.NumMap<LRItemSet> = ig.gotoSets[startState];\n    for (const symId in transitions) {\n      const startSym = g.getSymById(symId as any as number)!;\n      const p1 = startState as any as number;\n      if (!startSym.isTerminal) {\n        const newA = ensureG2Sym(p1, startSym);\n        g.forEachRule(startSym, (rule, index) => {\n          const newRHS = buildRuleFrom(p1, startSym, rule);\n          const newRule = new Rule(newA, newRHS);\n          g2.addRule(newRule);\n        });\n      }\n    }\n  }\n  // Do another pass to evaluate P'\n  return g2;\n}\n","const ALIAS = Symbol.for('yaml.alias');\nconst DOC = Symbol.for('yaml.document');\nconst MAP = Symbol.for('yaml.map');\nconst PAIR = Symbol.for('yaml.pair');\nconst SCALAR = Symbol.for('yaml.scalar');\nconst SEQ = Symbol.for('yaml.seq');\nconst NODE_TYPE = Symbol.for('yaml.node.type');\nconst isAlias = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === ALIAS;\nconst isDocument = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === DOC;\nconst isMap = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === MAP;\nconst isPair = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === PAIR;\nconst isScalar = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === SCALAR;\nconst isSeq = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === SEQ;\nfunction isCollection(node) {\n    if (node && typeof node === 'object')\n        switch (node[NODE_TYPE]) {\n            case MAP:\n            case SEQ:\n                return true;\n        }\n    return false;\n}\nfunction isNode(node) {\n    if (node && typeof node === 'object')\n        switch (node[NODE_TYPE]) {\n            case ALIAS:\n            case MAP:\n            case SCALAR:\n            case SEQ:\n                return true;\n        }\n    return false;\n}\nconst hasAnchor = (node) => (isScalar(node) || isCollection(node)) && !!node.anchor;\n\nexport { ALIAS, DOC, MAP, NODE_TYPE, PAIR, SCALAR, SEQ, hasAnchor, isAlias, isCollection, isDocument, isMap, isNode, isPair, isScalar, isSeq };\n","import { isDocument, isNode, isPair, isCollection, isMap, isSeq, isScalar, isAlias } from './nodes/identity.js';\n\nconst BREAK = Symbol('break visit');\nconst SKIP = Symbol('skip children');\nconst REMOVE = Symbol('remove node');\n/**\n * Apply a visitor to an AST node or document.\n *\n * Walks through the tree (depth-first) starting from `node`, calling a\n * `visitor` function with three arguments:\n *   - `key`: For sequence values and map `Pair`, the node's index in the\n *     collection. Within a `Pair`, `'key'` or `'value'`, correspondingly.\n *     `null` for the root node.\n *   - `node`: The current node.\n *   - `path`: The ancestry of the current node.\n *\n * The return value of the visitor may be used to control the traversal:\n *   - `undefined` (default): Do nothing and continue\n *   - `visit.SKIP`: Do not visit the children of this node, continue with next\n *     sibling\n *   - `visit.BREAK`: Terminate traversal completely\n *   - `visit.REMOVE`: Remove the current node, then continue with the next one\n *   - `Node`: Replace the current node, then continue by visiting it\n *   - `number`: While iterating the items of a sequence or map, set the index\n *     of the next step. This is useful especially if the index of the current\n *     node has changed.\n *\n * If `visitor` is a single function, it will be called with all values\n * encountered in the tree, including e.g. `null` values. Alternatively,\n * separate visitor functions may be defined for each `Map`, `Pair`, `Seq`,\n * `Alias` and `Scalar` node. To define the same visitor function for more than\n * one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar)\n * and `Node` (alias, map, seq & scalar) targets. Of all these, only the most\n * specific defined one will be used for each node.\n */\nfunction visit(node, visitor) {\n    const visitor_ = initVisitor(visitor);\n    if (isDocument(node)) {\n        const cd = visit_(null, node.contents, visitor_, Object.freeze([node]));\n        if (cd === REMOVE)\n            node.contents = null;\n    }\n    else\n        visit_(null, node, visitor_, Object.freeze([]));\n}\n// Without the `as symbol` casts, TS declares these in the `visit`\n// namespace using `var`, but then complains about that because\n// `unique symbol` must be `const`.\n/** Terminate visit traversal completely */\nvisit.BREAK = BREAK;\n/** Do not visit the children of the current node */\nvisit.SKIP = SKIP;\n/** Remove the current node */\nvisit.REMOVE = REMOVE;\nfunction visit_(key, node, visitor, path) {\n    const ctrl = callVisitor(key, node, visitor, path);\n    if (isNode(ctrl) || isPair(ctrl)) {\n        replaceNode(key, path, ctrl);\n        return visit_(key, ctrl, visitor, path);\n    }\n    if (typeof ctrl !== 'symbol') {\n        if (isCollection(node)) {\n            path = Object.freeze(path.concat(node));\n            for (let i = 0; i < node.items.length; ++i) {\n                const ci = visit_(i, node.items[i], visitor, path);\n                if (typeof ci === 'number')\n                    i = ci - 1;\n                else if (ci === BREAK)\n                    return BREAK;\n                else if (ci === REMOVE) {\n                    node.items.splice(i, 1);\n                    i -= 1;\n                }\n            }\n        }\n        else if (isPair(node)) {\n            path = Object.freeze(path.concat(node));\n            const ck = visit_('key', node.key, visitor, path);\n            if (ck === BREAK)\n                return BREAK;\n            else if (ck === REMOVE)\n                node.key = null;\n            const cv = visit_('value', node.value, visitor, path);\n            if (cv === BREAK)\n                return BREAK;\n            else if (cv === REMOVE)\n                node.value = null;\n        }\n    }\n    return ctrl;\n}\n/**\n * Apply an async visitor to an AST node or document.\n *\n * Walks through the tree (depth-first) starting from `node`, calling a\n * `visitor` function with three arguments:\n *   - `key`: For sequence values and map `Pair`, the node's index in the\n *     collection. Within a `Pair`, `'key'` or `'value'`, correspondingly.\n *     `null` for the root node.\n *   - `node`: The current node.\n *   - `path`: The ancestry of the current node.\n *\n * The return value of the visitor may be used to control the traversal:\n *   - `Promise`: Must resolve to one of the following values\n *   - `undefined` (default): Do nothing and continue\n *   - `visit.SKIP`: Do not visit the children of this node, continue with next\n *     sibling\n *   - `visit.BREAK`: Terminate traversal completely\n *   - `visit.REMOVE`: Remove the current node, then continue with the next one\n *   - `Node`: Replace the current node, then continue by visiting it\n *   - `number`: While iterating the items of a sequence or map, set the index\n *     of the next step. This is useful especially if the index of the current\n *     node has changed.\n *\n * If `visitor` is a single function, it will be called with all values\n * encountered in the tree, including e.g. `null` values. Alternatively,\n * separate visitor functions may be defined for each `Map`, `Pair`, `Seq`,\n * `Alias` and `Scalar` node. To define the same visitor function for more than\n * one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar)\n * and `Node` (alias, map, seq & scalar) targets. Of all these, only the most\n * specific defined one will be used for each node.\n */\nasync function visitAsync(node, visitor) {\n    const visitor_ = initVisitor(visitor);\n    if (isDocument(node)) {\n        const cd = await visitAsync_(null, node.contents, visitor_, Object.freeze([node]));\n        if (cd === REMOVE)\n            node.contents = null;\n    }\n    else\n        await visitAsync_(null, node, visitor_, Object.freeze([]));\n}\n// Without the `as symbol` casts, TS declares these in the `visit`\n// namespace using `var`, but then complains about that because\n// `unique symbol` must be `const`.\n/** Terminate visit traversal completely */\nvisitAsync.BREAK = BREAK;\n/** Do not visit the children of the current node */\nvisitAsync.SKIP = SKIP;\n/** Remove the current node */\nvisitAsync.REMOVE = REMOVE;\nasync function visitAsync_(key, node, visitor, path) {\n    const ctrl = await callVisitor(key, node, visitor, path);\n    if (isNode(ctrl) || isPair(ctrl)) {\n        replaceNode(key, path, ctrl);\n        return visitAsync_(key, ctrl, visitor, path);\n    }\n    if (typeof ctrl !== 'symbol') {\n        if (isCollection(node)) {\n            path = Object.freeze(path.concat(node));\n            for (let i = 0; i < node.items.length; ++i) {\n                const ci = await visitAsync_(i, node.items[i], visitor, path);\n                if (typeof ci === 'number')\n                    i = ci - 1;\n                else if (ci === BREAK)\n                    return BREAK;\n                else if (ci === REMOVE) {\n                    node.items.splice(i, 1);\n                    i -= 1;\n                }\n            }\n        }\n        else if (isPair(node)) {\n            path = Object.freeze(path.concat(node));\n            const ck = await visitAsync_('key', node.key, visitor, path);\n            if (ck === BREAK)\n                return BREAK;\n            else if (ck === REMOVE)\n                node.key = null;\n            const cv = await visitAsync_('value', node.value, visitor, path);\n            if (cv === BREAK)\n                return BREAK;\n            else if (cv === REMOVE)\n                node.value = null;\n        }\n    }\n    return ctrl;\n}\nfunction initVisitor(visitor) {\n    if (typeof visitor === 'object' &&\n        (visitor.Collection || visitor.Node || visitor.Value)) {\n        return Object.assign({\n            Alias: visitor.Node,\n            Map: visitor.Node,\n            Scalar: visitor.Node,\n            Seq: visitor.Node\n        }, visitor.Value && {\n            Map: visitor.Value,\n            Scalar: visitor.Value,\n            Seq: visitor.Value\n        }, visitor.Collection && {\n            Map: visitor.Collection,\n            Seq: visitor.Collection\n        }, visitor);\n    }\n    return visitor;\n}\nfunction callVisitor(key, node, visitor, path) {\n    if (typeof visitor === 'function')\n        return visitor(key, node, path);\n    if (isMap(node))\n        return visitor.Map?.(key, node, path);\n    if (isSeq(node))\n        return visitor.Seq?.(key, node, path);\n    if (isPair(node))\n        return visitor.Pair?.(key, node, path);\n    if (isScalar(node))\n        return visitor.Scalar?.(key, node, path);\n    if (isAlias(node))\n        return visitor.Alias?.(key, node, path);\n    return undefined;\n}\nfunction replaceNode(key, path, node) {\n    const parent = path[path.length - 1];\n    if (isCollection(parent)) {\n        parent.items[key] = node;\n    }\n    else if (isPair(parent)) {\n        if (key === 'key')\n            parent.key = node;\n        else\n            parent.value = node;\n    }\n    else if (isDocument(parent)) {\n        parent.contents = node;\n    }\n    else {\n        const pt = isAlias(parent) ? 'alias' : 'scalar';\n        throw new Error(`Cannot replace node with ${pt} parent`);\n    }\n}\n\nexport { visit, visitAsync };\n","import { isNode } from '../nodes/identity.js';\nimport { visit } from '../visit.js';\n\nconst escapeChars = {\n    '!': '%21',\n    ',': '%2C',\n    '[': '%5B',\n    ']': '%5D',\n    '{': '%7B',\n    '}': '%7D'\n};\nconst escapeTagName = (tn) => tn.replace(/[!,[\\]{}]/g, ch => escapeChars[ch]);\nclass Directives {\n    constructor(yaml, tags) {\n        /**\n         * The directives-end/doc-start marker `---`. If `null`, a marker may still be\n         * included in the document's stringified representation.\n         */\n        this.docStart = null;\n        /** The doc-end marker `...`.  */\n        this.docEnd = false;\n        this.yaml = Object.assign({}, Directives.defaultYaml, yaml);\n        this.tags = Object.assign({}, Directives.defaultTags, tags);\n    }\n    clone() {\n        const copy = new Directives(this.yaml, this.tags);\n        copy.docStart = this.docStart;\n        return copy;\n    }\n    /**\n     * During parsing, get a Directives instance for the current document and\n     * update the stream state according to the current version's spec.\n     */\n    atDocument() {\n        const res = new Directives(this.yaml, this.tags);\n        switch (this.yaml.version) {\n            case '1.1':\n                this.atNextDocument = true;\n                break;\n            case '1.2':\n                this.atNextDocument = false;\n                this.yaml = {\n                    explicit: Directives.defaultYaml.explicit,\n                    version: '1.2'\n                };\n                this.tags = Object.assign({}, Directives.defaultTags);\n                break;\n        }\n        return res;\n    }\n    /**\n     * @param onError - May be called even if the action was successful\n     * @returns `true` on success\n     */\n    add(line, onError) {\n        if (this.atNextDocument) {\n            this.yaml = { explicit: Directives.defaultYaml.explicit, version: '1.1' };\n            this.tags = Object.assign({}, Directives.defaultTags);\n            this.atNextDocument = false;\n        }\n        const parts = line.trim().split(/[ \\t]+/);\n        const name = parts.shift();\n        switch (name) {\n            case '%TAG': {\n                if (parts.length !== 2) {\n                    onError(0, '%TAG directive should contain exactly two parts');\n                    if (parts.length < 2)\n                        return false;\n                }\n                const [handle, prefix] = parts;\n                this.tags[handle] = prefix;\n                return true;\n            }\n            case '%YAML': {\n                this.yaml.explicit = true;\n                if (parts.length !== 1) {\n                    onError(0, '%YAML directive should contain exactly one part');\n                    return false;\n                }\n                const [version] = parts;\n                if (version === '1.1' || version === '1.2') {\n                    this.yaml.version = version;\n                    return true;\n                }\n                else {\n                    const isValid = /^\\d+\\.\\d+$/.test(version);\n                    onError(6, `Unsupported YAML version ${version}`, isValid);\n                    return false;\n                }\n            }\n            default:\n                onError(0, `Unknown directive ${name}`, true);\n                return false;\n        }\n    }\n    /**\n     * Resolves a tag, matching handles to those defined in %TAG directives.\n     *\n     * @returns Resolved tag, which may also be the non-specific tag `'!'` or a\n     *   `'!local'` tag, or `null` if unresolvable.\n     */\n    tagName(source, onError) {\n        if (source === '!')\n            return '!'; // non-specific tag\n        if (source[0] !== '!') {\n            onError(`Not a valid tag: ${source}`);\n            return null;\n        }\n        if (source[1] === '<') {\n            const verbatim = source.slice(2, -1);\n            if (verbatim === '!' || verbatim === '!!') {\n                onError(`Verbatim tags aren't resolved, so ${source} is invalid.`);\n                return null;\n            }\n            if (source[source.length - 1] !== '>')\n                onError('Verbatim tags must end with a >');\n            return verbatim;\n        }\n        const [, handle, suffix] = source.match(/^(.*!)([^!]*)$/s);\n        if (!suffix)\n            onError(`The ${source} tag has no suffix`);\n        const prefix = this.tags[handle];\n        if (prefix) {\n            try {\n                return prefix + decodeURIComponent(suffix);\n            }\n            catch (error) {\n                onError(String(error));\n                return null;\n            }\n        }\n        if (handle === '!')\n            return source; // local tag\n        onError(`Could not resolve tag: ${source}`);\n        return null;\n    }\n    /**\n     * Given a fully resolved tag, returns its printable string form,\n     * taking into account current tag prefixes and defaults.\n     */\n    tagString(tag) {\n        for (const [handle, prefix] of Object.entries(this.tags)) {\n            if (tag.startsWith(prefix))\n                return handle + escapeTagName(tag.substring(prefix.length));\n        }\n        return tag[0] === '!' ? tag : `!<${tag}>`;\n    }\n    toString(doc) {\n        const lines = this.yaml.explicit\n            ? [`%YAML ${this.yaml.version || '1.2'}`]\n            : [];\n        const tagEntries = Object.entries(this.tags);\n        let tagNames;\n        if (doc && tagEntries.length > 0 && isNode(doc.contents)) {\n            const tags = {};\n            visit(doc.contents, (_key, node) => {\n                if (isNode(node) && node.tag)\n                    tags[node.tag] = true;\n            });\n            tagNames = Object.keys(tags);\n        }\n        else\n            tagNames = [];\n        for (const [handle, prefix] of tagEntries) {\n            if (handle === '!!' && prefix === 'tag:yaml.org,2002:')\n                continue;\n            if (!doc || tagNames.some(tn => tn.startsWith(prefix)))\n                lines.push(`%TAG ${handle} ${prefix}`);\n        }\n        return lines.join('\\n');\n    }\n}\nDirectives.defaultYaml = { explicit: false, version: '1.2' };\nDirectives.defaultTags = { '!!': 'tag:yaml.org,2002:' };\n\nexport { Directives };\n","import { isScalar, isCollection } from '../nodes/identity.js';\nimport { visit } from '../visit.js';\n\n/**\n * Verify that the input string is a valid anchor.\n *\n * Will throw on errors.\n */\nfunction anchorIsValid(anchor) {\n    if (/[\\x00-\\x19\\s,[\\]{}]/.test(anchor)) {\n        const sa = JSON.stringify(anchor);\n        const msg = `Anchor must not contain whitespace or control characters: ${sa}`;\n        throw new Error(msg);\n    }\n    return true;\n}\nfunction anchorNames(root) {\n    const anchors = new Set();\n    visit(root, {\n        Value(_key, node) {\n            if (node.anchor)\n                anchors.add(node.anchor);\n        }\n    });\n    return anchors;\n}\n/** Find a new anchor name with the given `prefix` and a one-indexed suffix. */\nfunction findNewAnchor(prefix, exclude) {\n    for (let i = 1; true; ++i) {\n        const name = `${prefix}${i}`;\n        if (!exclude.has(name))\n            return name;\n    }\n}\nfunction createNodeAnchors(doc, prefix) {\n    const aliasObjects = [];\n    const sourceObjects = new Map();\n    let prevAnchors = null;\n    return {\n        onAnchor: (source) => {\n            aliasObjects.push(source);\n            prevAnchors ?? (prevAnchors = anchorNames(doc));\n            const anchor = findNewAnchor(prefix, prevAnchors);\n            prevAnchors.add(anchor);\n            return anchor;\n        },\n        /**\n         * With circular references, the source node is only resolved after all\n         * of its child nodes are. This is why anchors are set only after all of\n         * the nodes have been created.\n         */\n        setAnchors: () => {\n            for (const source of aliasObjects) {\n                const ref = sourceObjects.get(source);\n                if (typeof ref === 'object' &&\n                    ref.anchor &&\n                    (isScalar(ref.node) || isCollection(ref.node))) {\n                    ref.node.anchor = ref.anchor;\n                }\n                else {\n                    const error = new Error('Failed to resolve repeated object (this should not happen)');\n                    error.source = source;\n                    throw error;\n                }\n            }\n        },\n        sourceObjects\n    };\n}\n\nexport { anchorIsValid, anchorNames, createNodeAnchors, findNewAnchor };\n","/**\n * Applies the JSON.parse reviver algorithm as defined in the ECMA-262 spec,\n * in section 24.5.1.1 \"Runtime Semantics: InternalizeJSONProperty\" of the\n * 2021 edition: https://tc39.es/ecma262/#sec-json.parse\n *\n * Includes extensions for handling Map and Set objects.\n */\nfunction applyReviver(reviver, obj, key, val) {\n    if (val && typeof val === 'object') {\n        if (Array.isArray(val)) {\n            for (let i = 0, len = val.length; i < len; ++i) {\n                const v0 = val[i];\n                const v1 = applyReviver(reviver, val, String(i), v0);\n                // eslint-disable-next-line @typescript-eslint/no-array-delete\n                if (v1 === undefined)\n                    delete val[i];\n                else if (v1 !== v0)\n                    val[i] = v1;\n            }\n        }\n        else if (val instanceof Map) {\n            for (const k of Array.from(val.keys())) {\n                const v0 = val.get(k);\n                const v1 = applyReviver(reviver, val, k, v0);\n                if (v1 === undefined)\n                    val.delete(k);\n                else if (v1 !== v0)\n                    val.set(k, v1);\n            }\n        }\n        else if (val instanceof Set) {\n            for (const v0 of Array.from(val)) {\n                const v1 = applyReviver(reviver, val, v0, v0);\n                if (v1 === undefined)\n                    val.delete(v0);\n                else if (v1 !== v0) {\n                    val.delete(v0);\n                    val.add(v1);\n                }\n            }\n        }\n        else {\n            for (const [k, v0] of Object.entries(val)) {\n                const v1 = applyReviver(reviver, val, k, v0);\n                if (v1 === undefined)\n                    delete val[k];\n                else if (v1 !== v0)\n                    val[k] = v1;\n            }\n        }\n    }\n    return reviver.call(obj, key, val);\n}\n\nexport { applyReviver };\n","import { hasAnchor } from './identity.js';\n\n/**\n * Recursively convert any node or its contents to native JavaScript\n *\n * @param value - The input value\n * @param arg - If `value` defines a `toJSON()` method, use this\n *   as its first argument\n * @param ctx - Conversion context, originally set in Document#toJS(). If\n *   `{ keep: true }` is not set, output should be suitable for JSON\n *   stringification.\n */\nfunction toJS(value, arg, ctx) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n    if (Array.isArray(value))\n        return value.map((v, i) => toJS(v, String(i), ctx));\n    if (value && typeof value.toJSON === 'function') {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-call\n        if (!ctx || !hasAnchor(value))\n            return value.toJSON(arg, ctx);\n        const data = { aliasCount: 0, count: 1, res: undefined };\n        ctx.anchors.set(value, data);\n        ctx.onCreate = res => {\n            data.res = res;\n            delete ctx.onCreate;\n        };\n        const res = value.toJSON(arg, ctx);\n        if (ctx.onCreate)\n            ctx.onCreate(res);\n        return res;\n    }\n    if (typeof value === 'bigint' && !ctx?.keep)\n        return Number(value);\n    return value;\n}\n\nexport { toJS };\n","import { applyReviver } from '../doc/applyReviver.js';\nimport { NODE_TYPE, isDocument } from './identity.js';\nimport { toJS } from './toJS.js';\n\nclass NodeBase {\n    constructor(type) {\n        Object.defineProperty(this, NODE_TYPE, { value: type });\n    }\n    /** Create a copy of this node.  */\n    clone() {\n        const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));\n        if (this.range)\n            copy.range = this.range.slice();\n        return copy;\n    }\n    /** A plain JavaScript representation of this node. */\n    toJS(doc, { mapAsMap, maxAliasCount, onAnchor, reviver } = {}) {\n        if (!isDocument(doc))\n            throw new TypeError('A document argument is required');\n        const ctx = {\n            anchors: new Map(),\n            doc,\n            keep: true,\n            mapAsMap: mapAsMap === true,\n            mapKeyWarned: false,\n            maxAliasCount: typeof maxAliasCount === 'number' ? maxAliasCount : 100\n        };\n        const res = toJS(this, '', ctx);\n        if (typeof onAnchor === 'function')\n            for (const { count, res } of ctx.anchors.values())\n                onAnchor(res, count);\n        return typeof reviver === 'function'\n            ? applyReviver(reviver, { '': res }, '', res)\n            : res;\n    }\n}\n\nexport { NodeBase };\n","import { anchorIsValid } from '../doc/anchors.js';\nimport { visit } from '../visit.js';\nimport { ALIAS, isAlias, isCollection, isPair, hasAnchor } from './identity.js';\nimport { NodeBase } from './Node.js';\nimport { toJS } from './toJS.js';\n\nclass Alias extends NodeBase {\n    constructor(source) {\n        super(ALIAS);\n        this.source = source;\n        Object.defineProperty(this, 'tag', {\n            set() {\n                throw new Error('Alias nodes cannot have tags');\n            }\n        });\n    }\n    /**\n     * Resolve the value of this alias within `doc`, finding the last\n     * instance of the `source` anchor before this node.\n     */\n    resolve(doc, ctx) {\n        let nodes;\n        if (ctx?.aliasResolveCache) {\n            nodes = ctx.aliasResolveCache;\n        }\n        else {\n            nodes = [];\n            visit(doc, {\n                Node: (_key, node) => {\n                    if (isAlias(node) || hasAnchor(node))\n                        nodes.push(node);\n                }\n            });\n            if (ctx)\n                ctx.aliasResolveCache = nodes;\n        }\n        let found = undefined;\n        for (const node of nodes) {\n            if (node === this)\n                break;\n            if (node.anchor === this.source)\n                found = node;\n        }\n        return found;\n    }\n    toJSON(_arg, ctx) {\n        if (!ctx)\n            return { source: this.source };\n        const { anchors, doc, maxAliasCount } = ctx;\n        const source = this.resolve(doc, ctx);\n        if (!source) {\n            const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;\n            throw new ReferenceError(msg);\n        }\n        let data = anchors.get(source);\n        if (!data) {\n            // Resolve anchors for Node.prototype.toJS()\n            toJS(source, null, ctx);\n            data = anchors.get(source);\n        }\n        /* istanbul ignore if */\n        if (data?.res === undefined) {\n            const msg = 'This should not happen: Alias anchor was not resolved?';\n            throw new ReferenceError(msg);\n        }\n        if (maxAliasCount >= 0) {\n            data.count += 1;\n            if (data.aliasCount === 0)\n                data.aliasCount = getAliasCount(doc, source, anchors);\n            if (data.count * data.aliasCount > maxAliasCount) {\n                const msg = 'Excessive alias count indicates a resource exhaustion attack';\n                throw new ReferenceError(msg);\n            }\n        }\n        return data.res;\n    }\n    toString(ctx, _onComment, _onChompKeep) {\n        const src = `*${this.source}`;\n        if (ctx) {\n            anchorIsValid(this.source);\n            if (ctx.options.verifyAliasOrder && !ctx.anchors.has(this.source)) {\n                const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;\n                throw new Error(msg);\n            }\n            if (ctx.implicitKey)\n                return `${src} `;\n        }\n        return src;\n    }\n}\nfunction getAliasCount(doc, node, anchors) {\n    if (isAlias(node)) {\n        const source = node.resolve(doc);\n        const anchor = anchors && source && anchors.get(source);\n        return anchor ? anchor.count * anchor.aliasCount : 0;\n    }\n    else if (isCollection(node)) {\n        let count = 0;\n        for (const item of node.items) {\n            const c = getAliasCount(doc, item, anchors);\n            if (c > count)\n                count = c;\n        }\n        return count;\n    }\n    else if (isPair(node)) {\n        const kc = getAliasCount(doc, node.key, anchors);\n        const vc = getAliasCount(doc, node.value, anchors);\n        return Math.max(kc, vc);\n    }\n    return 1;\n}\n\nexport { Alias };\n","import { SCALAR } from './identity.js';\nimport { NodeBase } from './Node.js';\nimport { toJS } from './toJS.js';\n\nconst isScalarValue = (value) => !value || (typeof value !== 'function' && typeof value !== 'object');\nclass Scalar extends NodeBase {\n    constructor(value) {\n        super(SCALAR);\n        this.value = value;\n    }\n    toJSON(arg, ctx) {\n        return ctx?.keep ? this.value : toJS(this.value, arg, ctx);\n    }\n    toString() {\n        return String(this.value);\n    }\n}\nScalar.BLOCK_FOLDED = 'BLOCK_FOLDED';\nScalar.BLOCK_LITERAL = 'BLOCK_LITERAL';\nScalar.PLAIN = 'PLAIN';\nScalar.QUOTE_DOUBLE = 'QUOTE_DOUBLE';\nScalar.QUOTE_SINGLE = 'QUOTE_SINGLE';\n\nexport { Scalar, isScalarValue };\n","import { Alias } from '../nodes/Alias.js';\nimport { isNode, isPair, MAP, SEQ, isDocument } from '../nodes/identity.js';\nimport { Scalar } from '../nodes/Scalar.js';\n\nconst defaultTagPrefix = 'tag:yaml.org,2002:';\nfunction findTagObject(value, tagName, tags) {\n    if (tagName) {\n        const match = tags.filter(t => t.tag === tagName);\n        const tagObj = match.find(t => !t.format) ?? match[0];\n        if (!tagObj)\n            throw new Error(`Tag ${tagName} not found`);\n        return tagObj;\n    }\n    return tags.find(t => t.identify?.(value) && !t.format);\n}\nfunction createNode(value, tagName, ctx) {\n    if (isDocument(value))\n        value = value.contents;\n    if (isNode(value))\n        return value;\n    if (isPair(value)) {\n        const map = ctx.schema[MAP].createNode?.(ctx.schema, null, ctx);\n        map.items.push(value);\n        return map;\n    }\n    if (value instanceof String ||\n        value instanceof Number ||\n        value instanceof Boolean ||\n        (typeof BigInt !== 'undefined' && value instanceof BigInt) // not supported everywhere\n    ) {\n        // https://tc39.es/ecma262/#sec-serializejsonproperty\n        value = value.valueOf();\n    }\n    const { aliasDuplicateObjects, onAnchor, onTagObj, schema, sourceObjects } = ctx;\n    // Detect duplicate references to the same object & use Alias nodes for all\n    // after first. The `ref` wrapper allows for circular references to resolve.\n    let ref = undefined;\n    if (aliasDuplicateObjects && value && typeof value === 'object') {\n        ref = sourceObjects.get(value);\n        if (ref) {\n            ref.anchor ?? (ref.anchor = onAnchor(value));\n            return new Alias(ref.anchor);\n        }\n        else {\n            ref = { anchor: null, node: null };\n            sourceObjects.set(value, ref);\n        }\n    }\n    if (tagName?.startsWith('!!'))\n        tagName = defaultTagPrefix + tagName.slice(2);\n    let tagObj = findTagObject(value, tagName, schema.tags);\n    if (!tagObj) {\n        if (value && typeof value.toJSON === 'function') {\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-call\n            value = value.toJSON();\n        }\n        if (!value || typeof value !== 'object') {\n            const node = new Scalar(value);\n            if (ref)\n                ref.node = node;\n            return node;\n        }\n        tagObj =\n            value instanceof Map\n                ? schema[MAP]\n                : Symbol.iterator in Object(value)\n                    ? schema[SEQ]\n                    : schema[MAP];\n    }\n    if (onTagObj) {\n        onTagObj(tagObj);\n        delete ctx.onTagObj;\n    }\n    const node = tagObj?.createNode\n        ? tagObj.createNode(ctx.schema, value, ctx)\n        : typeof tagObj?.nodeClass?.from === 'function'\n            ? tagObj.nodeClass.from(ctx.schema, value, ctx)\n            : new Scalar(value);\n    if (tagName)\n        node.tag = tagName;\n    else if (!tagObj.default)\n        node.tag = tagObj.tag;\n    if (ref)\n        ref.node = node;\n    return node;\n}\n\nexport { createNode };\n","import { createNode } from '../doc/createNode.js';\nimport { isNode, isPair, isCollection, isScalar } from './identity.js';\nimport { NodeBase } from './Node.js';\n\nfunction collectionFromPath(schema, path, value) {\n    let v = value;\n    for (let i = path.length - 1; i >= 0; --i) {\n        const k = path[i];\n        if (typeof k === 'number' && Number.isInteger(k) && k >= 0) {\n            const a = [];\n            a[k] = v;\n            v = a;\n        }\n        else {\n            v = new Map([[k, v]]);\n        }\n    }\n    return createNode(v, undefined, {\n        aliasDuplicateObjects: false,\n        keepUndefined: false,\n        onAnchor: () => {\n            throw new Error('This should not happen, please report a bug.');\n        },\n        schema,\n        sourceObjects: new Map()\n    });\n}\n// Type guard is intentionally a little wrong so as to be more useful,\n// as it does not cover untypable empty non-string iterables (e.g. []).\nconst isEmptyPath = (path) => path == null ||\n    (typeof path === 'object' && !!path[Symbol.iterator]().next().done);\nclass Collection extends NodeBase {\n    constructor(type, schema) {\n        super(type);\n        Object.defineProperty(this, 'schema', {\n            value: schema,\n            configurable: true,\n            enumerable: false,\n            writable: true\n        });\n    }\n    /**\n     * Create a copy of this collection.\n     *\n     * @param schema - If defined, overwrites the original's schema\n     */\n    clone(schema) {\n        const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));\n        if (schema)\n            copy.schema = schema;\n        copy.items = copy.items.map(it => isNode(it) || isPair(it) ? it.clone(schema) : it);\n        if (this.range)\n            copy.range = this.range.slice();\n        return copy;\n    }\n    /**\n     * Adds a value to the collection. For `!!map` and `!!omap` the value must\n     * be a Pair instance or a `{ key, value }` object, which may not have a key\n     * that already exists in the map.\n     */\n    addIn(path, value) {\n        if (isEmptyPath(path))\n            this.add(value);\n        else {\n            const [key, ...rest] = path;\n            const node = this.get(key, true);\n            if (isCollection(node))\n                node.addIn(rest, value);\n            else if (node === undefined && this.schema)\n                this.set(key, collectionFromPath(this.schema, rest, value));\n            else\n                throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);\n        }\n    }\n    /**\n     * Removes a value from the collection.\n     * @returns `true` if the item was found and removed.\n     */\n    deleteIn(path) {\n        const [key, ...rest] = path;\n        if (rest.length === 0)\n            return this.delete(key);\n        const node = this.get(key, true);\n        if (isCollection(node))\n            return node.deleteIn(rest);\n        else\n            throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);\n    }\n    /**\n     * Returns item at `key`, or `undefined` if not found. By default unwraps\n     * scalar values from their surrounding node; to disable set `keepScalar` to\n     * `true` (collections are always returned intact).\n     */\n    getIn(path, keepScalar) {\n        const [key, ...rest] = path;\n        const node = this.get(key, true);\n        if (rest.length === 0)\n            return !keepScalar && isScalar(node) ? node.value : node;\n        else\n            return isCollection(node) ? node.getIn(rest, keepScalar) : undefined;\n    }\n    hasAllNullValues(allowScalar) {\n        return this.items.every(node => {\n            if (!isPair(node))\n                return false;\n            const n = node.value;\n            return (n == null ||\n                (allowScalar &&\n                    isScalar(n) &&\n                    n.value == null &&\n                    !n.commentBefore &&\n                    !n.comment &&\n                    !n.tag));\n        });\n    }\n    /**\n     * Checks if the collection includes a value with the key `key`.\n     */\n    hasIn(path) {\n        const [key, ...rest] = path;\n        if (rest.length === 0)\n            return this.has(key);\n        const node = this.get(key, true);\n        return isCollection(node) ? node.hasIn(rest) : false;\n    }\n    /**\n     * Sets a value in this collection. For `!!set`, `value` needs to be a\n     * boolean to add/remove the item from the set.\n     */\n    setIn(path, value) {\n        const [key, ...rest] = path;\n        if (rest.length === 0) {\n            this.set(key, value);\n        }\n        else {\n            const node = this.get(key, true);\n            if (isCollection(node))\n                node.setIn(rest, value);\n            else if (node === undefined && this.schema)\n                this.set(key, collectionFromPath(this.schema, rest, value));\n            else\n                throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);\n        }\n    }\n}\n\nexport { Collection, collectionFromPath, isEmptyPath };\n","/**\n * Stringifies a comment.\n *\n * Empty comment lines are left empty,\n * lines consisting of a single space are replaced by `#`,\n * and all other lines are prefixed with a `#`.\n */\nconst stringifyComment = (str) => str.replace(/^(?!$)(?: $)?/gm, '#');\nfunction indentComment(comment, indent) {\n    if (/^\\n+$/.test(comment))\n        return comment.substring(1);\n    return indent ? comment.replace(/^(?! *$)/gm, indent) : comment;\n}\nconst lineComment = (str, indent, comment) => str.endsWith('\\n')\n    ? indentComment(comment, indent)\n    : comment.includes('\\n')\n        ? '\\n' + indentComment(comment, indent)\n        : (str.endsWith(' ') ? '' : ' ') + comment;\n\nexport { indentComment, lineComment, stringifyComment };\n","const FOLD_FLOW = 'flow';\nconst FOLD_BLOCK = 'block';\nconst FOLD_QUOTED = 'quoted';\n/**\n * Tries to keep input at up to `lineWidth` characters, splitting only on spaces\n * not followed by newlines or spaces unless `mode` is `'quoted'`. Lines are\n * terminated with `\\n` and started with `indent`.\n */\nfunction foldFlowLines(text, indent, mode = 'flow', { indentAtStart, lineWidth = 80, minContentWidth = 20, onFold, onOverflow } = {}) {\n    if (!lineWidth || lineWidth < 0)\n        return text;\n    if (lineWidth < minContentWidth)\n        minContentWidth = 0;\n    const endStep = Math.max(1 + minContentWidth, 1 + lineWidth - indent.length);\n    if (text.length <= endStep)\n        return text;\n    const folds = [];\n    const escapedFolds = {};\n    let end = lineWidth - indent.length;\n    if (typeof indentAtStart === 'number') {\n        if (indentAtStart > lineWidth - Math.max(2, minContentWidth))\n            folds.push(0);\n        else\n            end = lineWidth - indentAtStart;\n    }\n    let split = undefined;\n    let prev = undefined;\n    let overflow = false;\n    let i = -1;\n    let escStart = -1;\n    let escEnd = -1;\n    if (mode === FOLD_BLOCK) {\n        i = consumeMoreIndentedLines(text, i, indent.length);\n        if (i !== -1)\n            end = i + endStep;\n    }\n    for (let ch; (ch = text[(i += 1)]);) {\n        if (mode === FOLD_QUOTED && ch === '\\\\') {\n            escStart = i;\n            switch (text[i + 1]) {\n                case 'x':\n                    i += 3;\n                    break;\n                case 'u':\n                    i += 5;\n                    break;\n                case 'U':\n                    i += 9;\n                    break;\n                default:\n                    i += 1;\n            }\n            escEnd = i;\n        }\n        if (ch === '\\n') {\n            if (mode === FOLD_BLOCK)\n                i = consumeMoreIndentedLines(text, i, indent.length);\n            end = i + indent.length + endStep;\n            split = undefined;\n        }\n        else {\n            if (ch === ' ' &&\n                prev &&\n                prev !== ' ' &&\n                prev !== '\\n' &&\n                prev !== '\\t') {\n                // space surrounded by non-space can be replaced with newline + indent\n                const next = text[i + 1];\n                if (next && next !== ' ' && next !== '\\n' && next !== '\\t')\n                    split = i;\n            }\n            if (i >= end) {\n                if (split) {\n                    folds.push(split);\n                    end = split + endStep;\n                    split = undefined;\n                }\n                else if (mode === FOLD_QUOTED) {\n                    // white-space collected at end may stretch past lineWidth\n                    while (prev === ' ' || prev === '\\t') {\n                        prev = ch;\n                        ch = text[(i += 1)];\n                        overflow = true;\n                    }\n                    // Account for newline escape, but don't break preceding escape\n                    const j = i > escEnd + 1 ? i - 2 : escStart - 1;\n                    // Bail out if lineWidth & minContentWidth are shorter than an escape string\n                    if (escapedFolds[j])\n                        return text;\n                    folds.push(j);\n                    escapedFolds[j] = true;\n                    end = j + endStep;\n                    split = undefined;\n                }\n                else {\n                    overflow = true;\n                }\n            }\n        }\n        prev = ch;\n    }\n    if (overflow && onOverflow)\n        onOverflow();\n    if (folds.length === 0)\n        return text;\n    if (onFold)\n        onFold();\n    let res = text.slice(0, folds[0]);\n    for (let i = 0; i < folds.length; ++i) {\n        const fold = folds[i];\n        const end = folds[i + 1] || text.length;\n        if (fold === 0)\n            res = `\\n${indent}${text.slice(0, end)}`;\n        else {\n            if (mode === FOLD_QUOTED && escapedFolds[fold])\n                res += `${text[fold]}\\\\`;\n            res += `\\n${indent}${text.slice(fold + 1, end)}`;\n        }\n    }\n    return res;\n}\n/**\n * Presumes `i + 1` is at the start of a line\n * @returns index of last newline in more-indented block\n */\nfunction consumeMoreIndentedLines(text, i, indent) {\n    let end = i;\n    let start = i + 1;\n    let ch = text[start];\n    while (ch === ' ' || ch === '\\t') {\n        if (i < start + indent) {\n            ch = text[++i];\n        }\n        else {\n            do {\n                ch = text[++i];\n            } while (ch && ch !== '\\n');\n            end = i;\n            start = i + 1;\n            ch = text[start];\n        }\n    }\n    return end;\n}\n\nexport { FOLD_BLOCK, FOLD_FLOW, FOLD_QUOTED, foldFlowLines };\n","import { Scalar } from '../nodes/Scalar.js';\nimport { foldFlowLines, FOLD_FLOW, FOLD_QUOTED, FOLD_BLOCK } from './foldFlowLines.js';\n\nconst getFoldOptions = (ctx, isBlock) => ({\n    indentAtStart: isBlock ? ctx.indent.length : ctx.indentAtStart,\n    lineWidth: ctx.options.lineWidth,\n    minContentWidth: ctx.options.minContentWidth\n});\n// Also checks for lines starting with %, as parsing the output as YAML 1.1 will\n// presume that's starting a new document.\nconst containsDocumentMarker = (str) => /^(%|---|\\.\\.\\.)/m.test(str);\nfunction lineLengthOverLimit(str, lineWidth, indentLength) {\n    if (!lineWidth || lineWidth < 0)\n        return false;\n    const limit = lineWidth - indentLength;\n    const strLen = str.length;\n    if (strLen <= limit)\n        return false;\n    for (let i = 0, start = 0; i < strLen; ++i) {\n        if (str[i] === '\\n') {\n            if (i - start > limit)\n                return true;\n            start = i + 1;\n            if (strLen - start <= limit)\n                return false;\n        }\n    }\n    return true;\n}\nfunction doubleQuotedString(value, ctx) {\n    const json = JSON.stringify(value);\n    if (ctx.options.doubleQuotedAsJSON)\n        return json;\n    const { implicitKey } = ctx;\n    const minMultiLineLength = ctx.options.doubleQuotedMinMultiLineLength;\n    const indent = ctx.indent || (containsDocumentMarker(value) ? '  ' : '');\n    let str = '';\n    let start = 0;\n    for (let i = 0, ch = json[i]; ch; ch = json[++i]) {\n        if (ch === ' ' && json[i + 1] === '\\\\' && json[i + 2] === 'n') {\n            // space before newline needs to be escaped to not be folded\n            str += json.slice(start, i) + '\\\\ ';\n            i += 1;\n            start = i;\n            ch = '\\\\';\n        }\n        if (ch === '\\\\')\n            switch (json[i + 1]) {\n                case 'u':\n                    {\n                        str += json.slice(start, i);\n                        const code = json.substr(i + 2, 4);\n                        switch (code) {\n                            case '0000':\n                                str += '\\\\0';\n                                break;\n                            case '0007':\n                                str += '\\\\a';\n                                break;\n                            case '000b':\n                                str += '\\\\v';\n                                break;\n                            case '001b':\n                                str += '\\\\e';\n                                break;\n                            case '0085':\n                                str += '\\\\N';\n                                break;\n                            case '00a0':\n                                str += '\\\\_';\n                                break;\n                            case '2028':\n                                str += '\\\\L';\n                                break;\n                            case '2029':\n                                str += '\\\\P';\n                                break;\n                            default:\n                                if (code.substr(0, 2) === '00')\n                                    str += '\\\\x' + code.substr(2);\n                                else\n                                    str += json.substr(i, 6);\n                        }\n                        i += 5;\n                        start = i + 1;\n                    }\n                    break;\n                case 'n':\n                    if (implicitKey ||\n                        json[i + 2] === '\"' ||\n                        json.length < minMultiLineLength) {\n                        i += 1;\n                    }\n                    else {\n                        // folding will eat first newline\n                        str += json.slice(start, i) + '\\n\\n';\n                        while (json[i + 2] === '\\\\' &&\n                            json[i + 3] === 'n' &&\n                            json[i + 4] !== '\"') {\n                            str += '\\n';\n                            i += 2;\n                        }\n                        str += indent;\n                        // space after newline needs to be escaped to not be folded\n                        if (json[i + 2] === ' ')\n                            str += '\\\\';\n                        i += 1;\n                        start = i + 1;\n                    }\n                    break;\n                default:\n                    i += 1;\n            }\n    }\n    str = start ? str + json.slice(start) : json;\n    return implicitKey\n        ? str\n        : foldFlowLines(str, indent, FOLD_QUOTED, getFoldOptions(ctx, false));\n}\nfunction singleQuotedString(value, ctx) {\n    if (ctx.options.singleQuote === false ||\n        (ctx.implicitKey && value.includes('\\n')) ||\n        /[ \\t]\\n|\\n[ \\t]/.test(value) // single quoted string can't have leading or trailing whitespace around newline\n    )\n        return doubleQuotedString(value, ctx);\n    const indent = ctx.indent || (containsDocumentMarker(value) ? '  ' : '');\n    const res = \"'\" + value.replace(/'/g, \"''\").replace(/\\n+/g, `$&\\n${indent}`) + \"'\";\n    return ctx.implicitKey\n        ? res\n        : foldFlowLines(res, indent, FOLD_FLOW, getFoldOptions(ctx, false));\n}\nfunction quotedString(value, ctx) {\n    const { singleQuote } = ctx.options;\n    let qs;\n    if (singleQuote === false)\n        qs = doubleQuotedString;\n    else {\n        const hasDouble = value.includes('\"');\n        const hasSingle = value.includes(\"'\");\n        if (hasDouble && !hasSingle)\n            qs = singleQuotedString;\n        else if (hasSingle && !hasDouble)\n            qs = doubleQuotedString;\n        else\n            qs = singleQuote ? singleQuotedString : doubleQuotedString;\n    }\n    return qs(value, ctx);\n}\n// The negative lookbehind avoids a polynomial search,\n// but isn't supported yet on Safari: https://caniuse.com/js-regexp-lookbehind\nlet blockEndNewlines;\ntry {\n    blockEndNewlines = new RegExp('(^|(?<!\\n))\\n+(?!\\n|$)', 'g');\n}\ncatch {\n    blockEndNewlines = /\\n+(?!\\n|$)/g;\n}\nfunction blockString({ comment, type, value }, ctx, onComment, onChompKeep) {\n    const { blockQuote, commentString, lineWidth } = ctx.options;\n    // 1. Block can't end in whitespace unless the last line is non-empty.\n    // 2. Strings consisting of only whitespace are best rendered explicitly.\n    if (!blockQuote || /\\n[\\t ]+$/.test(value)) {\n        return quotedString(value, ctx);\n    }\n    const indent = ctx.indent ||\n        (ctx.forceBlockIndent || containsDocumentMarker(value) ? '  ' : '');\n    const literal = blockQuote === 'literal'\n        ? true\n        : blockQuote === 'folded' || type === Scalar.BLOCK_FOLDED\n            ? false\n            : type === Scalar.BLOCK_LITERAL\n                ? true\n                : !lineLengthOverLimit(value, lineWidth, indent.length);\n    if (!value)\n        return literal ? '|\\n' : '>\\n';\n    // determine chomping from whitespace at value end\n    let chomp;\n    let endStart;\n    for (endStart = value.length; endStart > 0; --endStart) {\n        const ch = value[endStart - 1];\n        if (ch !== '\\n' && ch !== '\\t' && ch !== ' ')\n            break;\n    }\n    let end = value.substring(endStart);\n    const endNlPos = end.indexOf('\\n');\n    if (endNlPos === -1) {\n        chomp = '-'; // strip\n    }\n    else if (value === end || endNlPos !== end.length - 1) {\n        chomp = '+'; // keep\n        if (onChompKeep)\n            onChompKeep();\n    }\n    else {\n        chomp = ''; // clip\n    }\n    if (end) {\n        value = value.slice(0, -end.length);\n        if (end[end.length - 1] === '\\n')\n            end = end.slice(0, -1);\n        end = end.replace(blockEndNewlines, `$&${indent}`);\n    }\n    // determine indent indicator from whitespace at value start\n    let startWithSpace = false;\n    let startEnd;\n    let startNlPos = -1;\n    for (startEnd = 0; startEnd < value.length; ++startEnd) {\n        const ch = value[startEnd];\n        if (ch === ' ')\n            startWithSpace = true;\n        else if (ch === '\\n')\n            startNlPos = startEnd;\n        else\n            break;\n    }\n    let start = value.substring(0, startNlPos < startEnd ? startNlPos + 1 : startEnd);\n    if (start) {\n        value = value.substring(start.length);\n        start = start.replace(/\\n+/g, `$&${indent}`);\n    }\n    const indentSize = indent ? '2' : '1'; // root is at -1\n    // Leading | or > is added later\n    let header = (startWithSpace ? indentSize : '') + chomp;\n    if (comment) {\n        header += ' ' + commentString(comment.replace(/ ?[\\r\\n]+/g, ' '));\n        if (onComment)\n            onComment();\n    }\n    if (!literal) {\n        const foldedValue = value\n            .replace(/\\n+/g, '\\n$&')\n            .replace(/(?:^|\\n)([\\t ].*)(?:([\\n\\t ]*)\\n(?![\\n\\t ]))?/g, '$1$2') // more-indented lines aren't folded\n            //                ^ more-ind. ^ empty     ^ capture next empty lines only at end of indent\n            .replace(/\\n+/g, `$&${indent}`);\n        let literalFallback = false;\n        const foldOptions = getFoldOptions(ctx, true);\n        if (blockQuote !== 'folded' && type !== Scalar.BLOCK_FOLDED) {\n            foldOptions.onOverflow = () => {\n                literalFallback = true;\n            };\n        }\n        const body = foldFlowLines(`${start}${foldedValue}${end}`, indent, FOLD_BLOCK, foldOptions);\n        if (!literalFallback)\n            return `>${header}\\n${indent}${body}`;\n    }\n    value = value.replace(/\\n+/g, `$&${indent}`);\n    return `|${header}\\n${indent}${start}${value}${end}`;\n}\nfunction plainString(item, ctx, onComment, onChompKeep) {\n    const { type, value } = item;\n    const { actualString, implicitKey, indent, indentStep, inFlow } = ctx;\n    if ((implicitKey && value.includes('\\n')) ||\n        (inFlow && /[[\\]{},]/.test(value))) {\n        return quotedString(value, ctx);\n    }\n    if (/^[\\n\\t ,[\\]{}#&*!|>'\"%@`]|^[?-]$|^[?-][ \\t]|[\\n:][ \\t]|[ \\t]\\n|[\\n\\t ]#|[\\n\\t :]$/.test(value)) {\n        // not allowed:\n        // - '-' or '?'\n        // - start with an indicator character (except [?:-]) or /[?-] /\n        // - '\\n ', ': ' or ' \\n' anywhere\n        // - '#' not preceded by a non-space char\n        // - end with ' ' or ':'\n        return implicitKey || inFlow || !value.includes('\\n')\n            ? quotedString(value, ctx)\n            : blockString(item, ctx, onComment, onChompKeep);\n    }\n    if (!implicitKey &&\n        !inFlow &&\n        type !== Scalar.PLAIN &&\n        value.includes('\\n')) {\n        // Where allowed & type not set explicitly, prefer block style for multiline strings\n        return blockString(item, ctx, onComment, onChompKeep);\n    }\n    if (containsDocumentMarker(value)) {\n        if (indent === '') {\n            ctx.forceBlockIndent = true;\n            return blockString(item, ctx, onComment, onChompKeep);\n        }\n        else if (implicitKey && indent === indentStep) {\n            return quotedString(value, ctx);\n        }\n    }\n    const str = value.replace(/\\n+/g, `$&\\n${indent}`);\n    // Verify that output will be parsed as a string, as e.g. plain numbers and\n    // booleans get parsed with those types in v1.2 (e.g. '42', 'true' & '0.9e-3'),\n    // and others in v1.1.\n    if (actualString) {\n        const test = (tag) => tag.default && tag.tag !== 'tag:yaml.org,2002:str' && tag.test?.test(str);\n        const { compat, tags } = ctx.doc.schema;\n        if (tags.some(test) || compat?.some(test))\n            return quotedString(value, ctx);\n    }\n    return implicitKey\n        ? str\n        : foldFlowLines(str, indent, FOLD_FLOW, getFoldOptions(ctx, false));\n}\nfunction stringifyString(item, ctx, onComment, onChompKeep) {\n    const { implicitKey, inFlow } = ctx;\n    const ss = typeof item.value === 'string'\n        ? item\n        : Object.assign({}, item, { value: String(item.value) });\n    let { type } = item;\n    if (type !== Scalar.QUOTE_DOUBLE) {\n        // force double quotes on control characters & unpaired surrogates\n        if (/[\\x00-\\x08\\x0b-\\x1f\\x7f-\\x9f\\u{D800}-\\u{DFFF}]/u.test(ss.value))\n            type = Scalar.QUOTE_DOUBLE;\n    }\n    const _stringify = (_type) => {\n        switch (_type) {\n            case Scalar.BLOCK_FOLDED:\n            case Scalar.BLOCK_LITERAL:\n                return implicitKey || inFlow\n                    ? quotedString(ss.value, ctx) // blocks are not valid inside flow containers\n                    : blockString(ss, ctx, onComment, onChompKeep);\n            case Scalar.QUOTE_DOUBLE:\n                return doubleQuotedString(ss.value, ctx);\n            case Scalar.QUOTE_SINGLE:\n                return singleQuotedString(ss.value, ctx);\n            case Scalar.PLAIN:\n                return plainString(ss, ctx, onComment, onChompKeep);\n            default:\n                return null;\n        }\n    };\n    let res = _stringify(type);\n    if (res === null) {\n        const { defaultKeyType, defaultStringType } = ctx.options;\n        const t = (implicitKey && defaultKeyType) || defaultStringType;\n        res = _stringify(t);\n        if (res === null)\n            throw new Error(`Unsupported default string type ${t}`);\n    }\n    return res;\n}\n\nexport { stringifyString };\n","import { anchorIsValid } from '../doc/anchors.js';\nimport { isPair, isAlias, isNode, isScalar, isCollection } from '../nodes/identity.js';\nimport { stringifyComment } from './stringifyComment.js';\nimport { stringifyString } from './stringifyString.js';\n\nfunction createStringifyContext(doc, options) {\n    const opt = Object.assign({\n        blockQuote: true,\n        commentString: stringifyComment,\n        defaultKeyType: null,\n        defaultStringType: 'PLAIN',\n        directives: null,\n        doubleQuotedAsJSON: false,\n        doubleQuotedMinMultiLineLength: 40,\n        falseStr: 'false',\n        flowCollectionPadding: true,\n        indentSeq: true,\n        lineWidth: 80,\n        minContentWidth: 20,\n        nullStr: 'null',\n        simpleKeys: false,\n        singleQuote: null,\n        trueStr: 'true',\n        verifyAliasOrder: true\n    }, doc.schema.toStringOptions, options);\n    let inFlow;\n    switch (opt.collectionStyle) {\n        case 'block':\n            inFlow = false;\n            break;\n        case 'flow':\n            inFlow = true;\n            break;\n        default:\n            inFlow = null;\n    }\n    return {\n        anchors: new Set(),\n        doc,\n        flowCollectionPadding: opt.flowCollectionPadding ? ' ' : '',\n        indent: '',\n        indentStep: typeof opt.indent === 'number' ? ' '.repeat(opt.indent) : '  ',\n        inFlow,\n        options: opt\n    };\n}\nfunction getTagObject(tags, item) {\n    if (item.tag) {\n        const match = tags.filter(t => t.tag === item.tag);\n        if (match.length > 0)\n            return match.find(t => t.format === item.format) ?? match[0];\n    }\n    let tagObj = undefined;\n    let obj;\n    if (isScalar(item)) {\n        obj = item.value;\n        let match = tags.filter(t => t.identify?.(obj));\n        if (match.length > 1) {\n            const testMatch = match.filter(t => t.test);\n            if (testMatch.length > 0)\n                match = testMatch;\n        }\n        tagObj =\n            match.find(t => t.format === item.format) ?? match.find(t => !t.format);\n    }\n    else {\n        obj = item;\n        tagObj = tags.find(t => t.nodeClass && obj instanceof t.nodeClass);\n    }\n    if (!tagObj) {\n        const name = obj?.constructor?.name ?? (obj === null ? 'null' : typeof obj);\n        throw new Error(`Tag not resolved for ${name} value`);\n    }\n    return tagObj;\n}\n// needs to be called before value stringifier to allow for circular anchor refs\nfunction stringifyProps(node, tagObj, { anchors, doc }) {\n    if (!doc.directives)\n        return '';\n    const props = [];\n    const anchor = (isScalar(node) || isCollection(node)) && node.anchor;\n    if (anchor && anchorIsValid(anchor)) {\n        anchors.add(anchor);\n        props.push(`&${anchor}`);\n    }\n    const tag = node.tag ?? (tagObj.default ? null : tagObj.tag);\n    if (tag)\n        props.push(doc.directives.tagString(tag));\n    return props.join(' ');\n}\nfunction stringify(item, ctx, onComment, onChompKeep) {\n    if (isPair(item))\n        return item.toString(ctx, onComment, onChompKeep);\n    if (isAlias(item)) {\n        if (ctx.doc.directives)\n            return item.toString(ctx);\n        if (ctx.resolvedAliases?.has(item)) {\n            throw new TypeError(`Cannot stringify circular structure without alias nodes`);\n        }\n        else {\n            if (ctx.resolvedAliases)\n                ctx.resolvedAliases.add(item);\n            else\n                ctx.resolvedAliases = new Set([item]);\n            item = item.resolve(ctx.doc);\n        }\n    }\n    let tagObj = undefined;\n    const node = isNode(item)\n        ? item\n        : ctx.doc.createNode(item, { onTagObj: o => (tagObj = o) });\n    tagObj ?? (tagObj = getTagObject(ctx.doc.schema.tags, node));\n    const props = stringifyProps(node, tagObj, ctx);\n    if (props.length > 0)\n        ctx.indentAtStart = (ctx.indentAtStart ?? 0) + props.length + 1;\n    const str = typeof tagObj.stringify === 'function'\n        ? tagObj.stringify(node, ctx, onComment, onChompKeep)\n        : isScalar(node)\n            ? stringifyString(node, ctx, onComment, onChompKeep)\n            : node.toString(ctx, onComment, onChompKeep);\n    if (!props)\n        return str;\n    return isScalar(node) || str[0] === '{' || str[0] === '['\n        ? `${props} ${str}`\n        : `${props}\\n${ctx.indent}${str}`;\n}\n\nexport { createStringifyContext, stringify };\n","import { isScalar, isAlias, isSeq, isMap } from '../../nodes/identity.js';\nimport { Scalar } from '../../nodes/Scalar.js';\n\n// If the value associated with a merge key is a single mapping node, each of\n// its key/value pairs is inserted into the current mapping, unless the key\n// already exists in it. If the value associated with the merge key is a\n// sequence, then this sequence is expected to contain mapping nodes and each\n// of these nodes is merged in turn according to its order in the sequence.\n// Keys in mapping nodes earlier in the sequence override keys specified in\n// later mapping nodes. -- http://yaml.org/type/merge.html\nconst MERGE_KEY = '<<';\nconst merge = {\n    identify: value => value === MERGE_KEY ||\n        (typeof value === 'symbol' && value.description === MERGE_KEY),\n    default: 'key',\n    tag: 'tag:yaml.org,2002:merge',\n    test: /^<<$/,\n    resolve: () => Object.assign(new Scalar(Symbol(MERGE_KEY)), {\n        addToJSMap: addMergeToJSMap\n    }),\n    stringify: () => MERGE_KEY\n};\nconst isMergeKey = (ctx, key) => (merge.identify(key) ||\n    (isScalar(key) &&\n        (!key.type || key.type === Scalar.PLAIN) &&\n        merge.identify(key.value))) &&\n    ctx?.doc.schema.tags.some(tag => tag.tag === merge.tag && tag.default);\nfunction addMergeToJSMap(ctx, map, value) {\n    value = ctx && isAlias(value) ? value.resolve(ctx.doc) : value;\n    if (isSeq(value))\n        for (const it of value.items)\n            mergeValue(ctx, map, it);\n    else if (Array.isArray(value))\n        for (const it of value)\n            mergeValue(ctx, map, it);\n    else\n        mergeValue(ctx, map, value);\n}\nfunction mergeValue(ctx, map, value) {\n    const source = ctx && isAlias(value) ? value.resolve(ctx.doc) : value;\n    if (!isMap(source))\n        throw new Error('Merge sources must be maps or map aliases');\n    const srcMap = source.toJSON(null, ctx, Map);\n    for (const [key, value] of srcMap) {\n        if (map instanceof Map) {\n            if (!map.has(key))\n                map.set(key, value);\n        }\n        else if (map instanceof Set) {\n            map.add(key);\n        }\n        else if (!Object.prototype.hasOwnProperty.call(map, key)) {\n            Object.defineProperty(map, key, {\n                value,\n                writable: true,\n                enumerable: true,\n                configurable: true\n            });\n        }\n    }\n    return map;\n}\n\nexport { addMergeToJSMap, isMergeKey, merge };\n","import { warn } from '../log.js';\nimport { isMergeKey, addMergeToJSMap } from '../schema/yaml-1.1/merge.js';\nimport { createStringifyContext } from '../stringify/stringify.js';\nimport { isNode } from './identity.js';\nimport { toJS } from './toJS.js';\n\nfunction addPairToJSMap(ctx, map, { key, value }) {\n    if (isNode(key) && key.addToJSMap)\n        key.addToJSMap(ctx, map, value);\n    // TODO: Should drop this special case for bare << handling\n    else if (isMergeKey(ctx, key))\n        addMergeToJSMap(ctx, map, value);\n    else {\n        const jsKey = toJS(key, '', ctx);\n        if (map instanceof Map) {\n            map.set(jsKey, toJS(value, jsKey, ctx));\n        }\n        else if (map instanceof Set) {\n            map.add(jsKey);\n        }\n        else {\n            const stringKey = stringifyKey(key, jsKey, ctx);\n            const jsValue = toJS(value, stringKey, ctx);\n            if (stringKey in map)\n                Object.defineProperty(map, stringKey, {\n                    value: jsValue,\n                    writable: true,\n                    enumerable: true,\n                    configurable: true\n                });\n            else\n                map[stringKey] = jsValue;\n        }\n    }\n    return map;\n}\nfunction stringifyKey(key, jsKey, ctx) {\n    if (jsKey === null)\n        return '';\n    // eslint-disable-next-line @typescript-eslint/no-base-to-string\n    if (typeof jsKey !== 'object')\n        return String(jsKey);\n    if (isNode(key) && ctx?.doc) {\n        const strCtx = createStringifyContext(ctx.doc, {});\n        strCtx.anchors = new Set();\n        for (const node of ctx.anchors.keys())\n            strCtx.anchors.add(node.anchor);\n        strCtx.inFlow = true;\n        strCtx.inStringifyKey = true;\n        const strKey = key.toString(strCtx);\n        if (!ctx.mapKeyWarned) {\n            let jsonStr = JSON.stringify(strKey);\n            if (jsonStr.length > 40)\n                jsonStr = jsonStr.substring(0, 36) + '...\"';\n            warn(ctx.doc.options.logLevel, `Keys with collection values will be stringified due to JS Object restrictions: ${jsonStr}. Set mapAsMap: true to use object keys.`);\n            ctx.mapKeyWarned = true;\n        }\n        return strKey;\n    }\n    return JSON.stringify(jsKey);\n}\n\nexport { addPairToJSMap };\n","function debug(logLevel, ...messages) {\n    if (logLevel === 'debug')\n        console.log(...messages);\n}\nfunction warn(logLevel, warning) {\n    if (logLevel === 'debug' || logLevel === 'warn') {\n        console.warn(warning);\n    }\n}\n\nexport { debug, warn };\n","import { createNode } from '../doc/createNode.js';\nimport { stringifyPair } from '../stringify/stringifyPair.js';\nimport { addPairToJSMap } from './addPairToJSMap.js';\nimport { NODE_TYPE, PAIR, isNode } from './identity.js';\n\nfunction createPair(key, value, ctx) {\n    const k = createNode(key, undefined, ctx);\n    const v = createNode(value, undefined, ctx);\n    return new Pair(k, v);\n}\nclass Pair {\n    constructor(key, value = null) {\n        Object.defineProperty(this, NODE_TYPE, { value: PAIR });\n        this.key = key;\n        this.value = value;\n    }\n    clone(schema) {\n        let { key, value } = this;\n        if (isNode(key))\n            key = key.clone(schema);\n        if (isNode(value))\n            value = value.clone(schema);\n        return new Pair(key, value);\n    }\n    toJSON(_, ctx) {\n        const pair = ctx?.mapAsMap ? new Map() : {};\n        return addPairToJSMap(ctx, pair, this);\n    }\n    toString(ctx, onComment, onChompKeep) {\n        return ctx?.doc\n            ? stringifyPair(this, ctx, onComment, onChompKeep)\n            : JSON.stringify(this);\n    }\n}\n\nexport { Pair, createPair };\n","import { isCollection, isNode, isScalar, isSeq } from '../nodes/identity.js';\nimport { Scalar } from '../nodes/Scalar.js';\nimport { stringify } from './stringify.js';\nimport { lineComment, indentComment } from './stringifyComment.js';\n\nfunction stringifyPair({ key, value }, ctx, onComment, onChompKeep) {\n    const { allNullValues, doc, indent, indentStep, options: { commentString, indentSeq, simpleKeys } } = ctx;\n    let keyComment = (isNode(key) && key.comment) || null;\n    if (simpleKeys) {\n        if (keyComment) {\n            throw new Error('With simple keys, key nodes cannot have comments');\n        }\n        if (isCollection(key) || (!isNode(key) && typeof key === 'object')) {\n            const msg = 'With simple keys, collection cannot be used as a key value';\n            throw new Error(msg);\n        }\n    }\n    let explicitKey = !simpleKeys &&\n        (!key ||\n            (keyComment && value == null && !ctx.inFlow) ||\n            isCollection(key) ||\n            (isScalar(key)\n                ? key.type === Scalar.BLOCK_FOLDED || key.type === Scalar.BLOCK_LITERAL\n                : typeof key === 'object'));\n    ctx = Object.assign({}, ctx, {\n        allNullValues: false,\n        implicitKey: !explicitKey && (simpleKeys || !allNullValues),\n        indent: indent + indentStep\n    });\n    let keyCommentDone = false;\n    let chompKeep = false;\n    let str = stringify(key, ctx, () => (keyCommentDone = true), () => (chompKeep = true));\n    if (!explicitKey && !ctx.inFlow && str.length > 1024) {\n        if (simpleKeys)\n            throw new Error('With simple keys, single line scalar must not span more than 1024 characters');\n        explicitKey = true;\n    }\n    if (ctx.inFlow) {\n        if (allNullValues || value == null) {\n            if (keyCommentDone && onComment)\n                onComment();\n            return str === '' ? '?' : explicitKey ? `? ${str}` : str;\n        }\n    }\n    else if ((allNullValues && !simpleKeys) || (value == null && explicitKey)) {\n        str = `? ${str}`;\n        if (keyComment && !keyCommentDone) {\n            str += lineComment(str, ctx.indent, commentString(keyComment));\n        }\n        else if (chompKeep && onChompKeep)\n            onChompKeep();\n        return str;\n    }\n    if (keyCommentDone)\n        keyComment = null;\n    if (explicitKey) {\n        if (keyComment)\n            str += lineComment(str, ctx.indent, commentString(keyComment));\n        str = `? ${str}\\n${indent}:`;\n    }\n    else {\n        str = `${str}:`;\n        if (keyComment)\n            str += lineComment(str, ctx.indent, commentString(keyComment));\n    }\n    let vsb, vcb, valueComment;\n    if (isNode(value)) {\n        vsb = !!value.spaceBefore;\n        vcb = value.commentBefore;\n        valueComment = value.comment;\n    }\n    else {\n        vsb = false;\n        vcb = null;\n        valueComment = null;\n        if (value && typeof value === 'object')\n            value = doc.createNode(value);\n    }\n    ctx.implicitKey = false;\n    if (!explicitKey && !keyComment && isScalar(value))\n        ctx.indentAtStart = str.length + 1;\n    chompKeep = false;\n    if (!indentSeq &&\n        indentStep.length >= 2 &&\n        !ctx.inFlow &&\n        !explicitKey &&\n        isSeq(value) &&\n        !value.flow &&\n        !value.tag &&\n        !value.anchor) {\n        // If indentSeq === false, consider '- ' as part of indentation where possible\n        ctx.indent = ctx.indent.substring(2);\n    }\n    let valueCommentDone = false;\n    const valueStr = stringify(value, ctx, () => (valueCommentDone = true), () => (chompKeep = true));\n    let ws = ' ';\n    if (keyComment || vsb || vcb) {\n        ws = vsb ? '\\n' : '';\n        if (vcb) {\n            const cs = commentString(vcb);\n            ws += `\\n${indentComment(cs, ctx.indent)}`;\n        }\n        if (valueStr === '' && !ctx.inFlow) {\n            if (ws === '\\n' && valueComment)\n                ws = '\\n\\n';\n        }\n        else {\n            ws += `\\n${ctx.indent}`;\n        }\n    }\n    else if (!explicitKey && isCollection(value)) {\n        const vs0 = valueStr[0];\n        const nl0 = valueStr.indexOf('\\n');\n        const hasNewline = nl0 !== -1;\n        const flow = ctx.inFlow ?? value.flow ?? value.items.length === 0;\n        if (hasNewline || !flow) {\n            let hasPropsLine = false;\n            if (hasNewline && (vs0 === '&' || vs0 === '!')) {\n                let sp0 = valueStr.indexOf(' ');\n                if (vs0 === '&' &&\n                    sp0 !== -1 &&\n                    sp0 < nl0 &&\n                    valueStr[sp0 + 1] === '!') {\n                    sp0 = valueStr.indexOf(' ', sp0 + 1);\n                }\n                if (sp0 === -1 || nl0 < sp0)\n                    hasPropsLine = true;\n            }\n            if (!hasPropsLine)\n                ws = `\\n${ctx.indent}`;\n        }\n    }\n    else if (valueStr === '' || valueStr[0] === '\\n') {\n        ws = '';\n    }\n    str += ws + valueStr;\n    if (ctx.inFlow) {\n        if (valueCommentDone && onComment)\n            onComment();\n    }\n    else if (valueComment && !valueCommentDone) {\n        str += lineComment(str, ctx.indent, commentString(valueComment));\n    }\n    else if (chompKeep && onChompKeep) {\n        onChompKeep();\n    }\n    return str;\n}\n\nexport { stringifyPair };\n","import { isNode, isPair } from '../nodes/identity.js';\nimport { stringify } from './stringify.js';\nimport { lineComment, indentComment } from './stringifyComment.js';\n\nfunction stringifyCollection(collection, ctx, options) {\n    const flow = ctx.inFlow ?? collection.flow;\n    const stringify = flow ? stringifyFlowCollection : stringifyBlockCollection;\n    return stringify(collection, ctx, options);\n}\nfunction stringifyBlockCollection({ comment, items }, ctx, { blockItemPrefix, flowChars, itemIndent, onChompKeep, onComment }) {\n    const { indent, options: { commentString } } = ctx;\n    const itemCtx = Object.assign({}, ctx, { indent: itemIndent, type: null });\n    let chompKeep = false; // flag for the preceding node's status\n    const lines = [];\n    for (let i = 0; i < items.length; ++i) {\n        const item = items[i];\n        let comment = null;\n        if (isNode(item)) {\n            if (!chompKeep && item.spaceBefore)\n                lines.push('');\n            addCommentBefore(ctx, lines, item.commentBefore, chompKeep);\n            if (item.comment)\n                comment = item.comment;\n        }\n        else if (isPair(item)) {\n            const ik = isNode(item.key) ? item.key : null;\n            if (ik) {\n                if (!chompKeep && ik.spaceBefore)\n                    lines.push('');\n                addCommentBefore(ctx, lines, ik.commentBefore, chompKeep);\n            }\n        }\n        chompKeep = false;\n        let str = stringify(item, itemCtx, () => (comment = null), () => (chompKeep = true));\n        if (comment)\n            str += lineComment(str, itemIndent, commentString(comment));\n        if (chompKeep && comment)\n            chompKeep = false;\n        lines.push(blockItemPrefix + str);\n    }\n    let str;\n    if (lines.length === 0) {\n        str = flowChars.start + flowChars.end;\n    }\n    else {\n        str = lines[0];\n        for (let i = 1; i < lines.length; ++i) {\n            const line = lines[i];\n            str += line ? `\\n${indent}${line}` : '\\n';\n        }\n    }\n    if (comment) {\n        str += '\\n' + indentComment(commentString(comment), indent);\n        if (onComment)\n            onComment();\n    }\n    else if (chompKeep && onChompKeep)\n        onChompKeep();\n    return str;\n}\nfunction stringifyFlowCollection({ items }, ctx, { flowChars, itemIndent }) {\n    const { indent, indentStep, flowCollectionPadding: fcPadding, options: { commentString } } = ctx;\n    itemIndent += indentStep;\n    const itemCtx = Object.assign({}, ctx, {\n        indent: itemIndent,\n        inFlow: true,\n        type: null\n    });\n    let reqNewline = false;\n    let linesAtValue = 0;\n    const lines = [];\n    for (let i = 0; i < items.length; ++i) {\n        const item = items[i];\n        let comment = null;\n        if (isNode(item)) {\n            if (item.spaceBefore)\n                lines.push('');\n            addCommentBefore(ctx, lines, item.commentBefore, false);\n            if (item.comment)\n                comment = item.comment;\n        }\n        else if (isPair(item)) {\n            const ik = isNode(item.key) ? item.key : null;\n            if (ik) {\n                if (ik.spaceBefore)\n                    lines.push('');\n                addCommentBefore(ctx, lines, ik.commentBefore, false);\n                if (ik.comment)\n                    reqNewline = true;\n            }\n            const iv = isNode(item.value) ? item.value : null;\n            if (iv) {\n                if (iv.comment)\n                    comment = iv.comment;\n                if (iv.commentBefore)\n                    reqNewline = true;\n            }\n            else if (item.value == null && ik?.comment) {\n                comment = ik.comment;\n            }\n        }\n        if (comment)\n            reqNewline = true;\n        let str = stringify(item, itemCtx, () => (comment = null));\n        if (i < items.length - 1)\n            str += ',';\n        if (comment)\n            str += lineComment(str, itemIndent, commentString(comment));\n        if (!reqNewline && (lines.length > linesAtValue || str.includes('\\n')))\n            reqNewline = true;\n        lines.push(str);\n        linesAtValue = lines.length;\n    }\n    const { start, end } = flowChars;\n    if (lines.length === 0) {\n        return start + end;\n    }\n    else {\n        if (!reqNewline) {\n            const len = lines.reduce((sum, line) => sum + line.length + 2, 2);\n            reqNewline = ctx.options.lineWidth > 0 && len > ctx.options.lineWidth;\n        }\n        if (reqNewline) {\n            let str = start;\n            for (const line of lines)\n                str += line ? `\\n${indentStep}${indent}${line}` : '\\n';\n            return `${str}\\n${indent}${end}`;\n        }\n        else {\n            return `${start}${fcPadding}${lines.join(' ')}${fcPadding}${end}`;\n        }\n    }\n}\nfunction addCommentBefore({ indent, options: { commentString } }, lines, comment, chompKeep) {\n    if (comment && chompKeep)\n        comment = comment.replace(/^\\n+/, '');\n    if (comment) {\n        const ic = indentComment(commentString(comment), indent);\n        lines.push(ic.trimStart()); // Avoid double indent on first line\n    }\n}\n\nexport { stringifyCollection };\n","import { stringifyCollection } from '../stringify/stringifyCollection.js';\nimport { addPairToJSMap } from './addPairToJSMap.js';\nimport { Collection } from './Collection.js';\nimport { MAP, isPair, isScalar } from './identity.js';\nimport { Pair, createPair } from './Pair.js';\nimport { isScalarValue } from './Scalar.js';\n\nfunction findPair(items, key) {\n    const k = isScalar(key) ? key.value : key;\n    for (const it of items) {\n        if (isPair(it)) {\n            if (it.key === key || it.key === k)\n                return it;\n            if (isScalar(it.key) && it.key.value === k)\n                return it;\n        }\n    }\n    return undefined;\n}\nclass YAMLMap extends Collection {\n    static get tagName() {\n        return 'tag:yaml.org,2002:map';\n    }\n    constructor(schema) {\n        super(MAP, schema);\n        this.items = [];\n    }\n    /**\n     * A generic collection parsing method that can be extended\n     * to other node classes that inherit from YAMLMap\n     */\n    static from(schema, obj, ctx) {\n        const { keepUndefined, replacer } = ctx;\n        const map = new this(schema);\n        const add = (key, value) => {\n            if (typeof replacer === 'function')\n                value = replacer.call(obj, key, value);\n            else if (Array.isArray(replacer) && !replacer.includes(key))\n                return;\n            if (value !== undefined || keepUndefined)\n                map.items.push(createPair(key, value, ctx));\n        };\n        if (obj instanceof Map) {\n            for (const [key, value] of obj)\n                add(key, value);\n        }\n        else if (obj && typeof obj === 'object') {\n            for (const key of Object.keys(obj))\n                add(key, obj[key]);\n        }\n        if (typeof schema.sortMapEntries === 'function') {\n            map.items.sort(schema.sortMapEntries);\n        }\n        return map;\n    }\n    /**\n     * Adds a value to the collection.\n     *\n     * @param overwrite - If not set `true`, using a key that is already in the\n     *   collection will throw. Otherwise, overwrites the previous value.\n     */\n    add(pair, overwrite) {\n        let _pair;\n        if (isPair(pair))\n            _pair = pair;\n        else if (!pair || typeof pair !== 'object' || !('key' in pair)) {\n            // In TypeScript, this never happens.\n            _pair = new Pair(pair, pair?.value);\n        }\n        else\n            _pair = new Pair(pair.key, pair.value);\n        const prev = findPair(this.items, _pair.key);\n        const sortEntries = this.schema?.sortMapEntries;\n        if (prev) {\n            if (!overwrite)\n                throw new Error(`Key ${_pair.key} already set`);\n            // For scalars, keep the old node & its comments and anchors\n            if (isScalar(prev.value) && isScalarValue(_pair.value))\n                prev.value.value = _pair.value;\n            else\n                prev.value = _pair.value;\n        }\n        else if (sortEntries) {\n            const i = this.items.findIndex(item => sortEntries(_pair, item) < 0);\n            if (i === -1)\n                this.items.push(_pair);\n            else\n                this.items.splice(i, 0, _pair);\n        }\n        else {\n            this.items.push(_pair);\n        }\n    }\n    delete(key) {\n        const it = findPair(this.items, key);\n        if (!it)\n            return false;\n        const del = this.items.splice(this.items.indexOf(it), 1);\n        return del.length > 0;\n    }\n    get(key, keepScalar) {\n        const it = findPair(this.items, key);\n        const node = it?.value;\n        return (!keepScalar && isScalar(node) ? node.value : node) ?? undefined;\n    }\n    has(key) {\n        return !!findPair(this.items, key);\n    }\n    set(key, value) {\n        this.add(new Pair(key, value), true);\n    }\n    /**\n     * @param ctx - Conversion context, originally set in Document#toJS()\n     * @param {Class} Type - If set, forces the returned collection type\n     * @returns Instance of Type, Map, or Object\n     */\n    toJSON(_, ctx, Type) {\n        const map = Type ? new Type() : ctx?.mapAsMap ? new Map() : {};\n        if (ctx?.onCreate)\n            ctx.onCreate(map);\n        for (const item of this.items)\n            addPairToJSMap(ctx, map, item);\n        return map;\n    }\n    toString(ctx, onComment, onChompKeep) {\n        if (!ctx)\n            return JSON.stringify(this);\n        for (const item of this.items) {\n            if (!isPair(item))\n                throw new Error(`Map items must all be pairs; found ${JSON.stringify(item)} instead`);\n        }\n        if (!ctx.allNullValues && this.hasAllNullValues(false))\n            ctx = Object.assign({}, ctx, { allNullValues: true });\n        return stringifyCollection(this, ctx, {\n            blockItemPrefix: '',\n            flowChars: { start: '{', end: '}' },\n            itemIndent: ctx.indent || '',\n            onChompKeep,\n            onComment\n        });\n    }\n}\n\nexport { YAMLMap, findPair };\n","import { isMap } from '../../nodes/identity.js';\nimport { YAMLMap } from '../../nodes/YAMLMap.js';\n\nconst map = {\n    collection: 'map',\n    default: true,\n    nodeClass: YAMLMap,\n    tag: 'tag:yaml.org,2002:map',\n    resolve(map, onError) {\n        if (!isMap(map))\n            onError('Expected a mapping for this tag');\n        return map;\n    },\n    createNode: (schema, obj, ctx) => YAMLMap.from(schema, obj, ctx)\n};\n\nexport { map };\n","import { createNode } from '../doc/createNode.js';\nimport { stringifyCollection } from '../stringify/stringifyCollection.js';\nimport { Collection } from './Collection.js';\nimport { SEQ, isScalar } from './identity.js';\nimport { isScalarValue } from './Scalar.js';\nimport { toJS } from './toJS.js';\n\nclass YAMLSeq extends Collection {\n    static get tagName() {\n        return 'tag:yaml.org,2002:seq';\n    }\n    constructor(schema) {\n        super(SEQ, schema);\n        this.items = [];\n    }\n    add(value) {\n        this.items.push(value);\n    }\n    /**\n     * Removes a value from the collection.\n     *\n     * `key` must contain a representation of an integer for this to succeed.\n     * It may be wrapped in a `Scalar`.\n     *\n     * @returns `true` if the item was found and removed.\n     */\n    delete(key) {\n        const idx = asItemIndex(key);\n        if (typeof idx !== 'number')\n            return false;\n        const del = this.items.splice(idx, 1);\n        return del.length > 0;\n    }\n    get(key, keepScalar) {\n        const idx = asItemIndex(key);\n        if (typeof idx !== 'number')\n            return undefined;\n        const it = this.items[idx];\n        return !keepScalar && isScalar(it) ? it.value : it;\n    }\n    /**\n     * Checks if the collection includes a value with the key `key`.\n     *\n     * `key` must contain a representation of an integer for this to succeed.\n     * It may be wrapped in a `Scalar`.\n     */\n    has(key) {\n        const idx = asItemIndex(key);\n        return typeof idx === 'number' && idx < this.items.length;\n    }\n    /**\n     * Sets a value in this collection. For `!!set`, `value` needs to be a\n     * boolean to add/remove the item from the set.\n     *\n     * If `key` does not contain a representation of an integer, this will throw.\n     * It may be wrapped in a `Scalar`.\n     */\n    set(key, value) {\n        const idx = asItemIndex(key);\n        if (typeof idx !== 'number')\n            throw new Error(`Expected a valid index, not ${key}.`);\n        const prev = this.items[idx];\n        if (isScalar(prev) && isScalarValue(value))\n            prev.value = value;\n        else\n            this.items[idx] = value;\n    }\n    toJSON(_, ctx) {\n        const seq = [];\n        if (ctx?.onCreate)\n            ctx.onCreate(seq);\n        let i = 0;\n        for (const item of this.items)\n            seq.push(toJS(item, String(i++), ctx));\n        return seq;\n    }\n    toString(ctx, onComment, onChompKeep) {\n        if (!ctx)\n            return JSON.stringify(this);\n        return stringifyCollection(this, ctx, {\n            blockItemPrefix: '- ',\n            flowChars: { start: '[', end: ']' },\n            itemIndent: (ctx.indent || '') + '  ',\n            onChompKeep,\n            onComment\n        });\n    }\n    static from(schema, obj, ctx) {\n        const { replacer } = ctx;\n        const seq = new this(schema);\n        if (obj && Symbol.iterator in Object(obj)) {\n            let i = 0;\n            for (let it of obj) {\n                if (typeof replacer === 'function') {\n                    const key = obj instanceof Set ? it : String(i++);\n                    it = replacer.call(obj, key, it);\n                }\n                seq.items.push(createNode(it, undefined, ctx));\n            }\n        }\n        return seq;\n    }\n}\nfunction asItemIndex(key) {\n    let idx = isScalar(key) ? key.value : key;\n    if (idx && typeof idx === 'string')\n        idx = Number(idx);\n    return typeof idx === 'number' && Number.isInteger(idx) && idx >= 0\n        ? idx\n        : null;\n}\n\nexport { YAMLSeq };\n","import { isSeq } from '../../nodes/identity.js';\nimport { YAMLSeq } from '../../nodes/YAMLSeq.js';\n\nconst seq = {\n    collection: 'seq',\n    default: true,\n    nodeClass: YAMLSeq,\n    tag: 'tag:yaml.org,2002:seq',\n    resolve(seq, onError) {\n        if (!isSeq(seq))\n            onError('Expected a sequence for this tag');\n        return seq;\n    },\n    createNode: (schema, obj, ctx) => YAMLSeq.from(schema, obj, ctx)\n};\n\nexport { seq };\n","import { stringifyString } from '../../stringify/stringifyString.js';\n\nconst string = {\n    identify: value => typeof value === 'string',\n    default: true,\n    tag: 'tag:yaml.org,2002:str',\n    resolve: str => str,\n    stringify(item, ctx, onComment, onChompKeep) {\n        ctx = Object.assign({ actualString: true }, ctx);\n        return stringifyString(item, ctx, onComment, onChompKeep);\n    }\n};\n\nexport { string };\n","import { Scalar } from '../../nodes/Scalar.js';\n\nconst nullTag = {\n    identify: value => value == null,\n    createNode: () => new Scalar(null),\n    default: true,\n    tag: 'tag:yaml.org,2002:null',\n    test: /^(?:~|[Nn]ull|NULL)?$/,\n    resolve: () => new Scalar(null),\n    stringify: ({ source }, ctx) => typeof source === 'string' && nullTag.test.test(source)\n        ? source\n        : ctx.options.nullStr\n};\n\nexport { nullTag };\n","import { Scalar } from '../../nodes/Scalar.js';\n\nconst boolTag = {\n    identify: value => typeof value === 'boolean',\n    default: true,\n    tag: 'tag:yaml.org,2002:bool',\n    test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/,\n    resolve: str => new Scalar(str[0] === 't' || str[0] === 'T'),\n    stringify({ source, value }, ctx) {\n        if (source && boolTag.test.test(source)) {\n            const sv = source[0] === 't' || source[0] === 'T';\n            if (value === sv)\n                return source;\n        }\n        return value ? ctx.options.trueStr : ctx.options.falseStr;\n    }\n};\n\nexport { boolTag };\n","function stringifyNumber({ format, minFractionDigits, tag, value }) {\n    if (typeof value === 'bigint')\n        return String(value);\n    const num = typeof value === 'number' ? value : Number(value);\n    if (!isFinite(num))\n        return isNaN(num) ? '.nan' : num < 0 ? '-.inf' : '.inf';\n    let n = Object.is(value, -0) ? '-0' : JSON.stringify(value);\n    if (!format &&\n        minFractionDigits &&\n        (!tag || tag === 'tag:yaml.org,2002:float') &&\n        /^\\d/.test(n)) {\n        let i = n.indexOf('.');\n        if (i < 0) {\n            i = n.length;\n            n += '.';\n        }\n        let d = minFractionDigits - (n.length - i - 1);\n        while (d-- > 0)\n            n += '0';\n    }\n    return n;\n}\n\nexport { stringifyNumber };\n","import { Scalar } from '../../nodes/Scalar.js';\nimport { stringifyNumber } from '../../stringify/stringifyNumber.js';\n\nconst floatNaN = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    test: /^(?:[-+]?\\.(?:inf|Inf|INF)|\\.nan|\\.NaN|\\.NAN)$/,\n    resolve: str => str.slice(-3).toLowerCase() === 'nan'\n        ? NaN\n        : str[0] === '-'\n            ? Number.NEGATIVE_INFINITY\n            : Number.POSITIVE_INFINITY,\n    stringify: stringifyNumber\n};\nconst floatExp = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    format: 'EXP',\n    test: /^[-+]?(?:\\.[0-9]+|[0-9]+(?:\\.[0-9]*)?)[eE][-+]?[0-9]+$/,\n    resolve: str => parseFloat(str),\n    stringify(node) {\n        const num = Number(node.value);\n        return isFinite(num) ? num.toExponential() : stringifyNumber(node);\n    }\n};\nconst float = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    test: /^[-+]?(?:\\.[0-9]+|[0-9]+\\.[0-9]*)$/,\n    resolve(str) {\n        const node = new Scalar(parseFloat(str));\n        const dot = str.indexOf('.');\n        if (dot !== -1 && str[str.length - 1] === '0')\n            node.minFractionDigits = str.length - dot - 1;\n        return node;\n    },\n    stringify: stringifyNumber\n};\n\nexport { float, floatExp, floatNaN };\n","import { stringifyNumber } from '../../stringify/stringifyNumber.js';\n\nconst intIdentify = (value) => typeof value === 'bigint' || Number.isInteger(value);\nconst intResolve = (str, offset, radix, { intAsBigInt }) => (intAsBigInt ? BigInt(str) : parseInt(str.substring(offset), radix));\nfunction intStringify(node, radix, prefix) {\n    const { value } = node;\n    if (intIdentify(value) && value >= 0)\n        return prefix + value.toString(radix);\n    return stringifyNumber(node);\n}\nconst intOct = {\n    identify: value => intIdentify(value) && value >= 0,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    format: 'OCT',\n    test: /^0o[0-7]+$/,\n    resolve: (str, _onError, opt) => intResolve(str, 2, 8, opt),\n    stringify: node => intStringify(node, 8, '0o')\n};\nconst int = {\n    identify: intIdentify,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    test: /^[-+]?[0-9]+$/,\n    resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt),\n    stringify: stringifyNumber\n};\nconst intHex = {\n    identify: value => intIdentify(value) && value >= 0,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    format: 'HEX',\n    test: /^0x[0-9a-fA-F]+$/,\n    resolve: (str, _onError, opt) => intResolve(str, 2, 16, opt),\n    stringify: node => intStringify(node, 16, '0x')\n};\n\nexport { int, intHex, intOct };\n","import { map } from '../common/map.js';\nimport { nullTag } from '../common/null.js';\nimport { seq } from '../common/seq.js';\nimport { string } from '../common/string.js';\nimport { boolTag } from './bool.js';\nimport { floatNaN, floatExp, float } from './float.js';\nimport { intOct, int, intHex } from './int.js';\n\nconst schema = [\n    map,\n    seq,\n    string,\n    nullTag,\n    boolTag,\n    intOct,\n    int,\n    intHex,\n    floatNaN,\n    floatExp,\n    float\n];\n\nexport { schema };\n","import { Scalar } from '../../nodes/Scalar.js';\nimport { map } from '../common/map.js';\nimport { seq } from '../common/seq.js';\n\nfunction intIdentify(value) {\n    return typeof value === 'bigint' || Number.isInteger(value);\n}\nconst stringifyJSON = ({ value }) => JSON.stringify(value);\nconst jsonScalars = [\n    {\n        identify: value => typeof value === 'string',\n        default: true,\n        tag: 'tag:yaml.org,2002:str',\n        resolve: str => str,\n        stringify: stringifyJSON\n    },\n    {\n        identify: value => value == null,\n        createNode: () => new Scalar(null),\n        default: true,\n        tag: 'tag:yaml.org,2002:null',\n        test: /^null$/,\n        resolve: () => null,\n        stringify: stringifyJSON\n    },\n    {\n        identify: value => typeof value === 'boolean',\n        default: true,\n        tag: 'tag:yaml.org,2002:bool',\n        test: /^true$|^false$/,\n        resolve: str => str === 'true',\n        stringify: stringifyJSON\n    },\n    {\n        identify: intIdentify,\n        default: true,\n        tag: 'tag:yaml.org,2002:int',\n        test: /^-?(?:0|[1-9][0-9]*)$/,\n        resolve: (str, _onError, { intAsBigInt }) => intAsBigInt ? BigInt(str) : parseInt(str, 10),\n        stringify: ({ value }) => intIdentify(value) ? value.toString() : JSON.stringify(value)\n    },\n    {\n        identify: value => typeof value === 'number',\n        default: true,\n        tag: 'tag:yaml.org,2002:float',\n        test: /^-?(?:0|[1-9][0-9]*)(?:\\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$/,\n        resolve: str => parseFloat(str),\n        stringify: stringifyJSON\n    }\n];\nconst jsonError = {\n    default: true,\n    tag: '',\n    test: /^/,\n    resolve(str, onError) {\n        onError(`Unresolved plain scalar ${JSON.stringify(str)}`);\n        return str;\n    }\n};\nconst schema = [map, seq].concat(jsonScalars, jsonError);\n\nexport { schema };\n","import { Scalar } from '../../nodes/Scalar.js';\nimport { stringifyString } from '../../stringify/stringifyString.js';\n\nconst binary = {\n    identify: value => value instanceof Uint8Array, // Buffer inherits from Uint8Array\n    default: false,\n    tag: 'tag:yaml.org,2002:binary',\n    /**\n     * Returns a Buffer in node and an Uint8Array in browsers\n     *\n     * To use the resulting buffer as an image, you'll want to do something like:\n     *\n     *   const blob = new Blob([buffer], { type: 'image/jpeg' })\n     *   document.querySelector('#photo').src = URL.createObjectURL(blob)\n     */\n    resolve(src, onError) {\n        if (typeof atob === 'function') {\n            // On IE 11, atob() can't handle newlines\n            const str = atob(src.replace(/[\\n\\r]/g, ''));\n            const buffer = new Uint8Array(str.length);\n            for (let i = 0; i < str.length; ++i)\n                buffer[i] = str.charCodeAt(i);\n            return buffer;\n        }\n        else {\n            onError('This environment does not support reading binary tags; either Buffer or atob is required');\n            return src;\n        }\n    },\n    stringify({ comment, type, value }, ctx, onComment, onChompKeep) {\n        if (!value)\n            return '';\n        const buf = value; // checked earlier by binary.identify()\n        let str;\n        if (typeof btoa === 'function') {\n            let s = '';\n            for (let i = 0; i < buf.length; ++i)\n                s += String.fromCharCode(buf[i]);\n            str = btoa(s);\n        }\n        else {\n            throw new Error('This environment does not support writing binary tags; either Buffer or btoa is required');\n        }\n        type ?? (type = Scalar.BLOCK_LITERAL);\n        if (type !== Scalar.QUOTE_DOUBLE) {\n            const lineWidth = Math.max(ctx.options.lineWidth - ctx.indent.length, ctx.options.minContentWidth);\n            const n = Math.ceil(str.length / lineWidth);\n            const lines = new Array(n);\n            for (let i = 0, o = 0; i < n; ++i, o += lineWidth) {\n                lines[i] = str.substr(o, lineWidth);\n            }\n            str = lines.join(type === Scalar.BLOCK_LITERAL ? '\\n' : ' ');\n        }\n        return stringifyString({ comment, type, value: str }, ctx, onComment, onChompKeep);\n    }\n};\n\nexport { binary };\n","import { isSeq, isPair, isMap } from '../../nodes/identity.js';\nimport { createPair, Pair } from '../../nodes/Pair.js';\nimport { Scalar } from '../../nodes/Scalar.js';\nimport { YAMLSeq } from '../../nodes/YAMLSeq.js';\n\nfunction resolvePairs(seq, onError) {\n    if (isSeq(seq)) {\n        for (let i = 0; i < seq.items.length; ++i) {\n            let item = seq.items[i];\n            if (isPair(item))\n                continue;\n            else if (isMap(item)) {\n                if (item.items.length > 1)\n                    onError('Each pair must have its own sequence indicator');\n                const pair = item.items[0] || new Pair(new Scalar(null));\n                if (item.commentBefore)\n                    pair.key.commentBefore = pair.key.commentBefore\n                        ? `${item.commentBefore}\\n${pair.key.commentBefore}`\n                        : item.commentBefore;\n                if (item.comment) {\n                    const cn = pair.value ?? pair.key;\n                    cn.comment = cn.comment\n                        ? `${item.comment}\\n${cn.comment}`\n                        : item.comment;\n                }\n                item = pair;\n            }\n            seq.items[i] = isPair(item) ? item : new Pair(item);\n        }\n    }\n    else\n        onError('Expected a sequence for this tag');\n    return seq;\n}\nfunction createPairs(schema, iterable, ctx) {\n    const { replacer } = ctx;\n    const pairs = new YAMLSeq(schema);\n    pairs.tag = 'tag:yaml.org,2002:pairs';\n    let i = 0;\n    if (iterable && Symbol.iterator in Object(iterable))\n        for (let it of iterable) {\n            if (typeof replacer === 'function')\n                it = replacer.call(iterable, String(i++), it);\n            let key, value;\n            if (Array.isArray(it)) {\n                if (it.length === 2) {\n                    key = it[0];\n                    value = it[1];\n                }\n                else\n                    throw new TypeError(`Expected [key, value] tuple: ${it}`);\n            }\n            else if (it && it instanceof Object) {\n                const keys = Object.keys(it);\n                if (keys.length === 1) {\n                    key = keys[0];\n                    value = it[key];\n                }\n                else {\n                    throw new TypeError(`Expected tuple with one key, not ${keys.length} keys`);\n                }\n            }\n            else {\n                key = it;\n            }\n            pairs.items.push(createPair(key, value, ctx));\n        }\n    return pairs;\n}\nconst pairs = {\n    collection: 'seq',\n    default: false,\n    tag: 'tag:yaml.org,2002:pairs',\n    resolve: resolvePairs,\n    createNode: createPairs\n};\n\nexport { createPairs, pairs, resolvePairs };\n","import { isScalar, isPair } from '../../nodes/identity.js';\nimport { toJS } from '../../nodes/toJS.js';\nimport { YAMLMap } from '../../nodes/YAMLMap.js';\nimport { YAMLSeq } from '../../nodes/YAMLSeq.js';\nimport { resolvePairs, createPairs } from './pairs.js';\n\nclass YAMLOMap extends YAMLSeq {\n    constructor() {\n        super();\n        this.add = YAMLMap.prototype.add.bind(this);\n        this.delete = YAMLMap.prototype.delete.bind(this);\n        this.get = YAMLMap.prototype.get.bind(this);\n        this.has = YAMLMap.prototype.has.bind(this);\n        this.set = YAMLMap.prototype.set.bind(this);\n        this.tag = YAMLOMap.tag;\n    }\n    /**\n     * If `ctx` is given, the return type is actually `Map<unknown, unknown>`,\n     * but TypeScript won't allow widening the signature of a child method.\n     */\n    toJSON(_, ctx) {\n        if (!ctx)\n            return super.toJSON(_);\n        const map = new Map();\n        if (ctx?.onCreate)\n            ctx.onCreate(map);\n        for (const pair of this.items) {\n            let key, value;\n            if (isPair(pair)) {\n                key = toJS(pair.key, '', ctx);\n                value = toJS(pair.value, key, ctx);\n            }\n            else {\n                key = toJS(pair, '', ctx);\n            }\n            if (map.has(key))\n                throw new Error('Ordered maps must not include duplicate keys');\n            map.set(key, value);\n        }\n        return map;\n    }\n    static from(schema, iterable, ctx) {\n        const pairs = createPairs(schema, iterable, ctx);\n        const omap = new this();\n        omap.items = pairs.items;\n        return omap;\n    }\n}\nYAMLOMap.tag = 'tag:yaml.org,2002:omap';\nconst omap = {\n    collection: 'seq',\n    identify: value => value instanceof Map,\n    nodeClass: YAMLOMap,\n    default: false,\n    tag: 'tag:yaml.org,2002:omap',\n    resolve(seq, onError) {\n        const pairs = resolvePairs(seq, onError);\n        const seenKeys = [];\n        for (const { key } of pairs.items) {\n            if (isScalar(key)) {\n                if (seenKeys.includes(key.value)) {\n                    onError(`Ordered maps must not include duplicate keys: ${key.value}`);\n                }\n                else {\n                    seenKeys.push(key.value);\n                }\n            }\n        }\n        return Object.assign(new YAMLOMap(), pairs);\n    },\n    createNode: (schema, iterable, ctx) => YAMLOMap.from(schema, iterable, ctx)\n};\n\nexport { YAMLOMap, omap };\n","import { Scalar } from '../../nodes/Scalar.js';\n\nfunction boolStringify({ value, source }, ctx) {\n    const boolObj = value ? trueTag : falseTag;\n    if (source && boolObj.test.test(source))\n        return source;\n    return value ? ctx.options.trueStr : ctx.options.falseStr;\n}\nconst trueTag = {\n    identify: value => value === true,\n    default: true,\n    tag: 'tag:yaml.org,2002:bool',\n    test: /^(?:Y|y|[Yy]es|YES|[Tt]rue|TRUE|[Oo]n|ON)$/,\n    resolve: () => new Scalar(true),\n    stringify: boolStringify\n};\nconst falseTag = {\n    identify: value => value === false,\n    default: true,\n    tag: 'tag:yaml.org,2002:bool',\n    test: /^(?:N|n|[Nn]o|NO|[Ff]alse|FALSE|[Oo]ff|OFF)$/,\n    resolve: () => new Scalar(false),\n    stringify: boolStringify\n};\n\nexport { falseTag, trueTag };\n","import { Scalar } from '../../nodes/Scalar.js';\nimport { stringifyNumber } from '../../stringify/stringifyNumber.js';\n\nconst floatNaN = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    test: /^(?:[-+]?\\.(?:inf|Inf|INF)|\\.nan|\\.NaN|\\.NAN)$/,\n    resolve: (str) => str.slice(-3).toLowerCase() === 'nan'\n        ? NaN\n        : str[0] === '-'\n            ? Number.NEGATIVE_INFINITY\n            : Number.POSITIVE_INFINITY,\n    stringify: stringifyNumber\n};\nconst floatExp = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    format: 'EXP',\n    test: /^[-+]?(?:[0-9][0-9_]*)?(?:\\.[0-9_]*)?[eE][-+]?[0-9]+$/,\n    resolve: (str) => parseFloat(str.replace(/_/g, '')),\n    stringify(node) {\n        const num = Number(node.value);\n        return isFinite(num) ? num.toExponential() : stringifyNumber(node);\n    }\n};\nconst float = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    test: /^[-+]?(?:[0-9][0-9_]*)?\\.[0-9_]*$/,\n    resolve(str) {\n        const node = new Scalar(parseFloat(str.replace(/_/g, '')));\n        const dot = str.indexOf('.');\n        if (dot !== -1) {\n            const f = str.substring(dot + 1).replace(/_/g, '');\n            if (f[f.length - 1] === '0')\n                node.minFractionDigits = f.length;\n        }\n        return node;\n    },\n    stringify: stringifyNumber\n};\n\nexport { float, floatExp, floatNaN };\n","import { stringifyNumber } from '../../stringify/stringifyNumber.js';\n\nconst intIdentify = (value) => typeof value === 'bigint' || Number.isInteger(value);\nfunction intResolve(str, offset, radix, { intAsBigInt }) {\n    const sign = str[0];\n    if (sign === '-' || sign === '+')\n        offset += 1;\n    str = str.substring(offset).replace(/_/g, '');\n    if (intAsBigInt) {\n        switch (radix) {\n            case 2:\n                str = `0b${str}`;\n                break;\n            case 8:\n                str = `0o${str}`;\n                break;\n            case 16:\n                str = `0x${str}`;\n                break;\n        }\n        const n = BigInt(str);\n        return sign === '-' ? BigInt(-1) * n : n;\n    }\n    const n = parseInt(str, radix);\n    return sign === '-' ? -1 * n : n;\n}\nfunction intStringify(node, radix, prefix) {\n    const { value } = node;\n    if (intIdentify(value)) {\n        const str = value.toString(radix);\n        return value < 0 ? '-' + prefix + str.substr(1) : prefix + str;\n    }\n    return stringifyNumber(node);\n}\nconst intBin = {\n    identify: intIdentify,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    format: 'BIN',\n    test: /^[-+]?0b[0-1_]+$/,\n    resolve: (str, _onError, opt) => intResolve(str, 2, 2, opt),\n    stringify: node => intStringify(node, 2, '0b')\n};\nconst intOct = {\n    identify: intIdentify,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    format: 'OCT',\n    test: /^[-+]?0[0-7_]+$/,\n    resolve: (str, _onError, opt) => intResolve(str, 1, 8, opt),\n    stringify: node => intStringify(node, 8, '0')\n};\nconst int = {\n    identify: intIdentify,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    test: /^[-+]?[0-9][0-9_]*$/,\n    resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt),\n    stringify: stringifyNumber\n};\nconst intHex = {\n    identify: intIdentify,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    format: 'HEX',\n    test: /^[-+]?0x[0-9a-fA-F_]+$/,\n    resolve: (str, _onError, opt) => intResolve(str, 2, 16, opt),\n    stringify: node => intStringify(node, 16, '0x')\n};\n\nexport { int, intBin, intHex, intOct };\n","import { isMap, isPair, isScalar } from '../../nodes/identity.js';\nimport { Pair, createPair } from '../../nodes/Pair.js';\nimport { YAMLMap, findPair } from '../../nodes/YAMLMap.js';\n\nclass YAMLSet extends YAMLMap {\n    constructor(schema) {\n        super(schema);\n        this.tag = YAMLSet.tag;\n    }\n    add(key) {\n        let pair;\n        if (isPair(key))\n            pair = key;\n        else if (key &&\n            typeof key === 'object' &&\n            'key' in key &&\n            'value' in key &&\n            key.value === null)\n            pair = new Pair(key.key, null);\n        else\n            pair = new Pair(key, null);\n        const prev = findPair(this.items, pair.key);\n        if (!prev)\n            this.items.push(pair);\n    }\n    /**\n     * If `keepPair` is `true`, returns the Pair matching `key`.\n     * Otherwise, returns the value of that Pair's key.\n     */\n    get(key, keepPair) {\n        const pair = findPair(this.items, key);\n        return !keepPair && isPair(pair)\n            ? isScalar(pair.key)\n                ? pair.key.value\n                : pair.key\n            : pair;\n    }\n    set(key, value) {\n        if (typeof value !== 'boolean')\n            throw new Error(`Expected boolean value for set(key, value) in a YAML set, not ${typeof value}`);\n        const prev = findPair(this.items, key);\n        if (prev && !value) {\n            this.items.splice(this.items.indexOf(prev), 1);\n        }\n        else if (!prev && value) {\n            this.items.push(new Pair(key));\n        }\n    }\n    toJSON(_, ctx) {\n        return super.toJSON(_, ctx, Set);\n    }\n    toString(ctx, onComment, onChompKeep) {\n        if (!ctx)\n            return JSON.stringify(this);\n        if (this.hasAllNullValues(true))\n            return super.toString(Object.assign({}, ctx, { allNullValues: true }), onComment, onChompKeep);\n        else\n            throw new Error('Set items must all have null values');\n    }\n    static from(schema, iterable, ctx) {\n        const { replacer } = ctx;\n        const set = new this(schema);\n        if (iterable && Symbol.iterator in Object(iterable))\n            for (let value of iterable) {\n                if (typeof replacer === 'function')\n                    value = replacer.call(iterable, value, value);\n                set.items.push(createPair(value, null, ctx));\n            }\n        return set;\n    }\n}\nYAMLSet.tag = 'tag:yaml.org,2002:set';\nconst set = {\n    collection: 'map',\n    identify: value => value instanceof Set,\n    nodeClass: YAMLSet,\n    default: false,\n    tag: 'tag:yaml.org,2002:set',\n    createNode: (schema, iterable, ctx) => YAMLSet.from(schema, iterable, ctx),\n    resolve(map, onError) {\n        if (isMap(map)) {\n            if (map.hasAllNullValues(true))\n                return Object.assign(new YAMLSet(), map);\n            else\n                onError('Set items must all have null values');\n        }\n        else\n            onError('Expected a mapping for this tag');\n        return map;\n    }\n};\n\nexport { YAMLSet, set };\n","import { stringifyNumber } from '../../stringify/stringifyNumber.js';\n\n/** Internal types handle bigint as number, because TS can't figure it out. */\nfunction parseSexagesimal(str, asBigInt) {\n    const sign = str[0];\n    const parts = sign === '-' || sign === '+' ? str.substring(1) : str;\n    const num = (n) => asBigInt ? BigInt(n) : Number(n);\n    const res = parts\n        .replace(/_/g, '')\n        .split(':')\n        .reduce((res, p) => res * num(60) + num(p), num(0));\n    return (sign === '-' ? num(-1) * res : res);\n}\n/**\n * hhhh:mm:ss.sss\n *\n * Internal types handle bigint as number, because TS can't figure it out.\n */\nfunction stringifySexagesimal(node) {\n    let { value } = node;\n    let num = (n) => n;\n    if (typeof value === 'bigint')\n        num = n => BigInt(n);\n    else if (isNaN(value) || !isFinite(value))\n        return stringifyNumber(node);\n    let sign = '';\n    if (value < 0) {\n        sign = '-';\n        value *= num(-1);\n    }\n    const _60 = num(60);\n    const parts = [value % _60]; // seconds, including ms\n    if (value < 60) {\n        parts.unshift(0); // at least one : is required\n    }\n    else {\n        value = (value - parts[0]) / _60;\n        parts.unshift(value % _60); // minutes\n        if (value >= 60) {\n            value = (value - parts[0]) / _60;\n            parts.unshift(value); // hours\n        }\n    }\n    return (sign +\n        parts\n            .map(n => String(n).padStart(2, '0'))\n            .join(':')\n            .replace(/000000\\d*$/, '') // % 60 may introduce error\n    );\n}\nconst intTime = {\n    identify: value => typeof value === 'bigint' || Number.isInteger(value),\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    format: 'TIME',\n    test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+$/,\n    resolve: (str, _onError, { intAsBigInt }) => parseSexagesimal(str, intAsBigInt),\n    stringify: stringifySexagesimal\n};\nconst floatTime = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    format: 'TIME',\n    test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*$/,\n    resolve: str => parseSexagesimal(str, false),\n    stringify: stringifySexagesimal\n};\nconst timestamp = {\n    identify: value => value instanceof Date,\n    default: true,\n    tag: 'tag:yaml.org,2002:timestamp',\n    // If the time zone is omitted, the timestamp is assumed to be specified in UTC. The time part\n    // may be omitted altogether, resulting in a date format. In such a case, the time part is\n    // assumed to be 00:00:00Z (start of day, UTC).\n    test: RegExp('^([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})' + // YYYY-Mm-Dd\n        '(?:' + // time is optional\n        '(?:t|T|[ \\\\t]+)' + // t | T | whitespace\n        '([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2}(\\\\.[0-9]+)?)' + // Hh:Mm:Ss(.ss)?\n        '(?:[ \\\\t]*(Z|[-+][012]?[0-9](?::[0-9]{2})?))?' + // Z | +5 | -03:30\n        ')?$'),\n    resolve(str) {\n        const match = str.match(timestamp.test);\n        if (!match)\n            throw new Error('!!timestamp expects a date, starting with yyyy-mm-dd');\n        const [, year, month, day, hour, minute, second] = match.map(Number);\n        const millisec = match[7] ? Number((match[7] + '00').substr(1, 3)) : 0;\n        let date = Date.UTC(year, month - 1, day, hour || 0, minute || 0, second || 0, millisec);\n        const tz = match[8];\n        if (tz && tz !== 'Z') {\n            let d = parseSexagesimal(tz, false);\n            if (Math.abs(d) < 30)\n                d *= 60;\n            date -= 60000 * d;\n        }\n        return new Date(date);\n    },\n    stringify: ({ value }) => value?.toISOString().replace(/(T00:00:00)?\\.000Z$/, '') ?? ''\n};\n\nexport { floatTime, intTime, timestamp };\n","import { map } from '../common/map.js';\nimport { nullTag } from '../common/null.js';\nimport { seq } from '../common/seq.js';\nimport { string } from '../common/string.js';\nimport { binary } from './binary.js';\nimport { trueTag, falseTag } from './bool.js';\nimport { floatNaN, floatExp, float } from './float.js';\nimport { intBin, intOct, int, intHex } from './int.js';\nimport { merge } from './merge.js';\nimport { omap } from './omap.js';\nimport { pairs } from './pairs.js';\nimport { set } from './set.js';\nimport { intTime, floatTime, timestamp } from './timestamp.js';\n\nconst schema = [\n    map,\n    seq,\n    string,\n    nullTag,\n    trueTag,\n    falseTag,\n    intBin,\n    intOct,\n    int,\n    intHex,\n    floatNaN,\n    floatExp,\n    float,\n    binary,\n    merge,\n    omap,\n    pairs,\n    set,\n    intTime,\n    floatTime,\n    timestamp\n];\n\nexport { schema };\n","import { map } from './common/map.js';\nimport { nullTag } from './common/null.js';\nimport { seq } from './common/seq.js';\nimport { string } from './common/string.js';\nimport { boolTag } from './core/bool.js';\nimport { floatNaN, floatExp, float } from './core/float.js';\nimport { intOct, intHex, int } from './core/int.js';\nimport { schema } from './core/schema.js';\nimport { schema as schema$1 } from './json/schema.js';\nimport { binary } from './yaml-1.1/binary.js';\nimport { merge } from './yaml-1.1/merge.js';\nimport { omap } from './yaml-1.1/omap.js';\nimport { pairs } from './yaml-1.1/pairs.js';\nimport { schema as schema$2 } from './yaml-1.1/schema.js';\nimport { set } from './yaml-1.1/set.js';\nimport { timestamp, intTime, floatTime } from './yaml-1.1/timestamp.js';\n\nconst schemas = new Map([\n    ['core', schema],\n    ['failsafe', [map, seq, string]],\n    ['json', schema$1],\n    ['yaml11', schema$2],\n    ['yaml-1.1', schema$2]\n]);\nconst tagsByName = {\n    binary,\n    bool: boolTag,\n    float,\n    floatExp,\n    floatNaN,\n    floatTime,\n    int,\n    intHex,\n    intOct,\n    intTime,\n    map,\n    merge,\n    null: nullTag,\n    omap,\n    pairs,\n    seq,\n    set,\n    timestamp\n};\nconst coreKnownTags = {\n    'tag:yaml.org,2002:binary': binary,\n    'tag:yaml.org,2002:merge': merge,\n    'tag:yaml.org,2002:omap': omap,\n    'tag:yaml.org,2002:pairs': pairs,\n    'tag:yaml.org,2002:set': set,\n    'tag:yaml.org,2002:timestamp': timestamp\n};\nfunction getTags(customTags, schemaName, addMergeTag) {\n    const schemaTags = schemas.get(schemaName);\n    if (schemaTags && !customTags) {\n        return addMergeTag && !schemaTags.includes(merge)\n            ? schemaTags.concat(merge)\n            : schemaTags.slice();\n    }\n    let tags = schemaTags;\n    if (!tags) {\n        if (Array.isArray(customTags))\n            tags = [];\n        else {\n            const keys = Array.from(schemas.keys())\n                .filter(key => key !== 'yaml11')\n                .map(key => JSON.stringify(key))\n                .join(', ');\n            throw new Error(`Unknown schema \"${schemaName}\"; use one of ${keys} or define customTags array`);\n        }\n    }\n    if (Array.isArray(customTags)) {\n        for (const tag of customTags)\n            tags = tags.concat(tag);\n    }\n    else if (typeof customTags === 'function') {\n        tags = customTags(tags.slice());\n    }\n    if (addMergeTag)\n        tags = tags.concat(merge);\n    return tags.reduce((tags, tag) => {\n        const tagObj = typeof tag === 'string' ? tagsByName[tag] : tag;\n        if (!tagObj) {\n            const tagName = JSON.stringify(tag);\n            const keys = Object.keys(tagsByName)\n                .map(key => JSON.stringify(key))\n                .join(', ');\n            throw new Error(`Unknown custom tag ${tagName}; use one of ${keys}`);\n        }\n        if (!tags.includes(tagObj))\n            tags.push(tagObj);\n        return tags;\n    }, []);\n}\n\nexport { coreKnownTags, getTags };\n","class YAMLError extends Error {\n    constructor(name, pos, code, message) {\n        super();\n        this.name = name;\n        this.code = code;\n        this.message = message;\n        this.pos = pos;\n    }\n}\nclass YAMLParseError extends YAMLError {\n    constructor(pos, code, message) {\n        super('YAMLParseError', pos, code, message);\n    }\n}\nclass YAMLWarning extends YAMLError {\n    constructor(pos, code, message) {\n        super('YAMLWarning', pos, code, message);\n    }\n}\nconst prettifyError = (src, lc) => (error) => {\n    if (error.pos[0] === -1)\n        return;\n    error.linePos = error.pos.map(pos => lc.linePos(pos));\n    const { line, col } = error.linePos[0];\n    error.message += ` at line ${line}, column ${col}`;\n    let ci = col - 1;\n    let lineStr = src\n        .substring(lc.lineStarts[line - 1], lc.lineStarts[line])\n        .replace(/[\\n\\r]+$/, '');\n    // Trim to max 80 chars, keeping col position near the middle\n    if (ci >= 60 && lineStr.length > 80) {\n        const trimStart = Math.min(ci - 39, lineStr.length - 79);\n        lineStr = '…' + lineStr.substring(trimStart);\n        ci -= trimStart - 1;\n    }\n    if (lineStr.length > 80)\n        lineStr = lineStr.substring(0, 79) + '…';\n    // Include previous line in context if pointing at line start\n    if (line > 1 && /^ *$/.test(lineStr.substring(0, ci))) {\n        // Regexp won't match if start is trimmed\n        let prev = src.substring(lc.lineStarts[line - 2], lc.lineStarts[line - 1]);\n        if (prev.length > 80)\n            prev = prev.substring(0, 79) + '…\\n';\n        lineStr = prev + lineStr;\n    }\n    if (/[^ ]/.test(lineStr)) {\n        let count = 1;\n        const end = error.linePos[1];\n        if (end?.line === line && end.col > col) {\n            count = Math.max(1, Math.min(end.col - col, 80 - ci));\n        }\n        const pointer = ' '.repeat(ci) + '^'.repeat(count);\n        error.message += `:\\n\\n${lineStr}\\n${pointer}\\n`;\n    }\n};\n\nexport { YAMLError, YAMLParseError, YAMLWarning, prettifyError };\n","const BREAK = Symbol('break visit');\nconst SKIP = Symbol('skip children');\nconst REMOVE = Symbol('remove item');\n/**\n * Apply a visitor to a CST document or item.\n *\n * Walks through the tree (depth-first) starting from the root, calling a\n * `visitor` function with two arguments when entering each item:\n *   - `item`: The current item, which included the following members:\n *     - `start: SourceToken[]` – Source tokens before the key or value,\n *       possibly including its anchor or tag.\n *     - `key?: Token | null` – Set for pair values. May then be `null`, if\n *       the key before the `:` separator is empty.\n *     - `sep?: SourceToken[]` – Source tokens between the key and the value,\n *       which should include the `:` map value indicator if `value` is set.\n *     - `value?: Token` – The value of a sequence item, or of a map pair.\n *   - `path`: The steps from the root to the current node, as an array of\n *     `['key' | 'value', number]` tuples.\n *\n * The return value of the visitor may be used to control the traversal:\n *   - `undefined` (default): Do nothing and continue\n *   - `visit.SKIP`: Do not visit the children of this token, continue with\n *      next sibling\n *   - `visit.BREAK`: Terminate traversal completely\n *   - `visit.REMOVE`: Remove the current item, then continue with the next one\n *   - `number`: Set the index of the next step. This is useful especially if\n *     the index of the current token has changed.\n *   - `function`: Define the next visitor for this item. After the original\n *     visitor is called on item entry, next visitors are called after handling\n *     a non-empty `key` and when exiting the item.\n */\nfunction visit(cst, visitor) {\n    if ('type' in cst && cst.type === 'document')\n        cst = { start: cst.start, value: cst.value };\n    _visit(Object.freeze([]), cst, visitor);\n}\n// Without the `as symbol` casts, TS declares these in the `visit`\n// namespace using `var`, but then complains about that because\n// `unique symbol` must be `const`.\n/** Terminate visit traversal completely */\nvisit.BREAK = BREAK;\n/** Do not visit the children of the current item */\nvisit.SKIP = SKIP;\n/** Remove the current item */\nvisit.REMOVE = REMOVE;\n/** Find the item at `path` from `cst` as the root */\nvisit.itemAtPath = (cst, path) => {\n    let item = cst;\n    for (const [field, index] of path) {\n        const tok = item?.[field];\n        if (tok && 'items' in tok) {\n            item = tok.items[index];\n        }\n        else\n            return undefined;\n    }\n    return item;\n};\n/**\n * Get the immediate parent collection of the item at `path` from `cst` as the root.\n *\n * Throws an error if the collection is not found, which should never happen if the item itself exists.\n */\nvisit.parentCollection = (cst, path) => {\n    const parent = visit.itemAtPath(cst, path.slice(0, -1));\n    const field = path[path.length - 1][0];\n    const coll = parent?.[field];\n    if (coll && 'items' in coll)\n        return coll;\n    throw new Error('Parent collection not found');\n};\nfunction _visit(path, item, visitor) {\n    let ctrl = visitor(item, path);\n    if (typeof ctrl === 'symbol')\n        return ctrl;\n    for (const field of ['key', 'value']) {\n        const token = item[field];\n        if (token && 'items' in token) {\n            for (let i = 0; i < token.items.length; ++i) {\n                const ci = _visit(Object.freeze(path.concat([[field, i]])), token.items[i], visitor);\n                if (typeof ci === 'number')\n                    i = ci - 1;\n                else if (ci === BREAK)\n                    return BREAK;\n                else if (ci === REMOVE) {\n                    token.items.splice(i, 1);\n                    i -= 1;\n                }\n            }\n            if (typeof ctrl === 'function' && field === 'key')\n                ctrl = ctrl(item, path);\n        }\n    }\n    return typeof ctrl === 'function' ? ctrl(item, path) : ctrl;\n}\n\nexport { visit };\n","import { Note } from \"../core\";\n\nexport enum GamakaType {\n  // Kampitam (~)\n  // The oscilation between 2 notes - eg p , S..n S..n S..n\n  Kampitham = \"Kampitham\",\n\n  // Nokku (w)\n  Nokku = \"Nokku\",\n\n  // Spuritham (∴ / u+2234) - Stress on the second note of a jantai\n  Spuritham = \"Spuritham\",\n\n  // Prathyagatham (∵ / u+2235) - Similar to reverse of Spuritham (in descending order)\n  Prathyagatham = \"Prathyagatham\",\n\n  // Raavi (^)\n  Aahaatam_Raavi = \"Raavi\",\n\n  // Kandippu (✓)\n  // eg - Shankarabharanam's S. ,,, n , P ,,,  - where the n is subtle\n  Aahaatam_Kandippu = \"Kandippu\",\n\n  // Vali (⌒ - U+2312)\n  Vaali = \"Vaali\",\n\n  // Odukkal (x):\n  // A veena gamakam where the note itself is stretched more to get the next\n  // note effect (instead of plucking the next note itself).\n  // Not possible where plucking of strings is not possible.\n  // On voice etc it just will sound like an Eetra Jaaru.\n  Odukkal = \"Odukkal\",\n\n  // (/) Ascension from one note to another - eg S / P\n  Jaaru_Eetra = \"EetraJaaru\",\n\n  // (\\) Descending from one note to another - eg P \\ S\n  Jaaru_Irakka = \"IrakkaJaaru\",\n\n  // Orikkai (γ)\n  // eg S~~ RN N~~S.D  D~~~NP\n  Orikkai = \"Orikkai\",\n}\n\nexport class Gamaka {\n  constructor(public readonly type: GamakaType) {}\n  debugValue(): any {\n    return { type: this.type };\n  }\n}\n\nexport class JaaruGamaka extends Gamaka {\n  constructor(\n    public readonly ascending = true,\n    public readonly startingNote: null | Note = null,\n  ) {\n    super(ascending ? GamakaType.Jaaru_Eetra : GamakaType.Jaaru_Irakka);\n  }\n\n  debugValue(): any {\n    const out = { ...super.debugValue(), ascending: this.ascending };\n    if (this.startingNote) out[\"startingNote\"] = this.startingNote.debugValue();\n    return out;\n  }\n}\n\nexport function parseEmbelishment(value: string): [any, boolean] {\n  value = value.substring(1);\n  if (value == \"\") {\n    return [new Gamaka(GamakaType.Kampitham), true];\n  } else if (value == \"^\") {\n    return [new Gamaka(GamakaType.Aahaatam_Raavi), true];\n  } else if (value == \"~\") {\n    return [new Gamaka(GamakaType.Vaali), true];\n  } else if (value == \"w\" || value == \"W\") {\n    return [new Gamaka(GamakaType.Nokku), true];\n  } else if (value == \"∴\" || value == \":-\") {\n    return [new Gamaka(GamakaType.Spuritham), true];\n  } else if (value == \"∵\" || value == \"-:\") {\n    return [new Gamaka(GamakaType.Prathyagatham), true];\n  } else if (value == \"✓\" || value == \"./\" || value == \".\\\\\") {\n    return [new Gamaka(GamakaType.Aahaatam_Kandippu), true];\n  } else if (value.endsWith(\"/\")) {\n    value = value.substring(0, value.length - 1).trim();\n    return [new JaaruGamaka(true, value.length > 0 ? new Note(value) : null), true];\n  } else if (value.endsWith(\"\\\\\")) {\n    value = value.substring(0, value.length - 1);\n    return [new JaaruGamaka(false, value.length > 0 ? new Note(value) : null), true];\n  } else if (value == \"x\") {\n    return [new Gamaka(GamakaType.Odukkal), true];\n  } else if (value == \"γ\" || value == \"Y\") {\n    return [new Gamaka(GamakaType.Orikkai), true];\n  }\n  // throw new Error(\"Invalid carnatic embelishment: \" + value);\n  return [null, false];\n}\n","import { BOM, DOCUMENT, FLOW_END, SCALAR } from './cst.js';\n\n/*\nSTART -> stream\n\nstream\n  directive -> line-end -> stream\n  indent + line-end -> stream\n  [else] -> line-start\n\nline-end\n  comment -> line-end\n  newline -> .\n  input-end -> END\n\nline-start\n  doc-start -> doc\n  doc-end -> stream\n  [else] -> indent -> block-start\n\nblock-start\n  seq-item-start -> block-start\n  explicit-key-start -> block-start\n  map-value-start -> block-start\n  [else] -> doc\n\ndoc\n  line-end -> line-start\n  spaces -> doc\n  anchor -> doc\n  tag -> doc\n  flow-start -> flow -> doc\n  flow-end -> error -> doc\n  seq-item-start -> error -> doc\n  explicit-key-start -> error -> doc\n  map-value-start -> doc\n  alias -> doc\n  quote-start -> quoted-scalar -> doc\n  block-scalar-header -> line-end -> block-scalar(min) -> line-start\n  [else] -> plain-scalar(false, min) -> doc\n\nflow\n  line-end -> flow\n  spaces -> flow\n  anchor -> flow\n  tag -> flow\n  flow-start -> flow -> flow\n  flow-end -> .\n  seq-item-start -> error -> flow\n  explicit-key-start -> flow\n  map-value-start -> flow\n  alias -> flow\n  quote-start -> quoted-scalar -> flow\n  comma -> flow\n  [else] -> plain-scalar(true, 0) -> flow\n\nquoted-scalar\n  quote-end -> .\n  [else] -> quoted-scalar\n\nblock-scalar(min)\n  newline + peek(indent < min) -> .\n  [else] -> block-scalar(min)\n\nplain-scalar(is-flow, min)\n  scalar-end(is-flow) -> .\n  peek(newline + (indent < min)) -> .\n  [else] -> plain-scalar(min)\n*/\nfunction isEmpty(ch) {\n    switch (ch) {\n        case undefined:\n        case ' ':\n        case '\\n':\n        case '\\r':\n        case '\\t':\n            return true;\n        default:\n            return false;\n    }\n}\nconst hexDigits = new Set('0123456789ABCDEFabcdef');\nconst tagChars = new Set(\"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-#;/?:@&=+$_.!~*'()\");\nconst flowIndicatorChars = new Set(',[]{}');\nconst invalidAnchorChars = new Set(' ,[]{}\\n\\r\\t');\nconst isNotAnchorChar = (ch) => !ch || invalidAnchorChars.has(ch);\n/**\n * Splits an input string into lexical tokens, i.e. smaller strings that are\n * easily identifiable by `tokens.tokenType()`.\n *\n * Lexing starts always in a \"stream\" context. Incomplete input may be buffered\n * until a complete token can be emitted.\n *\n * In addition to slices of the original input, the following control characters\n * may also be emitted:\n *\n * - `\\x02` (Start of Text): A document starts with the next token\n * - `\\x18` (Cancel): Unexpected end of flow-mode (indicates an error)\n * - `\\x1f` (Unit Separator): Next token is a scalar value\n * - `\\u{FEFF}` (Byte order mark): Emitted separately outside documents\n */\nclass Lexer {\n    constructor() {\n        /**\n         * Flag indicating whether the end of the current buffer marks the end of\n         * all input\n         */\n        this.atEnd = false;\n        /**\n         * Explicit indent set in block scalar header, as an offset from the current\n         * minimum indent, so e.g. set to 1 from a header `|2+`. Set to -1 if not\n         * explicitly set.\n         */\n        this.blockScalarIndent = -1;\n        /**\n         * Block scalars that include a + (keep) chomping indicator in their header\n         * include trailing empty lines, which are otherwise excluded from the\n         * scalar's contents.\n         */\n        this.blockScalarKeep = false;\n        /** Current input */\n        this.buffer = '';\n        /**\n         * Flag noting whether the map value indicator : can immediately follow this\n         * node within a flow context.\n         */\n        this.flowKey = false;\n        /** Count of surrounding flow collection levels. */\n        this.flowLevel = 0;\n        /**\n         * Minimum level of indentation required for next lines to be parsed as a\n         * part of the current scalar value.\n         */\n        this.indentNext = 0;\n        /** Indentation level of the current line. */\n        this.indentValue = 0;\n        /** Position of the next \\n character. */\n        this.lineEndPos = null;\n        /** Stores the state of the lexer if reaching the end of incpomplete input */\n        this.next = null;\n        /** A pointer to `buffer`; the current position of the lexer. */\n        this.pos = 0;\n    }\n    /**\n     * Generate YAML tokens from the `source` string. If `incomplete`,\n     * a part of the last line may be left as a buffer for the next call.\n     *\n     * @returns A generator of lexical tokens\n     */\n    *lex(source, incomplete = false) {\n        if (source) {\n            if (typeof source !== 'string')\n                throw TypeError('source is not a string');\n            this.buffer = this.buffer ? this.buffer + source : source;\n            this.lineEndPos = null;\n        }\n        this.atEnd = !incomplete;\n        let next = this.next ?? 'stream';\n        while (next && (incomplete || this.hasChars(1)))\n            next = yield* this.parseNext(next);\n    }\n    atLineEnd() {\n        let i = this.pos;\n        let ch = this.buffer[i];\n        while (ch === ' ' || ch === '\\t')\n            ch = this.buffer[++i];\n        if (!ch || ch === '#' || ch === '\\n')\n            return true;\n        if (ch === '\\r')\n            return this.buffer[i + 1] === '\\n';\n        return false;\n    }\n    charAt(n) {\n        return this.buffer[this.pos + n];\n    }\n    continueScalar(offset) {\n        let ch = this.buffer[offset];\n        if (this.indentNext > 0) {\n            let indent = 0;\n            while (ch === ' ')\n                ch = this.buffer[++indent + offset];\n            if (ch === '\\r') {\n                const next = this.buffer[indent + offset + 1];\n                if (next === '\\n' || (!next && !this.atEnd))\n                    return offset + indent + 1;\n            }\n            return ch === '\\n' || indent >= this.indentNext || (!ch && !this.atEnd)\n                ? offset + indent\n                : -1;\n        }\n        if (ch === '-' || ch === '.') {\n            const dt = this.buffer.substr(offset, 3);\n            if ((dt === '---' || dt === '...') && isEmpty(this.buffer[offset + 3]))\n                return -1;\n        }\n        return offset;\n    }\n    getLine() {\n        let end = this.lineEndPos;\n        if (typeof end !== 'number' || (end !== -1 && end < this.pos)) {\n            end = this.buffer.indexOf('\\n', this.pos);\n            this.lineEndPos = end;\n        }\n        if (end === -1)\n            return this.atEnd ? this.buffer.substring(this.pos) : null;\n        if (this.buffer[end - 1] === '\\r')\n            end -= 1;\n        return this.buffer.substring(this.pos, end);\n    }\n    hasChars(n) {\n        return this.pos + n <= this.buffer.length;\n    }\n    setNext(state) {\n        this.buffer = this.buffer.substring(this.pos);\n        this.pos = 0;\n        this.lineEndPos = null;\n        this.next = state;\n        return null;\n    }\n    peek(n) {\n        return this.buffer.substr(this.pos, n);\n    }\n    *parseNext(next) {\n        switch (next) {\n            case 'stream':\n                return yield* this.parseStream();\n            case 'line-start':\n                return yield* this.parseLineStart();\n            case 'block-start':\n                return yield* this.parseBlockStart();\n            case 'doc':\n                return yield* this.parseDocument();\n            case 'flow':\n                return yield* this.parseFlowCollection();\n            case 'quoted-scalar':\n                return yield* this.parseQuotedScalar();\n            case 'block-scalar':\n                return yield* this.parseBlockScalar();\n            case 'plain-scalar':\n                return yield* this.parsePlainScalar();\n        }\n    }\n    *parseStream() {\n        let line = this.getLine();\n        if (line === null)\n            return this.setNext('stream');\n        if (line[0] === BOM) {\n            yield* this.pushCount(1);\n            line = line.substring(1);\n        }\n        if (line[0] === '%') {\n            let dirEnd = line.length;\n            let cs = line.indexOf('#');\n            while (cs !== -1) {\n                const ch = line[cs - 1];\n                if (ch === ' ' || ch === '\\t') {\n                    dirEnd = cs - 1;\n                    break;\n                }\n                else {\n                    cs = line.indexOf('#', cs + 1);\n                }\n            }\n            while (true) {\n                const ch = line[dirEnd - 1];\n                if (ch === ' ' || ch === '\\t')\n                    dirEnd -= 1;\n                else\n                    break;\n            }\n            const n = (yield* this.pushCount(dirEnd)) + (yield* this.pushSpaces(true));\n            yield* this.pushCount(line.length - n); // possible comment\n            this.pushNewline();\n            return 'stream';\n        }\n        if (this.atLineEnd()) {\n            const sp = yield* this.pushSpaces(true);\n            yield* this.pushCount(line.length - sp);\n            yield* this.pushNewline();\n            return 'stream';\n        }\n        yield DOCUMENT;\n        return yield* this.parseLineStart();\n    }\n    *parseLineStart() {\n        const ch = this.charAt(0);\n        if (!ch && !this.atEnd)\n            return this.setNext('line-start');\n        if (ch === '-' || ch === '.') {\n            if (!this.atEnd && !this.hasChars(4))\n                return this.setNext('line-start');\n            const s = this.peek(3);\n            if ((s === '---' || s === '...') && isEmpty(this.charAt(3))) {\n                yield* this.pushCount(3);\n                this.indentValue = 0;\n                this.indentNext = 0;\n                return s === '---' ? 'doc' : 'stream';\n            }\n        }\n        this.indentValue = yield* this.pushSpaces(false);\n        if (this.indentNext > this.indentValue && !isEmpty(this.charAt(1)))\n            this.indentNext = this.indentValue;\n        return yield* this.parseBlockStart();\n    }\n    *parseBlockStart() {\n        const [ch0, ch1] = this.peek(2);\n        if (!ch1 && !this.atEnd)\n            return this.setNext('block-start');\n        if ((ch0 === '-' || ch0 === '?' || ch0 === ':') && isEmpty(ch1)) {\n            const n = (yield* this.pushCount(1)) + (yield* this.pushSpaces(true));\n            this.indentNext = this.indentValue + 1;\n            this.indentValue += n;\n            return yield* this.parseBlockStart();\n        }\n        return 'doc';\n    }\n    *parseDocument() {\n        yield* this.pushSpaces(true);\n        const line = this.getLine();\n        if (line === null)\n            return this.setNext('doc');\n        let n = yield* this.pushIndicators();\n        switch (line[n]) {\n            case '#':\n                yield* this.pushCount(line.length - n);\n            // fallthrough\n            case undefined:\n                yield* this.pushNewline();\n                return yield* this.parseLineStart();\n            case '{':\n            case '[':\n                yield* this.pushCount(1);\n                this.flowKey = false;\n                this.flowLevel = 1;\n                return 'flow';\n            case '}':\n            case ']':\n                // this is an error\n                yield* this.pushCount(1);\n                return 'doc';\n            case '*':\n                yield* this.pushUntil(isNotAnchorChar);\n                return 'doc';\n            case '\"':\n            case \"'\":\n                return yield* this.parseQuotedScalar();\n            case '|':\n            case '>':\n                n += yield* this.parseBlockScalarHeader();\n                n += yield* this.pushSpaces(true);\n                yield* this.pushCount(line.length - n);\n                yield* this.pushNewline();\n                return yield* this.parseBlockScalar();\n            default:\n                return yield* this.parsePlainScalar();\n        }\n    }\n    *parseFlowCollection() {\n        let nl, sp;\n        let indent = -1;\n        do {\n            nl = yield* this.pushNewline();\n            if (nl > 0) {\n                sp = yield* this.pushSpaces(false);\n                this.indentValue = indent = sp;\n            }\n            else {\n                sp = 0;\n            }\n            sp += yield* this.pushSpaces(true);\n        } while (nl + sp > 0);\n        const line = this.getLine();\n        if (line === null)\n            return this.setNext('flow');\n        if ((indent !== -1 && indent < this.indentNext && line[0] !== '#') ||\n            (indent === 0 &&\n                (line.startsWith('---') || line.startsWith('...')) &&\n                isEmpty(line[3]))) {\n            // Allowing for the terminal ] or } at the same (rather than greater)\n            // indent level as the initial [ or { is technically invalid, but\n            // failing here would be surprising to users.\n            const atFlowEndMarker = indent === this.indentNext - 1 &&\n                this.flowLevel === 1 &&\n                (line[0] === ']' || line[0] === '}');\n            if (!atFlowEndMarker) {\n                // this is an error\n                this.flowLevel = 0;\n                yield FLOW_END;\n                return yield* this.parseLineStart();\n            }\n        }\n        let n = 0;\n        while (line[n] === ',') {\n            n += yield* this.pushCount(1);\n            n += yield* this.pushSpaces(true);\n            this.flowKey = false;\n        }\n        n += yield* this.pushIndicators();\n        switch (line[n]) {\n            case undefined:\n                return 'flow';\n            case '#':\n                yield* this.pushCount(line.length - n);\n                return 'flow';\n            case '{':\n            case '[':\n                yield* this.pushCount(1);\n                this.flowKey = false;\n                this.flowLevel += 1;\n                return 'flow';\n            case '}':\n            case ']':\n                yield* this.pushCount(1);\n                this.flowKey = true;\n                this.flowLevel -= 1;\n                return this.flowLevel ? 'flow' : 'doc';\n            case '*':\n                yield* this.pushUntil(isNotAnchorChar);\n                return 'flow';\n            case '\"':\n            case \"'\":\n                this.flowKey = true;\n                return yield* this.parseQuotedScalar();\n            case ':': {\n                const next = this.charAt(1);\n                if (this.flowKey || isEmpty(next) || next === ',') {\n                    this.flowKey = false;\n                    yield* this.pushCount(1);\n                    yield* this.pushSpaces(true);\n                    return 'flow';\n                }\n            }\n            // fallthrough\n            default:\n                this.flowKey = false;\n                return yield* this.parsePlainScalar();\n        }\n    }\n    *parseQuotedScalar() {\n        const quote = this.charAt(0);\n        let end = this.buffer.indexOf(quote, this.pos + 1);\n        if (quote === \"'\") {\n            while (end !== -1 && this.buffer[end + 1] === \"'\")\n                end = this.buffer.indexOf(\"'\", end + 2);\n        }\n        else {\n            // double-quote\n            while (end !== -1) {\n                let n = 0;\n                while (this.buffer[end - 1 - n] === '\\\\')\n                    n += 1;\n                if (n % 2 === 0)\n                    break;\n                end = this.buffer.indexOf('\"', end + 1);\n            }\n        }\n        // Only looking for newlines within the quotes\n        const qb = this.buffer.substring(0, end);\n        let nl = qb.indexOf('\\n', this.pos);\n        if (nl !== -1) {\n            while (nl !== -1) {\n                const cs = this.continueScalar(nl + 1);\n                if (cs === -1)\n                    break;\n                nl = qb.indexOf('\\n', cs);\n            }\n            if (nl !== -1) {\n                // this is an error caused by an unexpected unindent\n                end = nl - (qb[nl - 1] === '\\r' ? 2 : 1);\n            }\n        }\n        if (end === -1) {\n            if (!this.atEnd)\n                return this.setNext('quoted-scalar');\n            end = this.buffer.length;\n        }\n        yield* this.pushToIndex(end + 1, false);\n        return this.flowLevel ? 'flow' : 'doc';\n    }\n    *parseBlockScalarHeader() {\n        this.blockScalarIndent = -1;\n        this.blockScalarKeep = false;\n        let i = this.pos;\n        while (true) {\n            const ch = this.buffer[++i];\n            if (ch === '+')\n                this.blockScalarKeep = true;\n            else if (ch > '0' && ch <= '9')\n                this.blockScalarIndent = Number(ch) - 1;\n            else if (ch !== '-')\n                break;\n        }\n        return yield* this.pushUntil(ch => isEmpty(ch) || ch === '#');\n    }\n    *parseBlockScalar() {\n        let nl = this.pos - 1; // may be -1 if this.pos === 0\n        let indent = 0;\n        let ch;\n        loop: for (let i = this.pos; (ch = this.buffer[i]); ++i) {\n            switch (ch) {\n                case ' ':\n                    indent += 1;\n                    break;\n                case '\\n':\n                    nl = i;\n                    indent = 0;\n                    break;\n                case '\\r': {\n                    const next = this.buffer[i + 1];\n                    if (!next && !this.atEnd)\n                        return this.setNext('block-scalar');\n                    if (next === '\\n')\n                        break;\n                } // fallthrough\n                default:\n                    break loop;\n            }\n        }\n        if (!ch && !this.atEnd)\n            return this.setNext('block-scalar');\n        if (indent >= this.indentNext) {\n            if (this.blockScalarIndent === -1)\n                this.indentNext = indent;\n            else {\n                this.indentNext =\n                    this.blockScalarIndent + (this.indentNext === 0 ? 1 : this.indentNext);\n            }\n            do {\n                const cs = this.continueScalar(nl + 1);\n                if (cs === -1)\n                    break;\n                nl = this.buffer.indexOf('\\n', cs);\n            } while (nl !== -1);\n            if (nl === -1) {\n                if (!this.atEnd)\n                    return this.setNext('block-scalar');\n                nl = this.buffer.length;\n            }\n        }\n        // Trailing insufficiently indented tabs are invalid.\n        // To catch that during parsing, we include them in the block scalar value.\n        let i = nl + 1;\n        ch = this.buffer[i];\n        while (ch === ' ')\n            ch = this.buffer[++i];\n        if (ch === '\\t') {\n            while (ch === '\\t' || ch === ' ' || ch === '\\r' || ch === '\\n')\n                ch = this.buffer[++i];\n            nl = i - 1;\n        }\n        else if (!this.blockScalarKeep) {\n            do {\n                let i = nl - 1;\n                let ch = this.buffer[i];\n                if (ch === '\\r')\n                    ch = this.buffer[--i];\n                const lastChar = i; // Drop the line if last char not more indented\n                while (ch === ' ')\n                    ch = this.buffer[--i];\n                if (ch === '\\n' && i >= this.pos && i + 1 + indent > lastChar)\n                    nl = i;\n                else\n                    break;\n            } while (true);\n        }\n        yield SCALAR;\n        yield* this.pushToIndex(nl + 1, true);\n        return yield* this.parseLineStart();\n    }\n    *parsePlainScalar() {\n        const inFlow = this.flowLevel > 0;\n        let end = this.pos - 1;\n        let i = this.pos - 1;\n        let ch;\n        while ((ch = this.buffer[++i])) {\n            if (ch === ':') {\n                const next = this.buffer[i + 1];\n                if (isEmpty(next) || (inFlow && flowIndicatorChars.has(next)))\n                    break;\n                end = i;\n            }\n            else if (isEmpty(ch)) {\n                let next = this.buffer[i + 1];\n                if (ch === '\\r') {\n                    if (next === '\\n') {\n                        i += 1;\n                        ch = '\\n';\n                        next = this.buffer[i + 1];\n                    }\n                    else\n                        end = i;\n                }\n                if (next === '#' || (inFlow && flowIndicatorChars.has(next)))\n                    break;\n                if (ch === '\\n') {\n                    const cs = this.continueScalar(i + 1);\n                    if (cs === -1)\n                        break;\n                    i = Math.max(i, cs - 2); // to advance, but still account for ' #'\n                }\n            }\n            else {\n                if (inFlow && flowIndicatorChars.has(ch))\n                    break;\n                end = i;\n            }\n        }\n        if (!ch && !this.atEnd)\n            return this.setNext('plain-scalar');\n        yield SCALAR;\n        yield* this.pushToIndex(end + 1, true);\n        return inFlow ? 'flow' : 'doc';\n    }\n    *pushCount(n) {\n        if (n > 0) {\n            yield this.buffer.substr(this.pos, n);\n            this.pos += n;\n            return n;\n        }\n        return 0;\n    }\n    *pushToIndex(i, allowEmpty) {\n        const s = this.buffer.slice(this.pos, i);\n        if (s) {\n            yield s;\n            this.pos += s.length;\n            return s.length;\n        }\n        else if (allowEmpty)\n            yield '';\n        return 0;\n    }\n    *pushIndicators() {\n        switch (this.charAt(0)) {\n            case '!':\n                return ((yield* this.pushTag()) +\n                    (yield* this.pushSpaces(true)) +\n                    (yield* this.pushIndicators()));\n            case '&':\n                return ((yield* this.pushUntil(isNotAnchorChar)) +\n                    (yield* this.pushSpaces(true)) +\n                    (yield* this.pushIndicators()));\n            case '-': // this is an error\n            case '?': // this is an error outside flow collections\n            case ':': {\n                const inFlow = this.flowLevel > 0;\n                const ch1 = this.charAt(1);\n                if (isEmpty(ch1) || (inFlow && flowIndicatorChars.has(ch1))) {\n                    if (!inFlow)\n                        this.indentNext = this.indentValue + 1;\n                    else if (this.flowKey)\n                        this.flowKey = false;\n                    return ((yield* this.pushCount(1)) +\n                        (yield* this.pushSpaces(true)) +\n                        (yield* this.pushIndicators()));\n                }\n            }\n        }\n        return 0;\n    }\n    *pushTag() {\n        if (this.charAt(1) === '<') {\n            let i = this.pos + 2;\n            let ch = this.buffer[i];\n            while (!isEmpty(ch) && ch !== '>')\n                ch = this.buffer[++i];\n            return yield* this.pushToIndex(ch === '>' ? i + 1 : i, false);\n        }\n        else {\n            let i = this.pos + 1;\n            let ch = this.buffer[i];\n            while (ch) {\n                if (tagChars.has(ch))\n                    ch = this.buffer[++i];\n                else if (ch === '%' &&\n                    hexDigits.has(this.buffer[i + 1]) &&\n                    hexDigits.has(this.buffer[i + 2])) {\n                    ch = this.buffer[(i += 3)];\n                }\n                else\n                    break;\n            }\n            return yield* this.pushToIndex(i, false);\n        }\n    }\n    *pushNewline() {\n        const ch = this.buffer[this.pos];\n        if (ch === '\\n')\n            return yield* this.pushCount(1);\n        else if (ch === '\\r' && this.charAt(1) === '\\n')\n            return yield* this.pushCount(2);\n        else\n            return 0;\n    }\n    *pushSpaces(allowTabs) {\n        let i = this.pos - 1;\n        let ch;\n        do {\n            ch = this.buffer[++i];\n        } while (ch === ' ' || (allowTabs && ch === '\\t'));\n        const n = i - this.pos;\n        if (n > 0) {\n            yield this.buffer.substr(this.pos, n);\n            this.pos = i;\n        }\n        return n;\n    }\n    *pushUntil(test) {\n        let i = this.pos;\n        let ch = this.buffer[i];\n        while (!test(ch))\n            ch = this.buffer[++i];\n        return yield* this.pushToIndex(i, false);\n    }\n}\n\nexport { Lexer };\n","import * as TSU from \"@panyam/tsutils\";\nimport { ZERO, Atom, LeafAtom, Group } from \"./core\";\n\n/**\n * Base class for all renderable objects.\n *\n * Shape caches properties like bounding boxes to improve performance,\n * since bounding box calculations can be expensive. This also allows\n * testing layouts and positioning without worrying about implementation details.\n */\nexport abstract class Shape {\n  private static idCounter = 0;\n  readonly shapeId: number = Shape.idCounter++;\n\n  /**\n   * Note that x and y coordinates are not always the x and y coordinates\n   * of the bounding box.\n   * E.g., a circle's x and y coordinates are its center point and not the\n   * top left corner.\n   * These \"main\" coordinates are referred to as control coordinates.\n   */\n  protected _x: number | null = null;\n  protected _y: number | null = null;\n  protected _width: number | null = null;\n  protected _height: number | null = null;\n  protected _bbox: TSU.Geom.Rect;\n  protected _minSize: TSU.Geom.Size;\n  protected parentShape: Shape | null = null;\n  /** Child shapes contained within this shape */\n  children: Shape[] = [];\n\n  /**\n   * Gets the bounding box of this shape.\n   * Calculates it if it hasn't been calculated yet.\n   */\n  get bbox(): TSU.Geom.Rect {\n    if (!this._bbox) {\n      this._bbox = this.refreshBBox();\n    }\n    return this._bbox;\n  }\n\n  /**\n   * Gets the minimum size of this shape.\n   * This is usually the size of the bounding box.\n   */\n  get minSize(): TSU.Geom.Size {\n    if (!this._minSize) {\n      this._minSize = this.refreshMinSize();\n    }\n    return this._minSize;\n  }\n\n  /**\n   * Refreshes the bounding box of this shape.\n   * Called when the shape knows the bbox it is tracking cannot be trusted\n   * and has to be refreshed by calling native methods.\n   * @returns The refreshed bounding box\n   */\n  protected abstract refreshBBox(): TSU.Geom.Rect;\n\n  /**\n   * Refreshes the minimum size of this shape.\n   * @returns The refreshed minimum size\n   */\n  protected abstract refreshMinSize(): TSU.Geom.Size;\n\n  /**\n   * Updates the bounds of this shape.\n   * @param x New x coordinate, or null to keep current value\n   * @param y New y coordinate, or null to keep current value\n   * @param w New width, or null to keep current value\n   * @param h New height, or null to keep current value\n   * @returns The updated bounds values\n   */\n  protected abstract updateBounds(\n    x: null | number,\n    y: null | number,\n    w: null | number,\n    h: null | number,\n  ): [number | null, number | null, number | null, number | null];\n\n  /**\n   * Invalidates the cached bounds of this shape.\n   * Forces recalculation of bounding box and minimum size.\n   */\n  invalidateBounds(): void {\n    this._minSize = null as unknown as TSU.Geom.Size;\n    this._bbox = null as unknown as TSU.Geom.Rect;\n  }\n\n  /**\n   * Sets the bounds of this shape.\n   *\n   * Note that null and NaN are valid values and mean the following:\n   * - null: Don't change the value\n   * - NaN: Set the value to null (use the bounding box's value)\n   *\n   * @param x New x coordinate, or null to keep current value\n   * @param y New y coordinate, or null to keep current value\n   * @param w New width, or null to keep current value\n   * @param h New height, or null to keep current value\n   * @param applyLayout Whether to apply layout immediately\n   * @returns The updated bounds values\n   */\n  setBounds(\n    x: number | null,\n    y: number | null,\n    w: number | null,\n    h: number | null,\n    applyLayout = false,\n  ): [number | null, number | null, number | null, number | null] {\n    if (x != null) {\n      if (isNaN(x)) {\n        this._x = null;\n      } else {\n        this._x = x;\n      }\n    }\n    if (y != null) {\n      if (isNaN(y)) {\n        this._y = null;\n      } else {\n        this._y = y;\n      }\n    }\n    if (w != null) {\n      if (isNaN(w)) {\n        this._width = null;\n      } else {\n        this._width = w;\n      }\n    }\n    if (h != null) {\n      if (isNaN(h)) {\n        this._height = null;\n      } else {\n        this._height = h;\n      }\n    }\n    const [nx, ny, nw, nh] = this.updateBounds(x, y, w, h);\n    if (nx != null) {\n      if (isNaN(nx)) {\n        this._x = null;\n      } else {\n        this._x = nx;\n      }\n    }\n    if (ny != null) {\n      if (isNaN(ny)) {\n        this._y = null;\n      } else {\n        this._y = ny;\n      }\n    }\n    if (nw != null) {\n      if (isNaN(nw)) {\n        this._width = null;\n      } else {\n        this._width = nw;\n      }\n    }\n    if (nh != null) {\n      if (isNaN(nh)) {\n        this._height = null;\n      } else {\n        this._height = nh;\n      }\n    }\n    if (applyLayout) this.refreshLayout();\n    // this.resetBBox();\n    return [nx, ny, nw, nh];\n  }\n\n  /**\n   * Checks if this shape has an explicit x coordinate.\n   */\n  get hasX(): boolean {\n    return this._x != null && !isNaN(this._x);\n  }\n\n  /**\n   * Checks if this shape has an explicit y coordinate.\n   */\n  get hasY(): boolean {\n    return this._y != null && !isNaN(this._y);\n  }\n\n  /**\n   * Checks if this shape has an explicit width.\n   */\n  get hasWidth(): boolean {\n    return this._width != null && !isNaN(this._width);\n  }\n\n  /**\n   * Checks if this shape has an explicit height.\n   */\n  get hasHeight(): boolean {\n    return this._height != null && !isNaN(this._height);\n  }\n\n  /**\n   * Gets the x coordinate within the parent's coordinate system.\n   */\n  get x(): number {\n    return this._x || 0;\n  }\n\n  /**\n   * Sets the x coordinate within the parent's coordinate system.\n   */\n  set x(x: number | null) {\n    // Here a manual x is being set - how does this interfere with the bounding box?\n    // We should _x to the new value to indicate a manual value was set.\n    // and reset bbox so that based on this x a new bbox may need to be calculated\n    this.setBounds(x == null ? NaN : x, null, null, null);\n  }\n\n  /**\n   * Gets the y coordinate within the parent's coordinate system.\n   */\n  get y(): number {\n    if (this._y != null) return this._y;\n    return 0; // this.bbox.y;\n  }\n\n  /**\n   * Sets the y coordinate within the parent's coordinate system.\n   */\n  set y(y: number | null) {\n    this.setBounds(null, y == null ? NaN : y, null, null);\n  }\n\n  /**\n   * Gets the width of this shape.\n   */\n  get width(): number {\n    if (this._width != null) return this._width;\n    return 0; // this.bbox.width;\n  }\n\n  /**\n   * Sets the width of this shape.\n   */\n  set width(w: number | null) {\n    this.setBounds(null, null, w == null ? NaN : w, null);\n  }\n\n  /**\n   * Gets the height of this shape.\n   */\n  get height(): number {\n    if (this._height != null) return this._height;\n    return 0; // this.bbox.height;\n  }\n\n  /**\n   * Sets the height of this shape.\n   */\n  set height(h: number | null) {\n    this.setBounds(null, null, null, h == null ? NaN : h);\n  }\n\n  /**\n   * Refreshes the layout of this shape.\n   * Called when bounds or other properties have changed to give the shape an\n   * opportunity to layout its children. For shapes with no children this is a no-op.\n   */\n  refreshLayout(): void {\n    // throw new Error(\"Implement this\");\n  }\n}\n\n/**\n * Represents an embellishment applied to a musical element.\n */\nexport abstract class Embelishment extends Shape {}\n\n/**\n * A shape that wraps an SVG element.\n * ElementShape provides the base class for all shapes that are rendered as SVG elements.\n */\nexport class ElementShape<T extends SVGGraphicsElement = SVGGraphicsElement> extends Shape {\n  /**\n   * Creates a new ElementShape.\n   * @param element The SVG element this shape wraps\n   */\n  constructor(public readonly element: T) {\n    super();\n  }\n\n  /**\n   * Refreshes the bounding box of this element.\n   * @returns The refreshed bounding box\n   */\n  protected refreshBBox(): TSU.Geom.Rect {\n    return TSU.DOM.svgBBox(this.element);\n  }\n\n  /**\n   * Refreshes the minimum size of this element.\n   * @returns The refreshed minimum size\n   */\n  protected refreshMinSize(): TSU.Geom.Size {\n    return TSU.DOM.svgBBox(this.element);\n  }\n\n  /**\n   * Updates the bounds of this element.\n   * @param x New x coordinate, or null to keep current value\n   * @param y New y coordinate, or null to keep current value\n   * @param w New width, or null to keep current value\n   * @param h New height, or null to keep current value\n   * @returns The updated bounds values\n   */\n  protected updateBounds(\n    x: null | number,\n    y: null | number,\n    w: null | number,\n    h: null | number,\n  ): [number | null, number | null, number | null, number | null] {\n    return [x, y, w, h];\n  }\n\n  /**\n   * Refreshes the layout of this element.\n   * Updates the element's attributes based on the shape's properties.\n   */\n  refreshLayout(): void {\n    if (this.hasX) this.element.setAttribute(\"x\", \"\" + this._x);\n    if (this.hasY) this.element.setAttribute(\"y\", \"\" + this._y);\n  }\n}\n\n/**\n * Base class for views that represent atoms in the notation.\n * AtomView provides the visual representation of an atom.\n */\nexport abstract class AtomView extends Shape {\n  /** Nesting depth of this atom in the structure */\n  depth = 0;\n  /** Index of the role containing this atom */\n  roleIndex = 0;\n\n  // LayoutMetrics for the AtomView so all atomviews laid out on the\n  // same baseline will show up aligned vertically\n  /** Baseline position for vertical alignment */\n  baseline: number;\n  /** Ascent (space above baseline) */\n  ascent: number;\n  /** Descent (space below baseline) */\n  descent: number;\n  /** Height of capital letters */\n  capHeight: number;\n  /** Space between lines */\n  leading: number;\n\n  /**\n   * Checks if this atom view represents a leaf atom.\n   */\n  abstract isLeaf(): boolean;\n\n  abstract get totalDuration(): TSU.Num.Fraction;\n\n  /**\n   * Returns the horizontal offset from the atom's origin to where the note glyph starts.\n   * This accounts for left embellishments that appear before the note.\n   * Used by GroupView to align note glyphs at their correct time positions.\n   *\n   * Default is 0 (glyph starts at origin). Subclasses with left embellishments\n   * should override to return the width of left-side decorations.\n   */\n  get glyphOffset(): number {\n    return 0;\n  }\n\n  /**\n   * Creates the SVG elements needed for this atom view.\n   * @param parent The parent SVG element to attach to\n   */\n  abstract createElements(parent: SVGGraphicsElement): void;\n}\n\n/**\n * A view for leaf atoms (those that cannot contain other atoms).\n */\nexport abstract class LeafAtomView extends AtomView {\n  /**\n   * Creates a new LeafAtomView.\n   * @param leafAtom The leaf atom this view represents\n   */\n  constructor(public leafAtom: LeafAtom) {\n    super();\n  }\n\n  /**\n   * Leaf atom views always return true for isLeaf().\n   */\n  isLeaf(): boolean {\n    return true;\n  }\n\n  /**\n   * Gets a unique identifier for this view based on the atom's UUID.\n   */\n  get viewId(): number {\n    return this.leafAtom.uuid;\n  }\n\n  /**\n   * Returns the total duration of the atom rendered by this view.\n   */\n  get totalDuration(): TSU.Num.Fraction {\n    return this.leafAtom.duration;\n  }\n}\n\n/**\n * A view for group atoms that contain multiple child atoms.\n */\nexport abstract class GroupView extends AtomView {\n  /** Space between atoms in this group */\n  protected atomSpacing: number;\n  /** The SVG group element for this view */\n  protected groupElement: SVGGElement;\n  /** Views for the atoms in this group */\n  protected atomViews: AtomView[] = [];\n  private _embelishments: Embelishment[];\n  /** Whether this group represents notes by default */\n  defaultToNotes = true;\n  /** Whether this view needs layout */\n  needsLayout = true;\n  /** Scale factor for this group */\n  scaleFactor = 1.0;\n  /**\n   * When true, shows continuation markers (\",\") for atoms with duration > 1\n   * instead of just leaving empty space.\n   */\n  showContinuationMarkers = true;\n  /** SVG elements for continuation markers */\n  protected continuationMarkerElements: SVGTextElement[] = [];\n\n  /**\n   * Creates a new GroupView.\n   * @param group The group atom this view represents\n   * @param config Optional configuration object\n   */\n  constructor(\n    public group: Group,\n    config?: any,\n  ) {\n    super();\n    this.atomSpacing = 5;\n    this.setStyles(config || {});\n  }\n\n  /**\n   * Returns the total duration of the group rendered by this view.\n   */\n  get totalDuration(): TSU.Num.Fraction {\n    return this.group.totalChildDuration;\n  }\n\n  /**\n   * Creates the SVG elements needed for this group view.\n   * @param parent The parent SVG element to attach to\n   */\n  createElements(parent: SVGGraphicsElement): void {\n    this.groupElement = TSU.DOM.createSVGNode(\"g\", {\n      parent: parent,\n      attrs: {\n        class: \"groupViewRoot\",\n        id: \"groupViewRoot\" + this.group.uuid,\n      },\n    });\n\n    // now create child atom views for each atom in this Group\n    for (const atom of this.group.atoms.values()) {\n      const atomView = this.createAtomView(atom);\n      this.atomViews.push(atomView);\n    }\n    this.invalidateBounds();\n  }\n\n  /**\n   * Group views always return false for isLeaf().\n   */\n  isLeaf(): boolean {\n    return false;\n  }\n\n  /**\n   * Refreshes the bounding box of this group.\n   * @returns The refreshed bounding box\n   */\n  protected refreshBBox(): TSU.Geom.Rect {\n    return TSU.DOM.svgBBox(this.groupElement);\n  }\n\n  /**\n   * Refreshes the minimum size of this group using duration-based width calculation.\n   *\n   * ## Duration-Based Width Algorithm\n   *\n   * This algorithm ensures atoms with extended durations receive proportionally\n   * more horizontal space. For example, with `\\beatDuration(4)` and input `S 2 R G M`:\n   * - S has duration 1, R has duration 2, G has duration 1\n   * - R should visually occupy twice the horizontal space of S or G\n   *\n   * ### Algorithm Steps:\n   *\n   * 1. **Calculate width per duration unit**: For each atom, compute the visual width\n   *    needed per unit of duration: `(visualWidth + spacing) / duration`\n   *\n   * 2. **Find maximum**: Take the maximum width-per-duration across all atoms.\n   *    This ensures every atom has enough space for its visual content.\n   *\n   * 3. **Scale by total duration**: Multiply the max width-per-duration by the\n   *    group's total duration to get the final group width.\n   *\n   * ### Example:\n   * ```\n   * Atoms: S(dur=1, width=10px), R(dur=2, width=10px), G(dur=1, width=10px)\n   * Spacing: 5px\n   *\n   * Width per duration:\n   *   S: (10 + 5) / 1 = 15 px/unit\n   *   R: (10 + 5) / 2 = 7.5 px/unit\n   *   G: (10 + 5) / 1 = 15 px/unit\n   *\n   * Max width per duration: 15 px/unit\n   * Total duration: 1 + 2 + 1 = 4 units\n   * Group width: 15 * 4 = 60px\n   *\n   * Positioning:\n   *   S at x=0 (time 0/4 * 60 = 0)\n   *   R at x=15 (time 1/4 * 60 = 15)\n   *   G at x=45 (time 3/4 * 60 = 45)\n   * ```\n   *\n   * @returns The refreshed minimum size\n   */\n  protected refreshMinSize(): TSU.Geom.Size {\n    let maxHeight = 0;\n\n    // Step 1: Calculate width per duration unit for each atom\n    let minWidthPerDuration = 0;\n    this.atomViews.forEach((av) => {\n      const ms = av.minSize;\n      const dur = av.totalDuration;\n      if (!dur.isZero) {\n        const durValue = dur.num / dur.den;\n        const widthPerDur = (ms.width + this.atomSpacing) / durValue;\n        // Step 2: Track maximum width per duration\n        minWidthPerDuration = Math.max(minWidthPerDuration, widthPerDur);\n      }\n      maxHeight = Math.max(maxHeight, ms.height);\n    });\n\n    // Step 3: Scale by total duration\n    const totalDuration = this.group.totalChildDuration;\n    const totalDurValue = totalDuration.num / totalDuration.den;\n    const totalWidth = minWidthPerDuration * totalDurValue;\n\n    return new TSU.Geom.Size(totalWidth * this.scaleFactor, maxHeight * this.scaleFactor);\n  }\n\n  /**\n   * Creates an atom view for a specific atom.\n   * @param atom The atom to create a view for\n   * @returns The created atom view\n   */\n  abstract createAtomView(atom: Atom): AtomView;\n\n  /**\n   * Updates the bounds of this group.\n   * @param x New x coordinate, or null to keep current value\n   * @param y New y coordinate, or null to keep current value\n   * @param w New width, or null to keep current value\n   * @param h New height, or null to keep current value\n   * @returns The updated bounds values\n   */\n  protected updateBounds(\n    x: null | number,\n    y: null | number,\n    w: null | number,\n    h: null | number,\n  ): [number | null, number | null, number | null, number | null] {\n    return [x, y, w, h];\n  }\n\n  /**\n   * Refreshes the layout of this group using duration-based positioning.\n   *\n   * ## Duration-Based Positioning Algorithm\n   *\n   * Atoms are positioned at x-coordinates proportional to their time offset\n   * within the group's total duration. This ensures that atoms with extended\n   * durations visually occupy the correct amount of horizontal space.\n   *\n   * ### Width Source Priority:\n   *\n   * 1. **Column width** (preferred): If width was set via `setBounds()` from the\n   *    grid layout system (ColAlign), use that width. This enables global alignment\n   *    across all beats in the same column.\n   *\n   * 2. **Minimum size**: Fall back to `minSize.width` calculated by `refreshMinSize()`.\n   *\n   * ### Positioning Formula:\n   * ```\n   * xPosition = (timeOffset / totalDuration) * groupWidth\n   * ```\n   *\n   * ### Continuation Markers:\n   *\n   * When `showContinuationMarkers` is true (default), atoms with duration > 1\n   * will have \",\" markers rendered at each additional time slot. For example,\n   * an atom with duration 2 will show \"R ,\" instead of \"R   \".\n   *\n   * This helps users visually understand that the note continues through\n   * multiple time slots without relying on empty space alone.\n   *\n   * ### Example:\n   * ```\n   * Input: S 2 R G (with beatDuration=4)\n   * Group width: 60px, Total duration: 4 units\n   *\n   * Positioning:\n   *   S at x=0   (time 0, offset 0/4 * 60 = 0)\n   *   R at x=15  (time 1, offset 1/4 * 60 = 15)\n   *   \",\" at x=30 (continuation marker for R at time 2)\n   *   G at x=45  (time 3, offset 3/4 * 60 = 45)\n   * ```\n   */\n  refreshLayout(): void {\n    let transform = \"translate(\" + this.x + \",\" + this.y + \")\";\n    if (this.scaleFactor < 1) {\n      transform += \" scale(\" + this.scaleFactor + \")\";\n    }\n    this.groupElement.setAttribute(\"transform\", transform);\n\n    const currY = 0;\n    const totalDur = this.group.totalChildDuration;\n\n    // Width source priority: column width (for global alignment) > minSize\n    const unscaledMinWidth = this.minSize.width / this.scaleFactor;\n    const groupWidth = this.hasWidth ? this.width / this.scaleFactor : unscaledMinWidth;\n\n    // Clear existing continuation markers before re-rendering\n    this.clearContinuationMarkers();\n\n    // Position each atom based on its time offset\n    let currTime = ZERO;\n    this.atomViews.forEach((av, index) => {\n      // Calculate where the NOTE GLYPH should appear based on time offset\n      const glyphX = totalDur.isZero ? 0 : currTime.timesNum(groupWidth).divby(totalDur).floor;\n      // Subtract glyphOffset so left embellishments don't push the glyph past its time position\n      // The atom origin is placed earlier, so the glyph ends up at the correct time position\n      const xPos = Math.max(0, glyphX - av.glyphOffset);\n      av.setBounds(xPos, currY, null, null, true);\n\n      // Render continuation markers for atoms with duration > 1\n      if (this.showContinuationMarkers && !totalDur.isZero) {\n        const atomDur = av.totalDuration;\n        const durValue = atomDur.num / atomDur.den;\n        if (durValue > 1) {\n          // Render one marker at each additional time slot within the atom's duration\n          const numMarkers = Math.floor(durValue) - 1;\n          for (let i = 1; i <= numMarkers; i++) {\n            // Marker time = currTime + (atomDuration * i / floor(duration))\n            const markerTime = currTime.plus(atomDur.timesNum(i).divbyNum(Math.floor(durValue)));\n            const markerX = markerTime.timesNum(groupWidth).divby(totalDur).floor;\n            this.renderContinuationMarker(markerX, currY);\n          }\n        }\n      }\n\n      currTime = currTime.plus(av.totalDuration);\n    });\n\n    this.invalidateBounds();\n    for (const e of this.embelishments) e.refreshLayout();\n    this.invalidateBounds();\n  }\n\n  /**\n   * Clears all continuation marker elements.\n   */\n  protected clearContinuationMarkers(): void {\n    for (const el of this.continuationMarkerElements) {\n      el.remove();\n    }\n    this.continuationMarkerElements = [];\n  }\n\n  /**\n   * Renders a continuation marker (\",\") at the specified position.\n   * @param x X position for the marker\n   * @param y Y position for the marker\n   */\n  protected renderContinuationMarker(x: number, y: number): void {\n    const marker = TSU.DOM.createSVGNode(\"text\", {\n      parent: this.groupElement,\n      attrs: {\n        class: \"continuationMarker\",\n        x: x.toString(),\n        y: y.toString(),\n      },\n      text: \",\",\n    }) as SVGTextElement;\n    this.continuationMarkerElements.push(marker);\n  }\n\n  /**\n   * Gets the embellishments for this group.\n   */\n  get embelishments(): Embelishment[] {\n    if (!this._embelishments) {\n      this._embelishments = this.createEmbelishments();\n    }\n    return this._embelishments;\n  }\n\n  /**\n   * Creates the embellishments for this group.\n   * @returns An array of embellishments\n   */\n  protected createEmbelishments(): Embelishment[] {\n    return [];\n  }\n\n  /**\n   * Sets the styles for this group.\n   * @param config Style configuration object\n   */\n  setStyles(config: any): void {\n    if (\"atomSpacing\" in config) this.atomSpacing = config.atomSpacing;\n    if (\"showContinuationMarkers\" in config) this.showContinuationMarkers = config.showContinuationMarkers;\n    this.needsLayout = true;\n  }\n}\n","import * as TLEX from \"tlex\";\nimport { load as loadGrammar } from \"./dsl\";\nimport { makeParseTable } from \"./ptables\";\nimport { Parser, ParseTable } from \"./lr\";\nimport { LRItemGraph } from \"./lritems\";\nimport { logParserDebug } from \"./debug\";\n\n/**\n * Helper to create a grammar, and its parser.\n */\nexport function newLRParser(input: string, params: any = null): [Parser, null | TLEX.NextTokenFunc, LRItemGraph] {\n  const [ptable, tokenFunc, itemGraph] = newParseTable(input, params);\n  const parser = new Parser(ptable);\n  if (params.tokenizer || tokenFunc) {\n    parser.setTokenizer(params.tokenizer || tokenFunc);\n  }\n  const debug = params.debug || \"\";\n  if (debug.split(\"|\").findIndex((p: string) => p == \"all\" || p == \"parser\") >= 0) {\n    logParserDebug(parser, itemGraph);\n  }\n  return [parser, tokenFunc, itemGraph];\n}\n\nexport function newParseTable(input: string, params: any = null): [ParseTable, null | TLEX.NextTokenFunc, LRItemGraph] {\n  params = params || {};\n  const [g, tokenFunc] = loadGrammar(input, params);\n  g.augmentStartSymbol();\n  const [ptable, itemGraph] = makeParseTable(g, params.type);\n  return [ptable, tokenFunc, itemGraph];\n}\n","import { Parser, LRAction, ParseTable } from \"./lr\";\nimport { LRItemGraph } from \"./lritems\";\n\nexport function logParserDebug(parser: Parser, itemGraph?: LRItemGraph): void {\n  const g = parser.grammar;\n  const ptable = parser.parseTable;\n  console.log(\n    \"===============================\\nGrammar (as default): \\n\",\n    g.debugValue.map((x, i) => `${i + 1}  -   ${x}`),\n    \"===============================\\nGrammar (as Bison): \\n\",\n    g.debugValue.map((x, i) => `${x.replace(\"->\", \":\")} ; \\n`).join(\"\"),\n    \"===============================\\nParseTable: \\n\",\n    JSON.stringify(mergedDebugValue(ptable, itemGraph), null, 4),\n    \"===============================\\nConflicts: \\n\",\n    ptable.conflictActions,\n  );\n}\n\nexport function mergedDebugValue(ptable: ParseTable, itemGraph?: LRItemGraph): any {\n  const merged = {} as any;\n  const ptabDV = ptable.debugValue;\n  const igDV = itemGraph?.debugValue;\n  for (const stateId in ptabDV) {\n    const actions = ptabDV[stateId];\n    if (itemGraph) {\n      const items = igDV[stateId];\n      merged[stateId] = { items: items[\"items\"], actions: actions, goto: items[\"goto\"] };\n    } else {\n      merged[stateId] = actions;\n    }\n  }\n  return merged;\n}\n"],"names":["root","factory","exports","module","define","amd","this","read","buffer","offset","isLE","mLen","nBytes","e","m","eLen","eMax","eBias","nBits","i","d","s","NaN","Infinity","Math","pow","write","value","c","rt","abs","isNaN","floor","log","LN2","bind","fn","thisArg","apply","arguments","toString","Object","prototype","getPrototypeOf","iterator","toStringTag","Symbol","kindOf","cache","create","thing","str","call","slice","toLowerCase","kindOfTest","type","typeOfTest","isArray","Array","isUndefined","isBuffer","val","constructor","isFunction$1","isArrayBuffer","isString","isNumber","isObject","isPlainObject","isDate","isFile","isBlob","isFileList","isURLSearchParams","isReadableStream","isRequest","isResponse","isHeaders","map","forEach","obj","allOwnKeys","l","length","keys","getOwnPropertyNames","len","key","findKey","_key","_global","globalThis","self","window","global","isContextDefined","context","isTypedArray","TypedArray","Uint8Array","isHTMLForm","hasOwnProperty","prop","isRegExp","reduceDescriptors","reducer","descriptors","getOwnPropertyDescriptors","reducedDescriptors","descriptor","name","ret","defineProperties","isAsyncFn","_setImmediate","setImmediateSupported","setImmediate","postMessageSupported","postMessage","token","random","callbacks","addEventListener","source","data","shift","cb","push","setTimeout","asap","queueMicrotask","process","nextTick","utils$1","isFormData","kind","FormData","append","isArrayBufferView","result","ArrayBuffer","isView","isBoolean","isEmptyObject","isFunction","isStream","pipe","merge","caseless","skipUndefined","assignValue","targetKey","extend","a","b","trim","replace","stripBOM","content","charCodeAt","inherits","superConstructor","props","defineProperty","assign","toFlatObject","sourceObj","destObj","filter","propFilter","merged","endsWith","searchString","position","String","undefined","lastIndex","indexOf","toArray","arr","forEachEntry","_iterator","next","done","pair","matchAll","regExp","matches","exec","hasOwnProp","freezeMethods","enumerable","writable","set","Error","toObjectSet","arrayOrString","delimiter","split","toCamelCase","p1","p2","toUpperCase","noop","toFiniteNumber","defaultValue","Number","isFinite","isSpecCompliantForm","toJSONObject","stack","visit","target","reducedValue","isThenable","then","catch","isIterable","AxiosError","message","code","config","request","response","captureStackTrace","status","toJSON","description","number","fileName","lineNumber","columnNumber","prototype$1","isVisitable","removeBrackets","renderKey","path","dots","concat","join","from","error","customProps","axiosError","msg","errCode","cause","configurable","predicates","test","toFormData","formData","options","TypeError","metaTokens","indexes","option","visitor","defaultVisitor","useBlob","Blob","convertValue","toISOString","Buffer","JSON","stringify","some","isFlatArray","el","index","exposedHelpers","build","pop","encode$1","charMap","encodeURIComponent","match","AxiosURLSearchParams","params","_pairs","encode","buildURL","url","_encode","serialize","serializeFn","serializedParams","hashmarkIndex","encoder","InterceptorManager$1","handlers","use","fulfilled","rejected","synchronous","runWhen","eject","id","clear","h","transitionalDefaults","silentJSONParsing","forcedJSONParsing","clarifyTimeoutError","platform$1","isBrowser","classes","URLSearchParams","protocols","hasBrowserEnv","document","_navigator","navigator","hasStandardBrowserEnv","product","hasStandardBrowserWebWorkerEnv","WorkerGlobalScope","importScripts","origin","location","href","platform","formDataToJSON","buildPath","isNumericKey","isLast","arrayToObject","entries","parsePropPath","defaults","transitional","adapter","transformRequest","headers","contentType","getContentType","hasJSONContentType","isObjectPayload","setContentType","helpers","isNode","toURLEncodedForm","formSerializer","_FormData","env","rawValue","parse","stringifySafely","transformResponse","JSONRequested","responseType","strictJSONParsing","parseReviver","ERR_BAD_RESPONSE","timeout","xsrfCookieName","xsrfHeaderName","maxContentLength","maxBodyLength","validateStatus","common","method","defaults$1","ignoreDuplicateOf","$internals","normalizeHeader","header","normalizeValue","matchHeaderValue","isHeaderNameFilter","AxiosHeaders","valueOrRewrite","rewrite","setHeader","_value","_header","_rewrite","lHeader","setHeaders","rawHeaders","parsed","line","substring","parseHeaders","dest","entry","get","parser","tokens","tokensRE","parseTokens","has","matcher","delete","deleted","deleteHeader","normalize","format","normalized","w","char","formatHeader","targets","asStrings","getSetCookie","first","computed","accessor","accessors","defineAccessor","accessorName","methodName","arg1","arg2","arg3","buildAccessors","mapped","headerValue","AxiosHeaders$1","transformData","fns","isCancel","__CANCEL__","CanceledError","ERR_CANCELED","settle","resolve","reject","ERR_BAD_REQUEST","progressEventReducer","listener","isDownloadStream","freq","bytesNotified","_speedometer","samplesCount","min","bytes","timestamps","firstSampleTS","head","tail","chunkLength","now","Date","startedAt","bytesCount","passed","round","speedometer","lastArgs","timer","timestamp","threshold","invoke","args","clearTimeout","loaded","total","lengthComputable","progressBytes","rate","progress","estimated","event","throttled","flush","throttle","progressEventDecorator","asyncDecorator","isURLSameOrigin","isMSIE","URL","protocol","host","port","userAgent","cookies","expires","domain","secure","sameSite","cookie","toUTCString","RegExp","decodeURIComponent","remove","buildFullPath","baseURL","requestedURL","allowAbsoluteUrls","isRelativeUrl","relativeURL","combineURLs","headersToObject","mergeConfig","config1","config2","getMergedValue","mergeDeepProperties","valueFromConfig2","defaultToConfig2","mergeDirectKeys","mergeMap","paramsSerializer","timeoutMessage","withCredentials","withXSRFToken","onUploadProgress","onDownloadProgress","decompress","beforeRedirect","transport","httpAgent","httpsAgent","cancelToken","socketPath","responseEncoding","configValue","resolveConfig","newConfig","auth","btoa","username","password","unescape","getHeaders","formHeaders","allowedHeaders","includes","xsrfValue","xhrAdapter","XMLHttpRequest","Promise","_config","requestData","requestHeaders","onCanceled","uploadThrottled","downloadThrottled","flushUpload","flushDownload","unsubscribe","signal","removeEventListener","onloadend","responseHeaders","getAllResponseHeaders","err","responseText","statusText","open","onreadystatechange","readyState","responseURL","onabort","ECONNABORTED","onerror","ERR_NETWORK","ontimeout","timeoutErrorMessage","ETIMEDOUT","setRequestHeader","upload","cancel","abort","subscribe","aborted","parseProtocol","send","composeSignals$1","composeSignals","signals","Boolean","controller","AbortController","reason","streamChunk","chunk","chunkSize","byteLength","end","pos","trackStream","stream","onProgress","onFinish","async","iterable","asyncIterator","reader","getReader","readStream","readBytes","_onFinish","ReadableStream","pull","close","loadedBytes","enqueue","return","highWaterMark","globalFetchAPI","Request","Response","ReadableStream$1","TextEncoder","fetch","envFetch","isFetchSupported","isRequestSupported","isResponseSupported","isReadableStreamSupported","encodeText","arrayBuffer","supportsRequestStream","duplexAccessed","hasContentType","body","duplex","supportsResponseStream","resolvers","res","ERR_NOT_SUPPORT","fetchOptions","_fetch","composedSignal","toAbortSignal","requestContentLength","getContentLength","size","_request","getBodyLength","resolveBodyLength","contentTypeHeader","isCredentialsSupported","resolvedOptions","credentials","isStreamResponse","responseContentLength","responseData","seedCache","Map","getFetch","seeds","seed","knownAdapters","http","xhr","renderReason","isResolvedHandle","adapters","nameOrAdapter","rejectedReasons","reasons","state","throwIfCancellationRequested","throwIfRequested","dispatchRequest","VERSION","validators$1","deprecatedWarnings","validator","version","formatMessage","opt","desc","opts","ERR_DEPRECATED","console","warn","spelling","correctSpelling","assertOptions","schema","allowUnknown","ERR_BAD_OPTION_VALUE","ERR_BAD_OPTION","validators","Axios","instanceConfig","interceptors","configOrUrl","dummy","boolean","function","baseUrl","withXsrfToken","contextHeaders","requestInterceptorChain","synchronousRequestInterceptors","interceptor","unshift","responseInterceptorChain","promise","chain","onFulfilled","onRejected","getUri","generateHTTPMethod","isForm","Axios$1","CancelToken","executor","resolvePromise","_listeners","onfulfilled","_resolve","splice","CancelToken$1","HttpStatusCode","Continue","SwitchingProtocols","Processing","EarlyHints","Ok","Created","Accepted","NonAuthoritativeInformation","NoContent","ResetContent","PartialContent","MultiStatus","AlreadyReported","ImUsed","MultipleChoices","MovedPermanently","Found","SeeOther","NotModified","UseProxy","Unused","TemporaryRedirect","PermanentRedirect","BadRequest","Unauthorized","PaymentRequired","Forbidden","NotFound","MethodNotAllowed","NotAcceptable","ProxyAuthenticationRequired","RequestTimeout","Conflict","Gone","LengthRequired","PreconditionFailed","PayloadTooLarge","UriTooLong","UnsupportedMediaType","RangeNotSatisfiable","ExpectationFailed","ImATeapot","MisdirectedRequest","UnprocessableEntity","Locked","FailedDependency","TooEarly","UpgradeRequired","PreconditionRequired","TooManyRequests","RequestHeaderFieldsTooLarge","UnavailableForLegalReasons","InternalServerError","NotImplemented","BadGateway","ServiceUnavailable","GatewayTimeout","HttpVersionNotSupported","VariantAlsoNegotiates","InsufficientStorage","LoopDetected","NotExtended","NetworkAuthenticationRequired","WebServerIsDown","ConnectionTimedOut","OriginIsUnreachable","TimeoutOccurred","SslHandshakeFailed","InvalidSslCertificate","HttpStatusCode$1","axios","createInstance","defaultConfig","instance","Cancel","all","promises","spread","callback","isAxiosError","payload","formToJSON","getAdapter","default","base64","require","ieee754","K_MAX_LENGTH","createBuffer","RangeError","buf","__proto__","arg","encodingOrOffset","allocUnsafe","string","encoding","isEncoding","actual","fromString","fromArrayLike","isInstance","array","byteOffset","fromArrayBuffer","valueOf","checked","copy","numberIsNaN","fromObject","toPrimitive","assertSize","mustMatch","loweredCase","utf8ToBytes","base64ToBytes","slowToString","start","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","n","bidirectionalIndexOf","dir","arrayIndexOf","lastIndexOf","indexSize","arrLength","valLength","readUInt16BE","foundIndex","found","j","hexWrite","remaining","strLen","parseInt","substr","utf8Write","blitBuffer","asciiWrite","byteArray","asciiToBytes","latin1Write","base64Write","ucs2Write","units","hi","lo","utf16leToBytes","fromByteArray","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","codePoint","bytesPerSequence","codePoints","MAX_ARGUMENTS_LENGTH","fromCharCode","decodeCodePointsArray","TYPED_ARRAY_SUPPORT","foo","typedArraySupport","species","poolSize","alloc","fill","allocUnsafeSlow","_isBuffer","compare","x","y","list","swap16","swap32","swap64","toLocaleString","equals","inspect","max","thisStart","thisEnd","thisCopy","targetCopy","_arr","out","toHex","checkOffset","ext","checkInt","checkIEEE754","writeFloat","littleEndian","noAssert","writeDouble","newBuf","subarray","readUIntLE","mul","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUIntLE","writeUIntBE","writeUInt8","writeUInt16LE","writeUInt16BE","writeUInt32LE","writeUInt32BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","copyWithin","INVALID_BASE64_RE","leadSurrogate","toByteArray","base64clean","src","dst","b64","lens","getLens","validLen","placeHoldersLen","tmp","Arr","_byteLength","curByte","revLookup","uint8","extraBytes","parts","maxChunkLength","len2","encodeChunk","lookup","tripletToBase64","num","output","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","definition","o","g","Function","Entity","TYPE","uuid","counter","_parent","metadata","parent","setParent","debugValue","another","expect","clone","newInstance","copyTo","TimedEntity","super","duration","assert","condition","MAX_INT","TEvent","_spawnedFrom","sourceState","cancelled","timeStamp","children","spawnedFrom","setSpawnedFrom","_rootEvent","rootEvent","spawn","child","State","stateData","enter","handle","EventEmitter","_eventHub","EventHub","eventHub","hub","oldHub","eventHubChanged","_handlers","_events","_inBatchMode","on","names","_addHandler","removeOn","_removeHandler","_ensurestrings","v","handlerlist","handler","evHandlers","emit","evt","dispatchEvent","evtCallbacks","startBatchMode","cancelBatch","commitBatch","BATCH_EVENTS","ValueList","values","_firstChild","_lastChild","_size","pushBack","count","nextSibling","eqlFunc","tmp2","isEmpty","last","reversedValues","prevSibling","add","before","prev","pushFront","popBack","popFront","Browser","gcdof","t","IS_EXPLORER","IS_FIREFOX","IS_OPERA","UAHasChrome","UAHasSafari","IS_SAFARI","IS_CHROME","Fraction","den","factorized","gcd","isWhole","isZero","isInfinity","isOne","ceil","plus","plusNum","minus","minusNum","times","timesNum","divby","divbyNum","numDivby","mod","floorOfD","modNum","inverse","equalsNum","cmp","cmpNum","isLT","isLTE","isLTNum","isLTENum","isGT","isGTE","isGTNum","isGTENum","f1","f2","ZERO","ONE","INFINITY","Frac","TSU","CycleCursor","cycle","barIndex","beatIndex","currBar","bars","beatLengths","beatCounts","beatCount","Bar","bl","bc","instanceCount","totalBeatCount","Cycle","p","getAtIndex","globalIndex","bar","beatLength","getPosition","globalOffset","cycleNum","realOffset","barDuration","iterateBeats","startBar","startBeat","startInstance","instanceIndex","reduce","DEFAULT","AtomType","Atom","parentGroup","isContinuation","_duration","markersBefore","mbef","markersAfter","maft","LeafAtom","beforeRest","splitAt","spillOver","createSpilloverSpace","Space","Marker","text","isBefore","isSilent","Literal","embelishments","embs","Note","octave","fromLit","lit","NOTE","Group","atoms","durationIsMultiplier","addAtoms","a1","a2","atom","totalChildDuration","setDurationAsMultiplier","asMultiplier","setDuration","requiredDuration","targetGroup","remainingDur","durationFactor","lastChild","childDuration","newDuration","newRequiredDur","insertAtomsAt","removeAtoms","beforeAtom","adjustDuration","oldChildDuration","REST","GROUP","LABEL","scaleFactor","LayoutParams","beatDuration","_rowStartOffsets","_rowEndOffsets","_rowDurations","_totalLayoutDuration","_totalBeats","_beatLayouts","lineBreaks","layout","lineBreaksEqual","_lineBreaks","every","_a","getBeatLocation","beat","modIndex","totalBeats","cursor","refreshLayout","beatLayouts","totalLayoutDuration","cycleIter","akb","numBeats","beats","nextCP","rd","GridModel","idCounter","lastUpdatedAt","rows","rowAligns","colAligns","r","firstRow","gr","numCells","rowIndex","firstCol","minCol","fc","cellsInRow","row","cell","cells","cellsInCol","col","cellAt","addRowAlign","align","addColAlign","addRows","insertBefore","numRows","newRow","GridRow","defaultRowAlign","addSuccessor","getRow","setValue","cellCreator","grow","GridCell","clearCellAt","GridCellEvent","CLEARED","loc","oldValue","_b","UPDATED","gridRow","colIndex","rowAlign","_rowAlign","addCell","colAlign","_colAlign","grid","coordOffset","maxLength","RowAlign","numCols","creator","AlignedLine","needsLayout","_coordOffset","_maxLength","paddingBefore","paddingAfter","prevLines","nextLines","setMaxLength","setPadding","after","beforeAddingCell","removeCell","beforeRemovingCell","setOffset","cellView","getCellView","evalMaxLength","setBounds","changedCells","minSize","height","Beat","role","prevBeat","nextBeat","atomIsPlaceholder","endOffset","filled","preMarkers","curr","marker","postMarkers","allMinimalCycles","nodes","idFunc","edges","cycles","inACycle","node","startNode","visited","queue","newQueue","__read","node_1","__spreadArray","e_2","e_1","__values","e_2_1","_c","nextNode","edgeData","CharClassType","defaultKeyFunc","TrieNode","Trie","keyFunc","fromIndex","newNode","isLeaf","_d","IDSet","_entries","_entriesByKey","predicate","e2","modified","getByKey","ensure","throwIfExists","SymbolSet","grammar","enforceSymbolType","Set","hasNull","labels","sort","skipAux","exp","getSymById","isAuxiliary","label","addFrom","includeNull","addTo","termid","term","isTerminal","NullableSet","refresh","_this","beforeCount","allNonTerminals","nt","rulesForNT","rule","isStrNullable","rhs","isNullable","toIndex","syms","SymSymbolSets","_count","forEachTerm","entriesFor","debugString","sym","addNull","srcEntries","destEntries","FirstSets","_super","nullables","__extends","forEachTermIn","allNullable","symj","forEachRule","processRule","FollowSets","firstSets","startSymbol","Eof","Sym","auxType","precedence","assocLeft","creationId","compareTo","localeCompare","Str","_i","lits","lits_1","lits_1_1","strs","strs_1","strs_1_1","startIndex","endIndex","numToDelete","itemsToAdd","diff","containsAt","RuleAction","Rule","action","Grammar","symbolSet","allRules","_rulesForNT","_followSets","_hasNull","auxNTCount","auxNTPrefix","Null","newTerm","make","followSets","_AugStartRule","augmentStartSymbol","augSym","newNT","addRule","addTerminals","terminals","terminals_1","terminals_1_1","forEachNT","rules","getRule","getSym","findRule","production","findIndex","nonterm","ensureSym","removeRules","pred","removeSymbols","newRules","newRhs","sym2","T","NT","isNT","isAuxNT","seq","exps","normalizeRule","exps_1","exps_1_1","anyof","ensureAuxNT","atleast0","leftRec","auxNT","findAuxNT","which","newAuxNT","atleast1","newAuxNTName","findAuxNTByRules","rules_1","rules_1_1","ntRules","print","ruleSep","includeSemiColon","lambdaSymbol","nadded","allDerive","e_9","_e","e_10","_f","reachableSymbols","fromSymbol","reachable","queue_1","e_11","queue_1_1","e_12","e_13","_g","ruleIndex","PropertyName","PropertyValue","NINE","lA","lZ","uA","uZ","USCORE","CharClassHelper","charCode","neg","Spaces","spaceChars","reString","Digit","CharClassHelpers","WordChar","RegexType","CharType","Regex","groupIndex","groupName","groupIsSilent","ignoreCase","dotAll","multiline","setOptions","evalREString","StartOfInput","tag","START_OF_INPUT","reverse","EndOfInput","END_OF_INPUT","Assertion","StartOfWord","START_OF_WORD","EndOfWord","END_OF_WORD","expr","cond","negate","LookAhead","LOOK_AHEAD","LookBack","LOOK_BACK","Quant","minCount","maxCount","greedy","QUANT","isVariable","quant","isUnlimited","Cat","CAT","children_1","children_1_1","__assign","Union","UNION","options_1","options_1_1","Char","op","CHAR","ch","matchChar","modifiers","LeafChar","Any","AnyChar","Class","charClass","CharClass","Single","SingleChar","PropertyEscape","propNameOrId","propValueOrId","SyntaxError","PropertyEscapes","CharGroup","chars","CharRange","Intersection","Range","Var","reversed","VAR","BackNamedRef","BACK_NAMED_REF","BackRef","BackNumRef","BACK_NUM_REF","skip","priority","matchIndex","activeStates","stateCanActivate","isNewLineChar","OpCode","Match","groups","positions","Prog","startCondition","scIsInclusive","instrs","stateMapping","registerState","opcode","Instr","with","initializer","instrDebugValue","InstrDebugValue","instr","comment","Thread","gen","parentId","registers","regIncr","regId","regAcquire","regRelease","regValue","VM","prog","forward","configs","threadCounter","currThreads","nextThreads","startPos","currState","genForOffset","savePosition","thread","tapeIndex","jumpBy","delta","jumpTo","newOffset","forkTo","startGroup","newThread","endGroup","addThread","tape","nextCh","lastCh","Jump","Split","newOff","newThread_1","Save","tracer","threadQueued","GroupStart","GroupEnd","StartingChar","MLStartingChar","prevCh","EndingChar","MLEndingChar","RBegin","negate_1","end_1","groupStart","recurseMatch","matchSuccess","Begin","consume","EnsureState","states","states_1","states_1_1","matchCurrPos","currChCodeLower","currChCodeUpper","currChCode","hasMore","charAt","startMatching","bestMatch","stepChar","startOffset","savedPos","canAdvance","newPos","currMatch","nextMatch","stepThread","advance","threadStepped","advanceTape","End","currPriority","CIChar","AnyNonNL","currCh","Compiler","regexResolver","emitGroups","emitPosition","compile","needsSpecificStates","ensureInstr_1","ind","compileExpr","currOffset","compileChar","ml","compileCat","compileUnion","compileQuant","compileVar","compileBackNamedRef","compileBackNumRef","compileLookAhead","compileLookBack","cat","ne","union","jumps","jumps_1","jumps_1_1","compileAtleast0","compileAtleast1","compileOptional","l1","l3","l2","la","begin","lb","TokenizerError","setPrototypeOf","_newTarget","UnexpectedTokenError","foundToken","expectedTokens","Tape","input","_rawInput","hasIndex","TapeInterface","charCodeAtLower","charCodeAtUpper","TapeHelper","advanceAfter","pattern","ensureNoPrefixSlash","advanceTo","currStart","numSlashes","prefix","success","Token","isOneOf","expected","expected_1","expected_1_1","tok","TokenBuffer","nextToken","tokenizerContext","peek","nth","matchFunc","nextAction","consumeIf","expectToken","ensureToken","nextMatches","expected_2","expected_2_1","GroupCounter","isSpace","RegexParser","unicode","reduceLeft","throwError","refNum","current","gtPos","name_1","clPos","parseCharGroup","rest","parseGroup","parseQuant","parseChar","nchars","depth","subExpr","currch","endch","nchars_1","parseEscapeChar","parseSingleChar","parsePropertyEscape","clEnd","eqPos","propStr","propName","propValue","WORD_CHAR","DIGITS","SPACES","hexSeq","hexVal","ucodeSeq","ucodeVal","advanceIf","ignoreSpaces","obCount","ignoreSpaces2","foundComma","part1","part2","foundEq","exprFromJSRE","exprFromFlexRE","FlexREParser","re","JSREParser","flexRE","strings","raw","TokenType","NodeType","Tokenizer","owner","startChar","vm","onError","gi","toToken","onMatch","onMatchHandlers","matchHandlersByValue","tokenize","DefaultTape","BaseTokenizer","_prog","_vm","variables","compiler","findRuleByValue","getVar","addVar","regex","currValue","find","Builder","sortedRules","sortRules","r1","r2","SimpleTokenizer","peekedToken","literals","matchers","addMatcher","addLiteral","tokType","k","kwd","toktype","SINGLE_QUOTE_STRING","templateObject_1","__makeTemplateObject","DOUBLE_QUOTE_STRING","templateObject_2","JS_REGEX","templateObject_3","templateObject_4","str2regex","Loader","leftRecursive","generatedTokenizer","TLEX","regexSyntax","symbolsByLabel","newSymbolCallback","tokenHandlers","symbolForLabel","registerSymbol","ensureSymbol","assumedTerminal","currSym","lexer","et","ARROW","OPEN_SQ","CLOSE_SQ","OPEN_PAREN","CLOSE_PAREN","OPEN_BRACE","CLOSE_BRACE","STAR","PLUS","QMARK","SEMI_COLON","COLON","PIPE","COMMENT","STRING","REGEX","flags","NUMBER","PCT_IDENT","DOLLAR_NUM","DOLLAR_IDENT","IDENT","tokenizer","parseGrammar","parseRegex","syntax","tokPattern","patternStr","peeked","parseDecl","parseDirective","directive","startsWith","tokenHandler_1","parseTokenHandler","isDef","tokName","tokenHandler","funcName","ident","parseProductions","parseProd","PTNode","nodes_1","nodes_1_1","PFNode","childAt","out_1","ParserBase","setTokenizer","tokenbuffer","SimpleParser","delegate","parseInput","printRule","hideAux","ParallelParser","LRActionType","ParseStack","ParseTable","indentStr","printRules","printGrammar","leftRecursion","ensureEntry","entriesForNT","ntId","ntMap","e_4","termId","items","items_1","items_1_1","item","ruleIsNullable","parseTable","docNode","rootNode","top","Parser","topItem","topNode","nextSym","nextValue","consumeTokenAndPop","processInvalidToken","processInvalidReductions","ptnode","popSymAndPushRule","parentNode","ParseError","LRAction","gotoState","ACCEPT","SHIFT","REDUCE","Shift","goto","Reduce","Goto","GOTO","Accept","conflictActions","actions","getActions","stateId","addAction","ac","fromId","symId","stateStack","nodeStack","popN","L","buildParseTree","copySingleChild","augStartRule","resolveActions","actionResolver","onTokenError","onNextToken","topState","ruleLen","childNode","beforeAddingChildNode","handlerName","ruleHandlers","onReduction","newAction","LRItem","pre","post","LRItemSet","ig","_lookaheads","_hasLookAheads","itemGraph","addLookAhead","s1","s2","clearLookAheads","getLookAheads","revalKey","hasLookAheads","itemId","i1","i2","las","LRItemGraph","gotoSets","itemSets","startItem","reset","startSet","evalGotoSets","currSet","allSymbols","gotoSet","setGoto","itemSet","newItemSet","advanceItemAndAdd","closure","itemToAdvance","fromItemSet","toItemSet","newItem","laSym","ensureGotoSet","fromSet","toSet","getGoto","forEachGoto","symid","gotoSetFor","iset","LR0ItemGraph","newset","e_5","rule_1","LR1ItemGraph","this_1","B","e_6","lookahead","suffix","bRules","bRules_1","e_7","bRules_1_1","br","makeParseTable","makeParseTableFromLA","makeSLRParseTable","hasConflicts","g2","ensureG2Sym","pi","newSymLabel","newSym","startState","transitions","buildRuleFrom","A","newSyms","xi","nextSet","startSym","newA_1","newRHS","newRule","grammarFromLR0ItemGraph","prevSets","evalLASetsForLALRItem","makeLALRParseTable","evalLASetsForSLRItem","makeSLRAutomaton","lookaheads","lookaheads_1","lookaheads_1_1","lr1Item","augGrammar","findP","prevStates","nextState","pSet","pALabel","pA","ALIAS","for","DOC","MAP","PAIR","SCALAR","SEQ","NODE_TYPE","isAlias","isDocument","isMap","isPair","isScalar","isSeq","isCollection","hasAnchor","anchor","BREAK","SKIP","REMOVE","visitor_","initVisitor","visit_","contents","freeze","ctrl","callVisitor","replaceNode","ci","ck","cv","visitAsync","visitAsync_","Collection","Node","Value","Alias","Scalar","Seq","Pair","pt","escapeChars","escapeTagName","tn","Directives","yaml","tags","docStart","docEnd","defaultYaml","defaultTags","atDocument","atNextDocument","explicit","tagName","verbatim","tagString","doc","lines","tagEntries","tagNames","anchorIsValid","sa","applyReviver","reviver","v0","v1","toJS","ctx","aliasCount","anchors","onCreate","keep","NodeBase","range","mapAsMap","maxAliasCount","onAnchor","mapKeyWarned","aliasResolveCache","_arg","ReferenceError","getAliasCount","_onComment","_onChompKeep","verifyAliasOrder","implicitKey","kc","vc","isScalarValue","createNode","BigInt","aliasDuplicateObjects","onTagObj","sourceObjects","ref","tagObj","identify","findTagObject","nodeClass","collectionFromPath","isInteger","keepUndefined","BLOCK_FOLDED","BLOCK_LITERAL","PLAIN","QUOTE_DOUBLE","QUOTE_SINGLE","it","addIn","isEmptyPath","deleteIn","getIn","keepScalar","hasAllNullValues","allowScalar","commentBefore","hasIn","setIn","stringifyComment","indentComment","indent","lineComment","FOLD_FLOW","FOLD_BLOCK","FOLD_QUOTED","foldFlowLines","mode","indentAtStart","lineWidth","minContentWidth","onFold","onOverflow","endStep","folds","escapedFolds","overflow","escStart","escEnd","consumeMoreIndentedLines","fold","getFoldOptions","isBlock","containsDocumentMarker","doubleQuotedString","json","doubleQuotedAsJSON","minMultiLineLength","doubleQuotedMinMultiLineLength","singleQuotedString","singleQuote","quotedString","qs","hasDouble","hasSingle","blockEndNewlines","blockString","onComment","onChompKeep","blockQuote","commentString","forceBlockIndent","literal","indentLength","lineLengthOverLimit","chomp","endStart","endNlPos","startEnd","startWithSpace","startNlPos","foldedValue","literalFallback","foldOptions","stringifyString","inFlow","ss","_stringify","_type","actualString","indentStep","compat","plainString","defaultKeyType","defaultStringType","directives","resolvedAliases","testMatch","getTagObject","stringifyProps","MERGE_KEY","addToJSMap","addMergeToJSMap","mergeValue","srcMap","addPairToJSMap","isMergeKey","jsKey","stringKey","strCtx","falseStr","flowCollectionPadding","indentSeq","nullStr","simpleKeys","trueStr","toStringOptions","collectionStyle","repeat","createStringifyContext","inStringifyKey","strKey","jsonStr","warning","logLevel","stringifyKey","jsValue","createPair","_","allNullValues","keyComment","explicitKey","vsb","vcb","valueComment","keyCommentDone","chompKeep","spaceBefore","flow","valueCommentDone","valueStr","ws","vs0","nl0","hasNewline","hasPropsLine","sp0","stringifyPair","stringifyCollection","collection","stringifyFlowCollection","stringifyBlockCollection","blockItemPrefix","flowChars","itemIndent","itemCtx","addCommentBefore","ik","fcPadding","reqNewline","linesAtValue","iv","sum","ic","trimStart","findPair","YAMLMap","replacer","sortMapEntries","overwrite","_pair","sortEntries","Type","YAMLSeq","idx","asItemIndex","nullTag","boolTag","stringifyNumber","minFractionDigits","is","floatNaN","NEGATIVE_INFINITY","POSITIVE_INFINITY","floatExp","parseFloat","toExponential","intIdentify","intResolve","radix","intAsBigInt","intStringify","_onError","dot","stringifyJSON","binary","atob","resolvePairs","cn","createPairs","pairs","YAMLOMap","omap","seenKeys","boolStringify","trueTag","falseTag","float","f","sign","intBin","intOct","int","intHex","YAMLSet","keepPair","parseSexagesimal","asBigInt","stringifySexagesimal","_60","padStart","intTime","floatTime","year","month","day","hour","minute","second","millisec","date","UTC","tz","schema$1","schema$2","cst","_visit","field","GamakaType","itemAtPath","parentCollection","coll","Shape","shapeId","_x","_y","_width","_height","parentShape","bbox","_bbox","refreshBBox","_minSize","refreshMinSize","invalidateBounds","applyLayout","nx","ny","nw","nh","updateBounds","hasX","hasY","hasWidth","hasHeight","width","eparser","tokenFunc","debug","loadGrammar","newParseTable","ptable","ptabDV","igDV","mergedDebugValue","logParserDebug","G","allowLeftRecursion","toEmbelishment","emb","parseEmbelishment","errors","toCommandName","_tape","_owner","toBoolean","toNumber","toMarker","markerText","toOctavedNote","note","toRoleSelector","toLineAnnotation","toSingleLineRawString","toMultiLineRawString","endPat","endPos","toFrontMatter"],"sourceRoot":""}
+{"version":3,"file":"notations.umd.min.js","mappings":"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","sources":["webpack://Notations/webpack/universalModuleDefinition","webpack://Notations/webpack/bootstrap","webpack://Notations/webpack/runtime/define property getters","webpack://Notations/webpack/runtime/hasOwnProperty shorthand","webpack://Notations/../../src/entity.ts","webpack://Notations/../../src/types.ts","webpack://Notations/../../src/constants.ts","webpack://Notations/../../../src/comms/events.ts","webpack://Notations/../../src/list.ts","webpack://Notations/../../src/browser.ts","webpack://Notations/../../src/numberutils.ts","webpack://Notations/../../src/cycle.ts","webpack://Notations/../../src/core.ts","webpack://Notations/../../src/layouts.ts","webpack://Notations/../../src/grids.ts","webpack://Notations/../../src/beats.ts","webpack://Notations/../../src/graph.ts","webpack://Notations/../../src/sets.ts","webpack://Notations/../../src/grammar.ts","webpack://Notations/../../src/charclasses.ts","webpack://Notations/../../src/propertyescapes.ts","webpack://Notations/../../src/vm.ts","webpack://Notations/../../src/compiler.ts","webpack://Notations/../../src/errors.ts","webpack://Notations/../../src/tape.ts","webpack://Notations/../../src/token.ts","webpack://Notations/../../src/utils.ts","webpack://Notations/../../src/jsparser.ts","webpack://Notations/../../src/flexparser.ts","webpack://Notations/../../src/builder.ts","webpack://Notations/../../src/tokenizer.ts","webpack://Notations/../../src/samples.ts","webpack://Notations/../../src/dsl.ts","webpack://Notations/../../src/lr.ts","webpack://Notations/../../src/parser.ts","webpack://Notations/../../src/lritems.ts","webpack://Notations/../../src/ptables.ts","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/nodes/identity.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/visit.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/doc/directives.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/doc/anchors.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/doc/applyReviver.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/nodes/toJS.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/nodes/Node.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/nodes/Alias.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/nodes/Scalar.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/doc/createNode.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/nodes/Collection.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/stringify/stringifyComment.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/stringify/foldFlowLines.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/stringify/stringifyString.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/stringify/stringify.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/yaml-1.1/merge.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/nodes/addPairToJSMap.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/log.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/nodes/Pair.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/stringify/stringifyPair.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/stringify/stringifyCollection.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/nodes/YAMLMap.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/common/map.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/nodes/YAMLSeq.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/common/seq.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/common/string.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/common/null.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/core/bool.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/stringify/stringifyNumber.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/core/float.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/core/int.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/core/schema.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/json/schema.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/yaml-1.1/binary.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/yaml-1.1/pairs.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/yaml-1.1/omap.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/yaml-1.1/bool.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/yaml-1.1/float.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/yaml-1.1/int.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/yaml-1.1/set.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/yaml-1.1/timestamp.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/yaml-1.1/schema.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/tags.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/errors.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/parse/cst-visit.js","webpack://Notations/../../../src/carnatic/gamakas.ts","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/parse/lexer.js","webpack://Notations/../../src/shapes.ts","webpack://Notations/../../src/factory.ts","webpack://Notations/../../src/debug.ts"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"Notations\"] = factory();\n\telse\n\t\troot[\"Notations\"] = factory();\n})(this, () => {\nreturn ","// The require scope\nvar __webpack_require__ = {};\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","import * as TSU from \"@panyam/tsutils\";\n\n/**\n * A common Entity base class with support for unique IDs, parent references,\n * copying, and debug info. This serves as the foundation for all entities\n * in the notation system.\n *\n * Note: Child management is intentionally NOT included here. Each container type\n * (BlockContainer, Line, Group, etc.) defines its own child management with\n * appropriate types.\n */\nexport class Entity {\n  readonly TYPE: string = \"Entity\";\n\n  private static counter = 0;\n  /** Unique identifier for this entity */\n  readonly uuid = Entity.counter++;\n  /** Parent entity in the tree hierarchy */\n  protected _parent: TSU.Nullable<Entity> = null;\n\n  /**\n   * Creates a new Entity.\n   * @param config Optional configuration object\n   */\n  constructor(config: any = null) {\n    config = config || {};\n    if (config.metadata) throw new Error(\"See where metadata is being passed\");\n  }\n\n  /**\n   * Gets the parent entity.\n   */\n  get parent(): TSU.Nullable<Entity> {\n    return this._parent;\n  }\n\n  /**\n   * Sets the parent entity.\n   * @param parent The parent entity to set\n   */\n  setParent(parent: TSU.Nullable<Entity>): void {\n    this._parent = parent;\n  }\n\n  /**\n   * Returns a debug-friendly representation of this entity.\n   * Usually overridden by children to add more debug info.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return { type: this.TYPE };\n  }\n\n  /**\n   * Returns a simple string representation of this Entity.\n   * @returns A string representation\n   */\n  toString(): string {\n    return `Entity(id = ${this.uuid})`;\n  }\n\n  /**\n   * Checks if this Entity is equal to another Entity.\n   * @param another The Entity to compare with\n   * @param expect Optional parameter\n   * @returns True if the Entities are equal, false otherwise\n   */\n  equals(another: this, expect = false): boolean {\n    if (this.TYPE != another.TYPE) return false;\n    return true;\n  }\n\n  /**\n   * Creates a clone of this entity.\n   * Cloning is a two-part process:\n   * 1. Creation of a new instance via this.newInstance()\n   * 2. Copying of data into the new instance via this.copyTo()\n   *\n   * @returns A new instance of the same type with the same properties\n   */\n  clone(): this {\n    const out = this.newInstance();\n    this.copyTo(out);\n    return out;\n  }\n\n  /**\n   * Copies information about this instance into another instance of the same type.\n   * @param another The target instance to copy properties to\n   */\n  copyTo(another: this): void {\n    // Subclasses override to copy their specific properties\n  }\n\n  /**\n   * First part of the cloning process where the instance is created.\n   * @returns A new instance of the same type\n   */\n  protected newInstance(): this {\n    return new (this.constructor as any)();\n  }\n}\n\n/**\n * Music is all about timing! TimedEntities are base of all entities that\n * have a duration. This is an abstract class that all timed entities inherit from.\n */\nexport abstract class TimedEntity extends Entity {\n  readonly TYPE: string = \"TimedEntity\";\n\n  /**\n   * Gets the duration of this entity in terms of beats.\n   * By default, entity durations are readonly.\n   */\n  abstract get duration(): TSU.Num.Fraction;\n\n  /**\n   * Checks if this TimedEntity is equal to another TimedEntity.\n   * @param another The TimedEntity to compare with\n   * @returns True if the TimedEntities are equal, false otherwise\n   */\n  equals(another: this): boolean {\n    return super.equals(another) && this.duration.equals(another.duration);\n  }\n}\n","export type Timestamp = number;\nexport type NumberRange = [number, number];\n\nexport type StringMap<T> = { [key: string]: T };\nexport type NumMap<T> = { [key: number]: T };\nexport type Nullable<T> = T | null;\n\nexport type Undefined<T> = T | undefined | void;\n\nexport function assert(condition: boolean, msg?: string): asserts condition {\n  if (!condition) {\n    throw new Error(msg);\n  }\n}\n","export const INFINITY = 1e48;\nexport const MAX_INT = 2 ** 32;\nexport const MAX_LONG = 2 ** 64;\n","import { Nullable, Timestamp } from \"../types\";\n\n/**\n * Super class of all Events.\n */\nexport class TEvent {\n  // Globally unique ID for all events.\n  private static counter = 0;\n  readonly uuid = TEvent.counter++;\n\n  /**\n   * The event this event was spawned from (if any).\n   */\n  protected _spawnedFrom: Nullable<this> = null;\n\n  /**\n   * Name of the event.\n   */\n  readonly name: string;\n\n  /**\n   * Source from which this event is originating.\n   */\n  readonly source: any;\n\n  /**\n   * Source state that is set by the source of the event only\n   * *it* can use.\n   */\n  sourceState: any = null;\n\n  /**\n   * Event specific payload.\n   */\n  payload: any;\n\n  /**\n   * Whether the event was cancelled.\n   */\n  cancelled = false;\n\n  /**\n   * Timestamp of the event - optional.\n   */\n  timeStamp: Timestamp = -1;\n\n  /**\n   * All child events that were spawned from this Event.\n   * The parent/spawnedFrom and child event references help us\n   * form a call tree/trace of a events as it traverses\n   * the system.\n   */\n  children: TEvent[] = [];\n\n  constructor(name: string, source: any, payload?: any) {\n    this.name = name;\n    this.source = source;\n    this.payload = payload;\n  }\n\n  get spawnedFrom(): Nullable<this> {\n    return this._spawnedFrom;\n  }\n\n  protected setSpawnedFrom(msg: Nullable<this>): void {\n    this._spawnedFrom = msg;\n    if (msg == null) this._rootEvent = this;\n    else this._rootEvent = msg.rootEvent;\n  }\n\n  spawn(name: string, source: any, payload?: any): TEvent {\n    const child = new TEvent(name, source, payload);\n    child.setSpawnedFrom(this);\n    this.children.push(child);\n    return child;\n  }\n\n  /**\n   * The first/root message in the forward chain.\n   */\n  private _rootEvent: this;\n\n  get rootEvent(): this {\n    return this._rootEvent as this;\n  }\n}\n\nexport class State {\n  private static counter = 0;\n  stateData: any = null;\n  readonly id = State.counter++;\n\n  get name(): string {\n    return this.constructor.name;\n  }\n\n  enter(data: any): void {\n    this.stateData = data;\n  }\n\n  handle(event: TEvent): void {\n    // todo\n  }\n}\n\nexport type EventCallback = ((event: TEvent) => void) | ((event: TEvent) => Promise<void>);\n\nexport class EventEmitter {\n  protected _eventHub: EventHub | null;\n  constructor() {\n    this._eventHub = new EventHub();\n  }\n  get eventHub(): EventHub | null {\n    return this._eventHub;\n  }\n  set eventHub(hub: EventHub | null) {\n    const oldHub = this._eventHub;\n    this._eventHub = hub;\n    this.eventHubChanged(oldHub);\n  }\n  protected eventHubChanged(oldHub: EventHub | null): void {\n    // Do nothing\n    console.log(\"WARNING - EventHub Change Listener not implemented: \", this.constructor.name);\n  }\n}\n\nexport class EventHub {\n  private _handlers: { [key: string]: Array<EventCallback> } = {};\n\n  on(names: Array<string> | string, callback: EventCallback): this {\n    return this._addHandler(names, this._handlers, callback);\n  }\n\n  removeOn(names: Array<string> | string, callback: EventCallback): this {\n    return this._removeHandler(names, this._handlers, callback);\n  }\n\n  _ensurestrings(names: Array<string> | string): string[] {\n    if (typeof names === \"string\") {\n      names = (names as string).split(\",\");\n    }\n    return names.map(function (v) {\n      return v.trim();\n    });\n  }\n\n  _addHandler<T>(names: Array<string> | string, handlerlist: { [key: string]: Array<T> }, handler: T): this {\n    this._ensurestrings(names).forEach(function (name) {\n      handlerlist[name] = handlerlist[name] || [];\n      handlerlist[name].push(handler);\n    });\n    return this;\n  }\n\n  _removeHandler<T>(names: Array<string> | string, handlerlist: { [key: string]: Array<T> }, handler: T): this {\n    this._ensurestrings(names).forEach(function (name) {\n      const evHandlers = handlerlist[name] || [];\n      for (let i = 0; i < evHandlers.length; i++) {\n        if (evHandlers[i] == handler) {\n          evHandlers.splice(i, 1);\n          break;\n        }\n      }\n    });\n    return this;\n  }\n\n  emit(name: string, source: any, payload?: any): boolean {\n    const evt = new TEvent(name, source, payload);\n    if (this._inBatchMode) {\n      this._events.push(evt);\n      return true;\n    } else {\n      return this.dispatchEvent(evt);\n    }\n  }\n\n  dispatchEvent(event: TEvent): boolean {\n    const evtCallbacks = this._handlers[event.name] || [];\n    for (const callback of evtCallbacks) {\n      callback(event);\n      if (event.cancelled) return false;\n    }\n    return true;\n  }\n\n  // Support for transactional/batch event handling, where\n  // the user can allow a bunch of events to first collect\n  // before triggering a batch dispatch\n  public static BATCH_EVENTS = \"BatchEvents\";\n  protected _events: TEvent[] = [];\n  protected _inBatchMode = false;\n  startBatchMode(): this {\n    if (!this._inBatchMode) {\n      this._inBatchMode = true;\n    }\n    return this;\n  }\n\n  cancelBatch(): void {\n    this._inBatchMode = false;\n    this._events = [];\n  }\n\n  commitBatch(): void {\n    this._inBatchMode = false;\n    this.emit(EventHub.BATCH_EVENTS, this, this._events);\n    this._events = [];\n  }\n}\n\n/**\n * StateMachines allow declarative and stateful chaining of events.\n */\nexport class StateMachine {\n  private _states: { [key: string]: State } = {};\n  private _rootState: Nullable<State> = null;\n  private _currentState: Nullable<State> = null;\n  constructor() {\n    this._states = {};\n    this._rootState = null;\n    this._currentState = null;\n  }\n\n  /**\n   * The starting/root state of the machine.\n   *\n   * @param {String} name  Name of the default/root state.\n   */\n  set rootState(name: string) {\n    this._rootState = this.getState(name);\n    if (this._currentState == null) {\n      this._currentState = this._rootState;\n    }\n  }\n\n  /**\n   * Exits the current state (if any) and enters a new state.\n   *\n   * @param {String}   state   Name of the new state to enter.\n   * @param {Object}   data    State specific data for the state handler to use for the new state.\n   */\n  enter(state: string, data: any = null): void {\n    if (state == \"\") {\n      this._currentState = this._rootState;\n    } else {\n      this._currentState = this.getState(state);\n    }\n    if (this._currentState != null) {\n      this._currentState.enter(data);\n    }\n  }\n\n  /**\n   * Get the state by name.\n   *\n   * @param {String} name  Name of the state being queried.\n   * @returns {State} State object associated with the name.\n   */\n  getState(name: string): State {\n    if (!(name in this._states)) {\n      throw Error(\"State '\" + name + \"' not yet registered.\");\n    }\n    return this._states[name];\n  }\n\n  /**\n   * Register a new state in the state machine.\n   *\n   * @param {State} state  State being registered.  If another State with\n   * the same name exists, then a {DuplicateError} is thrown.\n   * @param {Bool} isRoot  Whether the new state is a root state.\n   */\n  registerState(state: State, isRoot = false): void {\n    const name = state.name;\n    if (name in this._states) {\n      throw Error(\"State '\" + name + \"' already registered.\");\n    }\n    this._states[name] = state;\n    if (isRoot || false) {\n      this.rootState = state.name;\n    }\n  }\n\n  /**\n   * Handles an event from the current state in the state machine possibly resulting in a state transition.\n   *\n   * @param {Object} name    Type of event being sent.\n   * @param {EventSource} source  The source generating the event.\n   * @param {Object} data    The event specific data.\n   */\n  handle(event: TEvent): void {\n    if (this._currentState == null) return;\n\n    const nextState: any = this._currentState.handle(event);\n    if (nextState != null) {\n      if (nextState == \"\") {\n        if (this._rootState != null) {\n          this.enter(this._rootState.name);\n        } else {\n          throw new Error(\"Root state has not been set\");\n        }\n      } else {\n        this.enter(nextState);\n      }\n    }\n  }\n}\n","import { Nullable } from \"./types\";\n\nexport interface ListNode<V> {\n  nextSibling: Nullable<V>;\n  prevSibling: Nullable<V>;\n}\n\nclass MutableListNode<V> implements ListNode<MutableListNode<V>> {\n  nextSibling: Nullable<MutableListNode<V>> = null;\n  prevSibling: Nullable<MutableListNode<V>> = null;\n  constructor(public value: V) {}\n}\n\n/**\n * A list implementation where the value itself contains next and prev pointers\n * so we do not need to create wrapper classes.\n */\nexport class ValueList<V extends ListNode<V>> {\n  protected _firstChild: Nullable<V> = null;\n  protected _lastChild: Nullable<V> = null;\n  protected _size = 0;\n\n  constructor(...values: V[]) {\n    for (const v of values) this.pushBack(v);\n  }\n\n  toJSON(): V[] {\n    return Array.from(this.values());\n  }\n\n  forEach(method: (val: V) => boolean | any): number {\n    let tmp: V | null = this._firstChild;\n    let count = 0;\n    while (tmp != null) {\n      if (method(tmp) == false) {\n        break;\n      }\n      count++;\n      tmp = tmp.nextSibling;\n    }\n    return count;\n  }\n\n  equals(another: ValueList<V>, eqlFunc: (val1: V, val2: V) => boolean): boolean {\n    if (this.size != another.size) return false;\n    let tmp = this.first;\n    let tmp2 = another.first;\n    for (; tmp != null && tmp2 != null; tmp = tmp.nextSibling, tmp2 = tmp2.nextSibling) {\n      if (!eqlFunc(tmp, tmp2)) {\n        return false;\n      }\n    }\n    return tmp == null && tmp2 == null;\n  }\n\n  get isEmpty(): boolean {\n    return this._size == 0;\n  }\n\n  get size(): number {\n    return this._size;\n  }\n\n  get first(): Nullable<V> {\n    return this._firstChild;\n  }\n\n  get last(): Nullable<V> {\n    return this._lastChild;\n  }\n\n  /**\n   * Generator of values in reverse order.\n   */\n  *reversedValues(): Generator<V> {\n    let tmp = this._lastChild;\n    while (tmp != null) {\n      yield tmp;\n      tmp = tmp.prevSibling;\n    }\n  }\n\n  /**\n   * Generator of values in forward order.\n   */\n  *values(): Generator<V> {\n    let tmp = this._firstChild;\n    while (tmp != null) {\n      yield tmp;\n      tmp = tmp.nextSibling;\n    }\n  }\n\n  add(child: V, before: Nullable<V> = null): this {\n    // Ensure that this node is not added anywhere else\n    if (child.nextSibling != null || child.prevSibling != null) {\n      throw new Error(\"New node already added to a list.  Remove it first\");\n    }\n    child.nextSibling = child.prevSibling = null;\n    this._size++;\n    if (this._firstChild == null || this._lastChild == null) {\n      this._firstChild = this._lastChild = child;\n    } else if (before == null) {\n      child.prevSibling = this._lastChild;\n      child.nextSibling = null;\n      this._lastChild.nextSibling = child;\n      this._lastChild = child;\n    } else if (before == this._firstChild) {\n      child.nextSibling = before;\n      child.prevSibling = null;\n      this._firstChild.prevSibling = child;\n      this._firstChild = child;\n    } else {\n      const prev = before.prevSibling;\n      child.nextSibling = before;\n      before.prevSibling = child;\n      child.prevSibling = prev;\n      if (prev != null) {\n        prev.nextSibling = child;\n      }\n    }\n    return this;\n  }\n\n  pushFront(value: V): this {\n    return this.add(value, this._firstChild);\n  }\n\n  pushBack(value: V): this {\n    return this.add(value);\n  }\n\n  /**\n   * Removes a child node from this list.\n   * It is upto the caller to ensure that this node indeed belongs\n   * to this list otherwise deletion of a non belonging node could result\n   * in undefined behaviour.\n   */\n  remove(child: V): this {\n    const next = child.nextSibling;\n    const prev = child.prevSibling;\n\n    if (next == null) {\n      this._lastChild = prev;\n      if (prev == null) this._firstChild = null;\n    } else {\n      next.prevSibling = prev;\n    }\n\n    if (prev == null) {\n      this._firstChild = next;\n      if (next == null) this._lastChild = null;\n    } else {\n      prev.nextSibling = next;\n    }\n\n    this._size--;\n\n    child.prevSibling = child.nextSibling = null;\n    return this;\n  }\n\n  popBack(): V {\n    if (this._lastChild == null) {\n      throw new Error(\"No children\");\n    }\n    const out = this._lastChild;\n    this.remove(out);\n    return out;\n  }\n\n  popFront(): V {\n    if (this._firstChild == null) {\n      throw new Error(\"No children\");\n    }\n    const out = this._firstChild;\n    this.remove(out);\n    return out;\n  }\n}\n\n/**\n * A list implementation where the values themselves need to be wrapper in a list node.\n * If values already have sibling node properties they can be direclty used\n * via ValueLists.\n */\nexport class List<V> {\n  private container: ValueList<MutableListNode<V>>;\n\n  constructor(...values: V[]) {\n    this.container = new ValueList<MutableListNode<V>>();\n    for (const v of values) this.push(v);\n  }\n\n  toJSON(): V[] {\n    return Array.from(this.values());\n  }\n\n  forEach(method: (val: V) => boolean | any): number {\n    return this.container.forEach((v) => method(v.value));\n  }\n\n  equals(another: List<V>, eqlFunc: (val1: V, val2: V) => boolean): boolean {\n    return this.container.equals(another.container, (a, b) => eqlFunc(a.value, b.value));\n  }\n\n  find(target: V): Nullable<MutableListNode<V>> {\n    for (const v of this.container.values()) {\n      if (target == v.value) {\n        return v;\n      }\n    }\n    return null;\n  }\n\n  get isEmpty(): boolean {\n    return this.container.isEmpty;\n  }\n\n  get size(): number {\n    return this.container.size;\n  }\n\n  get first(): Nullable<MutableListNode<V>> {\n    return this.container.first;\n  }\n\n  get last(): Nullable<MutableListNode<V>> {\n    return this.container.last;\n  }\n\n  /**\n   * Generator of values in reverse order.\n   */\n  *reversedValues(): Generator<V> {\n    for (const v of this.container.reversedValues()) yield v.value;\n  }\n\n  /**\n   * Generator of values in forward order.\n   */\n  *values(): Generator<V> {\n    for (const v of this.container.values()) yield v.value;\n  }\n\n  popBack(): V {\n    return this.container.popBack().value;\n  }\n\n  popFront(): V {\n    return this.container.popFront().value;\n  }\n\n  pushFront(value: V): this {\n    return this.add(value, this.container.first);\n  }\n\n  push(value: V): this {\n    return this.add(value);\n  }\n\n  add(child: V, before: Nullable<MutableListNode<V>> = null): this {\n    this.container.add(new MutableListNode(child), before);\n    return this;\n  }\n}\n","declare let navigator: any;\nexport class Browser {\n  static IS_EXPLORER = () => navigator && navigator.userAgent.indexOf(\"MSIE\") > -1;\n  static IS_FIREFOX = () => navigator && navigator.userAgent.indexOf(\"Firefox\") > -1;\n  static IS_OPERA = () => navigator && navigator.userAgent.toLowerCase().indexOf(\"op\") > -1;\n\n  protected static UAHasChrome = () => navigator && navigator.userAgent.indexOf(\"Chrome\") > -1;\n  protected static UAHasSafari = () => navigator && navigator.userAgent.indexOf(\"Safari\") > -1;\n  static IS_SAFARI = () => navigator && Browser.UAHasSafari() && (!Browser.UAHasChrome() || !Browser.UAHasSafari());\n  static IS_CHROME = () => navigator && Browser.UAHasChrome() && (!Browser.UAHasChrome() || !Browser.IS_OPERA());\n}\n","import { Nullable } from \"./types\";\n\nexport function range(start: number, end: Nullable<number> = null, incr: Nullable<number> = 1): number[] {\n  if (end == null) {\n    const absStart = Math.abs(start);\n    const arr = Array.from({ length: absStart });\n    if (start >= 0) {\n      return arr.map((x, i) => i);\n    } else {\n      return arr.map((x, i) => i - (absStart - 1));\n    }\n  }\n  const out: number[] = [];\n  if (incr == null) {\n    incr = 1;\n  }\n  incr = Math.abs(incr);\n  if (start !== end) {\n    if (start < end) {\n      for (let i = start; i <= end; i += incr) {\n        out.push(i);\n      }\n    } else {\n      for (let i = start; i >= end; i -= incr) {\n        out.push(i);\n      }\n    }\n  }\n  return out;\n}\n\nexport function gcdof(x: number, y: number): number {\n  x = Math.abs(x);\n  y = Math.abs(y);\n  while (y > 0) {\n    const t = y;\n    y = x % y;\n    x = t;\n  }\n  return x;\n}\n\nexport class Fraction {\n  readonly num: number;\n  readonly den: number;\n\n  static readonly ZERO = new Fraction();\n  static readonly ONE = new Fraction(1, 1);\n  static readonly INFINITY = new Fraction(1, 0);\n\n  constructor(num = 0, den = 1, factorized = false) {\n    if (isNaN(num) || isNaN(den)) {\n      throw new Error(`Invalid numerator(${num}) or denminator(${den})`);\n    }\n    if (factorized) {\n      const gcd = gcdof(num, den);\n      num /= gcd;\n      den /= gcd;\n    }\n    this.num = num;\n    this.den = den;\n  }\n\n  static parse(val: string, factorized = false): Fraction {\n    const parts = val\n      .trim()\n      .split(\"/\")\n      .map((x) => x.trim());\n    let num = 1;\n    let den = 1;\n    if (parts.length == 1) num = parseInt(parts[0]);\n    else if (parts.length != 2) {\n      throw new Error(\"Invalid fraction string: \" + val);\n    } else {\n      if (parts[0].length > 0) {\n        num = parseInt(parts[0]);\n      }\n      if (parts[1].length > 0) {\n        den = parseInt(parts[1]);\n      }\n    }\n    if (isNaN(num) || isNaN(den)) {\n      throw new Error(\"Invalid fraction string: \" + val);\n    }\n    return new Fraction(num, den, factorized);\n  }\n\n  get isWhole(): boolean {\n    return this.num % this.den == 0;\n  }\n\n  get isZero(): boolean {\n    return this.num == 0;\n  }\n\n  get isInfinity(): boolean {\n    return this.den == 0;\n  }\n\n  get isOne(): boolean {\n    return this.num == this.den;\n  }\n\n  get ceil(): number {\n    if (this.num % this.den == 0) {\n      return this.num / this.den;\n    } else {\n      return 1 + Math.floor(this.num / this.den);\n    }\n  }\n\n  get floor(): number {\n    if (this.num % this.den == 0) {\n      return this.num / this.den;\n    } else {\n      return Math.floor(this.num / this.den);\n    }\n  }\n\n  plus(another: Fraction, factorized = false): Fraction {\n    return new Fraction(this.num * another.den + this.den * another.num, this.den * another.den, factorized);\n  }\n\n  plusNum(another: number, factorized = false): Fraction {\n    return new Fraction(this.num + this.den * another, this.den, factorized);\n  }\n\n  minus(another: Fraction, factorized = false): Fraction {\n    return new Fraction(this.num * another.den - this.den * another.num, this.den * another.den, factorized);\n  }\n\n  minusNum(another: number, factorized = false): Fraction {\n    return new Fraction(this.num - this.den * another, this.den, factorized);\n  }\n\n  times(another: Fraction, factorized = false): Fraction {\n    return new Fraction(this.num * another.num, this.den * another.den, factorized);\n  }\n\n  timesNum(another: number, factorized = false): Fraction {\n    return new Fraction(this.num * another, this.den, factorized);\n  }\n\n  divby(another: Fraction, factorized = false): Fraction {\n    return new Fraction(this.num * another.den, this.den * another.num, factorized);\n  }\n\n  divbyNum(another: number, factorized = false): Fraction {\n    return new Fraction(this.num, this.den * another, factorized);\n  }\n\n  /**\n   * Returns another / this.\n   */\n  numDivby(another: number, factorized = false): Fraction {\n    return new Fraction(this.den * another, this.num, factorized);\n  }\n\n  /**\n   * Returns this % another\n   */\n  mod(another: Fraction): Fraction {\n    // a (mod b) = a − b ⌊a / b⌋\n    const d = this.divby(another);\n    const floorOfD = Math.floor(d.num / d.den);\n    return this.minus(another.timesNum(floorOfD));\n  }\n\n  /*\n   * Returns this % another\n   */\n  modNum(another: number): Fraction {\n    // a (mod b) = a − b ⌊a / b⌋\n    const d = this.divbyNum(another);\n    const floorOfD = Math.floor(d.num / d.den);\n    return this.minusNum(another * floorOfD);\n  }\n\n  get inverse(): Fraction {\n    return new Fraction(this.den, this.num);\n  }\n\n  get factorized(): Fraction {\n    const gcd = gcdof(this.num, this.den);\n    return new Fraction(this.num / gcd, this.den / gcd);\n  }\n\n  equals(another: Fraction): boolean {\n    return this.num * another.den == this.den * another.num;\n  }\n\n  equalsNum(another: number): boolean {\n    return this.num == this.den * another;\n  }\n\n  cmp(another: Fraction): number {\n    return this.num * another.den - this.den * another.num;\n  }\n\n  cmpNum(another: number): number {\n    return this.num - this.den * another;\n  }\n\n  isLT(another: Fraction): boolean {\n    return this.cmp(another) < 0;\n  }\n\n  isLTE(another: Fraction): boolean {\n    return this.cmp(another) <= 0;\n  }\n\n  isLTNum(another: number): boolean {\n    return this.cmpNum(another) < 0;\n  }\n\n  isLTENum(another: number): boolean {\n    return this.cmpNum(another) <= 0;\n  }\n\n  isGT(another: Fraction): boolean {\n    return this.cmp(another) > 0;\n  }\n\n  isGTE(another: Fraction): boolean {\n    return this.cmp(another) >= 0;\n  }\n\n  isGTNum(another: number): boolean {\n    return this.cmpNum(another) > 0;\n  }\n\n  isGTENum(another: number): boolean {\n    return this.cmpNum(another) >= 0;\n  }\n\n  toString(): string {\n    return this.num + \"/\" + this.den;\n  }\n\n  static max(f1: Fraction, f2: Fraction): Fraction {\n    return f1.cmp(f2) > 0 ? f1 : f2;\n  }\n\n  static min(f1: Fraction, f2: Fraction): Fraction {\n    return f1.cmp(f2) < 0 ? f1 : f2;\n  }\n}\n\n// Shortcut helper\nexport const Frac = (a = 0, b = 1, factorized = false): Fraction => new Fraction(a, b, factorized);\n","import * as TSU from \"@panyam/tsutils\";\nimport { Entity, TimedEntity } from \"./entity\";\n\n/**\n * Alias to TSU.Num.Fraction in tsutils.\n */\ntype Fraction = TSU.Num.Fraction;\nexport type CyclePosition = [number, number, number];\nexport type CycleIterator = Generator<[CyclePosition, Fraction]>;\n\nconst ZERO = TSU.Num.Fraction.ZERO;\nconst ONE = TSU.Num.Fraction.ONE;\n\n/**\n * A cursor that traverses through a Cycle's beats in a controlled manner.\n * Allows forward and backward navigation through the cycle.\n */\nexport class CycleCursor {\n  /**\n   * Creates a new CycleCursor.\n   * @param cycle The Cycle to traverse\n   * @param barIndex The starting bar index, defaults to 0\n   * @param beatIndex The starting beat index within the bar, defaults to 0\n   * @param instance The starting instance index within the beat, defaults to 0\n   */\n  constructor(\n    public readonly cycle: Cycle,\n    public barIndex = 0,\n    public beatIndex = 0,\n    public instance = 0,\n  ) {}\n\n  /**\n   * Advances the cursor to the next beat and returns the current position and beat length.\n   * @returns A tuple containing the current position and beat length\n   */\n  get next(): [CyclePosition, Fraction] {\n    const currBar = this.cycle.bars[this.barIndex];\n    const result: [CyclePosition, Fraction] = [\n      [this.barIndex, this.beatIndex, this.instance],\n      currBar.beatLengths[this.beatIndex],\n    ];\n    this.instance++;\n    if (!currBar.beatCounts[this.beatIndex] || this.instance >= currBar.beatCounts[this.beatIndex]) {\n      this.instance = 0;\n      this.beatIndex++;\n      if (this.beatIndex >= currBar.beatLengths.length) {\n        this.beatIndex = 0;\n        this.barIndex++;\n        if (this.barIndex >= this.cycle.bars.length) {\n          this.barIndex = 0;\n        }\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Moves the cursor to the previous beat and returns the current position and beat length.\n   * @returns A tuple containing the current position and beat length\n   */\n  get prev(): [CyclePosition, Fraction] {\n    const currBar = this.cycle.bars[this.barIndex];\n    const result: [CyclePosition, Fraction] = [\n      [this.barIndex, this.beatIndex, this.instance],\n      currBar.beatLengths[this.beatIndex],\n    ];\n    // TODO - result should be set *after* decrementing if we had already\n    // done a \"next\" before this otherwise user may have to do a prev twice\n    this.instance--;\n    if (this.instance < 0) {\n      this.beatIndex--;\n      if (this.beatIndex < 0) {\n        this.barIndex--;\n        if (this.barIndex < 0) {\n          this.barIndex = this.cycle.bars.length - 1;\n        }\n        this.beatIndex = this.cycle.bars[this.barIndex].beatCount - 1;\n      }\n      this.instance = (this.cycle.bars[this.barIndex].beatCounts[this.beatIndex] || 1) - 1;\n    }\n    return result;\n  }\n}\n\n/**\n * Represents a bar in a musical cycle.\n * A bar consists of beats with specific lengths and counts.\n */\nexport class Bar extends TimedEntity {\n  readonly TYPE: string = \"Bar\";\n\n  /** Name of the bar (e.g., \"Laghu\", \"Dhrutam\") */\n  name: string;\n\n  /** Length/Duration of each beat in the bar */\n  beatLengths: Fraction[] = [];\n\n  /** How many times each beat should be repeated (the Kalai) */\n  beatCounts: number[] = [];\n\n  /**\n   * Creates a new Bar.\n   * @param config Configuration object containing name, beatLengths, and beatCounts\n   */\n  constructor(config: any = null) {\n    super((config = config || {}));\n    this.name = config.name || \"\";\n    for (const bl of config.beatLengths || []) {\n      if (typeof bl === \"number\") {\n        this.beatLengths.push(TSU.Num.Frac(bl));\n      } else {\n        this.beatLengths.push(bl);\n      }\n    }\n    for (const bc of config.beatCounts || []) {\n      this.beatCounts.push(bc);\n    }\n    while (this.beatCounts.length < this.beatLengths.length) {\n      this.beatCounts.push(1);\n    }\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Bar.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return { ...super.debugValue(), name: name, beatLengths: this.beatLengths };\n  }\n\n  /**\n   * Checks if this Bar is equal to another Bar.\n   * @param another The Bar to compare with\n   * @returns True if the Bars are equal, false otherwise\n   */\n  equals(another: this): boolean {\n    if (!super.equals(another)) return false;\n    if (this.beatLengths.length != another.beatLengths.length) return false;\n    if (this.beatCounts.length != another.beatCounts.length) return false;\n    for (let i = 0; i < this.beatLengths.length; i++) {\n      if (!this.beatLengths[i].equals(another.beatLengths[i])) return false;\n    }\n    for (let i = 0; i < this.beatCounts.length; i++) {\n      if (this.beatCounts[i] != another.beatCounts[i]) return false;\n    }\n    return true;\n  }\n\n  /**\n   * Copies the properties of this Bar to another Bar.\n   * @param another The target Bar to copy properties to\n   */\n  copyTo(another: this): void {\n    super.copyTo(another);\n    another.name = this.name;\n    another.beatLengths = [...this.beatLengths];\n    another.beatCounts = [...this.beatCounts];\n  }\n\n  /**\n   * Gets the instance count for a specific beat in the bar.\n   * @param beatIndex The index of the beat\n   * @returns The number of instances for the specified beat\n   */\n  instanceCount(beatIndex: number): number {\n    if (beatIndex > this.beatCounts.length) {\n      // by default each beat has 1 instance?\n      return 1;\n    } else {\n      return this.beatCounts[beatIndex];\n    }\n  }\n\n  /**\n   * Gets the number of unique beats in this bar (irrespective of instances).\n   */\n  get beatCount(): number {\n    return this.beatLengths.length;\n  }\n\n  /**\n   * Gets the total number of beat instances in this bar.\n   */\n  get totalBeatCount(): number {\n    let out = 0;\n    for (let i = 0; i < this.beatLengths.length; i++) {\n      out += this.beatCounts[i] || 1;\n    }\n    return out;\n  }\n\n  /**\n   * Gets the total duration of time across all beats in this bar.\n   */\n  get duration(): Fraction {\n    let total = ZERO;\n    for (let i = 0; i < this.beatLengths.length; i++) {\n      total = total.plus(this.beatLengths[i].timesNum(this.beatCounts[i] || 1));\n    }\n    return total;\n  }\n}\n\n/**\n * Represents a complete rhythmic cycle pattern composed of bars.\n * In carnatic music, this typically represents a tala.\n */\nexport class Cycle extends TimedEntity {\n  readonly TYPE: string = \"Cycle\";\n\n  /** Name of the cycle (e.g., \"Adi Thalam\") */\n  name: string;\n\n  /** The bars that make up this cycle */\n  bars: Bar[];\n\n  /**\n   * Default cycle representing Adi Thalam (4+2+2 structure).\n   */\n  static readonly DEFAULT = new Cycle({\n    name: \"Adi Thalam\",\n    bars: [\n      new Bar({ name: \"Laghu\", beatLengths: [1, 1, 1, 1] }),\n      new Bar({ name: \"Dhrutam\", beatLengths: [1, 1] }),\n      new Bar({ name: \"Dhrutam\", beatLengths: [1, 1] }),\n    ],\n  });\n\n  /**\n   * Creates a new Cycle.\n   * @param config Configuration object containing name and bars\n   */\n  constructor(config: null | { name?: string; bars?: Bar[] } = null) {\n    super((config = config || {}));\n    this.name = config.name || \"\";\n    this.bars = config.bars || [];\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Cycle.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return { ...super.debugValue(), name: name, bars: this.bars.map((p) => p.debugValue()) };\n  }\n\n  /**\n   * Gets all child entities of this Cycle.\n   * @returns An array of child entities (bars)\n   */\n  children(): Entity[] {\n    return this.bars;\n  }\n\n  /**\n   * Checks if this Cycle is equal to another Cycle.\n   * @param another The Cycle to compare with\n   * @returns True if the Cycles are equal, false otherwise\n   */\n  equals(another: this): boolean {\n    if (!super.equals(another)) {\n      return false;\n    }\n    if (this.bars.length != another.bars.length) return false;\n    for (let i = 0; i < this.bars.length; i++) {\n      if (!this.bars[i].equals(another.bars[i])) return false;\n    }\n    return true;\n  }\n\n  /**\n   * Given a global beat index, returns the position within the cycle.\n   *\n   * @param globalIndex The global beat index\n   * @returns A tuple containing [cycle number, position, start offset]\n   *         - cycle: The nth cycle in which the beat lies\n   *         - position: [barIndex, beatIndex, instance] within the cycle\n   *         - startOffset: Offset of the beat at this global index\n   */\n  getAtIndex(globalIndex: number): [number, CyclePosition, Fraction] {\n    let cycle = 0;\n    while (globalIndex < 0) {\n      globalIndex += this.totalBeatCount;\n      cycle--;\n    }\n    if (globalIndex >= this.totalBeatCount) {\n      cycle = Math.floor(globalIndex / this.totalBeatCount);\n    }\n    globalIndex = globalIndex % this.totalBeatCount;\n    let offset = ZERO;\n    for (let barIndex = 0; barIndex < this.bars.length; barIndex++) {\n      const bar = this.bars[barIndex];\n      if (globalIndex >= bar.totalBeatCount) {\n        globalIndex -= bar.totalBeatCount;\n        offset = offset.plus(bar.duration);\n      } else {\n        // this is the bar!\n        for (let beatIndex = 0; beatIndex < bar.beatCount; beatIndex++) {\n          const beatLength = bar.beatLengths[beatIndex];\n          const beatCount = bar.beatCounts[beatIndex] || 1;\n          if (globalIndex >= beatCount) {\n            globalIndex -= beatCount;\n            offset = offset.plus(beatLength.timesNum(beatCount));\n          } else {\n            // this is it\n            const instance = globalIndex;\n            return [cycle, [barIndex, beatIndex, instance], offset.plus(beatLength.timesNum(instance))];\n          }\n        }\n      }\n    }\n    throw new Error(\"Should not be here!\");\n  }\n\n  /**\n   * Given a global offset, returns the position within the cycle.\n   *\n   * @param globalOffset The global time offset\n   * @returns A tuple containing [cycle number, position, note offset, global index]\n   *         - cycle: The nth cycle in which the offset lies\n   *         - position: [barIndex, beatIndex, instance] within the cycle\n   *         - startOffset: The note offset within the beat\n   *         - globalIndex: The beat index within the entire cycle\n   */\n  getPosition(globalOffset: Fraction): [number, CyclePosition, Fraction, number] {\n    const duration = this.duration;\n    let cycleNum = 0;\n    if (globalOffset.isLT(ZERO)) {\n      while (globalOffset.isLT(ZERO)) {\n        cycleNum--;\n        globalOffset = globalOffset.plus(duration);\n      }\n    } else if (globalOffset.isGTE(duration)) {\n      const realOffset = globalOffset.mod(duration);\n      globalOffset = globalOffset.minus(realOffset).divby(duration);\n      TSU.assert(globalOffset.isWhole);\n      cycleNum = globalOffset.floor;\n      globalOffset = realOffset;\n    }\n\n    // here globalOffset is positive and >= 0 and < this.duration\n    let globalIndex = 0;\n    for (let barIndex = 0; barIndex < this.bars.length; barIndex++) {\n      const bar = this.bars[barIndex];\n      const barDuration = bar.duration;\n      if (globalOffset.isGTE(barDuration)) {\n        globalOffset = globalOffset.minus(barDuration);\n      } else {\n        // this is the bar!\n        for (let beatIndex = 0; beatIndex < bar.beatCount; beatIndex++) {\n          const beatLength = bar.beatLengths[beatIndex];\n          const beatCount = bar.beatCounts[beatIndex] || 1;\n          for (let instance = 0; instance < beatCount; instance++, globalIndex++) {\n            if (globalOffset.isGTE(beatLength)) {\n              globalOffset = globalOffset.minus(beatLength);\n            } else {\n              // this is it\n              return [cycleNum, [barIndex, beatIndex, instance], globalOffset, globalIndex];\n            }\n          }\n        }\n      }\n      globalIndex += bar.totalBeatCount;\n    }\n\n    throw new Error(\"Should not be here!\");\n  }\n\n  /**\n   * Creates an iterator that yields beats in sequence from a starting position.\n   *\n   * @param startBar The starting bar index, defaults to 0\n   * @param startBeat The starting beat index, defaults to 0\n   * @param startInstance The starting instance index, defaults to 0\n   * @returns A generator that yields [position, beat length] pairs\n   */\n  *iterateBeats(startBar = 0, startBeat = 0, startInstance = 0): CycleIterator {\n    let barIndex = startBar;\n    let beatIndex = startBeat;\n    let instanceIndex = startInstance;\n    while (true) {\n      const currBar = this.bars[barIndex];\n      yield [[barIndex, beatIndex, instanceIndex], currBar.beatLengths[beatIndex]];\n      instanceIndex++;\n      if (!currBar.beatCounts[beatIndex] || instanceIndex >= currBar.beatCounts[beatIndex]) {\n        instanceIndex = 0;\n        beatIndex++;\n        if (beatIndex >= currBar.beatLengths.length) {\n          beatIndex = 0;\n          barIndex++;\n          if (barIndex >= this.bars.length) {\n            barIndex = 0;\n          }\n        }\n      }\n    }\n  }\n\n  /**\n   * Copies the properties of this Cycle to another Cycle.\n   * @param another The target Cycle to copy properties to\n   */\n  copyTo(another: this): void {\n    super.copyTo(another);\n    another.name = this.name;\n    another.bars = this.bars.map((x) => x.clone());\n  }\n\n  /**\n   * Gets the number of unique beats in this cycle (irrespective of instances).\n   */\n  get beatCount(): number {\n    let out = 0;\n    for (const bar of this.bars) out += bar.beatCount;\n    return out;\n  }\n\n  /**\n   * Gets the total number of beat instances in this cycle.\n   */\n  get totalBeatCount(): number {\n    let out = 0;\n    for (const bar of this.bars) out += bar.totalBeatCount;\n    return out;\n  }\n\n  /**\n   * Gets the total duration of time across all bars in this cycle.\n   */\n  get duration(): Fraction {\n    return this.bars.reduce((x, y) => x.plus(y.duration), ZERO);\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { Entity, TimedEntity } from \"./entity\";\nimport { LayoutParams } from \"./layouts\";\n\n/**\n * Alias to TSU.Num.Fraction in tsutils.\n */\ntype Fraction = TSU.Num.Fraction;\nexport const ZERO = TSU.Num.Fraction.ZERO;\nexport const ONE = TSU.Num.Fraction.ONE;\n\n/**\n * AtomType enums are used to denote specific Atoms\n * Each type represents a specific musical or notational element.\n * @enum\n */\nexport enum AtomType {\n  NOTE = \"Note\",\n  LITERAL = \"Literal\",\n  SYLLABLE = \"Syllable\",\n  SPACE = \"Space\",\n  GROUP = \"Group\",\n  LABEL = \"Label\",\n  REST = \"Rest\",\n  MARKER = \"Marker\",\n}\n\n/**\n * Atoms are the base class for all timed entities that can appear in a Notation.\n * An Atom represents the fundamental building block of the notation system.\n */\nexport abstract class Atom extends TimedEntity {\n  readonly TYPE: string = \"Atom\";\n\n  protected _duration: Fraction;\n  /** Markers to be displayed before this atom */\n  markersBefore: Marker[];\n  /** Markers to be displayed after this atom */\n  markersAfter: Marker[];\n  /** Next atom in the sequence */\n  nextSibling: TSU.Nullable<Atom> = null;\n  /** Previous atom in the sequence */\n  prevSibling: TSU.Nullable<Atom> = null;\n  /** The Group this Atom belongs to, if any */\n  parentGroup: TSU.Nullable<Group> = null;\n\n  /** Indicates if this Atom is a continuation from a previous atom */\n  isContinuation = false;\n\n  /**\n   * Creates a new Atom with the specified duration.\n   * @param duration The duration of the atom, defaults to ONE (1/1)\n   */\n  constructor(duration = ONE) {\n    super();\n    this._duration = duration || ONE;\n  }\n\n  /**\n   * Splits this atom at the specified duration.\n   * @param requiredDuration The duration at which to split the atom\n   * @returns A new atom representing the portion beyond the split point, or null if no split is needed\n   */\n  abstract splitAt(requiredDuration: Fraction): TSU.Nullable<Atom>;\n\n  /**\n   * Returns a debug-friendly representation of this Atom.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    const out = super.debugValue();\n    if (!this.duration.isOne) {\n      out.duration = this.duration.factorized.toString();\n    }\n    if (this.isContinuation) {\n      out.isContinuation = true;\n    }\n    if ((this.markersBefore || []).length > 0) {\n      out.mbef = this.markersBefore.map((m) => m.debugValue());\n    }\n    if ((this.markersAfter || []).length > 0) {\n      out.maft = this.markersAfter.map((m) => m.debugValue());\n    }\n    return out;\n  }\n\n  /**\n   * Copies the properties of this atom to another atom.\n   * @param another The target atom to copy properties to\n   */\n  copyTo(another: this): void {\n    super.copyTo(another);\n    another._duration = new TSU.Num.Fraction(this.duration.num, this.duration.den);\n  }\n\n  /**\n   * Gets the duration of this atom.\n   */\n  get duration(): Fraction {\n    return this._duration;\n  }\n\n  /**\n   * Sets the duration of this atom.\n   */\n  set duration(d: Fraction) {\n    this._duration = d;\n  }\n}\n\n/**\n * Base class for atoms that cannot contain other atoms.\n * LeafAtom represents atomic elements that can't be further subdivided.\n */\nexport abstract class LeafAtom extends Atom {\n  readonly TYPE: string = \"LeafAtom\";\n\n  /** Indicates if this atom is followed by a rest */\n  beforeRest = false;\n\n  /**\n   * Splits this atom at a certain duration.\n   * If this atom's duration is longer than the given duration, it's truncated\n   * to the given duration and a continuation space is returned.\n   *\n   * @param duration The duration at which to split the atom\n   * @returns A new Space atom representing the spillover if needed, otherwise null\n   */\n  splitAt(duration: Fraction): TSU.Nullable<Atom> {\n    if (this.duration.cmp(duration) > 0) {\n      const spillOver = this.createSpilloverSpace(this.duration.minus(duration));\n      spillOver.isContinuation = true;\n      this.duration = duration;\n      // TODO - Here we need to move the markersAfter to the spill-over as it doesnt belong to this any more\n      return spillOver;\n    }\n    return null;\n  }\n\n  /**\n   * Creates a Space atom to represent spillover duration when splitting.\n   * @param duration The duration of the spillover\n   * @returns A new Space atom\n   */\n  protected createSpilloverSpace(duration: Fraction): Space {\n    return new Space(duration);\n  }\n\n  /**\n   * Returns a debug-friendly representation of this LeafAtom.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return this.beforeRest ? { ...super.debugValue(), beforeRest: true } : super.debugValue();\n  }\n}\n\n/**\n * Represents a marker or annotation in the notation.\n * Markers can be placed before or after atoms to provide additional context.\n */\nexport class Marker extends Entity {\n  readonly TYPE = \"Marker\";\n\n  /**\n   * Creates a new Marker with the specified text.\n   * @param text The text content of the marker\n   * @param isBefore Whether the marker should appear before (true) or after (false) its associated atom\n   */\n  constructor(\n    public text: string,\n    public isBefore = true,\n  ) {\n    super();\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Marker.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return { ...super.debugValue(), text: this.text, before: this.isBefore };\n  }\n\n  /**\n   * Returns a string representation of this Marker.\n   * @returns A string representation\n   */\n  toString(): string {\n    return `Marker(${this.text}-${this.isBefore})`;\n  }\n}\n\n/**\n * Represents a rest (silence) in the notation.\n * Rests are zero-length atoms that indicate a pause.\n */\nexport class Rest extends LeafAtom {\n  readonly TYPE = \"Rest\";\n\n  /**\n   * Creates a new Rest.\n   * Rests are zero length by default.\n   */\n  constructor() {\n    super(ZERO);\n  }\n}\n\n/**\n * Represents a space or silence in the notation.\n * Spaces can be used to denote either silence or continuations of previous notes.\n */\nexport class Space extends LeafAtom {\n  readonly TYPE = \"Space\";\n\n  /**\n   * Indicates whether this is a silent space or a continuation of the previous note.\n   */\n  isSilent = false;\n\n  /**\n   * Creates a new Space with the specified duration and silence property.\n   * @param duration The duration of the space, defaults to ONE (1/1)\n   * @param isSilent Whether the space represents silence (true) or a continuation (false)\n   */\n  constructor(duration = ONE, isSilent = false) {\n    super(duration);\n    this.isSilent = isSilent;\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Space.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return { ...super.debugValue(), isSilent: this.isSilent };\n  }\n\n  /**\n   * Returns a string representation of this Space.\n   * @returns A string representation\n   */\n  toString(): string {\n    return `Space(${this.duration}-${this.isSilent})`;\n  }\n\n  /**\n   * Copies the properties of this Space to another Space.\n   * @param another The target Space to copy properties to\n   */\n  copyTo(another: this): void {\n    super.copyTo(another);\n    another.isSilent = this.isSilent;\n  }\n\n  /**\n   * Checks if this Space is equal to another Space.\n   * @param another The Space to compare with\n   * @returns True if the Spaces are equal, false otherwise\n   */\n  equals(another: this): boolean {\n    return super.equals(another) && this.isSilent == another.isSilent;\n  }\n\n  /**\n   * Creates a Space atom to represent spillover duration when splitting.\n   * @param duration The duration of the spillover\n   * @returns A new Space atom with the same silence property as this Space\n   */\n  protected createSpilloverSpace(duration: Fraction): Space {\n    const out = super.createSpilloverSpace(duration);\n    out.isSilent = this.isSilent;\n    return out;\n  }\n}\n\n/**\n * Represents a literal value in the notation.\n * Literals are the basic building blocks for notes and syllables.\n */\nexport class Literal extends LeafAtom {\n  readonly TYPE: string = \"Literal\";\n\n  /**\n   * The embellishments applied to this Literal.\n   */\n  embelishments: any[] = [];\n\n  /**\n   * Creates a new Literal with the specified value and duration.\n   * @param value The string value of the literal\n   * @param duration The duration of the literal, defaults to ONE (1/1)\n   */\n  constructor(\n    public value: string,\n    duration = ONE,\n  ) {\n    super(duration);\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Literal.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    const out = { ...super.debugValue(), value: this.value };\n    if (this.embelishments.length > 0) {\n      out.embs = this.embelishments.map((e) => (\"debugValue\" in e ? e.debugValue() : e));\n    }\n    return out;\n  }\n\n  /**\n   * Returns a string representation of this Literal.\n   * @returns A string representation\n   */\n  toString(): string {\n    return `Lit(${this.duration}-${this.value})`;\n  }\n\n  /**\n   * Checks if this Literal is equal to another Literal.\n   * @param another The Literal to compare with\n   * @returns True if the Literals are equal, false otherwise\n   */\n  equals(another: this): boolean {\n    return super.equals(another) && this.value == another.value;\n  }\n\n  /**\n   * Copies the properties of this Literal to another Literal.\n   * @param another The target Literal to copy properties to\n   */\n  copyTo(another: this): void {\n    super.copyTo(another);\n    another.value = this.value;\n  }\n}\n\n/**\n * Represents a syllable in lyrics or text to be sung.\n * Extends Literal to provide specialized handling for sung text.\n */\nexport class Syllable extends Literal {\n  readonly TYPE = \"Syllable\";\n\n  /**\n   * Creates a Syllable from a Literal.\n   * @param lit The Literal to convert to a Syllable\n   * @returns A new Syllable with the properties of the Literal\n   */\n  static fromLit(lit: Literal): Syllable {\n    if (lit.TYPE == AtomType.SYLLABLE) return lit as Syllable;\n    const out = new Syllable(lit.value, lit.duration);\n    out.embelishments = lit.embelishments;\n    out.beforeRest = lit.beforeRest;\n    return out;\n  }\n\n  /**\n   * Returns a string representation of this Syllable.\n   * @returns A string representation\n   */\n  toString(): string {\n    return `Syll(${this.duration}-${this.value})`;\n  }\n}\n\n/**\n * Represents a musical note in the notation.\n * Extends Literal to add properties specific to musical notes.\n */\nexport class Note extends Literal {\n  readonly TYPE = \"Note\";\n\n  /**\n   * Which octave the note is in. Can be positive or negative to indicate higher or lower octaves.\n   */\n  octave = 0;\n\n  /**\n   * How the note is shifted - i.e., shifted towards major or minor by # of semi-tones.\n   */\n  shift: number | boolean = 0;\n\n  /**\n   * Creates a new Note with the specified properties.\n   * @param value The string value of the note\n   * @param duration The duration of the note, defaults to ONE (1/1)\n   * @param octave The octave of the note, defaults to 0\n   * @param shift The shift of the note, defaults to 0\n   */\n  constructor(value: string, duration = ONE, octave = 0, shift = 0) {\n    super(value, duration);\n    this.octave = octave;\n    this.shift = shift;\n  }\n\n  /**\n   * Creates a Note from a Literal.\n   * @param lit The Literal to convert to a Note\n   * @returns A new Note with the properties of the Literal\n   */\n  static fromLit(lit: Literal): Note {\n    if (lit.TYPE == AtomType.NOTE) return lit as Note;\n    const out = new Note(lit.value, lit.duration);\n    out.embelishments = lit.embelishments;\n    out.beforeRest = lit.beforeRest;\n    return out;\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Note.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    const out = { ...super.debugValue() };\n    if (this.octave != 0) out.octave = this.octave;\n    if (this.shift != 0) out.shift = this.shift;\n    return out;\n  }\n\n  /**\n   * Returns a string representation of this Note.\n   * @returns A string representation\n   */\n  toString(): string {\n    return `Note(${this.duration}-${this.value}-${this.octave})`;\n  }\n\n  /**\n   * Checks if this Note is equal to another Note.\n   * @param another The Note to compare with\n   * @returns True if the Notes are equal, false otherwise\n   */\n  equals(another: this): boolean {\n    return super.equals(another) && this.octave == another.octave && this.shift == another.shift;\n  }\n\n  /**\n   * Copies the properties of this Note to another Note.\n   * @param another The target Note to copy properties to\n   */\n  copyTo(another: this): void {\n    super.copyTo(another);\n    another.octave = this.octave;\n    another.shift = this.shift;\n  }\n}\n\n/**\n * Represents a group of atoms that are treated as a single unit.\n * Groups can contain any number of atoms, including other groups.\n */\nexport class Group extends Atom {\n  readonly TYPE = \"Group\";\n\n  /**\n   * Indicates whether the duration is static or linear to the number of atoms in this group.\n   * When true, the duration is used as a multiplier for the total child duration.\n   * When false, the duration is absolute.\n   */\n  durationIsMultiplier = false;\n\n  /**\n   * The list of atoms in this group.\n   */\n  readonly atoms = new TSU.Lists.ValueList<Atom>();\n\n  /**\n   * Creates a new Group containing the specified atoms.\n   * @param atoms The atoms to include in this group\n   */\n  constructor(...atoms: Atom[]) {\n    super(atoms.length == 0 ? ZERO : ONE);\n    this.addAtoms(false, ...atoms);\n  }\n\n  /**\n   * Checks if this Group is equal to another Group.\n   * @param another The Group to compare with\n   * @param expect Optional parameter\n   * @returns True if the Groups are equal, false otherwise\n   */\n  equals(another: this, expect = false): boolean {\n    if (!super.equals(another)) return false;\n    return this.atoms.equals(another.atoms, (a1, a2) => a1.equals(a2));\n  }\n\n  /**\n   * Copies the properties of this Group to another Group.\n   * @param another The target Group to copy properties to\n   */\n  copyTo(another: this): void {\n    super.copyTo(another);\n    another.durationIsMultiplier = this.durationIsMultiplier;\n    this.atoms.forEach((atom) => another.atoms.add(atom.clone()));\n  }\n\n  /**\n   * Gets the duration of this group.\n   * If durationIsMultiplier is true, returns the total child duration divided by the multiplier.\n   * Otherwise, returns the absolute duration.\n   */\n  get duration(): Fraction {\n    if (this.durationIsMultiplier) {\n      return this.totalChildDuration.divby(this._duration);\n    } else {\n      return this._duration;\n    }\n  }\n\n  /**\n   * Sets this group to use a multiplier for duration calculations.\n   * @param asMultiplier Whether to use the duration as a multiplier\n   * @returns This Group instance for method chaining\n   */\n  setDurationAsMultiplier(asMultiplier = true): this {\n    this.durationIsMultiplier = asMultiplier;\n    return this;\n  }\n\n  /**\n   * Sets the duration of this group.\n   * @param d The new duration\n   * @param asMultiplier Whether to use the duration as a multiplier\n   * @returns This Group instance for method chaining\n   */\n  setDuration(d: Fraction, asMultiplier = false): this {\n    this._duration = d;\n    this.durationIsMultiplier = asMultiplier;\n    return this;\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Group.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    const out = { ...super.debugValue(), atoms: Array.from(this.atoms.values(), (a) => a.debugValue()) };\n    if (this.durationIsMultiplier) out.durationIsMultiplier = true;\n    return out;\n  }\n\n  /**\n   * Splits this group into two parts.\n   * The first part (this group) fits within the given duration and everything else\n   * longer than the given duration is returned as a new Group.\n   *\n   * @param requiredDuration The duration at which to split the group\n   * @returns A new Group containing the atoms beyond the split point, or null if no split is needed\n   */\n  splitAt(requiredDuration: Fraction): TSU.Nullable<Group> {\n    if (this.duration.isLTE(requiredDuration) || requiredDuration.isLTE(ZERO)) {\n      return null;\n    }\n    const targetGroup = new Group();\n    if (this.durationIsMultiplier) {\n      targetGroup.durationIsMultiplier = true;\n      targetGroup._duration = this._duration;\n    }\n\n    let remainingDur = this.duration;\n    const totalChildDuration = this.totalChildDuration;\n    const durationFactor = this.durationIsMultiplier\n      ? ONE.divby(this._duration)\n      : this._duration.divby(totalChildDuration, true);\n    while (remainingDur.isGT(requiredDuration) && this.atoms.last) {\n      const lastChild = this.atoms.last;\n      // Child's duration is absolute in its own \"system\"\n      // Its duration within the parent (this) group's frame of reference depends\n      // on whether the parent's duration is absolute or as a multiplier\n      //\n      // realChildDuration = case (group.durationIsMultiper) {\n      //  | true  => child.duration / this._duration\n      //  | false => child.duration * this._duration / total child duration\n      //  }\n      const childDuration = lastChild.duration.times(durationFactor);\n      const newDuration = remainingDur.minus(childDuration);\n      if (newDuration.isGTE(requiredDuration)) {\n        // remove ourselves and add to target\n        // in both cases duration will be adjusted if need be\n        this.removeAtoms(true, lastChild);\n        targetGroup.insertAtomsAt(targetGroup.atoms.first, true, lastChild);\n        if (newDuration.equals(requiredDuration)) {\n          // we have reached the end so return\n          return targetGroup;\n        }\n      } else {\n        // our scenario is now this:\n        //\n        // totalParentDuration = 10\n        // required = 8\n        // lastChildDuration (relative to parent) is 5\n        //\n        // durWithoutLast = 10 - 5\n        // newRequired = requiredDur - durWithoutLast = 3\n        //\n        // However 3 is a duration in the parent's frame of reference\n        // this has to be converted back to the child's FoR\n        const newRequiredDur = requiredDuration.minus(newDuration, true).divby(durationFactor, true);\n        // console.log( \"newRequiredDur: \", newRequiredDur, \"requiedDur: \", requiredDuration, \"remainingDur: \", remainingDur,);\n        // then the last item needs to be split, and by how much?\n        const spillOver = lastChild.splitAt(newRequiredDur);\n        if (spillOver == null) {\n          throw new Error(\"Spill over cannot be null here\");\n        }\n        if (!this.durationIsMultiplier) {\n          // Our own duration has also now changed\n          this._duration = requiredDuration;\n        } else {\n          if (this._duration.isZero) throw new Error(\"How can this be?\");\n        }\n        spillOver.isContinuation = true;\n        // Add spill over to the target\n        targetGroup.insertAtomsAt(targetGroup.atoms.first, true, spillOver);\n        return targetGroup;\n      }\n      remainingDur = newDuration;\n    }\n    return targetGroup;\n  }\n\n  /**\n   * Gets the total duration of all child atoms.\n   * @returns The sum of durations of all atoms in this group\n   */\n  get totalChildDuration(): Fraction {\n    let out = ZERO;\n    this.atoms.forEach((atom) => (out = out.plus(atom.duration)));\n    return out;\n  }\n\n  /**\n   * Inserts atoms before a given cursor atom.\n   * If the cursor atom is null, the atoms are appended at the end.\n   *\n   * @param beforeAtom The atom before which to insert the new atoms, or null to append\n   * @param adjustDuration Whether to adjust this group's duration based on the new atoms\n   * @param atoms The atoms to insert\n   * @returns This Group instance for method chaining\n   */\n  insertAtomsAt(beforeAtom: TSU.Nullable<Atom>, adjustDuration = false, ...atoms: Atom[]): this {\n    adjustDuration = adjustDuration && !this.durationIsMultiplier;\n    const oldChildDuration = adjustDuration ? this.totalChildDuration : ONE;\n    // First form a chain of the given atoms\n    for (const atom of atoms) {\n      if (atom.parentGroup != null) {\n        if (atom.parentGroup != this) {\n          throw new Error(\"Atom belongs to another parent. Remove it first\");\n        }\n        atom.parentGroup.removeAtoms(false, atom);\n      }\n      if (atom.TYPE == AtomType.REST) {\n        const last = this.atoms.last;\n        if (last && last.TYPE != AtomType.GROUP && last.TYPE != AtomType.LABEL) {\n          (last as LeafAtom).beforeRest = true;\n        }\n      } else {\n        atom.parentGroup = this;\n        this.atoms.add(atom, beforeAtom);\n      }\n    }\n    if (adjustDuration) {\n      if (this._duration.isZero) {\n        if (this.durationIsMultiplier) throw new Error(\"How can this be?\");\n        this._duration = this.totalChildDuration;\n      } else {\n        const scaleFactor = this.totalChildDuration.divby(oldChildDuration);\n        this._duration = this._duration.times(scaleFactor, true);\n      }\n    }\n    return this;\n  }\n\n  /**\n   * Adds atoms to the end of this group's atom list.\n   *\n   * @param adjustDuration Whether to adjust this group's duration based on the new atoms\n   * @param atoms The atoms to add\n   * @returns This Group instance for method chaining\n   */\n  addAtoms(adjustDuration = false, ...atoms: Atom[]): this {\n    return this.insertAtomsAt(null, adjustDuration, ...atoms);\n  }\n\n  /**\n   * Removes atoms from this group's child list.\n   *\n   * @param adjustDuration Whether to adjust this group's duration after removing atoms\n   * @param atoms The atoms to remove\n   * @returns This Group instance for method chaining\n   */\n  removeAtoms(adjustDuration = false, ...atoms: Atom[]): this {\n    adjustDuration = adjustDuration && !this.durationIsMultiplier;\n    const oldChildDuration = adjustDuration ? this.totalChildDuration : ONE;\n    for (const atom of atoms) {\n      if (atom.parentGroup == this) {\n        this.atoms.remove(atom);\n        atom.parentGroup = null;\n      } else if (atom.parentGroup != null) {\n        throw new Error(\"Atom cannot be removed as it does not belong to this group\");\n      }\n    }\n    if (adjustDuration) {\n      if (this._duration.isZero) {\n        if (this.durationIsMultiplier) throw new Error(\"How can this be?\");\n        this._duration = this.totalChildDuration;\n      } else {\n        const scaleFactor = this.totalChildDuration.divby(oldChildDuration);\n        this._duration = this._duration.times(scaleFactor, true);\n      }\n    }\n    return this;\n  }\n}\n\n/**\n * Represents a line of notation containing multiple roles.\n * A line can have atoms starting before or after the cycle.\n */\nexport class Line extends Entity {\n  readonly TYPE: string = \"Line\";\n\n  /**\n   * Offset tells how many notes before or after the cycle this line's atoms start at.\n   */\n  offset: Fraction = ZERO;\n\n  /**\n   * The roles contained in this line.\n   */\n  roles: Role[] = [];\n\n  /**\n   * Text to be displayed in the margin of the line.\n   * This is a hacky solution to doing left side pre-margin text typically\n   * found in notations - e.g., line X of a pallavi has this. This makes vertical\n   * space less wasteful.\n   *\n   * A better solution is inter-beat annotation but it is very complex for now.\n   */\n  marginText = \"\";\n\n  /**\n   * The LayoutParams associated with this line.\n   */\n  layoutParams: LayoutParams;\n\n  /**\n   * Finds the index of a role with the given name.\n   * @param name The name of the role to find\n   * @returns The index of the role, or -1 if not found\n   */\n  indexOfRole(name: string): number {\n    for (let i = 0; i < this.roles.length; i++) {\n      if (this.roles[i].name == name) return i;\n    }\n    return -1;\n  }\n\n  /**\n   * Checks if this line is empty (has no content in any role).\n   */\n  get isEmpty(): boolean {\n    for (const r of this.roles) if (!r.isEmpty) return false;\n    return true;\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Line.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    const out = {\n      ...super.debugValue(),\n      roles: this.roles.map((r) => r.debugValue()),\n    };\n    if (!this.offset.isZero) {\n      out.offset = this.offset.toString();\n    }\n    return out;\n  }\n\n  /**\n   * Copies the properties of this Line to another Line.\n   * @param another The target Line to copy properties to\n   */\n  copyTo(another: this): void {\n    super.copyTo(another);\n    another.roles = this.roles.map((r) => r.clone());\n  }\n\n  /**\n   * Adds atoms to a role in this line.\n   * @param roleName The name of the role to add atoms to\n   * @param defaultToNotes Whether to default to notes for this role\n   * @param atoms The atoms to add\n   * @returns This Line instance for method chaining\n   */\n  addAtoms(roleName: string, defaultToNotes: boolean, ...atoms: Atom[]): this {\n    const role = this.ensureRole(roleName, defaultToNotes);\n    role.addAtoms(...atoms);\n    return this;\n  }\n\n  /**\n   * Ensures a role with the given name exists in this line, creating it if needed.\n   * @param roleName The name of the role to ensure\n   * @param defaultToNotes Whether to default to notes for this role\n   * @returns The role with the specified name\n   */\n  ensureRole(roleName: string, defaultToNotes: boolean): Role {\n    // Ensure we have this many roles\n    let ri = this.roles.findIndex((r) => r.name == roleName);\n    if (ri < 0) {\n      ri = this.roles.length;\n      const role = new Role(this, roleName);\n      role.defaultToNotes = defaultToNotes;\n      this.roles.push(role);\n    }\n    return this.roles[ri];\n  }\n\n  /**\n   * Gets the maximum duration across all roles in this line.\n   */\n  get duration(): Fraction {\n    let max = ZERO;\n    for (const role of this.roles) {\n      max = TSU.Num.Fraction.max(role.duration, max);\n    }\n    return max;\n  }\n}\n\n/**\n * Represents a specific role or voice in a line of notation.\n * Each role contains a sequence of atoms.\n */\nexport class Role extends Entity {\n  readonly TYPE = \"Role\";\n\n  /**\n   * Whether this role represents notes by default.\n   */\n  defaultToNotes = true;\n\n  /**\n   * The atoms in this role.\n   */\n  atoms: Atom[] = [];\n\n  /**\n   * Creates a new Role with the specified line and name.\n   * @param line The line this role belongs to\n   * @param name The name of the role\n   */\n  constructor(\n    public readonly line: Line,\n    public readonly name: string,\n  ) {\n    super();\n  }\n\n  /**\n   * Checks if this role is empty (has no atoms).\n   */\n  get isEmpty(): boolean {\n    return this.atoms.length == 0;\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Role.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return { name: this.name, atoms: this.atoms.map((a) => a.debugValue()) };\n  }\n\n  /**\n   * Adds atoms to this role.\n   * @param atoms The atoms to add\n   */\n  addAtoms(...atoms: Atom[]): void {\n    let last: null | Atom = null;\n    for (const atom of atoms) {\n      if (atom.TYPE == AtomType.REST) {\n        if (last && last.TYPE != AtomType.GROUP && last.TYPE != AtomType.LABEL) {\n          (last as LeafAtom).beforeRest = true;\n        }\n      } else {\n        this.atoms.push(atom);\n      }\n      last = atom;\n    }\n  }\n\n  /**\n   * Copies the properties of this Role to another Role.\n   * @param another The target Role to copy properties to\n   */\n  copyTo(another: Role): void {\n    another.addAtoms(...this.atoms);\n  }\n\n  /**\n   * Gets the total duration of all atoms in this role.\n   */\n  get duration(): Fraction {\n    return this.atoms.reduce((a, b) => a.plus(b.duration), ZERO);\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { Cycle, CyclePosition, CycleCursor } from \"./cycle\";\n\ntype Fraction = TSU.Num.Fraction;\nconst ZERO = TSU.Num.Fraction.ZERO;\n\n/**\n * Manages layout parameters for arranging beats and notes in the notation.\n * LayoutParams determines how beats are organized into lines and rows based on\n * cycle patterns and line breaks.\n */\nexport class LayoutParams {\n  private static counter = 0;\n  /** Unique identifier for this layout parameters instance */\n  readonly uuid = LayoutParams.counter++;\n\n  /** Duration of a single beat (multiplier for beat lengths) */\n  beatDuration: number;\n\n  /** The cycle pattern to use for this layout */\n  cycle: Cycle;\n\n  /** The pattern of line breaks to apply */\n  protected _lineBreaks: number[];\n\n  /** Cache of row start offsets */\n  private _rowStartOffsets: Fraction[];\n\n  /** Cache of row end offsets */\n  private _rowEndOffsets: Fraction[];\n\n  /** Cache of row durations */\n  private _rowDurations: Fraction[];\n\n  /** Total duration of the layout pattern */\n  private _totalLayoutDuration;\n\n  /** Cached beat layout information */\n  private _beatLayouts: [CyclePosition, Fraction][][];\n\n  /** Total number of beats across all layout lines */\n  private _totalBeats: number;\n\n  /**\n   * Creates a new LayoutParams instance.\n   * @param config Configuration object containing beatDuration, cycle, and lineBreaks\n   */\n  constructor(config?: any) {\n    config = config || {};\n    this.beatDuration = config.beatDuration || 1;\n    if (\"cycle\" in config) this.cycle = config.cycle;\n    if (!this.cycle || this.cycle.duration.isZero) {\n      this.cycle = Cycle.DEFAULT;\n    }\n\n    this._rowStartOffsets = [];\n    this._rowEndOffsets = [];\n    this._rowDurations = [];\n    this._totalLayoutDuration = ZERO;\n    this._totalBeats = 0;\n    this._beatLayouts = [];\n    this.lineBreaks = config.lineBreaks || config.layout || [];\n  }\n\n  /**\n   * Checks if this LayoutParams is equal to another LayoutParams.\n   * @param another The LayoutParams to compare with\n   * @returns True if the LayoutParams are equal, false otherwise\n   */\n  equals(another: this): boolean {\n    return (\n      // super.equals(another) &&\n      this.beatDuration == another.beatDuration &&\n      this.cycle.equals(another.cycle) &&\n      this.lineBreaksEqual(another._lineBreaks)\n    );\n  }\n\n  /**\n   * Checks if the line breaks pattern is equal to another pattern.\n   * @param another The line breaks pattern to compare with\n   * @returns True if the patterns are equal, false otherwise\n   */\n  lineBreaksEqual(another: number[]): boolean {\n    return this._lineBreaks.length == another.length && this._lineBreaks.every((x, i) => x == another[i]);\n  }\n\n  /**\n   * Returns a debug-friendly representation of this LayoutParams.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return {\n      // ...super.debugValue(),\n      cycle: this.cycle?.debugValue(),\n      beatDuration: this.beatDuration,\n      lineBreaks: this._lineBreaks,\n    };\n  }\n\n  /**\n   * Returns the \"location\" of a beat within a layout.\n   *\n   * Lines are broken into beats of notes and those beats are aligned as per\n   * the specs in the LayoutParams (breaks). For example if the breaks param\n   * stipulates [5, 5, 4] then we have 5 beats in the first 2 lines and 4 in\n   * the last line.\n   *\n   * @param beat The beat to locate\n   * @returns A tuple containing [layoutLine, layoutColumn, rowOffset]\n   *         - layoutLine: The line in the layout break spec this beat falls in\n   *         - layoutColumn: The column within the layoutLine\n   *         - rowOffset: The offset of the beat from the start of the row/line\n   */\n  getBeatLocation(beat: {\n    index: number;\n    barIndex: number;\n    beatIndex: number;\n    instance: number;\n  }): [number, number, Fraction] {\n    //\n    // If a line contains say 50 beats (B1 - B50), then it is laid out as:\n    //\n    //      C0  C1  C2  C3  C4\n    //    ---------------------\n    // L0 | B1  B2  B3  B4  B5\n    // L1 | B6  B7  B8  B9  B10\n    // L2 | B11 B12 B13 B14\n    // L0 | B15 B16 B17 B18 B19\n    // L1 | B20 B21 B22 B23 B24\n    // L2 | B25 B26 B27 B28\n    // L0 | B29 B30 B31 B32 B33\n    // L1 | B34 B35 B36 B37 B38\n    // L2 | B39 B40 B41 B42\n    // L0 | B43 B44 B45 B46 B47\n    // L1 | B48 B49 B50\n    //\n    // This methods returns the triple: [layoutLine, layoutColumn, rowOffset]\n    // where\n    //\n    //  layoutLine: The particular line in the layout break spec this index falls in.\n    //              *Note*: Since lines can start with negative offsets, we can\n    //              even return a layoutLine that is towards the end and then go\n    //              back to 0, eg 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4 ...\n    //              (eg returns L0 or L1 ... Ln)\n    //  layoutColumn: The column within the layoutLine line where this beat falls.\n    //                (eg C0 - C4 above - or depending on how many columns exist\n    //                in the particular layout line).\n    //  rowOffset: The note offset of the beat from the start of the row/line\n    //             (not from the start of the cycle).\n    //\n    // Note the beatIndex can also be negative so we can return a beat\n    // starting from before the cycle starting point.\n    //\n    //  To calculate the \"real\" line globally simply do:\n    //\n    //    realLine = lineBreaks.length  // Math.floor(beatIndex / this.totalBeats) + layoutLine;\n    //\n    // Some examples here are (using B1-B50 above):\n    const modIndex = beat.index % this.totalBeats;\n    let total = 0;\n    for (let i = 0; i < this._lineBreaks.length; i++) {\n      if (modIndex < total + this._lineBreaks[i]) {\n        // TODO: What is the right offset here?\n        let offset = ZERO;\n        if (modIndex > total) {\n          const cursor = new CycleCursor(this.cycle, beat.barIndex, beat.beatIndex, beat.instance);\n          let [, duration] = cursor.prev;\n          for (let i = total; i < modIndex; i++) {\n            [, duration] = cursor.prev;\n            offset = offset.plus(duration.timesNum(this.beatDuration));\n          }\n        }\n        return [i, modIndex - total, offset];\n      }\n      total += this._lineBreaks[i];\n    }\n    throw new Error(\"Invalid beat index: \" + beat.index);\n    return [-1, -1, ZERO];\n  }\n\n  /**\n   * Gets the line layout pattern - i.e., number of beats in each line - as a\n   * repeating pattern.\n   *\n   * For example 4,2,4 indicates that the notes in our song should be\n   * laid out 4 beats in line 1, 2 beats in line 2, 4 beats in line 3 and\n   * 4 beats in line 4 and so on as long as there are more notes available\n   * in this line.\n   */\n  get lineBreaks(): number[] {\n    if (!this._lineBreaks || this._lineBreaks.length == 0) {\n      // trigger a refresh\n      this.lineBreaks = [this.cycle.beatCount];\n    }\n    return this._lineBreaks;\n  }\n\n  /**\n   * Sets the line layout pattern.\n   */\n  set lineBreaks(val: number[]) {\n    this._lineBreaks = val;\n    this.refreshLayout();\n  }\n\n  /**\n   * Returns the number of beats in each line based on the line layout\n   * after taking beatDuration into account.\n   */\n  get beatLayouts(): ReadonlyArray<ReadonlyArray<[CyclePosition, Fraction]>> {\n    if (!this._beatLayouts || this._beatLayouts.length < this.lineBreaks.length) {\n      this.refreshLayout();\n    }\n    return this._beatLayouts;\n  }\n\n  /**\n   * Gets the total number of beats across all lines in the layout pattern.\n   */\n  get totalBeats(): number {\n    this.beatLayouts;\n    return this._totalBeats;\n  }\n\n  /**\n   * Gets the total duration of all beats across all lines in the layout pattern.\n   */\n  get totalLayoutDuration(): Fraction {\n    this.beatLayouts;\n    return this._totalLayoutDuration;\n  }\n\n  /**\n   * Refreshes the layout calculations based on the current cycle and line breaks.\n   * This rebuilds the beat layouts, row durations, and offset information.\n   */\n  protected refreshLayout(): void {\n    const cycleIter = this.cycle.iterateBeats();\n    const akb = this.beatDuration;\n    this._beatLayouts = this.lineBreaks.map((numBeats, index) => {\n      const beats: [CyclePosition, Fraction][] = [];\n      // see what the beat lengths are here\n      for (let i = 0; i < numBeats; i++) {\n        const nextCP = cycleIter.next().value;\n        nextCP[1] = nextCP[1].timesNum(akb);\n        beats.push(nextCP);\n      }\n      return beats;\n    });\n    this._totalBeats = this.lineBreaks.reduce((a, b) => a + b, 0);\n    this._rowDurations = this._beatLayouts.map((beats) => beats.reduce((x, y) => x.plus(y[1]), ZERO));\n    this._rowDurations.forEach((rd, index) => {\n      this._rowStartOffsets[index] = index == 0 ? ZERO : this._rowStartOffsets[index - 1].plus(rd);\n    });\n    this._rowEndOffsets = this._rowDurations.map((rd, index) => {\n      return this._rowStartOffsets[index].plus(rd);\n    });\n    this._totalLayoutDuration = this._rowDurations.reduce((x, y) => x.plus(y), ZERO);\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\n// import * as kiwi from \"@lume/kiwi\";\n\n/**\n * Event emitted when layout changes occur in a GridLayoutGroup.\n * Subscribers can use this to update their views incrementally.\n */\nexport interface LayoutChangeEvent {\n  /** The range of rows affected by the change */\n  affectedRowRange: { start: number; end: number } | null;\n  /** The range of columns affected by the change */\n  affectedColRange: { start: number; end: number } | null;\n  /** Whether column widths changed (requires horizontal re-layout) */\n  columnWidthsChanged: boolean;\n  /** Whether row heights changed (requires vertical re-layout) */\n  rowHeightsChanged: boolean;\n  /** The grid models that were affected */\n  affectedGridModels: GridModel[];\n}\n\n/**\n * Callback type for layout change subscribers.\n */\nexport type LayoutChangeCallback = (event: LayoutChangeEvent) => void;\n\n/**\n * A generic grid layout system for hosting child views (similar to GridBagLayout).\n * This provides a framework for hosting BeatViews in a structured grid arrangement,\n * with support for rows, columns, and alignment.\n *\n * Grid \"cells\" can be referred to by cell indexes. Additionally, grid rows and\n * columns can have names (like in spreadsheets) so that even when rows and columns\n * are inserted, though indexes may change, the \"addresses\" remain fixed and immovable.\n */\nexport class GridModel extends TSU.Events.EventEmitter {\n  private static idCounter = 0;\n  readonly uuid = GridModel.idCounter++;\n  /** Timestamp of the last update to this grid */\n  lastUpdatedAt = 0;\n  // cells = new SparseArray<SparseArray<GridCell>>();\n  /** The rows in this grid */\n  rows: GridRow[] = [];\n  /** Mapping of row indices to row alignment objects */\n  rowAligns = new Map<number, RowAlign>();\n  /** Mapping of column indices to column alignment objects */\n  colAligns = new Map<number, ColAlign>();\n\n  /**\n   * Returns a debug-friendly representation of this GridModel.\n   * @returns An object containing debug information\n   */\n  debugValue() {\n    const out = {\n      rows: this.rows.map((r) => r.debugValue()),\n      lastUpdatedAt: this.lastUpdatedAt,\n    } as any;\n    return out;\n  }\n\n  /**\n   * Gets the index of the first non-empty row.\n   * @returns The index of the first row containing cells, or -1 if none\n   */\n  get firstRow(): number {\n    for (const gr of this.rows) {\n      if (gr.numCells > 0) return gr.rowIndex;\n    }\n    return -1;\n  }\n\n  /**\n   * Gets the index of the leftmost column containing cells.\n   * @returns The index of the first column containing cells, or -1 if none\n   */\n  get firstCol(): number {\n    let minCol = -1;\n    for (const gr of this.rows) {\n      const fc = gr.firstCol;\n      if (fc >= 0) {\n        if (minCol < 0 || fc < minCol) {\n          minCol = fc;\n        }\n      }\n    }\n    return minCol;\n  }\n\n  /**\n   * Gets all non-empty cells in a specific row.\n   * @param row The index of the row\n   * @returns An array of cells in the row\n   */\n  cellsInRow(row: number): GridCell[] {\n    const out = [] as GridCell[];\n    const gr = this.rows[row];\n    if (gr) {\n      for (const cell of gr.cells) {\n        if (cell?.value) out.push(cell);\n      }\n    }\n    return out;\n  }\n\n  /**\n   * Gets all non-empty cells in a specific column.\n   * @param col The index of the column\n   * @returns An array of cells in the column\n   */\n  cellsInCol(col: number): GridCell[] {\n    const out = [] as GridCell[];\n    for (const gr of this.rows) {\n      const cell = gr.cellAt(col);\n      if (cell?.value) out.push(cell);\n    }\n    return out;\n  }\n\n  /**\n   * Adds a row alignment object to the grid.\n   * @param align The row alignment to add\n   */\n  addRowAlign(align: RowAlign): void {\n    this.rowAligns.set(align.uuid, align);\n  }\n\n  /**\n   * Adds a column alignment object to the grid.\n   * @param align The column alignment to add\n   */\n  addColAlign(align: ColAlign): void {\n    this.colAligns.set(align.uuid, align);\n  }\n\n  /**\n   * Adds rows to the grid.\n   * @param insertBefore The index before which to insert the rows, or -1 to append\n   * @param numRows The number of rows to add\n   * @returns This grid instance for method chaining\n   */\n  addRows(insertBefore = -1, numRows = 1): this {\n    if (insertBefore < 0) {\n      insertBefore = this.rows.length;\n    }\n    let next = this.rows[insertBefore] || null;\n    const prev = this.rows[insertBefore - 1] || null;\n    for (let i = numRows - 1; i >= 0; i--) {\n      const newRow = new GridRow(this, insertBefore + i);\n      this.rows.splice(insertBefore, 0, newRow);\n      if (next != null) {\n        newRow.defaultRowAlign.addSuccessor(next.defaultRowAlign);\n      }\n      if (i == 0 && insertBefore > 0) {\n        prev.defaultRowAlign.addSuccessor(newRow.defaultRowAlign);\n      }\n      next = newRow;\n    }\n    for (let i = insertBefore + numRows; i < this.rows.length; i++) {\n      this.rows[i].rowIndex += numRows;\n    }\n    return this;\n  }\n\n  /**\n   * Gets a row at the specified index, creating it if necessary.\n   * @param row The index of the row to get\n   * @returns The row at the specified index\n   */\n  getRow(row: number): GridRow {\n    if (row >= this.rows.length) {\n      this.addRows(-1, 1 + row - this.rows.length);\n    }\n    return this.rows[row];\n  }\n\n  /**\n   * Sets a value in a cell at the specified row and column.\n   * @param row The row index\n   * @param col The column index\n   * @param value The value to set\n   * @param cellCreator Optional function to create a custom cell\n   * @returns The previous value of the cell\n   */\n  setValue(row: number, col: number, value: any, cellCreator?: (row: GridRow, col: number) => GridCell): any {\n    const grow = this.getRow(row);\n    if (!cellCreator) {\n      cellCreator = (row: GridRow, col: number) => {\n        return new GridCell(row, col);\n      };\n    }\n    if (value == null) {\n      const out = grow.clearCellAt(col);\n      if (out != null) {\n        this.eventHub?.emit(GridCellEvent.CLEARED, this, {\n          loc: out.location,\n        });\n      }\n      return out;\n    } else {\n      const cell = grow.cellAt(col, cellCreator) as GridCell;\n      const oldValue = cell.value;\n      this.eventHub?.emit(GridCellEvent.UPDATED, this, {\n        loc: cell.location,\n        cell: cell,\n        oldValue: cell.value,\n      });\n      cell.value = value;\n      return oldValue;\n    }\n  }\n\n  /**\n   * Handles changes to the event hub.\n   */\n  protected eventHubChanged(): void {\n    console.log(\"Event Hub Changed for GridModel\");\n  }\n}\n\n/**\n * Interface for a view associated with a grid cell.\n * GridCellView defines the contract for views that can be placed in grid cells.\n */\nexport interface GridCellView {\n  /** The grid cell this view is associated with */\n  readonly cell: GridCell;\n  /** X-coordinate of the view */\n  x: number;\n  /** Y-coordinate of the view */\n  y: number;\n  /** Width of the view */\n  width: number;\n  /** Height of the view */\n  height: number;\n\n  /**\n   * Sets the bounds of the view.\n   * @param x New x-coordinate, or null to keep current value\n   * @param y New y-coordinate, or null to keep current value\n   * @param w New width, or null to keep current value\n   * @param h New height, or null to keep current value\n   * @param applyLayout Whether to apply layout immediately\n   * @returns The new bounds values\n   */\n  setBounds(\n    x: number | null,\n    y: number | null,\n    w: number | null,\n    h: number | null,\n    applyLayout: boolean,\n  ): [number | null, number | null, number | null, number | null];\n\n  /** Whether this view needs layout */\n  readonly needsLayout: boolean;\n\n  /** The minimum size this view requires */\n  readonly minSize: TSU.Geom.Size;\n\n  /** The bounding box of this view */\n  readonly bbox: TSU.Geom.Rect;\n}\n\n/**\n * Enum defining the events that can occur on grid cells.\n */\nexport enum GridCellEvent {\n  ADDED = \"CellAdded\",\n  CLEARED = \"CellCleared\",\n  REMOVED = \"CellRemoved\",\n  UPDATED = \"CellUpdated\",\n  MOVED = \"CellMoved\",\n}\n\n/**\n * Represents a cell in the grid.\n * GridCell holds a value and manages alignment with rows and columns.\n */\nexport class GridCell {\n  private static idCounter = 0;\n  readonly uuid = GridCell.idCounter++;\n  /** The view associated with this cell */\n  cellView: GridCellView | null;\n  private _rowAlign: RowAlign;\n  private _colAlign: ColAlign;\n\n  /**\n   * Creates a new GridCell.\n   * @param gridRow The row this cell belongs to\n   * @param colIndex The column index of this cell\n   * @param value Optional initial value for the cell\n   */\n  constructor(\n    public gridRow: GridRow,\n    public colIndex: number,\n    public value: any = null,\n  ) {\n    this.rowAlign = gridRow.defaultRowAlign;\n  }\n\n  /**\n   * Gets the row alignment for this cell.\n   */\n  get rowAlign(): RowAlign {\n    return this._rowAlign;\n  }\n\n  /**\n   * Sets the row alignment for this cell.\n   */\n  set rowAlign(val: RowAlign) {\n    val.addCell(this);\n    this._rowAlign = val;\n  }\n\n  /**\n   * Gets the column alignment for this cell.\n   */\n  get colAlign(): ColAlign {\n    return this._colAlign;\n  }\n\n  /**\n   * Sets the column alignment for this cell.\n   */\n  set colAlign(val: ColAlign) {\n    val.addCell(this);\n    this._colAlign = val;\n  }\n\n  /**\n   * Gets the location string for this cell (rowIndex:colIndex).\n   */\n  get location(): string {\n    return this.gridRow.rowIndex + \":\" + this.colIndex;\n  }\n\n  /**\n   * Gets the grid this cell belongs to.\n   */\n  get grid(): GridModel {\n    return this.gridRow.grid;\n  }\n\n  /**\n   * Gets the row index of this cell.\n   */\n  get rowIndex(): number {\n    return this.gridRow.rowIndex;\n  }\n\n  /**\n   * Returns a debug-friendly representation of this GridCell.\n   * @returns An object containing debug information\n   */\n  debugValue() {\n    const out = {\n      r: this.gridRow.rowIndex,\n      c: this.colIndex,\n      value: this.value,\n      y: this.rowAlign.coordOffset,\n      h: this.rowAlign.maxLength,\n    } as any;\n    if (this.colAlign) {\n      out.x = this.colAlign.coordOffset;\n      out.w = this.colAlign.maxLength;\n    }\n    return out;\n  }\n}\n\n/**\n * Represents a row of grid cells in a GridModel.\n */\nexport class GridRow {\n  /** The cells in this row */\n  cells: (null | GridCell)[] = [];\n  /** The default vertical alignment for all cells in this row */\n  defaultRowAlign: RowAlign;\n\n  /**\n   * Creates a new GridRow.\n   * @param grid The grid this row belongs to\n   * @param rowIndex The index of this row\n   */\n  constructor(\n    public grid: GridModel,\n    public rowIndex: number,\n  ) {\n    this.defaultRowAlign = new RowAlign();\n    this.grid.addRowAlign(this.defaultRowAlign);\n  }\n\n  /**\n   * Gets the index of the first non-empty column in this row.\n   */\n  get firstCol() {\n    for (let i = 0; i < this.cells.length; i++) {\n      if (this.cells[i]?.value) {\n        return i;\n      }\n    }\n    return -1;\n  }\n\n  /**\n   * Gets the number of columns in this row.\n   */\n  get numCols() {\n    return this.cells.length;\n  }\n\n  /**\n   * Gets the number of cells that contain values.\n   */\n  get numCells() {\n    let i = 0;\n    for (const cell of this.cells) {\n      if (cell != null && cell.value != null) i++;\n    }\n    return i;\n  }\n\n  /**\n   * Gets the cell at the specified column index, optionally creating it if it doesn't exist.\n   * @param col The column index\n   * @param creator Optional function to create the cell if it doesn't exist\n   * @returns The cell at the specified index, or null if it doesn't exist and no creator was provided\n   */\n  cellAt(col: number, creator?: (row: GridRow, col: number) => GridCell): GridCell | null {\n    let out = this.cells[col] || null;\n    if (!out && creator) {\n      this.cells[col] = out = creator(this, col);\n      out.gridRow = this;\n      out.colIndex = col;\n      if (out.rowAlign) {\n        this.grid.addRowAlign(out.rowAlign);\n      }\n      if (out.colAlign) {\n        this.grid.addColAlign(out.colAlign);\n      }\n    }\n    return out;\n  }\n\n  /**\n   * Clears the cell at the given column.\n   * Note this is not the same as \"removing\" a cell.\n   * Removing a cell would require all cells to the \"right\" to be shifted left.\n   * @param col The column index\n   * @returns The cell that was cleared, or null if none existed\n   */\n  clearCellAt(col: number): GridCell | null {\n    const out = this.cells[col] || null;\n    if (out) {\n      this.cells[col] = null;\n    }\n    return out;\n  }\n\n  /**\n   * Returns a debug-friendly representation of this GridRow.\n   * @returns An object containing debug information\n   */\n  debugValue() {\n    return {\n      r: this.rowIndex,\n      cells: this.cells.filter((c) => c).map((c) => c?.debugValue()),\n    };\n  }\n}\n\n/**\n * Base class for row and column alignment objects.\n * AlignedLine manages the alignment of cells along a line (row or column).\n */\nexport abstract class AlignedLine {\n  private static idCounter = 0;\n  readonly uuid = AlignedLine.idCounter++;\n  /** Whether this line needs layout */\n  needsLayout = false;\n  /** The coordinate offset of this line */\n  protected _coordOffset = 0;\n  /** The maximum length of this line */\n  protected _maxLength = 0;\n  /** Padding before this line */\n  paddingBefore = 5;\n  /** Padding after this line */\n  paddingAfter = 5;\n  /** The cells that belong to this line */\n  cells: GridCell[] = [];\n  /** Function to get a view for a cell value */\n  getCellView: (value: any) => GridCellView;\n\n  /**\n   * Sets the offset of this line.\n   * @param val The new offset value\n   */\n  abstract setOffset(val: number): void;\n\n  /**\n   * Evaluates the maximum length required for this line.\n   * @param changedCells Cells that have changed and need re-evaluation\n   * @returns The maximum length\n   */\n  abstract evalMaxLength(changedCells: GridCell[]): number;\n\n  /**\n   * Gets the coordinate offset of this line.\n   */\n  get coordOffset(): number {\n    return this._coordOffset;\n  }\n\n  /**\n   * Gets the maximum length of this line, including padding.\n   */\n  get maxLength(): number {\n    return this._maxLength + this.paddingBefore + this.paddingAfter;\n  }\n\n  /**\n   * Sets the maximum length of this line.\n   * @param length The new maximum length\n   */\n  setMaxLength(length: number) {\n    this._maxLength = length;\n  }\n\n  /**\n   * Sets the padding before and after this line.\n   * @param before Padding before the line\n   * @param after Padding after the line\n   */\n  setPadding(before: number, after: number): void {\n    if (before >= 0) {\n      this.paddingBefore = before;\n    }\n    if (after >= 0) {\n      this.paddingAfter = after;\n    }\n  }\n\n  /**\n   * Adds a cell to this line.\n   * @param cell The cell to add\n   * @returns This line instance for method chaining\n   */\n  addCell(cell: GridCell): this {\n    if (this.beforeAddingCell(cell)) {\n      this.cells.push(cell);\n    }\n    return this;\n  }\n\n  /**\n   * Called before adding a cell to perform validation or preparation.\n   * @param cell The cell to be added\n   * @returns Whether the cell should be added\n   */\n  protected abstract beforeAddingCell(cell: GridCell): boolean;\n\n  /**\n   * Removes a cell from this line.\n   * @param cell The cell to remove\n   * @returns This line instance for method chaining\n   */\n  removeCell(cell: GridCell): this {\n    if (this.beforeRemovingCell(cell)) {\n      for (let i = 0; i < this.cells.length; i++) {\n        if (this.cells[i].uuid == cell.uuid) {\n          this.cells.splice(i, 1);\n          break;\n        }\n      }\n    }\n    return this;\n  }\n\n  /**\n   * Called before removing a cell to perform validation.\n   * @param cell The cell to be removed\n   * @returns Whether the cell should be removed\n   */\n  protected abstract beforeRemovingCell(cell: GridCell): boolean;\n\n  // The \"neighboring\" lines that depend on this line to be placed\n  // before they are placed\n  /** Lines that must be positioned before this line */\n  prevLines = [] as this[];\n  /** Lines that must be positioned after this line */\n  nextLines = [] as this[];\n\n  /**\n   * Adds a successor line to this line.\n   * @param next The line to add as a successor\n   */\n  addSuccessor(next: this): void {\n    // Set nextCol as a successor of this col\n    // TODO - Ensure no cycles\n    for (const c of this.nextLines) {\n      if (c == next) return;\n    }\n    this.nextLines.push(next);\n    next.prevLines.push(this);\n  }\n\n  /* TODO: Disabling only to improve test coverage as this method is\n   * not used.\n   * When we have mutable grids where we can insert/remove neighbors\n   * we can enable this again.\n   */\n  /*\n  removeSuccessor(next: this): void {\n    // Set nextCol as a successor of this col\n    // TODO - Ensure no cycles\n    for (let i = 0; i < this.nextLines.length; i++) {\n      if (this.nextLines[i] == next) {\n        this.nextLines.splice(i, 1);\n        break;\n      }\n    }\n    for (let i = 0; i < next.prevLines.length; i++) {\n      if (next.prevLines[i] == this) {\n        next.prevLines.splice(i, 1);\n        break;\n      }\n    }\n  }\n  */\n}\n\n/**\n * Manages the alignment of cells in a column.\n */\nexport class ColAlign extends AlignedLine {\n  paddingBefore = 10;\n  /** Padding after this line */\n  paddingAfter = 10;\n\n  /**\n   * Sets the offset of this column and updates all associated cells.\n   * @param val The new offset value\n   */\n  setOffset(val: number): void {\n    this._coordOffset = val;\n    for (const cell of this.cells) {\n      if (cell.value) {\n        const cellView = this.getCellView(cell);\n        if (this._maxLength <= 0) {\n          // this hasnt been evaluated yet so do it!\n          this.evalMaxLength();\n        }\n        cellView.setBounds(val, null, this.maxLength, null, true);\n      }\n    }\n  }\n\n  /**\n   * Evaluates the maximum width required for this column.\n   * @param changedCells Cells that have changed and need re-evaluation\n   * @returns The maximum width\n   */\n  evalMaxLength(changedCells: GridCell[] = []): number {\n    this._maxLength = 0;\n    for (const cell of this.cells) {\n      if (cell.value) {\n        const cellView = this.getCellView(cell);\n        this._maxLength = Math.max(cellView.minSize.width, this._maxLength);\n      }\n    }\n    return this._maxLength;\n  }\n\n  /**\n   * Called before adding a cell to perform validation or preparation.\n   * @param cell The cell to be added\n   * @returns Whether the cell should be added\n   */\n  protected beforeAddingCell(cell: GridCell): boolean {\n    if (cell.colAlign && cell.colAlign != this) {\n      cell.colAlign.removeCell(cell);\n    }\n    return cell.colAlign != this;\n  }\n\n  /**\n   * Called before removing a cell to perform validation.\n   * @param cell The cell to be removed\n   * @returns Whether the cell should be removed\n   */\n  beforeRemovingCell(cell: GridCell): boolean {\n    return cell.colAlign == this;\n  }\n}\n\n/**\n * Manages the alignment of cells in a row.\n */\nexport class RowAlign extends AlignedLine {\n  /**\n   * Sets the Y coordinate of all cells in this row.\n   * @param val The new Y coordinate\n   */\n  setOffset(val: number): void {\n    this._coordOffset = val;\n    for (const cell of this.cells) {\n      if (cell.value) {\n        const cellView = this.getCellView(cell);\n        if (this._maxLength <= 0) {\n          // this hasnt been evaluated yet so do it!\n          this.evalMaxLength();\n        }\n        cellView.setBounds(null, val, null, this.maxLength, true);\n      }\n    }\n  }\n\n  /**\n   * Evaluates the maximum height required for this row.\n   * @param changedCells Cells that have changed and need re-evaluation\n   * @returns The maximum height\n   */\n  evalMaxLength(changedCells: GridCell[] = []): number {\n    this._maxLength = 0;\n    for (const cell of this.cells) {\n      if (cell.value) {\n        const cellView = this.getCellView(cell);\n        this._maxLength = Math.max(cellView.minSize.height, this._maxLength);\n      }\n    }\n    return this._maxLength;\n  }\n\n  /**\n   * Called before adding a cell to perform validation or preparation.\n   * @param cell The cell to be added\n   * @returns Whether the cell should be added\n   */\n  protected beforeAddingCell(cell: GridCell): boolean {\n    if (cell.rowAlign && cell.rowAlign != this) {\n      cell.rowAlign.removeCell(cell);\n    }\n    return cell.rowAlign != this;\n  }\n\n  /**\n   * Called before removing a cell to perform validation.\n   * @param cell The cell to be removed\n   * @returns Whether the cell should be removed\n   */\n  beforeRemovingCell(cell: GridCell): boolean {\n    return cell.rowAlign == this;\n  }\n}\n\n/**\n * The layout manager for a collection of GridViews bound by common alignment objects.\n * Manages the layout of multiple grid models, ensuring proper alignment between them.\n */\nexport class GridLayoutGroup {\n  // rowAligns = new Map<number, RowAlign>();\n  // colAligns = new Map<number, ColAlign>();\n  /** The grid models managed by this layout group */\n  gridModels = [] as GridModel[];\n\n  /** Subscribers to layout change events */\n  private layoutChangeSubscribers = new Set<LayoutChangeCallback>();\n\n  /** Previous column widths by ColAlign uuid - for detecting actual changes */\n  private previousColumnWidths = new Map<number, number>();\n\n  /** Previous row heights by RowAlign uuid - for detecting actual changes */\n  private previousRowHeights = new Map<number, number>();\n\n  /**\n   * Subscribes to layout change events.\n   * @param callback Function to call when layout changes\n   * @returns Unsubscribe function\n   */\n  onLayoutChange(callback: LayoutChangeCallback): () => void {\n    this.layoutChangeSubscribers.add(callback);\n    return () => {\n      this.layoutChangeSubscribers.delete(callback);\n    };\n  }\n\n  /**\n   * Notifies all subscribers of a layout change.\n   * @param event The layout change event\n   */\n  protected notifyLayoutChange(event: LayoutChangeEvent): void {\n    for (const callback of this.layoutChangeSubscribers) {\n      try {\n        callback(event);\n      } catch (e) {\n        console.error(\"Error in layout change callback:\", e);\n      }\n    }\n  }\n\n  /**\n   * Gets the number of layout change subscribers.\n   */\n  get subscriberCount(): number {\n    return this.layoutChangeSubscribers.size;\n  }\n\n  /**\n   * Event handler for processing events from grid models.\n   */\n  private eventHandler = (event: TSU.Events.TEvent) => {\n    this.applyModelEvents(event.payload);\n  };\n\n  /**\n   * Adds a grid model to this layout group.\n   * @param gridModel The grid model to add\n   * @returns True if the model was added successfully\n   */\n  addGridModel(gridModel: GridModel): boolean {\n    gridModel.eventHub?.on(TSU.Events.EventHub.BATCH_EVENTS, this.eventHandler);\n    this.gridModels.push(gridModel);\n    return true;\n  }\n\n  /**\n   * Gets all row alignment objects that have no predecessors.\n   * @returns An array of starting row alignments\n   */\n  startingRowAligns(): RowAlign[] {\n    const out = [] as RowAlign[];\n    const visited = {} as any;\n    for (const gm of this.gridModels) {\n      for (const cell of gm.cellsInRow(gm.firstRow)) {\n        if (cell.rowAlign && !visited[cell.rowAlign.uuid]) {\n          visited[cell.rowAlign.uuid] = true;\n          out.push(cell.rowAlign);\n        }\n      }\n    }\n    return out;\n  }\n\n  /**\n   * Gets all column alignment objects that have no predecessors.\n   * @returns An array of starting column alignments\n   */\n  startingColAligns(): ColAlign[] {\n    const out = [] as ColAlign[];\n    const visited = {} as any;\n    for (const gm of this.gridModels) {\n      for (const cell of gm.cellsInCol(gm.firstCol)) {\n        if (cell.colAlign && !visited[cell.colAlign.uuid]) {\n          visited[cell.colAlign.uuid] = true;\n          out.push(cell.colAlign);\n        }\n      }\n    }\n    return out;\n  }\n\n  /**\n   * Removes a grid model from this layout group.\n   * @param gridModel The grid model to remove\n   */\n  removeGridModel(gridModel: GridModel): void {\n    gridModel.eventHub?.removeOn(TSU.Events.EventHub.BATCH_EVENTS, this.eventHandler);\n  }\n\n  /**\n   * Function to get a view for a cell value.\n   */\n  getCellView: (cell: GridCell) => GridCellView;\n\n  /**\n   * Gets the starting row alignments.\n   */\n  get startingRows(): RowAlign[] {\n    return this.startingRowAligns();\n  }\n\n  /**\n   * Gets the starting column alignments.\n   */\n  get startingCols(): ColAlign[] {\n    return this.startingColAligns();\n  }\n\n  /**\n   * Forces a full refresh of the layout.\n   * This recalculates all row and column sizes and positions.\n   * @param notify Whether to notify subscribers of the change (default: true)\n   */\n  refreshLayout(notify = true): void {\n    const changedRowAligns = {} as any;\n    const changedColAligns = {} as any;\n\n    for (const rowAlign of this.startingRowAligns()) {\n      if (!(rowAlign.uuid in changedRowAligns)) {\n        changedRowAligns[rowAlign.uuid] = {\n          align: rowAlign,\n          cells: [],\n        };\n      }\n    }\n\n    for (const colAlign of this.startingColAligns()) {\n      if (!(colAlign.uuid in changedColAligns)) {\n        changedColAligns[colAlign.uuid] = {\n          align: colAlign,\n          cells: [],\n        };\n      }\n    }\n\n    // Pass the previous dimension maps for O(1) inline change detection\n    const rowHeightsChanged = this.doBfsLayout(this.startingRows, changedRowAligns, this.previousRowHeights);\n    const columnWidthsChanged = this.doBfsLayout(this.startingCols, changedColAligns, this.previousColumnWidths);\n\n    // Notify subscribers of full refresh\n    if (notify && this.layoutChangeSubscribers.size > 0) {\n      this.notifyLayoutChange({\n        affectedRowRange: null, // null means all rows\n        affectedColRange: null, // null means all columns\n        columnWidthsChanged,\n        rowHeightsChanged,\n        affectedGridModels: this.gridModels,\n      });\n    }\n  }\n\n  /**\n   * Applies model events to update the layout.\n   * @param events The events to process\n   */\n  protected applyModelEvents(events: TSU.Events.TEvent[]): void {\n    // As the grid model changes (cell content changed, cleared etc) we need\n    // to refresh our layout based on this.\n    // As a first step the new height and width of all changed cells is\n    // evaluted to see which rows and/or columns are affected (and need to be\n    // resized/repositioned).\n    const [changedRowAligns, changedColAligns, affectedGridModels] = this.changesForEvents(events);\n    const hadRowChanges = Object.keys(changedRowAligns).length > 0;\n    const hadColChanges = Object.keys(changedColAligns).length > 0;\n\n    // Pass the previous dimension maps for O(1) inline change detection\n    const rowHeightsChanged = this.doBfsLayout(this.startingRows, changedRowAligns, this.previousRowHeights);\n    const columnWidthsChanged = this.doBfsLayout(this.startingCols, changedColAligns, this.previousColumnWidths);\n\n    // Notify subscribers of incremental changes\n    if (this.layoutChangeSubscribers.size > 0 && (hadRowChanges || hadColChanges)) {\n      // Calculate affected ranges from the changed alignments\n      const affectedRowRange = this.calculateAffectedRowRange(changedRowAligns);\n      const affectedColRange = this.calculateAffectedColRange(changedColAligns);\n\n      this.notifyLayoutChange({\n        affectedRowRange,\n        affectedColRange,\n        columnWidthsChanged,\n        rowHeightsChanged,\n        affectedGridModels: affectedGridModels,\n      });\n    }\n  }\n\n  /**\n   * Calculates the range of affected rows from changed row alignments.\n   * Returns null if no rows changed or range cannot be determined.\n   */\n  protected calculateAffectedRowRange(changedRowAligns: any): { start: number; end: number } | null {\n    let minRow = Infinity;\n    let maxRow = -Infinity;\n\n    for (const alignId in changedRowAligns) {\n      const { cells } = changedRowAligns[alignId];\n      for (const cell of cells) {\n        const rowIndex = cell.gridRow.rowIndex;\n        minRow = Math.min(minRow, rowIndex);\n        maxRow = Math.max(maxRow, rowIndex);\n      }\n    }\n\n    if (minRow === Infinity) return null;\n    return { start: minRow, end: maxRow };\n  }\n\n  /**\n   * Calculates the range of affected columns from changed column alignments.\n   * Returns null if no columns changed or range cannot be determined.\n   */\n  protected calculateAffectedColRange(changedColAligns: any): { start: number; end: number } | null {\n    let minCol = Infinity;\n    let maxCol = -Infinity;\n\n    for (const alignId in changedColAligns) {\n      const { cells } = changedColAligns[alignId];\n      for (const cell of cells) {\n        const colIndex = cell.colIndex;\n        minCol = Math.min(minCol, colIndex);\n        maxCol = Math.max(maxCol, colIndex);\n      }\n    }\n\n    if (minCol === Infinity) return null;\n    return { start: minCol, end: maxCol };\n  }\n\n  /**\n   * Checks if an alignment's maxLength changed from previous value.\n   * Updates the stored previous value. O(1) cost.\n   * @param align The alignment to check\n   * @param previousMap Map storing previous lengths\n   * @returns true if length changed (or is new)\n   */\n  private checkAndUpdateLength<T extends AlignedLine>(align: T, previousMap: Map<number, number>): boolean {\n    const previous = previousMap.get(align.uuid);\n    const current = align.maxLength;\n    previousMap.set(align.uuid, current);\n    return previous === undefined || previous !== current;\n  }\n\n  /**\n   * Determines which rows and columns need to be updated based on events.\n   * @param events The events to process\n   * @returns A tuple containing the changed row alignments, column alignments, and affected grid models\n   */\n  protected changesForEvents(events: TSU.Events.TEvent[]): [any, any, GridModel[]] {\n    // Step 1 - topologically sort RowAligns of changed cells\n    // Step 2 - topologically sort ColAligns of changed cells\n    // Step 3 -\n    const cellVisited = {} as any;\n    const changedRowAligns = {} as any;\n    const changedColAligns = {} as any;\n    const affectedGridModelsSet = new Set<GridModel>();\n    // Going in reverse means we only get the latest event affecting a cell\n    // instead of going through every change.\n    // Later on we can revisit this if the events are edge triggered instead\n    // of level triggered\n    for (let i = events.length - 1; i >= 0; i--) {\n      const event = events[i];\n      const loc = event.payload.loc;\n      if (cellVisited[loc]) continue;\n      cellVisited[loc] = true;\n      const [row, col] = loc.split(\":\").map((x: string) => parseInt(x));\n      const gridModel = event.source as GridModel;\n      affectedGridModelsSet.add(gridModel);\n      const cell = gridModel.getRow(row).cellAt(col);\n      if (cell) {\n        // TODO - For now we are marking both row and col as having\n        // changed for a cell.  We can optimize this to only row or\n        // col based on whether height or width has changed.\n        if (!(cell.rowAlign.uuid in changedRowAligns)) {\n          changedRowAligns[cell.rowAlign.uuid] = {\n            align: cell.rowAlign,\n            cells: [],\n          };\n        }\n        changedRowAligns[cell.rowAlign.uuid][\"cells\"].push(cell);\n\n        if (!(cell.colAlign.uuid in changedColAligns)) {\n          changedColAligns[cell.colAlign.uuid] = {\n            align: cell.colAlign,\n            cells: [],\n          };\n        }\n        changedColAligns[cell.colAlign.uuid][\"cells\"].push(cell);\n      }\n    }\n    return [changedRowAligns, changedColAligns, Array.from(affectedGridModelsSet)];\n  }\n\n  /**\n   * Ensures that a cell view getter function is available for an alignment.\n   * @param align The alignment to check\n   * @returns The cell view getter function\n   */\n  protected ensureGetCellView(align: AlignedLine) {\n    if (!align.getCellView) {\n      if (!this.getCellView) {\n        return null;\n      }\n      align.getCellView = this.getCellView;\n    }\n    return align.getCellView;\n  }\n\n  /**\n   * Performs a breadth-first layout of aligned lines.\n   * @param startingLines The lines to start from\n   * @param changedAligns Map of alignment IDs to changed alignments\n   * @param previousLengths Map to track previous lengths for change detection\n   * @returns true if any dimension (width/height) actually changed\n   */\n  protected doBfsLayout<T extends AlignedLine>(\n    startingLines: T[],\n    changedAligns: any,\n    previousLengths?: Map<number, number>,\n  ): boolean {\n    // 1. start from the starting lines and do a BF traversal\n    // 2. If a line not visited (ie laid out):\n    //      if it is in the changedAlign list then reval its length (w/h)\n    //      set its offset and length if either width or offset has changed\n    //      offset can be thought of changed if the preceding line's offset has changed\n    // first do above for rows\n    if (!this.getCellView) return false;\n    let anyDimensionChanged = false;\n\n    for (const alignId in changedAligns) {\n      const val = changedAligns[alignId];\n      this.ensureGetCellView(val.align);\n      val.align.evalMaxLength(val.cells);\n\n      // Check if this alignment's length actually changed (O(1))\n      if (previousLengths && this.checkAndUpdateLength(val.align, previousLengths)) {\n        anyDimensionChanged = true;\n      }\n    }\n\n    let lineQueue = [] as [null | T, T][];\n    const visitedLines = {} as any;\n    for (const line of startingLines) lineQueue.push([null, line]);\n    const lineOffsetChanged = {} as any;\n    while (lineQueue.length > 0) {\n      const nextQueue = [] as [null | T, T][];\n      for (let i = 0; i < lineQueue.length; i++) {\n        const [prevLineAlign, lineAlign] = lineQueue[i];\n        visitedLines[lineAlign.uuid] = true;\n        let newOffset = lineAlign.coordOffset;\n        let lineChanged = lineAlign.uuid in changedAligns;\n        if (prevLineAlign) {\n          if (lineOffsetChanged[prevLineAlign.uuid]) {\n            newOffset = prevLineAlign.coordOffset + prevLineAlign.maxLength;\n            lineChanged = true;\n          }\n        }\n        if (lineChanged) {\n          this.ensureGetCellView(lineAlign);\n          lineAlign.setOffset(newOffset);\n          lineOffsetChanged[lineAlign.uuid] = true;\n        }\n\n        // Add next neighbors now\n        for (const next of lineAlign.nextLines) {\n          if (!visitedLines[next.uuid]) {\n            nextQueue.push([lineAlign, next]);\n          }\n        }\n      }\n      lineQueue = nextQueue;\n    }\n\n    return anyDimensionChanged;\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { AtomType, Marker, Group, Line, Atom, Space, Role } from \"./\";\nimport { CycleIterator, CyclePosition } from \"./cycle\";\nimport { WindowIterator } from \"./iterators\";\nimport { LayoutParams } from \"./layouts\";\nimport { GridModel, GridRow, GridCell, ColAlign, GridLayoutGroup } from \"./grids\";\nimport { Block, BlockItem, isLine, isBlock } from \"./notation\";\n\ntype Fraction = TSU.Num.Fraction;\nconst ZERO = TSU.Num.Fraction.ZERO;\nconst ONE = TSU.Num.Fraction.ONE;\n\n/**\n * Represents a single beat in the notation.\n * A beat contains one or more atoms and has a specific position in a bar.\n */\nexport class Beat {\n  private static idCounter = 0;\n  readonly uuid = Beat.idCounter++;\n  // Should this be as flat Atoms or should we keep it as atoms and breakdown later?\n\n  /** The atom contained in this beat */\n  atom: Atom;\n  protected atomIsPlaceholder = false;\n\n  /**\n   * Creates a new Beat.\n   * @param index The index of this beat in the sequence\n   * @param role The role this beat belongs to\n   * @param offset The time offset of this beat from the start\n   * @param duration The duration of this beat\n   * @param barIndex The index of the bar containing this beat\n   * @param beatIndex The index of this beat within its bar\n   * @param instance The instance number of this beat\n   * @param prevBeat The previous beat in the sequence, if any\n   * @param nextBeat The next beat in the sequence, if any\n   */\n  constructor(\n    public readonly index: number,\n    public readonly role: Role,\n    public readonly offset: Fraction,\n    public readonly duration: Fraction,\n    public readonly barIndex: number,\n    public readonly beatIndex: number,\n    public readonly instance: number,\n    public readonly prevBeat: null | Beat,\n    public nextBeat: null | Beat,\n  ) {}\n\n  /**\n   * Returns a debug-friendly representation of this Beat.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return {\n      index: this.index,\n      role: this.role.name,\n      offset: this.offset.toString(),\n      duration: this.duration.toString(),\n      barIndex: this.barIndex,\n      beatIndex: this.beatIndex,\n      instance: this.instance,\n      atom: this.atom.debugValue(),\n    };\n  }\n\n  /**\n   * Gets the end offset of this beat (offset + duration).\n   */\n  get endOffset(): Fraction {\n    return this.offset.plus(this.duration);\n  }\n\n  /**\n   * Checks if this beat is filled completely (no remaining space).\n   */\n  get filled(): boolean {\n    return this.remaining.isZero;\n  }\n\n  /**\n   * Gets the remaining duration available in this beat.\n   */\n  get remaining(): Fraction {\n    return this.atom ? this.duration.minus(this.atom.duration, true) : this.duration;\n  }\n\n  /**\n   * Adds an atom to this beat.\n   * @param atom The atom to add\n   * @returns True if the atom was added successfully, false if there's not enough space\n   */\n  add(atom: Atom): boolean {\n    if (this.remaining.cmp(atom.duration) < 0) {\n      return false;\n    }\n    if (!this.atom) {\n      this.atom = atom;\n    } else {\n      if (!this.atomIsPlaceholder) {\n        this.atomIsPlaceholder = true;\n        this.atom = new Group(this.atom).setDuration(ONE, true);\n      }\n      (this.atom as Group).addAtoms(true, atom);\n    }\n    return true;\n  }\n\n  /**\n   * Gets all markers that should be displayed before this beat.\n   * @returns An array of Marker objects\n   */\n  get preMarkers(): Marker[] {\n    const out = [] as Marker[];\n    let curr: Atom | null = this.atom;\n    while (curr != null) {\n      for (const marker of curr.markersBefore || []) {\n        out.push(marker);\n      }\n      if (curr.TYPE == AtomType.GROUP) {\n        curr = (curr as Group).atoms.first;\n      } else {\n        curr = null;\n      }\n    }\n    return out;\n  }\n\n  /**\n   * Gets all markers that should be displayed after this beat.\n   * @returns An array of Marker objects\n   */\n  get postMarkers(): Marker[] {\n    const out = [] as Marker[];\n    let curr: Atom | null = this.atom;\n    while (curr != null) {\n      out.splice(0, 0, ...(curr.markersAfter || []));\n      if (curr.TYPE == AtomType.GROUP) {\n        curr = (curr as Group).atoms.last;\n      } else {\n        curr = null;\n      }\n    }\n    return out;\n  }\n}\n\n/**\n * Builds a sequence of beats from atoms according to layout parameters.\n * Used to convert a flat sequence of atoms into structured beats for display.\n */\nexport class BeatsBuilder {\n  /** All atoms divided into beats */\n  readonly beats: Beat[] = [];\n  readonly startIndex: number;\n  readonly beatOffset: Fraction;\n  cycleIter: CycleIterator;\n  windowIter: WindowIterator;\n\n  /** Callback for when an atom is added to this role */\n  onAtomAdded: (atom: Atom, beat: Beat) => void;\n\n  /** Callback for when a new beat is added */\n  onBeatAdded: (beat: Beat) => void;\n\n  /** Callback for when a beat has been filled */\n  onBeatFilled: (beat: Beat) => void;\n\n  /**\n   * Creates a new BeatsBuilder.\n   * @param role The role containing the atoms\n   * @param layoutParams Layout parameters for structuring beats\n   * @param startOffset The starting offset for the first beat, defaults to ZERO\n   * @param atoms Initial atoms to add to the beats\n   */\n  constructor(\n    public readonly role: Role,\n    public readonly layoutParams: LayoutParams,\n    public readonly startOffset: Fraction = ZERO,\n    ...atoms: Atom[]\n  ) {\n    const [, [bar, beat, instance], beatOffset, index] = layoutParams.cycle.getPosition(startOffset);\n    this.cycleIter = layoutParams.cycle.iterateBeats(bar, beat, instance);\n    this.windowIter = new WindowIterator();\n    this.beatOffset = beatOffset;\n\n    // evaluate the start beatindex - typically it would be 0 if things start\n    // at beginning of a cycle.  But if the start offset is < 0 then the\n    // startIndex should also shift accordingly\n    this.startIndex = index;\n    this.addAtoms(...atoms);\n  }\n\n  /**\n   * Adds atoms to be processed into beats.\n   * @param atoms The atoms to add\n   */\n  addAtoms(...atoms: Atom[]): void {\n    // First add all atoms to the atom Iterator so we can\n    // fetch them as FlatAtoms.  This is needed because atoms\n    // passed here could be unflatted (via groups) or much larger\n    // than what can fit in the given role/bar etc.  So this\n    // flattening and windowing is needed before we add them\n    // to the views - and this is done by the durationIterators.\n    this.windowIter.push(...atoms);\n    while (this.windowIter.hasMore) {\n      // get the last/current row and add a new one if it is full\n      let currBeat = this.beats[this.beats.length - 1];\n\n      // First add a row if last row is filled\n      if (this.beats.length == 0 || currBeat.filled) {\n        // what should be the beatlengths be here?\n        currBeat = this.addBeat();\n      }\n\n      // For this beat get symbols in all roles\n      const [remAtoms, filled] = this.windowIter.get(currBeat.remaining);\n      TSU.assert(remAtoms.length > 0, \"Atleast one element should have been available here\");\n      // render the atoms now\n      for (const atom of remAtoms) {\n        // console.log(\"Adding FA: \", flatAtom.debugValue(), flatAtom.atom);\n        TSU.assert(currBeat.add(atom), \"Should return true as we are already using a duration iterator here\");\n        if (this.onAtomAdded) this.onAtomAdded(atom, currBeat);\n      }\n      if (currBeat.filled) {\n        if (this.onBeatFilled) this.onBeatFilled(currBeat);\n      }\n    }\n  }\n\n  /**\n   * Adds a new beat to the sequence.\n   * @returns The newly created beat\n   */\n  protected addBeat(): Beat {\n    const numBeats = this.beats.length;\n    const lastBeat = numBeats == 0 ? null : this.beats[numBeats - 1];\n    const nextCP: [CyclePosition, Fraction] = this.cycleIter.next().value;\n    const apb = this.layoutParams.beatDuration;\n    const newBeat = new Beat(\n      lastBeat == null ? this.startIndex : lastBeat.index + 1,\n      this.role,\n      lastBeat == null ? this.startOffset.minus(this.beatOffset).timesNum(apb, true) : lastBeat.endOffset,\n      nextCP[1].timesNum(apb),\n      nextCP[0][0],\n      nextCP[0][1],\n      nextCP[0][2],\n      lastBeat,\n      null,\n    );\n    if (lastBeat == null && this.beatOffset.isGT(ZERO)) {\n      // Add spaces to fill up empty beats\n      newBeat.add(new Space(this.beatOffset.timesNum(apb)));\n    }\n    if (lastBeat) lastBeat.nextBeat = newBeat;\n    this.beats.push(newBeat);\n    if (this.onBeatAdded) this.onBeatAdded(newBeat);\n    return newBeat;\n  }\n}\n\n/**\n * Represents a column of beats in a layout grid.\n * Used for aligning beats vertically in the notation.\n */\nexport class BeatColumn extends ColAlign {\n  /** Spacing between atoms in this column */\n  atomSpacing = 5;\n  /** Unique key for this column */\n  readonly key: string;\n\n  /**\n   * Creates a new BeatColumn.\n   * @param offset The starting offset of this column\n   * @param endOffset The ending offset of this column\n   * @param markerType The type of marker for this column (negative: before, positive: after, zero: normal)\n   */\n  constructor(\n    public readonly offset: Fraction,\n    public readonly endOffset: Fraction,\n    public readonly markerType: number,\n  ) {\n    super();\n    offset = offset.factorized;\n    endOffset = endOffset.factorized;\n    this.key = BeatColumn.keyFor(offset, endOffset, markerType);\n  }\n\n  /**\n   * Generates a key for identifying columns with the same offsets and marker type.\n   * @param offset The starting offset\n   * @param endOffset The ending offset\n   * @param markerType The type of marker (negative: before, positive: after, zero: normal)\n   * @returns A string key\n   */\n  static keyFor(offset: Fraction, endOffset: Fraction, markerType = 0): string {\n    offset = offset.factorized;\n    endOffset = endOffset.factorized;\n    if (markerType < 0) {\n      // return the column for the marker \"before\" this col\n      // int his case only the \"start offset\" is needed and length doesnt matter\n      return \":\" + offset.toString();\n    } else if (markerType > 0) {\n      // return the column for the marker \"after\" this col\n      // in this case only thd end offset matters\n      return endOffset.toString() + \":\";\n    } else {\n      return offset.toString() + \":\" + endOffset.toString();\n    }\n  }\n}\n\n/**\n * Manages the organization of beats into columns based on their offsets.\n * Used to create a directed acyclic graph (DAG) of beat columns for layout purposes.\n *\n * Grouping of beats by their column based on the layout params.\n * The confusion is we have beats broken up and saved in columns\n * but we are loosing how a line is supposed to access it in its own way\n * we have beatsByRole for getting all beats for a role (in a line)\n * sequentially we have beatColumns for getting all beats in a particular\n * column across all lines and roles globally.\n *\n * What we want here is for a given line get all roles, their beats\n * in zipped way.  eg for a Line with 3 roles and say 10 beats each\n * (with the breaks of 4, 1) we need:\n *\n * R1 B1 R1 B2 R1 B3 R1 B4\n * R2 B1 R2 B2 R2 B3 R2 B4\n * R3 B1 R3 B2 R3 B3 R3 B4\n *\n * R1 B5\n * R2 B5\n * R3 B5\n *\n * R1 B6 R1 B7 R1 B8 R1 B9\n * R2 B6 R2 B7 R2 B8 R2 B9\n * R3 B6 R3 B7 R3 B8 R3 B9\n *\n * R1 B10\n * R2 B10\n * R3 B10\n *\n *\n * Here we have 5 distinct beat columns:\n *\n * 1: R1B1, R2B1, R3B1, R1B6, R2B6, R3B6,\n * 2: R1B2, R2B2, R3B2, R1B7, R2B7, R3B7,\n * 3: R1B3, R2B3, R3B3, R1B8, R2B8, R3B8,\n * 4: R1B4, R2B4, R3B4, R1B9, R2B9, R3B9,\n * 5: R1B5, R2B5, R3B5, R1B10, R2B10, R3B10,\n *\n */\nexport class BeatColDAG {\n  /** Map of column keys to BeatColumn objects */\n  beatColumns = new Map<string, BeatColumn>();\n\n  /**\n   * Creates a new BeatColDAG.\n   * @param layoutGroup The layout group to associate with this DAG\n   */\n  constructor(public readonly layoutGroup: GridLayoutGroup) {\n    //\n  }\n\n  /**\n   * Gets the beat column for a given duration at the specified offset.\n   * Creates a new column if none exists.\n   * @param offset The starting offset\n   * @param endOffset The ending offset\n   * @param markerType The type of marker\n   * @returns The BeatColumn for the specified parameters\n   */\n  getBeatColumn(offset: Fraction, endOffset: Fraction, markerType = 0): BeatColumn {\n    const [bcol, newcreated] = this.ensureBeatColumn(offset, endOffset, markerType);\n    if (newcreated) {\n      if (markerType == 0) {\n        const [prevcol] = this.ensureBeatColumn(offset, endOffset, -1);\n        const [nextcol] = this.ensureBeatColumn(offset, endOffset, 1);\n        prevcol.addSuccessor(bcol);\n        bcol.addSuccessor(nextcol);\n        for (const other of this.beatColumns.values()) {\n          // only join the \"marker\" columns\n          if (other.markerType == -1 && endOffset.equals(other.offset)) {\n            // our next col is a preecessor of other\n            nextcol.addSuccessor(other);\n          } else if (other.markerType == 1 && other.endOffset.equals(offset)) {\n            // our prev col is a predecessor of other\n            other.addSuccessor(prevcol);\n          }\n        }\n      }\n    }\n    return bcol;\n  }\n\n  /**\n   * Ensures a beat column exists for the given parameters.\n   * @param offset The starting offset\n   * @param endOffset The ending offset\n   * @param markerType The type of marker\n   * @returns A tuple containing the column and whether it was newly created\n   */\n  protected ensureBeatColumn(offset: Fraction, endOffset: Fraction, markerType = 0): [BeatColumn, boolean] {\n    const key = BeatColumn.keyFor(offset, endOffset, markerType);\n    let bcol = this.beatColumns.get(key) || null;\n    const newcreated = bcol == null;\n    if (!bcol) {\n      bcol = new BeatColumn(offset, endOffset, markerType);\n      this.beatColumns.set(key, bcol);\n    }\n    return [bcol, newcreated];\n  }\n}\n\n/** Type alias for line IDs */\ntype LineId = number;\n/** Type alias for layout parameter IDs */\ntype LPID = number;\n\n/**\n * Manages the beat layouts for all lines in a notation.\n * Handles the creation of grid models, positioning of beats, and alignment of beats across lines.\n */\nexport class GlobalBeatLayout {\n  /** Map of line IDs to grid models */\n  gridModelsForLine = new Map<LineId, GridModel>();\n  /** Map of line IDs to arrays of beats for each role */\n  roleBeatsForLine = new Map<LineId, Beat[][]>();\n  /** Map of layout parameter IDs to beat column DAGs */\n  beatColDAGsByLP = new Map<LPID, BeatColDAG>();\n  /** The global layout group for all grid models */\n  readonly gridLayoutGroup: GridLayoutGroup;\n\n  /**\n   * Creates a new GlobalBeatLayout.\n   * @param sharedGridLayoutGroup Optional shared GridLayoutGroup for column alignment across multiple views.\n   *                               If not provided, a new GridLayoutGroup is created internally.\n   */\n  constructor(sharedGridLayoutGroup?: GridLayoutGroup) {\n    this.gridLayoutGroup = sharedGridLayoutGroup ?? new GridLayoutGroup();\n  }\n\n  /**\n   * Gets the GridModel associated with a particular line, creating one if it doesn't exist.\n   * @param lineid The ID of the line\n   * @returns The GridModel for the line\n   */\n  getGridModelForLine(lineid: LineId): GridModel {\n    let out = this.gridModelsForLine.get(lineid) || null;\n    if (!out) {\n      out = new GridModel();\n      this.gridLayoutGroup.addGridModel(out);\n      this.gridModelsForLine.set(lineid, out);\n    }\n    return out;\n  }\n\n  /**\n   * Gets the BeatColDAG for a specific layout parameter ID, creating one if it doesn't exist.\n   * @param lpid The layout parameter ID\n   * @returns The BeatColDAG for the layout parameters\n   */\n  protected beatColDAGForLP(lpid: LPID): BeatColDAG {\n    let out = this.beatColDAGsByLP.get(lpid) || null;\n    if (!out) {\n      out = new BeatColDAG(this.gridLayoutGroup);\n      this.beatColDAGsByLP.set(lpid, out);\n    }\n    return out;\n  }\n\n  /**\n   * Adds a line to the beat layout.\n   * This ensures that a line is broken down into beats and added into a dedicated GridModel.\n   *\n   * A line must also be given the layout params by which the beat breakdown will happen.\n   * This LayoutParams object does not have to be unique per line (this non-constraint allows\n   * beats to be aligned across lines).\n   *\n   * @param line The line to add\n   */\n  addLine(line: Line): void {\n    const gridModel = this.getGridModelForLine(line.uuid) as GridModel;\n    gridModel.eventHub?.startBatchMode();\n    this.lineToRoleBeats(line, gridModel);\n    gridModel.eventHub?.commitBatch();\n  }\n\n  /**\n   * Recursively processes a block and its children to build beat layouts.\n   * Uses block.children() to get expanded children (e.g., RepeatBlock expands to N copies).\n   *\n   * @param block The block to process\n   */\n  processBlock(block: Block): void {\n    for (const child of block.children()) {\n      this.processBlockItem(child);\n    }\n  }\n\n  /**\n   * Processes a single block item (Block, Line, or RawBlock).\n   *\n   * @param item The item to process\n   */\n  protected processBlockItem(item: BlockItem): void {\n    if (isLine(item)) {\n      const line = item as Line;\n      if (!line.isEmpty && line.layoutParams != null) {\n        this.addLine(line);\n      }\n    } else if (isBlock(item)) {\n      this.processBlock(item as Block);\n    }\n    // RawBlocks are ignored (no beat layout for raw content)\n  }\n\n  /**\n   * Converts a line into a series of beats for each role.\n   * @param line The line to convert\n   * @param gridModel The grid model to use\n   * @returns Arrays of beats for each role\n   */\n  protected lineToRoleBeats(line: Line, gridModel: GridModel): Beat[][] {\n    const lp = line.layoutParams;\n    const roleBeats = [] as Beat[][];\n    this.roleBeatsForLine.set(line.uuid, roleBeats);\n    const lineOffset = line.offset.divbyNum(lp.beatDuration);\n    for (const role of line.roles) {\n      const bb = new BeatsBuilder(role, lp, lineOffset, ...role.atoms);\n      roleBeats.push(bb.beats);\n\n      // Add these to the beat layout too\n      for (const beat of bb.beats) {\n        // beat.ensureUniformSpaces(layoutParams.beatDuration);\n        this.addBeat(beat, gridModel);\n      }\n    }\n    return roleBeats;\n  }\n\n  /**\n   * Adds a beat to the layout.\n   * @param beat The beat to add\n   * @param gridModel The grid model to add the beat to\n   * @returns The grid cell containing the beat\n   */\n  protected addBeat(beat: Beat, gridModel: GridModel): GridCell {\n    // Get the beat column at this index (and line) and add to it.\n    const line = beat.role.line;\n    const lp = line.layoutParams;\n    const beatColDAG = this.beatColDAGForLP(lp.uuid);\n    const [layoutLine, layoutColumn, rowOffset] = lp.getBeatLocation(beat);\n    const colEnd = rowOffset.plus(beat.duration, true);\n    const bcol = beatColDAG.getBeatColumn(rowOffset, colEnd, 0);\n\n    // Since a beat's column has a \"pre\" and \"post\" col to, each\n    // beat has 3 columns for it\n    const roleIndex = beat.role.line.indexOfRole(beat.role.name);\n    const nthLine = Math.floor(beat.index / lp.totalBeats);\n    const realLine = lp.lineBreaks.length * nthLine + layoutLine;\n    const realRow = line.roles.length * realLine + roleIndex;\n    // pre marker goes on realCol - 1, post marker goes on realCol + 1\n    const realCol = 1 + layoutColumn * 3;\n    const preMarkers = beat.preMarkers;\n    if (preMarkers.length > 0) {\n      const val = {\n        beat: beat,\n        markers: preMarkers,\n      };\n      const precol = beatColDAG.getBeatColumn(rowOffset, colEnd, -1);\n      gridModel.setValue(realRow, realCol - 1, val, (gridRow: GridRow, col: number) => {\n        const cell = new GridCell(gridRow, col);\n        cell.colAlign = precol;\n        return cell;\n      });\n    }\n    const postMarkers = beat.postMarkers;\n    if (postMarkers.length > 0) {\n      const val = {\n        beat: beat,\n        markers: postMarkers,\n      };\n      const postcol = beatColDAG.getBeatColumn(rowOffset, colEnd, 1);\n      gridModel.setValue(realRow, realCol + 1, val, (gridRow: GridRow, col: number) => {\n        const cell = new GridCell(gridRow, col);\n        cell.colAlign = postcol;\n        return cell;\n      });\n    }\n    return gridModel.setValue(realRow, realCol, beat, (gridRow: GridRow, col: number) => {\n      const cell = new GridCell(gridRow, col);\n      cell.colAlign = bcol;\n      return cell;\n    });\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\n\ntype EdgeData = any;\ntype EdgeFunctor<T> = (node: T) => ReadonlyArray<[T, EdgeData]>;\ntype IDFunc<T> = (t: T) => number | string;\n\nexport function allMinimalCycles<T>(\n  nodes: ReadonlyArray<T>,\n  idFunc: IDFunc<T>,\n  edges: EdgeFunctor<T>,\n): ReadonlyArray<[T, EdgeData]> {\n  // Tells which cycle a node is assigned to if any\n  const cycles: [T, EdgeData][] = [];\n  const inACycle = {} as any;\n  nodes.forEach((node) => {\n    // start from node and do a BFS to see what cycle a node appears in\n    if (!(idFunc(node) in inACycle)) {\n      const startNode = node;\n      const visited = {} as any;\n      let queue: [T, [EdgeData, T][]][] = [[node, []]];\n      while (queue.length > 0) {\n        const newQueue: [T, [EdgeData, T][]][] = [];\n        for (let i = 0; i < queue.length; i++) {\n          const [node, c] = queue[i];\n          TSU.assert(node != null);\n          const e = edges(node);\n          let cycle = [...c];\n          for (const [nextNode, edgeData] of e) {\n            if (nextNode == startNode) {\n              // we have a cycle\n              cycle.push([edgeData, nextNode]);\n              cycle.forEach(([e, n], i) => (inACycle[n] = true));\n              cycles.push([startNode, cycle]);\n              cycle = cycle.slice(0, cycle.length - 1);\n            } else if (!(idFunc(nextNode) in visited)) {\n              visited[idFunc(nextNode)] = true;\n              newQueue.push([nextNode, [...cycle, [edgeData, nextNode]]]);\n            }\n          }\n        }\n        queue = newQueue;\n      }\n    }\n  });\n  return cycles;\n}\n\nexport function digraph(): void {\n  //\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { Grammar, Sym, Str, Rule } from \"./grammar\";\n\ntype NumMap<T> = TSU.NumMap<T>;\ntype StringMap<T> = TSU.StringMap<T>;\ntype Nullable<T> = TSU.Nullable<T>;\n\nconst defaultKeyFunc = (x: any) => x.key;\n\nexport class Trie<T> {\n  protected keyFunc: (t: T) => string;\n  readonly root: TrieNode<T> = new TrieNode();\n\n  constructor(keyFunc: (t: T) => string) {\n    this.keyFunc = keyFunc;\n  }\n\n  add(values: T[], fromIndex = 0): TrieNode<T> {\n    // we are at the bottom\n    let curr = this.root;\n    for (let i = fromIndex; i < values.length; i++) {\n      const key = this.keyFunc(values[i]);\n      if (curr.children.has(key)) {\n        curr = curr.children.get(key)!;\n      } else {\n        const newNode = new TrieNode<T>();\n        newNode.value = values[i];\n        newNode.parent = curr;\n        curr.children.set(key, newNode);\n        curr = newNode;\n      }\n    }\n    curr.isLeaf = true;\n    return curr;\n  }\n\n  get debugValue(): any {\n    return this.root.debugValue;\n  }\n}\n\nexport class TrieNode<T> {\n  isLeaf = false;\n  value: Nullable<T> = null;\n  parent: Nullable<TrieNode<T>> = null;\n  children = new Map<string, TrieNode<T>>();\n\n  get debugValue(): any {\n    const out = { value: this.value, children: {} as any } as any;\n    if (this.isLeaf) out[\"isLeaf\"] = true;\n    for (const [key, value] of this.children.entries()) {\n      out.children[key] = value.debugValue;\n    }\n    return out;\n  }\n}\n\nexport class IDSet<T extends { id: number }> {\n  protected _entries: T[] = [];\n  protected _entriesByKey: StringMap<T> = {};\n  protected keyFunc: (t: T) => string;\n\n  constructor(keyFunc: (t: T) => string = defaultKeyFunc) {\n    this.keyFunc = keyFunc;\n  }\n\n  clear(): void {\n    this._entries = [];\n    this._entriesByKey = {};\n  }\n\n  /**\n   * Removes all entries that match a predict.\n   */\n  remove(predicate: (t: T) => boolean): boolean {\n    const e2: T[] = [];\n    this._entriesByKey = {};\n    let modified = false;\n    for (let l = 0; l < this._entries.length; l++) {\n      const e = this._entries[l];\n      if (!predicate(e)) {\n        // keep it if predicate failes\n        e.id = e2.length;\n        e2.push(e);\n        this._entriesByKey[this.keyFunc(e)] = e;\n      } else {\n        modified = true;\n      }\n    }\n    this._entries = e2;\n    return modified;\n  }\n\n  get entries(): ReadonlyArray<T> {\n    return this._entries;\n  }\n\n  get(id: number): T {\n    TSU.assert(id >= 0 && id < this._entries.length);\n    return this._entries[id];\n  }\n\n  getByKey(key: string): Nullable<T> {\n    return this._entriesByKey[key] || null;\n  }\n\n  ensure(entry: T, throwIfExists = false): T {\n    // see if this itemset exists\n    if (this.has(entry)) {\n      if (throwIfExists) throw new Error(`Entry ${this.keyFunc(entry)} already exists`);\n      return this._entriesByKey[this.keyFunc(entry)];\n    } else {\n      this._entriesByKey[this.keyFunc(entry)] = entry;\n      entry.id = this._entries.length;\n      this._entries.push(entry);\n      return entry;\n    }\n  }\n\n  has(entry: T): boolean {\n    return this.keyFunc(entry) in this._entriesByKey;\n  }\n\n  get size(): number {\n    return this._entries.length;\n  }\n}\n\nexport class SymbolSet {\n  readonly grammar: Grammar;\n  readonly enforceSymbolType: Nullable<boolean>;\n  entries = new Set<number>();\n  hasNull = false;\n\n  constructor(grammar: Grammar, enforceSymbolType: Nullable<boolean> = true) {\n    this.grammar = grammar;\n    this.enforceSymbolType = enforceSymbolType;\n  }\n\n  get debugString(): string {\n    return \"<\" + this.labels().sort().join(\", \") + \">\";\n  }\n\n  labels(skipAux = false): string[] {\n    const out: string[] = [];\n    for (const i of this.entries) {\n      const exp = this.grammar.getSymById(i);\n      TSU.assert(exp != null);\n      if (!skipAux || !exp.isAuxiliary) out.push(exp.label);\n    }\n    if (this.hasNull) out.push(\"\");\n    return out;\n  }\n\n  addFrom(another: SymbolSet, includeNull = true): number {\n    return another.addTo(this, includeNull);\n  }\n\n  addTo(another: SymbolSet, includeNull = true): number {\n    const before = another.entries.size;\n    for (const termid of this.entries) {\n      another.entries.add(termid);\n    }\n    if (includeNull) {\n      another.hasNull = this.hasNull || another.hasNull;\n    }\n    return another.entries.size - before;\n  }\n\n  has(term: Sym): boolean {\n    return this.entries.has(term.id);\n  }\n\n  add(term: Sym): this {\n    TSU.assert(\n      this.enforceSymbolType == null || this.enforceSymbolType == term.isTerminal,\n      `Terminal types being enforced: ${this.enforceSymbolType}`,\n    );\n    this.entries.add(term.id);\n    return this;\n  }\n\n  delete(term: Sym): boolean {\n    return this.entries.delete(term.id);\n  }\n\n  get size(): number {\n    return this.entries.size + (this.hasNull ? 1 : 0);\n  }\n}\n\n/**\n * Tells which non terminals are nullables.\n */\nexport class NullableSet {\n  readonly grammar: Grammar;\n  entries: Set<number>;\n  private visited: any;\n\n  constructor(grammar: Grammar) {\n    this.grammar = grammar;\n    this.refresh();\n  }\n\n  get nonterms(): Sym[] {\n    const out: Sym[] = [];\n    this.entries.forEach((id) => {\n      const e = this.grammar.getSymById(id);\n      TSU.assert(e != null && !e.isTerminal);\n      out.push(e);\n    });\n    return out;\n  }\n\n  refresh(): void {\n    // Nuke entries cache.  Will force isNullable to recompute.\n    this.entries = new Set();\n    this.visited = {};\n\n    let beforeCount = 0;\n    do {\n      beforeCount = this.entries.size;\n      this.grammar.allNonTerminals.forEach((nt) => this.visit(nt));\n    } while (beforeCount != this.entries.size);\n  }\n\n  protected visit(nt: Sym): void {\n    for (const rule of this.grammar.rulesForNT(nt)) {\n      if (this.isStrNullable(rule.rhs)) {\n        this.add(nt);\n        break;\n      }\n    }\n  }\n\n  isNullable(nt: Sym): boolean {\n    return !nt.isTerminal && this.entries.has(nt.id);\n  }\n\n  isStrNullable(str: Str, fromIndex = 0, toIndex: Nullable<number> = null): boolean {\n    if (toIndex == null) {\n      toIndex = str.length - 1;\n    }\n    for (let i = fromIndex; i <= toIndex; i++) {\n      if (!this.isNullable(str.syms[i])) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  add(nt: Sym): void {\n    TSU.assert(!nt.isTerminal);\n    this.entries.add(nt.id);\n  }\n}\n\nclass SymSymbolSets {\n  readonly grammar: Grammar;\n  entries: NumMap<SymbolSet> = {};\n  private _count = 0;\n\n  constructor(grammar: Grammar) {\n    this.grammar = grammar;\n  }\n\n  refresh(): void {\n    this.entries = {};\n    this._count = 0;\n  }\n\n  forEachTerm(nt: Sym, visitor: (x: Nullable<Sym>) => boolean | void): void {\n    const entries = this.entriesFor(nt);\n    entries.entries.forEach((x) => {\n      const term = this.grammar.getSymById(x);\n      TSU.assert(term != null && term.isTerminal);\n      visitor(term);\n    });\n    if (entries.hasNull) visitor(null);\n  }\n\n  get debugValue(): any {\n    const out = {} as any;\n    for (const x in this.entries) out[this.grammar.getSymById(x as any)!.label] = this.entries[x].debugString;\n    return out;\n  }\n\n  get count(): number {\n    let c = 0;\n    for (const x in this.entries) c += this.entries[x].size;\n    return c;\n    // TSU.assert(c == this._count, \"Count mismatch\")\n    // return this._count;\n  }\n\n  entriesFor(sym: Sym): SymbolSet {\n    if (sym.id in this.entries) {\n      return this.entries[sym.id];\n    } else {\n      const out = new SymbolSet(this.grammar);\n      this.entries[sym.id] = out;\n      return out;\n    }\n  }\n\n  /**\n   * Add the null symbol into this set of terminals for a given expression.\n   */\n  addNull(nt: Sym): boolean {\n    const entries = this.entriesFor(nt);\n    if (entries.hasNull) return false;\n    entries.hasNull = true;\n    return true;\n  }\n\n  /**\n   * Add a Null, term or another expression to the set of terminals\n   * for a given expression.  If source is an expression then all\n   * of the source expression's terminal symbosl are added to exp's\n   * term set.\n   */\n  add(nt: Sym, source: Sym, includeNull = true): boolean {\n    if (nt.isTerminal) {\n      TSU.assert(false, \"Should not be here\");\n    }\n    const entries = this.entriesFor(nt);\n    if (source.isTerminal) {\n      if (entries.has(source)) return false;\n      // console.log(`Adding Term(${term.label}) to Set of ${exp.id}`);\n      entries.add(source);\n      this._count++;\n    } else {\n      const srcEntries = this.entriesFor(source);\n      const destEntries = this.entriesFor(nt);\n      const count = srcEntries.addTo(destEntries, includeNull);\n      this._count += count;\n    }\n    return true;\n  }\n}\n\n/**\n * For each symbol maps its label to a list of terminals that\n * start that non terminal.\n */\nexport class FirstSets extends SymSymbolSets {\n  readonly nullables: NullableSet;\n\n  constructor(grammar: Grammar, nullables?: NullableSet) {\n    super(grammar);\n    if (!nullables) {\n      nullables = new NullableSet(grammar);\n    }\n    this.nullables = nullables;\n    this.refresh();\n  }\n\n  /**\n   * For a given string return the first(str) starting at a given index.\n   * Including eps if it exists.\n   */\n  forEachTermIn(str: Str, fromIndex = 0, visitor: (term: Nullable<Sym>) => void): void {\n    // This needs to be memoized by exp.id + index\n    const syms = str.syms;\n    const visited = {} as any;\n    let allNullable = true;\n    for (let j = fromIndex; allNullable && j < syms.length; j++) {\n      const symj = syms[j];\n      if (symj.isTerminal) {\n        visitor(symj);\n        allNullable = false;\n      } else {\n        const nt = symj as Sym;\n        this.forEachTerm(nt, (term) => {\n          if (term != null && !(term.id in visited)) {\n            visited[term.id] = true;\n            visitor(term);\n          }\n        });\n        if (!this.nullables.isNullable(symj as Sym)) {\n          allNullable = false;\n        }\n      }\n    }\n    if (allNullable) visitor(null);\n  }\n\n  /**\n   * Reevaluates the first sets of a grammar.\n   * This method assumes that the grammar's nullables are fresh.\n   */\n  refresh(): void {\n    super.refresh();\n    // this.grammar.terminals.forEach((t) => this.add(t, t));\n\n    let beforeCount = 0;\n    do {\n      beforeCount = this.count;\n      this.grammar.forEachRule(null, (rule) => {\n        this.processRule(rule);\n      });\n    } while (beforeCount != this.count);\n  }\n\n  processRule(rule: Rule): void {\n    const nullables = this.nullables;\n    let allNullable = true;\n    for (const s of rule.rhs.syms) {\n      // First(s) - null will be in First(nonterm)\n      // Null will onlybe added if all symbols are nullable\n      this.add(rule.nt, s, false);\n      if (s.isTerminal || !nullables.isNullable(s as Sym)) {\n        // since s is not nullable the next rule's first set\n        // cannot affect nonterm's firs set\n        allNullable = false;\n        break;\n      }\n    }\n    if (allNullable) this.addNull(rule.nt);\n  }\n}\n\n/**\n * For each symbol maps its label to a list of terminals that\n * start that non terminal.\n */\nexport class FollowSets extends SymSymbolSets {\n  readonly firstSets: FirstSets;\n\n  constructor(grammar: Grammar, firstSets?: FirstSets) {\n    super(grammar);\n    this.firstSets = firstSets || new FirstSets(grammar);\n    this.refresh();\n  }\n\n  get nullables(): NullableSet {\n    return this.firstSets.nullables;\n  }\n\n  /**\n   * Reevaluates the follow sets of each expression in our grammar.\n   * This method assumes that the grammar's nullables and firstSets are\n   * up-to-date.\n   */\n  refresh(): void {\n    super.refresh();\n    const g = this.grammar;\n    TSU.assert(g.startSymbol != null, \"Select start symbol of the grammar\");\n    this.add(g.startSymbol, g.Eof);\n\n    let beforeCount = 0;\n    do {\n      beforeCount = this.count;\n      this.grammar.forEachRule(null, (rule) => this.processRule(rule));\n    } while (beforeCount != this.count);\n  }\n\n  /**\n   * Add Follows[source] into Follows[dest] recursively.\n   */\n  processRule(rule: Rule): void {\n    const syms = rule.rhs.syms;\n    const firstSets = this.firstSets;\n    const nullables = this.firstSets.nullables;\n\n    // Rule 1:\n    //  If A -> aBb1b2b3..bn:\n    //    Follow(B) = Follow(B) U { First(b1b2b3...bn) - eps }\n    for (let i = 0; i < syms.length; i++) {\n      const sym = syms[i];\n      if (sym.isTerminal) continue;\n      firstSets.forEachTermIn(rule.rhs, i + 1, (term) => {\n        if (term != null) this.add(sym, term);\n      });\n    }\n\n    // Rule 2:\n    //  If A -> aBb1b2b3..bn:\n    //    if Nullable(b1b2b3...bn):\n    //      Follow(B) = Follow(B) U Follow(N)\n    for (let i = syms.length - 1; i >= 0; i--) {\n      if (syms[i].isTerminal) continue;\n\n      // This needs to be memoized??\n      let allNullable = true;\n      for (let j = i + 1; j < syms.length; j++) {\n        const symj = syms[j];\n        if (symj.isTerminal || !nullables.isNullable(symj as Sym)) {\n          allNullable = false;\n          break;\n        }\n      }\n      if (allNullable) {\n        this.add(syms[i], rule.nt);\n      }\n    }\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { allMinimalCycles } from \"./graph\";\nimport { IDSet, SymbolSet, FirstSets, FollowSets, NullableSet } from \"./sets\";\n\ntype StringMap<T> = TSU.StringMap<T>;\ntype Nullable<T> = TSU.Nullable<T>;\n\n/**\n * Symbols represent both terminals and non-terminals in our system.\n * Chosing a convention of using a single class to represent both instead\n * of a base class with Term and NonTerm children has the following effects:\n * 1. We can change the type of a literal when doing things like reading\n *    a grammar DSL when we dont konw if a symbol is a term or non-term\n *    until *all* the declarations have been read and parsed.\n * 2. The down side of this we would need more explicit isTerm checks\n *    but we would have done that anyway by calling getTerm and getNT\n *    verions of the getSym method.\n */\nexport class Sym {\n  isAuxiliary = false;\n  auxType: string | null = null;\n  precedence = 1;\n  assocLeft = true;\n\n  private static idCounter = -1;\n\n  /**\n   * An ID assigned to indicate order of \"creation\" of this symbol in the grammar.\n   */\n  creationId = -1;\n\n  /**\n   * ID unique across all expression within the grammar.\n   */\n  id: number;\n\n  /**\n   * Creates a new symbol in the grammar.\n   *\n   * @param   grammar     Grammar this symbol belongs to.\n   * @param   label       Label for the symbol.\n   * @param   isTerminal  Whether the symbol is a terminal or not.\n   * @param   id          ID unique across all expression within the\n   *                      grammar.\n   */\n  constructor(\n    public readonly grammar: Grammar,\n    public readonly label: string,\n    public isTerminal: boolean,\n    id: Nullable<number> = null,\n  ) {\n    this.isTerminal = isTerminal;\n    this.label = label;\n    if (id == null) {\n      this.id = Sym.idCounter--;\n    } else {\n      this.id = id;\n    }\n  }\n\n  compareTo(another: this): number {\n    return this.label.localeCompare(another.label);\n  }\n\n  equals(another: this): boolean {\n    return this.label == another.label;\n  }\n\n  toString(): string {\n    return this.label;\n  }\n}\n\nexport class Str {\n  syms: Sym[];\n\n  constructor(...syms: Sym[]) {\n    this.syms = syms || [];\n  }\n\n  append(...lits: Sym[]): this {\n    for (const l of lits) this.syms.push(l);\n    return this;\n  }\n\n  extend(...strs: Str[]): this {\n    for (const s of strs) this.append(...s.syms);\n    return this;\n  }\n\n  copy(): Str {\n    return new Str(...this.syms);\n  }\n\n  add(lit: Sym): void {\n    this.syms.push(lit);\n  }\n\n  isTerminal(index: number): boolean {\n    return this.syms[index].isTerminal;\n  }\n\n  get length(): number {\n    return this.syms.length;\n  }\n\n  toString(): string {\n    return this.syms.map((s) => s.toString()).join(\" \");\n  }\n\n  slice(startIndex: number, endIndex: number): Str {\n    return new Str(...this.syms.slice(startIndex, endIndex));\n  }\n\n  splice(index: number, numToDelete: number, ...itemsToAdd: Sym[]): Str {\n    this.syms.splice(index, numToDelete, ...itemsToAdd);\n    return this;\n  }\n\n  compareTo(another: this): number {\n    for (let i = 0; i < this.syms.length && i < another.syms.length; i++) {\n      const diff = this.syms[i].compareTo(another.syms[i]);\n      if (diff != 0) return diff;\n    }\n    return this.syms.length - another.syms.length;\n  }\n\n  equals(another: this): boolean {\n    return this.compareTo(another) == 0;\n  }\n\n  /**\n   * Returns true if another string is a substring within\n   * this string at the given offset.\n   */\n  containsAt(offset: number, another: Str): boolean {\n    let i = 0;\n    for (; i < another.length && offset + i < this.syms.length; i++) {\n      if (!this.syms[offset + i].equals(another.syms[i])) return false;\n      // if (this.cardinalities[i] != another.cardinalities[i]) return false;\n    }\n    return i == another.length;\n  }\n\n  get debugString(): string {\n    return this.syms.map((lit) => lit.label).join(\" \");\n  }\n}\n\nexport class RuleAction {\n  constructor(public value: string | number) {}\n\n  get isFunction(): boolean {\n    return typeof this.value === \"string\";\n  }\n\n  get isChildPosition(): boolean {\n    return typeof this.value === \"number\";\n  }\n}\n\nexport class Rule {\n  id: number;\n  constructor(\n    public nt: Sym,\n    public rhs: Str,\n    public action: RuleAction | null = null,\n  ) {\n    if (nt.isTerminal) {\n      throw new Error(\"Cannot add rules to a terminal\");\n    }\n  }\n\n  get debugString(): string {\n    return `${this.nt.label} -> ${this.rhs.debugString}`;\n  }\n\n  equals(another: this): boolean {\n    return this.compareTo(another) == 0;\n  }\n\n  compareTo(another: this): number {\n    TSU.assert(!isNaN(this.id));\n    const diff = this.nt.compareTo(another.nt);\n    if (diff == 0) {\n      this.rhs.compareTo(another.rhs);\n    }\n    return diff;\n  }\n}\n\nexport class Grammar {\n  public startSymbol: Nullable<Sym> = null;\n  modified = true;\n  protected symbolSet = new IDSet<Sym>((s) => s.label);\n  protected allRules: Rule[] = [];\n  protected _rulesForNT: Nullable<StringMap<Rule[]>> = null;\n  protected _followSets: Nullable<FollowSets> = null;\n\n  /**\n   * Prefix used for auxiliary symbols.\n   */\n  auxNTPrefix: string;\n\n  readonly Null: Sym;\n  readonly Eof: Sym;\n  private _AugStartRule: Rule;\n  private _hasNull = false;\n\n  /**\n   * A way of creating Grammars with a \"single expresssion\".\n   */\n  static make(callback: (g: Grammar) => void): Grammar {\n    const g = new Grammar();\n    callback(g);\n    return g;\n  }\n\n  constructor(config?: any) {\n    config = config || {};\n    this.auxNTPrefix = config.auxNTPrefix || \"$\";\n    this.Null = this.newTerm(\"\");\n    this.Eof = this.newTerm(\"$end\");\n  }\n\n  rulesForNT(nt: Sym): Rule[] {\n    TSU.assert(!nt.isTerminal);\n    if (this._rulesForNT == null) {\n      this._rulesForNT = {};\n      for (const rule of this.allRules) {\n        if (!(rule.nt.label in this._rulesForNT)) {\n          this._rulesForNT[rule.nt.label] = [];\n        }\n        this._rulesForNT[rule.nt.label].push(rule);\n      }\n    }\n    if (!(nt.label in this._rulesForNT)) {\n      this._rulesForNT[nt.label] = [];\n    }\n    return this._rulesForNT[nt.label];\n  }\n\n  get nullables(): NullableSet {\n    return this.firstSets.nullables;\n  }\n\n  get firstSets(): FirstSets {\n    return this.followSets.firstSets;\n  }\n\n  get followSets(): FollowSets {\n    if (this.modified || this._followSets == null) {\n      this.refresh();\n    }\n    TSU.assert(this._followSets != null);\n    return this._followSets;\n  }\n\n  get augStartRule(): Rule {\n    return this._AugStartRule;\n  }\n\n  augmentStartSymbol(label = \"$accept\"): this {\n    TSU.assert(this._AugStartRule == null, \"Ensure this grammar has not yet been augmented.\");\n    TSU.assert(this.startSymbol != null, \"Start symbol not yet set\");\n    const augSym = this.newNT(label);\n    this._AugStartRule = new Rule(augSym, new Str(this.startSymbol));\n    this.addRule(this._AugStartRule, 0);\n    return this;\n  }\n\n  refresh(): this {\n    this.symbolSet.entries.forEach((s, i) => (s.id = i));\n    this._rulesForNT = null;\n    this.allRules.forEach((rule, i) => {\n      rule.id = i;\n    });\n    this._followSets = new FollowSets(this);\n    this.modified = false;\n    return this;\n  }\n\n  addTerminals(...terminals: string[]): void {\n    for (const t of terminals) {\n      this.newTerm(t);\n    }\n  }\n\n  get terminals(): ReadonlyArray<Sym> {\n    return this.symbolSet.entries.filter((x) => x.isTerminal);\n  }\n\n  get allNonTerminals(): ReadonlyArray<Sym> {\n    return this.symbolSet.entries.filter((x) => !x.isTerminal);\n  }\n\n  get nonTerminals(): ReadonlyArray<Sym> {\n    return this.symbolSet.entries.filter((x) => !x.isTerminal && !x.isAuxiliary);\n  }\n\n  get auxNonTerminals(): ReadonlyArray<Sym> {\n    return this.symbolSet.entries.filter((x) => x.isAuxiliary);\n  }\n\n  get allSymbols(): ReadonlyArray<Sym> {\n    return this.symbolSet.entries;\n  }\n\n  /**\n   * A way to quickly iterate through all non-terminals.\n   */\n  forEachNT(visitor: (nt: Sym) => void | boolean | undefined | null): void {\n    for (const sym of this.symbolSet.entries) {\n      if (sym.isTerminal) continue;\n      if (visitor(sym) == false) return;\n    }\n  }\n\n  /**\n   * A iterator across all the rules for either all non terminals in this grammar\n   * for a single non terminal (if the nt value is non null).\n   *\n   * @param visitor\n   */\n  forEachRule(nt: Nullable<Sym>, visitor: (rule: Rule, index: number) => void | boolean | undefined | null): boolean {\n    const rules = nt == null ? this.allRules : this.rulesForNT(nt) || [];\n    for (let i = 0; i < rules.length; i++) {\n      if (visitor(rules[i], i) == false) return false;\n    }\n    return true;\n  }\n\n  getRule(nt: string | Sym, index: number): Rule {\n    if (typeof nt === \"string\") nt = this.getSym(nt)!;\n    TSU.assert(nt != null);\n    return this.rulesForNT(nt)[index];\n  }\n\n  /**\n   * Return the the index of a rule if it already exists to prevent duplicates.\n   */\n  findRule(nt: Sym, production: Str): number {\n    return this.rulesForNT(nt).findIndex((r) => r.nt == nt && r.rhs.equals(production));\n  }\n\n  /**\n   * Adds a new rule to a particular non terminal of the grammar\n   * Each rule represents a production of the form:\n   *\n   * name -> A B C D;\n   *\n   * Null production can be represented with an empty exps list.\n   */\n  add(nt: string | Sym, production: Str, action: RuleAction | null = null): Rule {\n    let nonterm: Nullable<Sym> = null;\n    if (typeof nt === \"string\") {\n      nonterm = this.getSym(nt);\n      if (nonterm == null) {\n        // create it\n        nonterm = this.newNT(nt);\n      }\n    } else {\n      nonterm = this.ensureSym(nt);\n    }\n    return this.addRule(new Rule(nonterm, production, action));\n  }\n\n  /**\n   * Add a rule directly.\n   */\n  addRule(rule: Rule, index = -1): Rule {\n    if (this.findRule(rule.nt, rule.rhs) >= 0) {\n      throw new Error(\"Duplicate rule: \" + rule.debugString);\n    }\n    rule.id = this.allRules.length;\n    if (rule.rhs.length == 0) this._hasNull = true;\n    if (index < 0) {\n      this.allRules.push(rule);\n    } else {\n      this.allRules.splice(index, 0, rule);\n    }\n    this._rulesForNT = null;\n    // this.rulesForNT(rule.nt).push(rule);\n    this.modified = true;\n    return rule;\n  }\n\n  /**\n   * Removes all rules from the grammar which match the given predicate.\n   */\n  removeRules(pred: (r: Rule) => boolean): boolean {\n    this.allRules = this.allRules.filter((r) => !pred(r));\n    this._rulesForNT = null;\n    this.modified = true;\n    return true;\n  }\n\n  /**\n   * Removes all symbols from the grammar and all of its productions which match\n   * a particular predicate.\n   */\n  removeSymbols(pred: (s: Sym) => boolean): boolean {\n    let modified = false;\n    const newRules: Rule[] = [];\n    this.allRules.forEach((r) => {\n      if (pred(r.nt)) return;\n      // if it was already a null production then leave it\n      if (r.rhs.length == 0) {\n        newRules.push(r);\n      } else {\n        const newRhs = new Str(...r.rhs.syms.filter((s) => !pred(s)));\n        modified = modified || r.rhs.length != newRhs.length;\n        if (newRhs.length > 0) {\n          newRules.push(new Rule(r.nt, newRhs));\n        }\n      }\n    });\n    this.allRules = newRules;\n    modified = this.symbolSet.remove(pred) || modified;\n    this.modified = this.modified || modified;\n    return modified;\n  }\n\n  /**\n   * Gets or creates a terminal with the given label.\n   * The grammar acts as a factory for terminal symbols\n   * so that we can reuse symbols instead of having\n   * users create new symbols each time.\n   *\n   * This also ensures that users are not able mix terminal\n   * and non terminal labels.\n   */\n  getSymById(id: number): Nullable<Sym> {\n    // if (id == Grammar.AUG_SYM_ID) return this._AugStartRule?.nt || null;\n    // else if (id == this.Eof.id) return this.Eof;\n    // else if (id == this.Null.id) return this.Null;\n    return this.symbolSet.get(id);\n  }\n\n  getSym(label: string): Nullable<Sym> {\n    // if (this._AugStartRule && label == this._AugStartRule.nt.label) return this._AugStartRule.nt;\n    return this.symbolSet.getByKey(label);\n  }\n\n  ensureSym(sym: Sym, throwIfExists = false): Sym {\n    const sym2 = this.symbolSet.ensure(sym, throwIfExists);\n    if (sym == sym2) {\n      if (sym2.creationId < 0) {\n        sym2.creationId = this.symbolSet.size;\n      }\n    } else {\n      TSU.assert(!throwIfExists, \"Should have already thrown error\");\n    }\n    return sym2;\n  }\n\n  /**\n   * Ensures that a terminal by a given name exists (creating if\n   * necessary).  If a terminal already exists by this label then\n   * an error is thrown.\n   *\n   * The grammar acts as a factory for terminal and non terminal symbols\n   * so that we can reuse symbols instead of having users create new\n   * symbols each time.  This also ensures that users are not able mix\n   * terminal and non terminal labels.\n   */\n  T(label: string, throwIfExists = false): Sym {\n    let t = this.getSym(label);\n    if (t != null) {\n      if (throwIfExists) throw new Error(`Terminal ${label} is already exists`);\n      if (!t.isTerminal) throw new Error(`Symbol (${label}) already exists as a non-terminal`);\n    } else {\n      t = new Sym(this, label, true);\n      t = this.ensureSym(t, true);\n    }\n    return t;\n  }\n\n  /**\n   * Ensures that a non term by a given name exists (creating if\n   * necessary).  If a terminal already exists by this label then\n   * an error is thrown.\n   *\n   * The grammar acts as a factory for terminal and non terminal symbols\n   * so that we can reuse symbols instead of having users create new\n   * symbols each time.  This also ensures that users are not able mix\n   * terminal and non terminal labels.\n   */\n  NT(label: string, isAuxiliary = false, throwIfExists = false): Sym {\n    let nt = this.getSym(label);\n    if (nt != null) {\n      if (throwIfExists) throw new Error(`Non-terminal ${label} is already exists`);\n      if (nt.isTerminal) throw new Error(`Symbol (${label}) already exists as a terminal`);\n    } else {\n      nt = new Sym(this, label, false);\n      nt.isAuxiliary = isAuxiliary;\n      nt = this.ensureSym(nt, true);\n      if (!isAuxiliary && this.startSymbol == null) {\n        this.startSymbol = nt;\n      }\n    }\n    return nt;\n  }\n\n  /**\n   * Creates a terminal with the given label if one does not\n   * already exist.\n   */\n  newTerm(label: string): Sym {\n    return this.T(label, true);\n  }\n\n  /**\n   * Creates a non terminal with the given label if it does not\n   * already exist.\n   */\n  newNT(label: string, isAuxiliary = false): Sym {\n    return this.NT(label, isAuxiliary, true);\n  }\n\n  /**\n   * Checks if a given label is a terminal.\n   */\n  isTerminal(label: string): boolean {\n    const t = this.getSym(label);\n    return t != null && t.isTerminal;\n  }\n\n  /**\n   * Checks if a given label is a non-terminal.\n   */\n  isNT(label: string): boolean {\n    const t = this.getSym(label);\n    return t != null && !t.isTerminal && !t.isAuxiliary;\n  }\n\n  /**\n   * Checks if a given label is an auxiliary non-terminal.\n   */\n  isAuxNT(label: string): boolean {\n    const t = this.getSym(label);\n    return t != null && !t.isTerminal && t.isAuxiliary;\n  }\n\n  seq(...exps: (Str | string)[]): Str {\n    if (exps.length == 1) {\n      return this.normalizeRule(exps[0]);\n    } else {\n      const out = new Str();\n      for (const e of exps) {\n        const s = this.normalizeRule(e);\n        // insert string here inline\n        // A ( B C D ) => A B C D\n        for (let i = 0; i < s.length; i++) {\n          // out.add(s.syms[i], s.cardinalities[i]);\n          out.add(s.syms[i]);\n        }\n      }\n      return out;\n    }\n  }\n\n  /**\n   * Provides a union rule:\n   *\n   * (A | B | C | D)\n   *\n   * Each of A, B, C or D themselves could be strings or literals.\n   */\n  anyof(...rules: (Str | string)[]): Str {\n    if (rules.length == 1) {\n      return this.normalizeRule(rules[0]);\n    } else {\n      // see if there is already NT with the exact set of rules\n      // reuse if it exists.  That would make this method\n      // Idempotent (which it needs to be).\n      return new Str(this.ensureAuxNT(...rules.map((r) => this.normalizeRule(r))));\n    }\n  }\n\n  opt(exp: Str | string): Str {\n    // convert to aux rule\n    const out = this.anyof(exp, new Str());\n    const nt = out.syms[0];\n    TSU.assert(out.syms.length == 1 && nt.isAuxiliary, \"NT must be an auxiliary symbol\");\n    nt.auxType = \"opt\";\n    return out;\n  }\n\n  atleast0(exp: Str | string, leftRec = true): Str {\n    const s = this.normalizeRule(exp);\n    // We want to find another auxiliary NT that has the following rules:\n    //    X -> exp X | ;    # if leftRec = true\n    //\n    //    X -> X exp | ;    # otherwise:\n    let auxNT = this.findAuxNT((auxNT) => {\n      const rules = this.rulesForNT(auxNT);\n      if (rules.length != 2) return false;\n\n      let which = 0;\n      if (rules[0].rhs.length == 0) {\n        which = 1;\n      } else if (rules[1].rhs.length == 0) {\n        which = 0;\n      } else {\n        return false;\n      }\n\n      const rule = rules[which].rhs;\n      if (rule.length != 1 + exp.length) return false;\n      if (rule.syms[0].equals(auxNT)) {\n        return rule.containsAt(1, s);\n      } else if (rule.syms[rule.length - 1].equals(auxNT)) {\n        return rule.containsAt(0, s);\n      }\n      return false;\n    });\n    if (auxNT == null) {\n      auxNT = this.newAuxNT();\n      auxNT.auxType = leftRec ? \"atleast0:left\" : \"atleast0\";\n      this.add(auxNT, new Str());\n      if (leftRec) {\n        this.add(auxNT, new Str(auxNT).extend(s));\n      } else {\n        this.add(auxNT, s.copy().append(auxNT));\n      }\n    }\n    return new Str(auxNT);\n  }\n\n  atleast1(exp: Str | string, leftRec = true): Str {\n    const s = this.normalizeRule(exp);\n    // We want to find another auxiliary NT that has the following rules:\n    //    X -> exp X | exp ;    # if leftRec = true\n    //\n    //    X -> X exp | exp ;    # otherwise:\n    let auxNT = this.findAuxNT((auxNT) => {\n      const rules = this.rulesForNT(auxNT);\n      if (rules.length != 2) return false;\n\n      let which = 0;\n      if (rules[0].rhs.equals(s)) {\n        which = 1;\n      } else if (rules[1].rhs.equals(s)) {\n        which = 0;\n      } else {\n        return false;\n      }\n\n      const rule = rules[which].rhs;\n      if (rule.length != 1 + exp.length) return false;\n      if (rule.syms[0].equals(auxNT)) {\n        return rule.containsAt(1, s);\n      } else if (rule.syms[rule.length - 1].equals(auxNT)) {\n        return rule.containsAt(0, s);\n      }\n      return false;\n    });\n    if (auxNT == null) {\n      auxNT = this.newAuxNT();\n      auxNT.auxType = leftRec ? \"atleast1:left\" : \"atleast1\";\n      this.add(auxNT, s);\n      if (leftRec) {\n        this.add(auxNT, new Str(auxNT).extend(s));\n      } else {\n        this.add(auxNT, s.copy().append(auxNT));\n      }\n    }\n    return new Str(auxNT);\n  }\n\n  normalizeRule(exp: Str | string): Str {\n    if (typeof exp === \"string\") {\n      const lit = this.getSym(exp);\n      if (lit == null) throw new Error(`Invalid symbol: '${exp}'`);\n      return new Str(lit);\n    } else {\n      // We have an expression that needs to be fronted by an\n      // auxiliarry non-terminal\n      return exp;\n    }\n  }\n\n  // Override this to have a different\n  protected auxNTCount = 0;\n  protected newAuxNTName(): string {\n    return this.auxNTPrefix + this.auxNTCount++;\n  }\n\n  newAuxNT(name = \"\"): Sym {\n    if (name == \"\") name = this.newAuxNTName();\n    return this.newNT(name, true);\n  }\n\n  ensureAuxNT(...rules: Str[]): Sym {\n    let nt = this.findAuxNTByRules(...rules);\n    if (nt == null) {\n      nt = this.newAuxNT();\n      nt.auxType = \"anyof\";\n      for (const rule of rules) this.add(nt, rule);\n    }\n    return nt;\n  }\n\n  /**\n   * Find an auxiliary rule that has the same rules as the ones here.\n   * This can be used to ensure duplicate rules are not created for\n   * union expressions.\n   */\n  findAuxNT(filter: (nt: Sym) => boolean): Nullable<Sym> {\n    for (const auxNT of this.symbolSet.entries) {\n      if (!auxNT.isAuxiliary) continue;\n      if (filter(auxNT)) return auxNT;\n    }\n    return null;\n  }\n\n  findAuxNTByRules(...rules: Str[]): Nullable<Sym> {\n    return this.findAuxNT((auxNT) => {\n      const ntRules = this.rulesForNT(auxNT);\n      if (ntRules.length != rules.length) return false;\n      for (let i = 0; i < ntRules.length; i++) {\n        if (!ntRules[i].rhs.equals(rules[i])) return false;\n      }\n      return true;\n    });\n  }\n\n  print(options: any = null): string[] {\n    options = options || {};\n    const ruleSep = options.ruleSep || \"->\";\n    const includeSemiColon = options.includeSemiColon || false;\n    const lambdaSymbol = options.lambdaSymbol || \"\";\n    const out: string[] = [];\n    this.forEachRule(null, (rule: Rule, index: number) => {\n      let r = `${rule.nt.label} ${ruleSep} `;\n      if (rule.rhs.length > 0) r += rule.rhs.debugString;\n      else r += lambdaSymbol;\n      if (includeSemiColon) r += \" ;\";\n      out.push(r);\n    });\n    return out;\n  }\n\n  /**\n   * Returns a flat list of all productions in a single list.\n   */\n  get debugValue(): string[] {\n    const out: string[] = [];\n    this.forEachRule(null, (rule: Rule, index: number) => {\n      out.push(`${rule.nt.label} -> ${rule.rhs.debugString}`);\n    });\n    return out;\n  }\n\n  /**\n   * Returns all non terminals that can derive terminals.\n   */\n  get terminalDerivingSymbols(): SymbolSet {\n    const out = new SymbolSet(this, null);\n    let nadded = -1;\n    let allDerive = true;\n    while (nadded != 0) {\n      nadded = 0;\n      for (const rule of this.allRules) {\n        allDerive = true;\n        for (const sym of rule.rhs.syms) {\n          if (!out.has(sym)) {\n            if (sym.isTerminal) {\n              out.add(sym);\n              nadded++;\n            } else {\n              allDerive = false;\n            }\n          }\n        }\n        if (allDerive && !out.has(rule.nt)) {\n          out.add(rule.nt);\n          nadded++;\n        }\n      }\n    }\n    return out;\n  }\n\n  /*\n   * Returns all non terminal that are reachable from a given symbol.\n   * If the FROM symbol is omitted then the start symbol is used.\n   */\n  reachableSymbols(fromSymbol: Nullable<Sym> = null): SymbolSet {\n    if (fromSymbol == null) {\n      fromSymbol = this._AugStartRule ? this._AugStartRule.nt : this.startSymbol;\n    }\n    TSU.assert(fromSymbol != null, \"Start symbol does not exist\");\n    const reachable = new SymbolSet(this, false).add(fromSymbol);\n    let queue: Sym[] = [fromSymbol];\n    while (queue.length > 0) {\n      const newQueue: Sym[] = [];\n      for (const curr of queue) {\n        for (const rule of this.rulesForNT(curr)) {\n          for (const sym of rule.rhs.syms) {\n            if (!sym.isTerminal && !reachable.has(sym)) {\n              newQueue.push(sym);\n              reachable.add(sym);\n            }\n          }\n        }\n      }\n      queue = newQueue;\n    }\n    return reachable;\n  }\n\n  /**\n   * Returns all cycles in this grammar.\n   */\n  get cycles(): ReadonlyArray<[Sym, any]> {\n    /*\n     * Returns the edge of the given nonterm\n     * For a nt such that:\n     *             S -> alpha1 X1 beta1 |\n     *                  alpha2 X2 beta2 |\n     *                  ...\n     *                  alphaN XN betaN |\n     *\n     * S's neighbouring nodes would be Xk if all of alphak is optional\n     * AND all of betak is optional\n     */\n    const edgeFunctor = (node: Sym): [Sym, any][] => {\n      const out: [Sym, any][] = [];\n      this.forEachRule(node, (rule, ruleIndex) => {\n        rule.rhs.syms.forEach((s, j) => {\n          if (s.isTerminal) return;\n          if (this.nullables.isStrNullable(rule.rhs, 0, j - 1) && this.nullables.isStrNullable(rule.rhs, j + 1)) {\n            out.push([s, [node, ruleIndex]]);\n          }\n        });\n      });\n      return out;\n    };\n    return allMinimalCycles(this.allNonTerminals, (val: Sym) => val.label, edgeFunctor);\n  }\n\n  /**\n   * Returns a set of \"Starting\" non terminals which have atleast\n   * one production containing left recursion.\n   */\n  get leftRecursion(): any {\n    const edgeFunctor = (node: Sym): [Sym, any][] => {\n      const out: [Sym, any][] = [];\n      this.forEachRule(node, (rule, ruleIndex) => {\n        rule.rhs.syms.forEach((s, j) => {\n          if (s.isTerminal) return;\n          out.push([s, ruleIndex]);\n          // If this is symbol is not nullable then we can stop here\n          return this.nullables.isNullable(s);\n        });\n      });\n      return out;\n    };\n    return allMinimalCycles(this.allNonTerminals, (val: Sym) => val.id, edgeFunctor);\n  }\n}\n","export enum CharClassType {\n  WORD_CHAR,\n  DIGITS,\n  SPACES,\n}\n\nconst ZERO = \"0\".charCodeAt(0);\nconst NINE = \"9\".charCodeAt(0);\nconst lA = \"a\".charCodeAt(0);\nconst lZ = \"z\".charCodeAt(0);\nconst uA = \"A\".charCodeAt(0);\nconst uZ = \"Z\".charCodeAt(0);\nconst USCORE = \"_\".charCodeAt(0);\n\n/**\n * An abstract class to be implemented for enabling different types of char classes.\n * Char classes are a form of \"short codes\" to identify characters.  eg SPACES, DIGITS etc.\n * Char classes are only shortcuts.  One can get away without using them and instead explicitly\n * construct the underlying state machine or regex (eg DIGIT could be replaced with [0-9]).\n */\nexport abstract class CharClassHelper {\n  matches(charCode: number, neg: boolean): boolean {\n    const res = this.match(charCode);\n    return neg ? !res : res;\n  }\n  protected abstract match(charCode: number): boolean;\n  abstract reString(neg: boolean): string;\n}\n\nconst spaceChars = \" \\f\\n\\r\\t\\v\\u00a0\\u1680\\u2028\\u2029\\u202f\\u205f\\u3000\\ufeff\";\n\n/**\n * Spaces - \\s => [ \\b\\c\\u00a0\\t\\r\\n\\u2028\\u2029<BOM><USP>]\n * BOM = \\uFEFF\n * USP = Other unicode space separator\n */\nexport class Spaces extends CharClassHelper {\n  match(charCode: number): boolean {\n    // if (charCode == 0x180e) return true;\n    if (charCode >= 0x2000 && charCode <= 0x200a) return true;\n    for (let i = 0; i < spaceChars.length; i++) {\n      if (spaceChars.charCodeAt(i) == charCode) return true;\n    }\n    return false;\n  }\n\n  reString(neg: boolean): string {\n    return neg ? \"\\\\S\" : \"\\\\s\";\n  }\n}\n\n/**\n * Char class for denoting a digit - [0-9].\n */\nexport class Digit extends CharClassHelper {\n  match(charCode: number): boolean {\n    return charCode >= ZERO && charCode <= NINE;\n  }\n\n  reString(neg: boolean): string {\n    return neg ? \"\\\\D\" : \"\\\\d\";\n  }\n}\n\n/**\n * Char class for denoting \"\\\\w\" - ie any WordChar\n */\nexport class WordChar extends CharClassHelper {\n  match(charCode: number): boolean {\n    return (\n      charCode == USCORE ||\n      (charCode >= ZERO && charCode <= NINE) ||\n      (charCode >= lA && charCode <= lZ) ||\n      (charCode >= uA && charCode <= uZ)\n    );\n    return true;\n  }\n\n  reString(neg: boolean): string {\n    return neg ? \"\\\\W\" : \"\\\\w\";\n  }\n}\n\nexport const CharClassHelpers: ReadonlyArray<CharClassHelper> = [new WordChar(), new Digit(), new Spaces()];\n","export enum PropertyName {\n  // Binary Property Names\n  gc,\n  General_Category = gc,\n  sc,\n  Script = sc,\n  scx,\n  Script_Extension = scx,\n\n  // Non binary property names\n  Any,\n  ASCII,\n  AHex,\n  ASCII_Hex_Digit = AHex,\n  Alpha,\n  Alphabetic = Alpha,\n  Bidi_M,\n  Bidi_Mirrored = Bidi_M,\n  Bidi_C,\n  Bidi_Control = Bidi_C,\n  CI,\n  Case_Ignorable = CI,\n  Cased,\n  CWCF,\n  Changes_When_Casefolded = CWCF,\n  CWCM,\n  Changes_When_Casemapped = CWCM,\n  CWL,\n  Changes_When_Lowercased = CWL,\n  CWKCF,\n  Changes_When_NFKC_Casefolded = CWKCF,\n  CWT,\n  Changes_When_Titlecased = CWT,\n  CWU,\n  Changes_When_Uppercased = CWU,\n  Dash,\n  DI,\n  Default_Ignorable_Code_Point = DI,\n  Dep,\n  Deprecated = Dep,\n  Dia,\n  Diacritic = Dia,\n  Emoji,\n  Emoji_Component,\n  Emoji_Modifier,\n  Emoji_Modifier_Base,\n  Emoji_Presentation,\n  Ext,\n  Extender = Ext,\n  Gr_Base,\n  Grapheme_Base = Gr_Base,\n  Gr_Ext,\n  Grapheme_Extend = Gr_Ext,\n  Hex,\n  Hex_Digit = Hex,\n  IDSB,\n  IDS_Binary_Operator = IDSB,\n  IDST,\n  IDS_Trinary_Operator = IDST,\n  IDC,\n  ID_Continue = IDC,\n  IDS,\n  ID_Start = IDS,\n  Ideo,\n  Ideographic = Ideo,\n  Join_C,\n  Join_Control = Join_C,\n  LOE,\n  Logical_Order_Exception = LOE,\n  Lower,\n  Lowercase = Lower,\n  Math,\n  NChar,\n  Noncharacter_Code_Point = NChar,\n  Pat_Syn,\n  Pattern_Syntax = Pat_Syn,\n  Pat_WS,\n  Pattern_White_Space = Pat_WS,\n  QMark,\n  Quotation_Mark = QMark,\n  Radical,\n  RI,\n  Regional_Indicator = RI,\n  STerm,\n  Sentence_Terminal = STerm,\n  SD,\n  Soft_Dotted = SD,\n  Term,\n  Terminal_Punctuation = Term,\n  UIdeo,\n  Unified_Ideograph = UIdeo,\n  Upper,\n  Uppercase = Upper,\n  VS,\n  Variation_Selector = VS,\n  space,\n  White_Space = space,\n  XIDC,\n  XID_Continue = XIDC,\n  XIDS,\n  XID_Start = XIDS,\n}\n\nexport enum PropertyValue {\n  // General Category proeprty values\n  LC,\n  Cased_Letter = LC,\n  Pe,\n  Close_Punctuation = Pe,\n  Pc,\n  Connector_Punctuation = Pc,\n  Cc,\n  cntrl = Cc,\n  Control = Cc,\n  Sc,\n  Currency_Symbol = Sc,\n  Pd,\n  Dash_Punctuation = Pd,\n  Nd,\n  digit = Nd,\n  Decimal_Number = digit,\n  Me,\n  Enclosing_Mark = Me,\n  Pf,\n  Final_Punctuation = Pf,\n  Cf,\n  Format = Cf,\n  Pi,\n  Initial_Punctuation = Pi,\n  L,\n  Letter = L,\n  Nl,\n  Letter_Number = Nl,\n  Zl,\n  Line_Separator = Zl,\n  Ll,\n  Lowercase_Letter = Ll,\n  M,\n  Combining_Mark = M,\n  Mark,\n  Sm,\n  Math_Symbol = Sm,\n  Lm,\n  Modifier_Letter = Lm,\n  Sk,\n  Modifier_Symbol = Sk,\n  Mn,\n  Nonspacing_Mark = Mn,\n  N,\n  Number = N,\n  Ps,\n  Open_Punctuation = Ps,\n  C,\n  Other = C,\n  Lo,\n  Other_Letter = Lo,\n  No,\n  Other_Number = No,\n  Po,\n  Other_Punctuation = Po,\n  So,\n  Other_Symbol = So,\n  Zp,\n  Paragraph_Separator = Zp,\n  Co,\n  Private_Use = Co,\n  P,\n  punct = P,\n  Punctuation = P,\n  Z,\n  Separator = Z,\n  Zs,\n  Space_Separator = Zs,\n  Mc,\n  Spacing_Mark = Mc,\n  Cs,\n  Surrogate = Cs,\n  S,\n  Symbol = S,\n  Lt,\n  Titlecase_Letter = Lt,\n  Cn,\n  Unassigned = Cn,\n  Lu,\n  Uppercase_Letter = Lu,\n  // Script and Script Extension proeprty values\n}\n\nexport function propertyNameFor(value: string): PropertyName {\n  value = value.trim();\n  if (!(value in PropertyName)) {\n    throw new SyntaxError(\"Invalid property name: \" + value);\n  }\n  return (PropertyName as any)[value];\n}\n\nexport function propertyValueFor(value: string): PropertyValue {\n  value = value.trim();\n  if (!(value in PropertyValue)) {\n    throw new SyntaxError(\"Invalid property value: \" + value);\n  }\n  return (PropertyValue as any)[value];\n}\n\nexport function propertyNameString(value: number): string {\n  if (!(value in PropertyName)) {\n    throw new Error(\"Invalid property name: \" + value);\n  }\n  return PropertyName[value];\n}\n\nexport function propertyValueString(value: number): string {\n  if (!(value in PropertyValue)) {\n    throw new Error(\"Invalid property value: \" + value);\n  }\n  return PropertyValue[value];\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { TapeInterface as Tape } from \"./tape\";\nimport { Char } from \"./core\";\n\nfunction isNewLineChar(ch: string): boolean {\n  return ch == \"\\r\" || ch == \"\\n\" || ch == \"\\u2028\" || ch == \"\\u2029\";\n}\n\nexport class Match {\n  groups: [number, number][] = [];\n  positions: number[] = [];\n  constructor(public priority = 10, public matchIndex = -1, public start = -1, public end = -1) {}\n}\n\nexport enum OpCode {\n  // Any character\n  Any,\n  // Any character not including a new line\n  AnyNonNL,\n  // Char and CI Chars\n  Char,\n  CIChar,\n  // NegChar,\n  // NegCIChar,\n\n  // Non char opcodes\n  Match,\n  Noop,\n  Save,\n  Split,\n  Jump,\n  Begin, // Forward lookahead matches\n  RBegin, // Reverse lookahead matches\n  End,\n\n  // Look ahead and Look back matchers\n  // ^ and $ that are not activated on newlines\n  StartingChar,\n  EndingChar,\n  // ^ and $ that are activated on newlines as well\n  MLStartingChar,\n  MLEndingChar,\n  StartOfWord,\n  EndOfWord,\n  GroupStart,\n  GroupEnd,\n\n  // Stops the thread if state does not match\n  EnsureState,\n}\n\nexport class Prog {\n  instrs: Instr[] = [];\n  stateMapping: Map<string, number>;\n\n  constructor(public readonly startCondition = \"INITIAL\", public readonly scIsInclusive = true) {\n    this.stateMapping = new Map<string, number>();\n    this.registerState(\"INITIAL\");\n    this.registerState(startCondition);\n  }\n\n  get length(): number {\n    return this.instrs.length;\n  }\n\n  /**\n   * Adds a state to our program and returns the state's index.\n   */\n  registerState(state: string): number {\n    if (!this.stateMapping.has(state)) {\n      this.stateMapping.set(state, this.stateMapping.size);\n    }\n    return this.stateMapping.get(state) || -1;\n  }\n\n  add(opcode: any, char: null | Char = null, ...args: number[]): Instr {\n    const out = new Instr(opcode, char).add(...args);\n    out.offset = this.instrs.length;\n    this.instrs.push(out);\n    return out;\n  }\n\n  static with(initializer: (prog: Prog) => void): Prog {\n    const out = new Prog();\n    initializer(out);\n    return out;\n  }\n\n  debugValue(instrDebugValue: (instr: Instr) => string = InstrDebugValue): any {\n    if (instrDebugValue) {\n      return this.instrs.map((instr, index) => {\n        if (instr.comment.trim().length > 0) return `L${index}: ${instrDebugValue(instr)}     # ${instr.comment}`;\n        else return `L${index}: ${instrDebugValue(instr)}`;\n      });\n    } else {\n      return this.instrs.map((instr, index) => `L${index}: ${instr.debugValue}`);\n    }\n  }\n}\n\nexport class Instr {\n  offset = 0;\n  comment = \"\";\n  args: number[] = [];\n  // used for char match instructions - if opcode == Char or CIChar\n  constructor(public readonly opcode: any, public char: null | Char = null) {\n    this.char = char;\n  }\n\n  add(...args: number[]): this {\n    this.args.push(...args);\n    return this;\n  }\n\n  get debugValue(): any {\n    let c = this.comment.trim();\n    if (c.length > 0) c = \"    # \" + c;\n    return `${this.opcode} ${this.args.join(\" \")}    ${this.char || \"\"}   ${c}`;\n  }\n}\n\n/**\n * A thread that is performing an execution of the regex VM.\n */\nexport class Thread {\n  parentId = -1;\n  id = 0;\n  priority = 0;\n  /**\n   * Saved positions into the input stream for the purpose of\n   * partial and custom matches.\n   */\n  groups: [number, number][] = [];\n  positions: number[] = [];\n  registers: TSU.NumMap<number> = {};\n\n  /**\n   * Create a thread at the given offset\n   */\n  constructor(public readonly offset: number = 0, public readonly gen: number = 0) {}\n\n  regIncr(regId: number): void {\n    if (!(regId in this.registers)) {\n      throw new Error(`Register at offset ${regId} is invalid`);\n    }\n    this.registers[regId]++;\n  }\n\n  regAcquire(regId: number): void {\n    if (regId in this.registers) {\n      throw new Error(`Register at offset ${regId} already acquired.  Release it first`);\n    }\n    this.registers[regId] = 0;\n  }\n\n  regRelease(regId: number): void {\n    if (!(regId in this.registers)) {\n      throw new Error(`Register at offset ${regId} is invalid`);\n    }\n    delete this.registers[regId];\n  }\n\n  regValue(regId: number): number {\n    if (!(regId in this.registers)) {\n      throw new Error(`Register at offset ${regId} is invalid`);\n    }\n    return this.registers[regId];\n  }\n}\n\nexport interface VMTracer {\n  threadDequeued(thread: Thread, tapeIndex: number): void;\n  threadStepped(thread: Thread, tapeIndex: number, gen: number): void;\n  threadQueued(thread: Thread, tapeIndex: number): void;\n}\n\nexport class VM {\n  // TODO - To prevent excessive heap activity and GC\n  // create a pool of threads and just have a cap on\n  // match sizes\n  // To eve simplify each Thread could just be something like:\n  // number[] where\n  //  number[0] == offset\n  //  number[1-2*MaxSubs] = Substitutions\n  //  number[2*MaxSubs - 2*MaxSubs + M] = Registers\n  //      where M = Max number of NewReg instructions\n  protected threadCounter = 0;\n  protected currThreads: Thread[] = [];\n  protected nextThreads: Thread[] = [];\n  protected startPos = 0; // Where the match is beginning from - this will be set to tape.index when match is called\n  // Initial state is always 0\n  protected currState = 0;\n\n  /**\n   * Get the current lexer state (for incremental lexing support).\n   * State is used to track context-sensitive lexing (e.g., inside string, comment).\n   */\n  getState(): number {\n    return this.currState;\n  }\n\n  /**\n   * Set the lexer state (for incremental lexing support).\n   * Allows restarting lexing from a saved state.\n   */\n  setState(state: number): void {\n    this.currState = state;\n  }\n\n  protected gen = 0;\n  // Records which \"generation\" of the match a particular\n  // offset is in.  If a thread is added at a particular\n  // offset the generation number is used to see if the\n  // thread is a duplicate (and avoided if so).  This\n  // ensures that are linearly bounded on the number of\n  // number threads as we match.\n  protected genForOffset: TSU.NumMap<number> = {};\n\n  tracer: VMTracer;\n  constructor(\n    public readonly prog: Prog,\n    public readonly start = 0,\n    public readonly end = -1,\n    public readonly forward = true,\n    configs: any = {},\n  ) {\n    if (end < 0) {\n      end = prog.length - 1;\n    }\n    this.end = end;\n  }\n\n  savePosition(thread: Thread, pos: number, tapeIndex: number): void {\n    while (thread.positions.length <= pos) thread.positions.push(-1);\n    thread.positions[pos] = tapeIndex;\n  }\n\n  jumpBy(thread: Thread, delta = 1): Thread {\n    return this.jumpTo(thread, thread.offset + delta);\n  }\n\n  jumpTo(thread: Thread, newOffset: number): Thread {\n    // TODO - Why create new thread here - investigate if we can\n    // return the same thread with the offset updated?\n    // if we really want a \"history\" we could jsut keep prev offsets\n    // in a list so we can keep a trace\n    const out = new Thread(newOffset, this.gen);\n    out.id = thread.id;\n    out.parentId = thread.parentId;\n    out.priority = thread.priority;\n    out.positions = thread.positions;\n    out.groups = thread.groups;\n    out.registers = thread.registers;\n    return out;\n  }\n\n  forkTo(thread: Thread, newOffset: number): Thread {\n    const out = new Thread(newOffset, this.gen);\n    out.id = ++this.threadCounter;\n    out.parentId = thread.id;\n    out.priority = thread.priority;\n    out.positions = [...thread.positions];\n    out.groups = [...thread.groups];\n    out.registers = { ...thread.registers };\n    return out;\n  }\n\n  startGroup(thread: Thread, groupIndex: number, tapeIndex: number): Thread {\n    const newThread = this.forkTo(thread, thread.offset + 1);\n    newThread.groups.push([groupIndex, tapeIndex]);\n    return newThread;\n  }\n\n  endGroup(thread: Thread, groupIndex: number, tapeIndex: number): Thread {\n    const newThread = this.forkTo(thread, thread.offset + 1);\n    newThread.groups.push([-groupIndex, tapeIndex]);\n    return newThread;\n  }\n\n  addThread(thread: Thread, list: Thread[], tape: Tape, delta = 0): void {\n    if (\n      thread.offset < this.start ||\n      thread.offset > this.end ||\n      this.genForOffset[thread.offset - this.start] == this.gen\n    ) {\n      // duplicate\n      return;\n    }\n    this.genForOffset[thread.offset - this.start] = this.gen;\n    const instr = this.prog.instrs[thread.offset];\n    let nextCh: string;\n    let lastCh: string;\n    let newThread: Thread;\n    // if (this.tracer) this.tracer.threadStepped(thread, tape.index, this.gen);\n    const opcode = instr.opcode;\n    switch (opcode) {\n      case OpCode.Jump:\n        newThread = this.jumpTo(thread, instr.args[0]);\n        this.addThread(newThread, list, tape, delta);\n        break;\n      case OpCode.Split:\n        for (let j = 0; j < instr.args.length; j++) {\n          const newOff = instr.args[j];\n          // TODO - only fork on position/group write instead of always forking on a split\n          const newThread = j == 0 ? this.jumpTo(thread, newOff) : this.forkTo(thread, newOff);\n          this.addThread(newThread, list, tape, delta);\n        }\n        break;\n      case OpCode.Save:\n        newThread = this.jumpTo(thread, thread.offset + 1);\n        this.savePosition(newThread, instr.args[0], tape.index + delta);\n        if (this.tracer) this.tracer.threadQueued(thread, tape.index + delta);\n        this.addThread(newThread, list, tape, delta);\n        break;\n      case OpCode.GroupStart:\n        newThread = this.startGroup(thread, instr.args[0], tape.index + delta);\n        if (this.tracer) this.tracer.threadQueued(thread, tape.index + delta);\n        this.addThread(newThread, list, tape, delta);\n        break;\n      case OpCode.GroupEnd:\n        newThread = this.endGroup(thread, instr.args[0], tape.index + delta);\n        if (this.tracer) this.tracer.threadQueued(thread, tape.index + delta);\n        this.addThread(newThread, list, tape, delta);\n        break;\n      case OpCode.StartingChar:\n      case OpCode.MLStartingChar:\n        // only proceed further if prev was a newline or start\n        lastCh = this.prevCh(tape);\n        if (tape.index == 0 || (opcode == OpCode.MLStartingChar && isNewLineChar(lastCh))) {\n          // have a match so can go forwrd but dont advance tape on\n          // the same generation\n          this.addThread(this.jumpBy(thread, 1), list, tape, delta);\n        }\n        break;\n      case OpCode.EndingChar:\n      case OpCode.MLEndingChar:\n        // On end of input we dont advance tape but thread moves on\n        // if at end of line boundary\n        // check if next is end of input\n        nextCh = this.nextCh(tape);\n        if (nextCh == \"\" || (opcode == OpCode.MLEndingChar && isNewLineChar(nextCh))) {\n          this.addThread(this.jumpBy(thread, 1), list, tape, delta);\n        }\n        break;\n      case OpCode.StartOfWord:\n        // only proceed further if prev was a newline or start\n        /*\n        lastCh = this.prevCh(tape);\n        if (tape.index == 0 || (this.multiline && (isNewLineChar(lastCh) || isSpaceChar(lastCh)))) {\n          // have a match so can go forwrd but dont advance tape on\n          // the same generation\n          this.addThread(this.jumpBy(thread, 1), list, tape, delta);\n        }\n       */\n        break;\n      case OpCode.EndOfWord:\n        // On end of input we dont advance tape but thread moves on\n        // if at end of line boundary\n        // check if next is end of input\n        /*\n        nextCh = this.nextCh(tape);\n        if (nextCh == \"\" || (this.multiline && (isNewLineChar(nextCh) || isSpaceChar(nextCh)))) {\n          this.addThread(this.jumpBy(thread, 1), list, tape, delta);\n        }\n       */\n        break;\n      case OpCode.RBegin:\n        {\n          const [groupIndex, negate, end] = instr.args;\n          const pos = (1 + groupIndex) * 2;\n          const groupStart = thread.positions[pos];\n          const [matchSuccess, matchEnd] = this.recurseMatch(\n            tape,\n            groupStart - 1,\n            instr.offset + 1,\n            end,\n            false,\n            negate == 1,\n          );\n          if (matchSuccess) {\n            // TODO - Consider using a DFA for this case so we can mitigate\n            // pathological cases with an exponential blowup on a success\n            this.addThread(this.jumpTo(thread, end + 1), list, tape, delta);\n          }\n        }\n        break;\n      case OpCode.Begin:\n        // This results in a new VM being created for this sub program and\n        // kicking off a backtracking execution - Making these as explicit\n        // constructs for the user to use means the user can make this choice\n        // on their own voilition\n        const [consume, negate, end] = instr.args;\n        if (consume == 1) {\n          // since this results in the consumption of a character (similar to \"Char\")\n          // defer this to the list\n          if (this.tracer) this.tracer.threadQueued(thread, tape.index);\n          list.push(thread);\n        } else {\n          const [matchSuccess, matchEnd] = this.recurseMatch(\n            tape,\n            tape.index + 1,\n            instr.offset + 1,\n            end,\n            true,\n            negate == 1,\n          );\n          if (matchSuccess) {\n            // TODO - Consider using a DFA for this case so we can mitigate\n            // pathological cases with an exponential blowup on a success\n            this.addThread(this.jumpTo(thread, end + 1), list, tape, delta);\n          }\n        }\n        break;\n      case OpCode.EnsureState:\n        const states = instr.args;\n        for (const state of states) {\n          if (this.currState == state) {\n            this.addThread(this.jumpBy(thread, 1), list, tape, delta);\n            break;\n          }\n        }\n        break;\n      default:\n        if (this.tracer) this.tracer.threadQueued(thread, tape.index);\n        list.push(thread);\n        break;\n    }\n  }\n\n  matchCurrPos(tape: Tape, char: Char, ignoreCase = false): boolean {\n    if (ignoreCase) {\n      return char.match(tape.currChCodeLower) || char.match(tape.currChCodeUpper);\n    } else {\n      return char.match(tape.currChCode);\n    }\n  }\n\n  protected hasMore(tape: Tape): boolean {\n    return this.forward ? tape.hasMore : tape.index >= 0;\n  }\n\n  protected nextCh(tape: Tape): string {\n    const next = tape.index + (this.forward ? 1 : -1);\n    return tape.charAt(next);\n    // if (next < 0 || next >= tape.input.length) return \"\";\n    // return tape.input[next];\n  }\n\n  protected prevCh(tape: Tape): string {\n    return tape.charAt(tape.index - (this.forward ? 1 : -1));\n    // return tape.input[tape.index - (this.forward ? 1 : -1)];\n  }\n\n  /**\n   * Runs the given instructions and returns a triple:\n   * [matchId, matchStart, matchEnd]\n   */\n  match(tape: Tape): Match | null {\n    // this.gen = 0; this.genForOffset = {};\n    if (this.end < this.start) return null;\n    this.startMatching(tape);\n    let bestMatch: TSU.Nullable<Match> = null;\n    while (this.currThreads.length > 0) {\n      bestMatch = this.stepChar(tape, bestMatch);\n    }\n    // ensure tape is rewound to end of last match\n    if (bestMatch != null) tape.index = bestMatch.end;\n    return bestMatch;\n  }\n\n  recurseMatch(\n    tape: Tape,\n    tapeIndex: number,\n    startOffset: number,\n    endOffset: number,\n    forward = true,\n    negate = false,\n  ): [boolean, number] {\n    const savedPos = tape.index;\n    if (!tape.canAdvance(forward ? 1 : -1)) return [negate, -1];\n    tape.index = tapeIndex;\n    // tape.advance(forward ? 1 : -1);\n    const vm = new VM(this.prog, startOffset, endOffset, forward);\n    const match = vm.match(tape);\n    const newPos = tape.index;\n    tape.index = savedPos; // always restore it first and let caller use it\n    return [(match != null && !negate) || (match == null && negate), newPos];\n  }\n\n  startMatching(tape: Tape): void {\n    this.currThreads = [];\n    this.nextThreads = [];\n    this.gen++;\n    this.addThread(new Thread(this.start, this.gen), this.currThreads, tape);\n    // let largestMatchEnd = -1;\n    // let lastMatchIndex = -1;\n    this.startPos = tape.index;\n  }\n\n  stepChar(tape: Tape, currMatch: TSU.Nullable<Match> = null): TSU.Nullable<Match> {\n    // At this point all our threads are point to the next \"transition\" or \"match\" action.\n    this.gen++;\n    // console.log(`Ch (@${tape.index}): ${tape.currChCode}, Gen (${this.gen})`);\n    for (let i = 0; i < this.currThreads.length; i++) {\n      const thread = this.currThreads[i];\n      // console.log(`   Thread (${i}): ${thread.offset}(${thread.gen})`);\n      const nextMatch = this.stepThread(tape, thread);\n      if (nextMatch != null) {\n        if (\n          currMatch == null ||\n          nextMatch.priority > currMatch.priority ||\n          (nextMatch.priority == currMatch.priority && nextMatch.end > currMatch.end)\n        ) {\n          currMatch = nextMatch;\n          break;\n        } else if (currMatch != nextMatch) {\n          // Since we kill of lower priority matches becuase of matchedInGen\n          // we should not be here\n          // TSU.assert(false, \"Should not be here\");\n        }\n      }\n    }\n    if (this.hasMore(tape)) {\n      tape.advance(this.forward ? 1 : -1);\n    }\n    this.currThreads = this.nextThreads;\n    this.nextThreads = [];\n    return currMatch;\n  }\n\n  stepThread(tape: Tape, thread: Thread): TSU.Nullable<Match> {\n    if (this.tracer) this.tracer.threadStepped(thread, tape.index, this.gen);\n    let currMatch: TSU.Nullable<Match> = null;\n    const instrs = this.prog.instrs;\n    const instr = instrs[thread.offset];\n    const opcode = instr.opcode;\n    const args = instr.args;\n    const delta = this.forward ? 1 : -1;\n    // Do char match based actions\n    let advanceTape = false;\n    let ch: number;\n    switch (opcode) {\n      case OpCode.RBegin:\n        throw new Error(\"Invalid state.  Reverse matches must be handled in addThread\");\n        break;\n      case OpCode.Begin:\n        const [consume, negate, end] = instr.args;\n        TSU.assert(consume == 1, \"Plain lookahead cannot be here\");\n        const [matchSuccess, matchEnd] = this.recurseMatch(tape, tape.index, instr.offset + 1, end, true, negate == 1);\n        if (matchSuccess) {\n          // TODO - Consider using a DFA for this case so we can mitigate\n          // pathological cases with an exponential blowup\n          // on a success we have a few options\n          this.addThread(this.jumpTo(thread, end + 1), this.nextThreads, tape);\n        }\n        break;\n      case OpCode.End:\n        // Return back to calling VM - very similar to a match\n        const out = new Match(-1, -1, this.startPos, tape.index);\n        out.groups = thread.groups;\n        out.positions = thread.positions;\n        return out;\n        break;\n      case OpCode.Match:\n        // we have a match on this thread so return it\n        // Update the match if we are a higher prioirty or longer match\n        // than what was already found (if any)\n        if (tape.index > this.startPos) {\n          const currPriority = instr.args[0];\n          const matchIndex = instr.args[1];\n          currMatch = new Match();\n          currMatch.start = this.startPos;\n          currMatch.end = tape.index;\n          currMatch.priority = currPriority;\n          currMatch.matchIndex = matchIndex;\n          currMatch.groups = thread.groups;\n          currMatch.positions = thread.positions;\n        }\n        break;\n      case OpCode.Char:\n      case OpCode.CIChar:\n        if (this.hasMore(tape)) {\n          advanceTape = this.matchCurrPos(tape, instr.char!, opcode == OpCode.CIChar);\n        }\n        break;\n      /*\n      case OpCode.NegChar:\n      case OpCode.NegCIChar:\n        if (this.hasMore(tape)) {\n          advanceTape = !this.matchCurrPos(tape, args, opcode == OpCode.NegCIChar);\n        }\n        break;\n      */\n      case OpCode.AnyNonNL:\n      case OpCode.Any:\n        if (this.hasMore(tape)) {\n          advanceTape = opcode == OpCode.Any || !isNewLineChar(tape.currCh);\n        }\n        break;\n    }\n    if (advanceTape /* && this.hasMore(tape) */) {\n      this.addThread(this.jumpBy(thread, 1), this.nextThreads, tape, delta);\n    }\n    return currMatch;\n  }\n}\n\nexport function InstrDebugValue(instr: Instr): string {\n  switch (instr.opcode) {\n    case OpCode.Match:\n      return `Match ${instr.args[0]} ${instr.args[1]}`;\n    // case OpCode.NegChar:\n    // case OpCode.NegCIChar:\n    case OpCode.Char:\n    case OpCode.CIChar: {\n      let out = `${OpCode[instr.opcode].toString()} `;\n      // out += `${CharType[instr.args[0]]}`;\n      // for (let i = 1; i < instr.args.length; i++) out += \" \" + instr.args[i];\n      out += `${instr.char!.debugValue()}`;\n      return out;\n    }\n    case OpCode.Any:\n      return \".\";\n    case OpCode.AnyNonNL:\n      return \"NL.\";\n    case OpCode.StartingChar:\n      return \"^\";\n    case OpCode.MLStartingChar:\n      return \"NL^\";\n    case OpCode.EndingChar:\n      return \"$NL\";\n    case OpCode.MLEndingChar:\n      return \"$NL_MultiLine\";\n    case OpCode.Save:\n      return `Save ${instr.args[0]}`;\n    case OpCode.GroupStart:\n      return `GroupStart ${instr.args[0]}`;\n    case OpCode.GroupEnd:\n      return `GroupEnd ${instr.args[0]}`;\n    case OpCode.Split:\n      return `Split ${instr.args.join(\", \")}`;\n    case OpCode.Jump:\n      return `Jump ${instr.args[0]}`;\n    case OpCode.Begin:\n      return `Begin ${instr.args.join(\" \")}`;\n    case OpCode.RBegin:\n      return `RBegin ${instr.args.join(\" \")}`;\n    case OpCode.End:\n      return `End ${instr.args.join(\" \")}`;\n    case OpCode.EnsureState:\n      return `EnsureState ${instr.args.join(\" \")}`;\n    default:\n      throw new Error(\"Invalid Opcode: \" + instr.opcode);\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\n\nimport {\n  Rule,\n  RegexType,\n  Quant,\n  Regex,\n  Cat,\n  Char,\n  CharType,\n  Var,\n  BackNumRef,\n  BackNamedRef,\n  LookAhead,\n  LookBack,\n  Union,\n} from \"./core\";\nimport { OpCode, Prog, Instr } from \"./vm\";\n\nexport type RegexResolver = (name: string) => Regex;\nexport type CompilerListener = (expr: Regex, prog: Prog, start: number, length: number) => void;\n\n/**\n * The regex Compiler compiles a parsed regular expression tree into bytecode that is\n * executed by the VM.\n */\nexport class Compiler {\n  emitGroups = false;\n  emitPosition = true;\n  constructor(\n    public regexResolver: TSU.Nullable<RegexResolver>,\n    public listener: TSU.Nullable<CompilerListener> = null,\n  ) {}\n\n  compile(rules: Rule[]): Prog {\n    // Split across each of our expressions\n    const out = new Prog();\n    // only add the split instruction if we have more than one rule\n    const split: Instr = rules.length <= 1 ? new Instr(OpCode.Split) : out.add(OpCode.Split, null);\n    rules.forEach((rule, i) => {\n      split.add(out.instrs.length);\n      const ignoreCase = rule.expr.ignoreCase == null ? false : rule.expr.ignoreCase;\n      const dotAll = rule.expr.dotAll == null ? true : rule.expr.dotAll;\n      const multiline = rule.expr.multiline == null ? true : rule.expr.multiline;\n      if (rule.needsSpecificStates && rule.activeStates != null) {\n        const ensureInstr = out.add(OpCode.EnsureState, null);\n        rule.activeStates.forEach((state) => {\n          const ind = out.registerState(state);\n          ensureInstr.add(ind);\n        });\n      }\n      this.compileExpr(rule.expr, out, ignoreCase, dotAll, multiline);\n      out.add(OpCode.Match, null).add(rule.priority, rule.matchIndex >= 0 ? rule.matchIndex : i);\n    });\n    return out;\n  }\n\n  /**\n   * Compile a given expression into a set of instructions.\n   */\n  protected compileExpr(expr: Regex, prog: Prog, ignoreCase: boolean, dotAll: boolean, multiline: boolean): number {\n    const start = prog.length;\n    const currOffset = prog.length;\n    if (expr.groupIndex >= 0) {\n      if (this.emitPosition) prog.add(OpCode.Save).add((1 + expr.groupIndex) * 2);\n      if (this.emitGroups) prog.add(OpCode.GroupStart).add(1 + expr.groupIndex);\n    }\n    if (expr.tag == RegexType.CHAR) {\n      this.compileChar(expr as Char, prog, ignoreCase, dotAll, multiline);\n    } else if (expr.tag == RegexType.START_OF_INPUT) {\n      const ml = expr.multiline == null ? multiline : expr.multiline;\n      prog.add(ml ? OpCode.MLStartingChar : OpCode.StartingChar);\n    } else if (expr.tag == RegexType.END_OF_INPUT) {\n      const ml = expr.multiline == null ? multiline : expr.multiline;\n      prog.add(ml ? OpCode.MLEndingChar : OpCode.EndingChar);\n    } else if (expr.tag == RegexType.START_OF_WORD) {\n      prog.add(OpCode.StartOfWord);\n    } else if (expr.tag == RegexType.END_OF_WORD) {\n      prog.add(OpCode.EndOfWord);\n    } else if (expr.tag == RegexType.CAT) {\n      this.compileCat(expr as Cat, prog, ignoreCase, dotAll, multiline);\n    } else if (expr.tag == RegexType.UNION) {\n      this.compileUnion(expr as Union, prog, ignoreCase, dotAll, multiline);\n    } else if (expr.tag == RegexType.QUANT) {\n      this.compileQuant(expr as Quant, prog, ignoreCase, dotAll, multiline);\n    } else if (expr.tag == RegexType.VAR) {\n      this.compileVar(expr as Var, prog, ignoreCase, dotAll, multiline);\n    } else if (expr.tag == RegexType.BACK_NAMED_REF) {\n      this.compileBackNamedRef(expr as BackNamedRef, prog, ignoreCase, dotAll, multiline);\n    } else if (expr.tag == RegexType.BACK_NUM_REF) {\n      this.compileBackNumRef(expr as BackNumRef, prog, ignoreCase, dotAll, multiline);\n      // } else if (expr.tag == RegexType.NEG) { this.compileNeg(expr as Neg, prog);\n    } else if (expr.tag == RegexType.LOOK_AHEAD) {\n      this.compileLookAhead(expr as LookAhead, prog, ignoreCase, dotAll, multiline);\n    } else if (expr.tag == RegexType.LOOK_BACK) {\n      this.compileLookBack(expr as LookBack, prog, ignoreCase, dotAll, multiline);\n    } else {\n      throw new Error(\"Regex Type not yet supported: \" + expr.tag);\n    }\n    if (expr.groupIndex >= 0) {\n      if (this.emitGroups) prog.add(OpCode.GroupEnd).add(1 + expr.groupIndex);\n      if (this.emitPosition) prog.add(OpCode.Save).add((1 + expr.groupIndex) * 2 + 1);\n    }\n    if (this.listener && prog.length > currOffset) {\n      this.listener(expr, prog, currOffset, prog.length - currOffset);\n    }\n    return prog.length - start;\n  }\n\n  protected compileChar(char: Char, prog: Prog, ignoreCase: boolean, dotAll: boolean, multiline: boolean): void {\n    if (char.op == CharType.AnyChar) {\n      // TODO - Should neg be ignored?\n      prog.add(dotAll ? OpCode.Any : OpCode.AnyNonNL);\n    } else {\n      const instr = prog.add(ignoreCase ? OpCode.CIChar : OpCode.Char);\n      instr.char = char;\n      /*\n      // We have Neg or not, CI or not\n      const instr = prog.add(\n        ignoreCase ? (char.neg ? OpCode.NegCIChar : OpCode.CIChar) : char.neg ? OpCode.NegChar : OpCode.Char,\n      );\n      instr.add(char.op);\n\n      // And now the arguments\n      for (const arg of char.args) instr.add(arg);\n      */\n    }\n  }\n\n  protected compileCat(cat: Cat, prog: Prog, ignoreCase: boolean, dotAll: boolean, multiline: boolean): void {\n    for (const child of cat.children) {\n      this.compileExpr(child, prog, ignoreCase, dotAll, multiline);\n    }\n  }\n\n  protected compileBackNumRef(\n    ne: BackNumRef,\n    prog: Prog,\n    ignoreCase: boolean,\n    dotAll: boolean,\n    multiline: boolean,\n  ): void {\n    // TODO - This may need a resolution at \"runtime\" so the instruction\n    // should reflect as such?\n    // See compiler.spec.ts - \"Test Back Named Groups\"\n    throw new Error(\"BackNumRef Not Implemented\");\n  }\n\n  protected compileBackNamedRef(\n    ne: BackNamedRef,\n    prog: Prog,\n    ignoreCase: boolean,\n    dotAll: boolean,\n    multiline: boolean,\n  ): void {\n    // TODO - This may need a resolution at \"runtime\" so the instruction\n    // should reflect as such?\n    // See compiler.spec.ts - \"Test Back Named Groups\"\n    throw new Error(\"BackNameRef Not Implemented\");\n  }\n\n  protected compileVar(v: Var, prog: Prog, ignoreCase: boolean, dotAll: boolean, multiline: boolean): void {\n    const name = v.name.trim();\n    const expr = this.regexResolver ? this.regexResolver(name) : null;\n    if (expr == null) {\n      throw new Error(`Cannot find expression: ${name}`);\n    }\n    this.compileExpr(expr, prog, ignoreCase, dotAll, multiline);\n  }\n\n  protected compileUnion(union: Union, prog: Prog, ignoreCase: boolean, dotAll: boolean, multiline: boolean): void {\n    const split = prog.add(OpCode.Split);\n    const jumps: Instr[] = [];\n\n    for (let i = 0; i < union.options.length; i++) {\n      split.add(prog.length);\n      this.compileExpr(union.options[i], prog, ignoreCase, dotAll, multiline);\n      if (i < union.options.length - 1) {\n        jumps.push(prog.add(OpCode.Jump));\n      }\n    }\n    for (const jmp of jumps) {\n      jmp.add(prog.length);\n    }\n  }\n\n  /**\n   * Compiles a repetition (with quantifiers) into its instructions.  This explicitly expands\n   * a rule of the form x\\{a,b\\} to xx... (a) times followed by x? (b - a) times\n   */\n  protected compileQuant(quant: Quant, prog: Prog, ignoreCase: boolean, dotAll: boolean, multiline: boolean): void {\n    // optimize the special cases of *, ? and +\n    if (quant.minCount == 0 && quant.maxCount == TSU.Constants.MAX_INT) {\n      // *\n      this.compileAtleast0(quant.expr, prog, quant.greedy, ignoreCase, dotAll, multiline);\n    } else if (quant.minCount == 1 && quant.maxCount == TSU.Constants.MAX_INT) {\n      // +\n      this.compileAtleast1(quant.expr, prog, quant.greedy, ignoreCase, dotAll, multiline);\n    } else if (quant.minCount == 0 && quant.maxCount == 1) {\n      // ?\n      this.compileOptional(quant.expr, prog, quant.greedy, ignoreCase, dotAll, multiline);\n    } else {\n      // general case - Currently going with Option 1\n      //\n      // - convert x{a,b} to xxxxxx (a) times followed by x? b - a times\n      for (let i = 0; i < quant.minCount; i++) {\n        this.compileExpr(quant.expr, prog, ignoreCase, dotAll, multiline);\n      }\n      // generate x? b - a times\n      if (quant.isUnlimited) {\n        // then generate a a* here\n        this.compileAtleast0(quant.expr, prog, quant.greedy, ignoreCase, dotAll, multiline);\n      } else {\n        for (let i = quant.minCount; i < quant.maxCount; i++) {\n          this.compileOptional(quant.expr, prog, quant.greedy, ignoreCase, dotAll, multiline);\n        }\n      }\n    }\n  }\n\n  protected compileAtleast1(\n    expr: Regex,\n    prog: Prog,\n    greedy = true,\n    ignoreCase: boolean,\n    dotAll: boolean,\n    multiline: boolean,\n  ): void {\n    const l1 = prog.length;\n    this.compileExpr(expr, prog, ignoreCase, dotAll, multiline);\n    const split = prog.add(OpCode.Split);\n    const l3 = prog.length;\n    if (greedy) {\n      split.add(l1, l3);\n    } else {\n      split.add(l3, l1);\n    }\n  }\n\n  protected compileAtleast0(\n    expr: Regex,\n    prog: Prog,\n    greedy: boolean,\n    ignoreCase: boolean,\n    dotAll: boolean,\n    multiline: boolean,\n  ): void {\n    const split = prog.add(OpCode.Split);\n    const l1 = split.offset;\n    const l2 = prog.length;\n    this.compileExpr(expr, prog, ignoreCase, dotAll, multiline);\n    prog.add(OpCode.Jump).add(l1);\n    const l3 = prog.length;\n    if (greedy) {\n      split.add(l2, l3);\n    } else {\n      split.add(l3, l2);\n    }\n  }\n\n  protected compileOptional(\n    expr: Regex,\n    prog: Prog,\n    greedy: boolean,\n    ignoreCase: boolean,\n    dotAll: boolean,\n    multiline: boolean,\n  ): void {\n    const split = prog.add(OpCode.Split);\n    const l1 = prog.length;\n    this.compileExpr(expr, prog, ignoreCase, dotAll, multiline);\n    const l2 = prog.length;\n    if (greedy) {\n      split.add(l1, l2);\n    } else {\n      split.add(l2, l1);\n    }\n  }\n\n  /**\n   * Compiles lookahead assertions\n   */\n  protected compileLookAhead(\n    la: LookAhead,\n    prog: Prog,\n    ignoreCase: boolean,\n    dotAll: boolean,\n    multiline: boolean,\n  ): void {\n    // how should this work?\n    // Ensure that assertion matches first before continuing with the expression\n    this.compileExpr(la.expr, prog, ignoreCase, dotAll, multiline);\n    const begin = prog.add(OpCode.Begin).add(0, la.negate ? 1 : 0); // negate if needed\n    this.compileExpr(la.cond, prog, ignoreCase, dotAll, multiline);\n    const end = prog.add(OpCode.End).add(begin.offset);\n    begin.add(end.offset);\n  }\n\n  /**\n   * Compiles lookback assertions\n   */\n  protected compileLookBack(lb: LookBack, prog: Prog, ignoreCase: boolean, dotAll: boolean, multiline: boolean): void {\n    // Ensure that assertion matches first before continuing with the expression\n    this.compileExpr(lb.expr, prog, ignoreCase, dotAll, multiline);\n    TSU.assert(lb.expr.groupIndex >= 0, \"LookBack Assertion requires expression to have a group Index\");\n    const begin = prog.add(OpCode.RBegin).add(lb.expr.groupIndex, lb.negate ? 1 : 0); // negate if needed\n    this.compileExpr(lb.cond.reverse(), prog, ignoreCase, dotAll, multiline);\n    const end = prog.add(OpCode.End).add(begin.offset);\n    begin.add(end.offset);\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { Token } from \"./token\";\n\nexport class TokenizerError extends Error {\n  readonly name: string = \"TokenizerError\";\n\n  constructor(\n    message: string,\n    public offset: number,\n    public length: number,\n    public type: string,\n    public value: any = null,\n  ) {\n    super(message);\n    Object.setPrototypeOf(this, new.target.prototype);\n  }\n}\n\nexport class UnexpectedTokenError extends Error {\n  readonly name: string = \"UnexpectedTokenError\";\n  expectedTokens: Token[];\n\n  constructor(public foundToken: TSU.Nullable<Token>, ...expectedTokens: Token[]) {\n    super(\n      `Found Token: ${foundToken?.tag || \"EOF\"} (${foundToken?.value || \"\"}), Expected: ${expectedTokens.join(\", \")}`,\n    );\n    this.expectedTokens = expectedTokens;\n  }\n}\n","export abstract class TapeInterface {\n  index = 0;\n  abstract charAt(index: number): string;\n  abstract hasIndex(index: number): boolean;\n  abstract substring(startIndex: number, endIndex: number): string;\n\n  constructor(public forward = true) {}\n\n  advance(delta = 1): boolean {\n    const next = this.forward ? this.index + delta : this.index - delta;\n    // if (!this.hasIndex(next)) return false;\n    this.index = next;\n    return true;\n  }\n\n  canAdvance(delta = 1): boolean {\n    const next = this.forward ? this.index + delta : this.index - delta;\n    return this.hasIndex(next);\n  }\n\n  get hasMore(): boolean {\n    const next = this.forward ? this.index : this.index - 1;\n    return this.hasIndex(next);\n    // return this.forward ? this.index < this.input.length : this.index > 0;\n  }\n\n  get currCh(): string {\n    return this.charAt(this.index);\n  }\n\n  get prevCh(): string {\n    return this.charAt(this.index - (this.forward ? 1 : -1));\n  }\n\n  get nextCh(): string {\n    const next = this.index + (this.forward ? 1 : -1);\n    return this.charAt(next);\n  }\n\n  get currChCode(): number {\n    if (!this.hasMore) return -1;\n    return this.currCh.charCodeAt(0);\n    // return this.input.charCodeAt(this.index);\n  }\n\n  get currChCodeLower(): number {\n    if (!this.hasMore) return -1;\n    return this.currCh.toLowerCase().charCodeAt(0);\n  }\n\n  get currChCodeUpper(): number {\n    if (!this.hasMore) return -1;\n    return this.currCh.toUpperCase().charCodeAt(0);\n  }\n\n  charCodeAt(index: number): number {\n    if (!this.hasIndex(index)) return -1;\n    return this.charAt(index).charCodeAt(0);\n  }\n\n  charCodeAtLower(index: number): number {\n    if (!this.hasIndex(index)) return -1;\n    return this.charAt(index).toLowerCase().charCodeAt(0);\n  }\n\n  charCodeAtUpper(index: number): number {\n    if (!this.hasIndex(index)) return -1;\n    return this.charAt(index).toUpperCase().charCodeAt(0);\n  }\n}\n\n/**\n * A Tape of characters we would read with some extra helpers like rewinding\n * forwarding and prefix checking that is fed into the different tokenizers\n * used by the scannerless parsers.\n */\nexport class Tape extends TapeInterface {\n  protected _rawInput: string;\n  readonly input: string[];\n\n  constructor(input: string, public forward = true) {\n    super(forward);\n    this._rawInput = input;\n    this.input = [...input];\n  }\n\n  push(content: string): void {\n    this._rawInput += content;\n    this.input.push(...content);\n  }\n\n  substring(startIndex: number, endIndex: number): string {\n    return this._rawInput.substring(startIndex, endIndex);\n    // return this.input.slice(startIndex, endIndex).join(\"\");\n  }\n\n  hasIndex(index: number): boolean {\n    return index >= 0 && index < this.input.length;\n  }\n\n  charAt(index: number): string {\n    if (index < 0 || index >= this.input.length) return \"\";\n    return this.input[index];\n  }\n}\n\nexport class TapeHelper {\n  /**\n   * Advances the tape to the end of the first occurence of\n   * the given pattern.\n   */\n  static advanceAfter(tape: TapeInterface, pattern: string, ensureNoPrefixSlash = true): number {\n    let pos = TapeHelper.advanceTo(tape, pattern, ensureNoPrefixSlash);\n    if (pos >= 0) {\n      pos += pattern.length;\n      tape.index = pos;\n    }\n    return pos;\n  }\n\n  /**\n   * Advances the tape till the start of a given pattern.\n   * This is not the most optimal implementation and just does a brute\n   * force search at each index.  Instead using the Regex interface\n   * directly will be faster.\n   */\n  static advanceTo(tape: TapeInterface, pattern: string, ensureNoPrefixSlash = true): number {\n    const lastIndex = tape.index;\n    while (tape.hasMore) {\n      const currStart = tape.index;\n      if (TapeHelper.matches(tape, pattern)) {\n        const endIndex = tape.index;\n        tape.index = currStart;\n        let numSlashes = 0;\n        if (ensureNoPrefixSlash) {\n          for (let i = endIndex - 1; i >= 0; i--) {\n            if (tape.charAt(i) == \"\\\\\") numSlashes++;\n            else break;\n          }\n        }\n        if (numSlashes % 2 == 0) {\n          return tape.index;\n        }\n      }\n      tape.advance(1);\n    }\n    tape.index = lastIndex;\n    throw new Error(`Unexpected end of input before (${pattern})`);\n    return -1;\n  }\n\n  /**\n   * Tells if the given prefix is matche at the current position of the tokenizer.\n   */\n  static matches(tape: TapeInterface, prefix: string, advance = true): boolean {\n    const lastIndex = tape.index;\n    let i = 0;\n    let success = true;\n    for (; i < prefix.length; i++) {\n      if (prefix[i] != tape.currCh) {\n        success = false;\n        break;\n      }\n      tape.advance(1);\n    }\n    // Reset pointers if we are only peeking or match failed\n    if (!advance || !success) {\n      tape.index = lastIndex;\n    }\n    return success;\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { TapeInterface as Tape } from \"./tape\";\nimport { TokenizerError, UnexpectedTokenError } from \"./errors\";\n\nexport type TokenType = number | string;\n\nexport class Token {\n  private static idCounter = 0;\n  // ID for uniquely identifying tokens if needed for shallow equality\n  id = Token.idCounter++;\n  value: any = null;\n  groups: TSU.NumMap<number[]> = {};\n  positions: TSU.NumMap<[number, number]> = {};\n\n  // Incremental lexing support fields\n  /**\n   * Lexer state when this token was constructed.\n   * 0 = INITIAL state. Higher numbers represent other states (e.g., inside string, comment).\n   * Used for incremental lexing to restart from a token boundary.\n   */\n  state = 0;\n\n  /**\n   * Number of characters read beyond this token's lexeme to determine it.\n   * Most tokens need 1 char lookahead to know they're complete (e.g., identifier ends on non-alnum).\n   * Used for incremental lexing dependency tracking.\n   */\n  lookahead = 1;\n\n  /**\n   * Number of preceding tokens whose lookahead reaches this token.\n   * Default 1 means the previous token's lookahead extends into this token.\n   * Used for incremental lexing to find affected region on edit.\n   */\n  lookback = 1;\n\n  constructor(public tag: TokenType, public readonly matchIndex: number, public start: number, public end: number) {}\n\n  isOneOf(...expected: any[]): boolean {\n    for (const tok of expected) {\n      if (this.tag == tok) {\n        return true;\n      }\n    }\n    return false;\n  }\n}\n\nexport type NextTokenFunc = (tape: Tape, owner: any) => Token | null;\n\n/**\n * A wrapper on a tokenizer for providing features like k-lookahead, token\n * insertion, rewinding, expectation enforcement etc.\n */\nexport class TokenBuffer {\n  buffer: Token[] = [];\n\n  constructor(public readonly nextToken: NextTokenFunc, public tokenizerContext: any) {}\n\n  next(tape: Tape): Token | null {\n    const out = this.peek(tape);\n    if (out != null) {\n      this.consume();\n    }\n    return out;\n  }\n\n  /**\n   * Peek at the nth token in the token stream.\n   */\n  peek(tape: Tape, nth = 0): Token | null {\n    while (this.buffer.length <= nth) {\n      const tok = this.nextToken(tape, this.tokenizerContext);\n      if (tok == null) return null;\n      this.buffer.push(tok);\n    }\n    return this.buffer[nth];\n  }\n\n  match(\n    tape: Tape,\n    matchFunc: (token: Token) => boolean,\n    ensure = false,\n    consume = true,\n    nextAction?: (token: Token) => boolean | undefined,\n  ): Token | null {\n    const token = this.peek(tape);\n    if (token != null) {\n      if (matchFunc(token)) {\n        if (nextAction && nextAction != null) {\n          nextAction(token);\n        }\n        if (consume) {\n          this.consume();\n        }\n      } else if (ensure) {\n        // Should we throw an error?\n        throw new UnexpectedTokenError(token);\n      } else {\n        return null;\n      }\n    } else if (ensure) {\n      throw new TokenizerError(\"Unexpected end of input\", -1, 0, \"UnexpectedEndOfInput\");\n    }\n    return token;\n  }\n\n  consume(): void {\n    this.buffer.splice(0, 1);\n  }\n\n  consumeIf(tape: Tape, ...expected: TokenType[]): Token | null {\n    return this.match(tape, (t) => t.isOneOf(...expected));\n  }\n\n  expectToken(tape: Tape, ...expected: TokenType[]): Token {\n    return this.match(tape, (t) => t.isOneOf(...expected), true, true) as Token;\n  }\n\n  ensureToken(tape: Tape, ...expected: TokenType[]): Token {\n    return this.match(tape, (t) => t.isOneOf(...expected), true, false) as Token;\n  }\n\n  nextMatches(tape: Tape, ...expected: TokenType[]): Token | null {\n    const token = this.peek(tape);\n    if (token == null) return null;\n    for (const tok of expected) {\n      if (token.tag == tok) return token;\n    }\n    return null;\n  }\n}\n","export class GroupCounter {\n  value = -1;\n  next(): number {\n    return ++this.value;\n  }\n  get current(): number {\n    return this.value;\n  }\n}\n\nexport function isSpace(ch: string): boolean {\n  return ch == \" \" || ch == \"\\t\" || ch == \"\\n\" || ch == \"\\r\";\n}\n\n// function isSpaceChar(ch: string): boolean { return ch == \" \" || ch == \"\\t\"; }\n","import * as TSU from \"@panyam/tsutils\";\nimport {\n  Quant,\n  RegexType,\n  StartOfInput,\n  EndOfInput,\n  Regex,\n  Cat,\n  Char,\n  LeafChar,\n  CharGroup,\n  CharType,\n  Var,\n  BackNamedRef,\n  BackNumRef,\n  LookAhead,\n  LookBack,\n  Union,\n} from \"./core\";\nimport { CharClassType } from \"./charclasses\";\nimport { GroupCounter } from \"./utils\";\n\n/**\n * A RegexParser for parsing regex strings in JS RegExp format.\n * This class will seldom have to be used directly.  Instead use one of the methods in {@link Builder}\n */\nexport class RegexParser {\n  protected unicode: boolean;\n  protected counter: GroupCounter;\n  /**\n   * @param pattern The pattern string being parsed.\n   * @param config  Configs for the regex to include whether parsing is unicode or plain ASCII.\n   */\n  constructor(public readonly pattern: string, config?: { unicode?: boolean }) {\n    this.counter = new GroupCounter();\n    this.unicode = config?.unicode || false;\n  }\n\n  protected reduceLeft(stack: Regex[]): Regex {\n    const r = stack.length == 1 ? stack[0] : new Cat(...stack);\n    // remove all elements on stack\n    stack.splice(0);\n    return r;\n  }\n\n  protected throwError(msg: string): void {\n    throw new SyntaxError(`Error in JS RE '${this.pattern}': ${msg}`);\n  }\n\n  /**\n   * Creates a regex tree given a string\n   */\n  parse(curr = 0, end = -1): Regex {\n    const pattern = this.pattern;\n    const stack: Regex[] = [];\n    if (end < 0) end = pattern.length - 1;\n    while (curr <= end) {\n      const currCh = pattern[curr];\n      // see if we have groups so they get highest preference\n      if (currCh == \".\") {\n        stack.push(LeafChar.Any());\n        curr++;\n      } else if (currCh == \"\\\\\" && pattern[curr + 1] >= \"1\" && pattern[curr + 1] <= \"9\") {\n        // Numeric references\n        curr++;\n        let num = \"\";\n        while (curr <= end && pattern[curr] >= \"0\" && pattern[curr] <= \"9\") {\n          num = num + pattern[curr++];\n        }\n        const refNum = parseInt(num);\n        if (refNum > this.counter.current + 1) {\n          this.throwError(\"Invalid reference: \" + refNum);\n        }\n        stack.push(new BackNumRef(refNum));\n      } else if (currCh == \"\\\\\" && pattern[curr + 1] == \"k\" && pattern[curr + 2] == \"<\") {\n        // Named references\n        curr += 3;\n        let gtPos = curr;\n        while (gtPos <= end && pattern[gtPos] != \">\") gtPos++;\n        if (gtPos > end) this.throwError(\"Expected '>' found EOI\");\n        const name = pattern.substring(curr, gtPos);\n        if (name.trim() == \"\") {\n          this.throwError(\"Expected name\");\n        }\n        stack.push(new BackNamedRef(name));\n        curr = gtPos + 1;\n      } else if (currCh == \"[\") {\n        // character ranges\n        let clPos = curr + 1;\n        while (clPos <= end && pattern[clPos] != \"]\") {\n          if (pattern[clPos] == \"\\\\\") clPos++;\n          clPos++;\n        }\n        if (clPos > end) this.throwError(\"Expected ']' found EOI\");\n        stack.push(this.parseCharGroup(curr + 1, clPos - 1));\n        curr = clPos + 1;\n      } else if (currCh == \"^\") {\n        stack.push(new StartOfInput());\n        curr++;\n      } else if (currCh == \"$\") {\n        stack.push(new EndOfInput());\n        curr++;\n      } else if (currCh == \"|\") {\n        if (curr + 1 <= end) {\n          // reduce everything \"until now\" and THEN apply\n          const prev = this.reduceLeft(stack);\n          // this.parse everything to the right\n          const rest = this.parse(curr + 1, end);\n          return new Union(prev, rest);\n        }\n        curr = end + 1;\n      } else if (currCh == \"(\") {\n        curr = this.parseGroup(stack, curr, end);\n      } else if (currCh == \")\" || currCh == \"]\" || currCh == \"}\") {\n        this.throwError(`Unmatched ${currCh}.  Try using \\\\${currCh}`);\n      } else if (pattern[curr] == \"*\" || pattern[curr] == \"?\" || pattern[curr] == \"+\" || pattern[curr] == \"{\") {\n        curr = this.parseQuant(stack, curr, end);\n      } else {\n        // plain old alphabets\n        const [result, nchars] = this.parseChar(curr, end);\n        stack.push(result);\n        curr += nchars;\n      }\n    }\n    if (stack.length <= 0) {\n      // this.throwError(`Invalid Regex (${curr} - ${end}): ${pattern}`);\n    }\n    if (stack.length == 1) return stack[0];\n    return new Cat(...stack);\n  }\n\n  protected parseGroup(stack: Regex[], curr: number, end: number): number {\n    // we have a grouping or an assertion\n    let clPos = curr + 1;\n    let depth = 0;\n    const pattern = this.pattern;\n    while (clPos <= end && (pattern[clPos] != \")\" || depth > 0)) {\n      if (pattern[clPos] == \"(\") depth++;\n      else if (pattern[clPos] == \")\") depth--;\n      if (pattern[clPos] == \"\\\\\") clPos++;\n      clPos++;\n    }\n    if (clPos > end) this.throwError(\"Expected ')' found EOI\");\n\n    curr++;\n    if (pattern[curr] == \"?\") {\n      // assertions\n      curr++; // skip the \"?\"\n      if (pattern[curr] == \":\") {\n        // A non capturing\n        stack.push(this.parse(curr + 1, clPos - 1));\n      } else if (pattern[curr] == \"<\" && pattern[curr + 1] != \"!\" && pattern[curr + 1] != \"=\") {\n        // Named capture group\n        const groupIndex = this.counter.next();\n        let groupName = \"\";\n        // get name of this group\n        let gtPos = curr + 1;\n        while (gtPos <= end && pattern[gtPos] != \">\") {\n          groupName += pattern[gtPos];\n          gtPos++;\n        }\n        const subExpr = this.parse(gtPos + 1, clPos - 1);\n        subExpr.groupIndex = groupIndex;\n        if (groupName.length > 0) subExpr.groupName = groupName;\n      } else {\n        // We have lookback/ahead assertions\n        let after = true;\n        if (pattern[curr] == \"<\") {\n          curr++;\n          after = false;\n        }\n        const neg = pattern[curr++] == \"!\";\n        const cond = this.parse(curr, clPos - 1);\n        if (after) {\n          // reduce everything \"until now\" and THEN apply\n          if (stack.length == 0) {\n            // this.throwError(\"LookAhead condition cannot be before empty rule\");\n          }\n          // const endIndex = stack.length - 1;\n          // stack[endIndex] = new LookAhead(stack[endIndex], cond, neg);\n          const expr = new LookAhead(this.reduceLeft(stack), cond, neg);\n          stack.push(expr);\n        } else {\n          // Lookbacks are interesting, we have something like:\n          // (?<!...)abcde\n          // clPos points to \")\" We need abcde also parsed\n          // and then lookback applied to it\n          const rest = this.parse(clPos + 1, end);\n          if (rest.groupIndex < 0) {\n            rest.groupIndex = this.counter.next();\n            rest.groupIsSilent = true;\n          }\n          stack.push(new LookBack(rest, cond, neg));\n          return end + 1;\n        }\n      }\n    } else {\n      // plain old grouping of the form (xyz)\n      const groupIndex = this.counter.next();\n      let neg = false;\n      if (pattern[curr] == \"^\") {\n        neg = true;\n        curr++;\n      }\n      let subExpr = this.parse(curr, clPos - 1);\n      // if (neg) subExpr = new Neg(subExpr);\n      // Do the next before the previous call if we want group\n      // index to match outer brackets first\n      if (subExpr.groupIndex >= 0) {\n        // Already set so create cat\n        subExpr = new Cat(subExpr);\n      }\n      subExpr.groupIndex = groupIndex;\n      stack.push(subExpr);\n    }\n    return clPos + 1;\n  }\n\n  protected parseCharGroup(curr: number, end: number): Char {\n    const out: Char[] = [];\n    // first see which characters are in this (until the end)\n    let i = curr;\n    let neg = false;\n    const pattern = this.pattern;\n    if (pattern[i] == \"^\") {\n      neg = true;\n      i++;\n    }\n    for (; i <= end; ) {\n      const [currch, nchars] = this.parseChar(i, end);\n      i += nchars;\n      if (i < pattern.length && pattern[i] == \"-\") {\n        i++;\n        // TODO - Should this be for all such \"operator\" charactors?\n        if (pattern[i] == \"]\" || pattern[i] == \"[\") {\n          // Special case for something like:\n          // [....x-] or [.....x-[:alpha:]]\n          out.push(currch);\n          out.push(LeafChar.Single(\"-\"));\n        } else if (i <= end) {\n          const [endch, nchars] = this.parseChar(i, end);\n          if (currch.op != CharType.SingleChar || endch.op != CharType.SingleChar) {\n            this.throwError(\"Char range cannot start or end in a char class\");\n          }\n          if (endch.args[0] < currch.args[0]) {\n            this.throwError(\"End cannot be less than start\");\n          }\n          out.push(CharGroup.Range(currch, endch));\n          i += nchars;\n        } else {\n          this.throwError(\"Unterminated char class\");\n        }\n      } else {\n        out.push(currch);\n      }\n    }\n    return CharGroup.Union(neg, out);\n  }\n\n  protected parseChar(index = 0, end = 0): [LeafChar, number] {\n    if (this.pattern[index] == \"\\\\\") {\n      return this.parseEscapeChar(index, end);\n    } else {\n      return this.parseSingleChar(index, end);\n    }\n  }\n\n  protected parseSingleChar(index = 0, end = 0): [LeafChar, number] {\n    // single char\n    const ch = this.pattern.charCodeAt(index);\n    return [LeafChar.Single(ch), 1];\n  }\n\n  protected parsePropertyEscape(index = 0, end = 0): [LeafChar, number] {\n    const pattern = this.pattern;\n    if (pattern[index] + 1 != \"{\") {\n      this.throwError(\"Invalid property escape\");\n    }\n    index += 2;\n    let clEnd = index;\n    let eqPos = -1;\n    while (clEnd <= end && pattern[clEnd] != \"}\") {\n      if (pattern[clEnd] == \"=\") eqPos = clEnd;\n      clEnd++;\n    }\n    if (clEnd > end) {\n      this.throwError(\"Invalid property escape\");\n    }\n    // see if this is a lone property escape\n    const propStr = pattern.substring(index, clEnd);\n    let propName = \"General_Category\";\n    let propValue = propStr;\n    if (eqPos >= 0) {\n      const parts = propStr.split(\"=\");\n      if (parts.length != 2) this.throwError(\"Invalid property escape\");\n      propName = parts[0].trim();\n      propValue = parts[1].trim();\n    }\n    return [LeafChar.PropertyEscape(propName, propValue), 2 + clEnd + 1 - index];\n  }\n\n  protected parseEscapeChar(index = 0, end = 0): [LeafChar, number] {\n    const pattern = this.pattern;\n    TSU.assert(pattern[index] == \"\\\\\", \"Expected '\\\\'\");\n    // escape char\n    index++;\n    if (index > end) {\n      this.throwError(\"Encounted unexpected end of input after \\\\\");\n    }\n    const ch = pattern[index];\n    if ((this.unicode && ch == \"p\") || ch == \"P\") {\n      // property escapes\n      return this.parsePropertyEscape(index, end);\n    }\n    switch (ch) {\n      // char classes\n      case \"w\":\n        return [LeafChar.Class(CharClassType.WORD_CHAR), 2];\n      case \"W\":\n        return [LeafChar.Class(CharClassType.WORD_CHAR, true), 2];\n      case \"d\":\n        return [LeafChar.Class(CharClassType.DIGITS), 2];\n      case \"D\":\n        return [LeafChar.Class(CharClassType.DIGITS, true), 2];\n      case \"s\":\n        return [LeafChar.Class(CharClassType.SPACES), 2];\n      case \"S\":\n        return [LeafChar.Class(CharClassType.SPACES, true), 2];\n      case \"0\":\n        if (pattern[index + 1] >= \"0\" && pattern[index + 1] <= \"9\" && this.unicode) {\n          this.throwError(\"Invalid decimal escape\");\n        }\n        return [LeafChar.Single(\"\\0\"), 2];\n      case \"r\":\n        return [LeafChar.Single(\"\\r\"), 2];\n      case \"n\":\n        return [LeafChar.Single(\"\\n\"), 2];\n      case \"f\":\n        return [LeafChar.Single(\"\\f\"), 2];\n      case \"b\":\n        return [LeafChar.Single(\"\\b\"), 2];\n      case \"v\":\n        return [LeafChar.Single(\"\\v\"), 2];\n      case \"t\":\n        return [LeafChar.Single(\"\\t\"), 2];\n      case \"c\":\n        // ControlEscape:\n        // https://262.ecma-international.org/5.1/#sec-15.10.2.10\n        if (this.unicode || index >= end) {\n          this.throwError(`Invalid char sequence at ${index}, ${end}`);\n        }\n        const next = pattern.charCodeAt(index + 1) % 32;\n        return [LeafChar.Single(next), 3];\n      case \"x\":\n        // 2 digit hex digits\n        index++;\n        if (index >= end) {\n          this.throwError(`Invalid hex sequence at ${index}, ${end}`);\n        }\n        const hexSeq = pattern.substring(index, index + 2);\n        const hexVal = parseInt(hexSeq, 16);\n        TSU.assert(!isNaN(hexVal), `Invalid hex sequence: '${hexSeq}'`);\n        return [LeafChar.Single(hexVal), 4];\n      case \"u\": // this could \\uABCD or \\u{ABCDEF}\n        index++;\n        // 4 digit hex digits for unicode\n        if (index > end - 3) {\n          this.throwError(`Invalid unicode sequence at ${index}`);\n        }\n        const ucodeSeq = pattern.substring(index, index + 4);\n        const ucodeVal = parseInt(ucodeSeq, 16);\n        if (isNaN(ucodeVal)) {\n          this.throwError(`Invalid unicode sequence: '${ucodeSeq}'`);\n        }\n        return [LeafChar.Single(ucodeVal), 6];\n      case \"^\": // List of special operators that need to be escaped\n      case \"$\":\n      case \".\":\n      case \"*\":\n      case \"+\":\n      case \"?\":\n      case \"\\\\\":\n      case \"'\":\n      case '\"':\n      case \"(\":\n      case \")\":\n      case \"[\":\n      case \"]\":\n      case \"{\":\n      case \"}\":\n      case \"|\":\n      case \"/\":\n        return [LeafChar.Single(ch), 2];\n      default:\n        if (this.unicode) this.throwError(\"Invalid escape character: \" + ch);\n        return [LeafChar.Single(ch), 2];\n    }\n  }\n\n  protected parseQuant(stack: Regex[], curr: number, end: number): number {\n    const pattern = this.pattern;\n    const lastCh = pattern[curr - 1];\n    let minCount = 1,\n      maxCount = 1;\n    if (pattern[curr] == \"*\") {\n      minCount = 0;\n      maxCount = TSU.Constants.MAX_INT;\n    } else if (pattern[curr] == \"+\") {\n      minCount = Math.min(minCount, 1);\n      maxCount = TSU.Constants.MAX_INT;\n    } else if (pattern[curr] == \"?\") {\n      minCount = 0;\n      maxCount = Math.max(maxCount, 1);\n    } else if (pattern[curr] == \"{\") {\n      // find the next \"}\"\n      const clPos = pattern.indexOf(\"}\", curr + 1);\n      if (clPos <= curr || clPos > end) {\n        this.throwError(\"Unexpected end of input while looking for '}'\");\n      }\n      const sub = pattern.substring(curr + 1, clPos).trim();\n      const parts = sub.split(\",\").map((x) => parseInt(x.trim()));\n      curr = clPos;\n      if (parts.length == 1) {\n        if (isNaN(parts[0])) {\n          if (sub.trim().length > 0) {\n            stack.push(new Var(sub.trim()));\n            return curr + 1;\n          } else {\n            this.throwError(`Invalid quantifier: /${sub}/`);\n          }\n        }\n        minCount = maxCount = parts[0];\n      } else if (parts.length == 2) {\n        minCount = isNaN(parts[0]) ? 0 : parts[0];\n        maxCount = isNaN(parts[1]) ? TSU.Constants.MAX_INT : parts[1];\n        if (minCount > maxCount) {\n          this.throwError(`Invalid Quant /${sub}/: Min must be <= Max`);\n        }\n      } else if (parts.length > 2) {\n        this.throwError(`Invalid quantifier spec: \"{${sub}}\"`);\n      }\n    } else {\n      throw new Error(\"Here?\");\n    }\n    // Quantifiers\n    if (stack.length <= 0) {\n      this.throwError(\"Quantifier cannot appear before an expression\");\n    }\n    // no optimizations - convert the last one into a Quantifier\n    // and we will start to fill in the quantities and greediness\n    const last = stack[stack.length - 1];\n    if (last.tag == RegexType.QUANT && (lastCh == \"*\" || lastCh == \"?\" || lastCh == \"+\" || lastCh == \"}\")) {\n      this.throwError(\"Nothing to repeat\");\n    }\n    if (this.unicode && (last.tag == RegexType.LOOK_AHEAD || last.tag == RegexType.LOOK_BACK)) {\n      this.throwError(\"Cannot have quantifier on assertion in unicode mode\");\n    }\n    const quant = (stack[stack.length - 1] = new Quant(last));\n    quant.minCount = minCount;\n    quant.maxCount = maxCount;\n    // check if there is an extra lazy quantifier\n    curr++;\n    if (curr <= end && pattern[curr] == \"?\" && quant.greedy) {\n      curr++;\n      quant.greedy = false;\n    }\n    return curr;\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { TapeInterface as Tape } from \"./tape\";\nimport {\n  LookAhead,\n  Quant,\n  RegexType,\n  StartOfInput,\n  EndOfInput,\n  Regex,\n  Cat,\n  CharType,\n  Char,\n  LeafChar,\n  CharGroup,\n  Var,\n  Union,\n} from \"./core\";\nimport { CharClassType } from \"./charclasses\";\nimport { GroupCounter, isSpace } from \"./utils\";\n\nfunction advanceIf(tape: Tape, ch: string): boolean {\n  const pos = tape.index;\n  for (let i = 0; i < ch.length; i++) {\n    if (tape.currCh != ch.charAt(i)) {\n      tape.index = pos;\n      return false;\n    }\n    tape.advance(1);\n  }\n  return true;\n}\n\n/**\n * A RegexParser for parsing regex strings in Flex RE format.\n * This class will seldom have to be used directly.  Instead use one of the methods in {@link Builder}\n */\nexport class RegexParser {\n  protected counter: GroupCounter = new GroupCounter();\n\n  parse(pattern: Tape, ignoreSpaces = false, obCount = 0): Regex {\n    const stack: Regex[] = [];\n\n    while (pattern.hasMore) {\n      const currCh = pattern.currCh;\n      // see if we have groups so they get highest preference\n      if (advanceIf(pattern, \".\")) {\n        stack.push(LeafChar.Any());\n      } else if (advanceIf(pattern, \"^\")) {\n        const x = new StartOfInput();\n        x.multiline = true;\n        stack.push(x);\n      } else if (advanceIf(pattern, \"$\")) {\n        const x = new EndOfInput();\n        x.multiline = true;\n        stack.push(x);\n      } else if (advanceIf(pattern, \"|\")) {\n        // reduce everything \"until now\" and THEN apply\n        const prev = this.reduceLeft(stack);\n        // this.parse everything to the right\n        const rest = this.parse(pattern, ignoreSpaces, obCount);\n        return new Union(prev, rest);\n      } else if (currCh == \"[\") {\n        stack.push(this.parseCharGroup(pattern));\n      } else if (currCh == \"*\" || currCh == \"?\" || currCh == \"+\" || currCh == \"{\") {\n        this.parseQuant(pattern, stack);\n      } else if (ignoreSpaces && isSpace(currCh)) {\n        // do nothing\n        pattern.advance(1);\n      } else if (ignoreSpaces && advanceIf(pattern, \"/*\")) {\n        // Read everything until a */\n        while (pattern.currCh != \"*\" || pattern.nextCh != \"/\") {\n          if (!pattern.hasMore) {\n            this.throwError(pattern, \"Unterminated comment\");\n          }\n          pattern.advance(1);\n        }\n        pattern.advance(2);\n        // now do nothing\n      } else if (advanceIf(pattern, \"{-}\")) {\n        // char class intersection\n        throw new Error(\"Intersection Not yet supported\");\n      } else if (advanceIf(pattern, \"{+}\")) {\n        // char class union\n        throw new Error(\"Union Not yet supported\");\n      } else if (advanceIf(pattern, \"(\")) {\n        if (advanceIf(pattern, \"?\")) {\n          if (advanceIf(pattern, \"#\")) {\n            while (pattern.hasMore && pattern.currCh != \")\") pattern.advance(1);\n            TSU.assert(advanceIf(pattern, \")\"), \"Expected ')'\");\n          } else {\n            // pattern of the form (?r-s:pattern)\n            let ignoreCase = false;\n            let dotAll = false;\n            let ignoreSpaces2 = ignoreSpaces as boolean;\n            let neg = false;\n            while (pattern.hasMore && pattern.currCh != \":\") {\n              if (pattern.currCh == \"i\") {\n                ignoreCase = neg ? false : true;\n              } else if (pattern.currCh == \"s\") {\n                dotAll = neg ? false : true;\n              } else if (pattern.currCh == \"x\") {\n                ignoreSpaces2 = neg ? false : true;\n              } else if (pattern.currCh == \"-\") {\n                neg = true;\n              }\n              pattern.advance(1);\n            }\n            TSU.assert(advanceIf(pattern, \":\"), \"Expected ':'\");\n            const groupIndex = this.counter.next();\n            let subExpr = this.parse(pattern, ignoreSpaces2, obCount + 1);\n            if (subExpr.groupIndex >= 0) {\n              // Already set so create cat\n              subExpr = new Cat(subExpr);\n            }\n            subExpr.dotAll = dotAll;\n            subExpr.ignoreCase = ignoreCase;\n            subExpr.groupIndex = groupIndex;\n            stack.push(subExpr);\n            TSU.assert(advanceIf(pattern, \")\"), \"Expected ')'\");\n          }\n        } else {\n          // parse the subgroup and give it a group number\n          const groupIndex = this.counter.next();\n          let subExpr = this.parse(pattern, ignoreSpaces, obCount + 1);\n          if (subExpr.groupIndex >= 0) {\n            // Already set so create cat\n            subExpr = new Cat(subExpr);\n          }\n          subExpr.groupIndex = groupIndex;\n          stack.push(subExpr);\n          TSU.assert(advanceIf(pattern, \")\"), \"Expected ')'\");\n        }\n      } else if (currCh == \")\") {\n        if (obCount == 0) {\n          this.throwError(pattern, `Unmatched ${currCh}.  Try using \\\\${currCh}`);\n        }\n        // stop here so we can recurse up\n        break;\n      } else if (currCh == \"]\" || currCh == \"}\") {\n        this.throwError(pattern, `Unmatched ${currCh}.  Try using \\\\${currCh}`);\n      } else if (advanceIf(pattern, \"/\")) {\n        // LookAheads\n        const prev = this.reduceLeft(stack);\n        // this.parse everything to the right\n        const rest = this.parse(pattern, ignoreSpaces, obCount);\n        return new LookAhead(prev, rest, false);\n      } else if (advanceIf(pattern, '\"')) {\n        // raw string\n        while (pattern.currCh != '\"') {\n          if (!pattern.hasMore) {\n            this.throwError(pattern, \"Unterminated string\");\n          }\n          stack.push(this.parseChar(pattern));\n        }\n        pattern.advance(1);\n      } else {\n        // plain old alphabets\n        stack.push(this.parseChar(pattern));\n      }\n    }\n    if (stack.length == 1) return stack[0];\n    return new Cat(...stack);\n  }\n\n  protected parseQuant(pattern: Tape, stack: Regex[]): void {\n    let minCount = 1,\n      maxCount = 1;\n    if (advanceIf(pattern, \"*\")) {\n      minCount = 0;\n      maxCount = TSU.Constants.MAX_INT;\n    } else if (advanceIf(pattern, \"+\")) {\n      minCount = Math.min(minCount, 1);\n      maxCount = TSU.Constants.MAX_INT;\n    } else if (advanceIf(pattern, \"?\")) {\n      minCount = 0;\n      maxCount = Math.max(maxCount, 1);\n    } else if (advanceIf(pattern, \"{\")) {\n      let foundComma = false;\n      let p1 = \"\";\n      let p2 = \"\";\n      while (pattern.hasMore && pattern.currCh != \"}\") {\n        if (pattern.currCh == \",\") foundComma = true;\n        else {\n          if (!foundComma) p1 += pattern.currCh;\n          else p2 += pattern.currCh;\n        }\n        pattern.advance(1);\n      }\n      if (!pattern.hasMore) {\n        this.throwError(pattern, \"Invalid property escape\");\n      }\n      // see if this is a lone property escape\n      p1 = p1.trim();\n      p2 = p2.trim();\n      // advance over the \"}\"\n      pattern.advance(1);\n\n      const part1 = parseInt(p1);\n      const part2 = parseInt(p2);\n      if (foundComma) {\n        minCount = isNaN(part1) ? 0 : part1;\n        maxCount = isNaN(part2) ? TSU.Constants.MAX_INT : part2;\n        if (minCount > maxCount) {\n          this.throwError(pattern, `Invalid Quant /${p1},${p2}/: Min must be <= Max`);\n        }\n      } else {\n        if (isNaN(part1)) {\n          if (p1.length > 0) {\n            stack.push(new Var(p1));\n            // nothing more\n            return;\n          } else {\n            this.throwError(pattern, `Invalid quantifier: /${p1}/`);\n          }\n          minCount = maxCount = 1;\n        } else {\n          minCount = maxCount = part1;\n        }\n      }\n    } else {\n      this.throwError(pattern, \"Expected '{', '*', '?' or '+', Found: \" + pattern.currCh);\n    }\n    // Quantifiers\n    if (stack.length <= 0) {\n      this.throwError(pattern, \"Quantifier cannot appear before an expression\");\n    }\n    // no optimizations - convert the last one into a Quantifier\n    // and we will start to fill in the quantities and greediness\n    const last = stack[stack.length - 1];\n    let quant: Quant;\n    if (last.tag == RegexType.QUANT && last.groupIndex < 0) {\n      // Fold repeated quants unless they are not in a group\n      quant = last as Quant;\n      quant.minCount = Math.min(minCount, quant.minCount);\n      quant.maxCount = Math.max(maxCount, quant.maxCount);\n    } else {\n      quant = stack[stack.length - 1] = new Quant(last);\n      quant.minCount = minCount;\n      quant.maxCount = maxCount;\n    }\n    // check if there is an extra lazy quantifier\n    if (quant.greedy && advanceIf(pattern, \"?\")) {\n      quant.greedy = false;\n    }\n  }\n\n  protected parseCharGroup(pattern: Tape): Char {\n    const out: Char[] = [];\n    TSU.assert(advanceIf(pattern, \"[\"), \"Expected '['\");\n    // first see which characters are in this (until the end)\n    const neg = advanceIf(pattern, \"^\");\n    while (pattern.currCh != \"]\") {\n      const currch = this.parseChar(pattern);\n      if (advanceIf(pattern, \"-\")) {\n        if (pattern.hasMore) {\n          // TODO - Should this be for all such \"operator\" charactors?\n          if (pattern.currCh == \"]\" || pattern.currCh == \"[\") {\n            // Special case for something like:\n            // [....x-] or [.....x-[:alpha:]]\n            out.push(currch);\n            out.push(LeafChar.Single(\"-\"));\n          } else {\n            const endch = this.parseChar(pattern);\n            if (currch.op != CharType.SingleChar || endch.op != CharType.SingleChar) {\n              this.throwError(pattern, \"Char range cannot start or end in a char class\");\n            }\n            if (endch.args[0] < currch.args[0]) {\n              this.throwError(pattern, \"End cannot be less than start\");\n            }\n            // currch.end = endch.start;\n            out.push(CharGroup.Range(currch, endch));\n          }\n        } else {\n          this.throwError(pattern, \"Unterminated char class\");\n        }\n      } else {\n        out.push(currch);\n      }\n    }\n    TSU.assert(advanceIf(pattern, \"]\"), \"']' expected\");\n    return CharGroup.Union(neg, out);\n  }\n\n  protected parseChar(pattern: Tape): LeafChar {\n    if (pattern.currCh == \"\\\\\") {\n      return this.parseEscapeChar(pattern);\n    } else {\n      return this.parseSingleChar(pattern);\n    }\n  }\n\n  protected parseSingleChar(pattern: Tape): LeafChar {\n    // single char\n    const ch = pattern.currCh;\n    pattern.advance(1);\n    return LeafChar.Single(ch);\n  }\n\n  protected parsePropertyEscape(pattern: Tape): LeafChar {\n    TSU.assert(advanceIf(pattern, \"\\\\{\"), \"Invalid property escape\");\n    pattern.advance(2);\n    let foundEq = false;\n    let propName = \"\";\n    let propValue = \"\";\n    while (pattern.hasMore && pattern.currCh != \"}\") {\n      if (pattern.currCh == \"=\") foundEq = true;\n      else {\n        if (!foundEq) propName += pattern.currCh;\n        else propValue += pattern.currCh;\n      }\n      pattern.advance(1);\n    }\n    if (!pattern.hasMore) {\n      this.throwError(pattern, \"Invalid property escape\");\n    }\n    // see if this is a lone property escape\n    propName = propName.trim();\n    propValue = propValue.trim();\n    if (!foundEq) {\n      propValue = propName;\n      propName = \"General_Category\";\n    }\n    // advance over the \"}\"\n    pattern.advance(1);\n    return LeafChar.PropertyEscape(propName, propValue);\n  }\n\n  protected parseEscapeChar(pattern: Tape): LeafChar {\n    TSU.assert(advanceIf(pattern, \"\\\\\"), \"Expected '\\\\'\");\n    // escape char\n    if (!pattern.hasMore) {\n      this.throwError(pattern, \"Encounted unexpected end of input after \\\\\");\n    }\n    if (advanceIf(pattern, \"w\")) {\n      return LeafChar.Class(CharClassType.WORD_CHAR);\n    } else if (advanceIf(pattern, \"W\")) {\n      return LeafChar.Class(CharClassType.WORD_CHAR, true);\n    } else if (advanceIf(pattern, \"d\")) {\n      return LeafChar.Class(CharClassType.DIGITS);\n    } else if (advanceIf(pattern, \"D\")) {\n      return LeafChar.Class(CharClassType.DIGITS, true);\n    } else if (advanceIf(pattern, \"s\")) {\n      return LeafChar.Class(CharClassType.SPACES);\n    } else if (advanceIf(pattern, \"S\")) {\n      return LeafChar.Class(CharClassType.SPACES, true);\n    } else if (advanceIf(pattern, \"0\")) {\n      return LeafChar.Single(\"\\0\");\n    } else if (advanceIf(pattern, \"r\")) {\n      return LeafChar.Single(\"\\r\");\n    } else if (advanceIf(pattern, \"n\")) {\n      return LeafChar.Single(\"\\n\");\n    } else if (advanceIf(pattern, \"f\")) {\n      return LeafChar.Single(\"\\f\");\n    } else if (advanceIf(pattern, \"b\")) {\n      return LeafChar.Single(\"\\b\");\n    } else if (advanceIf(pattern, \"v\")) {\n      return LeafChar.Single(\"\\v\");\n    } else if (advanceIf(pattern, \"t\")) {\n      return LeafChar.Single(\"\\t\");\n    } else if (advanceIf(pattern, \"\\\\\")) {\n      return LeafChar.Single(\"\\\\\");\n    } else if (advanceIf(pattern, \"'\")) {\n      return LeafChar.Single(\"'\");\n    } else if (advanceIf(pattern, '\"')) {\n      return LeafChar.Single('\"');\n    } else if (advanceIf(pattern, \"x\")) {\n      // 2 digit hex digits\n      if (!pattern.hasMore) {\n        this.throwError(pattern, `Invalid hex sequence at ${pattern.index}`);\n      }\n      const hexSeq = pattern.currCh + pattern.nextCh;\n      const hexVal = parseInt(hexSeq, 16);\n      TSU.assert(!isNaN(hexVal), `Invalid hex sequence: '${hexSeq}'`);\n      pattern.advance(2);\n      return LeafChar.Single(hexVal);\n    } else if (advanceIf(pattern, \"u\")) {\n      // 4 digit hex digits for unicode\n      if (!pattern.canAdvance(3)) {\n        // index >= pattern.input.length - 3) {\n        this.throwError(pattern, `Invalid unicode sequence at ${pattern.index}`);\n      }\n      const ucodeSeq = pattern.substring(pattern.index, pattern.index + 4);\n      const ucodeVal = parseInt(ucodeSeq, 16);\n      if (isNaN(ucodeVal)) {\n        this.throwError(pattern, `Invalid unicode sequence: '${ucodeSeq}'`);\n      }\n      pattern.advance(4);\n      return LeafChar.Single(ucodeVal);\n    }\n    // default\n    const ch = pattern.currCh;\n    pattern.advance(1);\n    return LeafChar.Single(ch);\n  }\n\n  protected reduceLeft(stack: Regex[]): Regex {\n    const r = stack.length == 1 ? stack[0] : new Cat(...stack);\n    // remove all elements on stack\n    stack.splice(0);\n    return r;\n  }\n\n  protected throwError(pattern: Tape, msg: string): void {\n    throw new Error(msg);\n    // this.throwError(pattern, `Error in Flex RE '${pattern.input}': ${msg}`);\n  }\n}\n","import { Rule, Regex, REPatternType } from \"./core\";\nimport { RegexParser as JSREParser } from \"./jsparser\";\nimport { RegexParser as FlexREParser } from \"./flexparser\";\nimport { Tape } from \"./tape\";\n\n/**\n * Uber method to build a Regex given either a regex string or a JS regex.\n *\n * @param pattern   Either a regex pattern, a JS RegExp object, or an already parsed Regex object.\n * @param config    TBD\n *\n * @return A {@link Rule} object that contains the pattern as well as its normalized regex tree.\n */\nexport function build(pattern: string | RegExp | Regex, config?: any): Rule {\n  if (typeof pattern === \"string\") {\n    const rule = new Rule(exprFromJSRE(pattern, config), config);\n    rule.pattern = pattern;\n    return rule;\n  } else if (pattern.constructor.name == \"RegExp\") {\n    const rule = new Rule(exprFromJSRE(pattern as RegExp, config), config);\n    rule.pattern = (pattern as RegExp).source;\n    return rule;\n  } else {\n    // Already compiled expression\n    return new Rule(pattern as Regex, config);\n  }\n}\n\n/*\nexport function fromRE(pattern: string, config?: any): Rule {\n  const expr = new JSREParser(pattern, config).parse();\n  const rule = new Rule(expr, config);\n  rule.pattern = pattern;\n  return rule;\n}\n\nexport function fromJSRE(re: RegExp, config?: any): Rule {\n  const expr = exprFromJSRE(re);\n  const rule = new Rule(expr, config);\n  rule.pattern = re.source;\n  return rule;\n}\n\nexport function fromFlexRE(re: string, config?: any): Rule {\n  const expr = exprFromFlexRE(re);\n  const rule = new Rule(expr, config);\n  rule.pattern = re;\n  return rule;\n}\n*/\n\n/**\n * \"Flattens\" either a single REPatternType or a list of REPatternTypes into a flat list of all\n * REPatternTypes at the leaf levels.\n */\nexport function flatten(re: REPatternType | REPatternType[], index = 0, rules?: Rule[]): Rule[] {\n  rules = rules || [];\n  if (typeof re === \"string\") {\n    rules.push(build(re, { tag: index }));\n  } else if (re.constructor == RegExp) {\n    rules.push(build(re, { tag: index }));\n  } else if (re.constructor == Rule) {\n    rules.push(re as Rule);\n  } else if (re.constructor == Regex) {\n    rules.push(new Rule(re as Regex));\n  } else {\n    const res = re as (RegExp | Rule | string)[];\n    for (let i = 0; i < res.length; i++) {\n      flatten(res[i], i, rules);\n    }\n  }\n  return rules;\n}\n\n/**\n * Takes a string assumed to be in Flex RE format and parses the Regex expression out of it.\n */\nexport function exprFromFlexRE(pattern: string): Regex {\n  const parser = new FlexREParser();\n  try {\n    const expr = parser.parse(new Tape(pattern));\n    // if not specified default to false\n    if (expr.dotAll == null) expr.dotAll = false;\n    if (expr.multiline == null) expr.multiline = false;\n    return expr;\n  } catch (error) {\n    console.log(\"Error in FLEX RE: \", pattern);\n    throw error;\n  }\n}\n\n/**\n * Takes a string assumed to be in JS RE format and parses the Regex expression out of it.\n */\nexport function exprFromJSRE(re: string | RegExp, config?: any): Regex {\n  config = config || {};\n  const isRegExp = typeof re !== \"string\";\n  const pattern = typeof re === \"string\" ? re : re.source;\n  if (isRegExp) config.unicode = (re as RegExp).unicode;\n  const expr = new JSREParser(pattern, config).parse();\n  if (typeof re !== \"string\") {\n    expr.dotAll = re.dotAll;\n    expr.ignoreCase = re.ignoreCase;\n    expr.multiline = re.multiline;\n  }\n  return expr;\n}\n\n/**\n * A way to build a JS RE from a string literal, eg: jsRE`a*b+`\n */\nexport function jsRE(strings: TemplateStringsArray, ...keys: any[]): Regex {\n  // what we have is the raw value of this template and this can be parsed by our parser\n  const merged = String.raw(strings, ...keys);\n  return exprFromJSRE(merged);\n}\n\n/**\n * A way to build a Flex RE from a string literal, eg: flexRE`a*b+`\n */\nexport function flexRE(strings: TemplateStringsArray, ...keys: any[]): Regex {\n  const merged = String.raw(strings, ...keys);\n  return exprFromFlexRE(merged);\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { Regex, Union, Rule, RuleConfig } from \"./core\";\nimport { Prog, Match, VM } from \"./vm\";\nimport { Compiler } from \"./compiler\";\nimport { TapeInterface as Tape, Tape as DefaultTape } from \"./tape\";\nimport { TokenizerError } from \"./errors\";\nimport * as Builder from \"./builder\";\nimport { Token, TokenType } from \"./token\";\n\nexport type RuleMatchHandler = (rule: Rule, tape: Tape, token: Token, owner: any) => any;\nexport type TokenizerErrorHandler = (error: Error, tape: Tape, startIndex: number) => Error | null;\n\nexport function toToken(tag: TokenType, m: Match, tape: Tape | null): Token {\n  const out = new Token(tag, m.matchIndex, m.start, m.end);\n  for (let i = 0; i < m.positions.length; i += 2) {\n    if (m.positions[i] >= 0) {\n      out.positions[Math.floor(i / 2)] = [m.positions[i], m.positions[i + 1]];\n    }\n  }\n  for (const [groupIndex, tapeIndex] of m.groups) {\n    const gi = Math.abs(groupIndex);\n    if (!(gi in out.groups)) {\n      out.groups[gi] = [];\n    }\n    out.groups[gi].push(tapeIndex);\n  }\n  if (tape != null) out.value = tape.substring(m.start, m.end);\n  return out;\n}\n\nexport class BaseTokenizer {\n  protected _prog: Prog | null = null;\n  protected _vm: VM | null = null;\n\n  /**\n   * Error handler called when an invalid character or lexeme is encountered.\n   * If this method returns back an error then the tokenization stops otherwise\n   * (if a null is returned) then tokenization continues.\n   *\n   * @param error       The error currently caught and being handled.\n   * @param tape        The tape currently being tokenized.\n   * @param startIndex  The start index when the tokenization began resulting in the error.\n   */\n  onError: TokenizerErrorHandler | null = null;\n\n  // Stores named rules\n  // Rules are a \"regex\", whether literal or not\n  allRules: Rule[] = [];\n  onMatchHandlers: (RuleMatchHandler | null)[] = [];\n  matchHandlersByValue: any = {};\n  variables = new Map<string, Regex>();\n  compiler: Compiler = new Compiler((name) => {\n    let out = this.variables.get(name) || null;\n    if (out == null) out = this.findRuleByValue(name)?.expr || null;\n    if (out == null) throw new Error(`Invalid regex reference: ${name}`);\n    return out;\n  });\n\n  getVar(name: string): Regex | null {\n    return this.variables.get(name) || null;\n  }\n\n  addVar(name: string, regex: Regex): this {\n    let currValue = this.variables.get(name) || null;\n    if (currValue == null) {\n      currValue = regex;\n    } else {\n      currValue = new Union(currValue, regex);\n    }\n    this.variables.set(name, regex);\n    return this;\n  }\n\n  findRuleByValue(value: any): Rule | null {\n    return this.allRules.find((r) => r.tag == value) || null;\n  }\n\n  /**\n   * Helper method over the addRule method that converts the pattern to its normalized expression form\n   * and adds a rule to the tokenizer.\n   *\n   * @param pattern     A raw string or a JS RegExp, or parsed Regex expression\n   *                    (either from JS or Flex RE syntax).\n   * @param config      Rule configs to control priority and other aspects of rules to be used during\n   *                    the match stage.\n   * @param onMatch     A callback method called when the rule is matched.\n   */\n  add(\n    pattern: string | RegExp | Regex,\n    config?: RuleConfig | RuleMatchHandler | null,\n    onMatch: RuleMatchHandler | null = null,\n  ): this {\n    if (typeof config === \"function\") {\n      onMatch = config;\n      config = null;\n    }\n    return this.addRule(Builder.build(pattern, config), onMatch);\n  }\n\n  /**\n   * Helper method over the addRule method that converts the pattern to its normalized expression form\n   * and adds a rule to the tokenizer.\n   *\n   * @param rule        A normalized Rule object that contains both the pattern as well as rule configs\n   *                    to be used during the match and afterwards (if successfully matched).\n   * @param onMatch     A callback method called when the rule is matched.\n   */\n  addRule(rule: Rule, onMatch: null | RuleMatchHandler = null): this {\n    rule.matchIndex = this.allRules.length;\n    this.allRules.push(rule);\n    this.onMatchHandlers.push(onMatch);\n    this._prog = null;\n    this._vm = null;\n    return this;\n  }\n\n  /**\n   * Add a token match callback by value.\n   */\n  on(tag: any, onMatch: RuleMatchHandler): this {\n    this.matchHandlersByValue[tag] = onMatch;\n    return this;\n  }\n\n  get prog(): Prog {\n    if (this._prog == null) {\n      const sortedRules = this.sortRules();\n      this._prog = this.compiler.compile(sortedRules);\n    }\n    return this._prog;\n  }\n\n  get vm(): VM {\n    if (this._vm == null) {\n      this._vm = new VM(this.prog);\n    }\n    return this._vm;\n  }\n\n  protected sortRules(): Rule[] {\n    // Sort rules so high priority ones appear first\n    const sortedRules: Rule[] = this.allRules.map((rule) => rule);\n    sortedRules.sort((r1, r2) => {\n      if (r1.priority != r2.priority) return r2.priority - r1.priority;\n      return r1.matchIndex - r2.matchIndex;\n    });\n    return sortedRules;\n  }\n}\n\n/**\n * A batch tokenizer.\n */\nexport class Tokenizer extends BaseTokenizer {\n  idCounter = 0;\n\n  /**\n   * Get the current lexer state (for incremental lexing support).\n   * State is used to track context-sensitive lexing modes.\n   */\n  getState(): number {\n    return this.vm.getState();\n  }\n\n  /**\n   * Set the lexer state (for incremental lexing support).\n   * Allows restarting lexing from a saved state.\n   */\n  setState(state: number): void {\n    this.vm.setState(state);\n  }\n\n  /**\n   * Reset the tokenizer state. Useful for incremental lexing\n   * when restarting from a different position.\n   */\n  reset(): void {\n    this.idCounter = 0;\n    // Reset VM state to initial\n    if (this._vm) {\n      this._vm.setState(0);\n    }\n  }\n\n  next(tape: Tape, owner: any): Token | null {\n    if (!tape.hasMore) {\n      return null;\n    }\n    const startIndex = tape.index;\n    const startChar = tape.currCh;\n    const m = this.vm.match(tape);\n    if (m == null) {\n      // no match so we have an error\n      let err: Error | null = null;\n      if (tape.index == startIndex + 1) {\n        err = new TokenizerError(`Unexpected Character: ${startChar}`, startIndex, 1, \"UnexpectedCharacter\", startChar);\n      } else {\n        err = new TokenizerError(\n          `Unexpected Symbol: ${tape.substring(startIndex, tape.index)}`,\n          startIndex,\n          tape.index - startIndex,\n          \"UnexpectedLexeme\",\n        );\n      }\n      if (this.onError) {\n        err = this.onError(err, tape, startIndex);\n      }\n      if (err != null) {\n        throw err;\n      } else {\n        // err has been ocnsumed so we can restart tokenizer at the current position\n        return this.next(tape, owner);\n      }\n    }\n    const rule = this.allRules[m.matchIndex];\n    let token = toToken(rule.tag, m, tape);\n    token.id = this.idCounter++;\n    let onMatch = this.onMatchHandlers[m.matchIndex];\n    if (!onMatch) {\n      onMatch = this.matchHandlersByValue[rule.tag];\n    }\n    if (onMatch) {\n      token = onMatch(rule, tape, token, owner);\n      if (token == null) {\n        // null is returned by onMatch to skip tokens\n        return this.next(tape, owner);\n      }\n    } else if (rule.skip) {\n      return this.next(tape, owner);\n    }\n    return token;\n  }\n\n  tokenize(tape: string | Tape, owner: any = null): Token[] {\n    const tokens = [] as Token[];\n    if (typeof tape === \"string\") {\n      tape = new DefaultTape(tape);\n    }\n    let next = this.next(tape, owner);\n    while (next) {\n      tokens.push(next);\n      try {\n        next = this.next(tape, owner);\n      } catch (err: any) {\n        tokens.push({\n          tag: \"ERROR\",\n          start: err.offset,\n          end: err.offset + err.length,\n          value: err.message,\n        } as Token);\n        break;\n      }\n    }\n    return tokens;\n  }\n}\n","import { flexRE } from \"./builder\";\n\nexport const SINGLE_QUOTE_STRING = flexRE`[\"]([^\"\\\\\\n]|\\\\.|\\\\\\n)*[\"]`;\nexport const DOUBLE_QUOTE_STRING = flexRE`[']([^'\\\\\\n]|\\\\.|\\\\\\n)*[']`;\nexport const SIMPLE_JS_STRING = '\"(.*?(?<!\\\\\\\\))\"';\nexport const JS_REGEX_WITHOUT_LB = String.raw`/([^\\\\/]|\\\\.)*/([imus]*)`;\nexport const JS_REGEX = String.raw`/(.+?(?<!\\\\))/([imus]*)`;\n","import * as TSU from \"@panyam/tsutils\";\nimport * as TLEX from \"tlex\";\nimport { Sym, Grammar, Str, Rule, RuleAction } from \"./grammar\";\n\ntype Tape = TLEX.TapeInterface;\n\nconst str2regex = (s: string | number): string => {\n  if (typeof s === \"number\") return \"\" + s;\n  return s.replace(/[\\-\\[\\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\\\\\^\\$\\|]/g, \"\\\\$&\");\n};\n\nexport enum TokenType {\n  STRING = \"STRING\",\n  REGEX = \"REGEX\",\n  NUMBER = \"NUMBER\",\n  SPACES = \"SPACES\",\n  IDENT = \"IDENT\",\n  PCT_IDENT = \"PCT_IDENT\",\n  STAR = \"STAR\",\n  PLUS = \"PLUS\",\n  QMARK = \"QMARK\",\n  PIPE = \"PIPE\",\n  DOLLAR_NUM = \"DOLLAR_NUM\",\n  DOLLAR_IDENT = \"DOLLAR_IDENT\",\n  OPEN_PAREN = \"OPEN_PAREN\",\n  CLOSE_PAREN = \"CLOSE_PAREN\",\n  OPEN_BRACE = \"OPEN_BRACE\",\n  CLOSE_BRACE = \"CLOSE_BRACE\",\n  OPEN_SQ = \"OPEN_SQ\",\n  CLOSE_SQ = \"CLOSE_SQ\",\n  COMMENT = \"COMMENT\",\n  ARROW = \"ARROW\",\n  COLCOLHYPHEN = \"COLCOLHYPHEN\",\n  COLON = \"COLON\",\n  SEMI_COLON = \"SEMI_COLON\",\n}\n\nexport type NewSymbolCallback = TSU.Nullable<(label: string, assumedTerminal: boolean) => Sym | void>;\nexport type TokenHandler = (token: TLEX.Token, tape: TLEX.TapeInterface, owner: any) => TLEX.Token | null;\n\nexport interface LoaderConfig {\n  grammar?: Grammar;\n  leftRecursive?: boolean;\n  newSymbolCallback?: NewSymbolCallback;\n  tokenHandlers: TSU.StringMap<TokenHandler>;\n  debug?: string;\n}\n\n/**\n * Entry point in loading a grammar from a DSL spec.\n */\nexport function load(input: string, params?: LoaderConfig): [Grammar, null | TLEX.NextTokenFunc] {\n  params = params || ({} as LoaderConfig);\n  const g = new Grammar(params.grammar || {});\n  const eparser = new Loader(input, { ...params, grammar: g });\n  // g.augmentStartSymbol();\n  const tokenFunc = eparser.generatedTokenizer.next.bind(eparser.generatedTokenizer);\n  const debug = params.debug || \"\";\n  if (debug.split(\"|\").findIndex((p: string) => p == \"all\" || p == \"lexer\") >= 0) {\n    console.log(\"Prog: \\n\", `${eparser.generatedTokenizer.vm.prog.debugValue().join(\"\\n\")}`);\n  }\n  return [g, tokenFunc];\n}\n\n/**\n * The SemanticHandler is the bridge between the DSL, the Grammar, the Parser\n * and the caller of the parser.\n * In the DSL semantic actions can be added to tokenizer and grammar specs.\n * However the problem how to invoke them during runtime.\n *\n * For example in the grammar:\n *\n * E -> E + E { add($1, $3) }\n *\n * declares that when this rule is reduced the \"add\" function (in user land) is\n * invoked with the results of the right hand side values.\n *\n * This parsing however is done by the DSL loader and at this time the \"add\" method\n * is not declared anywhere.   In fact the the declaration is only  used by the parser\n * driver (after the parse tables have been constructed and parsing is started on\n * a real input).   The parser here needs to supply the definition for \"add\" method.\n * Note only this only the parser can call what is needed to kick off the \"add\" method\n * to be invoked.\n *\n * So the parser will need something like:\n *\n * while (input) {\n *    ....\n *    reduceRule(Nt, E1, E2, E3 ..., \"action\")\n * }\n *\n * the \"action\" will be part of the SemanticHandler\n *\n * reduceRule(Nt...., \"action\") {\n *  Nt.value = semanticHandler.getAction(\"action\").apply(E1, E2...., En);\n * }\n *\n * Similarly the caller of the \"parse\" method could populate the actions, eg:\n *\n * semanticHandler.register(\"action\", (a, b, c) => {\n *    return ....;\n * });\n *\n * The DSL loader in turn returns a semanticHandler instance just the way it\n * creates a tokenizer.\n *\n * There are a couple of options here.\n *\n * 1. Keep actions simple and store action IDs and let the caller do all the work, eg:\n *\n * E -> E + E { add $1 $3 }\n *\n * 2. Provide a stronger expression syntax:\n *\n * Or we could add a slightly more functional syntax so that a proper interpreter like setup is possible, eg:\n *\n * E -> E + E { add(halve($1), double($3)) }\n *\n * Here instead of calling an action \"add\" we could actually store expression trees and call an interpreter\n * with attribute value bindings.\n *\n * For now we will go with (1) as it is simpler and we can always build up (2) if doing (1) alone is too verbose.\n *\n * With (1), syntax for semantic actions is:\n *\n *  SemAction -> \"{\" ActionSpec \"}\" ;\n *\n *  ActionSpec -> DOLLAR_NUM\n *              | IDENT ( IDENT | DOLLAR_NUM | NUM | STRING | BOOLEAN | NULL ) *\n *              ;\n *\n * 3. There is an evern simpler third option.  Instead of the parser trying to martial parameters etc it could just\n * let the handler do the work of martialling/extracting parameters from children.  This is effective and easy\n *\n * In this mode all child nodes are passed as is to the handler and it is upto the handler to return the semantic\n * value of the production.\n */\n\nexport function Tokenizer(): TLEX.Tokenizer {\n  const lexer = new TLEX.Tokenizer();\n  lexer.add(/->/, { tag: TokenType.ARROW });\n  lexer.add(/\\[/, { tag: TokenType.OPEN_SQ });\n  lexer.add(/\\]/, { tag: TokenType.CLOSE_SQ });\n  lexer.add(/\\(/, { tag: TokenType.OPEN_PAREN });\n  lexer.add(/\\)/, { tag: TokenType.CLOSE_PAREN });\n  lexer.add(/\\{/, { tag: TokenType.OPEN_BRACE });\n  lexer.add(/\\}/, { tag: TokenType.CLOSE_BRACE });\n  lexer.add(/\\*/, { tag: TokenType.STAR });\n  lexer.add(/\\+/, { tag: TokenType.PLUS });\n  lexer.add(/\\?/, { tag: TokenType.QMARK });\n  lexer.add(/;/, { tag: TokenType.SEMI_COLON });\n  lexer.add(/:/, { tag: TokenType.COLON });\n  lexer.add(/\\|/, { tag: TokenType.PIPE });\n  lexer.add(/\\s+/m, { tag: TokenType.SPACES }, () => null);\n  lexer.add(/\\/\\*.*?\\*\\//s, { tag: TokenType.COMMENT }, () => null);\n  lexer.add(/\\/\\/.*$/m, { tag: TokenType.COMMENT }, () => null);\n  lexer.add(TLEX.Samples.DOUBLE_QUOTE_STRING, { tag: TokenType.STRING }, (rule, tape, token) => {\n    token.value = tape.substring(token.start + 1, token.end - 1);\n    return token;\n  });\n  lexer.add(TLEX.Samples.SINGLE_QUOTE_STRING, { tag: TokenType.STRING }, (rule, tape, token) => {\n    token.value = tape.substring(token.start + 1, token.end - 1);\n    return token;\n  });\n  lexer.add(TLEX.Samples.JS_REGEX, { tag: TokenType.REGEX }, (rule, tape, token) => {\n    const pattern = tape.substring(token.positions[1][0], token.positions[1][1]);\n    const flags = tape.substring(token.positions[3][0], token.positions[3][1]);\n    token.value = [pattern, flags];\n    return token;\n  });\n  lexer.add(/\\d+/, { tag: TokenType.NUMBER }, (rule, tape, token) => {\n    token.value = parseInt(tape.substring(token.start, token.end));\n    return token;\n  });\n  lexer.add(/%([\\w][\\w\\d_]*)/, { tag: TokenType.PCT_IDENT }, (rule, tape, token) => {\n    token.value = tape.substring(token.start + 1, token.end);\n    return token;\n  });\n  lexer.add(/\\$\\d+/, { tag: TokenType.DOLLAR_NUM }, (rule, tape, token) => {\n    token.value = parseInt(tape.substring(token.start + 1, token.end));\n    return token;\n  });\n  lexer.add(/\\$([\\w][\\w\\d_]*)/, { tag: TokenType.DOLLAR_IDENT }, (rule, tape, token) => {\n    token.value = tape.substring(token.start + 1, token.end);\n    return token;\n  });\n  lexer.add(/[\\w][\\w\\d_]*/, { tag: TokenType.IDENT });\n  return lexer;\n}\n\nexport enum NodeType {\n  GRAMMAR = \"GRAMMAR\",\n  DECL = \"DECL\",\n  RULE = \"RULE\",\n  PROD_NULL = \"PROD_NULL\",\n  PROD_STR = \"PROD_STR\",\n  PROD_UNION = \"PROD_UNION\",\n  PROD_NAME = \"PROD_NAME\",\n  PROD_STRING = \"PROD_STRING\",\n  PROD_NUM = \"PROD_NUM\",\n  PROD_IDENT = \"PROD_IDENT\",\n  PROD_STAR = \"PROD_STAR\",\n  PROD_PLUS = \"PROD_PLUS\",\n  PROD_OPTIONAL = \"PROD_OPTIONAL\",\n  IDENT = \"IDENT\",\n  ERROR = \"ERROR\",\n  COMMENT = \"COMMENT\",\n}\n\n/**\n * EBNF Grammar:\n *\n * grammar -> rules;\n *\n * decl -> rule ;\n *\n * rules -> rule | rule rules ;\n *\n * rule -> IDENT \"->\" top_productions \";\" ;\n *\n * top_productions -> ( actionSpec ) ?\n *                |   prod ( actionSpec ) ? top_productions\n *                ;\n *\n * productions ->\n *              | prod  \"|\" productions\n *              ;\n *\n * prod -> ( prod_group | optional_prod | IDENT ( \":\" name ) ? | STRING ) ( \"*\" | \"+\" | \"?\" ) ?\n *      ;\n *\n * prod_group -> \"(\" productions \")\"  ;\n *\n * optional_prod -> \"[\" productions \"]\"  ;\n *\n * actionSpec := \"{\" IDENT \"(\" IDENT ( \",\" IDENT ) * \")\" \"}\"\n */\nexport class Loader {\n  readonly grammar: Grammar;\n  private tokenizer: TLEX.TokenBuffer;\n  private leftRecursive = false;\n  readonly generatedTokenizer: TLEX.Tokenizer = new TLEX.Tokenizer();\n  tokenHandlers: TSU.StringMap<TokenHandler>;\n\n  /*\n   * The newSymbol callback provided to the contructor is a way for the client to\n   * be given a chance to create a symbol given a new label that is encountered.\n   * The client can either return a null to let this parser define the Symbol\n   * or return a Symbol which will be associated with the given label going\n   * forward.\n   *\n   * The newSymbol callback will ONLY be called once for each new label\n   * encountered by the parser.   If the client returns a duplicte symbol\n   * then parsing fails.\n   */\n  private newSymbolCallback: NewSymbolCallback;\n  private symbolsByLabel: TSU.StringMap<Sym>;\n\n  /**\n   * Allowed regex syntaxes - js or flex\n   */\n  private regexSyntax = \"js\";\n\n  constructor(input: string, config?: LoaderConfig) {\n    config = config || ({} as LoaderConfig);\n    this.symbolsByLabel = {};\n    this.grammar = config.grammar || new Grammar();\n    this.leftRecursive = \"leftRecursive\" in config ? config.leftRecursive || false : true;\n    this.newSymbolCallback = config.newSymbolCallback || null;\n    this.tokenHandlers = config.tokenHandlers || {};\n    this.parse(input);\n  }\n\n  /**\n   * As the parser creates encounters a new literal or an identifier (hinting at\n   * either a terminal or a non terminal), it needs to know which symbol to associate\n   * with this lit/ident going forward.\n   *\n   * All symbols created for the grammar, since they are either created\n   * by this parser or by the client (invokved by this parser), are\n   * stored locally to be returned in this method.\n   */\n  symbolForLabel(label: string): TSU.Nullable<Sym> {\n    return this.symbolsByLabel[label] || null;\n  }\n\n  /**\n   * Registers a symbol for a given label.\n   */\n  registerSymbol(label: string, sym: Sym): void {\n    TSU.assert(!(label in this.symbolsByLabel), `${label} is already registered`);\n    this.symbolsByLabel[label] = sym;\n  }\n\n  /**\n   * Ensures that a symbol exists for a given label (as found in the parser spec)\n   * to be used through out the grammar.\n   */\n  ensureSymbol(label: string, assumedTerminal: boolean): Sym {\n    let currSym = this.symbolForLabel(label);\n\n    if (currSym != null) return currSym;\n    else if (this.newSymbolCallback) {\n      // then give the user a chance to create a symbol for this\n      currSym = this.newSymbolCallback(label, assumedTerminal) || null;\n    }\n    if (currSym == null) {\n      if (assumedTerminal) {\n        currSym = this.grammar.newTerm(label);\n      } else {\n        currSym = this.grammar.newNT(label);\n      }\n    }\n    // then register it so it is used going forward\n    this.registerSymbol(label, currSym);\n    return currSym;\n  }\n\n  parse(input: string): void {\n    const et = Tokenizer();\n    const ntFunc = (tape: Tape, owner: any) => {\n      const out = et.next(tape, this);\n      return out;\n    };\n    this.tokenizer = new TLEX.TokenBuffer(ntFunc, this);\n    this.parseGrammar(new TLEX.Tape(input));\n  }\n\n  parseRegex(tape: TLEX.TapeInterface, tag?: string, priority = 0, syntax = \"\"): TLEX.Rule {\n    if (syntax == \"\") syntax = this.regexSyntax;\n    if (syntax == \"js\") {\n      const tokPattern = this.tokenizer.expectToken(tape, TokenType.STRING, TokenType.NUMBER, TokenType.REGEX);\n      let rule: TLEX.Rule;\n      if (!tag || tag.length == 0) {\n        tag = \"/\" + tokPattern.value[0] + \"/\" + tokPattern.value[1];\n      }\n      if (tokPattern.tag == TokenType.STRING || tokPattern.tag == TokenType.NUMBER) {\n        const pattern = str2regex(tokPattern.value);\n        rule = TLEX.Builder.build(pattern, { tag: tag, priority: priority + 20 });\n      } else if (tokPattern.tag == TokenType.REGEX) {\n        let re = tokPattern.value[0];\n        if (tokPattern.value[1].length > 0) {\n          // Flags given so create\n          re = new RegExp(tokPattern.value[0], tokPattern.value[1]);\n        }\n        rule = TLEX.Builder.build(re, { tag: tag, priority: priority + 10 });\n      } else {\n        throw new TLEX.UnexpectedTokenError(tokPattern);\n      }\n      return rule;\n    } else {\n      // Flex style RE - no delimiters - just read until end of line and strip spaces\n      let patternStr = \"\";\n      while (tape.hasMore && tape.currCh != \"\\n\") {\n        patternStr += tape.currCh;\n        tape.advance();\n      }\n      patternStr = patternStr.trim();\n      if (!tag || tag.length == 0) {\n        tag = \"/\" + patternStr + \"/\";\n      }\n      return new TLEX.Rule(TLEX.Builder.exprFromFlexRE(patternStr), { tag: tag, priority: priority });\n    }\n  }\n\n  parseGrammar(tape: TLEX.Tape): void {\n    let peeked = this.tokenizer.peek(tape);\n    while (peeked != null) {\n      if (peeked.tag == TokenType.IDENT) {\n        // declaration\n        this.parseDecl(tape);\n      } else if (peeked.tag == TokenType.PCT_IDENT) {\n        this.tokenizer.next(tape);\n        this.parseDirective(tape, peeked.value);\n      } else {\n        throw new SyntaxError(`Declaration must start with IDENT or PCT_IDENT.  Found: '${peeked.value}' instead.`);\n      }\n      peeked = this.tokenizer.peek(tape);\n    }\n  }\n\n  parseDirective(tape: TLEX.TapeInterface, directive: string): void {\n    if (directive == \"start\") {\n      // override start directive\n      const next = this.tokenizer.expectToken(tape, TokenType.IDENT);\n      this.grammar.startSymbol = this.ensureSymbol(next.value as string, false);\n    } else if (directive == \"resyntax\") {\n      // override start directive\n      const next = this.tokenizer.expectToken(tape, TokenType.IDENT);\n      if (next.value != \"js\" && next.value != \"flex\") {\n        throw new SyntaxError(\"Invalid regex syntax: \" + next.value);\n      }\n      this.regexSyntax = next.value;\n    } else if (directive.startsWith(\"skip\")) {\n      const rule = this.parseRegex(tape, \"\", 30, directive.endsWith(\"flex\") ? \"flex\" : \"\");\n      const tokenHandler = this.parseTokenHandler(tape);\n      if (tokenHandler) {\n        this.generatedTokenizer.addRule(rule, (rule, tape, token) => {\n          tokenHandler(rule, tape, token, this);\n          return null;\n        });\n      } else {\n        this.generatedTokenizer.addRule(rule, () => null);\n      }\n    } else if (directive.startsWith(\"token\") || directive.startsWith(\"define\")) {\n      const isDef = directive.startsWith(\"define\");\n      const tokName = this.tokenizer.expectToken(tape, TokenType.IDENT, TokenType.STRING);\n      let label = tokName.value as string;\n      if (tokName.tag == TokenType.STRING || tokName.tag == TokenType.NUMBER) {\n        label = `\"${tokName.value}\"`;\n      }\n      const rule = this.parseRegex(tape, label, 0, directive.endsWith(\"flex\") ? \"flex\" : \"\");\n      if (isDef) {\n        // Define a \"reusable\" regex that is not a token on its own\n        this.generatedTokenizer.addVar(label, rule.expr);\n      } else {\n        const tokenHandler = this.parseTokenHandler(tape);\n        // see if we have a handler function here\n        this.generatedTokenizer.addRule(rule, tokenHandler);\n        // register it\n        this.ensureSymbol(label, true);\n      }\n    } else {\n      throw new Error(\"Invalid directive: \" + directive);\n    }\n  }\n\n  parseTokenHandler(tape: Tape): TLEX.RuleMatchHandler | null {\n    if (!this.tokenizer.consumeIf(tape, TokenType.OPEN_BRACE)) {\n      return null;\n    }\n\n    const funcName = this.tokenizer.expectToken(tape, TokenType.IDENT);\n\n    // how do we use the funcName to\n    const out = (rule: TLEX.Rule, tape: Tape, token: any, owner: any) => {\n      const handler = this.tokenHandlers[funcName.value];\n      if (!handler) throw new Error(\"Handler method not found: \" + funcName.value);\n      token = handler(token, tape, owner);\n      return token;\n    };\n\n    this.tokenizer.expectToken(tape, TokenType.CLOSE_BRACE);\n    return out;\n  }\n\n  parseDecl(tape: Tape): void {\n    const ident = this.tokenizer.expectToken(tape, TokenType.IDENT);\n    if (this.tokenizer.consumeIf(tape, TokenType.ARROW, TokenType.COLON)) {\n      const nt = this.ensureSymbol(ident.value as string, false);\n      if (nt.isTerminal) {\n        // it is a terminal so mark it as a non-term now that we\n        // know there is a declaration for it.\n        nt.isTerminal = false;\n      } else if (nt.isAuxiliary) {\n        throw new Error(\"NT is already auxiliary and cannot be reused.\");\n      }\n      for (const [rhs, action] of this.parseProductions(tape, this.grammar, nt)) {\n        const rule = this.grammar.add(nt, rhs, action);\n      }\n      this.tokenizer.expectToken(tape, TokenType.SEMI_COLON);\n    }\n  }\n\n  parseProductions(tape: Tape, grammar: Grammar, nt: TSU.Nullable<Sym>): [Str, RuleAction | null][] {\n    const out: [Str, RuleAction | null][] = [];\n    while (this.tokenizer.peek(tape) != null) {\n      const rule = this.parseProd(tape, grammar);\n      out.push(rule);\n      if (this.tokenizer.consumeIf(tape, TokenType.PIPE)) {\n        continue;\n      } else if (this.tokenizer.nextMatches(tape, TokenType.CLOSE_SQ, TokenType.CLOSE_PAREN, TokenType.SEMI_COLON)) {\n        break;\n      }\n    }\n    return out;\n  }\n\n  parseProd(tape: Tape, grammar: Grammar): [Str, null | RuleAction] {\n    const out = new Str();\n    while (true) {\n      // if we are starting with a FOLLOW symbol then return as it marks\n      // the end of this production\n      if (\n        this.tokenizer.nextMatches(\n          tape,\n          TokenType.CLOSE_PAREN,\n          TokenType.CLOSE_SQ,\n          TokenType.SEMI_COLON,\n          TokenType.PIPE,\n          TokenType.OPEN_BRACE,\n        )\n      ) {\n        break;\n        // return [out, null];\n      }\n\n      let curr: TSU.Nullable<Str> = null;\n      if (this.tokenizer.consumeIf(tape, TokenType.OPEN_PAREN)) {\n        const rules = this.parseProductions(tape, grammar, null);\n        if (rules.length == 0) {\n          // nothing\n        } else if (rules.length == 1) {\n          // TODO: Consider actions in non top level rules\n          curr = rules[0][0];\n        } else {\n          // create a new NT over this\n          // TODO: Consider actions in non top level rules\n          curr = grammar.anyof(...rules.map((r) => r[0]));\n        }\n        this.tokenizer.expectToken(tape, TokenType.CLOSE_PAREN);\n      } else if (this.tokenizer.consumeIf(tape, TokenType.OPEN_SQ)) {\n        const rules = this.parseProductions(tape, grammar, null);\n        if (rules.length == 0) {\n          // nothing\n        } else if (rules.length == 1) {\n          // TODO: Consider actions in non top level rules\n          curr = grammar.opt(rules[0][0]);\n        } else {\n          // create a new NT over this\n          // TODO: Consider actions in non top level rules\n          curr = grammar.opt(grammar.anyof(...rules.map((r) => r[0])));\n        }\n        this.tokenizer.expectToken(tape, TokenType.CLOSE_SQ);\n      } else if (\n        this.tokenizer.nextMatches(tape, TokenType.IDENT, TokenType.STRING, TokenType.NUMBER, TokenType.REGEX)\n      ) {\n        const token = this.tokenizer.next(tape) as TLEX.Token;\n        let label = token.value as string;\n        if (token.tag == TokenType.STRING || token.tag == TokenType.NUMBER) {\n          label = `\"${token.value}\"`;\n          const pattern = str2regex(token.value);\n          const rule = TLEX.Builder.build(pattern, { tag: label, priority: 20 });\n          this.generatedTokenizer.addRule(rule);\n        } else if (token.tag == TokenType.REGEX) {\n          label = \"/\" + token.value[0] + \"/\" + token.value[1];\n          let re = token.value[0];\n          if (token.value[1].length > 0) {\n            // Flags given so create\n            re = new RegExp(token.value[0], token.value[1]);\n          }\n          const rule = TLEX.Builder.build(re, { tag: label, priority: 10 });\n          this.generatedTokenizer.addRule(rule);\n        } else {\n          // Normal\n        }\n        // See if this symbol is already registered\n        const currSym = this.ensureSymbol(label, true);\n        curr = new Str(currSym);\n      } else {\n        throw new TLEX.UnexpectedTokenError(this.tokenizer.peek(tape));\n      }\n\n      if (curr == null) {\n        throw new Error(\"Could not determine node\");\n      }\n\n      if (this.tokenizer.consumeIf(tape, TokenType.STAR)) {\n        curr = grammar.atleast0(curr, this.leftRecursive);\n      } else if (this.tokenizer.consumeIf(tape, TokenType.PLUS)) {\n        curr = grammar.atleast1(curr, this.leftRecursive);\n      } else if (this.tokenizer.consumeIf(tape, TokenType.QMARK)) {\n        curr = grammar.opt(curr);\n      }\n      out.extend(curr);\n    }\n    let action: RuleAction | null = null;\n    if (this.tokenizer.consumeIf(tape, TokenType.OPEN_BRACE)) {\n      const next = this.tokenizer.expectToken(tape, TokenType.DOLLAR_NUM, TokenType.IDENT);\n      action = new RuleAction(next.value);\n      this.tokenizer.expectToken(tape, TokenType.CLOSE_BRACE);\n    }\n    return [out, action];\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport * as TLEX from \"tlex\";\nimport { Sym, Grammar, Rule } from \"./grammar\";\nimport {\n  PTNode,\n  SimpleParser as ParserBase,\n  BeforeAddingChildCallback,\n  RuleReductionCallback,\n  NextTokenCallback,\n} from \"./parser\";\nimport { ParseError } from \"./errors\";\n\ntype Nullable<T> = TSU.Nullable<T>;\ntype NumMap<T> = TSU.NumMap<T>;\ntype StringMap<T> = TSU.StringMap<T>;\n\nexport enum LRActionType {\n  ACCEPT,\n  SHIFT,\n  REDUCE,\n  GOTO, // can *ONLY* be valid for non-terms\n}\n\nexport class LRAction {\n  // Type of action\n  tag: LRActionType;\n\n  // Next state to go to after performing the action (if valid).\n  gotoState: Nullable<number> = null;\n\n  // The rule to be used for a reduce action\n  rule: Nullable<Rule> = null;\n\n  toString(): string {\n    if (this.tag == LRActionType.ACCEPT) return \"Acc\";\n    else if (this.tag == LRActionType.SHIFT) {\n      return \"S\" + this.gotoState!;\n    } else if (this.tag == LRActionType.REDUCE) {\n      return \"R \" + this.rule!.id;\n    } else {\n      return \"\" + this.gotoState!;\n    }\n  }\n\n  equals(another: LRAction): boolean {\n    return this.tag == another.tag && this.gotoState == another.gotoState && this.rule == another.rule;\n  }\n\n  static Shift(goto: number): LRAction {\n    const out = new LRAction();\n    out.tag = LRActionType.SHIFT;\n    out.gotoState = goto;\n    return out;\n  }\n\n  static Reduce(rule: Rule): LRAction {\n    const out = new LRAction();\n    out.tag = LRActionType.REDUCE;\n    out.rule = rule;\n    return out;\n  }\n\n  static Goto(gotoState: number): LRAction {\n    const out = new LRAction();\n    out.tag = LRActionType.GOTO;\n    out.gotoState = gotoState;\n    return out;\n  }\n\n  static Accept(): LRAction {\n    const out = new LRAction();\n    out.tag = LRActionType.ACCEPT;\n    return out;\n  }\n}\n\n/**\n * A parsing table for LR parsers.\n */\nexport class ParseTable {\n  // Records which actions have conflicts\n  conflictActions: NumMap<StringMap<boolean>> = {};\n\n  /**\n   * Maps symbol (by id) to the action;\n   */\n  actions: NumMap<NumMap<LRAction[]>> = {};\n\n  constructor(public readonly grammar: Grammar) {}\n\n  get hasConflicts(): boolean {\n    return Object.keys(this.conflictActions).length > 0;\n  }\n\n  /**\n   * Gets the action for a given sym from a given state.\n   */\n  getActions(stateId: number, next: Sym, ensure = false): LRAction[] {\n    let l1: NumMap<LRAction[]>;\n    if (stateId in this.actions) {\n      l1 = this.actions[stateId];\n    } else if (ensure) {\n      l1 = this.actions[stateId] = {};\n    } else {\n      return [];\n    }\n\n    if (next.id in l1) {\n      return l1[next.id];\n    } else if (ensure) {\n      return (l1[next.id] = []);\n    }\n    return [];\n  }\n\n  addAction(stateId: number, next: Sym, action: LRAction): this {\n    const actions = this.getActions(stateId, next, true);\n    if (actions.findIndex((ac) => ac.equals(action)) < 0) {\n      actions.push(action);\n    }\n    if (actions.length > 1) {\n      this.conflictActions[stateId] = this.conflictActions[stateId] || {};\n      this.conflictActions[stateId][next.label] = true;\n    }\n    return this;\n  }\n\n  get debugValue(): any {\n    const out: any = {};\n    for (const fromId in this.actions) {\n      out[fromId] = {};\n      for (const symId in this.actions[fromId]) {\n        const sym = this.grammar.getSymById(symId as any)!;\n        const actions = this.actions[fromId][sym.id] || [];\n        if (actions.length > 0) {\n          out[fromId][sym.label] = actions.map((a) => a.toString());\n        }\n      }\n    }\n    return out;\n  }\n}\n\nexport class ParseStack {\n  // A way of marking the kind of item that is on the stack\n  // true => isStateId\n  // false => isSymbolId\n  readonly stateStack: number[] = [];\n  readonly nodeStack: PTNode[] = [];\n\n  push(state: number, node: PTNode): void {\n    this.stateStack.push(state);\n    this.nodeStack.push(node);\n  }\n\n  /**\n   * Gets the nth item from the top of the stack.\n   */\n  top(nth = 0): [number, PTNode] {\n    return [this.stateStack[this.stateStack.length - 1 - nth], this.nodeStack[this.nodeStack.length - 1 - nth]];\n  }\n\n  pop(): [number, PTNode] {\n    const out = this.top();\n    this.stateStack.pop();\n    this.nodeStack.pop();\n    return out;\n  }\n\n  /**\n   * Pop N items from the stack.\n   */\n  popN(n = 1): void {\n    const L = this.stateStack.length;\n    this.stateStack.splice(L - n, n);\n    this.nodeStack.splice(L - n, n);\n  }\n\n  get isEmpty(): boolean {\n    return this.stateStack.length == 0 || this.nodeStack.length == 0;\n  }\n}\n\nexport type ActionResolverCallback = (\n  actions: LRAction[],\n  stack: ParseStack,\n  tokenbuffer: TLEX.TokenBuffer,\n) => LRAction;\n\nexport type RuleActionHandler = (rule: Rule, parent: PTNode, ...children: PTNode[]) => any;\n\nexport type TokenErrorCallback = (err: TLEX.TokenizerError, input: TLEX.Tape) => boolean;\n\nexport interface ParserContext {\n  buildParseTree?: boolean;\n  copySingleChild?: boolean;\n  ruleHandlers: TSU.StringMap<RuleActionHandler>;\n  beforeAddingChildNode?: BeforeAddingChildCallback;\n  onReduction?: RuleReductionCallback;\n  onNextToken?: NextTokenCallback;\n  actionResolver?: ActionResolverCallback;\n  onTokenError?: TokenErrorCallback;\n  // The owner used for tokenizer to get an insight into the context\n  // (to allow context sensitive scanning - aka \"scanner hacks\").\n  tokenizerContext: any;\n}\n\nexport class Parser extends ParserBase {\n  constructor(\n    public readonly parseTable: ParseTable,\n    config: any = {},\n  ) {\n    super();\n  }\n\n  get grammar(): Grammar {\n    return this.parseTable.grammar;\n  }\n\n  /**\n   * Parses the input and returns the resulting root Parse Tree node.\n   */\n  protected parseInput(input: TLEX.Tape, context?: ParserContext): Nullable<PTNode> {\n    context = context || ({} as ParserContext);\n    // Set default values for missing values\n    this.tokenbuffer.tokenizerContext = context.tokenizerContext;\n    if (context.buildParseTree != false) context.buildParseTree = true;\n    if (context.copySingleChild != false) context.copySingleChild = true;\n    let idCounter = 0;\n    const stack = new ParseStack();\n    stack.push(0, new PTNode(idCounter++, this.grammar.augStartRule.nt, null));\n    const tokenbuffer = this.tokenbuffer;\n    const g = this.grammar;\n    let output: Nullable<PTNode> = null;\n\n    /**\n     * Pick an action among several actions based on several factors (eg\n     * curr parse stack, tokenbuffer etc).\n     */\n    function resolveActions(actions: LRAction[]): LRAction {\n      if (context?.actionResolver) {\n        return context.actionResolver(actions, stack, tokenbuffer);\n      } else {\n        if (actions.length > 1) {\n          throw new Error(\"Multiple actions found.\");\n        }\n        return actions[0];\n      }\n    }\n\n    function nextToken(): TLEX.Token | null {\n      try {\n        return tokenbuffer.peek(input);\n      } catch (err /* InvalidCharacterException */) {\n        if (!context?.onTokenError || !context?.onTokenError(err as TLEX.TokenizerError, input)) {\n          // no handler or handler could do nothing so throw it up again\n          throw err;\n        }\n\n        // Handler managed to do \"something\" so retry again\n        // TODO - Check offsets were modified?\n        return nextToken();\n      }\n    }\n\n    while (true) {\n      // while (tokenbuffer.peek(input) != null || !stack.isEmpty) {\n      let token = nextToken();\n      if (token == null) {\n        if (stack.isEmpty) {\n          // no more to do\n          break;\n        }\n      } else if (context.onNextToken) {\n        token = context.onNextToken(token);\n      }\n      const nextSym = token == null ? g.Eof : this.getSym(token);\n      const nextValue = token == null ? null : token.value;\n      let [topState, topNode] = stack.top();\n      const actions = this.parseTable.getActions(topState, nextSym);\n      if (actions == null || actions.length == 0) {\n        // TODO - use a error handler here\n        throw new ParseError(`Unexpected Token: '${nextSym.label}'`, \"UnexpectedToken\", {\n          state: topState,\n          token: token,\n          nextSym: nextSym,\n        });\n      }\n\n      const action = resolveActions(actions);\n      if (action.tag == LRActionType.ACCEPT) {\n        break;\n      } else if (action.tag == LRActionType.SHIFT) {\n        tokenbuffer.next(input);\n        const newNode = new PTNode(idCounter++, nextSym, nextValue);\n        stack.push(action.gotoState!, newNode);\n      } else {\n        // reduce\n        TSU.assert(action.rule != null, \"Nonterm and ruleindex must be provided for a reduction action\");\n        const ruleLen = action.rule.rhs.length;\n\n        // here see if a rule handler exists - if it does use it\n        let newNode = new PTNode(idCounter++, action.rule.nt, null);\n        // Begin the reduction here. We are breaking the reduction into\n        // two parts:\n        //\n        // 1. Adding child nodes into the parent (reduced) node. Here\n        // the beforeAddingChildNode callback is used to modify children\n        // being added.\n        // 2. After all children have been added to give the caller a chance\n        // to handle/post-process the reduction - eg to build the semantic value.\n        //\n        // Our onReduction is a catch all to perform semantic actions.  Instead\n        // we could do rule specific ones by using the rule.action (if it exists)\n        // and only invoke the onReduction if a rule specific action does not exist.\n        //\n        // Are these \"double steps\" needed?  Can we just build parse tree, filter out\n        // child nodes and eval semantic value with a single action?\n        //\n        // Can semanticHandler do this?\n        //\n        // eg with\n        //\n        // E -> E + E { add }\n        //\n        // we could have our stack looking like;\n        //\n        // .... s1 E s2 E\n        //\n        // to be reduced and add could be called with:\n        //\n        // add(E1, E2) - as the child nodes themselves.\n        //\n        // the add handler could now do a few things:\n        //\n        // 1. Ensure all nodes are added to E as is (resulting in 3 nodes - \"E\", \"+\", \"E\")\n        // 2. Not add any nodes\n        // 3. Computing the value of E and E and the sum of those and put it in the parent E.\n        // 4. or all of the above.\n        //\n        // Doing filtering seems like a very premature usecase.  In the case of incremental\n        // parsing we may need all nodes to exist and filtering out can get in the way of that.\n        //\n        // But let us leave it for now and make any semantic handling happen *after* parse tree\n        // child node filter/transformation\n        if (context.buildParseTree) {\n          for (let i = ruleLen - 1; i >= 0; i--) {\n            const childNode: TSU.Nullable<PTNode> = stack.top(i)[1];\n            if (context.beforeAddingChildNode) {\n              for (const node of context.beforeAddingChildNode(newNode, childNode)) {\n                newNode.add(node);\n              }\n            } else if (childNode != null) {\n              newNode.add(childNode);\n            }\n          }\n        }\n        // Now apply the semantic handler if it exists\n        if (action.rule.action) {\n          // call it\n          if (action.rule.action.isFunction) {\n            // find the function associated with\n            const handlerName = action.rule.action.value;\n            const handler = context.ruleHandlers![handlerName];\n            if (!handler) throw new Error(\"Action handler not found: \" + handlerName);\n            // TODO - Replace the handler signature to take an\n            // interface that returns the nth child node (directly from\n            // the parse stack) instead of all children - this way we\n            // can even avoid building a parse tree if need be and\n            // decouple semantic actions from parse tree building\n            newNode.value = handler(action.rule, newNode, ...newNode.children);\n          } else {\n            // setting value as a child's value, eg $1, $2 etc\n            newNode.value = newNode.children[(action.rule.action.value as number) - 1].value;\n          }\n        } else if (context.onReduction) {\n          // fallback to default reduction handler\n          newNode = context.onReduction(newNode, action.rule);\n        } else if (newNode.children.length == 1 && context.copySingleChild) {\n          // If we have only 1 child set the semantic value to be child's value\n          // ie values \"bubble up\"\n          newNode.value = newNode.children[0].value;\n        }\n\n        // Perform the action reduction by popping ruleLen number of items off the stack\n        // and replace the top with our newNode\n        stack.popN(ruleLen);\n        [topState, topNode] = stack.top();\n        const newAction = resolveActions(this.parseTable.getActions(topState, action.rule.nt));\n        TSU.assert(newAction != null && newAction.gotoState != null, \"Top item does not have an action.\");\n        stack.push(newAction.gotoState, newNode);\n        output = newNode;\n      }\n    }\n    // It is possible that here no reductions have been done!\n    return output;\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport * as TLEX from \"tlex\";\nimport { Sym, Grammar, Rule } from \"./grammar\";\n\ntype Nullable<T> = TSU.Nullable<T>;\n\n/**\n * As the parse tree is built, nodes are created and added to parents bottom up.\n * This method is called before a child node is added to its parent.  The\n * node's left-most siblings have already been added this point.\n *\n * This method is an opportunity to filter or transfor the node or even adding\n * other nodes to the parent's child list.  Note that at this point the parent\n * has *NOT* been added to its parent.\n *\n * In order to filter out the node, return null.  Otherwise return a\n * PTNode instance for the actual node to be added to the parent.\n */\nexport type BeforeAddingChildCallback = (parent: PTNode, child: PTNode) => PTNode[];\n\n/**\n * This method is called when after a rule has been reduced.  At this time\n * all the children have already been reduced (and called with this method).\n * Now is the opportunity for the parent node reduction to perform custom\n * actions.  Note that this method cannot modify the stack.  It can only be\n * used to perform things like AST building or logging etc.\n */\nexport type RuleReductionCallback = (node: PTNode, rule: Rule) => PTNode;\n\n/**\n * This method is called as soon as the next token is received from the tokenizer.\n * This allows one to filter out tokens or even transform them based on any other\n * context being maintained.\n */\nexport type NextTokenCallback = (token: TLEX.Token) => TSU.Nullable<TLEX.Token>;\n\nexport class PFNode {\n  children: this[] = [];\n  constructor(\n    public readonly id: number,\n    public readonly sym: Sym,\n    public value: any,\n    ...children: PFNode[]\n  ) {\n    this.children = (children as this[]) || [];\n  }\n\n  get childCount(): number {\n    return this.children.length;\n  }\n\n  childAt(index: number): this {\n    if (index < 0) return this.children[this.children.length + index] as this;\n    return this.children[index] as this;\n  }\n\n  get isTerminal(): boolean {\n    return this.sym.isTerminal;\n  }\n\n  add(node: this, index = -1): this {\n    if (this.isTerminal) {\n      throw new Error(`Cannot add children (${node.sym.label}) to a terminal node: ${this.sym.label}`);\n    }\n    if (index < 0) {\n      this.children.push(node);\n    } else {\n      this.children.splice(index, 0, node);\n    }\n    return this;\n  }\n\n  splice(index: number, numToDelete: number, ...nodes: this[]): this {\n    this.children.splice(index, numToDelete, ...nodes);\n    return this;\n  }\n\n  get reprString(): string {\n    /*\n    let out = `Node(${this.sym.label}, {this.value}`;\n    if (this.children.length > 0) out += \", \" + this.children.map((c) => c.reprString).join(\", \");\n    out += \")\";\n    return out;\n    */\n    return this.debugValue(false).join(\"\\n\");\n  }\n\n  debugValue(raw = true): any {\n    if (raw) {\n      const out: any = [this.sym.label];\n      if (this.value) out.push(this.value);\n      if (this.children.length > 0) out.push(this.children.map((c) => c.debugValue(raw)));\n      return out;\n    } else {\n      const out: any[] = [];\n      const value = this.value;\n      out.push(this.value == null ? this.sym.label : this.sym.label + \" - \" + this.value);\n      this.children.forEach((node) => (node.debugValue(raw) as string[]).forEach((l) => out.push(\"  \" + l)));\n      return out;\n    }\n  }\n}\n\nexport class PTNode extends PFNode {\n  parent: Nullable<PTNode> = null;\n\n  add(node: this, index = -1): this {\n    super.add(node, index);\n    node.parent = this;\n    return this;\n  }\n\n  splice(index: number, numToDelete: number, ...nodes: this[]): this {\n    for (const node of nodes) node.parent = this;\n    return super.splice(index, numToDelete, ...nodes);\n  }\n}\n\nexport abstract class ParserBase {\n  tokenbuffer: TLEX.TokenBuffer;\n\n  setTokenizer(tokenizer: TLEX.NextTokenFunc): this {\n    this.tokenbuffer = new TLEX.TokenBuffer(tokenizer, null);\n    return this;\n  }\n\n  abstract get grammar(): Grammar;\n\n  /**\n   * Converts the token to a Terminal based on the tag value.\n   */\n  getSym(token: TLEX.Token): Sym {\n    const out = this.grammar.getSym(token.tag as string);\n    if (out == null) {\n      throw new Error(\"Invalid token tag: \" + token.tag + \", Value: \" + token.value);\n    }\n    return out;\n  }\n}\n\nexport abstract class SimpleParser extends ParserBase {\n  parse(input: string | TLEX.Tape, delegate: any = null): Nullable<PTNode> {\n    if (typeof input === \"string\") {\n      input = new TLEX.Tape(input);\n    }\n    return this.parseInput(input, delegate);\n  }\n\n  /**\n   * Parses the input and returns the resulting root Parse Tree node.\n   */\n  protected abstract parseInput(input: TLEX.Tape, delegate: any): Nullable<PTNode>;\n}\n\nexport abstract class ParallelParser extends ParserBase {\n  parse(input: string | TLEX.Tape, delegate: any = null): PFNode[] {\n    if (typeof input === \"string\") {\n      input = new TLEX.Tape(input);\n    }\n    return this.parseInput(input, delegate);\n  }\n\n  /**\n   * Parses the input and returns the resulting root Parse Tree node.\n   */\n  protected abstract parseInput(input: TLEX.Tape, delegate: any): PFNode[];\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { Sym, Grammar, Rule } from \"./grammar\";\nimport { IDSet } from \"./sets\";\n\ntype Nullable<T> = TSU.Nullable<T>;\ntype NumMap<T> = TSU.NumMap<T>;\n\nexport class LRItem {\n  id = 0;\n  readonly rule: Rule;\n  readonly position: number;\n  constructor(rule: Rule, position = 0) {\n    this.rule = rule;\n    this.position = position;\n  }\n\n  advance(): LRItem {\n    TSU.assert(this.position < this.rule.rhs.length);\n    return new LRItem(this.rule, this.position + 1);\n  }\n\n  copy(): LRItem {\n    return new LRItem(this.rule, this.position);\n  }\n\n  /**\n   * TODO - Instead of using strings as keys, can we use a unique ID?\n   * If we assume a max limit on number of non terminals in our grammar\n   * and a max limit on the number of rules per non terminal and a\n   * max limit on the size of each rule then we can uniquely identify\n   * a rule and position for a non-terminal by a single (64 bit) number\n   *\n   * We can use the following bitpacking to nominate this:\n   *\n   * <padding 16 bits><nt id 16 bits><ruleIndex 16 bits><position 16 bits>\n   */\n  get key(): string {\n    TSU.assert(!isNaN(this.rule.id), \"Rule's ID is not yet set.\");\n    return this.rule.id + \":\" + this.position;\n  }\n\n  compareTo(another: this): number {\n    let diff = this.rule.id - another.rule.id;\n    if (diff == 0) diff = this.position - another.position;\n    return diff;\n  }\n\n  equals(another: this): boolean {\n    return this.compareTo(another) == 0;\n  }\n\n  get debugString(): string {\n    const rule = this.rule;\n    const pos = this.position;\n    const pre = rule.rhs.syms.slice(0, pos).join(\" \");\n    const post = rule.rhs.syms.slice(pos).join(\" \");\n    return `${rule.id}  -  ${rule.nt} -> ${pre} • ${post}`;\n  }\n}\n\nexport class LRItemSet {\n  id = 0;\n  readonly itemGraph: LRItemGraph;\n  protected _key: Nullable<string> = null;\n  readonly values: number[];\n  protected _lookaheads: NumMap<Sym[]> = {};\n  protected _hasLookAheads = false;\n\n  constructor(ig: LRItemGraph, ...entries: number[]) {\n    this.itemGraph = ig;\n    this.values = entries;\n  }\n\n  copy(): LRItemSet {\n    const out = new LRItemSet(this.itemGraph, ...this.values);\n    out._lookaheads = { ...this._lookaheads };\n    out._hasLookAheads = this._hasLookAheads;\n    return out;\n  }\n\n  /**\n   * Adds a new look ahead symbol for a given item.\n   */\n  addLookAhead(item: LRItem, sym: Sym): boolean {\n    if (!(item.id in this._lookaheads)) {\n      this._lookaheads[item.id] = [];\n    }\n    for (const s of this._lookaheads[item.id]) if (s == sym) return false;\n    this._hasLookAheads = true;\n    this._key = null;\n    this._lookaheads[item.id].push(sym);\n    this._lookaheads[item.id].sort((s1, s2) => s1.id - s2.id);\n    return true;\n  }\n\n  /**\n   * Clears all lookaheads from this itemset.\n   */\n  clearLookAheads(): void {\n    this._lookaheads = {};\n  }\n\n  /**\n   * Gets the lookahead symbols for a given item.\n   */\n  getLookAheads(item: LRItem): ReadonlyArray<Sym> {\n    return this._lookaheads[item.id] || [];\n  }\n\n  // A way to cache the key of this item set.\n  // Keys help make the comparison of two sets easy.\n  get key(): string {\n    if (this._key == null) {\n      this._key = this.revalKey();\n    }\n    return this._key;\n  }\n\n  protected revalKey(): string {\n    if (this.hasLookAheads) {\n      this.values.sort();\n      return this.values\n        .map((itemId) => {\n          const la = this._lookaheads[itemId] || [];\n          return itemId + \"[\" + la.map((s) => s.id).join(\",\") + \"]\";\n        })\n        .join(\"/\");\n    } else {\n      this.values.sort();\n      return this.values.join(\"/\");\n    }\n  }\n\n  has(itemId: number): boolean {\n    return this.values.indexOf(itemId) >= 0;\n  }\n\n  equals(another: LRItemSet): boolean {\n    return this.key == another.key;\n  }\n\n  add(itemId: number): this {\n    if (!this.has(itemId)) {\n      this.values.push(itemId);\n      this._key = null;\n    }\n    return this;\n  }\n\n  get size(): number {\n    return this.values.length;\n  }\n\n  get debugString(): string {\n    return this.debugValue.join(\"\\n\");\n  }\n\n  get hasLookAheads(): boolean {\n    return this._hasLookAheads;\n  }\n\n  get debugValue(): any {\n    if (this.hasLookAheads) {\n      const items = this.values.map((v: number) => this.itemGraph.items.get(v));\n      // sort them by rule\n      items.sort((i1, i2) => i1.compareTo(i2));\n      // then append the look aheads\n      return items.map((item) => {\n        const las = this.getLookAheads(item)\n          .map((s) => s.label)\n          .sort((s1, s2) => s1.localeCompare(s2))\n          .join(\", \");\n        return las.length > 0 ? `${item.debugString} / ( ${las} )` : item.debugString;\n      });\n    } else {\n      const items = this.values.map((v: number) => this.itemGraph.items.get(v));\n      // sort them by rule\n      items.sort((i1, i2) => i1.compareTo(i2));\n      return items.map((i) => i.debugString);\n    }\n  }\n}\n\nexport abstract class LRItemGraph {\n  // List of all unique LRItems that can be used in this item graph.\n  // Note that since the same Item can reside in multiple sets only\n  // one is created via the newItem method and it is referred\n  // everwhere it is needed.\n\n  /**\n   * Using IDed sets of Items and ItemSets.\n   * This ensures that only one copy of an item exists\n   * \"by value\".\n   */\n  items: IDSet<LRItem>;\n  itemSets: IDSet<LRItemSet>;\n\n  // Goto sets for a set and a given transition out of it\n  gotoSets: NumMap<NumMap<LRItemSet>> = {};\n\n  abstract closure(itemSet: LRItemSet): LRItemSet;\n  abstract startSet(): LRItemSet;\n\n  constructor(public readonly grammar: Grammar) {\n    this.items = new IDSet();\n    this.itemSets = new IDSet();\n  }\n\n  protected startItem(): LRItem {\n    const startSymbol = this.grammar.startSymbol;\n    TSU.assert(startSymbol != null, \"Start symbol must be set\");\n    TSU.assert((this.grammar.augStartRule || null) != null, \"Grammar is not augmented\");\n    return this.items.ensure(new LRItem(this.grammar.augStartRule));\n  }\n\n  reset(): void {\n    this.grammar.refresh();\n    this.gotoSets = {};\n    this.items.clear();\n    this.itemSets.clear();\n    this.startSet();\n  }\n\n  refresh(): this {\n    this.reset();\n    this.grammar.refresh();\n    this.evalGotoSets();\n    return this;\n  }\n\n  /**\n   * Computes all the goto sets used to create the graph of items.\n   */\n  protected evalGotoSets(): void {\n    const out = this.itemSets;\n    for (let i = 0; i < out.size; i++) {\n      const currSet = out.get(i);\n      // This will also include the null symbol since Grammar\n      // adds Null and Eof symbols automatically\n      for (const sym of this.grammar.allSymbols) {\n        if (sym != this.grammar.Null) {\n          const gotoSet = this.goto(currSet, sym);\n          if (gotoSet.size > 0) {\n            this.setGoto(currSet, sym, gotoSet);\n          }\n        }\n      }\n    }\n  }\n\n  /**\n   * Computes the GOTO set of this ItemSet for a particular symbol transitioning\n   * out of this item set.\n   */\n  goto(itemSet: LRItemSet, sym: Sym): LRItemSet {\n    const out = this.newItemSet();\n    for (const itemId of itemSet.values) {\n      const item = this.items.get(itemId);\n      // see if item.position points to \"sym\" in its rule\n      const rule = item.rule;\n      if (item.position < rule.rhs.length) {\n        if (rule.rhs.syms[item.position] == sym) {\n          // advance the item and add it\n          this.advanceItemAndAdd(item, itemSet, out);\n        }\n      }\n    }\n    // compute the closure of the new set\n    return this.closure(out);\n  }\n\n  protected advanceItemAndAdd(itemToAdvance: LRItem, fromItemSet: LRItemSet, toItemSet: LRItemSet): void {\n    const newItem = this.items.ensure(itemToAdvance.advance());\n    toItemSet.add(newItem.id);\n    // copy over the look aheads\n    for (const laSym of fromItemSet.getLookAheads(itemToAdvance)) {\n      toItemSet.addLookAhead(newItem, laSym);\n    }\n  }\n\n  protected newItemSet(...items: LRItem[]): LRItemSet {\n    return new LRItemSet(this, ...items.map((item) => item.id));\n  }\n\n  get size(): number {\n    return this.itemSets.size;\n  }\n\n  protected ensureGotoSet(fromSet: LRItemSet): NumMap<LRItemSet> {\n    if (!(fromSet.id in this.gotoSets)) {\n      this.gotoSets[fromSet.id] = {};\n    }\n    return this.gotoSets[fromSet.id];\n  }\n\n  setGoto(fromSet: LRItemSet, sym: Sym, toSet: LRItemSet): void {\n    const entries = this.ensureGotoSet(fromSet);\n    entries[sym.id] = toSet;\n  }\n\n  getGoto(fromSet: LRItemSet, sym: Sym): Nullable<LRItemSet> {\n    return (this.gotoSets[fromSet.id] || {})[sym.id] || null;\n  }\n\n  forEachGoto(itemSet: LRItemSet, visitor: (sym: Sym, nextSet: LRItemSet) => boolean | void): void {\n    const gotoSet = this.gotoSets[itemSet.id] || {};\n    for (const symid in gotoSet) {\n      const sym = this.grammar.getSymById(symid as any) as Sym;\n      const next = gotoSet[symid];\n      if (visitor(sym, next) == false) break;\n    }\n  }\n\n  gotoSetFor(itemSet: LRItemSet): NumMap<LRItemSet> {\n    return this.gotoSets[itemSet.id] || {};\n  }\n\n  get debugValue(): any {\n    const out = {} as any;\n    this.itemSets.entries.forEach((iset) => {\n      out[iset.id] = { items: [], goto: {} };\n      out[iset.id][\"items\"] = iset.debugValue;\n      const g = this.gotoSets[iset.id];\n      for (const symid in g) {\n        const sym = this.grammar.getSymById(symid as any)!;\n        out[iset.id][\"goto\"] = out[iset.id][\"goto\"] || {};\n        out[iset.id][\"goto\"][sym.label] = g[symid].id;\n      }\n    });\n    return out;\n  }\n}\n\nexport class LR0ItemGraph extends LRItemGraph {\n  /**\n   * Creates the set for the grammar.  This is done by creating an\n   * augmented rule of the form S' -> S (where S is the start symbol of\n   * the grammar) and creating the closure of this starting rule, ie:\n   *\n   * StartSet = closure({S' -> . S})\n   */\n  startSet(): LRItemSet {\n    const startItem = this.startItem();\n    const newset = this.newItemSet(startItem);\n    return this.closure(newset);\n  }\n\n  /**\n   * Computes the closure of a given item set and returns a new\n   * item set.\n   */\n  closure(itemSet: LRItemSet): LRItemSet {\n    const out = new LRItemSet(this, ...itemSet.values);\n    for (let i = 0; i < out.values.length; i++) {\n      const itemId = out.values[i];\n      const item = this.items.get(itemId)!;\n      const rule = item.rule;\n      // Evaluate the closure\n      // Cannot do anything past the end\n      if (item.position < rule.rhs.length) {\n        const sym = rule.rhs.syms[item.position];\n        if (!sym.isTerminal) {\n          for (const rule of this.grammar.rulesForNT(sym)) {\n            const newItem = this.items.ensure(new LRItem(rule, 0));\n            out.add(newItem.id);\n          }\n        }\n      }\n    }\n    return out.size == 0 ? out : this.itemSets.ensure(out);\n  }\n}\n\nexport class LR1ItemGraph extends LRItemGraph {\n  /**\n   * Overridden to include the EOF marker as the lookahead for the start state\n   *\n   * StartSet = closure({S' -> . S, $})\n   */\n  startSet(): LRItemSet {\n    const startItem = this.startItem();\n    const newset = this.newItemSet(startItem);\n    newset.addLookAhead(startItem, this.grammar.Eof);\n    return this.closure(newset);\n  }\n\n  /**\n   * Computes the closure of this item set and returns a new\n   * item set.\n   */\n  closure(itemSet: LRItemSet): LRItemSet {\n    const out = itemSet.copy();\n    for (let i = 0; i < out.values.length; i++) {\n      const itemId = out.values[i];\n      const item = this.items.get(itemId) as LRItem;\n      // Evaluate the closure\n      // Cannot do anything past the end\n      if (item.position >= item.rule.rhs.length) continue;\n      const rhs = item.rule.rhs;\n      const B = rhs.syms[item.position];\n      if (B.isTerminal) continue;\n\n      for (const lookahead of out.getLookAheads(item)) {\n        const suffix = rhs.copy().append(lookahead);\n        this.grammar.firstSets.forEachTermIn(suffix, item.position + 1, (term) => {\n          if (term != null) {\n            // For each rule [ B -> beta, term ] add it to\n            // our list of items if it doesnt already exist\n            const bRules = this.grammar.rulesForNT(B);\n            for (const br of bRules) {\n              const newItem = this.items.ensure(new LRItem(br, 0));\n              out.add(newItem.id);\n              out.addLookAhead(newItem, term);\n            }\n          }\n        });\n      }\n    }\n    return out.size == 0 ? out : this.itemSets.ensure(out);\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { Grammar, Str, Sym, Rule } from \"./grammar\";\nimport { LRAction, ParseTable } from \"./lr\";\nimport { LRItem, LRItemSet, LRItemGraph, LR0ItemGraph, LR1ItemGraph } from \"./lritems\";\nimport { Goto } from \"./tests/utils\";\n\nexport function makeParseTable(g: Grammar, type = \"lr1\"): [ParseTable, LRItemGraph] {\n  switch (type) {\n    case \"lr1\":\n      return makeLRParseTable(g);\n    case \"lalr\":\n      return makeLALRParseTable(g);\n  }\n  return makeSLRParseTable(g);\n}\n\n/**\n * A SLR parse table maker.\n */\nexport function makeSLRParseTable(grammar: Grammar): [ParseTable, LRItemGraph] {\n  const ig = makeSLRAutomaton(grammar);\n  return [makeParseTableFromLA(ig, grammar), ig];\n}\n\nexport function makeSLRAutomaton(grammar: Grammar): LRItemGraph {\n  const ig = new LR0ItemGraph(grammar).refresh();\n  for (const itemSet of ig.itemSets.entries) {\n    evalLASetsForSLRItem(grammar, ig, itemSet);\n  }\n  return ig;\n}\n\n/**\n * For a given LR(0) Item in the LR0 automaton evaluates the lookahead set\n * for an SLR1 parse table.\n *\n * The SLR lookahead is:\n *\n *    SLRLA(q, A -> w) = Follow(A)\n *\n * @param grammar\n * @param ig\n * @param itemSet\n */\nexport function evalLASetsForSLRItem(grammar: Grammar, ig: LRItemGraph, itemSet: LRItemSet): void {\n  // Look for transitions from this set\n  for (const itemId of itemSet.values) {\n    const item = ig.items.get(itemId);\n    const rule = item.rule;\n    if (item.position >= rule.rhs.length) {\n      // if sym is in follows(nt) then add the rule\n      // Reduce nt -> rule for all sym in follows(nt)\n      grammar.followSets.forEachTerm(rule.nt, (term) => {\n        if (term != null) {\n          TSU.assert(term.isTerminal);\n          itemSet.addLookAhead(item, term);\n        }\n      });\n    }\n  }\n}\n\n/**\n * A canonical LR1 parse table maker.\n */\nexport function makeLRParseTable(grammar: Grammar): [ParseTable, LRItemGraph] {\n  const ig = new LR1ItemGraph(grammar).refresh();\n  const parseTable = makeParseTableFromLA(ig, grammar);\n  return [parseTable, ig];\n}\n\n/**\n * A LALR(1) parse table maker using Bermudez and Logothetis' (1989)\n *  \"Simple computation of LALR(1) lookahead sets\" method.\n */\nexport function makeLALRParseTable(grammar: Grammar): [ParseTable, LRItemGraph] {\n  // const [parseTable, ig] = makeSLRParseTable(grammar);\n  const [parseTable, ig] = makeSLRParseTable(grammar);\n\n  if (!parseTable.hasConflicts) {\n    return [parseTable, ig];\n  }\n\n  // This is a really simple method compared to DeRemer and Penello's method\n  // (based on relations).\n  //\n  // 1. First transform the grammar G into G' that is based on around the LR0\n  // item graph\n  const g2 = grammarFromLR0ItemGraph(ig, grammar);\n\n  // Reverse of goto sets in the LR automaton to track predecessor states.\n  const prevSets: TSU.NumMap<TSU.NumMap<Set<number>>> = {};\n\n  for (const startState in ig.gotoSets) {\n    for (const symId in ig.gotoSets[startState]) {\n      const nextSet = ig.gotoSets[startState][symId];\n      if (!(nextSet.id in prevSets)) {\n        prevSets[nextSet.id] = {};\n      }\n      if (!(symId in prevSets[nextSet.id])) {\n        prevSets[nextSet.id][symId] = new Set();\n      }\n      prevSets[nextSet.id][symId].add(startState as any as number);\n    }\n  }\n\n  // For conflict states upgrade lookahead sets based on union of follow\n  // sets of G2 for the corresponding sets\n  // LALRLA(q, A -> w) =\n  for (const startState in parseTable.conflictActions) {\n    // So here we have a startState where a symbol was extraneously added\n    // into the look ahead set.   So here recompute the lookahead set\n    // for this state\n    const itemSet = ig.itemSets.get(startState as any as number);\n    evalLASetsForLALRItem(grammar, g2, ig, itemSet, prevSets);\n  }\n\n  // Now that all look aheads have been recomputed - recreate\n  // the parse table\n  return [makeParseTableFromLA(ig, grammar), ig];\n}\n\n/**\n * Shared parse table creator for SLR/LR/LALR grammars that have lookahead\n * in the LR0 automaton.\n */\nexport function makeParseTableFromLA(ig: LRItemGraph, grammar: Grammar): ParseTable {\n  const parseTable = new ParseTable(grammar);\n  for (const itemSet of ig.itemSets.entries) {\n    // Look for transitions from this set\n    for (const itemId of itemSet.values) {\n      const item = ig.items.get(itemId);\n      const rule = item.rule;\n      if (item.position < rule.rhs.length) {\n        // possibilities of shift\n        const sym = rule.rhs.syms[item.position];\n        if (sym.isTerminal) {\n          const nextSet = ig.getGoto(itemSet, sym);\n          if (nextSet) {\n            parseTable.addAction(itemSet.id, sym, LRAction.Shift(nextSet.id));\n          }\n        }\n      } else if (!rule.nt.equals(grammar.augStartRule.nt)) {\n        // We have nt -> rule DOT / t\n        // AND nt != S'\n        // Reduce nt -> rule for t\n        const lookaheads = itemSet.getLookAheads(item);\n        for (const lookahead of lookaheads) {\n          parseTable.addAction(itemSet.id, lookahead, LRAction.Reduce(rule));\n        }\n      }\n    }\n\n    // Now create GOTO entries for (State,X) where X is a non-term\n    ig.forEachGoto(itemSet, (sym, next) => {\n      if (sym != null && !sym.isTerminal) {\n        parseTable.addAction(itemSet.id, sym, LRAction.Goto(next.id));\n      }\n    });\n\n    // If this state contains the augmented item, S' -> S . / $\n    // then add accept\n    const lr1Item = ig.items.ensure(new LRItem(grammar.augStartRule, 1));\n    itemSet.addLookAhead(lr1Item, grammar.Eof);\n    if (itemSet.has(lr1Item.id)) {\n      parseTable.addAction(itemSet.id, grammar.Eof, LRAction.Accept());\n    }\n  }\n  return parseTable;\n}\n\n/**\n * For a given LR(0) Item in the LR0 automaton evaluates the lookahead set\n * for an LALR1 parse table.\n *\n * The LALR lookahead is:\n *\n *    LALRLA(q, A -> w) = {t | [r:t] in Follow[p: A], Go[p: w] = q }\n *\n * Here [r: t] refers to a state in the augmented grammar transformed from the original\n * grammar where the nonterminals and terminals are based on the transitions in the\n * LR(0) automaton.  This augmented grammar is also passed in as a parameter.\n *\n * @param grammar     - Original grammar\n * @param augGrammar  - Augmented grammar\n * @param ig          - LR0 Automaton\n * @param itemSet     - The item set in the automaton (ie a particular state)\n *                      for which lookahead sets are to be computed.\n * @param prevSets    - A mapping where prevSets[stateI][symId] is a list of\n *                      states X1,X2...Xn where where the transition\n *                      X1[symId] = stateI, X2[symId] = stateI ...\n *                      Xn[symId] = stateI\n */\nexport function evalLASetsForLALRItem(\n  grammar: Grammar,\n  augGrammar: Grammar,\n  ig: LRItemGraph,\n  itemSet: LRItemSet,\n  prevSets: TSU.NumMap<TSU.NumMap<Set<number>>>,\n): void {\n  // find p going backwards from q spelling w\n  function findP(rule: Rule, i: number, currState: number, states: Set<number>): void {\n    if (i < 0) {\n      // we have reached the end - currState is P\n      // Ensure there is a transition from currState on rule.nt\n      const transitions: TSU.NumMap<LRItemSet> = ig.gotoSets[currState];\n      TSU.assert((transitions[rule.nt.id] || null) != null, \"Transition on rule.nt missing from start state\");\n      states.add(currState);\n    } else {\n      const sym = rule.rhs.syms[i];\n      const prevStates = prevSets[currState][sym.id] || null;\n      TSU.assert(prevStates != null, \"Prev set should not be null\");\n      prevStates.forEach((nextState) => findP(rule, i - 1, nextState, states));\n    }\n  }\n\n  itemSet.clearLookAheads();\n  // Look for transitions from this set\n  for (const itemId of itemSet.values) {\n    const item = ig.items.get(itemId);\n    const rule = item.rule;\n    if (item.position >= rule.rhs.length) {\n      // Here we have rule of the form A -> w in state q\n      //\n      // For this state we compute LALR lookaheads as:\n      //\n      // LALRLA(q, A -> w) = {t | [r:t] in Follow[p: A], Go[p: w] = q }\n      const pSet = new Set<number>();\n      findP(rule, rule.rhs.length - 1, itemSet.id, pSet);\n      pSet.forEach((p) => {\n        // Now find the NT [p: A] in the augmented grammar\n        const pALabel = `[${p}:${rule.nt.label}]`;\n        const pA = augGrammar.getSym(pALabel);\n        TSU.assert(pA != null, \"Augmented grammar symbol [p:A] not found\");\n        augGrammar.followSets.forEachTerm(pA, (term) => {\n          if (term != null && term != augGrammar.Eof) {\n            TSU.assert(term.isTerminal);\n            // This term is in the form [r: T] in the augmented grammar.\n            // Get the T from this and add to the look ahead set\n            const label = term.label.substring(term.label.indexOf(\":\") + 1, term.label.length - 1).trim();\n            const T = grammar.getSym(label);\n            TSU.assert(T != null, `T (${label}) in [r:T] cannot be null`);\n            itemSet.addLookAhead(item, T);\n          }\n        });\n      });\n    }\n  }\n}\n\n/**\n * For a grammar G and its LR0 ItemGraph, IG, returns a transformed grammar G'\n * that is based along the transitions of IG.\n *\n * For this new Grammar G' we have:\n *\n * NonTerminals N' =  { [p: A] | if Go[p: A] is defined },\n * Terminals T' =  { [p: t] | if Go[p: t] is defined },\n * Start Symbol S' = [ Start : S ]\n * Productions P' =  { [p1 : A ] -> [p1 : X1][p2 : X2]...[pn : Xn], if\n *                            [p1 : A] is in N'         AND\n *                            [pi : Xi] is in N' U T'   AND\n *                            A -> X1 X2 .. An is in P (of original grammar G)\n */\nexport function grammarFromLR0ItemGraph(ig: LR0ItemGraph, g: Grammar): Grammar {\n  const g2 = new Grammar();\n\n  function ensureG2Sym(pi: number, sym: Sym): Sym {\n    const newSymLabel = `[${pi}:${sym.label}]`;\n    const newSym = g2.ensureSym(new Sym(g2, newSymLabel, sym.isTerminal), false);\n    if (pi == 0 && g.startSymbol == sym && g.startSymbol != newSym && !sym.isTerminal) {\n      g2.startSymbol = newSym;\n    }\n    return newSym;\n  }\n\n  // Create N', T' and S'\n  for (const startState in ig.gotoSets) {\n    // transitions is a Map of symId -> ItemSet\n    const transitions: TSU.NumMap<LRItemSet> = ig.gotoSets[startState];\n    for (const symId in transitions) {\n      const sym = g.getSymById(symId as any as number)!;\n      ensureG2Sym(startState as any as number, sym);\n    }\n  }\n\n  function buildRuleFrom(startSet: number, A: Sym, rule: Rule): Str {\n    // Str to be built up for the production in the transformed grammar\n    //    -   [P1:X1][P2:X2]...[Pn:Xn]\n    let pi = startSet;\n    const newSyms = rule.rhs.syms.map((xi, index) => {\n      const nextSym = ensureG2Sym(pi, xi);\n      const transitions: TSU.NumMap<LRItemSet> = ig.gotoSets[pi];\n      const nextSet = transitions[xi.id] || null;\n      TSU.assert(nextSet != null, \"Next set transition *must* be valid\");\n      pi = nextSet.id;\n      return nextSym;\n    });\n    return new Str(...newSyms);\n  }\n\n  for (const startState in ig.gotoSets) {\n    // from P1 - for every transition that is a non terminal A\n    // find an equivalent chain of transition starting from P1 where we have\n    // [P1:X1][P2:X2]...[Pn:Xn]\n    // for All A -> X1X2...Xn in G\n    const transitions: TSU.NumMap<LRItemSet> = ig.gotoSets[startState];\n    for (const symId in transitions) {\n      const startSym = g.getSymById(symId as any as number)!;\n      const p1 = startState as any as number;\n      if (!startSym.isTerminal) {\n        const newA = ensureG2Sym(p1, startSym);\n        g.forEachRule(startSym, (rule, index) => {\n          const newRHS = buildRuleFrom(p1, startSym, rule);\n          const newRule = new Rule(newA, newRHS);\n          g2.addRule(newRule);\n        });\n      }\n    }\n  }\n  // Do another pass to evaluate P'\n  return g2;\n}\n","const ALIAS = Symbol.for('yaml.alias');\nconst DOC = Symbol.for('yaml.document');\nconst MAP = Symbol.for('yaml.map');\nconst PAIR = Symbol.for('yaml.pair');\nconst SCALAR = Symbol.for('yaml.scalar');\nconst SEQ = Symbol.for('yaml.seq');\nconst NODE_TYPE = Symbol.for('yaml.node.type');\nconst isAlias = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === ALIAS;\nconst isDocument = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === DOC;\nconst isMap = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === MAP;\nconst isPair = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === PAIR;\nconst isScalar = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === SCALAR;\nconst isSeq = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === SEQ;\nfunction isCollection(node) {\n    if (node && typeof node === 'object')\n        switch (node[NODE_TYPE]) {\n            case MAP:\n            case SEQ:\n                return true;\n        }\n    return false;\n}\nfunction isNode(node) {\n    if (node && typeof node === 'object')\n        switch (node[NODE_TYPE]) {\n            case ALIAS:\n            case MAP:\n            case SCALAR:\n            case SEQ:\n                return true;\n        }\n    return false;\n}\nconst hasAnchor = (node) => (isScalar(node) || isCollection(node)) && !!node.anchor;\n\nexport { ALIAS, DOC, MAP, NODE_TYPE, PAIR, SCALAR, SEQ, hasAnchor, isAlias, isCollection, isDocument, isMap, isNode, isPair, isScalar, isSeq };\n","import { isDocument, isNode, isPair, isCollection, isMap, isSeq, isScalar, isAlias } from './nodes/identity.js';\n\nconst BREAK = Symbol('break visit');\nconst SKIP = Symbol('skip children');\nconst REMOVE = Symbol('remove node');\n/**\n * Apply a visitor to an AST node or document.\n *\n * Walks through the tree (depth-first) starting from `node`, calling a\n * `visitor` function with three arguments:\n *   - `key`: For sequence values and map `Pair`, the node's index in the\n *     collection. Within a `Pair`, `'key'` or `'value'`, correspondingly.\n *     `null` for the root node.\n *   - `node`: The current node.\n *   - `path`: The ancestry of the current node.\n *\n * The return value of the visitor may be used to control the traversal:\n *   - `undefined` (default): Do nothing and continue\n *   - `visit.SKIP`: Do not visit the children of this node, continue with next\n *     sibling\n *   - `visit.BREAK`: Terminate traversal completely\n *   - `visit.REMOVE`: Remove the current node, then continue with the next one\n *   - `Node`: Replace the current node, then continue by visiting it\n *   - `number`: While iterating the items of a sequence or map, set the index\n *     of the next step. This is useful especially if the index of the current\n *     node has changed.\n *\n * If `visitor` is a single function, it will be called with all values\n * encountered in the tree, including e.g. `null` values. Alternatively,\n * separate visitor functions may be defined for each `Map`, `Pair`, `Seq`,\n * `Alias` and `Scalar` node. To define the same visitor function for more than\n * one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar)\n * and `Node` (alias, map, seq & scalar) targets. Of all these, only the most\n * specific defined one will be used for each node.\n */\nfunction visit(node, visitor) {\n    const visitor_ = initVisitor(visitor);\n    if (isDocument(node)) {\n        const cd = visit_(null, node.contents, visitor_, Object.freeze([node]));\n        if (cd === REMOVE)\n            node.contents = null;\n    }\n    else\n        visit_(null, node, visitor_, Object.freeze([]));\n}\n// Without the `as symbol` casts, TS declares these in the `visit`\n// namespace using `var`, but then complains about that because\n// `unique symbol` must be `const`.\n/** Terminate visit traversal completely */\nvisit.BREAK = BREAK;\n/** Do not visit the children of the current node */\nvisit.SKIP = SKIP;\n/** Remove the current node */\nvisit.REMOVE = REMOVE;\nfunction visit_(key, node, visitor, path) {\n    const ctrl = callVisitor(key, node, visitor, path);\n    if (isNode(ctrl) || isPair(ctrl)) {\n        replaceNode(key, path, ctrl);\n        return visit_(key, ctrl, visitor, path);\n    }\n    if (typeof ctrl !== 'symbol') {\n        if (isCollection(node)) {\n            path = Object.freeze(path.concat(node));\n            for (let i = 0; i < node.items.length; ++i) {\n                const ci = visit_(i, node.items[i], visitor, path);\n                if (typeof ci === 'number')\n                    i = ci - 1;\n                else if (ci === BREAK)\n                    return BREAK;\n                else if (ci === REMOVE) {\n                    node.items.splice(i, 1);\n                    i -= 1;\n                }\n            }\n        }\n        else if (isPair(node)) {\n            path = Object.freeze(path.concat(node));\n            const ck = visit_('key', node.key, visitor, path);\n            if (ck === BREAK)\n                return BREAK;\n            else if (ck === REMOVE)\n                node.key = null;\n            const cv = visit_('value', node.value, visitor, path);\n            if (cv === BREAK)\n                return BREAK;\n            else if (cv === REMOVE)\n                node.value = null;\n        }\n    }\n    return ctrl;\n}\n/**\n * Apply an async visitor to an AST node or document.\n *\n * Walks through the tree (depth-first) starting from `node`, calling a\n * `visitor` function with three arguments:\n *   - `key`: For sequence values and map `Pair`, the node's index in the\n *     collection. Within a `Pair`, `'key'` or `'value'`, correspondingly.\n *     `null` for the root node.\n *   - `node`: The current node.\n *   - `path`: The ancestry of the current node.\n *\n * The return value of the visitor may be used to control the traversal:\n *   - `Promise`: Must resolve to one of the following values\n *   - `undefined` (default): Do nothing and continue\n *   - `visit.SKIP`: Do not visit the children of this node, continue with next\n *     sibling\n *   - `visit.BREAK`: Terminate traversal completely\n *   - `visit.REMOVE`: Remove the current node, then continue with the next one\n *   - `Node`: Replace the current node, then continue by visiting it\n *   - `number`: While iterating the items of a sequence or map, set the index\n *     of the next step. This is useful especially if the index of the current\n *     node has changed.\n *\n * If `visitor` is a single function, it will be called with all values\n * encountered in the tree, including e.g. `null` values. Alternatively,\n * separate visitor functions may be defined for each `Map`, `Pair`, `Seq`,\n * `Alias` and `Scalar` node. To define the same visitor function for more than\n * one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar)\n * and `Node` (alias, map, seq & scalar) targets. Of all these, only the most\n * specific defined one will be used for each node.\n */\nasync function visitAsync(node, visitor) {\n    const visitor_ = initVisitor(visitor);\n    if (isDocument(node)) {\n        const cd = await visitAsync_(null, node.contents, visitor_, Object.freeze([node]));\n        if (cd === REMOVE)\n            node.contents = null;\n    }\n    else\n        await visitAsync_(null, node, visitor_, Object.freeze([]));\n}\n// Without the `as symbol` casts, TS declares these in the `visit`\n// namespace using `var`, but then complains about that because\n// `unique symbol` must be `const`.\n/** Terminate visit traversal completely */\nvisitAsync.BREAK = BREAK;\n/** Do not visit the children of the current node */\nvisitAsync.SKIP = SKIP;\n/** Remove the current node */\nvisitAsync.REMOVE = REMOVE;\nasync function visitAsync_(key, node, visitor, path) {\n    const ctrl = await callVisitor(key, node, visitor, path);\n    if (isNode(ctrl) || isPair(ctrl)) {\n        replaceNode(key, path, ctrl);\n        return visitAsync_(key, ctrl, visitor, path);\n    }\n    if (typeof ctrl !== 'symbol') {\n        if (isCollection(node)) {\n            path = Object.freeze(path.concat(node));\n            for (let i = 0; i < node.items.length; ++i) {\n                const ci = await visitAsync_(i, node.items[i], visitor, path);\n                if (typeof ci === 'number')\n                    i = ci - 1;\n                else if (ci === BREAK)\n                    return BREAK;\n                else if (ci === REMOVE) {\n                    node.items.splice(i, 1);\n                    i -= 1;\n                }\n            }\n        }\n        else if (isPair(node)) {\n            path = Object.freeze(path.concat(node));\n            const ck = await visitAsync_('key', node.key, visitor, path);\n            if (ck === BREAK)\n                return BREAK;\n            else if (ck === REMOVE)\n                node.key = null;\n            const cv = await visitAsync_('value', node.value, visitor, path);\n            if (cv === BREAK)\n                return BREAK;\n            else if (cv === REMOVE)\n                node.value = null;\n        }\n    }\n    return ctrl;\n}\nfunction initVisitor(visitor) {\n    if (typeof visitor === 'object' &&\n        (visitor.Collection || visitor.Node || visitor.Value)) {\n        return Object.assign({\n            Alias: visitor.Node,\n            Map: visitor.Node,\n            Scalar: visitor.Node,\n            Seq: visitor.Node\n        }, visitor.Value && {\n            Map: visitor.Value,\n            Scalar: visitor.Value,\n            Seq: visitor.Value\n        }, visitor.Collection && {\n            Map: visitor.Collection,\n            Seq: visitor.Collection\n        }, visitor);\n    }\n    return visitor;\n}\nfunction callVisitor(key, node, visitor, path) {\n    if (typeof visitor === 'function')\n        return visitor(key, node, path);\n    if (isMap(node))\n        return visitor.Map?.(key, node, path);\n    if (isSeq(node))\n        return visitor.Seq?.(key, node, path);\n    if (isPair(node))\n        return visitor.Pair?.(key, node, path);\n    if (isScalar(node))\n        return visitor.Scalar?.(key, node, path);\n    if (isAlias(node))\n        return visitor.Alias?.(key, node, path);\n    return undefined;\n}\nfunction replaceNode(key, path, node) {\n    const parent = path[path.length - 1];\n    if (isCollection(parent)) {\n        parent.items[key] = node;\n    }\n    else if (isPair(parent)) {\n        if (key === 'key')\n            parent.key = node;\n        else\n            parent.value = node;\n    }\n    else if (isDocument(parent)) {\n        parent.contents = node;\n    }\n    else {\n        const pt = isAlias(parent) ? 'alias' : 'scalar';\n        throw new Error(`Cannot replace node with ${pt} parent`);\n    }\n}\n\nexport { visit, visitAsync };\n","import { isNode } from '../nodes/identity.js';\nimport { visit } from '../visit.js';\n\nconst escapeChars = {\n    '!': '%21',\n    ',': '%2C',\n    '[': '%5B',\n    ']': '%5D',\n    '{': '%7B',\n    '}': '%7D'\n};\nconst escapeTagName = (tn) => tn.replace(/[!,[\\]{}]/g, ch => escapeChars[ch]);\nclass Directives {\n    constructor(yaml, tags) {\n        /**\n         * The directives-end/doc-start marker `---`. If `null`, a marker may still be\n         * included in the document's stringified representation.\n         */\n        this.docStart = null;\n        /** The doc-end marker `...`.  */\n        this.docEnd = false;\n        this.yaml = Object.assign({}, Directives.defaultYaml, yaml);\n        this.tags = Object.assign({}, Directives.defaultTags, tags);\n    }\n    clone() {\n        const copy = new Directives(this.yaml, this.tags);\n        copy.docStart = this.docStart;\n        return copy;\n    }\n    /**\n     * During parsing, get a Directives instance for the current document and\n     * update the stream state according to the current version's spec.\n     */\n    atDocument() {\n        const res = new Directives(this.yaml, this.tags);\n        switch (this.yaml.version) {\n            case '1.1':\n                this.atNextDocument = true;\n                break;\n            case '1.2':\n                this.atNextDocument = false;\n                this.yaml = {\n                    explicit: Directives.defaultYaml.explicit,\n                    version: '1.2'\n                };\n                this.tags = Object.assign({}, Directives.defaultTags);\n                break;\n        }\n        return res;\n    }\n    /**\n     * @param onError - May be called even if the action was successful\n     * @returns `true` on success\n     */\n    add(line, onError) {\n        if (this.atNextDocument) {\n            this.yaml = { explicit: Directives.defaultYaml.explicit, version: '1.1' };\n            this.tags = Object.assign({}, Directives.defaultTags);\n            this.atNextDocument = false;\n        }\n        const parts = line.trim().split(/[ \\t]+/);\n        const name = parts.shift();\n        switch (name) {\n            case '%TAG': {\n                if (parts.length !== 2) {\n                    onError(0, '%TAG directive should contain exactly two parts');\n                    if (parts.length < 2)\n                        return false;\n                }\n                const [handle, prefix] = parts;\n                this.tags[handle] = prefix;\n                return true;\n            }\n            case '%YAML': {\n                this.yaml.explicit = true;\n                if (parts.length !== 1) {\n                    onError(0, '%YAML directive should contain exactly one part');\n                    return false;\n                }\n                const [version] = parts;\n                if (version === '1.1' || version === '1.2') {\n                    this.yaml.version = version;\n                    return true;\n                }\n                else {\n                    const isValid = /^\\d+\\.\\d+$/.test(version);\n                    onError(6, `Unsupported YAML version ${version}`, isValid);\n                    return false;\n                }\n            }\n            default:\n                onError(0, `Unknown directive ${name}`, true);\n                return false;\n        }\n    }\n    /**\n     * Resolves a tag, matching handles to those defined in %TAG directives.\n     *\n     * @returns Resolved tag, which may also be the non-specific tag `'!'` or a\n     *   `'!local'` tag, or `null` if unresolvable.\n     */\n    tagName(source, onError) {\n        if (source === '!')\n            return '!'; // non-specific tag\n        if (source[0] !== '!') {\n            onError(`Not a valid tag: ${source}`);\n            return null;\n        }\n        if (source[1] === '<') {\n            const verbatim = source.slice(2, -1);\n            if (verbatim === '!' || verbatim === '!!') {\n                onError(`Verbatim tags aren't resolved, so ${source} is invalid.`);\n                return null;\n            }\n            if (source[source.length - 1] !== '>')\n                onError('Verbatim tags must end with a >');\n            return verbatim;\n        }\n        const [, handle, suffix] = source.match(/^(.*!)([^!]*)$/s);\n        if (!suffix)\n            onError(`The ${source} tag has no suffix`);\n        const prefix = this.tags[handle];\n        if (prefix) {\n            try {\n                return prefix + decodeURIComponent(suffix);\n            }\n            catch (error) {\n                onError(String(error));\n                return null;\n            }\n        }\n        if (handle === '!')\n            return source; // local tag\n        onError(`Could not resolve tag: ${source}`);\n        return null;\n    }\n    /**\n     * Given a fully resolved tag, returns its printable string form,\n     * taking into account current tag prefixes and defaults.\n     */\n    tagString(tag) {\n        for (const [handle, prefix] of Object.entries(this.tags)) {\n            if (tag.startsWith(prefix))\n                return handle + escapeTagName(tag.substring(prefix.length));\n        }\n        return tag[0] === '!' ? tag : `!<${tag}>`;\n    }\n    toString(doc) {\n        const lines = this.yaml.explicit\n            ? [`%YAML ${this.yaml.version || '1.2'}`]\n            : [];\n        const tagEntries = Object.entries(this.tags);\n        let tagNames;\n        if (doc && tagEntries.length > 0 && isNode(doc.contents)) {\n            const tags = {};\n            visit(doc.contents, (_key, node) => {\n                if (isNode(node) && node.tag)\n                    tags[node.tag] = true;\n            });\n            tagNames = Object.keys(tags);\n        }\n        else\n            tagNames = [];\n        for (const [handle, prefix] of tagEntries) {\n            if (handle === '!!' && prefix === 'tag:yaml.org,2002:')\n                continue;\n            if (!doc || tagNames.some(tn => tn.startsWith(prefix)))\n                lines.push(`%TAG ${handle} ${prefix}`);\n        }\n        return lines.join('\\n');\n    }\n}\nDirectives.defaultYaml = { explicit: false, version: '1.2' };\nDirectives.defaultTags = { '!!': 'tag:yaml.org,2002:' };\n\nexport { Directives };\n","import { isScalar, isCollection } from '../nodes/identity.js';\nimport { visit } from '../visit.js';\n\n/**\n * Verify that the input string is a valid anchor.\n *\n * Will throw on errors.\n */\nfunction anchorIsValid(anchor) {\n    if (/[\\x00-\\x19\\s,[\\]{}]/.test(anchor)) {\n        const sa = JSON.stringify(anchor);\n        const msg = `Anchor must not contain whitespace or control characters: ${sa}`;\n        throw new Error(msg);\n    }\n    return true;\n}\nfunction anchorNames(root) {\n    const anchors = new Set();\n    visit(root, {\n        Value(_key, node) {\n            if (node.anchor)\n                anchors.add(node.anchor);\n        }\n    });\n    return anchors;\n}\n/** Find a new anchor name with the given `prefix` and a one-indexed suffix. */\nfunction findNewAnchor(prefix, exclude) {\n    for (let i = 1; true; ++i) {\n        const name = `${prefix}${i}`;\n        if (!exclude.has(name))\n            return name;\n    }\n}\nfunction createNodeAnchors(doc, prefix) {\n    const aliasObjects = [];\n    const sourceObjects = new Map();\n    let prevAnchors = null;\n    return {\n        onAnchor: (source) => {\n            aliasObjects.push(source);\n            prevAnchors ?? (prevAnchors = anchorNames(doc));\n            const anchor = findNewAnchor(prefix, prevAnchors);\n            prevAnchors.add(anchor);\n            return anchor;\n        },\n        /**\n         * With circular references, the source node is only resolved after all\n         * of its child nodes are. This is why anchors are set only after all of\n         * the nodes have been created.\n         */\n        setAnchors: () => {\n            for (const source of aliasObjects) {\n                const ref = sourceObjects.get(source);\n                if (typeof ref === 'object' &&\n                    ref.anchor &&\n                    (isScalar(ref.node) || isCollection(ref.node))) {\n                    ref.node.anchor = ref.anchor;\n                }\n                else {\n                    const error = new Error('Failed to resolve repeated object (this should not happen)');\n                    error.source = source;\n                    throw error;\n                }\n            }\n        },\n        sourceObjects\n    };\n}\n\nexport { anchorIsValid, anchorNames, createNodeAnchors, findNewAnchor };\n","/**\n * Applies the JSON.parse reviver algorithm as defined in the ECMA-262 spec,\n * in section 24.5.1.1 \"Runtime Semantics: InternalizeJSONProperty\" of the\n * 2021 edition: https://tc39.es/ecma262/#sec-json.parse\n *\n * Includes extensions for handling Map and Set objects.\n */\nfunction applyReviver(reviver, obj, key, val) {\n    if (val && typeof val === 'object') {\n        if (Array.isArray(val)) {\n            for (let i = 0, len = val.length; i < len; ++i) {\n                const v0 = val[i];\n                const v1 = applyReviver(reviver, val, String(i), v0);\n                // eslint-disable-next-line @typescript-eslint/no-array-delete\n                if (v1 === undefined)\n                    delete val[i];\n                else if (v1 !== v0)\n                    val[i] = v1;\n            }\n        }\n        else if (val instanceof Map) {\n            for (const k of Array.from(val.keys())) {\n                const v0 = val.get(k);\n                const v1 = applyReviver(reviver, val, k, v0);\n                if (v1 === undefined)\n                    val.delete(k);\n                else if (v1 !== v0)\n                    val.set(k, v1);\n            }\n        }\n        else if (val instanceof Set) {\n            for (const v0 of Array.from(val)) {\n                const v1 = applyReviver(reviver, val, v0, v0);\n                if (v1 === undefined)\n                    val.delete(v0);\n                else if (v1 !== v0) {\n                    val.delete(v0);\n                    val.add(v1);\n                }\n            }\n        }\n        else {\n            for (const [k, v0] of Object.entries(val)) {\n                const v1 = applyReviver(reviver, val, k, v0);\n                if (v1 === undefined)\n                    delete val[k];\n                else if (v1 !== v0)\n                    val[k] = v1;\n            }\n        }\n    }\n    return reviver.call(obj, key, val);\n}\n\nexport { applyReviver };\n","import { hasAnchor } from './identity.js';\n\n/**\n * Recursively convert any node or its contents to native JavaScript\n *\n * @param value - The input value\n * @param arg - If `value` defines a `toJSON()` method, use this\n *   as its first argument\n * @param ctx - Conversion context, originally set in Document#toJS(). If\n *   `{ keep: true }` is not set, output should be suitable for JSON\n *   stringification.\n */\nfunction toJS(value, arg, ctx) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n    if (Array.isArray(value))\n        return value.map((v, i) => toJS(v, String(i), ctx));\n    if (value && typeof value.toJSON === 'function') {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-call\n        if (!ctx || !hasAnchor(value))\n            return value.toJSON(arg, ctx);\n        const data = { aliasCount: 0, count: 1, res: undefined };\n        ctx.anchors.set(value, data);\n        ctx.onCreate = res => {\n            data.res = res;\n            delete ctx.onCreate;\n        };\n        const res = value.toJSON(arg, ctx);\n        if (ctx.onCreate)\n            ctx.onCreate(res);\n        return res;\n    }\n    if (typeof value === 'bigint' && !ctx?.keep)\n        return Number(value);\n    return value;\n}\n\nexport { toJS };\n","import { applyReviver } from '../doc/applyReviver.js';\nimport { NODE_TYPE, isDocument } from './identity.js';\nimport { toJS } from './toJS.js';\n\nclass NodeBase {\n    constructor(type) {\n        Object.defineProperty(this, NODE_TYPE, { value: type });\n    }\n    /** Create a copy of this node.  */\n    clone() {\n        const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));\n        if (this.range)\n            copy.range = this.range.slice();\n        return copy;\n    }\n    /** A plain JavaScript representation of this node. */\n    toJS(doc, { mapAsMap, maxAliasCount, onAnchor, reviver } = {}) {\n        if (!isDocument(doc))\n            throw new TypeError('A document argument is required');\n        const ctx = {\n            anchors: new Map(),\n            doc,\n            keep: true,\n            mapAsMap: mapAsMap === true,\n            mapKeyWarned: false,\n            maxAliasCount: typeof maxAliasCount === 'number' ? maxAliasCount : 100\n        };\n        const res = toJS(this, '', ctx);\n        if (typeof onAnchor === 'function')\n            for (const { count, res } of ctx.anchors.values())\n                onAnchor(res, count);\n        return typeof reviver === 'function'\n            ? applyReviver(reviver, { '': res }, '', res)\n            : res;\n    }\n}\n\nexport { NodeBase };\n","import { anchorIsValid } from '../doc/anchors.js';\nimport { visit } from '../visit.js';\nimport { ALIAS, isAlias, isCollection, isPair, hasAnchor } from './identity.js';\nimport { NodeBase } from './Node.js';\nimport { toJS } from './toJS.js';\n\nclass Alias extends NodeBase {\n    constructor(source) {\n        super(ALIAS);\n        this.source = source;\n        Object.defineProperty(this, 'tag', {\n            set() {\n                throw new Error('Alias nodes cannot have tags');\n            }\n        });\n    }\n    /**\n     * Resolve the value of this alias within `doc`, finding the last\n     * instance of the `source` anchor before this node.\n     */\n    resolve(doc, ctx) {\n        let nodes;\n        if (ctx?.aliasResolveCache) {\n            nodes = ctx.aliasResolveCache;\n        }\n        else {\n            nodes = [];\n            visit(doc, {\n                Node: (_key, node) => {\n                    if (isAlias(node) || hasAnchor(node))\n                        nodes.push(node);\n                }\n            });\n            if (ctx)\n                ctx.aliasResolveCache = nodes;\n        }\n        let found = undefined;\n        for (const node of nodes) {\n            if (node === this)\n                break;\n            if (node.anchor === this.source)\n                found = node;\n        }\n        return found;\n    }\n    toJSON(_arg, ctx) {\n        if (!ctx)\n            return { source: this.source };\n        const { anchors, doc, maxAliasCount } = ctx;\n        const source = this.resolve(doc, ctx);\n        if (!source) {\n            const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;\n            throw new ReferenceError(msg);\n        }\n        let data = anchors.get(source);\n        if (!data) {\n            // Resolve anchors for Node.prototype.toJS()\n            toJS(source, null, ctx);\n            data = anchors.get(source);\n        }\n        /* istanbul ignore if */\n        if (data?.res === undefined) {\n            const msg = 'This should not happen: Alias anchor was not resolved?';\n            throw new ReferenceError(msg);\n        }\n        if (maxAliasCount >= 0) {\n            data.count += 1;\n            if (data.aliasCount === 0)\n                data.aliasCount = getAliasCount(doc, source, anchors);\n            if (data.count * data.aliasCount > maxAliasCount) {\n                const msg = 'Excessive alias count indicates a resource exhaustion attack';\n                throw new ReferenceError(msg);\n            }\n        }\n        return data.res;\n    }\n    toString(ctx, _onComment, _onChompKeep) {\n        const src = `*${this.source}`;\n        if (ctx) {\n            anchorIsValid(this.source);\n            if (ctx.options.verifyAliasOrder && !ctx.anchors.has(this.source)) {\n                const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;\n                throw new Error(msg);\n            }\n            if (ctx.implicitKey)\n                return `${src} `;\n        }\n        return src;\n    }\n}\nfunction getAliasCount(doc, node, anchors) {\n    if (isAlias(node)) {\n        const source = node.resolve(doc);\n        const anchor = anchors && source && anchors.get(source);\n        return anchor ? anchor.count * anchor.aliasCount : 0;\n    }\n    else if (isCollection(node)) {\n        let count = 0;\n        for (const item of node.items) {\n            const c = getAliasCount(doc, item, anchors);\n            if (c > count)\n                count = c;\n        }\n        return count;\n    }\n    else if (isPair(node)) {\n        const kc = getAliasCount(doc, node.key, anchors);\n        const vc = getAliasCount(doc, node.value, anchors);\n        return Math.max(kc, vc);\n    }\n    return 1;\n}\n\nexport { Alias };\n","import { SCALAR } from './identity.js';\nimport { NodeBase } from './Node.js';\nimport { toJS } from './toJS.js';\n\nconst isScalarValue = (value) => !value || (typeof value !== 'function' && typeof value !== 'object');\nclass Scalar extends NodeBase {\n    constructor(value) {\n        super(SCALAR);\n        this.value = value;\n    }\n    toJSON(arg, ctx) {\n        return ctx?.keep ? this.value : toJS(this.value, arg, ctx);\n    }\n    toString() {\n        return String(this.value);\n    }\n}\nScalar.BLOCK_FOLDED = 'BLOCK_FOLDED';\nScalar.BLOCK_LITERAL = 'BLOCK_LITERAL';\nScalar.PLAIN = 'PLAIN';\nScalar.QUOTE_DOUBLE = 'QUOTE_DOUBLE';\nScalar.QUOTE_SINGLE = 'QUOTE_SINGLE';\n\nexport { Scalar, isScalarValue };\n","import { Alias } from '../nodes/Alias.js';\nimport { isNode, isPair, MAP, SEQ, isDocument } from '../nodes/identity.js';\nimport { Scalar } from '../nodes/Scalar.js';\n\nconst defaultTagPrefix = 'tag:yaml.org,2002:';\nfunction findTagObject(value, tagName, tags) {\n    if (tagName) {\n        const match = tags.filter(t => t.tag === tagName);\n        const tagObj = match.find(t => !t.format) ?? match[0];\n        if (!tagObj)\n            throw new Error(`Tag ${tagName} not found`);\n        return tagObj;\n    }\n    return tags.find(t => t.identify?.(value) && !t.format);\n}\nfunction createNode(value, tagName, ctx) {\n    if (isDocument(value))\n        value = value.contents;\n    if (isNode(value))\n        return value;\n    if (isPair(value)) {\n        const map = ctx.schema[MAP].createNode?.(ctx.schema, null, ctx);\n        map.items.push(value);\n        return map;\n    }\n    if (value instanceof String ||\n        value instanceof Number ||\n        value instanceof Boolean ||\n        (typeof BigInt !== 'undefined' && value instanceof BigInt) // not supported everywhere\n    ) {\n        // https://tc39.es/ecma262/#sec-serializejsonproperty\n        value = value.valueOf();\n    }\n    const { aliasDuplicateObjects, onAnchor, onTagObj, schema, sourceObjects } = ctx;\n    // Detect duplicate references to the same object & use Alias nodes for all\n    // after first. The `ref` wrapper allows for circular references to resolve.\n    let ref = undefined;\n    if (aliasDuplicateObjects && value && typeof value === 'object') {\n        ref = sourceObjects.get(value);\n        if (ref) {\n            ref.anchor ?? (ref.anchor = onAnchor(value));\n            return new Alias(ref.anchor);\n        }\n        else {\n            ref = { anchor: null, node: null };\n            sourceObjects.set(value, ref);\n        }\n    }\n    if (tagName?.startsWith('!!'))\n        tagName = defaultTagPrefix + tagName.slice(2);\n    let tagObj = findTagObject(value, tagName, schema.tags);\n    if (!tagObj) {\n        if (value && typeof value.toJSON === 'function') {\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-call\n            value = value.toJSON();\n        }\n        if (!value || typeof value !== 'object') {\n            const node = new Scalar(value);\n            if (ref)\n                ref.node = node;\n            return node;\n        }\n        tagObj =\n            value instanceof Map\n                ? schema[MAP]\n                : Symbol.iterator in Object(value)\n                    ? schema[SEQ]\n                    : schema[MAP];\n    }\n    if (onTagObj) {\n        onTagObj(tagObj);\n        delete ctx.onTagObj;\n    }\n    const node = tagObj?.createNode\n        ? tagObj.createNode(ctx.schema, value, ctx)\n        : typeof tagObj?.nodeClass?.from === 'function'\n            ? tagObj.nodeClass.from(ctx.schema, value, ctx)\n            : new Scalar(value);\n    if (tagName)\n        node.tag = tagName;\n    else if (!tagObj.default)\n        node.tag = tagObj.tag;\n    if (ref)\n        ref.node = node;\n    return node;\n}\n\nexport { createNode };\n","import { createNode } from '../doc/createNode.js';\nimport { isNode, isPair, isCollection, isScalar } from './identity.js';\nimport { NodeBase } from './Node.js';\n\nfunction collectionFromPath(schema, path, value) {\n    let v = value;\n    for (let i = path.length - 1; i >= 0; --i) {\n        const k = path[i];\n        if (typeof k === 'number' && Number.isInteger(k) && k >= 0) {\n            const a = [];\n            a[k] = v;\n            v = a;\n        }\n        else {\n            v = new Map([[k, v]]);\n        }\n    }\n    return createNode(v, undefined, {\n        aliasDuplicateObjects: false,\n        keepUndefined: false,\n        onAnchor: () => {\n            throw new Error('This should not happen, please report a bug.');\n        },\n        schema,\n        sourceObjects: new Map()\n    });\n}\n// Type guard is intentionally a little wrong so as to be more useful,\n// as it does not cover untypable empty non-string iterables (e.g. []).\nconst isEmptyPath = (path) => path == null ||\n    (typeof path === 'object' && !!path[Symbol.iterator]().next().done);\nclass Collection extends NodeBase {\n    constructor(type, schema) {\n        super(type);\n        Object.defineProperty(this, 'schema', {\n            value: schema,\n            configurable: true,\n            enumerable: false,\n            writable: true\n        });\n    }\n    /**\n     * Create a copy of this collection.\n     *\n     * @param schema - If defined, overwrites the original's schema\n     */\n    clone(schema) {\n        const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));\n        if (schema)\n            copy.schema = schema;\n        copy.items = copy.items.map(it => isNode(it) || isPair(it) ? it.clone(schema) : it);\n        if (this.range)\n            copy.range = this.range.slice();\n        return copy;\n    }\n    /**\n     * Adds a value to the collection. For `!!map` and `!!omap` the value must\n     * be a Pair instance or a `{ key, value }` object, which may not have a key\n     * that already exists in the map.\n     */\n    addIn(path, value) {\n        if (isEmptyPath(path))\n            this.add(value);\n        else {\n            const [key, ...rest] = path;\n            const node = this.get(key, true);\n            if (isCollection(node))\n                node.addIn(rest, value);\n            else if (node === undefined && this.schema)\n                this.set(key, collectionFromPath(this.schema, rest, value));\n            else\n                throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);\n        }\n    }\n    /**\n     * Removes a value from the collection.\n     * @returns `true` if the item was found and removed.\n     */\n    deleteIn(path) {\n        const [key, ...rest] = path;\n        if (rest.length === 0)\n            return this.delete(key);\n        const node = this.get(key, true);\n        if (isCollection(node))\n            return node.deleteIn(rest);\n        else\n            throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);\n    }\n    /**\n     * Returns item at `key`, or `undefined` if not found. By default unwraps\n     * scalar values from their surrounding node; to disable set `keepScalar` to\n     * `true` (collections are always returned intact).\n     */\n    getIn(path, keepScalar) {\n        const [key, ...rest] = path;\n        const node = this.get(key, true);\n        if (rest.length === 0)\n            return !keepScalar && isScalar(node) ? node.value : node;\n        else\n            return isCollection(node) ? node.getIn(rest, keepScalar) : undefined;\n    }\n    hasAllNullValues(allowScalar) {\n        return this.items.every(node => {\n            if (!isPair(node))\n                return false;\n            const n = node.value;\n            return (n == null ||\n                (allowScalar &&\n                    isScalar(n) &&\n                    n.value == null &&\n                    !n.commentBefore &&\n                    !n.comment &&\n                    !n.tag));\n        });\n    }\n    /**\n     * Checks if the collection includes a value with the key `key`.\n     */\n    hasIn(path) {\n        const [key, ...rest] = path;\n        if (rest.length === 0)\n            return this.has(key);\n        const node = this.get(key, true);\n        return isCollection(node) ? node.hasIn(rest) : false;\n    }\n    /**\n     * Sets a value in this collection. For `!!set`, `value` needs to be a\n     * boolean to add/remove the item from the set.\n     */\n    setIn(path, value) {\n        const [key, ...rest] = path;\n        if (rest.length === 0) {\n            this.set(key, value);\n        }\n        else {\n            const node = this.get(key, true);\n            if (isCollection(node))\n                node.setIn(rest, value);\n            else if (node === undefined && this.schema)\n                this.set(key, collectionFromPath(this.schema, rest, value));\n            else\n                throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);\n        }\n    }\n}\n\nexport { Collection, collectionFromPath, isEmptyPath };\n","/**\n * Stringifies a comment.\n *\n * Empty comment lines are left empty,\n * lines consisting of a single space are replaced by `#`,\n * and all other lines are prefixed with a `#`.\n */\nconst stringifyComment = (str) => str.replace(/^(?!$)(?: $)?/gm, '#');\nfunction indentComment(comment, indent) {\n    if (/^\\n+$/.test(comment))\n        return comment.substring(1);\n    return indent ? comment.replace(/^(?! *$)/gm, indent) : comment;\n}\nconst lineComment = (str, indent, comment) => str.endsWith('\\n')\n    ? indentComment(comment, indent)\n    : comment.includes('\\n')\n        ? '\\n' + indentComment(comment, indent)\n        : (str.endsWith(' ') ? '' : ' ') + comment;\n\nexport { indentComment, lineComment, stringifyComment };\n","const FOLD_FLOW = 'flow';\nconst FOLD_BLOCK = 'block';\nconst FOLD_QUOTED = 'quoted';\n/**\n * Tries to keep input at up to `lineWidth` characters, splitting only on spaces\n * not followed by newlines or spaces unless `mode` is `'quoted'`. Lines are\n * terminated with `\\n` and started with `indent`.\n */\nfunction foldFlowLines(text, indent, mode = 'flow', { indentAtStart, lineWidth = 80, minContentWidth = 20, onFold, onOverflow } = {}) {\n    if (!lineWidth || lineWidth < 0)\n        return text;\n    if (lineWidth < minContentWidth)\n        minContentWidth = 0;\n    const endStep = Math.max(1 + minContentWidth, 1 + lineWidth - indent.length);\n    if (text.length <= endStep)\n        return text;\n    const folds = [];\n    const escapedFolds = {};\n    let end = lineWidth - indent.length;\n    if (typeof indentAtStart === 'number') {\n        if (indentAtStart > lineWidth - Math.max(2, minContentWidth))\n            folds.push(0);\n        else\n            end = lineWidth - indentAtStart;\n    }\n    let split = undefined;\n    let prev = undefined;\n    let overflow = false;\n    let i = -1;\n    let escStart = -1;\n    let escEnd = -1;\n    if (mode === FOLD_BLOCK) {\n        i = consumeMoreIndentedLines(text, i, indent.length);\n        if (i !== -1)\n            end = i + endStep;\n    }\n    for (let ch; (ch = text[(i += 1)]);) {\n        if (mode === FOLD_QUOTED && ch === '\\\\') {\n            escStart = i;\n            switch (text[i + 1]) {\n                case 'x':\n                    i += 3;\n                    break;\n                case 'u':\n                    i += 5;\n                    break;\n                case 'U':\n                    i += 9;\n                    break;\n                default:\n                    i += 1;\n            }\n            escEnd = i;\n        }\n        if (ch === '\\n') {\n            if (mode === FOLD_BLOCK)\n                i = consumeMoreIndentedLines(text, i, indent.length);\n            end = i + indent.length + endStep;\n            split = undefined;\n        }\n        else {\n            if (ch === ' ' &&\n                prev &&\n                prev !== ' ' &&\n                prev !== '\\n' &&\n                prev !== '\\t') {\n                // space surrounded by non-space can be replaced with newline + indent\n                const next = text[i + 1];\n                if (next && next !== ' ' && next !== '\\n' && next !== '\\t')\n                    split = i;\n            }\n            if (i >= end) {\n                if (split) {\n                    folds.push(split);\n                    end = split + endStep;\n                    split = undefined;\n                }\n                else if (mode === FOLD_QUOTED) {\n                    // white-space collected at end may stretch past lineWidth\n                    while (prev === ' ' || prev === '\\t') {\n                        prev = ch;\n                        ch = text[(i += 1)];\n                        overflow = true;\n                    }\n                    // Account for newline escape, but don't break preceding escape\n                    const j = i > escEnd + 1 ? i - 2 : escStart - 1;\n                    // Bail out if lineWidth & minContentWidth are shorter than an escape string\n                    if (escapedFolds[j])\n                        return text;\n                    folds.push(j);\n                    escapedFolds[j] = true;\n                    end = j + endStep;\n                    split = undefined;\n                }\n                else {\n                    overflow = true;\n                }\n            }\n        }\n        prev = ch;\n    }\n    if (overflow && onOverflow)\n        onOverflow();\n    if (folds.length === 0)\n        return text;\n    if (onFold)\n        onFold();\n    let res = text.slice(0, folds[0]);\n    for (let i = 0; i < folds.length; ++i) {\n        const fold = folds[i];\n        const end = folds[i + 1] || text.length;\n        if (fold === 0)\n            res = `\\n${indent}${text.slice(0, end)}`;\n        else {\n            if (mode === FOLD_QUOTED && escapedFolds[fold])\n                res += `${text[fold]}\\\\`;\n            res += `\\n${indent}${text.slice(fold + 1, end)}`;\n        }\n    }\n    return res;\n}\n/**\n * Presumes `i + 1` is at the start of a line\n * @returns index of last newline in more-indented block\n */\nfunction consumeMoreIndentedLines(text, i, indent) {\n    let end = i;\n    let start = i + 1;\n    let ch = text[start];\n    while (ch === ' ' || ch === '\\t') {\n        if (i < start + indent) {\n            ch = text[++i];\n        }\n        else {\n            do {\n                ch = text[++i];\n            } while (ch && ch !== '\\n');\n            end = i;\n            start = i + 1;\n            ch = text[start];\n        }\n    }\n    return end;\n}\n\nexport { FOLD_BLOCK, FOLD_FLOW, FOLD_QUOTED, foldFlowLines };\n","import { Scalar } from '../nodes/Scalar.js';\nimport { foldFlowLines, FOLD_FLOW, FOLD_QUOTED, FOLD_BLOCK } from './foldFlowLines.js';\n\nconst getFoldOptions = (ctx, isBlock) => ({\n    indentAtStart: isBlock ? ctx.indent.length : ctx.indentAtStart,\n    lineWidth: ctx.options.lineWidth,\n    minContentWidth: ctx.options.minContentWidth\n});\n// Also checks for lines starting with %, as parsing the output as YAML 1.1 will\n// presume that's starting a new document.\nconst containsDocumentMarker = (str) => /^(%|---|\\.\\.\\.)/m.test(str);\nfunction lineLengthOverLimit(str, lineWidth, indentLength) {\n    if (!lineWidth || lineWidth < 0)\n        return false;\n    const limit = lineWidth - indentLength;\n    const strLen = str.length;\n    if (strLen <= limit)\n        return false;\n    for (let i = 0, start = 0; i < strLen; ++i) {\n        if (str[i] === '\\n') {\n            if (i - start > limit)\n                return true;\n            start = i + 1;\n            if (strLen - start <= limit)\n                return false;\n        }\n    }\n    return true;\n}\nfunction doubleQuotedString(value, ctx) {\n    const json = JSON.stringify(value);\n    if (ctx.options.doubleQuotedAsJSON)\n        return json;\n    const { implicitKey } = ctx;\n    const minMultiLineLength = ctx.options.doubleQuotedMinMultiLineLength;\n    const indent = ctx.indent || (containsDocumentMarker(value) ? '  ' : '');\n    let str = '';\n    let start = 0;\n    for (let i = 0, ch = json[i]; ch; ch = json[++i]) {\n        if (ch === ' ' && json[i + 1] === '\\\\' && json[i + 2] === 'n') {\n            // space before newline needs to be escaped to not be folded\n            str += json.slice(start, i) + '\\\\ ';\n            i += 1;\n            start = i;\n            ch = '\\\\';\n        }\n        if (ch === '\\\\')\n            switch (json[i + 1]) {\n                case 'u':\n                    {\n                        str += json.slice(start, i);\n                        const code = json.substr(i + 2, 4);\n                        switch (code) {\n                            case '0000':\n                                str += '\\\\0';\n                                break;\n                            case '0007':\n                                str += '\\\\a';\n                                break;\n                            case '000b':\n                                str += '\\\\v';\n                                break;\n                            case '001b':\n                                str += '\\\\e';\n                                break;\n                            case '0085':\n                                str += '\\\\N';\n                                break;\n                            case '00a0':\n                                str += '\\\\_';\n                                break;\n                            case '2028':\n                                str += '\\\\L';\n                                break;\n                            case '2029':\n                                str += '\\\\P';\n                                break;\n                            default:\n                                if (code.substr(0, 2) === '00')\n                                    str += '\\\\x' + code.substr(2);\n                                else\n                                    str += json.substr(i, 6);\n                        }\n                        i += 5;\n                        start = i + 1;\n                    }\n                    break;\n                case 'n':\n                    if (implicitKey ||\n                        json[i + 2] === '\"' ||\n                        json.length < minMultiLineLength) {\n                        i += 1;\n                    }\n                    else {\n                        // folding will eat first newline\n                        str += json.slice(start, i) + '\\n\\n';\n                        while (json[i + 2] === '\\\\' &&\n                            json[i + 3] === 'n' &&\n                            json[i + 4] !== '\"') {\n                            str += '\\n';\n                            i += 2;\n                        }\n                        str += indent;\n                        // space after newline needs to be escaped to not be folded\n                        if (json[i + 2] === ' ')\n                            str += '\\\\';\n                        i += 1;\n                        start = i + 1;\n                    }\n                    break;\n                default:\n                    i += 1;\n            }\n    }\n    str = start ? str + json.slice(start) : json;\n    return implicitKey\n        ? str\n        : foldFlowLines(str, indent, FOLD_QUOTED, getFoldOptions(ctx, false));\n}\nfunction singleQuotedString(value, ctx) {\n    if (ctx.options.singleQuote === false ||\n        (ctx.implicitKey && value.includes('\\n')) ||\n        /[ \\t]\\n|\\n[ \\t]/.test(value) // single quoted string can't have leading or trailing whitespace around newline\n    )\n        return doubleQuotedString(value, ctx);\n    const indent = ctx.indent || (containsDocumentMarker(value) ? '  ' : '');\n    const res = \"'\" + value.replace(/'/g, \"''\").replace(/\\n+/g, `$&\\n${indent}`) + \"'\";\n    return ctx.implicitKey\n        ? res\n        : foldFlowLines(res, indent, FOLD_FLOW, getFoldOptions(ctx, false));\n}\nfunction quotedString(value, ctx) {\n    const { singleQuote } = ctx.options;\n    let qs;\n    if (singleQuote === false)\n        qs = doubleQuotedString;\n    else {\n        const hasDouble = value.includes('\"');\n        const hasSingle = value.includes(\"'\");\n        if (hasDouble && !hasSingle)\n            qs = singleQuotedString;\n        else if (hasSingle && !hasDouble)\n            qs = doubleQuotedString;\n        else\n            qs = singleQuote ? singleQuotedString : doubleQuotedString;\n    }\n    return qs(value, ctx);\n}\n// The negative lookbehind avoids a polynomial search,\n// but isn't supported yet on Safari: https://caniuse.com/js-regexp-lookbehind\nlet blockEndNewlines;\ntry {\n    blockEndNewlines = new RegExp('(^|(?<!\\n))\\n+(?!\\n|$)', 'g');\n}\ncatch {\n    blockEndNewlines = /\\n+(?!\\n|$)/g;\n}\nfunction blockString({ comment, type, value }, ctx, onComment, onChompKeep) {\n    const { blockQuote, commentString, lineWidth } = ctx.options;\n    // 1. Block can't end in whitespace unless the last line is non-empty.\n    // 2. Strings consisting of only whitespace are best rendered explicitly.\n    if (!blockQuote || /\\n[\\t ]+$/.test(value)) {\n        return quotedString(value, ctx);\n    }\n    const indent = ctx.indent ||\n        (ctx.forceBlockIndent || containsDocumentMarker(value) ? '  ' : '');\n    const literal = blockQuote === 'literal'\n        ? true\n        : blockQuote === 'folded' || type === Scalar.BLOCK_FOLDED\n            ? false\n            : type === Scalar.BLOCK_LITERAL\n                ? true\n                : !lineLengthOverLimit(value, lineWidth, indent.length);\n    if (!value)\n        return literal ? '|\\n' : '>\\n';\n    // determine chomping from whitespace at value end\n    let chomp;\n    let endStart;\n    for (endStart = value.length; endStart > 0; --endStart) {\n        const ch = value[endStart - 1];\n        if (ch !== '\\n' && ch !== '\\t' && ch !== ' ')\n            break;\n    }\n    let end = value.substring(endStart);\n    const endNlPos = end.indexOf('\\n');\n    if (endNlPos === -1) {\n        chomp = '-'; // strip\n    }\n    else if (value === end || endNlPos !== end.length - 1) {\n        chomp = '+'; // keep\n        if (onChompKeep)\n            onChompKeep();\n    }\n    else {\n        chomp = ''; // clip\n    }\n    if (end) {\n        value = value.slice(0, -end.length);\n        if (end[end.length - 1] === '\\n')\n            end = end.slice(0, -1);\n        end = end.replace(blockEndNewlines, `$&${indent}`);\n    }\n    // determine indent indicator from whitespace at value start\n    let startWithSpace = false;\n    let startEnd;\n    let startNlPos = -1;\n    for (startEnd = 0; startEnd < value.length; ++startEnd) {\n        const ch = value[startEnd];\n        if (ch === ' ')\n            startWithSpace = true;\n        else if (ch === '\\n')\n            startNlPos = startEnd;\n        else\n            break;\n    }\n    let start = value.substring(0, startNlPos < startEnd ? startNlPos + 1 : startEnd);\n    if (start) {\n        value = value.substring(start.length);\n        start = start.replace(/\\n+/g, `$&${indent}`);\n    }\n    const indentSize = indent ? '2' : '1'; // root is at -1\n    // Leading | or > is added later\n    let header = (startWithSpace ? indentSize : '') + chomp;\n    if (comment) {\n        header += ' ' + commentString(comment.replace(/ ?[\\r\\n]+/g, ' '));\n        if (onComment)\n            onComment();\n    }\n    if (!literal) {\n        const foldedValue = value\n            .replace(/\\n+/g, '\\n$&')\n            .replace(/(?:^|\\n)([\\t ].*)(?:([\\n\\t ]*)\\n(?![\\n\\t ]))?/g, '$1$2') // more-indented lines aren't folded\n            //                ^ more-ind. ^ empty     ^ capture next empty lines only at end of indent\n            .replace(/\\n+/g, `$&${indent}`);\n        let literalFallback = false;\n        const foldOptions = getFoldOptions(ctx, true);\n        if (blockQuote !== 'folded' && type !== Scalar.BLOCK_FOLDED) {\n            foldOptions.onOverflow = () => {\n                literalFallback = true;\n            };\n        }\n        const body = foldFlowLines(`${start}${foldedValue}${end}`, indent, FOLD_BLOCK, foldOptions);\n        if (!literalFallback)\n            return `>${header}\\n${indent}${body}`;\n    }\n    value = value.replace(/\\n+/g, `$&${indent}`);\n    return `|${header}\\n${indent}${start}${value}${end}`;\n}\nfunction plainString(item, ctx, onComment, onChompKeep) {\n    const { type, value } = item;\n    const { actualString, implicitKey, indent, indentStep, inFlow } = ctx;\n    if ((implicitKey && value.includes('\\n')) ||\n        (inFlow && /[[\\]{},]/.test(value))) {\n        return quotedString(value, ctx);\n    }\n    if (/^[\\n\\t ,[\\]{}#&*!|>'\"%@`]|^[?-]$|^[?-][ \\t]|[\\n:][ \\t]|[ \\t]\\n|[\\n\\t ]#|[\\n\\t :]$/.test(value)) {\n        // not allowed:\n        // - '-' or '?'\n        // - start with an indicator character (except [?:-]) or /[?-] /\n        // - '\\n ', ': ' or ' \\n' anywhere\n        // - '#' not preceded by a non-space char\n        // - end with ' ' or ':'\n        return implicitKey || inFlow || !value.includes('\\n')\n            ? quotedString(value, ctx)\n            : blockString(item, ctx, onComment, onChompKeep);\n    }\n    if (!implicitKey &&\n        !inFlow &&\n        type !== Scalar.PLAIN &&\n        value.includes('\\n')) {\n        // Where allowed & type not set explicitly, prefer block style for multiline strings\n        return blockString(item, ctx, onComment, onChompKeep);\n    }\n    if (containsDocumentMarker(value)) {\n        if (indent === '') {\n            ctx.forceBlockIndent = true;\n            return blockString(item, ctx, onComment, onChompKeep);\n        }\n        else if (implicitKey && indent === indentStep) {\n            return quotedString(value, ctx);\n        }\n    }\n    const str = value.replace(/\\n+/g, `$&\\n${indent}`);\n    // Verify that output will be parsed as a string, as e.g. plain numbers and\n    // booleans get parsed with those types in v1.2 (e.g. '42', 'true' & '0.9e-3'),\n    // and others in v1.1.\n    if (actualString) {\n        const test = (tag) => tag.default && tag.tag !== 'tag:yaml.org,2002:str' && tag.test?.test(str);\n        const { compat, tags } = ctx.doc.schema;\n        if (tags.some(test) || compat?.some(test))\n            return quotedString(value, ctx);\n    }\n    return implicitKey\n        ? str\n        : foldFlowLines(str, indent, FOLD_FLOW, getFoldOptions(ctx, false));\n}\nfunction stringifyString(item, ctx, onComment, onChompKeep) {\n    const { implicitKey, inFlow } = ctx;\n    const ss = typeof item.value === 'string'\n        ? item\n        : Object.assign({}, item, { value: String(item.value) });\n    let { type } = item;\n    if (type !== Scalar.QUOTE_DOUBLE) {\n        // force double quotes on control characters & unpaired surrogates\n        if (/[\\x00-\\x08\\x0b-\\x1f\\x7f-\\x9f\\u{D800}-\\u{DFFF}]/u.test(ss.value))\n            type = Scalar.QUOTE_DOUBLE;\n    }\n    const _stringify = (_type) => {\n        switch (_type) {\n            case Scalar.BLOCK_FOLDED:\n            case Scalar.BLOCK_LITERAL:\n                return implicitKey || inFlow\n                    ? quotedString(ss.value, ctx) // blocks are not valid inside flow containers\n                    : blockString(ss, ctx, onComment, onChompKeep);\n            case Scalar.QUOTE_DOUBLE:\n                return doubleQuotedString(ss.value, ctx);\n            case Scalar.QUOTE_SINGLE:\n                return singleQuotedString(ss.value, ctx);\n            case Scalar.PLAIN:\n                return plainString(ss, ctx, onComment, onChompKeep);\n            default:\n                return null;\n        }\n    };\n    let res = _stringify(type);\n    if (res === null) {\n        const { defaultKeyType, defaultStringType } = ctx.options;\n        const t = (implicitKey && defaultKeyType) || defaultStringType;\n        res = _stringify(t);\n        if (res === null)\n            throw new Error(`Unsupported default string type ${t}`);\n    }\n    return res;\n}\n\nexport { stringifyString };\n","import { anchorIsValid } from '../doc/anchors.js';\nimport { isPair, isAlias, isNode, isScalar, isCollection } from '../nodes/identity.js';\nimport { stringifyComment } from './stringifyComment.js';\nimport { stringifyString } from './stringifyString.js';\n\nfunction createStringifyContext(doc, options) {\n    const opt = Object.assign({\n        blockQuote: true,\n        commentString: stringifyComment,\n        defaultKeyType: null,\n        defaultStringType: 'PLAIN',\n        directives: null,\n        doubleQuotedAsJSON: false,\n        doubleQuotedMinMultiLineLength: 40,\n        falseStr: 'false',\n        flowCollectionPadding: true,\n        indentSeq: true,\n        lineWidth: 80,\n        minContentWidth: 20,\n        nullStr: 'null',\n        simpleKeys: false,\n        singleQuote: null,\n        trueStr: 'true',\n        verifyAliasOrder: true\n    }, doc.schema.toStringOptions, options);\n    let inFlow;\n    switch (opt.collectionStyle) {\n        case 'block':\n            inFlow = false;\n            break;\n        case 'flow':\n            inFlow = true;\n            break;\n        default:\n            inFlow = null;\n    }\n    return {\n        anchors: new Set(),\n        doc,\n        flowCollectionPadding: opt.flowCollectionPadding ? ' ' : '',\n        indent: '',\n        indentStep: typeof opt.indent === 'number' ? ' '.repeat(opt.indent) : '  ',\n        inFlow,\n        options: opt\n    };\n}\nfunction getTagObject(tags, item) {\n    if (item.tag) {\n        const match = tags.filter(t => t.tag === item.tag);\n        if (match.length > 0)\n            return match.find(t => t.format === item.format) ?? match[0];\n    }\n    let tagObj = undefined;\n    let obj;\n    if (isScalar(item)) {\n        obj = item.value;\n        let match = tags.filter(t => t.identify?.(obj));\n        if (match.length > 1) {\n            const testMatch = match.filter(t => t.test);\n            if (testMatch.length > 0)\n                match = testMatch;\n        }\n        tagObj =\n            match.find(t => t.format === item.format) ?? match.find(t => !t.format);\n    }\n    else {\n        obj = item;\n        tagObj = tags.find(t => t.nodeClass && obj instanceof t.nodeClass);\n    }\n    if (!tagObj) {\n        const name = obj?.constructor?.name ?? (obj === null ? 'null' : typeof obj);\n        throw new Error(`Tag not resolved for ${name} value`);\n    }\n    return tagObj;\n}\n// needs to be called before value stringifier to allow for circular anchor refs\nfunction stringifyProps(node, tagObj, { anchors, doc }) {\n    if (!doc.directives)\n        return '';\n    const props = [];\n    const anchor = (isScalar(node) || isCollection(node)) && node.anchor;\n    if (anchor && anchorIsValid(anchor)) {\n        anchors.add(anchor);\n        props.push(`&${anchor}`);\n    }\n    const tag = node.tag ?? (tagObj.default ? null : tagObj.tag);\n    if (tag)\n        props.push(doc.directives.tagString(tag));\n    return props.join(' ');\n}\nfunction stringify(item, ctx, onComment, onChompKeep) {\n    if (isPair(item))\n        return item.toString(ctx, onComment, onChompKeep);\n    if (isAlias(item)) {\n        if (ctx.doc.directives)\n            return item.toString(ctx);\n        if (ctx.resolvedAliases?.has(item)) {\n            throw new TypeError(`Cannot stringify circular structure without alias nodes`);\n        }\n        else {\n            if (ctx.resolvedAliases)\n                ctx.resolvedAliases.add(item);\n            else\n                ctx.resolvedAliases = new Set([item]);\n            item = item.resolve(ctx.doc);\n        }\n    }\n    let tagObj = undefined;\n    const node = isNode(item)\n        ? item\n        : ctx.doc.createNode(item, { onTagObj: o => (tagObj = o) });\n    tagObj ?? (tagObj = getTagObject(ctx.doc.schema.tags, node));\n    const props = stringifyProps(node, tagObj, ctx);\n    if (props.length > 0)\n        ctx.indentAtStart = (ctx.indentAtStart ?? 0) + props.length + 1;\n    const str = typeof tagObj.stringify === 'function'\n        ? tagObj.stringify(node, ctx, onComment, onChompKeep)\n        : isScalar(node)\n            ? stringifyString(node, ctx, onComment, onChompKeep)\n            : node.toString(ctx, onComment, onChompKeep);\n    if (!props)\n        return str;\n    return isScalar(node) || str[0] === '{' || str[0] === '['\n        ? `${props} ${str}`\n        : `${props}\\n${ctx.indent}${str}`;\n}\n\nexport { createStringifyContext, stringify };\n","import { isScalar, isAlias, isSeq, isMap } from '../../nodes/identity.js';\nimport { Scalar } from '../../nodes/Scalar.js';\n\n// If the value associated with a merge key is a single mapping node, each of\n// its key/value pairs is inserted into the current mapping, unless the key\n// already exists in it. If the value associated with the merge key is a\n// sequence, then this sequence is expected to contain mapping nodes and each\n// of these nodes is merged in turn according to its order in the sequence.\n// Keys in mapping nodes earlier in the sequence override keys specified in\n// later mapping nodes. -- http://yaml.org/type/merge.html\nconst MERGE_KEY = '<<';\nconst merge = {\n    identify: value => value === MERGE_KEY ||\n        (typeof value === 'symbol' && value.description === MERGE_KEY),\n    default: 'key',\n    tag: 'tag:yaml.org,2002:merge',\n    test: /^<<$/,\n    resolve: () => Object.assign(new Scalar(Symbol(MERGE_KEY)), {\n        addToJSMap: addMergeToJSMap\n    }),\n    stringify: () => MERGE_KEY\n};\nconst isMergeKey = (ctx, key) => (merge.identify(key) ||\n    (isScalar(key) &&\n        (!key.type || key.type === Scalar.PLAIN) &&\n        merge.identify(key.value))) &&\n    ctx?.doc.schema.tags.some(tag => tag.tag === merge.tag && tag.default);\nfunction addMergeToJSMap(ctx, map, value) {\n    value = ctx && isAlias(value) ? value.resolve(ctx.doc) : value;\n    if (isSeq(value))\n        for (const it of value.items)\n            mergeValue(ctx, map, it);\n    else if (Array.isArray(value))\n        for (const it of value)\n            mergeValue(ctx, map, it);\n    else\n        mergeValue(ctx, map, value);\n}\nfunction mergeValue(ctx, map, value) {\n    const source = ctx && isAlias(value) ? value.resolve(ctx.doc) : value;\n    if (!isMap(source))\n        throw new Error('Merge sources must be maps or map aliases');\n    const srcMap = source.toJSON(null, ctx, Map);\n    for (const [key, value] of srcMap) {\n        if (map instanceof Map) {\n            if (!map.has(key))\n                map.set(key, value);\n        }\n        else if (map instanceof Set) {\n            map.add(key);\n        }\n        else if (!Object.prototype.hasOwnProperty.call(map, key)) {\n            Object.defineProperty(map, key, {\n                value,\n                writable: true,\n                enumerable: true,\n                configurable: true\n            });\n        }\n    }\n    return map;\n}\n\nexport { addMergeToJSMap, isMergeKey, merge };\n","import { warn } from '../log.js';\nimport { isMergeKey, addMergeToJSMap } from '../schema/yaml-1.1/merge.js';\nimport { createStringifyContext } from '../stringify/stringify.js';\nimport { isNode } from './identity.js';\nimport { toJS } from './toJS.js';\n\nfunction addPairToJSMap(ctx, map, { key, value }) {\n    if (isNode(key) && key.addToJSMap)\n        key.addToJSMap(ctx, map, value);\n    // TODO: Should drop this special case for bare << handling\n    else if (isMergeKey(ctx, key))\n        addMergeToJSMap(ctx, map, value);\n    else {\n        const jsKey = toJS(key, '', ctx);\n        if (map instanceof Map) {\n            map.set(jsKey, toJS(value, jsKey, ctx));\n        }\n        else if (map instanceof Set) {\n            map.add(jsKey);\n        }\n        else {\n            const stringKey = stringifyKey(key, jsKey, ctx);\n            const jsValue = toJS(value, stringKey, ctx);\n            if (stringKey in map)\n                Object.defineProperty(map, stringKey, {\n                    value: jsValue,\n                    writable: true,\n                    enumerable: true,\n                    configurable: true\n                });\n            else\n                map[stringKey] = jsValue;\n        }\n    }\n    return map;\n}\nfunction stringifyKey(key, jsKey, ctx) {\n    if (jsKey === null)\n        return '';\n    // eslint-disable-next-line @typescript-eslint/no-base-to-string\n    if (typeof jsKey !== 'object')\n        return String(jsKey);\n    if (isNode(key) && ctx?.doc) {\n        const strCtx = createStringifyContext(ctx.doc, {});\n        strCtx.anchors = new Set();\n        for (const node of ctx.anchors.keys())\n            strCtx.anchors.add(node.anchor);\n        strCtx.inFlow = true;\n        strCtx.inStringifyKey = true;\n        const strKey = key.toString(strCtx);\n        if (!ctx.mapKeyWarned) {\n            let jsonStr = JSON.stringify(strKey);\n            if (jsonStr.length > 40)\n                jsonStr = jsonStr.substring(0, 36) + '...\"';\n            warn(ctx.doc.options.logLevel, `Keys with collection values will be stringified due to JS Object restrictions: ${jsonStr}. Set mapAsMap: true to use object keys.`);\n            ctx.mapKeyWarned = true;\n        }\n        return strKey;\n    }\n    return JSON.stringify(jsKey);\n}\n\nexport { addPairToJSMap };\n","function debug(logLevel, ...messages) {\n    if (logLevel === 'debug')\n        console.log(...messages);\n}\nfunction warn(logLevel, warning) {\n    if (logLevel === 'debug' || logLevel === 'warn') {\n        console.warn(warning);\n    }\n}\n\nexport { debug, warn };\n","import { createNode } from '../doc/createNode.js';\nimport { stringifyPair } from '../stringify/stringifyPair.js';\nimport { addPairToJSMap } from './addPairToJSMap.js';\nimport { NODE_TYPE, PAIR, isNode } from './identity.js';\n\nfunction createPair(key, value, ctx) {\n    const k = createNode(key, undefined, ctx);\n    const v = createNode(value, undefined, ctx);\n    return new Pair(k, v);\n}\nclass Pair {\n    constructor(key, value = null) {\n        Object.defineProperty(this, NODE_TYPE, { value: PAIR });\n        this.key = key;\n        this.value = value;\n    }\n    clone(schema) {\n        let { key, value } = this;\n        if (isNode(key))\n            key = key.clone(schema);\n        if (isNode(value))\n            value = value.clone(schema);\n        return new Pair(key, value);\n    }\n    toJSON(_, ctx) {\n        const pair = ctx?.mapAsMap ? new Map() : {};\n        return addPairToJSMap(ctx, pair, this);\n    }\n    toString(ctx, onComment, onChompKeep) {\n        return ctx?.doc\n            ? stringifyPair(this, ctx, onComment, onChompKeep)\n            : JSON.stringify(this);\n    }\n}\n\nexport { Pair, createPair };\n","import { isCollection, isNode, isScalar, isSeq } from '../nodes/identity.js';\nimport { Scalar } from '../nodes/Scalar.js';\nimport { stringify } from './stringify.js';\nimport { lineComment, indentComment } from './stringifyComment.js';\n\nfunction stringifyPair({ key, value }, ctx, onComment, onChompKeep) {\n    const { allNullValues, doc, indent, indentStep, options: { commentString, indentSeq, simpleKeys } } = ctx;\n    let keyComment = (isNode(key) && key.comment) || null;\n    if (simpleKeys) {\n        if (keyComment) {\n            throw new Error('With simple keys, key nodes cannot have comments');\n        }\n        if (isCollection(key) || (!isNode(key) && typeof key === 'object')) {\n            const msg = 'With simple keys, collection cannot be used as a key value';\n            throw new Error(msg);\n        }\n    }\n    let explicitKey = !simpleKeys &&\n        (!key ||\n            (keyComment && value == null && !ctx.inFlow) ||\n            isCollection(key) ||\n            (isScalar(key)\n                ? key.type === Scalar.BLOCK_FOLDED || key.type === Scalar.BLOCK_LITERAL\n                : typeof key === 'object'));\n    ctx = Object.assign({}, ctx, {\n        allNullValues: false,\n        implicitKey: !explicitKey && (simpleKeys || !allNullValues),\n        indent: indent + indentStep\n    });\n    let keyCommentDone = false;\n    let chompKeep = false;\n    let str = stringify(key, ctx, () => (keyCommentDone = true), () => (chompKeep = true));\n    if (!explicitKey && !ctx.inFlow && str.length > 1024) {\n        if (simpleKeys)\n            throw new Error('With simple keys, single line scalar must not span more than 1024 characters');\n        explicitKey = true;\n    }\n    if (ctx.inFlow) {\n        if (allNullValues || value == null) {\n            if (keyCommentDone && onComment)\n                onComment();\n            return str === '' ? '?' : explicitKey ? `? ${str}` : str;\n        }\n    }\n    else if ((allNullValues && !simpleKeys) || (value == null && explicitKey)) {\n        str = `? ${str}`;\n        if (keyComment && !keyCommentDone) {\n            str += lineComment(str, ctx.indent, commentString(keyComment));\n        }\n        else if (chompKeep && onChompKeep)\n            onChompKeep();\n        return str;\n    }\n    if (keyCommentDone)\n        keyComment = null;\n    if (explicitKey) {\n        if (keyComment)\n            str += lineComment(str, ctx.indent, commentString(keyComment));\n        str = `? ${str}\\n${indent}:`;\n    }\n    else {\n        str = `${str}:`;\n        if (keyComment)\n            str += lineComment(str, ctx.indent, commentString(keyComment));\n    }\n    let vsb, vcb, valueComment;\n    if (isNode(value)) {\n        vsb = !!value.spaceBefore;\n        vcb = value.commentBefore;\n        valueComment = value.comment;\n    }\n    else {\n        vsb = false;\n        vcb = null;\n        valueComment = null;\n        if (value && typeof value === 'object')\n            value = doc.createNode(value);\n    }\n    ctx.implicitKey = false;\n    if (!explicitKey && !keyComment && isScalar(value))\n        ctx.indentAtStart = str.length + 1;\n    chompKeep = false;\n    if (!indentSeq &&\n        indentStep.length >= 2 &&\n        !ctx.inFlow &&\n        !explicitKey &&\n        isSeq(value) &&\n        !value.flow &&\n        !value.tag &&\n        !value.anchor) {\n        // If indentSeq === false, consider '- ' as part of indentation where possible\n        ctx.indent = ctx.indent.substring(2);\n    }\n    let valueCommentDone = false;\n    const valueStr = stringify(value, ctx, () => (valueCommentDone = true), () => (chompKeep = true));\n    let ws = ' ';\n    if (keyComment || vsb || vcb) {\n        ws = vsb ? '\\n' : '';\n        if (vcb) {\n            const cs = commentString(vcb);\n            ws += `\\n${indentComment(cs, ctx.indent)}`;\n        }\n        if (valueStr === '' && !ctx.inFlow) {\n            if (ws === '\\n' && valueComment)\n                ws = '\\n\\n';\n        }\n        else {\n            ws += `\\n${ctx.indent}`;\n        }\n    }\n    else if (!explicitKey && isCollection(value)) {\n        const vs0 = valueStr[0];\n        const nl0 = valueStr.indexOf('\\n');\n        const hasNewline = nl0 !== -1;\n        const flow = ctx.inFlow ?? value.flow ?? value.items.length === 0;\n        if (hasNewline || !flow) {\n            let hasPropsLine = false;\n            if (hasNewline && (vs0 === '&' || vs0 === '!')) {\n                let sp0 = valueStr.indexOf(' ');\n                if (vs0 === '&' &&\n                    sp0 !== -1 &&\n                    sp0 < nl0 &&\n                    valueStr[sp0 + 1] === '!') {\n                    sp0 = valueStr.indexOf(' ', sp0 + 1);\n                }\n                if (sp0 === -1 || nl0 < sp0)\n                    hasPropsLine = true;\n            }\n            if (!hasPropsLine)\n                ws = `\\n${ctx.indent}`;\n        }\n    }\n    else if (valueStr === '' || valueStr[0] === '\\n') {\n        ws = '';\n    }\n    str += ws + valueStr;\n    if (ctx.inFlow) {\n        if (valueCommentDone && onComment)\n            onComment();\n    }\n    else if (valueComment && !valueCommentDone) {\n        str += lineComment(str, ctx.indent, commentString(valueComment));\n    }\n    else if (chompKeep && onChompKeep) {\n        onChompKeep();\n    }\n    return str;\n}\n\nexport { stringifyPair };\n","import { isNode, isPair } from '../nodes/identity.js';\nimport { stringify } from './stringify.js';\nimport { lineComment, indentComment } from './stringifyComment.js';\n\nfunction stringifyCollection(collection, ctx, options) {\n    const flow = ctx.inFlow ?? collection.flow;\n    const stringify = flow ? stringifyFlowCollection : stringifyBlockCollection;\n    return stringify(collection, ctx, options);\n}\nfunction stringifyBlockCollection({ comment, items }, ctx, { blockItemPrefix, flowChars, itemIndent, onChompKeep, onComment }) {\n    const { indent, options: { commentString } } = ctx;\n    const itemCtx = Object.assign({}, ctx, { indent: itemIndent, type: null });\n    let chompKeep = false; // flag for the preceding node's status\n    const lines = [];\n    for (let i = 0; i < items.length; ++i) {\n        const item = items[i];\n        let comment = null;\n        if (isNode(item)) {\n            if (!chompKeep && item.spaceBefore)\n                lines.push('');\n            addCommentBefore(ctx, lines, item.commentBefore, chompKeep);\n            if (item.comment)\n                comment = item.comment;\n        }\n        else if (isPair(item)) {\n            const ik = isNode(item.key) ? item.key : null;\n            if (ik) {\n                if (!chompKeep && ik.spaceBefore)\n                    lines.push('');\n                addCommentBefore(ctx, lines, ik.commentBefore, chompKeep);\n            }\n        }\n        chompKeep = false;\n        let str = stringify(item, itemCtx, () => (comment = null), () => (chompKeep = true));\n        if (comment)\n            str += lineComment(str, itemIndent, commentString(comment));\n        if (chompKeep && comment)\n            chompKeep = false;\n        lines.push(blockItemPrefix + str);\n    }\n    let str;\n    if (lines.length === 0) {\n        str = flowChars.start + flowChars.end;\n    }\n    else {\n        str = lines[0];\n        for (let i = 1; i < lines.length; ++i) {\n            const line = lines[i];\n            str += line ? `\\n${indent}${line}` : '\\n';\n        }\n    }\n    if (comment) {\n        str += '\\n' + indentComment(commentString(comment), indent);\n        if (onComment)\n            onComment();\n    }\n    else if (chompKeep && onChompKeep)\n        onChompKeep();\n    return str;\n}\nfunction stringifyFlowCollection({ items }, ctx, { flowChars, itemIndent }) {\n    const { indent, indentStep, flowCollectionPadding: fcPadding, options: { commentString } } = ctx;\n    itemIndent += indentStep;\n    const itemCtx = Object.assign({}, ctx, {\n        indent: itemIndent,\n        inFlow: true,\n        type: null\n    });\n    let reqNewline = false;\n    let linesAtValue = 0;\n    const lines = [];\n    for (let i = 0; i < items.length; ++i) {\n        const item = items[i];\n        let comment = null;\n        if (isNode(item)) {\n            if (item.spaceBefore)\n                lines.push('');\n            addCommentBefore(ctx, lines, item.commentBefore, false);\n            if (item.comment)\n                comment = item.comment;\n        }\n        else if (isPair(item)) {\n            const ik = isNode(item.key) ? item.key : null;\n            if (ik) {\n                if (ik.spaceBefore)\n                    lines.push('');\n                addCommentBefore(ctx, lines, ik.commentBefore, false);\n                if (ik.comment)\n                    reqNewline = true;\n            }\n            const iv = isNode(item.value) ? item.value : null;\n            if (iv) {\n                if (iv.comment)\n                    comment = iv.comment;\n                if (iv.commentBefore)\n                    reqNewline = true;\n            }\n            else if (item.value == null && ik?.comment) {\n                comment = ik.comment;\n            }\n        }\n        if (comment)\n            reqNewline = true;\n        let str = stringify(item, itemCtx, () => (comment = null));\n        if (i < items.length - 1)\n            str += ',';\n        if (comment)\n            str += lineComment(str, itemIndent, commentString(comment));\n        if (!reqNewline && (lines.length > linesAtValue || str.includes('\\n')))\n            reqNewline = true;\n        lines.push(str);\n        linesAtValue = lines.length;\n    }\n    const { start, end } = flowChars;\n    if (lines.length === 0) {\n        return start + end;\n    }\n    else {\n        if (!reqNewline) {\n            const len = lines.reduce((sum, line) => sum + line.length + 2, 2);\n            reqNewline = ctx.options.lineWidth > 0 && len > ctx.options.lineWidth;\n        }\n        if (reqNewline) {\n            let str = start;\n            for (const line of lines)\n                str += line ? `\\n${indentStep}${indent}${line}` : '\\n';\n            return `${str}\\n${indent}${end}`;\n        }\n        else {\n            return `${start}${fcPadding}${lines.join(' ')}${fcPadding}${end}`;\n        }\n    }\n}\nfunction addCommentBefore({ indent, options: { commentString } }, lines, comment, chompKeep) {\n    if (comment && chompKeep)\n        comment = comment.replace(/^\\n+/, '');\n    if (comment) {\n        const ic = indentComment(commentString(comment), indent);\n        lines.push(ic.trimStart()); // Avoid double indent on first line\n    }\n}\n\nexport { stringifyCollection };\n","import { stringifyCollection } from '../stringify/stringifyCollection.js';\nimport { addPairToJSMap } from './addPairToJSMap.js';\nimport { Collection } from './Collection.js';\nimport { MAP, isPair, isScalar } from './identity.js';\nimport { Pair, createPair } from './Pair.js';\nimport { isScalarValue } from './Scalar.js';\n\nfunction findPair(items, key) {\n    const k = isScalar(key) ? key.value : key;\n    for (const it of items) {\n        if (isPair(it)) {\n            if (it.key === key || it.key === k)\n                return it;\n            if (isScalar(it.key) && it.key.value === k)\n                return it;\n        }\n    }\n    return undefined;\n}\nclass YAMLMap extends Collection {\n    static get tagName() {\n        return 'tag:yaml.org,2002:map';\n    }\n    constructor(schema) {\n        super(MAP, schema);\n        this.items = [];\n    }\n    /**\n     * A generic collection parsing method that can be extended\n     * to other node classes that inherit from YAMLMap\n     */\n    static from(schema, obj, ctx) {\n        const { keepUndefined, replacer } = ctx;\n        const map = new this(schema);\n        const add = (key, value) => {\n            if (typeof replacer === 'function')\n                value = replacer.call(obj, key, value);\n            else if (Array.isArray(replacer) && !replacer.includes(key))\n                return;\n            if (value !== undefined || keepUndefined)\n                map.items.push(createPair(key, value, ctx));\n        };\n        if (obj instanceof Map) {\n            for (const [key, value] of obj)\n                add(key, value);\n        }\n        else if (obj && typeof obj === 'object') {\n            for (const key of Object.keys(obj))\n                add(key, obj[key]);\n        }\n        if (typeof schema.sortMapEntries === 'function') {\n            map.items.sort(schema.sortMapEntries);\n        }\n        return map;\n    }\n    /**\n     * Adds a value to the collection.\n     *\n     * @param overwrite - If not set `true`, using a key that is already in the\n     *   collection will throw. Otherwise, overwrites the previous value.\n     */\n    add(pair, overwrite) {\n        let _pair;\n        if (isPair(pair))\n            _pair = pair;\n        else if (!pair || typeof pair !== 'object' || !('key' in pair)) {\n            // In TypeScript, this never happens.\n            _pair = new Pair(pair, pair?.value);\n        }\n        else\n            _pair = new Pair(pair.key, pair.value);\n        const prev = findPair(this.items, _pair.key);\n        const sortEntries = this.schema?.sortMapEntries;\n        if (prev) {\n            if (!overwrite)\n                throw new Error(`Key ${_pair.key} already set`);\n            // For scalars, keep the old node & its comments and anchors\n            if (isScalar(prev.value) && isScalarValue(_pair.value))\n                prev.value.value = _pair.value;\n            else\n                prev.value = _pair.value;\n        }\n        else if (sortEntries) {\n            const i = this.items.findIndex(item => sortEntries(_pair, item) < 0);\n            if (i === -1)\n                this.items.push(_pair);\n            else\n                this.items.splice(i, 0, _pair);\n        }\n        else {\n            this.items.push(_pair);\n        }\n    }\n    delete(key) {\n        const it = findPair(this.items, key);\n        if (!it)\n            return false;\n        const del = this.items.splice(this.items.indexOf(it), 1);\n        return del.length > 0;\n    }\n    get(key, keepScalar) {\n        const it = findPair(this.items, key);\n        const node = it?.value;\n        return (!keepScalar && isScalar(node) ? node.value : node) ?? undefined;\n    }\n    has(key) {\n        return !!findPair(this.items, key);\n    }\n    set(key, value) {\n        this.add(new Pair(key, value), true);\n    }\n    /**\n     * @param ctx - Conversion context, originally set in Document#toJS()\n     * @param {Class} Type - If set, forces the returned collection type\n     * @returns Instance of Type, Map, or Object\n     */\n    toJSON(_, ctx, Type) {\n        const map = Type ? new Type() : ctx?.mapAsMap ? new Map() : {};\n        if (ctx?.onCreate)\n            ctx.onCreate(map);\n        for (const item of this.items)\n            addPairToJSMap(ctx, map, item);\n        return map;\n    }\n    toString(ctx, onComment, onChompKeep) {\n        if (!ctx)\n            return JSON.stringify(this);\n        for (const item of this.items) {\n            if (!isPair(item))\n                throw new Error(`Map items must all be pairs; found ${JSON.stringify(item)} instead`);\n        }\n        if (!ctx.allNullValues && this.hasAllNullValues(false))\n            ctx = Object.assign({}, ctx, { allNullValues: true });\n        return stringifyCollection(this, ctx, {\n            blockItemPrefix: '',\n            flowChars: { start: '{', end: '}' },\n            itemIndent: ctx.indent || '',\n            onChompKeep,\n            onComment\n        });\n    }\n}\n\nexport { YAMLMap, findPair };\n","import { isMap } from '../../nodes/identity.js';\nimport { YAMLMap } from '../../nodes/YAMLMap.js';\n\nconst map = {\n    collection: 'map',\n    default: true,\n    nodeClass: YAMLMap,\n    tag: 'tag:yaml.org,2002:map',\n    resolve(map, onError) {\n        if (!isMap(map))\n            onError('Expected a mapping for this tag');\n        return map;\n    },\n    createNode: (schema, obj, ctx) => YAMLMap.from(schema, obj, ctx)\n};\n\nexport { map };\n","import { createNode } from '../doc/createNode.js';\nimport { stringifyCollection } from '../stringify/stringifyCollection.js';\nimport { Collection } from './Collection.js';\nimport { SEQ, isScalar } from './identity.js';\nimport { isScalarValue } from './Scalar.js';\nimport { toJS } from './toJS.js';\n\nclass YAMLSeq extends Collection {\n    static get tagName() {\n        return 'tag:yaml.org,2002:seq';\n    }\n    constructor(schema) {\n        super(SEQ, schema);\n        this.items = [];\n    }\n    add(value) {\n        this.items.push(value);\n    }\n    /**\n     * Removes a value from the collection.\n     *\n     * `key` must contain a representation of an integer for this to succeed.\n     * It may be wrapped in a `Scalar`.\n     *\n     * @returns `true` if the item was found and removed.\n     */\n    delete(key) {\n        const idx = asItemIndex(key);\n        if (typeof idx !== 'number')\n            return false;\n        const del = this.items.splice(idx, 1);\n        return del.length > 0;\n    }\n    get(key, keepScalar) {\n        const idx = asItemIndex(key);\n        if (typeof idx !== 'number')\n            return undefined;\n        const it = this.items[idx];\n        return !keepScalar && isScalar(it) ? it.value : it;\n    }\n    /**\n     * Checks if the collection includes a value with the key `key`.\n     *\n     * `key` must contain a representation of an integer for this to succeed.\n     * It may be wrapped in a `Scalar`.\n     */\n    has(key) {\n        const idx = asItemIndex(key);\n        return typeof idx === 'number' && idx < this.items.length;\n    }\n    /**\n     * Sets a value in this collection. For `!!set`, `value` needs to be a\n     * boolean to add/remove the item from the set.\n     *\n     * If `key` does not contain a representation of an integer, this will throw.\n     * It may be wrapped in a `Scalar`.\n     */\n    set(key, value) {\n        const idx = asItemIndex(key);\n        if (typeof idx !== 'number')\n            throw new Error(`Expected a valid index, not ${key}.`);\n        const prev = this.items[idx];\n        if (isScalar(prev) && isScalarValue(value))\n            prev.value = value;\n        else\n            this.items[idx] = value;\n    }\n    toJSON(_, ctx) {\n        const seq = [];\n        if (ctx?.onCreate)\n            ctx.onCreate(seq);\n        let i = 0;\n        for (const item of this.items)\n            seq.push(toJS(item, String(i++), ctx));\n        return seq;\n    }\n    toString(ctx, onComment, onChompKeep) {\n        if (!ctx)\n            return JSON.stringify(this);\n        return stringifyCollection(this, ctx, {\n            blockItemPrefix: '- ',\n            flowChars: { start: '[', end: ']' },\n            itemIndent: (ctx.indent || '') + '  ',\n            onChompKeep,\n            onComment\n        });\n    }\n    static from(schema, obj, ctx) {\n        const { replacer } = ctx;\n        const seq = new this(schema);\n        if (obj && Symbol.iterator in Object(obj)) {\n            let i = 0;\n            for (let it of obj) {\n                if (typeof replacer === 'function') {\n                    const key = obj instanceof Set ? it : String(i++);\n                    it = replacer.call(obj, key, it);\n                }\n                seq.items.push(createNode(it, undefined, ctx));\n            }\n        }\n        return seq;\n    }\n}\nfunction asItemIndex(key) {\n    let idx = isScalar(key) ? key.value : key;\n    if (idx && typeof idx === 'string')\n        idx = Number(idx);\n    return typeof idx === 'number' && Number.isInteger(idx) && idx >= 0\n        ? idx\n        : null;\n}\n\nexport { YAMLSeq };\n","import { isSeq } from '../../nodes/identity.js';\nimport { YAMLSeq } from '../../nodes/YAMLSeq.js';\n\nconst seq = {\n    collection: 'seq',\n    default: true,\n    nodeClass: YAMLSeq,\n    tag: 'tag:yaml.org,2002:seq',\n    resolve(seq, onError) {\n        if (!isSeq(seq))\n            onError('Expected a sequence for this tag');\n        return seq;\n    },\n    createNode: (schema, obj, ctx) => YAMLSeq.from(schema, obj, ctx)\n};\n\nexport { seq };\n","import { stringifyString } from '../../stringify/stringifyString.js';\n\nconst string = {\n    identify: value => typeof value === 'string',\n    default: true,\n    tag: 'tag:yaml.org,2002:str',\n    resolve: str => str,\n    stringify(item, ctx, onComment, onChompKeep) {\n        ctx = Object.assign({ actualString: true }, ctx);\n        return stringifyString(item, ctx, onComment, onChompKeep);\n    }\n};\n\nexport { string };\n","import { Scalar } from '../../nodes/Scalar.js';\n\nconst nullTag = {\n    identify: value => value == null,\n    createNode: () => new Scalar(null),\n    default: true,\n    tag: 'tag:yaml.org,2002:null',\n    test: /^(?:~|[Nn]ull|NULL)?$/,\n    resolve: () => new Scalar(null),\n    stringify: ({ source }, ctx) => typeof source === 'string' && nullTag.test.test(source)\n        ? source\n        : ctx.options.nullStr\n};\n\nexport { nullTag };\n","import { Scalar } from '../../nodes/Scalar.js';\n\nconst boolTag = {\n    identify: value => typeof value === 'boolean',\n    default: true,\n    tag: 'tag:yaml.org,2002:bool',\n    test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/,\n    resolve: str => new Scalar(str[0] === 't' || str[0] === 'T'),\n    stringify({ source, value }, ctx) {\n        if (source && boolTag.test.test(source)) {\n            const sv = source[0] === 't' || source[0] === 'T';\n            if (value === sv)\n                return source;\n        }\n        return value ? ctx.options.trueStr : ctx.options.falseStr;\n    }\n};\n\nexport { boolTag };\n","function stringifyNumber({ format, minFractionDigits, tag, value }) {\n    if (typeof value === 'bigint')\n        return String(value);\n    const num = typeof value === 'number' ? value : Number(value);\n    if (!isFinite(num))\n        return isNaN(num) ? '.nan' : num < 0 ? '-.inf' : '.inf';\n    let n = Object.is(value, -0) ? '-0' : JSON.stringify(value);\n    if (!format &&\n        minFractionDigits &&\n        (!tag || tag === 'tag:yaml.org,2002:float') &&\n        /^\\d/.test(n)) {\n        let i = n.indexOf('.');\n        if (i < 0) {\n            i = n.length;\n            n += '.';\n        }\n        let d = minFractionDigits - (n.length - i - 1);\n        while (d-- > 0)\n            n += '0';\n    }\n    return n;\n}\n\nexport { stringifyNumber };\n","import { Scalar } from '../../nodes/Scalar.js';\nimport { stringifyNumber } from '../../stringify/stringifyNumber.js';\n\nconst floatNaN = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    test: /^(?:[-+]?\\.(?:inf|Inf|INF)|\\.nan|\\.NaN|\\.NAN)$/,\n    resolve: str => str.slice(-3).toLowerCase() === 'nan'\n        ? NaN\n        : str[0] === '-'\n            ? Number.NEGATIVE_INFINITY\n            : Number.POSITIVE_INFINITY,\n    stringify: stringifyNumber\n};\nconst floatExp = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    format: 'EXP',\n    test: /^[-+]?(?:\\.[0-9]+|[0-9]+(?:\\.[0-9]*)?)[eE][-+]?[0-9]+$/,\n    resolve: str => parseFloat(str),\n    stringify(node) {\n        const num = Number(node.value);\n        return isFinite(num) ? num.toExponential() : stringifyNumber(node);\n    }\n};\nconst float = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    test: /^[-+]?(?:\\.[0-9]+|[0-9]+\\.[0-9]*)$/,\n    resolve(str) {\n        const node = new Scalar(parseFloat(str));\n        const dot = str.indexOf('.');\n        if (dot !== -1 && str[str.length - 1] === '0')\n            node.minFractionDigits = str.length - dot - 1;\n        return node;\n    },\n    stringify: stringifyNumber\n};\n\nexport { float, floatExp, floatNaN };\n","import { stringifyNumber } from '../../stringify/stringifyNumber.js';\n\nconst intIdentify = (value) => typeof value === 'bigint' || Number.isInteger(value);\nconst intResolve = (str, offset, radix, { intAsBigInt }) => (intAsBigInt ? BigInt(str) : parseInt(str.substring(offset), radix));\nfunction intStringify(node, radix, prefix) {\n    const { value } = node;\n    if (intIdentify(value) && value >= 0)\n        return prefix + value.toString(radix);\n    return stringifyNumber(node);\n}\nconst intOct = {\n    identify: value => intIdentify(value) && value >= 0,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    format: 'OCT',\n    test: /^0o[0-7]+$/,\n    resolve: (str, _onError, opt) => intResolve(str, 2, 8, opt),\n    stringify: node => intStringify(node, 8, '0o')\n};\nconst int = {\n    identify: intIdentify,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    test: /^[-+]?[0-9]+$/,\n    resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt),\n    stringify: stringifyNumber\n};\nconst intHex = {\n    identify: value => intIdentify(value) && value >= 0,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    format: 'HEX',\n    test: /^0x[0-9a-fA-F]+$/,\n    resolve: (str, _onError, opt) => intResolve(str, 2, 16, opt),\n    stringify: node => intStringify(node, 16, '0x')\n};\n\nexport { int, intHex, intOct };\n","import { map } from '../common/map.js';\nimport { nullTag } from '../common/null.js';\nimport { seq } from '../common/seq.js';\nimport { string } from '../common/string.js';\nimport { boolTag } from './bool.js';\nimport { floatNaN, floatExp, float } from './float.js';\nimport { intOct, int, intHex } from './int.js';\n\nconst schema = [\n    map,\n    seq,\n    string,\n    nullTag,\n    boolTag,\n    intOct,\n    int,\n    intHex,\n    floatNaN,\n    floatExp,\n    float\n];\n\nexport { schema };\n","import { Scalar } from '../../nodes/Scalar.js';\nimport { map } from '../common/map.js';\nimport { seq } from '../common/seq.js';\n\nfunction intIdentify(value) {\n    return typeof value === 'bigint' || Number.isInteger(value);\n}\nconst stringifyJSON = ({ value }) => JSON.stringify(value);\nconst jsonScalars = [\n    {\n        identify: value => typeof value === 'string',\n        default: true,\n        tag: 'tag:yaml.org,2002:str',\n        resolve: str => str,\n        stringify: stringifyJSON\n    },\n    {\n        identify: value => value == null,\n        createNode: () => new Scalar(null),\n        default: true,\n        tag: 'tag:yaml.org,2002:null',\n        test: /^null$/,\n        resolve: () => null,\n        stringify: stringifyJSON\n    },\n    {\n        identify: value => typeof value === 'boolean',\n        default: true,\n        tag: 'tag:yaml.org,2002:bool',\n        test: /^true$|^false$/,\n        resolve: str => str === 'true',\n        stringify: stringifyJSON\n    },\n    {\n        identify: intIdentify,\n        default: true,\n        tag: 'tag:yaml.org,2002:int',\n        test: /^-?(?:0|[1-9][0-9]*)$/,\n        resolve: (str, _onError, { intAsBigInt }) => intAsBigInt ? BigInt(str) : parseInt(str, 10),\n        stringify: ({ value }) => intIdentify(value) ? value.toString() : JSON.stringify(value)\n    },\n    {\n        identify: value => typeof value === 'number',\n        default: true,\n        tag: 'tag:yaml.org,2002:float',\n        test: /^-?(?:0|[1-9][0-9]*)(?:\\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$/,\n        resolve: str => parseFloat(str),\n        stringify: stringifyJSON\n    }\n];\nconst jsonError = {\n    default: true,\n    tag: '',\n    test: /^/,\n    resolve(str, onError) {\n        onError(`Unresolved plain scalar ${JSON.stringify(str)}`);\n        return str;\n    }\n};\nconst schema = [map, seq].concat(jsonScalars, jsonError);\n\nexport { schema };\n","import { Scalar } from '../../nodes/Scalar.js';\nimport { stringifyString } from '../../stringify/stringifyString.js';\n\nconst binary = {\n    identify: value => value instanceof Uint8Array, // Buffer inherits from Uint8Array\n    default: false,\n    tag: 'tag:yaml.org,2002:binary',\n    /**\n     * Returns a Buffer in node and an Uint8Array in browsers\n     *\n     * To use the resulting buffer as an image, you'll want to do something like:\n     *\n     *   const blob = new Blob([buffer], { type: 'image/jpeg' })\n     *   document.querySelector('#photo').src = URL.createObjectURL(blob)\n     */\n    resolve(src, onError) {\n        if (typeof atob === 'function') {\n            // On IE 11, atob() can't handle newlines\n            const str = atob(src.replace(/[\\n\\r]/g, ''));\n            const buffer = new Uint8Array(str.length);\n            for (let i = 0; i < str.length; ++i)\n                buffer[i] = str.charCodeAt(i);\n            return buffer;\n        }\n        else {\n            onError('This environment does not support reading binary tags; either Buffer or atob is required');\n            return src;\n        }\n    },\n    stringify({ comment, type, value }, ctx, onComment, onChompKeep) {\n        if (!value)\n            return '';\n        const buf = value; // checked earlier by binary.identify()\n        let str;\n        if (typeof btoa === 'function') {\n            let s = '';\n            for (let i = 0; i < buf.length; ++i)\n                s += String.fromCharCode(buf[i]);\n            str = btoa(s);\n        }\n        else {\n            throw new Error('This environment does not support writing binary tags; either Buffer or btoa is required');\n        }\n        type ?? (type = Scalar.BLOCK_LITERAL);\n        if (type !== Scalar.QUOTE_DOUBLE) {\n            const lineWidth = Math.max(ctx.options.lineWidth - ctx.indent.length, ctx.options.minContentWidth);\n            const n = Math.ceil(str.length / lineWidth);\n            const lines = new Array(n);\n            for (let i = 0, o = 0; i < n; ++i, o += lineWidth) {\n                lines[i] = str.substr(o, lineWidth);\n            }\n            str = lines.join(type === Scalar.BLOCK_LITERAL ? '\\n' : ' ');\n        }\n        return stringifyString({ comment, type, value: str }, ctx, onComment, onChompKeep);\n    }\n};\n\nexport { binary };\n","import { isSeq, isPair, isMap } from '../../nodes/identity.js';\nimport { createPair, Pair } from '../../nodes/Pair.js';\nimport { Scalar } from '../../nodes/Scalar.js';\nimport { YAMLSeq } from '../../nodes/YAMLSeq.js';\n\nfunction resolvePairs(seq, onError) {\n    if (isSeq(seq)) {\n        for (let i = 0; i < seq.items.length; ++i) {\n            let item = seq.items[i];\n            if (isPair(item))\n                continue;\n            else if (isMap(item)) {\n                if (item.items.length > 1)\n                    onError('Each pair must have its own sequence indicator');\n                const pair = item.items[0] || new Pair(new Scalar(null));\n                if (item.commentBefore)\n                    pair.key.commentBefore = pair.key.commentBefore\n                        ? `${item.commentBefore}\\n${pair.key.commentBefore}`\n                        : item.commentBefore;\n                if (item.comment) {\n                    const cn = pair.value ?? pair.key;\n                    cn.comment = cn.comment\n                        ? `${item.comment}\\n${cn.comment}`\n                        : item.comment;\n                }\n                item = pair;\n            }\n            seq.items[i] = isPair(item) ? item : new Pair(item);\n        }\n    }\n    else\n        onError('Expected a sequence for this tag');\n    return seq;\n}\nfunction createPairs(schema, iterable, ctx) {\n    const { replacer } = ctx;\n    const pairs = new YAMLSeq(schema);\n    pairs.tag = 'tag:yaml.org,2002:pairs';\n    let i = 0;\n    if (iterable && Symbol.iterator in Object(iterable))\n        for (let it of iterable) {\n            if (typeof replacer === 'function')\n                it = replacer.call(iterable, String(i++), it);\n            let key, value;\n            if (Array.isArray(it)) {\n                if (it.length === 2) {\n                    key = it[0];\n                    value = it[1];\n                }\n                else\n                    throw new TypeError(`Expected [key, value] tuple: ${it}`);\n            }\n            else if (it && it instanceof Object) {\n                const keys = Object.keys(it);\n                if (keys.length === 1) {\n                    key = keys[0];\n                    value = it[key];\n                }\n                else {\n                    throw new TypeError(`Expected tuple with one key, not ${keys.length} keys`);\n                }\n            }\n            else {\n                key = it;\n            }\n            pairs.items.push(createPair(key, value, ctx));\n        }\n    return pairs;\n}\nconst pairs = {\n    collection: 'seq',\n    default: false,\n    tag: 'tag:yaml.org,2002:pairs',\n    resolve: resolvePairs,\n    createNode: createPairs\n};\n\nexport { createPairs, pairs, resolvePairs };\n","import { isScalar, isPair } from '../../nodes/identity.js';\nimport { toJS } from '../../nodes/toJS.js';\nimport { YAMLMap } from '../../nodes/YAMLMap.js';\nimport { YAMLSeq } from '../../nodes/YAMLSeq.js';\nimport { resolvePairs, createPairs } from './pairs.js';\n\nclass YAMLOMap extends YAMLSeq {\n    constructor() {\n        super();\n        this.add = YAMLMap.prototype.add.bind(this);\n        this.delete = YAMLMap.prototype.delete.bind(this);\n        this.get = YAMLMap.prototype.get.bind(this);\n        this.has = YAMLMap.prototype.has.bind(this);\n        this.set = YAMLMap.prototype.set.bind(this);\n        this.tag = YAMLOMap.tag;\n    }\n    /**\n     * If `ctx` is given, the return type is actually `Map<unknown, unknown>`,\n     * but TypeScript won't allow widening the signature of a child method.\n     */\n    toJSON(_, ctx) {\n        if (!ctx)\n            return super.toJSON(_);\n        const map = new Map();\n        if (ctx?.onCreate)\n            ctx.onCreate(map);\n        for (const pair of this.items) {\n            let key, value;\n            if (isPair(pair)) {\n                key = toJS(pair.key, '', ctx);\n                value = toJS(pair.value, key, ctx);\n            }\n            else {\n                key = toJS(pair, '', ctx);\n            }\n            if (map.has(key))\n                throw new Error('Ordered maps must not include duplicate keys');\n            map.set(key, value);\n        }\n        return map;\n    }\n    static from(schema, iterable, ctx) {\n        const pairs = createPairs(schema, iterable, ctx);\n        const omap = new this();\n        omap.items = pairs.items;\n        return omap;\n    }\n}\nYAMLOMap.tag = 'tag:yaml.org,2002:omap';\nconst omap = {\n    collection: 'seq',\n    identify: value => value instanceof Map,\n    nodeClass: YAMLOMap,\n    default: false,\n    tag: 'tag:yaml.org,2002:omap',\n    resolve(seq, onError) {\n        const pairs = resolvePairs(seq, onError);\n        const seenKeys = [];\n        for (const { key } of pairs.items) {\n            if (isScalar(key)) {\n                if (seenKeys.includes(key.value)) {\n                    onError(`Ordered maps must not include duplicate keys: ${key.value}`);\n                }\n                else {\n                    seenKeys.push(key.value);\n                }\n            }\n        }\n        return Object.assign(new YAMLOMap(), pairs);\n    },\n    createNode: (schema, iterable, ctx) => YAMLOMap.from(schema, iterable, ctx)\n};\n\nexport { YAMLOMap, omap };\n","import { Scalar } from '../../nodes/Scalar.js';\n\nfunction boolStringify({ value, source }, ctx) {\n    const boolObj = value ? trueTag : falseTag;\n    if (source && boolObj.test.test(source))\n        return source;\n    return value ? ctx.options.trueStr : ctx.options.falseStr;\n}\nconst trueTag = {\n    identify: value => value === true,\n    default: true,\n    tag: 'tag:yaml.org,2002:bool',\n    test: /^(?:Y|y|[Yy]es|YES|[Tt]rue|TRUE|[Oo]n|ON)$/,\n    resolve: () => new Scalar(true),\n    stringify: boolStringify\n};\nconst falseTag = {\n    identify: value => value === false,\n    default: true,\n    tag: 'tag:yaml.org,2002:bool',\n    test: /^(?:N|n|[Nn]o|NO|[Ff]alse|FALSE|[Oo]ff|OFF)$/,\n    resolve: () => new Scalar(false),\n    stringify: boolStringify\n};\n\nexport { falseTag, trueTag };\n","import { Scalar } from '../../nodes/Scalar.js';\nimport { stringifyNumber } from '../../stringify/stringifyNumber.js';\n\nconst floatNaN = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    test: /^(?:[-+]?\\.(?:inf|Inf|INF)|\\.nan|\\.NaN|\\.NAN)$/,\n    resolve: (str) => str.slice(-3).toLowerCase() === 'nan'\n        ? NaN\n        : str[0] === '-'\n            ? Number.NEGATIVE_INFINITY\n            : Number.POSITIVE_INFINITY,\n    stringify: stringifyNumber\n};\nconst floatExp = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    format: 'EXP',\n    test: /^[-+]?(?:[0-9][0-9_]*)?(?:\\.[0-9_]*)?[eE][-+]?[0-9]+$/,\n    resolve: (str) => parseFloat(str.replace(/_/g, '')),\n    stringify(node) {\n        const num = Number(node.value);\n        return isFinite(num) ? num.toExponential() : stringifyNumber(node);\n    }\n};\nconst float = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    test: /^[-+]?(?:[0-9][0-9_]*)?\\.[0-9_]*$/,\n    resolve(str) {\n        const node = new Scalar(parseFloat(str.replace(/_/g, '')));\n        const dot = str.indexOf('.');\n        if (dot !== -1) {\n            const f = str.substring(dot + 1).replace(/_/g, '');\n            if (f[f.length - 1] === '0')\n                node.minFractionDigits = f.length;\n        }\n        return node;\n    },\n    stringify: stringifyNumber\n};\n\nexport { float, floatExp, floatNaN };\n","import { stringifyNumber } from '../../stringify/stringifyNumber.js';\n\nconst intIdentify = (value) => typeof value === 'bigint' || Number.isInteger(value);\nfunction intResolve(str, offset, radix, { intAsBigInt }) {\n    const sign = str[0];\n    if (sign === '-' || sign === '+')\n        offset += 1;\n    str = str.substring(offset).replace(/_/g, '');\n    if (intAsBigInt) {\n        switch (radix) {\n            case 2:\n                str = `0b${str}`;\n                break;\n            case 8:\n                str = `0o${str}`;\n                break;\n            case 16:\n                str = `0x${str}`;\n                break;\n        }\n        const n = BigInt(str);\n        return sign === '-' ? BigInt(-1) * n : n;\n    }\n    const n = parseInt(str, radix);\n    return sign === '-' ? -1 * n : n;\n}\nfunction intStringify(node, radix, prefix) {\n    const { value } = node;\n    if (intIdentify(value)) {\n        const str = value.toString(radix);\n        return value < 0 ? '-' + prefix + str.substr(1) : prefix + str;\n    }\n    return stringifyNumber(node);\n}\nconst intBin = {\n    identify: intIdentify,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    format: 'BIN',\n    test: /^[-+]?0b[0-1_]+$/,\n    resolve: (str, _onError, opt) => intResolve(str, 2, 2, opt),\n    stringify: node => intStringify(node, 2, '0b')\n};\nconst intOct = {\n    identify: intIdentify,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    format: 'OCT',\n    test: /^[-+]?0[0-7_]+$/,\n    resolve: (str, _onError, opt) => intResolve(str, 1, 8, opt),\n    stringify: node => intStringify(node, 8, '0')\n};\nconst int = {\n    identify: intIdentify,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    test: /^[-+]?[0-9][0-9_]*$/,\n    resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt),\n    stringify: stringifyNumber\n};\nconst intHex = {\n    identify: intIdentify,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    format: 'HEX',\n    test: /^[-+]?0x[0-9a-fA-F_]+$/,\n    resolve: (str, _onError, opt) => intResolve(str, 2, 16, opt),\n    stringify: node => intStringify(node, 16, '0x')\n};\n\nexport { int, intBin, intHex, intOct };\n","import { isMap, isPair, isScalar } from '../../nodes/identity.js';\nimport { Pair, createPair } from '../../nodes/Pair.js';\nimport { YAMLMap, findPair } from '../../nodes/YAMLMap.js';\n\nclass YAMLSet extends YAMLMap {\n    constructor(schema) {\n        super(schema);\n        this.tag = YAMLSet.tag;\n    }\n    add(key) {\n        let pair;\n        if (isPair(key))\n            pair = key;\n        else if (key &&\n            typeof key === 'object' &&\n            'key' in key &&\n            'value' in key &&\n            key.value === null)\n            pair = new Pair(key.key, null);\n        else\n            pair = new Pair(key, null);\n        const prev = findPair(this.items, pair.key);\n        if (!prev)\n            this.items.push(pair);\n    }\n    /**\n     * If `keepPair` is `true`, returns the Pair matching `key`.\n     * Otherwise, returns the value of that Pair's key.\n     */\n    get(key, keepPair) {\n        const pair = findPair(this.items, key);\n        return !keepPair && isPair(pair)\n            ? isScalar(pair.key)\n                ? pair.key.value\n                : pair.key\n            : pair;\n    }\n    set(key, value) {\n        if (typeof value !== 'boolean')\n            throw new Error(`Expected boolean value for set(key, value) in a YAML set, not ${typeof value}`);\n        const prev = findPair(this.items, key);\n        if (prev && !value) {\n            this.items.splice(this.items.indexOf(prev), 1);\n        }\n        else if (!prev && value) {\n            this.items.push(new Pair(key));\n        }\n    }\n    toJSON(_, ctx) {\n        return super.toJSON(_, ctx, Set);\n    }\n    toString(ctx, onComment, onChompKeep) {\n        if (!ctx)\n            return JSON.stringify(this);\n        if (this.hasAllNullValues(true))\n            return super.toString(Object.assign({}, ctx, { allNullValues: true }), onComment, onChompKeep);\n        else\n            throw new Error('Set items must all have null values');\n    }\n    static from(schema, iterable, ctx) {\n        const { replacer } = ctx;\n        const set = new this(schema);\n        if (iterable && Symbol.iterator in Object(iterable))\n            for (let value of iterable) {\n                if (typeof replacer === 'function')\n                    value = replacer.call(iterable, value, value);\n                set.items.push(createPair(value, null, ctx));\n            }\n        return set;\n    }\n}\nYAMLSet.tag = 'tag:yaml.org,2002:set';\nconst set = {\n    collection: 'map',\n    identify: value => value instanceof Set,\n    nodeClass: YAMLSet,\n    default: false,\n    tag: 'tag:yaml.org,2002:set',\n    createNode: (schema, iterable, ctx) => YAMLSet.from(schema, iterable, ctx),\n    resolve(map, onError) {\n        if (isMap(map)) {\n            if (map.hasAllNullValues(true))\n                return Object.assign(new YAMLSet(), map);\n            else\n                onError('Set items must all have null values');\n        }\n        else\n            onError('Expected a mapping for this tag');\n        return map;\n    }\n};\n\nexport { YAMLSet, set };\n","import { stringifyNumber } from '../../stringify/stringifyNumber.js';\n\n/** Internal types handle bigint as number, because TS can't figure it out. */\nfunction parseSexagesimal(str, asBigInt) {\n    const sign = str[0];\n    const parts = sign === '-' || sign === '+' ? str.substring(1) : str;\n    const num = (n) => asBigInt ? BigInt(n) : Number(n);\n    const res = parts\n        .replace(/_/g, '')\n        .split(':')\n        .reduce((res, p) => res * num(60) + num(p), num(0));\n    return (sign === '-' ? num(-1) * res : res);\n}\n/**\n * hhhh:mm:ss.sss\n *\n * Internal types handle bigint as number, because TS can't figure it out.\n */\nfunction stringifySexagesimal(node) {\n    let { value } = node;\n    let num = (n) => n;\n    if (typeof value === 'bigint')\n        num = n => BigInt(n);\n    else if (isNaN(value) || !isFinite(value))\n        return stringifyNumber(node);\n    let sign = '';\n    if (value < 0) {\n        sign = '-';\n        value *= num(-1);\n    }\n    const _60 = num(60);\n    const parts = [value % _60]; // seconds, including ms\n    if (value < 60) {\n        parts.unshift(0); // at least one : is required\n    }\n    else {\n        value = (value - parts[0]) / _60;\n        parts.unshift(value % _60); // minutes\n        if (value >= 60) {\n            value = (value - parts[0]) / _60;\n            parts.unshift(value); // hours\n        }\n    }\n    return (sign +\n        parts\n            .map(n => String(n).padStart(2, '0'))\n            .join(':')\n            .replace(/000000\\d*$/, '') // % 60 may introduce error\n    );\n}\nconst intTime = {\n    identify: value => typeof value === 'bigint' || Number.isInteger(value),\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    format: 'TIME',\n    test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+$/,\n    resolve: (str, _onError, { intAsBigInt }) => parseSexagesimal(str, intAsBigInt),\n    stringify: stringifySexagesimal\n};\nconst floatTime = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    format: 'TIME',\n    test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*$/,\n    resolve: str => parseSexagesimal(str, false),\n    stringify: stringifySexagesimal\n};\nconst timestamp = {\n    identify: value => value instanceof Date,\n    default: true,\n    tag: 'tag:yaml.org,2002:timestamp',\n    // If the time zone is omitted, the timestamp is assumed to be specified in UTC. The time part\n    // may be omitted altogether, resulting in a date format. In such a case, the time part is\n    // assumed to be 00:00:00Z (start of day, UTC).\n    test: RegExp('^([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})' + // YYYY-Mm-Dd\n        '(?:' + // time is optional\n        '(?:t|T|[ \\\\t]+)' + // t | T | whitespace\n        '([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2}(\\\\.[0-9]+)?)' + // Hh:Mm:Ss(.ss)?\n        '(?:[ \\\\t]*(Z|[-+][012]?[0-9](?::[0-9]{2})?))?' + // Z | +5 | -03:30\n        ')?$'),\n    resolve(str) {\n        const match = str.match(timestamp.test);\n        if (!match)\n            throw new Error('!!timestamp expects a date, starting with yyyy-mm-dd');\n        const [, year, month, day, hour, minute, second] = match.map(Number);\n        const millisec = match[7] ? Number((match[7] + '00').substr(1, 3)) : 0;\n        let date = Date.UTC(year, month - 1, day, hour || 0, minute || 0, second || 0, millisec);\n        const tz = match[8];\n        if (tz && tz !== 'Z') {\n            let d = parseSexagesimal(tz, false);\n            if (Math.abs(d) < 30)\n                d *= 60;\n            date -= 60000 * d;\n        }\n        return new Date(date);\n    },\n    stringify: ({ value }) => value?.toISOString().replace(/(T00:00:00)?\\.000Z$/, '') ?? ''\n};\n\nexport { floatTime, intTime, timestamp };\n","import { map } from '../common/map.js';\nimport { nullTag } from '../common/null.js';\nimport { seq } from '../common/seq.js';\nimport { string } from '../common/string.js';\nimport { binary } from './binary.js';\nimport { trueTag, falseTag } from './bool.js';\nimport { floatNaN, floatExp, float } from './float.js';\nimport { intBin, intOct, int, intHex } from './int.js';\nimport { merge } from './merge.js';\nimport { omap } from './omap.js';\nimport { pairs } from './pairs.js';\nimport { set } from './set.js';\nimport { intTime, floatTime, timestamp } from './timestamp.js';\n\nconst schema = [\n    map,\n    seq,\n    string,\n    nullTag,\n    trueTag,\n    falseTag,\n    intBin,\n    intOct,\n    int,\n    intHex,\n    floatNaN,\n    floatExp,\n    float,\n    binary,\n    merge,\n    omap,\n    pairs,\n    set,\n    intTime,\n    floatTime,\n    timestamp\n];\n\nexport { schema };\n","import { map } from './common/map.js';\nimport { nullTag } from './common/null.js';\nimport { seq } from './common/seq.js';\nimport { string } from './common/string.js';\nimport { boolTag } from './core/bool.js';\nimport { floatNaN, floatExp, float } from './core/float.js';\nimport { intOct, intHex, int } from './core/int.js';\nimport { schema } from './core/schema.js';\nimport { schema as schema$1 } from './json/schema.js';\nimport { binary } from './yaml-1.1/binary.js';\nimport { merge } from './yaml-1.1/merge.js';\nimport { omap } from './yaml-1.1/omap.js';\nimport { pairs } from './yaml-1.1/pairs.js';\nimport { schema as schema$2 } from './yaml-1.1/schema.js';\nimport { set } from './yaml-1.1/set.js';\nimport { timestamp, intTime, floatTime } from './yaml-1.1/timestamp.js';\n\nconst schemas = new Map([\n    ['core', schema],\n    ['failsafe', [map, seq, string]],\n    ['json', schema$1],\n    ['yaml11', schema$2],\n    ['yaml-1.1', schema$2]\n]);\nconst tagsByName = {\n    binary,\n    bool: boolTag,\n    float,\n    floatExp,\n    floatNaN,\n    floatTime,\n    int,\n    intHex,\n    intOct,\n    intTime,\n    map,\n    merge,\n    null: nullTag,\n    omap,\n    pairs,\n    seq,\n    set,\n    timestamp\n};\nconst coreKnownTags = {\n    'tag:yaml.org,2002:binary': binary,\n    'tag:yaml.org,2002:merge': merge,\n    'tag:yaml.org,2002:omap': omap,\n    'tag:yaml.org,2002:pairs': pairs,\n    'tag:yaml.org,2002:set': set,\n    'tag:yaml.org,2002:timestamp': timestamp\n};\nfunction getTags(customTags, schemaName, addMergeTag) {\n    const schemaTags = schemas.get(schemaName);\n    if (schemaTags && !customTags) {\n        return addMergeTag && !schemaTags.includes(merge)\n            ? schemaTags.concat(merge)\n            : schemaTags.slice();\n    }\n    let tags = schemaTags;\n    if (!tags) {\n        if (Array.isArray(customTags))\n            tags = [];\n        else {\n            const keys = Array.from(schemas.keys())\n                .filter(key => key !== 'yaml11')\n                .map(key => JSON.stringify(key))\n                .join(', ');\n            throw new Error(`Unknown schema \"${schemaName}\"; use one of ${keys} or define customTags array`);\n        }\n    }\n    if (Array.isArray(customTags)) {\n        for (const tag of customTags)\n            tags = tags.concat(tag);\n    }\n    else if (typeof customTags === 'function') {\n        tags = customTags(tags.slice());\n    }\n    if (addMergeTag)\n        tags = tags.concat(merge);\n    return tags.reduce((tags, tag) => {\n        const tagObj = typeof tag === 'string' ? tagsByName[tag] : tag;\n        if (!tagObj) {\n            const tagName = JSON.stringify(tag);\n            const keys = Object.keys(tagsByName)\n                .map(key => JSON.stringify(key))\n                .join(', ');\n            throw new Error(`Unknown custom tag ${tagName}; use one of ${keys}`);\n        }\n        if (!tags.includes(tagObj))\n            tags.push(tagObj);\n        return tags;\n    }, []);\n}\n\nexport { coreKnownTags, getTags };\n","class YAMLError extends Error {\n    constructor(name, pos, code, message) {\n        super();\n        this.name = name;\n        this.code = code;\n        this.message = message;\n        this.pos = pos;\n    }\n}\nclass YAMLParseError extends YAMLError {\n    constructor(pos, code, message) {\n        super('YAMLParseError', pos, code, message);\n    }\n}\nclass YAMLWarning extends YAMLError {\n    constructor(pos, code, message) {\n        super('YAMLWarning', pos, code, message);\n    }\n}\nconst prettifyError = (src, lc) => (error) => {\n    if (error.pos[0] === -1)\n        return;\n    error.linePos = error.pos.map(pos => lc.linePos(pos));\n    const { line, col } = error.linePos[0];\n    error.message += ` at line ${line}, column ${col}`;\n    let ci = col - 1;\n    let lineStr = src\n        .substring(lc.lineStarts[line - 1], lc.lineStarts[line])\n        .replace(/[\\n\\r]+$/, '');\n    // Trim to max 80 chars, keeping col position near the middle\n    if (ci >= 60 && lineStr.length > 80) {\n        const trimStart = Math.min(ci - 39, lineStr.length - 79);\n        lineStr = '…' + lineStr.substring(trimStart);\n        ci -= trimStart - 1;\n    }\n    if (lineStr.length > 80)\n        lineStr = lineStr.substring(0, 79) + '…';\n    // Include previous line in context if pointing at line start\n    if (line > 1 && /^ *$/.test(lineStr.substring(0, ci))) {\n        // Regexp won't match if start is trimmed\n        let prev = src.substring(lc.lineStarts[line - 2], lc.lineStarts[line - 1]);\n        if (prev.length > 80)\n            prev = prev.substring(0, 79) + '…\\n';\n        lineStr = prev + lineStr;\n    }\n    if (/[^ ]/.test(lineStr)) {\n        let count = 1;\n        const end = error.linePos[1];\n        if (end?.line === line && end.col > col) {\n            count = Math.max(1, Math.min(end.col - col, 80 - ci));\n        }\n        const pointer = ' '.repeat(ci) + '^'.repeat(count);\n        error.message += `:\\n\\n${lineStr}\\n${pointer}\\n`;\n    }\n};\n\nexport { YAMLError, YAMLParseError, YAMLWarning, prettifyError };\n","const BREAK = Symbol('break visit');\nconst SKIP = Symbol('skip children');\nconst REMOVE = Symbol('remove item');\n/**\n * Apply a visitor to a CST document or item.\n *\n * Walks through the tree (depth-first) starting from the root, calling a\n * `visitor` function with two arguments when entering each item:\n *   - `item`: The current item, which included the following members:\n *     - `start: SourceToken[]` – Source tokens before the key or value,\n *       possibly including its anchor or tag.\n *     - `key?: Token | null` – Set for pair values. May then be `null`, if\n *       the key before the `:` separator is empty.\n *     - `sep?: SourceToken[]` – Source tokens between the key and the value,\n *       which should include the `:` map value indicator if `value` is set.\n *     - `value?: Token` – The value of a sequence item, or of a map pair.\n *   - `path`: The steps from the root to the current node, as an array of\n *     `['key' | 'value', number]` tuples.\n *\n * The return value of the visitor may be used to control the traversal:\n *   - `undefined` (default): Do nothing and continue\n *   - `visit.SKIP`: Do not visit the children of this token, continue with\n *      next sibling\n *   - `visit.BREAK`: Terminate traversal completely\n *   - `visit.REMOVE`: Remove the current item, then continue with the next one\n *   - `number`: Set the index of the next step. This is useful especially if\n *     the index of the current token has changed.\n *   - `function`: Define the next visitor for this item. After the original\n *     visitor is called on item entry, next visitors are called after handling\n *     a non-empty `key` and when exiting the item.\n */\nfunction visit(cst, visitor) {\n    if ('type' in cst && cst.type === 'document')\n        cst = { start: cst.start, value: cst.value };\n    _visit(Object.freeze([]), cst, visitor);\n}\n// Without the `as symbol` casts, TS declares these in the `visit`\n// namespace using `var`, but then complains about that because\n// `unique symbol` must be `const`.\n/** Terminate visit traversal completely */\nvisit.BREAK = BREAK;\n/** Do not visit the children of the current item */\nvisit.SKIP = SKIP;\n/** Remove the current item */\nvisit.REMOVE = REMOVE;\n/** Find the item at `path` from `cst` as the root */\nvisit.itemAtPath = (cst, path) => {\n    let item = cst;\n    for (const [field, index] of path) {\n        const tok = item?.[field];\n        if (tok && 'items' in tok) {\n            item = tok.items[index];\n        }\n        else\n            return undefined;\n    }\n    return item;\n};\n/**\n * Get the immediate parent collection of the item at `path` from `cst` as the root.\n *\n * Throws an error if the collection is not found, which should never happen if the item itself exists.\n */\nvisit.parentCollection = (cst, path) => {\n    const parent = visit.itemAtPath(cst, path.slice(0, -1));\n    const field = path[path.length - 1][0];\n    const coll = parent?.[field];\n    if (coll && 'items' in coll)\n        return coll;\n    throw new Error('Parent collection not found');\n};\nfunction _visit(path, item, visitor) {\n    let ctrl = visitor(item, path);\n    if (typeof ctrl === 'symbol')\n        return ctrl;\n    for (const field of ['key', 'value']) {\n        const token = item[field];\n        if (token && 'items' in token) {\n            for (let i = 0; i < token.items.length; ++i) {\n                const ci = _visit(Object.freeze(path.concat([[field, i]])), token.items[i], visitor);\n                if (typeof ci === 'number')\n                    i = ci - 1;\n                else if (ci === BREAK)\n                    return BREAK;\n                else if (ci === REMOVE) {\n                    token.items.splice(i, 1);\n                    i -= 1;\n                }\n            }\n            if (typeof ctrl === 'function' && field === 'key')\n                ctrl = ctrl(item, path);\n        }\n    }\n    return typeof ctrl === 'function' ? ctrl(item, path) : ctrl;\n}\n\nexport { visit };\n","import { Note } from \"../core\";\n\nexport enum GamakaType {\n  // Kampitam (~)\n  // The oscilation between 2 notes - eg p , S..n S..n S..n\n  Kampitham = \"Kampitham\",\n\n  // Nokku (w)\n  Nokku = \"Nokku\",\n\n  // Spuritham (∴ / u+2234) - Stress on the second note of a jantai\n  Spuritham = \"Spuritham\",\n\n  // Prathyagatham (∵ / u+2235) - Similar to reverse of Spuritham (in descending order)\n  Prathyagatham = \"Prathyagatham\",\n\n  // Raavi (^)\n  Aahaatam_Raavi = \"Raavi\",\n\n  // Kandippu (✓)\n  // eg - Shankarabharanam's S. ,,, n , P ,,,  - where the n is subtle\n  Aahaatam_Kandippu = \"Kandippu\",\n\n  // Vali (⌒ - U+2312)\n  Vaali = \"Vaali\",\n\n  // Odukkal (x):\n  // A veena gamakam where the note itself is stretched more to get the next\n  // note effect (instead of plucking the next note itself).\n  // Not possible where plucking of strings is not possible.\n  // On voice etc it just will sound like an Eetra Jaaru.\n  Odukkal = \"Odukkal\",\n\n  // (/) Ascension from one note to another - eg S / P\n  Jaaru_Eetra = \"EetraJaaru\",\n\n  // (\\) Descending from one note to another - eg P \\ S\n  Jaaru_Irakka = \"IrakkaJaaru\",\n\n  // Orikkai (γ)\n  // eg S~~ RN N~~S.D  D~~~NP\n  Orikkai = \"Orikkai\",\n}\n\nexport class Gamaka {\n  constructor(public readonly type: GamakaType) {}\n  debugValue(): any {\n    return { type: this.type };\n  }\n}\n\nexport class JaaruGamaka extends Gamaka {\n  constructor(\n    public readonly ascending = true,\n    public readonly startingNote: null | Note = null,\n  ) {\n    super(ascending ? GamakaType.Jaaru_Eetra : GamakaType.Jaaru_Irakka);\n  }\n\n  debugValue(): any {\n    const out = { ...super.debugValue(), ascending: this.ascending };\n    if (this.startingNote) out[\"startingNote\"] = this.startingNote.debugValue();\n    return out;\n  }\n}\n\nexport function parseEmbelishment(value: string): [any, boolean] {\n  value = value.substring(1);\n  if (value == \"\") {\n    return [new Gamaka(GamakaType.Kampitham), true];\n  } else if (value == \"^\") {\n    return [new Gamaka(GamakaType.Aahaatam_Raavi), true];\n  } else if (value == \"~\") {\n    return [new Gamaka(GamakaType.Vaali), true];\n  } else if (value == \"w\" || value == \"W\") {\n    return [new Gamaka(GamakaType.Nokku), true];\n  } else if (value == \"∴\" || value == \":-\") {\n    return [new Gamaka(GamakaType.Spuritham), true];\n  } else if (value == \"∵\" || value == \"-:\") {\n    return [new Gamaka(GamakaType.Prathyagatham), true];\n  } else if (value == \"✓\" || value == \"./\" || value == \".\\\\\") {\n    return [new Gamaka(GamakaType.Aahaatam_Kandippu), true];\n  } else if (value.endsWith(\"/\")) {\n    value = value.substring(0, value.length - 1).trim();\n    return [new JaaruGamaka(true, value.length > 0 ? new Note(value) : null), true];\n  } else if (value.endsWith(\"\\\\\")) {\n    value = value.substring(0, value.length - 1);\n    return [new JaaruGamaka(false, value.length > 0 ? new Note(value) : null), true];\n  } else if (value == \"x\") {\n    return [new Gamaka(GamakaType.Odukkal), true];\n  } else if (value == \"γ\" || value == \"Y\") {\n    return [new Gamaka(GamakaType.Orikkai), true];\n  }\n  // throw new Error(\"Invalid carnatic embelishment: \" + value);\n  return [null, false];\n}\n","import { BOM, DOCUMENT, FLOW_END, SCALAR } from './cst.js';\n\n/*\nSTART -> stream\n\nstream\n  directive -> line-end -> stream\n  indent + line-end -> stream\n  [else] -> line-start\n\nline-end\n  comment -> line-end\n  newline -> .\n  input-end -> END\n\nline-start\n  doc-start -> doc\n  doc-end -> stream\n  [else] -> indent -> block-start\n\nblock-start\n  seq-item-start -> block-start\n  explicit-key-start -> block-start\n  map-value-start -> block-start\n  [else] -> doc\n\ndoc\n  line-end -> line-start\n  spaces -> doc\n  anchor -> doc\n  tag -> doc\n  flow-start -> flow -> doc\n  flow-end -> error -> doc\n  seq-item-start -> error -> doc\n  explicit-key-start -> error -> doc\n  map-value-start -> doc\n  alias -> doc\n  quote-start -> quoted-scalar -> doc\n  block-scalar-header -> line-end -> block-scalar(min) -> line-start\n  [else] -> plain-scalar(false, min) -> doc\n\nflow\n  line-end -> flow\n  spaces -> flow\n  anchor -> flow\n  tag -> flow\n  flow-start -> flow -> flow\n  flow-end -> .\n  seq-item-start -> error -> flow\n  explicit-key-start -> flow\n  map-value-start -> flow\n  alias -> flow\n  quote-start -> quoted-scalar -> flow\n  comma -> flow\n  [else] -> plain-scalar(true, 0) -> flow\n\nquoted-scalar\n  quote-end -> .\n  [else] -> quoted-scalar\n\nblock-scalar(min)\n  newline + peek(indent < min) -> .\n  [else] -> block-scalar(min)\n\nplain-scalar(is-flow, min)\n  scalar-end(is-flow) -> .\n  peek(newline + (indent < min)) -> .\n  [else] -> plain-scalar(min)\n*/\nfunction isEmpty(ch) {\n    switch (ch) {\n        case undefined:\n        case ' ':\n        case '\\n':\n        case '\\r':\n        case '\\t':\n            return true;\n        default:\n            return false;\n    }\n}\nconst hexDigits = new Set('0123456789ABCDEFabcdef');\nconst tagChars = new Set(\"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-#;/?:@&=+$_.!~*'()\");\nconst flowIndicatorChars = new Set(',[]{}');\nconst invalidAnchorChars = new Set(' ,[]{}\\n\\r\\t');\nconst isNotAnchorChar = (ch) => !ch || invalidAnchorChars.has(ch);\n/**\n * Splits an input string into lexical tokens, i.e. smaller strings that are\n * easily identifiable by `tokens.tokenType()`.\n *\n * Lexing starts always in a \"stream\" context. Incomplete input may be buffered\n * until a complete token can be emitted.\n *\n * In addition to slices of the original input, the following control characters\n * may also be emitted:\n *\n * - `\\x02` (Start of Text): A document starts with the next token\n * - `\\x18` (Cancel): Unexpected end of flow-mode (indicates an error)\n * - `\\x1f` (Unit Separator): Next token is a scalar value\n * - `\\u{FEFF}` (Byte order mark): Emitted separately outside documents\n */\nclass Lexer {\n    constructor() {\n        /**\n         * Flag indicating whether the end of the current buffer marks the end of\n         * all input\n         */\n        this.atEnd = false;\n        /**\n         * Explicit indent set in block scalar header, as an offset from the current\n         * minimum indent, so e.g. set to 1 from a header `|2+`. Set to -1 if not\n         * explicitly set.\n         */\n        this.blockScalarIndent = -1;\n        /**\n         * Block scalars that include a + (keep) chomping indicator in their header\n         * include trailing empty lines, which are otherwise excluded from the\n         * scalar's contents.\n         */\n        this.blockScalarKeep = false;\n        /** Current input */\n        this.buffer = '';\n        /**\n         * Flag noting whether the map value indicator : can immediately follow this\n         * node within a flow context.\n         */\n        this.flowKey = false;\n        /** Count of surrounding flow collection levels. */\n        this.flowLevel = 0;\n        /**\n         * Minimum level of indentation required for next lines to be parsed as a\n         * part of the current scalar value.\n         */\n        this.indentNext = 0;\n        /** Indentation level of the current line. */\n        this.indentValue = 0;\n        /** Position of the next \\n character. */\n        this.lineEndPos = null;\n        /** Stores the state of the lexer if reaching the end of incpomplete input */\n        this.next = null;\n        /** A pointer to `buffer`; the current position of the lexer. */\n        this.pos = 0;\n    }\n    /**\n     * Generate YAML tokens from the `source` string. If `incomplete`,\n     * a part of the last line may be left as a buffer for the next call.\n     *\n     * @returns A generator of lexical tokens\n     */\n    *lex(source, incomplete = false) {\n        if (source) {\n            if (typeof source !== 'string')\n                throw TypeError('source is not a string');\n            this.buffer = this.buffer ? this.buffer + source : source;\n            this.lineEndPos = null;\n        }\n        this.atEnd = !incomplete;\n        let next = this.next ?? 'stream';\n        while (next && (incomplete || this.hasChars(1)))\n            next = yield* this.parseNext(next);\n    }\n    atLineEnd() {\n        let i = this.pos;\n        let ch = this.buffer[i];\n        while (ch === ' ' || ch === '\\t')\n            ch = this.buffer[++i];\n        if (!ch || ch === '#' || ch === '\\n')\n            return true;\n        if (ch === '\\r')\n            return this.buffer[i + 1] === '\\n';\n        return false;\n    }\n    charAt(n) {\n        return this.buffer[this.pos + n];\n    }\n    continueScalar(offset) {\n        let ch = this.buffer[offset];\n        if (this.indentNext > 0) {\n            let indent = 0;\n            while (ch === ' ')\n                ch = this.buffer[++indent + offset];\n            if (ch === '\\r') {\n                const next = this.buffer[indent + offset + 1];\n                if (next === '\\n' || (!next && !this.atEnd))\n                    return offset + indent + 1;\n            }\n            return ch === '\\n' || indent >= this.indentNext || (!ch && !this.atEnd)\n                ? offset + indent\n                : -1;\n        }\n        if (ch === '-' || ch === '.') {\n            const dt = this.buffer.substr(offset, 3);\n            if ((dt === '---' || dt === '...') && isEmpty(this.buffer[offset + 3]))\n                return -1;\n        }\n        return offset;\n    }\n    getLine() {\n        let end = this.lineEndPos;\n        if (typeof end !== 'number' || (end !== -1 && end < this.pos)) {\n            end = this.buffer.indexOf('\\n', this.pos);\n            this.lineEndPos = end;\n        }\n        if (end === -1)\n            return this.atEnd ? this.buffer.substring(this.pos) : null;\n        if (this.buffer[end - 1] === '\\r')\n            end -= 1;\n        return this.buffer.substring(this.pos, end);\n    }\n    hasChars(n) {\n        return this.pos + n <= this.buffer.length;\n    }\n    setNext(state) {\n        this.buffer = this.buffer.substring(this.pos);\n        this.pos = 0;\n        this.lineEndPos = null;\n        this.next = state;\n        return null;\n    }\n    peek(n) {\n        return this.buffer.substr(this.pos, n);\n    }\n    *parseNext(next) {\n        switch (next) {\n            case 'stream':\n                return yield* this.parseStream();\n            case 'line-start':\n                return yield* this.parseLineStart();\n            case 'block-start':\n                return yield* this.parseBlockStart();\n            case 'doc':\n                return yield* this.parseDocument();\n            case 'flow':\n                return yield* this.parseFlowCollection();\n            case 'quoted-scalar':\n                return yield* this.parseQuotedScalar();\n            case 'block-scalar':\n                return yield* this.parseBlockScalar();\n            case 'plain-scalar':\n                return yield* this.parsePlainScalar();\n        }\n    }\n    *parseStream() {\n        let line = this.getLine();\n        if (line === null)\n            return this.setNext('stream');\n        if (line[0] === BOM) {\n            yield* this.pushCount(1);\n            line = line.substring(1);\n        }\n        if (line[0] === '%') {\n            let dirEnd = line.length;\n            let cs = line.indexOf('#');\n            while (cs !== -1) {\n                const ch = line[cs - 1];\n                if (ch === ' ' || ch === '\\t') {\n                    dirEnd = cs - 1;\n                    break;\n                }\n                else {\n                    cs = line.indexOf('#', cs + 1);\n                }\n            }\n            while (true) {\n                const ch = line[dirEnd - 1];\n                if (ch === ' ' || ch === '\\t')\n                    dirEnd -= 1;\n                else\n                    break;\n            }\n            const n = (yield* this.pushCount(dirEnd)) + (yield* this.pushSpaces(true));\n            yield* this.pushCount(line.length - n); // possible comment\n            this.pushNewline();\n            return 'stream';\n        }\n        if (this.atLineEnd()) {\n            const sp = yield* this.pushSpaces(true);\n            yield* this.pushCount(line.length - sp);\n            yield* this.pushNewline();\n            return 'stream';\n        }\n        yield DOCUMENT;\n        return yield* this.parseLineStart();\n    }\n    *parseLineStart() {\n        const ch = this.charAt(0);\n        if (!ch && !this.atEnd)\n            return this.setNext('line-start');\n        if (ch === '-' || ch === '.') {\n            if (!this.atEnd && !this.hasChars(4))\n                return this.setNext('line-start');\n            const s = this.peek(3);\n            if ((s === '---' || s === '...') && isEmpty(this.charAt(3))) {\n                yield* this.pushCount(3);\n                this.indentValue = 0;\n                this.indentNext = 0;\n                return s === '---' ? 'doc' : 'stream';\n            }\n        }\n        this.indentValue = yield* this.pushSpaces(false);\n        if (this.indentNext > this.indentValue && !isEmpty(this.charAt(1)))\n            this.indentNext = this.indentValue;\n        return yield* this.parseBlockStart();\n    }\n    *parseBlockStart() {\n        const [ch0, ch1] = this.peek(2);\n        if (!ch1 && !this.atEnd)\n            return this.setNext('block-start');\n        if ((ch0 === '-' || ch0 === '?' || ch0 === ':') && isEmpty(ch1)) {\n            const n = (yield* this.pushCount(1)) + (yield* this.pushSpaces(true));\n            this.indentNext = this.indentValue + 1;\n            this.indentValue += n;\n            return yield* this.parseBlockStart();\n        }\n        return 'doc';\n    }\n    *parseDocument() {\n        yield* this.pushSpaces(true);\n        const line = this.getLine();\n        if (line === null)\n            return this.setNext('doc');\n        let n = yield* this.pushIndicators();\n        switch (line[n]) {\n            case '#':\n                yield* this.pushCount(line.length - n);\n            // fallthrough\n            case undefined:\n                yield* this.pushNewline();\n                return yield* this.parseLineStart();\n            case '{':\n            case '[':\n                yield* this.pushCount(1);\n                this.flowKey = false;\n                this.flowLevel = 1;\n                return 'flow';\n            case '}':\n            case ']':\n                // this is an error\n                yield* this.pushCount(1);\n                return 'doc';\n            case '*':\n                yield* this.pushUntil(isNotAnchorChar);\n                return 'doc';\n            case '\"':\n            case \"'\":\n                return yield* this.parseQuotedScalar();\n            case '|':\n            case '>':\n                n += yield* this.parseBlockScalarHeader();\n                n += yield* this.pushSpaces(true);\n                yield* this.pushCount(line.length - n);\n                yield* this.pushNewline();\n                return yield* this.parseBlockScalar();\n            default:\n                return yield* this.parsePlainScalar();\n        }\n    }\n    *parseFlowCollection() {\n        let nl, sp;\n        let indent = -1;\n        do {\n            nl = yield* this.pushNewline();\n            if (nl > 0) {\n                sp = yield* this.pushSpaces(false);\n                this.indentValue = indent = sp;\n            }\n            else {\n                sp = 0;\n            }\n            sp += yield* this.pushSpaces(true);\n        } while (nl + sp > 0);\n        const line = this.getLine();\n        if (line === null)\n            return this.setNext('flow');\n        if ((indent !== -1 && indent < this.indentNext && line[0] !== '#') ||\n            (indent === 0 &&\n                (line.startsWith('---') || line.startsWith('...')) &&\n                isEmpty(line[3]))) {\n            // Allowing for the terminal ] or } at the same (rather than greater)\n            // indent level as the initial [ or { is technically invalid, but\n            // failing here would be surprising to users.\n            const atFlowEndMarker = indent === this.indentNext - 1 &&\n                this.flowLevel === 1 &&\n                (line[0] === ']' || line[0] === '}');\n            if (!atFlowEndMarker) {\n                // this is an error\n                this.flowLevel = 0;\n                yield FLOW_END;\n                return yield* this.parseLineStart();\n            }\n        }\n        let n = 0;\n        while (line[n] === ',') {\n            n += yield* this.pushCount(1);\n            n += yield* this.pushSpaces(true);\n            this.flowKey = false;\n        }\n        n += yield* this.pushIndicators();\n        switch (line[n]) {\n            case undefined:\n                return 'flow';\n            case '#':\n                yield* this.pushCount(line.length - n);\n                return 'flow';\n            case '{':\n            case '[':\n                yield* this.pushCount(1);\n                this.flowKey = false;\n                this.flowLevel += 1;\n                return 'flow';\n            case '}':\n            case ']':\n                yield* this.pushCount(1);\n                this.flowKey = true;\n                this.flowLevel -= 1;\n                return this.flowLevel ? 'flow' : 'doc';\n            case '*':\n                yield* this.pushUntil(isNotAnchorChar);\n                return 'flow';\n            case '\"':\n            case \"'\":\n                this.flowKey = true;\n                return yield* this.parseQuotedScalar();\n            case ':': {\n                const next = this.charAt(1);\n                if (this.flowKey || isEmpty(next) || next === ',') {\n                    this.flowKey = false;\n                    yield* this.pushCount(1);\n                    yield* this.pushSpaces(true);\n                    return 'flow';\n                }\n            }\n            // fallthrough\n            default:\n                this.flowKey = false;\n                return yield* this.parsePlainScalar();\n        }\n    }\n    *parseQuotedScalar() {\n        const quote = this.charAt(0);\n        let end = this.buffer.indexOf(quote, this.pos + 1);\n        if (quote === \"'\") {\n            while (end !== -1 && this.buffer[end + 1] === \"'\")\n                end = this.buffer.indexOf(\"'\", end + 2);\n        }\n        else {\n            // double-quote\n            while (end !== -1) {\n                let n = 0;\n                while (this.buffer[end - 1 - n] === '\\\\')\n                    n += 1;\n                if (n % 2 === 0)\n                    break;\n                end = this.buffer.indexOf('\"', end + 1);\n            }\n        }\n        // Only looking for newlines within the quotes\n        const qb = this.buffer.substring(0, end);\n        let nl = qb.indexOf('\\n', this.pos);\n        if (nl !== -1) {\n            while (nl !== -1) {\n                const cs = this.continueScalar(nl + 1);\n                if (cs === -1)\n                    break;\n                nl = qb.indexOf('\\n', cs);\n            }\n            if (nl !== -1) {\n                // this is an error caused by an unexpected unindent\n                end = nl - (qb[nl - 1] === '\\r' ? 2 : 1);\n            }\n        }\n        if (end === -1) {\n            if (!this.atEnd)\n                return this.setNext('quoted-scalar');\n            end = this.buffer.length;\n        }\n        yield* this.pushToIndex(end + 1, false);\n        return this.flowLevel ? 'flow' : 'doc';\n    }\n    *parseBlockScalarHeader() {\n        this.blockScalarIndent = -1;\n        this.blockScalarKeep = false;\n        let i = this.pos;\n        while (true) {\n            const ch = this.buffer[++i];\n            if (ch === '+')\n                this.blockScalarKeep = true;\n            else if (ch > '0' && ch <= '9')\n                this.blockScalarIndent = Number(ch) - 1;\n            else if (ch !== '-')\n                break;\n        }\n        return yield* this.pushUntil(ch => isEmpty(ch) || ch === '#');\n    }\n    *parseBlockScalar() {\n        let nl = this.pos - 1; // may be -1 if this.pos === 0\n        let indent = 0;\n        let ch;\n        loop: for (let i = this.pos; (ch = this.buffer[i]); ++i) {\n            switch (ch) {\n                case ' ':\n                    indent += 1;\n                    break;\n                case '\\n':\n                    nl = i;\n                    indent = 0;\n                    break;\n                case '\\r': {\n                    const next = this.buffer[i + 1];\n                    if (!next && !this.atEnd)\n                        return this.setNext('block-scalar');\n                    if (next === '\\n')\n                        break;\n                } // fallthrough\n                default:\n                    break loop;\n            }\n        }\n        if (!ch && !this.atEnd)\n            return this.setNext('block-scalar');\n        if (indent >= this.indentNext) {\n            if (this.blockScalarIndent === -1)\n                this.indentNext = indent;\n            else {\n                this.indentNext =\n                    this.blockScalarIndent + (this.indentNext === 0 ? 1 : this.indentNext);\n            }\n            do {\n                const cs = this.continueScalar(nl + 1);\n                if (cs === -1)\n                    break;\n                nl = this.buffer.indexOf('\\n', cs);\n            } while (nl !== -1);\n            if (nl === -1) {\n                if (!this.atEnd)\n                    return this.setNext('block-scalar');\n                nl = this.buffer.length;\n            }\n        }\n        // Trailing insufficiently indented tabs are invalid.\n        // To catch that during parsing, we include them in the block scalar value.\n        let i = nl + 1;\n        ch = this.buffer[i];\n        while (ch === ' ')\n            ch = this.buffer[++i];\n        if (ch === '\\t') {\n            while (ch === '\\t' || ch === ' ' || ch === '\\r' || ch === '\\n')\n                ch = this.buffer[++i];\n            nl = i - 1;\n        }\n        else if (!this.blockScalarKeep) {\n            do {\n                let i = nl - 1;\n                let ch = this.buffer[i];\n                if (ch === '\\r')\n                    ch = this.buffer[--i];\n                const lastChar = i; // Drop the line if last char not more indented\n                while (ch === ' ')\n                    ch = this.buffer[--i];\n                if (ch === '\\n' && i >= this.pos && i + 1 + indent > lastChar)\n                    nl = i;\n                else\n                    break;\n            } while (true);\n        }\n        yield SCALAR;\n        yield* this.pushToIndex(nl + 1, true);\n        return yield* this.parseLineStart();\n    }\n    *parsePlainScalar() {\n        const inFlow = this.flowLevel > 0;\n        let end = this.pos - 1;\n        let i = this.pos - 1;\n        let ch;\n        while ((ch = this.buffer[++i])) {\n            if (ch === ':') {\n                const next = this.buffer[i + 1];\n                if (isEmpty(next) || (inFlow && flowIndicatorChars.has(next)))\n                    break;\n                end = i;\n            }\n            else if (isEmpty(ch)) {\n                let next = this.buffer[i + 1];\n                if (ch === '\\r') {\n                    if (next === '\\n') {\n                        i += 1;\n                        ch = '\\n';\n                        next = this.buffer[i + 1];\n                    }\n                    else\n                        end = i;\n                }\n                if (next === '#' || (inFlow && flowIndicatorChars.has(next)))\n                    break;\n                if (ch === '\\n') {\n                    const cs = this.continueScalar(i + 1);\n                    if (cs === -1)\n                        break;\n                    i = Math.max(i, cs - 2); // to advance, but still account for ' #'\n                }\n            }\n            else {\n                if (inFlow && flowIndicatorChars.has(ch))\n                    break;\n                end = i;\n            }\n        }\n        if (!ch && !this.atEnd)\n            return this.setNext('plain-scalar');\n        yield SCALAR;\n        yield* this.pushToIndex(end + 1, true);\n        return inFlow ? 'flow' : 'doc';\n    }\n    *pushCount(n) {\n        if (n > 0) {\n            yield this.buffer.substr(this.pos, n);\n            this.pos += n;\n            return n;\n        }\n        return 0;\n    }\n    *pushToIndex(i, allowEmpty) {\n        const s = this.buffer.slice(this.pos, i);\n        if (s) {\n            yield s;\n            this.pos += s.length;\n            return s.length;\n        }\n        else if (allowEmpty)\n            yield '';\n        return 0;\n    }\n    *pushIndicators() {\n        switch (this.charAt(0)) {\n            case '!':\n                return ((yield* this.pushTag()) +\n                    (yield* this.pushSpaces(true)) +\n                    (yield* this.pushIndicators()));\n            case '&':\n                return ((yield* this.pushUntil(isNotAnchorChar)) +\n                    (yield* this.pushSpaces(true)) +\n                    (yield* this.pushIndicators()));\n            case '-': // this is an error\n            case '?': // this is an error outside flow collections\n            case ':': {\n                const inFlow = this.flowLevel > 0;\n                const ch1 = this.charAt(1);\n                if (isEmpty(ch1) || (inFlow && flowIndicatorChars.has(ch1))) {\n                    if (!inFlow)\n                        this.indentNext = this.indentValue + 1;\n                    else if (this.flowKey)\n                        this.flowKey = false;\n                    return ((yield* this.pushCount(1)) +\n                        (yield* this.pushSpaces(true)) +\n                        (yield* this.pushIndicators()));\n                }\n            }\n        }\n        return 0;\n    }\n    *pushTag() {\n        if (this.charAt(1) === '<') {\n            let i = this.pos + 2;\n            let ch = this.buffer[i];\n            while (!isEmpty(ch) && ch !== '>')\n                ch = this.buffer[++i];\n            return yield* this.pushToIndex(ch === '>' ? i + 1 : i, false);\n        }\n        else {\n            let i = this.pos + 1;\n            let ch = this.buffer[i];\n            while (ch) {\n                if (tagChars.has(ch))\n                    ch = this.buffer[++i];\n                else if (ch === '%' &&\n                    hexDigits.has(this.buffer[i + 1]) &&\n                    hexDigits.has(this.buffer[i + 2])) {\n                    ch = this.buffer[(i += 3)];\n                }\n                else\n                    break;\n            }\n            return yield* this.pushToIndex(i, false);\n        }\n    }\n    *pushNewline() {\n        const ch = this.buffer[this.pos];\n        if (ch === '\\n')\n            return yield* this.pushCount(1);\n        else if (ch === '\\r' && this.charAt(1) === '\\n')\n            return yield* this.pushCount(2);\n        else\n            return 0;\n    }\n    *pushSpaces(allowTabs) {\n        let i = this.pos - 1;\n        let ch;\n        do {\n            ch = this.buffer[++i];\n        } while (ch === ' ' || (allowTabs && ch === '\\t'));\n        const n = i - this.pos;\n        if (n > 0) {\n            yield this.buffer.substr(this.pos, n);\n            this.pos = i;\n        }\n        return n;\n    }\n    *pushUntil(test) {\n        let i = this.pos;\n        let ch = this.buffer[i];\n        while (!test(ch))\n            ch = this.buffer[++i];\n        return yield* this.pushToIndex(i, false);\n    }\n}\n\nexport { Lexer };\n","import * as TSU from \"@panyam/tsutils\";\nimport { ZERO, Atom, LeafAtom, Group } from \"./core\";\n\n/**\n * Base class for all renderable objects.\n *\n * Shape caches properties like bounding boxes to improve performance,\n * since bounding box calculations can be expensive. This also allows\n * testing layouts and positioning without worrying about implementation details.\n */\nexport abstract class Shape {\n  private static idCounter = 0;\n  readonly shapeId: number = Shape.idCounter++;\n\n  /**\n   * Note that x and y coordinates are not always the x and y coordinates\n   * of the bounding box.\n   * E.g., a circle's x and y coordinates are its center point and not the\n   * top left corner.\n   * These \"main\" coordinates are referred to as control coordinates.\n   */\n  protected _x: number | null = null;\n  protected _y: number | null = null;\n  protected _width: number | null = null;\n  protected _height: number | null = null;\n  protected _bbox: TSU.Geom.Rect;\n  protected _minSize: TSU.Geom.Size;\n  protected parentShape: Shape | null = null;\n  /** Child shapes contained within this shape */\n  children: Shape[] = [];\n\n  /**\n   * Gets the bounding box of this shape.\n   * Calculates it if it hasn't been calculated yet.\n   */\n  get bbox(): TSU.Geom.Rect {\n    if (!this._bbox) {\n      this._bbox = this.refreshBBox();\n    }\n    return this._bbox;\n  }\n\n  /**\n   * Gets the minimum size of this shape.\n   * This is usually the size of the bounding box.\n   */\n  get minSize(): TSU.Geom.Size {\n    if (!this._minSize) {\n      this._minSize = this.refreshMinSize();\n    }\n    return this._minSize;\n  }\n\n  /**\n   * Refreshes the bounding box of this shape.\n   * Called when the shape knows the bbox it is tracking cannot be trusted\n   * and has to be refreshed by calling native methods.\n   * @returns The refreshed bounding box\n   */\n  protected abstract refreshBBox(): TSU.Geom.Rect;\n\n  /**\n   * Refreshes the minimum size of this shape.\n   * @returns The refreshed minimum size\n   */\n  protected abstract refreshMinSize(): TSU.Geom.Size;\n\n  /**\n   * Updates the bounds of this shape.\n   * @param x New x coordinate, or null to keep current value\n   * @param y New y coordinate, or null to keep current value\n   * @param w New width, or null to keep current value\n   * @param h New height, or null to keep current value\n   * @returns The updated bounds values\n   */\n  protected abstract updateBounds(\n    x: null | number,\n    y: null | number,\n    w: null | number,\n    h: null | number,\n  ): [number | null, number | null, number | null, number | null];\n\n  /**\n   * Invalidates the cached bounds of this shape.\n   * Forces recalculation of bounding box and minimum size.\n   */\n  invalidateBounds(): void {\n    this._minSize = null as unknown as TSU.Geom.Size;\n    this._bbox = null as unknown as TSU.Geom.Rect;\n  }\n\n  /**\n   * Sets the bounds of this shape.\n   *\n   * Note that null and NaN are valid values and mean the following:\n   * - null: Don't change the value\n   * - NaN: Set the value to null (use the bounding box's value)\n   *\n   * @param x New x coordinate, or null to keep current value\n   * @param y New y coordinate, or null to keep current value\n   * @param w New width, or null to keep current value\n   * @param h New height, or null to keep current value\n   * @param applyLayout Whether to apply layout immediately\n   * @returns The updated bounds values\n   */\n  setBounds(\n    x: number | null,\n    y: number | null,\n    w: number | null,\n    h: number | null,\n    applyLayout = false,\n  ): [number | null, number | null, number | null, number | null] {\n    if (x != null) {\n      if (isNaN(x)) {\n        this._x = null;\n      } else {\n        this._x = x;\n      }\n    }\n    if (y != null) {\n      if (isNaN(y)) {\n        this._y = null;\n      } else {\n        this._y = y;\n      }\n    }\n    if (w != null) {\n      if (isNaN(w)) {\n        this._width = null;\n      } else {\n        this._width = w;\n      }\n    }\n    if (h != null) {\n      if (isNaN(h)) {\n        this._height = null;\n      } else {\n        this._height = h;\n      }\n    }\n    const [nx, ny, nw, nh] = this.updateBounds(x, y, w, h);\n    if (nx != null) {\n      if (isNaN(nx)) {\n        this._x = null;\n      } else {\n        this._x = nx;\n      }\n    }\n    if (ny != null) {\n      if (isNaN(ny)) {\n        this._y = null;\n      } else {\n        this._y = ny;\n      }\n    }\n    if (nw != null) {\n      if (isNaN(nw)) {\n        this._width = null;\n      } else {\n        this._width = nw;\n      }\n    }\n    if (nh != null) {\n      if (isNaN(nh)) {\n        this._height = null;\n      } else {\n        this._height = nh;\n      }\n    }\n    if (applyLayout) this.refreshLayout();\n    // this.resetBBox();\n    return [nx, ny, nw, nh];\n  }\n\n  /**\n   * Checks if this shape has an explicit x coordinate.\n   */\n  get hasX(): boolean {\n    return this._x != null && !isNaN(this._x);\n  }\n\n  /**\n   * Checks if this shape has an explicit y coordinate.\n   */\n  get hasY(): boolean {\n    return this._y != null && !isNaN(this._y);\n  }\n\n  /**\n   * Checks if this shape has an explicit width.\n   */\n  get hasWidth(): boolean {\n    return this._width != null && !isNaN(this._width);\n  }\n\n  /**\n   * Checks if this shape has an explicit height.\n   */\n  get hasHeight(): boolean {\n    return this._height != null && !isNaN(this._height);\n  }\n\n  /**\n   * Gets the x coordinate within the parent's coordinate system.\n   */\n  get x(): number {\n    return this._x || 0;\n  }\n\n  /**\n   * Sets the x coordinate within the parent's coordinate system.\n   */\n  set x(x: number | null) {\n    // Here a manual x is being set - how does this interfere with the bounding box?\n    // We should _x to the new value to indicate a manual value was set.\n    // and reset bbox so that based on this x a new bbox may need to be calculated\n    this.setBounds(x == null ? NaN : x, null, null, null);\n  }\n\n  /**\n   * Gets the y coordinate within the parent's coordinate system.\n   */\n  get y(): number {\n    if (this._y != null) return this._y;\n    return 0; // this.bbox.y;\n  }\n\n  /**\n   * Sets the y coordinate within the parent's coordinate system.\n   */\n  set y(y: number | null) {\n    this.setBounds(null, y == null ? NaN : y, null, null);\n  }\n\n  /**\n   * Gets the width of this shape.\n   */\n  get width(): number {\n    if (this._width != null) return this._width;\n    return 0; // this.bbox.width;\n  }\n\n  /**\n   * Sets the width of this shape.\n   */\n  set width(w: number | null) {\n    this.setBounds(null, null, w == null ? NaN : w, null);\n  }\n\n  /**\n   * Gets the height of this shape.\n   */\n  get height(): number {\n    if (this._height != null) return this._height;\n    return 0; // this.bbox.height;\n  }\n\n  /**\n   * Sets the height of this shape.\n   */\n  set height(h: number | null) {\n    this.setBounds(null, null, null, h == null ? NaN : h);\n  }\n\n  /**\n   * Refreshes the layout of this shape.\n   * Called when bounds or other properties have changed to give the shape an\n   * opportunity to layout its children. For shapes with no children this is a no-op.\n   */\n  refreshLayout(): void {\n    // throw new Error(\"Implement this\");\n  }\n}\n\n/**\n * Represents an embellishment applied to a musical element.\n */\nexport abstract class Embelishment extends Shape {}\n\n/**\n * A shape that wraps an SVG element.\n * ElementShape provides the base class for all shapes that are rendered as SVG elements.\n */\nexport class ElementShape<T extends SVGGraphicsElement = SVGGraphicsElement> extends Shape {\n  /**\n   * Creates a new ElementShape.\n   * @param element The SVG element this shape wraps\n   */\n  constructor(public readonly element: T) {\n    super();\n  }\n\n  /**\n   * Refreshes the bounding box of this element.\n   * @returns The refreshed bounding box\n   */\n  protected refreshBBox(): TSU.Geom.Rect {\n    return TSU.DOM.svgBBox(this.element);\n  }\n\n  /**\n   * Refreshes the minimum size of this element.\n   * @returns The refreshed minimum size\n   */\n  protected refreshMinSize(): TSU.Geom.Size {\n    return TSU.DOM.svgBBox(this.element);\n  }\n\n  /**\n   * Updates the bounds of this element.\n   * @param x New x coordinate, or null to keep current value\n   * @param y New y coordinate, or null to keep current value\n   * @param w New width, or null to keep current value\n   * @param h New height, or null to keep current value\n   * @returns The updated bounds values\n   */\n  protected updateBounds(\n    x: null | number,\n    y: null | number,\n    w: null | number,\n    h: null | number,\n  ): [number | null, number | null, number | null, number | null] {\n    return [x, y, w, h];\n  }\n\n  /**\n   * Refreshes the layout of this element.\n   * Updates the element's attributes based on the shape's properties.\n   */\n  refreshLayout(): void {\n    if (this.hasX) this.element.setAttribute(\"x\", \"\" + this._x);\n    if (this.hasY) this.element.setAttribute(\"y\", \"\" + this._y);\n  }\n}\n\n/**\n * Base class for views that represent atoms in the notation.\n * AtomView provides the visual representation of an atom.\n */\nexport abstract class AtomView extends Shape {\n  /** Nesting depth of this atom in the structure */\n  depth = 0;\n  /** Index of the role containing this atom */\n  roleIndex = 0;\n\n  // LayoutMetrics for the AtomView so all atomviews laid out on the\n  // same baseline will show up aligned vertically\n  /** Baseline position for vertical alignment */\n  baseline: number;\n  /** Ascent (space above baseline) */\n  ascent: number;\n  /** Descent (space below baseline) */\n  descent: number;\n  /** Height of capital letters */\n  capHeight: number;\n  /** Space between lines */\n  leading: number;\n\n  /**\n   * Checks if this atom view represents a leaf atom.\n   */\n  abstract isLeaf(): boolean;\n\n  abstract get totalDuration(): TSU.Num.Fraction;\n\n  /**\n   * Returns the horizontal offset from the atom's origin to where the note glyph starts.\n   * This accounts for left embellishments that appear before the note.\n   * Used by GroupView to align note glyphs at their correct time positions.\n   *\n   * Default is 0 (glyph starts at origin). Subclasses with left embellishments\n   * should override to return the width of left-side decorations.\n   */\n  get glyphOffset(): number {\n    return 0;\n  }\n\n  /**\n   * Creates the SVG elements needed for this atom view.\n   * @param parent The parent SVG element to attach to\n   */\n  abstract createElements(parent: SVGGraphicsElement): void;\n}\n\n/**\n * A view for leaf atoms (those that cannot contain other atoms).\n */\nexport abstract class LeafAtomView extends AtomView {\n  /**\n   * Creates a new LeafAtomView.\n   * @param leafAtom The leaf atom this view represents\n   */\n  constructor(public leafAtom: LeafAtom) {\n    super();\n  }\n\n  /**\n   * Leaf atom views always return true for isLeaf().\n   */\n  isLeaf(): boolean {\n    return true;\n  }\n\n  /**\n   * Gets a unique identifier for this view based on the atom's UUID.\n   */\n  get viewId(): number {\n    return this.leafAtom.uuid;\n  }\n\n  /**\n   * Returns the total duration of the atom rendered by this view.\n   */\n  get totalDuration(): TSU.Num.Fraction {\n    return this.leafAtom.duration;\n  }\n}\n\n/**\n * A view for group atoms that contain multiple child atoms.\n */\nexport abstract class GroupView extends AtomView {\n  /** Space between atoms in this group */\n  protected atomSpacing: number;\n  /** The SVG group element for this view */\n  protected groupElement: SVGGElement;\n  /** Views for the atoms in this group */\n  protected atomViews: AtomView[] = [];\n  private _embelishments: Embelishment[];\n  /** Whether this group represents notes by default */\n  defaultToNotes = true;\n  /** Whether this view needs layout */\n  needsLayout = true;\n  /** Scale factor for this group */\n  scaleFactor = 1.0;\n  /**\n   * When true, shows continuation markers (\",\") for atoms with duration > 1\n   * instead of just leaving empty space.\n   */\n  showContinuationMarkers = true;\n  /** SVG elements for continuation markers */\n  protected continuationMarkerElements: SVGTextElement[] = [];\n\n  /**\n   * Creates a new GroupView.\n   * @param group The group atom this view represents\n   * @param config Optional configuration object\n   */\n  constructor(\n    public group: Group,\n    config?: any,\n  ) {\n    super();\n    this.atomSpacing = 5;\n    this.setStyles(config || {});\n  }\n\n  /**\n   * Returns the total duration of the group rendered by this view.\n   */\n  get totalDuration(): TSU.Num.Fraction {\n    return this.group.totalChildDuration;\n  }\n\n  /**\n   * Creates the SVG elements needed for this group view.\n   * @param parent The parent SVG element to attach to\n   */\n  createElements(parent: SVGGraphicsElement): void {\n    this.groupElement = TSU.DOM.createSVGNode(\"g\", {\n      parent: parent,\n      attrs: {\n        class: \"groupViewRoot\",\n        id: \"groupViewRoot\" + this.group.uuid,\n      },\n    });\n\n    // now create child atom views for each atom in this Group\n    for (const atom of this.group.atoms.values()) {\n      const atomView = this.createAtomView(atom);\n      this.atomViews.push(atomView);\n    }\n    this.invalidateBounds();\n  }\n\n  /**\n   * Group views always return false for isLeaf().\n   */\n  isLeaf(): boolean {\n    return false;\n  }\n\n  /**\n   * Refreshes the bounding box of this group.\n   * @returns The refreshed bounding box\n   */\n  protected refreshBBox(): TSU.Geom.Rect {\n    return TSU.DOM.svgBBox(this.groupElement);\n  }\n\n  /**\n   * Refreshes the minimum size of this group using duration-based width calculation.\n   *\n   * ## Duration-Based Width Algorithm\n   *\n   * This algorithm ensures atoms with extended durations receive proportionally\n   * more horizontal space. For example, with `\\beatDuration(4)` and input `S 2 R G M`:\n   * - S has duration 1, R has duration 2, G has duration 1\n   * - R should visually occupy twice the horizontal space of S or G\n   *\n   * ### Algorithm Steps:\n   *\n   * 1. **Calculate width per duration unit**: For each atom, compute the visual width\n   *    needed per unit of duration: `(visualWidth + spacing) / duration`\n   *\n   * 2. **Find maximum**: Take the maximum width-per-duration across all atoms.\n   *    This ensures every atom has enough space for its visual content.\n   *\n   * 3. **Scale by total duration**: Multiply the max width-per-duration by the\n   *    group's total duration to get the final group width.\n   *\n   * ### Example:\n   * ```\n   * Atoms: S(dur=1, width=10px), R(dur=2, width=10px), G(dur=1, width=10px)\n   * Spacing: 5px\n   *\n   * Width per duration:\n   *   S: (10 + 5) / 1 = 15 px/unit\n   *   R: (10 + 5) / 2 = 7.5 px/unit\n   *   G: (10 + 5) / 1 = 15 px/unit\n   *\n   * Max width per duration: 15 px/unit\n   * Total duration: 1 + 2 + 1 = 4 units\n   * Group width: 15 * 4 = 60px\n   *\n   * Positioning:\n   *   S at x=0 (time 0/4 * 60 = 0)\n   *   R at x=15 (time 1/4 * 60 = 15)\n   *   G at x=45 (time 3/4 * 60 = 45)\n   * ```\n   *\n   * @returns The refreshed minimum size\n   */\n  protected refreshMinSize(): TSU.Geom.Size {\n    let maxHeight = 0;\n\n    // Step 1: Calculate width per duration unit for each atom\n    let minWidthPerDuration = 0;\n    this.atomViews.forEach((av) => {\n      const ms = av.minSize;\n      const dur = av.totalDuration;\n      if (!dur.isZero) {\n        const durValue = dur.num / dur.den;\n        const widthPerDur = (ms.width + this.atomSpacing) / durValue;\n        // Step 2: Track maximum width per duration\n        minWidthPerDuration = Math.max(minWidthPerDuration, widthPerDur);\n      }\n      maxHeight = Math.max(maxHeight, ms.height);\n    });\n\n    // Step 3: Scale by total duration\n    const totalDuration = this.group.totalChildDuration;\n    const totalDurValue = totalDuration.num / totalDuration.den;\n    const totalWidth = minWidthPerDuration * totalDurValue;\n\n    return new TSU.Geom.Size(totalWidth * this.scaleFactor, maxHeight * this.scaleFactor);\n  }\n\n  /**\n   * Creates an atom view for a specific atom.\n   * @param atom The atom to create a view for\n   * @returns The created atom view\n   */\n  abstract createAtomView(atom: Atom): AtomView;\n\n  /**\n   * Updates the bounds of this group.\n   * @param x New x coordinate, or null to keep current value\n   * @param y New y coordinate, or null to keep current value\n   * @param w New width, or null to keep current value\n   * @param h New height, or null to keep current value\n   * @returns The updated bounds values\n   */\n  protected updateBounds(\n    x: null | number,\n    y: null | number,\n    w: null | number,\n    h: null | number,\n  ): [number | null, number | null, number | null, number | null] {\n    return [x, y, w, h];\n  }\n\n  /**\n   * Refreshes the layout of this group using duration-based positioning.\n   *\n   * ## Duration-Based Positioning Algorithm\n   *\n   * Atoms are positioned at x-coordinates proportional to their time offset\n   * within the group's total duration. This ensures that atoms with extended\n   * durations visually occupy the correct amount of horizontal space.\n   *\n   * ### Width Source Priority:\n   *\n   * 1. **Column width** (preferred): If width was set via `setBounds()` from the\n   *    grid layout system (ColAlign), use that width. This enables global alignment\n   *    across all beats in the same column.\n   *\n   * 2. **Minimum size**: Fall back to `minSize.width` calculated by `refreshMinSize()`.\n   *\n   * ### Positioning Formula:\n   * ```\n   * xPosition = (timeOffset / totalDuration) * groupWidth\n   * ```\n   *\n   * ### Continuation Markers:\n   *\n   * When `showContinuationMarkers` is true (default), atoms with duration > 1\n   * will have \",\" markers rendered at each additional time slot. For example,\n   * an atom with duration 2 will show \"R ,\" instead of \"R   \".\n   *\n   * This helps users visually understand that the note continues through\n   * multiple time slots without relying on empty space alone.\n   *\n   * ### Example:\n   * ```\n   * Input: S 2 R G (with beatDuration=4)\n   * Group width: 60px, Total duration: 4 units\n   *\n   * Positioning:\n   *   S at x=0   (time 0, offset 0/4 * 60 = 0)\n   *   R at x=15  (time 1, offset 1/4 * 60 = 15)\n   *   \",\" at x=30 (continuation marker for R at time 2)\n   *   G at x=45  (time 3, offset 3/4 * 60 = 45)\n   * ```\n   */\n  refreshLayout(): void {\n    let transform = \"translate(\" + this.x + \",\" + this.y + \")\";\n    if (this.scaleFactor < 1) {\n      transform += \" scale(\" + this.scaleFactor + \")\";\n    }\n    this.groupElement.setAttribute(\"transform\", transform);\n\n    const currY = 0;\n    const totalDur = this.group.totalChildDuration;\n\n    // Width source priority: column width (for global alignment) > minSize\n    const unscaledMinWidth = this.minSize.width / this.scaleFactor;\n    const groupWidth = this.hasWidth ? this.width / this.scaleFactor : unscaledMinWidth;\n\n    // Clear existing continuation markers before re-rendering\n    this.clearContinuationMarkers();\n\n    // Position each atom based on its time offset\n    let currTime = ZERO;\n    this.atomViews.forEach((av, index) => {\n      // Calculate where the NOTE GLYPH should appear based on time offset\n      const glyphX = totalDur.isZero ? 0 : currTime.timesNum(groupWidth).divby(totalDur).floor;\n      // Subtract glyphOffset so left embellishments don't push the glyph past its time position\n      // The atom origin is placed earlier, so the glyph ends up at the correct time position\n      const xPos = Math.max(0, glyphX - av.glyphOffset);\n      av.setBounds(xPos, currY, null, null, true);\n\n      // Render continuation markers for atoms with duration > 1\n      if (this.showContinuationMarkers && !totalDur.isZero) {\n        const atomDur = av.totalDuration;\n        const durValue = atomDur.num / atomDur.den;\n        if (durValue > 1) {\n          // Render one marker at each additional time slot within the atom's duration\n          const numMarkers = Math.floor(durValue) - 1;\n          for (let i = 1; i <= numMarkers; i++) {\n            // Marker time = currTime + (atomDuration * i / floor(duration))\n            const markerTime = currTime.plus(atomDur.timesNum(i).divbyNum(Math.floor(durValue)));\n            const markerX = markerTime.timesNum(groupWidth).divby(totalDur).floor;\n            this.renderContinuationMarker(markerX, currY);\n          }\n        }\n      }\n\n      currTime = currTime.plus(av.totalDuration);\n    });\n\n    this.invalidateBounds();\n    for (const e of this.embelishments) e.refreshLayout();\n    this.invalidateBounds();\n  }\n\n  /**\n   * Clears all continuation marker elements.\n   */\n  protected clearContinuationMarkers(): void {\n    for (const el of this.continuationMarkerElements) {\n      el.remove();\n    }\n    this.continuationMarkerElements = [];\n  }\n\n  /**\n   * Renders a continuation marker (\",\") at the specified position.\n   * @param x X position for the marker\n   * @param y Y position for the marker\n   */\n  protected renderContinuationMarker(x: number, y: number): void {\n    const marker = TSU.DOM.createSVGNode(\"text\", {\n      parent: this.groupElement,\n      attrs: {\n        class: \"continuationMarker\",\n        x: x.toString(),\n        y: y.toString(),\n      },\n      text: \",\",\n    }) as SVGTextElement;\n    this.continuationMarkerElements.push(marker);\n  }\n\n  /**\n   * Gets the embellishments for this group.\n   */\n  get embelishments(): Embelishment[] {\n    if (!this._embelishments) {\n      this._embelishments = this.createEmbelishments();\n    }\n    return this._embelishments;\n  }\n\n  /**\n   * Creates the embellishments for this group.\n   * @returns An array of embellishments\n   */\n  protected createEmbelishments(): Embelishment[] {\n    return [];\n  }\n\n  /**\n   * Sets the styles for this group.\n   * @param config Style configuration object\n   */\n  setStyles(config: any): void {\n    if (\"atomSpacing\" in config) this.atomSpacing = config.atomSpacing;\n    if (\"showContinuationMarkers\" in config) this.showContinuationMarkers = config.showContinuationMarkers;\n    this.needsLayout = true;\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport * as TLEX from \"tlex\";\nimport { load as loadGrammar, TokenHandler } from \"./dsl\";\nimport { makeParseTable } from \"./ptables\";\nimport { Parser, ParseTable } from \"./lr\";\nimport { LRItemGraph } from \"./lritems\";\nimport { logParserDebug } from \"./debug\";\n\n/**\n * Configuration options for creating a parser.\n */\nexport interface ParserOptions {\n  /**\n   * Parser algorithm to use.\n   * - \"slr\": Simple LR - smallest tables, may have false conflicts\n   * - \"lalr\": Look-Ahead LR - default, good balance of power and size\n   * - \"lr1\": Canonical LR(1) - most powerful, largest tables\n   * @default \"lalr\"\n   */\n  type?: \"slr\" | \"lalr\" | \"lr1\";\n\n  /**\n   * Custom tokenizer function. If not provided, one is auto-generated\n   * from %token and inline token definitions in the grammar.\n   */\n  tokenizer?: TLEX.NextTokenFunc;\n\n  /**\n   * Enable debug output.\n   * - \"lexer\": Log tokenizer program\n   * - \"parser\": Log parse table and state transitions\n   * - \"all\": Log both lexer and parser\n   */\n  debug?: \"all\" | \"lexer\" | \"parser\" | string;\n\n  /**\n   * Use left recursion for EBNF expansions (*, +).\n   * @default true\n   */\n  leftRecursive?: boolean;\n\n  /**\n   * Prefix for auxiliary non-terminals created by EBNF expansions.\n   * @default \"$\"\n   */\n  auxNTPrefix?: string;\n\n  /**\n   * Custom token handlers for post-processing tokens.\n   */\n  tokenHandlers?: TSU.StringMap<TokenHandler>;\n}\n\n/**\n * Creates a parser from a grammar DSL string.\n *\n * This is the main entry point for creating parsers in Galore.\n *\n * @param input - Grammar definition in DSL format\n * @param params - Configuration options\n * @returns A tuple of [parser, tokenFunc, itemGraph]\n *   - parser: The LR parser instance\n *   - tokenFunc: The generated tokenizer (or null if custom provided)\n *   - itemGraph: The LR item graph (useful for debugging)\n *\n * @example\n * ```typescript\n * import { newParser } from \"galore\";\n *\n * const [parser, tokenFunc, itemGraph] = newParser(`\n *   %token NUMBER /[0-9]+/\n *   %skip /[ \\\\t\\\\n]+/\n *\n *   Expr -> Expr \"+\" Term | Term ;\n *   Term -> NUMBER ;\n * `, { type: \"lalr\" });\n *\n * const result = parser.parse(\"1 + 2\");\n * ```\n */\nexport function newLRParser(\n  input: string,\n  params: ParserOptions | null = null,\n): [Parser, null | TLEX.NextTokenFunc, LRItemGraph] {\n  const options = params || ({} as ParserOptions);\n  const [ptable, tokenFunc, itemGraph] = newParseTable(input, options);\n  const parser = new Parser(ptable);\n  if (options.tokenizer || tokenFunc) {\n    parser.setTokenizer(options.tokenizer || tokenFunc!);\n  }\n  const debug = options.debug || \"\";\n  if (debug.split(\"|\").findIndex((p: string) => p == \"all\" || p == \"parser\") >= 0) {\n    logParserDebug(parser, itemGraph);\n  }\n  return [parser, tokenFunc, itemGraph];\n}\n\n/**\n * Creates a parse table from a grammar DSL string without creating a parser.\n *\n * Useful when you need access to the parse table for analysis or visualization.\n *\n * @param input - Grammar definition in DSL format\n * @param params - Configuration options\n * @returns A tuple of [parseTable, tokenFunc, itemGraph]\n *\n * @example\n * ```typescript\n * import { newParseTable, Printers } from \"galore\";\n *\n * const [ptable, tokenFunc, itemGraph] = newParseTable(grammar, { type: \"lalr\" });\n *\n * // Check for conflicts\n * if (ptable.hasConflicts) {\n *   console.log(\"Conflicts:\", ptable.conflictActions);\n * }\n *\n * // Visualize the parse table\n * const html = Printers.parseTableToHtml(ptable, { itemGraph });\n * ```\n */\nexport function newParseTable(\n  input: string,\n  params: ParserOptions | null = null,\n): [ParseTable, null | TLEX.NextTokenFunc, LRItemGraph] {\n  const options = params || ({} as ParserOptions);\n  const [g, tokenFunc] = loadGrammar(input, options as any);\n  g.augmentStartSymbol();\n  const [ptable, itemGraph] = makeParseTable(g, options.type);\n  return [ptable, tokenFunc, itemGraph];\n}\n","import { Parser, LRAction, ParseTable } from \"./lr\";\nimport { LRItemGraph } from \"./lritems\";\n\nexport function logParserDebug(parser: Parser, itemGraph?: LRItemGraph): void {\n  const g = parser.grammar;\n  const ptable = parser.parseTable;\n  console.log(\n    \"===============================\\nGrammar (as default): \\n\",\n    g.debugValue.map((x, i) => `${i + 1}  -   ${x}`),\n    \"===============================\\nGrammar (as Bison): \\n\",\n    g.debugValue.map((x, i) => `${x.replace(\"->\", \":\")} ; \\n`).join(\"\"),\n    \"===============================\\nParseTable: \\n\",\n    JSON.stringify(mergedDebugValue(ptable, itemGraph), null, 4),\n    \"===============================\\nConflicts: \\n\",\n    ptable.conflictActions,\n  );\n}\n\nexport function mergedDebugValue(ptable: ParseTable, itemGraph?: LRItemGraph): any {\n  const merged = {} as any;\n  const ptabDV = ptable.debugValue;\n  const igDV = itemGraph?.debugValue;\n  for (const stateId in ptabDV) {\n    const actions = ptabDV[stateId];\n    if (itemGraph) {\n      const items = igDV[stateId];\n      merged[stateId] = { items: items[\"items\"], actions: actions, goto: items[\"goto\"] };\n    } else {\n      merged[stateId] = actions;\n    }\n  }\n  return merged;\n}\n"],"names":["root","factory","exports","module","define","amd","this","__webpack_require__","definition","key","o","Object","defineProperty","enumerable","get","obj","prop","prototype","hasOwnProperty","call","Entity","constructor","config","TYPE","uuid","counter","_parent","metadata","Error","parent","setParent","debugValue","type","toString","equals","another","expect","clone","out","newInstance","copyTo","TimedEntity","super","duration","assert","condition","msg","MAX_INT","Math","pow","TEvent","name","source","payload","_spawnedFrom","sourceState","cancelled","timeStamp","children","spawnedFrom","setSpawnedFrom","_rootEvent","rootEvent","spawn","child","push","State","stateData","id","enter","data","handle","event","EventEmitter","_eventHub","EventHub","eventHub","hub","oldHub","eventHubChanged","console","log","_handlers","_events","_inBatchMode","on","names","callback","_addHandler","removeOn","_removeHandler","_ensurestrings","split","map","v","trim","handlerlist","handler","forEach","evHandlers","i","length","splice","emit","evt","dispatchEvent","evtCallbacks","startBatchMode","cancelBatch","commitBatch","BATCH_EVENTS","ValueList","values","_firstChild","_lastChild","_size","pushBack","toJSON","Array","from","method","tmp","count","nextSibling","eqlFunc","size","first","tmp2","isEmpty","last","reversedValues","prevSibling","add","before","prev","pushFront","value","remove","next","popBack","popFront","Browser","gcdof","x","y","abs","t","IS_EXPLORER","navigator","userAgent","indexOf","IS_FIREFOX","IS_OPERA","toLowerCase","UAHasChrome","UAHasSafari","IS_SAFARI","IS_CHROME","Fraction","num","den","factorized","isNaN","gcd","parse","val","parts","parseInt","isWhole","isZero","isInfinity","isOne","ceil","floor","plus","plusNum","minus","minusNum","times","timesNum","divby","divbyNum","numDivby","mod","d","floorOfD","modNum","inverse","equalsNum","cmp","cmpNum","isLT","isLTE","isLTNum","isLTENum","isGT","isGTE","isGTNum","isGTENum","max","f1","f2","min","ZERO","ONE","INFINITY","Frac","a","b","TSU","CycleCursor","cycle","barIndex","beatIndex","instance","currBar","bars","result","beatLengths","beatCounts","beatCount","Bar","bl","bc","assign","instanceCount","totalBeatCount","total","Cycle","p","getAtIndex","globalIndex","offset","bar","beatLength","getPosition","globalOffset","cycleNum","realOffset","barDuration","iterateBeats","startBar","startBeat","startInstance","instanceIndex","reduce","DEFAULT","AtomType","Atom","parentGroup","isContinuation","_duration","markersBefore","mbef","m","markersAfter","maft","LeafAtom","beforeRest","splitAt","spillOver","createSpilloverSpace","Space","Marker","text","isBefore","isSilent","Literal","embelishments","embs","e","Note","octave","shift","fromLit","lit","NOTE","Group","atoms","durationIsMultiplier","addAtoms","a1","a2","atom","totalChildDuration","setDurationAsMultiplier","asMultiplier","setDuration","requiredDuration","targetGroup","remainingDur","durationFactor","lastChild","childDuration","newDuration","newRequiredDur","insertAtomsAt","removeAtoms","beforeAtom","adjustDuration","oldChildDuration","REST","GROUP","LABEL","scaleFactor","LayoutParams","beatDuration","_rowStartOffsets","_rowEndOffsets","_rowDurations","_totalLayoutDuration","_totalBeats","_beatLayouts","lineBreaks","layout","lineBreaksEqual","_lineBreaks","every","_a","getBeatLocation","beat","modIndex","index","totalBeats","cursor","refreshLayout","beatLayouts","totalLayoutDuration","cycleIter","akb","numBeats","beats","nextCP","rd","GridModel","idCounter","lastUpdatedAt","rows","rowAligns","Map","colAligns","r","firstRow","gr","numCells","rowIndex","firstCol","minCol","fc","cellsInRow","row","cell","cells","cellsInCol","col","cellAt","addRowAlign","align","set","addColAlign","addRows","insertBefore","numRows","newRow","GridRow","defaultRowAlign","addSuccessor","getRow","setValue","cellCreator","grow","GridCell","clearCellAt","GridCellEvent","CLEARED","loc","location","oldValue","_b","UPDATED","gridRow","colIndex","rowAlign","_rowAlign","addCell","colAlign","_colAlign","grid","c","coordOffset","h","maxLength","w","RowAlign","numCols","creator","filter","AlignedLine","needsLayout","_coordOffset","_maxLength","paddingBefore","paddingAfter","prevLines","nextLines","setMaxLength","setPadding","after","beforeAddingCell","removeCell","beforeRemovingCell","setOffset","cellView","getCellView","evalMaxLength","setBounds","changedCells","minSize","height","Beat","role","prevBeat","nextBeat","atomIsPlaceholder","endOffset","filled","remaining","preMarkers","curr","marker","postMarkers","allMinimalCycles","nodes","idFunc","edges","cycles","inACycle","node","startNode","visited","queue","newQueue","nextNode","edgeData","n","slice","defaultKeyFunc","IDSet","keyFunc","_entries","_entriesByKey","clear","predicate","e2","modified","l","entries","getByKey","ensure","entry","throwIfExists","has","SymbolSet","grammar","enforceSymbolType","Set","hasNull","debugString","labels","sort","join","skipAux","exp","getSymById","isAuxiliary","label","addFrom","includeNull","addTo","termid","term","isTerminal","delete","NullableSet","refresh","nonterms","beforeCount","allNonTerminals","nt","visit","rule","rulesForNT","isStrNullable","rhs","isNullable","str","fromIndex","toIndex","syms","SymSymbolSets","_count","forEachTerm","visitor","entriesFor","sym","addNull","srcEntries","destEntries","FirstSets","nullables","forEachTermIn","allNullable","j","symj","forEachRule","processRule","s","FollowSets","firstSets","g","startSymbol","Eof","Sym","auxType","precedence","assocLeft","creationId","compareTo","localeCompare","Str","append","lits","extend","strs","copy","startIndex","endIndex","numToDelete","itemsToAdd","diff","containsAt","RuleAction","isFunction","isChildPosition","Rule","action","Grammar","make","symbolSet","allRules","_rulesForNT","_followSets","_hasNull","auxNTCount","auxNTPrefix","Null","newTerm","followSets","augStartRule","_AugStartRule","augmentStartSymbol","augSym","newNT","addRule","addTerminals","terminals","nonTerminals","auxNonTerminals","allSymbols","forEachNT","rules","getRule","getSym","findRule","production","findIndex","nonterm","ensureSym","removeRules","pred","removeSymbols","newRules","newRhs","sym2","T","NT","isNT","isAuxNT","seq","exps","normalizeRule","anyof","ensureAuxNT","opt","atleast0","leftRec","auxNT","findAuxNT","which","newAuxNT","atleast1","newAuxNTName","findAuxNTByRules","ntRules","print","options","ruleSep","includeSemiColon","lambdaSymbol","terminalDerivingSymbols","nadded","allDerive","reachableSymbols","fromSymbol","reachable","ruleIndex","leftRecursion","CharClassType","charCodeAt","NINE","lA","lZ","uA","uZ","USCORE","CharClassHelper","matches","charCode","neg","res","match","CharClassHelpers","reString","spaceChars","PropertyName","PropertyValue","RegexType","CharType","OpCode","Regex","groupIndex","groupName","groupIsSilent","ignoreCase","dotAll","multiline","setOptions","isVariable","evalREString","modifiers","StartOfInput","tag","START_OF_INPUT","reverse","EndOfInput","END_OF_INPUT","Assertion","expr","cond","negate","LookAhead","LOOK_AHEAD","LookBack","LOOK_BACK","Quant","minCount","maxCount","greedy","QUANT","isUnlimited","quant","Cat","CAT","Union","UNION","option","Char","op","CHAR","ch","matchChar","LeafChar","args","Any","AnyChar","Class","charClass","CharClass","Single","SingleChar","PropertyEscape","propNameOrId","propValueOrId","SyntaxError","PropertyEscapes","String","fromCharCode","replace","CharGroup","chars","CharRange","Intersection","Range","start","end","Var","reversed","VAR","BackNamedRef","BACK_NAMED_REF","BackRef","BackNumRef","BACK_NUM_REF","skip","priority","matchIndex","activeStates","stateCanActivate","state","needsSpecificStates","isNewLineChar","Match","groups","positions","Prog","startCondition","scIsInclusive","instrs","stateMapping","registerState","opcode","char","Instr","with","initializer","instrDebugValue","InstrDebugValue","instr","comment","Thread","gen","parentId","registers","regIncr","regId","regAcquire","regRelease","regValue","VM","getState","currState","setState","prog","forward","configs","threadCounter","currThreads","nextThreads","startPos","genForOffset","savePosition","thread","pos","tapeIndex","jumpBy","delta","jumpTo","newOffset","forkTo","startGroup","newThread","endGroup","addThread","list","tape","nextCh","lastCh","Jump","Split","newOff","Save","tracer","threadQueued","GroupStart","GroupEnd","StartingChar","MLStartingChar","prevCh","EndingChar","MLEndingChar","StartOfWord","EndOfWord","RBegin","groupStart","matchSuccess","matchEnd","recurseMatch","Begin","consume","EnsureState","states","matchCurrPos","currChCodeLower","currChCodeUpper","currChCode","hasMore","charAt","startMatching","bestMatch","stepChar","startOffset","savedPos","canAdvance","newPos","currMatch","nextMatch","stepThread","advance","threadStepped","advanceTape","End","currPriority","CIChar","AnyNonNL","currCh","Compiler","regexResolver","listener","emitGroups","emitPosition","compile","ensureInstr","ind","compileExpr","currOffset","compileChar","ml","START_OF_WORD","END_OF_WORD","compileCat","compileUnion","compileQuant","compileVar","compileBackNamedRef","compileBackNumRef","compileLookAhead","compileLookBack","cat","ne","union","jumps","jmp","compileAtleast0","compileAtleast1","compileOptional","l1","l3","l2","la","begin","lb","TokenizerError","message","setPrototypeOf","UnexpectedTokenError","foundToken","expectedTokens","TapeInterface","hasIndex","toUpperCase","charCodeAtLower","charCodeAtUpper","Tape","input","_rawInput","content","substring","TapeHelper","advanceAfter","pattern","ensureNoPrefixSlash","advanceTo","lastIndex","currStart","numSlashes","prefix","success","Token","lookahead","lookback","isOneOf","expected","tok","TokenBuffer","nextToken","tokenizerContext","buffer","peek","nth","matchFunc","nextAction","token","consumeIf","expectToken","ensureToken","nextMatches","GroupCounter","current","isSpace","RegexParser","unicode","reduceLeft","stack","throwError","refNum","gtPos","clPos","parseCharGroup","rest","parseGroup","parseQuant","nchars","parseChar","depth","subExpr","currch","endch","parseEscapeChar","parseSingleChar","parsePropertyEscape","clEnd","eqPos","propStr","propName","propValue","WORD_CHAR","DIGITS","SPACES","hexSeq","hexVal","ucodeSeq","ucodeVal","sub","advanceIf","ignoreSpaces","obCount","ignoreSpaces2","foundComma","p1","p2","part1","part2","foundEq","build","exprFromJSRE","exprFromFlexRE","parser","FlexREParser","error","re","isRegExp","JSREParser","flexRE","strings","keys","raw","BaseTokenizer","_prog","_vm","onError","onMatchHandlers","matchHandlersByValue","variables","compiler","findRuleByValue","getVar","addVar","regex","currValue","find","onMatch","Builder","sortedRules","sortRules","vm","r1","r2","Tokenizer","reset","owner","startChar","err","gi","toToken","tokenize","tokens","DefaultTape","SINGLE_QUOTE_STRING","DOUBLE_QUOTE_STRING","JS_REGEX","str2regex","TokenType","NodeType","LRActionType","Loader","leftRecursive","generatedTokenizer","TLEX","regexSyntax","symbolsByLabel","newSymbolCallback","tokenHandlers","symbolForLabel","registerSymbol","ensureSymbol","assumedTerminal","currSym","et","lexer","ARROW","OPEN_SQ","CLOSE_SQ","OPEN_PAREN","CLOSE_PAREN","OPEN_BRACE","CLOSE_BRACE","STAR","PLUS","QMARK","SEMI_COLON","COLON","PIPE","COMMENT","STRING","REGEX","flags","NUMBER","PCT_IDENT","DOLLAR_NUM","DOLLAR_IDENT","IDENT","tokenizer","ntFunc","parseGrammar","parseRegex","syntax","tokPattern","RegExp","patternStr","peeked","parseDecl","parseDirective","directive","startsWith","endsWith","tokenHandler","parseTokenHandler","isDef","tokName","funcName","ident","parseProductions","parseProd","PFNode","childCount","childAt","reprString","PTNode","ParserBase","setTokenizer","tokenbuffer","SimpleParser","delegate","parseInput","ParseError","LRAction","gotoState","ACCEPT","SHIFT","REDUCE","Shift","goto","Reduce","Goto","GOTO","Accept","ParseTable","conflictActions","actions","hasConflicts","getActions","stateId","addAction","ac","fromId","symId","ParseStack","stateStack","nodeStack","top","pop","popN","L","Parser","parseTable","context","buildParseTree","copySingleChild","output","resolveActions","actionResolver","onTokenError","onNextToken","nextSym","nextValue","topState","topNode","newNode","ruleLen","childNode","beforeAddingChildNode","handlerName","ruleHandlers","onReduction","newAction","LRItem","position","pre","post","LRItemSet","ig","_key","_lookaheads","_hasLookAheads","itemGraph","addLookAhead","item","s1","s2","clearLookAheads","getLookAheads","revalKey","hasLookAheads","itemId","items","i1","i2","las","LRItemGraph","gotoSets","itemSets","startItem","startSet","evalGotoSets","currSet","gotoSet","setGoto","itemSet","newItemSet","advanceItemAndAdd","closure","itemToAdvance","fromItemSet","toItemSet","newItem","laSym","ensureGotoSet","fromSet","toSet","getGoto","forEachGoto","symid","gotoSetFor","iset","LR0ItemGraph","newset","LR1ItemGraph","B","suffix","bRules","br","makeSLRParseTable","evalLASetsForSLRItem","makeSLRAutomaton","makeParseTableFromLA","nextSet","lookaheads","lr1Item","evalLASetsForLALRItem","augGrammar","prevSets","findP","prevStates","nextState","pSet","pALabel","pA","ALIAS","Symbol","for","DOC","MAP","PAIR","SCALAR","SEQ","NODE_TYPE","isAlias","isDocument","isMap","isPair","isScalar","isSeq","isCollection","isNode","hasAnchor","anchor","BREAK","SKIP","REMOVE","visitor_","initVisitor","visit_","contents","freeze","path","ctrl","callVisitor","replaceNode","concat","ci","ck","cv","async","visitAsync","visitAsync_","Collection","Node","Value","Alias","Scalar","Seq","Pair","pt","escapeChars","escapeTagName","tn","Directives","yaml","tags","docStart","docEnd","defaultYaml","defaultTags","atDocument","version","atNextDocument","explicit","line","test","tagName","verbatim","decodeURIComponent","tagString","doc","lines","tagEntries","tagNames","some","anchorIsValid","sa","JSON","stringify","applyReviver","reviver","isArray","len","v0","v1","undefined","k","toJS","arg","ctx","aliasCount","anchors","onCreate","keep","Number","NodeBase","create","getPrototypeOf","getOwnPropertyDescriptors","range","mapAsMap","maxAliasCount","onAnchor","TypeError","mapKeyWarned","resolve","found","aliasResolveCache","_arg","ReferenceError","getAliasCount","_onComment","_onChompKeep","src","verifyAliasOrder","implicitKey","kc","vc","isScalarValue","createNode","schema","Boolean","BigInt","valueOf","aliasDuplicateObjects","onTagObj","sourceObjects","ref","tagObj","format","identify","findTagObject","iterator","nodeClass","default","collectionFromPath","isInteger","keepUndefined","BLOCK_FOLDED","BLOCK_LITERAL","PLAIN","QUOTE_DOUBLE","QUOTE_SINGLE","configurable","writable","it","addIn","done","isEmptyPath","deleteIn","getIn","keepScalar","hasAllNullValues","allowScalar","commentBefore","hasIn","setIn","stringifyComment","indentComment","indent","lineComment","includes","FOLD_FLOW","FOLD_BLOCK","FOLD_QUOTED","foldFlowLines","mode","indentAtStart","lineWidth","minContentWidth","onFold","onOverflow","endStep","folds","escapedFolds","overflow","escStart","escEnd","consumeMoreIndentedLines","fold","getFoldOptions","isBlock","containsDocumentMarker","doubleQuotedString","json","doubleQuotedAsJSON","minMultiLineLength","doubleQuotedMinMultiLineLength","code","substr","singleQuotedString","singleQuote","quotedString","qs","hasDouble","hasSingle","blockEndNewlines","blockString","onComment","onChompKeep","blockQuote","commentString","forceBlockIndent","literal","indentLength","limit","strLen","lineLengthOverLimit","chomp","endStart","endNlPos","startEnd","startWithSpace","startNlPos","header","foldedValue","literalFallback","foldOptions","body","stringifyString","inFlow","ss","_stringify","_type","actualString","indentStep","compat","plainString","defaultKeyType","defaultStringType","directives","resolvedAliases","testMatch","getTagObject","props","stringifyProps","MERGE_KEY","merge","description","addToJSMap","addMergeToJSMap","mergeValue","srcMap","addPairToJSMap","isMergeKey","jsKey","stringKey","strCtx","falseStr","flowCollectionPadding","indentSeq","nullStr","simpleKeys","trueStr","toStringOptions","collectionStyle","repeat","createStringifyContext","inStringifyKey","strKey","jsonStr","warning","logLevel","warn","stringifyKey","jsValue","createPair","_","allNullValues","keyComment","explicitKey","vsb","vcb","valueComment","keyCommentDone","chompKeep","spaceBefore","flow","valueCommentDone","valueStr","ws","vs0","nl0","hasNewline","hasPropsLine","sp0","stringifyPair","stringifyCollection","collection","stringifyFlowCollection","stringifyBlockCollection","blockItemPrefix","flowChars","itemIndent","itemCtx","addCommentBefore","ik","fcPadding","reqNewline","linesAtValue","iv","sum","ic","trimStart","findPair","YAMLMap","replacer","sortMapEntries","pair","overwrite","_pair","sortEntries","Type","YAMLSeq","idx","asItemIndex","string","nullTag","boolTag","stringifyNumber","minFractionDigits","isFinite","is","floatNaN","NaN","NEGATIVE_INFINITY","POSITIVE_INFINITY","floatExp","parseFloat","toExponential","intIdentify","intResolve","radix","intAsBigInt","intStringify","_onError","dot","stringifyJSON","binary","Uint8Array","atob","buf","btoa","resolvePairs","cn","createPairs","iterable","pairs","YAMLOMap","bind","omap","seenKeys","boolStringify","trueTag","falseTag","float","f","sign","intBin","intOct","int","intHex","YAMLSet","keepPair","parseSexagesimal","asBigInt","stringifySexagesimal","_60","unshift","padStart","intTime","floatTime","timestamp","Date","year","month","day","hour","minute","second","millisec","date","UTC","tz","toISOString","schema$1","schema$2","cst","_visit","field","GamakaType","itemAtPath","parentCollection","coll","Shape","shapeId","_x","_y","_width","_height","parentShape","bbox","_bbox","refreshBBox","_minSize","refreshMinSize","invalidateBounds","applyLayout","nx","ny","nw","nh","updateBounds","hasX","hasY","hasWidth","hasHeight","width","params","ptable","tokenFunc","eparser","debug","loadGrammar","makeLRParseTable","g2","ensureG2Sym","pi","newSymLabel","newSym","startState","transitions","buildRuleFrom","A","newSyms","xi","startSym","newA","newRHS","newRule","grammarFromLR0ItemGraph","makeLALRParseTable","makeParseTable","newParseTable","merged","ptabDV","igDV","mergedDebugValue","logParserDebug","G","toEmbelishment","emb","parseEmbelishment","errors","toCommandName","_tape","_owner","toBoolean","toNumber","toMarker","markerText","toOctavedNote","note","toRoleSelector","toLineAnnotation","toSingleLineRawString","toMultiLineRawString","endPat","endPos","toFrontMatter"],"ignoreList":[],"sourceRoot":""}