{"version":3,"file":"js/4709-a41b6f4d9afb731d74ae.js","mappings":"mFAAA,IAAIA,EAAW,EAAQ,OACnBC,EAAW,EAAQ,OAmEvBC,EAAOC,QAlBP,SAAkBC,EAAMC,EAAMC,GAC5B,IAAIC,GAAU,EACVC,GAAW,EAEf,GAAmB,mBAARJ,EACT,MAAM,IAAIK,UAnDQ,uBAyDpB,OAJIR,EAASK,KACXC,EAAU,YAAaD,IAAYA,EAAQC,QAAUA,EACrDC,EAAW,aAAcF,IAAYA,EAAQE,SAAWA,GAEnDR,EAASI,EAAMC,EAAM,CAC1B,QAAWE,EACX,QAAWF,EACX,SAAYG,GAEhB,C,qCC5DA,MAAME,E,SAAW,GAAUC,OAAO,CAC9BC,KAAM,WACN,UAAAC,GACI,MAAO,CACHC,MAAO,CAAC,aAEhB,EACA,mBAAAC,GACI,MAAO,CACH,CACID,MAAOE,KAAKV,QAAQQ,MACpBG,WAAY,CACRC,SAAU,CACNC,QAAS,KACTC,UAAYC,GAAYA,EAAQC,MAAMJ,SAASK,QAAQ,SAAU,IACjEC,WAAaP,GACJA,EAAWC,SAGT,CACHI,MAAO,cAAcL,EAAWC,YAHzB,CAAC,KAUpC,EACA,WAAAO,GACI,MAAO,CACHC,YAAcR,GAAa,EAAGS,WACnBA,IAAQC,QAAQ,YAAa,CAAEV,aAAYW,MAEtDC,cAAe,IAAM,EAAGH,WACbA,IACFC,QAAQ,YAAa,CAAEV,SAAU,OACjCa,uBACAF,MAGjB,IAEJ,K,oFC9CA,MAAMG,EAAU,KAAKrB,OAAO,CACxBC,KAAM,UACN,UAAAC,GACI,MAAO,CACHoB,OAAQ,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GACxBC,eAAgB,CAAC,EAEzB,EACAC,QAAS,UACTC,MAAO,QACPC,UAAU,EACV,aAAAC,GACI,MAAO,CACHC,MAAO,CACHpB,QAAS,EACTqB,UAAU,GAGtB,EACA,SAAApB,GACI,OAAOJ,KAAKV,QAAQ2B,OACfQ,KAAKF,IAAU,CAChBG,IAAK,IAAIH,IACTI,MAAO,CAAEJ,YAEjB,EACA,UAAAf,EAAW,KAAEoB,EAAI,eAAEV,IAKf,MAAO,CAAC,IAJSlB,KAAKV,QAAQ2B,OAAOY,SAASD,EAAKD,MAAMJ,OAEnDK,EAAKD,MAAMJ,MACXvB,KAAKV,QAAQ2B,OAAO,MACL,QAAgBjB,KAAKV,QAAQ4B,eAAgBA,GAAiB,EACvF,EACA,WAAAT,GACI,MAAO,CACHqB,WAAY7B,GAAc,EAAG8B,gBACpB/B,KAAKV,QAAQ2B,OAAOY,SAAS5B,EAAWsB,QAGtCQ,EAASC,QAAQhC,KAAKJ,KAAMK,GAEvCgC,cAAehC,GAAc,EAAG8B,gBACvB/B,KAAKV,QAAQ2B,OAAOY,SAAS5B,EAAWsB,QAGtCQ,EAASG,WAAWlC,KAAKJ,KAAM,YAAaK,GAG/D,EACA,oBAAAkC,GACI,OAAOnC,KAAKV,QAAQ2B,OAAOmB,QAAO,CAACC,EAAOd,KAAU,IAC7Cc,EAEC,CAAC,WAAWd,KAAU,IAAMvB,KAAKsC,OAAOP,SAASE,cAAc,CAAEV,aAErE,CAAC,EACT,EACA,aAAAgB,GACI,OAAOvC,KAAKV,QAAQ2B,OAAOQ,KAAIF,IACpB,QAAuB,CAC1BiB,KAAM,IAAIC,OAAO,SAASlB,WAC1BmB,KAAM1C,KAAK0C,KACXC,cAAe,CACXpB,YAIhB,I,sEC5DJ,MAAMqB,GAAY,QAAW,CACzBhD,KAAM,CAAEiD,8BACRC,OAAQ,UAFM,EAGf,CAACC,EAAOC,EAASC,KAAY,CAC5BC,KAAM,CAGF,CAAC,YAAYD,EAAQE,QAAS,CAC1BC,QAAS,MAGjBC,UAAW,CAGPC,QAAS,eAGTC,SAAU,YAEdJ,KAAM,CACFI,SAAU,WACVC,MAAO,GACPC,MAAO,GAAGV,EAAMW,QAAQC,KAAKC,uBAC7BR,QAAS,EACTS,WAAYd,EAAMe,YAAYnE,OAAO,WACrCoE,eAAgB,OAChBC,QAAS,OACT,CAACjB,EAAMkB,YAAYC,KAAK,OAAQ,CAC5BV,MAAO,IAQX,yCAA0C,CACtCF,QAAS,SAGjBa,SAAU,CAENC,UAAW,iBACXlE,SAAU,UACV,CAAC6C,EAAMkB,YAAYC,KAAK,OAAQ,CAC5BhE,SAAU,gBAIhBmE,GAAoC,QAAkBxB,EAA2BjD,KAAM,CACzF,OACA,YACA,OACA,aAEW,SAASiD,GAA2B,OAAEP,EAAM,KAAEV,EAAI,UAAE0C,IAC/D,MAAM,QAAErB,EAAO,GAAEsB,GAAO3B,IAMlB4B,EAAa,IAFFF,EAAUhF,QAAQ2B,OAAOY,SAASD,EAAKD,MAAMJ,OACrCK,EAAKD,MAAMJ,MAAQ+C,EAAUhF,QAAQ2B,OAAO,KAO/DwD,GAAkB,IAAAC,UAAQ,KAAM,QAA6BpC,EAAOqC,SAAS,CAACrC,EAAOqC,SACrFC,GAAoB,QAAQhD,EAAM,CACpC6C,gBAAiBA,ICpEhBI,cAGAC,UAAU,QAGVvE,QAAQ,aAAc,IAEtBA,QAAQ,UAAW,KAEnBA,QAAQ,qBAAsB,ID4DnC,OAAQ,SAAK,KAAiB,CAAEwE,GAAIP,EAAYQ,GAAIJ,KAAcN,EAAUhF,QAAQ4B,eAAgB+D,UAAWV,EAAGF,EAAkCnB,KAAMD,EAAQC,MAM9J5C,MAAO,CAAE4E,UAAWtD,EAAKD,MAAMuD,WAAaC,UAAU,UAAM,OAAQ,CAAEF,UAAWV,EAAGF,EAAkChB,UAAWJ,EAAQI,WAAY8B,SAAU,EAAC,SAAK,IAAK,CAAEC,KAAM,IAAIR,IAAaS,iBAAiB,EAAOJ,UAAWV,EAAGF,EAAkClB,KAAMF,EAAQE,MAAOgC,UAAU,SAAKG,EAAA,EAAU,CAAEL,UAAWV,EAAGF,EAAkCF,SAAUlB,EAAQkB,eAAiB,SAAK,KAAiB,CAAEY,GAAI,aAClb,CE5CA,MAhC0B/D,EAAQuE,OAAO,CACrC,UAAA1F,GACI,IAAI2F,EACJ,MAAO,IAIuB,QAAtBA,EAAKxF,KAAKyF,cAA2B,IAAPD,OAAgB,EAASA,EAAGE,KAAK1F,MACnE2F,uBAAuB,EAE/B,EACA,QAAAC,GAQQ5F,KAAKV,QAAQqG,uBACbE,YAAW,MAuBhB,SAAsCvD,GACzC,GAAIA,EAAOwD,eAAiB,YAAaxD,EAAOyD,SAG5C,OAEJ,MACMC,EADcC,OAAOC,SAASC,KACNC,MAAM,GACpC,IAAKJ,EACD,OAEJ,MAAMK,EAAiBJ,OAAOK,SAASC,eAAeP,GAGlDK,GAAkB/D,EAAOhD,QAAQe,QAAQmG,SAASH,IAClDA,EAAeI,eAAe,CAC1BC,SAAU,SACVC,MAAO,QACPC,OAAQ,WAGpB,CA3CgBC,CAA6B7G,KAAKsC,OAAO,GAGrD,EAIA,WAAAwE,GACI,OAAO,QAAsBjE,EACjC,G,yECxCOkE,E,uBACX,SAAWA,GACPA,EAAcA,EAAsB,OAAI,GAAK,SAC7CA,EAAcA,EAAiC,kBAAI,GAAK,oBACxDA,EAAcA,EAAyB,UAAI,GAAK,WACnD,CAJD,CAIGA,IAAkBA,EAAgB,CAAC,IAUtC,MAAMC,EAAwB,KAAUrH,OAAO,CAC3CC,KAAM,wBACN,UAAAqH,GACI,MAAO,CACHC,MAAOH,EAAcI,OACrBC,uBAAmBC,EAE3B,EACA,WAAA5G,GACI,MAAO,CACH6G,mBAAoB,CAACF,EAAoB,CAAC,IAAM,EAAG9E,SAAQ3B,QAAO4G,eAC9D,MAAMC,EAAmBxH,KAAK+F,QAAQmB,MACtC,IAAIO,EAiCJ,OAhCInF,EAAOoF,SAAS,SAGZF,IAAqBT,EAAcY,mBAanChH,IAAQiH,gBAAgB,QAAQC,QAAQhH,MAE5C4G,EAAeV,EAAcY,mBAI7BF,EAAeV,EAAce,UAE7BP,IAKAvH,KAAK+F,QAAQmB,MAAQO,EACrBzH,KAAK+F,QAAQqB,kBAAoBA,IAE9B,CAAI,EAEfW,qBAAsB,IAAM,EAAGR,eAC3B,MAAMC,EAAmBxH,KAAK+F,QAAQmB,MAChCO,EAAeV,EAAce,UACnC,OAAIN,IAAqBC,IAGrBF,IAGAvH,KAAK+F,QAAQmB,MAAQO,IAElB,EAAI,EAEfO,oBAAqB,IAAM,EAAGjG,WAAUwF,cACXvH,KAAK+F,QAAQmB,QACbH,EAAcI,SAKvCpF,EAAS8F,QACLN,IAKAvH,KAAK+F,QAAQmB,MAAQH,EAAcI,SAEhC,GAGnB,EACA,iBAAAc,GAcQjI,KAAK+F,QAAQmB,QAAUH,EAAce,UACrC9H,KAAKsC,OAAOP,SAASiG,sBAEhBhI,KAAK+F,QAAQmB,QAAUH,EAAcY,mBACzC3H,KAAKsC,OAAOoF,SAAS,SACtB1H,KAAKsC,OAAOP,SAASiG,qBAE7B,EACA,oBAAA7F,GACI,MAAO,CACH,cAAe,KACXnC,KAAKsC,OAAOP,SAASuF,sBACd,GAGnB,EACA,qBAAAY,GACI,MAAO,CACH,IAAI,KAAO,CACPC,IAAK,IAAI,KAAU,0BACnBC,MAAO,CACHC,YAAa,CAACC,EAAMC,EAAKC,KACrB,MAAM7G,GAAQ,QAAc2G,EAAKpB,MAAO,QAoBxC,OAnBasB,EAAMC,OAAOC,QAAQ,MAS9B/G,EAAMyD,MACNpF,KAAK+F,QAAQmB,QAAUH,EAAcI,OACrCnH,KAAKsC,OAAOP,SAASuF,qBAGrBtH,KAAKsC,OAAOP,SAASiG,uBAKlB,CAAK,KAKhC,IAEJ,K,oFC7JA,MAAMW,EAAa,2DACbC,EAAQ,KAAKjJ,OAAO,CACtBC,KAAM,QACN,UAAAC,GACI,MAAO,CACH+G,QAAQ,EACRiC,aAAa,EACb3H,eAAgB,CAAC,EAEzB,EACA,MAAA0F,GACI,OAAO5G,KAAKV,QAAQsH,MACxB,EACA,KAAAxF,GACI,OAAOpB,KAAKV,QAAQsH,OAAS,SAAW,OAC5C,EACAkC,WAAW,EACX,aAAAxH,GACI,MAAO,CACHyH,IAAK,CACD5I,QAAS,MAEb6I,IAAK,CACD7I,QAAS,MAEb8I,MAAO,CACH9I,QAAS,MAGrB,EACA,SAAAC,GACI,MAAO,CACH,CACIsB,IAAK1B,KAAKV,QAAQuJ,YACZ,WACA,gCAGlB,EACA,UAAArI,EAAW,eAAEU,IACT,MAAO,CAAC,OAAO,QAAgBlB,KAAKV,QAAQ4B,eAAgBA,GAChE,EACA,WAAAT,GACI,MAAO,CACHyI,SAAU5J,GAAW,EAAGyC,cACbA,EAASoH,cAAc,CAC1BzG,KAAM1C,KAAKJ,KACX+B,MAAOrC,IAIvB,EACA,aAAAiD,GACI,MAAO,EACH,QAAc,CACVC,KAAMmG,EACNjG,KAAM1C,KAAK0C,KACXC,cAAeyG,IACX,MAAO,CAAE,CAAEJ,EAAKD,EAAKE,GAASG,EAC9B,MAAO,CAAEL,MAAKC,MAAKC,QAAO,IAI1C,I,mEC9DJ,MAAMrG,GAAY,QAAW,CAAEhD,KAAM,CAAEyJ,0BAArB,EAAiDtG,IAAU,CACzEG,KAAM,CACFK,SAAU,WAGV+F,QAAS,EACTC,OAAQ,EACRC,MAAO,GACPC,OAAQ,GACRC,WAAY3G,EAAMW,QAAQiG,QAAQC,KAClCC,OAAQ,mBAGT,SAASR,GAAsB,SAAES,EAAQ,UAAE7E,IAC9C,MAAM,QAAEhC,EAAO,GAAEsB,GAAO3B,KACjBmH,EAAWC,IAAgB,IAAAC,WAAS,IAC3C,IAAAC,YAAU,KACN,MAAMC,EAAmB3B,IACrBsB,EAAStB,EAAM,EAQnB,OANIuB,GAIA9D,OAAOmE,iBAAiB,YAAaD,GAElC,KACHlE,OAAOoE,oBAAoB,YAAaF,EAAgB,CAC3D,GACF,CAACJ,EAAWD,KACf,IAAAI,YAAU,KACN,MAAMI,EAAgB,IAAMN,GAAa,GAEzC,OADA/D,OAAOmE,iBAAiB,UAAWE,GAC5B,KACHrE,OAAOoE,oBAAoB,UAAWC,EAAc,CACvD,GACF,IACH,MAAMC,GAAkB,IAAAC,cAAaC,IACjCT,GAAa,EAAK,GACnB,IACH,OAMA,SAAK,MAAO,CAKR/E,UAAWV,EAAGtB,EAAQC,KAAM+B,GAAYyF,YAAaH,GAC7D,CCjDA,MACM,GAAY,QAAW,CAAE3K,KAAM,CAAE+K,4BAArB,EAAmD5H,IAAU,CAC3E6H,eAAgB,CAGZtH,QAAS,eAGTC,SAAU,YAEdsH,MAAO,CAGHvH,QAAS,SAEbwH,cAAe,CAIX9G,QAAS,aAAajB,EAAMW,QAAQiG,QAAQC,QAEhDmB,QAAS,CASL,0CAA2C,CACvCzH,QAAS,aAIrB,SAASqH,GAAwB,KAAE/I,EAAI,SAAEoJ,EAAQ,iBAAEC,IAC/C,IAAIzF,EACJ,MAAM,QAAEvC,EAAO,GAAEsB,GAAO,KAClB,MAAE5C,GAAUC,EACZsJ,GAAW,IAAAC,QAAO,MAClBC,GAAe,IAAA1G,UAAQ,IAG7B,KAAU8D,IACN,IAAK0C,EAASG,QACV,OAEJ,MAAMC,EAAuBJ,EAASG,QAAQE,wBAMxCC,EAAehD,EAAMiD,QAAUH,EAAqBI,EACpDC,EAAgBnD,EAAMoD,QAAUN,EAAqBO,EASrDC,EAAiBC,KAAKC,IAAIR,EAAeF,EAAqB9B,MAAQ8B,EAAqB7B,OAC7FkC,EAhEuB,IAqE3BV,EAAiB,CACbzB,MAAOuC,KAAKE,MAAMH,IACpB,GACH,GAAI,CAAEtM,UAAU,KAChB,CAACyL,IACJ,OAAQ,SAAK,KAAiB,CAAE3K,MAAO,CAM/B4E,UAAWvD,EAAMuD,UACjBsE,MAAO,QACRrE,UAAU,UAAM,MAAO,CAAEF,UAAWhC,EAAQ2H,eAAgBzF,SAAU,EAAC,SAAK,MAAO,CAAE+G,IAAKhB,EAAUnC,IAAKpH,EAAMoH,IAAKU,OAAQ,OAAQD,MAAO7H,EAAM6H,MAAQ7H,EAAM6H,WAAQnC,EAE9J2B,IAAKrH,EAAMqH,UAAO3B,EAElB4B,MAAOtH,EAAMsH,YAAS5B,EAAWpC,UAAWV,EAAGtB,EAAQ4H,MAGvDG,GAAY,2BAEZA,GAAY/H,EAAQ6H,eAAgBxK,MAAO,CAEvC6L,SAAUxK,EAAM6H,WAAQnC,EAAY,OAGpC+E,YAA0C,QAA5B5G,EAAK7D,EAAMyK,mBAAgC,IAAP5G,EAAgBA,OAAK6B,GACxE,oBAAoB,EAKvBgF,OAAS7D,IACL,MAAM8D,EAAgB,CAAC,EAClB3K,EAAM6H,QACP8C,EAAc9C,MAAQhB,EAAM+D,cAAcC,cAEzC7K,EAAMyK,cACPE,EAAcF,YAAcK,OAAOjE,EAAM+D,cAAcC,aACnDhE,EAAM+D,cAAcG,iBAExBJ,EAAc9C,OAAS8C,EAAcF,cACrCnB,EAAiBqB,EACrB,IACEtB,IAAa,SAAK3B,EAAuB,CAAES,SAAUsB,EAAcnG,UAAWhC,EAAQ8H,cAChH,CACA,QCwCA,MAxJuBnC,EAAMrD,OAAO,CAChC,UAAA1F,GACI,IAAI2F,EACJ,MAAO,IAIuB,QAAtBA,EAAKxF,KAAKyF,cAA2B,IAAPD,OAAgB,EAASA,EAAGE,KAAK1F,MAEnE2M,gBAAkB5D,KACTA,EAOjB,EACA,aAAAzH,GACI,IAAIkE,EACJ,MAAO,IACuB,QAAtBA,EAAKxF,KAAKyF,cAA2B,IAAPD,OAAgB,EAASA,EAAGE,KAAK1F,MAMnEwJ,MAAO,CACHrJ,QAAS,KAGTK,WAAaP,IAAe,CACxBuJ,MAAOvJ,EAAWuJ,QAGtBpJ,UAAYC,GAAYA,EAAQuM,aAAa,UAYjDR,YAAa,CACTjM,QAAS,KACTK,WAAaP,GACJA,EAAWmM,YAGT,CACH9L,MAAO,iBAAiBL,EAAWmM,eAH5B,CAAC,EAMhBhM,UAAYC,GAAYA,EAAQC,MAAM8L,aAGlD,EACA,UAAA5L,EAAW,eAAEU,IACT,MAAO,CACH,OACA,QAGA,CACIuI,OAAQ,QACTzJ,KAAKV,QAAQ4B,eAAgBA,GAExC,EACA,SAAAd,GACI,MAAO,CACH,CAIIsB,IAAK1B,KAAKV,QAAQuJ,YACZ,WACA,+BAONgE,SAAWjL,IACP,KAAMA,aAAgBkL,SAIlB,OAAO,EAMX,MAAM/D,EAAMnH,EAAKgL,aAAa,OAC9B,OAAO5M,KAAKV,QAAQqN,gBAAgB5D,IAAQ,IAAI,GAIhE,EAOA,aAAAxG,GACI,IAAIiD,EACJ,MAAMuH,EAA0C,QAAtBvH,EAAKxF,KAAKyF,cAA2B,IAAPD,OAAgB,EAASA,EAAGE,KAAK1F,MACzF,IAAK+M,EACD,MAAO,GAiBX,OAAOA,EAAiBtL,KAAKuL,GAAS,IAAI,KAAU,CAChDxK,KAAMwK,EAAKxK,KACXyK,QAAU7E,IACN,MAAMnI,EAhBQ,CAACmJ,IACnB,MAAO,CAAE,CAAEJ,EAAKD,EAAKE,GAASG,EAC9B,MAAO,CAAEL,MAAKC,MAAKC,QAAO,EAcHtG,CAAcyF,EAAMgB,OACvC,GAAKpJ,KAAKV,QAAQqN,gBAAgB1M,EAAW8I,KAK7C,OAAOiE,EAAKC,QAAQ7E,EAAM,KAGtC,EACA,WAAAtB,GAKI,OAAO,QAAsB,EACjC,G,0EClJAoG,EACAC,E,iEACJ,GAAsB,oBAAXC,QAAwB,CACjC,IAAIC,EAAwB,IAAID,QAChCF,EAAiB/E,GAAQkF,EAAMC,IAAInF,GACnCgF,EAAa,CAAChF,EAAKoF,KACjBF,EAAMG,IAAIrF,EAAKoF,GACRA,EAEX,KAAO,CACL,MAAMF,EAAQ,GACRI,EAAY,GAClB,IAAIC,EAAW,EACfR,EAAiB/E,IACf,IAAK,IAAIwF,EAAI,EAAGA,EAAIN,EAAMO,OAAQD,GAAK,EACrC,GAAIN,EAAMM,IAAMxF,EACd,OAAOkF,EAAMM,EAAI,EAAE,EAEzBR,EAAa,CAAChF,EAAKoF,KACbG,GAAYD,IACdC,EAAW,GACbL,EAAMK,KAAcvF,EACbkF,EAAMK,KAAcH,EAE/B,CACA,IAAIM,EAAW,MACb,WAAAC,CAAYtE,EAAOC,EAAQhI,EAAKsM,GAC9B/N,KAAKwJ,MAAQA,EACbxJ,KAAKyJ,OAASA,EACdzJ,KAAKyB,IAAMA,EACXzB,KAAK+N,SAAWA,CAClB,CAEA,QAAAC,CAASzF,GACP,IAAK,IAAIoF,EAAI,EAAGA,EAAI3N,KAAKyB,IAAImM,OAAQD,IAAK,CACxC,MAAMM,EAASjO,KAAKyB,IAAIkM,GACxB,GAAIM,GAAU1F,EACZ,SACF,MAAM/E,EAAOmK,EAAI3N,KAAKwJ,MAChB0E,EAAMP,EAAI3N,KAAKwJ,MAAQ,EAC7B,IAAID,EAAQ/F,EAAO,EACf8F,EAAS4E,EAAM,EACnB,IAAK,IAAIC,EAAI,EAAG5E,EAAQvJ,KAAKwJ,OAASxJ,KAAKyB,IAAIkM,EAAIQ,IAAMF,EAAQE,IAC/D5E,IAEF,IAAK,IAAI4E,EAAI,EAAG7E,EAAStJ,KAAKyJ,QAAUzJ,KAAKyB,IAAIkM,EAAI3N,KAAKwJ,MAAQ2E,IAAMF,EAAQE,IAC9E7E,IAEF,MAAO,CAAE9F,OAAM0K,MAAK3E,QAAOD,SAC7B,CACA,MAAM,IAAI8E,WAAW,uBAAuB7F,UAC9C,CAEA,QAAA8F,CAAS9F,GACP,IAAK,IAAIoF,EAAI,EAAGA,EAAI3N,KAAKyB,IAAImM,OAAQD,IACnC,GAAI3N,KAAKyB,IAAIkM,IAAMpF,EACjB,OAAOoF,EAAI3N,KAAKwJ,MAGpB,MAAM,IAAI4E,WAAW,uBAAuB7F,UAC9C,CAGA,QAAA+F,CAAS/F,EAAKgG,EAAMC,GAClB,MAAM,KAAEhL,EAAI,MAAE+F,EAAK,IAAE2E,EAAG,OAAE5E,GAAWtJ,KAAKgO,SAASzF,GACnD,MAAY,SAARgG,GACEC,EAAM,EAAY,GAARhL,EAAY+F,GAASvJ,KAAKwJ,OAC/B,KACFxJ,KAAKyB,IAAIyM,EAAMlO,KAAKwJ,OAASgF,EAAM,EAAIhL,EAAO,EAAI+F,KAErDiF,EAAM,EAAW,GAAPN,EAAW5E,GAAUtJ,KAAKyJ,QAC/B,KACFzJ,KAAKyB,IAAI+B,EAAOxD,KAAKwJ,OAASgF,EAAM,EAAIN,EAAM,EAAI5E,GAE7D,CAEA,WAAAmF,CAAYC,EAAGC,GACb,MACEnL,KAAMoL,EACNrF,MAAOsF,EACPX,IAAKY,EACLxF,OAAQyF,GACN/O,KAAKgO,SAASU,IAEhBlL,KAAMwL,EACNzF,MAAO0F,EACPf,IAAKgB,EACL5F,OAAQ6F,GACNnP,KAAKgO,SAASW,GAClB,MAAO,CACLnL,KAAMuI,KAAKqD,IAAIR,EAAOI,GACtBd,IAAKnC,KAAKqD,IAAIN,EAAMI,GACpB3F,MAAOwC,KAAKC,IAAI6C,EAAQI,GACxB3F,OAAQyC,KAAKC,IAAI+C,EAASI,GAE9B,CAGA,WAAAE,CAAYC,GACV,MAAMC,EAAS,GACTC,EAAO,CAAC,EACd,IAAK,IAAIC,EAAMH,EAAKpB,IAAKuB,EAAMH,EAAKhG,OAAQmG,IAC1C,IAAK,IAAIC,EAAMJ,EAAK9L,KAAMkM,EAAMJ,EAAK/F,MAAOmG,IAAO,CACjD,MAAMC,EAAQF,EAAMzP,KAAKwJ,MAAQkG,EAC3BnH,EAAMvI,KAAKyB,IAAIkO,GACjBH,EAAKjH,KAETiH,EAAKjH,IAAO,EACRmH,GAAOJ,EAAK9L,MAAQkM,GAAO1P,KAAKyB,IAAIkO,EAAQ,IAAMpH,GAAOkH,GAAOH,EAAKpB,KAAOuB,GAAOzP,KAAKyB,IAAIkO,EAAQ3P,KAAKwJ,QAAUjB,GAGvHgH,EAAOK,KAAKrH,GACd,CAEF,OAAOgH,CACT,CAGA,UAAAM,CAAWJ,EAAKC,EAAKI,GACnB,IAAK,IAAInC,EAAI,EAAGoC,EAAW,GAAKpC,IAAK,CACnC,MAAMqC,EAASD,EAAWD,EAAMG,MAAMtC,GAAGuC,SACzC,GAAIvC,GAAK8B,EAAK,CACZ,IAAIE,EAAQD,EAAMD,EAAMzP,KAAKwJ,MAC7B,MAAM2G,GAAeV,EAAM,GAAKzP,KAAKwJ,MACrC,KAAOmG,EAAQQ,GAAenQ,KAAKyB,IAAIkO,GAASI,GAC9CJ,IACF,OAAOA,GAASQ,EAAcH,EAAS,EAAIhQ,KAAKyB,IAAIkO,EACtD,CACAI,EAAWC,CACb,CACF,CAEA,UAAO1C,CAAIwC,GACT,OAAO5C,EAAc4C,IAAU3C,EAAW2C,EAG9C,SAAoBA,GAClB,GAAiC,SAA7BA,EAAMpN,KAAK0N,KAAKC,UAClB,MAAM,IAAIjC,WAAW,qBAAuB0B,EAAMpN,KAAK9C,MACzD,MAAM4J,EAsER,SAAmBsG,GACjB,IAAItG,GAAS,EACT8G,GAAa,EACjB,IAAK,IAAIb,EAAM,EAAGA,EAAMK,EAAMS,WAAYd,IAAO,CAC/C,MAAMe,EAAUV,EAAMG,MAAMR,GAC5B,IAAIgB,EAAW,EACf,GAAIH,EACF,IAAK,IAAInC,EAAI,EAAGA,EAAIsB,EAAKtB,IAAK,CAC5B,MAAMuC,EAAUZ,EAAMG,MAAM9B,GAC5B,IAAK,IAAIR,EAAI,EAAGA,EAAI+C,EAAQH,WAAY5C,IAAK,CAC3C,MAAMgD,EAAOD,EAAQT,MAAMtC,GACvBQ,EAAIwC,EAAKhP,MAAMiP,QAAUnB,IAC3BgB,GAAYE,EAAKhP,MAAMkP,QAC3B,CACF,CACF,IAAK,IAAIlD,EAAI,EAAGA,EAAI6C,EAAQD,WAAY5C,IAAK,CAC3C,MAAMgD,EAAOH,EAAQP,MAAMtC,GAC3B8C,GAAYE,EAAKhP,MAAMkP,QACnBF,EAAKhP,MAAMiP,QAAU,IACvBN,GAAa,EACjB,EACc,GAAV9G,EACFA,EAAQiH,EACDjH,GAASiH,IAChBjH,EAAQuC,KAAKC,IAAIxC,EAAOiH,GAC5B,CACA,OAAOjH,CACT,CAjGgBsH,CAAUhB,GAAQrG,EAASqG,EAAMS,WACzC9O,EAAM,GACZ,IAAIsP,EAAS,EACThD,EAAW,KACf,MAAMiD,EAAY,GAClB,IAAK,IAAIrD,EAAI,EAAGsD,EAAIzH,EAAQC,EAAQkE,EAAIsD,EAAGtD,IACzClM,EAAIkM,GAAK,EACX,IAAK,IAAI8B,EAAM,EAAGlH,EAAM,EAAGkH,EAAMhG,EAAQgG,IAAO,CAC9C,MAAMe,EAAUV,EAAMG,MAAMR,GAC5BlH,IACA,IAAK,IAAIoF,EAAI,GAAKA,IAAK,CACrB,KAAOoD,EAAStP,EAAImM,QAAyB,GAAfnM,EAAIsP,IAChCA,IACF,GAAIpD,GAAK6C,EAAQD,WACf,MACF,MAAMW,EAAWV,EAAQP,MAAMtC,IACzB,QAAEkD,EAAO,QAAED,EAAO,SAAEO,GAAaD,EAASvP,MAChD,IAAK,IAAIyP,EAAI,EAAGA,EAAIR,EAASQ,IAAK,CAChC,GAAIA,EAAI3B,GAAOhG,EAAQ,EACpBsE,IAAaA,EAAW,KAAK6B,KAAK,CACjClN,KAAM,mBACN6F,MACA8I,EAAGT,EAAUQ,IAEf,KACF,CACA,MAAME,EAAQP,EAASK,EAAI5H,EAC3B,IAAK,IAAI+H,EAAI,EAAGA,EAAIV,EAASU,IAAK,CACV,GAAlB9P,EAAI6P,EAAQC,GACd9P,EAAI6P,EAAQC,GAAKhJ,GAEhBwF,IAAaA,EAAW,KAAK6B,KAAK,CACjClN,KAAM,YACN+M,MACAlH,MACA8I,EAAGR,EAAUU,IAEjB,MAAMC,EAAOL,GAAYA,EAASI,GAClC,GAAIC,EAAM,CACR,MAAMC,GAAcH,EAAQC,GAAK/H,EAAQ,EAAGkI,EAAOV,EAAUS,GACjD,MAARC,GAAgBA,GAAQF,GAAqC,GAA7BR,EAAUS,EAAa,IACzDT,EAAUS,GAAcD,EACxBR,EAAUS,EAAa,GAAK,GACnBC,GAAQF,GACjBR,EAAUS,EAAa,IAE3B,CACF,CACF,CACAV,GAAUF,EACVtI,GAAO2I,EAAShB,QAClB,CACA,MAAMyB,GAAelC,EAAM,GAAKjG,EAChC,IAAIoI,EAAU,EACd,KAAOb,EAASY,GACO,GAAjBlQ,EAAIsP,MACNa,IACAA,IACD7D,IAAaA,EAAW,KAAK6B,KAAK,CAAElN,KAAM,UAAW+M,MAAK4B,EAAGO,IAChErJ,GACF,CACA,MAAMsJ,EAAW,IAAIhE,EAASrE,EAAOC,EAAQhI,EAAKsM,GAClD,IAAI+D,GAAY,EAChB,IAAK,IAAInE,EAAI,GAAImE,GAAanE,EAAIqD,EAAUpD,OAAQD,GAAK,EACnC,MAAhBqD,EAAUrD,IAAcqD,EAAUrD,EAAI,GAAKlE,IAC7CqI,GAAY,GACZA,GAgCN,SAA0BrQ,EAAKuP,EAAWlB,GACnCrO,EAAIsM,WACPtM,EAAIsM,SAAW,IACjB,MAAMyB,EAAO,CAAC,EACd,IAAK,IAAI7B,EAAI,EAAGA,EAAIlM,EAAIA,IAAImM,OAAQD,IAAK,CACvC,MAAMpF,EAAM9G,EAAIA,IAAIkM,GACpB,GAAI6B,EAAKjH,GACP,SACFiH,EAAKjH,IAAO,EACZ,MAAM3G,EAAOkO,EAAMiC,OAAOxJ,GAC1B,IAAK3G,EACH,MAAM,IAAIwM,WAAW,uBAAuB7F,WAE9C,IAAIyJ,EAAU,KACd,MAAMrQ,EAAQC,EAAKD,MACnB,IAAK,IAAIwM,EAAI,EAAGA,EAAIxM,EAAMkP,QAAS1C,IAAK,CACtC,MACM8D,EAAWjB,EAAgB,IADpBrD,EAAIQ,GAAK1M,EAAI+H,QAEV,MAAZyI,GAAsBtQ,EAAMwP,UAAYxP,EAAMwP,SAAShD,IAAM8D,KAC9DD,IAAYA,EAAUE,EAAcvQ,KAASwM,GAAK8D,EACvD,CACID,GACFvQ,EAAIsM,SAASoE,QAAQ,CACnBzP,KAAM,oBACN6F,MACA4I,SAAUa,GAEhB,CACF,CA3DII,CAAiBP,EAAUb,EAAWlB,GACxC,OAAO+B,CACT,CA3EqDQ,CAAWvC,GAC9D,GAoIF,SAASoC,EAAcvQ,GACrB,GAAIA,EAAMwP,SACR,OAAOxP,EAAMwP,SAAS/K,QACxB,MAAMmJ,EAAS,GACf,IAAK,IAAI5B,EAAI,EAAGA,EAAIhM,EAAMkP,QAASlD,IACjC4B,EAAOK,KAAK,GACd,OAAOL,CACT,CAgGA,SAAS+C,EAAe3N,GACtB,IAAI4K,EAAS5K,EAAO4N,OAAOD,eAC3B,IAAK/C,EAAQ,CACXA,EAAS5K,EAAO4N,OAAOD,eAAiB,CAAC,EACzC,IAAK,MAAM1S,KAAQ+E,EAAO6N,MAAO,CAC/B,MAAM9P,EAAOiC,EAAO6N,MAAM5S,GAAO6S,EAAO/P,EAAK0N,KAAKC,UAC9CoC,IACFlD,EAAOkD,GAAQ/P,EACnB,CACF,CACA,OAAO6M,CACT,CAGA,IAAImD,EAAkB,IAAI,KAAU,kBACpC,SAASC,EAAWC,GAClB,IAAK,IAAIC,EAAID,EAAKE,MAAQ,EAAGD,EAAI,EAAGA,IAClC,GAAwC,OAApCD,EAAKhR,KAAKiR,GAAGnQ,KAAK0N,KAAKC,UACzB,OAAOuC,EAAKhR,KAAK,GAAGmR,QAAQH,EAAKI,OAAOH,EAAI,IAChD,OAAO,IACT,CASA,SAASI,EAAU/L,GACjB,MAAMgM,EAAQhM,EAAMiM,UAAUD,MAC9B,IAAK,IAAIL,EAAIK,EAAMJ,MAAOD,EAAI,EAAGA,IAC/B,GAAyC,OAArCK,EAAMtR,KAAKiR,GAAGnQ,KAAK0N,KAAKC,UAC1B,OAAO,EACX,OAAO,CACT,CACA,SAAS+C,EAAclM,GACrB,MAAMmM,EAAMnM,EAAMiM,UAClB,GAAI,gBAAiBE,GAAOA,EAAIC,YAC9B,OAAOD,EAAIC,YAAY/K,IAAM8K,EAAIE,UAAUhL,IAAM8K,EAAIC,YAAcD,EAAIE,UAClE,GAAI,SAAUF,GAAOA,EAAIzR,MAAwC,QAAhCyR,EAAIzR,KAAKc,KAAK0N,KAAKC,UACzD,OAAOgD,EAAIG,QAEb,MAAMC,EAAQd,EAAWU,EAAIH,QAM/B,SAAkBN,GAChB,IAAK,IAAIc,EAAQd,EAAKe,UAAWpL,EAAMqK,EAAKrK,IAAKmL,EAAOA,EAAQA,EAAME,WAAYrL,IAAO,CACvF,MAAMkK,EAAOiB,EAAMhR,KAAK0N,KAAKC,UAC7B,GAAY,QAARoC,GAA0B,eAARA,EACpB,OAAOG,EAAKiB,IAAId,QAAQxK,EAC5B,CACA,IAAK,IAAIyK,EAASJ,EAAKkB,WAAYvL,EAAMqK,EAAKrK,IAAKyK,EAAQA,EAASA,EAAOe,UAAWxL,IAAO,CAC3F,MAAMkK,EAAOO,EAAOtQ,KAAK0N,KAAKC,UAC9B,GAAY,QAARoC,GAA0B,eAARA,EACpB,OAAOG,EAAKiB,IAAId,QAAQxK,EAAMyK,EAAO9C,SACzC,CACF,CAjByC8D,CAASX,EAAIH,OACpD,GAAIO,EACF,OAAOA,EAET,MAAM,IAAIrF,WAAW,iCAAiCiF,EAAIY,OAC5D,CAaA,SAASC,EAAatB,GACpB,MAA0C,OAAnCA,EAAKnN,OAAO/C,KAAK0N,KAAKC,aAAwBuC,EAAKe,SAC5D,CAIA,SAASQ,EAAYC,EAAQC,GAC3B,OAAOD,EAAOtB,OAASuB,EAAOvB,OAASsB,EAAO7L,KAAO8L,EAAO/C,OAAO,IAAM8C,EAAO7L,KAAO8L,EAAOC,KAAK,EACrG,CAOA,SAAShG,EAASsE,EAAMrE,EAAMC,GAC5B,MAAMsB,EAAQ8C,EAAKhR,MAAM,GACnBH,EAAMoM,EAASP,IAAIwC,GACnByE,EAAa3B,EAAKtB,OAAO,GACzBkD,EAAQ/S,EAAI6M,SAASsE,EAAKrK,IAAMgM,EAAYhG,EAAMC,GACxD,OAAgB,MAATgG,EAAgB,KAAO5B,EAAKhR,KAAK,GAAGmR,QAAQwB,EAAaC,EAClE,CACA,SAASC,EAAc9S,EAAO4G,EAAK8I,EAAI,GACrC,MAAM9B,EAAS,IAAK5N,EAAOkP,QAASlP,EAAMkP,QAAUQ,GAOpD,OANI9B,EAAO4B,WACT5B,EAAO4B,SAAW5B,EAAO4B,SAAS/K,QAClCmJ,EAAO4B,SAASuD,OAAOnM,EAAK8I,GACvB9B,EAAO4B,SAASwD,MAAMpD,GAAMA,EAAI,MACnChC,EAAO4B,SAAW,OAEf5B,CACT,CACA,SAASqF,EAAWjT,EAAO4G,EAAK8I,EAAI,GAClC,MAAM9B,EAAS,IAAK5N,EAAOkP,QAASlP,EAAMkP,QAAUQ,GACpD,GAAI9B,EAAO4B,SAAU,CACnB5B,EAAO4B,SAAW5B,EAAO4B,SAAS/K,QAClC,IAAK,IAAIuH,EAAI,EAAGA,EAAI0D,EAAG1D,IACrB4B,EAAO4B,SAASuD,OAAOnM,EAAK,EAAG,EACnC,CACA,OAAOgH,CACT,CAUA,IAAIsF,EAAgB,MAAMC,UAAuB,KAK/C,WAAAhH,CAAYwF,EAAaC,EAAYD,GACnC,MAAMxD,EAAQwD,EAAY1R,MAAM,GAC1BH,EAAMoM,EAASP,IAAIwC,GACnByE,EAAajB,EAAYhC,OAAO,GAChChC,EAAO7N,EAAIgN,YACf6E,EAAY/K,IAAMgM,EAClBhB,EAAUhL,IAAMgM,GAEZV,EAAMP,EAAY1R,KAAK,GACvBmT,EAAQtT,EAAI4N,YAAYC,GAAM0F,QAAQC,GAAMA,GAAK1B,EAAUhL,IAAMgM,IACvEQ,EAAM5C,QAAQoB,EAAUhL,IAAMgM,GAC9B,MAAMW,EAASH,EAAMtT,KAAK8G,IACxB,MAAMoI,EAAOb,EAAMiC,OAAOxJ,GAC1B,IAAKoI,EACH,MAAMvC,WAAW,uBAAuB7F,WAE1C,MAAM4M,EAAOZ,EAAahM,EAAM,EAChC,OAAO,IAAI,KACTsL,EAAId,QAAQoC,GACZtB,EAAId,QAAQoC,EAAOxE,EAAKxP,QAAQiU,MACjC,IAEHC,MAAMH,EAAO,GAAGI,MAAOJ,EAAO,GAAGK,IAAKL,GACtClV,KAAKsT,YAAcA,EACnBtT,KAAKuT,UAAYA,CACnB,CACA,GAAA9R,CAAIoS,EAAK2B,GACP,MAAMlC,EAAcO,EAAId,QAAQyC,EAAQ/T,IAAIzB,KAAKsT,YAAY/K,MACvDgL,EAAYM,EAAId,QAAQyC,EAAQ/T,IAAIzB,KAAKuT,UAAUhL,MACzD,GAAI2L,EAAaZ,IAAgBY,EAAaX,IAAcY,EAAYb,EAAaC,GAAY,CAC/F,MAAMkC,EAAezV,KAAKsT,YAAY1R,MAAM,IAAM0R,EAAY1R,MAAM,GACpE,OAAI6T,GAAgBzV,KAAK0V,iBAChBZ,EAAea,aAAarC,EAAaC,GACzCkC,GAAgBzV,KAAK4V,iBACrBd,EAAee,aAAavC,EAAaC,GAEzC,IAAIuB,EAAexB,EAAaC,EAC3C,CACA,OAAO,KAAcuC,QAAQxC,EAAaC,EAC5C,CAGA,OAAApS,GACE,MAAM2O,EAAQ9P,KAAKsT,YAAY1R,MAAM,GAC/BH,EAAMoM,EAASP,IAAIwC,GACnByE,EAAavU,KAAKsT,YAAYhC,OAAO,GACrChC,EAAO7N,EAAIgN,YACfzO,KAAKsT,YAAY/K,IAAMgM,EACvBvU,KAAKuT,UAAUhL,IAAMgM,GAEjB/E,EAAO,CAAC,EACRuG,EAAO,GACb,IAAK,IAAItG,EAAMH,EAAKpB,IAAKuB,EAAMH,EAAKhG,OAAQmG,IAAO,CACjD,MAAMuG,EAAa,GACnB,IAAK,IAAIrG,EAAQF,EAAMhO,EAAI+H,MAAQ8F,EAAK9L,KAAMkM,EAAMJ,EAAK9L,KAAMkM,EAAMJ,EAAK/F,MAAOmG,IAAOC,IAAS,CAC/F,MAAMpH,EAAM9G,EAAIA,IAAIkO,GACpB,GAAIH,EAAKjH,GACP,SACFiH,EAAKjH,IAAO,EACZ,MAAM0N,EAAWxU,EAAIuM,SAASzF,GAC9B,IAAIoI,EAAOb,EAAMiC,OAAOxJ,GACxB,IAAKoI,EACH,MAAMvC,WAAW,uBAAuB7F,WAE1C,MAAM2N,EAAY5G,EAAK9L,KAAOyS,EAASzS,KACjC2S,EAAaF,EAAS1M,MAAQ+F,EAAK/F,MACzC,GAAI2M,EAAY,GAAKC,EAAa,EAAG,CACnC,IAAIxU,EAAQgP,EAAKhP,MAWjB,GAVIuU,EAAY,IACdvU,EAAQ8S,EAAc9S,EAAO,EAAGuU,IAE9BC,EAAa,IACfxU,EAAQ8S,EACN9S,EACAA,EAAMkP,QAAUsF,EAChBA,IAGAF,EAASzS,KAAO8L,EAAK9L,MAEvB,GADAmN,EAAOA,EAAKjO,KAAK0T,cAAczU,IAC1BgP,EACH,MAAMvC,WACJ,oCAAoCiI,KAAKC,UAAU3U,WAIvDgP,EAAOA,EAAKjO,KAAK/C,OAAOgC,EAAOgP,EAAKxP,QAExC,CACA,GAAI8U,EAAS/H,IAAMoB,EAAKpB,KAAO+H,EAAS3M,OAASgG,EAAKhG,OAAQ,CAC5D,MAAM3H,EAAQ,IACTgP,EAAKhP,MACRiP,QAAS7E,KAAKqD,IAAI6G,EAAS3M,OAAQgG,EAAKhG,QAAUyC,KAAKC,IAAIiK,EAAS/H,IAAKoB,EAAKpB,MAG9EyC,EADEsF,EAAS/H,IAAMoB,EAAKpB,IACfyC,EAAKjO,KAAK0T,cAAczU,GAExBgP,EAAKjO,KAAK/C,OAAOgC,EAAOgP,EAAKxP,QAExC,CACA6U,EAAWpG,KAAKe,EAClB,CACAoF,EAAKnG,KAAKE,EAAMG,MAAMR,GAAK8G,KAAK,KAASpB,KAAKa,IAChD,CACA,MAAMQ,EAAWxW,KAAK4V,kBAAoB5V,KAAK0V,iBAAmB5F,EAAQiG,EAC1E,OAAO,IAAI,KAAM,KAASZ,KAAKqB,GAAW,EAAG,EAC/C,CACA,OAAAjW,CAAQkW,EAAItV,EAAU,KAAMuV,OAC1B,MAAMC,EAAUF,EAAGG,MAAMhJ,OAAQsH,EAASlV,KAAKkV,OAC/C,IAAK,IAAIvH,EAAI,EAAGA,EAAIuH,EAAOtH,OAAQD,IAAK,CACtC,MAAM,MAAE2H,EAAK,IAAEC,GAAQL,EAAOvH,GAAI6H,EAAUiB,EAAGjB,QAAQpP,MAAMuQ,GAC7DF,EAAGlW,QACDiV,EAAQ/T,IAAI6T,EAAM/M,KAClBiN,EAAQ/T,IAAI8T,EAAIhN,KAChBoF,EAAI,KAAM+I,MAAQvV,EAEtB,CACA,MAAMkS,EAAM,KAAUwD,SACpBJ,EAAG5C,IAAId,QAAQ0D,EAAGjB,QAAQpP,MAAMuQ,GAASlV,IAAIzB,KAAK8W,MACjD,GAECzD,GACFoD,EAAGM,aAAa1D,EACpB,CACA,WAAA2D,CAAYP,EAAI7U,GACd5B,KAAKO,QAAQkW,EAAI,IAAI,KAAM,KAAStB,KAAKvT,GAAO,EAAG,GACrD,CACA,WAAAqV,CAAYC,GACV,MAAMpH,EAAQ9P,KAAKsT,YAAY1R,MAAM,GAC/BH,EAAMoM,EAASP,IAAIwC,GACnByE,EAAavU,KAAKsT,YAAYhC,OAAO,GACrCyD,EAAQtT,EAAI4N,YAChB5N,EAAIgN,YACFzO,KAAKsT,YAAY/K,IAAMgM,EACvBvU,KAAKuT,UAAUhL,IAAMgM,IAGzB,IAAK,IAAI5G,EAAI,EAAGA,EAAIoH,EAAMnH,OAAQD,IAChCuJ,EAAEpH,EAAMiC,OAAOgD,EAAMpH,IAAK4G,EAAaQ,EAAMpH,GAEjD,CAGA,cAAAiI,GACE,MAAMuB,EAAYnX,KAAKsT,YAAY3D,OAAO,GACpCyH,EAAUpX,KAAKuT,UAAU5D,OAAO,GACtC,GAAI5D,KAAKqD,IAAI+H,EAAWC,GAAW,EACjC,OAAO,EACT,MAAMC,EAAeF,EAAYnX,KAAKsT,YAAYK,UAAUhS,MAAMiP,QAC5D0G,EAAaF,EAAUpX,KAAKuT,UAAUI,UAAUhS,MAAMiP,QAC5D,OAAO7E,KAAKC,IAAIqL,EAAcC,IAAetX,KAAKuT,UAAU3R,MAAM,GAAG2O,UACvE,CAGA,mBAAOsF,CAAavC,EAAaC,EAAYD,GAC3C,MAAMxD,EAAQwD,EAAY1R,MAAM,GAC1BH,EAAMoM,EAASP,IAAIwC,GACnByE,EAAajB,EAAYhC,OAAO,GAChCiG,EAAa9V,EAAIuM,SAASsF,EAAY/K,IAAMgM,GAC5CiD,EAAW/V,EAAIuM,SAASuF,EAAUhL,IAAMgM,GACxCV,EAAMP,EAAY1R,KAAK,GAgB7B,OAfI2V,EAAWrJ,KAAOsJ,EAAStJ,KACzBqJ,EAAWrJ,IAAM,IACnBoF,EAAcO,EAAId,QAAQwB,EAAa9S,EAAIA,IAAI8V,EAAW/T,QACxDgU,EAASlO,OAAS7H,EAAIgI,SACxB8J,EAAYM,EAAId,QACdwB,EAAa9S,EAAIA,IAAIA,EAAI+H,OAAS/H,EAAIgI,OAAS,GAAK+N,EAASjO,MAAQ,OAGrEiO,EAAStJ,IAAM,IACjBqF,EAAYM,EAAId,QAAQwB,EAAa9S,EAAIA,IAAI+V,EAAShU,QACpD+T,EAAWjO,OAAS7H,EAAIgI,SAC1B6J,EAAcO,EAAId,QAChBwB,EAAa9S,EAAIA,IAAIA,EAAI+H,OAAS/H,EAAIgI,OAAS,GAAK8N,EAAWhO,MAAQ,MAGtE,IAAIuL,EAAexB,EAAaC,EACzC,CAGA,cAAAmC,GACE,MAAM5F,EAAQ9P,KAAKsT,YAAY1R,MAAM,GAC/BH,EAAMoM,EAASP,IAAIwC,GACnByE,EAAavU,KAAKsT,YAAYhC,OAAO,GACrCmG,EAAahW,EAAI4M,SAASrO,KAAKsT,YAAY/K,IAAMgM,GACjDmD,EAAWjW,EAAI4M,SAASrO,KAAKuT,UAAUhL,IAAMgM,GACnD,GAAIxI,KAAKqD,IAAIqI,EAAYC,GAAY,EACnC,OAAO,EACT,MAAMC,EAAcF,EAAazX,KAAKsT,YAAYK,UAAUhS,MAAMkP,QAC5D+G,EAAYF,EAAW1X,KAAKuT,UAAUI,UAAUhS,MAAMkP,QAC5D,OAAO9E,KAAKC,IAAI2L,EAAaC,IAAcnW,EAAI+H,KACjD,CACA,EAAAqO,CAAGC,GACD,OAAOA,aAAiBhD,GAAkBgD,EAAMxE,YAAY/K,KAAOvI,KAAKsT,YAAY/K,KAAOuP,EAAMvE,UAAUhL,KAAOvI,KAAKuT,UAAUhL,GACnI,CAGA,mBAAOoN,CAAarC,EAAaC,EAAYD,GAC3C,MAAMxD,EAAQwD,EAAY1R,MAAM,GAC1BH,EAAMoM,EAASP,IAAIwC,GACnByE,EAAajB,EAAYhC,OAAO,GAChCiG,EAAa9V,EAAIuM,SAASsF,EAAY/K,IAAMgM,GAC5CiD,EAAW/V,EAAIuM,SAASuF,EAAUhL,IAAMgM,GACxCV,EAAMP,EAAY1R,KAAK,GAkB7B,OAjBI2V,EAAW/T,MAAQgU,EAAShU,MAC1B+T,EAAW/T,KAAO,IACpB8P,EAAcO,EAAId,QAChBwB,EAAa9S,EAAIA,IAAI8V,EAAWrJ,IAAMzM,EAAI+H,SAE1CgO,EAASjO,MAAQ9H,EAAI+H,QACvB+J,EAAYM,EAAId,QACdwB,EAAa9S,EAAIA,IAAIA,EAAI+H,OAASgO,EAAStJ,IAAM,GAAK,OAGtDsJ,EAAShU,KAAO,IAClB+P,EAAYM,EAAId,QAAQwB,EAAa9S,EAAIA,IAAI+V,EAAStJ,IAAMzM,EAAI+H,SAC9D+N,EAAWhO,MAAQ9H,EAAI+H,QACzB8J,EAAcO,EAAId,QAChBwB,EAAa9S,EAAIA,IAAIA,EAAI+H,OAAS+N,EAAWrJ,IAAM,GAAK,MAGvD,IAAI4G,EAAexB,EAAaC,EACzC,CACA,MAAAwE,GACE,MAAO,CACLrV,KAAM,OACNsV,OAAQhY,KAAKsT,YAAY/K,IACzB0L,KAAMjU,KAAKuT,UAAUhL,IAEzB,CACA,eAAO0P,CAASpE,EAAKqE,GACnB,OAAO,IAAIpD,EAAejB,EAAId,QAAQmF,EAAKF,QAASnE,EAAId,QAAQmF,EAAKjE,MACvE,CACA,aAAOtU,CAAOkU,EAAKsE,EAAYC,EAAWD,GACxC,OAAO,IAAIrD,EAAejB,EAAId,QAAQoF,GAAatE,EAAId,QAAQqF,GACjE,CACA,WAAAC,GACE,OAAO,IAAIC,EAAatY,KAAKsT,YAAY/K,IAAKvI,KAAKuT,UAAUhL,IAC/D,GAEFsM,EAAc0D,UAAUC,SAAU,EAClC,KAAUC,OAAO,OAAQ5D,GACzB,IAAIyD,EAAe,MAAMI,EACvB,WAAA5K,CAAYkK,EAAQ/D,GAClBjU,KAAKgY,OAASA,EACdhY,KAAKiU,KAAOA,CACd,CACA,GAAAxS,CAAI+T,GACF,OAAO,IAAIkD,EAAclD,EAAQ/T,IAAIzB,KAAKgY,QAASxC,EAAQ/T,IAAIzB,KAAKiU,MACtE,CACA,OAAAlB,CAAQc,GACN,MAAMP,EAAcO,EAAId,QAAQ/S,KAAKgY,QAASzE,EAAYM,EAAId,QAAQ/S,KAAKiU,MAC3E,MAA8C,OAA1CX,EAAY7N,OAAO/C,KAAK0N,KAAKC,WAA8D,OAAxCkD,EAAU9N,OAAO/C,KAAK0N,KAAKC,WAAsBiD,EAAY3D,QAAU2D,EAAY7N,OAAO8K,YAAcgD,EAAU5D,QAAU4D,EAAU9N,OAAO8K,YAAc4D,EAAYb,EAAaC,GAClO,IAAIsB,EAAcvB,EAAaC,GAE/B,KAAUoF,KAAKpF,EAAW,EACrC,GAEF,SAASqF,EAAkB1R,GACzB,KAAMA,EAAMiM,qBAAqB0B,GAC/B,OAAO,KACT,MAAME,EAAQ,GAMd,OALA7N,EAAMiM,UAAU8D,aAAY,CAACrV,EAAM2G,KACjCwM,EAAMnF,KACJ,KAAWhO,KAAK2G,EAAKA,EAAM3G,EAAKsO,SAAU,CAAE2I,MAAO,iBACpD,IAEI,KAAclZ,OAAOuH,EAAM2M,IAAKkB,EACzC,CA+DA,IAAI+D,EAAe,IAAI,KAAW,cAClC,SAASC,EAAmBC,EAAKC,EAAKC,EAAQhC,GAC5C,MAAMiC,EAAUH,EAAIzI,WAAY6I,EAAUH,EAAI1I,WAC9C8I,EACE,IAAK,IAAI1L,EAAI,EAAGQ,EAAI,EAAGR,EAAIyL,EAASzL,IAAK,CACvC,MAAMsC,EAAQgJ,EAAIhJ,MAAMtC,GACxB,IAAK,IAAI2L,EAAOnL,EAAG8C,EAAIlF,KAAKqD,IAAI+J,EAASxL,EAAI,GAAI2L,EAAOrI,EAAGqI,IACzD,GAAIN,EAAI/I,MAAMqJ,IAASrJ,EAAO,CAC5B9B,EAAImL,EAAO,EACXJ,GAAUjJ,EAAMC,SAChB,SAASmJ,CACX,CAEFnC,EAAEjH,EAAOiJ,GACL/K,EAAIgL,GAAWH,EAAI/I,MAAM9B,GAAGoL,WAAWtJ,GACzC8I,EAAmBC,EAAI/I,MAAM9B,GAAI8B,EAAOiJ,EAAS,EAAGhC,GAEpDjH,EAAMuJ,aAAa,EAAGvJ,EAAM9O,QAAQiU,KAAM8B,EAAGgC,EAAS,GACxDA,GAAUjJ,EAAMC,QAClB,CACJ,CACA,SAASuJ,EAAUvS,EAAOwS,GACxB,IAAIjD,EACJ,MAAMkD,EAAQ,CAAC/X,EAAM2G,KACa,SAA5B3G,EAAKc,KAAK0N,KAAKC,YACjBoG,EAQN,SAAkBvP,EAAO4I,EAAO8J,EAAUnD,GACxC,MAAMhV,EAAMoM,EAASP,IAAIwC,GACzB,IAAKrO,EAAIsM,SACP,OAAO0I,EACJA,IACHA,EAAKvP,EAAMuP,IACb,MAAMoD,EAAU,GAChB,IAAK,IAAIlM,EAAI,EAAGA,EAAIlM,EAAIgI,OAAQkE,IAC9BkM,EAAQjK,KAAK,GACf,IAAK,IAAIjC,EAAI,EAAGA,EAAIlM,EAAIsM,SAASH,OAAQD,IAAK,CAC5C,MAAMmM,EAAOrY,EAAIsM,SAASJ,GAC1B,GAAiB,aAAbmM,EAAKpX,KAAqB,CAC5B,MAAMiO,EAAOb,EAAMiC,OAAO+H,EAAKvR,KAC/B,IAAKoI,EACH,SACF,MAAMhP,EAAQgP,EAAKhP,MACnB,IAAK,IAAIwM,EAAI,EAAGA,EAAIxM,EAAMiP,QAASzC,IACjC0L,EAAQC,EAAKrK,IAAMtB,IAAM2L,EAAKzI,EAChCoF,EAAGsD,cACDtD,EAAGjB,QAAQ/T,IAAImY,EAAW,EAAIE,EAAKvR,KACnC,KACAkM,EAAc9S,EAAOA,EAAMkP,QAAUiJ,EAAKzI,EAAGyI,EAAKzI,GAEtD,MAAO,GAAiB,WAAbyI,EAAKpX,KACdmX,EAAQC,EAAKrK,MAAQqK,EAAKzI,OACrB,GAAiB,oBAAbyI,EAAKpX,KAA4B,CAC1C,MAAMiO,EAAOb,EAAMiC,OAAO+H,EAAKvR,KAC/B,IAAKoI,EACH,SACF8F,EAAGsD,cAActD,EAAGjB,QAAQ/T,IAAImY,EAAW,EAAIE,EAAKvR,KAAM,KAAM,IAC3DoI,EAAKhP,MACRiP,QAASD,EAAKhP,MAAMiP,QAAUkJ,EAAKzI,GAEvC,MAAO,GAAiB,qBAAbyI,EAAKpX,KAA6B,CAC3C,MAAMiO,EAAOb,EAAMiC,OAAO+H,EAAKvR,KAC/B,IAAKoI,EACH,SACF8F,EAAGsD,cAActD,EAAGjB,QAAQ/T,IAAImY,EAAW,EAAIE,EAAKvR,KAAM,KAAM,IAC3DoI,EAAKhP,MACRwP,SAAU2I,EAAK3I,UAEnB,CACF,CACA,IAAI6I,EAAOC,EACX,IAAK,IAAItM,EAAI,EAAGA,EAAIkM,EAAQjM,OAAQD,IAC9BkM,EAAQlM,KACG,MAATqM,IACFA,EAAQrM,GACVsM,EAAOtM,GAEX,IAAK,IAAIA,EAAI,EAAGpF,EAAMqR,EAAW,EAAGjM,EAAIlM,EAAIgI,OAAQkE,IAAK,CACvD,MAAM8B,EAAMK,EAAMG,MAAMtC,GAClB2G,EAAM/L,EAAMkH,EAAIS,SAChBgK,EAAML,EAAQlM,GACpB,GAAIuM,EAAM,EAAG,CACX,IAAIzH,EAAO,OACPhD,EAAImE,aACNnB,EAAOhD,EAAImE,WAAWlR,KAAK0N,KAAKC,WAElC,MAAMmC,EAAQ,GACd,IAAK,IAAIrE,EAAI,EAAGA,EAAI+L,EAAK/L,IAAK,CAC5B,MAAMvM,EAAO0Q,EAAepL,EAAMvC,QAAQ8N,GAAM2D,gBAC5CxU,GACF4Q,EAAM5C,KAAKhO,EACf,CACA,MAAMuY,EAAa,GAALxM,GAAUqM,GAASrM,EAAI,GAAMsM,GAAQtM,EAAc2G,EAAM,EAAhB/L,EAAM,EAC7DkO,EAAG2D,OAAO3D,EAAGjB,QAAQ/T,IAAI0Y,GAAO3H,EAClC,CACAjK,EAAM+L,CACR,CACA,OAAOmC,EAAG4D,QAAQvB,EAAc,CAAEW,WAAW,GAC/C,CA/EWa,CAASpT,EAAOtF,EAAM2G,EAAKkO,GAAG,EAMvC,OAJKiD,EAEIA,EAAS7F,KAAO3M,EAAM2M,KAC7BkF,EAAmBW,EAAS7F,IAAK3M,EAAM2M,IAAK,EAAG8F,GAF/CzS,EAAM2M,IAAI0G,YAAYZ,GAGjBlD,CACT,CAqFA,SAAS+D,EAAYpU,GACnB,IAAKA,EAAMgP,KACT,OAAO,KACT,IAAI,QAAEjU,EAAO,UAAEsZ,EAAS,QAAEC,GAAYtU,EACtC,KAA6B,GAAtBjF,EAAQoP,aAAoBkK,EAAY,GAAKC,EAAU,GAA6C,SAAxCvZ,EAAQ8O,MAAM,GAAGvN,KAAK0N,KAAKC,YAC5FoK,IACAC,IACAvZ,EAAUA,EAAQ8O,MAAM,GAAG9O,QAE7B,MAAM6Y,EAAQ7Y,EAAQ8O,MAAM,GACtBwC,EAAOuH,EAAMtX,KAAK0N,KAAKC,UACvB1L,EAASqV,EAAMtX,KAAKiC,OAAQoR,EAAO,GACzC,GAAY,OAARtD,EACF,IAAK,IAAI9E,EAAI,EAAGA,EAAIxM,EAAQoP,WAAY5C,IAAK,CAC3C,IAAIoH,EAAQ5T,EAAQ8O,MAAMtC,GAAGxM,QAC7B,MAAMqC,EAAOmK,EAAI,EAAI5B,KAAKC,IAAI,EAAGyO,EAAY,GACvClR,EAAQoE,EAAIxM,EAAQoP,WAAa,EAAI,EAAIxE,KAAKC,IAAI,EAAG0O,EAAU,IACjElX,GAAQ+F,KACVwL,EAAQ4F,EACNrI,EAAe3N,GAAQ8K,IACvB,IAAI,KAAOsF,EAAOvR,EAAM+F,IACxBpI,SACJ4U,EAAKnG,KAAKmF,EACZ,KACK,IAAY,QAARtC,GAA0B,eAARA,EAQ3B,OAAO,KAPPsD,EAAKnG,KACH6K,GAAaC,EAAUC,EACrBrI,EAAe3N,GAAQ8K,IACvB,IAAI,KAAOtO,EAASsZ,EAAWC,IAC/BvZ,QAAUA,EAIhB,CACA,OAEF,SAA2BwD,EAAQoR,GACjC,MAAM6E,EAAS,GACf,IAAK,IAAIjN,EAAI,EAAGA,EAAIoI,EAAKnI,OAAQD,IAAK,CACpC,MAAM8B,EAAMsG,EAAKpI,GACjB,IAAK,IAAIQ,EAAIsB,EAAIc,WAAa,EAAGpC,GAAK,EAAGA,IAAK,CAC5C,MAAM,QAAEyC,EAAO,QAAEC,GAAYpB,EAAIQ,MAAM9B,GAAGxM,MAC1C,IAAK,IAAIkZ,EAAIlN,EAAGkN,EAAIlN,EAAIiD,EAASiK,IAC/BD,EAAOC,IAAMD,EAAOC,IAAM,GAAKhK,CACnC,CACF,CACA,IAAIrH,EAAQ,EACZ,IAAK,IAAIqR,EAAI,EAAGA,EAAID,EAAOhN,OAAQiN,IACjCrR,EAAQuC,KAAKC,IAAIxC,EAAOoR,EAAOC,IACjC,IAAK,IAAIA,EAAI,EAAGA,EAAID,EAAOhN,OAAQiN,IAGjC,GAFIA,GAAK9E,EAAKnI,QACZmI,EAAKnG,KAAK,KAAU8G,OAClBkE,EAAOC,GAAKrR,EAAO,CACrB,MAAMkN,EAAQpE,EAAe3N,GAAQgM,KAAKyF,gBACpCrB,EAAQ,GACd,IAAK,IAAIpH,EAAIiN,EAAOC,GAAIlN,EAAInE,EAAOmE,IACjCoH,EAAMnF,KAAK8G,GAEbX,EAAK8E,GAAK9E,EAAK8E,GAAGC,OAAO,KAAU3F,KAAKJ,GAC1C,CAEF,MAAO,CAAEtL,OAAQsM,EAAKnI,OAAQpE,QAAOuM,OACvC,CA5BSgF,CAAkBpW,EAAQoR,EACnC,CA4BA,SAAS4E,EAASK,EAAU5U,GAC1B,MAAMxE,EAAOoZ,EAAS5E,gBAEtB,OADW,IAAI,KAAUxU,GAAMrB,QAAQ,EAAGqB,EAAKT,QAAQiU,KAAMhP,GACnDyN,GACZ,CAsFA,SAASoH,EAAkBxE,EAAIhV,EAAKqO,EAAOwB,EAAO9N,EAAM+F,EAAO2E,EAAKyI,GAClE,GAAW,GAAPzI,GAAYA,GAAOzM,EAAIgI,OACzB,OAAO,EACT,IAAIyR,GAAQ,EACZ,IAAK,IAAIxL,EAAMlM,EAAMkM,EAAMnG,EAAOmG,IAAO,CACvC,MAAMC,EAAQzB,EAAMzM,EAAI+H,MAAQkG,EAAKnH,EAAM9G,EAAIA,IAAIkO,GACnD,GAAIlO,EAAIA,IAAIkO,EAAQlO,EAAI+H,QAAUjB,EAAK,CACrC2S,GAAQ,EACR,MAAMvK,EAAOb,EAAMiC,OAAOxJ,IAClB2F,IAAKiN,EAAS3X,KAAM4X,GAAa3Z,EAAIuM,SAASzF,GACtDkO,EAAGsD,cAActD,EAAGjB,QAAQpP,MAAMuQ,GAASlV,IAAI8G,EAAM+I,GAAQ,KAAM,IAC9DX,EAAKhP,MACRiP,QAAS1C,EAAMiN,IAEjB1E,EAAG2D,OACD3D,EAAGjB,QAAQpP,MAAMuQ,GAASlV,IAAIA,EAAIoO,WAAW3B,EAAKkN,EAAUtL,IAC5Da,EAAKjO,KAAK0T,cAAc,IACnBzF,EAAKhP,MACRiP,QAASuK,EAAUxK,EAAKhP,MAAMiP,QAAU1C,KAG5CwB,GAAOiB,EAAKhP,MAAMkP,QAAU,CAC9B,CACF,CACA,OAAOqK,CACT,CACA,SAASG,EAAgB5E,EAAIhV,EAAKqO,EAAOwB,EAAOpD,EAAK5E,EAAQ9F,EAAMmT,GACjE,GAAY,GAARnT,GAAaA,GAAQ/B,EAAI+H,MAC3B,OAAO,EACT,IAAI0R,GAAQ,EACZ,IAAK,IAAIzL,EAAMvB,EAAKuB,EAAMnG,EAAQmG,IAAO,CACvC,MAAME,EAAQF,EAAMhO,EAAI+H,MAAQhG,EAAM+E,EAAM9G,EAAIA,IAAIkO,GACpD,GAAIlO,EAAIA,IAAIkO,EAAQ,IAAMpH,EAAK,CAC7B2S,GAAQ,EACR,MAAMvK,EAAOb,EAAMiC,OAAOxJ,GACpB6S,EAAW3Z,EAAI4M,SAAS9F,GACxB+S,EAAY7E,EAAGjB,QAAQpP,MAAMuQ,GAASlV,IAAI8G,EAAM+I,GACtDmF,EAAGsD,cACDuB,EACA,KACA7G,EACE9D,EAAKhP,MACL6B,EAAO4X,EACPzK,EAAKhP,MAAMkP,SAAWrN,EAAO4X,KAGjC3E,EAAG2D,OACDkB,EAAY3K,EAAKT,SACjBS,EAAKjO,KAAK0T,cACR3B,EAAc9D,EAAKhP,MAAO,EAAG6B,EAAO4X,KAGxC3L,GAAOkB,EAAKhP,MAAMiP,QAAU,CAC9B,CACF,CACA,OAAOsK,CACT,CACA,SAASK,EAAYrU,EAAOK,EAAUgN,EAAYjF,EAAMyF,GACtD,IAAIjF,EAAQyE,EAAarN,EAAM2M,IAAI9B,OAAOwC,EAAa,GAAKrN,EAAM2M,IAClE,IAAK/D,EACH,MAAM,IAAI0L,MAAM,kBAElB,IAAI/Z,EAAMoM,EAASP,IAAIwC,GACvB,MAAM,IAAE5B,EAAG,KAAE1K,GAAS8L,EAChB/F,EAAQ/F,EAAOuR,EAAMvL,MAAOF,EAAS4E,EAAM6G,EAAMtL,OACjDgN,EAAKvP,EAAMuP,GACjB,IAAIE,EAAU,EACd,SAAS8E,IAEP,GADA3L,EAAQyE,EAAakC,EAAG5C,IAAI9B,OAAOwC,EAAa,GAAKkC,EAAG5C,KACnD/D,EACH,MAAM,IAAI0L,MAAM,kBAElB/Z,EAAMoM,EAASP,IAAIwC,GACnB6G,EAAUF,EAAGjB,QAAQkG,KAAK9N,MAC5B,EA7GF,SAAmB6I,EAAIhV,EAAKqO,EAAOwB,EAAO9H,EAAOC,EAAQkN,GACvD,MACM7W,EAAQwS,EADCmE,EAAG5C,IAAInR,KAAKiC,QAE3B,IAAI+R,EACAiF,EACJ,GAAInS,EAAQ/H,EAAI+H,MACd,IAAK,IAAIiG,EAAM,EAAGO,EAAS,EAAGP,EAAMhO,EAAIgI,OAAQgG,IAAO,CACrD,MAAMe,EAAUV,EAAMG,MAAMR,GAC5BO,GAAUQ,EAAQN,SAClB,MAAM6E,EAAQ,GACd,IAAImF,EAEFA,EADuB,MAArB1J,EAAQuD,WAAqBvD,EAAQuD,UAAUrR,MAAQ5C,EAAM6Q,KACzD+F,IAAUA,EAAQ5W,EAAM6Q,KAAKyF,iBAE7BuF,IAAcA,EAAY7b,EAAM8b,YAAYxF,iBACpD,IAAK,IAAIzI,EAAIlM,EAAI+H,MAAOmE,EAAInE,EAAOmE,IACjCoH,EAAMnF,KAAKsK,GACbzD,EAAG2D,OAAO3D,EAAGjB,QAAQpP,MAAMuQ,GAASlV,IAAIuO,EAAS,EAAIsB,GAAQyD,EAC/D,CAEF,GAAItL,EAAShI,EAAIgI,OAAQ,CACvB,MAAMsL,EAAQ,GACd,IAAK,IAAIpH,EAAI,EAAGkO,GAAUpa,EAAIgI,OAAS,GAAKhI,EAAI+H,MAAOmE,EAAI5B,KAAKC,IAAIvK,EAAI+H,MAAOA,GAAQmE,IAAK,CAC1F,MAAMmO,IAASnO,GAAKlM,EAAI+H,QAAgBsG,EAAMiC,OAAOtQ,EAAIA,IAAIoa,EAASlO,IAAIjL,MAAQ5C,EAAM8b,YACxF7G,EAAMnF,KACJkM,EAASH,IAAcA,EAAY7b,EAAM8b,YAAYxF,iBAAmBM,IAAUA,EAAQ5W,EAAM6Q,KAAKyF,iBAEzG,CACA,MAAM2F,EAAWjc,EAAM2P,IAAI9P,OAAO,KAAM,KAAUwV,KAAKJ,IAASgB,EAAO,GACvE,IAAK,IAAIpI,EAAIlM,EAAIgI,OAAQkE,EAAIlE,EAAQkE,IACnCoI,EAAKnG,KAAKmM,GACZtF,EAAG2D,OAAO3D,EAAGjB,QAAQpP,MAAMuQ,GAASlV,IAAI6P,EAAQxB,EAAMI,SAAW,GAAI6F,EACvE,CACA,SAAUW,IAASiF,EACrB,EA4EMK,CAAUvF,EAAIhV,EAAKqO,EAAOyE,EAAYhL,EAAOD,EAAQqN,IACvD8E,IACER,EAAkBxE,EAAIhV,EAAKqO,EAAOyE,EAAY/Q,EAAM+F,EAAO2E,EAAKyI,IAClE8E,IACER,EAAkBxE,EAAIhV,EAAKqO,EAAOyE,EAAY/Q,EAAM+F,EAAOD,EAAQqN,IACrE8E,IACEJ,EAAgB5E,EAAIhV,EAAKqO,EAAOyE,EAAYrG,EAAK5E,EAAQ9F,EAAMmT,IACjE8E,IACEJ,EAAgB5E,EAAIhV,EAAKqO,EAAOyE,EAAYrG,EAAK5E,EAAQC,EAAOoN,IAClE8E,IACF,IAAK,IAAIhM,EAAMvB,EAAKuB,EAAMnG,EAAQmG,IAAO,CACvC,MAAM0F,EAAO1T,EAAIoO,WAAWJ,EAAKjM,EAAMsM,GAAQgH,EAAKrV,EAAIoO,WAAWJ,EAAKlG,EAAOuG,GAC/E2G,EAAGlW,QACDkW,EAAGjB,QAAQpP,MAAMuQ,GAASlV,IAAI0T,EAAOZ,GACrCkC,EAAGjB,QAAQpP,MAAMuQ,GAASlV,IAAIqV,EAAKvC,GACnC,IAAI,KAAOQ,EAAMgB,KAAKtG,EAAMvB,GAAM,EAAG,GAEzC,CACAuN,IACAhF,EAAGM,aACD,IAAIlC,EACF4B,EAAG5C,IAAId,QAAQwB,EAAa9S,EAAIoO,WAAW3B,EAAK1K,EAAMsM,IACtD2G,EAAG5C,IAAId,QAAQwB,EAAa9S,EAAIoO,WAAWvG,EAAS,EAAGC,EAAQ,EAAGuG,MAGtEvI,EAASkP,EACX,CAGA,IAAIwF,GAAgB,OAAe,CACjCC,UAAWC,EAAM,SAAU,GAC3BC,WAAYD,EAAM,QAAS,GAC3BE,QAASF,EAAM,QAAS,GACxBG,UAAWH,EAAM,OAAQ,GACzB,kBAAmBI,EAAW,SAAU,GACxC,mBAAoBA,EAAW,QAAS,GACxC,gBAAiBA,EAAW,QAAS,GACrC,kBAAmBA,EAAW,OAAQ,GACtCC,UAAWC,EACX,gBAAiBA,EACjBC,OAAQD,EACR,aAAcA,IAEhB,SAASE,EAAkBzV,EAAOK,EAAU4L,GAC1C,OAAIA,EAAU0E,GAAG3Q,EAAMiM,aAEnB5L,GACFA,EAASL,EAAMuP,GAAGM,aAAa5D,GAAW1M,mBACrC,EACT,CACA,SAAS0V,EAAM5N,EAAMC,GACnB,MAAO,CAACtH,EAAOK,EAAUe,KACvB,IAAKA,EACH,OAAO,EACT,MAAM+K,EAAMnM,EAAMiM,UAClB,GAAIE,aAAewB,EACjB,OAAO8H,EACLzV,EACAK,EACA,KAAWoR,KAAKtF,EAAIE,UAAW/E,IAGnC,GAAY,SAARD,IAAoB8E,EAAIqD,MAC1B,OAAO,EACT,MAAMpC,EAAMsI,EAAYtU,EAAMiG,EAAMC,GACpC,GAAW,MAAP8F,EACF,OAAO,EACT,GAAY,SAAR/F,EACF,OAAOoO,EACLzV,EACAK,EACA,KAAWoR,KAAKzR,EAAM2M,IAAId,QAAQM,EAAIY,KAAOzF,GAAMA,IAEhD,CACL,MAAMiF,EAAQvM,EAAM2M,IAAId,QAAQuB,GAC1BuI,EAAQvO,EAASmF,EAAOlF,EAAMC,GACpC,IAAIsO,EAOJ,OALEA,EADED,EACO,KAAWlE,KAAKkE,EAAO,GACzBrO,EAAM,EACJ,KAAWmK,KAAKzR,EAAM2M,IAAId,QAAQU,EAAMT,QAAQ,KAAM,GAEtD,KAAW2F,KAAKzR,EAAM2M,IAAId,QAAQU,EAAMC,OAAO,IAAK,GACxDiJ,EAAkBzV,EAAOK,EAAUuV,EAC5C,EAEJ,CACA,SAASP,EAAWhO,EAAMC,GACxB,MAAO,CAACtH,EAAOK,EAAUe,KACvB,IAAKA,EACH,OAAO,EACT,MAAM+K,EAAMnM,EAAMiM,UAClB,IAAI4J,EACJ,GAAI1J,aAAewB,EACjBkI,EAAU1J,MACL,CACL,MAAMiB,EAAMsI,EAAYtU,EAAMiG,EAAMC,GACpC,GAAW,MAAP8F,EACF,OAAO,EACTyI,EAAU,IAAIlI,EAAc3N,EAAM2M,IAAId,QAAQuB,GAChD,CACA,MAAMpB,EAAQ5E,EAASyO,EAAQxJ,UAAWhF,EAAMC,GAChD,QAAK0E,GAEEyJ,EACLzV,EACAK,EACA,IAAIsN,EAAckI,EAAQzJ,YAAaJ,GACxC,CAEL,CACA,SAASuJ,EAAoBvV,EAAOK,GAClC,MAAM8L,EAAMnM,EAAMiM,UAClB,KAAME,aAAewB,GACnB,OAAO,EACT,GAAItN,EAAU,CACZ,MAAMkP,EAAKvP,EAAMuP,GACXuG,EAAc1K,EAAepL,EAAMvC,QAAQgM,KAAKyF,gBAAgBjV,QACtEkS,EAAI4D,aAAY,CAACtG,EAAMpI,KAChBoI,EAAKxP,QAAQ0W,GAAGmF,IACnBvG,EAAGlW,QACDkW,EAAGjB,QAAQ/T,IAAI8G,EAAM,GACrBkO,EAAGjB,QAAQ/T,IAAI8G,EAAMoI,EAAKT,SAAW,GACrC,IAAI,KAAO8M,EAAa,EAAG,GAC5B,IAEDvG,EAAGwG,YACL1V,EAASkP,EACb,CACA,OAAO,CACT,CACA,SAASyG,EAAkB5U,EAAMC,GAC/B,MAA4BkL,EAAQd,EAAxBrK,EAAKpB,MAAM2M,IAA4Bd,QAAQxK,IAC3D,QAAKkL,IAELnL,EAAKf,SAASe,EAAKpB,MAAMuP,GAAGM,aAAa,IAAIlC,EAAcpB,MACpD,EACT,CACA,SAAS0J,EAAY7U,EAAM8U,EAAGhX,GAC5B,IAAK6M,EAAU3K,EAAKpB,OAClB,OAAO,EACT,IAAI6N,EAAQyF,EAAYpU,GACxB,MAAMiN,EAAM/K,EAAKpB,MAAMiM,UACvB,GAAIE,aAAewB,EAAe,CAC3BE,IACHA,EAAQ,CACNvL,MAAO,EACPC,OAAQ,EACRsM,KAAM,CACJ,KAAUZ,KACRwF,EAASrI,EAAehK,EAAKpB,MAAMvC,QAAQgM,KAAMvK,OAIzD,MAAM0J,EAAQuD,EAAIC,YAAY1R,MAAM,GAC9B0P,EAAQ+B,EAAIC,YAAYhC,OAAO,GAC/BhC,EAAOzB,EAASP,IAAIwC,GAAOrB,YAC/B4E,EAAIC,YAAY/K,IAAM+I,EACtB+B,EAAIE,UAAUhL,IAAM+I,GAItB,OAFAyD,EAhUJ,UAAmB,MAAEvL,EAAK,OAAEC,EAAM,KAAEsM,GAAQsH,EAAUC,GACpD,GAAI9T,GAAS6T,EAAU,CACrB,MAAME,EAAQ,GACRC,EAAU,GAChB,IAAK,IAAI/N,EAAM,EAAGA,EAAMsG,EAAKnI,OAAQ6B,IAAO,CAC1C,MAAMgO,EAAO1H,EAAKtG,GAAMsF,EAAQ,GAChC,IAAK,IAAIrF,EAAM6N,EAAM9N,IAAQ,EAAG9B,EAAI,EAAG+B,EAAM2N,EAAU1P,IAAK,CAC1D,IAAIgD,EAAO8M,EAAKxN,MAAMtC,EAAI8P,EAAKlN,YAC3Bb,EAAMiB,EAAKhP,MAAMkP,QAAUwM,IAC7B1M,EAAOA,EAAKjO,KAAKgb,cACfjJ,EACE9D,EAAKhP,MACLgP,EAAKhP,MAAMkP,QACXnB,EAAMiB,EAAKhP,MAAMkP,QAAUwM,GAE7B1M,EAAKxP,UAET4T,EAAMnF,KAAKe,GACXjB,GAAOiB,EAAKhP,MAAMkP,QAClB,IAAK,IAAI1C,EAAI,EAAGA,EAAIwC,EAAKhP,MAAMiP,QAASzC,IACtCoP,EAAM9N,EAAMtB,IAAMoP,EAAM9N,EAAMtB,IAAM,GAAKwC,EAAKhP,MAAMkP,OACxD,CACA2M,EAAQ5N,KAAK,KAAUuF,KAAKJ,GAC9B,CACAgB,EAAOyH,EACPhU,EAAQ6T,CACV,CACA,GAAI5T,GAAU6T,EAAW,CACvB,MAAME,EAAU,GAChB,IAAK,IAAI/N,EAAM,EAAG9B,EAAI,EAAG8B,EAAM6N,EAAW7N,IAAO9B,IAAK,CACpD,MAAMoH,EAAQ,GAAI4I,EAAS5H,EAAKpI,EAAIlE,GACpC,IAAK,IAAI0E,EAAI,EAAGA,EAAIwP,EAAOpN,WAAYpC,IAAK,CAC1C,IAAIwC,EAAOgN,EAAO1N,MAAM9B,GACpBsB,EAAMkB,EAAKhP,MAAMiP,QAAU0M,IAC7B3M,EAAOA,EAAKjO,KAAK/C,OACf,IACKgR,EAAKhP,MACRiP,QAAS7E,KAAKC,IAAI,EAAGsR,EAAY3M,EAAKhP,MAAMiP,UAE9CD,EAAKxP,UAET4T,EAAMnF,KAAKe,EACb,CACA6M,EAAQ5N,KAAK,KAAUuF,KAAKJ,GAC9B,CACAgB,EAAOyH,EACP/T,EAAS6T,CACX,CACA,MAAO,CAAE9T,QAAOC,SAAQsM,OAC1B,CA+QY6H,CAAU7I,EAAOzF,EAAK/F,MAAQ+F,EAAK9L,KAAM8L,EAAKhG,OAASgG,EAAKpB,KACpEqN,EAAYjT,EAAKpB,MAAOoB,EAAKf,SAAU+J,EAAOhC,EAAMyF,IAC7C,CACT,CAAO,GAAIA,EAAO,CAChB,MAAMtB,EAAQL,EAAc9K,EAAKpB,OAC3BoK,EAAQmC,EAAMnC,OAAO,GAQ3B,OAPAiK,EACEjT,EAAKpB,MACLoB,EAAKf,SACL+J,EACAzD,EAASP,IAAImG,EAAM7R,MAAM,IAAIoM,SAASyF,EAAMlL,IAAM+I,GAClDyD,IAEK,CACT,CACE,OAAO,CAEX,CACA,SAASxK,EAAgBjC,EAAMuV,GAC7B,IAAIrY,EACJ,GAAIqY,EAAWC,SAAWD,EAAWE,QACnC,OACF,MAAMC,EAAeC,EAAU3V,EAAMuV,EAAWpV,QAChD,IAAI+K,EACJ,GAAIqK,EAAWK,UAAY5V,EAAKpB,MAAMiM,qBAAqB0B,EACzDsJ,EAAiB7V,EAAKpB,MAAMiM,UAAUG,YAAauK,GACnDA,EAAWO,sBACN,GAAIP,EAAWK,UAAYF,GAAwE,OAAvDxK,EAAUb,EAAWrK,EAAKpB,MAAMiM,UAAUK,YAAiE,OAA1ChO,EAAK6Y,EAAe/V,EAAMuV,SAAuB,EAASrY,EAAG+C,MAAQiL,EAAQjL,IAC/L4V,EAAiB3K,EAASqK,GAC1BA,EAAWO,sBACN,IAAKJ,EACV,OAEF,SAASG,EAAiBG,EAAU9V,GAClC,IAAI0K,EAAQmL,EAAe/V,EAAME,GACjC,MAAM+V,EAAmD,MAAxC7L,EAAgB8L,SAASlW,EAAKpB,OAC/C,IAAKgM,IAAUiB,EAAYmK,EAAUpL,GAAQ,CAC3C,IAAIqL,EAGF,OAFArL,EAAQoL,CAGZ,CACA,MAAMnL,EAAY,IAAI0B,EAAcyJ,EAAUpL,GAC9C,GAAIqL,IAAajW,EAAKpB,MAAMiM,UAAU0E,GAAG1E,GAAY,CACnD,MAAMsD,EAAKnO,EAAKpB,MAAMuP,GAAGM,aAAa5D,GAClCoL,GACF9H,EAAG4D,QAAQ3H,EAAiB4L,EAAS/V,KACvCD,EAAKf,SAASkP,EAChB,CACF,CACA,SAASgI,IACPnW,EAAKpF,KAAKmH,oBAAoB,UAAWoU,GACzCnW,EAAKpF,KAAKmH,oBAAoB,YAAaoU,GAC3CnW,EAAKpF,KAAKmH,oBAAoB,YAAaqU,GACC,MAAxChM,EAAgB8L,SAASlW,EAAKpB,QAChCoB,EAAKf,SAASe,EAAKpB,MAAMuP,GAAG4D,QAAQ3H,GAAkB,GAC1D,CACA,SAASgM,EAAKjU,GACZ,MAAMjC,EAAQiC,EACRuN,EAAStF,EAAgB8L,SAASlW,EAAKpB,OAC7C,IAAIoX,EACJ,GAAc,MAAVtG,EACFsG,EAAWhW,EAAKpB,MAAM2M,IAAId,QAAQiF,QAC7B,GAAIiG,EAAU3V,EAAME,EAAMC,SAAWuV,IAC1CM,EAAWD,EAAe/V,EAAMuV,IAC3BS,GACH,OAAOG,IAEPH,GACFH,EAAiBG,EAAU9V,EAC/B,CACAF,EAAKpF,KAAKkH,iBAAiB,UAAWqU,GACtCnW,EAAKpF,KAAKkH,iBAAiB,YAAaqU,GACxCnW,EAAKpF,KAAKkH,iBAAiB,YAAasU,EAC1C,CACA,SAAS9B,EAAYtU,EAAMiG,EAAMC,GAC/B,KAAMlG,EAAKpB,MAAMiM,qBAAqB,MACpC,OAAO,KACT,MAAM,MAAED,GAAU5K,EAAKpB,MAAMiM,UAC7B,IAAK,IAAIN,EAAIK,EAAMJ,MAAQ,EAAGD,GAAK,EAAGA,IAAK,CACzC,MAAMpN,EAASyN,EAAMtR,KAAKiR,GAC1B,IADsCrE,EAAM,EAAI0E,EAAMvD,MAAMkD,GAAKK,EAAMyL,WAAW9L,MACpErE,EAAM,EAAI,EAAI/I,EAAO8K,YACjC,OAAO,KACT,GAAkC,QAA9B9K,EAAO/C,KAAK0N,KAAKC,WAAqD,eAA9B5K,EAAO/C,KAAK0N,KAAKC,UAA4B,CACvF,MAAMuO,EAAU1L,EAAMF,OAAOH,GACvBgM,EAAiB,QAARtQ,EAAiBC,EAAM,EAAI,OAAS,KAAOA,EAAM,EAAI,QAAU,OAC9E,OAAOlG,EAAKwW,eAAeD,GAAUD,EAAU,IACjD,CACF,CACA,OAAO,IACT,CACA,SAASX,EAAU3V,EAAMyW,GACvB,KAAOA,GAAOA,GAAOzW,EAAKyW,IAAKA,EAAMA,EAAIC,WACvC,GAAoB,MAAhBD,EAAIE,UAAoC,MAAhBF,EAAIE,SAC9B,OAAOF,EAGX,OAAO,IACT,CACA,SAASV,EAAe/V,EAAME,GAC5B,MAAM0W,EAAW5W,EAAK6W,YAAY,CAChC3b,KAAMgF,EAAMiD,QACZyC,IAAK1F,EAAMoD,UAEb,OAAKsT,GAEEA,EAAWvM,EAAWrK,EAAKpB,MAAM2M,IAAId,QAAQmM,EAAS3W,MADpD,IAEX,CAUA,IAAI6W,EAAY,MACd,WAAAtR,CAAYlM,EAAMyd,GAChBrf,KAAK4B,KAAOA,EACZ5B,KAAKqf,aAAeA,EACpBrf,KAAK+e,IAAMzY,SAASgZ,cAAc,OAClCtf,KAAK+e,IAAI9Z,UAAY,eACrBjF,KAAK8P,MAAQ9P,KAAK+e,IAAIQ,YAAYjZ,SAASgZ,cAAc,UACzDtf,KAAKwf,SAAWxf,KAAK8P,MAAMyP,YAAYjZ,SAASgZ,cAAc,aAC9DG,EAAsB7d,EAAM5B,KAAKwf,SAAUxf,KAAK8P,MAAOuP,GACvDrf,KAAK0f,WAAa1f,KAAK8P,MAAMyP,YAAYjZ,SAASgZ,cAAc,SAClE,CACA,MAAAK,CAAO/d,GACL,OAAIA,EAAKc,MAAQ1C,KAAK4B,KAAKc,OAE3B1C,KAAK4B,KAAOA,EACZ6d,EAAsB7d,EAAM5B,KAAKwf,SAAUxf,KAAK8P,MAAO9P,KAAKqf,eACrD,EACT,CACA,cAAAO,CAAeC,GACb,MAAsB,cAAfA,EAAOnd,OAAyBmd,EAAOpX,QAAUzI,KAAK8P,OAAS9P,KAAKwf,SAAShZ,SAASqZ,EAAOpX,QACtG,GAEF,SAASgX,EAAsB7d,EAAM4d,EAAU1P,EAAOuP,EAAcS,EAAaC,GAC/E,IAAIva,EACJ,IAAIwa,EAAa,EACbC,GAAa,EACbC,EAAUV,EAAS5L,WACvB,MAAMnE,EAAM7N,EAAKgS,WACjB,GAAKnE,EAAL,CAEA,IAAK,IAAI9B,EAAI,EAAG+B,EAAM,EAAG/B,EAAI8B,EAAIc,WAAY5C,IAAK,CAChD,MAAM,QAAEkD,EAAO,SAAEM,GAAa1B,EAAIQ,MAAMtC,GAAGhM,MAC3C,IAAK,IAAIwM,EAAI,EAAGA,EAAI0C,EAAS1C,IAAKuB,IAAO,CACvC,MAAMyQ,EAAWL,GAAepQ,EAAMqQ,EAAgB5O,GAAYA,EAAShD,GACrEiS,EAAWD,EAAWA,EAAW,KAAO,GAC9CH,GAAcG,GAAYd,EACrBc,IACHF,GAAa,GACVC,GAGCA,EAAQ5f,MAAMkJ,OAAS4W,IACzBF,EAAQ5f,MAAMkJ,MAAQ4W,GACxBF,EAAUA,EAAQG,aAJlBb,EAASD,YAAYjZ,SAASgZ,cAAc,QAAQhf,MAAMkJ,MAAQ4W,CAMtE,CACF,CACA,KAAOF,GAAS,CACd,MAAMxM,EAAQwM,EAAQG,YACO,OAA5B7a,EAAK0a,EAAQlB,aAA+BxZ,EAAG8a,YAAYJ,GAC5DA,EAAUxM,CACZ,CACIuM,GACFnQ,EAAMxP,MAAMkJ,MAAQwW,EAAa,KACjClQ,EAAMxP,MAAMigB,SAAW,KAEvBzQ,EAAMxP,MAAMkJ,MAAQ,GACpBsG,EAAMxP,MAAMigB,SAAWP,EAAa,KA5B9B,CA8BV,CAGA,IAAIQ,EAA0B,IAAI,KAChC,uBAEF,SAASC,GAAe,YACtBC,EAAc,EAAC,aACfrB,EAAe,GAAE,KACjBsB,EAAOvB,EAAS,oBAChBwB,GAAsB,GACpB,CAAC,GACH,MAAMC,EAAS,IAAI,KAAO,CACxB1Y,IAAKqY,EACLtZ,MAAO,CACL,IAAA4Z,CAAK1D,EAAGlW,GACN,IAAI1B,EAAIub,EACR,MAAMC,EAAqE,OAAxDD,EAA2B,OAArBvb,EAAKqb,EAAOzQ,WAAgB,EAAS5K,EAAG4C,YAAiB,EAAS2Y,EAAGC,UACxFC,EAAY3O,EAAepL,EAAMvC,QAAQmL,MAAMlQ,KAMrD,OALI+gB,GAAQK,IACVA,EAAUC,GAAa,CAACrf,EAAM0G,IACrB,IAAIqY,EAAK/e,EAAMyd,EAAc/W,IAGjC,IAAI4Y,GAAa,GAAG,EAC7B,EACA,KAAAC,CAAM1K,EAAI/E,GACR,OAAOA,EAAKyP,MAAM1K,EACpB,GAEFrO,MAAO,CACLnI,WAAaiH,IACX,MAAMka,EAAcZ,EAAwBhC,SAAStX,GACrD,OAAOka,GAAeA,EAAYC,cAAgB,EAAI,CAAExI,MAAO,iBAAoB,CAAC,CAAC,EAEvFyI,gBAAiB,CACfC,UAAW,CAACjZ,EAAME,MAiD1B,SAAyBF,EAAME,EAAOkY,EAAarB,EAAcuB,GAC/D,MAAMQ,EAAcZ,EAAwBhC,SAASlW,EAAKpB,OAC1D,IAAKka,EACH,OACF,IAAKA,EAAYI,SAAU,CACzB,MAAM/Y,EAyFV,SAAuBA,GACrB,KAAOA,GAA6B,MAAnBA,EAAOwW,UAAuC,MAAnBxW,EAAOwW,UACjDxW,EAASA,EAAOgZ,WAAahZ,EAAOgZ,UAAUjb,SAAS,eAAiB,KAAOiC,EAAOuW,WACxF,OAAOvW,CACT,CA7FmBiZ,CAAclZ,EAAMC,QACnC,IAAIkI,GAAQ,EACZ,GAAIlI,EAAQ,CACV,MAAM,KAAEjF,EAAI,MAAE+F,GAAUd,EAAO8C,wBAC3B/C,EAAMiD,QAAUjI,GAAQkd,EAC1B/P,EAAOgR,EAASrZ,EAAME,EAAO,OAAQkY,GAC9BnX,EAAQf,EAAMiD,SAAWiV,IAChC/P,EAAOgR,EAASrZ,EAAME,EAAO,QAASkY,GAC1C,CACA,GAAI/P,GAAQyQ,EAAYC,aAAc,CACpC,IAAKT,IAAiC,IAAVjQ,EAAa,CACvC,MAAM8C,EAAQnL,EAAKpB,MAAM2M,IAAId,QAAQpC,GAC/Bb,EAAQ2D,EAAM7R,MAAM,GACpBH,EAAMoM,EAASP,IAAIwC,GACnByE,EAAad,EAAMnC,OAAO,GAEhC,GADY7P,EAAI4M,SAASoF,EAAMlL,IAAMgM,GAAcd,EAAME,UAAUhS,MAAMkP,QAAU,GACxEpP,EAAI+H,MAAQ,EACrB,MAEJ,CACAoY,EAAatZ,EAAMqI,EACrB,CACF,CACF,CA5EUxG,CACE7B,EACAE,EACAkY,EACArB,EACAuB,EACD,EAEHiB,WAAavZ,KAqErB,SAA0BA,GACxB,MAAM8Y,EAAcZ,EAAwBhC,SAASlW,EAAKpB,OACtDka,GAAeA,EAAYC,cAAgB,IAAMD,EAAYI,UAC/DI,EAAatZ,GAAO,EACxB,CAxEUwZ,CAAiBxZ,EAAK,EAExByZ,UAAW,CAACzZ,EAAME,MAuE1B,SAA0BF,EAAME,EAAO6W,GACrC,IAAI7Z,EACJ,MAAMwc,EAAmD,OAA5Cxc,EAAK8C,EAAKyW,IAAIkD,cAAcC,aAAuB1c,EAAKS,OAC/Dmb,EAAcZ,EAAwBhC,SAASlW,EAAKpB,OAC1D,IAAKka,IAA4C,GAA7BA,EAAYC,cAAsBD,EAAYI,SAChE,OAAO,EACT,MAAM7Q,EAAOrI,EAAKpB,MAAM2M,IAAI9B,OAAOqP,EAAYC,cACzC7X,EAqCR,SAAyBlB,EAAMsW,GAAS,QAAE/N,EAAO,SAAEM,IACjD,MAAM3H,EAAQ2H,GAAYA,EAASA,EAASvD,OAAS,GACrD,GAAIpE,EACF,OAAOA,EACT,MAAMuV,EAAMzW,EAAK6Z,SAASvD,GAE1B,IAAIwD,EADSrD,EAAInd,KAAKygB,WAAWtD,EAAI7F,QACjBoJ,YAAaC,EAAQ1R,EACzC,GAAIM,EACF,IAAK,IAAIxD,EAAI,EAAGA,EAAIkD,EAASlD,IACvBwD,EAASxD,KACXyU,GAAYjR,EAASxD,GACrB4U,KAGN,OAAOH,EAAWG,CACpB,CApDgBC,CAAgBla,EAAM8Y,EAAYC,aAAc1Q,EAAKhP,OAMnE,SAAS8gB,EAAOC,GACdV,EAAI3X,oBAAoB,UAAWoY,GACnCT,EAAI3X,oBAAoB,YAAaqU,GACrC,MAAMiE,EAAenC,EAAwBhC,SAASlW,EAAKpB,QACvC,MAAhByb,OAAuB,EAASA,EAAanB,aA2ErD,SAA2BlZ,EAAMqI,EAAMnH,GACrC,MAAMiK,EAAQnL,EAAKpB,MAAM2M,IAAId,QAAQpC,GAC/Bb,EAAQ2D,EAAM7R,MAAM,GAAIH,EAAMoM,EAASP,IAAIwC,GAAQwB,EAAQmC,EAAMnC,OAAO,GACxE5B,EAAMjO,EAAI4M,SAASoF,EAAMlL,IAAM+I,GAASmC,EAAME,UAAUhS,MAAMkP,QAAU,EACxE4F,EAAKnO,EAAKpB,MAAMuP,GACtB,IAAK,IAAIhH,EAAM,EAAGA,EAAMhO,EAAIgI,OAAQgG,IAAO,CACzC,MAAMmT,EAAWnT,EAAMhO,EAAI+H,MAAQkG,EACnC,GAAID,GAAOhO,EAAIA,IAAImhB,IAAanhB,EAAIA,IAAImhB,EAAWnhB,EAAI+H,OACrD,SACF,MAAMjB,EAAM9G,EAAIA,IAAImhB,GACdjhB,EAAQmO,EAAMiC,OAAOxJ,GAAK5G,MAC1BgO,EAAyB,GAAjBhO,EAAMkP,QAAe,EAAInB,EAAMjO,EAAI4M,SAAS9F,GAC1D,GAAI5G,EAAMwP,UAAYxP,EAAMwP,SAASxB,IAAUnG,EAC7C,SACF,MAAM2H,EAAWxP,EAAMwP,SAAWxP,EAAMwP,SAAS/K,QAAUyc,EAAOlhB,EAAMkP,SACxEM,EAASxB,GAASnG,EAClBiN,EAAGsD,cAAczI,EAAQ/I,EAAK,KAAM,IAAK5G,EAAOwP,YAClD,CACIsF,EAAGwG,YACL3U,EAAKf,SAASkP,EAClB,CA9FMqM,CACExa,EACAqa,EAAatB,aACb0B,EAAaJ,EAAanB,SAAUkB,EAAQrD,IAE9C/W,EAAKf,SACHe,EAAKpB,MAAMuP,GAAG4D,QAAQmG,EAAyB,CAAEwC,YAAa,QAGpE,CACA,SAAStE,EAAKgE,GACZ,IAAKA,EAAOO,MACV,OAAOR,EAAOC,GAChB,MAAMC,EAAenC,EAAwBhC,SAASlW,EAAKpB,OAC3D,GAAKyb,GAEDA,EAAanB,SAAU,CACzB,MAAM0B,EAAUH,EAAaJ,EAAanB,SAAUkB,EAAQrD,IA8ElE,SAA4B/W,EAAMqI,EAAMnH,EAAO6V,GAC7C,MAAM5L,EAAQnL,EAAKpB,MAAM2M,IAAId,QAAQpC,GAC/Bb,EAAQ2D,EAAM7R,MAAM,GAAI0P,EAAQmC,EAAMnC,OAAO,GAC7C5B,EAAM7B,EAASP,IAAIwC,GAAOzB,SAASoF,EAAMlL,IAAM+I,GAASmC,EAAME,UAAUhS,MAAMkP,QAAU,EAC9F,IAAIkO,EAAMzW,EAAK6Z,SAAS1O,EAAMnC,OAAO,IAAI1P,KACzC,KAAOmd,GAAuB,SAAhBA,EAAIE,UAChBF,EAAMA,EAAIC,WAEZ,IAAKD,EACH,OACFU,EACE3P,EACAiP,EAAInL,WACJmL,EACAM,EACA3P,EACAlG,EAEJ,CA/FM2Z,CAAmB7a,EAAMqa,EAAatB,aAAc6B,EAAS7D,EAC/D,CACF,CA9BA/W,EAAKf,SACHe,EAAKpB,MAAMuP,GAAG4D,QAAQmG,EAAyB,CAC7CwC,YAAa,CAAEI,OAAQ5a,EAAMiD,QAAS4X,WAAY7Z,MA6BtDwY,EAAI5X,iBAAiB,UAAWqY,GAChCT,EAAI5X,iBAAiB,YAAasU,GAClClW,EAAM4V,gBAER,CAjHUkF,CAAiBhb,EAAME,EAAO6W,EAAa,GAG/CkE,YAAcrc,IACZ,MAAMka,EAAcZ,EAAwBhC,SAAStX,GACrD,GAAIka,GAAeA,EAAYC,cAAgB,EAC7C,OAuMV,SAA2Bna,EAAOyJ,GAChC,MAAM4S,EAAc,GACd9P,EAAQvM,EAAM2M,IAAId,QAAQpC,GAC1Bb,EAAQ2D,EAAM7R,MAAM,GAC1B,IAAKkO,EACH,OAAO,KAAe4G,MAExB,MAAMjV,EAAMoM,EAASP,IAAIwC,GACnBwB,EAAQmC,EAAMnC,OAAO,GACrB5B,EAAMjO,EAAI4M,SAASoF,EAAMlL,IAAM+I,GAASmC,EAAME,UAAUhS,MAAMkP,QAAU,EAC9E,IAAK,IAAIpB,EAAM,EAAGA,EAAMhO,EAAIgI,OAAQgG,IAAO,CACzC,MAAME,EAAQD,EAAMD,EAAMhO,EAAI+H,MAC9B,IAAKkG,GAAOjO,EAAI+H,MAAQ,GAAK/H,EAAIA,IAAIkO,IAAUlO,EAAIA,IAAIkO,EAAQ,MAAe,GAAPF,GAAYhO,EAAIA,IAAIkO,IAAUlO,EAAIA,IAAIkO,EAAQlO,EAAI+H,QAAS,CAChI,MAAMoV,EAAUnd,EAAIA,IAAIkO,GAClBpH,EAAM+I,EAAQsN,EAAU9O,EAAMiC,OAAO6M,GAAS1O,SAAW,EACzD6O,EAAMzY,SAASgZ,cAAc,OACnCP,EAAI9Z,UAAY,uBAChBse,EAAY3T,KAAK,KAAY4T,OAAOjb,EAAKwW,GAC3C,CACF,CACA,OAAO,KAAepf,OAAOuH,EAAM2M,IAAK0P,EAC1C,CA5NiBE,CAAkBvc,EAAOka,EAAYC,aAC9C,EAEFL,UAAW,CAAC,KAGhB,OAAOH,CACT,CACA,IAAIK,EAAc,MAAMwC,EACtB,WAAA5V,CAAYuT,EAAcG,GACxBxhB,KAAKqhB,aAAeA,EACpBrhB,KAAKwhB,SAAWA,CAClB,CACA,KAAAL,CAAM1K,GACJ,MAAMvP,EAAQlH,KACR2jB,EAASlN,EAAGmN,QAAQpD,GAC1B,GAAImD,GAA8B,MAApBA,EAAOE,UACnB,OAAO,IAAIH,EAAaC,EAAOE,WAAW,GAC5C,GAAIF,QAAiC,IAAvBA,EAAOX,YACnB,OAAO,IAAIU,EAAaxc,EAAMma,aAAcsC,EAAOX,aACrD,GAAI9b,EAAMma,cAAgB,GAAK5K,EAAGwG,WAAY,CAC5C,IAAI6G,EAASrN,EAAGjB,QAAQ/T,IAAIyF,EAAMma,cAAe,GAIjD,OAHKnN,EAAauC,EAAG5C,IAAId,QAAQ+Q,MAC/BA,GAAU,GAEL,IAAIJ,EAAaI,EAAQ5c,EAAMsa,SACxC,CACA,OAAOta,CACT,GAqGF,SAASya,EAASrZ,EAAME,EAAO2R,EAAMuG,GACnC,MAAMxH,EAAiB,SAARiB,GAAmBuG,EAAcA,EAC1CxF,EAAQ5S,EAAK6W,YAAY,CAC7B3b,KAAMgF,EAAMiD,QAAUyN,EACtBhL,IAAK1F,EAAMoD,UAEb,IAAKsP,EACH,OAAQ,EACV,MAAM,IAAE3S,GAAQ2S,EACVzH,EAAQd,EAAWrK,EAAKpB,MAAM2M,IAAId,QAAQxK,IAChD,IAAKkL,EACH,OAAQ,EACV,GAAY,SAAR0G,EACF,OAAO1G,EAAMlL,IACf,MAAM9G,EAAMoM,EAASP,IAAImG,EAAM7R,MAAM,IAAK0P,EAAQmC,EAAMnC,OAAO,GACzD3B,EAAQlO,EAAIA,IAAIsiB,QAAQtQ,EAAMlL,IAAM+I,GAC1C,OAAO3B,EAAQlO,EAAI+H,OAAS,GAAK,EAAI8H,EAAQ7P,EAAIA,IAAIkO,EAAQ,EAC/D,CACA,SAASoT,EAAavB,EAAUhZ,EAAO6W,GACrC,MAAMnG,EAAS1Q,EAAMiD,QAAU+V,EAAS4B,OACxC,OAAOrX,KAAKC,IAAIqT,EAAcmC,EAAS6B,WAAanK,EACtD,CACA,SAAS0I,EAAatZ,EAAMiF,GAC1BjF,EAAKf,SACHe,EAAKpB,MAAMuP,GAAG4D,QAAQmG,EAAyB,CAAEqD,UAAWtW,IAEhE,CAyCA,SAASsV,EAAOxR,GACd,OAAO2S,MAAM3S,GAAG4S,KAAK,EACvB,CA6BA,SAASC,GAAahd,GACpB,MAAMmM,EAAMnM,EAAMiM,UACZP,EAAOQ,EAAclM,GACrB4I,EAAQ8C,EAAKhR,MAAM,GACnB2S,EAAa3B,EAAKtB,OAAO,GACzB7P,EAAMoM,EAASP,IAAIwC,GAKzB,MAAO,IAJMuD,aAAewB,EAAgBpT,EAAIgN,YAC9C4E,EAAIC,YAAY/K,IAAMgM,EACtBlB,EAAIE,UAAUhL,IAAMgM,GAClB9S,EAAIuM,SAAS4E,EAAKrK,IAAMgM,GACVA,aAAY9S,MAAKqO,QACrC,CACA,SAASqU,GAAU1N,GAAI,IAAEhV,EAAG,WAAE8S,EAAU,MAAEzE,GAASJ,GACjD,IAAI0U,EAAY1U,EAAM,GAAK,EAAI,GAzyCjC,SAAwBjO,EAAKqO,EAAOJ,GAClC,MAAM2U,EAAa/R,EAAexC,EAAMpN,KAAKiC,QAAQiX,YACrD,IAAK,IAAInM,EAAM,EAAGA,EAAMhO,EAAIgI,OAAQgG,IAClC,GAAIK,EAAMiC,OAAOtQ,EAAIA,IAAIiO,EAAMD,EAAMhO,EAAI+H,QAAQ9G,MAAQ2hB,EACvD,OAAO,EACX,OAAO,CACT,EAoyCMC,CAAe7iB,EAAKqO,EAAOJ,EAAM0U,KACnCA,EAAmB,GAAP1U,GAAYA,GAAOjO,EAAI+H,MAAQ,KAAO,GAEpD,IAAK,IAAIiG,EAAM,EAAGA,EAAMhO,EAAIgI,OAAQgG,IAAO,CACzC,MAAME,EAAQF,EAAMhO,EAAI+H,MAAQkG,EAChC,GAAIA,EAAM,GAAKA,EAAMjO,EAAI+H,OAAS/H,EAAIA,IAAIkO,EAAQ,IAAMlO,EAAIA,IAAIkO,GAAQ,CACtE,MAAMpH,EAAM9G,EAAIA,IAAIkO,GACdgB,EAAOb,EAAMiC,OAAOxJ,GAC1BkO,EAAGsD,cACDtD,EAAGjB,QAAQ/T,IAAI8S,EAAahM,GAC5B,KACAqM,EAAWjE,EAAKhP,MAAO+N,EAAMjO,EAAI4M,SAAS9F,KAE5CkH,GAAOkB,EAAKhP,MAAMiP,QAAU,CAC9B,KAAO,CACL,MAAMlO,EAAoB,MAAb0hB,EAAoB9R,EAAexC,EAAMpN,KAAKiC,QAAQgM,KAAOb,EAAMiC,OAAOtQ,EAAIA,IAAIkO,EAAQyU,IAAY1hB,KAC7G6F,EAAM9G,EAAIoO,WAAWJ,EAAKC,EAAKI,GACrC2G,EAAG2D,OAAO3D,EAAGjB,QAAQ/T,IAAI8S,EAAahM,GAAM7F,EAAK0T,gBACnD,CACF,CACA,OAAOK,CACT,CAmBA,SAAS8N,GAAa9N,GAAI,IAAEhV,EAAG,MAAEqO,EAAK,WAAEyE,GAAc7E,GACpD,MAAM8U,EAAW/N,EAAGjB,QAAQkG,KAAK9N,OACjC,IAAK,IAAI6B,EAAM,EAAGA,EAAMhO,EAAIgI,QAAU,CACpC,MAAMkG,EAAQF,EAAMhO,EAAI+H,MAAQkG,EAC1BnH,EAAM9G,EAAIA,IAAIkO,GACdgB,EAAOb,EAAMiC,OAAOxJ,GACpB5G,EAAQgP,EAAKhP,MACnB,GAAI+N,EAAM,GAAKjO,EAAIA,IAAIkO,EAAQ,IAAMpH,GAAOmH,EAAMjO,EAAI+H,MAAQ,GAAK/H,EAAIA,IAAIkO,EAAQ,IAAMpH,EACvFkO,EAAGsD,cACDtD,EAAGjB,QAAQpP,MAAMoe,GAAU/iB,IAAI8S,EAAahM,GAC5C,KACAkM,EAAc9S,EAAO+N,EAAMjO,EAAI4M,SAAS9F,SAErC,CACL,MAAM+I,EAAQmF,EAAGjB,QAAQpP,MAAMoe,GAAU/iB,IAAI8S,EAAahM,GAC1DkO,EAAGgO,OAAOnT,EAAOA,EAAQX,EAAKT,SAChC,CACAT,GAAO9N,EAAMiP,OACf,CACF,CAgCA,SAAS8T,GAAOjO,GAAI,IAAEhV,EAAG,WAAE8S,EAAU,MAAEzE,GAASL,GAC9C,IAAIjK,EACJ,IAAImf,EAASpQ,EACb,IAAK,IAAI5G,EAAI,EAAGA,EAAI8B,EAAK9B,IACvBgX,GAAU7U,EAAMG,MAAMtC,GAAGuC,SAC3B,MAAM6E,EAAQ,GACd,IAAI6P,EAASnV,EAAM,GAAK,EAAI,GAd9B,SAAqBhO,EAAKqO,EAAOL,GAC/B,IAAIjK,EACJ,MAAM6e,EAAa/R,EAAexC,EAAMpN,KAAKiC,QAAQiX,YACrD,IAAK,IAAIlM,EAAM,EAAGA,EAAMjO,EAAI+H,MAAOkG,IACjC,IAA4D,OAAtDlK,EAAKsK,EAAMiC,OAAOtQ,EAAIA,IAAIiO,EAAMD,EAAMhO,EAAI+H,cAAmB,EAAShE,EAAG9C,OAAS2hB,EACtF,OAAO,EACX,OAAO,CACT,EAQMQ,CAAYpjB,EAAKqO,EAAOL,EAAMmV,KAChCA,EAAgB,GAAPnV,GAAYA,GAAOhO,EAAIgI,OAAS,KAAO,GAClD,IAAK,IAAIiG,EAAM,EAAGC,EAAQlO,EAAI+H,MAAQiG,EAAKC,EAAMjO,EAAI+H,MAAOkG,IAAOC,IACjE,GAAIF,EAAM,GAAKA,EAAMhO,EAAIgI,QAAUhI,EAAIA,IAAIkO,IAAUlO,EAAIA,IAAIkO,EAAQlO,EAAI+H,OAAQ,CAC/E,MAAMjB,EAAM9G,EAAIA,IAAIkO,GACdhO,EAAQmO,EAAMiC,OAAOxJ,GAAK5G,MAChC8U,EAAGsD,cAAcxF,EAAahM,EAAK,KAAM,IACpC5G,EACHiP,QAASjP,EAAMiP,QAAU,IAE3BlB,GAAO/N,EAAMkP,QAAU,CACzB,KAAO,CACL,MAAMnO,EAAiB,MAAVkiB,EAAiBtS,EAAexC,EAAMpN,KAAKiC,QAAQgM,KAAmE,OAA3DnL,EAAKsK,EAAMiC,OAAOtQ,EAAIA,IAAIkO,EAAQiV,EAASnjB,EAAI+H,cAAmB,EAAShE,EAAG9C,KAChJd,EAAe,MAARc,OAAe,EAASA,EAAK0T,gBACtCxU,GACFmT,EAAMnF,KAAKhO,EACf,CAGF,OADA6U,EAAG2D,OAAOuK,EAAQrS,EAAexC,EAAMpN,KAAKiC,QAAQ8K,IAAI9P,OAAO,KAAMoV,IAC9D0B,CACT,CAmBA,SAASqO,GAAUrO,GAAI,IAAEhV,EAAG,MAAEqO,EAAK,WAAEyE,GAAc9E,GACjD,IAAIkV,EAAS,EACb,IAAK,IAAIhX,EAAI,EAAGA,EAAI8B,EAAK9B,IACvBgX,GAAU7U,EAAMG,MAAMtC,GAAGuC,SAC3B,MAAM6U,EAAUJ,EAAS7U,EAAMG,MAAMR,GAAKS,SACpCyG,EAAUF,EAAGjB,QAAQkG,KAAK9N,OAChC6I,EAAGgO,OAAOE,EAASpQ,EAAYwQ,EAAUxQ,GACzC,MAAM/E,EAAuB,IAAIwV,IACjC,IAAK,IAAItV,EAAM,EAAGC,EAAQF,EAAMhO,EAAI+H,MAAOkG,EAAMjO,EAAI+H,MAAOkG,IAAOC,IAAS,CAC1E,MAAMpH,EAAM9G,EAAIA,IAAIkO,GACpB,IAAIH,EAAKyV,IAAI1c,GAGb,GADAiH,EAAK0K,IAAI3R,GACLkH,EAAM,GAAKlH,GAAO9G,EAAIA,IAAIkO,EAAQlO,EAAI+H,OAAQ,CAChD,MAAM7H,EAAQmO,EAAMiC,OAAOxJ,GAAK5G,MAChC8U,EAAGsD,cAActD,EAAGjB,QAAQpP,MAAMuQ,GAASlV,IAAI8G,EAAMgM,GAAa,KAAM,IACnE5S,EACHiP,QAASjP,EAAMiP,QAAU,IAE3BlB,GAAO/N,EAAMkP,QAAU,CACzB,MAAO,GAAIpB,EAAMhO,EAAIgI,QAAUlB,GAAO9G,EAAIA,IAAIkO,EAAQlO,EAAI+H,OAAQ,CAChE,MAAMmH,EAAOb,EAAMiC,OAAOxJ,GACpB5G,EAAQgP,EAAKhP,MACb4U,EAAO5F,EAAKjO,KAAK/C,OACrB,IAAKgC,EAAOiP,QAASD,EAAKhP,MAAMiP,QAAU,GAC1CD,EAAKxP,SAED+jB,EAASzjB,EAAIoO,WAAWJ,EAAM,EAAGC,EAAKI,GAC5C2G,EAAG2D,OAAO3D,EAAGjB,QAAQpP,MAAMuQ,GAASlV,IAAI8S,EAAa2Q,GAAS3O,GAC9D7G,GAAO/N,EAAMkP,QAAU,CACzB,CACF,CACF,CAuBA,SAASsU,GAAQxU,GACf,MAAMyU,EAAIzU,EAAKxP,QACf,OAAuB,GAAhBikB,EAAE7U,YAAmB6U,EAAEnV,MAAM,GAAGoV,aAAwC,GAAzBD,EAAEnV,MAAM,GAAGM,UACnE,CAkBA,SAAS+U,GAAWpe,EAAOK,GACzB,MAAM8L,EAAMnM,EAAMiM,UAClB,KAAME,aAAewB,IAAkBxB,EAAIC,YAAY/K,KAAO8K,EAAIE,UAAUhL,IAC1E,OAAO,EACT,MAAM+G,EAAO4U,GAAahd,IAAQ,IAAEzF,GAAQ6N,EAC5C,GAtBF,UAA+B,MAAE9F,EAAK,OAAEC,EAAM,IAAEhI,GAAO6N,GACrD,IAAIiW,EAAWjW,EAAKpB,IAAM1E,EAAQ8F,EAAK9L,KAAMgiB,EAAYD,EACrDE,GAAenW,EAAKhG,OAAS,GAAKE,EAAQ8F,EAAK9L,KAAMkiB,EAAaH,GAAYjW,EAAK/F,MAAQ+F,EAAK9L,KAAO,GAC3G,IAAK,IAAImK,EAAI2B,EAAKpB,IAAKP,EAAI2B,EAAKhG,OAAQqE,IAAK,CAC3C,GAAI2B,EAAK9L,KAAO,GAAK/B,EAAI+jB,IAAc/jB,EAAI+jB,EAAY,IAAMlW,EAAK/F,MAAQC,GAAS/H,EAAIikB,IAAejkB,EAAIikB,EAAa,GACrH,OAAO,EACTF,GAAahc,EACbkc,GAAclc,CAChB,CACA,IAAK,IAAImE,EAAI2B,EAAK9L,KAAMmK,EAAI2B,EAAK/F,MAAOoE,IAAK,CAC3C,GAAI2B,EAAKpB,IAAM,GAAKzM,EAAI8jB,IAAa9jB,EAAI8jB,EAAW/b,IAAU8F,EAAKhG,OAASG,GAAUhI,EAAIgkB,IAAgBhkB,EAAIgkB,EAAcjc,GAC1H,OAAO,EACT+b,IACAE,GACF,CACA,OAAO,CACT,CAMME,CAAsBlkB,EAAK6N,GAC7B,OAAO,EACT,GAAI/H,EAAU,CACZ,MAAMkP,EAAKvP,EAAMuP,GACXjH,EAAO,CAAC,EACd,IACIoW,EACAC,EAFA1kB,EAAU,KAAUuV,MAGxB,IAAK,IAAIjH,EAAMH,EAAKpB,IAAKuB,EAAMH,EAAKhG,OAAQmG,IAC1C,IAAK,IAAIC,EAAMJ,EAAK9L,KAAMkM,EAAMJ,EAAK/F,MAAOmG,IAAO,CACjD,MAAMkP,EAAUnd,EAAIA,IAAIgO,EAAMhO,EAAI+H,MAAQkG,GACpCiB,EAAOrB,EAAKQ,MAAMiC,OAAO6M,GAC/B,IAAIpP,EAAKoP,IAAajO,EAGtB,GADAnB,EAAKoP,IAAW,EACC,MAAbgH,EACFA,EAAYhH,EACZiH,EAAalV,MACR,CACAwU,GAAQxU,KACXxP,EAAUA,EAAQ2Z,OAAOnK,EAAKxP,UAChC,MAAM2kB,EAASrP,EAAGjB,QAAQ/T,IAAImd,EAAUtP,EAAKiF,YAC7CkC,EAAGgO,OAAOqB,EAAQA,EAASnV,EAAKT,SAClC,CACF,CAEF,GAAiB,MAAb0V,GAAmC,MAAdC,EACvB,OAAO,EAUT,GARApP,EAAGsD,cAAc6L,EAAYtW,EAAKiF,WAAY,KAAM,IAC/CK,EACDiR,EAAWlkB,MACXkkB,EAAWlkB,MAAMkP,QACjBvB,EAAK/F,MAAQ+F,EAAK9L,KAAOqiB,EAAWlkB,MAAMkP,SAE5CD,QAAStB,EAAKhG,OAASgG,EAAKpB,MAE1B/M,EAAQiU,KAAM,CAChB,MAAMd,EAAMsR,EAAY,EAAIC,EAAW1kB,QAAQiU,KACzC9D,EAAQ6T,GAAQU,GAAcD,EAAY,EAAItR,EACpDmC,EAAGO,YAAY1F,EAAQhC,EAAKiF,WAAYD,EAAMhF,EAAKiF,WAAYpT,EACjE,CACAsV,EAAGM,aACD,IAAIlC,EAAc4B,EAAG5C,IAAId,QAAQ6S,EAAYtW,EAAKiF,cAEpDhN,EAASkP,EACX,CACA,OAAO,CACT,CACA,SAASsP,GAAU7e,EAAOK,GACxB,MAAMye,EAAY1T,EAAepL,EAAMvC,QACvC,OAIyBshB,EAJA,EAAGrkB,UACnBokB,EAAUpkB,EAAKc,KAAK0N,KAAKC,WAI3B,CAACnJ,EAAOK,KACb,IAAI/B,EACJ,MAAM6N,EAAMnM,EAAMiM,UAClB,IAAIjC,EACA0N,EACJ,GAAMvL,aAAewB,EAKd,CACL,GAAIxB,EAAIC,YAAY/K,KAAO8K,EAAIE,UAAUhL,IACvC,OAAO,EACT2I,EAAWmC,EAAIC,YAAYK,UAC3BiL,EAAUvL,EAAIC,YAAY/K,GAC5B,KAVqC,CAEnC,GADA2I,EAnpDN,SAAsB0B,GACpB,IAAK,IAAIC,EAAID,EAAKE,MAAOD,EAAI,EAAGA,IAAK,CACnC,MAAMJ,EAAOG,EAAKhR,KAAKiR,GAAGnQ,KAAK0N,KAAKC,UACpC,GAAa,SAAToC,GAA4B,gBAATA,EACrB,OAAOG,EAAKhR,KAAKiR,EACrB,CACA,OAAO,IACT,CA4oDiBqT,CAAa7S,EAAIiC,QACvBpE,EACH,OAAO,EACT0N,EAA0C,OAA/BpZ,EAAKmN,EAAWU,EAAIiC,aAAkB,EAAS9P,EAAG+C,GAC/D,CAMA,GAAgB,MAAZ2I,GAA+B,MAAX0N,EACtB,OAAO,EAET,GAA8B,GAA1B1N,EAASvP,MAAMkP,SAA0C,GAA1BK,EAASvP,MAAMiP,QAChD,OAAO,EAET,GAAIrJ,EAAU,CACZ,IAAI4e,EAAYjV,EAASvP,MACzB,MAAMA,EAAQ,GACRwP,EAAWgV,EAAUhV,SACvBgV,EAAUvV,QAAU,IACtBuV,EAAY,IAAKA,EAAWvV,QAAS,IACnCuV,EAAUtV,QAAU,IACtBsV,EAAY,IAAKA,EAAWtV,QAAS,IACvC,MAAMvB,EAAO4U,GAAahd,GAAQuP,EAAKvP,EAAMuP,GAC7C,IAAK,IAAI9I,EAAI,EAAGA,EAAI2B,EAAK/F,MAAQ+F,EAAK9L,KAAMmK,IAC1ChM,EAAMiO,KACJuB,EAAW,IACNgV,EACHhV,SAAUA,GAAYA,EAASxD,GAAK,CAACwD,EAASxD,IAAM,MAClDwY,GAER,IAAIC,EACJ,IAAK,IAAI3W,EAAMH,EAAKpB,IAAKuB,EAAMH,EAAKhG,OAAQmG,IAAO,CACjD,IAAIlH,EAAM+G,EAAK7N,IAAIoO,WAAWJ,EAAKH,EAAK9L,KAAM8L,EAAKQ,OAC/CL,GAAOH,EAAKpB,MACd3F,GAAO2I,EAAShB,UAClB,IAAK,IAAIR,EAAMJ,EAAK9L,KAAMmK,EAAI,EAAG+B,EAAMJ,EAAK/F,MAAOmG,IAAO/B,IACpD+B,GAAOJ,EAAK9L,MAAQiM,GAAOH,EAAKpB,KAEpCuI,EAAG2D,OACDgM,EAAW3P,EAAGjB,QAAQ/T,IAAI8G,EAAM+G,EAAKiF,WAAY,GACjD0R,EAAY,CAAErkB,KAAMsP,EAAUzB,MAAKC,QAAO0G,cAAczU,EAAMgM,IAGpE,CACA8I,EAAGsD,cACD6E,EACAqH,EAAY,CAAErkB,KAAMsP,EAAUzB,IAAKH,EAAKpB,IAAKwB,IAAKJ,EAAK9L,OACvD7B,EAAM,IAEJ0R,aAAewB,GACjB4B,EAAGM,aACD,IAAIlC,EACF4B,EAAG5C,IAAId,QAAQM,EAAIC,YAAY/K,KAC/B6d,EAAW3P,EAAG5C,IAAId,QAAQqT,QAAY,IAG5C7e,EAASkP,EACX,CACA,OAAO,CAAI,GArEVvP,EAAOK,GAEZ,IAA2B0e,CAD3B,CA0IA,SAASI,GAAsB3jB,EAAM4M,EAAMxP,GACzC,MAAMwmB,EAAgBhX,EAAK7N,IAAI4N,YAAY,CACzC7L,KAAM,EACN0K,IAAK,EACL3E,MAAe,OAAR7G,EAAgB4M,EAAK7N,IAAI+H,MAAQ,EACxCF,OAAgB,UAAR5G,EAAmB4M,EAAK7N,IAAIgI,OAAS,IAE/C,IAAK,IAAIkE,EAAI,EAAGA,EAAI2Y,EAAc1Y,OAAQD,IAAK,CAC7C,MAAMgD,EAAOrB,EAAKQ,MAAMiC,OAAOuU,EAAc3Y,IAC7C,GAAIgD,GAAQA,EAAKjO,OAAS5C,EAAM8b,YAC9B,OAAO,CAEX,CACA,OAAO,CACT,CACA,SAAS2K,GAAa7jB,EAAMpD,GAE1B,OADAA,EAAUA,GAAW,CAAEknB,oBAAoB,IAC/BA,mBAzDd,SAAiC9jB,GAC/B,OAAO,SAASwE,EAAOK,GACrB,IAAK0L,EAAU/L,GACb,OAAO,EACT,GAAIK,EAAU,CACZ,MAAMzH,EAAQwS,EAAepL,EAAMvC,QAC7B2K,EAAO4U,GAAahd,GAAQuP,EAAKvP,EAAMuP,GACvC1B,EAAQzF,EAAK7N,IAAI4N,YACb,UAAR3M,EAAmB,CACjBc,KAAM8L,EAAK9L,KACX0K,IAAK,EACL3E,MAAO+F,EAAK/F,MACZD,OAAQgG,EAAK7N,IAAIgI,QACP,OAAR/G,EAAgB,CAClBc,KAAM,EACN0K,IAAKoB,EAAKpB,IACV3E,MAAO+F,EAAK7N,IAAI+H,MAChBF,OAAQgG,EAAKhG,QACXgG,GAEAkD,EAAQuC,EAAMtT,KAAK8G,GAAQ+G,EAAKQ,MAAMiC,OAAOxJ,KACnD,IAAK,IAAIoF,EAAI,EAAGA,EAAIoH,EAAMnH,OAAQD,IAC5B6E,EAAM7E,GAAGjL,MAAQ5C,EAAM8b,aACzBnF,EAAGsD,cACDzK,EAAKiF,WAAaQ,EAAMpH,GACxB7N,EAAM6Q,KACN6B,EAAM7E,GAAGhM,OAEf,GAAuB,GAAnB8U,EAAGG,MAAMhJ,OACX,IAAK,IAAID,EAAI,EAAGA,EAAIoH,EAAMnH,OAAQD,IAChC8I,EAAGsD,cACDzK,EAAKiF,WAAaQ,EAAMpH,GACxB7N,EAAM8b,YACNpJ,EAAM7E,GAAGhM,OAEf4F,EAASkP,EACX,CACA,OAAO,CACT,CACF,CAmBWgQ,CAAwB/jB,GAC1B,SAASwE,EAAOK,GACrB,IAAK0L,EAAU/L,GACb,OAAO,EACT,GAAIK,EAAU,CACZ,MAAMzH,EAAQwS,EAAepL,EAAMvC,QAC7B2K,EAAO4U,GAAahd,GAAQuP,EAAKvP,EAAMuP,GACvCiQ,EAAqBL,GAAsB,MAAO/W,EAAMxP,GACxD6mB,EAAwBN,GAC5B,SACA/W,EACAxP,GAGI8mB,GAD2B,WAATlkB,EAAoBgkB,EAA8B,QAAThkB,GAAiBikB,GACtC,EAAI,EAC1CE,EAAoB,UAARnkB,EAAmB,CACnCc,KAAM,EACN0K,IAAK0Y,EACLrd,MAAO,EACPD,OAAQgG,EAAK7N,IAAIgI,QACP,OAAR/G,EAAgB,CAClBc,KAAMojB,EACN1Y,IAAK,EACL3E,MAAO+F,EAAK7N,IAAI+H,MAChBF,OAAQ,GACNgG,EACEwX,EAAkB,UAARpkB,EAAmBikB,EAAwB7mB,EAAM6Q,KAAO7Q,EAAM8b,YAAsB,OAARlZ,EAAgBgkB,EAAqB5mB,EAAM6Q,KAAO7Q,EAAM8b,YAAc9b,EAAM6Q,KACxKrB,EAAK7N,IAAI4N,YAAYwX,GAAWE,SAASC,IACvC,MAAMpI,EAAUoI,EAAkB1X,EAAKiF,WACjC5D,EAAO8F,EAAG5C,IAAI9B,OAAO6M,GACvBjO,GACF8F,EAAGsD,cAAc6E,EAASkI,EAASnW,EAAKhP,MAC1C,IAEF4F,EAASkP,EACX,CACA,OAAO,CACT,CACF,CACsB8P,GAAa,MAAO,CACxCC,oBAAoB,IAEGD,GAAa,SAAU,CAC9CC,oBAAoB,IAJtB,IAMIS,GAAmBV,GAAa,OAAQ,CAC1CC,oBAAoB,IA6BtB,SAASU,GAAaC,GACpB,OAAO,SAASjgB,EAAOK,GACrB,IAAK0L,EAAU/L,GACb,OAAO,EACT,MAAMyJ,EA/BV,SAAsB8C,EAAOjF,GAC3B,GAAIA,EAAM,EAAG,CACX,MAAMwE,EAASS,EAAMK,WACrB,GAAId,EACF,OAAOS,EAAMlL,IAAMyK,EAAO9C,SAC5B,IAAK,IAAIT,EAAMgE,EAAM9D,OAAO,GAAK,EAAGK,EAASyD,EAAMT,SAAUvD,GAAO,EAAGA,IAAO,CAC5E,MAAMe,EAAUiD,EAAM7R,MAAM,GAAGqO,MAAMR,GAC/BsE,EAAYvD,EAAQuD,UAC1B,GAAIA,EACF,OAAO/D,EAAS,EAAI+D,EAAU7D,SAEhCF,GAAUQ,EAAQN,QACpB,CACF,KAAO,CACL,GAAIuD,EAAM9D,QAAU8D,EAAMhO,OAAO8K,WAAa,EAC5C,OAAOkD,EAAMlL,IAAMkL,EAAME,UAAUzD,SAErC,MAAMJ,EAAQ2D,EAAM7R,MAAM,GAC1B,IAAK,IAAI6N,EAAMgE,EAAMkL,YAAY,GAAI5O,EAAW0D,EAAMC,QAASjE,EAAMK,EAAMS,WAAYd,IAAO,CAC5F,MAAMe,EAAUV,EAAMG,MAAMR,GAC5B,GAAIe,EAAQD,WACV,OAAOR,EAAW,EACpBA,GAAYS,EAAQN,QACtB,CACF,CACA,OAAO,IACT,CAKiBkX,CAAahU,EAAclM,GAAQigB,GAChD,GAAY,MAARxW,EACF,OAAO,EACT,GAAIpJ,EAAU,CACZ,MAAMkM,EAAQvM,EAAM2M,IAAId,QAAQpC,GAChCpJ,EACEL,EAAMuP,GAAGM,aAAa,KAAejB,QAAQrC,GAj1D5Bb,EAi1DmDa,EAh1DnEb,EAAKhR,KAAK,GAAGmR,QAAQH,EAAKrK,IAAMqK,EAAKe,UAAUzD,aAg1D6BzJ,iBAEjF,CAn1DJ,IAAyBmM,EAo1DrB,OAAO,CACT,CACF,CAiBA,SAASyU,IAAa,wBACpBC,GAA0B,GACxB,CAAC,GACH,OAAO,IAAI,KAAQ,CACjBnf,IAAKuK,EAILxL,MAAO,CACL,IAAA4Z,GACE,OAAO,IACT,EACA,KAAAK,CAAM1K,EAAIwC,GACR,MAAMzL,EAAMiJ,EAAGmN,QAAQlR,GACvB,GAAW,MAAPlF,EACF,OAAe,GAARA,EAAY,KAAOA,EAC5B,GAAW,MAAPyL,IAAgBxC,EAAGwG,WACrB,OAAOhE,EACT,MAAM,QAAEsO,EAAO,IAAEhf,GAAQkO,EAAGjB,QAAQgS,UAAUvO,GAC9C,OAAOsO,EAAU,KAAOhf,CAC1B,GAEFH,MAAO,CACLmb,YAAa3K,EACb0I,gBAAiB,CACfS,UAAWxX,GAEb,sBAAAkd,CAAuBnf,GACrB,OAA+C,MAAxCoK,EAAgB8L,SAASlW,EAAKpB,OAAiBoB,EAAKpB,MAAMiM,UAAY,IAC/E,EACA+J,oBACAjB,gBACAkB,eAEF,iBAAAuK,CAAkBtK,EAAG1D,EAAUxS,GAC7B,OAxiDN,SAA4BA,EAAOuP,EAAI6Q,GACrC,MAAMjU,GAAOoD,GAAMvP,GAAOiM,UACpBU,GAAO4C,GAAMvP,GAAO2M,IAC1B,IAAI/O,EACA2N,EACJ,GAAIY,aAAe,OAAmBZ,EAAOY,EAAIzR,KAAKc,KAAK0N,KAAKC,YAC9D,GAAY,QAARoC,GAA0B,eAARA,EACpB3N,EAAY+P,EAAclV,OAAOkU,EAAKR,EAAI8B,WACrC,GAAY,OAAR1C,EAAe,CACxB,MAAMgB,EAAQI,EAAId,QAAQM,EAAI8B,KAAO,GACrCrQ,EAAY+P,EAAcc,aAAalC,EAAOA,EAChD,MAAO,IAAK6T,EAAyB,CACnC,MAAM7lB,EAAMoM,EAASP,IAAI+F,EAAIzR,MACvB0P,EAAQ+B,EAAI8B,KAAO,EACnBiR,EAAW9U,EAAQ7P,EAAIA,IAAIA,EAAI+H,MAAQ/H,EAAIgI,OAAS,GAC1D3E,EAAY+P,EAAclV,OAAOkU,EAAKvC,EAAQ,EAAG8U,EACnD,OACS/S,aAAe,MAlD5B,UAAiC,MAAEiC,EAAK,IAAEC,IACxC,GAAID,EAAM/M,KAAOgN,EAAIhN,KAAO+M,EAAM/M,IAAM+M,EAAM/M,IAAM,EAClD,OAAO,EACT,IAAIof,EAAYrS,EAAM/M,IAClBqf,EAAWrS,EAAIhN,IACfuK,EAAQwC,EAAMxC,MAClB,KAAOA,GAAS,KACVwC,EAAM5B,MAAMZ,EAAQ,GAAKwC,EAAMhB,IAAIxB,IADtBA,IAAS6U,KAG5B,IAAK,IAAI9U,EAAI0C,EAAIzC,MAAOD,GAAK,KACvB0C,EAAIvC,OAAOH,EAAI,GAAK0C,EAAIjE,MAAMuB,IADJA,IAAK+U,KAGrC,OAAOD,GAAaC,GAAY,YAAYC,KAAKvS,EAAM1T,KAAKkR,GAAOpQ,KAAK0N,KAAKC,UAC/E,CAqC6CyX,CAAwBzU,GACjEvO,EAAY,KAAcnF,OAAOkU,EAAKR,EAAI8B,MACjC9B,aAAe,MAtC5B,UAAoC,MAAEiC,EAAK,IAAEC,IAC3C,IAAIwS,EACAC,EACJ,IAAK,IAAIra,EAAI2H,EAAMxC,MAAOnF,EAAI,EAAGA,IAAK,CACpC,MAAM/L,EAAO0T,EAAM1T,KAAK+L,GACxB,GAAiC,SAA7B/L,EAAKc,KAAK0N,KAAKC,WAAqD,gBAA7BzO,EAAKc,KAAK0N,KAAKC,UAA6B,CACrF0X,EAAuBnmB,EACvB,KACF,CACF,CACA,IAAK,IAAI+L,EAAI4H,EAAIzC,MAAOnF,EAAI,EAAGA,IAAK,CAClC,MAAM/L,EAAO2T,EAAI3T,KAAK+L,GACtB,GAAiC,SAA7B/L,EAAKc,KAAK0N,KAAKC,WAAqD,gBAA7BzO,EAAKc,KAAK0N,KAAKC,UAA6B,CACrF2X,EAAqBpmB,EACrB,KACF,CACF,CACA,OAAOmmB,IAAyBC,GAA2C,IAArBzS,EAAI0S,YAC5D,CAoB6CC,CAA2B7U,KACpEvO,EAAY,KAAcnF,OAAOkU,EAAKR,EAAIiC,MAAMhE,QAAS+B,EAAIiC,MAAMhB,QAIrE,OAFIxP,IACD2R,IAAOA,EAAKvP,EAAMuP,KAAKM,aAAajS,GAChC2R,CACT,CA+gDa0R,CACLjhB,EACAuS,EAAUvS,EAAOwS,GACjB4N,EAEJ,GAEJ,CC50EA,SAASc,GAAcxmB,EAAM4d,EAAU1P,EAAOuP,EAAcS,EAAaC,GACrE,IAAIC,EAAa,EACbC,GAAa,EACbC,EAAUV,EAAS5L,WACvB,MAAMnE,EAAM7N,EAAKgS,WACjB,IAAK,IAAIjG,EAAI,EAAG+B,EAAM,EAAG/B,EAAI8B,EAAIc,WAAY5C,GAAK,EAAG,CACjD,MAAM,QAAEkD,EAAO,SAAEM,GAAa1B,EAAIQ,MAAMtC,GAAGhM,MAC3C,IAAK,IAAIwM,EAAI,EAAGA,EAAI0C,EAAS1C,GAAK,EAAGuB,GAAO,EAAG,CAC3C,MAAMyQ,EAAWL,IAAgBpQ,EAAMqQ,EAAgB5O,GAAYA,EAAShD,GACtEiS,EAAWD,EAAW,GAAGA,MAAe,GAC9CH,GAAcG,GAAYd,EACrBc,IACDF,GAAa,GAEZC,GAIGA,EAAQ5f,MAAMkJ,QAAU4W,IACxBF,EAAQ5f,MAAMkJ,MAAQ4W,GAE1BF,EAAUA,EAAQG,aANlBb,EAASD,YAAYjZ,SAASgZ,cAAc,QAAQhf,MAAMkJ,MAAQ4W,CAQ1E,CACJ,CACA,KAAOF,GAAS,CACZ,MAAMxM,EAAQwM,EAAQG,YACtBH,EAAQlB,WAAWsB,YAAYJ,GAC/BA,EAAUxM,CACd,CACIuM,GACAnQ,EAAMxP,MAAMkJ,MAAQ,GAAGwW,MACvBlQ,EAAMxP,MAAMigB,SAAW,KAGvBzQ,EAAMxP,MAAMkJ,MAAQ,GACpBsG,EAAMxP,MAAMigB,SAAW,GAAGP,MAElC,CACA,MAAM,GACF,WAAAlS,CAAYlM,EAAMyd,GACdrf,KAAK4B,KAAOA,EACZ5B,KAAKqf,aAAeA,EACpBrf,KAAK+e,IAAMzY,SAASgZ,cAAc,OAClCtf,KAAK+e,IAAI9Z,UAAY,eACrBjF,KAAK8P,MAAQ9P,KAAK+e,IAAIQ,YAAYjZ,SAASgZ,cAAc,UACzDtf,KAAKwf,SAAWxf,KAAK8P,MAAMyP,YAAYjZ,SAASgZ,cAAc,aAC9D8I,GAAcxmB,EAAM5B,KAAKwf,SAAUxf,KAAK8P,MAAOuP,GAC/Crf,KAAK0f,WAAa1f,KAAK8P,MAAMyP,YAAYjZ,SAASgZ,cAAc,SACpE,CACA,MAAAK,CAAO/d,GACH,OAAIA,EAAKc,OAAS1C,KAAK4B,KAAKc,OAG5B1C,KAAK4B,KAAOA,EACZwmB,GAAcxmB,EAAM5B,KAAKwf,SAAUxf,KAAK8P,MAAO9P,KAAKqf,eAC7C,EACX,CACA,cAAAO,CAAeyI,GACX,MAA0B,eAAlBA,EAAS3lB,OACT2lB,EAAS5f,SAAWzI,KAAK8P,OAAS9P,KAAKwf,SAAShZ,SAAS6hB,EAAS5f,QAC9E,EAGJ,SAAS6f,GAAWC,EAAUC,GAC1B,OAAIA,EACOD,EAAS7K,cAAc,KAAM8K,GAEjCD,EAASnS,eACpB,CAiBA,SAASqS,GAAY9jB,EAAQ+jB,EAAWC,EAAWC,EAAeJ,GAC9D,MAAM1oB,EAhBV,SAA2B6E,GACvB,GAAIA,EAAO4N,OAAOD,eACd,OAAO3N,EAAO4N,OAAOD,eAEzB,MAAMuW,EAAQ,CAAC,EAQf,OAPAC,OAAOC,KAAKpkB,EAAO6N,OAAOuU,SAAQrkB,IAC9B,MAAMsY,EAAWrW,EAAO6N,MAAM9P,GAC1BsY,EAAS5K,KAAKC,YACdwY,EAAM7N,EAAS5K,KAAKC,WAAa2K,EACrC,IAEJrW,EAAO4N,OAAOD,eAAiBuW,EACxBA,CACX,CAGkBG,CAAkBrkB,GAC1BskB,EAAc,GACdlU,EAAQ,GACd,IAAK,IAAIpF,EAAQ,EAAGA,EAAQgZ,EAAWhZ,GAAS,EAAG,CAC/C,MAAMgB,EAAO2X,GAAWxoB,EAAM6Q,KAAM6X,GAIpC,GAHI7X,GACAoE,EAAMnF,KAAKe,GAEXiY,EAAe,CACf,MAAMvE,EAAaiE,GAAWxoB,EAAM8b,YAAa4M,GAC7CnE,GACA4E,EAAYrZ,KAAKyU,EAEzB,CACJ,CACA,MAAMtO,EAAO,GACb,IAAK,IAAIpG,EAAQ,EAAGA,EAAQ+Y,EAAW/Y,GAAS,EAC5CoG,EAAKnG,KAAK9P,EAAM2P,IAAIiO,cAAc,KAAMkL,GAA2B,IAAVjZ,EAAcsZ,EAAclU,IAEzF,OAAOjV,EAAMgQ,MAAM4N,cAAc,KAAM3H,EAC3C,CAMA,MAAMmT,GAAkC,EAAG5mB,aACvC,MAAM,UAAE6Q,GAAc7Q,EAAO4E,MAC7B,KAAqBiM,aALG0B,GAMpB,OAAO,EAEX,IAAIsU,EAAY,EAChB,MAAMrZ,GAAQ,QAA2BqD,EAAU+B,OAAO,GAAGI,OAAO1T,GACtC,UAAnBA,EAAKc,KAAK9C,OAEX,OAAVkQ,QAA4B,IAAVA,GAA4BA,EAAMlO,KAAK2Y,aAAY3Y,IACjE,GAAuB,UAAnBA,EAAKc,KAAK9C,KACV,OAAO,EAEP,CAAC,YAAa,eAAeiC,SAASD,EAAKc,KAAK9C,QAChDupB,GAAa,EACjB,IAGJ,OADyBA,IAAchW,EAAU+B,OAAOtH,SAIxDtL,EAAOP,SAASqnB,eACT,EAAI,EChGf,ODmGc,KAAKzpB,OAAO,CACtBC,KAAM,QAEN,UAAAC,GACI,MAAO,CACHqB,eAAgB,CAAC,EACjBmoB,WAAW,EACX3I,YAAa,EACbrB,aAAc,GAEdsB,KAAM,GACNC,qBAAqB,EACrB0G,yBAAyB,EAEjC,EACAnmB,QAAS,YACTkP,UAAW,QACXiZ,WAAW,EACXloB,MAAO,QACP,SAAAhB,GACI,MAAO,CAAC,CAAEsB,IAAK,SACnB,EACA,UAAAlB,EAAW,eAAEU,IACT,MAAO,CAAC,SAAS,QAAgBlB,KAAKV,QAAQ4B,eAAgBA,GAAiB,CAAC,QAAS,GAC7F,EACA,WAAAT,GACI,MAAO,CACH8oB,YAAa,EAAGxT,OAAO,EAAGyT,OAAO,EAAGZ,iBAAgB,GAAS,CAAC,IAAM,EAAGnS,KAAIlP,WAAUjF,aACjF,MAAMV,EAAO6mB,GAAYnmB,EAAOqC,OAAQoR,EAAMyT,EAAMZ,GACpD,GAAIrhB,EAAU,CACV,MAAM2R,EAASzC,EAAGtD,UAAU6E,OAAS,EACrCvB,EAAGgT,qBAAqB7nB,GACnB6E,iBACAsQ,aAAa,KAAc4B,KAAKlC,EAAG5C,IAAId,QAAQmG,IACxD,CACA,OAAO,CAAI,EAEfwQ,gBAAiB,IAAM,EAAGxiB,QAAOK,cDknD7C,SAAyBL,EAAOK,GAC9B,IAAK0L,EAAU/L,GACb,OAAO,EACT,GAAIK,EAAU,CACZ,MAAM+H,EAAO4U,GAAahd,GAC1BK,EAAS4c,GAAUjd,EAAMuP,GAAInH,EAAMA,EAAK9L,MAC1C,CACA,OAAO,CACT,CCznDuBkmB,CAAgBxiB,EAAOK,GAElCoiB,eAAgB,IAAM,EAAGziB,QAAOK,cDwnD5C,SAAwBL,EAAOK,GAC7B,IAAK0L,EAAU/L,GACb,OAAO,EACT,GAAIK,EAAU,CACZ,MAAM+H,EAAO4U,GAAahd,GAC1BK,EAAS4c,GAAUjd,EAAMuP,GAAInH,EAAMA,EAAK/F,OAC1C,CACA,OAAO,CACT,CC/nDuBogB,CAAeziB,EAAOK,GAEjCqiB,aAAc,IAAM,EAAG1iB,QAAOK,cDkpD1C,SAAsBL,EAAOK,GAC3B,IAAK0L,EAAU/L,GACb,OAAO,EACT,GAAIK,EAAU,CACZ,MAAM+H,EAAO4U,GAAahd,GACpBuP,EAAKvP,EAAMuP,GACjB,GAAiB,GAAbnH,EAAK9L,MAAa8L,EAAK/F,OAAS+F,EAAK7N,IAAI+H,MAC3C,OAAO,EACT,IAAK,IAAImE,EAAI2B,EAAK/F,MAAQ,EACxBgb,GAAa9N,EAAInH,EAAM3B,GACnBA,GAAK2B,EAAK9L,KAFemK,IAAK,CAIlC,MAAMmC,EAAQR,EAAKiF,WAAakC,EAAG5C,IAAI9B,OAAOzC,EAAKiF,WAAa,GAAKkC,EAAG5C,IACxE,IAAK/D,EACH,MAAM1B,WAAW,kBAEnBkB,EAAKQ,MAAQA,EACbR,EAAK7N,IAAMoM,EAASP,IAAIwC,EAC1B,CACAvI,EAASkP,EACX,CACA,OAAO,CACT,CCvqDuBmT,CAAa1iB,EAAOK,GAE/BsiB,aAAc,IAAM,EAAG3iB,QAAOK,cD0sD1C,SAAsBL,EAAOK,GAC3B,IAAK0L,EAAU/L,GACb,OAAO,EACT,GAAIK,EAAU,CACZ,MAAM+H,EAAO4U,GAAahd,GAC1BK,EAASmd,GAAOxd,EAAMuP,GAAInH,EAAMA,EAAKpB,KACvC,CACA,OAAO,CACT,CCjtDuB2b,CAAa3iB,EAAOK,GAE/BuiB,YAAa,IAAM,EAAG5iB,QAAOK,cDgtDzC,SAAqBL,EAAOK,GAC1B,IAAK0L,EAAU/L,GACb,OAAO,EACT,GAAIK,EAAU,CACZ,MAAM+H,EAAO4U,GAAahd,GAC1BK,EAASmd,GAAOxd,EAAMuP,GAAInH,EAAMA,EAAKhG,QACvC,CACA,OAAO,CACT,CCvtDuBwgB,CAAY5iB,EAAOK,GAE9BwiB,UAAW,IAAM,EAAG7iB,QAAOK,cDuvDvC,SAAmBL,EAAOK,GACxB,IAAK0L,EAAU/L,GACb,OAAO,EACT,GAAIK,EAAU,CACZ,MAAM+H,EAAO4U,GAAahd,GAAQuP,EAAKvP,EAAMuP,GAC7C,GAAgB,GAAZnH,EAAKpB,KAAYoB,EAAKhG,QAAUgG,EAAK7N,IAAIgI,OAC3C,OAAO,EACT,IAAK,IAAIkE,EAAI2B,EAAKhG,OAAS,EACzBwb,GAAUrO,EAAInH,EAAM3B,GAChBA,GAAK2B,EAAKpB,IAFgBP,IAAK,CAInC,MAAMmC,EAAQR,EAAKiF,WAAakC,EAAG5C,IAAI9B,OAAOzC,EAAKiF,WAAa,GAAKkC,EAAG5C,IACxE,IAAK/D,EACH,MAAM1B,WAAW,kBAEnBkB,EAAKQ,MAAQA,EACbR,EAAK7N,IAAMoM,EAASP,IAAIgC,EAAKQ,MAC/B,CACAvI,EAASkP,EACX,CACA,OAAO,CACT,CC3wDuBsT,CAAU7iB,EAAOK,GAE5B6hB,YAAa,IAAM,EAAGliB,QAAOK,cDilEzC,SAAqBL,EAAOK,GAC1B,MAAMqL,EAAO1L,EAAMiM,UAAUK,QAC7B,IAAK,IAAIX,EAAID,EAAKE,MAAOD,EAAI,EAAGA,IAE9B,GAAgC,SADnBD,EAAKhR,KAAKiR,GACdnQ,KAAK0N,KAAKC,UAKjB,OAJI9I,GACFA,EACEL,EAAMuP,GAAGgO,OAAO7R,EAAKI,OAAOH,GAAID,EAAKc,MAAMb,IAAIpM,mBAE5C,EAGX,OAAO,CACT,CC7lEuB2iB,CAAYliB,EAAOK,GAE9B+d,WAAY,IAAM,EAAGpe,QAAOK,cACjB+d,GAAWpe,EAAOK,GAE7Bwe,UAAW,IAAM,EAAG7e,QAAOK,cAChBwe,GAAU7e,EAAOK,GAE5ByiB,mBAAoB,IAAM,EAAG9iB,QAAOK,cACzBgf,GAAa,SAAbA,CAAuBrf,EAAOK,GAEzC0iB,gBAAiB,IAAM,EAAG/iB,QAAOK,cACtBgf,GAAa,MAAbA,CAAoBrf,EAAOK,GAEtC0f,iBAAkB,IAAM,EAAG/f,QAAOK,cACvB0f,GAAiB/f,EAAOK,GAEnC2iB,aAAc,IAAM,EAAGhjB,QAAOK,gBACtB+d,GAAWpe,EAAOK,IAGfwe,GAAU7e,EAAOK,GAE5B4iB,iBAAkB,CAACvqB,EAAM2N,IAAU,EAAGrG,QAAOK,cDy4DzD,SAAqB3H,EAAM2N,GACzB,OAAO,SAASrG,EAAOK,GACrB,IAAK0L,EAAU/L,GACb,OAAO,EACT,MAAMuM,EAAQL,EAAclM,GAC5B,GAAIuM,EAAME,UAAUhS,MAAM/B,KAAU2N,EAClC,OAAO,EACT,GAAIhG,EAAU,CACZ,MAAMkP,EAAKvP,EAAMuP,GACbvP,EAAMiM,qBAAqB0B,EAC7B3N,EAAMiM,UAAU8D,aAAY,CAACrV,EAAM2G,KAC7B3G,EAAKD,MAAM/B,KAAU2N,GACvBkJ,EAAGsD,cAAcxR,EAAK,KAAM,IACvB3G,EAAKD,MACR,CAAC/B,GAAO2N,GACR,IAGNkJ,EAAGsD,cAActG,EAAMlL,IAAK,KAAM,IAC7BkL,EAAME,UAAUhS,MACnB,CAAC/B,GAAO2N,IAEZhG,EAASkP,EACX,CACA,OAAO,CACT,CACF,CCl6DuB2T,CAAYxqB,EAAM2N,EAAlB6c,CAAyBljB,EAAOK,GAE3C2f,aAAc,IAAM,EAAGhgB,QAAOK,cACnB2f,GAAa,EAAbA,CAAgBhgB,EAAOK,GAElC8iB,iBAAkB,IAAM,EAAGnjB,QAAOK,cACvB2f,IAAc,EAAdA,CAAiBhgB,EAAOK,GAEnCkS,UAAW,IAAM,EAAGvS,QAAOK,eACnBA,GACAkS,EAAUvS,IAEP,GAEXiX,iBAAkB5a,GAAY,EAAGkT,KAAIlP,eACjC,GAAIA,EAAU,CACV,MAAM4L,EAAY0B,EAAclV,OAAO8W,EAAG5C,IAAKtQ,EAAS4U,WAAY5U,EAAS6U,UAE7E3B,EAAGM,aAAa5D,EACpB,CACA,OAAO,CAAI,EAGvB,EACA,oBAAAhR,GACI,MAAO,CACHmoB,IAAK,MACGtqB,KAAKsC,OAAOP,SAASmlB,kBAGpBlnB,KAAKsC,OAAOioB,MAAMT,eAGhB9pB,KAAKsC,OAAO3B,QAAQmpB,cAAc5C,eAAermB,MAE5D,YAAa,IAAMb,KAAKsC,OAAOP,SAASsoB,mBACxC7N,UAAW0M,GACX,gBAAiBA,GACjBxM,OAAQwM,GACR,aAAcA,GAEtB,EACA,qBAAAhhB,GAEI,MAAO,IADalI,KAAKV,QAAQ+pB,WAAarpB,KAAKsC,OAAOkoB,WAGhD,CACE/J,EAAe,CACXC,YAAa1gB,KAAKV,QAAQohB,YAC1BrB,aAAcrf,KAAKV,QAAQ+f,aAE3BsB,KAAM3gB,KAAKV,QAAQqhB,KAGnBC,oBAAqB5gB,KAAKV,QAAQshB,uBAGxC,GACNyG,GAAa,CACTC,wBAAyBtnB,KAAKV,QAAQgoB,0BAGlD,EACA,gBAAAmD,CAAiBnmB,GACb,MAAMomB,EAAU,CACZ9qB,KAAM0E,EAAU1E,KAChBN,QAASgF,EAAUhF,QACnByG,QAASzB,EAAUyB,SAEvB,MAAO,CACHsK,WAAW,SAAa,QAAkB/L,EAAW,YAAaomB,IAE1E,IC/RwBnlB,OAAO,CAgB/B,qBAAA2C,GAEI,MAAO,IADalI,KAAKV,QAAQ+pB,UAGvB,CACE5I,EAAe,CACXC,YAAa1gB,KAAKV,QAAQohB,YAC1BrB,aAAcrf,KAAKV,QAAQ+f,aAE3BsB,KAAM3gB,KAAKV,QAAQqhB,KACnBC,oBAAqB5gB,KAAKV,QAAQshB,uBAGxC,GACNyG,GAAa,CACTC,wBAAyBtnB,KAAKV,QAAQgoB,0BAGlD,G,qFCvCJ,MAAM3e,EAAa,WACbgiB,EAAa,KAAKhrB,OAAO,CAC3BC,KAAM,aACN,UAAAC,GACI,MAAO,CACHqB,eAAgB,CAAC,EAEzB,EACAC,QAAS,SACTC,MAAO,QACPC,UAAU,EACV,SAAAjB,GACI,MAAO,CACH,CAAEsB,IAAK,cAEf,EACA,UAAAlB,EAAW,eAAEU,IACT,MAAO,CAAC,cAAc,QAAgBlB,KAAKV,QAAQ4B,eAAgBA,GAAiB,EACxF,EACA,WAAAT,GACI,MAAO,CACHmqB,cAAe,IAAM,EAAG7oB,cACbA,EAAS8oB,OAAO7qB,KAAKJ,MAEhCkrB,iBAAkB,IAAM,EAAG/oB,cAChBA,EAASgpB,WAAW/qB,KAAKJ,MAEpCorB,gBAAiB,IAAM,EAAGjpB,cACfA,EAASkpB,KAAKjrB,KAAKJ,MAGtC,EACA,oBAAAuC,GACI,MAAO,CACH,cAAe,IAAMnC,KAAKsC,OAAOP,SAAS+oB,mBAElD,EACA,aAAAvoB,GACI,MAAO,EACH,QAAkB,CACdC,KAAMmG,EACNjG,KAAM1C,KAAK0C,OAGvB,G,qFC5CJ,MAAMwoB,EAAiB,yCACjBC,EAAiB,yCACjBC,EAAuB,sCACvBC,EAAuB,sCACvBC,EAAO,KAAK3rB,OAAO,CACrBC,KAAM,OACN,UAAAC,GACI,MAAO,CACHqB,eAAgB,CAAC,EAEzB,EACA,SAAAd,GACI,MAAO,CACH,CACIsB,IAAK,UAET,CACIA,IAAK,IACLmL,SAAUjL,GAAkC,WAA1BA,EAAKtB,MAAMirB,YAA2B,MAE5D,CACIjrB,MAAO,cACPuM,SAAUU,GAAS,4BAA4Bsa,KAAKta,IAAU,MAG1E,EACA,UAAA/M,EAAW,eAAEU,IACT,MAAO,CAAC,UAAU,QAAgBlB,KAAKV,QAAQ4B,eAAgBA,GAAiB,EACpF,EACA,WAAAT,GACI,MAAO,CACH+qB,QAAS,IAAM,EAAGzpB,cACPA,EAASnB,QAAQZ,KAAKJ,MAEjC6rB,WAAY,IAAM,EAAG1pB,cACVA,EAAS2pB,WAAW1rB,KAAKJ,MAEpC+rB,UAAW,IAAM,EAAG5pB,cACTA,EAAS6pB,UAAU5rB,KAAKJ,MAG3C,EACA,oBAAAuC,GACI,MAAO,CACH,QAAS,IAAMnC,KAAKsC,OAAOP,SAAS0pB,aACpC,QAAS,IAAMzrB,KAAKsC,OAAOP,SAAS0pB,aAE5C,EACA,aAAAlpB,GACI,MAAO,EACH,QAAc,CACVC,KAAM0oB,EACNxoB,KAAM1C,KAAK0C,QAEf,QAAc,CACVF,KAAM4oB,EACN1oB,KAAM1C,KAAK0C,OAGvB,EACA,aAAAmpB,GACI,MAAO,EACH,QAAc,CACVrpB,KAAM2oB,EACNzoB,KAAM1C,KAAK0C,QAEf,QAAc,CACVF,KAAM6oB,EACN3oB,KAAM1C,KAAK0C,OAGvB,G,qFCvEJ,MAAMopB,EAAW,KAAKnsB,OAAO,CACzBC,KAAM,WACN,UAAAC,GACI,MAAO,CACHqB,eAAgB,CAAC,EAEzB,EACAC,QAAS,mBACTE,UAAU,EACV,SAAAjB,GACI,MAAO,CACH,CACIsB,IAAK,MAGjB,EACA,UAAAlB,EAAW,eAAEU,IACT,MAAO,CAAC,MAAM,QAAgBlB,KAAKV,QAAQ4B,eAAgBA,GAAiB,EAChF,EACA,oBAAAiB,GACI,MAAO,CACH4pB,MAAO,IAAM/rB,KAAKsC,OAAOP,SAASiqB,cAAchsB,KAAKJ,MACrD0qB,IAAK,IAAMtqB,KAAKsC,OAAOP,SAASkqB,aAAajsB,KAAKJ,MAClD,YAAa,IAAMI,KAAKsC,OAAOP,SAASmqB,aAAalsB,KAAKJ,MAElE,IAGEusB,EAAY,KAAKxsB,OAAO,CAC1BC,KAAM,YACN,UAAAC,GACI,MAAO,CACHqB,eAAgB,CAAC,EAEzB,EACA,SAAAd,GACI,MAAO,CACH,CACIsB,IAAK,OACLmL,SAAUxM,KACYA,EAAQ+rB,aAAa,UAIhC,CAAC,GAIxB,EACA,UAAA5rB,EAAW,eAAEU,IACT,MAAO,CAAC,QAAQ,QAAgBlB,KAAKV,QAAQ4B,eAAgBA,GAAiB,EAClF,EACA,WAAAT,GACI,MAAO,CACHM,qBAAsB,IAAM,EAAGmG,QAAOnF,eAClC,MAAM9B,GAAa,QAAkBiH,EAAOlH,KAAK0C,MAEjD,QADkBomB,OAAOuD,QAAQpsB,GAAY0U,MAAK,EAAE,CAAEpH,OAAaA,KAI5DxL,EAAS6pB,UAAU5rB,KAAKJ,KAAK,EAGhD,IAGE+I,EAAa,iBACb2jB,EAAa,KAAK3sB,OAAO,CAC3BC,KAAM,aACN,UAAAC,GACI,MAAO,CACH0sB,aAAc,WACdrrB,eAAgB,CAAC,EACjBsrB,WAAW,EACXC,gBAAgB,EAExB,EACArrB,MAAO,aACP,OAAAD,GACI,MAAO,GAAGnB,KAAKV,QAAQitB,eAC3B,EACA,SAAAnsB,GACI,MAAO,CACH,CAAEsB,IAAK,MAEf,EACA,UAAAlB,EAAW,eAAEU,IACT,MAAO,CAAC,MAAM,QAAgBlB,KAAKV,QAAQ4B,eAAgBA,GAAiB,EAChF,EACA,WAAAT,GACI,MAAO,CACHisB,iBAAkB,IAAM,EAAG3qB,WAAUpB,WAC7BX,KAAKV,QAAQmtB,eACN9rB,IAAQgsB,WAAW3sB,KAAKJ,KAAMI,KAAKV,QAAQitB,aAAcvsB,KAAKV,QAAQktB,WAAWvhB,iBAAiB6gB,EAASlsB,KAAMI,KAAKsC,OAAOK,cAAcwpB,EAAUvsB,OAAOiB,MAEhKkB,EAAS4qB,WAAW3sB,KAAKJ,KAAMI,KAAKV,QAAQitB,aAAcvsB,KAAKV,QAAQktB,WAG1F,EACA,oBAAArqB,GACI,MAAO,CACH,cAAe,IAAMnC,KAAKsC,OAAOP,SAAS2qB,mBAElD,EACA,aAAAnqB,GACI,IAAIqqB,GAAY,QAAkB,CAC9BpqB,KAAMmG,EACNjG,KAAM1C,KAAK0C,OAYf,OAVI1C,KAAKV,QAAQktB,WAAaxsB,KAAKV,QAAQmtB,kBACvCG,GAAY,QAAkB,CAC1BpqB,KAAMmG,EACNjG,KAAM1C,KAAK0C,KACX8pB,UAAWxsB,KAAKV,QAAQktB,UACxBC,eAAgBzsB,KAAKV,QAAQmtB,eAC7B9pB,cAAe,IAAe3C,KAAKsC,OAAOK,cAAcwpB,EAAUvsB,MAClE0C,OAAQtC,KAAKsC,UAGd,CACHsqB,EAER,G,gGCzHJ,MAAMC,EAAqB,uBACrBC,EAAkB,uBAClBC,EAAY,KAAKptB,OAAO,CAC1BC,KAAM,YACN,UAAAC,GACI,MAAO,CACHmtB,oBAAqB,YACrBC,mBAAmB,EACnBC,iBAAiB,EACjBhsB,eAAgB,CAAC,EAEzB,EACAC,QAAS,QACTgsB,MAAO,GACP/rB,MAAO,QACPgsB,MAAM,EACN/rB,UAAU,EACV,aAAAC,GACI,MAAO,CACH+rB,SAAU,CACNltB,QAAS,KACTC,UAAWC,IACP,IAAImF,EACJ,MAAM,oBAAEwnB,GAAwBhtB,KAAKV,QAK/B+tB,EAJa,KAA2C,QAApC7nB,EAAKnF,EAAQitB,yBAAsC,IAAP9nB,OAAgB,EAASA,EAAGic,YAAc,IAE3GzM,QAAO/P,GAAaA,EAAUsoB,WAAWP,KACzCvrB,KAAIwD,GAAaA,EAAU1E,QAAQysB,EAAqB,MAClC,GAC3B,OAAKK,GACM,IAEI,EAEnB7rB,UAAU,GAGtB,EACA,SAAApB,GACI,MAAO,CACH,CACIsB,IAAK,MACL8rB,mBAAoB,QAGhC,EACA,UAAAhtB,EAAW,KAAEoB,EAAI,eAAEV,IACf,MAAO,CACH,OACA,QAAgBlB,KAAKV,QAAQ4B,eAAgBA,GAC7C,CACI,OACA,CACI2X,MAAOjX,EAAKD,MAAM0rB,SACZrtB,KAAKV,QAAQ0tB,oBAAsBprB,EAAKD,MAAM0rB,SAC9C,MAEV,GAGZ,EACA,WAAA5sB,GACI,MAAO,CACHgtB,aAAcxtB,GAAc,EAAG8B,cACpBA,EAASC,QAAQhC,KAAKJ,KAAMK,GAEvCytB,gBAAiBztB,GAAc,EAAG8B,cACvBA,EAASG,WAAWlC,KAAKJ,KAAM,YAAaK,GAG/D,EACA,oBAAAkC,GACI,MAAO,CACH,YAAa,IAAMnC,KAAKsC,OAAOP,SAAS2rB,kBAExClR,UAAW,KACP,MAAM,MAAE9F,EAAK,QAAElD,GAAYxT,KAAKsC,OAAO4E,MAAMiM,UACvCwa,EAA4B,IAAhBna,EAAQjL,IAC1B,SAAKmO,GAASlD,EAAQ/N,OAAO/C,KAAK9C,OAASI,KAAKJ,WAG5C+tB,GAAcna,EAAQ/N,OAAOmoB,YAAYhgB,SAClC5N,KAAKsC,OAAOP,SAAS8rB,aAEpB,EAGhB9B,MAAO,EAAGzpB,aACN,IAAKtC,KAAKV,QAAQ2tB,kBACd,OAAO,EAEX,MAAM,MAAE/lB,GAAU5E,GACZ,UAAE6Q,GAAcjM,GAChB,MAAEoO,EAAK,MAAEoB,GAAUvD,EACzB,IAAKuD,GAASpB,EAAM7P,OAAO/C,OAAS1C,KAAK0C,KACrC,OAAO,EAEX,MAAMorB,EAAUxY,EAAM2S,eAAiB3S,EAAM7P,OAAOyK,SAAW,EACzD6d,EAAwBzY,EAAM7P,OAAOmoB,YAAYI,SAAS,QAChE,SAAKF,IAAYC,IAGVzrB,EACF3B,QACAstB,SAAQ,EAAGxX,SACZA,EAAGgO,OAAOnP,EAAM/M,IAAM,EAAG+M,EAAM/M,MACxB,KAEN2lB,WACArtB,KAAK,EAGdyb,UAAW,EAAGha,aACV,IAAKtC,KAAKV,QAAQ4tB,gBACd,OAAO,EAEX,MAAM,MAAEhmB,GAAU5E,GACZ,UAAE6Q,EAAS,IAAEU,GAAQ3M,GACrB,MAAEoO,EAAK,MAAEoB,GAAUvD,EACzB,IAAKuD,GAASpB,EAAM7P,OAAO/C,OAAS1C,KAAK0C,KACrC,OAAO,EAGX,KADgB4S,EAAM2S,eAAiB3S,EAAM7P,OAAOyK,SAAW,GAE3D,OAAO,EAEX,MAAMwD,EAAQ4B,EAAM5B,QACpB,QAAcrM,IAAVqM,EACA,OAAO,EAGX,OADkBG,EAAI9B,OAAO2B,IAItBpR,EAAOP,SAASmsB,UAAU,EAG7C,EACA,aAAA3rB,GACI,MAAO,EACH,QAAuB,CACnBC,KAAMqqB,EACNnqB,KAAM1C,KAAK0C,KACXC,cAAeyG,IAAS,CACpBikB,SAAUjkB,EAAM,QAGxB,QAAuB,CACnB5G,KAAMsqB,EACNpqB,KAAM1C,KAAK0C,KACXC,cAAeyG,IAAS,CACpBikB,SAAUjkB,EAAM,OAIhC,EACA,qBAAAlB,GACI,MAAO,CAGH,IAAI,KAAO,CACPC,IAAK,IAAI,KAAU,0BACnBC,MAAO,CACH+U,YAAa,CAAC7U,EAAME,KAChB,IAAKA,EAAM2lB,cACP,OAAO,EAGX,GAAInuB,KAAKsC,OAAOoF,SAAS1H,KAAK0C,KAAK9C,MAC/B,OAAO,EAEX,MAAM+D,EAAO6E,EAAM2lB,cAAcC,QAAQ,cACnCC,EAAS7lB,EAAM2lB,cAAcC,QAAQ,sBACrCE,EAAaD,EAAShY,KAAKkY,MAAMF,QAAUhnB,EAC3CgmB,EAA0B,OAAfiB,QAAsC,IAAfA,OAAwB,EAASA,EAAWE,KACpF,IAAK7qB,IAAS0pB,EACV,OAAO,EAEX,MAAM,GAAE5W,GAAOnO,EAAKpB,MAcpB,OAZAuP,EAAGgT,qBAAqBzpB,KAAK0C,KAAK/C,OAAO,CAAE0tB,cAE3C5W,EAAGM,aAAa,KAAc4B,KAAKlC,EAAG5C,IAAId,QAAQhH,KAAKC,IAAI,EAAGyK,EAAGtD,UAAUgC,KAAO,MAIlFsB,EAAGgY,WAAW9qB,EAAKpD,QAAQ,SAAU,OAIrCkW,EAAG4D,QAAQ,SAAS,GACpB/R,EAAKf,SAASkP,IACP,CAAI,KAK/B,G,oFCtMJ,MAAM9N,EAAa,mCACb+lB,EAAa,mCACbC,EAAO,KAAKhvB,OAAO,CACrBC,KAAM,OACN,UAAAC,GACI,MAAO,CACHqB,eAAgB,CAAC,EAEzB,EACA0tB,SAAU,IACVxB,MAAM,EACNyB,UAAU,EACV,SAAAzuB,GACI,MAAO,CACH,CAAEsB,IAAK,QAEf,EACA,UAAAlB,EAAW,eAAEU,IACT,MAAO,CAAC,QAAQ,QAAgBlB,KAAKV,QAAQ4B,eAAgBA,GAAiB,EAClF,EACA,WAAAT,GACI,MAAO,CACHquB,QAAS,IAAM,EAAG/sB,cACPA,EAASnB,QAAQZ,KAAKJ,MAEjCmvB,WAAY,IAAM,EAAGhtB,cACVA,EAAS2pB,WAAW1rB,KAAKJ,MAEpCovB,UAAW,IAAM,EAAGjtB,cACTA,EAAS6pB,UAAU5rB,KAAKJ,MAG3C,EACA,oBAAAuC,GACI,MAAO,CACH,QAAS,IAAMnC,KAAKsC,OAAOP,SAASgtB,aAE5C,EACA,aAAAxsB,GACI,MAAO,EACH,QAAc,CACVC,KAAMmG,EACNjG,KAAM1C,KAAK0C,OAGvB,EACA,aAAAmpB,GACI,MAAO,EACH,QAAc,CACVrpB,KAAMksB,EACNhsB,KAAM1C,KAAK0C,OAGvB,G,6ECpDJ,MAAMusB,E,SAAQ,GAAUtvB,OAAO,CAC3BC,KAAM,QACN,UAAAC,GACI,MAAO,CACHC,MAAO,CAAC,aAEhB,EACA,mBAAAC,GACI,MAAO,CACH,CACID,MAAOE,KAAKV,QAAQQ,MACpBG,WAAY,CACRwD,MAAO,CACHtD,QAAS,KACTC,UAAWC,IAAa,IAAImF,EAAI,OAAsC,QAA9BA,EAAKnF,EAAQC,MAAMmD,aAA0B,IAAP+B,OAAgB,EAASA,EAAGjF,QAAQ,SAAU,GAAG,EAC/HC,WAAYP,GACHA,EAAWwD,MAGT,CACHnD,MAAO,UAAUL,EAAWwD,SAHrB,CAAC,KAUpC,EACA,WAAAhD,GACI,MAAO,CACHyuB,SAAUzrB,GAAS,EAAG9C,WACXA,IACFC,QAAQ,YAAa,CAAE6C,UACvB5C,MAETsuB,WAAY,IAAM,EAAGxuB,WACVA,IACFC,QAAQ,YAAa,CAAE6C,MAAO,OAC9B1C,uBACAF,MAGjB,G,mEC3CJ,MAAMuuB,E,SAAW,GAAKzvB,OAAO,CACzBC,KAAM,MACNyvB,SAAS,EACTluB,QAAS,U,0GCQb,SAASmuB,EAAWhwB,EAAU,CAAC,GAC3B,OAAO,IAAI,KAAO,CACd,IAAAgJ,CAAKinB,GAAc,OAAO,IAAIC,EAAeD,EAAYjwB,EAAU,GAE3E,CACA,MAAMkwB,EACF,WAAA1hB,CAAYyhB,EAAYjwB,GACpB,IAAIkG,EACJxF,KAAKuvB,WAAaA,EAClBvvB,KAAKyvB,UAAY,KACjBzvB,KAAKK,QAAU,KACfL,KAAK0vB,SAAW,EAChB1vB,KAAKwJ,MAAiC,QAAxBhE,EAAKlG,EAAQkK,aAA0B,IAAPhE,EAAgBA,EAAK,EACnExF,KAAKyD,OAA0B,IAAlBnE,EAAQmE,WAAkB4D,EAAa/H,EAAQmE,OAAS,QACrEzD,KAAK6Y,MAAQvZ,EAAQuZ,MACrB7Y,KAAK2vB,SAAW,CAAC,WAAY,UAAW,OAAQ,aAAaluB,KAAI7B,IAC7D,IAAIqN,EAAWgE,IAAQjR,KAAKJ,GAAMqR,EAAE,EAEpC,OADAse,EAAWxQ,IAAI3U,iBAAiBxK,EAAMqN,GAC/B,CAAErN,OAAMqN,UAAS,GAEhC,CACA,OAAA2iB,GACI5vB,KAAK2vB,SAAS5I,SAAQ,EAAGnnB,OAAMqN,aAAcjN,KAAKuvB,WAAWxQ,IAAI1U,oBAAoBzK,EAAMqN,IAC/F,CACA,MAAA0S,CAAO4P,EAAYM,GACO,MAAlB7vB,KAAKyvB,WAAqBI,EAAUhc,KAAO0b,EAAWroB,MAAM2M,MACxD7T,KAAKyvB,UAAYF,EAAWroB,MAAM2M,IAAI1S,QAAQiU,KAC9CpV,KAAK8vB,UAAU,MAEf9vB,KAAK+vB,gBAEjB,CACA,SAAAD,CAAUvnB,GACFA,GAAOvI,KAAKyvB,YAEhBzvB,KAAKyvB,UAAYlnB,EACN,MAAPA,GACAvI,KAAKK,QAAQ2e,WAAWsB,YAAYtgB,KAAKK,SACzCL,KAAKK,QAAU,MAGfL,KAAK+vB,gBAEb,CACA,aAAAA,GACI,IAC0CzgB,EADtCsD,EAAO5S,KAAKuvB,WAAWroB,MAAM2M,IAAId,QAAQ/S,KAAKyvB,WAC9CO,GAAWpd,EAAKnN,OAAOwqB,cAC3B,GAAID,EAAS,CACT,IAAIhd,EAASJ,EAAKkB,WAAYJ,EAAQd,EAAKe,UAC3C,GAAIX,GAAUU,EAAO,CACjB,IAAI9R,EAAO5B,KAAKuvB,WAAWW,QAAQlwB,KAAKyvB,WAAazc,EAASA,EAAO9C,SAAW,IAChF,GAAItO,EAAM,CACN,IAAIuuB,EAAWvuB,EAAK2J,wBAChB2C,EAAM8E,EAASmd,EAAS7mB,OAAS6mB,EAASjiB,IAC1C8E,GAAUU,IACVxF,GAAOA,EAAMlO,KAAKuvB,WAAWW,QAAQlwB,KAAKyvB,WAAWlkB,wBAAwB2C,KAAO,GACxFoB,EAAO,CAAE9L,KAAM2sB,EAAS3sB,KAAM+F,MAAO4mB,EAAS5mB,MAAO2E,IAAKA,EAAMlO,KAAKwJ,MAAQ,EAAGF,OAAQ4E,EAAMlO,KAAKwJ,MAAQ,EAC/G,CACJ,CACJ,CACA,IAAK8F,EAAM,CACP,IAAI8gB,EAASpwB,KAAKuvB,WAAWc,YAAYrwB,KAAKyvB,WAC9CngB,EAAO,CAAE9L,KAAM4sB,EAAO5sB,KAAOxD,KAAKwJ,MAAQ,EAAGD,MAAO6mB,EAAO5sB,KAAOxD,KAAKwJ,MAAQ,EAAG0E,IAAKkiB,EAAOliB,IAAK5E,OAAQ8mB,EAAO9mB,OACtH,CACA,IAYIgnB,EAAYC,EAZZ9qB,EAASzF,KAAKuvB,WAAWxQ,IAAIyR,aAajC,GAZKxwB,KAAKK,UACNL,KAAKK,QAAUoF,EAAO8Z,YAAYjZ,SAASgZ,cAAc,QACrDtf,KAAK6Y,QACL7Y,KAAKK,QAAQ4E,UAAYjF,KAAK6Y,OAClC7Y,KAAKK,QAAQC,MAAMmwB,QAAU,yDACzBzwB,KAAKyD,QACLzD,KAAKK,QAAQC,MAAMowB,gBAAkB1wB,KAAKyD,QAGlDzD,KAAKK,QAAQohB,UAAUkP,OAAO,+BAAgCX,GAC9DhwB,KAAKK,QAAQohB,UAAUkP,OAAO,iCAAkCX,IAE3DvqB,GAAUA,GAAUa,SAASsqB,MAA6C,UAArCC,iBAAiBprB,GAAQlC,SAC/D+sB,GAAcQ,YACdP,GAAaQ,gBAEZ,CACD,IAAIzhB,EAAO7J,EAAO8F,wBAClB+kB,EAAahhB,EAAK9L,KAAOiC,EAAOurB,WAChCT,EAAYjhB,EAAKpB,IAAMzI,EAAOwrB,SAClC,CACAjxB,KAAKK,QAAQC,MAAMkD,KAAQ8L,EAAK9L,KAAO8sB,EAAc,KACrDtwB,KAAKK,QAAQC,MAAM4N,IAAOoB,EAAKpB,IAAMqiB,EAAa,KAClDvwB,KAAKK,QAAQC,MAAMkJ,MAAS8F,EAAK/F,MAAQ+F,EAAK9L,KAAQ,KACtDxD,KAAKK,QAAQC,MAAMmJ,OAAU6F,EAAKhG,OAASgG,EAAKpB,IAAO,IAC3D,CACA,eAAAgjB,CAAgBxB,GACZyB,aAAanxB,KAAK0vB,SAClB1vB,KAAK0vB,QAAU7pB,YAAW,IAAM7F,KAAK8vB,UAAU,OAAOJ,EAC1D,CACA,QAAA0B,CAAS5oB,GACL,IAAKxI,KAAKuvB,WAAW8B,SACjB,OACJ,IAAI9oB,EAAMvI,KAAKuvB,WAAWpQ,YAAY,CAAE3b,KAAMgF,EAAMiD,QAASyC,IAAK1F,EAAMoD,UACpEhK,EAAO2G,GAAOA,EAAI+oB,QAAU,GAAKtxB,KAAKuvB,WAAWroB,MAAM2M,IAAI9B,OAAOxJ,EAAI+oB,QACtEC,EAAoB3vB,GAAQA,EAAKc,KAAK0N,KAAKmhB,kBAC3CC,EAAuC,mBAArBD,EAAkCA,EAAkBvxB,KAAKuvB,WAAYhnB,EAAKC,GAAS+oB,EACzG,GAAIhpB,IAAQipB,EAAU,CAClB,IAAI/oB,EAASF,EAAIA,IACjB,GAAIvI,KAAKuvB,WAAW/N,UAAYxhB,KAAKuvB,WAAW/N,SAASpb,MAAO,CAC5D,IAAIqrB,GAAQ,QAAUzxB,KAAKuvB,WAAWroB,MAAM2M,IAAKpL,EAAQzI,KAAKuvB,WAAW/N,SAASpb,OACrE,MAATqrB,IACAhpB,EAASgpB,EACjB,CACAzxB,KAAK8vB,UAAUrnB,GACfzI,KAAKkxB,gBAAgB,IACzB,CACJ,CACA,OAAAQ,GACI1xB,KAAKkxB,gBAAgB,GACzB,CACA,IAAAS,GACI3xB,KAAKkxB,gBAAgB,GACzB,CACA,SAAAU,CAAUppB,GACFA,EAAMC,QAAUzI,KAAKuvB,WAAWxQ,KAAQ/e,KAAKuvB,WAAWxQ,IAAIvY,SAASgC,EAAMqpB,gBAC3E7xB,KAAK8vB,UAAU,KACvB,ECpIJ,MAAMgC,EAAa,KAAUnyB,OAAO,CAChCC,KAAM,aACN,UAAAC,GACI,MAAO,CACH4D,MAAO,eACP+F,MAAO,EACPqP,WAAOxR,EAEf,EACA,qBAAAa,GACI,MAAO,CACHonB,EAAWtvB,KAAKV,SAExB,G,6ECbJ,MAAMyyB,E,SAAa,GAAUpyB,OAAO,CAChCC,KAAM,aACN,UAAAC,GACI,MAAO,CACHC,MAAO,CAAC,aAEhB,EACA,mBAAAC,GACI,MAAO,CACH,CACID,MAAOE,KAAKV,QAAQQ,MACpBG,WAAY,CACR+xB,WAAY,CACR7xB,QAAS,KACTC,UAAWC,IAAa,IAAImF,EAAI,OAA2C,QAAnCA,EAAKnF,EAAQC,MAAM0xB,kBAA+B,IAAPxsB,OAAgB,EAASA,EAAGjF,QAAQ,SAAU,GAAG,EACpIC,WAAYP,GACHA,EAAW+xB,WAGT,CACH1xB,MAAO,gBAAgBL,EAAW+xB,cAH3B,CAAC,KAUpC,EACA,WAAAvxB,GACI,MAAO,CACHwxB,cAAeD,GAAc,EAAGrxB,WACrBA,IACFC,QAAQ,YAAa,CAAEoxB,eACvBnxB,MAETqxB,gBAAiB,IAAM,EAAGvxB,WACfA,IACFC,QAAQ,YAAa,CAAEoxB,WAAY,OACnCjxB,uBACAF,MAGjB,G,6HCpCJ,MAAMsxB,UAAkB,KAIpB,WAAArkB,CAAY8E,GACRyC,MAAMzC,EAAMA,EAChB,CACA,GAAAnR,CAAIoS,EAAK2B,GACL,IAAI5C,EAAOiB,EAAId,QAAQyC,EAAQ/T,IAAIzB,KAAKiU,OACxC,OAAOke,EAAUC,MAAMxf,GAAQ,IAAIuf,EAAUvf,GAAQ,KAAU+F,KAAK/F,EACxE,CACA,OAAAzR,GAAY,OAAO,KAAMuV,KAAO,CAChC,EAAAmB,CAAGC,GACC,OAAOA,aAAiBqa,GAAara,EAAM7D,MAAQjU,KAAKiU,IAC5D,CACA,MAAA8D,GACI,MAAO,CAAErV,KAAM,YAAa6F,IAAKvI,KAAKiU,KAC1C,CAIA,eAAOgE,CAASpE,EAAKqE,GACjB,GAAuB,iBAAZA,EAAK3P,IACZ,MAAM,IAAI6F,WAAW,wCACzB,OAAO,IAAI+jB,EAAUte,EAAId,QAAQmF,EAAK3P,KAC1C,CAIA,WAAA8P,GAAgB,OAAO,IAAIga,EAAYryB,KAAKgY,OAAS,CAIrD,YAAOoa,CAAMxf,GACT,IAAInN,EAASmN,EAAKnN,OAClB,GAAIA,EAAO4f,cAmEnB,SAAsBzS,GAClB,IAAK,IAAIC,EAAID,EAAKE,MAAOD,GAAK,EAAGA,IAAK,CAClC,IAAIlD,EAAQiD,EAAKjD,MAAMkD,GAAIpN,EAASmN,EAAKhR,KAAKiR,GAE9C,GAAa,GAATlD,EAMJ,IAAK,IAAIqD,EAASvN,EAAOwK,MAAMN,EAAQ,IAAKqD,EAASA,EAAOe,UAAW,CACnE,GAA0B,GAArBf,EAAOzC,aAAoByC,EAAOid,eAAkBjd,EAAOsf,QAAUtf,EAAOtQ,KAAK0N,KAAKkZ,UACvF,OAAO,EACX,GAAItW,EAAOid,cACP,OAAO,CACf,MAVI,GAAIxqB,EAAO/C,KAAK0N,KAAKkZ,UACjB,OAAO,CAUnB,CAEA,OAAO,CACX,CAtFmCiJ,CAAa3f,KAuFhD,SAAqBA,GACjB,IAAK,IAAIC,EAAID,EAAKE,MAAOD,GAAK,EAAGA,IAAK,CAClC,IAAIlD,EAAQiD,EAAK+L,WAAW9L,GAAIpN,EAASmN,EAAKhR,KAAKiR,GACnD,GAAIlD,GAASlK,EAAO8K,WAKpB,IAAK,IAAImD,EAAQjO,EAAOwK,MAAMN,IAAS+D,EAAQA,EAAME,WAAY,CAC7D,GAAyB,GAApBF,EAAMnD,aAAoBmD,EAAMuc,eAAkBvc,EAAM4e,QAAU5e,EAAMhR,KAAK0N,KAAKkZ,UACnF,OAAO,EACX,GAAI5V,EAAMuc,cACN,OAAO,CACf,MATI,GAAIxqB,EAAO/C,KAAK0N,KAAKkZ,UACjB,OAAO,CASnB,CACA,OAAO,CACX,CAvG0DkJ,CAAY5f,GAC1D,OAAO,EACX,IAAI6f,EAAWhtB,EAAO/C,KAAK0N,KAAKsiB,eAChC,GAAgB,MAAZD,EACA,OAAOA,EACX,IAAIE,EAAQltB,EAAOmtB,eAAehgB,EAAKjD,SAASkjB,YAChD,OAAOF,GAASA,EAAMtN,WAC1B,CAIA,wBAAOyN,CAAkBlgB,EAAMpE,EAAKukB,GAAW,GAC3CC,EAAQ,OAAS,CACb,IAAKD,GAAYZ,EAAUC,MAAMxf,GAC7B,OAAOA,EACX,IAAIrK,EAAMqK,EAAKrK,IAAK0qB,EAAO,KAE3B,IAAK,IAAIpgB,EAAID,EAAKE,OAAQD,IAAK,CAC3B,IAAIpN,EAASmN,EAAKhR,KAAKiR,GACvB,GAAIrE,EAAM,EAAIoE,EAAK+L,WAAW9L,GAAKpN,EAAO8K,WAAaqC,EAAKjD,MAAMkD,GAAK,EAAG,CACtEogB,EAAOxtB,EAAOwK,MAAMzB,EAAM,EAAIoE,EAAK+L,WAAW9L,GAAKD,EAAKjD,MAAMkD,GAAK,GACnE,KACJ,CACK,GAAS,GAALA,EACL,OAAO,KAEXtK,GAAOiG,EACP,IAAI0kB,EAAOtgB,EAAKiB,IAAId,QAAQxK,GAC5B,GAAI4pB,EAAUC,MAAMc,GAChB,OAAOA,CACf,CAEA,OAAS,CACL,IAAI5B,EAAS9iB,EAAM,EAAIykB,EAAKrf,WAAaqf,EAAKlf,UAC9C,IAAKud,EAAQ,CACT,GAAI2B,EAAKX,SAAWW,EAAKE,SAAW,KAAcC,aAAaH,GAAO,CAClErgB,EAAOA,EAAKiB,IAAId,QAAQxK,EAAM0qB,EAAK/iB,SAAW1B,GAC9CukB,GAAW,EACX,SAASC,CACb,CACA,KACJ,CACAC,EAAO3B,EACP/oB,GAAOiG,EACP,IAAI0kB,EAAOtgB,EAAKiB,IAAId,QAAQxK,GAC5B,GAAI4pB,EAAUC,MAAMc,GAChB,OAAOA,CACf,CACA,OAAO,IACX,CACJ,EAEJf,EAAU5Z,UAAUC,SAAU,EAC9B2Z,EAAUtb,SAAWsb,EAAUW,kBAC/B,KAAUra,OAAO,YAAa0Z,GAC9B,MAAME,EACF,WAAAvkB,CAAYvF,GACRvI,KAAKuI,IAAMA,CACf,CACA,GAAA9G,CAAI+T,GACA,OAAO,IAAI6c,EAAY7c,EAAQ/T,IAAIzB,KAAKuI,KAC5C,CACA,OAAAwK,CAAQc,GACJ,IAAIjB,EAAOiB,EAAId,QAAQ/S,KAAKuI,KAC5B,OAAO4pB,EAAUC,MAAMxf,GAAQ,IAAIuf,EAAUvf,GAAQ,KAAU+F,KAAK/F,EACxE,EA8DJ,MAAMqJ,GAAgB,OAAe,CACjC,UAAaE,EAAM,SAAU,GAC7B,WAAcA,EAAM,QAAS,GAC7B,QAAWA,EAAM,QAAS,GAC1B,UAAaA,EAAM,OAAQ,KAE/B,SAASA,EAAM5N,EAAMC,GACjB,MAAMqQ,EAAiB,QAARtQ,EAAkBC,EAAM,EAAI,OAAS,KAASA,EAAM,EAAI,QAAU,OACjF,OAAO,SAAUtH,EAAOK,EAAUe,GAC9B,IAAI+K,EAAMnM,EAAMiM,UACZkgB,EAAS7kB,EAAM,EAAI6E,EAAIkC,IAAMlC,EAAIiC,MAAOyd,EAAW1f,EAAIqD,MAC3D,GAAIrD,aAAe,KAAe,CAC9B,IAAK/K,EAAKwW,eAAeD,IAA2B,GAAhBwU,EAAOvgB,MACvC,OAAO,EACXigB,GAAW,EACXM,EAASnsB,EAAM2M,IAAId,QAAQvE,EAAM,EAAI6kB,EAAO3f,QAAU2f,EAAOrgB,SACjE,CACA,IAAIsgB,EAASnB,EAAUW,kBAAkBO,EAAQ7kB,EAAKukB,GACtD,QAAKO,IAED/rB,GACAA,EAASL,EAAMuP,GAAGM,aAAa,IAAIob,EAAUmB,MAC1C,EACX,CACJ,CACA,SAASjrB,EAAYC,EAAMC,EAAKC,GAC5B,IAAKF,IAASA,EAAK+oB,SACf,OAAO,EACX,IAAIze,EAAOtK,EAAKpB,MAAM2M,IAAId,QAAQxK,GAClC,IAAK4pB,EAAUC,MAAMxf,GACjB,OAAO,EACX,IAAI2gB,EAAWjrB,EAAK6W,YAAY,CAAE3b,KAAMgF,EAAMiD,QAASyC,IAAK1F,EAAMoD,UAClE,QAAI2nB,GAAYA,EAASjC,QAAU,GAAK,KAAc8B,aAAa9qB,EAAKpB,MAAM2M,IAAI9B,OAAOwhB,EAASjC,YAElGhpB,EAAKf,SAASe,EAAKpB,MAAMuP,GAAGM,aAAa,IAAIob,EAAUvf,MAChD,EACX,CAKA,SAAS4gB,EAAYlrB,EAAME,GACvB,GAAuB,yBAAnBA,EAAMirB,aAA0CnrB,EAAKpB,MAAMiM,qBAAqBgf,GAChF,OAAO,EACX,IAAI,MAAE7c,GAAUhN,EAAKpB,MAAMiM,UACvBiH,EAAS9E,EAAM7P,OAAOmtB,eAAetd,EAAM3F,SAAS+jB,aAAaprB,EAAKpB,MAAMvC,OAAO6N,MAAM7O,MAC7F,IAAKyW,EACD,OAAO,EACX,IAAIqD,EAAO,KAAS/G,MACpB,IAAK,IAAI/I,EAAIyM,EAAOxM,OAAS,EAAGD,GAAK,EAAGA,IACpC8P,EAAO,KAAStI,KAAKiF,EAAOzM,GAAGyI,cAAc,KAAMqH,IACvD,IAAIhH,EAAKnO,EAAKpB,MAAMuP,GAAGlW,QAAQ+U,EAAM/M,IAAK+M,EAAM/M,IAAK,IAAI,KAAMkV,EAAM,EAAG,IAGxE,OAFAhH,EAAGM,aAAa,KAAc4B,KAAKlC,EAAG5C,IAAId,QAAQuC,EAAM/M,IAAM,KAC9DD,EAAKf,SAASkP,IACP,CACX,CACA,SAASkd,EAAczsB,GACnB,KAAMA,EAAMiM,qBAAqBgf,GAC7B,OAAO,KACX,IAAIvwB,EAAO0E,SAASgZ,cAAc,OAElC,OADA1d,EAAKqD,UAAY,wBACV,KAActF,OAAOuH,EAAM2M,IAAK,CAAC,KAAW2P,OAAOtc,EAAMiM,UAAUc,KAAMrS,EAAM,CAAEuG,IAAK,eACjG,CCtOA,MAAMyrB,EAAY,KAAUj0B,OAAO,CAC/BC,KAAM,YACN,qBAAAsI,GACI,MAAO,CDyJJ,IAAI,KAAO,CACdE,MAAO,CACHmb,YAAaoQ,EACb,sBAAAlM,CAAuBoM,EAAOrgB,EAASN,GACnC,OAAOM,EAAQjL,KAAO2K,EAAM3K,KAAO4pB,EAAUC,MAAMlf,GAAS,IAAIif,EAAUjf,GAAS,IACvF,EACA7K,cACA4T,gBACAqF,gBAAiB,CAAEkS,YAAaA,MC9JxC,EACA,gBAAA/I,CAAiBnmB,GACb,IAAIkB,EACJ,MAAMklB,EAAU,CACZ9qB,KAAM0E,EAAU1E,KAChBN,QAASgF,EAAUhF,QACnByG,QAASzB,EAAUyB,SAEvB,MAAO,CACH2sB,eAAiG,QAAhFltB,GAAK,SAAa,QAAkBlB,EAAW,iBAAkBomB,WAA8B,IAAPllB,EAAgBA,EAAK,KAEtI,G,mFClBJ,MAAMsuB,EAAY,KAAKn0B,OAAO,CAC1BC,KAAM,YACN,UAAAC,GACI,MAAO,CACH2sB,WAAW,EACXtrB,eAAgB,CAAC,EAEzB,EACA0F,QAAQ,EACRxF,MAAO,SACP2yB,YAAY,EACZ,SAAA3zB,GACI,MAAO,CACH,CAAEsB,IAAK,MAEf,EACA,UAAAlB,EAAW,eAAEU,IACT,MAAO,CAAC,MAAM,QAAgBlB,KAAKV,QAAQ4B,eAAgBA,GAC/D,EACA,UAAA8yB,GACI,MAAO,IACX,EACA,WAAAvzB,GACI,MAAO,CACHwzB,aAAc,IAAM,EAAGlyB,WAAUpB,QAAOuG,QAAO5E,YACpCP,EAASiY,MAAM,CAClB,IAAMjY,EAASmsB,WACf,IAAMnsB,EAASksB,SAAQ,KACnB,MAAM,UAAE9a,EAAS,YAAE+gB,GAAgBhtB,EACnC,GAAIiM,EAAUmC,MAAM7P,OAAO/C,KAAK0N,KAAKkZ,UACjC,OAAO,EAEX,MAAM,UAAEkD,GAAcxsB,KAAKV,SACrB,gBAAE60B,GAAoB7xB,EAAO8xB,iBAC7BjH,EAAQ+G,GACN/gB,EAAUoC,IAAI0S,cAAgB9U,EAAUmC,MAAM6X,QACtD,OAAOxsB,IACFwI,cAAc,CAAEzG,KAAM1C,KAAKJ,OAC3BquB,SAAQ,EAAGxX,KAAIlP,eAChB,GAAIA,GAAY4lB,GAASX,EAAW,CAChC,MAAM6H,EAAgBlH,EACjBnY,QAAOsf,GAAQH,EAAgBtyB,SAASyyB,EAAK5xB,KAAK9C,QACvD6W,EAAG8d,YAAYF,EACnB,CACA,OAAO,CAAI,IAEVxzB,KAAK,MAK9B,EACA,oBAAAsB,GACI,MAAO,CACH,YAAa,IAAMnC,KAAKsC,OAAOP,SAASkyB,eACxC,cAAe,IAAMj0B,KAAKsC,OAAOP,SAASkyB,eAElD,G,qFCzDJ,MAAMtrB,EAAa,sCACb+lB,EAAa,sCACb8F,EAAY,KAAK70B,OAAO,CAC1BC,KAAM,YACN,UAAAC,GACI,MAAO,CACH40B,YAAY,EACZvzB,eAAgB,CAAC,EAEzB,EACA,aAAAI,GACI,OAAKtB,KAAKV,QAAQm1B,WAGX,CACHhxB,MAAO,CACHtD,QAAS,KACTC,UAAWC,GAAWA,EAAQuM,aAAa,eAAiBvM,EAAQC,MAAMowB,gBAC1ElwB,WAAYP,GACHA,EAAWwD,MAGT,CACH,aAAcxD,EAAWwD,MACzBnD,MAAO,qBAAqBL,EAAWwD,yBAJhC,CAAC,IARb,CAAC,CAiBhB,EACA,SAAArD,GACI,MAAO,CACH,CACIsB,IAAK,QAGjB,EACA,UAAAlB,EAAW,eAAEU,IACT,MAAO,CAAC,QAAQ,QAAgBlB,KAAKV,QAAQ4B,eAAgBA,GAAiB,EAClF,EACA,WAAAT,GACI,MAAO,CACHi0B,aAAcz0B,GAAc,EAAG8B,cACpBA,EAASnB,QAAQZ,KAAKJ,KAAMK,GAEvC00B,gBAAiB10B,GAAc,EAAG8B,cACvBA,EAAS2pB,WAAW1rB,KAAKJ,KAAMK,GAE1C20B,eAAgB,IAAM,EAAG7yB,cACdA,EAAS6pB,UAAU5rB,KAAKJ,MAG3C,EACA,oBAAAuC,GACI,MAAO,CACH,cAAe,IAAMnC,KAAKsC,OAAOP,SAAS4yB,kBAElD,EACA,aAAApyB,GACI,MAAO,EACH,QAAc,CACVC,KAAMmG,EACNjG,KAAM1C,KAAK0C,OAGvB,EACA,aAAAmpB,GACI,MAAO,EACH,QAAc,CACVrpB,KAAMksB,EACNhsB,KAAM1C,KAAK0C,OAGvB,G,oFC3EAmyB,EAAiB,IAKjBC,EAAe,WAA0B,EAE7CA,EAAavc,UAAUuC,OAAS,SAAiBhD,GAC/C,OAAKA,EAAMlK,QACXkK,EAAQgd,EAAa3f,KAAK2C,IAEjB9X,KAAK4N,QAAUkK,GACrBA,EAAMlK,OAASinB,GAAkB70B,KAAK+0B,WAAWjd,IACjD9X,KAAK4N,OAASinB,GAAkB/c,EAAMkd,YAAYh1B,OACnDA,KAAKi1B,YAAYnd,IANS9X,IAO9B,EAIA80B,EAAavc,UAAU2c,QAAU,SAAkBpd,GACjD,OAAKA,EAAMlK,OACJknB,EAAa3f,KAAK2C,GAAOgD,OAAO9a,MADXA,IAE9B,EAEA80B,EAAavc,UAAU0c,YAAc,SAAsBnd,GACzD,OAAO,IAAIqd,EAAOn1B,KAAM8X,EAC1B,EAIAgd,EAAavc,UAAUnS,MAAQ,SAAgB+O,EAAM2B,GAInD,YAHgB,IAAT3B,IAAkBA,EAAO,QAClB,IAAP2B,IAAgBA,EAAK9W,KAAK4N,QAE7BuH,GAAQ2B,EAAage,EAAape,MAC/B1W,KAAKo1B,WAAWrpB,KAAKC,IAAI,EAAGmJ,GAAOpJ,KAAKqD,IAAIpP,KAAK4N,OAAQkJ,GAClE,EAIAge,EAAavc,UAAUjL,IAAM,SAAcK,GACzC,KAAIA,EAAI,GAAKA,GAAK3N,KAAK4N,QACvB,OAAO5N,KAAKq1B,SAAS1nB,EACvB,EAOAmnB,EAAavc,UAAUwO,QAAU,SAAkB7P,EAAG/B,EAAM2B,QAC1C,IAAT3B,IAAkBA,EAAO,QAClB,IAAP2B,IAAgBA,EAAK9W,KAAK4N,QAE7BuH,GAAQ2B,EACR9W,KAAKs1B,aAAape,EAAG/B,EAAM2B,EAAI,GAE/B9W,KAAKu1B,qBAAqBre,EAAG/B,EAAM2B,EAAI,EAC7C,EAKAge,EAAavc,UAAU9W,IAAM,SAAcyV,EAAG/B,EAAM2B,QAClC,IAAT3B,IAAkBA,EAAO,QAClB,IAAP2B,IAAgBA,EAAK9W,KAAK4N,QAEjC,IAAI2B,EAAS,GAEb,OADAvP,KAAK+mB,SAAQ,SAAUyO,EAAK7nB,GAAK,OAAO4B,EAAOK,KAAKsH,EAAEse,EAAK7nB,GAAK,GAAGwH,EAAM2B,GAClEvH,CACT,EAKAulB,EAAa3f,KAAO,SAAesgB,GACjC,OAAIA,aAAkBX,EAAuBW,EACtCA,GAAUA,EAAO7nB,OAAS,IAAI8nB,EAAKD,GAAUX,EAAape,KACnE,EAEA,IAAIgf,EAAqB,SAAUZ,GACjC,SAASY,EAAKD,GACZX,EAAapvB,KAAK1F,MAClBA,KAAKy1B,OAASA,CAChB,CAEKX,IAAeY,EAAKC,UAAYb,GACrCY,EAAKnd,UAAYuQ,OAAOnpB,OAAQm1B,GAAgBA,EAAavc,WAC7Dmd,EAAKnd,UAAUzK,YAAc4nB,EAE7B,IAAIE,EAAqB,CAAEhoB,OAAQ,CAAEioB,cAAc,GAAO/iB,MAAO,CAAE+iB,cAAc,IAyCjF,OAvCAH,EAAKnd,UAAUud,QAAU,WACvB,OAAO91B,KAAKy1B,MACd,EAEAC,EAAKnd,UAAU6c,WAAa,SAAqBjgB,EAAM2B,GACrD,OAAY,GAAR3B,GAAa2B,GAAM9W,KAAK4N,OAAiB5N,KACtC,IAAI01B,EAAK11B,KAAKy1B,OAAOrvB,MAAM+O,EAAM2B,GAC1C,EAEA4e,EAAKnd,UAAU8c,SAAW,SAAmB1nB,GAC3C,OAAO3N,KAAKy1B,OAAO9nB,EACrB,EAEA+nB,EAAKnd,UAAU+c,aAAe,SAAuBpe,EAAG/B,EAAM2B,EAAIxF,GAChE,IAAK,IAAI3D,EAAIwH,EAAMxH,EAAImJ,EAAInJ,IACvB,IAAqC,IAAjCuJ,EAAElX,KAAKy1B,OAAO9nB,GAAI2D,EAAQ3D,GAAgB,OAAO,CAC3D,EAEA+nB,EAAKnd,UAAUgd,qBAAuB,SAA+Bre,EAAG/B,EAAM2B,EAAIxF,GAChF,IAAK,IAAI3D,EAAIwH,EAAO,EAAGxH,GAAKmJ,EAAInJ,IAC5B,IAAqC,IAAjCuJ,EAAElX,KAAKy1B,OAAO9nB,GAAI2D,EAAQ3D,GAAgB,OAAO,CAC3D,EAEA+nB,EAAKnd,UAAUwc,WAAa,SAAqBjd,GAC/C,GAAI9X,KAAK4N,OAASkK,EAAMlK,QAAUinB,EAC9B,OAAO,IAAIa,EAAK11B,KAAKy1B,OAAOM,OAAOje,EAAMge,WAC/C,EAEAJ,EAAKnd,UAAUyc,YAAc,SAAsBld,GACjD,GAAI9X,KAAK4N,OAASkK,EAAMlK,QAAUinB,EAC9B,OAAO,IAAIa,EAAK5d,EAAMge,UAAUC,OAAO/1B,KAAKy1B,QAClD,EAEAG,EAAmBhoB,OAAON,IAAM,WAAc,OAAOtN,KAAKy1B,OAAO7nB,MAAO,EAExEgoB,EAAmB9iB,MAAMxF,IAAM,WAAc,OAAO,CAAE,EAEtDwb,OAAOkN,iBAAkBN,EAAKnd,UAAWqd,GAElCF,CACT,CApDwB,CAoDtBZ,GAIFA,EAAape,MAAQ,IAAIgf,EAAK,IAE9B,IAAIP,EAAuB,SAAUL,GACnC,SAASK,EAAO3xB,EAAM+F,GACpBurB,EAAapvB,KAAK1F,MAClBA,KAAKwD,KAAOA,EACZxD,KAAKuJ,MAAQA,EACbvJ,KAAK4N,OAASpK,EAAKoK,OAASrE,EAAMqE,OAClC5N,KAAK8S,MAAQ/G,KAAKC,IAAIxI,EAAKsP,MAAOvJ,EAAMuJ,OAAS,CACnD,CA0DA,OAxDKgiB,IAAeK,EAAOQ,UAAYb,GACvCK,EAAO5c,UAAYuQ,OAAOnpB,OAAQm1B,GAAgBA,EAAavc,WAC/D4c,EAAO5c,UAAUzK,YAAcqnB,EAE/BA,EAAO5c,UAAUud,QAAU,WACzB,OAAO91B,KAAKwD,KAAKsyB,UAAUC,OAAO/1B,KAAKuJ,MAAMusB,UAC/C,EAEAX,EAAO5c,UAAU8c,SAAW,SAAmB1nB,GAC7C,OAAOA,EAAI3N,KAAKwD,KAAKoK,OAAS5N,KAAKwD,KAAK8J,IAAIK,GAAK3N,KAAKuJ,MAAM+D,IAAIK,EAAI3N,KAAKwD,KAAKoK,OAChF,EAEAunB,EAAO5c,UAAU+c,aAAe,SAAuBpe,EAAG/B,EAAM2B,EAAIxF,GAClE,IAAI2kB,EAAUj2B,KAAKwD,KAAKoK,OACxB,QAAIuH,EAAO8gB,IAC2D,IAAlEj2B,KAAKwD,KAAK8xB,aAAape,EAAG/B,EAAMpJ,KAAKqD,IAAI0H,EAAImf,GAAU3kB,QAEvDwF,EAAKmf,IAC6G,IAAlHj2B,KAAKuJ,MAAM+rB,aAAape,EAAGnL,KAAKC,IAAImJ,EAAO8gB,EAAS,GAAIlqB,KAAKqD,IAAIpP,KAAK4N,OAAQkJ,GAAMmf,EAAS3kB,EAAQ2kB,UADzG,EAGF,EAEAd,EAAO5c,UAAUgd,qBAAuB,SAA+Bre,EAAG/B,EAAM2B,EAAIxF,GAClF,IAAI2kB,EAAUj2B,KAAKwD,KAAKoK,OACxB,QAAIuH,EAAO8gB,IACkG,IAAzGj2B,KAAKuJ,MAAMgsB,qBAAqBre,EAAG/B,EAAO8gB,EAASlqB,KAAKC,IAAI8K,EAAImf,GAAWA,EAAS3kB,EAAQ2kB,QAE5Fnf,EAAKmf,IACqE,IAA1Ej2B,KAAKwD,KAAK+xB,qBAAqBre,EAAGnL,KAAKqD,IAAI+F,EAAM8gB,GAAUnf,EAAIxF,UADnE,EAGF,EAEA6jB,EAAO5c,UAAU6c,WAAa,SAAqBjgB,EAAM2B,GACvD,GAAY,GAAR3B,GAAa2B,GAAM9W,KAAK4N,OAAU,OAAO5N,KAC7C,IAAIi2B,EAAUj2B,KAAKwD,KAAKoK,OACxB,OAAIkJ,GAAMmf,EAAkBj2B,KAAKwD,KAAK4C,MAAM+O,EAAM2B,GAC9C3B,GAAQ8gB,EAAkBj2B,KAAKuJ,MAAMnD,MAAM+O,EAAO8gB,EAASnf,EAAKmf,GAC7Dj2B,KAAKwD,KAAK4C,MAAM+O,EAAM8gB,GAASnb,OAAO9a,KAAKuJ,MAAMnD,MAAM,EAAG0Q,EAAKmf,GACxE,EAEAd,EAAO5c,UAAUwc,WAAa,SAAqBjd,GACjD,IAAIoe,EAAQl2B,KAAKuJ,MAAMwrB,WAAWjd,GAClC,GAAIoe,EAAS,OAAO,IAAIf,EAAOn1B,KAAKwD,KAAM0yB,EAC5C,EAEAf,EAAO5c,UAAUyc,YAAc,SAAsBld,GACnD,IAAIoe,EAAQl2B,KAAKwD,KAAKwxB,YAAYld,GAClC,GAAIoe,EAAS,OAAO,IAAIf,EAAOe,EAAOl2B,KAAKuJ,MAC7C,EAEA4rB,EAAO5c,UAAU0c,YAAc,SAAsBnd,GACnD,OAAI9X,KAAKwD,KAAKsP,OAAS/G,KAAKC,IAAIhM,KAAKuJ,MAAMuJ,MAAOgF,EAAMhF,OAAS,EACtD,IAAIqiB,EAAOn1B,KAAKwD,KAAM,IAAI2xB,EAAOn1B,KAAKuJ,MAAOuO,IACjD,IAAIqd,EAAOn1B,KAAM8X,EAC1B,EAEOqd,CACT,CAlE0B,CAkExBL,GAEF,I,sBCzLA,MAAMqB,EACF,WAAAroB,CAAYzL,EAAO+zB,GACfp2B,KAAKqC,MAAQA,EACbrC,KAAKo2B,WAAaA,CACtB,CAGA,QAAAC,CAASnvB,EAAOovB,GACZ,GAAuB,GAAnBt2B,KAAKo2B,WACL,OAAO,KACX,IAQIG,EAAO5f,EARPrC,EAAMtU,KAAKqC,MAAMuL,OACrB,MAAQ0G,IAAO,CAEX,GADWtU,KAAKqC,MAAMiL,IAAIgH,EAAM,GACvBnB,UAAW,GACdmB,EACF,KACJ,CACJ,CAEIgiB,IACAC,EAAQv2B,KAAKw2B,UAAUliB,EAAKtU,KAAKqC,MAAMuL,QACvC+I,EAAU4f,EAAM7a,KAAK9N,QAEzB,IACIuF,EAAWsjB,EADXryB,EAAY8C,EAAMuP,GAElBigB,EAAW,GAAIC,EAAY,GA+B/B,OA9BA32B,KAAKqC,MAAM0kB,SAAQ,CAAC6P,EAAMjpB,KACtB,IAAKipB,EAAKC,KAON,OANKN,IACDA,EAAQv2B,KAAKw2B,UAAUliB,EAAK3G,EAAI,GAChCgJ,EAAU4f,EAAM7a,KAAK9N,QAEzB+I,SACAggB,EAAU/mB,KAAKgnB,GAGnB,GAAIL,EAAO,CACPI,EAAU/mB,KAAK,IAAIknB,EAAKF,EAAKn1B,MAC7B,IAAgDA,EAA5Co1B,EAAOD,EAAKC,KAAKp1B,IAAI80B,EAAMnwB,MAAMuQ,IACjCkgB,GAAQzyB,EAAU2yB,UAAUF,GAAMhjB,MAClCpS,EAAM2C,EAAUoR,QAAQkG,KAAKtX,EAAUoR,QAAQkG,KAAK9N,OAAS,GAC7D8oB,EAAS9mB,KAAK,IAAIknB,EAAKr1B,OAAK4F,OAAWA,EAAWqvB,EAAS9oB,OAAS+oB,EAAU/oB,UAElF+I,IACIlV,GACA80B,EAAMS,UAAUv1B,EAAKkV,EAC7B,MAEIvS,EAAU2yB,UAAUH,EAAKC,MAE7B,OAAID,EAAKzjB,WACLA,EAAYojB,EAAQK,EAAKzjB,UAAU1R,IAAI80B,EAAMnwB,MAAMuQ,IAAYigB,EAAKzjB,UACpEsjB,EAAY,IAAIN,EAAOn2B,KAAKqC,MAAM+D,MAAM,EAAGkO,GAAKwG,OAAO6b,EAAUM,UAAUlB,OAAOW,IAAY12B,KAAKo2B,WAAa,IACzG,QAHX,CAIA,GACDp2B,KAAKqC,MAAMuL,OAAQ,GACf,CAAE6oB,UAAWA,EAAWryB,YAAW+O,UAAWA,EACzD,CAEA,YAAA+jB,CAAa9yB,EAAW+O,EAAWgkB,EAAab,GAC5C,IAAIc,EAAW,GAAIhB,EAAap2B,KAAKo2B,WACjCiB,EAAWr3B,KAAKqC,MAAOi1B,GAAYhB,GAAiBe,EAASzpB,OAASypB,EAAS/pB,IAAI+pB,EAASzpB,OAAS,GAAK,KAC9G,IAAK,IAAID,EAAI,EAAGA,EAAIvJ,EAAUwS,MAAMhJ,OAAQD,IAAK,CAC7C,IACiE4pB,EAD7DV,EAAOzyB,EAAUwS,MAAMjJ,GAAG6pB,OAAOpzB,EAAUqzB,KAAK9pB,IAChDipB,EAAO,IAAIE,EAAK1yB,EAAUoR,QAAQkG,KAAK/N,GAAIkpB,EAAM1jB,IACjDokB,EAASD,GAAYA,EAASI,MAAMd,MACpCA,EAAOW,EACH5pB,EACAypB,EAASO,MAETN,EAAWA,EAASjxB,MAAM,EAAGixB,EAASzpB,OAAS,IAEvDwpB,EAASxnB,KAAKgnB,GACVzjB,IACAijB,IACAjjB,OAAY9L,GAEXivB,IACDgB,EAAWV,EACnB,CACA,IAAIgB,EAAWxB,EAAae,EAAYrkB,MAKxC,OAJI8kB,EAAWC,IACXR,EAwGZ,SAAsBh1B,EAAOgP,GACzB,IAAIymB,EAOJ,OANAz1B,EAAM0kB,SAAQ,CAAC6P,EAAMjpB,KACjB,GAAIipB,EAAKzjB,WAAqB,GAAP9B,IAEnB,OADAymB,EAAWnqB,GACJ,CACX,IAEGtL,EAAM+D,MAAM0xB,EACvB,CAjHuBC,CAAaV,EAAUO,GAClCxB,GAAcwB,GAEX,IAAIzB,EAAOkB,EAASvc,OAAOsc,GAAWhB,EACjD,CACA,SAAAI,CAAUrhB,EAAM2B,GACZ,IAAI4E,EAAO,IAAI,KAMf,OALA1b,KAAKqC,MAAM0kB,SAAQ,CAAC6P,EAAMjpB,KACtB,IAAIqqB,EAAiC,MAArBpB,EAAKqB,cAAwBtqB,EAAIipB,EAAKqB,cAAgB9iB,EAChEuG,EAAKA,KAAK9N,OAASgpB,EAAKqB,kBAAe5wB,EAC7CqU,EAAKsb,UAAUJ,EAAKn1B,IAAKu2B,EAAU,GACpC7iB,EAAM2B,GACF4E,CACX,CACA,OAAAwc,CAAQC,GACJ,OAAuB,GAAnBn4B,KAAKo2B,WACEp2B,KACJ,IAAIm2B,EAAOn2B,KAAKqC,MAAMyY,OAAOqd,EAAM12B,KAAIA,GAAO,IAAIq1B,EAAKr1B,MAAQzB,KAAKo2B,WAC/E,CAKA,OAAAgC,CAAQC,EAAkBC,GACtB,IAAKt4B,KAAKo2B,WACN,OAAOp2B,KACX,IAAIu4B,EAAe,GAAIjnB,EAAQvF,KAAKC,IAAI,EAAGhM,KAAKqC,MAAMuL,OAAS0qB,GAC3D9iB,EAAU6iB,EAAiB7iB,QAC3BgjB,EAAWH,EAAiBzhB,MAAMhJ,OAClCwoB,EAAap2B,KAAKo2B,WACtBp2B,KAAKqC,MAAM0kB,SAAQ6P,IAAcA,EAAKzjB,WAClCijB,GAAY,GAAK9kB,GACrB,IAAImnB,EAAWH,EACft4B,KAAKqC,MAAM0kB,SAAQ6P,IACf,IAAIruB,EAAMiN,EAAQkjB,YAAYD,GAC9B,GAAW,MAAPlwB,EACA,OACJiwB,EAAWzsB,KAAKqD,IAAIopB,EAAUjwB,GAC9B,IAAI9G,EAAM+T,EAAQkG,KAAKnT,GACvB,GAAIquB,EAAKC,KAAM,CACX,IAAIA,EAAOwB,EAAiBzhB,MAAMrO,GAAKivB,OAAOa,EAAiBZ,KAAKlvB,IAChE4K,EAAYyjB,EAAKzjB,WAAayjB,EAAKzjB,UAAU1R,IAAI+T,EAAQpP,MAAMqyB,EAAW,EAAGlwB,IAC7E4K,GACAijB,IACJmC,EAAa3oB,KAAK,IAAIknB,EAAKr1B,EAAKo1B,EAAM1jB,GAC1C,MAEIolB,EAAa3oB,KAAK,IAAIknB,EAAKr1B,GAC/B,GACD6P,GACH,IAAIqnB,EAAU,GACd,IAAK,IAAIhrB,EAAI2qB,EAAc3qB,EAAI6qB,EAAU7qB,IACrCgrB,EAAQ/oB,KAAK,IAAIknB,EAAKthB,EAAQkG,KAAK/N,KACvC,IAAItL,EAAQrC,KAAKqC,MAAM+D,MAAM,EAAGkL,GAAOwJ,OAAO6d,GAAS7d,OAAOyd,GAC1DK,EAAS,IAAIzC,EAAO9zB,EAAO+zB,GAG/B,OAFIwC,EAAOC,iBA1IK,MA2IZD,EAASA,EAAOE,SAAS94B,KAAKqC,MAAMuL,OAAS2qB,EAAa3qB,SACvDgrB,CACX,CACA,cAAAC,GACI,IAAIE,EAAQ,EAGZ,OAFA/4B,KAAKqC,MAAM0kB,SAAQ6P,IAAeA,EAAKC,MACnCkC,GAAO,IACJA,CACX,CAOA,QAAAD,CAASE,EAAOh5B,KAAKqC,MAAMuL,QACvB,IAAI2oB,EAAQv2B,KAAKw2B,UAAU,EAAGwC,GAAOriB,EAAU4f,EAAM7a,KAAK9N,OACtDvL,EAAQ,GAAI42B,EAAS,EA2BzB,OA1BAj5B,KAAKqC,MAAM0kB,SAAQ,CAAC6P,EAAMjpB,KACtB,GAAIA,GAAKqrB,EACL32B,EAAMuN,KAAKgnB,GACPA,EAAKzjB,WACL8lB,SAEH,GAAIrC,EAAKC,KAAM,CAChB,IAAIA,EAAOD,EAAKC,KAAKp1B,IAAI80B,EAAMnwB,MAAMuQ,IAAWlV,EAAMo1B,GAAQA,EAAKqC,SAInE,GAHAviB,IACIlV,GACA80B,EAAMS,UAAUv1B,EAAKkV,GACrBkgB,EAAM,CACN,IAAI1jB,EAAYyjB,EAAKzjB,WAAayjB,EAAKzjB,UAAU1R,IAAI80B,EAAMnwB,MAAMuQ,IAC7DxD,GACA8lB,IACJ,IAAuD1B,EAAnD4B,EAAU,IAAIrC,EAAKr1B,EAAI+1B,SAAUX,EAAM1jB,GAAoB8G,EAAO5X,EAAMuL,OAAS,GACjF2pB,EAASl1B,EAAMuL,QAAUvL,EAAM4X,GAAMyd,MAAMyB,IAC3C92B,EAAM4X,GAAQsd,EAEdl1B,EAAMuN,KAAKupB,EACnB,CACJ,MACSvC,EAAKn1B,KACVkV,GACJ,GACD3W,KAAKqC,MAAMuL,OAAQ,GACf,IAAIuoB,EAAO,EAAahhB,KAAK9S,EAAM40B,WAAYgC,EAC1D,EAEJ9C,EAAOzf,MAAQ,IAAIyf,EAAO,EAAazf,MAAO,GAW9C,MAAMogB,EACF,WAAAhpB,CAEArM,EAEAo1B,EAIA1jB,EAGA8kB,GACIj4B,KAAKyB,IAAMA,EACXzB,KAAK62B,KAAOA,EACZ72B,KAAKmT,UAAYA,EACjBnT,KAAKi4B,aAAeA,CACxB,CACA,KAAAP,CAAM5f,GACF,GAAI9X,KAAK62B,MAAQ/e,EAAM+e,OAAS/e,EAAM3E,UAAW,CAC7C,IAAI0jB,EAAO/e,EAAM+e,KAAKa,MAAM13B,KAAK62B,MACjC,GAAIA,EACA,OAAO,IAAIC,EAAKD,EAAKqC,SAAS1B,SAAUX,EAAM72B,KAAKmT,UAC3D,CACJ,EAKJ,MAAMimB,EACF,WAAAtrB,CAAYurB,EAAMC,EAAQC,EAAYC,EAAUC,GAC5Cz5B,KAAKq5B,KAAOA,EACZr5B,KAAKs5B,OAASA,EACdt5B,KAAKu5B,WAAaA,EAClBv5B,KAAKw5B,SAAWA,EAChBx5B,KAAKy5B,gBAAkBA,CAC3B,EAEJ,MAAM5B,EAAiB,GAiDvB,SAAS6B,EAAUhe,GACf,IAAInM,EAAS,GACb,IAAK,IAAI5B,EAAI+N,EAAK9N,OAAS,EAAGD,GAAK,GAAsB,GAAjB4B,EAAO3B,OAAaD,IACxD+N,EAAK/N,GAAGoZ,SAAQ,CAAC4S,EAAOC,EAAKzkB,EAAM2B,IAAOvH,EAAOK,KAAKuF,EAAM2B,KAChE,OAAOvH,CACX,CACA,SAASsqB,EAAU3kB,EAAQM,GACvB,IAAKN,EACD,OAAO,KACX,IAAI3F,EAAS,GACb,IAAK,IAAI5B,EAAI,EAAGA,EAAIuH,EAAOtH,OAAQD,GAAK,EAAG,CACvC,IAAIwH,EAAOK,EAAQ/T,IAAIyT,EAAOvH,GAAI,GAAImJ,EAAKtB,EAAQ/T,IAAIyT,EAAOvH,EAAI,IAAK,GACnEwH,GAAQ2B,GACRvH,EAAOK,KAAKuF,EAAM2B,EAC1B,CACA,OAAOvH,CACX,CAcA,IAAIuqB,GAAsB,EAAOC,EAA6B,KAK9D,SAASC,EAAkB9yB,GACvB,IAAI+yB,EAAU/yB,EAAM+yB,QACpB,GAAIF,GAA8BE,EAAS,CACvCH,GAAsB,EACtBC,EAA6BE,EAC7B,IAAK,IAAItsB,EAAI,EAAGA,EAAIssB,EAAQrsB,OAAQD,IAChC,GAAIssB,EAAQtsB,GAAGyC,KAAK8pB,qBAAsB,CACtCJ,GAAsB,EACtB,KACJ,CACR,CACA,OAAOA,CACX,CASA,MAAMK,EAAa,IAAI,KAAU,WAC3BC,EAAkB,IAAI,KAAU,gBAUtC,SAAS,EAAQC,EAAS,CAAC,GAGvB,OAFAA,EAAS,CAAEvnB,MAAOunB,EAAOvnB,OAAS,IAC9BwnB,cAAeD,EAAOC,eAAiB,KACpC,IAAI,KAAO,CACdnyB,IAAKgyB,EACLjzB,MAAO,CACH,IAAA4Z,GACI,OAAO,IAAIsY,EAAajD,EAAOzf,MAAOyf,EAAOzf,MAAO,KAAM,GAAI,EAClE,EACA,KAAAyK,CAAM1K,EAAI8jB,EAAMrzB,GACZ,OA5HhB,SAA0BszB,EAAStzB,EAAOuP,EAAInX,GAC1C,IAAwC84B,EAApCqC,EAAYhkB,EAAGmN,QAAQuW,GAC3B,GAAIM,EACA,OAAOA,EAAUC,aACjBjkB,EAAGmN,QAAQwW,KACXI,EAAU,IAAIpB,EAAaoB,EAAQnB,KAAMmB,EAAQlB,OAAQ,KAAM,GAAI,IACvE,IAAIqB,EAAWlkB,EAAGmN,QAAQ,uBAC1B,GAAuB,GAAnBnN,EAAGG,MAAMhJ,OACT,OAAO4sB,EAEN,GAAIG,GAAYA,EAAS/W,QAAQuW,GAClC,OAAIQ,EAAS/W,QAAQuW,GAAYS,KACtB,IAAIxB,EAAaoB,EAAQnB,KAAKnC,aAAazgB,OAAIpP,EAAW/H,EAAS06B,EAAkB9yB,IAASszB,EAAQlB,OAAQI,EAAUjjB,EAAGjB,QAAQkG,MAAO8e,EAAQhB,SAAUgB,EAAQf,iBAEpK,IAAIL,EAAaoB,EAAQnB,KAAMmB,EAAQlB,OAAOpC,aAAazgB,OAAIpP,EAAW/H,EAAS06B,EAAkB9yB,IAAS,KAAMszB,EAAQhB,SAAUgB,EAAQf,iBAExJ,IAAmC,IAA/BhjB,EAAGmN,QAAQ,iBAA+B+W,IAAiD,IAArCA,EAAS/W,QAAQ,gBAS3E,OAAIwU,EAAU3hB,EAAGmN,QAAQ,YAGnB,IAAIwV,EAAaoB,EAAQnB,KAAKjB,QAAQ3hB,EAAI2hB,GAAUoC,EAAQlB,OAAOlB,QAAQ3hB,EAAI2hB,GAAUyB,EAAUW,EAAQjB,WAAY9iB,EAAGjB,SAAUglB,EAAQhB,SAAUgB,EAAQf,iBAG9J,IAAIL,EAAaoB,EAAQnB,KAAKnB,QAAQzhB,EAAGjB,QAAQkG,MAAO8e,EAAQlB,OAAOpB,QAAQzhB,EAAGjB,QAAQkG,MAAOme,EAAUW,EAAQjB,WAAY9iB,EAAGjB,SAAUglB,EAAQhB,SAAUgB,EAAQf,iBAfrE,CAExG,IAAIoB,EAAcpkB,EAAGmN,QAAQ,eACzBkX,EAA+B,GAApBN,EAAQhB,WACjBmB,GAAYH,EAAQf,iBAAmBoB,IACpCL,EAAQhB,UAAY/iB,EAAGskB,MAAQ,GAAKz7B,EAAQg7B,gBAa7D,SAAsBl2B,EAAWm1B,GAC7B,IAAKA,EACD,OAAO,EACX,IAAKn1B,EAAU6Y,WACX,OAAO,EACX,IAAI+d,GAAW,EAMf,OALA52B,EAAUoR,QAAQkG,KAAK,GAAGqL,SAAQ,CAACzV,EAAOgD,KACtC,IAAK,IAAI3G,EAAI,EAAGA,EAAI4rB,EAAW3rB,OAAQD,GAAK,EACpC2D,GAASioB,EAAW5rB,EAAI,IAAM2G,GAAOilB,EAAW5rB,KAChDqtB,GAAW,EAAI,IAEpBA,CACX,CAzB+EC,CAAaxkB,EAAI+jB,EAAQjB,aAC5FA,EAAaoB,EAAWd,EAAUW,EAAQjB,WAAY9iB,EAAGjB,SAAWkkB,EAAUjjB,EAAGjB,QAAQkG,MAC7F,OAAO,IAAI0d,EAAaoB,EAAQnB,KAAKnC,aAAazgB,EAAIqkB,EAAW5zB,EAAMiM,UAAUkF,mBAAgBhR,EAAW/H,EAAS06B,EAAkB9yB,IAASivB,EAAOzf,MAAO6iB,EAAY9iB,EAAGskB,KAAqB,MAAfF,EAAsBL,EAAQf,gBAAkBoB,EACvO,CASJ,CA2FuBK,CAAiBX,EAAMrzB,EAAOuP,EAAI4jB,EAC7C,GAEJA,SACAjyB,MAAO,CACHkZ,gBAAiB,CACb,WAAAkS,CAAYlrB,EAAM2I,GACd,IAAIwiB,EAAYxiB,EAAEwiB,UACdxF,EAAuB,eAAbwF,EAA6B0H,EAAoB,eAAb1H,EAA6BmH,EAAO,KACtF,QAAK3M,IAELhd,EAAEmN,iBACK6P,EAAQ3lB,EAAKpB,MAAOoB,EAAKf,UACpC,KAIhB,CACA,SAAS6zB,EAAaR,EAAMS,GACxB,MAAO,CAACn0B,EAAOK,KACX,IAAIgzB,EAAOJ,EAAW3b,SAAStX,GAC/B,IAAKqzB,GAAuD,IAA9CK,EAAOL,EAAKjB,OAASiB,EAAKlB,MAAMjD,WAC1C,OAAO,EACX,GAAI7uB,EAAU,CACV,IAAIkP,EAlFhB,SAAyB+jB,EAAStzB,EAAO0zB,GACrC,IAAItE,EAAgB0D,EAAkB9yB,GAClCiwB,EAAcgD,EAAW7sB,IAAIpG,GAAOkJ,KAAKiqB,OACzC1C,GAAOiD,EAAOJ,EAAQlB,OAASkB,EAAQnB,MAAMhD,SAASnvB,EAAOovB,GACjE,IAAKqB,EACD,OAAO,KACX,IAAIxkB,EAAYwkB,EAAIxkB,UAAUJ,QAAQ4kB,EAAIvzB,UAAUyP,KAChD0J,GAASqd,EAAOJ,EAAQnB,KAAOmB,EAAQlB,QAAQpC,aAAaS,EAAIvzB,UAAW8C,EAAMiM,UAAUkF,cAAe8e,EAAab,GACvHgF,EAAU,IAAIlC,EAAawB,EAAOrd,EAAQoa,EAAIlB,UAAWmE,EAAOjD,EAAIlB,UAAYlZ,EAAO,KAAM,GAAI,GACrG,OAAOoa,EAAIvzB,UAAU2S,aAAa5D,GAAWkH,QAAQ8f,EAAY,CAAES,OAAMF,aAAcY,GAC3F,CAwEqBC,CAAgBhB,EAAMrzB,EAAO0zB,GAClCnkB,GACAlP,EAAS8zB,EAAS5kB,EAAGhQ,iBAAmBgQ,EAChD,CACA,OAAO,CAAI,CAEnB,CAIA,MAAM0kB,EAAOC,GAAa,GAAO,GAI3BR,EAAOQ,GAAa,GAAM,GAKXA,GAAa,GAAO,GAKpBA,GAAa,GAAM,GC1axC,MAAMI,EAAU,KAAU77B,OAAO,CAC7BC,KAAM,UACN,UAAAC,GACI,MAAO,CACHiT,MAAO,IACPwnB,cAAe,IAEvB,EACA,WAAA75B,GACI,MAAO,CACH06B,KAAM,IAAM,EAAGj0B,QAAOK,cACX4zB,EAAKj0B,EAAOK,GAEvBqzB,KAAM,IAAM,EAAG1zB,QAAOK,cACXqzB,EAAK1zB,EAAOK,GAG/B,EACA,qBAAAW,GACI,MAAO,CACH,EAAQlI,KAAKV,SAErB,EACA,oBAAA6C,GACI,MAAO,CACH,QAAS,IAAMnC,KAAKsC,OAAOP,SAASo5B,OACpC,QAAS,IAAMn7B,KAAKsC,OAAOP,SAAS64B,OACpC,cAAe,IAAM56B,KAAKsC,OAAOP,SAAS64B,OAE1C,aAAS,IAAM56B,KAAKsC,OAAOP,SAASo5B,OACpC,mBAAe,IAAMn7B,KAAKsC,OAAOP,SAAS64B,OAElD,G,+FChCJ,MAAMa,EAAiB,KAAK97B,OAAO,CAC/BC,KAAM,iBACN,UAAAC,GACI,MAAO,CACHqB,eAAgB,CAAC,EAEzB,EACAE,MAAO,QACP,SAAAhB,GACI,MAAO,CAAC,CAAEsB,IAAK,MACnB,EACA,UAAAlB,EAAW,eAAEU,IACT,MAAO,CAAC,MAAM,QAAgBlB,KAAKV,QAAQ4B,eAAgBA,GAC/D,EACA,WAAAT,GACI,MAAO,CACHi7B,kBAAmB,IAAM,EAAG/6B,WAChBA,IACHwI,cAAc,CAAEzG,KAAM1C,KAAKJ,OAE3BquB,SAAQ,EAAGxX,KAAIlP,eAChB,IAAI/B,EACJ,GAAI+B,EAAU,CACV,MAAM,IAAEgO,GAAQkB,EAAGtD,UACbwoB,EAAWpmB,EAAIjB,MACrB,GAAIiB,EAAI5B,UACJ8C,EAAGM,aAAa,KAAcpX,OAAO8W,EAAG5C,IAAK0B,EAAIhN,UAEhD,CAED,MAAM3G,EAA2D,QAAnD4D,EAAK+P,EAAI9P,OAAO/C,KAAKk5B,aAAa/I,mBAAgC,IAAPrtB,OAAgB,EAASA,EAAG7F,SACjGiC,IACA6U,EAAG2D,OAAOuhB,EAAU/5B,GACpB6U,EAAGM,aAAa,KAAcpX,OAAO8W,EAAG5C,IAAK8nB,IAErD,CACAllB,EAAGhQ,gBACP,CACA,OAAO,CAAI,IAEV5F,MAGjB,EACA,aAAA0B,GACI,MAAO,EACH,QAAc,CACVC,KAAM,mCACNE,KAAM1C,KAAK0C,OAGvB,G,mFCpDJ,MAAMwoB,EAAiB,qCACjBC,EAAiB,qCACjBC,EAAuB,mCACvBC,EAAuB,mCACvBwQ,EAAS,KAAKl8B,OAAO,CACvBC,KAAM,SACN,UAAAC,GACI,MAAO,CACHqB,eAAgB,CAAC,EAEzB,EACA,SAAAd,GACI,MAAO,CACH,CACIsB,IAAK,MAET,CACIA,IAAK,IACLmL,SAAUjL,GAAiC,WAAzBA,EAAKtB,MAAMw7B,WAA0B,MAE3D,CACIx7B,MAAO,qBAGnB,EACA,UAAAE,EAAW,eAAEU,IACT,MAAO,CAAC,MAAM,QAAgBlB,KAAKV,QAAQ4B,eAAgBA,GAAiB,EAChF,EACA,WAAAT,GACI,MAAO,CACHs7B,UAAW,IAAM,EAAGh6B,cACTA,EAASnB,QAAQZ,KAAKJ,MAEjCo8B,aAAc,IAAM,EAAGj6B,cACZA,EAAS2pB,WAAW1rB,KAAKJ,MAEpCq8B,YAAa,IAAM,EAAGl6B,cACXA,EAAS6pB,UAAU5rB,KAAKJ,MAG3C,EACA,oBAAAuC,GACI,MAAO,CACH,QAAS,IAAMnC,KAAKsC,OAAOP,SAASi6B,eACpC,QAAS,IAAMh8B,KAAKsC,OAAOP,SAASi6B,eAE5C,EACA,aAAAz5B,GACI,MAAO,EACH,QAAc,CACVC,KAAM0oB,EACNxoB,KAAM1C,KAAK0C,QAEf,QAAc,CACVF,KAAM4oB,EACN1oB,KAAM1C,KAAK0C,OAGvB,EACA,aAAAmpB,GACI,MAAO,EACH,QAAc,CACVrpB,KAAM2oB,EACNzoB,KAAM1C,KAAK0C,QAEf,QAAc,CACVF,KAAM6oB,EACN3oB,KAAM1C,KAAK0C,OAGvB,G,qFCrEJ,MAAMw5B,EAAc,m3JAEdC,EAAe,21FASf,EAAS,CAAC1zB,EAAQ2zB,KACtB,IAAK,MAAMj0B,KAAOi0B,EAChB3zB,EAAON,GAAOi0B,EAAWj0B,GAE3B,OAAOM,CAAM,EAiBT4zB,EAAU,UACVC,EAAQ,QACRC,EAAQ,QACRC,EAAe,eACfC,EAAe,eACfC,EAAS,SACTC,EAAQ,QACRC,EAAS,SACTC,EAAc,cACdC,EAAa,aAQnB,SAASC,EAAcn9B,EAAMo9B,GAI3B,OAHMp9B,KAAQo9B,IACZA,EAAOp9B,GAAQ,IAEVo9B,EAAOp9B,EAChB,CAQA,SAASq9B,EAAYC,EAAGC,EAAOH,GACzBG,EAAMd,KACRc,EAAMX,IAAgB,EACtBW,EAAMV,IAAgB,GAEpBU,EAAMb,KACRa,EAAMX,IAAgB,EACtBW,EAAMZ,IAAS,GAEbY,EAAMX,KACRW,EAAMV,IAAgB,GAEpBU,EAAMZ,KACRY,EAAMV,IAAgB,GAEpBU,EAAMV,KACRU,EAAMT,IAAU,GAEdS,EAAMR,KACRQ,EAAMT,IAAU,GAElB,IAAK,MAAMU,KAAKD,EAAO,CACrB,MAAM/7B,EAAQ27B,EAAcK,EAAGJ,GAC3B57B,EAAM2iB,QAAQmZ,GAAK,GACrB97B,EAAMwO,KAAKstB,EAEf,CACF,CAoCA,SAASG,EAAMC,QACC,IAAVA,IACFA,EAAQ,MAIVt9B,KAAKmO,EAAI,CAAC,EAGVnO,KAAKu9B,GAAK,GAEVv9B,KAAKw9B,GAAK,KAEVx9B,KAAKk9B,EAAII,CACX,CAMAD,EAAML,OAAS,CAAC,EAChBK,EAAM9kB,UAAY,CAChB,OAAAklB,GACE,QAASz9B,KAAKk9B,CAChB,EAOA,EAAAQ,CAAGC,GACD,MAAMz2B,EAAQlH,KACR49B,EAAY12B,EAAMiH,EAAEwvB,GAC1B,GAAIC,EACF,OAAOA,EAET,IAAK,IAAIjwB,EAAI,EAAGA,EAAIzG,EAAMq2B,GAAG3vB,OAAQD,IAAK,CACxC,MAAMkwB,EAAQ32B,EAAMq2B,GAAG5vB,GAAG,GACpBiwB,EAAY12B,EAAMq2B,GAAG5vB,GAAG,GAC9B,GAAIiwB,GAAaC,EAAMhW,KAAK8V,GAC1B,OAAOC,CAEX,CAEA,OAAO12B,EAAMs2B,EACf,EAQA,GAAAvY,CAAI0Y,EAAOG,GAIT,YAHkB,IAAdA,IACFA,GAAY,GAEPA,EAAYH,KAAS39B,KAAKmO,IAAMnO,KAAK09B,GAAGC,EACjD,EASA,EAAAI,CAAGC,EAAQ/K,EAAMkK,EAAOH,GACtB,IAAK,IAAIrvB,EAAI,EAAGA,EAAIqwB,EAAOpwB,OAAQD,IACjC3N,KAAKi+B,GAAGD,EAAOrwB,GAAIslB,EAAMkK,EAAOH,EAEpC,EAUA,EAAAvmB,CAAGynB,EAAQjL,EAAMkK,EAAOH,GAEtB,IAAIY,EAWJ,OAZAZ,EAASA,GAAUK,EAAML,OAErB/J,GAAQA,EAAK9kB,EACfyvB,EAAY3K,GAGZ2K,EAAY,IAAIP,EAAMpK,GAClBkK,GAASH,GACXC,EAAYhK,EAAMkK,EAAOH,IAG7Bh9B,KAAKu9B,GAAG3tB,KAAK,CAACsuB,EAAQN,IACfA,CACT,EAWA,EAAAO,CAAGR,EAAO1K,EAAMkK,EAAOH,GACrB,IAAI91B,EAAQlH,KACZ,MAAMo+B,EAAMT,EAAM/vB,OAClB,IAAKwwB,EACH,OAAOl3B,EAET,IAAK,IAAIyG,EAAI,EAAGA,EAAIywB,EAAM,EAAGzwB,IAC3BzG,EAAQA,EAAM+2B,GAAGN,EAAMhwB,IAEzB,OAAOzG,EAAM+2B,GAAGN,EAAMS,EAAM,GAAInL,EAAMkK,EAAOH,EAC/C,EA2BA,EAAAiB,CAAGN,EAAO1K,EAAMkK,EAAOH,GACrBA,EAASA,GAAUK,EAAML,OACzB,MAAM91B,EAAQlH,KAGd,GAAIizB,GAAQA,EAAK9kB,EAEf,OADAjH,EAAMiH,EAAEwvB,GAAS1K,EACVA,EAET,MAAMiK,EAAIjK,EAIV,IAAI2K,EACFS,EAAgBn3B,EAAMw2B,GAAGC,GAU3B,GATIU,GACFT,EAAY,IAAIP,EAChB,EAAOO,EAAUzvB,EAAGkwB,EAAclwB,GAClCyvB,EAAUL,GAAG3tB,KAAKuR,MAAMyc,EAAUL,GAAIc,EAAcd,IACpDK,EAAUJ,GAAKa,EAAcb,GAC7BI,EAAUV,EAAImB,EAAcnB,GAE5BU,EAAY,IAAIP,EAEdH,EAAG,CAEL,GAAIF,EACF,GAAIY,EAAUV,GAA4B,kBAAhBU,EAAUV,EAAgB,CAClD,MAAMoB,EAAW,EAxM3B,SAAuBpB,EAAGF,GACxB,MAAMztB,EAAS,CAAC,EAChB,IAAK,MAAM6V,KAAK4X,EACVA,EAAO5X,GAAGrB,QAAQmZ,IAAM,IAC1B3tB,EAAO6V,IAAK,GAGhB,OAAO7V,CACT,CAgMkCgvB,CAAcX,EAAUV,EAAGF,GAASG,GAC5DF,EAAYC,EAAGoB,EAAUtB,EAC3B,MAAWG,GACTF,EAAYC,EAAGC,EAAOH,GAG1BY,EAAUV,EAAIA,CAChB,CAGA,OADAh2B,EAAMiH,EAAEwvB,GAASC,EACVA,CACT,GAYF,MAAMG,EAAK,CAAC72B,EAAOy2B,EAAO1K,EAAMkK,EAAOH,IAAW91B,EAAM62B,GAAGJ,EAAO1K,EAAMkK,EAAOH,GAUzEvmB,EAAK,CAACvP,EAAOg3B,EAAQjL,EAAMkK,EAAOH,IAAW91B,EAAMuP,GAAGynB,EAAQjL,EAAMkK,EAAOH,GAU3EmB,EAAK,CAACj3B,EAAOy2B,EAAO1K,EAAMkK,EAAOH,IAAW91B,EAAMi3B,GAAGR,EAAO1K,EAAMkK,EAAOH,GAUzEiB,EAAK,CAAC/2B,EAAOy2B,EAAO1K,EAAMkK,EAAOH,IAAW91B,EAAM+2B,GAAGN,EAAO1K,EAAMkK,EAAOH,GAQzEwB,EAAO,OACPC,EAAQ,QAGRC,EAAY,YAGZC,EAAM,MAGNC,EAAO,OAKPC,EAAS,SAKTC,EAAe,eAGfC,EAAM,MAGNC,EAAK,KAGLC,EAAO,KAKPC,EAAY,YACZC,EAAa,aACbC,EAAc,cACdC,EAAe,eACfC,EAAY,YACZC,EAAa,aACbC,EAAmB,mBACnBC,EAAoB,oBACpBC,EAAqB,qBACrBC,EAAsB,sBACtBC,EAAoB,oBACpBC,EAAqB,qBACrBC,EAAyB,yBACzBC,EAA0B,0BAC1BC,EAAoB,oBACpBC,EAAuB,uBAGvBC,EAAY,YACZC,EAAa,aACbC,EAAW,WACXC,EAAK,KACLC,GAAY,YACZC,GAAW,WACXC,GAAQ,QACRC,GAAQ,QACRC,GAAQ,QACRC,GAAS,SACTC,GAAM,MACNC,GAAS,SACTC,GAAc,cACdC,GAAS,SACTC,GAAU,UACVC,GAAO,OACPC,GAAO,OACPC,GAAQ,QACRC,GAAQ,QACRC,GAAQ,QAERC,GAAO,OACPC,GAAQ,QACRC,GAAQ,QACRC,GAAa,aAGbC,GAAU,QAGVC,GAAM,MAEZ,IAAIC,GAAkB9Y,OAAO+Y,OAAO,CACnClM,UAAW,KACX6I,KAAMA,EACNC,MAAOA,EACPC,UAAWA,EACXC,IAAKA,EACLC,KAAMA,EACNC,OAAQA,EACRC,aAAcA,EACdC,IAAKA,EACLC,GAAIA,EACJ8C,GAAI7C,EACJC,UAAWA,EACXC,WAAYA,EACZC,YAAaA,EACbC,aAAcA,EACdC,UAAWA,EACXC,WAAYA,EACZC,iBAAkBA,EAClBC,kBAAmBA,EACnBC,mBAAoBA,EACpBC,oBAAqBA,EACrBC,kBAAmBA,EACnBC,mBAAoBA,EACpBC,uBAAwBA,EACxBC,wBAAyBA,EACzBC,kBAAmBA,EACnBC,qBAAsBA,EACtBC,UAAWA,EACXC,WAAYA,EACZC,SAAUA,EACVC,GAAIA,EACJC,UAAWA,GACXC,SAAUA,GACVC,MAAOA,GACPC,MAAOA,GACPC,MAAOA,GACPC,OAAQA,GACRC,IAAKA,GACLC,OAAQA,GACRC,YAAaA,GACbC,OAAQA,GACRC,QAASA,GACTC,KAAMA,GACNC,KAAMA,GACNC,MAAOA,GACPC,MAAOA,GACPC,MAAOA,GACPC,KAAMA,GACNC,MAAOA,GACPC,MAAOA,GACPC,WAAYA,GACZM,MAAOL,GACPC,IAAKA,KAIN,MAAMK,GAAe,QACfC,GAAS,SACTF,GAAQ,aAERG,GAAQ,KACRC,GAAQ,KAgBd,MAAML,GAAK,KACLM,GAAkB,SAClBC,GAAe,SAErB,IAAIC,GAAO,KACTC,GAAQ,KA+SV,SAASC,GAAOt7B,EAAOy2B,EAAOT,EAAGuF,EAAUlF,GACzC,IAAItK,EACJ,MAAMmL,EAAMT,EAAM/vB,OAClB,IAAK,IAAID,EAAI,EAAGA,EAAIywB,EAAM,EAAGzwB,IAAK,CAChC,MAAM+0B,EAAO/E,EAAMhwB,GACfzG,EAAMiH,EAAEu0B,GACVzP,EAAO/rB,EAAMiH,EAAEu0B,IAEfzP,EAAO,IAAIoK,EAAMoF,GACjBxP,EAAKsK,GAAKA,EAAGn3B,QACbc,EAAMiH,EAAEu0B,GAAQzP,GAElB/rB,EAAQ+rB,CACV,CAIA,OAHAA,EAAO,IAAIoK,EAAMH,GACjBjK,EAAKsK,GAAKA,EAAGn3B,QACbc,EAAMiH,EAAEwvB,EAAMS,EAAM,IAAMnL,EACnBA,CACT,CAQA,SAAS0P,GAAWC,GAClB,MAAMC,EAAQ,GACRC,EAAQ,GACd,IAAIn1B,EAAI,EAER,KAAOA,EAAIi1B,EAAQh1B,QAAQ,CACzB,IAAIm1B,EAAgB,EACpB,KAHW,aAGGhf,QAAQ6e,EAAQj1B,EAAIo1B,KAAmB,GACnDA,IAGF,GAAIA,EAAgB,EAAG,CACrBF,EAAMjzB,KAAKkzB,EAAME,KAAK,KACtB,IAAK,IAAIC,EAAWC,SAASN,EAAQO,UAAUx1B,EAAGA,EAAIo1B,GAAgB,IAAKE,EAAW,EAAGA,IACvFH,EAAMnL,MAERhqB,GAAKo1B,CACP,MACED,EAAMlzB,KAAKgzB,EAAQj1B,IACnBA,GAEJ,CACA,OAAOk1B,CACT,CAmFA,MAAMO,GAAW,CACfC,gBAAiB,OACjBpK,OAAQ,KACRqK,OAAQC,GACRC,WAAYD,GACZE,OAAO,EACPC,QAAS,IACTj7B,OAAQ,KACRk7B,IAAK,KACLC,UAAU,EACVC,SAAUC,IACV7+B,UAAW,KACXhF,WAAY,KACZ8jC,WAAY,GACZC,OAAQ,MAaV,SAASC,GAAQC,EAAMC,QACC,IAAlBA,IACFA,EAAgB,MAElB,IAAIC,EAAI,EAAO,CAAC,EAAGhB,IACfc,IACFE,EAAI,EAAOA,EAAGF,aAAgBD,GAAUC,EAAKE,EAAIF,IAInD,MAAMG,EAAcD,EAAEL,WAChBO,EAAuB,GAC7B,IAAK,IAAI32B,EAAI,EAAGA,EAAI02B,EAAYz2B,OAAQD,IACtC22B,EAAqB10B,KAAKy0B,EAAY12B,GAAG42B,eAG3CvkC,KAAKokC,EAAIA,EACLD,IACFnkC,KAAKmkC,cAAgBA,GAEvBnkC,KAAK+jC,WAAaO,CACpB,CA+EA,SAASf,GAAKiB,GACZ,OAAOA,CACT,CAhFAP,GAAQ1rB,UAAY,CAClB6rB,EAAGhB,GAIHW,WAAY,GAKZ,aAAAI,CAAcM,GACZ,OAAOA,CACT,EAOA,KAAA9qB,CAAM2jB,GACJ,OAAOt9B,KAAKsN,IAAI,WAAYgwB,EAAMoH,WAAYpH,EAChD,EAcA,GAAAhwB,CAAInF,EAAKw8B,EAAUrH,GACjB,MAAMsH,EAAyB,MAAZD,EACnB,IAAIE,EAAS7kC,KAAKokC,EAAEj8B,GACpB,OAAK08B,GAGiB,kBAAXA,GACTA,EAASvH,EAAMJ,KAAK2H,EAASA,EAAOvH,EAAMJ,GAAKkG,GAASj7B,GAClC,oBAAX08B,GAAyBD,IAClCC,EAASA,EAAOF,EAAUrH,KAED,oBAAXuH,GAAyBD,IACzCC,EAASA,EAAOF,EAAUrH,EAAMJ,EAAGI,IAE9BuH,GAVEA,CAWX,EAQA,MAAAC,CAAO38B,EAAKw8B,EAAUrH,GACpB,IAAIyH,EAAM/kC,KAAKokC,EAAEj8B,GAIjB,MAHmB,oBAAR48B,GAAkC,MAAZJ,IAC/BI,EAAMA,EAAIJ,EAAUrH,EAAMJ,EAAGI,IAExByH,CACT,EAQA,MAAAf,CAAO1G,GACL,MAAMmH,EAAKnH,EAAM0G,OAAOhkC,MAExB,OADiBA,KAAKsN,IAAI,SAAU,KAAMgwB,IAAUt9B,KAAKmkC,eACzCM,EAAInH,EAAMJ,EAAGI,EAC/B,GAsBF,SAAS0H,GAAWz3B,EAAO03B,GACzBjlC,KAAKk9B,EAAI,QACTl9B,KAAKklC,EAAI33B,EACTvN,KAAK4hC,GAAKqD,CACZ,CA0JA,SAASE,GAAiBziC,EAAM0F,GAC9B,MAAMg9B,UAAcJ,GAClB,WAAAl3B,CAAYP,EAAO03B,GACjB5vB,MAAM9H,EAAO03B,GACbjlC,KAAKk9B,EAAIx6B,CACX,EAEF,IAAK,MAAMuS,KAAK7M,EACdg9B,EAAM7sB,UAAUtD,GAAK7M,EAAM6M,GAG7B,OADAmwB,EAAMlI,EAAIx6B,EACH0iC,CACT,CAvJAJ,GAAWzsB,UAAY,CACrB8sB,QAAQ,EAKR,QAAAX,GACE,OAAO1kC,KAAKklC,CACd,EAOA,MAAAI,CAAO1I,GACL,OAAO58B,KAAK0kC,UACd,EAKA,iBAAAa,CAAkBjmC,GAChB,MAAMklC,EAAMxkC,KAAK0kC,WACXb,EAAWvkC,EAAQgO,IAAI,WAAYk3B,EAAKxkC,MACxCwlC,EAAYlmC,EAAQgO,IAAI,SAAUk3B,EAAKxkC,MAC7C,OAAO6jC,GAAY2B,EAAU53B,OAASi2B,EAAW2B,EAAUrC,UAAU,EAAGU,GAAY,SAAM2B,CAC5F,EAMA,eAAAC,CAAgBnmC,GACd,OAAOA,EAAQgO,IAAI,aAActN,KAAKslC,OAAOhmC,EAAQgO,IAAI,oBAAqBtN,KAChF,EAKA,UAAA0lC,GACE,OAAO1lC,KAAK4hC,GAAG,GAAG+D,CACpB,EAMA,QAAAC,GACE,OAAO5lC,KAAK4hC,GAAG5hC,KAAK4hC,GAAGh0B,OAAS,GAAGqD,CACrC,EAUA,QAAA40B,CAASC,GAIP,YAHiB,IAAbA,IACFA,EAAW1C,GAASC,iBAEf,CACL3gC,KAAM1C,KAAKk9B,EACX3vB,MAAOvN,KAAK0kC,WACZW,OAAQrlC,KAAKqlC,OACbjgC,KAAMpF,KAAKslC,OAAOQ,GAClBx0B,MAAOtR,KAAK0lC,aACZpxB,IAAKtU,KAAK4lC,WAEd,EAKA,iBAAAG,CAAkBzmC,GAChB,MAAO,CACLoD,KAAM1C,KAAKk9B,EACX3vB,MAAOvN,KAAKulC,kBAAkBjmC,GAC9B+lC,OAAQrlC,KAAKqlC,OACbjgC,KAAMpF,KAAKylC,gBAAgBnmC,GAC3BgS,MAAOtR,KAAK0lC,aACZpxB,IAAKtU,KAAK4lC,WAEd,EAMA,QAAAhC,CAAStkC,GACP,OAAOA,EAAQgO,IAAI,WAAYtN,KAAK0kC,WAAY1kC,KAClD,EAKA,MAAAgkC,CAAO1kC,GACL,MAAMg+B,EAAQt9B,KACRoF,EAAOpF,KAAKslC,OAAOhmC,EAAQgO,IAAI,oBAC/B04B,EAAgB1mC,EAAQgO,IAAI,aAAclI,EAAMpF,MAChD0jC,EAAUpkC,EAAQgO,IAAI,UAAWlI,EAAMk4B,GACvCn8B,EAAUnB,KAAKulC,kBAAkBjmC,GACjCW,EAAa,CAAC,EACdgF,EAAY3F,EAAQgO,IAAI,YAAalI,EAAMk4B,GAC3C70B,EAASnJ,EAAQgO,IAAI,SAAUlI,EAAMk4B,GACrCqG,EAAMrkC,EAAQgO,IAAI,MAAOlI,EAAMk4B,GAC/B37B,EAAQrC,EAAQwlC,OAAO,aAAc1/B,EAAMk4B,GAC3C2I,EAAiB3mC,EAAQwlC,OAAO,SAAU1/B,EAAMk4B,GActD,OAbAr9B,EAAWmF,KAAO4gC,EACd/gC,IACFhF,EAAW4Y,MAAQ5T,GAEjBwD,IACFxI,EAAWwI,OAASA,GAElBk7B,IACF1jC,EAAW0jC,IAAMA,GAEfhiC,GACF,EAAO1B,EAAY0B,GAEd,CACL+hC,UACAzjC,aACAkB,UACA8kC,iBAEJ,GA0BF,MAAMC,GAAQf,GAAiB,QAAS,CACtCE,QAAQ,EACR,MAAAC,GACE,MAAO,UAAYtlC,KAAK0kC,UAC1B,IAMIyB,GAAOhB,GAAiB,QAMxBiB,GAAKjB,GAAiB,MAMtBkB,GAAMlB,GAAiB,MAAO,CAClCE,QAAQ,EAQR,MAAAC,CAAO1I,GAKL,YAJe,IAAXA,IACFA,EAASwG,GAASC,iBAGbrjC,KAAKsmC,cAAgBtmC,KAAKklC,EAAI,GAAGtI,OAAY58B,KAAKklC,GAC3D,EAKA,WAAAoB,GACE,MAAMrB,EAASjlC,KAAK4hC,GACpB,OAAOqD,EAAOr3B,QAAU,GAAKq3B,EAAO,GAAG/H,IAAMwB,GAAauG,EAAO,GAAG/H,IAAMuD,EAC5E,IA4BF,MAAM8F,GAAYC,GAAO,IAAInJ,EAAMmJ,GA2QnC,SAASC,GAAeC,EAAO/I,EAAOsH,GACpC,MAAM0B,EAAW1B,EAAO,GAAGU,EACrBiB,EAAS3B,EAAOA,EAAOr3B,OAAS,GAAGqD,EAEzC,OAAO,IAAIy1B,EADG/I,EAAMv3B,MAAMugC,EAAUC,GACZ3B,EAC1B,CAEA,MAAM4B,GAA0B,qBAAZC,SAA2BA,SAAWA,QAAQD,MAAQ,MAAS,GAC7EE,GAAa,gHAGbC,GAAO,CACXC,QAAS,KACTC,OAAQ,KACRC,WAAY,GACZC,YAAa,GACbC,cAAe,GACfC,aAAa,GA+Ff,SAASC,GAAuB3K,EAAQ4K,GAOtC,QAN2B,IAAvBA,IACFA,GAAqB,GAEnBR,GAAKM,aACPT,GAAK,qEAAqEjK,MAAWmK,OAElF,2BAA2Blf,KAAK+U,GACnC,MAAM,IAAIphB,MAAM,2JAKlBwrB,GAAKK,cAAcz3B,KAAK,CAACgtB,EAAQ4K,GACnC,CAMA,SAAS1mB,KAEPkmB,GAAKC,QAxrCP,SAAgBI,QACQ,IAAlBA,IACFA,EAAgB,IAIlB,MAAMrK,EAAS,CAAC,EAChBK,EAAML,OAASA,EAEf,MAAMyK,EAAQ,IAAIpK,EACN,MAARiF,KACFA,GAAOK,GAAWzG,IAEP,MAATqG,KACFA,GAAQI,GAAWxG,IAIrB8B,EAAGwJ,EAAO,IAAKtH,GACflC,EAAGwJ,EAAO,IAAKvI,GACfjB,EAAGwJ,EAAO,IAAKtI,GACflB,EAAGwJ,EAAO,IAAKrI,GACfnB,EAAGwJ,EAAO,IAAKpI,GACfpB,EAAGwJ,EAAO,IAAKnI,GACfrB,EAAGwJ,EAAO,IAAKlI,GACftB,EAAGwJ,EAAO,IAAKjI,GACfvB,EAAGwJ,EAAO,IAAKhI,GACfxB,EAAGwJ,EAAO,SAAK/H,GACfzB,EAAGwJ,EAAO,SAAK9H,GACf1B,EAAGwJ,EAAO,SAAK7H,GACf3B,EAAGwJ,EAAO,SAAK5H,GACf5B,EAAGwJ,EAAO,SAAK3H,GACf7B,EAAGwJ,EAAO,SAAK1H,GACf9B,EAAGwJ,EAAO,SAAKzH,GACf/B,EAAGwJ,EAAO,SAAKxH,GACfhC,EAAGwJ,EAAO,IAAKvH,GACfjC,EAAGwJ,EAAO,IAAKrH,GACfnC,EAAGwJ,EAAO,IAAKpH,GACfpC,EAAGwJ,EAAO,IAAKlH,IACftC,EAAGwJ,EAAO,IAAKjH,IACfvC,EAAGwJ,EAAO,IAAKhH,IACfxC,EAAGwJ,EAAO,IAAK/G,IACfzC,EAAGwJ,EAAO,IAAK9G,IACf1C,EAAGwJ,EAAO,IAAK7G,IACf3C,EAAGwJ,EAAO,IAAK5G,IACf5C,EAAGwJ,EAAO,IAAK3G,IACf7C,EAAGwJ,EAAO,IAAK1G,IACf9C,EAAGwJ,EAAO,IAAKzG,IACf/C,EAAGwJ,EAAO,IAAKxG,IACfhD,EAAGwJ,EAAO,IAAKvG,IACfjD,EAAGwJ,EAAO,IAAKtG,IACflD,EAAGwJ,EAAO,IAAKrG,IACfnD,EAAGwJ,EAAO,IAAKpG,IACfpD,EAAGwJ,EAAO,IAAKlG,IACftD,EAAGwJ,EAAO,IAAKnG,IACfrD,EAAGwJ,EAAO,IAAKjG,IACfvD,EAAGwJ,EAAO,IAAKhG,IACfxD,EAAGwJ,EAAO,KAAMnH,IAChB,MAAMoH,EAAMjxB,EAAGgxB,EAAOvF,GAAOnD,EAAK,CAChC,CAAC1C,IAAU,IAEb5lB,EAAGixB,EAAKxF,GAAOwF,GAGf,MAAMC,EAAOlxB,EAAGgxB,EAAOzF,GAAcxD,EAAM,CACzC,CAAClC,IAAQ,IAEX7lB,EAAGkxB,EAAM3F,GAAc2F,GAGvB,MAAMC,EAAQnxB,EAAGgxB,EAAOxF,GAAQxD,EAAO,CACrC,CAAClC,IAAQ,IAEX9lB,EAAGmxB,EAAO5F,IACVvrB,EAAGmxB,EAAO3F,GAAQ2F,GAKlB,MAAMC,EAAKpxB,EAAGgxB,EAAOtF,GAAOnD,EAAI,CAC9B,CAAClC,IAAa,IAEhBmB,EAAGwJ,EAAO3F,GAAI7C,EAAM,CAClB,CAACnC,IAAa,IAEhBmB,EAAG4J,EAAI/F,IACPrrB,EAAGoxB,EAAI1F,GAAO0F,GAId,MAAMC,GAAQrxB,EAAGgxB,EAAO1F,GAAOL,GAAS,CACtC,CAAC/E,IAAQ,IAEXlmB,EAAGqxB,GAAO/F,GAAO+F,IACjB7J,EAAG6J,GAAO1F,GAAiB0F,IAG3B,MAAMC,GAAc9J,EAAG6J,GAAOzF,IAC9B5rB,EAAGsxB,GAAahG,GAAO+F,IAKvB,MAAME,GAAS,CAAC,CAAChG,GAAc2F,IACzBM,GAAU,CAAC,CAACjG,GAAc,MAAO,CAACC,GAAQ2F,IAChD,IAAK,IAAIj6B,EAAI,EAAGA,EAAI20B,GAAK10B,OAAQD,IAC/B60B,GAAOiF,EAAOnF,GAAK30B,GAAIgxB,EAAKH,EAAMwJ,IAEpC,IAAK,IAAIr6B,EAAI,EAAGA,EAAI40B,GAAM30B,OAAQD,IAChC60B,GAAOiF,EAAOlF,GAAM50B,GAAIixB,EAAMH,EAAOwJ,IAEvChL,EAAY0B,EAAK,CACfuJ,KAAK,EACL5L,OAAO,GACNU,GACHC,EAAY2B,EAAM,CAChBuJ,MAAM,EACN5L,OAAO,GACNS,GAKHwF,GAAOiF,EAAO,OAAQ5I,EAAQL,EAAMwJ,IACpCxF,GAAOiF,EAAO,SAAU5I,EAAQL,EAAMwJ,IACtCxF,GAAOiF,EAAO,OAAQ3I,EAAcN,EAAMwJ,IAC1CxF,GAAOiF,EAAO,QAAS3I,EAAcN,EAAMwJ,IAC3CxF,GAAOiF,EAAO,MAAO3I,EAAcN,EAAMwJ,IACzCxF,GAAOiF,EAAO,OAAQ3I,EAAcN,EAAMwJ,IAC1C/K,EAAY4B,EAAQ,CAClBjC,QAAQ,EACRN,OAAO,GACNU,GACHC,EAAY6B,EAAc,CACxBjC,aAAa,EACbP,OAAO,GACNU,GAGHqK,EAAgBA,EAAce,MAAK,CAAC15B,EAAGC,IAAMD,EAAE,GAAKC,EAAE,GAAK,GAAK,IAChE,IAAK,IAAIhB,EAAI,EAAGA,EAAI05B,EAAcz5B,OAAQD,IAAK,CAC7C,MAAM06B,EAAMhB,EAAc15B,GAAG,GAEvBwvB,EADqBkK,EAAc15B,GAAG,GACT,CACjC,CAACivB,IAAS,GACR,CACF,CAACC,IAAc,GAEbwL,EAAItkB,QAAQ,MAAQ,EACtBoZ,EAAMT,IAAU,EACNsF,GAAana,KAAKwgB,GAEnBnG,GAAMra,KAAKwgB,GACpBlL,EAAMX,IAAgB,EAEtBW,EAAMb,IAAS,EAJfa,EAAMd,IAAW,EAMnB8B,EAAGsJ,EAAOY,EAAKA,EAAKlL,EACtB,CASA,OANAgB,EAAGsJ,EAAO,YAAa/I,EAAW,CAChCpC,OAAO,IAITmL,EAAMjK,GAAK,IAAIH,EAAMsE,IACd,CACLrwB,MAAOm2B,EACPxC,OAAQ,EAAO,CACbjI,UACC4E,IAEP,CA2gCiB0G,CAAOtB,GAAKK,eAC3B,IAAK,IAAI15B,EAAI,EAAGA,EAAIq5B,GAAKG,WAAWv5B,OAAQD,IAC1Cq5B,GAAKG,WAAWx5B,GAAG,GAAG,CACpBs5B,QAASD,GAAKC,UAKlBD,GAAKE,OAnZP,SAAgBqB,GACd,IAAI,OACFvL,GACEuL,EAEJ,MAAMC,EAAcxL,EAAON,OAAO3G,OAAO,CAACmK,EAAWE,EAAUC,EAAIC,GAAWC,GAAUC,GAAOG,GAAQE,GAAQE,GAAQhC,EAAKiC,GAASC,GAAMC,GAAMC,GAAOI,GAAOI,GAAKH,GAAOC,KAKrKgH,EAAiB,CAACtI,EAAYM,GAAOC,GAAOE,GAAKE,GAAaM,GAAOC,GAAOC,GAAM9B,EAAkBC,EAAmBP,EAAWC,EAAYE,EAAcD,EAAaE,EAAWC,EAAYG,EAAoBC,EAAqBC,EAAmBC,EAAoBC,EAAwBC,EAAyBC,EAAmBC,GAIpVyI,EAAqB,CAACxI,EAAWC,EAAYC,EAAUE,GAAWC,GAAUC,GAAOG,GAAQE,GAAQE,GAAQ7B,EAAWC,EAAY6B,GAASC,GAAMC,GAAMC,GAAOC,GAAOG,GAAOI,GAAKH,GAAOC,IAMxLgG,EAAQlB,KACRoC,EAAY1K,EAAGwJ,EAAOjG,IAC5BzD,EAAG4K,EAAWD,EAAoBC,GAClC5K,EAAG4K,EAAW3L,EAAON,OAAQiM,GAC7B,MAAMC,EAASrC,KACbsC,EAAStC,KACTuC,EAAcvC,KAChBxI,EAAG0J,EAAOzK,EAAON,OAAQkM,GACzB7K,EAAG0J,EAAOzK,EAAOJ,OAAQiM,GACzB9K,EAAG0J,EAAOzK,EAAOH,YAAaiM,GAE9B/K,EAAG6K,EAAQF,EAAoBC,GAC/B5K,EAAG6K,EAAQ5L,EAAON,OAAQkM,GAC1B,MAAMG,EAAc9K,EAAG2K,EAAQvI,GAE/BpC,EAAG0K,EAAWtI,EAAI0I,GAGlB9K,EAAG4K,EAAQxI,EAAI0I,GACf9K,EAAG6K,EAAazI,EAAI0I,GACpB,MAAMC,EAAe/K,EAAG0K,EAAW/H,IACnC7C,EAAGiL,EAAcN,EAAoBC,GACrC5K,EAAGiL,EAAchM,EAAON,OAAQiM,GAChC,MAAMM,EAAc1C,KACpBxI,EAAGgL,EAAa/L,EAAON,OAAQuM,GAC/BlL,EAAGkL,EAAajM,EAAON,OAAQuM,GAC/B,MAAMC,EAAiBjL,EAAGgL,EAAarI,IACvC7C,EAAGmL,EAAgBlM,EAAON,OAAQuM,GAClC,MAAME,EAAU5C,GAAUL,IAC1BnI,EAAGmL,EAAgBlM,EAAOkL,IAAKiB,GAC/BpL,EAAGmL,EAAgBlM,EAAOmL,KAAMgB,GAChClL,EAAG8K,EAAarK,EAAWyK,GAG3B,MAAMC,EAAoBnL,EAAGgL,EAAalI,IAC1ChD,EAAGqL,EAAmBpM,EAAON,OAAQuM,GACrClL,EAAGoL,EAASnM,EAAON,OAAQuM,GAC3BhL,EAAGkL,EAASvI,GAAKsI,GACjBjL,EAAGkL,EAASpI,GAAQqI,GAGpB,MAAMC,EAAapL,EAAGkL,EAAS1I,IAE/B1C,EAAGsL,EAAYrM,EAAOX,QAAS6J,IAI/B,MAAMoD,EAAerL,EAAG2K,EAAQ7H,IAC1BwI,EAAYtL,EAAG2K,EAAQhI,IAC7B7C,EAAGuL,EAActM,EAAON,OAAQkM,GAChC7K,EAAGwL,EAAWb,EAAoBC,GAClC5K,EAAGwL,EAAWvM,EAAON,OAAQkM,GAC7B,MAAMY,EAAejD,GAAUF,IAC/BtI,EAAGwL,EAAWvM,EAAOkL,IAAKsB,GAC1BzL,EAAGwL,EAAWvM,EAAOmL,KAAMqB,GAC3BzL,EAAGyL,EAAcxM,EAAON,OAAQkM,GAChC7K,EAAGyL,EAAcd,EAAoBC,GACrC1K,EAAGuL,EAAc5I,GAAK2I,GACtBtL,EAAGuL,EAAczI,GAAQuI,GACzBrL,EAAGuL,EAAcnJ,EAAI0I,GACrB,MAAMU,EAAoBxL,EAAGuL,EAAc/I,IACrCiJ,EAAwBnD,GAAUF,IACxCtI,EAAG0L,EAAmBzM,EAAOX,QAASqN,GAGtC,MAAMC,EAAQpD,GAAUF,IAGlBuD,EAAerD,KAGrBxI,EAAG4L,EAAOnB,EAAamB,GACvB5L,EAAG4L,EAAOlB,EAAgBmB,GAC1B7L,EAAG6L,EAAcpB,EAAamB,GAC9B5L,EAAG6L,EAAcnB,EAAgBmB,GAIjC3L,EAAGuL,EAAcjI,GAAOoI,GACxB1L,EAAGyL,EAAuBnI,GAAOoI,GAGjC,MAAME,EAAc5L,EAAG4K,EAAQpI,IACzBqJ,EAAmB7L,EAAG6K,EAAarI,IACnCsJ,EAAwB9L,EAAG6L,EAAkBvI,IAE7CyI,EAAY/L,EAAG8L,EAAuBxI,IAG5CxD,EAAG8K,EAAQ7L,EAAON,OAAQkM,GAC1B3K,EAAG4K,EAAQjI,GAAK2I,GAChBtL,EAAG4K,EAAQ9H,GAAQuI,GACnBvL,EAAG+K,EAAa9L,EAAON,OAAQkM,GAC/B3K,EAAG6K,EAAalI,GAAK2I,GACrBtL,EAAG6K,EAAa/H,GAAQuI,GAGxBvL,EAAG8L,EAAa7M,EAAON,OAAQiN,GAC/B1L,EAAG4L,EAAatI,GAAOoI,GACvB5L,EAAGiM,EAAWhN,EAAON,OAAQiN,GAC7B5L,EAAGiM,EAAWxB,EAAamB,GAC3B1L,EAAG+L,EAAWzI,GAAOoI,GACrB,MAAMM,EAAe,CAAC,CAAC/K,EAAWC,GAElC,CAACC,EAAaC,GAEd,CAACC,EAAWC,GAEZ,CAACC,EAAkBC,GAEnB,CAACC,EAAoBC,GAErB,CAACC,EAAmBC,GAEpB,CAACC,EAAwBC,GAEzB,CAACC,EAAmBC,IAGpB,IAAK,IAAItyB,EAAI,EAAGA,EAAIs8B,EAAar8B,OAAQD,IAAK,CAC5C,MAAOu8B,EAAMC,GAASF,EAAat8B,GAC7By8B,EAAUnM,EAAG0L,EAAOO,GAG1BjM,EAAG2L,EAAcM,EAAME,GAGvBnM,EAAGmM,EAASD,EAAOR,GAKnB,MAAMU,EAAW9D,GAAUF,IAC3BtI,EAAGqM,EAAS5B,EAAa6B,GACzB,MAAMC,EAAc/D,KACpBxI,EAAGqM,EAAS3B,GAGZ1K,EAAGsM,EAAU7B,EAAa6B,GAC1BtM,EAAGsM,EAAU5B,EAAgB6B,GAC7BvM,EAAGuM,EAAa9B,EAAa6B,GAC7BtM,EAAGuM,EAAa7B,EAAgB6B,GAGhCrM,EAAGoM,EAAUF,EAAOR,GACpB1L,EAAGqM,EAAaH,EAAOR,EACzB,CAIA,OAHA1L,EAAGwJ,EAAO/I,EAAW8K,GACrBvL,EAAGwJ,EAAOxI,EAAMmH,IAET,CACL90B,MAAOm2B,EACPxC,OAAQrD,GAEZ,CAqOgB2I,CAAOvD,GAAKC,QAAQhC,QAClC,IAAK,IAAIt3B,EAAI,EAAGA,EAAIq5B,GAAKI,YAAYx5B,OAAQD,IAC3Cq5B,GAAKI,YAAYz5B,GAAG,GAAG,CACrBs5B,QAASD,GAAKC,QACdC,OAAQF,GAAKE,SAGjBF,GAAKM,aAAc,CACrB,CAOA,SAASkD,GAASC,GAIhB,OAHKzD,GAAKM,aACRxmB,KA1OJ,SAAaxP,EAAOqsB,EAAOsH,GACzB,IAAI7G,EAAM6G,EAAOr3B,OACb/D,EAAS,EACT6gC,EAAS,GACTC,EAAa,GACjB,KAAO9gC,EAASu0B,GAAK,CACnB,IAAIl3B,EAAQoK,EACRs5B,EAAc,KACdhN,EAAY,KACZiN,EAAc,EACdC,EAAkB,KAClBC,GAAgB,EACpB,KAAOlhC,EAASu0B,KAASwM,EAAc1jC,EAAMw2B,GAAGuH,EAAOp7B,GAAQqzB,KAG7DyN,EAAW/6B,KAAKq1B,EAAOp7B,MAEzB,KAAOA,EAASu0B,IAAQR,EAAYgN,GAAe1jC,EAAMw2B,GAAGuH,EAAOp7B,GAAQqzB,KAEzE0N,EAAc,KACd1jC,EAAQ02B,EAGJ12B,EAAMu2B,WACRsN,EAAe,EACfD,EAAkB5jC,GACT6jC,GAAgB,GACzBA,IAEFlhC,IACAghC,IAEF,GAAIE,EAAe,EAIjBlhC,GAAUghC,EACNhhC,EAASu0B,IACXuM,EAAW/6B,KAAKq1B,EAAOp7B,IACvBA,SAEG,CAGD8gC,EAAW/8B,OAAS,IACtB88B,EAAO96B,KAAK62B,GAAeN,GAAMxI,EAAOgN,IACxCA,EAAa,IAIf9gC,GAAUkhC,EACVF,GAAeE,EAGf,MAAMrE,EAAQoE,EAAgB5N,EACxB8N,EAAY/F,EAAO7+B,MAAMyD,EAASghC,EAAahhC,GACrD6gC,EAAO96B,KAAK62B,GAAeC,EAAO/I,EAAOqN,GAC3C,CACF,CAMA,OAHIL,EAAW/8B,OAAS,GACtB88B,EAAO96B,KAAK62B,GAAeN,GAAMxI,EAAOgN,IAEnCD,CACT,CA2KS7pC,CAAImmC,GAAKE,OAAO51B,MAAOm5B,EA3hChC,SAAen5B,EAAOm5B,GAKpB,MAAMQ,EAmER,SAAuBR,GACrB,MAAMl7B,EAAS,GACT6uB,EAAMqM,EAAI78B,OAChB,IAAI+B,EAAQ,EACZ,KAAOA,EAAQyuB,GAAK,CAClB,IACI8M,EADAlxB,EAAQywB,EAAIU,WAAWx7B,GAEvB+yB,EAAO1oB,EAAQ,OAAUA,EAAQ,OAAUrK,EAAQ,IAAMyuB,IAAQ8M,EAAST,EAAIU,WAAWx7B,EAAQ,IAAM,OAAUu7B,EAAS,MAAST,EAAI96B,GACzI86B,EAAIrkC,MAAMuJ,EAAOA,EAAQ,GAC3BJ,EAAOK,KAAK8yB,GACZ/yB,GAAS+yB,EAAK90B,MAChB,CACA,OAAO2B,CACT,CAhFmB67B,CAAcX,EAAIlqC,QAAQ,UAAU6kB,GAAKA,EAAEvgB,iBACtDwmC,EAAYJ,EAASr9B,OACrBq3B,EAAS,GAIf,IAAIp7B,EAAS,EAGTyhC,EAAa,EAGjB,KAAOA,EAAaD,GAAW,CAC7B,IAAInkC,EAAQoK,EACRssB,EAAY,KACZ2N,EAAc,EACdT,EAAkB,KAClBC,GAAgB,EAChBS,GAAqB,EACzB,KAAOF,EAAaD,IAAczN,EAAY12B,EAAMw2B,GAAGuN,EAASK,MAC9DpkC,EAAQ02B,EAGJ12B,EAAMu2B,WACRsN,EAAe,EACfS,EAAoB,EACpBV,EAAkB5jC,GACT6jC,GAAgB,IACzBA,GAAgBE,EAASK,GAAY19B,OACrC49B,KAEFD,GAAeN,EAASK,GAAY19B,OACpC/D,GAAUohC,EAASK,GAAY19B,OAC/B09B,IAIFzhC,GAAUkhC,EACVO,GAAcE,EACdD,GAAeR,EAGf9F,EAAOr1B,KAAK,CACVstB,EAAG4N,EAAgB5N,EAEnBgI,EAAGuF,EAAIrkC,MAAMyD,EAAS0hC,EAAa1hC,GAEnC87B,EAAG97B,EAAS0hC,EAEZt6B,EAAGpH,GAEP,CAEA,OAAOo7B,CACT,CAg+BqCwG,CAAMzE,GAAKC,QAAQ31B,MAAOm5B,GAC/D,CAUA,SAASjoC,GAAKioC,EAAK/nC,EAAMwhC,GAOvB,QANa,IAATxhC,IACFA,EAAO,WAEI,IAATwhC,IACFA,EAAO,MAELxhC,GAAwB,kBAATA,EAAmB,CACpC,GAAIwhC,EACF,MAAM1oB,MAAM,gCAAgC9Y,uBAE9CwhC,EAAOxhC,EACPA,EAAO,IACT,CACA,MAAMpD,EAAU,IAAI2kC,GAAQC,GACtBe,EAASuF,GAASC,GAClBiB,EAAW,GACjB,IAAK,IAAI/9B,EAAI,EAAGA,EAAIs3B,EAAOr3B,OAAQD,IAAK,CACtC,MAAM2vB,EAAQ2H,EAAOt3B,IACjB2vB,EAAM+H,QAAY3iC,GAAQ46B,EAAMJ,IAAMx6B,IAASpD,EAAQqa,MAAM2jB,IAC/DoO,EAAS97B,KAAK0tB,EAAMyI,kBAAkBzmC,GAE1C,CACA,OAAOosC,CACT,CAkBA,SAAS7jB,GAAK4iB,EAAK/nC,QACJ,IAATA,IACFA,EAAO,MAET,MAAMuiC,EAASuF,GAASC,GACxB,OAAyB,IAAlBxF,EAAOr3B,QAAgBq3B,EAAO,GAAGI,UAAY3iC,GAAQuiC,EAAO,GAAG/H,IAAMx6B,EAC9E,C,gBCpqDA,MAAM4C,GAAO,KAAK3F,OAAO,CACrBC,KAAM,OACN+rC,SAAU,IACVC,aAAa,EACb,QAAAhmC,GACI5F,KAAKV,QAAQusC,UAAU9kB,SAAQ+e,IACH,kBAAbA,EAIXyB,GAAuBzB,EAASlJ,OAAQkJ,EAASgG,iBAH7CvE,GAAuBzB,EAGsC,GAEzE,EACA,SAAAiG,GD2+CF1O,EAAML,OAAS,CAAC,EAChBgK,GAAKC,QAAU,KACfD,GAAKE,OAAS,KACdF,GAAKG,WAAa,GAClBH,GAAKI,YAAc,GACnBJ,GAAKK,cAAgB,GACrBL,GAAKM,aAAc,CC/+CjB,EACA,SAAA0E,GACI,OAAOhsC,KAAKV,QAAQ2sC,QACxB,EACA,UAAApsC,GACI,MAAO,CACHqsC,aAAa,EACbC,aAAa,EACbF,UAAU,EACVJ,UAAW,GACX3qC,eAAgB,CACZuH,OAAQ,SACRk7B,IAAK,+BACL9qB,MAAO,MAEX+qB,cAAUv8B,EAElB,EACA,aAAA/F,GACI,MAAO,CACH8D,KAAM,CACFjF,QAAS,MAEbsI,OAAQ,CACJtI,QAASH,KAAKV,QAAQ4B,eAAeuH,QAEzCoQ,MAAO,CACH1Y,QAASH,KAAKV,QAAQ4B,eAAe2X,OAGjD,EACA,SAAAzY,GACI,MAAO,CAAC,CAAEsB,IAAK,0CACnB,EACA,UAAAlB,EAAW,eAAEU,IACT,MAAO,CAAC,KAAK,QAAgBlB,KAAKV,QAAQ4B,eAAgBA,GAAiB,EAC/E,EACA,WAAAT,GACI,MAAO,CACH2rC,QAASnsC,GAAc,EAAGU,WACfA,IAAQC,QAAQZ,KAAKJ,KAAMK,GAAYoa,QAAQ,mBAAmB,GAAMxZ,MAEnFwrC,WAAYpsC,GAAc,EAAGU,WAClBA,IACF+qB,WAAW1rB,KAAKJ,KAAMK,EAAY,CAAEqsC,sBAAsB,IAC1DjyB,QAAQ,mBAAmB,GAC3BxZ,MAET0rC,UAAW,IAAM,EAAG5rC,WACTA,IACFirB,UAAU5rB,KAAKJ,KAAM,CAAE0sC,sBAAsB,IAC7CjyB,QAAQ,mBAAmB,GAC3BxZ,MAGjB,EACA,aAAAgrB,GACI,MAAO,EACH,QAAc,CACVrpB,KAAMmB,GAAQnB,GAAKmB,GACdqR,QAAO7R,IACJnD,KAAKV,QAAQskC,UACN5jC,KAAKV,QAAQskC,SAASzgC,EAAKoK,SAIrCyH,QAAO7R,GAAQA,EAAKkiC,SACpB5jC,KAAI0B,IAAQ,CACbQ,KAAMR,EAAKoK,MACXoC,MAAOxM,EAAKmO,MACZk7B,KAAMrpC,MAEVT,KAAM1C,KAAK0C,KACXC,cAAeyG,IACX,IAAI5D,EACJ,MAAO,CACHJ,KAA4B,QAArBI,EAAK4D,EAAMojC,YAAyB,IAAPhnC,OAAgB,EAASA,EAAGJ,KAClE,IAIlB,EACA,qBAAA8C,GACI,MAAM+xB,EAAU,GAkBhB,OAjBIj6B,KAAKV,QAAQ2sC,UACbhS,EAAQrqB,KAjPpB,SAAkBtQ,GACd,OAAO,IAAI,MAAO,CACd6I,IAAK,IAAI,MAAU,YACnBuf,kBAAmB,CAAC+kB,EAAc/yB,EAAUgzB,KACxC,MAAMC,EAAaF,EAAa93B,MAAKi4B,GAAeA,EAAY3vB,eAAgBvD,EAAS7F,IAAIgE,GAAG60B,EAAS74B,KACnGg5B,EAAkBJ,EAAa93B,MAAKi4B,GAAeA,EAAYhpB,QAAQ,qBAC7E,IAAK+oB,GAAcE,EACf,OAEJ,MAAM,GAAEp2B,GAAOi2B,EACTtoC,GAAY,QAAwBsV,EAAS7F,IAAK,IAAI44B,KACtD,QAAEj3B,GAAYpR,EAuEpB,OAtEgB,QAAiBA,GACzB2iB,SAAQ,EAAG+lB,WAAUC,gBAEzB,QAAgBD,EAAS33B,KAAM23B,EAASh2B,GAAI4C,EAAS7F,KAChDmB,QAAO4hB,GAAQA,EAAKtC,KAAK5xB,OAASpD,EAAQoD,OAC1CqkB,SAAQimB,IACT,MAAMC,EAAUz3B,EAAQ/T,IAAIurC,EAAQ73B,MAC9B+3B,EAAQ13B,EAAQ/T,IAAIurC,EAAQl2B,IAC5Bq2B,GAAW,QAAgBF,EAASC,EAAOR,EAAS74B,KAAKmB,QAAO4hB,GAAQA,EAAKtC,KAAK5xB,OAASpD,EAAQoD,OACzG,IAAKyqC,EAASv/B,OACV,OAEJ,MAAMw/B,EAAUD,EAAS,GACnBE,EAAc3zB,EAAS7F,IAAIy5B,YAAYN,EAAQ73B,KAAM63B,EAAQl2B,QAAIzP,EAAW,KAC5EkmC,EAAcb,EAAS74B,IAAIy5B,YAAYF,EAAQj4B,KAAMi4B,EAAQt2B,QAAIzP,EAAW,KAC5EmmC,EAAU3lB,GAAKwlB,GACfhI,EAASxd,GAAK0lB,GAGhBC,IAAYnI,GACZ5uB,EAAGg3B,WAAWL,EAAQj4B,KAAMi4B,EAAQt2B,GAAIxX,EAAQoD,KACpD,IAGJ,MAAMgrC,GAAuB,QAAoBhB,EAAS74B,IAAKk5B,GAAUnrC,GAAQA,EAAKyjB,cACtF,IAAIsoB,EACAC,EAYJ,GAXIF,EAAqB9/B,OAAS,GAE9B+/B,EAAYD,EAAqB,GACjCE,EAAuBlB,EAAS74B,IAAIy5B,YAAYK,EAAUplC,IAAKolC,EAAUplC,IAAMolC,EAAU/rC,KAAKsO,cAAU7I,EAAW,MAE9GqmC,EAAqB9/B,QAEvB8+B,EAAS74B,IAAIy5B,YAAYP,EAAS53B,KAAM43B,EAASj2B,GAAI,IAAK,KAAKkX,SAAS,OAC3E2f,EAAYD,EAAqB,GACjCE,EAAuBlB,EAAS74B,IAAIy5B,YAAYK,EAAUplC,IAAKwkC,EAASj2B,QAAIzP,EAAW,MAEvFsmC,GAAaC,EAAsB,CACnC,MAAMC,EAAwBD,EAAqBE,MAAM,KAAK94B,QAAO2wB,GAAW,KAANA,IAC1E,GAAIkI,EAAsBjgC,QAAU,EAChC,OAAO,EAEX,MAAMmgC,EAAsBF,EAAsBA,EAAsBjgC,OAAS,GAC3EogC,EAAyBL,EAAUplC,IAAMqlC,EAAqBK,YAAYF,GAChF,IAAKA,EACD,OAAO,EAEXvrC,GAAKurC,GACA/4B,QAAO7R,GAAQA,EAAKkiC,SACpBrwB,QAAO7R,IACJ7D,EAAQskC,UACDtkC,EAAQskC,SAASzgC,EAAKoK,SAKhC9L,KAAI0B,IAAQ,IACVA,EACHgS,KAAM64B,EAAyB7qC,EAAKmO,MAAQ,EAC5CwF,GAAIk3B,EAAyB7qC,EAAKmR,IAAM,MAGvCyS,SAAQ5jB,IACTsT,EAAGy3B,QAAQ/qC,EAAKgS,KAAMhS,EAAK2T,GAAIxX,EAAQoD,KAAK/C,OAAO,CAC/CyF,KAAMjC,EAAKiC,OACZ,GAEX,KAECqR,EAAGG,MAAMhJ,OAGP6I,OAHP,CAGS,GAGrB,CAyJyBw1B,CAAS,CAClBvpC,KAAM1C,KAAK0C,KACXkhC,SAAU5jC,KAAKV,QAAQskC,YAG3B5jC,KAAKV,QAAQ4sC,aACbjS,EAAQrqB,KA7JpB,SAAsBtQ,GAClB,OAAO,IAAI,MAAO,CACd6I,IAAK,IAAI,MAAU,mBACnBC,MAAO,CACHC,YAAa,CAACC,EAAMC,EAAKC,KACrB,IAAIhD,EAAIub,EAAIotB,EACZ,GAAqB,IAAjB3lC,EAAM4lC,OACN,OAAO,EAEX,MAAMzsC,GAAQ,QAAc2G,EAAKpB,MAAO5H,EAAQoD,KAAK9C,MAC/CuD,EAA+B,QAAvBqC,EAAKgD,EAAMC,cAA2B,IAAPjD,OAAgB,EAASA,EAAGkD,QAAQ,KAC3EtD,EAAwE,QAAhE2b,EAAc,OAAT5d,QAA0B,IAATA,OAAkB,EAASA,EAAKiC,YAAyB,IAAP2b,EAAgBA,EAAKpf,EAAMyD,KAC3GqD,EAA4E,QAAlE0lC,EAAc,OAAThrC,QAA0B,IAATA,OAAkB,EAASA,EAAKsF,cAA2B,IAAP0lC,EAAgBA,EAAKxsC,EAAM8G,OACrH,SAAItF,IAAQiC,KACRa,OAAOooC,KAAKjpC,EAAMqD,IACX,EAEC,IAI5B,CAwIyB6lC,CAAa,CACtB5rC,KAAM1C,KAAK0C,QAGf1C,KAAKV,QAAQ6sC,aACblS,EAAQrqB,KA3IpB,SAAsBtQ,GAClB,OAAO,IAAI,MAAO,CACd6I,IAAK,IAAI,MAAU,mBACnBC,MAAO,CACH+U,YAAa,CAAC7U,EAAME,EAAOpC,KACvB,MAAM,MAAEc,GAAUoB,GACZ,UAAE6K,GAAcjM,GAChB,MAAEwP,GAAUvD,EAClB,GAAIuD,EACA,OAAO,EAEX,IAAIkX,EAAc,GAClBxnB,EAAMjF,QAAQ4lB,SAAQnlB,IAClBgsB,GAAehsB,EAAKgsB,WAAW,IAEnC,MAAMzqB,EAAOX,GAAKorB,GAAaprB,MAAKo0B,GAAQA,EAAKyO,QAAUzO,EAAKrpB,QAAUqgB,IAC1E,SAAKA,IAAgBzqB,KAGrB7D,EAAQgD,OAAOP,SAASnB,QAAQtB,EAAQoD,KAAM,CAC1C0C,KAAMjC,EAAKiC,QAER,EAAI,IAI3B,CAiHyBmpC,CAAa,CACtBjsC,OAAQtC,KAAKsC,OACbI,KAAM1C,KAAK0C,QAGZu3B,CACX,G,oFCpQJ,MAAMnO,EAAW,KAAKnsB,OAAO,CACzBC,KAAM,WACN,UAAAC,GACI,MAAO,CACHqB,eAAgB,CAAC,EAEzB,EACAC,QAAS,mBACTE,UAAU,EACV,SAAAjB,GACI,MAAO,CACH,CACIsB,IAAK,MAGjB,EACA,UAAAlB,EAAW,eAAEU,IACT,MAAO,CAAC,MAAM,QAAgBlB,KAAKV,QAAQ4B,eAAgBA,GAAiB,EAChF,EACA,oBAAAiB,GACI,MAAO,CACH4pB,MAAO,IAAM/rB,KAAKsC,OAAOP,SAASiqB,cAAchsB,KAAKJ,MACrD0qB,IAAK,IAAMtqB,KAAKsC,OAAOP,SAASkqB,aAAajsB,KAAKJ,MAClD,YAAa,IAAMI,KAAKsC,OAAOP,SAASmqB,aAAalsB,KAAKJ,MAElE,G,0GCyBJ,MAAM4uC,EAAsB,IAAI,KAAU,cAC1C,SAASC,GAAW,UAAEC,EAAYF,EAAmB,OAAElsC,EAAM,KAAEogC,EAAO,IAAG,YAAEiM,GAAc,EAAK,gBAAEC,EAAkB,CAAC,KAAI,YAAEC,GAAc,EAAK,cAAEC,EAAgB,OAAM,gBAAEC,EAAkB,aAAY,QAAE9gB,EAAU,IAAM,KAAI,MAAE5rB,EAAQ,IAAM,GAAE,OAAE2hC,EAAS,KAAM,CAAG,GAAC,MAAEgL,EAAQ,KAAM,IAC7Q,IAAI5mC,EACJ,MAAM6mC,EAAsB,OAAXjL,QAA8B,IAAXA,OAAoB,EAASA,IAC3DnjB,EAAS,IAAI,KAAO,CACtB1Y,IAAKumC,EACL,IAAApmC,GACI,MAAO,CACHqX,OAAQuvB,MAAO5mC,EAAMunB,KACjB,IAAIrqB,EAAIub,EAAIotB,EAAIgB,EAAIC,EAAIC,EAAIC,EAC5B,MAAM59B,EAA2B,QAAnBlM,EAAKxF,KAAKmI,WAAwB,IAAP3C,OAAgB,EAASA,EAAGgZ,SAASqR,GACxEoD,EAA2B,QAAnBlS,EAAK/gB,KAAKmI,WAAwB,IAAP4Y,OAAgB,EAASA,EAAGvC,SAASlW,EAAKpB,OAE7EsN,EAAQ9C,EAAK69B,QAAUtc,EAAKsc,QAAU79B,EAAK89B,MAAMr6B,OAAS8d,EAAKuc,MAAMr6B,KACrEs6B,GAAW/9B,EAAK69B,QAAUtc,EAAKsc,OAC/BG,EAAUh+B,EAAK69B,SAAWtc,EAAKsc,OAE/BI,EAAcF,GAAWj7B,EACzBo7B,GAFWH,IAAYC,GAAWh+B,EAAKm+B,QAAU5c,EAAK4c,QAE3Br7B,EAC3Bs7B,EAAaJ,GAAWl7B,EAE9B,IAAKm7B,IAAgBC,IAAiBE,EAClC,OAEJ,MAAM5oC,EAAQ4oC,IAAeH,EAAcj+B,EAAOuhB,EAC5C8c,EAAiBznC,EAAKyW,IAAIixB,cAAc,wBAAwB9oC,EAAM+oC,kBAC5E7nC,EAAQ,CACJ9F,SACAktC,MAAOtoC,EAAMsoC,MACbK,MAAO3oC,EAAM2oC,MACblsC,KAAMuD,EAAMvD,KACZtB,MAAO,GACP4rB,QAASiiB,IACLjiB,EAAQ,CACJ3rB,SACAktC,MAAOtoC,EAAMsoC,MACbpnC,MAAO8nC,GACT,EAENH,iBAGAI,WAAYJ,EACN,KACE,IAAIvqC,EAEJ,MAAM,aAAEyqC,GAAqC,QAAnBzqC,EAAKxF,KAAKmI,WAAwB,IAAP3C,OAAgB,EAASA,EAAGgZ,SAASlc,EAAO4E,OAC3FkpC,EAAwB9nC,EAAKyW,IAAIixB,cAAc,wBAAwBC,OAC7E,OAAkC,OAA1BG,QAA4D,IAA1BA,OAAmC,EAASA,EAAsB7kC,0BAA4B,IAAI,EAE9I,MAENokC,IACsF,QAArFxB,EAAkB,OAAbc,QAAkC,IAAbA,OAAsB,EAASA,EAASoB,qBAAkC,IAAPlC,GAAyBA,EAAGzoC,KAAKupC,EAAU7mC,IAEzIwnC,IACuF,QAAtFT,EAAkB,OAAbF,QAAkC,IAAbA,OAAsB,EAASA,EAASqB,sBAAmC,IAAPnB,GAAyBA,EAAGzpC,KAAKupC,EAAU7mC,KAE1IwnC,GAAgBD,KAChBvnC,EAAM/F,YAAcA,EAAM,CACtBC,SACAutC,MAAO3oC,EAAM2oC,SAGjBC,IAC+E,QAA9EV,EAAkB,OAAbH,QAAkC,IAAbA,OAAsB,EAASA,EAASsB,cAA2B,IAAPnB,GAAyBA,EAAG1pC,KAAKupC,EAAU7mC,IAElIwnC,IACiF,QAAhFP,EAAkB,OAAbJ,QAAkC,IAAbA,OAAsB,EAASA,EAASuB,gBAA6B,IAAPnB,GAAyBA,EAAG3pC,KAAKupC,EAAU7mC,IAEpIunC,IACgF,QAA/EL,EAAkB,OAAbL,QAAkC,IAAbA,OAAsB,EAASA,EAASwB,eAA4B,IAAPnB,GAAyBA,EAAG5pC,KAAKupC,EAAU7mC,GACvI,EAEJwnB,QAAS,KACL,IAAIpqB,EACC4C,IAG0E,QAA9E5C,EAAkB,OAAbypC,QAAkC,IAAbA,OAAsB,EAASA,EAASsB,cAA2B,IAAP/qC,GAAyBA,EAAGE,KAAKupC,EAAU7mC,GAAM,EAGpJ,EACAlB,MAAO,CAEH,IAAA4Z,GAWI,MAVc,CACVyuB,QAAQ,EACRC,MAAO,CACHr6B,KAAM,EACN2B,GAAI,GAER+4B,MAAO,KACPlsC,KAAM,KACN+sC,WAAW,EAGnB,EAEA,KAAAvvB,CAAMyrB,EAAal7B,EAAMgI,EAAUxS,GAC/B,MAAM,WAAEsjB,GAAeloB,GACjB,UAAEouC,GAAcpuC,EAAOgG,MACvB,UAAE6K,GAAcy5B,GAChB,MAAEl2B,EAAK,KAAEvB,GAAShC,EAClB8f,EAAO,IAAKvhB,GAKlB,GAJAuhB,EAAKyd,UAAYA,EAIblmB,IAAe9T,GAASpU,EAAOgG,KAAKooC,WAAY,GAE3Cv7B,EAAOzD,EAAK89B,MAAMr6B,MAAQA,EAAOzD,EAAK89B,MAAM14B,KAAQ45B,GAAch/B,EAAKg/B,YACxEzd,EAAKsc,QAAS,GAGlB,MAAMnmC,EAnK1B,SAA6BixB,GACzB,IAAI70B,EACJ,MAAM,KAAEk9B,EAAI,YAAEiM,EAAW,gBAAEC,EAAe,YAAEC,EAAW,UAAE8B,GAAetW,EAClEuW,GAAc,QAAelO,GAC7BmO,EAAS,IAAIpuC,OAAO,MAAMmuC,MAC1BE,EAASjC,EAAc,IAAM,GAC7B3Q,EAASyQ,EACT,IAAIlsC,OAAO,GAAGquC,IAASF,aAAuBA,OAAkB,MAChE,IAAInuC,OAAO,GAAGquC,UAAeF,SAAmBA,MAAiB,MACjEjtC,GAAwC,QAA/B6B,EAAKmrC,EAAU78B,kBAA+B,IAAPtO,OAAgB,EAASA,EAAG2tB,SAAWwd,EAAU78B,WAAWnQ,KAClH,IAAKA,EACD,OAAO,KAEX,MAAMotC,EAAWJ,EAAUpoC,IAAM5E,EAAKiK,OAChCxE,EAAQ4a,MAAM7O,KAAKxR,EAAKqtC,SAAS9S,IAASvG,MAChD,IAAKvuB,QAAyB/B,IAAhB+B,EAAMu0B,YAAuCt2B,IAAhB+B,EAAMuG,MAC7C,OAAO,KAIX,MAAMshC,EAAc7nC,EAAMu0B,MAAMv3B,MAAM2F,KAAKC,IAAI,EAAG5C,EAAMuG,MAAQ,GAAIvG,EAAMuG,OACpEuhC,EAAuB,IAAIzuC,OAAO,KAAyB,OAApBmsC,QAAgD,IAApBA,OAA6B,EAASA,EAAgB5L,KAAK,YAAYnb,KAAKopB,GACrJ,GAAwB,OAApBrC,IAA6BsC,EAC7B,OAAO,KAGX,MAAM/7B,EAAO47B,EAAW3nC,EAAMuG,MAC9B,IAAImH,EAAK3B,EAAO/L,EAAM,GAAGwE,OAQzB,OALI+gC,GAAekC,EAAOhpB,KAAKlkB,EAAKyC,MAAM0Q,EAAK,EAAGA,EAAK,MACnD1N,EAAM,IAAM,IACZ0N,GAAM,GAGN3B,EAAOw7B,EAAUpoC,KAAOuO,GAAM65B,EAAUpoC,IACjC,CACHinC,MAAO,CACHr6B,OACA2B,MAEJ+4B,MAAOzmC,EAAM,GAAGhD,MAAMs8B,EAAK90B,QAC3BjK,KAAMyF,EAAM,IAGb,IACX,CAqHkC+nC,CAAoB,CAC9BzO,OACAiM,cACAC,kBACAC,cACA8B,UAAWx9B,EAAUmC,QAEnB26B,EAAe,MAAMlkC,KAAKqlC,MAAsB,WAAhBrlC,KAAKslC,YAEvCjoC,GAAS4lC,EAAM,CAAE1sC,SAAQ4E,QAAOsoC,MAAOpmC,EAAMomC,SAC7Cvc,EAAKsc,QAAS,EACdtc,EAAKgd,aAAev+B,EAAKu+B,aAAev+B,EAAKu+B,aAAeA,EAC5Dhd,EAAKuc,MAAQpmC,EAAMomC,MACnBvc,EAAK4c,MAAQzmC,EAAMymC,MACnB5c,EAAKtvB,KAAOyF,EAAMzF,MAGlBsvB,EAAKsc,QAAS,CAEtB,MAEItc,EAAKsc,QAAS,EASlB,OANKtc,EAAKsc,SACNtc,EAAKgd,aAAe,KACpBhd,EAAKuc,MAAQ,CAAEr6B,KAAM,EAAG2B,GAAI,GAC5Bmc,EAAK4c,MAAQ,KACb5c,EAAKtvB,KAAO,MAETsvB,CACX,GAEJ7qB,MAAO,CAEH,aAAA6T,CAAc3T,EAAME,GAChB,IAAIhD,EACJ,MAAM,OAAE+pC,EAAM,MAAEC,GAAU3uB,EAAOrC,SAASlW,EAAKpB,OAC/C,OAAKqoC,IAGqF,QAAjF/pC,EAAkB,OAAbypC,QAAkC,IAAbA,OAAsB,EAASA,EAASqC,iBAA8B,IAAP9rC,OAAgB,EAASA,EAAGE,KAAKupC,EAAU,CAAE3mC,OAAME,QAAOgnC,aAFjJ,CAGf,EAEA,WAAAjsB,CAAYrc,GACR,MAAM,OAAEqoC,EAAM,MAAEC,EAAK,aAAES,GAAiBpvB,EAAOrC,SAAStX,GACxD,OAAKqoC,EAGE,KAAc5vC,OAAOuH,EAAM2M,IAAK,CACnC,KAAWjN,OAAO4oC,EAAMr6B,KAAMq6B,EAAM14B,GAAI,CACpCmI,SAAU6vB,EACVj2B,MAAOk2B,EACP,qBAAsBkB,MANnB,IASf,KAGR,OAAOpvB,CACX,CC/NA,MAAM0wB,EAAmB,IAAI,KAAU,WACjCC,EAAU,KAAK7xC,OAAO,CACxBC,KAAM,UACN,UAAAC,GACI,MAAO,CACHqB,eAAgB,CAAC,EACjB,WAAAuwC,EAAY,QAAEnyC,EAAO,KAAEsC,IACnB,IAAI4D,EACJ,MAAO,GAAGlG,EAAQoyC,WAAWhP,OAAmC,QAA3Bl9B,EAAK5D,EAAKD,MAAMgwC,aAA0B,IAAPnsC,EAAgBA,EAAK5D,EAAKD,MAAMqD,IAC5G,EACA0sC,WAAY,CACRhP,KAAM,IACNgM,UAAW6C,EACXtjB,QAAS,EAAG3rB,SAAQktC,QAAOpnC,YACvB,IAAI5C,EAAIub,EAGR,MAAMpN,EAAYrR,EAAOgG,KAAKpB,MAAMiM,UAAUoC,IAAI5B,WACoD,QAA/EnO,EAAmB,OAAdmO,QAAoC,IAAdA,OAAuB,EAASA,EAAUhQ,YAAyB,IAAP6B,OAAgB,EAASA,EAAG+nB,WAAW,QAEjJiiB,EAAM14B,IAAM,GAEhBxU,EACK3B,QACAkH,QACA+pC,gBAAgBpC,EAAO,CACxB,CACI9sC,KAAM1C,KAAKJ,KACX+B,MAAOyG,GAEX,CACI1F,KAAM,OACNiB,KAAM,OAGT9C,MAC4B,QAAhCkgB,EAAK9a,OAAO4rC,sBAAmC,IAAP9wB,GAAyBA,EAAG+wB,eAAe,EAExF9C,MAAO,EAAG9nC,QAAOsoC,YACb,MAAMl6B,EAAQpO,EAAM2M,IAAId,QAAQy8B,EAAMr6B,MAChCzS,EAAOwE,EAAMvC,OAAO6N,MAAMxS,KAAKJ,MAErC,QADgB0V,EAAM7P,OAAO/C,KAAKk5B,aAAamW,UAAUrvC,EAC7C,GAI5B,EACAtB,MAAO,SACPwF,QAAQ,EACRmtB,YAAY,EACZie,MAAM,EACN,aAAA1wC,GACI,MAAO,CACH0D,GAAI,CACA7E,QAAS,KACTC,UAAWC,GAAWA,EAAQuM,aAAa,WAC3CpM,WAAYP,GACHA,EAAW+E,GAGT,CACH,UAAW/E,EAAW+E,IAHf,CAAC,GAOpB2sC,MAAO,CACHxxC,QAAS,KACTC,UAAWC,GAAWA,EAAQuM,aAAa,cAC3CpM,WAAYP,GACHA,EAAW0xC,MAGT,CACH,aAAc1xC,EAAW0xC,OAHlB,CAAC,GAQ5B,EACA,SAAAvxC,GACI,MAAO,CACH,CACIsB,IAAK,mBAAmB1B,KAAKJ,UAGzC,EACA,UAAAY,EAAW,KAAEoB,EAAI,eAAEV,IACf,MAAO,CACH,QACA,QAAgB,CAAE,YAAalB,KAAKJ,MAAQI,KAAKV,QAAQ4B,eAAgBA,GACzElB,KAAKV,QAAQmyC,YAAY,CACrBnyC,QAASU,KAAKV,QACdsC,SAGZ,EACA,UAAAoyB,EAAW,KAAEpyB,IACT,OAAO5B,KAAKV,QAAQmyC,YAAY,CAC5BnyC,QAASU,KAAKV,QACdsC,QAER,EACA,oBAAAO,GACI,MAAO,CACHqa,UAAW,IAAMxc,KAAKsC,OAAOP,SAASksB,SAAQ,EAAGxX,KAAIvP,YACjD,IAAI+qC,GAAY,EAChB,MAAM,UAAE9+B,GAAcjM,GAChB,MAAEwP,EAAK,OAAEsB,GAAW7E,EAC1B,QAAKuD,IAGLxP,EAAM2M,IAAI2F,aAAaxB,EAAS,EAAGA,GAAQ,CAACpW,EAAM2G,KAC9C,GAAI3G,EAAKc,KAAK9C,OAASI,KAAKJ,KAGxB,OAFAqyC,GAAY,EACZx7B,EAAGgY,WAAWzuB,KAAKV,QAAQoyC,WAAWhP,MAAQ,GAAIn6B,EAAKA,EAAM3G,EAAKsO,WAC3D,CACX,IAEG+hC,EAAS,IAG5B,EACA,qBAAA/pC,GACI,MAAO,CACHumC,EAAW,CACPnsC,OAAQtC,KAAKsC,UACVtC,KAAKV,QAAQoyC,aAG5B,G,qFCnIJ,MAAM5lB,EAAW,KAAKnsB,OAAO,CACzBC,KAAM,WACN,UAAAC,GACI,MAAO,CACHqB,eAAgB,CAAC,EAEzB,EACAC,QAAS,mBACTE,UAAU,EACV,SAAAjB,GACI,MAAO,CACH,CACIsB,IAAK,MAGjB,EACA,UAAAlB,EAAW,eAAEU,IACT,MAAO,CAAC,MAAM,QAAgBlB,KAAKV,QAAQ4B,eAAgBA,GAAiB,EAChF,EACA,oBAAAiB,GACI,MAAO,CACH4pB,MAAO,IAAM/rB,KAAKsC,OAAOP,SAASiqB,cAAchsB,KAAKJ,MACrD0qB,IAAK,IAAMtqB,KAAKsC,OAAOP,SAASkqB,aAAajsB,KAAKJ,MAClD,YAAa,IAAMI,KAAKsC,OAAOP,SAASmqB,aAAalsB,KAAKJ,MAElE,IAGEusB,EAAY,KAAKxsB,OAAO,CAC1BC,KAAM,YACN,UAAAC,GACI,MAAO,CACHqB,eAAgB,CAAC,EAEzB,EACA,SAAAd,GACI,MAAO,CACH,CACIsB,IAAK,OACLmL,SAAUxM,KACYA,EAAQ+rB,aAAa,UAIhC,CAAC,GAIxB,EACA,UAAA5rB,EAAW,eAAEU,IACT,MAAO,CAAC,QAAQ,QAAgBlB,KAAKV,QAAQ4B,eAAgBA,GAAiB,EAClF,EACA,WAAAT,GACI,MAAO,CACHM,qBAAsB,IAAM,EAAGmG,QAAOnF,eAClC,MAAM9B,GAAa,QAAkBiH,EAAOlH,KAAK0C,MAEjD,QADkBomB,OAAOuD,QAAQpsB,GAAY0U,MAAK,EAAE,CAAEpH,OAAaA,KAI5DxL,EAAS6pB,UAAU5rB,KAAKJ,KAAK,EAGhD,IAGE+I,EAAa,cACbupC,EAAc,KAAKvyC,OAAO,CAC5BC,KAAM,cACN,UAAAC,GACI,MAAO,CACH0sB,aAAc,WACdrrB,eAAgB,CAAC,EACjBsrB,WAAW,EACXC,gBAAgB,EAExB,EACArrB,MAAO,aACP,OAAAD,GACI,MAAO,GAAGnB,KAAKV,QAAQitB,eAC3B,EACA,aAAAjrB,GACI,MAAO,CACHgQ,MAAO,CACHnR,QAAS,EACTC,UAAWC,GACAA,EAAQ+rB,aAAa,SACtB8W,SAAS7iC,EAAQuM,aAAa,UAAY,GAAI,IAC9C,GAItB,EACA,SAAAxM,GACI,MAAO,CACH,CACIsB,IAAK,MAGjB,EACA,UAAAlB,EAAW,eAAEU,IACT,MAAM,MAAEoQ,KAAU6gC,GAA2BjxC,EAC7C,OAAiB,IAAVoQ,EACD,CAAC,MAAM,QAAgBtR,KAAKV,QAAQ4B,eAAgBixC,GAAyB,GAC7E,CAAC,MAAM,QAAgBnyC,KAAKV,QAAQ4B,eAAgBA,GAAiB,EAC/E,EACA,WAAAT,GACI,MAAO,CACH2xC,kBAAmB,IAAM,EAAGrwC,WAAUpB,WAC9BX,KAAKV,QAAQmtB,eACN9rB,IAAQgsB,WAAW3sB,KAAKJ,KAAMI,KAAKV,QAAQitB,aAAcvsB,KAAKV,QAAQktB,WAAWvhB,iBAAiB6gB,EAASlsB,KAAMI,KAAKsC,OAAOK,cAAcwpB,EAAUvsB,OAAOiB,MAEhKkB,EAAS4qB,WAAW3sB,KAAKJ,KAAMI,KAAKV,QAAQitB,aAAcvsB,KAAKV,QAAQktB,WAG1F,EACA,oBAAArqB,GACI,MAAO,CACH,cAAe,IAAMnC,KAAKsC,OAAOP,SAASqwC,oBAElD,EACA,aAAA7vC,GACI,IAAIqqB,GAAY,QAAkB,CAC9BpqB,KAAMmG,EACNjG,KAAM1C,KAAK0C,KACXC,cAAeyG,IAAS,CAAGkI,OAAQlI,EAAM,KACzCipC,cAAe,CAACjpC,EAAOxH,IAASA,EAAK2O,WAAa3O,EAAKD,MAAM2P,SAAWlI,EAAM,KAalF,OAXIpJ,KAAKV,QAAQktB,WAAaxsB,KAAKV,QAAQmtB,kBACvCG,GAAY,QAAkB,CAC1BpqB,KAAMmG,EACNjG,KAAM1C,KAAK0C,KACX8pB,UAAWxsB,KAAKV,QAAQktB,UACxBC,eAAgBzsB,KAAKV,QAAQmtB,eAC7B9pB,cAAeyG,IAAS,CAAGkI,OAAQlI,EAAM,MAAOpJ,KAAKsC,OAAOK,cAAcwpB,EAAUvsB,QACpFyyC,cAAe,CAACjpC,EAAOxH,IAASA,EAAK2O,WAAa3O,EAAKD,MAAM2P,SAAWlI,EAAM,GAC9E9G,OAAQtC,KAAKsC,UAGd,CACHsqB,EAER,G,oFC9IJ,MAAM0lB,EAAY,KAAK3yC,OAAO,CAC1BC,KAAM,YACN+rC,SAAU,IACV,UAAA9rC,GACI,MAAO,CACHqB,eAAgB,CAAC,EAEzB,EACAE,MAAO,QACPD,QAAS,UACT,SAAAf,GACI,MAAO,CACH,CAAEsB,IAAK,KAEf,EACA,UAAAlB,EAAW,eAAEU,IACT,MAAO,CAAC,KAAK,QAAgBlB,KAAKV,QAAQ4B,eAAgBA,GAAiB,EAC/E,EACA,WAAAT,GACI,MAAO,CACH8xC,aAAc,IAAM,EAAGxwC,cACZA,EAASC,QAAQhC,KAAKJ,MAGzC,EACA,oBAAAuC,GACI,MAAO,CACH,YAAa,IAAMnC,KAAKsC,OAAOP,SAASwwC,eAEhD,G,yGC3BJ,MAAMC,EAAc,KAAU7yC,OAAO,CACjCC,KAAM,cACN,UAAAC,GACI,MAAO,CACH4yC,iBAAkB,kBAClBC,eAAgB,WAChBC,YAAa,yBACbC,sBAAsB,EACtBC,iBAAiB,EACjBC,iBAAiB,EAEzB,EACA,qBAAA5qC,GACI,MAAO,CACH,IAAI,KAAO,CACPC,IAAK,IAAI,KAAU,eACnBC,MAAO,CACHmb,YAAa,EAAG1P,MAAKV,gBACjB,MAAMo8B,EAASvvC,KAAKsC,OAAOkoB,aAAexqB,KAAKV,QAAQszC,sBACjD,OAAE56B,GAAW7E,EACboQ,EAAc,GACpB,IAAKgsB,EACD,OAAO,KAGX,MAAMwD,EAAmBl/B,EAAInR,KAAK0T,gBAC5B48B,GAAsC,OAArBD,QAAkD,IAArBA,OAA8B,EAASA,EAAiBx5B,WAAW1F,KACxD,OAAxDk/B,EAAiB5xC,QAAQ8xC,cAAcp/B,EAAI1S,SAwBlD,OAvBA0S,EAAI0G,aAAY,CAAC3Y,EAAM2G,KACnB,MAAM2qC,EAAYl7B,GAAUzP,GAAOyP,GAAUzP,EAAM3G,EAAKsO,SAClDiV,GAAWvjB,EAAKuxC,SAAWvxC,EAAK2O,WACtC,IAAK2iC,IAAclzC,KAAKV,QAAQuzC,kBAAoB1tB,EAAS,CACzD,MAAMliB,EAAU,CAACjD,KAAKV,QAAQozC,gBAC1BM,GACA/vC,EAAQ2M,KAAK5P,KAAKV,QAAQmzC,kBAE9B,MAAMW,EAAa,KAAWxxC,KAAK2G,EAAKA,EAAM3G,EAAKsO,SAAU,CACzD2I,MAAO5V,EAAQ+/B,KAAK,KACpB,mBAAwD,oBAA7BhjC,KAAKV,QAAQqzC,YAClC3yC,KAAKV,QAAQqzC,YAAY,CACvBrwC,OAAQtC,KAAKsC,OACbV,OACA2G,MACA2qC,cAEFlzC,KAAKV,QAAQqzC,cAEvBpvB,EAAY3T,KAAKwjC,EACrB,CACA,OAAOpzC,KAAKV,QAAQwzC,eAAe,IAEhC,KAAcnzC,OAAOkU,EAAK0P,EAAY,KAKjE,G,oFC1DJ,MAAM5a,EAAa,qCACb+lB,EAAa,qCACb2kB,EAAS,KAAK1zC,OAAO,CACvBC,KAAM,SACN,UAAAC,GACI,MAAO,CACHqB,eAAgB,CAAC,EAEzB,EACA,SAAAd,GACI,MAAO,CACH,CACIsB,IAAK,KAET,CACIA,IAAK,OAET,CACIA,IAAK,UAET,CACIpB,MAAO,kBACPgzC,WAAW,EACXzmC,SAAUvM,KAAUA,EAAMuB,SAAS,iBAAkB,CAAC,GAGlE,EACA,UAAArB,EAAW,eAAEU,IACT,MAAO,CAAC,KAAK,QAAgBlB,KAAKV,QAAQ4B,eAAgBA,GAAiB,EAC/E,EACA,WAAAT,GACI,MAAO,CACH8yC,UAAW,IAAM,EAAGxxC,cACTA,EAASnB,QAAQZ,KAAKJ,MAEjC4zC,aAAc,IAAM,EAAGzxC,cACZA,EAAS2pB,WAAW1rB,KAAKJ,MAEpC6zC,YAAa,IAAM,EAAG1xC,cACXA,EAAS6pB,UAAU5rB,KAAKJ,MAG3C,EACA,oBAAAuC,GACI,MAAO,CACH,cAAe,IAAMnC,KAAKsC,OAAOP,SAASyxC,eAElD,EACA,aAAAjxC,GACI,MAAO,EACH,QAAc,CACVC,KAAMmG,EACNjG,KAAM1C,KAAK0C,OAGvB,EACA,aAAAmpB,GACI,MAAO,EACH,QAAc,CACVrpB,KAAMksB,EACNhsB,KAAM1C,KAAK0C,OAGvB,G,oFC/DJ,MAAMgxC,EAAY,KAAK/zC,OAAO,CAC1BC,KAAM,YACN,UAAAC,GACI,MAAO,CACHqB,eAAgB,CAAC,EAEzB,EACA,SAAAd,GACI,MAAO,CACH,CACIsB,IAAK,OAET,CACIpB,MAAO,iBACP,QAAAuM,CAASU,GAEL,MAAc,QAAVA,GAIG,IACX,GAGZ,EACA,UAAA/M,EAAW,eAAEU,IACT,MAAO,CAAC,OAAO,QAAgBlB,KAAKV,QAAQ4B,eAAgBA,GAAiB,EACjF,EACA,WAAAT,GACI,MAAO,CACHkzC,aAAc,IAAM,EAAG5xC,cACZA,EAASnB,QAAQZ,KAAKJ,MAEjCg0C,gBAAiB,IAAM,EAAG7xC,cACfA,EAAS2pB,WAAW1rB,KAAKJ,MAEpCi0C,eAAgB,IAAM,EAAG9xC,cACdA,EAAS6pB,UAAU5rB,KAAKJ,MAG3C,EACA,oBAAAuC,GACI,MAAO,CACH,QAAS,IAAMnC,KAAKsC,OAAOP,SAAS6xC,kBAE5C,G,oFC7CJ,MAAME,EAAc,KAAKn0C,OAAO,CAC5BC,KAAM,cACN,UAAAC,GACI,MAAO,CACHqB,eAAgB,CAAC,EAEzB,EACA,SAAAd,GACI,MAAO,CACH,CACIsB,IAAK,OAET,CACIpB,MAAO,iBACP,QAAAuM,CAASU,GAEL,MAAc,UAAVA,GAIG,IACX,GAGZ,EACA,UAAA/M,EAAW,eAAEU,IACT,MAAO,CAAC,OAAO,QAAgBlB,KAAKV,QAAQ4B,eAAgBA,GAAiB,EACjF,EACA,WAAAT,GACI,MAAO,CACHszC,eAAgB,IAAM,EAAGhyC,cACdA,EAASnB,QAAQZ,KAAKJ,MAEjCo0C,kBAAmB,IAAM,EAAGjyC,cACjBA,EAAS2pB,WAAW1rB,KAAKJ,MAEpCq0C,iBAAkB,IAAM,EAAGlyC,cAChBA,EAAS6pB,UAAU5rB,KAAKJ,MAG3C,EACA,oBAAAuC,GACI,MAAO,CACH,QAAS,IAAMnC,KAAKsC,OAAOP,SAASiyC,oBAE5C,G,oFC7CJ,MAAME,EAAY,KAAKv0C,OAAO,CAC1BC,KAAM,YACN,UAAAC,GACI,MAAO,CACHqB,eAAgB,CAAC,EAEzB,EACAC,QAAS,SACT,aAAAG,GACI,MAAO,CACHuP,QAAS,CACL1Q,QAAS,GAEbyQ,QAAS,CACLzQ,QAAS,GAEbgR,SAAU,CACNhR,QAAS,KACTC,UAAWC,IACP,MAAM8Q,EAAW9Q,EAAQuM,aAAa,YAItC,OAHcuE,EACR,CAAC+xB,SAAS/xB,EAAU,KACpB,IACM,GAI5B,EACAd,UAAW,OACXiZ,WAAW,EACX,SAAAlpB,GACI,MAAO,CACH,CAAEsB,IAAK,MAEf,EACA,UAAAlB,EAAW,eAAEU,IACT,MAAO,CAAC,MAAM,QAAgBlB,KAAKV,QAAQ4B,eAAgBA,GAAiB,EAChF,G,mFCrCJ,MAAMizC,EAAc,KAAKx0C,OAAO,CAC5BC,KAAM,cACN,UAAAC,GACI,MAAO,CACHqB,eAAgB,CAAC,EAEzB,EACAC,QAAS,SACT,aAAAG,GACI,MAAO,CACHuP,QAAS,CACL1Q,QAAS,GAEbyQ,QAAS,CACLzQ,QAAS,GAEbgR,SAAU,CACNhR,QAAS,KACTC,UAAWC,IACP,MAAM8Q,EAAW9Q,EAAQuM,aAAa,YAItC,OAHcuE,EACR,CAAC+xB,SAAS/xB,EAAU,KACpB,IACM,GAI5B,EACAd,UAAW,cACXiZ,WAAW,EACX,SAAAlpB,GACI,MAAO,CACH,CAAEsB,IAAK,MAEf,EACA,UAAAlB,EAAW,eAAEU,IACT,MAAO,CAAC,MAAM,QAAgBlB,KAAKV,QAAQ4B,eAAgBA,GAAiB,EAChF,G,mFCrCJ,MAAMkzC,EAAW,KAAKz0C,OAAO,CACzBC,KAAM,WACN,UAAAC,GACI,MAAO,CACHqB,eAAgB,CAAC,EAEzB,EACAC,QAAS,6BACTkP,UAAW,MACX,SAAAjQ,GACI,MAAO,CACH,CAAEsB,IAAK,MAEf,EACA,UAAAlB,EAAW,eAAEU,IACT,MAAO,CAAC,MAAM,QAAgBlB,KAAKV,QAAQ4B,eAAgBA,GAAiB,EAChF,G,qFChBJ,MAAMyH,EAAa,yBACb0rC,EAAW,KAAK10C,OAAO,CACzBC,KAAM,WACN,UAAAC,GACI,MAAO,CACHy0C,QAAQ,EACRpzC,eAAgB,CAAC,EAEzB,EACA,OAAAC,GACI,OAAOnB,KAAKV,QAAQg1C,OAAS,mBAAqB,YACtD,EACAjzC,UAAU,EACV,aAAAC,GACI,MAAO,CACHizC,QAAS,CACLp0C,SAAS,EACTyrC,aAAa,EACbxrC,UAAWC,GAAoD,SAAzCA,EAAQuM,aAAa,gBAC3CpM,WAAYP,IAAc,CACtB,eAAgBA,EAAWs0C,WAI3C,EACA,SAAAn0C,GACI,MAAO,CACH,CACIsB,IAAK,iBAAiB1B,KAAKJ,SAC3B+rC,SAAU,IAGtB,EACA,UAAAnrC,EAAW,KAAEoB,EAAI,eAAEV,IACf,MAAO,CACH,MACA,QAAgBlB,KAAKV,QAAQ4B,eAAgBA,EAAgB,CACzD,YAAalB,KAAKJ,OAEtB,CACI,QACA,CACI,QACA,CACI8C,KAAM,WACN6xC,QAAS3yC,EAAKD,MAAM4yC,QAAU,UAAY,OAGlD,CAAC,SAEL,CAAC,MAAO,GAEhB,EACA,oBAAApyC,GACI,MAAMqyC,EAAY,CACdzoB,MAAO,IAAM/rB,KAAKsC,OAAOP,SAASiqB,cAAchsB,KAAKJ,MACrD,YAAa,IAAMI,KAAKsC,OAAOP,SAASmqB,aAAalsB,KAAKJ,OAE9D,OAAKI,KAAKV,QAAQg1C,OAGX,IACAE,EACHlqB,IAAK,IAAMtqB,KAAKsC,OAAOP,SAASkqB,aAAajsB,KAAKJ,OAJ3C40C,CAMf,EACA,WAAA1tC,GACI,MAAO,EAAGlF,OAAMV,iBAAgBuzC,SAAQnyC,aACpC,MAAMoyC,EAAWpuC,SAASgZ,cAAc,MAClCq1B,EAAkBruC,SAASgZ,cAAc,SACzCs1B,EAAiBtuC,SAASgZ,cAAc,QACxCu1B,EAAWvuC,SAASgZ,cAAc,SAClCne,EAAUmF,SAASgZ,cAAc,OA6CvC,OA5CAq1B,EAAgBtvC,gBAAkB,QAClCwvC,EAASnyC,KAAO,WAChBmyC,EAASzqC,iBAAiB,UAAU5B,IAGhC,IAAKlG,EAAOkoB,aAAexqB,KAAKV,QAAQw1C,kBAEpC,YADAD,EAASN,SAAWM,EAASN,SAGjC,MAAM,QAAEA,GAAY/rC,EAAMC,OACtBnG,EAAOkoB,YAAgC,oBAAXiqB,GAC5BnyC,EACK3B,QACAkH,WAAMR,EAAW,CAAEZ,gBAAgB,IACnCwnB,SAAQ,EAAGxX,SACZ,MAAMlT,EAAWkxC,IACXM,EAAct+B,EAAG5C,IAAI9B,OAAOxO,GAKlC,OAJAkT,EAAGsD,cAAcxW,OAAU8D,EAAW,IACf,OAAhB0tC,QAAwC,IAAhBA,OAAyB,EAASA,EAAYpzC,MACzE4yC,aAEG,CAAI,IAEV1zC,OAEJyB,EAAOkoB,YAAcxqB,KAAKV,QAAQw1C,oBAE9B90C,KAAKV,QAAQw1C,kBAAkBlzC,EAAM2yC,KACtCM,EAASN,SAAWM,EAASN,SAErC,IAEJzrB,OAAOuD,QAAQrsB,KAAKV,QAAQ4B,gBAAgB6lB,SAAQ,EAAE5e,EAAKoF,MACvDmnC,EAASM,aAAa7sC,EAAKoF,EAAM,IAErCmnC,EAASO,QAAQV,QAAU3yC,EAAKD,MAAM4yC,QAClC3yC,EAAKD,MAAM4yC,SACXM,EAASG,aAAa,UAAW,WAErCL,EAAgB75B,OAAO+5B,EAAUD,GACjCF,EAAS55B,OAAO65B,EAAiBxzC,GACjC2nB,OAAOuD,QAAQnrB,GAAgB6lB,SAAQ,EAAE5e,EAAKoF,MAC1CmnC,EAASM,aAAa7sC,EAAKoF,EAAM,IAE9B,CACHwR,IAAK21B,EACLh1B,WAAYve,EACZwe,OAAQu1B,GACAA,EAAYxyC,OAAS1C,KAAK0C,OAG9BgyC,EAASO,QAAQV,QAAUW,EAAYvzC,MAAM4yC,QACzCW,EAAYvzC,MAAM4yC,QAClBM,EAASG,aAAa,UAAW,WAGjCH,EAASM,gBAAgB,YAEtB,GAEd,CAET,EACA,aAAA5yC,GACI,MAAO,EACH,QAAkB,CACdC,KAAMmG,EACNjG,KAAM1C,KAAK0C,KACXC,cAAeyG,IAAS,CACpBmrC,QAAqC,MAA5BnrC,EAAMA,EAAMwE,OAAS,OAI9C,G,oFClJJ,MAAMwnC,EAAW,KAAKz1C,OAAO,CACzBC,KAAM,WACN,UAAAC,GACI,MAAO,CACH0sB,aAAc,WACdrrB,eAAgB,CAAC,EAEzB,EACAE,MAAO,aACP,OAAAD,GACI,MAAO,GAAGnB,KAAKV,QAAQitB,eAC3B,EACA,SAAAnsB,GACI,MAAO,CACH,CACIsB,IAAK,iBAAiB1B,KAAKJ,SAC3B+rC,SAAU,IAGtB,EACA,UAAAnrC,EAAW,eAAEU,IACT,MAAO,CAAC,MAAM,QAAgBlB,KAAKV,QAAQ4B,eAAgBA,EAAgB,CAAE,YAAalB,KAAKJ,OAAS,EAC5G,EACA,WAAAa,GACI,MAAO,CACH40C,eAAgB,IAAM,EAAGtzC,cACdA,EAAS4qB,WAAW3sB,KAAKJ,KAAMI,KAAKV,QAAQitB,cAG/D,EACA,oBAAApqB,GACI,MAAO,CACH,cAAe,IAAMnC,KAAKsC,OAAOP,SAASszC,iBAElD,G,qEClCJ,MAAMC,E,SAAY,GAAU31C,OAAO,CAC/BC,KAAM,YACN,UAAAC,GACI,MAAO,CACHC,MAAO,GACPy1C,WAAY,CAAC,OAAQ,SAAU,QAAS,WACxCC,iBAAkB,OAE1B,EACA,mBAAAz1C,GACI,MAAO,CACH,CACID,MAAOE,KAAKV,QAAQQ,MACpBG,WAAY,CACRiF,UAAW,CACP/E,QAASH,KAAKV,QAAQk2C,iBACtBp1C,UAAWC,GAAWA,EAAQC,MAAM4E,WAAalF,KAAKV,QAAQk2C,iBAC9Dh1C,WAAYP,GACJA,EAAWiF,YAAclF,KAAKV,QAAQk2C,iBAC/B,CAAC,EAEL,CAAEl1C,MAAO,eAAeL,EAAWiF,gBAMlE,EACA,WAAAzE,GACI,MAAO,CACHg1C,aAAeC,GAAc,EAAG3zC,gBACvB/B,KAAKV,QAAQi2C,WAAW1zC,SAAS6zC,IAG/B11C,KAAKV,QAAQQ,MAAM61C,OAAMjzC,GAAQX,EAASkJ,iBAAiBvI,EAAM,CAAEwC,UAAWwwC,MAEzFE,eAAgB,IAAM,EAAG7zC,cACd/B,KAAKV,QAAQQ,MAAM61C,OAAMjzC,GAAQX,EAAS8zC,gBAAgBnzC,EAAM,eAGnF,EACA,oBAAAP,GACI,MAAO,CACH,cAAe,IAAMnC,KAAKsC,OAAOP,SAAS0zC,aAAa,QACvD,cAAe,IAAMz1C,KAAKsC,OAAOP,SAAS0zC,aAAa,UACvD,cAAe,IAAMz1C,KAAKsC,OAAOP,SAAS0zC,aAAa,SACvD,cAAe,IAAMz1C,KAAKsC,OAAOP,SAAS0zC,aAAa,WAE/D,G,mFChDJ,MAAMtpB,EAAY,KAAKxsB,OAAO,CAC1BC,KAAM,YACN,UAAAC,GACI,MAAO,CACHqB,eAAgB,CAAC,EAEzB,EACA,SAAAd,GACI,MAAO,CACH,CACIsB,IAAK,OACLmL,SAAUxM,KACYA,EAAQ+rB,aAAa,UAIhC,CAAC,GAIxB,EACA,UAAA5rB,EAAW,eAAEU,IACT,MAAO,CAAC,QAAQ,QAAgBlB,KAAKV,QAAQ4B,eAAgBA,GAAiB,EAClF,EACA,WAAAT,GACI,MAAO,CACHM,qBAAsB,IAAM,EAAGmG,QAAOnF,eAClC,MAAM9B,GAAa,QAAkBiH,EAAOlH,KAAK0C,MAEjD,QADkBomB,OAAOuD,QAAQpsB,GAAY0U,MAAK,EAAE,CAAEpH,OAAaA,KAI5DxL,EAAS6pB,UAAU5rB,KAAKJ,KAAK,EAGhD,G,qECnCJ,MAAMumC,E,SAAO,GAAKxmC,OAAO,CACrBC,KAAM,OACNwB,MAAO,U,oFCFX,MAAM00C,EAAY,KAAKn2C,OAAO,CAC1BC,KAAM,YACN,UAAAC,GACI,MAAO,CACHqB,eAAgB,CAAC,EAEzB,EACA,SAAAd,GACI,MAAO,CACH,CACIsB,IAAK,KAET,CACIpB,MAAO,kBACPgzC,WAAW,EACXzmC,SAAUvM,KAAUA,EAAMuB,SAAS,cAAe,CAAC,GAG/D,EACA,UAAArB,EAAW,eAAEU,IACT,MAAO,CAAC,KAAK,QAAgBlB,KAAKV,QAAQ4B,eAAgBA,GAAiB,EAC/E,EACA,WAAAT,GACI,MAAO,CACHs1C,aAAc,IAAM,EAAGh0C,cACZA,EAASnB,QAAQZ,KAAKJ,MAEjCo2C,gBAAiB,IAAM,EAAGj0C,cACfA,EAAS2pB,WAAW1rB,KAAKJ,MAEpCq2C,eAAgB,IAAM,EAAGl0C,cACdA,EAAS6pB,UAAU5rB,KAAKJ,MAG3C,EACA,oBAAAuC,GACI,MAAO,CACH,QAAS,IAAMnC,KAAKsC,OAAOP,SAASi0C,kBACpC,QAAS,IAAMh2C,KAAKsC,OAAOP,SAASi0C,kBAE5C,G","sources":["webpack://app/./node_modules/lodash/throttle.js","webpack://app/./node_modules/mui-tiptap/dist/esm/extensions/FontSize.js","webpack://app/./node_modules/@tiptap/extension-heading/dist/index.js","webpack://app/./node_modules/mui-tiptap/dist/esm/extensions/HeadingWithAnchorComponent.js","webpack://app/./node_modules/mui-tiptap/dist/esm/utils/slugify.js","webpack://app/./node_modules/mui-tiptap/dist/esm/extensions/HeadingWithAnchor.js","webpack://app/./node_modules/mui-tiptap/dist/esm/extensions/LinkBubbleMenuHandler.js","webpack://app/./node_modules/@tiptap/extension-image/dist/index.js","webpack://app/./node_modules/mui-tiptap/dist/esm/extensions/ResizableImageResizer.js","webpack://app/./node_modules/mui-tiptap/dist/esm/extensions/ResizableImageComponent.js","webpack://app/./node_modules/mui-tiptap/dist/esm/extensions/ResizableImage.js","webpack://app/./node_modules/prosemirror-tables/dist/index.js","webpack://app/./node_modules/@tiptap/extension-table/dist/index.js","webpack://app/./node_modules/mui-tiptap/dist/esm/extensions/TableImproved.js","webpack://app/./node_modules/@tiptap/extension-blockquote/dist/index.js","webpack://app/./node_modules/@tiptap/extension-bold/dist/index.js","webpack://app/./node_modules/@tiptap/extension-bullet-list/dist/index.js","webpack://app/./node_modules/@tiptap/extension-code-block/dist/index.js","webpack://app/./node_modules/@tiptap/extension-code/dist/index.js","webpack://app/./node_modules/@tiptap/extension-color/dist/index.js","webpack://app/./node_modules/@tiptap/extension-document/dist/index.js","webpack://app/./node_modules/prosemirror-dropcursor/dist/index.js","webpack://app/./node_modules/@tiptap/extension-dropcursor/dist/index.js","webpack://app/./node_modules/@tiptap/extension-font-family/dist/index.js","webpack://app/./node_modules/prosemirror-gapcursor/dist/index.js","webpack://app/./node_modules/@tiptap/extension-gapcursor/dist/index.js","webpack://app/./node_modules/@tiptap/extension-hard-break/dist/index.js","webpack://app/./node_modules/@tiptap/extension-highlight/dist/index.js","webpack://app/./node_modules/rope-sequence/dist/index.js","webpack://app/./node_modules/prosemirror-history/dist/index.js","webpack://app/./node_modules/@tiptap/extension-history/dist/index.js","webpack://app/./node_modules/@tiptap/extension-horizontal-rule/dist/index.js","webpack://app/./node_modules/@tiptap/extension-italic/dist/index.js","webpack://app/./node_modules/linkifyjs/dist/linkify.es.js","webpack://app/./node_modules/@tiptap/extension-link/dist/index.js","webpack://app/./node_modules/@tiptap/extension-list-item/dist/index.js","webpack://app/./node_modules/@tiptap/suggestion/dist/index.js","webpack://app/./node_modules/@tiptap/extension-mention/dist/index.js","webpack://app/./node_modules/@tiptap/extension-ordered-list/dist/index.js","webpack://app/./node_modules/@tiptap/extension-paragraph/dist/index.js","webpack://app/./node_modules/@tiptap/extension-placeholder/dist/index.js","webpack://app/./node_modules/@tiptap/extension-strike/dist/index.js","webpack://app/./node_modules/@tiptap/extension-subscript/dist/index.js","webpack://app/./node_modules/@tiptap/extension-superscript/dist/index.js","webpack://app/./node_modules/@tiptap/extension-table-cell/dist/index.js","webpack://app/./node_modules/@tiptap/extension-table-header/dist/index.js","webpack://app/./node_modules/@tiptap/extension-table-row/dist/index.js","webpack://app/./node_modules/@tiptap/extension-task-item/dist/index.js","webpack://app/./node_modules/@tiptap/extension-task-list/dist/index.js","webpack://app/./node_modules/@tiptap/extension-text-align/dist/index.js","webpack://app/./node_modules/@tiptap/extension-text-style/dist/index.js","webpack://app/./node_modules/@tiptap/extension-text/dist/index.js","webpack://app/./node_modules/@tiptap/extension-underline/dist/index.js"],"sourcesContent":["var debounce = require('./debounce'),\n    isObject = require('./isObject');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * Creates a throttled function that only invokes `func` at most once per\n * every `wait` milliseconds. The throttled function comes with a `cancel`\n * method to cancel delayed `func` invocations and a `flush` method to\n * immediately invoke them. Provide `options` to indicate whether `func`\n * should be invoked on the leading and/or trailing edge of the `wait`\n * timeout. The `func` is invoked with the last arguments provided to the\n * throttled function. Subsequent calls to the throttled function return the\n * result of the last `func` invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the throttled function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.throttle` and `_.debounce`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to throttle.\n * @param {number} [wait=0] The number of milliseconds to throttle invocations to.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=true]\n *  Specify invoking on the leading edge of the timeout.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new throttled function.\n * @example\n *\n * // Avoid excessively updating the position while scrolling.\n * jQuery(window).on('scroll', _.throttle(updatePosition, 100));\n *\n * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.\n * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });\n * jQuery(element).on('click', throttled);\n *\n * // Cancel the trailing throttled invocation.\n * jQuery(window).on('popstate', throttled.cancel);\n */\nfunction throttle(func, wait, options) {\n  var leading = true,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  if (isObject(options)) {\n    leading = 'leading' in options ? !!options.leading : leading;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n  return debounce(func, wait, {\n    'leading': leading,\n    'maxWait': wait,\n    'trailing': trailing\n  });\n}\n\nmodule.exports = throttle;\n","/// <reference types=\"@tiptap/extension-text-style\" />\nimport { Extension } from \"@tiptap/core\";\n/**\n * Allow for setting the font size of text. Requires the TextStyle extension\n * https://tiptap.dev/api/marks/text-style, as Tiptap suggests.\n */\nconst FontSize = Extension.create({\n    name: \"fontSize\",\n    addOptions() {\n        return {\n            types: [\"textStyle\"],\n        };\n    },\n    addGlobalAttributes() {\n        return [\n            {\n                types: this.options.types,\n                attributes: {\n                    fontSize: {\n                        default: null,\n                        parseHTML: (element) => element.style.fontSize.replace(/['\"]+/g, \"\"),\n                        renderHTML: (attributes) => {\n                            if (!attributes.fontSize) {\n                                return {};\n                            }\n                            return {\n                                style: `font-size: ${attributes.fontSize}`,\n                            };\n                        },\n                    },\n                },\n            },\n        ];\n    },\n    addCommands() {\n        return {\n            setFontSize: (fontSize) => ({ chain }) => {\n                return chain().setMark(\"textStyle\", { fontSize }).run();\n            },\n            unsetFontSize: () => ({ chain }) => {\n                return chain()\n                    .setMark(\"textStyle\", { fontSize: null })\n                    .removeEmptyTextStyle()\n                    .run();\n            },\n        };\n    },\n});\nexport default FontSize;\n","import { Node, mergeAttributes, textblockTypeInputRule } from '@tiptap/core';\n\nconst Heading = Node.create({\r\n    name: 'heading',\r\n    addOptions() {\r\n        return {\r\n            levels: [1, 2, 3, 4, 5, 6],\r\n            HTMLAttributes: {},\r\n        };\r\n    },\r\n    content: 'inline*',\r\n    group: 'block',\r\n    defining: true,\r\n    addAttributes() {\r\n        return {\r\n            level: {\r\n                default: 1,\r\n                rendered: false,\r\n            },\r\n        };\r\n    },\r\n    parseHTML() {\r\n        return this.options.levels\r\n            .map((level) => ({\r\n            tag: `h${level}`,\r\n            attrs: { level },\r\n        }));\r\n    },\r\n    renderHTML({ node, HTMLAttributes }) {\r\n        const hasLevel = this.options.levels.includes(node.attrs.level);\r\n        const level = hasLevel\r\n            ? node.attrs.level\r\n            : this.options.levels[0];\r\n        return [`h${level}`, mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];\r\n    },\r\n    addCommands() {\r\n        return {\r\n            setHeading: attributes => ({ commands }) => {\r\n                if (!this.options.levels.includes(attributes.level)) {\r\n                    return false;\r\n                }\r\n                return commands.setNode(this.name, attributes);\r\n            },\r\n            toggleHeading: attributes => ({ commands }) => {\r\n                if (!this.options.levels.includes(attributes.level)) {\r\n                    return false;\r\n                }\r\n                return commands.toggleNode(this.name, 'paragraph', attributes);\r\n            },\r\n        };\r\n    },\r\n    addKeyboardShortcuts() {\r\n        return this.options.levels.reduce((items, level) => ({\r\n            ...items,\r\n            ...{\r\n                [`Mod-Alt-${level}`]: () => this.editor.commands.toggleHeading({ level }),\r\n            },\r\n        }), {});\r\n    },\r\n    addInputRules() {\r\n        return this.options.levels.map(level => {\r\n            return textblockTypeInputRule({\r\n                find: new RegExp(`^(#{1,${level}})\\\\s$`),\r\n                type: this.type,\r\n                getAttributes: {\r\n                    level,\r\n                },\r\n            });\r\n        });\r\n    },\r\n});\n\nexport { Heading, Heading as default };\n//# sourceMappingURL=index.js.map\n","import { jsx as _jsx, jsxs as _jsxs } from \"react/jsx-runtime\";\nimport { Link as LinkIcon } from \"@mui/icons-material\";\nimport { getText, getTextSerializersFromSchema, } from \"@tiptap/core\";\nimport { NodeViewContent, NodeViewWrapper } from \"@tiptap/react\";\nimport { useMemo } from \"react\";\nimport { makeStyles } from \"tss-react/mui\";\nimport { getUtilityClasses } from \"../styles\";\nimport slugify from \"../utils/slugify\";\n// eslint-disable-next-line @typescript-eslint/no-invalid-void-type\nconst useStyles = makeStyles({\n    name: { HeadingWithAnchorComponent },\n    uniqId: \"kNc4LD\", // https://docs.tss-react.dev/nested-selectors#ssr\n})((theme, _params, classes) => ({\n    root: {\n        // Reference the \"link\" class defined below so that when the header is\n        // hovered over, we make the anchor link visible.\n        [`&:hover .${classes.link}`]: {\n            opacity: 100,\n        },\n    },\n    container: {\n        // Use inline-block so that the container is only as big as the inner\n        // heading content\n        display: \"inline-block\",\n        // Use relative position so that the link is positioned relative to\n        // the inner heading content position (via this common container)\n        position: \"relative\",\n    },\n    link: {\n        position: \"absolute\",\n        left: -21,\n        color: `${theme.palette.text.secondary} !important`,\n        opacity: 0,\n        transition: theme.transitions.create(\"opacity\"),\n        textDecoration: \"none\",\n        outline: \"none\",\n        [theme.breakpoints.down(\"sm\")]: {\n            left: -18,\n        },\n        // As described here https://github.com/ueberdosis/tiptap/issues/3775,\n        // updates to editor isEditable do not trigger re-rendering of node views.\n        // Even editor state changes external to a given ReactNodeView component\n        // will not trigger re-render (which is probably a good thing most of the\n        // time, in terms of performance). As such, we always render the link in the\n        // DOM, but hide it with CSS when the editor is editable.\n        '.ProseMirror[contenteditable=\"true\"] &': {\n            display: \"none\",\n        },\n    },\n    linkIcon: {\n        // Looks better to have at an angle, similar to the GitHub icon\n        transform: \"rotate(-45deg)\",\n        fontSize: \"1.25rem\",\n        [theme.breakpoints.down(\"sm\")]: {\n            fontSize: \"1.15rem\",\n        },\n    },\n}));\nconst headingWithAnchorComponentClasses = getUtilityClasses(HeadingWithAnchorComponent.name, [\n    \"root\",\n    \"container\",\n    \"link\",\n    \"linkIcon\",\n]);\nexport default function HeadingWithAnchorComponent({ editor, node, extension, }) {\n    const { classes, cx } = useStyles();\n    // Some of the logic here is based on the renderHTML definition from the\n    // original Heading Node\n    // (https://github.com/ueberdosis/tiptap/blob/c9eb6a6299796450c7c1cfdc3552d76070c78c65/packages/extension-heading/src/heading.ts#L58-L65)\n    const hasLevel = extension.options.levels.includes(node.attrs.level);\n    const level = hasLevel ? node.attrs.level : extension.options.levels[0];\n    const HeadingTag = `h${level}`;\n    // Create an anchor ID based on the text content of the header (like\n    // GitHub/GitLab do). Note that we use Tiptap's `getText` rather than\n    // `node.textContent` so that nodes like Mentions can produce text for this\n    // purpose (see https://github.com/ueberdosis/tiptap/pull/1875 and\n    // https://github.com/ueberdosis/tiptap/issues/1336 for instance)\n    const textSerializers = useMemo(() => getTextSerializersFromSchema(editor.schema), [editor.schema]);\n    const headingId = slugify(getText(node, {\n        textSerializers: textSerializers,\n    }));\n    return (_jsx(NodeViewWrapper, { as: HeadingTag, id: headingId, ...extension.options.HTMLAttributes, className: cx(headingWithAnchorComponentClasses.root, classes.root), \n        // Handle @tiptap/extension-text-align. Ideally we'd be able to inherit\n        // this style from TextAlign's GlobalAttributes directly, but those are\n        // only applied via `renderHTML` and not the `NodeView` renderer\n        // (https://github.com/ueberdosis/tiptap/blob/6c34dec33ac39c9f037a0a72e4525f3fc6d422bf/packages/extension-text-align/src/text-align.ts#L43-L49),\n        // so we have to do this manually/redundantly here.\n        style: { textAlign: node.attrs.textAlign }, children: _jsxs(\"span\", { className: cx(headingWithAnchorComponentClasses.container, classes.container), children: [_jsx(\"a\", { href: `#${headingId}`, contentEditable: false, className: cx(headingWithAnchorComponentClasses.link, classes.link), children: _jsx(LinkIcon, { className: cx(headingWithAnchorComponentClasses.linkIcon, classes.linkIcon) }) }), _jsx(NodeViewContent, { as: \"span\" })] }) }));\n}\n","/** Convert a string to a URL slug. */\nexport default function slugify(text) {\n    // This is nearly a direct port of Django's slugify, minus the unicode\n    // handling, since regex in JS doesn't seem to handle unicode chars as a part\n    // of \\w (see here https://mathiasbynens.be/notes/es6-unicode-regex for more\n    // details).\n    // https://docs.djangoproject.com/en/4.0/ref/utils/#django.utils.text.slugify\n    // https://github.com/django/django/blob/7119f40c9881666b6f9b5cf7df09ee1d21cc8344/django/utils/text.py#L399-L417\n    // Copyright (c) Django Software Foundation and individual contributors.\n    // All rights reserved.\n    return (text\n        .toLowerCase()\n        // Convert to nearest compatible ascii chars\n        // (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize)\n        .normalize(\"NFKD\")\n        // Remove characters that aren’t alphanumerics, underscores, hyphens, or\n        // whitespace\n        .replace(/[^\\w\\s-]+/g, \"\")\n        // Replace any whitespace or repeated dashes with single dashes\n        .replace(/[-\\s]+/g, \"-\")\n        // Remove leading and trailing whitespace, dashes, and underscores\n        .replace(/^[\\s-_]+|[\\s-_]+$/g, \"\"));\n}\n","import { Heading } from \"@tiptap/extension-heading\";\nimport { ReactNodeViewRenderer } from \"@tiptap/react\";\nimport HeadingWithAnchorComponent from \"./HeadingWithAnchorComponent\";\n/**\n * A modified version of Tiptap’s `Heading` extension\n * (https://tiptap.dev/api/nodes/heading), with dynamic GitHub-like anchor links\n * for every heading you add. An anchor link button appears to the left of each\n * heading when you hovering over it, when the `editor` has `editable` set to\n * `false`. This allows users to share links and jump to specific headings\n * within your rendered editor content. It can also accommodate building a table\n * of contents or outline more easily.\n */\nconst HeadingWithAnchor = Heading.extend({\n    addOptions() {\n        var _a;\n        return {\n            // Tiptap claims this.parent can be undefined, so disable this eslint rule\n            // https://tiptap.dev/guide/custom-extensions/#extend-existing-attributes\n            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n            ...(_a = this.parent) === null || _a === void 0 ? void 0 : _a.call(this),\n            scrollToAnchorOnMount: true,\n        };\n    },\n    onCreate() {\n        // It seems that when `onCreate` is called via this extension `onCreate`\n        // definition, our content and HeadingWithAnchor React node-views have yet\n        // to be rendered. (Also notably, react renderers are async so don't appear\n        // even when the rest of the document HTML first shows up, as mentioned in\n        // https://github.com/ueberdosis/tiptap/issues/1527#issuecomment-888380206.)\n        // Delaying until the end of the event loop with setTimeout should do the\n        // trick.\n        if (this.options.scrollToAnchorOnMount) {\n            setTimeout(() => {\n                scrollToCurrentHeadingAnchor(this.editor);\n            });\n        }\n    },\n    // Although we could render this using just HTML presumably (via `renderHTML`)\n    // and don't need any fancy interaction with React, doing so allows us to use\n    // a MUI SVG icon as well as MUI styling\n    addNodeView() {\n        return ReactNodeViewRenderer(HeadingWithAnchorComponent);\n    },\n});\nexport default HeadingWithAnchor;\n/**\n * If there's a URL hash string indicating we should be anchored to a specific\n * heading, this function scrolls to that heading.\n *\n * We have to do this manually/programmatically after first render using this\n * function, since when the page first loads, the editor content will not be\n * mounted/rendered, so the browser doesn't move to the anchor automatically\n * just from having the anchor in the URL. Note that we only want to do this\n * once on mount/create.\n */\nexport function scrollToCurrentHeadingAnchor(editor) {\n    if (editor.isDestroyed || !(\"heading\" in editor.storage)) {\n        // If the editor is already removed/destroyed, or the heading extension\n        // isn't enabled, we can stop\n        return;\n    }\n    const currentHash = window.location.hash;\n    const elementId = currentHash.slice(1);\n    if (!elementId) {\n        return;\n    }\n    const elementForHash = window.document.getElementById(elementId);\n    // We'll only scroll if the given hash points to an element that's part of our\n    // editor content (i.e., ignore external anchors)\n    if (elementForHash && editor.options.element.contains(elementForHash)) {\n        elementForHash.scrollIntoView({\n            behavior: \"smooth\",\n            block: \"start\",\n            inline: \"nearest\",\n        });\n    }\n}\n","import { Extension, getAttributes } from \"@tiptap/core\";\nimport { Plugin, PluginKey } from \"@tiptap/pm/state\";\nexport var LinkMenuState;\n(function (LinkMenuState) {\n    LinkMenuState[LinkMenuState[\"HIDDEN\"] = 0] = \"HIDDEN\";\n    LinkMenuState[LinkMenuState[\"VIEW_LINK_DETAILS\"] = 1] = \"VIEW_LINK_DETAILS\";\n    LinkMenuState[LinkMenuState[\"EDIT_LINK\"] = 2] = \"EDIT_LINK\";\n})(LinkMenuState || (LinkMenuState = {}));\n/**\n * To be used in conjunction with the `LinkBubbleMenu` component, as this\n * extension provides editor commands to control the state of the link bubble\n * menu.\n *\n * The Tiptap Link extension (@tiptap/extension-link) should also be installed\n * and included in your extensions when using LinkBubbleMenuHandler:\n * https://tiptap.dev/api/marks/link.\n */\nconst LinkBubbleMenuHandler = Extension.create({\n    name: \"linkBubbleMenuHandler\",\n    addStorage() {\n        return {\n            state: LinkMenuState.HIDDEN,\n            bubbleMenuOptions: undefined,\n        };\n    },\n    addCommands() {\n        return {\n            openLinkBubbleMenu: (bubbleMenuOptions = {}) => ({ editor, chain, dispatch }) => {\n                const currentMenuState = this.storage.state;\n                let newMenuState;\n                if (editor.isActive(\"link\")) {\n                    // If their cursor is currently on a link, we'll open the link menu to\n                    // view the details.\n                    if (currentMenuState !== LinkMenuState.VIEW_LINK_DETAILS) {\n                        // If the user isn't already in the \"View Link Details\" menu, we'll first\n                        // change the selection to encompass the entire link to make it obvious which\n                        // link is being edited and what text it includes. We also focus in case the\n                        // user clicked the Link menu button (so we re-focus on the editor).\n                        // NOTE: there is a bug in Tiptap where `extendMarkRange` will not\n                        // work despite `isActive(\"link\")` having returning true if the\n                        // click/cursor is at the end of a link\n                        // https://github.com/ueberdosis/tiptap/issues/2535. This leads to\n                        // confusing behavior and should probably be handled with a workaround\n                        // (like checking whether `extendMarkRange` had any effect) so that we\n                        // don't open the link menu unless we know we've selected the entire\n                        // link.\n                        chain().extendMarkRange(\"link\").focus().run();\n                    }\n                    newMenuState = LinkMenuState.VIEW_LINK_DETAILS;\n                }\n                else {\n                    // Otherwise open the edit link menu for the user to add a new link\n                    newMenuState = LinkMenuState.EDIT_LINK;\n                }\n                if (dispatch) {\n                    // Only change the state if this is not a dry-run\n                    // https://tiptap.dev/api/commands#dry-run-for-commands. Note that\n                    // this happens automatically for the Tiptap built-in commands\n                    // called with `chain()` above.\n                    this.storage.state = newMenuState;\n                    this.storage.bubbleMenuOptions = bubbleMenuOptions;\n                }\n                return true;\n            },\n            editLinkInBubbleMenu: () => ({ dispatch }) => {\n                const currentMenuState = this.storage.state;\n                const newMenuState = LinkMenuState.EDIT_LINK;\n                if (currentMenuState === newMenuState) {\n                    return false;\n                }\n                if (dispatch) {\n                    // Only change the state if this is not a dry-run\n                    // https://tiptap.dev/api/commands#dry-run-for-commands.\n                    this.storage.state = newMenuState;\n                }\n                return true;\n            },\n            closeLinkBubbleMenu: () => ({ commands, dispatch }) => {\n                const currentMenuState = this.storage.state;\n                if (currentMenuState === LinkMenuState.HIDDEN) {\n                    return false;\n                }\n                // Re-focus on the editor (e.g. for re-selection) since the user was\n                // previously editing and has now canceled\n                commands.focus();\n                if (dispatch) {\n                    // Only change the state if this is not a dry-run\n                    // https://tiptap.dev/api/commands#dry-run-for-commands. Note that\n                    // this happens automatically for the Tiptap built-in commands\n                    // called with `commands` above.\n                    this.storage.state = LinkMenuState.HIDDEN;\n                }\n                return true;\n            },\n        };\n    },\n    onSelectionUpdate() {\n        // To ensure we maintain the proper bubble menu state, if someone is\n        // viewing/editing a link but moves off of it (e.g. with their keyboard\n        // arrow keys, or by clicking out, or by typing over the currently selected\n        // link), we'll close the bubble menu. Note that when in \"view\" mode (and\n        // not \"edit\") for an existing link, we only close if the state shows the\n        // user is not on an active link anymore, since the selection can be updated\n        // via `openLinkBubbleMenu` (and we don't want to immediately close it upon\n        // initial opening of the bubble menu). By contrast in \"edit\" mode, the\n        // user's focus should be in the edit form and selection shouldn't\n        // automatically update during opening or otherwise, so clicking out (i.e.\n        // changing selection) definitively indicates cancellation.\n        // onSelectionUpdate runs before handleClick, so we need to promptly close\n        // in that scenario.\n        if (this.storage.state === LinkMenuState.EDIT_LINK) {\n            this.editor.commands.closeLinkBubbleMenu();\n        }\n        else if (this.storage.state === LinkMenuState.VIEW_LINK_DETAILS &&\n            !this.editor.isActive(\"link\")) {\n            this.editor.commands.closeLinkBubbleMenu();\n        }\n    },\n    addKeyboardShortcuts() {\n        return {\n            \"Mod-Shift-u\": () => {\n                this.editor.commands.openLinkBubbleMenu();\n                return true;\n            },\n        };\n    },\n    addProseMirrorPlugins() {\n        return [\n            new Plugin({\n                key: new PluginKey(\"handleClickLinkForMenu\"),\n                props: {\n                    handleClick: (view, pos, event) => {\n                        const attrs = getAttributes(view.state, \"link\");\n                        const link = event.target.closest(\"a\");\n                        // If the user has clicked on a link and the menu isn't already\n                        // open, we'll open it. Otherwise we close it. (Closing the menu if\n                        // it's already open allows a user to put their cursor at a specific\n                        // point within the link text and implicitly close the bubble menu,\n                        // like the Slack UI does, if they don't want to use the bubble menu\n                        // but instead want to use regular cursor/keyboard interaction with\n                        // the link text.)\n                        if (link &&\n                            attrs.href &&\n                            this.storage.state === LinkMenuState.HIDDEN) {\n                            this.editor.commands.openLinkBubbleMenu();\n                        }\n                        else {\n                            this.editor.commands.closeLinkBubbleMenu();\n                        }\n                        // Return false so that the click still propagates to any other\n                        // handlers, without `preventDefault` (see note on boolean return\n                        // values here https://prosemirror.net/docs/ref/#view.EditorProps)\n                        return false;\n                    },\n                },\n            }),\n        ];\n    },\n});\nexport default LinkBubbleMenuHandler;\n","import { Node, mergeAttributes, nodeInputRule } from '@tiptap/core';\n\nconst inputRegex = /(?:^|\\s)(!\\[(.+|:?)]\\((\\S+)(?:(?:\\s+)[\"'](\\S+)[\"'])?\\))$/;\r\nconst Image = Node.create({\r\n    name: 'image',\r\n    addOptions() {\r\n        return {\r\n            inline: false,\r\n            allowBase64: false,\r\n            HTMLAttributes: {},\r\n        };\r\n    },\r\n    inline() {\r\n        return this.options.inline;\r\n    },\r\n    group() {\r\n        return this.options.inline ? 'inline' : 'block';\r\n    },\r\n    draggable: true,\r\n    addAttributes() {\r\n        return {\r\n            src: {\r\n                default: null,\r\n            },\r\n            alt: {\r\n                default: null,\r\n            },\r\n            title: {\r\n                default: null,\r\n            },\r\n        };\r\n    },\r\n    parseHTML() {\r\n        return [\r\n            {\r\n                tag: this.options.allowBase64\r\n                    ? 'img[src]'\r\n                    : 'img[src]:not([src^=\"data:\"])',\r\n            },\r\n        ];\r\n    },\r\n    renderHTML({ HTMLAttributes }) {\r\n        return ['img', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes)];\r\n    },\r\n    addCommands() {\r\n        return {\r\n            setImage: options => ({ commands }) => {\r\n                return commands.insertContent({\r\n                    type: this.name,\r\n                    attrs: options,\r\n                });\r\n            },\r\n        };\r\n    },\r\n    addInputRules() {\r\n        return [\r\n            nodeInputRule({\r\n                find: inputRegex,\r\n                type: this.type,\r\n                getAttributes: match => {\r\n                    const [, , alt, src, title] = match;\r\n                    return { src, alt, title };\r\n                },\r\n            }),\r\n        ];\r\n    },\r\n});\n\nexport { Image, Image as default, inputRegex };\n//# sourceMappingURL=index.js.map\n","import { jsx as _jsx } from \"react/jsx-runtime\";\nimport { useCallback, useEffect, useState } from \"react\";\nimport { makeStyles } from \"tss-react/mui\";\nconst useStyles = makeStyles({ name: { ResizableImageResizer } })((theme) => ({\n    root: {\n        position: \"absolute\",\n        // The `outline` styles of the selected image add 3px to the edges, so we'll\n        // position this offset by 3px outside to the bottom right\n        bottom: -3,\n        right: -3,\n        width: 12,\n        height: 12,\n        background: theme.palette.primary.main,\n        cursor: \"nwse-resize\",\n    },\n}));\nexport function ResizableImageResizer({ onResize, className, }) {\n    const { classes, cx } = useStyles();\n    const [mouseDown, setMouseDown] = useState(false);\n    useEffect(() => {\n        const handleMouseMove = (event) => {\n            onResize(event);\n        };\n        if (mouseDown) {\n            // If the user is currently holding down the resize handle, we'll have mouse\n            // movements fire the onResize callback (since the user would be \"dragging\" the\n            // handle)\n            window.addEventListener(\"mousemove\", handleMouseMove);\n        }\n        return () => {\n            window.removeEventListener(\"mousemove\", handleMouseMove);\n        };\n    }, [mouseDown, onResize]);\n    useEffect(() => {\n        const handleMouseUp = () => setMouseDown(false);\n        window.addEventListener(\"mouseup\", handleMouseUp);\n        return () => {\n            window.removeEventListener(\"mouseup\", handleMouseUp);\n        };\n    }, []);\n    const handleMouseDown = useCallback((_event) => {\n        setMouseDown(true);\n    }, []);\n    return (\n    // There isn't a great role to use here (perhaps role=\"separator\" is the\n    // closest, as described here https://stackoverflow.com/a/43022983/4543977,\n    // but we don't do keyboard-based resizing at this time so it doesn't make\n    // sense to have it keyboard focusable)\n    // eslint-disable-next-line jsx-a11y/no-static-element-interactions\n    _jsx(\"div\", { \n        // TODO(Steven DeMartini): Add keyboard support and better accessibility\n        // here, and allow users to override the aria-label when that happens to\n        // support localization.\n        // aria-label=\"resize image\"\n        className: cx(classes.root, className), onMouseDown: handleMouseDown }));\n}\n","import { jsx as _jsx, jsxs as _jsxs } from \"react/jsx-runtime\";\nimport { NodeViewWrapper } from \"@tiptap/react\";\nimport throttle from \"lodash/throttle\";\nimport { useMemo, useRef } from \"react\";\nimport { makeStyles } from \"tss-react/mui\";\nimport { ResizableImageResizer } from \"./ResizableImageResizer\";\nconst IMAGE_MINIMUM_WIDTH_PIXELS = 15;\nconst useStyles = makeStyles({ name: { ResizableImageComponent } })((theme) => ({\n    imageContainer: {\n        // Use inline-block so that the container is only as big as the inner\n        // img\n        display: \"inline-block\",\n        // Use relative position so that the resizer is positioned relative to\n        // the img dimensions (via their common container)\n        position: \"relative\",\n    },\n    image: {\n        // We need display:block in order for the container element to be\n        // sized properly (no extra space below the image)\n        display: \"block\",\n    },\n    imageSelected: {\n        // This \"selected\" state outline style is copied from our standard editor\n        // styles (which are kept there as well so they appear even if not using our\n        // custom resizable image).\n        outline: `3px solid ${theme.palette.primary.main}`,\n    },\n    resizer: {\n        // As described here https://github.com/ueberdosis/tiptap/issues/3775,\n        // updates to editor isEditable do not trigger re-rendering of node views.\n        // Even editor state changes external to a given ReactNodeView component\n        // will not trigger re-render (which is probably a good thing most of the\n        // time, in terms of performance). As such, we always render the resizer\n        // component with React (and so in the DOM), but hide it with CSS when the\n        // editor is not editable. This also means its mouse event listeners will\n        // also not fire, as intended.\n        '.ProseMirror[contenteditable=\"false\"] &': {\n            display: \"none\",\n        },\n    },\n}));\nfunction ResizableImageComponent({ node, selected, updateAttributes }) {\n    var _a;\n    const { classes, cx } = useStyles();\n    const { attrs } = node;\n    const imageRef = useRef(null);\n    const handleResize = useMemo(() => \n    // Throttle our \"on resize\" handler, since the event fires very rapidly during\n    // dragging, so rendering would end up stuttering a bit without a throttle\n    throttle((event) => {\n        if (!imageRef.current) {\n            return;\n        }\n        const originalBoundingRect = imageRef.current.getBoundingClientRect();\n        // Get the \"width\" and \"height\" of the resized image based on the user's\n        // cursor position after movement, if we were to imagine a box drawn from\n        // the top left corner of the image to their cursor. (clientX/Y and\n        // getBoundingClientRect both reference positions relative to the viewport,\n        // allowing us to use them to calculate the new \"resized\" image dimensions.)\n        const resizedWidth = event.clientX - originalBoundingRect.x;\n        const resizedHeight = event.clientY - originalBoundingRect.y;\n        // We always preserve the original image aspect ratio, setting only the\n        // `width` to a specific number upon resize (and leaving the `height` of the\n        // `img` as \"auto\"). So to determine the new width, we'll take the larger of\n        // (a) the new resized width after the user's latest drag resize movement,\n        // (b) the width proportional to the new resized height given the image\n        // aspect ratio, or (c) a minimum width to prevent mistakes. This is similar\n        // to what Google Docs image resizing appears to be doing, which feels\n        // intuitive.\n        const resultantWidth = Math.max(resizedWidth, (originalBoundingRect.width / originalBoundingRect.height) *\n            resizedHeight, \n        // Set a minimum width, since any smaller is probably a mistake, and we\n        // don't want images to get mistakenly shrunken below a size which makes\n        // it hard to later select/resize the image\n        IMAGE_MINIMUM_WIDTH_PIXELS);\n        updateAttributes({\n            width: Math.round(resultantWidth),\n        });\n    }, 50, { trailing: true } // Make sure our last event triggers a callback\n    ), [updateAttributes]);\n    return (_jsx(NodeViewWrapper, { style: {\n            // Handle @tiptap/extension-text-align. Ideally we'd be able to inherit\n            // this style from TextAlign's GlobalAttributes directly, but those are\n            // only applied via `renderHTML` and not the `NodeView` renderer\n            // (https://github.com/ueberdosis/tiptap/blob/6c34dec33ac39c9f037a0a72e4525f3fc6d422bf/packages/extension-text-align/src/text-align.ts#L43-L49),\n            // so we have to do this manually/redundantly here.\n            textAlign: attrs.textAlign,\n            width: \"100%\",\n        }, children: _jsxs(\"div\", { className: classes.imageContainer, children: [_jsx(\"img\", { ref: imageRef, src: attrs.src, height: \"auto\", width: attrs.width ? attrs.width : undefined, \n                    // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing\n                    alt: attrs.alt || undefined,\n                    // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing\n                    title: attrs.title || undefined, className: cx(classes.image, \n                    // For consistency with the standard Image extension selection\n                    // class/UI:\n                    selected && \"ProseMirror-selectednode\", \n                    // We'll only show the outline when the editor content is selected\n                    selected && classes.imageSelected), style: {\n                        // If no width has been specified, we use auto max-width\n                        maxWidth: attrs.width ? undefined : \"auto\",\n                        // Always specify the aspect-ratio if it's been defined, to improve\n                        // initial render (so auto-height works before the image loads)\n                        aspectRatio: (_a = attrs.aspectRatio) !== null && _a !== void 0 ? _a : undefined,\n                    }, \"data-drag-handle\": true, \n                    // When the image loads, we'll update our width and aspect-ratio based\n                    // on the image's natural size, if they're not set. That way, all future\n                    // renders will know the image width/height prior to load/render,\n                    // preventing flashing\n                    onLoad: (event) => {\n                        const newAttributes = {};\n                        if (!attrs.width) {\n                            newAttributes.width = event.currentTarget.naturalWidth;\n                        }\n                        if (!attrs.aspectRatio) {\n                            newAttributes.aspectRatio = String(event.currentTarget.naturalWidth /\n                                event.currentTarget.naturalHeight);\n                        }\n                        if (newAttributes.width || newAttributes.aspectRatio) {\n                            updateAttributes(newAttributes);\n                        }\n                    } }), selected && (_jsx(ResizableImageResizer, { onResize: handleResize, className: classes.resizer }))] }) }));\n}\nexport default ResizableImageComponent;\n","import { InputRule, mergeAttributes, } from \"@tiptap/core\";\nimport { Image } from \"@tiptap/extension-image\";\nimport { ReactNodeViewRenderer } from \"@tiptap/react\";\nimport ResizableImageComponent from \"./ResizableImageComponent\";\n/**\n * A modified version of Tiptap’s `Image` extension\n * (https://tiptap.dev/api/nodes/image), which adds the ability to resize images\n * directly in the editor. A drag handle appears in the bottom right when\n * clicking on an image, so users can interactively change the size.\n */\nconst ResizableImage = Image.extend({\n    addOptions() {\n        var _a;\n        return {\n            // Tiptap claims this.parent can be undefined, so disable this eslint rule\n            // https://tiptap.dev/guide/custom-extensions/#extend-existing-attributes\n            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n            ...(_a = this.parent) === null || _a === void 0 ? void 0 : _a.call(this),\n            // By default, allow all images where `src` is non-empty\n            isAllowedImgSrc: (src) => {\n                if (!src) {\n                    // The src field should be non-empty to be valid\n                    return false;\n                }\n                return true;\n            },\n        };\n    },\n    addAttributes() {\n        var _a;\n        return {\n            ...(_a = this.parent) === null || _a === void 0 ? void 0 : _a.call(this),\n            // The `width` attribute will be used by users to override/specify the width of\n            // the image. If not specified, the image will display with its default/full\n            // width, up to a `max-width: 100%` (via CSS styles). Height will be set to\n            // \"auto\", so `width` will always determine sizing and we'll preserve the original\n            // aspect ratio.\n            width: {\n                default: null,\n                // How to render this attribute in the HTML, so it's serialized/saved\n                // (and in this case, affects visuals)\n                renderHTML: (attributes) => ({\n                    width: attributes.width,\n                }),\n                // How to load this attribute from any existing HTML content\n                parseHTML: (element) => element.getAttribute(\"width\"),\n            },\n            // The `aspectRatio` attribute will be used to set the `aspect-ratio` CSS\n            // style, which ensures that whatever the width (the specific value set\n            // via attribute or max-width of 100%, if the viewport is narrower than\n            // that), the \"height: auto\" can be inferred even before the image loads,\n            // making the page flash/jitter less before/after the image renders (see\n            // https://developer.mozilla.org/en-US/docs/Web/CSS/aspect-ratio, and note\n            // that the newer alternative approach they describe using\n            // `attr(width) / attr(height)` does not work in Chrome and other browsers\n            // yet). We'll make sure to set `aspectRatio` whenever a user resizes and\n            // sets `width`, so that we improve initial page/image rendering.\n            aspectRatio: {\n                default: null,\n                renderHTML: (attributes) => {\n                    if (!attributes.aspectRatio) {\n                        return {};\n                    }\n                    return {\n                        style: `aspect-ratio: ${attributes.aspectRatio}`,\n                    };\n                },\n                parseHTML: (element) => element.style.aspectRatio,\n            },\n        };\n    },\n    renderHTML({ HTMLAttributes }) {\n        return [\n            \"img\",\n            mergeAttributes(\n            // Always render the `height=\"auto\"` attribute by default, since we control the\n            // width with resizing (and this maintains the image aspect ratio)\n            {\n                height: \"auto\",\n            }, this.options.HTMLAttributes, HTMLAttributes),\n        ];\n    },\n    parseHTML() {\n        return [\n            {\n                // This default tag-parsing rule is taken directly from the builtin Image\n                // extension\n                // (https://github.com/ueberdosis/tiptap/blob/4108e9f991522b5ac8f669ae2d24cfe9f91780ba/packages/extension-image/src/image.ts#L61-L69)\n                tag: this.options.allowBase64\n                    ? \"img[src]\"\n                    : 'img[src]:not([src^=\"data:\"])',\n                /**\n                 * We add `getAttrs` here to include our own additional conditions for\n                 * parsing/matching images from input HTML (where returning false marks it as\n                 * not \"matching\", therefore ignoring it and not creating an Image node in\n                 * prosemirror). See https://tiptap.dev/guide/custom-extensions#parse-html\n                 */\n                getAttrs: (node) => {\n                    if (!(node instanceof Element)) {\n                        // This shouldn't be possible, since `getAttrs` with a `tag` should always\n                        // pass in a node, an per the rules above, it should be an HTML element.\n                        // Here for type-narrowing.\n                        return false;\n                    }\n                    // Check if this is an allowed image src, and return null if so to treat it as\n                    // a match. (Prosemirror expects null or undefined to be returned if the check\n                    // is successful\n                    // https://prosemirror.net/docs/ref/version/0.18.0.html#model.ParseRule.getAttrs.)\n                    const src = node.getAttribute(\"src\");\n                    return this.options.isAllowedImgSrc(src) && null;\n                },\n            },\n        ];\n    },\n    /**\n     * By default, the Image extension supports markdown-like input rules for text entered\n     * in the editor, such as the string \"![wat](http://placekitten.com/g/500)\". We'll\n     * override the default implementation so that we can restrict which `src` values are\n     * permitted.\n     */\n    addInputRules() {\n        var _a;\n        const parentInputRules = (_a = this.parent) === null || _a === void 0 ? void 0 : _a.call(this);\n        if (!parentInputRules) {\n            return [];\n        }\n        // This `getAttributes` definition comes from the default implementation here\n        // https://github.com/ueberdosis/tiptap/blob/4108e9f991522b5ac8f669ae2d24cfe9f91780ba/packages/extension-image/src/image.ts#L91-L95\n        const getAttributes = (match) => {\n            const [, , alt, src, title] = match;\n            return { src, alt, title };\n        };\n        // Unlike for `parseHTML` above, we can't simply override the `getAttributes`\n        // function passed to `nodeInputRule`, since returning false there does not prevent\n        // usage of the input rule (see\n        // https://github.com/ueberdosis/tiptap/blob/f5c6fabbce534561cfe18012e48a5b6b406923bc/packages/core/src/inputRules/nodeInputRule.ts#L23).\n        // Instead, we have to update the handler of the InputRule itself, which is\n        // generated from the config passed to the `nodeInputRule`\n        // (https://github.com/ueberdosis/tiptap/blob/4108e9f991522b5ac8f669ae2d24cfe9f91780ba/packages/extension-image/src/image.ts#L86-L98).\n        // So iterate through each InputRule (should be just one in practice), and form an\n        // alternate version which performs nothing if the image src is not permissable.\n        return parentInputRules.map((rule) => new InputRule({\n            find: rule.find,\n            handler: (props) => {\n                const attributes = getAttributes(props.match);\n                if (!this.options.isAllowedImgSrc(attributes.src)) {\n                    // Skip this and don't transform the text into an Image\n                    return;\n                }\n                // Since the image src is valid, let the normal handler run\n                return rule.handler(props);\n            },\n        }));\n    },\n    addNodeView() {\n        // In order to add interactive functionality for a user to resize the image\n        // (and set the `width` attribute as it does so), use a Node View. See\n        // https://tiptap.dev/guide/custom-extensions#node-views and\n        // https://tiptap.dev/guide/node-views/react\n        return ReactNodeViewRenderer(ResizableImageComponent);\n    },\n});\nexport default ResizableImage;\n","// src/index.ts\nimport { Plugin as Plugin2 } from \"prosemirror-state\";\n\n// src/cellselection.ts\nimport { Fragment, Slice } from \"prosemirror-model\";\nimport {\n  NodeSelection as NodeSelection2,\n  Selection,\n  SelectionRange,\n  TextSelection\n} from \"prosemirror-state\";\nimport { Decoration, DecorationSet } from \"prosemirror-view\";\n\n// src/tablemap.ts\nvar readFromCache;\nvar addToCache;\nif (typeof WeakMap != \"undefined\") {\n  let cache = /* @__PURE__ */ new WeakMap();\n  readFromCache = (key) => cache.get(key);\n  addToCache = (key, value) => {\n    cache.set(key, value);\n    return value;\n  };\n} else {\n  const cache = [];\n  const cacheSize = 10;\n  let cachePos = 0;\n  readFromCache = (key) => {\n    for (let i = 0; i < cache.length; i += 2)\n      if (cache[i] == key)\n        return cache[i + 1];\n  };\n  addToCache = (key, value) => {\n    if (cachePos == cacheSize)\n      cachePos = 0;\n    cache[cachePos++] = key;\n    return cache[cachePos++] = value;\n  };\n}\nvar TableMap = class {\n  constructor(width, height, map, problems) {\n    this.width = width;\n    this.height = height;\n    this.map = map;\n    this.problems = problems;\n  }\n  // Find the dimensions of the cell at the given position.\n  findCell(pos) {\n    for (let i = 0; i < this.map.length; i++) {\n      const curPos = this.map[i];\n      if (curPos != pos)\n        continue;\n      const left = i % this.width;\n      const top = i / this.width | 0;\n      let right = left + 1;\n      let bottom = top + 1;\n      for (let j = 1; right < this.width && this.map[i + j] == curPos; j++) {\n        right++;\n      }\n      for (let j = 1; bottom < this.height && this.map[i + this.width * j] == curPos; j++) {\n        bottom++;\n      }\n      return { left, top, right, bottom };\n    }\n    throw new RangeError(`No cell with offset ${pos} found`);\n  }\n  // Find the left side of the cell at the given position.\n  colCount(pos) {\n    for (let i = 0; i < this.map.length; i++) {\n      if (this.map[i] == pos) {\n        return i % this.width;\n      }\n    }\n    throw new RangeError(`No cell with offset ${pos} found`);\n  }\n  // Find the next cell in the given direction, starting from the cell\n  // at `pos`, if any.\n  nextCell(pos, axis, dir) {\n    const { left, right, top, bottom } = this.findCell(pos);\n    if (axis == \"horiz\") {\n      if (dir < 0 ? left == 0 : right == this.width)\n        return null;\n      return this.map[top * this.width + (dir < 0 ? left - 1 : right)];\n    } else {\n      if (dir < 0 ? top == 0 : bottom == this.height)\n        return null;\n      return this.map[left + this.width * (dir < 0 ? top - 1 : bottom)];\n    }\n  }\n  // Get the rectangle spanning the two given cells.\n  rectBetween(a, b) {\n    const {\n      left: leftA,\n      right: rightA,\n      top: topA,\n      bottom: bottomA\n    } = this.findCell(a);\n    const {\n      left: leftB,\n      right: rightB,\n      top: topB,\n      bottom: bottomB\n    } = this.findCell(b);\n    return {\n      left: Math.min(leftA, leftB),\n      top: Math.min(topA, topB),\n      right: Math.max(rightA, rightB),\n      bottom: Math.max(bottomA, bottomB)\n    };\n  }\n  // Return the position of all cells that have the top left corner in\n  // the given rectangle.\n  cellsInRect(rect) {\n    const result = [];\n    const seen = {};\n    for (let row = rect.top; row < rect.bottom; row++) {\n      for (let col = rect.left; col < rect.right; col++) {\n        const index = row * this.width + col;\n        const pos = this.map[index];\n        if (seen[pos])\n          continue;\n        seen[pos] = true;\n        if (col == rect.left && col && this.map[index - 1] == pos || row == rect.top && row && this.map[index - this.width] == pos) {\n          continue;\n        }\n        result.push(pos);\n      }\n    }\n    return result;\n  }\n  // Return the position at which the cell at the given row and column\n  // starts, or would start, if a cell started there.\n  positionAt(row, col, table) {\n    for (let i = 0, rowStart = 0; ; i++) {\n      const rowEnd = rowStart + table.child(i).nodeSize;\n      if (i == row) {\n        let index = col + row * this.width;\n        const rowEndIndex = (row + 1) * this.width;\n        while (index < rowEndIndex && this.map[index] < rowStart)\n          index++;\n        return index == rowEndIndex ? rowEnd - 1 : this.map[index];\n      }\n      rowStart = rowEnd;\n    }\n  }\n  // Find the table map for the given table node.\n  static get(table) {\n    return readFromCache(table) || addToCache(table, computeMap(table));\n  }\n};\nfunction computeMap(table) {\n  if (table.type.spec.tableRole != \"table\")\n    throw new RangeError(\"Not a table node: \" + table.type.name);\n  const width = findWidth(table), height = table.childCount;\n  const map = [];\n  let mapPos = 0;\n  let problems = null;\n  const colWidths = [];\n  for (let i = 0, e = width * height; i < e; i++)\n    map[i] = 0;\n  for (let row = 0, pos = 0; row < height; row++) {\n    const rowNode = table.child(row);\n    pos++;\n    for (let i = 0; ; i++) {\n      while (mapPos < map.length && map[mapPos] != 0)\n        mapPos++;\n      if (i == rowNode.childCount)\n        break;\n      const cellNode = rowNode.child(i);\n      const { colspan, rowspan, colwidth } = cellNode.attrs;\n      for (let h = 0; h < rowspan; h++) {\n        if (h + row >= height) {\n          (problems || (problems = [])).push({\n            type: \"overlong_rowspan\",\n            pos,\n            n: rowspan - h\n          });\n          break;\n        }\n        const start = mapPos + h * width;\n        for (let w = 0; w < colspan; w++) {\n          if (map[start + w] == 0)\n            map[start + w] = pos;\n          else\n            (problems || (problems = [])).push({\n              type: \"collision\",\n              row,\n              pos,\n              n: colspan - w\n            });\n          const colW = colwidth && colwidth[w];\n          if (colW) {\n            const widthIndex = (start + w) % width * 2, prev = colWidths[widthIndex];\n            if (prev == null || prev != colW && colWidths[widthIndex + 1] == 1) {\n              colWidths[widthIndex] = colW;\n              colWidths[widthIndex + 1] = 1;\n            } else if (prev == colW) {\n              colWidths[widthIndex + 1]++;\n            }\n          }\n        }\n      }\n      mapPos += colspan;\n      pos += cellNode.nodeSize;\n    }\n    const expectedPos = (row + 1) * width;\n    let missing = 0;\n    while (mapPos < expectedPos)\n      if (map[mapPos++] == 0)\n        missing++;\n    if (missing)\n      (problems || (problems = [])).push({ type: \"missing\", row, n: missing });\n    pos++;\n  }\n  const tableMap = new TableMap(width, height, map, problems);\n  let badWidths = false;\n  for (let i = 0; !badWidths && i < colWidths.length; i += 2)\n    if (colWidths[i] != null && colWidths[i + 1] < height)\n      badWidths = true;\n  if (badWidths)\n    findBadColWidths(tableMap, colWidths, table);\n  return tableMap;\n}\nfunction findWidth(table) {\n  let width = -1;\n  let hasRowSpan = false;\n  for (let row = 0; row < table.childCount; row++) {\n    const rowNode = table.child(row);\n    let rowWidth = 0;\n    if (hasRowSpan)\n      for (let j = 0; j < row; j++) {\n        const prevRow = table.child(j);\n        for (let i = 0; i < prevRow.childCount; i++) {\n          const cell = prevRow.child(i);\n          if (j + cell.attrs.rowspan > row)\n            rowWidth += cell.attrs.colspan;\n        }\n      }\n    for (let i = 0; i < rowNode.childCount; i++) {\n      const cell = rowNode.child(i);\n      rowWidth += cell.attrs.colspan;\n      if (cell.attrs.rowspan > 1)\n        hasRowSpan = true;\n    }\n    if (width == -1)\n      width = rowWidth;\n    else if (width != rowWidth)\n      width = Math.max(width, rowWidth);\n  }\n  return width;\n}\nfunction findBadColWidths(map, colWidths, table) {\n  if (!map.problems)\n    map.problems = [];\n  const seen = {};\n  for (let i = 0; i < map.map.length; i++) {\n    const pos = map.map[i];\n    if (seen[pos])\n      continue;\n    seen[pos] = true;\n    const node = table.nodeAt(pos);\n    if (!node) {\n      throw new RangeError(`No cell with offset ${pos} found`);\n    }\n    let updated = null;\n    const attrs = node.attrs;\n    for (let j = 0; j < attrs.colspan; j++) {\n      const col = (i + j) % map.width;\n      const colWidth = colWidths[col * 2];\n      if (colWidth != null && (!attrs.colwidth || attrs.colwidth[j] != colWidth))\n        (updated || (updated = freshColWidth(attrs)))[j] = colWidth;\n    }\n    if (updated)\n      map.problems.unshift({\n        type: \"colwidth mismatch\",\n        pos,\n        colwidth: updated\n      });\n  }\n}\nfunction freshColWidth(attrs) {\n  if (attrs.colwidth)\n    return attrs.colwidth.slice();\n  const result = [];\n  for (let i = 0; i < attrs.colspan; i++)\n    result.push(0);\n  return result;\n}\n\n// src/util.ts\nimport { PluginKey } from \"prosemirror-state\";\n\n// src/schema.ts\nfunction getCellAttrs(dom, extraAttrs) {\n  if (typeof dom === \"string\") {\n    return {};\n  }\n  const widthAttr = dom.getAttribute(\"data-colwidth\");\n  const widths = widthAttr && /^\\d+(,\\d+)*$/.test(widthAttr) ? widthAttr.split(\",\").map((s) => Number(s)) : null;\n  const colspan = Number(dom.getAttribute(\"colspan\") || 1);\n  const result = {\n    colspan,\n    rowspan: Number(dom.getAttribute(\"rowspan\") || 1),\n    colwidth: widths && widths.length == colspan ? widths : null\n  };\n  for (const prop in extraAttrs) {\n    const getter = extraAttrs[prop].getFromDOM;\n    const value = getter && getter(dom);\n    if (value != null) {\n      result[prop] = value;\n    }\n  }\n  return result;\n}\nfunction setCellAttrs(node, extraAttrs) {\n  const attrs = {};\n  if (node.attrs.colspan != 1)\n    attrs.colspan = node.attrs.colspan;\n  if (node.attrs.rowspan != 1)\n    attrs.rowspan = node.attrs.rowspan;\n  if (node.attrs.colwidth)\n    attrs[\"data-colwidth\"] = node.attrs.colwidth.join(\",\");\n  for (const prop in extraAttrs) {\n    const setter = extraAttrs[prop].setDOMAttr;\n    if (setter)\n      setter(node.attrs[prop], attrs);\n  }\n  return attrs;\n}\nfunction tableNodes(options) {\n  const extraAttrs = options.cellAttributes || {};\n  const cellAttrs = {\n    colspan: { default: 1 },\n    rowspan: { default: 1 },\n    colwidth: { default: null }\n  };\n  for (const prop in extraAttrs)\n    cellAttrs[prop] = { default: extraAttrs[prop].default };\n  return {\n    table: {\n      content: \"table_row+\",\n      tableRole: \"table\",\n      isolating: true,\n      group: options.tableGroup,\n      parseDOM: [{ tag: \"table\" }],\n      toDOM() {\n        return [\"table\", [\"tbody\", 0]];\n      }\n    },\n    table_row: {\n      content: \"(table_cell | table_header)*\",\n      tableRole: \"row\",\n      parseDOM: [{ tag: \"tr\" }],\n      toDOM() {\n        return [\"tr\", 0];\n      }\n    },\n    table_cell: {\n      content: options.cellContent,\n      attrs: cellAttrs,\n      tableRole: \"cell\",\n      isolating: true,\n      parseDOM: [\n        { tag: \"td\", getAttrs: (dom) => getCellAttrs(dom, extraAttrs) }\n      ],\n      toDOM(node) {\n        return [\"td\", setCellAttrs(node, extraAttrs), 0];\n      }\n    },\n    table_header: {\n      content: options.cellContent,\n      attrs: cellAttrs,\n      tableRole: \"header_cell\",\n      isolating: true,\n      parseDOM: [\n        { tag: \"th\", getAttrs: (dom) => getCellAttrs(dom, extraAttrs) }\n      ],\n      toDOM(node) {\n        return [\"th\", setCellAttrs(node, extraAttrs), 0];\n      }\n    }\n  };\n}\nfunction tableNodeTypes(schema) {\n  let result = schema.cached.tableNodeTypes;\n  if (!result) {\n    result = schema.cached.tableNodeTypes = {};\n    for (const name in schema.nodes) {\n      const type = schema.nodes[name], role = type.spec.tableRole;\n      if (role)\n        result[role] = type;\n    }\n  }\n  return result;\n}\n\n// src/util.ts\nvar tableEditingKey = new PluginKey(\"selectingCells\");\nfunction cellAround($pos) {\n  for (let d = $pos.depth - 1; d > 0; d--)\n    if ($pos.node(d).type.spec.tableRole == \"row\")\n      return $pos.node(0).resolve($pos.before(d + 1));\n  return null;\n}\nfunction cellWrapping($pos) {\n  for (let d = $pos.depth; d > 0; d--) {\n    const role = $pos.node(d).type.spec.tableRole;\n    if (role === \"cell\" || role === \"header_cell\")\n      return $pos.node(d);\n  }\n  return null;\n}\nfunction isInTable(state) {\n  const $head = state.selection.$head;\n  for (let d = $head.depth; d > 0; d--)\n    if ($head.node(d).type.spec.tableRole == \"row\")\n      return true;\n  return false;\n}\nfunction selectionCell(state) {\n  const sel = state.selection;\n  if (\"$anchorCell\" in sel && sel.$anchorCell) {\n    return sel.$anchorCell.pos > sel.$headCell.pos ? sel.$anchorCell : sel.$headCell;\n  } else if (\"node\" in sel && sel.node && sel.node.type.spec.tableRole == \"cell\") {\n    return sel.$anchor;\n  }\n  const $cell = cellAround(sel.$head) || cellNear(sel.$head);\n  if ($cell) {\n    return $cell;\n  }\n  throw new RangeError(`No cell found around position ${sel.head}`);\n}\nfunction cellNear($pos) {\n  for (let after = $pos.nodeAfter, pos = $pos.pos; after; after = after.firstChild, pos++) {\n    const role = after.type.spec.tableRole;\n    if (role == \"cell\" || role == \"header_cell\")\n      return $pos.doc.resolve(pos);\n  }\n  for (let before = $pos.nodeBefore, pos = $pos.pos; before; before = before.lastChild, pos--) {\n    const role = before.type.spec.tableRole;\n    if (role == \"cell\" || role == \"header_cell\")\n      return $pos.doc.resolve(pos - before.nodeSize);\n  }\n}\nfunction pointsAtCell($pos) {\n  return $pos.parent.type.spec.tableRole == \"row\" && !!$pos.nodeAfter;\n}\nfunction moveCellForward($pos) {\n  return $pos.node(0).resolve($pos.pos + $pos.nodeAfter.nodeSize);\n}\nfunction inSameTable($cellA, $cellB) {\n  return $cellA.depth == $cellB.depth && $cellA.pos >= $cellB.start(-1) && $cellA.pos <= $cellB.end(-1);\n}\nfunction findCell($pos) {\n  return TableMap.get($pos.node(-1)).findCell($pos.pos - $pos.start(-1));\n}\nfunction colCount($pos) {\n  return TableMap.get($pos.node(-1)).colCount($pos.pos - $pos.start(-1));\n}\nfunction nextCell($pos, axis, dir) {\n  const table = $pos.node(-1);\n  const map = TableMap.get(table);\n  const tableStart = $pos.start(-1);\n  const moved = map.nextCell($pos.pos - tableStart, axis, dir);\n  return moved == null ? null : $pos.node(0).resolve(tableStart + moved);\n}\nfunction removeColSpan(attrs, pos, n = 1) {\n  const result = { ...attrs, colspan: attrs.colspan - n };\n  if (result.colwidth) {\n    result.colwidth = result.colwidth.slice();\n    result.colwidth.splice(pos, n);\n    if (!result.colwidth.some((w) => w > 0))\n      result.colwidth = null;\n  }\n  return result;\n}\nfunction addColSpan(attrs, pos, n = 1) {\n  const result = { ...attrs, colspan: attrs.colspan + n };\n  if (result.colwidth) {\n    result.colwidth = result.colwidth.slice();\n    for (let i = 0; i < n; i++)\n      result.colwidth.splice(pos, 0, 0);\n  }\n  return result;\n}\nfunction columnIsHeader(map, table, col) {\n  const headerCell = tableNodeTypes(table.type.schema).header_cell;\n  for (let row = 0; row < map.height; row++)\n    if (table.nodeAt(map.map[col + row * map.width]).type != headerCell)\n      return false;\n  return true;\n}\n\n// src/cellselection.ts\nvar CellSelection = class _CellSelection extends Selection {\n  // A table selection is identified by its anchor and head cells. The\n  // positions given to this constructor should point _before_ two\n  // cells in the same table. They may be the same, to select a single\n  // cell.\n  constructor($anchorCell, $headCell = $anchorCell) {\n    const table = $anchorCell.node(-1);\n    const map = TableMap.get(table);\n    const tableStart = $anchorCell.start(-1);\n    const rect = map.rectBetween(\n      $anchorCell.pos - tableStart,\n      $headCell.pos - tableStart\n    );\n    const doc = $anchorCell.node(0);\n    const cells = map.cellsInRect(rect).filter((p) => p != $headCell.pos - tableStart);\n    cells.unshift($headCell.pos - tableStart);\n    const ranges = cells.map((pos) => {\n      const cell = table.nodeAt(pos);\n      if (!cell) {\n        throw RangeError(`No cell with offset ${pos} found`);\n      }\n      const from = tableStart + pos + 1;\n      return new SelectionRange(\n        doc.resolve(from),\n        doc.resolve(from + cell.content.size)\n      );\n    });\n    super(ranges[0].$from, ranges[0].$to, ranges);\n    this.$anchorCell = $anchorCell;\n    this.$headCell = $headCell;\n  }\n  map(doc, mapping) {\n    const $anchorCell = doc.resolve(mapping.map(this.$anchorCell.pos));\n    const $headCell = doc.resolve(mapping.map(this.$headCell.pos));\n    if (pointsAtCell($anchorCell) && pointsAtCell($headCell) && inSameTable($anchorCell, $headCell)) {\n      const tableChanged = this.$anchorCell.node(-1) != $anchorCell.node(-1);\n      if (tableChanged && this.isRowSelection())\n        return _CellSelection.rowSelection($anchorCell, $headCell);\n      else if (tableChanged && this.isColSelection())\n        return _CellSelection.colSelection($anchorCell, $headCell);\n      else\n        return new _CellSelection($anchorCell, $headCell);\n    }\n    return TextSelection.between($anchorCell, $headCell);\n  }\n  // Returns a rectangular slice of table rows containing the selected\n  // cells.\n  content() {\n    const table = this.$anchorCell.node(-1);\n    const map = TableMap.get(table);\n    const tableStart = this.$anchorCell.start(-1);\n    const rect = map.rectBetween(\n      this.$anchorCell.pos - tableStart,\n      this.$headCell.pos - tableStart\n    );\n    const seen = {};\n    const rows = [];\n    for (let row = rect.top; row < rect.bottom; row++) {\n      const rowContent = [];\n      for (let index = row * map.width + rect.left, col = rect.left; col < rect.right; col++, index++) {\n        const pos = map.map[index];\n        if (seen[pos])\n          continue;\n        seen[pos] = true;\n        const cellRect = map.findCell(pos);\n        let cell = table.nodeAt(pos);\n        if (!cell) {\n          throw RangeError(`No cell with offset ${pos} found`);\n        }\n        const extraLeft = rect.left - cellRect.left;\n        const extraRight = cellRect.right - rect.right;\n        if (extraLeft > 0 || extraRight > 0) {\n          let attrs = cell.attrs;\n          if (extraLeft > 0) {\n            attrs = removeColSpan(attrs, 0, extraLeft);\n          }\n          if (extraRight > 0) {\n            attrs = removeColSpan(\n              attrs,\n              attrs.colspan - extraRight,\n              extraRight\n            );\n          }\n          if (cellRect.left < rect.left) {\n            cell = cell.type.createAndFill(attrs);\n            if (!cell) {\n              throw RangeError(\n                `Could not create cell with attrs ${JSON.stringify(attrs)}`\n              );\n            }\n          } else {\n            cell = cell.type.create(attrs, cell.content);\n          }\n        }\n        if (cellRect.top < rect.top || cellRect.bottom > rect.bottom) {\n          const attrs = {\n            ...cell.attrs,\n            rowspan: Math.min(cellRect.bottom, rect.bottom) - Math.max(cellRect.top, rect.top)\n          };\n          if (cellRect.top < rect.top) {\n            cell = cell.type.createAndFill(attrs);\n          } else {\n            cell = cell.type.create(attrs, cell.content);\n          }\n        }\n        rowContent.push(cell);\n      }\n      rows.push(table.child(row).copy(Fragment.from(rowContent)));\n    }\n    const fragment = this.isColSelection() && this.isRowSelection() ? table : rows;\n    return new Slice(Fragment.from(fragment), 1, 1);\n  }\n  replace(tr, content = Slice.empty) {\n    const mapFrom = tr.steps.length, ranges = this.ranges;\n    for (let i = 0; i < ranges.length; i++) {\n      const { $from, $to } = ranges[i], mapping = tr.mapping.slice(mapFrom);\n      tr.replace(\n        mapping.map($from.pos),\n        mapping.map($to.pos),\n        i ? Slice.empty : content\n      );\n    }\n    const sel = Selection.findFrom(\n      tr.doc.resolve(tr.mapping.slice(mapFrom).map(this.to)),\n      -1\n    );\n    if (sel)\n      tr.setSelection(sel);\n  }\n  replaceWith(tr, node) {\n    this.replace(tr, new Slice(Fragment.from(node), 0, 0));\n  }\n  forEachCell(f) {\n    const table = this.$anchorCell.node(-1);\n    const map = TableMap.get(table);\n    const tableStart = this.$anchorCell.start(-1);\n    const cells = map.cellsInRect(\n      map.rectBetween(\n        this.$anchorCell.pos - tableStart,\n        this.$headCell.pos - tableStart\n      )\n    );\n    for (let i = 0; i < cells.length; i++) {\n      f(table.nodeAt(cells[i]), tableStart + cells[i]);\n    }\n  }\n  // True if this selection goes all the way from the top to the\n  // bottom of the table.\n  isColSelection() {\n    const anchorTop = this.$anchorCell.index(-1);\n    const headTop = this.$headCell.index(-1);\n    if (Math.min(anchorTop, headTop) > 0)\n      return false;\n    const anchorBottom = anchorTop + this.$anchorCell.nodeAfter.attrs.rowspan;\n    const headBottom = headTop + this.$headCell.nodeAfter.attrs.rowspan;\n    return Math.max(anchorBottom, headBottom) == this.$headCell.node(-1).childCount;\n  }\n  // Returns the smallest column selection that covers the given anchor\n  // and head cell.\n  static colSelection($anchorCell, $headCell = $anchorCell) {\n    const table = $anchorCell.node(-1);\n    const map = TableMap.get(table);\n    const tableStart = $anchorCell.start(-1);\n    const anchorRect = map.findCell($anchorCell.pos - tableStart);\n    const headRect = map.findCell($headCell.pos - tableStart);\n    const doc = $anchorCell.node(0);\n    if (anchorRect.top <= headRect.top) {\n      if (anchorRect.top > 0)\n        $anchorCell = doc.resolve(tableStart + map.map[anchorRect.left]);\n      if (headRect.bottom < map.height)\n        $headCell = doc.resolve(\n          tableStart + map.map[map.width * (map.height - 1) + headRect.right - 1]\n        );\n    } else {\n      if (headRect.top > 0)\n        $headCell = doc.resolve(tableStart + map.map[headRect.left]);\n      if (anchorRect.bottom < map.height)\n        $anchorCell = doc.resolve(\n          tableStart + map.map[map.width * (map.height - 1) + anchorRect.right - 1]\n        );\n    }\n    return new _CellSelection($anchorCell, $headCell);\n  }\n  // True if this selection goes all the way from the left to the\n  // right of the table.\n  isRowSelection() {\n    const table = this.$anchorCell.node(-1);\n    const map = TableMap.get(table);\n    const tableStart = this.$anchorCell.start(-1);\n    const anchorLeft = map.colCount(this.$anchorCell.pos - tableStart);\n    const headLeft = map.colCount(this.$headCell.pos - tableStart);\n    if (Math.min(anchorLeft, headLeft) > 0)\n      return false;\n    const anchorRight = anchorLeft + this.$anchorCell.nodeAfter.attrs.colspan;\n    const headRight = headLeft + this.$headCell.nodeAfter.attrs.colspan;\n    return Math.max(anchorRight, headRight) == map.width;\n  }\n  eq(other) {\n    return other instanceof _CellSelection && other.$anchorCell.pos == this.$anchorCell.pos && other.$headCell.pos == this.$headCell.pos;\n  }\n  // Returns the smallest row selection that covers the given anchor\n  // and head cell.\n  static rowSelection($anchorCell, $headCell = $anchorCell) {\n    const table = $anchorCell.node(-1);\n    const map = TableMap.get(table);\n    const tableStart = $anchorCell.start(-1);\n    const anchorRect = map.findCell($anchorCell.pos - tableStart);\n    const headRect = map.findCell($headCell.pos - tableStart);\n    const doc = $anchorCell.node(0);\n    if (anchorRect.left <= headRect.left) {\n      if (anchorRect.left > 0)\n        $anchorCell = doc.resolve(\n          tableStart + map.map[anchorRect.top * map.width]\n        );\n      if (headRect.right < map.width)\n        $headCell = doc.resolve(\n          tableStart + map.map[map.width * (headRect.top + 1) - 1]\n        );\n    } else {\n      if (headRect.left > 0)\n        $headCell = doc.resolve(tableStart + map.map[headRect.top * map.width]);\n      if (anchorRect.right < map.width)\n        $anchorCell = doc.resolve(\n          tableStart + map.map[map.width * (anchorRect.top + 1) - 1]\n        );\n    }\n    return new _CellSelection($anchorCell, $headCell);\n  }\n  toJSON() {\n    return {\n      type: \"cell\",\n      anchor: this.$anchorCell.pos,\n      head: this.$headCell.pos\n    };\n  }\n  static fromJSON(doc, json) {\n    return new _CellSelection(doc.resolve(json.anchor), doc.resolve(json.head));\n  }\n  static create(doc, anchorCell, headCell = anchorCell) {\n    return new _CellSelection(doc.resolve(anchorCell), doc.resolve(headCell));\n  }\n  getBookmark() {\n    return new CellBookmark(this.$anchorCell.pos, this.$headCell.pos);\n  }\n};\nCellSelection.prototype.visible = false;\nSelection.jsonID(\"cell\", CellSelection);\nvar CellBookmark = class _CellBookmark {\n  constructor(anchor, head) {\n    this.anchor = anchor;\n    this.head = head;\n  }\n  map(mapping) {\n    return new _CellBookmark(mapping.map(this.anchor), mapping.map(this.head));\n  }\n  resolve(doc) {\n    const $anchorCell = doc.resolve(this.anchor), $headCell = doc.resolve(this.head);\n    if ($anchorCell.parent.type.spec.tableRole == \"row\" && $headCell.parent.type.spec.tableRole == \"row\" && $anchorCell.index() < $anchorCell.parent.childCount && $headCell.index() < $headCell.parent.childCount && inSameTable($anchorCell, $headCell))\n      return new CellSelection($anchorCell, $headCell);\n    else\n      return Selection.near($headCell, 1);\n  }\n};\nfunction drawCellSelection(state) {\n  if (!(state.selection instanceof CellSelection))\n    return null;\n  const cells = [];\n  state.selection.forEachCell((node, pos) => {\n    cells.push(\n      Decoration.node(pos, pos + node.nodeSize, { class: \"selectedCell\" })\n    );\n  });\n  return DecorationSet.create(state.doc, cells);\n}\nfunction isCellBoundarySelection({ $from, $to }) {\n  if ($from.pos == $to.pos || $from.pos < $from.pos - 6)\n    return false;\n  let afterFrom = $from.pos;\n  let beforeTo = $to.pos;\n  let depth = $from.depth;\n  for (; depth >= 0; depth--, afterFrom++)\n    if ($from.after(depth + 1) < $from.end(depth))\n      break;\n  for (let d = $to.depth; d >= 0; d--, beforeTo--)\n    if ($to.before(d + 1) > $to.start(d))\n      break;\n  return afterFrom == beforeTo && /row|table/.test($from.node(depth).type.spec.tableRole);\n}\nfunction isTextSelectionAcrossCells({ $from, $to }) {\n  let fromCellBoundaryNode;\n  let toCellBoundaryNode;\n  for (let i = $from.depth; i > 0; i--) {\n    const node = $from.node(i);\n    if (node.type.spec.tableRole === \"cell\" || node.type.spec.tableRole === \"header_cell\") {\n      fromCellBoundaryNode = node;\n      break;\n    }\n  }\n  for (let i = $to.depth; i > 0; i--) {\n    const node = $to.node(i);\n    if (node.type.spec.tableRole === \"cell\" || node.type.spec.tableRole === \"header_cell\") {\n      toCellBoundaryNode = node;\n      break;\n    }\n  }\n  return fromCellBoundaryNode !== toCellBoundaryNode && $to.parentOffset === 0;\n}\nfunction normalizeSelection(state, tr, allowTableNodeSelection) {\n  const sel = (tr || state).selection;\n  const doc = (tr || state).doc;\n  let normalize;\n  let role;\n  if (sel instanceof NodeSelection2 && (role = sel.node.type.spec.tableRole)) {\n    if (role == \"cell\" || role == \"header_cell\") {\n      normalize = CellSelection.create(doc, sel.from);\n    } else if (role == \"row\") {\n      const $cell = doc.resolve(sel.from + 1);\n      normalize = CellSelection.rowSelection($cell, $cell);\n    } else if (!allowTableNodeSelection) {\n      const map = TableMap.get(sel.node);\n      const start = sel.from + 1;\n      const lastCell = start + map.map[map.width * map.height - 1];\n      normalize = CellSelection.create(doc, start + 1, lastCell);\n    }\n  } else if (sel instanceof TextSelection && isCellBoundarySelection(sel)) {\n    normalize = TextSelection.create(doc, sel.from);\n  } else if (sel instanceof TextSelection && isTextSelectionAcrossCells(sel)) {\n    normalize = TextSelection.create(doc, sel.$from.start(), sel.$from.end());\n  }\n  if (normalize)\n    (tr || (tr = state.tr)).setSelection(normalize);\n  return tr;\n}\n\n// src/fixtables.ts\nimport { PluginKey as PluginKey2 } from \"prosemirror-state\";\nvar fixTablesKey = new PluginKey2(\"fix-tables\");\nfunction changedDescendants(old, cur, offset, f) {\n  const oldSize = old.childCount, curSize = cur.childCount;\n  outer:\n    for (let i = 0, j = 0; i < curSize; i++) {\n      const child = cur.child(i);\n      for (let scan = j, e = Math.min(oldSize, i + 3); scan < e; scan++) {\n        if (old.child(scan) == child) {\n          j = scan + 1;\n          offset += child.nodeSize;\n          continue outer;\n        }\n      }\n      f(child, offset);\n      if (j < oldSize && old.child(j).sameMarkup(child))\n        changedDescendants(old.child(j), child, offset + 1, f);\n      else\n        child.nodesBetween(0, child.content.size, f, offset + 1);\n      offset += child.nodeSize;\n    }\n}\nfunction fixTables(state, oldState) {\n  let tr;\n  const check = (node, pos) => {\n    if (node.type.spec.tableRole == \"table\")\n      tr = fixTable(state, node, pos, tr);\n  };\n  if (!oldState)\n    state.doc.descendants(check);\n  else if (oldState.doc != state.doc)\n    changedDescendants(oldState.doc, state.doc, 0, check);\n  return tr;\n}\nfunction fixTable(state, table, tablePos, tr) {\n  const map = TableMap.get(table);\n  if (!map.problems)\n    return tr;\n  if (!tr)\n    tr = state.tr;\n  const mustAdd = [];\n  for (let i = 0; i < map.height; i++)\n    mustAdd.push(0);\n  for (let i = 0; i < map.problems.length; i++) {\n    const prob = map.problems[i];\n    if (prob.type == \"collision\") {\n      const cell = table.nodeAt(prob.pos);\n      if (!cell)\n        continue;\n      const attrs = cell.attrs;\n      for (let j = 0; j < attrs.rowspan; j++)\n        mustAdd[prob.row + j] += prob.n;\n      tr.setNodeMarkup(\n        tr.mapping.map(tablePos + 1 + prob.pos),\n        null,\n        removeColSpan(attrs, attrs.colspan - prob.n, prob.n)\n      );\n    } else if (prob.type == \"missing\") {\n      mustAdd[prob.row] += prob.n;\n    } else if (prob.type == \"overlong_rowspan\") {\n      const cell = table.nodeAt(prob.pos);\n      if (!cell)\n        continue;\n      tr.setNodeMarkup(tr.mapping.map(tablePos + 1 + prob.pos), null, {\n        ...cell.attrs,\n        rowspan: cell.attrs.rowspan - prob.n\n      });\n    } else if (prob.type == \"colwidth mismatch\") {\n      const cell = table.nodeAt(prob.pos);\n      if (!cell)\n        continue;\n      tr.setNodeMarkup(tr.mapping.map(tablePos + 1 + prob.pos), null, {\n        ...cell.attrs,\n        colwidth: prob.colwidth\n      });\n    }\n  }\n  let first, last;\n  for (let i = 0; i < mustAdd.length; i++)\n    if (mustAdd[i]) {\n      if (first == null)\n        first = i;\n      last = i;\n    }\n  for (let i = 0, pos = tablePos + 1; i < map.height; i++) {\n    const row = table.child(i);\n    const end = pos + row.nodeSize;\n    const add = mustAdd[i];\n    if (add > 0) {\n      let role = \"cell\";\n      if (row.firstChild) {\n        role = row.firstChild.type.spec.tableRole;\n      }\n      const nodes = [];\n      for (let j = 0; j < add; j++) {\n        const node = tableNodeTypes(state.schema)[role].createAndFill();\n        if (node)\n          nodes.push(node);\n      }\n      const side = (i == 0 || first == i - 1) && last == i ? pos + 1 : end - 1;\n      tr.insert(tr.mapping.map(side), nodes);\n    }\n    pos = end;\n  }\n  return tr.setMeta(fixTablesKey, { fixTables: true });\n}\n\n// src/input.ts\nimport { Fragment as Fragment3, Slice as Slice3 } from \"prosemirror-model\";\nimport {\n  Selection as Selection2,\n  TextSelection as TextSelection2\n} from \"prosemirror-state\";\nimport { keydownHandler } from \"prosemirror-keymap\";\n\n// src/copypaste.ts\nimport { Fragment as Fragment2, Slice as Slice2 } from \"prosemirror-model\";\nimport { Transform } from \"prosemirror-transform\";\nfunction pastedCells(slice) {\n  if (!slice.size)\n    return null;\n  let { content, openStart, openEnd } = slice;\n  while (content.childCount == 1 && (openStart > 0 && openEnd > 0 || content.child(0).type.spec.tableRole == \"table\")) {\n    openStart--;\n    openEnd--;\n    content = content.child(0).content;\n  }\n  const first = content.child(0);\n  const role = first.type.spec.tableRole;\n  const schema = first.type.schema, rows = [];\n  if (role == \"row\") {\n    for (let i = 0; i < content.childCount; i++) {\n      let cells = content.child(i).content;\n      const left = i ? 0 : Math.max(0, openStart - 1);\n      const right = i < content.childCount - 1 ? 0 : Math.max(0, openEnd - 1);\n      if (left || right)\n        cells = fitSlice(\n          tableNodeTypes(schema).row,\n          new Slice2(cells, left, right)\n        ).content;\n      rows.push(cells);\n    }\n  } else if (role == \"cell\" || role == \"header_cell\") {\n    rows.push(\n      openStart || openEnd ? fitSlice(\n        tableNodeTypes(schema).row,\n        new Slice2(content, openStart, openEnd)\n      ).content : content\n    );\n  } else {\n    return null;\n  }\n  return ensureRectangular(schema, rows);\n}\nfunction ensureRectangular(schema, rows) {\n  const widths = [];\n  for (let i = 0; i < rows.length; i++) {\n    const row = rows[i];\n    for (let j = row.childCount - 1; j >= 0; j--) {\n      const { rowspan, colspan } = row.child(j).attrs;\n      for (let r = i; r < i + rowspan; r++)\n        widths[r] = (widths[r] || 0) + colspan;\n    }\n  }\n  let width = 0;\n  for (let r = 0; r < widths.length; r++)\n    width = Math.max(width, widths[r]);\n  for (let r = 0; r < widths.length; r++) {\n    if (r >= rows.length)\n      rows.push(Fragment2.empty);\n    if (widths[r] < width) {\n      const empty = tableNodeTypes(schema).cell.createAndFill();\n      const cells = [];\n      for (let i = widths[r]; i < width; i++) {\n        cells.push(empty);\n      }\n      rows[r] = rows[r].append(Fragment2.from(cells));\n    }\n  }\n  return { height: rows.length, width, rows };\n}\nfunction fitSlice(nodeType, slice) {\n  const node = nodeType.createAndFill();\n  const tr = new Transform(node).replace(0, node.content.size, slice);\n  return tr.doc;\n}\nfunction clipCells({ width, height, rows }, newWidth, newHeight) {\n  if (width != newWidth) {\n    const added = [];\n    const newRows = [];\n    for (let row = 0; row < rows.length; row++) {\n      const frag = rows[row], cells = [];\n      for (let col = added[row] || 0, i = 0; col < newWidth; i++) {\n        let cell = frag.child(i % frag.childCount);\n        if (col + cell.attrs.colspan > newWidth)\n          cell = cell.type.createChecked(\n            removeColSpan(\n              cell.attrs,\n              cell.attrs.colspan,\n              col + cell.attrs.colspan - newWidth\n            ),\n            cell.content\n          );\n        cells.push(cell);\n        col += cell.attrs.colspan;\n        for (let j = 1; j < cell.attrs.rowspan; j++)\n          added[row + j] = (added[row + j] || 0) + cell.attrs.colspan;\n      }\n      newRows.push(Fragment2.from(cells));\n    }\n    rows = newRows;\n    width = newWidth;\n  }\n  if (height != newHeight) {\n    const newRows = [];\n    for (let row = 0, i = 0; row < newHeight; row++, i++) {\n      const cells = [], source = rows[i % height];\n      for (let j = 0; j < source.childCount; j++) {\n        let cell = source.child(j);\n        if (row + cell.attrs.rowspan > newHeight)\n          cell = cell.type.create(\n            {\n              ...cell.attrs,\n              rowspan: Math.max(1, newHeight - cell.attrs.rowspan)\n            },\n            cell.content\n          );\n        cells.push(cell);\n      }\n      newRows.push(Fragment2.from(cells));\n    }\n    rows = newRows;\n    height = newHeight;\n  }\n  return { width, height, rows };\n}\nfunction growTable(tr, map, table, start, width, height, mapFrom) {\n  const schema = tr.doc.type.schema;\n  const types = tableNodeTypes(schema);\n  let empty;\n  let emptyHead;\n  if (width > map.width) {\n    for (let row = 0, rowEnd = 0; row < map.height; row++) {\n      const rowNode = table.child(row);\n      rowEnd += rowNode.nodeSize;\n      const cells = [];\n      let add;\n      if (rowNode.lastChild == null || rowNode.lastChild.type == types.cell)\n        add = empty || (empty = types.cell.createAndFill());\n      else\n        add = emptyHead || (emptyHead = types.header_cell.createAndFill());\n      for (let i = map.width; i < width; i++)\n        cells.push(add);\n      tr.insert(tr.mapping.slice(mapFrom).map(rowEnd - 1 + start), cells);\n    }\n  }\n  if (height > map.height) {\n    const cells = [];\n    for (let i = 0, start2 = (map.height - 1) * map.width; i < Math.max(map.width, width); i++) {\n      const header = i >= map.width ? false : table.nodeAt(map.map[start2 + i]).type == types.header_cell;\n      cells.push(\n        header ? emptyHead || (emptyHead = types.header_cell.createAndFill()) : empty || (empty = types.cell.createAndFill())\n      );\n    }\n    const emptyRow = types.row.create(null, Fragment2.from(cells)), rows = [];\n    for (let i = map.height; i < height; i++)\n      rows.push(emptyRow);\n    tr.insert(tr.mapping.slice(mapFrom).map(start + table.nodeSize - 2), rows);\n  }\n  return !!(empty || emptyHead);\n}\nfunction isolateHorizontal(tr, map, table, start, left, right, top, mapFrom) {\n  if (top == 0 || top == map.height)\n    return false;\n  let found = false;\n  for (let col = left; col < right; col++) {\n    const index = top * map.width + col, pos = map.map[index];\n    if (map.map[index - map.width] == pos) {\n      found = true;\n      const cell = table.nodeAt(pos);\n      const { top: cellTop, left: cellLeft } = map.findCell(pos);\n      tr.setNodeMarkup(tr.mapping.slice(mapFrom).map(pos + start), null, {\n        ...cell.attrs,\n        rowspan: top - cellTop\n      });\n      tr.insert(\n        tr.mapping.slice(mapFrom).map(map.positionAt(top, cellLeft, table)),\n        cell.type.createAndFill({\n          ...cell.attrs,\n          rowspan: cellTop + cell.attrs.rowspan - top\n        })\n      );\n      col += cell.attrs.colspan - 1;\n    }\n  }\n  return found;\n}\nfunction isolateVertical(tr, map, table, start, top, bottom, left, mapFrom) {\n  if (left == 0 || left == map.width)\n    return false;\n  let found = false;\n  for (let row = top; row < bottom; row++) {\n    const index = row * map.width + left, pos = map.map[index];\n    if (map.map[index - 1] == pos) {\n      found = true;\n      const cell = table.nodeAt(pos);\n      const cellLeft = map.colCount(pos);\n      const updatePos = tr.mapping.slice(mapFrom).map(pos + start);\n      tr.setNodeMarkup(\n        updatePos,\n        null,\n        removeColSpan(\n          cell.attrs,\n          left - cellLeft,\n          cell.attrs.colspan - (left - cellLeft)\n        )\n      );\n      tr.insert(\n        updatePos + cell.nodeSize,\n        cell.type.createAndFill(\n          removeColSpan(cell.attrs, 0, left - cellLeft)\n        )\n      );\n      row += cell.attrs.rowspan - 1;\n    }\n  }\n  return found;\n}\nfunction insertCells(state, dispatch, tableStart, rect, cells) {\n  let table = tableStart ? state.doc.nodeAt(tableStart - 1) : state.doc;\n  if (!table) {\n    throw new Error(\"No table found\");\n  }\n  let map = TableMap.get(table);\n  const { top, left } = rect;\n  const right = left + cells.width, bottom = top + cells.height;\n  const tr = state.tr;\n  let mapFrom = 0;\n  function recomp() {\n    table = tableStart ? tr.doc.nodeAt(tableStart - 1) : tr.doc;\n    if (!table) {\n      throw new Error(\"No table found\");\n    }\n    map = TableMap.get(table);\n    mapFrom = tr.mapping.maps.length;\n  }\n  if (growTable(tr, map, table, tableStart, right, bottom, mapFrom))\n    recomp();\n  if (isolateHorizontal(tr, map, table, tableStart, left, right, top, mapFrom))\n    recomp();\n  if (isolateHorizontal(tr, map, table, tableStart, left, right, bottom, mapFrom))\n    recomp();\n  if (isolateVertical(tr, map, table, tableStart, top, bottom, left, mapFrom))\n    recomp();\n  if (isolateVertical(tr, map, table, tableStart, top, bottom, right, mapFrom))\n    recomp();\n  for (let row = top; row < bottom; row++) {\n    const from = map.positionAt(row, left, table), to = map.positionAt(row, right, table);\n    tr.replace(\n      tr.mapping.slice(mapFrom).map(from + tableStart),\n      tr.mapping.slice(mapFrom).map(to + tableStart),\n      new Slice2(cells.rows[row - top], 0, 0)\n    );\n  }\n  recomp();\n  tr.setSelection(\n    new CellSelection(\n      tr.doc.resolve(tableStart + map.positionAt(top, left, table)),\n      tr.doc.resolve(tableStart + map.positionAt(bottom - 1, right - 1, table))\n    )\n  );\n  dispatch(tr);\n}\n\n// src/input.ts\nvar handleKeyDown = keydownHandler({\n  ArrowLeft: arrow(\"horiz\", -1),\n  ArrowRight: arrow(\"horiz\", 1),\n  ArrowUp: arrow(\"vert\", -1),\n  ArrowDown: arrow(\"vert\", 1),\n  \"Shift-ArrowLeft\": shiftArrow(\"horiz\", -1),\n  \"Shift-ArrowRight\": shiftArrow(\"horiz\", 1),\n  \"Shift-ArrowUp\": shiftArrow(\"vert\", -1),\n  \"Shift-ArrowDown\": shiftArrow(\"vert\", 1),\n  Backspace: deleteCellSelection,\n  \"Mod-Backspace\": deleteCellSelection,\n  Delete: deleteCellSelection,\n  \"Mod-Delete\": deleteCellSelection\n});\nfunction maybeSetSelection(state, dispatch, selection) {\n  if (selection.eq(state.selection))\n    return false;\n  if (dispatch)\n    dispatch(state.tr.setSelection(selection).scrollIntoView());\n  return true;\n}\nfunction arrow(axis, dir) {\n  return (state, dispatch, view) => {\n    if (!view)\n      return false;\n    const sel = state.selection;\n    if (sel instanceof CellSelection) {\n      return maybeSetSelection(\n        state,\n        dispatch,\n        Selection2.near(sel.$headCell, dir)\n      );\n    }\n    if (axis != \"horiz\" && !sel.empty)\n      return false;\n    const end = atEndOfCell(view, axis, dir);\n    if (end == null)\n      return false;\n    if (axis == \"horiz\") {\n      return maybeSetSelection(\n        state,\n        dispatch,\n        Selection2.near(state.doc.resolve(sel.head + dir), dir)\n      );\n    } else {\n      const $cell = state.doc.resolve(end);\n      const $next = nextCell($cell, axis, dir);\n      let newSel;\n      if ($next)\n        newSel = Selection2.near($next, 1);\n      else if (dir < 0)\n        newSel = Selection2.near(state.doc.resolve($cell.before(-1)), -1);\n      else\n        newSel = Selection2.near(state.doc.resolve($cell.after(-1)), 1);\n      return maybeSetSelection(state, dispatch, newSel);\n    }\n  };\n}\nfunction shiftArrow(axis, dir) {\n  return (state, dispatch, view) => {\n    if (!view)\n      return false;\n    const sel = state.selection;\n    let cellSel;\n    if (sel instanceof CellSelection) {\n      cellSel = sel;\n    } else {\n      const end = atEndOfCell(view, axis, dir);\n      if (end == null)\n        return false;\n      cellSel = new CellSelection(state.doc.resolve(end));\n    }\n    const $head = nextCell(cellSel.$headCell, axis, dir);\n    if (!$head)\n      return false;\n    return maybeSetSelection(\n      state,\n      dispatch,\n      new CellSelection(cellSel.$anchorCell, $head)\n    );\n  };\n}\nfunction deleteCellSelection(state, dispatch) {\n  const sel = state.selection;\n  if (!(sel instanceof CellSelection))\n    return false;\n  if (dispatch) {\n    const tr = state.tr;\n    const baseContent = tableNodeTypes(state.schema).cell.createAndFill().content;\n    sel.forEachCell((cell, pos) => {\n      if (!cell.content.eq(baseContent))\n        tr.replace(\n          tr.mapping.map(pos + 1),\n          tr.mapping.map(pos + cell.nodeSize - 1),\n          new Slice3(baseContent, 0, 0)\n        );\n    });\n    if (tr.docChanged)\n      dispatch(tr);\n  }\n  return true;\n}\nfunction handleTripleClick(view, pos) {\n  const doc = view.state.doc, $cell = cellAround(doc.resolve(pos));\n  if (!$cell)\n    return false;\n  view.dispatch(view.state.tr.setSelection(new CellSelection($cell)));\n  return true;\n}\nfunction handlePaste(view, _, slice) {\n  if (!isInTable(view.state))\n    return false;\n  let cells = pastedCells(slice);\n  const sel = view.state.selection;\n  if (sel instanceof CellSelection) {\n    if (!cells)\n      cells = {\n        width: 1,\n        height: 1,\n        rows: [\n          Fragment3.from(\n            fitSlice(tableNodeTypes(view.state.schema).cell, slice)\n          )\n        ]\n      };\n    const table = sel.$anchorCell.node(-1);\n    const start = sel.$anchorCell.start(-1);\n    const rect = TableMap.get(table).rectBetween(\n      sel.$anchorCell.pos - start,\n      sel.$headCell.pos - start\n    );\n    cells = clipCells(cells, rect.right - rect.left, rect.bottom - rect.top);\n    insertCells(view.state, view.dispatch, start, rect, cells);\n    return true;\n  } else if (cells) {\n    const $cell = selectionCell(view.state);\n    const start = $cell.start(-1);\n    insertCells(\n      view.state,\n      view.dispatch,\n      start,\n      TableMap.get($cell.node(-1)).findCell($cell.pos - start),\n      cells\n    );\n    return true;\n  } else {\n    return false;\n  }\n}\nfunction handleMouseDown(view, startEvent) {\n  var _a;\n  if (startEvent.ctrlKey || startEvent.metaKey)\n    return;\n  const startDOMCell = domInCell(view, startEvent.target);\n  let $anchor;\n  if (startEvent.shiftKey && view.state.selection instanceof CellSelection) {\n    setCellSelection(view.state.selection.$anchorCell, startEvent);\n    startEvent.preventDefault();\n  } else if (startEvent.shiftKey && startDOMCell && ($anchor = cellAround(view.state.selection.$anchor)) != null && ((_a = cellUnderMouse(view, startEvent)) == null ? void 0 : _a.pos) != $anchor.pos) {\n    setCellSelection($anchor, startEvent);\n    startEvent.preventDefault();\n  } else if (!startDOMCell) {\n    return;\n  }\n  function setCellSelection($anchor2, event) {\n    let $head = cellUnderMouse(view, event);\n    const starting = tableEditingKey.getState(view.state) == null;\n    if (!$head || !inSameTable($anchor2, $head)) {\n      if (starting)\n        $head = $anchor2;\n      else\n        return;\n    }\n    const selection = new CellSelection($anchor2, $head);\n    if (starting || !view.state.selection.eq(selection)) {\n      const tr = view.state.tr.setSelection(selection);\n      if (starting)\n        tr.setMeta(tableEditingKey, $anchor2.pos);\n      view.dispatch(tr);\n    }\n  }\n  function stop() {\n    view.root.removeEventListener(\"mouseup\", stop);\n    view.root.removeEventListener(\"dragstart\", stop);\n    view.root.removeEventListener(\"mousemove\", move);\n    if (tableEditingKey.getState(view.state) != null)\n      view.dispatch(view.state.tr.setMeta(tableEditingKey, -1));\n  }\n  function move(_event) {\n    const event = _event;\n    const anchor = tableEditingKey.getState(view.state);\n    let $anchor2;\n    if (anchor != null) {\n      $anchor2 = view.state.doc.resolve(anchor);\n    } else if (domInCell(view, event.target) != startDOMCell) {\n      $anchor2 = cellUnderMouse(view, startEvent);\n      if (!$anchor2)\n        return stop();\n    }\n    if ($anchor2)\n      setCellSelection($anchor2, event);\n  }\n  view.root.addEventListener(\"mouseup\", stop);\n  view.root.addEventListener(\"dragstart\", stop);\n  view.root.addEventListener(\"mousemove\", move);\n}\nfunction atEndOfCell(view, axis, dir) {\n  if (!(view.state.selection instanceof TextSelection2))\n    return null;\n  const { $head } = view.state.selection;\n  for (let d = $head.depth - 1; d >= 0; d--) {\n    const parent = $head.node(d), index = dir < 0 ? $head.index(d) : $head.indexAfter(d);\n    if (index != (dir < 0 ? 0 : parent.childCount))\n      return null;\n    if (parent.type.spec.tableRole == \"cell\" || parent.type.spec.tableRole == \"header_cell\") {\n      const cellPos = $head.before(d);\n      const dirStr = axis == \"vert\" ? dir > 0 ? \"down\" : \"up\" : dir > 0 ? \"right\" : \"left\";\n      return view.endOfTextblock(dirStr) ? cellPos : null;\n    }\n  }\n  return null;\n}\nfunction domInCell(view, dom) {\n  for (; dom && dom != view.dom; dom = dom.parentNode) {\n    if (dom.nodeName == \"TD\" || dom.nodeName == \"TH\") {\n      return dom;\n    }\n  }\n  return null;\n}\nfunction cellUnderMouse(view, event) {\n  const mousePos = view.posAtCoords({\n    left: event.clientX,\n    top: event.clientY\n  });\n  if (!mousePos)\n    return null;\n  return mousePos ? cellAround(view.state.doc.resolve(mousePos.pos)) : null;\n}\n\n// src/columnresizing.ts\nimport { Plugin, PluginKey as PluginKey3 } from \"prosemirror-state\";\nimport {\n  Decoration as Decoration2,\n  DecorationSet as DecorationSet2\n} from \"prosemirror-view\";\n\n// src/tableview.ts\nvar TableView = class {\n  constructor(node, cellMinWidth) {\n    this.node = node;\n    this.cellMinWidth = cellMinWidth;\n    this.dom = document.createElement(\"div\");\n    this.dom.className = \"tableWrapper\";\n    this.table = this.dom.appendChild(document.createElement(\"table\"));\n    this.colgroup = this.table.appendChild(document.createElement(\"colgroup\"));\n    updateColumnsOnResize(node, this.colgroup, this.table, cellMinWidth);\n    this.contentDOM = this.table.appendChild(document.createElement(\"tbody\"));\n  }\n  update(node) {\n    if (node.type != this.node.type)\n      return false;\n    this.node = node;\n    updateColumnsOnResize(node, this.colgroup, this.table, this.cellMinWidth);\n    return true;\n  }\n  ignoreMutation(record) {\n    return record.type == \"attributes\" && (record.target == this.table || this.colgroup.contains(record.target));\n  }\n};\nfunction updateColumnsOnResize(node, colgroup, table, cellMinWidth, overrideCol, overrideValue) {\n  var _a;\n  let totalWidth = 0;\n  let fixedWidth = true;\n  let nextDOM = colgroup.firstChild;\n  const row = node.firstChild;\n  if (!row)\n    return;\n  for (let i = 0, col = 0; i < row.childCount; i++) {\n    const { colspan, colwidth } = row.child(i).attrs;\n    for (let j = 0; j < colspan; j++, col++) {\n      const hasWidth = overrideCol == col ? overrideValue : colwidth && colwidth[j];\n      const cssWidth = hasWidth ? hasWidth + \"px\" : \"\";\n      totalWidth += hasWidth || cellMinWidth;\n      if (!hasWidth)\n        fixedWidth = false;\n      if (!nextDOM) {\n        colgroup.appendChild(document.createElement(\"col\")).style.width = cssWidth;\n      } else {\n        if (nextDOM.style.width != cssWidth)\n          nextDOM.style.width = cssWidth;\n        nextDOM = nextDOM.nextSibling;\n      }\n    }\n  }\n  while (nextDOM) {\n    const after = nextDOM.nextSibling;\n    (_a = nextDOM.parentNode) == null ? void 0 : _a.removeChild(nextDOM);\n    nextDOM = after;\n  }\n  if (fixedWidth) {\n    table.style.width = totalWidth + \"px\";\n    table.style.minWidth = \"\";\n  } else {\n    table.style.width = \"\";\n    table.style.minWidth = totalWidth + \"px\";\n  }\n}\n\n// src/columnresizing.ts\nvar columnResizingPluginKey = new PluginKey3(\n  \"tableColumnResizing\"\n);\nfunction columnResizing({\n  handleWidth = 5,\n  cellMinWidth = 25,\n  View = TableView,\n  lastColumnResizable = true\n} = {}) {\n  const plugin = new Plugin({\n    key: columnResizingPluginKey,\n    state: {\n      init(_, state) {\n        var _a, _b;\n        const nodeViews = (_b = (_a = plugin.spec) == null ? void 0 : _a.props) == null ? void 0 : _b.nodeViews;\n        const tableName = tableNodeTypes(state.schema).table.name;\n        if (View && nodeViews) {\n          nodeViews[tableName] = (node, view) => {\n            return new View(node, cellMinWidth, view);\n          };\n        }\n        return new ResizeState(-1, false);\n      },\n      apply(tr, prev) {\n        return prev.apply(tr);\n      }\n    },\n    props: {\n      attributes: (state) => {\n        const pluginState = columnResizingPluginKey.getState(state);\n        return pluginState && pluginState.activeHandle > -1 ? { class: \"resize-cursor\" } : {};\n      },\n      handleDOMEvents: {\n        mousemove: (view, event) => {\n          handleMouseMove(\n            view,\n            event,\n            handleWidth,\n            cellMinWidth,\n            lastColumnResizable\n          );\n        },\n        mouseleave: (view) => {\n          handleMouseLeave(view);\n        },\n        mousedown: (view, event) => {\n          handleMouseDown2(view, event, cellMinWidth);\n        }\n      },\n      decorations: (state) => {\n        const pluginState = columnResizingPluginKey.getState(state);\n        if (pluginState && pluginState.activeHandle > -1) {\n          return handleDecorations(state, pluginState.activeHandle);\n        }\n      },\n      nodeViews: {}\n    }\n  });\n  return plugin;\n}\nvar ResizeState = class _ResizeState {\n  constructor(activeHandle, dragging) {\n    this.activeHandle = activeHandle;\n    this.dragging = dragging;\n  }\n  apply(tr) {\n    const state = this;\n    const action = tr.getMeta(columnResizingPluginKey);\n    if (action && action.setHandle != null)\n      return new _ResizeState(action.setHandle, false);\n    if (action && action.setDragging !== void 0)\n      return new _ResizeState(state.activeHandle, action.setDragging);\n    if (state.activeHandle > -1 && tr.docChanged) {\n      let handle = tr.mapping.map(state.activeHandle, -1);\n      if (!pointsAtCell(tr.doc.resolve(handle))) {\n        handle = -1;\n      }\n      return new _ResizeState(handle, state.dragging);\n    }\n    return state;\n  }\n};\nfunction handleMouseMove(view, event, handleWidth, cellMinWidth, lastColumnResizable) {\n  const pluginState = columnResizingPluginKey.getState(view.state);\n  if (!pluginState)\n    return;\n  if (!pluginState.dragging) {\n    const target = domCellAround(event.target);\n    let cell = -1;\n    if (target) {\n      const { left, right } = target.getBoundingClientRect();\n      if (event.clientX - left <= handleWidth)\n        cell = edgeCell(view, event, \"left\", handleWidth);\n      else if (right - event.clientX <= handleWidth)\n        cell = edgeCell(view, event, \"right\", handleWidth);\n    }\n    if (cell != pluginState.activeHandle) {\n      if (!lastColumnResizable && cell !== -1) {\n        const $cell = view.state.doc.resolve(cell);\n        const table = $cell.node(-1);\n        const map = TableMap.get(table);\n        const tableStart = $cell.start(-1);\n        const col = map.colCount($cell.pos - tableStart) + $cell.nodeAfter.attrs.colspan - 1;\n        if (col == map.width - 1) {\n          return;\n        }\n      }\n      updateHandle(view, cell);\n    }\n  }\n}\nfunction handleMouseLeave(view) {\n  const pluginState = columnResizingPluginKey.getState(view.state);\n  if (pluginState && pluginState.activeHandle > -1 && !pluginState.dragging)\n    updateHandle(view, -1);\n}\nfunction handleMouseDown2(view, event, cellMinWidth) {\n  var _a;\n  const win = (_a = view.dom.ownerDocument.defaultView) != null ? _a : window;\n  const pluginState = columnResizingPluginKey.getState(view.state);\n  if (!pluginState || pluginState.activeHandle == -1 || pluginState.dragging)\n    return false;\n  const cell = view.state.doc.nodeAt(pluginState.activeHandle);\n  const width = currentColWidth(view, pluginState.activeHandle, cell.attrs);\n  view.dispatch(\n    view.state.tr.setMeta(columnResizingPluginKey, {\n      setDragging: { startX: event.clientX, startWidth: width }\n    })\n  );\n  function finish(event2) {\n    win.removeEventListener(\"mouseup\", finish);\n    win.removeEventListener(\"mousemove\", move);\n    const pluginState2 = columnResizingPluginKey.getState(view.state);\n    if (pluginState2 == null ? void 0 : pluginState2.dragging) {\n      updateColumnWidth(\n        view,\n        pluginState2.activeHandle,\n        draggedWidth(pluginState2.dragging, event2, cellMinWidth)\n      );\n      view.dispatch(\n        view.state.tr.setMeta(columnResizingPluginKey, { setDragging: null })\n      );\n    }\n  }\n  function move(event2) {\n    if (!event2.which)\n      return finish(event2);\n    const pluginState2 = columnResizingPluginKey.getState(view.state);\n    if (!pluginState2)\n      return;\n    if (pluginState2.dragging) {\n      const dragged = draggedWidth(pluginState2.dragging, event2, cellMinWidth);\n      displayColumnWidth(view, pluginState2.activeHandle, dragged, cellMinWidth);\n    }\n  }\n  win.addEventListener(\"mouseup\", finish);\n  win.addEventListener(\"mousemove\", move);\n  event.preventDefault();\n  return true;\n}\nfunction currentColWidth(view, cellPos, { colspan, colwidth }) {\n  const width = colwidth && colwidth[colwidth.length - 1];\n  if (width)\n    return width;\n  const dom = view.domAtPos(cellPos);\n  const node = dom.node.childNodes[dom.offset];\n  let domWidth = node.offsetWidth, parts = colspan;\n  if (colwidth) {\n    for (let i = 0; i < colspan; i++)\n      if (colwidth[i]) {\n        domWidth -= colwidth[i];\n        parts--;\n      }\n  }\n  return domWidth / parts;\n}\nfunction domCellAround(target) {\n  while (target && target.nodeName != \"TD\" && target.nodeName != \"TH\")\n    target = target.classList && target.classList.contains(\"ProseMirror\") ? null : target.parentNode;\n  return target;\n}\nfunction edgeCell(view, event, side, handleWidth) {\n  const offset = side == \"right\" ? -handleWidth : handleWidth;\n  const found = view.posAtCoords({\n    left: event.clientX + offset,\n    top: event.clientY\n  });\n  if (!found)\n    return -1;\n  const { pos } = found;\n  const $cell = cellAround(view.state.doc.resolve(pos));\n  if (!$cell)\n    return -1;\n  if (side == \"right\")\n    return $cell.pos;\n  const map = TableMap.get($cell.node(-1)), start = $cell.start(-1);\n  const index = map.map.indexOf($cell.pos - start);\n  return index % map.width == 0 ? -1 : start + map.map[index - 1];\n}\nfunction draggedWidth(dragging, event, cellMinWidth) {\n  const offset = event.clientX - dragging.startX;\n  return Math.max(cellMinWidth, dragging.startWidth + offset);\n}\nfunction updateHandle(view, value) {\n  view.dispatch(\n    view.state.tr.setMeta(columnResizingPluginKey, { setHandle: value })\n  );\n}\nfunction updateColumnWidth(view, cell, width) {\n  const $cell = view.state.doc.resolve(cell);\n  const table = $cell.node(-1), map = TableMap.get(table), start = $cell.start(-1);\n  const col = map.colCount($cell.pos - start) + $cell.nodeAfter.attrs.colspan - 1;\n  const tr = view.state.tr;\n  for (let row = 0; row < map.height; row++) {\n    const mapIndex = row * map.width + col;\n    if (row && map.map[mapIndex] == map.map[mapIndex - map.width])\n      continue;\n    const pos = map.map[mapIndex];\n    const attrs = table.nodeAt(pos).attrs;\n    const index = attrs.colspan == 1 ? 0 : col - map.colCount(pos);\n    if (attrs.colwidth && attrs.colwidth[index] == width)\n      continue;\n    const colwidth = attrs.colwidth ? attrs.colwidth.slice() : zeroes(attrs.colspan);\n    colwidth[index] = width;\n    tr.setNodeMarkup(start + pos, null, { ...attrs, colwidth });\n  }\n  if (tr.docChanged)\n    view.dispatch(tr);\n}\nfunction displayColumnWidth(view, cell, width, cellMinWidth) {\n  const $cell = view.state.doc.resolve(cell);\n  const table = $cell.node(-1), start = $cell.start(-1);\n  const col = TableMap.get(table).colCount($cell.pos - start) + $cell.nodeAfter.attrs.colspan - 1;\n  let dom = view.domAtPos($cell.start(-1)).node;\n  while (dom && dom.nodeName != \"TABLE\") {\n    dom = dom.parentNode;\n  }\n  if (!dom)\n    return;\n  updateColumnsOnResize(\n    table,\n    dom.firstChild,\n    dom,\n    cellMinWidth,\n    col,\n    width\n  );\n}\nfunction zeroes(n) {\n  return Array(n).fill(0);\n}\nfunction handleDecorations(state, cell) {\n  const decorations = [];\n  const $cell = state.doc.resolve(cell);\n  const table = $cell.node(-1);\n  if (!table) {\n    return DecorationSet2.empty;\n  }\n  const map = TableMap.get(table);\n  const start = $cell.start(-1);\n  const col = map.colCount($cell.pos - start) + $cell.nodeAfter.attrs.colspan - 1;\n  for (let row = 0; row < map.height; row++) {\n    const index = col + row * map.width;\n    if ((col == map.width - 1 || map.map[index] != map.map[index + 1]) && (row == 0 || map.map[index] != map.map[index - map.width])) {\n      const cellPos = map.map[index];\n      const pos = start + cellPos + table.nodeAt(cellPos).nodeSize - 1;\n      const dom = document.createElement(\"div\");\n      dom.className = \"column-resize-handle\";\n      decorations.push(Decoration2.widget(pos, dom));\n    }\n  }\n  return DecorationSet2.create(state.doc, decorations);\n}\n\n// src/commands.ts\nimport { Fragment as Fragment4 } from \"prosemirror-model\";\nimport {\n  TextSelection as TextSelection3\n} from \"prosemirror-state\";\nfunction selectedRect(state) {\n  const sel = state.selection;\n  const $pos = selectionCell(state);\n  const table = $pos.node(-1);\n  const tableStart = $pos.start(-1);\n  const map = TableMap.get(table);\n  const rect = sel instanceof CellSelection ? map.rectBetween(\n    sel.$anchorCell.pos - tableStart,\n    sel.$headCell.pos - tableStart\n  ) : map.findCell($pos.pos - tableStart);\n  return { ...rect, tableStart, map, table };\n}\nfunction addColumn(tr, { map, tableStart, table }, col) {\n  let refColumn = col > 0 ? -1 : 0;\n  if (columnIsHeader(map, table, col + refColumn)) {\n    refColumn = col == 0 || col == map.width ? null : 0;\n  }\n  for (let row = 0; row < map.height; row++) {\n    const index = row * map.width + col;\n    if (col > 0 && col < map.width && map.map[index - 1] == map.map[index]) {\n      const pos = map.map[index];\n      const cell = table.nodeAt(pos);\n      tr.setNodeMarkup(\n        tr.mapping.map(tableStart + pos),\n        null,\n        addColSpan(cell.attrs, col - map.colCount(pos))\n      );\n      row += cell.attrs.rowspan - 1;\n    } else {\n      const type = refColumn == null ? tableNodeTypes(table.type.schema).cell : table.nodeAt(map.map[index + refColumn]).type;\n      const pos = map.positionAt(row, col, table);\n      tr.insert(tr.mapping.map(tableStart + pos), type.createAndFill());\n    }\n  }\n  return tr;\n}\nfunction addColumnBefore(state, dispatch) {\n  if (!isInTable(state))\n    return false;\n  if (dispatch) {\n    const rect = selectedRect(state);\n    dispatch(addColumn(state.tr, rect, rect.left));\n  }\n  return true;\n}\nfunction addColumnAfter(state, dispatch) {\n  if (!isInTable(state))\n    return false;\n  if (dispatch) {\n    const rect = selectedRect(state);\n    dispatch(addColumn(state.tr, rect, rect.right));\n  }\n  return true;\n}\nfunction removeColumn(tr, { map, table, tableStart }, col) {\n  const mapStart = tr.mapping.maps.length;\n  for (let row = 0; row < map.height; ) {\n    const index = row * map.width + col;\n    const pos = map.map[index];\n    const cell = table.nodeAt(pos);\n    const attrs = cell.attrs;\n    if (col > 0 && map.map[index - 1] == pos || col < map.width - 1 && map.map[index + 1] == pos) {\n      tr.setNodeMarkup(\n        tr.mapping.slice(mapStart).map(tableStart + pos),\n        null,\n        removeColSpan(attrs, col - map.colCount(pos))\n      );\n    } else {\n      const start = tr.mapping.slice(mapStart).map(tableStart + pos);\n      tr.delete(start, start + cell.nodeSize);\n    }\n    row += attrs.rowspan;\n  }\n}\nfunction deleteColumn(state, dispatch) {\n  if (!isInTable(state))\n    return false;\n  if (dispatch) {\n    const rect = selectedRect(state);\n    const tr = state.tr;\n    if (rect.left == 0 && rect.right == rect.map.width)\n      return false;\n    for (let i = rect.right - 1; ; i--) {\n      removeColumn(tr, rect, i);\n      if (i == rect.left)\n        break;\n      const table = rect.tableStart ? tr.doc.nodeAt(rect.tableStart - 1) : tr.doc;\n      if (!table) {\n        throw RangeError(\"No table found\");\n      }\n      rect.table = table;\n      rect.map = TableMap.get(table);\n    }\n    dispatch(tr);\n  }\n  return true;\n}\nfunction rowIsHeader(map, table, row) {\n  var _a;\n  const headerCell = tableNodeTypes(table.type.schema).header_cell;\n  for (let col = 0; col < map.width; col++)\n    if (((_a = table.nodeAt(map.map[col + row * map.width])) == null ? void 0 : _a.type) != headerCell)\n      return false;\n  return true;\n}\nfunction addRow(tr, { map, tableStart, table }, row) {\n  var _a;\n  let rowPos = tableStart;\n  for (let i = 0; i < row; i++)\n    rowPos += table.child(i).nodeSize;\n  const cells = [];\n  let refRow = row > 0 ? -1 : 0;\n  if (rowIsHeader(map, table, row + refRow))\n    refRow = row == 0 || row == map.height ? null : 0;\n  for (let col = 0, index = map.width * row; col < map.width; col++, index++) {\n    if (row > 0 && row < map.height && map.map[index] == map.map[index - map.width]) {\n      const pos = map.map[index];\n      const attrs = table.nodeAt(pos).attrs;\n      tr.setNodeMarkup(tableStart + pos, null, {\n        ...attrs,\n        rowspan: attrs.rowspan + 1\n      });\n      col += attrs.colspan - 1;\n    } else {\n      const type = refRow == null ? tableNodeTypes(table.type.schema).cell : (_a = table.nodeAt(map.map[index + refRow * map.width])) == null ? void 0 : _a.type;\n      const node = type == null ? void 0 : type.createAndFill();\n      if (node)\n        cells.push(node);\n    }\n  }\n  tr.insert(rowPos, tableNodeTypes(table.type.schema).row.create(null, cells));\n  return tr;\n}\nfunction addRowBefore(state, dispatch) {\n  if (!isInTable(state))\n    return false;\n  if (dispatch) {\n    const rect = selectedRect(state);\n    dispatch(addRow(state.tr, rect, rect.top));\n  }\n  return true;\n}\nfunction addRowAfter(state, dispatch) {\n  if (!isInTable(state))\n    return false;\n  if (dispatch) {\n    const rect = selectedRect(state);\n    dispatch(addRow(state.tr, rect, rect.bottom));\n  }\n  return true;\n}\nfunction removeRow(tr, { map, table, tableStart }, row) {\n  let rowPos = 0;\n  for (let i = 0; i < row; i++)\n    rowPos += table.child(i).nodeSize;\n  const nextRow = rowPos + table.child(row).nodeSize;\n  const mapFrom = tr.mapping.maps.length;\n  tr.delete(rowPos + tableStart, nextRow + tableStart);\n  const seen = /* @__PURE__ */ new Set();\n  for (let col = 0, index = row * map.width; col < map.width; col++, index++) {\n    const pos = map.map[index];\n    if (seen.has(pos))\n      continue;\n    seen.add(pos);\n    if (row > 0 && pos == map.map[index - map.width]) {\n      const attrs = table.nodeAt(pos).attrs;\n      tr.setNodeMarkup(tr.mapping.slice(mapFrom).map(pos + tableStart), null, {\n        ...attrs,\n        rowspan: attrs.rowspan - 1\n      });\n      col += attrs.colspan - 1;\n    } else if (row < map.height && pos == map.map[index + map.width]) {\n      const cell = table.nodeAt(pos);\n      const attrs = cell.attrs;\n      const copy = cell.type.create(\n        { ...attrs, rowspan: cell.attrs.rowspan - 1 },\n        cell.content\n      );\n      const newPos = map.positionAt(row + 1, col, table);\n      tr.insert(tr.mapping.slice(mapFrom).map(tableStart + newPos), copy);\n      col += attrs.colspan - 1;\n    }\n  }\n}\nfunction deleteRow(state, dispatch) {\n  if (!isInTable(state))\n    return false;\n  if (dispatch) {\n    const rect = selectedRect(state), tr = state.tr;\n    if (rect.top == 0 && rect.bottom == rect.map.height)\n      return false;\n    for (let i = rect.bottom - 1; ; i--) {\n      removeRow(tr, rect, i);\n      if (i == rect.top)\n        break;\n      const table = rect.tableStart ? tr.doc.nodeAt(rect.tableStart - 1) : tr.doc;\n      if (!table) {\n        throw RangeError(\"No table found\");\n      }\n      rect.table = table;\n      rect.map = TableMap.get(rect.table);\n    }\n    dispatch(tr);\n  }\n  return true;\n}\nfunction isEmpty(cell) {\n  const c = cell.content;\n  return c.childCount == 1 && c.child(0).isTextblock && c.child(0).childCount == 0;\n}\nfunction cellsOverlapRectangle({ width, height, map }, rect) {\n  let indexTop = rect.top * width + rect.left, indexLeft = indexTop;\n  let indexBottom = (rect.bottom - 1) * width + rect.left, indexRight = indexTop + (rect.right - rect.left - 1);\n  for (let i = rect.top; i < rect.bottom; i++) {\n    if (rect.left > 0 && map[indexLeft] == map[indexLeft - 1] || rect.right < width && map[indexRight] == map[indexRight + 1])\n      return true;\n    indexLeft += width;\n    indexRight += width;\n  }\n  for (let i = rect.left; i < rect.right; i++) {\n    if (rect.top > 0 && map[indexTop] == map[indexTop - width] || rect.bottom < height && map[indexBottom] == map[indexBottom + width])\n      return true;\n    indexTop++;\n    indexBottom++;\n  }\n  return false;\n}\nfunction mergeCells(state, dispatch) {\n  const sel = state.selection;\n  if (!(sel instanceof CellSelection) || sel.$anchorCell.pos == sel.$headCell.pos)\n    return false;\n  const rect = selectedRect(state), { map } = rect;\n  if (cellsOverlapRectangle(map, rect))\n    return false;\n  if (dispatch) {\n    const tr = state.tr;\n    const seen = {};\n    let content = Fragment4.empty;\n    let mergedPos;\n    let mergedCell;\n    for (let row = rect.top; row < rect.bottom; row++) {\n      for (let col = rect.left; col < rect.right; col++) {\n        const cellPos = map.map[row * map.width + col];\n        const cell = rect.table.nodeAt(cellPos);\n        if (seen[cellPos] || !cell)\n          continue;\n        seen[cellPos] = true;\n        if (mergedPos == null) {\n          mergedPos = cellPos;\n          mergedCell = cell;\n        } else {\n          if (!isEmpty(cell))\n            content = content.append(cell.content);\n          const mapped = tr.mapping.map(cellPos + rect.tableStart);\n          tr.delete(mapped, mapped + cell.nodeSize);\n        }\n      }\n    }\n    if (mergedPos == null || mergedCell == null) {\n      return true;\n    }\n    tr.setNodeMarkup(mergedPos + rect.tableStart, null, {\n      ...addColSpan(\n        mergedCell.attrs,\n        mergedCell.attrs.colspan,\n        rect.right - rect.left - mergedCell.attrs.colspan\n      ),\n      rowspan: rect.bottom - rect.top\n    });\n    if (content.size) {\n      const end = mergedPos + 1 + mergedCell.content.size;\n      const start = isEmpty(mergedCell) ? mergedPos + 1 : end;\n      tr.replaceWith(start + rect.tableStart, end + rect.tableStart, content);\n    }\n    tr.setSelection(\n      new CellSelection(tr.doc.resolve(mergedPos + rect.tableStart))\n    );\n    dispatch(tr);\n  }\n  return true;\n}\nfunction splitCell(state, dispatch) {\n  const nodeTypes = tableNodeTypes(state.schema);\n  return splitCellWithType(({ node }) => {\n    return nodeTypes[node.type.spec.tableRole];\n  })(state, dispatch);\n}\nfunction splitCellWithType(getCellType) {\n  return (state, dispatch) => {\n    var _a;\n    const sel = state.selection;\n    let cellNode;\n    let cellPos;\n    if (!(sel instanceof CellSelection)) {\n      cellNode = cellWrapping(sel.$from);\n      if (!cellNode)\n        return false;\n      cellPos = (_a = cellAround(sel.$from)) == null ? void 0 : _a.pos;\n    } else {\n      if (sel.$anchorCell.pos != sel.$headCell.pos)\n        return false;\n      cellNode = sel.$anchorCell.nodeAfter;\n      cellPos = sel.$anchorCell.pos;\n    }\n    if (cellNode == null || cellPos == null) {\n      return false;\n    }\n    if (cellNode.attrs.colspan == 1 && cellNode.attrs.rowspan == 1) {\n      return false;\n    }\n    if (dispatch) {\n      let baseAttrs = cellNode.attrs;\n      const attrs = [];\n      const colwidth = baseAttrs.colwidth;\n      if (baseAttrs.rowspan > 1)\n        baseAttrs = { ...baseAttrs, rowspan: 1 };\n      if (baseAttrs.colspan > 1)\n        baseAttrs = { ...baseAttrs, colspan: 1 };\n      const rect = selectedRect(state), tr = state.tr;\n      for (let i = 0; i < rect.right - rect.left; i++)\n        attrs.push(\n          colwidth ? {\n            ...baseAttrs,\n            colwidth: colwidth && colwidth[i] ? [colwidth[i]] : null\n          } : baseAttrs\n        );\n      let lastCell;\n      for (let row = rect.top; row < rect.bottom; row++) {\n        let pos = rect.map.positionAt(row, rect.left, rect.table);\n        if (row == rect.top)\n          pos += cellNode.nodeSize;\n        for (let col = rect.left, i = 0; col < rect.right; col++, i++) {\n          if (col == rect.left && row == rect.top)\n            continue;\n          tr.insert(\n            lastCell = tr.mapping.map(pos + rect.tableStart, 1),\n            getCellType({ node: cellNode, row, col }).createAndFill(attrs[i])\n          );\n        }\n      }\n      tr.setNodeMarkup(\n        cellPos,\n        getCellType({ node: cellNode, row: rect.top, col: rect.left }),\n        attrs[0]\n      );\n      if (sel instanceof CellSelection)\n        tr.setSelection(\n          new CellSelection(\n            tr.doc.resolve(sel.$anchorCell.pos),\n            lastCell ? tr.doc.resolve(lastCell) : void 0\n          )\n        );\n      dispatch(tr);\n    }\n    return true;\n  };\n}\nfunction setCellAttr(name, value) {\n  return function(state, dispatch) {\n    if (!isInTable(state))\n      return false;\n    const $cell = selectionCell(state);\n    if ($cell.nodeAfter.attrs[name] === value)\n      return false;\n    if (dispatch) {\n      const tr = state.tr;\n      if (state.selection instanceof CellSelection)\n        state.selection.forEachCell((node, pos) => {\n          if (node.attrs[name] !== value)\n            tr.setNodeMarkup(pos, null, {\n              ...node.attrs,\n              [name]: value\n            });\n        });\n      else\n        tr.setNodeMarkup($cell.pos, null, {\n          ...$cell.nodeAfter.attrs,\n          [name]: value\n        });\n      dispatch(tr);\n    }\n    return true;\n  };\n}\nfunction deprecated_toggleHeader(type) {\n  return function(state, dispatch) {\n    if (!isInTable(state))\n      return false;\n    if (dispatch) {\n      const types = tableNodeTypes(state.schema);\n      const rect = selectedRect(state), tr = state.tr;\n      const cells = rect.map.cellsInRect(\n        type == \"column\" ? {\n          left: rect.left,\n          top: 0,\n          right: rect.right,\n          bottom: rect.map.height\n        } : type == \"row\" ? {\n          left: 0,\n          top: rect.top,\n          right: rect.map.width,\n          bottom: rect.bottom\n        } : rect\n      );\n      const nodes = cells.map((pos) => rect.table.nodeAt(pos));\n      for (let i = 0; i < cells.length; i++)\n        if (nodes[i].type == types.header_cell)\n          tr.setNodeMarkup(\n            rect.tableStart + cells[i],\n            types.cell,\n            nodes[i].attrs\n          );\n      if (tr.steps.length == 0)\n        for (let i = 0; i < cells.length; i++)\n          tr.setNodeMarkup(\n            rect.tableStart + cells[i],\n            types.header_cell,\n            nodes[i].attrs\n          );\n      dispatch(tr);\n    }\n    return true;\n  };\n}\nfunction isHeaderEnabledByType(type, rect, types) {\n  const cellPositions = rect.map.cellsInRect({\n    left: 0,\n    top: 0,\n    right: type == \"row\" ? rect.map.width : 1,\n    bottom: type == \"column\" ? rect.map.height : 1\n  });\n  for (let i = 0; i < cellPositions.length; i++) {\n    const cell = rect.table.nodeAt(cellPositions[i]);\n    if (cell && cell.type !== types.header_cell) {\n      return false;\n    }\n  }\n  return true;\n}\nfunction toggleHeader(type, options) {\n  options = options || { useDeprecatedLogic: false };\n  if (options.useDeprecatedLogic)\n    return deprecated_toggleHeader(type);\n  return function(state, dispatch) {\n    if (!isInTable(state))\n      return false;\n    if (dispatch) {\n      const types = tableNodeTypes(state.schema);\n      const rect = selectedRect(state), tr = state.tr;\n      const isHeaderRowEnabled = isHeaderEnabledByType(\"row\", rect, types);\n      const isHeaderColumnEnabled = isHeaderEnabledByType(\n        \"column\",\n        rect,\n        types\n      );\n      const isHeaderEnabled = type === \"column\" ? isHeaderRowEnabled : type === \"row\" ? isHeaderColumnEnabled : false;\n      const selectionStartsAt = isHeaderEnabled ? 1 : 0;\n      const cellsRect = type == \"column\" ? {\n        left: 0,\n        top: selectionStartsAt,\n        right: 1,\n        bottom: rect.map.height\n      } : type == \"row\" ? {\n        left: selectionStartsAt,\n        top: 0,\n        right: rect.map.width,\n        bottom: 1\n      } : rect;\n      const newType = type == \"column\" ? isHeaderColumnEnabled ? types.cell : types.header_cell : type == \"row\" ? isHeaderRowEnabled ? types.cell : types.header_cell : types.cell;\n      rect.map.cellsInRect(cellsRect).forEach((relativeCellPos) => {\n        const cellPos = relativeCellPos + rect.tableStart;\n        const cell = tr.doc.nodeAt(cellPos);\n        if (cell) {\n          tr.setNodeMarkup(cellPos, newType, cell.attrs);\n        }\n      });\n      dispatch(tr);\n    }\n    return true;\n  };\n}\nvar toggleHeaderRow = toggleHeader(\"row\", {\n  useDeprecatedLogic: true\n});\nvar toggleHeaderColumn = toggleHeader(\"column\", {\n  useDeprecatedLogic: true\n});\nvar toggleHeaderCell = toggleHeader(\"cell\", {\n  useDeprecatedLogic: true\n});\nfunction findNextCell($cell, dir) {\n  if (dir < 0) {\n    const before = $cell.nodeBefore;\n    if (before)\n      return $cell.pos - before.nodeSize;\n    for (let row = $cell.index(-1) - 1, rowEnd = $cell.before(); row >= 0; row--) {\n      const rowNode = $cell.node(-1).child(row);\n      const lastChild = rowNode.lastChild;\n      if (lastChild) {\n        return rowEnd - 1 - lastChild.nodeSize;\n      }\n      rowEnd -= rowNode.nodeSize;\n    }\n  } else {\n    if ($cell.index() < $cell.parent.childCount - 1) {\n      return $cell.pos + $cell.nodeAfter.nodeSize;\n    }\n    const table = $cell.node(-1);\n    for (let row = $cell.indexAfter(-1), rowStart = $cell.after(); row < table.childCount; row++) {\n      const rowNode = table.child(row);\n      if (rowNode.childCount)\n        return rowStart + 1;\n      rowStart += rowNode.nodeSize;\n    }\n  }\n  return null;\n}\nfunction goToNextCell(direction) {\n  return function(state, dispatch) {\n    if (!isInTable(state))\n      return false;\n    const cell = findNextCell(selectionCell(state), direction);\n    if (cell == null)\n      return false;\n    if (dispatch) {\n      const $cell = state.doc.resolve(cell);\n      dispatch(\n        state.tr.setSelection(TextSelection3.between($cell, moveCellForward($cell))).scrollIntoView()\n      );\n    }\n    return true;\n  };\n}\nfunction deleteTable(state, dispatch) {\n  const $pos = state.selection.$anchor;\n  for (let d = $pos.depth; d > 0; d--) {\n    const node = $pos.node(d);\n    if (node.type.spec.tableRole == \"table\") {\n      if (dispatch)\n        dispatch(\n          state.tr.delete($pos.before(d), $pos.after(d)).scrollIntoView()\n        );\n      return true;\n    }\n  }\n  return false;\n}\n\n// src/index.ts\nfunction tableEditing({\n  allowTableNodeSelection = false\n} = {}) {\n  return new Plugin2({\n    key: tableEditingKey,\n    // This piece of state is used to remember when a mouse-drag\n    // cell-selection is happening, so that it can continue even as\n    // transactions (which might move its anchor cell) come in.\n    state: {\n      init() {\n        return null;\n      },\n      apply(tr, cur) {\n        const set = tr.getMeta(tableEditingKey);\n        if (set != null)\n          return set == -1 ? null : set;\n        if (cur == null || !tr.docChanged)\n          return cur;\n        const { deleted, pos } = tr.mapping.mapResult(cur);\n        return deleted ? null : pos;\n      }\n    },\n    props: {\n      decorations: drawCellSelection,\n      handleDOMEvents: {\n        mousedown: handleMouseDown\n      },\n      createSelectionBetween(view) {\n        return tableEditingKey.getState(view.state) != null ? view.state.selection : null;\n      },\n      handleTripleClick,\n      handleKeyDown,\n      handlePaste\n    },\n    appendTransaction(_, oldState, state) {\n      return normalizeSelection(\n        state,\n        fixTables(state, oldState),\n        allowTableNodeSelection\n      );\n    }\n  });\n}\nexport {\n  CellBookmark,\n  CellSelection,\n  ResizeState,\n  TableMap,\n  TableView,\n  clipCells as __clipCells,\n  insertCells as __insertCells,\n  pastedCells as __pastedCells,\n  addColSpan,\n  addColumn,\n  addColumnAfter,\n  addColumnBefore,\n  addRow,\n  addRowAfter,\n  addRowBefore,\n  cellAround,\n  colCount,\n  columnIsHeader,\n  columnResizing,\n  columnResizingPluginKey,\n  deleteColumn,\n  deleteRow,\n  deleteTable,\n  findCell,\n  fixTables,\n  fixTablesKey,\n  goToNextCell,\n  handlePaste,\n  inSameTable,\n  isInTable,\n  mergeCells,\n  moveCellForward,\n  nextCell,\n  pointsAtCell,\n  removeColSpan,\n  removeColumn,\n  removeRow,\n  rowIsHeader,\n  selectedRect,\n  selectionCell,\n  setCellAttr,\n  splitCell,\n  splitCellWithType,\n  tableEditing,\n  tableEditingKey,\n  tableNodeTypes,\n  tableNodes,\n  toggleHeader,\n  toggleHeaderCell,\n  toggleHeaderColumn,\n  toggleHeaderRow,\n  updateColumnsOnResize\n};\n","import { findParentNodeClosestToPos, Node, mergeAttributes, callOrReturn, getExtensionField } from '@tiptap/core';\nimport { TextSelection } from '@tiptap/pm/state';\nimport { CellSelection, addColumnBefore, addColumnAfter, deleteColumn, addRowBefore, addRowAfter, deleteRow, deleteTable, mergeCells, splitCell, toggleHeader, toggleHeaderCell, setCellAttr, goToNextCell, fixTables, columnResizing, tableEditing } from '@tiptap/pm/tables';\n\nfunction updateColumns(node, colgroup, table, cellMinWidth, overrideCol, overrideValue) {\r\n    let totalWidth = 0;\r\n    let fixedWidth = true;\r\n    let nextDOM = colgroup.firstChild;\r\n    const row = node.firstChild;\r\n    for (let i = 0, col = 0; i < row.childCount; i += 1) {\r\n        const { colspan, colwidth } = row.child(i).attrs;\r\n        for (let j = 0; j < colspan; j += 1, col += 1) {\r\n            const hasWidth = overrideCol === col ? overrideValue : colwidth && colwidth[j];\r\n            const cssWidth = hasWidth ? `${hasWidth}px` : '';\r\n            totalWidth += hasWidth || cellMinWidth;\r\n            if (!hasWidth) {\r\n                fixedWidth = false;\r\n            }\r\n            if (!nextDOM) {\r\n                colgroup.appendChild(document.createElement('col')).style.width = cssWidth;\r\n            }\r\n            else {\r\n                if (nextDOM.style.width !== cssWidth) {\r\n                    nextDOM.style.width = cssWidth;\r\n                }\r\n                nextDOM = nextDOM.nextSibling;\r\n            }\r\n        }\r\n    }\r\n    while (nextDOM) {\r\n        const after = nextDOM.nextSibling;\r\n        nextDOM.parentNode.removeChild(nextDOM);\r\n        nextDOM = after;\r\n    }\r\n    if (fixedWidth) {\r\n        table.style.width = `${totalWidth}px`;\r\n        table.style.minWidth = '';\r\n    }\r\n    else {\r\n        table.style.width = '';\r\n        table.style.minWidth = `${totalWidth}px`;\r\n    }\r\n}\r\nclass TableView {\r\n    constructor(node, cellMinWidth) {\r\n        this.node = node;\r\n        this.cellMinWidth = cellMinWidth;\r\n        this.dom = document.createElement('div');\r\n        this.dom.className = 'tableWrapper';\r\n        this.table = this.dom.appendChild(document.createElement('table'));\r\n        this.colgroup = this.table.appendChild(document.createElement('colgroup'));\r\n        updateColumns(node, this.colgroup, this.table, cellMinWidth);\r\n        this.contentDOM = this.table.appendChild(document.createElement('tbody'));\r\n    }\r\n    update(node) {\r\n        if (node.type !== this.node.type) {\r\n            return false;\r\n        }\r\n        this.node = node;\r\n        updateColumns(node, this.colgroup, this.table, this.cellMinWidth);\r\n        return true;\r\n    }\r\n    ignoreMutation(mutation) {\r\n        return (mutation.type === 'attributes'\r\n            && (mutation.target === this.table || this.colgroup.contains(mutation.target)));\r\n    }\r\n}\n\nfunction createCell(cellType, cellContent) {\r\n    if (cellContent) {\r\n        return cellType.createChecked(null, cellContent);\r\n    }\r\n    return cellType.createAndFill();\r\n}\n\nfunction getTableNodeTypes(schema) {\r\n    if (schema.cached.tableNodeTypes) {\r\n        return schema.cached.tableNodeTypes;\r\n    }\r\n    const roles = {};\r\n    Object.keys(schema.nodes).forEach(type => {\r\n        const nodeType = schema.nodes[type];\r\n        if (nodeType.spec.tableRole) {\r\n            roles[nodeType.spec.tableRole] = nodeType;\r\n        }\r\n    });\r\n    schema.cached.tableNodeTypes = roles;\r\n    return roles;\r\n}\n\nfunction createTable(schema, rowsCount, colsCount, withHeaderRow, cellContent) {\r\n    const types = getTableNodeTypes(schema);\r\n    const headerCells = [];\r\n    const cells = [];\r\n    for (let index = 0; index < colsCount; index += 1) {\r\n        const cell = createCell(types.cell, cellContent);\r\n        if (cell) {\r\n            cells.push(cell);\r\n        }\r\n        if (withHeaderRow) {\r\n            const headerCell = createCell(types.header_cell, cellContent);\r\n            if (headerCell) {\r\n                headerCells.push(headerCell);\r\n            }\r\n        }\r\n    }\r\n    const rows = [];\r\n    for (let index = 0; index < rowsCount; index += 1) {\r\n        rows.push(types.row.createChecked(null, withHeaderRow && index === 0 ? headerCells : cells));\r\n    }\r\n    return types.table.createChecked(null, rows);\r\n}\n\nfunction isCellSelection(value) {\r\n    return value instanceof CellSelection;\r\n}\n\nconst deleteTableWhenAllCellsSelected = ({ editor }) => {\r\n    const { selection } = editor.state;\r\n    if (!isCellSelection(selection)) {\r\n        return false;\r\n    }\r\n    let cellCount = 0;\r\n    const table = findParentNodeClosestToPos(selection.ranges[0].$from, node => {\r\n        return node.type.name === 'table';\r\n    });\r\n    table === null || table === void 0 ? void 0 : table.node.descendants(node => {\r\n        if (node.type.name === 'table') {\r\n            return false;\r\n        }\r\n        if (['tableCell', 'tableHeader'].includes(node.type.name)) {\r\n            cellCount += 1;\r\n        }\r\n    });\r\n    const allCellsSelected = cellCount === selection.ranges.length;\r\n    if (!allCellsSelected) {\r\n        return false;\r\n    }\r\n    editor.commands.deleteTable();\r\n    return true;\r\n};\n\nconst Table = Node.create({\r\n    name: 'table',\r\n    // @ts-ignore\r\n    addOptions() {\r\n        return {\r\n            HTMLAttributes: {},\r\n            resizable: false,\r\n            handleWidth: 5,\r\n            cellMinWidth: 25,\r\n            // TODO: fix\r\n            View: TableView,\r\n            lastColumnResizable: true,\r\n            allowTableNodeSelection: false,\r\n        };\r\n    },\r\n    content: 'tableRow+',\r\n    tableRole: 'table',\r\n    isolating: true,\r\n    group: 'block',\r\n    parseHTML() {\r\n        return [{ tag: 'table' }];\r\n    },\r\n    renderHTML({ HTMLAttributes }) {\r\n        return ['table', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), ['tbody', 0]];\r\n    },\r\n    addCommands() {\r\n        return {\r\n            insertTable: ({ rows = 3, cols = 3, withHeaderRow = true } = {}) => ({ tr, dispatch, editor }) => {\r\n                const node = createTable(editor.schema, rows, cols, withHeaderRow);\r\n                if (dispatch) {\r\n                    const offset = tr.selection.anchor + 1;\r\n                    tr.replaceSelectionWith(node)\r\n                        .scrollIntoView()\r\n                        .setSelection(TextSelection.near(tr.doc.resolve(offset)));\r\n                }\r\n                return true;\r\n            },\r\n            addColumnBefore: () => ({ state, dispatch }) => {\r\n                return addColumnBefore(state, dispatch);\r\n            },\r\n            addColumnAfter: () => ({ state, dispatch }) => {\r\n                return addColumnAfter(state, dispatch);\r\n            },\r\n            deleteColumn: () => ({ state, dispatch }) => {\r\n                return deleteColumn(state, dispatch);\r\n            },\r\n            addRowBefore: () => ({ state, dispatch }) => {\r\n                return addRowBefore(state, dispatch);\r\n            },\r\n            addRowAfter: () => ({ state, dispatch }) => {\r\n                return addRowAfter(state, dispatch);\r\n            },\r\n            deleteRow: () => ({ state, dispatch }) => {\r\n                return deleteRow(state, dispatch);\r\n            },\r\n            deleteTable: () => ({ state, dispatch }) => {\r\n                return deleteTable(state, dispatch);\r\n            },\r\n            mergeCells: () => ({ state, dispatch }) => {\r\n                return mergeCells(state, dispatch);\r\n            },\r\n            splitCell: () => ({ state, dispatch }) => {\r\n                return splitCell(state, dispatch);\r\n            },\r\n            toggleHeaderColumn: () => ({ state, dispatch }) => {\r\n                return toggleHeader('column')(state, dispatch);\r\n            },\r\n            toggleHeaderRow: () => ({ state, dispatch }) => {\r\n                return toggleHeader('row')(state, dispatch);\r\n            },\r\n            toggleHeaderCell: () => ({ state, dispatch }) => {\r\n                return toggleHeaderCell(state, dispatch);\r\n            },\r\n            mergeOrSplit: () => ({ state, dispatch }) => {\r\n                if (mergeCells(state, dispatch)) {\r\n                    return true;\r\n                }\r\n                return splitCell(state, dispatch);\r\n            },\r\n            setCellAttribute: (name, value) => ({ state, dispatch }) => {\r\n                return setCellAttr(name, value)(state, dispatch);\r\n            },\r\n            goToNextCell: () => ({ state, dispatch }) => {\r\n                return goToNextCell(1)(state, dispatch);\r\n            },\r\n            goToPreviousCell: () => ({ state, dispatch }) => {\r\n                return goToNextCell(-1)(state, dispatch);\r\n            },\r\n            fixTables: () => ({ state, dispatch }) => {\r\n                if (dispatch) {\r\n                    fixTables(state);\r\n                }\r\n                return true;\r\n            },\r\n            setCellSelection: position => ({ tr, dispatch }) => {\r\n                if (dispatch) {\r\n                    const selection = CellSelection.create(tr.doc, position.anchorCell, position.headCell);\r\n                    // @ts-ignore\r\n                    tr.setSelection(selection);\r\n                }\r\n                return true;\r\n            },\r\n        };\r\n    },\r\n    addKeyboardShortcuts() {\r\n        return {\r\n            Tab: () => {\r\n                if (this.editor.commands.goToNextCell()) {\r\n                    return true;\r\n                }\r\n                if (!this.editor.can().addRowAfter()) {\r\n                    return false;\r\n                }\r\n                return this.editor.chain().addRowAfter().goToNextCell().run();\r\n            },\r\n            'Shift-Tab': () => this.editor.commands.goToPreviousCell(),\r\n            Backspace: deleteTableWhenAllCellsSelected,\r\n            'Mod-Backspace': deleteTableWhenAllCellsSelected,\r\n            Delete: deleteTableWhenAllCellsSelected,\r\n            'Mod-Delete': deleteTableWhenAllCellsSelected,\r\n        };\r\n    },\r\n    addProseMirrorPlugins() {\r\n        const isResizable = this.options.resizable && this.editor.isEditable;\r\n        return [\r\n            ...(isResizable\r\n                ? [\r\n                    columnResizing({\r\n                        handleWidth: this.options.handleWidth,\r\n                        cellMinWidth: this.options.cellMinWidth,\r\n                        // @ts-ignore (incorrect type)\r\n                        View: this.options.View,\r\n                        // TODO: PR for @types/prosemirror-tables\r\n                        // @ts-ignore (incorrect type)\r\n                        lastColumnResizable: this.options.lastColumnResizable,\r\n                    }),\r\n                ]\r\n                : []),\r\n            tableEditing({\r\n                allowTableNodeSelection: this.options.allowTableNodeSelection,\r\n            }),\r\n        ];\r\n    },\r\n    extendNodeSchema(extension) {\r\n        const context = {\r\n            name: extension.name,\r\n            options: extension.options,\r\n            storage: extension.storage,\r\n        };\r\n        return {\r\n            tableRole: callOrReturn(getExtensionField(extension, 'tableRole', context)),\r\n        };\r\n    },\r\n});\n\nexport { Table, createTable, Table as default };\n//# sourceMappingURL=index.js.map\n","import { Table } from \"@tiptap/extension-table\";\nimport { columnResizing, tableEditing } from \"@tiptap/pm/tables\";\n/**\n * Extend the standard Table extension, but ensures that columns maintain their\n * previously set widths even when `editable=false`, and irrespective of the\n * initial `editable` state when the `editor` is created.\n */\nconst TableImproved = Table.extend({\n    // This function is taken directly from\n    // https://github.com/ueberdosis/tiptap/blob/31c3a9aad9eb37f445eadcd27135611291178ca6/packages/extension-table/src/table.ts#L229-L245,\n    // except overridden to always include `columnResizing`, even if `editable` is\n    // false. We update our RichTextContent styles so that the table resizing\n    // controls are not visible when `editable` is false, and since the editor\n    // itself has contenteditable=false, the table will remain read-only. By doing\n    // this, we can ensure that column widths are preserved when editable is false\n    // (otherwise any dragged column widths are ignored when editable is false, as\n    // reported here https://github.com/ueberdosis/tiptap/issues/2041). Moreover,\n    // we do not need any hacky workarounds to ensure that the necessary table\n    // extensions are reset when the editable state changes (since the resizable\n    // extension will be omitted if not initially editable, or wouldn't be removed\n    // if initially not editable if we relied on it being removed, as reported\n    // here https://github.com/ueberdosis/tiptap/issues/2301, which was not\n    // resolved despite what the OP there later said).\n    addProseMirrorPlugins() {\n        const isResizable = this.options.resizable;\n        return [\n            ...(isResizable\n                ? [\n                    columnResizing({\n                        handleWidth: this.options.handleWidth,\n                        cellMinWidth: this.options.cellMinWidth,\n                        // @ts-expect-error incorrect type https://github.com/ueberdosis/tiptap/blob/b0198eb14b98db5ca691bd9bfe698ffaddbc4ded/packages/extension-table/src/table.ts#L253\n                        View: this.options.View,\n                        lastColumnResizable: this.options.lastColumnResizable,\n                    }),\n                ]\n                : []),\n            tableEditing({\n                allowTableNodeSelection: this.options.allowTableNodeSelection,\n            }),\n        ];\n    },\n});\nexport default TableImproved;\n","import { Node, mergeAttributes, wrappingInputRule } from '@tiptap/core';\n\nconst inputRegex = /^\\s*>\\s$/;\r\nconst Blockquote = Node.create({\r\n    name: 'blockquote',\r\n    addOptions() {\r\n        return {\r\n            HTMLAttributes: {},\r\n        };\r\n    },\r\n    content: 'block+',\r\n    group: 'block',\r\n    defining: true,\r\n    parseHTML() {\r\n        return [\r\n            { tag: 'blockquote' },\r\n        ];\r\n    },\r\n    renderHTML({ HTMLAttributes }) {\r\n        return ['blockquote', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];\r\n    },\r\n    addCommands() {\r\n        return {\r\n            setBlockquote: () => ({ commands }) => {\r\n                return commands.wrapIn(this.name);\r\n            },\r\n            toggleBlockquote: () => ({ commands }) => {\r\n                return commands.toggleWrap(this.name);\r\n            },\r\n            unsetBlockquote: () => ({ commands }) => {\r\n                return commands.lift(this.name);\r\n            },\r\n        };\r\n    },\r\n    addKeyboardShortcuts() {\r\n        return {\r\n            'Mod-Shift-b': () => this.editor.commands.toggleBlockquote(),\r\n        };\r\n    },\r\n    addInputRules() {\r\n        return [\r\n            wrappingInputRule({\r\n                find: inputRegex,\r\n                type: this.type,\r\n            }),\r\n        ];\r\n    },\r\n});\n\nexport { Blockquote, Blockquote as default, inputRegex };\n//# sourceMappingURL=index.js.map\n","import { Mark, mergeAttributes, markInputRule, markPasteRule } from '@tiptap/core';\n\nconst starInputRegex = /(?:^|\\s)((?:\\*\\*)((?:[^*]+))(?:\\*\\*))$/;\r\nconst starPasteRegex = /(?:^|\\s)((?:\\*\\*)((?:[^*]+))(?:\\*\\*))/g;\r\nconst underscoreInputRegex = /(?:^|\\s)((?:__)((?:[^__]+))(?:__))$/;\r\nconst underscorePasteRegex = /(?:^|\\s)((?:__)((?:[^__]+))(?:__))/g;\r\nconst Bold = Mark.create({\r\n    name: 'bold',\r\n    addOptions() {\r\n        return {\r\n            HTMLAttributes: {},\r\n        };\r\n    },\r\n    parseHTML() {\r\n        return [\r\n            {\r\n                tag: 'strong',\r\n            },\r\n            {\r\n                tag: 'b',\r\n                getAttrs: node => node.style.fontWeight !== 'normal' && null,\r\n            },\r\n            {\r\n                style: 'font-weight',\r\n                getAttrs: value => /^(bold(er)?|[5-9]\\d{2,})$/.test(value) && null,\r\n            },\r\n        ];\r\n    },\r\n    renderHTML({ HTMLAttributes }) {\r\n        return ['strong', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];\r\n    },\r\n    addCommands() {\r\n        return {\r\n            setBold: () => ({ commands }) => {\r\n                return commands.setMark(this.name);\r\n            },\r\n            toggleBold: () => ({ commands }) => {\r\n                return commands.toggleMark(this.name);\r\n            },\r\n            unsetBold: () => ({ commands }) => {\r\n                return commands.unsetMark(this.name);\r\n            },\r\n        };\r\n    },\r\n    addKeyboardShortcuts() {\r\n        return {\r\n            'Mod-b': () => this.editor.commands.toggleBold(),\r\n            'Mod-B': () => this.editor.commands.toggleBold(),\r\n        };\r\n    },\r\n    addInputRules() {\r\n        return [\r\n            markInputRule({\r\n                find: starInputRegex,\r\n                type: this.type,\r\n            }),\r\n            markInputRule({\r\n                find: underscoreInputRegex,\r\n                type: this.type,\r\n            }),\r\n        ];\r\n    },\r\n    addPasteRules() {\r\n        return [\r\n            markPasteRule({\r\n                find: starPasteRegex,\r\n                type: this.type,\r\n            }),\r\n            markPasteRule({\r\n                find: underscorePasteRegex,\r\n                type: this.type,\r\n            }),\r\n        ];\r\n    },\r\n});\n\nexport { Bold, Bold as default, starInputRegex, starPasteRegex, underscoreInputRegex, underscorePasteRegex };\n//# sourceMappingURL=index.js.map\n","import { Node, mergeAttributes, Mark, getMarkAttributes, wrappingInputRule } from '@tiptap/core';\n\nconst ListItem = Node.create({\r\n    name: 'listItem',\r\n    addOptions() {\r\n        return {\r\n            HTMLAttributes: {},\r\n        };\r\n    },\r\n    content: 'paragraph block*',\r\n    defining: true,\r\n    parseHTML() {\r\n        return [\r\n            {\r\n                tag: 'li',\r\n            },\r\n        ];\r\n    },\r\n    renderHTML({ HTMLAttributes }) {\r\n        return ['li', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];\r\n    },\r\n    addKeyboardShortcuts() {\r\n        return {\r\n            Enter: () => this.editor.commands.splitListItem(this.name),\r\n            Tab: () => this.editor.commands.sinkListItem(this.name),\r\n            'Shift-Tab': () => this.editor.commands.liftListItem(this.name),\r\n        };\r\n    },\r\n});\n\nconst TextStyle = Mark.create({\r\n    name: 'textStyle',\r\n    addOptions() {\r\n        return {\r\n            HTMLAttributes: {},\r\n        };\r\n    },\r\n    parseHTML() {\r\n        return [\r\n            {\r\n                tag: 'span',\r\n                getAttrs: element => {\r\n                    const hasStyles = element.hasAttribute('style');\r\n                    if (!hasStyles) {\r\n                        return false;\r\n                    }\r\n                    return {};\r\n                },\r\n            },\r\n        ];\r\n    },\r\n    renderHTML({ HTMLAttributes }) {\r\n        return ['span', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];\r\n    },\r\n    addCommands() {\r\n        return {\r\n            removeEmptyTextStyle: () => ({ state, commands }) => {\r\n                const attributes = getMarkAttributes(state, this.type);\r\n                const hasStyles = Object.entries(attributes).some(([, value]) => !!value);\r\n                if (hasStyles) {\r\n                    return true;\r\n                }\r\n                return commands.unsetMark(this.name);\r\n            },\r\n        };\r\n    },\r\n});\n\nconst inputRegex = /^\\s*([-+*])\\s$/;\r\nconst BulletList = Node.create({\r\n    name: 'bulletList',\r\n    addOptions() {\r\n        return {\r\n            itemTypeName: 'listItem',\r\n            HTMLAttributes: {},\r\n            keepMarks: false,\r\n            keepAttributes: false,\r\n        };\r\n    },\r\n    group: 'block list',\r\n    content() {\r\n        return `${this.options.itemTypeName}+`;\r\n    },\r\n    parseHTML() {\r\n        return [\r\n            { tag: 'ul' },\r\n        ];\r\n    },\r\n    renderHTML({ HTMLAttributes }) {\r\n        return ['ul', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];\r\n    },\r\n    addCommands() {\r\n        return {\r\n            toggleBulletList: () => ({ commands, chain }) => {\r\n                if (this.options.keepAttributes) {\r\n                    return chain().toggleList(this.name, this.options.itemTypeName, this.options.keepMarks).updateAttributes(ListItem.name, this.editor.getAttributes(TextStyle.name)).run();\r\n                }\r\n                return commands.toggleList(this.name, this.options.itemTypeName, this.options.keepMarks);\r\n            },\r\n        };\r\n    },\r\n    addKeyboardShortcuts() {\r\n        return {\r\n            'Mod-Shift-8': () => this.editor.commands.toggleBulletList(),\r\n        };\r\n    },\r\n    addInputRules() {\r\n        let inputRule = wrappingInputRule({\r\n            find: inputRegex,\r\n            type: this.type,\r\n        });\r\n        if (this.options.keepMarks || this.options.keepAttributes) {\r\n            inputRule = wrappingInputRule({\r\n                find: inputRegex,\r\n                type: this.type,\r\n                keepMarks: this.options.keepMarks,\r\n                keepAttributes: this.options.keepAttributes,\r\n                getAttributes: () => { return this.editor.getAttributes(TextStyle.name); },\r\n                editor: this.editor,\r\n            });\r\n        }\r\n        return [\r\n            inputRule,\r\n        ];\r\n    },\r\n});\n\nexport { BulletList, BulletList as default, inputRegex };\n//# sourceMappingURL=index.js.map\n","import { Node, mergeAttributes, textblockTypeInputRule } from '@tiptap/core';\nimport { Plugin, PluginKey, TextSelection } from '@tiptap/pm/state';\n\nconst backtickInputRegex = /^```([a-z]+)?[\\s\\n]$/;\r\nconst tildeInputRegex = /^~~~([a-z]+)?[\\s\\n]$/;\r\nconst CodeBlock = Node.create({\r\n    name: 'codeBlock',\r\n    addOptions() {\r\n        return {\r\n            languageClassPrefix: 'language-',\r\n            exitOnTripleEnter: true,\r\n            exitOnArrowDown: true,\r\n            HTMLAttributes: {},\r\n        };\r\n    },\r\n    content: 'text*',\r\n    marks: '',\r\n    group: 'block',\r\n    code: true,\r\n    defining: true,\r\n    addAttributes() {\r\n        return {\r\n            language: {\r\n                default: null,\r\n                parseHTML: element => {\r\n                    var _a;\r\n                    const { languageClassPrefix } = this.options;\r\n                    const classNames = [...(((_a = element.firstElementChild) === null || _a === void 0 ? void 0 : _a.classList) || [])];\r\n                    const languages = classNames\r\n                        .filter(className => className.startsWith(languageClassPrefix))\r\n                        .map(className => className.replace(languageClassPrefix, ''));\r\n                    const language = languages[0];\r\n                    if (!language) {\r\n                        return null;\r\n                    }\r\n                    return language;\r\n                },\r\n                rendered: false,\r\n            },\r\n        };\r\n    },\r\n    parseHTML() {\r\n        return [\r\n            {\r\n                tag: 'pre',\r\n                preserveWhitespace: 'full',\r\n            },\r\n        ];\r\n    },\r\n    renderHTML({ node, HTMLAttributes }) {\r\n        return [\r\n            'pre',\r\n            mergeAttributes(this.options.HTMLAttributes, HTMLAttributes),\r\n            [\r\n                'code',\r\n                {\r\n                    class: node.attrs.language\r\n                        ? this.options.languageClassPrefix + node.attrs.language\r\n                        : null,\r\n                },\r\n                0,\r\n            ],\r\n        ];\r\n    },\r\n    addCommands() {\r\n        return {\r\n            setCodeBlock: attributes => ({ commands }) => {\r\n                return commands.setNode(this.name, attributes);\r\n            },\r\n            toggleCodeBlock: attributes => ({ commands }) => {\r\n                return commands.toggleNode(this.name, 'paragraph', attributes);\r\n            },\r\n        };\r\n    },\r\n    addKeyboardShortcuts() {\r\n        return {\r\n            'Mod-Alt-c': () => this.editor.commands.toggleCodeBlock(),\r\n            // remove code block when at start of document or code block is empty\r\n            Backspace: () => {\r\n                const { empty, $anchor } = this.editor.state.selection;\r\n                const isAtStart = $anchor.pos === 1;\r\n                if (!empty || $anchor.parent.type.name !== this.name) {\r\n                    return false;\r\n                }\r\n                if (isAtStart || !$anchor.parent.textContent.length) {\r\n                    return this.editor.commands.clearNodes();\r\n                }\r\n                return false;\r\n            },\r\n            // exit node on triple enter\r\n            Enter: ({ editor }) => {\r\n                if (!this.options.exitOnTripleEnter) {\r\n                    return false;\r\n                }\r\n                const { state } = editor;\r\n                const { selection } = state;\r\n                const { $from, empty } = selection;\r\n                if (!empty || $from.parent.type !== this.type) {\r\n                    return false;\r\n                }\r\n                const isAtEnd = $from.parentOffset === $from.parent.nodeSize - 2;\r\n                const endsWithDoubleNewline = $from.parent.textContent.endsWith('\\n\\n');\r\n                if (!isAtEnd || !endsWithDoubleNewline) {\r\n                    return false;\r\n                }\r\n                return editor\r\n                    .chain()\r\n                    .command(({ tr }) => {\r\n                    tr.delete($from.pos - 2, $from.pos);\r\n                    return true;\r\n                })\r\n                    .exitCode()\r\n                    .run();\r\n            },\r\n            // exit node on arrow down\r\n            ArrowDown: ({ editor }) => {\r\n                if (!this.options.exitOnArrowDown) {\r\n                    return false;\r\n                }\r\n                const { state } = editor;\r\n                const { selection, doc } = state;\r\n                const { $from, empty } = selection;\r\n                if (!empty || $from.parent.type !== this.type) {\r\n                    return false;\r\n                }\r\n                const isAtEnd = $from.parentOffset === $from.parent.nodeSize - 2;\r\n                if (!isAtEnd) {\r\n                    return false;\r\n                }\r\n                const after = $from.after();\r\n                if (after === undefined) {\r\n                    return false;\r\n                }\r\n                const nodeAfter = doc.nodeAt(after);\r\n                if (nodeAfter) {\r\n                    return false;\r\n                }\r\n                return editor.commands.exitCode();\r\n            },\r\n        };\r\n    },\r\n    addInputRules() {\r\n        return [\r\n            textblockTypeInputRule({\r\n                find: backtickInputRegex,\r\n                type: this.type,\r\n                getAttributes: match => ({\r\n                    language: match[1],\r\n                }),\r\n            }),\r\n            textblockTypeInputRule({\r\n                find: tildeInputRegex,\r\n                type: this.type,\r\n                getAttributes: match => ({\r\n                    language: match[1],\r\n                }),\r\n            }),\r\n        ];\r\n    },\r\n    addProseMirrorPlugins() {\r\n        return [\r\n            // this plugin creates a code block for pasted content from VS Code\r\n            // we can also detect the copied code language\r\n            new Plugin({\r\n                key: new PluginKey('codeBlockVSCodeHandler'),\r\n                props: {\r\n                    handlePaste: (view, event) => {\r\n                        if (!event.clipboardData) {\r\n                            return false;\r\n                        }\r\n                        // don’t create a new code block within code blocks\r\n                        if (this.editor.isActive(this.type.name)) {\r\n                            return false;\r\n                        }\r\n                        const text = event.clipboardData.getData('text/plain');\r\n                        const vscode = event.clipboardData.getData('vscode-editor-data');\r\n                        const vscodeData = vscode ? JSON.parse(vscode) : undefined;\r\n                        const language = vscodeData === null || vscodeData === void 0 ? void 0 : vscodeData.mode;\r\n                        if (!text || !language) {\r\n                            return false;\r\n                        }\r\n                        const { tr } = view.state;\r\n                        // create an empty code block\r\n                        tr.replaceSelectionWith(this.type.create({ language }));\r\n                        // put cursor inside the newly created code block\r\n                        tr.setSelection(TextSelection.near(tr.doc.resolve(Math.max(0, tr.selection.from - 2))));\r\n                        // add text to code block\r\n                        // strip carriage return chars from text pasted as code\r\n                        // see: https://github.com/ProseMirror/prosemirror-view/commit/a50a6bcceb4ce52ac8fcc6162488d8875613aacd\r\n                        tr.insertText(text.replace(/\\r\\n?/g, '\\n'));\r\n                        // store meta information\r\n                        // this is useful for other plugins that depends on the paste event\r\n                        // like the paste rule plugin\r\n                        tr.setMeta('paste', true);\r\n                        view.dispatch(tr);\r\n                        return true;\r\n                    },\r\n                },\r\n            }),\r\n        ];\r\n    },\r\n});\n\nexport { CodeBlock, backtickInputRegex, CodeBlock as default, tildeInputRegex };\n//# sourceMappingURL=index.js.map\n","import { Mark, mergeAttributes, markInputRule, markPasteRule } from '@tiptap/core';\n\nconst inputRegex = /(?:^|\\s)((?:`)((?:[^`]+))(?:`))$/;\r\nconst pasteRegex = /(?:^|\\s)((?:`)((?:[^`]+))(?:`))/g;\r\nconst Code = Mark.create({\r\n    name: 'code',\r\n    addOptions() {\r\n        return {\r\n            HTMLAttributes: {},\r\n        };\r\n    },\r\n    excludes: '_',\r\n    code: true,\r\n    exitable: true,\r\n    parseHTML() {\r\n        return [\r\n            { tag: 'code' },\r\n        ];\r\n    },\r\n    renderHTML({ HTMLAttributes }) {\r\n        return ['code', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];\r\n    },\r\n    addCommands() {\r\n        return {\r\n            setCode: () => ({ commands }) => {\r\n                return commands.setMark(this.name);\r\n            },\r\n            toggleCode: () => ({ commands }) => {\r\n                return commands.toggleMark(this.name);\r\n            },\r\n            unsetCode: () => ({ commands }) => {\r\n                return commands.unsetMark(this.name);\r\n            },\r\n        };\r\n    },\r\n    addKeyboardShortcuts() {\r\n        return {\r\n            'Mod-e': () => this.editor.commands.toggleCode(),\r\n        };\r\n    },\r\n    addInputRules() {\r\n        return [\r\n            markInputRule({\r\n                find: inputRegex,\r\n                type: this.type,\r\n            }),\r\n        ];\r\n    },\r\n    addPasteRules() {\r\n        return [\r\n            markPasteRule({\r\n                find: pasteRegex,\r\n                type: this.type,\r\n            }),\r\n        ];\r\n    },\r\n});\n\nexport { Code, Code as default, inputRegex, pasteRegex };\n//# sourceMappingURL=index.js.map\n","import '@tiptap/extension-text-style';\nimport { Extension } from '@tiptap/core';\n\nconst Color = Extension.create({\r\n    name: 'color',\r\n    addOptions() {\r\n        return {\r\n            types: ['textStyle'],\r\n        };\r\n    },\r\n    addGlobalAttributes() {\r\n        return [\r\n            {\r\n                types: this.options.types,\r\n                attributes: {\r\n                    color: {\r\n                        default: null,\r\n                        parseHTML: element => { var _a; return (_a = element.style.color) === null || _a === void 0 ? void 0 : _a.replace(/['\"]+/g, ''); },\r\n                        renderHTML: attributes => {\r\n                            if (!attributes.color) {\r\n                                return {};\r\n                            }\r\n                            return {\r\n                                style: `color: ${attributes.color}`,\r\n                            };\r\n                        },\r\n                    },\r\n                },\r\n            },\r\n        ];\r\n    },\r\n    addCommands() {\r\n        return {\r\n            setColor: color => ({ chain }) => {\r\n                return chain()\r\n                    .setMark('textStyle', { color })\r\n                    .run();\r\n            },\r\n            unsetColor: () => ({ chain }) => {\r\n                return chain()\r\n                    .setMark('textStyle', { color: null })\r\n                    .removeEmptyTextStyle()\r\n                    .run();\r\n            },\r\n        };\r\n    },\r\n});\n\nexport { Color, Color as default };\n//# sourceMappingURL=index.js.map\n","import { Node } from '@tiptap/core';\n\nconst Document = Node.create({\r\n    name: 'doc',\r\n    topNode: true,\r\n    content: 'block+',\r\n});\n\nexport { Document, Document as default };\n//# sourceMappingURL=index.js.map\n","import { Plugin } from 'prosemirror-state';\nimport { dropPoint } from 'prosemirror-transform';\n\n/**\nCreate a plugin that, when added to a ProseMirror instance,\ncauses a decoration to show up at the drop position when something\nis dragged over the editor.\n\nNodes may add a `disableDropCursor` property to their spec to\ncontrol the showing of a drop cursor inside them. This may be a\nboolean or a function, which will be called with a view and a\nposition, and should return a boolean.\n*/\nfunction dropCursor(options = {}) {\n    return new Plugin({\n        view(editorView) { return new DropCursorView(editorView, options); }\n    });\n}\nclass DropCursorView {\n    constructor(editorView, options) {\n        var _a;\n        this.editorView = editorView;\n        this.cursorPos = null;\n        this.element = null;\n        this.timeout = -1;\n        this.width = (_a = options.width) !== null && _a !== void 0 ? _a : 1;\n        this.color = options.color === false ? undefined : (options.color || \"black\");\n        this.class = options.class;\n        this.handlers = [\"dragover\", \"dragend\", \"drop\", \"dragleave\"].map(name => {\n            let handler = (e) => { this[name](e); };\n            editorView.dom.addEventListener(name, handler);\n            return { name, handler };\n        });\n    }\n    destroy() {\n        this.handlers.forEach(({ name, handler }) => this.editorView.dom.removeEventListener(name, handler));\n    }\n    update(editorView, prevState) {\n        if (this.cursorPos != null && prevState.doc != editorView.state.doc) {\n            if (this.cursorPos > editorView.state.doc.content.size)\n                this.setCursor(null);\n            else\n                this.updateOverlay();\n        }\n    }\n    setCursor(pos) {\n        if (pos == this.cursorPos)\n            return;\n        this.cursorPos = pos;\n        if (pos == null) {\n            this.element.parentNode.removeChild(this.element);\n            this.element = null;\n        }\n        else {\n            this.updateOverlay();\n        }\n    }\n    updateOverlay() {\n        let $pos = this.editorView.state.doc.resolve(this.cursorPos);\n        let isBlock = !$pos.parent.inlineContent, rect;\n        if (isBlock) {\n            let before = $pos.nodeBefore, after = $pos.nodeAfter;\n            if (before || after) {\n                let node = this.editorView.nodeDOM(this.cursorPos - (before ? before.nodeSize : 0));\n                if (node) {\n                    let nodeRect = node.getBoundingClientRect();\n                    let top = before ? nodeRect.bottom : nodeRect.top;\n                    if (before && after)\n                        top = (top + this.editorView.nodeDOM(this.cursorPos).getBoundingClientRect().top) / 2;\n                    rect = { left: nodeRect.left, right: nodeRect.right, top: top - this.width / 2, bottom: top + this.width / 2 };\n                }\n            }\n        }\n        if (!rect) {\n            let coords = this.editorView.coordsAtPos(this.cursorPos);\n            rect = { left: coords.left - this.width / 2, right: coords.left + this.width / 2, top: coords.top, bottom: coords.bottom };\n        }\n        let parent = this.editorView.dom.offsetParent;\n        if (!this.element) {\n            this.element = parent.appendChild(document.createElement(\"div\"));\n            if (this.class)\n                this.element.className = this.class;\n            this.element.style.cssText = \"position: absolute; z-index: 50; pointer-events: none;\";\n            if (this.color) {\n                this.element.style.backgroundColor = this.color;\n            }\n        }\n        this.element.classList.toggle(\"prosemirror-dropcursor-block\", isBlock);\n        this.element.classList.toggle(\"prosemirror-dropcursor-inline\", !isBlock);\n        let parentLeft, parentTop;\n        if (!parent || parent == document.body && getComputedStyle(parent).position == \"static\") {\n            parentLeft = -pageXOffset;\n            parentTop = -pageYOffset;\n        }\n        else {\n            let rect = parent.getBoundingClientRect();\n            parentLeft = rect.left - parent.scrollLeft;\n            parentTop = rect.top - parent.scrollTop;\n        }\n        this.element.style.left = (rect.left - parentLeft) + \"px\";\n        this.element.style.top = (rect.top - parentTop) + \"px\";\n        this.element.style.width = (rect.right - rect.left) + \"px\";\n        this.element.style.height = (rect.bottom - rect.top) + \"px\";\n    }\n    scheduleRemoval(timeout) {\n        clearTimeout(this.timeout);\n        this.timeout = setTimeout(() => this.setCursor(null), timeout);\n    }\n    dragover(event) {\n        if (!this.editorView.editable)\n            return;\n        let pos = this.editorView.posAtCoords({ left: event.clientX, top: event.clientY });\n        let node = pos && pos.inside >= 0 && this.editorView.state.doc.nodeAt(pos.inside);\n        let disableDropCursor = node && node.type.spec.disableDropCursor;\n        let disabled = typeof disableDropCursor == \"function\" ? disableDropCursor(this.editorView, pos, event) : disableDropCursor;\n        if (pos && !disabled) {\n            let target = pos.pos;\n            if (this.editorView.dragging && this.editorView.dragging.slice) {\n                let point = dropPoint(this.editorView.state.doc, target, this.editorView.dragging.slice);\n                if (point != null)\n                    target = point;\n            }\n            this.setCursor(target);\n            this.scheduleRemoval(5000);\n        }\n    }\n    dragend() {\n        this.scheduleRemoval(20);\n    }\n    drop() {\n        this.scheduleRemoval(20);\n    }\n    dragleave(event) {\n        if (event.target == this.editorView.dom || !this.editorView.dom.contains(event.relatedTarget))\n            this.setCursor(null);\n    }\n}\n\nexport { dropCursor };\n","import { Extension } from '@tiptap/core';\nimport { dropCursor } from '@tiptap/pm/dropcursor';\n\nconst Dropcursor = Extension.create({\r\n    name: 'dropCursor',\r\n    addOptions() {\r\n        return {\r\n            color: 'currentColor',\r\n            width: 1,\r\n            class: undefined,\r\n        };\r\n    },\r\n    addProseMirrorPlugins() {\r\n        return [\r\n            dropCursor(this.options),\r\n        ];\r\n    },\r\n});\n\nexport { Dropcursor, Dropcursor as default };\n//# sourceMappingURL=index.js.map\n","import '@tiptap/extension-text-style';\nimport { Extension } from '@tiptap/core';\n\nconst FontFamily = Extension.create({\r\n    name: 'fontFamily',\r\n    addOptions() {\r\n        return {\r\n            types: ['textStyle'],\r\n        };\r\n    },\r\n    addGlobalAttributes() {\r\n        return [\r\n            {\r\n                types: this.options.types,\r\n                attributes: {\r\n                    fontFamily: {\r\n                        default: null,\r\n                        parseHTML: element => { var _a; return (_a = element.style.fontFamily) === null || _a === void 0 ? void 0 : _a.replace(/['\"]+/g, ''); },\r\n                        renderHTML: attributes => {\r\n                            if (!attributes.fontFamily) {\r\n                                return {};\r\n                            }\r\n                            return {\r\n                                style: `font-family: ${attributes.fontFamily}`,\r\n                            };\r\n                        },\r\n                    },\r\n                },\r\n            },\r\n        ];\r\n    },\r\n    addCommands() {\r\n        return {\r\n            setFontFamily: fontFamily => ({ chain }) => {\r\n                return chain()\r\n                    .setMark('textStyle', { fontFamily })\r\n                    .run();\r\n            },\r\n            unsetFontFamily: () => ({ chain }) => {\r\n                return chain()\r\n                    .setMark('textStyle', { fontFamily: null })\r\n                    .removeEmptyTextStyle()\r\n                    .run();\r\n            },\r\n        };\r\n    },\r\n});\n\nexport { FontFamily, FontFamily as default };\n//# sourceMappingURL=index.js.map\n","import { keydownHandler } from 'prosemirror-keymap';\nimport { Selection, NodeSelection, TextSelection, Plugin } from 'prosemirror-state';\nimport { Slice, Fragment } from 'prosemirror-model';\nimport { DecorationSet, Decoration } from 'prosemirror-view';\n\n/**\nGap cursor selections are represented using this class. Its\n`$anchor` and `$head` properties both point at the cursor position.\n*/\nclass GapCursor extends Selection {\n    /**\n    Create a gap cursor.\n    */\n    constructor($pos) {\n        super($pos, $pos);\n    }\n    map(doc, mapping) {\n        let $pos = doc.resolve(mapping.map(this.head));\n        return GapCursor.valid($pos) ? new GapCursor($pos) : Selection.near($pos);\n    }\n    content() { return Slice.empty; }\n    eq(other) {\n        return other instanceof GapCursor && other.head == this.head;\n    }\n    toJSON() {\n        return { type: \"gapcursor\", pos: this.head };\n    }\n    /**\n    @internal\n    */\n    static fromJSON(doc, json) {\n        if (typeof json.pos != \"number\")\n            throw new RangeError(\"Invalid input for GapCursor.fromJSON\");\n        return new GapCursor(doc.resolve(json.pos));\n    }\n    /**\n    @internal\n    */\n    getBookmark() { return new GapBookmark(this.anchor); }\n    /**\n    @internal\n    */\n    static valid($pos) {\n        let parent = $pos.parent;\n        if (parent.isTextblock || !closedBefore($pos) || !closedAfter($pos))\n            return false;\n        let override = parent.type.spec.allowGapCursor;\n        if (override != null)\n            return override;\n        let deflt = parent.contentMatchAt($pos.index()).defaultType;\n        return deflt && deflt.isTextblock;\n    }\n    /**\n    @internal\n    */\n    static findGapCursorFrom($pos, dir, mustMove = false) {\n        search: for (;;) {\n            if (!mustMove && GapCursor.valid($pos))\n                return $pos;\n            let pos = $pos.pos, next = null;\n            // Scan up from this position\n            for (let d = $pos.depth;; d--) {\n                let parent = $pos.node(d);\n                if (dir > 0 ? $pos.indexAfter(d) < parent.childCount : $pos.index(d) > 0) {\n                    next = parent.child(dir > 0 ? $pos.indexAfter(d) : $pos.index(d) - 1);\n                    break;\n                }\n                else if (d == 0) {\n                    return null;\n                }\n                pos += dir;\n                let $cur = $pos.doc.resolve(pos);\n                if (GapCursor.valid($cur))\n                    return $cur;\n            }\n            // And then down into the next node\n            for (;;) {\n                let inside = dir > 0 ? next.firstChild : next.lastChild;\n                if (!inside) {\n                    if (next.isAtom && !next.isText && !NodeSelection.isSelectable(next)) {\n                        $pos = $pos.doc.resolve(pos + next.nodeSize * dir);\n                        mustMove = false;\n                        continue search;\n                    }\n                    break;\n                }\n                next = inside;\n                pos += dir;\n                let $cur = $pos.doc.resolve(pos);\n                if (GapCursor.valid($cur))\n                    return $cur;\n            }\n            return null;\n        }\n    }\n}\nGapCursor.prototype.visible = false;\nGapCursor.findFrom = GapCursor.findGapCursorFrom;\nSelection.jsonID(\"gapcursor\", GapCursor);\nclass GapBookmark {\n    constructor(pos) {\n        this.pos = pos;\n    }\n    map(mapping) {\n        return new GapBookmark(mapping.map(this.pos));\n    }\n    resolve(doc) {\n        let $pos = doc.resolve(this.pos);\n        return GapCursor.valid($pos) ? new GapCursor($pos) : Selection.near($pos);\n    }\n}\nfunction closedBefore($pos) {\n    for (let d = $pos.depth; d >= 0; d--) {\n        let index = $pos.index(d), parent = $pos.node(d);\n        // At the start of this parent, look at next one\n        if (index == 0) {\n            if (parent.type.spec.isolating)\n                return true;\n            continue;\n        }\n        // See if the node before (or its first ancestor) is closed\n        for (let before = parent.child(index - 1);; before = before.lastChild) {\n            if ((before.childCount == 0 && !before.inlineContent) || before.isAtom || before.type.spec.isolating)\n                return true;\n            if (before.inlineContent)\n                return false;\n        }\n    }\n    // Hit start of document\n    return true;\n}\nfunction closedAfter($pos) {\n    for (let d = $pos.depth; d >= 0; d--) {\n        let index = $pos.indexAfter(d), parent = $pos.node(d);\n        if (index == parent.childCount) {\n            if (parent.type.spec.isolating)\n                return true;\n            continue;\n        }\n        for (let after = parent.child(index);; after = after.firstChild) {\n            if ((after.childCount == 0 && !after.inlineContent) || after.isAtom || after.type.spec.isolating)\n                return true;\n            if (after.inlineContent)\n                return false;\n        }\n    }\n    return true;\n}\n\n/**\nCreate a gap cursor plugin. When enabled, this will capture clicks\nnear and arrow-key-motion past places that don't have a normally\nselectable position nearby, and create a gap cursor selection for\nthem. The cursor is drawn as an element with class\n`ProseMirror-gapcursor`. You can either include\n`style/gapcursor.css` from the package's directory or add your own\nstyles to make it visible.\n*/\nfunction gapCursor() {\n    return new Plugin({\n        props: {\n            decorations: drawGapCursor,\n            createSelectionBetween(_view, $anchor, $head) {\n                return $anchor.pos == $head.pos && GapCursor.valid($head) ? new GapCursor($head) : null;\n            },\n            handleClick,\n            handleKeyDown,\n            handleDOMEvents: { beforeinput: beforeinput }\n        }\n    });\n}\nconst handleKeyDown = keydownHandler({\n    \"ArrowLeft\": arrow(\"horiz\", -1),\n    \"ArrowRight\": arrow(\"horiz\", 1),\n    \"ArrowUp\": arrow(\"vert\", -1),\n    \"ArrowDown\": arrow(\"vert\", 1)\n});\nfunction arrow(axis, dir) {\n    const dirStr = axis == \"vert\" ? (dir > 0 ? \"down\" : \"up\") : (dir > 0 ? \"right\" : \"left\");\n    return function (state, dispatch, view) {\n        let sel = state.selection;\n        let $start = dir > 0 ? sel.$to : sel.$from, mustMove = sel.empty;\n        if (sel instanceof TextSelection) {\n            if (!view.endOfTextblock(dirStr) || $start.depth == 0)\n                return false;\n            mustMove = false;\n            $start = state.doc.resolve(dir > 0 ? $start.after() : $start.before());\n        }\n        let $found = GapCursor.findGapCursorFrom($start, dir, mustMove);\n        if (!$found)\n            return false;\n        if (dispatch)\n            dispatch(state.tr.setSelection(new GapCursor($found)));\n        return true;\n    };\n}\nfunction handleClick(view, pos, event) {\n    if (!view || !view.editable)\n        return false;\n    let $pos = view.state.doc.resolve(pos);\n    if (!GapCursor.valid($pos))\n        return false;\n    let clickPos = view.posAtCoords({ left: event.clientX, top: event.clientY });\n    if (clickPos && clickPos.inside > -1 && NodeSelection.isSelectable(view.state.doc.nodeAt(clickPos.inside)))\n        return false;\n    view.dispatch(view.state.tr.setSelection(new GapCursor($pos)));\n    return true;\n}\n// This is a hack that, when a composition starts while a gap cursor\n// is active, quickly creates an inline context for the composition to\n// happen in, to avoid it being aborted by the DOM selection being\n// moved into a valid position.\nfunction beforeinput(view, event) {\n    if (event.inputType != \"insertCompositionText\" || !(view.state.selection instanceof GapCursor))\n        return false;\n    let { $from } = view.state.selection;\n    let insert = $from.parent.contentMatchAt($from.index()).findWrapping(view.state.schema.nodes.text);\n    if (!insert)\n        return false;\n    let frag = Fragment.empty;\n    for (let i = insert.length - 1; i >= 0; i--)\n        frag = Fragment.from(insert[i].createAndFill(null, frag));\n    let tr = view.state.tr.replace($from.pos, $from.pos, new Slice(frag, 0, 0));\n    tr.setSelection(TextSelection.near(tr.doc.resolve($from.pos + 1)));\n    view.dispatch(tr);\n    return false;\n}\nfunction drawGapCursor(state) {\n    if (!(state.selection instanceof GapCursor))\n        return null;\n    let node = document.createElement(\"div\");\n    node.className = \"ProseMirror-gapcursor\";\n    return DecorationSet.create(state.doc, [Decoration.widget(state.selection.head, node, { key: \"gapcursor\" })]);\n}\n\nexport { GapCursor, gapCursor };\n","import { Extension, callOrReturn, getExtensionField } from '@tiptap/core';\nimport { gapCursor } from '@tiptap/pm/gapcursor';\n\nconst Gapcursor = Extension.create({\r\n    name: 'gapCursor',\r\n    addProseMirrorPlugins() {\r\n        return [\r\n            gapCursor(),\r\n        ];\r\n    },\r\n    extendNodeSchema(extension) {\r\n        var _a;\r\n        const context = {\r\n            name: extension.name,\r\n            options: extension.options,\r\n            storage: extension.storage,\r\n        };\r\n        return {\r\n            allowGapCursor: (_a = callOrReturn(getExtensionField(extension, 'allowGapCursor', context))) !== null && _a !== void 0 ? _a : null,\r\n        };\r\n    },\r\n});\n\nexport { Gapcursor, Gapcursor as default };\n//# sourceMappingURL=index.js.map\n","import { Node, mergeAttributes } from '@tiptap/core';\n\nconst HardBreak = Node.create({\r\n    name: 'hardBreak',\r\n    addOptions() {\r\n        return {\r\n            keepMarks: true,\r\n            HTMLAttributes: {},\r\n        };\r\n    },\r\n    inline: true,\r\n    group: 'inline',\r\n    selectable: false,\r\n    parseHTML() {\r\n        return [\r\n            { tag: 'br' },\r\n        ];\r\n    },\r\n    renderHTML({ HTMLAttributes }) {\r\n        return ['br', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes)];\r\n    },\r\n    renderText() {\r\n        return '\\n';\r\n    },\r\n    addCommands() {\r\n        return {\r\n            setHardBreak: () => ({ commands, chain, state, editor, }) => {\r\n                return commands.first([\r\n                    () => commands.exitCode(),\r\n                    () => commands.command(() => {\r\n                        const { selection, storedMarks } = state;\r\n                        if (selection.$from.parent.type.spec.isolating) {\r\n                            return false;\r\n                        }\r\n                        const { keepMarks } = this.options;\r\n                        const { splittableMarks } = editor.extensionManager;\r\n                        const marks = storedMarks\r\n                            || (selection.$to.parentOffset && selection.$from.marks());\r\n                        return chain()\r\n                            .insertContent({ type: this.name })\r\n                            .command(({ tr, dispatch }) => {\r\n                            if (dispatch && marks && keepMarks) {\r\n                                const filteredMarks = marks\r\n                                    .filter(mark => splittableMarks.includes(mark.type.name));\r\n                                tr.ensureMarks(filteredMarks);\r\n                            }\r\n                            return true;\r\n                        })\r\n                            .run();\r\n                    }),\r\n                ]);\r\n            },\r\n        };\r\n    },\r\n    addKeyboardShortcuts() {\r\n        return {\r\n            'Mod-Enter': () => this.editor.commands.setHardBreak(),\r\n            'Shift-Enter': () => this.editor.commands.setHardBreak(),\r\n        };\r\n    },\r\n});\n\nexport { HardBreak, HardBreak as default };\n//# sourceMappingURL=index.js.map\n","import { Mark, mergeAttributes, markInputRule, markPasteRule } from '@tiptap/core';\n\nconst inputRegex = /(?:^|\\s)((?:==)((?:[^~=]+))(?:==))$/;\r\nconst pasteRegex = /(?:^|\\s)((?:==)((?:[^~=]+))(?:==))/g;\r\nconst Highlight = Mark.create({\r\n    name: 'highlight',\r\n    addOptions() {\r\n        return {\r\n            multicolor: false,\r\n            HTMLAttributes: {},\r\n        };\r\n    },\r\n    addAttributes() {\r\n        if (!this.options.multicolor) {\r\n            return {};\r\n        }\r\n        return {\r\n            color: {\r\n                default: null,\r\n                parseHTML: element => element.getAttribute('data-color') || element.style.backgroundColor,\r\n                renderHTML: attributes => {\r\n                    if (!attributes.color) {\r\n                        return {};\r\n                    }\r\n                    return {\r\n                        'data-color': attributes.color,\r\n                        style: `background-color: ${attributes.color}; color: inherit`,\r\n                    };\r\n                },\r\n            },\r\n        };\r\n    },\r\n    parseHTML() {\r\n        return [\r\n            {\r\n                tag: 'mark',\r\n            },\r\n        ];\r\n    },\r\n    renderHTML({ HTMLAttributes }) {\r\n        return ['mark', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];\r\n    },\r\n    addCommands() {\r\n        return {\r\n            setHighlight: attributes => ({ commands }) => {\r\n                return commands.setMark(this.name, attributes);\r\n            },\r\n            toggleHighlight: attributes => ({ commands }) => {\r\n                return commands.toggleMark(this.name, attributes);\r\n            },\r\n            unsetHighlight: () => ({ commands }) => {\r\n                return commands.unsetMark(this.name);\r\n            },\r\n        };\r\n    },\r\n    addKeyboardShortcuts() {\r\n        return {\r\n            'Mod-Shift-h': () => this.editor.commands.toggleHighlight(),\r\n        };\r\n    },\r\n    addInputRules() {\r\n        return [\r\n            markInputRule({\r\n                find: inputRegex,\r\n                type: this.type,\r\n            }),\r\n        ];\r\n    },\r\n    addPasteRules() {\r\n        return [\r\n            markPasteRule({\r\n                find: pasteRegex,\r\n                type: this.type,\r\n            }),\r\n        ];\r\n    },\r\n});\n\nexport { Highlight, Highlight as default, inputRegex, pasteRegex };\n//# sourceMappingURL=index.js.map\n","var GOOD_LEAF_SIZE = 200;\n\n// :: class<T> A rope sequence is a persistent sequence data structure\n// that supports appending, prepending, and slicing without doing a\n// full copy. It is represented as a mostly-balanced tree.\nvar RopeSequence = function RopeSequence () {};\n\nRopeSequence.prototype.append = function append (other) {\n  if (!other.length) { return this }\n  other = RopeSequence.from(other);\n\n  return (!this.length && other) ||\n    (other.length < GOOD_LEAF_SIZE && this.leafAppend(other)) ||\n    (this.length < GOOD_LEAF_SIZE && other.leafPrepend(this)) ||\n    this.appendInner(other)\n};\n\n// :: (union<[T], RopeSequence<T>>) → RopeSequence<T>\n// Prepend an array or other rope to this one, returning a new rope.\nRopeSequence.prototype.prepend = function prepend (other) {\n  if (!other.length) { return this }\n  return RopeSequence.from(other).append(this)\n};\n\nRopeSequence.prototype.appendInner = function appendInner (other) {\n  return new Append(this, other)\n};\n\n// :: (?number, ?number) → RopeSequence<T>\n// Create a rope repesenting a sub-sequence of this rope.\nRopeSequence.prototype.slice = function slice (from, to) {\n    if ( from === void 0 ) from = 0;\n    if ( to === void 0 ) to = this.length;\n\n  if (from >= to) { return RopeSequence.empty }\n  return this.sliceInner(Math.max(0, from), Math.min(this.length, to))\n};\n\n// :: (number) → T\n// Retrieve the element at the given position from this rope.\nRopeSequence.prototype.get = function get (i) {\n  if (i < 0 || i >= this.length) { return undefined }\n  return this.getInner(i)\n};\n\n// :: ((element: T, index: number) → ?bool, ?number, ?number)\n// Call the given function for each element between the given\n// indices. This tends to be more efficient than looping over the\n// indices and calling `get`, because it doesn't have to descend the\n// tree for every element.\nRopeSequence.prototype.forEach = function forEach (f, from, to) {\n    if ( from === void 0 ) from = 0;\n    if ( to === void 0 ) to = this.length;\n\n  if (from <= to)\n    { this.forEachInner(f, from, to, 0); }\n  else\n    { this.forEachInvertedInner(f, from, to, 0); }\n};\n\n// :: ((element: T, index: number) → U, ?number, ?number) → [U]\n// Map the given functions over the elements of the rope, producing\n// a flat array.\nRopeSequence.prototype.map = function map (f, from, to) {\n    if ( from === void 0 ) from = 0;\n    if ( to === void 0 ) to = this.length;\n\n  var result = [];\n  this.forEach(function (elt, i) { return result.push(f(elt, i)); }, from, to);\n  return result\n};\n\n// :: (?union<[T], RopeSequence<T>>) → RopeSequence<T>\n// Create a rope representing the given array, or return the rope\n// itself if a rope was given.\nRopeSequence.from = function from (values) {\n  if (values instanceof RopeSequence) { return values }\n  return values && values.length ? new Leaf(values) : RopeSequence.empty\n};\n\nvar Leaf = /*@__PURE__*/(function (RopeSequence) {\n  function Leaf(values) {\n    RopeSequence.call(this);\n    this.values = values;\n  }\n\n  if ( RopeSequence ) Leaf.__proto__ = RopeSequence;\n  Leaf.prototype = Object.create( RopeSequence && RopeSequence.prototype );\n  Leaf.prototype.constructor = Leaf;\n\n  var prototypeAccessors = { length: { configurable: true },depth: { configurable: true } };\n\n  Leaf.prototype.flatten = function flatten () {\n    return this.values\n  };\n\n  Leaf.prototype.sliceInner = function sliceInner (from, to) {\n    if (from == 0 && to == this.length) { return this }\n    return new Leaf(this.values.slice(from, to))\n  };\n\n  Leaf.prototype.getInner = function getInner (i) {\n    return this.values[i]\n  };\n\n  Leaf.prototype.forEachInner = function forEachInner (f, from, to, start) {\n    for (var i = from; i < to; i++)\n      { if (f(this.values[i], start + i) === false) { return false } }\n  };\n\n  Leaf.prototype.forEachInvertedInner = function forEachInvertedInner (f, from, to, start) {\n    for (var i = from - 1; i >= to; i--)\n      { if (f(this.values[i], start + i) === false) { return false } }\n  };\n\n  Leaf.prototype.leafAppend = function leafAppend (other) {\n    if (this.length + other.length <= GOOD_LEAF_SIZE)\n      { return new Leaf(this.values.concat(other.flatten())) }\n  };\n\n  Leaf.prototype.leafPrepend = function leafPrepend (other) {\n    if (this.length + other.length <= GOOD_LEAF_SIZE)\n      { return new Leaf(other.flatten().concat(this.values)) }\n  };\n\n  prototypeAccessors.length.get = function () { return this.values.length };\n\n  prototypeAccessors.depth.get = function () { return 0 };\n\n  Object.defineProperties( Leaf.prototype, prototypeAccessors );\n\n  return Leaf;\n}(RopeSequence));\n\n// :: RopeSequence\n// The empty rope sequence.\nRopeSequence.empty = new Leaf([]);\n\nvar Append = /*@__PURE__*/(function (RopeSequence) {\n  function Append(left, right) {\n    RopeSequence.call(this);\n    this.left = left;\n    this.right = right;\n    this.length = left.length + right.length;\n    this.depth = Math.max(left.depth, right.depth) + 1;\n  }\n\n  if ( RopeSequence ) Append.__proto__ = RopeSequence;\n  Append.prototype = Object.create( RopeSequence && RopeSequence.prototype );\n  Append.prototype.constructor = Append;\n\n  Append.prototype.flatten = function flatten () {\n    return this.left.flatten().concat(this.right.flatten())\n  };\n\n  Append.prototype.getInner = function getInner (i) {\n    return i < this.left.length ? this.left.get(i) : this.right.get(i - this.left.length)\n  };\n\n  Append.prototype.forEachInner = function forEachInner (f, from, to, start) {\n    var leftLen = this.left.length;\n    if (from < leftLen &&\n        this.left.forEachInner(f, from, Math.min(to, leftLen), start) === false)\n      { return false }\n    if (to > leftLen &&\n        this.right.forEachInner(f, Math.max(from - leftLen, 0), Math.min(this.length, to) - leftLen, start + leftLen) === false)\n      { return false }\n  };\n\n  Append.prototype.forEachInvertedInner = function forEachInvertedInner (f, from, to, start) {\n    var leftLen = this.left.length;\n    if (from > leftLen &&\n        this.right.forEachInvertedInner(f, from - leftLen, Math.max(to, leftLen) - leftLen, start + leftLen) === false)\n      { return false }\n    if (to < leftLen &&\n        this.left.forEachInvertedInner(f, Math.min(from, leftLen), to, start) === false)\n      { return false }\n  };\n\n  Append.prototype.sliceInner = function sliceInner (from, to) {\n    if (from == 0 && to == this.length) { return this }\n    var leftLen = this.left.length;\n    if (to <= leftLen) { return this.left.slice(from, to) }\n    if (from >= leftLen) { return this.right.slice(from - leftLen, to - leftLen) }\n    return this.left.slice(from, leftLen).append(this.right.slice(0, to - leftLen))\n  };\n\n  Append.prototype.leafAppend = function leafAppend (other) {\n    var inner = this.right.leafAppend(other);\n    if (inner) { return new Append(this.left, inner) }\n  };\n\n  Append.prototype.leafPrepend = function leafPrepend (other) {\n    var inner = this.left.leafPrepend(other);\n    if (inner) { return new Append(inner, this.right) }\n  };\n\n  Append.prototype.appendInner = function appendInner (other) {\n    if (this.left.depth >= Math.max(this.right.depth, other.depth) + 1)\n      { return new Append(this.left, new Append(this.right, other)) }\n    return new Append(this, other)\n  };\n\n  return Append;\n}(RopeSequence));\n\nexport default RopeSequence;\n","import RopeSequence from 'rope-sequence';\nimport { Mapping } from 'prosemirror-transform';\nimport { PluginKey, Plugin } from 'prosemirror-state';\n\n// ProseMirror's history isn't simply a way to roll back to a previous\n// state, because ProseMirror supports applying changes without adding\n// them to the history (for example during collaboration).\n//\n// To this end, each 'Branch' (one for the undo history and one for\n// the redo history) keeps an array of 'Items', which can optionally\n// hold a step (an actual undoable change), and always hold a position\n// map (which is needed to move changes below them to apply to the\n// current document).\n//\n// An item that has both a step and a selection bookmark is the start\n// of an 'event' — a group of changes that will be undone or redone at\n// once. (It stores only the bookmark, since that way we don't have to\n// provide a document until the selection is actually applied, which\n// is useful when compressing.)\n// Used to schedule history compression\nconst max_empty_items = 500;\nclass Branch {\n    constructor(items, eventCount) {\n        this.items = items;\n        this.eventCount = eventCount;\n    }\n    // Pop the latest event off the branch's history and apply it\n    // to a document transform.\n    popEvent(state, preserveItems) {\n        if (this.eventCount == 0)\n            return null;\n        let end = this.items.length;\n        for (;; end--) {\n            let next = this.items.get(end - 1);\n            if (next.selection) {\n                --end;\n                break;\n            }\n        }\n        let remap, mapFrom;\n        if (preserveItems) {\n            remap = this.remapping(end, this.items.length);\n            mapFrom = remap.maps.length;\n        }\n        let transform = state.tr;\n        let selection, remaining;\n        let addAfter = [], addBefore = [];\n        this.items.forEach((item, i) => {\n            if (!item.step) {\n                if (!remap) {\n                    remap = this.remapping(end, i + 1);\n                    mapFrom = remap.maps.length;\n                }\n                mapFrom--;\n                addBefore.push(item);\n                return;\n            }\n            if (remap) {\n                addBefore.push(new Item(item.map));\n                let step = item.step.map(remap.slice(mapFrom)), map;\n                if (step && transform.maybeStep(step).doc) {\n                    map = transform.mapping.maps[transform.mapping.maps.length - 1];\n                    addAfter.push(new Item(map, undefined, undefined, addAfter.length + addBefore.length));\n                }\n                mapFrom--;\n                if (map)\n                    remap.appendMap(map, mapFrom);\n            }\n            else {\n                transform.maybeStep(item.step);\n            }\n            if (item.selection) {\n                selection = remap ? item.selection.map(remap.slice(mapFrom)) : item.selection;\n                remaining = new Branch(this.items.slice(0, end).append(addBefore.reverse().concat(addAfter)), this.eventCount - 1);\n                return false;\n            }\n        }, this.items.length, 0);\n        return { remaining: remaining, transform, selection: selection };\n    }\n    // Create a new branch with the given transform added.\n    addTransform(transform, selection, histOptions, preserveItems) {\n        let newItems = [], eventCount = this.eventCount;\n        let oldItems = this.items, lastItem = !preserveItems && oldItems.length ? oldItems.get(oldItems.length - 1) : null;\n        for (let i = 0; i < transform.steps.length; i++) {\n            let step = transform.steps[i].invert(transform.docs[i]);\n            let item = new Item(transform.mapping.maps[i], step, selection), merged;\n            if (merged = lastItem && lastItem.merge(item)) {\n                item = merged;\n                if (i)\n                    newItems.pop();\n                else\n                    oldItems = oldItems.slice(0, oldItems.length - 1);\n            }\n            newItems.push(item);\n            if (selection) {\n                eventCount++;\n                selection = undefined;\n            }\n            if (!preserveItems)\n                lastItem = item;\n        }\n        let overflow = eventCount - histOptions.depth;\n        if (overflow > DEPTH_OVERFLOW) {\n            oldItems = cutOffEvents(oldItems, overflow);\n            eventCount -= overflow;\n        }\n        return new Branch(oldItems.append(newItems), eventCount);\n    }\n    remapping(from, to) {\n        let maps = new Mapping;\n        this.items.forEach((item, i) => {\n            let mirrorPos = item.mirrorOffset != null && i - item.mirrorOffset >= from\n                ? maps.maps.length - item.mirrorOffset : undefined;\n            maps.appendMap(item.map, mirrorPos);\n        }, from, to);\n        return maps;\n    }\n    addMaps(array) {\n        if (this.eventCount == 0)\n            return this;\n        return new Branch(this.items.append(array.map(map => new Item(map))), this.eventCount);\n    }\n    // When the collab module receives remote changes, the history has\n    // to know about those, so that it can adjust the steps that were\n    // rebased on top of the remote changes, and include the position\n    // maps for the remote changes in its array of items.\n    rebased(rebasedTransform, rebasedCount) {\n        if (!this.eventCount)\n            return this;\n        let rebasedItems = [], start = Math.max(0, this.items.length - rebasedCount);\n        let mapping = rebasedTransform.mapping;\n        let newUntil = rebasedTransform.steps.length;\n        let eventCount = this.eventCount;\n        this.items.forEach(item => { if (item.selection)\n            eventCount--; }, start);\n        let iRebased = rebasedCount;\n        this.items.forEach(item => {\n            let pos = mapping.getMirror(--iRebased);\n            if (pos == null)\n                return;\n            newUntil = Math.min(newUntil, pos);\n            let map = mapping.maps[pos];\n            if (item.step) {\n                let step = rebasedTransform.steps[pos].invert(rebasedTransform.docs[pos]);\n                let selection = item.selection && item.selection.map(mapping.slice(iRebased + 1, pos));\n                if (selection)\n                    eventCount++;\n                rebasedItems.push(new Item(map, step, selection));\n            }\n            else {\n                rebasedItems.push(new Item(map));\n            }\n        }, start);\n        let newMaps = [];\n        for (let i = rebasedCount; i < newUntil; i++)\n            newMaps.push(new Item(mapping.maps[i]));\n        let items = this.items.slice(0, start).append(newMaps).append(rebasedItems);\n        let branch = new Branch(items, eventCount);\n        if (branch.emptyItemCount() > max_empty_items)\n            branch = branch.compress(this.items.length - rebasedItems.length);\n        return branch;\n    }\n    emptyItemCount() {\n        let count = 0;\n        this.items.forEach(item => { if (!item.step)\n            count++; });\n        return count;\n    }\n    // Compressing a branch means rewriting it to push the air (map-only\n    // items) out. During collaboration, these naturally accumulate\n    // because each remote change adds one. The `upto` argument is used\n    // to ensure that only the items below a given level are compressed,\n    // because `rebased` relies on a clean, untouched set of items in\n    // order to associate old items with rebased steps.\n    compress(upto = this.items.length) {\n        let remap = this.remapping(0, upto), mapFrom = remap.maps.length;\n        let items = [], events = 0;\n        this.items.forEach((item, i) => {\n            if (i >= upto) {\n                items.push(item);\n                if (item.selection)\n                    events++;\n            }\n            else if (item.step) {\n                let step = item.step.map(remap.slice(mapFrom)), map = step && step.getMap();\n                mapFrom--;\n                if (map)\n                    remap.appendMap(map, mapFrom);\n                if (step) {\n                    let selection = item.selection && item.selection.map(remap.slice(mapFrom));\n                    if (selection)\n                        events++;\n                    let newItem = new Item(map.invert(), step, selection), merged, last = items.length - 1;\n                    if (merged = items.length && items[last].merge(newItem))\n                        items[last] = merged;\n                    else\n                        items.push(newItem);\n                }\n            }\n            else if (item.map) {\n                mapFrom--;\n            }\n        }, this.items.length, 0);\n        return new Branch(RopeSequence.from(items.reverse()), events);\n    }\n}\nBranch.empty = new Branch(RopeSequence.empty, 0);\nfunction cutOffEvents(items, n) {\n    let cutPoint;\n    items.forEach((item, i) => {\n        if (item.selection && (n-- == 0)) {\n            cutPoint = i;\n            return false;\n        }\n    });\n    return items.slice(cutPoint);\n}\nclass Item {\n    constructor(\n    // The (forward) step map for this item.\n    map, \n    // The inverted step\n    step, \n    // If this is non-null, this item is the start of a group, and\n    // this selection is the starting selection for the group (the one\n    // that was active before the first step was applied)\n    selection, \n    // If this item is the inverse of a previous mapping on the stack,\n    // this points at the inverse's offset\n    mirrorOffset) {\n        this.map = map;\n        this.step = step;\n        this.selection = selection;\n        this.mirrorOffset = mirrorOffset;\n    }\n    merge(other) {\n        if (this.step && other.step && !other.selection) {\n            let step = other.step.merge(this.step);\n            if (step)\n                return new Item(step.getMap().invert(), step, this.selection);\n        }\n    }\n}\n// The value of the state field that tracks undo/redo history for that\n// state. Will be stored in the plugin state when the history plugin\n// is active.\nclass HistoryState {\n    constructor(done, undone, prevRanges, prevTime, prevComposition) {\n        this.done = done;\n        this.undone = undone;\n        this.prevRanges = prevRanges;\n        this.prevTime = prevTime;\n        this.prevComposition = prevComposition;\n    }\n}\nconst DEPTH_OVERFLOW = 20;\n// Record a transformation in undo history.\nfunction applyTransaction(history, state, tr, options) {\n    let historyTr = tr.getMeta(historyKey), rebased;\n    if (historyTr)\n        return historyTr.historyState;\n    if (tr.getMeta(closeHistoryKey))\n        history = new HistoryState(history.done, history.undone, null, 0, -1);\n    let appended = tr.getMeta(\"appendedTransaction\");\n    if (tr.steps.length == 0) {\n        return history;\n    }\n    else if (appended && appended.getMeta(historyKey)) {\n        if (appended.getMeta(historyKey).redo)\n            return new HistoryState(history.done.addTransform(tr, undefined, options, mustPreserveItems(state)), history.undone, rangesFor(tr.mapping.maps), history.prevTime, history.prevComposition);\n        else\n            return new HistoryState(history.done, history.undone.addTransform(tr, undefined, options, mustPreserveItems(state)), null, history.prevTime, history.prevComposition);\n    }\n    else if (tr.getMeta(\"addToHistory\") !== false && !(appended && appended.getMeta(\"addToHistory\") === false)) {\n        // Group transforms that occur in quick succession into one event.\n        let composition = tr.getMeta(\"composition\");\n        let newGroup = history.prevTime == 0 ||\n            (!appended && history.prevComposition != composition &&\n                (history.prevTime < (tr.time || 0) - options.newGroupDelay || !isAdjacentTo(tr, history.prevRanges)));\n        let prevRanges = appended ? mapRanges(history.prevRanges, tr.mapping) : rangesFor(tr.mapping.maps);\n        return new HistoryState(history.done.addTransform(tr, newGroup ? state.selection.getBookmark() : undefined, options, mustPreserveItems(state)), Branch.empty, prevRanges, tr.time, composition == null ? history.prevComposition : composition);\n    }\n    else if (rebased = tr.getMeta(\"rebased\")) {\n        // Used by the collab module to tell the history that some of its\n        // content has been rebased.\n        return new HistoryState(history.done.rebased(tr, rebased), history.undone.rebased(tr, rebased), mapRanges(history.prevRanges, tr.mapping), history.prevTime, history.prevComposition);\n    }\n    else {\n        return new HistoryState(history.done.addMaps(tr.mapping.maps), history.undone.addMaps(tr.mapping.maps), mapRanges(history.prevRanges, tr.mapping), history.prevTime, history.prevComposition);\n    }\n}\nfunction isAdjacentTo(transform, prevRanges) {\n    if (!prevRanges)\n        return false;\n    if (!transform.docChanged)\n        return true;\n    let adjacent = false;\n    transform.mapping.maps[0].forEach((start, end) => {\n        for (let i = 0; i < prevRanges.length; i += 2)\n            if (start <= prevRanges[i + 1] && end >= prevRanges[i])\n                adjacent = true;\n    });\n    return adjacent;\n}\nfunction rangesFor(maps) {\n    let result = [];\n    for (let i = maps.length - 1; i >= 0 && result.length == 0; i--)\n        maps[i].forEach((_from, _to, from, to) => result.push(from, to));\n    return result;\n}\nfunction mapRanges(ranges, mapping) {\n    if (!ranges)\n        return null;\n    let result = [];\n    for (let i = 0; i < ranges.length; i += 2) {\n        let from = mapping.map(ranges[i], 1), to = mapping.map(ranges[i + 1], -1);\n        if (from <= to)\n            result.push(from, to);\n    }\n    return result;\n}\n// Apply the latest event from one branch to the document and shift the event\n// onto the other branch.\nfunction histTransaction(history, state, redo) {\n    let preserveItems = mustPreserveItems(state);\n    let histOptions = historyKey.get(state).spec.config;\n    let pop = (redo ? history.undone : history.done).popEvent(state, preserveItems);\n    if (!pop)\n        return null;\n    let selection = pop.selection.resolve(pop.transform.doc);\n    let added = (redo ? history.done : history.undone).addTransform(pop.transform, state.selection.getBookmark(), histOptions, preserveItems);\n    let newHist = new HistoryState(redo ? added : pop.remaining, redo ? pop.remaining : added, null, 0, -1);\n    return pop.transform.setSelection(selection).setMeta(historyKey, { redo, historyState: newHist });\n}\nlet cachedPreserveItems = false, cachedPreserveItemsPlugins = null;\n// Check whether any plugin in the given state has a\n// `historyPreserveItems` property in its spec, in which case we must\n// preserve steps exactly as they came in, so that they can be\n// rebased.\nfunction mustPreserveItems(state) {\n    let plugins = state.plugins;\n    if (cachedPreserveItemsPlugins != plugins) {\n        cachedPreserveItems = false;\n        cachedPreserveItemsPlugins = plugins;\n        for (let i = 0; i < plugins.length; i++)\n            if (plugins[i].spec.historyPreserveItems) {\n                cachedPreserveItems = true;\n                break;\n            }\n    }\n    return cachedPreserveItems;\n}\n/**\nSet a flag on the given transaction that will prevent further steps\nfrom being appended to an existing history event (so that they\nrequire a separate undo command to undo).\n*/\nfunction closeHistory(tr) {\n    return tr.setMeta(closeHistoryKey, true);\n}\nconst historyKey = new PluginKey(\"history\");\nconst closeHistoryKey = new PluginKey(\"closeHistory\");\n/**\nReturns a plugin that enables the undo history for an editor. The\nplugin will track undo and redo stacks, which can be used with the\n[`undo`](https://prosemirror.net/docs/ref/#history.undo) and [`redo`](https://prosemirror.net/docs/ref/#history.redo) commands.\n\nYou can set an `\"addToHistory\"` [metadata\nproperty](https://prosemirror.net/docs/ref/#state.Transaction.setMeta) of `false` on a transaction\nto prevent it from being rolled back by undo.\n*/\nfunction history(config = {}) {\n    config = { depth: config.depth || 100,\n        newGroupDelay: config.newGroupDelay || 500 };\n    return new Plugin({\n        key: historyKey,\n        state: {\n            init() {\n                return new HistoryState(Branch.empty, Branch.empty, null, 0, -1);\n            },\n            apply(tr, hist, state) {\n                return applyTransaction(hist, state, tr, config);\n            }\n        },\n        config,\n        props: {\n            handleDOMEvents: {\n                beforeinput(view, e) {\n                    let inputType = e.inputType;\n                    let command = inputType == \"historyUndo\" ? undo : inputType == \"historyRedo\" ? redo : null;\n                    if (!command)\n                        return false;\n                    e.preventDefault();\n                    return command(view.state, view.dispatch);\n                }\n            }\n        }\n    });\n}\nfunction buildCommand(redo, scroll) {\n    return (state, dispatch) => {\n        let hist = historyKey.getState(state);\n        if (!hist || (redo ? hist.undone : hist.done).eventCount == 0)\n            return false;\n        if (dispatch) {\n            let tr = histTransaction(hist, state, redo);\n            if (tr)\n                dispatch(scroll ? tr.scrollIntoView() : tr);\n        }\n        return true;\n    };\n}\n/**\nA command function that undoes the last change, if any.\n*/\nconst undo = buildCommand(false, true);\n/**\nA command function that redoes the last undone change, if any.\n*/\nconst redo = buildCommand(true, true);\n/**\nA command function that undoes the last change. Don't scroll the\nselection into view.\n*/\nconst undoNoScroll = buildCommand(false, false);\n/**\nA command function that redoes the last undone change. Don't\nscroll the selection into view.\n*/\nconst redoNoScroll = buildCommand(true, false);\n/**\nThe amount of undoable events available in a given state.\n*/\nfunction undoDepth(state) {\n    let hist = historyKey.getState(state);\n    return hist ? hist.done.eventCount : 0;\n}\n/**\nThe amount of redoable events available in a given editor state.\n*/\nfunction redoDepth(state) {\n    let hist = historyKey.getState(state);\n    return hist ? hist.undone.eventCount : 0;\n}\n\nexport { closeHistory, history, redo, redoDepth, redoNoScroll, undo, undoDepth, undoNoScroll };\n","import { Extension } from '@tiptap/core';\nimport { undo, redo, history } from '@tiptap/pm/history';\n\nconst History = Extension.create({\r\n    name: 'history',\r\n    addOptions() {\r\n        return {\r\n            depth: 100,\r\n            newGroupDelay: 500,\r\n        };\r\n    },\r\n    addCommands() {\r\n        return {\r\n            undo: () => ({ state, dispatch }) => {\r\n                return undo(state, dispatch);\r\n            },\r\n            redo: () => ({ state, dispatch }) => {\r\n                return redo(state, dispatch);\r\n            },\r\n        };\r\n    },\r\n    addProseMirrorPlugins() {\r\n        return [\r\n            history(this.options),\r\n        ];\r\n    },\r\n    addKeyboardShortcuts() {\r\n        return {\r\n            'Mod-z': () => this.editor.commands.undo(),\r\n            'Mod-y': () => this.editor.commands.redo(),\r\n            'Shift-Mod-z': () => this.editor.commands.redo(),\r\n            // Russian keyboard layouts\r\n            'Mod-я': () => this.editor.commands.undo(),\r\n            'Shift-Mod-я': () => this.editor.commands.redo(),\r\n        };\r\n    },\r\n});\n\nexport { History, History as default };\n//# sourceMappingURL=index.js.map\n","import { Node, mergeAttributes, nodeInputRule } from '@tiptap/core';\nimport { TextSelection } from '@tiptap/pm/state';\n\nconst HorizontalRule = Node.create({\r\n    name: 'horizontalRule',\r\n    addOptions() {\r\n        return {\r\n            HTMLAttributes: {},\r\n        };\r\n    },\r\n    group: 'block',\r\n    parseHTML() {\r\n        return [{ tag: 'hr' }];\r\n    },\r\n    renderHTML({ HTMLAttributes }) {\r\n        return ['hr', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes)];\r\n    },\r\n    addCommands() {\r\n        return {\r\n            setHorizontalRule: () => ({ chain }) => {\r\n                return (chain()\r\n                    .insertContent({ type: this.name })\r\n                    // set cursor after horizontal rule\r\n                    .command(({ tr, dispatch }) => {\r\n                    var _a;\r\n                    if (dispatch) {\r\n                        const { $to } = tr.selection;\r\n                        const posAfter = $to.end();\r\n                        if ($to.nodeAfter) {\r\n                            tr.setSelection(TextSelection.create(tr.doc, $to.pos));\r\n                        }\r\n                        else {\r\n                            // add node after horizontal rule if it’s the end of the document\r\n                            const node = (_a = $to.parent.type.contentMatch.defaultType) === null || _a === void 0 ? void 0 : _a.create();\r\n                            if (node) {\r\n                                tr.insert(posAfter, node);\r\n                                tr.setSelection(TextSelection.create(tr.doc, posAfter));\r\n                            }\r\n                        }\r\n                        tr.scrollIntoView();\r\n                    }\r\n                    return true;\r\n                })\r\n                    .run());\r\n            },\r\n        };\r\n    },\r\n    addInputRules() {\r\n        return [\r\n            nodeInputRule({\r\n                find: /^(?:---|—-|___\\s|\\*\\*\\*\\s)$/,\r\n                type: this.type,\r\n            }),\r\n        ];\r\n    },\r\n});\n\nexport { HorizontalRule, HorizontalRule as default };\n//# sourceMappingURL=index.js.map\n","import { Mark, mergeAttributes, markInputRule, markPasteRule } from '@tiptap/core';\n\nconst starInputRegex = /(?:^|\\s)((?:\\*)((?:[^*]+))(?:\\*))$/;\r\nconst starPasteRegex = /(?:^|\\s)((?:\\*)((?:[^*]+))(?:\\*))/g;\r\nconst underscoreInputRegex = /(?:^|\\s)((?:_)((?:[^_]+))(?:_))$/;\r\nconst underscorePasteRegex = /(?:^|\\s)((?:_)((?:[^_]+))(?:_))/g;\r\nconst Italic = Mark.create({\r\n    name: 'italic',\r\n    addOptions() {\r\n        return {\r\n            HTMLAttributes: {},\r\n        };\r\n    },\r\n    parseHTML() {\r\n        return [\r\n            {\r\n                tag: 'em',\r\n            },\r\n            {\r\n                tag: 'i',\r\n                getAttrs: node => node.style.fontStyle !== 'normal' && null,\r\n            },\r\n            {\r\n                style: 'font-style=italic',\r\n            },\r\n        ];\r\n    },\r\n    renderHTML({ HTMLAttributes }) {\r\n        return ['em', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];\r\n    },\r\n    addCommands() {\r\n        return {\r\n            setItalic: () => ({ commands }) => {\r\n                return commands.setMark(this.name);\r\n            },\r\n            toggleItalic: () => ({ commands }) => {\r\n                return commands.toggleMark(this.name);\r\n            },\r\n            unsetItalic: () => ({ commands }) => {\r\n                return commands.unsetMark(this.name);\r\n            },\r\n        };\r\n    },\r\n    addKeyboardShortcuts() {\r\n        return {\r\n            'Mod-i': () => this.editor.commands.toggleItalic(),\r\n            'Mod-I': () => this.editor.commands.toggleItalic(),\r\n        };\r\n    },\r\n    addInputRules() {\r\n        return [\r\n            markInputRule({\r\n                find: starInputRegex,\r\n                type: this.type,\r\n            }),\r\n            markInputRule({\r\n                find: underscoreInputRegex,\r\n                type: this.type,\r\n            }),\r\n        ];\r\n    },\r\n    addPasteRules() {\r\n        return [\r\n            markPasteRule({\r\n                find: starPasteRegex,\r\n                type: this.type,\r\n            }),\r\n            markPasteRule({\r\n                find: underscorePasteRegex,\r\n                type: this.type,\r\n            }),\r\n        ];\r\n    },\r\n});\n\nexport { Italic, Italic as default, starInputRegex, starPasteRegex, underscoreInputRegex, underscorePasteRegex };\n//# sourceMappingURL=index.js.map\n","// THIS FILE IS AUTOMATICALLY GENERATED DO NOT EDIT DIRECTLY\n// See update-tlds.js for encoding/decoding format\n// https://data.iana.org/TLD/tlds-alpha-by-domain.txt\nconst encodedTlds = 'aaa1rp3bb0ott3vie4c1le2ogado5udhabi7c0ademy5centure6ountant0s9o1tor4d0s1ult4e0g1ro2tna4f0l1rica5g0akhan5ency5i0g1rbus3force5tel5kdn3l0ibaba4pay4lfinanz6state5y2sace3tom5m0azon4ericanexpress7family11x2fam3ica3sterdam8nalytics7droid5quan4z2o0l2partments8p0le4q0uarelle8r0ab1mco4chi3my2pa2t0e3s0da2ia2sociates9t0hleta5torney7u0ction5di0ble3o3spost5thor3o0s4vianca6w0s2x0a2z0ure5ba0by2idu3namex3narepublic11d1k2r0celona5laycard4s5efoot5gains6seball5ketball8uhaus5yern5b0c1t1va3cg1n2d1e0ats2uty4er2ntley5rlin4st0buy5t2f1g1h0arti5i0ble3d1ke2ng0o3o1z2j1lack0friday9ockbuster8g1omberg7ue3m0s1w2n0pparibas9o0ats3ehringer8fa2m1nd2o0k0ing5sch2tik2on4t1utique6x2r0adesco6idgestone9oadway5ker3ther5ussels7s1t1uild0ers6siness6y1zz3v1w1y1z0h3ca0b1fe2l0l1vinklein9m0era3p2non3petown5ital0one8r0avan4ds2e0er0s4s2sa1e1h1ino4t0ering5holic7ba1n1re3c1d1enter4o1rn3f0a1d2g1h0anel2nel4rity4se2t2eap3intai5ristmas6ome4urch5i0priani6rcle4sco3tadel4i0c2y3k1l0aims4eaning6ick2nic1que6othing5ud3ub0med6m1n1o0ach3des3ffee4llege4ogne5m0cast4mbank4unity6pany2re3uter5sec4ndos3struction8ulting7tact3ractors9oking4l1p2rsica5untry4pon0s4rses6pa2r0edit0card4union9icket5own3s1uise0s6u0isinella9v1w1x1y0mru3ou3z2dabur3d1nce3ta1e1ing3sun4y2clk3ds2e0al0er2s3gree4livery5l1oitte5ta3mocrat6ntal2ist5si0gn4v2hl2iamonds6et2gital5rect0ory7scount3ver5h2y2j1k1m1np2o0cs1tor4g1mains5t1wnload7rive4tv2ubai3nlop4pont4rban5vag2r2z2earth3t2c0o2deka3u0cation8e1g1mail3erck5nergy4gineer0ing9terprises10pson4quipment8r0icsson6ni3s0q1tate5t1u0rovision8s2vents5xchange6pert3osed4ress5traspace10fage2il1rwinds6th3mily4n0s2rm0ers5shion4t3edex3edback6rrari3ero6i0delity5o2lm2nal1nce1ial7re0stone6mdale6sh0ing5t0ness6j1k1lickr3ghts4r2orist4wers5y2m1o0o0d1tball6rd1ex2sale4um3undation8x2r0ee1senius7l1ogans4ntier7tr2ujitsu5n0d2rniture7tbol5yi3ga0l0lery3o1up4me0s3p1rden4y2b0iz3d0n2e0a1nt0ing5orge5f1g0ee3h1i0ft0s3ves2ing5l0ass3e1obal2o4m0ail3bh2o1x2n1odaddy5ld0point6f2o0dyear5g0le4p1t1v2p1q1r0ainger5phics5tis4een3ipe3ocery4up4s1t1u0ardian6cci3ge2ide2tars5ru3w1y2hair2mburg5ngout5us3bo2dfc0bank7ealth0care8lp1sinki6re1mes5iphop4samitsu7tachi5v2k0t2m1n1ockey4ldings5iday5medepot5goods5s0ense7nda3rse3spital5t0ing5t0els3mail5use3w2r1sbc3t1u0ghes5yatt3undai7ibm2cbc2e1u2d1e0ee3fm2kano4l1m0amat4db2mo0bilien9n0c1dustries8finiti5o2g1k1stitute6urance4e4t0ernational10uit4vestments10o1piranga7q1r0ish4s0maili5t0anbul7t0au2v3jaguar4va3cb2e0ep2tzt3welry6io2ll2m0p2nj2o0bs1urg4t1y2p0morgan6rs3uegos4niper7kaufen5ddi3e0rryhotels6logistics9properties14fh2g1h1i0a1ds2m1ndle4tchen5wi3m1n1oeln3matsu5sher5p0mg2n2r0d1ed3uokgroup8w1y0oto4z2la0caixa5mborghini8er3ncaster6d0rover6xess5salle5t0ino3robe5w0yer5b1c1ds2ease3clerc5frak4gal2o2xus4gbt3i0dl2fe0insurance9style7ghting6ke2lly3mited4o2ncoln4k2psy3ve1ing5k1lc1p2oan0s3cker3us3l1ndon4tte1o3ve3pl0financial11r1s1t0d0a3u0ndbeck6xe1ury5v1y2ma0drid4if1son4keup4n0agement7go3p1rket0ing3s4riott5shalls7ttel5ba2c0kinsey7d1e0d0ia3et2lbourne7me1orial6n0u2rckmsd7g1h1iami3crosoft7l1ni1t2t0subishi9k1l0b1s2m0a2n1o0bi0le4da2e1i1m1nash3ey2ster5rmon3tgage6scow4to0rcycles9v0ie4p1q1r1s0d2t0n1r2u0seum3ic4v1w1x1y1z2na0b1goya4me2tura4vy3ba2c1e0c1t0bank4flix4work5ustar5w0s2xt0direct7us4f0l2g0o2hk2i0co2ke1on3nja3ssan1y5l1o0kia3rton4w0ruz3tv4p1r0a1w2tt2u1yc2z2obi1server7ffice5kinawa6layan0group9dnavy5lo3m0ega4ne1g1l0ine5oo2pen3racle3nge4g0anic5igins6saka4tsuka4t2vh3pa0ge2nasonic7ris2s1tners4s1y3y2ccw3e0t2f0izer5g1h0armacy6d1ilips5one2to0graphy6s4ysio5ics1tet2ures6d1n0g1k2oneer5zza4k1l0ace2y0station9umbing5s3m1n0c2ohl2ker3litie5rn2st3r0america6xi3ess3ime3o0d0uctions8f1gressive8mo2perties3y5tection8u0dential9s1t1ub2w0c2y2qa1pon3uebec3st5racing4dio4e0ad1lestate6tor2y4cipes5d0stone5umbrella9hab3ise0n3t2liance6n0t0als5pair3ort3ublican8st0aurant8view0s5xroth6ich0ardli6oh3l1o1p2o0cks3deo3gers4om3s0vp3u0gby3hr2n2w0e2yukyu6sa0arland6fe0ty4kura4le1on3msclub4ung5ndvik0coromant12ofi4p1rl2s1ve2xo3b0i1s2c0a1b1haeffler7midt4olarships8ol3ule3warz5ience5ot3d1e0arch3t2cure1ity6ek2lect4ner3rvices6ven3w1x0y3fr2g1h0angrila6rp2w2ell3ia1ksha5oes2p0ping5uji3w3i0lk2na1gles5te3j1k0i0n2y0pe4l0ing4m0art3ile4n0cf3o0ccer3ial4ftbank4ware6hu2lar2utions7ng1y2y2pa0ce3ort2t3r0l2s1t0ada2ples4r1tebank4farm7c0group6ockholm6rage3e3ream4udio2y3yle4u0cks3pplies3y2ort5rf1gery5zuki5v1watch4iss4x1y0dney4stems6z2tab1ipei4lk2obao4rget4tamotors6r2too4x0i3c0i2d0k2eam2ch0nology8l1masek5nnis4va3f1g1h0d1eater2re6iaa2ckets5enda4ps2res2ol4j0maxx4x2k0maxx5l1m0all4n1o0day3kyo3ols3p1ray3shiba5tal3urs3wn2yota3s3r0ade1ing4ining5vel0ers0insurance16ust3v2t1ube2i1nes3shu4v0s2w1z2ua1bank3s2g1k1nicom3versity8o2ol2ps2s1y1z2va0cations7na1guard7c1e0gas3ntures6risign5mögensberater2ung14sicherung10t2g1i0ajes4deo3g1king4llas4n1p1rgin4sa1ion4va1o3laanderen9n1odka3lvo3te1ing3o2yage5u2wales2mart4ter4ng0gou5tch0es6eather0channel12bcam3er2site5d0ding5ibo2r3f1hoswho6ien2ki2lliamhill9n0dows4e1ners6me2olterskluwer11odside6rk0s2ld3w2s1tc1f3xbox3erox4finity6ihuan4n2xx2yz3yachts4hoo3maxun5ndex5e1odobashi7ga2kohama6u0tube6t1un3za0ppos4ra3ero3ip2m1one3uerich6w2';\n// Internationalized domain names containing non-ASCII\nconst encodedUtlds = 'ελ1υ2бг1ел3дети4ею2католик6ом3мкд2он1сква6онлайн5рг3рус2ф2сайт3рб3укр3қаз3հայ3ישראל5קום3ابوظبي5رامكو5لاردن4بحرين5جزائر5سعودية6عليان5مغرب5مارات5یران5بارت2زار4يتك3ھارت5تونس4سودان3رية5شبكة4عراق2ب2مان4فلسطين6قطر3كاثوليك6وم3مصر2ليسيا5وريتانيا7قع4همراه5پاکستان7ڀارت4कॉम3नेट3भारत0म्3ोत5संगठन5বাংলা5ভারত2ৰত4ਭਾਰਤ4ભારત4ଭାରତ4இந்தியா6லங்கை6சிங்கப்பூர்11భారత్5ಭಾರತ4ഭാരതം5ලංකා4คอม3ไทย3ລາວ3გე2みんな3アマゾン4クラウド4グーグル4コム2ストア3セール3ファッション6ポイント4世界2中信1国1國1文网3亚马逊3企业2佛山2信息2健康2八卦2公司1益2台湾1灣2商城1店1标2嘉里0大酒店5在线2大拿2天主教3娱乐2家電2广东2微博2慈善2我爱你3手机2招聘2政务1府2新加坡2闻2时尚2書籍2机构2淡马锡3游戏2澳門2点看2移动2组织机构4网址1店1站1络2联通2谷歌2购物2通販2集团2電訊盈科4飞利浦3食品2餐厅2香格里拉3港2닷넷1컴2삼성2한국2';\n\n/**\n * @template A\n * @template B\n * @param {A} target\n * @param {B} properties\n * @return {A & B}\n */\nconst assign = (target, properties) => {\n  for (const key in properties) {\n    target[key] = properties[key];\n  }\n  return target;\n};\n\n/**\n * Finite State Machine generation utilities\n */\n\n/**\n * @template T\n * @typedef {{ [group: string]: T[] }} Collections\n */\n\n/**\n * @typedef {{ [group: string]: true }} Flags\n */\n\n// Keys in scanner Collections instances\nconst numeric = 'numeric';\nconst ascii = 'ascii';\nconst alpha = 'alpha';\nconst asciinumeric = 'asciinumeric';\nconst alphanumeric = 'alphanumeric';\nconst domain = 'domain';\nconst emoji = 'emoji';\nconst scheme = 'scheme';\nconst slashscheme = 'slashscheme';\nconst whitespace = 'whitespace';\n\n/**\n * @template T\n * @param {string} name\n * @param {Collections<T>} groups to register in\n * @returns {T[]} Current list of tokens in the given collection\n */\nfunction registerGroup(name, groups) {\n  if (!(name in groups)) {\n    groups[name] = [];\n  }\n  return groups[name];\n}\n\n/**\n * @template T\n * @param {T} t token to add\n * @param {Collections<T>} groups\n * @param {Flags} flags\n */\nfunction addToGroups(t, flags, groups) {\n  if (flags[numeric]) {\n    flags[asciinumeric] = true;\n    flags[alphanumeric] = true;\n  }\n  if (flags[ascii]) {\n    flags[asciinumeric] = true;\n    flags[alpha] = true;\n  }\n  if (flags[asciinumeric]) {\n    flags[alphanumeric] = true;\n  }\n  if (flags[alpha]) {\n    flags[alphanumeric] = true;\n  }\n  if (flags[alphanumeric]) {\n    flags[domain] = true;\n  }\n  if (flags[emoji]) {\n    flags[domain] = true;\n  }\n  for (const k in flags) {\n    const group = registerGroup(k, groups);\n    if (group.indexOf(t) < 0) {\n      group.push(t);\n    }\n  }\n}\n\n/**\n * @template T\n * @param {T} t token to check\n * @param {Collections<T>} groups\n * @returns {Flags} group flags that contain this token\n */\nfunction flagsForToken(t, groups) {\n  const result = {};\n  for (const c in groups) {\n    if (groups[c].indexOf(t) >= 0) {\n      result[c] = true;\n    }\n  }\n  return result;\n}\n\n/**\n * @template T\n * @typedef {null | T } Transition\n */\n\n/**\n * Define a basic state machine state. j is the list of character transitions,\n * jr is the list of regex-match transitions, jd is the default state to\n * transition to t is the accepting token type, if any. If this is the terminal\n * state, then it does not emit a token.\n *\n * The template type T represents the type of the token this state accepts. This\n * should be a string (such as of the token exports in `text.js`) or a\n * MultiToken subclass (from `multi.js`)\n *\n * @template T\n * @param {T} [token] Token that this state emits\n */\nfunction State(token) {\n  if (token === void 0) {\n    token = null;\n  }\n  // this.n = null; // DEBUG: State name\n  /** @type {{ [input: string]: State<T> }} j */\n  this.j = {}; // IMPLEMENTATION 1\n  // this.j = []; // IMPLEMENTATION 2\n  /** @type {[RegExp, State<T>][]} jr */\n  this.jr = [];\n  /** @type {?State<T>} jd */\n  this.jd = null;\n  /** @type {?T} t */\n  this.t = token;\n}\n\n/**\n * Scanner token groups\n * @type Collections<string>\n */\nState.groups = {};\nState.prototype = {\n  accepts() {\n    return !!this.t;\n  },\n  /**\n   * Follow an existing transition from the given input to the next state.\n   * Does not mutate.\n   * @param {string} input character or token type to transition on\n   * @returns {?State<T>} the next state, if any\n   */\n  go(input) {\n    const state = this;\n    const nextState = state.j[input];\n    if (nextState) {\n      return nextState;\n    }\n    for (let i = 0; i < state.jr.length; i++) {\n      const regex = state.jr[i][0];\n      const nextState = state.jr[i][1]; // note: might be empty to prevent default jump\n      if (nextState && regex.test(input)) {\n        return nextState;\n      }\n    }\n    // Nowhere left to jump! Return default, if any\n    return state.jd;\n  },\n  /**\n   * Whether the state has a transition for the given input. Set the second\n   * argument to true to only look for an exact match (and not a default or\n   * regular-expression-based transition)\n   * @param {string} input\n   * @param {boolean} exactOnly\n   */\n  has(input, exactOnly) {\n    if (exactOnly === void 0) {\n      exactOnly = false;\n    }\n    return exactOnly ? input in this.j : !!this.go(input);\n  },\n  /**\n   * Short for \"transition all\"; create a transition from the array of items\n   * in the given list to the same final resulting state.\n   * @param {string | string[]} inputs Group of inputs to transition on\n   * @param {Transition<T> | State<T>} [next] Transition options\n   * @param {Flags} [flags] Collections flags to add token to\n   * @param {Collections<T>} [groups] Master list of token groups\n   */\n  ta(inputs, next, flags, groups) {\n    for (let i = 0; i < inputs.length; i++) {\n      this.tt(inputs[i], next, flags, groups);\n    }\n  },\n  /**\n   * Short for \"take regexp transition\"; defines a transition for this state\n   * when it encounters a token which matches the given regular expression\n   * @param {RegExp} regexp Regular expression transition (populate first)\n   * @param {T | State<T>} [next] Transition options\n   * @param {Flags} [flags] Collections flags to add token to\n   * @param {Collections<T>} [groups] Master list of token groups\n   * @returns {State<T>} taken after the given input\n   */\n  tr(regexp, next, flags, groups) {\n    groups = groups || State.groups;\n    let nextState;\n    if (next && next.j) {\n      nextState = next;\n    } else {\n      // Token with maybe token groups\n      nextState = new State(next);\n      if (flags && groups) {\n        addToGroups(next, flags, groups);\n      }\n    }\n    this.jr.push([regexp, nextState]);\n    return nextState;\n  },\n  /**\n   * Short for \"take transitions\", will take as many sequential transitions as\n   * the length of the given input and returns the\n   * resulting final state.\n   * @param {string | string[]} input\n   * @param {T | State<T>} [next] Transition options\n   * @param {Flags} [flags] Collections flags to add token to\n   * @param {Collections<T>} [groups] Master list of token groups\n   * @returns {State<T>} taken after the given input\n   */\n  ts(input, next, flags, groups) {\n    let state = this;\n    const len = input.length;\n    if (!len) {\n      return state;\n    }\n    for (let i = 0; i < len - 1; i++) {\n      state = state.tt(input[i]);\n    }\n    return state.tt(input[len - 1], next, flags, groups);\n  },\n  /**\n   * Short for \"take transition\", this is a method for building/working with\n   * state machines.\n   *\n   * If a state already exists for the given input, returns it.\n   *\n   * If a token is specified, that state will emit that token when reached by\n   * the linkify engine.\n   *\n   * If no state exists, it will be initialized with some default transitions\n   * that resemble existing default transitions.\n   *\n   * If a state is given for the second argument, that state will be\n   * transitioned to on the given input regardless of what that input\n   * previously did.\n   *\n   * Specify a token group flags to define groups that this token belongs to.\n   * The token will be added to corresponding entires in the given groups\n   * object.\n   *\n   * @param {string} input character, token type to transition on\n   * @param {T | State<T>} [next] Transition options\n   * @param {Flags} [flags] Collections flags to add token to\n   * @param {Collections<T>} [groups] Master list of groups\n   * @returns {State<T>} taken after the given input\n   */\n  tt(input, next, flags, groups) {\n    groups = groups || State.groups;\n    const state = this;\n\n    // Check if existing state given, just a basic transition\n    if (next && next.j) {\n      state.j[input] = next;\n      return next;\n    }\n    const t = next;\n\n    // Take the transition with the usual default mechanisms and use that as\n    // a template for creating the next state\n    let nextState,\n      templateState = state.go(input);\n    if (templateState) {\n      nextState = new State();\n      assign(nextState.j, templateState.j);\n      nextState.jr.push.apply(nextState.jr, templateState.jr);\n      nextState.jd = templateState.jd;\n      nextState.t = templateState.t;\n    } else {\n      nextState = new State();\n    }\n    if (t) {\n      // Ensure newly token is in the same groups as the old token\n      if (groups) {\n        if (nextState.t && typeof nextState.t === 'string') {\n          const allFlags = assign(flagsForToken(nextState.t, groups), flags);\n          addToGroups(t, allFlags, groups);\n        } else if (flags) {\n          addToGroups(t, flags, groups);\n        }\n      }\n      nextState.t = t; // overwrite anything that was previously there\n    }\n\n    state.j[input] = nextState;\n    return nextState;\n  }\n};\n\n// Helper functions to improve minification (not exported outside linkifyjs module)\n\n/**\n * @template T\n * @param {State<T>} state\n * @param {string | string[]} input\n * @param {Flags} [flags]\n * @param {Collections<T>} [groups]\n */\nconst ta = (state, input, next, flags, groups) => state.ta(input, next, flags, groups);\n\n/**\n * @template T\n * @param {State<T>} state\n * @param {RegExp} regexp\n * @param {T | State<T>} [next]\n * @param {Flags} [flags]\n * @param {Collections<T>} [groups]\n */\nconst tr = (state, regexp, next, flags, groups) => state.tr(regexp, next, flags, groups);\n\n/**\n * @template T\n * @param {State<T>} state\n * @param {string | string[]} input\n * @param {T | State<T>} [next]\n * @param {Flags} [flags]\n * @param {Collections<T>} [groups]\n */\nconst ts = (state, input, next, flags, groups) => state.ts(input, next, flags, groups);\n\n/**\n * @template T\n * @param {State<T>} state\n * @param {string} input\n * @param {T | State<T>} [next]\n * @param {Collections<T>} [groups]\n * @param {Flags} [flags]\n */\nconst tt = (state, input, next, flags, groups) => state.tt(input, next, flags, groups);\n\n/******************************************************************************\nText Tokens\nIdentifiers for token outputs from the regexp scanner\n******************************************************************************/\n\n// A valid web domain token\nconst WORD = 'WORD'; // only contains a-z\nconst UWORD = 'UWORD'; // contains letters other than a-z, used for IDN\n\n// Special case of word\nconst LOCALHOST = 'LOCALHOST';\n\n// Valid top-level domain, special case of WORD (see tlds.js)\nconst TLD = 'TLD';\n\n// Valid IDN TLD, special case of UWORD (see tlds.js)\nconst UTLD = 'UTLD';\n\n// The scheme portion of a web URI protocol. Supported types include: `mailto`,\n// `file`, and user-defined custom protocols. Limited to schemes that contain\n// only letters\nconst SCHEME = 'SCHEME';\n\n// Similar to SCHEME, except makes distinction for schemes that must always be\n// followed by `://`, not just `:`. Supported types include `http`, `https`,\n// `ftp`, `ftps`\nconst SLASH_SCHEME = 'SLASH_SCHEME';\n\n// Any sequence of digits 0-9\nconst NUM = 'NUM';\n\n// Any number of consecutive whitespace characters that are not newline\nconst WS = 'WS';\n\n// New line (unix style)\nconst NL$1 = 'NL'; // \\n\n\n// Opening/closing bracket classes\n// TODO: Rename OPEN -> LEFT and CLOSE -> RIGHT in v5 to fit with Unicode names\n// Also rename angle brackes to LESSTHAN and GREATER THAN\nconst OPENBRACE = 'OPENBRACE'; // {\nconst CLOSEBRACE = 'CLOSEBRACE'; // }\nconst OPENBRACKET = 'OPENBRACKET'; // [\nconst CLOSEBRACKET = 'CLOSEBRACKET'; // ]\nconst OPENPAREN = 'OPENPAREN'; // (\nconst CLOSEPAREN = 'CLOSEPAREN'; // )\nconst OPENANGLEBRACKET = 'OPENANGLEBRACKET'; // <\nconst CLOSEANGLEBRACKET = 'CLOSEANGLEBRACKET'; // >\nconst FULLWIDTHLEFTPAREN = 'FULLWIDTHLEFTPAREN'; // （\nconst FULLWIDTHRIGHTPAREN = 'FULLWIDTHRIGHTPAREN'; // ）\nconst LEFTCORNERBRACKET = 'LEFTCORNERBRACKET'; // 「\nconst RIGHTCORNERBRACKET = 'RIGHTCORNERBRACKET'; // 」\nconst LEFTWHITECORNERBRACKET = 'LEFTWHITECORNERBRACKET'; // 『\nconst RIGHTWHITECORNERBRACKET = 'RIGHTWHITECORNERBRACKET'; // 』\nconst FULLWIDTHLESSTHAN = 'FULLWIDTHLESSTHAN'; // ＜\nconst FULLWIDTHGREATERTHAN = 'FULLWIDTHGREATERTHAN'; // ＞\n\n// Various symbols\nconst AMPERSAND = 'AMPERSAND'; // &\nconst APOSTROPHE = 'APOSTROPHE'; // '\nconst ASTERISK = 'ASTERISK'; // *\nconst AT = 'AT'; // @\nconst BACKSLASH = 'BACKSLASH'; // \\\nconst BACKTICK = 'BACKTICK'; // `\nconst CARET = 'CARET'; // ^\nconst COLON = 'COLON'; // :\nconst COMMA = 'COMMA'; // ,\nconst DOLLAR = 'DOLLAR'; // $\nconst DOT = 'DOT'; // .\nconst EQUALS = 'EQUALS'; // =\nconst EXCLAMATION = 'EXCLAMATION'; // !\nconst HYPHEN = 'HYPHEN'; // -\nconst PERCENT = 'PERCENT'; // %\nconst PIPE = 'PIPE'; // |\nconst PLUS = 'PLUS'; // +\nconst POUND = 'POUND'; // #\nconst QUERY = 'QUERY'; // ?\nconst QUOTE = 'QUOTE'; // \"\n\nconst SEMI = 'SEMI'; // ;\nconst SLASH = 'SLASH'; // /\nconst TILDE = 'TILDE'; // ~\nconst UNDERSCORE = 'UNDERSCORE'; // _\n\n// Emoji symbol\nconst EMOJI$1 = 'EMOJI';\n\n// Default token - anything that is not one of the above\nconst SYM = 'SYM';\n\nvar tk = /*#__PURE__*/Object.freeze({\n\t__proto__: null,\n\tWORD: WORD,\n\tUWORD: UWORD,\n\tLOCALHOST: LOCALHOST,\n\tTLD: TLD,\n\tUTLD: UTLD,\n\tSCHEME: SCHEME,\n\tSLASH_SCHEME: SLASH_SCHEME,\n\tNUM: NUM,\n\tWS: WS,\n\tNL: NL$1,\n\tOPENBRACE: OPENBRACE,\n\tCLOSEBRACE: CLOSEBRACE,\n\tOPENBRACKET: OPENBRACKET,\n\tCLOSEBRACKET: CLOSEBRACKET,\n\tOPENPAREN: OPENPAREN,\n\tCLOSEPAREN: CLOSEPAREN,\n\tOPENANGLEBRACKET: OPENANGLEBRACKET,\n\tCLOSEANGLEBRACKET: CLOSEANGLEBRACKET,\n\tFULLWIDTHLEFTPAREN: FULLWIDTHLEFTPAREN,\n\tFULLWIDTHRIGHTPAREN: FULLWIDTHRIGHTPAREN,\n\tLEFTCORNERBRACKET: LEFTCORNERBRACKET,\n\tRIGHTCORNERBRACKET: RIGHTCORNERBRACKET,\n\tLEFTWHITECORNERBRACKET: LEFTWHITECORNERBRACKET,\n\tRIGHTWHITECORNERBRACKET: RIGHTWHITECORNERBRACKET,\n\tFULLWIDTHLESSTHAN: FULLWIDTHLESSTHAN,\n\tFULLWIDTHGREATERTHAN: FULLWIDTHGREATERTHAN,\n\tAMPERSAND: AMPERSAND,\n\tAPOSTROPHE: APOSTROPHE,\n\tASTERISK: ASTERISK,\n\tAT: AT,\n\tBACKSLASH: BACKSLASH,\n\tBACKTICK: BACKTICK,\n\tCARET: CARET,\n\tCOLON: COLON,\n\tCOMMA: COMMA,\n\tDOLLAR: DOLLAR,\n\tDOT: DOT,\n\tEQUALS: EQUALS,\n\tEXCLAMATION: EXCLAMATION,\n\tHYPHEN: HYPHEN,\n\tPERCENT: PERCENT,\n\tPIPE: PIPE,\n\tPLUS: PLUS,\n\tPOUND: POUND,\n\tQUERY: QUERY,\n\tQUOTE: QUOTE,\n\tSEMI: SEMI,\n\tSLASH: SLASH,\n\tTILDE: TILDE,\n\tUNDERSCORE: UNDERSCORE,\n\tEMOJI: EMOJI$1,\n\tSYM: SYM\n});\n\n// Note that these two Unicode ones expand into a really big one with Babel\nconst ASCII_LETTER = /[a-z]/;\nconst LETTER = /\\p{L}/u; // Any Unicode character with letter data type\nconst EMOJI = /\\p{Emoji}/u; // Any Unicode emoji character\nconst EMOJI_VARIATION$1 = /\\ufe0f/;\nconst DIGIT = /\\d/;\nconst SPACE = /\\s/;\n\nvar regexp = /*#__PURE__*/Object.freeze({\n\t__proto__: null,\n\tASCII_LETTER: ASCII_LETTER,\n\tLETTER: LETTER,\n\tEMOJI: EMOJI,\n\tEMOJI_VARIATION: EMOJI_VARIATION$1,\n\tDIGIT: DIGIT,\n\tSPACE: SPACE\n});\n\n/**\n\tThe scanner provides an interface that takes a string of text as input, and\n\toutputs an array of tokens instances that can be used for easy URL parsing.\n*/\nconst NL = '\\n'; // New line character\nconst EMOJI_VARIATION = '\\ufe0f'; // Variation selector, follows heart and others\nconst EMOJI_JOINER = '\\u200d'; // zero-width joiner\n\nlet tlds = null,\n  utlds = null; // don't change so only have to be computed once\n\n/**\n * Scanner output token:\n * - `t` is the token name (e.g., 'NUM', 'EMOJI', 'TLD')\n * - `v` is the value of the token (e.g., '123', '❤️', 'com')\n * - `s` is the start index of the token in the original string\n * - `e` is the end index of the token in the original string\n * @typedef {{t: string, v: string, s: number, e: number}} Token\n */\n\n/**\n * @template T\n * @typedef {{ [collection: string]: T[] }} Collections\n */\n\n/**\n * Initialize the scanner character-based state machine for the given start\n * state\n * @param {[string, boolean][]} customSchemes List of custom schemes, where each\n * item is a length-2 tuple with the first element set to the string scheme, and\n * the second element set to `true` if the `://` after the scheme is optional\n */\nfunction init$2(customSchemes) {\n  if (customSchemes === void 0) {\n    customSchemes = [];\n  }\n  // Frequently used states (name argument removed during minification)\n  /** @type Collections<string> */\n  const groups = {}; // of tokens\n  State.groups = groups;\n  /** @type State<string> */\n  const Start = new State();\n  if (tlds == null) {\n    tlds = decodeTlds(encodedTlds);\n  }\n  if (utlds == null) {\n    utlds = decodeTlds(encodedUtlds);\n  }\n\n  // States for special URL symbols that accept immediately after start\n  tt(Start, \"'\", APOSTROPHE);\n  tt(Start, '{', OPENBRACE);\n  tt(Start, '}', CLOSEBRACE);\n  tt(Start, '[', OPENBRACKET);\n  tt(Start, ']', CLOSEBRACKET);\n  tt(Start, '(', OPENPAREN);\n  tt(Start, ')', CLOSEPAREN);\n  tt(Start, '<', OPENANGLEBRACKET);\n  tt(Start, '>', CLOSEANGLEBRACKET);\n  tt(Start, '（', FULLWIDTHLEFTPAREN);\n  tt(Start, '）', FULLWIDTHRIGHTPAREN);\n  tt(Start, '「', LEFTCORNERBRACKET);\n  tt(Start, '」', RIGHTCORNERBRACKET);\n  tt(Start, '『', LEFTWHITECORNERBRACKET);\n  tt(Start, '』', RIGHTWHITECORNERBRACKET);\n  tt(Start, '＜', FULLWIDTHLESSTHAN);\n  tt(Start, '＞', FULLWIDTHGREATERTHAN);\n  tt(Start, '&', AMPERSAND);\n  tt(Start, '*', ASTERISK);\n  tt(Start, '@', AT);\n  tt(Start, '`', BACKTICK);\n  tt(Start, '^', CARET);\n  tt(Start, ':', COLON);\n  tt(Start, ',', COMMA);\n  tt(Start, '$', DOLLAR);\n  tt(Start, '.', DOT);\n  tt(Start, '=', EQUALS);\n  tt(Start, '!', EXCLAMATION);\n  tt(Start, '-', HYPHEN);\n  tt(Start, '%', PERCENT);\n  tt(Start, '|', PIPE);\n  tt(Start, '+', PLUS);\n  tt(Start, '#', POUND);\n  tt(Start, '?', QUERY);\n  tt(Start, '\"', QUOTE);\n  tt(Start, '/', SLASH);\n  tt(Start, ';', SEMI);\n  tt(Start, '~', TILDE);\n  tt(Start, '_', UNDERSCORE);\n  tt(Start, '\\\\', BACKSLASH);\n  const Num = tr(Start, DIGIT, NUM, {\n    [numeric]: true\n  });\n  tr(Num, DIGIT, Num);\n\n  // State which emits a word token\n  const Word = tr(Start, ASCII_LETTER, WORD, {\n    [ascii]: true\n  });\n  tr(Word, ASCII_LETTER, Word);\n\n  // Same as previous, but specific to non-fsm.ascii alphabet words\n  const UWord = tr(Start, LETTER, UWORD, {\n    [alpha]: true\n  });\n  tr(UWord, ASCII_LETTER); // Non-accepting\n  tr(UWord, LETTER, UWord);\n\n  // Whitespace jumps\n  // Tokens of only non-newline whitespace are arbitrarily long\n  // If any whitespace except newline, more whitespace!\n  const Ws = tr(Start, SPACE, WS, {\n    [whitespace]: true\n  });\n  tt(Start, NL, NL$1, {\n    [whitespace]: true\n  });\n  tt(Ws, NL); // non-accepting state to avoid mixing whitespaces\n  tr(Ws, SPACE, Ws);\n\n  // Emoji tokens. They are not grouped by the scanner except in cases where a\n  // zero-width joiner is present\n  const Emoji = tr(Start, EMOJI, EMOJI$1, {\n    [emoji]: true\n  });\n  tr(Emoji, EMOJI, Emoji);\n  tt(Emoji, EMOJI_VARIATION, Emoji);\n  // tt(Start, EMOJI_VARIATION, Emoji); // This one is sketchy\n\n  const EmojiJoiner = tt(Emoji, EMOJI_JOINER);\n  tr(EmojiJoiner, EMOJI, Emoji);\n  // tt(EmojiJoiner, EMOJI_VARIATION, Emoji); // also sketchy\n\n  // Generates states for top-level domains\n  // Note that this is most accurate when tlds are in alphabetical order\n  const wordjr = [[ASCII_LETTER, Word]];\n  const uwordjr = [[ASCII_LETTER, null], [LETTER, UWord]];\n  for (let i = 0; i < tlds.length; i++) {\n    fastts(Start, tlds[i], TLD, WORD, wordjr);\n  }\n  for (let i = 0; i < utlds.length; i++) {\n    fastts(Start, utlds[i], UTLD, UWORD, uwordjr);\n  }\n  addToGroups(TLD, {\n    tld: true,\n    ascii: true\n  }, groups);\n  addToGroups(UTLD, {\n    utld: true,\n    alpha: true\n  }, groups);\n\n  // Collect the states generated by different protocols. NOTE: If any new TLDs\n  // get added that are also protocols, set the token to be the same as the\n  // protocol to ensure parsing works as expected.\n  fastts(Start, 'file', SCHEME, WORD, wordjr);\n  fastts(Start, 'mailto', SCHEME, WORD, wordjr);\n  fastts(Start, 'http', SLASH_SCHEME, WORD, wordjr);\n  fastts(Start, 'https', SLASH_SCHEME, WORD, wordjr);\n  fastts(Start, 'ftp', SLASH_SCHEME, WORD, wordjr);\n  fastts(Start, 'ftps', SLASH_SCHEME, WORD, wordjr);\n  addToGroups(SCHEME, {\n    scheme: true,\n    ascii: true\n  }, groups);\n  addToGroups(SLASH_SCHEME, {\n    slashscheme: true,\n    ascii: true\n  }, groups);\n\n  // Register custom schemes. Assumes each scheme is asciinumeric with hyphens\n  customSchemes = customSchemes.sort((a, b) => a[0] > b[0] ? 1 : -1);\n  for (let i = 0; i < customSchemes.length; i++) {\n    const sch = customSchemes[i][0];\n    const optionalSlashSlash = customSchemes[i][1];\n    const flags = optionalSlashSlash ? {\n      [scheme]: true\n    } : {\n      [slashscheme]: true\n    };\n    if (sch.indexOf('-') >= 0) {\n      flags[domain] = true;\n    } else if (!ASCII_LETTER.test(sch)) {\n      flags[numeric] = true; // numbers only\n    } else if (DIGIT.test(sch)) {\n      flags[asciinumeric] = true;\n    } else {\n      flags[ascii] = true;\n    }\n    ts(Start, sch, sch, flags);\n  }\n\n  // Localhost token\n  ts(Start, 'localhost', LOCALHOST, {\n    ascii: true\n  });\n\n  // Set default transition for start state (some symbol)\n  Start.jd = new State(SYM);\n  return {\n    start: Start,\n    tokens: assign({\n      groups\n    }, tk)\n  };\n}\n\n/**\n\tGiven a string, returns an array of TOKEN instances representing the\n\tcomposition of that string.\n\n\t@method run\n\t@param {State<string>} start scanner starting state\n\t@param {string} str input string to scan\n\t@return {Token[]} list of tokens, each with a type and value\n*/\nfunction run$1(start, str) {\n  // State machine is not case sensitive, so input is tokenized in lowercased\n  // form (still returns regular case). Uses selective `toLowerCase` because\n  // lowercasing the entire string causes the length and character position to\n  // vary in some non-English strings with V8-based runtimes.\n  const iterable = stringToArray(str.replace(/[A-Z]/g, c => c.toLowerCase()));\n  const charCount = iterable.length; // <= len if there are emojis, etc\n  const tokens = []; // return value\n\n  // cursor through the string itself, accounting for characters that have\n  // width with length 2 such as emojis\n  let cursor = 0;\n\n  // Cursor through the array-representation of the string\n  let charCursor = 0;\n\n  // Tokenize the string\n  while (charCursor < charCount) {\n    let state = start;\n    let nextState = null;\n    let tokenLength = 0;\n    let latestAccepting = null;\n    let sinceAccepts = -1;\n    let charsSinceAccepts = -1;\n    while (charCursor < charCount && (nextState = state.go(iterable[charCursor]))) {\n      state = nextState;\n\n      // Keep track of the latest accepting state\n      if (state.accepts()) {\n        sinceAccepts = 0;\n        charsSinceAccepts = 0;\n        latestAccepting = state;\n      } else if (sinceAccepts >= 0) {\n        sinceAccepts += iterable[charCursor].length;\n        charsSinceAccepts++;\n      }\n      tokenLength += iterable[charCursor].length;\n      cursor += iterable[charCursor].length;\n      charCursor++;\n    }\n\n    // Roll back to the latest accepting state\n    cursor -= sinceAccepts;\n    charCursor -= charsSinceAccepts;\n    tokenLength -= sinceAccepts;\n\n    // No more jumps, just make a new token from the last accepting one\n    tokens.push({\n      t: latestAccepting.t,\n      // token type/name\n      v: str.slice(cursor - tokenLength, cursor),\n      // string value\n      s: cursor - tokenLength,\n      // start index\n      e: cursor // end index (excluding)\n    });\n  }\n\n  return tokens;\n}\n\n/**\n * Convert a String to an Array of characters, taking into account that some\n * characters like emojis take up two string indexes.\n *\n * Adapted from core-js (MIT license)\n * https://github.com/zloirock/core-js/blob/2d69cf5f99ab3ea3463c395df81e5a15b68f49d9/packages/core-js/internals/string-multibyte.js\n *\n * @function stringToArray\n * @param {string} str\n * @returns {string[]}\n */\nfunction stringToArray(str) {\n  const result = [];\n  const len = str.length;\n  let index = 0;\n  while (index < len) {\n    let first = str.charCodeAt(index);\n    let second;\n    let char = first < 0xd800 || first > 0xdbff || index + 1 === len || (second = str.charCodeAt(index + 1)) < 0xdc00 || second > 0xdfff ? str[index] // single character\n    : str.slice(index, index + 2); // two-index characters\n    result.push(char);\n    index += char.length;\n  }\n  return result;\n}\n\n/**\n * Fast version of ts function for when transition defaults are well known\n * @param {State<string>} state\n * @param {string} input\n * @param {string} t\n * @param {string} defaultt\n * @param {[RegExp, State<string>][]} jr\n * @returns {State<string>}\n */\nfunction fastts(state, input, t, defaultt, jr) {\n  let next;\n  const len = input.length;\n  for (let i = 0; i < len - 1; i++) {\n    const char = input[i];\n    if (state.j[char]) {\n      next = state.j[char];\n    } else {\n      next = new State(defaultt);\n      next.jr = jr.slice();\n      state.j[char] = next;\n    }\n    state = next;\n  }\n  next = new State(t);\n  next.jr = jr.slice();\n  state.j[input[len - 1]] = next;\n  return next;\n}\n\n/**\n * Converts a string of Top-Level Domain names encoded in update-tlds.js back\n * into a list of strings.\n * @param {str} encoded encoded TLDs string\n * @returns {str[]} original TLDs list\n */\nfunction decodeTlds(encoded) {\n  const words = [];\n  const stack = [];\n  let i = 0;\n  let digits = '0123456789';\n  while (i < encoded.length) {\n    let popDigitCount = 0;\n    while (digits.indexOf(encoded[i + popDigitCount]) >= 0) {\n      popDigitCount++; // encountered some digits, have to pop to go one level up trie\n    }\n\n    if (popDigitCount > 0) {\n      words.push(stack.join('')); // whatever preceded the pop digits must be a word\n      for (let popCount = parseInt(encoded.substring(i, i + popDigitCount), 10); popCount > 0; popCount--) {\n        stack.pop();\n      }\n      i += popDigitCount;\n    } else {\n      stack.push(encoded[i]); // drop down a level into the trie\n      i++;\n    }\n  }\n  return words;\n}\n\n/**\n * An object where each key is a valid DOM Event Name such as `click` or `focus`\n * and each value is an event handler function.\n *\n * https://developer.mozilla.org/en-US/docs/Web/API/Element#events\n * @typedef {?{ [event: string]: Function }} EventListeners\n */\n\n/**\n * All formatted properties required to render a link, including `tagName`,\n * `attributes`, `content` and `eventListeners`.\n * @typedef {{ tagName: any, attributes: {[attr: string]: any}, content: string,\n * eventListeners: EventListeners }} IntermediateRepresentation\n */\n\n/**\n * Specify either an object described by the template type `O` or a function.\n *\n * The function takes a string value (usually the link's href attribute), the\n * link type (`'url'`, `'hashtag`', etc.) and an internal token representation\n * of the link. It should return an object of the template type `O`\n * @template O\n * @typedef {O | ((value: string, type: string, token: MultiToken) => O)} OptObj\n */\n\n/**\n * Specify either a function described by template type `F` or an object.\n *\n * Each key in the object should be a link type (`'url'`, `'hashtag`', etc.). Each\n * value should be a function with template type `F` that is called when the\n * corresponding link type is encountered.\n * @template F\n * @typedef {F | { [type: string]: F}} OptFn\n */\n\n/**\n * Specify either a value with template type `V`, a function that returns `V` or\n * an object where each value resolves to `V`.\n *\n * The function takes a string value (usually the link's href attribute), the\n * link type (`'url'`, `'hashtag`', etc.) and an internal token representation\n * of the link. It should return an object of the template type `V`\n *\n * For the object, each key should be a link type (`'url'`, `'hashtag`', etc.).\n * Each value should either have type `V` or a function that returns V. This\n * function similarly takes a string value and a token.\n *\n * Example valid types for `Opt<string>`:\n *\n * ```js\n * 'hello'\n * (value, type, token) => 'world'\n * { url: 'hello', email: (value, token) => 'world'}\n * ```\n * @template V\n * @typedef {V | ((value: string, type: string, token: MultiToken) => V) | { [type: string]: V | ((value: string, token: MultiToken) => V) }} Opt\n */\n\n/**\n * See available options: https://linkify.js.org/docs/options.html\n * @typedef {{\n * \tdefaultProtocol?: string,\n *  events?: OptObj<EventListeners>,\n * \tformat?: Opt<string>,\n * \tformatHref?: Opt<string>,\n * \tnl2br?: boolean,\n * \ttagName?: Opt<any>,\n * \ttarget?: Opt<string>,\n * \trel?: Opt<string>,\n * \tvalidate?: Opt<boolean>,\n * \ttruncate?: Opt<number>,\n * \tclassName?: Opt<string>,\n * \tattributes?: OptObj<({ [attr: string]: any })>,\n *  ignoreTags?: string[],\n * \trender?: OptFn<((ir: IntermediateRepresentation) => any)>\n * }} Opts\n */\n\n/**\n * @type Required<Opts>\n */\nconst defaults = {\n  defaultProtocol: 'http',\n  events: null,\n  format: noop,\n  formatHref: noop,\n  nl2br: false,\n  tagName: 'a',\n  target: null,\n  rel: null,\n  validate: true,\n  truncate: Infinity,\n  className: null,\n  attributes: null,\n  ignoreTags: [],\n  render: null\n};\n\n/**\n * Utility class for linkify interfaces to apply specified\n * {@link Opts formatting and rendering options}.\n *\n * @param {Opts | Options} [opts] Option value overrides.\n * @param {(ir: IntermediateRepresentation) => any} [defaultRender] (For\n *   internal use) default render function that determines how to generate an\n *   HTML element based on a link token's derived tagName, attributes and HTML.\n *   Similar to render option\n */\nfunction Options(opts, defaultRender) {\n  if (defaultRender === void 0) {\n    defaultRender = null;\n  }\n  let o = assign({}, defaults);\n  if (opts) {\n    o = assign(o, opts instanceof Options ? opts.o : opts);\n  }\n\n  // Ensure all ignored tags are uppercase\n  const ignoredTags = o.ignoreTags;\n  const uppercaseIgnoredTags = [];\n  for (let i = 0; i < ignoredTags.length; i++) {\n    uppercaseIgnoredTags.push(ignoredTags[i].toUpperCase());\n  }\n  /** @protected */\n  this.o = o;\n  if (defaultRender) {\n    this.defaultRender = defaultRender;\n  }\n  this.ignoreTags = uppercaseIgnoredTags;\n}\nOptions.prototype = {\n  o: defaults,\n  /**\n   * @type string[]\n   */\n  ignoreTags: [],\n  /**\n   * @param {IntermediateRepresentation} ir\n   * @returns {any}\n   */\n  defaultRender(ir) {\n    return ir;\n  },\n  /**\n   * Returns true or false based on whether a token should be displayed as a\n   * link based on the user options.\n   * @param {MultiToken} token\n   * @returns {boolean}\n   */\n  check(token) {\n    return this.get('validate', token.toString(), token);\n  },\n  // Private methods\n\n  /**\n   * Resolve an option's value based on the value of the option and the given\n   * params. If operator and token are specified and the target option is\n   * callable, automatically calls the function with the given argument.\n   * @template {keyof Opts} K\n   * @param {K} key Name of option to use\n   * @param {string} [operator] will be passed to the target option if it's a\n   * function. If not specified, RAW function value gets returned\n   * @param {MultiToken} [token] The token from linkify.tokenize\n   * @returns {Opts[K] | any}\n   */\n  get(key, operator, token) {\n    const isCallable = operator != null;\n    let option = this.o[key];\n    if (!option) {\n      return option;\n    }\n    if (typeof option === 'object') {\n      option = token.t in option ? option[token.t] : defaults[key];\n      if (typeof option === 'function' && isCallable) {\n        option = option(operator, token);\n      }\n    } else if (typeof option === 'function' && isCallable) {\n      option = option(operator, token.t, token);\n    }\n    return option;\n  },\n  /**\n   * @template {keyof Opts} L\n   * @param {L} key Name of options object to use\n   * @param {string} [operator]\n   * @param {MultiToken} [token]\n   * @returns {Opts[L] | any}\n   */\n  getObj(key, operator, token) {\n    let obj = this.o[key];\n    if (typeof obj === 'function' && operator != null) {\n      obj = obj(operator, token.t, token);\n    }\n    return obj;\n  },\n  /**\n   * Convert the given token to a rendered element that may be added to the\n   * calling-interface's DOM\n   * @param {MultiToken} token Token to render to an HTML element\n   * @returns {any} Render result; e.g., HTML string, DOM element, React\n   *   Component, etc.\n   */\n  render(token) {\n    const ir = token.render(this); // intermediate representation\n    const renderFn = this.get('render', null, token) || this.defaultRender;\n    return renderFn(ir, token.t, token);\n  }\n};\nfunction noop(val) {\n  return val;\n}\n\nvar options = /*#__PURE__*/Object.freeze({\n\t__proto__: null,\n\tdefaults: defaults,\n\tOptions: Options,\n\tassign: assign\n});\n\n/******************************************************************************\n\tMulti-Tokens\n\tTokens composed of arrays of TextTokens\n******************************************************************************/\n\n/**\n * @param {string} value\n * @param {Token[]} tokens\n */\nfunction MultiToken(value, tokens) {\n  this.t = 'token';\n  this.v = value;\n  this.tk = tokens;\n}\n\n/**\n * Abstract class used for manufacturing tokens of text tokens. That is rather\n * than the value for a token being a small string of text, it's value an array\n * of text tokens.\n *\n * Used for grouping together URLs, emails, hashtags, and other potential\n * creations.\n * @class MultiToken\n * @property {string} t\n * @property {string} v\n * @property {Token[]} tk\n * @abstract\n */\nMultiToken.prototype = {\n  isLink: false,\n  /**\n   * Return the string this token represents.\n   * @return {string}\n   */\n  toString() {\n    return this.v;\n  },\n  /**\n   * What should the value for this token be in the `href` HTML attribute?\n   * Returns the `.toString` value by default.\n   * @param {string} [scheme]\n   * @return {string}\n  */\n  toHref(scheme) {\n    return this.toString();\n  },\n  /**\n   * @param {Options} options Formatting options\n   * @returns {string}\n   */\n  toFormattedString(options) {\n    const val = this.toString();\n    const truncate = options.get('truncate', val, this);\n    const formatted = options.get('format', val, this);\n    return truncate && formatted.length > truncate ? formatted.substring(0, truncate) + '…' : formatted;\n  },\n  /**\n   *\n   * @param {Options} options\n   * @returns {string}\n   */\n  toFormattedHref(options) {\n    return options.get('formatHref', this.toHref(options.get('defaultProtocol')), this);\n  },\n  /**\n   * The start index of this token in the original input string\n   * @returns {number}\n   */\n  startIndex() {\n    return this.tk[0].s;\n  },\n  /**\n   * The end index of this token in the original input string (up to this\n   * index but not including it)\n   * @returns {number}\n   */\n  endIndex() {\n    return this.tk[this.tk.length - 1].e;\n  },\n  /**\n  \tReturns an object  of relevant values for this token, which includes keys\n  \t* type - Kind of token ('url', 'email', etc.)\n  \t* value - Original text\n  \t* href - The value that should be added to the anchor tag's href\n  \t\tattribute\n  \t\t@method toObject\n  \t@param {string} [protocol] `'http'` by default\n  */\n  toObject(protocol) {\n    if (protocol === void 0) {\n      protocol = defaults.defaultProtocol;\n    }\n    return {\n      type: this.t,\n      value: this.toString(),\n      isLink: this.isLink,\n      href: this.toHref(protocol),\n      start: this.startIndex(),\n      end: this.endIndex()\n    };\n  },\n  /**\n   *\n   * @param {Options} options Formatting option\n   */\n  toFormattedObject(options) {\n    return {\n      type: this.t,\n      value: this.toFormattedString(options),\n      isLink: this.isLink,\n      href: this.toFormattedHref(options),\n      start: this.startIndex(),\n      end: this.endIndex()\n    };\n  },\n  /**\n   * Whether this token should be rendered as a link according to the given options\n   * @param {Options} options\n   * @returns {boolean}\n   */\n  validate(options) {\n    return options.get('validate', this.toString(), this);\n  },\n  /**\n   * Return an object that represents how this link should be rendered.\n   * @param {Options} options Formattinng options\n   */\n  render(options) {\n    const token = this;\n    const href = this.toHref(options.get('defaultProtocol'));\n    const formattedHref = options.get('formatHref', href, this);\n    const tagName = options.get('tagName', href, token);\n    const content = this.toFormattedString(options);\n    const attributes = {};\n    const className = options.get('className', href, token);\n    const target = options.get('target', href, token);\n    const rel = options.get('rel', href, token);\n    const attrs = options.getObj('attributes', href, token);\n    const eventListeners = options.getObj('events', href, token);\n    attributes.href = formattedHref;\n    if (className) {\n      attributes.class = className;\n    }\n    if (target) {\n      attributes.target = target;\n    }\n    if (rel) {\n      attributes.rel = rel;\n    }\n    if (attrs) {\n      assign(attributes, attrs);\n    }\n    return {\n      tagName,\n      attributes,\n      content,\n      eventListeners\n    };\n  }\n};\n\n/**\n * Create a new token that can be emitted by the parser state machine\n * @param {string} type readable type of the token\n * @param {object} props properties to assign or override, including isLink = true or false\n * @returns {new (value: string, tokens: Token[]) => MultiToken} new token class\n */\nfunction createTokenClass(type, props) {\n  class Token extends MultiToken {\n    constructor(value, tokens) {\n      super(value, tokens);\n      this.t = type;\n    }\n  }\n  for (const p in props) {\n    Token.prototype[p] = props[p];\n  }\n  Token.t = type;\n  return Token;\n}\n\n/**\n\tRepresents a list of tokens making up a valid email address\n*/\nconst Email = createTokenClass('email', {\n  isLink: true,\n  toHref() {\n    return 'mailto:' + this.toString();\n  }\n});\n\n/**\n\tRepresents some plain text\n*/\nconst Text = createTokenClass('text');\n\n/**\n\tMulti-linebreak token - represents a line break\n\t@class Nl\n*/\nconst Nl = createTokenClass('nl');\n\n/**\n\tRepresents a list of text tokens making up a valid URL\n\t@class Url\n*/\nconst Url = createTokenClass('url', {\n  isLink: true,\n  /**\n  \tLowercases relevant parts of the domain and adds the protocol if\n  \trequired. Note that this will not escape unsafe HTML characters in the\n  \tURL.\n  \t\t@param {string} [scheme] default scheme (e.g., 'https')\n  \t@return {string} the full href\n  */\n  toHref(scheme) {\n    if (scheme === void 0) {\n      scheme = defaults.defaultProtocol;\n    }\n    // Check if already has a prefix scheme\n    return this.hasProtocol() ? this.v : `${scheme}://${this.v}`;\n  },\n  /**\n   * Check whether this URL token has a protocol\n   * @return {boolean}\n   */\n  hasProtocol() {\n    const tokens = this.tk;\n    return tokens.length >= 2 && tokens[0].t !== LOCALHOST && tokens[1].t === COLON;\n  }\n});\n\nvar multi = /*#__PURE__*/Object.freeze({\n\t__proto__: null,\n\tMultiToken: MultiToken,\n\tBase: MultiToken,\n\tcreateTokenClass: createTokenClass,\n\tEmail: Email,\n\tText: Text,\n\tNl: Nl,\n\tUrl: Url\n});\n\n/**\n\tNot exactly parser, more like the second-stage scanner (although we can\n\ttheoretically hotswap the code here with a real parser in the future... but\n\tfor a little URL-finding utility abstract syntax trees may be a little\n\toverkill).\n\n\tURL format: http://en.wikipedia.org/wiki/URI_scheme\n\tEmail format: http://en.wikipedia.org/wiki/EmailAddress (links to RFC in\n\treference)\n\n\t@module linkify\n\t@submodule parser\n\t@main run\n*/\nconst makeState = arg => new State(arg);\n\n/**\n * Generate the parser multi token-based state machine\n * @param {{ groups: Collections<string> }} tokens\n */\nfunction init$1(_ref) {\n  let {\n    groups\n  } = _ref;\n  // Types of characters the URL can definitely end in\n  const qsAccepting = groups.domain.concat([AMPERSAND, ASTERISK, AT, BACKSLASH, BACKTICK, CARET, DOLLAR, EQUALS, HYPHEN, NUM, PERCENT, PIPE, PLUS, POUND, SLASH, SYM, TILDE, UNDERSCORE]);\n\n  // Types of tokens that can follow a URL and be part of the query string\n  // but cannot be the very last characters\n  // Characters that cannot appear in the URL at all should be excluded\n  const qsNonAccepting = [APOSTROPHE, COLON, COMMA, DOT, EXCLAMATION, QUERY, QUOTE, SEMI, OPENANGLEBRACKET, CLOSEANGLEBRACKET, OPENBRACE, CLOSEBRACE, CLOSEBRACKET, OPENBRACKET, OPENPAREN, CLOSEPAREN, FULLWIDTHLEFTPAREN, FULLWIDTHRIGHTPAREN, LEFTCORNERBRACKET, RIGHTCORNERBRACKET, LEFTWHITECORNERBRACKET, RIGHTWHITECORNERBRACKET, FULLWIDTHLESSTHAN, FULLWIDTHGREATERTHAN];\n\n  // For addresses without the mailto prefix\n  // Tokens allowed in the localpart of the email\n  const localpartAccepting = [AMPERSAND, APOSTROPHE, ASTERISK, BACKSLASH, BACKTICK, CARET, DOLLAR, EQUALS, HYPHEN, OPENBRACE, CLOSEBRACE, PERCENT, PIPE, PLUS, POUND, QUERY, SLASH, SYM, TILDE, UNDERSCORE];\n\n  // The universal starting state.\n  /**\n   * @type State<Token>\n   */\n  const Start = makeState();\n  const Localpart = tt(Start, TILDE); // Local part of the email address\n  ta(Localpart, localpartAccepting, Localpart);\n  ta(Localpart, groups.domain, Localpart);\n  const Domain = makeState(),\n    Scheme = makeState(),\n    SlashScheme = makeState();\n  ta(Start, groups.domain, Domain); // parsed string ends with a potential domain name (A)\n  ta(Start, groups.scheme, Scheme); // e.g., 'mailto'\n  ta(Start, groups.slashscheme, SlashScheme); // e.g., 'http'\n\n  ta(Domain, localpartAccepting, Localpart);\n  ta(Domain, groups.domain, Domain);\n  const LocalpartAt = tt(Domain, AT); // Local part of the email address plus @\n\n  tt(Localpart, AT, LocalpartAt); // close to an email address now\n\n  // Local part of an email address can be e.g. 'http' or 'mailto'\n  tt(Scheme, AT, LocalpartAt);\n  tt(SlashScheme, AT, LocalpartAt);\n  const LocalpartDot = tt(Localpart, DOT); // Local part of the email address plus '.' (localpart cannot end in .)\n  ta(LocalpartDot, localpartAccepting, Localpart);\n  ta(LocalpartDot, groups.domain, Localpart);\n  const EmailDomain = makeState();\n  ta(LocalpartAt, groups.domain, EmailDomain); // parsed string starts with local email info + @ with a potential domain name\n  ta(EmailDomain, groups.domain, EmailDomain);\n  const EmailDomainDot = tt(EmailDomain, DOT); // domain followed by DOT\n  ta(EmailDomainDot, groups.domain, EmailDomain);\n  const Email$1 = makeState(Email); // Possible email address (could have more tlds)\n  ta(EmailDomainDot, groups.tld, Email$1);\n  ta(EmailDomainDot, groups.utld, Email$1);\n  tt(LocalpartAt, LOCALHOST, Email$1);\n\n  // Hyphen can jump back to a domain name\n  const EmailDomainHyphen = tt(EmailDomain, HYPHEN); // parsed string starts with local email info + @ with a potential domain name\n  ta(EmailDomainHyphen, groups.domain, EmailDomain);\n  ta(Email$1, groups.domain, EmailDomain);\n  tt(Email$1, DOT, EmailDomainDot);\n  tt(Email$1, HYPHEN, EmailDomainHyphen);\n\n  // Final possible email states\n  const EmailColon = tt(Email$1, COLON); // URL followed by colon (potential port number here)\n  /*const EmailColonPort = */\n  ta(EmailColon, groups.numeric, Email); // URL followed by colon and port number\n\n  // Account for dots and hyphens. Hyphens are usually parts of domain names\n  // (but not TLDs)\n  const DomainHyphen = tt(Domain, HYPHEN); // domain followed by hyphen\n  const DomainDot = tt(Domain, DOT); // domain followed by DOT\n  ta(DomainHyphen, groups.domain, Domain);\n  ta(DomainDot, localpartAccepting, Localpart);\n  ta(DomainDot, groups.domain, Domain);\n  const DomainDotTld = makeState(Url); // Simplest possible URL with no query string\n  ta(DomainDot, groups.tld, DomainDotTld);\n  ta(DomainDot, groups.utld, DomainDotTld);\n  ta(DomainDotTld, groups.domain, Domain);\n  ta(DomainDotTld, localpartAccepting, Localpart);\n  tt(DomainDotTld, DOT, DomainDot);\n  tt(DomainDotTld, HYPHEN, DomainHyphen);\n  tt(DomainDotTld, AT, LocalpartAt);\n  const DomainDotTldColon = tt(DomainDotTld, COLON); // URL followed by colon (potential port number here)\n  const DomainDotTldColonPort = makeState(Url); // TLD followed by a port number\n  ta(DomainDotTldColon, groups.numeric, DomainDotTldColonPort);\n\n  // Long URL with optional port and maybe query string\n  const Url$1 = makeState(Url);\n\n  // URL with extra symbols at the end, followed by an opening bracket\n  const UrlNonaccept = makeState(); // URL followed by some symbols (will not be part of the final URL)\n\n  // Query strings\n  ta(Url$1, qsAccepting, Url$1);\n  ta(Url$1, qsNonAccepting, UrlNonaccept);\n  ta(UrlNonaccept, qsAccepting, Url$1);\n  ta(UrlNonaccept, qsNonAccepting, UrlNonaccept);\n\n  // Become real URLs after `SLASH` or `COLON NUM SLASH`\n  // Here works with or without scheme:// prefix\n  tt(DomainDotTld, SLASH, Url$1);\n  tt(DomainDotTldColonPort, SLASH, Url$1);\n\n  // Note that domains that begin with schemes are treated slighly differently\n  const SchemeColon = tt(Scheme, COLON); // e.g., 'mailto:'\n  const SlashSchemeColon = tt(SlashScheme, COLON); // e.g., 'http:'\n  const SlashSchemeColonSlash = tt(SlashSchemeColon, SLASH); // e.g., 'http:/'\n\n  const UriPrefix = tt(SlashSchemeColonSlash, SLASH); // e.g., 'http://'\n\n  // Scheme states can transition to domain states\n  ta(Scheme, groups.domain, Domain);\n  tt(Scheme, DOT, DomainDot);\n  tt(Scheme, HYPHEN, DomainHyphen);\n  ta(SlashScheme, groups.domain, Domain);\n  tt(SlashScheme, DOT, DomainDot);\n  tt(SlashScheme, HYPHEN, DomainHyphen);\n\n  // Force URL with scheme prefix followed by anything sane\n  ta(SchemeColon, groups.domain, Url$1);\n  tt(SchemeColon, SLASH, Url$1);\n  ta(UriPrefix, groups.domain, Url$1);\n  ta(UriPrefix, qsAccepting, Url$1);\n  tt(UriPrefix, SLASH, Url$1);\n  const bracketPairs = [[OPENBRACE, CLOSEBRACE],\n  // {}\n  [OPENBRACKET, CLOSEBRACKET],\n  // []\n  [OPENPAREN, CLOSEPAREN],\n  // ()\n  [OPENANGLEBRACKET, CLOSEANGLEBRACKET],\n  // <>\n  [FULLWIDTHLEFTPAREN, FULLWIDTHRIGHTPAREN],\n  // （）\n  [LEFTCORNERBRACKET, RIGHTCORNERBRACKET],\n  // 「」\n  [LEFTWHITECORNERBRACKET, RIGHTWHITECORNERBRACKET],\n  // 『』\n  [FULLWIDTHLESSTHAN, FULLWIDTHGREATERTHAN] // ＜＞\n  ];\n\n  for (let i = 0; i < bracketPairs.length; i++) {\n    const [OPEN, CLOSE] = bracketPairs[i];\n    const UrlOpen = tt(Url$1, OPEN); // URL followed by open bracket\n\n    // Continue not accepting for open brackets\n    tt(UrlNonaccept, OPEN, UrlOpen);\n\n    // Closing bracket component. This character WILL be included in the URL\n    tt(UrlOpen, CLOSE, Url$1);\n\n    // URL that beings with an opening bracket, followed by a symbols.\n    // Note that the final state can still be `UrlOpen` (if the URL has a\n    // single opening bracket for some reason).\n    const UrlOpenQ = makeState(Url);\n    ta(UrlOpen, qsAccepting, UrlOpenQ);\n    const UrlOpenSyms = makeState(); // UrlOpen followed by some symbols it cannot end it\n    ta(UrlOpen, qsNonAccepting);\n\n    // URL that begins with an opening bracket, followed by some symbols\n    ta(UrlOpenQ, qsAccepting, UrlOpenQ);\n    ta(UrlOpenQ, qsNonAccepting, UrlOpenSyms);\n    ta(UrlOpenSyms, qsAccepting, UrlOpenQ);\n    ta(UrlOpenSyms, qsNonAccepting, UrlOpenSyms);\n\n    // Close brace/bracket to become regular URL\n    tt(UrlOpenQ, CLOSE, Url$1);\n    tt(UrlOpenSyms, CLOSE, Url$1);\n  }\n  tt(Start, LOCALHOST, DomainDotTld); // localhost is a valid URL state\n  tt(Start, NL$1, Nl); // single new line\n\n  return {\n    start: Start,\n    tokens: tk\n  };\n}\n\n/**\n * Run the parser state machine on a list of scanned string-based tokens to\n * create a list of multi tokens, each of which represents a URL, email address,\n * plain text, etc.\n *\n * @param {State<MultiToken>} start parser start state\n * @param {string} input the original input used to generate the given tokens\n * @param {Token[]} tokens list of scanned tokens\n * @returns {MultiToken[]}\n */\nfunction run(start, input, tokens) {\n  let len = tokens.length;\n  let cursor = 0;\n  let multis = [];\n  let textTokens = [];\n  while (cursor < len) {\n    let state = start;\n    let secondState = null;\n    let nextState = null;\n    let multiLength = 0;\n    let latestAccepting = null;\n    let sinceAccepts = -1;\n    while (cursor < len && !(secondState = state.go(tokens[cursor].t))) {\n      // Starting tokens with nowhere to jump to.\n      // Consider these to be just plain text\n      textTokens.push(tokens[cursor++]);\n    }\n    while (cursor < len && (nextState = secondState || state.go(tokens[cursor].t))) {\n      // Get the next state\n      secondState = null;\n      state = nextState;\n\n      // Keep track of the latest accepting state\n      if (state.accepts()) {\n        sinceAccepts = 0;\n        latestAccepting = state;\n      } else if (sinceAccepts >= 0) {\n        sinceAccepts++;\n      }\n      cursor++;\n      multiLength++;\n    }\n    if (sinceAccepts < 0) {\n      // No accepting state was found, part of a regular text token add\n      // the first text token to the text tokens array and try again from\n      // the next\n      cursor -= multiLength;\n      if (cursor < len) {\n        textTokens.push(tokens[cursor]);\n        cursor++;\n      }\n    } else {\n      // Accepting state!\n      // First close off the textTokens (if available)\n      if (textTokens.length > 0) {\n        multis.push(initMultiToken(Text, input, textTokens));\n        textTokens = [];\n      }\n\n      // Roll back to the latest accepting state\n      cursor -= sinceAccepts;\n      multiLength -= sinceAccepts;\n\n      // Create a new multitoken\n      const Multi = latestAccepting.t;\n      const subtokens = tokens.slice(cursor - multiLength, cursor);\n      multis.push(initMultiToken(Multi, input, subtokens));\n    }\n  }\n\n  // Finally close off the textTokens (if available)\n  if (textTokens.length > 0) {\n    multis.push(initMultiToken(Text, input, textTokens));\n  }\n  return multis;\n}\n\n/**\n * Utility function for instantiating a new multitoken with all the relevant\n * fields during parsing.\n * @param {new (value: string, tokens: Token[]) => MultiToken} Multi class to instantiate\n * @param {string} input original input string\n * @param {Token[]} tokens consecutive tokens scanned from input string\n * @returns {MultiToken}\n */\nfunction initMultiToken(Multi, input, tokens) {\n  const startIdx = tokens[0].s;\n  const endIdx = tokens[tokens.length - 1].e;\n  const value = input.slice(startIdx, endIdx);\n  return new Multi(value, tokens);\n}\n\nconst warn = typeof console !== 'undefined' && console && console.warn || (() => {});\nconst warnAdvice = 'until manual call of linkify.init(). Register all schemes and plugins before invoking linkify the first time.';\n\n// Side-effect initialization state\nconst INIT = {\n  scanner: null,\n  parser: null,\n  tokenQueue: [],\n  pluginQueue: [],\n  customSchemes: [],\n  initialized: false\n};\n\n/**\n * @typedef {{\n * \tstart: State<string>,\n * \ttokens: { groups: Collections<string> } & typeof tk\n * }} ScannerInit\n */\n\n/**\n * @typedef {{\n * \tstart: State<MultiToken>,\n * \ttokens: typeof multi\n * }} ParserInit\n */\n\n/**\n * @typedef {(arg: { scanner: ScannerInit }) => void} TokenPlugin\n */\n\n/**\n * @typedef {(arg: { scanner: ScannerInit, parser: ParserInit }) => void} Plugin\n */\n\n/**\n * De-register all plugins and reset the internal state-machine. Used for\n * testing; not required in practice.\n * @private\n */\nfunction reset() {\n  State.groups = {};\n  INIT.scanner = null;\n  INIT.parser = null;\n  INIT.tokenQueue = [];\n  INIT.pluginQueue = [];\n  INIT.customSchemes = [];\n  INIT.initialized = false;\n}\n\n/**\n * Register a token plugin to allow the scanner to recognize additional token\n * types before the parser state machine is constructed from the results.\n * @param {string} name of plugin to register\n * @param {TokenPlugin} plugin function that accepts the scanner state machine\n * and available scanner tokens and collections and extends the state machine to\n * recognize additional tokens or groups.\n */\nfunction registerTokenPlugin(name, plugin) {\n  if (typeof plugin !== 'function') {\n    throw new Error(`linkifyjs: Invalid token plugin ${plugin} (expects function)`);\n  }\n  for (let i = 0; i < INIT.tokenQueue.length; i++) {\n    if (name === INIT.tokenQueue[i][0]) {\n      warn(`linkifyjs: token plugin \"${name}\" already registered - will be overwritten`);\n      INIT.tokenQueue[i] = [name, plugin];\n      return;\n    }\n  }\n  INIT.tokenQueue.push([name, plugin]);\n  if (INIT.initialized) {\n    warn(`linkifyjs: already initialized - will not register token plugin \"${name}\" ${warnAdvice}`);\n  }\n}\n\n/**\n * Register a linkify plugin\n * @param {string} name of plugin to register\n * @param {Plugin} plugin function that accepts the parser state machine and\n * extends the parser to recognize additional link types\n */\nfunction registerPlugin(name, plugin) {\n  if (typeof plugin !== 'function') {\n    throw new Error(`linkifyjs: Invalid plugin ${plugin} (expects function)`);\n  }\n  for (let i = 0; i < INIT.pluginQueue.length; i++) {\n    if (name === INIT.pluginQueue[i][0]) {\n      warn(`linkifyjs: plugin \"${name}\" already registered - will be overwritten`);\n      INIT.pluginQueue[i] = [name, plugin];\n      return;\n    }\n  }\n  INIT.pluginQueue.push([name, plugin]);\n  if (INIT.initialized) {\n    warn(`linkifyjs: already initialized - will not register plugin \"${name}\" ${warnAdvice}`);\n  }\n}\n\n/**\n * Detect URLs with the following additional protocol. Anything with format\n * \"protocol://...\" will be considered a link. If `optionalSlashSlash` is set to\n * `true`, anything with format \"protocol:...\" will be considered a link.\n * @param {string} protocol\n * @param {boolean} [optionalSlashSlash]\n */\nfunction registerCustomProtocol(scheme, optionalSlashSlash) {\n  if (optionalSlashSlash === void 0) {\n    optionalSlashSlash = false;\n  }\n  if (INIT.initialized) {\n    warn(`linkifyjs: already initialized - will not register custom scheme \"${scheme}\" ${warnAdvice}`);\n  }\n  if (!/^[0-9a-z]+(-[0-9a-z]+)*$/.test(scheme)) {\n    throw new Error(`linkifyjs: incorrect scheme format.\n1. Must only contain digits, lowercase ASCII letters or \"-\"\n2. Cannot start or end with \"-\"\n3. \"-\" cannot repeat`);\n  }\n  INIT.customSchemes.push([scheme, optionalSlashSlash]);\n}\n\n/**\n * Initialize the linkify state machine. Called automatically the first time\n * linkify is called on a string, but may be called manually as well.\n */\nfunction init() {\n  // Initialize scanner state machine and plugins\n  INIT.scanner = init$2(INIT.customSchemes);\n  for (let i = 0; i < INIT.tokenQueue.length; i++) {\n    INIT.tokenQueue[i][1]({\n      scanner: INIT.scanner\n    });\n  }\n\n  // Initialize parser state machine and plugins\n  INIT.parser = init$1(INIT.scanner.tokens);\n  for (let i = 0; i < INIT.pluginQueue.length; i++) {\n    INIT.pluginQueue[i][1]({\n      scanner: INIT.scanner,\n      parser: INIT.parser\n    });\n  }\n  INIT.initialized = true;\n}\n\n/**\n * Parse a string into tokens that represent linkable and non-linkable sub-components\n * @param {string} str\n * @return {MultiToken[]} tokens\n */\nfunction tokenize(str) {\n  if (!INIT.initialized) {\n    init();\n  }\n  return run(INIT.parser.start, str, run$1(INIT.scanner.start, str));\n}\n\n/**\n * Find a list of linkable items in the given string.\n * @param {string} str string to find links in\n * @param {string | Opts} [type] either formatting options or specific type of\n * links to find, e.g., 'url' or 'email'\n * @param {Opts} [opts] formatting options for final output. Cannot be specified\n * if opts already provided in `type` argument\n */\nfunction find(str, type, opts) {\n  if (type === void 0) {\n    type = null;\n  }\n  if (opts === void 0) {\n    opts = null;\n  }\n  if (type && typeof type === 'object') {\n    if (opts) {\n      throw Error(`linkifyjs: Invalid link type ${type}; must be a string`);\n    }\n    opts = type;\n    type = null;\n  }\n  const options = new Options(opts);\n  const tokens = tokenize(str);\n  const filtered = [];\n  for (let i = 0; i < tokens.length; i++) {\n    const token = tokens[i];\n    if (token.isLink && (!type || token.t === type) && options.check(token)) {\n      filtered.push(token.toFormattedObject(options));\n    }\n  }\n  return filtered;\n}\n\n/**\n * Is the given string valid linkable text of some sort. Note that this does not\n * trim the text for you.\n *\n * Optionally pass in a second `type` param, which is the type of link to test\n * for.\n *\n * For example,\n *\n *     linkify.test(str, 'email');\n *\n * Returns `true` if str is a valid email.\n * @param {string} str string to test for links\n * @param {string} [type] optional specific link type to look for\n * @returns boolean true/false\n */\nfunction test(str, type) {\n  if (type === void 0) {\n    type = null;\n  }\n  const tokens = tokenize(str);\n  return tokens.length === 1 && tokens[0].isLink && (!type || tokens[0].t === type);\n}\n\nexport { MultiToken, Options, State, createTokenClass, find, init, multi, options, regexp, registerCustomProtocol, registerPlugin, registerTokenPlugin, reset, stringToArray, test, tokenize };\n","import { combineTransactionSteps, getChangedRanges, getMarksBetween, findChildrenInRange, getAttributes, Mark, mergeAttributes, markPasteRule } from '@tiptap/core';\nimport { test, find, registerCustomProtocol, reset } from 'linkifyjs';\nimport { Plugin, PluginKey } from '@tiptap/pm/state';\n\nfunction autolink(options) {\r\n    return new Plugin({\r\n        key: new PluginKey('autolink'),\r\n        appendTransaction: (transactions, oldState, newState) => {\r\n            const docChanges = transactions.some(transaction => transaction.docChanged) && !oldState.doc.eq(newState.doc);\r\n            const preventAutolink = transactions.some(transaction => transaction.getMeta('preventAutolink'));\r\n            if (!docChanges || preventAutolink) {\r\n                return;\r\n            }\r\n            const { tr } = newState;\r\n            const transform = combineTransactionSteps(oldState.doc, [...transactions]);\r\n            const { mapping } = transform;\r\n            const changes = getChangedRanges(transform);\r\n            changes.forEach(({ oldRange, newRange }) => {\r\n                // at first we check if we have to remove links\r\n                getMarksBetween(oldRange.from, oldRange.to, oldState.doc)\r\n                    .filter(item => item.mark.type === options.type)\r\n                    .forEach(oldMark => {\r\n                    const newFrom = mapping.map(oldMark.from);\r\n                    const newTo = mapping.map(oldMark.to);\r\n                    const newMarks = getMarksBetween(newFrom, newTo, newState.doc).filter(item => item.mark.type === options.type);\r\n                    if (!newMarks.length) {\r\n                        return;\r\n                    }\r\n                    const newMark = newMarks[0];\r\n                    const oldLinkText = oldState.doc.textBetween(oldMark.from, oldMark.to, undefined, ' ');\r\n                    const newLinkText = newState.doc.textBetween(newMark.from, newMark.to, undefined, ' ');\r\n                    const wasLink = test(oldLinkText);\r\n                    const isLink = test(newLinkText);\r\n                    // remove only the link, if it was a link before too\r\n                    // because we don’t want to remove links that were set manually\r\n                    if (wasLink && !isLink) {\r\n                        tr.removeMark(newMark.from, newMark.to, options.type);\r\n                    }\r\n                });\r\n                // now let’s see if we can add new links\r\n                const nodesInChangedRanges = findChildrenInRange(newState.doc, newRange, node => node.isTextblock);\r\n                let textBlock;\r\n                let textBeforeWhitespace;\r\n                if (nodesInChangedRanges.length > 1) {\r\n                    // Grab the first node within the changed ranges (ex. the first of two paragraphs when hitting enter)\r\n                    textBlock = nodesInChangedRanges[0];\r\n                    textBeforeWhitespace = newState.doc.textBetween(textBlock.pos, textBlock.pos + textBlock.node.nodeSize, undefined, ' ');\r\n                }\r\n                else if (nodesInChangedRanges.length\r\n                    // We want to make sure to include the block seperator argument to treat hard breaks like spaces\r\n                    && newState.doc.textBetween(newRange.from, newRange.to, ' ', ' ').endsWith(' ')) {\r\n                    textBlock = nodesInChangedRanges[0];\r\n                    textBeforeWhitespace = newState.doc.textBetween(textBlock.pos, newRange.to, undefined, ' ');\r\n                }\r\n                if (textBlock && textBeforeWhitespace) {\r\n                    const wordsBeforeWhitespace = textBeforeWhitespace.split(' ').filter(s => s !== '');\r\n                    if (wordsBeforeWhitespace.length <= 0) {\r\n                        return false;\r\n                    }\r\n                    const lastWordBeforeSpace = wordsBeforeWhitespace[wordsBeforeWhitespace.length - 1];\r\n                    const lastWordAndBlockOffset = textBlock.pos + textBeforeWhitespace.lastIndexOf(lastWordBeforeSpace);\r\n                    if (!lastWordBeforeSpace) {\r\n                        return false;\r\n                    }\r\n                    find(lastWordBeforeSpace)\r\n                        .filter(link => link.isLink)\r\n                        .filter(link => {\r\n                        if (options.validate) {\r\n                            return options.validate(link.value);\r\n                        }\r\n                        return true;\r\n                    })\r\n                        // calculate link position\r\n                        .map(link => ({\r\n                        ...link,\r\n                        from: lastWordAndBlockOffset + link.start + 1,\r\n                        to: lastWordAndBlockOffset + link.end + 1,\r\n                    }))\r\n                        // add link mark\r\n                        .forEach(link => {\r\n                        tr.addMark(link.from, link.to, options.type.create({\r\n                            href: link.href,\r\n                        }));\r\n                    });\r\n                }\r\n            });\r\n            if (!tr.steps.length) {\r\n                return;\r\n            }\r\n            return tr;\r\n        },\r\n    });\r\n}\n\nfunction clickHandler(options) {\r\n    return new Plugin({\r\n        key: new PluginKey('handleClickLink'),\r\n        props: {\r\n            handleClick: (view, pos, event) => {\r\n                var _a, _b, _c;\r\n                if (event.button !== 0) {\r\n                    return false;\r\n                }\r\n                const attrs = getAttributes(view.state, options.type.name);\r\n                const link = (_a = event.target) === null || _a === void 0 ? void 0 : _a.closest('a');\r\n                const href = (_b = link === null || link === void 0 ? void 0 : link.href) !== null && _b !== void 0 ? _b : attrs.href;\r\n                const target = (_c = link === null || link === void 0 ? void 0 : link.target) !== null && _c !== void 0 ? _c : attrs.target;\r\n                if (link && href) {\r\n                    window.open(href, target);\r\n                    return true;\r\n                }\r\n                return false;\r\n            },\r\n        },\r\n    });\r\n}\n\nfunction pasteHandler(options) {\r\n    return new Plugin({\r\n        key: new PluginKey('handlePasteLink'),\r\n        props: {\r\n            handlePaste: (view, event, slice) => {\r\n                const { state } = view;\r\n                const { selection } = state;\r\n                const { empty } = selection;\r\n                if (empty) {\r\n                    return false;\r\n                }\r\n                let textContent = '';\r\n                slice.content.forEach(node => {\r\n                    textContent += node.textContent;\r\n                });\r\n                const link = find(textContent).find(item => item.isLink && item.value === textContent);\r\n                if (!textContent || !link) {\r\n                    return false;\r\n                }\r\n                options.editor.commands.setMark(options.type, {\r\n                    href: link.href,\r\n                });\r\n                return true;\r\n            },\r\n        },\r\n    });\r\n}\n\nconst Link = Mark.create({\r\n    name: 'link',\r\n    priority: 1000,\r\n    keepOnSplit: false,\r\n    onCreate() {\r\n        this.options.protocols.forEach(protocol => {\r\n            if (typeof protocol === 'string') {\r\n                registerCustomProtocol(protocol);\r\n                return;\r\n            }\r\n            registerCustomProtocol(protocol.scheme, protocol.optionalSlashes);\r\n        });\r\n    },\r\n    onDestroy() {\r\n        reset();\r\n    },\r\n    inclusive() {\r\n        return this.options.autolink;\r\n    },\r\n    addOptions() {\r\n        return {\r\n            openOnClick: true,\r\n            linkOnPaste: true,\r\n            autolink: true,\r\n            protocols: [],\r\n            HTMLAttributes: {\r\n                target: '_blank',\r\n                rel: 'noopener noreferrer nofollow',\r\n                class: null,\r\n            },\r\n            validate: undefined,\r\n        };\r\n    },\r\n    addAttributes() {\r\n        return {\r\n            href: {\r\n                default: null,\r\n            },\r\n            target: {\r\n                default: this.options.HTMLAttributes.target,\r\n            },\r\n            class: {\r\n                default: this.options.HTMLAttributes.class,\r\n            },\r\n        };\r\n    },\r\n    parseHTML() {\r\n        return [{ tag: 'a[href]:not([href *= \"javascript:\" i])' }];\r\n    },\r\n    renderHTML({ HTMLAttributes }) {\r\n        return ['a', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];\r\n    },\r\n    addCommands() {\r\n        return {\r\n            setLink: attributes => ({ chain }) => {\r\n                return chain().setMark(this.name, attributes).setMeta('preventAutolink', true).run();\r\n            },\r\n            toggleLink: attributes => ({ chain }) => {\r\n                return chain()\r\n                    .toggleMark(this.name, attributes, { extendEmptyMarkRange: true })\r\n                    .setMeta('preventAutolink', true)\r\n                    .run();\r\n            },\r\n            unsetLink: () => ({ chain }) => {\r\n                return chain()\r\n                    .unsetMark(this.name, { extendEmptyMarkRange: true })\r\n                    .setMeta('preventAutolink', true)\r\n                    .run();\r\n            },\r\n        };\r\n    },\r\n    addPasteRules() {\r\n        return [\r\n            markPasteRule({\r\n                find: text => find(text)\r\n                    .filter(link => {\r\n                    if (this.options.validate) {\r\n                        return this.options.validate(link.value);\r\n                    }\r\n                    return true;\r\n                })\r\n                    .filter(link => link.isLink)\r\n                    .map(link => ({\r\n                    text: link.value,\r\n                    index: link.start,\r\n                    data: link,\r\n                })),\r\n                type: this.type,\r\n                getAttributes: match => {\r\n                    var _a;\r\n                    return ({\r\n                        href: (_a = match.data) === null || _a === void 0 ? void 0 : _a.href,\r\n                    });\r\n                },\r\n            }),\r\n        ];\r\n    },\r\n    addProseMirrorPlugins() {\r\n        const plugins = [];\r\n        if (this.options.autolink) {\r\n            plugins.push(autolink({\r\n                type: this.type,\r\n                validate: this.options.validate,\r\n            }));\r\n        }\r\n        if (this.options.openOnClick) {\r\n            plugins.push(clickHandler({\r\n                type: this.type,\r\n            }));\r\n        }\r\n        if (this.options.linkOnPaste) {\r\n            plugins.push(pasteHandler({\r\n                editor: this.editor,\r\n                type: this.type,\r\n            }));\r\n        }\r\n        return plugins;\r\n    },\r\n});\n\nexport { Link, Link as default };\n//# sourceMappingURL=index.js.map\n","import { Node, mergeAttributes } from '@tiptap/core';\n\nconst ListItem = Node.create({\r\n    name: 'listItem',\r\n    addOptions() {\r\n        return {\r\n            HTMLAttributes: {},\r\n        };\r\n    },\r\n    content: 'paragraph block*',\r\n    defining: true,\r\n    parseHTML() {\r\n        return [\r\n            {\r\n                tag: 'li',\r\n            },\r\n        ];\r\n    },\r\n    renderHTML({ HTMLAttributes }) {\r\n        return ['li', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];\r\n    },\r\n    addKeyboardShortcuts() {\r\n        return {\r\n            Enter: () => this.editor.commands.splitListItem(this.name),\r\n            Tab: () => this.editor.commands.sinkListItem(this.name),\r\n            'Shift-Tab': () => this.editor.commands.liftListItem(this.name),\r\n        };\r\n    },\r\n});\n\nexport { ListItem, ListItem as default };\n//# sourceMappingURL=index.js.map\n","import { PluginKey, Plugin } from '@tiptap/pm/state';\nimport { DecorationSet, Decoration } from '@tiptap/pm/view';\nimport { escapeForRegEx } from '@tiptap/core';\n\nfunction findSuggestionMatch(config) {\r\n    var _a;\r\n    const { char, allowSpaces, allowedPrefixes, startOfLine, $position, } = config;\r\n    const escapedChar = escapeForRegEx(char);\r\n    const suffix = new RegExp(`\\\\s${escapedChar}$`);\r\n    const prefix = startOfLine ? '^' : '';\r\n    const regexp = allowSpaces\r\n        ? new RegExp(`${prefix}${escapedChar}.*?(?=\\\\s${escapedChar}|$)`, 'gm')\r\n        : new RegExp(`${prefix}(?:^)?${escapedChar}[^\\\\s${escapedChar}]*`, 'gm');\r\n    const text = ((_a = $position.nodeBefore) === null || _a === void 0 ? void 0 : _a.isText) && $position.nodeBefore.text;\r\n    if (!text) {\r\n        return null;\r\n    }\r\n    const textFrom = $position.pos - text.length;\r\n    const match = Array.from(text.matchAll(regexp)).pop();\r\n    if (!match || match.input === undefined || match.index === undefined) {\r\n        return null;\r\n    }\r\n    // JavaScript doesn't have lookbehinds. This hacks a check that first character\r\n    // is a space or the start of the line\r\n    const matchPrefix = match.input.slice(Math.max(0, match.index - 1), match.index);\r\n    const matchPrefixIsAllowed = new RegExp(`^[${allowedPrefixes === null || allowedPrefixes === void 0 ? void 0 : allowedPrefixes.join('')}\\0]?$`).test(matchPrefix);\r\n    if (allowedPrefixes !== null && !matchPrefixIsAllowed) {\r\n        return null;\r\n    }\r\n    // The absolute position of the match in the document\r\n    const from = textFrom + match.index;\r\n    let to = from + match[0].length;\r\n    // Edge case handling; if spaces are allowed and we're directly in between\r\n    // two triggers\r\n    if (allowSpaces && suffix.test(text.slice(to - 1, to + 1))) {\r\n        match[0] += ' ';\r\n        to += 1;\r\n    }\r\n    // If the $position is located within the matched substring, return that range\r\n    if (from < $position.pos && to >= $position.pos) {\r\n        return {\r\n            range: {\r\n                from,\r\n                to,\r\n            },\r\n            query: match[0].slice(char.length),\r\n            text: match[0],\r\n        };\r\n    }\r\n    return null;\r\n}\n\nconst SuggestionPluginKey = new PluginKey('suggestion');\r\nfunction Suggestion({ pluginKey = SuggestionPluginKey, editor, char = '@', allowSpaces = false, allowedPrefixes = [' '], startOfLine = false, decorationTag = 'span', decorationClass = 'suggestion', command = () => null, items = () => [], render = () => ({}), allow = () => true, }) {\r\n    let props;\r\n    const renderer = render === null || render === void 0 ? void 0 : render();\r\n    const plugin = new Plugin({\r\n        key: pluginKey,\r\n        view() {\r\n            return {\r\n                update: async (view, prevState) => {\r\n                    var _a, _b, _c, _d, _e, _f, _g;\r\n                    const prev = (_a = this.key) === null || _a === void 0 ? void 0 : _a.getState(prevState);\r\n                    const next = (_b = this.key) === null || _b === void 0 ? void 0 : _b.getState(view.state);\r\n                    // See how the state changed\r\n                    const moved = prev.active && next.active && prev.range.from !== next.range.from;\r\n                    const started = !prev.active && next.active;\r\n                    const stopped = prev.active && !next.active;\r\n                    const changed = !started && !stopped && prev.query !== next.query;\r\n                    const handleStart = started || moved;\r\n                    const handleChange = changed && !moved;\r\n                    const handleExit = stopped || moved;\r\n                    // Cancel when suggestion isn't active\r\n                    if (!handleStart && !handleChange && !handleExit) {\r\n                        return;\r\n                    }\r\n                    const state = handleExit && !handleStart ? prev : next;\r\n                    const decorationNode = view.dom.querySelector(`[data-decoration-id=\"${state.decorationId}\"]`);\r\n                    props = {\r\n                        editor,\r\n                        range: state.range,\r\n                        query: state.query,\r\n                        text: state.text,\r\n                        items: [],\r\n                        command: commandProps => {\r\n                            command({\r\n                                editor,\r\n                                range: state.range,\r\n                                props: commandProps,\r\n                            });\r\n                        },\r\n                        decorationNode,\r\n                        // virtual node for popper.js or tippy.js\r\n                        // this can be used for building popups without a DOM node\r\n                        clientRect: decorationNode\r\n                            ? () => {\r\n                                var _a;\r\n                                // because of `items` can be asynchrounous we’ll search for the current decoration node\r\n                                const { decorationId } = (_a = this.key) === null || _a === void 0 ? void 0 : _a.getState(editor.state); // eslint-disable-line\r\n                                const currentDecorationNode = view.dom.querySelector(`[data-decoration-id=\"${decorationId}\"]`);\r\n                                return (currentDecorationNode === null || currentDecorationNode === void 0 ? void 0 : currentDecorationNode.getBoundingClientRect()) || null;\r\n                            }\r\n                            : null,\r\n                    };\r\n                    if (handleStart) {\r\n                        (_c = renderer === null || renderer === void 0 ? void 0 : renderer.onBeforeStart) === null || _c === void 0 ? void 0 : _c.call(renderer, props);\r\n                    }\r\n                    if (handleChange) {\r\n                        (_d = renderer === null || renderer === void 0 ? void 0 : renderer.onBeforeUpdate) === null || _d === void 0 ? void 0 : _d.call(renderer, props);\r\n                    }\r\n                    if (handleChange || handleStart) {\r\n                        props.items = await items({\r\n                            editor,\r\n                            query: state.query,\r\n                        });\r\n                    }\r\n                    if (handleExit) {\r\n                        (_e = renderer === null || renderer === void 0 ? void 0 : renderer.onExit) === null || _e === void 0 ? void 0 : _e.call(renderer, props);\r\n                    }\r\n                    if (handleChange) {\r\n                        (_f = renderer === null || renderer === void 0 ? void 0 : renderer.onUpdate) === null || _f === void 0 ? void 0 : _f.call(renderer, props);\r\n                    }\r\n                    if (handleStart) {\r\n                        (_g = renderer === null || renderer === void 0 ? void 0 : renderer.onStart) === null || _g === void 0 ? void 0 : _g.call(renderer, props);\r\n                    }\r\n                },\r\n                destroy: () => {\r\n                    var _a;\r\n                    if (!props) {\r\n                        return;\r\n                    }\r\n                    (_a = renderer === null || renderer === void 0 ? void 0 : renderer.onExit) === null || _a === void 0 ? void 0 : _a.call(renderer, props);\r\n                },\r\n            };\r\n        },\r\n        state: {\r\n            // Initialize the plugin's internal state.\r\n            init() {\r\n                const state = {\r\n                    active: false,\r\n                    range: {\r\n                        from: 0,\r\n                        to: 0,\r\n                    },\r\n                    query: null,\r\n                    text: null,\r\n                    composing: false,\r\n                };\r\n                return state;\r\n            },\r\n            // Apply changes to the plugin state from a view transaction.\r\n            apply(transaction, prev, oldState, state) {\r\n                const { isEditable } = editor;\r\n                const { composing } = editor.view;\r\n                const { selection } = transaction;\r\n                const { empty, from } = selection;\r\n                const next = { ...prev };\r\n                next.composing = composing;\r\n                // We can only be suggesting if the view is editable, and:\r\n                //   * there is no selection, or\r\n                //   * a composition is active (see: https://github.com/ueberdosis/tiptap/issues/1449)\r\n                if (isEditable && (empty || editor.view.composing)) {\r\n                    // Reset active state if we just left the previous suggestion range\r\n                    if ((from < prev.range.from || from > prev.range.to) && !composing && !prev.composing) {\r\n                        next.active = false;\r\n                    }\r\n                    // Try to match against where our cursor currently is\r\n                    const match = findSuggestionMatch({\r\n                        char,\r\n                        allowSpaces,\r\n                        allowedPrefixes,\r\n                        startOfLine,\r\n                        $position: selection.$from,\r\n                    });\r\n                    const decorationId = `id_${Math.floor(Math.random() * 0xffffffff)}`;\r\n                    // If we found a match, update the current state to show it\r\n                    if (match && allow({ editor, state, range: match.range })) {\r\n                        next.active = true;\r\n                        next.decorationId = prev.decorationId ? prev.decorationId : decorationId;\r\n                        next.range = match.range;\r\n                        next.query = match.query;\r\n                        next.text = match.text;\r\n                    }\r\n                    else {\r\n                        next.active = false;\r\n                    }\r\n                }\r\n                else {\r\n                    next.active = false;\r\n                }\r\n                // Make sure to empty the range if suggestion is inactive\r\n                if (!next.active) {\r\n                    next.decorationId = null;\r\n                    next.range = { from: 0, to: 0 };\r\n                    next.query = null;\r\n                    next.text = null;\r\n                }\r\n                return next;\r\n            },\r\n        },\r\n        props: {\r\n            // Call the keydown hook if suggestion is active.\r\n            handleKeyDown(view, event) {\r\n                var _a;\r\n                const { active, range } = plugin.getState(view.state);\r\n                if (!active) {\r\n                    return false;\r\n                }\r\n                return ((_a = renderer === null || renderer === void 0 ? void 0 : renderer.onKeyDown) === null || _a === void 0 ? void 0 : _a.call(renderer, { view, event, range })) || false;\r\n            },\r\n            // Setup decorator on the currently active suggestion.\r\n            decorations(state) {\r\n                const { active, range, decorationId } = plugin.getState(state);\r\n                if (!active) {\r\n                    return null;\r\n                }\r\n                return DecorationSet.create(state.doc, [\r\n                    Decoration.inline(range.from, range.to, {\r\n                        nodeName: decorationTag,\r\n                        class: decorationClass,\r\n                        'data-decoration-id': decorationId,\r\n                    }),\r\n                ]);\r\n            },\r\n        },\r\n    });\r\n    return plugin;\r\n}\n\nexport { Suggestion, SuggestionPluginKey, Suggestion as default, findSuggestionMatch };\n//# sourceMappingURL=index.js.map\n","import { Node, mergeAttributes } from '@tiptap/core';\nimport { PluginKey } from '@tiptap/pm/state';\nimport Suggestion from '@tiptap/suggestion';\n\nconst MentionPluginKey = new PluginKey('mention');\r\nconst Mention = Node.create({\r\n    name: 'mention',\r\n    addOptions() {\r\n        return {\r\n            HTMLAttributes: {},\r\n            renderLabel({ options, node }) {\r\n                var _a;\r\n                return `${options.suggestion.char}${(_a = node.attrs.label) !== null && _a !== void 0 ? _a : node.attrs.id}`;\r\n            },\r\n            suggestion: {\r\n                char: '@',\r\n                pluginKey: MentionPluginKey,\r\n                command: ({ editor, range, props }) => {\r\n                    var _a, _b;\r\n                    // increase range.to by one when the next node is of type \"text\"\r\n                    // and starts with a space character\r\n                    const nodeAfter = editor.view.state.selection.$to.nodeAfter;\r\n                    const overrideSpace = (_a = nodeAfter === null || nodeAfter === void 0 ? void 0 : nodeAfter.text) === null || _a === void 0 ? void 0 : _a.startsWith(' ');\r\n                    if (overrideSpace) {\r\n                        range.to += 1;\r\n                    }\r\n                    editor\r\n                        .chain()\r\n                        .focus()\r\n                        .insertContentAt(range, [\r\n                        {\r\n                            type: this.name,\r\n                            attrs: props,\r\n                        },\r\n                        {\r\n                            type: 'text',\r\n                            text: ' ',\r\n                        },\r\n                    ])\r\n                        .run();\r\n                    (_b = window.getSelection()) === null || _b === void 0 ? void 0 : _b.collapseToEnd();\r\n                },\r\n                allow: ({ state, range }) => {\r\n                    const $from = state.doc.resolve(range.from);\r\n                    const type = state.schema.nodes[this.name];\r\n                    const allow = !!$from.parent.type.contentMatch.matchType(type);\r\n                    return allow;\r\n                },\r\n            },\r\n        };\r\n    },\r\n    group: 'inline',\r\n    inline: true,\r\n    selectable: false,\r\n    atom: true,\r\n    addAttributes() {\r\n        return {\r\n            id: {\r\n                default: null,\r\n                parseHTML: element => element.getAttribute('data-id'),\r\n                renderHTML: attributes => {\r\n                    if (!attributes.id) {\r\n                        return {};\r\n                    }\r\n                    return {\r\n                        'data-id': attributes.id,\r\n                    };\r\n                },\r\n            },\r\n            label: {\r\n                default: null,\r\n                parseHTML: element => element.getAttribute('data-label'),\r\n                renderHTML: attributes => {\r\n                    if (!attributes.label) {\r\n                        return {};\r\n                    }\r\n                    return {\r\n                        'data-label': attributes.label,\r\n                    };\r\n                },\r\n            },\r\n        };\r\n    },\r\n    parseHTML() {\r\n        return [\r\n            {\r\n                tag: `span[data-type=\"${this.name}\"]`,\r\n            },\r\n        ];\r\n    },\r\n    renderHTML({ node, HTMLAttributes }) {\r\n        return [\r\n            'span',\r\n            mergeAttributes({ 'data-type': this.name }, this.options.HTMLAttributes, HTMLAttributes),\r\n            this.options.renderLabel({\r\n                options: this.options,\r\n                node,\r\n            }),\r\n        ];\r\n    },\r\n    renderText({ node }) {\r\n        return this.options.renderLabel({\r\n            options: this.options,\r\n            node,\r\n        });\r\n    },\r\n    addKeyboardShortcuts() {\r\n        return {\r\n            Backspace: () => this.editor.commands.command(({ tr, state }) => {\r\n                let isMention = false;\r\n                const { selection } = state;\r\n                const { empty, anchor } = selection;\r\n                if (!empty) {\r\n                    return false;\r\n                }\r\n                state.doc.nodesBetween(anchor - 1, anchor, (node, pos) => {\r\n                    if (node.type.name === this.name) {\r\n                        isMention = true;\r\n                        tr.insertText(this.options.suggestion.char || '', pos, pos + node.nodeSize);\r\n                        return false;\r\n                    }\r\n                });\r\n                return isMention;\r\n            }),\r\n        };\r\n    },\r\n    addProseMirrorPlugins() {\r\n        return [\r\n            Suggestion({\r\n                editor: this.editor,\r\n                ...this.options.suggestion,\r\n            }),\r\n        ];\r\n    },\r\n});\n\nexport { Mention, MentionPluginKey, Mention as default };\n//# sourceMappingURL=index.js.map\n","import { Node, mergeAttributes, Mark, getMarkAttributes, wrappingInputRule } from '@tiptap/core';\n\nconst ListItem = Node.create({\r\n    name: 'listItem',\r\n    addOptions() {\r\n        return {\r\n            HTMLAttributes: {},\r\n        };\r\n    },\r\n    content: 'paragraph block*',\r\n    defining: true,\r\n    parseHTML() {\r\n        return [\r\n            {\r\n                tag: 'li',\r\n            },\r\n        ];\r\n    },\r\n    renderHTML({ HTMLAttributes }) {\r\n        return ['li', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];\r\n    },\r\n    addKeyboardShortcuts() {\r\n        return {\r\n            Enter: () => this.editor.commands.splitListItem(this.name),\r\n            Tab: () => this.editor.commands.sinkListItem(this.name),\r\n            'Shift-Tab': () => this.editor.commands.liftListItem(this.name),\r\n        };\r\n    },\r\n});\n\nconst TextStyle = Mark.create({\r\n    name: 'textStyle',\r\n    addOptions() {\r\n        return {\r\n            HTMLAttributes: {},\r\n        };\r\n    },\r\n    parseHTML() {\r\n        return [\r\n            {\r\n                tag: 'span',\r\n                getAttrs: element => {\r\n                    const hasStyles = element.hasAttribute('style');\r\n                    if (!hasStyles) {\r\n                        return false;\r\n                    }\r\n                    return {};\r\n                },\r\n            },\r\n        ];\r\n    },\r\n    renderHTML({ HTMLAttributes }) {\r\n        return ['span', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];\r\n    },\r\n    addCommands() {\r\n        return {\r\n            removeEmptyTextStyle: () => ({ state, commands }) => {\r\n                const attributes = getMarkAttributes(state, this.type);\r\n                const hasStyles = Object.entries(attributes).some(([, value]) => !!value);\r\n                if (hasStyles) {\r\n                    return true;\r\n                }\r\n                return commands.unsetMark(this.name);\r\n            },\r\n        };\r\n    },\r\n});\n\nconst inputRegex = /^(\\d+)\\.\\s$/;\r\nconst OrderedList = Node.create({\r\n    name: 'orderedList',\r\n    addOptions() {\r\n        return {\r\n            itemTypeName: 'listItem',\r\n            HTMLAttributes: {},\r\n            keepMarks: false,\r\n            keepAttributes: false,\r\n        };\r\n    },\r\n    group: 'block list',\r\n    content() {\r\n        return `${this.options.itemTypeName}+`;\r\n    },\r\n    addAttributes() {\r\n        return {\r\n            start: {\r\n                default: 1,\r\n                parseHTML: element => {\r\n                    return element.hasAttribute('start')\r\n                        ? parseInt(element.getAttribute('start') || '', 10)\r\n                        : 1;\r\n                },\r\n            },\r\n        };\r\n    },\r\n    parseHTML() {\r\n        return [\r\n            {\r\n                tag: 'ol',\r\n            },\r\n        ];\r\n    },\r\n    renderHTML({ HTMLAttributes }) {\r\n        const { start, ...attributesWithoutStart } = HTMLAttributes;\r\n        return start === 1\r\n            ? ['ol', mergeAttributes(this.options.HTMLAttributes, attributesWithoutStart), 0]\r\n            : ['ol', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];\r\n    },\r\n    addCommands() {\r\n        return {\r\n            toggleOrderedList: () => ({ commands, chain }) => {\r\n                if (this.options.keepAttributes) {\r\n                    return chain().toggleList(this.name, this.options.itemTypeName, this.options.keepMarks).updateAttributes(ListItem.name, this.editor.getAttributes(TextStyle.name)).run();\r\n                }\r\n                return commands.toggleList(this.name, this.options.itemTypeName, this.options.keepMarks);\r\n            },\r\n        };\r\n    },\r\n    addKeyboardShortcuts() {\r\n        return {\r\n            'Mod-Shift-7': () => this.editor.commands.toggleOrderedList(),\r\n        };\r\n    },\r\n    addInputRules() {\r\n        let inputRule = wrappingInputRule({\r\n            find: inputRegex,\r\n            type: this.type,\r\n            getAttributes: match => ({ start: +match[1] }),\r\n            joinPredicate: (match, node) => node.childCount + node.attrs.start === +match[1],\r\n        });\r\n        if (this.options.keepMarks || this.options.keepAttributes) {\r\n            inputRule = wrappingInputRule({\r\n                find: inputRegex,\r\n                type: this.type,\r\n                keepMarks: this.options.keepMarks,\r\n                keepAttributes: this.options.keepAttributes,\r\n                getAttributes: match => ({ start: +match[1], ...this.editor.getAttributes(TextStyle.name) }),\r\n                joinPredicate: (match, node) => node.childCount + node.attrs.start === +match[1],\r\n                editor: this.editor,\r\n            });\r\n        }\r\n        return [\r\n            inputRule,\r\n        ];\r\n    },\r\n});\n\nexport { OrderedList, OrderedList as default, inputRegex };\n//# sourceMappingURL=index.js.map\n","import { Node, mergeAttributes } from '@tiptap/core';\n\nconst Paragraph = Node.create({\r\n    name: 'paragraph',\r\n    priority: 1000,\r\n    addOptions() {\r\n        return {\r\n            HTMLAttributes: {},\r\n        };\r\n    },\r\n    group: 'block',\r\n    content: 'inline*',\r\n    parseHTML() {\r\n        return [\r\n            { tag: 'p' },\r\n        ];\r\n    },\r\n    renderHTML({ HTMLAttributes }) {\r\n        return ['p', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];\r\n    },\r\n    addCommands() {\r\n        return {\r\n            setParagraph: () => ({ commands }) => {\r\n                return commands.setNode(this.name);\r\n            },\r\n        };\r\n    },\r\n    addKeyboardShortcuts() {\r\n        return {\r\n            'Mod-Alt-0': () => this.editor.commands.setParagraph(),\r\n        };\r\n    },\r\n});\n\nexport { Paragraph, Paragraph as default };\n//# sourceMappingURL=index.js.map\n","import { Extension } from '@tiptap/core';\nimport { Plugin, PluginKey } from '@tiptap/pm/state';\nimport { Decoration, DecorationSet } from '@tiptap/pm/view';\n\nconst Placeholder = Extension.create({\r\n    name: 'placeholder',\r\n    addOptions() {\r\n        return {\r\n            emptyEditorClass: 'is-editor-empty',\r\n            emptyNodeClass: 'is-empty',\r\n            placeholder: 'Write something …',\r\n            showOnlyWhenEditable: true,\r\n            showOnlyCurrent: true,\r\n            includeChildren: false,\r\n        };\r\n    },\r\n    addProseMirrorPlugins() {\r\n        return [\r\n            new Plugin({\r\n                key: new PluginKey('placeholder'),\r\n                props: {\r\n                    decorations: ({ doc, selection }) => {\r\n                        const active = this.editor.isEditable || !this.options.showOnlyWhenEditable;\r\n                        const { anchor } = selection;\r\n                        const decorations = [];\r\n                        if (!active) {\r\n                            return null;\r\n                        }\r\n                        // only calculate isEmpty once due to its performance impacts (see issue #3360)\r\n                        const emptyDocInstance = doc.type.createAndFill();\r\n                        const isEditorEmpty = (emptyDocInstance === null || emptyDocInstance === void 0 ? void 0 : emptyDocInstance.sameMarkup(doc))\r\n                            && emptyDocInstance.content.findDiffStart(doc.content) === null;\r\n                        doc.descendants((node, pos) => {\r\n                            const hasAnchor = anchor >= pos && anchor <= pos + node.nodeSize;\r\n                            const isEmpty = !node.isLeaf && !node.childCount;\r\n                            if ((hasAnchor || !this.options.showOnlyCurrent) && isEmpty) {\r\n                                const classes = [this.options.emptyNodeClass];\r\n                                if (isEditorEmpty) {\r\n                                    classes.push(this.options.emptyEditorClass);\r\n                                }\r\n                                const decoration = Decoration.node(pos, pos + node.nodeSize, {\r\n                                    class: classes.join(' '),\r\n                                    'data-placeholder': typeof this.options.placeholder === 'function'\r\n                                        ? this.options.placeholder({\r\n                                            editor: this.editor,\r\n                                            node,\r\n                                            pos,\r\n                                            hasAnchor,\r\n                                        })\r\n                                        : this.options.placeholder,\r\n                                });\r\n                                decorations.push(decoration);\r\n                            }\r\n                            return this.options.includeChildren;\r\n                        });\r\n                        return DecorationSet.create(doc, decorations);\r\n                    },\r\n                },\r\n            }),\r\n        ];\r\n    },\r\n});\n\nexport { Placeholder, Placeholder as default };\n//# sourceMappingURL=index.js.map\n","import { Mark, mergeAttributes, markInputRule, markPasteRule } from '@tiptap/core';\n\nconst inputRegex = /(?:^|\\s)((?:~~)((?:[^~]+))(?:~~))$/;\r\nconst pasteRegex = /(?:^|\\s)((?:~~)((?:[^~]+))(?:~~))/g;\r\nconst Strike = Mark.create({\r\n    name: 'strike',\r\n    addOptions() {\r\n        return {\r\n            HTMLAttributes: {},\r\n        };\r\n    },\r\n    parseHTML() {\r\n        return [\r\n            {\r\n                tag: 's',\r\n            },\r\n            {\r\n                tag: 'del',\r\n            },\r\n            {\r\n                tag: 'strike',\r\n            },\r\n            {\r\n                style: 'text-decoration',\r\n                consuming: false,\r\n                getAttrs: style => (style.includes('line-through') ? {} : false),\r\n            },\r\n        ];\r\n    },\r\n    renderHTML({ HTMLAttributes }) {\r\n        return ['s', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];\r\n    },\r\n    addCommands() {\r\n        return {\r\n            setStrike: () => ({ commands }) => {\r\n                return commands.setMark(this.name);\r\n            },\r\n            toggleStrike: () => ({ commands }) => {\r\n                return commands.toggleMark(this.name);\r\n            },\r\n            unsetStrike: () => ({ commands }) => {\r\n                return commands.unsetMark(this.name);\r\n            },\r\n        };\r\n    },\r\n    addKeyboardShortcuts() {\r\n        return {\r\n            'Mod-Shift-x': () => this.editor.commands.toggleStrike(),\r\n        };\r\n    },\r\n    addInputRules() {\r\n        return [\r\n            markInputRule({\r\n                find: inputRegex,\r\n                type: this.type,\r\n            }),\r\n        ];\r\n    },\r\n    addPasteRules() {\r\n        return [\r\n            markPasteRule({\r\n                find: pasteRegex,\r\n                type: this.type,\r\n            }),\r\n        ];\r\n    },\r\n});\n\nexport { Strike, Strike as default, inputRegex, pasteRegex };\n//# sourceMappingURL=index.js.map\n","import { Mark, mergeAttributes } from '@tiptap/core';\n\nconst Subscript = Mark.create({\r\n    name: 'subscript',\r\n    addOptions() {\r\n        return {\r\n            HTMLAttributes: {},\r\n        };\r\n    },\r\n    parseHTML() {\r\n        return [\r\n            {\r\n                tag: 'sub',\r\n            },\r\n            {\r\n                style: 'vertical-align',\r\n                getAttrs(value) {\r\n                    // Don’t match this rule if the vertical align isn’t sub.\r\n                    if (value !== 'sub') {\r\n                        return false;\r\n                    }\r\n                    // If it falls through we’ll match, and this mark will be applied.\r\n                    return null;\r\n                },\r\n            },\r\n        ];\r\n    },\r\n    renderHTML({ HTMLAttributes }) {\r\n        return ['sub', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];\r\n    },\r\n    addCommands() {\r\n        return {\r\n            setSubscript: () => ({ commands }) => {\r\n                return commands.setMark(this.name);\r\n            },\r\n            toggleSubscript: () => ({ commands }) => {\r\n                return commands.toggleMark(this.name);\r\n            },\r\n            unsetSubscript: () => ({ commands }) => {\r\n                return commands.unsetMark(this.name);\r\n            },\r\n        };\r\n    },\r\n    addKeyboardShortcuts() {\r\n        return {\r\n            'Mod-,': () => this.editor.commands.toggleSubscript(),\r\n        };\r\n    },\r\n});\n\nexport { Subscript, Subscript as default };\n//# sourceMappingURL=index.js.map\n","import { Mark, mergeAttributes } from '@tiptap/core';\n\nconst Superscript = Mark.create({\r\n    name: 'superscript',\r\n    addOptions() {\r\n        return {\r\n            HTMLAttributes: {},\r\n        };\r\n    },\r\n    parseHTML() {\r\n        return [\r\n            {\r\n                tag: 'sup',\r\n            },\r\n            {\r\n                style: 'vertical-align',\r\n                getAttrs(value) {\r\n                    // Don’t match this rule if the vertical align isn’t super.\r\n                    if (value !== 'super') {\r\n                        return false;\r\n                    }\r\n                    // If it falls through we’ll match, and this mark will be applied.\r\n                    return null;\r\n                },\r\n            },\r\n        ];\r\n    },\r\n    renderHTML({ HTMLAttributes }) {\r\n        return ['sup', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];\r\n    },\r\n    addCommands() {\r\n        return {\r\n            setSuperscript: () => ({ commands }) => {\r\n                return commands.setMark(this.name);\r\n            },\r\n            toggleSuperscript: () => ({ commands }) => {\r\n                return commands.toggleMark(this.name);\r\n            },\r\n            unsetSuperscript: () => ({ commands }) => {\r\n                return commands.unsetMark(this.name);\r\n            },\r\n        };\r\n    },\r\n    addKeyboardShortcuts() {\r\n        return {\r\n            'Mod-.': () => this.editor.commands.toggleSuperscript(),\r\n        };\r\n    },\r\n});\n\nexport { Superscript, Superscript as default };\n//# sourceMappingURL=index.js.map\n","import { Node, mergeAttributes } from '@tiptap/core';\n\nconst TableCell = Node.create({\r\n    name: 'tableCell',\r\n    addOptions() {\r\n        return {\r\n            HTMLAttributes: {},\r\n        };\r\n    },\r\n    content: 'block+',\r\n    addAttributes() {\r\n        return {\r\n            colspan: {\r\n                default: 1,\r\n            },\r\n            rowspan: {\r\n                default: 1,\r\n            },\r\n            colwidth: {\r\n                default: null,\r\n                parseHTML: element => {\r\n                    const colwidth = element.getAttribute('colwidth');\r\n                    const value = colwidth\r\n                        ? [parseInt(colwidth, 10)]\r\n                        : null;\r\n                    return value;\r\n                },\r\n            },\r\n        };\r\n    },\r\n    tableRole: 'cell',\r\n    isolating: true,\r\n    parseHTML() {\r\n        return [\r\n            { tag: 'td' },\r\n        ];\r\n    },\r\n    renderHTML({ HTMLAttributes }) {\r\n        return ['td', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];\r\n    },\r\n});\n\nexport { TableCell, TableCell as default };\n//# sourceMappingURL=index.js.map\n","import { Node, mergeAttributes } from '@tiptap/core';\n\nconst TableHeader = Node.create({\r\n    name: 'tableHeader',\r\n    addOptions() {\r\n        return {\r\n            HTMLAttributes: {},\r\n        };\r\n    },\r\n    content: 'block+',\r\n    addAttributes() {\r\n        return {\r\n            colspan: {\r\n                default: 1,\r\n            },\r\n            rowspan: {\r\n                default: 1,\r\n            },\r\n            colwidth: {\r\n                default: null,\r\n                parseHTML: element => {\r\n                    const colwidth = element.getAttribute('colwidth');\r\n                    const value = colwidth\r\n                        ? [parseInt(colwidth, 10)]\r\n                        : null;\r\n                    return value;\r\n                },\r\n            },\r\n        };\r\n    },\r\n    tableRole: 'header_cell',\r\n    isolating: true,\r\n    parseHTML() {\r\n        return [\r\n            { tag: 'th' },\r\n        ];\r\n    },\r\n    renderHTML({ HTMLAttributes }) {\r\n        return ['th', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];\r\n    },\r\n});\n\nexport { TableHeader, TableHeader as default };\n//# sourceMappingURL=index.js.map\n","import { Node, mergeAttributes } from '@tiptap/core';\n\nconst TableRow = Node.create({\r\n    name: 'tableRow',\r\n    addOptions() {\r\n        return {\r\n            HTMLAttributes: {},\r\n        };\r\n    },\r\n    content: '(tableCell | tableHeader)*',\r\n    tableRole: 'row',\r\n    parseHTML() {\r\n        return [\r\n            { tag: 'tr' },\r\n        ];\r\n    },\r\n    renderHTML({ HTMLAttributes }) {\r\n        return ['tr', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];\r\n    },\r\n});\n\nexport { TableRow, TableRow as default };\n//# sourceMappingURL=index.js.map\n","import { Node, mergeAttributes, wrappingInputRule } from '@tiptap/core';\n\nconst inputRegex = /^\\s*(\\[([( |x])?\\])\\s$/;\r\nconst TaskItem = Node.create({\r\n    name: 'taskItem',\r\n    addOptions() {\r\n        return {\r\n            nested: false,\r\n            HTMLAttributes: {},\r\n        };\r\n    },\r\n    content() {\r\n        return this.options.nested ? 'paragraph block*' : 'paragraph+';\r\n    },\r\n    defining: true,\r\n    addAttributes() {\r\n        return {\r\n            checked: {\r\n                default: false,\r\n                keepOnSplit: false,\r\n                parseHTML: element => element.getAttribute('data-checked') === 'true',\r\n                renderHTML: attributes => ({\r\n                    'data-checked': attributes.checked,\r\n                }),\r\n            },\r\n        };\r\n    },\r\n    parseHTML() {\r\n        return [\r\n            {\r\n                tag: `li[data-type=\"${this.name}\"]`,\r\n                priority: 51,\r\n            },\r\n        ];\r\n    },\r\n    renderHTML({ node, HTMLAttributes }) {\r\n        return [\r\n            'li',\r\n            mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, {\r\n                'data-type': this.name,\r\n            }),\r\n            [\r\n                'label',\r\n                [\r\n                    'input',\r\n                    {\r\n                        type: 'checkbox',\r\n                        checked: node.attrs.checked ? 'checked' : null,\r\n                    },\r\n                ],\r\n                ['span'],\r\n            ],\r\n            ['div', 0],\r\n        ];\r\n    },\r\n    addKeyboardShortcuts() {\r\n        const shortcuts = {\r\n            Enter: () => this.editor.commands.splitListItem(this.name),\r\n            'Shift-Tab': () => this.editor.commands.liftListItem(this.name),\r\n        };\r\n        if (!this.options.nested) {\r\n            return shortcuts;\r\n        }\r\n        return {\r\n            ...shortcuts,\r\n            Tab: () => this.editor.commands.sinkListItem(this.name),\r\n        };\r\n    },\r\n    addNodeView() {\r\n        return ({ node, HTMLAttributes, getPos, editor, }) => {\r\n            const listItem = document.createElement('li');\r\n            const checkboxWrapper = document.createElement('label');\r\n            const checkboxStyler = document.createElement('span');\r\n            const checkbox = document.createElement('input');\r\n            const content = document.createElement('div');\r\n            checkboxWrapper.contentEditable = 'false';\r\n            checkbox.type = 'checkbox';\r\n            checkbox.addEventListener('change', event => {\r\n                // if the editor isn’t editable and we don't have a handler for\r\n                // readonly checks we have to undo the latest change\r\n                if (!editor.isEditable && !this.options.onReadOnlyChecked) {\r\n                    checkbox.checked = !checkbox.checked;\r\n                    return;\r\n                }\r\n                const { checked } = event.target;\r\n                if (editor.isEditable && typeof getPos === 'function') {\r\n                    editor\r\n                        .chain()\r\n                        .focus(undefined, { scrollIntoView: false })\r\n                        .command(({ tr }) => {\r\n                        const position = getPos();\r\n                        const currentNode = tr.doc.nodeAt(position);\r\n                        tr.setNodeMarkup(position, undefined, {\r\n                            ...currentNode === null || currentNode === void 0 ? void 0 : currentNode.attrs,\r\n                            checked,\r\n                        });\r\n                        return true;\r\n                    })\r\n                        .run();\r\n                }\r\n                if (!editor.isEditable && this.options.onReadOnlyChecked) {\r\n                    // Reset state if onReadOnlyChecked returns false\r\n                    if (!this.options.onReadOnlyChecked(node, checked)) {\r\n                        checkbox.checked = !checkbox.checked;\r\n                    }\r\n                }\r\n            });\r\n            Object.entries(this.options.HTMLAttributes).forEach(([key, value]) => {\r\n                listItem.setAttribute(key, value);\r\n            });\r\n            listItem.dataset.checked = node.attrs.checked;\r\n            if (node.attrs.checked) {\r\n                checkbox.setAttribute('checked', 'checked');\r\n            }\r\n            checkboxWrapper.append(checkbox, checkboxStyler);\r\n            listItem.append(checkboxWrapper, content);\r\n            Object.entries(HTMLAttributes).forEach(([key, value]) => {\r\n                listItem.setAttribute(key, value);\r\n            });\r\n            return {\r\n                dom: listItem,\r\n                contentDOM: content,\r\n                update: updatedNode => {\r\n                    if (updatedNode.type !== this.type) {\r\n                        return false;\r\n                    }\r\n                    listItem.dataset.checked = updatedNode.attrs.checked;\r\n                    if (updatedNode.attrs.checked) {\r\n                        checkbox.setAttribute('checked', 'checked');\r\n                    }\r\n                    else {\r\n                        checkbox.removeAttribute('checked');\r\n                    }\r\n                    return true;\r\n                },\r\n            };\r\n        };\r\n    },\r\n    addInputRules() {\r\n        return [\r\n            wrappingInputRule({\r\n                find: inputRegex,\r\n                type: this.type,\r\n                getAttributes: match => ({\r\n                    checked: match[match.length - 1] === 'x',\r\n                }),\r\n            }),\r\n        ];\r\n    },\r\n});\n\nexport { TaskItem, TaskItem as default, inputRegex };\n//# sourceMappingURL=index.js.map\n","import { Node, mergeAttributes } from '@tiptap/core';\n\nconst TaskList = Node.create({\r\n    name: 'taskList',\r\n    addOptions() {\r\n        return {\r\n            itemTypeName: 'taskItem',\r\n            HTMLAttributes: {},\r\n        };\r\n    },\r\n    group: 'block list',\r\n    content() {\r\n        return `${this.options.itemTypeName}+`;\r\n    },\r\n    parseHTML() {\r\n        return [\r\n            {\r\n                tag: `ul[data-type=\"${this.name}\"]`,\r\n                priority: 51,\r\n            },\r\n        ];\r\n    },\r\n    renderHTML({ HTMLAttributes }) {\r\n        return ['ul', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, { 'data-type': this.name }), 0];\r\n    },\r\n    addCommands() {\r\n        return {\r\n            toggleTaskList: () => ({ commands }) => {\r\n                return commands.toggleList(this.name, this.options.itemTypeName);\r\n            },\r\n        };\r\n    },\r\n    addKeyboardShortcuts() {\r\n        return {\r\n            'Mod-Shift-9': () => this.editor.commands.toggleTaskList(),\r\n        };\r\n    },\r\n});\n\nexport { TaskList, TaskList as default };\n//# sourceMappingURL=index.js.map\n","import { Extension } from '@tiptap/core';\n\nconst TextAlign = Extension.create({\r\n    name: 'textAlign',\r\n    addOptions() {\r\n        return {\r\n            types: [],\r\n            alignments: ['left', 'center', 'right', 'justify'],\r\n            defaultAlignment: 'left',\r\n        };\r\n    },\r\n    addGlobalAttributes() {\r\n        return [\r\n            {\r\n                types: this.options.types,\r\n                attributes: {\r\n                    textAlign: {\r\n                        default: this.options.defaultAlignment,\r\n                        parseHTML: element => element.style.textAlign || this.options.defaultAlignment,\r\n                        renderHTML: attributes => {\r\n                            if (attributes.textAlign === this.options.defaultAlignment) {\r\n                                return {};\r\n                            }\r\n                            return { style: `text-align: ${attributes.textAlign}` };\r\n                        },\r\n                    },\r\n                },\r\n            },\r\n        ];\r\n    },\r\n    addCommands() {\r\n        return {\r\n            setTextAlign: (alignment) => ({ commands }) => {\r\n                if (!this.options.alignments.includes(alignment)) {\r\n                    return false;\r\n                }\r\n                return this.options.types.every(type => commands.updateAttributes(type, { textAlign: alignment }));\r\n            },\r\n            unsetTextAlign: () => ({ commands }) => {\r\n                return this.options.types.every(type => commands.resetAttributes(type, 'textAlign'));\r\n            },\r\n        };\r\n    },\r\n    addKeyboardShortcuts() {\r\n        return {\r\n            'Mod-Shift-l': () => this.editor.commands.setTextAlign('left'),\r\n            'Mod-Shift-e': () => this.editor.commands.setTextAlign('center'),\r\n            'Mod-Shift-r': () => this.editor.commands.setTextAlign('right'),\r\n            'Mod-Shift-j': () => this.editor.commands.setTextAlign('justify'),\r\n        };\r\n    },\r\n});\n\nexport { TextAlign, TextAlign as default };\n//# sourceMappingURL=index.js.map\n","import { Mark, mergeAttributes, getMarkAttributes } from '@tiptap/core';\n\nconst TextStyle = Mark.create({\r\n    name: 'textStyle',\r\n    addOptions() {\r\n        return {\r\n            HTMLAttributes: {},\r\n        };\r\n    },\r\n    parseHTML() {\r\n        return [\r\n            {\r\n                tag: 'span',\r\n                getAttrs: element => {\r\n                    const hasStyles = element.hasAttribute('style');\r\n                    if (!hasStyles) {\r\n                        return false;\r\n                    }\r\n                    return {};\r\n                },\r\n            },\r\n        ];\r\n    },\r\n    renderHTML({ HTMLAttributes }) {\r\n        return ['span', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];\r\n    },\r\n    addCommands() {\r\n        return {\r\n            removeEmptyTextStyle: () => ({ state, commands }) => {\r\n                const attributes = getMarkAttributes(state, this.type);\r\n                const hasStyles = Object.entries(attributes).some(([, value]) => !!value);\r\n                if (hasStyles) {\r\n                    return true;\r\n                }\r\n                return commands.unsetMark(this.name);\r\n            },\r\n        };\r\n    },\r\n});\n\nexport { TextStyle, TextStyle as default };\n//# sourceMappingURL=index.js.map\n","import { Node } from '@tiptap/core';\n\nconst Text = Node.create({\r\n    name: 'text',\r\n    group: 'inline',\r\n});\n\nexport { Text, Text as default };\n//# sourceMappingURL=index.js.map\n","import { Mark, mergeAttributes } from '@tiptap/core';\n\nconst Underline = Mark.create({\r\n    name: 'underline',\r\n    addOptions() {\r\n        return {\r\n            HTMLAttributes: {},\r\n        };\r\n    },\r\n    parseHTML() {\r\n        return [\r\n            {\r\n                tag: 'u',\r\n            },\r\n            {\r\n                style: 'text-decoration',\r\n                consuming: false,\r\n                getAttrs: style => (style.includes('underline') ? {} : false),\r\n            },\r\n        ];\r\n    },\r\n    renderHTML({ HTMLAttributes }) {\r\n        return ['u', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];\r\n    },\r\n    addCommands() {\r\n        return {\r\n            setUnderline: () => ({ commands }) => {\r\n                return commands.setMark(this.name);\r\n            },\r\n            toggleUnderline: () => ({ commands }) => {\r\n                return commands.toggleMark(this.name);\r\n            },\r\n            unsetUnderline: () => ({ commands }) => {\r\n                return commands.unsetMark(this.name);\r\n            },\r\n        };\r\n    },\r\n    addKeyboardShortcuts() {\r\n        return {\r\n            'Mod-u': () => this.editor.commands.toggleUnderline(),\r\n            'Mod-U': () => this.editor.commands.toggleUnderline(),\r\n        };\r\n    },\r\n});\n\nexport { Underline, Underline as default };\n//# sourceMappingURL=index.js.map\n"],"names":["debounce","isObject","module","exports","func","wait","options","leading","trailing","TypeError","FontSize","create","name","addOptions","types","addGlobalAttributes","this","attributes","fontSize","default","parseHTML","element","style","replace","renderHTML","addCommands","setFontSize","chain","setMark","run","unsetFontSize","removeEmptyTextStyle","Heading","levels","HTMLAttributes","content","group","defining","addAttributes","level","rendered","map","tag","attrs","node","includes","setHeading","commands","setNode","toggleHeading","toggleNode","addKeyboardShortcuts","reduce","items","editor","addInputRules","find","RegExp","type","getAttributes","useStyles","HeadingWithAnchorComponent","uniqId","theme","_params","classes","root","link","opacity","container","display","position","left","color","palette","text","secondary","transition","transitions","textDecoration","outline","breakpoints","down","linkIcon","transform","headingWithAnchorComponentClasses","extension","cx","HeadingTag","textSerializers","useMemo","schema","headingId","toLowerCase","normalize","as","id","className","textAlign","children","href","contentEditable","Link","extend","_a","parent","call","scrollToAnchorOnMount","onCreate","setTimeout","isDestroyed","storage","elementId","window","location","hash","slice","elementForHash","document","getElementById","contains","scrollIntoView","behavior","block","inline","scrollToCurrentHeadingAnchor","addNodeView","LinkMenuState","LinkBubbleMenuHandler","addStorage","state","HIDDEN","bubbleMenuOptions","undefined","openLinkBubbleMenu","dispatch","currentMenuState","newMenuState","isActive","VIEW_LINK_DETAILS","extendMarkRange","focus","EDIT_LINK","editLinkInBubbleMenu","closeLinkBubbleMenu","onSelectionUpdate","addProseMirrorPlugins","key","props","handleClick","view","pos","event","target","closest","inputRegex","Image","allowBase64","draggable","src","alt","title","setImage","insertContent","match","ResizableImageResizer","bottom","right","width","height","background","primary","main","cursor","onResize","mouseDown","setMouseDown","useState","useEffect","handleMouseMove","addEventListener","removeEventListener","handleMouseUp","handleMouseDown","useCallback","_event","onMouseDown","ResizableImageComponent","imageContainer","image","imageSelected","resizer","selected","updateAttributes","imageRef","useRef","handleResize","current","originalBoundingRect","getBoundingClientRect","resizedWidth","clientX","x","resizedHeight","clientY","y","resultantWidth","Math","max","round","ref","maxWidth","aspectRatio","onLoad","newAttributes","currentTarget","naturalWidth","String","naturalHeight","isAllowedImgSrc","getAttribute","getAttrs","Element","parentInputRules","rule","handler","readFromCache","addToCache","WeakMap","cache","get","value","set","cacheSize","cachePos","i","length","TableMap","constructor","problems","findCell","curPos","top","j","RangeError","colCount","nextCell","axis","dir","rectBetween","a","b","leftA","rightA","topA","bottomA","leftB","rightB","topB","bottomB","min","cellsInRect","rect","result","seen","row","col","index","push","positionAt","table","rowStart","rowEnd","child","nodeSize","rowEndIndex","spec","tableRole","hasRowSpan","childCount","rowNode","rowWidth","prevRow","cell","rowspan","colspan","findWidth","mapPos","colWidths","e","cellNode","colwidth","h","n","start","w","colW","widthIndex","prev","expectedPos","missing","tableMap","badWidths","nodeAt","updated","colWidth","freshColWidth","unshift","findBadColWidths","computeMap","tableNodeTypes","cached","nodes","role","tableEditingKey","cellAround","$pos","d","depth","resolve","before","isInTable","$head","selection","selectionCell","sel","$anchorCell","$headCell","$anchor","$cell","after","nodeAfter","firstChild","doc","nodeBefore","lastChild","cellNear","head","pointsAtCell","inSameTable","$cellA","$cellB","end","tableStart","moved","removeColSpan","splice","some","addColSpan","CellSelection","_CellSelection","cells","filter","p","ranges","from","size","super","$from","$to","mapping","tableChanged","isRowSelection","rowSelection","isColSelection","colSelection","between","rows","rowContent","cellRect","extraLeft","extraRight","createAndFill","JSON","stringify","copy","fragment","tr","empty","mapFrom","steps","findFrom","to","setSelection","replaceWith","forEachCell","f","anchorTop","headTop","anchorBottom","headBottom","anchorRect","headRect","anchorLeft","headLeft","anchorRight","headRight","eq","other","toJSON","anchor","fromJSON","json","anchorCell","headCell","getBookmark","CellBookmark","prototype","visible","jsonID","_CellBookmark","near","drawCellSelection","class","fixTablesKey","changedDescendants","old","cur","offset","oldSize","curSize","outer","scan","sameMarkup","nodesBetween","fixTables","oldState","check","tablePos","mustAdd","prob","setNodeMarkup","first","last","add","side","insert","setMeta","fixTable","descendants","pastedCells","openStart","openEnd","fitSlice","widths","r","append","ensureRectangular","nodeType","isolateHorizontal","found","cellTop","cellLeft","isolateVertical","updatePos","insertCells","Error","recomp","maps","emptyHead","header_cell","start2","header","emptyRow","growTable","handleKeyDown","ArrowLeft","arrow","ArrowRight","ArrowUp","ArrowDown","shiftArrow","Backspace","deleteCellSelection","Delete","maybeSetSelection","atEndOfCell","$next","newSel","cellSel","baseContent","docChanged","handleTripleClick","handlePaste","_","newWidth","newHeight","added","newRows","frag","createChecked","source","clipCells","startEvent","ctrlKey","metaKey","startDOMCell","domInCell","shiftKey","setCellSelection","preventDefault","cellUnderMouse","$anchor2","starting","getState","stop","move","indexAfter","cellPos","dirStr","endOfTextblock","dom","parentNode","nodeName","mousePos","posAtCoords","TableView","cellMinWidth","createElement","appendChild","colgroup","updateColumnsOnResize","contentDOM","update","ignoreMutation","record","overrideCol","overrideValue","totalWidth","fixedWidth","nextDOM","hasWidth","cssWidth","nextSibling","removeChild","minWidth","columnResizingPluginKey","columnResizing","handleWidth","View","lastColumnResizable","plugin","init","_b","nodeViews","tableName","ResizeState","apply","pluginState","activeHandle","handleDOMEvents","mousemove","dragging","classList","domCellAround","edgeCell","updateHandle","mouseleave","handleMouseLeave","mousedown","win","ownerDocument","defaultView","domAtPos","domWidth","childNodes","offsetWidth","parts","currentColWidth","finish","event2","pluginState2","mapIndex","zeroes","updateColumnWidth","draggedWidth","setDragging","which","dragged","displayColumnWidth","startX","startWidth","handleMouseDown2","decorations","widget","handleDecorations","_ResizeState","action","getMeta","setHandle","handle","indexOf","Array","fill","selectedRect","addColumn","refColumn","headerCell","columnIsHeader","removeColumn","mapStart","delete","addRow","rowPos","refRow","rowIsHeader","removeRow","nextRow","Set","has","newPos","isEmpty","c","isTextblock","mergeCells","indexTop","indexLeft","indexBottom","indexRight","cellsOverlapRectangle","mergedPos","mergedCell","mapped","splitCell","nodeTypes","getCellType","cellWrapping","baseAttrs","lastCell","isHeaderEnabledByType","cellPositions","toggleHeader","useDeprecatedLogic","deprecated_toggleHeader","isHeaderRowEnabled","isHeaderColumnEnabled","selectionStartsAt","cellsRect","newType","forEach","relativeCellPos","toggleHeaderCell","goToNextCell","direction","findNextCell","tableEditing","allowTableNodeSelection","deleted","mapResult","createSelectionBetween","appendTransaction","afterFrom","beforeTo","test","isCellBoundarySelection","fromCellBoundaryNode","toCellBoundaryNode","parentOffset","isTextSelectionAcrossCells","normalizeSelection","updateColumns","mutation","createCell","cellType","cellContent","createTable","rowsCount","colsCount","withHeaderRow","roles","Object","keys","getTableNodeTypes","headerCells","deleteTableWhenAllCellsSelected","cellCount","deleteTable","resizable","isolating","insertTable","cols","replaceSelectionWith","addColumnBefore","addColumnAfter","deleteColumn","addRowBefore","addRowAfter","deleteRow","toggleHeaderColumn","toggleHeaderRow","mergeOrSplit","setCellAttribute","setCellAttr","goToPreviousCell","Tab","can","isEditable","extendNodeSchema","context","Blockquote","setBlockquote","wrapIn","toggleBlockquote","toggleWrap","unsetBlockquote","lift","starInputRegex","starPasteRegex","underscoreInputRegex","underscorePasteRegex","Bold","fontWeight","setBold","toggleBold","toggleMark","unsetBold","unsetMark","addPasteRules","ListItem","Enter","splitListItem","sinkListItem","liftListItem","TextStyle","hasAttribute","entries","BulletList","itemTypeName","keepMarks","keepAttributes","toggleBulletList","toggleList","inputRule","backtickInputRegex","tildeInputRegex","CodeBlock","languageClassPrefix","exitOnTripleEnter","exitOnArrowDown","marks","code","language","firstElementChild","startsWith","preserveWhitespace","setCodeBlock","toggleCodeBlock","isAtStart","textContent","clearNodes","isAtEnd","endsWithDoubleNewline","endsWith","command","exitCode","clipboardData","getData","vscode","vscodeData","parse","mode","insertText","pasteRegex","Code","excludes","exitable","setCode","toggleCode","unsetCode","Color","setColor","unsetColor","Document","topNode","dropCursor","editorView","DropCursorView","cursorPos","timeout","handlers","destroy","prevState","setCursor","updateOverlay","isBlock","inlineContent","nodeDOM","nodeRect","coords","coordsAtPos","parentLeft","parentTop","offsetParent","cssText","backgroundColor","toggle","body","getComputedStyle","pageXOffset","pageYOffset","scrollLeft","scrollTop","scheduleRemoval","clearTimeout","dragover","editable","inside","disableDropCursor","disabled","point","dragend","drop","dragleave","relatedTarget","Dropcursor","FontFamily","fontFamily","setFontFamily","unsetFontFamily","GapCursor","valid","GapBookmark","isAtom","closedBefore","closedAfter","override","allowGapCursor","deflt","contentMatchAt","defaultType","findGapCursorFrom","mustMove","search","next","$cur","isText","isSelectable","$start","$found","clickPos","beforeinput","inputType","findWrapping","drawGapCursor","Gapcursor","_view","HardBreak","selectable","renderText","setHardBreak","storedMarks","splittableMarks","extensionManager","filteredMarks","mark","ensureMarks","Highlight","multicolor","setHighlight","toggleHighlight","unsetHighlight","GOOD_LEAF_SIZE","RopeSequence","leafAppend","leafPrepend","appendInner","prepend","Append","sliceInner","getInner","forEachInner","forEachInvertedInner","elt","values","Leaf","__proto__","prototypeAccessors","configurable","flatten","concat","defineProperties","leftLen","inner","Branch","eventCount","popEvent","preserveItems","remap","remapping","remaining","addAfter","addBefore","item","step","Item","maybeStep","appendMap","reverse","addTransform","histOptions","newItems","oldItems","lastItem","merged","invert","docs","merge","pop","overflow","DEPTH_OVERFLOW","cutPoint","cutOffEvents","mirrorPos","mirrorOffset","addMaps","array","rebased","rebasedTransform","rebasedCount","rebasedItems","newUntil","iRebased","getMirror","newMaps","branch","emptyItemCount","compress","count","upto","events","getMap","newItem","HistoryState","done","undone","prevRanges","prevTime","prevComposition","rangesFor","_from","_to","mapRanges","cachedPreserveItems","cachedPreserveItemsPlugins","mustPreserveItems","plugins","historyPreserveItems","historyKey","closeHistoryKey","config","newGroupDelay","hist","history","historyTr","historyState","appended","redo","composition","newGroup","time","adjacent","isAdjacentTo","applyTransaction","undo","buildCommand","scroll","newHist","histTransaction","History","HorizontalRule","setHorizontalRule","posAfter","contentMatch","Italic","fontStyle","setItalic","toggleItalic","unsetItalic","encodedTlds","encodedUtlds","properties","numeric","ascii","alpha","asciinumeric","alphanumeric","domain","emoji","scheme","slashscheme","whitespace","registerGroup","groups","addToGroups","t","flags","k","State","token","jr","jd","accepts","go","input","nextState","regex","exactOnly","ta","inputs","tt","regexp","ts","len","templateState","allFlags","flagsForToken","WORD","UWORD","LOCALHOST","TLD","UTLD","SCHEME","SLASH_SCHEME","NUM","WS","NL$1","OPENBRACE","CLOSEBRACE","OPENBRACKET","CLOSEBRACKET","OPENPAREN","CLOSEPAREN","OPENANGLEBRACKET","CLOSEANGLEBRACKET","FULLWIDTHLEFTPAREN","FULLWIDTHRIGHTPAREN","LEFTCORNERBRACKET","RIGHTCORNERBRACKET","LEFTWHITECORNERBRACKET","RIGHTWHITECORNERBRACKET","FULLWIDTHLESSTHAN","FULLWIDTHGREATERTHAN","AMPERSAND","APOSTROPHE","ASTERISK","AT","BACKSLASH","BACKTICK","CARET","COLON","COMMA","DOLLAR","DOT","EQUALS","EXCLAMATION","HYPHEN","PERCENT","PIPE","PLUS","POUND","QUERY","QUOTE","SEMI","SLASH","TILDE","UNDERSCORE","EMOJI$1","SYM","tk","freeze","NL","EMOJI","ASCII_LETTER","LETTER","DIGIT","SPACE","EMOJI_VARIATION","EMOJI_JOINER","tlds","utlds","fastts","defaultt","char","decodeTlds","encoded","words","stack","popDigitCount","join","popCount","parseInt","substring","defaults","defaultProtocol","format","noop","formatHref","nl2br","tagName","rel","validate","truncate","Infinity","ignoreTags","render","Options","opts","defaultRender","o","ignoredTags","uppercaseIgnoredTags","toUpperCase","val","ir","toString","operator","isCallable","option","getObj","obj","MultiToken","tokens","v","createTokenClass","Token","isLink","toHref","toFormattedString","formatted","toFormattedHref","startIndex","s","endIndex","toObject","protocol","toFormattedObject","formattedHref","eventListeners","Email","Text","Nl","Url","hasProtocol","makeState","arg","initMultiToken","Multi","startIdx","endIdx","warn","console","warnAdvice","INIT","scanner","parser","tokenQueue","pluginQueue","customSchemes","initialized","registerCustomProtocol","optionalSlashSlash","Start","Num","Word","UWord","Ws","Emoji","EmojiJoiner","wordjr","uwordjr","tld","utld","sort","sch","init$2","_ref","qsAccepting","qsNonAccepting","localpartAccepting","Localpart","Domain","Scheme","SlashScheme","LocalpartAt","LocalpartDot","EmailDomain","EmailDomainDot","Email$1","EmailDomainHyphen","EmailColon","DomainHyphen","DomainDot","DomainDotTld","DomainDotTldColon","DomainDotTldColonPort","Url$1","UrlNonaccept","SchemeColon","SlashSchemeColon","SlashSchemeColonSlash","UriPrefix","bracketPairs","OPEN","CLOSE","UrlOpen","UrlOpenQ","UrlOpenSyms","init$1","tokenize","str","multis","textTokens","secondState","multiLength","latestAccepting","sinceAccepts","subtokens","iterable","second","charCodeAt","stringToArray","charCount","charCursor","tokenLength","charsSinceAccepts","run$1","filtered","priority","keepOnSplit","protocols","optionalSlashes","onDestroy","inclusive","autolink","openOnClick","linkOnPaste","setLink","toggleLink","extendEmptyMarkRange","unsetLink","data","transactions","newState","docChanges","transaction","preventAutolink","oldRange","newRange","oldMark","newFrom","newTo","newMarks","newMark","oldLinkText","textBetween","newLinkText","wasLink","removeMark","nodesInChangedRanges","textBlock","textBeforeWhitespace","wordsBeforeWhitespace","split","lastWordBeforeSpace","lastWordAndBlockOffset","lastIndexOf","addMark","_c","button","open","clickHandler","pasteHandler","SuggestionPluginKey","Suggestion","pluginKey","allowSpaces","allowedPrefixes","startOfLine","decorationTag","decorationClass","allow","renderer","async","_d","_e","_f","_g","active","range","started","stopped","handleStart","handleChange","query","handleExit","decorationNode","querySelector","decorationId","commandProps","clientRect","currentDecorationNode","onBeforeStart","onBeforeUpdate","onExit","onUpdate","onStart","composing","$position","escapedChar","suffix","prefix","textFrom","matchAll","matchPrefix","matchPrefixIsAllowed","findSuggestionMatch","floor","random","onKeyDown","MentionPluginKey","Mention","renderLabel","suggestion","label","insertContentAt","getSelection","collapseToEnd","matchType","atom","isMention","OrderedList","attributesWithoutStart","toggleOrderedList","joinPredicate","Paragraph","setParagraph","Placeholder","emptyEditorClass","emptyNodeClass","placeholder","showOnlyWhenEditable","showOnlyCurrent","includeChildren","emptyDocInstance","isEditorEmpty","findDiffStart","hasAnchor","isLeaf","decoration","Strike","consuming","setStrike","toggleStrike","unsetStrike","Subscript","setSubscript","toggleSubscript","unsetSubscript","Superscript","setSuperscript","toggleSuperscript","unsetSuperscript","TableCell","TableHeader","TableRow","TaskItem","nested","checked","shortcuts","getPos","listItem","checkboxWrapper","checkboxStyler","checkbox","onReadOnlyChecked","currentNode","setAttribute","dataset","updatedNode","removeAttribute","TaskList","toggleTaskList","TextAlign","alignments","defaultAlignment","setTextAlign","alignment","every","unsetTextAlign","resetAttributes","Underline","setUnderline","toggleUnderline","unsetUnderline"],"sourceRoot":""}