{"version":3,"file":"9ba789b57e20f6c48d9f5a8e126a91ee15f1d86e-dc74dbab266202d614b3.js","mappings":";oHAEAA,EAAOC,QAEP,SAAcC,GACZ,GAAIA,EACF,MAAMA,kCCJV,IAAIC,EAASC,OAAOC,UAAUC,eAC1BC,EAAQH,OAAOC,UAAUG,SACzBC,EAAiBL,OAAOK,eACxBC,EAAON,OAAOO,yBAEdC,EAAU,SAAiBC,GAC7B,MAA6B,mBAAlBC,MAAMF,QACRE,MAAMF,QAAQC,GAGI,mBAApBN,EAAMQ,KAAKF,IAGhBG,EAAgB,SAAuBC,GACzC,IAAKA,GAA2B,oBAApBV,EAAMQ,KAAKE,GACrB,OAAO,EAGT,IASIC,EATAC,EAAoBhB,EAAOY,KAAKE,EAAK,eACrCG,EAAmBH,EAAII,aAAeJ,EAAII,YAAYhB,WAAaF,EAAOY,KAAKE,EAAII,YAAYhB,UAAW,iBAE9G,GAAIY,EAAII,cAAgBF,IAAsBC,EAC5C,OAAO,EAOT,IAAKF,KAAOD,GAIZ,YAAsB,IAARC,GAAuBf,EAAOY,KAAKE,EAAKC,IAIpDI,EAAc,SAAqBC,EAAQC,GACzCf,GAAmC,cAAjBe,EAAQC,KAC5BhB,EAAec,EAAQC,EAAQC,KAAM,CACnCC,YAAY,EACZC,cAAc,EACdC,MAAOJ,EAAQK,SACfC,UAAU,IAGZP,EAAOC,EAAQC,MAAQD,EAAQK,UAK/BE,EAAc,SAAqBd,EAAKQ,GAC1C,GAAa,cAATA,EAAsB,CACxB,IAAKtB,EAAOY,KAAKE,EAAKQ,GACpB,OACK,GAAIf,EAGT,OAAOA,EAAKO,EAAKQ,GAAMG,MAI3B,OAAOX,EAAIQ,IAGbzB,EAAOC,QAAU,SAAS+B,IACxB,IAAIR,EAASC,EAAMQ,EAAKC,EAAMC,EAAaC,EACvCb,EAASc,UAAU,GACnBC,EAAI,EACJC,EAASF,UAAUE,OACnBC,GAAO,EAaX,IAXsB,kBAAXjB,IACTiB,EAAOjB,EACPA,EAASc,UAAU,IAAM,GAEzBC,EAAI,IAGQ,MAAVf,GAAoC,iBAAXA,GAAyC,mBAAXA,KACzDA,EAAS,IAGJe,EAAIC,IAAUD,EAGnB,GAAe,OAFfd,EAAUa,UAAUC,IAIlB,IAAKb,KAAQD,EACXS,EAAMF,EAAYR,EAAQE,GAGtBF,KAFJW,EAAOH,EAAYP,EAASC,MAItBe,GAAQN,IAASlB,EAAckB,KAAUC,EAAcvB,EAAQsB,MAC7DC,GACFA,GAAc,EACdC,EAAQH,GAAOrB,EAAQqB,GAAOA,EAAM,IAEpCG,EAAQH,GAAOjB,EAAciB,GAAOA,EAAM,GAI5CX,EAAYC,EAAQ,CAClBE,KAAMA,EACNI,SAAUG,EAAOQ,EAAMJ,EAAOF,WAEP,IAATA,GAChBZ,EAAYC,EAAQ,CAClBE,KAAMA,EACNI,SAAUK,KAStB,OAAOX,qBCnHTvB,EAAOC,QAAU,SAAkBgB,GACjC,OAAc,MAAPA,GAAkC,MAAnBA,EAAII,aAA2D,mBAA7BJ,EAAII,YAAYoB,UAA2BxB,EAAII,YAAYoB,SAASxB,mCCL9HjB,EAAOC,QAAU,SAAU2B,GACzB,GAA8C,oBAA1CxB,OAAOC,UAAUG,SAASO,KAAKa,GACjC,OAAO,EAGT,IAAIvB,EAAYD,OAAOsC,eAAed,GACtC,OAAqB,OAAdvB,GAAsBA,IAAcD,OAAOC,iCCRpD,IAAIsC,EAAmB,EAAQ,MAyB/B3C,EAAOC,QAvBP,WACE,OAAO,SAAU2C,GAkBf,OAjBAD,EAAiBC,EAAK,QAAQ,SAAUC,EAAUC,GAChD,IACIR,EACAS,EAFAC,EAAQ,EAIZ,IAAKV,EAAI,EAAGS,EAAID,EAAQP,OAAQD,EAAIS,EAAGT,IACb,SAApBQ,EAAQR,GAAGW,OAAiBD,GAAS,GAG3C,IAAKV,EAAI,EAAGS,EAAIF,EAASK,SAASX,OAAQD,EAAIS,EAAGT,IAAK,CACpD,IAAIa,EAAQN,EAASK,SAASZ,GAC9Ba,EAAMC,MAAQd,EACda,EAAME,QAAUR,EAASQ,QAG3BR,EAASG,MAAQA,KAEZJ,mCClBX5C,EAAOC,QAGP,SAAsBqD,EAAML,EAAMM,GAChC,IAAIC,EAAQ,GAEQ,mBAATP,IACTM,EAAUN,EACVA,EAAO,MAMT,SAASQ,EAAIC,GACX,IAAIC,EAMJ,OAJKV,GAAQS,EAAKT,OAASA,IACzBU,EAASJ,EAAQG,EAAMF,EAAMI,WAG3BF,EAAKR,WAAuB,IAAXS,EASvB,SAAaT,EAAUW,GACrB,IAEIV,EAFAZ,EAASW,EAASX,OAClBa,GAAS,EAEbI,EAAMM,KAAKD,GAEX,OAAST,EAAQb,GAGf,IAFAY,EAAQD,EAASE,MAEW,IAAfK,EAAIN,GACf,OAAO,EAKX,OADAK,EAAMO,OACC,EAvBEC,CAAIN,EAAKR,SAAUQ,GAGrBC,EAdTF,EAAIH,oCCJN,IAAIW,EAAI,mBAAsBC,QAAUA,OAAOC,IAC3CC,EAAIH,EAAIC,OAAOC,IAAI,iBAAmB,MACtCE,EAAIJ,EAAIC,OAAOC,IAAI,gBAAkB,MACrCG,EAAIL,EAAIC,OAAOC,IAAI,kBAAoB,MACvCI,EAAIN,EAAIC,OAAOC,IAAI,qBAAuB,MAC1CK,EAAIP,EAAIC,OAAOC,IAAI,kBAAoB,MACvCM,EAAIR,EAAIC,OAAOC,IAAI,kBAAoB,MACvCO,EAAIT,EAAIC,OAAOC,IAAI,iBAAmB,MACtCQ,EAAIV,EAAIC,OAAOC,IAAI,oBAAsB,MACzCS,EAAIX,EAAIC,OAAOC,IAAI,yBAA2B,MAC9CpB,EAAIkB,EAAIC,OAAOC,IAAI,qBAAuB,MAC1CU,EAAIZ,EAAIC,OAAOC,IAAI,kBAAoB,MACvCW,EAAIb,EAAIC,OAAOC,IAAI,uBAAyB,MAC5CY,EAAId,EAAIC,OAAOC,IAAI,cAAgB,MACnCa,EAAIf,EAAIC,OAAOC,IAAI,cAAgB,MACnCc,EAAIhB,EAAIC,OAAOC,IAAI,eAAiB,MACpCe,EAAIjB,EAAIC,OAAOC,IAAI,qBAAuB,MAC1CgB,EAAIlB,EAAIC,OAAOC,IAAI,mBAAqB,MACxCiB,EAAInB,EAAIC,OAAOC,IAAI,eAAiB,MAExC,SAASkB,EAAEC,GACT,GAAI,iBAAoBA,GAAK,OAASA,EAAG,CACvC,IAAIC,EAAID,EAAEE,SAEV,OAAQD,GACN,KAAKnB,EACH,OAAQkB,EAAIA,EAAErC,MACZ,KAAK0B,EACL,KAAKC,EACL,KAAKN,EACL,KAAKE,EACL,KAAKD,EACL,KAAKM,EACH,OAAOS,EAET,QACE,OAAQA,EAAIA,GAAKA,EAAEE,UACjB,KAAKd,EACL,KAAK3B,EACL,KAAKiC,EACL,KAAKD,EACL,KAAKN,EACH,OAAOa,EAET,QACE,OAAOC,GAKjB,KAAKlB,EACH,OAAOkB,IAKf,SAASE,EAAEH,GACT,OAAOD,EAAEC,KAAOV,EAGlB3E,EAAQyF,UAAYf,EACpB1E,EAAQ0F,eAAiBf,EACzB3E,EAAQ2F,gBAAkBlB,EAC1BzE,EAAQ4F,gBAAkBpB,EAC1BxE,EAAQ6F,QAAU1B,EAClBnE,EAAQ8F,WAAahD,EACrB9C,EAAQ+F,SAAW1B,EACnBrE,EAAQgG,KAAOjB,EACf/E,EAAQiG,KAAOnB,EACf9E,EAAQkG,OAAS9B,EACjBpE,EAAQmG,SAAW5B,EACnBvE,EAAQoG,WAAa9B,EACrBtE,EAAQqG,SAAWzB,EAEnB5E,EAAQsG,YAAc,SAAUjB,GAC9B,OAAOG,EAAEH,IAAMD,EAAEC,KAAOX,GAG1B1E,EAAQuG,iBAAmBf,EAE3BxF,EAAQwG,kBAAoB,SAAUnB,GACpC,OAAOD,EAAEC,KAAOZ,GAGlBzE,EAAQyG,kBAAoB,SAAUpB,GACpC,OAAOD,EAAEC,KAAOb,GAGlBxE,EAAQ0G,UAAY,SAAUrB,GAC5B,MAAO,iBAAoBA,GAAK,OAASA,GAAKA,EAAEE,WAAapB,GAG/DnE,EAAQ2G,aAAe,SAAUtB,GAC/B,OAAOD,EAAEC,KAAOvC,GAGlB9C,EAAQ4G,WAAa,SAAUvB,GAC7B,OAAOD,EAAEC,KAAOhB,GAGlBrE,EAAQ6G,OAAS,SAAUxB,GACzB,OAAOD,EAAEC,KAAON,GAGlB/E,EAAQ8G,OAAS,SAAUzB,GACzB,OAAOD,EAAEC,KAAOP,GAGlB9E,EAAQ+G,SAAW,SAAU1B,GAC3B,OAAOD,EAAEC,KAAOjB,GAGlBpE,EAAQgH,WAAa,SAAU3B,GAC7B,OAAOD,EAAEC,KAAOd,GAGlBvE,EAAQiH,aAAe,SAAU5B,GAC/B,OAAOD,EAAEC,KAAOf,GAGlBtE,EAAQkH,WAAa,SAAU7B,GAC7B,OAAOD,EAAEC,KAAOT,GAGlB5E,EAAQmH,mBAAqB,SAAU9B,GACrC,MAAO,iBAAoBA,GAAK,mBAAsBA,GAAKA,IAAMhB,GAAKgB,IAAMV,GAAKU,IAAMd,GAAKc,IAAMf,GAAKe,IAAMT,GAAKS,IAAMR,GAAK,iBAAoBQ,GAAK,OAASA,IAAMA,EAAEE,WAAaR,GAAKM,EAAEE,WAAaT,GAAKO,EAAEE,WAAaf,GAAKa,EAAEE,WAAad,GAAKY,EAAEE,WAAazC,GAAKuC,EAAEE,WAAaN,GAAKI,EAAEE,WAAaL,GAAKG,EAAEE,WAAaJ,GAAKE,EAAEE,WAAaP,IAGtVhF,EAAQoH,OAAShC,qCCvIfrF,EAAOC,QAAU,EAAjB,wCCDF,IAAIqH,EAAQ,EAAQ,MAEhBC,EAAQ,EAAQ,MAEhBC,EAAU,EAAQ,MAEtB,SAASC,EAAW/D,EAAMlC,GACxB,IAAIqC,EAASxB,UAAUE,OAAS,QAAsBmF,IAAjBrF,UAAU,GAAmBA,UAAU,GAAK,GAC7Ee,EAAQf,UAAUE,OAAS,QAAsBmF,IAAjBrF,UAAU,GAAmBA,UAAU,GAAK,EAC5EsF,EAAWnG,EAAQoG,UAAUlE,EAAKT,MAGjCS,EAAKmE,WACRnE,EAAKmE,SAAW,CACdC,MAAO,CACLC,KAAM,KACNC,OAAQ,KACRC,OAAQ,MAEVC,IAAK,CACHH,KAAM,KACNC,OAAQ,KACRC,OAAQ,QAKd,IAAIE,EAAMzE,EAAKmE,SAASC,MACpB5G,EAAM,CAACwC,EAAKT,KAAMkF,EAAIJ,KAAMI,EAAIH,OAAQ5E,GAAOgF,KAAK,KAExD,IAAKZ,EAAQJ,mBAAmBO,GAC9B,MAAM,IAAIU,MAAM,sBAAsBzE,OAAOF,EAAKT,KAAM,uCAG1D,IAAIqF,EAAYC,EAAa7E,EAAMxC,EAAKM,EAASmG,EAAU9D,EAAQT,GACnE,OAAOkE,EAAMkB,cAAcb,EAAUW,EAAWA,EAAUpF,UAAYuF,UAAqBf,GAE3F,SAASe,IACP,OAAO/E,EAAKR,UAAYQ,EAAKR,SAASwF,KAAI,SAAUC,EAAWrG,GAC7D,OAAOmF,EAAWkB,EAAWnH,EAAS,CACpCkC,KAAMA,EACNkF,MAAON,GACNhG,OAMT,SAASiG,EAAa7E,EAAMxC,EAAK2H,EAAMlB,EAAU9D,EAAQT,GACvD,IA0MuB+E,EA1MnBS,EAAQ,CACV1H,IAAKA,GAEH4H,EAAuC,iBAAbnB,GAAyBA,IAAaL,EAAMtB,SAEtE6C,EAAKE,WAAarF,EAAKmE,WACzBe,EAAM,kBAqMD,EADgBT,EApMqBzE,EAAKmE,UAqMrCC,MAAMC,KAAM,IAAKI,EAAIL,MAAME,OAAQ,IAAKG,EAAID,IAAIH,KAAM,IAAKI,EAAID,IAAIF,QAAQU,IAAIM,QAAQZ,KAAK,KAlMpGS,EAAKI,eAAiBH,IACxBF,EAAMM,eAAiBxF,EAAKmE,UAI1BgB,EAAKM,kBAAoBtF,EAAOH,MAAQG,EAAOH,KAAKR,WAAa4F,IACnEF,EAAMxF,MAAQS,EAAOH,KAAKR,SAASkG,QAAQ1F,GAC3CkF,EAAMS,iBAAmBxF,EAAOH,KAAKR,SAASX,QAGhD,IAAI+G,EAA0B,OAApB5F,EAAK6F,iBAA2C7B,IAApBhE,EAAK6F,WAE3CV,EAAKW,YAAY9F,EAAK6F,WAAWE,gBAAkB,GAAK,KAExD,OAAQ/F,EAAKT,MACX,IAAK,OACHyG,EAAcd,EAAO,CACnBe,UAAWd,EAAKc,YAElB,MAEF,IAAK,OACHf,EAAMgB,QAAU1I,EAChB0H,EAAM1F,SAAWQ,EAAK9B,MACtB,MAEF,IAAK,UACHgH,EAAMiB,MAAQnG,EAAKV,MACnB,MAEF,IAAK,OACH4F,EAAMd,MAAQpE,EAAKoE,MACnBc,EAAMvF,QAAUK,EAAKL,QACrBuF,EAAMkB,OAASpG,EAAKoG,OACpBlB,EAAM5F,MAAQU,EAAKV,MACnB,MAEF,IAAK,WACH4F,EAAMmB,QAAUrG,EAAKqG,QACrBnB,EAAMkB,OAASpG,EAAKoG,OACpBlB,EAAMvF,QAAUK,EAAKL,QACrBuF,EAAMxF,MAAQM,EAAKN,MACnBwF,EAAM1F,SA2JZ,SAA6BQ,EAAMG,GAGjC,OADYA,GAAUA,EAAOH,KAU/B,SAAmBA,GACjB,IAAIR,EAAWQ,EAAKR,SAChB8G,EAAQtG,EAAKoG,OACb1G,GAAS,EAEb,MAAQ4G,KAAW5G,EAAQF,EAASX,QAClCyH,EAAQC,EAAc/G,EAASE,IAGjC,OAAO4G,EAnB6BE,CAAUrG,EAAOH,MAAQuG,EAAcvG,IAC5DA,EAAKR,SAGtB,SAA0BQ,GACxB,OAAOA,EAAKR,SAASiH,QAAO,SAAUC,EAAOjH,GAC3C,OAAOiH,EAAMxG,OAAsB,cAAfT,EAAMF,KAAuBE,EAAMD,SAAW,CAACC,MAClE,IAN4BkH,CAAiB3G,GA9J3B4G,CAAoB5G,EAAMG,GAAQ6E,KAAI,SAAUC,EAAWrG,GAC1E,OAAOmF,EAAWkB,EAAWE,EAAM,CACjCnF,KAAMA,EACNkF,MAAOA,GACNtG,MAEL,MAEF,IAAK,aACHoH,EAAcd,EAAO,CACnBW,WAAY7F,EAAK6F,WACjBgB,MAAO7G,EAAK6G,MACZC,IAAK9G,EAAK8G,MAEZ,MAEF,IAAK,OACHd,EAAcd,EAAO,CACnB6B,SAAU/G,EAAKgH,MAAQhH,EAAKgH,KAAKC,MAAM,KAAM,GAAG,KAElD,MAEF,IAAK,aACH/B,EAAM1F,SAAWQ,EAAK9B,MACtBgH,EAAMgC,QAAS,EACf,MAEF,IAAK,OACHlB,EAAcd,EAAO,CACnB2B,MAAO7G,EAAK6G,YAAS7C,EACrBnG,OAAmC,mBAApBsH,EAAKgC,WAA4BhC,EAAKgC,WAAWnH,EAAK8G,IAAK9G,EAAKR,SAAUQ,EAAK6G,OAAS1B,EAAKgC,WAC5GC,KAAMjC,EAAKkC,iBAAmBlC,EAAKkC,iBAAiBrH,EAAK8G,IAAK9G,EAAKR,SAAUQ,EAAK6G,OAAS7G,EAAK8G,MAElG,MAEF,IAAK,QACHd,EAAcd,EAAO,CACnB3G,IAAK4G,EAAKmC,kBAAoBnC,EAAKmC,kBAAkBtH,EAAK8G,IAAK9G,EAAKR,SAAUQ,EAAK6G,MAAO7G,EAAKuH,KAAOvH,EAAK8G,IAC3GS,IAAKvH,EAAKuH,KAAO,GACjBV,MAAO7G,EAAK6G,YAAS7C,IAEvB,MAEF,IAAK,gBACHgC,EAAcd,EAAOrB,EAAM+B,EAAK,CAC9BwB,KAAMjC,EAAKkC,iBAAmBlC,EAAKkC,iBAAiBzB,EAAIwB,MAAQxB,EAAIwB,QAEtE,MAEF,IAAK,iBACHpB,EAAcd,EAAO,CACnB3G,IAAK4G,EAAKmC,mBAAqB1B,EAAIwB,KAAOjC,EAAKmC,kBAAkB1B,EAAIwB,KAAMpH,EAAKR,SAAUoG,EAAIiB,MAAO7G,EAAKuH,KAAO3B,EAAIwB,KACrHG,IAAKvH,EAAKuH,KAAO,GACjBV,MAAOjB,EAAIiB,YAAS7C,IAEtB,MAEF,IAAK,QACL,IAAK,YACL,IAAK,YACHkB,EAAMsC,gBAAkBxH,EAAKyH,MAC7B,MAEF,IAAK,WACHvC,EAAMwC,SAAgC,cAArBvH,EAAOH,KAAKT,KAC7B2F,EAAMsC,gBAAkBrH,EAAO+E,MAAMsC,gBACrC,MAEF,IAAK,YACHxB,EAAcd,EAAO,CACnBwC,SAAUvH,EAAO+E,MAAMwC,SACvBD,MAAOtH,EAAO+E,MAAMsC,gBAAgB9H,KAEtC,MAEF,IAAK,cACHwF,EAAMyC,IAAM3H,EAAK2H,IACjB,MAEF,IAAK,OAEHzC,EAAM0C,QAAU5H,EAAKmE,SAASC,MAAMC,OAASrE,EAAKmE,SAASK,IAAIH,KAC/Da,EAAM2C,mBAAqB1C,EAAK0C,mBAChC3C,EAAM4C,WAAa3C,EAAK2C,WACxB5C,EAAM6C,SAAW5C,EAAK4C,SACtB,MAEF,IAAK,aAED,IAAIC,EAEAhI,EAAKR,WACPwI,EAAiBhI,EAAKR,SAASwF,KAAI,SAAUvF,EAAOb,GAClD,OAAOmF,EAAWtE,EAAO0F,EAAM,CAC7BnF,KAAMA,EACNkF,MAAOA,GACNtG,OAIPsG,EAAM2C,mBAAqB1C,EAAK0C,mBAChC3C,EAAM4C,WAAa3C,EAAK2C,WACxB5C,EAAM6C,SAAW5C,EAAK4C,SACtB7C,EAAM+C,QAAUjI,EAAKiI,QA+B7B,SAA2BjI,EAAMgI,GAC/B,IAAIE,EAAKlI,EAAKiI,QAEd,GAAI7K,MAAMF,QAAQgL,GAAK,CAErB,IAAI5F,EAAWsB,EAAMtB,UAAY,MACjC,OAAOsB,EAAMkB,cAAcxC,EAAU,KAAM4F,GAG7C,GAAIA,EAAGhD,MAAM1F,UAAYwI,EAAgB,CACvC,IAAIxI,EAAWoE,EAAMuE,SAASC,QAAQF,EAAGhD,MAAM1F,UAAUU,OAAO8H,GAChE,OAAOpE,EAAMyE,aAAaH,EAAI,KAAM1I,GAGtC,OAAOoE,EAAMyE,aAAaH,EAAI,MA7COI,CAAkBtI,EAAMgI,GAAkB,KACzE,MAGJ,QACEhC,EAAcd,EAAOrB,EAAM7D,EAAM,CAC/BT,UAAMyE,EACNG,cAAUH,EACVxE,cAAUwE,KAYhB,OARKoB,GAAoBpF,EAAK9B,QAC5BgH,EAAMhH,MAAQ8B,EAAK9B,OAGhBkH,IACHF,EAAMlF,KAAOA,GAGRkF,EAGT,SAASc,EAAcnI,EAAQ0K,GAC7B,IAAK,IAAI/K,KAAO+K,OACY,IAAfA,EAAM/K,KACfK,EAAOL,GAAO+K,EAAM/K,IAkD1B,SAAS+I,EAAcvG,GACrB,IAAIoG,EAASpG,EAAKoG,OAGlB,OAAOA,MAAAA,EAA0CpG,EAAKR,SAASX,OAAS,EAAIuH,EAG9E9J,EAAOC,QAAUwH,qCC9RjB,IAAIyE,EAAQ,EAAQ,MAEpBlM,EAAOC,QAAU,SAAwBqD,GACvC,IAAIkG,EAAcnH,UAAUE,OAAS,QAAsBmF,IAAjBrF,UAAU,GAAmBA,UAAU,GAAK,GAStF,OARA6J,EAAM5I,EAAM,cAAc,SAAUI,GAClC,IAAI6F,EAAa7F,EAAK6F,WAAWE,cAC7BF,KAAcC,IAClBA,EAAYD,GAAc,CACxBuB,KAAMpH,EAAK8G,IACXD,MAAO7G,EAAK6G,WAGTf,sCCZT,IAAI0C,EAAQ,EAAQ,MAEhBC,EAAS,GAAGA,OAYhB,SAASC,EAAWC,EAAOC,GACzB,OAEA,SAAmBhJ,GAEjB,OADA4I,EAAM5I,EAAMiJ,GACLjJ,GAIT,SAASiJ,EAAO7I,EAAMN,EAAOS,GAC3B,GAAIA,IAAWwI,EAAM3I,EAAMN,EAAOS,GAAS,CACzC,IAAI2I,EAAa,CAACpJ,EAAO,GAOzB,MALa,WAATkJ,GAAqB5I,EAAKR,WAC5BsJ,EAAaA,EAAW5I,OAAOF,EAAKR,WAGtCiJ,EAAOM,MAAM5I,EAAOX,SAAUsJ,GACvBpJ,IA5BbnD,EAAQyM,OAAS,SAAUC,EAAOL,GAChC,OAAOF,GAEP,SAAe1I,EAAMN,EAAOS,GAC1B,OAAQ8I,EAAMC,SAASlJ,EAAKT,QAHLqJ,IAO3BrM,EAAQmM,WAAaA,qCCPrB,IAAIF,EAAQ,EAAQ,MAEhBjJ,EAAO,cACP4J,EAAgB,2FAChBC,EAAc,uBAElB9M,EAAOC,QAAU,SAAUqD,GACzB,IAAIyJ,EACAC,EAmCJ,OAlCAd,EAAM5I,EAAM,QAAQ,SAAUI,EAAMN,EAAOS,GACrCmJ,IAAkBnJ,IACpBkJ,EAAO,GACPC,EAAgBnJ,GAGlB,IAAIoJ,EAoDR,SAAwBvJ,GACtB,IAAIwJ,EAAQxJ,EAAK9B,MAAMsL,MAAML,GAC7B,QAAOK,GAAQA,EAAM,GAtDDC,CAAezJ,GAEjC,GAAIuJ,EAMF,OALApJ,EAAOX,SAASiJ,OAAO/I,EAAO,EAAG,CAC/BH,KAAMA,EACNoI,IAAK4B,EACLpF,SAAUnE,EAAKmE,YAEV,EAGT,IAAIuF,EAgCR,SAAsB1J,EAAMG,GAC1B,IAAIqJ,EAAQxJ,EAAK9B,MAAMsL,MAAMJ,GAC7B,QAAOI,GAAQ,CACb7B,IAAK6B,EAAM,GACXG,SAAUH,EAAM,GAChBxJ,KAAMA,GArCQ4J,CAAa5J,GAE3B,IAAK0J,EACH,OAAO,EAGT,IAAIG,EAcR,SAAqBR,EAAMS,GACzB,IAAIlL,EAAIyK,EAAKxK,OAEb,KAAOD,KACL,GAAIyK,EAAKzK,GAAG+I,MAAQmC,EAClB,OAAOT,EAAKZ,OAAO7J,EAAG,GAAG,GAI7B,OAAO,EAvBUmL,CAAYV,EAAMK,EAAQ/B,KAQzC,OANIkC,EACF1J,EAAOX,SAASiJ,OAAO/I,EAAO,EAqCpC,SAAiBsK,EAAUC,EAAQ9J,GACjC,IAAI+J,EAAY/J,EAAOX,SAASkG,QAAQsE,EAAShK,MAC7CmK,EAAUhK,EAAOX,SAASkG,QAAQuE,EAAOjK,MAEzCR,EADYW,EAAOX,SAASiJ,OAAOyB,EAAWC,EAAUD,EAAY,GAC/CE,MAAM,GAAI,GACnC,MAAO,CACL7K,KAAMA,EACNC,SAAUA,EACVmI,IAAKqC,EAASrC,IACdxD,SAAU,CACRC,MAAO4F,EAAShK,KAAKmE,SAASC,MAC9BI,IAAKyF,EAAOjK,KAAKmE,SAASK,IAC1B6F,OAAQ,KAjDyBC,CAAQZ,EAASG,EAAU1J,IAClDuJ,EAAQC,SAClBN,EAAKjJ,KAAKsJ,IAGL,KACN,GAEI9J,sCChDT,IAAIiE,EAAQ,EAAQ,MAEhB0G,EAAU,EAAQ,MAElBC,EAAQ,EAAQ,MAEhBC,EAAY,EAAQ,MAEpBC,EAAkB,EAAQ,MAE1BC,EAAY,EAAQ,MAEpBC,EAAe,EAAQ,MAEvB7G,EAAa,EAAQ,MAErB8G,EAAgB,EAAQ,MAExBC,EAAiB,EAAQ,MAEzBC,EAAiB,EAAQ,MAEzBC,EAAmB,EAAQ,MAE3BC,EAAU,EAAQ,MAElBC,EAAWxO,OAAOyO,KAAKH,GAEvBI,EAAgB,SAAuBlG,GAEzC,IAAI3G,EAAM2G,EAAMmG,QAAUnG,EAAM1F,UAAY,GAE5C,GAAI0F,EAAMoG,cAAgBpG,EAAMqG,gBAC9B,MAAM,IAAI5G,MAAM,sEAGlB,IAAIT,EAAYL,EAAMmH,EAAkB9F,EAAMhB,WAC1CsH,EAAYjB,IAAUkB,IAAIjB,GAAOiB,IAAIvG,EAAMwG,SAAW,IAEtD9L,EAAO4L,EAAUG,QAAQH,EAAUhB,MAAMjM,IACzCqN,EAAc/H,EAAMqB,EAAO,CAC7BhB,UAAWA,EACX4B,YAAagF,EAAelL,KAK9B,OAGF,SAAuCsF,GACrC,IAAI2G,EAAa,CAAChB,EAAeH,KAC7Ba,EAAkBrG,EAAMqG,gBAExBrG,EAAMoG,eACRC,EAAkBL,EAASrC,QAAO,SAAUtJ,GAC1C,MAAgB,SAATA,IAAyD,IAAtC2F,EAAMoG,aAAa5F,QAAQnG,OAIzD,IAAIuM,EAAgB5G,EAAM6G,iBAAmB,SAAW,SAEpDR,GAAmBA,EAAgB1M,OAAS,GAC9CgN,EAAWzL,KAAKwK,EAAa5B,OAAOuC,EAAiBO,IAGnD5G,EAAM8G,WACRH,EAAWzL,KAAKwK,EAAalC,WAAWxD,EAAM8G,UAAWF,IAI3D,IAAIG,GAAc/G,EAAM2C,qBAA2C,IAArB3C,EAAM4C,cAA0B5C,EAAM6C,SAChFmE,GAAiBhH,EAAMiH,YAAc,IAAIC,MAAK,SAAUC,GAC1D,OAAOA,EAAUC,WAAarB,EAAQsB,cAGpCN,IAAeC,GACjBL,EAAWzL,KAAKuK,GAGdzF,EAAMiH,aACRN,EAAaA,EAAW3L,OAAOgF,EAAMiH,aAKvC,OADAN,EAAWzL,KAAK2D,GACT8H,EA1CPW,CAA8BtH,GAAOuH,SAAQ,SAAUJ,GACrDzM,EAAOyM,EAAUzM,EAAMgM,MAElBhM,GA0CTwL,EAAcsB,aAAe,CAC3BrF,iBAAkB0D,GAEpBK,EAAcuB,UAAY,CACxB1G,UAAWwE,EAAUmC,OACrBvB,OAAQZ,EAAUmC,OAClBpN,SAAUiL,EAAUmC,OACpBvH,UAAWoF,EAAUoC,KACrBtH,aAAckF,EAAUoC,KACxB/E,WAAY2C,EAAUoC,KACtBhF,mBAAoB4C,EAAUoC,KAC9B9E,SAAU0C,EAAUoC,KACpBb,UAAWvB,EAAUqC,KACrBxB,aAAcb,EAAUsC,QAAQtC,EAAUuC,MAAM9B,IAChDK,gBAAiBd,EAAUsC,QAAQtC,EAAUuC,MAAM9B,IACnD7D,iBAAkBoD,EAAUwC,UAAU,CAACxC,EAAUqC,KAAMrC,EAAUoC,OACjE1F,WAAYsD,EAAUwC,UAAU,CAACxC,EAAUqC,KAAMrC,EAAUmC,SAC3DtF,kBAAmBmD,EAAUqC,KAC7BX,WAAY1B,EAAUsC,QAAQtC,EAAUqC,MACxCf,iBAAkBtB,EAAUoC,KAC5B3I,UAAWuG,EAAUyC,OACrBxB,QAASjB,EAAU/D,OAErB0E,EAAcnC,MAAQiC,EACtBE,EAAclH,UAAY8G,EAC1BI,EAAcL,eAAiBA,EAC/BzO,EAAOC,QAAU6O,qCClHjB,IAAIvH,EAAQ,EAAQ,MAEhBD,EAAQ,EAAQ,MAIhBuJ,EAAuBC,UAAUxJ,EAAMyJ,SAAW,MAAMjD,MAAM,EAAG,GAAI,KAAO,GAC5EtF,EAAgBlB,EAAMkB,cA+C1B,SAASwI,EAAe3F,EAAKzC,GAC3B,OAAOJ,EAAc6C,EAAK4F,EAAarI,GAAQA,EAAM1F,UA0FvD,SAAS+N,EAAarI,GACpB,IAAImG,EAASnG,EAAM,kBAGnB,OAAOmG,EAAS,CACd,iBAAkBA,GAChB,GA/IN/O,EAAOC,QAAU,CACfiR,MAAO,KACPC,UAAW,IACXC,SAAU,KACVC,OAAQ,SACRC,cAAe,KACfC,WAAY,aACZC,OAAQ,MACRC,KAAM,IACNC,MAAO,MACPC,cAAe,IACfC,eAAgB,MAChBC,MAAOb,EAAec,KAAK,KAAM,SACjCC,UAAWf,EAAec,KAAK,KAAM,SACrCE,UAAWhB,EAAec,KAAK,KAAM,SACrCG,SAAUjB,EAAec,KAAK,KAAM,MACpCI,UAkCF,SAAmBtJ,GACjB,IAAIuJ,EAAQvJ,EAAMuC,MAAQ,CACxBiH,UAAWxJ,EAAMuC,YACfzD,EACA2K,EAAYpB,EAAarI,GAC7B,OAAOJ,EAAcI,EAAMwC,SAAW,KAAO,KAAM+G,EAAQ5K,EAAM,CAC/D4K,MAAOA,GACNE,GAAaA,EAAWzJ,EAAM1F,WAxCjCoP,KAqBF,SAAc1J,GACZ,IAAIe,EAAYf,EAAMe,UAClB2I,GAAQ3I,GAAarC,EAAMtB,UAAY,MAC3C,OAAOwC,EAAc8J,EAAM3I,EAAY,CACrCA,UAAWA,GACT,KAAMf,EAAM1F,WAzBhBqP,KAYF,SAAsB3J,GAEpB,IAAI1F,EAAW0F,EAAM1F,UAAY,GAGjC,OAAO2N,EAAuB3N,EAAWsF,EAAc,OAAQ,KAAMtF,IAhBrEsP,KA6CF,SAAc5J,GACZ,IAAIqD,EAAQgF,EAAarI,GAEL,OAAhBA,EAAMd,OAAkC,IAAhBc,EAAMd,YAA+BJ,IAAhBkB,EAAMd,QACrDmE,EAAMnE,MAAQc,EAAMd,MAAMtH,YAG5B,OAAOgI,EAAcI,EAAMvF,QAAU,KAAO,KAAM4I,EAAOrD,EAAM1F,WAnD/DuP,SAsDF,SAAkB7J,GAChB,IAAI8J,EAAW,KAEf,GAAsB,OAAlB9J,EAAMmB,cAAsCrC,IAAlBkB,EAAMmB,QAAuB,CACzD,IAAIA,EAAUnB,EAAMmB,QACpB2I,EAAWlK,EAAc,QAAS,CAChCvF,KAAM,WACN8G,QAASA,EACT4I,UAAU,IAId,OAAOnK,EAAc,KAAMyI,EAAarI,GAAQ8J,EAAU9J,EAAM1F,WAjEhE0P,WAgHF,WACE,OAAO,MAhHPC,QAsCF,SAAiBjK,GACf,OAAOJ,EAAc,IAAI5E,OAAOgF,EAAMiB,OAAQoH,EAAarI,GAAQA,EAAM1F,WAtCzE4P,WA0EF,SAAoBlK,GAClB,OAAOJ,EAAc,OAAQyI,EAAarI,GAAQA,EAAM1F,WA1ExD6P,KAiEF,SAAmBnK,GACjB,IAAIe,EAAYf,EAAM6B,UAAY,YAAY7G,OAAOgF,EAAM6B,UACvDsI,EAAOvK,EAAc,OAAQmB,EAAY,CAC3CA,UAAWA,GACT,KAAMf,EAAMhH,OAChB,OAAO4G,EAAc,MAAOyI,EAAarI,GAAQmK,IArEjDC,KA4EF,SAAcpK,GACZ,GAAIA,EAAM6C,SACR,OAAO,KAGT,IAAIwH,EAAYrK,EAAM2C,qBAA2C,IAArB3C,EAAM4C,WAC9CH,EAAMzC,EAAM0C,QAAU,MAAQ,OAElC,IAAK2H,EAEH,OAAOzK,EAAclB,EAAMtB,UAAYqF,EAAK,KAAMzC,EAAMhH,OAG1D,IAAI0G,EAAY,CACd4K,wBAAyB,CACvBC,OAAQvK,EAAMhH,QAGlB,OAAO4G,EAAc6C,EAAK/C,IA7F1B8K,YAuGF,SAAqBxK,GACnB,OAAOJ,EAAcI,EAAMyC,IAAK4F,EAAarI,GAAQA,EAAM1F,WAvG3DmQ,WA+FF,SAAoBzK,GAElB,OAAOA,EAAM,kBAAoBtB,EAAMyE,aAAanD,EAAM+C,QAAS,CACjE,iBAAkB/C,EAAM,oBACrBA,EAAM+C,2CCvIb,IAAIsE,EAAa,sBAGjBhQ,EAAQgQ,WAA+B,oBAAX/L,OAAyB+L,EAAa/L,OAAO+L,kCCHzE,IAAIqD,EAAY,CAAC,OAAQ,QAAS,SAAU,OAE5CtT,EAAOC,QAAU,SAAwBsT,GACvC,IAAI/I,GAAO+I,GAAO,IAAIC,OAClBC,EAAQjJ,EAAIkJ,OAAO,GAEvB,GAAc,MAAVD,GAA2B,MAAVA,EACnB,OAAOjJ,EAGT,IAAImJ,EAAQnJ,EAAIpB,QAAQ,KAExB,IAAe,IAAXuK,EACF,OAAOnJ,EAMT,IAHA,IAAIjI,EAAS+Q,EAAU/Q,OACnBa,GAAS,IAEJA,EAAQb,GAAQ,CACvB,IAAIqR,EAAWN,EAAUlQ,GAEzB,GAAIuQ,IAAUC,EAASrR,QAAUiI,EAAIsD,MAAM,EAAG8F,EAASrR,QAAQsR,gBAAkBD,EAC/E,OAAOpJ,EAMX,OAAe,KAFfpH,EAAQoH,EAAIpB,QAAQ,OAEAuK,EAAQvQ,IAMb,KAFfA,EAAQoH,EAAIpB,QAAQ,OAEAuK,EAAQvQ,EALnBoH,EAUF,yDCxCT,IAAI0B,EAAQ,EAAQ,MAOpB,SAAS4H,EAAKjC,GACZ,IAAI3O,EAAW2O,EAAM3O,SACrB2O,EAAM3O,SAAW,CAAC,CAChBD,KAAM,YACNkI,MAAO0G,EAAM1G,MACbjI,SAAU,CAACA,EAAS,IACpB2E,SAAU3E,EAAS,GAAG2E,WAGpB3E,EAASX,OAAS,GACpBsP,EAAM3O,SAASY,KAAK,CAClBb,KAAM,YACNkI,MAAO0G,EAAM1G,MACbjI,SAAUA,EAAS4K,MAAM,GACzBjG,SAAU,CACRC,MAAO5E,EAAS,GAAG2E,SAASC,MAC5BI,IAAKhF,EAASA,EAASX,OAAS,GAAGsF,SAASK,OArBpDlI,EAAOC,QAAU,SAAUyD,GAEzB,OADAwI,EAAMxI,EAAM,QAASoQ,GACdpQ,sCCJT1D,EAAOC,QAsBP,SAAsB2B,EAAOmS,EAAUvS,GACb,iBAAbuS,IACTvS,EAAUuS,EACVA,OAAWrM,GAGb,OAIF,SAAkBlG,GAChB,IAAIwS,EAAWxS,GAAW,GACtByS,EA6sBN,SAAmBA,EAAQC,GACzB,IAAI9Q,GAAS,EAEb,OAASA,EAAQ8Q,EAAW3R,QAC1B4R,EAAUF,EAAQC,EAAW9Q,IAG/B,OAAO6Q,EAptBMG,CAAU,CACrB7E,WAAY,GACZ8E,eAAgB,CAAC,WAAY,WAAY,UAAW,YAAa,UACjEC,MAAO,CACLC,SAAUC,EAAO/C,IACjBgD,iBAAkBC,EAClBC,cAAeD,EACfE,WAAYJ,EAAO3B,IACnBgC,WAAYL,EAAOK,IACnBC,gBAAiBJ,EACjBK,mBAAoBL,EACpBM,WAAYR,EAAOS,IACnBC,oBAAqBC,EACrBC,oBAAqBD,EACrBE,aAAcb,EAAOS,GAAUE,GAC/BG,SAAUd,EAAOc,GAAUH,GAC3BI,aAAcb,EACdc,KAAMd,EACNe,cAAef,EACf9B,WAAY4B,EAAO5B,IACnB8C,4BAA6BP,EAC7BQ,sBAAuBR,EACvBS,sBAAuBT,EACvB/D,SAAUoD,EAAOpD,IACjByE,gBAAiBrB,EAAOsB,IACxBC,kBAAmBvB,EAAOsB,IAC1BE,SAAUxB,EAAOxB,GAAMmC,GACvBc,aAAcvB,EACdwB,SAAU1B,EAAOxB,GAAMmC,GACvBgB,aAAczB,EACdhD,MAAO8C,EAAO9C,IACd0E,MAAOjB,EACP1D,KAAM+C,EAAO/C,IACbgB,SAAU+B,EAAO/B,IACjB4D,cAAeC,EACfC,YAAa/B,EAAOhC,GAAMgE,GAC1BC,cAAejC,EAAOhC,IACtBrB,UAAWqD,EAAOrD,IAClBuF,UAAWC,EACXC,gBAAiBzB,EACjB0B,0BAA2B1B,EAC3B2B,oBAAqB3B,EACrB4B,cAAevC,EAAO3B,IACtBxB,OAAQmD,EAAOnD,IACfC,cAAekD,EAAOlD,KAExB0F,KAAM,CACJpC,WAAYqC,IACZC,mBAAoBC,EACpB5C,SAAU0C,IACVtC,cAAeyC,GACf3C,iBAAkB4C,GAClBxC,WAAYoC,IACZK,qBAAsBC,EACtBC,oCAAqCC,EACrCC,gCAAiCD,EACjCE,wBAAyBC,GACzB5C,WAAYiC,EAAOY,GACnBC,gBAAiBC,EACjB7C,oBAAqB8C,EACrB5C,oBAAqB6C,EACrBxC,cAAe8B,EACflC,aAAc4B,EAAOiB,GACrB5C,SAAU2B,EAAOkB,GACjB5C,aAAcgC,EACd/B,KAAM+B,EACN3E,WAAYqE,IACZvB,4BAA6B0C,EAC7BzC,sBAAuB0C,EACvBzC,sBAAuB0C,EACvBlH,SAAU6F,IACVpB,gBAAiBoB,EAAOsB,GACxBxC,kBAAmBkB,EAAOsB,GAC1BvC,SAAUiB,EAAOuB,GACjBvC,aAAcsB,EACdrB,SAAUe,EAAOwB,GACjBtC,aAAcoB,EACd7F,MAAOuF,EAAOyB,GACdtC,MAAOuC,EACPC,UAAWC,EACXC,WAAYC,EACZtH,KAAMwF,EAAO+B,GACbvG,SAAUwE,IACVV,YAAaU,IACbR,cAAeQ,IACf9F,UAAW8F,IACXL,gBAAiBqC,EACjBpC,0BAA2BqC,EAC3BpC,oBAAqBqC,EACrBC,SAAUC,EACVtC,cAAeE,EAAOqC,GACtBC,0BAA2BC,EAC3BC,kBAAmBC,EACnBrI,OAAQ4F,IACR3F,cAAe2F,MAEhBjD,EAAS2F,iBAAmB,IAC3BnE,EAAO,GACX,OAAOoE,EAEP,SAASA,EAAQC,GAuBf,IAtBA,IAQIC,EARAxW,EAAO,CACTL,KAAM,OACNC,SAAU,IAGR6W,EAAa,GACbC,EAAY,GACZ5W,GAAS,EAGT6W,EAAU,CACZzW,MAPU,CAACF,GAQXyW,WAAYA,EACZ9F,OAAQA,EACRK,MAAOA,EACP0C,KAAMA,EACN7B,OAAQA,EACR+E,OAAQA,EACRC,QAASA,EACTC,QAASA,KAGFhX,EAAQyW,EAAOtX,QAGQ,gBAA1BsX,EAAOzW,GAAO,GAAGH,MAAoD,kBAA1B4W,EAAOzW,GAAO,GAAGH,OACrC,UAArB4W,EAAOzW,GAAO,GAChB4W,EAAUlW,KAAKV,GAGfA,EAAQiX,EAAYR,EADRG,EAAUjW,IAAIX,GACaA,IAO7C,IAFAA,GAAS,IAEAA,EAAQyW,EAAOtX,QACtBuX,EAAU7F,EAAO4F,EAAOzW,GAAO,IAE3BkX,EAAIvZ,KAAK+Y,EAASD,EAAOzW,GAAO,GAAGH,OACrC6W,EAAQD,EAAOzW,GAAO,GAAGH,MAAMlC,KAAKwZ,EAAO,CACzCC,eAAgBX,EAAOzW,GAAO,GAAGoX,gBAChCP,GAAUJ,EAAOzW,GAAO,IAI/B,GAAI2W,EAAWxX,OACb,MAAM,IAAI8F,MAAM,oCAAsC0R,EAAWA,EAAWxX,OAAS,GAAGU,KAAO,MAAQwX,EAAkB,CACvH3S,MAAOiS,EAAWA,EAAWxX,OAAS,GAAGuF,MACzCI,IAAK6R,EAAWA,EAAWxX,OAAS,GAAG2F,MACpC,mBAkBP,IAdA5E,EAAKuE,SAAW,CACdC,MAAO4S,EAAMb,EAAOtX,OAASsX,EAAO,GAAG,GAAG/R,MAAQ,CAChDC,KAAM,EACNC,OAAQ,EACRC,OAAQ,IAEVC,IAAKwS,EAAMb,EAAOtX,OAASsX,EAAOA,EAAOtX,OAAS,GAAG,GAAG2F,IAAM,CAC5DH,KAAM,EACNC,OAAQ,EACRC,OAAQ,KAGZ7E,GAAS,IAEAA,EAAQ6Q,EAAO1E,WAAWhN,QACjCe,EAAO2Q,EAAO1E,WAAWnM,GAAOE,IAASA,EAG3C,OAAOA,EAGT,SAAS+W,EAAYR,EAAQ/R,EAAOvF,GAYlC,IAXA,IAGIkQ,EACAkI,EACAC,EACAC,EACAC,EACAC,EACAC,EATA5X,EAAQ0E,EAAQ,EAChBmT,GAAoB,EACpBC,GAAa,IASR9X,GAASb,GAwBhB,GArBsB,mBAFtBuY,EAAQjB,EAAOzW,IAEL,GAAGH,MAA8C,gBAAlB6X,EAAM,GAAG7X,MAA4C,eAAlB6X,EAAM,GAAG7X,MAClE,UAAb6X,EAAM,GACRG,IAEAA,IAGFD,OAAWtT,GACgB,oBAAlBoT,EAAM,GAAG7X,KACD,UAAb6X,EAAM,MACJrI,GAAauI,GAAaC,GAAqBF,IACjDA,EAAsB3X,GAGxB4X,OAAWtT,GAEc,eAAlBoT,EAAM,GAAG7X,MAA2C,kBAAlB6X,EAAM,GAAG7X,MAA8C,mBAAlB6X,EAAM,GAAG7X,MAA+C,mBAAlB6X,EAAM,GAAG7X,MAA+C,6BAAlB6X,EAAM,GAAG7X,OAErK+X,OAAWtT,IAGRuT,GAAiC,UAAbH,EAAM,IAAoC,mBAAlBA,EAAM,GAAG7X,OAAmD,IAAtBgY,GAAwC,SAAbH,EAAM,KAAoC,kBAAlBA,EAAM,GAAG7X,MAA8C,gBAAlB6X,EAAM,GAAG7X,MAAyB,CAC/M,GAAIwP,EAAU,CAIZ,IAHAkI,EAAYvX,EACZwX,OAAYlT,EAELiT,KAGL,GAA0B,gBAF1BE,EAAYhB,EAAOc,IAEL,GAAG1X,MAA+C,oBAAtB4X,EAAU,GAAG5X,KAA4B,CACjF,GAAqB,SAAjB4X,EAAU,GAAe,SAEzBD,IACFf,EAAOe,GAAW,GAAG3X,KAAO,kBAC5BiY,GAAa,GAGfL,EAAU,GAAG5X,KAAO,aACpB2X,EAAYD,OACP,GAA0B,eAAtBE,EAAU,GAAG5X,MAA+C,qBAAtB4X,EAAU,GAAG5X,MAAqD,+BAAtB4X,EAAU,GAAG5X,MAA+D,qBAAtB4X,EAAU,GAAG5X,MAAqD,mBAAtB4X,EAAU,GAAG5X,KAE1M,MAIA8X,KAAyBH,GAAaG,EAAsBH,KAC9DnI,EAAS0I,SAAU,GAIrB1I,EAASvK,IAAMwS,EAAME,EAAYf,EAAOe,GAAW,GAAG9S,MAAQgT,EAAM,GAAG5S,KACvE2R,EAAO1N,OAAOyO,GAAaxX,EAAO,EAAG,CAAC,OAAQqP,EAAUqI,EAAM,KAC9D1X,IACAb,IAIoB,mBAAlBuY,EAAM,GAAG7X,OACXwP,EAAW,CACTxP,KAAM,WACNkY,SAAS,EACTrT,MAAO4S,EAAMI,EAAM,GAAGhT,QAExB+R,EAAO1N,OAAO/I,EAAO,EAAG,CAAC,QAASqP,EAAUqI,EAAM,KAClD1X,IACAb,IACAwY,OAAsBrT,EACtBsT,GAAW,GAMjB,OADAnB,EAAO/R,GAAO,GAAGqT,QAAUD,EACpB3Y,EAGT,SAAS4X,EAAQjZ,EAAKU,GACpB4T,EAAKtU,GAAOU,EAGd,SAASwY,EAAQlZ,GACf,OAAOsU,EAAKtU,GAGd,SAASwZ,EAAMrW,GACb,MAAO,CACL0D,KAAM1D,EAAE0D,KACRC,OAAQ3D,EAAE2D,OACVC,OAAQ5D,EAAE4D,QAId,SAASuM,EAAO4G,EAAQC,GACtB,OAAOtO,EAEP,SAASA,EAAKuO,GACZhH,EAAMvT,KAAKwa,KAAMH,EAAOE,GAAQA,GAC5BD,GAAKA,EAAIta,KAAKwa,KAAMD,IAI5B,SAASnG,IACPoG,KAAK/X,MAAMM,KAAK,CACdb,KAAM,WACNC,SAAU,KAId,SAASoR,EAAM5Q,EAAM4X,GAOnB,OANAC,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAAGW,SAASY,KAAKJ,GAChD6X,KAAK/X,MAAMM,KAAKJ,GAChB6X,KAAKxB,WAAWjW,KAAKwX,GACrB5X,EAAKmE,SAAW,CACdC,MAAO4S,EAAMY,EAAMxT,QAEdpE,EAGT,SAASuT,EAAOoE,GACd,OAAOG,EAEP,SAASA,EAAMF,GACTD,GAAKA,EAAIta,KAAKwa,KAAMD,GACxBtE,EAAKjW,KAAKwa,KAAMD,IAIpB,SAAStE,EAAKsE,GACZ,IAAI5X,EAAO6X,KAAK/X,MAAMO,MAClBgJ,EAAOwO,KAAKxB,WAAWhW,MAE3B,IAAKgJ,EACH,MAAM,IAAI1E,MAAM,iBAAmBiT,EAAMrY,KAAO,MAAQwX,EAAkB,CACxE3S,MAAOwT,EAAMxT,MACbI,IAAKoT,EAAMpT,MACR,oBACA,GAAI6E,EAAK9J,OAASqY,EAAMrY,KAC7B,MAAM,IAAIoF,MAAM,iBAAmBiT,EAAMrY,KAAO,MAAQwX,EAAkB,CACxE3S,MAAOwT,EAAMxT,MACbI,IAAKoT,EAAMpT,MACR,0BAA4B6E,EAAK9J,KAAO,MAAQwX,EAAkB,CACrE3S,MAAOiF,EAAKjF,MACZI,IAAK6E,EAAK7E,MACP,aAIP,OADAxE,EAAKmE,SAASK,IAAMwS,EAAMY,EAAMpT,KACzBxE,EAGT,SAASwW,IACP,OAAO1Z,EAAS+a,KAAK/X,MAAMO,OAM7B,SAASyS,IACP2D,EAAQ,+BAA+B,GAGzC,SAAS7D,EAAqBgF,GACxBlB,EAAQ,iCACVmB,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAAGuF,MAAQgJ,SAASyK,KAAKf,eAAec,GAAQ,IAC/EnB,EAAQ,gCAIZ,SAASnC,IACP,IAAIxC,EAAO+F,KAAKrB,SAChBqB,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAAGmI,KAAO8K,EAG3C,SAASyC,IACP,IAAIzC,EAAO+F,KAAKrB,SAChBqB,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAAGkZ,KAAOjG,EAG3C,SAASuC,IAEHqC,EAAQ,oBACZmB,KAAKpG,SACLgF,EAAQ,kBAAkB,IAG5B,SAAStC,IACP,IAAIrC,EAAO+F,KAAKrB,SAChBqB,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAAGX,MAAQ4T,EAAKkG,QAAQ,2BAA4B,IACnFvB,EAAQ,kBAGV,SAASjC,IACP,IAAI1C,EAAO+F,KAAKrB,SAChBqB,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAAGX,MAAQ4T,EAG5C,SAAS6C,EAA4BiD,GAEnC,IAAIlF,EAAQmF,KAAKrB,SACjBqB,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAAG6T,MAAQA,EAC1CmF,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAAGgH,WAAaoS,EAAoBJ,KAAKf,eAAec,IAAQzH,cAGjG,SAASyE,IACP,IAAI9C,EAAO+F,KAAKrB,SAChBqB,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAAGgI,MAAQiL,EAG5C,SAAS4C,IACP,IAAI5C,EAAO+F,KAAKrB,SAChBqB,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAAGiI,IAAMgL,EAG1C,SAAS2B,EAAyBmE,GAC3BC,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAAGS,QACrCuY,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAAGS,MAAQuY,KAAKf,eAAec,GAAO/Y,QAIzE,SAASmX,IACPS,EAAQ,gCAAgC,GAG1C,SAASX,EAAgC8B,GACvCC,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAAGS,MAAqD,KAA7CuY,KAAKf,eAAec,GAAOM,WAAW,GAAY,EAAI,EAGlG,SAAStC,IACPa,EAAQ,gCAGV,SAASzF,EAAY4G,GACnB,IAAIO,EAAWN,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAAGW,SAC7C4Y,EAAOD,EAASA,EAAStZ,OAAS,GAEjCuZ,GAAsB,SAAdA,EAAK7Y,QAEhB6Y,EAAOvJ,MACF1K,SAAW,CACdC,MAAO4S,EAAMY,EAAMxT,QAErByT,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAAGW,SAASY,KAAKgY,IAGlDP,KAAK/X,MAAMM,KAAKgY,GAGlB,SAASvE,EAAW+D,GAClB,IAAIQ,EAAOP,KAAK/X,MAAMO,MACtB+X,EAAKla,OAAS2Z,KAAKf,eAAec,GAClCQ,EAAKjU,SAASK,IAAMwS,EAAMY,EAAMpT,KAGlC,SAAS6Q,EAAiBuC,GACxB,IAAIrB,EAAUsB,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAE7C,GAAI6X,EAAQ,eAGV,OAFAH,EAAQ/W,SAAS+W,EAAQ/W,SAASX,OAAS,GAAGsF,SAASK,IAAMwS,EAAMY,EAAMpT,UACzEiS,EAAQ,gBAILC,EAAQ,iCAAmCnG,EAAOI,eAAejL,QAAQ6Q,EAAQhX,OAAS,IAC7FyR,EAAY3T,KAAKwa,KAAMD,GACvB/D,EAAWxW,KAAKwa,KAAMD,IAI1B,SAAS/C,IACP4B,EAAQ,eAAe,GAGzB,SAAS3B,IACP,IAAIhD,EAAO+F,KAAKrB,SAChBqB,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAAGX,MAAQ4T,EAG5C,SAASiD,IACP,IAAIjD,EAAO+F,KAAKrB,SAChBqB,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAAGX,MAAQ4T,EAG5C,SAAS2C,IACP,IAAI3C,EAAO+F,KAAKrB,SAChBqB,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAAGX,MAAQ4T,EAG5C,SAASwD,IACP,IAAIiB,EAAUsB,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAEzC6X,EAAQ,gBACVH,EAAQhX,MAAQ,YAChBgX,EAAQ8B,cAAgB3B,EAAQ,kBAAoB,kBAC7CH,EAAQzP,WACRyP,EAAQ1P,eAER0P,EAAQ1Q,kBACR0Q,EAAQ7D,aACR6D,EAAQ8B,eAGjB5B,EAAQ,iBAGV,SAASzB,IACP,IAAIuB,EAAUsB,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAEzC6X,EAAQ,gBACVH,EAAQhX,MAAQ,YAChBgX,EAAQ8B,cAAgB3B,EAAQ,kBAAoB,kBAC7CH,EAAQzP,WACRyP,EAAQ1P,eAER0P,EAAQ1Q,kBACR0Q,EAAQ7D,aACR6D,EAAQ8B,eAGjB5B,EAAQ,iBAGV,SAAStB,EAAgByC,GACvBC,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAAGgH,WAAaoS,EAAoBJ,KAAKf,eAAec,IAAQzH,cAGjG,SAAS8E,IACP,IAAIqD,EAAWT,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAC1CX,EAAQ2Z,KAAKrB,SACjBqB,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAAG6T,MAAQxU,EAE1CuY,EAAQ,eAAe,GAEwB,SAA3CoB,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAAGU,KACpCsY,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAAGW,SAAW8Y,EAAS9Y,SAEtDqY,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAAG0I,IAAMrJ,EAI5C,SAASsX,IACP,IAAI1D,EAAO+F,KAAKrB,SAChBqB,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAAGiI,IAAMgL,EAG1C,SAAS2D,IACP,IAAI3D,EAAO+F,KAAKrB,SAChBqB,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAAGgI,MAAQiL,EAG5C,SAAS6D,IACPc,EAAQ,eAGV,SAASxD,IACPwD,EAAQ,gBAAiB,aAG3B,SAASlB,EAAsBqC,GAC7B,IAAIlF,EAAQmF,KAAKrB,SACjBqB,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAAG6T,MAAQA,EAC1CmF,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAAGgH,WAAaoS,EAAoBJ,KAAKf,eAAec,IAAQzH,cAC/FsG,EAAQ,gBAAiB,QAG3B,SAAS1C,EAA+B6D,GACtCnB,EAAQ,yBAA0BmB,EAAMrY,MAG1C,SAAS2U,GAA8B0D,GACrC,IAEI1Z,EACAka,EAHAtG,EAAO+F,KAAKf,eAAec,GAC3BrY,EAAOmX,EAAQ,0BAIfnX,GACFrB,EAAQqa,EAAYzG,EAAe,oCAATvS,EAA6C,GAAK,IAC5EkX,EAAQ,2BAERvY,EAAQsa,EAAO1G,IAGjBsG,EAAOP,KAAK/X,MAAMO,OACbnC,OAASA,EACdka,EAAKjU,SAASK,IAAMwS,EAAMY,EAAMpT,KAGlC,SAASmP,GAAuBiE,GAC9B/D,EAAWxW,KAAKwa,KAAMD,GACtBC,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAAGiI,IAAM+Q,KAAKf,eAAec,GAG9D,SAASlE,GAAoBkE,GAC3B/D,EAAWxW,KAAKwa,KAAMD,GACtBC,KAAK/X,MAAM+X,KAAK/X,MAAMjB,OAAS,GAAGiI,IAAM,UAAY+Q,KAAKf,eAAec,GAM1E,SAASzG,KACP,MAAO,CACL5R,KAAM,aACNC,SAAU,IAId,SAAS+R,KACP,MAAO,CACLhS,KAAM,OACNyH,KAAM,KACN+Q,KAAM,KACN7Z,MAAO,IAIX,SAAS0T,KACP,MAAO,CACLrS,KAAM,aACNrB,MAAO,IAIX,SAASgR,KACP,MAAO,CACL3P,KAAM,aACNsG,WAAY,GACZ6M,MAAO,KACP7L,MAAO,KACPC,IAAK,IAIT,SAAS4G,KACP,MAAO,CACLnO,KAAM,WACNC,SAAU,IAId,SAAS2P,KACP,MAAO,CACL5P,KAAM,UACND,WAAO0E,EACPxE,SAAU,IAId,SAAS4S,KACP,MAAO,CACL7S,KAAM,SAIV,SAAS+P,KACP,MAAO,CACL/P,KAAM,OACNrB,MAAO,IAIX,SAAS8P,KACP,MAAO,CACLzO,KAAM,QACNsH,MAAO,KACPC,IAAK,GACLS,IAAK,MAIT,SAASwG,KACP,MAAO,CACLxO,KAAM,OACNsH,MAAO,KACPC,IAAK,GACLtH,SAAU,IAId,SAASsP,GAAK8I,GACZ,MAAO,CACLrY,KAAM,OACNI,QAAwB,gBAAfiY,EAAMrY,KACf6E,MAAO,KACPgC,OAAQwR,EAAMH,QACdjY,SAAU,IAId,SAASuP,GAAS6I,GAChB,MAAO,CACLrY,KAAM,WACN6G,OAAQwR,EAAMH,QACdpR,QAAS,KACT7G,SAAU,IAId,SAASiO,KACP,MAAO,CACLlO,KAAM,YACNC,SAAU,IAId,SAASmO,KACP,MAAO,CACLpO,KAAM,SACNC,SAAU,IAId,SAASqP,KACP,MAAO,CACLtP,KAAM,OACNrB,MAAO,IAIX,SAAS0P,KACP,MAAO,CACLrO,KAAM,kBA9sBHkZ,CAAS3a,EAAT2a,CAAkBC,EAAYC,EAAO7a,GAAS8a,WAAWC,MAAMC,GAAAA,CAAe5a,EAAOmS,GAAU,OA1BxG,IAAIvT,EAAW,EAAQ,MAEnB+Z,EAAS,EAAQ,MAEjBD,EAAM,EAAQ,KAEdqB,EAAsB,EAAQ,KAE9BM,EAAc,EAAQ,KAEtBI,EAAS,EAAQ,MAEjBG,EAAe,EAAQ,MAEvBJ,EAAc,EAAQ,MAEtBF,EAAS,EAAQ,MAEjBzB,EAAoB,EAAQ,MAquBhC,SAAStG,EAAUF,EAAQE,GACzB,IAAIjT,EACAub,EAEJ,IAAKvb,KAAOiT,EACVsI,EAAOnC,EAAIvZ,KAAKkT,EAAQ/S,GAAO+S,EAAO/S,GAAO+S,EAAO/S,GAAO,GAE/C,mBAARA,GAAoC,eAARA,EAC9B+S,EAAO/S,GAAO,GAAG0C,OAAO6Y,EAAMtI,EAAUjT,IAExCd,OAAOma,OAAOkC,EAAMtI,EAAUjT,wCCnwBpClB,EAAOC,QAAU,EAAjB,qCCIA,SAASO,EAASkD,GAChB,OAAOA,IAASA,EAAK9B,OAAS8B,EAAKuH,KAAOvH,EAAK6G,OAAS,aAAc7G,GAAQM,EAAIN,EAAKR,WAAa,WAAYQ,GAAQM,EAAIN,KAAU,GAGxI,SAASM,EAAI0Y,GAIX,IAHA,IAAI/Y,EAAS,GACTP,GAAS,IAEJA,EAAQsZ,EAAOna,QACtBoB,EAAOP,GAAS5C,EAASkc,EAAOtZ,IAGlC,OAAOO,EAAOyE,KAAK,IAhBrBpI,EAAOC,QAAUO,qCCAjB,IAEImc,EAFa,EAAQ,KAERC,CAAW,YAC5B5c,EAAOC,QAAU0c,qCCHjB,IAEIE,EAFa,EAAQ,KAEDD,CAAW,cACnC5c,EAAOC,QAAU4c,qCCHjB,IAEIC,EAFa,EAAQ,KAERF,CAAW,uBAC5B5c,EAAOC,QAAU6c,iCCIjB9c,EAAOC,QAPP,SAAsB8S,GACpB,OAEEA,EAAO,IAAe,MAATA,sCCHjB,IAEIgK,EAFa,EAAQ,KAERH,CAAW,MAC5B5c,EAAOC,QAAU8c,qCCHjB,IAEIC,EAFa,EAAQ,KAELJ,CAAW,cAC/B5c,EAAOC,QAAU+c,qCCHjB,IAEIC,EAFa,EAAQ,KAEFL,CAAW,kBAClC5c,EAAOC,QAAUgd,iCCCjBjd,EAAOC,QAJP,SAAmC8S,GACjC,OAAOA,EAAO,GAAc,KAATA,kCCGrB/S,EAAOC,QAJP,SAA4B8S,GAC1B,OAAOA,GAAQ,kCCGjB/S,EAAOC,QAJP,SAAuB8S,GACrB,OAAiB,IAAVA,IAAyB,IAAVA,GAAwB,KAATA,sCCDvC,IAAImK,EAA0B,EAAQ,MAKlCC,EAHa,EAAQ,KAGAP,CAAWM,GACpCld,EAAOC,QAAUkd,qCCNjB,IAEIC,EAFa,EAAQ,KAEDR,CAAW,MACnC5c,EAAOC,QAAUmd,iCCHjB,IAAI7C,EAASna,OAAOma,OACpBva,EAAOC,QAAUsa,iCCDjB,IAAI8C,EAAerU,OAAOqU,aAC1Brd,EAAOC,QAAUod,gCCDjB,IAAI/C,EAAM,GAAGha,eACbN,EAAOC,QAAUqa,iCCAjBta,EAAOC,QADM,CAAC,UAAW,UAAW,QAAS,OAAQ,WAAY,aAAc,OAAQ,UAAW,SAAU,MAAO,WAAY,KAAM,UAAW,SAAU,MAAO,MAAO,KAAM,KAAM,WAAY,aAAc,SAAU,SAAU,OAAQ,QAAS,WAAY,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,OAAQ,SAAU,KAAM,OAAQ,SAAU,SAAU,KAAM,OAAQ,OAAQ,OAAQ,WAAY,MAAO,WAAY,KAAM,WAAY,SAAU,IAAK,QAAS,UAAW,SAAU,UAAW,QAAS,QAAS,KAAM,QAAS,KAAM,QAAS,QAAS,KAAM,QAAS,qCCCtiBD,EAAOC,QADI,CAAC,MAAO,SAAU,QAAS,2CCAtC,IAAIkM,EAAS,GAAGA,OAChBnM,EAAOC,QAAUkM,iCCKjBnM,EAAOC,QADkB,sxCCLzBG,OAAOK,eAAeR,EAAS,aAA/B,CACE2B,OAAO,IAGT,IAAI0b,EAAS,EAAQ,MAEjBC,EAAY,EAAQ,MAEpBhJ,EAAW,EAAQ,MAEnBM,EAAa,EAAQ,MAErBC,EAAkB,EAAQ,MAE1BC,EAAqB,EAAQ,MAE7BC,EAAa,EAAQ,KAErBK,EAAe,EAAQ,MAEvBC,EAAW,EAAQ,MAEnB1C,EAAa,EAAQ,MAErBiD,EAAkB,EAAQ,MAE1B2H,EAAa,EAAQ,KAErBxH,EAAW,EAAQ,MAEnBE,EAAW,EAAQ,MAEnBuH,EAAW,EAAQ,MAEnBC,EAAkB,EAAQ,MAE1BC,EAAiB,EAAQ,MAEzB7E,EAAa,EAAQ,MAErBtG,EAAO,EAAQ,MAEfoL,EAAkB,EAAQ,MAE1BtM,EAAgB,EAAQ,MAExBgL,EAAW,CACb,GAAI9J,EAEJ,GAAIA,EAEJ,GAAIA,EAEJ,GAAIA,EAEJ,GAAIA,EAEJ,GAAIA,EAEJ,GAAIA,EAEJ,GAAIA,EAEJ,GAAIA,EAEJ,GAAIA,EAEJ,GAAIA,EAEJ,GAAIA,EAEJ,GAAIA,EAEJ,GAAIqC,GAGFgJ,EAAiB,CACnB,GAAIjL,GAGFkL,EAAc,CAChB,KAAMzI,EAEN,KAAMA,EAEN,GAAIA,GAGF0I,EAAO,CACT,GAAIP,EAEJ,GAAIlM,EAEJ,GAAI,CAACsM,EAAiBtM,GAEtB,GAAI0E,EAEJ,GAAI4H,EAEJ,GAAItM,EAEJ,GAAI0D,EAEJ,IAAKA,GAGH1E,EAAS,CACX,GAAIyE,EAEJ,GAAID,GAGFvC,EAAO,CACT,KAAMuG,EAEN,KAAMA,EAEN,KAAMA,EAEN,GAAI4E,EAEJ,GAAI3I,EAEJ,GAAIwI,EAEJ,GAAI,CAAChJ,EAAU2B,GAEf,GAAIyH,EAEJ,GAAI,CAAC9H,EAAiBf,GAEtB,GAAI2I,EAEJ,GAAIF,EAEJ,GAAIjI,GAGF0I,EAAa,CACfC,KAAM,CAACV,EAAWD,EAAOY,WAK3Bje,EAAQ4d,eAAiBA,EACzB5d,EAAQke,QAJM,CACZF,KAAM,IAIRhe,EAAQqc,SAAWA,EACnBrc,EAAQ8d,KAAOA,EACf9d,EAAQ6d,YAAcA,EACtB7d,EAAQ+d,WAAaA,EACrB/d,EAAQqQ,OAASA,EACjBrQ,EAAQsS,KAAOA,qCCvJfnS,OAAOK,eAAeR,EAAS,aAA/B,CACE2B,OAAO,IAGT,IAAIwc,EAAqB,EAAQ,MAE7BC,EAAe,EAAQ,KAEvBC,EAEJ,SAA2BC,GACzB,IACIC,EADAC,EAAeF,EAAQG,QAAQnD,KAAKc,OAAOsC,WAAWd,gBAI1D,SAAoC9K,GAClC,GAAa,OAATA,EAEF,YADAwL,EAAQK,QAAQ7L,GAOlB,OAHAwL,EAAQjK,MAAM,cACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,cACNqH,EAAaE,EAASE,EAAc,iBAG7C,SAA0B1L,GAExB,OADAwL,EAAQjK,MAAM,aACPuK,EAAU9L,MAhBnB,OAAO0L,EAmBP,SAASI,EAAU9L,GACjB,IAAIuI,EAAQiD,EAAQjK,MAAM,YAAa,CACrCwK,YAAa,OACbN,SAAUA,IAQZ,OALIA,IACFA,EAASO,KAAOzD,GAGlBkD,EAAWlD,EACJ9F,EAAKzC,GAGd,SAASyC,EAAKzC,GACZ,OAAa,OAATA,GACFwL,EAAQvH,KAAK,aACbuH,EAAQvH,KAAK,kBACbuH,EAAQK,QAAQ7L,IAIdqL,EAAmBrL,IACrBwL,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,aACN6H,IAITN,EAAQK,QAAQ7L,GACTyC,KAIXvV,EAAQqe,SAAWA,qCClEnBle,OAAOK,eAAeR,EAAS,aAA/B,CACE2B,OAAO,IAGT,IAAIwc,EAAqB,EAAQ,MAE7BC,EAAe,EAAQ,KAEvBW,EAAmB,EAAQ,MAE3BV,EAQJ,SAA4BC,GAC1B,IAOIU,EACAC,EACAC,EATAC,EAAO7D,KACP/X,EAAQ,GACR6b,EAAY,EACZC,EAAmB,CACrBhB,SAuGF,SAAyBC,EAASgB,GAChC,IAAIC,EAAe,EAEnB,OADAP,EAAgB,GACTQ,EAEP,SAASA,EAAa1M,GACpB,OAAIyM,EAAehc,EAAMjB,QACvB6c,EAAKM,eAAiBlc,EAAMgc,GAAc,GACnCjB,EAAQG,QAAQlb,EAAMgc,GAAc,GAAGG,aAAcC,EAAiBC,EAAtEtB,CAAmFxL,IAKxFmM,EAAUY,kBAAoBZ,EAAUY,iBAAiBC,UAC3Dd,EAAce,cAAe,EACtBC,EAAYlN,KAGrBqM,EAAKc,UAAYhB,EAAUY,kBAAoBZ,EAAUY,iBAAiBK,cAC1Ef,EAAKM,eAAiB,GACfnB,EAAQG,QAAQ0B,EAAoBC,EAAgBJ,EAApD1B,CAAiExL,IAG1E,SAAS6M,EAAgB7M,GAEvB,OADAyM,IACOJ,EAAKM,eAAeY,WAAaD,EAAetN,GAAQ0M,EAAa1M,GAG9E,SAAS8M,EAAY9M,GACnB,OAAImM,EAAUY,kBAAoBZ,EAAUY,iBAAiBS,MAE3DnB,EAAKM,eAAiB,GACfnB,EAAQG,QAAQ0B,EAAoBC,EAC3C9B,EAAQG,QAAQ8B,EAAmBH,EAAgB9B,EAAQkC,MAAMzB,EAAkBqB,EAAgBK,IAD5FnC,CAC2GxL,IAI7GsN,EAAetN,GAGxB,SAAS2N,EAAY3N,GAKnB,OAHAyM,EAAehc,EAAMjB,OACrB0c,EAAcsB,MAAO,EACrBtB,EAAce,cAAe,EACtBC,EAAYlN,GAIrB,SAASsN,EAAetN,GAEtB,OADAkM,EAAc0B,SAAU,EACjBV,EAAYlN,GAGrB,SAASkN,EAAYlN,GAGnB,OAFAkM,EAAcI,UAAYG,EAC1BJ,EAAKc,UAAYd,EAAKM,oBAAiBhY,EAChC6X,EAAGxM,KA/JZ6N,SAAS,GAKX,OAAO9Y,EAEP,SAASA,EAAMiL,GACb,OAAIsM,EAAY7b,EAAMjB,QACpB6c,EAAKM,eAAiBlc,EAAM6b,GAAW,GAChCd,EAAQG,QAAQlb,EAAM6b,GAAW,GAAGM,aAAckB,EAAkBC,EAApEvC,CAAuFxL,IAGzF+N,EAAkB/N,GAG3B,SAAS8N,EAAiB9N,GAExB,OADAsM,IACOvX,EAAMiL,GAGf,SAAS+N,EAAkB/N,GAGzB,OAAIkM,GAAiBA,EAAce,aAC1Be,EAAUhO,IAGnBqM,EAAKc,UAAYhB,GAAaA,EAAUY,kBAAoBZ,EAAUY,iBAAiBK,cACvFf,EAAKM,eAAiB,GACfnB,EAAQG,QAAQ0B,EAAoBY,EAAmBD,EAAvDxC,CAAkExL,IAG3E,SAASiO,EAAkBjO,GAGzB,OAFAvP,EAAMM,KAAK,CAACsb,EAAKU,iBAAkBV,EAAKM,iBACxCN,EAAKM,oBAAiBhY,EACfoZ,EAAkB/N,GAG3B,SAASgO,EAAUhO,GACjB,OAAa,OAATA,GACFkO,EAAe,GAAG,QAClB1C,EAAQK,QAAQ7L,KAIlBmM,EAAYA,GAAaE,EAAK/C,OAAO0B,KAAKqB,EAAK8B,OAC/C3C,EAAQjK,MAAM,YAAa,CACzBwK,YAAa,OACbN,SAAUW,EACVgC,WAAYjC,IAEPc,EAAajN,IAGtB,SAASiN,EAAajN,GACpB,OAAa,OAATA,GACFqO,EAAa7C,EAAQvH,KAAK,cACnB+J,EAAUhO,IAGfqL,EAAmBrL,IACrBwL,EAAQK,QAAQ7L,GAChBqO,EAAa7C,EAAQvH,KAAK,cACnBuH,EAAQkC,MAAMnB,EAAkB+B,KAGzC9C,EAAQK,QAAQ7L,GACTiN,GAGT,SAASqB,EAAkBtO,GAGzB,OAFAkO,EAAehC,EAAcI,UAAWJ,GAAiBA,EAAc0B,SACvEtB,EAAY,EACLvX,EAAMiL,GAGf,SAASqO,EAAa9F,GAChB6D,IAAYA,EAAWJ,KAAOzD,GAClC6D,EAAa7D,EACb4D,EAAUqB,KAAOtB,GAAiBA,EAAcsB,KAChDrB,EAAUoC,WAAWhG,EAAMxT,OAC3BoX,EAAU3C,MAAM6C,EAAKmC,YAAYjG,IAGnC,SAAS2F,EAAeO,EAAMtZ,GAC5B,IAAI9E,EAAQI,EAAMjB,OAQlB,IANI2c,GAAahX,IACfgX,EAAU3C,MAAM,CAAC,OACjB4C,EAAaD,OAAYxX,GAIpBtE,KAAUoe,GACfpC,EAAKM,eAAiBlc,EAAMJ,GAAO,GACnCI,EAAMJ,GAAO,GAAG4T,KAAKjW,KAAKqe,EAAMb,GAGlC/a,EAAMjB,OAASif,IAhHfpB,EAAqB,CACvB9B,SAgLF,SAA2BC,EAASgB,EAAIkC,GACtC,OAAOpD,EAAaE,EAASA,EAAQG,QAAQnD,KAAKc,OAAOsC,WAAWrC,SAAUiD,EAAIkC,GAAM,aAAclG,KAAKc,OAAOsC,WAAWR,QAAQF,KAAK7U,QAAQ,iBAAmB,OAAI1B,EAAY,KA/KnL8Y,EAAoB,CACtBlC,SAiLF,SAA0BC,EAASgB,EAAIkC,GACrC,OAAOpD,EAAaE,EAASA,EAAQgC,KAAKhF,KAAKc,OAAOsC,WAAWZ,KAAMwB,EAAIkC,GAAM,aAAclG,KAAKc,OAAOsC,WAAWR,QAAQF,KAAK7U,QAAQ,iBAAmB,OAAI1B,EAAY,KAGhLzH,EAAQqe,SAAWA,qCCpMnBle,OAAOK,eAAeR,EAAS,aAA/B,CACE2B,OAAO,IAGT,IAAI8f,EAAU,EAAQ,MAElBrD,EAAe,EAAQ,KAEvBW,EAAmB,EAAQ,MAE3BV,EAEJ,SAAwBC,GACtB,IAAIa,EAAO7D,KACPoG,EAAUpD,EAAQG,QACtBM,GAIA,SAAuBjM,GACrB,GAAa,OAATA,EAEF,YADAwL,EAAQK,QAAQ7L,GAQlB,OAJAwL,EAAQjK,MAAM,mBACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,mBACboI,EAAKU,sBAAmBpY,EACjBia,IAbTpD,EAAQG,QAAQnD,KAAKc,OAAOsC,WAAWb,YAAa8D,EAAgBvD,EAAaE,EAASA,EAAQG,QAAQnD,KAAKc,OAAOsC,WAAWZ,KAAM6D,EAAgBrD,EAAQG,QAAQgD,EAASE,IAAkB,gBAClM,OAAOD,EAeP,SAASC,EAAe7O,GACtB,GAAa,OAATA,EASJ,OAJAwL,EAAQjK,MAAM,cACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,cACboI,EAAKU,sBAAmBpY,EACjBia,EARLpD,EAAQK,QAAQ7L,KAYtB9S,EAAQqe,SAAWA,qCC9CnBle,OAAOK,eAAeR,EAAS,aAA/B,CACE2B,OAAO,IAGT,IAAI2Y,EAAS,EAAQ,MAEjBsH,EAAU,EAAQ,MAElBtP,EAAOuP,EAAkB,QACzBxR,EAASwR,EAAkB,UAC3B5D,EAAW,CACb6D,WAAYC,KAGd,SAASF,EAAkBG,GACzB,MAAO,CACL3D,SAIF,SAAwBC,GACtB,IAAIa,EAAO7D,KACPoD,EAAapD,KAAKc,OAAOsC,WAAWsD,GACpC1P,EAAOgM,EAAQG,QAAQC,EAAY7W,EAAOoa,GAC9C,OAAOpa,EAEP,SAASA,EAAMiL,GACb,OAAOoP,EAAQpP,GAAQR,EAAKQ,GAAQmP,EAAQnP,GAG9C,SAASmP,EAAQnP,GACf,GAAa,OAATA,EAOJ,OAFAwL,EAAQjK,MAAM,QACdiK,EAAQK,QAAQ7L,GACTyC,EANL+I,EAAQK,QAAQ7L,GASpB,SAASyC,EAAKzC,GACZ,OAAIoP,EAAQpP,IACVwL,EAAQvH,KAAK,QACNzE,EAAKQ,KAIdwL,EAAQK,QAAQ7L,GACTyC,GAGT,SAAS2M,EAAQpP,GACf,IAAIP,EAAOmM,EAAW5L,GAClB3P,GAAS,EAEb,GAAa,OAAT2P,EACF,OAAO,EAGT,GAAIP,EACF,OAASpP,EAAQoP,EAAKjQ,QACpB,IAAKiQ,EAAKpP,GAAOob,UAAYhM,EAAKpP,GAAOob,SAASzd,KAAKqe,EAAMA,EAAKZ,UAChE,OAAO,IA9CfuD,WAAYC,EAAyB,SAAVC,EAAmBG,OAAyB1a,IAsD3E,SAASsa,EAAeK,GACtB,OAEA,SAAwBxI,EAAQI,GAC9B,IACI3F,EADAlR,GAAS,EAIb,OAASA,GAASyW,EAAOtX,aACTmF,IAAV4M,EACEuF,EAAOzW,IAAoC,SAA1ByW,EAAOzW,GAAO,GAAGH,OACpCqR,EAAQlR,EACRA,KAEQyW,EAAOzW,IAAoC,SAA1ByW,EAAOzW,GAAO,GAAGH,OAExCG,IAAUkR,EAAQ,IACpBuF,EAAOvF,GAAO,GAAGpM,IAAM2R,EAAOzW,EAAQ,GAAG,GAAG8E,IAC5C2R,EAAO1N,OAAOmI,EAAQ,EAAGlR,EAAQkR,EAAQ,GACzClR,EAAQkR,EAAQ,GAGlBA,OAAQ5M,GAIZ,OAAO2a,EAAgBA,EAAcxI,EAAQI,GAAWJ,GAW5D,SAASuI,EAAuBvI,EAAQI,GAWtC,IAVA,IACIqI,EACA9M,EACA+M,EACAnf,EACAof,EACAhB,EACAiB,EACAnH,EARAoH,GAAc,IAUTA,GAAc7I,EAAOtX,QAC5B,IAAKmgB,IAAe7I,EAAOtX,QAAyC,eAA/BsX,EAAO6I,GAAY,GAAGzf,OAA6D,SAAnC4W,EAAO6I,EAAa,GAAG,GAAGzf,KAAiB,CAQ9H,IAPAuS,EAAOqE,EAAO6I,EAAa,GAAG,GAE9Btf,GADAkf,EAASrI,EAAQsH,YAAY/L,IACdjT,OACfigB,GAAe,EACfhB,EAAO,EACPiB,OAAO/a,EAEAtE,KAGL,GAAqB,iBAFrBmf,EAAQD,EAAOlf,IAEgB,CAG7B,IAFAof,EAAcD,EAAMhgB,OAEyB,KAAtCggB,EAAM3G,WAAW4G,EAAc,IACpChB,IACAgB,IAGF,GAAIA,EAAa,MACjBA,GAAe,OAEZ,IAAe,IAAXD,EACPE,GAAO,EACPjB,SACK,IAAe,IAAXe,EAAoB,CAE7Bnf,IACA,MAIAoe,IACFlG,EAAQ,CACNrY,KAAMyf,IAAe7I,EAAOtX,QAAUkgB,GAAQjB,EAAO,EAAI,aAAe,oBACxE1Z,MAAO,CACLC,KAAMyN,EAAKtN,IAAIH,KACfC,OAAQwN,EAAKtN,IAAIF,OAASwZ,EAC1BvZ,OAAQuN,EAAKtN,IAAID,OAASuZ,EAC1BmB,OAAQnN,EAAK1N,MAAM6a,OAASvf,EAC5Bwf,aAAcxf,EAAQof,EAAchN,EAAK1N,MAAM8a,aAAeJ,GAEhEta,IAAK2Z,EAAQrM,EAAKtN,MAEpBsN,EAAKtN,IAAM2Z,EAAQvG,EAAMxT,OAErB0N,EAAK1N,MAAMG,SAAWuN,EAAKtN,IAAID,OACjCsS,EAAO/E,EAAM8F,IAEbzB,EAAO1N,OAAOuW,EAAY,EAAG,CAAC,QAASpH,EAAOrB,GAAU,CAAC,OAAQqB,EAAOrB,IACxEyI,GAAc,IAIlBA,IAIJ,OAAO7I,EAGT5Z,EAAQie,SAAWA,EACnBje,EAAQqQ,OAASA,EACjBrQ,EAAQsS,KAAOA,qCCvLf,IAAImP,EAAU,EAAQ,MAElBpF,EAAW,EAAQ,MAEnByB,EAAO,EAAQ,MAEfxL,EAAO,EAAQ,MAEfsQ,EAAoB,EAAQ,MAE5BC,EAAkB,EAAQ,MAE1BC,EAAW,EAAQ,MAEnBpE,EAAa,EAAQ,MAwBzB3e,EAAOC,QAtBP,SAAeuB,GACb,IACI6a,EAAS,CACX2G,QAAS,GACTrE,WAAYkE,EAAkB,CAAClE,GAAY/a,OAAOmf,GAHrCvhB,GAAW,IAG4C0S,cACpEwN,QAAStG,EAAOsG,GAChBpF,SAAUlB,EAAOkB,GACjByB,KAAM3C,EAAO2C,GACbzN,OAAQ8K,EAAO7I,EAAKjC,QACpBiC,KAAM6I,EAAO7I,EAAKA,OAEpB,OAAO8J,EAEP,SAASjB,EAAO6H,GACd,OAEA,SAAiBC,GACf,OAAOJ,EAAgBzG,EAAQ4G,EAAaC,yCCjClD,IAAIC,EAAc,EAAQ,MAS1BnjB,EAAOC,QAPP,SAAqB4Z,GACnB,MAAQsJ,EAAYtJ,KAGpB,OAAOA,kCCNT,IAAIuJ,EAAS,cAsFbpjB,EAAOC,QApFP,WACE,IAGIojB,EAHAvb,GAAQ,EACRE,EAAS,EACTmN,EAAS,GAEb,OAEA,SAAsBvT,EAAOmS,EAAU7L,GACrC,IACIgF,EACA6R,EACAuE,EACAC,EACAxQ,EALAuP,EAAS,GAMb1gB,EAAQuT,EAASvT,EAAMpB,SAASuT,GAChCuP,EAAgB,EAChBnO,EAAS,GAELrN,IAC0B,QAAxBlG,EAAMga,WAAW,IACnB0H,IAGFxb,OAAQJ,GAGV,KAAO4b,EAAgB1hB,EAAMW,QAAQ,CAMnC,GALA6gB,EAAOI,UAAYF,EACnBpW,EAAQkW,EAAOK,KAAK7hB,GACpB2hB,EAAcrW,EAAQA,EAAM9J,MAAQxB,EAAMW,OAC1CwQ,EAAOnR,EAAMga,WAAW2H,IAEnBrW,EAAO,CACViI,EAASvT,EAAMkM,MAAMwV,GACrB,MAGF,GAAa,KAATvQ,GAAeuQ,IAAkBC,GAAeF,EAClDf,EAAOxe,MAAM,GACbuf,OAAmB3b,OAYnB,GAVI2b,IACFf,EAAOxe,MAAM,GACbuf,OAAmB3b,GAGjB4b,EAAgBC,IAClBjB,EAAOxe,KAAKlC,EAAMkM,MAAMwV,EAAeC,IACvCvb,GAAUub,EAAcD,GAGb,IAATvQ,EACFuP,EAAOxe,KAAK,OACZkE,SACK,GAAa,IAAT+K,EAIT,IAHAgM,EAA+B,EAAxB2E,KAAKC,KAAK3b,EAAS,GAC1Bsa,EAAOxe,MAAM,GAENkE,IAAW+W,GAChBuD,EAAOxe,MAAM,QAEG,KAATiP,GACTuP,EAAOxe,MAAM,GACbkE,EAAS,IAGTqb,GAAmB,EACnBrb,EAAS,GAIbsb,EAAgBC,EAAc,EAG5Brb,IACEmb,GAAkBf,EAAOxe,MAAM,GAC/BqR,GAAQmN,EAAOxe,KAAKqR,GACxBmN,EAAOxe,KAAK,OAGd,OAAOwe,uCClFX,IAAIsB,EAAc,EAAQ,MAEtBC,EAAgB,EAAQ,MAExBC,EAAoB,EAAQ,KAE5BC,EAAY,EAAQ,MAEpBhC,EAAa,EAAQ,MAErBF,EAAU,EAAQ,MAElBtE,EAAY,CACd9b,KAAM,YACN6c,SAmGF,SAA2BC,EAASgB,GAClC,IACIyE,EADAC,EAASH,EAAkBvI,KAAKiD,UAEpC,OAEA,SAAezL,GAGb,OAFAwL,EAAQjK,MAAM,qBACd0P,EAASjR,EACFmR,EAASnR,IAGlB,SAASmR,EAASnR,GAChB,IAAIuI,EACA6I,EACApX,EACAyO,EAEJ,OAAIzI,IAASiR,GACXzF,EAAQK,QAAQ7L,GACTmR,IAGT5I,EAAQiD,EAAQvH,KAAK,qBAErBjK,IADAoX,EAAQL,EAAkB/Q,KACC,IAAVoR,GAAeF,EAChCzI,GAASyI,GAAqB,IAAXA,GAAgBE,EACnC7I,EAAM8I,MAAmB,KAAXJ,EAAgBjX,EAAOA,IAASkX,IAAWzI,GACzDF,EAAM+I,OAAoB,KAAXL,EAAgBxI,EAAQA,IAAU2I,IAAUpX,GACpDwS,EAAGxM,MA9HZgP,WAGF,SAA6BlI,EAAQI,GACnC,IACIlN,EACAuX,EACA/R,EACAgS,EACAC,EACArV,EACAsV,EACAxc,EARA7E,GAAS,EAab,OAASA,EAAQyW,EAAOtX,QAEtB,GAAyB,UAArBsX,EAAOzW,GAAO,IAA4C,sBAA1ByW,EAAOzW,GAAO,GAAGH,MAAgC4W,EAAOzW,GAAO,GAAGihB,OAGpG,IAFAtX,EAAO3J,EAEA2J,KAEL,GAAwB,SAApB8M,EAAO9M,GAAM,IAA0C,sBAAzB8M,EAAO9M,GAAM,GAAG9J,MAAgC4W,EAAO9M,GAAM,GAAGqX,OAClGnK,EAAQO,eAAeX,EAAO9M,GAAM,IAAI6O,WAAW,KAAO3B,EAAQO,eAAeX,EAAOzW,GAAO,IAAIwY,WAAW,GAAI,CAKhH,IAAK/B,EAAO9M,GAAM,GAAGsX,QAAUxK,EAAOzW,GAAO,GAAGghB,SAAWvK,EAAOzW,GAAO,GAAG8E,IAAID,OAAS4R,EAAOzW,GAAO,GAAG0E,MAAMG,QAAU,MAAQ4R,EAAO9M,GAAM,GAAG7E,IAAID,OAAS4R,EAAO9M,GAAM,GAAGjF,MAAMG,OAAS4R,EAAOzW,GAAO,GAAG8E,IAAID,OAAS4R,EAAOzW,GAAO,GAAG0E,MAAMG,QAAU,GAC3P,SAIFkH,EAAM0K,EAAO9M,GAAM,GAAG7E,IAAID,OAAS4R,EAAO9M,GAAM,GAAGjF,MAAMG,OAAS,GAAK4R,EAAOzW,GAAO,GAAG8E,IAAID,OAAS4R,EAAOzW,GAAO,GAAG0E,MAAMG,OAAS,EAAI,EAAI,EAC7Isc,EAAkB,CAChBthB,KAAMkM,EAAM,EAAI,iBAAmB,mBACnCrH,MAAOic,EAAUlC,EAAQhI,EAAO9M,GAAM,GAAG7E,MAAOiH,GAChDjH,IAAK2Z,EAAQhI,EAAO9M,GAAM,GAAG7E,MAE/Bsc,EAAkB,CAChBvhB,KAAMkM,EAAM,EAAI,iBAAmB,mBACnCrH,MAAO+Z,EAAQhI,EAAOzW,GAAO,GAAG0E,OAChCI,IAAK6b,EAAUlC,EAAQhI,EAAOzW,GAAO,GAAG0E,OAAQqH,IAElDoD,EAAO,CACLtP,KAAMkM,EAAM,EAAI,aAAe,eAC/BrH,MAAO+Z,EAAQhI,EAAO9M,GAAM,GAAG7E,KAC/BA,IAAK2Z,EAAQhI,EAAOzW,GAAO,GAAG0E,QAEhCwc,EAAQ,CACNrhB,KAAMkM,EAAM,EAAI,SAAW,WAC3BrH,MAAO+Z,EAAQ0C,EAAgBzc,OAC/BI,IAAK2Z,EAAQ2C,EAAgBtc,MAE/B2R,EAAO9M,GAAM,GAAG7E,IAAM2Z,EAAQ0C,EAAgBzc,OAC9C+R,EAAOzW,GAAO,GAAG0E,MAAQ+Z,EAAQ2C,EAAgBtc,KACjDuc,EAAa,GAET5K,EAAO9M,GAAM,GAAG7E,IAAID,OAAS4R,EAAO9M,GAAM,GAAGjF,MAAMG,SACrDwc,EAAab,EAAYa,EAAY,CAAC,CAAC,QAAS5K,EAAO9M,GAAM,GAAIkN,GAAU,CAAC,OAAQJ,EAAO9M,GAAM,GAAIkN,MAIvGwK,EAAab,EAAYa,EAAY,CAAC,CAAC,QAASH,EAAOrK,GAAU,CAAC,QAASsK,EAAiBtK,GAAU,CAAC,OAAQsK,EAAiBtK,GAAU,CAAC,QAAS1H,EAAM0H,KAE1JwK,EAAab,EAAYa,EAAY1C,EAAW9H,EAAQoC,OAAOsC,WAAWX,WAAWC,KAAMpE,EAAO/L,MAAMf,EAAO,EAAG3J,GAAQ6W,IAE1HwK,EAAab,EAAYa,EAAY,CAAC,CAAC,OAAQlS,EAAM0H,GAAU,CAAC,QAASuK,EAAiBvK,GAAU,CAAC,OAAQuK,EAAiBvK,GAAU,CAAC,OAAQqK,EAAOrK,KAEpJJ,EAAOzW,GAAO,GAAG8E,IAAID,OAAS4R,EAAOzW,GAAO,GAAG0E,MAAMG,QACvDA,EAAS,EACTwc,EAAab,EAAYa,EAAY,CAAC,CAAC,QAAS5K,EAAOzW,GAAO,GAAI6W,GAAU,CAAC,OAAQJ,EAAOzW,GAAO,GAAI6W,MAEvGhS,EAAS,EAGX4b,EAAchK,EAAQ9M,EAAO,EAAG3J,EAAQ2J,EAAO,EAAG0X,GAClDrhB,EAAQ2J,EAAO0X,EAAWliB,OAAS0F,EAAS,EAC5C,MAOR7E,GAAS,EAET,OAASA,EAAQyW,EAAOtX,QACQ,sBAA1BsX,EAAOzW,GAAO,GAAGH,OACnB4W,EAAOzW,GAAO,GAAGH,KAAO,QAI5B,OAAO4W,IAmCT7Z,EAAOC,QAAUsd,qCCjJjB,IAAIZ,EAAa,EAAQ,MAErBE,EAAoB,EAAQ,MAE5BC,EAAa,EAAQ,MAErB4H,EAAe,EAAQ,MAEvBnQ,EAAW,CACb9S,KAAM,WACN6c,SAGF,SAA0BC,EAASgB,EAAIkC,GACrC,IAAID,EAAO,EACX,OAEA,SAAezO,GAMb,OALAwL,EAAQjK,MAAM,YACdiK,EAAQjK,MAAM,kBACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,kBACbuH,EAAQjK,MAAM,oBACPvH,GAGT,SAASA,EAAKgG,GACZ,OAAI4J,EAAW5J,IACbwL,EAAQK,QAAQ7L,GACT4R,GAGF7H,EAAW/J,GAAQ6R,EAAW7R,GAAQ0O,EAAI1O,GAGnD,SAAS4R,EAAmB5R,GAC1B,OAAgB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAe8J,EAAkB9J,GAAQ8R,EAAyB9R,GAAQ6R,EAAW7R,GAG5H,SAAS8R,EAAyB9R,GAChC,OAAa,KAATA,GACFwL,EAAQK,QAAQ7L,GACT+R,IAGK,KAAT/R,GAAwB,KAATA,GAAwB,KAATA,GAAe8J,EAAkB9J,KAAUyO,IAAS,IACrFjD,EAAQK,QAAQ7L,GACT8R,GAGFD,EAAW7R,GAGpB,SAAS+R,EAAU/R,GACjB,OAAa,KAATA,GACFwL,EAAQvH,KAAK,oBACN9O,EAAI6K,IAGA,KAATA,GAAwB,KAATA,GAAe2R,EAAa3R,GACtC0O,EAAI1O,IAGbwL,EAAQK,QAAQ7L,GACT+R,GAGT,SAASF,EAAW7R,GAClB,OAAa,KAATA,GACFwL,EAAQK,QAAQ7L,GAChByO,EAAO,EACAuD,GAGLjI,EAAW/J,IACbwL,EAAQK,QAAQ7L,GACT6R,GAGFnD,EAAI1O,GAGb,SAASgS,EAAiBhS,GACxB,OAAO8J,EAAkB9J,GAAQiS,EAAWjS,GAAQ0O,EAAI1O,GAG1D,SAASiS,EAAWjS,GAClB,OAAa,KAATA,GACFwL,EAAQK,QAAQ7L,GAChByO,EAAO,EACAuD,GAGI,KAAThS,GAEFwL,EAAQvH,KAAK,oBAAoB/T,KAAO,gBACjCiF,EAAI6K,IAGNkS,EAAWlS,GAGpB,SAASkS,EAAWlS,GAClB,OAAc,KAATA,GAAe8J,EAAkB9J,KAAUyO,IAAS,IACvDjD,EAAQK,QAAQ7L,GACA,KAATA,EAAckS,EAAaD,GAG7BvD,EAAI1O,GAGb,SAAS7K,EAAI6K,GAKX,OAJAwL,EAAQjK,MAAM,kBACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,kBACbuH,EAAQvH,KAAK,YACNuI,KAIXvf,EAAOC,QAAUsU,qCCxHjB,IAAI2Q,EAAgB,EAAQ,MAExB7G,EAAe,EAAQ,KAEvBxJ,EAAa,CACfpT,KAAM,aACN6c,SAOF,SAAiCC,EAASgB,EAAIkC,GAC5C,IAAIrC,EAAO7D,KACX,OAEA,SAAexI,GACb,GAAa,KAATA,EAYF,OAXKqM,EAAKM,eAAe3S,OACvBwR,EAAQjK,MAAM,aAAc,CAC1B6Q,YAAY,IAEd/F,EAAKM,eAAe3S,MAAO,GAG7BwR,EAAQjK,MAAM,oBACdiK,EAAQjK,MAAM,oBACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,oBACNmN,EAGT,OAAO1C,EAAI1O,IAGb,SAASoR,EAAMpR,GACb,OAAImS,EAAcnS,IAChBwL,EAAQjK,MAAM,8BACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,8BACbuH,EAAQvH,KAAK,oBACNuI,IAGThB,EAAQvH,KAAK,oBACNuI,EAAGxM,MAvCZ4M,aAAc,CACZrB,SA0CJ,SAAwCC,EAASgB,EAAIkC,GACnD,OAAOpD,EAAaE,EAASA,EAAQG,QAAQ7J,EAAY0K,EAAIkC,GAAM,aAAclG,KAAKc,OAAOsC,WAAWR,QAAQF,KAAK7U,QAAQ,iBAAmB,OAAI1B,EAAY,KAzChKsP,KA4CF,SAAcuH,GACZA,EAAQvH,KAAK,gBAGfhX,EAAOC,QAAU4U,qCC1DjB,IAAIoI,EAAmB,EAAQ,MAE3BnI,EAAkB,CACpBrT,KAAM,kBACN6c,SAGF,SAAiCC,EAASgB,EAAIkC,GAC5C,OAEA,SAAe1O,GAKb,OAJAwL,EAAQjK,MAAM,mBACdiK,EAAQjK,MAAM,gBACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,gBACNjK,GAGT,SAASA,EAAKgG,GACZ,OAAIkK,EAAiBlK,IACnBwL,EAAQjK,MAAM,wBACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,wBACbuH,EAAQvH,KAAK,mBACNuI,GAGFkC,EAAI1O,MAIf/S,EAAOC,QAAU6U,qCC/BjB,IAAIsQ,EAAe,EAAQ,MAEvBvI,EAAoB,EAAQ,MAE5BE,EAAa,EAAQ,MAErBC,EAAgB,EAAQ,MAE5B,SAASqI,EAAsB/gB,GAC7B,OAAOA,GAAkB,iBAANA,GAAkB,YAAaA,EAAIA,EAAI,CACxDghB,QAAShhB,GAIb,IAAIihB,EAAqCF,EAAsBD,GAE3DrQ,EAAqB,CACvBtT,KAAM,qBACN6c,SAGF,SAAoCC,EAASgB,EAAIkC,GAC/C,IAEI+D,EACAC,EAHArG,EAAO7D,KACPiG,EAAO,EAGX,OAEA,SAAezO,GAKb,OAJAwL,EAAQjK,MAAM,sBACdiK,EAAQjK,MAAM,4BACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,4BACNjK,GAGT,SAASA,EAAKgG,GACZ,OAAa,KAATA,GACFwL,EAAQjK,MAAM,mCACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,mCACN0O,IAGTnH,EAAQjK,MAAM,2BACdkR,EAAM,GACNC,EAAO5I,EACAjb,EAAMmR,IAGf,SAAS2S,EAAQ3S,GACf,OAAa,KAATA,GAAwB,MAATA,GACjBwL,EAAQjK,MAAM,uCACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,uCACbuH,EAAQjK,MAAM,2BACdkR,EAAM,EACNC,EAAOzI,EACApb,IAGT2c,EAAQjK,MAAM,2BACdkR,EAAM,EACNC,EAAO1I,EACAnb,EAAMmR,IAGf,SAASnR,EAAMmR,GACb,IAAIuI,EAEJ,OAAa,KAATvI,GAAeyO,GACjBlG,EAAQiD,EAAQvH,KAAK,2BAEjByO,IAAS5I,GAAsB0I,EAA+B,QAAEnG,EAAK5E,eAAec,KAIxFiD,EAAQjK,MAAM,4BACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,4BACbuH,EAAQvH,KAAK,sBACNuI,GAPEkC,EAAI1O,IAUX0S,EAAK1S,IAASyO,IAASgE,GACzBjH,EAAQK,QAAQ7L,GACTnR,GAGF6f,EAAI1O,MAIf/S,EAAOC,QAAU8U,oCC7FjB,IAAIqJ,EAAqB,EAAQ,MAE7BuH,EAA4B,EAAQ,MAEpCC,EAAa,EAAQ,MAErBvH,EAAe,EAAQ,KAEvBrJ,EAAa,CACfvT,KAAM,aACN6c,SAIF,SAA4BC,EAASgB,EAAIkC,GACvC,IAOIuC,EAPA5E,EAAO7D,KACPsK,EAAwB,CAC1BvH,SA+GF,SAA8BC,EAASgB,EAAIkC,GACzC,IAAID,EAAO,EACX,OAAOnD,EAAaE,EAASuH,EAAsB,aAAcvK,KAAKc,OAAOsC,WAAWR,QAAQF,KAAK7U,QAAQ,iBAAmB,OAAI1B,EAAY,GAEhJ,SAASoe,EAAqB/S,GAG5B,OAFAwL,EAAQjK,MAAM,mBACdiK,EAAQjK,MAAM,2BACPkQ,EAAgBzR,GAGzB,SAASyR,EAAgBzR,GACvB,OAAIA,IAASiR,GACXzF,EAAQK,QAAQ7L,GAChByO,IACOgD,GAGLhD,EAAOuE,EAAiBtE,EAAI1O,IAChCwL,EAAQvH,KAAK,2BACNqH,EAAaE,EAASyH,EAAoB,aAA1C3H,CAAwDtL,IAGjE,SAASiT,EAAmBjT,GAC1B,OAAa,OAATA,GAAiBqL,EAAmBrL,IACtCwL,EAAQvH,KAAK,mBACNuI,EAAGxM,IAGL0O,EAAI1O,KA1Ib6N,SAAS,GAEPqF,EAAgBL,EAAWrK,KAAK1B,OAAQ,cACxCkM,EAAW,EAEf,OAEA,SAAehT,GAKb,OAJAwL,EAAQjK,MAAM,cACdiK,EAAQjK,MAAM,mBACdiK,EAAQjK,MAAM,2BACd0P,EAASjR,EACFmT,EAAanT,IAGtB,SAASmT,EAAanT,GACpB,OAAIA,IAASiR,GACXzF,EAAQK,QAAQ7L,GAChBgT,IACOG,IAGT3H,EAAQvH,KAAK,2BACN+O,EAAW,EAAItE,EAAI1O,GAAQsL,EAAaE,EAAS4H,EAAU,aAAhC9H,CAA8CtL,IAGlF,SAASoT,EAASpT,GAChB,OAAa,OAATA,GAAiBqL,EAAmBrL,GAC/BqT,EAAUrT,IAGnBwL,EAAQjK,MAAM,uBACdiK,EAAQjK,MAAM,cAAe,CAC3BwK,YAAa,WAERuH,EAAKtT,IAGd,SAASsT,EAAKtT,GACZ,OAAa,OAATA,GAAiB4S,EAA0B5S,IAC7CwL,EAAQvH,KAAK,eACbuH,EAAQvH,KAAK,uBACNqH,EAAaE,EAAS+H,EAAW,aAAjCjI,CAA+CtL,IAG3C,KAATA,GAAeA,IAASiR,EAAevC,EAAI1O,IAC/CwL,EAAQK,QAAQ7L,GACTsT,GAGT,SAASC,EAAUvT,GACjB,OAAa,OAATA,GAAiBqL,EAAmBrL,GAC/BqT,EAAUrT,IAGnBwL,EAAQjK,MAAM,uBACdiK,EAAQjK,MAAM,cAAe,CAC3BwK,YAAa,WAERrD,EAAK1I,IAGd,SAAS0I,EAAK1I,GACZ,OAAa,OAATA,GAAiBqL,EAAmBrL,IACtCwL,EAAQvH,KAAK,eACbuH,EAAQvH,KAAK,uBACNoP,EAAUrT,IAGN,KAATA,GAAeA,IAASiR,EAAevC,EAAI1O,IAC/CwL,EAAQK,QAAQ7L,GACT0I,GAGT,SAAS2K,EAAUrT,GAEjB,OADAwL,EAAQvH,KAAK,mBACNoI,EAAKc,UAAYX,EAAGxM,GAAQ2O,EAAQ3O,GAG7C,SAAS2O,EAAQ3O,GACf,OAAa,OAATA,EACKoR,EAAMpR,GAGXqL,EAAmBrL,IACrBwL,EAAQjK,MAAM,cACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,cACNuH,EAAQG,QAAQmH,EAAuB1B,EAAO8B,EAAgB5H,EAAaE,EAASmD,EAAS,aAAcuE,EAAgB,GAAKvE,KAGzInD,EAAQjK,MAAM,iBACPiS,EAAgBxT,IAGzB,SAASwT,EAAgBxT,GACvB,OAAa,OAATA,GAAiBqL,EAAmBrL,IACtCwL,EAAQvH,KAAK,iBACN0K,EAAQ3O,KAGjBwL,EAAQK,QAAQ7L,GACTwT,GAGT,SAASpC,EAAMpR,GAEb,OADAwL,EAAQvH,KAAK,cACNuI,EAAGxM,KAlHZgN,UAAU,GAsJZ/f,EAAOC,QAAU+U,qCCjKjB,IAAIoJ,EAAqB,EAAQ,MAE7ByF,EAAgB,EAAQ,MAExB+B,EAAa,EAAQ,MAErBvH,EAAe,EAAQ,KAEvBhJ,EAAe,CACjB5T,KAAM,eACN6c,SAmBF,SAA8BC,EAASgB,EAAIkC,GACzC,OAAOlD,EAAQG,QAAQ8H,EAA0BC,EAAahF,GAE9D,SAASgF,EAAY1T,GACnB,OAAa,OAATA,EACKwM,EAAGxM,GAGRqL,EAAmBrL,GACdwL,EAAQG,QAAQ8H,EAA0BC,EAAalH,EAAvDhB,CAA2DxL,IAGpEwL,EAAQjK,MAAM,iBACPoN,EAAQ3O,IAGjB,SAAS2O,EAAQ3O,GACf,OAAa,OAATA,GAAiBqL,EAAmBrL,IACtCwL,EAAQvH,KAAK,iBACNyP,EAAY1T,KAGrBwL,EAAQK,QAAQ7L,GACT2O,KAzCTgF,QAOF,SAA6B7M,EAAQI,GACnC,IAAIlH,EAAO,CACT9P,KAAM,eACN6E,MAAO+R,EAAO,GAAG,GAAG/R,MACpBI,IAAK2R,EAAOA,EAAOtX,OAAS,GAAG,GAAG2F,KAIpC,OAFA2b,EAAchK,EAAQ,EAAG,EAAG,CAAC,CAAC,QAAS9G,EAAMkH,KAC7C4J,EAAchK,EAAQA,EAAOtX,OAAQ,EAAG,CAAC,CAAC,OAAQwQ,EAAMkH,KACjDJ,IAbL2M,EAA2B,CAC7BlI,SA0CF,SAAiCC,EAASgB,EAAIkC,GAC5C,IAAIrC,EAAO7D,KACX,OAAO8C,EAAaE,GAEpB,SAASkI,EAAY1T,GACnB,GAAIqL,EAAmBrL,GAIrB,OAHAwL,EAAQjK,MAAM,cACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,cACNqH,EAAaE,EAASkI,EAAa,aAAc,GAG1D,OAAOb,EAAWxG,EAAKvF,OAAQ,cAAgB,EAAI4H,EAAI1O,GAAQwM,EAAGxM,KAV1B,aAAc,IA3CxD6N,SAAS,GAyDX5gB,EAAOC,QAAUoV,qCCxEjB,IAAI+I,EAAqB,EAAQ,MAE7B9I,EAAW,CACb7T,KAAM,WACN6c,SAwDF,SAA0BC,EAASgB,EAAIkC,GACrC,IACID,EACAlG,EAFAyK,EAAW,EAGf,OAEA,SAAehT,GAGb,OAFAwL,EAAQjK,MAAM,YACdiK,EAAQjK,MAAM,oBACPiQ,EAAgBxR,IAGzB,SAASwR,EAAgBxR,GACvB,OAAa,KAATA,GACFwL,EAAQK,QAAQ7L,GAChBgT,IACOxB,IAGThG,EAAQvH,KAAK,oBACN2P,EAAI5T,IAGb,SAAS4T,EAAI5T,GAEX,OAAa,OAATA,EACK0O,EAAI1O,GAKA,KAATA,GACFuI,EAAQiD,EAAQjK,MAAM,oBACtBkN,EAAO,EACAgD,EAAgBzR,IAIZ,KAATA,GACFwL,EAAQjK,MAAM,SACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,SACN2P,GAGLvI,EAAmBrL,IACrBwL,EAAQjK,MAAM,cACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,cACN2P,IAITpI,EAAQjK,MAAM,gBACPkB,EAAKzC,IAId,SAASyC,EAAKzC,GACZ,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAeqL,EAAmBrL,IACpEwL,EAAQvH,KAAK,gBACN2P,EAAI5T,KAGbwL,EAAQK,QAAQ7L,GACTyC,GAIT,SAASgP,EAAgBzR,GAEvB,OAAa,KAATA,GACFwL,EAAQK,QAAQ7L,GAChByO,IACOgD,GAILhD,IAASuE,GACXxH,EAAQvH,KAAK,oBACbuH,EAAQvH,KAAK,YACNuI,EAAGxM,KAIZuI,EAAMrY,KAAO,eACNuS,EAAKzC,MA7Id2T,QAIF,SAAyB7M,GACvB,IAEIzW,EACAkR,EAHAsS,EAAgB/M,EAAOtX,OAAS,EAChCskB,EAAiB,EAIrB,KAAwC,eAAnChN,EAAOgN,GAAgB,GAAG5jB,MAA4D,UAAnC4W,EAAOgN,GAAgB,GAAG5jB,MAAwD,eAAlC4W,EAAO+M,GAAe,GAAG3jB,MAA2D,UAAlC4W,EAAO+M,GAAe,GAAG3jB,MAGjL,IAFAG,EAAQyjB,IAECzjB,EAAQwjB,GACf,GAA8B,iBAA1B/M,EAAOzW,GAAO,GAAGH,KAAyB,CAE5C4W,EAAO+M,GAAe,GAAG3jB,KAAO4W,EAAOgN,GAAgB,GAAG5jB,KAAO,kBACjE4jB,GAAkB,EAClBD,GAAiB,EACjB,MAMNxjB,EAAQyjB,EAAiB,EACzBD,IAEA,OAASxjB,GAASwjB,QACFlf,IAAV4M,EACElR,IAAUwjB,GAA2C,eAA1B/M,EAAOzW,GAAO,GAAGH,OAC9CqR,EAAQlR,GAEDA,IAAUwjB,GAA2C,eAA1B/M,EAAOzW,GAAO,GAAGH,OACrD4W,EAAOvF,GAAO,GAAGrR,KAAO,eAEpBG,IAAUkR,EAAQ,IACpBuF,EAAOvF,GAAO,GAAGpM,IAAM2R,EAAOzW,EAAQ,GAAG,GAAG8E,IAC5C2R,EAAO1N,OAAOmI,EAAQ,EAAGlR,EAAQkR,EAAQ,GACzCsS,GAAiBxjB,EAAQkR,EAAQ,EACjClR,EAAQkR,EAAQ,GAGlBA,OAAQ5M,GAIZ,OAAOmS,GA9CP2E,SAiDF,SAAkBzL,GAEhB,OAAgB,KAATA,GAA+D,oBAAhDwI,KAAK1B,OAAO0B,KAAK1B,OAAOtX,OAAS,GAAG,GAAGU,OA6F/DjD,EAAOC,QAAUqV,qCCtJjB,IAAI8I,EAAqB,EAAQ,MAE7BwH,EAAa,EAAQ,MAErBzC,EAAc,EAAQ,MAEtB9E,EAAe,EAAQ,KAGvBqD,EAAU,CACZpD,SAgBF,SAAyBC,EAASgB,GAChC,IAAIf,EACJ,OAEA,SAAezL,GAKb,OAJAwL,EAAQjK,MAAM,WACdkK,EAAWD,EAAQjK,MAAM,eAAgB,CACvCwK,YAAa,YAERtJ,EAAKzC,IAGd,SAASyC,EAAKzC,GACZ,OAAa,OAATA,EACK+T,EAAW/T,GAGhBqL,EAAmBrL,GACdwL,EAAQkC,MAAMsG,EAAuBR,EAAiBO,EAAtDvI,CAAkExL,IAI3EwL,EAAQK,QAAQ7L,GACTyC,GAGT,SAASsR,EAAW/T,GAGlB,OAFAwL,EAAQvH,KAAK,gBACbuH,EAAQvH,KAAK,WACNuI,EAAGxM,GAGZ,SAASwT,EAAgBxT,GAOvB,OANAwL,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,gBACbwH,EAAWA,EAASO,KAAOR,EAAQjK,MAAM,eAAgB,CACvDwK,YAAa,UACbN,SAAUA,IAELhJ,IAtDTkR,QAUF,SAAwB7M,GAEtB,OADAsJ,EAAYtJ,GACLA,GAXPsG,eAAe,EACfI,MAAM,GAEJwG,EAAwB,CAC1BzI,SAqDF,SAA8BC,EAASgB,EAAIkC,GACzC,IAAIrC,EAAO7D,KACX,OAEA,SAAwBxI,GAItB,OAHAwL,EAAQjK,MAAM,cACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,cACNqH,EAAaE,EAASyI,EAAU,eAGzC,SAASA,EAASjU,GAChB,OAAa,OAATA,GAAiBqL,EAAmBrL,GAC/B0O,EAAI1O,GAGTqM,EAAK/C,OAAOsC,WAAWR,QAAQF,KAAK7U,QAAQ,iBAAmB,GAAKwc,EAAWxG,EAAKvF,OAAQ,cAAgB,EACvG0E,EAAQ2B,UAAUd,EAAK/C,OAAOsC,WAAWZ,KAAM0D,EAAKlC,EAApDhB,CAAwDxL,GAG1DwM,EAAGxM,KAxEZ6N,SAAS,GA4EX5gB,EAAOC,QAAUyhB,qCC7FjB,IAAItD,EAAqB,EAAQ,MAE7BuH,EAA4B,EAAQ,MAEpChK,EAAsB,EAAQ,KAE9BsL,EAAqB,EAAQ,MAE7BC,EAAe,EAAQ,MAEvB7I,EAAe,EAAQ,KAEvB8I,EAAoB,EAAQ,MAE5BC,EAAe,EAAQ,MAEvBxU,EAAa,CACfnR,KAAM,aACN6c,SAOF,SAA4BC,EAASgB,EAAIkC,GACvC,IACIlY,EADA6V,EAAO7D,KAEX,OAEA,SAAexI,GAEb,OADAwL,EAAQjK,MAAM,cACP4S,EAAanmB,KAAKqe,EAAMb,EAAS8I,EAAY5F,EAAK,kBAAmB,wBAAyB,wBAA9FyF,CAAuHnU,IAGhI,SAASsU,EAAWtU,GAGlB,OAFAxJ,EAAaoS,EAAoByD,EAAK5E,eAAe4E,EAAKvF,OAAOuF,EAAKvF,OAAOtX,OAAS,GAAG,IAAIuL,MAAM,GAAI,IAE1F,KAATiF,GACFwL,EAAQjK,MAAM,oBACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,oBAENmQ,EAAkB5I,EAAS0I,EAAmB1I,EAASA,EAAQG,QAAQ4I,EAAgBjJ,EAAaE,EAAS4F,EAAO,cAAe9F,EAAaE,EAAS4F,EAAO,eAAgB1C,EAAK,wBAAyB,+BAAgC,qCAAsC,2BAA4B,iCAGlTA,EAAI1O,GAGb,SAASoR,EAAMpR,GACb,OAAa,OAATA,GAAiBqL,EAAmBrL,IACtCwL,EAAQvH,KAAK,cAEToI,EAAK/C,OAAO2G,QAAQ5Z,QAAQG,GAAc,GAC5C6V,EAAK/C,OAAO2G,QAAQlf,KAAKyF,GAGpBgW,EAAGxM,IAGL0O,EAAI1O,MAxCXuU,EAAiB,CACnBhJ,SA2CF,SAAuBC,EAASgB,EAAIkC,GAClC,OAEA,SAAe1O,GACb,OAAO4S,EAA0B5S,GAAQoU,EAAkB5I,EAAS0F,EAA3BkD,CAAmCpU,GAAQ0O,EAAI1O,IAG1F,SAASkR,EAAOlR,GACd,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,EACzBqU,EAAa7I,EAASF,EAAaE,EAAS4F,EAAO,cAAe1C,EAAK,kBAAmB,wBAAyB,wBAAnH2F,CAA4IrU,GAG9I0O,EAAI1O,GAGb,SAASoR,EAAMpR,GACb,OAAgB,OAATA,GAAiBqL,EAAmBrL,GAAQwM,EAAGxM,GAAQ0O,EAAI1O,KA1DpE6N,SAAS,GA8DX5gB,EAAOC,QAAU2S,qCCpFjB,IAAI8R,EAAe,EAAQ,MAEvBiB,EAA4B,EAAQ,MAEpCvH,EAAqB,EAAQ,MAoHjCpe,EAAOC,QAjHP,SAA4Bse,EAASgB,EAAIkC,EAAKxe,EAAMskB,EAAaC,EAAmBC,EAASC,EAAYlC,GACvG,IAAImC,EAAQnC,GAAOoC,EAAAA,EACfC,EAAU,EACd,OAEA,SAAe9U,GACb,GAAa,KAATA,EAMF,OALAwL,EAAQjK,MAAMrR,GACdsb,EAAQjK,MAAMiT,GACdhJ,EAAQjK,MAAMkT,GACdjJ,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAKwQ,GACNM,EAGT,GAAIpD,EAAa3R,IAAkB,KAATA,EACxB,OAAO0O,EAAI1O,GASb,OANAwL,EAAQjK,MAAMrR,GACdsb,EAAQjK,MAAMmT,GACdlJ,EAAQjK,MAAMoT,GACdnJ,EAAQjK,MAAM,cAAe,CAC3BwK,YAAa,WAERiJ,EAAehV,IAGxB,SAAS+U,EAA0B/U,GACjC,OAAa,KAATA,GACFwL,EAAQjK,MAAMkT,GACdjJ,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAKwQ,GACbjJ,EAAQvH,KAAKuQ,GACbhJ,EAAQvH,KAAK/T,GACNsc,IAGThB,EAAQjK,MAAMoT,GACdnJ,EAAQjK,MAAM,cAAe,CAC3BwK,YAAa,WAERkJ,EAAoBjV,IAG7B,SAASiV,EAAoBjV,GAC3B,OAAa,KAATA,GACFwL,EAAQvH,KAAK,eACbuH,EAAQvH,KAAK0Q,GACNI,EAA0B/U,IAGtB,OAATA,GAA0B,KAATA,GAAeqL,EAAmBrL,GAC9C0O,EAAI1O,IAGbwL,EAAQK,QAAQ7L,GACA,KAATA,EAAckV,EAA4BD,GAGnD,SAASC,EAA0BlV,GACjC,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAChCwL,EAAQK,QAAQ7L,GACTiV,GAGFA,EAAoBjV,GAG7B,SAASgV,EAAehV,GACtB,OAAa,KAATA,IACI8U,EAAUF,EAAclG,EAAI1O,IAClCwL,EAAQK,QAAQ7L,GACTgV,GAGI,KAAThV,EACG8U,KAQLtJ,EAAQK,QAAQ7L,GACTgV,IARLxJ,EAAQvH,KAAK,eACbuH,EAAQvH,KAAK0Q,GACbnJ,EAAQvH,KAAKyQ,GACblJ,EAAQvH,KAAK/T,GACNsc,EAAGxM,IAOD,OAATA,GAAiB4S,EAA0B5S,GACzC8U,EAAgBpG,EAAI1O,IACxBwL,EAAQvH,KAAK,eACbuH,EAAQvH,KAAK0Q,GACbnJ,EAAQvH,KAAKyQ,GACblJ,EAAQvH,KAAK/T,GACNsc,EAAGxM,IAGR2R,EAAa3R,GAAc0O,EAAI1O,IACnCwL,EAAQK,QAAQ7L,GACA,KAATA,EAAcmV,EAAuBH,GAG9C,SAASG,EAAqBnV,GAC5B,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAChCwL,EAAQK,QAAQ7L,GACTgV,GAGFA,EAAehV,wCCpH1B,IAAIqL,EAAqB,EAAQ,MAE7B8G,EAAgB,EAAQ,MAyE5BllB,EAAOC,QAtEP,SAAsBse,EAASgB,EAAIkC,EAAKxe,EAAMklB,EAAYT,GACxD,IAEIlS,EAFA4J,EAAO7D,KACPiG,EAAO,EAEX,OAEA,SAAezO,GAMb,OALAwL,EAAQjK,MAAMrR,GACdsb,EAAQjK,MAAM6T,GACd5J,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAKmR,GACb5J,EAAQjK,MAAMoT,GACPvF,GAGT,SAASA,EAAQpP,GACf,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,IAAgByC,GAE3C,KAATzC,IAECyO,GAED,2BAA4BpC,EAAK/C,OAAOsC,YAAc6C,EAAO,IACpDC,EAAI1O,GAGA,KAATA,GACFwL,EAAQvH,KAAK0Q,GACbnJ,EAAQjK,MAAM6T,GACd5J,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAKmR,GACb5J,EAAQvH,KAAK/T,GACNsc,GAGLnB,EAAmBrL,IACrBwL,EAAQjK,MAAM,cACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,cACNmL,IAGT5D,EAAQjK,MAAM,cAAe,CAC3BwK,YAAa,WAER1I,EAAMrD,IAGf,SAASqD,EAAMrD,GACb,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAeqL,EAAmBrL,IAASyO,IAAS,KACtFjD,EAAQvH,KAAK,eACNmL,EAAQpP,KAGjBwL,EAAQK,QAAQ7L,GAChByC,EAAOA,IAAS0P,EAAcnS,GACd,KAATA,EAAcqV,EAAchS,GAGrC,SAASgS,EAAYrV,GACnB,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAChCwL,EAAQK,QAAQ7L,GAChByO,IACOpL,GAGFA,EAAMrD,uCCvEjB,IAAImS,EAAgB,EAAQ,MA2B5BllB,EAAOC,QAzBP,SAAsBse,EAASgB,EAAItc,EAAMuiB,GACvC,IAAImC,EAAQnC,EAAMA,EAAM,EAAIoC,EAAAA,EACxBpG,EAAO,EACX,OAEA,SAAezO,GACb,GAAImS,EAAcnS,GAEhB,OADAwL,EAAQjK,MAAMrR,GACPolB,EAAOtV,GAGhB,OAAOwM,EAAGxM,IAGZ,SAASsV,EAAOtV,GACd,OAAImS,EAAcnS,IAASyO,IAASmG,GAClCpJ,EAAQK,QAAQ7L,GACTsV,IAGT9J,EAAQvH,KAAK/T,GACNsc,EAAGxM,yCCvBd,IAAIqL,EAAqB,EAAQ,MAE7BC,EAAe,EAAQ,KAwE3Bre,EAAOC,QAtEP,SAAsBse,EAASgB,EAAIkC,EAAKxe,EAAMklB,EAAYT,GACxD,IAAI1D,EACJ,OAEA,SAAejR,GAMb,OALAwL,EAAQjK,MAAMrR,GACdsb,EAAQjK,MAAM6T,GACd5J,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAKmR,GACbnE,EAAkB,KAATjR,EAAc,GAAKA,EACrBuV,GAGT,SAASA,EAAkBvV,GACzB,OAAIA,IAASiR,GACXzF,EAAQjK,MAAM6T,GACd5J,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAKmR,GACb5J,EAAQvH,KAAK/T,GACNsc,IAGThB,EAAQjK,MAAMoT,GACPa,EAAaxV,IAGtB,SAASwV,EAAaxV,GACpB,OAAIA,IAASiR,GACXzF,EAAQvH,KAAK0Q,GACNY,EAAkBtE,IAGd,OAATjR,EACK0O,EAAI1O,GAITqL,EAAmBrL,IACrBwL,EAAQjK,MAAM,cACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,cACNqH,EAAaE,EAASgK,EAAc,gBAG7ChK,EAAQjK,MAAM,cAAe,CAC3BwK,YAAa,WAERvU,EAAMwI,IAGf,SAASxI,EAAMwI,GACb,OAAIA,IAASiR,GAAmB,OAATjR,GAAiBqL,EAAmBrL,IACzDwL,EAAQvH,KAAK,eACNuR,EAAaxV,KAGtBwL,EAAQK,QAAQ7L,GACA,KAATA,EAAcyV,EAAcje,GAGrC,SAASie,EAAYzV,GACnB,OAAIA,IAASiR,GAAmB,KAATjR,GACrBwL,EAAQK,QAAQ7L,GACTxI,GAGFA,EAAMwI,wCCtEjB,IAAIqL,EAAqB,EAAQ,MAE7B8G,EAAgB,EAAQ,MAExB7G,EAAe,EAAQ,KAuB3Bre,EAAOC,QArBP,SAA2Bse,EAASgB,GAClC,IAAIkJ,EACJ,OAEA,SAAS3gB,EAAMiL,GACb,GAAIqL,EAAmBrL,GAKrB,OAJAwL,EAAQjK,MAAM,cACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,cACbyR,GAAO,EACA3gB,EAGT,GAAIod,EAAcnS,GAChB,OAAOsL,EAAaE,EAASzW,EAAO2gB,EAAO,aAAe,aAAnDpK,CAAiEtL,GAG1E,OAAOwM,EAAGxM,wCCvBd,IAAIqL,EAAqB,EAAQ,MAE7BvI,EAAkB,CACpBpU,KAAM,kBACN6c,SAGF,SAAiCC,EAASgB,EAAIkC,GAC5C,OAEA,SAAe1O,GAIb,OAHAwL,EAAQjK,MAAM,mBACdiK,EAAQjK,MAAM,gBACdiK,EAAQK,QAAQ7L,GACThG,GAGT,SAASA,EAAKgG,GACZ,OAAIqL,EAAmBrL,IACrBwL,EAAQvH,KAAK,gBACbuH,EAAQvH,KAAK,mBACNuI,EAAGxM,IAGL0O,EAAI1O,MAIf/S,EAAOC,QAAU4V,oCC5BjB,IAAIuI,EAAqB,EAAQ,MAE7BuH,EAA4B,EAAQ,MAEpCT,EAAgB,EAAQ,MAExBrB,EAAgB,EAAQ,MAExBxF,EAAe,EAAQ,KAEvBb,EAAa,CACf/b,KAAM,aACN6c,SAyCF,SAA4BC,EAASgB,EAAIkC,GACvC,IAAIrC,EAAO7D,KACPiG,EAAO,EACX,OAEA,SAAezO,GAGb,OAFAwL,EAAQjK,MAAM,cACdiK,EAAQjK,MAAM,sBACPoU,EAAgB3V,IAGzB,SAAS2V,EAAgB3V,GACvB,OAAa,KAATA,GAAeyO,IAAS,GAC1BjD,EAAQK,QAAQ7L,GACT2V,GAGI,OAAT3V,GAAiB4S,EAA0B5S,IAC7CwL,EAAQvH,KAAK,sBACNoI,EAAKc,UAAYX,EAAGxM,GAAQ4V,EAAa5V,IAG3C0O,EAAI1O,GAGb,SAAS4V,EAAa5V,GACpB,OAAa,KAATA,GACFwL,EAAQjK,MAAM,sBACP4P,EAASnR,IAGL,OAATA,GAAiBqL,EAAmBrL,IACtCwL,EAAQvH,KAAK,cACNuI,EAAGxM,IAGRmS,EAAcnS,GACTsL,EAAaE,EAASoK,EAAc,aAApCtK,CAAkDtL,IAG3DwL,EAAQjK,MAAM,kBACPkB,EAAKzC,IAGd,SAASmR,EAASnR,GAChB,OAAa,KAATA,GACFwL,EAAQK,QAAQ7L,GACTmR,IAGT3F,EAAQvH,KAAK,sBACN2R,EAAa5V,IAGtB,SAASyC,EAAKzC,GACZ,OAAa,OAATA,GAA0B,KAATA,GAAe4S,EAA0B5S,IAC5DwL,EAAQvH,KAAK,kBACN2R,EAAa5V,KAGtBwL,EAAQK,QAAQ7L,GACTyC,KArGTkR,QAGF,SAA2B7M,EAAQI,GACjC,IAEIyH,EACAnP,EAHAuU,EAAajN,EAAOtX,OAAS,EAC7Bkc,EAAe,EAIkB,eAAjC5E,EAAO4E,GAAc,GAAGxb,OAC1Bwb,GAAgB,GAIdqI,EAAa,EAAIrI,GAA+C,eAA/B5E,EAAOiN,GAAY,GAAG7jB,OACzD6jB,GAAc,GAGmB,uBAA/BjN,EAAOiN,GAAY,GAAG7jB,OAAkCwb,IAAiBqI,EAAa,GAAKA,EAAa,EAAIrI,GAAmD,eAAnC5E,EAAOiN,EAAa,GAAG,GAAG7jB,QACxJ6jB,GAAcrI,EAAe,IAAMqI,EAAa,EAAI,GAGlDA,EAAarI,IACfiD,EAAU,CACRze,KAAM,iBACN6E,MAAO+R,EAAO4E,GAAc,GAAG3W,MAC/BI,IAAK2R,EAAOiN,GAAY,GAAG5e,KAE7BqK,EAAO,CACLtP,KAAM,YACN6E,MAAO+R,EAAO4E,GAAc,GAAG3W,MAC/BI,IAAK2R,EAAOiN,GAAY,GAAG5e,IAC3B4W,YAAa,QAEf+E,EAAchK,EAAQ4E,EAAcqI,EAAarI,EAAe,EAAG,CAAC,CAAC,QAASiD,EAASzH,GAAU,CAAC,QAAS1H,EAAM0H,GAAU,CAAC,OAAQ1H,EAAM0H,GAAU,CAAC,OAAQyH,EAASzH,MAGxK,OAAOJ,IAoET7Z,EAAOC,QAAUud,qCCtHjB,IAAIb,EAAa,EAAQ,MAErBE,EAAoB,EAAQ,MAE5BuB,EAAqB,EAAQ,MAE7BuH,EAA4B,EAAQ,MAEpCT,EAAgB,EAAQ,MAExB7H,EAAe,EAAQ,MAEvBuL,EAAiB,EAAQ,MAEzBC,EAAe,EAAQ,MAEvB7J,EAAmB,EAAQ,MAE3BhJ,EAAW,CACbvU,KAAM,WACN6c,SA8BF,SAA0BC,EAASgB,EAAIkC,GACrC,IACIqH,EACAC,EACA5T,EACA/R,EACA4gB,EALA5E,EAAO7D,KAMX,OAEA,SAAexI,GAIb,OAHAwL,EAAQjK,MAAM,YACdiK,EAAQjK,MAAM,gBACdiK,EAAQK,QAAQ7L,GACThG,GAGT,SAASA,EAAKgG,GACZ,OAAa,KAATA,GACFwL,EAAQK,QAAQ7L,GACTiW,GAGI,KAATjW,GACFwL,EAAQK,QAAQ7L,GACTkW,GAGI,KAATlW,GACFwL,EAAQK,QAAQ7L,GAChB+V,EAAO,EAGA1J,EAAKc,UAAYX,EAAK2J,GAG3BvM,EAAW5J,IACbwL,EAAQK,QAAQ7L,GAChBoC,EAASkI,EAAatK,GACtBgW,GAAW,EACJI,GAGF1H,EAAI1O,GAGb,SAASiW,EAAiBjW,GACxB,OAAa,KAATA,GACFwL,EAAQK,QAAQ7L,GAChB+V,EAAO,EACAM,GAGI,KAATrW,GACFwL,EAAQK,QAAQ7L,GAChB+V,EAAO,EACP3T,EAAS,SACT/R,EAAQ,EACDimB,GAGL1M,EAAW5J,IACbwL,EAAQK,QAAQ7L,GAChB+V,EAAO,EACA1J,EAAKc,UAAYX,EAAK2J,GAGxBzH,EAAI1O,GAGb,SAASqW,EAAkBrW,GACzB,OAAa,KAATA,GACFwL,EAAQK,QAAQ7L,GACTqM,EAAKc,UAAYX,EAAK2J,GAGxBzH,EAAI1O,GAGb,SAASsW,EAAgBtW,GACvB,OAAIA,IAASoC,EAAOyG,WAAWxY,MAC7Bmb,EAAQK,QAAQ7L,GACT3P,IAAU+R,EAAO5S,OAAS6c,EAAKc,UAAYX,EAAKI,EAAe0J,GAGjE5H,EAAI1O,GAGb,SAASkW,EAAclW,GACrB,OAAI4J,EAAW5J,IACbwL,EAAQK,QAAQ7L,GAChBoC,EAASkI,EAAatK,GACfoW,GAGF1H,EAAI1O,GAGb,SAASoW,EAAQpW,GACf,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAe4S,EAA0B5S,GAC9D,KAATA,GAAegW,GAAYF,EAAazf,QAAQ+L,EAAOtB,gBAAkB,GAC3EiV,EAAO,EACA1J,EAAKc,UAAYX,EAAGxM,GAAQ4M,EAAa5M,IAG9C6V,EAAexf,QAAQ+L,EAAOtB,gBAAkB,GAClDiV,EAAO,EAEM,KAAT/V,GACFwL,EAAQK,QAAQ7L,GACTuW,GAGFlK,EAAKc,UAAYX,EAAGxM,GAAQ4M,EAAa5M,KAGlD+V,EAAO,EAEA1J,EAAKc,UAAYuB,EAAI1O,GAAQgW,EAAWQ,EAA4BxW,GAAQyW,EAAwBzW,IAGhG,KAATA,GAAe8J,EAAkB9J,IACnCwL,EAAQK,QAAQ7L,GAChBoC,GAAUkI,EAAatK,GAChBoW,GAGF1H,EAAI1O,GAGb,SAASuW,EAAiBvW,GACxB,OAAa,KAATA,GACFwL,EAAQK,QAAQ7L,GACTqM,EAAKc,UAAYX,EAAKI,GAGxB8B,EAAI1O,GAGb,SAASyW,EAAwBzW,GAC/B,OAAImS,EAAcnS,IAChBwL,EAAQK,QAAQ7L,GACTyW,GAGFC,EAAY1W,GAGrB,SAASwW,EAA4BxW,GACnC,OAAa,KAATA,GACFwL,EAAQK,QAAQ7L,GACT0W,GAGI,KAAT1W,GAAwB,KAATA,GAAe4J,EAAW5J,IAC3CwL,EAAQK,QAAQ7L,GACT2W,GAGLxE,EAAcnS,IAChBwL,EAAQK,QAAQ7L,GACTwW,GAGFE,EAAY1W,GAGrB,SAAS2W,EAAsB3W,GAC7B,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAe8J,EAAkB9J,IAChFwL,EAAQK,QAAQ7L,GACT2W,GAGFC,EAA2B5W,GAGpC,SAAS4W,EAA2B5W,GAClC,OAAa,KAATA,GACFwL,EAAQK,QAAQ7L,GACT6W,GAGL1E,EAAcnS,IAChBwL,EAAQK,QAAQ7L,GACT4W,GAGFJ,EAA4BxW,GAGrC,SAAS6W,EAA6B7W,GACpC,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,EACzD0O,EAAI1O,GAGA,KAATA,GAAwB,KAATA,GACjBwL,EAAQK,QAAQ7L,GAChBiR,EAASjR,EACF8W,GAGL3E,EAAcnS,IAChBwL,EAAQK,QAAQ7L,GACT6W,IAGT5F,OAAStc,EACFoiB,EAA+B/W,IAGxC,SAAS8W,EAA6B9W,GACpC,OAAIA,IAASiR,GACXzF,EAAQK,QAAQ7L,GACTgX,GAGI,OAAThX,GAAiBqL,EAAmBrL,GAC/B0O,EAAI1O,IAGbwL,EAAQK,QAAQ7L,GACT8W,GAGT,SAASC,EAA+B/W,GACtC,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAe4S,EAA0B5S,GAChI4W,EAA2B5W,IAGpCwL,EAAQK,QAAQ7L,GACT+W,GAGT,SAASC,EAAkChX,GACzC,OAAa,KAATA,GAAwB,KAATA,GAAemS,EAAcnS,GACvCwW,EAA4BxW,GAG9B0O,EAAI1O,GAGb,SAAS0W,EAAY1W,GACnB,OAAa,KAATA,GACFwL,EAAQK,QAAQ7L,GACTiX,GAGFvI,EAAI1O,GAGb,SAASiX,EAAcjX,GACrB,OAAImS,EAAcnS,IAChBwL,EAAQK,QAAQ7L,GACTiX,GAGO,OAATjX,GAAiBqL,EAAmBrL,GAAQ4M,EAAa5M,GAAQ0O,EAAI1O,GAG9E,SAAS4M,EAAa5M,GACpB,OAAa,KAATA,GAAwB,IAAT+V,GACjBvK,EAAQK,QAAQ7L,GACTkX,GAGI,KAATlX,GAAwB,IAAT+V,GACjBvK,EAAQK,QAAQ7L,GACTmX,GAGI,KAATnX,GAAwB,IAAT+V,GACjBvK,EAAQK,QAAQ7L,GACToX,GAGI,KAATpX,GAAwB,IAAT+V,GACjBvK,EAAQK,QAAQ7L,GACTmW,GAGI,KAATnW,GAAwB,IAAT+V,GACjBvK,EAAQK,QAAQ7L,GACTqX,IAGLhM,EAAmBrL,IAAmB,IAAT+V,GAAuB,IAATA,EAIlC,OAAT/V,GAAiBqL,EAAmBrL,GAC/BsX,EAAyBtX,IAGlCwL,EAAQK,QAAQ7L,GACT4M,GAREpB,EAAQkC,MAAM6J,EAAoBH,EAAmBE,EAArD9L,CAA+ExL,GAW1F,SAASsX,EAAyBtX,GAEhC,OADAwL,EAAQvH,KAAK,gBACNuT,EAAkBxX,GAG3B,SAASwX,EAAkBxX,GACzB,OAAa,OAATA,EACKyX,EAAKzX,GAGVqL,EAAmBrL,IACrBwL,EAAQjK,MAAM,cACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,cACNuT,IAGThM,EAAQjK,MAAM,gBACPqL,EAAa5M,IAGtB,SAASkX,EAA0BlX,GACjC,OAAa,KAATA,GACFwL,EAAQK,QAAQ7L,GACTmW,GAGFvJ,EAAa5M,GAGtB,SAASmX,EAAuBnX,GAC9B,OAAa,KAATA,GACFwL,EAAQK,QAAQ7L,GAChBoC,EAAS,GACFsV,GAGF9K,EAAa5M,GAGtB,SAAS0X,EAAsB1X,GAC7B,OAAa,KAATA,GAAe8V,EAAazf,QAAQ+L,EAAOtB,gBAAkB,GAC/D0K,EAAQK,QAAQ7L,GACToX,GAGLxN,EAAW5J,IAASoC,EAAO5S,OAAS,GACtCgc,EAAQK,QAAQ7L,GAChBoC,GAAUkI,EAAatK,GAChB0X,GAGF9K,EAAa5M,GAGtB,SAASqX,EAAgCrX,GACvC,OAAa,KAATA,GACFwL,EAAQK,QAAQ7L,GACTmW,GAGFvJ,EAAa5M,GAGtB,SAASmW,EAA8BnW,GACrC,OAAa,KAATA,GACFwL,EAAQK,QAAQ7L,GACToX,GAGFxK,EAAa5M,GAGtB,SAASoX,EAAkBpX,GACzB,OAAa,OAATA,GAAiBqL,EAAmBrL,IACtCwL,EAAQvH,KAAK,gBACNwT,EAAKzX,KAGdwL,EAAQK,QAAQ7L,GACToX,GAGT,SAASK,EAAKzX,GAEZ,OADAwL,EAAQvH,KAAK,YACNuI,EAAGxM,KA1ZZ2X,UAQF,SAA2B7Q,GACzB,IAAIzW,EAAQyW,EAAOtX,OAEnB,KAAOa,MACoB,UAArByW,EAAOzW,GAAO,IAA4C,aAA1ByW,EAAOzW,GAAO,GAAGH,QAKnDG,EAAQ,GAAmC,eAA9ByW,EAAOzW,EAAQ,GAAG,GAAGH,OAEpC4W,EAAOzW,GAAO,GAAG0E,MAAQ+R,EAAOzW,EAAQ,GAAG,GAAG0E,MAE9C+R,EAAOzW,EAAQ,GAAG,GAAG0E,MAAQ+R,EAAOzW,EAAQ,GAAG,GAAG0E,MAElD+R,EAAO1N,OAAO/I,EAAQ,EAAG,IAG3B,OAAOyW,GAzBPkG,UAAU,GAERuK,EAAqB,CACvBhM,SA0ZF,SAA2BC,EAASgB,EAAIkC,GACtC,OAEA,SAAe1O,GAKb,OAJAwL,EAAQvH,KAAK,gBACbuH,EAAQjK,MAAM,mBACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,mBACNuH,EAAQG,QAAQM,EAAkBO,EAAIkC,KAja/Cb,SAAS,GAqaX5gB,EAAOC,QAAU+V,qCC/bjB,IAAI2G,EAAa,EAAQ,MAErBE,EAAoB,EAAQ,MAE5BuB,EAAqB,EAAQ,MAE7BuH,EAA4B,EAAQ,MAEpCT,EAAgB,EAAQ,MAExB7G,EAAe,EAAQ,KAEvBnI,EAAW,CACbzU,KAAM,WACN6c,SAGF,SAA0BC,EAASgB,EAAIkC,GACrC,IACIuC,EACA7O,EACA/R,EACAunB,EAJAvL,EAAO7D,KAKX,OAEA,SAAexI,GAIb,OAHAwL,EAAQjK,MAAM,YACdiK,EAAQjK,MAAM,gBACdiK,EAAQK,QAAQ7L,GACThG,GAGT,SAASA,EAAKgG,GACZ,OAAa,KAATA,GACFwL,EAAQK,QAAQ7L,GACT6X,GAGI,KAAT7X,GACFwL,EAAQK,QAAQ7L,GACTkW,GAGI,KAATlW,GACFwL,EAAQK,QAAQ7L,GACT8X,GAGLlO,EAAW5J,IACbwL,EAAQK,QAAQ7L,GACT+X,GAGFrJ,EAAI1O,GAGb,SAAS6X,EAAgB7X,GACvB,OAAa,KAATA,GACFwL,EAAQK,QAAQ7L,GACTgY,GAGI,KAAThY,GACFwL,EAAQK,QAAQ7L,GAChBoC,EAAS,SACT/R,EAAQ,EACD4nB,GAGLrO,EAAW5J,IACbwL,EAAQK,QAAQ7L,GACTkY,GAGFxJ,EAAI1O,GAGb,SAASgY,EAAYhY,GACnB,OAAa,KAATA,GACFwL,EAAQK,QAAQ7L,GACTmY,GAGFzJ,EAAI1O,GAGb,SAASmY,EAAanY,GACpB,OAAa,OAATA,GAA0B,KAATA,EACZ0O,EAAI1O,GAGA,KAATA,GACFwL,EAAQK,QAAQ7L,GACToY,GAGFC,EAAQrY,GAGjB,SAASoY,EAAiBpY,GACxB,OAAa,OAATA,GAA0B,KAATA,EACZ0O,EAAI1O,GAGNqY,EAAQrY,GAGjB,SAASqY,EAAQrY,GACf,OAAa,OAATA,EACK0O,EAAI1O,GAGA,KAATA,GACFwL,EAAQK,QAAQ7L,GACTsY,GAGLjN,EAAmBrL,IACrB4X,EAAcS,EACPE,EAAavY,KAGtBwL,EAAQK,QAAQ7L,GACTqY,GAGT,SAASC,EAAatY,GACpB,OAAa,KAATA,GACFwL,EAAQK,QAAQ7L,GACT7K,GAGFkjB,EAAQrY,GAGjB,SAASiY,EAAUjY,GACjB,OAAIA,IAASoC,EAAOyG,WAAWxY,MAC7Bmb,EAAQK,QAAQ7L,GACT3P,IAAU+R,EAAO5S,OAASgpB,EAAQP,GAGpCvJ,EAAI1O,GAGb,SAASwY,EAAMxY,GACb,OAAa,OAATA,EACK0O,EAAI1O,GAGA,KAATA,GACFwL,EAAQK,QAAQ7L,GACTyY,GAGLpN,EAAmBrL,IACrB4X,EAAcY,EACPD,EAAavY,KAGtBwL,EAAQK,QAAQ7L,GACTwY,GAGT,SAASC,EAAWzY,GAClB,OAAa,KAATA,GACFwL,EAAQK,QAAQ7L,GACT0Y,GAGFF,EAAMxY,GAGf,SAAS0Y,EAAS1Y,GAChB,OAAa,KAATA,EACK7K,EAAI6K,GAGA,KAATA,GACFwL,EAAQK,QAAQ7L,GACT0Y,GAGFF,EAAMxY,GAGf,SAASkY,EAAYlY,GACnB,OAAa,OAATA,GAA0B,KAATA,EACZ7K,EAAI6K,GAGTqL,EAAmBrL,IACrB4X,EAAcM,EACPK,EAAavY,KAGtBwL,EAAQK,QAAQ7L,GACTkY,GAGT,SAASJ,EAAY9X,GACnB,OAAa,OAATA,EACK0O,EAAI1O,GAGA,KAATA,GACFwL,EAAQK,QAAQ7L,GACT2Y,GAGLtN,EAAmBrL,IACrB4X,EAAcE,EACPS,EAAavY,KAGtBwL,EAAQK,QAAQ7L,GACT8X,GAGT,SAASa,EAAiB3Y,GACxB,OAAgB,KAATA,EAAc7K,EAAI6K,GAAQ8X,EAAY9X,GAG/C,SAASkW,EAAclW,GACrB,OAAI4J,EAAW5J,IACbwL,EAAQK,QAAQ7L,GACT4Y,GAGFlK,EAAI1O,GAGb,SAAS4Y,EAAS5Y,GAChB,OAAa,KAATA,GAAe8J,EAAkB9J,IACnCwL,EAAQK,QAAQ7L,GACT4Y,GAGFC,EAAgB7Y,GAGzB,SAAS6Y,EAAgB7Y,GACvB,OAAIqL,EAAmBrL,IACrB4X,EAAciB,EACPN,EAAavY,IAGlBmS,EAAcnS,IAChBwL,EAAQK,QAAQ7L,GACT6Y,GAGF1jB,EAAI6K,GAGb,SAAS+X,EAAQ/X,GACf,OAAa,KAATA,GAAe8J,EAAkB9J,IACnCwL,EAAQK,QAAQ7L,GACT+X,GAGI,KAAT/X,GAAwB,KAATA,GAAe4S,EAA0B5S,GACnD8Y,EAAe9Y,GAGjB0O,EAAI1O,GAGb,SAAS8Y,EAAe9Y,GACtB,OAAa,KAATA,GACFwL,EAAQK,QAAQ7L,GACT7K,GAGI,KAAT6K,GAAwB,KAATA,GAAe4J,EAAW5J,IAC3CwL,EAAQK,QAAQ7L,GACT+Y,GAGL1N,EAAmBrL,IACrB4X,EAAckB,EACPP,EAAavY,IAGlBmS,EAAcnS,IAChBwL,EAAQK,QAAQ7L,GACT8Y,GAGF3jB,EAAI6K,GAGb,SAAS+Y,EAAqB/Y,GAC5B,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAe8J,EAAkB9J,IAChFwL,EAAQK,QAAQ7L,GACT+Y,GAGFC,EAA0BhZ,GAGnC,SAASgZ,EAA0BhZ,GACjC,OAAa,KAATA,GACFwL,EAAQK,QAAQ7L,GACTiZ,GAGL5N,EAAmBrL,IACrB4X,EAAcoB,EACPT,EAAavY,IAGlBmS,EAAcnS,IAChBwL,EAAQK,QAAQ7L,GACTgZ,GAGFF,EAAe9Y,GAGxB,SAASiZ,EAA4BjZ,GACnC,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,EACzD0O,EAAI1O,GAGA,KAATA,GAAwB,KAATA,GACjBwL,EAAQK,QAAQ7L,GAChBiR,EAASjR,EACFkZ,GAGL7N,EAAmBrL,IACrB4X,EAAcqB,EACPV,EAAavY,IAGlBmS,EAAcnS,IAChBwL,EAAQK,QAAQ7L,GACTiZ,IAGTzN,EAAQK,QAAQ7L,GAChBiR,OAAStc,EACFwkB,GAGT,SAASD,EAA4BlZ,GACnC,OAAIA,IAASiR,GACXzF,EAAQK,QAAQ7L,GACToZ,GAGI,OAATpZ,EACK0O,EAAI1O,GAGTqL,EAAmBrL,IACrB4X,EAAcsB,EACPX,EAAavY,KAGtBwL,EAAQK,QAAQ7L,GACTkZ,GAGT,SAASE,EAAiCpZ,GACxC,OAAa,KAATA,GAAwB,KAATA,GAAe4S,EAA0B5S,GACnD8Y,EAAe9Y,GAGjB0O,EAAI1O,GAGb,SAASmZ,EAA8BnZ,GACrC,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,EACxE0O,EAAI1O,GAGA,KAATA,GAAe4S,EAA0B5S,GACpC8Y,EAAe9Y,IAGxBwL,EAAQK,QAAQ7L,GACTmZ,GAKT,SAASZ,EAAavY,GAKpB,OAJAwL,EAAQvH,KAAK,gBACbuH,EAAQjK,MAAM,cACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,cACNqH,EAAaE,EAASkI,EAAa,aAAcrH,EAAK/C,OAAOsC,WAAWR,QAAQF,KAAK7U,QAAQ,iBAAmB,OAAI1B,EAAY,GAGzI,SAAS+e,EAAY1T,GAEnB,OADAwL,EAAQjK,MAAM,gBACPqW,EAAY5X,GAGrB,SAAS7K,EAAI6K,GACX,OAAa,KAATA,GACFwL,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,gBACbuH,EAAQvH,KAAK,YACNuI,GAGFkC,EAAI1O,MAIf/S,EAAOC,QAAUiW,qCC5ZjB,IAAIyP,EAA4B,EAAQ,MAEpC/B,EAAc,EAAQ,MAEtBC,EAAgB,EAAQ,MAExBlI,EAAsB,EAAQ,KAE9BoG,EAAa,EAAQ,MAErBF,EAAU,EAAQ,MAElBoF,EAAqB,EAAQ,MAE7BC,EAAe,EAAQ,MAEvBE,EAAe,EAAQ,MAEvBD,EAAoB,EAAQ,MAE5B1J,EAAW,CACbhc,KAAM,WACN6c,SAuGF,SAA0BC,EAASgB,EAAIkC,GACrC,IAEI2K,EACApJ,EAHA5D,EAAO7D,KACPnY,EAAQgc,EAAKvF,OAAOtX,OAIxB,KAAOa,KACL,IAAoC,eAA/Bgc,EAAKvF,OAAOzW,GAAO,GAAGH,MAAwD,cAA/Bmc,EAAKvF,OAAOzW,GAAO,GAAGH,QAA0Bmc,EAAKvF,OAAOzW,GAAO,GAAGipB,UAAW,CACnID,EAAahN,EAAKvF,OAAOzW,GAAO,GAChC,MAIJ,OAEA,SAAe2P,GACb,IAAKqZ,EACH,OAAO3K,EAAI1O,GAIb,OAAIqZ,EAAWE,UAAkBC,EAASxZ,IAC1CiQ,EAAU5D,EAAK/C,OAAO2G,QAAQ5Z,QAAQuS,EAAoByD,EAAK5E,eAAe,CAC5E1S,MAAOskB,EAAWlkB,IAClBA,IAAKkX,EAAK8B,WACJ,EACR3C,EAAQjK,MAAM,YACdiK,EAAQjK,MAAM,eACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,eACbuH,EAAQvH,KAAK,YACNwV,IAGT,SAASA,EAAczZ,GAErB,OAAa,KAATA,EACKwL,EAAQG,QAAQ+N,EAAmBlN,EAAIyD,EAAUzD,EAAKgN,EAAtDhO,CAAgExL,GAI5D,KAATA,EACKwL,EAAQG,QAAQgO,EAAwBnN,EAAIyD,EAAUzE,EAAQG,QAAQiO,EAA6BpN,EAAIgN,GAAYA,EAAnHhO,CAA6HxL,GAI/HiQ,EAAUzD,EAAGxM,GAAQwZ,EAASxZ,GAGvC,SAASwZ,EAASxZ,GAEhB,OADAqZ,EAAWC,WAAY,EAChB5K,EAAI1O,KAzJb2X,UA+BF,SAA2B7Q,EAAQI,GACjC,IAEIqK,EACAlO,EACA7D,EACA+I,EACAvO,EACAyO,EACAoR,EARAxpB,EAAQyW,EAAOtX,OACf0F,EAAS,EASb,KAAO7E,KAGL,GAFAkY,EAAQzB,EAAOzW,GAAO,GAElB2J,EAAM,CAER,GAAmB,SAAfuO,EAAMrY,MAAkC,cAAfqY,EAAMrY,MAAwBqY,EAAMgR,UAC/D,MAKuB,UAArBzS,EAAOzW,GAAO,IAAiC,cAAfkY,EAAMrY,OACxCqY,EAAMgR,WAAY,QAEf,GAAI9Q,GACT,GAAyB,UAArB3B,EAAOzW,GAAO,KAAkC,eAAfkY,EAAMrY,MAAwC,cAAfqY,EAAMrY,QAA0BqY,EAAM+Q,YACxGtf,EAAO3J,EAEY,cAAfkY,EAAMrY,MAAsB,CAC9BgF,EAAS,EACT,WAGoB,aAAfqT,EAAMrY,OACfuY,EAAQpY,GAiCZ,OA7BAkhB,EAAQ,CACNrhB,KAA+B,cAAzB4W,EAAO9M,GAAM,GAAG9J,KAAuB,OAAS,QACtD6E,MAAO+Z,EAAQhI,EAAO9M,GAAM,GAAGjF,OAC/BI,IAAK2Z,EAAQhI,EAAOA,EAAOtX,OAAS,GAAG,GAAG2F,MAE5CkO,EAAQ,CACNnT,KAAM,QACN6E,MAAO+Z,EAAQhI,EAAO9M,GAAM,GAAGjF,OAC/BI,IAAK2Z,EAAQhI,EAAO2B,GAAO,GAAGtT,MAEhCqK,EAAO,CACLtP,KAAM,YACN6E,MAAO+Z,EAAQhI,EAAO9M,EAAO9E,EAAS,GAAG,GAAGC,KAC5CA,IAAK2Z,EAAQhI,EAAO2B,EAAQ,GAAG,GAAG1T,QAIpC8kB,EAAQhJ,EAFRgJ,EAAQ,CAAC,CAAC,QAAStI,EAAOrK,GAAU,CAAC,QAAS7D,EAAO6D,IAE1BJ,EAAO/L,MAAMf,EAAO,EAAGA,EAAO9E,EAAS,IAElE2kB,EAAQhJ,EAAYgJ,EAAO,CAAC,CAAC,QAASra,EAAM0H,KAE5C2S,EAAQhJ,EAAYgJ,EAAO7K,EAAW9H,EAAQoC,OAAOsC,WAAWX,WAAWC,KAAMpE,EAAO/L,MAAMf,EAAO9E,EAAS,EAAGuT,EAAQ,GAAIvB,IAE7H2S,EAAQhJ,EAAYgJ,EAAO,CAAC,CAAC,OAAQra,EAAM0H,GAAUJ,EAAO2B,EAAQ,GAAI3B,EAAO2B,EAAQ,GAAI,CAAC,OAAQpF,EAAO6D,KAE3G2S,EAAQhJ,EAAYgJ,EAAO/S,EAAO/L,MAAM0N,EAAQ,IAEhDoR,EAAQhJ,EAAYgJ,EAAO,CAAC,CAAC,OAAQtI,EAAOrK,KAC5C4J,EAAchK,EAAQ9M,EAAM8M,EAAOtX,OAAQqqB,GACpC/S,GAlGPkI,WAYF,SAA4BlI,GAC1B,IACIyB,EADAlY,GAAS,EAGb,OAASA,EAAQyW,EAAOtX,SACtB+Y,EAAQzB,EAAOzW,GAAO,IAEXypB,OAAyB,eAAfvR,EAAMrY,MAAwC,cAAfqY,EAAMrY,MAAuC,aAAfqY,EAAMrY,OAEtF4W,EAAO1N,OAAO/I,EAAQ,EAAkB,eAAfkY,EAAMrY,KAAwB,EAAI,GAC3DqY,EAAMrY,KAAO,OACbG,KAIJ,OAAOyW,IAzBL4S,EAAoB,CACtBnO,SAyJF,SAA0BC,EAASgB,EAAIkC,GACrC,OAEA,SAAe1O,GAKb,OAJAwL,EAAQjK,MAAM,YACdiK,EAAQjK,MAAM,kBACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,kBACNmQ,EAAkB5I,EAASxR,IAGpC,SAASA,EAAKgG,GACZ,OAAa,KAATA,EACK7K,EAAI6K,GAGNkU,EAAmB1I,EAASuO,EAAkBrL,EAAK,sBAAuB,6BAA8B,mCAAoC,yBAA0B,4BAA6B,EAAnMwF,CAAsMlU,GAG/M,SAAS+Z,EAAiB/Z,GACxB,OAAO4S,EAA0B5S,GAAQoU,EAAkB5I,EAASwO,EAA3B5F,CAAoCpU,GAAQ7K,EAAI6K,GAG3F,SAASga,EAAQha,GACf,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,EACzBqU,EAAa7I,EAAS4I,EAAkB5I,EAASrW,GAAMuZ,EAAK,gBAAiB,sBAAuB,sBAApG2F,CAA2HrU,GAG7H7K,EAAI6K,GAGb,SAAS7K,EAAI6K,GACX,OAAa,KAATA,GACFwL,EAAQjK,MAAM,kBACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,kBACbuH,EAAQvH,KAAK,YACNuI,GAGFkC,EAAI1O,MA/LX2Z,EAAyB,CAC3BpO,SAkMF,SAA+BC,EAASgB,EAAIkC,GAC1C,IAAIrC,EAAO7D,KACX,OAEA,SAAexI,GACb,OAAOmU,EAAanmB,KAAKqe,EAAMb,EAASyO,EAAYvL,EAAK,YAAa,kBAAmB,kBAAlFyF,CAAqGnU,IAG9G,SAASia,EAAWja,GAClB,OAAOqM,EAAK/C,OAAO2G,QAAQ5Z,QAAQuS,EAAoByD,EAAK5E,eAAe4E,EAAKvF,OAAOuF,EAAKvF,OAAOtX,OAAS,GAAG,IAAIuL,MAAM,GAAI,KAAO,EAAI2T,EAAI1O,GAAQwM,EAAGxM,MAzMvJ4Z,EAA8B,CAChCrO,SA4MF,SAAoCC,EAASgB,EAAIkC,GAC/C,OAEA,SAAe1O,GAKb,OAJAwL,EAAQjK,MAAM,aACdiK,EAAQjK,MAAM,mBACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,mBACNjK,GAGT,SAASA,EAAKgG,GACZ,OAAa,KAATA,GACFwL,EAAQjK,MAAM,mBACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,mBACbuH,EAAQvH,KAAK,aACNuI,GAGFkC,EAAI1O,MAIf/S,EAAOC,QAAUwd,qCCrQjB,IAEIC,EAAkB,CACpBjc,KAAM,kBACN6c,SAIF,SAAiCC,EAASgB,EAAIkC,GAC5C,IAAIrC,EAAO7D,KACX,OAEA,SAAexI,GAKb,OAJAwL,EAAQjK,MAAM,cACdiK,EAAQjK,MAAM,oBACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,oBACNjK,GAGT,SAASA,EAAKgG,GACZ,OAAa,KAATA,GACFwL,EAAQjK,MAAM,eACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,eACbuH,EAAQvH,KAAK,cACNmN,GAGF1C,EAAI1O,GAGb,SAASoR,EAAMpR,GAEb,OAAgB,KAATA,GAEP,2BAA4BqM,EAAK/C,OAAOsC,WAExC8C,EAAI1O,GAAQwM,EAAGxM,KAjCjBgP,WALa,EAAQ,MAKAA,YAqCvB/hB,EAAOC,QAAUyd,qCC1CjB,IAEIC,EAAiB,CACnBlc,KAAM,iBACN6c,SAIF,SAAgCC,EAASgB,EAAIkC,GAC3C,IAAIrC,EAAO7D,KACX,OAEA,SAAexI,GAMb,OALAwL,EAAQjK,MAAM,aACdiK,EAAQjK,MAAM,eACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,eACbuH,EAAQvH,KAAK,aACNmN,GAGT,SAASA,EAAMpR,GAEb,OAAgB,KAATA,GAEP,2BAA4BqM,EAAK/C,OAAOsC,WAExC8C,EAAI1O,GAAQwM,EAAGxM,KAtBjBgP,WALa,EAAQ,MAKAA,YA0BvB/hB,EAAOC,QAAU0d,qCC/BjB,IAAIU,EAAe,EAAQ,KAEvBvF,EAAa,CACfrX,KAAM,aACN6c,SAGF,SAA4BC,EAASgB,GACnC,OAEA,SAAexM,GAIb,OAHAwL,EAAQjK,MAAM,cACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,cACNqH,EAAaE,EAASgB,EAAI,iBAIrCvf,EAAOC,QAAU6Y,qCClBjB,IAAIiE,EAAa,EAAQ,MAErBmI,EAAgB,EAAQ,MAExBU,EAAa,EAAQ,MAErBqH,EAAa,EAAQ,MAErB5O,EAAe,EAAQ,KAEvBW,EAAmB,EAAQ,MAE3B1N,EAAgB,EAAQ,MAExBkB,EAAO,CACT/Q,KAAM,OACN6c,SAeF,SAA2BC,EAASgB,EAAIkC,GACtC,IAAIrC,EAAO7D,KACP2R,EAActH,EAAWxG,EAAKvF,OAAQ,cACtC2H,EAAO,EACX,OAEA,SAAezO,GACb,IAAI+V,EAAO1J,EAAKM,eAAezc,OAAkB,KAAT8P,GAAwB,KAATA,GAAwB,KAATA,EAAc,gBAAkB,eAEtG,GAAa,kBAAT+V,GAA4B1J,EAAKM,eAAesE,QAAUjR,IAASqM,EAAKM,eAAesE,OAASjH,EAAWhK,GAAO,CAQpH,GAPKqM,EAAKM,eAAezc,OACvBmc,EAAKM,eAAezc,KAAO6lB,EAC3BvK,EAAQjK,MAAMwU,EAAM,CAClB3D,YAAY,KAIH,kBAAT2D,EAEF,OADAvK,EAAQjK,MAAM,kBACE,KAATvB,GAAwB,KAATA,EAAcwL,EAAQkC,MAAMnP,EAAemQ,EAAKzG,EAAlCuD,CAA4CxL,GAAQiI,EAASjI,GAGnG,IAAKqM,EAAKc,WAAsB,KAATnN,EAGrB,OAFAwL,EAAQjK,MAAM,kBACdiK,EAAQjK,MAAM,iBACP6Y,EAAOpa,GAIlB,OAAO0O,EAAI1O,IAGb,SAASoa,EAAOpa,GACd,OAAIgK,EAAWhK,MAAWyO,EAAO,IAC/BjD,EAAQK,QAAQ7L,GACToa,KAGH/N,EAAKc,WAAasB,EAAO,KAAOpC,EAAKM,eAAesE,OAASjR,IAASqM,EAAKM,eAAesE,OAAkB,KAATjR,GAAwB,KAATA,IACtHwL,EAAQvH,KAAK,iBACNgE,EAASjI,IAGX0O,EAAI1O,GAGb,SAASiI,EAASjI,GAKhB,OAJAwL,EAAQjK,MAAM,kBACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,kBACboI,EAAKM,eAAesE,OAAS5E,EAAKM,eAAesE,QAAUjR,EACpDwL,EAAQkC,MAAMzB,EACrBI,EAAKc,UAAYuB,EAAM2L,EAAS7O,EAAQG,QAAQ2O,EAAmCC,EAAaC,IAGlG,SAASH,EAAQra,GAGf,OAFAqM,EAAKM,eAAe8N,kBAAmB,EACvCN,IACOI,EAAYva,GAGrB,SAASwa,EAAYxa,GACnB,OAAImS,EAAcnS,IAChBwL,EAAQjK,MAAM,4BACdiK,EAAQK,QAAQ7L,GAChBwL,EAAQvH,KAAK,4BACNsW,GAGF7L,EAAI1O,GAGb,SAASua,EAAYva,GAEnB,OADAqM,EAAKM,eAAe8B,KAAO0L,EAAcD,EAAW7N,EAAKmC,YAAYhD,EAAQvH,KAAK,oBAC3EuI,EAAGxM,KAxFZ4M,aAAc,CACZrB,SA2FJ,SAAkCC,EAASgB,EAAIkC,GAC7C,IAAIrC,EAAO7D,KAEX,OADA6D,EAAKM,eAAeY,gBAAa5Y,EAC1B6W,EAAQkC,MAAMzB,GAErB,SAAiBjM,GAIf,OAHAqM,EAAKM,eAAe+N,kBAAoBrO,EAAKM,eAAe+N,mBAAqBrO,EAAKM,eAAe8N,iBAG9FnP,EAAaE,EAASgB,EAAI,iBAAkBH,EAAKM,eAAe8B,KAAO,EAAvEnD,CAA0EtL,MAGnF,SAAkBA,GAChB,GAAIqM,EAAKM,eAAe+N,oBAAsBvI,EAAcnS,GAE1D,OADAqM,EAAKM,eAAe+N,kBAAoBrO,EAAKM,eAAe8N,sBAAmB9lB,EACxEgmB,EAAiB3a,GAI1B,OADAqM,EAAKM,eAAe+N,kBAAoBrO,EAAKM,eAAe8N,sBAAmB9lB,EACxE6W,EAAQG,QAAQiP,EAAiBpO,EAAImO,EAArCnP,CAAuDxL,MAGhE,SAAS2a,EAAiB3a,GAKxB,OAHAqM,EAAKM,eAAeY,YAAa,EAEjClB,EAAKc,eAAYxY,EACV2W,EAAaE,EAASA,EAAQG,QAAQlM,EAAM+M,EAAIkC,GAAM,aAAcrC,EAAK/C,OAAOsC,WAAWR,QAAQF,KAAK7U,QAAQ,iBAAmB,OAAI1B,EAAY,EAAnJ2W,CAAsJtL,MApH/JiE,KAiIF,SAAyBuH,GACvBA,EAAQvH,KAAKuE,KAAKmE,eAAezc,QAhI/BoqB,EAAoC,CACtC/O,SAkIF,SAA0CC,EAASgB,EAAIkC,GACrD,IAAIrC,EAAO7D,KACX,OAAO8C,EAAaE,GAEpB,SAAqBxL,GACnB,OAAOmS,EAAcnS,KAAU6S,EAAWxG,EAAKvF,OAAQ,4BAA8B4H,EAAI1O,GAAQwM,EAAGxM,KAH5D,2BAA4BqM,EAAK/C,OAAOsC,WAAWR,QAAQF,KAAK7U,QAAQ,iBAAmB,OAAI1B,EAAY,IAnIrJkZ,SAAS,GAEP+M,EAAkB,CACpBrP,SAiHF,SAAwBC,EAASgB,EAAIkC,GACnC,IAAIrC,EAAO7D,KACX,OAAO8C,EAAaE,GAEpB,SAAqBxL,GACnB,OAAO6S,EAAWxG,EAAKvF,OAAQ,oBAAsBuF,EAAKM,eAAe8B,KAAOjC,EAAGxM,GAAQ0O,EAAI1O,KAHvD,iBAAkBqM,EAAKM,eAAe8B,KAAO,IAlHvFZ,SAAS,GAsIX5gB,EAAOC,QAAUuS,qCClKjB,IAAI4L,EAAqB,EAAQ,MAE7BC,EAAe,EAAQ,KAEvBW,EAAmB,CACrBV,SAIF,SAAkCC,EAASgB,EAAIkC,GAC7C,OAAOpD,EAAaE,GAEpB,SAAyBxL,GACvB,OAAgB,OAATA,GAAiBqL,EAAmBrL,GAAQwM,EAAGxM,GAAQ0O,EAAI1O,KAHtB,eAJ9C6N,SAAS,GAWX5gB,EAAOC,QAAU+e,qCCjBjB,IAAIZ,EAAqB,EAAQ,MAE7ByD,EAAU,EAAQ,MAElBxD,EAAe,EAAQ,KAEvBT,EAAkB,CACpBnc,KAAM,kBACN6c,SAyDF,SAAiCC,EAASgB,EAAIkC,GAC5C,IAEIuC,EACA7S,EAHAiO,EAAO7D,KACPnY,EAAQgc,EAAKvF,OAAOtX,OAIxB,KAAOa,KAGL,GAAmC,eAA/Bgc,EAAKvF,OAAOzW,GAAO,GAAGH,MAAwD,eAA/Bmc,EAAKvF,OAAOzW,GAAO,GAAGH,MAAwD,YAA/Bmc,EAAKvF,OAAOzW,GAAO,GAAGH,KAAoB,CAC1IkO,EAA2C,cAA/BiO,EAAKvF,OAAOzW,GAAO,GAAGH,KAClC,MAIJ,OAEA,SAAe8P,GACb,IAAKqM,EAAKmB,OAASnB,EAAKc,WAAa/O,GAInC,OAHAoN,EAAQjK,MAAM,qBACdiK,EAAQjK,MAAM,6BACd0P,EAASjR,EACFyR,EAAgBzR,GAGzB,OAAO0O,EAAI1O,IAGb,SAASyR,EAAgBzR,GACvB,OAAIA,IAASiR,GACXzF,EAAQK,QAAQ7L,GACTyR,IAGTjG,EAAQvH,KAAK,6BACNqH,EAAaE,EAASyH,EAAoB,aAA1C3H,CAAwDtL,IAGjE,SAASiT,EAAmBjT,GAC1B,OAAa,OAATA,GAAiBqL,EAAmBrL,IACtCwL,EAAQvH,KAAK,qBACNuI,EAAGxM,IAGL0O,EAAI1O,KApGb2X,UAGF,SAAkC7Q,EAAQI,GACxC,IACIyH,EACAnP,EACAK,EACAC,EAJAzP,EAAQyW,EAAOtX,OAOnB,KAAOa,KACL,GAAyB,UAArByW,EAAOzW,GAAO,GAAgB,CAChC,GAA8B,YAA1ByW,EAAOzW,GAAO,GAAGH,KAAoB,CACvCye,EAAUte,EACV,MAG4B,cAA1ByW,EAAOzW,GAAO,GAAGH,OACnBsP,EAAOnP,OAIqB,YAA1ByW,EAAOzW,GAAO,GAAGH,MAEnB4W,EAAO1N,OAAO/I,EAAO,GAGlBwP,GAAwC,eAA1BiH,EAAOzW,GAAO,GAAGH,OAClC2P,EAAaxP,GAKnByP,EAAU,CACR5P,KAAM,gBACN6E,MAAO+Z,EAAQhI,EAAOtH,GAAM,GAAGzK,OAC/BI,IAAK2Z,EAAQhI,EAAOA,EAAOtX,OAAS,GAAG,GAAG2F,MAG5C2R,EAAOtH,GAAM,GAAGtP,KAAO,oBAGnB2P,GACFiH,EAAO1N,OAAOoG,EAAM,EAAG,CAAC,QAASM,EAASoH,IAC1CJ,EAAO1N,OAAOyG,EAAa,EAAG,EAAG,CAAC,OAAQiH,EAAO6H,GAAS,GAAIzH,IAC9DJ,EAAO6H,GAAS,GAAGxZ,IAAM2Z,EAAQhI,EAAOjH,GAAY,GAAG1K,MAEvD2R,EAAO6H,GAAS,GAAK7O,EAKvB,OADAgH,EAAO/V,KAAK,CAAC,OAAQ+O,EAASoH,IACvBJ,IAmDT7Z,EAAOC,QAAU2d,qCCjHjB,IAAIQ,EAAqB,EAAQ,MAE7B8G,EAAgB,EAAQ,MAExB7G,EAAe,EAAQ,KAEvB/M,EAAgB,CAClB7P,KAAM,gBACN6c,SAGF,SAA+BC,EAASgB,EAAIkC,GAC1C,IACIuC,EADAxC,EAAO,EAEX,OAEA,SAAezO,GAGb,OAFAwL,EAAQjK,MAAM,iBACd0P,EAASjR,EACFoP,EAAQpP,IAGjB,SAASoP,EAAQpP,GACf,OAAIA,IAASiR,GACXzF,EAAQjK,MAAM,yBACP4P,EAASnR,IAGdmS,EAAcnS,GACTsL,EAAaE,EAAS4D,EAAS,aAA/B9D,CAA6CtL,GAGlDyO,EAAO,GAAc,OAATzO,IAAkBqL,EAAmBrL,GAC5C0O,EAAI1O,IAGbwL,EAAQvH,KAAK,iBACNuI,EAAGxM,IAGZ,SAASmR,EAASnR,GAChB,OAAIA,IAASiR,GACXzF,EAAQK,QAAQ7L,GAChByO,IACO0C,IAGT3F,EAAQvH,KAAK,yBACNmL,EAAQpP,OAInB/S,EAAOC,QAAUqR,qCCpDjB,IAAIuS,EAAgB,EAAQ,MAW5B7jB,EAAOC,QATP,SAAqBuS,EAAMob,GACzB,OAAIpb,EAAKjQ,QACPshB,EAAcrR,EAAMA,EAAKjQ,OAAQ,EAAGqrB,GAC7Bpb,GAGFob,sCCRT,IAAIzhB,EAAS,EAAQ,MAkCrBnM,EAAOC,QA/BP,SAAuBuS,EAAM1K,EAAO+lB,EAAQD,GAC1C,IAEIphB,EAFAtE,EAAMsK,EAAKjQ,OACXurB,EAAa,EAWjB,GAPEhmB,EADEA,EAAQ,GACDA,EAAQI,EAAM,EAAIA,EAAMJ,EAEzBA,EAAQI,EAAMA,EAAMJ,EAG9B+lB,EAASA,EAAS,EAAIA,EAAS,EAE3BD,EAAMrrB,OAAS,KACjBiK,EAAa1L,MAAMoiB,KAAK0K,IACbG,QAAQjmB,EAAO+lB,GAC1B1hB,EAAOM,MAAM+F,EAAMhG,QAKnB,IAFIqhB,GAAQ1hB,EAAOM,MAAM+F,EAAM,CAAC1K,EAAO+lB,IAEhCC,EAAaF,EAAMrrB,SACxBiK,EAAaohB,EAAM9f,MAAMggB,EAAYA,EAAa,MACvCC,QAAQjmB,EAAO,GAC1BqE,EAAOM,MAAM+F,EAAMhG,GACnBshB,GAAc,IACdhmB,GAAS,uCC7Bf,IAAI6d,EAA4B,EAAQ,MAEpCxI,EAAqB,EAAQ,MAE7BC,EAAoB,EAAQ,MAgBhCpd,EAAOC,QAVP,SAA2B8S,GACzB,OAAa,OAATA,GAAiB4S,EAA0B5S,IAASqK,EAAkBrK,GACjE,EAGLoK,EAAmBpK,GACd,OADT,sCCfF,IAAIzS,EAAiB,EAAQ,KAEzBujB,EAAgB,EAAQ,MAExBd,EAAW,EAAQ,MAavB,SAAS5O,EAAUnQ,EAAKmQ,GACtB,IAAI6Z,EACAvR,EACAwR,EACAlb,EAEJ,IAAKib,KAAQ7Z,EAIX,IAAKpB,KAHL0J,EAAOnc,EAAeS,KAAKiD,EAAKgqB,GAAQhqB,EAAIgqB,GAAQhqB,EAAIgqB,GAAQ,GAChEC,EAAQ9Z,EAAU6Z,GAGhBvR,EAAK1J,GAAQ4L,EAAWoE,EAASkL,EAAMlb,IAAQzS,EAAeS,KAAK0b,EAAM1J,GAAQ0J,EAAK1J,GAAQ,IAKpG,SAAS4L,EAAWnM,EAAM0b,GAIxB,IAHA,IAAI9qB,GAAS,EACT6gB,EAAS,KAEJ7gB,EAAQoP,EAAKjQ,SAEC,UAApBiQ,EAAKpP,GAAO+qB,IAAkBD,EAAWjK,GAAQngB,KAAK0O,EAAKpP,IAI9D,OADAygB,EAAcqK,EAAU,EAAG,EAAGjK,GACvBiK,EAGTluB,EAAOC,QAxCP,SAA2BiU,GAIzB,IAHA,IAAIlQ,EAAM,GACNZ,GAAS,IAEJA,EAAQ8Q,EAAW3R,QAC1B4R,EAAUnQ,EAAKkQ,EAAW9Q,IAG5B,OAAOY,sCCdT,IAAIuW,EAAS,EAAQ,MAEjB6D,EAAqB,EAAQ,MAE7BwF,EAAc,EAAQ,MAEtBC,EAAgB,EAAQ,MAExBd,EAAW,EAAQ,MAEnBhB,EAAa,EAAQ,MAErBqM,EAAkB,EAAQ,KAE1BvM,EAAU,EAAQ,MAElBwM,EAAc,EAAQ,MAqS1BruB,EAAOC,QA5RP,SAAyBoc,EAAQiS,EAAYpL,GAC3C,IAAIxI,EAAQwI,EAAOrB,EAAQqB,GAAQ,CACjCnb,KAAM,EACNC,OAAQ,EACRC,OAAQ,GAENsmB,EAAc,GACdC,EAAuB,GACvBlM,EAAS,GACT9e,EAAQ,GACR+a,EAAU,CACZK,QA2GF,SAAiB7L,GACXqL,EAAmBrL,IACrB2H,EAAM3S,OACN2S,EAAM1S,OAAS,EACf0S,EAAMzS,SAAoB,IAAV8K,EAAc,EAAI,EAClC0b,MACmB,IAAV1b,IACT2H,EAAM1S,SACN0S,EAAMzS,UAIJyS,EAAMkI,aAAe,EACvBlI,EAAMiI,UAENjI,EAAMkI,eAEFlI,EAAMkI,eAAiBN,EAAO5H,EAAMiI,QAAQpgB,SAC9CmY,EAAMkI,cAAgB,EACtBlI,EAAMiI,WAKV1I,EAAQuE,SAAWzL,GAlInBuB,MAsIF,SAAerR,EAAMyrB,GACnB,IAAIpT,EAAQoT,GAAU,GAKtB,OAJApT,EAAMrY,KAAOA,EACbqY,EAAMxT,MAAQoZ,IACdjH,EAAQJ,OAAO/V,KAAK,CAAC,QAASwX,EAAOrB,IACrCzW,EAAMM,KAAKwX,GACJA,GA3IPtE,KA+IF,SAAc/T,GACZ,IAAIqY,EAAQ9X,EAAMO,MAGlB,OAFAuX,EAAMpT,IAAMgZ,IACZjH,EAAQJ,OAAO/V,KAAK,CAAC,OAAQwX,EAAOrB,IAC7BqB,GAlJPoD,QAASiQ,GAsJX,SAA+BC,EAAWvI,GACxCwI,EAAUD,EAAWvI,EAAKnD,SAtJ1BzC,MAAOkO,EAAiBG,GACxB5O,UAAWyO,EAAiBG,EAAmB,CAC7C5O,WAAW,IAEbK,KAAMoO,EAAiBG,EAAmB,CACxCvO,MAAM,KAINtG,EAAU,CACZuE,SAAU,KACV3E,OAAQ,GACRwC,OAAQA,EACRkF,YAAaA,EACb/G,eAkCF,SAAwBc,GACtB,OAAO8S,EAAgB7M,EAAYjG,KAlCnC4F,IAAKA,EACLI,WA4CF,SAAc1f,GACZ2sB,EAAY3sB,EAAMmG,MAAQnG,EAAMoG,OAChCymB,KA7CAlS,MAcF,SAAezO,GAIb,GAHAwU,EAASsB,EAAYtB,EAAQxU,GAC7BihB,IAEkC,OAA9BzM,EAAOA,EAAO/f,OAAS,GACzB,MAAO,GAMT,OAHAssB,EAAUP,EAAY,GAEtBrU,EAAQJ,OAASkI,EAAWyM,EAAsBvU,EAAQJ,OAAQI,GAC3DA,EAAQJ,SAtBbmV,EAAQV,EAAWhQ,SAASvd,KAAKkZ,EAASsE,GAS9C,OAPI+P,EAAWvM,YACbyM,EAAqB1qB,KAAKwqB,GAI5B5T,EAAMiI,OAAS,EACfjI,EAAMkI,cAAgB,EACf3I,EAuBP,SAASsH,EAAYjG,GACnB,OAAO+S,EAAY/L,EAAQhH,GAG7B,SAAS4F,IACP,OAAOW,EAAQnH,GAiBjB,SAASqU,IAIP,IAHA,IAAIE,EACA1M,EAEG7H,EAAMiI,OAASL,EAAO/f,QAG3B,GAAqB,iBAFrBggB,EAAQD,EAAO5H,EAAMiI,SASnB,IANAsM,EAAavU,EAAMiI,OAEfjI,EAAMkI,aAAe,IACvBlI,EAAMkI,aAAe,GAGhBlI,EAAMiI,SAAWsM,GAAcvU,EAAMkI,aAAeL,EAAMhgB,QAC/D2sB,EAAG3M,EAAM3G,WAAWlB,EAAMkI,oBAG5BsM,EAAG3M,GAMT,SAAS2M,EAAGnc,GACVic,EAAQA,EAAMjc,GAuDhB,SAAS+b,EAAkBF,EAAWvI,GACpCA,EAAK8I,UAIP,SAASR,EAAiBS,EAAUV,GAClC,OAGA,SAAc/P,EAAYgM,EAAa0E,GACrC,IAAIC,EACAC,EACAzP,EACAuG,EACJ,OAAO1H,EAAWL,UAAY,WAAYK,EAAa6Q,EAAuBzM,EAASpE,IAEvF,SAA+B5L,GAC7B,GAAIA,KAAQ4L,GAAc,QAAQA,EAChC,OAAO6Q,EAAuB7Q,EAAWV,KAEzC8E,EAASpE,EAAW5L,IAAOnP,OAAOmf,EAASpE,EAAWV,OAASU,EAAW5L,GAFnEyc,CAE0Ezc,GAGnF,OAAOsc,EAAWtc,IAGpB,SAASyc,EAAuBhd,GAG9B,OAFA8c,EAAmB9c,EAEZid,EAAgBjd,EADvB+c,EAAiB,IAInB,SAASE,EAAgBb,GACvB,OAEA,SAAe7b,GAKbsT,EA8CR,WACE,IAAIqJ,EAAaxO,IACbyO,EAAgB1V,EAAQuE,SACxBoR,EAAwB3V,EAAQ6F,iBAChC+P,EAAmB5V,EAAQJ,OAAOtX,OAClCutB,EAAahvB,MAAMoiB,KAAK1f,GAC5B,MAAO,CACL2rB,QAASA,EACTjM,KAAM2M,GAGR,SAASV,IACPzU,EAAQgV,EACRzV,EAAQuE,SAAWmR,EACnB1V,EAAQ6F,iBAAmB8P,EAC3B3V,EAAQJ,OAAOtX,OAASstB,EACxBrsB,EAAQssB,EACRrB,KA/DWsB,GACPjQ,EAAmB8O,EAEdA,EAAUhO,UACb3G,EAAQ6F,iBAAmB8O,GAG7B,GAAIA,EAAUntB,MAAQwY,EAAQoC,OAAOsC,WAAWR,QAAQF,KAAK7U,QAAQwlB,EAAUntB,OAAS,EACtF,OAAOggB,IAGT,OAAOmN,EAAUtQ,SAASvd,KAAK2tB,EAASnU,EAAO,GAAIN,EAASyU,GAAUzU,EAASsE,EAASgB,EAAIkC,EAArFmN,CAA0F7b,IAIrG,SAASwM,EAAGxM,GAEV,OADAqc,EAAStP,EAAkBuG,GACpBsE,EAGT,SAASlJ,EAAI1O,GAGX,OAFAsT,EAAK8I,YAECI,EAAiBD,EAAiB/sB,OAC/BktB,EAAgBH,EAAiBC,IAGnCF,IAKb,SAASR,EAAUD,EAAW1L,GACxB0L,EAAU7M,YAAcyM,EAAqBplB,QAAQwlB,GAAa,GACpEJ,EAAqB1qB,KAAK8qB,GAGxBA,EAAUlI,SACZ7C,EAAc5J,EAAQJ,OAAQqJ,EAAMjJ,EAAQJ,OAAOtX,OAAS2gB,EAAM0L,EAAUlI,QAAQzM,EAAQJ,OAAO/L,MAAMoV,GAAOjJ,IAG9G2U,EAAUlE,YACZzQ,EAAQJ,OAAS+U,EAAUlE,UAAUzQ,EAAQJ,OAAQI,IAyBzD,SAASwU,IACH/T,EAAM3S,QAAQwmB,GAAe7T,EAAM1S,OAAS,IAC9C0S,EAAM1S,OAASumB,EAAY7T,EAAM3S,MACjC2S,EAAMzS,QAAUsmB,EAAY7T,EAAM3S,MAAQ,oCC5ShD/H,EAAOC,QAJP,SAAkB2B,GAChB,OAAOA,MAAAA,EAAwC,GAAK,WAAYA,EAAQA,EAAQ,CAACA,mCCMnF5B,EAAOC,QAPP,SAAmBya,EAAOzS,GAIxB,OAHAyS,EAAM1S,QAAUC,EAChByS,EAAMzS,QAAUA,EAChByS,EAAMkI,cAAgB3a,EACfyS,iCCQT1a,EAAOC,QAZP,SAA6B2B,GAC3B,OAAOA,EACN8Z,QAAQ,cAAe,KACvBA,QAAQ,SAAU,IAMlB7H,cAAcpK,kDCTjB,IAAIwjB,EAAa,EAAQ,MAQzBjtB,EAAOC,QANP,SAAoB4Z,EAAQ5W,GAC1B,IAAI6Y,EAAOjC,EAAOA,EAAOtX,OAAS,GAClC,OAAKuZ,GAAQA,EAAK,GAAG7Y,OAASA,EACvBgqB,EAAWnR,EAAK,GAAGyF,YAAYzF,EAAK,KADA,sCCJ7C,IAAIuB,EAAe,EAAQ,MAU3Brd,EAAOC,QARP,SAAoB+vB,GAClB,OAEA,SAAejd,GACb,OAAOid,EAAMvK,KAAKpI,EAAatK,qCCWnC/S,EAAOC,QAjBP,SAAoB0e,EAAY9E,EAAQI,GAKtC,IAJA,IAEIyM,EAFAuJ,EAAS,GACT7sB,GAAS,IAGJA,EAAQub,EAAWpc,SAC1BmkB,EAAU/H,EAAWvb,GAAO2e,aAEbkO,EAAO7mB,QAAQsd,GAAW,IACvC7M,EAAS6M,EAAQ7M,EAAQI,GACzBgW,EAAOnsB,KAAK4iB,IAIhB,OAAO7M,qCCdT,IAAIwD,EAAe,EAAQ,MAiB3Brd,EAAOC,QAfP,SAAqB2B,EAAOsuB,GAC1B,IAAInd,EAAOjC,SAASlP,EAAOsuB,GAE3B,OACAnd,EAAO,GAAc,KAATA,GAAeA,EAAO,IAAMA,EAAO,IAC/CA,EAAO,KAAOA,EAAO,KACrBA,EAAO,OAASA,EAAO,OACvBA,EAAO,OAASA,EAAO,OAA4B,QAAX,MAAPA,IAA8C,QAAX,MAAPA,IAC7DA,EAAO,QACE,IAGFsK,EAAatK,sCCdtB,IAAIsK,EAAe,EAAQ,MAqC3Brd,EAAOC,QAnCP,SAAyBqiB,GAOvB,IANA,IAEIC,EACA3gB,EACAuuB,EAJA/sB,GAAS,EACTO,EAAS,KAKJP,EAAQkf,EAAO/f,QAAQ,CAG9B,GAAqB,iBAFrBggB,EAAQD,EAAOlf,IAGbxB,EAAQ2gB,OACH,IAAe,IAAXA,EACT3gB,EAAQ,UACH,IAAe,IAAX2gB,EACT3gB,EAAQ,UACH,IAAe,IAAX2gB,EACT3gB,EAAQ,YACH,IAAe,IAAX2gB,EACT3gB,EAAQ,UACH,IAAe,IAAX2gB,EAAc,CACvB,GAAI4N,EAAO,SACXvuB,EAAQ,SAGRA,EAAQyb,EAAakF,GAGvB4N,GAAmB,IAAX5N,EACR5e,EAAOG,KAAKlC,GAGd,OAAO+B,EAAOyE,KAAK,wCClCrB,IAAImS,EAAS,EAAQ,MAMrBva,EAAOC,QAJP,SAAiB2Q,GACf,OAAO2J,EAAO,GAAI3J,mCCQpB5Q,EAAOC,QAXP,SAAoBqiB,GAIlB,IAHA,IAAIlf,GAAS,EACToe,EAAO,IAEFpe,EAAQkf,EAAO/f,QACtBif,GAAiC,iBAAlBc,EAAOlf,GAAsBkf,EAAOlf,GAAOb,OAAS,EAGrE,OAAOif,kCCgBTxhB,EAAOC,QAxBP,SAAqBqiB,EAAQhH,GAC3B,IAII8U,EAJAC,EAAa/U,EAAMxT,MAAM6a,OACzB2N,EAAmBhV,EAAMxT,MAAM8a,aAC/B2N,EAAWjV,EAAMpT,IAAIya,OACrB6N,EAAiBlV,EAAMpT,IAAI0a,aAiB/B,OAdIyN,IAAeE,EACjBH,EAAO,CAAC9N,EAAO+N,GAAYviB,MAAMwiB,EAAkBE,KAEnDJ,EAAO9N,EAAOxU,MAAMuiB,EAAYE,GAE5BD,GAAoB,IACtBF,EAAK,GAAKA,EAAK,GAAGtiB,MAAMwiB,IAGtBE,EAAiB,GACnBJ,EAAKtsB,KAAKwe,EAAOiO,GAAUziB,MAAM,EAAG0iB,KAIjCJ,sCCrBT,IAAI7V,EAAS,EAAQ,MAEjBsJ,EAAgB,EAAQ,MAExBhC,EAAU,EAAQ,MAsFtB,SAAS4O,EAAW5W,EAAQ6I,GAiB1B,IAhBA,IAQIgO,EACAlS,EACApb,EACAutB,EACAzoB,EACA0oB,EAbAtV,EAAQzB,EAAO6I,GAAY,GAC3BzI,EAAUJ,EAAO6I,GAAY,GAC7BY,EAAgBZ,EAAa,EAC7BmO,EAAiB,GACjBC,EAAYxV,EAAM6F,YAAclH,EAAQoC,OAAOf,EAAMwD,aAAaxD,EAAMxT,OACxEipB,EAAcD,EAAUjX,OACxBmX,EAAQ,GACRC,EAAO,GASJ3V,GAAO,CAEZ,KAAOzB,IAASyJ,GAAe,KAAOhI,IAGtCuV,EAAe/sB,KAAKwf,GAEfhI,EAAM6F,aACTuP,EAASzW,EAAQsH,YAAYjG,GAExBA,EAAMyD,MACT2R,EAAO5sB,KAAK,MAGV0a,GACFsS,EAAUxP,WAAWhG,EAAMxT,OAGzBwT,EAAM4V,6BACRJ,EAAUK,oCAAqC,GAGjDL,EAAUvU,MAAMmU,GAEZpV,EAAM4V,6BACRJ,EAAUK,wCAAqCzpB,IAKnD8W,EAAWlD,EACXA,EAAQA,EAAMyD,KAQhB,IAHAzD,EAAQkD,EACRpb,EAAQ2tB,EAAYxuB,OAEba,KAGyB,UAA1B2tB,EAAY3tB,GAAO,GACrButB,GAAU,EAEZA,GAAWI,EAAY3tB,GAAO,GAAGH,OAAS8tB,EAAY3tB,EAAQ,GAAG,GAAGH,MAAQ8tB,EAAY3tB,GAAO,GAAG0E,MAAMC,OAASgpB,EAAY3tB,GAAO,GAAG8E,IAAIH,OACzIomB,EAAI4C,EAAYjjB,MAAM1K,EAAQ,EAAG8E,IAEjCoT,EAAM6F,WAAa7F,EAAMyD,UAAOrX,EAChC4T,EAAQA,EAAMkD,SACdtW,EAAM9E,EAAQ,GAWlB,IANA0tB,EAAUjX,OAASyB,EAAM6F,WAAa7F,EAAMyD,UAAOrX,EAEnDymB,EAAI4C,EAAYjjB,MAAM,EAAG5F,IACzB9E,GAAS,EACTwtB,EAAS,IAEAxtB,EAAQ4tB,EAAMzuB,QACrB0uB,EAAKL,EAASI,EAAM5tB,GAAO,IAAMwtB,EAASI,EAAM5tB,GAAO,GACvDwtB,GAAUI,EAAM5tB,GAAO,GAAK4tB,EAAM5tB,GAAO,GAAK,EAGhD,OAAO6tB,EAEP,SAAS9C,EAAIrgB,GACX,IAAIhG,EAAQ+oB,EAAe9sB,MAC3BitB,EAAMjD,QAAQ,CAACjmB,EAAOA,EAAQgG,EAAMvL,OAAS,IAC7CshB,EAAchK,EAAQ/R,EAAO,EAAGgG,IAIpC9N,EAAOC,QAhLP,SAAqB4Z,GAWnB,IAVA,IAEIiB,EACAF,EACAwW,EACAC,EACA7kB,EACA8kB,EACAC,EARAP,EAAQ,GACR5tB,GAAS,IASJA,EAAQyW,EAAOtX,QAAQ,CAC9B,KAAOa,KAAS4tB,GACd5tB,EAAQ4tB,EAAM5tB,GAMhB,GAHA0X,EAAQjB,EAAOzW,GAGXA,GAA2B,cAAlB0X,EAAM,GAAG7X,MAAsD,mBAA9B4W,EAAOzW,EAAQ,GAAG,GAAGH,QAEjEmuB,EAAa,IADbE,EAAYxW,EAAM,GAAGqG,WAAWtH,QAGLtX,QAA4C,oBAAlC+uB,EAAUF,GAAY,GAAGnuB,OAC5DmuB,GAAc,GAGZA,EAAaE,EAAU/uB,QAA4C,YAAlC+uB,EAAUF,GAAY,GAAGnuB,MAC5D,OAASmuB,EAAaE,EAAU/uB,QACQ,YAAlC+uB,EAAUF,GAAY,GAAGnuB,MAIS,cAAlCquB,EAAUF,GAAY,GAAGnuB,OAC3BquB,EAAUF,GAAY,GAAGF,4BAA6B,EACtDE,KAOR,GAAiB,UAAbtW,EAAM,GACJA,EAAM,GAAGgE,cACXvE,EAAOyW,EAAOP,EAAW5W,EAAQzW,IACjCA,EAAQ4tB,EAAM5tB,GACdmuB,GAAO,QAGN,GAAIzW,EAAM,GAAGqK,YAAcrK,EAAM,GAAG0W,yBAA0B,CAIjE,IAHAJ,EAAahuB,EACbwX,OAAYlT,EAEL0pB,MAGsB,gBAF3BC,EAAaxX,EAAOuX,IAEL,GAAGnuB,MAAgD,oBAAvBouB,EAAW,GAAGpuB,OACjC,UAAlBouB,EAAW,KACTzW,IACFf,EAAOe,GAAW,GAAG3X,KAAO,mBAG9BouB,EAAW,GAAGpuB,KAAO,aACrB2X,EAAYwW,GAOdxW,IAEFE,EAAM,GAAG5S,IAAM2Z,EAAQhI,EAAOe,GAAW,GAAG9S,QAE5C0E,EAAaqN,EAAO/L,MAAM8M,EAAWxX,IAC1B2qB,QAAQjT,GACnB+I,EAAchK,EAAQe,EAAWxX,EAAQwX,EAAY,EAAGpO,KAK9D,OAAQ+kB,kCCtFV,IAAI3lB,EAGJ5L,EAAOC,QAEP,SAAsBwxB,GACpB,IACIC,EADAC,EAAS,IAAMF,EAAa,IAUhC,IARA7lB,EAAKA,GAAM0Q,SAAS9T,cAAc,MAC/BopB,UAAYD,EARD,MASdD,EAAO9lB,EAAGimB,aAMDjW,WAAW8V,EAAKnvB,OAAS,IAAmC,SAAfkvB,EACpD,OAAO,EAIT,OAAOC,IAASC,GAAiBD,sCCtBnC1xB,EAAOC,QAIP,SAAeuB,GACb,IAAI4d,EAAO7D,KACXA,KAAKuW,OAEL,SAAeC,GACb,OAAOC,EAAaD,EAAK3xB,OAAOma,OAAO,GAAI6E,EAAK5J,KAAK,YAAahU,EAAS,CAIzE0S,WAAYkL,EAAK5J,KAAK,wBAA0B,GAChDmE,gBAAiByF,EAAK5J,KAAK,2BAA6B,QAZ9D,IAAIwc,EAAe,EAAQ,yCCF3B,IAAIC,EAAO,EAAQ,MAEf9c,EAAS,EAAQ,MAEjBnT,EAAS,EAAQ,MAEjBkwB,EAAQ,EAAQ,MAEhBC,EAAS,EAAQ,MAEjBC,EAAQ,EAAQ,MAGpBpyB,EAAOC,QAwCP,SAASgO,IACP,IAIIokB,EAJAC,EAAY,GACZC,EAAeJ,IACfK,EAAY,GACZC,GAAe,EAiBnB,OAdAvjB,EAAUsG,KAoEV,SAActU,EAAKU,GACjB,GAAmB,iBAARV,EAET,OAAyB,IAArBmB,UAAUE,QACZmwB,EAAe,OAAQL,GACvBG,EAAUtxB,GAAOU,EACVsN,GAIFoL,EAAIvZ,KAAKyxB,EAAWtxB,IAAQsxB,EAAUtxB,IAAQ,KAIvD,GAAIA,EAGF,OAFAwxB,EAAe,OAAQL,GACvBG,EAAYtxB,EACLgO,EAIT,OAAOsjB,GAvFTtjB,EAAUyjB,OAASA,EAEnBzjB,EAAUojB,UAAYA,EACtBpjB,EAAUC,IA8FV,SAAavN,GACX,IAAIoS,EAGJ,GAFA0e,EAAe,MAAOL,GAElBzwB,MAAAA,QACG,GAAqB,mBAAVA,EAChBgxB,EAAUnmB,MAAM,KAAMpK,eACjB,IAAqB,iBAAVT,EAOhB,MAAM,IAAIyG,MAAM,+BAAiCzG,EAAQ,KANrD,WAAYA,EACdixB,EAAQjxB,GAERkxB,EAAUlxB,GAMVoS,IACFwe,EAAUxe,SAAWhS,EAAOwwB,EAAUxe,UAAY,GAAIA,IAGxD,OAAO9E,EAEP,SAAS4jB,EAAUnvB,GACjBkvB,EAAQlvB,EAAOyL,SAEXzL,EAAOqQ,WACTA,EAAWhS,EAAOgS,GAAY,GAAIrQ,EAAOqQ,WAI7C,SAASma,EAAIvsB,GACX,GAAqB,mBAAVA,EACTgxB,EAAUhxB,OACL,IAAqB,iBAAVA,EAOhB,MAAM,IAAIyG,MAAM,+BAAiCzG,EAAQ,KANrD,WAAYA,EACdgxB,EAAUnmB,MAAM,KAAM7K,GAEtBkxB,EAAUlxB,IAOhB,SAASixB,EAAQzjB,GACf,IAAIhM,GAAS,EAEb,GAAIgM,MAAAA,OACG,IAAuB,iBAAZA,KAAwB,WAAYA,GAKpD,MAAM,IAAI/G,MAAM,oCAAsC+G,EAAU,KAJhE,OAAShM,EAAQgM,EAAQ7M,QACvB4rB,EAAI/e,EAAQhM,KAOlB,SAASwvB,EAAUG,EAAQnxB,GACzB,IAAIoxB,EAAQC,EAAKF,GAEbC,GACEd,EAAMc,EAAM,KAAOd,EAAMtwB,KAC3BA,EAAQI,GAAO,EAAMgxB,EAAM,GAAIpxB,IAGjCoxB,EAAM,GAAKpxB,GAEX0wB,EAAUxuB,KAAKgK,EAAM/M,KAAKsB,cAhKhC6M,EAAUhB,MAiLV,SAAe6jB,GACb,IACID,EADAoB,EAAOd,EAAML,GAMjB,GAJAY,IAEAQ,EAAa,QADbrB,EAAS5iB,EAAU4iB,QAGfsB,EAAQtB,EAAQ,SAClB,OAAO,IAAIA,EAAO9oB,OAAOkqB,GAAOA,GAAMhlB,QAGxC,OAAO4jB,EAAO9oB,OAAOkqB,GAAOA,IA3L9BhkB,EAAUmkB,UAkPV,SAAmB3vB,EAAMquB,GACvB,IACIuB,EADAJ,EAAOd,EAAML,GAOjB,GALAY,IAEAY,EAAe,YADfD,EAAWpkB,EAAUokB,UAErBE,EAAW9vB,GAEP0vB,EAAQE,EAAU,WACpB,OAAO,IAAIA,EAAS5vB,EAAMwvB,GAAMtZ,UAGlC,OAAO0Z,EAAS5vB,EAAMwvB,IA7PxBhkB,EAAUukB,IAAMA,EAChBvkB,EAAUG,QAgOV,SAAiB3L,EAAMwvB,GACrB,IAAIvvB,EACA+vB,EAGJ,OAFAD,EAAI/vB,EAAMwvB,EAAM1I,GAChBmJ,EAAW,UAAW,MAAOD,GACtB/vB,EAEP,SAAS6mB,EAAKoJ,EAAOtwB,GACnBowB,GAAW,EACX/vB,EAASL,EACT2uB,EAAK2B,KAzOT1kB,EAAU2kB,QAAUA,EACpB3kB,EAAU4kB,YA+RV,SAAqB/B,GACnB,IAAImB,EACAQ,EAOJ,OANAf,IACAQ,EAAa,cAAejkB,EAAU4iB,QACtCyB,EAAe,cAAerkB,EAAUokB,UAExCO,EADAX,EAAOd,EAAML,GACCvH,GACdmJ,EAAW,cAAe,UAAWD,GAC9BR,EAEP,SAAS1I,EAAKoJ,GACZF,GAAW,EACXzB,EAAK2B,KA1SF1kB,EAEP,SAASA,IAIP,IAHA,IAAI6kB,EAAc9lB,IACd7K,GAAS,IAEJA,EAAQkvB,EAAU/vB,QACzBwxB,EAAY5kB,IAAI1C,MAAM,KAAM6lB,EAAUlvB,IAIxC,OADA2wB,EAAYve,KAAKxT,GAAO,EAAM,GAAIwwB,IAC3BuB,EAUT,SAASpB,IACP,IAAIjW,EACAsX,EAEJ,GAAI3B,EACF,OAAOnjB,EAGT,OAASujB,EAAcH,EAAU/vB,SAGb,KAFlBma,EAAS4V,EAAUG,IAER,MAIO,IAAd/V,EAAO,KACTA,EAAO,QAAKhV,GAKa,mBAF3BssB,EAActX,EAAO,GAAGjQ,MAAMyC,EAAWwN,EAAO5O,MAAM,MAGpDykB,EAAapjB,IAAI6kB,IAMrB,OAFA3B,GAAS,EACTI,EAAc7K,EAAAA,EACP1Y,EA6GT,SAAS+jB,EAAKF,GAGZ,IAFA,IAAI3vB,GAAS,IAEJA,EAAQkvB,EAAU/vB,QACzB,GAAI+vB,EAAUlvB,GAAO,KAAO2vB,EAC1B,OAAOT,EAAUlvB,GAuBvB,SAASqwB,EAAI/vB,EAAMwvB,EAAMe,GASvB,GARAT,EAAW9vB,GACXivB,IAEKsB,GAAsB,mBAATf,IAChBe,EAAKf,EACLA,EAAO,OAGJe,EACH,OAAO,IAAIC,QAAQC,GAKrB,SAASA,EAASzN,EAAS0N,GACzB7B,EAAakB,IAAI/vB,EAAM0uB,EAAMc,IAE7B,SAAcU,EAAOtwB,EAAM4vB,GACzB5vB,EAAOA,GAAQI,EAEXkwB,EACFQ,EAAOR,GACElN,EACTA,EAAQpjB,GAER2wB,EAAG,KAAM3wB,EAAM4vB,MAbrBiB,EAAS,KAAMF,GAwDjB,SAASJ,EAAQ9B,EAAKkC,GAKpB,GAJAtB,IACAQ,EAAa,UAAWjkB,EAAU4iB,QAClCyB,EAAe,UAAWrkB,EAAUokB,WAE/BW,EACH,OAAO,IAAIC,QAAQC,GAKrB,SAASA,EAASzN,EAAS0N,GACzB,IAAIlB,EAAOd,EAAML,GACjBsC,EAASZ,IAAIvkB,EAAW,CACtBgkB,KAAMA,IAGR,SAAcU,GACRA,EACFQ,EAAOR,GACElN,EACTA,EAAQwM,GAERe,EAAG,KAAMf,MAdfiB,EAAS,KAAMF,IArUFhmB,GAAU0kB,SAC3B,IAAI7kB,EAAQ,GAAGA,MACXwM,EAAM,GAAGha,eAET+zB,EAAWlC,IAAShjB,KAExB,SAAuBtK,EAAGyvB,GACxBA,EAAIhxB,KAAOuB,EAAEqJ,MAAMomB,EAAIpB,SAHkB/jB,KAM3C,SAAqBtK,EAAGyvB,EAAKvV,GAC3Bla,EAAE4uB,IAAIa,EAAIhxB,KAAMgxB,EAAIpB,MAEpB,SAAcU,EAAOtwB,EAAM4vB,GACrBU,EACF7U,EAAK6U,IAELU,EAAIhxB,KAAOA,EACXgxB,EAAIpB,KAAOA,EACXnU,WAfsD5P,KAoB5D,SAA2BtK,EAAGyvB,GAC5B,IAAI3wB,EAASkB,EAAEwuB,UAAUiB,EAAIhxB,KAAMgxB,EAAIpB,MAEnCvvB,MAAAA,IACyB,iBAAXA,GAAuBwR,EAAOxR,IAC1C,UAAW2wB,EAAIpB,OACjBoB,EAAIpB,KAAKtxB,MAAQ+B,GAGnB2wB,EAAIpB,KAAKqB,SAAW5wB,GAEpB2wB,EAAIpB,KAAKvvB,OAASA,MA0UtB,SAASyvB,EAAQxxB,EAAOH,GACtB,MAAwB,mBAAVG,GAAwBA,EAAMvB,YAO9C,SAAcuB,GACZ,IAAIV,EAEJ,IAAKA,KAAOU,EACV,OAAO,EAGT,OAAO,EAXPiN,CAAKjN,EAAMvB,YAAcoB,KAAQG,EAAMvB,WAezC,SAAS8yB,EAAa1xB,EAAMqwB,GAC1B,GAAsB,mBAAXA,EACT,MAAM,IAAIzpB,MAAM,WAAa5G,EAAO,sBAKxC,SAAS8xB,EAAe9xB,EAAM6xB,GAC5B,GAAwB,mBAAbA,EACT,MAAM,IAAIjrB,MAAM,WAAa5G,EAAO,wBAKxC,SAASixB,EAAejxB,EAAM4wB,GAC5B,GAAIA,EACF,MAAM,IAAIhqB,MAAM,kBAAoB5G,EAAO,qHAK/C,SAAS+xB,EAAW9vB,GAClB,IAAKA,GAA6B,iBAAdA,EAAKT,KACvB,MAAM,IAAIoF,MAAM,uBAAyB3E,EAAO,KAKpD,SAASiwB,EAAWlyB,EAAM+yB,EAAWd,GACnC,IAAKA,EACH,MAAM,IAAIrrB,MAAM,IAAM5G,EAAO,0BAA4B+yB,EAAY,6CC3azE,IAAIla,EAAM,GAAGha,eA4Bb,SAASoa,EAAMA,GAKb,OAJKA,GAA0B,iBAAVA,IACnBA,EAAQ,IAGHtX,EAAMsX,EAAM3S,MAAQ,IAAM3E,EAAMsX,EAAM1S,QAG/C,SAASH,EAASM,GAKhB,OAJKA,GAAsB,iBAARA,IACjBA,EAAM,IAGDuS,EAAMvS,EAAIL,OAAS,IAAM4S,EAAMvS,EAAID,KAG5C,SAAS9E,EAAMxB,GACb,OAAOA,GAA0B,iBAAVA,EAAqBA,EAAQ,EA5CtD5B,EAAOC,QAEP,SAAmB2B,GAEjB,IAAKA,GAA0B,iBAAVA,EACnB,MAAO,GAIT,GAAI0Y,EAAIvZ,KAAKa,EAAO,aAAe0Y,EAAIvZ,KAAKa,EAAO,QACjD,OAAOiG,EAASjG,EAAMiG,UAIxB,GAAIyS,EAAIvZ,KAAKa,EAAO,UAAY0Y,EAAIvZ,KAAKa,EAAO,OAC9C,OAAOiG,EAASjG,GAIlB,GAAI0Y,EAAIvZ,KAAKa,EAAO,SAAW0Y,EAAIvZ,KAAKa,EAAO,UAC7C,OAAO8Y,EAAM9Y,GAIf,MAAO,uCCzBT,IAAIkS,EAAO,EAAQ,MAEnB9T,EAAOC,QAAUkyB,EACjBA,EAAOre,KAAOA,EACd,IAAIhG,EAAQ,GAAGA,MAEf,SAASqkB,IACP,IAAIsC,EAAM,GACNC,EAAa,CACjBA,IAIA,WACE,IAAItxB,GAAS,EACTuxB,EAAQ7mB,EAAM/M,KAAKsB,UAAW,GAAI,GAClCmoB,EAAOnoB,UAAUA,UAAUE,OAAS,GAExC,GAAoB,mBAATioB,EACT,MAAM,IAAIniB,MAAM,2CAA6CmiB,GAK/D,SAASzL,EAAK7e,GACZ,IAAI00B,EAAKH,IAAMrxB,GACXyxB,EAAS/mB,EAAM/M,KAAKsB,UAAW,GAC/Bqa,EAASmY,EAAO/mB,MAAM,GACtBvL,EAASoyB,EAAMpyB,OACf4F,GAAO,EAEX,GAAIjI,EACFsqB,EAAKtqB,OADP,CAMA,OAASiI,EAAM5F,GACO,OAAhBma,EAAOvU,SAAiCT,IAAhBgV,EAAOvU,KACjCuU,EAAOvU,GAAOwsB,EAAMxsB,IAIxBwsB,EAAQjY,EAEJkY,EACF9gB,EAAK8gB,EAAI7V,GAAMtS,MAAM,KAAMkoB,GAE3BnK,EAAK/d,MAAM,KAAM,CAAC,MAAM7I,OAAO+wB,KA1BnC5V,EAAKtS,MAAM,KAAM,CAAC,MAAM7I,OAAO+wB,KAZjCD,IA4CA,SAAaE,GACX,GAAkB,mBAAPA,EACT,MAAM,IAAIvsB,MAAM,uCAAyCusB,GAI3D,OADAH,EAAI3wB,KAAK8wB,GACFF,IAjDT,OAAOA,kCCXT,IAAI5mB,EAAQ,GAAGA,MACf9N,EAAOC,QAIP,SAAc20B,EAAIE,GAChB,IAAIC,EACJ,OAEA,WACE,IAEIpxB,EAFAkxB,EAAS/mB,EAAM/M,KAAKsB,UAAW,GAC/ByyB,EAAWF,EAAGryB,OAASsyB,EAAOtyB,OAG9BuyB,GACFD,EAAO/wB,KAAK0mB,GAGd,IACE7mB,EAASixB,EAAGnoB,MAAM,KAAMooB,GACxB,MAAOjB,GAMP,GAAIkB,GAAYC,EACd,MAAMnB,EAGR,OAAOpJ,EAAKoJ,GAGTkB,IACCnxB,GAAiC,mBAAhBA,EAAOqxB,KAC1BrxB,EAAOqxB,KAAKA,EAAMxK,GACT7mB,aAAkB0E,MAC3BmiB,EAAK7mB,GAELqxB,EAAKrxB,KAMX,SAAS6mB,IACFuK,IACHA,GAAU,EACVD,EAASroB,MAAM,KAAMpK,YAMzB,SAAS2yB,EAAKpzB,GACZ4oB,EAAK,KAAM5oB,wCCvDf5B,EAAOC,QAAUiM,EAEjB,IAAI+oB,EAAe,EAAQ,MAEvBC,EAAWD,EAAaC,SACxBC,EAAOF,EAAaE,KACpBC,EAAOH,EAAaG,KAKxB,SAASlpB,EAAM5I,EAAMmiB,EAAMliB,EAAS8xB,GACd,mBAAT5P,GAA0C,mBAAZliB,IACvC8xB,EAAU9xB,EACVA,EAAUkiB,EACVA,EAAO,MAGTwP,EAAa3xB,EAAMmiB,GAEnB,SAAkB/hB,EAAMZ,GACtB,IAAIe,EAASf,EAAQA,EAAQP,OAAS,GAClCa,EAAQS,EAASA,EAAOX,SAASkG,QAAQ1F,GAAQ,KACrD,OAAOH,EAAQG,EAAMN,EAAOS,KALKwxB,GAXrCnpB,EAAMgpB,SAAWA,EACjBhpB,EAAMipB,KAAOA,EACbjpB,EAAMkpB,KAAOA,iCCPb,SAASE,EAAQ7P,GACf,GAAY,MAARA,EACF,OAAOlG,EAGT,GAAoB,iBAATkG,EACT,OAuDJ,SAAqBA,GACnB,OAAOxiB,EAEP,SAASA,EAAKS,GACZ,OAAO6xB,QAAQ7xB,GAAQA,EAAKT,OAASwiB,IA3D9B+P,CAAY/P,GAGrB,GAAoB,iBAATA,EACT,MAAO,WAAYA,EA0BvB,SAAoBgQ,GAClB,IAAIC,EAAS,GACTtyB,GAAS,EAEb,OAASA,EAAQqyB,EAAMlzB,QACrBmzB,EAAOtyB,GAASkyB,EAAQG,EAAMryB,IAGhC,OAAOuyB,EAEP,SAASA,IAGP,IAFA,IAAIvyB,GAAS,IAEJA,EAAQsyB,EAAOnzB,QACtB,GAAImzB,EAAOtyB,GAAOqJ,MAAM8O,KAAMlZ,WAC5B,OAAO,EAIX,OAAO,GA7CmBuzB,CAAWnQ,GAYzC,SAAoBA,GAClB,OAAOzhB,EAEP,SAASA,EAAIN,GACX,IAAIxC,EAEJ,IAAKA,KAAOukB,EACV,GAAI/hB,EAAKxC,KAASukB,EAAKvkB,GAAM,OAAO,EAGtC,OAAO,GAtBsC20B,CAAWpQ,GAG1D,GAAoB,mBAATA,EACT,OAAOA,EAGT,MAAM,IAAIpd,MAAM,gDAqDlB,SAASkX,IACP,OAAO,EAzETvf,EAAOC,QAAUq1B,oBCFjBt1B,EAAOC,QAEP,SAAkBoE,GAChB,OAAOA,sCCDTrE,EAAOC,QAAUg1B,EAEjB,IAAIK,EAAU,EAAQ,MAElBQ,EAAQ,EAAQ,MAEhBZ,GAAW,EACXC,EAAO,OACPC,GAAO,EAKX,SAASH,EAAa3xB,EAAMmiB,EAAMliB,EAAS8xB,GACzC,IAAIU,EACAC,EAEgB,mBAATvQ,GAA0C,mBAAZliB,IACvC8xB,EAAU9xB,EACVA,EAAUkiB,EACVA,EAAO,MAGTuQ,EAAKV,EAAQ7P,GACbsQ,EAAOV,GAAW,EAAI,EAGtB,SAASY,EAAQvyB,EAAMN,EAAON,GAC5B,IACIrB,EADAG,EAAwB,iBAAT8B,GAA8B,OAATA,EAAgBA,EAAO,GAGrC,iBAAf9B,EAAMqB,OACfxB,EAAgC,iBAAlBG,EAAMunB,QAAuBvnB,EAAMunB,QAAgC,iBAAfvnB,EAAMH,KAAoBG,EAAMH,UAAOiG,EACzGwE,EAAMgqB,YAAc,SAAWJ,EAAMl0B,EAAMqB,MAAQxB,EAAO,IAAMA,EAAO,IAAM,KAAO,KAGtF,OAAOyK,EAEP,SAASA,IACP,IAEIiqB,EACAluB,EAHAmuB,EAAetzB,EAAQc,OAAOF,GAC9BC,EAAS,GAIb,KAAK8hB,GAAQuQ,EAAGtyB,EAAMN,EAAON,EAAQA,EAAQP,OAAS,IAAM,SAC1DoB,EA0BR,SAAkB/B,GAChB,GAAc,OAAVA,GAAmC,iBAAVA,GAAsB,WAAYA,EAC7D,OAAOA,EAGT,GAAqB,iBAAVA,EACT,MAAO,CAACszB,EAAUtzB,GAGpB,MAAO,CAACA,GAnCOy0B,CAAS9yB,EAAQG,EAAMZ,IAE5Ba,EAAO,KAAOyxB,GAChB,OAAOzxB,EAIX,GAAID,EAAKR,UAAYS,EAAO,KAAOwxB,EAGjC,IAFAltB,GAAUotB,EAAU3xB,EAAKR,SAASX,QAAU,GAAKwzB,EAE1C9tB,GAAU,GAAKA,EAASvE,EAAKR,SAASX,QAAQ,CAGnD,GAFA4zB,EAAYF,EAAQvyB,EAAKR,SAAS+E,GAASA,EAAQmuB,EAAvCH,GAERE,EAAU,KAAOf,EACnB,OAAOe,EAGTluB,EAAiC,iBAAjBkuB,EAAU,GAAkBA,EAAU,GAAKluB,EAAS8tB,EAIxE,OAAOpyB,GAzCXsyB,CAAQ3yB,EAAM,KAAM,GAApB2yB,GAhBFhB,EAAaC,SAHE,KAIfD,EAAaE,KAAOA,EACpBF,EAAaG,KAAOA,qCCXpBp1B,EAAOC,QAAU,EAAjB,yCCAA,IAAI4E,EAAI,EAAQ,MAEZyxB,EAAO,EAAQ,MAEfnhB,EAAS,EAAQ,MAErBnV,EAAOC,QAAUs2B,EACjB,IAAIjc,EAAM,GAAGha,eAITk2B,EAAQ,CAAC,UAAW,OAAQ,WAAY,OAAQ,UAAW,WA4B/D,SAASD,EAAM/0B,GACb,IAAIi1B,EACArzB,EAEJ,GAAK5B,GAEE,GAAuB,iBAAZA,GAAwB2T,EAAO3T,GAC/CA,EAAU,CACR+yB,SAAU/yB,QAEP,GAAI,YAAaA,GAAW,aAAcA,EAC/C,OAAOA,OANPA,EAAU,GASZ,KAAM+Z,gBAAgBgb,GACpB,OAAO,IAAIA,EAAM/0B,GAUnB,IAPA+Z,KAAK/F,KAAO,GACZ+F,KAAKmb,SAAW,GAChBnb,KAAKob,QAAU,GACfpb,KAAKqb,IAAMN,EAAKM,MAEhBxzB,GAAS,IAEAA,EAAQozB,EAAMj0B,QACrBk0B,EAAOD,EAAMpzB,GAETkX,EAAIvZ,KAAKS,EAASi1B,KACpBlb,KAAKkb,GAAQj1B,EAAQi1B,IAKzB,IAAKA,KAAQj1B,EACPg1B,EAAMptB,QAAQqtB,GAAQ,IACxBlb,KAAKkb,GAAQj1B,EAAQi1B,IA2E3B,SAASI,EAAWC,EAAMr1B,GACxB,GAAIq1B,GAAQA,EAAK1tB,QAAQvE,EAAEkyB,MAAQ,EACjC,MAAM,IAAI1uB,MAAM,IAAM5G,EAAO,uCAAyCoD,EAAEkyB,IAAM,KAKlF,SAASC,EAAeF,EAAMr1B,GAC5B,IAAKq1B,EACH,MAAM,IAAIzuB,MAAM,IAAM5G,EAAO,qBAKjC,SAASw1B,EAAWC,EAAMz1B,GACxB,IAAKy1B,EACH,MAAM,IAAI7uB,MAAM,YAAc5G,EAAO,mCA1JzC80B,EAAMl2B,UAAUG,SAqIhB,SAAkBuT,GAChB,OAAQwH,KAAKgZ,UAAY,IAAI/zB,SAASuT,IApIxC3T,OAAOK,eAAe81B,EAAMl2B,UAAW,OAAQ,CAC7C82B,IAiEF,WACE,OAAO5b,KAAKob,QAAQpb,KAAKob,QAAQp0B,OAAS,IAjE1C60B,IAoEF,SAAiBF,GACfF,EAAeE,EAAM,QAEjB3b,KAAK2b,OAASA,GAChB3b,KAAKob,QAAQ7yB,KAAKozB,MArEtB92B,OAAOK,eAAe81B,EAAMl2B,UAAW,UAAW,CAChD82B,IAwEF,WACE,MAA4B,iBAAd5b,KAAK2b,KAAoBryB,EAAEwyB,QAAQ9b,KAAK2b,WAAQxvB,GAxE9D0vB,IA2EF,SAAoBC,GAClBJ,EAAW1b,KAAK2b,KAAM,WACtB3b,KAAK2b,KAAOryB,EAAEuD,KAAKivB,GAAW,GAAI9b,KAAK+b,aA1EzCl3B,OAAOK,eAAe81B,EAAMl2B,UAAW,WAAY,CACjD82B,IA4EF,WACE,MAA4B,iBAAd5b,KAAK2b,KAAoBryB,EAAEyyB,SAAS/b,KAAK2b,WAAQxvB,GA5E/D0vB,IA+EF,SAAqBE,GACnBN,EAAeM,EAAU,YACzBT,EAAWS,EAAU,YACrB/b,KAAK2b,KAAOryB,EAAEuD,KAAKmT,KAAK8b,SAAW,GAAIC,MA/EzCl3B,OAAOK,eAAe81B,EAAMl2B,UAAW,UAAW,CAChD82B,IAiFF,WACE,MAA4B,iBAAd5b,KAAK2b,KAAoBryB,EAAE0yB,QAAQhc,KAAK2b,WAAQxvB,GAjF9D0vB,IAoFF,SAAoBG,GAIlB,GAHAV,EAAWU,EAAS,WACpBN,EAAW1b,KAAK2b,KAAM,WAElBK,EAAS,CACX,GAA8B,KAA1BA,EAAQ3b,WAAW,GAGrB,MAAM,IAAIvT,MAAM,iCAGlB,GAAIkvB,EAAQnuB,QAAQ,IAAK,IAAM,EAC7B,MAAM,IAAIf,MAAM,0CAIpBkT,KAAK2b,KAAOryB,EAAEuD,KAAKmT,KAAK8b,QAAS9b,KAAKic,MAAQD,GAAW,QAjG3Dn3B,OAAOK,eAAe81B,EAAMl2B,UAAW,OAAQ,CAC7C82B,IAmGF,WACE,MAA4B,iBAAd5b,KAAK2b,KAAoBryB,EAAEyyB,SAAS/b,KAAK2b,KAAM3b,KAAKgc,cAAW7vB,GAnG7E0vB,IAsGF,SAAiBI,GACfR,EAAeQ,EAAM,QACrBX,EAAWW,EAAM,QACjBjc,KAAK2b,KAAOryB,EAAEuD,KAAKmT,KAAK8b,SAAW,GAAIG,GAAQjc,KAAKgc,SAAW,2CC7IjE,IAAIE,EAAW,EAAQ,MAEnBlB,EAAQ,EAAQ,MAEpBv2B,EAAOC,QAAUs2B,EACjBA,EAAMl2B,UAAUq3B,QAKhB,SAAiBC,EAAQ9vB,EAAU+vB,GACjC,IAAIF,EAAU,IAAID,EAASE,EAAQ9vB,EAAU+vB,GAEzCrc,KAAK2b,OACPQ,EAAQj2B,KAAO8Z,KAAK2b,KAAO,IAAMQ,EAAQj2B,KACzCi2B,EAAQxE,KAAO3X,KAAK2b,MAKtB,OAFAQ,EAAQG,OAAQ,EAChBtc,KAAKmb,SAAS5yB,KAAK4zB,GACZA,GAdTnB,EAAMl2B,UAAUgmB,KA0BhB,WACE,IAAIqR,EAAUnc,KAAKmc,QAAQjrB,MAAM8O,KAAMlZ,WAEvC,OADAq1B,EAAQG,MAAQ,KACTH,GA5BTnB,EAAMl2B,UAAUy3B,KAiBhB,WACE,IAAIJ,EAAUnc,KAAKmc,QAAQjrB,MAAM8O,KAAMlZ,WAEvC,MADAq1B,EAAQG,OAAQ,EACVH,oCCqOR,SAASK,EAAUb,GACjB,IAAIc,EACAp2B,EAkBJ,OAjBAq1B,EAAWC,GACXc,EAAkC,KAAvBd,EAAKtb,WAAW,GAI3Bha,EAgBF,SAAyBs1B,EAAMe,GAC7B,IAKIllB,EACAmlB,EANAv0B,EAAS,GACTw0B,EAAoB,EACpBC,GAAa,EACbC,EAAO,EACPj1B,GAAS,EAIb,OAASA,GAAS8zB,EAAK30B,QAAQ,CAC7B,GAAIa,EAAQ8zB,EAAK30B,OACfwQ,EAAOmkB,EAAKtb,WAAWxY,OAClB,IAAa,KAAT2P,EAGT,MAEAA,EAAO,GAIT,GAAa,KAATA,EAEF,CACA,GAAIqlB,IAAch1B,EAAQ,GAAc,IAATi1B,QACxB,GAAID,IAAch1B,EAAQ,GAAc,IAATi1B,EAAY,CAChD,GAAI10B,EAAOpB,OAAS,GAA2B,IAAtB41B,GAAoE,KAAzCx0B,EAAOiY,WAAWjY,EAAOpB,OAAS,IAE1C,KAAzCoB,EAAOiY,WAAWjY,EAAOpB,OAAS,GAGnC,GAAIoB,EAAOpB,OAAS,GAIlB,IAHA21B,EAAiBv0B,EAAO20B,YAAY,QAGb30B,EAAOpB,OAAS,EAAG,CACpC21B,EAAiB,GACnBv0B,EAAS,GACTw0B,EAAoB,GAGpBA,GADAx0B,EAASA,EAAOmK,MAAM,EAAGoqB,IACE31B,OAAS,EAAIoB,EAAO20B,YAAY,KAG7DF,EAAYh1B,EACZi1B,EAAO,EACP,eAEG,GAAI10B,EAAOpB,OAAQ,CACxBoB,EAAS,GACTw0B,EAAoB,EACpBC,EAAYh1B,EACZi1B,EAAO,EACP,SAIAJ,IACFt0B,EAASA,EAAOpB,OAASoB,EAAS,MAAQ,KAC1Cw0B,EAAoB,QAGlBx0B,EAAOpB,OACToB,GAAU,IAAMuzB,EAAKppB,MAAMsqB,EAAY,EAAGh1B,GAE1CO,EAASuzB,EAAKppB,MAAMsqB,EAAY,EAAGh1B,GAGrC+0B,EAAoB/0B,EAAQg1B,EAAY,EAG1CA,EAAYh1B,EACZi1B,EAAO,OACW,KAATtlB,GAERslB,GAAQ,EACTA,IAEAA,GAAQ,EAIZ,OAAO10B,EAlGC40B,CAAgBrB,GAAOc,GAE1Bp2B,EAAMW,QAAWy1B,IACpBp2B,EAAQ,KAGNA,EAAMW,QAA+C,KAArC20B,EAAKtb,WAAWsb,EAAK30B,OAAS,KAGhDX,GAAS,KAGJo2B,EAAW,IAAMp2B,EAAQA,EAyFlC,SAASq1B,EAAWC,GAClB,GAAoB,iBAATA,EACT,MAAM,IAAIsB,UAAU,mCAAqCC,KAAKpF,UAAU6D,IA9T5Ej3B,EAAQq3B,SAMR,SAAkBJ,EAAMwB,GACtB,IAEIt1B,EACAu1B,EACAC,EACAC,EALA/wB,EAAQ,EACRI,GAAO,EAMX,QAAYR,IAARgxB,GAAoC,iBAARA,EAC9B,MAAM,IAAIF,UAAU,mCAMtB,GAHAvB,EAAWC,GACX9zB,EAAQ8zB,EAAK30B,YAEDmF,IAARgxB,IAAsBA,EAAIn2B,QAAUm2B,EAAIn2B,OAAS20B,EAAK30B,OAAQ,CAChE,KAAOa,KACL,GAA+B,KAA3B8zB,EAAKtb,WAAWxY,IAKlB,GAAIw1B,EAAc,CAChB9wB,EAAQ1E,EAAQ,EAChB,YAEO8E,EAAM,IAGf0wB,GAAe,EACf1wB,EAAM9E,EAAQ,GAIlB,OAAO8E,EAAM,EAAI,GAAKgvB,EAAKppB,MAAMhG,EAAOI,GAG1C,GAAIwwB,IAAQxB,EACV,MAAO,GAGTyB,GAAoB,EACpBE,EAAWH,EAAIn2B,OAAS,EAExB,KAAOa,KACL,GAA+B,KAA3B8zB,EAAKtb,WAAWxY,IAKlB,GAAIw1B,EAAc,CAChB9wB,EAAQ1E,EAAQ,EAChB,YAGEu1B,EAAmB,IAGrBC,GAAe,EACfD,EAAmBv1B,EAAQ,GAGzBy1B,GAAY,IAEV3B,EAAKtb,WAAWxY,KAAWs1B,EAAI9c,WAAWid,KACxCA,EAAW,IAGb3wB,EAAM9E,IAKRy1B,GAAY,EACZ3wB,EAAMywB,IAMV7wB,IAAUI,EACZA,EAAMywB,EACGzwB,EAAM,IACfA,EAAMgvB,EAAK30B,QAGb,OAAO20B,EAAKppB,MAAMhG,EAAOI,IA3F3BjI,EAAQo3B,QA8FR,SAAiBH,GACf,IAAIhvB,EACA4wB,EACA11B,EAGJ,GAFA6zB,EAAWC,IAENA,EAAK30B,OACR,MAAO,IAGT2F,GAAO,EACP9E,EAAQ8zB,EAAK30B,OAEb,OAASa,GACP,GAA+B,KAA3B8zB,EAAKtb,WAAWxY,IAGlB,GAAI01B,EAAgB,CAClB5wB,EAAM9E,EACN,YAEQ01B,IAEVA,GAAiB,GAIrB,OAAO5wB,EAAM,EAA2B,KAAvBgvB,EAAKtb,WAAW,GAE/B,IAAM,IAAc,IAAR1T,GAAoC,KAAvBgvB,EAAKtb,WAAW,GAEzC,KAAOsb,EAAKppB,MAAM,EAAG5F,IA5HzBjI,EAAQs3B,QA+HR,SAAiBL,GACf,IAMI4B,EACA/lB,EACA3P,EARA21B,GAAY,EACZC,EAAY,EACZ9wB,GAAO,EAGP+wB,EAAc,EAIlBhC,EAAWC,GACX9zB,EAAQ8zB,EAAK30B,OAEb,KAAOa,KAGL,GAAa,MAFb2P,EAAOmkB,EAAKtb,WAAWxY,IAenB8E,EAAM,IAGR4wB,GAAiB,EACjB5wB,EAAM9E,EAAQ,GAGH,KAAT2P,EAIEgmB,EAAW,EACbA,EAAW31B,EACc,IAAhB61B,IACTA,EAAc,GAEPF,GAAY,IAGrBE,GAAe,QA3Bf,GAAIH,EAAgB,CAClBE,EAAY51B,EAAQ,EACpB,MA6BN,GAAI21B,EAAW,GAAK7wB,EAAM,GACV,IAAhB+wB,GACgB,IAAhBA,GAAqBF,IAAa7wB,EAAM,GAAK6wB,IAAaC,EAAY,EACpE,MAAO,GAGT,OAAO9B,EAAKppB,MAAMirB,EAAU7wB,IAxL9BjI,EAAQmI,KA2LR,WACE,IACI8wB,EADA91B,GAAS,EAGb,OAASA,EAAQf,UAAUE,QACzB00B,EAAW50B,UAAUe,IAEjBf,UAAUe,KACZ81B,OAAoBxxB,IAAXwxB,EAAuB72B,UAAUe,GAAS81B,EAAS,IAAM72B,UAAUe,IAIhF,YAAkBsE,IAAXwxB,EAAuB,IAAMnB,EAAUmB,IAtMhDj5B,EAAQ82B,IAAM,qCCnDd92B,EAAQ22B,IAER,WACE,MAAO,mCCLT,IAAItc,EAAM,GAAGha,eA4Bb,SAASoa,EAAMA,GAKb,OAJKA,GAA0B,iBAAVA,IACnBA,EAAQ,IAGHtX,EAAMsX,EAAM3S,MAAQ,IAAM3E,EAAMsX,EAAM1S,QAG/C,SAASH,EAASM,GAKhB,OAJKA,GAAsB,iBAARA,IACjBA,EAAM,IAGDuS,EAAMvS,EAAIL,OAAS,IAAM4S,EAAMvS,EAAID,KAG5C,SAAS9E,EAAMxB,GACb,OAAOA,GAA0B,iBAAVA,EAAqBA,EAAQ,EA5CtD5B,EAAOC,QAEP,SAAmB2B,GAEjB,IAAKA,GAA0B,iBAAVA,EACnB,MAAO,GAIT,GAAI0Y,EAAIvZ,KAAKa,EAAO,aAAe0Y,EAAIvZ,KAAKa,EAAO,QACjD,OAAOiG,EAASjG,EAAMiG,UAIxB,GAAIyS,EAAIvZ,KAAKa,EAAO,UAAY0Y,EAAIvZ,KAAKa,EAAO,OAC9C,OAAOiG,EAASjG,GAIlB,GAAI0Y,EAAIvZ,KAAKa,EAAO,SAAW0Y,EAAIvZ,KAAKa,EAAO,UAC7C,OAAO8Y,EAAM9Y,GAIf,MAAO,uCCzBT,IAAIyxB,EAAY,EAAQ,KAIxB,SAAS8F,KAFTn5B,EAAOC,QAAUw3B,EAIjB0B,EAAkB94B,UAAYgI,MAAMhI,UACpCo3B,EAASp3B,UAAY,IAAI84B,EAEzB,IAAIC,EAAQ3B,EAASp3B,UAcrB,SAASo3B,EAASE,EAAQ9vB,EAAU+vB,GAClC,IAAIyB,EACAC,EACAC,EAEoB,iBAAb1xB,IACT+vB,EAAS/vB,EACTA,EAAW,MAGbwxB,EA2CF,SAAqBzB,GACnB,IACIx0B,EADAO,EAAS,CAAC,KAAM,MAGE,iBAAXi0B,KAGM,KAFfx0B,EAAQw0B,EAAOxuB,QAAQ,MAGrBzF,EAAO,GAAKi0B,GAEZj0B,EAAO,GAAKi0B,EAAO9pB,MAAM,EAAG1K,GAC5BO,EAAO,GAAKi0B,EAAO9pB,MAAM1K,EAAQ,KAIrC,OAAOO,EA1DC61B,CAAY5B,GACpB0B,EAAQjG,EAAUxrB,IAAa,MAC/B0xB,EAAW,CACTzxB,MAAO,CACLC,KAAM,KACNC,OAAQ,MAEVE,IAAK,CACHH,KAAM,KACNC,OAAQ,OAIRH,GAAYA,EAASA,WACvBA,EAAWA,EAASA,UAGlBA,IAEEA,EAASC,OACXyxB,EAAW1xB,EACXA,EAAWA,EAASC,OAGpByxB,EAASzxB,MAAQD,GAIjB8vB,EAAOn0B,QACT+X,KAAK/X,MAAQm0B,EAAOn0B,MACpBm0B,EAASA,EAAOD,SAGlBnc,KAAKmc,QAAUC,EACfpc,KAAK9Z,KAAO63B,EACZ/d,KAAKoc,OAASA,EACdpc,KAAKxT,KAAOF,EAAWA,EAASE,KAAO,KACvCwT,KAAKvT,OAASH,EAAWA,EAASG,OAAS,KAC3CuT,KAAKge,SAAWA,EAChBhe,KAAKxM,OAASsqB,EAAM,GACpB9d,KAAKke,OAASJ,EAAM,GA/DtBD,EAAMlG,KAAO,GACbkG,EAAM33B,KAAO,GACb23B,EAAMzB,OAAS,GACfyB,EAAM1B,QAAU,GAChB0B,EAAM51B,MAAQ,GACd41B,EAAMvB,MAAQ,KACduB,EAAMpxB,OAAS,KACfoxB,EAAMrxB,KAAO,uBCnBb/H,EAAOC,QAGP,WAGE,IAFA,IAAIsB,EAAS,GAEJe,EAAI,EAAGA,EAAID,UAAUE,OAAQD,IAAK,CACzC,IAAIyM,EAAS1M,UAAUC,GAEvB,IAAK,IAAIpB,KAAO6N,EACVzO,EAAeS,KAAKgO,EAAQ7N,KAC9BK,EAAOL,GAAO6N,EAAO7N,IAK3B,OAAOK,GAfT,IAAIjB,EAAiBF,OAAOC,UAAUC","sources":["webpack://website-frontend/./node_modules/bail/index.js","webpack://website-frontend/./node_modules/extend/index.js","webpack://website-frontend/./node_modules/is-buffer/index.js","webpack://website-frontend/./node_modules/is-plain-obj/index.js","webpack://website-frontend/./node_modules/mdast-add-list-metadata/index.js","webpack://website-frontend/./node_modules/mdast-add-list-metadata/node_modules/unist-util-visit-parents/index.js","webpack://website-frontend/./node_modules/react-is/cjs/react-is.production.min.js","webpack://website-frontend/./node_modules/react-is/index.js","webpack://website-frontend/./node_modules/react-markdown/lib/ast-to-react.js","webpack://website-frontend/./node_modules/react-markdown/lib/get-definitions.js","webpack://website-frontend/./node_modules/react-markdown/lib/plugins/disallow-node.js","webpack://website-frontend/./node_modules/react-markdown/lib/plugins/naive-html.js","webpack://website-frontend/./node_modules/react-markdown/lib/react-markdown.js","webpack://website-frontend/./node_modules/react-markdown/lib/renderers.js","webpack://website-frontend/./node_modules/react-markdown/lib/symbols.js","webpack://website-frontend/./node_modules/react-markdown/lib/uri-transformer.js","webpack://website-frontend/./node_modules/react-markdown/lib/wrap-table-rows.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/mdast-util-from-markdown/dist/index.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/mdast-util-from-markdown/index.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/mdast-util-to-string/index.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/character/ascii-alpha.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/character/ascii-alphanumeric.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/character/ascii-atext.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/character/ascii-control.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/character/ascii-digit.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/character/ascii-hex-digit.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/character/ascii-punctuation.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/character/markdown-line-ending-or-space.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/character/markdown-line-ending.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/character/markdown-space.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/character/unicode-punctuation.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/character/unicode-whitespace.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/constant/assign.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/constant/from-char-code.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/constant/has-own-property.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/constant/html-block-names.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/constant/html-raw-names.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/constant/splice.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/constant/unicode-punctuation-regex.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/constructs.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/initialize/content.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/initialize/document.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/initialize/flow.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/initialize/text.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/parse.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/postprocess.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/preprocess.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/tokenize/attention.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/tokenize/autolink.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/tokenize/block-quote.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/tokenize/character-escape.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/tokenize/character-reference.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/tokenize/code-fenced.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/tokenize/code-indented.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/tokenize/code-text.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/tokenize/content.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/tokenize/definition.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/tokenize/factory-destination.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/tokenize/factory-label.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/tokenize/factory-space.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/tokenize/factory-title.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/tokenize/factory-whitespace.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/tokenize/hard-break-escape.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/tokenize/heading-atx.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/tokenize/html-flow.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/tokenize/html-text.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/tokenize/label-end.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/tokenize/label-start-image.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/tokenize/label-start-link.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/tokenize/line-ending.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/tokenize/list.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/tokenize/partial-blank-line.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/tokenize/setext-underline.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/tokenize/thematic-break.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/util/chunked-push.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/util/chunked-splice.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/util/classify-character.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/util/combine-extensions.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/util/create-tokenizer.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/util/miniflat.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/util/move-point.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/util/normalize-identifier.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/util/prefix-size.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/util/regex-check.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/util/resolve-all.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/util/safe-from-int.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/util/serialize-chunks.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/util/shallow.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/util/size-chunks.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/util/slice-chunks.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/micromark/dist/util/subtokenize.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/parse-entities/decode-entity.browser.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/remark-parse/index.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/unified/index.js","webpack://website-frontend/./node_modules/react-markdown/node_modules/unist-util-stringify-position/index.js","webpack://website-frontend/./node_modules/trough/index.js","webpack://website-frontend/./node_modules/trough/wrap.js","webpack://website-frontend/./node_modules/unist-util-visit/index.js","webpack://website-frontend/./node_modules/unist-util-visit/node_modules/unist-util-is/convert.js","webpack://website-frontend/./node_modules/unist-util-visit/node_modules/unist-util-visit-parents/color.browser.js","webpack://website-frontend/./node_modules/unist-util-visit/node_modules/unist-util-visit-parents/index.js","webpack://website-frontend/./node_modules/vfile/index.js","webpack://website-frontend/./node_modules/vfile/lib/core.js","webpack://website-frontend/./node_modules/vfile/lib/index.js","webpack://website-frontend/./node_modules/vfile/lib/minpath.browser.js","webpack://website-frontend/./node_modules/vfile/lib/minproc.browser.js","webpack://website-frontend/./node_modules/vfile/node_modules/unist-util-stringify-position/index.js","webpack://website-frontend/./node_modules/vfile/node_modules/vfile-message/index.js","webpack://website-frontend/./node_modules/xtend/immutable.js"],"sourcesContent":["'use strict';\n\nmodule.exports = bail;\n\nfunction bail(err) {\n  if (err) {\n    throw err;\n  }\n}","'use strict';\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar toStr = Object.prototype.toString;\nvar defineProperty = Object.defineProperty;\nvar gOPD = Object.getOwnPropertyDescriptor;\n\nvar isArray = function isArray(arr) {\n  if (typeof Array.isArray === 'function') {\n    return Array.isArray(arr);\n  }\n\n  return toStr.call(arr) === '[object Array]';\n};\n\nvar isPlainObject = function isPlainObject(obj) {\n  if (!obj || toStr.call(obj) !== '[object Object]') {\n    return false;\n  }\n\n  var hasOwnConstructor = hasOwn.call(obj, 'constructor');\n  var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf'); // Not own constructor property must be Object\n\n  if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {\n    return false;\n  } // Own properties are enumerated firstly, so to speed up,\n  // if last one is own, then all properties are own.\n\n\n  var key;\n\n  for (key in obj) {\n    /**/\n  }\n\n  return typeof key === 'undefined' || hasOwn.call(obj, key);\n}; // If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target\n\n\nvar setProperty = function setProperty(target, options) {\n  if (defineProperty && options.name === '__proto__') {\n    defineProperty(target, options.name, {\n      enumerable: true,\n      configurable: true,\n      value: options.newValue,\n      writable: true\n    });\n  } else {\n    target[options.name] = options.newValue;\n  }\n}; // Return undefined instead of __proto__ if '__proto__' is not an own property\n\n\nvar getProperty = function getProperty(obj, name) {\n  if (name === '__proto__') {\n    if (!hasOwn.call(obj, name)) {\n      return void 0;\n    } else if (gOPD) {\n      // In early versions of node, obj['__proto__'] is buggy when obj has\n      // __proto__ as an own property. Object.getOwnPropertyDescriptor() works.\n      return gOPD(obj, name).value;\n    }\n  }\n\n  return obj[name];\n};\n\nmodule.exports = function extend() {\n  var options, name, src, copy, copyIsArray, clone;\n  var target = arguments[0];\n  var i = 1;\n  var length = arguments.length;\n  var deep = false; // Handle a deep copy situation\n\n  if (typeof target === 'boolean') {\n    deep = target;\n    target = arguments[1] || {}; // skip the boolean and the target\n\n    i = 2;\n  }\n\n  if (target == null || typeof target !== 'object' && typeof target !== 'function') {\n    target = {};\n  }\n\n  for (; i < length; ++i) {\n    options = arguments[i]; // Only deal with non-null/undefined values\n\n    if (options != null) {\n      // Extend the base object\n      for (name in options) {\n        src = getProperty(target, name);\n        copy = getProperty(options, name); // Prevent never-ending loop\n\n        if (target !== copy) {\n          // Recurse if we're merging plain objects or arrays\n          if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {\n            if (copyIsArray) {\n              copyIsArray = false;\n              clone = src && isArray(src) ? src : [];\n            } else {\n              clone = src && isPlainObject(src) ? src : {};\n            } // Never move original objects, clone them\n\n\n            setProperty(target, {\n              name: name,\n              newValue: extend(deep, clone, copy)\n            }); // Don't bring in undefined values\n          } else if (typeof copy !== 'undefined') {\n            setProperty(target, {\n              name: name,\n              newValue: copy\n            });\n          }\n        }\n      }\n    }\n  } // Return the modified object\n\n\n  return target;\n};","/*!\n * Determine if an object is a Buffer\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */\nmodule.exports = function isBuffer(obj) {\n  return obj != null && obj.constructor != null && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj);\n};","'use strict';\n\nmodule.exports = function (value) {\n  if (Object.prototype.toString.call(value) !== '[object Object]') {\n    return false;\n  }\n\n  var prototype = Object.getPrototypeOf(value);\n  return prototype === null || prototype === Object.prototype;\n};","var visitWithParents = require('unist-util-visit-parents');\n\nfunction addListMetadata() {\n  return function (ast) {\n    visitWithParents(ast, 'list', function (listNode, parents) {\n      var depth = 0,\n          i,\n          n;\n\n      for (i = 0, n = parents.length; i < n; i++) {\n        if (parents[i].type === 'list') depth += 1;\n      }\n\n      for (i = 0, n = listNode.children.length; i < n; i++) {\n        var child = listNode.children[i];\n        child.index = i;\n        child.ordered = listNode.ordered;\n      }\n\n      listNode.depth = depth;\n    });\n    return ast;\n  };\n}\n\nmodule.exports = addListMetadata;","'use strict';\n/* Expose. */\n\nmodule.exports = visitParents;\n/* Visit. */\n\nfunction visitParents(tree, type, visitor) {\n  var stack = [];\n\n  if (typeof type === 'function') {\n    visitor = type;\n    type = null;\n  }\n\n  one(tree);\n  /* Visit a single node. */\n\n  function one(node) {\n    var result;\n\n    if (!type || node.type === type) {\n      result = visitor(node, stack.concat());\n    }\n\n    if (node.children && result !== false) {\n      return all(node.children, node);\n    }\n\n    return result;\n  }\n  /* Visit children in `parent`. */\n\n\n  function all(children, parent) {\n    var length = children.length;\n    var index = -1;\n    var child;\n    stack.push(parent);\n\n    while (++index < length) {\n      child = children[index];\n\n      if (child && one(child) === false) {\n        return false;\n      }\n    }\n\n    stack.pop();\n    return true;\n  }\n}","/** @license React v16.13.1\n * react-is.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';\n\nvar b = \"function\" === typeof Symbol && Symbol.for,\n    c = b ? Symbol.for(\"react.element\") : 60103,\n    d = b ? Symbol.for(\"react.portal\") : 60106,\n    e = b ? Symbol.for(\"react.fragment\") : 60107,\n    f = b ? Symbol.for(\"react.strict_mode\") : 60108,\n    g = b ? Symbol.for(\"react.profiler\") : 60114,\n    h = b ? Symbol.for(\"react.provider\") : 60109,\n    k = b ? Symbol.for(\"react.context\") : 60110,\n    l = b ? Symbol.for(\"react.async_mode\") : 60111,\n    m = b ? Symbol.for(\"react.concurrent_mode\") : 60111,\n    n = b ? Symbol.for(\"react.forward_ref\") : 60112,\n    p = b ? Symbol.for(\"react.suspense\") : 60113,\n    q = b ? Symbol.for(\"react.suspense_list\") : 60120,\n    r = b ? Symbol.for(\"react.memo\") : 60115,\n    t = b ? Symbol.for(\"react.lazy\") : 60116,\n    v = b ? Symbol.for(\"react.block\") : 60121,\n    w = b ? Symbol.for(\"react.fundamental\") : 60117,\n    x = b ? Symbol.for(\"react.responder\") : 60118,\n    y = b ? Symbol.for(\"react.scope\") : 60119;\n\nfunction z(a) {\n  if (\"object\" === typeof a && null !== a) {\n    var u = a.$$typeof;\n\n    switch (u) {\n      case c:\n        switch (a = a.type, a) {\n          case l:\n          case m:\n          case e:\n          case g:\n          case f:\n          case p:\n            return a;\n\n          default:\n            switch (a = a && a.$$typeof, a) {\n              case k:\n              case n:\n              case t:\n              case r:\n              case h:\n                return a;\n\n              default:\n                return u;\n            }\n\n        }\n\n      case d:\n        return u;\n    }\n  }\n}\n\nfunction A(a) {\n  return z(a) === m;\n}\n\nexports.AsyncMode = l;\nexports.ConcurrentMode = m;\nexports.ContextConsumer = k;\nexports.ContextProvider = h;\nexports.Element = c;\nexports.ForwardRef = n;\nexports.Fragment = e;\nexports.Lazy = t;\nexports.Memo = r;\nexports.Portal = d;\nexports.Profiler = g;\nexports.StrictMode = f;\nexports.Suspense = p;\n\nexports.isAsyncMode = function (a) {\n  return A(a) || z(a) === l;\n};\n\nexports.isConcurrentMode = A;\n\nexports.isContextConsumer = function (a) {\n  return z(a) === k;\n};\n\nexports.isContextProvider = function (a) {\n  return z(a) === h;\n};\n\nexports.isElement = function (a) {\n  return \"object\" === typeof a && null !== a && a.$$typeof === c;\n};\n\nexports.isForwardRef = function (a) {\n  return z(a) === n;\n};\n\nexports.isFragment = function (a) {\n  return z(a) === e;\n};\n\nexports.isLazy = function (a) {\n  return z(a) === t;\n};\n\nexports.isMemo = function (a) {\n  return z(a) === r;\n};\n\nexports.isPortal = function (a) {\n  return z(a) === d;\n};\n\nexports.isProfiler = function (a) {\n  return z(a) === g;\n};\n\nexports.isStrictMode = function (a) {\n  return z(a) === f;\n};\n\nexports.isSuspense = function (a) {\n  return z(a) === p;\n};\n\nexports.isValidElementType = function (a) {\n  return \"string\" === typeof a || \"function\" === typeof a || a === e || a === m || a === g || a === f || a === p || a === q || \"object\" === typeof a && null !== a && (a.$$typeof === t || a.$$typeof === r || a.$$typeof === h || a.$$typeof === k || a.$$typeof === n || a.$$typeof === w || a.$$typeof === x || a.$$typeof === y || a.$$typeof === v);\n};\n\nexports.typeOf = z;","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react-is.production.min.js');\n} else {\n  module.exports = require('./cjs/react-is.development.js');\n}","'use strict';\n\nvar React = require('react');\n\nvar xtend = require('xtend');\n\nvar ReactIs = require('react-is');\n\nfunction astToReact(node, options) {\n  var parent = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  var index = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;\n  var renderer = options.renderers[node.type]; // Nodes created by plugins do not have positional info, in which case we set\n  // an object that matches the positon interface.\n\n  if (!node.position) {\n    node.position = {\n      start: {\n        line: null,\n        column: null,\n        offset: null\n      },\n      end: {\n        line: null,\n        column: null,\n        offset: null\n      }\n    };\n  }\n\n  var pos = node.position.start;\n  var key = [node.type, pos.line, pos.column, index].join('-');\n\n  if (!ReactIs.isValidElementType(renderer)) {\n    throw new Error(\"Renderer for type `\".concat(node.type, \"` not defined or is not renderable\"));\n  }\n\n  var nodeProps = getNodeProps(node, key, options, renderer, parent, index);\n  return React.createElement(renderer, nodeProps, nodeProps.children || resolveChildren() || undefined);\n\n  function resolveChildren() {\n    return node.children && node.children.map(function (childNode, i) {\n      return astToReact(childNode, options, {\n        node: node,\n        props: nodeProps\n      }, i);\n    });\n  }\n} // eslint-disable-next-line max-params, complexity\n\n\nfunction getNodeProps(node, key, opts, renderer, parent, index) {\n  var props = {\n    key: key\n  };\n  var isSimpleRenderer = typeof renderer === 'string' || renderer === React.Fragment; // `sourcePos` is true if the user wants source information (line/column info from markdown source)\n\n  if (opts.sourcePos && node.position) {\n    props['data-sourcepos'] = flattenPosition(node.position);\n  }\n\n  if (opts.rawSourcePos && !isSimpleRenderer) {\n    props.sourcePosition = node.position;\n  } // If `includeNodeIndex` is true, pass node index info to all non-tag renderers\n\n\n  if (opts.includeNodeIndex && parent.node && parent.node.children && !isSimpleRenderer) {\n    props.index = parent.node.children.indexOf(node);\n    props.parentChildCount = parent.node.children.length;\n  }\n\n  var ref = node.identifier !== null && node.identifier !== undefined ?\n  /* istanbul ignore next - plugins could inject an undefined reference. */\n  opts.definitions[node.identifier.toUpperCase()] || {} : null;\n\n  switch (node.type) {\n    case 'root':\n      assignDefined(props, {\n        className: opts.className\n      });\n      break;\n\n    case 'text':\n      props.nodeKey = key;\n      props.children = node.value;\n      break;\n\n    case 'heading':\n      props.level = node.depth;\n      break;\n\n    case 'list':\n      props.start = node.start;\n      props.ordered = node.ordered;\n      props.spread = node.spread;\n      props.depth = node.depth;\n      break;\n\n    case 'listItem':\n      props.checked = node.checked;\n      props.spread = node.spread;\n      props.ordered = node.ordered;\n      props.index = node.index;\n      props.children = getListItemChildren(node, parent).map(function (childNode, i) {\n        return astToReact(childNode, opts, {\n          node: node,\n          props: props\n        }, i);\n      });\n      break;\n\n    case 'definition':\n      assignDefined(props, {\n        identifier: node.identifier,\n        title: node.title,\n        url: node.url\n      });\n      break;\n\n    case 'code':\n      assignDefined(props, {\n        language: node.lang && node.lang.split(/\\s/, 1)[0]\n      });\n      break;\n\n    case 'inlineCode':\n      props.children = node.value;\n      props.inline = true;\n      break;\n\n    case 'link':\n      assignDefined(props, {\n        title: node.title || undefined,\n        target: typeof opts.linkTarget === 'function' ? opts.linkTarget(node.url, node.children, node.title) : opts.linkTarget,\n        href: opts.transformLinkUri ? opts.transformLinkUri(node.url, node.children, node.title) : node.url\n      });\n      break;\n\n    case 'image':\n      assignDefined(props, {\n        src: opts.transformImageUri ? opts.transformImageUri(node.url, node.children, node.title, node.alt) : node.url,\n        alt: node.alt || '',\n        title: node.title || undefined\n      });\n      break;\n\n    case 'linkReference':\n      assignDefined(props, xtend(ref, {\n        href: opts.transformLinkUri ? opts.transformLinkUri(ref.href) : ref.href\n      }));\n      break;\n\n    case 'imageReference':\n      assignDefined(props, {\n        src: opts.transformImageUri && ref.href ? opts.transformImageUri(ref.href, node.children, ref.title, node.alt) : ref.href,\n        alt: node.alt || '',\n        title: ref.title || undefined\n      });\n      break;\n\n    case 'table':\n    case 'tableHead':\n    case 'tableBody':\n      props.columnAlignment = node.align;\n      break;\n\n    case 'tableRow':\n      props.isHeader = parent.node.type === 'tableHead';\n      props.columnAlignment = parent.props.columnAlignment;\n      break;\n\n    case 'tableCell':\n      assignDefined(props, {\n        isHeader: parent.props.isHeader,\n        align: parent.props.columnAlignment[index]\n      });\n      break;\n\n    case 'virtualHtml':\n      props.tag = node.tag;\n      break;\n\n    case 'html':\n      // @todo find a better way than this\n      props.isBlock = node.position.start.line !== node.position.end.line;\n      props.allowDangerousHtml = opts.allowDangerousHtml;\n      props.escapeHtml = opts.escapeHtml;\n      props.skipHtml = opts.skipHtml;\n      break;\n\n    case 'parsedHtml':\n      {\n        var parsedChildren;\n\n        if (node.children) {\n          parsedChildren = node.children.map(function (child, i) {\n            return astToReact(child, opts, {\n              node: node,\n              props: props\n            }, i);\n          });\n        }\n\n        props.allowDangerousHtml = opts.allowDangerousHtml;\n        props.escapeHtml = opts.escapeHtml;\n        props.skipHtml = opts.skipHtml;\n        props.element = node.element ? mergeNodeChildren(node, parsedChildren) : null;\n        break;\n      }\n\n    default:\n      assignDefined(props, xtend(node, {\n        type: undefined,\n        position: undefined,\n        children: undefined\n      }));\n  }\n\n  if (!isSimpleRenderer && node.value) {\n    props.value = node.value;\n  }\n\n  if (!isSimpleRenderer) {\n    props.node = node;\n  }\n\n  return props;\n}\n\nfunction assignDefined(target, attrs) {\n  for (var key in attrs) {\n    if (typeof attrs[key] !== 'undefined') {\n      target[key] = attrs[key];\n    }\n  }\n}\n\nfunction mergeNodeChildren(node, parsedChildren) {\n  var el = node.element;\n\n  if (Array.isArray(el)) {\n    /* istanbul ignore next - `div` fallback for old React. */\n    var Fragment = React.Fragment || 'div';\n    return React.createElement(Fragment, null, el);\n  }\n\n  if (el.props.children || parsedChildren) {\n    var children = React.Children.toArray(el.props.children).concat(parsedChildren);\n    return React.cloneElement(el, null, children);\n  }\n\n  return React.cloneElement(el, null);\n}\n\nfunction flattenPosition(pos) {\n  return [pos.start.line, ':', pos.start.column, '-', pos.end.line, ':', pos.end.column].map(String).join('');\n}\n\nfunction getListItemChildren(node, parent) {\n  /* istanbul ignore next - list items are always in a list, but best to be sure. */\n  var loose = parent && parent.node ? listLoose(parent.node) : listItemLoose(node);\n  return loose ? node.children : unwrapParagraphs(node);\n}\n\nfunction unwrapParagraphs(node) {\n  return node.children.reduce(function (array, child) {\n    return array.concat(child.type === 'paragraph' ? child.children : [child]);\n  }, []);\n}\n\nfunction listLoose(node) {\n  var children = node.children;\n  var loose = node.spread;\n  var index = -1;\n\n  while (!loose && ++index < children.length) {\n    loose = listItemLoose(children[index]);\n  }\n\n  return loose;\n}\n\nfunction listItemLoose(node) {\n  var spread = node.spread;\n  /* istanbul ignore next - spread is present from remark-parse, but maybe plugins don’t set it. */\n\n  return spread === undefined || spread === null ? node.children.length > 1 : spread;\n}\n\nmodule.exports = astToReact;","'use strict';\n\nvar visit = require('unist-util-visit');\n\nmodule.exports = function getDefinitions(tree) {\n  var definitions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  visit(tree, 'definition', function (node) {\n    var identifier = node.identifier.toUpperCase();\n    if (identifier in definitions) return;\n    definitions[identifier] = {\n      href: node.url,\n      title: node.title\n    };\n  });\n  return definitions;\n};","\"use strict\";\n\nvar visit = require('unist-util-visit');\n\nvar splice = [].splice;\n\nexports.ofType = function (types, mode) {\n  return ifNotMatch(allow, mode);\n\n  function allow(node, index, parent) {\n    return !types.includes(node.type);\n  }\n};\n\nexports.ifNotMatch = ifNotMatch;\n\nfunction ifNotMatch(allow, mode) {\n  return transform;\n\n  function transform(tree) {\n    visit(tree, filter);\n    return tree;\n  } // eslint-disable-next-line consistent-return\n\n\n  function filter(node, index, parent) {\n    if (parent && !allow(node, index, parent)) {\n      var parameters = [index, 1];\n\n      if (mode === 'unwrap' && node.children) {\n        parameters = parameters.concat(node.children);\n      }\n\n      splice.apply(parent.children, parameters);\n      return index;\n    }\n  }\n}","\"use strict\";\n/**\n * Naive, simple plugin to match inline nodes without attributes\n * This allows say <strong>foo</strong>, but not <strong class=\"very\">foo</strong>\n * For proper HTML support, you'll want a different plugin\n **/\n\nvar visit = require('unist-util-visit');\n\nvar type = 'virtualHtml';\nvar selfClosingRe = /^<(area|base|br|col|embed|hr|img|input|keygen|link|meta|param|source|track|wbr)\\s*\\/?>$/i;\nvar simpleTagRe = /^<(\\/?)([a-z]+)\\s*>$/;\n\nmodule.exports = function (tree) {\n  var open;\n  var currentParent;\n  visit(tree, 'html', function (node, index, parent) {\n    if (currentParent !== parent) {\n      open = [];\n      currentParent = parent;\n    }\n\n    var selfClosing = getSelfClosing(node);\n\n    if (selfClosing) {\n      parent.children.splice(index, 1, {\n        type: type,\n        tag: selfClosing,\n        position: node.position\n      });\n      return true;\n    }\n\n    var current = getSimpleTag(node, parent);\n\n    if (!current) {\n      return true;\n    }\n\n    var matching = findAndPull(open, current.tag);\n\n    if (matching) {\n      parent.children.splice(index, 0, virtual(current, matching, parent));\n    } else if (!current.opening) {\n      open.push(current);\n    }\n\n    return true;\n  }, true // Iterate in reverse\n  );\n  return tree;\n};\n\nfunction findAndPull(open, matchingTag) {\n  var i = open.length;\n\n  while (i--) {\n    if (open[i].tag === matchingTag) {\n      return open.splice(i, 1)[0];\n    }\n  }\n\n  return false;\n}\n\nfunction getSimpleTag(node, parent) {\n  var match = node.value.match(simpleTagRe);\n  return match ? {\n    tag: match[2],\n    opening: !match[1],\n    node: node\n  } : false;\n}\n\nfunction getSelfClosing(node) {\n  var match = node.value.match(selfClosingRe);\n  return match ? match[1] : false;\n}\n\nfunction virtual(fromNode, toNode, parent) {\n  var fromIndex = parent.children.indexOf(fromNode.node);\n  var toIndex = parent.children.indexOf(toNode.node);\n  var extracted = parent.children.splice(fromIndex, toIndex - fromIndex + 1);\n  var children = extracted.slice(1, -1);\n  return {\n    type: type,\n    children: children,\n    tag: fromNode.tag,\n    position: {\n      start: fromNode.node.position.start,\n      end: toNode.node.position.end,\n      indent: []\n    }\n  };\n}","'use strict';\n\nvar xtend = require('xtend');\n\nvar unified = require('unified');\n\nvar parse = require('remark-parse');\n\nvar PropTypes = require('prop-types');\n\nvar addListMetadata = require('mdast-add-list-metadata');\n\nvar naiveHtml = require('./plugins/naive-html');\n\nvar disallowNode = require('./plugins/disallow-node');\n\nvar astToReact = require('./ast-to-react');\n\nvar wrapTableRows = require('./wrap-table-rows');\n\nvar getDefinitions = require('./get-definitions');\n\nvar uriTransformer = require('./uri-transformer');\n\nvar defaultRenderers = require('./renderers');\n\nvar symbols = require('./symbols');\n\nvar allTypes = Object.keys(defaultRenderers);\n\nvar ReactMarkdown = function ReactMarkdown(props) {\n  // To do in next major: remove `source`.\n  var src = props.source || props.children || '';\n\n  if (props.allowedTypes && props.disallowedTypes) {\n    throw new Error('Only one of `allowedTypes` and `disallowedTypes` should be defined');\n  }\n\n  var renderers = xtend(defaultRenderers, props.renderers);\n  var processor = unified().use(parse).use(props.plugins || []); // eslint-disable-next-line no-sync\n\n  var tree = processor.runSync(processor.parse(src));\n  var renderProps = xtend(props, {\n    renderers: renderers,\n    definitions: getDefinitions(tree)\n  });\n  determineAstToReactTransforms(props).forEach(function (transform) {\n    tree = transform(tree, renderProps);\n  });\n  return tree;\n};\n\nfunction determineAstToReactTransforms(props) {\n  var transforms = [wrapTableRows, addListMetadata()];\n  var disallowedTypes = props.disallowedTypes;\n\n  if (props.allowedTypes) {\n    disallowedTypes = allTypes.filter(function (type) {\n      return type !== 'root' && props.allowedTypes.indexOf(type) === -1;\n    });\n  }\n\n  var removalMethod = props.unwrapDisallowed ? 'unwrap' : 'remove';\n\n  if (disallowedTypes && disallowedTypes.length > 0) {\n    transforms.push(disallowNode.ofType(disallowedTypes, removalMethod));\n  }\n\n  if (props.allowNode) {\n    transforms.push(disallowNode.ifNotMatch(props.allowNode, removalMethod));\n  } // To do in next major: remove `escapeHtml`.\n\n\n  var renderHtml = (props.allowDangerousHtml || props.escapeHtml === false) && !props.skipHtml;\n  var hasHtmlParser = (props.astPlugins || []).some(function (transform) {\n    return transform.identity === symbols.HtmlParser;\n  });\n\n  if (renderHtml && !hasHtmlParser) {\n    transforms.push(naiveHtml);\n  }\n\n  if (props.astPlugins) {\n    transforms = transforms.concat(props.astPlugins);\n  } // Add the final transform to turn everything into React.\n\n\n  transforms.push(astToReact);\n  return transforms;\n}\n\nReactMarkdown.defaultProps = {\n  transformLinkUri: uriTransformer\n};\nReactMarkdown.propTypes = {\n  className: PropTypes.string,\n  source: PropTypes.string,\n  children: PropTypes.string,\n  sourcePos: PropTypes.bool,\n  rawSourcePos: PropTypes.bool,\n  escapeHtml: PropTypes.bool,\n  allowDangerousHtml: PropTypes.bool,\n  skipHtml: PropTypes.bool,\n  allowNode: PropTypes.func,\n  allowedTypes: PropTypes.arrayOf(PropTypes.oneOf(allTypes)),\n  disallowedTypes: PropTypes.arrayOf(PropTypes.oneOf(allTypes)),\n  transformLinkUri: PropTypes.oneOfType([PropTypes.func, PropTypes.bool]),\n  linkTarget: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  transformImageUri: PropTypes.func,\n  astPlugins: PropTypes.arrayOf(PropTypes.func),\n  unwrapDisallowed: PropTypes.bool,\n  renderers: PropTypes.object,\n  plugins: PropTypes.array\n};\nReactMarkdown.types = allTypes;\nReactMarkdown.renderers = defaultRenderers;\nReactMarkdown.uriTransformer = uriTransformer;\nmodule.exports = ReactMarkdown;","/* eslint-disable react/prop-types, react/no-multi-comp */\n'use strict';\n\nvar xtend = require('xtend');\n\nvar React = require('react');\n/* istanbul ignore next - Don’t crash on old React. */\n\n\nvar supportsStringRender = parseInt((React.version || '16').slice(0, 2), 10) >= 16;\nvar createElement = React.createElement;\nmodule.exports = {\n  break: 'br',\n  paragraph: 'p',\n  emphasis: 'em',\n  strong: 'strong',\n  thematicBreak: 'hr',\n  blockquote: 'blockquote',\n  delete: 'del',\n  link: 'a',\n  image: 'img',\n  linkReference: 'a',\n  imageReference: 'img',\n  table: SimpleRenderer.bind(null, 'table'),\n  tableHead: SimpleRenderer.bind(null, 'thead'),\n  tableBody: SimpleRenderer.bind(null, 'tbody'),\n  tableRow: SimpleRenderer.bind(null, 'tr'),\n  tableCell: TableCell,\n  root: Root,\n  text: TextRenderer,\n  list: List,\n  listItem: ListItem,\n  definition: NullRenderer,\n  heading: Heading,\n  inlineCode: InlineCode,\n  code: CodeBlock,\n  html: Html,\n  virtualHtml: VirtualHtml,\n  parsedHtml: ParsedHtml\n};\n\nfunction TextRenderer(props) {\n  /* istanbul ignore next - a text node w/o a value could be injected by plugins */\n  var children = props.children || '';\n  /* istanbul ignore next - `span` is a fallback for old React. */\n\n  return supportsStringRender ? children : createElement('span', null, children);\n}\n\nfunction Root(props) {\n  var className = props.className;\n  var root = !className && React.Fragment || 'div';\n  return createElement(root, className ? {\n    className: className\n  } : null, props.children);\n}\n\nfunction SimpleRenderer(tag, props) {\n  return createElement(tag, getCoreProps(props), props.children);\n}\n\nfunction TableCell(props) {\n  var style = props.align ? {\n    textAlign: props.align\n  } : undefined;\n  var coreProps = getCoreProps(props);\n  return createElement(props.isHeader ? 'th' : 'td', style ? xtend({\n    style: style\n  }, coreProps) : coreProps, props.children);\n}\n\nfunction Heading(props) {\n  return createElement(\"h\".concat(props.level), getCoreProps(props), props.children);\n}\n\nfunction List(props) {\n  var attrs = getCoreProps(props);\n\n  if (props.start !== null && props.start !== 1 && props.start !== undefined) {\n    attrs.start = props.start.toString();\n  }\n\n  return createElement(props.ordered ? 'ol' : 'ul', attrs, props.children);\n}\n\nfunction ListItem(props) {\n  var checkbox = null;\n\n  if (props.checked !== null && props.checked !== undefined) {\n    var checked = props.checked;\n    checkbox = createElement('input', {\n      type: 'checkbox',\n      checked: checked,\n      readOnly: true\n    });\n  }\n\n  return createElement('li', getCoreProps(props), checkbox, props.children);\n}\n\nfunction CodeBlock(props) {\n  var className = props.language && \"language-\".concat(props.language);\n  var code = createElement('code', className ? {\n    className: className\n  } : null, props.value);\n  return createElement('pre', getCoreProps(props), code);\n}\n\nfunction InlineCode(props) {\n  return createElement('code', getCoreProps(props), props.children);\n}\n\nfunction Html(props) {\n  if (props.skipHtml) {\n    return null;\n  }\n\n  var dangerous = props.allowDangerousHtml || props.escapeHtml === false;\n  var tag = props.isBlock ? 'div' : 'span';\n\n  if (!dangerous) {\n    /* istanbul ignore next - `tag` is a fallback for old React. */\n    return createElement(React.Fragment || tag, null, props.value);\n  }\n\n  var nodeProps = {\n    dangerouslySetInnerHTML: {\n      __html: props.value\n    }\n  };\n  return createElement(tag, nodeProps);\n}\n\nfunction ParsedHtml(props) {\n  /* To do: `React.cloneElement` is slow, is it really needed? */\n  return props['data-sourcepos'] ? React.cloneElement(props.element, {\n    'data-sourcepos': props['data-sourcepos']\n  }) : props.element;\n}\n\nfunction VirtualHtml(props) {\n  return createElement(props.tag, getCoreProps(props), props.children);\n}\n\nfunction NullRenderer() {\n  return null;\n}\n\nfunction getCoreProps(props) {\n  var source = props['data-sourcepos'];\n  /* istanbul ignore next - nodes from plugins w/o position */\n\n  return source ? {\n    'data-sourcepos': source\n  } : {};\n}","\"use strict\";\n\nvar HtmlParser = '__RMD_HTML_PARSER__';\n/* istanbul ignore next - Fallback for `Symbol`. */\n\nexports.HtmlParser = typeof Symbol === 'undefined' ? HtmlParser : Symbol(HtmlParser);","\"use strict\";\n\nvar protocols = ['http', 'https', 'mailto', 'tel'];\n\nmodule.exports = function uriTransformer(uri) {\n  var url = (uri || '').trim();\n  var first = url.charAt(0);\n\n  if (first === '#' || first === '/') {\n    return url;\n  }\n\n  var colon = url.indexOf(':');\n\n  if (colon === -1) {\n    return url;\n  }\n\n  var length = protocols.length;\n  var index = -1;\n\n  while (++index < length) {\n    var protocol = protocols[index];\n\n    if (colon === protocol.length && url.slice(0, protocol.length).toLowerCase() === protocol) {\n      return url;\n    }\n  }\n\n  index = url.indexOf('?');\n\n  if (index !== -1 && colon > index) {\n    return url;\n  }\n\n  index = url.indexOf('#');\n\n  if (index !== -1 && colon > index) {\n    return url;\n  } // eslint-disable-next-line no-script-url\n\n\n  return 'javascript:void(0)';\n};","'use strict';\n\nvar visit = require('unist-util-visit');\n\nmodule.exports = function (node) {\n  visit(node, 'table', wrap);\n  return node;\n};\n\nfunction wrap(table) {\n  var children = table.children;\n  table.children = [{\n    type: 'tableHead',\n    align: table.align,\n    children: [children[0]],\n    position: children[0].position\n  }];\n\n  if (children.length > 1) {\n    table.children.push({\n      type: 'tableBody',\n      align: table.align,\n      children: children.slice(1),\n      position: {\n        start: children[1].position.start,\n        end: children[children.length - 1].position.end\n      }\n    });\n  }\n}","'use strict';\n\nmodule.exports = fromMarkdown; // These three are compiled away in the `dist/`\n\nvar toString = require('mdast-util-to-string');\n\nvar assign = require('micromark/dist/constant/assign');\n\nvar own = require('micromark/dist/constant/has-own-property');\n\nvar normalizeIdentifier = require('micromark/dist/util/normalize-identifier');\n\nvar safeFromInt = require('micromark/dist/util/safe-from-int');\n\nvar parser = require('micromark/dist/parse');\n\nvar preprocessor = require('micromark/dist/preprocess');\n\nvar postprocess = require('micromark/dist/postprocess');\n\nvar decode = require('parse-entities/decode-entity');\n\nvar stringifyPosition = require('unist-util-stringify-position');\n\nfunction fromMarkdown(value, encoding, options) {\n  if (typeof encoding !== 'string') {\n    options = encoding;\n    encoding = undefined;\n  }\n\n  return compiler(options)(postprocess(parser(options).document().write(preprocessor()(value, encoding, true))));\n} // Note this compiler only understand complete buffering, not streaming.\n\n\nfunction compiler(options) {\n  var settings = options || {};\n  var config = configure({\n    transforms: [],\n    canContainEols: ['emphasis', 'fragment', 'heading', 'paragraph', 'strong'],\n    enter: {\n      autolink: opener(link),\n      autolinkProtocol: onenterdata,\n      autolinkEmail: onenterdata,\n      atxHeading: opener(heading),\n      blockQuote: opener(blockQuote),\n      characterEscape: onenterdata,\n      characterReference: onenterdata,\n      codeFenced: opener(codeFlow),\n      codeFencedFenceInfo: buffer,\n      codeFencedFenceMeta: buffer,\n      codeIndented: opener(codeFlow, buffer),\n      codeText: opener(codeText, buffer),\n      codeTextData: onenterdata,\n      data: onenterdata,\n      codeFlowValue: onenterdata,\n      definition: opener(definition),\n      definitionDestinationString: buffer,\n      definitionLabelString: buffer,\n      definitionTitleString: buffer,\n      emphasis: opener(emphasis),\n      hardBreakEscape: opener(hardBreak),\n      hardBreakTrailing: opener(hardBreak),\n      htmlFlow: opener(html, buffer),\n      htmlFlowData: onenterdata,\n      htmlText: opener(html, buffer),\n      htmlTextData: onenterdata,\n      image: opener(image),\n      label: buffer,\n      link: opener(link),\n      listItem: opener(listItem),\n      listItemValue: onenterlistitemvalue,\n      listOrdered: opener(list, onenterlistordered),\n      listUnordered: opener(list),\n      paragraph: opener(paragraph),\n      reference: onenterreference,\n      referenceString: buffer,\n      resourceDestinationString: buffer,\n      resourceTitleString: buffer,\n      setextHeading: opener(heading),\n      strong: opener(strong),\n      thematicBreak: opener(thematicBreak)\n    },\n    exit: {\n      atxHeading: closer(),\n      atxHeadingSequence: onexitatxheadingsequence,\n      autolink: closer(),\n      autolinkEmail: onexitautolinkemail,\n      autolinkProtocol: onexitautolinkprotocol,\n      blockQuote: closer(),\n      characterEscapeValue: onexitdata,\n      characterReferenceMarkerHexadecimal: onexitcharacterreferencemarker,\n      characterReferenceMarkerNumeric: onexitcharacterreferencemarker,\n      characterReferenceValue: onexitcharacterreferencevalue,\n      codeFenced: closer(onexitcodefenced),\n      codeFencedFence: onexitcodefencedfence,\n      codeFencedFenceInfo: onexitcodefencedfenceinfo,\n      codeFencedFenceMeta: onexitcodefencedfencemeta,\n      codeFlowValue: onexitdata,\n      codeIndented: closer(onexitcodeindented),\n      codeText: closer(onexitcodetext),\n      codeTextData: onexitdata,\n      data: onexitdata,\n      definition: closer(),\n      definitionDestinationString: onexitdefinitiondestinationstring,\n      definitionLabelString: onexitdefinitionlabelstring,\n      definitionTitleString: onexitdefinitiontitlestring,\n      emphasis: closer(),\n      hardBreakEscape: closer(onexithardbreak),\n      hardBreakTrailing: closer(onexithardbreak),\n      htmlFlow: closer(onexithtmlflow),\n      htmlFlowData: onexitdata,\n      htmlText: closer(onexithtmltext),\n      htmlTextData: onexitdata,\n      image: closer(onexitimage),\n      label: onexitlabel,\n      labelText: onexitlabeltext,\n      lineEnding: onexitlineending,\n      link: closer(onexitlink),\n      listItem: closer(),\n      listOrdered: closer(),\n      listUnordered: closer(),\n      paragraph: closer(),\n      referenceString: onexitreferencestring,\n      resourceDestinationString: onexitresourcedestinationstring,\n      resourceTitleString: onexitresourcetitlestring,\n      resource: onexitresource,\n      setextHeading: closer(onexitsetextheading),\n      setextHeadingLineSequence: onexitsetextheadinglinesequence,\n      setextHeadingText: onexitsetextheadingtext,\n      strong: closer(),\n      thematicBreak: closer()\n    }\n  }, settings.mdastExtensions || []);\n  var data = {};\n  return compile;\n\n  function compile(events) {\n    var tree = {\n      type: 'root',\n      children: []\n    };\n    var stack = [tree];\n    var tokenStack = [];\n    var listStack = [];\n    var index = -1;\n    var handler;\n    var listStart;\n    var context = {\n      stack: stack,\n      tokenStack: tokenStack,\n      config: config,\n      enter: enter,\n      exit: exit,\n      buffer: buffer,\n      resume: resume,\n      setData: setData,\n      getData: getData\n    };\n\n    while (++index < events.length) {\n      // We preprocess lists to add `listItem` tokens, and to infer whether\n      // items the list itself are spread out.\n      if (events[index][1].type === 'listOrdered' || events[index][1].type === 'listUnordered') {\n        if (events[index][0] === 'enter') {\n          listStack.push(index);\n        } else {\n          listStart = listStack.pop(index);\n          index = prepareList(events, listStart, index);\n        }\n      }\n    }\n\n    index = -1;\n\n    while (++index < events.length) {\n      handler = config[events[index][0]];\n\n      if (own.call(handler, events[index][1].type)) {\n        handler[events[index][1].type].call(assign({\n          sliceSerialize: events[index][2].sliceSerialize\n        }, context), events[index][1]);\n      }\n    }\n\n    if (tokenStack.length) {\n      throw new Error('Cannot close document, a token (`' + tokenStack[tokenStack.length - 1].type + '`, ' + stringifyPosition({\n        start: tokenStack[tokenStack.length - 1].start,\n        end: tokenStack[tokenStack.length - 1].end\n      }) + ') is still open');\n    } // Figure out `root` position.\n\n\n    tree.position = {\n      start: point(events.length ? events[0][1].start : {\n        line: 1,\n        column: 1,\n        offset: 0\n      }),\n      end: point(events.length ? events[events.length - 2][1].end : {\n        line: 1,\n        column: 1,\n        offset: 0\n      })\n    };\n    index = -1;\n\n    while (++index < config.transforms.length) {\n      tree = config.transforms[index](tree) || tree;\n    }\n\n    return tree;\n  }\n\n  function prepareList(events, start, length) {\n    var index = start - 1;\n    var containerBalance = -1;\n    var listSpread = false;\n    var listItem;\n    var tailIndex;\n    var lineIndex;\n    var tailEvent;\n    var event;\n    var firstBlankLineIndex;\n    var atMarker;\n\n    while (++index <= length) {\n      event = events[index];\n\n      if (event[1].type === 'listUnordered' || event[1].type === 'listOrdered' || event[1].type === 'blockQuote') {\n        if (event[0] === 'enter') {\n          containerBalance++;\n        } else {\n          containerBalance--;\n        }\n\n        atMarker = undefined;\n      } else if (event[1].type === 'lineEndingBlank') {\n        if (event[0] === 'enter') {\n          if (listItem && !atMarker && !containerBalance && !firstBlankLineIndex) {\n            firstBlankLineIndex = index;\n          }\n\n          atMarker = undefined;\n        }\n      } else if (event[1].type === 'linePrefix' || event[1].type === 'listItemValue' || event[1].type === 'listItemMarker' || event[1].type === 'listItemPrefix' || event[1].type === 'listItemPrefixWhitespace') {// Empty.\n      } else {\n        atMarker = undefined;\n      }\n\n      if (!containerBalance && event[0] === 'enter' && event[1].type === 'listItemPrefix' || containerBalance === -1 && event[0] === 'exit' && (event[1].type === 'listUnordered' || event[1].type === 'listOrdered')) {\n        if (listItem) {\n          tailIndex = index;\n          lineIndex = undefined;\n\n          while (tailIndex--) {\n            tailEvent = events[tailIndex];\n\n            if (tailEvent[1].type === 'lineEnding' || tailEvent[1].type === 'lineEndingBlank') {\n              if (tailEvent[0] === 'exit') continue;\n\n              if (lineIndex) {\n                events[lineIndex][1].type = 'lineEndingBlank';\n                listSpread = true;\n              }\n\n              tailEvent[1].type = 'lineEnding';\n              lineIndex = tailIndex;\n            } else if (tailEvent[1].type === 'linePrefix' || tailEvent[1].type === 'blockQuotePrefix' || tailEvent[1].type === 'blockQuotePrefixWhitespace' || tailEvent[1].type === 'blockQuoteMarker' || tailEvent[1].type === 'listItemIndent') {// Empty\n            } else {\n              break;\n            }\n          }\n\n          if (firstBlankLineIndex && (!lineIndex || firstBlankLineIndex < lineIndex)) {\n            listItem._spread = true;\n          } // Fix position.\n\n\n          listItem.end = point(lineIndex ? events[lineIndex][1].start : event[1].end);\n          events.splice(lineIndex || index, 0, ['exit', listItem, event[2]]);\n          index++;\n          length++;\n        } // Create a new list item.\n\n\n        if (event[1].type === 'listItemPrefix') {\n          listItem = {\n            type: 'listItem',\n            _spread: false,\n            start: point(event[1].start)\n          };\n          events.splice(index, 0, ['enter', listItem, event[2]]);\n          index++;\n          length++;\n          firstBlankLineIndex = undefined;\n          atMarker = true;\n        }\n      }\n    }\n\n    events[start][1]._spread = listSpread;\n    return length;\n  }\n\n  function setData(key, value) {\n    data[key] = value;\n  }\n\n  function getData(key) {\n    return data[key];\n  }\n\n  function point(d) {\n    return {\n      line: d.line,\n      column: d.column,\n      offset: d.offset\n    };\n  }\n\n  function opener(create, and) {\n    return open;\n\n    function open(token) {\n      enter.call(this, create(token), token);\n      if (and) and.call(this, token);\n    }\n  }\n\n  function buffer() {\n    this.stack.push({\n      type: 'fragment',\n      children: []\n    });\n  }\n\n  function enter(node, token) {\n    this.stack[this.stack.length - 1].children.push(node);\n    this.stack.push(node);\n    this.tokenStack.push(token);\n    node.position = {\n      start: point(token.start)\n    };\n    return node;\n  }\n\n  function closer(and) {\n    return close;\n\n    function close(token) {\n      if (and) and.call(this, token);\n      exit.call(this, token);\n    }\n  }\n\n  function exit(token) {\n    var node = this.stack.pop();\n    var open = this.tokenStack.pop();\n\n    if (!open) {\n      throw new Error('Cannot close `' + token.type + '` (' + stringifyPosition({\n        start: token.start,\n        end: token.end\n      }) + '): it’s not open');\n    } else if (open.type !== token.type) {\n      throw new Error('Cannot close `' + token.type + '` (' + stringifyPosition({\n        start: token.start,\n        end: token.end\n      }) + '): a different token (`' + open.type + '`, ' + stringifyPosition({\n        start: open.start,\n        end: open.end\n      }) + ') is open');\n    }\n\n    node.position.end = point(token.end);\n    return node;\n  }\n\n  function resume() {\n    return toString(this.stack.pop());\n  } //\n  // Handlers.\n  //\n\n\n  function onenterlistordered() {\n    setData('expectingFirstListItemValue', true);\n  }\n\n  function onenterlistitemvalue(token) {\n    if (getData('expectingFirstListItemValue')) {\n      this.stack[this.stack.length - 2].start = parseInt(this.sliceSerialize(token), 10);\n      setData('expectingFirstListItemValue');\n    }\n  }\n\n  function onexitcodefencedfenceinfo() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].lang = data;\n  }\n\n  function onexitcodefencedfencemeta() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].meta = data;\n  }\n\n  function onexitcodefencedfence() {\n    // Exit if this is the closing fence.\n    if (getData('flowCodeInside')) return;\n    this.buffer();\n    setData('flowCodeInside', true);\n  }\n\n  function onexitcodefenced() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].value = data.replace(/^(\\r?\\n|\\r)|(\\r?\\n|\\r)$/g, '');\n    setData('flowCodeInside');\n  }\n\n  function onexitcodeindented() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].value = data;\n  }\n\n  function onexitdefinitionlabelstring(token) {\n    // Discard label, use the source content instead.\n    var label = this.resume();\n    this.stack[this.stack.length - 1].label = label;\n    this.stack[this.stack.length - 1].identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();\n  }\n\n  function onexitdefinitiontitlestring() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].title = data;\n  }\n\n  function onexitdefinitiondestinationstring() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].url = data;\n  }\n\n  function onexitatxheadingsequence(token) {\n    if (!this.stack[this.stack.length - 1].depth) {\n      this.stack[this.stack.length - 1].depth = this.sliceSerialize(token).length;\n    }\n  }\n\n  function onexitsetextheadingtext() {\n    setData('setextHeadingSlurpLineEnding', true);\n  }\n\n  function onexitsetextheadinglinesequence(token) {\n    this.stack[this.stack.length - 1].depth = this.sliceSerialize(token).charCodeAt(0) === 61 ? 1 : 2;\n  }\n\n  function onexitsetextheading() {\n    setData('setextHeadingSlurpLineEnding');\n  }\n\n  function onenterdata(token) {\n    var siblings = this.stack[this.stack.length - 1].children;\n    var tail = siblings[siblings.length - 1];\n\n    if (!tail || tail.type !== 'text') {\n      // Add a new text node.\n      tail = text();\n      tail.position = {\n        start: point(token.start)\n      };\n      this.stack[this.stack.length - 1].children.push(tail);\n    }\n\n    this.stack.push(tail);\n  }\n\n  function onexitdata(token) {\n    var tail = this.stack.pop();\n    tail.value += this.sliceSerialize(token);\n    tail.position.end = point(token.end);\n  }\n\n  function onexitlineending(token) {\n    var context = this.stack[this.stack.length - 1]; // If we’re at a hard break, include the line ending in there.\n\n    if (getData('atHardBreak')) {\n      context.children[context.children.length - 1].position.end = point(token.end);\n      setData('atHardBreak');\n      return;\n    }\n\n    if (!getData('setextHeadingSlurpLineEnding') && config.canContainEols.indexOf(context.type) > -1) {\n      onenterdata.call(this, token);\n      onexitdata.call(this, token);\n    }\n  }\n\n  function onexithardbreak() {\n    setData('atHardBreak', true);\n  }\n\n  function onexithtmlflow() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].value = data;\n  }\n\n  function onexithtmltext() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].value = data;\n  }\n\n  function onexitcodetext() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].value = data;\n  }\n\n  function onexitlink() {\n    var context = this.stack[this.stack.length - 1]; // To do: clean.\n\n    if (getData('inReference')) {\n      context.type += 'Reference';\n      context.referenceType = getData('referenceType') || 'shortcut';\n      delete context.url;\n      delete context.title;\n    } else {\n      delete context.identifier;\n      delete context.label;\n      delete context.referenceType;\n    }\n\n    setData('referenceType');\n  }\n\n  function onexitimage() {\n    var context = this.stack[this.stack.length - 1]; // To do: clean.\n\n    if (getData('inReference')) {\n      context.type += 'Reference';\n      context.referenceType = getData('referenceType') || 'shortcut';\n      delete context.url;\n      delete context.title;\n    } else {\n      delete context.identifier;\n      delete context.label;\n      delete context.referenceType;\n    }\n\n    setData('referenceType');\n  }\n\n  function onexitlabeltext(token) {\n    this.stack[this.stack.length - 2].identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();\n  }\n\n  function onexitlabel() {\n    var fragment = this.stack[this.stack.length - 1];\n    var value = this.resume();\n    this.stack[this.stack.length - 1].label = value; // Assume a reference.\n\n    setData('inReference', true);\n\n    if (this.stack[this.stack.length - 1].type === 'link') {\n      this.stack[this.stack.length - 1].children = fragment.children;\n    } else {\n      this.stack[this.stack.length - 1].alt = value;\n    }\n  }\n\n  function onexitresourcedestinationstring() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].url = data;\n  }\n\n  function onexitresourcetitlestring() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].title = data;\n  }\n\n  function onexitresource() {\n    setData('inReference');\n  }\n\n  function onenterreference() {\n    setData('referenceType', 'collapsed');\n  }\n\n  function onexitreferencestring(token) {\n    var label = this.resume();\n    this.stack[this.stack.length - 1].label = label;\n    this.stack[this.stack.length - 1].identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();\n    setData('referenceType', 'full');\n  }\n\n  function onexitcharacterreferencemarker(token) {\n    setData('characterReferenceType', token.type);\n  }\n\n  function onexitcharacterreferencevalue(token) {\n    var data = this.sliceSerialize(token);\n    var type = getData('characterReferenceType');\n    var value;\n    var tail;\n\n    if (type) {\n      value = safeFromInt(data, type === 'characterReferenceMarkerNumeric' ? 10 : 16);\n      setData('characterReferenceType');\n    } else {\n      value = decode(data);\n    }\n\n    tail = this.stack.pop();\n    tail.value += value;\n    tail.position.end = point(token.end);\n  }\n\n  function onexitautolinkprotocol(token) {\n    onexitdata.call(this, token);\n    this.stack[this.stack.length - 1].url = this.sliceSerialize(token);\n  }\n\n  function onexitautolinkemail(token) {\n    onexitdata.call(this, token);\n    this.stack[this.stack.length - 1].url = 'mailto:' + this.sliceSerialize(token);\n  } //\n  // Creaters.\n  //\n\n\n  function blockQuote() {\n    return {\n      type: 'blockquote',\n      children: []\n    };\n  }\n\n  function codeFlow() {\n    return {\n      type: 'code',\n      lang: null,\n      meta: null,\n      value: ''\n    };\n  }\n\n  function codeText() {\n    return {\n      type: 'inlineCode',\n      value: ''\n    };\n  }\n\n  function definition() {\n    return {\n      type: 'definition',\n      identifier: '',\n      label: null,\n      title: null,\n      url: ''\n    };\n  }\n\n  function emphasis() {\n    return {\n      type: 'emphasis',\n      children: []\n    };\n  }\n\n  function heading() {\n    return {\n      type: 'heading',\n      depth: undefined,\n      children: []\n    };\n  }\n\n  function hardBreak() {\n    return {\n      type: 'break'\n    };\n  }\n\n  function html() {\n    return {\n      type: 'html',\n      value: ''\n    };\n  }\n\n  function image() {\n    return {\n      type: 'image',\n      title: null,\n      url: '',\n      alt: null\n    };\n  }\n\n  function link() {\n    return {\n      type: 'link',\n      title: null,\n      url: '',\n      children: []\n    };\n  }\n\n  function list(token) {\n    return {\n      type: 'list',\n      ordered: token.type === 'listOrdered',\n      start: null,\n      spread: token._spread,\n      children: []\n    };\n  }\n\n  function listItem(token) {\n    return {\n      type: 'listItem',\n      spread: token._spread,\n      checked: null,\n      children: []\n    };\n  }\n\n  function paragraph() {\n    return {\n      type: 'paragraph',\n      children: []\n    };\n  }\n\n  function strong() {\n    return {\n      type: 'strong',\n      children: []\n    };\n  }\n\n  function text() {\n    return {\n      type: 'text',\n      value: ''\n    };\n  }\n\n  function thematicBreak() {\n    return {\n      type: 'thematicBreak'\n    };\n  }\n}\n\nfunction configure(config, extensions) {\n  var index = -1;\n\n  while (++index < extensions.length) {\n    extension(config, extensions[index]);\n  }\n\n  return config;\n}\n\nfunction extension(config, extension) {\n  var key;\n  var left;\n\n  for (key in extension) {\n    left = own.call(config, key) ? config[key] : config[key] = {};\n\n    if (key === 'canContainEols' || key === 'transforms') {\n      config[key] = [].concat(left, extension[key]);\n    } else {\n      Object.assign(left, extension[key]);\n    }\n  }\n}","'use strict';\n\nmodule.exports = require('./dist');","'use strict';\n\nmodule.exports = toString; // Get the text content of a node.\n// Prefer the node’s plain-text fields, otherwise serialize its children,\n// and if the given value is an array, serialize the nodes in it.\n\nfunction toString(node) {\n  return node && (node.value || node.alt || node.title || 'children' in node && all(node.children) || 'length' in node && all(node)) || '';\n}\n\nfunction all(values) {\n  var result = [];\n  var index = -1;\n\n  while (++index < values.length) {\n    result[index] = toString(values[index]);\n  }\n\n  return result.join('');\n}","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\n\nvar asciiAlpha = regexCheck(/[A-Za-z]/);\nmodule.exports = asciiAlpha;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\n\nvar asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/);\nmodule.exports = asciiAlphanumeric;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\n\nvar asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/);\nmodule.exports = asciiAtext;","'use strict'; // Note: EOF is seen as ASCII control here, because `null < 32 == true`.\n\nfunction asciiControl(code) {\n  return (// Special whitespace codes (which have negative values), C0 and Control\n    // character DEL\n    code < 32 || code === 127\n  );\n}\n\nmodule.exports = asciiControl;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\n\nvar asciiDigit = regexCheck(/\\d/);\nmodule.exports = asciiDigit;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\n\nvar asciiHexDigit = regexCheck(/[\\dA-Fa-f]/);\nmodule.exports = asciiHexDigit;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\n\nvar asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);\nmodule.exports = asciiPunctuation;","'use strict';\n\nfunction markdownLineEndingOrSpace(code) {\n  return code < 0 || code === 32;\n}\n\nmodule.exports = markdownLineEndingOrSpace;","'use strict';\n\nfunction markdownLineEnding(code) {\n  return code < -2;\n}\n\nmodule.exports = markdownLineEnding;","'use strict';\n\nfunction markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32;\n}\n\nmodule.exports = markdownSpace;","'use strict';\n\nvar unicodePunctuationRegex = require('../constant/unicode-punctuation-regex.js');\n\nvar regexCheck = require('../util/regex-check.js'); // In fact adds to the bundle size.\n\n\nvar unicodePunctuation = regexCheck(unicodePunctuationRegex);\nmodule.exports = unicodePunctuation;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\n\nvar unicodeWhitespace = regexCheck(/\\s/);\nmodule.exports = unicodeWhitespace;","'use strict';\n\nvar assign = Object.assign;\nmodule.exports = assign;","'use strict';\n\nvar fromCharCode = String.fromCharCode;\nmodule.exports = fromCharCode;","'use strict';\n\nvar own = {}.hasOwnProperty;\nmodule.exports = own;","'use strict'; // This module is copied from <https://spec.commonmark.org/0.29/#html-blocks>.\n\nvar basics = ['address', 'article', 'aside', 'base', 'basefont', 'blockquote', 'body', 'caption', 'center', 'col', 'colgroup', 'dd', 'details', 'dialog', 'dir', 'div', 'dl', 'dt', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'frame', 'frameset', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hr', 'html', 'iframe', 'legend', 'li', 'link', 'main', 'menu', 'menuitem', 'nav', 'noframes', 'ol', 'optgroup', 'option', 'p', 'param', 'section', 'source', 'summary', 'table', 'tbody', 'td', 'tfoot', 'th', 'thead', 'title', 'tr', 'track', 'ul'];\nmodule.exports = basics;","'use strict'; // This module is copied from <https://spec.commonmark.org/0.29/#html-blocks>.\n\nvar raws = ['pre', 'script', 'style', 'textarea'];\nmodule.exports = raws;","'use strict';\n\nvar splice = [].splice;\nmodule.exports = splice;","'use strict'; // This module is generated by `script/`.\n//\n// CommonMark handles attention (emphasis, strong) markers based on what comes\n// before or after them.\n// One such difference is if those characters are Unicode punctuation.\n// This script is generated from the Unicode data.\n\nvar unicodePunctuation = /[!-\\/:-@\\[-`\\{-~\\xA1\\xA7\\xAB\\xB6\\xB7\\xBB\\xBF\\u037E\\u0387\\u055A-\\u055F\\u0589\\u058A\\u05BE\\u05C0\\u05C3\\u05C6\\u05F3\\u05F4\\u0609\\u060A\\u060C\\u060D\\u061B\\u061E\\u061F\\u066A-\\u066D\\u06D4\\u0700-\\u070D\\u07F7-\\u07F9\\u0830-\\u083E\\u085E\\u0964\\u0965\\u0970\\u09FD\\u0A76\\u0AF0\\u0C77\\u0C84\\u0DF4\\u0E4F\\u0E5A\\u0E5B\\u0F04-\\u0F12\\u0F14\\u0F3A-\\u0F3D\\u0F85\\u0FD0-\\u0FD4\\u0FD9\\u0FDA\\u104A-\\u104F\\u10FB\\u1360-\\u1368\\u1400\\u166E\\u169B\\u169C\\u16EB-\\u16ED\\u1735\\u1736\\u17D4-\\u17D6\\u17D8-\\u17DA\\u1800-\\u180A\\u1944\\u1945\\u1A1E\\u1A1F\\u1AA0-\\u1AA6\\u1AA8-\\u1AAD\\u1B5A-\\u1B60\\u1BFC-\\u1BFF\\u1C3B-\\u1C3F\\u1C7E\\u1C7F\\u1CC0-\\u1CC7\\u1CD3\\u2010-\\u2027\\u2030-\\u2043\\u2045-\\u2051\\u2053-\\u205E\\u207D\\u207E\\u208D\\u208E\\u2308-\\u230B\\u2329\\u232A\\u2768-\\u2775\\u27C5\\u27C6\\u27E6-\\u27EF\\u2983-\\u2998\\u29D8-\\u29DB\\u29FC\\u29FD\\u2CF9-\\u2CFC\\u2CFE\\u2CFF\\u2D70\\u2E00-\\u2E2E\\u2E30-\\u2E4F\\u2E52\\u3001-\\u3003\\u3008-\\u3011\\u3014-\\u301F\\u3030\\u303D\\u30A0\\u30FB\\uA4FE\\uA4FF\\uA60D-\\uA60F\\uA673\\uA67E\\uA6F2-\\uA6F7\\uA874-\\uA877\\uA8CE\\uA8CF\\uA8F8-\\uA8FA\\uA8FC\\uA92E\\uA92F\\uA95F\\uA9C1-\\uA9CD\\uA9DE\\uA9DF\\uAA5C-\\uAA5F\\uAADE\\uAADF\\uAAF0\\uAAF1\\uABEB\\uFD3E\\uFD3F\\uFE10-\\uFE19\\uFE30-\\uFE52\\uFE54-\\uFE61\\uFE63\\uFE68\\uFE6A\\uFE6B\\uFF01-\\uFF03\\uFF05-\\uFF0A\\uFF0C-\\uFF0F\\uFF1A\\uFF1B\\uFF1F\\uFF20\\uFF3B-\\uFF3D\\uFF3F\\uFF5B\\uFF5D\\uFF5F-\\uFF65]/;\nmodule.exports = unicodePunctuation;","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nvar text$1 = require('./initialize/text.js');\n\nvar attention = require('./tokenize/attention.js');\n\nvar autolink = require('./tokenize/autolink.js');\n\nvar blockQuote = require('./tokenize/block-quote.js');\n\nvar characterEscape = require('./tokenize/character-escape.js');\n\nvar characterReference = require('./tokenize/character-reference.js');\n\nvar codeFenced = require('./tokenize/code-fenced.js');\n\nvar codeIndented = require('./tokenize/code-indented.js');\n\nvar codeText = require('./tokenize/code-text.js');\n\nvar definition = require('./tokenize/definition.js');\n\nvar hardBreakEscape = require('./tokenize/hard-break-escape.js');\n\nvar headingAtx = require('./tokenize/heading-atx.js');\n\nvar htmlFlow = require('./tokenize/html-flow.js');\n\nvar htmlText = require('./tokenize/html-text.js');\n\nvar labelEnd = require('./tokenize/label-end.js');\n\nvar labelStartImage = require('./tokenize/label-start-image.js');\n\nvar labelStartLink = require('./tokenize/label-start-link.js');\n\nvar lineEnding = require('./tokenize/line-ending.js');\n\nvar list = require('./tokenize/list.js');\n\nvar setextUnderline = require('./tokenize/setext-underline.js');\n\nvar thematicBreak = require('./tokenize/thematic-break.js');\n\nvar document = {\n  42: list,\n  // Asterisk\n  43: list,\n  // Plus sign\n  45: list,\n  // Dash\n  48: list,\n  // 0\n  49: list,\n  // 1\n  50: list,\n  // 2\n  51: list,\n  // 3\n  52: list,\n  // 4\n  53: list,\n  // 5\n  54: list,\n  // 6\n  55: list,\n  // 7\n  56: list,\n  // 8\n  57: list,\n  // 9\n  62: blockQuote // Greater than\n\n};\nvar contentInitial = {\n  91: definition // Left square bracket\n\n};\nvar flowInitial = {\n  '-2': codeIndented,\n  // Horizontal tab\n  '-1': codeIndented,\n  // Virtual space\n  32: codeIndented // Space\n\n};\nvar flow = {\n  35: headingAtx,\n  // Number sign\n  42: thematicBreak,\n  // Asterisk\n  45: [setextUnderline, thematicBreak],\n  // Dash\n  60: htmlFlow,\n  // Less than\n  61: setextUnderline,\n  // Equals to\n  95: thematicBreak,\n  // Underscore\n  96: codeFenced,\n  // Grave accent\n  126: codeFenced // Tilde\n\n};\nvar string = {\n  38: characterReference,\n  // Ampersand\n  92: characterEscape // Backslash\n\n};\nvar text = {\n  '-5': lineEnding,\n  // Carriage return\n  '-4': lineEnding,\n  // Line feed\n  '-3': lineEnding,\n  // Carriage return + line feed\n  33: labelStartImage,\n  // Exclamation mark\n  38: characterReference,\n  // Ampersand\n  42: attention,\n  // Asterisk\n  60: [autolink, htmlText],\n  // Less than\n  91: labelStartLink,\n  // Left square bracket\n  92: [hardBreakEscape, characterEscape],\n  // Backslash\n  93: labelEnd,\n  // Right square bracket\n  95: attention,\n  // Underscore\n  96: codeText // Grave accent\n\n};\nvar insideSpan = {\n  null: [attention, text$1.resolver]\n};\nvar disable = {\n  null: []\n};\nexports.contentInitial = contentInitial;\nexports.disable = disable;\nexports.document = document;\nexports.flow = flow;\nexports.flowInitial = flowInitial;\nexports.insideSpan = insideSpan;\nexports.string = string;\nexports.text = text;","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar factorySpace = require('../tokenize/factory-space.js');\n\nvar tokenize = initializeContent;\n\nfunction initializeContent(effects) {\n  var contentStart = effects.attempt(this.parser.constructs.contentInitial, afterContentStartConstruct, paragraphInitial);\n  var previous;\n  return contentStart;\n\n  function afterContentStartConstruct(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    return factorySpace(effects, contentStart, 'linePrefix');\n  }\n\n  function paragraphInitial(code) {\n    effects.enter('paragraph');\n    return lineStart(code);\n  }\n\n  function lineStart(code) {\n    var token = effects.enter('chunkText', {\n      contentType: 'text',\n      previous: previous\n    });\n\n    if (previous) {\n      previous.next = token;\n    }\n\n    previous = token;\n    return data(code);\n  }\n\n  function data(code) {\n    if (code === null) {\n      effects.exit('chunkText');\n      effects.exit('paragraph');\n      effects.consume(code);\n      return;\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.consume(code);\n      effects.exit('chunkText');\n      return lineStart;\n    } // Data.\n\n\n    effects.consume(code);\n    return data;\n  }\n}\n\nexports.tokenize = tokenize;","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar factorySpace = require('../tokenize/factory-space.js');\n\nvar partialBlankLine = require('../tokenize/partial-blank-line.js');\n\nvar tokenize = initializeDocument;\nvar containerConstruct = {\n  tokenize: tokenizeContainer\n};\nvar lazyFlowConstruct = {\n  tokenize: tokenizeLazyFlow\n};\n\nfunction initializeDocument(effects) {\n  var self = this;\n  var stack = [];\n  var continued = 0;\n  var inspectConstruct = {\n    tokenize: tokenizeInspect,\n    partial: true\n  };\n  var inspectResult;\n  var childFlow;\n  var childToken;\n  return start;\n\n  function start(code) {\n    if (continued < stack.length) {\n      self.containerState = stack[continued][1];\n      return effects.attempt(stack[continued][0].continuation, documentContinue, documentContinued)(code);\n    }\n\n    return documentContinued(code);\n  }\n\n  function documentContinue(code) {\n    continued++;\n    return start(code);\n  }\n\n  function documentContinued(code) {\n    // If we’re in a concrete construct (such as when expecting another line of\n    // HTML, or we resulted in lazy content), we can immediately start flow.\n    if (inspectResult && inspectResult.flowContinue) {\n      return flowStart(code);\n    }\n\n    self.interrupt = childFlow && childFlow.currentConstruct && childFlow.currentConstruct.interruptible;\n    self.containerState = {};\n    return effects.attempt(containerConstruct, containerContinue, flowStart)(code);\n  }\n\n  function containerContinue(code) {\n    stack.push([self.currentConstruct, self.containerState]);\n    self.containerState = undefined;\n    return documentContinued(code);\n  }\n\n  function flowStart(code) {\n    if (code === null) {\n      exitContainers(0, true);\n      effects.consume(code);\n      return;\n    }\n\n    childFlow = childFlow || self.parser.flow(self.now());\n    effects.enter('chunkFlow', {\n      contentType: 'flow',\n      previous: childToken,\n      _tokenizer: childFlow\n    });\n    return flowContinue(code);\n  }\n\n  function flowContinue(code) {\n    if (code === null) {\n      continueFlow(effects.exit('chunkFlow'));\n      return flowStart(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.consume(code);\n      continueFlow(effects.exit('chunkFlow'));\n      return effects.check(inspectConstruct, documentAfterPeek);\n    }\n\n    effects.consume(code);\n    return flowContinue;\n  }\n\n  function documentAfterPeek(code) {\n    exitContainers(inspectResult.continued, inspectResult && inspectResult.flowEnd);\n    continued = 0;\n    return start(code);\n  }\n\n  function continueFlow(token) {\n    if (childToken) childToken.next = token;\n    childToken = token;\n    childFlow.lazy = inspectResult && inspectResult.lazy;\n    childFlow.defineSkip(token.start);\n    childFlow.write(self.sliceStream(token));\n  }\n\n  function exitContainers(size, end) {\n    var index = stack.length; // Close the flow.\n\n    if (childFlow && end) {\n      childFlow.write([null]);\n      childToken = childFlow = undefined;\n    } // Exit open containers.\n\n\n    while (index-- > size) {\n      self.containerState = stack[index][1];\n      stack[index][0].exit.call(self, effects);\n    }\n\n    stack.length = size;\n  }\n\n  function tokenizeInspect(effects, ok) {\n    var subcontinued = 0;\n    inspectResult = {};\n    return inspectStart;\n\n    function inspectStart(code) {\n      if (subcontinued < stack.length) {\n        self.containerState = stack[subcontinued][1];\n        return effects.attempt(stack[subcontinued][0].continuation, inspectContinue, inspectLess)(code);\n      } // If we’re continued but in a concrete flow, we can’t have more\n      // containers.\n\n\n      if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {\n        inspectResult.flowContinue = true;\n        return inspectDone(code);\n      }\n\n      self.interrupt = childFlow.currentConstruct && childFlow.currentConstruct.interruptible;\n      self.containerState = {};\n      return effects.attempt(containerConstruct, inspectFlowEnd, inspectDone)(code);\n    }\n\n    function inspectContinue(code) {\n      subcontinued++;\n      return self.containerState._closeFlow ? inspectFlowEnd(code) : inspectStart(code);\n    }\n\n    function inspectLess(code) {\n      if (childFlow.currentConstruct && childFlow.currentConstruct.lazy) {\n        // Maybe another container?\n        self.containerState = {};\n        return effects.attempt(containerConstruct, inspectFlowEnd, // Maybe flow, or a blank line?\n        effects.attempt(lazyFlowConstruct, inspectFlowEnd, effects.check(partialBlankLine, inspectFlowEnd, inspectLazy)))(code);\n      } // Otherwise we’re interrupting.\n\n\n      return inspectFlowEnd(code);\n    }\n\n    function inspectLazy(code) {\n      // Act as if all containers are continued.\n      subcontinued = stack.length;\n      inspectResult.lazy = true;\n      inspectResult.flowContinue = true;\n      return inspectDone(code);\n    } // We’re done with flow if we have more containers, or an interruption.\n\n\n    function inspectFlowEnd(code) {\n      inspectResult.flowEnd = true;\n      return inspectDone(code);\n    }\n\n    function inspectDone(code) {\n      inspectResult.continued = subcontinued;\n      self.interrupt = self.containerState = undefined;\n      return ok(code);\n    }\n  }\n}\n\nfunction tokenizeContainer(effects, ok, nok) {\n  return factorySpace(effects, effects.attempt(this.parser.constructs.document, ok, nok), 'linePrefix', this.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4);\n}\n\nfunction tokenizeLazyFlow(effects, ok, nok) {\n  return factorySpace(effects, effects.lazy(this.parser.constructs.flow, ok, nok), 'linePrefix', this.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4);\n}\n\nexports.tokenize = tokenize;","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nvar content = require('../tokenize/content.js');\n\nvar factorySpace = require('../tokenize/factory-space.js');\n\nvar partialBlankLine = require('../tokenize/partial-blank-line.js');\n\nvar tokenize = initializeFlow;\n\nfunction initializeFlow(effects) {\n  var self = this;\n  var initial = effects.attempt( // Try to parse a blank line.\n  partialBlankLine, atBlankEnding, // Try to parse initial flow (essentially, only code).\n  effects.attempt(this.parser.constructs.flowInitial, afterConstruct, factorySpace(effects, effects.attempt(this.parser.constructs.flow, afterConstruct, effects.attempt(content, afterConstruct)), 'linePrefix')));\n  return initial;\n\n  function atBlankEnding(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n\n    effects.enter('lineEndingBlank');\n    effects.consume(code);\n    effects.exit('lineEndingBlank');\n    self.currentConstruct = undefined;\n    return initial;\n  }\n\n  function afterConstruct(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    self.currentConstruct = undefined;\n    return initial;\n  }\n}\n\nexports.tokenize = tokenize;","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nvar assign = require('../constant/assign.js');\n\nvar shallow = require('../util/shallow.js');\n\nvar text = initializeFactory('text');\nvar string = initializeFactory('string');\nvar resolver = {\n  resolveAll: createResolver()\n};\n\nfunction initializeFactory(field) {\n  return {\n    tokenize: initializeText,\n    resolveAll: createResolver(field === 'text' ? resolveAllLineSuffixes : undefined)\n  };\n\n  function initializeText(effects) {\n    var self = this;\n    var constructs = this.parser.constructs[field];\n    var text = effects.attempt(constructs, start, notText);\n    return start;\n\n    function start(code) {\n      return atBreak(code) ? text(code) : notText(code);\n    }\n\n    function notText(code) {\n      if (code === null) {\n        effects.consume(code);\n        return;\n      }\n\n      effects.enter('data');\n      effects.consume(code);\n      return data;\n    }\n\n    function data(code) {\n      if (atBreak(code)) {\n        effects.exit('data');\n        return text(code);\n      } // Data.\n\n\n      effects.consume(code);\n      return data;\n    }\n\n    function atBreak(code) {\n      var list = constructs[code];\n      var index = -1;\n\n      if (code === null) {\n        return true;\n      }\n\n      if (list) {\n        while (++index < list.length) {\n          if (!list[index].previous || list[index].previous.call(self, self.previous)) {\n            return true;\n          }\n        }\n      }\n    }\n  }\n}\n\nfunction createResolver(extraResolver) {\n  return resolveAllText;\n\n  function resolveAllText(events, context) {\n    var index = -1;\n    var enter; // A rather boring computation (to merge adjacent `data` events) which\n    // improves mm performance by 29%.\n\n    while (++index <= events.length) {\n      if (enter === undefined) {\n        if (events[index] && events[index][1].type === 'data') {\n          enter = index;\n          index++;\n        }\n      } else if (!events[index] || events[index][1].type !== 'data') {\n        // Don’t do anything if there is one data token.\n        if (index !== enter + 2) {\n          events[enter][1].end = events[index - 1][1].end;\n          events.splice(enter + 2, index - enter - 2);\n          index = enter + 2;\n        }\n\n        enter = undefined;\n      }\n    }\n\n    return extraResolver ? extraResolver(events, context) : events;\n  }\n} // A rather ugly set of instructions which again looks at chunks in the input\n// stream.\n// The reason to do this here is that it is *much* faster to parse in reverse.\n// And that we can’t hook into `null` to split the line suffix before an EOF.\n// To do: figure out if we can make this into a clean utility, or even in core.\n// As it will be useful for GFMs literal autolink extension (and maybe even\n// tables?)\n\n\nfunction resolveAllLineSuffixes(events, context) {\n  var eventIndex = -1;\n  var chunks;\n  var data;\n  var chunk;\n  var index;\n  var bufferIndex;\n  var size;\n  var tabs;\n  var token;\n\n  while (++eventIndex <= events.length) {\n    if ((eventIndex === events.length || events[eventIndex][1].type === 'lineEnding') && events[eventIndex - 1][1].type === 'data') {\n      data = events[eventIndex - 1][1];\n      chunks = context.sliceStream(data);\n      index = chunks.length;\n      bufferIndex = -1;\n      size = 0;\n      tabs = undefined;\n\n      while (index--) {\n        chunk = chunks[index];\n\n        if (typeof chunk === 'string') {\n          bufferIndex = chunk.length;\n\n          while (chunk.charCodeAt(bufferIndex - 1) === 32) {\n            size++;\n            bufferIndex--;\n          }\n\n          if (bufferIndex) break;\n          bufferIndex = -1;\n        } // Number\n        else if (chunk === -2) {\n          tabs = true;\n          size++;\n        } else if (chunk === -1) ;else {\n          // Replacement character, exit.\n          index++;\n          break;\n        }\n      }\n\n      if (size) {\n        token = {\n          type: eventIndex === events.length || tabs || size < 2 ? 'lineSuffix' : 'hardBreakTrailing',\n          start: {\n            line: data.end.line,\n            column: data.end.column - size,\n            offset: data.end.offset - size,\n            _index: data.start._index + index,\n            _bufferIndex: index ? bufferIndex : data.start._bufferIndex + bufferIndex\n          },\n          end: shallow(data.end)\n        };\n        data.end = shallow(token.start);\n\n        if (data.start.offset === data.end.offset) {\n          assign(data, token);\n        } else {\n          events.splice(eventIndex, 0, ['enter', token, context], ['exit', token, context]);\n          eventIndex += 2;\n        }\n      }\n\n      eventIndex++;\n    }\n  }\n\n  return events;\n}\n\nexports.resolver = resolver;\nexports.string = string;\nexports.text = text;","'use strict';\n\nvar content = require('./initialize/content.js');\n\nvar document = require('./initialize/document.js');\n\nvar flow = require('./initialize/flow.js');\n\nvar text = require('./initialize/text.js');\n\nvar combineExtensions = require('./util/combine-extensions.js');\n\nvar createTokenizer = require('./util/create-tokenizer.js');\n\nvar miniflat = require('./util/miniflat.js');\n\nvar constructs = require('./constructs.js');\n\nfunction parse(options) {\n  var settings = options || {};\n  var parser = {\n    defined: [],\n    constructs: combineExtensions([constructs].concat(miniflat(settings.extensions))),\n    content: create(content),\n    document: create(document),\n    flow: create(flow),\n    string: create(text.string),\n    text: create(text.text)\n  };\n  return parser;\n\n  function create(initializer) {\n    return creator;\n\n    function creator(from) {\n      return createTokenizer(parser, initializer, from);\n    }\n  }\n}\n\nmodule.exports = parse;","'use strict';\n\nvar subtokenize = require('./util/subtokenize.js');\n\nfunction postprocess(events) {\n  while (!subtokenize(events)) {// Empty\n  }\n\n  return events;\n}\n\nmodule.exports = postprocess;","'use strict';\n\nvar search = /[\\0\\t\\n\\r]/g;\n\nfunction preprocess() {\n  var start = true;\n  var column = 1;\n  var buffer = '';\n  var atCarriageReturn;\n  return preprocessor;\n\n  function preprocessor(value, encoding, end) {\n    var chunks = [];\n    var match;\n    var next;\n    var startPosition;\n    var endPosition;\n    var code;\n    value = buffer + value.toString(encoding);\n    startPosition = 0;\n    buffer = '';\n\n    if (start) {\n      if (value.charCodeAt(0) === 65279) {\n        startPosition++;\n      }\n\n      start = undefined;\n    }\n\n    while (startPosition < value.length) {\n      search.lastIndex = startPosition;\n      match = search.exec(value);\n      endPosition = match ? match.index : value.length;\n      code = value.charCodeAt(endPosition);\n\n      if (!match) {\n        buffer = value.slice(startPosition);\n        break;\n      }\n\n      if (code === 10 && startPosition === endPosition && atCarriageReturn) {\n        chunks.push(-3);\n        atCarriageReturn = undefined;\n      } else {\n        if (atCarriageReturn) {\n          chunks.push(-5);\n          atCarriageReturn = undefined;\n        }\n\n        if (startPosition < endPosition) {\n          chunks.push(value.slice(startPosition, endPosition));\n          column += endPosition - startPosition;\n        }\n\n        if (code === 0) {\n          chunks.push(65533);\n          column++;\n        } else if (code === 9) {\n          next = Math.ceil(column / 4) * 4;\n          chunks.push(-2);\n\n          while (column++ < next) {\n            chunks.push(-1);\n          }\n        } else if (code === 10) {\n          chunks.push(-4);\n          column = 1;\n        } // Must be carriage return.\n        else {\n          atCarriageReturn = true;\n          column = 1;\n        }\n      }\n\n      startPosition = endPosition + 1;\n    }\n\n    if (end) {\n      if (atCarriageReturn) chunks.push(-5);\n      if (buffer) chunks.push(buffer);\n      chunks.push(null);\n    }\n\n    return chunks;\n  }\n}\n\nmodule.exports = preprocess;","'use strict';\n\nvar chunkedPush = require('../util/chunked-push.js');\n\nvar chunkedSplice = require('../util/chunked-splice.js');\n\nvar classifyCharacter = require('../util/classify-character.js');\n\nvar movePoint = require('../util/move-point.js');\n\nvar resolveAll = require('../util/resolve-all.js');\n\nvar shallow = require('../util/shallow.js');\n\nvar attention = {\n  name: 'attention',\n  tokenize: tokenizeAttention,\n  resolveAll: resolveAllAttention\n};\n\nfunction resolveAllAttention(events, context) {\n  var index = -1;\n  var open;\n  var group;\n  var text;\n  var openingSequence;\n  var closingSequence;\n  var use;\n  var nextEvents;\n  var offset; // Walk through all events.\n  //\n  // Note: performance of this is fine on an mb of normal markdown, but it’s\n  // a bottleneck for malicious stuff.\n\n  while (++index < events.length) {\n    // Find a token that can close.\n    if (events[index][0] === 'enter' && events[index][1].type === 'attentionSequence' && events[index][1]._close) {\n      open = index; // Now walk back to find an opener.\n\n      while (open--) {\n        // Find a token that can open the closer.\n        if (events[open][0] === 'exit' && events[open][1].type === 'attentionSequence' && events[open][1]._open && // If the markers are the same:\n        context.sliceSerialize(events[open][1]).charCodeAt(0) === context.sliceSerialize(events[index][1]).charCodeAt(0)) {\n          // If the opening can close or the closing can open,\n          // and the close size *is not* a multiple of three,\n          // but the sum of the opening and closing size *is* multiple of three,\n          // then don’t match.\n          if ((events[open][1]._close || events[index][1]._open) && (events[index][1].end.offset - events[index][1].start.offset) % 3 && !((events[open][1].end.offset - events[open][1].start.offset + events[index][1].end.offset - events[index][1].start.offset) % 3)) {\n            continue;\n          } // Number of markers to use from the sequence.\n\n\n          use = events[open][1].end.offset - events[open][1].start.offset > 1 && events[index][1].end.offset - events[index][1].start.offset > 1 ? 2 : 1;\n          openingSequence = {\n            type: use > 1 ? 'strongSequence' : 'emphasisSequence',\n            start: movePoint(shallow(events[open][1].end), -use),\n            end: shallow(events[open][1].end)\n          };\n          closingSequence = {\n            type: use > 1 ? 'strongSequence' : 'emphasisSequence',\n            start: shallow(events[index][1].start),\n            end: movePoint(shallow(events[index][1].start), use)\n          };\n          text = {\n            type: use > 1 ? 'strongText' : 'emphasisText',\n            start: shallow(events[open][1].end),\n            end: shallow(events[index][1].start)\n          };\n          group = {\n            type: use > 1 ? 'strong' : 'emphasis',\n            start: shallow(openingSequence.start),\n            end: shallow(closingSequence.end)\n          };\n          events[open][1].end = shallow(openingSequence.start);\n          events[index][1].start = shallow(closingSequence.end);\n          nextEvents = []; // If there are more markers in the opening, add them before.\n\n          if (events[open][1].end.offset - events[open][1].start.offset) {\n            nextEvents = chunkedPush(nextEvents, [['enter', events[open][1], context], ['exit', events[open][1], context]]);\n          } // Opening.\n\n\n          nextEvents = chunkedPush(nextEvents, [['enter', group, context], ['enter', openingSequence, context], ['exit', openingSequence, context], ['enter', text, context]]); // Between.\n\n          nextEvents = chunkedPush(nextEvents, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + 1, index), context)); // Closing.\n\n          nextEvents = chunkedPush(nextEvents, [['exit', text, context], ['enter', closingSequence, context], ['exit', closingSequence, context], ['exit', group, context]]); // If there are more markers in the closing, add them after.\n\n          if (events[index][1].end.offset - events[index][1].start.offset) {\n            offset = 2;\n            nextEvents = chunkedPush(nextEvents, [['enter', events[index][1], context], ['exit', events[index][1], context]]);\n          } else {\n            offset = 0;\n          }\n\n          chunkedSplice(events, open - 1, index - open + 3, nextEvents);\n          index = open + nextEvents.length - offset - 2;\n          break;\n        }\n      }\n    }\n  } // Remove remaining sequences.\n\n\n  index = -1;\n\n  while (++index < events.length) {\n    if (events[index][1].type === 'attentionSequence') {\n      events[index][1].type = 'data';\n    }\n  }\n\n  return events;\n}\n\nfunction tokenizeAttention(effects, ok) {\n  var before = classifyCharacter(this.previous);\n  var marker;\n  return start;\n\n  function start(code) {\n    effects.enter('attentionSequence');\n    marker = code;\n    return sequence(code);\n  }\n\n  function sequence(code) {\n    var token;\n    var after;\n    var open;\n    var close;\n\n    if (code === marker) {\n      effects.consume(code);\n      return sequence;\n    }\n\n    token = effects.exit('attentionSequence');\n    after = classifyCharacter(code);\n    open = !after || after === 2 && before;\n    close = !before || before === 2 && after;\n    token._open = marker === 42 ? open : open && (before || !close);\n    token._close = marker === 42 ? close : close && (after || !open);\n    return ok(code);\n  }\n}\n\nmodule.exports = attention;","'use strict';\n\nvar asciiAlpha = require('../character/ascii-alpha.js');\n\nvar asciiAlphanumeric = require('../character/ascii-alphanumeric.js');\n\nvar asciiAtext = require('../character/ascii-atext.js');\n\nvar asciiControl = require('../character/ascii-control.js');\n\nvar autolink = {\n  name: 'autolink',\n  tokenize: tokenizeAutolink\n};\n\nfunction tokenizeAutolink(effects, ok, nok) {\n  var size = 1;\n  return start;\n\n  function start(code) {\n    effects.enter('autolink');\n    effects.enter('autolinkMarker');\n    effects.consume(code);\n    effects.exit('autolinkMarker');\n    effects.enter('autolinkProtocol');\n    return open;\n  }\n\n  function open(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return schemeOrEmailAtext;\n    }\n\n    return asciiAtext(code) ? emailAtext(code) : nok(code);\n  }\n\n  function schemeOrEmailAtext(code) {\n    return code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code) ? schemeInsideOrEmailAtext(code) : emailAtext(code);\n  }\n\n  function schemeInsideOrEmailAtext(code) {\n    if (code === 58) {\n      effects.consume(code);\n      return urlInside;\n    }\n\n    if ((code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) && size++ < 32) {\n      effects.consume(code);\n      return schemeInsideOrEmailAtext;\n    }\n\n    return emailAtext(code);\n  }\n\n  function urlInside(code) {\n    if (code === 62) {\n      effects.exit('autolinkProtocol');\n      return end(code);\n    }\n\n    if (code === 32 || code === 60 || asciiControl(code)) {\n      return nok(code);\n    }\n\n    effects.consume(code);\n    return urlInside;\n  }\n\n  function emailAtext(code) {\n    if (code === 64) {\n      effects.consume(code);\n      size = 0;\n      return emailAtSignOrDot;\n    }\n\n    if (asciiAtext(code)) {\n      effects.consume(code);\n      return emailAtext;\n    }\n\n    return nok(code);\n  }\n\n  function emailAtSignOrDot(code) {\n    return asciiAlphanumeric(code) ? emailLabel(code) : nok(code);\n  }\n\n  function emailLabel(code) {\n    if (code === 46) {\n      effects.consume(code);\n      size = 0;\n      return emailAtSignOrDot;\n    }\n\n    if (code === 62) {\n      // Exit, then change the type.\n      effects.exit('autolinkProtocol').type = 'autolinkEmail';\n      return end(code);\n    }\n\n    return emailValue(code);\n  }\n\n  function emailValue(code) {\n    if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) {\n      effects.consume(code);\n      return code === 45 ? emailValue : emailLabel;\n    }\n\n    return nok(code);\n  }\n\n  function end(code) {\n    effects.enter('autolinkMarker');\n    effects.consume(code);\n    effects.exit('autolinkMarker');\n    effects.exit('autolink');\n    return ok;\n  }\n}\n\nmodule.exports = autolink;","'use strict';\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar blockQuote = {\n  name: 'blockQuote',\n  tokenize: tokenizeBlockQuoteStart,\n  continuation: {\n    tokenize: tokenizeBlockQuoteContinuation\n  },\n  exit: exit\n};\n\nfunction tokenizeBlockQuoteStart(effects, ok, nok) {\n  var self = this;\n  return start;\n\n  function start(code) {\n    if (code === 62) {\n      if (!self.containerState.open) {\n        effects.enter('blockQuote', {\n          _container: true\n        });\n        self.containerState.open = true;\n      }\n\n      effects.enter('blockQuotePrefix');\n      effects.enter('blockQuoteMarker');\n      effects.consume(code);\n      effects.exit('blockQuoteMarker');\n      return after;\n    }\n\n    return nok(code);\n  }\n\n  function after(code) {\n    if (markdownSpace(code)) {\n      effects.enter('blockQuotePrefixWhitespace');\n      effects.consume(code);\n      effects.exit('blockQuotePrefixWhitespace');\n      effects.exit('blockQuotePrefix');\n      return ok;\n    }\n\n    effects.exit('blockQuotePrefix');\n    return ok(code);\n  }\n}\n\nfunction tokenizeBlockQuoteContinuation(effects, ok, nok) {\n  return factorySpace(effects, effects.attempt(blockQuote, ok, nok), 'linePrefix', this.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4);\n}\n\nfunction exit(effects) {\n  effects.exit('blockQuote');\n}\n\nmodule.exports = blockQuote;","'use strict';\n\nvar asciiPunctuation = require('../character/ascii-punctuation.js');\n\nvar characterEscape = {\n  name: 'characterEscape',\n  tokenize: tokenizeCharacterEscape\n};\n\nfunction tokenizeCharacterEscape(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    effects.enter('characterEscape');\n    effects.enter('escapeMarker');\n    effects.consume(code);\n    effects.exit('escapeMarker');\n    return open;\n  }\n\n  function open(code) {\n    if (asciiPunctuation(code)) {\n      effects.enter('characterEscapeValue');\n      effects.consume(code);\n      effects.exit('characterEscapeValue');\n      effects.exit('characterEscape');\n      return ok;\n    }\n\n    return nok(code);\n  }\n}\n\nmodule.exports = characterEscape;","'use strict';\n\nvar decodeEntity = require('parse-entities/decode-entity.js');\n\nvar asciiAlphanumeric = require('../character/ascii-alphanumeric.js');\n\nvar asciiDigit = require('../character/ascii-digit.js');\n\nvar asciiHexDigit = require('../character/ascii-hex-digit.js');\n\nfunction _interopDefaultLegacy(e) {\n  return e && typeof e === 'object' && 'default' in e ? e : {\n    default: e\n  };\n}\n\nvar decodeEntity__default = /*#__PURE__*/_interopDefaultLegacy(decodeEntity);\n\nvar characterReference = {\n  name: 'characterReference',\n  tokenize: tokenizeCharacterReference\n};\n\nfunction tokenizeCharacterReference(effects, ok, nok) {\n  var self = this;\n  var size = 0;\n  var max;\n  var test;\n  return start;\n\n  function start(code) {\n    effects.enter('characterReference');\n    effects.enter('characterReferenceMarker');\n    effects.consume(code);\n    effects.exit('characterReferenceMarker');\n    return open;\n  }\n\n  function open(code) {\n    if (code === 35) {\n      effects.enter('characterReferenceMarkerNumeric');\n      effects.consume(code);\n      effects.exit('characterReferenceMarkerNumeric');\n      return numeric;\n    }\n\n    effects.enter('characterReferenceValue');\n    max = 31;\n    test = asciiAlphanumeric;\n    return value(code);\n  }\n\n  function numeric(code) {\n    if (code === 88 || code === 120) {\n      effects.enter('characterReferenceMarkerHexadecimal');\n      effects.consume(code);\n      effects.exit('characterReferenceMarkerHexadecimal');\n      effects.enter('characterReferenceValue');\n      max = 6;\n      test = asciiHexDigit;\n      return value;\n    }\n\n    effects.enter('characterReferenceValue');\n    max = 7;\n    test = asciiDigit;\n    return value(code);\n  }\n\n  function value(code) {\n    var token;\n\n    if (code === 59 && size) {\n      token = effects.exit('characterReferenceValue');\n\n      if (test === asciiAlphanumeric && !decodeEntity__default['default'](self.sliceSerialize(token))) {\n        return nok(code);\n      }\n\n      effects.enter('characterReferenceMarker');\n      effects.consume(code);\n      effects.exit('characterReferenceMarker');\n      effects.exit('characterReference');\n      return ok;\n    }\n\n    if (test(code) && size++ < max) {\n      effects.consume(code);\n      return value;\n    }\n\n    return nok(code);\n  }\n}\n\nmodule.exports = characterReference;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\n\nvar prefixSize = require('../util/prefix-size.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar codeFenced = {\n  name: 'codeFenced',\n  tokenize: tokenizeCodeFenced,\n  concrete: true\n};\n\nfunction tokenizeCodeFenced(effects, ok, nok) {\n  var self = this;\n  var closingFenceConstruct = {\n    tokenize: tokenizeClosingFence,\n    partial: true\n  };\n  var initialPrefix = prefixSize(this.events, 'linePrefix');\n  var sizeOpen = 0;\n  var marker;\n  return start;\n\n  function start(code) {\n    effects.enter('codeFenced');\n    effects.enter('codeFencedFence');\n    effects.enter('codeFencedFenceSequence');\n    marker = code;\n    return sequenceOpen(code);\n  }\n\n  function sequenceOpen(code) {\n    if (code === marker) {\n      effects.consume(code);\n      sizeOpen++;\n      return sequenceOpen;\n    }\n\n    effects.exit('codeFencedFenceSequence');\n    return sizeOpen < 3 ? nok(code) : factorySpace(effects, infoOpen, 'whitespace')(code);\n  }\n\n  function infoOpen(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return openAfter(code);\n    }\n\n    effects.enter('codeFencedFenceInfo');\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return info(code);\n  }\n\n  function info(code) {\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit('chunkString');\n      effects.exit('codeFencedFenceInfo');\n      return factorySpace(effects, infoAfter, 'whitespace')(code);\n    }\n\n    if (code === 96 && code === marker) return nok(code);\n    effects.consume(code);\n    return info;\n  }\n\n  function infoAfter(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return openAfter(code);\n    }\n\n    effects.enter('codeFencedFenceMeta');\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return meta(code);\n  }\n\n  function meta(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString');\n      effects.exit('codeFencedFenceMeta');\n      return openAfter(code);\n    }\n\n    if (code === 96 && code === marker) return nok(code);\n    effects.consume(code);\n    return meta;\n  }\n\n  function openAfter(code) {\n    effects.exit('codeFencedFence');\n    return self.interrupt ? ok(code) : content(code);\n  }\n\n  function content(code) {\n    if (code === null) {\n      return after(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return effects.attempt(closingFenceConstruct, after, initialPrefix ? factorySpace(effects, content, 'linePrefix', initialPrefix + 1) : content);\n    }\n\n    effects.enter('codeFlowValue');\n    return contentContinue(code);\n  }\n\n  function contentContinue(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue');\n      return content(code);\n    }\n\n    effects.consume(code);\n    return contentContinue;\n  }\n\n  function after(code) {\n    effects.exit('codeFenced');\n    return ok(code);\n  }\n\n  function tokenizeClosingFence(effects, ok, nok) {\n    var size = 0;\n    return factorySpace(effects, closingSequenceStart, 'linePrefix', this.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4);\n\n    function closingSequenceStart(code) {\n      effects.enter('codeFencedFence');\n      effects.enter('codeFencedFenceSequence');\n      return closingSequence(code);\n    }\n\n    function closingSequence(code) {\n      if (code === marker) {\n        effects.consume(code);\n        size++;\n        return closingSequence;\n      }\n\n      if (size < sizeOpen) return nok(code);\n      effects.exit('codeFencedFenceSequence');\n      return factorySpace(effects, closingSequenceEnd, 'whitespace')(code);\n    }\n\n    function closingSequenceEnd(code) {\n      if (code === null || markdownLineEnding(code)) {\n        effects.exit('codeFencedFence');\n        return ok(code);\n      }\n\n      return nok(code);\n    }\n  }\n}\n\nmodule.exports = codeFenced;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar chunkedSplice = require('../util/chunked-splice.js');\n\nvar prefixSize = require('../util/prefix-size.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar codeIndented = {\n  name: 'codeIndented',\n  tokenize: tokenizeCodeIndented,\n  resolve: resolveCodeIndented\n};\nvar indentedContentConstruct = {\n  tokenize: tokenizeIndentedContent,\n  partial: true\n};\n\nfunction resolveCodeIndented(events, context) {\n  var code = {\n    type: 'codeIndented',\n    start: events[0][1].start,\n    end: events[events.length - 1][1].end\n  };\n  chunkedSplice(events, 0, 0, [['enter', code, context]]);\n  chunkedSplice(events, events.length, 0, [['exit', code, context]]);\n  return events;\n}\n\nfunction tokenizeCodeIndented(effects, ok, nok) {\n  return effects.attempt(indentedContentConstruct, afterPrefix, nok);\n\n  function afterPrefix(code) {\n    if (code === null) {\n      return ok(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.attempt(indentedContentConstruct, afterPrefix, ok)(code);\n    }\n\n    effects.enter('codeFlowValue');\n    return content(code);\n  }\n\n  function content(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue');\n      return afterPrefix(code);\n    }\n\n    effects.consume(code);\n    return content;\n  }\n}\n\nfunction tokenizeIndentedContent(effects, ok, nok) {\n  var self = this;\n  return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1);\n\n  function afterPrefix(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1);\n    }\n\n    return prefixSize(self.events, 'linePrefix') < 4 ? nok(code) : ok(code);\n  }\n}\n\nmodule.exports = codeIndented;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar codeText = {\n  name: 'codeText',\n  tokenize: tokenizeCodeText,\n  resolve: resolveCodeText,\n  previous: previous\n};\n\nfunction resolveCodeText(events) {\n  var tailExitIndex = events.length - 4;\n  var headEnterIndex = 3;\n  var index;\n  var enter; // If we start and end with an EOL or a space.\n\n  if ((events[headEnterIndex][1].type === 'lineEnding' || events[headEnterIndex][1].type === 'space') && (events[tailExitIndex][1].type === 'lineEnding' || events[tailExitIndex][1].type === 'space')) {\n    index = headEnterIndex; // And we have data.\n\n    while (++index < tailExitIndex) {\n      if (events[index][1].type === 'codeTextData') {\n        // Then we have padding.\n        events[tailExitIndex][1].type = events[headEnterIndex][1].type = 'codeTextPadding';\n        headEnterIndex += 2;\n        tailExitIndex -= 2;\n        break;\n      }\n    }\n  } // Merge adjacent spaces and data.\n\n\n  index = headEnterIndex - 1;\n  tailExitIndex++;\n\n  while (++index <= tailExitIndex) {\n    if (enter === undefined) {\n      if (index !== tailExitIndex && events[index][1].type !== 'lineEnding') {\n        enter = index;\n      }\n    } else if (index === tailExitIndex || events[index][1].type === 'lineEnding') {\n      events[enter][1].type = 'codeTextData';\n\n      if (index !== enter + 2) {\n        events[enter][1].end = events[index - 1][1].end;\n        events.splice(enter + 2, index - enter - 2);\n        tailExitIndex -= index - enter - 2;\n        index = enter + 2;\n      }\n\n      enter = undefined;\n    }\n  }\n\n  return events;\n}\n\nfunction previous(code) {\n  // If there is a previous code, there will always be a tail.\n  return code !== 96 || this.events[this.events.length - 1][1].type === 'characterEscape';\n}\n\nfunction tokenizeCodeText(effects, ok, nok) {\n  var sizeOpen = 0;\n  var size;\n  var token;\n  return start;\n\n  function start(code) {\n    effects.enter('codeText');\n    effects.enter('codeTextSequence');\n    return openingSequence(code);\n  }\n\n  function openingSequence(code) {\n    if (code === 96) {\n      effects.consume(code);\n      sizeOpen++;\n      return openingSequence;\n    }\n\n    effects.exit('codeTextSequence');\n    return gap(code);\n  }\n\n  function gap(code) {\n    // EOF.\n    if (code === null) {\n      return nok(code);\n    } // Closing fence?\n    // Could also be data.\n\n\n    if (code === 96) {\n      token = effects.enter('codeTextSequence');\n      size = 0;\n      return closingSequence(code);\n    } // Tabs don’t work, and virtual spaces don’t make sense.\n\n\n    if (code === 32) {\n      effects.enter('space');\n      effects.consume(code);\n      effects.exit('space');\n      return gap;\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return gap;\n    } // Data.\n\n\n    effects.enter('codeTextData');\n    return data(code);\n  } // In code.\n\n\n  function data(code) {\n    if (code === null || code === 32 || code === 96 || markdownLineEnding(code)) {\n      effects.exit('codeTextData');\n      return gap(code);\n    }\n\n    effects.consume(code);\n    return data;\n  } // Closing fence.\n\n\n  function closingSequence(code) {\n    // More.\n    if (code === 96) {\n      effects.consume(code);\n      size++;\n      return closingSequence;\n    } // Done!\n\n\n    if (size === sizeOpen) {\n      effects.exit('codeTextSequence');\n      effects.exit('codeText');\n      return ok(code);\n    } // More or less accents: mark as data.\n\n\n    token.type = 'codeTextData';\n    return data(code);\n  }\n}\n\nmodule.exports = codeText;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar prefixSize = require('../util/prefix-size.js');\n\nvar subtokenize = require('../util/subtokenize.js');\n\nvar factorySpace = require('./factory-space.js'); // No name because it must not be turned off.\n\n\nvar content = {\n  tokenize: tokenizeContent,\n  resolve: resolveContent,\n  interruptible: true,\n  lazy: true\n};\nvar continuationConstruct = {\n  tokenize: tokenizeContinuation,\n  partial: true\n}; // Content is transparent: it’s parsed right now. That way, definitions are also\n// parsed right now: before text in paragraphs (specifically, media) are parsed.\n\nfunction resolveContent(events) {\n  subtokenize(events);\n  return events;\n}\n\nfunction tokenizeContent(effects, ok) {\n  var previous;\n  return start;\n\n  function start(code) {\n    effects.enter('content');\n    previous = effects.enter('chunkContent', {\n      contentType: 'content'\n    });\n    return data(code);\n  }\n\n  function data(code) {\n    if (code === null) {\n      return contentEnd(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.check(continuationConstruct, contentContinue, contentEnd)(code);\n    } // Data.\n\n\n    effects.consume(code);\n    return data;\n  }\n\n  function contentEnd(code) {\n    effects.exit('chunkContent');\n    effects.exit('content');\n    return ok(code);\n  }\n\n  function contentContinue(code) {\n    effects.consume(code);\n    effects.exit('chunkContent');\n    previous = previous.next = effects.enter('chunkContent', {\n      contentType: 'content',\n      previous: previous\n    });\n    return data;\n  }\n}\n\nfunction tokenizeContinuation(effects, ok, nok) {\n  var self = this;\n  return startLookahead;\n\n  function startLookahead(code) {\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    return factorySpace(effects, prefixed, 'linePrefix');\n  }\n\n  function prefixed(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code);\n    }\n\n    if (self.parser.constructs.disable.null.indexOf('codeIndented') > -1 || prefixSize(self.events, 'linePrefix') < 4) {\n      return effects.interrupt(self.parser.constructs.flow, nok, ok)(code);\n    }\n\n    return ok(code);\n  }\n}\n\nmodule.exports = content;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\n\nvar normalizeIdentifier = require('../util/normalize-identifier.js');\n\nvar factoryDestination = require('./factory-destination.js');\n\nvar factoryLabel = require('./factory-label.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar factoryWhitespace = require('./factory-whitespace.js');\n\nvar factoryTitle = require('./factory-title.js');\n\nvar definition = {\n  name: 'definition',\n  tokenize: tokenizeDefinition\n};\nvar titleConstruct = {\n  tokenize: tokenizeTitle,\n  partial: true\n};\n\nfunction tokenizeDefinition(effects, ok, nok) {\n  var self = this;\n  var identifier;\n  return start;\n\n  function start(code) {\n    effects.enter('definition');\n    return factoryLabel.call(self, effects, labelAfter, nok, 'definitionLabel', 'definitionLabelMarker', 'definitionLabelString')(code);\n  }\n\n  function labelAfter(code) {\n    identifier = normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1));\n\n    if (code === 58) {\n      effects.enter('definitionMarker');\n      effects.consume(code);\n      effects.exit('definitionMarker'); // Note: blank lines can’t exist in content.\n\n      return factoryWhitespace(effects, factoryDestination(effects, effects.attempt(titleConstruct, factorySpace(effects, after, 'whitespace'), factorySpace(effects, after, 'whitespace')), nok, 'definitionDestination', 'definitionDestinationLiteral', 'definitionDestinationLiteralMarker', 'definitionDestinationRaw', 'definitionDestinationString'));\n    }\n\n    return nok(code);\n  }\n\n  function after(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('definition');\n\n      if (self.parser.defined.indexOf(identifier) < 0) {\n        self.parser.defined.push(identifier);\n      }\n\n      return ok(code);\n    }\n\n    return nok(code);\n  }\n}\n\nfunction tokenizeTitle(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, before)(code) : nok(code);\n  }\n\n  function before(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(effects, factorySpace(effects, after, 'whitespace'), nok, 'definitionTitle', 'definitionTitleMarker', 'definitionTitleString')(code);\n    }\n\n    return nok(code);\n  }\n\n  function after(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}\n\nmodule.exports = definition;","'use strict';\n\nvar asciiControl = require('../character/ascii-control.js');\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js'); // eslint-disable-next-line max-params\n\n\nfunction destinationFactory(effects, ok, nok, type, literalType, literalMarkerType, rawType, stringType, max) {\n  var limit = max || Infinity;\n  var balance = 0;\n  return start;\n\n  function start(code) {\n    if (code === 60) {\n      effects.enter(type);\n      effects.enter(literalType);\n      effects.enter(literalMarkerType);\n      effects.consume(code);\n      effects.exit(literalMarkerType);\n      return destinationEnclosedBefore;\n    }\n\n    if (asciiControl(code) || code === 41) {\n      return nok(code);\n    }\n\n    effects.enter(type);\n    effects.enter(rawType);\n    effects.enter(stringType);\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return destinationRaw(code);\n  }\n\n  function destinationEnclosedBefore(code) {\n    if (code === 62) {\n      effects.enter(literalMarkerType);\n      effects.consume(code);\n      effects.exit(literalMarkerType);\n      effects.exit(literalType);\n      effects.exit(type);\n      return ok;\n    }\n\n    effects.enter(stringType);\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return destinationEnclosed(code);\n  }\n\n  function destinationEnclosed(code) {\n    if (code === 62) {\n      effects.exit('chunkString');\n      effects.exit(stringType);\n      return destinationEnclosedBefore(code);\n    }\n\n    if (code === null || code === 60 || markdownLineEnding(code)) {\n      return nok(code);\n    }\n\n    effects.consume(code);\n    return code === 92 ? destinationEnclosedEscape : destinationEnclosed;\n  }\n\n  function destinationEnclosedEscape(code) {\n    if (code === 60 || code === 62 || code === 92) {\n      effects.consume(code);\n      return destinationEnclosed;\n    }\n\n    return destinationEnclosed(code);\n  }\n\n  function destinationRaw(code) {\n    if (code === 40) {\n      if (++balance > limit) return nok(code);\n      effects.consume(code);\n      return destinationRaw;\n    }\n\n    if (code === 41) {\n      if (!balance--) {\n        effects.exit('chunkString');\n        effects.exit(stringType);\n        effects.exit(rawType);\n        effects.exit(type);\n        return ok(code);\n      }\n\n      effects.consume(code);\n      return destinationRaw;\n    }\n\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      if (balance) return nok(code);\n      effects.exit('chunkString');\n      effects.exit(stringType);\n      effects.exit(rawType);\n      effects.exit(type);\n      return ok(code);\n    }\n\n    if (asciiControl(code)) return nok(code);\n    effects.consume(code);\n    return code === 92 ? destinationRawEscape : destinationRaw;\n  }\n\n  function destinationRawEscape(code) {\n    if (code === 40 || code === 41 || code === 92) {\n      effects.consume(code);\n      return destinationRaw;\n    }\n\n    return destinationRaw(code);\n  }\n}\n\nmodule.exports = destinationFactory;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar markdownSpace = require('../character/markdown-space.js'); // eslint-disable-next-line max-params\n\n\nfunction labelFactory(effects, ok, nok, type, markerType, stringType) {\n  var self = this;\n  var size = 0;\n  var data;\n  return start;\n\n  function start(code) {\n    effects.enter(type);\n    effects.enter(markerType);\n    effects.consume(code);\n    effects.exit(markerType);\n    effects.enter(stringType);\n    return atBreak;\n  }\n\n  function atBreak(code) {\n    if (code === null || code === 91 || code === 93 && !data ||\n    /* c8 ignore next */\n    code === 94 &&\n    /* c8 ignore next */\n    !size &&\n    /* c8 ignore next */\n    '_hiddenFootnoteSupport' in self.parser.constructs || size > 999) {\n      return nok(code);\n    }\n\n    if (code === 93) {\n      effects.exit(stringType);\n      effects.enter(markerType);\n      effects.consume(code);\n      effects.exit(markerType);\n      effects.exit(type);\n      return ok;\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return atBreak;\n    }\n\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return label(code);\n  }\n\n  function label(code) {\n    if (code === null || code === 91 || code === 93 || markdownLineEnding(code) || size++ > 999) {\n      effects.exit('chunkString');\n      return atBreak(code);\n    }\n\n    effects.consume(code);\n    data = data || !markdownSpace(code);\n    return code === 92 ? labelEscape : label;\n  }\n\n  function labelEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code);\n      size++;\n      return label;\n    }\n\n    return label(code);\n  }\n}\n\nmodule.exports = labelFactory;","'use strict';\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nfunction spaceFactory(effects, ok, type, max) {\n  var limit = max ? max - 1 : Infinity;\n  var size = 0;\n  return start;\n\n  function start(code) {\n    if (markdownSpace(code)) {\n      effects.enter(type);\n      return prefix(code);\n    }\n\n    return ok(code);\n  }\n\n  function prefix(code) {\n    if (markdownSpace(code) && size++ < limit) {\n      effects.consume(code);\n      return prefix;\n    }\n\n    effects.exit(type);\n    return ok(code);\n  }\n}\n\nmodule.exports = spaceFactory;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar factorySpace = require('./factory-space.js');\n\nfunction titleFactory(effects, ok, nok, type, markerType, stringType) {\n  var marker;\n  return start;\n\n  function start(code) {\n    effects.enter(type);\n    effects.enter(markerType);\n    effects.consume(code);\n    effects.exit(markerType);\n    marker = code === 40 ? 41 : code;\n    return atFirstTitleBreak;\n  }\n\n  function atFirstTitleBreak(code) {\n    if (code === marker) {\n      effects.enter(markerType);\n      effects.consume(code);\n      effects.exit(markerType);\n      effects.exit(type);\n      return ok;\n    }\n\n    effects.enter(stringType);\n    return atTitleBreak(code);\n  }\n\n  function atTitleBreak(code) {\n    if (code === marker) {\n      effects.exit(stringType);\n      return atFirstTitleBreak(marker);\n    }\n\n    if (code === null) {\n      return nok(code);\n    } // Note: blank lines can’t exist in content.\n\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return factorySpace(effects, atTitleBreak, 'linePrefix');\n    }\n\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return title(code);\n  }\n\n  function title(code) {\n    if (code === marker || code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString');\n      return atTitleBreak(code);\n    }\n\n    effects.consume(code);\n    return code === 92 ? titleEscape : title;\n  }\n\n  function titleEscape(code) {\n    if (code === marker || code === 92) {\n      effects.consume(code);\n      return title;\n    }\n\n    return title(code);\n  }\n}\n\nmodule.exports = titleFactory;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nvar factorySpace = require('./factory-space.js');\n\nfunction whitespaceFactory(effects, ok) {\n  var seen;\n  return start;\n\n  function start(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      seen = true;\n      return start;\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(effects, start, seen ? 'linePrefix' : 'lineSuffix')(code);\n    }\n\n    return ok(code);\n  }\n}\n\nmodule.exports = whitespaceFactory;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar hardBreakEscape = {\n  name: 'hardBreakEscape',\n  tokenize: tokenizeHardBreakEscape\n};\n\nfunction tokenizeHardBreakEscape(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    effects.enter('hardBreakEscape');\n    effects.enter('escapeMarker');\n    effects.consume(code);\n    return open;\n  }\n\n  function open(code) {\n    if (markdownLineEnding(code)) {\n      effects.exit('escapeMarker');\n      effects.exit('hardBreakEscape');\n      return ok(code);\n    }\n\n    return nok(code);\n  }\n}\n\nmodule.exports = hardBreakEscape;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nvar chunkedSplice = require('../util/chunked-splice.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar headingAtx = {\n  name: 'headingAtx',\n  tokenize: tokenizeHeadingAtx,\n  resolve: resolveHeadingAtx\n};\n\nfunction resolveHeadingAtx(events, context) {\n  var contentEnd = events.length - 2;\n  var contentStart = 3;\n  var content;\n  var text; // Prefix whitespace, part of the opening.\n\n  if (events[contentStart][1].type === 'whitespace') {\n    contentStart += 2;\n  } // Suffix whitespace, part of the closing.\n\n\n  if (contentEnd - 2 > contentStart && events[contentEnd][1].type === 'whitespace') {\n    contentEnd -= 2;\n  }\n\n  if (events[contentEnd][1].type === 'atxHeadingSequence' && (contentStart === contentEnd - 1 || contentEnd - 4 > contentStart && events[contentEnd - 2][1].type === 'whitespace')) {\n    contentEnd -= contentStart + 1 === contentEnd ? 2 : 4;\n  }\n\n  if (contentEnd > contentStart) {\n    content = {\n      type: 'atxHeadingText',\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end\n    };\n    text = {\n      type: 'chunkText',\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end,\n      contentType: 'text'\n    };\n    chunkedSplice(events, contentStart, contentEnd - contentStart + 1, [['enter', content, context], ['enter', text, context], ['exit', text, context], ['exit', content, context]]);\n  }\n\n  return events;\n}\n\nfunction tokenizeHeadingAtx(effects, ok, nok) {\n  var self = this;\n  var size = 0;\n  return start;\n\n  function start(code) {\n    effects.enter('atxHeading');\n    effects.enter('atxHeadingSequence');\n    return fenceOpenInside(code);\n  }\n\n  function fenceOpenInside(code) {\n    if (code === 35 && size++ < 6) {\n      effects.consume(code);\n      return fenceOpenInside;\n    }\n\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingSequence');\n      return self.interrupt ? ok(code) : headingBreak(code);\n    }\n\n    return nok(code);\n  }\n\n  function headingBreak(code) {\n    if (code === 35) {\n      effects.enter('atxHeadingSequence');\n      return sequence(code);\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('atxHeading');\n      return ok(code);\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(effects, headingBreak, 'whitespace')(code);\n    }\n\n    effects.enter('atxHeadingText');\n    return data(code);\n  }\n\n  function sequence(code) {\n    if (code === 35) {\n      effects.consume(code);\n      return sequence;\n    }\n\n    effects.exit('atxHeadingSequence');\n    return headingBreak(code);\n  }\n\n  function data(code) {\n    if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingText');\n      return headingBreak(code);\n    }\n\n    effects.consume(code);\n    return data;\n  }\n}\n\nmodule.exports = headingAtx;","'use strict';\n\nvar asciiAlpha = require('../character/ascii-alpha.js');\n\nvar asciiAlphanumeric = require('../character/ascii-alphanumeric.js');\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nvar fromCharCode = require('../constant/from-char-code.js');\n\nvar htmlBlockNames = require('../constant/html-block-names.js');\n\nvar htmlRawNames = require('../constant/html-raw-names.js');\n\nvar partialBlankLine = require('./partial-blank-line.js');\n\nvar htmlFlow = {\n  name: 'htmlFlow',\n  tokenize: tokenizeHtmlFlow,\n  resolveTo: resolveToHtmlFlow,\n  concrete: true\n};\nvar nextBlankConstruct = {\n  tokenize: tokenizeNextBlank,\n  partial: true\n};\n\nfunction resolveToHtmlFlow(events) {\n  var index = events.length;\n\n  while (index--) {\n    if (events[index][0] === 'enter' && events[index][1].type === 'htmlFlow') {\n      break;\n    }\n  }\n\n  if (index > 1 && events[index - 2][1].type === 'linePrefix') {\n    // Add the prefix start to the HTML token.\n    events[index][1].start = events[index - 2][1].start; // Add the prefix start to the HTML line token.\n\n    events[index + 1][1].start = events[index - 2][1].start; // Remove the line prefix.\n\n    events.splice(index - 2, 2);\n  }\n\n  return events;\n}\n\nfunction tokenizeHtmlFlow(effects, ok, nok) {\n  var self = this;\n  var kind;\n  var startTag;\n  var buffer;\n  var index;\n  var marker;\n  return start;\n\n  function start(code) {\n    effects.enter('htmlFlow');\n    effects.enter('htmlFlowData');\n    effects.consume(code);\n    return open;\n  }\n\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code);\n      return declarationStart;\n    }\n\n    if (code === 47) {\n      effects.consume(code);\n      return tagCloseStart;\n    }\n\n    if (code === 63) {\n      effects.consume(code);\n      kind = 3; // While we’re in an instruction instead of a declaration, we’re on a `?`\n      // right now, so we do need to search for `>`, similar to declarations.\n\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      buffer = fromCharCode(code);\n      startTag = true;\n      return tagName;\n    }\n\n    return nok(code);\n  }\n\n  function declarationStart(code) {\n    if (code === 45) {\n      effects.consume(code);\n      kind = 2;\n      return commentOpenInside;\n    }\n\n    if (code === 91) {\n      effects.consume(code);\n      kind = 5;\n      buffer = 'CDATA[';\n      index = 0;\n      return cdataOpenInside;\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      kind = 4;\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n\n    return nok(code);\n  }\n\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n\n    return nok(code);\n  }\n\n  function cdataOpenInside(code) {\n    if (code === buffer.charCodeAt(index++)) {\n      effects.consume(code);\n      return index === buffer.length ? self.interrupt ? ok : continuation : cdataOpenInside;\n    }\n\n    return nok(code);\n  }\n\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      buffer = fromCharCode(code);\n      return tagName;\n    }\n\n    return nok(code);\n  }\n\n  function tagName(code) {\n    if (code === null || code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      if (code !== 47 && startTag && htmlRawNames.indexOf(buffer.toLowerCase()) > -1) {\n        kind = 1;\n        return self.interrupt ? ok(code) : continuation(code);\n      }\n\n      if (htmlBlockNames.indexOf(buffer.toLowerCase()) > -1) {\n        kind = 6;\n\n        if (code === 47) {\n          effects.consume(code);\n          return basicSelfClosing;\n        }\n\n        return self.interrupt ? ok(code) : continuation(code);\n      }\n\n      kind = 7; // Do not support complete HTML when interrupting.\n\n      return self.interrupt ? nok(code) : startTag ? completeAttributeNameBefore(code) : completeClosingTagAfter(code);\n    }\n\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      buffer += fromCharCode(code);\n      return tagName;\n    }\n\n    return nok(code);\n  }\n\n  function basicSelfClosing(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return self.interrupt ? ok : continuation;\n    }\n\n    return nok(code);\n  }\n\n  function completeClosingTagAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeClosingTagAfter;\n    }\n\n    return completeEnd(code);\n  }\n\n  function completeAttributeNameBefore(code) {\n    if (code === 47) {\n      effects.consume(code);\n      return completeEnd;\n    }\n\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code);\n      return completeAttributeName;\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeNameBefore;\n    }\n\n    return completeEnd(code);\n  }\n\n  function completeAttributeName(code) {\n    if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return completeAttributeName;\n    }\n\n    return completeAttributeNameAfter(code);\n  }\n\n  function completeAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code);\n      return completeAttributeValueBefore;\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeNameAfter;\n    }\n\n    return completeAttributeNameBefore(code);\n  }\n\n  function completeAttributeValueBefore(code) {\n    if (code === null || code === 60 || code === 61 || code === 62 || code === 96) {\n      return nok(code);\n    }\n\n    if (code === 34 || code === 39) {\n      effects.consume(code);\n      marker = code;\n      return completeAttributeValueQuoted;\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeValueBefore;\n    }\n\n    marker = undefined;\n    return completeAttributeValueUnquoted(code);\n  }\n\n  function completeAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return completeAttributeValueQuotedAfter;\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code);\n    }\n\n    effects.consume(code);\n    return completeAttributeValueQuoted;\n  }\n\n  function completeAttributeValueUnquoted(code) {\n    if (code === null || code === 34 || code === 39 || code === 60 || code === 61 || code === 62 || code === 96 || markdownLineEndingOrSpace(code)) {\n      return completeAttributeNameAfter(code);\n    }\n\n    effects.consume(code);\n    return completeAttributeValueUnquoted;\n  }\n\n  function completeAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownSpace(code)) {\n      return completeAttributeNameBefore(code);\n    }\n\n    return nok(code);\n  }\n\n  function completeEnd(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return completeAfter;\n    }\n\n    return nok(code);\n  }\n\n  function completeAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAfter;\n    }\n\n    return code === null || markdownLineEnding(code) ? continuation(code) : nok(code);\n  }\n\n  function continuation(code) {\n    if (code === 45 && kind === 2) {\n      effects.consume(code);\n      return continuationCommentInside;\n    }\n\n    if (code === 60 && kind === 1) {\n      effects.consume(code);\n      return continuationRawTagOpen;\n    }\n\n    if (code === 62 && kind === 4) {\n      effects.consume(code);\n      return continuationClose;\n    }\n\n    if (code === 63 && kind === 3) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n\n    if (code === 93 && kind === 5) {\n      effects.consume(code);\n      return continuationCharacterDataInside;\n    }\n\n    if (markdownLineEnding(code) && (kind === 6 || kind === 7)) {\n      return effects.check(nextBlankConstruct, continuationClose, continuationAtLineEnding)(code);\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      return continuationAtLineEnding(code);\n    }\n\n    effects.consume(code);\n    return continuation;\n  }\n\n  function continuationAtLineEnding(code) {\n    effects.exit('htmlFlowData');\n    return htmlContinueStart(code);\n  }\n\n  function htmlContinueStart(code) {\n    if (code === null) {\n      return done(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return htmlContinueStart;\n    }\n\n    effects.enter('htmlFlowData');\n    return continuation(code);\n  }\n\n  function continuationCommentInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n\n    return continuation(code);\n  }\n\n  function continuationRawTagOpen(code) {\n    if (code === 47) {\n      effects.consume(code);\n      buffer = '';\n      return continuationRawEndTag;\n    }\n\n    return continuation(code);\n  }\n\n  function continuationRawEndTag(code) {\n    if (code === 62 && htmlRawNames.indexOf(buffer.toLowerCase()) > -1) {\n      effects.consume(code);\n      return continuationClose;\n    }\n\n    if (asciiAlpha(code) && buffer.length < 8) {\n      effects.consume(code);\n      buffer += fromCharCode(code);\n      return continuationRawEndTag;\n    }\n\n    return continuation(code);\n  }\n\n  function continuationCharacterDataInside(code) {\n    if (code === 93) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n\n    return continuation(code);\n  }\n\n  function continuationDeclarationInside(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return continuationClose;\n    }\n\n    return continuation(code);\n  }\n\n  function continuationClose(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('htmlFlowData');\n      return done(code);\n    }\n\n    effects.consume(code);\n    return continuationClose;\n  }\n\n  function done(code) {\n    effects.exit('htmlFlow');\n    return ok(code);\n  }\n}\n\nfunction tokenizeNextBlank(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    effects.exit('htmlFlowData');\n    effects.enter('lineEndingBlank');\n    effects.consume(code);\n    effects.exit('lineEndingBlank');\n    return effects.attempt(partialBlankLine, ok, nok);\n  }\n}\n\nmodule.exports = htmlFlow;","'use strict';\n\nvar asciiAlpha = require('../character/ascii-alpha.js');\n\nvar asciiAlphanumeric = require('../character/ascii-alphanumeric.js');\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar htmlText = {\n  name: 'htmlText',\n  tokenize: tokenizeHtmlText\n};\n\nfunction tokenizeHtmlText(effects, ok, nok) {\n  var self = this;\n  var marker;\n  var buffer;\n  var index;\n  var returnState;\n  return start;\n\n  function start(code) {\n    effects.enter('htmlText');\n    effects.enter('htmlTextData');\n    effects.consume(code);\n    return open;\n  }\n\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code);\n      return declarationOpen;\n    }\n\n    if (code === 47) {\n      effects.consume(code);\n      return tagCloseStart;\n    }\n\n    if (code === 63) {\n      effects.consume(code);\n      return instruction;\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return tagOpen;\n    }\n\n    return nok(code);\n  }\n\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentOpen;\n    }\n\n    if (code === 91) {\n      effects.consume(code);\n      buffer = 'CDATA[';\n      index = 0;\n      return cdataOpen;\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return declaration;\n    }\n\n    return nok(code);\n  }\n\n  function commentOpen(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentStart;\n    }\n\n    return nok(code);\n  }\n\n  function commentStart(code) {\n    if (code === null || code === 62) {\n      return nok(code);\n    }\n\n    if (code === 45) {\n      effects.consume(code);\n      return commentStartDash;\n    }\n\n    return comment(code);\n  }\n\n  function commentStartDash(code) {\n    if (code === null || code === 62) {\n      return nok(code);\n    }\n\n    return comment(code);\n  }\n\n  function comment(code) {\n    if (code === null) {\n      return nok(code);\n    }\n\n    if (code === 45) {\n      effects.consume(code);\n      return commentClose;\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = comment;\n      return atLineEnding(code);\n    }\n\n    effects.consume(code);\n    return comment;\n  }\n\n  function commentClose(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return end;\n    }\n\n    return comment(code);\n  }\n\n  function cdataOpen(code) {\n    if (code === buffer.charCodeAt(index++)) {\n      effects.consume(code);\n      return index === buffer.length ? cdata : cdataOpen;\n    }\n\n    return nok(code);\n  }\n\n  function cdata(code) {\n    if (code === null) {\n      return nok(code);\n    }\n\n    if (code === 93) {\n      effects.consume(code);\n      return cdataClose;\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = cdata;\n      return atLineEnding(code);\n    }\n\n    effects.consume(code);\n    return cdata;\n  }\n\n  function cdataClose(code) {\n    if (code === 93) {\n      effects.consume(code);\n      return cdataEnd;\n    }\n\n    return cdata(code);\n  }\n\n  function cdataEnd(code) {\n    if (code === 62) {\n      return end(code);\n    }\n\n    if (code === 93) {\n      effects.consume(code);\n      return cdataEnd;\n    }\n\n    return cdata(code);\n  }\n\n  function declaration(code) {\n    if (code === null || code === 62) {\n      return end(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = declaration;\n      return atLineEnding(code);\n    }\n\n    effects.consume(code);\n    return declaration;\n  }\n\n  function instruction(code) {\n    if (code === null) {\n      return nok(code);\n    }\n\n    if (code === 63) {\n      effects.consume(code);\n      return instructionClose;\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = instruction;\n      return atLineEnding(code);\n    }\n\n    effects.consume(code);\n    return instruction;\n  }\n\n  function instructionClose(code) {\n    return code === 62 ? end(code) : instruction(code);\n  }\n\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return tagClose;\n    }\n\n    return nok(code);\n  }\n\n  function tagClose(code) {\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagClose;\n    }\n\n    return tagCloseBetween(code);\n  }\n\n  function tagCloseBetween(code) {\n    if (markdownLineEnding(code)) {\n      returnState = tagCloseBetween;\n      return atLineEnding(code);\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagCloseBetween;\n    }\n\n    return end(code);\n  }\n\n  function tagOpen(code) {\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagOpen;\n    }\n\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n\n    return nok(code);\n  }\n\n  function tagOpenBetween(code) {\n    if (code === 47) {\n      effects.consume(code);\n      return end;\n    }\n\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code);\n      return tagOpenAttributeName;\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenBetween;\n      return atLineEnding(code);\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenBetween;\n    }\n\n    return end(code);\n  }\n\n  function tagOpenAttributeName(code) {\n    if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagOpenAttributeName;\n    }\n\n    return tagOpenAttributeNameAfter(code);\n  }\n\n  function tagOpenAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code);\n      return tagOpenAttributeValueBefore;\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeNameAfter;\n      return atLineEnding(code);\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenAttributeNameAfter;\n    }\n\n    return tagOpenBetween(code);\n  }\n\n  function tagOpenAttributeValueBefore(code) {\n    if (code === null || code === 60 || code === 61 || code === 62 || code === 96) {\n      return nok(code);\n    }\n\n    if (code === 34 || code === 39) {\n      effects.consume(code);\n      marker = code;\n      return tagOpenAttributeValueQuoted;\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueBefore;\n      return atLineEnding(code);\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenAttributeValueBefore;\n    }\n\n    effects.consume(code);\n    marker = undefined;\n    return tagOpenAttributeValueUnquoted;\n  }\n\n  function tagOpenAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return tagOpenAttributeValueQuotedAfter;\n    }\n\n    if (code === null) {\n      return nok(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueQuoted;\n      return atLineEnding(code);\n    }\n\n    effects.consume(code);\n    return tagOpenAttributeValueQuoted;\n  }\n\n  function tagOpenAttributeValueQuotedAfter(code) {\n    if (code === 62 || code === 47 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n\n    return nok(code);\n  }\n\n  function tagOpenAttributeValueUnquoted(code) {\n    if (code === null || code === 34 || code === 39 || code === 60 || code === 61 || code === 96) {\n      return nok(code);\n    }\n\n    if (code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n\n    effects.consume(code);\n    return tagOpenAttributeValueUnquoted;\n  } // We can’t have blank lines in content, so no need to worry about empty\n  // tokens.\n\n\n  function atLineEnding(code) {\n    effects.exit('htmlTextData');\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    return factorySpace(effects, afterPrefix, 'linePrefix', self.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4);\n  }\n\n  function afterPrefix(code) {\n    effects.enter('htmlTextData');\n    return returnState(code);\n  }\n\n  function end(code) {\n    if (code === 62) {\n      effects.consume(code);\n      effects.exit('htmlTextData');\n      effects.exit('htmlText');\n      return ok;\n    }\n\n    return nok(code);\n  }\n}\n\nmodule.exports = htmlText;","'use strict';\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\n\nvar chunkedPush = require('../util/chunked-push.js');\n\nvar chunkedSplice = require('../util/chunked-splice.js');\n\nvar normalizeIdentifier = require('../util/normalize-identifier.js');\n\nvar resolveAll = require('../util/resolve-all.js');\n\nvar shallow = require('../util/shallow.js');\n\nvar factoryDestination = require('./factory-destination.js');\n\nvar factoryLabel = require('./factory-label.js');\n\nvar factoryTitle = require('./factory-title.js');\n\nvar factoryWhitespace = require('./factory-whitespace.js');\n\nvar labelEnd = {\n  name: 'labelEnd',\n  tokenize: tokenizeLabelEnd,\n  resolveTo: resolveToLabelEnd,\n  resolveAll: resolveAllLabelEnd\n};\nvar resourceConstruct = {\n  tokenize: tokenizeResource\n};\nvar fullReferenceConstruct = {\n  tokenize: tokenizeFullReference\n};\nvar collapsedReferenceConstruct = {\n  tokenize: tokenizeCollapsedReference\n};\n\nfunction resolveAllLabelEnd(events) {\n  var index = -1;\n  var token;\n\n  while (++index < events.length) {\n    token = events[index][1];\n\n    if (!token._used && (token.type === 'labelImage' || token.type === 'labelLink' || token.type === 'labelEnd')) {\n      // Remove the marker.\n      events.splice(index + 1, token.type === 'labelImage' ? 4 : 2);\n      token.type = 'data';\n      index++;\n    }\n  }\n\n  return events;\n}\n\nfunction resolveToLabelEnd(events, context) {\n  var index = events.length;\n  var offset = 0;\n  var group;\n  var label;\n  var text;\n  var token;\n  var open;\n  var close;\n  var media; // Find an opening.\n\n  while (index--) {\n    token = events[index][1];\n\n    if (open) {\n      // If we see another link, or inactive link label, we’ve been here before.\n      if (token.type === 'link' || token.type === 'labelLink' && token._inactive) {\n        break;\n      } // Mark other link openings as inactive, as we can’t have links in\n      // links.\n\n\n      if (events[index][0] === 'enter' && token.type === 'labelLink') {\n        token._inactive = true;\n      }\n    } else if (close) {\n      if (events[index][0] === 'enter' && (token.type === 'labelImage' || token.type === 'labelLink') && !token._balanced) {\n        open = index;\n\n        if (token.type !== 'labelLink') {\n          offset = 2;\n          break;\n        }\n      }\n    } else if (token.type === 'labelEnd') {\n      close = index;\n    }\n  }\n\n  group = {\n    type: events[open][1].type === 'labelLink' ? 'link' : 'image',\n    start: shallow(events[open][1].start),\n    end: shallow(events[events.length - 1][1].end)\n  };\n  label = {\n    type: 'label',\n    start: shallow(events[open][1].start),\n    end: shallow(events[close][1].end)\n  };\n  text = {\n    type: 'labelText',\n    start: shallow(events[open + offset + 2][1].end),\n    end: shallow(events[close - 2][1].start)\n  };\n  media = [['enter', group, context], ['enter', label, context]]; // Opening marker.\n\n  media = chunkedPush(media, events.slice(open + 1, open + offset + 3)); // Text open.\n\n  media = chunkedPush(media, [['enter', text, context]]); // Between.\n\n  media = chunkedPush(media, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + offset + 4, close - 3), context)); // Text close, marker close, label close.\n\n  media = chunkedPush(media, [['exit', text, context], events[close - 2], events[close - 1], ['exit', label, context]]); // Reference, resource, or so.\n\n  media = chunkedPush(media, events.slice(close + 1)); // Media close.\n\n  media = chunkedPush(media, [['exit', group, context]]);\n  chunkedSplice(events, open, events.length, media);\n  return events;\n}\n\nfunction tokenizeLabelEnd(effects, ok, nok) {\n  var self = this;\n  var index = self.events.length;\n  var labelStart;\n  var defined; // Find an opening.\n\n  while (index--) {\n    if ((self.events[index][1].type === 'labelImage' || self.events[index][1].type === 'labelLink') && !self.events[index][1]._balanced) {\n      labelStart = self.events[index][1];\n      break;\n    }\n  }\n\n  return start;\n\n  function start(code) {\n    if (!labelStart) {\n      return nok(code);\n    } // It’s a balanced bracket, but contains a link.\n\n\n    if (labelStart._inactive) return balanced(code);\n    defined = self.parser.defined.indexOf(normalizeIdentifier(self.sliceSerialize({\n      start: labelStart.end,\n      end: self.now()\n    }))) > -1;\n    effects.enter('labelEnd');\n    effects.enter('labelMarker');\n    effects.consume(code);\n    effects.exit('labelMarker');\n    effects.exit('labelEnd');\n    return afterLabelEnd;\n  }\n\n  function afterLabelEnd(code) {\n    // Resource: `[asd](fgh)`.\n    if (code === 40) {\n      return effects.attempt(resourceConstruct, ok, defined ? ok : balanced)(code);\n    } // Collapsed (`[asd][]`) or full (`[asd][fgh]`) reference?\n\n\n    if (code === 91) {\n      return effects.attempt(fullReferenceConstruct, ok, defined ? effects.attempt(collapsedReferenceConstruct, ok, balanced) : balanced)(code);\n    } // Shortcut reference: `[asd]`?\n\n\n    return defined ? ok(code) : balanced(code);\n  }\n\n  function balanced(code) {\n    labelStart._balanced = true;\n    return nok(code);\n  }\n}\n\nfunction tokenizeResource(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    effects.enter('resource');\n    effects.enter('resourceMarker');\n    effects.consume(code);\n    effects.exit('resourceMarker');\n    return factoryWhitespace(effects, open);\n  }\n\n  function open(code) {\n    if (code === 41) {\n      return end(code);\n    }\n\n    return factoryDestination(effects, destinationAfter, nok, 'resourceDestination', 'resourceDestinationLiteral', 'resourceDestinationLiteralMarker', 'resourceDestinationRaw', 'resourceDestinationString', 3)(code);\n  }\n\n  function destinationAfter(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, between)(code) : end(code);\n  }\n\n  function between(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(effects, factoryWhitespace(effects, end), nok, 'resourceTitle', 'resourceTitleMarker', 'resourceTitleString')(code);\n    }\n\n    return end(code);\n  }\n\n  function end(code) {\n    if (code === 41) {\n      effects.enter('resourceMarker');\n      effects.consume(code);\n      effects.exit('resourceMarker');\n      effects.exit('resource');\n      return ok;\n    }\n\n    return nok(code);\n  }\n}\n\nfunction tokenizeFullReference(effects, ok, nok) {\n  var self = this;\n  return start;\n\n  function start(code) {\n    return factoryLabel.call(self, effects, afterLabel, nok, 'reference', 'referenceMarker', 'referenceString')(code);\n  }\n\n  function afterLabel(code) {\n    return self.parser.defined.indexOf(normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1))) < 0 ? nok(code) : ok(code);\n  }\n}\n\nfunction tokenizeCollapsedReference(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    effects.enter('reference');\n    effects.enter('referenceMarker');\n    effects.consume(code);\n    effects.exit('referenceMarker');\n    return open;\n  }\n\n  function open(code) {\n    if (code === 93) {\n      effects.enter('referenceMarker');\n      effects.consume(code);\n      effects.exit('referenceMarker');\n      effects.exit('reference');\n      return ok;\n    }\n\n    return nok(code);\n  }\n}\n\nmodule.exports = labelEnd;","'use strict';\n\nvar labelEnd = require('./label-end.js');\n\nvar labelStartImage = {\n  name: 'labelStartImage',\n  tokenize: tokenizeLabelStartImage,\n  resolveAll: labelEnd.resolveAll\n};\n\nfunction tokenizeLabelStartImage(effects, ok, nok) {\n  var self = this;\n  return start;\n\n  function start(code) {\n    effects.enter('labelImage');\n    effects.enter('labelImageMarker');\n    effects.consume(code);\n    effects.exit('labelImageMarker');\n    return open;\n  }\n\n  function open(code) {\n    if (code === 91) {\n      effects.enter('labelMarker');\n      effects.consume(code);\n      effects.exit('labelMarker');\n      effects.exit('labelImage');\n      return after;\n    }\n\n    return nok(code);\n  }\n\n  function after(code) {\n    /* c8 ignore next */\n    return code === 94 &&\n    /* c8 ignore next */\n    '_hiddenFootnoteSupport' in self.parser.constructs ?\n    /* c8 ignore next */\n    nok(code) : ok(code);\n  }\n}\n\nmodule.exports = labelStartImage;","'use strict';\n\nvar labelEnd = require('./label-end.js');\n\nvar labelStartLink = {\n  name: 'labelStartLink',\n  tokenize: tokenizeLabelStartLink,\n  resolveAll: labelEnd.resolveAll\n};\n\nfunction tokenizeLabelStartLink(effects, ok, nok) {\n  var self = this;\n  return start;\n\n  function start(code) {\n    effects.enter('labelLink');\n    effects.enter('labelMarker');\n    effects.consume(code);\n    effects.exit('labelMarker');\n    effects.exit('labelLink');\n    return after;\n  }\n\n  function after(code) {\n    /* c8 ignore next */\n    return code === 94 &&\n    /* c8 ignore next */\n    '_hiddenFootnoteSupport' in self.parser.constructs ?\n    /* c8 ignore next */\n    nok(code) : ok(code);\n  }\n}\n\nmodule.exports = labelStartLink;","'use strict';\n\nvar factorySpace = require('./factory-space.js');\n\nvar lineEnding = {\n  name: 'lineEnding',\n  tokenize: tokenizeLineEnding\n};\n\nfunction tokenizeLineEnding(effects, ok) {\n  return start;\n\n  function start(code) {\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    return factorySpace(effects, ok, 'linePrefix');\n  }\n}\n\nmodule.exports = lineEnding;","'use strict';\n\nvar asciiDigit = require('../character/ascii-digit.js');\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nvar prefixSize = require('../util/prefix-size.js');\n\nvar sizeChunks = require('../util/size-chunks.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar partialBlankLine = require('./partial-blank-line.js');\n\nvar thematicBreak = require('./thematic-break.js');\n\nvar list = {\n  name: 'list',\n  tokenize: tokenizeListStart,\n  continuation: {\n    tokenize: tokenizeListContinuation\n  },\n  exit: tokenizeListEnd\n};\nvar listItemPrefixWhitespaceConstruct = {\n  tokenize: tokenizeListItemPrefixWhitespace,\n  partial: true\n};\nvar indentConstruct = {\n  tokenize: tokenizeIndent,\n  partial: true\n};\n\nfunction tokenizeListStart(effects, ok, nok) {\n  var self = this;\n  var initialSize = prefixSize(self.events, 'linePrefix');\n  var size = 0;\n  return start;\n\n  function start(code) {\n    var kind = self.containerState.type || (code === 42 || code === 43 || code === 45 ? 'listUnordered' : 'listOrdered');\n\n    if (kind === 'listUnordered' ? !self.containerState.marker || code === self.containerState.marker : asciiDigit(code)) {\n      if (!self.containerState.type) {\n        self.containerState.type = kind;\n        effects.enter(kind, {\n          _container: true\n        });\n      }\n\n      if (kind === 'listUnordered') {\n        effects.enter('listItemPrefix');\n        return code === 42 || code === 45 ? effects.check(thematicBreak, nok, atMarker)(code) : atMarker(code);\n      }\n\n      if (!self.interrupt || code === 49) {\n        effects.enter('listItemPrefix');\n        effects.enter('listItemValue');\n        return inside(code);\n      }\n    }\n\n    return nok(code);\n  }\n\n  function inside(code) {\n    if (asciiDigit(code) && ++size < 10) {\n      effects.consume(code);\n      return inside;\n    }\n\n    if ((!self.interrupt || size < 2) && (self.containerState.marker ? code === self.containerState.marker : code === 41 || code === 46)) {\n      effects.exit('listItemValue');\n      return atMarker(code);\n    }\n\n    return nok(code);\n  }\n\n  function atMarker(code) {\n    effects.enter('listItemMarker');\n    effects.consume(code);\n    effects.exit('listItemMarker');\n    self.containerState.marker = self.containerState.marker || code;\n    return effects.check(partialBlankLine, // Can’t be empty when interrupting.\n    self.interrupt ? nok : onBlank, effects.attempt(listItemPrefixWhitespaceConstruct, endOfPrefix, otherPrefix));\n  }\n\n  function onBlank(code) {\n    self.containerState.initialBlankLine = true;\n    initialSize++;\n    return endOfPrefix(code);\n  }\n\n  function otherPrefix(code) {\n    if (markdownSpace(code)) {\n      effects.enter('listItemPrefixWhitespace');\n      effects.consume(code);\n      effects.exit('listItemPrefixWhitespace');\n      return endOfPrefix;\n    }\n\n    return nok(code);\n  }\n\n  function endOfPrefix(code) {\n    self.containerState.size = initialSize + sizeChunks(self.sliceStream(effects.exit('listItemPrefix')));\n    return ok(code);\n  }\n}\n\nfunction tokenizeListContinuation(effects, ok, nok) {\n  var self = this;\n  self.containerState._closeFlow = undefined;\n  return effects.check(partialBlankLine, onBlank, notBlank);\n\n  function onBlank(code) {\n    self.containerState.furtherBlankLines = self.containerState.furtherBlankLines || self.containerState.initialBlankLine; // We have a blank line.\n    // Still, try to consume at most the items size.\n\n    return factorySpace(effects, ok, 'listItemIndent', self.containerState.size + 1)(code);\n  }\n\n  function notBlank(code) {\n    if (self.containerState.furtherBlankLines || !markdownSpace(code)) {\n      self.containerState.furtherBlankLines = self.containerState.initialBlankLine = undefined;\n      return notInCurrentItem(code);\n    }\n\n    self.containerState.furtherBlankLines = self.containerState.initialBlankLine = undefined;\n    return effects.attempt(indentConstruct, ok, notInCurrentItem)(code);\n  }\n\n  function notInCurrentItem(code) {\n    // While we do continue, we signal that the flow should be closed.\n    self.containerState._closeFlow = true; // As we’re closing flow, we’re no longer interrupting.\n\n    self.interrupt = undefined;\n    return factorySpace(effects, effects.attempt(list, ok, nok), 'linePrefix', self.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4)(code);\n  }\n}\n\nfunction tokenizeIndent(effects, ok, nok) {\n  var self = this;\n  return factorySpace(effects, afterPrefix, 'listItemIndent', self.containerState.size + 1);\n\n  function afterPrefix(code) {\n    return prefixSize(self.events, 'listItemIndent') === self.containerState.size ? ok(code) : nok(code);\n  }\n}\n\nfunction tokenizeListEnd(effects) {\n  effects.exit(this.containerState.type);\n}\n\nfunction tokenizeListItemPrefixWhitespace(effects, ok, nok) {\n  var self = this;\n  return factorySpace(effects, afterPrefix, 'listItemPrefixWhitespace', self.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4 + 1);\n\n  function afterPrefix(code) {\n    return markdownSpace(code) || !prefixSize(self.events, 'listItemPrefixWhitespace') ? nok(code) : ok(code);\n  }\n}\n\nmodule.exports = list;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar partialBlankLine = {\n  tokenize: tokenizePartialBlankLine,\n  partial: true\n};\n\nfunction tokenizePartialBlankLine(effects, ok, nok) {\n  return factorySpace(effects, afterWhitespace, 'linePrefix');\n\n  function afterWhitespace(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}\n\nmodule.exports = partialBlankLine;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar shallow = require('../util/shallow.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar setextUnderline = {\n  name: 'setextUnderline',\n  tokenize: tokenizeSetextUnderline,\n  resolveTo: resolveToSetextUnderline\n};\n\nfunction resolveToSetextUnderline(events, context) {\n  var index = events.length;\n  var content;\n  var text;\n  var definition;\n  var heading; // Find the opening of the content.\n  // It’ll always exist: we don’t tokenize if it isn’t there.\n\n  while (index--) {\n    if (events[index][0] === 'enter') {\n      if (events[index][1].type === 'content') {\n        content = index;\n        break;\n      }\n\n      if (events[index][1].type === 'paragraph') {\n        text = index;\n      }\n    } // Exit\n    else {\n      if (events[index][1].type === 'content') {\n        // Remove the content end (if needed we’ll add it later)\n        events.splice(index, 1);\n      }\n\n      if (!definition && events[index][1].type === 'definition') {\n        definition = index;\n      }\n    }\n  }\n\n  heading = {\n    type: 'setextHeading',\n    start: shallow(events[text][1].start),\n    end: shallow(events[events.length - 1][1].end)\n  }; // Change the paragraph to setext heading text.\n\n  events[text][1].type = 'setextHeadingText'; // If we have definitions in the content, we’ll keep on having content,\n  // but we need move it.\n\n  if (definition) {\n    events.splice(text, 0, ['enter', heading, context]);\n    events.splice(definition + 1, 0, ['exit', events[content][1], context]);\n    events[content][1].end = shallow(events[definition][1].end);\n  } else {\n    events[content][1] = heading;\n  } // Add the heading exit at the end.\n\n\n  events.push(['exit', heading, context]);\n  return events;\n}\n\nfunction tokenizeSetextUnderline(effects, ok, nok) {\n  var self = this;\n  var index = self.events.length;\n  var marker;\n  var paragraph; // Find an opening.\n\n  while (index--) {\n    // Skip enter/exit of line ending, line prefix, and content.\n    // We can now either have a definition or a paragraph.\n    if (self.events[index][1].type !== 'lineEnding' && self.events[index][1].type !== 'linePrefix' && self.events[index][1].type !== 'content') {\n      paragraph = self.events[index][1].type === 'paragraph';\n      break;\n    }\n  }\n\n  return start;\n\n  function start(code) {\n    if (!self.lazy && (self.interrupt || paragraph)) {\n      effects.enter('setextHeadingLine');\n      effects.enter('setextHeadingLineSequence');\n      marker = code;\n      return closingSequence(code);\n    }\n\n    return nok(code);\n  }\n\n  function closingSequence(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return closingSequence;\n    }\n\n    effects.exit('setextHeadingLineSequence');\n    return factorySpace(effects, closingSequenceEnd, 'lineSuffix')(code);\n  }\n\n  function closingSequenceEnd(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('setextHeadingLine');\n      return ok(code);\n    }\n\n    return nok(code);\n  }\n}\n\nmodule.exports = setextUnderline;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar thematicBreak = {\n  name: 'thematicBreak',\n  tokenize: tokenizeThematicBreak\n};\n\nfunction tokenizeThematicBreak(effects, ok, nok) {\n  var size = 0;\n  var marker;\n  return start;\n\n  function start(code) {\n    effects.enter('thematicBreak');\n    marker = code;\n    return atBreak(code);\n  }\n\n  function atBreak(code) {\n    if (code === marker) {\n      effects.enter('thematicBreakSequence');\n      return sequence(code);\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(effects, atBreak, 'whitespace')(code);\n    }\n\n    if (size < 3 || code !== null && !markdownLineEnding(code)) {\n      return nok(code);\n    }\n\n    effects.exit('thematicBreak');\n    return ok(code);\n  }\n\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code);\n      size++;\n      return sequence;\n    }\n\n    effects.exit('thematicBreakSequence');\n    return atBreak(code);\n  }\n}\n\nmodule.exports = thematicBreak;","'use strict';\n\nvar chunkedSplice = require('./chunked-splice.js');\n\nfunction chunkedPush(list, items) {\n  if (list.length) {\n    chunkedSplice(list, list.length, 0, items);\n    return list;\n  }\n\n  return items;\n}\n\nmodule.exports = chunkedPush;","'use strict';\n\nvar splice = require('../constant/splice.js'); // causes a stack overflow in V8 when trying to insert 100k items for instance.\n\n\nfunction chunkedSplice(list, start, remove, items) {\n  var end = list.length;\n  var chunkStart = 0;\n  var parameters; // Make start between zero and `end` (included).\n\n  if (start < 0) {\n    start = -start > end ? 0 : end + start;\n  } else {\n    start = start > end ? end : start;\n  }\n\n  remove = remove > 0 ? remove : 0; // No need to chunk the items if there’s only a couple (10k) items.\n\n  if (items.length < 10000) {\n    parameters = Array.from(items);\n    parameters.unshift(start, remove);\n    splice.apply(list, parameters);\n  } else {\n    // Delete `remove` items starting from `start`\n    if (remove) splice.apply(list, [start, remove]); // Insert the items in chunks to not cause stack overflows.\n\n    while (chunkStart < items.length) {\n      parameters = items.slice(chunkStart, chunkStart + 10000);\n      parameters.unshift(start, 0);\n      splice.apply(list, parameters);\n      chunkStart += 10000;\n      start += 10000;\n    }\n  }\n}\n\nmodule.exports = chunkedSplice;","'use strict';\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\n\nvar unicodePunctuation = require('../character/unicode-punctuation.js');\n\nvar unicodeWhitespace = require('../character/unicode-whitespace.js'); // Classify whether a character is unicode whitespace, unicode punctuation, or\n// anything else.\n// Used for attention (emphasis, strong), whose sequences can open or close\n// based on the class of surrounding characters.\n\n\nfunction classifyCharacter(code) {\n  if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {\n    return 1;\n  }\n\n  if (unicodePunctuation(code)) {\n    return 2;\n  }\n}\n\nmodule.exports = classifyCharacter;","'use strict';\n\nvar hasOwnProperty = require('../constant/has-own-property.js');\n\nvar chunkedSplice = require('./chunked-splice.js');\n\nvar miniflat = require('./miniflat.js');\n\nfunction combineExtensions(extensions) {\n  var all = {};\n  var index = -1;\n\n  while (++index < extensions.length) {\n    extension(all, extensions[index]);\n  }\n\n  return all;\n}\n\nfunction extension(all, extension) {\n  var hook;\n  var left;\n  var right;\n  var code;\n\n  for (hook in extension) {\n    left = hasOwnProperty.call(all, hook) ? all[hook] : all[hook] = {};\n    right = extension[hook];\n\n    for (code in right) {\n      left[code] = constructs(miniflat(right[code]), hasOwnProperty.call(left, code) ? left[code] : []);\n    }\n  }\n}\n\nfunction constructs(list, existing) {\n  var index = -1;\n  var before = [];\n\n  while (++index < list.length) {\n    ;\n    (list[index].add === 'after' ? existing : before).push(list[index]);\n  }\n\n  chunkedSplice(existing, 0, 0, before);\n  return existing;\n}\n\nmodule.exports = combineExtensions;","'use strict';\n\nvar assign = require('../constant/assign.js');\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar chunkedPush = require('./chunked-push.js');\n\nvar chunkedSplice = require('./chunked-splice.js');\n\nvar miniflat = require('./miniflat.js');\n\nvar resolveAll = require('./resolve-all.js');\n\nvar serializeChunks = require('./serialize-chunks.js');\n\nvar shallow = require('./shallow.js');\n\nvar sliceChunks = require('./slice-chunks.js'); // Create a tokenizer.\n// Tokenizers deal with one type of data (e.g., containers, flow, text).\n// The parser is the object dealing with it all.\n// `initialize` works like other constructs, except that only its `tokenize`\n// function is used, in which case it doesn’t receive an `ok` or `nok`.\n// `from` can be given to set the point before the first character, although\n// when further lines are indented, they must be set with `defineSkip`.\n\n\nfunction createTokenizer(parser, initialize, from) {\n  var point = from ? shallow(from) : {\n    line: 1,\n    column: 1,\n    offset: 0\n  };\n  var columnStart = {};\n  var resolveAllConstructs = [];\n  var chunks = [];\n  var stack = [];\n  var effects = {\n    consume: consume,\n    enter: enter,\n    exit: exit,\n    attempt: constructFactory(onsuccessfulconstruct),\n    check: constructFactory(onsuccessfulcheck),\n    interrupt: constructFactory(onsuccessfulcheck, {\n      interrupt: true\n    }),\n    lazy: constructFactory(onsuccessfulcheck, {\n      lazy: true\n    })\n  }; // State and tools for resolving and serializing.\n\n  var context = {\n    previous: null,\n    events: [],\n    parser: parser,\n    sliceStream: sliceStream,\n    sliceSerialize: sliceSerialize,\n    now: now,\n    defineSkip: skip,\n    write: write\n  }; // The state function.\n\n  var state = initialize.tokenize.call(context, effects); // Track which character we expect to be consumed, to catch bugs.\n\n  if (initialize.resolveAll) {\n    resolveAllConstructs.push(initialize);\n  } // Store where we are in the input stream.\n\n\n  point._index = 0;\n  point._bufferIndex = -1;\n  return context;\n\n  function write(slice) {\n    chunks = chunkedPush(chunks, slice);\n    main(); // Exit if we’re not done, resolve might change stuff.\n\n    if (chunks[chunks.length - 1] !== null) {\n      return [];\n    }\n\n    addResult(initialize, 0); // Otherwise, resolve, and exit.\n\n    context.events = resolveAll(resolveAllConstructs, context.events, context);\n    return context.events;\n  } //\n  // Tools.\n  //\n\n\n  function sliceSerialize(token) {\n    return serializeChunks(sliceStream(token));\n  }\n\n  function sliceStream(token) {\n    return sliceChunks(chunks, token);\n  }\n\n  function now() {\n    return shallow(point);\n  }\n\n  function skip(value) {\n    columnStart[value.line] = value.column;\n    accountForPotentialSkip();\n  } //\n  // State management.\n  //\n  // Main loop (note that `_index` and `_bufferIndex` in `point` are modified by\n  // `consume`).\n  // Here is where we walk through the chunks, which either include strings of\n  // several characters, or numerical character codes.\n  // The reason to do this in a loop instead of a call is so the stack can\n  // drain.\n\n\n  function main() {\n    var chunkIndex;\n    var chunk;\n\n    while (point._index < chunks.length) {\n      chunk = chunks[point._index]; // If we’re in a buffer chunk, loop through it.\n\n      if (typeof chunk === 'string') {\n        chunkIndex = point._index;\n\n        if (point._bufferIndex < 0) {\n          point._bufferIndex = 0;\n        }\n\n        while (point._index === chunkIndex && point._bufferIndex < chunk.length) {\n          go(chunk.charCodeAt(point._bufferIndex));\n        }\n      } else {\n        go(chunk);\n      }\n    }\n  } // Deal with one code.\n\n\n  function go(code) {\n    state = state(code);\n  } // Move a character forward.\n\n\n  function consume(code) {\n    if (markdownLineEnding(code)) {\n      point.line++;\n      point.column = 1;\n      point.offset += code === -3 ? 2 : 1;\n      accountForPotentialSkip();\n    } else if (code !== -1) {\n      point.column++;\n      point.offset++;\n    } // Not in a string chunk.\n\n\n    if (point._bufferIndex < 0) {\n      point._index++;\n    } else {\n      point._bufferIndex++; // At end of string chunk.\n\n      if (point._bufferIndex === chunks[point._index].length) {\n        point._bufferIndex = -1;\n        point._index++;\n      }\n    } // Expose the previous character.\n\n\n    context.previous = code; // Mark as consumed.\n  } // Start a token.\n\n\n  function enter(type, fields) {\n    var token = fields || {};\n    token.type = type;\n    token.start = now();\n    context.events.push(['enter', token, context]);\n    stack.push(token);\n    return token;\n  } // Stop a token.\n\n\n  function exit(type) {\n    var token = stack.pop();\n    token.end = now();\n    context.events.push(['exit', token, context]);\n    return token;\n  } // Use results.\n\n\n  function onsuccessfulconstruct(construct, info) {\n    addResult(construct, info.from);\n  } // Discard results.\n\n\n  function onsuccessfulcheck(construct, info) {\n    info.restore();\n  } // Factory to attempt/check/interrupt.\n\n\n  function constructFactory(onreturn, fields) {\n    return hook; // Handle either an object mapping codes to constructs, a list of\n    // constructs, or a single construct.\n\n    function hook(constructs, returnState, bogusState) {\n      var listOfConstructs;\n      var constructIndex;\n      var currentConstruct;\n      var info;\n      return constructs.tokenize || 'length' in constructs ? handleListOfConstructs(miniflat(constructs)) : handleMapOfConstructs;\n\n      function handleMapOfConstructs(code) {\n        if (code in constructs || null in constructs) {\n          return handleListOfConstructs(constructs.null ?\n          /* c8 ignore next */\n          miniflat(constructs[code]).concat(miniflat(constructs.null)) : constructs[code])(code);\n        }\n\n        return bogusState(code);\n      }\n\n      function handleListOfConstructs(list) {\n        listOfConstructs = list;\n        constructIndex = 0;\n        return handleConstruct(list[constructIndex]);\n      }\n\n      function handleConstruct(construct) {\n        return start;\n\n        function start(code) {\n          // To do: not nede to store if there is no bogus state, probably?\n          // Currently doesn’t work because `inspect` in document does a check\n          // w/o a bogus, which doesn’t make sense. But it does seem to help perf\n          // by not storing.\n          info = store();\n          currentConstruct = construct;\n\n          if (!construct.partial) {\n            context.currentConstruct = construct;\n          }\n\n          if (construct.name && context.parser.constructs.disable.null.indexOf(construct.name) > -1) {\n            return nok();\n          }\n\n          return construct.tokenize.call(fields ? assign({}, context, fields) : context, effects, ok, nok)(code);\n        }\n      }\n\n      function ok(code) {\n        onreturn(currentConstruct, info);\n        return returnState;\n      }\n\n      function nok(code) {\n        info.restore();\n\n        if (++constructIndex < listOfConstructs.length) {\n          return handleConstruct(listOfConstructs[constructIndex]);\n        }\n\n        return bogusState;\n      }\n    }\n  }\n\n  function addResult(construct, from) {\n    if (construct.resolveAll && resolveAllConstructs.indexOf(construct) < 0) {\n      resolveAllConstructs.push(construct);\n    }\n\n    if (construct.resolve) {\n      chunkedSplice(context.events, from, context.events.length - from, construct.resolve(context.events.slice(from), context));\n    }\n\n    if (construct.resolveTo) {\n      context.events = construct.resolveTo(context.events, context);\n    }\n  }\n\n  function store() {\n    var startPoint = now();\n    var startPrevious = context.previous;\n    var startCurrentConstruct = context.currentConstruct;\n    var startEventsIndex = context.events.length;\n    var startStack = Array.from(stack);\n    return {\n      restore: restore,\n      from: startEventsIndex\n    };\n\n    function restore() {\n      point = startPoint;\n      context.previous = startPrevious;\n      context.currentConstruct = startCurrentConstruct;\n      context.events.length = startEventsIndex;\n      stack = startStack;\n      accountForPotentialSkip();\n    }\n  }\n\n  function accountForPotentialSkip() {\n    if (point.line in columnStart && point.column < 2) {\n      point.column = columnStart[point.line];\n      point.offset += columnStart[point.line] - 1;\n    }\n  }\n}\n\nmodule.exports = createTokenizer;","'use strict';\n\nfunction miniflat(value) {\n  return value === null || value === undefined ? [] : 'length' in value ? value : [value];\n}\n\nmodule.exports = miniflat;","'use strict'; // chunks (replacement characters, tabs, or line endings).\n\nfunction movePoint(point, offset) {\n  point.column += offset;\n  point.offset += offset;\n  point._bufferIndex += offset;\n  return point;\n}\n\nmodule.exports = movePoint;","'use strict';\n\nfunction normalizeIdentifier(value) {\n  return value // Collapse Markdown whitespace.\n  .replace(/[\\t\\n\\r ]+/g, ' ') // Trim.\n  .replace(/^ | $/g, '') // Some characters are considered “uppercase”, but if their lowercase\n  // counterpart is uppercased will result in a different uppercase\n  // character.\n  // Hence, to get that form, we perform both lower- and uppercase.\n  // Upper case makes sure keys will not interact with default prototypal\n  // methods: no object method is uppercase.\n  .toLowerCase().toUpperCase();\n}\n\nmodule.exports = normalizeIdentifier;","'use strict';\n\nvar sizeChunks = require('./size-chunks.js');\n\nfunction prefixSize(events, type) {\n  var tail = events[events.length - 1];\n  if (!tail || tail[1].type !== type) return 0;\n  return sizeChunks(tail[2].sliceStream(tail[1]));\n}\n\nmodule.exports = prefixSize;","'use strict';\n\nvar fromCharCode = require('../constant/from-char-code.js');\n\nfunction regexCheck(regex) {\n  return check;\n\n  function check(code) {\n    return regex.test(fromCharCode(code));\n  }\n}\n\nmodule.exports = regexCheck;","'use strict';\n\nfunction resolveAll(constructs, events, context) {\n  var called = [];\n  var index = -1;\n  var resolve;\n\n  while (++index < constructs.length) {\n    resolve = constructs[index].resolveAll;\n\n    if (resolve && called.indexOf(resolve) < 0) {\n      events = resolve(events, context);\n      called.push(resolve);\n    }\n  }\n\n  return events;\n}\n\nmodule.exports = resolveAll;","'use strict';\n\nvar fromCharCode = require('../constant/from-char-code.js');\n\nfunction safeFromInt(value, base) {\n  var code = parseInt(value, base);\n\n  if ( // C0 except for HT, LF, FF, CR, space\n  code < 9 || code === 11 || code > 13 && code < 32 || // Control character (DEL) of the basic block and C1 controls.\n  code > 126 && code < 160 || // Lone high surrogates and low surrogates.\n  code > 55295 && code < 57344 || // Noncharacters.\n  code > 64975 && code < 65008 || (code & 65535) === 65535 || (code & 65535) === 65534 || // Out of range\n  code > 1114111) {\n    return \"\\uFFFD\";\n  }\n\n  return fromCharCode(code);\n}\n\nmodule.exports = safeFromInt;","'use strict';\n\nvar fromCharCode = require('../constant/from-char-code.js');\n\nfunction serializeChunks(chunks) {\n  var index = -1;\n  var result = [];\n  var chunk;\n  var value;\n  var atTab;\n\n  while (++index < chunks.length) {\n    chunk = chunks[index];\n\n    if (typeof chunk === 'string') {\n      value = chunk;\n    } else if (chunk === -5) {\n      value = '\\r';\n    } else if (chunk === -4) {\n      value = '\\n';\n    } else if (chunk === -3) {\n      value = '\\r' + '\\n';\n    } else if (chunk === -2) {\n      value = '\\t';\n    } else if (chunk === -1) {\n      if (atTab) continue;\n      value = ' ';\n    } else {\n      // Currently only replacement character.\n      value = fromCharCode(chunk);\n    }\n\n    atTab = chunk === -2;\n    result.push(value);\n  }\n\n  return result.join('');\n}\n\nmodule.exports = serializeChunks;","'use strict';\n\nvar assign = require('../constant/assign.js');\n\nfunction shallow(object) {\n  return assign({}, object);\n}\n\nmodule.exports = shallow;","'use strict'; // Counts tabs based on their expanded size, and CR+LF as one character.\n\nfunction sizeChunks(chunks) {\n  var index = -1;\n  var size = 0;\n\n  while (++index < chunks.length) {\n    size += typeof chunks[index] === 'string' ? chunks[index].length : 1;\n  }\n\n  return size;\n}\n\nmodule.exports = sizeChunks;","'use strict';\n\nfunction sliceChunks(chunks, token) {\n  var startIndex = token.start._index;\n  var startBufferIndex = token.start._bufferIndex;\n  var endIndex = token.end._index;\n  var endBufferIndex = token.end._bufferIndex;\n  var view;\n\n  if (startIndex === endIndex) {\n    view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)];\n  } else {\n    view = chunks.slice(startIndex, endIndex);\n\n    if (startBufferIndex > -1) {\n      view[0] = view[0].slice(startBufferIndex);\n    }\n\n    if (endBufferIndex > 0) {\n      view.push(chunks[endIndex].slice(0, endBufferIndex));\n    }\n  }\n\n  return view;\n}\n\nmodule.exports = sliceChunks;","'use strict';\n\nvar assign = require('../constant/assign.js');\n\nvar chunkedSplice = require('./chunked-splice.js');\n\nvar shallow = require('./shallow.js');\n\nfunction subtokenize(events) {\n  var jumps = {};\n  var index = -1;\n  var event;\n  var lineIndex;\n  var otherIndex;\n  var otherEvent;\n  var parameters;\n  var subevents;\n  var more;\n\n  while (++index < events.length) {\n    while (index in jumps) {\n      index = jumps[index];\n    }\n\n    event = events[index]; // Add a hook for the GFM tasklist extension, which needs to know if text\n    // is in the first content of a list item.\n\n    if (index && event[1].type === 'chunkFlow' && events[index - 1][1].type === 'listItemPrefix') {\n      subevents = event[1]._tokenizer.events;\n      otherIndex = 0;\n\n      if (otherIndex < subevents.length && subevents[otherIndex][1].type === 'lineEndingBlank') {\n        otherIndex += 2;\n      }\n\n      if (otherIndex < subevents.length && subevents[otherIndex][1].type === 'content') {\n        while (++otherIndex < subevents.length) {\n          if (subevents[otherIndex][1].type === 'content') {\n            break;\n          }\n\n          if (subevents[otherIndex][1].type === 'chunkText') {\n            subevents[otherIndex][1].isInFirstContentOfListItem = true;\n            otherIndex++;\n          }\n        }\n      }\n    } // Enter.\n\n\n    if (event[0] === 'enter') {\n      if (event[1].contentType) {\n        assign(jumps, subcontent(events, index));\n        index = jumps[index];\n        more = true;\n      }\n    } // Exit.\n    else if (event[1]._container || event[1]._movePreviousLineEndings) {\n      otherIndex = index;\n      lineIndex = undefined;\n\n      while (otherIndex--) {\n        otherEvent = events[otherIndex];\n\n        if (otherEvent[1].type === 'lineEnding' || otherEvent[1].type === 'lineEndingBlank') {\n          if (otherEvent[0] === 'enter') {\n            if (lineIndex) {\n              events[lineIndex][1].type = 'lineEndingBlank';\n            }\n\n            otherEvent[1].type = 'lineEnding';\n            lineIndex = otherIndex;\n          }\n        } else {\n          break;\n        }\n      }\n\n      if (lineIndex) {\n        // Fix position.\n        event[1].end = shallow(events[lineIndex][1].start); // Switch container exit w/ line endings.\n\n        parameters = events.slice(lineIndex, index);\n        parameters.unshift(event);\n        chunkedSplice(events, lineIndex, index - lineIndex + 1, parameters);\n      }\n    }\n  }\n\n  return !more;\n}\n\nfunction subcontent(events, eventIndex) {\n  var token = events[eventIndex][1];\n  var context = events[eventIndex][2];\n  var startPosition = eventIndex - 1;\n  var startPositions = [];\n  var tokenizer = token._tokenizer || context.parser[token.contentType](token.start);\n  var childEvents = tokenizer.events;\n  var jumps = [];\n  var gaps = {};\n  var stream;\n  var previous;\n  var index;\n  var entered;\n  var end;\n  var adjust; // Loop forward through the linked tokens to pass them in order to the\n  // subtokenizer.\n\n  while (token) {\n    // Find the position of the event for this token.\n    while (events[++startPosition][1] !== token) {// Empty.\n    }\n\n    startPositions.push(startPosition);\n\n    if (!token._tokenizer) {\n      stream = context.sliceStream(token);\n\n      if (!token.next) {\n        stream.push(null);\n      }\n\n      if (previous) {\n        tokenizer.defineSkip(token.start);\n      }\n\n      if (token.isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = true;\n      }\n\n      tokenizer.write(stream);\n\n      if (token.isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = undefined;\n      }\n    } // Unravel the next token.\n\n\n    previous = token;\n    token = token.next;\n  } // Now, loop back through all events (and linked tokens), to figure out which\n  // parts belong where.\n\n\n  token = previous;\n  index = childEvents.length;\n\n  while (index--) {\n    // Make sure we’ve at least seen something (final eol is part of the last\n    // token).\n    if (childEvents[index][0] === 'enter') {\n      entered = true;\n    } else if ( // Find a void token that includes a break.\n    entered && childEvents[index][1].type === childEvents[index - 1][1].type && childEvents[index][1].start.line !== childEvents[index][1].end.line) {\n      add(childEvents.slice(index + 1, end)); // Help GC.\n\n      token._tokenizer = token.next = undefined;\n      token = token.previous;\n      end = index + 1;\n    }\n  } // Help GC.\n\n\n  tokenizer.events = token._tokenizer = token.next = undefined; // Do head:\n\n  add(childEvents.slice(0, end));\n  index = -1;\n  adjust = 0;\n\n  while (++index < jumps.length) {\n    gaps[adjust + jumps[index][0]] = adjust + jumps[index][1];\n    adjust += jumps[index][1] - jumps[index][0] - 1;\n  }\n\n  return gaps;\n\n  function add(slice) {\n    var start = startPositions.pop();\n    jumps.unshift([start, start + slice.length - 1]);\n    chunkedSplice(events, start, 2, slice);\n  }\n}\n\nmodule.exports = subtokenize;","'use strict';\n/* eslint-env browser */\n\nvar el;\nvar semicolon = 59; //  ';'\n\nmodule.exports = decodeEntity;\n\nfunction decodeEntity(characters) {\n  var entity = '&' + characters + ';';\n  var char;\n  el = el || document.createElement('i');\n  el.innerHTML = entity;\n  char = el.textContent; // Some entities do not require the closing semicolon (`&not` - for instance),\n  // which leads to situations where parsing the assumed entity of &notit; will\n  // result in the string `¬it;`.  When we encounter a trailing semicolon after\n  // parsing and the entity to decode was not a semicolon (`&semi;`), we can\n  // assume that the matching was incomplete\n\n  if (char.charCodeAt(char.length - 1) === semicolon && characters !== 'semi') {\n    return false;\n  } // If the decoded string is equal to the input, the entity was not valid\n\n\n  return char === entity ? false : char;\n}","'use strict';\n\nmodule.exports = parse;\n\nvar fromMarkdown = require('mdast-util-from-markdown');\n\nfunction parse(options) {\n  var self = this;\n  this.Parser = parse;\n\n  function parse(doc) {\n    return fromMarkdown(doc, Object.assign({}, self.data('settings'), options, {\n      // Note: these options are not in the readme.\n      // The goal is for them to be set by plugins on `data` instead of being\n      // passed by users.\n      extensions: self.data('micromarkExtensions') || [],\n      mdastExtensions: self.data('fromMarkdownExtensions') || []\n    }));\n  }\n}","'use strict';\n\nvar bail = require('bail');\n\nvar buffer = require('is-buffer');\n\nvar extend = require('extend');\n\nvar plain = require('is-plain-obj');\n\nvar trough = require('trough');\n\nvar vfile = require('vfile'); // Expose a frozen processor.\n\n\nmodule.exports = unified().freeze();\nvar slice = [].slice;\nvar own = {}.hasOwnProperty; // Process pipeline.\n\nvar pipeline = trough().use(pipelineParse).use(pipelineRun).use(pipelineStringify);\n\nfunction pipelineParse(p, ctx) {\n  ctx.tree = p.parse(ctx.file);\n}\n\nfunction pipelineRun(p, ctx, next) {\n  p.run(ctx.tree, ctx.file, done);\n\n  function done(error, tree, file) {\n    if (error) {\n      next(error);\n    } else {\n      ctx.tree = tree;\n      ctx.file = file;\n      next();\n    }\n  }\n}\n\nfunction pipelineStringify(p, ctx) {\n  var result = p.stringify(ctx.tree, ctx.file);\n\n  if (result === undefined || result === null) {// Empty.\n  } else if (typeof result === 'string' || buffer(result)) {\n    if ('value' in ctx.file) {\n      ctx.file.value = result;\n    }\n\n    ctx.file.contents = result;\n  } else {\n    ctx.file.result = result;\n  }\n} // Function to create the first processor.\n\n\nfunction unified() {\n  var attachers = [];\n  var transformers = trough();\n  var namespace = {};\n  var freezeIndex = -1;\n  var frozen; // Data management.\n\n  processor.data = data; // Lock.\n\n  processor.freeze = freeze; // Plugins.\n\n  processor.attachers = attachers;\n  processor.use = use; // API.\n\n  processor.parse = parse;\n  processor.stringify = stringify;\n  processor.run = run;\n  processor.runSync = runSync;\n  processor.process = process;\n  processor.processSync = processSync; // Expose.\n\n  return processor; // Create a new processor based on the processor in the current scope.\n\n  function processor() {\n    var destination = unified();\n    var index = -1;\n\n    while (++index < attachers.length) {\n      destination.use.apply(null, attachers[index]);\n    }\n\n    destination.data(extend(true, {}, namespace));\n    return destination;\n  } // Freeze: used to signal a processor that has finished configuration.\n  //\n  // For example, take unified itself: it’s frozen.\n  // Plugins should not be added to it.\n  // Rather, it should be extended, by invoking it, before modifying it.\n  //\n  // In essence, always invoke this when exporting a processor.\n\n\n  function freeze() {\n    var values;\n    var transformer;\n\n    if (frozen) {\n      return processor;\n    }\n\n    while (++freezeIndex < attachers.length) {\n      values = attachers[freezeIndex];\n\n      if (values[1] === false) {\n        continue;\n      }\n\n      if (values[1] === true) {\n        values[1] = undefined;\n      }\n\n      transformer = values[0].apply(processor, values.slice(1));\n\n      if (typeof transformer === 'function') {\n        transformers.use(transformer);\n      }\n    }\n\n    frozen = true;\n    freezeIndex = Infinity;\n    return processor;\n  } // Data management.\n  // Getter / setter for processor-specific informtion.\n\n\n  function data(key, value) {\n    if (typeof key === 'string') {\n      // Set `key`.\n      if (arguments.length === 2) {\n        assertUnfrozen('data', frozen);\n        namespace[key] = value;\n        return processor;\n      } // Get `key`.\n\n\n      return own.call(namespace, key) && namespace[key] || null;\n    } // Set space.\n\n\n    if (key) {\n      assertUnfrozen('data', frozen);\n      namespace = key;\n      return processor;\n    } // Get space.\n\n\n    return namespace;\n  } // Plugin management.\n  //\n  // Pass it:\n  // *   an attacher and options,\n  // *   a preset,\n  // *   a list of presets, attachers, and arguments (list of attachers and\n  //     options).\n\n\n  function use(value) {\n    var settings;\n    assertUnfrozen('use', frozen);\n\n    if (value === null || value === undefined) {// Empty.\n    } else if (typeof value === 'function') {\n      addPlugin.apply(null, arguments);\n    } else if (typeof value === 'object') {\n      if ('length' in value) {\n        addList(value);\n      } else {\n        addPreset(value);\n      }\n    } else {\n      throw new Error('Expected usable value, not `' + value + '`');\n    }\n\n    if (settings) {\n      namespace.settings = extend(namespace.settings || {}, settings);\n    }\n\n    return processor;\n\n    function addPreset(result) {\n      addList(result.plugins);\n\n      if (result.settings) {\n        settings = extend(settings || {}, result.settings);\n      }\n    }\n\n    function add(value) {\n      if (typeof value === 'function') {\n        addPlugin(value);\n      } else if (typeof value === 'object') {\n        if ('length' in value) {\n          addPlugin.apply(null, value);\n        } else {\n          addPreset(value);\n        }\n      } else {\n        throw new Error('Expected usable value, not `' + value + '`');\n      }\n    }\n\n    function addList(plugins) {\n      var index = -1;\n\n      if (plugins === null || plugins === undefined) {// Empty.\n      } else if (typeof plugins === 'object' && 'length' in plugins) {\n        while (++index < plugins.length) {\n          add(plugins[index]);\n        }\n      } else {\n        throw new Error('Expected a list of plugins, not `' + plugins + '`');\n      }\n    }\n\n    function addPlugin(plugin, value) {\n      var entry = find(plugin);\n\n      if (entry) {\n        if (plain(entry[1]) && plain(value)) {\n          value = extend(true, entry[1], value);\n        }\n\n        entry[1] = value;\n      } else {\n        attachers.push(slice.call(arguments));\n      }\n    }\n  }\n\n  function find(plugin) {\n    var index = -1;\n\n    while (++index < attachers.length) {\n      if (attachers[index][0] === plugin) {\n        return attachers[index];\n      }\n    }\n  } // Parse a file (in string or vfile representation) into a unist node using\n  // the `Parser` on the processor.\n\n\n  function parse(doc) {\n    var file = vfile(doc);\n    var Parser;\n    freeze();\n    Parser = processor.Parser;\n    assertParser('parse', Parser);\n\n    if (newable(Parser, 'parse')) {\n      return new Parser(String(file), file).parse();\n    }\n\n    return Parser(String(file), file); // eslint-disable-line new-cap\n  } // Run transforms on a unist node representation of a file (in string or\n  // vfile representation), async.\n\n\n  function run(node, file, cb) {\n    assertNode(node);\n    freeze();\n\n    if (!cb && typeof file === 'function') {\n      cb = file;\n      file = null;\n    }\n\n    if (!cb) {\n      return new Promise(executor);\n    }\n\n    executor(null, cb);\n\n    function executor(resolve, reject) {\n      transformers.run(node, vfile(file), done);\n\n      function done(error, tree, file) {\n        tree = tree || node;\n\n        if (error) {\n          reject(error);\n        } else if (resolve) {\n          resolve(tree);\n        } else {\n          cb(null, tree, file);\n        }\n      }\n    }\n  } // Run transforms on a unist node representation of a file (in string or\n  // vfile representation), sync.\n\n\n  function runSync(node, file) {\n    var result;\n    var complete;\n    run(node, file, done);\n    assertDone('runSync', 'run', complete);\n    return result;\n\n    function done(error, tree) {\n      complete = true;\n      result = tree;\n      bail(error);\n    }\n  } // Stringify a unist node representation of a file (in string or vfile\n  // representation) into a string using the `Compiler` on the processor.\n\n\n  function stringify(node, doc) {\n    var file = vfile(doc);\n    var Compiler;\n    freeze();\n    Compiler = processor.Compiler;\n    assertCompiler('stringify', Compiler);\n    assertNode(node);\n\n    if (newable(Compiler, 'compile')) {\n      return new Compiler(node, file).compile();\n    }\n\n    return Compiler(node, file); // eslint-disable-line new-cap\n  } // Parse a file (in string or vfile representation) into a unist node using\n  // the `Parser` on the processor, then run transforms on that node, and\n  // compile the resulting node using the `Compiler` on the processor, and\n  // store that result on the vfile.\n\n\n  function process(doc, cb) {\n    freeze();\n    assertParser('process', processor.Parser);\n    assertCompiler('process', processor.Compiler);\n\n    if (!cb) {\n      return new Promise(executor);\n    }\n\n    executor(null, cb);\n\n    function executor(resolve, reject) {\n      var file = vfile(doc);\n      pipeline.run(processor, {\n        file: file\n      }, done);\n\n      function done(error) {\n        if (error) {\n          reject(error);\n        } else if (resolve) {\n          resolve(file);\n        } else {\n          cb(null, file);\n        }\n      }\n    }\n  } // Process the given document (in string or vfile representation), sync.\n\n\n  function processSync(doc) {\n    var file;\n    var complete;\n    freeze();\n    assertParser('processSync', processor.Parser);\n    assertCompiler('processSync', processor.Compiler);\n    file = vfile(doc);\n    process(file, done);\n    assertDone('processSync', 'process', complete);\n    return file;\n\n    function done(error) {\n      complete = true;\n      bail(error);\n    }\n  }\n} // Check if `value` is a constructor.\n\n\nfunction newable(value, name) {\n  return typeof value === 'function' && value.prototype && ( // A function with keys in its prototype is probably a constructor.\n  // Classes’ prototype methods are not enumerable, so we check if some value\n  // exists in the prototype.\n  keys(value.prototype) || name in value.prototype);\n} // Check if `value` is an object with keys.\n\n\nfunction keys(value) {\n  var key;\n\n  for (key in value) {\n    return true;\n  }\n\n  return false;\n} // Assert a parser is available.\n\n\nfunction assertParser(name, Parser) {\n  if (typeof Parser !== 'function') {\n    throw new Error('Cannot `' + name + '` without `Parser`');\n  }\n} // Assert a compiler is available.\n\n\nfunction assertCompiler(name, Compiler) {\n  if (typeof Compiler !== 'function') {\n    throw new Error('Cannot `' + name + '` without `Compiler`');\n  }\n} // Assert the processor is not frozen.\n\n\nfunction assertUnfrozen(name, frozen) {\n  if (frozen) {\n    throw new Error('Cannot invoke `' + name + '` on a frozen processor.\\nCreate a new processor first, by invoking it: use `processor()` instead of `processor`.');\n  }\n} // Assert `node` is a unist node.\n\n\nfunction assertNode(node) {\n  if (!node || typeof node.type !== 'string') {\n    throw new Error('Expected node, got `' + node + '`');\n  }\n} // Assert that `complete` is `true`.\n\n\nfunction assertDone(name, asyncName, complete) {\n  if (!complete) {\n    throw new Error('`' + name + '` finished async. Use `' + asyncName + '` instead');\n  }\n}","'use strict';\n\nvar own = {}.hasOwnProperty;\nmodule.exports = stringify;\n\nfunction stringify(value) {\n  // Nothing.\n  if (!value || typeof value !== 'object') {\n    return '';\n  } // Node.\n\n\n  if (own.call(value, 'position') || own.call(value, 'type')) {\n    return position(value.position);\n  } // Position.\n\n\n  if (own.call(value, 'start') || own.call(value, 'end')) {\n    return position(value);\n  } // Point.\n\n\n  if (own.call(value, 'line') || own.call(value, 'column')) {\n    return point(value);\n  } // ?\n\n\n  return '';\n}\n\nfunction point(point) {\n  if (!point || typeof point !== 'object') {\n    point = {};\n  }\n\n  return index(point.line) + ':' + index(point.column);\n}\n\nfunction position(pos) {\n  if (!pos || typeof pos !== 'object') {\n    pos = {};\n  }\n\n  return point(pos.start) + '-' + point(pos.end);\n}\n\nfunction index(value) {\n  return value && typeof value === 'number' ? value : 1;\n}","'use strict';\n\nvar wrap = require('./wrap.js');\n\nmodule.exports = trough;\ntrough.wrap = wrap;\nvar slice = [].slice; // Create new middleware.\n\nfunction trough() {\n  var fns = [];\n  var middleware = {};\n  middleware.run = run;\n  middleware.use = use;\n  return middleware; // Run `fns`.  Last argument must be a completion handler.\n\n  function run() {\n    var index = -1;\n    var input = slice.call(arguments, 0, -1);\n    var done = arguments[arguments.length - 1];\n\n    if (typeof done !== 'function') {\n      throw new Error('Expected function as last argument, not ' + done);\n    }\n\n    next.apply(null, [null].concat(input)); // Run the next `fn`, if any.\n\n    function next(err) {\n      var fn = fns[++index];\n      var params = slice.call(arguments, 0);\n      var values = params.slice(1);\n      var length = input.length;\n      var pos = -1;\n\n      if (err) {\n        done(err);\n        return;\n      } // Copy non-nully input into values.\n\n\n      while (++pos < length) {\n        if (values[pos] === null || values[pos] === undefined) {\n          values[pos] = input[pos];\n        }\n      }\n\n      input = values; // Next or done.\n\n      if (fn) {\n        wrap(fn, next).apply(null, input);\n      } else {\n        done.apply(null, [null].concat(input));\n      }\n    }\n  } // Add `fn` to the list.\n\n\n  function use(fn) {\n    if (typeof fn !== 'function') {\n      throw new Error('Expected `fn` to be a function, not ' + fn);\n    }\n\n    fns.push(fn);\n    return middleware;\n  }\n}","'use strict';\n\nvar slice = [].slice;\nmodule.exports = wrap; // Wrap `fn`.\n// Can be sync or async; return a promise, receive a completion handler, return\n// new values and errors.\n\nfunction wrap(fn, callback) {\n  var invoked;\n  return wrapped;\n\n  function wrapped() {\n    var params = slice.call(arguments, 0);\n    var callback = fn.length > params.length;\n    var result;\n\n    if (callback) {\n      params.push(done);\n    }\n\n    try {\n      result = fn.apply(null, params);\n    } catch (error) {\n      // Well, this is quite the pickle.\n      // `fn` received a callback and invoked it (thus continuing the pipeline),\n      // but later also threw an error.\n      // We’re not about to restart the pipeline again, so the only thing left\n      // to do is to throw the thing instead.\n      if (callback && invoked) {\n        throw error;\n      }\n\n      return done(error);\n    }\n\n    if (!callback) {\n      if (result && typeof result.then === 'function') {\n        result.then(then, done);\n      } else if (result instanceof Error) {\n        done(result);\n      } else {\n        then(result);\n      }\n    }\n  } // Invoke `next`, only once.\n\n\n  function done() {\n    if (!invoked) {\n      invoked = true;\n      callback.apply(null, arguments);\n    }\n  } // Invoke `done` with one value.\n  // Tracks if an error is passed, too.\n\n\n  function then(value) {\n    done(null, value);\n  }\n}","'use strict';\n\nmodule.exports = visit;\n\nvar visitParents = require('unist-util-visit-parents');\n\nvar CONTINUE = visitParents.CONTINUE;\nvar SKIP = visitParents.SKIP;\nvar EXIT = visitParents.EXIT;\nvisit.CONTINUE = CONTINUE;\nvisit.SKIP = SKIP;\nvisit.EXIT = EXIT;\n\nfunction visit(tree, test, visitor, reverse) {\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor;\n    visitor = test;\n    test = null;\n  }\n\n  visitParents(tree, test, overload, reverse);\n\n  function overload(node, parents) {\n    var parent = parents[parents.length - 1];\n    var index = parent ? parent.children.indexOf(node) : null;\n    return visitor(node, index, parent);\n  }\n}","'use strict';\n\nmodule.exports = convert;\n\nfunction convert(test) {\n  if (test == null) {\n    return ok;\n  }\n\n  if (typeof test === 'string') {\n    return typeFactory(test);\n  }\n\n  if (typeof test === 'object') {\n    return 'length' in test ? anyFactory(test) : allFactory(test);\n  }\n\n  if (typeof test === 'function') {\n    return test;\n  }\n\n  throw new Error('Expected function, string, or object as test');\n} // Utility assert each property in `test` is represented in `node`, and each\n// values are strictly equal.\n\n\nfunction allFactory(test) {\n  return all;\n\n  function all(node) {\n    var key;\n\n    for (key in test) {\n      if (node[key] !== test[key]) return false;\n    }\n\n    return true;\n  }\n}\n\nfunction anyFactory(tests) {\n  var checks = [];\n  var index = -1;\n\n  while (++index < tests.length) {\n    checks[index] = convert(tests[index]);\n  }\n\n  return any;\n\n  function any() {\n    var index = -1;\n\n    while (++index < checks.length) {\n      if (checks[index].apply(this, arguments)) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n} // Utility to convert a string into a function which checks a given node’s type\n// for said string.\n\n\nfunction typeFactory(test) {\n  return type;\n\n  function type(node) {\n    return Boolean(node && node.type === test);\n  }\n} // Utility to return true.\n\n\nfunction ok() {\n  return true;\n}","module.exports = identity;\n\nfunction identity(d) {\n  return d;\n}","'use strict';\n\nmodule.exports = visitParents;\n\nvar convert = require('unist-util-is/convert');\n\nvar color = require('./color');\n\nvar CONTINUE = true;\nvar SKIP = 'skip';\nvar EXIT = false;\nvisitParents.CONTINUE = CONTINUE;\nvisitParents.SKIP = SKIP;\nvisitParents.EXIT = EXIT;\n\nfunction visitParents(tree, test, visitor, reverse) {\n  var step;\n  var is;\n\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor;\n    visitor = test;\n    test = null;\n  }\n\n  is = convert(test);\n  step = reverse ? -1 : 1;\n  factory(tree, null, [])();\n\n  function factory(node, index, parents) {\n    var value = typeof node === 'object' && node !== null ? node : {};\n    var name;\n\n    if (typeof value.type === 'string') {\n      name = typeof value.tagName === 'string' ? value.tagName : typeof value.name === 'string' ? value.name : undefined;\n      visit.displayName = 'node (' + color(value.type + (name ? '<' + name + '>' : '')) + ')';\n    }\n\n    return visit;\n\n    function visit() {\n      var grandparents = parents.concat(node);\n      var result = [];\n      var subresult;\n      var offset;\n\n      if (!test || is(node, index, parents[parents.length - 1] || null)) {\n        result = toResult(visitor(node, parents));\n\n        if (result[0] === EXIT) {\n          return result;\n        }\n      }\n\n      if (node.children && result[0] !== SKIP) {\n        offset = (reverse ? node.children.length : -1) + step;\n\n        while (offset > -1 && offset < node.children.length) {\n          subresult = factory(node.children[offset], offset, grandparents)();\n\n          if (subresult[0] === EXIT) {\n            return subresult;\n          }\n\n          offset = typeof subresult[1] === 'number' ? subresult[1] : offset + step;\n        }\n      }\n\n      return result;\n    }\n  }\n}\n\nfunction toResult(value) {\n  if (value !== null && typeof value === 'object' && 'length' in value) {\n    return value;\n  }\n\n  if (typeof value === 'number') {\n    return [CONTINUE, value];\n  }\n\n  return [value];\n}","'use strict';\n\nmodule.exports = require('./lib');","'use strict';\n\nvar p = require('./minpath');\n\nvar proc = require('./minproc');\n\nvar buffer = require('is-buffer');\n\nmodule.exports = VFile;\nvar own = {}.hasOwnProperty; // Order of setting (least specific to most), we need this because otherwise\n// `{stem: 'a', path: '~/b.js'}` would throw, as a path is needed before a\n// stem can be set.\n\nvar order = ['history', 'path', 'basename', 'stem', 'extname', 'dirname'];\nVFile.prototype.toString = toString; // Access full path (`~/index.min.js`).\n\nObject.defineProperty(VFile.prototype, 'path', {\n  get: getPath,\n  set: setPath\n}); // Access parent path (`~`).\n\nObject.defineProperty(VFile.prototype, 'dirname', {\n  get: getDirname,\n  set: setDirname\n}); // Access basename (`index.min.js`).\n\nObject.defineProperty(VFile.prototype, 'basename', {\n  get: getBasename,\n  set: setBasename\n}); // Access extname (`.js`).\n\nObject.defineProperty(VFile.prototype, 'extname', {\n  get: getExtname,\n  set: setExtname\n}); // Access stem (`index.min`).\n\nObject.defineProperty(VFile.prototype, 'stem', {\n  get: getStem,\n  set: setStem\n}); // Construct a new file.\n\nfunction VFile(options) {\n  var prop;\n  var index;\n\n  if (!options) {\n    options = {};\n  } else if (typeof options === 'string' || buffer(options)) {\n    options = {\n      contents: options\n    };\n  } else if ('message' in options && 'messages' in options) {\n    return options;\n  }\n\n  if (!(this instanceof VFile)) {\n    return new VFile(options);\n  }\n\n  this.data = {};\n  this.messages = [];\n  this.history = [];\n  this.cwd = proc.cwd(); // Set path related properties in the correct order.\n\n  index = -1;\n\n  while (++index < order.length) {\n    prop = order[index];\n\n    if (own.call(options, prop)) {\n      this[prop] = options[prop];\n    }\n  } // Set non-path related properties.\n\n\n  for (prop in options) {\n    if (order.indexOf(prop) < 0) {\n      this[prop] = options[prop];\n    }\n  }\n}\n\nfunction getPath() {\n  return this.history[this.history.length - 1];\n}\n\nfunction setPath(path) {\n  assertNonEmpty(path, 'path');\n\n  if (this.path !== path) {\n    this.history.push(path);\n  }\n}\n\nfunction getDirname() {\n  return typeof this.path === 'string' ? p.dirname(this.path) : undefined;\n}\n\nfunction setDirname(dirname) {\n  assertPath(this.path, 'dirname');\n  this.path = p.join(dirname || '', this.basename);\n}\n\nfunction getBasename() {\n  return typeof this.path === 'string' ? p.basename(this.path) : undefined;\n}\n\nfunction setBasename(basename) {\n  assertNonEmpty(basename, 'basename');\n  assertPart(basename, 'basename');\n  this.path = p.join(this.dirname || '', basename);\n}\n\nfunction getExtname() {\n  return typeof this.path === 'string' ? p.extname(this.path) : undefined;\n}\n\nfunction setExtname(extname) {\n  assertPart(extname, 'extname');\n  assertPath(this.path, 'extname');\n\n  if (extname) {\n    if (extname.charCodeAt(0) !== 46\n    /* `.` */\n    ) {\n      throw new Error('`extname` must start with `.`');\n    }\n\n    if (extname.indexOf('.', 1) > -1) {\n      throw new Error('`extname` cannot contain multiple dots');\n    }\n  }\n\n  this.path = p.join(this.dirname, this.stem + (extname || ''));\n}\n\nfunction getStem() {\n  return typeof this.path === 'string' ? p.basename(this.path, this.extname) : undefined;\n}\n\nfunction setStem(stem) {\n  assertNonEmpty(stem, 'stem');\n  assertPart(stem, 'stem');\n  this.path = p.join(this.dirname || '', stem + (this.extname || ''));\n} // Get the value of the file.\n\n\nfunction toString(encoding) {\n  return (this.contents || '').toString(encoding);\n} // Assert that `part` is not a path (i.e., does not contain `p.sep`).\n\n\nfunction assertPart(part, name) {\n  if (part && part.indexOf(p.sep) > -1) {\n    throw new Error('`' + name + '` cannot be a path: did not expect `' + p.sep + '`');\n  }\n} // Assert that `part` is not empty.\n\n\nfunction assertNonEmpty(part, name) {\n  if (!part) {\n    throw new Error('`' + name + '` cannot be empty');\n  }\n} // Assert `path` exists.\n\n\nfunction assertPath(path, name) {\n  if (!path) {\n    throw new Error('Setting `' + name + '` requires `path` to be set too');\n  }\n}","'use strict';\n\nvar VMessage = require('vfile-message');\n\nvar VFile = require('./core.js');\n\nmodule.exports = VFile;\nVFile.prototype.message = message;\nVFile.prototype.info = info;\nVFile.prototype.fail = fail; // Create a message with `reason` at `position`.\n// When an error is passed in as `reason`, copies the stack.\n\nfunction message(reason, position, origin) {\n  var message = new VMessage(reason, position, origin);\n\n  if (this.path) {\n    message.name = this.path + ':' + message.name;\n    message.file = this.path;\n  }\n\n  message.fatal = false;\n  this.messages.push(message);\n  return message;\n} // Fail: creates a vmessage, associates it with the file, and throws it.\n\n\nfunction fail() {\n  var message = this.message.apply(this, arguments);\n  message.fatal = true;\n  throw message;\n} // Info: creates a vmessage, associates it with the file, and marks the fatality\n// as null.\n\n\nfunction info() {\n  var message = this.message.apply(this, arguments);\n  message.fatal = null;\n  return message;\n}","'use strict'; // A derivative work based on:\n// <https://github.com/browserify/path-browserify>.\n// Which is licensed:\n//\n// MIT License\n//\n// Copyright (c) 2013 James Halliday\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy of\n// this software and associated documentation files (the \"Software\"), to deal in\n// the Software without restriction, including without limitation the rights to\n// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\n// the Software, and to permit persons to whom the Software is furnished to do so,\n// subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\n// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\n// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\n// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\n// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n// A derivative work based on:\n//\n// Parts of that are extracted from Node’s internal `path` module:\n// <https://github.com/nodejs/node/blob/master/lib/path.js>.\n// Which is licensed:\n//\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nexports.basename = basename;\nexports.dirname = dirname;\nexports.extname = extname;\nexports.join = join;\nexports.sep = '/';\n\nfunction basename(path, ext) {\n  var start = 0;\n  var end = -1;\n  var index;\n  var firstNonSlashEnd;\n  var seenNonSlash;\n  var extIndex;\n\n  if (ext !== undefined && typeof ext !== 'string') {\n    throw new TypeError('\"ext\" argument must be a string');\n  }\n\n  assertPath(path);\n  index = path.length;\n\n  if (ext === undefined || !ext.length || ext.length > path.length) {\n    while (index--) {\n      if (path.charCodeAt(index) === 47\n      /* `/` */\n      ) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now.\n        if (seenNonSlash) {\n          start = index + 1;\n          break;\n        }\n      } else if (end < 0) {\n        // We saw the first non-path separator, mark this as the end of our\n        // path component.\n        seenNonSlash = true;\n        end = index + 1;\n      }\n    }\n\n    return end < 0 ? '' : path.slice(start, end);\n  }\n\n  if (ext === path) {\n    return '';\n  }\n\n  firstNonSlashEnd = -1;\n  extIndex = ext.length - 1;\n\n  while (index--) {\n    if (path.charCodeAt(index) === 47\n    /* `/` */\n    ) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now.\n      if (seenNonSlash) {\n        start = index + 1;\n        break;\n      }\n    } else {\n      if (firstNonSlashEnd < 0) {\n        // We saw the first non-path separator, remember this index in case\n        // we need it if the extension ends up not matching.\n        seenNonSlash = true;\n        firstNonSlashEnd = index + 1;\n      }\n\n      if (extIndex > -1) {\n        // Try to match the explicit extension.\n        if (path.charCodeAt(index) === ext.charCodeAt(extIndex--)) {\n          if (extIndex < 0) {\n            // We matched the extension, so mark this as the end of our path\n            // component\n            end = index;\n          }\n        } else {\n          // Extension does not match, so our result is the entire path\n          // component\n          extIndex = -1;\n          end = firstNonSlashEnd;\n        }\n      }\n    }\n  }\n\n  if (start === end) {\n    end = firstNonSlashEnd;\n  } else if (end < 0) {\n    end = path.length;\n  }\n\n  return path.slice(start, end);\n}\n\nfunction dirname(path) {\n  var end;\n  var unmatchedSlash;\n  var index;\n  assertPath(path);\n\n  if (!path.length) {\n    return '.';\n  }\n\n  end = -1;\n  index = path.length; // Prefix `--` is important to not run on `0`.\n\n  while (--index) {\n    if (path.charCodeAt(index) === 47\n    /* `/` */\n    ) {\n      if (unmatchedSlash) {\n        end = index;\n        break;\n      }\n    } else if (!unmatchedSlash) {\n      // We saw the first non-path separator\n      unmatchedSlash = true;\n    }\n  }\n\n  return end < 0 ? path.charCodeAt(0) === 47\n  /* `/` */\n  ? '/' : '.' : end === 1 && path.charCodeAt(0) === 47\n  /* `/` */\n  ? '//' : path.slice(0, end);\n}\n\nfunction extname(path) {\n  var startDot = -1;\n  var startPart = 0;\n  var end = -1; // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find.\n\n  var preDotState = 0;\n  var unmatchedSlash;\n  var code;\n  var index;\n  assertPath(path);\n  index = path.length;\n\n  while (index--) {\n    code = path.charCodeAt(index);\n\n    if (code === 47\n    /* `/` */\n    ) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now.\n      if (unmatchedSlash) {\n        startPart = index + 1;\n        break;\n      }\n\n      continue;\n    }\n\n    if (end < 0) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension.\n      unmatchedSlash = true;\n      end = index + 1;\n    }\n\n    if (code === 46\n    /* `.` */\n    ) {\n      // If this is our first dot, mark it as the start of our extension.\n      if (startDot < 0) {\n        startDot = index;\n      } else if (preDotState !== 1) {\n        preDotState = 1;\n      }\n    } else if (startDot > -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension.\n      preDotState = -1;\n    }\n  }\n\n  if (startDot < 0 || end < 0 || // We saw a non-dot character immediately before the dot.\n  preDotState === 0 || // The (right-most) trimmed path component is exactly `..`.\n  preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n    return '';\n  }\n\n  return path.slice(startDot, end);\n}\n\nfunction join() {\n  var index = -1;\n  var joined;\n\n  while (++index < arguments.length) {\n    assertPath(arguments[index]);\n\n    if (arguments[index]) {\n      joined = joined === undefined ? arguments[index] : joined + '/' + arguments[index];\n    }\n  }\n\n  return joined === undefined ? '.' : normalize(joined);\n} // Note: `normalize` is not exposed as `path.normalize`, so some code is\n// manually removed from it.\n\n\nfunction normalize(path) {\n  var absolute;\n  var value;\n  assertPath(path);\n  absolute = path.charCodeAt(0) === 47;\n  /* `/` */\n  // Normalize the path according to POSIX rules.\n\n  value = normalizeString(path, !absolute);\n\n  if (!value.length && !absolute) {\n    value = '.';\n  }\n\n  if (value.length && path.charCodeAt(path.length - 1) === 47\n  /* / */\n  ) {\n    value += '/';\n  }\n\n  return absolute ? '/' + value : value;\n} // Resolve `.` and `..` elements in a path with directory names.\n\n\nfunction normalizeString(path, allowAboveRoot) {\n  var result = '';\n  var lastSegmentLength = 0;\n  var lastSlash = -1;\n  var dots = 0;\n  var index = -1;\n  var code;\n  var lastSlashIndex;\n\n  while (++index <= path.length) {\n    if (index < path.length) {\n      code = path.charCodeAt(index);\n    } else if (code === 47\n    /* `/` */\n    ) {\n      break;\n    } else {\n      code = 47;\n      /* `/` */\n    }\n\n    if (code === 47\n    /* `/` */\n    ) {\n      if (lastSlash === index - 1 || dots === 1) {// Empty.\n      } else if (lastSlash !== index - 1 && dots === 2) {\n        if (result.length < 2 || lastSegmentLength !== 2 || result.charCodeAt(result.length - 1) !== 46\n        /* `.` */\n        || result.charCodeAt(result.length - 2) !== 46\n        /* `.` */\n        ) {\n          if (result.length > 2) {\n            lastSlashIndex = result.lastIndexOf('/');\n            /* istanbul ignore else - No clue how to cover it. */\n\n            if (lastSlashIndex !== result.length - 1) {\n              if (lastSlashIndex < 0) {\n                result = '';\n                lastSegmentLength = 0;\n              } else {\n                result = result.slice(0, lastSlashIndex);\n                lastSegmentLength = result.length - 1 - result.lastIndexOf('/');\n              }\n\n              lastSlash = index;\n              dots = 0;\n              continue;\n            }\n          } else if (result.length) {\n            result = '';\n            lastSegmentLength = 0;\n            lastSlash = index;\n            dots = 0;\n            continue;\n          }\n        }\n\n        if (allowAboveRoot) {\n          result = result.length ? result + '/..' : '..';\n          lastSegmentLength = 2;\n        }\n      } else {\n        if (result.length) {\n          result += '/' + path.slice(lastSlash + 1, index);\n        } else {\n          result = path.slice(lastSlash + 1, index);\n        }\n\n        lastSegmentLength = index - lastSlash - 1;\n      }\n\n      lastSlash = index;\n      dots = 0;\n    } else if (code === 46\n    /* `.` */\n    && dots > -1) {\n      dots++;\n    } else {\n      dots = -1;\n    }\n  }\n\n  return result;\n}\n\nfunction assertPath(path) {\n  if (typeof path !== 'string') {\n    throw new TypeError('Path must be a string. Received ' + JSON.stringify(path));\n  }\n}","'use strict'; // Somewhat based on:\n// <https://github.com/defunctzombie/node-process/blob/master/browser.js>.\n// But I don’t think one tiny line of code can be copyrighted. 😅\n\nexports.cwd = cwd;\n\nfunction cwd() {\n  return '/';\n}","'use strict';\n\nvar own = {}.hasOwnProperty;\nmodule.exports = stringify;\n\nfunction stringify(value) {\n  // Nothing.\n  if (!value || typeof value !== 'object') {\n    return '';\n  } // Node.\n\n\n  if (own.call(value, 'position') || own.call(value, 'type')) {\n    return position(value.position);\n  } // Position.\n\n\n  if (own.call(value, 'start') || own.call(value, 'end')) {\n    return position(value);\n  } // Point.\n\n\n  if (own.call(value, 'line') || own.call(value, 'column')) {\n    return point(value);\n  } // ?\n\n\n  return '';\n}\n\nfunction point(point) {\n  if (!point || typeof point !== 'object') {\n    point = {};\n  }\n\n  return index(point.line) + ':' + index(point.column);\n}\n\nfunction position(pos) {\n  if (!pos || typeof pos !== 'object') {\n    pos = {};\n  }\n\n  return point(pos.start) + '-' + point(pos.end);\n}\n\nfunction index(value) {\n  return value && typeof value === 'number' ? value : 1;\n}","'use strict';\n\nvar stringify = require('unist-util-stringify-position');\n\nmodule.exports = VMessage; // Inherit from `Error#`.\n\nfunction VMessagePrototype() {}\n\nVMessagePrototype.prototype = Error.prototype;\nVMessage.prototype = new VMessagePrototype(); // Message properties.\n\nvar proto = VMessage.prototype;\nproto.file = '';\nproto.name = '';\nproto.reason = '';\nproto.message = '';\nproto.stack = '';\nproto.fatal = null;\nproto.column = null;\nproto.line = null; // Construct a new VMessage.\n//\n// Note: We cannot invoke `Error` on the created context, as that adds readonly\n// `line` and `column` attributes on Safari 9, thus throwing and failing the\n// data.\n\nfunction VMessage(reason, position, origin) {\n  var parts;\n  var range;\n  var location;\n\n  if (typeof position === 'string') {\n    origin = position;\n    position = null;\n  }\n\n  parts = parseOrigin(origin);\n  range = stringify(position) || '1:1';\n  location = {\n    start: {\n      line: null,\n      column: null\n    },\n    end: {\n      line: null,\n      column: null\n    }\n  }; // Node.\n\n  if (position && position.position) {\n    position = position.position;\n  }\n\n  if (position) {\n    // Position.\n    if (position.start) {\n      location = position;\n      position = position.start;\n    } else {\n      // Point.\n      location.start = position;\n    }\n  }\n\n  if (reason.stack) {\n    this.stack = reason.stack;\n    reason = reason.message;\n  }\n\n  this.message = reason;\n  this.name = range;\n  this.reason = reason;\n  this.line = position ? position.line : null;\n  this.column = position ? position.column : null;\n  this.location = location;\n  this.source = parts[0];\n  this.ruleId = parts[1];\n}\n\nfunction parseOrigin(origin) {\n  var result = [null, null];\n  var index;\n\n  if (typeof origin === 'string') {\n    index = origin.indexOf(':');\n\n    if (index === -1) {\n      result[1] = origin;\n    } else {\n      result[0] = origin.slice(0, index);\n      result[1] = origin.slice(index + 1);\n    }\n  }\n\n  return result;\n}","module.exports = extend;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction extend() {\n  var target = {};\n\n  for (var i = 0; i < arguments.length; i++) {\n    var source = arguments[i];\n\n    for (var key in source) {\n      if (hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n\n  return target;\n}"],"names":["module","exports","err","hasOwn","Object","prototype","hasOwnProperty","toStr","toString","defineProperty","gOPD","getOwnPropertyDescriptor","isArray","arr","Array","call","isPlainObject","obj","key","hasOwnConstructor","hasIsPrototypeOf","constructor","setProperty","target","options","name","enumerable","configurable","value","newValue","writable","getProperty","extend","src","copy","copyIsArray","clone","arguments","i","length","deep","isBuffer","getPrototypeOf","visitWithParents","ast","listNode","parents","n","depth","type","children","child","index","ordered","tree","visitor","stack","one","node","result","concat","parent","push","pop","all","b","Symbol","for","c","d","e","f","g","h","k","l","m","p","q","r","t","v","w","x","y","z","a","u","$$typeof","A","AsyncMode","ConcurrentMode","ContextConsumer","ContextProvider","Element","ForwardRef","Fragment","Lazy","Memo","Portal","Profiler","StrictMode","Suspense","isAsyncMode","isConcurrentMode","isContextConsumer","isContextProvider","isElement","isForwardRef","isFragment","isLazy","isMemo","isPortal","isProfiler","isStrictMode","isSuspense","isValidElementType","typeOf","React","xtend","ReactIs","astToReact","undefined","renderer","renderers","position","start","line","column","offset","end","pos","join","Error","nodeProps","getNodeProps","createElement","resolveChildren","map","childNode","props","opts","isSimpleRenderer","sourcePos","String","rawSourcePos","sourcePosition","includeNodeIndex","indexOf","parentChildCount","ref","identifier","definitions","toUpperCase","assignDefined","className","nodeKey","level","spread","checked","loose","listItemLoose","listLoose","reduce","array","unwrapParagraphs","getListItemChildren","title","url","language","lang","split","inline","linkTarget","href","transformLinkUri","transformImageUri","alt","columnAlignment","align","isHeader","tag","isBlock","allowDangerousHtml","escapeHtml","skipHtml","parsedChildren","element","el","Children","toArray","cloneElement","mergeNodeChildren","attrs","visit","splice","ifNotMatch","allow","mode","filter","parameters","apply","ofType","types","includes","selfClosingRe","simpleTagRe","open","currentParent","selfClosing","match","getSelfClosing","current","opening","getSimpleTag","matching","matchingTag","findAndPull","fromNode","toNode","fromIndex","toIndex","slice","indent","virtual","unified","parse","PropTypes","addListMetadata","naiveHtml","disallowNode","wrapTableRows","getDefinitions","uriTransformer","defaultRenderers","symbols","allTypes","keys","ReactMarkdown","source","allowedTypes","disallowedTypes","processor","use","plugins","runSync","renderProps","transforms","removalMethod","unwrapDisallowed","allowNode","renderHtml","hasHtmlParser","astPlugins","some","transform","identity","HtmlParser","determineAstToReactTransforms","forEach","defaultProps","propTypes","string","bool","func","arrayOf","oneOf","oneOfType","object","supportsStringRender","parseInt","version","SimpleRenderer","getCoreProps","break","paragraph","emphasis","strong","thematicBreak","blockquote","delete","link","image","linkReference","imageReference","table","bind","tableHead","tableBody","tableRow","tableCell","style","textAlign","coreProps","root","text","list","listItem","checkbox","readOnly","definition","heading","inlineCode","code","html","dangerous","dangerouslySetInnerHTML","__html","virtualHtml","parsedHtml","protocols","uri","trim","first","charAt","colon","protocol","toLowerCase","wrap","encoding","settings","config","extensions","extension","configure","canContainEols","enter","autolink","opener","autolinkProtocol","onenterdata","autolinkEmail","atxHeading","blockQuote","characterEscape","characterReference","codeFenced","codeFlow","codeFencedFenceInfo","buffer","codeFencedFenceMeta","codeIndented","codeText","codeTextData","data","codeFlowValue","definitionDestinationString","definitionLabelString","definitionTitleString","hardBreakEscape","hardBreak","hardBreakTrailing","htmlFlow","htmlFlowData","htmlText","htmlTextData","label","listItemValue","onenterlistitemvalue","listOrdered","onenterlistordered","listUnordered","reference","onenterreference","referenceString","resourceDestinationString","resourceTitleString","setextHeading","exit","closer","atxHeadingSequence","onexitatxheadingsequence","onexitautolinkemail","onexitautolinkprotocol","characterEscapeValue","onexitdata","characterReferenceMarkerHexadecimal","onexitcharacterreferencemarker","characterReferenceMarkerNumeric","characterReferenceValue","onexitcharacterreferencevalue","onexitcodefenced","codeFencedFence","onexitcodefencedfence","onexitcodefencedfenceinfo","onexitcodefencedfencemeta","onexitcodeindented","onexitcodetext","onexitdefinitiondestinationstring","onexitdefinitionlabelstring","onexitdefinitiontitlestring","onexithardbreak","onexithtmlflow","onexithtmltext","onexitimage","onexitlabel","labelText","onexitlabeltext","lineEnding","onexitlineending","onexitlink","onexitreferencestring","onexitresourcedestinationstring","onexitresourcetitlestring","resource","onexitresource","onexitsetextheading","setextHeadingLineSequence","onexitsetextheadinglinesequence","setextHeadingText","onexitsetextheadingtext","mdastExtensions","compile","events","handler","tokenStack","listStack","context","resume","setData","getData","prepareList","own","assign","sliceSerialize","stringifyPosition","point","tailIndex","lineIndex","tailEvent","event","firstBlankLineIndex","atMarker","containerBalance","listSpread","_spread","create","and","token","this","close","meta","replace","normalizeIdentifier","charCodeAt","siblings","tail","referenceType","fragment","safeFromInt","decode","compiler","postprocess","parser","document","write","preprocessor","left","values","asciiAlpha","regexCheck","asciiAlphanumeric","asciiAtext","asciiDigit","asciiHexDigit","asciiPunctuation","unicodePunctuationRegex","unicodePunctuation","unicodeWhitespace","fromCharCode","text$1","attention","headingAtx","labelEnd","labelStartImage","labelStartLink","setextUnderline","contentInitial","flowInitial","flow","insideSpan","null","resolver","disable","markdownLineEnding","factorySpace","tokenize","effects","previous","contentStart","attempt","constructs","consume","lineStart","contentType","next","partialBlankLine","inspectResult","childFlow","childToken","self","continued","inspectConstruct","ok","subcontinued","inspectStart","containerState","continuation","inspectContinue","inspectLess","currentConstruct","concrete","flowContinue","inspectDone","interrupt","interruptible","containerConstruct","inspectFlowEnd","_closeFlow","lazy","lazyFlowConstruct","check","inspectLazy","flowEnd","partial","documentContinue","documentContinued","flowStart","containerContinue","exitContainers","now","_tokenizer","continueFlow","documentAfterPeek","defineSkip","sliceStream","size","nok","content","initial","afterConstruct","shallow","initializeFactory","resolveAll","createResolver","field","notText","atBreak","resolveAllLineSuffixes","extraResolver","chunks","chunk","bufferIndex","tabs","eventIndex","_index","_bufferIndex","combineExtensions","createTokenizer","miniflat","defined","initializer","from","subtokenize","search","atCarriageReturn","startPosition","endPosition","lastIndex","exec","Math","ceil","chunkedPush","chunkedSplice","classifyCharacter","movePoint","marker","before","sequence","after","_open","_close","group","openingSequence","closingSequence","nextEvents","asciiControl","schemeOrEmailAtext","emailAtext","schemeInsideOrEmailAtext","urlInside","emailAtSignOrDot","emailLabel","emailValue","markdownSpace","_container","decodeEntity","_interopDefaultLegacy","default","decodeEntity__default","max","test","numeric","markdownLineEndingOrSpace","prefixSize","closingFenceConstruct","closingSequenceStart","sizeOpen","closingSequenceEnd","initialPrefix","sequenceOpen","infoOpen","openAfter","info","infoAfter","contentContinue","indentedContentConstruct","afterPrefix","resolve","gap","tailExitIndex","headEnterIndex","contentEnd","continuationConstruct","prefixed","factoryDestination","factoryLabel","factoryWhitespace","factoryTitle","labelAfter","titleConstruct","literalType","literalMarkerType","rawType","stringType","limit","Infinity","balance","destinationEnclosedBefore","destinationRaw","destinationEnclosed","destinationEnclosedEscape","destinationRawEscape","markerType","labelEscape","prefix","atFirstTitleBreak","atTitleBreak","titleEscape","seen","fenceOpenInside","headingBreak","htmlBlockNames","htmlRawNames","kind","startTag","declarationStart","tagCloseStart","continuationDeclarationInside","tagName","commentOpenInside","cdataOpenInside","basicSelfClosing","completeAttributeNameBefore","completeClosingTagAfter","completeEnd","completeAttributeName","completeAttributeNameAfter","completeAttributeValueBefore","completeAttributeValueQuoted","completeAttributeValueUnquoted","completeAttributeValueQuotedAfter","completeAfter","continuationCommentInside","continuationRawTagOpen","continuationClose","continuationCharacterDataInside","continuationAtLineEnding","nextBlankConstruct","htmlContinueStart","done","continuationRawEndTag","resolveTo","returnState","declarationOpen","instruction","tagOpen","commentOpen","cdataOpen","declaration","commentStart","commentStartDash","comment","commentClose","atLineEnding","cdata","cdataClose","cdataEnd","instructionClose","tagClose","tagCloseBetween","tagOpenBetween","tagOpenAttributeName","tagOpenAttributeNameAfter","tagOpenAttributeValueBefore","tagOpenAttributeValueQuoted","tagOpenAttributeValueUnquoted","tagOpenAttributeValueQuotedAfter","labelStart","_balanced","_inactive","balanced","afterLabelEnd","resourceConstruct","fullReferenceConstruct","collapsedReferenceConstruct","media","_used","destinationAfter","between","afterLabel","sizeChunks","initialSize","inside","onBlank","listItemPrefixWhitespaceConstruct","endOfPrefix","otherPrefix","initialBlankLine","furtherBlankLines","notInCurrentItem","indentConstruct","items","remove","chunkStart","unshift","hook","right","existing","add","serializeChunks","sliceChunks","initialize","columnStart","resolveAllConstructs","accountForPotentialSkip","fields","constructFactory","construct","addResult","onsuccessfulcheck","main","state","chunkIndex","go","restore","onreturn","bogusState","listOfConstructs","constructIndex","handleListOfConstructs","handleConstruct","startPoint","startPrevious","startCurrentConstruct","startEventsIndex","startStack","store","regex","called","base","atTab","view","startIndex","startBufferIndex","endIndex","endBufferIndex","subcontent","stream","entered","adjust","startPositions","tokenizer","childEvents","jumps","gaps","isInFirstContentOfListItem","_gfmTasklistFirstContentOfListItem","otherIndex","otherEvent","subevents","more","_movePreviousLineEndings","characters","char","entity","innerHTML","textContent","Parser","doc","fromMarkdown","bail","plain","trough","vfile","frozen","attachers","transformers","namespace","freezeIndex","assertUnfrozen","freeze","addPlugin","addList","addPreset","plugin","entry","find","file","assertParser","newable","stringify","Compiler","assertCompiler","assertNode","run","complete","assertDone","error","process","processSync","destination","transformer","cb","Promise","executor","reject","pipeline","ctx","contents","asyncName","fns","middleware","input","fn","params","callback","invoked","then","visitParents","CONTINUE","SKIP","EXIT","reverse","convert","Boolean","typeFactory","tests","checks","any","anyFactory","allFactory","color","step","is","factory","displayName","subresult","grandparents","toResult","proc","VFile","order","prop","messages","history","cwd","assertPart","part","sep","assertNonEmpty","assertPath","path","get","set","dirname","basename","extname","stem","VMessage","message","reason","origin","fatal","fail","normalize","absolute","allowAboveRoot","lastSlashIndex","lastSegmentLength","lastSlash","dots","lastIndexOf","normalizeString","TypeError","JSON","ext","firstNonSlashEnd","seenNonSlash","extIndex","unmatchedSlash","startDot","startPart","preDotState","joined","VMessagePrototype","proto","parts","range","location","parseOrigin","ruleId"],"sourceRoot":""}