{"version":3,"file":"webpack.vendors-a5e16831.7a6c8b5caaa72af2f882.js","mappings":";kvBAWO,MAAMA,EACXC,cACEC,KAAKC,SAAW,KAChBD,KAAKE,QAAU,IAAIC,IACnBH,KAAKI,UAAW,EAChBJ,KAAKK,eAAYC,CACnB,CAKAC,QAAQC,EAAOC,EAAOC,EAAMC,GAC1B,MAAMC,EAAYH,EAAMI,UAAUF,GAC5BG,EAAWL,EAAMM,SAEvBH,EAAUI,SAAQC,GAAMA,EAAG,CACzBT,QACAU,QAAST,EAAMS,QACfJ,WACAK,YAAaC,KAAKC,IAAIX,EAAOD,EAAMa,MAAOR,MAE9C,CAKAS,WACMvB,KAAKC,WAGTD,KAAKI,UAAW,EAEhBJ,KAAKC,SAAWuB,EAAAA,EAAiBC,KAAKC,QAAQ,KAC5C1B,KAAK2B,UACL3B,KAAKC,SAAW,KAEZD,KAAKI,UACPJ,KAAKuB,cAGX,CAKAI,QAAQjB,EAAOkB,KAAKC,OAClB,IAAIC,EAAY,EAEhB9B,KAAKE,QAAQc,SAAQ,CAACP,EAAOD,KAC3B,IAAKC,EAAMsB,UAAYtB,EAAMuB,MAAMC,OACjC,OAEF,MAAMD,EAAQvB,EAAMuB,MACpB,IAEIE,EAFAC,EAAIH,EAAMC,OAAS,EACnBG,GAAO,EAGX,KAAOD,GAAK,IAAKA,EACfD,EAAOF,EAAMG,GAETD,EAAKG,SACHH,EAAKI,OAAS7B,EAAMM,WAGtBN,EAAMM,SAAWmB,EAAKI,QAExBJ,EAAKK,KAAK7B,GACV0B,GAAO,IAIPJ,EAAMG,GAAKH,EAAMA,EAAMC,OAAS,GAChCD,EAAMQ,OAINJ,IACF5B,EAAM4B,OACNpC,KAAKO,QAAQC,EAAOC,EAAOC,EAAM,aAG9BsB,EAAMC,SACTxB,EAAMsB,SAAU,EAChB/B,KAAKO,QAAQC,EAAOC,EAAOC,EAAM,YACjCD,EAAMS,SAAU,GAGlBY,GAAaE,EAAMC,MAAM,IAG3BjC,KAAKK,UAAYK,EAEC,IAAdoB,IACF9B,KAAKI,UAAW,EAEpB,CAKAqC,UAAUjC,GACR,MAAMkC,EAAS1C,KAAKE,QACpB,IAAIO,EAAQiC,EAAOC,IAAInC,GAavB,OAZKC,IACHA,EAAQ,CACNsB,SAAS,EACTb,SAAS,EACTc,MAAO,GACPnB,UAAW,CACT+B,SAAU,GACVC,SAAU,KAGdH,EAAOI,IAAItC,EAAOC,IAEbA,CACT,CAOAsC,OAAOvC,EAAOwC,EAAOC,GACnBjD,KAAKyC,UAAUjC,GAAOK,UAAUmC,GAAOE,KAAKD,EAC9C,CAOAE,IAAI3C,EAAOwB,GACJA,GAAUA,EAAMC,QAGrBjC,KAAKyC,UAAUjC,GAAOwB,MAAMkB,QAAQlB,EACtC,CAMAoB,IAAI5C,GACF,OAAOR,KAAKyC,UAAUjC,GAAOwB,MAAMC,OAAS,CAC9C,CAMAX,MAAMd,GACJ,MAAMC,EAAQT,KAAKE,QAAQyC,IAAInC,GAC1BC,IAGLA,EAAMsB,SAAU,EAChBtB,EAAMa,MAAQM,KAAKC,MACnBpB,EAAMM,SAAWN,EAAMuB,MAAMqB,QAAO,CAACC,EAAKC,IAAQnC,KAAKoC,IAAIF,EAAKC,EAAIE,YAAY,GAChFzD,KAAKuB,WACP,CAEAQ,QAAQvB,GACN,IAAKR,KAAKI,SACR,OAAO,EAET,MAAMK,EAAQT,KAAKE,QAAQyC,IAAInC,GAC/B,SAAKC,GAAUA,EAAMsB,SAAYtB,EAAMuB,MAAMC,OAI/C,CAMAyB,KAAKlD,GACH,MAAMC,EAAQT,KAAKE,QAAQyC,IAAInC,GAC/B,IAAKC,IAAUA,EAAMuB,MAAMC,OACzB,OAEF,MAAMD,EAAQvB,EAAMuB,MACpB,IAAIG,EAAIH,EAAMC,OAAS,EAEvB,KAAOE,GAAK,IAAKA,EACfH,EAAMG,GAAGwB,SAEXlD,EAAMuB,MAAQ,GACdhC,KAAKO,QAAQC,EAAOC,EAAOmB,KAAKC,MAAO,WACzC,CAMA+B,OAAOpD,GACL,OAAOR,KAAKE,QAAQ2D,OAAOrD,EAC7B,EAIF,IAAAsD,EAA+B,IAAIhE,ECjNnC,MAAMiE,EAAc,cACdC,EAAgB,CACpBC,QAAO,CAACC,EAAMC,EAAIC,IACTA,EAAS,GAAMD,EAAKD,EAO7BG,MAAMH,EAAMC,EAAIC,GACd,MAAME,GAAKD,EAAAA,EAAAA,GAAaH,GAAQH,GAC1BQ,EAAKD,EAAGE,QAASH,EAAAA,EAAAA,GAAaF,GAAMJ,GAC1C,OAAOQ,GAAMA,EAAGC,MACZD,EAAGE,IAAIH,EAAIF,GAAQM,YACnBP,CACN,EACAQ,OAAM,CAACT,EAAMC,EAAIC,IACRF,GAAQC,EAAKD,GAAQE,GAIjB,MAAMQ,EACnB7E,YAAY8E,EAAKC,EAAQC,EAAMZ,GAC7B,MAAMa,EAAeF,EAAOC,GAE5BZ,GAAKc,EAAAA,EAAAA,GAAQ,CAACJ,EAAIV,GAAIA,EAAIa,EAAcH,EAAIX,OAC5C,MAAMA,GAAOe,EAAAA,EAAAA,GAAQ,CAACJ,EAAIX,KAAMc,EAAcb,IAE9CnE,KAAKqC,SAAU,EACfrC,KAAKkF,IAAML,EAAI5D,IAAM+C,EAAca,EAAIlE,aAAeuD,GACtDlE,KAAKmF,QAAUC,EAAAA,EAAQP,EAAIQ,SAAWD,EAAAA,EAAQE,OAC9CtF,KAAKuF,OAASnE,KAAKoE,MAAM5D,KAAKC,OAASgD,EAAIY,OAAS,IACpDzF,KAAKyD,UAAYzD,KAAKsC,OAASlB,KAAKoE,MAAMX,EAAI9D,UAC9Cf,KAAK0F,QAAUb,EAAIc,KACnB3F,KAAK4F,QAAUd,EACf9E,KAAK6F,MAAQd,EACb/E,KAAK8F,MAAQ5B,EACblE,KAAK+F,IAAM5B,EACXnE,KAAKgG,eAAY1F,CACnB,CAEA2F,SACE,OAAOjG,KAAKqC,OACd,CAEA6D,OAAOrB,EAAKV,EAAIzD,GACd,GAAIV,KAAKqC,QAAS,CAChBrC,KAAKO,SAAQ,GAEb,MAAMyE,EAAehF,KAAK4F,QAAQ5F,KAAK6F,OACjCM,EAAUzF,EAAOV,KAAKuF,OACtBa,EAASpG,KAAKyD,UAAY0C,EAChCnG,KAAKuF,OAAS7E,EACdV,KAAKyD,UAAYrC,KAAKoE,MAAMpE,KAAKoC,IAAI4C,EAAQvB,EAAI9D,WACjDf,KAAKsC,QAAU6D,EACfnG,KAAK0F,QAAUb,EAAIc,KACnB3F,KAAK+F,KAAMd,EAAAA,EAAAA,GAAQ,CAACJ,EAAIV,GAAIA,EAAIa,EAAcH,EAAIX,OAClDlE,KAAK8F,OAAQb,EAAAA,EAAAA,GAAQ,CAACJ,EAAIX,KAAMc,EAAcb,IAElD,CAEAR,SACM3D,KAAKqC,UAEPrC,KAAKuC,KAAKX,KAAKC,OACf7B,KAAKqC,SAAU,EACfrC,KAAKO,SAAQ,GAEjB,CAEAgC,KAAK7B,GACH,MAAMyF,EAAUzF,EAAOV,KAAKuF,OACtBxE,EAAWf,KAAKyD,UAChBsB,EAAO/E,KAAK6F,MACZ3B,EAAOlE,KAAK8F,MACZH,EAAO3F,KAAK0F,MACZvB,EAAKnE,KAAK+F,IAChB,IAAI3B,EAIJ,GAFApE,KAAKqC,QAAU6B,IAASC,IAAOwB,GAASQ,EAAUpF,IAE7Cf,KAAKqC,QAGR,OAFArC,KAAK4F,QAAQb,GAAQZ,OACrBnE,KAAKO,SAAQ,GAIX4F,EAAU,EACZnG,KAAK4F,QAAQb,GAAQb,GAIvBE,EAAU+B,EAAUpF,EAAY,EAChCqD,EAASuB,GAAQvB,EAAS,EAAI,EAAIA,EAASA,EAC3CA,EAASpE,KAAKmF,QAAQ/D,KAAKC,IAAI,EAAGD,KAAKoC,IAAI,EAAGY,KAE9CpE,KAAK4F,QAAQb,GAAQ/E,KAAKkF,IAAIhB,EAAMC,EAAIC,GAC1C,CAEAiC,OACE,MAAMC,EAAWtG,KAAKgG,YAAchG,KAAKgG,UAAY,IACrD,OAAO,IAAIO,SAAQ,CAACC,EAAKC,KACvBH,EAASpD,KAAK,CAACsD,MAAKC,OAAK,GAE7B,CAEAlG,QAAQmG,GACN,MAAMC,EAASD,EAAW,MAAQ,MAC5BJ,EAAWtG,KAAKgG,WAAa,GACnC,IAAK,IAAI7D,EAAI,EAAGA,EAAImE,EAASrE,OAAQE,IACnCmE,EAASnE,GAAGwE,IAEhB,EChHa,MAAMC,EACnB7G,YAAYS,EAAOqG,GACjB7G,KAAK8G,OAAStG,EACdR,KAAK+G,YAAc,IAAI5G,IACvBH,KAAKgH,UAAUH,EACjB,CAEAG,UAAUH,GACR,KAAKI,EAAAA,EAAAA,GAASJ,GACZ,OAGF,MAAMK,EAAmBC,OAAOC,KAAKC,EAAAA,EAASC,WACxCC,EAAgBvH,KAAK+G,YAE3BI,OAAOK,oBAAoBX,GAAQ7F,SAAQyG,IACzC,MAAM5C,EAAMgC,EAAOY,GACnB,KAAKR,EAAAA,EAAAA,GAASpC,GACZ,OAEF,MAAM6B,EAAW,CAAC,EAClB,IAAK,MAAMgB,KAAUR,EACnBR,EAASgB,GAAU7C,EAAI6C,KAGxBC,EAAAA,EAAAA,GAAQ9C,EAAI+C,aAAe/C,EAAI+C,YAAc,CAACH,IAAMzG,SAAS+D,IACxDA,IAAS0C,GAAQF,EAAcnE,IAAI2B,IACrCwC,EAAczE,IAAIiC,EAAM2B,KAE1B,GAEN,CAMAmB,gBAAgB/C,EAAQgD,GACtB,MAAMC,EAAaD,EAAOE,QACpBA,EAsGV,SAA8BlD,EAAQiD,GACpC,IAAKA,EACH,OAEF,IAAIC,EAAUlD,EAAOkD,QACrB,GAAKA,EASL,OALIA,EAAQC,UAGVnD,EAAOkD,QAAUA,EAAUb,OAAOe,OAAO,CAAC,EAAGF,EAAS,CAACC,SAAS,EAAOE,YAAa,CAAC,KAEhFH,EARLlD,EAAOkD,QAAUD,CASrB,CArHoBK,CAAqBtD,EAAQiD,GAC7C,IAAKC,EACH,MAAO,GAGT,MAAMK,EAAarI,KAAKsI,kBAAkBN,EAASD,GAYnD,OAXIA,EAAWE,SAmFnB,SAAkBI,EAAYT,GAC5B,MAAM7F,EAAU,GACVqF,EAAOD,OAAOC,KAAKQ,GACzB,IAAK,IAAIzF,EAAI,EAAGA,EAAIiF,EAAKnF,OAAQE,IAAK,CACpC,MAAMoG,EAAOF,EAAWjB,EAAKjF,IACzBoG,GAAQA,EAAKtC,UACflE,EAAQmB,KAAKqF,EAAKlC,OAEtB,CAEA,OAAOE,QAAQiC,IAAIzG,EACrB,CA1FM0G,CAAS3D,EAAOkD,QAAQG,YAAaJ,GAAYW,MAAK,KACpD5D,EAAOkD,QAAUD,CAAA,IAChB,SAKEM,CACT,CAKAC,kBAAkBxD,EAAQgD,GACxB,MAAMP,EAAgBvH,KAAK+G,YACrBsB,EAAa,GACbtG,EAAU+C,EAAOqD,cAAgBrD,EAAOqD,YAAc,CAAC,GACvDQ,EAAQxB,OAAOC,KAAKU,GACpBpH,EAAOkB,KAAKC,MAClB,IAAIM,EAEJ,IAAKA,EAAIwG,EAAM1G,OAAS,EAAGE,GAAK,IAAKA,EAAG,CACtC,MAAM4C,EAAO4D,EAAMxG,GACnB,GAAuB,MAAnB4C,EAAK6D,OAAO,GACd,SAGF,GAAa,YAAT7D,EAAoB,CACtBsD,EAAWnF,QAAQlD,KAAK6H,gBAAgB/C,EAAQgD,IAChD,SAEF,MAAMe,EAAQf,EAAO/C,GACrB,IAAIuC,EAAYvF,EAAQgD,GACxB,MAAMF,EAAM0C,EAAc5E,IAAIoC,GAE9B,GAAIuC,EAAW,CACb,GAAIzC,GAAOyC,EAAUrB,SAAU,CAE7BqB,EAAUpB,OAAOrB,EAAKgE,EAAOnI,GAC7B,SAEA4G,EAAU3D,SAGTkB,GAAQA,EAAI9D,UAMjBgB,EAAQgD,GAAQuC,EAAY,IAAI1C,EAAUC,EAAKC,EAAQC,EAAM8D,GAC7DR,EAAWnF,KAAKoE,IALdxC,EAAOC,GAAQ8D,CAMnB,CACA,OAAOR,CACT,CASAnC,OAAOpB,EAAQgD,GACb,GAA8B,IAA1B9H,KAAK+G,YAAY+B,KAGnB,YADA3B,OAAOe,OAAOpD,EAAQgD,GAIxB,MAAMO,EAAarI,KAAKsI,kBAAkBxD,EAAQgD,GAElD,OAAIO,EAAWpG,QACb6B,EAASX,IAAInD,KAAK8G,OAAQuB,IACnB,QAFT,CAIF,ECvHF,SAASU,EAAUC,EAAOC,GACxB,MAAMC,EAAOF,GAASA,EAAMhB,SAAW,CAAC,EAClCmB,EAAUD,EAAKC,QACf9H,OAAmBf,IAAb4I,EAAK7H,IAAoB4H,EAAkB,EACjDzF,OAAmBlD,IAAb4I,EAAK1F,IAAoByF,EAAkB,EACvD,MAAO,CACL3H,MAAO6H,EAAU3F,EAAMnC,EACvB+H,IAAKD,EAAU9H,EAAMmC,EAEzB,CAsCA,SAAS6F,EAAwB7I,EAAO8I,GACtC,MAAMlC,EAAO,GACPmC,EAAW/I,EAAMgJ,uBAAuBF,GAC9C,IAAInH,EAAGsH,EAEP,IAAKtH,EAAI,EAAGsH,EAAOF,EAAStH,OAAQE,EAAIsH,IAAQtH,EAC9CiF,EAAKlE,KAAKqG,EAASpH,GAAGuH,OAExB,OAAOtC,CACT,CAEA,SAASuC,EAAWC,EAAOf,EAAOgB,EAAS7B,EAAU,CAAC,GACpD,MAAMZ,EAAOwC,EAAMxC,KACb0C,EAA8B,WAAjB9B,EAAQ+B,KAC3B,IAAI5H,EAAGsH,EAAMO,EAAcC,EAE3B,GAAc,OAAVpB,EAAJ,CAIA,IAAK1G,EAAI,EAAGsH,EAAOrC,EAAKnF,OAAQE,EAAIsH,IAAQtH,EAAG,CAE7C,GADA6H,GAAgB5C,EAAKjF,GACjB6H,IAAiBH,EAAS,CAC5B,GAAI7B,EAAQQ,IACV,SAEF,MAEFyB,EAAaL,EAAM9B,OAAOkC,IACtBE,EAAAA,EAAAA,GAASD,KAAgBH,GAAyB,IAAVjB,IAAesB,EAAAA,EAAAA,GAAKtB,MAAWsB,EAAAA,EAAAA,GAAKF,MAC9EpB,GAASoB,EAEb,CACA,OAAOpB,EACT,CAgBA,SAASuB,EAAUpB,EAAOqB,GACxB,MAAMC,EAAUtB,GAASA,EAAMhB,QAAQsC,QACvC,OAAOA,QAAwBhK,IAAZgK,QAAwChK,IAAf+J,EAAKT,KACnD,CAcA,SAASW,EAAiBC,EAAQC,EAAUC,GAC1C,MAAMC,EAAWH,EAAOC,KAAcD,EAAOC,GAAY,CAAC,GAC1D,OAAOE,EAASD,KAAgBC,EAASD,GAAc,CAAC,EAC1D,CAEA,SAASE,EAAoBhB,EAAOiB,EAAQC,EAAUnK,GACpD,IAAK,MAAM0J,KAAQQ,EAAOE,wBAAwBpK,GAAMwI,UAAW,CACjE,MAAMN,EAAQe,EAAMS,EAAKX,OACzB,GAAIoB,GAAajC,EAAQ,IAAQiC,GAAYjC,EAAQ,EACnD,OAAOwB,EAAKX,KAEhB,CAEA,OAAO,IACT,CAEA,SAASsB,EAAaC,EAAYC,GAChC,MAAM,MAAC1K,EAAO2K,YAAad,GAAQY,EAC7BT,EAAShK,EAAM4K,UAAY5K,EAAM4K,QAAU,CAAC,IAC5C,OAACC,EAAA,OAAQR,EAAQnB,MAAOM,GAAgBK,EACxCiB,EAAQD,EAAOE,KACfC,EAAQX,EAAOU,KACf9D,EAlCR,SAAqBgE,EAAYC,EAAYrB,GAC3C,MAAQ,GAAEoB,EAAWE,MAAMD,EAAWC,MAAMtB,EAAKT,OAASS,EAAK1J,MACjE,CAgCciL,CAAYP,EAAQR,EAAQR,GAClCZ,EAAOyB,EAAOjJ,OACpB,IAAI2H,EAEJ,IAAK,IAAIzH,EAAI,EAAGA,EAAIsH,IAAQtH,EAAG,CAC7B,MAAMD,EAAOgJ,EAAO/I,IACb,CAACmJ,GAAQ5B,EAAO,CAAC8B,GAAQ3C,GAAS3G,EAEzC0H,GADmB1H,EAAKkJ,UAAYlJ,EAAKkJ,QAAU,CAAC,IACjCI,GAASjB,EAAiBC,EAAQ/C,EAAKiC,GAC1DE,EAAMI,GAAgBnB,EAEtBe,EAAMiC,KAAOjB,EAAoBhB,EAAOiB,GAAQ,EAAMR,EAAK1J,MAC3DiJ,EAAMkC,QAAUlB,EAAoBhB,EAAOiB,GAAQ,EAAOR,EAAK1J,OAE1CiJ,EAAMmC,gBAAkBnC,EAAMmC,cAAgB,CAAC,IACvD/B,GAAgBnB,CAC/B,CACF,CAEA,SAASmD,EAAgBxL,EAAO+K,GAC9B,MAAMU,EAASzL,EAAMyL,OACrB,OAAO9E,OAAOC,KAAK6E,GAAQC,QAAOzE,GAAOwE,EAAOxE,GAAK8D,OAASA,IAAMY,OACtE,CA4BA,SAASC,EAAY/B,EAAMrI,GAEzB,MAAMgI,EAAeK,EAAKY,WAAWvB,MAC/B6B,EAAOlB,EAAKQ,QAAUR,EAAKQ,OAAOU,KACxC,GAAKA,EAAL,CAIAvJ,EAAQA,GAASqI,EAAKgC,QACtB,IAAK,MAAMnB,KAAUlJ,EAAO,CAC1B,MAAMwI,EAASU,EAAOE,QACtB,IAAKZ,QAA2BlK,IAAjBkK,EAAOe,SAAsDjL,IAA/BkK,EAAOe,GAAMvB,GACxD,cAEKQ,EAAOe,GAAMvB,QACe1J,IAA/BkK,EAAOe,GAAMQ,oBAA4EzL,IAA7CkK,EAAOe,GAAMQ,cAAc/B,WAClEQ,EAAOe,GAAMQ,cAAc/B,EAEtC,EACF,CAEA,MAAMsC,EAAsBvC,GAAkB,UAATA,GAA6B,SAATA,EACnDwC,EAAmBA,CAACC,EAAQC,IAAWA,EAASD,EAASrF,OAAOe,OAAO,CAAC,EAAGsE,GAIlE,MAAME,EAKnBC,gBAAkB,GAKlBA,0BAA4B,KAK5BA,uBAAyB,KAMzB5M,YAAYS,EAAOwJ,GACjBhK,KAAKQ,MAAQA,EACbR,KAAK4M,KAAOpM,EAAMqM,IAClB7M,KAAK0J,MAAQM,EACbhK,KAAK8M,gBAAkB,CAAC,EACxB9M,KAAKmL,YAAcnL,KAAK+M,UACxB/M,KAAKgN,MAAQhN,KAAKmL,YAAYxK,KAC9BX,KAAKgI,aAAU1H,EAEfN,KAAKiN,UAAW,EAChBjN,KAAKkN,WAAQ5M,EACbN,KAAKmN,iBAAc7M,EACnBN,KAAKoN,oBAAiB9M,EACtBN,KAAKqN,gBAAa/M,EAClBN,KAAKsN,gBAAahN,EAClBN,KAAKuN,qBAAsB,EAC3BvN,KAAKwN,oBAAqB,EAC1BxN,KAAKyN,cAAWnN,EAChBN,KAAK0N,UAAY,GACjB1N,KAAK2N,8BAAgCA,mBACrC3N,KAAK4N,2BAA6BA,gBAElC5N,KAAK6N,YACP,CAEAA,aACE,MAAMxD,EAAOrK,KAAKmL,YAClBnL,KAAKgH,YACLhH,KAAK8N,aACLzD,EAAK0D,SAAW3D,EAAUC,EAAKQ,OAAQR,GACvCrK,KAAKgO,cAEDhO,KAAKgI,QAAQiG,OAASjO,KAAKQ,MAAM0N,gBAAgB,WACnDC,QAAQC,KAAK,qKAEjB,CAEAC,YAAYrE,GACNhK,KAAK0J,QAAUM,GACjBoC,EAAYpM,KAAKmL,aAEnBnL,KAAK0J,MAAQM,CACf,CAEA8D,aACE,MAAMtN,EAAQR,KAAKQ,MACb6J,EAAOrK,KAAKmL,YACZmD,EAAUtO,KAAKuO,aAEfC,EAAWA,CAACjD,EAAMkD,EAAGC,EAAGC,IAAe,MAATpD,EAAekD,EAAa,MAATlD,EAAeoD,EAAID,EAEpEE,EAAMvE,EAAKwE,SAAUC,EAAAA,EAAAA,GAAeR,EAAQO,QAAS7C,EAAgBxL,EAAO,MAC5EuO,EAAM1E,EAAK2E,SAAUF,EAAAA,EAAAA,GAAeR,EAAQU,QAAShD,EAAgBxL,EAAO,MAC5EyO,EAAM5E,EAAK6E,SAAUJ,EAAAA,EAAAA,GAAeR,EAAQY,QAASlD,EAAgBxL,EAAO,MAC5E2O,EAAY9E,EAAK8E,UACjBC,EAAM/E,EAAKgF,QAAUb,EAASW,EAAWP,EAAKG,EAAKE,GACnDK,EAAMjF,EAAKkF,QAAUf,EAASW,EAAWJ,EAAKH,EAAKK,GACzD5E,EAAKmF,OAASxP,KAAKyP,cAAcb,GACjCvE,EAAKqF,OAAS1P,KAAKyP,cAAcV,GACjC1E,EAAKsF,OAAS3P,KAAKyP,cAAcR,GACjC5E,EAAKgB,OAASrL,KAAKyP,cAAcL,GACjC/E,EAAKQ,OAAS7K,KAAKyP,cAAcH,EACnC,CAEAf,aACE,OAAOvO,KAAKQ,MAAMoP,KAAKC,SAAS7P,KAAK0J,MACvC,CAEAqD,UACE,OAAO/M,KAAKQ,MAAMsP,eAAe9P,KAAK0J,MACxC,CAMA+F,cAAcM,GACZ,OAAO/P,KAAKQ,MAAMyL,OAAO8D,EAC3B,CAKAC,eAAehH,GACb,MAAMqB,EAAOrK,KAAKmL,YAClB,OAAOnC,IAAUqB,EAAKgB,OAClBhB,EAAKQ,OACLR,EAAKgB,MACX,CAEA4E,QACEjQ,KAAK2B,QAAQ,QACf,CAKAuO,WACE,MAAM7F,EAAOrK,KAAKmL,YACdnL,KAAKkN,QACPiD,EAAAA,EAAAA,GAAoBnQ,KAAKkN,MAAOlN,MAE9BqK,EAAK0D,UACP3B,EAAY/B,EAEhB,CAKA+F,aACE,MAAM9B,EAAUtO,KAAKuO,aACfqB,EAAOtB,EAAQsB,OAAStB,EAAQsB,KAAO,IACvC1C,EAAQlN,KAAKkN,MAMnB,IAAIjG,EAAAA,EAAAA,GAAS2I,GACX5P,KAAKkN,MA9QX,SAAkC0C,GAChC,MAAMxI,EAAOD,OAAOC,KAAKwI,GACnBS,EAAQ,IAAIC,MAAMlJ,EAAKnF,QAC7B,IAAIE,EAAGsH,EAAMhC,EACb,IAAKtF,EAAI,EAAGsH,EAAOrC,EAAKnF,OAAQE,EAAIsH,IAAQtH,EAC1CsF,EAAML,EAAKjF,GACXkO,EAAMlO,GAAK,CACTsM,EAAGhH,EACHiH,EAAGkB,EAAKnI,IAGZ,OAAO4I,CACT,CAkQmBE,CAAyBX,QACjC,GAAI1C,IAAU0C,EAAM,CACzB,GAAI1C,EAAO,EAETiD,EAAAA,EAAAA,GAAoBjD,EAAOlN,MAE3B,MAAMqK,EAAOrK,KAAKmL,YAClBiB,EAAY/B,GACZA,EAAKgC,QAAU,GAEbuD,GAAQzI,OAAOqJ,aAAaZ,KAC9Ba,EAAAA,EAAAA,GAAkBb,EAAM5P,MAE1BA,KAAK0N,UAAY,GACjB1N,KAAKkN,MAAQ0C,EAEjB,CAEA5B,cACE,MAAM3D,EAAOrK,KAAKmL,YAElBnL,KAAKoQ,aAEDpQ,KAAK2N,qBACPtD,EAAKiE,QAAU,IAAItO,KAAK2N,mBAE5B,CAEA+C,sBAAsBC,GACpB,MAAMtG,EAAOrK,KAAKmL,YACZmD,EAAUtO,KAAKuO,aACrB,IAAIqC,GAAe,EAEnB5Q,KAAKoQ,aAGL,MAAMS,EAAaxG,EAAK0D,SACxB1D,EAAK0D,SAAW3D,EAAUC,EAAKQ,OAAQR,GAGnCA,EAAKT,QAAU0E,EAAQ1E,QACzBgH,GAAe,EAEfxE,EAAY/B,GACZA,EAAKT,MAAQ0E,EAAQ1E,OAKvB5J,KAAK8Q,gBAAgBH,IAGjBC,GAAgBC,IAAexG,EAAK0D,WACtC/C,EAAahL,KAAMqK,EAAKgC,QAE5B,CAMArF,YACE,MAAMH,EAAS7G,KAAKQ,MAAMqG,OACpBkK,EAAYlK,EAAOmK,iBAAiBhR,KAAKgN,OACzCiE,EAASpK,EAAOqK,gBAAgBlR,KAAKuO,aAAcwC,GAAW,GACpE/Q,KAAKgI,QAAUnB,EAAOsK,eAAeF,EAAQjR,KAAKoR,cAClDpR,KAAKiN,SAAWjN,KAAKgI,QAAQqJ,QAC7BrR,KAAK8M,gBAAkB,CAAC,CAC1B,CAMAwE,MAAMhQ,EAAOiQ,GACX,MAAOpG,YAAad,EAAM6C,MAAO0C,GAAQ5P,MACnC,OAACqL,EAAA,SAAQ0C,GAAY1D,EACrBiB,EAAQD,EAAOE,KAErB,IAEIpJ,EAAGoB,EAAK2H,EAFRsG,EAAmB,IAAVlQ,GAAeiQ,IAAU3B,EAAK3N,QAAgBoI,EAAKoH,QAC5DC,EAAOpQ,EAAQ,GAAK+I,EAAKgC,QAAQ/K,EAAQ,GAG7C,IAAsB,IAAlBtB,KAAKiN,SACP5C,EAAKgC,QAAUuD,EACfvF,EAAKoH,SAAU,EACfvG,EAAS0E,MACJ,CAEH1E,GADEvD,EAAAA,EAAAA,GAAQiI,EAAKtO,IACNtB,KAAK2R,eAAetH,EAAMuF,EAAMtO,EAAOiQ,IACvCtK,EAAAA,EAAAA,GAAS2I,EAAKtO,IACdtB,KAAK4R,gBAAgBvH,EAAMuF,EAAMtO,EAAOiQ,GAExCvR,KAAK6R,mBAAmBxH,EAAMuF,EAAMtO,EAAOiQ,GAGtD,MAAMO,EAA6BA,IAAqB,OAAfvO,EAAI+H,IAAoBoG,GAAQnO,EAAI+H,GAASoG,EAAKpG,GAC3F,IAAKnJ,EAAI,EAAGA,EAAIoP,IAASpP,EACvBkI,EAAKgC,QAAQlK,EAAIb,GAASiC,EAAM2H,EAAO/I,GACnCqP,IACEM,MACFN,GAAS,GAEXE,EAAOnO,GAGX8G,EAAKoH,QAAUD,EAGbzD,GACF/C,EAAahL,KAAMkL,EAEvB,CAaA2G,mBAAmBxH,EAAMuF,EAAMtO,EAAOiQ,GACpC,MAAM,OAAClG,EAAA,OAAQR,GAAUR,EACnBiB,EAAQD,EAAOE,KACfC,EAAQX,EAAOU,KACfwG,EAAS1G,EAAO2G,YAChBC,EAAc5G,IAAWR,EACzBK,EAAS,IAAIoF,MAAMiB,GACzB,IAAIpP,EAAGsH,EAAMC,EAEb,IAAKvH,EAAI,EAAGsH,EAAO8H,EAAOpP,EAAIsH,IAAQtH,EACpCuH,EAAQvH,EAAIb,EACZ4J,EAAO/I,GAAK,CACV,CAACmJ,GAAQ2G,GAAe5G,EAAOiG,MAAMS,EAAOrI,GAAQA,GACpD,CAAC8B,GAAQX,EAAOyG,MAAM1B,EAAKlG,GAAQA,IAGvC,OAAOwB,CACT,CAaAyG,eAAetH,EAAMuF,EAAMtO,EAAOiQ,GAChC,MAAM,OAAC/B,EAAA,OAAQE,GAAUrF,EACnBa,EAAS,IAAIoF,MAAMiB,GACzB,IAAIpP,EAAGsH,EAAMC,EAAOxH,EAEpB,IAAKC,EAAI,EAAGsH,EAAO8H,EAAOpP,EAAIsH,IAAQtH,EACpCuH,EAAQvH,EAAIb,EACZY,EAAO0N,EAAKlG,GACZwB,EAAO/I,GAAK,CACVsM,EAAGe,EAAO8B,MAAMpP,EAAK,GAAIwH,GACzBgF,EAAGgB,EAAO4B,MAAMpP,EAAK,GAAIwH,IAG7B,OAAOwB,CACT,CAaA0G,gBAAgBvH,EAAMuF,EAAMtO,EAAOiQ,GACjC,MAAM,OAAC/B,EAAA,OAAQE,GAAUrF,GACnB,SAAC6H,EAAW,aAAKC,EAAW,KAAOnS,KAAKiN,SACxC/B,EAAS,IAAIoF,MAAMiB,GACzB,IAAIpP,EAAGsH,EAAMC,EAAOxH,EAEpB,IAAKC,EAAI,EAAGsH,EAAO8H,EAAOpP,EAAIsH,IAAQtH,EACpCuH,EAAQvH,EAAIb,EACZY,EAAO0N,EAAKlG,GACZwB,EAAO/I,GAAK,CACVsM,EAAGe,EAAO8B,OAAMc,EAAAA,EAAAA,GAAiBlQ,EAAMgQ,GAAWxI,GAClDgF,EAAGgB,EAAO4B,OAAMc,EAAAA,EAAAA,GAAiBlQ,EAAMiQ,GAAWzI,IAGtD,OAAOwB,CACT,CAKAmH,UAAU3I,GACR,OAAO1J,KAAKmL,YAAYkB,QAAQ3C,EAClC,CAKA4I,eAAe5I,GACb,OAAO1J,KAAKmL,YAAYyE,KAAKlG,EAC/B,CAKAC,WAAWX,EAAOkC,EAAQnB,GACxB,MAAMvJ,EAAQR,KAAKQ,MACb6J,EAAOrK,KAAKmL,YACZtC,EAAQqC,EAAOlC,EAAMuC,MAK3B,OAAO5B,EAJO,CACZvC,KAAMiC,EAAwB7I,GAAO,GACrCsH,OAAQoD,EAAOE,QAAQpC,EAAMuC,MAAMQ,eAEZlD,EAAOwB,EAAKX,MAAO,CAACK,QAC/C,CAKAwI,sBAAsBC,EAAOxJ,EAAOkC,EAAQtB,GAC1C,MAAM6I,EAAcvH,EAAOlC,EAAMuC,MACjC,IAAI1C,EAAwB,OAAhB4J,EAAuBC,IAAMD,EACzC,MAAM3K,EAAS8B,GAASsB,EAAOE,QAAQpC,EAAMuC,MACzC3B,GAAS9B,IACX8B,EAAM9B,OAASA,EACfe,EAAQc,EAAWC,EAAO6I,EAAazS,KAAKmL,YAAYzB,QAE1D8I,EAAMnR,IAAMD,KAAKC,IAAImR,EAAMnR,IAAKwH,GAChC2J,EAAMhP,IAAMpC,KAAKoC,IAAIgP,EAAMhP,IAAKqF,EAClC,CAKA8J,UAAU3J,EAAO4J,GACf,MAAMvI,EAAOrK,KAAKmL,YACZkB,EAAUhC,EAAKgC,QACfmF,EAASnH,EAAKoH,SAAWzI,IAAUqB,EAAKgB,OACxC5B,EAAO4C,EAAQpK,OACf4Q,EAAa7S,KAAKgQ,eAAehH,GACjCY,EA3YUkJ,EAACF,EAAUvI,EAAM7J,IAAUoS,IAAavI,EAAK0I,QAAU1I,EAAK0D,UAC3E,CAAC3G,KAAMiC,EAAwB7I,GAAO,GAAOsH,OAAQ,MA0YxCgL,CAAYF,EAAUvI,EAAMrK,KAAKQ,OACzCgS,EAAQ,CAACnR,IAAK2R,OAAOC,kBAAmBzP,IAAKwP,OAAOE,oBACnD7R,IAAK8R,EAAU3P,IAAK4P,GApf/B,SAAuBpK,GACrB,MAAM,IAAC3H,EAAG,IAAEmC,EAAG,WAAE6P,EAAU,WAAEC,GAActK,EAAMuK,gBACjD,MAAO,CACLlS,IAAKgS,EAAahS,EAAM2R,OAAOE,kBAC/B1P,IAAK8P,EAAa9P,EAAMwP,OAAOC,kBAEnC,CA8e2CM,CAAcV,GACrD,IAAI1Q,EAAG+I,EAEP,SAASsI,IACPtI,EAASmB,EAAQlK,GACjB,MAAM8H,EAAaiB,EAAO2H,EAAWtH,MACrC,QAAQrB,EAAAA,EAAAA,GAASgB,EAAOlC,EAAMuC,QAAU4H,EAAWlJ,GAAcmJ,EAAWnJ,CAC9E,CAEA,IAAK9H,EAAI,EAAGA,EAAIsH,IACV+J,MAGJxT,KAAKuS,sBAAsBC,EAAOxJ,EAAOkC,EAAQtB,IAC7C4H,MALkBrP,GAUxB,GAAIqP,EAEF,IAAKrP,EAAIsH,EAAO,EAAGtH,GAAK,IAAKA,EAC3B,IAAIqR,IAAJ,CAGAxT,KAAKuS,sBAAsBC,EAAOxJ,EAAOkC,EAAQtB,GACjD,MAGJ,OAAO4I,CACT,CAEAiB,mBAAmBzK,GACjB,MAAMkC,EAASlL,KAAKmL,YAAYkB,QAC1BvE,EAAS,GACf,IAAI3F,EAAGsH,EAAMZ,EAEb,IAAK1G,EAAI,EAAGsH,EAAOyB,EAAOjJ,OAAQE,EAAIsH,IAAQtH,EAC5C0G,EAAQqC,EAAO/I,GAAG6G,EAAMuC,OACpBrB,EAAAA,EAAAA,GAASrB,IACXf,EAAO5E,KAAK2F,GAGhB,OAAOf,CACT,CAMA4L,iBACE,OAAO,CACT,CAKAC,iBAAiBjK,GACf,MAAMW,EAAOrK,KAAKmL,YACZE,EAAShB,EAAKgB,OACdR,EAASR,EAAKQ,OACdK,EAASlL,KAAKqS,UAAU3I,GAC9B,MAAO,CACLkK,MAAOvI,EAAS,GAAKA,EAAOwI,iBAAiB3I,EAAOG,EAAOE,OAAS,GACpE1C,MAAOgC,EAAS,GAAKA,EAAOgJ,iBAAiB3I,EAAOL,EAAOU,OAAS,GAExE,CAKA5J,QAAQoI,GACN,MAAMM,EAAOrK,KAAKmL,YAClBnL,KAAKkG,OAAO6D,GAAQ,WACpBM,EAAKyJ,MA9oBT,SAAgBjL,GACd,IAAIkL,EAAGpF,EAAGqF,EAAGC,EAWb,OATIhN,EAAAA,EAAAA,GAAS4B,IACXkL,EAAIlL,EAAMqL,IACVvF,EAAI9F,EAAMsL,MACVH,EAAInL,EAAMuL,OACVH,EAAIpL,EAAMwL,MAEVN,EAAIpF,EAAIqF,EAAIC,EAAIpL,EAGX,CACLqL,IAAKH,EACLI,MAAOxF,EACPyF,OAAQJ,EACRK,KAAMJ,EACNK,UAAoB,IAAVzL,EAEd,CA2nBiB0L,EAAOzF,EAAAA,EAAAA,GAAe9O,KAAKgI,QAAQwM,KA7pBpD,SAAqBhF,EAAQE,EAAQzG,GACnC,IAAwB,IAApBA,EACF,OAAO,EAET,MAAMwF,EAAI1F,EAAUyG,EAAQvG,GACtByF,EAAI3F,EAAU2G,EAAQzG,GAE5B,MAAO,CACLiL,IAAKxF,EAAEtF,IACP+K,MAAO1F,EAAErF,IACTgL,OAAQ1F,EAAEpN,MACV+S,KAAM5F,EAAEnN,MAEZ,CAgpB0DmT,CAAYpK,EAAKmF,OAAQnF,EAAKqF,OAAQ1P,KAAK0T,mBACnG,CAKAxN,OAAO6D,GAAO,CAEd3H,OACE,MAAMyK,EAAM7M,KAAK4M,KACXpM,EAAQR,KAAKQ,MACb6J,EAAOrK,KAAKmL,YACZuJ,EAAWrK,EAAKuF,MAAQ,GACxB+E,EAAOnU,EAAMoU,UACb3O,EAAS,GACT3E,EAAQtB,KAAKqN,YAAc,EAC3BkE,EAAQvR,KAAKsN,YAAeoH,EAASzS,OAASX,EAC9CuT,EAA0B7U,KAAKgI,QAAQ6M,wBAC7C,IAAI1S,EAMJ,IAJIkI,EAAKiE,SACPjE,EAAKiE,QAAQlM,KAAKyK,EAAK8H,EAAMrT,EAAOiQ,GAGjCpP,EAAIb,EAAOa,EAAIb,EAAQiQ,IAASpP,EAAG,CACtC,MAAM2S,EAAUJ,EAASvS,GACrB2S,EAAQ/B,SAGR+B,EAAQ7O,QAAU4O,EACpB5O,EAAO/C,KAAK4R,GAEZA,EAAQ1S,KAAKyK,EAAK8H,GAEtB,CAEA,IAAKxS,EAAI,EAAGA,EAAI8D,EAAOhE,SAAUE,EAC/B8D,EAAO9D,GAAGC,KAAKyK,EAAK8H,EAExB,CASAI,SAASrL,EAAOzD,GACd,MAAM8D,EAAO9D,EAAS,SAAW,UACjC,YAAiB3F,IAAVoJ,GAAuB1J,KAAKmL,YAAYmD,QAC3CtO,KAAKgV,6BAA6BjL,GAClC/J,KAAKiV,0BAA0BvL,GAAS,EAAGK,EACjD,CAKAqH,WAAW1H,EAAOzD,EAAQ8D,GACxB,MAAMuE,EAAUtO,KAAKuO,aACrB,IAAI2G,EACJ,GAAIxL,GAAS,GAAKA,EAAQ1J,KAAKmL,YAAYyE,KAAK3N,OAAQ,CACtD,MAAM6S,EAAU9U,KAAKmL,YAAYyE,KAAKlG,GACtCwL,EAAUJ,EAAQrH,WACfqH,EAAQrH,SA3jBjB,SAA2B0H,EAAQzL,EAAOoL,GACxC,OAAOM,EAAAA,EAAAA,GAAcD,EAAQ,CAC3BlP,QAAQ,EACRoP,UAAW3L,EACXwB,YAAQ5K,EACRgV,SAAKhV,EACLwU,UACApL,QACAK,KAAM,UACNpJ,KAAM,QAEV,CAgjB4B4U,CAAkBvV,KAAKoR,aAAc1H,EAAOoL,IAClEI,EAAQhK,OAASlL,KAAKqS,UAAU3I,GAChCwL,EAAQI,IAAMhH,EAAQsB,KAAKlG,GAC3BwL,EAAQxL,MAAQwL,EAAQG,UAAY3L,OAEpCwL,EAAUlV,KAAKyN,WACZzN,KAAKyN,SA9kBd,SAA8B0H,EAAQzL,GACpC,OAAO0L,EAAAA,EAAAA,GAAcD,EACnB,CACElP,QAAQ,EACRqI,aAAShO,EACT0J,aAAcN,EACdA,QACAK,KAAM,UACNpJ,KAAM,WAGZ,CAmkByB6U,CAAqBxV,KAAKQ,MAAM4Q,aAAcpR,KAAK0J,QACtEwL,EAAQ5G,QAAUA,EAClB4G,EAAQxL,MAAQwL,EAAQlL,aAAehK,KAAK0J,MAK9C,OAFAwL,EAAQjP,SAAWA,EACnBiP,EAAQnL,KAAOA,EACRmL,CACT,CAMAF,6BAA6BjL,GAC3B,OAAO/J,KAAKyV,uBAAuBzV,KAAK2N,mBAAmBhC,GAAI5B,EACjE,CAOAkL,0BAA0BvL,EAAOK,GAC/B,OAAO/J,KAAKyV,uBAAuBzV,KAAK4N,gBAAgBjC,GAAI5B,EAAML,EACpE,CAKA+L,uBAAuBC,EAAa3L,EAAO,UAAWL,GACpD,MAAMzD,EAAkB,WAAT8D,EACT4L,EAAQ3V,KAAK8M,gBACb8I,EAAWF,EAAc,IAAM3L,EAC/ByC,EAASmJ,EAAMC,GACfC,EAAU7V,KAAKuN,sBAAuBuI,EAAAA,EAAAA,GAAQpM,GACpD,GAAI8C,EACF,OAAOD,EAAiBC,EAAQqJ,GAElC,MAAMhP,EAAS7G,KAAKQ,MAAMqG,OACpBkK,EAAYlK,EAAOkP,wBAAwB/V,KAAKgN,MAAO0I,GACvDM,EAAW/P,EAAS,CAAE,GAAEyP,SAAoB,QAASA,EAAa,IAAM,CAACA,EAAa,IACtFzE,EAASpK,EAAOqK,gBAAgBlR,KAAKuO,aAAcwC,GACnDkF,EAAQ9O,OAAOC,KAAKC,EAAAA,EAASqN,SAASgB,IAItC5N,EAASjB,EAAOqP,oBAAoBjF,EAAQgF,GADlCf,IAAMlV,KAAKoR,WAAW1H,EAAOzD,EAAQ8D,IACaiM,GAalE,OAXIlO,EAAOG,UAGTH,EAAOG,QAAU4N,EAKjBF,EAAMC,GAAYzO,OAAOgP,OAAO5J,EAAiBzE,EAAQ+N,KAGpD/N,CACT,CAMAsO,mBAAmB1M,EAAO2M,EAAYpQ,GACpC,MAAMzF,EAAQR,KAAKQ,MACbmV,EAAQ3V,KAAK8M,gBACb8I,EAAY,aAAYS,IACxB7J,EAASmJ,EAAMC,GACrB,GAAIpJ,EACF,OAAOA,EAET,IAAIxE,EACJ,IAAgC,IAA5BxH,EAAMwH,QAAQV,UAAqB,CACrC,MAAMT,EAAS7G,KAAKQ,MAAMqG,OACpBkK,EAAYlK,EAAOyP,0BAA0BtW,KAAKgN,MAAOqJ,GACzDpF,EAASpK,EAAOqK,gBAAgBlR,KAAKuO,aAAcwC,GACzD/I,EAAUnB,EAAOsK,eAAeF,EAAQjR,KAAKoR,WAAW1H,EAAOzD,EAAQoQ,IAEzE,MAAMhO,EAAa,IAAIzB,EAAWpG,EAAOwH,GAAWA,EAAQK,YAI5D,OAHIL,GAAWA,EAAQuO,aACrBZ,EAAMC,GAAYzO,OAAOgP,OAAO9N,IAE3BA,CACT,CAMAmO,iBAAiBxO,GACf,GAAKA,EAAQC,QAGb,OAAOjI,KAAKoN,iBAAmBpN,KAAKoN,eAAiBjG,OAAOe,OAAO,CAAC,EAAGF,GACzE,CAMAyO,eAAe1M,EAAM2M,GACnB,OAAQA,GAAiBpK,EAAmBvC,IAAS/J,KAAKQ,MAAMmW,mBAClE,CAKAC,kBAAkBtV,EAAOyI,GACvB,MAAM8M,EAAY7W,KAAKiV,0BAA0B3T,EAAOyI,GAClD+M,EAA0B9W,KAAKoN,eAC/BsJ,EAAgB1W,KAAKwW,iBAAiBK,GACtCJ,EAAiBzW,KAAKyW,eAAe1M,EAAM2M,IAAmBA,IAAkBI,EAEtF,OADA9W,KAAK+W,oBAAoBL,EAAe3M,EAAM8M,GACvC,CAACH,gBAAeD,iBACzB,CAMAO,cAAclC,EAASpL,EAAO9B,EAAYmC,GACpCuC,EAAmBvC,GACrB5C,OAAOe,OAAO4M,EAASlN,GAEvB5H,KAAKoW,mBAAmB1M,EAAOK,GAAM7D,OAAO4O,EAASlN,EAEzD,CAMAmP,oBAAoBL,EAAe3M,EAAMhC,GACnC2O,IAAkBpK,EAAmBvC,IACvC/J,KAAKoW,wBAAmB9V,EAAWyJ,GAAM7D,OAAOwQ,EAAe3O,EAEnE,CAKAkP,UAAUnC,EAASpL,EAAOK,EAAM9D,GAC9B6O,EAAQ7O,OAASA,EACjB,MAAM+B,EAAUhI,KAAK+U,SAASrL,EAAOzD,GACrCjG,KAAKoW,mBAAmB1M,EAAOK,EAAM9D,GAAQC,OAAO4O,EAAS,CAG3D9M,SAAW/B,GAAUjG,KAAKwW,iBAAiBxO,IAAaA,GAE5D,CAEAkP,iBAAiBpC,EAAS9K,EAAcN,GACtC1J,KAAKiX,UAAUnC,EAASpL,EAAO,UAAU,EAC3C,CAEAyN,cAAcrC,EAAS9K,EAAcN,GACnC1J,KAAKiX,UAAUnC,EAASpL,EAAO,UAAU,EAC3C,CAKA0N,2BACE,MAAMtC,EAAU9U,KAAKmL,YAAYmD,QAE7BwG,GACF9U,KAAKiX,UAAUnC,OAASxU,EAAW,UAAU,EAEjD,CAKA+W,wBACE,MAAMvC,EAAU9U,KAAKmL,YAAYmD,QAE7BwG,GACF9U,KAAKiX,UAAUnC,OAASxU,EAAW,UAAU,EAEjD,CAKAwQ,gBAAgBH,GACd,MAAMf,EAAO5P,KAAKkN,MACZwH,EAAW1U,KAAKmL,YAAYyE,KAGlC,IAAK,MAAOjJ,EAAQ2Q,EAAMC,KAASvX,KAAK0N,UACtC1N,KAAK2G,GAAQ2Q,EAAMC,GAErBvX,KAAK0N,UAAY,GAEjB,MAAM8J,EAAU9C,EAASzS,OACnBwV,EAAU7H,EAAK3N,OACfsP,EAAQnQ,KAAKC,IAAIoW,EAASD,GAE5BjG,GAKFvR,KAAKsR,MAAM,EAAGC,GAGZkG,EAAUD,EACZxX,KAAK0X,gBAAgBF,EAASC,EAAUD,EAAS7G,GACxC8G,EAAUD,GACnBxX,KAAK2X,gBAAgBF,EAASD,EAAUC,EAE5C,CAKAC,gBAAgBpW,EAAOiQ,EAAOZ,GAAmB,GAC/C,MAAMtG,EAAOrK,KAAKmL,YACZyE,EAAOvF,EAAKuF,KACZxG,EAAM9H,EAAQiQ,EACpB,IAAIpP,EAEJ,MAAMyV,EAAQC,IAEZ,IADAA,EAAI5V,QAAUsP,EACTpP,EAAI0V,EAAI5V,OAAS,EAAGE,GAAKiH,EAAKjH,IACjC0V,EAAI1V,GAAK0V,EAAI1V,EAAIoP,EACnB,EAIF,IAFAqG,EAAKhI,GAEAzN,EAAIb,EAAOa,EAAIiH,IAAOjH,EACzByN,EAAKzN,GAAK,IAAInC,KAAK4N,gBAGjB5N,KAAKiN,UACP2K,EAAKvN,EAAKgC,SAEZrM,KAAKsR,MAAMhQ,EAAOiQ,GAEdZ,GACF3Q,KAAK8X,eAAelI,EAAMtO,EAAOiQ,EAAO,QAE5C,CAEAuG,eAAehD,EAASxT,EAAOiQ,EAAOxH,GAAO,CAK7C4N,gBAAgBrW,EAAOiQ,GACrB,MAAMlH,EAAOrK,KAAKmL,YAClB,GAAInL,KAAKiN,SAAU,CACjB,MAAM8K,EAAU1N,EAAKgC,QAAQ2L,OAAO1W,EAAOiQ,GACvClH,EAAK0D,UACP3B,EAAY/B,EAAM0N,GAGtB1N,EAAKuF,KAAKoI,OAAO1W,EAAOiQ,EAC1B,CAKA0G,MAAMC,GACJ,GAAIlY,KAAKiN,SACPjN,KAAK0N,UAAUxK,KAAKgV,OACf,CACL,MAAOvR,EAAQ2Q,EAAMC,GAAQW,EAC7BlY,KAAK2G,GAAQ2Q,EAAMC,GAErBvX,KAAKQ,MAAM2X,aAAajV,KAAK,CAAClD,KAAK0J,SAAUwO,GAC/C,CAEAE,cACE,MAAM7G,EAAQ8G,UAAUpW,OACxBjC,KAAKiY,MAAM,CAAC,kBAAmBjY,KAAKuO,aAAaqB,KAAK3N,OAASsP,EAAOA,GACxE,CAEA+G,aACEtY,KAAKiY,MAAM,CAAC,kBAAmBjY,KAAKmL,YAAYyE,KAAK3N,OAAS,EAAG,GACnE,CAEAsW,eACEvY,KAAKiY,MAAM,CAAC,kBAAmB,EAAG,GACpC,CAEAO,cAAclX,EAAOiQ,GACfA,GACFvR,KAAKiY,MAAM,CAAC,kBAAmB3W,EAAOiQ,IAExC,MAAMkH,EAAWJ,UAAUpW,OAAS,EAChCwW,GACFzY,KAAKiY,MAAM,CAAC,kBAAmB3W,EAAOmX,GAE1C,CAEAC,iBACE1Y,KAAKiY,MAAM,CAAC,kBAAmB,EAAGI,UAAUpW,QAC9C,EChhCF,SAAS0W,EAAqBtO,GAC5B,MAAMrB,EAAQqB,EAAKgB,OACbvD,EAnBR,SAA2BkB,EAAOrI,GAChC,IAAKqI,EAAM4P,OAAOC,KAAM,CACtB,MAAMC,EAAe9P,EAAM+B,wBAAwBpK,GACnD,IAAImH,EAAS,GAEb,IAAK,IAAI3F,EAAI,EAAGsH,EAAOqP,EAAa7W,OAAQE,EAAIsH,EAAMtH,IACpD2F,EAASA,EAAOiR,OAAOD,EAAa3W,GAAG8I,WAAWwI,mBAAmBzK,IAEvEA,EAAM4P,OAAOC,MAAOG,EAAAA,EAAAA,GAAalR,EAAOmR,MAAK,CAACC,EAAGlF,IAAMkF,EAAIlF,KAE7D,OAAOhL,EAAM4P,OAAOC,IACtB,CAQiBM,CAAkBnQ,EAAOqB,EAAK1J,MAC7C,IACIwB,EAAGsH,EAAM2P,EAAM1H,EADfrQ,EAAM2H,EAAMqQ,QAEhB,MAAMC,EAAmBA,KACV,QAATF,IAA4B,QAAVA,KAIlBtD,EAAAA,EAAAA,GAAQpE,KAEVrQ,EAAMD,KAAKC,IAAIA,EAAKD,KAAKmY,IAAIH,EAAO1H,IAASrQ,IAE/CqQ,EAAO0H,EAAA,EAGT,IAAKjX,EAAI,EAAGsH,EAAO3B,EAAO7F,OAAQE,EAAIsH,IAAQtH,EAC5CiX,EAAOpQ,EAAMwQ,iBAAiB1R,EAAO3F,IACrCmX,IAIF,IADA5H,OAAOpR,EACF6B,EAAI,EAAGsH,EAAOT,EAAMyQ,MAAMxX,OAAQE,EAAIsH,IAAQtH,EACjDiX,EAAOpQ,EAAM0Q,gBAAgBvX,GAC7BmX,IAGF,OAAOjY,CACT,CA2FA,SAASsY,EAAWC,EAAO1X,EAAM2I,EAAQ1I,GAMvC,OALIwF,EAAAA,EAAAA,GAAQiS,GA5Bd,SAAuBA,EAAO1X,EAAM2I,EAAQ1I,GAC1C,MAAM0X,EAAahP,EAAOyG,MAAMsI,EAAM,GAAIzX,GACpC2X,EAAWjP,EAAOyG,MAAMsI,EAAM,GAAIzX,GAClCd,EAAMD,KAAKC,IAAIwY,EAAYC,GAC3BtW,EAAMpC,KAAKoC,IAAIqW,EAAYC,GACjC,IAAIC,EAAW1Y,EACX2Y,EAASxW,EAETpC,KAAKmY,IAAIlY,GAAOD,KAAKmY,IAAI/V,KAC3BuW,EAAWvW,EACXwW,EAAS3Y,GAKXa,EAAK2I,EAAOU,MAAQyO,EAEpB9X,EAAK+X,QAAU,CACbF,WACAC,SACA1Y,MAAOuY,EACPzQ,IAAK0Q,EACLzY,MACAmC,MAEJ,CAII0W,CAAcN,EAAO1X,EAAM2I,EAAQ1I,GAEnCD,EAAK2I,EAAOU,MAAQV,EAAOyG,MAAMsI,EAAOzX,GAEnCD,CACT,CAEA,SAASiY,EAAsB9P,EAAMuF,EAAMtO,EAAOiQ,GAChD,MAAMlG,EAAShB,EAAKgB,OACdR,EAASR,EAAKQ,OACdkH,EAAS1G,EAAO2G,YAChBC,EAAc5G,IAAWR,EACzBK,EAAS,GACf,IAAI/I,EAAGsH,EAAMvH,EAAM0X,EAEnB,IAAKzX,EAAIb,EAAOmI,EAAOnI,EAAQiQ,EAAOpP,EAAIsH,IAAQtH,EAChDyX,EAAQhK,EAAKzN,GACbD,EAAO,CAAC,EACRA,EAAKmJ,EAAOE,MAAQ0G,GAAe5G,EAAOiG,MAAMS,EAAO5P,GAAIA,GAC3D+I,EAAOhI,KAAKyW,EAAWC,EAAO1X,EAAM2I,EAAQ1I,IAE9C,OAAO+I,CACT,CAEA,SAASkP,EAAWC,GAClB,OAAOA,QAA8B/Z,IAApB+Z,EAAON,eAA4CzZ,IAAlB+Z,EAAOL,MAC3D,CA8BA,SAASM,EAAiB1S,EAAYI,EAAS4B,EAAOF,GACpD,IAAI6Q,EAAOvS,EAAQwS,cACnB,MAAMhU,EAAM,CAAC,EAEb,IAAK+T,EAEH,YADA3S,EAAW4S,cAAgBhU,GAI7B,IAAa,IAAT+T,EAEF,YADA3S,EAAW4S,cAAgB,CAACtG,KAAK,EAAMC,OAAO,EAAMC,QAAQ,EAAMC,MAAM,IAI1E,MAAM,MAAC/S,EAAA,IAAO8H,EAAA,QAAKD,EAAA,IAAS+K,EAAA,OAAKE,GAnCnC,SAAqBxM,GACnB,IAAIuB,EAAS7H,EAAO8H,EAAK8K,EAAKE,EAiB9B,OAhBIxM,EAAW6S,YACbtR,EAAUvB,EAAW8S,KAAO9S,EAAW6G,EACvCnN,EAAQ,OACR8H,EAAM,UAEND,EAAUvB,EAAW8S,KAAO9S,EAAW8G,EACvCpN,EAAQ,SACR8H,EAAM,OAEJD,GACF+K,EAAM,MACNE,EAAS,UAETF,EAAM,QACNE,EAAS,OAEJ,CAAC9S,QAAO8H,MAAKD,UAAS+K,MAAKE,SACpC,CAgB6CuG,CAAY/S,GAE1C,WAAT2S,GAAqB3Q,IACvBhC,EAAWgT,oBAAqB,GAC3BhR,EAAMiC,MAAQ,KAAOnC,EACxB6Q,EAAOrG,GACGtK,EAAMkC,SAAW,KAAOpC,EAClC6Q,EAAOnG,GAEP5N,EAAIqU,EAAUzG,EAAQ9S,EAAO8H,EAAKD,KAAY,EAC9CoR,EAAOrG,IAIX1N,EAAIqU,EAAUN,EAAMjZ,EAAO8H,EAAKD,KAAY,EAC5CvB,EAAW4S,cAAgBhU,CAC7B,CAEA,SAASqU,EAAUN,EAAMrB,EAAGlF,EAAG7K,GAU/B,IAAc2R,EAAMC,EAAIC,EAHtB,OANI7R,GASkB6R,EARChH,EACrBuG,EAAOU,EADPV,GAQUO,EAREP,MAQIQ,EARE7B,GASC8B,EAAKF,IAASE,EAAKD,EAAKD,EARrB9G,EAAGkF,IAEzBqB,EAAOU,EAASV,EAAMrB,EAAGlF,GAEpBuG,CACT,CAMA,SAASU,EAASC,EAAG5Z,EAAO8H,GAC1B,MAAa,UAAN8R,EAAgB5Z,EAAc,QAAN4Z,EAAc9R,EAAM8R,CACrD,CAEA,SAASC,EAAiBvT,GAAY,cAACwT,GAAgBC,GACrDzT,EAAWwT,cAAkC,SAAlBA,EACb,IAAVC,EAAc,IAAO,EACrBD,CACN,CAEe,MAAME,UAAsB5O,EAEzCC,UAAY,MAKZA,gBAAkB,CAChBgB,oBAAoB,EACpBC,gBAAiB,MAEjB2N,mBAAoB,GACpBC,cAAe,GACfC,SAAS,EAETpT,WAAY,CACVqT,QAAS,CACP/a,KAAM,SACNiH,WAAY,CAAC,IAAK,IAAK,OAAQ,QAAS,aAQ9C+E,iBAAmB,CACjBV,OAAQ,CACN0P,QAAS,CACPhb,KAAM,WACNib,QAAQ,EACRC,KAAM,CACJD,QAAQ,IAGZE,QAAS,CACPnb,KAAM,SACNob,aAAa,KAWnBlK,mBAAmBxH,EAAMuF,EAAMtO,EAAOiQ,GACpC,OAAO4I,EAAsB9P,EAAMuF,EAAMtO,EAAOiQ,EAClD,CAOAI,eAAetH,EAAMuF,EAAMtO,EAAOiQ,GAChC,OAAO4I,EAAsB9P,EAAMuF,EAAMtO,EAAOiQ,EAClD,CAOAK,gBAAgBvH,EAAMuF,EAAMtO,EAAOiQ,GACjC,MAAM,OAAClG,EAAA,OAAQR,GAAUR,GACnB,SAAC6H,EAAW,aAAKC,EAAW,KAAOnS,KAAKiN,SACxC+O,EAA2B,MAAhB3Q,EAAOE,KAAe2G,EAAWC,EAC5C8J,EAA2B,MAAhBpR,EAAOU,KAAe2G,EAAWC,EAC5CjH,EAAS,GACf,IAAI/I,EAAGsH,EAAMvH,EAAMga,EACnB,IAAK/Z,EAAIb,EAAOmI,EAAOnI,EAAQiQ,EAAOpP,EAAIsH,IAAQtH,EAChD+Z,EAAMtM,EAAKzN,GACXD,EAAO,CAAC,EACRA,EAAKmJ,EAAOE,MAAQF,EAAOiG,OAAMc,EAAAA,EAAAA,GAAiB8J,EAAKF,GAAW7Z,GAClE+I,EAAOhI,KAAKyW,GAAWvH,EAAAA,EAAAA,GAAiB8J,EAAKD,GAAW/Z,EAAM2I,EAAQ1I,IAExE,OAAO+I,CACT,CAKAqH,sBAAsBC,EAAOxJ,EAAOkC,EAAQtB,GAC1CuS,MAAM5J,sBAAsBC,EAAOxJ,EAAOkC,EAAQtB,GAClD,MAAMyQ,EAASnP,EAAO+O,QAClBI,GAAUrR,IAAUhJ,KAAKmL,YAAYN,SAEvC2H,EAAMnR,IAAMD,KAAKC,IAAImR,EAAMnR,IAAKgZ,EAAOhZ,KACvCmR,EAAMhP,IAAMpC,KAAKoC,IAAIgP,EAAMhP,IAAK6W,EAAO7W,KAE3C,CAMAkQ,iBACE,OAAO,CACT,CAKAC,iBAAiBjK,GACf,MAAMW,EAAOrK,KAAKmL,aACZ,OAACE,EAAA,OAAQR,GAAUR,EACnBa,EAASlL,KAAKqS,UAAU3I,GACxB2Q,EAASnP,EAAO+O,QAChBpR,EAAQuR,EAAWC,GACrB,IAAMA,EAAO/Y,MAAQ,KAAO+Y,EAAOjR,IAAM,IACzC,GAAKyB,EAAOgJ,iBAAiB3I,EAAOL,EAAOU,OAE/C,MAAO,CACLqI,MAAO,GAAKvI,EAAOwI,iBAAiB3I,EAAOG,EAAOE,OAClD1C,QAEJ,CAEAgF,aACE7N,KAAKuN,qBAAsB,EAE3B4O,MAAMtO,aAEO7N,KAAKmL,YACbvB,MAAQ5J,KAAKuO,aAAa3E,KACjC,CAEA1D,OAAO6D,GACL,MAAMM,EAAOrK,KAAKmL,YAClBnL,KAAK8X,eAAezN,EAAKuF,KAAM,EAAGvF,EAAKuF,KAAK3N,OAAQ8H,EACtD,CAEA+N,eAAesE,EAAM9a,EAAOiQ,EAAOxH,GACjC,MAAMkG,EAAiB,UAATlG,GACR,MAACL,EAAOyB,aAAa,OAACN,IAAW7K,KACjC0a,EAAO7P,EAAOwR,eACd5B,EAAa5P,EAAOyR,eACpBC,EAAQvc,KAAKwc,aACb,cAAC9F,EAAa,eAAED,GAAkBzW,KAAK4W,kBAAkBtV,EAAOyI,GAEtE,IAAK,IAAI5H,EAAIb,EAAOa,EAAIb,EAAQiQ,EAAOpP,IAAK,CAC1C,MAAM+I,EAASlL,KAAKqS,UAAUlQ,GACxBsa,EAAUxM,IAASyM,EAAAA,EAAAA,GAAcxR,EAAOL,EAAOU,OAAS,CAACmP,OAAMiC,KAAMjC,GAAQ1a,KAAK4c,yBAAyBza,GAC3G0a,EAAU7c,KAAK8c,yBAAyB3a,EAAGoa,GAC3C3S,GAASsB,EAAOE,SAAW,CAAC,GAAGP,EAAOU,MAEtC3D,EAAa,CACjB6S,aACAC,KAAM+B,EAAQ/B,KACdE,oBAAqBhR,GAASwQ,EAAWlP,EAAO+O,UAAavQ,IAAUE,EAAMiC,MAAQnC,IAAUE,EAAMkC,QACrG2C,EAAGgM,EAAagC,EAAQE,KAAOE,EAAQE,OACvCrO,EAAG+L,EAAaoC,EAAQE,OAASN,EAAQE,KACzCK,OAAQvC,EAAaoC,EAAQ/T,KAAO1H,KAAKmY,IAAIkD,EAAQ3T,MACrDmU,MAAOxC,EAAarZ,KAAKmY,IAAIkD,EAAQ3T,MAAQ+T,EAAQ/T,MAGnD2N,IACF7O,EAAWI,QAAU0O,GAAiB1W,KAAKiV,0BAA0B9S,EAAGia,EAAKja,GAAG8D,OAAS,SAAW8D,IAEtG,MAAM/B,EAAUJ,EAAWI,SAAWoU,EAAKja,GAAG6F,QAC9CsS,EAAiB1S,EAAYI,EAAS4B,EAAOF,GAC7CyR,EAAiBvT,EAAYI,EAASuU,EAAMlB,OAC5Crb,KAAKgX,cAAcoF,EAAKja,GAAIA,EAAGyF,EAAYmC,EAC7C,CACF,CASAmT,WAAWC,EAAM9H,GACf,MAAM,OAAChK,GAAUrL,KAAKmL,YAChB5B,EAAW8B,EAAON,wBAAwB/K,KAAKgN,OAClDd,QAAO7B,GAAQA,EAAKY,WAAWjD,QAAQyT,UACpCnR,EAAUe,EAAOrD,QAAQsC,QACzBE,EAAS,GAET4S,EAAY/S,IAChB,MAAMa,EAASb,EAAKY,WAAWoH,UAAUgD,GACnCgI,EAAMnS,GAAUA,EAAOb,EAAKQ,OAAOU,MAEzC,IAAImR,EAAAA,EAAAA,GAAcW,IAAQC,MAAMD,GAC9B,OAAO,GAIX,IAAK,MAAMhT,KAAQd,EACjB,SAAkBjJ,IAAd+U,IAA2B+H,EAAS/S,QASxB,IAAZC,IAAqD,IAAhCE,EAAO+S,QAAQlT,EAAKT,aAClCtJ,IAAZgK,QAAwChK,IAAf+J,EAAKT,QAC3BY,EAAOtH,KAAKmH,EAAKT,OAEfS,EAAKX,QAAUyT,GACjB,MAWJ,OAJK3S,EAAOvI,QACVuI,EAAOtH,UAAK5C,GAGPkK,CACT,CAMAgT,eAAe9T,GACb,OAAO1J,KAAKkd,gBAAW5c,EAAWoJ,GAAOzH,MAC3C,CAUAwb,eAAezT,EAAc0T,EAAMrI,GACjC,MAAM7K,EAASxK,KAAKkd,WAAWlT,EAAcqL,GACvC3L,OAAkBpJ,IAAVod,EACVlT,EAAO+S,QAAQG,IACd,EAEL,OAAmB,IAAXhU,EACJc,EAAOvI,OAAS,EAChByH,CACN,CAKA8S,YACE,MAAMtT,EAAOlJ,KAAKgI,QACZqC,EAAOrK,KAAKmL,YACZE,EAAShB,EAAKgB,OACdsS,EAAS,GACf,IAAIxb,EAAGsH,EAEP,IAAKtH,EAAI,EAAGsH,EAAOY,EAAKuF,KAAK3N,OAAQE,EAAIsH,IAAQtH,EAC/Cwb,EAAOza,KAAKmI,EAAOmO,iBAAiBxZ,KAAKqS,UAAUlQ,GAAGkJ,EAAOE,MAAOpJ,IAGtE,MAAMyb,EAAe1U,EAAK0U,aAG1B,MAAO,CACLvc,IAHUuc,GAAgBjF,EAAqBtO,GAI/CsT,SACArc,MAAO+J,EAAOwS,YACdzU,IAAKiC,EAAOyS,UACZC,WAAY/d,KAAKwd,iBACjBxU,MAAOqC,EACPoQ,QAASvS,EAAKuS,QAEdJ,MAAOuC,EAAe,EAAI1U,EAAKqS,mBAAqBrS,EAAKsS,cAE7D,CAMAoB,yBAAyBlT,GACvB,MAAOyB,aAAa,OAACN,EAAA,SAAQkD,EAAUrE,MAAOM,GAAehC,SAAU0S,KAAMsD,EAAS,aAAEC,IAAiBje,KACnGke,EAAaF,GAAa,EAC1B9S,EAASlL,KAAKqS,UAAU3I,GACxB2Q,EAASnP,EAAO+O,QAChBkE,EAAW/D,EAAWC,GAC5B,IAGIsC,EAAM7T,EAHND,EAAQqC,EAAOL,EAAOU,MACtBjK,EAAQ,EACRW,EAAS8L,EAAW/N,KAAK2J,WAAWkB,EAAQK,EAAQ6C,GAAYlF,EAGhE5G,IAAW4G,IACbvH,EAAQW,EAAS4G,EACjB5G,EAAS4G,GAGPsV,IACFtV,EAAQwR,EAAON,SACf9X,EAASoY,EAAOL,OAASK,EAAON,SAElB,IAAVlR,IAAesB,EAAAA,EAAAA,GAAKtB,MAAWsB,EAAAA,EAAAA,GAAKkQ,EAAOL,UAC7C1Y,EAAQ,GAEVA,GAASuH,GAGX,MAAMgR,GAAc6C,EAAAA,EAAAA,GAAcsB,IAAeG,EAAuB7c,EAAZ0c,EAC5D,IAAItD,EAAO7P,EAAO2O,iBAAiBK,GAWnC,GARE8C,EADE3c,KAAKQ,MAAM4d,kBAAkB1U,GACxBmB,EAAO2O,iBAAiBlY,EAAQW,GAGhCyY,EAGT5R,EAAO6T,EAAOjC,EAEVtZ,KAAKmY,IAAIzQ,GAAQmV,EAAc,CACjCnV,EArZN,SAAiBA,EAAM+B,EAAQqT,GAC7B,OAAa,IAATpV,GACKqB,EAAAA,EAAAA,GAAKrB,IAEN+B,EAAOyR,eAAiB,GAAK,IAAMzR,EAAOxJ,KAAO6c,EAAa,GAAK,EAC7E,CAgZaG,CAAQvV,EAAM+B,EAAQqT,GAAcD,EACvCpV,IAAUqV,IACZxD,GAAQ5R,EAAO,GAEjB,MAAMwV,EAAazT,EAAO0T,mBAAmB,GACvCC,EAAW3T,EAAO0T,mBAAmB,GACrCld,EAAMD,KAAKC,IAAIid,EAAYE,GAC3Bhb,EAAMpC,KAAKoC,IAAI8a,EAAYE,GACjC9D,EAAOtZ,KAAKoC,IAAIpC,KAAKC,IAAIqZ,EAAMlX,GAAMnC,GACrCsb,EAAOjC,EAAO5R,EAEViF,IAAaoQ,IAEfjT,EAAOE,QAAQP,EAAOU,MAAMQ,cAAc/B,GAAgBa,EAAO4T,iBAAiB9B,GAAQ9R,EAAO4T,iBAAiB/D,IAItH,GAAIA,IAAS7P,EAAO2O,iBAAiB0E,GAAa,CAChD,MAAMQ,GAAWvU,EAAAA,EAAAA,GAAKrB,GAAQ+B,EAAO8T,qBAAqBT,GAAc,EACxExD,GAAQgE,EACR5V,GAAQ4V,EAGV,MAAO,CACL5V,OACA4R,OACAiC,OACAI,OAAQJ,EAAO7T,EAAO,EAE1B,CAKAgU,yBAAyBpT,EAAO6S,GAC9B,MAAMvT,EAAQuT,EAAMvT,MACdhB,EAAUhI,KAAKgI,QACfoV,EAAWpV,EAAQoV,SACnBwB,GAAkB9P,EAAAA,EAAAA,GAAe9G,EAAQ4W,gBAAiBC,KAChE,IAAI9B,EAAQjU,EACZ,GAAIyT,EAAMd,QAAS,CACjB,MAAMsC,EAAaX,EAAWpd,KAAKwd,eAAe9T,GAAS6S,EAAMwB,WAC3DvL,EAAiC,SAAzBxK,EAAQ4V,aAphB5B,SAAmClU,EAAO6S,EAAOvU,EAAS+V,GACxD,MAAMJ,EAASpB,EAAMoB,OACfvE,EAAOuE,EAAOjU,GACpB,IAAIgI,EAAOhI,EAAQ,EAAIiU,EAAOjU,EAAQ,GAAK,KACvCoV,EAAOpV,EAAQiU,EAAO1b,OAAS,EAAI0b,EAAOjU,EAAQ,GAAK,KAC3D,MAAMqV,EAAU/W,EAAQuT,mBAEX,OAAT7J,IAGFA,EAAO0H,GAAiB,OAAT0F,EAAgBvC,EAAMnT,IAAMmT,EAAMjb,MAAQwd,EAAO1F,IAGrD,OAAT0F,IAEFA,EAAO1F,EAAOA,EAAO1H,GAGvB,MAAMpQ,EAAQ8X,GAAQA,EAAOhY,KAAKC,IAAIqQ,EAAMoN,IAAS,EAAIC,EAGzD,MAAO,CACLC,MAHW5d,KAAKmY,IAAIuF,EAAOpN,GAAQ,EAAIqN,EAGzBhB,EACd1C,MAAOrT,EAAQwT,cACfla,QAEJ,CA2fU2d,CAA0BvV,EAAO6S,EAAOvU,EAAS+V,GAjjB3D,SAAkCrU,EAAO6S,EAAOvU,EAAS+V,GACvD,MAAMmB,EAAYlX,EAAQ4V,aAC1B,IAAI9U,EAAMuS,EAaV,OAXIqB,EAAAA,EAAAA,GAAcwC,IAChBpW,EAAOyT,EAAMlb,IAAM2G,EAAQuT,mBAC3BF,EAAQrT,EAAQwT,gBAKhB1S,EAAOoW,EAAYnB,EACnB1C,EAAQ,GAGH,CACL2D,MAAOlW,EAAOiV,EACd1C,QACA/Z,MAAOib,EAAMoB,OAAOjU,GAAUZ,EAAO,EAEzC,CA8hBUqW,CAAyBzV,EAAO6S,EAAOvU,EAAS+V,GAE9CqB,EAAapf,KAAKyd,eAAezd,KAAK0J,MAAO1J,KAAKmL,YAAYvB,MAAOwT,EAAW1T,OAAQpJ,GAC9Fyc,EAASvK,EAAMlR,MAASkR,EAAMwM,MAAQI,EAAe5M,EAAMwM,MAAQ,EACnElW,EAAO1H,KAAKC,IAAIud,EAAiBpM,EAAMwM,MAAQxM,EAAM6I,YAGrD0B,EAAS/T,EAAMwQ,iBAAiBxZ,KAAKqS,UAAU3I,GAAOV,EAAMuC,MAAO7B,GACnEZ,EAAO1H,KAAKC,IAAIud,EAAiBrC,EAAMlb,IAAMkb,EAAMlB,OAGrD,MAAO,CACLX,KAAMqC,EAASjU,EAAO,EACtB6T,KAAMI,EAASjU,EAAO,EACtBiU,SACAjU,OAEJ,CAEA1G,OACE,MAAMiI,EAAOrK,KAAKmL,YACZN,EAASR,EAAKQ,OACdwU,EAAQhV,EAAKuF,KACbnG,EAAO4V,EAAMpd,OACnB,IAAIE,EAAI,EAER,KAAOA,EAAIsH,IAAQtH,EACsB,OAAnCnC,KAAKqS,UAAUlQ,GAAG0I,EAAOU,OAC3B8T,EAAMld,GAAGC,KAAKpC,KAAK4M,KAGzB,ECxoBa,MAAM0S,UAAuB5S,EAE1CC,UAAY,OAKZA,gBAAkB,CAChBgB,mBAAoB,OACpBC,gBAAiB,QAEjB2R,UAAU,EACVC,UAAU,GAMZ7S,iBAAmB,CACjBV,OAAQ,CACN0P,QAAS,CACPhb,KAAM,YAERmb,QAAS,CACPnb,KAAM,YAKZkN,aACE7N,KAAKuN,qBAAsB,EAC3BvN,KAAKwN,oBAAqB,EAC1B2O,MAAMtO,YACR,CAEA3H,OAAO6D,GACL,MAAMM,EAAOrK,KAAKmL,aACXmD,QAASmR,EAAM7P,KAAM8P,EAAS,GAAE,SAAEC,GAAYtV,EAE/CuV,EAAqB5f,KAAKQ,MAAMmW,oBACtC,IAAI,MAACrV,EAAA,MAAOiQ,IAASsO,EAAAA,EAAAA,GAAiCxV,EAAMqV,EAAQE,GAEpE5f,KAAKqN,WAAa/L,EAClBtB,KAAKsN,WAAaiE,GAEduO,EAAAA,EAAAA,GAAoBzV,KACtB/I,EAAQ,EACRiQ,EAAQmO,EAAOzd,QAIjBwd,EAAK3Y,OAAS9G,KAAKQ,MACnBif,EAAKM,cAAgB/f,KAAK0J,MAC1B+V,EAAKO,aAAeL,EAASK,WAC7BP,EAAKC,OAASA,EAEd,MAAM1X,EAAUhI,KAAKgV,6BAA6BjL,GAC7C/J,KAAKgI,QAAQuX,WAChBvX,EAAQiY,YAAc,GAExBjY,EAAQkY,QAAUlgB,KAAKgI,QAAQkY,QAC/BlgB,KAAKgX,cAAcyI,OAAMnf,EAAW,CAClC6f,UAAWP,EACX5X,WACC+B,GAGH/J,KAAK8X,eAAe4H,EAAQpe,EAAOiQ,EAAOxH,EAC5C,CAEA+N,eAAe4H,EAAQpe,EAAOiQ,EAAOxH,GACnC,MAAMkG,EAAiB,UAATlG,GACR,OAACsB,EAAA,OAAQR,EAAA,SAAQkD,EAAA,SAAU4R,GAAY3f,KAAKmL,aAC5C,cAACuL,EAAa,eAAED,GAAkBzW,KAAK4W,kBAAkBtV,EAAOyI,GAChEuB,EAAQD,EAAOE,KACfC,EAAQX,EAAOU,MACf,SAACiU,EAAA,QAAUU,GAAWlgB,KAAKgI,QAC3BoY,GAAeC,EAAAA,EAAAA,GAASb,GAAYA,EAAWxM,OAAOC,kBACtDqN,EAAetgB,KAAKQ,MAAMmW,qBAAuB1G,GAAkB,SAATlG,EAC1DX,EAAM9H,EAAQiQ,EACdgP,EAAcb,EAAOzd,OAC3B,IAAIue,EAAalf,EAAQ,GAAKtB,KAAKqS,UAAU/Q,EAAQ,GAErD,IAAK,IAAIa,EAAI,EAAGA,EAAIoe,IAAepe,EAAG,CACpC,MAAMse,EAAQf,EAAOvd,GACfyF,EAAa0Y,EAAeG,EAAQ,GAE1C,GAAIte,EAAIb,GAASa,GAAKiH,EAAK,CACzBxB,EAAW8Y,MAAO,EAClB,SAGF,MAAMxV,EAASlL,KAAKqS,UAAUlQ,GACxBwe,GAAWjE,EAAAA,EAAAA,GAAcxR,EAAOM,IAChCoV,EAAShZ,EAAW0D,GAASD,EAAOmO,iBAAiBtO,EAAOI,GAAQnJ,GACpE0e,EAASjZ,EAAW4D,GAASyE,GAAS0Q,EAAW9V,EAAOwR,eAAiBxR,EAAO2O,iBAAiBzL,EAAW/N,KAAK2J,WAAWkB,EAAQK,EAAQ6C,GAAY7C,EAAOM,GAAQrJ,GAE7KyF,EAAW8Y,KAAOpD,MAAMsD,IAAWtD,MAAMuD,IAAWF,EACpD/Y,EAAWlE,KAAOvB,EAAI,GAAKf,KAAMmY,IAAIrO,EAAOI,GAASkV,EAAWlV,IAAW8U,EACvEF,IACFtY,EAAWsD,OAASA,EACpBtD,EAAW0N,IAAMqK,EAAS/P,KAAKzN,IAG7BsU,IACF7O,EAAWI,QAAU0O,GAAiB1W,KAAKiV,0BAA0B9S,EAAGse,EAAMxa,OAAS,SAAW8D,IAG/FuW,GACHtgB,KAAKgX,cAAcyJ,EAAOte,EAAGyF,EAAYmC,GAG3CyW,EAAatV,CACf,CACF,CAKAwI,iBACE,MAAMrJ,EAAOrK,KAAKmL,YACZmD,EAAUjE,EAAKiE,QACfwS,EAASxS,EAAQtG,SAAWsG,EAAQtG,QAAQiY,aAAe,EAC3DrQ,EAAOvF,EAAKuF,MAAQ,GAC1B,IAAKA,EAAK3N,OACR,OAAO6e,EAET,MAAMC,EAAanR,EAAK,GAAG9G,KAAK9I,KAAKiV,0BAA0B,IACzD+L,EAAYpR,EAAKA,EAAK3N,OAAS,GAAG6G,KAAK9I,KAAKiV,0BAA0BrF,EAAK3N,OAAS,IAC1F,OAAOb,KAAKoC,IAAIsd,EAAQC,EAAYC,GAAa,CACnD,CAEA5e,OACE,MAAMiI,EAAOrK,KAAKmL,YAClBd,EAAKiE,QAAQ2S,oBAAoBjhB,KAAKQ,MAAMoU,UAAWvK,EAAKgB,OAAOE,MACnE4Q,MAAM/Z,MACR,ECxHF,SAAS8e,EAAaC,EAAS5V,EAAM1C,EAAOuY,GAC1C,MAAM,WAACnW,EAAU,KAAE2E,EAAA,QAAM6B,GAAW0P,EAC9B9V,EAASJ,EAAWE,YAAYE,OACtC,GAAIA,GAAUE,IAASF,EAAOE,MAAiB,MAATA,GAAgBkG,GAAW7B,EAAK3N,OAAQ,CAC5E,MAAMof,EAAehW,EAAOiW,eAAiBC,EAAAA,EAAgBC,EAAAA,EAC7D,IAAKJ,EACH,OAAOC,EAAazR,EAAMrE,EAAM1C,GAC3B,GAAIoC,EAAWmC,eAAgB,CAIpC,MAAMqU,EAAK7R,EAAK,GACV4C,EAA+B,mBAAhBiP,EAAGC,UAA2BD,EAAGC,SAASnW,GAC/D,GAAIiH,EAAO,CACT,MAAMlR,EAAQ+f,EAAazR,EAAMrE,EAAM1C,EAAQ2J,GACzCpJ,EAAMiY,EAAazR,EAAMrE,EAAM1C,EAAQ2J,GAC7C,MAAO,CAACmP,GAAIrgB,EAAMqgB,GAAIC,GAAIxY,EAAIwY,MAKpC,MAAO,CAACD,GAAI,EAAGC,GAAIhS,EAAK3N,OAAS,EACnC,CAUA,SAAS4f,EAAyBrhB,EAAO+K,EAAMuW,EAAUC,EAASX,GAChE,MAAM7X,EAAW/I,EAAMwhB,+BACjBnZ,EAAQiZ,EAASvW,GACvB,IAAK,IAAIpJ,EAAI,EAAGsH,EAAOF,EAAStH,OAAQE,EAAIsH,IAAQtH,EAAG,CACrD,MAAM,MAACuH,EAAA,KAAOkG,GAAQrG,EAASpH,IACzB,GAACwf,EAAA,GAAIC,GAAMV,EAAa3X,EAASpH,GAAIoJ,EAAM1C,EAAOuY,GACxD,IAAK,IAAIa,EAAIN,EAAIM,GAAKL,IAAMK,EAAG,CAC7B,MAAMnN,EAAUlF,EAAKqS,GAChBnN,EAAQ4L,MACXqB,EAAQjN,EAASpL,EAAOuY,EAE5B,CACF,CACF,CA2BA,SAASC,EAAkB1hB,EAAOshB,EAAUvW,EAAM4W,EAAkBC,GAClE,MAAMpgB,EAAQ,GAEd,OAAKogB,GAAqB5hB,EAAM6hB,cAAcP,IAa9CD,EAAyBrhB,EAAO+K,EAAMuW,GATf,SAAShN,EAAS9K,EAAcN,IAChD0Y,IAAqBE,EAAAA,EAAAA,GAAexN,EAAStU,EAAMoU,UAAW,KAG/DE,EAAQyN,QAAQT,EAASrT,EAAGqT,EAASpT,EAAGyT,IAC1CngB,EAAMkB,KAAK,CAAC4R,UAAS9K,eAAcN,SAEvC,IAEgE,GACzD1H,GAbEA,CAcX,CA6EA,SAASwgB,EAAgBhiB,EAAOshB,EAAUvW,EAAM6V,EAAWe,EAAkBC,GAC3E,OAAKA,GAAqB5hB,EAAM6hB,cAAcP,GAI9B,MAATvW,GAAiB6V,EA9C1B,SAAkC5gB,EAAOshB,EAAUvW,EAAM6V,EAAWe,EAAkBC,GACpF,IAAIpgB,EAAQ,GACZ,MAAMygB,EA5ER,SAAkClX,GAChC,MAAMmX,GAA8B,IAAvBnX,EAAKgS,QAAQ,KACpBoF,GAA8B,IAAvBpX,EAAKgS,QAAQ,KAE1B,OAAO,SAASqF,EAAKC,GACnB,MAAMC,EAASJ,EAAOthB,KAAKmY,IAAIqJ,EAAInU,EAAIoU,EAAIpU,GAAK,EAC1CsU,EAASJ,EAAOvhB,KAAKmY,IAAIqJ,EAAIlU,EAAImU,EAAInU,GAAK,EAChD,OAAOtN,KAAK4hB,KAAK5hB,KAAK6hB,IAAIH,EAAQ,GAAK1hB,KAAK6hB,IAAIF,EAAQ,GAC1D,CACF,CAmEyBG,CAAyB3X,GAChD,IAAI4X,EAAcnQ,OAAOC,kBAyBzB,OADA4O,EAAyBrhB,EAAO+K,EAAMuW,GAtBtC,SAAwBhN,EAAS9K,EAAcN,GAC7C,MAAM6Y,EAAUzN,EAAQyN,QAAQT,EAASrT,EAAGqT,EAASpT,EAAGyT,GACxD,GAAIf,IAAcmB,EAChB,OAGF,MAAMxF,EAASjI,EAAQsO,eAAejB,GAEtC,IADsBC,IAAoB5hB,EAAM6hB,cAActF,KACzCwF,EACnB,OAGF,MAAMc,EAAWZ,EAAeX,EAAU/E,GACtCsG,EAAWF,GACbnhB,EAAQ,CAAC,CAAC8S,UAAS9K,eAAcN,UACjCyZ,EAAcE,GACLA,IAAaF,GAEtBnhB,EAAMkB,KAAK,CAAC4R,UAAS9K,eAAcN,SAEvC,IAGO1H,CACT,CAmBMshB,CAAyB9iB,EAAOshB,EAAUvW,EAAM6V,EAAWe,EAAkBC,GA1EnF,SAA+B5hB,EAAOshB,EAAUvW,EAAM4W,GACpD,IAAIngB,EAAQ,GAYZ,OADA6f,EAAyBrhB,EAAO+K,EAAMuW,GATtC,SAAwBhN,EAAS9K,EAAcN,GAC7C,MAAM,WAAC6Z,EAAA,SAAYC,GAAY1O,EAAQ2O,SAAS,CAAC,aAAc,YAAatB,IACtE,MAACuB,IAASC,EAAAA,EAAAA,GAAkB7O,EAAS,CAACrG,EAAGqT,EAASrT,EAAGC,EAAGoT,EAASpT,KAEnEkV,EAAAA,EAAAA,GAAcF,EAAOH,EAAYC,IACnCxhB,EAAMkB,KAAK,CAAC4R,UAAS9K,eAAcN,SAEvC,IAGO1H,CACT,CA2DM6hB,CAAsBrjB,EAAOshB,EAAUvW,EAAM4W,GAJxC,EAMX,CAWA,SAAS2B,EAAatjB,EAAOshB,EAAUvW,EAAM6V,EAAWe,GACtD,MAAMngB,EAAQ,GACR+hB,EAAuB,MAATxY,EAAe,WAAa,WAChD,IAAIyY,GAAiB,EAWrB,OATAnC,EAAyBrhB,EAAO+K,EAAMuW,GAAU,CAAChN,EAAS9K,EAAcN,KAClEoL,EAAQiP,GAAajC,EAASvW,GAAO4W,KACvCngB,EAAMkB,KAAK,CAAC4R,UAAS9K,eAAcN,UACnCsa,EAAiBA,GAAkBlP,EAAQyN,QAAQT,EAASrT,EAAGqT,EAASpT,EAAGyT,OAM3Ef,IAAc4C,EACT,GAEFhiB,CACT,CAMA,IAAAiiB,EAAe,CAEbpC,2BAGAqC,MAAO,CAYLxa,MAAMlJ,EAAO2jB,EAAGnc,EAASma,GACvB,MAAML,GAAWsC,EAAAA,EAAAA,GAAoBD,EAAG3jB,GAElC+K,EAAOvD,EAAQuD,MAAQ,IACvB6W,EAAmBpa,EAAQoa,mBAAoB,EAC/CpgB,EAAQgG,EAAQoZ,UAClBc,EAAkB1hB,EAAOshB,EAAUvW,EAAM4W,EAAkBC,GAC3DI,EAAgBhiB,EAAOshB,EAAUvW,GAAM,EAAO4W,EAAkBC,GAC9D1N,EAAW,GAEjB,OAAK1S,EAAMC,QAIXzB,EAAMwhB,+BAA+BhhB,SAASqJ,IAC5C,MAAMX,EAAQ1H,EAAM,GAAG0H,MACjBoL,EAAUzK,EAAKuF,KAAKlG,GAGtBoL,IAAYA,EAAQ4L,MACtBhM,EAASxR,KAAK,CAAC4R,UAAS9K,aAAcK,EAAKX,MAAOA,aAI/CgL,GAbE,EAcX,EAYApG,QAAQ9N,EAAO2jB,EAAGnc,EAASma,GACzB,MAAML,GAAWsC,EAAAA,EAAAA,GAAoBD,EAAG3jB,GAClC+K,EAAOvD,EAAQuD,MAAQ,KACvB6W,EAAmBpa,EAAQoa,mBAAoB,EACrD,IAAIpgB,EAAQgG,EAAQoZ,UAChBc,EAAkB1hB,EAAOshB,EAAUvW,EAAM4W,EAAkBC,GAC7DI,EAAgBhiB,EAAOshB,EAAUvW,GAAM,EAAO4W,EAAkBC,GAElE,GAAIpgB,EAAMC,OAAS,EAAG,CACpB,MAAM+H,EAAehI,EAAM,GAAGgI,aACxB4F,EAAOpP,EAAMsP,eAAe9F,GAAc4F,KAChD5N,EAAQ,GACR,IAAK,IAAIG,EAAI,EAAGA,EAAIyN,EAAK3N,SAAUE,EACjCH,EAAMkB,KAAK,CAAC4R,QAASlF,EAAKzN,GAAI6H,eAAcN,MAAOvH,IAIvD,OAAOH,CACT,EAYAye,MAAK,CAACjgB,EAAO2jB,EAAGnc,EAASma,IAIhBD,EAAkB1hB,GAHR4jB,EAAAA,EAAAA,GAAoBD,EAAG3jB,GAC3BwH,EAAQuD,MAAQ,KAEmB4W,EADvBna,EAAQoa,mBAAoB,GAavDiC,QAAQ7jB,EAAO2jB,EAAGnc,EAASma,GACzB,MAAML,GAAWsC,EAAAA,EAAAA,GAAoBD,EAAG3jB,GAClC+K,EAAOvD,EAAQuD,MAAQ,KACvB6W,EAAmBpa,EAAQoa,mBAAoB,EACrD,OAAOI,EAAgBhiB,EAAOshB,EAAUvW,EAAMvD,EAAQoZ,UAAWe,EAAkBC,EACrF,EAWA3T,EAAC,CAACjO,EAAO2jB,EAAGnc,EAASma,IAEZ2B,EAAatjB,GADH4jB,EAAAA,EAAAA,GAAoBD,EAAG3jB,GACH,IAAKwH,EAAQoZ,UAAWe,GAY/DzT,EAAC,CAAClO,EAAO2jB,EAAGnc,EAASma,IAEZ2B,EAAatjB,GADH4jB,EAAAA,EAAAA,GAAoBD,EAAG3jB,GACH,IAAKwH,EAAQoZ,UAAWe,KCpWnE,MAAMmC,EAAmB,CAAC,OAAQ,MAAO,QAAS,UAElD,SAASC,EAAiBC,EAAO1C,GAC/B,OAAO0C,EAAMtY,QAAOgP,GAAKA,EAAEuJ,MAAQ3C,GACrC,CAEA,SAAS4C,EAA4BF,EAAOjZ,GAC1C,OAAOiZ,EAAMtY,QAAOgP,IAA0C,IAArCoJ,EAAiB/G,QAAQrC,EAAEuJ,MAAevJ,EAAEyJ,IAAIpZ,OAASA,GACpF,CAEA,SAASqZ,EAAaJ,EAAOrb,GAC3B,OAAOqb,EAAMvL,MAAK,CAACC,EAAGlF,KACpB,MAAM6Q,EAAK1b,EAAU6K,EAAIkF,EACnB6B,EAAK5R,EAAU+P,EAAIlF,EACzB,OAAO6Q,EAAGC,SAAW/J,EAAG+J,OACtBD,EAAGnb,MAAQqR,EAAGrR,MACdmb,EAAGC,OAAS/J,EAAG+J,MAAM,GAE3B,CA+EA,SAASC,EAAeC,EAAYpQ,EAAWsE,EAAGlF,GAChD,OAAO5S,KAAKoC,IAAIwhB,EAAW9L,GAAItE,EAAUsE,IAAM9X,KAAKoC,IAAIwhB,EAAWhR,GAAIY,EAAUZ,GACnF,CAEA,SAASiR,EAAiBD,EAAYE,GACpCF,EAAW9Q,IAAM9S,KAAKoC,IAAIwhB,EAAW9Q,IAAKgR,EAAWhR,KACrD8Q,EAAW3Q,KAAOjT,KAAKoC,IAAIwhB,EAAW3Q,KAAM6Q,EAAW7Q,MACvD2Q,EAAW5Q,OAAShT,KAAKoC,IAAIwhB,EAAW5Q,OAAQ8Q,EAAW9Q,QAC3D4Q,EAAW7Q,MAAQ/S,KAAKoC,IAAIwhB,EAAW7Q,MAAO+Q,EAAW/Q,MAC3D,CAEA,SAASgR,EAAWvQ,EAAWwQ,EAAQC,EAAQ7a,GAC7C,MAAM,IAACia,EAAA,IAAKE,GAAOU,EACbL,EAAapQ,EAAUoQ,WAG7B,KAAK/d,EAAAA,EAAAA,GAASwd,GAAM,CACdY,EAAOvc,OAET8L,EAAU6P,IAAQY,EAAOvc,MAE3B,MAAMc,EAAQY,EAAO6a,EAAOzb,QAAU,CAACd,KAAM,EAAGyI,MAAO,GACvD3H,EAAMd,KAAO1H,KAAKoC,IAAIoG,EAAMd,KAAMuc,EAAO5K,WAAakK,EAAI3H,OAAS2H,EAAI1H,OACvEoI,EAAOvc,KAAOc,EAAMd,KAAOc,EAAM2H,MACjCqD,EAAU6P,IAAQY,EAAOvc,KAGvB6b,EAAIW,YACNL,EAAiBD,EAAYL,EAAIW,cAGnC,MAAMC,EAAWnkB,KAAKoC,IAAI,EAAG4hB,EAAOI,WAAaT,EAAeC,EAAYpQ,EAAW,OAAQ,UACzF6Q,EAAYrkB,KAAKoC,IAAI,EAAG4hB,EAAOM,YAAcX,EAAeC,EAAYpQ,EAAW,MAAO,WAC1F+Q,EAAeJ,IAAa3Q,EAAUgR,EACtCC,EAAgBJ,IAAc7Q,EAAUkR,EAK9C,OAJAlR,EAAUgR,EAAIL,EACd3Q,EAAUkR,EAAIL,EAGPJ,EAAO5K,WACV,CAACsL,KAAMJ,EAAcK,MAAOH,GAC5B,CAACE,KAAMF,EAAeG,MAAOL,EACnC,CAgBA,SAASM,EAAWxL,EAAY7F,GAC9B,MAAMoQ,EAAapQ,EAAUoQ,WAU7B,OARA,SAA4BkB,GAC1B,MAAMC,EAAS,CAAC9R,KAAM,EAAGH,IAAK,EAAGC,MAAO,EAAGC,OAAQ,GAInD,OAHA8R,EAAUllB,SAASyjB,IACjB0B,EAAO1B,GAAOrjB,KAAKoC,IAAIoR,EAAU6P,GAAMO,EAAWP,GAAI,IAEjD0B,CACT,CAGIC,CADG3L,EACgB,CAAC,OAAQ,SACT,CAAC,MAAO,UACjC,CAEA,SAAS4L,EAASC,EAAO1R,EAAWwQ,EAAQ5a,GAC1C,MAAM+b,EAAa,GACnB,IAAIpkB,EAAGsH,EAAM4b,EAAQV,EAAK6B,EAAOC,EAEjC,IAAKtkB,EAAI,EAAGsH,EAAO6c,EAAMrkB,OAAQukB,EAAQ,EAAGrkB,EAAIsH,IAAQtH,EAAG,CACzDkjB,EAASiB,EAAMnkB,GACfwiB,EAAMU,EAAOV,IAEbA,EAAIze,OACFmf,EAAOpI,OAASrI,EAAUgR,EAC1BP,EAAOrI,QAAUpI,EAAUkR,EAC3BG,EAAWZ,EAAO5K,WAAY7F,IAEhC,MAAM,KAACmR,EAAA,MAAMC,GAASb,EAAWvQ,EAAWwQ,EAAQC,EAAQ7a,GAI5Dgc,GAAST,GAAQQ,EAAWtkB,OAG5BwkB,EAAUA,GAAWT,EAEhBrB,EAAI+B,UACPH,EAAWrjB,KAAKmiB,EAEpB,CAEA,OAAOmB,GAASH,EAASE,EAAY3R,EAAWwQ,EAAQ5a,IAAWic,CACrE,CAEA,SAASE,EAAWhC,EAAKtQ,EAAMH,EAAK+I,EAAOD,GACzC2H,EAAIzQ,IAAMA,EACVyQ,EAAItQ,KAAOA,EACXsQ,EAAIxQ,MAAQE,EAAO4I,EACnB0H,EAAIvQ,OAASF,EAAM8I,EACnB2H,EAAI1H,MAAQA,EACZ0H,EAAI3H,OAASA,CACf,CAEA,SAAS4J,EAAWN,EAAO1R,EAAWwQ,EAAQ5a,GAC5C,MAAMqc,EAAczB,EAAO0B,QAC3B,IAAI,EAACrY,EAAA,EAAGC,GAAKkG,EAEb,IAAK,MAAMyQ,KAAUiB,EAAO,CAC1B,MAAM3B,EAAMU,EAAOV,IACb/a,EAAQY,EAAO6a,EAAOzb,QAAU,CAAC2H,MAAO,EAAGwV,OAAQ,EAAGjC,OAAQ,GAC9DA,EAASO,EAAQ2B,YAAcpd,EAAMkb,QAAW,EACtD,GAAIO,EAAO5K,WAAY,CACrB,MAAMwC,EAAQrI,EAAUgR,EAAId,EACtB9H,EAASpT,EAAMd,MAAQ6b,EAAI3H,QAC7BlH,EAAAA,EAAAA,GAAQlM,EAAMtI,SAChBoN,EAAI9E,EAAMtI,OAERqjB,EAAI+B,SACNC,EAAWhC,EAAKkC,EAAYxS,KAAM3F,EAAG0W,EAAOI,WAAaqB,EAAY1S,MAAQ0S,EAAYxS,KAAM2I,GAE/F2J,EAAWhC,EAAK/P,EAAUP,KAAOzK,EAAMmd,OAAQrY,EAAGuO,EAAOD,GAE3DpT,EAAMtI,MAAQoN,EACd9E,EAAMmd,QAAU9J,EAChBvO,EAAIiW,EAAIvQ,WACH,CACL,MAAM4I,EAASpI,EAAUkR,EAAIhB,EACvB7H,EAAQrT,EAAMd,MAAQ6b,EAAI1H,OAC5BnH,EAAAA,EAAAA,GAAQlM,EAAMtI,SAChBmN,EAAI7E,EAAMtI,OAERqjB,EAAI+B,SACNC,EAAWhC,EAAKlW,EAAGoY,EAAY3S,IAAK+I,EAAOmI,EAAOM,YAAcmB,EAAYzS,OAASyS,EAAY3S,KAEjGyS,EAAWhC,EAAKlW,EAAGmG,EAAUV,IAAMtK,EAAMmd,OAAQ9J,EAAOD,GAE1DpT,EAAMtI,MAAQmN,EACd7E,EAAMmd,QAAU/J,EAChBvO,EAAIkW,EAAIxQ,MAEZ,CAEAS,EAAUnG,EAAIA,EACdmG,EAAUlG,EAAIA,CAChB,CAwBA,IAAAuY,EAAe,CAQbC,OAAO1mB,EAAO0B,GACP1B,EAAM8lB,QACT9lB,EAAM8lB,MAAQ,IAIhBpkB,EAAKwkB,SAAWxkB,EAAKwkB,WAAY,EACjCxkB,EAAK4f,SAAW5f,EAAK4f,UAAY,MACjC5f,EAAK4iB,OAAS5iB,EAAK4iB,QAAU,EAE7B5iB,EAAKilB,QAAUjlB,EAAKilB,SAAW,WAC7B,MAAO,CAAC,CACNC,EAAG,EACHhlB,KAAKwS,GACH1S,EAAKE,KAAKwS,EACZ,GAEJ,EAEApU,EAAM8lB,MAAMpjB,KAAKhB,EACnB,EAOAmlB,UAAU7mB,EAAO8mB,GACf,MAAM5d,EAAQlJ,EAAM8lB,MAAQ9lB,EAAM8lB,MAAM/I,QAAQ+J,IAAe,GAChD,IAAX5d,GACFlJ,EAAM8lB,MAAMtO,OAAOtO,EAAO,EAE9B,EAQA1C,UAAUxG,EAAO0B,EAAM8F,GACrB9F,EAAKwkB,SAAW1e,EAAQ0e,SACxBxkB,EAAK4f,SAAW9Z,EAAQ8Z,SACxB5f,EAAK4iB,OAAS9c,EAAQ8c,MACxB,EAUA5e,OAAO1F,EAAOyc,EAAOD,EAAQuK,GAC3B,IAAK/mB,EACH,OAGF,MAAMsmB,GAAUU,EAAAA,EAAAA,GAAUhnB,EAAMwH,QAAQqd,OAAOyB,SACzCW,EAAiBrmB,KAAKoC,IAAIyZ,EAAQ6J,EAAQ7J,MAAO,GACjDyK,EAAkBtmB,KAAKoC,IAAIwZ,EAAS8J,EAAQ9J,OAAQ,GACpDsJ,EA5QV,SAA0BA,GACxB,MAAMqB,EA1DR,SAAmBrB,GACjB,MAAMqB,EAAc,GACpB,IAAIxlB,EAAGsH,EAAMkb,EAAKF,EAAK7a,EAAOod,EAE9B,IAAK7kB,EAAI,EAAGsH,GAAQ6c,GAAS,IAAIrkB,OAAQE,EAAIsH,IAAQtH,EACnDwiB,EAAM2B,EAAMnkB,KACV2f,SAAU2C,EAAKzc,SAAU4B,QAAOod,cAAc,IAAMrC,GACtDgD,EAAYzkB,KAAK,CACfwG,MAAOvH,EACPwiB,MACAF,MACAhK,WAAYkK,EAAIrI,eAChBwI,OAAQH,EAAIG,OACZlb,MAAOA,GAAU6a,EAAM7a,EACvBod,gBAGJ,OAAOW,CACT,CAwCsBC,CAAUtB,GACxBI,EAAW9B,EAAa+C,EAAYzb,QAAO2b,GAAQA,EAAKlD,IAAI+B,YAAW,GACvErS,EAAOuQ,EAAaL,EAAiBoD,EAAa,SAAS,GAC3DxT,EAAQyQ,EAAaL,EAAiBoD,EAAa,UACnDzT,EAAM0Q,EAAaL,EAAiBoD,EAAa,QAAQ,GACzDvT,EAASwQ,EAAaL,EAAiBoD,EAAa,WACpDG,EAAmBpD,EAA4BiD,EAAa,KAC5DI,EAAiBrD,EAA4BiD,EAAa,KAEhE,MAAO,CACLjB,WACAsB,WAAY3T,EAAK0E,OAAO7E,GACxB+T,eAAgB9T,EAAM4E,OAAOgP,GAAgBhP,OAAO3E,GAAQ2E,OAAO+O,GACnElT,UAAW2P,EAAiBoD,EAAa,aACzCO,SAAU7T,EAAK0E,OAAO5E,GAAO4E,OAAOgP,GACpCtN,WAAYvG,EAAI6E,OAAO3E,GAAQ2E,OAAO+O,GAE1C,CA0PkBK,CAAiB3nB,EAAM8lB,OAC/B8B,EAAgB9B,EAAM4B,SACtBG,EAAkB/B,EAAM7L,YAI9B6N,EAAAA,EAAAA,GAAK9nB,EAAM8lB,OAAO3B,IACgB,mBAArBA,EAAI4D,cACb5D,EAAI4D,kBA+BR,MAAMC,EAA0BJ,EAAc/kB,QAAO,CAAColB,EAAOZ,IAC3DA,EAAKlD,IAAI3c,UAAwC,IAA7B6f,EAAKlD,IAAI3c,QAAQ0gB,QAAoBD,EAAQA,EAAQ,GAAG,IAAM,EAE9ErD,EAASje,OAAOgP,OAAO,CAC3BqP,WAAYvI,EACZyI,YAAa1I,EACb8J,UACAW,iBACAC,kBACAiB,aAAclB,EAAiB,EAAIe,EACnCI,cAAelB,EAAkB,IAE7B1C,EAAa7d,OAAOe,OAAO,CAAC,EAAG4e,GACrC7B,EAAiBD,GAAYwC,EAAAA,EAAAA,GAAUD,IACvC,MAAM3S,EAAYzN,OAAOe,OAAO,CAC9B8c,aACAY,EAAG6B,EACH3B,EAAG4B,EACHjZ,EAAGqY,EAAQzS,KACX3F,EAAGoY,EAAQ5S,KACV4S,GAEGtc,EA7VV,SAAuByc,EAAS7B,GAC9B,MAAM5a,EAlBR,SAAqByc,GACnB,MAAMzc,EAAS,CAAC,EAChB,IAAK,MAAMqd,KAAQZ,EAAS,CAC1B,MAAM,MAACrd,EAAK,IAAE6a,EAAA,YAAKuC,GAAea,EAClC,IAAKje,IAAU0a,EAAiBuE,SAASpE,GACvC,SAEF,MAAMqE,EAASte,EAAOZ,KAAWY,EAAOZ,GAAS,CAAC2H,MAAO,EAAGwV,OAAQ,EAAGjC,OAAQ,EAAGhc,KAAM,IACxFggB,EAAOvX,QACPuX,EAAOhE,QAAUkC,CACnB,CACA,OAAOxc,CACT,CAMiBue,CAAY9B,IACrB,aAAC0B,EAAA,cAAcC,GAAiBxD,EACtC,IAAIjjB,EAAGsH,EAAM4b,EACb,IAAKljB,EAAI,EAAGsH,EAAOwd,EAAQhlB,OAAQE,EAAIsH,IAAQtH,EAAG,CAChDkjB,EAAS4B,EAAQ9kB,GACjB,MAAM,SAACukB,GAAYrB,EAAOV,IACpB/a,EAAQY,EAAO6a,EAAOzb,OACtBxF,EAASwF,GAASyb,EAAO2B,YAAcpd,EAAMkb,OAC/CO,EAAO5K,YACT4K,EAAOpI,MAAQ7Y,EAASA,EAASukB,EAAejC,GAAYtB,EAAOqC,eACnEpC,EAAOrI,OAAS4L,IAEhBvD,EAAOpI,MAAQ0L,EACftD,EAAOrI,OAAS5Y,EAASA,EAASwkB,EAAgBlC,GAAYtB,EAAOsC,gBAEzE,CACA,OAAOld,CACT,CA2UmBwe,CAAcZ,EAAcrP,OAAOsP,GAAkBjD,GAGpEiB,EAASC,EAAMI,SAAU9R,EAAWwQ,EAAQ5a,GAG5C6b,EAAS+B,EAAexT,EAAWwQ,EAAQ5a,GAGvC6b,EAASgC,EAAiBzT,EAAWwQ,EAAQ5a,IAE/C6b,EAAS+B,EAAexT,EAAWwQ,EAAQ5a,GApRjD,SAA0BoK,GACxB,MAAMoQ,EAAapQ,EAAUoQ,WAE7B,SAASiE,EAAUxE,GACjB,MAAMyE,EAAS9nB,KAAKoC,IAAIwhB,EAAWP,GAAO7P,EAAU6P,GAAM,GAE1D,OADA7P,EAAU6P,IAAQyE,EACXA,CACT,CACAtU,EAAUlG,GAAKua,EAAU,OACzBrU,EAAUnG,GAAKwa,EAAU,QACzBA,EAAU,SACVA,EAAU,SACZ,CA2QIE,CAAiBvU,GAGjBgS,EAAWN,EAAM0B,WAAYpT,EAAWwQ,EAAQ5a,GAGhDoK,EAAUnG,GAAKmG,EAAUgR,EACzBhR,EAAUlG,GAAKkG,EAAUkR,EAEzBc,EAAWN,EAAM2B,eAAgBrT,EAAWwQ,EAAQ5a,GAEpDhK,EAAMoU,UAAY,CAChBP,KAAMO,EAAUP,KAChBH,IAAKU,EAAUV,IACfC,MAAOS,EAAUP,KAAOO,EAAUgR,EAClCxR,OAAQQ,EAAUV,IAAMU,EAAUkR,EAClC9I,OAAQpI,EAAUkR,EAClB7I,MAAOrI,EAAUgR,IAInB0C,EAAAA,EAAAA,GAAKhC,EAAM1R,WAAYyQ,IACrB,MAAMV,EAAMU,EAAOV,IACnBxd,OAAOe,OAAOyc,EAAKnkB,EAAMoU,WACzB+P,EAAIze,OAAO0O,EAAUgR,EAAGhR,EAAUkR,EAAG,CAACzR,KAAM,EAAGH,IAAK,EAAGC,MAAO,EAAGC,OAAQ,GAAG,GAEhF,GC7ba,MAAMgV,EAOnBC,eAAeC,EAAQC,GAAc,CAQrCC,eAAetU,GACb,OAAO,CACT,CASAuU,iBAAiBjpB,EAAOG,EAAM+oB,GAAW,CAQzCC,oBAAoBnpB,EAAOG,EAAM+oB,GAAW,CAK5CE,sBACE,OAAO,CACT,CASAC,eAAe/U,EAASmI,EAAOD,EAAQuM,GAGrC,OAFAtM,EAAQ7b,KAAKoC,IAAI,EAAGyZ,GAASnI,EAAQmI,OACrCD,EAASA,GAAUlI,EAAQkI,OACpB,CACLC,QACAD,OAAQ5b,KAAKoC,IAAI,EAAG+lB,EAAcnoB,KAAKoE,MAAMyX,EAAQsM,GAAevM,GAExE,CAMA8M,WAAWR,GACT,OAAO,CACT,CAMAS,aAAaljB,GAEb,ECrEa,MAAMmjB,UAAsBZ,EACzCC,eAAennB,GAIb,OAAOA,GAAQA,EAAKkP,YAAclP,EAAKkP,WAAW,OAAS,IAC7D,CACA2Y,aAAaljB,GACXA,EAAOmB,QAAQV,WAAY,CAC7B,ECRF,MAAM2iB,EAAc,WAOdC,EAAc,CAClBC,WAAY,YACZC,UAAW,YACXC,SAAU,UACVC,aAAc,aACdC,YAAa,YACbC,YAAa,YACbC,UAAW,UACXC,aAAc,WACdC,WAAY,YAGRC,GAAgB/hB,GAAmB,OAAVA,GAA4B,KAAVA,EA8D3CgiB,KAAuBC,EAAAA,GAA+B,CAACC,SAAS,GAMtE,SAASC,GAAexqB,EAAOG,EAAM+oB,GACnClpB,EAAM8oB,OAAOK,oBAAoBhpB,EAAM+oB,EAAUmB,GACnD,CAcA,SAASI,GAAiBC,EAAU5B,GAClC,IAAK,MAAM6B,KAAQD,EACjB,GAAIC,IAAS7B,GAAU6B,EAAKC,SAAS9B,GACnC,OAAO,CAGb,CAEA,SAAS+B,GAAqB7qB,EAAOG,EAAM+oB,GACzC,MAAMJ,EAAS9oB,EAAM8oB,OACfgC,EAAW,IAAIC,kBAAiBC,IACpC,IAAIC,GAAU,EACd,IAAK,MAAM7R,KAAS4R,EAClBC,EAAUA,GAAWR,GAAiBrR,EAAM8R,WAAYpC,GACxDmC,EAAUA,IAAYR,GAAiBrR,EAAM+R,aAAcrC,GAEzDmC,GACF/B,OAIJ,OADA4B,EAASM,QAAQC,SAAU,CAACC,WAAW,EAAMC,SAAS,IAC/CT,CACT,CAEA,SAASU,GAAqBxrB,EAAOG,EAAM+oB,GACzC,MAAMJ,EAAS9oB,EAAM8oB,OACfgC,EAAW,IAAIC,kBAAiBC,IACpC,IAAIC,GAAU,EACd,IAAK,MAAM7R,KAAS4R,EAClBC,EAAUA,GAAWR,GAAiBrR,EAAM+R,aAAcrC,GAC1DmC,EAAUA,IAAYR,GAAiBrR,EAAM8R,WAAYpC,GAEvDmC,GACF/B,OAIJ,OADA4B,EAASM,QAAQC,SAAU,CAACC,WAAW,EAAMC,SAAS,IAC/CT,CACT,CAEA,MAAMW,GAAqB,IAAI9rB,IAC/B,IAAI+rB,GAAsB,EAE1B,SAASC,KACP,MAAMC,EAAM1qB,OAAO2qB,iBACfD,IAAQF,KAGZA,GAAsBE,EACtBH,GAAmBjrB,SAAQ,CAACsrB,EAAQ9rB,KAC9BA,EAAM+rB,0BAA4BH,GACpCE,OAGN,CAgBA,SAASE,GAAqBhsB,EAAOG,EAAM+oB,GACzC,MAAMJ,EAAS9oB,EAAM8oB,OACfmD,EAAYnD,IAAUoD,EAAAA,EAAAA,GAAepD,GAC3C,IAAKmD,EACH,OAEF,MAAMH,GAASK,EAAAA,EAAAA,IAAU,CAAC1P,EAAOD,KAC/B,MAAM4I,EAAI6G,EAAUG,YACpBlD,EAASzM,EAAOD,GACZ4I,EAAI6G,EAAUG,aAQhBlD,MAEDhoB,QAGG4pB,EAAW,IAAIuB,gBAAerB,IAClC,MAAM5R,EAAQ4R,EAAQ,GAChBvO,EAAQrD,EAAMkT,YAAY7P,MAC1BD,EAASpD,EAAMkT,YAAY9P,OAInB,IAAVC,GAA0B,IAAXD,GAGnBsP,EAAOrP,EAAOD,EAAA,IAKhB,OAHAsO,EAASM,QAAQa,GAhDnB,SAAuCjsB,EAAO8rB,GACvCL,GAAmBnjB,MACtBpH,OAAO+nB,iBAAiB,SAAU0C,IAEpCF,GAAmBnpB,IAAItC,EAAO8rB,EAChC,CA4CES,CAA8BvsB,EAAO8rB,GAE9BhB,CACT,CAEA,SAAS0B,GAAgBxsB,EAAOG,EAAM2qB,GAChCA,GACFA,EAAS2B,aAEE,WAATtsB,GAnDN,SAAyCH,GACvCyrB,GAAmBpoB,OAAOrD,GACrByrB,GAAmBnjB,MACtBpH,OAAOioB,oBAAoB,SAAUwC,GAEzC,CA+CIe,CAAgC1sB,EAEpC,CAEA,SAAS2sB,GAAqB3sB,EAAOG,EAAM+oB,GACzC,MAAMJ,EAAS9oB,EAAM8oB,OACf8D,GAAQT,EAAAA,EAAAA,IAAW3pB,IAIL,OAAdxC,EAAMqM,KACR6c,EA1IN,SAAyB1mB,EAAOxC,GAC9B,MAAMG,EAAOupB,EAAYlnB,EAAMrC,OAASqC,EAAMrC,MACxC,EAAC8N,EAAC,EAAEC,IAAK0V,EAAAA,EAAAA,GAAoBphB,EAAOxC,GAC1C,MAAO,CACLG,OACAH,QACA6sB,OAAQrqB,EACRyL,OAASnO,IAANmO,EAAkBA,EAAI,KACzBC,OAASpO,IAANoO,EAAkBA,EAAI,KAE7B,CAgIe4e,CAAgBtqB,EAAOxC,MAEjCA,GAIH,OAxJF,SAAqB2qB,EAAMxqB,EAAM+oB,GAC/ByB,EAAK1B,iBAAiB9oB,EAAM+oB,EAAUmB,GACxC,CAoJE0C,CAAYjE,EAAQ3oB,EAAMysB,GAEnBA,CACT,CAMe,MAAMI,WAAoBpE,EAOvCC,eAAeC,EAAQC,GAIrB,MAAMrU,EAAUoU,GAAUA,EAAOlY,YAAckY,EAAOlY,WAAW,MASjE,OAAI8D,GAAWA,EAAQoU,SAAWA,GA3OtC,SAAoBA,EAAQC,GAC1B,MAAMkE,EAAQnE,EAAOmE,MAIfC,EAAepE,EAAOqE,aAAa,UACnCC,EAActE,EAAOqE,aAAa,SAsBxC,GAnBArE,EAAOW,GAAe,CACpB/oB,QAAS,CACP8b,OAAQ0Q,EACRzQ,MAAO2Q,EACPH,MAAO,CACL/E,QAAS+E,EAAM/E,QACf1L,OAAQyQ,EAAMzQ,OACdC,MAAOwQ,EAAMxQ,SAQnBwQ,EAAM/E,QAAU+E,EAAM/E,SAAW,QAEjC+E,EAAMI,UAAYJ,EAAMI,WAAa,aAEjCjD,GAAcgD,GAAc,CAC9B,MAAME,GAAeC,EAAAA,EAAAA,GAAazE,EAAQ,cACrBhpB,IAAjBwtB,IACFxE,EAAOrM,MAAQ6Q,GAInB,GAAIlD,GAAc8C,GAChB,GAA4B,KAAxBpE,EAAOmE,MAAMzQ,OAIfsM,EAAOtM,OAASsM,EAAOrM,OAASsM,GAAe,OAC1C,CACL,MAAMyE,GAAgBD,EAAAA,EAAAA,GAAazE,EAAQ,eACrBhpB,IAAlB0tB,IACF1E,EAAOtM,OAASgR,GAMxB,CA4LMC,CAAW3E,EAAQC,GACZrU,GAGF,IACT,CAKAsU,eAAetU,GACb,MAAMoU,EAASpU,EAAQoU,OACvB,IAAKA,EAAOW,GACV,OAAO,EAGT,MAAM/oB,EAAUooB,EAAOW,GAAa/oB,QACpC,CAAC,SAAU,SAASF,SAAS+D,IAC3B,MAAM8D,EAAQ3H,EAAQ6D,IAClB2X,EAAAA,EAAAA,GAAc7T,GAChBygB,EAAO4E,gBAAgBnpB,GAEvBukB,EAAO6E,aAAappB,EAAM8D,MAI9B,MAAM4kB,EAAQvsB,EAAQusB,OAAS,CAAC,EAahC,OAZAtmB,OAAOC,KAAKqmB,GAAOzsB,SAASyG,IAC1B6hB,EAAOmE,MAAMhmB,GAAOgmB,EAAMhmB,EAAI,IAQhC6hB,EAAOrM,MAAQqM,EAAOrM,aAEfqM,EAAOW,IACP,CACT,CAQAR,iBAAiBjpB,EAAOG,EAAM+oB,GAE5B1pB,KAAK2pB,oBAAoBnpB,EAAOG,GAEhC,MAAMytB,EAAU5tB,EAAM6tB,WAAa7tB,EAAM6tB,SAAW,CAAC,GAM/CtM,EALW,CACfuM,OAAQjD,GACRkD,OAAQvC,GACRM,OAAQE,IAEe7rB,IAASwsB,GAClCiB,EAAQztB,GAAQohB,EAAQvhB,EAAOG,EAAM+oB,EACvC,CAOAC,oBAAoBnpB,EAAOG,GACzB,MAAMytB,EAAU5tB,EAAM6tB,WAAa7tB,EAAM6tB,SAAW,CAAC,GAC/CjB,EAAQgB,EAAQztB,GAEjBysB,KAIY,CACfkB,OAAQtB,GACRuB,OAAQvB,GACRV,OAAQU,IAEersB,IAASqqB,IAC1BxqB,EAAOG,EAAMysB,GACrBgB,EAAQztB,QAAQL,EAClB,CAEAspB,sBACE,OAAOloB,OAAO2qB,gBAChB,CAQAxC,eAAeP,EAAQrM,EAAOD,EAAQuM,GACpC,OAAOM,EAAAA,EAAAA,GAAeP,EAAQrM,EAAOD,EAAQuM,EAC/C,CAKAO,WAAWR,GACT,MAAMmD,GAAYC,EAAAA,EAAAA,GAAepD,GACjC,SAAUmD,IAAaA,EAAU+B,YACnC,EC1Xa,MAAMC,GAEnB9hB,gBAAkB,CAAC,EACnBA,0BAAuBrM,EAEvBmO,EACAC,EACAzI,QAAS,EACT+B,QACAG,YAEAumB,gBAAgBvM,GACd,MAAM,EAAC1T,EAAA,EAAGC,GAAK1O,KAAKyjB,SAAS,CAAC,IAAK,KAAMtB,GACzC,MAAO,CAAC1T,IAAGC,IACb,CAEAigB,WACE,OAAOtO,EAAAA,EAAAA,GAASrgB,KAAKyO,KAAM4R,EAAAA,EAAAA,GAASrgB,KAAK0O,EAC3C,CASA+U,SAAS9a,EAAiBimB,GACxB,MAAMnuB,EAAQT,KAAKmI,YACnB,IAAKymB,IAAUnuB,EAEb,OAAOT,KAET,MAAM6uB,EAA+B,CAAC,EAItC,OAHAlmB,EAAM3H,SAAS+D,IACb8pB,EAAI9pB,GAAQtE,EAAMsE,IAAStE,EAAMsE,GAAMkB,SAAWxF,EAAMsE,GAAMgB,IAAM/F,KAAK+E,EAAe,IAEnF8pB,CACT,ECgFF,SAASnO,GAAKjH,EAAOqV,EAAUC,EAASC,EAAYC,GAClD,MAAM3tB,GAAQwN,EAAAA,EAAAA,GAAekgB,EAAY,GACnC5lB,EAAMhI,KAAKC,KAAIyN,EAAAA,EAAAA,GAAemgB,EAAUxV,EAAMxX,QAASwX,EAAMxX,QACnE,IACIA,EAAQE,EAAG2c,EADXvN,EAAQ,EAWZ,IARAwd,EAAU3tB,KAAK8tB,KAAKH,GAChBE,IACFhtB,EAASgtB,EAAWD,EACpBD,EAAU9sB,EAASb,KAAKoE,MAAMvD,EAAS8sB,IAGzCjQ,EAAOxd,EAEAwd,EAAO,GACZvN,IACAuN,EAAO1d,KAAK+tB,MAAM7tB,EAAQiQ,EAAQwd,GAGpC,IAAK5sB,EAAIf,KAAKoC,IAAIlC,EAAO,GAAIa,EAAIiH,EAAKjH,IAChCA,IAAM2c,IACRgQ,EAAS5rB,KAAKuW,EAAMtX,IACpBoP,IACAuN,EAAO1d,KAAK+tB,MAAM7tB,EAAQiQ,EAAQwd,GAGxC,CC7IA,MACMK,GAAiBA,CAACpmB,EAAOuR,EAAMqB,IAAoB,QAATrB,GAA2B,SAATA,EAAkBvR,EAAMuR,GAAQqB,EAAS5S,EAAMuR,GAAQqB,EACnHyT,GAAgBA,CAACC,EAAaC,IAAkBnuB,KAAKC,IAAIkuB,GAAiBD,EAAaA,GAY7F,SAASE,GAAO3X,EAAK4X,GACnB,MAAMC,EAAS,GACTC,EAAY9X,EAAI5V,OAASwtB,EACzBG,EAAM/X,EAAI5V,OAChB,IAAIE,EAAI,EAER,KAAOA,EAAIytB,EAAKztB,GAAKwtB,EACnBD,EAAOxsB,KAAK2U,EAAIzW,KAAKoE,MAAMrD,KAE7B,OAAOutB,CACT,CAOA,SAASG,GAAoB7mB,EAAOU,EAAOomB,GACzC,MAAM7tB,EAAS+G,EAAMyQ,MAAMxX,OACrB8tB,EAAa3uB,KAAKC,IAAIqI,EAAOzH,EAAS,GACtCX,EAAQ0H,EAAM6U,YACdzU,EAAMJ,EAAM8U,UACZkS,EAAU,KAChB,IACIpU,EADAqU,EAAYjnB,EAAM0Q,gBAAgBqW,GAGtC,KAAID,IAEAlU,EADa,IAAX3Z,EACOb,KAAKoC,IAAIysB,EAAY3uB,EAAO8H,EAAM6mB,GACxB,IAAVvmB,GACCV,EAAM0Q,gBAAgB,GAAKuW,GAAa,GAExCA,EAAYjnB,EAAM0Q,gBAAgBqW,EAAa,IAAM,EAEjEE,GAAaF,EAAarmB,EAAQkS,GAAUA,EAGxCqU,EAAY3uB,EAAQ0uB,GAAWC,EAAY7mB,EAAM4mB,IAIvD,OAAOC,CACT,CAuBA,SAASC,GAAkBloB,GACzB,OAAOA,EAAQmoB,UAAYnoB,EAAQooB,WAAa,CAClD,CAKA,SAASC,GAAeroB,EAASsoB,GAC/B,IAAKtoB,EAAQ0gB,QACX,OAAO,EAGT,MAAM6H,GAAOC,EAAAA,EAAAA,IAAOxoB,EAAQuoB,KAAMD,GAC5BxJ,GAAUU,EAAAA,EAAAA,GAAUxf,EAAQ8e,SAGlC,QAFcnf,EAAAA,EAAAA,GAAQK,EAAQyoB,MAAQzoB,EAAQyoB,KAAKxuB,OAAS,GAE5CsuB,EAAKG,WAAc5J,EAAQ9J,MAC7C,CAiBA,SAAS2T,GAAWC,EAAO9O,EAAU3Y,GAEnC,IAAI0lB,GAAMgC,EAAAA,EAAAA,IAAmBD,GAI7B,OAHIznB,GAAyB,UAAb2Y,IAA2B3Y,GAAwB,UAAb2Y,KACpD+M,EArHkB+B,IAAoB,SAAVA,EAAmB,QAAoB,UAAVA,EAAoB,OAASA,EAqHhFE,CAAajC,IAEdA,CACT,CAuCe,MAAMkC,WAActC,GAGjC1uB,YAAY8E,GACVsX,QAGAnc,KAAK2L,GAAK9G,EAAI8G,GAEd3L,KAAKW,KAAOkE,EAAIlE,KAEhBX,KAAKgI,aAAU1H,EAEfN,KAAK6M,IAAMhI,EAAIgI,IAEf7M,KAAKQ,MAAQqE,EAAIrE,MAIjBR,KAAKkU,SAAM5T,EAEXN,KAAKoU,YAAS9T,EAEdN,KAAKqU,UAAO/T,EAEZN,KAAKmU,WAAQ7T,EAEbN,KAAKid,WAAQ3c,EAEbN,KAAKgd,YAAS1c,EACdN,KAAKgxB,SAAW,CACd3c,KAAM,EACNF,MAAO,EACPD,IAAK,EACLE,OAAQ,GAGVpU,KAAKixB,cAAW3wB,EAEhBN,KAAKkxB,eAAY5wB,EAEjBN,KAAKmxB,gBAAa7wB,EAElBN,KAAKoxB,mBAAgB9wB,EAErBN,KAAKqxB,iBAAc/wB,EAEnBN,KAAKsxB,kBAAehxB,EAIpBN,KAAKuL,UAAOjL,EAEZN,KAAKuxB,mBAAgBjxB,EACrBN,KAAKqB,SAAMf,EACXN,KAAKwD,SAAMlD,EACXN,KAAKwxB,YAASlxB,EAEdN,KAAKyZ,MAAQ,GAEbzZ,KAAKyxB,eAAiB,KAEtBzxB,KAAK0xB,YAAc,KAEnB1xB,KAAK2xB,YAAc,KACnB3xB,KAAKqZ,QAAU,EACfrZ,KAAK4xB,WAAa,EAClB5xB,KAAK6xB,kBAAoB,CAAC,EAE1B7xB,KAAK6d,iBAAcvd,EAEnBN,KAAK8d,eAAYxd,EACjBN,KAAKshB,gBAAiB,EACtBthB,KAAK8xB,cAAWxxB,EAChBN,KAAK+xB,cAAWzxB,EAChBN,KAAKgyB,mBAAgB1xB,EACrBN,KAAKiyB,mBAAgB3xB,EACrBN,KAAKkyB,aAAe,EACpBlyB,KAAKmyB,aAAe,EACpBnyB,KAAK4Y,OAAS,CAAC,EACf5Y,KAAKoyB,mBAAoB,EACzBpyB,KAAKyN,cAAWnN,CAClB,CAMA+xB,KAAKrqB,GACHhI,KAAKgI,QAAUA,EAAQsqB,WAAWtyB,KAAKoR,cAEvCpR,KAAKuL,KAAOvD,EAAQuD,KAGpBvL,KAAK+xB,SAAW/xB,KAAKsR,MAAMtJ,EAAQ3G,KACnCrB,KAAK8xB,SAAW9xB,KAAKsR,MAAMtJ,EAAQxE,KACnCxD,KAAKiyB,cAAgBjyB,KAAKsR,MAAMtJ,EAAQuqB,cACxCvyB,KAAKgyB,cAAgBhyB,KAAKsR,MAAMtJ,EAAQwqB,aAC1C,CAQAlhB,MAAMgE,EAAK5L,GACT,OAAO4L,CACT,CAOA/B,gBACE,IAAI,SAACwe,EAAQ,SAAED,EAAQ,cAAEG,EAAA,cAAeD,GAAiBhyB,KAKzD,OAJA+xB,GAAWU,EAAAA,EAAAA,GAAgBV,EAAU/e,OAAOC,mBAC5C6e,GAAWW,EAAAA,EAAAA,GAAgBX,EAAU9e,OAAOE,mBAC5C+e,GAAgBQ,EAAAA,EAAAA,GAAgBR,EAAejf,OAAOC,mBACtD+e,GAAgBS,EAAAA,EAAAA,GAAgBT,EAAehf,OAAOE,mBAC/C,CACL7R,KAAKoxB,EAAAA,EAAAA,GAAgBV,EAAUE,GAC/BzuB,KAAKivB,EAAAA,EAAAA,GAAgBX,EAAUE,GAC/B3e,YAAYnJ,EAAAA,EAAAA,GAAS6nB,GACrBze,YAAYpJ,EAAAA,EAAAA,GAAS4nB,GAEzB,CAQAnf,UAAUC,GAER,IACIJ,GADA,IAACnR,EAAA,IAAKmC,EAAA,WAAK6P,EAAA,WAAYC,GAActT,KAAKuT,gBAG9C,GAAIF,GAAcC,EAChB,MAAO,CAACjS,MAAKmC,OAGf,MAAMkvB,EAAQ1yB,KAAK+K,0BACnB,IAAK,IAAI5I,EAAI,EAAGsH,EAAOipB,EAAMzwB,OAAQE,EAAIsH,IAAQtH,EAC/CqQ,EAAQkgB,EAAMvwB,GAAG8I,WAAW0H,UAAU3S,KAAM4S,GACvCS,IACHhS,EAAMD,KAAKC,IAAIA,EAAKmR,EAAMnR,MAEvBiS,IACH9P,EAAMpC,KAAKoC,IAAIA,EAAKgP,EAAMhP,MAQ9B,OAHAnC,EAAMiS,GAAcjS,EAAMmC,EAAMA,EAAMnC,EACtCmC,EAAM6P,GAAchS,EAAMmC,EAAMnC,EAAMmC,EAE/B,CACLnC,KAAKoxB,EAAAA,EAAAA,GAAgBpxB,GAAKoxB,EAAAA,EAAAA,GAAgBjvB,EAAKnC,IAC/CmC,KAAKivB,EAAAA,EAAAA,GAAgBjvB,GAAKivB,EAAAA,EAAAA,GAAgBpxB,EAAKmC,IAEnD,CAOA8hB,aACE,MAAO,CACLjR,KAAMrU,KAAKqxB,aAAe,EAC1Bnd,IAAKlU,KAAKmxB,YAAc,EACxBhd,MAAOnU,KAAKsxB,cAAgB,EAC5Bld,OAAQpU,KAAKoxB,eAAiB,EAElC,CAOAuB,WACE,OAAO3yB,KAAKyZ,KACd,CAKAzH,YACE,MAAMpC,EAAO5P,KAAKQ,MAAMoP,KACxB,OAAO5P,KAAKgI,QAAQ+J,SAAW/R,KAAKsc,eAAiB1M,EAAKgjB,QAAUhjB,EAAKijB,UAAYjjB,EAAKmC,QAAU,EACtG,CAKA+gB,cAAcle,EAAY5U,KAAKQ,MAAMoU,WAEnC,OADc5U,KAAK0xB,cAAgB1xB,KAAK0xB,YAAc1xB,KAAK+yB,mBAAmBne,GAEhF,CAGA2T,eACEvoB,KAAK4Y,OAAS,CAAC,EACf5Y,KAAKoyB,mBAAoB,CAC3B,CAMAY,gBACEC,EAAAA,EAAAA,GAAKjzB,KAAKgI,QAAQgrB,aAAc,CAAChzB,MACnC,CAUAkG,OAAO+qB,EAAUC,EAAWgC,GAC1B,MAAM,YAACnX,EAAW,MAAEoX,EAAO1Z,MAAO2Z,GAAYpzB,KAAKgI,QAC7CqrB,EAAaD,EAASC,WAG5BrzB,KAAKgzB,eAGLhzB,KAAKixB,SAAWA,EAChBjxB,KAAKkxB,UAAYA,EACjBlxB,KAAKgxB,SAAWkC,EAAU/rB,OAAOe,OAAO,CACtCmM,KAAM,EACNF,MAAO,EACPD,IAAK,EACLE,OAAQ,GACP8e,GAEHlzB,KAAKyZ,MAAQ,KACbzZ,KAAK2xB,YAAc,KACnB3xB,KAAKyxB,eAAiB,KACtBzxB,KAAK0xB,YAAc,KAGnB1xB,KAAKszB,sBACLtzB,KAAKuzB,gBACLvzB,KAAKwzB,qBAELxzB,KAAK4xB,WAAa5xB,KAAKsc,eACnBtc,KAAKid,MAAQiW,EAAQ7e,KAAO6e,EAAQ/e,MACpCnU,KAAKgd,OAASkW,EAAQhf,IAAMgf,EAAQ9e,OAGnCpU,KAAKoyB,oBACRpyB,KAAKyzB,mBACLzzB,KAAK0zB,sBACL1zB,KAAK2zB,kBACL3zB,KAAKwxB,QAASoC,EAAAA,EAAAA,GAAU5zB,KAAMmzB,EAAOpX,GACrC/b,KAAKoyB,mBAAoB,GAG3BpyB,KAAK6zB,mBAEL7zB,KAAKyZ,MAAQzZ,KAAK8zB,cAAgB,GAGlC9zB,KAAK+zB,kBAIL,MAAMC,EAAkBX,EAAarzB,KAAKyZ,MAAMxX,OAChDjC,KAAKi0B,sBAAsBD,EAAkBxE,GAAOxvB,KAAKyZ,MAAO4Z,GAAcrzB,KAAKyZ,OAMnFzZ,KAAKgH,YAGLhH,KAAKk0B,+BACLl0B,KAAKm0B,yBACLn0B,KAAKo0B,8BAGDhB,EAAS1K,UAAY0K,EAASiB,UAAgC,SAApBjB,EAASkB,UACrDt0B,KAAKyZ,MD1bJ,SAAkBzQ,EAAOyQ,GAC9B,MAAM2Z,EAAWpqB,EAAMhB,QAAQyR,MACzB8a,EA8BR,SAA2BvrB,GACzB,MAAM4S,EAAS5S,EAAMhB,QAAQ4T,OACvBwU,EAAapnB,EAAMwrB,YACnBC,EAAWzrB,EAAMqQ,QAAU+W,GAAcxU,EAAS,EAAI,GACtD8Y,EAAW1rB,EAAM4oB,WAAaxB,EACpC,OAAOhvB,KAAKoE,MAAMpE,KAAKC,IAAIozB,EAAUC,GACvC,CApC6BC,CAAkB3rB,GACvC4rB,EAAaxzB,KAAKC,IAAI+xB,EAAS7D,eAAiBgF,EAAoBA,GACpEM,EAAezB,EAAS0B,MAAMC,QAgEtC,SAAyBtb,GACvB,MAAMiW,EAAS,GACf,IAAIvtB,EAAGsH,EACP,IAAKtH,EAAI,EAAGsH,EAAOgQ,EAAMxX,OAAQE,EAAIsH,EAAMtH,IACrCsX,EAAMtX,GAAG2yB,OACXpF,EAAOxsB,KAAKf,GAGhB,OAAOutB,CACT,CAzEgDsF,CAAgBvb,GAAS,GACjEwb,EAAkBJ,EAAa5yB,OAC/BizB,EAAQL,EAAa,GACrB1X,EAAO0X,EAAaI,EAAkB,GACtCnG,EAAW,GAGjB,GAAImG,EAAkBL,EAEpB,OAwEJ,SAAoBnb,EAAOqV,EAAU+F,EAAc9F,GACjD,IAEI5sB,EAFAoP,EAAQ,EACRuN,EAAO+V,EAAa,GAIxB,IADA9F,EAAU3tB,KAAK8tB,KAAKH,GACf5sB,EAAI,EAAGA,EAAIsX,EAAMxX,OAAQE,IACxBA,IAAM2c,IACRgQ,EAAS5rB,KAAKuW,EAAMtX,IACpBoP,IACAuN,EAAO+V,EAAatjB,EAAQwd,GAGlC,CAtFIoG,CAAW1b,EAAOqV,EAAU+F,EAAcI,EAAkBL,GACrD9F,EAGT,MAAMC,EA6BR,SAA0B8F,EAAcpb,EAAOmb,GAC7C,MAAMQ,EA6FR,SAAwBvd,GACtB,MAAM+X,EAAM/X,EAAI5V,OAChB,IAAIE,EAAGkzB,EAEP,GAAIzF,EAAM,EACR,OAAO,EAGT,IAAKyF,EAAOxd,EAAI,GAAI1V,EAAI,EAAGA,EAAIytB,IAAOztB,EACpC,GAAI0V,EAAI1V,GAAK0V,EAAI1V,EAAI,KAAOkzB,EAC1B,OAAO,EAGX,OAAOA,CACT,CA3G2BC,CAAeT,GAClC9F,EAAUtV,EAAMxX,OAAS2yB,EAI/B,IAAKQ,EACH,OAAOh0B,KAAKoC,IAAIurB,EAAS,GAG3B,MAAMwG,GAAUC,EAAAA,EAAAA,GAAWJ,GAC3B,IAAK,IAAIjzB,EAAI,EAAGsH,EAAO8rB,EAAQtzB,OAAS,EAAGE,EAAIsH,EAAMtH,IAAK,CACxD,MAAMiC,EAASmxB,EAAQpzB,GACvB,GAAIiC,EAAS2qB,EACX,OAAO3qB,CAEX,CACA,OAAOhD,KAAKoC,IAAIurB,EAAS,EAC3B,CA/CkB0G,CAAiBZ,EAAcpb,EAAOmb,GAEtD,GAAIK,EAAkB,EAAG,CACvB,IAAI9yB,EAAGsH,EACP,MAAMisB,EAAkBT,EAAkB,EAAI7zB,KAAK+tB,OAAOhS,EAAO+X,IAAUD,EAAkB,IAAM,KAEnG,IADAvU,GAAKjH,EAAOqV,EAAUC,GAASrS,EAAAA,EAAAA,GAAcgZ,GAAmB,EAAIR,EAAQQ,EAAiBR,GACxF/yB,EAAI,EAAGsH,EAAOwrB,EAAkB,EAAG9yB,EAAIsH,EAAMtH,IAChDue,GAAKjH,EAAOqV,EAAUC,EAAS8F,EAAa1yB,GAAI0yB,EAAa1yB,EAAI,IAGnE,OADAue,GAAKjH,EAAOqV,EAAUC,EAAS5R,GAAMT,EAAAA,EAAAA,GAAcgZ,GAAmBjc,EAAMxX,OAASkb,EAAOuY,GACrF5G,EAGT,OADApO,GAAKjH,EAAOqV,EAAUC,GACfD,CACT,CC4ZmBuF,CAASr0B,KAAMA,KAAKyZ,OACjCzZ,KAAK2xB,YAAc,KACnB3xB,KAAK21B,iBAGH3B,GAEFh0B,KAAKi0B,sBAAsBj0B,KAAKyZ,OAGlCzZ,KAAK41B,YACL51B,KAAK61B,MACL71B,KAAK81B,WAIL91B,KAAK+1B,aACP,CAKA/uB,YACE,IACIsX,EAAYE,EADZwX,EAAgBh2B,KAAKgI,QAAQmB,QAG7BnJ,KAAKsc,gBACPgC,EAAate,KAAKqU,KAClBmK,EAAWxe,KAAKmU,QAEhBmK,EAAate,KAAKkU,IAClBsK,EAAWxe,KAAKoU,OAEhB4hB,GAAiBA,GAEnBh2B,KAAK6d,YAAcS,EACnBte,KAAK8d,UAAYU,EACjBxe,KAAKshB,eAAiB0U,EACtBh2B,KAAKqZ,QAAUmF,EAAWF,EAC1Bte,KAAKi2B,eAAiBj2B,KAAKgI,QAAQkuB,aACrC,CAEAH,eACE9C,EAAAA,EAAAA,GAAKjzB,KAAKgI,QAAQ+tB,YAAa,CAAC/1B,MAClC,CAIAszB,uBACEL,EAAAA,EAAAA,GAAKjzB,KAAKgI,QAAQsrB,oBAAqB,CAACtzB,MAC1C,CACAuzB,gBAEMvzB,KAAKsc,gBAEPtc,KAAKid,MAAQjd,KAAKixB,SAClBjxB,KAAKqU,KAAO,EACZrU,KAAKmU,MAAQnU,KAAKid,QAElBjd,KAAKgd,OAAShd,KAAKkxB,UAGnBlxB,KAAKkU,IAAM,EACXlU,KAAKoU,OAASpU,KAAKgd,QAIrBhd,KAAKqxB,YAAc,EACnBrxB,KAAKmxB,WAAa,EAClBnxB,KAAKsxB,aAAe,EACpBtxB,KAAKoxB,cAAgB,CACvB,CACAoC,sBACEP,EAAAA,EAAAA,GAAKjzB,KAAKgI,QAAQwrB,mBAAoB,CAACxzB,MACzC,CAEAm2B,WAAWzY,GACT1d,KAAKQ,MAAM41B,cAAc1Y,EAAM1d,KAAKoR,eACpC6hB,EAAAA,EAAAA,GAAKjzB,KAAKgI,QAAQ0V,GAAO,CAAC1d,MAC5B,CAGAyzB,mBACEzzB,KAAKm2B,WAAW,mBAClB,CACAzC,sBAAuB,CACvBC,kBACE3zB,KAAKm2B,WAAW,kBAClB,CAGAtC,mBACE7zB,KAAKm2B,WAAW,mBAClB,CAIArC,aACE,MAAO,EACT,CACAC,kBACE/zB,KAAKm2B,WAAW,kBAClB,CAEAE,+BACEpD,EAAAA,EAAAA,GAAKjzB,KAAKgI,QAAQquB,4BAA6B,CAACr2B,MAClD,CAKAs2B,mBAAmB7c,GACjB,MAAM2Z,EAAWpzB,KAAKgI,QAAQyR,MAC9B,IAAItX,EAAGsH,EAAMlH,EACb,IAAKJ,EAAI,EAAGsH,EAAOgQ,EAAMxX,OAAQE,EAAIsH,EAAMtH,IACzCI,EAAOkX,EAAMtX,GACbI,EAAKqR,OAAQqf,EAAAA,EAAAA,GAAKG,EAASH,SAAU,CAAC1wB,EAAKsG,MAAO1G,EAAGsX,GAAQzZ,KAEjE,CACAu2B,8BACEtD,EAAAA,EAAAA,GAAKjzB,KAAKgI,QAAQuuB,2BAA4B,CAACv2B,MACjD,CAIAk0B,gCACEjB,EAAAA,EAAAA,GAAKjzB,KAAKgI,QAAQksB,6BAA8B,CAACl0B,MACnD,CACAm0B,yBACE,MAAMnsB,EAAUhI,KAAKgI,QACforB,EAAWprB,EAAQyR,MACnB+c,EAAWnH,GAAcrvB,KAAKyZ,MAAMxX,OAAQ+F,EAAQyR,MAAM8V,eAC1DkH,EAAcrD,EAASqD,aAAe,EACtCC,EAActD,EAASsD,YAC7B,IACIC,EAAWzF,EAAW0F,EADtBrF,EAAgBkF,EAGpB,IAAKz2B,KAAK62B,eAAiBzD,EAAS1K,SAAW+N,GAAeC,GAAeF,GAAY,IAAMx2B,KAAKsc,eAElG,YADAtc,KAAKuxB,cAAgBkF,GAIvB,MAAMK,EAAa92B,KAAK+2B,iBAClBC,EAAgBF,EAAWG,OAAOha,MAClCia,EAAiBJ,EAAWK,QAAQna,OAIpCiU,GAAWmG,EAAAA,EAAAA,GAAYp3B,KAAKQ,MAAMyc,MAAQ+Z,EAAe,EAAGh3B,KAAKixB,UACvE0F,EAAY3uB,EAAQ4T,OAAS5b,KAAKixB,SAAWuF,EAAWvF,GAAYuF,EAAW,GAG3EQ,EAAgB,EAAIL,IACtBA,EAAY1F,GAAYuF,GAAYxuB,EAAQ4T,OAAS,GAAM,IAC3DsV,EAAYlxB,KAAKkxB,UAAYhB,GAAkBloB,EAAQ6T,MACvDuX,EAAStM,QAAUuJ,GAAeroB,EAAQqvB,MAAOr3B,KAAKQ,MAAMwH,QAAQuoB,MACpEqG,EAAmBx1B,KAAK4hB,KAAKgU,EAAgBA,EAAgBE,EAAiBA,GAC9E3F,GAAgB+F,EAAAA,EAAAA,GAAUl2B,KAAKC,IAC7BD,KAAKm2B,MAAKH,EAAAA,EAAAA,IAAaN,EAAWK,QAAQna,OAAS,GAAK2Z,GAAY,EAAG,IACvEv1B,KAAKm2B,MAAKH,EAAAA,EAAAA,GAAYlG,EAAY0F,GAAmB,EAAG,IAAMx1B,KAAKm2B,MAAKH,EAAAA,EAAAA,GAAYF,EAAiBN,GAAmB,EAAG,MAE7HrF,EAAgBnwB,KAAKoC,IAAIizB,EAAar1B,KAAKC,IAAIq1B,EAAanF,KAG9DvxB,KAAKuxB,cAAgBA,CACvB,CACA6C,+BACEnB,EAAAA,EAAAA,GAAKjzB,KAAKgI,QAAQosB,4BAA6B,CAACp0B,MAClD,CACA21B,gBAAiB,CAIjBC,aACE3C,EAAAA,EAAAA,GAAKjzB,KAAKgI,QAAQ4tB,UAAW,CAAC51B,MAChC,CACA61B,MAEE,MAAM2B,EAAU,CACdva,MAAO,EACPD,OAAQ,IAGJ,MAACxc,EAAOwH,SAAUyR,MAAO2Z,EAAUiE,MAAOI,EAAW5b,KAAM6b,IAAa13B,KACxE0oB,EAAU1oB,KAAK62B,aACfva,EAAetc,KAAKsc,eAE1B,GAAIoM,EAAS,CACX,MAAMiP,EAActH,GAAeoH,EAAWj3B,EAAMwH,QAAQuoB,MAU5D,GATIjU,GACFkb,EAAQva,MAAQjd,KAAKixB,SACrBuG,EAAQxa,OAASkT,GAAkBwH,GAAYC,IAE/CH,EAAQxa,OAAShd,KAAKkxB,UACtBsG,EAAQva,MAAQiT,GAAkBwH,GAAYC,GAI5CvE,EAAS1K,SAAW1oB,KAAKyZ,MAAMxX,OAAQ,CACzC,MAAM,MAACizB,EAAA,KAAO/X,EAAA,OAAM8Z,EAAA,QAAQE,GAAWn3B,KAAK+2B,iBACtCa,EAAiC,EAAnBxE,EAAStM,QACvB+Q,GAAeC,EAAAA,EAAAA,GAAU93B,KAAKuxB,eAC9BwG,EAAM32B,KAAK22B,IAAIF,GACfG,EAAM52B,KAAK42B,IAAIH,GAErB,GAAIvb,EAAc,CAEhB,MAAM2b,EAAc7E,EAAS8E,OAAS,EAAIF,EAAMf,EAAOha,MAAQ8a,EAAMZ,EAAQna,OAC7Ewa,EAAQxa,OAAS5b,KAAKC,IAAIrB,KAAKkxB,UAAWsG,EAAQxa,OAASib,EAAcL,OACpE,CAGL,MAAMO,EAAa/E,EAAS8E,OAAS,EAAIH,EAAMd,EAAOha,MAAQ+a,EAAMb,EAAQna,OAE5Ewa,EAAQva,MAAQ7b,KAAKC,IAAIrB,KAAKixB,SAAUuG,EAAQva,MAAQkb,EAAaP,GAEvE53B,KAAKo4B,kBAAkBlD,EAAO/X,EAAM6a,EAAKD,IAI7C/3B,KAAKq4B,iBAED/b,GACFtc,KAAKid,MAAQjd,KAAKqZ,QAAU7Y,EAAMyc,MAAQjd,KAAKgxB,SAAS3c,KAAOrU,KAAKgxB,SAAS7c,MAC7EnU,KAAKgd,OAASwa,EAAQxa,SAEtBhd,KAAKid,MAAQua,EAAQva,MACrBjd,KAAKgd,OAAShd,KAAKqZ,QAAU7Y,EAAMwc,OAAShd,KAAKgxB,SAAS9c,IAAMlU,KAAKgxB,SAAS5c,OAElF,CAEAgkB,kBAAkBlD,EAAO/X,EAAM6a,EAAKD,GAClC,MAAOte,OAAO,MAACmX,EAAA,QAAO9J,GAAQ,SAAEhF,GAAY9hB,KAAKgI,QAC3CswB,EAAmC,IAAvBt4B,KAAKuxB,cACjBgH,EAAgC,QAAbzW,GAAoC,MAAd9hB,KAAKuL,KAEpD,GAAIvL,KAAKsc,eAAgB,CACvB,MAAMkc,EAAax4B,KAAK0Z,gBAAgB,GAAK1Z,KAAKqU,KAC5CokB,EAAcz4B,KAAKmU,MAAQnU,KAAK0Z,gBAAgB1Z,KAAKyZ,MAAMxX,OAAS,GAC1E,IAAIovB,EAAc,EACdC,EAAe,EAIfgH,EACEC,GACFlH,EAAc0G,EAAM7C,EAAMjY,MAC1BqU,EAAe0G,EAAM7a,EAAKH,SAE1BqU,EAAc2G,EAAM9C,EAAMlY,OAC1BsU,EAAeyG,EAAM5a,EAAKF,OAET,UAAV2T,EACTU,EAAenU,EAAKF,MACD,QAAV2T,EACTS,EAAc6D,EAAMjY,MACD,UAAV2T,IACTS,EAAc6D,EAAMjY,MAAQ,EAC5BqU,EAAenU,EAAKF,MAAQ,GAI9Bjd,KAAKqxB,YAAcjwB,KAAKoC,KAAK6tB,EAAcmH,EAAa1R,GAAW9mB,KAAKid,OAASjd,KAAKid,MAAQub,GAAa,GAC3Gx4B,KAAKsxB,aAAelwB,KAAKoC,KAAK8tB,EAAemH,EAAc3R,GAAW9mB,KAAKid,OAASjd,KAAKid,MAAQwb,GAAc,OAC1G,CACL,IAAItH,EAAahU,EAAKH,OAAS,EAC3BoU,EAAgB8D,EAAMlY,OAAS,EAErB,UAAV4T,GACFO,EAAa,EACbC,EAAgB8D,EAAMlY,QACH,QAAV4T,IACTO,EAAahU,EAAKH,OAClBoU,EAAgB,GAGlBpxB,KAAKmxB,WAAaA,EAAarK,EAC/B9mB,KAAKoxB,cAAgBA,EAAgBtK,EAEzC,CAMAuR,iBACMr4B,KAAKgxB,WACPhxB,KAAKgxB,SAAS3c,KAAOjT,KAAKoC,IAAIxD,KAAKqxB,YAAarxB,KAAKgxB,SAAS3c,MAC9DrU,KAAKgxB,SAAS9c,IAAM9S,KAAKoC,IAAIxD,KAAKmxB,WAAYnxB,KAAKgxB,SAAS9c,KAC5DlU,KAAKgxB,SAAS7c,MAAQ/S,KAAKoC,IAAIxD,KAAKsxB,aAActxB,KAAKgxB,SAAS7c,OAChEnU,KAAKgxB,SAAS5c,OAAShT,KAAKoC,IAAIxD,KAAKoxB,cAAepxB,KAAKgxB,SAAS5c,QAEtE,CAEA0hB,YACE7C,EAAAA,EAAAA,GAAKjzB,KAAKgI,QAAQ8tB,SAAU,CAAC91B,MAC/B,CAMAsc,eACE,MAAM,KAAC/Q,EAAA,SAAMuW,GAAY9hB,KAAKgI,QAC9B,MAAoB,QAAb8Z,GAAmC,WAAbA,GAAkC,MAATvW,CACxD,CAIAmtB,aACE,OAAO14B,KAAKgI,QAAQ0e,QACtB,CAMAuN,sBAAsBxa,GAMpB,IAAItX,EAAGsH,EACP,IANAzJ,KAAKq2B,8BAELr2B,KAAKs2B,mBAAmB7c,GAInBtX,EAAI,EAAGsH,EAAOgQ,EAAMxX,OAAQE,EAAIsH,EAAMtH,KACrCua,EAAAA,EAAAA,GAAcjD,EAAMtX,GAAGyR,SACzB6F,EAAMzB,OAAO7V,EAAG,GAChBsH,IACAtH,KAIJnC,KAAKu2B,4BACP,CAMAQ,iBACE,IAAID,EAAa92B,KAAK2xB,YAEtB,IAAKmF,EAAY,CACf,MAAMzD,EAAarzB,KAAKgI,QAAQyR,MAAM4Z,WACtC,IAAI5Z,EAAQzZ,KAAKyZ,MACb4Z,EAAa5Z,EAAMxX,SACrBwX,EAAQ+V,GAAO/V,EAAO4Z,IAGxBrzB,KAAK2xB,YAAcmF,EAAa92B,KAAK24B,mBAAmBlf,EAAOA,EAAMxX,OAAQjC,KAAKgI,QAAQyR,MAAM8V,eAGlG,OAAOuH,CACT,CAQA6B,mBAAmBlf,EAAOxX,EAAQstB,GAChC,MAAM,IAAC1iB,EAAKglB,kBAAmB+G,GAAU54B,KACnC64B,EAAS,GACTC,EAAU,GACVnJ,EAAYvuB,KAAKoE,MAAMvD,EAASotB,GAAcptB,EAAQstB,IAC5D,IAEIptB,EAAG8f,EAAG8W,EAAMnlB,EAAOolB,EAAUC,EAAYtjB,EAAO+a,EAAYzT,EAAOD,EAAQkc,EAF3EC,EAAkB,EAClBC,EAAmB,EAGvB,IAAKj3B,EAAI,EAAGA,EAAIF,EAAQE,GAAKwtB,EAAW,CAQtC,GAPA/b,EAAQ6F,EAAMtX,GAAGyR,MACjBolB,EAAWh5B,KAAKq5B,wBAAwBl3B,GACxC0K,EAAI0jB,KAAO0I,EAAaD,EAASM,OACjC3jB,EAAQijB,EAAOK,GAAcL,EAAOK,IAAe,CAACrpB,KAAM,CAAC,EAAG2pB,GAAI,IAClE7I,EAAasI,EAAStI,WACtBzT,EAAQD,EAAS,GAEZN,EAAAA,EAAAA,GAAc9I,KAAWjM,EAAAA,EAAAA,GAAQiM,IAG/B,IAAIjM,EAAAA,EAAAA,GAAQiM,GAEjB,IAAKqO,EAAI,EAAG8W,EAAOnlB,EAAM3R,OAAQggB,EAAI8W,IAAQ9W,EAC3CiX,EAAqCtlB,EAAMqO,IAEtCvF,EAAAA,EAAAA,GAAcwc,KAAiBvxB,EAAAA,EAAAA,GAAQuxB,KAC1Cjc,GAAQuc,EAAAA,EAAAA,GAAa3sB,EAAK8I,EAAM/F,KAAM+F,EAAM4jB,GAAItc,EAAOic,GACvDlc,GAAU0T,QATdzT,GAAQuc,EAAAA,EAAAA,GAAa3sB,EAAK8I,EAAM/F,KAAM+F,EAAM4jB,GAAItc,EAAOrJ,GACvDoJ,EAAS0T,EAYXmI,EAAO31B,KAAK+Z,GACZ6b,EAAQ51B,KAAK8Z,GACbmc,EAAkB/3B,KAAKoC,IAAIyZ,EAAOkc,GAClCC,EAAmBh4B,KAAKoC,IAAIwZ,EAAQoc,EACtC,EAhxBJ,SAAwBR,EAAQ32B,IAC9BqmB,EAAAA,EAAAA,GAAKsQ,GAASjjB,IACZ,MAAM4jB,EAAK5jB,EAAM4jB,GACXE,EAAQF,EAAGt3B,OAAS,EAC1B,IAAIE,EACJ,GAAIs3B,EAAQx3B,EAAQ,CAClB,IAAKE,EAAI,EAAGA,EAAIs3B,IAASt3B,SAChBwT,EAAM/F,KAAK2pB,EAAGp3B,IAEvBo3B,EAAGvhB,OAAO,EAAGyhB,MAGnB,CAqwBIC,CAAed,EAAQ32B,GAEvB,MAAMg1B,EAAS4B,EAAOtb,QAAQ4b,GACxBhC,EAAU2B,EAAQvb,QAAQ6b,GAE1BO,EAAWC,IAAA,CAAU3c,MAAO4b,EAAOe,IAAQ,EAAG5c,OAAQ8b,EAAQc,IAAQ,IAE5E,MAAO,CACL1E,MAAOyE,EAAQ,GACfxc,KAAMwc,EAAQ13B,EAAS,GACvBg1B,OAAQ0C,EAAQ1C,GAChBE,QAASwC,EAAQxC,GACjB0B,SACAC,UAEJ,CAOAjlB,iBAAiBhL,GACf,OAAOA,CACT,CASA2Q,iBAAiB3Q,EAAOa,GACtB,OAAOgJ,GACT,CAQA+L,iBAAiBob,GAAQ,CAQzBngB,gBAAgBhQ,GACd,MAAM+P,EAAQzZ,KAAKyZ,MACnB,OAAI/P,EAAQ,GAAKA,EAAQ+P,EAAMxX,OAAS,EAC/B,KAEFjC,KAAKwZ,iBAAiBC,EAAM/P,GAAOb,MAC5C,CAQA0V,mBAAmBub,GACb95B,KAAKshB,iBACPwY,EAAU,EAAIA,GAGhB,MAAMD,EAAQ75B,KAAK6d,YAAcic,EAAU95B,KAAKqZ,QAChD,OAAO0gB,EAAAA,EAAAA,GAAY/5B,KAAKi2B,gBAAiB+D,EAAAA,EAAAA,GAAYh6B,KAAKQ,MAAOq5B,EAAO,GAAKA,EAC/E,CAMAI,mBAAmBJ,GACjB,MAAMC,GAAWD,EAAQ75B,KAAK6d,aAAe7d,KAAKqZ,QAClD,OAAOrZ,KAAKshB,eAAiB,EAAIwY,EAAUA,CAC7C,CAOAzd,eACE,OAAOrc,KAAKwZ,iBAAiBxZ,KAAKk6B,eACpC,CAKAA,eACE,MAAM,IAAC74B,EAAG,IAAEmC,GAAOxD,KAEnB,OAAOqB,EAAM,GAAKmC,EAAM,EAAIA,EAC1BnC,EAAM,GAAKmC,EAAM,EAAInC,EACrB,CACJ,CAKA+P,WAAW1H,GACT,MAAM+P,EAAQzZ,KAAKyZ,OAAS,GAE5B,GAAI/P,GAAS,GAAKA,EAAQ+P,EAAMxX,OAAQ,CACtC,MAAMM,EAAOkX,EAAM/P,GACnB,OAAOnH,EAAKkL,WACblL,EAAKkL,SAt1BV,SAA2B0H,EAAQzL,EAAOnH,GACxC,OAAO6S,EAAAA,EAAAA,GAAcD,EAAQ,CAC3B5S,OACAmH,QACA/I,KAAM,QAEV,CAg1BqBw5B,CAAkBn6B,KAAKoR,aAAc1H,EAAOnH,IAE7D,OAAOvC,KAAKyN,WACZzN,KAAKyN,UAh2BmB0H,EAg2BWnV,KAAKQ,MAAM4Q,aAAcpR,MA/1BvDoV,EAAAA,EAAAA,GAAcD,EAAQ,CAC3BnM,MA81B4DhJ,KA71B5DW,KAAM,YAHV,IAA4BwU,CAi2B1B,CAMAqf,YACE,MAAM4F,EAAcp6B,KAAKgI,QAAQyR,MAG3B4gB,GAAMvC,EAAAA,EAAAA,GAAU93B,KAAKuxB,eACrBwG,EAAM32B,KAAKmY,IAAInY,KAAK22B,IAAIsC,IACxBrC,EAAM52B,KAAKmY,IAAInY,KAAK42B,IAAIqC,IAExBvD,EAAa92B,KAAK+2B,iBAClBjQ,EAAUsT,EAAYE,iBAAmB,EACzC1U,EAAIkR,EAAaA,EAAWG,OAAOha,MAAQ6J,EAAU,EACrDhB,EAAIgR,EAAaA,EAAWK,QAAQna,OAAS8J,EAAU,EAG7D,OAAO9mB,KAAKsc,eACRwJ,EAAIiS,EAAMnS,EAAIoS,EAAMpS,EAAImS,EAAMjS,EAAIkS,EAClClS,EAAIkS,EAAMpS,EAAImS,EAAMjS,EAAIiS,EAAMnS,EAAIoS,CACxC,CAMAnB,aACE,MAAMnO,EAAU1oB,KAAKgI,QAAQ0gB,QAE7B,MAAgB,SAAZA,IACOA,EAGJ1oB,KAAK+K,0BAA0B9I,OAAS,CACjD,CAKAs4B,sBAAsB3lB,GACpB,MAAMrJ,EAAOvL,KAAKuL,KACZ/K,EAAQR,KAAKQ,MACbwH,EAAUhI,KAAKgI,SACf,KAAC6T,EAAI,SAAEiG,EAAA,OAAUhB,GAAU9Y,EAC3B4T,EAASC,EAAKD,OACdU,EAAetc,KAAKsc,eAEpBgT,EADQtvB,KAAKyZ,MACOxX,QAAU2Z,EAAS,EAAI,GAC3C4e,EAAKtK,GAAkBrU,GACvB7Z,EAAQ,GAERy4B,EAAa3Z,EAAOwR,WAAWtyB,KAAKoR,cACpCspB,EAAYD,EAAW/R,QAAU+R,EAAWxd,MAAQ,EACpD0d,EAAgBD,EAAY,EAC5BE,EAAmB,SAASf,GAChC,OAAOG,EAAAA,EAAAA,GAAYx5B,EAAOq5B,EAAOa,EACnC,EACA,IAAIG,EAAa14B,EAAG8tB,EAAW6K,EAC3BC,EAAKC,EAAKC,EAAKC,EAAKC,EAAIC,EAAIC,EAAIC,EAEpC,GAAiB,QAAbxZ,EACF+Y,EAAcD,EAAiB56B,KAAKoU,QACpC4mB,EAAMh7B,KAAKoU,OAASomB,EACpBU,EAAML,EAAcF,EACpBS,EAAKR,EAAiBhmB,EAAUV,KAAOymB,EACvCW,EAAK1mB,EAAUR,YACV,GAAiB,WAAb0N,EACT+Y,EAAcD,EAAiB56B,KAAKkU,KACpCknB,EAAKxmB,EAAUV,IACfonB,EAAKV,EAAiBhmB,EAAUR,QAAUumB,EAC1CK,EAAMH,EAAcF,EACpBO,EAAMl7B,KAAKkU,IAAMsmB,OACZ,GAAiB,SAAb1Y,EACT+Y,EAAcD,EAAiB56B,KAAKmU,OACpC4mB,EAAM/6B,KAAKmU,MAAQqmB,EACnBS,EAAMJ,EAAcF,EACpBQ,EAAKP,EAAiBhmB,EAAUP,MAAQsmB,EACxCU,EAAKzmB,EAAUT,WACV,GAAiB,UAAb2N,EACT+Y,EAAcD,EAAiB56B,KAAKqU,MACpC8mB,EAAKvmB,EAAUP,KACfgnB,EAAKT,EAAiBhmB,EAAUT,OAASwmB,EACzCI,EAAMF,EAAcF,EACpBM,EAAMj7B,KAAKqU,KAAOmmB,OACb,GAAa,MAATjvB,EAAc,CACvB,GAAiB,WAAbuW,EACF+Y,EAAcD,GAAkBhmB,EAAUV,IAAMU,EAAUR,QAAU,EAAI,SACnE,IAAInN,EAAAA,EAAAA,GAAS6a,GAAW,CAC7B,MAAMyZ,EAAiBp0B,OAAOC,KAAK0a,GAAU,GACvCjZ,EAAQiZ,EAASyZ,GACvBV,EAAcD,EAAiB56B,KAAKQ,MAAMyL,OAAOsvB,GAAgB/hB,iBAAiB3Q,IAGpFuyB,EAAKxmB,EAAUV,IACfonB,EAAK1mB,EAAUR,OACf4mB,EAAMH,EAAcF,EACpBO,EAAMF,EAAMR,OACP,GAAa,MAATjvB,EAAc,CACvB,GAAiB,WAAbuW,EACF+Y,EAAcD,GAAkBhmB,EAAUP,KAAOO,EAAUT,OAAS,QAC/D,IAAIlN,EAAAA,EAAAA,GAAS6a,GAAW,CAC7B,MAAMyZ,EAAiBp0B,OAAOC,KAAK0a,GAAU,GACvCjZ,EAAQiZ,EAASyZ,GACvBV,EAAcD,EAAiB56B,KAAKQ,MAAMyL,OAAOsvB,GAAgB/hB,iBAAiB3Q,IAGpFkyB,EAAMF,EAAcF,EACpBM,EAAMF,EAAMP,EACZW,EAAKvmB,EAAUP,KACfgnB,EAAKzmB,EAAUT,MAGjB,MAAMqnB,GAAQ1sB,EAAAA,EAAAA,GAAe9G,EAAQyR,MAAM8V,cAAeD,GACpDmM,EAAOr6B,KAAKoC,IAAI,EAAGpC,KAAK8tB,KAAKI,EAAckM,IACjD,IAAKr5B,EAAI,EAAGA,EAAImtB,EAAantB,GAAKs5B,EAAM,CACtC,MAAMvmB,EAAUlV,KAAKoR,WAAWjP,GAC1Bu5B,EAAc7f,EAAKyW,WAAWpd,GAC9BymB,EAAoB7a,EAAOwR,WAAWpd,GAEtC0mB,EAAYF,EAAYE,UACxBC,EAAYH,EAAYr3B,MACxBy3B,EAAaH,EAAkBI,MAAQ,GACvCC,EAAmBL,EAAkBM,WAErCtF,EAAY+E,EAAY/E,UACxBuF,EAAYR,EAAYQ,UACxBC,EAAiBT,EAAYS,gBAAkB,GAC/CC,EAAuBV,EAAYU,qBAEzCnM,EAAYJ,GAAoB7vB,KAAMmC,EAAGyZ,QAGvBtb,IAAd2vB,IAIJ6K,GAAmBd,EAAAA,EAAAA,GAAYx5B,EAAOyvB,EAAW2L,GAE7Ctf,EACFye,EAAME,EAAME,EAAKE,EAAKP,EAEtBE,EAAME,EAAME,EAAKE,EAAKR,EAGxB94B,EAAMkB,KAAK,CACT63B,MACAC,MACAC,MACAC,MACAC,KACAC,KACAC,KACAC,KACAre,MAAO2e,EACPv3B,MAAOw3B,EACPC,aACAE,mBACArF,YACAuF,YACAC,iBACAC,yBAEJ,CAKA,OAHAp8B,KAAKkyB,aAAe5C,EACpBtvB,KAAKmyB,aAAe0I,EAEb74B,CACT,CAKA+wB,mBAAmBne,GACjB,MAAMrJ,EAAOvL,KAAKuL,KACZvD,EAAUhI,KAAKgI,SACf,SAAC8Z,EAAUrI,MAAO2gB,GAAepyB,EACjCsU,EAAetc,KAAKsc,eACpB7C,EAAQzZ,KAAKyZ,OACb,MAACmX,EAAA,WAAOyL,EAAA,QAAYvV,EAAO,OAAEoR,GAAUkC,EACvCI,EAAKtK,GAAkBloB,EAAQ6T,MAC/BygB,EAAiB9B,EAAK1T,EACtByV,EAAkBrE,GAAUpR,EAAUwV,EACtCE,IAAY1E,EAAAA,EAAAA,GAAU93B,KAAKuxB,eAC3BvvB,EAAQ,GACd,IAAIG,EAAGsH,EAAMlH,EAAMqR,EAAOnF,EAAGC,EAAG+tB,EAAW5C,EAAOtJ,EAAMG,EAAYgM,EAAWC,EAC3EC,EAAe,SAEnB,GAAiB,QAAb9a,EACFpT,EAAI1O,KAAKoU,OAASmoB,EAClBE,EAAYz8B,KAAK68B,+BACZ,GAAiB,WAAb/a,EACTpT,EAAI1O,KAAKkU,IAAMqoB,EACfE,EAAYz8B,KAAK68B,+BACZ,GAAiB,SAAb/a,EAAqB,CAC9B,MAAM+M,EAAM7uB,KAAK88B,wBAAwBtC,GACzCiC,EAAY5N,EAAI4N,UAChBhuB,EAAIogB,EAAIpgB,OACH,GAAiB,UAAbqT,EAAsB,CAC/B,MAAM+M,EAAM7uB,KAAK88B,wBAAwBtC,GACzCiC,EAAY5N,EAAI4N,UAChBhuB,EAAIogB,EAAIpgB,OACH,GAAa,MAATlD,EAAc,CACvB,GAAiB,WAAbuW,EACFpT,GAAMkG,EAAUV,IAAMU,EAAUR,QAAU,EAAKkoB,OAC1C,IAAIr1B,EAAAA,EAAAA,GAAS6a,GAAW,CAC7B,MAAMyZ,EAAiBp0B,OAAOC,KAAK0a,GAAU,GACvCjZ,EAAQiZ,EAASyZ,GACvB7sB,EAAI1O,KAAKQ,MAAMyL,OAAOsvB,GAAgB/hB,iBAAiB3Q,GAASyzB,EAElEG,EAAYz8B,KAAK68B,+BACZ,GAAa,MAATtxB,EAAc,CACvB,GAAiB,WAAbuW,EACFrT,GAAMmG,EAAUP,KAAOO,EAAUT,OAAS,EAAKmoB,OAC1C,IAAIr1B,EAAAA,EAAAA,GAAS6a,GAAW,CAC7B,MAAMyZ,EAAiBp0B,OAAOC,KAAK0a,GAAU,GACvCjZ,EAAQiZ,EAASyZ,GACvB9sB,EAAIzO,KAAKQ,MAAMyL,OAAOsvB,GAAgB/hB,iBAAiB3Q,GAEzD4zB,EAAYz8B,KAAK88B,wBAAwBtC,GAAIiC,UAGlC,MAATlxB,IACY,UAAVqlB,EACFgM,EAAe,MACI,QAAVhM,IACTgM,EAAe,WAInB,MAAM9F,EAAa92B,KAAK+2B,iBACxB,IAAK50B,EAAI,EAAGsH,EAAOgQ,EAAMxX,OAAQE,EAAIsH,IAAQtH,EAAG,CAC9CI,EAAOkX,EAAMtX,GACbyR,EAAQrR,EAAKqR,MAEb,MAAM8nB,EAActB,EAAY9H,WAAWtyB,KAAKoR,WAAWjP,IAC3D03B,EAAQ75B,KAAK0Z,gBAAgBvX,GAAKi4B,EAAY2C,YAC9CxM,EAAOvwB,KAAKq5B,wBAAwBl3B,GACpCuuB,EAAaH,EAAKG,WAClBgM,GAAY/0B,EAAAA,EAAAA,GAAQiM,GAASA,EAAM3R,OAAS,EAC5C,MAAM+6B,EAAYN,EAAY,EACxBr4B,EAAQq3B,EAAYr3B,MACpB44B,EAAcvB,EAAYwB,gBAC1BC,EAAczB,EAAY0B,gBAChC,IA4CIC,EA5CAC,EAAgBb,EA8CpB,GA5CIngB,GACF7N,EAAIorB,EAEc,UAAd4C,IAEAa,EADEn7B,IAAMsH,EAAO,EACEzJ,KAAKgI,QAAQmB,QAAoB,OAAV,QACzB,IAANhH,EACQnC,KAAKgI,QAAQmB,QAAmB,QAAT,OAExB,UAMhBwzB,EAFa,QAAb7a,EACiB,SAAfua,GAAsC,IAAbG,GACbE,EAAYhM,EAAaA,EAAa,EAC5B,WAAf2L,GACKvF,EAAWK,QAAQna,OAAS,EAAIggB,EAAYtM,EAAaA,GAEzDoG,EAAWK,QAAQna,OAAS0T,EAAa,EAItC,SAAf2L,GAAsC,IAAbG,EACd9L,EAAa,EACF,WAAf2L,EACIvF,EAAWK,QAAQna,OAAS,EAAIggB,EAAYtM,EAE5CoG,EAAWK,QAAQna,OAAS0f,EAAYhM,EAGrDwH,IACFyE,IAAe,GAEA,IAAbH,GAAmBd,EAAY6B,oBACjC9uB,GAAKiiB,EAAc,EAAKtvB,KAAK42B,IAAIwE,MAGnC9tB,EAAImrB,EACJ8C,GAAc,EAAID,GAAahM,EAAa,GAK1CgL,EAAY6B,kBAAmB,CACjC,MAAMC,GAAehW,EAAAA,EAAAA,GAAUkU,EAAY+B,iBACrCzgB,EAAS8Z,EAAWgC,QAAQ32B,GAC5B8a,EAAQ6Z,EAAW+B,OAAO12B,GAEhC,IAAI+R,EAAMyoB,EAAaa,EAAatpB,IAChCG,EAAO,EAAImpB,EAAanpB,KAE5B,OAAQuoB,GACR,IAAK,SACH1oB,GAAO8I,EAAS,EAChB,MACF,IAAK,SACH9I,GAAO8I,EAMT,OAAQyf,GACR,IAAK,SACHpoB,GAAQ4I,EAAQ,EAChB,MACF,IAAK,QACH5I,GAAQ4I,EAMVogB,EAAW,CACThpB,OACAH,MACA+I,MAAOA,EAAQugB,EAAavgB,MAC5BD,OAAQA,EAASwgB,EAAaxgB,OAE9B3Y,MAAOq3B,EAAYgC,eAIvB17B,EAAMkB,KAAK,CACT0Q,QACA2c,OACAoM,aACA30B,QAAS,CACPw0B,WACAn4B,QACA44B,cACAE,cACAV,UAAWa,EACXV,eACAe,YAAa,CAAClvB,EAAGC,GACjB2uB,aAGN,CAEA,OAAOr7B,CACT,CAEA66B,0BACE,MAAM,SAAC/a,EAAA,MAAUrI,GAASzZ,KAAKgI,QAG/B,KAFkB8vB,EAAAA,EAAAA,GAAU93B,KAAKuxB,eAG/B,MAAoB,QAAbzP,EAAqB,OAAS,QAGvC,IAAI8O,EAAQ,SAUZ,MARoB,UAAhBnX,EAAMmX,MACRA,EAAQ,OACiB,QAAhBnX,EAAMmX,MACfA,EAAQ,QACiB,UAAhBnX,EAAMmX,QACfA,EAAQ,SAGHA,CACT,CAEAkM,wBAAwBtC,GACtB,MAAM,SAAC1Y,EAAUrI,OAAO,WAAC4iB,EAAA,OAAYnE,EAAA,QAAQpR,IAAY9mB,KAAKgI,QAExDs0B,EAAiB9B,EAAK1T,EACtBmQ,EAFaj3B,KAAK+2B,iBAEEE,OAAOha,MAEjC,IAAIwf,EACAhuB,EA0DJ,MAxDiB,SAAbqT,EACEoW,GACFzpB,EAAIzO,KAAKmU,MAAQ2S,EAEE,SAAfuV,EACFI,EAAY,OACY,WAAfJ,GACTI,EAAY,SACZhuB,GAAMwoB,EAAS,IAEfwF,EAAY,QACZhuB,GAAKwoB,KAGPxoB,EAAIzO,KAAKmU,MAAQmoB,EAEE,SAAfD,EACFI,EAAY,QACY,WAAfJ,GACTI,EAAY,SACZhuB,GAAMwoB,EAAS,IAEfwF,EAAY,OACZhuB,EAAIzO,KAAKqU,OAGS,UAAbyN,EACLoW,GACFzpB,EAAIzO,KAAKqU,KAAOyS,EAEG,SAAfuV,EACFI,EAAY,QACY,WAAfJ,GACTI,EAAY,SACZhuB,GAAMwoB,EAAS,IAEfwF,EAAY,OACZhuB,GAAKwoB,KAGPxoB,EAAIzO,KAAKqU,KAAOioB,EAEG,SAAfD,EACFI,EAAY,OACY,WAAfJ,GACTI,EAAY,SACZhuB,GAAKwoB,EAAS,IAEdwF,EAAY,QACZhuB,EAAIzO,KAAKmU,QAIbsoB,EAAY,QAGP,CAACA,YAAWhuB,IACrB,CAKAmvB,oBACE,GAAI59B,KAAKgI,QAAQyR,MAAMye,OACrB,OAGF,MAAM13B,EAAQR,KAAKQ,MACbshB,EAAW9hB,KAAKgI,QAAQ8Z,SAE9B,MAAiB,SAAbA,GAAoC,UAAbA,EAClB,CAAC5N,IAAK,EAAGG,KAAMrU,KAAKqU,KAAMD,OAAQ5T,EAAMwc,OAAQ7I,MAAOnU,KAAKmU,OAClD,QAAb2N,GAAmC,WAAbA,EACnB,CAAC5N,IAAKlU,KAAKkU,IAAKG,KAAM,EAAGD,OAAQpU,KAAKoU,OAAQD,MAAO3T,EAAMyc,YADlE,CAGJ,CAKA4gB,iBACE,MAAM,IAAChxB,EAAK7E,SAAS,gBAAC81B,GAAgB,KAAEzpB,EAAI,IAAEH,EAAA,MAAK+I,EAAA,OAAOD,GAAUhd,KAChE89B,IACFjxB,EAAIkxB,OACJlxB,EAAImxB,UAAYF,EAChBjxB,EAAIoxB,SAAS5pB,EAAMH,EAAK+I,EAAOD,GAC/BnQ,EAAIqxB,UAER,CAEAvf,qBAAqB9V,GACnB,MAAMgT,EAAO7b,KAAKgI,QAAQ6T,KAC1B,IAAK7b,KAAK62B,eAAiBhb,EAAK6M,QAC9B,OAAO,EAET,MACMhf,EADQ1J,KAAKyZ,MACC0kB,WAAUpqB,GAAKA,EAAElL,QAAUA,IAC/C,OAAIa,GAAS,EACEmS,EAAKyW,WAAWtyB,KAAKoR,WAAW1H,IACjCkyB,UAEP,CACT,CAKAwC,SAASxpB,GACP,MAAMiH,EAAO7b,KAAKgI,QAAQ6T,KACpBhP,EAAM7M,KAAK6M,IACX7K,EAAQhC,KAAKyxB,iBAAmBzxB,KAAKyxB,eAAiBzxB,KAAKu6B,sBAAsB3lB,IACvF,IAAIzS,EAAGsH,EAEP,MAAM40B,EAAWA,CAACC,EAAIC,EAAI9Q,KACnBA,EAAMxQ,OAAUwQ,EAAMppB,QAG3BwI,EAAIkxB,OACJlxB,EAAI+uB,UAAYnO,EAAMxQ,MACtBpQ,EAAI2xB,YAAc/Q,EAAMppB,MACxBwI,EAAI4xB,YAAYhR,EAAMqO,YAAc,IACpCjvB,EAAI6xB,eAAiBjR,EAAMuO,iBAE3BnvB,EAAI8xB,YACJ9xB,EAAI+xB,OAAON,EAAG7vB,EAAG6vB,EAAG5vB,GACpB7B,EAAIgyB,OAAON,EAAG9vB,EAAG8vB,EAAG7vB,GACpB7B,EAAIiyB,SACJjyB,EAAIqxB,UAAS,EAGf,GAAIriB,EAAK6M,QACP,IAAKvmB,EAAI,EAAGsH,EAAOzH,EAAMC,OAAQE,EAAIsH,IAAQtH,EAAG,CAC9C,MAAMD,EAAOF,EAAMG,GAEf0Z,EAAKkjB,iBACPV,EACE,CAAC5vB,EAAGvM,EAAKi5B,GAAIzsB,EAAGxM,EAAKk5B,IACrB,CAAC3sB,EAAGvM,EAAKm5B,GAAI3sB,EAAGxM,EAAKo5B,IACrBp5B,GAIA2Z,EAAKsU,WACPkO,EACE,CAAC5vB,EAAGvM,EAAK64B,IAAKrsB,EAAGxM,EAAK84B,KACtB,CAACvsB,EAAGvM,EAAK+4B,IAAKvsB,EAAGxM,EAAKg5B,KACtB,CACE72B,MAAOnC,EAAKg6B,UACZjf,MAAO/a,EAAKy0B,UACZmF,WAAY55B,EAAKi6B,eACjBH,iBAAkB95B,EAAKk6B,sBAI/B,CAEJ,CAKA4C,aACE,MAAM,MAACx+B,EAAA,IAAOqM,EAAK7E,SAAS,OAAC8Y,EAAM,KAAEjF,IAAS7b,KACxCy6B,EAAa3Z,EAAOwR,WAAWtyB,KAAKoR,cACpCspB,EAAY5Z,EAAO4H,QAAU+R,EAAWxd,MAAQ,EACtD,IAAKyd,EACH,OAEF,MAAMuE,EAAgBpjB,EAAKyW,WAAWtyB,KAAKoR,WAAW,IAAIwqB,UACpDf,EAAc76B,KAAKmyB,aACzB,IAAIgJ,EAAIE,EAAID,EAAIE,EAEZt7B,KAAKsc,gBACP6e,GAAKnB,EAAAA,EAAAA,GAAYx5B,EAAOR,KAAKqU,KAAMqmB,GAAaA,EAAY,EAC5DW,GAAKrB,EAAAA,EAAAA,GAAYx5B,EAAOR,KAAKmU,MAAO8qB,GAAiBA,EAAgB,EACrE7D,EAAKE,EAAKT,IAEVO,GAAKpB,EAAAA,EAAAA,GAAYx5B,EAAOR,KAAKkU,IAAKwmB,GAAaA,EAAY,EAC3DY,GAAKtB,EAAAA,EAAAA,GAAYx5B,EAAOR,KAAKoU,OAAQ6qB,GAAiBA,EAAgB,EACtE9D,EAAKE,EAAKR,GAEZhuB,EAAIkxB,OACJlxB,EAAI+uB,UAAYnB,EAAWxd,MAC3BpQ,EAAI2xB,YAAc/D,EAAWp2B,MAE7BwI,EAAI8xB,YACJ9xB,EAAI+xB,OAAOzD,EAAIC,GACfvuB,EAAIgyB,OAAOxD,EAAIC,GACfzuB,EAAIiyB,SAEJjyB,EAAIqxB,SACN,CAKAgB,WAAWtqB,GAGT,IAFoB5U,KAAKgI,QAAQyR,MAEhBiP,QACf,OAGF,MAAM7b,EAAM7M,KAAK6M,IAEX8H,EAAO3U,KAAK49B,oBACdjpB,IACFwqB,EAAAA,EAAAA,GAAStyB,EAAK8H,GAGhB,MAAM3S,EAAQhC,KAAK8yB,cAAcle,GACjC,IAAK,MAAM1S,KAAQF,EAAO,CACxB,MAAMo9B,EAAoBl9B,EAAK8F,QACzBgxB,EAAW92B,EAAKquB,KAChB3c,EAAQ1R,EAAK0R,MACblF,EAAIxM,EAAKy6B,YACf0C,EAAAA,EAAAA,GAAWxyB,EAAK+G,EAAO,EAAGlF,EAAGsqB,EAAUoG,EACzC,CAEIzqB,IACF2qB,EAAAA,EAAAA,GAAWzyB,EAEf,CAKA0yB,YACE,MAAM,IAAC1yB,EAAK7E,SAAS,SAAC8Z,EAAQ,MAAEuV,EAAK,QAAEluB,IAAYnJ,KAEnD,IAAKq3B,EAAM3O,QACT,OAGF,MAAM6H,GAAOC,EAAAA,EAAAA,IAAO6G,EAAM9G,MACpBzJ,GAAUU,EAAAA,EAAAA,GAAU6P,EAAMvQ,SAC1B8J,EAAQyG,EAAMzG,MACpB,IAAIhV,EAAS2U,EAAKG,WAAa,EAEd,WAAb5O,GAAsC,WAAbA,IAAyB7a,EAAAA,EAAAA,GAAS6a,IAC7DlG,GAAUkL,EAAQ1S,QACdzM,EAAAA,EAAAA,GAAQ0vB,EAAM5G,QAChB7U,GAAU2U,EAAKG,YAAc2G,EAAM5G,KAAKxuB,OAAS,KAGnD2Z,GAAUkL,EAAQ5S,IAGpB,MAAM,OAACsrB,EAAA,OAAQC,EAAA,SAAQxO,EAAQ,SAAEuL,GAh8CrC,SAAmBxzB,EAAO4S,EAAQkG,EAAU8O,GAC1C,MAAM,IAAC1c,EAAG,KAAEG,EAAI,OAAED,EAAM,MAAED,EAAK,MAAE3T,GAASwI,GACpC,UAAC4L,EAAA,OAAW3I,GAAUzL,EAC5B,IACIywB,EAAUuO,EAAQC,EADlBjD,EAAW,EAEf,MAAMxf,EAAS5I,EAASF,EAClB+I,EAAQ9I,EAAQE,EAEtB,GAAIrL,EAAMsT,eAAgB,CAGxB,GAFAkjB,GAASE,EAAAA,EAAAA,IAAe9O,EAAOvc,EAAMF,IAEjClN,EAAAA,EAAAA,GAAS6a,GAAW,CACtB,MAAMyZ,EAAiBp0B,OAAOC,KAAK0a,GAAU,GACvCjZ,EAAQiZ,EAASyZ,GACvBkE,EAASxzB,EAAOsvB,GAAgB/hB,iBAAiB3Q,GAASmU,EAASpB,OAEnE6jB,EADsB,WAAb3d,GACClN,EAAUR,OAASQ,EAAUV,KAAO,EAAI8I,EAASpB,EAElDwT,GAAepmB,EAAO8Y,EAAUlG,GAE3CqV,EAAW9c,EAAQE,MACd,CACL,IAAIpN,EAAAA,EAAAA,GAAS6a,GAAW,CACtB,MAAMyZ,EAAiBp0B,OAAOC,KAAK0a,GAAU,GACvCjZ,EAAQiZ,EAASyZ,GACvBiE,EAASvzB,EAAOsvB,GAAgB/hB,iBAAiB3Q,GAASoU,EAAQrB,OAElE4jB,EADsB,WAAb1d,GACClN,EAAUP,KAAOO,EAAUT,OAAS,EAAI8I,EAAQrB,EAEjDwT,GAAepmB,EAAO8Y,EAAUlG,GAE3C6jB,GAASC,EAAAA,EAAAA,IAAe9O,EAAOxc,EAAQF,GACvCsoB,EAAwB,SAAb1a,GAAuB6d,EAAAA,EAAUA,EAAAA,EAE9C,MAAO,CAACH,SAAQC,SAAQxO,WAAUuL,WACpC,CA65CiDoD,CAAU5/B,KAAM4b,EAAQkG,EAAU8O,IAE/EyO,EAAAA,EAAAA,GAAWxyB,EAAKwqB,EAAM5G,KAAM,EAAG,EAAGF,EAAM,CACtClsB,MAAOgzB,EAAMhzB,MACb4sB,WACAuL,WACAC,UAAW9L,GAAWC,EAAO9O,EAAU3Y,GACvCyzB,aAAc,SACde,YAAa,CAAC6B,EAAQC,IAE1B,CAEAr9B,KAAKwS,GACE5U,KAAK62B,eAIV72B,KAAK69B,iBACL79B,KAAKo+B,SAASxpB,GACd5U,KAAKg/B,aACLh/B,KAAKu/B,YACLv/B,KAAKk/B,WAAWtqB,GAClB,CAMAuS,UACE,MAAMje,EAAOlJ,KAAKgI,QACZ63B,EAAK32B,EAAKuQ,OAASvQ,EAAKuQ,MAAM2N,GAAK,EACnC0Y,GAAKhxB,EAAAA,EAAAA,GAAe5F,EAAK2S,MAAQ3S,EAAK2S,KAAKuL,GAAI,GAC/C2Y,GAAKjxB,EAAAA,EAAAA,GAAe5F,EAAK4X,QAAU5X,EAAK4X,OAAOsG,EAAG,GAExD,OAAKpnB,KAAK62B,cAAgB72B,KAAKoC,OAAS2uB,GAAMiP,UAAU59B,KAUjD,CAAC,CACNglB,EAAG0Y,EACH19B,KAAOwS,IACL5U,KAAK69B,iBACL79B,KAAKo+B,SAASxpB,GACd5U,KAAKu/B,WAAW,GAEjB,CACDnY,EAAG2Y,EACH39B,KAAMA,KACJpC,KAAKg/B,YAAY,GAElB,CACD5X,EAAGyY,EACHz9B,KAAOwS,IACL5U,KAAKk/B,WAAWtqB,EAAA,IAvBX,CAAC,CACNwS,EAAGyY,EACHz9B,KAAOwS,IACL5U,KAAKoC,KAAKwS,EAAA,GAuBlB,CAOA7J,wBAAwBpK,GACtB,MAAM+xB,EAAQ1yB,KAAKQ,MAAMwhB,+BACnBie,EAASjgC,KAAKuL,KAAO,SACrBmkB,EAAS,GACf,IAAIvtB,EAAGsH,EAEP,IAAKtH,EAAI,EAAGsH,EAAOipB,EAAMzwB,OAAQE,EAAIsH,IAAQtH,EAAG,CAC9C,MAAMkI,EAAOqoB,EAAMvwB,GACfkI,EAAK41B,KAAYjgC,KAAK2L,IAAQhL,GAAQ0J,EAAK1J,OAASA,GACtD+uB,EAAOxsB,KAAKmH,EAEhB,CACA,OAAOqlB,CACT,CAOA2J,wBAAwB3vB,GACtB,MAAMR,EAAOlJ,KAAKgI,QAAQyR,MAAM6Y,WAAWtyB,KAAKoR,WAAW1H,IAC3D,OAAO8mB,EAAAA,EAAAA,IAAOtnB,EAAKqnB,KACrB,CAKA2P,aACE,MAAMC,EAAWngC,KAAKq5B,wBAAwB,GAAG3I,WACjD,OAAQ1wB,KAAKsc,eAAiBtc,KAAKid,MAAQjd,KAAKgd,QAAUmjB,CAC5D,EC/pDa,MAAMC,GACnBrgC,YAAYY,EAAM0/B,EAAOC,GACvBtgC,KAAKW,KAAOA,EACZX,KAAKqgC,MAAQA,EACbrgC,KAAKsgC,SAAWA,EAChBtgC,KAAKgC,MAAQmF,OAAOo5B,OAAO,KAC7B,CAEAC,UAAU7/B,GACR,OAAOwG,OAAO64B,UAAUS,cAAch/B,KAAKzB,KAAKW,KAAKq/B,UAAWr/B,EAAKq/B,UACvE,CAMAU,SAASx+B,GACP,MAAMy+B,EAAQx5B,OAAOy5B,eAAe1+B,GACpC,IAAI2+B,GAyFR,SAA2BF,GACzB,MAAO,OAAQA,GAAS,aAAcA,CACxC,EAzFQG,CAAkBH,KAEpBE,EAAc7gC,KAAK0gC,SAASC,IAG9B,MAAM3+B,EAAQhC,KAAKgC,MACb2J,EAAKzJ,EAAKyJ,GACV00B,EAAQrgC,KAAKqgC,MAAQ,IAAM10B,EAEjC,IAAKA,EACH,MAAM,IAAIo1B,MAAM,2BAA6B7+B,GAG/C,OAAIyJ,KAAM3J,IAKVA,EAAM2J,GAAMzJ,EAsChB,SAA0BA,EAAMm+B,EAAOQ,GAErC,MAAMG,GAAeC,EAAAA,EAAAA,IAAM95B,OAAOo5B,OAAO,MAAO,CAC9CM,EAAcx5B,EAAAA,EAAS1E,IAAIk+B,GAAe,CAAC,EAC3Cx5B,EAAAA,EAAS1E,IAAI09B,GACbn+B,EAAKmF,WAGPA,EAAAA,EAASvE,IAAIu9B,EAAOW,GAEhB9+B,EAAKg/B,eASX,SAAuBb,EAAOc,GAC5Bh6B,OAAOC,KAAK+5B,GAAQngC,SAAQogC,IAC1B,MAAMC,EAAgBD,EAASE,MAAM,KAC/BC,EAAaF,EAAc7+B,MAC3Bg/B,EAAc,CAACnB,GAAOtnB,OAAOsoB,GAAeI,KAAK,KACjDC,EAAQP,EAAOC,GAAUE,MAAM,KAC/BK,EAAaD,EAAMl/B,MACnBo/B,EAAcF,EAAMD,KAAK,KAC/Bp6B,EAAAA,EAASw6B,MAAML,EAAaD,EAAYK,EAAaD,EAAA,GAEzD,CAlBIG,CAAczB,EAAOn+B,EAAKg/B,eAGxBh/B,EAAK6/B,aACP16B,EAAAA,EAAS26B,SAAS3B,EAAOn+B,EAAK6/B,YAElC,CAtDIE,CAAiB//B,EAAMm+B,EAAOQ,GAC1B7gC,KAAKsgC,UACPj5B,EAAAA,EAASi5B,SAASp+B,EAAKyJ,GAAIzJ,EAAKggC,YANzB7B,CAUX,CAMA19B,IAAIgJ,GACF,OAAO3L,KAAKgC,MAAM2J,EACpB,CAKAw2B,WAAWjgC,GACT,MAAMF,EAAQhC,KAAKgC,MACb2J,EAAKzJ,EAAKyJ,GACV00B,EAAQrgC,KAAKqgC,MAEf10B,KAAM3J,UACDA,EAAM2J,GAGX00B,GAAS10B,KAAMtE,EAAAA,EAASg5B,YACnBh5B,EAAAA,EAASg5B,GAAO10B,GACnB3L,KAAKsgC,iBACA4B,EAAAA,GAAUv2B,GAGvB,ECtEK,MAAMy2B,GACXriC,cACEC,KAAKqiC,YAAc,IAAIjC,GAAc1zB,EAAmB,YAAY,GACpE1M,KAAK0U,SAAW,IAAI0rB,GAAc3R,GAAS,YAC3CzuB,KAAKsiC,QAAU,IAAIlC,GAAcj5B,OAAQ,WACzCnH,KAAKiM,OAAS,IAAIm0B,GAAcrP,GAAO,UAGvC/wB,KAAKuiC,iBAAmB,CAACviC,KAAKqiC,YAAariC,KAAKiM,OAAQjM,KAAK0U,SAC/D,CAKAvR,OAAO+U,GACLlY,KAAKwiC,MAAM,WAAYtqB,EACzB,CAEAtU,UAAUsU,GACRlY,KAAKwiC,MAAM,aAActqB,EAC3B,CAKAuqB,kBAAkBvqB,GAChBlY,KAAKwiC,MAAM,WAAYtqB,EAAMlY,KAAKqiC,YACpC,CAKAr0B,eAAekK,GACblY,KAAKwiC,MAAM,WAAYtqB,EAAMlY,KAAK0U,SACpC,CAKAguB,cAAcxqB,GACZlY,KAAKwiC,MAAM,WAAYtqB,EAAMlY,KAAKsiC,QACpC,CAKAK,aAAazqB,GACXlY,KAAKwiC,MAAM,WAAYtqB,EAAMlY,KAAKiM,OACpC,CAMA22B,cAAcj3B,GACZ,OAAO3L,KAAK6iC,KAAKl3B,EAAI3L,KAAKqiC,YAAa,aACzC,CAMAS,WAAWn3B,GACT,OAAO3L,KAAK6iC,KAAKl3B,EAAI3L,KAAK0U,SAAU,UACtC,CAMAquB,UAAUp3B,GACR,OAAO3L,KAAK6iC,KAAKl3B,EAAI3L,KAAKsiC,QAAS,SACrC,CAMAU,SAASr3B,GACP,OAAO3L,KAAK6iC,KAAKl3B,EAAI3L,KAAKiM,OAAQ,QACpC,CAKAg3B,qBAAqB/qB,GACnBlY,KAAKwiC,MAAM,aAActqB,EAAMlY,KAAKqiC,YACtC,CAKAa,kBAAkBhrB,GAChBlY,KAAKwiC,MAAM,aAActqB,EAAMlY,KAAK0U,SACtC,CAKAyuB,iBAAiBjrB,GACflY,KAAKwiC,MAAM,aAActqB,EAAMlY,KAAKsiC,QACtC,CAKAc,gBAAgBlrB,GACdlY,KAAKwiC,MAAM,aAActqB,EAAMlY,KAAKiM,OACtC,CAKAu2B,MAAM77B,EAAQuR,EAAMmrB,GAClB,IAAInrB,GAAMlX,SAAQsiC,IAChB,MAAMC,EAAMF,GAAiBrjC,KAAKwjC,oBAAoBF,GAClDD,GAAiBE,EAAI/C,UAAU8C,IAASC,IAAQvjC,KAAKsiC,SAAWgB,EAAI33B,GACtE3L,KAAKyjC,MAAM98B,EAAQ48B,EAAKD,IAMxBhb,EAAAA,EAAAA,GAAKgb,GAAKphC,IAOR,MAAMwhC,EAAUL,GAAiBrjC,KAAKwjC,oBAAoBthC,GAC1DlC,KAAKyjC,MAAM98B,EAAQ+8B,EAASxhC,EAAA,MAIpC,CAKAuhC,MAAM98B,EAAQg9B,EAAUC,GACtB,MAAMC,GAAcC,EAAAA,EAAAA,IAAYn9B,IAChCssB,EAAAA,EAAAA,GAAK2Q,EAAU,SAAWC,GAAc,GAAID,GAC5CD,EAASh9B,GAAQi9B,IACjB3Q,EAAAA,EAAAA,GAAK2Q,EAAU,QAAUC,GAAc,GAAID,EAC7C,CAKAJ,oBAAoB7iC,GAClB,IAAK,IAAIwB,EAAI,EAAGA,EAAInC,KAAKuiC,iBAAiBtgC,OAAQE,IAAK,CACrD,MAAMohC,EAAMvjC,KAAKuiC,iBAAiBpgC,GAClC,GAAIohC,EAAI/C,UAAU7/B,GAChB,OAAO4iC,CAEX,CAEA,OAAOvjC,KAAKsiC,OACd,CAKAO,KAAKl3B,EAAI03B,EAAe1iC,GACtB,MAAMuB,EAAOmhC,EAAc1gC,IAAIgJ,GAC/B,QAAarL,IAAT4B,EACF,MAAM,IAAI6+B,MAAM,IAAMp1B,EAAK,yBAA2BhL,EAAO,KAE/D,OAAOuB,CACT,EAKF,IAAAyhC,GAA+B,IAAIvB,GCtKpB,MAAM2B,GACnBhkC,cACEC,KAAKgkC,MAAQ,EACf,CAYAC,OAAOzjC,EAAO0jC,EAAMhsB,EAAMhM,GACX,eAATg4B,IACFlkC,KAAKgkC,MAAQhkC,KAAKmkC,mBAAmB3jC,GAAO,GAC5CR,KAAKO,QAAQP,KAAKgkC,MAAOxjC,EAAO,YAGlC,MAAMuhC,EAAc71B,EAASlM,KAAKokC,aAAa5jC,GAAO0L,OAAOA,GAAUlM,KAAKokC,aAAa5jC,GACnFkvB,EAAS1vB,KAAKO,QAAQwhC,EAAavhC,EAAO0jC,EAAMhsB,GAMtD,MAJa,iBAATgsB,IACFlkC,KAAKO,QAAQwhC,EAAavhC,EAAO,QACjCR,KAAKO,QAAQP,KAAKgkC,MAAOxjC,EAAO,cAE3BkvB,CACT,CAKAnvB,QAAQwhC,EAAavhC,EAAO0jC,EAAMhsB,GAChCA,EAAOA,GAAQ,CAAC,EAChB,IAAK,MAAMmsB,KAActC,EAAa,CACpC,MAAMuC,EAASD,EAAWC,OACpB39B,EAAS29B,EAAOJ,GAChB9e,EAAS,CAAC5kB,EAAO0X,EAAMmsB,EAAWr8B,SACxC,IAA6C,KAAzCirB,EAAAA,EAAAA,GAAatsB,EAAQye,EAAQkf,IAAqBpsB,EAAKqsB,WACzD,OAAO,CAEX,CAEA,OAAO,CACT,CAEAC,cAMO9nB,EAAAA,EAAAA,GAAc1c,KAAK4Y,UACtB5Y,KAAKykC,UAAYzkC,KAAK4Y,OACtB5Y,KAAK4Y,YAAStY,EAElB,CAMA8jC,aAAa5jC,GACX,GAAIR,KAAK4Y,OACP,OAAO5Y,KAAK4Y,OAGd,MAAMmpB,EAAc/hC,KAAK4Y,OAAS5Y,KAAKmkC,mBAAmB3jC,GAI1D,OAFAR,KAAK0kC,oBAAoBlkC,GAElBuhC,CACT,CAEAoC,mBAAmB3jC,EAAOgI,GACxB,MAAM3B,EAASrG,GAASA,EAAMqG,OACxBmB,GAAU8G,EAAAA,EAAAA,GAAejI,EAAOmB,SAAWnB,EAAOmB,QAAQs6B,QAAS,CAAC,GACpEA,EAqBV,SAAoBz7B,GAClB,MAAM89B,EAAW,CAAC,EACZrC,EAAU,GACVl7B,EAAOD,OAAOC,KAAKu8B,GAASrB,QAAQtgC,OAC1C,IAAK,IAAIG,EAAI,EAAGA,EAAIiF,EAAKnF,OAAQE,IAC/BmgC,EAAQp/B,KAAKygC,GAASZ,UAAU37B,EAAKjF,KAGvC,MAAMyiC,EAAQ/9B,EAAOy7B,SAAW,GAChC,IAAK,IAAIngC,EAAI,EAAGA,EAAIyiC,EAAM3iC,OAAQE,IAAK,CACrC,MAAMmiC,EAASM,EAAMziC,IAEY,IAA7BmgC,EAAQ/kB,QAAQ+mB,KAClBhC,EAAQp/B,KAAKohC,GACbK,EAASL,EAAO34B,KAAM,EAE1B,CAEA,MAAO,CAAC22B,UAASqC,WACnB,CAxCoBE,CAAWh+B,GAE3B,OAAmB,IAAZmB,GAAsBQ,EAkDjC,SAA2BhI,GAAO,QAAC8hC,EAAO,SAAEqC,GAAW38B,EAASQ,GAC9D,MAAMknB,EAAS,GACTxa,EAAU1U,EAAM4Q,aAEtB,IAAK,MAAMkzB,KAAUhC,EAAS,CAC5B,MAAM32B,EAAK24B,EAAO34B,GACZzC,EAAO47B,GAAQ98B,EAAQ2D,GAAKnD,GACrB,OAATU,GAGJwmB,EAAOxsB,KAAK,CACVohC,SACAt8B,QAAS+8B,GAAWvkC,EAAMqG,OAAQ,CAACy9B,SAAQM,MAAOD,EAASh5B,IAAMzC,EAAMgM,IAE3E,CAEA,OAAOwa,CACT,CAnE4CsV,CAAkBxkC,EAAO8hC,EAASt6B,EAASQ,GAAhD,EACrC,CAMAk8B,oBAAoBlkC,GAClB,MAAMykC,EAAsBjlC,KAAKykC,WAAa,GACxC1C,EAAc/hC,KAAK4Y,OACnByc,EAAOA,CAACnc,EAAGlF,IAAMkF,EAAEhN,QAAOuC,IAAMuF,EAAEkxB,MAAKx2B,GAAKD,EAAE61B,OAAO34B,KAAO+C,EAAE41B,OAAO34B,OAC3E3L,KAAKO,QAAQ80B,EAAK4P,EAAqBlD,GAAcvhC,EAAO,QAC5DR,KAAKO,QAAQ80B,EAAK0M,EAAakD,GAAsBzkC,EAAO,QAC9D,EA2BF,SAASskC,GAAQ98B,EAASQ,GACxB,OAAKA,IAAmB,IAAZR,GAGI,IAAZA,EACK,CAAC,EAEHA,EALE,IAMX,CAqBA,SAAS+8B,GAAWl+B,GAAQ,OAACy9B,EAAM,MAAEM,GAAQ17B,EAAMgM,GACjD,MAAM9N,EAAOP,EAAOs+B,gBAAgBb,GAC9BrzB,EAASpK,EAAOqK,gBAAgBhI,EAAM9B,GAK5C,OAJIw9B,GAASN,EAAOj9B,UAElB4J,EAAO/N,KAAKohC,EAAOj9B,UAEdR,EAAOsK,eAAeF,EAAQiE,EAAS,CAAC,IAAK,CAElDkwB,YAAY,EACZC,WAAW,EACXC,SAAS,GAEb,CClLO,SAASC,GAAa5kC,EAAMqH,GACjC,MAAMw9B,EAAkBn+B,EAAAA,EAASwI,SAASlP,IAAS,CAAC,EAEpD,QADwBqH,EAAQ6H,UAAY,CAAC,GAAGlP,IAAS,CAAC,GACpCwO,WAAanH,EAAQmH,WAAaq2B,EAAgBr2B,WAAa,GACvF,CAgBA,SAASs2B,GAAc95B,GACrB,GAAW,MAAPA,GAAqB,MAAPA,GAAqB,MAAPA,EAC9B,OAAOA,CAEX,CAWO,SAAS+5B,GAAc/5B,KAAOg6B,GACnC,GAAIF,GAAc95B,GAChB,OAAOA,EAET,IAAK,MAAMzC,KAAQy8B,EAAc,CAC/B,MAAMp6B,EAAOrC,EAAKqC,OAbH,SADOuW,EAeA5Y,EAAK4Y,WAdU,WAAbA,EACjB,IAEQ,SAAbA,GAAoC,UAAbA,EAClB,SADT,IAYOnW,EAAG1J,OAAS,GAAKwjC,GAAc95B,EAAG,GAAGi6B,eAC1C,GAAIr6B,EACF,OAAOA,CAEX,CApBF,IAA0BuW,EAqBxB,MAAM,IAAIif,MAAO,6BAA4Bp1B,uDAC/C,CAEA,SAASk6B,GAAmBl6B,EAAIJ,EAAM+C,GACpC,GAAIA,EAAQ/C,EAAO,YAAcI,EAC/B,MAAO,CAACJ,OAEZ,CAwDA,SAASu6B,GAAYj/B,GACnB,MAAMmB,EAAUnB,EAAOmB,UAAYnB,EAAOmB,QAAU,CAAC,GAErDA,EAAQs6B,SAAUxzB,EAAAA,EAAAA,GAAe9G,EAAQs6B,QAAS,CAAC,GACnDt6B,EAAQiE,OAhDV,SAA0BpF,EAAQmB,GAChC,MAAM+9B,EAAgB7D,EAAAA,GAAUr7B,EAAOlG,OAAS,CAACsL,OAAQ,CAAC,GACpD+5B,EAAeh+B,EAAQiE,QAAU,CAAC,EAClCg6B,EAAiBV,GAAa1+B,EAAOlG,KAAMqH,GAC3CiE,EAAS9E,OAAOo5B,OAAO,MAqC7B,OAlCAp5B,OAAOC,KAAK4+B,GAAchlC,SAAQ2K,IAChC,MAAMu6B,EAAYF,EAAar6B,GAC/B,KAAK1E,EAAAA,EAAAA,GAASi/B,GACZ,OAAO/3B,QAAQg4B,MAAO,0CAAyCx6B,KAEjE,GAAIu6B,EAAUE,OACZ,OAAOj4B,QAAQC,KAAM,kDAAiDzC,KAExE,MAAMJ,EAAOm6B,GAAc/5B,EAAIu6B,EAzBnC,SAAkCv6B,EAAI9E,GACpC,GAAIA,EAAO+I,MAAQ/I,EAAO+I,KAAKC,SAAU,CACvC,MAAMw2B,EAAUx/B,EAAO+I,KAAKC,SAAS3D,QAAQo6B,GAAMA,EAAEz3B,UAAYlD,GAAM26B,EAAEt3B,UAAYrD,IACrF,GAAI06B,EAAQpkC,OACV,OAAO4jC,GAAmBl6B,EAAI,IAAK06B,EAAQ,KAAOR,GAAmBl6B,EAAI,IAAK06B,EAAQ,IAG1F,MAAO,CAAC,CACV,CAiB8CE,CAAyB56B,EAAI9E,GAASQ,EAAAA,EAAS4E,OAAOi6B,EAAUvlC,OACpG6lC,EAlEV,SAAmCj7B,EAAM4D,GACvC,OAAO5D,IAAS4D,EAAY,UAAY,SAC1C,CAgEsBs3B,CAA0Bl7B,EAAM06B,GAC5CS,EAAsBX,EAAc95B,QAAU,CAAC,EACrDA,EAAON,IAAMg7B,EAAAA,EAAAA,IAAQx/B,OAAOo5B,OAAO,MAAO,CAAC,CAACh1B,QAAO26B,EAAWQ,EAAoBn7B,GAAOm7B,EAAoBF,IAAY,IAI3H3/B,EAAO+I,KAAKC,SAAS7O,SAAQsN,IAC3B,MAAM3N,EAAO2N,EAAQ3N,MAAQkG,EAAOlG,KAC9BwO,EAAYb,EAAQa,WAAao2B,GAAa5kC,EAAMqH,GAEpD0+B,GADkBxE,EAAAA,GAAUvhC,IAAS,CAAC,GACAsL,QAAU,CAAC,EACvD9E,OAAOC,KAAKs/B,GAAqB1lC,SAAQ4lC,IACvC,MAAMr7B,EAxFZ,SAAmCI,EAAIwD,GACrC,IAAI5D,EAAOI,EAMX,MALW,YAAPA,EACFJ,EAAO4D,EACS,YAAPxD,IACTJ,EAAqB,MAAd4D,EAAoB,IAAM,KAE5B5D,CACT,CAgFmBs7B,CAA0BD,EAAWz3B,GAC5CxD,EAAK2C,EAAQ/C,EAAO,WAAaA,EACvCU,EAAON,GAAMM,EAAON,IAAOxE,OAAOo5B,OAAO,OACzCoG,EAAAA,EAAAA,IAAQ16B,EAAON,GAAK,CAAC,CAACJ,QAAOy6B,EAAar6B,GAAK+6B,EAAoBE,IAAY,GAC/E,IAIJz/B,OAAOC,KAAK6E,GAAQjL,SAAQyG,IAC1B,MAAMuB,EAAQiD,EAAOxE,IACrBk/B,EAAAA,EAAAA,IAAQ39B,EAAO,CAAC3B,EAAAA,EAAS4E,OAAOjD,EAAMrI,MAAO0G,EAAAA,EAAS2B,OAAO,IAGxDiD,CACT,CAMmB66B,CAAiBjgC,EAAQmB,EAC5C,CAEA,SAAS++B,GAASn3B,GAIhB,OAHAA,EAAOA,GAAQ,CAAC,GACXC,SAAWD,EAAKC,UAAY,GACjCD,EAAKmC,OAASnC,EAAKmC,QAAU,GACtBnC,CACT,CAWA,MAAMo3B,GAAW,IAAI7mC,IACf8mC,GAAa,IAAIC,IAEvB,SAASC,GAAWvxB,EAAUwxB,GAC5B,IAAIhgC,EAAO4/B,GAASrkC,IAAIiT,GAMxB,OALKxO,IACHA,EAAOggC,IACPJ,GAASlkC,IAAI8S,EAAUxO,GACvB6/B,GAAW9jC,IAAIiE,IAEVA,CACT,CAEA,MAAMigC,GAAaA,CAACvkC,EAAKoZ,EAAKzU,KAC5B,MAAMyB,GAAOkJ,EAAAA,EAAAA,GAAiB8J,EAAKzU,QACtBnH,IAAT4I,GACFpG,EAAIK,IAAI+F,IAIG,MAAMo+B,GACnBvnC,YAAY8G,GACV7G,KAAKunC,QA/BT,SAAoB1gC,GAMlB,OALAA,EAASA,GAAU,CAAC,GACb+I,KAAOm3B,GAASlgC,EAAO+I,MAE9Bk2B,GAAYj/B,GAELA,CACT,CAwBmB2gC,CAAW3gC,GAC1B7G,KAAKynC,YAAc,IAAItnC,IACvBH,KAAK0nC,eAAiB,IAAIvnC,GAC5B,CAEIwnC,eACF,OAAO3nC,KAAKunC,QAAQI,QACtB,CAEIhnC,WACF,OAAOX,KAAKunC,QAAQ5mC,IACtB,CAEIA,SAAKA,GACPX,KAAKunC,QAAQ5mC,KAAOA,CACtB,CAEIiP,WACF,OAAO5P,KAAKunC,QAAQ33B,IACtB,CAEIA,SAAKA,GACP5P,KAAKunC,QAAQ33B,KAAOm3B,GAASn3B,EAC/B,CAEI5H,cACF,OAAOhI,KAAKunC,QAAQv/B,OACtB,CAEIA,YAAQA,GACVhI,KAAKunC,QAAQv/B,QAAUA,CACzB,CAEIs6B,cACF,OAAOtiC,KAAKunC,QAAQjF,OACtB,CAEAp8B,SACE,MAAMW,EAAS7G,KAAKunC,QACpBvnC,KAAK4nC,aACL9B,GAAYj/B,EACd,CAEA+gC,aACE5nC,KAAKynC,YAAYI,QACjB7nC,KAAK0nC,eAAeG,OACtB,CAQA72B,iBAAiB82B,GACf,OAAOX,GAAWW,GAChB,IAAM,CAAC,CACJ,YAAWA,IACZ,MAEN,CASAxxB,0BAA0BwxB,EAAazxB,GACrC,OAAO8wB,GAAY,GAAEW,gBAA0BzxB,KAC7C,IAAM,CACJ,CACG,YAAWyxB,iBAA2BzxB,IACtC,eAAcA,KAGjB,CACG,YAAWyxB,IACZ,MAGR,CAUA/xB,wBAAwB+xB,EAAapyB,GACnC,OAAOyxB,GAAY,GAAEW,KAAepyB,KAClC,IAAM,CAAC,CACJ,YAAWoyB,cAAwBpyB,IACnC,YAAWoyB,IACX,YAAWpyB,IACZ,MAEN,CAOAyvB,gBAAgBb,GACd,MAAM34B,EAAK24B,EAAO34B,GAElB,OAAOw7B,GAAY,GADNnnC,KAAKW,eACkBgL,KAClC,IAAM,CAAC,CACJ,WAAUA,OACR24B,EAAOyD,wBAA0B,MAE1C,CAKAC,cAAcC,EAAWC,GACvB,MAAMT,EAAcznC,KAAKynC,YACzB,IAAI9xB,EAAQ8xB,EAAY9kC,IAAIslC,GAK5B,OAJKtyB,IAASuyB,IACZvyB,EAAQ,IAAIxV,IACZsnC,EAAY3kC,IAAImlC,EAAWtyB,IAEtBA,CACT,CAQAzE,gBAAgB+2B,EAAWE,EAAUD,GACnC,MAAM,QAAClgC,EAAO,KAAErH,GAAQX,KAClB2V,EAAQ3V,KAAKgoC,cAAcC,EAAWC,GACtC17B,EAASmJ,EAAMhT,IAAIwlC,GACzB,GAAI37B,EACF,OAAOA,EAGT,MAAMyE,EAAS,IAAIi2B,IAEnBiB,EAASnnC,SAAQoG,IACX6gC,IACFh3B,EAAO9N,IAAI8kC,GACX7gC,EAAKpG,SAAQyG,GAAO4/B,GAAWp2B,EAAQg3B,EAAWxgC,MAEpDL,EAAKpG,SAAQyG,GAAO4/B,GAAWp2B,EAAQjJ,EAASP,KAChDL,EAAKpG,SAAQyG,GAAO4/B,GAAWp2B,EAAQixB,EAAAA,GAAUvhC,IAAS,CAAC,EAAG8G,KAC9DL,EAAKpG,SAAQyG,GAAO4/B,GAAWp2B,EAAQ5J,EAAAA,EAAUI,KACjDL,EAAKpG,SAAQyG,GAAO4/B,GAAWp2B,EAAQ8wB,EAAAA,GAAat6B,IAAA,IAGtD,MAAM+c,EAAQlU,MAAMpM,KAAK+M,GAOzB,OANqB,IAAjBuT,EAAMviB,QACRuiB,EAAMthB,KAAKiE,OAAOo5B,OAAO,OAEvB0G,GAAW7jC,IAAI+kC,IACjBxyB,EAAM7S,IAAIqlC,EAAU3jB,GAEfA,CACT,CAMA4jB,oBACE,MAAM,QAACpgC,EAAO,KAAErH,GAAQX,KAExB,MAAO,CACLgI,EACAk6B,EAAAA,GAAUvhC,IAAS,CAAC,EACpB0G,EAAAA,EAASwI,SAASlP,IAAS,CAAC,EAC5B,CAACA,QACD0G,EAAAA,EACA06B,EAAAA,GAEJ,CASA7rB,oBAAoBjF,EAAQgF,EAAOf,EAASc,EAAW,CAAC,KACtD,MAAM0Z,EAAS,CAACznB,SAAS,IACnB,SAACogC,EAAQ,YAAEC,GAAeC,GAAYvoC,KAAK0nC,eAAgBz2B,EAAQ+E,GACzE,IAAIhO,EAAUqgC,EACd,GAkDJ,SAAqBjb,EAAOnX,GAC1B,MAAM,aAACuyB,EAAY,YAAEC,IAAerE,EAAAA,EAAAA,IAAahX,GAEjD,IAAK,MAAMroB,KAAQkR,EAAO,CACxB,MAAMmvB,EAAaoD,EAAazjC,GAC1BsgC,EAAYoD,EAAY1jC,GACxB8D,GAASw8B,GAAaD,IAAehY,EAAMroB,GACjD,GAAKqgC,KAAesD,EAAAA,EAAAA,IAAW7/B,IAAU8/B,GAAY9/B,KAC/Cw8B,IAAa19B,EAAAA,EAAAA,GAAQkB,GACzB,OAAO,CAEX,CACA,OAAO,CACT,CA/DQ+/B,CAAYP,EAAUpyB,GAAQ,CAChCyZ,EAAOznB,SAAU,EACjBiN,GAAUwzB,EAAAA,EAAAA,IAAWxzB,GAAWA,IAAYA,EAE5C,MAAM2zB,EAAc7oC,KAAKmR,eAAeF,EAAQiE,EAASozB,GACzDtgC,GAAU8gC,EAAAA,EAAAA,IAAeT,EAAUnzB,EAAS2zB,GAG9C,IAAK,MAAM9jC,KAAQkR,EACjByZ,EAAO3qB,GAAQiD,EAAQjD,GAEzB,OAAO2qB,CACT,CAQAve,eAAeF,EAAQiE,EAASc,EAAW,CAAC,IAAK+yB,GAC/C,MAAM,SAACV,GAAYE,GAAYvoC,KAAK0nC,eAAgBz2B,EAAQ+E,GAC5D,OAAO/O,EAAAA,EAAAA,GAASiO,IACZ4zB,EAAAA,EAAAA,IAAeT,EAAUnzB,OAAS5U,EAAWyoC,GAC7CV,CACN,EAGF,SAASE,GAAYS,EAAe/3B,EAAQ+E,GAC1C,IAAIL,EAAQqzB,EAAcrmC,IAAIsO,GACzB0E,IACHA,EAAQ,IAAIxV,IACZ6oC,EAAclmC,IAAImO,EAAQ0E,IAE5B,MAAMC,EAAWI,EAASyrB,OAC1B,IAAIj1B,EAASmJ,EAAMhT,IAAIiT,GASvB,OARKpJ,IAEHA,EAAS,CACP67B,UAFeY,EAAAA,EAAAA,IAAgBh4B,EAAQ+E,GAGvCsyB,YAAatyB,EAAS9J,QAAOg9B,IAAMA,EAAEtD,cAAc/c,SAAS,YAE9DlT,EAAM7S,IAAI8S,EAAUpJ,IAEfA,CACT,CAEA,MAAMm8B,GAAc9/B,IAAS5B,EAAAA,EAAAA,GAAS4B,IACjC1B,OAAOK,oBAAoBqB,GAAOxF,QAAO,CAACC,EAAKmE,IAAQnE,IAAOolC,EAAAA,EAAAA,IAAW7/B,EAAMpB,MAAO,GC9XrF0hC,GAAkB,CAAC,MAAO,SAAU,OAAQ,QAAS,aAC3D,SAASC,GAAqBtnB,EAAUvW,GACtC,MAAoB,QAAbuW,GAAmC,WAAbA,IAAiE,IAAvCqnB,GAAgB5rB,QAAQuE,IAA6B,MAATvW,CACrG,CAEA,SAAS89B,GAAcC,EAAIC,GACzB,OAAO,SAASrwB,EAAGlF,GACjB,OAAOkF,EAAEowB,KAAQt1B,EAAEs1B,GACfpwB,EAAEqwB,GAAMv1B,EAAEu1B,GACVrwB,EAAEowB,GAAMt1B,EAAEs1B,EAChB,CACF,CAEA,SAASE,GAAqBt0B,GAC5B,MAAM1U,EAAQ0U,EAAQ1U,MAChB0G,EAAmB1G,EAAMwH,QAAQV,UAEvC9G,EAAM41B,cAAc,gBACpBnD,EAAAA,EAAAA,GAAa/rB,GAAoBA,EAAiBuiC,WAAY,CAACv0B,GAAU1U,EAC3E,CAEA,SAASkpC,GAAoBx0B,GAC3B,MAAM1U,EAAQ0U,EAAQ1U,MAChB0G,EAAmB1G,EAAMwH,QAAQV,WACvC2rB,EAAAA,EAAAA,GAAa/rB,GAAoBA,EAAiByiC,WAAY,CAACz0B,GAAU1U,EAC3E,CAMA,SAASopC,GAAU1nC,GAYjB,OAXI2nC,EAAAA,EAAAA,MAAqC,iBAAT3nC,EAC9BA,EAAO2pB,SAASie,eAAe5nC,GACtBA,GAAQA,EAAKD,SAEtBC,EAAOA,EAAK,IAGVA,GAAQA,EAAKonB,SAEfpnB,EAAOA,EAAKonB,QAEPpnB,CACT,CAEA,MAAM6nC,GAAY,CAAC,EACbC,GAAYviC,IAChB,MAAM6hB,EAASsgB,GAAUniC,GACzB,OAAON,OAAOW,OAAOiiC,IAAW79B,QAAQ+9B,GAAMA,EAAE3gB,SAAWA,IAAQ9mB,KAAK,EAG1E,SAAS0nC,GAAgBhuB,EAAK5a,EAAOsW,GACnC,MAAMxQ,EAAOD,OAAOC,KAAK8U,GACzB,IAAK,MAAMzU,KAAOL,EAAM,CACtB,MAAM+iC,GAAU1iC,EAChB,GAAI0iC,GAAU7oC,EAAO,CACnB,MAAMuH,EAAQqT,EAAIzU,UACXyU,EAAIzU,IACPmQ,EAAO,GAAKuyB,EAAS7oC,KACvB4a,EAAIiuB,EAASvyB,GAAQ/O,GAG3B,CACF,CAmBA,SAASuhC,GAAephC,EAAO4L,EAAWy1B,GACxC,OAAOrhC,EAAMhB,QAAQwM,KAAOxL,EAAMqhC,GAASz1B,EAAUy1B,EACvD,CAeA,MAAMC,GAEJ39B,gBAAkBtF,EAAAA,EAClBsF,iBAAmBo9B,GACnBp9B,iBAAmBu1B,EAAAA,GACnBv1B,gBAAkBg3B,GAClBh3B,uBACAA,gBAAkBq9B,GAElBr9B,mBAAmB3K,GACjB2hC,GAASxgC,OAAOnB,GAChBuoC,IACF,CAEA59B,qBAAqB3K,GACnB2hC,GAAS//B,UAAU5B,GACnBuoC,IACF,CAGAxqC,YAAYmC,EAAMsoC,GAChB,MAAM3jC,EAAS7G,KAAK6G,OAAS,IAAIygC,GAAOkD,GAClCC,EAAgBb,GAAU1nC,GAC1BwoC,EAAgBV,GAASS,GAC/B,GAAIC,EACF,MAAM,IAAI3J,MACR,4CAA+C2J,EAAc/+B,GAA7D,kDACgD++B,EAAcphB,OAAO3d,GAAK,oBAI9E,MAAM3D,EAAUnB,EAAOsK,eAAetK,EAAOuhC,oBAAqBpoC,KAAKoR,cAEvEpR,KAAK2nC,SAAW,IAAK9gC,EAAO8gC,UCpJzB,SAAyBre,GAC9B,QAAKugB,EAAAA,EAAAA,MAAiD,oBAApBc,iBAAmCrhB,aAAkBqhB,gBAC9E3gB,EAEFwD,EACT,CD+I4Cod,CAAgBH,IACxDzqC,KAAK2nC,SAAS5d,aAAaljB,GAE3B,MAAMqO,EAAUlV,KAAK2nC,SAASte,eAAeohB,EAAeziC,EAAQuhB,aAC9DD,EAASpU,GAAWA,EAAQoU,OAC5BtM,EAASsM,GAAUA,EAAOtM,OAC1BC,EAAQqM,GAAUA,EAAOrM,MAE/Bjd,KAAK2L,IAAKk/B,EAAAA,EAAAA,MACV7qC,KAAK6M,IAAMqI,EACXlV,KAAKspB,OAASA,EACdtpB,KAAKid,MAAQA,EACbjd,KAAKgd,OAASA,EACdhd,KAAK8qC,SAAW9iC,EAIhBhI,KAAK+qC,aAAe/qC,KAAKupB,YACzBvpB,KAAKmnB,QAAU,GACfnnB,KAAKgrC,UAAY,GACjBhrC,KAAKoL,aAAU9K,EACfN,KAAKsmB,MAAQ,GACbtmB,KAAKusB,6BAA0BjsB,EAC/BN,KAAK4U,eAAYtU,EACjBN,KAAKqC,QAAU,GACfrC,KAAKirC,gBAAa3qC,EAClBN,KAAKkrC,WAAa,CAAC,EAEnBlrC,KAAKmrC,0BAAuB7qC,EAC5BN,KAAKorC,gBAAkB,GACvBprC,KAAKiM,OAAS,CAAC,EACfjM,KAAKqrC,SAAW,IAAItH,GACpB/jC,KAAKquB,SAAW,CAAC,EACjBruB,KAAKsrC,eAAiB,CAAC,EACvBtrC,KAAKurC,UAAW,EAChBvrC,KAAK2W,yBAAsBrW,EAC3BN,KAAKyN,cAAWnN,EAChBN,KAAKwrC,WAAYC,EAAAA,EAAAA,KAAS1hC,GAAQ/J,KAAKkG,OAAO6D,IAAO/B,EAAQ0jC,aAAe,GAC5E1rC,KAAKmY,aAAe,GAGpB4xB,GAAU/pC,KAAK2L,IAAM3L,KAEhBkV,GAAYoU,GASjBxlB,EAASf,OAAO/C,KAAM,WAAYwpC,IAClC1lC,EAASf,OAAO/C,KAAM,WAAY0pC,IAElC1pC,KAAK2rC,cACD3rC,KAAKurC,UACPvrC,KAAKkG,UATLiI,QAAQg4B,MAAM,oEAWlB,CAEI5c,kBACF,MAAOvhB,SAAS,YAACuhB,EAAW,oBAAEqiB,GAAoB,MAAE3uB,EAAA,OAAOD,EAAM,aAAE+tB,GAAgB/qC,KACnF,OAAK0c,EAAAA,EAAAA,GAAc6M,GAKfqiB,GAAuBb,EAElBA,EAIF/tB,EAASC,EAAQD,EAAS,KATxBuM,CAUX,CAEI3Z,WACF,OAAO5P,KAAK6G,OAAO+I,IACrB,CAEIA,SAAKA,GACP5P,KAAK6G,OAAO+I,KAAOA,CACrB,CAEI5H,cACF,OAAOhI,KAAK8qC,QACd,CAEI9iC,YAAQA,GACVhI,KAAK6G,OAAOmB,QAAUA,CACxB,CAEI27B,eACF,OAAOA,EACT,CAKAgI,cAeE,OAbA3rC,KAAKo2B,cAAc,cAEfp2B,KAAKgI,QAAQ6jC,WACf7rC,KAAKssB,UAELwf,EAAAA,EAAAA,IAAY9rC,KAAMA,KAAKgI,QAAQqkB,kBAGjCrsB,KAAK+rC,aAGL/rC,KAAKo2B,cAAc,aAEZp2B,IACT,CAEA6nC,QAEE,OADAmE,EAAAA,EAAAA,IAAYhsC,KAAKspB,OAAQtpB,KAAK6M,KACvB7M,IACT,CAEA0D,OAEE,OADAI,EAASJ,KAAK1D,MACPA,IACT,CAOAssB,OAAOrP,EAAOD,GACPlZ,EAAS/B,QAAQ/B,MAGpBA,KAAKisC,kBAAoB,CAAChvB,QAAOD,UAFjChd,KAAKksC,QAAQjvB,EAAOD,EAIxB,CAEAkvB,QAAQjvB,EAAOD,GACb,MAAMhV,EAAUhI,KAAKgI,QACfshB,EAAStpB,KAAKspB,OACdC,EAAcvhB,EAAQ4jC,qBAAuB5rC,KAAKupB,YAClD4iB,EAAUnsC,KAAK2nC,SAAS9d,eAAeP,EAAQrM,EAAOD,EAAQuM,GAC9D6iB,EAAWpkC,EAAQqkB,kBAAoBrsB,KAAK2nC,SAAS/d,sBACrD7f,EAAO/J,KAAKid,MAAQ,SAAW,SAErCjd,KAAKid,MAAQkvB,EAAQlvB,MACrBjd,KAAKgd,OAASmvB,EAAQnvB,OACtBhd,KAAK+qC,aAAe/qC,KAAKupB,aACpBuiB,EAAAA,EAAAA,IAAY9rC,KAAMosC,GAAU,KAIjCpsC,KAAKo2B,cAAc,SAAU,CAACttB,KAAMqjC,KAEpClZ,EAAAA,EAAAA,GAAajrB,EAAQqkC,SAAU,CAACrsC,KAAMmsC,GAAUnsC,MAE5CA,KAAKurC,UACHvrC,KAAKwrC,UAAUzhC,IAEjB/J,KAAKssC,SAGX,CAEAC,sBACE,MACMC,EADUxsC,KAAKgI,QACSiE,QAAU,CAAC,GAEzCqc,EAAAA,EAAAA,GAAKkkB,GAAe,CAACC,EAAaxM,KAChCwM,EAAY9gC,GAAKs0B,CAAA,GAErB,CAKAyM,sBACE,MAAM1kC,EAAUhI,KAAKgI,QACf2kC,EAAY3kC,EAAQiE,OACpBA,EAASjM,KAAKiM,OACd2gC,EAAUzlC,OAAOC,KAAK6E,GAAQ5I,QAAO,CAAC6Y,EAAKvQ,KAC/CuQ,EAAIvQ,IAAM,EACHuQ,IACN,CAAC,GACJ,IAAIla,EAAQ,GAER2qC,IACF3qC,EAAQA,EAAM+W,OACZ5R,OAAOC,KAAKulC,GAAWE,KAAKlhC,IAC1B,MAAMg6B,EAAegH,EAAUhhC,GACzBJ,EAAOm6B,GAAc/5B,EAAIg6B,GACzBmH,EAAoB,MAATvhC,EACX+Q,EAAwB,MAAT/Q,EACrB,MAAO,CACLvD,QAAS29B,EACToH,UAAWD,EAAW,YAAcxwB,EAAe,SAAW,OAC9D0wB,MAAOF,EAAW,eAAiBxwB,EAAe,WAAa,SAChE,OAKPgM,EAAAA,EAAAA,GAAKtmB,GAAQE,IACX,MAAMyjC,EAAezjC,EAAK8F,QACpB2D,EAAKg6B,EAAah6B,GAClBJ,EAAOm6B,GAAc/5B,EAAIg6B,GACzBsH,GAAYn+B,EAAAA,EAAAA,GAAe62B,EAAahlC,KAAMuB,EAAK8qC,YAE3B1sC,IAA1BqlC,EAAa7jB,UAA0BsnB,GAAqBzD,EAAa7jB,SAAUvW,KAAU69B,GAAqBlnC,EAAK6qC,aACzHpH,EAAa7jB,SAAW5f,EAAK6qC,WAG/BH,EAAQjhC,IAAM,EACd,IAAI3C,EAAQ,KACR2C,KAAMM,GAAUA,EAAON,GAAIhL,OAASssC,EACtCjkC,EAAQiD,EAAON,IAGf3C,EAAQ,IADW26B,GAASX,SAASiK,GAC7B,CAAe,CACrBthC,KACAhL,KAAMssC,EACNpgC,IAAK7M,KAAK6M,IACVrM,MAAOR,OAETiM,EAAOjD,EAAM2C,IAAM3C,GAGrBA,EAAMqpB,KAAKsT,EAAc39B,EAAA,KAG3BsgB,EAAAA,EAAAA,GAAKskB,GAAS,CAACM,EAAYvhC,KACpBuhC,UACIjhC,EAAON,OAIlB2c,EAAAA,EAAAA,GAAKrc,GAASjD,IACZie,EAAQjgB,UAAUhH,KAAMgJ,EAAOA,EAAMhB,SACrCif,EAAQC,OAAOlnB,KAAMgJ,EAAA,GAEzB,CAKAmkC,kBACE,MAAM5jC,EAAWvJ,KAAKgrC,UAChBvzB,EAAUzX,KAAK4P,KAAKC,SAAS5N,OAC7BuV,EAAUjO,EAAStH,OAGzB,GADAsH,EAAS0P,MAAK,CAACC,EAAGlF,IAAMkF,EAAExP,MAAQsK,EAAEtK,QAChC8N,EAAUC,EAAS,CACrB,IAAK,IAAItV,EAAIsV,EAAStV,EAAIqV,IAAWrV,EACnCnC,KAAKotC,oBAAoBjrC,GAE3BoH,EAASyO,OAAOP,EAASD,EAAUC,GAErCzX,KAAKorC,gBAAkB7hC,EAAS8jC,MAAM,GAAGp0B,KAAKowB,GAAc,QAAS,SACvE,CAKAiE,8BACE,MAAOtC,UAAWzhC,EAAUqG,MAAM,SAACC,IAAa7P,KAC5CuJ,EAAStH,OAAS4N,EAAS5N,eACtBjC,KAAKoL,QAEd7B,EAASvI,SAAQ,CAACqJ,EAAMX,KACmC,IAArDmG,EAAS3D,QAAOuC,GAAKA,IAAMpE,EAAKsV,WAAU1d,QAC5CjC,KAAKotC,oBAAoB1jC,KAG/B,CAEA6jC,2BACE,MAAMC,EAAiB,GACjB39B,EAAW7P,KAAK4P,KAAKC,SAC3B,IAAI1N,EAAGsH,EAIP,IAFAzJ,KAAKstC,8BAEAnrC,EAAI,EAAGsH,EAAOoG,EAAS5N,OAAQE,EAAIsH,EAAMtH,IAAK,CACjD,MAAMmM,EAAUuB,EAAS1N,GACzB,IAAIkI,EAAOrK,KAAK8P,eAAe3N,GAC/B,MAAMxB,EAAO2N,EAAQ3N,MAAQX,KAAK6G,OAAOlG,KAazC,GAXI0J,EAAK1J,MAAQ0J,EAAK1J,OAASA,IAC7BX,KAAKotC,oBAAoBjrC,GACzBkI,EAAOrK,KAAK8P,eAAe3N,IAE7BkI,EAAK1J,KAAOA,EACZ0J,EAAK8E,UAAYb,EAAQa,WAAao2B,GAAa5kC,EAAMX,KAAKgI,SAC9DqC,EAAKojC,MAAQn/B,EAAQm/B,OAAS,EAC9BpjC,EAAKX,MAAQvH,EACbkI,EAAKuJ,MAAQ,GAAKtF,EAAQsF,MAC1BvJ,EAAKqjC,QAAU1tC,KAAK2tC,iBAAiBxrC,GAEjCkI,EAAKY,WACPZ,EAAKY,WAAWoD,YAAYlM,GAC5BkI,EAAKY,WAAW6C,iBACX,CACL,MAAM8/B,EAAkBjK,GAASf,cAAcjiC,IACzC,mBAACgN,EAAA,gBAAoBC,GAAmBvG,EAAAA,EAASwI,SAASlP,GAChEwG,OAAOe,OAAO0lC,EAAiB,CAC7BhgC,gBAAiB+1B,GAASb,WAAWl1B,GACrCD,mBAAoBA,GAAsBg2B,GAASb,WAAWn1B,KAEhEtD,EAAKY,WAAa,IAAI2iC,EAAgB5tC,KAAMmC,GAC5CqrC,EAAetqC,KAAKmH,EAAKY,YAE7B,CAGA,OADAjL,KAAKmtC,kBACEK,CACT,CAMAK,kBACEvlB,EAAAA,EAAAA,GAAKtoB,KAAK4P,KAAKC,UAAU,CAACvB,EAAStE,KACjChK,KAAK8P,eAAe9F,GAAciB,WAAWgF,OAAO,GACnDjQ,KACL,CAKAiQ,QACEjQ,KAAK6tC,iBACL7tC,KAAKo2B,cAAc,QACrB,CAEAlwB,OAAO6D,GACL,MAAMlD,EAAS7G,KAAK6G,OAEpBA,EAAOX,SACP,MAAM8B,EAAUhI,KAAK8qC,SAAWjkC,EAAOsK,eAAetK,EAAOuhC,oBAAqBpoC,KAAKoR,cACjF08B,EAAgB9tC,KAAK2W,qBAAuB3O,EAAQV,UAU1D,GARAtH,KAAK+tC,gBACL/tC,KAAKguC,sBACLhuC,KAAKiuC,uBAILjuC,KAAKqrC,SAAS7G,cAEuD,IAAjExkC,KAAKo2B,cAAc,eAAgB,CAACrsB,OAAMw6B,YAAY,IACxD,OAIF,MAAMiJ,EAAiBxtC,KAAKutC,2BAE5BvtC,KAAKo2B,cAAc,wBAGnB,IAAI7O,EAAa,EACjB,IAAK,IAAIplB,EAAI,EAAGsH,EAAOzJ,KAAK4P,KAAKC,SAAS5N,OAAQE,EAAIsH,EAAMtH,IAAK,CAC/D,MAAM,WAAC8I,GAAcjL,KAAK8P,eAAe3N,GACnC8N,GAAS69B,IAAyD,IAAxCN,EAAejwB,QAAQtS,GAGvDA,EAAWyF,sBAAsBT,GACjCsX,EAAanmB,KAAKoC,KAAKyH,EAAWyI,iBAAkB6T,EACtD,CACAA,EAAavnB,KAAKkuC,YAAclmC,EAAQqd,OAAO8oB,YAAc5mB,EAAa,EAC1EvnB,KAAKouC,cAAc7mB,GAGdumB,IAGHxlB,EAAAA,EAAAA,GAAKklB,GAAiBviC,IACpBA,EAAWgF,OAAO,IAItBjQ,KAAKquC,gBAAgBtkC,GAGrB/J,KAAKo2B,cAAc,cAAe,CAACrsB,SAEnC/J,KAAKmnB,QAAQlO,KAAKowB,GAAc,IAAK,SAGrC,MAAM,QAAChnC,EAAO,WAAE4oC,GAAcjrC,KAC1BirC,EACFjrC,KAAKsuC,cAAcrD,GAAY,GACtB5oC,EAAQJ,QACjBjC,KAAKuuC,mBAAmBlsC,EAASA,GAAS,GAG5CrC,KAAKssC,QACP,CAKAyB,iBACEzlB,EAAAA,EAAAA,GAAKtoB,KAAKiM,QAASjD,IACjBie,EAAQI,UAAUrnB,KAAMgJ,EAAA,IAG1BhJ,KAAKusC,sBACLvsC,KAAK0sC,qBACP,CAKAsB,sBACE,MAAMhmC,EAAUhI,KAAKgI,QACfwmC,EAAiB,IAAItH,IAAI//B,OAAOC,KAAKpH,KAAKkrC,aAC1CuD,EAAY,IAAIvH,IAAIl/B,EAAQ0mC,SAE7BC,EAAAA,EAAAA,IAAUH,EAAgBC,MAAgBzuC,KAAKmrC,uBAAyBnjC,EAAQ6jC,aAEnF7rC,KAAK4uC,eACL5uC,KAAK+rC,aAET,CAKAkC,uBACE,MAAM,eAAC3C,GAAkBtrC,KACnB6uC,EAAU7uC,KAAK8uC,0BAA4B,GACjD,IAAK,MAAM,OAACnoC,EAAM,MAAErF,EAAA,MAAOiQ,KAAUs9B,EAEnC3E,GAAgBoB,EAAgBhqC,EADR,oBAAXqF,GAAgC4K,EAAQA,EAGzD,CAKAu9B,yBACE,MAAM32B,EAAenY,KAAKmY,aAC1B,IAAKA,IAAiBA,EAAalW,OACjC,OAGFjC,KAAKmY,aAAe,GACpB,MAAM42B,EAAe/uC,KAAK4P,KAAKC,SAAS5N,OAClC+sC,EAAWpV,GAAQ,IAAIsN,IAC3B/uB,EACGjM,QAAO+9B,GAAKA,EAAE,KAAOrQ,IACrBiT,KAAI,CAAC5C,EAAG9nC,IAAMA,EAAI,IAAM8nC,EAAEjyB,OAAO,GAAGypB,KAAK,QAGxCwN,EAAYD,EAAQ,GAC1B,IAAK,IAAI7sC,EAAI,EAAGA,EAAI4sC,EAAc5sC,IAChC,KAAKwsC,EAAAA,EAAAA,IAAUM,EAAWD,EAAQ7sC,IAChC,OAGJ,OAAOmO,MAAMpM,KAAK+qC,GACfpC,KAAI5C,GAAKA,EAAE3I,MAAM,OACjBuL,KAAI3zB,IAAA,CAAOvS,OAAQuS,EAAE,GAAI5X,OAAQ4X,EAAE,GAAI3H,OAAQ2H,EAAE,MACtD,CAOAk1B,cAAc7mB,GACZ,IAA+D,IAA3DvnB,KAAKo2B,cAAc,eAAgB,CAACmO,YAAY,IAClD,OAGFtd,EAAQ/gB,OAAOlG,KAAMA,KAAKid,MAAOjd,KAAKgd,OAAQuK,GAE9C,MAAM5S,EAAO3U,KAAK4U,UACZs6B,EAASv6B,EAAKsI,OAAS,GAAKtI,EAAKqI,QAAU,EAEjDhd,KAAKmnB,QAAU,IACfmB,EAAAA,EAAAA,GAAKtoB,KAAKsmB,OAAQ3B,IACZuqB,GAA2B,cAAjBvqB,EAAI7C,WAOd6C,EAAI3d,WACN2d,EAAI3d,YAENhH,KAAKmnB,QAAQjkB,QAAQyhB,EAAIwC,WAAU,GAClCnnB,MAEHA,KAAKmnB,QAAQnmB,SAAQ,CAACkB,EAAMwH,KAC1BxH,EAAKitC,KAAOzlC,CAAA,IAGd1J,KAAKo2B,cAAc,cACrB,CAOAiY,gBAAgBtkC,GACd,IAA6E,IAAzE/J,KAAKo2B,cAAc,uBAAwB,CAACrsB,OAAMw6B,YAAY,IAAlE,CAIA,IAAK,IAAIpiC,EAAI,EAAGsH,EAAOzJ,KAAK4P,KAAKC,SAAS5N,OAAQE,EAAIsH,IAAQtH,EAC5DnC,KAAK8P,eAAe3N,GAAG8I,WAAWjE,YAGpC,IAAK,IAAI7E,EAAI,EAAGsH,EAAOzJ,KAAK4P,KAAKC,SAAS5N,OAAQE,EAAIsH,IAAQtH,EAC5DnC,KAAKovC,eAAejtC,GAAGumC,EAAAA,EAAAA,IAAW3+B,GAAQA,EAAK,CAACC,aAAc7H,IAAM4H,GAGtE/J,KAAKo2B,cAAc,sBAAuB,CAACrsB,SAC7C,CAOAqlC,eAAe1lC,EAAOK,GACpB,MAAMM,EAAOrK,KAAK8P,eAAepG,GAC3BwO,EAAO,CAAC7N,OAAMX,QAAOK,OAAMw6B,YAAY,IAEW,IAApDvkC,KAAKo2B,cAAc,sBAAuBle,KAI9C7N,EAAKY,WAAWtJ,QAAQoI,GAExBmO,EAAKqsB,YAAa,EAClBvkC,KAAKo2B,cAAc,qBAAsBle,GAC3C,CAEAo0B,UACiE,IAA3DtsC,KAAKo2B,cAAc,eAAgB,CAACmO,YAAY,MAIhDzgC,EAASV,IAAIpD,MACXA,KAAKurC,WAAaznC,EAAS/B,QAAQ/B,OACrC8D,EAASxC,MAAMtB,OAGjBA,KAAKoC,OACLonC,GAAqB,CAAChpC,MAAOR,QAEjC,CAEAoC,OACE,IAAID,EACJ,GAAInC,KAAKisC,kBAAmB,CAC1B,MAAM,MAAChvB,EAAA,OAAOD,GAAUhd,KAAKisC,kBAC7BjsC,KAAKksC,QAAQjvB,EAAOD,GACpBhd,KAAKisC,kBAAoB,KAI3B,GAFAjsC,KAAK6nC,QAED7nC,KAAKid,OAAS,GAAKjd,KAAKgd,QAAU,EACpC,OAGF,IAA6D,IAAzDhd,KAAKo2B,cAAc,aAAc,CAACmO,YAAY,IAChD,OAMF,MAAM8K,EAASrvC,KAAKmnB,QACpB,IAAKhlB,EAAI,EAAGA,EAAIktC,EAAOptC,QAAUotC,EAAOltC,GAAGilB,GAAK,IAAKjlB,EACnDktC,EAAOltC,GAAGC,KAAKpC,KAAK4U,WAMtB,IAHA5U,KAAKsvC,gBAGEntC,EAAIktC,EAAOptC,SAAUE,EAC1BktC,EAAOltC,GAAGC,KAAKpC,KAAK4U,WAGtB5U,KAAKo2B,cAAc,YACrB,CAKA5sB,uBAAuBF,GACrB,MAAMC,EAAWvJ,KAAKorC,gBAChB1b,EAAS,GACf,IAAIvtB,EAAGsH,EAEP,IAAKtH,EAAI,EAAGsH,EAAOF,EAAStH,OAAQE,EAAIsH,IAAQtH,EAAG,CACjD,MAAMkI,EAAOd,EAASpH,GACjBmH,IAAiBe,EAAKqjC,SACzBhe,EAAOxsB,KAAKmH,EAEhB,CAEA,OAAOqlB,CACT,CAMA1N,+BACE,OAAOhiB,KAAKwJ,wBAAuB,EACrC,CAOA8lC,gBACE,IAAqE,IAAjEtvC,KAAKo2B,cAAc,qBAAsB,CAACmO,YAAY,IACxD,OAGF,MAAMh7B,EAAWvJ,KAAKgiB,+BACtB,IAAK,IAAI7f,EAAIoH,EAAStH,OAAS,EAAGE,GAAK,IAAKA,EAC1CnC,KAAKuvC,aAAahmC,EAASpH,IAG7BnC,KAAKo2B,cAAc,oBACrB,CAOAmZ,aAAallC,GACX,MAAMwC,EAAM7M,KAAK6M,IACX2H,EAAOnK,EAAKyJ,MACZ07B,GAAWh7B,EAAKF,SAChBK,EAxrBV,SAAwBtK,EAAMuK,GAC5B,MAAM,OAACpF,EAAA,OAAQE,GAAUrF,EACzB,OAAImF,GAAUE,EACL,CACL2E,KAAM+1B,GAAe56B,EAAQoF,EAAW,QACxCT,MAAOi2B,GAAe56B,EAAQoF,EAAW,SACzCV,IAAKk2B,GAAe16B,EAAQkF,EAAW,OACvCR,OAAQg2B,GAAe16B,EAAQkF,EAAW,WAGvCA,CACT,CA6qBiB66B,CAAeplC,EAAMrK,KAAK4U,WACjCsD,EAAO,CACX7N,OACAX,MAAOW,EAAKX,MACZ66B,YAAY,IAGwC,IAAlDvkC,KAAKo2B,cAAc,oBAAqBle,KAIxCs3B,IACFrQ,EAAAA,EAAAA,GAAStyB,EAAK,CACZwH,MAAoB,IAAdG,EAAKH,KAAiB,EAAIM,EAAKN,KAAOG,EAAKH,KACjDF,OAAsB,IAAfK,EAAKL,MAAkBnU,KAAKid,MAAQtI,EAAKR,MAAQK,EAAKL,MAC7DD,KAAkB,IAAbM,EAAKN,IAAgB,EAAIS,EAAKT,IAAMM,EAAKN,IAC9CE,QAAwB,IAAhBI,EAAKJ,OAAmBpU,KAAKgd,OAASrI,EAAKP,OAASI,EAAKJ,SAIrE/J,EAAKY,WAAW7I,OAEZotC,IACFlQ,EAAAA,EAAAA,GAAWzyB,GAGbqL,EAAKqsB,YAAa,EAClBvkC,KAAKo2B,cAAc,mBAAoBle,GACzC,CAOAmK,cAAc5B,GACZ,OAAO6B,EAAAA,EAAAA,GAAe7B,EAAOzgB,KAAK4U,UAAW5U,KAAKkuC,YACpD,CAEAwB,0BAA0BvrB,EAAGpa,EAAM/B,EAASma,GAC1C,MAAMxb,EAASsd,EAAYC,MAAMna,GACjC,MAAsB,mBAAXpD,EACFA,EAAO3G,KAAMmkB,EAAGnc,EAASma,GAG3B,EACT,CAEArS,eAAe9F,GACb,MAAMsE,EAAUtO,KAAK4P,KAAKC,SAAS7F,GAC7BT,EAAWvJ,KAAKgrC,UACtB,IAAI3gC,EAAOd,EAAS2C,QAAOuC,GAAKA,GAAKA,EAAEkR,WAAarR,IAAS9L,MAoB7D,OAlBK6H,IACHA,EAAO,CACL1J,KAAM,KACNiP,KAAM,GACNtB,QAAS,KACTrD,WAAY,KACZ8H,OAAQ,KACRlE,QAAS,KACTG,QAAS,KACTy+B,MAAOn/B,GAAWA,EAAQm/B,OAAS,EACnC/jC,MAAOM,EACP2V,SAAUrR,EACVjC,QAAS,GACToF,SAAS,GAEXlI,EAASrG,KAAKmH,IAGTA,CACT,CAEA+G,aACE,OAAOpR,KAAKyN,WAAazN,KAAKyN,UAAW2H,EAAAA,EAAAA,GAAc,KAAM,CAAC5U,MAAOR,KAAMW,KAAM,UACnF,CAEAgvC,yBACE,OAAO3vC,KAAKgiB,+BAA+B/f,MAC7C,CAEA0rC,iBAAiB3jC,GACf,MAAMsE,EAAUtO,KAAK4P,KAAKC,SAAS7F,GACnC,IAAKsE,EACH,OAAO,EAGT,MAAMjE,EAAOrK,KAAK8P,eAAe9F,GAIjC,MAA8B,kBAAhBK,EAAK0I,QAAwB1I,EAAK0I,QAAUzE,EAAQyE,MACpE,CAEA68B,qBAAqB5lC,EAAc0jC,GACpB1tC,KAAK8P,eAAe9F,GAC5B+I,QAAU26B,CACjB,CAEAmC,qBAAqBnmC,GACnB1J,KAAKsrC,eAAe5hC,IAAU1J,KAAKsrC,eAAe5hC,EACpD,CAEA0U,kBAAkB1U,GAChB,OAAQ1J,KAAKsrC,eAAe5hC,EAC9B,CAKAomC,kBAAkB9lC,EAAcqL,EAAWq4B,GACzC,MAAM3jC,EAAO2jC,EAAU,OAAS,OAC1BrjC,EAAOrK,KAAK8P,eAAe9F,GAC3BvJ,EAAQ4J,EAAKY,WAAWmL,wBAAmB9V,EAAWyJ,IAExD+L,EAAAA,EAAAA,GAAQT,IACVhL,EAAKuF,KAAKyF,GAAWtC,QAAU26B,EAC/B1tC,KAAKkG,WAELlG,KAAK4vC,qBAAqB5lC,EAAc0jC,GAExCjtC,EAAMyF,OAAOmE,EAAM,CAACqjC,YACpB1tC,KAAKkG,QAAQ2G,GAAQA,EAAI7C,eAAiBA,EAAeD,OAAOzJ,IAEpE,CAEAyvC,KAAK/lC,EAAcqL,GACjBrV,KAAK8vC,kBAAkB9lC,EAAcqL,GAAW,EAClD,CAEA26B,KAAKhmC,EAAcqL,GACjBrV,KAAK8vC,kBAAkB9lC,EAAcqL,GAAW,EAClD,CAKA+3B,oBAAoBpjC,GAClB,MAAMK,EAAOrK,KAAKgrC,UAAUhhC,GACxBK,GAAQA,EAAKY,YACfZ,EAAKY,WAAWiF,kBAEXlQ,KAAKgrC,UAAUhhC,EACxB,CAEAimC,QACE,IAAI9tC,EAAGsH,EAIP,IAHAzJ,KAAK0D,OACLI,EAASF,OAAO5D,MAEXmC,EAAI,EAAGsH,EAAOzJ,KAAK4P,KAAKC,SAAS5N,OAAQE,EAAIsH,IAAQtH,EACxDnC,KAAKotC,oBAAoBjrC,EAE7B,CAEA+tC,UACElwC,KAAKo2B,cAAc,iBACnB,MAAM,OAAC9M,EAAM,IAAEzc,GAAO7M,KAEtBA,KAAKiwC,QACLjwC,KAAK6G,OAAO+gC,aAERte,IACFtpB,KAAK4uC,gBACL5C,EAAAA,EAAAA,IAAY1iB,EAAQzc,GACpB7M,KAAK2nC,SAASne,eAAe3c,GAC7B7M,KAAKspB,OAAS,KACdtpB,KAAK6M,IAAM,aAGNk9B,GAAU/pC,KAAK2L,IAEtB3L,KAAKo2B,cAAc,eACrB,CAEA+Z,iBAAiBj4B,GACf,OAAOlY,KAAKspB,OAAO8mB,aAAal4B,EAClC,CAKA6zB,aACE/rC,KAAKqwC,iBACDrwC,KAAKgI,QAAQ6jC,WACf7rC,KAAKswC,uBAELtwC,KAAKurC,UAAW,CAEpB,CAKA8E,iBACE,MAAMxvC,EAAYb,KAAKkrC,WACjBvD,EAAW3nC,KAAK2nC,SAEhB4I,EAAOA,CAAC5vC,EAAM+oB,KAClBie,EAASle,iBAAiBzpB,KAAMW,EAAM+oB,GACtC7oB,EAAUF,GAAQ+oB,CAAA,EAGdA,EAAWA,CAACvF,EAAG1V,EAAGC,KACtByV,EAAEqsB,QAAU/hC,EACZ0V,EAAEssB,QAAU/hC,EACZ1O,KAAKsuC,cAAcnqB,EAAA,GAGrBmE,EAAAA,EAAAA,GAAKtoB,KAAKgI,QAAQ0mC,QAAS/tC,GAAS4vC,EAAK5vC,EAAM+oB,IACjD,CAKA4mB,uBACOtwC,KAAKmrC,uBACRnrC,KAAKmrC,qBAAuB,CAAC,GAE/B,MAAMtqC,EAAYb,KAAKmrC,qBACjBxD,EAAW3nC,KAAK2nC,SAEhB4I,EAAOA,CAAC5vC,EAAM+oB,KAClBie,EAASle,iBAAiBzpB,KAAMW,EAAM+oB,GACtC7oB,EAAUF,GAAQ+oB,CAAA,EAEdgnB,EAAUA,CAAC/vC,EAAM+oB,KACjB7oB,EAAUF,KACZgnC,EAAShe,oBAAoB3pB,KAAMW,EAAM+oB,UAClC7oB,EAAUF,KAIf+oB,EAAWA,CAACzM,EAAOD,KACnBhd,KAAKspB,QACPtpB,KAAKssB,OAAOrP,EAAOD,IAIvB,IAAI2zB,EACJ,MAAMpF,EAAWA,KACfmF,EAAQ,SAAUnF,GAElBvrC,KAAKurC,UAAW,EAChBvrC,KAAKssB,SAELikB,EAAK,SAAU7mB,GACf6mB,EAAK,SAAUI,EAAA,EAGjBA,EAAWA,KACT3wC,KAAKurC,UAAW,EAEhBmF,EAAQ,SAAUhnB,GAGlB1pB,KAAKiwC,QACLjwC,KAAKksC,QAAQ,EAAG,GAEhBqE,EAAK,SAAUhF,EAAA,EAGb5D,EAAS7d,WAAW9pB,KAAKspB,QAC3BiiB,IAEAoF,GAEJ,CAKA/B,gBACEtmB,EAAAA,EAAAA,GAAKtoB,KAAKkrC,YAAY,CAACxhB,EAAU/oB,KAC/BX,KAAK2nC,SAAShe,oBAAoB3pB,KAAMW,EAAM+oB,EAAA,IAEhD1pB,KAAKkrC,WAAa,CAAC,GAEnB5iB,EAAAA,EAAAA,GAAKtoB,KAAKmrC,sBAAsB,CAACzhB,EAAU/oB,KACzCX,KAAK2nC,SAAShe,oBAAoB3pB,KAAMW,EAAM+oB,EAAA,IAEhD1pB,KAAKmrC,0BAAuB7qC,CAC9B,CAEAswC,iBAAiB5uC,EAAO+H,EAAMgrB,GAC5B,MAAM8b,EAAS9b,EAAU,MAAQ,SACjC,IAAI1qB,EAAMnI,EAAMC,EAAGsH,EAOnB,IALa,YAATM,IACFM,EAAOrK,KAAK8P,eAAe9N,EAAM,GAAGgI,cACpCK,EAAKY,WAAW,IAAM4lC,EAAS,wBAG5B1uC,EAAI,EAAGsH,EAAOzH,EAAMC,OAAQE,EAAIsH,IAAQtH,EAAG,CAC9CD,EAAOF,EAAMG,GACb,MAAM8I,EAAa/I,GAAQlC,KAAK8P,eAAe5N,EAAK8H,cAAciB,WAC9DA,GACFA,EAAW4lC,EAAS,cAAc3uC,EAAK4S,QAAS5S,EAAK8H,aAAc9H,EAAKwH,MAE5E,CACF,CAMAonC,oBACE,OAAO9wC,KAAKqC,SAAW,EACzB,CAMA0uC,kBAAkBC,GAChB,MAAMC,EAAajxC,KAAKqC,SAAW,GAC7B4D,EAAS+qC,EAAenE,KAAI,EAAE7iC,eAAcN,YAChD,MAAMW,EAAOrK,KAAK8P,eAAe9F,GACjC,IAAKK,EACH,MAAM,IAAI02B,MAAM,6BAA+B/2B,GAGjD,MAAO,CACLA,eACA8K,QAASzK,EAAKuF,KAAKlG,GACnBA,QACD,MAEcwnC,EAAAA,EAAAA,IAAejrC,EAAQgrC,KAGtCjxC,KAAKqC,QAAU4D,EAEfjG,KAAKirC,WAAa,KAClBjrC,KAAKuuC,mBAAmBtoC,EAAQgrC,GAEpC,CAWA7a,cAAc8N,EAAMhsB,EAAMhM,GACxB,OAAOlM,KAAKqrC,SAASpH,OAAOjkC,KAAMkkC,EAAMhsB,EAAMhM,EAChD,CAOAgC,gBAAgBijC,GACd,OAA6E,IAAtEnxC,KAAKqrC,SAASzyB,OAAO1M,QAAOg9B,GAAKA,EAAE5E,OAAO34B,KAAOwlC,IAAUlvC,MACpE,CAKAssC,mBAAmBtoC,EAAQgrC,EAAYG,GACrC,MAAMC,EAAerxC,KAAKgI,QAAQspC,MAC5Bjc,EAAOA,CAACnc,EAAGlF,IAAMkF,EAAEhN,QAAOuC,IAAMuF,EAAEkxB,MAAKx2B,GAAKD,EAAEzE,eAAiB0E,EAAE1E,cAAgByE,EAAE/E,QAAUgF,EAAEhF,UAC/F6nC,EAAclc,EAAK4b,EAAYhrC,GAC/BurC,EAAYJ,EAASnrC,EAASovB,EAAKpvB,EAAQgrC,GAE7CM,EAAYtvC,QACdjC,KAAK4wC,iBAAiBW,EAAaF,EAAatnC,MAAM,GAGpDynC,EAAUvvC,QAAUovC,EAAatnC,MACnC/J,KAAK4wC,iBAAiBY,EAAWH,EAAatnC,MAAM,EAExD,CAKAukC,cAAcnqB,EAAGitB,GACf,MAAMl5B,EAAO,CACXlV,MAAOmhB,EACPitB,SACA7M,YAAY,EACZkN,YAAazxC,KAAKqiB,cAAc8B,IAE5ButB,EAAepN,IAAYA,EAAOt8B,QAAQ0mC,QAAU1uC,KAAKgI,QAAQ0mC,QAAQ7lB,SAAS1E,EAAEkJ,OAAO1sB,MAEjG,IAA6D,IAAzDX,KAAKo2B,cAAc,cAAele,EAAMw5B,GAC1C,OAGF,MAAMjrB,EAAUzmB,KAAK2xC,aAAaxtB,EAAGitB,EAAQl5B,EAAKu5B,aASlD,OAPAv5B,EAAKqsB,YAAa,EAClBvkC,KAAKo2B,cAAc,aAAcle,EAAMw5B,IAEnCjrB,GAAWvO,EAAKuO,UAClBzmB,KAAKssC,SAGAtsC,IACT,CAUA2xC,aAAaxtB,EAAGitB,EAAQK,GACtB,MAAOpvC,QAAS4uC,EAAa,GAAE,QAAEjpC,GAAWhI,KAetCmiB,EAAmBivB,EACnBnrC,EAASjG,KAAK4xC,mBAAmBztB,EAAG8sB,EAAYQ,EAAatvB,GAC7D0vB,GAAUC,EAAAA,EAAAA,IAAc3tB,GACxB4tB,EAxnCV,SAA4B5tB,EAAG4tB,EAAWN,EAAaI,GACrD,OAAKJ,GAA0B,aAAXttB,EAAExjB,KAGlBkxC,EACKE,EAEF5tB,EALE,IAMX,CAgnCsB6tB,CAAmB7tB,EAAGnkB,KAAKirC,WAAYwG,EAAaI,GAElEJ,IAGFzxC,KAAKirC,WAAa,MAGlBhY,EAAAA,EAAAA,GAAajrB,EAAQiqC,QAAS,CAAC9tB,EAAGle,EAAQjG,MAAOA,MAE7C6xC,IACF5e,EAAAA,EAAAA,GAAajrB,EAAQkqC,QAAS,CAAC/tB,EAAGle,EAAQjG,MAAOA,OAIrD,MAAMymB,IAAWyqB,EAAAA,EAAAA,IAAejrC,EAAQgrC,GAQxC,OAPIxqB,GAAW2qB,KACbpxC,KAAKqC,QAAU4D,EACfjG,KAAKuuC,mBAAmBtoC,EAAQgrC,EAAYG,IAG9CpxC,KAAKirC,WAAa8G,EAEXtrB,CACT,CAUAmrB,mBAAmBztB,EAAG8sB,EAAYQ,EAAatvB,GAC7C,GAAe,aAAXgC,EAAExjB,KACJ,MAAO,GAGT,IAAK8wC,EAEH,OAAOR,EAGT,MAAMI,EAAerxC,KAAKgI,QAAQspC,MAClC,OAAOtxC,KAAK0vC,0BAA0BvrB,EAAGktB,EAAatnC,KAAMsnC,EAAclvB,EAC5E,EAIF,SAASooB,KACP,OAAOjiB,EAAAA,EAAAA,GAAKgiB,GAAMP,WAAYvpC,GAAUA,EAAM6qC,SAAS7G,cACzD,CE9vCA,SAAS2N,GAAStlC,EAAK7E,EAASylB,EAAQzlB,GACtC6E,EAAIulC,SAAUtjC,EAAAA,EAAAA,GAAe2e,EAAM4kB,eAAgBrqC,EAAQqqC,gBAC3DxlC,EAAI4xB,aAAY3vB,EAAAA,EAAAA,GAAe2e,EAAMqO,WAAY9zB,EAAQ8zB,aACzDjvB,EAAI6xB,gBAAiB5vB,EAAAA,EAAAA,GAAe2e,EAAMuO,iBAAkBh0B,EAAQg0B,kBACpEnvB,EAAIylC,UAAWxjC,EAAAA,EAAAA,GAAe2e,EAAM8kB,gBAAiBvqC,EAAQuqC,iBAC7D1lC,EAAI+uB,WAAY9sB,EAAAA,EAAAA,GAAe2e,EAAMxN,YAAajY,EAAQiY,aAC1DpT,EAAI2xB,aAAc1vB,EAAAA,EAAAA,GAAe2e,EAAM+kB,YAAaxqC,EAAQwqC,YAC9D,CAEA,SAAS3T,GAAOhyB,EAAK4lC,EAAU3tC,GAC7B+H,EAAIgyB,OAAO/5B,EAAO2J,EAAG3J,EAAO4J,EAC9B,CAiBA,SAASgkC,GAAShzB,EAAQQ,EAASkF,EAAS,IAC1C,MAAM7T,EAAQmO,EAAOzd,QACdX,MAAOqxC,EAAc,EAAGvpC,IAAKwpC,EAAYrhC,EAAQ,GAAK6T,GACtD9jB,MAAOuxC,EAAczpC,IAAK0pC,GAAc5yB,EACzC5e,EAAQF,KAAKoC,IAAImvC,EAAaE,GAC9BzpC,EAAMhI,KAAKC,IAAIuxC,EAAWE,GAC1BC,EAAUJ,EAAcE,GAAgBD,EAAYC,GAAgBF,EAAcG,GAAcF,EAAYE,EAElH,MAAO,CACLvhC,QACAjQ,QACAqE,KAAMua,EAAQva,KACd8D,KAAML,EAAM9H,IAAUyxC,EAAUxhC,EAAQnI,EAAM9H,EAAQ8H,EAAM9H,EAEhE,CAiBA,SAAS0xC,GAAYnmC,EAAK4S,EAAMS,EAASkF,GACvC,MAAM,OAAC1F,EAAA,QAAQ1X,GAAWyX,GACpB,MAAClO,EAAA,MAAOjQ,EAAA,KAAOqE,EAAA,KAAM8D,GAAQipC,GAAShzB,EAAQQ,EAASkF,GACvD6tB,EA9CR,SAAuBjrC,GACrB,OAAIA,EAAQkrC,QACHC,EAAAA,GAGLnrC,EAAQorC,SAA8C,aAAnCprC,EAAQqrC,uBACtBC,EAAAA,GAGFzU,EACT,CAoCqB0U,CAAcvrC,GAEjC,IACI7F,EAAGse,EAAO/O,GADV,KAACkG,GAAO,EAAI,QAAEzO,GAAWic,GAAU,CAAC,EAGxC,IAAKjjB,EAAI,EAAGA,GAAKsH,IAAQtH,EACvBse,EAAQf,GAAQpe,GAAS6H,EAAUM,EAAOtH,EAAIA,IAAMoP,GAEhDkP,EAAMC,OAGC9I,GACT/K,EAAI+xB,OAAOne,EAAMhS,EAAGgS,EAAM/R,GAC1BkJ,GAAO,GAEPq7B,EAAWpmC,EAAK6E,EAAM+O,EAAOtX,EAASnB,EAAQkrC,SAGhDxhC,EAAO+O,GAQT,OALI9a,IACF8a,EAAQf,GAAQpe,GAAS6H,EAAUM,EAAO,IAAM8H,GAChD0hC,EAAWpmC,EAAK6E,EAAM+O,EAAOtX,EAASnB,EAAQkrC,YAGvCvtC,CACX,CAiBA,SAAS6tC,GAAgB3mC,EAAK4S,EAAMS,EAASkF,GAC3C,MAAM1F,EAASD,EAAKC,QACd,MAACnO,EAAK,MAAEjQ,EAAK,KAAEmI,GAAQipC,GAAShzB,EAAQQ,EAASkF,IACjD,KAACxN,GAAO,EAAI,QAAEzO,GAAWic,GAAU,CAAC,EAC1C,IAEIjjB,EAAGse,EAAOgzB,EAAOC,EAAMC,EAAMC,EAF7BC,EAAO,EACPC,EAAS,EAGb,MAAMC,EAAcrqC,IAAWpI,GAAS6H,EAAUM,EAAOC,EAAQA,IAAU6H,EACrEyiC,EAAQA,KACRN,IAASC,IAEX9mC,EAAIgyB,OAAOgV,EAAMF,GACjB9mC,EAAIgyB,OAAOgV,EAAMH,GAGjB7mC,EAAIgyB,OAAOgV,EAAMD,KASrB,IALIh8B,IACF6I,EAAQf,EAAOq0B,EAAW,IAC1BlnC,EAAI+xB,OAAOne,EAAMhS,EAAGgS,EAAM/R,IAGvBvM,EAAI,EAAGA,GAAKsH,IAAQtH,EAAG,CAG1B,GAFAse,EAAQf,EAAOq0B,EAAW5xC,IAEtBse,EAAMC,KAER,SAGF,MAAMjS,EAAIgS,EAAMhS,EACVC,EAAI+R,EAAM/R,EACVulC,EAAa,EAAJxlC,EAEXwlC,IAAWR,GAET/kC,EAAIglC,EACNA,EAAOhlC,EACEA,EAAIilC,IACbA,EAAOjlC,GAGTmlC,GAAQC,EAASD,EAAOplC,KAAOqlC,IAE/BE,IAGAnnC,EAAIgyB,OAAOpwB,EAAGC,GAEd+kC,EAAQQ,EACRH,EAAS,EACTJ,EAAOC,EAAOjlC,GAGhBklC,EAAQllC,CACV,CACAslC,GACF,CAOA,SAASE,GAAkBz0B,GACzB,MAAMvW,EAAOuW,EAAKzX,QACZ8zB,EAAa5yB,EAAK4yB,YAAc5yB,EAAK4yB,WAAW75B,OAEtD,OADqBwd,EAAKO,YAAeP,EAAK/Z,OAAUwD,EAAKkqC,SAA2C,aAAhClqC,EAAKmqC,wBAA0CnqC,EAAKgqC,SAAYpX,EACjGkX,GAAlBQ,EACvB,CA2CA,MAAMW,GAA8B,mBAAXC,OAUV,MAAMC,WAAoB5lB,GAEvC9hB,UAAY,OAKZA,gBAAkB,CAChB0lC,eAAgB,OAChBvW,WAAY,GACZE,iBAAkB,EAClBuW,gBAAiB,QACjBtyB,YAAa,EACbq0B,iBAAiB,EACjBjB,uBAAwB,UACxBplC,MAAM,EACNuR,UAAU,EACV0zB,SAAS,EACTE,QAAS,GAMXzmC,qBAAuB,CACrBmxB,gBAAiB,kBACjB0U,YAAa,eAIf7lC,mBAAqB,CACnB4nC,aAAa,EACbC,WAAa92B,GAAkB,eAATA,GAAkC,SAATA,GAIjD3d,YAAY8E,GACVsX,QAEAnc,KAAKmgB,UAAW,EAChBngB,KAAKgI,aAAU1H,EACfN,KAAK8G,YAASxG,EACdN,KAAK0F,WAAQpF,EACbN,KAAKy0C,eAAYn0C,EACjBN,KAAK00C,WAAQp0C,EACbN,KAAK20C,aAAUr0C,EACfN,KAAK40C,eAAYt0C,EACjBN,KAAKggB,YAAa,EAClBhgB,KAAK60C,gBAAiB,EACtB70C,KAAK+f,mBAAgBzf,EAEjBuE,GACFsC,OAAOe,OAAOlI,KAAM6E,EAExB,CAEAoc,oBAAoBrM,EAAWzF,GAC7B,MAAMnH,EAAUhI,KAAKgI,QACrB,IAAKA,EAAQorC,SAA8C,aAAnCprC,EAAQqrC,0BAA2CrrC,EAAQkrC,UAAYlzC,KAAK60C,eAAgB,CAClH,MAAMlvC,EAAOqC,EAAQwX,SAAWxf,KAAK0F,MAAQ1F,KAAKy0C,WAClDK,EAAAA,EAAAA,IAA2B90C,KAAK20C,QAAS3sC,EAAS4M,EAAWjP,EAAMwJ,GACnEnP,KAAK60C,gBAAiB,EAE1B,CAEIn1B,WAAOA,GACT1f,KAAK20C,QAAUj1B,SACR1f,KAAK40C,iBACL50C,KAAK00C,MACZ10C,KAAK60C,gBAAiB,CACxB,CAEIn1B,aACF,OAAO1f,KAAK20C,OACd,CAEII,eACF,OAAO/0C,KAAK40C,YAAc50C,KAAK40C,WAAYI,EAAAA,EAAAA,IAAiBh1C,KAAMA,KAAKgI,QAAQkY,SACjF,CAMAgV,QACE,MAAM6f,EAAW/0C,KAAK+0C,SAChBr1B,EAAS1f,KAAK0f,OACpB,OAAOq1B,EAAS9yC,QAAUyd,EAAOq1B,EAAS,GAAGzzC,MAC/C,CAMA6b,OACE,MAAM43B,EAAW/0C,KAAK+0C,SAChBr1B,EAAS1f,KAAK0f,OACdnO,EAAQwjC,EAAS9yC,OACvB,OAAOsP,GAASmO,EAAOq1B,EAASxjC,EAAQ,GAAGnI,IAC7C,CASA6rC,YAAYx0B,EAAO2gB,GACjB,MAAMp5B,EAAUhI,KAAKgI,QACfa,EAAQ4X,EAAM2gB,GACd1hB,EAAS1f,KAAK0f,OACdq1B,GAAWG,EAAAA,EAAAA,IAAel1C,KAAM,CAACohC,WAAU9/B,MAAOuH,EAAOO,IAAKP,IAEpE,IAAKksC,EAAS9yC,OACZ,OAGF,MAAMytB,EAAS,GACTylB,EAvKV,SAAiCntC,GAC/B,OAAIA,EAAQkrC,QACHkC,EAAAA,GAGLptC,EAAQorC,SAA8C,aAAnCprC,EAAQqrC,uBACtBgC,EAAAA,GAGFC,EAAAA,EACT,CA6JyBC,CAAwBvtC,GAC7C,IAAI7F,EAAGsH,EACP,IAAKtH,EAAI,EAAGsH,EAAOsrC,EAAS9yC,OAAQE,EAAIsH,IAAQtH,EAAG,CACjD,MAAM,MAACb,EAAA,IAAO8H,GAAO2rC,EAAS5yC,GACxBm8B,EAAK5e,EAAOpe,GACZi9B,EAAK7e,EAAOtW,GAClB,GAAIk1B,IAAOC,EAAI,CACb7O,EAAOxsB,KAAKo7B,GACZ,SAEF,MACMkX,EAAeL,EAAa7W,EAAIC,EAD5Bn9B,KAAKmY,KAAK1Q,EAAQy1B,EAAG8C,KAAc7C,EAAG6C,GAAY9C,EAAG8C,KAClBp5B,EAAQkrC,SACrDsC,EAAapU,GAAY3gB,EAAM2gB,GAC/B1R,EAAOxsB,KAAKsyC,EACd,CACA,OAAyB,IAAlB9lB,EAAOztB,OAAeytB,EAAO,GAAKA,CAC3C,CAgBAsjB,YAAYnmC,EAAKqT,EAASkF,GAExB,OADsB8uB,GAAkBl0C,KACjCy1C,CAAc5oC,EAAK7M,KAAMkgB,EAASkF,EAC3C,CASAswB,KAAK7oC,EAAKvL,EAAOiQ,GACf,MAAMwjC,EAAW/0C,KAAK+0C,SAChBU,EAAgBvB,GAAkBl0C,MACxC,IAAI2F,EAAO3F,KAAK0F,MAEhBpE,EAAQA,GAAS,EACjBiQ,EAAQA,GAAUvR,KAAK0f,OAAOzd,OAASX,EAEvC,IAAK,MAAM4e,KAAW60B,EACpBpvC,GAAQ8vC,EAAc5oC,EAAK7M,KAAMkgB,EAAS,CAAC5e,QAAO8H,IAAK9H,EAAQiQ,EAAQ,IAEzE,QAAS5L,CACX,CASAvD,KAAKyK,EAAK+H,EAAWtT,EAAOiQ,GAC1B,MAAMvJ,EAAUhI,KAAKgI,SAAW,CAAC,GAClBhI,KAAK0f,QAAU,IAEnBzd,QAAU+F,EAAQiY,cAC3BpT,EAAIkxB,OArMV,SAAclxB,EAAK4S,EAAMne,EAAOiQ,GAC1B4iC,KAAc10B,EAAKzX,QAAQkY,QA7BjC,SAA6BrT,EAAK4S,EAAMne,EAAOiQ,GAC7C,IAAImkC,EAAOj2B,EAAKi1B,MACXgB,IACHA,EAAOj2B,EAAKi1B,MAAQ,IAAIN,OACpB30B,EAAKi2B,KAAKA,EAAMp0C,EAAOiQ,IACzBmkC,EAAKC,aAGTxD,GAAStlC,EAAK4S,EAAKzX,SACnB6E,EAAIiyB,OAAO4W,EACb,CAoBIE,CAAoB/oC,EAAK4S,EAAMne,EAAOiQ,GAlB1C,SAA0B1E,EAAK4S,EAAMne,EAAOiQ,GAC1C,MAAM,SAACwjC,EAAA,QAAU/sC,GAAWyX,EACtBg2B,EAAgBvB,GAAkBz0B,GAExC,IAAK,MAAMS,KAAW60B,EACpB5C,GAAStlC,EAAK7E,EAASkY,EAAQuN,OAC/B5gB,EAAI8xB,YACA8W,EAAc5oC,EAAK4S,EAAMS,EAAS,CAAC5e,QAAO8H,IAAK9H,EAAQiQ,EAAQ,KACjE1E,EAAI8oC,YAEN9oC,EAAIiyB,QAER,CAQI+W,CAAiBhpC,EAAK4S,EAAMne,EAAOiQ,EAEvC,CAiMMnP,CAAKyK,EAAK7M,KAAMsB,EAAOiQ,GAEvB1E,EAAIqxB,WAGFl+B,KAAKmgB,WAEPngB,KAAK60C,gBAAiB,EACtB70C,KAAK00C,WAAQp0C,EAEjB,ECjbF,SAASw1C,GAAQr0B,EAAkBgD,EAAalZ,EAAiB4W,GAC/D,MAAMna,EAAUyZ,EAAGzZ,SACZ,CAACuD,GAAO1C,GAAS4Y,EAAGgC,SAAS,CAAClY,GAAO4W,GAE5C,OAAQ/gB,KAAKmY,IAAIkL,EAAM5b,GAASb,EAAQ+tC,OAAS/tC,EAAQguC,SAC3D,CAIe,MAAMC,WAAqBxnB,GAExC9hB,UAAY,QAEZzB,OACAwV,KACAhd,KAKAiJ,gBAAkB,CAChBsT,YAAa,EACb+1B,UAAW,EACXE,iBAAkB,EAClBC,YAAa,EACbC,WAAY,SACZL,OAAQ,EACRvZ,SAAU,GAMZ7vB,qBAAuB,CACrBmxB,gBAAiB,kBACjB0U,YAAa,eAGfzyC,YAAY8E,GACVsX,QAEAnc,KAAKgI,aAAU1H,EACfN,KAAKkL,YAAS5K,EACdN,KAAK0gB,UAAOpgB,EACZN,KAAK0D,UAAOpD,EAERuE,GACFsC,OAAOe,OAAOlI,KAAM6E,EAExB,CAEA0d,QAAQ8zB,EAAgBC,EAAgBn0B,GACtC,MAAMna,EAAUhI,KAAKgI,SACf,EAACyG,EAAA,EAAGC,GAAK1O,KAAKyjB,SAAS,CAAC,IAAK,KAAMtB,GACzC,OAAS/gB,KAAK6hB,IAAIozB,EAAS5nC,EAAG,GAAKrN,KAAK6hB,IAAIqzB,EAAS5nC,EAAG,GAAMtN,KAAK6hB,IAAIjb,EAAQguC,UAAYhuC,EAAQ+tC,OAAQ,EAC7G,CAEAQ,SAASF,EAAgBl0B,GACvB,OAAO2zB,GAAQ91C,KAAMq2C,EAAQ,IAAKl0B,EACpC,CAEAq0B,SAASF,EAAgBn0B,GACvB,OAAO2zB,GAAQ91C,KAAMs2C,EAAQ,IAAKn0B,EACpC,CAEAiB,eAAejB,GACb,MAAM,EAAC1T,EAAA,EAAGC,GAAK1O,KAAKyjB,SAAS,CAAC,IAAK,KAAMtB,GACzC,MAAO,CAAC1T,IAAGC,IACb,CAEA5F,KAAKd,GAEH,IAAI+tC,GADJ/tC,EAAUA,GAAWhI,KAAKgI,SAAW,CAAC,GACjB+tC,QAAU,EAG/B,OAFAA,EAAS30C,KAAKoC,IAAIuyC,EAAQA,GAAU/tC,EAAQmuC,aAAe,GAE3B,GAAxBJ,GADYA,GAAU/tC,EAAQiY,aAAe,GAEvD,CAEA7d,KAAKyK,EAA+B8H,GAClC,MAAM3M,EAAUhI,KAAKgI,QAEjBhI,KAAK0gB,MAAQ1Y,EAAQ+tC,OAAS,MAAQzzB,EAAAA,EAAAA,GAAetiB,KAAM2U,EAAM3U,KAAK8I,KAAKd,GAAW,KAI1F6E,EAAI2xB,YAAcx2B,EAAQwqC,YAC1B3lC,EAAI+uB,UAAY5zB,EAAQiY,YACxBpT,EAAImxB,UAAYh2B,EAAQ81B,iBACxB2Y,EAAAA,EAAAA,IAAU5pC,EAAK7E,EAAShI,KAAKyO,EAAGzO,KAAK0O,GACvC,CAEAgT,WACE,MAAM1Z,EAAUhI,KAAKgI,SAAW,CAAC,EAEjC,OAAOA,EAAQ+tC,OAAS/tC,EAAQguC,SAClC,EC3FF,SAASU,GAAaC,EAAKx0B,GACzB,MAAM,EAAC1T,EAAC,EAAEC,EAAC,KAAEgM,EAAA,MAAMuC,EAAA,OAAOD,GAAmC25B,EAAIlzB,SAAS,CAAC,IAAK,IAAK,OAAQ,QAAS,UAAWtB,GAEjH,IAAI9N,EAAMF,EAAOD,EAAKE,EAAQwiC,EAgB9B,OAdID,EAAIl8B,YACNm8B,EAAO55B,EAAS,EAChB3I,EAAOjT,KAAKC,IAAIoN,EAAGiM,GACnBvG,EAAQ/S,KAAKoC,IAAIiL,EAAGiM,GACpBxG,EAAMxF,EAAIkoC,EACVxiC,EAAS1F,EAAIkoC,IAEbA,EAAO35B,EAAQ,EACf5I,EAAO5F,EAAImoC,EACXziC,EAAQ1F,EAAImoC,EACZ1iC,EAAM9S,KAAKC,IAAIqN,EAAGgM,GAClBtG,EAAShT,KAAKoC,IAAIkL,EAAGgM,IAGhB,CAACrG,OAAMH,MAAKC,QAAOC,SAC5B,CAEA,SAASyiC,GAAYn2B,EAAM7X,EAAOxH,EAAKmC,GACrC,OAAOkd,EAAO,GAAI0W,EAAAA,EAAAA,GAAYvuB,EAAOxH,EAAKmC,EAC5C,CAgEA,SAAS+e,GAAQo0B,EAAKloC,EAAGC,EAAGyT,GAC1B,MAAM20B,EAAc,OAANroC,EACRsoC,EAAc,OAANroC,EAERsoC,EAASL,KADEG,GAASC,IACSL,GAAaC,EAAKx0B,GAErD,OAAO60B,IACHF,IAASG,EAAAA,EAAAA,IAAWxoC,EAAGuoC,EAAO3iC,KAAM2iC,EAAO7iC,UAC3C4iC,IAASE,EAAAA,EAAAA,IAAWvoC,EAAGsoC,EAAO9iC,IAAK8iC,EAAO5iC,QAChD,CAWA,SAAS8iC,GAAkBrqC,EAAKsqC,GAC9BtqC,EAAIsqC,KAAKA,EAAK1oC,EAAG0oC,EAAKzoC,EAAGyoC,EAAKvxB,EAAGuxB,EAAKrxB,EACxC,CAEA,SAASsxB,GAAYD,EAAME,EAAQC,EAAU,IAC3C,MAAM7oC,EAAI0oC,EAAK1oC,IAAM6oC,EAAQ7oC,GAAK4oC,EAAS,EACrC3oC,EAAIyoC,EAAKzoC,IAAM4oC,EAAQ5oC,GAAK2oC,EAAS,EACrCzxB,GAAKuxB,EAAK1oC,EAAI0oC,EAAKvxB,IAAM0xB,EAAQ7oC,EAAI6oC,EAAQ1xB,EAAIyxB,EAAS,GAAK5oC,EAC/DqX,GAAKqxB,EAAKzoC,EAAIyoC,EAAKrxB,IAAMwxB,EAAQ5oC,EAAI4oC,EAAQxxB,EAAIuxB,EAAS,GAAK3oC,EACrE,MAAO,CACLD,EAAG0oC,EAAK1oC,EAAIA,EACZC,EAAGyoC,EAAKzoC,EAAIA,EACZkX,EAAGuxB,EAAKvxB,EAAIA,EACZE,EAAGqxB,EAAKrxB,EAAIA,EACZiwB,OAAQoB,EAAKpB,OAEjB,CAEe,MAAMwB,WAAmB9oB,GAEtC9hB,UAAY,MAKZA,gBAAkB,CAChB6N,cAAe,QACfyF,YAAa,EACbu3B,aAAc,EACdp8B,cAAe,OACfg7B,gBAAY91C,GAMdqM,qBAAuB,CACrBmxB,gBAAiB,kBACjB0U,YAAa,eAGfzyC,YAAY8E,GACVsX,QAEAnc,KAAKgI,aAAU1H,EACfN,KAAKya,gBAAana,EAClBN,KAAK0a,UAAOpa,EACZN,KAAKid,WAAQ3c,EACbN,KAAKgd,YAAS1c,EACdN,KAAKob,mBAAgB9a,EAEjBuE,GACFsC,OAAOe,OAAOlI,KAAM6E,EAExB,CAEAzC,KAAKyK,GACH,MAAM,cAACuO,EAAepT,SAAS,YAACwqC,EAAA,gBAAa1U,IAAoB99B,MAC3D,MAACy3C,EAAK,MAAEC,GA5GlB,SAAuBf,GACrB,MAAMK,EAASN,GAAaC,GACtB15B,EAAQ+5B,EAAO7iC,MAAQ6iC,EAAO3iC,KAC9B2I,EAASg6B,EAAO5iC,OAAS4iC,EAAO9iC,IAChC4M,EApCR,SAA0B61B,EAAKgB,EAAMC,GACnC,MAAM/uC,EAAQ8tC,EAAI3uC,QAAQiY,YACpBS,EAAOi2B,EAAIn8B,cACXq9B,GAAIC,EAAAA,EAAAA,IAAOjvC,GAEjB,MAAO,CACLkL,EAAG8iC,GAAYn2B,EAAKxM,IAAK2jC,EAAE3jC,IAAK,EAAG0jC,GACnCjpC,EAAGkoC,GAAYn2B,EAAKvM,MAAO0jC,EAAE1jC,MAAO,EAAGwjC,GACvC3jC,EAAG6iC,GAAYn2B,EAAKtM,OAAQyjC,EAAEzjC,OAAQ,EAAGwjC,GACzC3jC,EAAG4iC,GAAYn2B,EAAKrM,KAAMwjC,EAAExjC,KAAM,EAAGsjC,GAEzC,CAyBiBI,CAAiBpB,EAAK15B,EAAQ,EAAGD,EAAS,GACnD+4B,EAxBR,SAA2BY,EAAKgB,EAAMC,GACpC,MAAM,mBAACh9B,GAAsB+7B,EAAIlzB,SAAS,CAAC,uBACrC5a,EAAQ8tC,EAAI3uC,QAAQwvC,aACpBK,GAAIG,EAAAA,EAAAA,IAAcnvC,GAClBovC,EAAO72C,KAAKC,IAAIs2C,EAAMC,GACtBl3B,EAAOi2B,EAAIn8B,cAIX09B,EAAet9B,IAAsB3T,EAAAA,EAAAA,GAAS4B,GAEpD,MAAO,CACLsvC,QAAStB,IAAaqB,GAAgBx3B,EAAKxM,KAAOwM,EAAKrM,KAAMwjC,EAAEM,QAAS,EAAGF,GAC3EG,SAAUvB,IAAaqB,GAAgBx3B,EAAKxM,KAAOwM,EAAKvM,MAAO0jC,EAAEO,SAAU,EAAGH,GAC9EI,WAAYxB,IAAaqB,GAAgBx3B,EAAKtM,QAAUsM,EAAKrM,KAAMwjC,EAAEQ,WAAY,EAAGJ,GACpFK,YAAazB,IAAaqB,GAAgBx3B,EAAKtM,QAAUsM,EAAKvM,MAAO0jC,EAAES,YAAa,EAAGL,GAE3F,CAOiBM,CAAkB5B,EAAK15B,EAAQ,EAAGD,EAAS,GAE1D,MAAO,CACL06B,MAAO,CACLjpC,EAAGuoC,EAAO3iC,KACV3F,EAAGsoC,EAAO9iC,IACV0R,EAAG3I,EACH6I,EAAG9I,EACH+4B,UAEF0B,MAAO,CACLhpC,EAAGuoC,EAAO3iC,KAAOyM,EAAO7M,EACxBvF,EAAGsoC,EAAO9iC,IAAM4M,EAAO/M,EACvB6R,EAAG3I,EAAQ6D,EAAO7M,EAAI6M,EAAOnS,EAC7BmX,EAAG9I,EAAS8D,EAAO/M,EAAI+M,EAAO9M,EAC9B+hC,OAAQ,CACNoC,QAAS/2C,KAAKoC,IAAI,EAAGuyC,EAAOoC,QAAU/2C,KAAKoC,IAAIsd,EAAO/M,EAAG+M,EAAO7M,IAChEmkC,SAAUh3C,KAAKoC,IAAI,EAAGuyC,EAAOqC,SAAWh3C,KAAKoC,IAAIsd,EAAO/M,EAAG+M,EAAOnS,IAClE0pC,WAAYj3C,KAAKoC,IAAI,EAAGuyC,EAAOsC,WAAaj3C,KAAKoC,IAAIsd,EAAO9M,EAAG8M,EAAO7M,IACtEqkC,YAAal3C,KAAKoC,IAAI,EAAGuyC,EAAOuC,YAAcl3C,KAAKoC,IAAIsd,EAAO9M,EAAG8M,EAAOnS,MAIhF,CAgF2B6pC,CAAcx4C,MAC/By4C,GApES1C,EAoEe2B,EAAM3B,QAnExBoC,SAAWpC,EAAOqC,UAAYrC,EAAOsC,YAActC,EAAOuC,YAmExBI,EAAAA,GAAqBxB,GApEvE,IAAmBnB,EAsEflpC,EAAIkxB,OAEA2Z,EAAM9xB,IAAM6xB,EAAM7xB,GAAK8xB,EAAM5xB,IAAM2xB,EAAM3xB,IAC3CjZ,EAAI8xB,YACJ8Z,EAAY5rC,EAAKuqC,GAAYM,EAAOt8B,EAAeq8B,IACnD5qC,EAAI2H,OACJikC,EAAY5rC,EAAKuqC,GAAYK,GAAQr8B,EAAes8B,IACpD7qC,EAAImxB,UAAYwU,EAChB3lC,EAAIoB,KAAK,YAGXpB,EAAI8xB,YACJ8Z,EAAY5rC,EAAKuqC,GAAYK,EAAOr8B,IACpCvO,EAAImxB,UAAYF,EAChBjxB,EAAIoB,OAEJpB,EAAIqxB,SACN,CAEA3b,QAAQ8zB,EAAQC,EAAQn0B,GACtB,OAAOI,GAAQviB,KAAMq2C,EAAQC,EAAQn0B,EACvC,CAEAo0B,SAASF,EAAQl0B,GACf,OAAOI,GAAQviB,KAAMq2C,EAAQ,KAAMl0B,EACrC,CAEAq0B,SAASF,EAAQn0B,GACf,OAAOI,GAAQviB,KAAM,KAAMs2C,EAAQn0B,EACrC,CAEAiB,eAAejB,GACb,MAAM,EAAC1T,EAAA,EAAGC,EAAA,KAAGgM,EAAI,WAAED,GAAuCza,KAAKyjB,SAAS,CAAC,IAAK,IAAK,OAAQ,cAAetB,GAC1G,MAAO,CACL1T,EAAGgM,GAAchM,EAAIiM,GAAQ,EAAIjM,EACjCC,EAAG+L,EAAa/L,GAAKA,EAAIgM,GAAQ,EAErC,CAEAgH,SAASnW,GACP,MAAgB,MAATA,EAAevL,KAAKid,MAAQ,EAAIjd,KAAKgd,OAAS,CACvD,ECzMF,MAAM27B,GAAaA,CAACC,EAAWzY,KAC7B,IAAI,UAAC0Y,EAAY1Y,EAAA,SAAU2Y,EAAW3Y,GAAYyY,EAOlD,OALIA,EAAUG,gBACZF,EAAYz3C,KAAKC,IAAIw3C,EAAW1Y,GAChC2Y,EAAWF,EAAUI,iBAAmB53C,KAAKC,IAAIy3C,EAAU3Y,IAGtD,CACL2Y,WACAD,YACAI,WAAY73C,KAAKoC,IAAI28B,EAAU0Y,GAChC,EAKI,MAAMK,WAAezqB,GAK1B1uB,YAAY8G,GACVsV,QAEAnc,KAAKm5C,QAAS,EAGdn5C,KAAKo5C,eAAiB,GAKtBp5C,KAAKq5C,aAAe,KAGpBr5C,KAAKs5C,cAAe,EAEpBt5C,KAAKQ,MAAQqG,EAAOrG,MACpBR,KAAKgI,QAAUnB,EAAOmB,QACtBhI,KAAK6M,IAAMhG,EAAOgG,IAClB7M,KAAKu5C,iBAAcj5C,EACnBN,KAAKw5C,iBAAcl5C,EACnBN,KAAKy5C,gBAAan5C,EAClBN,KAAKkxB,eAAY5wB,EACjBN,KAAKixB,cAAW3wB,EAChBN,KAAKkU,SAAM5T,EACXN,KAAKoU,YAAS9T,EACdN,KAAKqU,UAAO/T,EACZN,KAAKmU,WAAQ7T,EACbN,KAAKgd,YAAS1c,EACdN,KAAKid,WAAQ3c,EACbN,KAAKgxB,cAAW1wB,EAChBN,KAAK8hB,cAAWxhB,EAChBN,KAAK8kB,YAASxkB,EACdN,KAAK0mB,cAAWpmB,CAClB,CAEA4F,OAAO+qB,EAAUC,EAAWgC,GAC1BlzB,KAAKixB,SAAWA,EAChBjxB,KAAKkxB,UAAYA,EACjBlxB,KAAKgxB,SAAWkC,EAEhBlzB,KAAKuzB,gBACLvzB,KAAK05C,cACL15C,KAAK61B,KACP,CAEAtC,gBACMvzB,KAAKsc,gBACPtc,KAAKid,MAAQjd,KAAKixB,SAClBjxB,KAAKqU,KAAOrU,KAAKgxB,SAAS3c,KAC1BrU,KAAKmU,MAAQnU,KAAKid,QAElBjd,KAAKgd,OAAShd,KAAKkxB,UACnBlxB,KAAKkU,IAAMlU,KAAKgxB,SAAS9c,IACzBlU,KAAKoU,OAASpU,KAAKgd,OAEvB,CAEA08B,cACE,MAAMd,EAAY54C,KAAKgI,QAAQ+J,QAAU,CAAC,EAC1C,IAAIwnC,GAActmB,EAAAA,EAAAA,GAAK2lB,EAAUe,eAAgB,CAAC35C,KAAKQ,OAAQR,OAAS,GAEpE44C,EAAU1sC,SACZqtC,EAAcA,EAAYrtC,QAAQhK,GAAS02C,EAAU1sC,OAAOhK,EAAMlC,KAAKQ,MAAMoP,SAG3EgpC,EAAU3/B,OACZsgC,EAAcA,EAAYtgC,MAAK,CAACC,EAAGlF,IAAM4kC,EAAU3/B,KAAKC,EAAGlF,EAAGhU,KAAKQ,MAAMoP,SAGvE5P,KAAKgI,QAAQmB,SACfowC,EAAYpwC,UAGdnJ,KAAKu5C,YAAcA,CACrB,CAEA1jB,MACE,MAAM,QAAC7tB,EAAO,IAAE6E,GAAO7M,KAMvB,IAAKgI,EAAQ0gB,QAEX,YADA1oB,KAAKid,MAAQjd,KAAKgd,OAAS,GAI7B,MAAM47B,EAAY5wC,EAAQ+J,OACpB6nC,GAAYppB,EAAAA,EAAAA,IAAOooB,EAAUroB,MAC7B4P,EAAWyZ,EAAU9wC,KACrB6uB,EAAc33B,KAAK65C,uBACnB,SAACf,EAAQ,WAAEG,GAAcN,GAAWC,EAAWzY,GAErD,IAAIljB,EAAOD,EAEXnQ,EAAI0jB,KAAOqpB,EAAUtgB,OAEjBt5B,KAAKsc,gBACPW,EAAQjd,KAAKixB,SACbjU,EAAShd,KAAK85C,SAASniB,EAAawI,EAAU2Y,EAAUG,GAAc,KAEtEj8B,EAAShd,KAAKkxB,UACdjU,EAAQjd,KAAK+5C,SAASpiB,EAAaiiB,EAAWd,EAAUG,GAAc,IAGxEj5C,KAAKid,MAAQ7b,KAAKC,IAAI4b,EAAOjV,EAAQipB,UAAYjxB,KAAKixB,UACtDjxB,KAAKgd,OAAS5b,KAAKC,IAAI2b,EAAQhV,EAAQkpB,WAAalxB,KAAKkxB,UAC3D,CAKA4oB,SAASniB,EAAawI,EAAU2Y,EAAUG,GACxC,MAAM,IAACpsC,EAAG,SAAEokB,EAAUjpB,SAAU+J,QAAQ,QAAC+U,KAAa9mB,KAChDg6C,EAAWh6C,KAAKo5C,eAAiB,GAEjCK,EAAaz5C,KAAKy5C,WAAa,CAAC,GAChC/oB,EAAauoB,EAAanyB,EAChC,IAAImzB,EAActiB,EAElB9qB,EAAI4vB,UAAY,OAChB5vB,EAAI+vB,aAAe,SAEnB,IAAIsd,GAAO,EACPhmC,GAAOwc,EAgBX,OAfA1wB,KAAKu5C,YAAYv4C,SAAQ,CAACm5C,EAAYh4C,KACpC,MAAMi4C,EAAYtB,EAAY3Y,EAAW,EAAKtzB,EAAIwtC,YAAYF,EAAW1pB,MAAMxT,OAErE,IAAN9a,GAAWs3C,EAAWA,EAAWx3C,OAAS,GAAKm4C,EAAY,EAAItzB,EAAUmK,KAC3EgpB,GAAevpB,EACf+oB,EAAWA,EAAWx3C,QAAUE,EAAI,EAAI,EAAI,IAAM,EAClD+R,GAAOwc,EACPwpB,KAGFF,EAAS73C,GAAK,CAACkS,KAAM,EAAGH,MAAKgmC,MAAKj9B,MAAOm9B,EAAWp9B,OAAQi8B,GAE5DQ,EAAWA,EAAWx3C,OAAS,IAAMm4C,EAAYtzB,CAAA,IAG5CmzB,CACT,CAEAF,SAASpiB,EAAaiiB,EAAWd,EAAUwB,GACzC,MAAM,IAACztC,EAAG,UAAEqkB,EAAWlpB,SAAU+J,QAAQ,QAAC+U,KAAa9mB,KACjDg6C,EAAWh6C,KAAKo5C,eAAiB,GACjCI,EAAcx5C,KAAKw5C,YAAc,GACjCe,EAAcrpB,EAAYyG,EAEhC,IAAI6iB,EAAa1zB,EACb2zB,EAAkB,EAClBC,EAAmB,EAEnBrmC,EAAO,EACPsmC,EAAM,EAyBV,OAvBA36C,KAAKu5C,YAAYv4C,SAAQ,CAACm5C,EAAYh4C,KACpC,MAAM,UAACi4C,EAAS,WAAEnB,GA8VxB,SAA2BH,EAAUc,EAAW/sC,EAAKstC,EAAYG,GAC/D,MAAMF,EAKR,SAA4BD,EAAYrB,EAAUc,EAAW/sC,GAC3D,IAAI+tC,EAAiBT,EAAW1pB,KAIhC,OAHImqB,GAA4C,iBAAnBA,IAC3BA,EAAiBA,EAAev3C,QAAO,CAAC6V,EAAGlF,IAAMkF,EAAEjX,OAAS+R,EAAE/R,OAASiX,EAAIlF,KAEtE8kC,EAAYc,EAAU9wC,KAAO,EAAK+D,EAAIwtC,YAAYO,GAAgB39B,KAC3E,CAXoB49B,CAAmBV,EAAYrB,EAAUc,EAAW/sC,GAChEosC,EAYR,SAA6BqB,EAAaH,EAAYW,GACpD,IAAI7B,EAAaqB,EAIjB,MAH+B,iBAApBH,EAAW1pB,OACpBwoB,EAAa8B,GAA0BZ,EAAYW,IAE9C7B,CACT,CAlBqB+B,CAAoBV,EAAaH,EAAYP,EAAUlpB,YAC1E,MAAO,CAAC0pB,YAAWnB,aACrB,CAlWsCgC,CAAkBnC,EAAUc,EAAW/sC,EAAKstC,EAAYG,GAGpFn4C,EAAI,GAAKu4C,EAAmBzB,EAAa,EAAInyB,EAAUyzB,IACzDC,GAAcC,EAAkB3zB,EAChC0yB,EAAYt2C,KAAK,CAAC+Z,MAAOw9B,EAAiBz9B,OAAQ09B,IAClDrmC,GAAQomC,EAAkB3zB,EAC1B6zB,IACAF,EAAkBC,EAAmB,GAIvCV,EAAS73C,GAAK,CAACkS,OAAMH,IAAKwmC,EAAkBC,MAAK19B,MAAOm9B,EAAWp9B,OAAQi8B,GAG3EwB,EAAkBr5C,KAAKoC,IAAIi3C,EAAiBL,GAC5CM,GAAoBzB,EAAanyB,CAAA,IAGnC0zB,GAAcC,EACdjB,EAAYt2C,KAAK,CAAC+Z,MAAOw9B,EAAiBz9B,OAAQ09B,IAE3CF,CACT,CAEAU,iBACE,IAAKl7C,KAAKgI,QAAQ0gB,QAChB,OAEF,MAAMiP,EAAc33B,KAAK65C,uBAClBT,eAAgBY,EAAUhyC,SAAS,MAAC4oB,EAAO7e,QAAQ,QAAC+U,GAAQ,IAAEq0B,IAAQn7C,KACvEo7C,GAAYC,EAAAA,EAAAA,IAAcF,EAAKn7C,KAAKqU,KAAMrU,KAAKid,OACrD,GAAIjd,KAAKsc,eAAgB,CACvB,IAAI49B,EAAM,EACN7lC,GAAOqrB,EAAAA,EAAAA,IAAe9O,EAAO5wB,KAAKqU,KAAOyS,EAAS9mB,KAAKmU,MAAQnU,KAAKy5C,WAAWS,IACnF,IAAK,MAAMoB,KAAUtB,EACfE,IAAQoB,EAAOpB,MACjBA,EAAMoB,EAAOpB,IACb7lC,GAAOqrB,EAAAA,EAAAA,IAAe9O,EAAO5wB,KAAKqU,KAAOyS,EAAS9mB,KAAKmU,MAAQnU,KAAKy5C,WAAWS,KAEjFoB,EAAOpnC,KAAOlU,KAAKkU,IAAMyjB,EAAc7Q,EACvCw0B,EAAOjnC,KAAO+mC,EAAUG,WAAWH,EAAU3sC,EAAE4F,GAAOinC,EAAOr+B,OAC7D5I,GAAQinC,EAAOr+B,MAAQ6J,MAEpB,CACL,IAAI6zB,EAAM,EACNzmC,GAAMwrB,EAAAA,EAAAA,IAAe9O,EAAO5wB,KAAKkU,IAAMyjB,EAAc7Q,EAAS9mB,KAAKoU,OAASpU,KAAKw5C,YAAYmB,GAAK39B,QACtG,IAAK,MAAMs+B,KAAUtB,EACfsB,EAAOX,MAAQA,IACjBA,EAAMW,EAAOX,IACbzmC,GAAMwrB,EAAAA,EAAAA,IAAe9O,EAAO5wB,KAAKkU,IAAMyjB,EAAc7Q,EAAS9mB,KAAKoU,OAASpU,KAAKw5C,YAAYmB,GAAK39B,SAEpGs+B,EAAOpnC,IAAMA,EACbonC,EAAOjnC,MAAQrU,KAAKqU,KAAOyS,EAC3Bw0B,EAAOjnC,KAAO+mC,EAAUG,WAAWH,EAAU3sC,EAAE6sC,EAAOjnC,MAAOinC,EAAOr+B,OACpE/I,GAAOonC,EAAOt+B,OAAS8J,EAG7B,CAEAxK,eACE,MAAiC,QAA1Btc,KAAKgI,QAAQ8Z,UAAgD,WAA1B9hB,KAAKgI,QAAQ8Z,QACzD,CAEA1f,OACE,GAAIpC,KAAKgI,QAAQ0gB,QAAS,CACxB,MAAM7b,EAAM7M,KAAK6M,KACjBsyB,EAAAA,EAAAA,GAAStyB,EAAK7M,MAEdA,KAAKw7C,SAELlc,EAAAA,EAAAA,GAAWzyB,GAEf,CAKA2uC,QACE,MAAOxzC,QAASkB,EAAA,YAAMswC,EAAA,WAAaC,EAAA,IAAY5sC,GAAO7M,MAChD,MAAC4wB,EAAO7e,OAAQ6mC,GAAa1vC,EAC7BuyC,EAAep0C,EAAAA,EAAShD,MACxB+2C,GAAYC,EAAAA,EAAAA,IAAcnyC,EAAKiyC,IAAKn7C,KAAKqU,KAAMrU,KAAKid,OACpD28B,GAAYppB,EAAAA,EAAAA,IAAOooB,EAAUroB,OAC7B,QAACzJ,GAAW8xB,EACZzY,EAAWyZ,EAAU9wC,KACrB4yC,EAAevb,EAAW,EAChC,IAAIwb,EAEJ37C,KAAKu/B,YAGL1yB,EAAI4vB,UAAY2e,EAAU3e,UAAU,QACpC5vB,EAAI+vB,aAAe,SACnB/vB,EAAI+uB,UAAY,GAChB/uB,EAAI0jB,KAAOqpB,EAAUtgB,OAErB,MAAM,SAACwf,EAAA,UAAUD,EAAA,WAAWI,GAAcN,GAAWC,EAAWzY,GAyE1D7jB,EAAetc,KAAKsc,eACpBqb,EAAc33B,KAAK65C,sBAEvB8B,EADEr/B,EACO,CACP7N,GAAGixB,EAAAA,EAAAA,IAAe9O,EAAO5wB,KAAKqU,KAAOyS,EAAS9mB,KAAKmU,MAAQslC,EAAW,IACtE/qC,EAAG1O,KAAKkU,IAAM4S,EAAU6Q,EACxBlY,KAAM,GAGC,CACPhR,EAAGzO,KAAKqU,KAAOyS,EACfpY,GAAGgxB,EAAAA,EAAAA,IAAe9O,EAAO5wB,KAAKkU,IAAMyjB,EAAc7Q,EAAS9mB,KAAKoU,OAASolC,EAAY,GAAGx8B,QACxFyC,KAAM,IAIVm8B,EAAAA,EAAAA,IAAsB57C,KAAK6M,IAAK3D,EAAK2yC,eAErC,MAAMnrB,EAAauoB,EAAanyB,EAChC9mB,KAAKu5C,YAAYv4C,SAAQ,CAACm5C,EAAYh4C,KACpC0K,EAAI2xB,YAAc2b,EAAW2B,UAC7BjvC,EAAImxB,UAAYmc,EAAW2B,UAE3B,MAAMC,EAAYlvC,EAAIwtC,YAAYF,EAAW1pB,MAAMxT,MAC7Cwf,EAAY2e,EAAU3e,UAAU0d,EAAW1d,YAAc0d,EAAW1d,UAAYmc,EAAUnc,YAC1Fxf,EAAQ67B,EAAW4C,EAAeK,EACxC,IAAIttC,EAAIktC,EAAOltC,EACXC,EAAIitC,EAAOjtC,EAyBf,GAvBA0sC,EAAUY,SAASh8C,KAAKid,OAEpBX,EACEna,EAAI,GAAKsM,EAAIwO,EAAQ6J,EAAU9mB,KAAKmU,QACtCzF,EAAIitC,EAAOjtC,GAAKgiB,EAChBirB,EAAOl8B,OACPhR,EAAIktC,EAAOltC,GAAIixB,EAAAA,EAAAA,IAAe9O,EAAO5wB,KAAKqU,KAAOyS,EAAS9mB,KAAKmU,MAAQslC,EAAWkC,EAAOl8B,QAElFtd,EAAI,GAAKuM,EAAIgiB,EAAa1wB,KAAKoU,SACxC3F,EAAIktC,EAAOltC,EAAIA,EAAI+qC,EAAYmC,EAAOl8B,MAAMxC,MAAQ6J,EACpD60B,EAAOl8B,OACP/Q,EAAIitC,EAAOjtC,GAAIgxB,EAAAA,EAAAA,IAAe9O,EAAO5wB,KAAKkU,IAAMyjB,EAAc7Q,EAAS9mB,KAAKoU,OAASolC,EAAYmC,EAAOl8B,MAAMzC,SA9G5F,SAASvO,EAAGC,EAAGyrC,GACnC,GAAI78B,MAAMw7B,IAAaA,GAAY,GAAKx7B,MAAMu7B,IAAcA,EAAY,EACtE,OAIFhsC,EAAIkxB,OAEJ,MAAMnC,GAAY9sB,EAAAA,EAAAA,GAAeqrC,EAAWve,UAAW,GAUvD,GATA/uB,EAAImxB,WAAYlvB,EAAAA,EAAAA,GAAeqrC,EAAWnc,UAAWyd,GACrD5uC,EAAIulC,SAAUtjC,EAAAA,EAAAA,GAAeqrC,EAAW/H,QAAS,QACjDvlC,EAAI6xB,gBAAiB5vB,EAAAA,EAAAA,GAAeqrC,EAAWzb,eAAgB,GAC/D7xB,EAAIylC,UAAWxjC,EAAAA,EAAAA,GAAeqrC,EAAW7H,SAAU,SACnDzlC,EAAI+uB,UAAYA,EAChB/uB,EAAI2xB,aAAc1vB,EAAAA,EAAAA,GAAeqrC,EAAW3b,YAAaid,GAEzD5uC,EAAI4xB,aAAY3vB,EAAAA,EAAAA,GAAeqrC,EAAW8B,SAAU,KAEhDrD,EAAUG,cAAe,CAG3B,MAAMmD,EAAc,CAClBnG,OAAQ8C,EAAYz3C,KAAK+6C,MAAQ,EACjC/F,WAAY+D,EAAW/D,WACvB5Z,SAAU2d,EAAW3d,SACrBvc,YAAa2b,GAETwgB,EAAUhB,EAAUiB,MAAM5tC,EAAGqqC,EAAW,GACxCwD,EAAU5tC,EAAIgtC,GAGpBa,EAAAA,EAAAA,IAAgB1vC,EAAKqvC,EAAaE,EAASE,EAAS1D,EAAUI,iBAAmBF,OAC5E,CAGL,MAAM0D,EAAU9tC,EAAItN,KAAKoC,KAAK28B,EAAW0Y,GAAa,EAAG,GACnD4D,EAAWrB,EAAUG,WAAW9sC,EAAGqqC,GACnCtB,GAAeQ,EAAAA,EAAAA,IAAcmC,EAAW3C,cAE9C3qC,EAAI8xB,YAEAx3B,OAAOW,OAAO0vC,GAActS,MAAKhqB,GAAW,IAANA,KACxCw9B,EAAAA,EAAAA,IAAmB7rC,EAAK,CACtB4B,EAAGguC,EACH/tC,EAAG8tC,EACH52B,EAAGkzB,EACHhzB,EAAG+yB,EACH9C,OAAQyB,IAGV3qC,EAAIsqC,KAAKsF,EAAUD,EAAS1D,EAAUD,GAGxChsC,EAAIoB,OACc,IAAd2tB,GACF/uB,EAAIiyB,SAIRjyB,EAAIqxB,SACN,CAuDEwe,CAFctB,EAAU3sC,EAAEA,GAELC,EAAGyrC,GAExB1rC,GAAIkuC,EAAAA,EAAAA,IAAOlgB,EAAWhuB,EAAIqqC,EAAW4C,EAAcp/B,EAAe7N,EAAIwO,EAAQjd,KAAKmU,MAAOjL,EAAKiyC,KAvDhF,SAAS1sC,EAAGC,EAAGyrC,IAC9B9a,EAAAA,EAAAA,GAAWxyB,EAAKstC,EAAW1pB,KAAMhiB,EAAGC,EAAKuqC,EAAa,EAAIW,EAAW,CACnEgD,cAAezC,EAAWpnC,OAC1B0pB,UAAW2e,EAAU3e,UAAU0d,EAAW1d,YAE9C,CAqDEogB,CAASzB,EAAU3sC,EAAEA,GAAIC,EAAGyrC,GAExB79B,EACFq/B,EAAOltC,GAAKwO,EAAQ6J,OACf,GAA+B,iBAApBqzB,EAAW1pB,KAAmB,CAC9C,MAAMqqB,EAAiBlB,EAAUlpB,WACjCirB,EAAOjtC,GAAKqsC,GAA0BZ,EAAYW,GAAkBh0B,OAEpE60B,EAAOjtC,GAAKgiB,MAIhBosB,EAAAA,EAAAA,IAAqB98C,KAAK6M,IAAK3D,EAAK2yC,cACtC,CAKAtc,YACE,MAAMr2B,EAAOlJ,KAAKgI,QACZyvB,EAAYvuB,EAAKmuB,MACjB0lB,GAAYvsB,EAAAA,EAAAA,IAAOiH,EAAUlH,MAC7BysB,GAAex1B,EAAAA,EAAAA,GAAUiQ,EAAU3Q,SAEzC,IAAK2Q,EAAU/O,QACb,OAGF,MAAM0yB,GAAYC,EAAAA,EAAAA,IAAcnyC,EAAKiyC,IAAKn7C,KAAKqU,KAAMrU,KAAKid,OACpDpQ,EAAM7M,KAAK6M,IACXiV,EAAW2V,EAAU3V,SACrB45B,EAAeqB,EAAUj0C,KAAO,EAChCm0C,EAA6BD,EAAa9oC,IAAMwnC,EACtD,IAAIhtC,EAIA2F,EAAOrU,KAAKqU,KACZ4c,EAAWjxB,KAAKid,MAEpB,GAAIjd,KAAKsc,eAEP2U,EAAW7vB,KAAKoC,OAAOxD,KAAKy5C,YAC5B/qC,EAAI1O,KAAKkU,IAAM+oC,EACf5oC,GAAOqrB,EAAAA,EAAAA,IAAex2B,EAAK0nB,MAAOvc,EAAMrU,KAAKmU,MAAQ8c,OAChD,CAEL,MAAMC,EAAYlxB,KAAKw5C,YAAYn2C,QAAO,CAACC,EAAKwF,IAAS1H,KAAKoC,IAAIF,EAAKwF,EAAKkU,SAAS,GACrFtO,EAAIuuC,GAA6Bvd,EAAAA,EAAAA,IAAex2B,EAAK0nB,MAAO5wB,KAAKkU,IAAKlU,KAAKoU,OAAS8c,EAAYhoB,EAAK6I,OAAO+U,QAAU9mB,KAAK65C,uBAK7H,MAAMprC,GAAIixB,EAAAA,EAAAA,IAAe5d,EAAUzN,EAAMA,EAAO4c,GAGhDpkB,EAAI4vB,UAAY2e,EAAU3e,WAAU5L,EAAAA,EAAAA,IAAmB/O,IACvDjV,EAAI+vB,aAAe,SACnB/vB,EAAI2xB,YAAc/G,EAAUpzB,MAC5BwI,EAAImxB,UAAYvG,EAAUpzB,MAC1BwI,EAAI0jB,KAAOwsB,EAAUzjB,QAErB+F,EAAAA,EAAAA,GAAWxyB,EAAK4qB,EAAUhH,KAAMhiB,EAAGC,EAAGquC,EACxC,CAKAlD,sBACE,MAAMpiB,EAAYz3B,KAAKgI,QAAQqvB,MACzB0lB,GAAYvsB,EAAAA,EAAAA,IAAOiH,EAAUlH,MAC7BysB,GAAex1B,EAAAA,EAAAA,GAAUiQ,EAAU3Q,SACzC,OAAO2Q,EAAU/O,QAAUq0B,EAAUrsB,WAAassB,EAAahgC,OAAS,CAC1E,CAKAkgC,iBAAiBzuC,EAAGC,GAClB,IAAIvM,EAAGg7C,EAAQC,EAEf,IAAInG,EAAAA,EAAAA,IAAWxoC,EAAGzO,KAAKqU,KAAMrU,KAAKmU,SAC7B8iC,EAAAA,EAAAA,IAAWvoC,EAAG1O,KAAKkU,IAAKlU,KAAKoU,QAGhC,IADAgpC,EAAKp9C,KAAKo5C,eACLj3C,EAAI,EAAGA,EAAIi7C,EAAGn7C,SAAUE,EAG3B,GAFAg7C,EAASC,EAAGj7C,IAER80C,EAAAA,EAAAA,IAAWxoC,EAAG0uC,EAAO9oC,KAAM8oC,EAAO9oC,KAAO8oC,EAAOlgC,SAC/Cg6B,EAAAA,EAAAA,IAAWvoC,EAAGyuC,EAAOjpC,IAAKipC,EAAOjpC,IAAMipC,EAAOngC,QAEjD,OAAOhd,KAAKu5C,YAAYp3C,GAK9B,OAAO,IACT,CAMAk7C,YAAYl5B,GACV,MAAMjb,EAAOlJ,KAAKgI,QAClB,IAoDJ,SAAoBrH,EAAMuI,GACxB,QAAc,cAATvI,GAAiC,aAATA,IAAyBuI,EAAK+oC,UAAW/oC,EAAKo0C,aAGvEp0C,EAAKgpC,SAAqB,UAATvxC,GAA6B,YAATA,EAI3C,CA5DS48C,CAAWp5B,EAAExjB,KAAMuI,GACtB,OAIF,MAAMs0C,EAAcx9C,KAAKk9C,iBAAiB/4B,EAAE1V,EAAG0V,EAAEzV,GAEjD,GAAe,cAAXyV,EAAExjB,MAAmC,aAAXwjB,EAAExjB,KAAqB,CACnD,MAAM8xC,EAAWzyC,KAAKq5C,aAChBoE,GApfWzpC,EAofqBwpC,EApfT,QAAftkC,EAofcu5B,IApfe,OAANz+B,GAAckF,EAAElP,eAAiBgK,EAAEhK,cAAgBkP,EAAExP,QAAUsK,EAAEtK,OAqflG+oC,IAAagL,IACfxqB,EAAAA,EAAAA,GAAK/pB,EAAKo0C,QAAS,CAACn5B,EAAGsuB,EAAUzyC,MAAOA,MAG1CA,KAAKq5C,aAAemE,EAEhBA,IAAgBC,IAClBxqB,EAAAA,EAAAA,GAAK/pB,EAAK+oC,QAAS,CAAC9tB,EAAGq5B,EAAax9C,MAAOA,KAE/C,MAAWw9C,IACTvqB,EAAAA,EAAAA,GAAK/pB,EAAKgpC,QAAS,CAAC/tB,EAAGq5B,EAAax9C,MAAOA,MA/f9B09C,IAACxkC,EAAGlF,CAigBrB,EAyBF,SAAS+mC,GAA0BZ,EAAYW,GAE7C,OAAOA,GADaX,EAAW1pB,KAAO0pB,EAAW1pB,KAAKxuB,OAAS,EAEjE,CAYA,IAAA07C,GAAe,CACbhyC,GAAI,SAMJiyC,SAAU1E,GAEV53C,MAAMd,EAAOq9C,EAAO71C,GAClB,MAAM81C,EAASt9C,EAAMs9C,OAAS,IAAI5E,GAAO,CAACrsC,IAAKrM,EAAMqM,IAAK7E,UAASxH,UACnEymB,EAAQjgB,UAAUxG,EAAOs9C,EAAQ91C,GACjCif,EAAQC,OAAO1mB,EAAOs9C,EACxB,EAEAp6C,KAAKlD,GACHymB,EAAQI,UAAU7mB,EAAOA,EAAMs9C,eACxBt9C,EAAMs9C,MACf,EAKA9qB,aAAaxyB,EAAOq9C,EAAO71C,GACzB,MAAM81C,EAASt9C,EAAMs9C,OACrB72B,EAAQjgB,UAAUxG,EAAOs9C,EAAQ91C,GACjC81C,EAAO91C,QAAUA,CACnB,EAIA+tB,YAAYv1B,GACV,MAAMs9C,EAASt9C,EAAMs9C,OACrBA,EAAOpE,cACPoE,EAAO5C,gBACT,EAGA6C,WAAWv9C,EAAO0X,GACXA,EAAKk5B,QACR5wC,EAAMs9C,OAAOT,YAAYnlC,EAAKlV,MAElC,EAEAqE,SAAU,CACRqhB,SAAS,EACT5G,SAAU,MACV8O,MAAO,SACPlK,UAAU,EACVvd,SAAS,EACT2b,OAAQ,IAGRotB,QAAQ/tB,EAAGg2B,EAAY2D,GACrB,MAAMp0C,EAAQywC,EAAWnwC,aACnBg0C,EAAKF,EAAOt9C,MACdw9C,EAAGrQ,iBAAiBjkC,IACtBs0C,EAAGjO,KAAKrmC,GACRywC,EAAWpnC,QAAS,IAEpBirC,EAAGhO,KAAKtmC,GACRywC,EAAWpnC,QAAS,EAExB,EAEAk/B,QAAS,KACTqL,QAAS,KAETvrC,OAAQ,CACN1N,MAAQwI,GAAQA,EAAIrM,MAAMwH,QAAQ3D,MAClCy0C,SAAU,GACVhyB,QAAS,GAYT6yB,eAAen5C,GACb,MAAMqP,EAAWrP,EAAMoP,KAAKC,UACrBkC,QAAQ,cAACgnC,EAAA,WAAe3C,EAAU,UAAE3Z,EAAA,MAAWp4B,EAAA,gBAAO45C,EAAe,aAAEzG,IAAiBh3C,EAAMs9C,OAAO91C,QAE5G,OAAOxH,EAAMgJ,yBAAyBqjC,KAAKxiC,IACzC,MAAMojB,EAAQpjB,EAAKY,WAAW8J,SAASgkC,EAAgB,OAAIz4C,GACrD2f,GAAcuH,EAAAA,EAAAA,GAAUiG,EAAMxN,aAEpC,MAAO,CACLwQ,KAAM5gB,EAASxF,EAAKX,OAAOkK,MAC3BoqB,UAAWvQ,EAAMqQ,gBACjBge,UAAWz3C,EACX0O,QAAS1I,EAAKqjC,QACd0E,QAAS3kB,EAAM4kB,eACf4J,SAAUxuB,EAAMqO,WAChB4C,eAAgBjR,EAAMuO,iBACtBsW,SAAU7kB,EAAM8kB,gBAChB3W,WAAY3b,EAAYhD,MAAQgD,EAAYjD,QAAU,EACtDwhB,YAAa/Q,EAAM+kB,YACnB4D,WAAYA,GAAc3oB,EAAM2oB,WAChC5Z,SAAU/O,EAAM+O,SAChBC,UAAWA,GAAahP,EAAMgP,UAC9B+a,aAAcyG,IAAoBzG,GAAgB/pB,EAAM+pB,cAGxDxtC,aAAcK,EAAKX,MACpB,GACA1J,KACL,GAGFq3B,MAAO,CACLhzB,MAAQwI,GAAQA,EAAIrM,MAAMwH,QAAQ3D,MAClCqkB,SAAS,EACT5G,SAAU,SACV2O,KAAM,KAIVsR,YAAa,CACXwS,YAAc72B,IAAUA,EAAKwgC,WAAW,MACxCnsC,OAAQ,CACNwiC,YAAc72B,IAAU,CAAC,iBAAkB,SAAU,QAAQmL,SAASnL,MCzsBhE,IAAIygC,QCahB,MAAMC,GAAc,CAIlBC,QAAQr8C,GACN,IAAKA,EAAMC,OACT,OAAO,EAGT,IAAIE,EAAGytB,EACHnhB,EAAI,EACJC,EAAI,EACJ6C,EAAQ,EAEZ,IAAKpP,EAAI,EAAGytB,EAAM5tB,EAAMC,OAAQE,EAAIytB,IAAOztB,EAAG,CAC5C,MAAMsf,EAAKzf,EAAMG,GAAG2S,QACpB,GAAI2M,GAAMA,EAAGkN,WAAY,CACvB,MAAMlK,EAAMhD,EAAGiN,kBACfjgB,GAAKgW,EAAIhW,EACTC,GAAK+V,EAAI/V,IACP6C,EAEN,CAEA,MAAO,CACL9C,EAAGA,EAAI8C,EACP7C,EAAGA,EAAI6C,EAEX,EAKA8S,QAAQriB,EAAOs8C,GACb,IAAKt8C,EAAMC,OACT,OAAO,EAGT,IAGIE,EAAGytB,EAAK2uB,EAHR9vC,EAAI6vC,EAAc7vC,EAClBC,EAAI4vC,EAAc5vC,EAClByU,EAAcnQ,OAAOC,kBAGzB,IAAK9Q,EAAI,EAAGytB,EAAM5tB,EAAMC,OAAQE,EAAIytB,IAAOztB,EAAG,CAC5C,MAAMsf,EAAKzf,EAAMG,GAAG2S,QACpB,GAAI2M,GAAMA,EAAGkN,WAAY,CACvB,MAAM5R,EAAS0E,EAAG2B,iBACZkjB,GAAIkY,EAAAA,EAAAA,IAAsBF,EAAevhC,GAE3CupB,EAAInjB,IACNA,EAAcmjB,EACdiY,EAAiB98B,GAGvB,CAEA,GAAI88B,EAAgB,CAClB,MAAME,EAAKF,EAAe7vB,kBAC1BjgB,EAAIgwC,EAAGhwC,EACPC,EAAI+vC,EAAG/vC,EAGT,MAAO,CACLD,IACAC,IAEJ,GAIF,SAASgwC,GAAahkC,EAAMikC,GAU1B,OATIA,KACEh3C,EAAAA,EAAAA,GAAQg3C,GAEVruC,MAAM0vB,UAAU98B,KAAK07C,MAAMlkC,EAAMikC,GAEjCjkC,EAAKxX,KAAKy7C,IAIPjkC,CACT,CAQA,SAASmkC,GAAcC,GACrB,OAAoB,iBAARA,GAAoBA,aAAeC,SAAWD,EAAIvhC,QAAQ,OAAS,EACtEuhC,EAAIxd,MAAM,MAEZwd,CACT,CASA,SAASE,GAAkBx+C,EAAO0B,GAChC,MAAM,QAAC4S,EAAO,aAAE9K,EAAA,MAAcN,GAASxH,EACjC+I,EAAazK,EAAMsP,eAAe9F,GAAciB,YAChD,MAAC2I,EAAA,MAAO/K,GAASoC,EAAW0I,iBAAiBjK,GAEnD,MAAO,CACLlJ,QACAoT,QACA1I,OAAQD,EAAWoH,UAAU3I,GAC7B4L,IAAK9U,EAAMoP,KAAKC,SAAS7F,GAAc4F,KAAKlG,GAC5Cu1C,eAAgBp2C,EAChByF,QAASrD,EAAWsD,aACpB8G,UAAW3L,EACXM,eACA8K,UAEJ,CAKA,SAASoqC,GAAeC,EAASn3C,GAC/B,MAAM6E,EAAMsyC,EAAQ3+C,MAAMqM,KACpB,KAACuyC,EAAI,OAAEC,EAAA,MAAQhoB,GAAS8nB,GACxB,SAACrG,EAAA,UAAUD,GAAa7wC,EACxBs3C,GAAW9uB,EAAAA,EAAAA,IAAOxoB,EAAQs3C,UAC1BvC,GAAYvsB,EAAAA,EAAAA,IAAOxoB,EAAQ+0C,WAC3BwC,GAAa/uB,EAAAA,EAAAA,IAAOxoB,EAAQu3C,YAC5BC,EAAiBnoB,EAAMp1B,OACvBw9C,EAAkBJ,EAAOp9C,OACzBy9C,EAAoBN,EAAKn9C,OAEzB6kB,GAAUU,EAAAA,EAAAA,GAAUxf,EAAQ8e,SAClC,IAAI9J,EAAS8J,EAAQ9J,OACjBC,EAAQ,EAGR0iC,EAAqBP,EAAK/7C,QAAO,CAACkO,EAAOquC,IAAaruC,EAAQquC,EAASC,OAAO59C,OAAS29C,EAASE,MAAM79C,OAAS29C,EAASG,MAAM99C,QAAQ,GAC1I09C,GAAsBR,EAAQa,WAAW/9C,OAASk9C,EAAQc,UAAUh+C,OAEhEu9C,IACFxiC,GAAUwiC,EAAiBzC,EAAUrsB,YACnC8uB,EAAiB,GAAKx3C,EAAQk4C,aAC/Bl4C,EAAQm4C,mBAEPR,IAGF3iC,GAAU0iC,GADa13C,EAAQo4C,cAAgBh/C,KAAKoC,IAAIq1C,EAAWyG,EAAS5uB,YAAc4uB,EAAS5uB,aAEjGivB,EAAqBD,GAAqBJ,EAAS5uB,YACnDivB,EAAqB,GAAK33C,EAAQq4C,aAElCZ,IACFziC,GAAUhV,EAAQs4C,gBACjBb,EAAkBF,EAAW7uB,YAC5B+uB,EAAkB,GAAKz3C,EAAQu4C,eAInC,IAAIC,EAAe,EACnB,MAAMC,EAAe,SAAShhC,GAC5BxC,EAAQ7b,KAAKoC,IAAIyZ,EAAOpQ,EAAIwtC,YAAY56B,GAAMxC,MAAQujC,EACxD,EA+BA,OA7BA3zC,EAAIkxB,OAEJlxB,EAAI0jB,KAAOwsB,EAAUzjB,QACrBhR,EAAAA,EAAAA,GAAK62B,EAAQ9nB,MAAOopB,GAGpB5zC,EAAI0jB,KAAO+uB,EAAShmB,QACpBhR,EAAAA,EAAAA,GAAK62B,EAAQa,WAAWjnC,OAAOomC,EAAQc,WAAYQ,GAGnDD,EAAex4C,EAAQo4C,cAAiBtH,EAAW,EAAI9wC,EAAQkd,WAAc,GAC7EoD,EAAAA,EAAAA,GAAK82B,GAAOQ,KACVt3B,EAAAA,EAAAA,GAAKs3B,EAASC,OAAQY,IACtBn4B,EAAAA,EAAAA,GAAKs3B,EAASE,MAAOW,IACrBn4B,EAAAA,EAAAA,GAAKs3B,EAASG,MAAOU,EAAA,IAIvBD,EAAe,EAGf3zC,EAAI0jB,KAAOgvB,EAAWjmB,QACtBhR,EAAAA,EAAAA,GAAK62B,EAAQE,OAAQoB,GAErB5zC,EAAIqxB,UAGJjhB,GAAS6J,EAAQ7J,MAEV,CAACA,QAAOD,SACjB,CAyBA,SAAS0jC,GAAgBlgD,EAAOwH,EAASc,EAAM63C,GAC7C,MAAM,EAAClyC,EAAA,MAAGwO,GAASnU,GACZmU,MAAO2jC,EAAYhsC,WAAW,KAACP,EAAI,MAAEF,IAAU3T,EACtD,IAAIqgD,EAAS,SAcb,MAZe,WAAXF,EACFE,EAASpyC,IAAM4F,EAAOF,GAAS,EAAI,OAAS,QACnC1F,GAAKwO,EAAQ,EACtB4jC,EAAS,OACApyC,GAAKmyC,EAAa3jC,EAAQ,IACnC4jC,EAAS,SAtBb,SAA6BA,EAAQrgD,EAAOwH,EAASc,GACnD,MAAM,EAAC2F,EAAA,MAAGwO,GAASnU,EACbg4C,EAAQ94C,EAAQ+4C,UAAY/4C,EAAQg5C,aAC1C,MAAe,SAAXH,GAAqBpyC,EAAIwO,EAAQ6jC,EAAQtgD,EAAMyc,OAIpC,UAAX4jC,GAAsBpyC,EAAIwO,EAAQ6jC,EAAQ,QAA9C,CAGF,CAeMG,CAAoBJ,EAAQrgD,EAAOwH,EAASc,KAC9C+3C,EAAS,UAGJA,CACT,CAKA,SAASK,GAAmB1gD,EAAOwH,EAASc,GAC1C,MAAM63C,EAAS73C,EAAK63C,QAAU34C,EAAQ24C,QA/CxC,SAAyBngD,EAAOsI,GAC9B,MAAM,EAAC4F,EAAA,OAAGsO,GAAUlU,EAEpB,OAAI4F,EAAIsO,EAAS,EACR,MACEtO,EAAKlO,EAAMwc,OAASA,EAAS,EAC/B,SAEF,QACT,CAsCkDmkC,CAAgB3gD,EAAOsI,GAEvE,MAAO,CACL+3C,OAAQ/3C,EAAK+3C,QAAU74C,EAAQ64C,QAAUH,GAAgBlgD,EAAOwH,EAASc,EAAM63C,GAC/EA,SAEJ,CA4BA,SAASS,GAAmBp5C,EAASc,EAAMu4C,EAAW7gD,GACpD,MAAM,UAACugD,EAAS,aAAEC,EAAA,aAAcM,GAAgBt5C,GAC1C,OAAC64C,EAAA,OAAQF,GAAUU,EACnBE,EAAiBR,EAAYC,GAC7B,QAAC7I,EAAO,SAAEC,EAAQ,WAAEC,EAAA,YAAYC,IAAeN,EAAAA,EAAAA,IAAcsJ,GAEnE,IAAI7yC,EAhCN,SAAgB3F,EAAM+3C,GACpB,IAAI,EAACpyC,EAAA,MAAGwO,GAASnU,EAMjB,MALe,UAAX+3C,EACFpyC,GAAKwO,EACe,WAAX4jC,IACTpyC,GAAMwO,EAAQ,GAETxO,CACT,CAwBU+yC,CAAO14C,EAAM+3C,GACrB,MAAMnyC,EAvBR,SAAgB5F,EAAM63C,EAAQY,GAE5B,IAAI,EAAC7yC,EAAA,OAAGsO,GAAUlU,EAQlB,MAPe,QAAX63C,EACFjyC,GAAK6yC,EAEL7yC,GADoB,WAAXiyC,EACJ3jC,EAASukC,EAERvkC,EAAS,EAEVtO,CACT,CAYY+yC,CAAO34C,EAAM63C,EAAQY,GAc/B,MAZe,WAAXZ,EACa,SAAXE,EACFpyC,GAAK8yC,EACe,UAAXV,IACTpyC,GAAK8yC,GAEa,SAAXV,EACTpyC,GAAKrN,KAAKoC,IAAI20C,EAASE,GAAc0I,EACjB,UAAXF,IACTpyC,GAAKrN,KAAKoC,IAAI40C,EAAUE,GAAeyI,GAGlC,CACLtyC,GAAG2oB,EAAAA,EAAAA,GAAY3oB,EAAG,EAAGjO,EAAMyc,MAAQnU,EAAKmU,OACxCvO,GAAG0oB,EAAAA,EAAAA,GAAY1oB,EAAG,EAAGlO,EAAMwc,OAASlU,EAAKkU,QAE7C,CAEA,SAAS0kC,GAAYvC,EAASvuB,EAAO5oB,GACnC,MAAM8e,GAAUU,EAAAA,EAAAA,GAAUxf,EAAQ8e,SAElC,MAAiB,WAAV8J,EACHuuB,EAAQ1wC,EAAI0wC,EAAQliC,MAAQ,EAClB,UAAV2T,EACEuuB,EAAQ1wC,EAAI0wC,EAAQliC,MAAQ6J,EAAQ3S,MACpCgrC,EAAQ1wC,EAAIqY,EAAQzS,IAC5B,CAKA,SAASstC,GAAwB1uB,GAC/B,OAAOyrB,GAAa,GAAIG,GAAc5rB,GACxC,CAUA,SAAS2uB,GAAkBhhD,EAAWsU,GACpC,MAAMorB,EAAWprB,GAAWA,EAAQ5G,SAAW4G,EAAQ5G,QAAQ6wC,SAAWjqC,EAAQ5G,QAAQ6wC,QAAQv+C,UAClG,OAAO0/B,EAAW1/B,EAAU0/B,SAASA,GAAY1/B,CACnD,CAEA,MAAMihD,GAAmB,CAEvBC,YAAaC,EAAAA,GACb1qB,MAAM2qB,GACJ,GAAIA,EAAa//C,OAAS,EAAG,CAC3B,MAAMC,EAAO8/C,EAAa,GACpBjwC,EAAS7P,EAAK1B,MAAMoP,KAAKmC,OACzBkwC,EAAalwC,EAASA,EAAO9P,OAAS,EAE5C,GAAIjC,MAAQA,KAAKgI,SAAiC,YAAtBhI,KAAKgI,QAAQ+B,KACvC,OAAO7H,EAAKoM,QAAQsF,OAAS,GACxB,GAAI1R,EAAK0R,MACd,OAAO1R,EAAK0R,MACP,GAAIquC,EAAa,GAAK//C,EAAKmT,UAAY4sC,EAC5C,OAAOlwC,EAAO7P,EAAKmT,WAIvB,MAAO,EACT,EACA6sC,WAAYH,EAAAA,GAGZ/B,WAAY+B,EAAAA,GAGZI,YAAaJ,EAAAA,GACbnuC,MAAMwuC,GACJ,GAAIpiD,MAAQA,KAAKgI,SAAiC,YAAtBhI,KAAKgI,QAAQ+B,KACvC,OAAOq4C,EAAYxuC,MAAQ,KAAOwuC,EAAYnD,gBAAkBmD,EAAYnD,eAG9E,IAAIrrC,EAAQwuC,EAAY9zC,QAAQsF,OAAS,GAErCA,IACFA,GAAS,MAEX,MAAM/K,EAAQu5C,EAAYnD,eAI1B,OAHKviC,EAAAA,EAAAA,GAAc7T,KACjB+K,GAAS/K,GAEJ+K,CACT,EACAyuC,WAAWD,GACT,MACMp6C,EADOo6C,EAAY5hD,MAAMsP,eAAesyC,EAAYp4C,cACrCiB,WAAW8J,SAASqtC,EAAY/sC,WACrD,MAAO,CACLm9B,YAAaxqC,EAAQwqC,YACrB1U,gBAAiB91B,EAAQ81B,gBACzB7d,YAAajY,EAAQiY,YACrB6b,WAAY9zB,EAAQ8zB,WACpBE,iBAAkBh0B,EAAQg0B,iBAC1Bwb,aAAc,EAElB,EACA8K,iBACE,OAAOtiD,KAAKgI,QAAQu6C,SACtB,EACAC,gBAAgBJ,GACd,MACMp6C,EADOo6C,EAAY5hD,MAAMsP,eAAesyC,EAAYp4C,cACrCiB,WAAW8J,SAASqtC,EAAY/sC,WACrD,MAAO,CACL+gC,WAAYpuC,EAAQouC,WACpB5Z,SAAUx0B,EAAQw0B,SAEtB,EACAimB,WAAYV,EAAAA,GAGZ9B,UAAW8B,EAAAA,GAGXW,aAAcX,EAAAA,GACd1C,OAAQ0C,EAAAA,GACRY,YAAaZ,EAAAA,IAYf,SAASa,GAA2BhiD,EAAW8c,EAAM7Q,EAAKy2B,GACxD,MAAM5T,EAAS9uB,EAAU8c,GAAMjc,KAAKoL,EAAKy2B,GAEzC,YAAsB,IAAX5T,EACFmyB,GAAiBnkC,GAAMjc,KAAKoL,EAAKy2B,GAGnC5T,CACT,CAEO,MAAMmzB,WAAgBp0B,GAK3B9hB,mBAAqByxC,GAErBr+C,YAAY8G,GACVsV,QAEAnc,KAAK8iD,QAAU,EACf9iD,KAAKqC,QAAU,GACfrC,KAAK+iD,oBAAiBziD,EACtBN,KAAKgjD,WAAQ1iD,EACbN,KAAKijD,uBAAoB3iD,EACzBN,KAAKkjD,cAAgB,GACrBljD,KAAKmI,iBAAc7H,EACnBN,KAAKyN,cAAWnN,EAChBN,KAAKQ,MAAQqG,EAAOrG,MACpBR,KAAKgI,QAAUnB,EAAOmB,QACtBhI,KAAKmjD,gBAAa7iD,EAClBN,KAAKq3B,WAAQ/2B,EACbN,KAAKggD,gBAAa1/C,EAClBN,KAAKo/C,UAAO9+C,EACZN,KAAKigD,eAAY3/C,EACjBN,KAAKq/C,YAAS/+C,EACdN,KAAK6gD,YAASvgD,EACdN,KAAK2gD,YAASrgD,EACdN,KAAKyO,OAAInO,EACTN,KAAK0O,OAAIpO,EACTN,KAAKgd,YAAS1c,EACdN,KAAKid,WAAQ3c,EACbN,KAAKojD,YAAS9iD,EACdN,KAAKqjD,YAAS/iD,EAGdN,KAAKsjD,iBAAchjD,EACnBN,KAAKujD,sBAAmBjjD,EACxBN,KAAKwjD,qBAAkBljD,CACzB,CAEAuN,WAAW7F,GACThI,KAAKgI,QAAUA,EACfhI,KAAKijD,uBAAoB3iD,EACzBN,KAAKyN,cAAWnN,CAClB,CAKA8V,qBACE,MAAM5J,EAASxM,KAAKijD,kBAEpB,GAAIz2C,EACF,OAAOA,EAGT,MAAMhM,EAAQR,KAAKQ,MACbwH,EAAUhI,KAAKgI,QAAQsqB,WAAWtyB,KAAKoR,cACvClI,EAAOlB,EAAQ+sB,SAAWv0B,EAAMwH,QAAQV,WAAaU,EAAQK,WAC7DA,EAAa,IAAIzB,EAAW5G,KAAKQ,MAAO0I,GAK9C,OAJIA,EAAKqN,aACPvW,KAAKijD,kBAAoB97C,OAAOgP,OAAO9N,IAGlCA,CACT,CAKA+I,aACE,OAAOpR,KAAKyN,WACZzN,KAAKyN,UAtLqB0H,EAsLWnV,KAAKQ,MAAM4Q,aAAcpR,KAtLnBgiD,EAsLyBhiD,KAAKkjD,eArLpE9tC,EAAAA,EAAAA,GAAcD,EAAQ,CAC3BgqC,QAoL8Dn/C,KAnL9DgiD,eACArhD,KAAM,cAJV,IAA8BwU,EAAiB6sC,CAuL7C,CAEAyB,SAASvuC,EAASlN,GAChB,MAAM,UAACpH,GAAaoH,EAEd85C,EAAcc,GAA2BhiD,EAAW,cAAeZ,KAAMkV,GACzEmiB,EAAQurB,GAA2BhiD,EAAW,QAASZ,KAAMkV,GAC7DgtC,EAAaU,GAA2BhiD,EAAW,aAAcZ,KAAMkV,GAE7E,IAAI4qC,EAAQ,GAKZ,OAJAA,EAAQpB,GAAaoB,EAAOjB,GAAciD,IAC1ChC,EAAQpB,GAAaoB,EAAOjB,GAAcxnB,IAC1CyoB,EAAQpB,GAAaoB,EAAOjB,GAAcqD,IAEnCpC,CACT,CAEA4D,cAAc1B,EAAch6C,GAC1B,OAAO25C,GACLiB,GAA2B56C,EAAQpH,UAAW,aAAcZ,KAAMgiD,GAEtE,CAEA2B,QAAQ3B,EAAch6C,GACpB,MAAM,UAACpH,GAAaoH,EACd47C,EAAY,GAgBlB,OAdAt7B,EAAAA,EAAAA,GAAK05B,GAAe9sC,IAClB,MAAM0qC,EAAW,CACfC,OAAQ,GACRC,MAAO,GACPC,MAAO,IAEH8D,EAASjC,GAAkBhhD,EAAWsU,GAC5CwpC,GAAakB,EAASC,OAAQhB,GAAc+D,GAA2BiB,EAAQ,cAAe7jD,KAAMkV,KACpGwpC,GAAakB,EAASE,MAAO8C,GAA2BiB,EAAQ,QAAS7jD,KAAMkV,IAC/EwpC,GAAakB,EAASG,MAAOlB,GAAc+D,GAA2BiB,EAAQ,aAAc7jD,KAAMkV,KAElG0uC,EAAU1gD,KAAK08C,EAAA,IAGVgE,CACT,CAEAE,aAAa9B,EAAch6C,GACzB,OAAO25C,GACLiB,GAA2B56C,EAAQpH,UAAW,YAAaZ,KAAMgiD,GAErE,CAGA+B,UAAU/B,EAAch6C,GACtB,MAAM,UAACpH,GAAaoH,EAEd06C,EAAeE,GAA2BhiD,EAAW,eAAgBZ,KAAMgiD,GAC3E3C,EAASuD,GAA2BhiD,EAAW,SAAUZ,KAAMgiD,GAC/DW,EAAcC,GAA2BhiD,EAAW,cAAeZ,KAAMgiD,GAE/E,IAAIlC,EAAQ,GAKZ,OAJAA,EAAQpB,GAAaoB,EAAOjB,GAAc6D,IAC1C5C,EAAQpB,GAAaoB,EAAOjB,GAAcQ,IAC1CS,EAAQpB,GAAaoB,EAAOjB,GAAc8D,IAEnC7C,CACT,CAKAkE,aAAah8C,GACX,MAAM/B,EAASjG,KAAKqC,QACduN,EAAO5P,KAAKQ,MAAMoP,KAClB0zC,EAAc,GACdC,EAAmB,GACnBC,EAAkB,GACxB,IACIrhD,EAAGytB,EADHoyB,EAAe,GAGnB,IAAK7/C,EAAI,EAAGytB,EAAM3pB,EAAOhE,OAAQE,EAAIytB,IAAOztB,EAC1C6/C,EAAa9+C,KAAK87C,GAAkBh/C,KAAKQ,MAAOyF,EAAO9D,KAyBzD,OArBI6F,EAAQkE,SACV81C,EAAeA,EAAa91C,QAAO,CAAC4I,EAASpL,EAAO8a,IAAUxc,EAAQkE,OAAO4I,EAASpL,EAAO8a,EAAO5U,MAIlG5H,EAAQi8C,WACVjC,EAAeA,EAAa/oC,MAAK,CAACC,EAAGlF,IAAMhM,EAAQi8C,SAAS/qC,EAAGlF,EAAGpE,OAIpE0Y,EAAAA,EAAAA,GAAK05B,GAAe9sC,IAClB,MAAM2uC,EAASjC,GAAkB55C,EAAQpH,UAAWsU,GACpDouC,EAAYpgD,KAAK0/C,GAA2BiB,EAAQ,aAAc7jD,KAAMkV,IACxEquC,EAAiBrgD,KAAK0/C,GAA2BiB,EAAQ,kBAAmB7jD,KAAMkV,IAClFsuC,EAAgBtgD,KAAK0/C,GAA2BiB,EAAQ,iBAAkB7jD,KAAMkV,GAAA,IAGlFlV,KAAKsjD,YAAcA,EACnBtjD,KAAKujD,iBAAmBA,EACxBvjD,KAAKwjD,gBAAkBA,EACvBxjD,KAAKmjD,WAAanB,EACXA,CACT,CAEA97C,OAAOugB,EAAS2qB,GACd,MAAMppC,EAAUhI,KAAKgI,QAAQsqB,WAAWtyB,KAAKoR,cACvCnL,EAASjG,KAAKqC,QACpB,IAAIuF,EACAo6C,EAAe,GAEnB,GAAK/7C,EAAOhE,OAML,CACL,MAAM6f,EAAWs8B,GAAYp2C,EAAQ8Z,UAAUrgB,KAAKzB,KAAMiG,EAAQjG,KAAK+iD,gBACvEf,EAAehiD,KAAKgkD,aAAah8C,GAEjChI,KAAKq3B,MAAQr3B,KAAKyjD,SAASzB,EAAch6C,GACzChI,KAAKggD,WAAahgD,KAAK0jD,cAAc1B,EAAch6C,GACnDhI,KAAKo/C,KAAOp/C,KAAK2jD,QAAQ3B,EAAch6C,GACvChI,KAAKigD,UAAYjgD,KAAK8jD,aAAa9B,EAAch6C,GACjDhI,KAAKq/C,OAASr/C,KAAK+jD,UAAU/B,EAAch6C,GAE3C,MAAMc,EAAO9I,KAAKgjD,MAAQ9D,GAAel/C,KAAMgI,GACzCk8C,EAAkB/8C,OAAOe,OAAO,CAAC,EAAG4Z,EAAUhZ,GAC9Cu4C,EAAYH,GAAmBlhD,KAAKQ,MAAOwH,EAASk8C,GACpDC,EAAkB/C,GAAmBp5C,EAASk8C,EAAiB7C,EAAWrhD,KAAKQ,OAErFR,KAAK6gD,OAASQ,EAAUR,OACxB7gD,KAAK2gD,OAASU,EAAUV,OAExB/4C,EAAa,CACXk7C,QAAS,EACTr0C,EAAG01C,EAAgB11C,EACnBC,EAAGy1C,EAAgBz1C,EACnBuO,MAAOnU,EAAKmU,MACZD,OAAQlU,EAAKkU,OACbomC,OAAQthC,EAASrT,EACjB40C,OAAQvhC,EAASpT,QA9BE,IAAjB1O,KAAK8iD,UACPl7C,EAAa,CACXk7C,QAAS,IAgCf9iD,KAAKkjD,cAAgBlB,EACrBhiD,KAAKyN,cAAWnN,EAEZsH,GACF5H,KAAKoW,qBAAqBlQ,OAAOlG,KAAM4H,GAGrC6e,GAAWze,EAAQo8C,UACrBp8C,EAAQo8C,SAAS3iD,KAAKzB,KAAM,CAACQ,MAAOR,KAAKQ,MAAO2+C,QAASn/C,KAAMoxC,UAEnE,CAEAiT,UAAUC,EAAcz3C,EAAK/D,EAAMd,GACjC,MAAMu8C,EAAgBvkD,KAAKwkD,iBAAiBF,EAAcx7C,EAAMd,GAEhE6E,EAAIgyB,OAAO0lB,EAAcppB,GAAIopB,EAAcnpB,IAC3CvuB,EAAIgyB,OAAO0lB,EAAclpB,GAAIkpB,EAAcjpB,IAC3CzuB,EAAIgyB,OAAO0lB,EAAcE,GAAIF,EAAcG,GAC7C,CAEAF,iBAAiBF,EAAcx7C,EAAMd,GACnC,MAAM,OAAC64C,EAAM,OAAEF,GAAU3gD,MACnB,UAAC+gD,EAAA,aAAWO,GAAgBt5C,GAC5B,QAACmwC,EAAO,SAAEC,EAAQ,WAAEC,EAAA,YAAYC,IAAeN,EAAAA,EAAAA,IAAcsJ,IAC5D7yC,EAAGk2C,EAAKj2C,EAAGk2C,GAAON,GACnB,MAACrnC,EAAA,OAAOD,GAAUlU,EACxB,IAAIqyB,EAAIE,EAAIopB,EAAIrpB,EAAIE,EAAIopB,EAgDxB,MA9Ce,WAAX/D,GACFrlB,EAAKspB,EAAO5nC,EAAS,EAEN,SAAX6jC,GACF1lB,EAAKwpB,EACLtpB,EAAKF,EAAK4lB,EAGV3lB,EAAKE,EAAKylB,EACV2D,EAAKppB,EAAKylB,IAEV5lB,EAAKwpB,EAAM1nC,EACXoe,EAAKF,EAAK4lB,EAGV3lB,EAAKE,EAAKylB,EACV2D,EAAKppB,EAAKylB,GAGZ0D,EAAKtpB,IAGHE,EADa,SAAXwlB,EACG8D,EAAMvjD,KAAKoC,IAAI20C,EAASE,GAAe0I,EACxB,UAAXF,EACJ8D,EAAM1nC,EAAQ7b,KAAKoC,IAAI40C,EAAUE,GAAeyI,EAEhD/gD,KAAKojD,OAGG,QAAXzC,GACFvlB,EAAKwpB,EACLtpB,EAAKF,EAAK2lB,EAGV5lB,EAAKE,EAAK0lB,EACV0D,EAAKppB,EAAK0lB,IAEV3lB,EAAKwpB,EAAM5nC,EACXse,EAAKF,EAAK2lB,EAGV5lB,EAAKE,EAAK0lB,EACV0D,EAAKppB,EAAK0lB,GAEZ2D,EAAKtpB,GAEA,CAACD,KAAIE,KAAIopB,KAAIrpB,KAAIE,KAAIopB,KAC9B,CAEAnlB,UAAUslB,EAAIh4C,EAAK7E,GACjB,MAAMqvB,EAAQr3B,KAAKq3B,MACbp1B,EAASo1B,EAAMp1B,OACrB,IAAI86C,EAAWmD,EAAc/9C,EAE7B,GAAIF,EAAQ,CACV,MAAMm5C,GAAYC,EAAAA,EAAAA,IAAcrzC,EAAQmzC,IAAKn7C,KAAKyO,EAAGzO,KAAKid,OAa1D,IAXA4nC,EAAGp2C,EAAIizC,GAAY1hD,KAAMgI,EAAQ2oB,WAAY3oB,GAE7C6E,EAAI4vB,UAAY2e,EAAU3e,UAAUz0B,EAAQ2oB,YAC5C9jB,EAAI+vB,aAAe,SAEnBmgB,GAAYvsB,EAAAA,EAAAA,IAAOxoB,EAAQ+0C,WAC3BmD,EAAel4C,EAAQk4C,aAEvBrzC,EAAImxB,UAAYh2B,EAAQ88C,WACxBj4C,EAAI0jB,KAAOwsB,EAAUzjB,OAEhBn3B,EAAI,EAAGA,EAAIF,IAAUE,EACxB0K,EAAIgwC,SAASxlB,EAAMl1B,GAAIi5C,EAAU3sC,EAAEo2C,EAAGp2C,GAAIo2C,EAAGn2C,EAAIquC,EAAUrsB,WAAa,GACxEm0B,EAAGn2C,GAAKquC,EAAUrsB,WAAawvB,EAE3B/9C,EAAI,IAAMF,IACZ4iD,EAAGn2C,GAAK1G,EAAQm4C,kBAAoBD,GAI5C,CAKA6E,cAAcl4C,EAAKg4C,EAAI1iD,EAAGi5C,EAAWpzC,GACnC,MAAMq6C,EAAariD,KAAKsjD,YAAYnhD,GAC9BqgD,EAAkBxiD,KAAKujD,iBAAiBphD,IACxC,UAAC02C,EAAA,SAAWC,GAAY9wC,EACxBs3C,GAAW9uB,EAAAA,EAAAA,IAAOxoB,EAAQs3C,UAC1B0F,EAAStD,GAAY1hD,KAAM,OAAQgI,GACnCi9C,EAAY7J,EAAU3sC,EAAEu2C,GACxBE,EAAUrM,EAAYyG,EAAS5uB,YAAc4uB,EAAS5uB,WAAamoB,GAAa,EAAI,EACpFsM,EAASN,EAAGn2C,EAAIw2C,EAEtB,GAAIl9C,EAAQ+wC,cAAe,CACzB,MAAMmD,EAAc,CAClBnG,OAAQ30C,KAAKC,IAAIy3C,EAAUD,GAAa,EACxCzC,WAAYoM,EAAgBpM,WAC5B5Z,SAAUgmB,EAAgBhmB,SAC1Bvc,YAAa,GAITm8B,EAAUhB,EAAUG,WAAW0J,EAAWnM,GAAYA,EAAW,EACjEwD,EAAU6I,EAAStM,EAAY,EAGrChsC,EAAI2xB,YAAcx2B,EAAQo9C,mBAC1Bv4C,EAAImxB,UAAYh2B,EAAQo9C,oBACxB3O,EAAAA,EAAAA,IAAU5pC,EAAKqvC,EAAaE,EAASE,GAGrCzvC,EAAI2xB,YAAc6jB,EAAW7P,YAC7B3lC,EAAImxB,UAAYqkB,EAAWvkB,iBAC3B2Y,EAAAA,EAAAA,IAAU5pC,EAAKqvC,EAAaE,EAASE,OAChC,CAELzvC,EAAI+uB,WAAY30B,EAAAA,EAAAA,GAASo7C,EAAWpiC,aAAe7e,KAAKoC,OAAO2D,OAAOW,OAAOu6C,EAAWpiC,cAAiBoiC,EAAWpiC,aAAe,EACnIpT,EAAI2xB,YAAc6jB,EAAW7P,YAC7B3lC,EAAI4xB,YAAY4jB,EAAWvmB,YAAc,IACzCjvB,EAAI6xB,eAAiB2jB,EAAWrmB,kBAAoB,EAGpD,MAAMqpB,EAASjK,EAAUG,WAAW0J,EAAWnM,GACzCwM,EAASlK,EAAUG,WAAWH,EAAUiB,MAAM4I,EAAW,GAAInM,EAAW,GACxEtB,GAAeQ,EAAAA,EAAAA,IAAcqK,EAAW7K,cAE1CrwC,OAAOW,OAAO0vC,GAActS,MAAKhqB,GAAW,IAANA,KACxCrO,EAAI8xB,YACJ9xB,EAAImxB,UAAYh2B,EAAQo9C,oBACxB1M,EAAAA,EAAAA,IAAmB7rC,EAAK,CACtB4B,EAAG42C,EACH32C,EAAGy2C,EACHv/B,EAAGkzB,EACHhzB,EACAiwB,OAAQyB,IAEV3qC,EAAIoB,OACJpB,EAAIiyB,SAGJjyB,EAAImxB,UAAYqkB,EAAWvkB,gBAC3BjxB,EAAI8xB,aACJ+Z,EAAAA,EAAAA,IAAmB7rC,EAAK,CACtB4B,EAAG62C,EACH52C,EAAGy2C,EAAS,EACZv/B,EAAGkzB,EAAW,EACdhzB,EAAG+yB,EAAY,EACf9C,OAAQyB,IAEV3qC,EAAIoB,SAGJpB,EAAImxB,UAAYh2B,EAAQo9C,mBACxBv4C,EAAIoxB,SAASonB,EAAQF,EAAQrM,EAAUD,GACvChsC,EAAI04C,WAAWF,EAAQF,EAAQrM,EAAUD,GAEzChsC,EAAImxB,UAAYqkB,EAAWvkB,gBAC3BjxB,EAAIoxB,SAASqnB,EAAQH,EAAS,EAAGrM,EAAW,EAAGD,EAAY,IAK/DhsC,EAAImxB,UAAYh+B,KAAKwjD,gBAAgBrhD,EACvC,CAEAqjD,SAASX,EAAIh4C,EAAK7E,GAChB,MAAM,KAACo3C,GAAQp/C,MACT,YAACqgD,EAAA,UAAaoF,EAAA,cAAWrF,EAAA,UAAevH,EAAA,SAAWC,EAAA,WAAU5zB,GAAcld,EAC3Es3C,GAAW9uB,EAAAA,EAAAA,IAAOxoB,EAAQs3C,UAChC,IAAIoG,EAAiBpG,EAAS5uB,WAC1Bi1B,EAAe,EAEnB,MAAMvK,GAAYC,EAAAA,EAAAA,IAAcrzC,EAAQmzC,IAAKn7C,KAAKyO,EAAGzO,KAAKid,OAEpD2oC,EAAiB,SAASnmC,GAC9B5S,EAAIgwC,SAASp9B,EAAM27B,EAAU3sC,EAAEo2C,EAAGp2C,EAAIk3C,GAAed,EAAGn2C,EAAIg3C,EAAiB,GAC7Eb,EAAGn2C,GAAKg3C,EAAiBrF,CAC3B,EAEMwF,EAA0BzK,EAAU3e,UAAUgpB,GACpD,IAAI7F,EAAUkG,EAAWhG,EAAO39C,EAAG8f,EAAGxY,EAAMsvB,EAiB5C,IAfAlsB,EAAI4vB,UAAYgpB,EAChB54C,EAAI+vB,aAAe,SACnB/vB,EAAI0jB,KAAO+uB,EAAShmB,OAEpBurB,EAAGp2C,EAAIizC,GAAY1hD,KAAM6lD,EAAyB79C,GAGlD6E,EAAImxB,UAAYh2B,EAAQu6C,WACxBj6B,EAAAA,EAAAA,GAAKtoB,KAAKggD,WAAY4F,GAEtBD,EAAevF,GAA6C,UAA5ByF,EACd,WAAdJ,EAA0B3M,EAAW,EAAI5zB,EAAe4zB,EAAW,EAAI5zB,EACvE,EAGC/iB,EAAI,EAAGsH,EAAO21C,EAAKn9C,OAAQE,EAAIsH,IAAQtH,EAAG,CAc7C,IAbAy9C,EAAWR,EAAKj9C,GAChB2jD,EAAY9lD,KAAKwjD,gBAAgBrhD,GAEjC0K,EAAImxB,UAAY8nB,GAChBx9B,EAAAA,EAAAA,GAAKs3B,EAASC,OAAQ+F,GAEtB9F,EAAQF,EAASE,MAEbM,GAAiBN,EAAM79C,SACzBjC,KAAK+kD,cAAcl4C,EAAKg4C,EAAI1iD,EAAGi5C,EAAWpzC,GAC1C09C,EAAiBtkD,KAAKoC,IAAI87C,EAAS5uB,WAAYmoB,IAG5C52B,EAAI,EAAG8W,EAAO+mB,EAAM79C,OAAQggB,EAAI8W,IAAQ9W,EAC3C2jC,EAAe9F,EAAM79B,IAErByjC,EAAiBpG,EAAS5uB,YAG5BpI,EAAAA,EAAAA,GAAKs3B,EAASG,MAAO6F,EACvB,CAGAD,EAAe,EACfD,EAAiBpG,EAAS5uB,YAG1BpI,EAAAA,EAAAA,GAAKtoB,KAAKigD,UAAW2F,GACrBf,EAAGn2C,GAAK2xC,CACV,CAEA0F,WAAWlB,EAAIh4C,EAAK7E,GAClB,MAAMq3C,EAASr/C,KAAKq/C,OACdp9C,EAASo9C,EAAOp9C,OACtB,IAAIs9C,EAAYp9C,EAEhB,GAAIF,EAAQ,CACV,MAAMm5C,GAAYC,EAAAA,EAAAA,IAAcrzC,EAAQmzC,IAAKn7C,KAAKyO,EAAGzO,KAAKid,OAa1D,IAXA4nC,EAAGp2C,EAAIizC,GAAY1hD,KAAMgI,EAAQg+C,YAAah+C,GAC9C68C,EAAGn2C,GAAK1G,EAAQs4C,gBAEhBzzC,EAAI4vB,UAAY2e,EAAU3e,UAAUz0B,EAAQg+C,aAC5Cn5C,EAAI+vB,aAAe,SAEnB2iB,GAAa/uB,EAAAA,EAAAA,IAAOxoB,EAAQu3C,YAE5B1yC,EAAImxB,UAAYh2B,EAAQi+C,YACxBp5C,EAAI0jB,KAAOgvB,EAAWjmB,OAEjBn3B,EAAI,EAAGA,EAAIF,IAAUE,EACxB0K,EAAIgwC,SAASwC,EAAOl9C,GAAIi5C,EAAU3sC,EAAEo2C,EAAGp2C,GAAIo2C,EAAGn2C,EAAI6wC,EAAW7uB,WAAa,GAC1Em0B,EAAGn2C,GAAK6wC,EAAW7uB,WAAa1oB,EAAQu4C,cAG9C,CAEA1iB,eAAegnB,EAAIh4C,EAAKq5C,EAAal+C,GACnC,MAAM,OAAC64C,EAAM,OAAEF,GAAU3gD,MACnB,EAACyO,EAAA,EAAGC,GAAKm2C,GACT,MAAC5nC,EAAA,OAAOD,GAAUkpC,GAClB,QAAC/N,EAAA,SAASC,EAAA,WAAUC,EAAA,YAAYC,IAAeN,EAAAA,EAAAA,IAAchwC,EAAQs5C,cAE3Ez0C,EAAImxB,UAAYh2B,EAAQ81B,gBACxBjxB,EAAI2xB,YAAcx2B,EAAQwqC,YAC1B3lC,EAAI+uB,UAAY5zB,EAAQiY,YAExBpT,EAAI8xB,YACJ9xB,EAAI+xB,OAAOnwB,EAAI0pC,EAASzpC,GACT,QAAXiyC,GACF3gD,KAAKqkD,UAAUQ,EAAIh4C,EAAKq5C,EAAal+C,GAEvC6E,EAAIgyB,OAAOpwB,EAAIwO,EAAQm7B,EAAU1pC,GACjC7B,EAAIs5C,iBAAiB13C,EAAIwO,EAAOvO,EAAGD,EAAIwO,EAAOvO,EAAI0pC,GACnC,WAAXuI,GAAkC,UAAXE,GACzB7gD,KAAKqkD,UAAUQ,EAAIh4C,EAAKq5C,EAAal+C,GAEvC6E,EAAIgyB,OAAOpwB,EAAIwO,EAAOvO,EAAIsO,EAASs7B,GACnCzrC,EAAIs5C,iBAAiB13C,EAAIwO,EAAOvO,EAAIsO,EAAQvO,EAAIwO,EAAQq7B,EAAa5pC,EAAIsO,GAC1D,WAAX2jC,GACF3gD,KAAKqkD,UAAUQ,EAAIh4C,EAAKq5C,EAAal+C,GAEvC6E,EAAIgyB,OAAOpwB,EAAI4pC,EAAY3pC,EAAIsO,GAC/BnQ,EAAIs5C,iBAAiB13C,EAAGC,EAAIsO,EAAQvO,EAAGC,EAAIsO,EAASq7B,GACrC,WAAXsI,GAAkC,SAAXE,GACzB7gD,KAAKqkD,UAAUQ,EAAIh4C,EAAKq5C,EAAal+C,GAEvC6E,EAAIgyB,OAAOpwB,EAAGC,EAAIypC,GAClBtrC,EAAIs5C,iBAAiB13C,EAAGC,EAAGD,EAAI0pC,EAASzpC,GACxC7B,EAAI8oC,YAEJ9oC,EAAIoB,OAEAjG,EAAQiY,YAAc,GACxBpT,EAAIiyB,QAER,CAMAsnB,uBAAuBp+C,GACrB,MAAMxH,EAAQR,KAAKQ,MACbC,EAAQT,KAAKmI,YACbk+C,EAAQ5lD,GAASA,EAAMgO,EACvB63C,EAAQ7lD,GAASA,EAAMiO,EAC7B,GAAI23C,GAASC,EAAO,CAClB,MAAMxkC,EAAWs8B,GAAYp2C,EAAQ8Z,UAAUrgB,KAAKzB,KAAMA,KAAKqC,QAASrC,KAAK+iD,gBAC7E,IAAKjhC,EACH,OAEF,MAAMhZ,EAAO9I,KAAKgjD,MAAQ9D,GAAel/C,KAAMgI,GACzCk8C,EAAkB/8C,OAAOe,OAAO,CAAC,EAAG4Z,EAAU9hB,KAAKgjD,OACnD3B,EAAYH,GAAmB1gD,EAAOwH,EAASk8C,GAC/CzjC,EAAQ2gC,GAAmBp5C,EAASk8C,EAAiB7C,EAAW7gD,GAClE6lD,EAAMtgD,MAAQ0a,EAAMhS,GAAK63C,EAAMvgD,MAAQ0a,EAAM/R,IAC/C1O,KAAK6gD,OAASQ,EAAUR,OACxB7gD,KAAK2gD,OAASU,EAAUV,OACxB3gD,KAAKid,MAAQnU,EAAKmU,MAClBjd,KAAKgd,OAASlU,EAAKkU,OACnBhd,KAAKojD,OAASthC,EAASrT,EACvBzO,KAAKqjD,OAASvhC,EAASpT,EACvB1O,KAAKoW,qBAAqBlQ,OAAOlG,KAAMygB,IAG7C,CAMA8lC,cACE,QAASvmD,KAAK8iD,OAChB,CAEA1gD,KAAKyK,GACH,MAAM7E,EAAUhI,KAAKgI,QAAQsqB,WAAWtyB,KAAKoR,cAC7C,IAAI0xC,EAAU9iD,KAAK8iD,QAEnB,IAAKA,EACH,OAGF9iD,KAAKomD,uBAAuBp+C,GAE5B,MAAMk+C,EAAc,CAClBjpC,MAAOjd,KAAKid,MACZD,OAAQhd,KAAKgd,QAET6nC,EAAK,CACTp2C,EAAGzO,KAAKyO,EACRC,EAAG1O,KAAK0O,GAIVo0C,EAAU1hD,KAAKmY,IAAIupC,GAAW,KAAO,EAAIA,EAEzC,MAAMh8B,GAAUU,EAAAA,EAAAA,GAAUxf,EAAQ8e,SAG5B0/B,EAAoBxmD,KAAKq3B,MAAMp1B,QAAUjC,KAAKggD,WAAW/9C,QAAUjC,KAAKo/C,KAAKn9C,QAAUjC,KAAKigD,UAAUh+C,QAAUjC,KAAKq/C,OAAOp9C,OAE9H+F,EAAQ+sB,SAAWyxB,IACrB35C,EAAIkxB,OACJlxB,EAAI45C,YAAc3D,EAGlB9iD,KAAK69B,eAAegnB,EAAIh4C,EAAKq5C,EAAal+C,IAE1C4zC,EAAAA,EAAAA,IAAsB/uC,EAAK7E,EAAQ6zC,eAEnCgJ,EAAGn2C,GAAKoY,EAAQ5S,IAGhBlU,KAAKu/B,UAAUslB,EAAIh4C,EAAK7E,GAGxBhI,KAAKwlD,SAASX,EAAIh4C,EAAK7E,GAGvBhI,KAAK+lD,WAAWlB,EAAIh4C,EAAK7E,IAEzB80C,EAAAA,EAAAA,IAAqBjwC,EAAK7E,EAAQ6zC,eAElChvC,EAAIqxB,UAER,CAMA4S,oBACE,OAAO9wC,KAAKqC,SAAW,EACzB,CAOA0uC,kBAAkBC,EAAgBsN,GAChC,MAAMrN,EAAajxC,KAAKqC,QAClB4D,EAAS+qC,EAAenE,KAAI,EAAE7iC,eAAcN,YAChD,MAAMW,EAAOrK,KAAKQ,MAAMsP,eAAe9F,GAEvC,IAAKK,EACH,MAAM,IAAI02B,MAAM,kCAAoC/2B,GAGtD,MAAO,CACLA,eACA8K,QAASzK,EAAKuF,KAAKlG,GACnBA,QACD,IAEG+c,IAAWyqB,EAAAA,EAAAA,IAAeD,EAAYhrC,GACtCygD,EAAkB1mD,KAAK2mD,iBAAiB1gD,EAAQq4C,IAElD73B,GAAWigC,KACb1mD,KAAKqC,QAAU4D,EACfjG,KAAK+iD,eAAiBzE,EACtBt+C,KAAK4mD,qBAAsB,EAC3B5mD,KAAKkG,QAAO,GAEhB,CASAm3C,YAAYl5B,EAAGitB,EAAQK,GAAc,GACnC,GAAIL,GAAUpxC,KAAK4mD,oBACjB,OAAO,EAET5mD,KAAK4mD,qBAAsB,EAE3B,MAAM5+C,EAAUhI,KAAKgI,QACfipC,EAAajxC,KAAKqC,SAAW,GAC7B4D,EAASjG,KAAK4xC,mBAAmBztB,EAAG8sB,EAAYG,EAAQK,GAKxDiV,EAAkB1mD,KAAK2mD,iBAAiB1gD,EAAQke,GAGhDsC,EAAU2qB,KAAWF,EAAAA,EAAAA,IAAejrC,EAAQgrC,IAAeyV,EAgBjE,OAbIjgC,IACFzmB,KAAKqC,QAAU4D,GAEX+B,EAAQ+sB,SAAW/sB,EAAQo8C,YAC7BpkD,KAAK+iD,eAAiB,CACpBt0C,EAAG0V,EAAE1V,EACLC,EAAGyV,EAAEzV,GAGP1O,KAAKkG,QAAO,EAAMkrC,KAIf3qB,CACT,CAWAmrB,mBAAmBztB,EAAG8sB,EAAYG,EAAQK,GACxC,MAAMzpC,EAAUhI,KAAKgI,QAErB,GAAe,aAAXmc,EAAExjB,KACJ,MAAO,GAGT,IAAK8wC,EAEH,OAAOR,EAIT,MAAMhrC,EAASjG,KAAKQ,MAAMkvC,0BAA0BvrB,EAAGnc,EAAQ+B,KAAM/B,EAASopC,GAM9E,OAJIppC,EAAQmB,SACVlD,EAAOkD,UAGFlD,CACT,CASA0gD,iBAAiB1gD,EAAQke,GACvB,MAAM,OAACi/B,EAAA,OAAQC,EAAA,QAAQr7C,GAAWhI,KAC5B8hB,EAAWs8B,GAAYp2C,EAAQ8Z,UAAUrgB,KAAKzB,KAAMiG,EAAQke,GAClE,OAAoB,IAAbrC,IAAuBshC,IAAWthC,EAASrT,GAAK40C,IAAWvhC,EAASpT,EAC7E,EAGF,IAAAm4C,GAAe,CACbl7C,GAAI,UACJiyC,SAAUiF,GACVzE,eAEA0I,UAAUtmD,EAAOq9C,EAAO71C,GAClBA,IACFxH,EAAM2+C,QAAU,IAAI0D,GAAQ,CAACriD,QAAOwH,YAExC,EAEAgrB,aAAaxyB,EAAOq9C,EAAO71C,GACrBxH,EAAM2+C,SACR3+C,EAAM2+C,QAAQtxC,WAAW7F,EAE7B,EAEAiI,MAAMzP,EAAOq9C,EAAO71C,GACdxH,EAAM2+C,SACR3+C,EAAM2+C,QAAQtxC,WAAW7F,EAE7B,EAEA++C,UAAUvmD,GACR,MAAM2+C,EAAU3+C,EAAM2+C,QAEtB,GAAIA,GAAWA,EAAQoH,cAAe,CACpC,MAAMruC,EAAO,CACXinC,WAGF,IAA8E,IAA1E3+C,EAAM41B,cAAc,oBAAqB,IAAIle,EAAMqsB,YAAY,IACjE,OAGF4a,EAAQ/8C,KAAK5B,EAAMqM,KAEnBrM,EAAM41B,cAAc,mBAAoBle,GAE5C,EAEA6lC,WAAWv9C,EAAO0X,GAChB,GAAI1X,EAAM2+C,QAAS,CAEjB,MAAMh9B,EAAmBjK,EAAKk5B,OAC1B5wC,EAAM2+C,QAAQ9B,YAAYnlC,EAAKlV,MAAOmf,EAAkBjK,EAAKu5B,eAE/Dv5B,EAAKuO,SAAU,GAGrB,EAEApf,SAAU,CACR0tB,SAAS,EACTqvB,SAAU,KACVtiC,SAAU,UACVgc,gBAAiB,kBACjBgnB,WAAY,OACZ/H,UAAW,CACTj4B,OAAQ,QAEVo7B,aAAc,EACdC,kBAAmB,EACnBxvB,WAAY,OACZ4xB,UAAW,OACXlC,YAAa,EACbf,SAAU,CAAC,EAEXmG,UAAW,OACXQ,YAAa,OACb1F,cAAe,EACfD,gBAAiB,EACjBf,WAAY,CACVz6B,OAAQ,QAEVkhC,YAAa,OACbl/B,QAAS,EACTk6B,aAAc,EACdD,UAAW,EACXO,aAAc,EACdzI,UAAWA,CAAChsC,EAAK3D,IAASA,EAAKo2C,SAASx2C,KACxCgwC,SAAUA,CAACjsC,EAAK3D,IAASA,EAAKo2C,SAASx2C,KACvCs8C,mBAAoB,OACpBhF,eAAe,EACfl7B,WAAY,EACZstB,YAAa,gBACbvyB,YAAa,EACb3Y,UAAW,CACTvG,SAAU,IACVsE,OAAQ,gBAEVgD,WAAY,CACVqT,QAAS,CACP/a,KAAM,SACNiH,WAAY,CAAC,IAAK,IAAK,QAAS,SAAU,SAAU,WAEtDk7C,QAAS,CACPz9C,OAAQ,SACRtE,SAAU,MAGdH,UAAWihD,IAGb3gB,cAAe,CACboe,SAAU,OACVC,WAAY,OACZxC,UAAW,QAGbhb,YAAa,CACXwS,YAAc72B,GAAkB,WAATA,GAA8B,aAATA,GAAgC,aAATA,EACnE82B,YAAY,EACZ5zC,UAAW,CACT2zC,aAAa,EACbC,YAAY,GAEdltC,UAAW,CACT0/C,WAAW,GAEb3+C,WAAY,CACV2+C,UAAW,cAKfjf,uBAAwB,CAAC,gBCjyC3B,SAASkf,GAAkBp+C,GACzB,MAAMkJ,EAAS/R,KAAKgS,YAEpB,OAAInJ,GAAS,GAAKA,EAAQkJ,EAAO9P,OACxB8P,EAAOlJ,GAETA,CACT,CAEe,MAAMq+C,WAAsBn2B,GAEzCpkB,UAAY,WAKZA,gBAAkB,CAChB8M,MAAO,CACLwZ,SAAUg0B,KAIdlnD,YAAY8E,GACVsX,MAAMtX,GAGN7E,KAAKmnD,iBAAc7mD,EACnBN,KAAKonD,YAAc,EACnBpnD,KAAKqnD,aAAe,EACtB,CAEAh1B,KAAKsT,GACH,MAAM2hB,EAAQtnD,KAAKqnD,aACnB,GAAIC,EAAMrlD,OAAQ,CAChB,MAAM8P,EAAS/R,KAAKgS,YACpB,IAAK,MAAM,MAACtI,EAAA,MAAOkK,KAAU0zC,EACvBv1C,EAAOrI,KAAWkK,GACpB7B,EAAOiG,OAAOtO,EAAO,GAGzB1J,KAAKqnD,aAAe,GAEtBlrC,MAAMkW,KAAKsT,EACb,CAEAr0B,MAAMgE,EAAK5L,GACT,IAAIgT,EAAAA,EAAAA,GAAcpH,GAChB,OAAO,KAET,MAAMvD,EAAS/R,KAAKgS,YAGpB,MAtDe+d,EAACrmB,EAAOlG,IAAkB,OAAVkG,EAAiB,MAAO0tB,EAAAA,EAAAA,GAAYh2B,KAAK+tB,MAAMzlB,GAAQ,EAAGlG,GAsDlFusB,CAFPrmB,EAAQ69C,SAAS79C,IAAUqI,EAAOrI,KAAW4L,EAAM5L,EA7DvD,SAAwBqI,EAAQuD,EAAK5L,EAAO89C,GAC1C,MAAMtyB,EAAQnjB,EAAOwL,QAAQjI,GAC7B,OAAe,IAAX4f,EAZcuyB,EAAC11C,EAAQuD,EAAK5L,EAAO89C,KACpB,iBAARlyC,GACT5L,EAAQqI,EAAO7O,KAAKoS,GAAO,EAC3BkyC,EAAYE,QAAQ,CAACh+C,QAAOkK,MAAO0B,KAC1BgI,MAAMhI,KACf5L,EAAQ,MAEHA,GAME+9C,CAAY11C,EAAQuD,EAAK5L,EAAO89C,GAGlCtyB,IADMnjB,EAAO41C,YAAYryC,GACR5L,EAAQwrB,CAClC,CAuDQ0yB,CAAe71C,EAAQuD,GAAKxG,EAAAA,EAAAA,GAAepF,EAAO4L,GAAMtV,KAAKqnD,cACxCt1C,EAAO9P,OAAS,EAC3C,CAEAyxB,sBACE,MAAM,WAACrgB,EAAA,WAAYC,GAActT,KAAKuT,gBACtC,IAAI,IAAClS,EAAG,IAAEmC,GAAOxD,KAAK2S,WAAU,GAEJ,UAAxB3S,KAAKgI,QAAQgvC,SACV3jC,IACHhS,EAAM,GAEHiS,IACH9P,EAAMxD,KAAKgS,YAAY/P,OAAS,IAIpCjC,KAAKqB,IAAMA,EACXrB,KAAKwD,IAAMA,CACb,CAEAswB,aACE,MAAMzyB,EAAMrB,KAAKqB,IACXmC,EAAMxD,KAAKwD,IACXoY,EAAS5b,KAAKgI,QAAQ4T,OACtBnC,EAAQ,GACd,IAAI1H,EAAS/R,KAAKgS,YAGlBD,EAAkB,IAAT1Q,GAAcmC,IAAQuO,EAAO9P,OAAS,EAAK8P,EAASA,EAAOs7B,MAAMhsC,EAAKmC,EAAM,GAErFxD,KAAKonD,YAAchmD,KAAKoC,IAAIuO,EAAO9P,QAAU2Z,EAAS,EAAI,GAAI,GAC9D5b,KAAKmnD,YAAcnnD,KAAKqB,KAAOua,EAAS,GAAM,GAE9C,IAAK,IAAI/S,EAAQxH,EAAKwH,GAASrF,EAAKqF,IAClC4Q,EAAMvW,KAAK,CAAC2F,UAEd,OAAO4Q,CACT,CAEA5F,iBAAiBhL,GACf,OAAOo+C,GAAkBxlD,KAAKzB,KAAM6I,EACtC,CAKA7B,YACEmV,MAAMnV,YAEDhH,KAAKsc,iBAERtc,KAAKshB,gBAAkBthB,KAAKshB,eAEhC,CAGA9H,iBAAiB3Q,GAKf,MAJqB,iBAAVA,IACTA,EAAQ7I,KAAKsR,MAAMzI,IAGJ,OAAVA,EAAiB6J,IAAM1S,KAAKue,oBAAoB1V,EAAQ7I,KAAKmnD,aAAennD,KAAKonD,YAC1F,CAIA1tC,gBAAgBhQ,GACd,MAAM+P,EAAQzZ,KAAKyZ,MACnB,OAAI/P,EAAQ,GAAKA,EAAQ+P,EAAMxX,OAAS,EAC/B,KAEFjC,KAAKwZ,iBAAiBC,EAAM/P,GAAOb,MAC5C,CAEA4V,iBAAiBob,GACf,OAAOz4B,KAAK+tB,MAAMnvB,KAAKmnD,YAAcnnD,KAAKi6B,mBAAmBJ,GAAS75B,KAAKonD,YAC7E,CAEA/qC,eACE,OAAOrc,KAAKoU,MACd,ECVF,SAASyzC,GAAkBh/C,EAAOi/C,GAAY,WAACrtC,EAAU,YAAEgc,IACzD,MAAMsxB,GAAMjwB,EAAAA,EAAAA,GAAUrB,GAChBpb,GAASZ,EAAarZ,KAAK42B,IAAI+vB,GAAO3mD,KAAK22B,IAAIgwB,KAAS,KACxD9lD,EAAS,IAAO6lD,GAAc,GAAKj/C,GAAO5G,OAChD,OAAOb,KAAKC,IAAIymD,EAAazsC,EAAOpZ,EACtC,CAEe,MAAM+lD,WAAwBj3B,GAE3ChxB,YAAY8E,GACVsX,MAAMtX,GAGN7E,KAAKsB,WAAQhB,EAEbN,KAAKoJ,SAAM9I,EAEXN,KAAKmnD,iBAAc7mD,EAEnBN,KAAKioD,eAAY3nD,EACjBN,KAAKonD,YAAc,CACrB,CAEA91C,MAAMgE,EAAK5L,GACT,OAAIgT,EAAAA,EAAAA,GAAcpH,KAGE,iBAARA,GAAoBA,aAAetC,UAAYu0C,UAAUjyC,GAF5D,MAMDA,CACV,CAEA4yC,yBACE,MAAM,YAACnsC,GAAe/b,KAAKgI,SACrB,WAACqL,EAAA,WAAYC,GAActT,KAAKuT,gBACtC,IAAI,IAAClS,EAAG,IAAEmC,GAAOxD,KAEjB,MAAMmoD,EAASjtC,GAAM7Z,EAAMgS,EAAahS,EAAM6Z,EACxCktC,EAASltC,GAAM1X,EAAM8P,EAAa9P,EAAM0X,EAE9C,GAAIa,EAAa,CACf,MAAMssC,GAAUl+C,EAAAA,EAAAA,GAAK9I,GACfinD,GAAUn+C,EAAAA,EAAAA,GAAK3G,GAEjB6kD,EAAU,GAAKC,EAAU,EAC3BF,EAAO,GACEC,EAAU,GAAKC,EAAU,GAClCH,EAAO,GAIX,GAAI9mD,IAAQmC,EAAK,CACf,IAAIoY,EAAiB,IAARpY,EAAY,EAAIpC,KAAKmY,IAAU,IAAN/V,GAEtC4kD,EAAO5kD,EAAMoY,GAERG,GACHosC,EAAO9mD,EAAMua,GAGjB5b,KAAKqB,IAAMA,EACXrB,KAAKwD,IAAMA,CACb,CAEA+kD,eACE,MAAMn1B,EAAWpzB,KAAKgI,QAAQyR,MAE9B,IACI+uC,GADA,cAACj5B,EAAA,SAAek5B,GAAYr1B,EAkBhC,OAfIq1B,GACFD,EAAWpnD,KAAK8tB,KAAKlvB,KAAKwD,IAAMilD,GAAYrnD,KAAKoE,MAAMxF,KAAKqB,IAAMonD,GAAY,EAC1ED,EAAW,MACbr6C,QAAQC,KAAM,UAASpO,KAAK2L,sBAAsB88C,mCAA0CD,8BAC5FA,EAAW,OAGbA,EAAWxoD,KAAK0oD,mBAChBn5B,EAAgBA,GAAiB,IAG/BA,IACFi5B,EAAWpnD,KAAKC,IAAIkuB,EAAei5B,IAG9BA,CACT,CAKAE,mBACE,OAAO11C,OAAOC,iBAChB,CAEA6gB,aACE,MAAM5qB,EAAOlJ,KAAKgI,QACZorB,EAAWlqB,EAAKuQ,MAMtB,IAAI+uC,EAAWxoD,KAAKuoD,eACpBC,EAAWpnD,KAAKoC,IAAI,EAAGglD,GAEvB,MAcM/uC,EApPV,SAAuBkvC,EAAmBC,GACxC,MAAMnvC,EAAQ,IAMR,OAACu9B,EAAM,KAAEvb,EAAA,IAAMp6B,EAAA,IAAKmC,EAAG,UAAEqlD,EAAA,MAAWt3C,EAAA,SAAOi3C,EAAQ,UAAEM,EAAA,cAAWC,GAAiBJ,EACjFK,EAAOvtB,GAAQ,EACfwtB,EAAYT,EAAW,GACtBnnD,IAAK6nD,EAAM1lD,IAAK2lD,GAAQP,EACzBv1C,IAAcqJ,EAAAA,EAAAA,GAAcrb,GAC5BiS,IAAcoJ,EAAAA,EAAAA,GAAclZ,GAC5B4lD,IAAgB1sC,EAAAA,EAAAA,GAAcnL,GAC9Bu2C,GAAcqB,EAAOD,IAASJ,EAAY,GAChD,IACI1kD,EAAQilD,EAASC,EAASC,EAD1Bx6B,GAAUy6B,EAAAA,EAAAA,KAASL,EAAOD,GAAQD,EAAYD,GAAQA,EAK1D,GAAIj6B,EAdgB,QAcU1b,IAAeC,EAC3C,MAAO,CAAC,CAACzK,MAAOqgD,GAAO,CAACrgD,MAAOsgD,IAGjCI,EAAYnoD,KAAK8tB,KAAKi6B,EAAOp6B,GAAW3tB,KAAKoE,MAAM0jD,EAAOn6B,GACtDw6B,EAAYN,IAEdl6B,GAAUy6B,EAAAA,EAAAA,IAAQD,EAAYx6B,EAAUk6B,EAAYD,GAAQA,IAGzDtsC,EAAAA,EAAAA,GAAcmsC,KAEjBzkD,EAAShD,KAAK6hB,IAAI,GAAI4lC,GACtB95B,EAAU3tB,KAAK8tB,KAAKH,EAAU3qB,GAAUA,GAG3B,UAAX4yC,GACFqS,EAAUjoD,KAAKoE,MAAM0jD,EAAOn6B,GAAWA,EACvCu6B,EAAUloD,KAAK8tB,KAAKi6B,EAAOp6B,GAAWA,IAEtCs6B,EAAUH,EACVI,EAAUH,GAGR91C,GAAcC,GAAcmoB,IAAQguB,EAAAA,EAAAA,KAAajmD,EAAMnC,GAAOo6B,EAAM1M,EAAU,MAKhFw6B,EAAYnoD,KAAK+tB,MAAM/tB,KAAKC,KAAKmC,EAAMnC,GAAO0tB,EAASy5B,IACvDz5B,GAAWvrB,EAAMnC,GAAOkoD,EACxBF,EAAUhoD,EACVioD,EAAU9lD,GACD4lD,GAITC,EAAUh2C,EAAahS,EAAMgoD,EAC7BC,EAAUh2C,EAAa9P,EAAM8lD,EAC7BC,EAAYh4C,EAAQ,EACpBwd,GAAWu6B,EAAUD,GAAWE,IAGhCA,GAAaD,EAAUD,GAAWt6B,EAIhCw6B,GADEG,EAAAA,EAAAA,IAAaH,EAAWnoD,KAAK+tB,MAAMo6B,GAAYx6B,EAAU,KAC/C3tB,KAAK+tB,MAAMo6B,GAEXnoD,KAAK8tB,KAAKq6B,IAM1B,MAAMI,EAAgBvoD,KAAKoC,KACzBomD,EAAAA,EAAAA,IAAe76B,IACf66B,EAAAA,EAAAA,IAAeP,IAEjBjlD,EAAShD,KAAK6hB,IAAI,IAAIvG,EAAAA,EAAAA,GAAcmsC,GAAac,EAAgBd,GACjEQ,EAAUjoD,KAAK+tB,MAAMk6B,EAAUjlD,GAAUA,EACzCklD,EAAUloD,KAAK+tB,MAAMm6B,EAAUllD,GAAUA,EAEzC,IAAI6d,EAAI,EAiBR,IAhBI5O,IACE01C,GAAiBM,IAAYhoD,GAC/BoY,EAAMvW,KAAK,CAAC2F,MAAOxH,IAEfgoD,EAAUhoD,GACZ4gB,KAGEynC,EAAAA,EAAAA,IAAatoD,KAAK+tB,OAAOk6B,EAAUpnC,EAAI8M,GAAW3qB,GAAUA,EAAQ/C,EAAKwmD,GAAkBxmD,EAAKymD,EAAYa,KAC9G1mC,KAEOonC,EAAUhoD,GACnB4gB,KAIGA,EAAIsnC,IAAatnC,EAAG,CACzB,MAAM4nC,EAAYzoD,KAAK+tB,OAAOk6B,EAAUpnC,EAAI8M,GAAW3qB,GAAUA,EACjE,GAAIkP,GAAcu2C,EAAYrmD,EAC5B,MAEFiW,EAAMvW,KAAK,CAAC2F,MAAOghD,GACrB,CAaA,OAXIv2C,GAAcy1C,GAAiBO,IAAY9lD,EAEzCiW,EAAMxX,SAAUynD,EAAAA,EAAAA,IAAajwC,EAAMA,EAAMxX,OAAS,GAAG4G,MAAOrF,EAAKqkD,GAAkBrkD,EAAKskD,EAAYa,IACtGlvC,EAAMA,EAAMxX,OAAS,GAAG4G,MAAQrF,EAEhCiW,EAAMvW,KAAK,CAAC2F,MAAOrF,IAEX8P,GAAcg2C,IAAY9lD,GACpCiW,EAAMvW,KAAK,CAAC2F,MAAOygD,IAGd7vC,CACT,CA4HkBqwC,CAdkB,CAC9BtB,WACAxR,OAAQ9tC,EAAK8tC,OACb31C,IAAK6H,EAAK7H,IACVmC,IAAK0F,EAAK1F,IACVqlD,UAAWz1B,EAASy1B,UACpBptB,KAAMrI,EAASq1B,SACfl3C,MAAO6hB,EAAS7hB,MAChBu3C,UAAW9oD,KAAKkgC,aAChBzlB,WAAYza,KAAKsc,eACjBma,YAAarD,EAASqD,aAAe,EACrCsyB,eAA0C,IAA3B31B,EAAS21B,eAER/oD,KAAKwxB,QAAUxxB,MAmBjC,MAdoB,UAAhBkJ,EAAK8tC,SACP+S,EAAAA,EAAAA,IAAmBtwC,EAAOzZ,KAAM,SAG9BkJ,EAAKC,SACPsQ,EAAMtQ,UAENnJ,KAAKsB,MAAQtB,KAAKwD,IAClBxD,KAAKoJ,IAAMpJ,KAAKqB,MAEhBrB,KAAKsB,MAAQtB,KAAKqB,IAClBrB,KAAKoJ,IAAMpJ,KAAKwD,KAGXiW,CACT,CAKAzS,YACE,MAAMyS,EAAQzZ,KAAKyZ,MACnB,IAAInY,EAAQtB,KAAKqB,IACb+H,EAAMpJ,KAAKwD,IAIf,GAFA2Y,MAAMnV,YAEFhH,KAAKgI,QAAQ4T,QAAUnC,EAAMxX,OAAQ,CACvC,MAAM2Z,GAAUxS,EAAM9H,GAASF,KAAKoC,IAAIiW,EAAMxX,OAAS,EAAG,GAAK,EAC/DX,GAASsa,EACTxS,GAAOwS,EAET5b,KAAKmnD,YAAc7lD,EACnBtB,KAAKioD,UAAY7+C,EACjBpJ,KAAKonD,YAAch+C,EAAM9H,CAC3B,CAEAuS,iBAAiBhL,GACf,OAAOmhD,EAAAA,EAAAA,GAAanhD,EAAO7I,KAAKQ,MAAMwH,QAAQiiD,OAAQjqD,KAAKgI,QAAQyR,MAAMywC,OAC3E,EClTa,MAAMC,WAAoBnC,GAEvCr7C,UAAY,SAKZA,gBAAkB,CAChB8M,MAAO,CACLwZ,SAAUm3B,EAAAA,GAAMC,WAAWC,UAK/B52B,sBACE,MAAM,IAACryB,EAAG,IAAEmC,GAAOxD,KAAK2S,WAAU,GAElC3S,KAAKqB,KAAM6I,EAAAA,EAAAA,GAAS7I,GAAOA,EAAM,EACjCrB,KAAKwD,KAAM0G,EAAAA,EAAAA,GAAS1G,GAAOA,EAAM,EAGjCxD,KAAKkoD,wBACP,CAMAQ,mBACE,MAAMjuC,EAAaza,KAAKsc,eAClBra,EAASwY,EAAaza,KAAKid,MAAQjd,KAAKgd,OACxCyZ,GAAcqB,EAAAA,EAAAA,GAAU93B,KAAKgI,QAAQyR,MAAMgd,aAC3Cpb,GAASZ,EAAarZ,KAAK42B,IAAIvB,GAAer1B,KAAK22B,IAAItB,KAAiB,KACxEuC,EAAWh5B,KAAKq5B,wBAAwB,GAC9C,OAAOj4B,KAAK8tB,KAAKjtB,EAASb,KAAKC,IAAI,GAAI23B,EAAStI,WAAarV,GAC/D,CAGA7B,iBAAiB3Q,GACf,OAAiB,OAAVA,EAAiB6J,IAAM1S,KAAKue,oBAAoB1V,EAAQ7I,KAAKmnD,aAAennD,KAAKonD,YAC1F,CAEA3oC,iBAAiBob,GACf,OAAO75B,KAAKmnD,YAAcnnD,KAAKi6B,mBAAmBJ,GAAS75B,KAAKonD,WAClE,ECiCcgD,EAAAA,GAAMC,WAAWE,YC+RjBH,EAAAA,GAAMC,WAAWC","sources":["webpack://thoughtleaderscentral/../src/core/core.animator.js","webpack://thoughtleaderscentral/../src/core/core.animation.js","webpack://thoughtleaderscentral/../src/core/core.animations.js","webpack://thoughtleaderscentral/../src/core/core.datasetController.js","webpack://thoughtleaderscentral/../src/controllers/controller.bar.js","webpack://thoughtleaderscentral/../src/controllers/controller.line.js","webpack://thoughtleaderscentral/../src/core/core.interaction.js","webpack://thoughtleaderscentral/../src/core/core.layouts.js","webpack://thoughtleaderscentral/../src/platform/platform.base.js","webpack://thoughtleaderscentral/../src/platform/platform.basic.js","webpack://thoughtleaderscentral/../src/platform/platform.dom.js","webpack://thoughtleaderscentral/../src/core/core.element.ts","webpack://thoughtleaderscentral/../src/core/core.scale.autoskip.js","webpack://thoughtleaderscentral/../src/core/core.scale.js","webpack://thoughtleaderscentral/../src/core/core.typedRegistry.js","webpack://thoughtleaderscentral/../src/core/core.registry.js","webpack://thoughtleaderscentral/../src/core/core.plugins.js","webpack://thoughtleaderscentral/../src/core/core.config.js","webpack://thoughtleaderscentral/../src/core/core.controller.js","webpack://thoughtleaderscentral/../src/platform/index.js","webpack://thoughtleaderscentral/../src/elements/element.line.js","webpack://thoughtleaderscentral/../src/elements/element.point.ts","webpack://thoughtleaderscentral/../src/elements/element.bar.js","webpack://thoughtleaderscentral/../src/plugins/plugin.legend.js","webpack://thoughtleaderscentral/../src/plugins/plugin.subtitle.js","webpack://thoughtleaderscentral/../src/plugins/plugin.tooltip.js","webpack://thoughtleaderscentral/../src/scales/scale.category.js","webpack://thoughtleaderscentral/../src/scales/scale.linearbase.js","webpack://thoughtleaderscentral/../src/scales/scale.linear.js","webpack://thoughtleaderscentral/../src/scales/scale.logarithmic.js","webpack://thoughtleaderscentral/../src/scales/scale.radialLinear.js"],"sourcesContent":["import {requestAnimFrame} from '../helpers/helpers.extras.js';\n\n/**\n * @typedef { import('./core.animation.js').default } Animation\n * @typedef { import('./core.controller.js').default } Chart\n */\n\n/**\n * Please use the module's default export which provides a singleton instance\n * Note: class is export for typedoc\n */\nexport class Animator {\n  constructor() {\n    this._request = null;\n    this._charts = new Map();\n    this._running = false;\n    this._lastDate = undefined;\n  }\n\n  /**\n\t * @private\n\t */\n  _notify(chart, anims, date, type) {\n    const callbacks = anims.listeners[type];\n    const numSteps = anims.duration;\n\n    callbacks.forEach(fn => fn({\n      chart,\n      initial: anims.initial,\n      numSteps,\n      currentStep: Math.min(date - anims.start, numSteps)\n    }));\n  }\n\n  /**\n\t * @private\n\t */\n  _refresh() {\n    if (this._request) {\n      return;\n    }\n    this._running = true;\n\n    this._request = requestAnimFrame.call(window, () => {\n      this._update();\n      this._request = null;\n\n      if (this._running) {\n        this._refresh();\n      }\n    });\n  }\n\n  /**\n\t * @private\n\t */\n  _update(date = Date.now()) {\n    let remaining = 0;\n\n    this._charts.forEach((anims, chart) => {\n      if (!anims.running || !anims.items.length) {\n        return;\n      }\n      const items = anims.items;\n      let i = items.length - 1;\n      let draw = false;\n      let item;\n\n      for (; i >= 0; --i) {\n        item = items[i];\n\n        if (item._active) {\n          if (item._total > anims.duration) {\n            // if the animation has been updated and its duration prolonged,\n            // update to total duration of current animations run (for progress event)\n            anims.duration = item._total;\n          }\n          item.tick(date);\n          draw = true;\n        } else {\n          // Remove the item by replacing it with last item and removing the last\n          // A lot faster than splice.\n          items[i] = items[items.length - 1];\n          items.pop();\n        }\n      }\n\n      if (draw) {\n        chart.draw();\n        this._notify(chart, anims, date, 'progress');\n      }\n\n      if (!items.length) {\n        anims.running = false;\n        this._notify(chart, anims, date, 'complete');\n        anims.initial = false;\n      }\n\n      remaining += items.length;\n    });\n\n    this._lastDate = date;\n\n    if (remaining === 0) {\n      this._running = false;\n    }\n  }\n\n  /**\n\t * @private\n\t */\n  _getAnims(chart) {\n    const charts = this._charts;\n    let anims = charts.get(chart);\n    if (!anims) {\n      anims = {\n        running: false,\n        initial: true,\n        items: [],\n        listeners: {\n          complete: [],\n          progress: []\n        }\n      };\n      charts.set(chart, anims);\n    }\n    return anims;\n  }\n\n  /**\n\t * @param {Chart} chart\n\t * @param {string} event - event name\n\t * @param {Function} cb - callback\n\t */\n  listen(chart, event, cb) {\n    this._getAnims(chart).listeners[event].push(cb);\n  }\n\n  /**\n\t * Add animations\n\t * @param {Chart} chart\n\t * @param {Animation[]} items - animations\n\t */\n  add(chart, items) {\n    if (!items || !items.length) {\n      return;\n    }\n    this._getAnims(chart).items.push(...items);\n  }\n\n  /**\n\t * Counts number of active animations for the chart\n\t * @param {Chart} chart\n\t */\n  has(chart) {\n    return this._getAnims(chart).items.length > 0;\n  }\n\n  /**\n\t * Start animating (all charts)\n\t * @param {Chart} chart\n\t */\n  start(chart) {\n    const anims = this._charts.get(chart);\n    if (!anims) {\n      return;\n    }\n    anims.running = true;\n    anims.start = Date.now();\n    anims.duration = anims.items.reduce((acc, cur) => Math.max(acc, cur._duration), 0);\n    this._refresh();\n  }\n\n  running(chart) {\n    if (!this._running) {\n      return false;\n    }\n    const anims = this._charts.get(chart);\n    if (!anims || !anims.running || !anims.items.length) {\n      return false;\n    }\n    return true;\n  }\n\n  /**\n\t * Stop all animations for the chart\n\t * @param {Chart} chart\n\t */\n  stop(chart) {\n    const anims = this._charts.get(chart);\n    if (!anims || !anims.items.length) {\n      return;\n    }\n    const items = anims.items;\n    let i = items.length - 1;\n\n    for (; i >= 0; --i) {\n      items[i].cancel();\n    }\n    anims.items = [];\n    this._notify(chart, anims, Date.now(), 'complete');\n  }\n\n  /**\n\t * Remove chart from Animator\n\t * @param {Chart} chart\n\t */\n  remove(chart) {\n    return this._charts.delete(chart);\n  }\n}\n\n// singleton instance\nexport default /* #__PURE__ */ new Animator();\n","import effects from '../helpers/helpers.easing.js';\nimport {resolve} from '../helpers/helpers.options.js';\nimport {color as helpersColor} from '../helpers/helpers.color.js';\n\nconst transparent = 'transparent';\nconst interpolators = {\n  boolean(from, to, factor) {\n    return factor > 0.5 ? to : from;\n  },\n  /**\n   * @param {string} from\n   * @param {string} to\n   * @param {number} factor\n   */\n  color(from, to, factor) {\n    const c0 = helpersColor(from || transparent);\n    const c1 = c0.valid && helpersColor(to || transparent);\n    return c1 && c1.valid\n      ? c1.mix(c0, factor).hexString()\n      : to;\n  },\n  number(from, to, factor) {\n    return from + (to - from) * factor;\n  }\n};\n\nexport default class Animation {\n  constructor(cfg, target, prop, to) {\n    const currentValue = target[prop];\n\n    to = resolve([cfg.to, to, currentValue, cfg.from]);\n    const from = resolve([cfg.from, currentValue, to]);\n\n    this._active = true;\n    this._fn = cfg.fn || interpolators[cfg.type || typeof from];\n    this._easing = effects[cfg.easing] || effects.linear;\n    this._start = Math.floor(Date.now() + (cfg.delay || 0));\n    this._duration = this._total = Math.floor(cfg.duration);\n    this._loop = !!cfg.loop;\n    this._target = target;\n    this._prop = prop;\n    this._from = from;\n    this._to = to;\n    this._promises = undefined;\n  }\n\n  active() {\n    return this._active;\n  }\n\n  update(cfg, to, date) {\n    if (this._active) {\n      this._notify(false);\n\n      const currentValue = this._target[this._prop];\n      const elapsed = date - this._start;\n      const remain = this._duration - elapsed;\n      this._start = date;\n      this._duration = Math.floor(Math.max(remain, cfg.duration));\n      this._total += elapsed;\n      this._loop = !!cfg.loop;\n      this._to = resolve([cfg.to, to, currentValue, cfg.from]);\n      this._from = resolve([cfg.from, currentValue, to]);\n    }\n  }\n\n  cancel() {\n    if (this._active) {\n      // update current evaluated value, for smoother animations\n      this.tick(Date.now());\n      this._active = false;\n      this._notify(false);\n    }\n  }\n\n  tick(date) {\n    const elapsed = date - this._start;\n    const duration = this._duration;\n    const prop = this._prop;\n    const from = this._from;\n    const loop = this._loop;\n    const to = this._to;\n    let factor;\n\n    this._active = from !== to && (loop || (elapsed < duration));\n\n    if (!this._active) {\n      this._target[prop] = to;\n      this._notify(true);\n      return;\n    }\n\n    if (elapsed < 0) {\n      this._target[prop] = from;\n      return;\n    }\n\n    factor = (elapsed / duration) % 2;\n    factor = loop && factor > 1 ? 2 - factor : factor;\n    factor = this._easing(Math.min(1, Math.max(0, factor)));\n\n    this._target[prop] = this._fn(from, to, factor);\n  }\n\n  wait() {\n    const promises = this._promises || (this._promises = []);\n    return new Promise((res, rej) => {\n      promises.push({res, rej});\n    });\n  }\n\n  _notify(resolved) {\n    const method = resolved ? 'res' : 'rej';\n    const promises = this._promises || [];\n    for (let i = 0; i < promises.length; i++) {\n      promises[i][method]();\n    }\n  }\n}\n","import animator from './core.animator.js';\nimport Animation from './core.animation.js';\nimport defaults from './core.defaults.js';\nimport {isArray, isObject} from '../helpers/helpers.core.js';\n\nexport default class Animations {\n  constructor(chart, config) {\n    this._chart = chart;\n    this._properties = new Map();\n    this.configure(config);\n  }\n\n  configure(config) {\n    if (!isObject(config)) {\n      return;\n    }\n\n    const animationOptions = Object.keys(defaults.animation);\n    const animatedProps = this._properties;\n\n    Object.getOwnPropertyNames(config).forEach(key => {\n      const cfg = config[key];\n      if (!isObject(cfg)) {\n        return;\n      }\n      const resolved = {};\n      for (const option of animationOptions) {\n        resolved[option] = cfg[option];\n      }\n\n      (isArray(cfg.properties) && cfg.properties || [key]).forEach((prop) => {\n        if (prop === key || !animatedProps.has(prop)) {\n          animatedProps.set(prop, resolved);\n        }\n      });\n    });\n  }\n\n  /**\n\t * Utility to handle animation of `options`.\n\t * @private\n\t */\n  _animateOptions(target, values) {\n    const newOptions = values.options;\n    const options = resolveTargetOptions(target, newOptions);\n    if (!options) {\n      return [];\n    }\n\n    const animations = this._createAnimations(options, newOptions);\n    if (newOptions.$shared) {\n      // Going to shared options:\n      // After all animations are done, assign the shared options object to the element\n      // So any new updates to the shared options are observed\n      awaitAll(target.options.$animations, newOptions).then(() => {\n        target.options = newOptions;\n      }, () => {\n        // rejected, noop\n      });\n    }\n\n    return animations;\n  }\n\n  /**\n\t * @private\n\t */\n  _createAnimations(target, values) {\n    const animatedProps = this._properties;\n    const animations = [];\n    const running = target.$animations || (target.$animations = {});\n    const props = Object.keys(values);\n    const date = Date.now();\n    let i;\n\n    for (i = props.length - 1; i >= 0; --i) {\n      const prop = props[i];\n      if (prop.charAt(0) === '$') {\n        continue;\n      }\n\n      if (prop === 'options') {\n        animations.push(...this._animateOptions(target, values));\n        continue;\n      }\n      const value = values[prop];\n      let animation = running[prop];\n      const cfg = animatedProps.get(prop);\n\n      if (animation) {\n        if (cfg && animation.active()) {\n          // There is an existing active animation, let's update that\n          animation.update(cfg, value, date);\n          continue;\n        } else {\n          animation.cancel();\n        }\n      }\n      if (!cfg || !cfg.duration) {\n        // not animated, set directly to new value\n        target[prop] = value;\n        continue;\n      }\n\n      running[prop] = animation = new Animation(cfg, target, prop, value);\n      animations.push(animation);\n    }\n    return animations;\n  }\n\n\n  /**\n\t * Update `target` properties to new values, using configured animations\n\t * @param {object} target - object to update\n\t * @param {object} values - new target properties\n\t * @returns {boolean|undefined} - `true` if animations were started\n\t **/\n  update(target, values) {\n    if (this._properties.size === 0) {\n      // Nothing is animated, just apply the new values.\n      Object.assign(target, values);\n      return;\n    }\n\n    const animations = this._createAnimations(target, values);\n\n    if (animations.length) {\n      animator.add(this._chart, animations);\n      return true;\n    }\n  }\n}\n\nfunction awaitAll(animations, properties) {\n  const running = [];\n  const keys = Object.keys(properties);\n  for (let i = 0; i < keys.length; i++) {\n    const anim = animations[keys[i]];\n    if (anim && anim.active()) {\n      running.push(anim.wait());\n    }\n  }\n  // @ts-ignore\n  return Promise.all(running);\n}\n\nfunction resolveTargetOptions(target, newOptions) {\n  if (!newOptions) {\n    return;\n  }\n  let options = target.options;\n  if (!options) {\n    target.options = newOptions;\n    return;\n  }\n  if (options.$shared) {\n    // Going from shared options to distinct one:\n    // Create new options object containing the old shared values and start updating that.\n    target.options = options = Object.assign({}, options, {$shared: false, $animations: {}});\n  }\n  return options;\n}\n","import Animations from './core.animations.js';\nimport defaults from './core.defaults.js';\nimport {isArray, isFinite, isObject, valueOrDefault, resolveObjectKey, defined} from '../helpers/helpers.core.js';\nimport {listenArrayEvents, unlistenArrayEvents} from '../helpers/helpers.collection.js';\nimport {createContext, sign} from '../helpers/index.js';\n\n/**\n * @typedef { import('./core.controller.js').default } Chart\n * @typedef { import('./core.scale.js').default } Scale\n */\n\nfunction scaleClip(scale, allowedOverflow) {\n  const opts = scale && scale.options || {};\n  const reverse = opts.reverse;\n  const min = opts.min === undefined ? allowedOverflow : 0;\n  const max = opts.max === undefined ? allowedOverflow : 0;\n  return {\n    start: reverse ? max : min,\n    end: reverse ? min : max\n  };\n}\n\nfunction defaultClip(xScale, yScale, allowedOverflow) {\n  if (allowedOverflow === false) {\n    return false;\n  }\n  const x = scaleClip(xScale, allowedOverflow);\n  const y = scaleClip(yScale, allowedOverflow);\n\n  return {\n    top: y.end,\n    right: x.end,\n    bottom: y.start,\n    left: x.start\n  };\n}\n\nfunction toClip(value) {\n  let t, r, b, l;\n\n  if (isObject(value)) {\n    t = value.top;\n    r = value.right;\n    b = value.bottom;\n    l = value.left;\n  } else {\n    t = r = b = l = value;\n  }\n\n  return {\n    top: t,\n    right: r,\n    bottom: b,\n    left: l,\n    disabled: value === false\n  };\n}\n\nfunction getSortedDatasetIndices(chart, filterVisible) {\n  const keys = [];\n  const metasets = chart._getSortedDatasetMetas(filterVisible);\n  let i, ilen;\n\n  for (i = 0, ilen = metasets.length; i < ilen; ++i) {\n    keys.push(metasets[i].index);\n  }\n  return keys;\n}\n\nfunction applyStack(stack, value, dsIndex, options = {}) {\n  const keys = stack.keys;\n  const singleMode = options.mode === 'single';\n  let i, ilen, datasetIndex, otherValue;\n\n  if (value === null) {\n    return;\n  }\n\n  for (i = 0, ilen = keys.length; i < ilen; ++i) {\n    datasetIndex = +keys[i];\n    if (datasetIndex === dsIndex) {\n      if (options.all) {\n        continue;\n      }\n      break;\n    }\n    otherValue = stack.values[datasetIndex];\n    if (isFinite(otherValue) && (singleMode || (value === 0 || sign(value) === sign(otherValue)))) {\n      value += otherValue;\n    }\n  }\n  return value;\n}\n\nfunction convertObjectDataToArray(data) {\n  const keys = Object.keys(data);\n  const adata = new Array(keys.length);\n  let i, ilen, key;\n  for (i = 0, ilen = keys.length; i < ilen; ++i) {\n    key = keys[i];\n    adata[i] = {\n      x: key,\n      y: data[key]\n    };\n  }\n  return adata;\n}\n\nfunction isStacked(scale, meta) {\n  const stacked = scale && scale.options.stacked;\n  return stacked || (stacked === undefined && meta.stack !== undefined);\n}\n\nfunction getStackKey(indexScale, valueScale, meta) {\n  return `${indexScale.id}.${valueScale.id}.${meta.stack || meta.type}`;\n}\n\nfunction getUserBounds(scale) {\n  const {min, max, minDefined, maxDefined} = scale.getUserBounds();\n  return {\n    min: minDefined ? min : Number.NEGATIVE_INFINITY,\n    max: maxDefined ? max : Number.POSITIVE_INFINITY\n  };\n}\n\nfunction getOrCreateStack(stacks, stackKey, indexValue) {\n  const subStack = stacks[stackKey] || (stacks[stackKey] = {});\n  return subStack[indexValue] || (subStack[indexValue] = {});\n}\n\nfunction getLastIndexInStack(stack, vScale, positive, type) {\n  for (const meta of vScale.getMatchingVisibleMetas(type).reverse()) {\n    const value = stack[meta.index];\n    if ((positive && value > 0) || (!positive && value < 0)) {\n      return meta.index;\n    }\n  }\n\n  return null;\n}\n\nfunction updateStacks(controller, parsed) {\n  const {chart, _cachedMeta: meta} = controller;\n  const stacks = chart._stacks || (chart._stacks = {}); // map structure is {stackKey: {datasetIndex: value}}\n  const {iScale, vScale, index: datasetIndex} = meta;\n  const iAxis = iScale.axis;\n  const vAxis = vScale.axis;\n  const key = getStackKey(iScale, vScale, meta);\n  const ilen = parsed.length;\n  let stack;\n\n  for (let i = 0; i < ilen; ++i) {\n    const item = parsed[i];\n    const {[iAxis]: index, [vAxis]: value} = item;\n    const itemStacks = item._stacks || (item._stacks = {});\n    stack = itemStacks[vAxis] = getOrCreateStack(stacks, key, index);\n    stack[datasetIndex] = value;\n\n    stack._top = getLastIndexInStack(stack, vScale, true, meta.type);\n    stack._bottom = getLastIndexInStack(stack, vScale, false, meta.type);\n\n    const visualValues = stack._visualValues || (stack._visualValues = {});\n    visualValues[datasetIndex] = value;\n  }\n}\n\nfunction getFirstScaleId(chart, axis) {\n  const scales = chart.scales;\n  return Object.keys(scales).filter(key => scales[key].axis === axis).shift();\n}\n\nfunction createDatasetContext(parent, index) {\n  return createContext(parent,\n    {\n      active: false,\n      dataset: undefined,\n      datasetIndex: index,\n      index,\n      mode: 'default',\n      type: 'dataset'\n    }\n  );\n}\n\nfunction createDataContext(parent, index, element) {\n  return createContext(parent, {\n    active: false,\n    dataIndex: index,\n    parsed: undefined,\n    raw: undefined,\n    element,\n    index,\n    mode: 'default',\n    type: 'data'\n  });\n}\n\nfunction clearStacks(meta, items) {\n  // Not using meta.index here, because it might be already updated if the dataset changed location\n  const datasetIndex = meta.controller.index;\n  const axis = meta.vScale && meta.vScale.axis;\n  if (!axis) {\n    return;\n  }\n\n  items = items || meta._parsed;\n  for (const parsed of items) {\n    const stacks = parsed._stacks;\n    if (!stacks || stacks[axis] === undefined || stacks[axis][datasetIndex] === undefined) {\n      return;\n    }\n    delete stacks[axis][datasetIndex];\n    if (stacks[axis]._visualValues !== undefined && stacks[axis]._visualValues[datasetIndex] !== undefined) {\n      delete stacks[axis]._visualValues[datasetIndex];\n    }\n  }\n}\n\nconst isDirectUpdateMode = (mode) => mode === 'reset' || mode === 'none';\nconst cloneIfNotShared = (cached, shared) => shared ? cached : Object.assign({}, cached);\nconst createStack = (canStack, meta, chart) => canStack && !meta.hidden && meta._stacked\n  && {keys: getSortedDatasetIndices(chart, true), values: null};\n\nexport default class DatasetController {\n\n  /**\n   * @type {any}\n   */\n  static defaults = {};\n\n  /**\n   * Element type used to generate a meta dataset (e.g. Chart.element.LineElement).\n   */\n  static datasetElementType = null;\n\n  /**\n   * Element type used to generate a meta data (e.g. Chart.element.PointElement).\n   */\n  static dataElementType = null;\n\n  /**\n\t * @param {Chart} chart\n\t * @param {number} datasetIndex\n\t */\n  constructor(chart, datasetIndex) {\n    this.chart = chart;\n    this._ctx = chart.ctx;\n    this.index = datasetIndex;\n    this._cachedDataOpts = {};\n    this._cachedMeta = this.getMeta();\n    this._type = this._cachedMeta.type;\n    this.options = undefined;\n    /** @type {boolean | object} */\n    this._parsing = false;\n    this._data = undefined;\n    this._objectData = undefined;\n    this._sharedOptions = undefined;\n    this._drawStart = undefined;\n    this._drawCount = undefined;\n    this.enableOptionSharing = false;\n    this.supportsDecimation = false;\n    this.$context = undefined;\n    this._syncList = [];\n    this.datasetElementType = new.target.datasetElementType;\n    this.dataElementType = new.target.dataElementType;\n\n    this.initialize();\n  }\n\n  initialize() {\n    const meta = this._cachedMeta;\n    this.configure();\n    this.linkScales();\n    meta._stacked = isStacked(meta.vScale, meta);\n    this.addElements();\n\n    if (this.options.fill && !this.chart.isPluginEnabled('filler')) {\n      console.warn(\"Tried to use the 'fill' option without the 'Filler' plugin enabled. Please import and register the 'Filler' plugin and make sure it is not disabled in the options\");\n    }\n  }\n\n  updateIndex(datasetIndex) {\n    if (this.index !== datasetIndex) {\n      clearStacks(this._cachedMeta);\n    }\n    this.index = datasetIndex;\n  }\n\n  linkScales() {\n    const chart = this.chart;\n    const meta = this._cachedMeta;\n    const dataset = this.getDataset();\n\n    const chooseId = (axis, x, y, r) => axis === 'x' ? x : axis === 'r' ? r : y;\n\n    const xid = meta.xAxisID = valueOrDefault(dataset.xAxisID, getFirstScaleId(chart, 'x'));\n    const yid = meta.yAxisID = valueOrDefault(dataset.yAxisID, getFirstScaleId(chart, 'y'));\n    const rid = meta.rAxisID = valueOrDefault(dataset.rAxisID, getFirstScaleId(chart, 'r'));\n    const indexAxis = meta.indexAxis;\n    const iid = meta.iAxisID = chooseId(indexAxis, xid, yid, rid);\n    const vid = meta.vAxisID = chooseId(indexAxis, yid, xid, rid);\n    meta.xScale = this.getScaleForId(xid);\n    meta.yScale = this.getScaleForId(yid);\n    meta.rScale = this.getScaleForId(rid);\n    meta.iScale = this.getScaleForId(iid);\n    meta.vScale = this.getScaleForId(vid);\n  }\n\n  getDataset() {\n    return this.chart.data.datasets[this.index];\n  }\n\n  getMeta() {\n    return this.chart.getDatasetMeta(this.index);\n  }\n\n  /**\n\t * @param {string} scaleID\n\t * @return {Scale}\n\t */\n  getScaleForId(scaleID) {\n    return this.chart.scales[scaleID];\n  }\n\n  /**\n\t * @private\n\t */\n  _getOtherScale(scale) {\n    const meta = this._cachedMeta;\n    return scale === meta.iScale\n      ? meta.vScale\n      : meta.iScale;\n  }\n\n  reset() {\n    this._update('reset');\n  }\n\n  /**\n\t * @private\n\t */\n  _destroy() {\n    const meta = this._cachedMeta;\n    if (this._data) {\n      unlistenArrayEvents(this._data, this);\n    }\n    if (meta._stacked) {\n      clearStacks(meta);\n    }\n  }\n\n  /**\n\t * @private\n\t */\n  _dataCheck() {\n    const dataset = this.getDataset();\n    const data = dataset.data || (dataset.data = []);\n    const _data = this._data;\n\n    // In order to correctly handle data addition/deletion animation (and thus simulate\n    // real-time charts), we need to monitor these data modifications and synchronize\n    // the internal metadata accordingly.\n\n    if (isObject(data)) {\n      this._data = convertObjectDataToArray(data);\n    } else if (_data !== data) {\n      if (_data) {\n        // This case happens when the user replaced the data array instance.\n        unlistenArrayEvents(_data, this);\n        // Discard old parsed data and stacks\n        const meta = this._cachedMeta;\n        clearStacks(meta);\n        meta._parsed = [];\n      }\n      if (data && Object.isExtensible(data)) {\n        listenArrayEvents(data, this);\n      }\n      this._syncList = [];\n      this._data = data;\n    }\n  }\n\n  addElements() {\n    const meta = this._cachedMeta;\n\n    this._dataCheck();\n\n    if (this.datasetElementType) {\n      meta.dataset = new this.datasetElementType();\n    }\n  }\n\n  buildOrUpdateElements(resetNewElements) {\n    const meta = this._cachedMeta;\n    const dataset = this.getDataset();\n    let stackChanged = false;\n\n    this._dataCheck();\n\n    // make sure cached _stacked status is current\n    const oldStacked = meta._stacked;\n    meta._stacked = isStacked(meta.vScale, meta);\n\n    // detect change in stack option\n    if (meta.stack !== dataset.stack) {\n      stackChanged = true;\n      // remove values from old stack\n      clearStacks(meta);\n      meta.stack = dataset.stack;\n    }\n\n    // Re-sync meta data in case the user replaced the data array or if we missed\n    // any updates and so make sure that we handle number of datapoints changing.\n    this._resyncElements(resetNewElements);\n\n    // if stack changed, update stack values for the whole dataset\n    if (stackChanged || oldStacked !== meta._stacked) {\n      updateStacks(this, meta._parsed);\n    }\n  }\n\n  /**\n\t * Merges user-supplied and default dataset-level options\n\t * @private\n\t */\n  configure() {\n    const config = this.chart.config;\n    const scopeKeys = config.datasetScopeKeys(this._type);\n    const scopes = config.getOptionScopes(this.getDataset(), scopeKeys, true);\n    this.options = config.createResolver(scopes, this.getContext());\n    this._parsing = this.options.parsing;\n    this._cachedDataOpts = {};\n  }\n\n  /**\n\t * @param {number} start\n\t * @param {number} count\n\t */\n  parse(start, count) {\n    const {_cachedMeta: meta, _data: data} = this;\n    const {iScale, _stacked} = meta;\n    const iAxis = iScale.axis;\n\n    let sorted = start === 0 && count === data.length ? true : meta._sorted;\n    let prev = start > 0 && meta._parsed[start - 1];\n    let i, cur, parsed;\n\n    if (this._parsing === false) {\n      meta._parsed = data;\n      meta._sorted = true;\n      parsed = data;\n    } else {\n      if (isArray(data[start])) {\n        parsed = this.parseArrayData(meta, data, start, count);\n      } else if (isObject(data[start])) {\n        parsed = this.parseObjectData(meta, data, start, count);\n      } else {\n        parsed = this.parsePrimitiveData(meta, data, start, count);\n      }\n\n      const isNotInOrderComparedToPrev = () => cur[iAxis] === null || (prev && cur[iAxis] < prev[iAxis]);\n      for (i = 0; i < count; ++i) {\n        meta._parsed[i + start] = cur = parsed[i];\n        if (sorted) {\n          if (isNotInOrderComparedToPrev()) {\n            sorted = false;\n          }\n          prev = cur;\n        }\n      }\n      meta._sorted = sorted;\n    }\n\n    if (_stacked) {\n      updateStacks(this, parsed);\n    }\n  }\n\n  /**\n\t * Parse array of primitive values\n\t * @param {object} meta - dataset meta\n\t * @param {array} data - data array. Example [1,3,4]\n\t * @param {number} start - start index\n\t * @param {number} count - number of items to parse\n\t * @returns {object} parsed item - item containing index and a parsed value\n\t * for each scale id.\n\t * Example: {xScale0: 0, yScale0: 1}\n\t * @protected\n\t */\n  parsePrimitiveData(meta, data, start, count) {\n    const {iScale, vScale} = meta;\n    const iAxis = iScale.axis;\n    const vAxis = vScale.axis;\n    const labels = iScale.getLabels();\n    const singleScale = iScale === vScale;\n    const parsed = new Array(count);\n    let i, ilen, index;\n\n    for (i = 0, ilen = count; i < ilen; ++i) {\n      index = i + start;\n      parsed[i] = {\n        [iAxis]: singleScale || iScale.parse(labels[index], index),\n        [vAxis]: vScale.parse(data[index], index)\n      };\n    }\n    return parsed;\n  }\n\n  /**\n\t * Parse array of arrays\n\t * @param {object} meta - dataset meta\n\t * @param {array} data - data array. Example [[1,2],[3,4]]\n\t * @param {number} start - start index\n\t * @param {number} count - number of items to parse\n\t * @returns {object} parsed item - item containing index and a parsed value\n\t * for each scale id.\n\t * Example: {x: 0, y: 1}\n\t * @protected\n\t */\n  parseArrayData(meta, data, start, count) {\n    const {xScale, yScale} = meta;\n    const parsed = new Array(count);\n    let i, ilen, index, item;\n\n    for (i = 0, ilen = count; i < ilen; ++i) {\n      index = i + start;\n      item = data[index];\n      parsed[i] = {\n        x: xScale.parse(item[0], index),\n        y: yScale.parse(item[1], index)\n      };\n    }\n    return parsed;\n  }\n\n  /**\n\t * Parse array of objects\n\t * @param {object} meta - dataset meta\n\t * @param {array} data - data array. Example [{x:1, y:5}, {x:2, y:10}]\n\t * @param {number} start - start index\n\t * @param {number} count - number of items to parse\n\t * @returns {object} parsed item - item containing index and a parsed value\n\t * for each scale id. _custom is optional\n\t * Example: {xScale0: 0, yScale0: 1, _custom: {r: 10, foo: 'bar'}}\n\t * @protected\n\t */\n  parseObjectData(meta, data, start, count) {\n    const {xScale, yScale} = meta;\n    const {xAxisKey = 'x', yAxisKey = 'y'} = this._parsing;\n    const parsed = new Array(count);\n    let i, ilen, index, item;\n\n    for (i = 0, ilen = count; i < ilen; ++i) {\n      index = i + start;\n      item = data[index];\n      parsed[i] = {\n        x: xScale.parse(resolveObjectKey(item, xAxisKey), index),\n        y: yScale.parse(resolveObjectKey(item, yAxisKey), index)\n      };\n    }\n    return parsed;\n  }\n\n  /**\n\t * @protected\n\t */\n  getParsed(index) {\n    return this._cachedMeta._parsed[index];\n  }\n\n  /**\n\t * @protected\n\t */\n  getDataElement(index) {\n    return this._cachedMeta.data[index];\n  }\n\n  /**\n\t * @protected\n\t */\n  applyStack(scale, parsed, mode) {\n    const chart = this.chart;\n    const meta = this._cachedMeta;\n    const value = parsed[scale.axis];\n    const stack = {\n      keys: getSortedDatasetIndices(chart, true),\n      values: parsed._stacks[scale.axis]._visualValues\n    };\n    return applyStack(stack, value, meta.index, {mode});\n  }\n\n  /**\n\t * @protected\n\t */\n  updateRangeFromParsed(range, scale, parsed, stack) {\n    const parsedValue = parsed[scale.axis];\n    let value = parsedValue === null ? NaN : parsedValue;\n    const values = stack && parsed._stacks[scale.axis];\n    if (stack && values) {\n      stack.values = values;\n      value = applyStack(stack, parsedValue, this._cachedMeta.index);\n    }\n    range.min = Math.min(range.min, value);\n    range.max = Math.max(range.max, value);\n  }\n\n  /**\n\t * @protected\n\t */\n  getMinMax(scale, canStack) {\n    const meta = this._cachedMeta;\n    const _parsed = meta._parsed;\n    const sorted = meta._sorted && scale === meta.iScale;\n    const ilen = _parsed.length;\n    const otherScale = this._getOtherScale(scale);\n    const stack = createStack(canStack, meta, this.chart);\n    const range = {min: Number.POSITIVE_INFINITY, max: Number.NEGATIVE_INFINITY};\n    const {min: otherMin, max: otherMax} = getUserBounds(otherScale);\n    let i, parsed;\n\n    function _skip() {\n      parsed = _parsed[i];\n      const otherValue = parsed[otherScale.axis];\n      return !isFinite(parsed[scale.axis]) || otherMin > otherValue || otherMax < otherValue;\n    }\n\n    for (i = 0; i < ilen; ++i) {\n      if (_skip()) {\n        continue;\n      }\n      this.updateRangeFromParsed(range, scale, parsed, stack);\n      if (sorted) {\n        // if the data is sorted, we don't need to check further from this end of array\n        break;\n      }\n    }\n    if (sorted) {\n      // in the sorted case, find first non-skipped value from other end of array\n      for (i = ilen - 1; i >= 0; --i) {\n        if (_skip()) {\n          continue;\n        }\n        this.updateRangeFromParsed(range, scale, parsed, stack);\n        break;\n      }\n    }\n    return range;\n  }\n\n  getAllParsedValues(scale) {\n    const parsed = this._cachedMeta._parsed;\n    const values = [];\n    let i, ilen, value;\n\n    for (i = 0, ilen = parsed.length; i < ilen; ++i) {\n      value = parsed[i][scale.axis];\n      if (isFinite(value)) {\n        values.push(value);\n      }\n    }\n    return values;\n  }\n\n  /**\n\t * @return {number|boolean}\n\t * @protected\n\t */\n  getMaxOverflow() {\n    return false;\n  }\n\n  /**\n\t * @protected\n\t */\n  getLabelAndValue(index) {\n    const meta = this._cachedMeta;\n    const iScale = meta.iScale;\n    const vScale = meta.vScale;\n    const parsed = this.getParsed(index);\n    return {\n      label: iScale ? '' + iScale.getLabelForValue(parsed[iScale.axis]) : '',\n      value: vScale ? '' + vScale.getLabelForValue(parsed[vScale.axis]) : ''\n    };\n  }\n\n  /**\n\t * @private\n\t */\n  _update(mode) {\n    const meta = this._cachedMeta;\n    this.update(mode || 'default');\n    meta._clip = toClip(valueOrDefault(this.options.clip, defaultClip(meta.xScale, meta.yScale, this.getMaxOverflow())));\n  }\n\n  /**\n\t * @param {string} mode\n\t */\n  update(mode) {} // eslint-disable-line no-unused-vars\n\n  draw() {\n    const ctx = this._ctx;\n    const chart = this.chart;\n    const meta = this._cachedMeta;\n    const elements = meta.data || [];\n    const area = chart.chartArea;\n    const active = [];\n    const start = this._drawStart || 0;\n    const count = this._drawCount || (elements.length - start);\n    const drawActiveElementsOnTop = this.options.drawActiveElementsOnTop;\n    let i;\n\n    if (meta.dataset) {\n      meta.dataset.draw(ctx, area, start, count);\n    }\n\n    for (i = start; i < start + count; ++i) {\n      const element = elements[i];\n      if (element.hidden) {\n        continue;\n      }\n      if (element.active && drawActiveElementsOnTop) {\n        active.push(element);\n      } else {\n        element.draw(ctx, area);\n      }\n    }\n\n    for (i = 0; i < active.length; ++i) {\n      active[i].draw(ctx, area);\n    }\n  }\n\n  /**\n\t * Returns a set of predefined style properties that should be used to represent the dataset\n\t * or the data if the index is specified\n\t * @param {number} index - data index\n\t * @param {boolean} [active] - true if hover\n\t * @return {object} style object\n\t */\n  getStyle(index, active) {\n    const mode = active ? 'active' : 'default';\n    return index === undefined && this._cachedMeta.dataset\n      ? this.resolveDatasetElementOptions(mode)\n      : this.resolveDataElementOptions(index || 0, mode);\n  }\n\n  /**\n\t * @protected\n\t */\n  getContext(index, active, mode) {\n    const dataset = this.getDataset();\n    let context;\n    if (index >= 0 && index < this._cachedMeta.data.length) {\n      const element = this._cachedMeta.data[index];\n      context = element.$context ||\n        (element.$context = createDataContext(this.getContext(), index, element));\n      context.parsed = this.getParsed(index);\n      context.raw = dataset.data[index];\n      context.index = context.dataIndex = index;\n    } else {\n      context = this.$context ||\n        (this.$context = createDatasetContext(this.chart.getContext(), this.index));\n      context.dataset = dataset;\n      context.index = context.datasetIndex = this.index;\n    }\n\n    context.active = !!active;\n    context.mode = mode;\n    return context;\n  }\n\n  /**\n\t * @param {string} [mode]\n\t * @protected\n\t */\n  resolveDatasetElementOptions(mode) {\n    return this._resolveElementOptions(this.datasetElementType.id, mode);\n  }\n\n  /**\n\t * @param {number} index\n\t * @param {string} [mode]\n\t * @protected\n\t */\n  resolveDataElementOptions(index, mode) {\n    return this._resolveElementOptions(this.dataElementType.id, mode, index);\n  }\n\n  /**\n\t * @private\n\t */\n  _resolveElementOptions(elementType, mode = 'default', index) {\n    const active = mode === 'active';\n    const cache = this._cachedDataOpts;\n    const cacheKey = elementType + '-' + mode;\n    const cached = cache[cacheKey];\n    const sharing = this.enableOptionSharing && defined(index);\n    if (cached) {\n      return cloneIfNotShared(cached, sharing);\n    }\n    const config = this.chart.config;\n    const scopeKeys = config.datasetElementScopeKeys(this._type, elementType);\n    const prefixes = active ? [`${elementType}Hover`, 'hover', elementType, ''] : [elementType, ''];\n    const scopes = config.getOptionScopes(this.getDataset(), scopeKeys);\n    const names = Object.keys(defaults.elements[elementType]);\n    // context is provided as a function, and is called only if needed,\n    // so we don't create a context for each element if not needed.\n    const context = () => this.getContext(index, active, mode);\n    const values = config.resolveNamedOptions(scopes, names, context, prefixes);\n\n    if (values.$shared) {\n      // `$shared` indicates this set of options can be shared between multiple elements.\n      // Sharing is used to reduce number of properties to change during animation.\n      values.$shared = sharing;\n\n      // We cache options by `mode`, which can be 'active' for example. This enables us\n      // to have the 'active' element options and 'default' options to switch between\n      // when interacting.\n      cache[cacheKey] = Object.freeze(cloneIfNotShared(values, sharing));\n    }\n\n    return values;\n  }\n\n\n  /**\n\t * @private\n\t */\n  _resolveAnimations(index, transition, active) {\n    const chart = this.chart;\n    const cache = this._cachedDataOpts;\n    const cacheKey = `animation-${transition}`;\n    const cached = cache[cacheKey];\n    if (cached) {\n      return cached;\n    }\n    let options;\n    if (chart.options.animation !== false) {\n      const config = this.chart.config;\n      const scopeKeys = config.datasetAnimationScopeKeys(this._type, transition);\n      const scopes = config.getOptionScopes(this.getDataset(), scopeKeys);\n      options = config.createResolver(scopes, this.getContext(index, active, transition));\n    }\n    const animations = new Animations(chart, options && options.animations);\n    if (options && options._cacheable) {\n      cache[cacheKey] = Object.freeze(animations);\n    }\n    return animations;\n  }\n\n  /**\n\t * Utility for getting the options object shared between elements\n\t * @protected\n\t */\n  getSharedOptions(options) {\n    if (!options.$shared) {\n      return;\n    }\n    return this._sharedOptions || (this._sharedOptions = Object.assign({}, options));\n  }\n\n  /**\n\t * Utility for determining if `options` should be included in the updated properties\n\t * @protected\n\t */\n  includeOptions(mode, sharedOptions) {\n    return !sharedOptions || isDirectUpdateMode(mode) || this.chart._animationsDisabled;\n  }\n\n  /**\n   * @todo v4, rename to getSharedOptions and remove excess functions\n   */\n  _getSharedOptions(start, mode) {\n    const firstOpts = this.resolveDataElementOptions(start, mode);\n    const previouslySharedOptions = this._sharedOptions;\n    const sharedOptions = this.getSharedOptions(firstOpts);\n    const includeOptions = this.includeOptions(mode, sharedOptions) || (sharedOptions !== previouslySharedOptions);\n    this.updateSharedOptions(sharedOptions, mode, firstOpts);\n    return {sharedOptions, includeOptions};\n  }\n\n  /**\n\t * Utility for updating an element with new properties, using animations when appropriate.\n\t * @protected\n\t */\n  updateElement(element, index, properties, mode) {\n    if (isDirectUpdateMode(mode)) {\n      Object.assign(element, properties);\n    } else {\n      this._resolveAnimations(index, mode).update(element, properties);\n    }\n  }\n\n  /**\n\t * Utility to animate the shared options, that are potentially affecting multiple elements.\n\t * @protected\n\t */\n  updateSharedOptions(sharedOptions, mode, newOptions) {\n    if (sharedOptions && !isDirectUpdateMode(mode)) {\n      this._resolveAnimations(undefined, mode).update(sharedOptions, newOptions);\n    }\n  }\n\n  /**\n\t * @private\n\t */\n  _setStyle(element, index, mode, active) {\n    element.active = active;\n    const options = this.getStyle(index, active);\n    this._resolveAnimations(index, mode, active).update(element, {\n      // When going from active to inactive, we need to update to the shared options.\n      // This way the once hovered element will end up with the same original shared options instance, after animation.\n      options: (!active && this.getSharedOptions(options)) || options\n    });\n  }\n\n  removeHoverStyle(element, datasetIndex, index) {\n    this._setStyle(element, index, 'active', false);\n  }\n\n  setHoverStyle(element, datasetIndex, index) {\n    this._setStyle(element, index, 'active', true);\n  }\n\n  /**\n\t * @private\n\t */\n  _removeDatasetHoverStyle() {\n    const element = this._cachedMeta.dataset;\n\n    if (element) {\n      this._setStyle(element, undefined, 'active', false);\n    }\n  }\n\n  /**\n\t * @private\n\t */\n  _setDatasetHoverStyle() {\n    const element = this._cachedMeta.dataset;\n\n    if (element) {\n      this._setStyle(element, undefined, 'active', true);\n    }\n  }\n\n  /**\n\t * @private\n\t */\n  _resyncElements(resetNewElements) {\n    const data = this._data;\n    const elements = this._cachedMeta.data;\n\n    // Apply changes detected through array listeners\n    for (const [method, arg1, arg2] of this._syncList) {\n      this[method](arg1, arg2);\n    }\n    this._syncList = [];\n\n    const numMeta = elements.length;\n    const numData = data.length;\n    const count = Math.min(numData, numMeta);\n\n    if (count) {\n      // TODO: It is not optimal to always parse the old data\n      // This is done because we are not detecting direct assignments:\n      // chart.data.datasets[0].data[5] = 10;\n      // chart.data.datasets[0].data[5].y = 10;\n      this.parse(0, count);\n    }\n\n    if (numData > numMeta) {\n      this._insertElements(numMeta, numData - numMeta, resetNewElements);\n    } else if (numData < numMeta) {\n      this._removeElements(numData, numMeta - numData);\n    }\n  }\n\n  /**\n\t * @private\n\t */\n  _insertElements(start, count, resetNewElements = true) {\n    const meta = this._cachedMeta;\n    const data = meta.data;\n    const end = start + count;\n    let i;\n\n    const move = (arr) => {\n      arr.length += count;\n      for (i = arr.length - 1; i >= end; i--) {\n        arr[i] = arr[i - count];\n      }\n    };\n    move(data);\n\n    for (i = start; i < end; ++i) {\n      data[i] = new this.dataElementType();\n    }\n\n    if (this._parsing) {\n      move(meta._parsed);\n    }\n    this.parse(start, count);\n\n    if (resetNewElements) {\n      this.updateElements(data, start, count, 'reset');\n    }\n  }\n\n  updateElements(element, start, count, mode) {} // eslint-disable-line no-unused-vars\n\n  /**\n\t * @private\n\t */\n  _removeElements(start, count) {\n    const meta = this._cachedMeta;\n    if (this._parsing) {\n      const removed = meta._parsed.splice(start, count);\n      if (meta._stacked) {\n        clearStacks(meta, removed);\n      }\n    }\n    meta.data.splice(start, count);\n  }\n\n  /**\n\t * @private\n   */\n  _sync(args) {\n    if (this._parsing) {\n      this._syncList.push(args);\n    } else {\n      const [method, arg1, arg2] = args;\n      this[method](arg1, arg2);\n    }\n    this.chart._dataChanges.push([this.index, ...args]);\n  }\n\n  _onDataPush() {\n    const count = arguments.length;\n    this._sync(['_insertElements', this.getDataset().data.length - count, count]);\n  }\n\n  _onDataPop() {\n    this._sync(['_removeElements', this._cachedMeta.data.length - 1, 1]);\n  }\n\n  _onDataShift() {\n    this._sync(['_removeElements', 0, 1]);\n  }\n\n  _onDataSplice(start, count) {\n    if (count) {\n      this._sync(['_removeElements', start, count]);\n    }\n    const newCount = arguments.length - 2;\n    if (newCount) {\n      this._sync(['_insertElements', start, newCount]);\n    }\n  }\n\n  _onDataUnshift() {\n    this._sync(['_insertElements', 0, arguments.length]);\n  }\n}\n","import DatasetController from '../core/core.datasetController.js';\nimport {\n  _arrayUnique, isArray, isNullOrUndef,\n  valueOrDefault, resolveObjectKey, sign, defined\n} from '../helpers/index.js';\n\nfunction getAllScaleValues(scale, type) {\n  if (!scale._cache.$bar) {\n    const visibleMetas = scale.getMatchingVisibleMetas(type);\n    let values = [];\n\n    for (let i = 0, ilen = visibleMetas.length; i < ilen; i++) {\n      values = values.concat(visibleMetas[i].controller.getAllParsedValues(scale));\n    }\n    scale._cache.$bar = _arrayUnique(values.sort((a, b) => a - b));\n  }\n  return scale._cache.$bar;\n}\n\n/**\n * Computes the \"optimal\" sample size to maintain bars equally sized while preventing overlap.\n * @private\n */\nfunction computeMinSampleSize(meta) {\n  const scale = meta.iScale;\n  const values = getAllScaleValues(scale, meta.type);\n  let min = scale._length;\n  let i, ilen, curr, prev;\n  const updateMinAndPrev = () => {\n    if (curr === 32767 || curr === -32768) {\n      // Ignore truncated pixels\n      return;\n    }\n    if (defined(prev)) {\n      // curr - prev === 0 is ignored\n      min = Math.min(min, Math.abs(curr - prev) || min);\n    }\n    prev = curr;\n  };\n\n  for (i = 0, ilen = values.length; i < ilen; ++i) {\n    curr = scale.getPixelForValue(values[i]);\n    updateMinAndPrev();\n  }\n\n  prev = undefined;\n  for (i = 0, ilen = scale.ticks.length; i < ilen; ++i) {\n    curr = scale.getPixelForTick(i);\n    updateMinAndPrev();\n  }\n\n  return min;\n}\n\n/**\n * Computes an \"ideal\" category based on the absolute bar thickness or, if undefined or null,\n * uses the smallest interval (see computeMinSampleSize) that prevents bar overlapping. This\n * mode currently always generates bars equally sized (until we introduce scriptable options?).\n * @private\n */\nfunction computeFitCategoryTraits(index, ruler, options, stackCount) {\n  const thickness = options.barThickness;\n  let size, ratio;\n\n  if (isNullOrUndef(thickness)) {\n    size = ruler.min * options.categoryPercentage;\n    ratio = options.barPercentage;\n  } else {\n    // When bar thickness is enforced, category and bar percentages are ignored.\n    // Note(SB): we could add support for relative bar thickness (e.g. barThickness: '50%')\n    // and deprecate barPercentage since this value is ignored when thickness is absolute.\n    size = thickness * stackCount;\n    ratio = 1;\n  }\n\n  return {\n    chunk: size / stackCount,\n    ratio,\n    start: ruler.pixels[index] - (size / 2)\n  };\n}\n\n/**\n * Computes an \"optimal\" category that globally arranges bars side by side (no gap when\n * percentage options are 1), based on the previous and following categories. This mode\n * generates bars with different widths when data are not evenly spaced.\n * @private\n */\nfunction computeFlexCategoryTraits(index, ruler, options, stackCount) {\n  const pixels = ruler.pixels;\n  const curr = pixels[index];\n  let prev = index > 0 ? pixels[index - 1] : null;\n  let next = index < pixels.length - 1 ? pixels[index + 1] : null;\n  const percent = options.categoryPercentage;\n\n  if (prev === null) {\n    // first data: its size is double based on the next point or,\n    // if it's also the last data, we use the scale size.\n    prev = curr - (next === null ? ruler.end - ruler.start : next - curr);\n  }\n\n  if (next === null) {\n    // last data: its size is also double based on the previous point.\n    next = curr + curr - prev;\n  }\n\n  const start = curr - (curr - Math.min(prev, next)) / 2 * percent;\n  const size = Math.abs(next - prev) / 2 * percent;\n\n  return {\n    chunk: size / stackCount,\n    ratio: options.barPercentage,\n    start\n  };\n}\n\nfunction parseFloatBar(entry, item, vScale, i) {\n  const startValue = vScale.parse(entry[0], i);\n  const endValue = vScale.parse(entry[1], i);\n  const min = Math.min(startValue, endValue);\n  const max = Math.max(startValue, endValue);\n  let barStart = min;\n  let barEnd = max;\n\n  if (Math.abs(min) > Math.abs(max)) {\n    barStart = max;\n    barEnd = min;\n  }\n\n  // Store `barEnd` (furthest away from origin) as parsed value,\n  // to make stacking straight forward\n  item[vScale.axis] = barEnd;\n\n  item._custom = {\n    barStart,\n    barEnd,\n    start: startValue,\n    end: endValue,\n    min,\n    max\n  };\n}\n\nfunction parseValue(entry, item, vScale, i) {\n  if (isArray(entry)) {\n    parseFloatBar(entry, item, vScale, i);\n  } else {\n    item[vScale.axis] = vScale.parse(entry, i);\n  }\n  return item;\n}\n\nfunction parseArrayOrPrimitive(meta, data, start, count) {\n  const iScale = meta.iScale;\n  const vScale = meta.vScale;\n  const labels = iScale.getLabels();\n  const singleScale = iScale === vScale;\n  const parsed = [];\n  let i, ilen, item, entry;\n\n  for (i = start, ilen = start + count; i < ilen; ++i) {\n    entry = data[i];\n    item = {};\n    item[iScale.axis] = singleScale || iScale.parse(labels[i], i);\n    parsed.push(parseValue(entry, item, vScale, i));\n  }\n  return parsed;\n}\n\nfunction isFloatBar(custom) {\n  return custom && custom.barStart !== undefined && custom.barEnd !== undefined;\n}\n\nfunction barSign(size, vScale, actualBase) {\n  if (size !== 0) {\n    return sign(size);\n  }\n  return (vScale.isHorizontal() ? 1 : -1) * (vScale.min >= actualBase ? 1 : -1);\n}\n\nfunction borderProps(properties) {\n  let reverse, start, end, top, bottom;\n  if (properties.horizontal) {\n    reverse = properties.base > properties.x;\n    start = 'left';\n    end = 'right';\n  } else {\n    reverse = properties.base < properties.y;\n    start = 'bottom';\n    end = 'top';\n  }\n  if (reverse) {\n    top = 'end';\n    bottom = 'start';\n  } else {\n    top = 'start';\n    bottom = 'end';\n  }\n  return {start, end, reverse, top, bottom};\n}\n\nfunction setBorderSkipped(properties, options, stack, index) {\n  let edge = options.borderSkipped;\n  const res = {};\n\n  if (!edge) {\n    properties.borderSkipped = res;\n    return;\n  }\n\n  if (edge === true) {\n    properties.borderSkipped = {top: true, right: true, bottom: true, left: true};\n    return;\n  }\n\n  const {start, end, reverse, top, bottom} = borderProps(properties);\n\n  if (edge === 'middle' && stack) {\n    properties.enableBorderRadius = true;\n    if ((stack._top || 0) === index) {\n      edge = top;\n    } else if ((stack._bottom || 0) === index) {\n      edge = bottom;\n    } else {\n      res[parseEdge(bottom, start, end, reverse)] = true;\n      edge = top;\n    }\n  }\n\n  res[parseEdge(edge, start, end, reverse)] = true;\n  properties.borderSkipped = res;\n}\n\nfunction parseEdge(edge, a, b, reverse) {\n  if (reverse) {\n    edge = swap(edge, a, b);\n    edge = startEnd(edge, b, a);\n  } else {\n    edge = startEnd(edge, a, b);\n  }\n  return edge;\n}\n\nfunction swap(orig, v1, v2) {\n  return orig === v1 ? v2 : orig === v2 ? v1 : orig;\n}\n\nfunction startEnd(v, start, end) {\n  return v === 'start' ? start : v === 'end' ? end : v;\n}\n\nfunction setInflateAmount(properties, {inflateAmount}, ratio) {\n  properties.inflateAmount = inflateAmount === 'auto'\n    ? ratio === 1 ? 0.33 : 0\n    : inflateAmount;\n}\n\nexport default class BarController extends DatasetController {\n\n  static id = 'bar';\n\n  /**\n   * @type {any}\n   */\n  static defaults = {\n    datasetElementType: false,\n    dataElementType: 'bar',\n\n    categoryPercentage: 0.8,\n    barPercentage: 0.9,\n    grouped: true,\n\n    animations: {\n      numbers: {\n        type: 'number',\n        properties: ['x', 'y', 'base', 'width', 'height']\n      }\n    }\n  };\n\n  /**\n   * @type {any}\n   */\n  static overrides = {\n    scales: {\n      _index_: {\n        type: 'category',\n        offset: true,\n        grid: {\n          offset: true\n        }\n      },\n      _value_: {\n        type: 'linear',\n        beginAtZero: true,\n      }\n    }\n  };\n\n\n  /**\n\t * Overriding primitive data parsing since we support mixed primitive/array\n\t * data for float bars\n\t * @protected\n\t */\n  parsePrimitiveData(meta, data, start, count) {\n    return parseArrayOrPrimitive(meta, data, start, count);\n  }\n\n  /**\n\t * Overriding array data parsing since we support mixed primitive/array\n\t * data for float bars\n\t * @protected\n\t */\n  parseArrayData(meta, data, start, count) {\n    return parseArrayOrPrimitive(meta, data, start, count);\n  }\n\n  /**\n\t * Overriding object data parsing since we support mixed primitive/array\n\t * value-scale data for float bars\n\t * @protected\n\t */\n  parseObjectData(meta, data, start, count) {\n    const {iScale, vScale} = meta;\n    const {xAxisKey = 'x', yAxisKey = 'y'} = this._parsing;\n    const iAxisKey = iScale.axis === 'x' ? xAxisKey : yAxisKey;\n    const vAxisKey = vScale.axis === 'x' ? xAxisKey : yAxisKey;\n    const parsed = [];\n    let i, ilen, item, obj;\n    for (i = start, ilen = start + count; i < ilen; ++i) {\n      obj = data[i];\n      item = {};\n      item[iScale.axis] = iScale.parse(resolveObjectKey(obj, iAxisKey), i);\n      parsed.push(parseValue(resolveObjectKey(obj, vAxisKey), item, vScale, i));\n    }\n    return parsed;\n  }\n\n  /**\n\t * @protected\n\t */\n  updateRangeFromParsed(range, scale, parsed, stack) {\n    super.updateRangeFromParsed(range, scale, parsed, stack);\n    const custom = parsed._custom;\n    if (custom && scale === this._cachedMeta.vScale) {\n      // float bar: only one end of the bar is considered by `super`\n      range.min = Math.min(range.min, custom.min);\n      range.max = Math.max(range.max, custom.max);\n    }\n  }\n\n  /**\n\t * @return {number|boolean}\n\t * @protected\n\t */\n  getMaxOverflow() {\n    return 0;\n  }\n\n  /**\n\t * @protected\n\t */\n  getLabelAndValue(index) {\n    const meta = this._cachedMeta;\n    const {iScale, vScale} = meta;\n    const parsed = this.getParsed(index);\n    const custom = parsed._custom;\n    const value = isFloatBar(custom)\n      ? '[' + custom.start + ', ' + custom.end + ']'\n      : '' + vScale.getLabelForValue(parsed[vScale.axis]);\n\n    return {\n      label: '' + iScale.getLabelForValue(parsed[iScale.axis]),\n      value\n    };\n  }\n\n  initialize() {\n    this.enableOptionSharing = true;\n\n    super.initialize();\n\n    const meta = this._cachedMeta;\n    meta.stack = this.getDataset().stack;\n  }\n\n  update(mode) {\n    const meta = this._cachedMeta;\n    this.updateElements(meta.data, 0, meta.data.length, mode);\n  }\n\n  updateElements(bars, start, count, mode) {\n    const reset = mode === 'reset';\n    const {index, _cachedMeta: {vScale}} = this;\n    const base = vScale.getBasePixel();\n    const horizontal = vScale.isHorizontal();\n    const ruler = this._getRuler();\n    const {sharedOptions, includeOptions} = this._getSharedOptions(start, mode);\n\n    for (let i = start; i < start + count; i++) {\n      const parsed = this.getParsed(i);\n      const vpixels = reset || isNullOrUndef(parsed[vScale.axis]) ? {base, head: base} : this._calculateBarValuePixels(i);\n      const ipixels = this._calculateBarIndexPixels(i, ruler);\n      const stack = (parsed._stacks || {})[vScale.axis];\n\n      const properties = {\n        horizontal,\n        base: vpixels.base,\n        enableBorderRadius: !stack || isFloatBar(parsed._custom) || (index === stack._top || index === stack._bottom),\n        x: horizontal ? vpixels.head : ipixels.center,\n        y: horizontal ? ipixels.center : vpixels.head,\n        height: horizontal ? ipixels.size : Math.abs(vpixels.size),\n        width: horizontal ? Math.abs(vpixels.size) : ipixels.size\n      };\n\n      if (includeOptions) {\n        properties.options = sharedOptions || this.resolveDataElementOptions(i, bars[i].active ? 'active' : mode);\n      }\n      const options = properties.options || bars[i].options;\n      setBorderSkipped(properties, options, stack, index);\n      setInflateAmount(properties, options, ruler.ratio);\n      this.updateElement(bars[i], i, properties, mode);\n    }\n  }\n\n  /**\n\t * Returns the stacks based on groups and bar visibility.\n\t * @param {number} [last] - The dataset index\n\t * @param {number} [dataIndex] - The data index of the ruler\n\t * @returns {string[]} The list of stack IDs\n\t * @private\n\t */\n  _getStacks(last, dataIndex) {\n    const {iScale} = this._cachedMeta;\n    const metasets = iScale.getMatchingVisibleMetas(this._type)\n      .filter(meta => meta.controller.options.grouped);\n    const stacked = iScale.options.stacked;\n    const stacks = [];\n\n    const skipNull = (meta) => {\n      const parsed = meta.controller.getParsed(dataIndex);\n      const val = parsed && parsed[meta.vScale.axis];\n\n      if (isNullOrUndef(val) || isNaN(val)) {\n        return true;\n      }\n    };\n\n    for (const meta of metasets) {\n      if (dataIndex !== undefined && skipNull(meta)) {\n        continue;\n      }\n\n      // stacked   | meta.stack\n      //           | found | not found | undefined\n      // false     |   x   |     x     |     x\n      // true      |       |     x     |\n      // undefined |       |     x     |     x\n      if (stacked === false || stacks.indexOf(meta.stack) === -1 ||\n\t\t\t\t(stacked === undefined && meta.stack === undefined)) {\n        stacks.push(meta.stack);\n      }\n      if (meta.index === last) {\n        break;\n      }\n    }\n\n    // No stacks? that means there is no visible data. Let's still initialize an `undefined`\n    // stack where possible invisible bars will be located.\n    // https://github.com/chartjs/Chart.js/issues/6368\n    if (!stacks.length) {\n      stacks.push(undefined);\n    }\n\n    return stacks;\n  }\n\n  /**\n\t * Returns the effective number of stacks based on groups and bar visibility.\n\t * @private\n\t */\n  _getStackCount(index) {\n    return this._getStacks(undefined, index).length;\n  }\n\n  /**\n\t * Returns the stack index for the given dataset based on groups and bar visibility.\n\t * @param {number} [datasetIndex] - The dataset index\n\t * @param {string} [name] - The stack name to find\n   * @param {number} [dataIndex]\n\t * @returns {number} The stack index\n\t * @private\n\t */\n  _getStackIndex(datasetIndex, name, dataIndex) {\n    const stacks = this._getStacks(datasetIndex, dataIndex);\n    const index = (name !== undefined)\n      ? stacks.indexOf(name)\n      : -1; // indexOf returns -1 if element is not present\n\n    return (index === -1)\n      ? stacks.length - 1\n      : index;\n  }\n\n  /**\n\t * @private\n\t */\n  _getRuler() {\n    const opts = this.options;\n    const meta = this._cachedMeta;\n    const iScale = meta.iScale;\n    const pixels = [];\n    let i, ilen;\n\n    for (i = 0, ilen = meta.data.length; i < ilen; ++i) {\n      pixels.push(iScale.getPixelForValue(this.getParsed(i)[iScale.axis], i));\n    }\n\n    const barThickness = opts.barThickness;\n    const min = barThickness || computeMinSampleSize(meta);\n\n    return {\n      min,\n      pixels,\n      start: iScale._startPixel,\n      end: iScale._endPixel,\n      stackCount: this._getStackCount(),\n      scale: iScale,\n      grouped: opts.grouped,\n      // bar thickness ratio used for non-grouped bars\n      ratio: barThickness ? 1 : opts.categoryPercentage * opts.barPercentage\n    };\n  }\n\n  /**\n\t * Note: pixel values are not clamped to the scale area.\n\t * @private\n\t */\n  _calculateBarValuePixels(index) {\n    const {_cachedMeta: {vScale, _stacked, index: datasetIndex}, options: {base: baseValue, minBarLength}} = this;\n    const actualBase = baseValue || 0;\n    const parsed = this.getParsed(index);\n    const custom = parsed._custom;\n    const floating = isFloatBar(custom);\n    let value = parsed[vScale.axis];\n    let start = 0;\n    let length = _stacked ? this.applyStack(vScale, parsed, _stacked) : value;\n    let head, size;\n\n    if (length !== value) {\n      start = length - value;\n      length = value;\n    }\n\n    if (floating) {\n      value = custom.barStart;\n      length = custom.barEnd - custom.barStart;\n      // bars crossing origin are not stacked\n      if (value !== 0 && sign(value) !== sign(custom.barEnd)) {\n        start = 0;\n      }\n      start += value;\n    }\n\n    const startValue = !isNullOrUndef(baseValue) && !floating ? baseValue : start;\n    let base = vScale.getPixelForValue(startValue);\n\n    if (this.chart.getDataVisibility(index)) {\n      head = vScale.getPixelForValue(start + length);\n    } else {\n      // When not visible, no height\n      head = base;\n    }\n\n    size = head - base;\n\n    if (Math.abs(size) < minBarLength) {\n      size = barSign(size, vScale, actualBase) * minBarLength;\n      if (value === actualBase) {\n        base -= size / 2;\n      }\n      const startPixel = vScale.getPixelForDecimal(0);\n      const endPixel = vScale.getPixelForDecimal(1);\n      const min = Math.min(startPixel, endPixel);\n      const max = Math.max(startPixel, endPixel);\n      base = Math.max(Math.min(base, max), min);\n      head = base + size;\n\n      if (_stacked && !floating) {\n        // visual data coordinates after applying minBarLength\n        parsed._stacks[vScale.axis]._visualValues[datasetIndex] = vScale.getValueForPixel(head) - vScale.getValueForPixel(base);\n      }\n    }\n\n    if (base === vScale.getPixelForValue(actualBase)) {\n      const halfGrid = sign(size) * vScale.getLineWidthForValue(actualBase) / 2;\n      base += halfGrid;\n      size -= halfGrid;\n    }\n\n    return {\n      size,\n      base,\n      head,\n      center: head + size / 2\n    };\n  }\n\n  /**\n\t * @private\n\t */\n  _calculateBarIndexPixels(index, ruler) {\n    const scale = ruler.scale;\n    const options = this.options;\n    const skipNull = options.skipNull;\n    const maxBarThickness = valueOrDefault(options.maxBarThickness, Infinity);\n    let center, size;\n    if (ruler.grouped) {\n      const stackCount = skipNull ? this._getStackCount(index) : ruler.stackCount;\n      const range = options.barThickness === 'flex'\n        ? computeFlexCategoryTraits(index, ruler, options, stackCount)\n        : computeFitCategoryTraits(index, ruler, options, stackCount);\n\n      const stackIndex = this._getStackIndex(this.index, this._cachedMeta.stack, skipNull ? index : undefined);\n      center = range.start + (range.chunk * stackIndex) + (range.chunk / 2);\n      size = Math.min(maxBarThickness, range.chunk * range.ratio);\n    } else {\n      // For non-grouped bar charts, exact pixel values are used\n      center = scale.getPixelForValue(this.getParsed(index)[scale.axis], index);\n      size = Math.min(maxBarThickness, ruler.min * ruler.ratio);\n    }\n\n    return {\n      base: center - size / 2,\n      head: center + size / 2,\n      center,\n      size\n    };\n  }\n\n  draw() {\n    const meta = this._cachedMeta;\n    const vScale = meta.vScale;\n    const rects = meta.data;\n    const ilen = rects.length;\n    let i = 0;\n\n    for (; i < ilen; ++i) {\n      if (this.getParsed(i)[vScale.axis] !== null) {\n        rects[i].draw(this._ctx);\n      }\n    }\n  }\n\n}\n","import DatasetController from '../core/core.datasetController.js';\nimport {isNullOrUndef} from '../helpers/index.js';\nimport {isNumber} from '../helpers/helpers.math.js';\nimport {_getStartAndCountOfVisiblePoints, _scaleRangesChanged} from '../helpers/helpers.extras.js';\n\nexport default class LineController extends DatasetController {\n\n  static id = 'line';\n\n  /**\n   * @type {any}\n   */\n  static defaults = {\n    datasetElementType: 'line',\n    dataElementType: 'point',\n\n    showLine: true,\n    spanGaps: false,\n  };\n\n  /**\n   * @type {any}\n   */\n  static overrides = {\n    scales: {\n      _index_: {\n        type: 'category',\n      },\n      _value_: {\n        type: 'linear',\n      },\n    }\n  };\n\n  initialize() {\n    this.enableOptionSharing = true;\n    this.supportsDecimation = true;\n    super.initialize();\n  }\n\n  update(mode) {\n    const meta = this._cachedMeta;\n    const {dataset: line, data: points = [], _dataset} = meta;\n    // @ts-ignore\n    const animationsDisabled = this.chart._animationsDisabled;\n    let {start, count} = _getStartAndCountOfVisiblePoints(meta, points, animationsDisabled);\n\n    this._drawStart = start;\n    this._drawCount = count;\n\n    if (_scaleRangesChanged(meta)) {\n      start = 0;\n      count = points.length;\n    }\n\n    // Update Line\n    line._chart = this.chart;\n    line._datasetIndex = this.index;\n    line._decimated = !!_dataset._decimated;\n    line.points = points;\n\n    const options = this.resolveDatasetElementOptions(mode);\n    if (!this.options.showLine) {\n      options.borderWidth = 0;\n    }\n    options.segment = this.options.segment;\n    this.updateElement(line, undefined, {\n      animated: !animationsDisabled,\n      options\n    }, mode);\n\n    // Update Points\n    this.updateElements(points, start, count, mode);\n  }\n\n  updateElements(points, start, count, mode) {\n    const reset = mode === 'reset';\n    const {iScale, vScale, _stacked, _dataset} = this._cachedMeta;\n    const {sharedOptions, includeOptions} = this._getSharedOptions(start, mode);\n    const iAxis = iScale.axis;\n    const vAxis = vScale.axis;\n    const {spanGaps, segment} = this.options;\n    const maxGapLength = isNumber(spanGaps) ? spanGaps : Number.POSITIVE_INFINITY;\n    const directUpdate = this.chart._animationsDisabled || reset || mode === 'none';\n    const end = start + count;\n    const pointsCount = points.length;\n    let prevParsed = start > 0 && this.getParsed(start - 1);\n\n    for (let i = 0; i < pointsCount; ++i) {\n      const point = points[i];\n      const properties = directUpdate ? point : {};\n\n      if (i < start || i >= end) {\n        properties.skip = true;\n        continue;\n      }\n\n      const parsed = this.getParsed(i);\n      const nullData = isNullOrUndef(parsed[vAxis]);\n      const iPixel = properties[iAxis] = iScale.getPixelForValue(parsed[iAxis], i);\n      const vPixel = properties[vAxis] = reset || nullData ? vScale.getBasePixel() : vScale.getPixelForValue(_stacked ? this.applyStack(vScale, parsed, _stacked) : parsed[vAxis], i);\n\n      properties.skip = isNaN(iPixel) || isNaN(vPixel) || nullData;\n      properties.stop = i > 0 && (Math.abs(parsed[iAxis] - prevParsed[iAxis])) > maxGapLength;\n      if (segment) {\n        properties.parsed = parsed;\n        properties.raw = _dataset.data[i];\n      }\n\n      if (includeOptions) {\n        properties.options = sharedOptions || this.resolveDataElementOptions(i, point.active ? 'active' : mode);\n      }\n\n      if (!directUpdate) {\n        this.updateElement(point, i, properties, mode);\n      }\n\n      prevParsed = parsed;\n    }\n  }\n\n  /**\n\t * @protected\n\t */\n  getMaxOverflow() {\n    const meta = this._cachedMeta;\n    const dataset = meta.dataset;\n    const border = dataset.options && dataset.options.borderWidth || 0;\n    const data = meta.data || [];\n    if (!data.length) {\n      return border;\n    }\n    const firstPoint = data[0].size(this.resolveDataElementOptions(0));\n    const lastPoint = data[data.length - 1].size(this.resolveDataElementOptions(data.length - 1));\n    return Math.max(border, firstPoint, lastPoint) / 2;\n  }\n\n  draw() {\n    const meta = this._cachedMeta;\n    meta.dataset.updateControlPoints(this.chart.chartArea, meta.iScale.axis);\n    super.draw();\n  }\n}\n","import {_lookupByKey, _rlookupByKey} from '../helpers/helpers.collection.js';\nimport {getRelativePosition} from '../helpers/helpers.dom.js';\nimport {_angleBetween, getAngleFromPoint} from '../helpers/helpers.math.js';\nimport {_isPointInArea} from '../helpers/index.js';\n\n/**\n * @typedef { import('./core.controller.js').default } Chart\n * @typedef { import('../types/index.js').ChartEvent } ChartEvent\n * @typedef {{axis?: string, intersect?: boolean, includeInvisible?: boolean}} InteractionOptions\n * @typedef {{datasetIndex: number, index: number, element: import('./core.element.js').default}} InteractionItem\n * @typedef { import('../types/index.js').Point } Point\n */\n\n/**\n * Helper function to do binary search when possible\n * @param {object} metaset - the dataset meta\n * @param {string} axis - the axis mode. x|y|xy|r\n * @param {number} value - the value to find\n * @param {boolean} [intersect] - should the element intersect\n * @returns {{lo:number, hi:number}} indices to search data array between\n */\nfunction binarySearch(metaset, axis, value, intersect) {\n  const {controller, data, _sorted} = metaset;\n  const iScale = controller._cachedMeta.iScale;\n  if (iScale && axis === iScale.axis && axis !== 'r' && _sorted && data.length) {\n    const lookupMethod = iScale._reversePixels ? _rlookupByKey : _lookupByKey;\n    if (!intersect) {\n      return lookupMethod(data, axis, value);\n    } else if (controller._sharedOptions) {\n      // _sharedOptions indicates that each element has equal options -> equal proportions\n      // So we can do a ranged binary search based on the range of first element and\n      // be confident to get the full range of indices that can intersect with the value.\n      const el = data[0];\n      const range = typeof el.getRange === 'function' && el.getRange(axis);\n      if (range) {\n        const start = lookupMethod(data, axis, value - range);\n        const end = lookupMethod(data, axis, value + range);\n        return {lo: start.lo, hi: end.hi};\n      }\n    }\n  }\n  // Default to all elements, when binary search can not be used.\n  return {lo: 0, hi: data.length - 1};\n}\n\n/**\n * Helper function to select candidate elements for interaction\n * @param {Chart} chart - the chart\n * @param {string} axis - the axis mode. x|y|xy|r\n * @param {Point} position - the point to be nearest to, in relative coordinates\n * @param {function} handler - the callback to execute for each visible item\n * @param {boolean} [intersect] - consider intersecting items\n */\nfunction evaluateInteractionItems(chart, axis, position, handler, intersect) {\n  const metasets = chart.getSortedVisibleDatasetMetas();\n  const value = position[axis];\n  for (let i = 0, ilen = metasets.length; i < ilen; ++i) {\n    const {index, data} = metasets[i];\n    const {lo, hi} = binarySearch(metasets[i], axis, value, intersect);\n    for (let j = lo; j <= hi; ++j) {\n      const element = data[j];\n      if (!element.skip) {\n        handler(element, index, j);\n      }\n    }\n  }\n}\n\n/**\n * Get a distance metric function for two points based on the\n * axis mode setting\n * @param {string} axis - the axis mode. x|y|xy|r\n */\nfunction getDistanceMetricForAxis(axis) {\n  const useX = axis.indexOf('x') !== -1;\n  const useY = axis.indexOf('y') !== -1;\n\n  return function(pt1, pt2) {\n    const deltaX = useX ? Math.abs(pt1.x - pt2.x) : 0;\n    const deltaY = useY ? Math.abs(pt1.y - pt2.y) : 0;\n    return Math.sqrt(Math.pow(deltaX, 2) + Math.pow(deltaY, 2));\n  };\n}\n\n/**\n * Helper function to get the items that intersect the event position\n * @param {Chart} chart - the chart\n * @param {Point} position - the point to be nearest to, in relative coordinates\n * @param {string} axis - the axis mode. x|y|xy|r\n * @param {boolean} [useFinalPosition] - use the element's animation target instead of current position\n * @param {boolean} [includeInvisible] - include invisible points that are outside of the chart area\n * @return {InteractionItem[]} the nearest items\n */\nfunction getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible) {\n  const items = [];\n\n  if (!includeInvisible && !chart.isPointInArea(position)) {\n    return items;\n  }\n\n  const evaluationFunc = function(element, datasetIndex, index) {\n    if (!includeInvisible && !_isPointInArea(element, chart.chartArea, 0)) {\n      return;\n    }\n    if (element.inRange(position.x, position.y, useFinalPosition)) {\n      items.push({element, datasetIndex, index});\n    }\n  };\n\n  evaluateInteractionItems(chart, axis, position, evaluationFunc, true);\n  return items;\n}\n\n/**\n * Helper function to get the items nearest to the event position for a radial chart\n * @param {Chart} chart - the chart to look at elements from\n * @param {Point} position - the point to be nearest to, in relative coordinates\n * @param {string} axis - the axes along which to measure distance\n * @param {boolean} [useFinalPosition] - use the element's animation target instead of current position\n * @return {InteractionItem[]} the nearest items\n */\nfunction getNearestRadialItems(chart, position, axis, useFinalPosition) {\n  let items = [];\n\n  function evaluationFunc(element, datasetIndex, index) {\n    const {startAngle, endAngle} = element.getProps(['startAngle', 'endAngle'], useFinalPosition);\n    const {angle} = getAngleFromPoint(element, {x: position.x, y: position.y});\n\n    if (_angleBetween(angle, startAngle, endAngle)) {\n      items.push({element, datasetIndex, index});\n    }\n  }\n\n  evaluateInteractionItems(chart, axis, position, evaluationFunc);\n  return items;\n}\n\n/**\n * Helper function to get the items nearest to the event position for a cartesian chart\n * @param {Chart} chart - the chart to look at elements from\n * @param {Point} position - the point to be nearest to, in relative coordinates\n * @param {string} axis - the axes along which to measure distance\n * @param {boolean} [intersect] - if true, only consider items that intersect the position\n * @param {boolean} [useFinalPosition] - use the element's animation target instead of current position\n * @param {boolean} [includeInvisible] - include invisible points that are outside of the chart area\n * @return {InteractionItem[]} the nearest items\n */\nfunction getNearestCartesianItems(chart, position, axis, intersect, useFinalPosition, includeInvisible) {\n  let items = [];\n  const distanceMetric = getDistanceMetricForAxis(axis);\n  let minDistance = Number.POSITIVE_INFINITY;\n\n  function evaluationFunc(element, datasetIndex, index) {\n    const inRange = element.inRange(position.x, position.y, useFinalPosition);\n    if (intersect && !inRange) {\n      return;\n    }\n\n    const center = element.getCenterPoint(useFinalPosition);\n    const pointInArea = !!includeInvisible || chart.isPointInArea(center);\n    if (!pointInArea && !inRange) {\n      return;\n    }\n\n    const distance = distanceMetric(position, center);\n    if (distance < minDistance) {\n      items = [{element, datasetIndex, index}];\n      minDistance = distance;\n    } else if (distance === minDistance) {\n      // Can have multiple items at the same distance in which case we sort by size\n      items.push({element, datasetIndex, index});\n    }\n  }\n\n  evaluateInteractionItems(chart, axis, position, evaluationFunc);\n  return items;\n}\n\n/**\n * Helper function to get the items nearest to the event position considering all visible items in the chart\n * @param {Chart} chart - the chart to look at elements from\n * @param {Point} position - the point to be nearest to, in relative coordinates\n * @param {string} axis - the axes along which to measure distance\n * @param {boolean} [intersect] - if true, only consider items that intersect the position\n * @param {boolean} [useFinalPosition] - use the element's animation target instead of current position\n * @param {boolean} [includeInvisible] - include invisible points that are outside of the chart area\n * @return {InteractionItem[]} the nearest items\n */\nfunction getNearestItems(chart, position, axis, intersect, useFinalPosition, includeInvisible) {\n  if (!includeInvisible && !chart.isPointInArea(position)) {\n    return [];\n  }\n\n  return axis === 'r' && !intersect\n    ? getNearestRadialItems(chart, position, axis, useFinalPosition)\n    : getNearestCartesianItems(chart, position, axis, intersect, useFinalPosition, includeInvisible);\n}\n\n/**\n * Helper function to get the items matching along the given X or Y axis\n * @param {Chart} chart - the chart to look at elements from\n * @param {Point} position - the point to be nearest to, in relative coordinates\n * @param {string} axis - the axis to match\n * @param {boolean} [intersect] - if true, only consider items that intersect the position\n * @param {boolean} [useFinalPosition] - use the element's animation target instead of current position\n * @return {InteractionItem[]} the nearest items\n */\nfunction getAxisItems(chart, position, axis, intersect, useFinalPosition) {\n  const items = [];\n  const rangeMethod = axis === 'x' ? 'inXRange' : 'inYRange';\n  let intersectsItem = false;\n\n  evaluateInteractionItems(chart, axis, position, (element, datasetIndex, index) => {\n    if (element[rangeMethod](position[axis], useFinalPosition)) {\n      items.push({element, datasetIndex, index});\n      intersectsItem = intersectsItem || element.inRange(position.x, position.y, useFinalPosition);\n    }\n  });\n\n  // If we want to trigger on an intersect and we don't have any items\n  // that intersect the position, return nothing\n  if (intersect && !intersectsItem) {\n    return [];\n  }\n  return items;\n}\n\n/**\n * Contains interaction related functions\n * @namespace Chart.Interaction\n */\nexport default {\n  // Part of the public API to facilitate developers creating their own modes\n  evaluateInteractionItems,\n\n  // Helper function for different modes\n  modes: {\n    /**\n\t\t * Returns items at the same index. If the options.intersect parameter is true, we only return items if we intersect something\n\t\t * If the options.intersect mode is false, we find the nearest item and return the items at the same index as that item\n\t\t * @function Chart.Interaction.modes.index\n\t\t * @since v2.4.0\n\t\t * @param {Chart} chart - the chart we are returning items from\n\t\t * @param {Event} e - the event we are find things at\n\t\t * @param {InteractionOptions} options - options to use\n\t\t * @param {boolean} [useFinalPosition] - use final element position (animation target)\n\t\t * @return {InteractionItem[]} - items that are found\n\t\t */\n    index(chart, e, options, useFinalPosition) {\n      const position = getRelativePosition(e, chart);\n      // Default axis for index mode is 'x' to match old behaviour\n      const axis = options.axis || 'x';\n      const includeInvisible = options.includeInvisible || false;\n      const items = options.intersect\n        ? getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible)\n        : getNearestItems(chart, position, axis, false, useFinalPosition, includeInvisible);\n      const elements = [];\n\n      if (!items.length) {\n        return [];\n      }\n\n      chart.getSortedVisibleDatasetMetas().forEach((meta) => {\n        const index = items[0].index;\n        const element = meta.data[index];\n\n        // don't count items that are skipped (null data)\n        if (element && !element.skip) {\n          elements.push({element, datasetIndex: meta.index, index});\n        }\n      });\n\n      return elements;\n    },\n\n    /**\n\t\t * Returns items in the same dataset. If the options.intersect parameter is true, we only return items if we intersect something\n\t\t * If the options.intersect is false, we find the nearest item and return the items in that dataset\n\t\t * @function Chart.Interaction.modes.dataset\n\t\t * @param {Chart} chart - the chart we are returning items from\n\t\t * @param {Event} e - the event we are find things at\n\t\t * @param {InteractionOptions} options - options to use\n\t\t * @param {boolean} [useFinalPosition] - use final element position (animation target)\n\t\t * @return {InteractionItem[]} - items that are found\n\t\t */\n    dataset(chart, e, options, useFinalPosition) {\n      const position = getRelativePosition(e, chart);\n      const axis = options.axis || 'xy';\n      const includeInvisible = options.includeInvisible || false;\n      let items = options.intersect\n        ? getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible) :\n        getNearestItems(chart, position, axis, false, useFinalPosition, includeInvisible);\n\n      if (items.length > 0) {\n        const datasetIndex = items[0].datasetIndex;\n        const data = chart.getDatasetMeta(datasetIndex).data;\n        items = [];\n        for (let i = 0; i < data.length; ++i) {\n          items.push({element: data[i], datasetIndex, index: i});\n        }\n      }\n\n      return items;\n    },\n\n    /**\n\t\t * Point mode returns all elements that hit test based on the event position\n\t\t * of the event\n\t\t * @function Chart.Interaction.modes.intersect\n\t\t * @param {Chart} chart - the chart we are returning items from\n\t\t * @param {Event} e - the event we are find things at\n\t\t * @param {InteractionOptions} options - options to use\n\t\t * @param {boolean} [useFinalPosition] - use final element position (animation target)\n\t\t * @return {InteractionItem[]} - items that are found\n\t\t */\n    point(chart, e, options, useFinalPosition) {\n      const position = getRelativePosition(e, chart);\n      const axis = options.axis || 'xy';\n      const includeInvisible = options.includeInvisible || false;\n      return getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible);\n    },\n\n    /**\n\t\t * nearest mode returns the element closest to the point\n\t\t * @function Chart.Interaction.modes.intersect\n\t\t * @param {Chart} chart - the chart we are returning items from\n\t\t * @param {Event} e - the event we are find things at\n\t\t * @param {InteractionOptions} options - options to use\n\t\t * @param {boolean} [useFinalPosition] - use final element position (animation target)\n\t\t * @return {InteractionItem[]} - items that are found\n\t\t */\n    nearest(chart, e, options, useFinalPosition) {\n      const position = getRelativePosition(e, chart);\n      const axis = options.axis || 'xy';\n      const includeInvisible = options.includeInvisible || false;\n      return getNearestItems(chart, position, axis, options.intersect, useFinalPosition, includeInvisible);\n    },\n\n    /**\n\t\t * x mode returns the elements that hit-test at the current x coordinate\n\t\t * @function Chart.Interaction.modes.x\n\t\t * @param {Chart} chart - the chart we are returning items from\n\t\t * @param {Event} e - the event we are find things at\n\t\t * @param {InteractionOptions} options - options to use\n\t\t * @param {boolean} [useFinalPosition] - use final element position (animation target)\n\t\t * @return {InteractionItem[]} - items that are found\n\t\t */\n    x(chart, e, options, useFinalPosition) {\n      const position = getRelativePosition(e, chart);\n      return getAxisItems(chart, position, 'x', options.intersect, useFinalPosition);\n    },\n\n    /**\n\t\t * y mode returns the elements that hit-test at the current y coordinate\n\t\t * @function Chart.Interaction.modes.y\n\t\t * @param {Chart} chart - the chart we are returning items from\n\t\t * @param {Event} e - the event we are find things at\n\t\t * @param {InteractionOptions} options - options to use\n\t\t * @param {boolean} [useFinalPosition] - use final element position (animation target)\n\t\t * @return {InteractionItem[]} - items that are found\n\t\t */\n    y(chart, e, options, useFinalPosition) {\n      const position = getRelativePosition(e, chart);\n      return getAxisItems(chart, position, 'y', options.intersect, useFinalPosition);\n    }\n  }\n};\n","import {defined, each, isObject} from '../helpers/helpers.core.js';\nimport {toPadding} from '../helpers/helpers.options.js';\n\n/**\n * @typedef { import('./core.controller.js').default } Chart\n */\n\nconst STATIC_POSITIONS = ['left', 'top', 'right', 'bottom'];\n\nfunction filterByPosition(array, position) {\n  return array.filter(v => v.pos === position);\n}\n\nfunction filterDynamicPositionByAxis(array, axis) {\n  return array.filter(v => STATIC_POSITIONS.indexOf(v.pos) === -1 && v.box.axis === axis);\n}\n\nfunction sortByWeight(array, reverse) {\n  return array.sort((a, b) => {\n    const v0 = reverse ? b : a;\n    const v1 = reverse ? a : b;\n    return v0.weight === v1.weight ?\n      v0.index - v1.index :\n      v0.weight - v1.weight;\n  });\n}\n\nfunction wrapBoxes(boxes) {\n  const layoutBoxes = [];\n  let i, ilen, box, pos, stack, stackWeight;\n\n  for (i = 0, ilen = (boxes || []).length; i < ilen; ++i) {\n    box = boxes[i];\n    ({position: pos, options: {stack, stackWeight = 1}} = box);\n    layoutBoxes.push({\n      index: i,\n      box,\n      pos,\n      horizontal: box.isHorizontal(),\n      weight: box.weight,\n      stack: stack && (pos + stack),\n      stackWeight\n    });\n  }\n  return layoutBoxes;\n}\n\nfunction buildStacks(layouts) {\n  const stacks = {};\n  for (const wrap of layouts) {\n    const {stack, pos, stackWeight} = wrap;\n    if (!stack || !STATIC_POSITIONS.includes(pos)) {\n      continue;\n    }\n    const _stack = stacks[stack] || (stacks[stack] = {count: 0, placed: 0, weight: 0, size: 0});\n    _stack.count++;\n    _stack.weight += stackWeight;\n  }\n  return stacks;\n}\n\n/**\n * store dimensions used instead of available chartArea in fitBoxes\n **/\nfunction setLayoutDims(layouts, params) {\n  const stacks = buildStacks(layouts);\n  const {vBoxMaxWidth, hBoxMaxHeight} = params;\n  let i, ilen, layout;\n  for (i = 0, ilen = layouts.length; i < ilen; ++i) {\n    layout = layouts[i];\n    const {fullSize} = layout.box;\n    const stack = stacks[layout.stack];\n    const factor = stack && layout.stackWeight / stack.weight;\n    if (layout.horizontal) {\n      layout.width = factor ? factor * vBoxMaxWidth : fullSize && params.availableWidth;\n      layout.height = hBoxMaxHeight;\n    } else {\n      layout.width = vBoxMaxWidth;\n      layout.height = factor ? factor * hBoxMaxHeight : fullSize && params.availableHeight;\n    }\n  }\n  return stacks;\n}\n\nfunction buildLayoutBoxes(boxes) {\n  const layoutBoxes = wrapBoxes(boxes);\n  const fullSize = sortByWeight(layoutBoxes.filter(wrap => wrap.box.fullSize), true);\n  const left = sortByWeight(filterByPosition(layoutBoxes, 'left'), true);\n  const right = sortByWeight(filterByPosition(layoutBoxes, 'right'));\n  const top = sortByWeight(filterByPosition(layoutBoxes, 'top'), true);\n  const bottom = sortByWeight(filterByPosition(layoutBoxes, 'bottom'));\n  const centerHorizontal = filterDynamicPositionByAxis(layoutBoxes, 'x');\n  const centerVertical = filterDynamicPositionByAxis(layoutBoxes, 'y');\n\n  return {\n    fullSize,\n    leftAndTop: left.concat(top),\n    rightAndBottom: right.concat(centerVertical).concat(bottom).concat(centerHorizontal),\n    chartArea: filterByPosition(layoutBoxes, 'chartArea'),\n    vertical: left.concat(right).concat(centerVertical),\n    horizontal: top.concat(bottom).concat(centerHorizontal)\n  };\n}\n\nfunction getCombinedMax(maxPadding, chartArea, a, b) {\n  return Math.max(maxPadding[a], chartArea[a]) + Math.max(maxPadding[b], chartArea[b]);\n}\n\nfunction updateMaxPadding(maxPadding, boxPadding) {\n  maxPadding.top = Math.max(maxPadding.top, boxPadding.top);\n  maxPadding.left = Math.max(maxPadding.left, boxPadding.left);\n  maxPadding.bottom = Math.max(maxPadding.bottom, boxPadding.bottom);\n  maxPadding.right = Math.max(maxPadding.right, boxPadding.right);\n}\n\nfunction updateDims(chartArea, params, layout, stacks) {\n  const {pos, box} = layout;\n  const maxPadding = chartArea.maxPadding;\n\n  // dynamically placed boxes size is not considered\n  if (!isObject(pos)) {\n    if (layout.size) {\n      // this layout was already counted for, lets first reduce old size\n      chartArea[pos] -= layout.size;\n    }\n    const stack = stacks[layout.stack] || {size: 0, count: 1};\n    stack.size = Math.max(stack.size, layout.horizontal ? box.height : box.width);\n    layout.size = stack.size / stack.count;\n    chartArea[pos] += layout.size;\n  }\n\n  if (box.getPadding) {\n    updateMaxPadding(maxPadding, box.getPadding());\n  }\n\n  const newWidth = Math.max(0, params.outerWidth - getCombinedMax(maxPadding, chartArea, 'left', 'right'));\n  const newHeight = Math.max(0, params.outerHeight - getCombinedMax(maxPadding, chartArea, 'top', 'bottom'));\n  const widthChanged = newWidth !== chartArea.w;\n  const heightChanged = newHeight !== chartArea.h;\n  chartArea.w = newWidth;\n  chartArea.h = newHeight;\n\n  // return booleans on the changes per direction\n  return layout.horizontal\n    ? {same: widthChanged, other: heightChanged}\n    : {same: heightChanged, other: widthChanged};\n}\n\nfunction handleMaxPadding(chartArea) {\n  const maxPadding = chartArea.maxPadding;\n\n  function updatePos(pos) {\n    const change = Math.max(maxPadding[pos] - chartArea[pos], 0);\n    chartArea[pos] += change;\n    return change;\n  }\n  chartArea.y += updatePos('top');\n  chartArea.x += updatePos('left');\n  updatePos('right');\n  updatePos('bottom');\n}\n\nfunction getMargins(horizontal, chartArea) {\n  const maxPadding = chartArea.maxPadding;\n\n  function marginForPositions(positions) {\n    const margin = {left: 0, top: 0, right: 0, bottom: 0};\n    positions.forEach((pos) => {\n      margin[pos] = Math.max(chartArea[pos], maxPadding[pos]);\n    });\n    return margin;\n  }\n\n  return horizontal\n    ? marginForPositions(['left', 'right'])\n    : marginForPositions(['top', 'bottom']);\n}\n\nfunction fitBoxes(boxes, chartArea, params, stacks) {\n  const refitBoxes = [];\n  let i, ilen, layout, box, refit, changed;\n\n  for (i = 0, ilen = boxes.length, refit = 0; i < ilen; ++i) {\n    layout = boxes[i];\n    box = layout.box;\n\n    box.update(\n      layout.width || chartArea.w,\n      layout.height || chartArea.h,\n      getMargins(layout.horizontal, chartArea)\n    );\n    const {same, other} = updateDims(chartArea, params, layout, stacks);\n\n    // Dimensions changed and there were non full width boxes before this\n    // -> we have to refit those\n    refit |= same && refitBoxes.length;\n\n    // Chart area changed in the opposite direction\n    changed = changed || other;\n\n    if (!box.fullSize) { // fullSize boxes don't need to be re-fitted in any case\n      refitBoxes.push(layout);\n    }\n  }\n\n  return refit && fitBoxes(refitBoxes, chartArea, params, stacks) || changed;\n}\n\nfunction setBoxDims(box, left, top, width, height) {\n  box.top = top;\n  box.left = left;\n  box.right = left + width;\n  box.bottom = top + height;\n  box.width = width;\n  box.height = height;\n}\n\nfunction placeBoxes(boxes, chartArea, params, stacks) {\n  const userPadding = params.padding;\n  let {x, y} = chartArea;\n\n  for (const layout of boxes) {\n    const box = layout.box;\n    const stack = stacks[layout.stack] || {count: 1, placed: 0, weight: 1};\n    const weight = (layout.stackWeight / stack.weight) || 1;\n    if (layout.horizontal) {\n      const width = chartArea.w * weight;\n      const height = stack.size || box.height;\n      if (defined(stack.start)) {\n        y = stack.start;\n      }\n      if (box.fullSize) {\n        setBoxDims(box, userPadding.left, y, params.outerWidth - userPadding.right - userPadding.left, height);\n      } else {\n        setBoxDims(box, chartArea.left + stack.placed, y, width, height);\n      }\n      stack.start = y;\n      stack.placed += width;\n      y = box.bottom;\n    } else {\n      const height = chartArea.h * weight;\n      const width = stack.size || box.width;\n      if (defined(stack.start)) {\n        x = stack.start;\n      }\n      if (box.fullSize) {\n        setBoxDims(box, x, userPadding.top, width, params.outerHeight - userPadding.bottom - userPadding.top);\n      } else {\n        setBoxDims(box, x, chartArea.top + stack.placed, width, height);\n      }\n      stack.start = x;\n      stack.placed += height;\n      x = box.right;\n    }\n  }\n\n  chartArea.x = x;\n  chartArea.y = y;\n}\n\n/**\n * @interface LayoutItem\n * @typedef {object} LayoutItem\n * @prop {string} position - The position of the item in the chart layout. Possible values are\n * 'left', 'top', 'right', 'bottom', and 'chartArea'\n * @prop {number} weight - The weight used to sort the item. Higher weights are further away from the chart area\n * @prop {boolean} fullSize - if true, and the item is horizontal, then push vertical boxes down\n * @prop {function} isHorizontal - returns true if the layout item is horizontal (ie. top or bottom)\n * @prop {function} update - Takes two parameters: width and height. Returns size of item\n * @prop {function} draw - Draws the element\n * @prop {function} [getPadding] -  Returns an object with padding on the edges\n * @prop {number} width - Width of item. Must be valid after update()\n * @prop {number} height - Height of item. Must be valid after update()\n * @prop {number} left - Left edge of the item. Set by layout system and cannot be used in update\n * @prop {number} top - Top edge of the item. Set by layout system and cannot be used in update\n * @prop {number} right - Right edge of the item. Set by layout system and cannot be used in update\n * @prop {number} bottom - Bottom edge of the item. Set by layout system and cannot be used in update\n */\n\n// The layout service is very self explanatory.  It's responsible for the layout within a chart.\n// Scales, Legends and Plugins all rely on the layout service and can easily register to be placed anywhere they need\n// It is this service's responsibility of carrying out that layout.\nexport default {\n\n  /**\n\t * Register a box to a chart.\n\t * A box is simply a reference to an object that requires layout. eg. Scales, Legend, Title.\n\t * @param {Chart} chart - the chart to use\n\t * @param {LayoutItem} item - the item to add to be laid out\n\t */\n  addBox(chart, item) {\n    if (!chart.boxes) {\n      chart.boxes = [];\n    }\n\n    // initialize item with default values\n    item.fullSize = item.fullSize || false;\n    item.position = item.position || 'top';\n    item.weight = item.weight || 0;\n    // @ts-ignore\n    item._layers = item._layers || function() {\n      return [{\n        z: 0,\n        draw(chartArea) {\n          item.draw(chartArea);\n        }\n      }];\n    };\n\n    chart.boxes.push(item);\n  },\n\n  /**\n\t * Remove a layoutItem from a chart\n\t * @param {Chart} chart - the chart to remove the box from\n\t * @param {LayoutItem} layoutItem - the item to remove from the layout\n\t */\n  removeBox(chart, layoutItem) {\n    const index = chart.boxes ? chart.boxes.indexOf(layoutItem) : -1;\n    if (index !== -1) {\n      chart.boxes.splice(index, 1);\n    }\n  },\n\n  /**\n\t * Sets (or updates) options on the given `item`.\n\t * @param {Chart} chart - the chart in which the item lives (or will be added to)\n\t * @param {LayoutItem} item - the item to configure with the given options\n\t * @param {object} options - the new item options.\n\t */\n  configure(chart, item, options) {\n    item.fullSize = options.fullSize;\n    item.position = options.position;\n    item.weight = options.weight;\n  },\n\n  /**\n\t * Fits boxes of the given chart into the given size by having each box measure itself\n\t * then running a fitting algorithm\n\t * @param {Chart} chart - the chart\n\t * @param {number} width - the width to fit into\n\t * @param {number} height - the height to fit into\n   * @param {number} minPadding - minimum padding required for each side of chart area\n\t */\n  update(chart, width, height, minPadding) {\n    if (!chart) {\n      return;\n    }\n\n    const padding = toPadding(chart.options.layout.padding);\n    const availableWidth = Math.max(width - padding.width, 0);\n    const availableHeight = Math.max(height - padding.height, 0);\n    const boxes = buildLayoutBoxes(chart.boxes);\n    const verticalBoxes = boxes.vertical;\n    const horizontalBoxes = boxes.horizontal;\n\n    // Before any changes are made, notify boxes that an update is about to being\n    // This is used to clear any cached data (e.g. scale limits)\n    each(chart.boxes, box => {\n      if (typeof box.beforeLayout === 'function') {\n        box.beforeLayout();\n      }\n    });\n\n    // Essentially we now have any number of boxes on each of the 4 sides.\n    // Our canvas looks like the following.\n    // The areas L1 and L2 are the left axes. R1 is the right axis, T1 is the top axis and\n    // B1 is the bottom axis\n    // There are also 4 quadrant-like locations (left to right instead of clockwise) reserved for chart overlays\n    // These locations are single-box locations only, when trying to register a chartArea location that is already taken,\n    // an error will be thrown.\n    //\n    // |----------------------------------------------------|\n    // |                  T1 (Full Width)                   |\n    // |----------------------------------------------------|\n    // |    |    |                 T2                  |    |\n    // |    |----|-------------------------------------|----|\n    // |    |    | C1 |                           | C2 |    |\n    // |    |    |----|                           |----|    |\n    // |    |    |                                     |    |\n    // | L1 | L2 |           ChartArea (C0)            | R1 |\n    // |    |    |                                     |    |\n    // |    |    |----|                           |----|    |\n    // |    |    | C3 |                           | C4 |    |\n    // |    |----|-------------------------------------|----|\n    // |    |    |                 B1                  |    |\n    // |----------------------------------------------------|\n    // |                  B2 (Full Width)                   |\n    // |----------------------------------------------------|\n    //\n\n    const visibleVerticalBoxCount = verticalBoxes.reduce((total, wrap) =>\n      wrap.box.options && wrap.box.options.display === false ? total : total + 1, 0) || 1;\n\n    const params = Object.freeze({\n      outerWidth: width,\n      outerHeight: height,\n      padding,\n      availableWidth,\n      availableHeight,\n      vBoxMaxWidth: availableWidth / 2 / visibleVerticalBoxCount,\n      hBoxMaxHeight: availableHeight / 2\n    });\n    const maxPadding = Object.assign({}, padding);\n    updateMaxPadding(maxPadding, toPadding(minPadding));\n    const chartArea = Object.assign({\n      maxPadding,\n      w: availableWidth,\n      h: availableHeight,\n      x: padding.left,\n      y: padding.top\n    }, padding);\n\n    const stacks = setLayoutDims(verticalBoxes.concat(horizontalBoxes), params);\n\n    // First fit the fullSize boxes, to reduce probability of re-fitting.\n    fitBoxes(boxes.fullSize, chartArea, params, stacks);\n\n    // Then fit vertical boxes\n    fitBoxes(verticalBoxes, chartArea, params, stacks);\n\n    // Then fit horizontal boxes\n    if (fitBoxes(horizontalBoxes, chartArea, params, stacks)) {\n      // if the area changed, re-fit vertical boxes\n      fitBoxes(verticalBoxes, chartArea, params, stacks);\n    }\n\n    handleMaxPadding(chartArea);\n\n    // Finally place the boxes to correct coordinates\n    placeBoxes(boxes.leftAndTop, chartArea, params, stacks);\n\n    // Move to opposite side of chart\n    chartArea.x += chartArea.w;\n    chartArea.y += chartArea.h;\n\n    placeBoxes(boxes.rightAndBottom, chartArea, params, stacks);\n\n    chart.chartArea = {\n      left: chartArea.left,\n      top: chartArea.top,\n      right: chartArea.left + chartArea.w,\n      bottom: chartArea.top + chartArea.h,\n      height: chartArea.h,\n      width: chartArea.w,\n    };\n\n    // Finally update boxes in chartArea (radial scale for example)\n    each(boxes.chartArea, (layout) => {\n      const box = layout.box;\n      Object.assign(box, chart.chartArea);\n      box.update(chartArea.w, chartArea.h, {left: 0, top: 0, right: 0, bottom: 0});\n    });\n  }\n};\n","\n/**\n * @typedef { import('../core/core.controller.js').default } Chart\n */\n\n/**\n * Abstract class that allows abstracting platform dependencies away from the chart.\n */\nexport default class BasePlatform {\n  /**\n\t * Called at chart construction time, returns a context2d instance implementing\n\t * the [W3C Canvas 2D Context API standard]{@link https://www.w3.org/TR/2dcontext/}.\n\t * @param {HTMLCanvasElement} canvas - The canvas from which to acquire context (platform specific)\n\t * @param {number} [aspectRatio] - The chart options\n\t */\n  acquireContext(canvas, aspectRatio) {} // eslint-disable-line no-unused-vars\n\n  /**\n\t * Called at chart destruction time, releases any resources associated to the context\n\t * previously returned by the acquireContext() method.\n\t * @param {CanvasRenderingContext2D} context - The context2d instance\n\t * @returns {boolean} true if the method succeeded, else false\n\t */\n  releaseContext(context) { // eslint-disable-line no-unused-vars\n    return false;\n  }\n\n  /**\n\t * Registers the specified listener on the given chart.\n\t * @param {Chart} chart - Chart from which to listen for event\n\t * @param {string} type - The ({@link ChartEvent}) type to listen for\n\t * @param {function} listener - Receives a notification (an object that implements\n\t * the {@link ChartEvent} interface) when an event of the specified type occurs.\n\t */\n  addEventListener(chart, type, listener) {} // eslint-disable-line no-unused-vars\n\n  /**\n\t * Removes the specified listener previously registered with addEventListener.\n\t * @param {Chart} chart - Chart from which to remove the listener\n\t * @param {string} type - The ({@link ChartEvent}) type to remove\n\t * @param {function} listener - The listener function to remove from the event target.\n\t */\n  removeEventListener(chart, type, listener) {} // eslint-disable-line no-unused-vars\n\n  /**\n\t * @returns {number} the current devicePixelRatio of the device this platform is connected to.\n\t */\n  getDevicePixelRatio() {\n    return 1;\n  }\n\n  /**\n\t * Returns the maximum size in pixels of given canvas element.\n\t * @param {HTMLCanvasElement} element\n\t * @param {number} [width] - content width of parent element\n\t * @param {number} [height] - content height of parent element\n\t * @param {number} [aspectRatio] - aspect ratio to maintain\n\t */\n  getMaximumSize(element, width, height, aspectRatio) {\n    width = Math.max(0, width || element.width);\n    height = height || element.height;\n    return {\n      width,\n      height: Math.max(0, aspectRatio ? Math.floor(width / aspectRatio) : height)\n    };\n  }\n\n  /**\n\t * @param {HTMLCanvasElement} canvas\n\t * @returns {boolean} true if the canvas is attached to the platform, false if not.\n\t */\n  isAttached(canvas) { // eslint-disable-line no-unused-vars\n    return true;\n  }\n\n  /**\n   * Updates config with platform specific requirements\n   * @param {import('../core/core.config.js').default} config\n   */\n  updateConfig(config) { // eslint-disable-line no-unused-vars\n    // no-op\n  }\n}\n","/**\n * Platform fallback implementation (minimal).\n * @see https://github.com/chartjs/Chart.js/pull/4591#issuecomment-319575939\n */\n\nimport BasePlatform from './platform.base.js';\n\n/**\n * Platform class for charts without access to the DOM or to many element properties\n * This platform is used by default for any chart passed an OffscreenCanvas.\n * @extends BasePlatform\n */\nexport default class BasicPlatform extends BasePlatform {\n  acquireContext(item) {\n    // To prevent canvas fingerprinting, some add-ons undefine the getContext\n    // method, for example: https://github.com/kkapsner/CanvasBlocker\n    // https://github.com/chartjs/Chart.js/issues/2807\n    return item && item.getContext && item.getContext('2d') || null;\n  }\n  updateConfig(config) {\n    config.options.animation = false;\n  }\n}\n","/**\n * Chart.Platform implementation for targeting a web browser\n */\n\nimport BasePlatform from './platform.base.js';\nimport {_getParentNode, getRelativePosition, supportsEventListenerOptions, readUsedSize, getMaximumSize} from '../helpers/helpers.dom.js';\nimport {throttled} from '../helpers/helpers.extras.js';\nimport {isNullOrUndef} from '../helpers/helpers.core.js';\n\n/**\n * @typedef { import('../core/core.controller.js').default } Chart\n */\n\nconst EXPANDO_KEY = '$chartjs';\n\n/**\n * DOM event types -> Chart.js event types.\n * Note: only events with different types are mapped.\n * @see https://developer.mozilla.org/en-US/docs/Web/Events\n */\nconst EVENT_TYPES = {\n  touchstart: 'mousedown',\n  touchmove: 'mousemove',\n  touchend: 'mouseup',\n  pointerenter: 'mouseenter',\n  pointerdown: 'mousedown',\n  pointermove: 'mousemove',\n  pointerup: 'mouseup',\n  pointerleave: 'mouseout',\n  pointerout: 'mouseout'\n};\n\nconst isNullOrEmpty = value => value === null || value === '';\n/**\n * Initializes the canvas style and render size without modifying the canvas display size,\n * since responsiveness is handled by the controller.resize() method. The config is used\n * to determine the aspect ratio to apply in case no explicit height has been specified.\n * @param {HTMLCanvasElement} canvas\n * @param {number} [aspectRatio]\n */\nfunction initCanvas(canvas, aspectRatio) {\n  const style = canvas.style;\n\n  // NOTE(SB) canvas.getAttribute('width') !== canvas.width: in the first case it\n  // returns null or '' if no explicit value has been set to the canvas attribute.\n  const renderHeight = canvas.getAttribute('height');\n  const renderWidth = canvas.getAttribute('width');\n\n  // Chart.js modifies some canvas values that we want to restore on destroy\n  canvas[EXPANDO_KEY] = {\n    initial: {\n      height: renderHeight,\n      width: renderWidth,\n      style: {\n        display: style.display,\n        height: style.height,\n        width: style.width\n      }\n    }\n  };\n\n  // Force canvas to display as block to avoid extra space caused by inline\n  // elements, which would interfere with the responsive resize process.\n  // https://github.com/chartjs/Chart.js/issues/2538\n  style.display = style.display || 'block';\n  // Include possible borders in the size\n  style.boxSizing = style.boxSizing || 'border-box';\n\n  if (isNullOrEmpty(renderWidth)) {\n    const displayWidth = readUsedSize(canvas, 'width');\n    if (displayWidth !== undefined) {\n      canvas.width = displayWidth;\n    }\n  }\n\n  if (isNullOrEmpty(renderHeight)) {\n    if (canvas.style.height === '') {\n      // If no explicit render height and style height, let's apply the aspect ratio,\n      // which one can be specified by the user but also by charts as default option\n      // (i.e. options.aspectRatio). If not specified, use canvas aspect ratio of 2.\n      canvas.height = canvas.width / (aspectRatio || 2);\n    } else {\n      const displayHeight = readUsedSize(canvas, 'height');\n      if (displayHeight !== undefined) {\n        canvas.height = displayHeight;\n      }\n    }\n  }\n\n  return canvas;\n}\n\n// Default passive to true as expected by Chrome for 'touchstart' and 'touchend' events.\n// https://github.com/chartjs/Chart.js/issues/4287\nconst eventListenerOptions = supportsEventListenerOptions ? {passive: true} : false;\n\nfunction addListener(node, type, listener) {\n  node.addEventListener(type, listener, eventListenerOptions);\n}\n\nfunction removeListener(chart, type, listener) {\n  chart.canvas.removeEventListener(type, listener, eventListenerOptions);\n}\n\nfunction fromNativeEvent(event, chart) {\n  const type = EVENT_TYPES[event.type] || event.type;\n  const {x, y} = getRelativePosition(event, chart);\n  return {\n    type,\n    chart,\n    native: event,\n    x: x !== undefined ? x : null,\n    y: y !== undefined ? y : null,\n  };\n}\n\nfunction nodeListContains(nodeList, canvas) {\n  for (const node of nodeList) {\n    if (node === canvas || node.contains(canvas)) {\n      return true;\n    }\n  }\n}\n\nfunction createAttachObserver(chart, type, listener) {\n  const canvas = chart.canvas;\n  const observer = new MutationObserver(entries => {\n    let trigger = false;\n    for (const entry of entries) {\n      trigger = trigger || nodeListContains(entry.addedNodes, canvas);\n      trigger = trigger && !nodeListContains(entry.removedNodes, canvas);\n    }\n    if (trigger) {\n      listener();\n    }\n  });\n  observer.observe(document, {childList: true, subtree: true});\n  return observer;\n}\n\nfunction createDetachObserver(chart, type, listener) {\n  const canvas = chart.canvas;\n  const observer = new MutationObserver(entries => {\n    let trigger = false;\n    for (const entry of entries) {\n      trigger = trigger || nodeListContains(entry.removedNodes, canvas);\n      trigger = trigger && !nodeListContains(entry.addedNodes, canvas);\n    }\n    if (trigger) {\n      listener();\n    }\n  });\n  observer.observe(document, {childList: true, subtree: true});\n  return observer;\n}\n\nconst drpListeningCharts = new Map();\nlet oldDevicePixelRatio = 0;\n\nfunction onWindowResize() {\n  const dpr = window.devicePixelRatio;\n  if (dpr === oldDevicePixelRatio) {\n    return;\n  }\n  oldDevicePixelRatio = dpr;\n  drpListeningCharts.forEach((resize, chart) => {\n    if (chart.currentDevicePixelRatio !== dpr) {\n      resize();\n    }\n  });\n}\n\nfunction listenDevicePixelRatioChanges(chart, resize) {\n  if (!drpListeningCharts.size) {\n    window.addEventListener('resize', onWindowResize);\n  }\n  drpListeningCharts.set(chart, resize);\n}\n\nfunction unlistenDevicePixelRatioChanges(chart) {\n  drpListeningCharts.delete(chart);\n  if (!drpListeningCharts.size) {\n    window.removeEventListener('resize', onWindowResize);\n  }\n}\n\nfunction createResizeObserver(chart, type, listener) {\n  const canvas = chart.canvas;\n  const container = canvas && _getParentNode(canvas);\n  if (!container) {\n    return;\n  }\n  const resize = throttled((width, height) => {\n    const w = container.clientWidth;\n    listener(width, height);\n    if (w < container.clientWidth) {\n      // If the container size shrank during chart resize, let's assume\n      // scrollbar appeared. So we resize again with the scrollbar visible -\n      // effectively making chart smaller and the scrollbar hidden again.\n      // Because we are inside `throttled`, and currently `ticking`, scroll\n      // events are ignored during this whole 2 resize process.\n      // If we assumed wrong and something else happened, we are resizing\n      // twice in a frame (potential performance issue)\n      listener();\n    }\n  }, window);\n\n  // @ts-ignore until https://github.com/microsoft/TypeScript/issues/37861 implemented\n  const observer = new ResizeObserver(entries => {\n    const entry = entries[0];\n    const width = entry.contentRect.width;\n    const height = entry.contentRect.height;\n    // When its container's display is set to 'none' the callback will be called with a\n    // size of (0, 0), which will cause the chart to lose its original height, so skip\n    // resizing in such case.\n    if (width === 0 && height === 0) {\n      return;\n    }\n    resize(width, height);\n  });\n  observer.observe(container);\n  listenDevicePixelRatioChanges(chart, resize);\n\n  return observer;\n}\n\nfunction releaseObserver(chart, type, observer) {\n  if (observer) {\n    observer.disconnect();\n  }\n  if (type === 'resize') {\n    unlistenDevicePixelRatioChanges(chart);\n  }\n}\n\nfunction createProxyAndListen(chart, type, listener) {\n  const canvas = chart.canvas;\n  const proxy = throttled((event) => {\n    // This case can occur if the chart is destroyed while waiting\n    // for the throttled function to occur. We prevent crashes by checking\n    // for a destroyed chart\n    if (chart.ctx !== null) {\n      listener(fromNativeEvent(event, chart));\n    }\n  }, chart);\n\n  addListener(canvas, type, proxy);\n\n  return proxy;\n}\n\n/**\n * Platform class for charts that can access the DOM and global window/document properties\n * @extends BasePlatform\n */\nexport default class DomPlatform extends BasePlatform {\n\n  /**\n\t * @param {HTMLCanvasElement} canvas\n\t * @param {number} [aspectRatio]\n\t * @return {CanvasRenderingContext2D|null}\n\t */\n  acquireContext(canvas, aspectRatio) {\n    // To prevent canvas fingerprinting, some add-ons undefine the getContext\n    // method, for example: https://github.com/kkapsner/CanvasBlocker\n    // https://github.com/chartjs/Chart.js/issues/2807\n    const context = canvas && canvas.getContext && canvas.getContext('2d');\n\n    // `instanceof HTMLCanvasElement/CanvasRenderingContext2D` fails when the canvas is\n    // inside an iframe or when running in a protected environment. We could guess the\n    // types from their toString() value but let's keep things flexible and assume it's\n    // a sufficient condition if the canvas has a context2D which has canvas as `canvas`.\n    // https://github.com/chartjs/Chart.js/issues/3887\n    // https://github.com/chartjs/Chart.js/issues/4102\n    // https://github.com/chartjs/Chart.js/issues/4152\n    if (context && context.canvas === canvas) {\n      // Load platform resources on first chart creation, to make it possible to\n      // import the library before setting platform options.\n      initCanvas(canvas, aspectRatio);\n      return context;\n    }\n\n    return null;\n  }\n\n  /**\n\t * @param {CanvasRenderingContext2D} context\n\t */\n  releaseContext(context) {\n    const canvas = context.canvas;\n    if (!canvas[EXPANDO_KEY]) {\n      return false;\n    }\n\n    const initial = canvas[EXPANDO_KEY].initial;\n    ['height', 'width'].forEach((prop) => {\n      const value = initial[prop];\n      if (isNullOrUndef(value)) {\n        canvas.removeAttribute(prop);\n      } else {\n        canvas.setAttribute(prop, value);\n      }\n    });\n\n    const style = initial.style || {};\n    Object.keys(style).forEach((key) => {\n      canvas.style[key] = style[key];\n    });\n\n    // The canvas render size might have been changed (and thus the state stack discarded),\n    // we can't use save() and restore() to restore the initial state. So make sure that at\n    // least the canvas context is reset to the default state by setting the canvas width.\n    // https://www.w3.org/TR/2011/WD-html5-20110525/the-canvas-element.html\n    // eslint-disable-next-line no-self-assign\n    canvas.width = canvas.width;\n\n    delete canvas[EXPANDO_KEY];\n    return true;\n  }\n\n  /**\n\t *\n\t * @param {Chart} chart\n\t * @param {string} type\n\t * @param {function} listener\n\t */\n  addEventListener(chart, type, listener) {\n    // Can have only one listener per type, so make sure previous is removed\n    this.removeEventListener(chart, type);\n\n    const proxies = chart.$proxies || (chart.$proxies = {});\n    const handlers = {\n      attach: createAttachObserver,\n      detach: createDetachObserver,\n      resize: createResizeObserver\n    };\n    const handler = handlers[type] || createProxyAndListen;\n    proxies[type] = handler(chart, type, listener);\n  }\n\n\n  /**\n\t * @param {Chart} chart\n\t * @param {string} type\n\t */\n  removeEventListener(chart, type) {\n    const proxies = chart.$proxies || (chart.$proxies = {});\n    const proxy = proxies[type];\n\n    if (!proxy) {\n      return;\n    }\n\n    const handlers = {\n      attach: releaseObserver,\n      detach: releaseObserver,\n      resize: releaseObserver\n    };\n    const handler = handlers[type] || removeListener;\n    handler(chart, type, proxy);\n    proxies[type] = undefined;\n  }\n\n  getDevicePixelRatio() {\n    return window.devicePixelRatio;\n  }\n\n  /**\n\t * @param {HTMLCanvasElement} canvas\n\t * @param {number} [width] - content width of parent element\n\t * @param {number} [height] - content height of parent element\n\t * @param {number} [aspectRatio] - aspect ratio to maintain\n\t */\n  getMaximumSize(canvas, width, height, aspectRatio) {\n    return getMaximumSize(canvas, width, height, aspectRatio);\n  }\n\n  /**\n\t * @param {HTMLCanvasElement} canvas\n\t */\n  isAttached(canvas) {\n    const container = _getParentNode(canvas);\n    return !!(container && container.isConnected);\n  }\n}\n","import type {AnyObject} from '../types/basic.js';\nimport type {Point} from '../types/geometric.js';\nimport type {Animation} from '../types/animation.js';\nimport {isNumber} from '../helpers/helpers.math.js';\n\nexport default class Element<T = AnyObject, O = AnyObject> {\n\n  static defaults = {};\n  static defaultRoutes = undefined;\n\n  x: number;\n  y: number;\n  active = false;\n  options: O;\n  $animations: Record<keyof T, Animation>;\n\n  tooltipPosition(useFinalPosition: boolean): Point {\n    const {x, y} = this.getProps(['x', 'y'], useFinalPosition);\n    return {x, y} as Point;\n  }\n\n  hasValue() {\n    return isNumber(this.x) && isNumber(this.y);\n  }\n\n  /**\n   * Gets the current or final value of each prop. Can return extra properties (whole object).\n   * @param props - properties to get\n   * @param [final] - get the final value (animation target)\n   */\n  getProps<P extends (keyof T)[]>(props: P, final?: boolean): Pick<T, P[number]>;\n  getProps<P extends string>(props: P[], final?: boolean): Partial<Record<P, unknown>>;\n  getProps(props: string[], final?: boolean): Partial<Record<string, unknown>> {\n    const anims = this.$animations;\n    if (!final || !anims) {\n      // let's not create an object, if not needed\n      return this as Record<string, unknown>;\n    }\n    const ret: Record<string, unknown> = {};\n    props.forEach((prop) => {\n      ret[prop] = anims[prop] && anims[prop].active() ? anims[prop]._to : this[prop as string];\n    });\n    return ret;\n  }\n}\n","import {isNullOrUndef, valueOrDefault} from '../helpers/helpers.core.js';\nimport {_factorize} from '../helpers/helpers.math.js';\n\n\n/**\n * @typedef { import('./core.controller.js').default } Chart\n * @typedef {{value:number | string, label?:string, major?:boolean, $context?:any}} Tick\n */\n\n/**\n * Returns a subset of ticks to be plotted to avoid overlapping labels.\n * @param {import('./core.scale.js').default} scale\n * @param {Tick[]} ticks\n * @return {Tick[]}\n * @private\n */\nexport function autoSkip(scale, ticks) {\n  const tickOpts = scale.options.ticks;\n  const determinedMaxTicks = determineMaxTicks(scale);\n  const ticksLimit = Math.min(tickOpts.maxTicksLimit || determinedMaxTicks, determinedMaxTicks);\n  const majorIndices = tickOpts.major.enabled ? getMajorIndices(ticks) : [];\n  const numMajorIndices = majorIndices.length;\n  const first = majorIndices[0];\n  const last = majorIndices[numMajorIndices - 1];\n  const newTicks = [];\n\n  // If there are too many major ticks to display them all\n  if (numMajorIndices > ticksLimit) {\n    skipMajors(ticks, newTicks, majorIndices, numMajorIndices / ticksLimit);\n    return newTicks;\n  }\n\n  const spacing = calculateSpacing(majorIndices, ticks, ticksLimit);\n\n  if (numMajorIndices > 0) {\n    let i, ilen;\n    const avgMajorSpacing = numMajorIndices > 1 ? Math.round((last - first) / (numMajorIndices - 1)) : null;\n    skip(ticks, newTicks, spacing, isNullOrUndef(avgMajorSpacing) ? 0 : first - avgMajorSpacing, first);\n    for (i = 0, ilen = numMajorIndices - 1; i < ilen; i++) {\n      skip(ticks, newTicks, spacing, majorIndices[i], majorIndices[i + 1]);\n    }\n    skip(ticks, newTicks, spacing, last, isNullOrUndef(avgMajorSpacing) ? ticks.length : last + avgMajorSpacing);\n    return newTicks;\n  }\n  skip(ticks, newTicks, spacing);\n  return newTicks;\n}\n\nfunction determineMaxTicks(scale) {\n  const offset = scale.options.offset;\n  const tickLength = scale._tickSize();\n  const maxScale = scale._length / tickLength + (offset ? 0 : 1);\n  const maxChart = scale._maxLength / tickLength;\n  return Math.floor(Math.min(maxScale, maxChart));\n}\n\n/**\n * @param {number[]} majorIndices\n * @param {Tick[]} ticks\n * @param {number} ticksLimit\n */\nfunction calculateSpacing(majorIndices, ticks, ticksLimit) {\n  const evenMajorSpacing = getEvenSpacing(majorIndices);\n  const spacing = ticks.length / ticksLimit;\n\n  // If the major ticks are evenly spaced apart, place the minor ticks\n  // so that they divide the major ticks into even chunks\n  if (!evenMajorSpacing) {\n    return Math.max(spacing, 1);\n  }\n\n  const factors = _factorize(evenMajorSpacing);\n  for (let i = 0, ilen = factors.length - 1; i < ilen; i++) {\n    const factor = factors[i];\n    if (factor > spacing) {\n      return factor;\n    }\n  }\n  return Math.max(spacing, 1);\n}\n\n/**\n * @param {Tick[]} ticks\n */\nfunction getMajorIndices(ticks) {\n  const result = [];\n  let i, ilen;\n  for (i = 0, ilen = ticks.length; i < ilen; i++) {\n    if (ticks[i].major) {\n      result.push(i);\n    }\n  }\n  return result;\n}\n\n/**\n * @param {Tick[]} ticks\n * @param {Tick[]} newTicks\n * @param {number[]} majorIndices\n * @param {number} spacing\n */\nfunction skipMajors(ticks, newTicks, majorIndices, spacing) {\n  let count = 0;\n  let next = majorIndices[0];\n  let i;\n\n  spacing = Math.ceil(spacing);\n  for (i = 0; i < ticks.length; i++) {\n    if (i === next) {\n      newTicks.push(ticks[i]);\n      count++;\n      next = majorIndices[count * spacing];\n    }\n  }\n}\n\n/**\n * @param {Tick[]} ticks\n * @param {Tick[]} newTicks\n * @param {number} spacing\n * @param {number} [majorStart]\n * @param {number} [majorEnd]\n */\nfunction skip(ticks, newTicks, spacing, majorStart, majorEnd) {\n  const start = valueOrDefault(majorStart, 0);\n  const end = Math.min(valueOrDefault(majorEnd, ticks.length), ticks.length);\n  let count = 0;\n  let length, i, next;\n\n  spacing = Math.ceil(spacing);\n  if (majorEnd) {\n    length = majorEnd - majorStart;\n    spacing = length / Math.floor(length / spacing);\n  }\n\n  next = start;\n\n  while (next < 0) {\n    count++;\n    next = Math.round(start + count * spacing);\n  }\n\n  for (i = Math.max(start, 0); i < end; i++) {\n    if (i === next) {\n      newTicks.push(ticks[i]);\n      count++;\n      next = Math.round(start + count * spacing);\n    }\n  }\n}\n\n\n/**\n * @param {number[]} arr\n */\nfunction getEvenSpacing(arr) {\n  const len = arr.length;\n  let i, diff;\n\n  if (len < 2) {\n    return false;\n  }\n\n  for (diff = arr[0], i = 1; i < len; ++i) {\n    if (arr[i] - arr[i - 1] !== diff) {\n      return false;\n    }\n  }\n  return diff;\n}\n","import Element from './core.element.js';\nimport {_alignPixel, _measureText, renderText, clipArea, unclipArea} from '../helpers/helpers.canvas.js';\nimport {callback as call, each, finiteOrDefault, isArray, isFinite, isNullOrUndef, isObject, valueOrDefault} from '../helpers/helpers.core.js';\nimport {toDegrees, toRadians, _int16Range, _limitValue, HALF_PI} from '../helpers/helpers.math.js';\nimport {_alignStartEnd, _toLeftRightCenter} from '../helpers/helpers.extras.js';\nimport {createContext, toFont, toPadding, _addGrace} from '../helpers/helpers.options.js';\nimport {autoSkip} from './core.scale.autoskip.js';\n\nconst reverseAlign = (align) => align === 'left' ? 'right' : align === 'right' ? 'left' : align;\nconst offsetFromEdge = (scale, edge, offset) => edge === 'top' || edge === 'left' ? scale[edge] + offset : scale[edge] - offset;\nconst getTicksLimit = (ticksLength, maxTicksLimit) => Math.min(maxTicksLimit || ticksLength, ticksLength);\n\n/**\n * @typedef { import('../types/index.js').Chart } Chart\n * @typedef {{value:number | string, label?:string, major?:boolean, $context?:any}} Tick\n */\n\n/**\n * Returns a new array containing numItems from arr\n * @param {any[]} arr\n * @param {number} numItems\n */\nfunction sample(arr, numItems) {\n  const result = [];\n  const increment = arr.length / numItems;\n  const len = arr.length;\n  let i = 0;\n\n  for (; i < len; i += increment) {\n    result.push(arr[Math.floor(i)]);\n  }\n  return result;\n}\n\n/**\n * @param {Scale} scale\n * @param {number} index\n * @param {boolean} offsetGridLines\n */\nfunction getPixelForGridLine(scale, index, offsetGridLines) {\n  const length = scale.ticks.length;\n  const validIndex = Math.min(index, length - 1);\n  const start = scale._startPixel;\n  const end = scale._endPixel;\n  const epsilon = 1e-6; // 1e-6 is margin in pixels for accumulated error.\n  let lineValue = scale.getPixelForTick(validIndex);\n  let offset;\n\n  if (offsetGridLines) {\n    if (length === 1) {\n      offset = Math.max(lineValue - start, end - lineValue);\n    } else if (index === 0) {\n      offset = (scale.getPixelForTick(1) - lineValue) / 2;\n    } else {\n      offset = (lineValue - scale.getPixelForTick(validIndex - 1)) / 2;\n    }\n    lineValue += validIndex < index ? offset : -offset;\n\n    // Return undefined if the pixel is out of the range\n    if (lineValue < start - epsilon || lineValue > end + epsilon) {\n      return;\n    }\n  }\n  return lineValue;\n}\n\n/**\n * @param {object} caches\n * @param {number} length\n */\nfunction garbageCollect(caches, length) {\n  each(caches, (cache) => {\n    const gc = cache.gc;\n    const gcLen = gc.length / 2;\n    let i;\n    if (gcLen > length) {\n      for (i = 0; i < gcLen; ++i) {\n        delete cache.data[gc[i]];\n      }\n      gc.splice(0, gcLen);\n    }\n  });\n}\n\n/**\n * @param {object} options\n */\nfunction getTickMarkLength(options) {\n  return options.drawTicks ? options.tickLength : 0;\n}\n\n/**\n * @param {object} options\n */\nfunction getTitleHeight(options, fallback) {\n  if (!options.display) {\n    return 0;\n  }\n\n  const font = toFont(options.font, fallback);\n  const padding = toPadding(options.padding);\n  const lines = isArray(options.text) ? options.text.length : 1;\n\n  return (lines * font.lineHeight) + padding.height;\n}\n\nfunction createScaleContext(parent, scale) {\n  return createContext(parent, {\n    scale,\n    type: 'scale'\n  });\n}\n\nfunction createTickContext(parent, index, tick) {\n  return createContext(parent, {\n    tick,\n    index,\n    type: 'tick'\n  });\n}\n\nfunction titleAlign(align, position, reverse) {\n  /** @type {CanvasTextAlign} */\n  let ret = _toLeftRightCenter(align);\n  if ((reverse && position !== 'right') || (!reverse && position === 'right')) {\n    ret = reverseAlign(ret);\n  }\n  return ret;\n}\n\nfunction titleArgs(scale, offset, position, align) {\n  const {top, left, bottom, right, chart} = scale;\n  const {chartArea, scales} = chart;\n  let rotation = 0;\n  let maxWidth, titleX, titleY;\n  const height = bottom - top;\n  const width = right - left;\n\n  if (scale.isHorizontal()) {\n    titleX = _alignStartEnd(align, left, right);\n\n    if (isObject(position)) {\n      const positionAxisID = Object.keys(position)[0];\n      const value = position[positionAxisID];\n      titleY = scales[positionAxisID].getPixelForValue(value) + height - offset;\n    } else if (position === 'center') {\n      titleY = (chartArea.bottom + chartArea.top) / 2 + height - offset;\n    } else {\n      titleY = offsetFromEdge(scale, position, offset);\n    }\n    maxWidth = right - left;\n  } else {\n    if (isObject(position)) {\n      const positionAxisID = Object.keys(position)[0];\n      const value = position[positionAxisID];\n      titleX = scales[positionAxisID].getPixelForValue(value) - width + offset;\n    } else if (position === 'center') {\n      titleX = (chartArea.left + chartArea.right) / 2 - width + offset;\n    } else {\n      titleX = offsetFromEdge(scale, position, offset);\n    }\n    titleY = _alignStartEnd(align, bottom, top);\n    rotation = position === 'left' ? -HALF_PI : HALF_PI;\n  }\n  return {titleX, titleY, maxWidth, rotation};\n}\n\nexport default class Scale extends Element {\n\n  // eslint-disable-next-line max-statements\n  constructor(cfg) {\n    super();\n\n    /** @type {string} */\n    this.id = cfg.id;\n    /** @type {string} */\n    this.type = cfg.type;\n    /** @type {any} */\n    this.options = undefined;\n    /** @type {CanvasRenderingContext2D} */\n    this.ctx = cfg.ctx;\n    /** @type {Chart} */\n    this.chart = cfg.chart;\n\n    // implements box\n    /** @type {number} */\n    this.top = undefined;\n    /** @type {number} */\n    this.bottom = undefined;\n    /** @type {number} */\n    this.left = undefined;\n    /** @type {number} */\n    this.right = undefined;\n    /** @type {number} */\n    this.width = undefined;\n    /** @type {number} */\n    this.height = undefined;\n    this._margins = {\n      left: 0,\n      right: 0,\n      top: 0,\n      bottom: 0\n    };\n    /** @type {number} */\n    this.maxWidth = undefined;\n    /** @type {number} */\n    this.maxHeight = undefined;\n    /** @type {number} */\n    this.paddingTop = undefined;\n    /** @type {number} */\n    this.paddingBottom = undefined;\n    /** @type {number} */\n    this.paddingLeft = undefined;\n    /** @type {number} */\n    this.paddingRight = undefined;\n\n    // scale-specific properties\n    /** @type {string=} */\n    this.axis = undefined;\n    /** @type {number=} */\n    this.labelRotation = undefined;\n    this.min = undefined;\n    this.max = undefined;\n    this._range = undefined;\n    /** @type {Tick[]} */\n    this.ticks = [];\n    /** @type {object[]|null} */\n    this._gridLineItems = null;\n    /** @type {object[]|null} */\n    this._labelItems = null;\n    /** @type {object|null} */\n    this._labelSizes = null;\n    this._length = 0;\n    this._maxLength = 0;\n    this._longestTextCache = {};\n    /** @type {number} */\n    this._startPixel = undefined;\n    /** @type {number} */\n    this._endPixel = undefined;\n    this._reversePixels = false;\n    this._userMax = undefined;\n    this._userMin = undefined;\n    this._suggestedMax = undefined;\n    this._suggestedMin = undefined;\n    this._ticksLength = 0;\n    this._borderValue = 0;\n    this._cache = {};\n    this._dataLimitsCached = false;\n    this.$context = undefined;\n  }\n\n  /**\n\t * @param {any} options\n\t * @since 3.0\n\t */\n  init(options) {\n    this.options = options.setContext(this.getContext());\n\n    this.axis = options.axis;\n\n    // parse min/max value, so we can properly determine min/max for other scales\n    this._userMin = this.parse(options.min);\n    this._userMax = this.parse(options.max);\n    this._suggestedMin = this.parse(options.suggestedMin);\n    this._suggestedMax = this.parse(options.suggestedMax);\n  }\n\n  /**\n\t * Parse a supported input value to internal representation.\n\t * @param {*} raw\n\t * @param {number} [index]\n\t * @since 3.0\n\t */\n  parse(raw, index) { // eslint-disable-line no-unused-vars\n    return raw;\n  }\n\n  /**\n\t * @return {{min: number, max: number, minDefined: boolean, maxDefined: boolean}}\n\t * @protected\n\t * @since 3.0\n\t */\n  getUserBounds() {\n    let {_userMin, _userMax, _suggestedMin, _suggestedMax} = this;\n    _userMin = finiteOrDefault(_userMin, Number.POSITIVE_INFINITY);\n    _userMax = finiteOrDefault(_userMax, Number.NEGATIVE_INFINITY);\n    _suggestedMin = finiteOrDefault(_suggestedMin, Number.POSITIVE_INFINITY);\n    _suggestedMax = finiteOrDefault(_suggestedMax, Number.NEGATIVE_INFINITY);\n    return {\n      min: finiteOrDefault(_userMin, _suggestedMin),\n      max: finiteOrDefault(_userMax, _suggestedMax),\n      minDefined: isFinite(_userMin),\n      maxDefined: isFinite(_userMax)\n    };\n  }\n\n  /**\n\t * @param {boolean} canStack\n\t * @return {{min: number, max: number}}\n\t * @protected\n\t * @since 3.0\n\t */\n  getMinMax(canStack) {\n    // eslint-disable-next-line prefer-const\n    let {min, max, minDefined, maxDefined} = this.getUserBounds();\n    let range;\n\n    if (minDefined && maxDefined) {\n      return {min, max};\n    }\n\n    const metas = this.getMatchingVisibleMetas();\n    for (let i = 0, ilen = metas.length; i < ilen; ++i) {\n      range = metas[i].controller.getMinMax(this, canStack);\n      if (!minDefined) {\n        min = Math.min(min, range.min);\n      }\n      if (!maxDefined) {\n        max = Math.max(max, range.max);\n      }\n    }\n\n    // Make sure min <= max when only min or max is defined by user and the data is outside that range\n    min = maxDefined && min > max ? max : min;\n    max = minDefined && min > max ? min : max;\n\n    return {\n      min: finiteOrDefault(min, finiteOrDefault(max, min)),\n      max: finiteOrDefault(max, finiteOrDefault(min, max))\n    };\n  }\n\n  /**\n\t * Get the padding needed for the scale\n\t * @return {{top: number, left: number, bottom: number, right: number}} the necessary padding\n\t * @private\n\t */\n  getPadding() {\n    return {\n      left: this.paddingLeft || 0,\n      top: this.paddingTop || 0,\n      right: this.paddingRight || 0,\n      bottom: this.paddingBottom || 0\n    };\n  }\n\n  /**\n\t * Returns the scale tick objects\n\t * @return {Tick[]}\n\t * @since 2.7\n\t */\n  getTicks() {\n    return this.ticks;\n  }\n\n  /**\n\t * @return {string[]}\n\t */\n  getLabels() {\n    const data = this.chart.data;\n    return this.options.labels || (this.isHorizontal() ? data.xLabels : data.yLabels) || data.labels || [];\n  }\n\n  /**\n   * @return {import('../types.js').LabelItem[]}\n   */\n  getLabelItems(chartArea = this.chart.chartArea) {\n    const items = this._labelItems || (this._labelItems = this._computeLabelItems(chartArea));\n    return items;\n  }\n\n  // When a new layout is created, reset the data limits cache\n  beforeLayout() {\n    this._cache = {};\n    this._dataLimitsCached = false;\n  }\n\n  // These methods are ordered by lifecycle. Utilities then follow.\n  // Any function defined here is inherited by all scale types.\n  // Any function can be extended by the scale type\n\n  beforeUpdate() {\n    call(this.options.beforeUpdate, [this]);\n  }\n\n  /**\n\t * @param {number} maxWidth - the max width in pixels\n\t * @param {number} maxHeight - the max height in pixels\n\t * @param {{top: number, left: number, bottom: number, right: number}} margins - the space between the edge of the other scales and edge of the chart\n\t *   This space comes from two sources:\n\t *     - padding - space that's required to show the labels at the edges of the scale\n\t *     - thickness of scales or legends in another orientation\n\t */\n  update(maxWidth, maxHeight, margins) {\n    const {beginAtZero, grace, ticks: tickOpts} = this.options;\n    const sampleSize = tickOpts.sampleSize;\n\n    // Update Lifecycle - Probably don't want to ever extend or overwrite this function ;)\n    this.beforeUpdate();\n\n    // Absorb the master measurements\n    this.maxWidth = maxWidth;\n    this.maxHeight = maxHeight;\n    this._margins = margins = Object.assign({\n      left: 0,\n      right: 0,\n      top: 0,\n      bottom: 0\n    }, margins);\n\n    this.ticks = null;\n    this._labelSizes = null;\n    this._gridLineItems = null;\n    this._labelItems = null;\n\n    // Dimensions\n    this.beforeSetDimensions();\n    this.setDimensions();\n    this.afterSetDimensions();\n\n    this._maxLength = this.isHorizontal()\n      ? this.width + margins.left + margins.right\n      : this.height + margins.top + margins.bottom;\n\n    // Data min/max\n    if (!this._dataLimitsCached) {\n      this.beforeDataLimits();\n      this.determineDataLimits();\n      this.afterDataLimits();\n      this._range = _addGrace(this, grace, beginAtZero);\n      this._dataLimitsCached = true;\n    }\n\n    this.beforeBuildTicks();\n\n    this.ticks = this.buildTicks() || [];\n\n    // Allow modification of ticks in callback.\n    this.afterBuildTicks();\n\n    // Compute tick rotation and fit using a sampled subset of labels\n    // We generally don't need to compute the size of every single label for determining scale size\n    const samplingEnabled = sampleSize < this.ticks.length;\n    this._convertTicksToLabels(samplingEnabled ? sample(this.ticks, sampleSize) : this.ticks);\n\n    // configure is called twice, once here, once from core.controller.updateLayout.\n    // Here we haven't been positioned yet, but dimensions are correct.\n    // Variables set in configure are needed for calculateLabelRotation, and\n    // it's ok that coordinates are not correct there, only dimensions matter.\n    this.configure();\n\n    // Tick Rotation\n    this.beforeCalculateLabelRotation();\n    this.calculateLabelRotation(); // Preconditions: number of ticks and sizes of largest labels must be calculated beforehand\n    this.afterCalculateLabelRotation();\n\n    // Auto-skip\n    if (tickOpts.display && (tickOpts.autoSkip || tickOpts.source === 'auto')) {\n      this.ticks = autoSkip(this, this.ticks);\n      this._labelSizes = null;\n      this.afterAutoSkip();\n    }\n\n    if (samplingEnabled) {\n      // Generate labels using all non-skipped ticks\n      this._convertTicksToLabels(this.ticks);\n    }\n\n    this.beforeFit();\n    this.fit(); // Preconditions: label rotation and label sizes must be calculated beforehand\n    this.afterFit();\n\n    // IMPORTANT: after this point, we consider that `this.ticks` will NEVER change!\n\n    this.afterUpdate();\n  }\n\n  /**\n\t * @protected\n\t */\n  configure() {\n    let reversePixels = this.options.reverse;\n    let startPixel, endPixel;\n\n    if (this.isHorizontal()) {\n      startPixel = this.left;\n      endPixel = this.right;\n    } else {\n      startPixel = this.top;\n      endPixel = this.bottom;\n      // by default vertical scales are from bottom to top, so pixels are reversed\n      reversePixels = !reversePixels;\n    }\n    this._startPixel = startPixel;\n    this._endPixel = endPixel;\n    this._reversePixels = reversePixels;\n    this._length = endPixel - startPixel;\n    this._alignToPixels = this.options.alignToPixels;\n  }\n\n  afterUpdate() {\n    call(this.options.afterUpdate, [this]);\n  }\n\n  //\n\n  beforeSetDimensions() {\n    call(this.options.beforeSetDimensions, [this]);\n  }\n  setDimensions() {\n    // Set the unconstrained dimension before label rotation\n    if (this.isHorizontal()) {\n      // Reset position before calculating rotation\n      this.width = this.maxWidth;\n      this.left = 0;\n      this.right = this.width;\n    } else {\n      this.height = this.maxHeight;\n\n      // Reset position before calculating rotation\n      this.top = 0;\n      this.bottom = this.height;\n    }\n\n    // Reset padding\n    this.paddingLeft = 0;\n    this.paddingTop = 0;\n    this.paddingRight = 0;\n    this.paddingBottom = 0;\n  }\n  afterSetDimensions() {\n    call(this.options.afterSetDimensions, [this]);\n  }\n\n  _callHooks(name) {\n    this.chart.notifyPlugins(name, this.getContext());\n    call(this.options[name], [this]);\n  }\n\n  // Data limits\n  beforeDataLimits() {\n    this._callHooks('beforeDataLimits');\n  }\n  determineDataLimits() {}\n  afterDataLimits() {\n    this._callHooks('afterDataLimits');\n  }\n\n  //\n  beforeBuildTicks() {\n    this._callHooks('beforeBuildTicks');\n  }\n  /**\n\t * @return {object[]} the ticks\n\t */\n  buildTicks() {\n    return [];\n  }\n  afterBuildTicks() {\n    this._callHooks('afterBuildTicks');\n  }\n\n  beforeTickToLabelConversion() {\n    call(this.options.beforeTickToLabelConversion, [this]);\n  }\n  /**\n\t * Convert ticks to label strings\n\t * @param {Tick[]} ticks\n\t */\n  generateTickLabels(ticks) {\n    const tickOpts = this.options.ticks;\n    let i, ilen, tick;\n    for (i = 0, ilen = ticks.length; i < ilen; i++) {\n      tick = ticks[i];\n      tick.label = call(tickOpts.callback, [tick.value, i, ticks], this);\n    }\n  }\n  afterTickToLabelConversion() {\n    call(this.options.afterTickToLabelConversion, [this]);\n  }\n\n  //\n\n  beforeCalculateLabelRotation() {\n    call(this.options.beforeCalculateLabelRotation, [this]);\n  }\n  calculateLabelRotation() {\n    const options = this.options;\n    const tickOpts = options.ticks;\n    const numTicks = getTicksLimit(this.ticks.length, options.ticks.maxTicksLimit);\n    const minRotation = tickOpts.minRotation || 0;\n    const maxRotation = tickOpts.maxRotation;\n    let labelRotation = minRotation;\n    let tickWidth, maxHeight, maxLabelDiagonal;\n\n    if (!this._isVisible() || !tickOpts.display || minRotation >= maxRotation || numTicks <= 1 || !this.isHorizontal()) {\n      this.labelRotation = minRotation;\n      return;\n    }\n\n    const labelSizes = this._getLabelSizes();\n    const maxLabelWidth = labelSizes.widest.width;\n    const maxLabelHeight = labelSizes.highest.height;\n\n    // Estimate the width of each grid based on the canvas width, the maximum\n    // label width and the number of tick intervals\n    const maxWidth = _limitValue(this.chart.width - maxLabelWidth, 0, this.maxWidth);\n    tickWidth = options.offset ? this.maxWidth / numTicks : maxWidth / (numTicks - 1);\n\n    // Allow 3 pixels x2 padding either side for label readability\n    if (maxLabelWidth + 6 > tickWidth) {\n      tickWidth = maxWidth / (numTicks - (options.offset ? 0.5 : 1));\n      maxHeight = this.maxHeight - getTickMarkLength(options.grid)\n\t\t\t\t- tickOpts.padding - getTitleHeight(options.title, this.chart.options.font);\n      maxLabelDiagonal = Math.sqrt(maxLabelWidth * maxLabelWidth + maxLabelHeight * maxLabelHeight);\n      labelRotation = toDegrees(Math.min(\n        Math.asin(_limitValue((labelSizes.highest.height + 6) / tickWidth, -1, 1)),\n        Math.asin(_limitValue(maxHeight / maxLabelDiagonal, -1, 1)) - Math.asin(_limitValue(maxLabelHeight / maxLabelDiagonal, -1, 1))\n      ));\n      labelRotation = Math.max(minRotation, Math.min(maxRotation, labelRotation));\n    }\n\n    this.labelRotation = labelRotation;\n  }\n  afterCalculateLabelRotation() {\n    call(this.options.afterCalculateLabelRotation, [this]);\n  }\n  afterAutoSkip() {}\n\n  //\n\n  beforeFit() {\n    call(this.options.beforeFit, [this]);\n  }\n  fit() {\n    // Reset\n    const minSize = {\n      width: 0,\n      height: 0\n    };\n\n    const {chart, options: {ticks: tickOpts, title: titleOpts, grid: gridOpts}} = this;\n    const display = this._isVisible();\n    const isHorizontal = this.isHorizontal();\n\n    if (display) {\n      const titleHeight = getTitleHeight(titleOpts, chart.options.font);\n      if (isHorizontal) {\n        minSize.width = this.maxWidth;\n        minSize.height = getTickMarkLength(gridOpts) + titleHeight;\n      } else {\n        minSize.height = this.maxHeight; // fill all the height\n        minSize.width = getTickMarkLength(gridOpts) + titleHeight;\n      }\n\n      // Don't bother fitting the ticks if we are not showing the labels\n      if (tickOpts.display && this.ticks.length) {\n        const {first, last, widest, highest} = this._getLabelSizes();\n        const tickPadding = tickOpts.padding * 2;\n        const angleRadians = toRadians(this.labelRotation);\n        const cos = Math.cos(angleRadians);\n        const sin = Math.sin(angleRadians);\n\n        if (isHorizontal) {\n        // A horizontal axis is more constrained by the height.\n          const labelHeight = tickOpts.mirror ? 0 : sin * widest.width + cos * highest.height;\n          minSize.height = Math.min(this.maxHeight, minSize.height + labelHeight + tickPadding);\n        } else {\n        // A vertical axis is more constrained by the width. Labels are the\n        // dominant factor here, so get that length first and account for padding\n          const labelWidth = tickOpts.mirror ? 0 : cos * widest.width + sin * highest.height;\n\n          minSize.width = Math.min(this.maxWidth, minSize.width + labelWidth + tickPadding);\n        }\n        this._calculatePadding(first, last, sin, cos);\n      }\n    }\n\n    this._handleMargins();\n\n    if (isHorizontal) {\n      this.width = this._length = chart.width - this._margins.left - this._margins.right;\n      this.height = minSize.height;\n    } else {\n      this.width = minSize.width;\n      this.height = this._length = chart.height - this._margins.top - this._margins.bottom;\n    }\n  }\n\n  _calculatePadding(first, last, sin, cos) {\n    const {ticks: {align, padding}, position} = this.options;\n    const isRotated = this.labelRotation !== 0;\n    const labelsBelowTicks = position !== 'top' && this.axis === 'x';\n\n    if (this.isHorizontal()) {\n      const offsetLeft = this.getPixelForTick(0) - this.left;\n      const offsetRight = this.right - this.getPixelForTick(this.ticks.length - 1);\n      let paddingLeft = 0;\n      let paddingRight = 0;\n\n      // Ensure that our ticks are always inside the canvas. When rotated, ticks are right aligned\n      // which means that the right padding is dominated by the font height\n      if (isRotated) {\n        if (labelsBelowTicks) {\n          paddingLeft = cos * first.width;\n          paddingRight = sin * last.height;\n        } else {\n          paddingLeft = sin * first.height;\n          paddingRight = cos * last.width;\n        }\n      } else if (align === 'start') {\n        paddingRight = last.width;\n      } else if (align === 'end') {\n        paddingLeft = first.width;\n      } else if (align !== 'inner') {\n        paddingLeft = first.width / 2;\n        paddingRight = last.width / 2;\n      }\n\n      // Adjust padding taking into account changes in offsets\n      this.paddingLeft = Math.max((paddingLeft - offsetLeft + padding) * this.width / (this.width - offsetLeft), 0);\n      this.paddingRight = Math.max((paddingRight - offsetRight + padding) * this.width / (this.width - offsetRight), 0);\n    } else {\n      let paddingTop = last.height / 2;\n      let paddingBottom = first.height / 2;\n\n      if (align === 'start') {\n        paddingTop = 0;\n        paddingBottom = first.height;\n      } else if (align === 'end') {\n        paddingTop = last.height;\n        paddingBottom = 0;\n      }\n\n      this.paddingTop = paddingTop + padding;\n      this.paddingBottom = paddingBottom + padding;\n    }\n  }\n\n  /**\n\t * Handle margins and padding interactions\n\t * @private\n\t */\n  _handleMargins() {\n    if (this._margins) {\n      this._margins.left = Math.max(this.paddingLeft, this._margins.left);\n      this._margins.top = Math.max(this.paddingTop, this._margins.top);\n      this._margins.right = Math.max(this.paddingRight, this._margins.right);\n      this._margins.bottom = Math.max(this.paddingBottom, this._margins.bottom);\n    }\n  }\n\n  afterFit() {\n    call(this.options.afterFit, [this]);\n  }\n\n  // Shared Methods\n  /**\n\t * @return {boolean}\n\t */\n  isHorizontal() {\n    const {axis, position} = this.options;\n    return position === 'top' || position === 'bottom' || axis === 'x';\n  }\n  /**\n\t * @return {boolean}\n\t */\n  isFullSize() {\n    return this.options.fullSize;\n  }\n\n  /**\n\t * @param {Tick[]} ticks\n\t * @private\n\t */\n  _convertTicksToLabels(ticks) {\n    this.beforeTickToLabelConversion();\n\n    this.generateTickLabels(ticks);\n\n    // Ticks should be skipped when callback returns null or undef, so lets remove those.\n    let i, ilen;\n    for (i = 0, ilen = ticks.length; i < ilen; i++) {\n      if (isNullOrUndef(ticks[i].label)) {\n        ticks.splice(i, 1);\n        ilen--;\n        i--;\n      }\n    }\n\n    this.afterTickToLabelConversion();\n  }\n\n  /**\n\t * @return {{ first: object, last: object, widest: object, highest: object, widths: Array, heights: array }}\n\t * @private\n\t */\n  _getLabelSizes() {\n    let labelSizes = this._labelSizes;\n\n    if (!labelSizes) {\n      const sampleSize = this.options.ticks.sampleSize;\n      let ticks = this.ticks;\n      if (sampleSize < ticks.length) {\n        ticks = sample(ticks, sampleSize);\n      }\n\n      this._labelSizes = labelSizes = this._computeLabelSizes(ticks, ticks.length, this.options.ticks.maxTicksLimit);\n    }\n\n    return labelSizes;\n  }\n\n  /**\n\t * Returns {width, height, offset} objects for the first, last, widest, highest tick\n\t * labels where offset indicates the anchor point offset from the top in pixels.\n\t * @return {{ first: object, last: object, widest: object, highest: object, widths: Array, heights: array }}\n\t * @private\n\t */\n  _computeLabelSizes(ticks, length, maxTicksLimit) {\n    const {ctx, _longestTextCache: caches} = this;\n    const widths = [];\n    const heights = [];\n    const increment = Math.floor(length / getTicksLimit(length, maxTicksLimit));\n    let widestLabelSize = 0;\n    let highestLabelSize = 0;\n    let i, j, jlen, label, tickFont, fontString, cache, lineHeight, width, height, nestedLabel;\n\n    for (i = 0; i < length; i += increment) {\n      label = ticks[i].label;\n      tickFont = this._resolveTickFontOptions(i);\n      ctx.font = fontString = tickFont.string;\n      cache = caches[fontString] = caches[fontString] || {data: {}, gc: []};\n      lineHeight = tickFont.lineHeight;\n      width = height = 0;\n      // Undefined labels and arrays should not be measured\n      if (!isNullOrUndef(label) && !isArray(label)) {\n        width = _measureText(ctx, cache.data, cache.gc, width, label);\n        height = lineHeight;\n      } else if (isArray(label)) {\n        // if it is an array let's measure each element\n        for (j = 0, jlen = label.length; j < jlen; ++j) {\n          nestedLabel = /** @type {string} */ (label[j]);\n          // Undefined labels and arrays should not be measured\n          if (!isNullOrUndef(nestedLabel) && !isArray(nestedLabel)) {\n            width = _measureText(ctx, cache.data, cache.gc, width, nestedLabel);\n            height += lineHeight;\n          }\n        }\n      }\n      widths.push(width);\n      heights.push(height);\n      widestLabelSize = Math.max(width, widestLabelSize);\n      highestLabelSize = Math.max(height, highestLabelSize);\n    }\n    garbageCollect(caches, length);\n\n    const widest = widths.indexOf(widestLabelSize);\n    const highest = heights.indexOf(highestLabelSize);\n\n    const valueAt = (idx) => ({width: widths[idx] || 0, height: heights[idx] || 0});\n\n    return {\n      first: valueAt(0),\n      last: valueAt(length - 1),\n      widest: valueAt(widest),\n      highest: valueAt(highest),\n      widths,\n      heights,\n    };\n  }\n\n  /**\n\t * Used to get the label to display in the tooltip for the given value\n\t * @param {*} value\n\t * @return {string}\n\t */\n  getLabelForValue(value) {\n    return value;\n  }\n\n  /**\n\t * Returns the location of the given data point. Value can either be an index or a numerical value\n\t * The coordinate (0, 0) is at the upper-left corner of the canvas\n\t * @param {*} value\n\t * @param {number} [index]\n\t * @return {number}\n\t */\n  getPixelForValue(value, index) { // eslint-disable-line no-unused-vars\n    return NaN;\n  }\n\n  /**\n\t * Used to get the data value from a given pixel. This is the inverse of getPixelForValue\n\t * The coordinate (0, 0) is at the upper-left corner of the canvas\n\t * @param {number} pixel\n\t * @return {*}\n\t */\n  getValueForPixel(pixel) {} // eslint-disable-line no-unused-vars\n\n  /**\n\t * Returns the location of the tick at the given index\n\t * The coordinate (0, 0) is at the upper-left corner of the canvas\n\t * @param {number} index\n\t * @return {number}\n\t */\n  getPixelForTick(index) {\n    const ticks = this.ticks;\n    if (index < 0 || index > ticks.length - 1) {\n      return null;\n    }\n    return this.getPixelForValue(ticks[index].value);\n  }\n\n  /**\n\t * Utility for getting the pixel location of a percentage of scale\n\t * The coordinate (0, 0) is at the upper-left corner of the canvas\n\t * @param {number} decimal\n\t * @return {number}\n\t */\n  getPixelForDecimal(decimal) {\n    if (this._reversePixels) {\n      decimal = 1 - decimal;\n    }\n\n    const pixel = this._startPixel + decimal * this._length;\n    return _int16Range(this._alignToPixels ? _alignPixel(this.chart, pixel, 0) : pixel);\n  }\n\n  /**\n\t * @param {number} pixel\n\t * @return {number}\n\t */\n  getDecimalForPixel(pixel) {\n    const decimal = (pixel - this._startPixel) / this._length;\n    return this._reversePixels ? 1 - decimal : decimal;\n  }\n\n  /**\n\t * Returns the pixel for the minimum chart value\n\t * The coordinate (0, 0) is at the upper-left corner of the canvas\n\t * @return {number}\n\t */\n  getBasePixel() {\n    return this.getPixelForValue(this.getBaseValue());\n  }\n\n  /**\n\t * @return {number}\n\t */\n  getBaseValue() {\n    const {min, max} = this;\n\n    return min < 0 && max < 0 ? max :\n      min > 0 && max > 0 ? min :\n      0;\n  }\n\n  /**\n\t * @protected\n\t */\n  getContext(index) {\n    const ticks = this.ticks || [];\n\n    if (index >= 0 && index < ticks.length) {\n      const tick = ticks[index];\n      return tick.$context ||\n\t\t\t\t(tick.$context = createTickContext(this.getContext(), index, tick));\n    }\n    return this.$context ||\n\t\t\t(this.$context = createScaleContext(this.chart.getContext(), this));\n  }\n\n  /**\n\t * @return {number}\n\t * @private\n\t */\n  _tickSize() {\n    const optionTicks = this.options.ticks;\n\n    // Calculate space needed by label in axis direction.\n    const rot = toRadians(this.labelRotation);\n    const cos = Math.abs(Math.cos(rot));\n    const sin = Math.abs(Math.sin(rot));\n\n    const labelSizes = this._getLabelSizes();\n    const padding = optionTicks.autoSkipPadding || 0;\n    const w = labelSizes ? labelSizes.widest.width + padding : 0;\n    const h = labelSizes ? labelSizes.highest.height + padding : 0;\n\n    // Calculate space needed for 1 tick in axis direction.\n    return this.isHorizontal()\n      ? h * cos > w * sin ? w / cos : h / sin\n      : h * sin < w * cos ? h / cos : w / sin;\n  }\n\n  /**\n\t * @return {boolean}\n\t * @private\n\t */\n  _isVisible() {\n    const display = this.options.display;\n\n    if (display !== 'auto') {\n      return !!display;\n    }\n\n    return this.getMatchingVisibleMetas().length > 0;\n  }\n\n  /**\n\t * @private\n\t */\n  _computeGridLineItems(chartArea) {\n    const axis = this.axis;\n    const chart = this.chart;\n    const options = this.options;\n    const {grid, position, border} = options;\n    const offset = grid.offset;\n    const isHorizontal = this.isHorizontal();\n    const ticks = this.ticks;\n    const ticksLength = ticks.length + (offset ? 1 : 0);\n    const tl = getTickMarkLength(grid);\n    const items = [];\n\n    const borderOpts = border.setContext(this.getContext());\n    const axisWidth = borderOpts.display ? borderOpts.width : 0;\n    const axisHalfWidth = axisWidth / 2;\n    const alignBorderValue = function(pixel) {\n      return _alignPixel(chart, pixel, axisWidth);\n    };\n    let borderValue, i, lineValue, alignedLineValue;\n    let tx1, ty1, tx2, ty2, x1, y1, x2, y2;\n\n    if (position === 'top') {\n      borderValue = alignBorderValue(this.bottom);\n      ty1 = this.bottom - tl;\n      ty2 = borderValue - axisHalfWidth;\n      y1 = alignBorderValue(chartArea.top) + axisHalfWidth;\n      y2 = chartArea.bottom;\n    } else if (position === 'bottom') {\n      borderValue = alignBorderValue(this.top);\n      y1 = chartArea.top;\n      y2 = alignBorderValue(chartArea.bottom) - axisHalfWidth;\n      ty1 = borderValue + axisHalfWidth;\n      ty2 = this.top + tl;\n    } else if (position === 'left') {\n      borderValue = alignBorderValue(this.right);\n      tx1 = this.right - tl;\n      tx2 = borderValue - axisHalfWidth;\n      x1 = alignBorderValue(chartArea.left) + axisHalfWidth;\n      x2 = chartArea.right;\n    } else if (position === 'right') {\n      borderValue = alignBorderValue(this.left);\n      x1 = chartArea.left;\n      x2 = alignBorderValue(chartArea.right) - axisHalfWidth;\n      tx1 = borderValue + axisHalfWidth;\n      tx2 = this.left + tl;\n    } else if (axis === 'x') {\n      if (position === 'center') {\n        borderValue = alignBorderValue((chartArea.top + chartArea.bottom) / 2 + 0.5);\n      } else if (isObject(position)) {\n        const positionAxisID = Object.keys(position)[0];\n        const value = position[positionAxisID];\n        borderValue = alignBorderValue(this.chart.scales[positionAxisID].getPixelForValue(value));\n      }\n\n      y1 = chartArea.top;\n      y2 = chartArea.bottom;\n      ty1 = borderValue + axisHalfWidth;\n      ty2 = ty1 + tl;\n    } else if (axis === 'y') {\n      if (position === 'center') {\n        borderValue = alignBorderValue((chartArea.left + chartArea.right) / 2);\n      } else if (isObject(position)) {\n        const positionAxisID = Object.keys(position)[0];\n        const value = position[positionAxisID];\n        borderValue = alignBorderValue(this.chart.scales[positionAxisID].getPixelForValue(value));\n      }\n\n      tx1 = borderValue - axisHalfWidth;\n      tx2 = tx1 - tl;\n      x1 = chartArea.left;\n      x2 = chartArea.right;\n    }\n\n    const limit = valueOrDefault(options.ticks.maxTicksLimit, ticksLength);\n    const step = Math.max(1, Math.ceil(ticksLength / limit));\n    for (i = 0; i < ticksLength; i += step) {\n      const context = this.getContext(i);\n      const optsAtIndex = grid.setContext(context);\n      const optsAtIndexBorder = border.setContext(context);\n\n      const lineWidth = optsAtIndex.lineWidth;\n      const lineColor = optsAtIndex.color;\n      const borderDash = optsAtIndexBorder.dash || [];\n      const borderDashOffset = optsAtIndexBorder.dashOffset;\n\n      const tickWidth = optsAtIndex.tickWidth;\n      const tickColor = optsAtIndex.tickColor;\n      const tickBorderDash = optsAtIndex.tickBorderDash || [];\n      const tickBorderDashOffset = optsAtIndex.tickBorderDashOffset;\n\n      lineValue = getPixelForGridLine(this, i, offset);\n\n      // Skip if the pixel is out of the range\n      if (lineValue === undefined) {\n        continue;\n      }\n\n      alignedLineValue = _alignPixel(chart, lineValue, lineWidth);\n\n      if (isHorizontal) {\n        tx1 = tx2 = x1 = x2 = alignedLineValue;\n      } else {\n        ty1 = ty2 = y1 = y2 = alignedLineValue;\n      }\n\n      items.push({\n        tx1,\n        ty1,\n        tx2,\n        ty2,\n        x1,\n        y1,\n        x2,\n        y2,\n        width: lineWidth,\n        color: lineColor,\n        borderDash,\n        borderDashOffset,\n        tickWidth,\n        tickColor,\n        tickBorderDash,\n        tickBorderDashOffset,\n      });\n    }\n\n    this._ticksLength = ticksLength;\n    this._borderValue = borderValue;\n\n    return items;\n  }\n\n  /**\n\t * @private\n\t */\n  _computeLabelItems(chartArea) {\n    const axis = this.axis;\n    const options = this.options;\n    const {position, ticks: optionTicks} = options;\n    const isHorizontal = this.isHorizontal();\n    const ticks = this.ticks;\n    const {align, crossAlign, padding, mirror} = optionTicks;\n    const tl = getTickMarkLength(options.grid);\n    const tickAndPadding = tl + padding;\n    const hTickAndPadding = mirror ? -padding : tickAndPadding;\n    const rotation = -toRadians(this.labelRotation);\n    const items = [];\n    let i, ilen, tick, label, x, y, textAlign, pixel, font, lineHeight, lineCount, textOffset;\n    let textBaseline = 'middle';\n\n    if (position === 'top') {\n      y = this.bottom - hTickAndPadding;\n      textAlign = this._getXAxisLabelAlignment();\n    } else if (position === 'bottom') {\n      y = this.top + hTickAndPadding;\n      textAlign = this._getXAxisLabelAlignment();\n    } else if (position === 'left') {\n      const ret = this._getYAxisLabelAlignment(tl);\n      textAlign = ret.textAlign;\n      x = ret.x;\n    } else if (position === 'right') {\n      const ret = this._getYAxisLabelAlignment(tl);\n      textAlign = ret.textAlign;\n      x = ret.x;\n    } else if (axis === 'x') {\n      if (position === 'center') {\n        y = ((chartArea.top + chartArea.bottom) / 2) + tickAndPadding;\n      } else if (isObject(position)) {\n        const positionAxisID = Object.keys(position)[0];\n        const value = position[positionAxisID];\n        y = this.chart.scales[positionAxisID].getPixelForValue(value) + tickAndPadding;\n      }\n      textAlign = this._getXAxisLabelAlignment();\n    } else if (axis === 'y') {\n      if (position === 'center') {\n        x = ((chartArea.left + chartArea.right) / 2) - tickAndPadding;\n      } else if (isObject(position)) {\n        const positionAxisID = Object.keys(position)[0];\n        const value = position[positionAxisID];\n        x = this.chart.scales[positionAxisID].getPixelForValue(value);\n      }\n      textAlign = this._getYAxisLabelAlignment(tl).textAlign;\n    }\n\n    if (axis === 'y') {\n      if (align === 'start') {\n        textBaseline = 'top';\n      } else if (align === 'end') {\n        textBaseline = 'bottom';\n      }\n    }\n\n    const labelSizes = this._getLabelSizes();\n    for (i = 0, ilen = ticks.length; i < ilen; ++i) {\n      tick = ticks[i];\n      label = tick.label;\n\n      const optsAtIndex = optionTicks.setContext(this.getContext(i));\n      pixel = this.getPixelForTick(i) + optionTicks.labelOffset;\n      font = this._resolveTickFontOptions(i);\n      lineHeight = font.lineHeight;\n      lineCount = isArray(label) ? label.length : 1;\n      const halfCount = lineCount / 2;\n      const color = optsAtIndex.color;\n      const strokeColor = optsAtIndex.textStrokeColor;\n      const strokeWidth = optsAtIndex.textStrokeWidth;\n      let tickTextAlign = textAlign;\n\n      if (isHorizontal) {\n        x = pixel;\n\n        if (textAlign === 'inner') {\n          if (i === ilen - 1) {\n            tickTextAlign = !this.options.reverse ? 'right' : 'left';\n          } else if (i === 0) {\n            tickTextAlign = !this.options.reverse ? 'left' : 'right';\n          } else {\n            tickTextAlign = 'center';\n          }\n        }\n\n        if (position === 'top') {\n          if (crossAlign === 'near' || rotation !== 0) {\n            textOffset = -lineCount * lineHeight + lineHeight / 2;\n          } else if (crossAlign === 'center') {\n            textOffset = -labelSizes.highest.height / 2 - halfCount * lineHeight + lineHeight;\n          } else {\n            textOffset = -labelSizes.highest.height + lineHeight / 2;\n          }\n        } else {\n          // eslint-disable-next-line no-lonely-if\n          if (crossAlign === 'near' || rotation !== 0) {\n            textOffset = lineHeight / 2;\n          } else if (crossAlign === 'center') {\n            textOffset = labelSizes.highest.height / 2 - halfCount * lineHeight;\n          } else {\n            textOffset = labelSizes.highest.height - lineCount * lineHeight;\n          }\n        }\n        if (mirror) {\n          textOffset *= -1;\n        }\n        if (rotation !== 0 && !optsAtIndex.showLabelBackdrop) {\n          x += (lineHeight / 2) * Math.sin(rotation);\n        }\n      } else {\n        y = pixel;\n        textOffset = (1 - lineCount) * lineHeight / 2;\n      }\n\n      let backdrop;\n\n      if (optsAtIndex.showLabelBackdrop) {\n        const labelPadding = toPadding(optsAtIndex.backdropPadding);\n        const height = labelSizes.heights[i];\n        const width = labelSizes.widths[i];\n\n        let top = textOffset - labelPadding.top;\n        let left = 0 - labelPadding.left;\n\n        switch (textBaseline) {\n        case 'middle':\n          top -= height / 2;\n          break;\n        case 'bottom':\n          top -= height;\n          break;\n        default:\n          break;\n        }\n\n        switch (textAlign) {\n        case 'center':\n          left -= width / 2;\n          break;\n        case 'right':\n          left -= width;\n          break;\n        default:\n          break;\n        }\n\n        backdrop = {\n          left,\n          top,\n          width: width + labelPadding.width,\n          height: height + labelPadding.height,\n\n          color: optsAtIndex.backdropColor,\n        };\n      }\n\n      items.push({\n        label,\n        font,\n        textOffset,\n        options: {\n          rotation,\n          color,\n          strokeColor,\n          strokeWidth,\n          textAlign: tickTextAlign,\n          textBaseline,\n          translation: [x, y],\n          backdrop,\n        }\n      });\n    }\n\n    return items;\n  }\n\n  _getXAxisLabelAlignment() {\n    const {position, ticks} = this.options;\n    const rotation = -toRadians(this.labelRotation);\n\n    if (rotation) {\n      return position === 'top' ? 'left' : 'right';\n    }\n\n    let align = 'center';\n\n    if (ticks.align === 'start') {\n      align = 'left';\n    } else if (ticks.align === 'end') {\n      align = 'right';\n    } else if (ticks.align === 'inner') {\n      align = 'inner';\n    }\n\n    return align;\n  }\n\n  _getYAxisLabelAlignment(tl) {\n    const {position, ticks: {crossAlign, mirror, padding}} = this.options;\n    const labelSizes = this._getLabelSizes();\n    const tickAndPadding = tl + padding;\n    const widest = labelSizes.widest.width;\n\n    let textAlign;\n    let x;\n\n    if (position === 'left') {\n      if (mirror) {\n        x = this.right + padding;\n\n        if (crossAlign === 'near') {\n          textAlign = 'left';\n        } else if (crossAlign === 'center') {\n          textAlign = 'center';\n          x += (widest / 2);\n        } else {\n          textAlign = 'right';\n          x += widest;\n        }\n      } else {\n        x = this.right - tickAndPadding;\n\n        if (crossAlign === 'near') {\n          textAlign = 'right';\n        } else if (crossAlign === 'center') {\n          textAlign = 'center';\n          x -= (widest / 2);\n        } else {\n          textAlign = 'left';\n          x = this.left;\n        }\n      }\n    } else if (position === 'right') {\n      if (mirror) {\n        x = this.left + padding;\n\n        if (crossAlign === 'near') {\n          textAlign = 'right';\n        } else if (crossAlign === 'center') {\n          textAlign = 'center';\n          x -= (widest / 2);\n        } else {\n          textAlign = 'left';\n          x -= widest;\n        }\n      } else {\n        x = this.left + tickAndPadding;\n\n        if (crossAlign === 'near') {\n          textAlign = 'left';\n        } else if (crossAlign === 'center') {\n          textAlign = 'center';\n          x += widest / 2;\n        } else {\n          textAlign = 'right';\n          x = this.right;\n        }\n      }\n    } else {\n      textAlign = 'right';\n    }\n\n    return {textAlign, x};\n  }\n\n  /**\n\t * @private\n\t */\n  _computeLabelArea() {\n    if (this.options.ticks.mirror) {\n      return;\n    }\n\n    const chart = this.chart;\n    const position = this.options.position;\n\n    if (position === 'left' || position === 'right') {\n      return {top: 0, left: this.left, bottom: chart.height, right: this.right};\n    } if (position === 'top' || position === 'bottom') {\n      return {top: this.top, left: 0, bottom: this.bottom, right: chart.width};\n    }\n  }\n\n  /**\n   * @protected\n   */\n  drawBackground() {\n    const {ctx, options: {backgroundColor}, left, top, width, height} = this;\n    if (backgroundColor) {\n      ctx.save();\n      ctx.fillStyle = backgroundColor;\n      ctx.fillRect(left, top, width, height);\n      ctx.restore();\n    }\n  }\n\n  getLineWidthForValue(value) {\n    const grid = this.options.grid;\n    if (!this._isVisible() || !grid.display) {\n      return 0;\n    }\n    const ticks = this.ticks;\n    const index = ticks.findIndex(t => t.value === value);\n    if (index >= 0) {\n      const opts = grid.setContext(this.getContext(index));\n      return opts.lineWidth;\n    }\n    return 0;\n  }\n\n  /**\n\t * @protected\n\t */\n  drawGrid(chartArea) {\n    const grid = this.options.grid;\n    const ctx = this.ctx;\n    const items = this._gridLineItems || (this._gridLineItems = this._computeGridLineItems(chartArea));\n    let i, ilen;\n\n    const drawLine = (p1, p2, style) => {\n      if (!style.width || !style.color) {\n        return;\n      }\n      ctx.save();\n      ctx.lineWidth = style.width;\n      ctx.strokeStyle = style.color;\n      ctx.setLineDash(style.borderDash || []);\n      ctx.lineDashOffset = style.borderDashOffset;\n\n      ctx.beginPath();\n      ctx.moveTo(p1.x, p1.y);\n      ctx.lineTo(p2.x, p2.y);\n      ctx.stroke();\n      ctx.restore();\n    };\n\n    if (grid.display) {\n      for (i = 0, ilen = items.length; i < ilen; ++i) {\n        const item = items[i];\n\n        if (grid.drawOnChartArea) {\n          drawLine(\n            {x: item.x1, y: item.y1},\n            {x: item.x2, y: item.y2},\n            item\n          );\n        }\n\n        if (grid.drawTicks) {\n          drawLine(\n            {x: item.tx1, y: item.ty1},\n            {x: item.tx2, y: item.ty2},\n            {\n              color: item.tickColor,\n              width: item.tickWidth,\n              borderDash: item.tickBorderDash,\n              borderDashOffset: item.tickBorderDashOffset\n            }\n          );\n        }\n      }\n    }\n  }\n\n  /**\n\t * @protected\n\t */\n  drawBorder() {\n    const {chart, ctx, options: {border, grid}} = this;\n    const borderOpts = border.setContext(this.getContext());\n    const axisWidth = border.display ? borderOpts.width : 0;\n    if (!axisWidth) {\n      return;\n    }\n    const lastLineWidth = grid.setContext(this.getContext(0)).lineWidth;\n    const borderValue = this._borderValue;\n    let x1, x2, y1, y2;\n\n    if (this.isHorizontal()) {\n      x1 = _alignPixel(chart, this.left, axisWidth) - axisWidth / 2;\n      x2 = _alignPixel(chart, this.right, lastLineWidth) + lastLineWidth / 2;\n      y1 = y2 = borderValue;\n    } else {\n      y1 = _alignPixel(chart, this.top, axisWidth) - axisWidth / 2;\n      y2 = _alignPixel(chart, this.bottom, lastLineWidth) + lastLineWidth / 2;\n      x1 = x2 = borderValue;\n    }\n    ctx.save();\n    ctx.lineWidth = borderOpts.width;\n    ctx.strokeStyle = borderOpts.color;\n\n    ctx.beginPath();\n    ctx.moveTo(x1, y1);\n    ctx.lineTo(x2, y2);\n    ctx.stroke();\n\n    ctx.restore();\n  }\n\n  /**\n\t * @protected\n\t */\n  drawLabels(chartArea) {\n    const optionTicks = this.options.ticks;\n\n    if (!optionTicks.display) {\n      return;\n    }\n\n    const ctx = this.ctx;\n\n    const area = this._computeLabelArea();\n    if (area) {\n      clipArea(ctx, area);\n    }\n\n    const items = this.getLabelItems(chartArea);\n    for (const item of items) {\n      const renderTextOptions = item.options;\n      const tickFont = item.font;\n      const label = item.label;\n      const y = item.textOffset;\n      renderText(ctx, label, 0, y, tickFont, renderTextOptions);\n    }\n\n    if (area) {\n      unclipArea(ctx);\n    }\n  }\n\n  /**\n\t * @protected\n\t */\n  drawTitle() {\n    const {ctx, options: {position, title, reverse}} = this;\n\n    if (!title.display) {\n      return;\n    }\n\n    const font = toFont(title.font);\n    const padding = toPadding(title.padding);\n    const align = title.align;\n    let offset = font.lineHeight / 2;\n\n    if (position === 'bottom' || position === 'center' || isObject(position)) {\n      offset += padding.bottom;\n      if (isArray(title.text)) {\n        offset += font.lineHeight * (title.text.length - 1);\n      }\n    } else {\n      offset += padding.top;\n    }\n\n    const {titleX, titleY, maxWidth, rotation} = titleArgs(this, offset, position, align);\n\n    renderText(ctx, title.text, 0, 0, font, {\n      color: title.color,\n      maxWidth,\n      rotation,\n      textAlign: titleAlign(align, position, reverse),\n      textBaseline: 'middle',\n      translation: [titleX, titleY],\n    });\n  }\n\n  draw(chartArea) {\n    if (!this._isVisible()) {\n      return;\n    }\n\n    this.drawBackground();\n    this.drawGrid(chartArea);\n    this.drawBorder();\n    this.drawTitle();\n    this.drawLabels(chartArea);\n  }\n\n  /**\n\t * @return {object[]}\n\t * @private\n\t */\n  _layers() {\n    const opts = this.options;\n    const tz = opts.ticks && opts.ticks.z || 0;\n    const gz = valueOrDefault(opts.grid && opts.grid.z, -1);\n    const bz = valueOrDefault(opts.border && opts.border.z, 0);\n\n    if (!this._isVisible() || this.draw !== Scale.prototype.draw) {\n      // backward compatibility: draw has been overridden by custom scale\n      return [{\n        z: tz,\n        draw: (chartArea) => {\n          this.draw(chartArea);\n        }\n      }];\n    }\n\n    return [{\n      z: gz,\n      draw: (chartArea) => {\n        this.drawBackground();\n        this.drawGrid(chartArea);\n        this.drawTitle();\n      }\n    }, {\n      z: bz,\n      draw: () => {\n        this.drawBorder();\n      }\n    }, {\n      z: tz,\n      draw: (chartArea) => {\n        this.drawLabels(chartArea);\n      }\n    }];\n  }\n\n  /**\n\t * Returns visible dataset metas that are attached to this scale\n\t * @param {string} [type] - if specified, also filter by dataset type\n\t * @return {object[]}\n\t */\n  getMatchingVisibleMetas(type) {\n    const metas = this.chart.getSortedVisibleDatasetMetas();\n    const axisID = this.axis + 'AxisID';\n    const result = [];\n    let i, ilen;\n\n    for (i = 0, ilen = metas.length; i < ilen; ++i) {\n      const meta = metas[i];\n      if (meta[axisID] === this.id && (!type || meta.type === type)) {\n        result.push(meta);\n      }\n    }\n    return result;\n  }\n\n  /**\n\t * @param {number} index\n\t * @return {object}\n\t * @protected\n \t */\n  _resolveTickFontOptions(index) {\n    const opts = this.options.ticks.setContext(this.getContext(index));\n    return toFont(opts.font);\n  }\n\n  /**\n   * @protected\n   */\n  _maxDigits() {\n    const fontSize = this._resolveTickFontOptions(0).lineHeight;\n    return (this.isHorizontal() ? this.width : this.height) / fontSize;\n  }\n}\n","import {merge} from '../helpers/index.js';\nimport defaults, {overrides} from './core.defaults.js';\n\n/**\n * @typedef {{id: string, defaults: any, overrides?: any, defaultRoutes: any}} IChartComponent\n */\n\nexport default class TypedRegistry {\n  constructor(type, scope, override) {\n    this.type = type;\n    this.scope = scope;\n    this.override = override;\n    this.items = Object.create(null);\n  }\n\n  isForType(type) {\n    return Object.prototype.isPrototypeOf.call(this.type.prototype, type.prototype);\n  }\n\n  /**\n\t * @param {IChartComponent} item\n\t * @returns {string} The scope where items defaults were registered to.\n\t */\n  register(item) {\n    const proto = Object.getPrototypeOf(item);\n    let parentScope;\n\n    if (isIChartComponent(proto)) {\n      // Make sure the parent is registered and note the scope where its defaults are.\n      parentScope = this.register(proto);\n    }\n\n    const items = this.items;\n    const id = item.id;\n    const scope = this.scope + '.' + id;\n\n    if (!id) {\n      throw new Error('class does not have id: ' + item);\n    }\n\n    if (id in items) {\n      // already registered\n      return scope;\n    }\n\n    items[id] = item;\n    registerDefaults(item, scope, parentScope);\n    if (this.override) {\n      defaults.override(item.id, item.overrides);\n    }\n\n    return scope;\n  }\n\n  /**\n\t * @param {string} id\n\t * @returns {object?}\n\t */\n  get(id) {\n    return this.items[id];\n  }\n\n  /**\n\t * @param {IChartComponent} item\n\t */\n  unregister(item) {\n    const items = this.items;\n    const id = item.id;\n    const scope = this.scope;\n\n    if (id in items) {\n      delete items[id];\n    }\n\n    if (scope && id in defaults[scope]) {\n      delete defaults[scope][id];\n      if (this.override) {\n        delete overrides[id];\n      }\n    }\n  }\n}\n\nfunction registerDefaults(item, scope, parentScope) {\n  // Inherit the parent's defaults and keep existing defaults\n  const itemDefaults = merge(Object.create(null), [\n    parentScope ? defaults.get(parentScope) : {},\n    defaults.get(scope),\n    item.defaults\n  ]);\n\n  defaults.set(scope, itemDefaults);\n\n  if (item.defaultRoutes) {\n    routeDefaults(scope, item.defaultRoutes);\n  }\n\n  if (item.descriptors) {\n    defaults.describe(scope, item.descriptors);\n  }\n}\n\nfunction routeDefaults(scope, routes) {\n  Object.keys(routes).forEach(property => {\n    const propertyParts = property.split('.');\n    const sourceName = propertyParts.pop();\n    const sourceScope = [scope].concat(propertyParts).join('.');\n    const parts = routes[property].split('.');\n    const targetName = parts.pop();\n    const targetScope = parts.join('.');\n    defaults.route(sourceScope, sourceName, targetScope, targetName);\n  });\n}\n\nfunction isIChartComponent(proto) {\n  return 'id' in proto && 'defaults' in proto;\n}\n","import DatasetController from './core.datasetController.js';\nimport Element from './core.element.js';\nimport Scale from './core.scale.js';\nimport TypedRegistry from './core.typedRegistry.js';\nimport {each, callback as call, _capitalize} from '../helpers/helpers.core.js';\n\n/**\n * Please use the module's default export which provides a singleton instance\n * Note: class is exported for typedoc\n */\nexport class Registry {\n  constructor() {\n    this.controllers = new TypedRegistry(DatasetController, 'datasets', true);\n    this.elements = new TypedRegistry(Element, 'elements');\n    this.plugins = new TypedRegistry(Object, 'plugins');\n    this.scales = new TypedRegistry(Scale, 'scales');\n    // Order is important, Scale has Element in prototype chain,\n    // so Scales must be before Elements. Plugins are a fallback, so not listed here.\n    this._typedRegistries = [this.controllers, this.scales, this.elements];\n  }\n\n  /**\n\t * @param  {...any} args\n\t */\n  add(...args) {\n    this._each('register', args);\n  }\n\n  remove(...args) {\n    this._each('unregister', args);\n  }\n\n  /**\n\t * @param  {...typeof DatasetController} args\n\t */\n  addControllers(...args) {\n    this._each('register', args, this.controllers);\n  }\n\n  /**\n\t * @param  {...typeof Element} args\n\t */\n  addElements(...args) {\n    this._each('register', args, this.elements);\n  }\n\n  /**\n\t * @param  {...any} args\n\t */\n  addPlugins(...args) {\n    this._each('register', args, this.plugins);\n  }\n\n  /**\n\t * @param  {...typeof Scale} args\n\t */\n  addScales(...args) {\n    this._each('register', args, this.scales);\n  }\n\n  /**\n\t * @param {string} id\n\t * @returns {typeof DatasetController}\n\t */\n  getController(id) {\n    return this._get(id, this.controllers, 'controller');\n  }\n\n  /**\n\t * @param {string} id\n\t * @returns {typeof Element}\n\t */\n  getElement(id) {\n    return this._get(id, this.elements, 'element');\n  }\n\n  /**\n\t * @param {string} id\n\t * @returns {object}\n\t */\n  getPlugin(id) {\n    return this._get(id, this.plugins, 'plugin');\n  }\n\n  /**\n\t * @param {string} id\n\t * @returns {typeof Scale}\n\t */\n  getScale(id) {\n    return this._get(id, this.scales, 'scale');\n  }\n\n  /**\n\t * @param  {...typeof DatasetController} args\n\t */\n  removeControllers(...args) {\n    this._each('unregister', args, this.controllers);\n  }\n\n  /**\n\t * @param  {...typeof Element} args\n\t */\n  removeElements(...args) {\n    this._each('unregister', args, this.elements);\n  }\n\n  /**\n\t * @param  {...any} args\n\t */\n  removePlugins(...args) {\n    this._each('unregister', args, this.plugins);\n  }\n\n  /**\n\t * @param  {...typeof Scale} args\n\t */\n  removeScales(...args) {\n    this._each('unregister', args, this.scales);\n  }\n\n  /**\n\t * @private\n\t */\n  _each(method, args, typedRegistry) {\n    [...args].forEach(arg => {\n      const reg = typedRegistry || this._getRegistryForType(arg);\n      if (typedRegistry || reg.isForType(arg) || (reg === this.plugins && arg.id)) {\n        this._exec(method, reg, arg);\n      } else {\n        // Handle loopable args\n        // Use case:\n        //  import * as plugins from './plugins.js';\n        //  Chart.register(plugins);\n        each(arg, item => {\n          // If there are mixed types in the loopable, make sure those are\n          // registered in correct registry\n          // Use case: (treemap exporting controller, elements etc)\n          //  import * as treemap from 'chartjs-chart-treemap.js';\n          //  Chart.register(treemap);\n\n          const itemReg = typedRegistry || this._getRegistryForType(item);\n          this._exec(method, itemReg, item);\n        });\n      }\n    });\n  }\n\n  /**\n\t * @private\n\t */\n  _exec(method, registry, component) {\n    const camelMethod = _capitalize(method);\n    call(component['before' + camelMethod], [], component); // beforeRegister / beforeUnregister\n    registry[method](component);\n    call(component['after' + camelMethod], [], component); // afterRegister / afterUnregister\n  }\n\n  /**\n\t * @private\n\t */\n  _getRegistryForType(type) {\n    for (let i = 0; i < this._typedRegistries.length; i++) {\n      const reg = this._typedRegistries[i];\n      if (reg.isForType(type)) {\n        return reg;\n      }\n    }\n    // plugins is the fallback registry\n    return this.plugins;\n  }\n\n  /**\n\t * @private\n\t */\n  _get(id, typedRegistry, type) {\n    const item = typedRegistry.get(id);\n    if (item === undefined) {\n      throw new Error('\"' + id + '\" is not a registered ' + type + '.');\n    }\n    return item;\n  }\n\n}\n\n// singleton instance\nexport default /* #__PURE__ */ new Registry();\n","import registry from './core.registry.js';\nimport {callback as callCallback, isNullOrUndef, valueOrDefault} from '../helpers/helpers.core.js';\n\n/**\n * @typedef { import('./core.controller.js').default } Chart\n * @typedef { import('../types/index.js').ChartEvent } ChartEvent\n * @typedef { import('../plugins/plugin.tooltip.js').default } Tooltip\n */\n\n/**\n * @callback filterCallback\n * @param {{plugin: object, options: object}} value\n * @param {number} [index]\n * @param {array} [array]\n * @param {object} [thisArg]\n * @return {boolean}\n */\n\n\nexport default class PluginService {\n  constructor() {\n    this._init = [];\n  }\n\n  /**\n\t * Calls enabled plugins for `chart` on the specified hook and with the given args.\n\t * This method immediately returns as soon as a plugin explicitly returns false. The\n\t * returned value can be used, for instance, to interrupt the current action.\n\t * @param {Chart} chart - The chart instance for which plugins should be called.\n\t * @param {string} hook - The name of the plugin method to call (e.g. 'beforeUpdate').\n\t * @param {object} [args] - Extra arguments to apply to the hook call.\n   * @param {filterCallback} [filter] - Filtering function for limiting which plugins are notified\n\t * @returns {boolean} false if any of the plugins return false, else returns true.\n\t */\n  notify(chart, hook, args, filter) {\n    if (hook === 'beforeInit') {\n      this._init = this._createDescriptors(chart, true);\n      this._notify(this._init, chart, 'install');\n    }\n\n    const descriptors = filter ? this._descriptors(chart).filter(filter) : this._descriptors(chart);\n    const result = this._notify(descriptors, chart, hook, args);\n\n    if (hook === 'afterDestroy') {\n      this._notify(descriptors, chart, 'stop');\n      this._notify(this._init, chart, 'uninstall');\n    }\n    return result;\n  }\n\n  /**\n\t * @private\n\t */\n  _notify(descriptors, chart, hook, args) {\n    args = args || {};\n    for (const descriptor of descriptors) {\n      const plugin = descriptor.plugin;\n      const method = plugin[hook];\n      const params = [chart, args, descriptor.options];\n      if (callCallback(method, params, plugin) === false && args.cancelable) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  invalidate() {\n    // When plugins are registered, there is the possibility of a double\n    // invalidate situation. In this case, we only want to invalidate once.\n    // If we invalidate multiple times, the `_oldCache` is lost and all of the\n    // plugins are restarted without being correctly stopped.\n    // See https://github.com/chartjs/Chart.js/issues/8147\n    if (!isNullOrUndef(this._cache)) {\n      this._oldCache = this._cache;\n      this._cache = undefined;\n    }\n  }\n\n  /**\n\t * @param {Chart} chart\n\t * @private\n\t */\n  _descriptors(chart) {\n    if (this._cache) {\n      return this._cache;\n    }\n\n    const descriptors = this._cache = this._createDescriptors(chart);\n\n    this._notifyStateChanges(chart);\n\n    return descriptors;\n  }\n\n  _createDescriptors(chart, all) {\n    const config = chart && chart.config;\n    const options = valueOrDefault(config.options && config.options.plugins, {});\n    const plugins = allPlugins(config);\n    // options === false => all plugins are disabled\n    return options === false && !all ? [] : createDescriptors(chart, plugins, options, all);\n  }\n\n  /**\n\t * @param {Chart} chart\n\t * @private\n\t */\n  _notifyStateChanges(chart) {\n    const previousDescriptors = this._oldCache || [];\n    const descriptors = this._cache;\n    const diff = (a, b) => a.filter(x => !b.some(y => x.plugin.id === y.plugin.id));\n    this._notify(diff(previousDescriptors, descriptors), chart, 'stop');\n    this._notify(diff(descriptors, previousDescriptors), chart, 'start');\n  }\n}\n\n/**\n * @param {import('./core.config.js').default} config\n */\nfunction allPlugins(config) {\n  const localIds = {};\n  const plugins = [];\n  const keys = Object.keys(registry.plugins.items);\n  for (let i = 0; i < keys.length; i++) {\n    plugins.push(registry.getPlugin(keys[i]));\n  }\n\n  const local = config.plugins || [];\n  for (let i = 0; i < local.length; i++) {\n    const plugin = local[i];\n\n    if (plugins.indexOf(plugin) === -1) {\n      plugins.push(plugin);\n      localIds[plugin.id] = true;\n    }\n  }\n\n  return {plugins, localIds};\n}\n\nfunction getOpts(options, all) {\n  if (!all && options === false) {\n    return null;\n  }\n  if (options === true) {\n    return {};\n  }\n  return options;\n}\n\nfunction createDescriptors(chart, {plugins, localIds}, options, all) {\n  const result = [];\n  const context = chart.getContext();\n\n  for (const plugin of plugins) {\n    const id = plugin.id;\n    const opts = getOpts(options[id], all);\n    if (opts === null) {\n      continue;\n    }\n    result.push({\n      plugin,\n      options: pluginOpts(chart.config, {plugin, local: localIds[id]}, opts, context)\n    });\n  }\n\n  return result;\n}\n\nfunction pluginOpts(config, {plugin, local}, opts, context) {\n  const keys = config.pluginScopeKeys(plugin);\n  const scopes = config.getOptionScopes(opts, keys);\n  if (local && plugin.defaults) {\n    // make sure plugin defaults are in scopes for local (not registered) plugins\n    scopes.push(plugin.defaults);\n  }\n  return config.createResolver(scopes, context, [''], {\n    // These are just defaults that plugins can override\n    scriptable: false,\n    indexable: false,\n    allKeys: true\n  });\n}\n","import defaults, {overrides, descriptors} from './core.defaults.js';\nimport {mergeIf, resolveObjectKey, isArray, isFunction, valueOrDefault, isObject} from '../helpers/helpers.core.js';\nimport {_attachContext, _createResolver, _descriptors} from '../helpers/helpers.config.js';\n\nexport function getIndexAxis(type, options) {\n  const datasetDefaults = defaults.datasets[type] || {};\n  const datasetOptions = (options.datasets || {})[type] || {};\n  return datasetOptions.indexAxis || options.indexAxis || datasetDefaults.indexAxis || 'x';\n}\n\nfunction getAxisFromDefaultScaleID(id, indexAxis) {\n  let axis = id;\n  if (id === '_index_') {\n    axis = indexAxis;\n  } else if (id === '_value_') {\n    axis = indexAxis === 'x' ? 'y' : 'x';\n  }\n  return axis;\n}\n\nfunction getDefaultScaleIDFromAxis(axis, indexAxis) {\n  return axis === indexAxis ? '_index_' : '_value_';\n}\n\nfunction idMatchesAxis(id) {\n  if (id === 'x' || id === 'y' || id === 'r') {\n    return id;\n  }\n}\n\nfunction axisFromPosition(position) {\n  if (position === 'top' || position === 'bottom') {\n    return 'x';\n  }\n  if (position === 'left' || position === 'right') {\n    return 'y';\n  }\n}\n\nexport function determineAxis(id, ...scaleOptions) {\n  if (idMatchesAxis(id)) {\n    return id;\n  }\n  for (const opts of scaleOptions) {\n    const axis = opts.axis\n      || axisFromPosition(opts.position)\n      || id.length > 1 && idMatchesAxis(id[0].toLowerCase());\n    if (axis) {\n      return axis;\n    }\n  }\n  throw new Error(`Cannot determine type of '${id}' axis. Please provide 'axis' or 'position' option.`);\n}\n\nfunction getAxisFromDataset(id, axis, dataset) {\n  if (dataset[axis + 'AxisID'] === id) {\n    return {axis};\n  }\n}\n\nfunction retrieveAxisFromDatasets(id, config) {\n  if (config.data && config.data.datasets) {\n    const boundDs = config.data.datasets.filter((d) => d.xAxisID === id || d.yAxisID === id);\n    if (boundDs.length) {\n      return getAxisFromDataset(id, 'x', boundDs[0]) || getAxisFromDataset(id, 'y', boundDs[0]);\n    }\n  }\n  return {};\n}\n\nfunction mergeScaleConfig(config, options) {\n  const chartDefaults = overrides[config.type] || {scales: {}};\n  const configScales = options.scales || {};\n  const chartIndexAxis = getIndexAxis(config.type, options);\n  const scales = Object.create(null);\n\n  // First figure out first scale id's per axis.\n  Object.keys(configScales).forEach(id => {\n    const scaleConf = configScales[id];\n    if (!isObject(scaleConf)) {\n      return console.error(`Invalid scale configuration for scale: ${id}`);\n    }\n    if (scaleConf._proxy) {\n      return console.warn(`Ignoring resolver passed as options for scale: ${id}`);\n    }\n    const axis = determineAxis(id, scaleConf, retrieveAxisFromDatasets(id, config), defaults.scales[scaleConf.type]);\n    const defaultId = getDefaultScaleIDFromAxis(axis, chartIndexAxis);\n    const defaultScaleOptions = chartDefaults.scales || {};\n    scales[id] = mergeIf(Object.create(null), [{axis}, scaleConf, defaultScaleOptions[axis], defaultScaleOptions[defaultId]]);\n  });\n\n  // Then merge dataset defaults to scale configs\n  config.data.datasets.forEach(dataset => {\n    const type = dataset.type || config.type;\n    const indexAxis = dataset.indexAxis || getIndexAxis(type, options);\n    const datasetDefaults = overrides[type] || {};\n    const defaultScaleOptions = datasetDefaults.scales || {};\n    Object.keys(defaultScaleOptions).forEach(defaultID => {\n      const axis = getAxisFromDefaultScaleID(defaultID, indexAxis);\n      const id = dataset[axis + 'AxisID'] || axis;\n      scales[id] = scales[id] || Object.create(null);\n      mergeIf(scales[id], [{axis}, configScales[id], defaultScaleOptions[defaultID]]);\n    });\n  });\n\n  // apply scale defaults, if not overridden by dataset defaults\n  Object.keys(scales).forEach(key => {\n    const scale = scales[key];\n    mergeIf(scale, [defaults.scales[scale.type], defaults.scale]);\n  });\n\n  return scales;\n}\n\nfunction initOptions(config) {\n  const options = config.options || (config.options = {});\n\n  options.plugins = valueOrDefault(options.plugins, {});\n  options.scales = mergeScaleConfig(config, options);\n}\n\nfunction initData(data) {\n  data = data || {};\n  data.datasets = data.datasets || [];\n  data.labels = data.labels || [];\n  return data;\n}\n\nfunction initConfig(config) {\n  config = config || {};\n  config.data = initData(config.data);\n\n  initOptions(config);\n\n  return config;\n}\n\nconst keyCache = new Map();\nconst keysCached = new Set();\n\nfunction cachedKeys(cacheKey, generate) {\n  let keys = keyCache.get(cacheKey);\n  if (!keys) {\n    keys = generate();\n    keyCache.set(cacheKey, keys);\n    keysCached.add(keys);\n  }\n  return keys;\n}\n\nconst addIfFound = (set, obj, key) => {\n  const opts = resolveObjectKey(obj, key);\n  if (opts !== undefined) {\n    set.add(opts);\n  }\n};\n\nexport default class Config {\n  constructor(config) {\n    this._config = initConfig(config);\n    this._scopeCache = new Map();\n    this._resolverCache = new Map();\n  }\n\n  get platform() {\n    return this._config.platform;\n  }\n\n  get type() {\n    return this._config.type;\n  }\n\n  set type(type) {\n    this._config.type = type;\n  }\n\n  get data() {\n    return this._config.data;\n  }\n\n  set data(data) {\n    this._config.data = initData(data);\n  }\n\n  get options() {\n    return this._config.options;\n  }\n\n  set options(options) {\n    this._config.options = options;\n  }\n\n  get plugins() {\n    return this._config.plugins;\n  }\n\n  update() {\n    const config = this._config;\n    this.clearCache();\n    initOptions(config);\n  }\n\n  clearCache() {\n    this._scopeCache.clear();\n    this._resolverCache.clear();\n  }\n\n  /**\n   * Returns the option scope keys for resolving dataset options.\n   * These keys do not include the dataset itself, because it is not under options.\n   * @param {string} datasetType\n   * @return {string[][]}\n   */\n  datasetScopeKeys(datasetType) {\n    return cachedKeys(datasetType,\n      () => [[\n        `datasets.${datasetType}`,\n        ''\n      ]]);\n  }\n\n  /**\n   * Returns the option scope keys for resolving dataset animation options.\n   * These keys do not include the dataset itself, because it is not under options.\n   * @param {string} datasetType\n   * @param {string} transition\n   * @return {string[][]}\n   */\n  datasetAnimationScopeKeys(datasetType, transition) {\n    return cachedKeys(`${datasetType}.transition.${transition}`,\n      () => [\n        [\n          `datasets.${datasetType}.transitions.${transition}`,\n          `transitions.${transition}`,\n        ],\n        // The following are used for looking up the `animations` and `animation` keys\n        [\n          `datasets.${datasetType}`,\n          ''\n        ]\n      ]);\n  }\n\n  /**\n   * Returns the options scope keys for resolving element options that belong\n   * to an dataset. These keys do not include the dataset itself, because it\n   * is not under options.\n   * @param {string} datasetType\n   * @param {string} elementType\n   * @return {string[][]}\n   */\n  datasetElementScopeKeys(datasetType, elementType) {\n    return cachedKeys(`${datasetType}-${elementType}`,\n      () => [[\n        `datasets.${datasetType}.elements.${elementType}`,\n        `datasets.${datasetType}`,\n        `elements.${elementType}`,\n        ''\n      ]]);\n  }\n\n  /**\n   * Returns the options scope keys for resolving plugin options.\n   * @param {{id: string, additionalOptionScopes?: string[]}} plugin\n   * @return {string[][]}\n   */\n  pluginScopeKeys(plugin) {\n    const id = plugin.id;\n    const type = this.type;\n    return cachedKeys(`${type}-plugin-${id}`,\n      () => [[\n        `plugins.${id}`,\n        ...plugin.additionalOptionScopes || [],\n      ]]);\n  }\n\n  /**\n   * @private\n   */\n  _cachedScopes(mainScope, resetCache) {\n    const _scopeCache = this._scopeCache;\n    let cache = _scopeCache.get(mainScope);\n    if (!cache || resetCache) {\n      cache = new Map();\n      _scopeCache.set(mainScope, cache);\n    }\n    return cache;\n  }\n\n  /**\n   * Resolves the objects from options and defaults for option value resolution.\n   * @param {object} mainScope - The main scope object for options\n   * @param {string[][]} keyLists - The arrays of keys in resolution order\n   * @param {boolean} [resetCache] - reset the cache for this mainScope\n   */\n  getOptionScopes(mainScope, keyLists, resetCache) {\n    const {options, type} = this;\n    const cache = this._cachedScopes(mainScope, resetCache);\n    const cached = cache.get(keyLists);\n    if (cached) {\n      return cached;\n    }\n\n    const scopes = new Set();\n\n    keyLists.forEach(keys => {\n      if (mainScope) {\n        scopes.add(mainScope);\n        keys.forEach(key => addIfFound(scopes, mainScope, key));\n      }\n      keys.forEach(key => addIfFound(scopes, options, key));\n      keys.forEach(key => addIfFound(scopes, overrides[type] || {}, key));\n      keys.forEach(key => addIfFound(scopes, defaults, key));\n      keys.forEach(key => addIfFound(scopes, descriptors, key));\n    });\n\n    const array = Array.from(scopes);\n    if (array.length === 0) {\n      array.push(Object.create(null));\n    }\n    if (keysCached.has(keyLists)) {\n      cache.set(keyLists, array);\n    }\n    return array;\n  }\n\n  /**\n   * Returns the option scopes for resolving chart options\n   * @return {object[]}\n   */\n  chartOptionScopes() {\n    const {options, type} = this;\n\n    return [\n      options,\n      overrides[type] || {},\n      defaults.datasets[type] || {}, // https://github.com/chartjs/Chart.js/issues/8531\n      {type},\n      defaults,\n      descriptors\n    ];\n  }\n\n  /**\n   * @param {object[]} scopes\n   * @param {string[]} names\n   * @param {function|object} context\n   * @param {string[]} [prefixes]\n   * @return {object}\n   */\n  resolveNamedOptions(scopes, names, context, prefixes = ['']) {\n    const result = {$shared: true};\n    const {resolver, subPrefixes} = getResolver(this._resolverCache, scopes, prefixes);\n    let options = resolver;\n    if (needContext(resolver, names)) {\n      result.$shared = false;\n      context = isFunction(context) ? context() : context;\n      // subResolver is passed to scriptable options. It should not resolve to hover options.\n      const subResolver = this.createResolver(scopes, context, subPrefixes);\n      options = _attachContext(resolver, context, subResolver);\n    }\n\n    for (const prop of names) {\n      result[prop] = options[prop];\n    }\n    return result;\n  }\n\n  /**\n   * @param {object[]} scopes\n   * @param {object} [context]\n   * @param {string[]} [prefixes]\n   * @param {{scriptable: boolean, indexable: boolean, allKeys?: boolean}} [descriptorDefaults]\n   */\n  createResolver(scopes, context, prefixes = [''], descriptorDefaults) {\n    const {resolver} = getResolver(this._resolverCache, scopes, prefixes);\n    return isObject(context)\n      ? _attachContext(resolver, context, undefined, descriptorDefaults)\n      : resolver;\n  }\n}\n\nfunction getResolver(resolverCache, scopes, prefixes) {\n  let cache = resolverCache.get(scopes);\n  if (!cache) {\n    cache = new Map();\n    resolverCache.set(scopes, cache);\n  }\n  const cacheKey = prefixes.join();\n  let cached = cache.get(cacheKey);\n  if (!cached) {\n    const resolver = _createResolver(scopes, prefixes);\n    cached = {\n      resolver,\n      subPrefixes: prefixes.filter(p => !p.toLowerCase().includes('hover'))\n    };\n    cache.set(cacheKey, cached);\n  }\n  return cached;\n}\n\nconst hasFunction = value => isObject(value)\n  && Object.getOwnPropertyNames(value).reduce((acc, key) => acc || isFunction(value[key]), false);\n\nfunction needContext(proxy, names) {\n  const {isScriptable, isIndexable} = _descriptors(proxy);\n\n  for (const prop of names) {\n    const scriptable = isScriptable(prop);\n    const indexable = isIndexable(prop);\n    const value = (indexable || scriptable) && proxy[prop];\n    if ((scriptable && (isFunction(value) || hasFunction(value)))\n      || (indexable && isArray(value))) {\n      return true;\n    }\n  }\n  return false;\n}\n","import animator from './core.animator.js';\nimport defaults, {overrides} from './core.defaults.js';\nimport Interaction from './core.interaction.js';\nimport layouts from './core.layouts.js';\nimport {_detectPlatform} from '../platform/index.js';\nimport PluginService from './core.plugins.js';\nimport registry from './core.registry.js';\nimport Config, {determineAxis, getIndexAxis} from './core.config.js';\nimport {retinaScale, _isDomSupported} from '../helpers/helpers.dom.js';\nimport {each, callback as callCallback, uid, valueOrDefault, _elementsEqual, isNullOrUndef, setsEqual, defined, isFunction, _isClickEvent} from '../helpers/helpers.core.js';\nimport {clearCanvas, clipArea, createContext, unclipArea, _isPointInArea} from '../helpers/index.js';\n// @ts-ignore\nimport {version} from '../../package.json';\nimport {debounce} from '../helpers/helpers.extras.js';\n\n/**\n * @typedef { import('../types/index.js').ChartEvent } ChartEvent\n * @typedef { import('../types/index.js').Point } Point\n */\n\nconst KNOWN_POSITIONS = ['top', 'bottom', 'left', 'right', 'chartArea'];\nfunction positionIsHorizontal(position, axis) {\n  return position === 'top' || position === 'bottom' || (KNOWN_POSITIONS.indexOf(position) === -1 && axis === 'x');\n}\n\nfunction compare2Level(l1, l2) {\n  return function(a, b) {\n    return a[l1] === b[l1]\n      ? a[l2] - b[l2]\n      : a[l1] - b[l1];\n  };\n}\n\nfunction onAnimationsComplete(context) {\n  const chart = context.chart;\n  const animationOptions = chart.options.animation;\n\n  chart.notifyPlugins('afterRender');\n  callCallback(animationOptions && animationOptions.onComplete, [context], chart);\n}\n\nfunction onAnimationProgress(context) {\n  const chart = context.chart;\n  const animationOptions = chart.options.animation;\n  callCallback(animationOptions && animationOptions.onProgress, [context], chart);\n}\n\n/**\n * Chart.js can take a string id of a canvas element, a 2d context, or a canvas element itself.\n * Attempt to unwrap the item passed into the chart constructor so that it is a canvas element (if possible).\n */\nfunction getCanvas(item) {\n  if (_isDomSupported() && typeof item === 'string') {\n    item = document.getElementById(item);\n  } else if (item && item.length) {\n    // Support for array based queries (such as jQuery)\n    item = item[0];\n  }\n\n  if (item && item.canvas) {\n    // Support for any object associated to a canvas (including a context2d)\n    item = item.canvas;\n  }\n  return item;\n}\n\nconst instances = {};\nconst getChart = (key) => {\n  const canvas = getCanvas(key);\n  return Object.values(instances).filter((c) => c.canvas === canvas).pop();\n};\n\nfunction moveNumericKeys(obj, start, move) {\n  const keys = Object.keys(obj);\n  for (const key of keys) {\n    const intKey = +key;\n    if (intKey >= start) {\n      const value = obj[key];\n      delete obj[key];\n      if (move > 0 || intKey > start) {\n        obj[intKey + move] = value;\n      }\n    }\n  }\n}\n\n/**\n * @param {ChartEvent} e\n * @param {ChartEvent|null} lastEvent\n * @param {boolean} inChartArea\n * @param {boolean} isClick\n * @returns {ChartEvent|null}\n */\nfunction determineLastEvent(e, lastEvent, inChartArea, isClick) {\n  if (!inChartArea || e.type === 'mouseout') {\n    return null;\n  }\n  if (isClick) {\n    return lastEvent;\n  }\n  return e;\n}\n\nfunction getSizeForArea(scale, chartArea, field) {\n  return scale.options.clip ? scale[field] : chartArea[field];\n}\n\nfunction getDatasetArea(meta, chartArea) {\n  const {xScale, yScale} = meta;\n  if (xScale && yScale) {\n    return {\n      left: getSizeForArea(xScale, chartArea, 'left'),\n      right: getSizeForArea(xScale, chartArea, 'right'),\n      top: getSizeForArea(yScale, chartArea, 'top'),\n      bottom: getSizeForArea(yScale, chartArea, 'bottom')\n    };\n  }\n  return chartArea;\n}\n\nclass Chart {\n\n  static defaults = defaults;\n  static instances = instances;\n  static overrides = overrides;\n  static registry = registry;\n  static version = version;\n  static getChart = getChart;\n\n  static register(...items) {\n    registry.add(...items);\n    invalidatePlugins();\n  }\n\n  static unregister(...items) {\n    registry.remove(...items);\n    invalidatePlugins();\n  }\n\n  // eslint-disable-next-line max-statements\n  constructor(item, userConfig) {\n    const config = this.config = new Config(userConfig);\n    const initialCanvas = getCanvas(item);\n    const existingChart = getChart(initialCanvas);\n    if (existingChart) {\n      throw new Error(\n        'Canvas is already in use. Chart with ID \\'' + existingChart.id + '\\'' +\n\t\t\t\t' must be destroyed before the canvas with ID \\'' + existingChart.canvas.id + '\\' can be reused.'\n      );\n    }\n\n    const options = config.createResolver(config.chartOptionScopes(), this.getContext());\n\n    this.platform = new (config.platform || _detectPlatform(initialCanvas))();\n    this.platform.updateConfig(config);\n\n    const context = this.platform.acquireContext(initialCanvas, options.aspectRatio);\n    const canvas = context && context.canvas;\n    const height = canvas && canvas.height;\n    const width = canvas && canvas.width;\n\n    this.id = uid();\n    this.ctx = context;\n    this.canvas = canvas;\n    this.width = width;\n    this.height = height;\n    this._options = options;\n    // Store the previously used aspect ratio to determine if a resize\n    // is needed during updates. Do this after _options is set since\n    // aspectRatio uses a getter\n    this._aspectRatio = this.aspectRatio;\n    this._layers = [];\n    this._metasets = [];\n    this._stacks = undefined;\n    this.boxes = [];\n    this.currentDevicePixelRatio = undefined;\n    this.chartArea = undefined;\n    this._active = [];\n    this._lastEvent = undefined;\n    this._listeners = {};\n    /** @type {?{attach?: function, detach?: function, resize?: function}} */\n    this._responsiveListeners = undefined;\n    this._sortedMetasets = [];\n    this.scales = {};\n    this._plugins = new PluginService();\n    this.$proxies = {};\n    this._hiddenIndices = {};\n    this.attached = false;\n    this._animationsDisabled = undefined;\n    this.$context = undefined;\n    this._doResize = debounce(mode => this.update(mode), options.resizeDelay || 0);\n    this._dataChanges = [];\n\n    // Add the chart instance to the global namespace\n    instances[this.id] = this;\n\n    if (!context || !canvas) {\n      // The given item is not a compatible context2d element, let's return before finalizing\n      // the chart initialization but after setting basic chart / controller properties that\n      // can help to figure out that the chart is not valid (e.g chart.canvas !== null);\n      // https://github.com/chartjs/Chart.js/issues/2807\n      console.error(\"Failed to create chart: can't acquire context from the given item\");\n      return;\n    }\n\n    animator.listen(this, 'complete', onAnimationsComplete);\n    animator.listen(this, 'progress', onAnimationProgress);\n\n    this._initialize();\n    if (this.attached) {\n      this.update();\n    }\n  }\n\n  get aspectRatio() {\n    const {options: {aspectRatio, maintainAspectRatio}, width, height, _aspectRatio} = this;\n    if (!isNullOrUndef(aspectRatio)) {\n      // If aspectRatio is defined in options, use that.\n      return aspectRatio;\n    }\n\n    if (maintainAspectRatio && _aspectRatio) {\n      // If maintainAspectRatio is truthly and we had previously determined _aspectRatio, use that\n      return _aspectRatio;\n    }\n\n    // Calculate\n    return height ? width / height : null;\n  }\n\n  get data() {\n    return this.config.data;\n  }\n\n  set data(data) {\n    this.config.data = data;\n  }\n\n  get options() {\n    return this._options;\n  }\n\n  set options(options) {\n    this.config.options = options;\n  }\n\n  get registry() {\n    return registry;\n  }\n\n  /**\n\t * @private\n\t */\n  _initialize() {\n    // Before init plugin notification\n    this.notifyPlugins('beforeInit');\n\n    if (this.options.responsive) {\n      this.resize();\n    } else {\n      retinaScale(this, this.options.devicePixelRatio);\n    }\n\n    this.bindEvents();\n\n    // After init plugin notification\n    this.notifyPlugins('afterInit');\n\n    return this;\n  }\n\n  clear() {\n    clearCanvas(this.canvas, this.ctx);\n    return this;\n  }\n\n  stop() {\n    animator.stop(this);\n    return this;\n  }\n\n  /**\n\t * Resize the chart to its container or to explicit dimensions.\n\t * @param {number} [width]\n\t * @param {number} [height]\n\t */\n  resize(width, height) {\n    if (!animator.running(this)) {\n      this._resize(width, height);\n    } else {\n      this._resizeBeforeDraw = {width, height};\n    }\n  }\n\n  _resize(width, height) {\n    const options = this.options;\n    const canvas = this.canvas;\n    const aspectRatio = options.maintainAspectRatio && this.aspectRatio;\n    const newSize = this.platform.getMaximumSize(canvas, width, height, aspectRatio);\n    const newRatio = options.devicePixelRatio || this.platform.getDevicePixelRatio();\n    const mode = this.width ? 'resize' : 'attach';\n\n    this.width = newSize.width;\n    this.height = newSize.height;\n    this._aspectRatio = this.aspectRatio;\n    if (!retinaScale(this, newRatio, true)) {\n      return;\n    }\n\n    this.notifyPlugins('resize', {size: newSize});\n\n    callCallback(options.onResize, [this, newSize], this);\n\n    if (this.attached) {\n      if (this._doResize(mode)) {\n        // The resize update is delayed, only draw without updating.\n        this.render();\n      }\n    }\n  }\n\n  ensureScalesHaveIDs() {\n    const options = this.options;\n    const scalesOptions = options.scales || {};\n\n    each(scalesOptions, (axisOptions, axisID) => {\n      axisOptions.id = axisID;\n    });\n  }\n\n  /**\n\t * Builds a map of scale ID to scale object for future lookup.\n\t */\n  buildOrUpdateScales() {\n    const options = this.options;\n    const scaleOpts = options.scales;\n    const scales = this.scales;\n    const updated = Object.keys(scales).reduce((obj, id) => {\n      obj[id] = false;\n      return obj;\n    }, {});\n    let items = [];\n\n    if (scaleOpts) {\n      items = items.concat(\n        Object.keys(scaleOpts).map((id) => {\n          const scaleOptions = scaleOpts[id];\n          const axis = determineAxis(id, scaleOptions);\n          const isRadial = axis === 'r';\n          const isHorizontal = axis === 'x';\n          return {\n            options: scaleOptions,\n            dposition: isRadial ? 'chartArea' : isHorizontal ? 'bottom' : 'left',\n            dtype: isRadial ? 'radialLinear' : isHorizontal ? 'category' : 'linear'\n          };\n        })\n      );\n    }\n\n    each(items, (item) => {\n      const scaleOptions = item.options;\n      const id = scaleOptions.id;\n      const axis = determineAxis(id, scaleOptions);\n      const scaleType = valueOrDefault(scaleOptions.type, item.dtype);\n\n      if (scaleOptions.position === undefined || positionIsHorizontal(scaleOptions.position, axis) !== positionIsHorizontal(item.dposition)) {\n        scaleOptions.position = item.dposition;\n      }\n\n      updated[id] = true;\n      let scale = null;\n      if (id in scales && scales[id].type === scaleType) {\n        scale = scales[id];\n      } else {\n        const scaleClass = registry.getScale(scaleType);\n        scale = new scaleClass({\n          id,\n          type: scaleType,\n          ctx: this.ctx,\n          chart: this\n        });\n        scales[scale.id] = scale;\n      }\n\n      scale.init(scaleOptions, options);\n    });\n    // clear up discarded scales\n    each(updated, (hasUpdated, id) => {\n      if (!hasUpdated) {\n        delete scales[id];\n      }\n    });\n\n    each(scales, (scale) => {\n      layouts.configure(this, scale, scale.options);\n      layouts.addBox(this, scale);\n    });\n  }\n\n  /**\n\t * @private\n\t */\n  _updateMetasets() {\n    const metasets = this._metasets;\n    const numData = this.data.datasets.length;\n    const numMeta = metasets.length;\n\n    metasets.sort((a, b) => a.index - b.index);\n    if (numMeta > numData) {\n      for (let i = numData; i < numMeta; ++i) {\n        this._destroyDatasetMeta(i);\n      }\n      metasets.splice(numData, numMeta - numData);\n    }\n    this._sortedMetasets = metasets.slice(0).sort(compare2Level('order', 'index'));\n  }\n\n  /**\n\t * @private\n\t */\n  _removeUnreferencedMetasets() {\n    const {_metasets: metasets, data: {datasets}} = this;\n    if (metasets.length > datasets.length) {\n      delete this._stacks;\n    }\n    metasets.forEach((meta, index) => {\n      if (datasets.filter(x => x === meta._dataset).length === 0) {\n        this._destroyDatasetMeta(index);\n      }\n    });\n  }\n\n  buildOrUpdateControllers() {\n    const newControllers = [];\n    const datasets = this.data.datasets;\n    let i, ilen;\n\n    this._removeUnreferencedMetasets();\n\n    for (i = 0, ilen = datasets.length; i < ilen; i++) {\n      const dataset = datasets[i];\n      let meta = this.getDatasetMeta(i);\n      const type = dataset.type || this.config.type;\n\n      if (meta.type && meta.type !== type) {\n        this._destroyDatasetMeta(i);\n        meta = this.getDatasetMeta(i);\n      }\n      meta.type = type;\n      meta.indexAxis = dataset.indexAxis || getIndexAxis(type, this.options);\n      meta.order = dataset.order || 0;\n      meta.index = i;\n      meta.label = '' + dataset.label;\n      meta.visible = this.isDatasetVisible(i);\n\n      if (meta.controller) {\n        meta.controller.updateIndex(i);\n        meta.controller.linkScales();\n      } else {\n        const ControllerClass = registry.getController(type);\n        const {datasetElementType, dataElementType} = defaults.datasets[type];\n        Object.assign(ControllerClass, {\n          dataElementType: registry.getElement(dataElementType),\n          datasetElementType: datasetElementType && registry.getElement(datasetElementType)\n        });\n        meta.controller = new ControllerClass(this, i);\n        newControllers.push(meta.controller);\n      }\n    }\n\n    this._updateMetasets();\n    return newControllers;\n  }\n\n  /**\n\t * Reset the elements of all datasets\n\t * @private\n\t */\n  _resetElements() {\n    each(this.data.datasets, (dataset, datasetIndex) => {\n      this.getDatasetMeta(datasetIndex).controller.reset();\n    }, this);\n  }\n\n  /**\n\t* Resets the chart back to its state before the initial animation\n\t*/\n  reset() {\n    this._resetElements();\n    this.notifyPlugins('reset');\n  }\n\n  update(mode) {\n    const config = this.config;\n\n    config.update();\n    const options = this._options = config.createResolver(config.chartOptionScopes(), this.getContext());\n    const animsDisabled = this._animationsDisabled = !options.animation;\n\n    this._updateScales();\n    this._checkEventBindings();\n    this._updateHiddenIndices();\n\n    // plugins options references might have change, let's invalidate the cache\n    // https://github.com/chartjs/Chart.js/issues/5111#issuecomment-355934167\n    this._plugins.invalidate();\n\n    if (this.notifyPlugins('beforeUpdate', {mode, cancelable: true}) === false) {\n      return;\n    }\n\n    // Make sure dataset controllers are updated and new controllers are reset\n    const newControllers = this.buildOrUpdateControllers();\n\n    this.notifyPlugins('beforeElementsUpdate');\n\n    // Make sure all dataset controllers have correct meta data counts\n    let minPadding = 0;\n    for (let i = 0, ilen = this.data.datasets.length; i < ilen; i++) {\n      const {controller} = this.getDatasetMeta(i);\n      const reset = !animsDisabled && newControllers.indexOf(controller) === -1;\n      // New controllers will be reset after the layout pass, so we only want to modify\n      // elements added to new datasets\n      controller.buildOrUpdateElements(reset);\n      minPadding = Math.max(+controller.getMaxOverflow(), minPadding);\n    }\n    minPadding = this._minPadding = options.layout.autoPadding ? minPadding : 0;\n    this._updateLayout(minPadding);\n\n    // Only reset the controllers if we have animations\n    if (!animsDisabled) {\n      // Can only reset the new controllers after the scales have been updated\n      // Reset is done to get the starting point for the initial animation\n      each(newControllers, (controller) => {\n        controller.reset();\n      });\n    }\n\n    this._updateDatasets(mode);\n\n    // Do this before render so that any plugins that need final scale updates can use it\n    this.notifyPlugins('afterUpdate', {mode});\n\n    this._layers.sort(compare2Level('z', '_idx'));\n\n    // Replay last event from before update, or set hover styles on active elements\n    const {_active, _lastEvent} = this;\n    if (_lastEvent) {\n      this._eventHandler(_lastEvent, true);\n    } else if (_active.length) {\n      this._updateHoverStyles(_active, _active, true);\n    }\n\n    this.render();\n  }\n\n  /**\n   * @private\n   */\n  _updateScales() {\n    each(this.scales, (scale) => {\n      layouts.removeBox(this, scale);\n    });\n\n    this.ensureScalesHaveIDs();\n    this.buildOrUpdateScales();\n  }\n\n  /**\n   * @private\n   */\n  _checkEventBindings() {\n    const options = this.options;\n    const existingEvents = new Set(Object.keys(this._listeners));\n    const newEvents = new Set(options.events);\n\n    if (!setsEqual(existingEvents, newEvents) || !!this._responsiveListeners !== options.responsive) {\n      // The configured events have changed. Rebind.\n      this.unbindEvents();\n      this.bindEvents();\n    }\n  }\n\n  /**\n   * @private\n   */\n  _updateHiddenIndices() {\n    const {_hiddenIndices} = this;\n    const changes = this._getUniformDataChanges() || [];\n    for (const {method, start, count} of changes) {\n      const move = method === '_removeElements' ? -count : count;\n      moveNumericKeys(_hiddenIndices, start, move);\n    }\n  }\n\n  /**\n   * @private\n   */\n  _getUniformDataChanges() {\n    const _dataChanges = this._dataChanges;\n    if (!_dataChanges || !_dataChanges.length) {\n      return;\n    }\n\n    this._dataChanges = [];\n    const datasetCount = this.data.datasets.length;\n    const makeSet = (idx) => new Set(\n      _dataChanges\n        .filter(c => c[0] === idx)\n        .map((c, i) => i + ',' + c.splice(1).join(','))\n    );\n\n    const changeSet = makeSet(0);\n    for (let i = 1; i < datasetCount; i++) {\n      if (!setsEqual(changeSet, makeSet(i))) {\n        return;\n      }\n    }\n    return Array.from(changeSet)\n      .map(c => c.split(','))\n      .map(a => ({method: a[1], start: +a[2], count: +a[3]}));\n  }\n\n  /**\n\t * Updates the chart layout unless a plugin returns `false` to the `beforeLayout`\n\t * hook, in which case, plugins will not be called on `afterLayout`.\n\t * @private\n\t */\n  _updateLayout(minPadding) {\n    if (this.notifyPlugins('beforeLayout', {cancelable: true}) === false) {\n      return;\n    }\n\n    layouts.update(this, this.width, this.height, minPadding);\n\n    const area = this.chartArea;\n    const noArea = area.width <= 0 || area.height <= 0;\n\n    this._layers = [];\n    each(this.boxes, (box) => {\n      if (noArea && box.position === 'chartArea') {\n        // Skip drawing and configuring chartArea boxes when chartArea is zero or negative\n        return;\n      }\n\n      // configure is called twice, once in core.scale.update and once here.\n      // Here the boxes are fully updated and at their final positions.\n      if (box.configure) {\n        box.configure();\n      }\n      this._layers.push(...box._layers());\n    }, this);\n\n    this._layers.forEach((item, index) => {\n      item._idx = index;\n    });\n\n    this.notifyPlugins('afterLayout');\n  }\n\n  /**\n\t * Updates all datasets unless a plugin returns `false` to the `beforeDatasetsUpdate`\n\t * hook, in which case, plugins will not be called on `afterDatasetsUpdate`.\n\t * @private\n\t */\n  _updateDatasets(mode) {\n    if (this.notifyPlugins('beforeDatasetsUpdate', {mode, cancelable: true}) === false) {\n      return;\n    }\n\n    for (let i = 0, ilen = this.data.datasets.length; i < ilen; ++i) {\n      this.getDatasetMeta(i).controller.configure();\n    }\n\n    for (let i = 0, ilen = this.data.datasets.length; i < ilen; ++i) {\n      this._updateDataset(i, isFunction(mode) ? mode({datasetIndex: i}) : mode);\n    }\n\n    this.notifyPlugins('afterDatasetsUpdate', {mode});\n  }\n\n  /**\n\t * Updates dataset at index unless a plugin returns `false` to the `beforeDatasetUpdate`\n\t * hook, in which case, plugins will not be called on `afterDatasetUpdate`.\n\t * @private\n\t */\n  _updateDataset(index, mode) {\n    const meta = this.getDatasetMeta(index);\n    const args = {meta, index, mode, cancelable: true};\n\n    if (this.notifyPlugins('beforeDatasetUpdate', args) === false) {\n      return;\n    }\n\n    meta.controller._update(mode);\n\n    args.cancelable = false;\n    this.notifyPlugins('afterDatasetUpdate', args);\n  }\n\n  render() {\n    if (this.notifyPlugins('beforeRender', {cancelable: true}) === false) {\n      return;\n    }\n\n    if (animator.has(this)) {\n      if (this.attached && !animator.running(this)) {\n        animator.start(this);\n      }\n    } else {\n      this.draw();\n      onAnimationsComplete({chart: this});\n    }\n  }\n\n  draw() {\n    let i;\n    if (this._resizeBeforeDraw) {\n      const {width, height} = this._resizeBeforeDraw;\n      this._resize(width, height);\n      this._resizeBeforeDraw = null;\n    }\n    this.clear();\n\n    if (this.width <= 0 || this.height <= 0) {\n      return;\n    }\n\n    if (this.notifyPlugins('beforeDraw', {cancelable: true}) === false) {\n      return;\n    }\n\n    // Because of plugin hooks (before/afterDatasetsDraw), datasets can't\n    // currently be part of layers. Instead, we draw\n    // layers <= 0 before(default, backward compat), and the rest after\n    const layers = this._layers;\n    for (i = 0; i < layers.length && layers[i].z <= 0; ++i) {\n      layers[i].draw(this.chartArea);\n    }\n\n    this._drawDatasets();\n\n    // Rest of layers\n    for (; i < layers.length; ++i) {\n      layers[i].draw(this.chartArea);\n    }\n\n    this.notifyPlugins('afterDraw');\n  }\n\n  /**\n\t * @private\n\t */\n  _getSortedDatasetMetas(filterVisible) {\n    const metasets = this._sortedMetasets;\n    const result = [];\n    let i, ilen;\n\n    for (i = 0, ilen = metasets.length; i < ilen; ++i) {\n      const meta = metasets[i];\n      if (!filterVisible || meta.visible) {\n        result.push(meta);\n      }\n    }\n\n    return result;\n  }\n\n  /**\n\t * Gets the visible dataset metas in drawing order\n\t * @return {object[]}\n\t */\n  getSortedVisibleDatasetMetas() {\n    return this._getSortedDatasetMetas(true);\n  }\n\n  /**\n\t * Draws all datasets unless a plugin returns `false` to the `beforeDatasetsDraw`\n\t * hook, in which case, plugins will not be called on `afterDatasetsDraw`.\n\t * @private\n\t */\n  _drawDatasets() {\n    if (this.notifyPlugins('beforeDatasetsDraw', {cancelable: true}) === false) {\n      return;\n    }\n\n    const metasets = this.getSortedVisibleDatasetMetas();\n    for (let i = metasets.length - 1; i >= 0; --i) {\n      this._drawDataset(metasets[i]);\n    }\n\n    this.notifyPlugins('afterDatasetsDraw');\n  }\n\n  /**\n\t * Draws dataset at index unless a plugin returns `false` to the `beforeDatasetDraw`\n\t * hook, in which case, plugins will not be called on `afterDatasetDraw`.\n\t * @private\n\t */\n  _drawDataset(meta) {\n    const ctx = this.ctx;\n    const clip = meta._clip;\n    const useClip = !clip.disabled;\n    const area = getDatasetArea(meta, this.chartArea);\n    const args = {\n      meta,\n      index: meta.index,\n      cancelable: true\n    };\n\n    if (this.notifyPlugins('beforeDatasetDraw', args) === false) {\n      return;\n    }\n\n    if (useClip) {\n      clipArea(ctx, {\n        left: clip.left === false ? 0 : area.left - clip.left,\n        right: clip.right === false ? this.width : area.right + clip.right,\n        top: clip.top === false ? 0 : area.top - clip.top,\n        bottom: clip.bottom === false ? this.height : area.bottom + clip.bottom\n      });\n    }\n\n    meta.controller.draw();\n\n    if (useClip) {\n      unclipArea(ctx);\n    }\n\n    args.cancelable = false;\n    this.notifyPlugins('afterDatasetDraw', args);\n  }\n\n  /**\n   * Checks whether the given point is in the chart area.\n   * @param {Point} point - in relative coordinates (see, e.g., getRelativePosition)\n   * @returns {boolean}\n   */\n  isPointInArea(point) {\n    return _isPointInArea(point, this.chartArea, this._minPadding);\n  }\n\n  getElementsAtEventForMode(e, mode, options, useFinalPosition) {\n    const method = Interaction.modes[mode];\n    if (typeof method === 'function') {\n      return method(this, e, options, useFinalPosition);\n    }\n\n    return [];\n  }\n\n  getDatasetMeta(datasetIndex) {\n    const dataset = this.data.datasets[datasetIndex];\n    const metasets = this._metasets;\n    let meta = metasets.filter(x => x && x._dataset === dataset).pop();\n\n    if (!meta) {\n      meta = {\n        type: null,\n        data: [],\n        dataset: null,\n        controller: null,\n        hidden: null,\t\t\t// See isDatasetVisible() comment\n        xAxisID: null,\n        yAxisID: null,\n        order: dataset && dataset.order || 0,\n        index: datasetIndex,\n        _dataset: dataset,\n        _parsed: [],\n        _sorted: false\n      };\n      metasets.push(meta);\n    }\n\n    return meta;\n  }\n\n  getContext() {\n    return this.$context || (this.$context = createContext(null, {chart: this, type: 'chart'}));\n  }\n\n  getVisibleDatasetCount() {\n    return this.getSortedVisibleDatasetMetas().length;\n  }\n\n  isDatasetVisible(datasetIndex) {\n    const dataset = this.data.datasets[datasetIndex];\n    if (!dataset) {\n      return false;\n    }\n\n    const meta = this.getDatasetMeta(datasetIndex);\n\n    // meta.hidden is a per chart dataset hidden flag override with 3 states: if true or false,\n    // the dataset.hidden value is ignored, else if null, the dataset hidden state is returned.\n    return typeof meta.hidden === 'boolean' ? !meta.hidden : !dataset.hidden;\n  }\n\n  setDatasetVisibility(datasetIndex, visible) {\n    const meta = this.getDatasetMeta(datasetIndex);\n    meta.hidden = !visible;\n  }\n\n  toggleDataVisibility(index) {\n    this._hiddenIndices[index] = !this._hiddenIndices[index];\n  }\n\n  getDataVisibility(index) {\n    return !this._hiddenIndices[index];\n  }\n\n  /**\n\t * @private\n\t */\n  _updateVisibility(datasetIndex, dataIndex, visible) {\n    const mode = visible ? 'show' : 'hide';\n    const meta = this.getDatasetMeta(datasetIndex);\n    const anims = meta.controller._resolveAnimations(undefined, mode);\n\n    if (defined(dataIndex)) {\n      meta.data[dataIndex].hidden = !visible;\n      this.update();\n    } else {\n      this.setDatasetVisibility(datasetIndex, visible);\n      // Animate visible state, so hide animation can be seen. This could be handled better if update / updateDataset returned a Promise.\n      anims.update(meta, {visible});\n      this.update((ctx) => ctx.datasetIndex === datasetIndex ? mode : undefined);\n    }\n  }\n\n  hide(datasetIndex, dataIndex) {\n    this._updateVisibility(datasetIndex, dataIndex, false);\n  }\n\n  show(datasetIndex, dataIndex) {\n    this._updateVisibility(datasetIndex, dataIndex, true);\n  }\n\n  /**\n\t * @private\n\t */\n  _destroyDatasetMeta(datasetIndex) {\n    const meta = this._metasets[datasetIndex];\n    if (meta && meta.controller) {\n      meta.controller._destroy();\n    }\n    delete this._metasets[datasetIndex];\n  }\n\n  _stop() {\n    let i, ilen;\n    this.stop();\n    animator.remove(this);\n\n    for (i = 0, ilen = this.data.datasets.length; i < ilen; ++i) {\n      this._destroyDatasetMeta(i);\n    }\n  }\n\n  destroy() {\n    this.notifyPlugins('beforeDestroy');\n    const {canvas, ctx} = this;\n\n    this._stop();\n    this.config.clearCache();\n\n    if (canvas) {\n      this.unbindEvents();\n      clearCanvas(canvas, ctx);\n      this.platform.releaseContext(ctx);\n      this.canvas = null;\n      this.ctx = null;\n    }\n\n    delete instances[this.id];\n\n    this.notifyPlugins('afterDestroy');\n  }\n\n  toBase64Image(...args) {\n    return this.canvas.toDataURL(...args);\n  }\n\n  /**\n\t * @private\n\t */\n  bindEvents() {\n    this.bindUserEvents();\n    if (this.options.responsive) {\n      this.bindResponsiveEvents();\n    } else {\n      this.attached = true;\n    }\n  }\n\n  /**\n   * @private\n   */\n  bindUserEvents() {\n    const listeners = this._listeners;\n    const platform = this.platform;\n\n    const _add = (type, listener) => {\n      platform.addEventListener(this, type, listener);\n      listeners[type] = listener;\n    };\n\n    const listener = (e, x, y) => {\n      e.offsetX = x;\n      e.offsetY = y;\n      this._eventHandler(e);\n    };\n\n    each(this.options.events, (type) => _add(type, listener));\n  }\n\n  /**\n   * @private\n   */\n  bindResponsiveEvents() {\n    if (!this._responsiveListeners) {\n      this._responsiveListeners = {};\n    }\n    const listeners = this._responsiveListeners;\n    const platform = this.platform;\n\n    const _add = (type, listener) => {\n      platform.addEventListener(this, type, listener);\n      listeners[type] = listener;\n    };\n    const _remove = (type, listener) => {\n      if (listeners[type]) {\n        platform.removeEventListener(this, type, listener);\n        delete listeners[type];\n      }\n    };\n\n    const listener = (width, height) => {\n      if (this.canvas) {\n        this.resize(width, height);\n      }\n    };\n\n    let detached; // eslint-disable-line prefer-const\n    const attached = () => {\n      _remove('attach', attached);\n\n      this.attached = true;\n      this.resize();\n\n      _add('resize', listener);\n      _add('detach', detached);\n    };\n\n    detached = () => {\n      this.attached = false;\n\n      _remove('resize', listener);\n\n      // Stop animating and remove metasets, so when re-attached, the animations start from beginning.\n      this._stop();\n      this._resize(0, 0);\n\n      _add('attach', attached);\n    };\n\n    if (platform.isAttached(this.canvas)) {\n      attached();\n    } else {\n      detached();\n    }\n  }\n\n  /**\n\t * @private\n\t */\n  unbindEvents() {\n    each(this._listeners, (listener, type) => {\n      this.platform.removeEventListener(this, type, listener);\n    });\n    this._listeners = {};\n\n    each(this._responsiveListeners, (listener, type) => {\n      this.platform.removeEventListener(this, type, listener);\n    });\n    this._responsiveListeners = undefined;\n  }\n\n  updateHoverStyle(items, mode, enabled) {\n    const prefix = enabled ? 'set' : 'remove';\n    let meta, item, i, ilen;\n\n    if (mode === 'dataset') {\n      meta = this.getDatasetMeta(items[0].datasetIndex);\n      meta.controller['_' + prefix + 'DatasetHoverStyle']();\n    }\n\n    for (i = 0, ilen = items.length; i < ilen; ++i) {\n      item = items[i];\n      const controller = item && this.getDatasetMeta(item.datasetIndex).controller;\n      if (controller) {\n        controller[prefix + 'HoverStyle'](item.element, item.datasetIndex, item.index);\n      }\n    }\n  }\n\n  /**\n\t * Get active (hovered) elements\n\t * @returns array\n\t */\n  getActiveElements() {\n    return this._active || [];\n  }\n\n  /**\n\t * Set active (hovered) elements\n\t * @param {array} activeElements New active data points\n\t */\n  setActiveElements(activeElements) {\n    const lastActive = this._active || [];\n    const active = activeElements.map(({datasetIndex, index}) => {\n      const meta = this.getDatasetMeta(datasetIndex);\n      if (!meta) {\n        throw new Error('No dataset found at index ' + datasetIndex);\n      }\n\n      return {\n        datasetIndex,\n        element: meta.data[index],\n        index,\n      };\n    });\n    const changed = !_elementsEqual(active, lastActive);\n\n    if (changed) {\n      this._active = active;\n      // Make sure we don't use the previous mouse event to override the active elements in update.\n      this._lastEvent = null;\n      this._updateHoverStyles(active, lastActive);\n    }\n  }\n\n  /**\n\t * Calls enabled plugins on the specified hook and with the given args.\n\t * This method immediately returns as soon as a plugin explicitly returns false. The\n\t * returned value can be used, for instance, to interrupt the current action.\n\t * @param {string} hook - The name of the plugin method to call (e.g. 'beforeUpdate').\n\t * @param {Object} [args] - Extra arguments to apply to the hook call.\n   * @param {import('./core.plugins.js').filterCallback} [filter] - Filtering function for limiting which plugins are notified\n\t * @returns {boolean} false if any of the plugins return false, else returns true.\n\t */\n  notifyPlugins(hook, args, filter) {\n    return this._plugins.notify(this, hook, args, filter);\n  }\n\n  /**\n   * Check if a plugin with the specific ID is registered and enabled\n   * @param {string} pluginId - The ID of the plugin of which to check if it is enabled\n   * @returns {boolean}\n   */\n  isPluginEnabled(pluginId) {\n    return this._plugins._cache.filter(p => p.plugin.id === pluginId).length === 1;\n  }\n\n  /**\n\t * @private\n\t */\n  _updateHoverStyles(active, lastActive, replay) {\n    const hoverOptions = this.options.hover;\n    const diff = (a, b) => a.filter(x => !b.some(y => x.datasetIndex === y.datasetIndex && x.index === y.index));\n    const deactivated = diff(lastActive, active);\n    const activated = replay ? active : diff(active, lastActive);\n\n    if (deactivated.length) {\n      this.updateHoverStyle(deactivated, hoverOptions.mode, false);\n    }\n\n    if (activated.length && hoverOptions.mode) {\n      this.updateHoverStyle(activated, hoverOptions.mode, true);\n    }\n  }\n\n  /**\n\t * @private\n\t */\n  _eventHandler(e, replay) {\n    const args = {\n      event: e,\n      replay,\n      cancelable: true,\n      inChartArea: this.isPointInArea(e)\n    };\n    const eventFilter = (plugin) => (plugin.options.events || this.options.events).includes(e.native.type);\n\n    if (this.notifyPlugins('beforeEvent', args, eventFilter) === false) {\n      return;\n    }\n\n    const changed = this._handleEvent(e, replay, args.inChartArea);\n\n    args.cancelable = false;\n    this.notifyPlugins('afterEvent', args, eventFilter);\n\n    if (changed || args.changed) {\n      this.render();\n    }\n\n    return this;\n  }\n\n  /**\n\t * Handle an event\n\t * @param {ChartEvent} e the event to handle\n\t * @param {boolean} [replay] - true if the event was replayed by `update`\n   * @param {boolean} [inChartArea] - true if the event is inside chartArea\n\t * @return {boolean} true if the chart needs to re-render\n\t * @private\n\t */\n  _handleEvent(e, replay, inChartArea) {\n    const {_active: lastActive = [], options} = this;\n\n    // If the event is replayed from `update`, we should evaluate with the final positions.\n    //\n    // The `replay`:\n    // It's the last event (excluding click) that has occurred before `update`.\n    // So mouse has not moved. It's also over the chart, because there is a `replay`.\n    //\n    // The why:\n    // If animations are active, the elements haven't moved yet compared to state before update.\n    // But if they will, we are activating the elements that would be active, if this check\n    // was done after the animations have completed. => \"final positions\".\n    // If there is no animations, the \"final\" and \"current\" positions are equal.\n    // This is done so we do not have to evaluate the active elements each animation frame\n    // - it would be expensive.\n    const useFinalPosition = replay;\n    const active = this._getActiveElements(e, lastActive, inChartArea, useFinalPosition);\n    const isClick = _isClickEvent(e);\n    const lastEvent = determineLastEvent(e, this._lastEvent, inChartArea, isClick);\n\n    if (inChartArea) {\n      // Set _lastEvent to null while we are processing the event handlers.\n      // This prevents recursion if the handler calls chart.update()\n      this._lastEvent = null;\n\n      // Invoke onHover hook\n      callCallback(options.onHover, [e, active, this], this);\n\n      if (isClick) {\n        callCallback(options.onClick, [e, active, this], this);\n      }\n    }\n\n    const changed = !_elementsEqual(active, lastActive);\n    if (changed || replay) {\n      this._active = active;\n      this._updateHoverStyles(active, lastActive, replay);\n    }\n\n    this._lastEvent = lastEvent;\n\n    return changed;\n  }\n\n  /**\n   * @param {ChartEvent} e - The event\n   * @param {import('../types/index.js').ActiveElement[]} lastActive - Previously active elements\n   * @param {boolean} inChartArea - Is the envent inside chartArea\n   * @param {boolean} useFinalPosition - Should the evaluation be done with current or final (after animation) element positions\n   * @returns {import('../types/index.js').ActiveElement[]} - The active elements\n   * @pravate\n   */\n  _getActiveElements(e, lastActive, inChartArea, useFinalPosition) {\n    if (e.type === 'mouseout') {\n      return [];\n    }\n\n    if (!inChartArea) {\n      // Let user control the active elements outside chartArea. Eg. using Legend.\n      return lastActive;\n    }\n\n    const hoverOptions = this.options.hover;\n    return this.getElementsAtEventForMode(e, hoverOptions.mode, hoverOptions, useFinalPosition);\n  }\n}\n\n// @ts-ignore\nfunction invalidatePlugins() {\n  return each(Chart.instances, (chart) => chart._plugins.invalidate());\n}\n\nexport default Chart;\n","import {_isDomSupported} from '../helpers/index.js';\nimport BasePlatform from './platform.base.js';\nimport BasicPlatform from './platform.basic.js';\nimport DomPlatform from './platform.dom.js';\n\nexport function _detectPlatform(canvas) {\n  if (!_isDomSupported() || (typeof OffscreenCanvas !== 'undefined' && canvas instanceof OffscreenCanvas)) {\n    return BasicPlatform;\n  }\n  return DomPlatform;\n}\n\nexport {BasePlatform, BasicPlatform, DomPlatform};\n","import Element from '../core/core.element.js';\nimport {_bezierInterpolation, _pointInLine, _steppedInterpolation} from '../helpers/helpers.interpolation.js';\nimport {_computeSegments, _boundSegments} from '../helpers/helpers.segment.js';\nimport {_steppedLineTo, _bezierCurveTo} from '../helpers/helpers.canvas.js';\nimport {_updateBezierControlPoints} from '../helpers/helpers.curve.js';\nimport {valueOrDefault} from '../helpers/index.js';\n\n/**\n * @typedef { import('./element.point.js').default } PointElement\n */\n\nfunction setStyle(ctx, options, style = options) {\n  ctx.lineCap = valueOrDefault(style.borderCapStyle, options.borderCapStyle);\n  ctx.setLineDash(valueOrDefault(style.borderDash, options.borderDash));\n  ctx.lineDashOffset = valueOrDefault(style.borderDashOffset, options.borderDashOffset);\n  ctx.lineJoin = valueOrDefault(style.borderJoinStyle, options.borderJoinStyle);\n  ctx.lineWidth = valueOrDefault(style.borderWidth, options.borderWidth);\n  ctx.strokeStyle = valueOrDefault(style.borderColor, options.borderColor);\n}\n\nfunction lineTo(ctx, previous, target) {\n  ctx.lineTo(target.x, target.y);\n}\n\n/**\n * @returns {any}\n */\nfunction getLineMethod(options) {\n  if (options.stepped) {\n    return _steppedLineTo;\n  }\n\n  if (options.tension || options.cubicInterpolationMode === 'monotone') {\n    return _bezierCurveTo;\n  }\n\n  return lineTo;\n}\n\nfunction pathVars(points, segment, params = {}) {\n  const count = points.length;\n  const {start: paramsStart = 0, end: paramsEnd = count - 1} = params;\n  const {start: segmentStart, end: segmentEnd} = segment;\n  const start = Math.max(paramsStart, segmentStart);\n  const end = Math.min(paramsEnd, segmentEnd);\n  const outside = paramsStart < segmentStart && paramsEnd < segmentStart || paramsStart > segmentEnd && paramsEnd > segmentEnd;\n\n  return {\n    count,\n    start,\n    loop: segment.loop,\n    ilen: end < start && !outside ? count + end - start : end - start\n  };\n}\n\n/**\n * Create path from points, grouping by truncated x-coordinate\n * Points need to be in order by x-coordinate for this to work efficiently\n * @param {CanvasRenderingContext2D|Path2D} ctx - Context\n * @param {LineElement} line\n * @param {object} segment\n * @param {number} segment.start - start index of the segment, referring the points array\n * @param {number} segment.end - end index of the segment, referring the points array\n * @param {boolean} segment.loop - indicates that the segment is a loop\n * @param {object} params\n * @param {boolean} params.move - move to starting point (vs line to it)\n * @param {boolean} params.reverse - path the segment from end to start\n * @param {number} params.start - limit segment to points starting from `start` index\n * @param {number} params.end - limit segment to points ending at `start` + `count` index\n */\nfunction pathSegment(ctx, line, segment, params) {\n  const {points, options} = line;\n  const {count, start, loop, ilen} = pathVars(points, segment, params);\n  const lineMethod = getLineMethod(options);\n  // eslint-disable-next-line prefer-const\n  let {move = true, reverse} = params || {};\n  let i, point, prev;\n\n  for (i = 0; i <= ilen; ++i) {\n    point = points[(start + (reverse ? ilen - i : i)) % count];\n\n    if (point.skip) {\n      // If there is a skipped point inside a segment, spanGaps must be true\n      continue;\n    } else if (move) {\n      ctx.moveTo(point.x, point.y);\n      move = false;\n    } else {\n      lineMethod(ctx, prev, point, reverse, options.stepped);\n    }\n\n    prev = point;\n  }\n\n  if (loop) {\n    point = points[(start + (reverse ? ilen : 0)) % count];\n    lineMethod(ctx, prev, point, reverse, options.stepped);\n  }\n\n  return !!loop;\n}\n\n/**\n * Create path from points, grouping by truncated x-coordinate\n * Points need to be in order by x-coordinate for this to work efficiently\n * @param {CanvasRenderingContext2D|Path2D} ctx - Context\n * @param {LineElement} line\n * @param {object} segment\n * @param {number} segment.start - start index of the segment, referring the points array\n * @param {number} segment.end - end index of the segment, referring the points array\n * @param {boolean} segment.loop - indicates that the segment is a loop\n * @param {object} params\n * @param {boolean} params.move - move to starting point (vs line to it)\n * @param {boolean} params.reverse - path the segment from end to start\n * @param {number} params.start - limit segment to points starting from `start` index\n * @param {number} params.end - limit segment to points ending at `start` + `count` index\n */\nfunction fastPathSegment(ctx, line, segment, params) {\n  const points = line.points;\n  const {count, start, ilen} = pathVars(points, segment, params);\n  const {move = true, reverse} = params || {};\n  let avgX = 0;\n  let countX = 0;\n  let i, point, prevX, minY, maxY, lastY;\n\n  const pointIndex = (index) => (start + (reverse ? ilen - index : index)) % count;\n  const drawX = () => {\n    if (minY !== maxY) {\n      // Draw line to maxY and minY, using the average x-coordinate\n      ctx.lineTo(avgX, maxY);\n      ctx.lineTo(avgX, minY);\n      // Line to y-value of last point in group. So the line continues\n      // from correct position. Not using move, to have solid path.\n      ctx.lineTo(avgX, lastY);\n    }\n  };\n\n  if (move) {\n    point = points[pointIndex(0)];\n    ctx.moveTo(point.x, point.y);\n  }\n\n  for (i = 0; i <= ilen; ++i) {\n    point = points[pointIndex(i)];\n\n    if (point.skip) {\n      // If there is a skipped point inside a segment, spanGaps must be true\n      continue;\n    }\n\n    const x = point.x;\n    const y = point.y;\n    const truncX = x | 0; // truncated x-coordinate\n\n    if (truncX === prevX) {\n      // Determine `minY` / `maxY` and `avgX` while we stay within same x-position\n      if (y < minY) {\n        minY = y;\n      } else if (y > maxY) {\n        maxY = y;\n      }\n      // For first point in group, countX is `0`, so average will be `x` / 1.\n      avgX = (countX * avgX + x) / ++countX;\n    } else {\n      drawX();\n      // Draw line to next x-position, using the first (or only)\n      // y-value in that group\n      ctx.lineTo(x, y);\n\n      prevX = truncX;\n      countX = 0;\n      minY = maxY = y;\n    }\n    // Keep track of the last y-value in group\n    lastY = y;\n  }\n  drawX();\n}\n\n/**\n * @param {LineElement} line - the line\n * @returns {function}\n * @private\n */\nfunction _getSegmentMethod(line) {\n  const opts = line.options;\n  const borderDash = opts.borderDash && opts.borderDash.length;\n  const useFastPath = !line._decimated && !line._loop && !opts.tension && opts.cubicInterpolationMode !== 'monotone' && !opts.stepped && !borderDash;\n  return useFastPath ? fastPathSegment : pathSegment;\n}\n\n/**\n * @private\n */\nfunction _getInterpolationMethod(options) {\n  if (options.stepped) {\n    return _steppedInterpolation;\n  }\n\n  if (options.tension || options.cubicInterpolationMode === 'monotone') {\n    return _bezierInterpolation;\n  }\n\n  return _pointInLine;\n}\n\nfunction strokePathWithCache(ctx, line, start, count) {\n  let path = line._path;\n  if (!path) {\n    path = line._path = new Path2D();\n    if (line.path(path, start, count)) {\n      path.closePath();\n    }\n  }\n  setStyle(ctx, line.options);\n  ctx.stroke(path);\n}\n\nfunction strokePathDirect(ctx, line, start, count) {\n  const {segments, options} = line;\n  const segmentMethod = _getSegmentMethod(line);\n\n  for (const segment of segments) {\n    setStyle(ctx, options, segment.style);\n    ctx.beginPath();\n    if (segmentMethod(ctx, line, segment, {start, end: start + count - 1})) {\n      ctx.closePath();\n    }\n    ctx.stroke();\n  }\n}\n\nconst usePath2D = typeof Path2D === 'function';\n\nfunction draw(ctx, line, start, count) {\n  if (usePath2D && !line.options.segment) {\n    strokePathWithCache(ctx, line, start, count);\n  } else {\n    strokePathDirect(ctx, line, start, count);\n  }\n}\n\nexport default class LineElement extends Element {\n\n  static id = 'line';\n\n  /**\n   * @type {any}\n   */\n  static defaults = {\n    borderCapStyle: 'butt',\n    borderDash: [],\n    borderDashOffset: 0,\n    borderJoinStyle: 'miter',\n    borderWidth: 3,\n    capBezierPoints: true,\n    cubicInterpolationMode: 'default',\n    fill: false,\n    spanGaps: false,\n    stepped: false,\n    tension: 0,\n  };\n\n  /**\n   * @type {any}\n   */\n  static defaultRoutes = {\n    backgroundColor: 'backgroundColor',\n    borderColor: 'borderColor'\n  };\n\n\n  static descriptors = {\n    _scriptable: true,\n    _indexable: (name) => name !== 'borderDash' && name !== 'fill',\n  };\n\n\n  constructor(cfg) {\n    super();\n\n    this.animated = true;\n    this.options = undefined;\n    this._chart = undefined;\n    this._loop = undefined;\n    this._fullLoop = undefined;\n    this._path = undefined;\n    this._points = undefined;\n    this._segments = undefined;\n    this._decimated = false;\n    this._pointsUpdated = false;\n    this._datasetIndex = undefined;\n\n    if (cfg) {\n      Object.assign(this, cfg);\n    }\n  }\n\n  updateControlPoints(chartArea, indexAxis) {\n    const options = this.options;\n    if ((options.tension || options.cubicInterpolationMode === 'monotone') && !options.stepped && !this._pointsUpdated) {\n      const loop = options.spanGaps ? this._loop : this._fullLoop;\n      _updateBezierControlPoints(this._points, options, chartArea, loop, indexAxis);\n      this._pointsUpdated = true;\n    }\n  }\n\n  set points(points) {\n    this._points = points;\n    delete this._segments;\n    delete this._path;\n    this._pointsUpdated = false;\n  }\n\n  get points() {\n    return this._points;\n  }\n\n  get segments() {\n    return this._segments || (this._segments = _computeSegments(this, this.options.segment));\n  }\n\n  /**\n\t * First non-skipped point on this line\n\t * @returns {PointElement|undefined}\n\t */\n  first() {\n    const segments = this.segments;\n    const points = this.points;\n    return segments.length && points[segments[0].start];\n  }\n\n  /**\n\t * Last non-skipped point on this line\n\t * @returns {PointElement|undefined}\n\t */\n  last() {\n    const segments = this.segments;\n    const points = this.points;\n    const count = segments.length;\n    return count && points[segments[count - 1].end];\n  }\n\n  /**\n\t * Interpolate a point in this line at the same value on `property` as\n\t * the reference `point` provided\n\t * @param {PointElement} point - the reference point\n\t * @param {string} property - the property to match on\n\t * @returns {PointElement|undefined}\n\t */\n  interpolate(point, property) {\n    const options = this.options;\n    const value = point[property];\n    const points = this.points;\n    const segments = _boundSegments(this, {property, start: value, end: value});\n\n    if (!segments.length) {\n      return;\n    }\n\n    const result = [];\n    const _interpolate = _getInterpolationMethod(options);\n    let i, ilen;\n    for (i = 0, ilen = segments.length; i < ilen; ++i) {\n      const {start, end} = segments[i];\n      const p1 = points[start];\n      const p2 = points[end];\n      if (p1 === p2) {\n        result.push(p1);\n        continue;\n      }\n      const t = Math.abs((value - p1[property]) / (p2[property] - p1[property]));\n      const interpolated = _interpolate(p1, p2, t, options.stepped);\n      interpolated[property] = point[property];\n      result.push(interpolated);\n    }\n    return result.length === 1 ? result[0] : result;\n  }\n\n  /**\n\t * Append a segment of this line to current path.\n\t * @param {CanvasRenderingContext2D} ctx\n\t * @param {object} segment\n\t * @param {number} segment.start - start index of the segment, referring the points array\n \t * @param {number} segment.end - end index of the segment, referring the points array\n \t * @param {boolean} segment.loop - indicates that the segment is a loop\n\t * @param {object} params\n\t * @param {boolean} params.move - move to starting point (vs line to it)\n\t * @param {boolean} params.reverse - path the segment from end to start\n\t * @param {number} params.start - limit segment to points starting from `start` index\n\t * @param {number} params.end - limit segment to points ending at `start` + `count` index\n\t * @returns {undefined|boolean} - true if the segment is a full loop (path should be closed)\n\t */\n  pathSegment(ctx, segment, params) {\n    const segmentMethod = _getSegmentMethod(this);\n    return segmentMethod(ctx, this, segment, params);\n  }\n\n  /**\n\t * Append all segments of this line to current path.\n\t * @param {CanvasRenderingContext2D|Path2D} ctx\n\t * @param {number} [start]\n\t * @param {number} [count]\n\t * @returns {undefined|boolean} - true if line is a full loop (path should be closed)\n\t */\n  path(ctx, start, count) {\n    const segments = this.segments;\n    const segmentMethod = _getSegmentMethod(this);\n    let loop = this._loop;\n\n    start = start || 0;\n    count = count || (this.points.length - start);\n\n    for (const segment of segments) {\n      loop &= segmentMethod(ctx, this, segment, {start, end: start + count - 1});\n    }\n    return !!loop;\n  }\n\n  /**\n\t * Draw\n\t * @param {CanvasRenderingContext2D} ctx\n\t * @param {object} chartArea\n\t * @param {number} [start]\n\t * @param {number} [count]\n\t */\n  draw(ctx, chartArea, start, count) {\n    const options = this.options || {};\n    const points = this.points || [];\n\n    if (points.length && options.borderWidth) {\n      ctx.save();\n\n      draw(ctx, this, start, count);\n\n      ctx.restore();\n    }\n\n    if (this.animated) {\n      // When line is animated, the control points and path are not cached.\n      this._pointsUpdated = false;\n      this._path = undefined;\n    }\n  }\n}\n","import Element from '../core/core.element.js';\nimport {drawPoint, _isPointInArea} from '../helpers/helpers.canvas.js';\nimport type {\n  CartesianParsedData,\n  ChartArea,\n  Point,\n  PointHoverOptions,\n  PointOptions,\n} from '../types/index.js';\n\nfunction inRange(el: PointElement, pos: number, axis: 'x' | 'y', useFinalPosition?: boolean) {\n  const options = el.options;\n  const {[axis]: value} = el.getProps([axis], useFinalPosition);\n\n  return (Math.abs(pos - value) < options.radius + options.hitRadius);\n}\n\nexport type PointProps = Point\n\nexport default class PointElement extends Element<PointProps, PointOptions & PointHoverOptions> {\n\n  static id = 'point';\n\n  parsed: CartesianParsedData;\n  skip?: boolean;\n  stop?: boolean;\n\n  /**\n   * @type {any}\n   */\n  static defaults = {\n    borderWidth: 1,\n    hitRadius: 1,\n    hoverBorderWidth: 1,\n    hoverRadius: 4,\n    pointStyle: 'circle',\n    radius: 3,\n    rotation: 0\n  };\n\n  /**\n   * @type {any}\n   */\n  static defaultRoutes = {\n    backgroundColor: 'backgroundColor',\n    borderColor: 'borderColor'\n  };\n\n  constructor(cfg) {\n    super();\n\n    this.options = undefined;\n    this.parsed = undefined;\n    this.skip = undefined;\n    this.stop = undefined;\n\n    if (cfg) {\n      Object.assign(this, cfg);\n    }\n  }\n\n  inRange(mouseX: number, mouseY: number, useFinalPosition?: boolean) {\n    const options = this.options;\n    const {x, y} = this.getProps(['x', 'y'], useFinalPosition);\n    return ((Math.pow(mouseX - x, 2) + Math.pow(mouseY - y, 2)) < Math.pow(options.hitRadius + options.radius, 2));\n  }\n\n  inXRange(mouseX: number, useFinalPosition?: boolean) {\n    return inRange(this, mouseX, 'x', useFinalPosition);\n  }\n\n  inYRange(mouseY: number, useFinalPosition?: boolean) {\n    return inRange(this, mouseY, 'y', useFinalPosition);\n  }\n\n  getCenterPoint(useFinalPosition?: boolean) {\n    const {x, y} = this.getProps(['x', 'y'], useFinalPosition);\n    return {x, y};\n  }\n\n  size(options?: Partial<PointOptions & PointHoverOptions>) {\n    options = options || this.options || {};\n    let radius = options.radius || 0;\n    radius = Math.max(radius, radius && options.hoverRadius || 0);\n    const borderWidth = radius && options.borderWidth || 0;\n    return (radius + borderWidth) * 2;\n  }\n\n  draw(ctx: CanvasRenderingContext2D, area: ChartArea) {\n    const options = this.options;\n\n    if (this.skip || options.radius < 0.1 || !_isPointInArea(this, area, this.size(options) / 2)) {\n      return;\n    }\n\n    ctx.strokeStyle = options.borderColor;\n    ctx.lineWidth = options.borderWidth;\n    ctx.fillStyle = options.backgroundColor;\n    drawPoint(ctx, options, this.x, this.y);\n  }\n\n  getRange() {\n    const options = this.options || {};\n    // @ts-expect-error Fallbacks should never be hit in practice\n    return options.radius + options.hitRadius;\n  }\n}\n","import Element from '../core/core.element.js';\nimport {isObject, _isBetween, _limitValue} from '../helpers/index.js';\nimport {addRoundedRectPath} from '../helpers/helpers.canvas.js';\nimport {toTRBL, toTRBLCorners} from '../helpers/helpers.options.js';\n\n/** @typedef {{ x: number, y: number, base: number, horizontal: boolean, width: number, height: number }} BarProps */\n\n/**\n * Helper function to get the bounds of the bar regardless of the orientation\n * @param {BarElement} bar the bar\n * @param {boolean} [useFinalPosition]\n * @return {object} bounds of the bar\n * @private\n */\nfunction getBarBounds(bar, useFinalPosition) {\n  const {x, y, base, width, height} = /** @type {BarProps} */ (bar.getProps(['x', 'y', 'base', 'width', 'height'], useFinalPosition));\n\n  let left, right, top, bottom, half;\n\n  if (bar.horizontal) {\n    half = height / 2;\n    left = Math.min(x, base);\n    right = Math.max(x, base);\n    top = y - half;\n    bottom = y + half;\n  } else {\n    half = width / 2;\n    left = x - half;\n    right = x + half;\n    top = Math.min(y, base);\n    bottom = Math.max(y, base);\n  }\n\n  return {left, top, right, bottom};\n}\n\nfunction skipOrLimit(skip, value, min, max) {\n  return skip ? 0 : _limitValue(value, min, max);\n}\n\nfunction parseBorderWidth(bar, maxW, maxH) {\n  const value = bar.options.borderWidth;\n  const skip = bar.borderSkipped;\n  const o = toTRBL(value);\n\n  return {\n    t: skipOrLimit(skip.top, o.top, 0, maxH),\n    r: skipOrLimit(skip.right, o.right, 0, maxW),\n    b: skipOrLimit(skip.bottom, o.bottom, 0, maxH),\n    l: skipOrLimit(skip.left, o.left, 0, maxW)\n  };\n}\n\nfunction parseBorderRadius(bar, maxW, maxH) {\n  const {enableBorderRadius} = bar.getProps(['enableBorderRadius']);\n  const value = bar.options.borderRadius;\n  const o = toTRBLCorners(value);\n  const maxR = Math.min(maxW, maxH);\n  const skip = bar.borderSkipped;\n\n  // If the value is an object, assume the user knows what they are doing\n  // and apply as directed.\n  const enableBorder = enableBorderRadius || isObject(value);\n\n  return {\n    topLeft: skipOrLimit(!enableBorder || skip.top || skip.left, o.topLeft, 0, maxR),\n    topRight: skipOrLimit(!enableBorder || skip.top || skip.right, o.topRight, 0, maxR),\n    bottomLeft: skipOrLimit(!enableBorder || skip.bottom || skip.left, o.bottomLeft, 0, maxR),\n    bottomRight: skipOrLimit(!enableBorder || skip.bottom || skip.right, o.bottomRight, 0, maxR)\n  };\n}\n\nfunction boundingRects(bar) {\n  const bounds = getBarBounds(bar);\n  const width = bounds.right - bounds.left;\n  const height = bounds.bottom - bounds.top;\n  const border = parseBorderWidth(bar, width / 2, height / 2);\n  const radius = parseBorderRadius(bar, width / 2, height / 2);\n\n  return {\n    outer: {\n      x: bounds.left,\n      y: bounds.top,\n      w: width,\n      h: height,\n      radius\n    },\n    inner: {\n      x: bounds.left + border.l,\n      y: bounds.top + border.t,\n      w: width - border.l - border.r,\n      h: height - border.t - border.b,\n      radius: {\n        topLeft: Math.max(0, radius.topLeft - Math.max(border.t, border.l)),\n        topRight: Math.max(0, radius.topRight - Math.max(border.t, border.r)),\n        bottomLeft: Math.max(0, radius.bottomLeft - Math.max(border.b, border.l)),\n        bottomRight: Math.max(0, radius.bottomRight - Math.max(border.b, border.r)),\n      }\n    }\n  };\n}\n\nfunction inRange(bar, x, y, useFinalPosition) {\n  const skipX = x === null;\n  const skipY = y === null;\n  const skipBoth = skipX && skipY;\n  const bounds = bar && !skipBoth && getBarBounds(bar, useFinalPosition);\n\n  return bounds\n\t\t&& (skipX || _isBetween(x, bounds.left, bounds.right))\n\t\t&& (skipY || _isBetween(y, bounds.top, bounds.bottom));\n}\n\nfunction hasRadius(radius) {\n  return radius.topLeft || radius.topRight || radius.bottomLeft || radius.bottomRight;\n}\n\n/**\n * Add a path of a rectangle to the current sub-path\n * @param {CanvasRenderingContext2D} ctx Context\n * @param {*} rect Bounding rect\n */\nfunction addNormalRectPath(ctx, rect) {\n  ctx.rect(rect.x, rect.y, rect.w, rect.h);\n}\n\nfunction inflateRect(rect, amount, refRect = {}) {\n  const x = rect.x !== refRect.x ? -amount : 0;\n  const y = rect.y !== refRect.y ? -amount : 0;\n  const w = (rect.x + rect.w !== refRect.x + refRect.w ? amount : 0) - x;\n  const h = (rect.y + rect.h !== refRect.y + refRect.h ? amount : 0) - y;\n  return {\n    x: rect.x + x,\n    y: rect.y + y,\n    w: rect.w + w,\n    h: rect.h + h,\n    radius: rect.radius\n  };\n}\n\nexport default class BarElement extends Element {\n\n  static id = 'bar';\n\n  /**\n   * @type {any}\n   */\n  static defaults = {\n    borderSkipped: 'start',\n    borderWidth: 0,\n    borderRadius: 0,\n    inflateAmount: 'auto',\n    pointStyle: undefined\n  };\n\n  /**\n   * @type {any}\n   */\n  static defaultRoutes = {\n    backgroundColor: 'backgroundColor',\n    borderColor: 'borderColor'\n  };\n\n  constructor(cfg) {\n    super();\n\n    this.options = undefined;\n    this.horizontal = undefined;\n    this.base = undefined;\n    this.width = undefined;\n    this.height = undefined;\n    this.inflateAmount = undefined;\n\n    if (cfg) {\n      Object.assign(this, cfg);\n    }\n  }\n\n  draw(ctx) {\n    const {inflateAmount, options: {borderColor, backgroundColor}} = this;\n    const {inner, outer} = boundingRects(this);\n    const addRectPath = hasRadius(outer.radius) ? addRoundedRectPath : addNormalRectPath;\n\n    ctx.save();\n\n    if (outer.w !== inner.w || outer.h !== inner.h) {\n      ctx.beginPath();\n      addRectPath(ctx, inflateRect(outer, inflateAmount, inner));\n      ctx.clip();\n      addRectPath(ctx, inflateRect(inner, -inflateAmount, outer));\n      ctx.fillStyle = borderColor;\n      ctx.fill('evenodd');\n    }\n\n    ctx.beginPath();\n    addRectPath(ctx, inflateRect(inner, inflateAmount));\n    ctx.fillStyle = backgroundColor;\n    ctx.fill();\n\n    ctx.restore();\n  }\n\n  inRange(mouseX, mouseY, useFinalPosition) {\n    return inRange(this, mouseX, mouseY, useFinalPosition);\n  }\n\n  inXRange(mouseX, useFinalPosition) {\n    return inRange(this, mouseX, null, useFinalPosition);\n  }\n\n  inYRange(mouseY, useFinalPosition) {\n    return inRange(this, null, mouseY, useFinalPosition);\n  }\n\n  getCenterPoint(useFinalPosition) {\n    const {x, y, base, horizontal} = /** @type {BarProps} */ (this.getProps(['x', 'y', 'base', 'horizontal'], useFinalPosition));\n    return {\n      x: horizontal ? (x + base) / 2 : x,\n      y: horizontal ? y : (y + base) / 2\n    };\n  }\n\n  getRange(axis) {\n    return axis === 'x' ? this.width / 2 : this.height / 2;\n  }\n}\n","import defaults from '../core/core.defaults.js';\nimport Element from '../core/core.element.js';\nimport layouts from '../core/core.layouts.js';\nimport {addRoundedRectPath, drawPointLegend, renderText} from '../helpers/helpers.canvas.js';\nimport {\n  _isBetween,\n  callback as call,\n  clipArea,\n  getRtlAdapter,\n  overrideTextDirection,\n  restoreTextDirection,\n  toFont,\n  toPadding,\n  unclipArea,\n  valueOrDefault,\n} from '../helpers/index.js';\nimport {_alignStartEnd, _textX, _toLeftRightCenter} from '../helpers/helpers.extras.js';\nimport {toTRBLCorners} from '../helpers/helpers.options.js';\n\n/**\n * @typedef { import('../types/index.js').ChartEvent } ChartEvent\n */\n\nconst getBoxSize = (labelOpts, fontSize) => {\n  let {boxHeight = fontSize, boxWidth = fontSize} = labelOpts;\n\n  if (labelOpts.usePointStyle) {\n    boxHeight = Math.min(boxHeight, fontSize);\n    boxWidth = labelOpts.pointStyleWidth || Math.min(boxWidth, fontSize);\n  }\n\n  return {\n    boxWidth,\n    boxHeight,\n    itemHeight: Math.max(fontSize, boxHeight)\n  };\n};\n\nconst itemsEqual = (a, b) => a !== null && b !== null && a.datasetIndex === b.datasetIndex && a.index === b.index;\n\nexport class Legend extends Element {\n\n  /**\n\t * @param {{ ctx: any; options: any; chart: any; }} config\n\t */\n  constructor(config) {\n    super();\n\n    this._added = false;\n\n    // Contains hit boxes for each dataset (in dataset order)\n    this.legendHitBoxes = [];\n\n    /**\n \t\t * @private\n \t\t */\n    this._hoveredItem = null;\n\n    // Are we in doughnut mode which has a different data type\n    this.doughnutMode = false;\n\n    this.chart = config.chart;\n    this.options = config.options;\n    this.ctx = config.ctx;\n    this.legendItems = undefined;\n    this.columnSizes = undefined;\n    this.lineWidths = undefined;\n    this.maxHeight = undefined;\n    this.maxWidth = undefined;\n    this.top = undefined;\n    this.bottom = undefined;\n    this.left = undefined;\n    this.right = undefined;\n    this.height = undefined;\n    this.width = undefined;\n    this._margins = undefined;\n    this.position = undefined;\n    this.weight = undefined;\n    this.fullSize = undefined;\n  }\n\n  update(maxWidth, maxHeight, margins) {\n    this.maxWidth = maxWidth;\n    this.maxHeight = maxHeight;\n    this._margins = margins;\n\n    this.setDimensions();\n    this.buildLabels();\n    this.fit();\n  }\n\n  setDimensions() {\n    if (this.isHorizontal()) {\n      this.width = this.maxWidth;\n      this.left = this._margins.left;\n      this.right = this.width;\n    } else {\n      this.height = this.maxHeight;\n      this.top = this._margins.top;\n      this.bottom = this.height;\n    }\n  }\n\n  buildLabels() {\n    const labelOpts = this.options.labels || {};\n    let legendItems = call(labelOpts.generateLabels, [this.chart], this) || [];\n\n    if (labelOpts.filter) {\n      legendItems = legendItems.filter((item) => labelOpts.filter(item, this.chart.data));\n    }\n\n    if (labelOpts.sort) {\n      legendItems = legendItems.sort((a, b) => labelOpts.sort(a, b, this.chart.data));\n    }\n\n    if (this.options.reverse) {\n      legendItems.reverse();\n    }\n\n    this.legendItems = legendItems;\n  }\n\n  fit() {\n    const {options, ctx} = this;\n\n    // The legend may not be displayed for a variety of reasons including\n    // the fact that the defaults got set to `false`.\n    // When the legend is not displayed, there are no guarantees that the options\n    // are correctly formatted so we need to bail out as early as possible.\n    if (!options.display) {\n      this.width = this.height = 0;\n      return;\n    }\n\n    const labelOpts = options.labels;\n    const labelFont = toFont(labelOpts.font);\n    const fontSize = labelFont.size;\n    const titleHeight = this._computeTitleHeight();\n    const {boxWidth, itemHeight} = getBoxSize(labelOpts, fontSize);\n\n    let width, height;\n\n    ctx.font = labelFont.string;\n\n    if (this.isHorizontal()) {\n      width = this.maxWidth; // fill all the width\n      height = this._fitRows(titleHeight, fontSize, boxWidth, itemHeight) + 10;\n    } else {\n      height = this.maxHeight; // fill all the height\n      width = this._fitCols(titleHeight, labelFont, boxWidth, itemHeight) + 10;\n    }\n\n    this.width = Math.min(width, options.maxWidth || this.maxWidth);\n    this.height = Math.min(height, options.maxHeight || this.maxHeight);\n  }\n\n  /**\n\t * @private\n\t */\n  _fitRows(titleHeight, fontSize, boxWidth, itemHeight) {\n    const {ctx, maxWidth, options: {labels: {padding}}} = this;\n    const hitboxes = this.legendHitBoxes = [];\n    // Width of each line of legend boxes. Labels wrap onto multiple lines when there are too many to fit on one\n    const lineWidths = this.lineWidths = [0];\n    const lineHeight = itemHeight + padding;\n    let totalHeight = titleHeight;\n\n    ctx.textAlign = 'left';\n    ctx.textBaseline = 'middle';\n\n    let row = -1;\n    let top = -lineHeight;\n    this.legendItems.forEach((legendItem, i) => {\n      const itemWidth = boxWidth + (fontSize / 2) + ctx.measureText(legendItem.text).width;\n\n      if (i === 0 || lineWidths[lineWidths.length - 1] + itemWidth + 2 * padding > maxWidth) {\n        totalHeight += lineHeight;\n        lineWidths[lineWidths.length - (i > 0 ? 0 : 1)] = 0;\n        top += lineHeight;\n        row++;\n      }\n\n      hitboxes[i] = {left: 0, top, row, width: itemWidth, height: itemHeight};\n\n      lineWidths[lineWidths.length - 1] += itemWidth + padding;\n    });\n\n    return totalHeight;\n  }\n\n  _fitCols(titleHeight, labelFont, boxWidth, _itemHeight) {\n    const {ctx, maxHeight, options: {labels: {padding}}} = this;\n    const hitboxes = this.legendHitBoxes = [];\n    const columnSizes = this.columnSizes = [];\n    const heightLimit = maxHeight - titleHeight;\n\n    let totalWidth = padding;\n    let currentColWidth = 0;\n    let currentColHeight = 0;\n\n    let left = 0;\n    let col = 0;\n\n    this.legendItems.forEach((legendItem, i) => {\n      const {itemWidth, itemHeight} = calculateItemSize(boxWidth, labelFont, ctx, legendItem, _itemHeight);\n\n      // If too tall, go to new column\n      if (i > 0 && currentColHeight + itemHeight + 2 * padding > heightLimit) {\n        totalWidth += currentColWidth + padding;\n        columnSizes.push({width: currentColWidth, height: currentColHeight}); // previous column size\n        left += currentColWidth + padding;\n        col++;\n        currentColWidth = currentColHeight = 0;\n      }\n\n      // Store the hitbox width and height here. Final position will be updated in `draw`\n      hitboxes[i] = {left, top: currentColHeight, col, width: itemWidth, height: itemHeight};\n\n      // Get max width\n      currentColWidth = Math.max(currentColWidth, itemWidth);\n      currentColHeight += itemHeight + padding;\n    });\n\n    totalWidth += currentColWidth;\n    columnSizes.push({width: currentColWidth, height: currentColHeight}); // previous column size\n\n    return totalWidth;\n  }\n\n  adjustHitBoxes() {\n    if (!this.options.display) {\n      return;\n    }\n    const titleHeight = this._computeTitleHeight();\n    const {legendHitBoxes: hitboxes, options: {align, labels: {padding}, rtl}} = this;\n    const rtlHelper = getRtlAdapter(rtl, this.left, this.width);\n    if (this.isHorizontal()) {\n      let row = 0;\n      let left = _alignStartEnd(align, this.left + padding, this.right - this.lineWidths[row]);\n      for (const hitbox of hitboxes) {\n        if (row !== hitbox.row) {\n          row = hitbox.row;\n          left = _alignStartEnd(align, this.left + padding, this.right - this.lineWidths[row]);\n        }\n        hitbox.top += this.top + titleHeight + padding;\n        hitbox.left = rtlHelper.leftForLtr(rtlHelper.x(left), hitbox.width);\n        left += hitbox.width + padding;\n      }\n    } else {\n      let col = 0;\n      let top = _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - this.columnSizes[col].height);\n      for (const hitbox of hitboxes) {\n        if (hitbox.col !== col) {\n          col = hitbox.col;\n          top = _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - this.columnSizes[col].height);\n        }\n        hitbox.top = top;\n        hitbox.left += this.left + padding;\n        hitbox.left = rtlHelper.leftForLtr(rtlHelper.x(hitbox.left), hitbox.width);\n        top += hitbox.height + padding;\n      }\n    }\n  }\n\n  isHorizontal() {\n    return this.options.position === 'top' || this.options.position === 'bottom';\n  }\n\n  draw() {\n    if (this.options.display) {\n      const ctx = this.ctx;\n      clipArea(ctx, this);\n\n      this._draw();\n\n      unclipArea(ctx);\n    }\n  }\n\n  /**\n\t * @private\n\t */\n  _draw() {\n    const {options: opts, columnSizes, lineWidths, ctx} = this;\n    const {align, labels: labelOpts} = opts;\n    const defaultColor = defaults.color;\n    const rtlHelper = getRtlAdapter(opts.rtl, this.left, this.width);\n    const labelFont = toFont(labelOpts.font);\n    const {padding} = labelOpts;\n    const fontSize = labelFont.size;\n    const halfFontSize = fontSize / 2;\n    let cursor;\n\n    this.drawTitle();\n\n    // Canvas setup\n    ctx.textAlign = rtlHelper.textAlign('left');\n    ctx.textBaseline = 'middle';\n    ctx.lineWidth = 0.5;\n    ctx.font = labelFont.string;\n\n    const {boxWidth, boxHeight, itemHeight} = getBoxSize(labelOpts, fontSize);\n\n    // current position\n    const drawLegendBox = function(x, y, legendItem) {\n      if (isNaN(boxWidth) || boxWidth <= 0 || isNaN(boxHeight) || boxHeight < 0) {\n        return;\n      }\n\n      // Set the ctx for the box\n      ctx.save();\n\n      const lineWidth = valueOrDefault(legendItem.lineWidth, 1);\n      ctx.fillStyle = valueOrDefault(legendItem.fillStyle, defaultColor);\n      ctx.lineCap = valueOrDefault(legendItem.lineCap, 'butt');\n      ctx.lineDashOffset = valueOrDefault(legendItem.lineDashOffset, 0);\n      ctx.lineJoin = valueOrDefault(legendItem.lineJoin, 'miter');\n      ctx.lineWidth = lineWidth;\n      ctx.strokeStyle = valueOrDefault(legendItem.strokeStyle, defaultColor);\n\n      ctx.setLineDash(valueOrDefault(legendItem.lineDash, []));\n\n      if (labelOpts.usePointStyle) {\n        // Recalculate x and y for drawPoint() because its expecting\n        // x and y to be center of figure (instead of top left)\n        const drawOptions = {\n          radius: boxHeight * Math.SQRT2 / 2,\n          pointStyle: legendItem.pointStyle,\n          rotation: legendItem.rotation,\n          borderWidth: lineWidth\n        };\n        const centerX = rtlHelper.xPlus(x, boxWidth / 2);\n        const centerY = y + halfFontSize;\n\n        // Draw pointStyle as legend symbol\n        drawPointLegend(ctx, drawOptions, centerX, centerY, labelOpts.pointStyleWidth && boxWidth);\n      } else {\n        // Draw box as legend symbol\n        // Adjust position when boxHeight < fontSize (want it centered)\n        const yBoxTop = y + Math.max((fontSize - boxHeight) / 2, 0);\n        const xBoxLeft = rtlHelper.leftForLtr(x, boxWidth);\n        const borderRadius = toTRBLCorners(legendItem.borderRadius);\n\n        ctx.beginPath();\n\n        if (Object.values(borderRadius).some(v => v !== 0)) {\n          addRoundedRectPath(ctx, {\n            x: xBoxLeft,\n            y: yBoxTop,\n            w: boxWidth,\n            h: boxHeight,\n            radius: borderRadius,\n          });\n        } else {\n          ctx.rect(xBoxLeft, yBoxTop, boxWidth, boxHeight);\n        }\n\n        ctx.fill();\n        if (lineWidth !== 0) {\n          ctx.stroke();\n        }\n      }\n\n      ctx.restore();\n    };\n\n    const fillText = function(x, y, legendItem) {\n      renderText(ctx, legendItem.text, x, y + (itemHeight / 2), labelFont, {\n        strikethrough: legendItem.hidden,\n        textAlign: rtlHelper.textAlign(legendItem.textAlign)\n      });\n    };\n\n    // Horizontal\n    const isHorizontal = this.isHorizontal();\n    const titleHeight = this._computeTitleHeight();\n    if (isHorizontal) {\n      cursor = {\n        x: _alignStartEnd(align, this.left + padding, this.right - lineWidths[0]),\n        y: this.top + padding + titleHeight,\n        line: 0\n      };\n    } else {\n      cursor = {\n        x: this.left + padding,\n        y: _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - columnSizes[0].height),\n        line: 0\n      };\n    }\n\n    overrideTextDirection(this.ctx, opts.textDirection);\n\n    const lineHeight = itemHeight + padding;\n    this.legendItems.forEach((legendItem, i) => {\n      ctx.strokeStyle = legendItem.fontColor; // for strikethrough effect\n      ctx.fillStyle = legendItem.fontColor; // render in correct colour\n\n      const textWidth = ctx.measureText(legendItem.text).width;\n      const textAlign = rtlHelper.textAlign(legendItem.textAlign || (legendItem.textAlign = labelOpts.textAlign));\n      const width = boxWidth + halfFontSize + textWidth;\n      let x = cursor.x;\n      let y = cursor.y;\n\n      rtlHelper.setWidth(this.width);\n\n      if (isHorizontal) {\n        if (i > 0 && x + width + padding > this.right) {\n          y = cursor.y += lineHeight;\n          cursor.line++;\n          x = cursor.x = _alignStartEnd(align, this.left + padding, this.right - lineWidths[cursor.line]);\n        }\n      } else if (i > 0 && y + lineHeight > this.bottom) {\n        x = cursor.x = x + columnSizes[cursor.line].width + padding;\n        cursor.line++;\n        y = cursor.y = _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - columnSizes[cursor.line].height);\n      }\n\n      const realX = rtlHelper.x(x);\n\n      drawLegendBox(realX, y, legendItem);\n\n      x = _textX(textAlign, x + boxWidth + halfFontSize, isHorizontal ? x + width : this.right, opts.rtl);\n\n      // Fill the actual label\n      fillText(rtlHelper.x(x), y, legendItem);\n\n      if (isHorizontal) {\n        cursor.x += width + padding;\n      } else if (typeof legendItem.text !== 'string') {\n        const fontLineHeight = labelFont.lineHeight;\n        cursor.y += calculateLegendItemHeight(legendItem, fontLineHeight) + padding;\n      } else {\n        cursor.y += lineHeight;\n      }\n    });\n\n    restoreTextDirection(this.ctx, opts.textDirection);\n  }\n\n  /**\n\t * @protected\n\t */\n  drawTitle() {\n    const opts = this.options;\n    const titleOpts = opts.title;\n    const titleFont = toFont(titleOpts.font);\n    const titlePadding = toPadding(titleOpts.padding);\n\n    if (!titleOpts.display) {\n      return;\n    }\n\n    const rtlHelper = getRtlAdapter(opts.rtl, this.left, this.width);\n    const ctx = this.ctx;\n    const position = titleOpts.position;\n    const halfFontSize = titleFont.size / 2;\n    const topPaddingPlusHalfFontSize = titlePadding.top + halfFontSize;\n    let y;\n\n    // These defaults are used when the legend is vertical.\n    // When horizontal, they are computed below.\n    let left = this.left;\n    let maxWidth = this.width;\n\n    if (this.isHorizontal()) {\n      // Move left / right so that the title is above the legend lines\n      maxWidth = Math.max(...this.lineWidths);\n      y = this.top + topPaddingPlusHalfFontSize;\n      left = _alignStartEnd(opts.align, left, this.right - maxWidth);\n    } else {\n      // Move down so that the title is above the legend stack in every alignment\n      const maxHeight = this.columnSizes.reduce((acc, size) => Math.max(acc, size.height), 0);\n      y = topPaddingPlusHalfFontSize + _alignStartEnd(opts.align, this.top, this.bottom - maxHeight - opts.labels.padding - this._computeTitleHeight());\n    }\n\n    // Now that we know the left edge of the inner legend box, compute the correct\n    // X coordinate from the title alignment\n    const x = _alignStartEnd(position, left, left + maxWidth);\n\n    // Canvas setup\n    ctx.textAlign = rtlHelper.textAlign(_toLeftRightCenter(position));\n    ctx.textBaseline = 'middle';\n    ctx.strokeStyle = titleOpts.color;\n    ctx.fillStyle = titleOpts.color;\n    ctx.font = titleFont.string;\n\n    renderText(ctx, titleOpts.text, x, y, titleFont);\n  }\n\n  /**\n\t * @private\n\t */\n  _computeTitleHeight() {\n    const titleOpts = this.options.title;\n    const titleFont = toFont(titleOpts.font);\n    const titlePadding = toPadding(titleOpts.padding);\n    return titleOpts.display ? titleFont.lineHeight + titlePadding.height : 0;\n  }\n\n  /**\n\t * @private\n\t */\n  _getLegendItemAt(x, y) {\n    let i, hitBox, lh;\n\n    if (_isBetween(x, this.left, this.right)\n      && _isBetween(y, this.top, this.bottom)) {\n      // See if we are touching one of the dataset boxes\n      lh = this.legendHitBoxes;\n      for (i = 0; i < lh.length; ++i) {\n        hitBox = lh[i];\n\n        if (_isBetween(x, hitBox.left, hitBox.left + hitBox.width)\n          && _isBetween(y, hitBox.top, hitBox.top + hitBox.height)) {\n          // Touching an element\n          return this.legendItems[i];\n        }\n      }\n    }\n\n    return null;\n  }\n\n  /**\n\t * Handle an event\n\t * @param {ChartEvent} e - The event to handle\n\t */\n  handleEvent(e) {\n    const opts = this.options;\n    if (!isListened(e.type, opts)) {\n      return;\n    }\n\n    // Chart event already has relative position in it\n    const hoveredItem = this._getLegendItemAt(e.x, e.y);\n\n    if (e.type === 'mousemove' || e.type === 'mouseout') {\n      const previous = this._hoveredItem;\n      const sameItem = itemsEqual(previous, hoveredItem);\n      if (previous && !sameItem) {\n        call(opts.onLeave, [e, previous, this], this);\n      }\n\n      this._hoveredItem = hoveredItem;\n\n      if (hoveredItem && !sameItem) {\n        call(opts.onHover, [e, hoveredItem, this], this);\n      }\n    } else if (hoveredItem) {\n      call(opts.onClick, [e, hoveredItem, this], this);\n    }\n  }\n}\n\nfunction calculateItemSize(boxWidth, labelFont, ctx, legendItem, _itemHeight) {\n  const itemWidth = calculateItemWidth(legendItem, boxWidth, labelFont, ctx);\n  const itemHeight = calculateItemHeight(_itemHeight, legendItem, labelFont.lineHeight);\n  return {itemWidth, itemHeight};\n}\n\nfunction calculateItemWidth(legendItem, boxWidth, labelFont, ctx) {\n  let legendItemText = legendItem.text;\n  if (legendItemText && typeof legendItemText !== 'string') {\n    legendItemText = legendItemText.reduce((a, b) => a.length > b.length ? a : b);\n  }\n  return boxWidth + (labelFont.size / 2) + ctx.measureText(legendItemText).width;\n}\n\nfunction calculateItemHeight(_itemHeight, legendItem, fontLineHeight) {\n  let itemHeight = _itemHeight;\n  if (typeof legendItem.text !== 'string') {\n    itemHeight = calculateLegendItemHeight(legendItem, fontLineHeight);\n  }\n  return itemHeight;\n}\n\nfunction calculateLegendItemHeight(legendItem, fontLineHeight) {\n  const labelHeight = legendItem.text ? legendItem.text.length : 0;\n  return fontLineHeight * labelHeight;\n}\n\nfunction isListened(type, opts) {\n  if ((type === 'mousemove' || type === 'mouseout') && (opts.onHover || opts.onLeave)) {\n    return true;\n  }\n  if (opts.onClick && (type === 'click' || type === 'mouseup')) {\n    return true;\n  }\n  return false;\n}\n\nexport default {\n  id: 'legend',\n\n  /**\n\t * For tests\n\t * @private\n\t */\n  _element: Legend,\n\n  start(chart, _args, options) {\n    const legend = chart.legend = new Legend({ctx: chart.ctx, options, chart});\n    layouts.configure(chart, legend, options);\n    layouts.addBox(chart, legend);\n  },\n\n  stop(chart) {\n    layouts.removeBox(chart, chart.legend);\n    delete chart.legend;\n  },\n\n  // During the beforeUpdate step, the layout configuration needs to run\n  // This ensures that if the legend position changes (via an option update)\n  // the layout system respects the change. See https://github.com/chartjs/Chart.js/issues/7527\n  beforeUpdate(chart, _args, options) {\n    const legend = chart.legend;\n    layouts.configure(chart, legend, options);\n    legend.options = options;\n  },\n\n  // The labels need to be built after datasets are updated to ensure that colors\n  // and other styling are correct. See https://github.com/chartjs/Chart.js/issues/6968\n  afterUpdate(chart) {\n    const legend = chart.legend;\n    legend.buildLabels();\n    legend.adjustHitBoxes();\n  },\n\n\n  afterEvent(chart, args) {\n    if (!args.replay) {\n      chart.legend.handleEvent(args.event);\n    }\n  },\n\n  defaults: {\n    display: true,\n    position: 'top',\n    align: 'center',\n    fullSize: true,\n    reverse: false,\n    weight: 1000,\n\n    // a callback that will handle\n    onClick(e, legendItem, legend) {\n      const index = legendItem.datasetIndex;\n      const ci = legend.chart;\n      if (ci.isDatasetVisible(index)) {\n        ci.hide(index);\n        legendItem.hidden = true;\n      } else {\n        ci.show(index);\n        legendItem.hidden = false;\n      }\n    },\n\n    onHover: null,\n    onLeave: null,\n\n    labels: {\n      color: (ctx) => ctx.chart.options.color,\n      boxWidth: 40,\n      padding: 10,\n      // Generates labels shown in the legend\n      // Valid properties to return:\n      // text : text to display\n      // fillStyle : fill of coloured box\n      // strokeStyle: stroke of coloured box\n      // hidden : if this legend item refers to a hidden item\n      // lineCap : cap style for line\n      // lineDash\n      // lineDashOffset :\n      // lineJoin :\n      // lineWidth :\n      generateLabels(chart) {\n        const datasets = chart.data.datasets;\n        const {labels: {usePointStyle, pointStyle, textAlign, color, useBorderRadius, borderRadius}} = chart.legend.options;\n\n        return chart._getSortedDatasetMetas().map((meta) => {\n          const style = meta.controller.getStyle(usePointStyle ? 0 : undefined);\n          const borderWidth = toPadding(style.borderWidth);\n\n          return {\n            text: datasets[meta.index].label,\n            fillStyle: style.backgroundColor,\n            fontColor: color,\n            hidden: !meta.visible,\n            lineCap: style.borderCapStyle,\n            lineDash: style.borderDash,\n            lineDashOffset: style.borderDashOffset,\n            lineJoin: style.borderJoinStyle,\n            lineWidth: (borderWidth.width + borderWidth.height) / 4,\n            strokeStyle: style.borderColor,\n            pointStyle: pointStyle || style.pointStyle,\n            rotation: style.rotation,\n            textAlign: textAlign || style.textAlign,\n            borderRadius: useBorderRadius && (borderRadius || style.borderRadius),\n\n            // Below is extra data used for toggling the datasets\n            datasetIndex: meta.index\n          };\n        }, this);\n      }\n    },\n\n    title: {\n      color: (ctx) => ctx.chart.options.color,\n      display: false,\n      position: 'center',\n      text: '',\n    }\n  },\n\n  descriptors: {\n    _scriptable: (name) => !name.startsWith('on'),\n    labels: {\n      _scriptable: (name) => !['generateLabels', 'filter', 'sort'].includes(name),\n    }\n  },\n};\n","import {Title} from './plugin.title.js';\nimport layouts from '../core/core.layouts.js';\n\nconst map = new WeakMap();\n\nexport default {\n  id: 'subtitle',\n\n  start(chart, _args, options) {\n    const title = new Title({\n      ctx: chart.ctx,\n      options,\n      chart\n    });\n\n    layouts.configure(chart, title, options);\n    layouts.addBox(chart, title);\n    map.set(chart, title);\n  },\n\n  stop(chart) {\n    layouts.removeBox(chart, map.get(chart));\n    map.delete(chart);\n  },\n\n  beforeUpdate(chart, _args, options) {\n    const title = map.get(chart);\n    layouts.configure(chart, title, options);\n    title.options = options;\n  },\n\n  defaults: {\n    align: 'center',\n    display: false,\n    font: {\n      weight: 'normal',\n    },\n    fullSize: true,\n    padding: 0,\n    position: 'top',\n    text: '',\n    weight: 1500         // by default greater than legend (1000) and smaller than title (2000)\n  },\n\n  defaultRoutes: {\n    color: 'color'\n  },\n\n  descriptors: {\n    _scriptable: true,\n    _indexable: false,\n  },\n};\n","import Animations from '../core/core.animations.js';\nimport Element from '../core/core.element.js';\nimport {addRoundedRectPath} from '../helpers/helpers.canvas.js';\nimport {each, noop, isNullOrUndef, isArray, _elementsEqual, isObject} from '../helpers/helpers.core.js';\nimport {toFont, toPadding, toTRBLCorners} from '../helpers/helpers.options.js';\nimport {getRtlAdapter, overrideTextDirection, restoreTextDirection} from '../helpers/helpers.rtl.js';\nimport {distanceBetweenPoints, _limitValue} from '../helpers/helpers.math.js';\nimport {createContext, drawPoint} from '../helpers/index.js';\n\n/**\n * @typedef { import('../platform/platform.base.js').Chart } Chart\n * @typedef { import('../types/index.js').ChartEvent } ChartEvent\n * @typedef { import('../types/index.js').ActiveElement } ActiveElement\n * @typedef { import('../core/core.interaction.js').InteractionItem } InteractionItem\n */\n\nconst positioners = {\n  /**\n\t * Average mode places the tooltip at the average position of the elements shown\n\t */\n  average(items) {\n    if (!items.length) {\n      return false;\n    }\n\n    let i, len;\n    let x = 0;\n    let y = 0;\n    let count = 0;\n\n    for (i = 0, len = items.length; i < len; ++i) {\n      const el = items[i].element;\n      if (el && el.hasValue()) {\n        const pos = el.tooltipPosition();\n        x += pos.x;\n        y += pos.y;\n        ++count;\n      }\n    }\n\n    return {\n      x: x / count,\n      y: y / count\n    };\n  },\n\n  /**\n\t * Gets the tooltip position nearest of the item nearest to the event position\n\t */\n  nearest(items, eventPosition) {\n    if (!items.length) {\n      return false;\n    }\n\n    let x = eventPosition.x;\n    let y = eventPosition.y;\n    let minDistance = Number.POSITIVE_INFINITY;\n    let i, len, nearestElement;\n\n    for (i = 0, len = items.length; i < len; ++i) {\n      const el = items[i].element;\n      if (el && el.hasValue()) {\n        const center = el.getCenterPoint();\n        const d = distanceBetweenPoints(eventPosition, center);\n\n        if (d < minDistance) {\n          minDistance = d;\n          nearestElement = el;\n        }\n      }\n    }\n\n    if (nearestElement) {\n      const tp = nearestElement.tooltipPosition();\n      x = tp.x;\n      y = tp.y;\n    }\n\n    return {\n      x,\n      y\n    };\n  }\n};\n\n// Helper to push or concat based on if the 2nd parameter is an array or not\nfunction pushOrConcat(base, toPush) {\n  if (toPush) {\n    if (isArray(toPush)) {\n      // base = base.concat(toPush);\n      Array.prototype.push.apply(base, toPush);\n    } else {\n      base.push(toPush);\n    }\n  }\n\n  return base;\n}\n\n/**\n * Returns array of strings split by newline\n * @param {*} str - The value to split by newline.\n * @returns {string|string[]} value if newline present - Returned from String split() method\n * @function\n */\nfunction splitNewlines(str) {\n  if ((typeof str === 'string' || str instanceof String) && str.indexOf('\\n') > -1) {\n    return str.split('\\n');\n  }\n  return str;\n}\n\n\n/**\n * Private helper to create a tooltip item model\n * @param {Chart} chart\n * @param {ActiveElement} item - {element, index, datasetIndex} to create the tooltip item for\n * @return new tooltip item\n */\nfunction createTooltipItem(chart, item) {\n  const {element, datasetIndex, index} = item;\n  const controller = chart.getDatasetMeta(datasetIndex).controller;\n  const {label, value} = controller.getLabelAndValue(index);\n\n  return {\n    chart,\n    label,\n    parsed: controller.getParsed(index),\n    raw: chart.data.datasets[datasetIndex].data[index],\n    formattedValue: value,\n    dataset: controller.getDataset(),\n    dataIndex: index,\n    datasetIndex,\n    element\n  };\n}\n\n/**\n * Get the size of the tooltip\n */\nfunction getTooltipSize(tooltip, options) {\n  const ctx = tooltip.chart.ctx;\n  const {body, footer, title} = tooltip;\n  const {boxWidth, boxHeight} = options;\n  const bodyFont = toFont(options.bodyFont);\n  const titleFont = toFont(options.titleFont);\n  const footerFont = toFont(options.footerFont);\n  const titleLineCount = title.length;\n  const footerLineCount = footer.length;\n  const bodyLineItemCount = body.length;\n\n  const padding = toPadding(options.padding);\n  let height = padding.height;\n  let width = 0;\n\n  // Count of all lines in the body\n  let combinedBodyLength = body.reduce((count, bodyItem) => count + bodyItem.before.length + bodyItem.lines.length + bodyItem.after.length, 0);\n  combinedBodyLength += tooltip.beforeBody.length + tooltip.afterBody.length;\n\n  if (titleLineCount) {\n    height += titleLineCount * titleFont.lineHeight\n\t\t\t+ (titleLineCount - 1) * options.titleSpacing\n\t\t\t+ options.titleMarginBottom;\n  }\n  if (combinedBodyLength) {\n    // Body lines may include some extra height depending on boxHeight\n    const bodyLineHeight = options.displayColors ? Math.max(boxHeight, bodyFont.lineHeight) : bodyFont.lineHeight;\n    height += bodyLineItemCount * bodyLineHeight\n\t\t\t+ (combinedBodyLength - bodyLineItemCount) * bodyFont.lineHeight\n\t\t\t+ (combinedBodyLength - 1) * options.bodySpacing;\n  }\n  if (footerLineCount) {\n    height += options.footerMarginTop\n\t\t\t+ footerLineCount * footerFont.lineHeight\n\t\t\t+ (footerLineCount - 1) * options.footerSpacing;\n  }\n\n  // Title width\n  let widthPadding = 0;\n  const maxLineWidth = function(line) {\n    width = Math.max(width, ctx.measureText(line).width + widthPadding);\n  };\n\n  ctx.save();\n\n  ctx.font = titleFont.string;\n  each(tooltip.title, maxLineWidth);\n\n  // Body width\n  ctx.font = bodyFont.string;\n  each(tooltip.beforeBody.concat(tooltip.afterBody), maxLineWidth);\n\n  // Body lines may include some extra width due to the color box\n  widthPadding = options.displayColors ? (boxWidth + 2 + options.boxPadding) : 0;\n  each(body, (bodyItem) => {\n    each(bodyItem.before, maxLineWidth);\n    each(bodyItem.lines, maxLineWidth);\n    each(bodyItem.after, maxLineWidth);\n  });\n\n  // Reset back to 0\n  widthPadding = 0;\n\n  // Footer width\n  ctx.font = footerFont.string;\n  each(tooltip.footer, maxLineWidth);\n\n  ctx.restore();\n\n  // Add padding\n  width += padding.width;\n\n  return {width, height};\n}\n\nfunction determineYAlign(chart, size) {\n  const {y, height} = size;\n\n  if (y < height / 2) {\n    return 'top';\n  } else if (y > (chart.height - height / 2)) {\n    return 'bottom';\n  }\n  return 'center';\n}\n\nfunction doesNotFitWithAlign(xAlign, chart, options, size) {\n  const {x, width} = size;\n  const caret = options.caretSize + options.caretPadding;\n  if (xAlign === 'left' && x + width + caret > chart.width) {\n    return true;\n  }\n\n  if (xAlign === 'right' && x - width - caret < 0) {\n    return true;\n  }\n}\n\nfunction determineXAlign(chart, options, size, yAlign) {\n  const {x, width} = size;\n  const {width: chartWidth, chartArea: {left, right}} = chart;\n  let xAlign = 'center';\n\n  if (yAlign === 'center') {\n    xAlign = x <= (left + right) / 2 ? 'left' : 'right';\n  } else if (x <= width / 2) {\n    xAlign = 'left';\n  } else if (x >= chartWidth - width / 2) {\n    xAlign = 'right';\n  }\n\n  if (doesNotFitWithAlign(xAlign, chart, options, size)) {\n    xAlign = 'center';\n  }\n\n  return xAlign;\n}\n\n/**\n * Helper to get the alignment of a tooltip given the size\n */\nfunction determineAlignment(chart, options, size) {\n  const yAlign = size.yAlign || options.yAlign || determineYAlign(chart, size);\n\n  return {\n    xAlign: size.xAlign || options.xAlign || determineXAlign(chart, options, size, yAlign),\n    yAlign\n  };\n}\n\nfunction alignX(size, xAlign) {\n  let {x, width} = size;\n  if (xAlign === 'right') {\n    x -= width;\n  } else if (xAlign === 'center') {\n    x -= (width / 2);\n  }\n  return x;\n}\n\nfunction alignY(size, yAlign, paddingAndSize) {\n  // eslint-disable-next-line prefer-const\n  let {y, height} = size;\n  if (yAlign === 'top') {\n    y += paddingAndSize;\n  } else if (yAlign === 'bottom') {\n    y -= height + paddingAndSize;\n  } else {\n    y -= (height / 2);\n  }\n  return y;\n}\n\n/**\n * Helper to get the location a tooltip needs to be placed at given the initial position (via the vm) and the size and alignment\n */\nfunction getBackgroundPoint(options, size, alignment, chart) {\n  const {caretSize, caretPadding, cornerRadius} = options;\n  const {xAlign, yAlign} = alignment;\n  const paddingAndSize = caretSize + caretPadding;\n  const {topLeft, topRight, bottomLeft, bottomRight} = toTRBLCorners(cornerRadius);\n\n  let x = alignX(size, xAlign);\n  const y = alignY(size, yAlign, paddingAndSize);\n\n  if (yAlign === 'center') {\n    if (xAlign === 'left') {\n      x += paddingAndSize;\n    } else if (xAlign === 'right') {\n      x -= paddingAndSize;\n    }\n  } else if (xAlign === 'left') {\n    x -= Math.max(topLeft, bottomLeft) + caretSize;\n  } else if (xAlign === 'right') {\n    x += Math.max(topRight, bottomRight) + caretSize;\n  }\n\n  return {\n    x: _limitValue(x, 0, chart.width - size.width),\n    y: _limitValue(y, 0, chart.height - size.height)\n  };\n}\n\nfunction getAlignedX(tooltip, align, options) {\n  const padding = toPadding(options.padding);\n\n  return align === 'center'\n    ? tooltip.x + tooltip.width / 2\n    : align === 'right'\n      ? tooltip.x + tooltip.width - padding.right\n      : tooltip.x + padding.left;\n}\n\n/**\n * Helper to build before and after body lines\n */\nfunction getBeforeAfterBodyLines(callback) {\n  return pushOrConcat([], splitNewlines(callback));\n}\n\nfunction createTooltipContext(parent, tooltip, tooltipItems) {\n  return createContext(parent, {\n    tooltip,\n    tooltipItems,\n    type: 'tooltip'\n  });\n}\n\nfunction overrideCallbacks(callbacks, context) {\n  const override = context && context.dataset && context.dataset.tooltip && context.dataset.tooltip.callbacks;\n  return override ? callbacks.override(override) : callbacks;\n}\n\nconst defaultCallbacks = {\n  // Args are: (tooltipItems, data)\n  beforeTitle: noop,\n  title(tooltipItems) {\n    if (tooltipItems.length > 0) {\n      const item = tooltipItems[0];\n      const labels = item.chart.data.labels;\n      const labelCount = labels ? labels.length : 0;\n\n      if (this && this.options && this.options.mode === 'dataset') {\n        return item.dataset.label || '';\n      } else if (item.label) {\n        return item.label;\n      } else if (labelCount > 0 && item.dataIndex < labelCount) {\n        return labels[item.dataIndex];\n      }\n    }\n\n    return '';\n  },\n  afterTitle: noop,\n\n  // Args are: (tooltipItems, data)\n  beforeBody: noop,\n\n  // Args are: (tooltipItem, data)\n  beforeLabel: noop,\n  label(tooltipItem) {\n    if (this && this.options && this.options.mode === 'dataset') {\n      return tooltipItem.label + ': ' + tooltipItem.formattedValue || tooltipItem.formattedValue;\n    }\n\n    let label = tooltipItem.dataset.label || '';\n\n    if (label) {\n      label += ': ';\n    }\n    const value = tooltipItem.formattedValue;\n    if (!isNullOrUndef(value)) {\n      label += value;\n    }\n    return label;\n  },\n  labelColor(tooltipItem) {\n    const meta = tooltipItem.chart.getDatasetMeta(tooltipItem.datasetIndex);\n    const options = meta.controller.getStyle(tooltipItem.dataIndex);\n    return {\n      borderColor: options.borderColor,\n      backgroundColor: options.backgroundColor,\n      borderWidth: options.borderWidth,\n      borderDash: options.borderDash,\n      borderDashOffset: options.borderDashOffset,\n      borderRadius: 0,\n    };\n  },\n  labelTextColor() {\n    return this.options.bodyColor;\n  },\n  labelPointStyle(tooltipItem) {\n    const meta = tooltipItem.chart.getDatasetMeta(tooltipItem.datasetIndex);\n    const options = meta.controller.getStyle(tooltipItem.dataIndex);\n    return {\n      pointStyle: options.pointStyle,\n      rotation: options.rotation,\n    };\n  },\n  afterLabel: noop,\n\n  // Args are: (tooltipItems, data)\n  afterBody: noop,\n\n  // Args are: (tooltipItems, data)\n  beforeFooter: noop,\n  footer: noop,\n  afterFooter: noop\n};\n\n/**\n * Invoke callback from object with context and arguments.\n * If callback returns `undefined`, then will be invoked default callback.\n * @param {Record<keyof typeof defaultCallbacks, Function>} callbacks\n * @param {keyof typeof defaultCallbacks} name\n * @param {*} ctx\n * @param {*} arg\n * @returns {any}\n */\nfunction invokeCallbackWithFallback(callbacks, name, ctx, arg) {\n  const result = callbacks[name].call(ctx, arg);\n\n  if (typeof result === 'undefined') {\n    return defaultCallbacks[name].call(ctx, arg);\n  }\n\n  return result;\n}\n\nexport class Tooltip extends Element {\n\n  /**\n   * @namespace Chart.Tooltip.positioners\n   */\n  static positioners = positioners;\n\n  constructor(config) {\n    super();\n\n    this.opacity = 0;\n    this._active = [];\n    this._eventPosition = undefined;\n    this._size = undefined;\n    this._cachedAnimations = undefined;\n    this._tooltipItems = [];\n    this.$animations = undefined;\n    this.$context = undefined;\n    this.chart = config.chart;\n    this.options = config.options;\n    this.dataPoints = undefined;\n    this.title = undefined;\n    this.beforeBody = undefined;\n    this.body = undefined;\n    this.afterBody = undefined;\n    this.footer = undefined;\n    this.xAlign = undefined;\n    this.yAlign = undefined;\n    this.x = undefined;\n    this.y = undefined;\n    this.height = undefined;\n    this.width = undefined;\n    this.caretX = undefined;\n    this.caretY = undefined;\n    // TODO: V4, make this private, rename to `_labelStyles`, and combine with `labelPointStyles`\n    // and `labelTextColors` to create a single variable\n    this.labelColors = undefined;\n    this.labelPointStyles = undefined;\n    this.labelTextColors = undefined;\n  }\n\n  initialize(options) {\n    this.options = options;\n    this._cachedAnimations = undefined;\n    this.$context = undefined;\n  }\n\n  /**\n\t * @private\n\t */\n  _resolveAnimations() {\n    const cached = this._cachedAnimations;\n\n    if (cached) {\n      return cached;\n    }\n\n    const chart = this.chart;\n    const options = this.options.setContext(this.getContext());\n    const opts = options.enabled && chart.options.animation && options.animations;\n    const animations = new Animations(this.chart, opts);\n    if (opts._cacheable) {\n      this._cachedAnimations = Object.freeze(animations);\n    }\n\n    return animations;\n  }\n\n  /**\n\t * @protected\n\t */\n  getContext() {\n    return this.$context ||\n\t\t\t(this.$context = createTooltipContext(this.chart.getContext(), this, this._tooltipItems));\n  }\n\n  getTitle(context, options) {\n    const {callbacks} = options;\n\n    const beforeTitle = invokeCallbackWithFallback(callbacks, 'beforeTitle', this, context);\n    const title = invokeCallbackWithFallback(callbacks, 'title', this, context);\n    const afterTitle = invokeCallbackWithFallback(callbacks, 'afterTitle', this, context);\n\n    let lines = [];\n    lines = pushOrConcat(lines, splitNewlines(beforeTitle));\n    lines = pushOrConcat(lines, splitNewlines(title));\n    lines = pushOrConcat(lines, splitNewlines(afterTitle));\n\n    return lines;\n  }\n\n  getBeforeBody(tooltipItems, options) {\n    return getBeforeAfterBodyLines(\n      invokeCallbackWithFallback(options.callbacks, 'beforeBody', this, tooltipItems)\n    );\n  }\n\n  getBody(tooltipItems, options) {\n    const {callbacks} = options;\n    const bodyItems = [];\n\n    each(tooltipItems, (context) => {\n      const bodyItem = {\n        before: [],\n        lines: [],\n        after: []\n      };\n      const scoped = overrideCallbacks(callbacks, context);\n      pushOrConcat(bodyItem.before, splitNewlines(invokeCallbackWithFallback(scoped, 'beforeLabel', this, context)));\n      pushOrConcat(bodyItem.lines, invokeCallbackWithFallback(scoped, 'label', this, context));\n      pushOrConcat(bodyItem.after, splitNewlines(invokeCallbackWithFallback(scoped, 'afterLabel', this, context)));\n\n      bodyItems.push(bodyItem);\n    });\n\n    return bodyItems;\n  }\n\n  getAfterBody(tooltipItems, options) {\n    return getBeforeAfterBodyLines(\n      invokeCallbackWithFallback(options.callbacks, 'afterBody', this, tooltipItems)\n    );\n  }\n\n  // Get the footer and beforeFooter and afterFooter lines\n  getFooter(tooltipItems, options) {\n    const {callbacks} = options;\n\n    const beforeFooter = invokeCallbackWithFallback(callbacks, 'beforeFooter', this, tooltipItems);\n    const footer = invokeCallbackWithFallback(callbacks, 'footer', this, tooltipItems);\n    const afterFooter = invokeCallbackWithFallback(callbacks, 'afterFooter', this, tooltipItems);\n\n    let lines = [];\n    lines = pushOrConcat(lines, splitNewlines(beforeFooter));\n    lines = pushOrConcat(lines, splitNewlines(footer));\n    lines = pushOrConcat(lines, splitNewlines(afterFooter));\n\n    return lines;\n  }\n\n  /**\n\t * @private\n\t */\n  _createItems(options) {\n    const active = this._active;\n    const data = this.chart.data;\n    const labelColors = [];\n    const labelPointStyles = [];\n    const labelTextColors = [];\n    let tooltipItems = [];\n    let i, len;\n\n    for (i = 0, len = active.length; i < len; ++i) {\n      tooltipItems.push(createTooltipItem(this.chart, active[i]));\n    }\n\n    // If the user provided a filter function, use it to modify the tooltip items\n    if (options.filter) {\n      tooltipItems = tooltipItems.filter((element, index, array) => options.filter(element, index, array, data));\n    }\n\n    // If the user provided a sorting function, use it to modify the tooltip items\n    if (options.itemSort) {\n      tooltipItems = tooltipItems.sort((a, b) => options.itemSort(a, b, data));\n    }\n\n    // Determine colors for boxes\n    each(tooltipItems, (context) => {\n      const scoped = overrideCallbacks(options.callbacks, context);\n      labelColors.push(invokeCallbackWithFallback(scoped, 'labelColor', this, context));\n      labelPointStyles.push(invokeCallbackWithFallback(scoped, 'labelPointStyle', this, context));\n      labelTextColors.push(invokeCallbackWithFallback(scoped, 'labelTextColor', this, context));\n    });\n\n    this.labelColors = labelColors;\n    this.labelPointStyles = labelPointStyles;\n    this.labelTextColors = labelTextColors;\n    this.dataPoints = tooltipItems;\n    return tooltipItems;\n  }\n\n  update(changed, replay) {\n    const options = this.options.setContext(this.getContext());\n    const active = this._active;\n    let properties;\n    let tooltipItems = [];\n\n    if (!active.length) {\n      if (this.opacity !== 0) {\n        properties = {\n          opacity: 0\n        };\n      }\n    } else {\n      const position = positioners[options.position].call(this, active, this._eventPosition);\n      tooltipItems = this._createItems(options);\n\n      this.title = this.getTitle(tooltipItems, options);\n      this.beforeBody = this.getBeforeBody(tooltipItems, options);\n      this.body = this.getBody(tooltipItems, options);\n      this.afterBody = this.getAfterBody(tooltipItems, options);\n      this.footer = this.getFooter(tooltipItems, options);\n\n      const size = this._size = getTooltipSize(this, options);\n      const positionAndSize = Object.assign({}, position, size);\n      const alignment = determineAlignment(this.chart, options, positionAndSize);\n      const backgroundPoint = getBackgroundPoint(options, positionAndSize, alignment, this.chart);\n\n      this.xAlign = alignment.xAlign;\n      this.yAlign = alignment.yAlign;\n\n      properties = {\n        opacity: 1,\n        x: backgroundPoint.x,\n        y: backgroundPoint.y,\n        width: size.width,\n        height: size.height,\n        caretX: position.x,\n        caretY: position.y\n      };\n    }\n\n    this._tooltipItems = tooltipItems;\n    this.$context = undefined;\n\n    if (properties) {\n      this._resolveAnimations().update(this, properties);\n    }\n\n    if (changed && options.external) {\n      options.external.call(this, {chart: this.chart, tooltip: this, replay});\n    }\n  }\n\n  drawCaret(tooltipPoint, ctx, size, options) {\n    const caretPosition = this.getCaretPosition(tooltipPoint, size, options);\n\n    ctx.lineTo(caretPosition.x1, caretPosition.y1);\n    ctx.lineTo(caretPosition.x2, caretPosition.y2);\n    ctx.lineTo(caretPosition.x3, caretPosition.y3);\n  }\n\n  getCaretPosition(tooltipPoint, size, options) {\n    const {xAlign, yAlign} = this;\n    const {caretSize, cornerRadius} = options;\n    const {topLeft, topRight, bottomLeft, bottomRight} = toTRBLCorners(cornerRadius);\n    const {x: ptX, y: ptY} = tooltipPoint;\n    const {width, height} = size;\n    let x1, x2, x3, y1, y2, y3;\n\n    if (yAlign === 'center') {\n      y2 = ptY + (height / 2);\n\n      if (xAlign === 'left') {\n        x1 = ptX;\n        x2 = x1 - caretSize;\n\n        // Left draws bottom -> top, this y1 is on the bottom\n        y1 = y2 + caretSize;\n        y3 = y2 - caretSize;\n      } else {\n        x1 = ptX + width;\n        x2 = x1 + caretSize;\n\n        // Right draws top -> bottom, thus y1 is on the top\n        y1 = y2 - caretSize;\n        y3 = y2 + caretSize;\n      }\n\n      x3 = x1;\n    } else {\n      if (xAlign === 'left') {\n        x2 = ptX + Math.max(topLeft, bottomLeft) + (caretSize);\n      } else if (xAlign === 'right') {\n        x2 = ptX + width - Math.max(topRight, bottomRight) - caretSize;\n      } else {\n        x2 = this.caretX;\n      }\n\n      if (yAlign === 'top') {\n        y1 = ptY;\n        y2 = y1 - caretSize;\n\n        // Top draws left -> right, thus x1 is on the left\n        x1 = x2 - caretSize;\n        x3 = x2 + caretSize;\n      } else {\n        y1 = ptY + height;\n        y2 = y1 + caretSize;\n\n        // Bottom draws right -> left, thus x1 is on the right\n        x1 = x2 + caretSize;\n        x3 = x2 - caretSize;\n      }\n      y3 = y1;\n    }\n    return {x1, x2, x3, y1, y2, y3};\n  }\n\n  drawTitle(pt, ctx, options) {\n    const title = this.title;\n    const length = title.length;\n    let titleFont, titleSpacing, i;\n\n    if (length) {\n      const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width);\n\n      pt.x = getAlignedX(this, options.titleAlign, options);\n\n      ctx.textAlign = rtlHelper.textAlign(options.titleAlign);\n      ctx.textBaseline = 'middle';\n\n      titleFont = toFont(options.titleFont);\n      titleSpacing = options.titleSpacing;\n\n      ctx.fillStyle = options.titleColor;\n      ctx.font = titleFont.string;\n\n      for (i = 0; i < length; ++i) {\n        ctx.fillText(title[i], rtlHelper.x(pt.x), pt.y + titleFont.lineHeight / 2);\n        pt.y += titleFont.lineHeight + titleSpacing; // Line Height and spacing\n\n        if (i + 1 === length) {\n          pt.y += options.titleMarginBottom - titleSpacing; // If Last, add margin, remove spacing\n        }\n      }\n    }\n  }\n\n  /**\n\t * @private\n\t */\n  _drawColorBox(ctx, pt, i, rtlHelper, options) {\n    const labelColor = this.labelColors[i];\n    const labelPointStyle = this.labelPointStyles[i];\n    const {boxHeight, boxWidth} = options;\n    const bodyFont = toFont(options.bodyFont);\n    const colorX = getAlignedX(this, 'left', options);\n    const rtlColorX = rtlHelper.x(colorX);\n    const yOffSet = boxHeight < bodyFont.lineHeight ? (bodyFont.lineHeight - boxHeight) / 2 : 0;\n    const colorY = pt.y + yOffSet;\n\n    if (options.usePointStyle) {\n      const drawOptions = {\n        radius: Math.min(boxWidth, boxHeight) / 2, // fit the circle in the box\n        pointStyle: labelPointStyle.pointStyle,\n        rotation: labelPointStyle.rotation,\n        borderWidth: 1\n      };\n      // Recalculate x and y for drawPoint() because its expecting\n      // x and y to be center of figure (instead of top left)\n      const centerX = rtlHelper.leftForLtr(rtlColorX, boxWidth) + boxWidth / 2;\n      const centerY = colorY + boxHeight / 2;\n\n      // Fill the point with white so that colours merge nicely if the opacity is < 1\n      ctx.strokeStyle = options.multiKeyBackground;\n      ctx.fillStyle = options.multiKeyBackground;\n      drawPoint(ctx, drawOptions, centerX, centerY);\n\n      // Draw the point\n      ctx.strokeStyle = labelColor.borderColor;\n      ctx.fillStyle = labelColor.backgroundColor;\n      drawPoint(ctx, drawOptions, centerX, centerY);\n    } else {\n      // Border\n      ctx.lineWidth = isObject(labelColor.borderWidth) ? Math.max(...Object.values(labelColor.borderWidth)) : (labelColor.borderWidth || 1); // TODO, v4 remove fallback\n      ctx.strokeStyle = labelColor.borderColor;\n      ctx.setLineDash(labelColor.borderDash || []);\n      ctx.lineDashOffset = labelColor.borderDashOffset || 0;\n\n      // Fill a white rect so that colours merge nicely if the opacity is < 1\n      const outerX = rtlHelper.leftForLtr(rtlColorX, boxWidth);\n      const innerX = rtlHelper.leftForLtr(rtlHelper.xPlus(rtlColorX, 1), boxWidth - 2);\n      const borderRadius = toTRBLCorners(labelColor.borderRadius);\n\n      if (Object.values(borderRadius).some(v => v !== 0)) {\n        ctx.beginPath();\n        ctx.fillStyle = options.multiKeyBackground;\n        addRoundedRectPath(ctx, {\n          x: outerX,\n          y: colorY,\n          w: boxWidth,\n          h: boxHeight,\n          radius: borderRadius,\n        });\n        ctx.fill();\n        ctx.stroke();\n\n        // Inner square\n        ctx.fillStyle = labelColor.backgroundColor;\n        ctx.beginPath();\n        addRoundedRectPath(ctx, {\n          x: innerX,\n          y: colorY + 1,\n          w: boxWidth - 2,\n          h: boxHeight - 2,\n          radius: borderRadius,\n        });\n        ctx.fill();\n      } else {\n        // Normal rect\n        ctx.fillStyle = options.multiKeyBackground;\n        ctx.fillRect(outerX, colorY, boxWidth, boxHeight);\n        ctx.strokeRect(outerX, colorY, boxWidth, boxHeight);\n        // Inner square\n        ctx.fillStyle = labelColor.backgroundColor;\n        ctx.fillRect(innerX, colorY + 1, boxWidth - 2, boxHeight - 2);\n      }\n    }\n\n    // restore fillStyle\n    ctx.fillStyle = this.labelTextColors[i];\n  }\n\n  drawBody(pt, ctx, options) {\n    const {body} = this;\n    const {bodySpacing, bodyAlign, displayColors, boxHeight, boxWidth, boxPadding} = options;\n    const bodyFont = toFont(options.bodyFont);\n    let bodyLineHeight = bodyFont.lineHeight;\n    let xLinePadding = 0;\n\n    const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width);\n\n    const fillLineOfText = function(line) {\n      ctx.fillText(line, rtlHelper.x(pt.x + xLinePadding), pt.y + bodyLineHeight / 2);\n      pt.y += bodyLineHeight + bodySpacing;\n    };\n\n    const bodyAlignForCalculation = rtlHelper.textAlign(bodyAlign);\n    let bodyItem, textColor, lines, i, j, ilen, jlen;\n\n    ctx.textAlign = bodyAlign;\n    ctx.textBaseline = 'middle';\n    ctx.font = bodyFont.string;\n\n    pt.x = getAlignedX(this, bodyAlignForCalculation, options);\n\n    // Before body lines\n    ctx.fillStyle = options.bodyColor;\n    each(this.beforeBody, fillLineOfText);\n\n    xLinePadding = displayColors && bodyAlignForCalculation !== 'right'\n      ? bodyAlign === 'center' ? (boxWidth / 2 + boxPadding) : (boxWidth + 2 + boxPadding)\n      : 0;\n\n    // Draw body lines now\n    for (i = 0, ilen = body.length; i < ilen; ++i) {\n      bodyItem = body[i];\n      textColor = this.labelTextColors[i];\n\n      ctx.fillStyle = textColor;\n      each(bodyItem.before, fillLineOfText);\n\n      lines = bodyItem.lines;\n      // Draw Legend-like boxes if needed\n      if (displayColors && lines.length) {\n        this._drawColorBox(ctx, pt, i, rtlHelper, options);\n        bodyLineHeight = Math.max(bodyFont.lineHeight, boxHeight);\n      }\n\n      for (j = 0, jlen = lines.length; j < jlen; ++j) {\n        fillLineOfText(lines[j]);\n        // Reset for any lines that don't include colorbox\n        bodyLineHeight = bodyFont.lineHeight;\n      }\n\n      each(bodyItem.after, fillLineOfText);\n    }\n\n    // Reset back to 0 for after body\n    xLinePadding = 0;\n    bodyLineHeight = bodyFont.lineHeight;\n\n    // After body lines\n    each(this.afterBody, fillLineOfText);\n    pt.y -= bodySpacing; // Remove last body spacing\n  }\n\n  drawFooter(pt, ctx, options) {\n    const footer = this.footer;\n    const length = footer.length;\n    let footerFont, i;\n\n    if (length) {\n      const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width);\n\n      pt.x = getAlignedX(this, options.footerAlign, options);\n      pt.y += options.footerMarginTop;\n\n      ctx.textAlign = rtlHelper.textAlign(options.footerAlign);\n      ctx.textBaseline = 'middle';\n\n      footerFont = toFont(options.footerFont);\n\n      ctx.fillStyle = options.footerColor;\n      ctx.font = footerFont.string;\n\n      for (i = 0; i < length; ++i) {\n        ctx.fillText(footer[i], rtlHelper.x(pt.x), pt.y + footerFont.lineHeight / 2);\n        pt.y += footerFont.lineHeight + options.footerSpacing;\n      }\n    }\n  }\n\n  drawBackground(pt, ctx, tooltipSize, options) {\n    const {xAlign, yAlign} = this;\n    const {x, y} = pt;\n    const {width, height} = tooltipSize;\n    const {topLeft, topRight, bottomLeft, bottomRight} = toTRBLCorners(options.cornerRadius);\n\n    ctx.fillStyle = options.backgroundColor;\n    ctx.strokeStyle = options.borderColor;\n    ctx.lineWidth = options.borderWidth;\n\n    ctx.beginPath();\n    ctx.moveTo(x + topLeft, y);\n    if (yAlign === 'top') {\n      this.drawCaret(pt, ctx, tooltipSize, options);\n    }\n    ctx.lineTo(x + width - topRight, y);\n    ctx.quadraticCurveTo(x + width, y, x + width, y + topRight);\n    if (yAlign === 'center' && xAlign === 'right') {\n      this.drawCaret(pt, ctx, tooltipSize, options);\n    }\n    ctx.lineTo(x + width, y + height - bottomRight);\n    ctx.quadraticCurveTo(x + width, y + height, x + width - bottomRight, y + height);\n    if (yAlign === 'bottom') {\n      this.drawCaret(pt, ctx, tooltipSize, options);\n    }\n    ctx.lineTo(x + bottomLeft, y + height);\n    ctx.quadraticCurveTo(x, y + height, x, y + height - bottomLeft);\n    if (yAlign === 'center' && xAlign === 'left') {\n      this.drawCaret(pt, ctx, tooltipSize, options);\n    }\n    ctx.lineTo(x, y + topLeft);\n    ctx.quadraticCurveTo(x, y, x + topLeft, y);\n    ctx.closePath();\n\n    ctx.fill();\n\n    if (options.borderWidth > 0) {\n      ctx.stroke();\n    }\n  }\n\n  /**\n\t * Update x/y animation targets when _active elements are animating too\n\t * @private\n\t */\n  _updateAnimationTarget(options) {\n    const chart = this.chart;\n    const anims = this.$animations;\n    const animX = anims && anims.x;\n    const animY = anims && anims.y;\n    if (animX || animY) {\n      const position = positioners[options.position].call(this, this._active, this._eventPosition);\n      if (!position) {\n        return;\n      }\n      const size = this._size = getTooltipSize(this, options);\n      const positionAndSize = Object.assign({}, position, this._size);\n      const alignment = determineAlignment(chart, options, positionAndSize);\n      const point = getBackgroundPoint(options, positionAndSize, alignment, chart);\n      if (animX._to !== point.x || animY._to !== point.y) {\n        this.xAlign = alignment.xAlign;\n        this.yAlign = alignment.yAlign;\n        this.width = size.width;\n        this.height = size.height;\n        this.caretX = position.x;\n        this.caretY = position.y;\n        this._resolveAnimations().update(this, point);\n      }\n    }\n  }\n\n  /**\n   * Determine if the tooltip will draw anything\n   * @returns {boolean} True if the tooltip will render\n   */\n  _willRender() {\n    return !!this.opacity;\n  }\n\n  draw(ctx) {\n    const options = this.options.setContext(this.getContext());\n    let opacity = this.opacity;\n\n    if (!opacity) {\n      return;\n    }\n\n    this._updateAnimationTarget(options);\n\n    const tooltipSize = {\n      width: this.width,\n      height: this.height\n    };\n    const pt = {\n      x: this.x,\n      y: this.y\n    };\n\n    // IE11/Edge does not like very small opacities, so snap to 0\n    opacity = Math.abs(opacity) < 1e-3 ? 0 : opacity;\n\n    const padding = toPadding(options.padding);\n\n    // Truthy/falsey value for empty tooltip\n    const hasTooltipContent = this.title.length || this.beforeBody.length || this.body.length || this.afterBody.length || this.footer.length;\n\n    if (options.enabled && hasTooltipContent) {\n      ctx.save();\n      ctx.globalAlpha = opacity;\n\n      // Draw Background\n      this.drawBackground(pt, ctx, tooltipSize, options);\n\n      overrideTextDirection(ctx, options.textDirection);\n\n      pt.y += padding.top;\n\n      // Titles\n      this.drawTitle(pt, ctx, options);\n\n      // Body\n      this.drawBody(pt, ctx, options);\n\n      // Footer\n      this.drawFooter(pt, ctx, options);\n\n      restoreTextDirection(ctx, options.textDirection);\n\n      ctx.restore();\n    }\n  }\n\n  /**\n\t * Get active elements in the tooltip\n\t * @returns {Array} Array of elements that are active in the tooltip\n\t */\n  getActiveElements() {\n    return this._active || [];\n  }\n\n  /**\n\t * Set active elements in the tooltip\n\t * @param {array} activeElements Array of active datasetIndex/index pairs.\n\t * @param {object} eventPosition Synthetic event position used in positioning\n\t */\n  setActiveElements(activeElements, eventPosition) {\n    const lastActive = this._active;\n    const active = activeElements.map(({datasetIndex, index}) => {\n      const meta = this.chart.getDatasetMeta(datasetIndex);\n\n      if (!meta) {\n        throw new Error('Cannot find a dataset at index ' + datasetIndex);\n      }\n\n      return {\n        datasetIndex,\n        element: meta.data[index],\n        index,\n      };\n    });\n    const changed = !_elementsEqual(lastActive, active);\n    const positionChanged = this._positionChanged(active, eventPosition);\n\n    if (changed || positionChanged) {\n      this._active = active;\n      this._eventPosition = eventPosition;\n      this._ignoreReplayEvents = true;\n      this.update(true);\n    }\n  }\n\n  /**\n\t * Handle an event\n\t * @param {ChartEvent} e - The event to handle\n\t * @param {boolean} [replay] - This is a replayed event (from update)\n\t * @param {boolean} [inChartArea] - The event is inside chartArea\n\t * @returns {boolean} true if the tooltip changed\n\t */\n  handleEvent(e, replay, inChartArea = true) {\n    if (replay && this._ignoreReplayEvents) {\n      return false;\n    }\n    this._ignoreReplayEvents = false;\n\n    const options = this.options;\n    const lastActive = this._active || [];\n    const active = this._getActiveElements(e, lastActive, replay, inChartArea);\n\n    // When there are multiple items shown, but the tooltip position is nearest mode\n    // an update may need to be made because our position may have changed even though\n    // the items are the same as before.\n    const positionChanged = this._positionChanged(active, e);\n\n    // Remember Last Actives\n    const changed = replay || !_elementsEqual(active, lastActive) || positionChanged;\n\n    // Only handle target event on tooltip change\n    if (changed) {\n      this._active = active;\n\n      if (options.enabled || options.external) {\n        this._eventPosition = {\n          x: e.x,\n          y: e.y\n        };\n\n        this.update(true, replay);\n      }\n    }\n\n    return changed;\n  }\n\n  /**\n\t * Helper for determining the active elements for event\n\t * @param {ChartEvent} e - The event to handle\n\t * @param {InteractionItem[]} lastActive - Previously active elements\n\t * @param {boolean} [replay] - This is a replayed event (from update)\n\t * @param {boolean} [inChartArea] - The event is inside chartArea\n\t * @returns {InteractionItem[]} - Active elements\n\t * @private\n\t */\n  _getActiveElements(e, lastActive, replay, inChartArea) {\n    const options = this.options;\n\n    if (e.type === 'mouseout') {\n      return [];\n    }\n\n    if (!inChartArea) {\n      // Let user control the active elements outside chartArea. Eg. using Legend.\n      return lastActive;\n    }\n\n    // Find Active Elements for tooltips\n    const active = this.chart.getElementsAtEventForMode(e, options.mode, options, replay);\n\n    if (options.reverse) {\n      active.reverse();\n    }\n\n    return active;\n  }\n\n  /**\n\t * Determine if the active elements + event combination changes the\n\t * tooltip position\n\t * @param {array} active - Active elements\n\t * @param {ChartEvent} e - Event that triggered the position change\n\t * @returns {boolean} True if the position has changed\n\t */\n  _positionChanged(active, e) {\n    const {caretX, caretY, options} = this;\n    const position = positioners[options.position].call(this, active, e);\n    return position !== false && (caretX !== position.x || caretY !== position.y);\n  }\n}\n\nexport default {\n  id: 'tooltip',\n  _element: Tooltip,\n  positioners,\n\n  afterInit(chart, _args, options) {\n    if (options) {\n      chart.tooltip = new Tooltip({chart, options});\n    }\n  },\n\n  beforeUpdate(chart, _args, options) {\n    if (chart.tooltip) {\n      chart.tooltip.initialize(options);\n    }\n  },\n\n  reset(chart, _args, options) {\n    if (chart.tooltip) {\n      chart.tooltip.initialize(options);\n    }\n  },\n\n  afterDraw(chart) {\n    const tooltip = chart.tooltip;\n\n    if (tooltip && tooltip._willRender()) {\n      const args = {\n        tooltip\n      };\n\n      if (chart.notifyPlugins('beforeTooltipDraw', {...args, cancelable: true}) === false) {\n        return;\n      }\n\n      tooltip.draw(chart.ctx);\n\n      chart.notifyPlugins('afterTooltipDraw', args);\n    }\n  },\n\n  afterEvent(chart, args) {\n    if (chart.tooltip) {\n      // If the event is replayed from `update`, we should evaluate with the final positions.\n      const useFinalPosition = args.replay;\n      if (chart.tooltip.handleEvent(args.event, useFinalPosition, args.inChartArea)) {\n        // notify chart about the change, so it will render\n        args.changed = true;\n      }\n    }\n  },\n\n  defaults: {\n    enabled: true,\n    external: null,\n    position: 'average',\n    backgroundColor: 'rgba(0,0,0,0.8)',\n    titleColor: '#fff',\n    titleFont: {\n      weight: 'bold',\n    },\n    titleSpacing: 2,\n    titleMarginBottom: 6,\n    titleAlign: 'left',\n    bodyColor: '#fff',\n    bodySpacing: 2,\n    bodyFont: {\n    },\n    bodyAlign: 'left',\n    footerColor: '#fff',\n    footerSpacing: 2,\n    footerMarginTop: 6,\n    footerFont: {\n      weight: 'bold',\n    },\n    footerAlign: 'left',\n    padding: 6,\n    caretPadding: 2,\n    caretSize: 5,\n    cornerRadius: 6,\n    boxHeight: (ctx, opts) => opts.bodyFont.size,\n    boxWidth: (ctx, opts) => opts.bodyFont.size,\n    multiKeyBackground: '#fff',\n    displayColors: true,\n    boxPadding: 0,\n    borderColor: 'rgba(0,0,0,0)',\n    borderWidth: 0,\n    animation: {\n      duration: 400,\n      easing: 'easeOutQuart',\n    },\n    animations: {\n      numbers: {\n        type: 'number',\n        properties: ['x', 'y', 'width', 'height', 'caretX', 'caretY'],\n      },\n      opacity: {\n        easing: 'linear',\n        duration: 200\n      }\n    },\n    callbacks: defaultCallbacks\n  },\n\n  defaultRoutes: {\n    bodyFont: 'font',\n    footerFont: 'font',\n    titleFont: 'font'\n  },\n\n  descriptors: {\n    _scriptable: (name) => name !== 'filter' && name !== 'itemSort' && name !== 'external',\n    _indexable: false,\n    callbacks: {\n      _scriptable: false,\n      _indexable: false,\n    },\n    animation: {\n      _fallback: false\n    },\n    animations: {\n      _fallback: 'animation'\n    }\n  },\n\n  // Resolve additionally from `interaction` options and defaults.\n  additionalOptionScopes: ['interaction']\n};\n","import Scale from '../core/core.scale.js';\nimport {isNullOrUndef, valueOrDefault, _limitValue} from '../helpers/index.js';\n\nconst addIfString = (labels, raw, index, addedLabels) => {\n  if (typeof raw === 'string') {\n    index = labels.push(raw) - 1;\n    addedLabels.unshift({index, label: raw});\n  } else if (isNaN(raw)) {\n    index = null;\n  }\n  return index;\n};\n\nfunction findOrAddLabel(labels, raw, index, addedLabels) {\n  const first = labels.indexOf(raw);\n  if (first === -1) {\n    return addIfString(labels, raw, index, addedLabels);\n  }\n  const last = labels.lastIndexOf(raw);\n  return first !== last ? index : first;\n}\n\nconst validIndex = (index, max) => index === null ? null : _limitValue(Math.round(index), 0, max);\n\nfunction _getLabelForValue(value) {\n  const labels = this.getLabels();\n\n  if (value >= 0 && value < labels.length) {\n    return labels[value];\n  }\n  return value;\n}\n\nexport default class CategoryScale extends Scale {\n\n  static id = 'category';\n\n  /**\n   * @type {any}\n   */\n  static defaults = {\n    ticks: {\n      callback: _getLabelForValue\n    }\n  };\n\n  constructor(cfg) {\n    super(cfg);\n\n    /** @type {number} */\n    this._startValue = undefined;\n    this._valueRange = 0;\n    this._addedLabels = [];\n  }\n\n  init(scaleOptions) {\n    const added = this._addedLabels;\n    if (added.length) {\n      const labels = this.getLabels();\n      for (const {index, label} of added) {\n        if (labels[index] === label) {\n          labels.splice(index, 1);\n        }\n      }\n      this._addedLabels = [];\n    }\n    super.init(scaleOptions);\n  }\n\n  parse(raw, index) {\n    if (isNullOrUndef(raw)) {\n      return null;\n    }\n    const labels = this.getLabels();\n    index = isFinite(index) && labels[index] === raw ? index\n      : findOrAddLabel(labels, raw, valueOrDefault(index, raw), this._addedLabels);\n    return validIndex(index, labels.length - 1);\n  }\n\n  determineDataLimits() {\n    const {minDefined, maxDefined} = this.getUserBounds();\n    let {min, max} = this.getMinMax(true);\n\n    if (this.options.bounds === 'ticks') {\n      if (!minDefined) {\n        min = 0;\n      }\n      if (!maxDefined) {\n        max = this.getLabels().length - 1;\n      }\n    }\n\n    this.min = min;\n    this.max = max;\n  }\n\n  buildTicks() {\n    const min = this.min;\n    const max = this.max;\n    const offset = this.options.offset;\n    const ticks = [];\n    let labels = this.getLabels();\n\n    // If we are viewing some subset of labels, slice the original array\n    labels = (min === 0 && max === labels.length - 1) ? labels : labels.slice(min, max + 1);\n\n    this._valueRange = Math.max(labels.length - (offset ? 0 : 1), 1);\n    this._startValue = this.min - (offset ? 0.5 : 0);\n\n    for (let value = min; value <= max; value++) {\n      ticks.push({value});\n    }\n    return ticks;\n  }\n\n  getLabelForValue(value) {\n    return _getLabelForValue.call(this, value);\n  }\n\n  /**\n\t * @protected\n\t */\n  configure() {\n    super.configure();\n\n    if (!this.isHorizontal()) {\n      // For backward compatibility, vertical category scale reverse is inverted.\n      this._reversePixels = !this._reversePixels;\n    }\n  }\n\n  // Used to get data value locations. Value can either be an index or a numerical value\n  getPixelForValue(value) {\n    if (typeof value !== 'number') {\n      value = this.parse(value);\n    }\n\n    return value === null ? NaN : this.getPixelForDecimal((value - this._startValue) / this._valueRange);\n  }\n\n  // Must override base implementation because it calls getPixelForValue\n  // and category scale can have duplicate values\n  getPixelForTick(index) {\n    const ticks = this.ticks;\n    if (index < 0 || index > ticks.length - 1) {\n      return null;\n    }\n    return this.getPixelForValue(ticks[index].value);\n  }\n\n  getValueForPixel(pixel) {\n    return Math.round(this._startValue + this.getDecimalForPixel(pixel) * this._valueRange);\n  }\n\n  getBasePixel() {\n    return this.bottom;\n  }\n}\n","import {isNullOrUndef} from '../helpers/helpers.core.js';\nimport {almostEquals, almostWhole, niceNum, _decimalPlaces, _setMinAndMaxByKey, sign, toRadians} from '../helpers/helpers.math.js';\nimport Scale from '../core/core.scale.js';\nimport {formatNumber} from '../helpers/helpers.intl.js';\n\n/**\n * Generate a set of linear ticks for an axis\n * 1. If generationOptions.min, generationOptions.max, and generationOptions.step are defined:\n *    if (max - min) / step is an integer, ticks are generated as [min, min + step, ..., max]\n *    Note that the generationOptions.maxCount setting is respected in this scenario\n *\n * 2. If generationOptions.min, generationOptions.max, and generationOptions.count is defined\n *    spacing = (max - min) / count\n *    Ticks are generated as [min, min + spacing, ..., max]\n *\n * 3. If generationOptions.count is defined\n *    spacing = (niceMax - niceMin) / count\n *\n * 4. Compute optimal spacing of ticks using niceNum algorithm\n *\n * @param generationOptions the options used to generate the ticks\n * @param dataRange the range of the data\n * @returns {object[]} array of tick objects\n */\nfunction generateTicks(generationOptions, dataRange) {\n  const ticks = [];\n  // To get a \"nice\" value for the tick spacing, we will use the appropriately named\n  // \"nice number\" algorithm. See https://stackoverflow.com/questions/8506881/nice-label-algorithm-for-charts-with-minimum-ticks\n  // for details.\n\n  const MIN_SPACING = 1e-14;\n  const {bounds, step, min, max, precision, count, maxTicks, maxDigits, includeBounds} = generationOptions;\n  const unit = step || 1;\n  const maxSpaces = maxTicks - 1;\n  const {min: rmin, max: rmax} = dataRange;\n  const minDefined = !isNullOrUndef(min);\n  const maxDefined = !isNullOrUndef(max);\n  const countDefined = !isNullOrUndef(count);\n  const minSpacing = (rmax - rmin) / (maxDigits + 1);\n  let spacing = niceNum((rmax - rmin) / maxSpaces / unit) * unit;\n  let factor, niceMin, niceMax, numSpaces;\n\n  // Beyond MIN_SPACING floating point numbers being to lose precision\n  // such that we can't do the math necessary to generate ticks\n  if (spacing < MIN_SPACING && !minDefined && !maxDefined) {\n    return [{value: rmin}, {value: rmax}];\n  }\n\n  numSpaces = Math.ceil(rmax / spacing) - Math.floor(rmin / spacing);\n  if (numSpaces > maxSpaces) {\n    // If the calculated num of spaces exceeds maxNumSpaces, recalculate it\n    spacing = niceNum(numSpaces * spacing / maxSpaces / unit) * unit;\n  }\n\n  if (!isNullOrUndef(precision)) {\n    // If the user specified a precision, round to that number of decimal places\n    factor = Math.pow(10, precision);\n    spacing = Math.ceil(spacing * factor) / factor;\n  }\n\n  if (bounds === 'ticks') {\n    niceMin = Math.floor(rmin / spacing) * spacing;\n    niceMax = Math.ceil(rmax / spacing) * spacing;\n  } else {\n    niceMin = rmin;\n    niceMax = rmax;\n  }\n\n  if (minDefined && maxDefined && step && almostWhole((max - min) / step, spacing / 1000)) {\n    // Case 1: If min, max and stepSize are set and they make an evenly spaced scale use it.\n    // spacing = step;\n    // numSpaces = (max - min) / spacing;\n    // Note that we round here to handle the case where almostWhole translated an FP error\n    numSpaces = Math.round(Math.min((max - min) / spacing, maxTicks));\n    spacing = (max - min) / numSpaces;\n    niceMin = min;\n    niceMax = max;\n  } else if (countDefined) {\n    // Cases 2 & 3, we have a count specified. Handle optional user defined edges to the range.\n    // Sometimes these are no-ops, but it makes the code a lot clearer\n    // and when a user defined range is specified, we want the correct ticks\n    niceMin = minDefined ? min : niceMin;\n    niceMax = maxDefined ? max : niceMax;\n    numSpaces = count - 1;\n    spacing = (niceMax - niceMin) / numSpaces;\n  } else {\n    // Case 4\n    numSpaces = (niceMax - niceMin) / spacing;\n\n    // If very close to our rounded value, use it.\n    if (almostEquals(numSpaces, Math.round(numSpaces), spacing / 1000)) {\n      numSpaces = Math.round(numSpaces);\n    } else {\n      numSpaces = Math.ceil(numSpaces);\n    }\n  }\n\n  // The spacing will have changed in cases 1, 2, and 3 so the factor cannot be computed\n  // until this point\n  const decimalPlaces = Math.max(\n    _decimalPlaces(spacing),\n    _decimalPlaces(niceMin)\n  );\n  factor = Math.pow(10, isNullOrUndef(precision) ? decimalPlaces : precision);\n  niceMin = Math.round(niceMin * factor) / factor;\n  niceMax = Math.round(niceMax * factor) / factor;\n\n  let j = 0;\n  if (minDefined) {\n    if (includeBounds && niceMin !== min) {\n      ticks.push({value: min});\n\n      if (niceMin < min) {\n        j++; // Skip niceMin\n      }\n      // If the next nice tick is close to min, skip it\n      if (almostEquals(Math.round((niceMin + j * spacing) * factor) / factor, min, relativeLabelSize(min, minSpacing, generationOptions))) {\n        j++;\n      }\n    } else if (niceMin < min) {\n      j++;\n    }\n  }\n\n  for (; j < numSpaces; ++j) {\n    const tickValue = Math.round((niceMin + j * spacing) * factor) / factor;\n    if (maxDefined && tickValue > max) {\n      break;\n    }\n    ticks.push({value: tickValue});\n  }\n\n  if (maxDefined && includeBounds && niceMax !== max) {\n    // If the previous tick is too close to max, replace it with max, else add max\n    if (ticks.length && almostEquals(ticks[ticks.length - 1].value, max, relativeLabelSize(max, minSpacing, generationOptions))) {\n      ticks[ticks.length - 1].value = max;\n    } else {\n      ticks.push({value: max});\n    }\n  } else if (!maxDefined || niceMax === max) {\n    ticks.push({value: niceMax});\n  }\n\n  return ticks;\n}\n\nfunction relativeLabelSize(value, minSpacing, {horizontal, minRotation}) {\n  const rad = toRadians(minRotation);\n  const ratio = (horizontal ? Math.sin(rad) : Math.cos(rad)) || 0.001;\n  const length = 0.75 * minSpacing * ('' + value).length;\n  return Math.min(minSpacing / ratio, length);\n}\n\nexport default class LinearScaleBase extends Scale {\n\n  constructor(cfg) {\n    super(cfg);\n\n    /** @type {number} */\n    this.start = undefined;\n    /** @type {number} */\n    this.end = undefined;\n    /** @type {number} */\n    this._startValue = undefined;\n    /** @type {number} */\n    this._endValue = undefined;\n    this._valueRange = 0;\n  }\n\n  parse(raw, index) { // eslint-disable-line no-unused-vars\n    if (isNullOrUndef(raw)) {\n      return null;\n    }\n    if ((typeof raw === 'number' || raw instanceof Number) && !isFinite(+raw)) {\n      return null;\n    }\n\n    return +raw;\n  }\n\n  handleTickRangeOptions() {\n    const {beginAtZero} = this.options;\n    const {minDefined, maxDefined} = this.getUserBounds();\n    let {min, max} = this;\n\n    const setMin = v => (min = minDefined ? min : v);\n    const setMax = v => (max = maxDefined ? max : v);\n\n    if (beginAtZero) {\n      const minSign = sign(min);\n      const maxSign = sign(max);\n\n      if (minSign < 0 && maxSign < 0) {\n        setMax(0);\n      } else if (minSign > 0 && maxSign > 0) {\n        setMin(0);\n      }\n    }\n\n    if (min === max) {\n      let offset = max === 0 ? 1 : Math.abs(max * 0.05);\n\n      setMax(max + offset);\n\n      if (!beginAtZero) {\n        setMin(min - offset);\n      }\n    }\n    this.min = min;\n    this.max = max;\n  }\n\n  getTickLimit() {\n    const tickOpts = this.options.ticks;\n    // eslint-disable-next-line prefer-const\n    let {maxTicksLimit, stepSize} = tickOpts;\n    let maxTicks;\n\n    if (stepSize) {\n      maxTicks = Math.ceil(this.max / stepSize) - Math.floor(this.min / stepSize) + 1;\n      if (maxTicks > 1000) {\n        console.warn(`scales.${this.id}.ticks.stepSize: ${stepSize} would result generating up to ${maxTicks} ticks. Limiting to 1000.`);\n        maxTicks = 1000;\n      }\n    } else {\n      maxTicks = this.computeTickLimit();\n      maxTicksLimit = maxTicksLimit || 11;\n    }\n\n    if (maxTicksLimit) {\n      maxTicks = Math.min(maxTicksLimit, maxTicks);\n    }\n\n    return maxTicks;\n  }\n\n  /**\n\t * @protected\n\t */\n  computeTickLimit() {\n    return Number.POSITIVE_INFINITY;\n  }\n\n  buildTicks() {\n    const opts = this.options;\n    const tickOpts = opts.ticks;\n\n    // Figure out what the max number of ticks we can support it is based on the size of\n    // the axis area. For now, we say that the minimum tick spacing in pixels must be 40\n    // We also limit the maximum number of ticks to 11 which gives a nice 10 squares on\n    // the graph. Make sure we always have at least 2 ticks\n    let maxTicks = this.getTickLimit();\n    maxTicks = Math.max(2, maxTicks);\n\n    const numericGeneratorOptions = {\n      maxTicks,\n      bounds: opts.bounds,\n      min: opts.min,\n      max: opts.max,\n      precision: tickOpts.precision,\n      step: tickOpts.stepSize,\n      count: tickOpts.count,\n      maxDigits: this._maxDigits(),\n      horizontal: this.isHorizontal(),\n      minRotation: tickOpts.minRotation || 0,\n      includeBounds: tickOpts.includeBounds !== false\n    };\n    const dataRange = this._range || this;\n    const ticks = generateTicks(numericGeneratorOptions, dataRange);\n\n    // At this point, we need to update our max and min given the tick values,\n    // since we probably have expanded the range of the scale\n    if (opts.bounds === 'ticks') {\n      _setMinAndMaxByKey(ticks, this, 'value');\n    }\n\n    if (opts.reverse) {\n      ticks.reverse();\n\n      this.start = this.max;\n      this.end = this.min;\n    } else {\n      this.start = this.min;\n      this.end = this.max;\n    }\n\n    return ticks;\n  }\n\n  /**\n\t * @protected\n\t */\n  configure() {\n    const ticks = this.ticks;\n    let start = this.min;\n    let end = this.max;\n\n    super.configure();\n\n    if (this.options.offset && ticks.length) {\n      const offset = (end - start) / Math.max(ticks.length - 1, 1) / 2;\n      start -= offset;\n      end += offset;\n    }\n    this._startValue = start;\n    this._endValue = end;\n    this._valueRange = end - start;\n  }\n\n  getLabelForValue(value) {\n    return formatNumber(value, this.chart.options.locale, this.options.ticks.format);\n  }\n}\n","import {isFinite} from '../helpers/helpers.core.js';\nimport LinearScaleBase from './scale.linearbase.js';\nimport Ticks from '../core/core.ticks.js';\nimport {toRadians} from '../helpers/index.js';\n\nexport default class LinearScale extends LinearScaleBase {\n\n  static id = 'linear';\n\n  /**\n   * @type {any}\n   */\n  static defaults = {\n    ticks: {\n      callback: Ticks.formatters.numeric\n    }\n  };\n\n\n  determineDataLimits() {\n    const {min, max} = this.getMinMax(true);\n\n    this.min = isFinite(min) ? min : 0;\n    this.max = isFinite(max) ? max : 1;\n\n    // Common base implementation to handle min, max, beginAtZero\n    this.handleTickRangeOptions();\n  }\n\n  /**\n\t * Returns the maximum number of ticks based on the scale dimension\n\t * @protected\n \t */\n  computeTickLimit() {\n    const horizontal = this.isHorizontal();\n    const length = horizontal ? this.width : this.height;\n    const minRotation = toRadians(this.options.ticks.minRotation);\n    const ratio = (horizontal ? Math.sin(minRotation) : Math.cos(minRotation)) || 0.001;\n    const tickFont = this._resolveTickFontOptions(0);\n    return Math.ceil(length / Math.min(40, tickFont.lineHeight / ratio));\n  }\n\n  // Utils\n  getPixelForValue(value) {\n    return value === null ? NaN : this.getPixelForDecimal((value - this._startValue) / this._valueRange);\n  }\n\n  getValueForPixel(pixel) {\n    return this._startValue + this.getDecimalForPixel(pixel) * this._valueRange;\n  }\n}\n","import {finiteOrDefault, isFinite} from '../helpers/helpers.core.js';\nimport {formatNumber} from '../helpers/helpers.intl.js';\nimport {_setMinAndMaxByKey, log10} from '../helpers/helpers.math.js';\nimport Scale from '../core/core.scale.js';\nimport LinearScaleBase from './scale.linearbase.js';\nimport Ticks from '../core/core.ticks.js';\n\nconst log10Floor = v => Math.floor(log10(v));\nconst changeExponent = (v, m) => Math.pow(10, log10Floor(v) + m);\n\nfunction isMajor(tickVal) {\n  const remain = tickVal / (Math.pow(10, log10Floor(tickVal)));\n  return remain === 1;\n}\n\nfunction steps(min, max, rangeExp) {\n  const rangeStep = Math.pow(10, rangeExp);\n  const start = Math.floor(min / rangeStep);\n  const end = Math.ceil(max / rangeStep);\n  return end - start;\n}\n\nfunction startExp(min, max) {\n  const range = max - min;\n  let rangeExp = log10Floor(range);\n  while (steps(min, max, rangeExp) > 10) {\n    rangeExp++;\n  }\n  while (steps(min, max, rangeExp) < 10) {\n    rangeExp--;\n  }\n  return Math.min(rangeExp, log10Floor(min));\n}\n\n\n/**\n * Generate a set of logarithmic ticks\n * @param generationOptions the options used to generate the ticks\n * @param dataRange the range of the data\n * @returns {object[]} array of tick objects\n */\nfunction generateTicks(generationOptions, {min, max}) {\n  min = finiteOrDefault(generationOptions.min, min);\n  const ticks = [];\n  const minExp = log10Floor(min);\n  let exp = startExp(min, max);\n  let precision = exp < 0 ? Math.pow(10, Math.abs(exp)) : 1;\n  const stepSize = Math.pow(10, exp);\n  const base = minExp > exp ? Math.pow(10, minExp) : 0;\n  const start = Math.round((min - base) * precision) / precision;\n  const offset = Math.floor((min - base) / stepSize / 10) * stepSize * 10;\n  let significand = Math.floor((start - offset) / Math.pow(10, exp));\n  let value = finiteOrDefault(generationOptions.min, Math.round((base + offset + significand * Math.pow(10, exp)) * precision) / precision);\n  while (value < max) {\n    ticks.push({value, major: isMajor(value), significand});\n    if (significand >= 10) {\n      significand = significand < 15 ? 15 : 20;\n    } else {\n      significand++;\n    }\n    if (significand >= 20) {\n      exp++;\n      significand = 2;\n      precision = exp >= 0 ? 1 : precision;\n    }\n    value = Math.round((base + offset + significand * Math.pow(10, exp)) * precision) / precision;\n  }\n  const lastTick = finiteOrDefault(generationOptions.max, value);\n  ticks.push({value: lastTick, major: isMajor(lastTick), significand});\n\n  return ticks;\n}\n\nexport default class LogarithmicScale extends Scale {\n\n  static id = 'logarithmic';\n\n  /**\n   * @type {any}\n   */\n  static defaults = {\n    ticks: {\n      callback: Ticks.formatters.logarithmic,\n      major: {\n        enabled: true\n      }\n    }\n  };\n\n\n  constructor(cfg) {\n    super(cfg);\n\n    /** @type {number} */\n    this.start = undefined;\n    /** @type {number} */\n    this.end = undefined;\n    /** @type {number} */\n    this._startValue = undefined;\n    this._valueRange = 0;\n  }\n\n  parse(raw, index) {\n    const value = LinearScaleBase.prototype.parse.apply(this, [raw, index]);\n    if (value === 0) {\n      this._zero = true;\n      return undefined;\n    }\n    return isFinite(value) && value > 0 ? value : null;\n  }\n\n  determineDataLimits() {\n    const {min, max} = this.getMinMax(true);\n\n    this.min = isFinite(min) ? Math.max(0, min) : null;\n    this.max = isFinite(max) ? Math.max(0, max) : null;\n\n    if (this.options.beginAtZero) {\n      this._zero = true;\n    }\n\n    // if data has `0` in it or `beginAtZero` is true, min (non zero) value is at bottom\n    // of scale, and it does not equal suggestedMin, lower the min bound by one exp.\n    if (this._zero && this.min !== this._suggestedMin && !isFinite(this._userMin)) {\n      this.min = min === changeExponent(this.min, 0) ? changeExponent(this.min, -1) : changeExponent(this.min, 0);\n    }\n\n    this.handleTickRangeOptions();\n  }\n\n  handleTickRangeOptions() {\n    const {minDefined, maxDefined} = this.getUserBounds();\n    let min = this.min;\n    let max = this.max;\n\n    const setMin = v => (min = minDefined ? min : v);\n    const setMax = v => (max = maxDefined ? max : v);\n\n    if (min === max) {\n      if (min <= 0) { // includes null\n        setMin(1);\n        setMax(10);\n      } else {\n        setMin(changeExponent(min, -1));\n        setMax(changeExponent(max, +1));\n      }\n    }\n    if (min <= 0) {\n      setMin(changeExponent(max, -1));\n    }\n    if (max <= 0) {\n\n      setMax(changeExponent(min, +1));\n    }\n\n    this.min = min;\n    this.max = max;\n  }\n\n  buildTicks() {\n    const opts = this.options;\n\n    const generationOptions = {\n      min: this._userMin,\n      max: this._userMax\n    };\n    const ticks = generateTicks(generationOptions, this);\n\n    // At this point, we need to update our max and min given the tick values,\n    // since we probably have expanded the range of the scale\n    if (opts.bounds === 'ticks') {\n      _setMinAndMaxByKey(ticks, this, 'value');\n    }\n\n    if (opts.reverse) {\n      ticks.reverse();\n\n      this.start = this.max;\n      this.end = this.min;\n    } else {\n      this.start = this.min;\n      this.end = this.max;\n    }\n\n    return ticks;\n  }\n\n  /**\n\t * @param {number} value\n\t * @return {string}\n\t */\n  getLabelForValue(value) {\n    return value === undefined\n      ? '0'\n      : formatNumber(value, this.chart.options.locale, this.options.ticks.format);\n  }\n\n  /**\n\t * @protected\n\t */\n  configure() {\n    const start = this.min;\n\n    super.configure();\n\n    this._startValue = log10(start);\n    this._valueRange = log10(this.max) - log10(start);\n  }\n\n  getPixelForValue(value) {\n    if (value === undefined || value === 0) {\n      value = this.min;\n    }\n    if (value === null || isNaN(value)) {\n      return NaN;\n    }\n    return this.getPixelForDecimal(value === this.min\n      ? 0\n      : (log10(value) - this._startValue) / this._valueRange);\n  }\n\n  getValueForPixel(pixel) {\n    const decimal = this.getDecimalForPixel(pixel);\n    return Math.pow(10, this._startValue + decimal * this._valueRange);\n  }\n}\n","import defaults from '../core/core.defaults.js';\nimport {_longestText, addRoundedRectPath, renderText, _isPointInArea} from '../helpers/helpers.canvas.js';\nimport {HALF_PI, TAU, toDegrees, toRadians, _normalizeAngle, PI} from '../helpers/helpers.math.js';\nimport LinearScaleBase from './scale.linearbase.js';\nimport Ticks from '../core/core.ticks.js';\nimport {valueOrDefault, isArray, isFinite, callback as callCallback, isNullOrUndef} from '../helpers/helpers.core.js';\nimport {createContext, toFont, toPadding, toTRBLCorners} from '../helpers/helpers.options.js';\n\nfunction getTickBackdropHeight(opts) {\n  const tickOpts = opts.ticks;\n\n  if (tickOpts.display && opts.display) {\n    const padding = toPadding(tickOpts.backdropPadding);\n    return valueOrDefault(tickOpts.font && tickOpts.font.size, defaults.font.size) + padding.height;\n  }\n  return 0;\n}\n\nfunction measureLabelSize(ctx, font, label) {\n  label = isArray(label) ? label : [label];\n  return {\n    w: _longestText(ctx, font.string, label),\n    h: label.length * font.lineHeight\n  };\n}\n\nfunction determineLimits(angle, pos, size, min, max) {\n  if (angle === min || angle === max) {\n    return {\n      start: pos - (size / 2),\n      end: pos + (size / 2)\n    };\n  } else if (angle < min || angle > max) {\n    return {\n      start: pos - size,\n      end: pos\n    };\n  }\n\n  return {\n    start: pos,\n    end: pos + size\n  };\n}\n\n/**\n * Helper function to fit a radial linear scale with point labels\n */\nfunction fitWithPointLabels(scale) {\n\n  // Right, this is really confusing and there is a lot of maths going on here\n  // The gist of the problem is here: https://gist.github.com/nnnick/696cc9c55f4b0beb8fe9\n  //\n  // Reaction: https://dl.dropboxusercontent.com/u/34601363/toomuchscience.gif\n  //\n  // Solution:\n  //\n  // We assume the radius of the polygon is half the size of the canvas at first\n  // at each index we check if the text overlaps.\n  //\n  // Where it does, we store that angle and that index.\n  //\n  // After finding the largest index and angle we calculate how much we need to remove\n  // from the shape radius to move the point inwards by that x.\n  //\n  // We average the left and right distances to get the maximum shape radius that can fit in the box\n  // along with labels.\n  //\n  // Once we have that, we can find the centre point for the chart, by taking the x text protrusion\n  // on each side, removing that from the size, halving it and adding the left x protrusion width.\n  //\n  // This will mean we have a shape fitted to the canvas, as large as it can be with the labels\n  // and position it in the most space efficient manner\n  //\n  // https://dl.dropboxusercontent.com/u/34601363/yeahscience.gif\n\n  // Get maximum radius of the polygon. Either half the height (minus the text width) or half the width.\n  // Use this to calculate the offset + change. - Make sure L/R protrusion is at least 0 to stop issues with centre points\n  const orig = {\n    l: scale.left + scale._padding.left,\n    r: scale.right - scale._padding.right,\n    t: scale.top + scale._padding.top,\n    b: scale.bottom - scale._padding.bottom\n  };\n  const limits = Object.assign({}, orig);\n  const labelSizes = [];\n  const padding = [];\n  const valueCount = scale._pointLabels.length;\n  const pointLabelOpts = scale.options.pointLabels;\n  const additionalAngle = pointLabelOpts.centerPointLabels ? PI / valueCount : 0;\n\n  for (let i = 0; i < valueCount; i++) {\n    const opts = pointLabelOpts.setContext(scale.getPointLabelContext(i));\n    padding[i] = opts.padding;\n    const pointPosition = scale.getPointPosition(i, scale.drawingArea + padding[i], additionalAngle);\n    const plFont = toFont(opts.font);\n    const textSize = measureLabelSize(scale.ctx, plFont, scale._pointLabels[i]);\n    labelSizes[i] = textSize;\n\n    const angleRadians = _normalizeAngle(scale.getIndexAngle(i) + additionalAngle);\n    const angle = Math.round(toDegrees(angleRadians));\n    const hLimits = determineLimits(angle, pointPosition.x, textSize.w, 0, 180);\n    const vLimits = determineLimits(angle, pointPosition.y, textSize.h, 90, 270);\n    updateLimits(limits, orig, angleRadians, hLimits, vLimits);\n  }\n\n  scale.setCenterPoint(\n    orig.l - limits.l,\n    limits.r - orig.r,\n    orig.t - limits.t,\n    limits.b - orig.b\n  );\n\n  // Now that text size is determined, compute the full positions\n  scale._pointLabelItems = buildPointLabelItems(scale, labelSizes, padding);\n}\n\nfunction updateLimits(limits, orig, angle, hLimits, vLimits) {\n  const sin = Math.abs(Math.sin(angle));\n  const cos = Math.abs(Math.cos(angle));\n  let x = 0;\n  let y = 0;\n  if (hLimits.start < orig.l) {\n    x = (orig.l - hLimits.start) / sin;\n    limits.l = Math.min(limits.l, orig.l - x);\n  } else if (hLimits.end > orig.r) {\n    x = (hLimits.end - orig.r) / sin;\n    limits.r = Math.max(limits.r, orig.r + x);\n  }\n  if (vLimits.start < orig.t) {\n    y = (orig.t - vLimits.start) / cos;\n    limits.t = Math.min(limits.t, orig.t - y);\n  } else if (vLimits.end > orig.b) {\n    y = (vLimits.end - orig.b) / cos;\n    limits.b = Math.max(limits.b, orig.b + y);\n  }\n}\n\nfunction createPointLabelItem(scale, index, itemOpts) {\n  const outerDistance = scale.drawingArea;\n  const {extra, additionalAngle, padding, size} = itemOpts;\n  const pointLabelPosition = scale.getPointPosition(index, outerDistance + extra + padding, additionalAngle);\n  const angle = Math.round(toDegrees(_normalizeAngle(pointLabelPosition.angle + HALF_PI)));\n  const y = yForAngle(pointLabelPosition.y, size.h, angle);\n  const textAlign = getTextAlignForAngle(angle);\n  const left = leftForTextAlign(pointLabelPosition.x, size.w, textAlign);\n  return {\n    // if to draw or overlapped\n    visible: true,\n\n    // Text position\n    x: pointLabelPosition.x,\n    y,\n\n    // Text rendering data\n    textAlign,\n\n    // Bounding box\n    left,\n    top: y,\n    right: left + size.w,\n    bottom: y + size.h\n  };\n}\n\nfunction isNotOverlapped(item, area) {\n  if (!area) {\n    return true;\n  }\n  const {left, top, right, bottom} = item;\n  const apexesInArea = _isPointInArea({x: left, y: top}, area) || _isPointInArea({x: left, y: bottom}, area) ||\n    _isPointInArea({x: right, y: top}, area) || _isPointInArea({x: right, y: bottom}, area);\n  return !apexesInArea;\n}\n\nfunction buildPointLabelItems(scale, labelSizes, padding) {\n  const items = [];\n  const valueCount = scale._pointLabels.length;\n  const opts = scale.options;\n  const {centerPointLabels, display} = opts.pointLabels;\n  const itemOpts = {\n    extra: getTickBackdropHeight(opts) / 2,\n    additionalAngle: centerPointLabels ? PI / valueCount : 0\n  };\n  let area;\n\n  for (let i = 0; i < valueCount; i++) {\n    itemOpts.padding = padding[i];\n    itemOpts.size = labelSizes[i];\n\n    const item = createPointLabelItem(scale, i, itemOpts);\n    items.push(item);\n    if (display === 'auto') {\n      item.visible = isNotOverlapped(item, area);\n      if (item.visible) {\n        area = item;\n      }\n    }\n  }\n  return items;\n}\n\nfunction getTextAlignForAngle(angle) {\n  if (angle === 0 || angle === 180) {\n    return 'center';\n  } else if (angle < 180) {\n    return 'left';\n  }\n\n  return 'right';\n}\n\nfunction leftForTextAlign(x, w, align) {\n  if (align === 'right') {\n    x -= w;\n  } else if (align === 'center') {\n    x -= (w / 2);\n  }\n  return x;\n}\n\nfunction yForAngle(y, h, angle) {\n  if (angle === 90 || angle === 270) {\n    y -= (h / 2);\n  } else if (angle > 270 || angle < 90) {\n    y -= h;\n  }\n  return y;\n}\n\nfunction drawPointLabelBox(ctx, opts, item) {\n  const {left, top, right, bottom} = item;\n  const {backdropColor} = opts;\n\n  if (!isNullOrUndef(backdropColor)) {\n    const borderRadius = toTRBLCorners(opts.borderRadius);\n    const padding = toPadding(opts.backdropPadding);\n    ctx.fillStyle = backdropColor;\n\n    const backdropLeft = left - padding.left;\n    const backdropTop = top - padding.top;\n    const backdropWidth = right - left + padding.width;\n    const backdropHeight = bottom - top + padding.height;\n\n    if (Object.values(borderRadius).some(v => v !== 0)) {\n      ctx.beginPath();\n      addRoundedRectPath(ctx, {\n        x: backdropLeft,\n        y: backdropTop,\n        w: backdropWidth,\n        h: backdropHeight,\n        radius: borderRadius,\n      });\n      ctx.fill();\n    } else {\n      ctx.fillRect(backdropLeft, backdropTop, backdropWidth, backdropHeight);\n    }\n  }\n}\n\nfunction drawPointLabels(scale, labelCount) {\n  const {ctx, options: {pointLabels}} = scale;\n\n  for (let i = labelCount - 1; i >= 0; i--) {\n    const item = scale._pointLabelItems[i];\n    if (!item.visible) {\n      // overlapping\n      continue;\n    }\n    const optsAtIndex = pointLabels.setContext(scale.getPointLabelContext(i));\n    drawPointLabelBox(ctx, optsAtIndex, item);\n    const plFont = toFont(optsAtIndex.font);\n    const {x, y, textAlign} = item;\n\n    renderText(\n      ctx,\n      scale._pointLabels[i],\n      x,\n      y + (plFont.lineHeight / 2),\n      plFont,\n      {\n        color: optsAtIndex.color,\n        textAlign: textAlign,\n        textBaseline: 'middle'\n      }\n    );\n  }\n}\n\nfunction pathRadiusLine(scale, radius, circular, labelCount) {\n  const {ctx} = scale;\n  if (circular) {\n    // Draw circular arcs between the points\n    ctx.arc(scale.xCenter, scale.yCenter, radius, 0, TAU);\n  } else {\n    // Draw straight lines connecting each index\n    let pointPosition = scale.getPointPosition(0, radius);\n    ctx.moveTo(pointPosition.x, pointPosition.y);\n\n    for (let i = 1; i < labelCount; i++) {\n      pointPosition = scale.getPointPosition(i, radius);\n      ctx.lineTo(pointPosition.x, pointPosition.y);\n    }\n  }\n}\n\nfunction drawRadiusLine(scale, gridLineOpts, radius, labelCount, borderOpts) {\n  const ctx = scale.ctx;\n  const circular = gridLineOpts.circular;\n\n  const {color, lineWidth} = gridLineOpts;\n\n  if ((!circular && !labelCount) || !color || !lineWidth || radius < 0) {\n    return;\n  }\n\n  ctx.save();\n  ctx.strokeStyle = color;\n  ctx.lineWidth = lineWidth;\n  ctx.setLineDash(borderOpts.dash);\n  ctx.lineDashOffset = borderOpts.dashOffset;\n\n  ctx.beginPath();\n  pathRadiusLine(scale, radius, circular, labelCount);\n  ctx.closePath();\n  ctx.stroke();\n  ctx.restore();\n}\n\nfunction createPointLabelContext(parent, index, label) {\n  return createContext(parent, {\n    label,\n    index,\n    type: 'pointLabel'\n  });\n}\n\nexport default class RadialLinearScale extends LinearScaleBase {\n\n  static id = 'radialLinear';\n\n  /**\n   * @type {any}\n   */\n  static defaults = {\n    display: true,\n\n    // Boolean - Whether to animate scaling the chart from the centre\n    animate: true,\n    position: 'chartArea',\n\n    angleLines: {\n      display: true,\n      lineWidth: 1,\n      borderDash: [],\n      borderDashOffset: 0.0\n    },\n\n    grid: {\n      circular: false\n    },\n\n    startAngle: 0,\n\n    // label settings\n    ticks: {\n      // Boolean - Show a backdrop to the scale label\n      showLabelBackdrop: true,\n\n      callback: Ticks.formatters.numeric\n    },\n\n    pointLabels: {\n      backdropColor: undefined,\n\n      // Number - The backdrop padding above & below the label in pixels\n      backdropPadding: 2,\n\n      // Boolean - if true, show point labels\n      display: true,\n\n      // Number - Point label font size in pixels\n      font: {\n        size: 10\n      },\n\n      // Function - Used to convert point labels\n      callback(label) {\n        return label;\n      },\n\n      // Number - Additionl padding between scale and pointLabel\n      padding: 5,\n\n      // Boolean - if true, center point labels to slices in polar chart\n      centerPointLabels: false\n    }\n  };\n\n  static defaultRoutes = {\n    'angleLines.color': 'borderColor',\n    'pointLabels.color': 'color',\n    'ticks.color': 'color'\n  };\n\n  static descriptors = {\n    angleLines: {\n      _fallback: 'grid'\n    }\n  };\n\n  constructor(cfg) {\n    super(cfg);\n\n    /** @type {number} */\n    this.xCenter = undefined;\n    /** @type {number} */\n    this.yCenter = undefined;\n    /** @type {number} */\n    this.drawingArea = undefined;\n    /** @type {string[]} */\n    this._pointLabels = [];\n    this._pointLabelItems = [];\n  }\n\n  setDimensions() {\n    // Set the unconstrained dimension before label rotation\n    const padding = this._padding = toPadding(getTickBackdropHeight(this.options) / 2);\n    const w = this.width = this.maxWidth - padding.width;\n    const h = this.height = this.maxHeight - padding.height;\n    this.xCenter = Math.floor(this.left + w / 2 + padding.left);\n    this.yCenter = Math.floor(this.top + h / 2 + padding.top);\n    this.drawingArea = Math.floor(Math.min(w, h) / 2);\n  }\n\n  determineDataLimits() {\n    const {min, max} = this.getMinMax(false);\n\n    this.min = isFinite(min) && !isNaN(min) ? min : 0;\n    this.max = isFinite(max) && !isNaN(max) ? max : 0;\n\n    // Common base implementation to handle min, max, beginAtZero\n    this.handleTickRangeOptions();\n  }\n\n  /**\n\t * Returns the maximum number of ticks based on the scale dimension\n\t * @protected\n\t */\n  computeTickLimit() {\n    return Math.ceil(this.drawingArea / getTickBackdropHeight(this.options));\n  }\n\n  generateTickLabels(ticks) {\n    LinearScaleBase.prototype.generateTickLabels.call(this, ticks);\n\n    // Point labels\n    this._pointLabels = this.getLabels()\n      .map((value, index) => {\n        const label = callCallback(this.options.pointLabels.callback, [value, index], this);\n        return label || label === 0 ? label : '';\n      })\n      .filter((v, i) => this.chart.getDataVisibility(i));\n  }\n\n  fit() {\n    const opts = this.options;\n\n    if (opts.display && opts.pointLabels.display) {\n      fitWithPointLabels(this);\n    } else {\n      this.setCenterPoint(0, 0, 0, 0);\n    }\n  }\n\n  setCenterPoint(leftMovement, rightMovement, topMovement, bottomMovement) {\n    this.xCenter += Math.floor((leftMovement - rightMovement) / 2);\n    this.yCenter += Math.floor((topMovement - bottomMovement) / 2);\n    this.drawingArea -= Math.min(this.drawingArea / 2, Math.max(leftMovement, rightMovement, topMovement, bottomMovement));\n  }\n\n  getIndexAngle(index) {\n    const angleMultiplier = TAU / (this._pointLabels.length || 1);\n    const startAngle = this.options.startAngle || 0;\n\n    return _normalizeAngle(index * angleMultiplier + toRadians(startAngle));\n  }\n\n  getDistanceFromCenterForValue(value) {\n    if (isNullOrUndef(value)) {\n      return NaN;\n    }\n\n    // Take into account half font size + the yPadding of the top value\n    const scalingFactor = this.drawingArea / (this.max - this.min);\n    if (this.options.reverse) {\n      return (this.max - value) * scalingFactor;\n    }\n    return (value - this.min) * scalingFactor;\n  }\n\n  getValueForDistanceFromCenter(distance) {\n    if (isNullOrUndef(distance)) {\n      return NaN;\n    }\n\n    const scaledDistance = distance / (this.drawingArea / (this.max - this.min));\n    return this.options.reverse ? this.max - scaledDistance : this.min + scaledDistance;\n  }\n\n  getPointLabelContext(index) {\n    const pointLabels = this._pointLabels || [];\n\n    if (index >= 0 && index < pointLabels.length) {\n      const pointLabel = pointLabels[index];\n      return createPointLabelContext(this.getContext(), index, pointLabel);\n    }\n  }\n\n  getPointPosition(index, distanceFromCenter, additionalAngle = 0) {\n    const angle = this.getIndexAngle(index) - HALF_PI + additionalAngle;\n    return {\n      x: Math.cos(angle) * distanceFromCenter + this.xCenter,\n      y: Math.sin(angle) * distanceFromCenter + this.yCenter,\n      angle\n    };\n  }\n\n  getPointPositionForValue(index, value) {\n    return this.getPointPosition(index, this.getDistanceFromCenterForValue(value));\n  }\n\n  getBasePosition(index) {\n    return this.getPointPositionForValue(index || 0, this.getBaseValue());\n  }\n\n  getPointLabelPosition(index) {\n    const {left, top, right, bottom} = this._pointLabelItems[index];\n    return {\n      left,\n      top,\n      right,\n      bottom,\n    };\n  }\n\n  /**\n\t * @protected\n\t */\n  drawBackground() {\n    const {backgroundColor, grid: {circular}} = this.options;\n    if (backgroundColor) {\n      const ctx = this.ctx;\n      ctx.save();\n      ctx.beginPath();\n      pathRadiusLine(this, this.getDistanceFromCenterForValue(this._endValue), circular, this._pointLabels.length);\n      ctx.closePath();\n      ctx.fillStyle = backgroundColor;\n      ctx.fill();\n      ctx.restore();\n    }\n  }\n\n  /**\n\t * @protected\n\t */\n  drawGrid() {\n    const ctx = this.ctx;\n    const opts = this.options;\n    const {angleLines, grid, border} = opts;\n    const labelCount = this._pointLabels.length;\n\n    let i, offset, position;\n\n    if (opts.pointLabels.display) {\n      drawPointLabels(this, labelCount);\n    }\n\n    if (grid.display) {\n      this.ticks.forEach((tick, index) => {\n        if (index !== 0) {\n          offset = this.getDistanceFromCenterForValue(tick.value);\n          const context = this.getContext(index);\n          const optsAtIndex = grid.setContext(context);\n          const optsAtIndexBorder = border.setContext(context);\n\n          drawRadiusLine(this, optsAtIndex, offset, labelCount, optsAtIndexBorder);\n        }\n      });\n    }\n\n    if (angleLines.display) {\n      ctx.save();\n\n      for (i = labelCount - 1; i >= 0; i--) {\n        const optsAtIndex = angleLines.setContext(this.getPointLabelContext(i));\n        const {color, lineWidth} = optsAtIndex;\n\n        if (!lineWidth || !color) {\n          continue;\n        }\n\n        ctx.lineWidth = lineWidth;\n        ctx.strokeStyle = color;\n\n        ctx.setLineDash(optsAtIndex.borderDash);\n        ctx.lineDashOffset = optsAtIndex.borderDashOffset;\n\n        offset = this.getDistanceFromCenterForValue(opts.ticks.reverse ? this.min : this.max);\n        position = this.getPointPosition(i, offset);\n        ctx.beginPath();\n        ctx.moveTo(this.xCenter, this.yCenter);\n        ctx.lineTo(position.x, position.y);\n        ctx.stroke();\n      }\n\n      ctx.restore();\n    }\n  }\n\n  /**\n\t * @protected\n\t */\n  drawBorder() {}\n\n  /**\n\t * @protected\n\t */\n  drawLabels() {\n    const ctx = this.ctx;\n    const opts = this.options;\n    const tickOpts = opts.ticks;\n\n    if (!tickOpts.display) {\n      return;\n    }\n\n    const startAngle = this.getIndexAngle(0);\n    let offset, width;\n\n    ctx.save();\n    ctx.translate(this.xCenter, this.yCenter);\n    ctx.rotate(startAngle);\n    ctx.textAlign = 'center';\n    ctx.textBaseline = 'middle';\n\n    this.ticks.forEach((tick, index) => {\n      if (index === 0 && !opts.reverse) {\n        return;\n      }\n\n      const optsAtIndex = tickOpts.setContext(this.getContext(index));\n      const tickFont = toFont(optsAtIndex.font);\n      offset = this.getDistanceFromCenterForValue(this.ticks[index].value);\n\n      if (optsAtIndex.showLabelBackdrop) {\n        ctx.font = tickFont.string;\n        width = ctx.measureText(tick.label).width;\n        ctx.fillStyle = optsAtIndex.backdropColor;\n\n        const padding = toPadding(optsAtIndex.backdropPadding);\n        ctx.fillRect(\n          -width / 2 - padding.left,\n          -offset - tickFont.size / 2 - padding.top,\n          width + padding.width,\n          tickFont.size + padding.height\n        );\n      }\n\n      renderText(ctx, tick.label, 0, -offset, tickFont, {\n        color: optsAtIndex.color,\n        strokeColor: optsAtIndex.textStrokeColor,\n        strokeWidth: optsAtIndex.textStrokeWidth,\n      });\n    });\n\n    ctx.restore();\n  }\n\n  /**\n\t * @protected\n\t */\n  drawTitle() {}\n}\n"],"names":["Animator","constructor","this","_request","_charts","Map","_running","_lastDate","undefined","_notify","chart","anims","date","type","callbacks","listeners","numSteps","duration","forEach","fn","initial","currentStep","Math","min","start","_refresh","requestAnimFrame","call","window","_update","Date","now","remaining","running","items","length","item","i","draw","_active","_total","tick","pop","_getAnims","charts","get","complete","progress","set","listen","event","cb","push","add","has","reduce","acc","cur","max","_duration","stop","cancel","remove","delete","animator","transparent","interpolators","boolean","from","to","factor","color","c0","c1","valid","mix","hexString","number","Animation","cfg","target","prop","currentValue","resolve","_fn","_easing","effects","easing","linear","_start","floor","delay","_loop","loop","_target","_prop","_from","_to","_promises","active","update","elapsed","remain","wait","promises","Promise","res","rej","resolved","method","Animations","config","_chart","_properties","configure","isObject","animationOptions","Object","keys","defaults","animation","animatedProps","getOwnPropertyNames","key","option","isArray","properties","_animateOptions","values","newOptions","options","$shared","assign","$animations","resolveTargetOptions","animations","_createAnimations","anim","all","awaitAll","then","props","charAt","value","size","scaleClip","scale","allowedOverflow","opts","reverse","end","getSortedDatasetIndices","filterVisible","metasets","_getSortedDatasetMetas","ilen","index","applyStack","stack","dsIndex","singleMode","mode","datasetIndex","otherValue","isNumberFinite","sign","isStacked","meta","stacked","getOrCreateStack","stacks","stackKey","indexValue","subStack","getLastIndexInStack","vScale","positive","getMatchingVisibleMetas","updateStacks","controller","parsed","_cachedMeta","_stacks","iScale","iAxis","axis","vAxis","indexScale","valueScale","id","getStackKey","_top","_bottom","_visualValues","getFirstScaleId","scales","filter","shift","clearStacks","_parsed","isDirectUpdateMode","cloneIfNotShared","cached","shared","DatasetController","static","_ctx","ctx","_cachedDataOpts","getMeta","_type","_parsing","_data","_objectData","_sharedOptions","_drawStart","_drawCount","enableOptionSharing","supportsDecimation","$context","_syncList","datasetElementType","dataElementType","initialize","linkScales","_stacked","addElements","fill","isPluginEnabled","console","warn","updateIndex","dataset","getDataset","chooseId","x","y","r","xid","xAxisID","valueOrDefault","yid","yAxisID","rid","rAxisID","indexAxis","iid","iAxisID","vid","vAxisID","xScale","getScaleForId","yScale","rScale","data","datasets","getDatasetMeta","scaleID","_getOtherScale","reset","_destroy","unlistenArrayEvents","_dataCheck","adata","Array","convertObjectDataToArray","isExtensible","listenArrayEvents","buildOrUpdateElements","resetNewElements","stackChanged","oldStacked","_resyncElements","scopeKeys","datasetScopeKeys","scopes","getOptionScopes","createResolver","getContext","parsing","parse","count","sorted","_sorted","prev","parseArrayData","parseObjectData","parsePrimitiveData","isNotInOrderComparedToPrev","labels","getLabels","singleScale","xAxisKey","yAxisKey","resolveObjectKey","getParsed","getDataElement","updateRangeFromParsed","range","parsedValue","NaN","getMinMax","canStack","otherScale","createStack","hidden","Number","POSITIVE_INFINITY","NEGATIVE_INFINITY","otherMin","otherMax","minDefined","maxDefined","getUserBounds","_skip","getAllParsedValues","getMaxOverflow","getLabelAndValue","label","getLabelForValue","_clip","t","b","l","top","right","bottom","left","disabled","toClip","clip","defaultClip","elements","area","chartArea","drawActiveElementsOnTop","element","getStyle","resolveDatasetElementOptions","resolveDataElementOptions","context","parent","createContext","dataIndex","raw","createDataContext","createDatasetContext","_resolveElementOptions","elementType","cache","cacheKey","sharing","defined","datasetElementScopeKeys","prefixes","names","resolveNamedOptions","freeze","_resolveAnimations","transition","datasetAnimationScopeKeys","_cacheable","getSharedOptions","includeOptions","sharedOptions","_animationsDisabled","_getSharedOptions","firstOpts","previouslySharedOptions","updateSharedOptions","updateElement","_setStyle","removeHoverStyle","setHoverStyle","_removeDatasetHoverStyle","_setDatasetHoverStyle","arg1","arg2","numMeta","numData","_insertElements","_removeElements","move","arr","updateElements","removed","splice","_sync","args","_dataChanges","_onDataPush","arguments","_onDataPop","_onDataShift","_onDataSplice","newCount","_onDataUnshift","computeMinSampleSize","_cache","$bar","visibleMetas","concat","_arrayUnique","sort","a","getAllScaleValues","curr","_length","updateMinAndPrev","abs","getPixelForValue","ticks","getPixelForTick","parseValue","entry","startValue","endValue","barStart","barEnd","_custom","parseFloatBar","parseArrayOrPrimitive","isFloatBar","custom","setBorderSkipped","edge","borderSkipped","horizontal","base","borderProps","enableBorderRadius","parseEdge","orig","v1","v2","startEnd","v","setInflateAmount","inflateAmount","ratio","BarController","categoryPercentage","barPercentage","grouped","numbers","_index_","offset","grid","_value_","beginAtZero","iAxisKey","vAxisKey","obj","super","bars","getBasePixel","isHorizontal","ruler","_getRuler","vpixels","isNullOrUndef","head","_calculateBarValuePixels","ipixels","_calculateBarIndexPixels","center","height","width","_getStacks","last","skipNull","val","isNaN","indexOf","_getStackCount","_getStackIndex","name","pixels","barThickness","_startPixel","_endPixel","stackCount","baseValue","minBarLength","actualBase","floating","getDataVisibility","barSign","startPixel","getPixelForDecimal","endPixel","getValueForPixel","halfGrid","getLineWidthForValue","maxBarThickness","Infinity","next","percent","chunk","computeFlexCategoryTraits","thickness","computeFitCategoryTraits","stackIndex","rects","LineController","showLine","spanGaps","line","points","_dataset","animationsDisabled","_getStartAndCountOfVisiblePoints","_scaleRangesChanged","_datasetIndex","_decimated","borderWidth","segment","animated","maxGapLength","isNumber","directUpdate","pointsCount","prevParsed","point","skip","nullData","iPixel","vPixel","border","firstPoint","lastPoint","updateControlPoints","binarySearch","metaset","intersect","lookupMethod","_reversePixels","_rlookupByKey","_lookupByKey","el","getRange","lo","hi","evaluateInteractionItems","position","handler","getSortedVisibleDatasetMetas","j","getIntersectItems","useFinalPosition","includeInvisible","isPointInArea","_isPointInArea","inRange","getNearestItems","distanceMetric","useX","useY","pt1","pt2","deltaX","deltaY","sqrt","pow","getDistanceMetricForAxis","minDistance","getCenterPoint","distance","getNearestCartesianItems","startAngle","endAngle","getProps","angle","getAngleFromPoint","_angleBetween","getNearestRadialItems","getAxisItems","rangeMethod","intersectsItem","Interaction","modes","e","getRelativePosition","nearest","STATIC_POSITIONS","filterByPosition","array","pos","filterDynamicPositionByAxis","box","sortByWeight","v0","weight","getCombinedMax","maxPadding","updateMaxPadding","boxPadding","updateDims","params","layout","getPadding","newWidth","outerWidth","newHeight","outerHeight","widthChanged","w","heightChanged","h","same","other","getMargins","positions","margin","marginForPositions","fitBoxes","boxes","refitBoxes","refit","changed","fullSize","setBoxDims","placeBoxes","userPadding","padding","placed","stackWeight","layouts","addBox","_layers","z","removeBox","layoutItem","minPadding","toPadding","availableWidth","availableHeight","layoutBoxes","wrapBoxes","wrap","centerHorizontal","centerVertical","leftAndTop","rightAndBottom","vertical","buildLayoutBoxes","verticalBoxes","horizontalBoxes","each","beforeLayout","visibleVerticalBoxCount","total","display","vBoxMaxWidth","hBoxMaxHeight","includes","_stack","buildStacks","setLayoutDims","updatePos","change","handleMaxPadding","BasePlatform","acquireContext","canvas","aspectRatio","releaseContext","addEventListener","listener","removeEventListener","getDevicePixelRatio","getMaximumSize","isAttached","updateConfig","BasicPlatform","EXPANDO_KEY","EVENT_TYPES","touchstart","touchmove","touchend","pointerenter","pointerdown","pointermove","pointerup","pointerleave","pointerout","isNullOrEmpty","eventListenerOptions","supportsEventListenerOptions","passive","removeListener","nodeListContains","nodeList","node","contains","createAttachObserver","observer","MutationObserver","entries","trigger","addedNodes","removedNodes","observe","document","childList","subtree","createDetachObserver","drpListeningCharts","oldDevicePixelRatio","onWindowResize","dpr","devicePixelRatio","resize","currentDevicePixelRatio","createResizeObserver","container","_getParentNode","throttled","clientWidth","ResizeObserver","contentRect","listenDevicePixelRatioChanges","releaseObserver","disconnect","unlistenDevicePixelRatioChanges","createProxyAndListen","proxy","native","fromNativeEvent","addListener","DomPlatform","style","renderHeight","getAttribute","renderWidth","boxSizing","displayWidth","readUsedSize","displayHeight","initCanvas","removeAttribute","setAttribute","proxies","$proxies","attach","detach","isConnected","Element","tooltipPosition","hasValue","final","ret","newTicks","spacing","majorStart","majorEnd","ceil","round","offsetFromEdge","getTicksLimit","ticksLength","maxTicksLimit","sample","numItems","result","increment","len","getPixelForGridLine","offsetGridLines","validIndex","epsilon","lineValue","getTickMarkLength","drawTicks","tickLength","getTitleHeight","fallback","font","toFont","text","lineHeight","titleAlign","align","_toLeftRightCenter","reverseAlign","Scale","_margins","maxWidth","maxHeight","paddingTop","paddingBottom","paddingLeft","paddingRight","labelRotation","_range","_gridLineItems","_labelItems","_labelSizes","_maxLength","_longestTextCache","_userMax","_userMin","_suggestedMax","_suggestedMin","_ticksLength","_borderValue","_dataLimitsCached","init","setContext","suggestedMin","suggestedMax","finiteOrDefault","metas","getTicks","xLabels","yLabels","getLabelItems","_computeLabelItems","beforeUpdate","callback","margins","grace","tickOpts","sampleSize","beforeSetDimensions","setDimensions","afterSetDimensions","beforeDataLimits","determineDataLimits","afterDataLimits","_addGrace","beforeBuildTicks","buildTicks","afterBuildTicks","samplingEnabled","_convertTicksToLabels","beforeCalculateLabelRotation","calculateLabelRotation","afterCalculateLabelRotation","autoSkip","source","determinedMaxTicks","_tickSize","maxScale","maxChart","determineMaxTicks","ticksLimit","majorIndices","major","enabled","getMajorIndices","numMajorIndices","first","skipMajors","evenMajorSpacing","diff","getEvenSpacing","factors","_factorize","calculateSpacing","avgMajorSpacing","afterAutoSkip","beforeFit","fit","afterFit","afterUpdate","reversePixels","_alignToPixels","alignToPixels","_callHooks","notifyPlugins","beforeTickToLabelConversion","generateTickLabels","afterTickToLabelConversion","numTicks","minRotation","maxRotation","tickWidth","maxLabelDiagonal","_isVisible","labelSizes","_getLabelSizes","maxLabelWidth","widest","maxLabelHeight","highest","_limitValue","title","toDegrees","asin","minSize","titleOpts","gridOpts","titleHeight","tickPadding","angleRadians","toRadians","cos","sin","labelHeight","mirror","labelWidth","_calculatePadding","_handleMargins","isRotated","labelsBelowTicks","offsetLeft","offsetRight","isFullSize","_computeLabelSizes","caches","widths","heights","jlen","tickFont","fontString","nestedLabel","widestLabelSize","highestLabelSize","_resolveTickFontOptions","string","gc","_measureText","gcLen","garbageCollect","valueAt","idx","pixel","decimal","_int16Range","_alignPixel","getDecimalForPixel","getBaseValue","createTickContext","optionTicks","rot","autoSkipPadding","_computeGridLineItems","tl","borderOpts","axisWidth","axisHalfWidth","alignBorderValue","borderValue","alignedLineValue","tx1","ty1","tx2","ty2","x1","y1","x2","y2","positionAxisID","limit","step","optsAtIndex","optsAtIndexBorder","lineWidth","lineColor","borderDash","dash","borderDashOffset","dashOffset","tickColor","tickBorderDash","tickBorderDashOffset","crossAlign","tickAndPadding","hTickAndPadding","rotation","textAlign","lineCount","textOffset","textBaseline","_getXAxisLabelAlignment","_getYAxisLabelAlignment","labelOffset","halfCount","strokeColor","textStrokeColor","strokeWidth","textStrokeWidth","backdrop","tickTextAlign","showLabelBackdrop","labelPadding","backdropPadding","backdropColor","translation","_computeLabelArea","drawBackground","backgroundColor","save","fillStyle","fillRect","restore","findIndex","drawGrid","drawLine","p1","p2","strokeStyle","setLineDash","lineDashOffset","beginPath","moveTo","lineTo","stroke","drawOnChartArea","drawBorder","lastLineWidth","drawLabels","clipArea","renderTextOptions","renderText","unclipArea","drawTitle","titleX","titleY","_alignStartEnd","HALF_PI","titleArgs","tz","gz","bz","prototype","axisID","_maxDigits","fontSize","TypedRegistry","scope","override","create","isForType","isPrototypeOf","register","proto","getPrototypeOf","parentScope","isIChartComponent","Error","itemDefaults","merge","defaultRoutes","routes","property","propertyParts","split","sourceName","sourceScope","join","parts","targetName","targetScope","route","routeDefaults","descriptors","describe","registerDefaults","overrides","unregister","Registry","controllers","plugins","_typedRegistries","_each","addControllers","addPlugins","addScales","getController","_get","getElement","getPlugin","getScale","removeControllers","removeElements","removePlugins","removeScales","typedRegistry","arg","reg","_getRegistryForType","_exec","itemReg","registry","component","camelMethod","_capitalize","PluginService","_init","notify","hook","_createDescriptors","_descriptors","descriptor","plugin","cancelable","invalidate","_oldCache","_notifyStateChanges","localIds","local","allPlugins","getOpts","pluginOpts","createDescriptors","previousDescriptors","some","pluginScopeKeys","scriptable","indexable","allKeys","getIndexAxis","datasetDefaults","idMatchesAxis","determineAxis","scaleOptions","toLowerCase","getAxisFromDataset","initOptions","chartDefaults","configScales","chartIndexAxis","scaleConf","error","_proxy","boundDs","d","retrieveAxisFromDatasets","defaultId","getDefaultScaleIDFromAxis","defaultScaleOptions","mergeIf","defaultID","getAxisFromDefaultScaleID","mergeScaleConfig","initData","keyCache","keysCached","Set","cachedKeys","generate","addIfFound","Config","_config","initConfig","_scopeCache","_resolverCache","platform","clearCache","clear","datasetType","additionalOptionScopes","_cachedScopes","mainScope","resetCache","keyLists","chartOptionScopes","resolver","subPrefixes","getResolver","isScriptable","isIndexable","isFunction","hasFunction","needContext","subResolver","_attachContext","descriptorDefaults","resolverCache","_createResolver","p","KNOWN_POSITIONS","positionIsHorizontal","compare2Level","l1","l2","onAnimationsComplete","onComplete","onAnimationProgress","onProgress","getCanvas","_isDomSupported","getElementById","instances","getChart","c","moveNumericKeys","intKey","getSizeForArea","field","Chart","invalidatePlugins","userConfig","initialCanvas","existingChart","OffscreenCanvas","_detectPlatform","uid","_options","_aspectRatio","_metasets","_lastEvent","_listeners","_responsiveListeners","_sortedMetasets","_plugins","_hiddenIndices","attached","_doResize","debounce","resizeDelay","_initialize","maintainAspectRatio","responsive","retinaScale","bindEvents","clearCanvas","_resizeBeforeDraw","_resize","newSize","newRatio","onResize","render","ensureScalesHaveIDs","scalesOptions","axisOptions","buildOrUpdateScales","scaleOpts","updated","map","isRadial","dposition","dtype","scaleType","hasUpdated","_updateMetasets","_destroyDatasetMeta","slice","_removeUnreferencedMetasets","buildOrUpdateControllers","newControllers","order","visible","isDatasetVisible","ControllerClass","_resetElements","animsDisabled","_updateScales","_checkEventBindings","_updateHiddenIndices","_minPadding","autoPadding","_updateLayout","_updateDatasets","_eventHandler","_updateHoverStyles","existingEvents","newEvents","events","setsEqual","unbindEvents","changes","_getUniformDataChanges","datasetCount","makeSet","changeSet","noArea","_idx","_updateDataset","layers","_drawDatasets","_drawDataset","useClip","getDatasetArea","getElementsAtEventForMode","getVisibleDatasetCount","setDatasetVisibility","toggleDataVisibility","_updateVisibility","hide","show","_stop","destroy","toBase64Image","toDataURL","bindUserEvents","bindResponsiveEvents","_add","offsetX","offsetY","_remove","detached","updateHoverStyle","prefix","getActiveElements","setActiveElements","activeElements","lastActive","_elementsEqual","pluginId","replay","hoverOptions","hover","deactivated","activated","inChartArea","eventFilter","_handleEvent","_getActiveElements","isClick","_isClickEvent","lastEvent","determineLastEvent","onHover","onClick","setStyle","lineCap","borderCapStyle","lineJoin","borderJoinStyle","borderColor","previous","pathVars","paramsStart","paramsEnd","segmentStart","segmentEnd","outside","pathSegment","lineMethod","stepped","_steppedLineTo","tension","cubicInterpolationMode","_bezierCurveTo","getLineMethod","fastPathSegment","prevX","minY","maxY","lastY","avgX","countX","pointIndex","drawX","truncX","_getSegmentMethod","usePath2D","Path2D","LineElement","capBezierPoints","_scriptable","_indexable","_fullLoop","_path","_points","_segments","_pointsUpdated","_updateBezierControlPoints","segments","_computeSegments","interpolate","_boundSegments","_interpolate","_steppedInterpolation","_bezierInterpolation","_pointInLine","_getInterpolationMethod","interpolated","segmentMethod","path","closePath","strokePathWithCache","strokePathDirect","inRange$1","radius","hitRadius","PointElement","hoverBorderWidth","hoverRadius","pointStyle","mouseX","mouseY","inXRange","inYRange","drawPoint","getBarBounds","bar","half","skipOrLimit","skipX","skipY","bounds","_isBetween","addNormalRectPath","rect","inflateRect","amount","refRect","BarElement","borderRadius","inner","outer","maxW","maxH","o","toTRBL","parseBorderWidth","toTRBLCorners","maxR","enableBorder","topLeft","topRight","bottomLeft","bottomRight","parseBorderRadius","boundingRects","addRectPath","addRoundedRectPath","getBoxSize","labelOpts","boxHeight","boxWidth","usePointStyle","pointStyleWidth","itemHeight","Legend","_added","legendHitBoxes","_hoveredItem","doughnutMode","legendItems","columnSizes","lineWidths","buildLabels","generateLabels","labelFont","_computeTitleHeight","_fitRows","_fitCols","hitboxes","totalHeight","row","legendItem","itemWidth","measureText","_itemHeight","heightLimit","totalWidth","currentColWidth","currentColHeight","col","legendItemText","calculateItemWidth","fontLineHeight","calculateLegendItemHeight","calculateItemHeight","calculateItemSize","adjustHitBoxes","rtl","rtlHelper","getRtlAdapter","hitbox","leftForLtr","_draw","defaultColor","halfFontSize","cursor","overrideTextDirection","textDirection","fontColor","textWidth","setWidth","lineDash","drawOptions","SQRT2","centerX","xPlus","centerY","drawPointLegend","yBoxTop","xBoxLeft","drawLegendBox","_textX","strikethrough","fillText","restoreTextDirection","titleFont","titlePadding","topPaddingPlusHalfFontSize","_getLegendItemAt","hitBox","lh","handleEvent","onLeave","isListened","hoveredItem","sameItem","itemsEqual","plugin_legend","_element","_args","legend","afterEvent","ci","useBorderRadius","startsWith","WeakMap","positioners","average","eventPosition","nearestElement","distanceBetweenPoints","tp","pushOrConcat","toPush","apply","splitNewlines","str","String","createTooltipItem","formattedValue","getTooltipSize","tooltip","body","footer","bodyFont","footerFont","titleLineCount","footerLineCount","bodyLineItemCount","combinedBodyLength","bodyItem","before","lines","after","beforeBody","afterBody","titleSpacing","titleMarginBottom","displayColors","bodySpacing","footerMarginTop","footerSpacing","widthPadding","maxLineWidth","determineXAlign","yAlign","chartWidth","xAlign","caret","caretSize","caretPadding","doesNotFitWithAlign","determineAlignment","determineYAlign","getBackgroundPoint","alignment","cornerRadius","paddingAndSize","alignX","alignY","getAlignedX","getBeforeAfterBodyLines","overrideCallbacks","defaultCallbacks","beforeTitle","noop","tooltipItems","labelCount","afterTitle","beforeLabel","tooltipItem","labelColor","labelTextColor","bodyColor","labelPointStyle","afterLabel","beforeFooter","afterFooter","invokeCallbackWithFallback","Tooltip","opacity","_eventPosition","_size","_cachedAnimations","_tooltipItems","dataPoints","caretX","caretY","labelColors","labelPointStyles","labelTextColors","getTitle","getBeforeBody","getBody","bodyItems","scoped","getAfterBody","getFooter","_createItems","itemSort","positionAndSize","backgroundPoint","external","drawCaret","tooltipPoint","caretPosition","getCaretPosition","x3","y3","ptX","ptY","pt","titleColor","_drawColorBox","colorX","rtlColorX","yOffSet","colorY","multiKeyBackground","outerX","innerX","strokeRect","drawBody","bodyAlign","bodyLineHeight","xLinePadding","fillLineOfText","bodyAlignForCalculation","textColor","drawFooter","footerAlign","footerColor","tooltipSize","quadraticCurveTo","_updateAnimationTarget","animX","animY","_willRender","hasTooltipContent","globalAlpha","positionChanged","_positionChanged","_ignoreReplayEvents","plugin_tooltip","afterInit","afterDraw","_fallback","_getLabelForValue","CategoryScale","_startValue","_valueRange","_addedLabels","added","isFinite","addedLabels","addIfString","unshift","lastIndexOf","findOrAddLabel","relativeLabelSize","minSpacing","rad","LinearScaleBase","_endValue","handleTickRangeOptions","setMin","setMax","minSign","maxSign","getTickLimit","maxTicks","stepSize","computeTickLimit","generationOptions","dataRange","precision","maxDigits","includeBounds","unit","maxSpaces","rmin","rmax","countDefined","niceMin","niceMax","numSpaces","niceNum","almostWhole","almostEquals","decimalPlaces","_decimalPlaces","tickValue","generateTicks$1","_setMinAndMaxByKey","formatNumber","locale","format","LinearScale","Ticks","formatters","numeric","logarithmic"],"sourceRoot":""}