{"version":3,"file":"paypalcorpOrganizerUpdatePreview.32d73fe1b1dd3209e967.bundle.js","mappings":";8ZAWA,SAASA,EAASC,GAChB,MAA6C,oBAAtCC,OAAOC,UAAUC,SAASC,KAAKJ,EACxC,CAEA,SAASK,EAAcL,GACrB,IAAIM,EAAKC,EAET,OAAoB,IAAhBR,EAASC,UAIAQ,KADbF,EAAON,EAAES,eAKc,IAAnBV,EADJQ,EAAOD,EAAKJ,aAIiC,IAAzCK,EAAKG,eAAe,iBAM1B,CAEA,SAASC,EAAEA,GAAG,IAAI,IAAIC,EAAEC,UAAUC,OAAOC,EAAEC,MAAMJ,EAAE,EAAEA,EAAE,EAAE,GAAGK,EAAE,EAAEA,EAAEL,EAAEK,IAAIF,EAAEE,EAAE,GAAGJ,UAAUI,GAAI,IAAIC,EAAEC,EAAER,GAAGX,EAAEkB,EAAE,mBAAmBA,EAAEA,EAAEE,MAAM,KAAKL,GAAGG,EAAE,qBAAqBP,EAAE,MAAMU,MAAM,WAAWrB,EAAG,CAAC,SAASY,EAAED,GAAG,QAASA,KAAKA,EAAEW,EAAE,CAAC,SAASP,EAAEJ,GAAG,IAAIC,EAAE,QAASD,IAAI,SAASA,GAAG,IAAIA,GAAG,iBAAiBA,EAAE,OAAO,EAAG,IAAIC,EAAEX,OAAOsB,eAAeZ,GAAG,GAAG,OAAOC,EAAE,OAAO,EAAG,IAAIG,EAAEd,OAAOS,eAAeN,KAAKQ,EAAE,gBAAgBA,EAAEH,YAAY,OAAOM,IAAId,QAAQ,mBAAmBc,GAAGS,SAASrB,SAASC,KAAKW,KAAKU,CAAC,CAA5O,CAA8Od,IAAIK,MAAMU,QAAQf,MAAMA,EAAEgB,OAAO,QAAQf,EAAED,EAAEF,mBAAc,IAASG,OAAE,EAAOA,EAAEe,KAAKC,EAAEjB,IAAIkB,EAAElB,GAAG,CAAC,SAASO,EAAEP,EAAEC,EAAEG,QAAG,IAASA,IAAIA,GAAE,GAAI,IAAIf,EAAEW,IAAII,EAAEd,OAAO6B,KAAKC,GAAIpB,GAAGqB,SAAQ,SAAUf,GAAGF,GAAG,iBAAiBE,GAAGL,EAAEK,EAAEN,EAAEM,GAAGN,EAAI,IAAGA,EAAEqB,SAAQ,SAAUjB,EAAEE,GAAG,OAAOL,EAAEK,EAAEF,EAAEJ,EAAG,GAAG,CAAC,SAASX,EAAEW,GAAG,IAAIC,EAAED,EAAEW,GAAG,OAAOV,EAAEA,EAAEM,EAAE,EAAEN,EAAEM,EAAE,EAAEN,EAAEM,EAAEF,MAAMU,QAAQf,GAAG,EAAEiB,EAAEjB,GAAG,EAAEkB,EAAElB,GAAG,EAAE,CAAC,CAAC,SAASsB,EAAEtB,EAAEC,GAAG,OAAO,IAAIZ,EAAEW,GAAGA,EAAEuB,IAAItB,GAAGX,OAAOC,UAAUQ,eAAeN,KAAKO,EAAEC,EAAE,CAA+C,SAASuB,EAAExB,EAAEC,EAAEG,GAAG,IAAIE,EAAEjB,EAAEW,GAAG,IAAIM,EAAEN,EAAEyB,IAAIxB,EAAEG,GAAG,IAAIE,EAAEN,EAAE0B,IAAItB,GAAGJ,EAAEC,GAAGG,CAAE,CAAyD,SAASa,EAAEjB,GAAG,OAAO2B,GAAG3B,aAAa4B,GAAG,CAAC,SAASV,EAAElB,GAAG,OAAO6B,GAAG7B,aAAa8B,GAAG,CAAC,SAASC,EAAE/B,GAAG,OAAOA,EAAEX,GAAGW,EAAEI,CAAC,CAAC,SAAS4B,EAAEhC,GAAG,GAAGK,MAAMU,QAAQf,GAAG,OAAOK,MAAMd,UAAU0C,MAAMxC,KAAKO,GAAG,IAAIC,EAAEiC,GAAGlC,UAAUC,EAAEU,GAAG,IAAI,IAAIP,EAAEgB,EAAGnB,GAAGK,EAAE,EAAEA,EAAEF,EAAED,OAAOG,IAAI,CAAC,IAAIC,EAAEH,EAAEE,GAAGjB,EAAEY,EAAEM,IAAG,IAAKlB,EAAE8C,WAAW9C,EAAE8C,UAAS,EAAG9C,EAAE+C,cAAa,IAAK/C,EAAEgD,KAAKhD,EAAEoC,OAAOxB,EAAEM,GAAG,CAAC6B,cAAa,EAAGD,UAAS,EAAGG,WAAWjD,EAAEiD,WAAWC,MAAMvC,EAAEO,IAAK,CAAC,OAAOjB,OAAOkD,OAAOlD,OAAOsB,eAAeZ,GAAGC,EAAE,CAAC,SAASwC,EAAEzC,EAAEM,GAAG,YAAO,IAASA,IAAIA,GAAE,GAAIoC,EAAE1C,IAAIC,EAAED,KAAKI,EAAEJ,KAAKX,EAAEW,GAAG,IAAIA,EAAEyB,IAAIzB,EAAE0B,IAAI1B,EAAE2C,MAAM3C,EAAE4C,OAAOC,GAAGvD,OAAOwD,OAAO9C,GAAGM,GAAGC,EAAEP,GAAE,SAAUA,EAAEC,GAAG,OAAOwC,EAAExC,GAAE,EAAI,IAAE,IAAKD,CAAC,CAAC,SAAS6C,IAAI7C,EAAE,EAAG,CAAC,SAAS0C,EAAE1C,GAAG,OAAO,MAAMA,GAAG,iBAAiBA,GAAGV,OAAOyD,SAAS/C,EAAE,CAAC,SAASgD,EAAE/C,GAAG,IAAIG,EAAE6C,GAAGhD,GAAG,OAAOG,GAAGJ,EAAE,GAAGC,GAAGG,CAAC,CAAC,SAAS8C,IAAI,OAAOC,GAAGnD,EAAE,GAAGmD,CAAC,CAAC,SAASC,EAAEpD,EAAEC,GAAGA,IAAI+C,EAAE,WAAWhD,EAAEsB,EAAE,GAAGtB,EAAEiB,EAAE,GAAGjB,EAAEkB,EAAEjB,EAAG,CAAC,SAASoD,EAAErD,GAAGsD,EAAEtD,GAAGA,EAAE+B,EAAEV,QAAQkC,GAAGvD,EAAE+B,EAAE,IAAK,CAAC,SAASuB,EAAEtD,GAAGA,IAAImD,IAAIA,EAAEnD,EAAEgC,EAAG,CAAC,SAASwB,EAAExD,GAAG,OAAOmD,EAAE,CAACpB,EAAE,GAAGC,EAAEmB,EAAEN,EAAE7C,EAAEyD,GAAE,EAAGP,EAAE,EAAE,CAAC,SAASK,EAAEvD,GAAG,IAAIC,EAAED,EAAEW,GAAG,IAAIV,EAAEM,GAAG,IAAIN,EAAEM,EAAEN,EAAEmD,IAAInD,EAAEoD,GAAE,CAAG,CAAC,SAASK,EAAEzD,EAAEK,GAAGA,EAAE4C,EAAE5C,EAAEyB,EAAE5B,OAAO,IAAII,EAAED,EAAEyB,EAAE,GAAG1C,OAAE,IAASY,GAAGA,IAAIM,EAAE,OAAOD,EAAEuC,EAAES,GAAGN,EAAE,OAAOO,EAAEjD,EAAEL,EAAEZ,GAAGA,GAAGkB,EAAEI,GAAG+C,IAAIL,EAAE/C,GAAGN,EAAE,IAAII,EAAEH,KAAKA,EAAE0D,EAAErD,EAAEL,GAAGK,EAAE0B,GAAG4B,EAAEtD,EAAEL,IAAIK,EAAEgB,GAAG0B,EAAE,WAAWW,EAAEpD,EAAEI,GAAGP,EAAEH,EAAEK,EAAEgB,EAAEhB,EAAEW,IAAIhB,EAAE0D,EAAErD,EAAEC,EAAE,IAAI8C,EAAE/C,GAAGA,EAAEgB,GAAGhB,EAAEY,EAAEZ,EAAEgB,EAAEhB,EAAEW,GAAGhB,IAAI4D,EAAE5D,OAAE,CAAM,CAAC,SAAS0D,EAAE3D,EAAEC,EAAEG,GAAG,GAAGsC,EAAEzC,GAAG,OAAOA,EAAE,IAAIK,EAAEL,EAAEU,GAAG,IAAIL,EAAE,OAAOC,EAAEN,GAAE,SAAUM,EAAElB,GAAG,OAAOyE,EAAE9D,EAAEM,EAAEL,EAAEM,EAAElB,EAAEe,EAAG,IAAE,GAAIH,EAAE,GAAGK,EAAEwD,IAAI9D,EAAE,OAAOC,EAAE,IAAIK,EAAEoD,EAAE,OAAOE,EAAE5D,EAAEM,EAAEF,GAAE,GAAIE,EAAEF,EAAE,IAAIE,EAAEyD,EAAE,CAACzD,EAAEyD,GAAE,EAAGzD,EAAEwD,EAAEZ,IAAI,IAAI7D,EAAE,IAAIiB,EAAEC,GAAG,IAAID,EAAEC,EAAED,EAAEjB,EAAE2C,EAAE1B,EAAE0D,GAAG1D,EAAEjB,EAAEiC,EAAEjC,EAAE4E,GAAE,EAAG,IAAI3D,EAAEC,IAAIe,EAAE,IAAIQ,IAAIzC,GAAGA,EAAEsD,QAAQsB,GAAE,GAAI1D,EAAEe,GAAE,SAAUrB,EAAEM,GAAG,OAAOuD,EAAE9D,EAAEM,EAAEjB,EAAEY,EAAEM,EAAEH,EAAE6D,EAAG,IAAGL,EAAE5D,EAAEX,GAAE,GAAIe,GAAGJ,EAAEsB,GAAG0B,EAAE,WAAWkB,EAAE5D,EAAEF,EAAEJ,EAAEsB,EAAEtB,EAAEiB,EAAG,CAAC,OAAOX,EAAEjB,CAAC,CAAC,SAASyE,EAAExD,EAAEC,EAAElB,EAAE4E,EAAEE,EAAElD,EAAEC,GAAG,GAAGiD,IAAI9E,GAAGW,EAAE,GAAGC,EAAEkE,GAAG,CAAC,IAAIpC,EAAE4B,EAAErD,EAAE6D,EAAElD,GAAGV,GAAG,IAAIA,EAAEA,IAAIe,EAAEf,EAAE6D,EAAEH,GAAGhD,EAAEoD,OAAOJ,QAAG,GAAQ,GAAGzC,EAAEnC,EAAE4E,EAAElC,IAAI9B,EAAE8B,GAAG,OAAOzB,EAAEmD,GAAE,CAAG,MAAMvC,GAAG7B,EAAEqC,IAAIyC,GAAG,GAAG/D,EAAE+D,KAAKzB,EAAEyB,GAAG,CAAC,IAAI7D,EAAEuC,EAAEyB,GAAGhE,EAAE4C,EAAE,EAAE,OAAOS,EAAErD,EAAE6D,GAAG5D,GAAGA,EAAEuD,EAAE9B,GAAG4B,EAAEtD,EAAE6D,EAAG,CAAC,CAAC,SAASP,EAAE5D,EAAEC,EAAEG,QAAG,IAASA,IAAIA,GAAE,IAAKJ,EAAEgC,GAAGhC,EAAE6C,EAAEyB,GAAGtE,EAAEyD,GAAGhB,EAAExC,EAAEG,EAAG,CAAC,SAASmE,EAAEvE,EAAEC,GAAG,IAAIG,EAAEJ,EAAEW,GAAG,OAAQP,EAAE2B,EAAE3B,GAAGJ,GAAGC,EAAE,CAAC,SAAS8D,EAAE/D,EAAEC,GAAG,GAAGA,KAAKD,EAAE,IAAI,IAAII,EAAEd,OAAOsB,eAAeZ,GAAGI,GAAG,CAAC,IAAIE,EAAEhB,OAAOkF,yBAAyBpE,EAAEH,GAAG,GAAGK,EAAE,OAAOA,EAAEF,EAAEd,OAAOsB,eAAeR,EAAG,CAAC,CAAC,SAAS4D,EAAEhE,GAAGA,EAAE0D,IAAI1D,EAAE0D,GAAE,EAAG1D,EAAEgC,GAAGgC,EAAEhE,EAAEgC,GAAI,CAAC,SAASyC,EAAEzE,GAAGA,EAAEX,IAAIW,EAAEX,EAAE2C,EAAEhC,EAAEI,GAAI,CAAC,SAAS8D,EAAElE,EAAEC,EAAEG,GAAG,IAAIE,EAAEW,EAAEhB,GAAG+C,EAAE,UAAU0B,EAAEzE,EAAEG,GAAGc,EAAEjB,GAAG+C,EAAE,UAAU2B,EAAE1E,EAAEG,GAAGJ,EAAEsD,EAAE,SAAStD,EAAEC,GAAG,IAAIG,EAAEC,MAAMU,QAAQf,GAAGM,EAAE,CAACC,EAAEH,EAAE,EAAE,EAAE0D,EAAE7D,EAAEA,EAAE6D,EAAEZ,IAAIQ,GAAE,EAAGK,GAAE,EAAGK,EAAE,CAAC,EAAEpC,EAAE/B,EAAEG,EAAEJ,EAAEgE,EAAE,KAAK3E,EAAE,KAAK+D,EAAE,KAAKwB,GAAE,GAAIrE,EAAED,EAAEjB,EAAEwF,GAAGzE,IAAIG,EAAE,CAACD,GAAGjB,EAAEyF,IAAI,IAAIxD,EAAEyD,MAAMC,UAAUzE,EAAElB,GAAG4E,EAAE3C,EAAE2D,OAAOzD,EAAEF,EAAE4D,MAAM,OAAO5E,EAAE0D,EAAExC,EAAElB,EAAE8C,EAAEa,EAAEzC,CAAC,CAA3M,CAA6MvB,EAAEG,GAAG4C,EAAE,OAAOmC,EAAElF,EAAEG,GAAG,OAAQA,EAAEA,EAAE0D,EAAEZ,KAAKnB,EAAEqD,KAAK9E,GAAGA,CAAC,CAAC,SAAS8D,EAAE9D,GAAG,OAAOL,EAAEK,IAAIN,EAAE,GAAGM,GAAG,SAASN,EAAEC,GAAG,IAAIG,EAAEH,GAAG,OAAOA,EAAE,IAAIK,EAAEgB,EAAErB,EAAEU,GAAGwD,EAAE9E,EAAEY,GAAG,GAAGqB,EAAE,CAAC,IAAIA,EAAEoC,IAAIpC,EAAEf,EAAE,IAAIyC,EAAE,OAAOqC,EAAE/D,IAAI,OAAOA,EAAElB,EAAEkB,EAAEyC,GAAE,EAAGzD,EAAEgE,EAAErE,EAAEkE,GAAG7C,EAAEyC,GAAE,CAAG,MAAMzD,EAAEgE,EAAErE,EAAEkE,GAAG,OAAO5D,EAAED,GAAE,SAAUL,EAAEG,GAAGkB,GAAn0F,SAAWtB,EAAEC,GAAG,OAAO,IAAIZ,EAAEW,GAAGA,EAAEqC,IAAIpC,GAAGD,EAAEC,EAAE,CAAyxFgE,CAAE3C,EAAElB,EAAEH,KAAKG,GAAGoB,EAAElB,EAAEL,EAAED,EAAEI,GAAK,IAAG,IAAI+D,EAAE,IAAIrC,IAAIxB,GAAGA,CAAC,CAAzN,CAA2NA,EAAE,CAAC,SAASgE,EAAEtE,EAAEC,GAAG,OAAOA,GAAG,KAAK,EAAE,OAAO,IAAI2B,IAAI5B,GAAG,KAAK,EAAE,OAAOK,MAAMiF,KAAKtF,GAAG,OAAOgC,EAAEhC,EAAE,CAAC,IAAIuF,EAAEpC,EAAEqC,EAAE,oBAAoBC,QAAQ,iBAAiBA,OAAO,KAAK9D,EAAE,oBAAoBC,IAAIC,EAAE,oBAAoBC,IAAI4D,EAAE,oBAAoBX,YAAO,IAASA,MAAMC,WAAW,oBAAoBW,QAAQ9B,EAAE2B,EAAEC,OAAOG,IAAI,mBAAmBL,EAAE,CAAC,GAAG,kBAAiB,EAAGA,GAAGvE,EAAEwE,EAAEC,OAAOG,IAAI,mBAAmB,qBAAqBjF,EAAE6E,EAAEC,OAAOG,IAAI,eAAe,iBAAiBpF,EAAE,CAAC,EAAE,gBAAgB,EAAE,+CAA+C,EAAE,wDAAwD,EAAE,SAASR,GAAG,MAAO,uHAAuHA,CAAC,EAAE,EAAE,oHAAoH,EAAE,oCAAoC,EAAE,+DAA+D,EAAE,kEAAkE,EAAE,2FAA2F,EAAE,4EAA4E,GAAG,uCAAuC,GAAG,2DAA2D,GAAG,2DAA2D,GAAG,6CAA6C,GAAG,sEAAsE,GAAG,SAASA,GAAG,MAAO,6CAA6CA,CAAC,EAAE,GAAG,sCAAsC,GAAG,SAASA,GAAG,MAAO,gCAAgCA,CAAC,EAAE,GAAG,SAASA,GAAG,MAAO,mBAAmBA,EAAE,kFAAkFA,EAAE,yCAAyC,EAAE,GAAG,4EAA4E,GAAG,SAASA,GAAG,MAAO,sJAAsJA,EAAE,GAAG,EAAE,GAAG,SAASA,GAAG,MAAO,mCAAmCA,CAAC,EAAE,GAAG,SAASA,GAAG,MAAO,oCAAoCA,CAAC,EAAE,GAAG,yFAAyFc,EAAE,GAAGxB,OAAOC,UAAUO,YAAYsB,EAAG,oBAAoBuE,SAASA,QAAQE,QAAQF,QAAQE,aAAQ,IAASvG,OAAOwG,sBAAsB,SAAS9F,GAAG,OAAOV,OAAOyG,oBAAoB/F,GAAGqE,OAAO/E,OAAOwG,sBAAsB9F,GAAG,EAAEV,OAAOyG,oBAAoB7D,GAAG5C,OAAO0G,2BAA2B,SAAShG,GAAG,IAAIC,EAAE,CAAC,EAAE,OAAOmB,EAAGpB,GAAGqB,SAAQ,SAAUjB,GAAGH,EAAEG,GAAGd,OAAOkF,yBAAyBxE,EAAEI,EAAI,IAAGH,CAAC,EAAEgD,GAAG,CAAC,EAAE4B,GAAG,CAACxC,IAAI,SAASrC,EAAEC,GAAG,GAAGA,IAAIU,EAAE,OAAOX,EAAE,IAAIM,EAAEyB,EAAE/B,GAAG,IAAIsB,EAAEhB,EAAEL,GAAG,OAAO,SAASD,EAAEC,EAAEG,GAAG,IAAIE,EAAEC,EAAEwD,EAAE9D,EAAEG,GAAG,OAAOG,EAAE,UAAUA,EAAEA,EAAEgC,MAAM,QAAQjC,EAAEC,EAAE8B,WAAM,IAAS/B,OAAE,EAAOA,EAAEb,KAAKO,EAAEgE,QAAG,CAAM,CAAlH,CAAoHhE,EAAEM,EAAEL,GAAG,IAAIM,EAAED,EAAEL,GAAG,OAAOD,EAAE+D,IAAI3D,EAAEG,GAAGA,EAAEA,IAAIgE,EAAEvE,EAAEI,EAAEH,IAAIwE,EAAEzE,GAAGA,EAAEX,EAAEY,GAAGiE,EAAElE,EAAE8D,EAAEjB,EAAEtC,EAAEP,IAAIO,CAAC,EAAEgB,IAAI,SAASvB,EAAEC,GAAG,OAAOA,KAAK8B,EAAE/B,EAAE,EAAE6F,QAAQ,SAAS7F,GAAG,OAAO2F,QAAQE,QAAQ9D,EAAE/B,GAAG,EAAEyB,IAAI,SAASzB,EAAEC,EAAEG,GAAG,IAAIE,EAAEyD,EAAEhC,EAAE/B,GAAGC,GAAG,GAAG,MAAMK,OAAE,EAAOA,EAAEmB,IAAI,OAAOnB,EAAEmB,IAAIhC,KAAKO,EAAEgE,EAAE5D,IAAG,EAAG,IAAIJ,EAAE0D,EAAE,CAAC,IAAInD,EAAEgE,EAAExC,EAAE/B,GAAGC,GAAGZ,EAAE,MAAMkB,OAAE,EAAOA,EAAEI,GAAG,GAAGtB,GAAGA,EAAEe,IAAIA,EAAE,OAAOJ,EAAEX,EAAEY,GAAGG,EAAEJ,EAAEoE,EAAEnE,IAAG,GAAG,EAAG,GAAv5L,SAAWD,EAAEC,GAAG,OAAOD,IAAIC,EAAE,IAAID,GAAG,EAAEA,GAAG,EAAEC,EAAED,GAAGA,GAAGC,GAAGA,CAAC,CAAm2LkE,CAAE/D,EAAEG,UAAK,IAASH,GAAGkB,EAAEtB,EAAEI,EAAEH,IAAI,OAAO,EAAGwE,EAAEzE,GAAGgE,EAAEhE,EAAG,CAAC,OAAOA,EAAEX,EAAEY,KAAKG,SAAI,IAASA,GAAGH,KAAKD,EAAEX,IAAI4G,OAAOC,MAAM9F,IAAI6F,OAAOC,MAAMlG,EAAEX,EAAEY,MAAMD,EAAEX,EAAEY,GAAGG,EAAEJ,EAAEoE,EAAEnE,IAAG,IAAI,CAAE,EAAEkG,eAAe,SAASnG,EAAEC,GAAG,YAAO,IAASsE,EAAEvE,EAAEI,EAAEH,IAAIA,KAAKD,EAAEI,GAAGJ,EAAEoE,EAAEnE,IAAG,EAAGwE,EAAEzE,GAAGgE,EAAEhE,WAAWA,EAAEoE,EAAEnE,GAAGD,EAAEX,UAAUW,EAAEX,EAAEY,IAAG,CAAE,EAAEuE,yBAAyB,SAASxE,EAAEC,GAAG,IAAIG,EAAE2B,EAAE/B,GAAGM,EAAEqF,QAAQnB,yBAAyBpE,EAAEH,GAAG,OAAOK,EAAE,CAAC6B,UAAS,EAAGC,aAAa,IAAIpC,EAAEO,GAAG,WAAWN,EAAEqC,WAAWhC,EAAEgC,WAAWC,MAAMnC,EAAEH,IAAIK,CAAC,EAAE8F,eAAe,WAAWpG,EAAE,GAAI,EAAEY,eAAe,SAASZ,GAAG,OAAOV,OAAOsB,eAAeZ,EAAEI,EAAE,EAAEiG,eAAe,WAAWrG,EAAE,GAAI,GAAG8E,GAAG,CAAC,EAAEvE,EAAEsE,IAAG,SAAU7E,EAAEC,GAAG6E,GAAG9E,GAAG,WAAW,OAAOE,UAAU,GAAGA,UAAU,GAAG,GAAGD,EAAEQ,MAAM6F,KAAKpG,UAAU,CAAG,IAAG4E,GAAGqB,eAAe,SAASlG,EAAEG,GAAG,OAAO8F,MAAMK,SAASnG,KAAKJ,EAAE,IAAI8E,GAAGrD,IAAIhC,KAAK6G,KAAKrG,EAAEG,OAAE,EAAO,EAAE0E,GAAGrD,IAAI,SAASxB,EAAEG,EAAEE,GAAG,MAAO,WAAWF,GAAG8F,MAAMK,SAASnG,KAAKJ,EAAE,IAAI6E,GAAGpD,IAAIhC,KAAK6G,KAAKrG,EAAE,GAAGG,EAAEE,EAAEL,EAAE,GAAG,EAAE,IAAIuG,GAAG,WAAW,SAASlG,EAAEL,GAAG,IAAIK,EAAEgG,KAAKA,KAAKhD,EAAEoC,EAAEY,KAAKhC,GAAE,EAAGgC,KAAKG,QAAQ,SAASxG,EAAEM,EAAElB,GAAG,GAAG,mBAAmBY,GAAG,mBAAmBM,EAAE,CAAC,IAAIe,EAAEf,EAAEA,EAAEN,EAAE,IAAIgE,EAAE3D,EAAE,OAAO,SAASN,GAAG,IAAIC,EAAEqG,UAAK,IAAStG,IAAIA,EAAEsB,GAAG,IAAI,IAAIlB,EAAEF,UAAUC,OAAOG,EAAED,MAAMD,EAAE,EAAEA,EAAE,EAAE,GAAGf,EAAE,EAAEA,EAAEe,EAAEf,IAAIiB,EAAEjB,EAAE,GAAGa,UAAUb,GAAG,OAAO4E,EAAEwC,QAAQzG,GAAE,SAAUA,GAAG,IAAII,EAAE,OAAQA,EAAEG,GAAGd,KAAKgB,MAAML,EAAE,CAACH,EAAED,GAAGqE,OAAO/D,GAAI,GAAE,CAAC,CAAC,IAAIkB,EAAE,GAAG,mBAAmBjB,GAAGP,EAAE,QAAG,IAASX,GAAG,mBAAmBA,GAAGW,EAAE,GAAGI,EAAEH,GAAG,CAAC,IAAIkE,EAAEX,EAAElD,GAAGW,EAAEiD,EAAE5D,EAAEL,OAAE,GAAQiB,GAAE,EAAG,IAAIM,EAAEjB,EAAEU,GAAGC,GAAE,CAAG,CAAC,QAAQA,EAAEmC,EAAEc,GAAGb,EAAEa,EAAG,CAAC,MAAO,oBAAoBuC,SAASlF,aAAakF,QAAQlF,EAAEmF,MAAK,SAAU3G,GAAG,OAAOoD,EAAEe,EAAE9E,GAAGqE,EAAE1D,EAAEmE,EAAG,IAAE,SAAUnE,GAAG,MAAMqD,EAAEc,GAAGnE,CAAE,KAAIoD,EAAEe,EAAE9E,GAAGqE,EAAElC,EAAE2C,GAAG,CAAC,IAAIlE,GAAG,iBAAiBA,EAAE,CAAC,QAAG,KAAUuB,EAAEjB,EAAEN,MAAMuB,EAAEvB,GAAGuB,IAAIqC,IAAIrC,OAAE,GAAQlB,EAAEgE,GAAG7B,EAAEjB,GAAE,GAAInC,EAAE,CAAC,IAAI0C,EAAE,GAAGC,EAAE,GAAGgB,EAAE,WAAWW,EAAE1D,EAAEuB,EAAEO,EAAEC,GAAG3C,EAAE0C,EAAEC,EAAG,CAAC,OAAOR,CAAC,CAACxB,EAAE,GAAGC,EAAG,EAAEqG,KAAKM,mBAAmB,SAAS5G,EAAEC,GAAG,GAAG,mBAAmBD,EAAE,OAAO,SAASC,GAAG,IAAI,IAAIG,EAAEF,UAAUC,OAAOI,EAAEF,MAAMD,EAAE,EAAEA,EAAE,EAAE,GAAGf,EAAE,EAAEA,EAAEe,EAAEf,IAAIkB,EAAElB,EAAE,GAAGa,UAAUb,GAAG,OAAOiB,EAAEsG,mBAAmB3G,GAAE,SAAUA,GAAG,OAAOD,EAAES,WAAM,EAAO,CAACR,GAAGoE,OAAO9D,GAAI,GAAE,EAAE,IAAIH,EAAEG,EAAElB,EAAEiB,EAAEmG,QAAQzG,EAAEC,GAAE,SAAUD,EAAEC,GAAGG,EAAEJ,EAAEO,EAAEN,CAAG,IAAG,MAAO,oBAAoByG,SAASrH,aAAaqH,QAAQrH,EAAEsH,MAAK,SAAU3G,GAAG,MAAO,CAACA,EAAEI,EAAEG,EAAG,IAAG,CAAClB,EAAEe,EAAEG,EAAE,EAAE,kBAAkB,MAAMN,OAAE,EAAOA,EAAE4G,aAAaP,KAAKQ,cAAc7G,EAAE4G,YAAY,kBAAkB,MAAM5G,OAAE,EAAOA,EAAE8G,aAAaT,KAAKU,cAAc/G,EAAE8G,WAAY,CAAC,IAAIxG,EAAED,EAAEf,UAAU,OAAOgB,EAAE0G,YAAY,SAAS3G,GAAGF,EAAEE,IAAIN,EAAE,GAAGC,EAAEK,KAAKA,EAAE8D,EAAE9D,IAAI,IAAIC,EAAEiD,EAAE8C,MAAMjH,EAAE6E,EAAEoC,KAAKhG,OAAE,GAAQ,OAAOjB,EAAEsB,GAAGiE,GAAE,EAAGtB,EAAE/C,GAAGlB,CAAC,EAAEkB,EAAE2G,YAAY,SAASjH,EAAEG,GAAG,IAAIE,EAAEL,GAAGA,EAAEU,GAAIL,GAAGA,EAAEsE,GAAG5E,EAAE,GAAGM,EAAEyD,GAAG/D,EAAE,IAAK,IAAIO,EAAED,EAAEwD,EAAE,OAAOV,EAAE7C,EAAEH,GAAGsD,OAAE,EAAOnD,EAAE,EAAEA,EAAEyG,cAAc,SAAShH,GAAGsG,KAAKhC,EAAEtE,CAAE,EAAEO,EAAEuG,cAAc,SAAS7G,GAAGA,IAAIyF,GAAG1F,EAAE,IAAIsG,KAAKhD,EAAErD,CAAE,EAAEM,EAAE4G,aAAa,SAASnH,EAAEI,GAAG,IAAIE,EAAE,IAAIA,EAAEF,EAAED,OAAO,EAAEG,GAAG,EAAEA,IAAI,CAAC,IAAIC,EAAEH,EAAEE,GAAG,GAAG,IAAIC,EAAE6G,KAAKjH,QAAQ,YAAYI,EAAE8G,GAAG,CAACrH,EAAEO,EAAEgC,MAAM,KAAK,CAAC,CAACjC,GAAG,IAAIF,EAAEA,EAAE6B,MAAM3B,EAAE,IAAI,IAAIjB,EAAE2D,EAAE,WAAWsE,EAAE,OAAOrH,EAAED,GAAGX,EAAEW,EAAEI,GAAGkG,KAAKG,QAAQzG,GAAE,SAAUA,GAAG,OAAOX,EAAEW,EAAEI,EAAG,GAAE,EAAEE,CAAC,CAAx5D,GAA45DiH,GAAG,IAAIf,GAAGgB,GAAGD,GAAGd,QAAQc,GAAGX,mBAAmBa,KAAKF,IAAIA,GAAGP,cAAcS,KAAKF,IAAIA,GAAGT,cAAcW,KAAKF,IAAIA,GAAGJ,aAAaM,KAAKF,IAAI,IAAIG,GAAGH,GAAGN,YAAYQ,KAAKF,IAAII,GAAGJ,GAAGL,YAAYO,KAAKF,IAE75T,SAASK,GAAgBC,EAAKC,EAAKvF,GAYjC,OAXIuF,KAAOD,EACTvI,OAAO8G,eAAeyB,EAAKC,EAAK,CAC9BvF,MAAOA,EACPD,YAAY,EACZF,cAAc,EACdD,UAAU,IAGZ0F,EAAIC,GAAOvF,EAGNsF,CACT,CAEA,IAAIE,GAAc,IAAIC,QAClBC,GAAkB,IAAID,QACtBE,GAAc,IAAIF,QAClBG,GAAY,IAAIH,QAChBI,GAAa,IAAIJ,QACjBK,GAAa,IAAIL,QAiBrB,SAASM,GAA2BC,EAAQC,GAC1C,GAAc,MAAVD,EAAgB,MAAO,CAAC,EAC5B,IACIT,EAAKvH,EADLkI,EAjBN,SAAyCF,EAAQC,GAC/C,GAAc,MAAVD,EAAgB,MAAO,CAAC,EAC5B,IAEIT,EAAKvH,EAFLkI,EAAS,CAAC,EACVC,EAAapJ,OAAO6B,KAAKoH,GAG7B,IAAKhI,EAAI,EAAGA,EAAImI,EAAWvI,OAAQI,IACjCuH,EAAMY,EAAWnI,GACbiI,EAASG,QAAQb,IAAQ,IAC7BW,EAAOX,GAAOS,EAAOT,IAGvB,OAAOW,CACT,CAIeG,CAAgCL,EAAQC,GAGrD,GAAIlJ,OAAOwG,sBAAuB,CAChC,IAAI+C,EAAmBvJ,OAAOwG,sBAAsByC,GAEpD,IAAKhI,EAAI,EAAGA,EAAIsI,EAAiB1I,OAAQI,IACvCuH,EAAMe,EAAiBtI,GACnBiI,EAASG,QAAQb,IAAQ,GACxBxI,OAAOC,UAAUuJ,qBAAqBrJ,KAAK8I,EAAQT,KACxDW,EAAOX,GAAOS,EAAOT,GAEzB,CAEA,OAAOW,CACT,CAeA,IAuKIM,GAvKAC,GAAuB,SAA8BC,GACvD,IAAIC,EAAQhJ,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,IAAmBA,UAAU,GACvEiJ,GAASD,EACTE,EAAaF,EAAQG,GAAsBJ,GAAOA,EAClDK,EAAOP,GAAcQ,KACrBC,EAAQT,GAAcQ,KACtBE,EAAW,EAIXC,EAAW,KAEf,IAAK,IAAIC,KAAQP,EAAY,CAC3B,IAAIQ,EAAOD,EAAKE,YAAY,GAC5B,IAAKD,EAAM,MACX,IAAIE,EAAOC,GAAiBJ,EAAMC,GAGlC,IAFCN,EAAME,GAASL,EAAQ,CAACK,EAAOM,GAAQ,CAACA,EAAMR,GAE3CU,GAAWV,EAAMP,GAAckB,MAAQD,GAAWR,EAAOT,GAAcmB,WAEhEC,GADLhB,EACsBF,EAAImB,UAAU,EAAGX,GAEjBR,EAAImB,UAAU,EAAGnB,EAAI9I,OAASsJ,IAG7C,MAGb,GAAIO,GAAWV,EAAMP,GAAcsB,KAAOL,GAAWR,EAAOT,GAAcsB,OAEtEX,EADe,OAAbA,GACUA,IAERP,GAGSmB,GAAuBrB,EAAImB,UAAU,EAAGnB,EAAI9I,OAASsJ,KAIrD,MAGjB,GAAIH,IAASP,GAAcQ,MAAQC,IAAUT,GAAcQ,MAAQgB,GAAejB,EAAME,GACtF,MAGFC,GAAYE,EAAKxJ,MACnB,CAEA,OAAOsJ,GAAY,CACrB,EACIe,GAAQ,KACRC,GAAc,qyCACdC,GAAY,kBAiCZC,GAA2B,CAAC1B,EAAK2B,EAAM1B,KACzC,GAAIA,EAAO,CACT,IAAI2B,EAAK5B,EAAI9I,OAASyK,EACtB,MAAO,CAAC3B,EAAIhH,MAAM4I,EAAI5B,EAAI9I,QAAS8I,EAAIhH,MAAM,EAAG4I,GAClD,CAEA,MAAO,CAAC5B,EAAIhH,MAAM,EAAG2I,GAAO3B,EAAIhH,MAAM2I,GAAM,EAO1CE,GAAkB,SAASA,EAAgBnB,EAAMoB,GACnD,IAAI7B,EAAQhJ,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,IAAmBA,UAAU,GAE3E,GAAIsK,GAAMQ,KAAKrB,GACb,OAAO,EAKT,GAAIe,GAAUM,KAAKrB,GAAO,CACxB,IAAIsB,EAAWjC,GAAqB+B,EAAW7B,IAC1CgC,EAAUC,GAAiBR,GAAyBI,EAAWE,EAAU/B,GAE9E,GAAI4B,EAAgBI,EAAUC,EAAejC,GAC3C,OAAO,CAEX,CAEA,OAAIuB,GAAYO,KAAKrB,EAKvB,EAMIN,GAAwB,UAAgCJ,GAG1D,IAFA,IAAImC,EAAMnC,EAAI9I,OAAS,EAEdI,EAAI,EAAGA,EAAI0I,EAAI9I,OAAQI,IAAK,CACnC,IAAI8K,EAAQpC,EAAIqC,OAAOF,EAAM7K,GAE7B,GAAIgL,GAAeF,EAAMG,WAAW,IAAK,CACvC,IAAIC,EAAQxC,EAAIqC,OAAOF,EAAM7K,EAAI,GAEjC,GAAImL,GAAgBD,EAAMD,WAAW,IAAK,OAClCC,EAAQJ,EACd9K,IACA,QACF,CACF,OAEM8K,CACR,CACF,EAOIK,GAAkBC,GACbA,GAAY,OAAUA,GAAY,MASvCJ,GAAiBI,GACZA,GAAY,OAAUA,GAAY,OAK3C,SAAW5C,GACTA,EAAcA,EAAoB,KAAI,GAAK,OAC3CA,EAAcA,EAAsB,OAAI,GAAK,SAC7CA,EAAcA,EAAmB,IAAI,GAAK,MAC1CA,EAAcA,EAAkB,GAAI,GAAK,KACzCA,EAAcA,EAAuB,QAAI,GAAK,UAC9CA,EAAcA,EAA2B,YAAI,IAAM,cACnDA,EAAcA,EAAiB,EAAI,IAAM,IACzCA,EAAcA,EAAiB,EAAI,IAAM,IACzCA,EAAcA,EAAiB,EAAI,KAAO,IAC1CA,EAAcA,EAAkB,GAAI,KAAO,KAC3CA,EAAcA,EAAmB,IAAI,KAAO,MAC5CA,EAAcA,EAAuB,QAAI,MAAQ,UACjDA,EAAcA,EAAmB,IAAI,MAAQ,KAC9C,CAdD,CAcGA,KAAkBA,GAAgB,CAAC,IAEtC,IAAI6C,GAAW,8nHACXC,GAAY,kJACZC,GAAgB,+lDAChBC,GAAM,iCACNC,GAAM,iCACNC,GAAM,iCACNC,GAAO,i2EACPC,GAAQ,0kKACRC,GAAY,qyBAEZrC,GAAmB,CAACJ,EAAMC,KAC5B,IAAIE,EAAOf,GAAcsD,IA8CzB,OA5C+B,IAA3B1C,EAAK2C,OAAOV,MACd9B,GAAQf,GAAcwD,QAGX,OAAT3C,IACFE,GAAQf,GAAckB,KAGpBL,GAAQ,QAAWA,GAAQ,SAC7BE,GAAQf,GAAcsB,KAGQ,IAA5BV,EAAK2C,OAAOT,MACd/B,GAAQf,GAAcyD,UAGY,IAAhC7C,EAAK2C,OAAOR,MACdhC,GAAQf,GAAc0D,cAGE,IAAtB9C,EAAK2C,OAAOP,MACdjC,GAAQf,GAAc/H,IAGE,IAAtB2I,EAAK2C,OAAON,MACdlC,GAAQf,GAAc2D,IAGE,IAAtB/C,EAAK2C,OAAOL,MACdnC,GAAQf,GAAcpE,IAGG,IAAvBgF,EAAK2C,OAAOJ,MACdpC,GAAQf,GAAc4D,KAGI,IAAxBhD,EAAK2C,OAAOH,MACdrC,GAAQf,GAAc6D,MAGQ,IAA5BjD,EAAK2C,OAAOF,MACdtC,GAAQf,GAAcmB,SAGjBJ,CAAI,EAGb,SAASE,GAAWpG,EAAGlB,GACrB,SAAQkB,EAAIlB,EACd,CAEA,IAAImK,GAAmB,CACvB,CAAC9D,GAAc/H,EAAG+H,GAAc/H,EAAI+H,GAAc2D,EAAI3D,GAAc4D,GAAK5D,GAAc6D,KACvF,CAAC7D,GAAc4D,GAAK5D,GAAc2D,EAAG3D,GAAc2D,EAAI3D,GAAcpE,GACrE,CAACoE,GAAc6D,IAAM7D,GAAcpE,EAAGoE,GAAcpE,GACpD,CAACoE,GAAcsD,IAAKtD,GAAcwD,OAASxD,GAAckB,KACzD,CAAClB,GAAcsD,IAAKtD,GAAc0D,aAClC,CAAC1D,GAAcyD,QAASzD,GAAcsD,KACtC,CAACtD,GAAckB,IAAKlB,GAAcmB,SAClC,CAACnB,GAAcsB,GAAItB,GAAcsB,KAEjC,SAASE,GAAejB,EAAME,GAC5B,OAA+F,IAAxFqD,GAAiBC,WAAU7M,GAAK+J,GAAWV,EAAMrJ,EAAE,KAAO+J,GAAWR,EAAOvJ,EAAE,KACvF,CAEA,IAAI8M,GAAiB,o6IAEjB5C,GAAmBlB,IACkB,IAAhCA,EAAIqD,OAAOS,IAGhBC,GAAY,+BAEZ1C,GAAyBrB,IAC3B,IAAIgE,EAAQhE,EAAIgE,MAAMD,IAEtB,OAAc,OAAVC,GAIWA,EAAM,GAAG9M,OAAS,EACf,GAAM,CACxB,EAOE+M,GAAY3K,GACP7C,EAAc6C,IAAU4K,GAAKC,WAAW7K,EAAM8K,YAAcC,GAAOC,SAAShL,GAIjFiL,GAAU,CAIZC,WAAWlL,GACF7C,EAAc6C,IAAU4K,GAAKC,WAAW7K,EAAM8K,UAMvDH,aAKAQ,cAAcnL,GACLlC,MAAMU,QAAQwB,IAAUA,EAAMoL,OAAMC,GAAOJ,GAAQN,UAAUU,KAMtEC,eAAeC,QACajO,IAAnBiO,EAAMT,SAOfU,cAAe,SAAuBxL,EAAOyL,GAC3C,IAAIC,EAAa/N,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,OACrF,OAAOgN,GAAU3K,IAAUA,EAAM0L,KAAgBD,CACnD,EAQA,OAAAE,CAAQC,EAASL,GACf,IAAK,IAAIhG,KAAOgG,EACd,GAAY,aAARhG,GAIAqG,EAAQrG,KAASgG,EAAMhG,GACzB,OAAO,EAIX,OAAO,CACT,GAIEsG,GAAc,CAAC,QACfC,GAAe,CAAC,QAEpB,SAASC,GAAUC,EAAQC,GAAkB,IAAIrN,EAAO7B,OAAO6B,KAAKoN,GAAS,GAAIjP,OAAOwG,sBAAuB,CAAE,IAAI2I,EAAUnP,OAAOwG,sBAAsByI,GAAaC,IAAkBC,EAAUA,EAAQC,QAAO,SAAUC,GAAO,OAAOrP,OAAOkF,yBAAyB+J,EAAQI,GAAKrM,UAAY,KAAMnB,EAAKiE,KAAK3E,MAAMU,EAAMsN,EAAU,CAAE,OAAOtN,CAAM,CAE1V,SAASyN,GAAgBnG,GAAU,IAAK,IAAIlI,EAAI,EAAGA,EAAIL,UAAUC,OAAQI,IAAK,CAAE,IAAIgI,EAAyB,MAAhBrI,UAAUK,GAAaL,UAAUK,GAAK,CAAC,EAAOA,EAAI,EAAK+N,GAAUhP,OAAOiJ,IAAS,GAAMlH,SAAQ,SAAUyG,GAAOF,GAAgBa,EAAQX,EAAKS,EAAOT,GAAO,IAAexI,OAAO0G,0BAA6B1G,OAAOuP,iBAAiBpG,EAAQnJ,OAAO0G,0BAA0BuC,IAAmB+F,GAAUhP,OAAOiJ,IAASlH,SAAQ,SAAUyG,GAAOxI,OAAO8G,eAAeqC,EAAQX,EAAKxI,OAAOkF,yBAAyB+D,EAAQT,GAAO,GAAM,CAAE,OAAOW,CAAQ,CAC3hB,IAAIqG,GAAkB,IAAI9G,QAEtBsF,GAAS,CAIX,KAAAyB,CAAMC,GACJ,IAAIC,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,GAC/E,MACFgP,GAAQ,EAAK,KACbC,EAAO,SAAQ,GACftE,EAAKmE,EAAOI,UAAS,MACrBnC,GACEgC,EAEJ,GAAKpE,EAAL,CAIA,IAAIzD,EAAOkG,GAAOlG,KAAK4H,EAAQnE,GAC3BwE,EAAmB,WAATF,EAEd,IAAK,IAAKnP,EAAG+B,KAAMuL,GAAOgC,OAAON,EAAQ,CACvCnE,GAAIzD,EACJ8H,QACAjC,QACAoC,YAEA,IAAKE,GAAKC,OAAOxP,KAAOyP,GAAKC,OAAOtI,EAAMrF,GACxC,MAAO,CAAC/B,EAAG+B,EAZf,CAeF,EAQA,OAAA4N,CAAQX,EAAQlH,EAAKvF,GACnByM,EAAOW,QAAQ7H,EAAKvF,EACtB,EAKA,KAAAqN,CAAMZ,EAAQnE,GACZ,IAaIpC,EAbAwG,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,EAK/E2P,EAAQ,CACVC,OALWxC,GAAOyC,MAAMf,EAAQnE,EAAI,CACpCmF,KAAM,QAKNC,MAHU3C,GAAOlC,IAAI4D,EAAQ,MAK3B,SACFvF,EAAW,GACTwF,EACAxM,EAAI,EAGR,IAAK,IAAIV,KAAKuL,GAAO4C,UAAUlB,EAAQJ,GAAgBA,GAAgB,CAAC,EAAGK,GAAU,CAAC,EAAG,CACvFpE,GAAIgF,KACD,CACH,GAAIpN,EAAIgH,EACN,MAGQ,IAANhH,IACFgG,EAAS1G,GAGXU,GACF,CAEA,OAAOgG,CACT,EAKA,MAAA0H,CAAOnB,EAAQnE,GACb,IAaIpC,EAbAwG,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,EAK/E2P,EAAQ,CACVC,OALWxC,GAAO8C,MAAMpB,EAAQ,IAMhCiB,MALU3C,GAAOyC,MAAMf,EAAQnE,EAAI,CACnCmF,KAAM,YAMJ,SACFvG,EAAW,GACTwF,EACAxM,EAAI,EAGR,IAAK,IAAIV,KAAKuL,GAAO4C,UAAUlB,EAAQJ,GAAgBA,GAAgB,CAAC,EAAGK,GAAU,CAAC,EAAG,CACvFpE,GAAIgF,EACJR,SAAS,KACN,CACH,GAAI5M,EAAIgH,EACN,MAGQ,IAANhH,IACFgG,EAAS1G,GAGXU,GACF,CAEA,OAAOgG,CACT,EAKA,cAAA4H,CAAerB,GACb,IAAIC,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,GAC/E,KACFoQ,EAAO,aACLrB,EACJD,EAAOqB,eAAeC,EACxB,EAKA,aAAAC,CAAcvB,GACZ,IAAIC,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,GAC/E,KACFoQ,EAAO,aACLrB,EACJD,EAAOuB,cAAcD,EACvB,EAKA,cAAAE,CAAexB,GACb,IAAIC,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,GAC/E,UACFuQ,EAAY,WACVxB,EACJD,EAAOwB,eAAeC,EACxB,EAKAC,MAAK,CAAC1B,EAAQnE,IACL,CAACyC,GAAO8C,MAAMpB,EAAQnE,GAAKyC,GAAOlC,IAAI4D,EAAQnE,IAMvDO,IAAG,CAAC4D,EAAQnE,IACHyC,GAAOyC,MAAMf,EAAQnE,EAAI,CAC9BmF,KAAM,QAOV,KAAAW,CAAM3B,EAAQnE,GACZ,IAAIzD,EAAOkG,GAAOlG,KAAK4H,EAAQnE,EAAI,CACjCmF,KAAM,UAER,OAAO1C,GAAOsD,KAAK5B,EAAQ5H,EAC7B,EAKA,QAAAyJ,CAAS7B,EAAQnE,GACf,IAAIgF,EAAQvC,GAAOuC,MAAMb,EAAQnE,GAEjC,OADesC,GAAK0D,SAAS7B,EAAQa,EAEvC,EAKAiB,UAAS,CAAC9B,EAAQb,IACTA,EAAQd,SAAS0D,MAAK/Q,GAAKsN,GAAO0D,QAAQhC,EAAQhP,KAM3DiR,WAAU,CAACjC,EAAQb,IACVA,EAAQd,SAAS0D,MAAK/Q,GAAKuP,GAAKC,OAAOxP,IAAMsN,GAAO4D,SAASlC,EAAQhP,KAM9EmR,SAAQ,CAACnC,EAAQb,IACRA,EAAQd,SAASM,OAAM3N,GAAKuP,GAAKC,OAAOxP,KAQjD,WAAAoR,CAAYpC,GACVA,EAAOoC,aACT,EAOA,eAAAC,CAAgBrC,GACdA,EAAOqC,iBACT,EAOA,cAAAC,CAAetC,EAAQ6B,GACrB7B,EAAOsC,eAAeT,EACxB,EAOA,UAAAU,CAAWvC,EAAQ4B,GACjB5B,EAAOuC,WAAWX,EACpB,EAOA,UAAAY,CAAWxC,EAAQyC,GACjBzC,EAAOwC,WAAWC,EACpB,EAKAT,QAAO,CAAChC,EAAQzM,IACPiL,GAAQN,UAAU3K,KAAWyM,EAAOkC,SAAS3O,GAMtD,QAAAgL,CAAShL,GACP,IAAImP,EAAiB5C,GAAgBzM,IAAIE,GAEzC,QAAuB1C,IAAnB6R,EACF,OAAOA,EAGT,IAAKhS,EAAc6C,GACjB,OAAO,EAGT,IAAIgL,EAAoC,mBAAlBhL,EAAMoN,SAAiD,mBAAhBpN,EAAM9B,OAAwD,mBAAzB8B,EAAM8N,gBAAgE,mBAAxB9N,EAAMgO,eAAgE,mBAAzBhO,EAAMiO,gBAA8D,mBAAtBjO,EAAM6O,aAA+D,mBAA1B7O,EAAM8O,iBAAkE,mBAAzB9O,EAAM+O,gBAA6D,mBAArB/O,EAAMgP,YAAyD,mBAArBhP,EAAMiP,YAAuD,mBAAnBjP,EAAM2O,UAAmD,mBAAjB3O,EAAMoP,QAAwD,mBAAxBpP,EAAMqP,eAA0D,mBAAnBrP,EAAMsP,UAAuD,mBAArBtP,EAAMuP,YAA4D,mBAAxBvP,EAAMwP,gBAAiD,OAAhBxP,EAAMyP,OAAkBtS,EAAc6C,EAAMyP,UAAgC,OAApBzP,EAAM6M,WAAsB6C,GAAMC,QAAQ3P,EAAM6M,aAAejC,GAAKC,WAAW7K,EAAM8K,WAAa8E,GAAUC,gBAAgB7P,EAAM8P,YAEr3B,OADAvD,GAAgBrN,IAAIc,EAAOgL,GACpBA,CACT,EAKA,KAAA+E,CAAMtD,EAAQe,EAAOlF,GACnB,IAAIO,EAAMkC,GAAOlC,IAAI4D,EAAQnE,GAC7B,OAAO0H,GAAM7C,OAAOK,EAAO3E,EAC7B,EAKAoH,OAAM,CAACxD,EAAQe,EAAOlF,IACbyC,GAAOmF,QAAQzD,EAAQe,EAAOlF,IAAOyC,GAAOgF,MAAMtD,EAAQe,EAAOlF,GAM1E,OAAA6H,CAAQ1D,EAAQb,GACd,IAAI,SACFd,GACEc,GACCwC,GAAStD,EACd,OAA2B,IAApBA,EAASlN,QAAoC,IAApBkN,EAASlN,QAAgBoP,GAAKC,OAAOmB,IAAyB,KAAfA,EAAMc,OAAgBzC,EAAO2C,OAAOxD,EACrH,EAKA+C,SAAQ,CAAClC,EAAQzM,IACRiL,GAAQN,UAAU3K,IAAUyM,EAAOkC,SAAS3O,GAMrD,aAAAoQ,CAAc3D,GACZ,IAAI2D,EAAgBzK,GAAY7F,IAAI2M,GACpC,YAAyBnP,IAAlB8S,GAAqCA,CAC9C,EAKA,OAAAF,CAAQzD,EAAQe,EAAOlF,GAErB,GAAqB,IAAjBkF,EAAM6C,OACR,OAAO,EAGT,IAAIxC,EAAQ9C,GAAO8C,MAAMpB,EAAQnE,GACjC,OAAO0H,GAAM7C,OAAOK,EAAOK,EAC7B,EAKAuB,OAAM,CAAC3C,EAAQzM,IACNiL,GAAQN,UAAU3K,IAAUyM,EAAO2C,OAAOpP,GAMnD,IAAAsQ,CAAK7D,EAAQnE,GACX,IAAIzD,EAAOkG,GAAOlG,KAAK4H,EAAQnE,EAAI,CACjCmF,KAAM,QAER,OAAO1C,GAAOsD,KAAK5B,EAAQ5H,EAC7B,EAKA,IAAA0L,CAAK9D,EAAQnE,GACX,IAAIoE,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,EAC/EkH,EAAOkG,GAAOlG,KAAK4H,EAAQnE,EAAIoE,GAEnC,MAAO,CADI9B,GAAK2F,KAAK9D,EAAQ5H,GACfA,EAChB,EAKA,OAACkI,CAAON,GACN,IAAIC,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,GAC/E,GACF2K,EAAKmE,EAAOI,UAAS,QACrBC,GAAU,EAAK,MACfH,GAAQ,GACND,GACA,MACFhC,GACEgC,EAMJ,GAJa,MAAThC,IACFA,EAAQ,KAAM,GAGXpC,EAAL,CAIA,IAAIyE,EAAS,GACTlI,EAAOkG,GAAOlG,KAAK4H,EAAQnE,GAE/B,IAAK,IAAK7K,EAAG+B,KAAMoL,GAAKmC,OAAON,EAAQ5H,GACrC,GAAK6F,EAAMjN,EAAG+B,KAIduN,EAAOlK,KAAK,CAACpF,EAAG+B,KAEXmN,GAAS5B,GAAOqE,OAAO3C,EAAQhP,IAClC,MAIAqP,GACFC,EAAOD,gBAGFC,CArBP,CAsBF,EAKA,KAAA0C,CAAMhD,GACJ,IAAI,MACFgD,EAAK,UACL5C,GACEJ,EAEJ,IAAKI,EACH,OAAO,KAGT,GAAI4C,EACF,OAAOA,EAGT,GAAIC,GAAMc,WAAW3D,GAAY,CAC/B,IAAKnC,GAASK,GAAO0F,MAAMhE,EAAQ,CACjC/B,MAAOsC,GAAKC,SAGd,GAAIvC,EAAO,CACT,IAAKgG,GAAShG,EAId,OAFY3E,GAA2B2K,EAAO7E,GAGhD,CACE,MAAO,CAAC,CAEZ,CAEA,IAAI,OACF0B,GACEV,GACA,KACFhI,GACE0I,GACCc,GAAQtD,GAAOwF,KAAK9D,EAAQ5H,GAEjC,GAAsB,IAAlB0I,EAAO8C,OAAc,CACvB,IAAIM,EAAO5F,GAAO6F,SAASnE,EAAQ,CACjCnE,GAAIzD,EACJ6F,MAAOsC,GAAKC,SAEV4D,EAAQ9F,GAAOyB,MAAMC,EAAQ,CAC/B/B,MAAOjN,GAAKsN,GAAO0D,QAAQhC,EAAQhP,KAGrC,GAAIkT,GAAQE,EAAO,CACjB,IAAKC,EAAUC,GAAYJ,GACtB,CAAEK,GAAaH,EAEhB3D,GAAKhC,WAAW8F,EAAWD,KAC7B1C,EAAOyC,EAEX,CACF,CAIA,OAFW/K,GAA2BsI,EAAMvC,GAG9C,EAKA,IAAAmF,CAAKxE,GACH,IAAIC,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,GAC/E,KACFiP,EAAO,SAAQ,MACfD,GAAQ,GACND,GACA,MACFhC,EAAK,GACLpC,EAAKmE,EAAOI,WACVH,EAEJ,GAAKpE,EAAL,CAIA,IAAI4I,EAAqBnG,GAAOsC,MAAMZ,EAAQnE,EAAI,CAChDqE,UAEF,GAAKuE,EAAL,CACA,IAAK,CAAEC,GAAMpG,GAAOuF,KAAK7D,EAAQ,IAC7B2E,EAAO,CAACF,EAAmBrM,KAAMsM,GAErC,GAAIjE,GAAKmE,OAAO/I,IAAqB,IAAdA,EAAG1K,OACxB,MAAM,IAAIO,MAAM,gDAGlB,GAAa,MAATuM,EACF,GAAIwC,GAAKmE,OAAO/I,GAAK,CACnB,IAAKgJ,GAAUvG,GAAOuG,OAAO7E,EAAQnE,GAErCoC,EAAQjN,GAAK6T,EAAOxG,SAASyG,SAAS9T,EACxC,MACEiN,EAAQ,KAAM,EAIlB,IAAKuG,GAAQlG,GAAO0F,MAAMhE,EAAQ,CAChCnE,GAAI8I,EACJ1G,QACAkC,OACAD,UAEF,OAAOsE,CAxBwB,CAL/B,CA8BF,EAKA,IAAA5C,CAAK5B,EAAQnE,GACX,IAAIoE,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,EAC/EkH,EAAOkG,GAAOlG,KAAK4H,EAAQnE,EAAIoE,GAEnC,MAAO,CADI9B,GAAK9K,IAAI2M,EAAQ5H,GACdA,EAChB,EAKA,MAAC4L,CAAMhE,GACL,IAAIC,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,GAC/E,GACF2K,EAAKmE,EAAOI,UAAS,KACrBD,EAAO,MAAK,UACZ4E,GAAY,EAAK,QACjB1E,GAAU,EAAK,MACfH,GAAQ,GACND,GACA,MACFhC,GACEgC,EAMJ,GAJKhC,IACHA,EAAQ,KAAM,GAGXpC,EAAL,CAIA,IAAIvF,EACAoO,EAEJ,GAAIM,GAAKC,OAAOpJ,GACdvF,EAAOuF,EAAG,GACV6I,EAAK7I,EAAG,OACH,CACL,IAAI8F,EAAQrD,GAAOlG,KAAK4H,EAAQnE,EAAI,CAClCmF,KAAM,UAEJ6C,EAAOvF,GAAOlG,KAAK4H,EAAQnE,EAAI,CACjCmF,KAAM,QAER1K,EAAO+J,EAAUwD,EAAOlC,EACxB+C,EAAKrE,EAAUsB,EAAQkC,CACzB,CAEA,IAUIqB,EAVAC,EAAchH,GAAK6F,MAAMhE,EAAQ,CACnCK,UACA/J,OACAoO,KACAU,KAAMC,IACJ,IAAKrU,GAAKqU,EACV,OAAOnF,GAAgB5B,GAAOqE,OAAO3C,EAAQhP,EAAE,IAG/CkO,EAAU,GAGd,IAAK,IAAK0C,EAAMxJ,KAAS+M,EAAa,CACpC,IAAIG,EAAUJ,GAAsC,IAA/BzE,GAAK8E,QAAQnN,EAAM8M,EAAI,IAE5C,GAAa,YAAT/E,IAAsBmF,EAI1B,GAAKrH,EAAM2D,EAAMxJ,GAYjB,GAAa,WAAT+H,GAAqBmF,EACvBJ,EAAM,CAACtD,EAAMxJ,OADf,CAMA,IAAIoN,EAAgB,WAATrF,EAAoB+E,EAAM,CAACtD,EAAMxJ,GAExCoN,IACET,EACF7F,EAAQ9I,KAAKoP,SAEPA,GAIVN,EAAM,CAACtD,EAAMxJ,EAbb,MAXE,GAAI2M,IAAcO,GAAW/E,GAAKC,OAAOoB,GACvC,MAwBN,CAGa,WAATzB,GAAqB+E,IACnBH,EACF7F,EAAQ9I,KAAK8O,SAEPA,GAMNH,UACK7F,EAjFT,CAmFF,EAKA,SAAAuG,CAAUzF,GACR,IAAIC,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,GAC/E,MACFwU,GAAQ,GACNzF,EAEA8C,EAAgB/C,GACXjH,GAAY1F,IAAI2M,IAAW,GAOhC2F,EAAe3F,IACjB,IAAI5H,EAAO2K,EAAc/C,GAAQ4F,MAC7B9M,EAAMV,EAAKyN,KAAK,KAEpB,MARqB7F,IACd/G,GAAgB5F,IAAI2M,IAAW,IAAIlN,IAM1CgT,CAAiB9F,GAAQpM,OAAOkF,GACzBV,CAAI,EAGb,GAAKkG,GAAOqF,cAAc3D,GAA1B,CAIA,GAAI0F,EAAO,CACT,IAAIK,EAAW1U,MAAMiF,KAAK6H,GAAK6F,MAAMhE,IAASgG,IAC5C,IAAK,CAAEjT,GAAKiT,EACZ,OAAOjT,CAAC,IAENkT,EAAc,IAAInT,IAAIiT,EAASG,KAAInT,GAAKA,EAAE8S,KAAK,QACnD9M,GAAYtG,IAAIuN,EAAQ+F,GACxB9M,GAAgBxG,IAAIuN,EAAQiG,EAC9B,CAEqC,IAAjClD,EAAc/C,GAAQ7O,QAI1BmN,GAAO6H,mBAAmBnG,GAAQ,KAMhC,IAAK,IAAIoG,KAAarD,EAAc/C,GAClC,GAAI7B,GAAK5L,IAAIyN,EAAQoG,GAAY,CAC/B,IAAIC,EAAQ/H,GAAOsD,KAAK5B,EAAQoG,IAC3BxE,EAAM1N,GAAKmS,EAQZ7H,GAAQN,UAAU0D,IAAkC,IAAzBA,EAAKvD,SAASlN,QAC3C6O,EAAO4C,cAAcyD,EAEzB,CAOF,IAJA,IAAIC,EAAqC,GAA/BvD,EAAc/C,GAAQ7O,OAE5BsD,EAAI,EAEgC,IAAjCsO,EAAc/C,GAAQ7O,QAAc,CACzC,GAAIsD,EAAI6R,EACN,MAAM,IAAI5U,MAAM,iEAAiE2D,OAAOiR,EAAK,0HAG/F,IAAIC,EAAaZ,EAAa3F,GAG9B,GAAI7B,GAAK5L,IAAIyN,EAAQuG,GAAa,CAChC,IAAIC,EAASlI,GAAOsD,KAAK5B,EAAQuG,GAEjCvG,EAAO4C,cAAc4D,EACvB,CAEA/R,GACF,IA1DF,CA4DF,EAKA,MAAAoQ,CAAO7E,EAAQnE,GACb,IAAIoE,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,EAC/EkH,EAAOkG,GAAOlG,KAAK4H,EAAQnE,EAAIoE,GAC/BwG,EAAahG,GAAKoE,OAAOzM,GAE7B,OADYkG,GAAOsD,KAAK5B,EAAQyG,EAElC,EAKA,IAAArO,CAAK4H,EAAQnE,GACX,IAAIoE,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,GAC/E,MACFwV,EAAK,KACL1F,GACEf,EAEJ,GAAIQ,GAAKmE,OAAO/I,GACd,GAAa,UAATmF,EAAkB,CACpB,IAAK,CAAE2F,GAAaxI,GAAKwD,MAAM3B,EAAQnE,GACvCA,EAAK8K,CACP,MAAO,GAAa,QAAT3F,EAAgB,CACzB,IAAK,CAAE4F,GAAYzI,GAAK0F,KAAK7D,EAAQnE,GACrCA,EAAK+K,CACP,CAqBF,OAlBI3D,GAAMC,QAAQrH,KAEdA,EADW,UAATmF,EACGiC,GAAM7B,MAAMvF,GACC,QAATmF,EACJiC,GAAM7G,IAAIP,GAEV4E,GAAKoG,OAAOhL,EAAGiF,OAAO1I,KAAMyD,EAAGoF,MAAM7I,OAI1CmL,GAAMuD,QAAQjL,KAChBA,EAAKA,EAAGzD,MAGG,MAATsO,IACF7K,EAAKA,EAAG5I,MAAM,EAAGyT,IAGZ7K,CACT,EAEAkL,QAAO,CAAC/G,EAAQ5H,IACP+F,GAAK5L,IAAIyN,EAAQ5H,GAO1B,OAAA4O,CAAQhH,EAAQ5H,GACd,IAAI6H,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,GAC/E,SACF+V,EAAW,WACThH,EACAiH,EAAM,CACRC,QAAS/O,EACT6O,WAEA,KAAAG,GACE,IAAI,QACFD,GACED,EAIJ,OAHe5I,GAAO+I,SAASrH,GACtBpM,OAAOsT,GAChBA,EAAIC,QAAU,KACPA,CACT,GAKF,OAFW7I,GAAO+I,SAASrH,GACtBtN,IAAIwU,GACFA,CACT,EAKA,QAAAG,CAASrH,GACP,IAAIsH,EAAOnO,GAAU9F,IAAI2M,GAOzB,OALKsH,IACHA,EAAO,IAAIxU,IACXqG,GAAU1G,IAAIuN,EAAQsH,IAGjBA,CACT,EAKA,KAAAvG,CAAMf,EAAQnE,GACZ,IAAIoE,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,GAC/E,KACF8P,EAAO,SACLf,EAEJ,GAAIQ,GAAKmE,OAAO/I,GAAK,CACnB,IAAIzD,EAEJ,GAAa,QAAT4I,EAAgB,CAClB,IAAK,CAAE4F,GAAYzI,GAAK0F,KAAK7D,EAAQnE,GACrCzD,EAAOwO,CACT,KAAO,CACL,IAAK,CAAED,GAAaxI,GAAKwD,MAAM3B,EAAQnE,GACvCzD,EAAOuO,CACT,CAEA,IAAI/E,EAAOzD,GAAK9K,IAAI2M,EAAQ5H,GAE5B,IAAKmI,GAAKC,OAAOoB,GACf,MAAM,IAAIlQ,MAAM,kBAAkB2D,OAAO2L,EAAM,gCAAgC3L,OAAOwG,EAAI,wBAAwBxG,OAAO2L,EAAM,gBAGjI,MAAO,CACL5I,OACAwL,OAAiB,QAAT5C,EAAiBY,EAAKa,KAAKtR,OAAS,EAEhD,CAEA,GAAI8R,GAAMC,QAAQrH,GAAK,CACrB,IAAKuF,EAAOhF,GAAO6G,GAAMvB,MAAM7F,GAC/B,MAAgB,UAATmF,EAAmBI,EAAQhF,CACpC,CAEA,OAAOP,CACT,EAMA,QAAA0L,CAASvH,EAAQe,GACf,IAAId,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,GAC/E,SACF+V,EAAW,WACThH,EACAiH,EAAM,CACRC,QAASpG,EACTkG,WAEA,KAAAG,GACE,IAAI,QACFD,GACED,EAIJ,OAHgB5I,GAAOkJ,UAAUxH,GACvBpM,OAAOsT,GACjBA,EAAIC,QAAU,KACPA,CACT,GAKF,OAFW7I,GAAOkJ,UAAUxH,GACvBtN,IAAIwU,GACFA,CACT,EAKA,SAAAM,CAAUxH,GACR,IAAIsH,EAAOlO,GAAW/F,IAAI2M,GAO1B,OALKsH,IACHA,EAAO,IAAIxU,IACXsG,GAAW3G,IAAIuN,EAAQsH,IAGlBA,CACT,EAcA,UAACpG,CAAUlB,GACT,IAAIC,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,GAC/E,GACF2K,EAAKmE,EAAOI,UAAS,KACrBkB,EAAO,SAAQ,QACfjB,GAAU,EAAK,MACfH,GAAQ,GACND,EAEJ,GAAKpE,EAAL,CAsBA,IAAIgF,EAAQvC,GAAOuC,MAAMb,EAAQnE,IAC5BuF,EAAOhF,GAAO6G,GAAMvB,MAAMb,GAC3Bc,EAAQtB,EAAUjE,EAAMgF,EACxBqG,GAAa,EACbC,EAAY,GACZjN,EAAW,EAEXkN,EAAoB,EACpBC,EAAiB,EAOrB,IAAK,IAAKhG,EAAMxJ,KAASkG,GAAO0F,MAAMhE,EAAQ,CAC5CnE,KACAwE,UACAH,UACE,CAIF,GAAI1B,GAAQN,UAAU0D,GAAO,CAI3B,IAAK1B,GAASF,EAAO2C,OAAOf,GAAO,OAC3BtD,GAAO8C,MAAMpB,EAAQ5H,GAC3B,QACF,CAKA,GAAI4H,EAAOkC,SAASN,GAAO,SAE3B,GAAItD,GAAO2D,WAAWjC,EAAQ4B,GAAO,CAWnC,IAAItQ,EAAImP,GAAKhC,WAAWrG,EAAMgE,EAAIhE,MAAQgE,EAAMkC,GAAOlC,IAAI4D,EAAQ5H,GAC/DnG,EAAIwO,GAAKhC,WAAWrG,EAAMgJ,EAAMhJ,MAAQgJ,EAAQ9C,GAAO8C,MAAMpB,EAAQ5H,GACzEsP,EAAYpJ,GAAOuJ,OAAO7H,EAAQ,CAChCc,OAAQ7O,EACRgP,MAAO3P,GACN,CACD4O,UAEFuH,GAAa,CACf,CACF,CAOA,GAAIlH,GAAKC,OAAOoB,GAAO,CACrB,IAAIkG,EAAUrH,GAAKC,OAAOtI,EAAMuJ,EAAMvJ,MAwBtC,IAlBI0P,GACFH,EAAoBtH,EAAUsB,EAAMiC,OAAShC,EAAKa,KAAKtR,OAASwQ,EAAMiC,OACtEgE,EAAiBjG,EAAMiC,SAEvB+D,EAAoB/F,EAAKa,KAAKtR,OAC9ByW,EAAiBvH,EAAUsH,EAAoB,IAI7CG,GAAWL,GAAuB,WAATnG,UACrB,CACJlJ,OACAwL,OAAQgE,GAEVH,GAAa,KAIF,CAIX,GAAiB,IAAbhN,EAAgB,CAClB,GAAkB,KAAdiN,EAAkB,MACtBjN,EAAWsN,EAAaL,EAAWpG,EAAMjB,GAGzCqH,EAAY/L,GAAyB+L,EAAWjN,EAAU4F,GAAS,EACrE,CAQA,GALAuH,EAAiBvH,EAAUuH,EAAiBnN,EAAWmN,EAAiBnN,GACxEkN,GAAwClN,GAIhB,EAAG,CACzBA,GAAYkN,EACZ,KACF,CAKAlN,EAAW,OACL,CACJrC,OACAwL,OAAQgE,EAEZ,CACF,CACF,CA/IA,CAsJA,SAASG,EAAatF,EAAMnB,EAAMjB,GAChC,MAAa,cAATiB,EACKtH,GAAqByI,EAAMpC,GAChB,SAATiB,EAh2CK,SAAyBmB,GAK7C,IAJA,IAAIvI,EAAQhJ,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,IAAmBA,UAAU,GACvE0K,EAAO,EACPoM,GAAU,EAEPvF,EAAKtR,OAAS,GAAG,CACtB,IAAI8K,EAAWjC,GAAqByI,EAAMvI,IACrCS,EAAMoB,GAAaJ,GAAyB8G,EAAMxG,EAAU/B,GAEjE,GAAI4B,GAAgBnB,EAAMoB,EAAW7B,GACnC8N,GAAU,EACVpM,GAAQK,MACH,IAAK+L,EAGV,MAFApM,GAAQK,CAGV,CAEAwG,EAAO1G,CACT,CAEA,OAAOH,CACT,CA20CeqM,CAAgBxF,EAAMpC,GACX,SAATiB,GAA4B,UAATA,EACrBmB,EAAKtR,OAGP,CACT,CACF,EAKA,QAAAgT,CAASnE,GACP,IAAIC,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,GAC/E,KACFiP,EAAO,SAAQ,MACfD,GAAQ,GACND,GACA,MACFhC,EAAK,GACLpC,EAAKmE,EAAOI,WACVH,EAEJ,GAAKpE,EAAL,CAIA,IAAIqM,EAAsB5J,GAAO6C,OAAOnB,EAAQnE,EAAI,CAClDqE,UAGF,GAAKgI,EAAL,CAIA,IAAK,CAAExD,GAAMpG,GAAOqD,MAAM3B,EAAQ,IAG9B2E,EAAO,CAACuD,EAAoB9P,KAAMsM,GAEtC,GAAIjE,GAAKmE,OAAO/I,IAAqB,IAAdA,EAAG1K,OACxB,MAAM,IAAIO,MAAM,oDAGlB,GAAa,MAATuM,EACF,GAAIwC,GAAKmE,OAAO/I,GAAK,CACnB,IAAKgJ,GAAUvG,GAAOuG,OAAO7E,EAAQnE,GAErCoC,EAAQjN,GAAK6T,EAAOxG,SAASyG,SAAS9T,EACxC,MACEiN,EAAQ,KAAM,EAIlB,IAAKkG,GAAY7F,GAAO0F,MAAMhE,EAAQ,CACpCK,SAAS,EACTxE,GAAI8I,EACJ1G,QACAkC,OACAD,UAEF,OAAOiE,CA5BP,CARA,CAqCF,EAKAtD,MAAK,CAACb,EAAQnE,EAAI6I,IACZzB,GAAMC,QAAQrH,KAAQ6I,EACjB7I,EAKF,CACLiF,OAHUxC,GAAO8C,MAAMpB,EAAQnE,GAI/BoF,MAHQ3C,GAAOlC,IAAI4D,EAAQ0E,GAAM7I,IAWrC,QAAAsM,CAASnI,EAAQa,GACf,IAAIZ,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,GAC/E,SACF+V,EAAW,WACThH,EACAiH,EAAM,CACRC,QAAStG,EACToG,WAEA,KAAAG,GACE,IAAI,QACFD,GACED,EAIJ,OAHgB5I,GAAO8J,UAAUpI,GACvBpM,OAAOsT,GACjBA,EAAIC,QAAU,KACPA,CACT,GAKF,OAFW7I,GAAO8J,UAAUpI,GACvBtN,IAAIwU,GACFA,CACT,EAKA,SAAAkB,CAAUpI,GACR,IAAIsH,EAAOjO,GAAWhG,IAAI2M,GAO1B,OALKsH,IACHA,EAAO,IAAIxU,IACXuG,GAAW5G,IAAIuN,EAAQsH,IAGlBA,CACT,EASA,UAAAxE,CAAW9C,EAAQlH,GACjBkH,EAAO8C,WAAWhK,EACpB,EAQA,cAAAuP,CAAerI,EAAQ2D,GACrBzK,GAAYzG,IAAIuN,EAAQ2D,EAC1B,EAKAvC,MAAK,CAACpB,EAAQnE,IACLyC,GAAOyC,MAAMf,EAAQnE,EAAI,CAC9BmF,KAAM,UAUV,MAAA6G,CAAO7H,EAAQnE,GACb,IAAIoE,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,GAC/E,MACFgP,GAAQ,GACND,EACAY,EAAQvC,GAAOuC,MAAMb,EAAQnE,IAC5BuF,EAAOhF,GAAO6G,GAAMvB,MAAMb,GAC3B4B,EAAO,GAEX,IAAK,IAAKb,EAAMxJ,KAASkG,GAAO0F,MAAMhE,EAAQ,CAC5CnE,GAAIgF,EACJ5C,MAAOsC,GAAKC,OACZN,UACE,CACF,IAAI9O,EAAIwQ,EAAKa,KAEThC,GAAKC,OAAOtI,EAAMgE,EAAIhE,QACxBhH,EAAIA,EAAE6B,MAAM,EAAGmJ,EAAIwH,SAGjBnD,GAAKC,OAAOtI,EAAMgJ,EAAMhJ,QAC1BhH,EAAIA,EAAE6B,MAAMmO,EAAMwC,SAGpBnB,GAAQrR,CACV,CAEA,OAAOqR,CACT,EAKA,WAAA6F,CAAYtI,EAAQa,GAClB,IAAIZ,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,GAC/E,MACFgP,GAAQ,GACND,GACCmB,EAAOhF,GAAO6G,GAAMvB,MAAMb,GAE/B,GAAqB,IAAjBO,EAAMwC,QAA+B,IAAfxH,EAAIwH,QAAgBX,GAAMsF,YAAY1H,GAC9D,OAAOA,EAGT,IAAI2H,EAAWlK,GAAOyB,MAAMC,EAAQ,CAClCnE,GAAIO,EACJ6B,MAAOjN,GAAKsN,GAAO0D,QAAQhC,EAAQhP,KAEjCuT,EAAYiE,EAAWA,EAAS,GAAK,GAErCrH,EAAS,CACXL,OAFUxC,GAAO8C,MAAMpB,EAAQoB,GAG/BH,MAAO7E,GAELqM,GAAO,EAEX,IAAK,IAAK7G,EAAMxJ,KAASkG,GAAO0F,MAAMhE,EAAQ,CAC5CnE,GAAIsF,EACJlD,MAAOsC,GAAKC,OACZH,SAAS,EACTH,UAEA,GAAIuI,EACFA,GAAO,OAIT,GAAkB,KAAd7G,EAAKa,MAAehC,GAAKiI,SAAStQ,EAAMmM,GAAY,CACtDnI,EAAM,CACJhE,OACAwL,OAAQhC,EAAKa,KAAKtR,QAEpB,KACF,CAGF,MAAO,CACL2P,OAAQM,EACRH,MAAO7E,EAEX,EAKA,KAAK4D,GACH,IAAIC,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,EACnF,OAAOoN,GAAOyB,MAAMC,EAAQJ,GAAgBA,GAAgB,CAAC,EAAGK,GAAU,CAAC,EAAG,CAC5EhC,MAAOjN,GAAKsN,GAAOqE,OAAO3C,EAAQhP,KAEtC,EAKA,kBAAAmV,CAAmBnG,EAAQxH,GACzB,IAAIjF,EAAQ+K,GAAOqF,cAAc3D,GACjC1B,GAAO+J,eAAerI,GAAQ,GAE9B,IACExH,GACF,CAAE,QACA8F,GAAO+J,eAAerI,EAAQzM,EAChC,CAEA+K,GAAOmH,UAAUzF,EACnB,GAIEgF,GAAO,CAITC,OAAO1R,GACElC,MAAMU,QAAQwB,IAA2B,IAAjBA,EAAMpC,QAAgBoC,EAAMoL,MAAM8B,GAAKmE,SAKtE+D,GAAc,CAAC,YACfC,GAAe,CAAC,QAChBC,GAAqB,IAAI7P,QAEzBmF,GAAO,CAIT,QAAA2K,CAASC,EAAM3Q,GACb,IAAIwJ,EAAOzD,GAAK9K,IAAI0V,EAAM3Q,GAE1B,GAAImI,GAAKC,OAAOoB,GACd,MAAM,IAAIlQ,MAAM,yCAAyC2D,OAAO+C,EAAM,gDAAgD/C,OAAO2T,GAASC,UAAUrH,KAGlJ,OAAOA,CACT,EAQA,UAACsH,CAAUH,EAAM3Q,GACf,IAAI6H,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,EAEnF,IAAK,IAAI6B,KAAK0N,GAAKyI,UAAU9Q,EAAM6H,GAAU,CAC3C,IACIoG,EAAQ,CADJlI,GAAK2K,SAASC,EAAMhW,GACZA,SACVsT,CACR,CACF,EAKA,KAAA8C,CAAMJ,EAAMK,GACV,GAAI7I,GAAKC,OAAOuI,GACd,MAAM,IAAIrX,MAAM,wCAAwC2D,OAAO2T,GAASC,UAAUF,KAGpF,IAAI5T,EAAI4T,EAAK1K,SAAS+K,GAEtB,GAAS,MAALjU,EACF,MAAM,IAAIzD,MAAM,8BAA8B2D,OAAO+T,EAAO,eAAe/T,OAAO2T,GAASC,UAAUF,KAGvG,OAAO5T,CACT,EAKA,SAACkJ,CAAS0K,EAAM3Q,GAWd,IAVA,IAAI6H,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,GAC/E,QACFmP,GAAU,GACRJ,EACA6I,EAAW3K,GAAK2K,SAASC,EAAM3Q,IAC/B,SACFiG,GACEyK,EACAM,EAAQ/I,EAAUhC,EAASlN,OAAS,EAAI,EAErCkP,EAAU+I,GAAS,EAAIA,EAAQ/K,EAASlN,QAAQ,CACrD,IAAIgY,EAAQhL,GAAKgL,MAAML,EAAUM,GAC7BC,EAAYjR,EAAK/C,OAAO+T,QACtB,CAACD,EAAOE,GACdD,EAAQ/I,EAAU+I,EAAQ,EAAIA,EAAQ,CACxC,CACF,EAKA,MAAAvC,CAAOkC,EAAM3Q,EAAMkR,GACjB,IAAIvW,EAAI0N,GAAKoG,OAAOzO,EAAMkR,GAE1B,MAAO,CADCnL,GAAK9K,IAAI0V,EAAMhW,GACZA,EACb,EAKA,UAAAwW,CAAWR,EAAM3Q,GACf,IAAIwJ,EAAOzD,GAAK9K,IAAI0V,EAAM3Q,GAE1B,GAAIkG,GAAOC,SAASqD,GAClB,MAAM,IAAIlQ,MAAM,2CAA2C2D,OAAO+C,EAAM,yDAAyD/C,OAAO2T,GAASC,UAAUrH,KAG7J,OAAOA,CACT,EAKA,YAAC4H,CAAYT,GACX,IAAI9I,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,EAEnF,IAAK,IAAK0Q,EAAMxJ,KAAS+F,GAAK6F,MAAM+E,EAAM9I,GACpB,IAAhB7H,EAAKjH,cAGD,CAACyQ,EAAMxJ,GAGnB,EAOA,SAACqR,CAASV,GACR,IAAI9I,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,EAEnF,IAAK,IAAK0Q,EAAMxJ,KAAS+F,GAAK6F,MAAM+E,EAAM9I,GACpCzB,GAAQN,UAAU0D,UACd,CAACA,EAAMxJ,GAGnB,EAKAsR,aAAa9H,GACPpD,GAAQC,WAAWmD,GACJtI,GAA2BsI,EAAM+G,IAIjCrP,GAA2BsI,EAAMgH,IAStD,KAAAjH,CAAMoH,EAAM3Q,GAIV,IAHA,IAAIrF,EAAIqF,EAAKnF,QACTjC,EAAImN,GAAK9K,IAAI0V,EAAMhW,GAEhB/B,IACDuP,GAAKC,OAAOxP,IAA4B,IAAtBA,EAAEqN,SAASlN,QAG/BH,EAAIA,EAAEqN,SAAS,GACftL,EAAEqD,KAAK,GAIX,MAAO,CAACpF,EAAG+B,EACb,EAKA,QAAA8O,CAASkH,EAAMlI,GACb,GAAIN,GAAKC,OAAOuI,GACd,MAAM,IAAIrX,MAAM,yDAAyD2D,OAAO2T,GAASC,UAAUF,KAGrG,IAAIY,EAAUnR,GAAG,CACf6F,SAAU0K,EAAK1K,WACdpN,IACD,IAAKmQ,EAAOhF,GAAO6G,GAAMvB,MAAMb,GAC3BsE,EAAchH,GAAK6F,MAAM/S,EAAG,CAC9BoP,SAAS,EACT+E,KAAMC,IACJ,IAAK,CAAEjN,GAAQiN,EACf,OAAQpC,GAAM6B,SAASjE,EAAOzI,EAAK,IAIvC,IAAK,IAAK,CAAEA,KAAS+M,EAAa,CAChC,IAAKlC,GAAM6B,SAASjE,EAAOzI,GAAO,CAChC,IAAIyM,EAAS1G,GAAK0G,OAAO5T,EAAGmH,GACxBgR,EAAQhR,EAAKA,EAAKjH,OAAS,GAC/B0T,EAAOxG,SAASuL,OAAOR,EAAO,EAChC,CAEA,GAAI3I,GAAKC,OAAOtI,EAAMgE,EAAIhE,MAAO,CAC/B,IAAI0L,EAAO3F,GAAK2F,KAAK7S,EAAGmH,GACxB0L,EAAKrB,KAAOqB,EAAKrB,KAAKxP,MAAM,EAAGmJ,EAAIwH,OACrC,CAEA,GAAInD,GAAKC,OAAOtI,EAAMgJ,EAAMhJ,MAAO,CACjC,IAAIyR,EAAQ1L,GAAK2F,KAAK7S,EAAGmH,GAEzByR,EAAMpH,KAAOoH,EAAMpH,KAAKxP,MAAMmO,EAAMwC,OACtC,CACF,CAEItF,GAAOC,SAAStN,KAClBA,EAAEmP,UAAY,KAChB,IAEF,OAAOuJ,EAAQtL,QACjB,EAMA,GAAAhL,CAAI0V,EAAM3Q,GAGR,IAFA,IAAIwJ,EAAOmH,EAEFxX,EAAI,EAAGA,EAAI6G,EAAKjH,OAAQI,IAAK,CACpC,IAAIwB,EAAIqF,EAAK7G,GAEb,GAAIgP,GAAKC,OAAOoB,KAAUA,EAAKvD,SAAStL,GACtC,MAAM,IAAIrB,MAAM,qCAAqC2D,OAAO+C,EAAM,eAAe/C,OAAO2T,GAASC,UAAUF,KAG7GnH,EAAOA,EAAKvD,SAAStL,EACvB,CAEA,OAAO6O,CACT,EAKA,GAAArP,CAAIwW,EAAM3Q,GAGR,IAFA,IAAIwJ,EAAOmH,EAEFxX,EAAI,EAAGA,EAAI6G,EAAKjH,OAAQI,IAAK,CACpC,IAAIwB,EAAIqF,EAAK7G,GAEb,GAAIgP,GAAKC,OAAOoB,KAAUA,EAAKvD,SAAStL,GACtC,OAAO,EAGT6O,EAAOA,EAAKvD,SAAStL,EACvB,CAEA,OAAO,CACT,EAKA+W,OAAOvW,GACEgN,GAAKC,OAAOjN,IAAUiL,GAAQN,UAAU3K,IAAU+K,GAAOC,SAAShL,GAM3E,UAAA6K,CAAW7K,GACT,IAAKlC,MAAMU,QAAQwB,GACjB,OAAO,EAGT,IAAIwW,EAAelB,GAAmBxV,IAAIE,GAE1C,QAAqB1C,IAAjBkZ,EACF,OAAOA,EAGT,IAAI3L,EAAa7K,EAAMoL,OAAMC,GAAOT,GAAK2L,OAAOlL,KAEhD,OADAiK,GAAmBpW,IAAIc,EAAO6K,GACvBA,CACT,EAKA,IAAAyF,CAAKkF,EAAM3Q,GAIT,IAHA,IAAIrF,EAAIqF,EAAKnF,QACTjC,EAAImN,GAAK9K,IAAI0V,EAAMhW,GAEhB/B,IACDuP,GAAKC,OAAOxP,IAA4B,IAAtBA,EAAEqN,SAASlN,QADzB,CAIN,IAAII,EAAIP,EAAEqN,SAASlN,OAAS,EAC5BH,EAAIA,EAAEqN,SAAS9M,GACfwB,EAAEqD,KAAK7E,EAEX,CAEA,MAAO,CAACP,EAAG+B,EACb,EAKA,IAAA+Q,CAAKiF,EAAM3Q,GACT,IAAIwJ,EAAOzD,GAAK9K,IAAI0V,EAAM3Q,GAE1B,IAAKmI,GAAKC,OAAOoB,GACf,MAAM,IAAIlQ,MAAM,qCAAqC2D,OAAO+C,EAAM,4CAA4C/C,OAAO2T,GAASC,UAAUrH,KAG1I,OAAOA,CACT,EAQA,OAACtB,CAAOyI,EAAM3Q,GACZ,IAAI6H,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,EAEnF,IAAK,IAAI6B,KAAK0N,GAAKH,OAAOlI,EAAM6H,GAAU,CACxC,IAAIjP,EAAImN,GAAK9K,IAAI0V,EAAMhW,QACjB,CAAC/B,EAAG+B,EACZ,CACF,EAKAmM,QAAO,CAAC0C,EAAM9C,IACLN,GAAQN,UAAU0D,IAASpD,GAAQK,eAAeC,IAAUN,GAAQU,QAAQ0C,EAAM9C,IAAUyB,GAAKC,OAAOoB,IAASrB,GAAKyJ,YAAYlL,IAAUyB,GAAKrB,QAAQ0C,EAAM9C,GAQxK,MAACkF,CAAM+E,GAcL,IAbA,IAAI9I,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,GAC/E,KACFkU,EAAI,QACJ/E,GAAU,GACRJ,GACA,KACF3J,EAAO,GAAE,GACToO,GACEzE,EACAgK,EAAU,IAAInX,IACdC,EAAI,GACJ/B,EAAI+X,GAGFrE,KAAOrE,EAAUI,GAAKiI,SAAS3V,EAAG2R,GAAMjE,GAAKyJ,QAAQnX,EAAG2R,KAS5D,GALKuF,EAAQ1X,IAAIvB,UACT,CAACA,EAAG+B,IAIPkX,EAAQ1X,IAAIvB,IAAOuP,GAAKC,OAAOxP,IAA4B,IAAtBA,EAAEqN,SAASlN,QAAyB,MAARiU,IAAiC,IAAjBA,EAAK,CAACpU,EAAG+B,IAA/F,CAcA,GAAiB,IAAbA,EAAE5B,OACJ,MAIF,IAAKkP,EAAS,CACZ,IAAI8J,EAAU1J,GAAK+D,KAAKzR,GAExB,GAAIoL,GAAK5L,IAAIwW,EAAMoB,GAAU,CAC3BpX,EAAIoX,EACJnZ,EAAImN,GAAK9K,IAAI0V,EAAMhW,GACnB,QACF,CACF,CAGA,GAAIsN,GAA+B,IAApBtN,EAAEA,EAAE5B,OAAS,GAG1B4B,EAFe0N,GAAK0D,SAASpR,GAG7B/B,EAAImN,GAAK9K,IAAI0V,EAAMhW,QAKrBA,EAAI0N,GAAKoE,OAAO9R,GAChB/B,EAAImN,GAAK9K,IAAI0V,EAAMhW,GACnBkX,EAAQvX,IAAI1B,EA9BZ,KAXA,CACEiZ,EAAQvX,IAAI1B,GACZ,IAAIoZ,EAAY/J,EAAUrP,EAAEqN,SAASlN,OAAS,EAAI,EAE9CsP,GAAKhC,WAAW1L,EAAGuD,KACrB8T,EAAY9T,EAAKvD,EAAE5B,SAGrB4B,EAAIA,EAAEsC,OAAO+U,GACbpZ,EAAImN,GAAK9K,IAAI0V,EAAMhW,EAErB,CAgCJ,EAKA,MAAA8R,CAAOkE,EAAM3Q,GACX,IAAIqO,EAAahG,GAAKoE,OAAOzM,GACzBrF,EAAIoL,GAAK9K,IAAI0V,EAAMtC,GAEvB,GAAIlG,GAAKC,OAAOzN,GACd,MAAM,IAAIrB,MAAM,kCAAkC2D,OAAO+C,EAAM,6CAGjE,OAAOrF,CACT,EASA8U,OAAOjG,GACDrB,GAAKC,OAAOoB,GACPA,EAAKa,KAELb,EAAKvD,SAAS6H,IAAI/H,GAAK0J,QAAQhC,KAAK,IAO/C,MAACwE,CAAMtB,GACL,IAAI9I,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,EAEnF,IAAK,IAAK0Q,EAAMxJ,KAAS+F,GAAK6F,MAAM+E,EAAM9I,GACpCM,GAAKC,OAAOoB,UACR,CAACA,EAAMxJ,GAGnB,GAIF,SAASkS,GAAU/K,EAAQC,GAAkB,IAAIrN,EAAO7B,OAAO6B,KAAKoN,GAAS,GAAIjP,OAAOwG,sBAAuB,CAAE,IAAI2I,EAAUnP,OAAOwG,sBAAsByI,GAAaC,IAAkBC,EAAUA,EAAQC,QAAO,SAAUC,GAAO,OAAOrP,OAAOkF,yBAAyB+J,EAAQI,GAAKrM,UAAY,KAAMnB,EAAKiE,KAAK3E,MAAMU,EAAMsN,EAAU,CAAE,OAAOtN,CAAM,CAE1V,SAASoY,GAAgB9Q,GAAU,IAAK,IAAIlI,EAAI,EAAGA,EAAIL,UAAUC,OAAQI,IAAK,CAAE,IAAIgI,EAAyB,MAAhBrI,UAAUK,GAAaL,UAAUK,GAAK,CAAC,EAAOA,EAAI,EAAK+Y,GAAUha,OAAOiJ,IAAS,GAAMlH,SAAQ,SAAUyG,GAAOF,GAAgBa,EAAQX,EAAKS,EAAOT,GAAO,IAAexI,OAAO0G,0BAA6B1G,OAAOuP,iBAAiBpG,EAAQnJ,OAAO0G,0BAA0BuC,IAAmB+Q,GAAUha,OAAOiJ,IAASlH,SAAQ,SAAUyG,GAAOxI,OAAO8G,eAAeqC,EAAQX,EAAKxI,OAAOkF,yBAAyB+D,EAAQT,GAAO,GAAM,CAAE,OAAOW,CAAQ,CAE3hB,IAAI0J,GAAY,CAIdqH,gBAAgBjX,GACP4P,GAAUsH,YAAYlX,IAAUA,EAAMuH,KAAK4P,SAAS,SAM7D,WAAAD,CAAYlX,GACV,IAAK7C,EAAc6C,GACjB,OAAO,EAGT,OAAQA,EAAMuH,MACZ,IAAK,cAYL,IAAK,cACH,OAAO2F,GAAKmE,OAAOrR,EAAM6E,OAAS+F,GAAK2L,OAAOvW,EAAMqO,MAVtD,IAAK,cAYL,IAAK,cACH,MAA+B,iBAAjBrO,EAAMqQ,QAA6C,iBAAfrQ,EAAMkP,MAAqBhC,GAAKmE,OAAOrR,EAAM6E,MAVjG,IAAK,aACH,MAAiC,iBAAnB7E,EAAMoX,UAAyBlK,GAAKmE,OAAOrR,EAAM6E,OAAS1H,EAAc6C,EAAMqX,YAE9F,IAAK,YACH,OAAOnK,GAAKmE,OAAOrR,EAAM6E,OAASqI,GAAKmE,OAAOrR,EAAM4W,SAQtD,IAAK,WACH,OAAO1J,GAAKmE,OAAOrR,EAAM6E,OAAS1H,EAAc6C,EAAMqX,aAAela,EAAc6C,EAAMsX,eAE3F,IAAK,gBACH,OAA4B,OAArBtX,EAAMqX,YAAuB3H,GAAMC,QAAQ3P,EAAMsX,gBAA0C,OAAxBtX,EAAMsX,eAA0B5H,GAAMC,QAAQ3P,EAAMqX,aAAela,EAAc6C,EAAMqX,aAAela,EAAc6C,EAAMsX,eAEtM,IAAK,aACH,OAAOpK,GAAKmE,OAAOrR,EAAM6E,OAAmC,iBAAnB7E,EAAMoX,UAAyBja,EAAc6C,EAAMqX,YAE9F,QACE,OAAO,EAEb,EAKAxH,gBAAgB7P,GACPlC,MAAMU,QAAQwB,IAAUA,EAAMoL,OAAMC,GAAOuE,GAAUsH,YAAY7L,KAM1EkM,qBAAqBvX,GACZ4P,GAAUsH,YAAYlX,IAAUA,EAAMuH,KAAK4P,SAAS,cAM7DK,gBAAgBxX,GACP4P,GAAUsH,YAAYlX,IAAUA,EAAMuH,KAAK4P,SAAS,SAO7D,OAAAM,CAAQ3S,GACN,OAAQA,EAAGyC,MACT,IAAK,cAED,OAAOyP,GAAgBA,GAAgB,CAAC,EAAGlS,GAAK,CAAC,EAAG,CAClDyC,KAAM,gBAIZ,IAAK,cAED,OAAOyP,GAAgBA,GAAgB,CAAC,EAAGlS,GAAK,CAAC,EAAG,CAClDyC,KAAM,gBAIZ,IAAK,aAED,OAAOyP,GAAgBA,GAAgB,CAAC,EAAGlS,GAAK,CAAC,EAAG,CAClDyC,KAAM,aACN1C,KAAMqI,GAAK0D,SAAS9L,EAAGD,QAI7B,IAAK,YAED,IAAI,QACF+R,EAAO,KACP/R,GACEC,EAEJ,GAAIoI,GAAKC,OAAOyJ,EAAS/R,GACvB,OAAOC,EAKT,GAAIoI,GAAKwK,UAAU7S,EAAM+R,GACvB,OAAOI,GAAgBA,GAAgB,CAAC,EAAGlS,GAAK,CAAC,EAAG,CAClDD,KAAM+R,EACNA,QAAS/R,IAUb,IAAI8S,EAAczK,GAAK0K,UAAU/S,EAAMC,GACnC+S,EAAiB3K,GAAK0K,UAAU1K,GAAK+D,KAAKpM,GAAOC,GACrD,OAAOkS,GAAgBA,GAAgB,CAAC,EAAGlS,GAAK,CAAC,EAAG,CAClDD,KAAM8S,EACNf,QAASiB,IAIf,IAAK,cAED,OAAOb,GAAgBA,GAAgB,CAAC,EAAGlS,GAAK,CAAC,EAAG,CAClDyC,KAAM,gBAIZ,IAAK,cAED,OAAOyP,GAAgBA,GAAgB,CAAC,EAAGlS,GAAK,CAAC,EAAG,CAClDyC,KAAM,gBAIZ,IAAK,WAED,IAAI,WACF8P,EAAU,cACVC,GACExS,EACJ,OAAOkS,GAAgBA,GAAgB,CAAC,EAAGlS,GAAK,CAAC,EAAG,CAClDuS,WAAYC,EACZA,cAAeD,IAIrB,IAAK,gBAED,IACEA,WAAYS,EACZR,cAAeS,GACbjT,EAEJ,OACSkS,GAAgBA,GAAgB,CAAC,EAAGlS,GAAK,CAAC,EADhC,MAAfgT,EACkD,CAClDT,WAAYU,EACZT,cAAe,MAEU,MAAlBS,EAC2C,CAClDV,WAAY,KACZC,cAAeQ,GAGmC,CAClDT,WAAYU,EACZT,cAAeQ,IAKvB,IAAK,aAED,OAAOd,GAAgBA,GAAgB,CAAC,EAAGlS,GAAK,CAAC,EAAG,CAClDyC,KAAM,aACN1C,KAAMqI,GAAK+D,KAAKnM,EAAGD,QAI7B,GAKEqI,GAAO,CAOT,SAAAyI,CAAU9Q,GACR,IAAI6H,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,GAC/E,QACFmP,GAAU,GACRJ,EACAsL,EAAQ9K,GAAKH,OAAOlI,EAAM6H,GAQ9B,OALEsL,EADElL,EACMkL,EAAMtY,MAAM,GAEZsY,EAAMtY,MAAM,GAAI,EAI5B,EAKA,MAAA4T,CAAOzO,EAAMkR,GAGX,IAFA,IAAIzC,EAAS,GAEJtV,EAAI,EAAGA,EAAI6G,EAAKjH,QAAUI,EAAI+X,EAAQnY,OAAQI,IAAK,CAC1D,IAAIia,EAAKpT,EAAK7G,GAGd,GAAIia,IAFKlC,EAAQ/X,GAGf,MAGFsV,EAAOzQ,KAAKoV,EACd,CAEA,OAAO3E,CACT,EAUA,OAAAtB,CAAQnN,EAAMkR,GAGZ,IAFA,IAAImC,EAAMC,KAAKD,IAAIrT,EAAKjH,OAAQmY,EAAQnY,QAE/BI,EAAI,EAAGA,EAAIka,EAAKla,IAAK,CAC5B,GAAI6G,EAAK7G,GAAK+X,EAAQ/X,GAAI,OAAQ,EAClC,GAAI6G,EAAK7G,GAAK+X,EAAQ/X,GAAI,OAAO,CACnC,CAEA,OAAO,CACT,EAKA,SAAAoa,CAAUvT,EAAMkR,GACd,IAAI/X,EAAI6G,EAAKjH,OAAS,EAClBya,EAAKxT,EAAKnF,MAAM,EAAG1B,GACnBsa,EAAKvC,EAAQrW,MAAM,EAAG1B,GACtBia,EAAKpT,EAAK7G,GACVua,EAAKxC,EAAQ/X,GACjB,OAAOkP,GAAKC,OAAOkL,EAAIC,IAAOL,EAAKM,CACrC,EAKA,MAAAC,CAAO3T,EAAMkR,GACX,IAAI/X,EAAI6G,EAAKjH,OACTya,EAAKxT,EAAKnF,MAAM,EAAG1B,GACnBsa,EAAKvC,EAAQrW,MAAM,EAAG1B,GAC1B,OAAOkP,GAAKC,OAAOkL,EAAIC,EACzB,EAKA,UAAAG,CAAW5T,EAAMkR,GACf,IAAI/X,EAAI6G,EAAKjH,OAAS,EAClBya,EAAKxT,EAAKnF,MAAM,EAAG1B,GACnBsa,EAAKvC,EAAQrW,MAAM,EAAG1B,GACtBia,EAAKpT,EAAK7G,GACVua,EAAKxC,EAAQ/X,GACjB,OAAOkP,GAAKC,OAAOkL,EAAIC,IAAOL,EAAKM,CACrC,EAKApL,OAAM,CAACtI,EAAMkR,IACJlR,EAAKjH,SAAWmY,EAAQnY,QAAUiH,EAAKuG,OAAM,CAAC3N,EAAGO,IAAMP,IAAMsY,EAAQ/X,KAM9E0a,YAAY7T,GACHA,EAAKA,EAAKjH,OAAS,GAAK,EAMjC+Y,QAAO,CAAC9R,EAAMkR,IAC2B,IAAhC7I,GAAK8E,QAAQnN,EAAMkR,GAM5B7K,WAAU,CAACrG,EAAMkR,IACRlR,EAAKjH,OAASmY,EAAQnY,QAA0C,IAAhCsP,GAAK8E,QAAQnN,EAAMkR,GAM5DZ,SAAQ,CAACtQ,EAAMkR,KAC2B,IAAjC7I,GAAK8E,QAAQnN,EAAMkR,GAM5B4C,QAAO,CAAC9T,EAAMkR,IACLlR,EAAKjH,SAAWmY,EAAQnY,OAAS,GAAqC,IAAhCsP,GAAK8E,QAAQnN,EAAMkR,GAMlE6C,SAAQ,CAAC/T,EAAMkR,IACNlR,EAAKjH,QAAUmY,EAAQnY,QAA0C,IAAhCsP,GAAK8E,QAAQnN,EAAMkR,GAM7D8C,aAAY,CAAChU,EAAMkR,IACVlR,EAAKjH,OAASmY,EAAQnY,QAA0C,IAAhCsP,GAAK8E,QAAQnN,EAAMkR,GAM5D+C,SAAQ,CAACjU,EAAMkR,IACNlR,EAAKjH,OAAS,IAAMmY,EAAQnY,QAA0C,IAAhCsP,GAAK8E,QAAQnN,EAAMkR,GAMlE1E,OAAOrR,GACElC,MAAMU,QAAQwB,KAA4B,IAAjBA,EAAMpC,QAAoC,iBAAboC,EAAM,IAMrE,SAAA0X,CAAU7S,EAAMkR,GACd,GAAIlR,EAAKjH,SAAWmY,EAAQnY,OAC1B,OAAO,EAGT,IAAIya,EAAKxT,EAAKnF,MAAM,GAAI,GACpB4Y,EAAKvC,EAAQrW,MAAM,GAAI,GAG3B,OAFSmF,EAAKA,EAAKjH,OAAS,KACnBmY,EAAQA,EAAQnY,OAAS,IACdsP,GAAKC,OAAOkL,EAAIC,EACtC,EASA,MAAAvL,CAAOlI,GAOL,IANA,IAAI6H,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,GAC/E,QACFmP,GAAU,GACRJ,EACAqM,EAAO,GAEF/a,EAAI,EAAGA,GAAK6G,EAAKjH,OAAQI,IAChC+a,EAAKlW,KAAKgC,EAAKnF,MAAM,EAAG1B,IAO1B,OAJI8O,GACFiM,EAAKjM,UAGAiM,CACT,EAKA,IAAA9H,CAAKpM,GACH,GAAoB,IAAhBA,EAAKjH,OACP,MAAM,IAAIO,MAAM,4CAA4C2D,OAAO+C,EAAM,qCAG3E,IAAIyL,EAAOzL,EAAKA,EAAKjH,OAAS,GAC9B,OAAOiH,EAAKnF,MAAM,GAAI,GAAGoC,OAAOwO,EAAO,EACzC,EASA,yBAAA0I,CAA0BC,GACxB,OAAQA,EAAU1R,MAChB,IAAK,cACL,IAAK,cACL,IAAK,aACL,IAAK,aACL,IAAK,YACH,OAAO,EAET,QACE,OAAO,EAEb,EAKA,MAAA+J,CAAOzM,GACL,GAAoB,IAAhBA,EAAKjH,OACP,MAAM,IAAIO,MAAM,gDAAgD2D,OAAO+C,EAAM,OAG/E,OAAOA,EAAKnF,MAAM,GAAI,EACxB,EAKA,QAAAkR,CAAS/L,GACP,GAAoB,IAAhBA,EAAKjH,OACP,MAAM,IAAIO,MAAM,gDAAgD2D,OAAO+C,EAAM,yCAG/E,IAAIyL,EAAOzL,EAAKA,EAAKjH,OAAS,GAE9B,GAAI0S,GAAQ,EACV,MAAM,IAAInS,MAAM,uDAAuD2D,OAAO+C,EAAM,mDAGtF,OAAOA,EAAKnF,MAAM,GAAI,GAAGoC,OAAOwO,EAAO,EACzC,EAKA,QAAA4I,CAASrU,EAAM0Q,GACb,IAAKrI,GAAKhC,WAAWqK,EAAU1Q,KAAUqI,GAAKC,OAAOtI,EAAM0Q,GACzD,MAAM,IAAIpX,MAAM,oCAAoC2D,OAAO+C,EAAM,uBAAuB/C,OAAOyT,EAAU,qDAG3G,OAAO1Q,EAAKnF,MAAM6V,EAAS3X,OAC7B,EAKA,SAAAga,CAAU/S,EAAMoU,GACd,IAAIvM,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,EACnF,IAAKkH,EAAM,OAAO,KAElB,IAAIrF,EAAI,IAAIqF,IACR,SACF6O,EAAW,WACThH,EAEJ,GAAoB,IAAhB7H,EAAKjH,OACP,OAAO4B,EAGT,OAAQyZ,EAAU1R,MAChB,IAAK,cAED,IACE1C,KAAMC,GACJmU,GAEA/L,GAAKC,OAAOrI,EAAItF,IAAM0N,GAAKuL,WAAW3T,EAAItF,IAAM0N,GAAKhC,WAAWpG,EAAItF,MACtEA,EAAEsF,EAAGlH,OAAS,IAAM,GAGtB,MAGJ,IAAK,cAED,IACEiH,KAAMsU,GACJF,EAEJ,GAAI/L,GAAKC,OAAOgM,EAAK3Z,IAAM0N,GAAKhC,WAAWiO,EAAK3Z,GAC9C,OAAO,KACE0N,GAAKuL,WAAWU,EAAK3Z,KAC9BA,EAAE2Z,EAAIvb,OAAS,IAAM,GAGvB,MAGJ,IAAK,aAED,IACEiH,KAAMuU,EAAI,SACVhC,GACE6B,EAEA/L,GAAKC,OAAOiM,EAAM5Z,IAAM0N,GAAKuL,WAAWW,EAAM5Z,GAChDA,EAAE4Z,EAAKxb,OAAS,IAAM,EACbsP,GAAKhC,WAAWkO,EAAM5Z,KAC/BA,EAAE4Z,EAAKxb,OAAS,IAAM,EACtB4B,EAAE4Z,EAAKxb,SAAWwZ,GAGpB,MAGJ,IAAK,aAED,IACEvS,KAAMwU,EACNjC,SAAUkC,GACRL,EAEJ,GAAI/L,GAAKC,OAAOkM,EAAM7Z,IACpB,GAAiB,YAAbkU,EACFlU,EAAEA,EAAE5B,OAAS,IAAM,OACd,GAAiB,aAAb8V,EACT,OAAO,UAEAxG,GAAKuL,WAAWY,EAAM7Z,GAC/BA,EAAE6Z,EAAKzb,OAAS,IAAM,EACbsP,GAAKhC,WAAWmO,EAAM7Z,IAAMqF,EAAKwU,EAAKzb,SAAW0b,IAC1D9Z,EAAE6Z,EAAKzb,OAAS,IAAM,EACtB4B,EAAE6Z,EAAKzb,SAAW0b,GAGpB,MAGJ,IAAK,YAED,IACEzU,KAAM0U,EACN3C,QAAS4C,GACPP,EAEJ,GAAI/L,GAAKC,OAAOoM,EAAMC,GACpB,OAAOha,EAGT,GAAI0N,GAAKhC,WAAWqO,EAAM/Z,IAAM0N,GAAKC,OAAOoM,EAAM/Z,GAAI,CACpD,IAAIia,EAAOD,EAAI9Z,QAMf,OAJIwN,GAAKuL,WAAWc,EAAMC,IAAQD,EAAK3b,OAAS4b,EAAI5b,SAClD6b,EAAKF,EAAK3b,OAAS,IAAM,GAGpB6b,EAAK3X,OAAOtC,EAAEE,MAAM6Z,EAAK3b,QAClC,CAAWsP,GAAKwK,UAAU6B,EAAMC,KAAStM,GAAKhC,WAAWsO,EAAKha,IAAM0N,GAAKC,OAAOqM,EAAKha,IAC/E0N,GAAKuL,WAAWc,EAAM/Z,GACxBA,EAAE+Z,EAAK3b,OAAS,IAAM,EAEtB4B,EAAE+Z,EAAK3b,OAAS,IAAM,EAEfsP,GAAKuL,WAAWe,EAAKha,IAAM0N,GAAKC,OAAOqM,EAAKha,IAAM0N,GAAKhC,WAAWsO,EAAKha,IAC5E0N,GAAKuL,WAAWc,EAAM/Z,KACxBA,EAAE+Z,EAAK3b,OAAS,IAAM,GAGxB4B,EAAEga,EAAI5b,OAAS,IAAM,GACZsP,GAAKuL,WAAWc,EAAM/Z,KAC3B0N,GAAKC,OAAOqM,EAAKha,KACnBA,EAAEga,EAAI5b,OAAS,IAAM,GAGvB4B,EAAE+Z,EAAK3b,OAAS,IAAM,GAO9B,OAAO4B,CACT,GAIF,SAASka,GAAU1N,EAAQC,GAAkB,IAAIrN,EAAO7B,OAAO6B,KAAKoN,GAAS,GAAIjP,OAAOwG,sBAAuB,CAAE,IAAI2I,EAAUnP,OAAOwG,sBAAsByI,GAAaC,IAAkBC,EAAUA,EAAQC,QAAO,SAAUC,GAAO,OAAOrP,OAAOkF,yBAAyB+J,EAAQI,GAAKrM,UAAY,KAAMnB,EAAKiE,KAAK3E,MAAMU,EAAMsN,EAAU,CAAE,OAAOtN,CAAM,CAE1V,SAAS+a,GAAgBzT,GAAU,IAAK,IAAIlI,EAAI,EAAGA,EAAIL,UAAUC,OAAQI,IAAK,CAAE,IAAIgI,EAAyB,MAAhBrI,UAAUK,GAAaL,UAAUK,GAAK,CAAC,EAAOA,EAAI,EAAK0b,GAAU3c,OAAOiJ,IAAS,GAAMlH,SAAQ,SAAUyG,GAAOF,GAAgBa,EAAQX,EAAKS,EAAOT,GAAO,IAAexI,OAAO0G,0BAA6B1G,OAAOuP,iBAAiBpG,EAAQnJ,OAAO0G,0BAA0BuC,IAAmB0T,GAAU3c,OAAOiJ,IAASlH,SAAQ,SAAUyG,GAAOxI,OAAO8G,eAAeqC,EAAQX,EAAKxI,OAAOkF,yBAAyB+D,EAAQT,GAAO,GAAM,CAAE,OAAOW,CAAQ,CAE3hB,IAAI8J,GAAQ,CAKV,OAAAgC,CAAQxE,EAAOuI,GACb,IAAI6D,EAAS1M,GAAK8E,QAAQxE,EAAM3I,KAAMkR,EAAQlR,MAE9C,OAAe,IAAX+U,EACEpM,EAAM6C,OAAS0F,EAAQ1F,QAAgB,EACvC7C,EAAM6C,OAAS0F,EAAQ1F,OAAe,EACnC,EAGFuJ,CACT,EAKAjD,QAAO,CAACnJ,EAAOuI,IAC4B,IAAlC/F,GAAMgC,QAAQxE,EAAOuI,GAM9BZ,SAAQ,CAAC3H,EAAOuI,KAC4B,IAAnC/F,GAAMgC,QAAQxE,EAAOuI,GAM9B5I,OAAM,CAACK,EAAOuI,IAELvI,EAAM6C,SAAW0F,EAAQ1F,QAAUnD,GAAKC,OAAOK,EAAM3I,KAAMkR,EAAQlR,MAM5E0O,QAAQvT,GACC7C,EAAc6C,IAAkC,iBAAjBA,EAAMqQ,QAAuBnD,GAAKmE,OAAOrR,EAAM6E,MAMvF,SAAA+S,CAAUpK,EAAO1I,GACf,IAAI4H,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,EACnF,OAAOsH,GAAGuI,GAAOhO,IACf,GAAU,OAANA,EACF,OAAO,KAGT,IAAI,SACFkU,EAAW,WACThH,GACA,KACF7H,EAAI,OACJwL,GACE7Q,EAEJ,OAAQsF,EAAGyC,MACT,IAAK,cACL,IAAK,YAED/H,EAAEqF,KAAOqI,GAAK0K,UAAU/S,EAAMC,EAAI4H,GAClC,MAGJ,IAAK,cAEGQ,GAAKC,OAAOrI,EAAGD,KAAMA,KAAUC,EAAGuL,OAASA,GAAUvL,EAAGuL,SAAWA,GAAuB,YAAbqD,KAC/ElU,EAAE6Q,QAAUvL,EAAGoK,KAAKtR,QAGtB,MAGJ,IAAK,aAEGsP,GAAKC,OAAOrI,EAAGD,KAAMA,KACvBrF,EAAE6Q,QAAUvL,EAAGsS,UAGjB5X,EAAEqF,KAAOqI,GAAK0K,UAAU/S,EAAMC,EAAI4H,GAClC,MAGJ,IAAK,cAEGQ,GAAKC,OAAOrI,EAAGD,KAAMA,IAASC,EAAGuL,QAAUA,IAC7C7Q,EAAE6Q,QAAU8H,KAAKD,IAAI7H,EAASvL,EAAGuL,OAAQvL,EAAGoK,KAAKtR,SAGnD,MAGJ,IAAK,cAED,GAAIsP,GAAKC,OAAOrI,EAAGD,KAAMA,IAASqI,GAAKhC,WAAWpG,EAAGD,KAAMA,GACzD,OAAO,KAGTrF,EAAEqF,KAAOqI,GAAK0K,UAAU/S,EAAMC,EAAI4H,GAClC,MAGJ,IAAK,aAED,GAAIQ,GAAKC,OAAOrI,EAAGD,KAAMA,GAAO,CAC9B,GAAIC,EAAGsS,WAAa/G,GAAsB,MAAZqD,EAC5B,OAAO,MACE5O,EAAGsS,SAAW/G,GAAUvL,EAAGsS,WAAa/G,GAAuB,YAAbqD,KAC3DlU,EAAE6Q,QAAUvL,EAAGsS,SACf5X,EAAEqF,KAAOqI,GAAK0K,UAAU/S,EAAMC,EAAI6U,GAAgBA,GAAgB,CAAC,EAAGjN,GAAU,CAAC,EAAG,CAClFgH,SAAU,aAGhB,MACElU,EAAEqF,KAAOqI,GAAK0K,UAAU/S,EAAMC,EAAI4H,GAK1C,GAEJ,GAIEmN,GAAc,CAAC,SAAU,SAE7B,SAASC,GAAU9N,EAAQC,GAAkB,IAAIrN,EAAO7B,OAAO6B,KAAKoN,GAAS,GAAIjP,OAAOwG,sBAAuB,CAAE,IAAI2I,EAAUnP,OAAOwG,sBAAsByI,GAAaC,IAAkBC,EAAUA,EAAQC,QAAO,SAAUC,GAAO,OAAOrP,OAAOkF,yBAAyB+J,EAAQI,GAAKrM,UAAY,KAAMnB,EAAKiE,KAAK3E,MAAMU,EAAMsN,EAAU,CAAE,OAAOtN,CAAM,CAI1V,IAAI8Q,GAAQ,CAKV,KAAAvB,CAAMb,GACJ,IAAIZ,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,GAC/E,QACFmP,GAAU,GACRJ,GACA,OACFa,EAAM,MACNG,GACEJ,EACJ,OAAOoC,GAAMqK,WAAWzM,KAAWR,EAAU,CAACS,EAAQG,GAAS,CAACA,EAAOH,EACzE,EAKA,GAAA1E,CAAIyE,GACF,IAAK,CAAEzE,GAAO6G,GAAMvB,MAAMb,GAC1B,OAAOzE,CACT,EAKAsE,OAAM,CAACG,EAAOyI,IACL/F,GAAM7C,OAAOG,EAAMC,OAAQwI,EAAQxI,SAAWyC,GAAM7C,OAAOG,EAAMI,MAAOqI,EAAQrI,OAMzF,QAAA6D,CAASjE,EAAOpH,GACd,GAAIwJ,GAAMC,QAAQzJ,GAAS,CACzB,GAAIwJ,GAAM6B,SAASjE,EAAOpH,EAAOqH,SAAWmC,GAAM6B,SAASjE,EAAOpH,EAAOwH,OACvE,OAAO,EAGT,IAAKsM,EAAIC,GAAMvK,GAAMvB,MAAMb,IACtB4M,EAAIC,GAAMzK,GAAMvB,MAAMjI,GAC3B,OAAO8J,GAAMmF,SAAS6E,EAAIE,IAAOlK,GAAM2G,QAAQsD,EAAIE,EACrD,CAEA,IAAKtM,EAAOhF,GAAO6G,GAAMvB,MAAMb,GAC3B8M,GAAe,EACfC,GAAc,EAUlB,OARIrK,GAAMuD,QAAQrN,IAChBkU,EAAepK,GAAMgC,QAAQ9L,EAAQ2H,IAAU,EAC/CwM,EAAcrK,GAAMgC,QAAQ9L,EAAQ2C,IAAQ,IAE5CuR,EAAelN,GAAK8E,QAAQ9L,EAAQ2H,EAAMhJ,OAAS,EACnDwV,EAAcnN,GAAK8E,QAAQ9L,EAAQ2C,EAAIhE,OAAS,GAG3CuV,GAAgBC,CACzB,EAKA,YAAAC,CAAahN,EAAOyI,GAClB,IAAIwE,EAAOxU,GAA2BuH,EAAOuM,KAExCW,EAAIC,GAAM/K,GAAMvB,MAAMb,IACtBoN,EAAIC,GAAMjL,GAAMvB,MAAM4H,GACvBlI,EAAQmC,GAAMmF,SAASqF,EAAIE,GAAMA,EAAKF,EACtC3R,EAAMmH,GAAMmF,SAASsF,EAAIE,GAAMF,EAAKE,EAExC,OAAI3K,GAAMmF,SAAStM,EAAKgF,GACf,KA3Eb,SAAyB3H,GAAU,IAAK,IAAIlI,EAAI,EAAGA,EAAIL,UAAUC,OAAQI,IAAK,CAAE,IAAIgI,EAAyB,MAAhBrI,UAAUK,GAAaL,UAAUK,GAAK,CAAC,EAAOA,EAAI,EAAK8b,GAAU/c,OAAOiJ,IAAS,GAAMlH,SAAQ,SAAUyG,GAAOF,GAAgBa,EAAQX,EAAKS,EAAOT,GAAO,IAAexI,OAAO0G,0BAA6B1G,OAAOuP,iBAAiBpG,EAAQnJ,OAAO0G,0BAA0BuC,IAAmB8T,GAAU/c,OAAOiJ,IAASlH,SAAQ,SAAUyG,GAAOxI,OAAO8G,eAAeqC,EAAQX,EAAKxI,OAAOkF,yBAAyB+D,EAAQT,GAAO,GAAM,CAAE,OAAOW,CAAQ,CA6E9gB0U,CAAgB,CACrBrN,OAAQM,EACRH,MAAO7E,GACN0R,EAEP,EAMA,UAAAR,CAAWzM,GACT,IAAI,OACFC,EAAM,MACNG,GACEJ,EACJ,OAAO0C,GAAM2G,QAAQpJ,EAAQG,EAC/B,EAMA,WAAAsH,CAAY1H,GACV,IAAI,OACFC,EAAM,MACNG,GACEJ,EACJ,OAAO0C,GAAM7C,OAAOI,EAAQG,EAC9B,EAOA8C,WAAWlD,IACDoC,GAAMsF,YAAY1H,GAQ5BuN,UAAUvN,IACAoC,GAAMqK,WAAWzM,GAM3BqC,QAAQ3P,GACC7C,EAAc6C,IAAUgQ,GAAMuD,QAAQvT,EAAMuN,SAAWyC,GAAMuD,QAAQvT,EAAM0N,OAMpF,OAACoN,CAAOxN,QACA,CAACA,EAAMC,OAAQ,eACf,CAACD,EAAMI,MAAO,QACtB,EAKA,KAAAG,CAAMP,GACJ,IAAKO,GAAS6B,GAAMvB,MAAMb,GAC1B,OAAOO,CACT,EAKA,SAAA+J,CAAUtK,EAAOxI,GACf,IAAI4H,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,EACnF,OAAOsH,GAAGqI,GAAO5P,IACf,GAAU,OAANA,EACF,OAAO,KAGT,IAGIqd,EACAC,GAJA,SACFtH,EAAW,UACThH,EAIJ,GAAiB,WAAbgH,EAAuB,CAIzB,IAAIsB,EAActF,GAAMsF,YAAYtX,GAEhCgS,GAAMmL,UAAUnd,IAClBqd,EAAiB,UACjBC,EAAgBhG,EAAc+F,EAAiB,aAE/CA,EAAiB,WACjBC,EAAgBhG,EAAc+F,EAAiB,UAEnD,KAAwB,YAAbrH,EACLhE,GAAMmL,UAAUnd,IAClBqd,EAAiB,WACjBC,EAAgB,YAEhBD,EAAiB,UACjBC,EAAgB,aAGlBD,EAAiBrH,EACjBsH,EAAgBtH,GAGlB,IAAInG,EAASyC,GAAM4H,UAAUla,EAAE6P,OAAQzI,EAAI,CACzC4O,SAAUqH,IAERrN,EAAQsC,GAAM4H,UAAUla,EAAEgQ,MAAO5I,EAAI,CACvC4O,SAAUsH,IAGZ,IAAKzN,IAAWG,EACd,OAAO,KAGThQ,EAAE6P,OAASA,EACX7P,EAAEgQ,MAAQA,CAAK,GAEnB,GAIEuN,QAAY3d,EAkBZmY,GAAW,CACb,WAAAyF,CAAYC,GACVF,GAAYE,CACd,EAEAzF,UAAU1V,GACDob,KAAK1F,UAAU1V,EAAOib,KAgB7BI,GAAc,CAAChN,EAAM0H,KACvB,IAAK,IAAIxQ,KAAO8I,EAAM,CACpB,IAAI3M,EAAI2M,EAAK9I,GACT9E,EAAIsV,EAAQxQ,GAEhB,GAAIpI,EAAcuE,IAAMvE,EAAcsD,IACpC,IAAK4a,GAAY3Z,EAAGjB,GAAI,OAAO,OAC1B,GAAI3C,MAAMU,QAAQkD,IAAM5D,MAAMU,QAAQiC,GAAI,CAC/C,GAAIiB,EAAE9D,SAAW6C,EAAE7C,OAAQ,OAAO,EAElC,IAAK,IAAII,EAAI,EAAGA,EAAI0D,EAAE9D,OAAQI,IAC5B,GAAI0D,EAAE1D,KAAOyC,EAAEzC,GAAI,OAAO,CAE9B,MAAO,GAAI0D,IAAMjB,EACf,OAAO,CAEX,CAQA,IAAK,IAAI6a,KAAQvF,EACf,QAAmBzY,IAAf+Q,EAAKiN,SAAyChe,IAAlByY,EAAQuF,GACtC,OAAO,EAIX,OAAO,CAAI,EAGTC,GAAc,CAAC,QACfC,GAAe,CAAC,SAAU,SAE9B,SAASC,GAAUzP,EAAQC,GAAkB,IAAIrN,EAAO7B,OAAO6B,KAAKoN,GAAS,GAAIjP,OAAOwG,sBAAuB,CAAE,IAAI2I,EAAUnP,OAAOwG,sBAAsByI,GAAaC,IAAkBC,EAAUA,EAAQC,QAAO,SAAUC,GAAO,OAAOrP,OAAOkF,yBAAyB+J,EAAQI,GAAKrM,UAAY,KAAMnB,EAAKiE,KAAK3E,MAAMU,EAAMsN,EAAU,CAAE,OAAOtN,CAAM,CAE1V,SAAS8c,GAAgBxV,GAAU,IAAK,IAAIlI,EAAI,EAAGA,EAAIL,UAAUC,OAAQI,IAAK,CAAE,IAAIgI,EAAyB,MAAhBrI,UAAUK,GAAaL,UAAUK,GAAK,CAAC,EAAOA,EAAI,EAAKyd,GAAU1e,OAAOiJ,IAAS,GAAMlH,SAAQ,SAAUyG,GAAOF,GAAgBa,EAAQX,EAAKS,EAAOT,GAAO,IAAexI,OAAO0G,0BAA6B1G,OAAOuP,iBAAiBpG,EAAQnJ,OAAO0G,0BAA0BuC,IAAmByV,GAAU1e,OAAOiJ,IAASlH,SAAQ,SAAUyG,GAAOxI,OAAO8G,eAAeqC,EAAQX,EAAKxI,OAAOkF,yBAAyB+D,EAAQT,GAAO,GAAM,CAAE,OAAOW,CAAQ,CAE3hB,IAAI8G,GAAO,CAOT,MAAAG,CAAO+B,EAAM6G,GACX,IAAIrJ,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,GAC/E,MACFge,GAAQ,GACNjP,EAEJ,SAASkP,EAAStW,GAGhB,OAFWS,GAA2BT,EAAKiW,GAG7C,CAEA,OAAOF,GAAYM,EAAQC,EAAS1M,GAAQA,EAAMyM,EAAQC,EAAS7F,GAAWA,EAChF,EAKA9I,OAAOjN,GACE7C,EAAc6C,IAAgC,iBAAfA,EAAMkP,KAM9C2M,WAAW7b,GACFlC,MAAMU,QAAQwB,IAAUA,EAAMoL,OAAMC,GAAO2B,GAAKC,OAAO5B,KAMhEoL,YAAYlL,QACYjO,IAAfiO,EAAM2D,KASf,OAAAvD,CAAQuD,EAAM3D,GACZ,IAAK,IAAIhG,KAAOgG,EACd,GAAY,SAARhG,KAIC2J,EAAK1R,eAAe+H,IAAQ2J,EAAK3J,KAASgG,EAAMhG,IACnD,OAAO,EAIX,OAAO,CACT,EAKA,WAAAuW,CAAYzN,EAAMyN,GAChB,IAAIC,EAAS,CAACL,GAAgB,CAAC,EAAGrN,IAElC,IAAK,IAAI2N,KAAOF,EAAa,CAC3B,IAAIvB,EAAOxU,GAA2BiW,EAAKR,KAEtC3N,EAAOhF,GAAO6G,GAAMvB,MAAM6N,GAC3B/K,EAAO,GACPgL,EAAU,EACVC,EAAkBrO,EAAMwC,OACxB8L,EAAgBtT,EAAIwH,OAExB,IAAK,IAAIE,KAAQwL,EAAQ,CACvB,IAAI,OACFne,GACE2S,EAAKrB,KACLkN,EAAYH,EAGhB,GAFAA,GAAWre,EAEPse,GAAmBE,GAAaH,GAAWE,EAC7Cpf,OAAOsf,OAAO9L,EAAMgK,GACpBtJ,EAAKpO,KAAK0N,QAKZ,GAAI2L,IAAoBC,IAAkBD,IAAoBD,GAAWE,IAAkBC,IAAcF,EAAkBD,GAAWE,EAAgBC,GAAaD,IAAkBC,GAA2B,IAAdA,EAChMnL,EAAKpO,KAAK0N,OADZ,CAQA,IAAI+L,EAAS/L,EACT3C,OAAS,EACTP,OAAQ,EAEZ,GAAI8O,EAAgBF,EAAS,CAC3B,IAAIM,EAAMJ,EAAgBC,EAC1B/O,EAAQqO,GAAgBA,GAAgB,CAAC,EAAGY,GAAS,CAAC,EAAG,CACvDpN,KAAMoN,EAAOpN,KAAKxP,MAAM6c,KAE1BD,EAASZ,GAAgBA,GAAgB,CAAC,EAAGY,GAAS,CAAC,EAAG,CACxDpN,KAAMoN,EAAOpN,KAAKxP,MAAM,EAAG6c,IAE/B,CAEA,GAAIL,EAAkBE,EAAW,CAC/B,IAAII,EAAON,EAAkBE,EAE7BxO,EAAS8N,GAAgBA,GAAgB,CAAC,EAAGY,GAAS,CAAC,EAAG,CACxDpN,KAAMoN,EAAOpN,KAAKxP,MAAM,EAAG8c,KAE7BF,EAASZ,GAAgBA,GAAgB,CAAC,EAAGY,GAAS,CAAC,EAAG,CACxDpN,KAAMoN,EAAOpN,KAAKxP,MAAM8c,IAE5B,CAEAzf,OAAOsf,OAAOC,EAAQ/B,GAElB3M,GACFqD,EAAKpO,KAAK+K,GAGZqD,EAAKpO,KAAKyZ,GAENjP,GACF4D,EAAKpO,KAAKwK,EAvCZ,CAyCF,CAEA0O,EAAS9K,CACX,CAEA,OAAO8K,CACT,GAIF,SAASU,GAAUzQ,EAAQC,GAAkB,IAAIrN,EAAO7B,OAAO6B,KAAKoN,GAAS,GAAIjP,OAAOwG,sBAAuB,CAAE,IAAI2I,EAAUnP,OAAOwG,sBAAsByI,GAAaC,IAAkBC,EAAUA,EAAQC,QAAO,SAAUC,GAAO,OAAOrP,OAAOkF,yBAAyB+J,EAAQI,GAAKrM,UAAY,KAAMnB,EAAKiE,KAAK3E,MAAMU,EAAMsN,EAAU,CAAE,OAAOtN,CAAM,CAE1V,SAAS8d,GAAgBxW,GAAU,IAAK,IAAIlI,EAAI,EAAGA,EAAIL,UAAUC,OAAQI,IAAK,CAAE,IAAIgI,EAAyB,MAAhBrI,UAAUK,GAAaL,UAAUK,GAAK,CAAC,EAAOA,EAAI,EAAKye,GAAU1f,OAAOiJ,IAAS,GAAMlH,SAAQ,SAAUyG,GAAOF,GAAgBa,EAAQX,EAAKS,EAAOT,GAAO,IAAexI,OAAO0G,0BAA6B1G,OAAOuP,iBAAiBpG,EAAQnJ,OAAO0G,0BAA0BuC,IAAmByW,GAAU1f,OAAOiJ,IAASlH,SAAQ,SAAUyG,GAAOxI,OAAO8G,eAAeqC,EAAQX,EAAKxI,OAAOkF,yBAAyB+D,EAAQT,GAAO,GAAM,CAAE,OAAOW,CAAQ,CAE3hB,IAiVIyW,GAAoB,CAItB,SAAA/E,CAAUnL,EAAQ3H,GAChB2H,EAAO3B,SAAW3F,GAAGsH,EAAO3B,UAC5B,IAAI+B,EAAYJ,EAAOI,WAAa1H,GAAGsH,EAAOI,WAE9C,IACEA,EA1Va,EAACJ,EAAQI,EAAW/H,KACrC,OAAQA,EAAGyC,MACT,IAAK,cAED,IAAI,KACF1C,EAAI,KACJwJ,GACEvJ,EACAwM,EAAS1G,GAAK0G,OAAO7E,EAAQ5H,GAC7BgR,EAAQhR,EAAKA,EAAKjH,OAAS,GAE/B,GAAIiY,EAAQvE,EAAOxG,SAASlN,OAC1B,MAAM,IAAIO,MAAM,oDAAsD2D,OAAO+C,EAAM,2DAKrF,GAFAyM,EAAOxG,SAASuL,OAAOR,EAAO,EAAGxH,GAE7BxB,EACF,IAAK,IAAKW,EAAOjI,KAAQmK,GAAMoL,OAAOjO,GACpCA,EAAUtH,GAAOyK,GAAM4H,UAAUpK,EAAO1I,GAI5C,MAGJ,IAAK,cAED,IACED,KAAM+X,EAAK,OACXvM,EAAM,KACNnB,GACEpK,EACJ,GAAoB,IAAhBoK,EAAKtR,OAAc,MAEvB,IAAI8S,EAAQ9F,GAAK2F,KAAK9D,EAAQmQ,GAE1BhP,EAAS8C,EAAMxB,KAAKxP,MAAM,EAAG2Q,GAE7BhD,EAAQqD,EAAMxB,KAAKxP,MAAM2Q,GAI7B,GAFAK,EAAMxB,KAAOtB,EAASsB,EAAO7B,EAEzBR,EACF,IAAK,IAAKgQ,EAAQvB,KAAS5L,GAAMoL,OAAOjO,GACtCA,EAAUyO,GAAQtL,GAAM4H,UAAUiF,EAAQ/X,GAI9C,MAGJ,IAAK,aAED,IACED,KAAMiY,GACJhY,EAEAiY,EAASnS,GAAK9K,IAAI2M,EAAQqQ,GAE1B/L,EAAW7D,GAAK0D,SAASkM,GACzBnM,EAAO/F,GAAK9K,IAAI2M,EAAQsE,GAExBiM,EAAUpS,GAAK0G,OAAO7E,EAAQqQ,GAE9BG,EAASH,EAAOA,EAAOlf,OAAS,GAEpC,GAAIoP,GAAKC,OAAO8P,IAAW/P,GAAKC,OAAO0D,GACrCA,EAAKzB,MAAQ6N,EAAO7N,SACf,IAAKlC,GAAKC,OAAO8P,IAAY/P,GAAKC,OAAO0D,GAG9C,MAAM,IAAIxS,MAAM,kDAAoD2D,OAAOgb,EAAQ,wCAAwChb,OAAO2T,GAASC,UAAUqH,GAAS,KAAKjb,OAAO2T,GAASC,UAAU/E,KAF7LA,EAAK7F,SAASjI,QAAQka,EAAOjS,SAG/B,CAIA,GAFAkS,EAAQlS,SAASuL,OAAO4G,EAAQ,GAE5BpQ,EACF,IAAK,IAAKqQ,EAASC,KAAUzN,GAAMoL,OAAOjO,GACxCA,EAAUsQ,GAASnN,GAAM4H,UAAUsF,EAASpY,GAIhD,MAGJ,IAAK,YAED,IACED,KAAMuY,EAAM,QACZxG,GACE9R,EAEJ,GAAIoI,GAAKhC,WAAWkS,EAAQxG,GAC1B,MAAM,IAAIzY,MAAM,uBAAuB2D,OAAOsb,EAAQ,mBAAmBtb,OAAO8U,EAAS,gDAG3F,IAAIyG,EAASzS,GAAK9K,IAAI2M,EAAQ2Q,GAE1BE,EAAW1S,GAAK0G,OAAO7E,EAAQ2Q,GAE/BG,EAAUH,EAAOA,EAAOxf,OAAS,GAOrC0f,EAASxS,SAASuL,OAAOkH,EAAS,GAElC,IAAIC,EAAWtQ,GAAK0K,UAAUwF,EAAQtY,GAClC2Y,EAAY7S,GAAK9K,IAAI2M,EAAQS,GAAKoE,OAAOkM,IACzCE,EAAWF,EAASA,EAAS5f,OAAS,GAG1C,GAFA6f,EAAU3S,SAASuL,OAAOqH,EAAU,EAAGL,GAEnCxQ,EACF,IAAK,IAAK8Q,EAASC,KAAUlO,GAAMoL,OAAOjO,GACxCA,EAAU+Q,GAAS5N,GAAM4H,UAAU+F,EAAS7Y,GAIhD,MAGJ,IAAK,cAED,IACED,KAAMgZ,GACJ/Y,EACAgZ,EAAUD,EAAOA,EAAOjgB,OAAS,GAQrC,GANegN,GAAK0G,OAAO7E,EAAQoR,GAE1B/S,SAASuL,OAAOyH,EAAS,GAI9BjR,EACF,IAAK,IAAKkR,EAASC,KAAUtO,GAAMoL,OAAOjO,GAAY,CACpD,IAAI+M,EAAS5J,GAAM4H,UAAUmG,EAASjZ,GAEtC,GAAiB,MAAb+H,GAA+B,MAAV+M,EACvB/M,EAAUmR,GAASpE,MACd,CACL,IAAIqE,OAAQ,EAERhN,OAAO,EAEX,IAAK,IAAKxT,EAAG+B,KAAMoL,GAAKkM,MAAMrK,GAAS,CACrC,IAAiC,IAA7BS,GAAK8E,QAAQxS,EAAGqe,GAEb,CACL5M,EAAO,CAACxT,EAAG+B,GACX,KACF,CAJEye,EAAQ,CAACxgB,EAAG+B,EAKhB,CAEA,IAAI0e,GAAa,EAEbD,GAAShN,IAETiN,EADEhR,GAAKC,OAAO8D,EAAK,GAAI4M,IACT3Q,GAAKwL,YAAYzH,EAAK,IAEvB/D,GAAKoG,OAAO2K,EAAM,GAAIJ,GAAQjgB,OAASsP,GAAKoG,OAAOrC,EAAK,GAAI4M,GAAQjgB,QAIjFqgB,IAAUC,GACZH,EAAQlZ,KAAOoZ,EAAM,GACrBF,EAAQ1N,OAAS4N,EAAM,GAAG/O,KAAKtR,QACtBqT,GACT8M,EAAQlZ,KAAOoM,EAAK,GACpB8M,EAAQ1N,OAAS,GAEjBxD,EAAY,IAEhB,CACF,CAGF,MAGJ,IAAK,cAED,IACEhI,KAAMsZ,EACN9N,OAAQ+N,EACRlP,KAAMmP,GACJvZ,EACJ,GAAqB,IAAjBuZ,EAAMzgB,OAAc,MAExB,IAAI0gB,EAAS1T,GAAK2F,KAAK9D,EAAQ0R,GAE3BI,EAAUD,EAAOpP,KAAKxP,MAAM,EAAG0e,GAE/BI,EAASF,EAAOpP,KAAKxP,MAAM0e,EAAUC,EAAMzgB,QAI/C,GAFA0gB,EAAOpP,KAAOqP,EAAUC,EAEpB3R,EACF,IAAK,IAAK4R,EAASC,KAAUhP,GAAMoL,OAAOjO,GACxCA,EAAU6R,GAAS1O,GAAM4H,UAAU6G,EAAS3Z,GAIhD,MAGJ,IAAK,WAED,IACED,KAAM8Z,EAAM,WACZtH,GAAU,cACVC,IACExS,EAEJ,GAAsB,IAAlB6Z,EAAO/gB,OACT,MAAM,IAAIO,MAAM,2CAGlB,IAAIygB,GAAShU,GAAK9K,IAAI2M,EAAQkS,GAE9B,IAAK,IAAIE,MAASvH,GAAe,CAC/B,GAAc,aAAVuH,IAAkC,SAAVA,GAC1B,MAAM,IAAI1gB,MAAM,mBAAoB2D,OAAO+c,GAAO,yBAGpD,IAAI7e,GAAQsX,GAAcuH,IAEb,MAAT7e,UACK4e,GAAOC,IAEdD,GAAOC,IAAS7e,EAEpB,CAGA,IAAK,IAAI8e,MAASzH,GACXC,GAAc9Z,eAAeshB,YACzBF,GAAOE,IAIlB,MAGJ,IAAK,gBAED,IACExH,cAAeS,IACbjT,EAEJ,GAAsB,MAAlBiT,GACFlL,EAAYkL,OACP,CACL,GAAiB,MAAblL,EAAmB,CACrB,IAAK6C,GAAMC,QAAQoI,IACjB,MAAM,IAAI5Z,MAAM,mEAAqE2D,OAAO2T,GAASC,UAAUqC,IAAiB,yCAGlIlL,EAAY6P,GAAgB,CAAC,EAAG3E,GAClC,CAEA,IAAK,IAAIgH,MAAShH,GAAgB,CAChC,IAAIiH,GAASjH,GAAegH,IAE5B,GAAc,MAAVC,GAAgB,CAClB,GAAc,WAAVD,IAAgC,UAAVA,GACxB,MAAM,IAAI5gB,MAAM,sBAAuB2D,OAAOid,GAAO,gCAGhDlS,EAAUkS,GACnB,MACElS,EAAUkS,IAASC,EAEvB,CACF,CAEA,MAGJ,IAAK,aAED,IACEna,KAAMoa,GAAM,SACZ7H,GACAC,WAAYS,IACVhT,EAEJ,GAAsB,IAAlBma,GAAOrhB,OACT,MAAM,IAAIO,MAAM,kDAAoD2D,OAAOmd,GAAQ,6CAGrF,IAKIC,GALAC,GAASvU,GAAK9K,IAAI2M,EAAQwS,IAE1BG,GAAWxU,GAAK0G,OAAO7E,EAAQwS,IAE/BI,GAAUJ,GAAOA,GAAOrhB,OAAS,GAGrC,GAAIoP,GAAKC,OAAOkS,IAAS,CACvB,IAAIG,GAAWH,GAAOjQ,KAAKxP,MAAM,EAAG0X,IAEhCmI,GAAUJ,GAAOjQ,KAAKxP,MAAM0X,IAEhC+H,GAAOjQ,KAAOoQ,GACdJ,GAAUxC,GAAgBA,GAAgB,CAAC,EAAG5E,IAAc,CAAC,EAAG,CAC9D5I,KAAMqQ,IAEV,KAAO,CACL,IAAIC,GAAWL,GAAOrU,SAASpL,MAAM,EAAG0X,IAEpCqI,GAAUN,GAAOrU,SAASpL,MAAM0X,IAEpC+H,GAAOrU,SAAW0U,GAClBN,GAAUxC,GAAgBA,GAAgB,CAAC,EAAG5E,IAAc,CAAC,EAAG,CAC9DhN,SAAU2U,IAEd,CAIA,GAFAL,GAAStU,SAASuL,OAAOgJ,GAAU,EAAG,EAAGH,IAErCrS,EACF,IAAK,IAAK6S,GAASC,MAAUjQ,GAAMoL,OAAOjO,GACxCA,EAAU8S,IAAS3P,GAAM4H,UAAU8H,GAAS5a,GAQtD,OAAO+H,CAAS,EAaA+S,CAAanT,EAAQI,EAAW/H,EAC9C,CAAE,QACA2H,EAAO3B,SAAW1F,GAAGqH,EAAO3B,UAG1B2B,EAAOI,UADLA,EACiBnP,EAAEmP,GAAazH,GAAGyH,GAAaA,EAE/B,IAEvB,CACF,GAIEgT,GAAc,CAAC,QACfC,GAAa,CAAC,YAElB,SAASC,GAAU/T,EAAQC,GAAkB,IAAIrN,EAAO7B,OAAO6B,KAAKoN,GAAS,GAAIjP,OAAOwG,sBAAuB,CAAE,IAAI2I,EAAUnP,OAAOwG,sBAAsByI,GAAaC,IAAkBC,EAAUA,EAAQC,QAAO,SAAUC,GAAO,OAAOrP,OAAOkF,yBAAyB+J,EAAQI,GAAKrM,UAAY,KAAMnB,EAAKiE,KAAK3E,MAAMU,EAAMsN,EAAU,CAAE,OAAOtN,CAAM,CAE1V,SAASohB,GAAgB9Z,GAAU,IAAK,IAAIlI,EAAI,EAAGA,EAAIL,UAAUC,OAAQI,IAAK,CAAE,IAAIgI,EAAyB,MAAhBrI,UAAUK,GAAaL,UAAUK,GAAK,CAAC,EAAOA,EAAI,EAAK+hB,GAAUhjB,OAAOiJ,IAAS,GAAMlH,SAAQ,SAAUyG,GAAOF,GAAgBa,EAAQX,EAAKS,EAAOT,GAAO,IAAexI,OAAO0G,0BAA6B1G,OAAOuP,iBAAiBpG,EAAQnJ,OAAO0G,0BAA0BuC,IAAmB+Z,GAAUhjB,OAAOiJ,IAASlH,SAAQ,SAAUyG,GAAOxI,OAAO8G,eAAeqC,EAAQX,EAAKxI,OAAOkF,yBAAyB+D,EAAQT,GAAO,GAAM,CAAE,OAAOW,CAAQ,CAE3hB,IAAI+Z,GAAiB,CAInB,WAAAC,CAAYzT,EAAQgE,GAClB,IAAI/D,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,EACnFoN,GAAO6H,mBAAmBnG,GAAQ,KAChC,IAAI,QACF0T,GAAU,EAAK,MACfxT,GAAQ,EAAK,KACbC,EAAO,UACLF,GACA,GACFpE,EAAE,MACFoC,EAAK,OACL0V,GACE1T,EAMJ,GAJI9B,GAAK2L,OAAO9F,KACdA,EAAQ,CAACA,IAGU,IAAjBA,EAAM7S,OAAV,CAIA,IAAKyQ,GAAQoC,EAoBb,GAhBKnI,IAEDA,EADEmE,EAAOI,UACJJ,EAAOI,UACHJ,EAAO3B,SAASlN,OAAS,EAC7BmN,GAAOlC,IAAI4D,EAAQ,IAEnB,CAAC,GAGR2T,GAAS,GAGG,MAAVA,IACFA,GAAS,GAGP1Q,GAAMC,QAAQrH,GAKhB,GAJK6X,IACH7X,EAAKyC,GAAOgK,YAAYtI,EAAQnE,IAG9BoH,GAAMsF,YAAY1M,GACpBA,EAAKA,EAAGiF,WACH,CACL,IAAK,CAAE1E,GAAO6G,GAAMvB,MAAM7F,GACtB0L,EAAWjJ,GAAOiJ,SAASvH,EAAQ5D,GACvCwX,GAAWhgB,OAAOoM,EAAQ,CACxBnE,OAEFA,EAAK0L,EAASH,OAChB,CAGF,GAAI7D,GAAMuD,QAAQjL,GAAK,CACR,MAAToC,IAEAA,EADEsC,GAAKC,OAAOoB,GACN5Q,GAAKuP,GAAKC,OAAOxP,GAChBgP,EAAOkC,SAASN,GACjB5Q,GAAKuP,GAAKC,OAAOxP,IAAMsN,GAAO4D,SAASlC,EAAQhP,GAE/CA,GAAKsN,GAAO0D,QAAQhC,EAAQhP,IAIxC,IAAKqV,GAAS/H,GAAO0F,MAAMhE,EAAQ,CACjCnE,GAAIA,EAAGzD,KACP6F,QACAkC,OACAD,UAGF,IAAImG,EAaF,OAZA,IAAK,CAAEwN,GAAcxN,EACjBW,EAAU1I,GAAO0I,QAAQhH,EAAQ6T,GACjCC,EAAUxV,GAAOgF,MAAMtD,EAAQnE,EAAIgY,GACvCD,GAAWG,WAAW/T,EAAQ,CAC5BnE,KACAoC,QACAkC,OACAD,UAEF,IAAI9H,EAAO4O,EAAQI,QACnBvL,EAAKiY,EAAUrT,GAAK+D,KAAKpM,GAAQA,CAIrC,CAEA,IAAIqO,EAAahG,GAAKoE,OAAOhJ,GACzBuN,EAAQvN,EAAGA,EAAG1K,OAAS,GAE3B,GAAK+O,IAAS5B,GAAO0V,KAAKhU,EAAQ,CAChCnE,GAAI4K,IADN,CAMA,IAAK,IAAIxC,KAASD,EAAO,CACvB,IAAImM,EAAQ1J,EAAWpR,OAAO+T,GAE9BA,IACApJ,EAAOvO,MAAM,CACXqJ,KAAM,cACN1C,KAAM+X,EACNvO,KAAMqC,IAERpI,EAAK4E,GAAK+D,KAAK3I,EACjB,CAIA,GAFAA,EAAK4E,GAAK0D,SAAStI,GAEf8X,EAAQ,CACV,IAAI5S,EAAQzC,GAAOlC,IAAI4D,EAAQnE,GAE3BkF,GACF6S,GAAWD,OAAO3T,EAAQe,EAE9B,CAtBA,CAjFA,CAuGA,GAEJ,EAMA,SAAAkT,CAAUjU,GACR,IAAIC,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,EACnFoN,GAAO6H,mBAAmBnG,GAAQ,KAChC,IAAI,GACFnE,EAAKmE,EAAOI,UAAS,KACrBD,EAAO,SAAQ,MACfD,GAAQ,GACND,GACA,MACFhC,GACEgC,EAMJ,GAJa,MAAThC,IACFA,EAAQwC,GAAKmE,OAAO/I,GAAMqY,GAAUlU,EAAQnE,GAAM7K,GAAKsN,GAAO0D,QAAQhC,EAAQhP,IAG3E6K,EAAL,CAIA,IAAIqD,EAAUZ,GAAO0F,MAAMhE,EAAQ,CACjCnE,KACAoC,QACAkC,OACAD,UAEEmH,EAAWhW,MAAMiF,KAAK4I,GAASmG,IACjC,IAAK,CAAEtS,GAAKsS,EACZ,OAAO/G,GAAO0I,QAAQhH,EAAQjN,EAAE,IAGlC,IAAK,IAAIiU,KAAWK,EAAU,CAC5B,IAAIjP,EAAO4O,EAAQI,QAEnB,GAAIhP,EAAKjH,OAAS,EAChB,MAAM,IAAIO,MAAM,+BAA+B2D,OAAO+C,EAAM,+CAG9D,IAAI+b,EAAkB7V,GAAOsD,KAAK5B,EAAQS,GAAKoE,OAAOzM,KACjDyM,EAAQ4B,GAAc0N,EACvB/K,EAAQhR,EAAKA,EAAKjH,OAAS,IAC3B,OACFA,GACE0T,EAAOxG,SAEX,GAAe,IAAXlN,EAAc,CAChB,IAAIijB,EAAS3T,GAAK+D,KAAKiC,GACvBmN,GAAWS,UAAUrU,EAAQ,CAC3BnE,GAAIzD,EACJsM,GAAI0P,EACJlU,UAEF0T,GAAWU,YAAYtU,EAAQ,CAC7BnE,GAAI4K,EACJvG,SAEJ,MAAO,GAAc,IAAVkJ,EACTwK,GAAWS,UAAUrU,EAAQ,CAC3BnE,GAAIzD,EACJsM,GAAI+B,EACJvG,eAEG,GAAIkJ,IAAUjY,EAAS,EAAG,CAC/B,IAAIojB,EAAU9T,GAAK+D,KAAKiC,GAExBmN,GAAWS,UAAUrU,EAAQ,CAC3BnE,GAAIzD,EACJsM,GAAI6P,EACJrU,SAEJ,KAAO,CACL,IAAIsU,EAAY/T,GAAK+D,KAAKpM,GAEtBqc,EAAWhU,GAAK+D,KAAKiC,GAEzBmN,GAAWG,WAAW/T,EAAQ,CAC5BnE,GAAI2Y,EACJtU,UAEF0T,GAAWS,UAAUrU,EAAQ,CAC3BnE,GAAIzD,EACJsM,GAAI+P,EACJvU,SAEJ,CACF,CAnEA,CAmEA,GAEJ,EAMA,UAAAwU,CAAW1U,GACT,IAAIC,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,EACnFoN,GAAO6H,mBAAmBnG,GAAQ,KAChC,IAAI,MACF/B,EAAK,GACLpC,EAAKmE,EAAOI,WACVH,GACA,QACFyT,GAAU,EAAK,MACfxT,GAAQ,EAAK,KACbC,EAAO,UACLF,EAEJ,GAAKpE,EAAL,CAIA,GAAa,MAAToC,EACF,GAAIwC,GAAKmE,OAAO/I,GAAK,CACnB,IAAKgJ,GAAUvG,GAAOuG,OAAO7E,EAAQnE,GAErCoC,EAAQjN,GAAK6T,EAAOxG,SAASyG,SAAS9T,EACxC,MACEiN,EAAQjN,GAAKsN,GAAO0D,QAAQhC,EAAQhP,GAQxC,IAJK0iB,GAAWzQ,GAAMC,QAAQrH,KAC5BA,EAAKyC,GAAOgK,YAAYtI,EAAQnE,IAG9BoH,GAAMC,QAAQrH,GAChB,GAAIoH,GAAMsF,YAAY1M,GACpBA,EAAKA,EAAGiF,WACH,CACL,IAAK,CAAE1E,GAAO6G,GAAMvB,MAAM7F,GACtB0L,EAAWjJ,GAAOiJ,SAASvH,EAAQ5D,GACvCwX,GAAWhgB,OAAOoM,EAAQ,CACxBnE,OAEFA,EAAK0L,EAASH,QAEI,MAAdnH,EAAQpE,IACV+X,GAAWD,OAAO3T,EAAQnE,EAE9B,CAGF,IAAKsL,GAAW7I,GAAO0F,MAAMhE,EAAQ,CACnCnE,KACAoC,QACAiC,QACAC,SAEE+D,EAAO5F,GAAO6F,SAASnE,EAAQ,CACjCnE,KACAoC,QACAiC,QACAC,SAGF,GAAKgH,GAAYjD,EAAjB,CAIA,IAAKtC,EAAMxJ,GAAQ+O,GACd9C,EAAUC,GAAYJ,EAE3B,GAAoB,IAAhB9L,EAAKjH,QAAoC,IAApBmT,EAASnT,OAAlC,CAIA,IAiBIyZ,EACAD,EAlBAR,EAAU1J,GAAK+D,KAAKF,GACpBqQ,EAAalU,GAAKoG,OAAOzO,EAAMkM,GAC/BsQ,EAAoBnU,GAAKwK,UAAU7S,EAAMkM,GACzChE,EAASjP,MAAMiF,KAAKgI,GAAOgC,OAAON,EAAQ,CAC5CnE,GAAIzD,KACF4N,IACF,IAAKhV,GAAKgV,EACV,OAAOhV,CAAC,IACPiC,MAAM0hB,EAAWxjB,QAAQ8B,MAAM,GAAI,GAGlC4hB,EAAgBvW,GAAOyB,MAAMC,EAAQ,CACvCnE,GAAIzD,EACJ+H,KAAM,UACNlC,MAAOjN,GAAKsP,EAAOwE,SAAS9T,IAAM8jB,GAAmB9U,EAAQhP,KAE3D+jB,EAAWF,GAAiBvW,GAAO0I,QAAQhH,EAAQ6U,EAAc,IAKrE,GAAItU,GAAKC,OAAOoB,IAASrB,GAAKC,OAAO6D,GAAW,CAC9C,IAAIyJ,EAAOxU,GAA2BsI,EAAMwR,IAE5CzI,EAAWtG,EAAS5B,KAAKtR,OACzByZ,EAAakD,CACf,KAAO,KAAItP,GAAQN,UAAU0D,KAASpD,GAAQN,UAAUmG,GAMtD,MAAM,IAAI3S,MAAM,kCAAkC2D,OAAO+C,EAAM,iEAAiE/C,OAAO2T,GAASC,UAAUrH,GAAO,KAAKvM,OAAO2T,GAASC,UAAU5E,KAL5LyJ,EAAOxU,GAA2BsI,EAAMyR,IAE5C1I,EAAWtG,EAAShG,SAASlN,OAC7ByZ,EAAakD,CAGf,CAIK8G,GACHhB,GAAWS,UAAUrU,EAAQ,CAC3BnE,GAAIzD,EACJsM,GAAIyF,EACJjK,UAMA6U,GACFnB,GAAWU,YAAYtU,EAAQ,CAC7BnE,GAAIkZ,EAAS5N,QACbjH,UASA1B,GAAQN,UAAUmG,IAAa/F,GAAOoF,QAAQ1D,EAAQqE,IAAa9D,GAAKC,OAAO6D,IAA+B,KAAlBA,EAAS5B,MAAiD,IAAlC6B,EAASA,EAASnT,OAAS,GACjJyiB,GAAWU,YAAYtU,EAAQ,CAC7BnE,GAAIyI,EACJpE,UAGFF,EAAOvO,MAAM,CACXqJ,KAAM,aACN1C,KAAM+R,EACNQ,WACAC,eAIAmK,GACFA,EAAS3N,OA5EX,CAPA,CAhDA,CAoIA,GAEJ,EAKA,SAAAiN,CAAUrU,EAAQC,GAChB3B,GAAO6H,mBAAmBnG,GAAQ,KAChC,IAAI,GACF0E,EAAE,GACF7I,EAAKmE,EAAOI,UAAS,KACrBD,EAAO,SAAQ,MACfD,GAAQ,GACND,GACA,MACFhC,GACEgC,EAEJ,GAAKpE,EAAL,CAIa,MAAToC,IACFA,EAAQwC,GAAKmE,OAAO/I,GAAMqY,GAAUlU,EAAQnE,GAAM7K,GAAKsN,GAAO0D,QAAQhC,EAAQhP,IAGhF,IAAIgkB,EAAQ1W,GAAO0I,QAAQhH,EAAQ0E,GAC/BuQ,EAAU3W,GAAO0F,MAAMhE,EAAQ,CACjCnE,KACAoC,QACAkC,OACAD,UAEEmH,EAAWhW,MAAMiF,KAAK2e,GAASC,IACjC,IAAK,CAAEniB,GAAKmiB,EACZ,OAAO5W,GAAO0I,QAAQhH,EAAQjN,EAAE,IAGlC,IAAK,IAAIiU,KAAWK,EAAU,CAC5B,IAAIjP,EAAO4O,EAAQI,QACf+C,EAAU6K,EAAM7N,QAEA,IAAhB/O,EAAKjH,QACP6O,EAAOvO,MAAM,CACXqJ,KAAM,YACN1C,OACA+R,YAIA6K,EAAM7N,SAAW1G,GAAKwK,UAAUd,EAAS/R,IAASqI,GAAKyJ,QAAQC,EAAS/R,KAI1E4c,EAAM7N,QAAU1G,GAAK+D,KAAKwQ,EAAM7N,SAEpC,CAEA6N,EAAM5N,OAtCN,CAsCa,GAEjB,EAKA,WAAAkN,CAAYtU,GACV,IAAIC,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,EACnFoN,GAAO6H,mBAAmBnG,GAAQ,KAChC,IAAI,QACF0T,GAAU,EAAK,MACfxT,GAAQ,EAAK,KACbC,EAAO,UACLF,GACA,GACFpE,EAAKmE,EAAOI,UAAS,MACrBnC,GACEgC,EAEJ,GAAKpE,EAAL,CAIa,MAAToC,IACFA,EAAQwC,GAAKmE,OAAO/I,GAAMqY,GAAUlU,EAAQnE,GAAM7K,GAAKsN,GAAO0D,QAAQhC,EAAQhP,KAG3E0iB,GAAWzQ,GAAMC,QAAQrH,KAC5BA,EAAKyC,GAAOgK,YAAYtI,EAAQnE,IAGlC,IAAIsZ,EAAS7W,GAAO0F,MAAMhE,EAAQ,CAChCnE,KACAoC,QACAkC,OACAD,UAEEmH,EAAWhW,MAAMiF,KAAK6e,GAAQC,IAChC,IAAK,CAAEriB,GAAKqiB,EACZ,OAAO9W,GAAO0I,QAAQhH,EAAQjN,EAAE,IAGlC,IAAK,IAAIiU,KAAWK,EAAU,CAC5B,IAAIjP,EAAO4O,EAAQI,QAEnB,GAAIhP,EAAM,CACR,IAAKwJ,GAAQtD,GAAOsD,KAAK5B,EAAQ5H,GACjC4H,EAAOvO,MAAM,CACXqJ,KAAM,cACN1C,OACAwJ,QAEJ,CACF,CAhCA,CAgCA,GAEJ,EAKA,QAAAyT,CAASrV,EAAQlB,GACf,IAAImB,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,EACnFoN,GAAO6H,mBAAmBnG,GAAQ,KAChC,IAAI,MACF/B,EAAK,GACLpC,EAAKmE,EAAOI,UAAS,QACrBmF,EAAO,MACP+P,GACErV,GACA,QACFyT,GAAU,EAAK,KACfvT,EAAO,SAAQ,MACfoV,GAAQ,EAAK,MACbrV,GAAQ,GACND,EAEJ,GAAKpE,EAAL,CAYA,GARa,MAAToC,IACFA,EAAQwC,GAAKmE,OAAO/I,GAAMqY,GAAUlU,EAAQnE,GAAM7K,GAAKsN,GAAO0D,QAAQhC,EAAQhP,KAG3E0iB,GAAWzQ,GAAMC,QAAQrH,KAC5BA,EAAKyC,GAAOgK,YAAYtI,EAAQnE,IAG9B0Z,GAAStS,GAAMC,QAAQrH,GAAK,CAC9B,GAAIoH,GAAMsF,YAAY1M,IAAOyC,GAAOwF,KAAK9D,EAAQnE,EAAGiF,QAAQ,GAAG2B,KAAKtR,OAAS,EAG3E,OAGF,IAAIgX,EAAW7J,GAAO6J,SAASnI,EAAQnE,EAAI,CACzCoL,SAAU,YAEP7F,EAAOhF,GAAO6G,GAAMvB,MAAM7F,GAC3B2Z,EAAqB,WAATrV,EAAoB,SAAW,UAC3CsV,EAAiBnX,GAAOgF,MAAMtD,EAAQ5D,EAAKA,EAAIhE,MACnDwb,GAAWG,WAAW/T,EAAQ,CAC5BnE,GAAIO,EACJ6B,QACAkC,KAAMqV,EACNtV,QACAwV,QAASD,IAEX,IAAIE,EAAqBrX,GAAOmF,QAAQzD,EAAQoB,EAAOA,EAAMhJ,MAC7Dwb,GAAWG,WAAW/T,EAAQ,CAC5BnE,GAAIuF,EACJnD,QACAkC,KAAMqV,EACNtV,QACAwV,QAASC,IAEX9Z,EAAKsM,EAASf,QAEI,MAAdnH,EAAQpE,IACV+X,GAAWD,OAAO3T,EAAQnE,EAE9B,CAMA,IAAK,IAAK+F,EAAMxJ,KAJXmN,IACHA,EAAU,CAACqQ,EAAMC,IAAaD,IAASC,GAGhBvX,GAAO0F,MAAMhE,EAAQ,CAC5CnE,KACAoC,QACAkC,OACAD,WACE,CACF,IAAI0K,EAAa,CAAC,EACdC,EAAgB,CAAC,EAErB,GAAoB,IAAhBzS,EAAKjH,OAAT,CAIA,IAAI2kB,GAAa,EAEjB,IAAK,IAAI9gB,KAAK8J,EACF,aAAN9J,GAA0B,SAANA,GAIpBuQ,EAAQzG,EAAM9J,GAAI4M,EAAK5M,MACzB8gB,GAAa,EAETlU,EAAK7Q,eAAeiE,KAAI4V,EAAW5V,GAAK4M,EAAK5M,IAE7CsgB,EACc,MAAZxW,EAAM9J,KAAY6V,EAAc7V,GAAKsgB,EAAM1T,EAAK5M,GAAI8J,EAAM9J,KAE9C,MAAZ8J,EAAM9J,KAAY6V,EAAc7V,GAAK8J,EAAM9J,KAKjD8gB,GACF9V,EAAOvO,MAAM,CACXqJ,KAAM,WACN1C,OACAwS,aACAC,iBA3BJ,CA8BF,CA1FA,CA0FA,GAEJ,EAKA,UAAAkJ,CAAW/T,GACT,IAAIC,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,EACnFoN,GAAO6H,mBAAmBnG,GAAQ,KAChC,IAAI,KACFG,EAAO,SAAQ,MACfD,GAAQ,GACND,GACA,MACFhC,EAAK,GACLpC,EAAKmE,EAAOI,UAAS,OACrB2V,EAAS,EAAC,OACVL,GAAS,GACPzV,EAYJ,GAVa,MAAThC,IACFA,EAAQjN,GAAKsN,GAAO0D,QAAQhC,EAAQhP,IAGlCiS,GAAMC,QAAQrH,KAChBA,EAAKma,GAAYhW,EAAQnE,IAKvB4E,GAAKmE,OAAO/I,GAAK,CACnB,IAAIzD,EAAOyD,EACPkF,EAAQzC,GAAOyC,MAAMf,EAAQ5H,IAC5ByM,GAAUvG,GAAOuG,OAAO7E,EAAQ5H,GAErC6F,EAAQjN,GAAKA,IAAM6T,EAEnBkR,EAAShV,EAAM3I,KAAKjH,OAASiH,EAAKjH,OAAS,EAC3C0K,EAAKkF,EACL2U,GAAS,CACX,CAEA,GAAK7Z,EAAL,CAIA,IAGIoa,EAHAC,EAAY5X,GAAOiJ,SAASvH,EAAQnE,EAAI,CAC1CoL,SAAU,aAIZ,IACE,IAAKkP,GAAW7X,GAAO0F,MAAMhE,EAAQ,CACnCnE,KACAoC,QACAkC,OACAD,UAGF,IAAKiW,EACH,OAGF,IAAIC,EAAY9X,GAAO0V,KAAKhU,EAAQ,CAClCnE,KACAsE,KAAM,YAIR,IAAKD,GAASkW,EAAW,CACvB,IAAKC,EAAUC,GAAYF,EAE3B,GAAI5X,GAAQN,UAAUmY,IAAarW,EAAOkC,SAASmU,GAAW,CAC5D,IAAIzV,EAAQtC,GAAOsC,MAAMZ,EAAQsW,GAEjC,IAAK1V,EAAO,CACV,IAGI2V,EAAY9V,GAAK+D,KAAK8R,GAC1B1C,GAAWH,YAAYzT,EAJZ,CACTyC,KAAM,IAG6B,CACnC5G,GAAI0a,EACJrW,UAEFU,EAAQtC,GAAOyC,MAAMf,EAAQuW,EAC/B,CAEA1a,EAAK+E,EACL8U,GAAS,CACX,CAGAK,EADoBla,EAAGzD,KAAKjH,OAASmlB,EAASnlB,OACrB,EACzBukB,GAAS,CACX,CAEAO,EAAW3X,GAAOiJ,SAASvH,EAAQnE,GACnC,IAAI6K,EAAQ7K,EAAGzD,KAAKjH,OAAS4kB,GACxB,CAAES,GAAeL,EAClBM,EAAa5a,EAAGzD,KAAKnF,MAAM,EAAGyT,GAC9BiE,EAAsB,IAAXoL,EAAela,EAAG+H,OAAS/H,EAAGzD,KAAKsO,GAjCtC,EAmCZ,IAAK,IAAK9E,EAAMyO,KAAW/R,GAAOgC,OAAON,EAAQ,CAC/CnE,GAAI4a,EACJpW,SAAS,EACTH,UACE,CACF,IAAIqV,GAAQ,EAEZ,GAAIlF,EAAOlf,OAASqlB,EAAYrlB,QAA4B,IAAlBkf,EAAOlf,SAAiB+O,GAAS5B,GAAOqE,OAAO3C,EAAQ4B,GAC/F,MAGF,IAAIwO,EAAS8F,EAAU/O,QACnB7D,EAAQhF,GAAOgF,MAAMtD,EAAQoQ,EAAQC,GAEzC,GAAIqF,IAAWQ,IAAc5X,GAAOkF,OAAOxD,EAAQoQ,EAAQC,GAAS,CAClEkF,GAAQ,EACR,IAAI3K,EAAazM,GAAKuL,aAAa9H,GACnC5B,EAAOvO,MAAM,CACXqJ,KAAM,aACN1C,KAAMiY,EACN1F,WACAC,cAEJ,CAEAD,EAAW0F,EAAOA,EAAOlf,OAAS,IAAMokB,GAASjS,EAAQ,EAAI,EAC/D,CAEA,GAAkB,MAAdrD,EAAQpE,GAAY,CACtB,IAAI4U,EAAUwF,EAAS9O,SAAW7I,GAAOlC,IAAI4D,EAAQ,IAErD4T,GAAWD,OAAO3T,EAAQyQ,EAC5B,CACF,CAAE,QACA,IAAIiG,EAEJR,EAAU9O,QACiB,QAA1BsP,EAAYT,SAAoC,IAAdS,GAAgCA,EAAUtP,OAC/E,CAhGA,CAgGA,GAEJ,EAKA,UAAAuP,CAAW3W,EAAQlB,GACjB,IAAImB,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,EAE9EG,MAAMU,QAAQ+M,KACjBA,EAAQ,CAACA,IAGX,IAAIjG,EAAM,CAAC,EAEX,IAAK,IAAIC,KAAOgG,EACdjG,EAAIC,GAAO,KAGb8a,GAAWyB,SAASrV,EAAQnH,EAAKoH,EACnC,EAMA,WAAA2W,CAAY5W,GACV,IAAIC,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,EACnFoN,GAAO6H,mBAAmBnG,GAAQ,KAChC,IAAI,KACFG,EAAO,SAAQ,MACfoV,GAAQ,EAAK,MACbrV,GAAQ,GACND,GACA,GACFpE,EAAKmE,EAAOI,UAAS,MACrBnC,GACEgC,EAEJ,GAAKpE,EAAL,CAIa,MAAToC,IACFA,EAAQwC,GAAKmE,OAAO/I,GAAMqY,GAAUlU,EAAQnE,GAAM7K,GAAKsN,GAAO0D,QAAQhC,EAAQhP,IAG5EyP,GAAKmE,OAAO/I,KACdA,EAAKyC,GAAOuC,MAAMb,EAAQnE,IAG5B,IAAIsM,EAAWlF,GAAMC,QAAQrH,GAAMyC,GAAO6J,SAASnI,EAAQnE,GAAM,KAC7DqD,EAAUZ,GAAO0F,MAAMhE,EAAQ,CACjCnE,KACAoC,QACAkC,OACAD,UAEEmH,EAAWhW,MAAMiF,KAAK4I,GAAS2X,IACjC,IAAK,CAAE9jB,GAAK8jB,EACZ,OAAOvY,GAAO0I,QAAQhH,EAAQjN,EAAE,IAIhCsN,UAEEyW,EAAQ,SAAe9P,GACzB,IAAI5O,EAAO4O,EAAQI,SACdxF,GAAQtD,GAAOsD,KAAK5B,EAAQ5H,GAC7ByI,EAAQvC,GAAOuC,MAAMb,EAAQ5H,GAE7Bmd,GAASpN,IACXtH,EAAQoC,GAAM4K,aAAa1F,EAAShB,QAAStG,IAG/C+S,GAAWK,UAAUjU,EAAQ,CAC3BnE,GAAIgF,EACJ5C,MAAOjN,GAAKwN,GAAQC,WAAWmD,IAASA,EAAKvD,SAASyG,SAAS9T,GAC/DkP,SAEJ,EAEA,IAAK,IAAI8G,KAAWK,EAClByP,EAAM9P,GAGJmB,GACFA,EAASf,OA9CX,CA+CA,GAEJ,EAMA,SAAA2P,CAAU/W,EAAQb,GAChB,IAAIc,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,EACnFoN,GAAO6H,mBAAmBnG,GAAQ,KAChC,IAAI,KACFG,EAAO,SAAQ,MACfoV,GAAQ,EAAK,MACbrV,GAAQ,GACND,GACA,MACFhC,EAAK,GACLpC,EAAKmE,EAAOI,WACVH,EAEJ,GAAKpE,EAAL,CAcA,GAVa,MAAToC,IAEAA,EADEwC,GAAKmE,OAAO/I,GACNqY,GAAUlU,EAAQnE,GACjBmE,EAAOkC,SAAS/C,GACjBnO,GAAKsN,GAAO4D,SAASlC,EAAQhP,IAAMuP,GAAKC,OAAOxP,GAE/CA,GAAKsN,GAAO0D,QAAQhC,EAAQhP,IAIpCukB,GAAStS,GAAMC,QAAQrH,GAAK,CAC9B,IAAKuF,EAAOhF,GAAO6G,GAAMvB,MAAM7F,GAC3BsM,EAAW7J,GAAO6J,SAASnI,EAAQnE,EAAI,CACzCoL,SAAU,WAEZ2M,GAAWG,WAAW/T,EAAQ,CAC5BnE,GAAIO,EACJ6B,QACAiC,UAEF0T,GAAWG,WAAW/T,EAAQ,CAC5BnE,GAAIuF,EACJnD,QACAiC,UAEFrE,EAAKsM,EAASf,QAEI,MAAdnH,EAAQpE,IACV+X,GAAWD,OAAO3T,EAAQnE,EAE9B,CAEA,IAAImb,EAAQ3lB,MAAMiF,KAAKgI,GAAO0F,MAAMhE,EAAQ,CAC1CnE,KACAoC,MAAO+B,EAAOkC,SAAS/C,GAAWnO,GAAKsN,GAAO0D,QAAQhC,EAAQhP,GAAKA,GAAKsN,GAAOC,SAASvN,GACxFmP,KAAM,SACND,WAGF,IAAK,IAAK,CAAE+W,KAAaD,EAAO,CAC9B,IAAI/hB,EAAIgO,GAAMC,QAAQrH,GAAMoH,GAAM4K,aAAahS,EAAIyC,GAAOuC,MAAMb,EAAQiX,IAAapb,EAErF,GAAK5G,EAAL,CAIA,IAAIiK,EAAU7N,MAAMiF,KAAKgI,GAAO0F,MAAMhE,EAAQ,CAC5CnE,GAAI5G,EACJgJ,QACAkC,OACAD,WAGF,GAAIhB,EAAQ/N,OAAS,EAAG,CACtB,IAAI+lB,EAAO,WACT,IAAKvV,GAASzC,EACV2E,EAAO3E,EAAQA,EAAQ/N,OAAS,IAC/B,CAAEwV,GAAahF,GACf,CAAEiF,GAAY/C,EAEnB,GAAyB,IAArB8C,EAAUxV,QAAoC,IAApByV,EAASzV,OAErC,MAAO,WAGT,IAAIwjB,EAAalU,GAAKC,OAAOiG,EAAWC,GAAYnG,GAAKoE,OAAO8B,GAAalG,GAAKoG,OAAOF,EAAWC,GAChG/F,EAAQvC,GAAOuC,MAAMb,EAAQ2G,EAAWC,GACxCuQ,EAAkB7Y,GAAOsD,KAAK5B,EAAQ2U,IACrCyC,GAAcD,EACfzQ,EAAQiO,EAAWxjB,OAAS,EAC5BkmB,EAAc5W,GAAK+D,KAAKoC,EAAS3T,MAAM,EAAGyT,IAE1C4Q,EAAU/D,GAAgBA,GAAgB,CAAC,EAAGpU,GAAU,CAAC,EAAG,CAC9Dd,SAAU,KAGZuV,GAAWH,YAAYzT,EAAQsX,EAAS,CACtCzb,GAAIwb,EACJnX,UAEF0T,GAAWS,UAAUrU,EAAQ,CAC3BnE,GAAIgF,EACJ5C,MAAOjN,GAAKwN,GAAQC,WAAW2Y,IAAeA,EAAW/Y,SAASyG,SAAS9T,GAC3E0T,GAAI2S,EAAYhiB,OAAO,GACvB6K,SAEJ,CAhCW,GAkCX,GAAa,aAATgX,EAAqB,QAC3B,CA7CA,CA8CF,CA5FA,CA4FA,GAEJ,GAIEpC,GAAqB,CAAC9U,EAAQ4B,KAChC,GAAIpD,GAAQN,UAAU0D,GAAO,CAC3B,IAAIzC,EAAUyC,EAEd,QAAItD,GAAOqE,OAAO3C,EAAQ4B,IAEa,IAA5BzC,EAAQd,SAASlN,QACnB2jB,GAAmB9U,EAAQb,EAAQd,SAAS,GAIvD,CAAO,OAAIC,GAAOC,SAASqD,EAI3B,EAOEoU,GAAc,CAAChW,EAAQa,KACzB,GAAIoC,GAAMsF,YAAY1H,GACpB,OAAOA,EAAMC,OAEb,IAAK,CAAE1E,GAAO6G,GAAMvB,MAAMb,GACtB0G,EAAWjJ,GAAOiJ,SAASvH,EAAQ5D,GAIvC,OAHAwX,GAAWhgB,OAAOoM,EAAQ,CACxBnE,GAAIgF,IAEC0G,EAASH,OAClB,EAGE8M,GAAY,CAAClU,EAAQ5H,KACvB,IAAKwJ,GAAQtD,GAAOsD,KAAK5B,EAAQ5H,GACjC,OAAOpH,GAAKA,IAAM4Q,CAAI,EAGxB,SAAS2V,GAAUhY,EAAQC,GAAkB,IAAIrN,EAAO7B,OAAO6B,KAAKoN,GAAS,GAAIjP,OAAOwG,sBAAuB,CAAE,IAAI2I,EAAUnP,OAAOwG,sBAAsByI,GAAaC,IAAkBC,EAAUA,EAAQC,QAAO,SAAUC,GAAO,OAAOrP,OAAOkF,yBAAyB+J,EAAQI,GAAKrM,UAAY,KAAMnB,EAAKiE,KAAK3E,MAAMU,EAAMsN,EAAU,CAAE,OAAOtN,CAAM,CAE1V,SAASqlB,GAAgB/d,GAAU,IAAK,IAAIlI,EAAI,EAAGA,EAAIL,UAAUC,OAAQI,IAAK,CAAE,IAAIgI,EAAyB,MAAhBrI,UAAUK,GAAaL,UAAUK,GAAK,CAAC,EAAOA,EAAI,EAAKgmB,GAAUjnB,OAAOiJ,IAAS,GAAMlH,SAAQ,SAAUyG,GAAOF,GAAgBa,EAAQX,EAAKS,EAAOT,GAAO,IAAexI,OAAO0G,0BAA6B1G,OAAOuP,iBAAiBpG,EAAQnJ,OAAO0G,0BAA0BuC,IAAmBge,GAAUjnB,OAAOiJ,IAASlH,SAAQ,SAAUyG,GAAOxI,OAAO8G,eAAeqC,EAAQX,EAAKxI,OAAOkF,yBAAyB+D,EAAQT,GAAO,GAAM,CAAE,OAAOW,CAAQ,CAE3hB,IAAIge,GAAsB,CAIxB,QAAAC,CAAS1X,GACP,IAAIC,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,GAC/E,KACF8P,EAAO,UACLf,GACA,UACFG,GACEJ,EAEJ,GAAKI,EAEE,GAAa,WAATY,EACT4S,GAAWD,OAAO3T,EAAQI,EAAUU,aAC/B,GAAa,UAATE,EACT4S,GAAWD,OAAO3T,EAAQI,EAAUa,YAC/B,GAAa,UAATD,EAAkB,CAC3B,IAAKI,GAAS6B,GAAMvB,MAAMtB,GAC1BwT,GAAWD,OAAO3T,EAAQoB,EAC5B,MAAO,GAAa,QAATJ,EAAgB,CACzB,IAAK,CAAE5E,GAAO6G,GAAMvB,MAAMtB,GAC1BwT,GAAWD,OAAO3T,EAAQ5D,EAC5B,CACF,EAKA,QAAAub,CAAS3X,GACP,IAAI,UACFI,GACEJ,EAEAI,GACFJ,EAAOvO,MAAM,CACXqJ,KAAM,gBACN8P,WAAYxK,EACZyK,cAAe,MAGrB,EAKA,IAAA+M,CAAK5X,GACH,IAAIC,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,GAC/E,UACFkP,GACEJ,GACA,SACFvF,EAAW,EAAC,KACZ6G,EAAO,YAAW,QAClBjB,GAAU,GACRJ,GACA,KACFe,EAAO,MACLf,EAEJ,GAAKG,EAAL,CAIa,UAATY,IACFA,EAAOiC,GAAMqK,WAAWlN,GAAa,QAAU,UAGpC,QAATY,IACFA,EAAOiC,GAAMqK,WAAWlN,GAAa,SAAW,SAGlD,IAAI,OACFU,EAAM,MACNG,GACEb,EACAyX,EAAO,CACTpd,WACA6G,QAEExC,EAAQ,CAAC,EAEb,GAAY,MAARkC,GAAyB,WAATA,EAAmB,CACrC,IAAID,EAAQV,EAAU/B,GAAO6C,OAAOnB,EAAQc,EAAQ+W,GAAQvZ,GAAOsC,MAAMZ,EAAQc,EAAQ+W,GAErF9W,IACFjC,EAAMgC,OAASC,EAEnB,CAEA,GAAY,MAARC,GAAyB,UAATA,EAAkB,CACpC,IAAIoP,EAAS/P,EAAU/B,GAAO6C,OAAOnB,EAAQiB,EAAO4W,GAAQvZ,GAAOsC,MAAMZ,EAAQiB,EAAO4W,GAEpFzH,IACFtR,EAAMmC,MAAQmP,EAElB,CAEAwD,GAAWkE,aAAa9X,EAAQlB,EApChC,CAqCF,EAKA,MAAA6U,CAAO3T,EAAQvG,GACb,IAAI,UACF2G,GACEJ,EAGJ,GAFAvG,EAAS6E,GAAOuC,MAAMb,EAAQvG,GAE1B2G,EACFwT,GAAWkE,aAAa9X,EAAQvG,OADlC,CAKA,IAAKwJ,GAAMC,QAAQzJ,GACjB,MAAM,IAAI/H,MAAM,qIAAqI2D,OAAO2T,GAASC,UAAUxP,KAGjLuG,EAAOvO,MAAM,CACXqJ,KAAM,gBACN8P,WAAYxK,EACZyK,cAAepR,GATjB,CAWF,EAKA,QAAAse,CAAS/X,EAAQlB,GACf,IAAImB,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,GAC/E,UACFkP,GACEJ,GACA,KACFgB,EAAO,QACLf,EAEJ,GAAKG,EAAL,CAIa,UAATY,IACFA,EAAOiC,GAAMqK,WAAWlN,GAAa,QAAU,UAGpC,QAATY,IACFA,EAAOiC,GAAMqK,WAAWlN,GAAa,SAAW,SAGlD,IAAI,OACFU,EAAM,MACNG,GACEb,EACAW,EAAiB,WAATC,EAAoBF,EAASG,EACzC2S,GAAWkE,aAAa9X,EAAQ,CAC9B,CAAU,WAATgB,EAAoB,SAAW,SAAUwW,GAAgBA,GAAgB,CAAC,EAAGzW,GAAQjC,IAhBxF,CAkBF,EAKA,YAAAgZ,CAAa9X,EAAQlB,GACnB,IAAI,UACFsB,GACEJ,EACAgY,EAAW,CAAC,EACZC,EAAW,CAAC,EAEhB,GAAK7X,EAAL,CAIA,IAAK,IAAIpL,KAAK8J,GACF,WAAN9J,GAAkC,MAAhB8J,EAAMgC,SAAmByC,GAAM7C,OAAO5B,EAAMgC,OAAQV,EAAUU,SAAiB,UAAN9L,GAAgC,MAAf8J,EAAMmC,QAAkBsC,GAAM7C,OAAO5B,EAAMmC,MAAOb,EAAUa,QAAgB,WAANjM,GAAwB,UAANA,GAAiB8J,EAAM9J,KAAOoL,EAAUpL,MAC9OgjB,EAAShjB,GAAKoL,EAAUpL,GACxBijB,EAASjjB,GAAK8J,EAAM9J,IAIpB1E,OAAO6B,KAAK6lB,GAAU7mB,OAAS,GACjC6O,EAAOvO,MAAM,CACXqJ,KAAM,gBACN8P,WAAYoN,EACZnN,cAAeoN,GAbnB,CAgBF,GAIEC,GAAiB,CAInB,OAAOlY,GACL,IAAIC,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,EACnFoN,GAAO6H,mBAAmBnG,GAAQ,KAChC,IAAI,QACFK,GAAU,EAAK,KACfiB,EAAO,YAAW,SAClB7G,EAAW,EAAC,MACZyF,GAAQ,GACND,GACA,GACFpE,EAAKmE,EAAOI,UAAS,QACrBsT,GAAU,GACRzT,EAEJ,GAAKpE,EAAL,CAIA,IAAI0M,GAAc,EAOlB,GALItF,GAAMC,QAAQrH,IAAOoH,GAAMsF,YAAY1M,KACzC0M,GAAc,EACd1M,EAAKA,EAAGiF,QAGNyC,GAAMuD,QAAQjL,GAAK,CACrB,IAAIsc,EAAe7Z,GAAO0V,KAAKhU,EAAQ,CACrCnE,KACAsE,KAAM,YAGR,IAAKD,GAASiY,EAAc,CAC1B,IAAK,CAAE7B,GAAY6B,EACnBtc,EAAKya,CACP,KAAO,CACL,IAAIuB,EAAO,CACTvW,OACA7G,YAGFoB,EAAK,CACHiF,OAAQjF,EACRoF,MAHWZ,EAAU/B,GAAO6C,OAAOnB,EAAQnE,EAAIgc,IAASvZ,GAAO8C,MAAMpB,EAAQ,IAAM1B,GAAOsC,MAAMZ,EAAQnE,EAAIgc,IAASvZ,GAAOlC,IAAI4D,EAAQ,KAK1I0T,GAAU,CACZ,CACF,CAEA,GAAIjT,GAAKmE,OAAO/I,GACd+X,GAAWU,YAAYtU,EAAQ,CAC7BnE,KACAqE,eAKJ,IAAI+C,GAAMsF,YAAY1M,GAAtB,CAIA,IAAK6X,EAAS,CACZ,IAAK,CAAE0E,GAAQnV,GAAMvB,MAAM7F,GACvBwc,EAAW/Z,GAAOlC,IAAI4D,EAAQ,IAE7BuD,GAAM7C,OAAO0X,EAAMC,KACtBxc,EAAKyC,GAAOgK,YAAYtI,EAAQnE,EAAI,CAClCqE,UAGN,CAEA,IAAKkB,EAAOhF,GAAO6G,GAAMvB,MAAM7F,GAC3Byc,EAAaha,GAAOyB,MAAMC,EAAQ,CACpC/B,MAAOjN,GAAKsN,GAAO0D,QAAQhC,EAAQhP,GACnC6K,GAAIuF,EACJlB,UAEEsI,EAAWlK,GAAOyB,MAAMC,EAAQ,CAClC/B,MAAOjN,GAAKsN,GAAO0D,QAAQhC,EAAQhP,GACnC6K,GAAIO,EACJ8D,UAEEqY,EAAiBD,GAAc9P,IAAa/H,GAAKC,OAAO4X,EAAW,GAAI9P,EAAS,IAChFgQ,EAAe/X,GAAKC,OAAOU,EAAMhJ,KAAMgE,EAAIhE,MAC3CqgB,EAAYvY,EAAQ,KAAO5B,GAAO0V,KAAKhU,EAAQ,CACjDnE,GAAIuF,EACJjB,KAAM,YAEJuY,EAAUxY,EAAQ,KAAO5B,GAAO0V,KAAKhU,EAAQ,CAC/CnE,GAAIO,EACJ+D,KAAM,YAGR,GAAIsY,EAAW,CACb,IAAItX,EAAS7C,GAAO6C,OAAOnB,EAAQoB,GAE/BD,GAAUmX,GAAc7X,GAAKhC,WAAW6Z,EAAW,GAAInX,EAAO/I,QAChEgJ,EAAQD,EAEZ,CAEA,GAAIuX,EAAS,CACX,IAAI9X,EAAQtC,GAAOsC,MAAMZ,EAAQ5D,GAE7BwE,GAAS4H,GAAY/H,GAAKhC,WAAW+J,EAAS,GAAI5H,EAAMxI,QAC1DgE,EAAMwE,EAEV,CAIA,IACIgG,EADA1H,EAAU,GAGd,IAAK,IAAImH,KAAS/H,GAAO0F,MAAMhE,EAAQ,CACrCnE,KACAqE,UACE,CACF,IAAK0B,EAAMxJ,GAAQiO,EAEfO,GAA6C,IAAjCnG,GAAK8E,QAAQnN,EAAMwO,MAI9B1G,GAAS5B,GAAOqE,OAAO3C,EAAQ4B,KAAUnB,GAAK0L,SAAS/T,EAAMgJ,EAAMhJ,QAAUqI,GAAK0L,SAAS/T,EAAMgE,EAAIhE,SACxG8G,EAAQ9I,KAAKiQ,GACbO,EAAWxO,EAEf,CAEA,IAAIiP,EAAWhW,MAAMiF,KAAK4I,GAASmG,IACjC,IAAK,CAAEtS,GAAKsS,EACZ,OAAO/G,GAAO0I,QAAQhH,EAAQjN,EAAE,IAE9B4lB,EAAWra,GAAOiJ,SAASvH,EAAQoB,GACnCwX,EAASta,GAAOiJ,SAASvH,EAAQ5D,GACjCyc,EAAc,GAElB,IAAKL,IAAiBC,EAAW,CAC/B,IAAIrI,EAASuI,EAASxR,SACjBlD,GAAS3F,GAAOwF,KAAK9D,EAAQoQ,IAEhChY,KAAM+X,GACJC,GACA,OACFxM,GACExC,EAEAqB,EAAOwB,EAAMxB,KAAKxP,MAAM2Q,GAExBnB,EAAKtR,OAAS,IAChB6O,EAAOvO,MAAM,CACXqJ,KAAM,cACN1C,KAAM+X,EACNvM,SACAnB,SAEFoW,EAAcpW,EAElB,CAOA,GALA4E,EAAShH,UAAU6F,KAAIjV,GAAKA,EAAEmW,UAAS1H,QAAOzO,GAAW,OAANA,IAAYoB,SAAQU,GAAK6gB,GAAWU,YAAYtU,EAAQ,CACzGnE,GAAI9I,EACJmN,aAGGwY,EAAS,CACZ,IAAIjI,EAAUmI,EAAOzR,SAChBmJ,GAAUhS,GAAOwF,KAAK9D,EAAQyQ,IAEjCrY,KAAMiY,GACJI,EAEAkB,EAAU6G,EAAepX,EAAMwC,OAAS,EAExCgO,EAAQtB,EAAO7N,KAAKxP,MAAM0e,EAASvV,EAAIwH,QAEvCgO,EAAMzgB,OAAS,IACjB6O,EAAOvO,MAAM,CACXqJ,KAAM,cACN1C,KAAMiY,EACNzM,OAAQ+N,EACRlP,KAAMmP,IAERiH,EAAcjH,EAElB,EAEK4G,GAAgBD,GAAkBK,EAAOzR,SAAWwR,EAASxR,SAChEyM,GAAWc,WAAW1U,EAAQ,CAC5BnE,GAAI+c,EAAOzR,QACXuM,SAAS,EACTxT,UAOAqI,GAAelI,GAAoB,cAATiB,GAAwBuX,EAAY1nB,OAAS,GAAK0nB,EAAY5a,MAAM,qBAChG2V,GAAWpR,WAAWxC,EAAQ6Y,EAAY5lB,MAAM,EAAG4lB,EAAY1nB,OAASsJ,IAG1E,IAAIqe,EAAaH,EAASvR,QACtB2R,EAAWH,EAAOxR,QAClBrG,EAAQV,EAAUyY,GAAcC,EAAWA,GAAYD,EAEzC,MAAd7Y,EAAQpE,IAAckF,GACxB6S,GAAWD,OAAO3T,EAAQe,EAtJ5B,CA1CA,CAiMA,GAEJ,EAKA,cAAAuB,CAAetC,EAAQ6B,GACrB,IAAI5B,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,EACnFoN,GAAO6H,mBAAmBnG,GAAQ,KAChC,IAAI,QACF0T,GAAU,EAAK,MACfxT,GAAQ,GACND,GACA,GACFpE,EAAKmE,EAAOI,WACVH,EAEJ,GAAK4B,EAAS1Q,QAIT0K,EAAL,CAEO,GAAIoH,GAAMC,QAAQrH,GAKvB,GAJK6X,IACH7X,EAAKyC,GAAOgK,YAAYtI,EAAQnE,IAG9BoH,GAAMsF,YAAY1M,GACpBA,EAAKA,EAAGiF,WACH,CACL,IAAK,CAAE1E,GAAO6G,GAAMvB,MAAM7F,GAE1B,IAAKqE,GAAS5B,GAAO0V,KAAKhU,EAAQ,CAChCnE,GAAIO,IAEJ,OAGF,IAAImL,EAAWjJ,GAAOiJ,SAASvH,EAAQ5D,GACvCwX,GAAWhgB,OAAOoM,EAAQ,CACxBnE,OAEFA,EAAK0L,EAASH,OAChB,MACS3G,GAAKmE,OAAO/I,KACrBA,EAAKyC,GAAO8C,MAAMpB,EAAQnE,IAG5B,GAAKqE,IAAS5B,GAAO0V,KAAKhU,EAAQ,CAChCnE,OADF,CAQA,IAAImd,EAAqB1a,GAAOyB,MAAMC,EAAQ,CAC5CnE,KACAoC,MAAOjN,GAAKsN,GAAO4D,SAASlC,EAAQhP,GACpCmP,KAAM,UACND,UAGF,GAAI8Y,EAAoB,CACtB,IAAK,CAAEC,GAAeD,EAEtB,GAAI1a,GAAOgF,MAAMtD,EAAQnE,EAAIod,GAE3Bpd,EADYyC,GAAOsC,MAAMZ,EAAQiZ,QAE5B,GAAI3a,GAAOmF,QAAQzD,EAAQnE,EAAIod,GAAc,CAElDpd,EADayC,GAAO6C,OAAOnB,EAAQiZ,EAErC,CACF,CAEA,IAAIC,EAAa5a,GAAOyB,MAAMC,EAAQ,CACpC/B,MAAOjN,GAAKsN,GAAO0D,QAAQhC,EAAQhP,GACnC6K,KACAqE,WAEG,CAAEqE,GAAa2U,EAChBC,EAAe7a,GAAOmF,QAAQzD,EAAQnE,EAAI0I,GAC1C6U,EAAa9a,GAAOgF,MAAMtD,EAAQnE,EAAI0I,GACtC8U,EAAeF,GAAgBC,EAC/BE,GAAcH,GAAgBA,GAAgBC,EAC9CG,GAAYH,GACX,CAAEzS,GAAaxI,GAAKwD,MAAM,CAC7BtD,SAAUwD,GACT,KACE,CAAE+E,GAAYzI,GAAK0F,KAAK,CAC3BxF,SAAUwD,GACT,IACC3C,EAAU,GAEVsa,EAAUxT,IACZ,IAAKhV,EAAG+B,GAAKiT,EAGb,QAF0B,IAAbjT,EAAE5B,YAMXkoB,KAIAC,GAAc7Y,GAAKhC,WAAW1L,EAAG4T,IAAcnI,GAAQN,UAAUlN,KAAOgP,EAAO2C,OAAO3R,KAAOgP,EAAOkC,SAASlR,OAI7GuoB,GAAY9Y,GAAKhC,WAAW1L,EAAG6T,IAAapI,GAAQN,UAAUlN,KAAOgP,EAAO2C,OAAO3R,KAAOgP,EAAOkC,SAASlR,IAInG,EAGb,IAAK,IAAIqV,KAASlI,GAAK6F,MAAM,CAC3B3F,SAAUwD,GACT,CACDuD,KAAMoU,IAEFA,EAAQnT,IACVnH,EAAQ9I,KAAKiQ,GAIjB,IAAIoT,EAAS,GACTC,EAAU,GACVC,EAAO,GACPC,GAAW,EACX9X,GAAY,EAEhB,IAAK,IAAKF,KAAS1C,EACbV,GAAQN,UAAU0D,KAAU5B,EAAOkC,SAASN,IAC9CgY,GAAW,EACX9X,GAAY,EACZ4X,EAAQtjB,KAAKwL,IACJgY,EACTH,EAAOrjB,KAAKwL,GAEZ+X,EAAKvjB,KAAKwL,GAId,IAAKiY,GAAevb,GAAO0F,MAAMhE,EAAQ,CACvCnE,KACAoC,MAAOjN,GAAKuP,GAAKC,OAAOxP,IAAMsN,GAAO4D,SAASlC,EAAQhP,GACtDmP,KAAM,UACND,WAEG,CAAE4Z,GAAcD,EACjBE,EAAgBzb,GAAOmF,QAAQzD,EAAQnE,EAAIie,GAC3CE,EAAc1b,GAAOgF,MAAMtD,EAAQnE,EAAIie,GACvCG,EAAY3b,GAAO0I,QAAQhH,EAAQoZ,IAAeO,EAAKxoB,OAASsP,GAAK+D,KAAKD,GAAaA,GACvFqU,EAASta,GAAO0I,QAAQhH,EAAQga,EAAcvZ,GAAK+D,KAAKsV,GAAcA,GAC1ElG,GAAWG,WAAW/T,EAAQ,CAC5BnE,KACAoC,MAAOjN,GAAK8Q,EAAYxD,GAAO0D,QAAQhC,EAAQhP,GAAKuP,GAAKC,OAAOxP,IAAMsN,GAAO4D,SAASlC,EAAQhP,GAC9FmP,KAAM2B,EAAY,SAAW,UAC7B4T,OAAQ5T,KAAeqX,GAAgBM,EAAOtoB,OAAS,MAAQioB,GAAcO,EAAKxoB,OAAS,GAC3F+O,UAEF,IA6BM9H,EA7BFugB,EAAWra,GAAO0I,QAAQhH,GAAS+Z,GAAiBA,GAAiBC,EAAcvZ,GAAK+D,KAAKsV,GAAcA,GA4B/G,GA3BAlG,GAAWH,YAAYzT,EAAQyZ,EAAQ,CACrC5d,GAAI8c,EAASxR,QACblJ,MAAOjN,GAAKuP,GAAKC,OAAOxP,IAAMsN,GAAO4D,SAASlC,EAAQhP,GACtDmP,KAAM,UACND,UAGEmZ,IAAiBI,EAAOtoB,QAAUuoB,EAAQvoB,SAAWwoB,EAAKxoB,QAC5DyiB,GAAWhgB,OAAOoM,EAAQ,CACxBnE,GAAI0I,EACJrE,UAIJ0T,GAAWH,YAAYzT,EAAQ0Z,EAAS,CACtC7d,GAAIoe,EAAU9S,QACdlJ,MAAOjN,GAAKsN,GAAO0D,QAAQhC,EAAQhP,GACnCmP,KAAM,SACND,UAEF0T,GAAWH,YAAYzT,EAAQ2Z,EAAM,CACnC9d,GAAI+c,EAAOzR,QACXlJ,MAAOjN,GAAKuP,GAAKC,OAAOxP,IAAMsN,GAAO4D,SAASlC,EAAQhP,GACtDmP,KAAM,UACND,WAGGD,EAAQpE,GAWX,GARI8d,EAAKxoB,OAAS,GAAKynB,EAAOzR,QAC5B/O,EAAOqI,GAAK0D,SAASyU,EAAOzR,SACnBuS,EAAQvoB,OAAS,GAAK8oB,EAAU9S,QACzC/O,EAAOqI,GAAK0D,SAAS8V,EAAU9S,SACtBwR,EAASxR,UAClB/O,EAAOqI,GAAK0D,SAASwU,EAASxR,UAG5B/O,EAAM,CACR,IAAI8hB,EAAQ5b,GAAOlC,IAAI4D,EAAQ5H,GAE/Bwb,GAAWD,OAAO3T,EAAQka,EAC5B,CAGFvB,EAASvR,QACT6S,EAAU7S,QACVwR,EAAOxR,OA/JP,CANA,CAqKc,GAElB,EAKA,UAAA5E,CAAWxC,EAAQyC,GACjB,IAAIxC,EAAU/O,UAAUC,OAAS,QAAsBN,IAAjBK,UAAU,GAAmBA,UAAU,GAAK,CAAC,EACnFoN,GAAO6H,mBAAmBnG,GAAQ,KAChC,IAAI,MACFE,GAAQ,GACND,GACA,GACFpE,EAAKmE,EAAOI,WACVH,EAEJ,GAAKpE,EAAL,CAQA,GAJI4E,GAAKmE,OAAO/I,KACdA,EAAKyC,GAAOuC,MAAMb,EAAQnE,IAGxBoH,GAAMC,QAAQrH,GAChB,GAAIoH,GAAMsF,YAAY1M,GACpBA,EAAKA,EAAGiF,WACH,CACL,IAAI1E,EAAM6G,GAAM7G,IAAIP,GAEpB,IAAKqE,GAAS5B,GAAO0V,KAAKhU,EAAQ,CAChCnE,GAAIO,IAEJ,OAGF,IAAIgF,EAAQ6B,GAAM7B,MAAMvF,GACpB8c,EAAWra,GAAOiJ,SAASvH,EAAQoB,GACnCwX,EAASta,GAAOiJ,SAASvH,EAAQ5D,GACrCwX,GAAWhgB,OAAOoM,EAAQ,CACxBnE,KACAqE,UAEF,IAAIia,EAAaxB,EAASvR,QACtBgT,EAAWxB,EAAOxR,QACtBvL,EAAKse,GAAcC,EACnBxG,GAAWkE,aAAa9X,EAAQ,CAC9Bc,OAAQjF,EACRoF,MAAOpF,GAEX,CAGF,GAAKqE,IAAS5B,GAAO0V,KAAKhU,EAAQ,CAChCnE,OADF,CAMA,IAAI,KACFzD,EAAI,OACJwL,GACE/H,EACA4G,EAAKtR,OAAS,GAAG6O,EAAOvO,MAAM,CAChCqJ,KAAM,cACN1C,OACAwL,SACAnB,QAVF,CAvCA,CAkDE,GAEN,GAIF,SAAS5L,GAAQ0I,EAAQC,GAAkB,IAAIrN,EAAO7B,OAAO6B,KAAKoN,GAAS,GAAIjP,OAAOwG,sBAAuB,CAAE,IAAI2I,EAAUnP,OAAOwG,sBAAsByI,GAAaC,IAAkBC,EAAUA,EAAQC,QAAO,SAAUC,GAAO,OAAOrP,OAAOkF,yBAAyB+J,EAAQI,GAAKrM,UAAY,KAAMnB,EAAKiE,KAAK3E,MAAMU,EAAMsN,EAAU,CAAE,OAAOtN,CAAM,CAExV,SAASkoB,GAAc5gB,GAAU,IAAK,IAAIlI,EAAI,EAAGA,EAAIL,UAAUC,OAAQI,IAAK,CAAE,IAAIgI,EAAyB,MAAhBrI,UAAUK,GAAaL,UAAUK,GAAK,CAAC,EAAOA,EAAI,EAAKsF,GAAQvG,OAAOiJ,IAAS,GAAMlH,SAAQ,SAAUyG,GAAOF,GAAgBa,EAAQX,EAAKS,EAAOT,GAAO,IAAexI,OAAO0G,0BAA6B1G,OAAOuP,iBAAiBpG,EAAQnJ,OAAO0G,0BAA0BuC,IAAmB1C,GAAQvG,OAAOiJ,IAASlH,SAAQ,SAAUyG,GAAOxI,OAAO8G,eAAeqC,EAAQX,EAAKxI,OAAOkF,yBAAyB+D,EAAQT,GAAO,GAAM,CAAE,OAAOW,CAAQ,CACrhB,IAAIma,GAAayG,GAAcA,GAAcA,GAAcA,GAAc,CAAC,EAAGnK,IAAoBsD,IAAiBiE,IAAsBS,IA0BxI,IACIoC,GACM,6BA1BV,SAAuBC,EAAKrT,QACd,IAARA,IAAgBA,EAAM,CAAC,GAC3B,IAAIsT,EAAWtT,EAAIsT,SACnB,GAAKD,GAA2B,oBAAbE,SAAnB,CAGA,IAAIC,EAAOD,SAASC,MAAQD,SAASE,qBAAqB,QAAQ,GAC9DC,EAAQH,SAASI,cAAc,SACnCD,EAAM9f,KAAO,WACI,QAAb0f,GACEE,EAAKI,WACPJ,EAAKK,aAAaH,EAAOF,EAAKI,YAKhCJ,EAAKM,YAAYJ,GAEfA,EAAMK,WACRL,EAAMK,WAAWC,QAAUX,EAE3BK,EAAMI,YAAYP,SAASU,eAAeZ,GAhB5C,CAkBF,CAKAa,CAJiB,kGASjB,IAAIC,GAAY,SAAmBhW,GACjC,IAAIiW,EAAwBjW,EAAKiW,sBAC/BC,EAAOlW,EAAKkW,KACd,OAAoB,kBAAoB,MAAa,CACnDC,UAAWlB,IARf,SAA4BiB,EAAMD,GAChC,IAAIG,EAAU,IAAIC,KAAKA,KAAKC,IAAIJ,EAAKK,iBAAkBL,EAAKM,cAAeN,EAAKO,aAAcP,EAAKQ,cAAeR,EAAKS,gBAAiBT,EAAKU,kBAC7I,OAAOX,EAAsBY,OAAOT,EACtC,CAMKU,CAAmBZ,EAAMD,GAC9B,EAMA,SAASc,KAYP,OAXAA,GAAW9rB,OAAOsf,OAAStf,OAAOsf,OAAOnX,OAAS,SAAUgB,GAC1D,IAAK,IAAIlI,EAAI,EAAGA,EAAIL,UAAUC,OAAQI,IAAK,CACzC,IAAIgI,EAASrI,UAAUK,GACvB,IAAK,IAAIuH,KAAOS,EACVjJ,OAAOC,UAAUQ,eAAeN,KAAK8I,EAAQT,KAC/CW,EAAOX,GAAOS,EAAOT,GAG3B,CACA,OAAOW,CACT,EACO2iB,GAAS3qB,MAAM6F,KAAMpG,UAC9B,CAaA,SAASmrB,GAAyB9iB,EAAQC,GACxC,GAAc,MAAVD,EAAgB,MAAO,CAAC,EAC5B,IACIT,EAAKvH,EADLkI,EAdN,SAAuCF,EAAQC,GAC7C,GAAc,MAAVD,EAAgB,MAAO,CAAC,EAC5B,IAEIT,EAAKvH,EAFLkI,EAAS,CAAC,EACVC,EAAapJ,OAAO6B,KAAKoH,GAE7B,IAAKhI,EAAI,EAAGA,EAAImI,EAAWvI,OAAQI,IACjCuH,EAAMY,EAAWnI,GACbiI,EAASG,QAAQb,IAAQ,IAC7BW,EAAOX,GAAOS,EAAOT,IAEvB,OAAOW,CACT,CAGe6iB,CAA8B/iB,EAAQC,GAEnD,GAAIlJ,OAAOwG,sBAAuB,CAChC,IAAI+C,EAAmBvJ,OAAOwG,sBAAsByC,GACpD,IAAKhI,EAAI,EAAGA,EAAIsI,EAAiB1I,OAAQI,IACvCuH,EAAMe,EAAiBtI,GACnBiI,EAASG,QAAQb,IAAQ,GACxBxI,OAAOC,UAAUuJ,qBAAqBrJ,KAAK8I,EAAQT,KACxDW,EAAOX,GAAOS,EAAOT,GAEzB,CACA,OAAOW,CACT,CA7CA4hB,GAAUkB,UAAY,CACpBjB,sBAAuB,QACvBC,KAAM,YAoER,IACIiB,GACa,mCADbA,GAEe,qCAFfA,GAGY,kCAHZA,GAImB,yCAJnBA,GAKkB,yCA9BtB,SAAuBjC,EAAKrT,QACd,IAARA,IAAgBA,EAAM,CAAC,GAC3B,IAAIsT,EAAWtT,EAAIsT,SACnB,GAAKD,GAA2B,oBAAbE,SAAnB,CAGA,IAAIC,EAAOD,SAASC,MAAQD,SAASE,qBAAqB,QAAQ,GAC9DC,EAAQH,SAASI,cAAc,SACnCD,EAAM9f,KAAO,WACI,QAAb0f,GACEE,EAAKI,WACPJ,EAAKK,aAAaH,EAAOF,EAAKI,YAKhCJ,EAAKM,YAAYJ,GAEfA,EAAMK,WACRL,EAAMK,WAAWC,QAAUX,EAE3BK,EAAMI,YAAYP,SAASU,eAAeZ,GAhB5C,CAkBF,CASAkC,CARiB,iiBASjB,IAAIC,GAAY,CAAC,aAAc,UAAW,SAAU,UAAW,YAC3DC,GAAa,SAAoBtX,GACnC,IAWMmW,EAXFoB,EAAkBvX,EAAKwX,WACzBA,OAAiC,IAApBD,GAAqCA,EAClDE,EAAezX,EAAK0X,QACpBA,OAA2B,IAAjBD,GAAkCA,EAC5CE,EAAc3X,EAAK4X,OACnBA,OAAyB,IAAhBD,EAAyB,EAAIA,EACtCE,EAAU7X,EAAK6X,QACfC,EAAgB9X,EAAK+X,SACrBA,OAA6B,IAAlBD,EAA2B,UAAYA,EAClDrP,EAAOuO,GAAyBhX,EAAMqX,IAkBxC,OAAOG,EAA0B,kBAAoB,MAAO,CAC1D/hB,KAAM,UACNuiB,SAAU,MACV,aAAcH,GACbD,GAAU,GAAkB,kBAAoB,MAAQb,GAAS,CAAC,EAAGtO,EAAM,CAC5EwP,cAAeP,EAAU,MAAuB,MAChDvB,UAAW,GAAGnmB,QAtBVmmB,EAAY,GAAGnmB,OAAOmnB,IAExBhB,GAAa,IAAInmB,OADf4nB,EAAS,EACaT,GAEAA,IAET,YAAbY,EACK5B,EAGPA,GAAa,IAAInmB,OADf0nB,EACsBP,GAEAA,MAW1Be,WAAW,EACXC,iBAAkBN,EAClB,aAAcA,EACdE,SAAUA,IACRH,EAAS,GAAKA,EACpB,EACAN,GAAWJ,UAAY,CACrBM,WAAY,SACZE,QAAS,SACTE,OAAQ,WACRC,QAAS,WACTE,SAAU,WACVK,QAAS,UA4BX,IACIC,GAAgC,2CAAhCA,GAAsG,gDAAtGA,GAA6J,4BAA7JA,GAAqN,iDAArNA,GAAiS,iDA1BrS,SAAqBnD,EAAKrT,QACZ,IAARA,IAAgBA,EAAM,CAAC,GAC3B,IAAIsT,EAAWtT,EAAIsT,SACnB,GAAKD,GAA2B,oBAAbE,SAAnB,CAGA,IAAIC,EAAOD,SAASC,MAAQD,SAASE,qBAAqB,QAAQ,GAC9DC,EAAQH,SAASI,cAAc,SACnCD,EAAM9f,KAAO,WACI,QAAb0f,GACEE,EAAKI,WACPJ,EAAKK,aAAaH,EAAOF,EAAKI,YAKhCJ,EAAKM,YAAYJ,GAEfA,EAAMK,WACRL,EAAMK,WAAWC,QAAUX,EAE3BK,EAAMI,YAAYP,SAASU,eAAeZ,GAhB5C,CAkBF,CAIAoD,CAFe,8iBAIf,IAUIC,GAAyB,SAAgCvY,GAC3D,IAAIwY,EAAuBxY,EAAKwY,qBAC9BC,EAAyBzY,EAAKyY,uBAC9BvC,EAAOlW,EAAKkW,KACZD,EAAwBjW,EAAKiW,sBAC7ByC,EAAK1Y,EAAK0Y,GACVC,EAAkB3Y,EAAK2Y,gBACvBC,EAAe5Y,EAAK4Y,aAClBC,EAlBwB,SAAiCC,GAC7D,IACE,IAAIC,EAAeD,EAAYjY,KAAI,SAAUlV,GAC3C,OAAOmN,GAAK0J,OAAO7W,EACrB,IAAG6U,KAAK,MACR,OAAOuY,CACT,CAAE,MAAO9sB,GACP,OAAO,CACT,CACF,CASyB+sB,CAAwBP,GAO/C,OAAoB,kBAAoB,MAAO,CAC7CtC,UAAWkC,GACXY,SAAU,IACVC,UATgB,SAAqBC,GACnB,UAAdA,EAAM1lB,KAAiC,MAAd0lB,EAAM1lB,MACjC0lB,EAAMC,iBACNR,IAEJ,EAKER,QAASQ,GACK,kBAAoB,MAAM,CACxCF,GAAIA,EACJW,KAAM,MACQ,kBAAoB,MAAKC,OAAQ,CAC/CnD,UAAWkC,IACVG,EAAmC,kBAAoBxC,GAAW,CACnEE,KAAMA,EACNC,UAAWkC,GACXpC,sBAAuBA,KACP,kBAAoB,MAAKsD,QAAS,CAClDpD,UAAWkC,IACVQ,GAAgC,kBAAoB,MAAKW,OAAQ,CAClErD,UAAWkC,IACG,kBAAoBf,GAAYqB,KAClD,EACAJ,GAAuBrB,UAAY,CACjCsB,qBAAsB,WACtBC,uBAAwB,UACxBvC,KAAM,WACND,sBAAuB,QACvByC,GAAI,WACJE,aAAc,SACdD,gBAAiB,UAAgB,CAC/BP,QAAS,SACTZ,WAAY,SACZI,OAAQ,WACRF,QAAS,SACTG,QAAS","sources":["webpack:///../../node_modules/@paypalcorp/donate-react-organizer-update-preview/dist/donate-react-organizer-update-preview.esm.js"],"sourcesContent":["import React from 'react';\nimport PropTypes from 'prop-types';\nimport { CaptionText, Badge, FavoriteIcon, Button, FavoriteSelectedIcon, Card } from '@paypalcorp/pp-react';\n\n/*!\n * is-plain-object <https://github.com/jonschlinkert/is-plain-object>\n *\n * Copyright (c) 2014-2017, Jon Schlinkert.\n * Released under the MIT License.\n */\n\nfunction isObject(o) {\n  return Object.prototype.toString.call(o) === '[object Object]';\n}\n\nfunction isPlainObject(o) {\n  var ctor,prot;\n\n  if (isObject(o) === false) return false;\n\n  // If has modified constructor\n  ctor = o.constructor;\n  if (ctor === undefined) return true;\n\n  // If has modified prototype\n  prot = ctor.prototype;\n  if (isObject(prot) === false) return false;\n\n  // If constructor does not have an Object-specific method\n  if (prot.hasOwnProperty('isPrototypeOf') === false) {\n    return false;\n  }\n\n  // Most likely a plain Object\n  return true;\n}\n\nfunction n(n){for(var r=arguments.length,t=Array(r>1?r-1:0),e=1;e<r;e++)t[e-1]=arguments[e];{var i=Y[n],o=i?\"function\"==typeof i?i.apply(null,t):i:\"unknown error nr: \"+n;throw Error(\"[Immer] \"+o)}}function r(n){return !!n&&!!n[Q]}function t(n){var r;return !!n&&(function(n){if(!n||\"object\"!=typeof n)return !1;var r=Object.getPrototypeOf(n);if(null===r)return !0;var t=Object.hasOwnProperty.call(r,\"constructor\")&&r.constructor;return t===Object||\"function\"==typeof t&&Function.toString.call(t)===Z}(n)||Array.isArray(n)||!!n[L]||!!(null===(r=n.constructor)||void 0===r?void 0:r[L])||s(n)||v(n))}function i(n,r,t){void 0===t&&(t=!1),0===o(n)?(t?Object.keys:nn)(n).forEach((function(e){t&&\"symbol\"==typeof e||r(e,n[e],n);})):n.forEach((function(t,e){return r(e,t,n)}));}function o(n){var r=n[Q];return r?r.i>3?r.i-4:r.i:Array.isArray(n)?1:s(n)?2:v(n)?3:0}function u(n,r){return 2===o(n)?n.has(r):Object.prototype.hasOwnProperty.call(n,r)}function a(n,r){return 2===o(n)?n.get(r):n[r]}function f(n,r,t){var e=o(n);2===e?n.set(r,t):3===e?n.add(t):n[r]=t;}function c(n,r){return n===r?0!==n||1/n==1/r:n!=n&&r!=r}function s(n){return X&&n instanceof Map}function v(n){return q&&n instanceof Set}function p(n){return n.o||n.t}function l(n){if(Array.isArray(n))return Array.prototype.slice.call(n);var r=rn(n);delete r[Q];for(var t=nn(r),e=0;e<t.length;e++){var i=t[e],o=r[i];!1===o.writable&&(o.writable=!0,o.configurable=!0),(o.get||o.set)&&(r[i]={configurable:!0,writable:!0,enumerable:o.enumerable,value:n[i]});}return Object.create(Object.getPrototypeOf(n),r)}function d(n,e){return void 0===e&&(e=!1),y(n)||r(n)||!t(n)||(o(n)>1&&(n.set=n.add=n.clear=n.delete=h),Object.freeze(n),e&&i(n,(function(n,r){return d(r,!0)}),!0)),n}function h(){n(2);}function y(n){return null==n||\"object\"!=typeof n||Object.isFrozen(n)}function b(r){var t=tn[r];return t||n(18,r),t}function _(){return U||n(0),U}function j(n,r){r&&(b(\"Patches\"),n.u=[],n.s=[],n.v=r);}function g(n){O(n),n.p.forEach(S),n.p=null;}function O(n){n===U&&(U=n.l);}function w(n){return U={p:[],l:U,h:n,m:!0,_:0}}function S(n){var r=n[Q];0===r.i||1===r.i?r.j():r.g=!0;}function P(r,e){e._=e.p.length;var i=e.p[0],o=void 0!==r&&r!==i;return e.h.O||b(\"ES5\").S(e,r,o),o?(i[Q].P&&(g(e),n(4)),t(r)&&(r=M(e,r),e.l||x(e,r)),e.u&&b(\"Patches\").M(i[Q].t,r,e.u,e.s)):r=M(e,i,[]),g(e),e.u&&e.v(e.u,e.s),r!==H?r:void 0}function M(n,r,t){if(y(r))return r;var e=r[Q];if(!e)return i(r,(function(i,o){return A(n,e,r,i,o,t)}),!0),r;if(e.A!==n)return r;if(!e.P)return x(n,e.t,!0),e.t;if(!e.I){e.I=!0,e.A._--;var o=4===e.i||5===e.i?e.o=l(e.k):e.o,u=o,a=!1;3===e.i&&(u=new Set(o),o.clear(),a=!0),i(u,(function(r,i){return A(n,e,o,r,i,t,a)})),x(n,o,!1),t&&n.u&&b(\"Patches\").N(e,t,n.u,n.s);}return e.o}function A(e,i,o,a,c,s,v){if(c===o&&n(5),r(c)){var p=M(e,c,s&&i&&3!==i.i&&!u(i.R,a)?s.concat(a):void 0);if(f(o,a,p),!r(p))return;e.m=!1;}else v&&o.add(c);if(t(c)&&!y(c)){if(!e.h.D&&e._<1)return;M(e,c),i&&i.A.l||x(e,c);}}function x(n,r,t){void 0===t&&(t=!1),!n.l&&n.h.D&&n.m&&d(r,t);}function z(n,r){var t=n[Q];return (t?p(t):n)[r]}function I(n,r){if(r in n)for(var t=Object.getPrototypeOf(n);t;){var e=Object.getOwnPropertyDescriptor(t,r);if(e)return e;t=Object.getPrototypeOf(t);}}function k(n){n.P||(n.P=!0,n.l&&k(n.l));}function E(n){n.o||(n.o=l(n.t));}function N(n,r,t){var e=s(r)?b(\"MapSet\").F(r,t):v(r)?b(\"MapSet\").T(r,t):n.O?function(n,r){var t=Array.isArray(n),e={i:t?1:0,A:r?r.A:_(),P:!1,I:!1,R:{},l:r,t:n,k:null,o:null,j:null,C:!1},i=e,o=en;t&&(i=[e],o=on);var u=Proxy.revocable(i,o),a=u.revoke,f=u.proxy;return e.k=f,e.j=a,f}(r,t):b(\"ES5\").J(r,t);return (t?t.A:_()).p.push(e),e}function R(e){return r(e)||n(22,e),function n(r){if(!t(r))return r;var e,u=r[Q],c=o(r);if(u){if(!u.P&&(u.i<4||!b(\"ES5\").K(u)))return u.t;u.I=!0,e=D(r,c),u.I=!1;}else e=D(r,c);return i(e,(function(r,t){u&&a(u.t,r)===t||f(e,r,n(t));})),3===c?new Set(e):e}(e)}function D(n,r){switch(r){case 2:return new Map(n);case 3:return Array.from(n)}return l(n)}var G,U,W=\"undefined\"!=typeof Symbol&&\"symbol\"==typeof Symbol(\"x\"),X=\"undefined\"!=typeof Map,q=\"undefined\"!=typeof Set,B=\"undefined\"!=typeof Proxy&&void 0!==Proxy.revocable&&\"undefined\"!=typeof Reflect,H=W?Symbol.for(\"immer-nothing\"):((G={})[\"immer-nothing\"]=!0,G),L=W?Symbol.for(\"immer-draftable\"):\"__$immer_draftable\",Q=W?Symbol.for(\"immer-state\"):\"__$immer_state\",Y={0:\"Illegal state\",1:\"Immer drafts cannot have computed properties\",2:\"This object has been frozen and should not be mutated\",3:function(n){return \"Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? \"+n},4:\"An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.\",5:\"Immer forbids circular references\",6:\"The first or second argument to `produce` must be a function\",7:\"The third argument to `produce` must be a function or undefined\",8:\"First argument to `createDraft` must be a plain object, an array, or an immerable object\",9:\"First argument to `finishDraft` must be a draft returned by `createDraft`\",10:\"The given draft is already finalized\",11:\"Object.defineProperty() cannot be used on an Immer draft\",12:\"Object.setPrototypeOf() cannot be used on an Immer draft\",13:\"Immer only supports deleting array indices\",14:\"Immer only supports setting array indices and the 'length' property\",15:function(n){return \"Cannot apply patch, path doesn't resolve: \"+n},16:'Sets cannot have \"replace\" patches.',17:function(n){return \"Unsupported patch operation: \"+n},18:function(n){return \"The plugin for '\"+n+\"' has not been loaded into Immer. To enable the plugin, import and call `enable\"+n+\"()` when initializing your application.\"},20:\"Cannot use proxies if Proxy, Proxy.revocable or Reflect are not available\",21:function(n){return \"produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '\"+n+\"'\"},22:function(n){return \"'current' expects a draft, got: \"+n},23:function(n){return \"'original' expects a draft, got: \"+n},24:\"Patching reserved attributes like __proto__, prototype and constructor is not allowed\"},Z=\"\"+Object.prototype.constructor,nn=\"undefined\"!=typeof Reflect&&Reflect.ownKeys?Reflect.ownKeys:void 0!==Object.getOwnPropertySymbols?function(n){return Object.getOwnPropertyNames(n).concat(Object.getOwnPropertySymbols(n))}:Object.getOwnPropertyNames,rn=Object.getOwnPropertyDescriptors||function(n){var r={};return nn(n).forEach((function(t){r[t]=Object.getOwnPropertyDescriptor(n,t);})),r},tn={},en={get:function(n,r){if(r===Q)return n;var e=p(n);if(!u(e,r))return function(n,r,t){var e,i=I(r,t);return i?\"value\"in i?i.value:null===(e=i.get)||void 0===e?void 0:e.call(n.k):void 0}(n,e,r);var i=e[r];return n.I||!t(i)?i:i===z(n.t,r)?(E(n),n.o[r]=N(n.A.h,i,n)):i},has:function(n,r){return r in p(n)},ownKeys:function(n){return Reflect.ownKeys(p(n))},set:function(n,r,t){var e=I(p(n),r);if(null==e?void 0:e.set)return e.set.call(n.k,t),!0;if(!n.P){var i=z(p(n),r),o=null==i?void 0:i[Q];if(o&&o.t===t)return n.o[r]=t,n.R[r]=!1,!0;if(c(t,i)&&(void 0!==t||u(n.t,r)))return !0;E(n),k(n);}return n.o[r]===t&&(void 0!==t||r in n.o)||Number.isNaN(t)&&Number.isNaN(n.o[r])||(n.o[r]=t,n.R[r]=!0),!0},deleteProperty:function(n,r){return void 0!==z(n.t,r)||r in n.t?(n.R[r]=!1,E(n),k(n)):delete n.R[r],n.o&&delete n.o[r],!0},getOwnPropertyDescriptor:function(n,r){var t=p(n),e=Reflect.getOwnPropertyDescriptor(t,r);return e?{writable:!0,configurable:1!==n.i||\"length\"!==r,enumerable:e.enumerable,value:t[r]}:e},defineProperty:function(){n(11);},getPrototypeOf:function(n){return Object.getPrototypeOf(n.t)},setPrototypeOf:function(){n(12);}},on={};i(en,(function(n,r){on[n]=function(){return arguments[0]=arguments[0][0],r.apply(this,arguments)};})),on.deleteProperty=function(r,t){return isNaN(parseInt(t))&&n(13),on.set.call(this,r,t,void 0)},on.set=function(r,t,e){return \"length\"!==t&&isNaN(parseInt(t))&&n(14),en.set.call(this,r[0],t,e,r[0])};var un=function(){function e(r){var e=this;this.O=B,this.D=!0,this.produce=function(r,i,o){if(\"function\"==typeof r&&\"function\"!=typeof i){var u=i;i=r;var a=e;return function(n){var r=this;void 0===n&&(n=u);for(var t=arguments.length,e=Array(t>1?t-1:0),o=1;o<t;o++)e[o-1]=arguments[o];return a.produce(n,(function(n){var t;return (t=i).call.apply(t,[r,n].concat(e))}))}}var f;if(\"function\"!=typeof i&&n(6),void 0!==o&&\"function\"!=typeof o&&n(7),t(r)){var c=w(e),s=N(e,r,void 0),v=!0;try{f=i(s),v=!1;}finally{v?g(c):O(c);}return \"undefined\"!=typeof Promise&&f instanceof Promise?f.then((function(n){return j(c,o),P(n,c)}),(function(n){throw g(c),n})):(j(c,o),P(f,c))}if(!r||\"object\"!=typeof r){if(void 0===(f=i(r))&&(f=r),f===H&&(f=void 0),e.D&&d(f,!0),o){var p=[],l=[];b(\"Patches\").M(r,f,p,l),o(p,l);}return f}n(21,r);},this.produceWithPatches=function(n,r){if(\"function\"==typeof n)return function(r){for(var t=arguments.length,i=Array(t>1?t-1:0),o=1;o<t;o++)i[o-1]=arguments[o];return e.produceWithPatches(r,(function(r){return n.apply(void 0,[r].concat(i))}))};var t,i,o=e.produce(n,r,(function(n,r){t=n,i=r;}));return \"undefined\"!=typeof Promise&&o instanceof Promise?o.then((function(n){return [n,t,i]})):[o,t,i]},\"boolean\"==typeof(null==r?void 0:r.useProxies)&&this.setUseProxies(r.useProxies),\"boolean\"==typeof(null==r?void 0:r.autoFreeze)&&this.setAutoFreeze(r.autoFreeze);}var i=e.prototype;return i.createDraft=function(e){t(e)||n(8),r(e)&&(e=R(e));var i=w(this),o=N(this,e,void 0);return o[Q].C=!0,O(i),o},i.finishDraft=function(r,t){var e=r&&r[Q];(e&&e.C||n(9),e.I&&n(10));var i=e.A;return j(i,t),P(void 0,i)},i.setAutoFreeze=function(n){this.D=n;},i.setUseProxies=function(r){r&&!B&&n(20),this.O=r;},i.applyPatches=function(n,t){var e;for(e=t.length-1;e>=0;e--){var i=t[e];if(0===i.path.length&&\"replace\"===i.op){n=i.value;break}}e>-1&&(t=t.slice(e+1));var o=b(\"Patches\").$;return r(n)?o(n,t):this.produce(n,(function(n){return o(n,t)}))},e}(),an=new un,fn=an.produce;an.produceWithPatches.bind(an);an.setAutoFreeze.bind(an);an.setUseProxies.bind(an);an.applyPatches.bind(an);var ln=an.createDraft.bind(an),dn=an.finishDraft.bind(an);\n\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nvar DIRTY_PATHS = new WeakMap();\nvar DIRTY_PATH_KEYS = new WeakMap();\nvar NORMALIZING = new WeakMap();\nvar PATH_REFS = new WeakMap();\nvar POINT_REFS = new WeakMap();\nvar RANGE_REFS = new WeakMap();\n\nfunction _objectWithoutPropertiesLoose$1(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}\n\nfunction _objectWithoutProperties$1(source, excluded) {\n  if (source == null) return {};\n  var target = _objectWithoutPropertiesLoose$1(source, excluded);\n  var key, i;\n\n  if (Object.getOwnPropertySymbols) {\n    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);\n\n    for (i = 0; i < sourceSymbolKeys.length; i++) {\n      key = sourceSymbolKeys[i];\n      if (excluded.indexOf(key) >= 0) continue;\n      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;\n      target[key] = source[key];\n    }\n  }\n\n  return target;\n}\n\n// Character (grapheme cluster) boundaries are determined according to\n// the default grapheme cluster boundary specification, extended grapheme clusters variant[1].\n//\n// References:\n//\n// [1] https://www.unicode.org/reports/tr29/#Default_Grapheme_Cluster_Table\n// [2] https://www.unicode.org/Public/UCD/latest/ucd/auxiliary/GraphemeBreakProperty.txt\n// [3] https://www.unicode.org/Public/UCD/latest/ucd/auxiliary/GraphemeBreakTest.html\n// [4] https://www.unicode.org/Public/UCD/latest/ucd/auxiliary/GraphemeBreakTest.txt\n\n/**\r\n * Get the distance to the end of the first character in a string of text.\r\n */\nvar getCharacterDistance = function getCharacterDistance(str) {\n  var isRTL = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n  var isLTR = !isRTL;\n  var codepoints = isRTL ? codepointsIteratorRTL(str) : str;\n  var left = CodepointType.None;\n  var right = CodepointType.None;\n  var distance = 0; // Evaluation of these conditions are deferred.\n\n  var gb11 = null; // Is GB11 applicable?\n\n  var gb12Or13 = null; // Is GB12 or GB13 applicable?\n\n  for (var char of codepoints) {\n    var code = char.codePointAt(0);\n    if (!code) break;\n    var type = getCodepointType(char, code);\n    [left, right] = isLTR ? [right, type] : [type, left];\n\n    if (intersects(left, CodepointType.ZWJ) && intersects(right, CodepointType.ExtPict)) {\n      if (isLTR) {\n        gb11 = endsWithEmojiZWJ(str.substring(0, distance));\n      } else {\n        gb11 = endsWithEmojiZWJ(str.substring(0, str.length - distance));\n      }\n\n      if (!gb11) break;\n    }\n\n    if (intersects(left, CodepointType.RI) && intersects(right, CodepointType.RI)) {\n      if (gb12Or13 !== null) {\n        gb12Or13 = !gb12Or13;\n      } else {\n        if (isLTR) {\n          gb12Or13 = true;\n        } else {\n          gb12Or13 = endsWithOddNumberOfRIs(str.substring(0, str.length - distance));\n        }\n      }\n\n      if (!gb12Or13) break;\n    }\n\n    if (left !== CodepointType.None && right !== CodepointType.None && isBoundaryPair(left, right)) {\n      break;\n    }\n\n    distance += char.length;\n  }\n\n  return distance || 1;\n};\nvar SPACE = /\\s/;\nvar PUNCTUATION = /[\\u0021-\\u0023\\u0025-\\u002A\\u002C-\\u002F\\u003A\\u003B\\u003F\\u0040\\u005B-\\u005D\\u005F\\u007B\\u007D\\u00A1\\u00A7\\u00AB\\u00B6\\u00B7\\u00BB\\u00BF\\u037E\\u0387\\u055A-\\u055F\\u0589\\u058A\\u05BE\\u05C0\\u05C3\\u05C6\\u05F3\\u05F4\\u0609\\u060A\\u060C\\u060D\\u061B\\u061E\\u061F\\u066A-\\u066D\\u06D4\\u0700-\\u070D\\u07F7-\\u07F9\\u0830-\\u083E\\u085E\\u0964\\u0965\\u0970\\u0AF0\\u0DF4\\u0E4F\\u0E5A\\u0E5B\\u0F04-\\u0F12\\u0F14\\u0F3A-\\u0F3D\\u0F85\\u0FD0-\\u0FD4\\u0FD9\\u0FDA\\u104A-\\u104F\\u10FB\\u1360-\\u1368\\u1400\\u166D\\u166E\\u169B\\u169C\\u16EB-\\u16ED\\u1735\\u1736\\u17D4-\\u17D6\\u17D8-\\u17DA\\u1800-\\u180A\\u1944\\u1945\\u1A1E\\u1A1F\\u1AA0-\\u1AA6\\u1AA8-\\u1AAD\\u1B5A-\\u1B60\\u1BFC-\\u1BFF\\u1C3B-\\u1C3F\\u1C7E\\u1C7F\\u1CC0-\\u1CC7\\u1CD3\\u2010-\\u2027\\u2030-\\u2043\\u2045-\\u2051\\u2053-\\u205E\\u207D\\u207E\\u208D\\u208E\\u2329\\u232A\\u2768-\\u2775\\u27C5\\u27C6\\u27E6-\\u27EF\\u2983-\\u2998\\u29D8-\\u29DB\\u29FC\\u29FD\\u2CF9-\\u2CFC\\u2CFE\\u2CFF\\u2D70\\u2E00-\\u2E2E\\u2E30-\\u2E3B\\u3001-\\u3003\\u3008-\\u3011\\u3014-\\u301F\\u3030\\u303D\\u30A0\\u30FB\\uA4FE\\uA4FF\\uA60D-\\uA60F\\uA673\\uA67E\\uA6F2-\\uA6F7\\uA874-\\uA877\\uA8CE\\uA8CF\\uA8F8-\\uA8FA\\uA92E\\uA92F\\uA95F\\uA9C1-\\uA9CD\\uA9DE\\uA9DF\\uAA5C-\\uAA5F\\uAADE\\uAADF\\uAAF0\\uAAF1\\uABEB\\uFD3E\\uFD3F\\uFE10-\\uFE19\\uFE30-\\uFE52\\uFE54-\\uFE61\\uFE63\\uFE68\\uFE6A\\uFE6B\\uFF01-\\uFF03\\uFF05-\\uFF0A\\uFF0C-\\uFF0F\\uFF1A\\uFF1B\\uFF1F\\uFF20\\uFF3B-\\uFF3D\\uFF3F\\uFF5B\\uFF5D\\uFF5F-\\uFF65]/;\nvar CHAMELEON = /['\\u2018\\u2019]/;\n/**\r\n * Get the distance to the end of the first word in a string of text.\r\n */\n\nvar getWordDistance = function getWordDistance(text) {\n  var isRTL = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n  var dist = 0;\n  var started = false;\n\n  while (text.length > 0) {\n    var charDist = getCharacterDistance(text, isRTL);\n    var [char, remaining] = splitByCharacterDistance(text, charDist, isRTL);\n\n    if (isWordCharacter(char, remaining, isRTL)) {\n      started = true;\n      dist += charDist;\n    } else if (!started) {\n      dist += charDist;\n    } else {\n      break;\n    }\n\n    text = remaining;\n  }\n\n  return dist;\n};\n/**\r\n * Split a string in two parts at a given distance starting from the end when\r\n * `isRTL` is set to `true`.\r\n */\n\nvar splitByCharacterDistance = (str, dist, isRTL) => {\n  if (isRTL) {\n    var at = str.length - dist;\n    return [str.slice(at, str.length), str.slice(0, at)];\n  }\n\n  return [str.slice(0, dist), str.slice(dist)];\n};\n/**\r\n * Check if a character is a word character. The `remaining` argument is used\r\n * because sometimes you must read subsequent characters to truly determine it.\r\n */\n\nvar isWordCharacter = function isWordCharacter(char, remaining) {\n  var isRTL = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n\n  if (SPACE.test(char)) {\n    return false;\n  } // Chameleons count as word characters as long as they're in a word, so\n  // recurse to see if the next one is a word character or not.\n\n\n  if (CHAMELEON.test(char)) {\n    var charDist = getCharacterDistance(remaining, isRTL);\n    var [nextChar, nextRemaining] = splitByCharacterDistance(remaining, charDist, isRTL);\n\n    if (isWordCharacter(nextChar, nextRemaining, isRTL)) {\n      return true;\n    }\n  }\n\n  if (PUNCTUATION.test(char)) {\n    return false;\n  }\n\n  return true;\n};\n/**\r\n * Iterate on codepoints from right to left.\r\n */\n\n\nvar codepointsIteratorRTL = function* codepointsIteratorRTL(str) {\n  var end = str.length - 1;\n\n  for (var i = 0; i < str.length; i++) {\n    var char1 = str.charAt(end - i);\n\n    if (isLowSurrogate(char1.charCodeAt(0))) {\n      var char2 = str.charAt(end - i - 1);\n\n      if (isHighSurrogate(char2.charCodeAt(0))) {\n        yield char2 + char1;\n        i++;\n        continue;\n      }\n    }\n\n    yield char1;\n  }\n};\n/**\r\n * Is `charCode` a high surrogate.\r\n *\r\n * https://en.wikipedia.org/wiki/Universal_Character_Set_characters#Surrogates\r\n */\n\nvar isHighSurrogate = charCode => {\n  return charCode >= 0xd800 && charCode <= 0xdbff;\n};\n/**\r\n * Is `charCode` a low surrogate.\r\n *\r\n * https://en.wikipedia.org/wiki/Universal_Character_Set_characters#Surrogates\r\n */\n\n\nvar isLowSurrogate = charCode => {\n  return charCode >= 0xdc00 && charCode <= 0xdfff;\n};\n\nvar CodepointType;\n\n(function (CodepointType) {\n  CodepointType[CodepointType[\"None\"] = 0] = \"None\";\n  CodepointType[CodepointType[\"Extend\"] = 1] = \"Extend\";\n  CodepointType[CodepointType[\"ZWJ\"] = 2] = \"ZWJ\";\n  CodepointType[CodepointType[\"RI\"] = 4] = \"RI\";\n  CodepointType[CodepointType[\"Prepend\"] = 8] = \"Prepend\";\n  CodepointType[CodepointType[\"SpacingMark\"] = 16] = \"SpacingMark\";\n  CodepointType[CodepointType[\"L\"] = 32] = \"L\";\n  CodepointType[CodepointType[\"V\"] = 64] = \"V\";\n  CodepointType[CodepointType[\"T\"] = 128] = \"T\";\n  CodepointType[CodepointType[\"LV\"] = 256] = \"LV\";\n  CodepointType[CodepointType[\"LVT\"] = 512] = \"LVT\";\n  CodepointType[CodepointType[\"ExtPict\"] = 1024] = \"ExtPict\";\n  CodepointType[CodepointType[\"Any\"] = 2048] = \"Any\";\n})(CodepointType || (CodepointType = {}));\n\nvar reExtend = /^(?:[\\u0300-\\u036F\\u0483-\\u0489\\u0591-\\u05BD\\u05BF\\u05C1\\u05C2\\u05C4\\u05C5\\u05C7\\u0610-\\u061A\\u064B-\\u065F\\u0670\\u06D6-\\u06DC\\u06DF-\\u06E4\\u06E7\\u06E8\\u06EA-\\u06ED\\u0711\\u0730-\\u074A\\u07A6-\\u07B0\\u07EB-\\u07F3\\u07FD\\u0816-\\u0819\\u081B-\\u0823\\u0825-\\u0827\\u0829-\\u082D\\u0859-\\u085B\\u08D3-\\u08E1\\u08E3-\\u0902\\u093A\\u093C\\u0941-\\u0948\\u094D\\u0951-\\u0957\\u0962\\u0963\\u0981\\u09BC\\u09BE\\u09C1-\\u09C4\\u09CD\\u09D7\\u09E2\\u09E3\\u09FE\\u0A01\\u0A02\\u0A3C\\u0A41\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A51\\u0A70\\u0A71\\u0A75\\u0A81\\u0A82\\u0ABC\\u0AC1-\\u0AC5\\u0AC7\\u0AC8\\u0ACD\\u0AE2\\u0AE3\\u0AFA-\\u0AFF\\u0B01\\u0B3C\\u0B3E\\u0B3F\\u0B41-\\u0B44\\u0B4D\\u0B55-\\u0B57\\u0B62\\u0B63\\u0B82\\u0BBE\\u0BC0\\u0BCD\\u0BD7\\u0C00\\u0C04\\u0C3E-\\u0C40\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C62\\u0C63\\u0C81\\u0CBC\\u0CBF\\u0CC2\\u0CC6\\u0CCC\\u0CCD\\u0CD5\\u0CD6\\u0CE2\\u0CE3\\u0D00\\u0D01\\u0D3B\\u0D3C\\u0D3E\\u0D41-\\u0D44\\u0D4D\\u0D57\\u0D62\\u0D63\\u0D81\\u0DCA\\u0DCF\\u0DD2-\\u0DD4\\u0DD6\\u0DDF\\u0E31\\u0E34-\\u0E3A\\u0E47-\\u0E4E\\u0EB1\\u0EB4-\\u0EBC\\u0EC8-\\u0ECD\\u0F18\\u0F19\\u0F35\\u0F37\\u0F39\\u0F71-\\u0F7E\\u0F80-\\u0F84\\u0F86\\u0F87\\u0F8D-\\u0F97\\u0F99-\\u0FBC\\u0FC6\\u102D-\\u1030\\u1032-\\u1037\\u1039\\u103A\\u103D\\u103E\\u1058\\u1059\\u105E-\\u1060\\u1071-\\u1074\\u1082\\u1085\\u1086\\u108D\\u109D\\u135D-\\u135F\\u1712-\\u1714\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17B4\\u17B5\\u17B7-\\u17BD\\u17C6\\u17C9-\\u17D3\\u17DD\\u180B-\\u180D\\u1885\\u1886\\u18A9\\u1920-\\u1922\\u1927\\u1928\\u1932\\u1939-\\u193B\\u1A17\\u1A18\\u1A1B\\u1A56\\u1A58-\\u1A5E\\u1A60\\u1A62\\u1A65-\\u1A6C\\u1A73-\\u1A7C\\u1A7F\\u1AB0-\\u1AC0\\u1B00-\\u1B03\\u1B34-\\u1B3A\\u1B3C\\u1B42\\u1B6B-\\u1B73\\u1B80\\u1B81\\u1BA2-\\u1BA5\\u1BA8\\u1BA9\\u1BAB-\\u1BAD\\u1BE6\\u1BE8\\u1BE9\\u1BED\\u1BEF-\\u1BF1\\u1C2C-\\u1C33\\u1C36\\u1C37\\u1CD0-\\u1CD2\\u1CD4-\\u1CE0\\u1CE2-\\u1CE8\\u1CED\\u1CF4\\u1CF8\\u1CF9\\u1DC0-\\u1DF9\\u1DFB-\\u1DFF\\u200C\\u20D0-\\u20F0\\u2CEF-\\u2CF1\\u2D7F\\u2DE0-\\u2DFF\\u302A-\\u302F\\u3099\\u309A\\uA66F-\\uA672\\uA674-\\uA67D\\uA69E\\uA69F\\uA6F0\\uA6F1\\uA802\\uA806\\uA80B\\uA825\\uA826\\uA82C\\uA8C4\\uA8C5\\uA8E0-\\uA8F1\\uA8FF\\uA926-\\uA92D\\uA947-\\uA951\\uA980-\\uA982\\uA9B3\\uA9B6-\\uA9B9\\uA9BC\\uA9BD\\uA9E5\\uAA29-\\uAA2E\\uAA31\\uAA32\\uAA35\\uAA36\\uAA43\\uAA4C\\uAA7C\\uAAB0\\uAAB2-\\uAAB4\\uAAB7\\uAAB8\\uAABE\\uAABF\\uAAC1\\uAAEC\\uAAED\\uAAF6\\uABE5\\uABE8\\uABED\\uFB1E\\uFE00-\\uFE0F\\uFE20-\\uFE2F\\uFF9E\\uFF9F]|\\uD800[\\uDDFD\\uDEE0\\uDF76-\\uDF7A]|\\uD802[\\uDE01-\\uDE03\\uDE05\\uDE06\\uDE0C-\\uDE0F\\uDE38-\\uDE3A\\uDE3F\\uDEE5\\uDEE6]|\\uD803[\\uDD24-\\uDD27\\uDEAB\\uDEAC\\uDF46-\\uDF50]|\\uD804[\\uDC01\\uDC38-\\uDC46\\uDC7F-\\uDC81\\uDCB3-\\uDCB6\\uDCB9\\uDCBA\\uDD00-\\uDD02\\uDD27-\\uDD2B\\uDD2D-\\uDD34\\uDD73\\uDD80\\uDD81\\uDDB6-\\uDDBE\\uDDC9-\\uDDCC\\uDDCF\\uDE2F-\\uDE31\\uDE34\\uDE36\\uDE37\\uDE3E\\uDEDF\\uDEE3-\\uDEEA\\uDF00\\uDF01\\uDF3B\\uDF3C\\uDF3E\\uDF40\\uDF57\\uDF66-\\uDF6C\\uDF70-\\uDF74]|\\uD805[\\uDC38-\\uDC3F\\uDC42-\\uDC44\\uDC46\\uDC5E\\uDCB0\\uDCB3-\\uDCB8\\uDCBA\\uDCBD\\uDCBF\\uDCC0\\uDCC2\\uDCC3\\uDDAF\\uDDB2-\\uDDB5\\uDDBC\\uDDBD\\uDDBF\\uDDC0\\uDDDC\\uDDDD\\uDE33-\\uDE3A\\uDE3D\\uDE3F\\uDE40\\uDEAB\\uDEAD\\uDEB0-\\uDEB5\\uDEB7\\uDF1D-\\uDF1F\\uDF22-\\uDF25\\uDF27-\\uDF2B]|\\uD806[\\uDC2F-\\uDC37\\uDC39\\uDC3A\\uDD30\\uDD3B\\uDD3C\\uDD3E\\uDD43\\uDDD4-\\uDDD7\\uDDDA\\uDDDB\\uDDE0\\uDE01-\\uDE0A\\uDE33-\\uDE38\\uDE3B-\\uDE3E\\uDE47\\uDE51-\\uDE56\\uDE59-\\uDE5B\\uDE8A-\\uDE96\\uDE98\\uDE99]|\\uD807[\\uDC30-\\uDC36\\uDC38-\\uDC3D\\uDC3F\\uDC92-\\uDCA7\\uDCAA-\\uDCB0\\uDCB2\\uDCB3\\uDCB5\\uDCB6\\uDD31-\\uDD36\\uDD3A\\uDD3C\\uDD3D\\uDD3F-\\uDD45\\uDD47\\uDD90\\uDD91\\uDD95\\uDD97\\uDEF3\\uDEF4]|\\uD81A[\\uDEF0-\\uDEF4\\uDF30-\\uDF36]|\\uD81B[\\uDF4F\\uDF8F-\\uDF92\\uDFE4]|\\uD82F[\\uDC9D\\uDC9E]|\\uD834[\\uDD65\\uDD67-\\uDD69\\uDD6E-\\uDD72\\uDD7B-\\uDD82\\uDD85-\\uDD8B\\uDDAA-\\uDDAD\\uDE42-\\uDE44]|\\uD836[\\uDE00-\\uDE36\\uDE3B-\\uDE6C\\uDE75\\uDE84\\uDE9B-\\uDE9F\\uDEA1-\\uDEAF]|\\uD838[\\uDC00-\\uDC06\\uDC08-\\uDC18\\uDC1B-\\uDC21\\uDC23\\uDC24\\uDC26-\\uDC2A\\uDD30-\\uDD36\\uDEEC-\\uDEEF]|\\uD83A[\\uDCD0-\\uDCD6\\uDD44-\\uDD4A]|\\uD83C[\\uDFFB-\\uDFFF]|\\uDB40[\\uDC20-\\uDC7F\\uDD00-\\uDDEF])$/;\nvar rePrepend = /^(?:[\\u0600-\\u0605\\u06DD\\u070F\\u0890\\u0891\\u08E2\\u0D4E]|\\uD804[\\uDCBD\\uDCCD\\uDDC2\\uDDC3]|\\uD806[\\uDD3F\\uDD41\\uDE3A\\uDE84-\\uDE89]|\\uD807\\uDD46)$/;\nvar reSpacingMark = /^(?:[\\u0903\\u093B\\u093E-\\u0940\\u0949-\\u094C\\u094E\\u094F\\u0982\\u0983\\u09BF\\u09C0\\u09C7\\u09C8\\u09CB\\u09CC\\u0A03\\u0A3E-\\u0A40\\u0A83\\u0ABE-\\u0AC0\\u0AC9\\u0ACB\\u0ACC\\u0B02\\u0B03\\u0B40\\u0B47\\u0B48\\u0B4B\\u0B4C\\u0BBF\\u0BC1\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCC\\u0C01-\\u0C03\\u0C41-\\u0C44\\u0C82\\u0C83\\u0CBE\\u0CC0\\u0CC1\\u0CC3\\u0CC4\\u0CC7\\u0CC8\\u0CCA\\u0CCB\\u0D02\\u0D03\\u0D3F\\u0D40\\u0D46-\\u0D48\\u0D4A-\\u0D4C\\u0D82\\u0D83\\u0DD0\\u0DD1\\u0DD8-\\u0DDE\\u0DF2\\u0DF3\\u0E33\\u0EB3\\u0F3E\\u0F3F\\u0F7F\\u1031\\u103B\\u103C\\u1056\\u1057\\u1084\\u1715\\u1734\\u17B6\\u17BE-\\u17C5\\u17C7\\u17C8\\u1923-\\u1926\\u1929-\\u192B\\u1930\\u1931\\u1933-\\u1938\\u1A19\\u1A1A\\u1A55\\u1A57\\u1A6D-\\u1A72\\u1B04\\u1B3B\\u1B3D-\\u1B41\\u1B43\\u1B44\\u1B82\\u1BA1\\u1BA6\\u1BA7\\u1BAA\\u1BE7\\u1BEA-\\u1BEC\\u1BEE\\u1BF2\\u1BF3\\u1C24-\\u1C2B\\u1C34\\u1C35\\u1CE1\\u1CF7\\uA823\\uA824\\uA827\\uA880\\uA881\\uA8B4-\\uA8C3\\uA952\\uA953\\uA983\\uA9B4\\uA9B5\\uA9BA\\uA9BB\\uA9BE-\\uA9C0\\uAA2F\\uAA30\\uAA33\\uAA34\\uAA4D\\uAAEB\\uAAEE\\uAAEF\\uAAF5\\uABE3\\uABE4\\uABE6\\uABE7\\uABE9\\uABEA\\uABEC]|\\uD804[\\uDC00\\uDC02\\uDC82\\uDCB0-\\uDCB2\\uDCB7\\uDCB8\\uDD2C\\uDD45\\uDD46\\uDD82\\uDDB3-\\uDDB5\\uDDBF\\uDDC0\\uDDCE\\uDE2C-\\uDE2E\\uDE32\\uDE33\\uDE35\\uDEE0-\\uDEE2\\uDF02\\uDF03\\uDF3F\\uDF41-\\uDF44\\uDF47\\uDF48\\uDF4B-\\uDF4D\\uDF62\\uDF63]|\\uD805[\\uDC35-\\uDC37\\uDC40\\uDC41\\uDC45\\uDCB1\\uDCB2\\uDCB9\\uDCBB\\uDCBC\\uDCBE\\uDCC1\\uDDB0\\uDDB1\\uDDB8-\\uDDBB\\uDDBE\\uDE30-\\uDE32\\uDE3B\\uDE3C\\uDE3E\\uDEAC\\uDEAE\\uDEAF\\uDEB6\\uDF26]|\\uD806[\\uDC2C-\\uDC2E\\uDC38\\uDD31-\\uDD35\\uDD37\\uDD38\\uDD3D\\uDD40\\uDD42\\uDDD1-\\uDDD3\\uDDDC-\\uDDDF\\uDDE4\\uDE39\\uDE57\\uDE58\\uDE97]|\\uD807[\\uDC2F\\uDC3E\\uDCA9\\uDCB1\\uDCB4\\uDD8A-\\uDD8E\\uDD93\\uDD94\\uDD96\\uDEF5\\uDEF6]|\\uD81B[\\uDF51-\\uDF87\\uDFF0\\uDFF1]|\\uD834[\\uDD66\\uDD6D])$/;\nvar reL = /^[\\u1100-\\u115F\\uA960-\\uA97C]$/;\nvar reV = /^[\\u1160-\\u11A7\\uD7B0-\\uD7C6]$/;\nvar reT = /^[\\u11A8-\\u11FF\\uD7CB-\\uD7FB]$/;\nvar reLV = /^[\\uAC00\\uAC1C\\uAC38\\uAC54\\uAC70\\uAC8C\\uACA8\\uACC4\\uACE0\\uACFC\\uAD18\\uAD34\\uAD50\\uAD6C\\uAD88\\uADA4\\uADC0\\uADDC\\uADF8\\uAE14\\uAE30\\uAE4C\\uAE68\\uAE84\\uAEA0\\uAEBC\\uAED8\\uAEF4\\uAF10\\uAF2C\\uAF48\\uAF64\\uAF80\\uAF9C\\uAFB8\\uAFD4\\uAFF0\\uB00C\\uB028\\uB044\\uB060\\uB07C\\uB098\\uB0B4\\uB0D0\\uB0EC\\uB108\\uB124\\uB140\\uB15C\\uB178\\uB194\\uB1B0\\uB1CC\\uB1E8\\uB204\\uB220\\uB23C\\uB258\\uB274\\uB290\\uB2AC\\uB2C8\\uB2E4\\uB300\\uB31C\\uB338\\uB354\\uB370\\uB38C\\uB3A8\\uB3C4\\uB3E0\\uB3FC\\uB418\\uB434\\uB450\\uB46C\\uB488\\uB4A4\\uB4C0\\uB4DC\\uB4F8\\uB514\\uB530\\uB54C\\uB568\\uB584\\uB5A0\\uB5BC\\uB5D8\\uB5F4\\uB610\\uB62C\\uB648\\uB664\\uB680\\uB69C\\uB6B8\\uB6D4\\uB6F0\\uB70C\\uB728\\uB744\\uB760\\uB77C\\uB798\\uB7B4\\uB7D0\\uB7EC\\uB808\\uB824\\uB840\\uB85C\\uB878\\uB894\\uB8B0\\uB8CC\\uB8E8\\uB904\\uB920\\uB93C\\uB958\\uB974\\uB990\\uB9AC\\uB9C8\\uB9E4\\uBA00\\uBA1C\\uBA38\\uBA54\\uBA70\\uBA8C\\uBAA8\\uBAC4\\uBAE0\\uBAFC\\uBB18\\uBB34\\uBB50\\uBB6C\\uBB88\\uBBA4\\uBBC0\\uBBDC\\uBBF8\\uBC14\\uBC30\\uBC4C\\uBC68\\uBC84\\uBCA0\\uBCBC\\uBCD8\\uBCF4\\uBD10\\uBD2C\\uBD48\\uBD64\\uBD80\\uBD9C\\uBDB8\\uBDD4\\uBDF0\\uBE0C\\uBE28\\uBE44\\uBE60\\uBE7C\\uBE98\\uBEB4\\uBED0\\uBEEC\\uBF08\\uBF24\\uBF40\\uBF5C\\uBF78\\uBF94\\uBFB0\\uBFCC\\uBFE8\\uC004\\uC020\\uC03C\\uC058\\uC074\\uC090\\uC0AC\\uC0C8\\uC0E4\\uC100\\uC11C\\uC138\\uC154\\uC170\\uC18C\\uC1A8\\uC1C4\\uC1E0\\uC1FC\\uC218\\uC234\\uC250\\uC26C\\uC288\\uC2A4\\uC2C0\\uC2DC\\uC2F8\\uC314\\uC330\\uC34C\\uC368\\uC384\\uC3A0\\uC3BC\\uC3D8\\uC3F4\\uC410\\uC42C\\uC448\\uC464\\uC480\\uC49C\\uC4B8\\uC4D4\\uC4F0\\uC50C\\uC528\\uC544\\uC560\\uC57C\\uC598\\uC5B4\\uC5D0\\uC5EC\\uC608\\uC624\\uC640\\uC65C\\uC678\\uC694\\uC6B0\\uC6CC\\uC6E8\\uC704\\uC720\\uC73C\\uC758\\uC774\\uC790\\uC7AC\\uC7C8\\uC7E4\\uC800\\uC81C\\uC838\\uC854\\uC870\\uC88C\\uC8A8\\uC8C4\\uC8E0\\uC8FC\\uC918\\uC934\\uC950\\uC96C\\uC988\\uC9A4\\uC9C0\\uC9DC\\uC9F8\\uCA14\\uCA30\\uCA4C\\uCA68\\uCA84\\uCAA0\\uCABC\\uCAD8\\uCAF4\\uCB10\\uCB2C\\uCB48\\uCB64\\uCB80\\uCB9C\\uCBB8\\uCBD4\\uCBF0\\uCC0C\\uCC28\\uCC44\\uCC60\\uCC7C\\uCC98\\uCCB4\\uCCD0\\uCCEC\\uCD08\\uCD24\\uCD40\\uCD5C\\uCD78\\uCD94\\uCDB0\\uCDCC\\uCDE8\\uCE04\\uCE20\\uCE3C\\uCE58\\uCE74\\uCE90\\uCEAC\\uCEC8\\uCEE4\\uCF00\\uCF1C\\uCF38\\uCF54\\uCF70\\uCF8C\\uCFA8\\uCFC4\\uCFE0\\uCFFC\\uD018\\uD034\\uD050\\uD06C\\uD088\\uD0A4\\uD0C0\\uD0DC\\uD0F8\\uD114\\uD130\\uD14C\\uD168\\uD184\\uD1A0\\uD1BC\\uD1D8\\uD1F4\\uD210\\uD22C\\uD248\\uD264\\uD280\\uD29C\\uD2B8\\uD2D4\\uD2F0\\uD30C\\uD328\\uD344\\uD360\\uD37C\\uD398\\uD3B4\\uD3D0\\uD3EC\\uD408\\uD424\\uD440\\uD45C\\uD478\\uD494\\uD4B0\\uD4CC\\uD4E8\\uD504\\uD520\\uD53C\\uD558\\uD574\\uD590\\uD5AC\\uD5C8\\uD5E4\\uD600\\uD61C\\uD638\\uD654\\uD670\\uD68C\\uD6A8\\uD6C4\\uD6E0\\uD6FC\\uD718\\uD734\\uD750\\uD76C\\uD788]$/;\nvar reLVT = /^[\\uAC01-\\uAC1B\\uAC1D-\\uAC37\\uAC39-\\uAC53\\uAC55-\\uAC6F\\uAC71-\\uAC8B\\uAC8D-\\uACA7\\uACA9-\\uACC3\\uACC5-\\uACDF\\uACE1-\\uACFB\\uACFD-\\uAD17\\uAD19-\\uAD33\\uAD35-\\uAD4F\\uAD51-\\uAD6B\\uAD6D-\\uAD87\\uAD89-\\uADA3\\uADA5-\\uADBF\\uADC1-\\uADDB\\uADDD-\\uADF7\\uADF9-\\uAE13\\uAE15-\\uAE2F\\uAE31-\\uAE4B\\uAE4D-\\uAE67\\uAE69-\\uAE83\\uAE85-\\uAE9F\\uAEA1-\\uAEBB\\uAEBD-\\uAED7\\uAED9-\\uAEF3\\uAEF5-\\uAF0F\\uAF11-\\uAF2B\\uAF2D-\\uAF47\\uAF49-\\uAF63\\uAF65-\\uAF7F\\uAF81-\\uAF9B\\uAF9D-\\uAFB7\\uAFB9-\\uAFD3\\uAFD5-\\uAFEF\\uAFF1-\\uB00B\\uB00D-\\uB027\\uB029-\\uB043\\uB045-\\uB05F\\uB061-\\uB07B\\uB07D-\\uB097\\uB099-\\uB0B3\\uB0B5-\\uB0CF\\uB0D1-\\uB0EB\\uB0ED-\\uB107\\uB109-\\uB123\\uB125-\\uB13F\\uB141-\\uB15B\\uB15D-\\uB177\\uB179-\\uB193\\uB195-\\uB1AF\\uB1B1-\\uB1CB\\uB1CD-\\uB1E7\\uB1E9-\\uB203\\uB205-\\uB21F\\uB221-\\uB23B\\uB23D-\\uB257\\uB259-\\uB273\\uB275-\\uB28F\\uB291-\\uB2AB\\uB2AD-\\uB2C7\\uB2C9-\\uB2E3\\uB2E5-\\uB2FF\\uB301-\\uB31B\\uB31D-\\uB337\\uB339-\\uB353\\uB355-\\uB36F\\uB371-\\uB38B\\uB38D-\\uB3A7\\uB3A9-\\uB3C3\\uB3C5-\\uB3DF\\uB3E1-\\uB3FB\\uB3FD-\\uB417\\uB419-\\uB433\\uB435-\\uB44F\\uB451-\\uB46B\\uB46D-\\uB487\\uB489-\\uB4A3\\uB4A5-\\uB4BF\\uB4C1-\\uB4DB\\uB4DD-\\uB4F7\\uB4F9-\\uB513\\uB515-\\uB52F\\uB531-\\uB54B\\uB54D-\\uB567\\uB569-\\uB583\\uB585-\\uB59F\\uB5A1-\\uB5BB\\uB5BD-\\uB5D7\\uB5D9-\\uB5F3\\uB5F5-\\uB60F\\uB611-\\uB62B\\uB62D-\\uB647\\uB649-\\uB663\\uB665-\\uB67F\\uB681-\\uB69B\\uB69D-\\uB6B7\\uB6B9-\\uB6D3\\uB6D5-\\uB6EF\\uB6F1-\\uB70B\\uB70D-\\uB727\\uB729-\\uB743\\uB745-\\uB75F\\uB761-\\uB77B\\uB77D-\\uB797\\uB799-\\uB7B3\\uB7B5-\\uB7CF\\uB7D1-\\uB7EB\\uB7ED-\\uB807\\uB809-\\uB823\\uB825-\\uB83F\\uB841-\\uB85B\\uB85D-\\uB877\\uB879-\\uB893\\uB895-\\uB8AF\\uB8B1-\\uB8CB\\uB8CD-\\uB8E7\\uB8E9-\\uB903\\uB905-\\uB91F\\uB921-\\uB93B\\uB93D-\\uB957\\uB959-\\uB973\\uB975-\\uB98F\\uB991-\\uB9AB\\uB9AD-\\uB9C7\\uB9C9-\\uB9E3\\uB9E5-\\uB9FF\\uBA01-\\uBA1B\\uBA1D-\\uBA37\\uBA39-\\uBA53\\uBA55-\\uBA6F\\uBA71-\\uBA8B\\uBA8D-\\uBAA7\\uBAA9-\\uBAC3\\uBAC5-\\uBADF\\uBAE1-\\uBAFB\\uBAFD-\\uBB17\\uBB19-\\uBB33\\uBB35-\\uBB4F\\uBB51-\\uBB6B\\uBB6D-\\uBB87\\uBB89-\\uBBA3\\uBBA5-\\uBBBF\\uBBC1-\\uBBDB\\uBBDD-\\uBBF7\\uBBF9-\\uBC13\\uBC15-\\uBC2F\\uBC31-\\uBC4B\\uBC4D-\\uBC67\\uBC69-\\uBC83\\uBC85-\\uBC9F\\uBCA1-\\uBCBB\\uBCBD-\\uBCD7\\uBCD9-\\uBCF3\\uBCF5-\\uBD0F\\uBD11-\\uBD2B\\uBD2D-\\uBD47\\uBD49-\\uBD63\\uBD65-\\uBD7F\\uBD81-\\uBD9B\\uBD9D-\\uBDB7\\uBDB9-\\uBDD3\\uBDD5-\\uBDEF\\uBDF1-\\uBE0B\\uBE0D-\\uBE27\\uBE29-\\uBE43\\uBE45-\\uBE5F\\uBE61-\\uBE7B\\uBE7D-\\uBE97\\uBE99-\\uBEB3\\uBEB5-\\uBECF\\uBED1-\\uBEEB\\uBEED-\\uBF07\\uBF09-\\uBF23\\uBF25-\\uBF3F\\uBF41-\\uBF5B\\uBF5D-\\uBF77\\uBF79-\\uBF93\\uBF95-\\uBFAF\\uBFB1-\\uBFCB\\uBFCD-\\uBFE7\\uBFE9-\\uC003\\uC005-\\uC01F\\uC021-\\uC03B\\uC03D-\\uC057\\uC059-\\uC073\\uC075-\\uC08F\\uC091-\\uC0AB\\uC0AD-\\uC0C7\\uC0C9-\\uC0E3\\uC0E5-\\uC0FF\\uC101-\\uC11B\\uC11D-\\uC137\\uC139-\\uC153\\uC155-\\uC16F\\uC171-\\uC18B\\uC18D-\\uC1A7\\uC1A9-\\uC1C3\\uC1C5-\\uC1DF\\uC1E1-\\uC1FB\\uC1FD-\\uC217\\uC219-\\uC233\\uC235-\\uC24F\\uC251-\\uC26B\\uC26D-\\uC287\\uC289-\\uC2A3\\uC2A5-\\uC2BF\\uC2C1-\\uC2DB\\uC2DD-\\uC2F7\\uC2F9-\\uC313\\uC315-\\uC32F\\uC331-\\uC34B\\uC34D-\\uC367\\uC369-\\uC383\\uC385-\\uC39F\\uC3A1-\\uC3BB\\uC3BD-\\uC3D7\\uC3D9-\\uC3F3\\uC3F5-\\uC40F\\uC411-\\uC42B\\uC42D-\\uC447\\uC449-\\uC463\\uC465-\\uC47F\\uC481-\\uC49B\\uC49D-\\uC4B7\\uC4B9-\\uC4D3\\uC4D5-\\uC4EF\\uC4F1-\\uC50B\\uC50D-\\uC527\\uC529-\\uC543\\uC545-\\uC55F\\uC561-\\uC57B\\uC57D-\\uC597\\uC599-\\uC5B3\\uC5B5-\\uC5CF\\uC5D1-\\uC5EB\\uC5ED-\\uC607\\uC609-\\uC623\\uC625-\\uC63F\\uC641-\\uC65B\\uC65D-\\uC677\\uC679-\\uC693\\uC695-\\uC6AF\\uC6B1-\\uC6CB\\uC6CD-\\uC6E7\\uC6E9-\\uC703\\uC705-\\uC71F\\uC721-\\uC73B\\uC73D-\\uC757\\uC759-\\uC773\\uC775-\\uC78F\\uC791-\\uC7AB\\uC7AD-\\uC7C7\\uC7C9-\\uC7E3\\uC7E5-\\uC7FF\\uC801-\\uC81B\\uC81D-\\uC837\\uC839-\\uC853\\uC855-\\uC86F\\uC871-\\uC88B\\uC88D-\\uC8A7\\uC8A9-\\uC8C3\\uC8C5-\\uC8DF\\uC8E1-\\uC8FB\\uC8FD-\\uC917\\uC919-\\uC933\\uC935-\\uC94F\\uC951-\\uC96B\\uC96D-\\uC987\\uC989-\\uC9A3\\uC9A5-\\uC9BF\\uC9C1-\\uC9DB\\uC9DD-\\uC9F7\\uC9F9-\\uCA13\\uCA15-\\uCA2F\\uCA31-\\uCA4B\\uCA4D-\\uCA67\\uCA69-\\uCA83\\uCA85-\\uCA9F\\uCAA1-\\uCABB\\uCABD-\\uCAD7\\uCAD9-\\uCAF3\\uCAF5-\\uCB0F\\uCB11-\\uCB2B\\uCB2D-\\uCB47\\uCB49-\\uCB63\\uCB65-\\uCB7F\\uCB81-\\uCB9B\\uCB9D-\\uCBB7\\uCBB9-\\uCBD3\\uCBD5-\\uCBEF\\uCBF1-\\uCC0B\\uCC0D-\\uCC27\\uCC29-\\uCC43\\uCC45-\\uCC5F\\uCC61-\\uCC7B\\uCC7D-\\uCC97\\uCC99-\\uCCB3\\uCCB5-\\uCCCF\\uCCD1-\\uCCEB\\uCCED-\\uCD07\\uCD09-\\uCD23\\uCD25-\\uCD3F\\uCD41-\\uCD5B\\uCD5D-\\uCD77\\uCD79-\\uCD93\\uCD95-\\uCDAF\\uCDB1-\\uCDCB\\uCDCD-\\uCDE7\\uCDE9-\\uCE03\\uCE05-\\uCE1F\\uCE21-\\uCE3B\\uCE3D-\\uCE57\\uCE59-\\uCE73\\uCE75-\\uCE8F\\uCE91-\\uCEAB\\uCEAD-\\uCEC7\\uCEC9-\\uCEE3\\uCEE5-\\uCEFF\\uCF01-\\uCF1B\\uCF1D-\\uCF37\\uCF39-\\uCF53\\uCF55-\\uCF6F\\uCF71-\\uCF8B\\uCF8D-\\uCFA7\\uCFA9-\\uCFC3\\uCFC5-\\uCFDF\\uCFE1-\\uCFFB\\uCFFD-\\uD017\\uD019-\\uD033\\uD035-\\uD04F\\uD051-\\uD06B\\uD06D-\\uD087\\uD089-\\uD0A3\\uD0A5-\\uD0BF\\uD0C1-\\uD0DB\\uD0DD-\\uD0F7\\uD0F9-\\uD113\\uD115-\\uD12F\\uD131-\\uD14B\\uD14D-\\uD167\\uD169-\\uD183\\uD185-\\uD19F\\uD1A1-\\uD1BB\\uD1BD-\\uD1D7\\uD1D9-\\uD1F3\\uD1F5-\\uD20F\\uD211-\\uD22B\\uD22D-\\uD247\\uD249-\\uD263\\uD265-\\uD27F\\uD281-\\uD29B\\uD29D-\\uD2B7\\uD2B9-\\uD2D3\\uD2D5-\\uD2EF\\uD2F1-\\uD30B\\uD30D-\\uD327\\uD329-\\uD343\\uD345-\\uD35F\\uD361-\\uD37B\\uD37D-\\uD397\\uD399-\\uD3B3\\uD3B5-\\uD3CF\\uD3D1-\\uD3EB\\uD3ED-\\uD407\\uD409-\\uD423\\uD425-\\uD43F\\uD441-\\uD45B\\uD45D-\\uD477\\uD479-\\uD493\\uD495-\\uD4AF\\uD4B1-\\uD4CB\\uD4CD-\\uD4E7\\uD4E9-\\uD503\\uD505-\\uD51F\\uD521-\\uD53B\\uD53D-\\uD557\\uD559-\\uD573\\uD575-\\uD58F\\uD591-\\uD5AB\\uD5AD-\\uD5C7\\uD5C9-\\uD5E3\\uD5E5-\\uD5FF\\uD601-\\uD61B\\uD61D-\\uD637\\uD639-\\uD653\\uD655-\\uD66F\\uD671-\\uD68B\\uD68D-\\uD6A7\\uD6A9-\\uD6C3\\uD6C5-\\uD6DF\\uD6E1-\\uD6FB\\uD6FD-\\uD717\\uD719-\\uD733\\uD735-\\uD74F\\uD751-\\uD76B\\uD76D-\\uD787\\uD789-\\uD7A3]$/;\nvar reExtPict = /^(?:[\\xA9\\xAE\\u203C\\u2049\\u2122\\u2139\\u2194-\\u2199\\u21A9\\u21AA\\u231A\\u231B\\u2328\\u2388\\u23CF\\u23E9-\\u23F3\\u23F8-\\u23FA\\u24C2\\u25AA\\u25AB\\u25B6\\u25C0\\u25FB-\\u25FE\\u2600-\\u2605\\u2607-\\u2612\\u2614-\\u2685\\u2690-\\u2705\\u2708-\\u2712\\u2714\\u2716\\u271D\\u2721\\u2728\\u2733\\u2734\\u2744\\u2747\\u274C\\u274E\\u2753-\\u2755\\u2757\\u2763-\\u2767\\u2795-\\u2797\\u27A1\\u27B0\\u27BF\\u2934\\u2935\\u2B05-\\u2B07\\u2B1B\\u2B1C\\u2B50\\u2B55\\u3030\\u303D\\u3297\\u3299]|\\uD83C[\\uDC00-\\uDCFF\\uDD0D-\\uDD0F\\uDD2F\\uDD6C-\\uDD71\\uDD7E\\uDD7F\\uDD8E\\uDD91-\\uDD9A\\uDDAD-\\uDDE5\\uDE01-\\uDE0F\\uDE1A\\uDE2F\\uDE32-\\uDE3A\\uDE3C-\\uDE3F\\uDE49-\\uDFFA]|\\uD83D[\\uDC00-\\uDD3D\\uDD46-\\uDE4F\\uDE80-\\uDEFF\\uDF74-\\uDF7F\\uDFD5-\\uDFFF]|\\uD83E[\\uDC0C-\\uDC0F\\uDC48-\\uDC4F\\uDC5A-\\uDC5F\\uDC88-\\uDC8F\\uDCAE-\\uDCFF\\uDD0C-\\uDD3A\\uDD3C-\\uDD45\\uDD47-\\uDEFF]|\\uD83F[\\uDC00-\\uDFFD])$/;\n\nvar getCodepointType = (char, code) => {\n  var type = CodepointType.Any;\n\n  if (char.search(reExtend) !== -1) {\n    type |= CodepointType.Extend;\n  }\n\n  if (code === 0x200d) {\n    type |= CodepointType.ZWJ;\n  }\n\n  if (code >= 0x1f1e6 && code <= 0x1f1ff) {\n    type |= CodepointType.RI;\n  }\n\n  if (char.search(rePrepend) !== -1) {\n    type |= CodepointType.Prepend;\n  }\n\n  if (char.search(reSpacingMark) !== -1) {\n    type |= CodepointType.SpacingMark;\n  }\n\n  if (char.search(reL) !== -1) {\n    type |= CodepointType.L;\n  }\n\n  if (char.search(reV) !== -1) {\n    type |= CodepointType.V;\n  }\n\n  if (char.search(reT) !== -1) {\n    type |= CodepointType.T;\n  }\n\n  if (char.search(reLV) !== -1) {\n    type |= CodepointType.LV;\n  }\n\n  if (char.search(reLVT) !== -1) {\n    type |= CodepointType.LVT;\n  }\n\n  if (char.search(reExtPict) !== -1) {\n    type |= CodepointType.ExtPict;\n  }\n\n  return type;\n};\n\nfunction intersects(x, y) {\n  return (x & y) !== 0;\n}\n\nvar NonBoundaryPairs = [// GB6\n[CodepointType.L, CodepointType.L | CodepointType.V | CodepointType.LV | CodepointType.LVT], // GB7\n[CodepointType.LV | CodepointType.V, CodepointType.V | CodepointType.T], // GB8\n[CodepointType.LVT | CodepointType.T, CodepointType.T], // GB9\n[CodepointType.Any, CodepointType.Extend | CodepointType.ZWJ], // GB9a\n[CodepointType.Any, CodepointType.SpacingMark], // GB9b\n[CodepointType.Prepend, CodepointType.Any], // GB11\n[CodepointType.ZWJ, CodepointType.ExtPict], // GB12 and GB13\n[CodepointType.RI, CodepointType.RI]];\n\nfunction isBoundaryPair(left, right) {\n  return NonBoundaryPairs.findIndex(r => intersects(left, r[0]) && intersects(right, r[1])) === -1;\n}\n\nvar endingEmojiZWJ = /(?:[\\xA9\\xAE\\u203C\\u2049\\u2122\\u2139\\u2194-\\u2199\\u21A9\\u21AA\\u231A\\u231B\\u2328\\u2388\\u23CF\\u23E9-\\u23F3\\u23F8-\\u23FA\\u24C2\\u25AA\\u25AB\\u25B6\\u25C0\\u25FB-\\u25FE\\u2600-\\u2605\\u2607-\\u2612\\u2614-\\u2685\\u2690-\\u2705\\u2708-\\u2712\\u2714\\u2716\\u271D\\u2721\\u2728\\u2733\\u2734\\u2744\\u2747\\u274C\\u274E\\u2753-\\u2755\\u2757\\u2763-\\u2767\\u2795-\\u2797\\u27A1\\u27B0\\u27BF\\u2934\\u2935\\u2B05-\\u2B07\\u2B1B\\u2B1C\\u2B50\\u2B55\\u3030\\u303D\\u3297\\u3299]|\\uD83C[\\uDC00-\\uDCFF\\uDD0D-\\uDD0F\\uDD2F\\uDD6C-\\uDD71\\uDD7E\\uDD7F\\uDD8E\\uDD91-\\uDD9A\\uDDAD-\\uDDE5\\uDE01-\\uDE0F\\uDE1A\\uDE2F\\uDE32-\\uDE3A\\uDE3C-\\uDE3F\\uDE49-\\uDFFA]|\\uD83D[\\uDC00-\\uDD3D\\uDD46-\\uDE4F\\uDE80-\\uDEFF\\uDF74-\\uDF7F\\uDFD5-\\uDFFF]|\\uD83E[\\uDC0C-\\uDC0F\\uDC48-\\uDC4F\\uDC5A-\\uDC5F\\uDC88-\\uDC8F\\uDCAE-\\uDCFF\\uDD0C-\\uDD3A\\uDD3C-\\uDD45\\uDD47-\\uDEFF]|\\uD83F[\\uDC00-\\uDFFD])(?:[\\u0300-\\u036F\\u0483-\\u0489\\u0591-\\u05BD\\u05BF\\u05C1\\u05C2\\u05C4\\u05C5\\u05C7\\u0610-\\u061A\\u064B-\\u065F\\u0670\\u06D6-\\u06DC\\u06DF-\\u06E4\\u06E7\\u06E8\\u06EA-\\u06ED\\u0711\\u0730-\\u074A\\u07A6-\\u07B0\\u07EB-\\u07F3\\u07FD\\u0816-\\u0819\\u081B-\\u0823\\u0825-\\u0827\\u0829-\\u082D\\u0859-\\u085B\\u08D3-\\u08E1\\u08E3-\\u0902\\u093A\\u093C\\u0941-\\u0948\\u094D\\u0951-\\u0957\\u0962\\u0963\\u0981\\u09BC\\u09BE\\u09C1-\\u09C4\\u09CD\\u09D7\\u09E2\\u09E3\\u09FE\\u0A01\\u0A02\\u0A3C\\u0A41\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A51\\u0A70\\u0A71\\u0A75\\u0A81\\u0A82\\u0ABC\\u0AC1-\\u0AC5\\u0AC7\\u0AC8\\u0ACD\\u0AE2\\u0AE3\\u0AFA-\\u0AFF\\u0B01\\u0B3C\\u0B3E\\u0B3F\\u0B41-\\u0B44\\u0B4D\\u0B55-\\u0B57\\u0B62\\u0B63\\u0B82\\u0BBE\\u0BC0\\u0BCD\\u0BD7\\u0C00\\u0C04\\u0C3E-\\u0C40\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C62\\u0C63\\u0C81\\u0CBC\\u0CBF\\u0CC2\\u0CC6\\u0CCC\\u0CCD\\u0CD5\\u0CD6\\u0CE2\\u0CE3\\u0D00\\u0D01\\u0D3B\\u0D3C\\u0D3E\\u0D41-\\u0D44\\u0D4D\\u0D57\\u0D62\\u0D63\\u0D81\\u0DCA\\u0DCF\\u0DD2-\\u0DD4\\u0DD6\\u0DDF\\u0E31\\u0E34-\\u0E3A\\u0E47-\\u0E4E\\u0EB1\\u0EB4-\\u0EBC\\u0EC8-\\u0ECD\\u0F18\\u0F19\\u0F35\\u0F37\\u0F39\\u0F71-\\u0F7E\\u0F80-\\u0F84\\u0F86\\u0F87\\u0F8D-\\u0F97\\u0F99-\\u0FBC\\u0FC6\\u102D-\\u1030\\u1032-\\u1037\\u1039\\u103A\\u103D\\u103E\\u1058\\u1059\\u105E-\\u1060\\u1071-\\u1074\\u1082\\u1085\\u1086\\u108D\\u109D\\u135D-\\u135F\\u1712-\\u1714\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17B4\\u17B5\\u17B7-\\u17BD\\u17C6\\u17C9-\\u17D3\\u17DD\\u180B-\\u180D\\u1885\\u1886\\u18A9\\u1920-\\u1922\\u1927\\u1928\\u1932\\u1939-\\u193B\\u1A17\\u1A18\\u1A1B\\u1A56\\u1A58-\\u1A5E\\u1A60\\u1A62\\u1A65-\\u1A6C\\u1A73-\\u1A7C\\u1A7F\\u1AB0-\\u1AC0\\u1B00-\\u1B03\\u1B34-\\u1B3A\\u1B3C\\u1B42\\u1B6B-\\u1B73\\u1B80\\u1B81\\u1BA2-\\u1BA5\\u1BA8\\u1BA9\\u1BAB-\\u1BAD\\u1BE6\\u1BE8\\u1BE9\\u1BED\\u1BEF-\\u1BF1\\u1C2C-\\u1C33\\u1C36\\u1C37\\u1CD0-\\u1CD2\\u1CD4-\\u1CE0\\u1CE2-\\u1CE8\\u1CED\\u1CF4\\u1CF8\\u1CF9\\u1DC0-\\u1DF9\\u1DFB-\\u1DFF\\u200C\\u20D0-\\u20F0\\u2CEF-\\u2CF1\\u2D7F\\u2DE0-\\u2DFF\\u302A-\\u302F\\u3099\\u309A\\uA66F-\\uA672\\uA674-\\uA67D\\uA69E\\uA69F\\uA6F0\\uA6F1\\uA802\\uA806\\uA80B\\uA825\\uA826\\uA82C\\uA8C4\\uA8C5\\uA8E0-\\uA8F1\\uA8FF\\uA926-\\uA92D\\uA947-\\uA951\\uA980-\\uA982\\uA9B3\\uA9B6-\\uA9B9\\uA9BC\\uA9BD\\uA9E5\\uAA29-\\uAA2E\\uAA31\\uAA32\\uAA35\\uAA36\\uAA43\\uAA4C\\uAA7C\\uAAB0\\uAAB2-\\uAAB4\\uAAB7\\uAAB8\\uAABE\\uAABF\\uAAC1\\uAAEC\\uAAED\\uAAF6\\uABE5\\uABE8\\uABED\\uFB1E\\uFE00-\\uFE0F\\uFE20-\\uFE2F\\uFF9E\\uFF9F]|\\uD800[\\uDDFD\\uDEE0\\uDF76-\\uDF7A]|\\uD802[\\uDE01-\\uDE03\\uDE05\\uDE06\\uDE0C-\\uDE0F\\uDE38-\\uDE3A\\uDE3F\\uDEE5\\uDEE6]|\\uD803[\\uDD24-\\uDD27\\uDEAB\\uDEAC\\uDF46-\\uDF50]|\\uD804[\\uDC01\\uDC38-\\uDC46\\uDC7F-\\uDC81\\uDCB3-\\uDCB6\\uDCB9\\uDCBA\\uDD00-\\uDD02\\uDD27-\\uDD2B\\uDD2D-\\uDD34\\uDD73\\uDD80\\uDD81\\uDDB6-\\uDDBE\\uDDC9-\\uDDCC\\uDDCF\\uDE2F-\\uDE31\\uDE34\\uDE36\\uDE37\\uDE3E\\uDEDF\\uDEE3-\\uDEEA\\uDF00\\uDF01\\uDF3B\\uDF3C\\uDF3E\\uDF40\\uDF57\\uDF66-\\uDF6C\\uDF70-\\uDF74]|\\uD805[\\uDC38-\\uDC3F\\uDC42-\\uDC44\\uDC46\\uDC5E\\uDCB0\\uDCB3-\\uDCB8\\uDCBA\\uDCBD\\uDCBF\\uDCC0\\uDCC2\\uDCC3\\uDDAF\\uDDB2-\\uDDB5\\uDDBC\\uDDBD\\uDDBF\\uDDC0\\uDDDC\\uDDDD\\uDE33-\\uDE3A\\uDE3D\\uDE3F\\uDE40\\uDEAB\\uDEAD\\uDEB0-\\uDEB5\\uDEB7\\uDF1D-\\uDF1F\\uDF22-\\uDF25\\uDF27-\\uDF2B]|\\uD806[\\uDC2F-\\uDC37\\uDC39\\uDC3A\\uDD30\\uDD3B\\uDD3C\\uDD3E\\uDD43\\uDDD4-\\uDDD7\\uDDDA\\uDDDB\\uDDE0\\uDE01-\\uDE0A\\uDE33-\\uDE38\\uDE3B-\\uDE3E\\uDE47\\uDE51-\\uDE56\\uDE59-\\uDE5B\\uDE8A-\\uDE96\\uDE98\\uDE99]|\\uD807[\\uDC30-\\uDC36\\uDC38-\\uDC3D\\uDC3F\\uDC92-\\uDCA7\\uDCAA-\\uDCB0\\uDCB2\\uDCB3\\uDCB5\\uDCB6\\uDD31-\\uDD36\\uDD3A\\uDD3C\\uDD3D\\uDD3F-\\uDD45\\uDD47\\uDD90\\uDD91\\uDD95\\uDD97\\uDEF3\\uDEF4]|\\uD81A[\\uDEF0-\\uDEF4\\uDF30-\\uDF36]|\\uD81B[\\uDF4F\\uDF8F-\\uDF92\\uDFE4]|\\uD82F[\\uDC9D\\uDC9E]|\\uD834[\\uDD65\\uDD67-\\uDD69\\uDD6E-\\uDD72\\uDD7B-\\uDD82\\uDD85-\\uDD8B\\uDDAA-\\uDDAD\\uDE42-\\uDE44]|\\uD836[\\uDE00-\\uDE36\\uDE3B-\\uDE6C\\uDE75\\uDE84\\uDE9B-\\uDE9F\\uDEA1-\\uDEAF]|\\uD838[\\uDC00-\\uDC06\\uDC08-\\uDC18\\uDC1B-\\uDC21\\uDC23\\uDC24\\uDC26-\\uDC2A\\uDD30-\\uDD36\\uDEEC-\\uDEEF]|\\uD83A[\\uDCD0-\\uDCD6\\uDD44-\\uDD4A]|\\uD83C[\\uDFFB-\\uDFFF]|\\uDB40[\\uDC20-\\uDC7F\\uDD00-\\uDDEF])*\\u200D$/;\n\nvar endsWithEmojiZWJ = str => {\n  return str.search(endingEmojiZWJ) !== -1;\n};\n\nvar endingRIs = /(?:\\uD83C[\\uDDE6-\\uDDFF])+$/g;\n\nvar endsWithOddNumberOfRIs = str => {\n  var match = str.match(endingRIs);\n\n  if (match === null) {\n    return false;\n  } else {\n    // A RI is represented by a surrogate pair.\n    var numRIs = match[0].length / 2;\n    return numRIs % 2 === 1;\n  }\n};\n\n/**\r\n * Shared the function with isElementType utility\r\n */\n\nvar isElement = value => {\n  return isPlainObject(value) && Node.isNodeList(value.children) && !Editor.isEditor(value);\n}; // eslint-disable-next-line no-redeclare\n\n\nvar Element = {\n  /**\r\n   * Check if a value implements the 'Ancestor' interface.\r\n   */\n  isAncestor(value) {\n    return isPlainObject(value) && Node.isNodeList(value.children);\n  },\n\n  /**\r\n   * Check if a value implements the `Element` interface.\r\n   */\n  isElement,\n\n  /**\r\n   * Check if a value is an array of `Element` objects.\r\n   */\n  isElementList(value) {\n    return Array.isArray(value) && value.every(val => Element.isElement(val));\n  },\n\n  /**\r\n   * Check if a set of props is a partial of Element.\r\n   */\n  isElementProps(props) {\n    return props.children !== undefined;\n  },\n\n  /**\r\n   * Check if a value implements the `Element` interface and has elementKey with selected value.\r\n   * Default it check to `type` key value\r\n   */\n  isElementType: function isElementType(value, elementVal) {\n    var elementKey = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'type';\n    return isElement(value) && value[elementKey] === elementVal;\n  },\n\n  /**\r\n   * Check if an element matches set of properties.\r\n   *\r\n   * Note: this checks custom properties, and it does not ensure that any\r\n   * children are equivalent.\r\n   */\n  matches(element, props) {\n    for (var key in props) {\n      if (key === 'children') {\n        continue;\n      }\n\n      if (element[key] !== props[key]) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n};\n\nvar _excluded$4 = [\"text\"],\n    _excluded2$3 = [\"text\"];\n\nfunction ownKeys$8(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread$8(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$8(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$8(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\nvar IS_EDITOR_CACHE = new WeakMap(); // eslint-disable-next-line no-redeclare\n\nvar Editor = {\n  /**\r\n   * Get the ancestor above a location in the document.\r\n   */\n  above(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var {\n      voids = false,\n      mode = 'lowest',\n      at = editor.selection,\n      match\n    } = options;\n\n    if (!at) {\n      return;\n    }\n\n    var path = Editor.path(editor, at);\n    var reverse = mode === 'lowest';\n\n    for (var [n, p] of Editor.levels(editor, {\n      at: path,\n      voids,\n      match,\n      reverse\n    })) {\n      if (!Text.isText(n) && !Path.equals(path, p)) {\n        return [n, p];\n      }\n    }\n  },\n\n  /**\r\n   * Add a custom property to the leaf text nodes in the current selection.\r\n   *\r\n   * If the selection is currently collapsed, the marks will be added to the\r\n   * `editor.marks` property instead, and applied when text is inserted next.\r\n   */\n  addMark(editor, key, value) {\n    editor.addMark(key, value);\n  },\n\n  /**\r\n   * Get the point after a location.\r\n   */\n  after(editor, at) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var anchor = Editor.point(editor, at, {\n      edge: 'end'\n    });\n    var focus = Editor.end(editor, []);\n    var range = {\n      anchor,\n      focus\n    };\n    var {\n      distance = 1\n    } = options;\n    var d = 0;\n    var target;\n\n    for (var p of Editor.positions(editor, _objectSpread$8(_objectSpread$8({}, options), {}, {\n      at: range\n    }))) {\n      if (d > distance) {\n        break;\n      }\n\n      if (d !== 0) {\n        target = p;\n      }\n\n      d++;\n    }\n\n    return target;\n  },\n\n  /**\r\n   * Get the point before a location.\r\n   */\n  before(editor, at) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var anchor = Editor.start(editor, []);\n    var focus = Editor.point(editor, at, {\n      edge: 'start'\n    });\n    var range = {\n      anchor,\n      focus\n    };\n    var {\n      distance = 1\n    } = options;\n    var d = 0;\n    var target;\n\n    for (var p of Editor.positions(editor, _objectSpread$8(_objectSpread$8({}, options), {}, {\n      at: range,\n      reverse: true\n    }))) {\n      if (d > distance) {\n        break;\n      }\n\n      if (d !== 0) {\n        target = p;\n      }\n\n      d++;\n    }\n\n    return target;\n  },\n\n  /**\r\n   * Delete content in the editor backward from the current selection.\r\n   */\n  deleteBackward(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var {\n      unit = 'character'\n    } = options;\n    editor.deleteBackward(unit);\n  },\n\n  /**\r\n   * Delete content in the editor forward from the current selection.\r\n   */\n  deleteForward(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var {\n      unit = 'character'\n    } = options;\n    editor.deleteForward(unit);\n  },\n\n  /**\r\n   * Delete the content in the current selection.\r\n   */\n  deleteFragment(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var {\n      direction = 'forward'\n    } = options;\n    editor.deleteFragment(direction);\n  },\n\n  /**\r\n   * Get the start and end points of a location.\r\n   */\n  edges(editor, at) {\n    return [Editor.start(editor, at), Editor.end(editor, at)];\n  },\n\n  /**\r\n   * Get the end point of a location.\r\n   */\n  end(editor, at) {\n    return Editor.point(editor, at, {\n      edge: 'end'\n    });\n  },\n\n  /**\r\n   * Get the first node at a location.\r\n   */\n  first(editor, at) {\n    var path = Editor.path(editor, at, {\n      edge: 'start'\n    });\n    return Editor.node(editor, path);\n  },\n\n  /**\r\n   * Get the fragment at a location.\r\n   */\n  fragment(editor, at) {\n    var range = Editor.range(editor, at);\n    var fragment = Node.fragment(editor, range);\n    return fragment;\n  },\n\n  /**\r\n   * Check if a node has block children.\r\n   */\n  hasBlocks(editor, element) {\n    return element.children.some(n => Editor.isBlock(editor, n));\n  },\n\n  /**\r\n   * Check if a node has inline and text children.\r\n   */\n  hasInlines(editor, element) {\n    return element.children.some(n => Text.isText(n) || Editor.isInline(editor, n));\n  },\n\n  /**\r\n   * Check if a node has text children.\r\n   */\n  hasTexts(editor, element) {\n    return element.children.every(n => Text.isText(n));\n  },\n\n  /**\r\n   * Insert a block break at the current selection.\r\n   *\r\n   * If the selection is currently expanded, it will be deleted first.\r\n   */\n  insertBreak(editor) {\n    editor.insertBreak();\n  },\n\n  /**\r\n   * Insert a soft break at the current selection.\r\n   *\r\n   * If the selection is currently expanded, it will be deleted first.\r\n   */\n  insertSoftBreak(editor) {\n    editor.insertSoftBreak();\n  },\n\n  /**\r\n   * Insert a fragment at the current selection.\r\n   *\r\n   * If the selection is currently expanded, it will be deleted first.\r\n   */\n  insertFragment(editor, fragment) {\n    editor.insertFragment(fragment);\n  },\n\n  /**\r\n   * Insert a node at the current selection.\r\n   *\r\n   * If the selection is currently expanded, it will be deleted first.\r\n   */\n  insertNode(editor, node) {\n    editor.insertNode(node);\n  },\n\n  /**\r\n   * Insert text at the current selection.\r\n   *\r\n   * If the selection is currently expanded, it will be deleted first.\r\n   */\n  insertText(editor, text) {\n    editor.insertText(text);\n  },\n\n  /**\r\n   * Check if a value is a block `Element` object.\r\n   */\n  isBlock(editor, value) {\n    return Element.isElement(value) && !editor.isInline(value);\n  },\n\n  /**\r\n   * Check if a value is an `Editor` object.\r\n   */\n  isEditor(value) {\n    var cachedIsEditor = IS_EDITOR_CACHE.get(value);\n\n    if (cachedIsEditor !== undefined) {\n      return cachedIsEditor;\n    }\n\n    if (!isPlainObject(value)) {\n      return false;\n    }\n\n    var isEditor = typeof value.addMark === 'function' && typeof value.apply === 'function' && typeof value.deleteBackward === 'function' && typeof value.deleteForward === 'function' && typeof value.deleteFragment === 'function' && typeof value.insertBreak === 'function' && typeof value.insertSoftBreak === 'function' && typeof value.insertFragment === 'function' && typeof value.insertNode === 'function' && typeof value.insertText === 'function' && typeof value.isInline === 'function' && typeof value.isVoid === 'function' && typeof value.normalizeNode === 'function' && typeof value.onChange === 'function' && typeof value.removeMark === 'function' && typeof value.getDirtyPaths === 'function' && (value.marks === null || isPlainObject(value.marks)) && (value.selection === null || Range.isRange(value.selection)) && Node.isNodeList(value.children) && Operation.isOperationList(value.operations);\n    IS_EDITOR_CACHE.set(value, isEditor);\n    return isEditor;\n  },\n\n  /**\r\n   * Check if a point is the end point of a location.\r\n   */\n  isEnd(editor, point, at) {\n    var end = Editor.end(editor, at);\n    return Point.equals(point, end);\n  },\n\n  /**\r\n   * Check if a point is an edge of a location.\r\n   */\n  isEdge(editor, point, at) {\n    return Editor.isStart(editor, point, at) || Editor.isEnd(editor, point, at);\n  },\n\n  /**\r\n   * Check if an element is empty, accounting for void nodes.\r\n   */\n  isEmpty(editor, element) {\n    var {\n      children\n    } = element;\n    var [first] = children;\n    return children.length === 0 || children.length === 1 && Text.isText(first) && first.text === '' && !editor.isVoid(element);\n  },\n\n  /**\r\n   * Check if a value is an inline `Element` object.\r\n   */\n  isInline(editor, value) {\n    return Element.isElement(value) && editor.isInline(value);\n  },\n\n  /**\r\n   * Check if the editor is currently normalizing after each operation.\r\n   */\n  isNormalizing(editor) {\n    var isNormalizing = NORMALIZING.get(editor);\n    return isNormalizing === undefined ? true : isNormalizing;\n  },\n\n  /**\r\n   * Check if a point is the start point of a location.\r\n   */\n  isStart(editor, point, at) {\n    // PERF: If the offset isn't `0` we know it's not the start.\n    if (point.offset !== 0) {\n      return false;\n    }\n\n    var start = Editor.start(editor, at);\n    return Point.equals(point, start);\n  },\n\n  /**\r\n   * Check if a value is a void `Element` object.\r\n   */\n  isVoid(editor, value) {\n    return Element.isElement(value) && editor.isVoid(value);\n  },\n\n  /**\r\n   * Get the last node at a location.\r\n   */\n  last(editor, at) {\n    var path = Editor.path(editor, at, {\n      edge: 'end'\n    });\n    return Editor.node(editor, path);\n  },\n\n  /**\r\n   * Get the leaf text node at a location.\r\n   */\n  leaf(editor, at) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var path = Editor.path(editor, at, options);\n    var node = Node.leaf(editor, path);\n    return [node, path];\n  },\n\n  /**\r\n   * Iterate through all of the levels at a location.\r\n   */\n  *levels(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var {\n      at = editor.selection,\n      reverse = false,\n      voids = false\n    } = options;\n    var {\n      match\n    } = options;\n\n    if (match == null) {\n      match = () => true;\n    }\n\n    if (!at) {\n      return;\n    }\n\n    var levels = [];\n    var path = Editor.path(editor, at);\n\n    for (var [n, p] of Node.levels(editor, path)) {\n      if (!match(n, p)) {\n        continue;\n      }\n\n      levels.push([n, p]);\n\n      if (!voids && Editor.isVoid(editor, n)) {\n        break;\n      }\n    }\n\n    if (reverse) {\n      levels.reverse();\n    }\n\n    yield* levels;\n  },\n\n  /**\r\n   * Get the marks that would be added to text at the current selection.\r\n   */\n  marks(editor) {\n    var {\n      marks,\n      selection\n    } = editor;\n\n    if (!selection) {\n      return null;\n    }\n\n    if (marks) {\n      return marks;\n    }\n\n    if (Range.isExpanded(selection)) {\n      var [match] = Editor.nodes(editor, {\n        match: Text.isText\n      });\n\n      if (match) {\n        var [_node] = match;\n\n        var _rest = _objectWithoutProperties$1(_node, _excluded$4);\n\n        return _rest;\n      } else {\n        return {};\n      }\n    }\n\n    var {\n      anchor\n    } = selection;\n    var {\n      path\n    } = anchor;\n    var [node] = Editor.leaf(editor, path);\n\n    if (anchor.offset === 0) {\n      var prev = Editor.previous(editor, {\n        at: path,\n        match: Text.isText\n      });\n      var block = Editor.above(editor, {\n        match: n => Editor.isBlock(editor, n)\n      });\n\n      if (prev && block) {\n        var [prevNode, prevPath] = prev;\n        var [, blockPath] = block;\n\n        if (Path.isAncestor(blockPath, prevPath)) {\n          node = prevNode;\n        }\n      }\n    }\n\n    var rest = _objectWithoutProperties$1(node, _excluded2$3);\n\n    return rest;\n  },\n\n  /**\r\n   * Get the matching node in the branch of the document after a location.\r\n   */\n  next(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var {\n      mode = 'lowest',\n      voids = false\n    } = options;\n    var {\n      match,\n      at = editor.selection\n    } = options;\n\n    if (!at) {\n      return;\n    }\n\n    var pointAfterLocation = Editor.after(editor, at, {\n      voids\n    });\n    if (!pointAfterLocation) return;\n    var [, to] = Editor.last(editor, []);\n    var span = [pointAfterLocation.path, to];\n\n    if (Path.isPath(at) && at.length === 0) {\n      throw new Error(\"Cannot get the next node from the root node!\");\n    }\n\n    if (match == null) {\n      if (Path.isPath(at)) {\n        var [parent] = Editor.parent(editor, at);\n\n        match = n => parent.children.includes(n);\n      } else {\n        match = () => true;\n      }\n    }\n\n    var [next] = Editor.nodes(editor, {\n      at: span,\n      match,\n      mode,\n      voids\n    });\n    return next;\n  },\n\n  /**\r\n   * Get the node at a location.\r\n   */\n  node(editor, at) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var path = Editor.path(editor, at, options);\n    var node = Node.get(editor, path);\n    return [node, path];\n  },\n\n  /**\r\n   * Iterate through all of the nodes in the Editor.\r\n   */\n  *nodes(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var {\n      at = editor.selection,\n      mode = 'all',\n      universal = false,\n      reverse = false,\n      voids = false\n    } = options;\n    var {\n      match\n    } = options;\n\n    if (!match) {\n      match = () => true;\n    }\n\n    if (!at) {\n      return;\n    }\n\n    var from;\n    var to;\n\n    if (Span.isSpan(at)) {\n      from = at[0];\n      to = at[1];\n    } else {\n      var first = Editor.path(editor, at, {\n        edge: 'start'\n      });\n      var last = Editor.path(editor, at, {\n        edge: 'end'\n      });\n      from = reverse ? last : first;\n      to = reverse ? first : last;\n    }\n\n    var nodeEntries = Node.nodes(editor, {\n      reverse,\n      from,\n      to,\n      pass: _ref => {\n        var [n] = _ref;\n        return voids ? false : Editor.isVoid(editor, n);\n      }\n    });\n    var matches = [];\n    var hit;\n\n    for (var [node, path] of nodeEntries) {\n      var isLower = hit && Path.compare(path, hit[1]) === 0; // In highest mode any node lower than the last hit is not a match.\n\n      if (mode === 'highest' && isLower) {\n        continue;\n      }\n\n      if (!match(node, path)) {\n        // If we've arrived at a leaf text node that is not lower than the last\n        // hit, then we've found a branch that doesn't include a match, which\n        // means the match is not universal.\n        if (universal && !isLower && Text.isText(node)) {\n          return;\n        } else {\n          continue;\n        }\n      } // If there's a match and it's lower than the last, update the hit.\n\n\n      if (mode === 'lowest' && isLower) {\n        hit = [node, path];\n        continue;\n      } // In lowest mode we emit the last hit, once it's guaranteed lowest.\n\n\n      var emit = mode === 'lowest' ? hit : [node, path];\n\n      if (emit) {\n        if (universal) {\n          matches.push(emit);\n        } else {\n          yield emit;\n        }\n      }\n\n      hit = [node, path];\n    } // Since lowest is always emitting one behind, catch up at the end.\n\n\n    if (mode === 'lowest' && hit) {\n      if (universal) {\n        matches.push(hit);\n      } else {\n        yield hit;\n      }\n    } // Universal defers to ensure that the match occurs in every branch, so we\n    // yield all of the matches after iterating.\n\n\n    if (universal) {\n      yield* matches;\n    }\n  },\n\n  /**\r\n   * Normalize any dirty objects in the editor.\r\n   */\n  normalize(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var {\n      force = false\n    } = options;\n\n    var getDirtyPaths = editor => {\n      return DIRTY_PATHS.get(editor) || [];\n    };\n\n    var getDirtyPathKeys = editor => {\n      return DIRTY_PATH_KEYS.get(editor) || new Set();\n    };\n\n    var popDirtyPath = editor => {\n      var path = getDirtyPaths(editor).pop();\n      var key = path.join(',');\n      getDirtyPathKeys(editor).delete(key);\n      return path;\n    };\n\n    if (!Editor.isNormalizing(editor)) {\n      return;\n    }\n\n    if (force) {\n      var allPaths = Array.from(Node.nodes(editor), _ref2 => {\n        var [, p] = _ref2;\n        return p;\n      });\n      var allPathKeys = new Set(allPaths.map(p => p.join(',')));\n      DIRTY_PATHS.set(editor, allPaths);\n      DIRTY_PATH_KEYS.set(editor, allPathKeys);\n    }\n\n    if (getDirtyPaths(editor).length === 0) {\n      return;\n    }\n\n    Editor.withoutNormalizing(editor, () => {\n      /*\r\n        Fix dirty elements with no children.\r\n        editor.normalizeNode() does fix this, but some normalization fixes also require it to work.\r\n        Running an initial pass avoids the catch-22 race condition.\r\n      */\n      for (var dirtyPath of getDirtyPaths(editor)) {\n        if (Node.has(editor, dirtyPath)) {\n          var entry = Editor.node(editor, dirtyPath);\n          var [node, _] = entry;\n          /*\r\n            The default normalizer inserts an empty text node in this scenario, but it can be customised.\r\n            So there is some risk here.\r\n                       As long as the normalizer only inserts child nodes for this case it is safe to do in any order;\r\n            by definition adding children to an empty node can't cause other paths to change.\r\n          */\n\n          if (Element.isElement(node) && node.children.length === 0) {\n            editor.normalizeNode(entry);\n          }\n        }\n      }\n\n      var max = getDirtyPaths(editor).length * 42; // HACK: better way?\n\n      var m = 0;\n\n      while (getDirtyPaths(editor).length !== 0) {\n        if (m > max) {\n          throw new Error(\"\\n            Could not completely normalize the editor after \".concat(max, \" iterations! This is usually due to incorrect normalization logic that leaves a node in an invalid state.\\n          \"));\n        }\n\n        var _dirtyPath = popDirtyPath(editor); // If the node doesn't exist in the tree, it does not need to be normalized.\n\n\n        if (Node.has(editor, _dirtyPath)) {\n          var _entry = Editor.node(editor, _dirtyPath);\n\n          editor.normalizeNode(_entry);\n        }\n\n        m++;\n      }\n    });\n  },\n\n  /**\r\n   * Get the parent node of a location.\r\n   */\n  parent(editor, at) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var path = Editor.path(editor, at, options);\n    var parentPath = Path.parent(path);\n    var entry = Editor.node(editor, parentPath);\n    return entry;\n  },\n\n  /**\r\n   * Get the path of a location.\r\n   */\n  path(editor, at) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var {\n      depth,\n      edge\n    } = options;\n\n    if (Path.isPath(at)) {\n      if (edge === 'start') {\n        var [, firstPath] = Node.first(editor, at);\n        at = firstPath;\n      } else if (edge === 'end') {\n        var [, lastPath] = Node.last(editor, at);\n        at = lastPath;\n      }\n    }\n\n    if (Range.isRange(at)) {\n      if (edge === 'start') {\n        at = Range.start(at);\n      } else if (edge === 'end') {\n        at = Range.end(at);\n      } else {\n        at = Path.common(at.anchor.path, at.focus.path);\n      }\n    }\n\n    if (Point.isPoint(at)) {\n      at = at.path;\n    }\n\n    if (depth != null) {\n      at = at.slice(0, depth);\n    }\n\n    return at;\n  },\n\n  hasPath(editor, path) {\n    return Node.has(editor, path);\n  },\n\n  /**\r\n   * Create a mutable ref for a `Path` object, which will stay in sync as new\r\n   * operations are applied to the editor.\r\n   */\n  pathRef(editor, path) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var {\n      affinity = 'forward'\n    } = options;\n    var ref = {\n      current: path,\n      affinity,\n\n      unref() {\n        var {\n          current\n        } = ref;\n        var pathRefs = Editor.pathRefs(editor);\n        pathRefs.delete(ref);\n        ref.current = null;\n        return current;\n      }\n\n    };\n    var refs = Editor.pathRefs(editor);\n    refs.add(ref);\n    return ref;\n  },\n\n  /**\r\n   * Get the set of currently tracked path refs of the editor.\r\n   */\n  pathRefs(editor) {\n    var refs = PATH_REFS.get(editor);\n\n    if (!refs) {\n      refs = new Set();\n      PATH_REFS.set(editor, refs);\n    }\n\n    return refs;\n  },\n\n  /**\r\n   * Get the start or end point of a location.\r\n   */\n  point(editor, at) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var {\n      edge = 'start'\n    } = options;\n\n    if (Path.isPath(at)) {\n      var path;\n\n      if (edge === 'end') {\n        var [, lastPath] = Node.last(editor, at);\n        path = lastPath;\n      } else {\n        var [, firstPath] = Node.first(editor, at);\n        path = firstPath;\n      }\n\n      var node = Node.get(editor, path);\n\n      if (!Text.isText(node)) {\n        throw new Error(\"Cannot get the \".concat(edge, \" point in the node at path [\").concat(at, \"] because it has no \").concat(edge, \" text node.\"));\n      }\n\n      return {\n        path,\n        offset: edge === 'end' ? node.text.length : 0\n      };\n    }\n\n    if (Range.isRange(at)) {\n      var [start, end] = Range.edges(at);\n      return edge === 'start' ? start : end;\n    }\n\n    return at;\n  },\n\n  /**\r\n   * Create a mutable ref for a `Point` object, which will stay in sync as new\r\n   * operations are applied to the editor.\r\n   */\n  pointRef(editor, point) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var {\n      affinity = 'forward'\n    } = options;\n    var ref = {\n      current: point,\n      affinity,\n\n      unref() {\n        var {\n          current\n        } = ref;\n        var pointRefs = Editor.pointRefs(editor);\n        pointRefs.delete(ref);\n        ref.current = null;\n        return current;\n      }\n\n    };\n    var refs = Editor.pointRefs(editor);\n    refs.add(ref);\n    return ref;\n  },\n\n  /**\r\n   * Get the set of currently tracked point refs of the editor.\r\n   */\n  pointRefs(editor) {\n    var refs = POINT_REFS.get(editor);\n\n    if (!refs) {\n      refs = new Set();\n      POINT_REFS.set(editor, refs);\n    }\n\n    return refs;\n  },\n\n  /**\r\n   * Return all the positions in `at` range where a `Point` can be placed.\r\n   *\r\n   * By default, moves forward by individual offsets at a time, but\r\n   * the `unit` option can be used to to move by character, word, line, or block.\r\n   *\r\n   * The `reverse` option can be used to change iteration direction.\r\n   *\r\n   * Note: By default void nodes are treated as a single point and iteration\r\n   * will not happen inside their content unless you pass in true for the\r\n   * `voids` option, then iteration will occur.\r\n   */\n  *positions(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var {\n      at = editor.selection,\n      unit = 'offset',\n      reverse = false,\n      voids = false\n    } = options;\n\n    if (!at) {\n      return;\n    }\n    /**\r\n     * Algorithm notes:\r\n     *\r\n     * Each step `distance` is dynamic depending on the underlying text\r\n     * and the `unit` specified.  Each step, e.g., a line or word, may\r\n     * span multiple text nodes, so we iterate through the text both on\r\n     * two levels in step-sync:\r\n     *\r\n     * `leafText` stores the text on a text leaf level, and is advanced\r\n     * through using the counters `leafTextOffset` and `leafTextRemaining`.\r\n     *\r\n     * `blockText` stores the text on a block level, and is shortened\r\n     * by `distance` every time it is advanced.\r\n     *\r\n     * We only maintain a window of one blockText and one leafText because\r\n     * a block node always appears before all of its leaf nodes.\r\n     */\n\n\n    var range = Editor.range(editor, at);\n    var [start, end] = Range.edges(range);\n    var first = reverse ? end : start;\n    var isNewBlock = false;\n    var blockText = '';\n    var distance = 0; // Distance for leafText to catch up to blockText.\n\n    var leafTextRemaining = 0;\n    var leafTextOffset = 0; // Iterate through all nodes in range, grabbing entire textual content\n    // of block nodes in blockText, and text nodes in leafText.\n    // Exploits the fact that nodes are sequenced in such a way that we first\n    // encounter the block node, then all of its text nodes, so when iterating\n    // through the blockText and leafText we just need to remember a window of\n    // one block node and leaf node, respectively.\n\n    for (var [node, path] of Editor.nodes(editor, {\n      at,\n      reverse,\n      voids\n    })) {\n      /*\r\n       * ELEMENT NODE - Yield position(s) for voids, collect blockText for blocks\r\n       */\n      if (Element.isElement(node)) {\n        // Void nodes are a special case, so by default we will always\n        // yield their first point. If the `voids` option is set to true,\n        // then we will iterate over their content.\n        if (!voids && editor.isVoid(node)) {\n          yield Editor.start(editor, path);\n          continue;\n        } // Inline element nodes are ignored as they don't themselves\n        // contribute to `blockText` or `leafText` - their parent and\n        // children do.\n\n\n        if (editor.isInline(node)) continue; // Block element node - set `blockText` to its text content.\n\n        if (Editor.hasInlines(editor, node)) {\n          // We always exhaust block nodes before encountering a new one:\n          //   console.assert(blockText === '',\n          //     `blockText='${blockText}' - `+\n          //     `not exhausted before new block node`, path)\n          // Ensure range considered is capped to `range`, in the\n          // start/end edge cases where block extends beyond range.\n          // Equivalent to this, but presumably more performant:\n          //   blockRange = Editor.range(editor, ...Editor.edges(editor, path))\n          //   blockRange = Range.intersection(range, blockRange) // intersect\n          //   blockText = Editor.string(editor, blockRange, { voids })\n          var e = Path.isAncestor(path, end.path) ? end : Editor.end(editor, path);\n          var s = Path.isAncestor(path, start.path) ? start : Editor.start(editor, path);\n          blockText = Editor.string(editor, {\n            anchor: s,\n            focus: e\n          }, {\n            voids\n          });\n          isNewBlock = true;\n        }\n      }\n      /*\r\n       * TEXT LEAF NODE - Iterate through text content, yielding\r\n       * positions every `distance` offset according to `unit`.\r\n       */\n\n\n      if (Text.isText(node)) {\n        var isFirst = Path.equals(path, first.path); // Proof that we always exhaust text nodes before encountering a new one:\n        //   console.assert(leafTextRemaining <= 0,\n        //     `leafTextRemaining=${leafTextRemaining} - `+\n        //     `not exhausted before new leaf text node`, path)\n        // Reset `leafText` counters for new text node.\n\n        if (isFirst) {\n          leafTextRemaining = reverse ? first.offset : node.text.length - first.offset;\n          leafTextOffset = first.offset; // Works for reverse too.\n        } else {\n          leafTextRemaining = node.text.length;\n          leafTextOffset = reverse ? leafTextRemaining : 0;\n        } // Yield position at the start of node (potentially).\n\n\n        if (isFirst || isNewBlock || unit === 'offset') {\n          yield {\n            path,\n            offset: leafTextOffset\n          };\n          isNewBlock = false;\n        } // Yield positions every (dynamically calculated) `distance` offset.\n\n\n        while (true) {\n          // If `leafText` has caught up with `blockText` (distance=0),\n          // and if blockText is exhausted, break to get another block node,\n          // otherwise advance blockText forward by the new `distance`.\n          if (distance === 0) {\n            if (blockText === '') break;\n            distance = calcDistance(blockText, unit, reverse); // Split the string at the previously found distance and use the\n            // remaining string for the next iteration.\n\n            blockText = splitByCharacterDistance(blockText, distance, reverse)[1];\n          } // Advance `leafText` by the current `distance`.\n\n\n          leafTextOffset = reverse ? leafTextOffset - distance : leafTextOffset + distance;\n          leafTextRemaining = leafTextRemaining - distance; // If `leafText` is exhausted, break to get a new leaf node\n          // and set distance to the overflow amount, so we'll (maybe)\n          // catch up to blockText in the next leaf text node.\n\n          if (leafTextRemaining < 0) {\n            distance = -leafTextRemaining;\n            break;\n          } // Successfully walked `distance` offsets through `leafText`\n          // to catch up with `blockText`, so we can reset `distance`\n          // and yield this position in this node.\n\n\n          distance = 0;\n          yield {\n            path,\n            offset: leafTextOffset\n          };\n        }\n      }\n    } // Proof that upon completion, we've exahusted both leaf and block text:\n    //   console.assert(leafTextRemaining <= 0, \"leafText wasn't exhausted\")\n    //   console.assert(blockText === '', \"blockText wasn't exhausted\")\n    // Helper:\n    // Return the distance in offsets for a step of size `unit` on given string.\n\n\n    function calcDistance(text, unit, reverse) {\n      if (unit === 'character') {\n        return getCharacterDistance(text, reverse);\n      } else if (unit === 'word') {\n        return getWordDistance(text, reverse);\n      } else if (unit === 'line' || unit === 'block') {\n        return text.length;\n      }\n\n      return 1;\n    }\n  },\n\n  /**\r\n   * Get the matching node in the branch of the document before a location.\r\n   */\n  previous(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var {\n      mode = 'lowest',\n      voids = false\n    } = options;\n    var {\n      match,\n      at = editor.selection\n    } = options;\n\n    if (!at) {\n      return;\n    }\n\n    var pointBeforeLocation = Editor.before(editor, at, {\n      voids\n    });\n\n    if (!pointBeforeLocation) {\n      return;\n    }\n\n    var [, to] = Editor.first(editor, []); // The search location is from the start of the document to the path of\n    // the point before the location passed in\n\n    var span = [pointBeforeLocation.path, to];\n\n    if (Path.isPath(at) && at.length === 0) {\n      throw new Error(\"Cannot get the previous node from the root node!\");\n    }\n\n    if (match == null) {\n      if (Path.isPath(at)) {\n        var [parent] = Editor.parent(editor, at);\n\n        match = n => parent.children.includes(n);\n      } else {\n        match = () => true;\n      }\n    }\n\n    var [previous] = Editor.nodes(editor, {\n      reverse: true,\n      at: span,\n      match,\n      mode,\n      voids\n    });\n    return previous;\n  },\n\n  /**\r\n   * Get a range of a location.\r\n   */\n  range(editor, at, to) {\n    if (Range.isRange(at) && !to) {\n      return at;\n    }\n\n    var start = Editor.start(editor, at);\n    var end = Editor.end(editor, to || at);\n    return {\n      anchor: start,\n      focus: end\n    };\n  },\n\n  /**\r\n   * Create a mutable ref for a `Range` object, which will stay in sync as new\r\n   * operations are applied to the editor.\r\n   */\n  rangeRef(editor, range) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var {\n      affinity = 'forward'\n    } = options;\n    var ref = {\n      current: range,\n      affinity,\n\n      unref() {\n        var {\n          current\n        } = ref;\n        var rangeRefs = Editor.rangeRefs(editor);\n        rangeRefs.delete(ref);\n        ref.current = null;\n        return current;\n      }\n\n    };\n    var refs = Editor.rangeRefs(editor);\n    refs.add(ref);\n    return ref;\n  },\n\n  /**\r\n   * Get the set of currently tracked range refs of the editor.\r\n   */\n  rangeRefs(editor) {\n    var refs = RANGE_REFS.get(editor);\n\n    if (!refs) {\n      refs = new Set();\n      RANGE_REFS.set(editor, refs);\n    }\n\n    return refs;\n  },\n\n  /**\r\n   * Remove a custom property from all of the leaf text nodes in the current\r\n   * selection.\r\n   *\r\n   * If the selection is currently collapsed, the removal will be stored on\r\n   * `editor.marks` and applied to the text inserted next.\r\n   */\n  removeMark(editor, key) {\n    editor.removeMark(key);\n  },\n\n  /**\r\n   * Manually set if the editor should currently be normalizing.\r\n   *\r\n   * Note: Using this incorrectly can leave the editor in an invalid state.\r\n   *\r\n   */\n  setNormalizing(editor, isNormalizing) {\n    NORMALIZING.set(editor, isNormalizing);\n  },\n\n  /**\r\n   * Get the start point of a location.\r\n   */\n  start(editor, at) {\n    return Editor.point(editor, at, {\n      edge: 'start'\n    });\n  },\n\n  /**\r\n   * Get the text string content of a location.\r\n   *\r\n   * Note: by default the text of void nodes is considered to be an empty\r\n   * string, regardless of content, unless you pass in true for the voids option\r\n   */\n  string(editor, at) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var {\n      voids = false\n    } = options;\n    var range = Editor.range(editor, at);\n    var [start, end] = Range.edges(range);\n    var text = '';\n\n    for (var [node, path] of Editor.nodes(editor, {\n      at: range,\n      match: Text.isText,\n      voids\n    })) {\n      var t = node.text;\n\n      if (Path.equals(path, end.path)) {\n        t = t.slice(0, end.offset);\n      }\n\n      if (Path.equals(path, start.path)) {\n        t = t.slice(start.offset);\n      }\n\n      text += t;\n    }\n\n    return text;\n  },\n\n  /**\r\n   * Convert a range into a non-hanging one.\r\n   */\n  unhangRange(editor, range) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var {\n      voids = false\n    } = options;\n    var [start, end] = Range.edges(range); // PERF: exit early if we can guarantee that the range isn't hanging.\n\n    if (start.offset !== 0 || end.offset !== 0 || Range.isCollapsed(range)) {\n      return range;\n    }\n\n    var endBlock = Editor.above(editor, {\n      at: end,\n      match: n => Editor.isBlock(editor, n)\n    });\n    var blockPath = endBlock ? endBlock[1] : [];\n    var first = Editor.start(editor, start);\n    var before = {\n      anchor: first,\n      focus: end\n    };\n    var skip = true;\n\n    for (var [node, path] of Editor.nodes(editor, {\n      at: before,\n      match: Text.isText,\n      reverse: true,\n      voids\n    })) {\n      if (skip) {\n        skip = false;\n        continue;\n      }\n\n      if (node.text !== '' || Path.isBefore(path, blockPath)) {\n        end = {\n          path,\n          offset: node.text.length\n        };\n        break;\n      }\n    }\n\n    return {\n      anchor: start,\n      focus: end\n    };\n  },\n\n  /**\r\n   * Match a void node in the current branch of the editor.\r\n   */\n  void(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    return Editor.above(editor, _objectSpread$8(_objectSpread$8({}, options), {}, {\n      match: n => Editor.isVoid(editor, n)\n    }));\n  },\n\n  /**\r\n   * Call a function, deferring normalization until after it completes.\r\n   */\n  withoutNormalizing(editor, fn) {\n    var value = Editor.isNormalizing(editor);\n    Editor.setNormalizing(editor, false);\n\n    try {\n      fn();\n    } finally {\n      Editor.setNormalizing(editor, value);\n    }\n\n    Editor.normalize(editor);\n  }\n\n};\n\nvar Span = {\n  /**\r\n   * Check if a value implements the `Span` interface.\r\n   */\n  isSpan(value) {\n    return Array.isArray(value) && value.length === 2 && value.every(Path.isPath);\n  }\n\n};\n\nvar _excluded$3 = [\"children\"],\n    _excluded2$2 = [\"text\"];\nvar IS_NODE_LIST_CACHE = new WeakMap(); // eslint-disable-next-line no-redeclare\n\nvar Node = {\n  /**\r\n   * Get the node at a specific path, asserting that it's an ancestor node.\r\n   */\n  ancestor(root, path) {\n    var node = Node.get(root, path);\n\n    if (Text.isText(node)) {\n      throw new Error(\"Cannot get the ancestor node at path [\".concat(path, \"] because it refers to a text node instead: \").concat(Scrubber.stringify(node)));\n    }\n\n    return node;\n  },\n\n  /**\r\n   * Return a generator of all the ancestor nodes above a specific path.\r\n   *\r\n   * By default the order is top-down, from highest to lowest ancestor in\r\n   * the tree, but you can pass the `reverse: true` option to go bottom-up.\r\n   */\n  *ancestors(root, path) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n\n    for (var p of Path.ancestors(path, options)) {\n      var n = Node.ancestor(root, p);\n      var entry = [n, p];\n      yield entry;\n    }\n  },\n\n  /**\r\n   * Get the child of a node at a specific index.\r\n   */\n  child(root, index) {\n    if (Text.isText(root)) {\n      throw new Error(\"Cannot get the child of a text node: \".concat(Scrubber.stringify(root)));\n    }\n\n    var c = root.children[index];\n\n    if (c == null) {\n      throw new Error(\"Cannot get child at index `\".concat(index, \"` in node: \").concat(Scrubber.stringify(root)));\n    }\n\n    return c;\n  },\n\n  /**\r\n   * Iterate over the children of a node at a specific path.\r\n   */\n  *children(root, path) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var {\n      reverse = false\n    } = options;\n    var ancestor = Node.ancestor(root, path);\n    var {\n      children\n    } = ancestor;\n    var index = reverse ? children.length - 1 : 0;\n\n    while (reverse ? index >= 0 : index < children.length) {\n      var child = Node.child(ancestor, index);\n      var childPath = path.concat(index);\n      yield [child, childPath];\n      index = reverse ? index - 1 : index + 1;\n    }\n  },\n\n  /**\r\n   * Get an entry for the common ancesetor node of two paths.\r\n   */\n  common(root, path, another) {\n    var p = Path.common(path, another);\n    var n = Node.get(root, p);\n    return [n, p];\n  },\n\n  /**\r\n   * Get the node at a specific path, asserting that it's a descendant node.\r\n   */\n  descendant(root, path) {\n    var node = Node.get(root, path);\n\n    if (Editor.isEditor(node)) {\n      throw new Error(\"Cannot get the descendant node at path [\".concat(path, \"] because it refers to the root editor node instead: \").concat(Scrubber.stringify(node)));\n    }\n\n    return node;\n  },\n\n  /**\r\n   * Return a generator of all the descendant node entries inside a root node.\r\n   */\n  *descendants(root) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    for (var [node, path] of Node.nodes(root, options)) {\n      if (path.length !== 0) {\n        // NOTE: we have to coerce here because checking the path's length does\n        // guarantee that `node` is not a `Editor`, but TypeScript doesn't know.\n        yield [node, path];\n      }\n    }\n  },\n\n  /**\r\n   * Return a generator of all the element nodes inside a root node. Each iteration\r\n   * will return an `ElementEntry` tuple consisting of `[Element, Path]`. If the\r\n   * root node is an element it will be included in the iteration as well.\r\n   */\n  *elements(root) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    for (var [node, path] of Node.nodes(root, options)) {\n      if (Element.isElement(node)) {\n        yield [node, path];\n      }\n    }\n  },\n\n  /**\r\n   * Extract props from a Node.\r\n   */\n  extractProps(node) {\n    if (Element.isAncestor(node)) {\n      var properties = _objectWithoutProperties$1(node, _excluded$3);\n\n      return properties;\n    } else {\n      var properties = _objectWithoutProperties$1(node, _excluded2$2);\n\n      return properties;\n    }\n  },\n\n  /**\r\n   * Get the first node entry in a root node from a path.\r\n   */\n  first(root, path) {\n    var p = path.slice();\n    var n = Node.get(root, p);\n\n    while (n) {\n      if (Text.isText(n) || n.children.length === 0) {\n        break;\n      } else {\n        n = n.children[0];\n        p.push(0);\n      }\n    }\n\n    return [n, p];\n  },\n\n  /**\r\n   * Get the sliced fragment represented by a range inside a root node.\r\n   */\n  fragment(root, range) {\n    if (Text.isText(root)) {\n      throw new Error(\"Cannot get a fragment starting from a root text node: \".concat(Scrubber.stringify(root)));\n    }\n\n    var newRoot = fn({\n      children: root.children\n    }, r => {\n      var [start, end] = Range.edges(range);\n      var nodeEntries = Node.nodes(r, {\n        reverse: true,\n        pass: _ref => {\n          var [, path] = _ref;\n          return !Range.includes(range, path);\n        }\n      });\n\n      for (var [, path] of nodeEntries) {\n        if (!Range.includes(range, path)) {\n          var parent = Node.parent(r, path);\n          var index = path[path.length - 1];\n          parent.children.splice(index, 1);\n        }\n\n        if (Path.equals(path, end.path)) {\n          var leaf = Node.leaf(r, path);\n          leaf.text = leaf.text.slice(0, end.offset);\n        }\n\n        if (Path.equals(path, start.path)) {\n          var _leaf = Node.leaf(r, path);\n\n          _leaf.text = _leaf.text.slice(start.offset);\n        }\n      }\n\n      if (Editor.isEditor(r)) {\n        r.selection = null;\n      }\n    });\n    return newRoot.children;\n  },\n\n  /**\r\n   * Get the descendant node referred to by a specific path. If the path is an\r\n   * empty array, it refers to the root node itself.\r\n   */\n  get(root, path) {\n    var node = root;\n\n    for (var i = 0; i < path.length; i++) {\n      var p = path[i];\n\n      if (Text.isText(node) || !node.children[p]) {\n        throw new Error(\"Cannot find a descendant at path [\".concat(path, \"] in node: \").concat(Scrubber.stringify(root)));\n      }\n\n      node = node.children[p];\n    }\n\n    return node;\n  },\n\n  /**\r\n   * Check if a descendant node exists at a specific path.\r\n   */\n  has(root, path) {\n    var node = root;\n\n    for (var i = 0; i < path.length; i++) {\n      var p = path[i];\n\n      if (Text.isText(node) || !node.children[p]) {\n        return false;\n      }\n\n      node = node.children[p];\n    }\n\n    return true;\n  },\n\n  /**\r\n   * Check if a value implements the `Node` interface.\r\n   */\n  isNode(value) {\n    return Text.isText(value) || Element.isElement(value) || Editor.isEditor(value);\n  },\n\n  /**\r\n   * Check if a value is a list of `Node` objects.\r\n   */\n  isNodeList(value) {\n    if (!Array.isArray(value)) {\n      return false;\n    }\n\n    var cachedResult = IS_NODE_LIST_CACHE.get(value);\n\n    if (cachedResult !== undefined) {\n      return cachedResult;\n    }\n\n    var isNodeList = value.every(val => Node.isNode(val));\n    IS_NODE_LIST_CACHE.set(value, isNodeList);\n    return isNodeList;\n  },\n\n  /**\r\n   * Get the last node entry in a root node from a path.\r\n   */\n  last(root, path) {\n    var p = path.slice();\n    var n = Node.get(root, p);\n\n    while (n) {\n      if (Text.isText(n) || n.children.length === 0) {\n        break;\n      } else {\n        var i = n.children.length - 1;\n        n = n.children[i];\n        p.push(i);\n      }\n    }\n\n    return [n, p];\n  },\n\n  /**\r\n   * Get the node at a specific path, ensuring it's a leaf text node.\r\n   */\n  leaf(root, path) {\n    var node = Node.get(root, path);\n\n    if (!Text.isText(node)) {\n      throw new Error(\"Cannot get the leaf node at path [\".concat(path, \"] because it refers to a non-leaf node: \").concat(Scrubber.stringify(node)));\n    }\n\n    return node;\n  },\n\n  /**\r\n   * Return a generator of the in a branch of the tree, from a specific path.\r\n   *\r\n   * By default the order is top-down, from highest to lowest node in the tree,\r\n   * but you can pass the `reverse: true` option to go bottom-up.\r\n   */\n  *levels(root, path) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n\n    for (var p of Path.levels(path, options)) {\n      var n = Node.get(root, p);\n      yield [n, p];\n    }\n  },\n\n  /**\r\n   * Check if a node matches a set of props.\r\n   */\n  matches(node, props) {\n    return Element.isElement(node) && Element.isElementProps(props) && Element.matches(node, props) || Text.isText(node) && Text.isTextProps(props) && Text.matches(node, props);\n  },\n\n  /**\r\n   * Return a generator of all the node entries of a root node. Each entry is\r\n   * returned as a `[Node, Path]` tuple, with the path referring to the node's\r\n   * position inside the root node.\r\n   */\n  *nodes(root) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var {\n      pass,\n      reverse = false\n    } = options;\n    var {\n      from = [],\n      to\n    } = options;\n    var visited = new Set();\n    var p = [];\n    var n = root;\n\n    while (true) {\n      if (to && (reverse ? Path.isBefore(p, to) : Path.isAfter(p, to))) {\n        break;\n      }\n\n      if (!visited.has(n)) {\n        yield [n, p];\n      } // If we're allowed to go downward and we haven't descended yet, do.\n\n\n      if (!visited.has(n) && !Text.isText(n) && n.children.length !== 0 && (pass == null || pass([n, p]) === false)) {\n        visited.add(n);\n        var nextIndex = reverse ? n.children.length - 1 : 0;\n\n        if (Path.isAncestor(p, from)) {\n          nextIndex = from[p.length];\n        }\n\n        p = p.concat(nextIndex);\n        n = Node.get(root, p);\n        continue;\n      } // If we're at the root and we can't go down, we're done.\n\n\n      if (p.length === 0) {\n        break;\n      } // If we're going forward...\n\n\n      if (!reverse) {\n        var newPath = Path.next(p);\n\n        if (Node.has(root, newPath)) {\n          p = newPath;\n          n = Node.get(root, p);\n          continue;\n        }\n      } // If we're going backward...\n\n\n      if (reverse && p[p.length - 1] !== 0) {\n        var _newPath = Path.previous(p);\n\n        p = _newPath;\n        n = Node.get(root, p);\n        continue;\n      } // Otherwise we're going upward...\n\n\n      p = Path.parent(p);\n      n = Node.get(root, p);\n      visited.add(n);\n    }\n  },\n\n  /**\r\n   * Get the parent of a node at a specific path.\r\n   */\n  parent(root, path) {\n    var parentPath = Path.parent(path);\n    var p = Node.get(root, parentPath);\n\n    if (Text.isText(p)) {\n      throw new Error(\"Cannot get the parent of path [\".concat(path, \"] because it does not exist in the root.\"));\n    }\n\n    return p;\n  },\n\n  /**\r\n   * Get the concatenated text string of a node's content.\r\n   *\r\n   * Note that this will not include spaces or line breaks between block nodes.\r\n   * It is not a user-facing string, but a string for performing offset-related\r\n   * computations for a node.\r\n   */\n  string(node) {\n    if (Text.isText(node)) {\n      return node.text;\n    } else {\n      return node.children.map(Node.string).join('');\n    }\n  },\n\n  /**\r\n   * Return a generator of all leaf text nodes in a root node.\r\n   */\n  *texts(root) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    for (var [node, path] of Node.nodes(root, options)) {\n      if (Text.isText(node)) {\n        yield [node, path];\n      }\n    }\n  }\n\n};\n\nfunction ownKeys$7(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread$7(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$7(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$7(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nvar Operation = {\n  /**\r\n   * Check of a value is a `NodeOperation` object.\r\n   */\n  isNodeOperation(value) {\n    return Operation.isOperation(value) && value.type.endsWith('_node');\n  },\n\n  /**\r\n   * Check of a value is an `Operation` object.\r\n   */\n  isOperation(value) {\n    if (!isPlainObject(value)) {\n      return false;\n    }\n\n    switch (value.type) {\n      case 'insert_node':\n        return Path.isPath(value.path) && Node.isNode(value.node);\n\n      case 'insert_text':\n        return typeof value.offset === 'number' && typeof value.text === 'string' && Path.isPath(value.path);\n\n      case 'merge_node':\n        return typeof value.position === 'number' && Path.isPath(value.path) && isPlainObject(value.properties);\n\n      case 'move_node':\n        return Path.isPath(value.path) && Path.isPath(value.newPath);\n\n      case 'remove_node':\n        return Path.isPath(value.path) && Node.isNode(value.node);\n\n      case 'remove_text':\n        return typeof value.offset === 'number' && typeof value.text === 'string' && Path.isPath(value.path);\n\n      case 'set_node':\n        return Path.isPath(value.path) && isPlainObject(value.properties) && isPlainObject(value.newProperties);\n\n      case 'set_selection':\n        return value.properties === null && Range.isRange(value.newProperties) || value.newProperties === null && Range.isRange(value.properties) || isPlainObject(value.properties) && isPlainObject(value.newProperties);\n\n      case 'split_node':\n        return Path.isPath(value.path) && typeof value.position === 'number' && isPlainObject(value.properties);\n\n      default:\n        return false;\n    }\n  },\n\n  /**\r\n   * Check if a value is a list of `Operation` objects.\r\n   */\n  isOperationList(value) {\n    return Array.isArray(value) && value.every(val => Operation.isOperation(val));\n  },\n\n  /**\r\n   * Check of a value is a `SelectionOperation` object.\r\n   */\n  isSelectionOperation(value) {\n    return Operation.isOperation(value) && value.type.endsWith('_selection');\n  },\n\n  /**\r\n   * Check of a value is a `TextOperation` object.\r\n   */\n  isTextOperation(value) {\n    return Operation.isOperation(value) && value.type.endsWith('_text');\n  },\n\n  /**\r\n   * Invert an operation, returning a new operation that will exactly undo the\r\n   * original when applied.\r\n   */\n  inverse(op) {\n    switch (op.type) {\n      case 'insert_node':\n        {\n          return _objectSpread$7(_objectSpread$7({}, op), {}, {\n            type: 'remove_node'\n          });\n        }\n\n      case 'insert_text':\n        {\n          return _objectSpread$7(_objectSpread$7({}, op), {}, {\n            type: 'remove_text'\n          });\n        }\n\n      case 'merge_node':\n        {\n          return _objectSpread$7(_objectSpread$7({}, op), {}, {\n            type: 'split_node',\n            path: Path.previous(op.path)\n          });\n        }\n\n      case 'move_node':\n        {\n          var {\n            newPath,\n            path\n          } = op; // PERF: in this case the move operation is a no-op anyways.\n\n          if (Path.equals(newPath, path)) {\n            return op;\n          } // If the move happens completely within a single parent the path and\n          // newPath are stable with respect to each other.\n\n\n          if (Path.isSibling(path, newPath)) {\n            return _objectSpread$7(_objectSpread$7({}, op), {}, {\n              path: newPath,\n              newPath: path\n            });\n          } // If the move does not happen within a single parent it is possible\n          // for the move to impact the true path to the location where the node\n          // was removed from and where it was inserted. We have to adjust for this\n          // and find the original path. We can accomplish this (only in non-sibling)\n          // moves by looking at the impact of the move operation on the node\n          // after the original move path.\n\n\n          var inversePath = Path.transform(path, op);\n          var inverseNewPath = Path.transform(Path.next(path), op);\n          return _objectSpread$7(_objectSpread$7({}, op), {}, {\n            path: inversePath,\n            newPath: inverseNewPath\n          });\n        }\n\n      case 'remove_node':\n        {\n          return _objectSpread$7(_objectSpread$7({}, op), {}, {\n            type: 'insert_node'\n          });\n        }\n\n      case 'remove_text':\n        {\n          return _objectSpread$7(_objectSpread$7({}, op), {}, {\n            type: 'insert_text'\n          });\n        }\n\n      case 'set_node':\n        {\n          var {\n            properties,\n            newProperties\n          } = op;\n          return _objectSpread$7(_objectSpread$7({}, op), {}, {\n            properties: newProperties,\n            newProperties: properties\n          });\n        }\n\n      case 'set_selection':\n        {\n          var {\n            properties: _properties,\n            newProperties: _newProperties\n          } = op;\n\n          if (_properties == null) {\n            return _objectSpread$7(_objectSpread$7({}, op), {}, {\n              properties: _newProperties,\n              newProperties: null\n            });\n          } else if (_newProperties == null) {\n            return _objectSpread$7(_objectSpread$7({}, op), {}, {\n              properties: null,\n              newProperties: _properties\n            });\n          } else {\n            return _objectSpread$7(_objectSpread$7({}, op), {}, {\n              properties: _newProperties,\n              newProperties: _properties\n            });\n          }\n        }\n\n      case 'split_node':\n        {\n          return _objectSpread$7(_objectSpread$7({}, op), {}, {\n            type: 'merge_node',\n            path: Path.next(op.path)\n          });\n        }\n    }\n  }\n\n};\n\n// eslint-disable-next-line no-redeclare\nvar Path = {\n  /**\r\n   * Get a list of ancestor paths for a given path.\r\n   *\r\n   * The paths are sorted from shallowest to deepest ancestor. However, if the\r\n   * `reverse: true` option is passed, they are reversed.\r\n   */\n  ancestors(path) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var {\n      reverse = false\n    } = options;\n    var paths = Path.levels(path, options);\n\n    if (reverse) {\n      paths = paths.slice(1);\n    } else {\n      paths = paths.slice(0, -1);\n    }\n\n    return paths;\n  },\n\n  /**\r\n   * Get the common ancestor path of two paths.\r\n   */\n  common(path, another) {\n    var common = [];\n\n    for (var i = 0; i < path.length && i < another.length; i++) {\n      var av = path[i];\n      var bv = another[i];\n\n      if (av !== bv) {\n        break;\n      }\n\n      common.push(av);\n    }\n\n    return common;\n  },\n\n  /**\r\n   * Compare a path to another, returning an integer indicating whether the path\r\n   * was before, at, or after the other.\r\n   *\r\n   * Note: Two paths of unequal length can still receive a `0` result if one is\r\n   * directly above or below the other. If you want exact matching, use\r\n   * [[Path.equals]] instead.\r\n   */\n  compare(path, another) {\n    var min = Math.min(path.length, another.length);\n\n    for (var i = 0; i < min; i++) {\n      if (path[i] < another[i]) return -1;\n      if (path[i] > another[i]) return 1;\n    }\n\n    return 0;\n  },\n\n  /**\r\n   * Check if a path ends after one of the indexes in another.\r\n   */\n  endsAfter(path, another) {\n    var i = path.length - 1;\n    var as = path.slice(0, i);\n    var bs = another.slice(0, i);\n    var av = path[i];\n    var bv = another[i];\n    return Path.equals(as, bs) && av > bv;\n  },\n\n  /**\r\n   * Check if a path ends at one of the indexes in another.\r\n   */\n  endsAt(path, another) {\n    var i = path.length;\n    var as = path.slice(0, i);\n    var bs = another.slice(0, i);\n    return Path.equals(as, bs);\n  },\n\n  /**\r\n   * Check if a path ends before one of the indexes in another.\r\n   */\n  endsBefore(path, another) {\n    var i = path.length - 1;\n    var as = path.slice(0, i);\n    var bs = another.slice(0, i);\n    var av = path[i];\n    var bv = another[i];\n    return Path.equals(as, bs) && av < bv;\n  },\n\n  /**\r\n   * Check if a path is exactly equal to another.\r\n   */\n  equals(path, another) {\n    return path.length === another.length && path.every((n, i) => n === another[i]);\n  },\n\n  /**\r\n   * Check if the path of previous sibling node exists\r\n   */\n  hasPrevious(path) {\n    return path[path.length - 1] > 0;\n  },\n\n  /**\r\n   * Check if a path is after another.\r\n   */\n  isAfter(path, another) {\n    return Path.compare(path, another) === 1;\n  },\n\n  /**\r\n   * Check if a path is an ancestor of another.\r\n   */\n  isAncestor(path, another) {\n    return path.length < another.length && Path.compare(path, another) === 0;\n  },\n\n  /**\r\n   * Check if a path is before another.\r\n   */\n  isBefore(path, another) {\n    return Path.compare(path, another) === -1;\n  },\n\n  /**\r\n   * Check if a path is a child of another.\r\n   */\n  isChild(path, another) {\n    return path.length === another.length + 1 && Path.compare(path, another) === 0;\n  },\n\n  /**\r\n   * Check if a path is equal to or an ancestor of another.\r\n   */\n  isCommon(path, another) {\n    return path.length <= another.length && Path.compare(path, another) === 0;\n  },\n\n  /**\r\n   * Check if a path is a descendant of another.\r\n   */\n  isDescendant(path, another) {\n    return path.length > another.length && Path.compare(path, another) === 0;\n  },\n\n  /**\r\n   * Check if a path is the parent of another.\r\n   */\n  isParent(path, another) {\n    return path.length + 1 === another.length && Path.compare(path, another) === 0;\n  },\n\n  /**\r\n   * Check is a value implements the `Path` interface.\r\n   */\n  isPath(value) {\n    return Array.isArray(value) && (value.length === 0 || typeof value[0] === 'number');\n  },\n\n  /**\r\n   * Check if a path is a sibling of another.\r\n   */\n  isSibling(path, another) {\n    if (path.length !== another.length) {\n      return false;\n    }\n\n    var as = path.slice(0, -1);\n    var bs = another.slice(0, -1);\n    var al = path[path.length - 1];\n    var bl = another[another.length - 1];\n    return al !== bl && Path.equals(as, bs);\n  },\n\n  /**\r\n   * Get a list of paths at every level down to a path. Note: this is the same\r\n   * as `Path.ancestors`, but including the path itself.\r\n   *\r\n   * The paths are sorted from shallowest to deepest. However, if the `reverse:\r\n   * true` option is passed, they are reversed.\r\n   */\n  levels(path) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var {\n      reverse = false\n    } = options;\n    var list = [];\n\n    for (var i = 0; i <= path.length; i++) {\n      list.push(path.slice(0, i));\n    }\n\n    if (reverse) {\n      list.reverse();\n    }\n\n    return list;\n  },\n\n  /**\r\n   * Given a path, get the path to the next sibling node.\r\n   */\n  next(path) {\n    if (path.length === 0) {\n      throw new Error(\"Cannot get the next path of a root path [\".concat(path, \"], because it has no next index.\"));\n    }\n\n    var last = path[path.length - 1];\n    return path.slice(0, -1).concat(last + 1);\n  },\n\n  /**\r\n   * Returns whether this operation can affect paths or not. Used as an\r\n   * optimization when updating dirty paths during normalization\r\n   *\r\n   * NOTE: This *must* be kept in sync with the implementation of 'transform'\r\n   * below\r\n   */\n  operationCanTransformPath(operation) {\n    switch (operation.type) {\n      case 'insert_node':\n      case 'remove_node':\n      case 'merge_node':\n      case 'split_node':\n      case 'move_node':\n        return true;\n\n      default:\n        return false;\n    }\n  },\n\n  /**\r\n   * Given a path, return a new path referring to the parent node above it.\r\n   */\n  parent(path) {\n    if (path.length === 0) {\n      throw new Error(\"Cannot get the parent path of the root path [\".concat(path, \"].\"));\n    }\n\n    return path.slice(0, -1);\n  },\n\n  /**\r\n   * Given a path, get the path to the previous sibling node.\r\n   */\n  previous(path) {\n    if (path.length === 0) {\n      throw new Error(\"Cannot get the previous path of a root path [\".concat(path, \"], because it has no previous index.\"));\n    }\n\n    var last = path[path.length - 1];\n\n    if (last <= 0) {\n      throw new Error(\"Cannot get the previous path of a first child path [\".concat(path, \"] because it would result in a negative index.\"));\n    }\n\n    return path.slice(0, -1).concat(last - 1);\n  },\n\n  /**\r\n   * Get a path relative to an ancestor.\r\n   */\n  relative(path, ancestor) {\n    if (!Path.isAncestor(ancestor, path) && !Path.equals(path, ancestor)) {\n      throw new Error(\"Cannot get the relative path of [\".concat(path, \"] inside ancestor [\").concat(ancestor, \"], because it is not above or equal to the path.\"));\n    }\n\n    return path.slice(ancestor.length);\n  },\n\n  /**\r\n   * Transform a path by an operation.\r\n   */\n  transform(path, operation) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    if (!path) return null; // PERF: use destructing instead of immer\n\n    var p = [...path];\n    var {\n      affinity = 'forward'\n    } = options; // PERF: Exit early if the operation is guaranteed not to have an effect.\n\n    if (path.length === 0) {\n      return p;\n    }\n\n    switch (operation.type) {\n      case 'insert_node':\n        {\n          var {\n            path: op\n          } = operation;\n\n          if (Path.equals(op, p) || Path.endsBefore(op, p) || Path.isAncestor(op, p)) {\n            p[op.length - 1] += 1;\n          }\n\n          break;\n        }\n\n      case 'remove_node':\n        {\n          var {\n            path: _op\n          } = operation;\n\n          if (Path.equals(_op, p) || Path.isAncestor(_op, p)) {\n            return null;\n          } else if (Path.endsBefore(_op, p)) {\n            p[_op.length - 1] -= 1;\n          }\n\n          break;\n        }\n\n      case 'merge_node':\n        {\n          var {\n            path: _op2,\n            position\n          } = operation;\n\n          if (Path.equals(_op2, p) || Path.endsBefore(_op2, p)) {\n            p[_op2.length - 1] -= 1;\n          } else if (Path.isAncestor(_op2, p)) {\n            p[_op2.length - 1] -= 1;\n            p[_op2.length] += position;\n          }\n\n          break;\n        }\n\n      case 'split_node':\n        {\n          var {\n            path: _op3,\n            position: _position\n          } = operation;\n\n          if (Path.equals(_op3, p)) {\n            if (affinity === 'forward') {\n              p[p.length - 1] += 1;\n            } else if (affinity === 'backward') ; else {\n              return null;\n            }\n          } else if (Path.endsBefore(_op3, p)) {\n            p[_op3.length - 1] += 1;\n          } else if (Path.isAncestor(_op3, p) && path[_op3.length] >= _position) {\n            p[_op3.length - 1] += 1;\n            p[_op3.length] -= _position;\n          }\n\n          break;\n        }\n\n      case 'move_node':\n        {\n          var {\n            path: _op4,\n            newPath: onp\n          } = operation; // If the old and new path are the same, it's a no-op.\n\n          if (Path.equals(_op4, onp)) {\n            return p;\n          }\n\n          if (Path.isAncestor(_op4, p) || Path.equals(_op4, p)) {\n            var copy = onp.slice();\n\n            if (Path.endsBefore(_op4, onp) && _op4.length < onp.length) {\n              copy[_op4.length - 1] -= 1;\n            }\n\n            return copy.concat(p.slice(_op4.length));\n          } else if (Path.isSibling(_op4, onp) && (Path.isAncestor(onp, p) || Path.equals(onp, p))) {\n            if (Path.endsBefore(_op4, p)) {\n              p[_op4.length - 1] -= 1;\n            } else {\n              p[_op4.length - 1] += 1;\n            }\n          } else if (Path.endsBefore(onp, p) || Path.equals(onp, p) || Path.isAncestor(onp, p)) {\n            if (Path.endsBefore(_op4, p)) {\n              p[_op4.length - 1] -= 1;\n            }\n\n            p[onp.length - 1] += 1;\n          } else if (Path.endsBefore(_op4, p)) {\n            if (Path.equals(onp, p)) {\n              p[onp.length - 1] += 1;\n            }\n\n            p[_op4.length - 1] -= 1;\n          }\n\n          break;\n        }\n    }\n\n    return p;\n  }\n\n};\n\nfunction ownKeys$6(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread$6(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$6(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$6(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nvar Point = {\n  /**\r\n   * Compare a point to another, returning an integer indicating whether the\r\n   * point was before, at, or after the other.\r\n   */\n  compare(point, another) {\n    var result = Path.compare(point.path, another.path);\n\n    if (result === 0) {\n      if (point.offset < another.offset) return -1;\n      if (point.offset > another.offset) return 1;\n      return 0;\n    }\n\n    return result;\n  },\n\n  /**\r\n   * Check if a point is after another.\r\n   */\n  isAfter(point, another) {\n    return Point.compare(point, another) === 1;\n  },\n\n  /**\r\n   * Check if a point is before another.\r\n   */\n  isBefore(point, another) {\n    return Point.compare(point, another) === -1;\n  },\n\n  /**\r\n   * Check if a point is exactly equal to another.\r\n   */\n  equals(point, another) {\n    // PERF: ensure the offsets are equal first since they are cheaper to check.\n    return point.offset === another.offset && Path.equals(point.path, another.path);\n  },\n\n  /**\r\n   * Check if a value implements the `Point` interface.\r\n   */\n  isPoint(value) {\n    return isPlainObject(value) && typeof value.offset === 'number' && Path.isPath(value.path);\n  },\n\n  /**\r\n   * Transform a point by an operation.\r\n   */\n  transform(point, op) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    return fn(point, p => {\n      if (p === null) {\n        return null;\n      }\n\n      var {\n        affinity = 'forward'\n      } = options;\n      var {\n        path,\n        offset\n      } = p;\n\n      switch (op.type) {\n        case 'insert_node':\n        case 'move_node':\n          {\n            p.path = Path.transform(path, op, options);\n            break;\n          }\n\n        case 'insert_text':\n          {\n            if (Path.equals(op.path, path) && (op.offset < offset || op.offset === offset && affinity === 'forward')) {\n              p.offset += op.text.length;\n            }\n\n            break;\n          }\n\n        case 'merge_node':\n          {\n            if (Path.equals(op.path, path)) {\n              p.offset += op.position;\n            }\n\n            p.path = Path.transform(path, op, options);\n            break;\n          }\n\n        case 'remove_text':\n          {\n            if (Path.equals(op.path, path) && op.offset <= offset) {\n              p.offset -= Math.min(offset - op.offset, op.text.length);\n            }\n\n            break;\n          }\n\n        case 'remove_node':\n          {\n            if (Path.equals(op.path, path) || Path.isAncestor(op.path, path)) {\n              return null;\n            }\n\n            p.path = Path.transform(path, op, options);\n            break;\n          }\n\n        case 'split_node':\n          {\n            if (Path.equals(op.path, path)) {\n              if (op.position === offset && affinity == null) {\n                return null;\n              } else if (op.position < offset || op.position === offset && affinity === 'forward') {\n                p.offset -= op.position;\n                p.path = Path.transform(path, op, _objectSpread$6(_objectSpread$6({}, options), {}, {\n                  affinity: 'forward'\n                }));\n              }\n            } else {\n              p.path = Path.transform(path, op, options);\n            }\n\n            break;\n          }\n      }\n    });\n  }\n\n};\n\nvar _excluded$2 = [\"anchor\", \"focus\"];\n\nfunction ownKeys$5(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread$5(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$5(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$5(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nvar Range = {\n  /**\r\n   * Get the start and end points of a range, in the order in which they appear\r\n   * in the document.\r\n   */\n  edges(range) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var {\n      reverse = false\n    } = options;\n    var {\n      anchor,\n      focus\n    } = range;\n    return Range.isBackward(range) === reverse ? [anchor, focus] : [focus, anchor];\n  },\n\n  /**\r\n   * Get the end point of a range.\r\n   */\n  end(range) {\n    var [, end] = Range.edges(range);\n    return end;\n  },\n\n  /**\r\n   * Check if a range is exactly equal to another.\r\n   */\n  equals(range, another) {\n    return Point.equals(range.anchor, another.anchor) && Point.equals(range.focus, another.focus);\n  },\n\n  /**\r\n   * Check if a range includes a path, a point or part of another range.\r\n   */\n  includes(range, target) {\n    if (Range.isRange(target)) {\n      if (Range.includes(range, target.anchor) || Range.includes(range, target.focus)) {\n        return true;\n      }\n\n      var [rs, re] = Range.edges(range);\n      var [ts, te] = Range.edges(target);\n      return Point.isBefore(rs, ts) && Point.isAfter(re, te);\n    }\n\n    var [start, end] = Range.edges(range);\n    var isAfterStart = false;\n    var isBeforeEnd = false;\n\n    if (Point.isPoint(target)) {\n      isAfterStart = Point.compare(target, start) >= 0;\n      isBeforeEnd = Point.compare(target, end) <= 0;\n    } else {\n      isAfterStart = Path.compare(target, start.path) >= 0;\n      isBeforeEnd = Path.compare(target, end.path) <= 0;\n    }\n\n    return isAfterStart && isBeforeEnd;\n  },\n\n  /**\r\n   * Get the intersection of a range with another.\r\n   */\n  intersection(range, another) {\n    var rest = _objectWithoutProperties$1(range, _excluded$2);\n\n    var [s1, e1] = Range.edges(range);\n    var [s2, e2] = Range.edges(another);\n    var start = Point.isBefore(s1, s2) ? s2 : s1;\n    var end = Point.isBefore(e1, e2) ? e1 : e2;\n\n    if (Point.isBefore(end, start)) {\n      return null;\n    } else {\n      return _objectSpread$5({\n        anchor: start,\n        focus: end\n      }, rest);\n    }\n  },\n\n  /**\r\n   * Check if a range is backward, meaning that its anchor point appears in the\r\n   * document _after_ its focus point.\r\n   */\n  isBackward(range) {\n    var {\n      anchor,\n      focus\n    } = range;\n    return Point.isAfter(anchor, focus);\n  },\n\n  /**\r\n   * Check if a range is collapsed, meaning that both its anchor and focus\r\n   * points refer to the exact same position in the document.\r\n   */\n  isCollapsed(range) {\n    var {\n      anchor,\n      focus\n    } = range;\n    return Point.equals(anchor, focus);\n  },\n\n  /**\r\n   * Check if a range is expanded.\r\n   *\r\n   * This is the opposite of [[Range.isCollapsed]] and is provided for legibility.\r\n   */\n  isExpanded(range) {\n    return !Range.isCollapsed(range);\n  },\n\n  /**\r\n   * Check if a range is forward.\r\n   *\r\n   * This is the opposite of [[Range.isBackward]] and is provided for legibility.\r\n   */\n  isForward(range) {\n    return !Range.isBackward(range);\n  },\n\n  /**\r\n   * Check if a value implements the [[Range]] interface.\r\n   */\n  isRange(value) {\n    return isPlainObject(value) && Point.isPoint(value.anchor) && Point.isPoint(value.focus);\n  },\n\n  /**\r\n   * Iterate through all of the point entries in a range.\r\n   */\n  *points(range) {\n    yield [range.anchor, 'anchor'];\n    yield [range.focus, 'focus'];\n  },\n\n  /**\r\n   * Get the start point of a range.\r\n   */\n  start(range) {\n    var [start] = Range.edges(range);\n    return start;\n  },\n\n  /**\r\n   * Transform a range by an operation.\r\n   */\n  transform(range, op) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    return fn(range, r => {\n      if (r === null) {\n        return null;\n      }\n\n      var {\n        affinity = 'inward'\n      } = options;\n      var affinityAnchor;\n      var affinityFocus;\n\n      if (affinity === 'inward') {\n        // If the range is collapsed, make sure to use the same affinity to\n        // avoid the two points passing each other and expanding in the opposite\n        // direction\n        var isCollapsed = Range.isCollapsed(r);\n\n        if (Range.isForward(r)) {\n          affinityAnchor = 'forward';\n          affinityFocus = isCollapsed ? affinityAnchor : 'backward';\n        } else {\n          affinityAnchor = 'backward';\n          affinityFocus = isCollapsed ? affinityAnchor : 'forward';\n        }\n      } else if (affinity === 'outward') {\n        if (Range.isForward(r)) {\n          affinityAnchor = 'backward';\n          affinityFocus = 'forward';\n        } else {\n          affinityAnchor = 'forward';\n          affinityFocus = 'backward';\n        }\n      } else {\n        affinityAnchor = affinity;\n        affinityFocus = affinity;\n      }\n\n      var anchor = Point.transform(r.anchor, op, {\n        affinity: affinityAnchor\n      });\n      var focus = Point.transform(r.focus, op, {\n        affinity: affinityFocus\n      });\n\n      if (!anchor || !focus) {\n        return null;\n      }\n\n      r.anchor = anchor;\n      r.focus = focus;\n    });\n  }\n\n};\n\nvar _scrubber = undefined;\n/**\r\n * This interface implements a stringify() function, which is used by Slate\r\n * internally when generating exceptions containing end user data. Developers\r\n * using Slate may call Scrubber.setScrubber() to alter the behavior of this\r\n * stringify() function.\r\n *\r\n * For example, to prevent the cleartext logging of 'text' fields within Nodes:\r\n *\r\n *    import { Scrubber } from 'slate';\r\n *    Scrubber.setScrubber((key, val) => {\r\n *      if (key === 'text') return '...scrubbed...'\r\n *      return val\r\n *    });\r\n *\r\n */\n// eslint-disable-next-line no-redeclare\n\nvar Scrubber = {\n  setScrubber(scrubber) {\n    _scrubber = scrubber;\n  },\n\n  stringify(value) {\n    return JSON.stringify(value, _scrubber);\n  }\n\n};\n\n/*\r\n  Custom deep equal comparison for Slate nodes.\r\n\n  We don't need general purpose deep equality;\r\n  Slate only supports plain values, Arrays, and nested objects.\r\n  Complex values nested inside Arrays are not supported.\r\n\n  Slate objects are designed to be serialised, so\r\n  missing keys are deliberately normalised to undefined.\r\n */\n\nvar isDeepEqual = (node, another) => {\n  for (var key in node) {\n    var a = node[key];\n    var b = another[key];\n\n    if (isPlainObject(a) && isPlainObject(b)) {\n      if (!isDeepEqual(a, b)) return false;\n    } else if (Array.isArray(a) && Array.isArray(b)) {\n      if (a.length !== b.length) return false;\n\n      for (var i = 0; i < a.length; i++) {\n        if (a[i] !== b[i]) return false;\n      }\n    } else if (a !== b) {\n      return false;\n    }\n  }\n  /*\r\n    Deep object equality is only necessary in one direction; in the reverse direction\r\n    we are only looking for keys that are missing.\r\n    As above, undefined keys are normalised to missing.\r\n  */\n\n\n  for (var _key in another) {\n    if (node[_key] === undefined && another[_key] !== undefined) {\n      return false;\n    }\n  }\n\n  return true;\n};\n\nvar _excluded$1 = [\"text\"],\n    _excluded2$1 = [\"anchor\", \"focus\"];\n\nfunction ownKeys$4(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread$4(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$4(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$4(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nvar Text = {\n  /**\r\n   * Check if two text nodes are equal.\r\n   *\r\n   * When loose is set, the text is not compared. This is\r\n   * used to check whether sibling text nodes can be merged.\r\n   */\n  equals(text, another) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var {\n      loose = false\n    } = options;\n\n    function omitText(obj) {\n      var rest = _objectWithoutProperties$1(obj, _excluded$1);\n\n      return rest;\n    }\n\n    return isDeepEqual(loose ? omitText(text) : text, loose ? omitText(another) : another);\n  },\n\n  /**\r\n   * Check if a value implements the `Text` interface.\r\n   */\n  isText(value) {\n    return isPlainObject(value) && typeof value.text === 'string';\n  },\n\n  /**\r\n   * Check if a value is a list of `Text` objects.\r\n   */\n  isTextList(value) {\n    return Array.isArray(value) && value.every(val => Text.isText(val));\n  },\n\n  /**\r\n   * Check if some props are a partial of Text.\r\n   */\n  isTextProps(props) {\n    return props.text !== undefined;\n  },\n\n  /**\r\n   * Check if an text matches set of properties.\r\n   *\r\n   * Note: this is for matching custom properties, and it does not ensure that\r\n   * the `text` property are two nodes equal.\r\n   */\n  matches(text, props) {\n    for (var key in props) {\n      if (key === 'text') {\n        continue;\n      }\n\n      if (!text.hasOwnProperty(key) || text[key] !== props[key]) {\n        return false;\n      }\n    }\n\n    return true;\n  },\n\n  /**\r\n   * Get the leaves for a text node given decorations.\r\n   */\n  decorations(node, decorations) {\n    var leaves = [_objectSpread$4({}, node)];\n\n    for (var dec of decorations) {\n      var rest = _objectWithoutProperties$1(dec, _excluded2$1);\n\n      var [start, end] = Range.edges(dec);\n      var next = [];\n      var leafEnd = 0;\n      var decorationStart = start.offset;\n      var decorationEnd = end.offset;\n\n      for (var leaf of leaves) {\n        var {\n          length\n        } = leaf.text;\n        var leafStart = leafEnd;\n        leafEnd += length; // If the range encompasses the entire leaf, add the range.\n\n        if (decorationStart <= leafStart && leafEnd <= decorationEnd) {\n          Object.assign(leaf, rest);\n          next.push(leaf);\n          continue;\n        } // If the range expanded and match the leaf, or starts after, or ends before it, continue.\n\n\n        if (decorationStart !== decorationEnd && (decorationStart === leafEnd || decorationEnd === leafStart) || decorationStart > leafEnd || decorationEnd < leafStart || decorationEnd === leafStart && leafStart !== 0) {\n          next.push(leaf);\n          continue;\n        } // Otherwise we need to split the leaf, at the start, end, or both,\n        // and add the range to the middle intersecting section. Do the end\n        // split first since we don't need to update the offset that way.\n\n\n        var middle = leaf;\n        var before = void 0;\n        var after = void 0;\n\n        if (decorationEnd < leafEnd) {\n          var off = decorationEnd - leafStart;\n          after = _objectSpread$4(_objectSpread$4({}, middle), {}, {\n            text: middle.text.slice(off)\n          });\n          middle = _objectSpread$4(_objectSpread$4({}, middle), {}, {\n            text: middle.text.slice(0, off)\n          });\n        }\n\n        if (decorationStart > leafStart) {\n          var _off = decorationStart - leafStart;\n\n          before = _objectSpread$4(_objectSpread$4({}, middle), {}, {\n            text: middle.text.slice(0, _off)\n          });\n          middle = _objectSpread$4(_objectSpread$4({}, middle), {}, {\n            text: middle.text.slice(_off)\n          });\n        }\n\n        Object.assign(middle, rest);\n\n        if (before) {\n          next.push(before);\n        }\n\n        next.push(middle);\n\n        if (after) {\n          next.push(after);\n        }\n      }\n\n      leaves = next;\n    }\n\n    return leaves;\n  }\n\n};\n\nfunction ownKeys$3(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread$3(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$3(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$3(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nvar applyToDraft = (editor, selection, op) => {\n  switch (op.type) {\n    case 'insert_node':\n      {\n        var {\n          path,\n          node\n        } = op;\n        var parent = Node.parent(editor, path);\n        var index = path[path.length - 1];\n\n        if (index > parent.children.length) {\n          throw new Error(\"Cannot apply an \\\"insert_node\\\" operation at path [\".concat(path, \"] because the destination is past the end of the node.\"));\n        }\n\n        parent.children.splice(index, 0, node);\n\n        if (selection) {\n          for (var [point, key] of Range.points(selection)) {\n            selection[key] = Point.transform(point, op);\n          }\n        }\n\n        break;\n      }\n\n    case 'insert_text':\n      {\n        var {\n          path: _path,\n          offset,\n          text\n        } = op;\n        if (text.length === 0) break;\n\n        var _node = Node.leaf(editor, _path);\n\n        var before = _node.text.slice(0, offset);\n\n        var after = _node.text.slice(offset);\n\n        _node.text = before + text + after;\n\n        if (selection) {\n          for (var [_point, _key] of Range.points(selection)) {\n            selection[_key] = Point.transform(_point, op);\n          }\n        }\n\n        break;\n      }\n\n    case 'merge_node':\n      {\n        var {\n          path: _path2\n        } = op;\n\n        var _node2 = Node.get(editor, _path2);\n\n        var prevPath = Path.previous(_path2);\n        var prev = Node.get(editor, prevPath);\n\n        var _parent = Node.parent(editor, _path2);\n\n        var _index = _path2[_path2.length - 1];\n\n        if (Text.isText(_node2) && Text.isText(prev)) {\n          prev.text += _node2.text;\n        } else if (!Text.isText(_node2) && !Text.isText(prev)) {\n          prev.children.push(..._node2.children);\n        } else {\n          throw new Error(\"Cannot apply a \\\"merge_node\\\" operation at path [\".concat(_path2, \"] to nodes of different interfaces: \").concat(Scrubber.stringify(_node2), \" \").concat(Scrubber.stringify(prev)));\n        }\n\n        _parent.children.splice(_index, 1);\n\n        if (selection) {\n          for (var [_point2, _key2] of Range.points(selection)) {\n            selection[_key2] = Point.transform(_point2, op);\n          }\n        }\n\n        break;\n      }\n\n    case 'move_node':\n      {\n        var {\n          path: _path3,\n          newPath\n        } = op;\n\n        if (Path.isAncestor(_path3, newPath)) {\n          throw new Error(\"Cannot move a path [\".concat(_path3, \"] to new path [\").concat(newPath, \"] because the destination is inside itself.\"));\n        }\n\n        var _node3 = Node.get(editor, _path3);\n\n        var _parent2 = Node.parent(editor, _path3);\n\n        var _index2 = _path3[_path3.length - 1]; // This is tricky, but since the `path` and `newPath` both refer to\n        // the same snapshot in time, there's a mismatch. After either\n        // removing the original position, the second step's path can be out\n        // of date. So instead of using the `op.newPath` directly, we\n        // transform `op.path` to ascertain what the `newPath` would be after\n        // the operation was applied.\n\n        _parent2.children.splice(_index2, 1);\n\n        var truePath = Path.transform(_path3, op);\n        var newParent = Node.get(editor, Path.parent(truePath));\n        var newIndex = truePath[truePath.length - 1];\n        newParent.children.splice(newIndex, 0, _node3);\n\n        if (selection) {\n          for (var [_point3, _key3] of Range.points(selection)) {\n            selection[_key3] = Point.transform(_point3, op);\n          }\n        }\n\n        break;\n      }\n\n    case 'remove_node':\n      {\n        var {\n          path: _path4\n        } = op;\n        var _index3 = _path4[_path4.length - 1];\n\n        var _parent3 = Node.parent(editor, _path4);\n\n        _parent3.children.splice(_index3, 1); // Transform all of the points in the value, but if the point was in the\n        // node that was removed we need to update the range or remove it.\n\n\n        if (selection) {\n          for (var [_point4, _key4] of Range.points(selection)) {\n            var result = Point.transform(_point4, op);\n\n            if (selection != null && result != null) {\n              selection[_key4] = result;\n            } else {\n              var _prev = void 0;\n\n              var next = void 0;\n\n              for (var [n, p] of Node.texts(editor)) {\n                if (Path.compare(p, _path4) === -1) {\n                  _prev = [n, p];\n                } else {\n                  next = [n, p];\n                  break;\n                }\n              }\n\n              var preferNext = false;\n\n              if (_prev && next) {\n                if (Path.equals(next[1], _path4)) {\n                  preferNext = !Path.hasPrevious(next[1]);\n                } else {\n                  preferNext = Path.common(_prev[1], _path4).length < Path.common(next[1], _path4).length;\n                }\n              }\n\n              if (_prev && !preferNext) {\n                _point4.path = _prev[1];\n                _point4.offset = _prev[0].text.length;\n              } else if (next) {\n                _point4.path = next[1];\n                _point4.offset = 0;\n              } else {\n                selection = null;\n              }\n            }\n          }\n        }\n\n        break;\n      }\n\n    case 'remove_text':\n      {\n        var {\n          path: _path5,\n          offset: _offset,\n          text: _text\n        } = op;\n        if (_text.length === 0) break;\n\n        var _node4 = Node.leaf(editor, _path5);\n\n        var _before = _node4.text.slice(0, _offset);\n\n        var _after = _node4.text.slice(_offset + _text.length);\n\n        _node4.text = _before + _after;\n\n        if (selection) {\n          for (var [_point5, _key5] of Range.points(selection)) {\n            selection[_key5] = Point.transform(_point5, op);\n          }\n        }\n\n        break;\n      }\n\n    case 'set_node':\n      {\n        var {\n          path: _path6,\n          properties,\n          newProperties\n        } = op;\n\n        if (_path6.length === 0) {\n          throw new Error(\"Cannot set properties on the root node!\");\n        }\n\n        var _node5 = Node.get(editor, _path6);\n\n        for (var _key6 in newProperties) {\n          if (_key6 === 'children' || _key6 === 'text') {\n            throw new Error(\"Cannot set the \\\"\".concat(_key6, \"\\\" property of nodes!\"));\n          }\n\n          var value = newProperties[_key6];\n\n          if (value == null) {\n            delete _node5[_key6];\n          } else {\n            _node5[_key6] = value;\n          }\n        } // properties that were previously defined, but are now missing, must be deleted\n\n\n        for (var _key7 in properties) {\n          if (!newProperties.hasOwnProperty(_key7)) {\n            delete _node5[_key7];\n          }\n        }\n\n        break;\n      }\n\n    case 'set_selection':\n      {\n        var {\n          newProperties: _newProperties\n        } = op;\n\n        if (_newProperties == null) {\n          selection = _newProperties;\n        } else {\n          if (selection == null) {\n            if (!Range.isRange(_newProperties)) {\n              throw new Error(\"Cannot apply an incomplete \\\"set_selection\\\" operation properties \".concat(Scrubber.stringify(_newProperties), \" when there is no current selection.\"));\n            }\n\n            selection = _objectSpread$3({}, _newProperties);\n          }\n\n          for (var _key8 in _newProperties) {\n            var _value = _newProperties[_key8];\n\n            if (_value == null) {\n              if (_key8 === 'anchor' || _key8 === 'focus') {\n                throw new Error(\"Cannot remove the \\\"\".concat(_key8, \"\\\" selection property\"));\n              }\n\n              delete selection[_key8];\n            } else {\n              selection[_key8] = _value;\n            }\n          }\n        }\n\n        break;\n      }\n\n    case 'split_node':\n      {\n        var {\n          path: _path7,\n          position,\n          properties: _properties\n        } = op;\n\n        if (_path7.length === 0) {\n          throw new Error(\"Cannot apply a \\\"split_node\\\" operation at path [\".concat(_path7, \"] because the root node cannot be split.\"));\n        }\n\n        var _node6 = Node.get(editor, _path7);\n\n        var _parent4 = Node.parent(editor, _path7);\n\n        var _index4 = _path7[_path7.length - 1];\n        var newNode;\n\n        if (Text.isText(_node6)) {\n          var _before2 = _node6.text.slice(0, position);\n\n          var _after2 = _node6.text.slice(position);\n\n          _node6.text = _before2;\n          newNode = _objectSpread$3(_objectSpread$3({}, _properties), {}, {\n            text: _after2\n          });\n        } else {\n          var _before3 = _node6.children.slice(0, position);\n\n          var _after3 = _node6.children.slice(position);\n\n          _node6.children = _before3;\n          newNode = _objectSpread$3(_objectSpread$3({}, _properties), {}, {\n            children: _after3\n          });\n        }\n\n        _parent4.children.splice(_index4 + 1, 0, newNode);\n\n        if (selection) {\n          for (var [_point6, _key9] of Range.points(selection)) {\n            selection[_key9] = Point.transform(_point6, op);\n          }\n        }\n\n        break;\n      }\n  }\n\n  return selection;\n}; // eslint-disable-next-line no-redeclare\n\n\nvar GeneralTransforms = {\n  /**\r\n   * Transform the editor by an operation.\r\n   */\n  transform(editor, op) {\n    editor.children = ln(editor.children);\n    var selection = editor.selection && ln(editor.selection);\n\n    try {\n      selection = applyToDraft(editor, selection, op);\n    } finally {\n      editor.children = dn(editor.children);\n\n      if (selection) {\n        editor.selection = r(selection) ? dn(selection) : selection;\n      } else {\n        editor.selection = null;\n      }\n    }\n  }\n\n};\n\nvar _excluded$5 = [\"text\"],\n    _excluded2 = [\"children\"];\n\nfunction ownKeys$2(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread$2(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$2(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$2(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nvar NodeTransforms = {\n  /**\r\n   * Insert nodes at a specific location in the Editor.\r\n   */\n  insertNodes(editor, nodes) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    Editor.withoutNormalizing(editor, () => {\n      var {\n        hanging = false,\n        voids = false,\n        mode = 'lowest'\n      } = options;\n      var {\n        at,\n        match,\n        select\n      } = options;\n\n      if (Node.isNode(nodes)) {\n        nodes = [nodes];\n      }\n\n      if (nodes.length === 0) {\n        return;\n      }\n\n      var [node] = nodes; // By default, use the selection as the target location. But if there is\n      // no selection, insert at the end of the document since that is such a\n      // common use case when inserting from a non-selected state.\n\n      if (!at) {\n        if (editor.selection) {\n          at = editor.selection;\n        } else if (editor.children.length > 0) {\n          at = Editor.end(editor, []);\n        } else {\n          at = [0];\n        }\n\n        select = true;\n      }\n\n      if (select == null) {\n        select = false;\n      }\n\n      if (Range.isRange(at)) {\n        if (!hanging) {\n          at = Editor.unhangRange(editor, at);\n        }\n\n        if (Range.isCollapsed(at)) {\n          at = at.anchor;\n        } else {\n          var [, end] = Range.edges(at);\n          var pointRef = Editor.pointRef(editor, end);\n          Transforms.delete(editor, {\n            at\n          });\n          at = pointRef.unref();\n        }\n      }\n\n      if (Point.isPoint(at)) {\n        if (match == null) {\n          if (Text.isText(node)) {\n            match = n => Text.isText(n);\n          } else if (editor.isInline(node)) {\n            match = n => Text.isText(n) || Editor.isInline(editor, n);\n          } else {\n            match = n => Editor.isBlock(editor, n);\n          }\n        }\n\n        var [entry] = Editor.nodes(editor, {\n          at: at.path,\n          match,\n          mode,\n          voids\n        });\n\n        if (entry) {\n          var [, _matchPath] = entry;\n          var pathRef = Editor.pathRef(editor, _matchPath);\n          var isAtEnd = Editor.isEnd(editor, at, _matchPath);\n          Transforms.splitNodes(editor, {\n            at,\n            match,\n            mode,\n            voids\n          });\n          var path = pathRef.unref();\n          at = isAtEnd ? Path.next(path) : path;\n        } else {\n          return;\n        }\n      }\n\n      var parentPath = Path.parent(at);\n      var index = at[at.length - 1];\n\n      if (!voids && Editor.void(editor, {\n        at: parentPath\n      })) {\n        return;\n      }\n\n      for (var _node of nodes) {\n        var _path = parentPath.concat(index);\n\n        index++;\n        editor.apply({\n          type: 'insert_node',\n          path: _path,\n          node: _node\n        });\n        at = Path.next(at);\n      }\n\n      at = Path.previous(at);\n\n      if (select) {\n        var point = Editor.end(editor, at);\n\n        if (point) {\n          Transforms.select(editor, point);\n        }\n      }\n    });\n  },\n\n  /**\r\n   * Lift nodes at a specific location upwards in the document tree, splitting\r\n   * their parent in two if necessary.\r\n   */\n  liftNodes(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    Editor.withoutNormalizing(editor, () => {\n      var {\n        at = editor.selection,\n        mode = 'lowest',\n        voids = false\n      } = options;\n      var {\n        match\n      } = options;\n\n      if (match == null) {\n        match = Path.isPath(at) ? matchPath(editor, at) : n => Editor.isBlock(editor, n);\n      }\n\n      if (!at) {\n        return;\n      }\n\n      var matches = Editor.nodes(editor, {\n        at,\n        match,\n        mode,\n        voids\n      });\n      var pathRefs = Array.from(matches, _ref => {\n        var [, p] = _ref;\n        return Editor.pathRef(editor, p);\n      });\n\n      for (var pathRef of pathRefs) {\n        var path = pathRef.unref();\n\n        if (path.length < 2) {\n          throw new Error(\"Cannot lift node at a path [\".concat(path, \"] because it has a depth of less than `2`.\"));\n        }\n\n        var parentNodeEntry = Editor.node(editor, Path.parent(path));\n        var [parent, parentPath] = parentNodeEntry;\n        var index = path[path.length - 1];\n        var {\n          length\n        } = parent.children;\n\n        if (length === 1) {\n          var toPath = Path.next(parentPath);\n          Transforms.moveNodes(editor, {\n            at: path,\n            to: toPath,\n            voids\n          });\n          Transforms.removeNodes(editor, {\n            at: parentPath,\n            voids\n          });\n        } else if (index === 0) {\n          Transforms.moveNodes(editor, {\n            at: path,\n            to: parentPath,\n            voids\n          });\n        } else if (index === length - 1) {\n          var _toPath = Path.next(parentPath);\n\n          Transforms.moveNodes(editor, {\n            at: path,\n            to: _toPath,\n            voids\n          });\n        } else {\n          var splitPath = Path.next(path);\n\n          var _toPath2 = Path.next(parentPath);\n\n          Transforms.splitNodes(editor, {\n            at: splitPath,\n            voids\n          });\n          Transforms.moveNodes(editor, {\n            at: path,\n            to: _toPath2,\n            voids\n          });\n        }\n      }\n    });\n  },\n\n  /**\r\n   * Merge a node at a location with the previous node of the same depth,\r\n   * removing any empty containing nodes after the merge if necessary.\r\n   */\n  mergeNodes(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    Editor.withoutNormalizing(editor, () => {\n      var {\n        match,\n        at = editor.selection\n      } = options;\n      var {\n        hanging = false,\n        voids = false,\n        mode = 'lowest'\n      } = options;\n\n      if (!at) {\n        return;\n      }\n\n      if (match == null) {\n        if (Path.isPath(at)) {\n          var [parent] = Editor.parent(editor, at);\n\n          match = n => parent.children.includes(n);\n        } else {\n          match = n => Editor.isBlock(editor, n);\n        }\n      }\n\n      if (!hanging && Range.isRange(at)) {\n        at = Editor.unhangRange(editor, at);\n      }\n\n      if (Range.isRange(at)) {\n        if (Range.isCollapsed(at)) {\n          at = at.anchor;\n        } else {\n          var [, end] = Range.edges(at);\n          var pointRef = Editor.pointRef(editor, end);\n          Transforms.delete(editor, {\n            at\n          });\n          at = pointRef.unref();\n\n          if (options.at == null) {\n            Transforms.select(editor, at);\n          }\n        }\n      }\n\n      var [current] = Editor.nodes(editor, {\n        at,\n        match,\n        voids,\n        mode\n      });\n      var prev = Editor.previous(editor, {\n        at,\n        match,\n        voids,\n        mode\n      });\n\n      if (!current || !prev) {\n        return;\n      }\n\n      var [node, path] = current;\n      var [prevNode, prevPath] = prev;\n\n      if (path.length === 0 || prevPath.length === 0) {\n        return;\n      }\n\n      var newPath = Path.next(prevPath);\n      var commonPath = Path.common(path, prevPath);\n      var isPreviousSibling = Path.isSibling(path, prevPath);\n      var levels = Array.from(Editor.levels(editor, {\n        at: path\n      }), _ref2 => {\n        var [n] = _ref2;\n        return n;\n      }).slice(commonPath.length).slice(0, -1); // Determine if the merge will leave an ancestor of the path empty as a\n      // result, in which case we'll want to remove it after merging.\n\n      var emptyAncestor = Editor.above(editor, {\n        at: path,\n        mode: 'highest',\n        match: n => levels.includes(n) && hasSingleChildNest(editor, n)\n      });\n      var emptyRef = emptyAncestor && Editor.pathRef(editor, emptyAncestor[1]);\n      var properties;\n      var position; // Ensure that the nodes are equivalent, and figure out what the position\n      // and extra properties of the merge will be.\n\n      if (Text.isText(node) && Text.isText(prevNode)) {\n        var rest = _objectWithoutProperties$1(node, _excluded$5);\n\n        position = prevNode.text.length;\n        properties = rest;\n      } else if (Element.isElement(node) && Element.isElement(prevNode)) {\n        var rest = _objectWithoutProperties$1(node, _excluded2);\n\n        position = prevNode.children.length;\n        properties = rest;\n      } else {\n        throw new Error(\"Cannot merge the node at path [\".concat(path, \"] with the previous sibling because it is not the same kind: \").concat(Scrubber.stringify(node), \" \").concat(Scrubber.stringify(prevNode)));\n      } // If the node isn't already the next sibling of the previous node, move\n      // it so that it is before merging.\n\n\n      if (!isPreviousSibling) {\n        Transforms.moveNodes(editor, {\n          at: path,\n          to: newPath,\n          voids\n        });\n      } // If there was going to be an empty ancestor of the node that was merged,\n      // we remove it from the tree.\n\n\n      if (emptyRef) {\n        Transforms.removeNodes(editor, {\n          at: emptyRef.current,\n          voids\n        });\n      } // If the target node that we're merging with is empty, remove it instead\n      // of merging the two. This is a common rich text editor behavior to\n      // prevent losing formatting when deleting entire nodes when you have a\n      // hanging selection.\n      // if prevNode is first child in parent,don't remove it.\n\n\n      if (Element.isElement(prevNode) && Editor.isEmpty(editor, prevNode) || Text.isText(prevNode) && prevNode.text === '' && prevPath[prevPath.length - 1] !== 0) {\n        Transforms.removeNodes(editor, {\n          at: prevPath,\n          voids\n        });\n      } else {\n        editor.apply({\n          type: 'merge_node',\n          path: newPath,\n          position,\n          properties\n        });\n      }\n\n      if (emptyRef) {\n        emptyRef.unref();\n      }\n    });\n  },\n\n  /**\r\n   * Move the nodes at a location to a new location.\r\n   */\n  moveNodes(editor, options) {\n    Editor.withoutNormalizing(editor, () => {\n      var {\n        to,\n        at = editor.selection,\n        mode = 'lowest',\n        voids = false\n      } = options;\n      var {\n        match\n      } = options;\n\n      if (!at) {\n        return;\n      }\n\n      if (match == null) {\n        match = Path.isPath(at) ? matchPath(editor, at) : n => Editor.isBlock(editor, n);\n      }\n\n      var toRef = Editor.pathRef(editor, to);\n      var targets = Editor.nodes(editor, {\n        at,\n        match,\n        mode,\n        voids\n      });\n      var pathRefs = Array.from(targets, _ref3 => {\n        var [, p] = _ref3;\n        return Editor.pathRef(editor, p);\n      });\n\n      for (var pathRef of pathRefs) {\n        var path = pathRef.unref();\n        var newPath = toRef.current;\n\n        if (path.length !== 0) {\n          editor.apply({\n            type: 'move_node',\n            path,\n            newPath\n          });\n        }\n\n        if (toRef.current && Path.isSibling(newPath, path) && Path.isAfter(newPath, path)) {\n          // When performing a sibling move to a later index, the path at the destination is shifted\n          // to before the insertion point instead of after. To ensure our group of nodes are inserted\n          // in the correct order we increment toRef to account for that\n          toRef.current = Path.next(toRef.current);\n        }\n      }\n\n      toRef.unref();\n    });\n  },\n\n  /**\r\n   * Remove the nodes at a specific location in the document.\r\n   */\n  removeNodes(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    Editor.withoutNormalizing(editor, () => {\n      var {\n        hanging = false,\n        voids = false,\n        mode = 'lowest'\n      } = options;\n      var {\n        at = editor.selection,\n        match\n      } = options;\n\n      if (!at) {\n        return;\n      }\n\n      if (match == null) {\n        match = Path.isPath(at) ? matchPath(editor, at) : n => Editor.isBlock(editor, n);\n      }\n\n      if (!hanging && Range.isRange(at)) {\n        at = Editor.unhangRange(editor, at);\n      }\n\n      var depths = Editor.nodes(editor, {\n        at,\n        match,\n        mode,\n        voids\n      });\n      var pathRefs = Array.from(depths, _ref4 => {\n        var [, p] = _ref4;\n        return Editor.pathRef(editor, p);\n      });\n\n      for (var pathRef of pathRefs) {\n        var path = pathRef.unref();\n\n        if (path) {\n          var [node] = Editor.node(editor, path);\n          editor.apply({\n            type: 'remove_node',\n            path,\n            node\n          });\n        }\n      }\n    });\n  },\n\n  /**\r\n   * Set new properties on the nodes at a location.\r\n   */\n  setNodes(editor, props) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    Editor.withoutNormalizing(editor, () => {\n      var {\n        match,\n        at = editor.selection,\n        compare,\n        merge\n      } = options;\n      var {\n        hanging = false,\n        mode = 'lowest',\n        split = false,\n        voids = false\n      } = options;\n\n      if (!at) {\n        return;\n      }\n\n      if (match == null) {\n        match = Path.isPath(at) ? matchPath(editor, at) : n => Editor.isBlock(editor, n);\n      }\n\n      if (!hanging && Range.isRange(at)) {\n        at = Editor.unhangRange(editor, at);\n      }\n\n      if (split && Range.isRange(at)) {\n        if (Range.isCollapsed(at) && Editor.leaf(editor, at.anchor)[0].text.length > 0) {\n          // If the range is collapsed in a non-empty node and 'split' is true, there's nothing to\n          // set that won't get normalized away\n          return;\n        }\n\n        var rangeRef = Editor.rangeRef(editor, at, {\n          affinity: 'inward'\n        });\n        var [start, end] = Range.edges(at);\n        var splitMode = mode === 'lowest' ? 'lowest' : 'highest';\n        var endAtEndOfNode = Editor.isEnd(editor, end, end.path);\n        Transforms.splitNodes(editor, {\n          at: end,\n          match,\n          mode: splitMode,\n          voids,\n          always: !endAtEndOfNode\n        });\n        var startAtStartOfNode = Editor.isStart(editor, start, start.path);\n        Transforms.splitNodes(editor, {\n          at: start,\n          match,\n          mode: splitMode,\n          voids,\n          always: !startAtStartOfNode\n        });\n        at = rangeRef.unref();\n\n        if (options.at == null) {\n          Transforms.select(editor, at);\n        }\n      }\n\n      if (!compare) {\n        compare = (prop, nodeProp) => prop !== nodeProp;\n      }\n\n      for (var [node, path] of Editor.nodes(editor, {\n        at,\n        match,\n        mode,\n        voids\n      })) {\n        var properties = {};\n        var newProperties = {}; // You can't set properties on the editor node.\n\n        if (path.length === 0) {\n          continue;\n        }\n\n        var hasChanges = false;\n\n        for (var k in props) {\n          if (k === 'children' || k === 'text') {\n            continue;\n          }\n\n          if (compare(props[k], node[k])) {\n            hasChanges = true; // Omit new properties from the old properties list\n\n            if (node.hasOwnProperty(k)) properties[k] = node[k]; // Omit properties that have been removed from the new properties list\n\n            if (merge) {\n              if (props[k] != null) newProperties[k] = merge(node[k], props[k]);\n            } else {\n              if (props[k] != null) newProperties[k] = props[k];\n            }\n          }\n        }\n\n        if (hasChanges) {\n          editor.apply({\n            type: 'set_node',\n            path,\n            properties,\n            newProperties\n          });\n        }\n      }\n    });\n  },\n\n  /**\r\n   * Split the nodes at a specific location.\r\n   */\n  splitNodes(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    Editor.withoutNormalizing(editor, () => {\n      var {\n        mode = 'lowest',\n        voids = false\n      } = options;\n      var {\n        match,\n        at = editor.selection,\n        height = 0,\n        always = false\n      } = options;\n\n      if (match == null) {\n        match = n => Editor.isBlock(editor, n);\n      }\n\n      if (Range.isRange(at)) {\n        at = deleteRange(editor, at);\n      } // If the target is a path, the default height-skipping and position\n      // counters need to account for us potentially splitting at a non-leaf.\n\n\n      if (Path.isPath(at)) {\n        var path = at;\n        var point = Editor.point(editor, path);\n        var [parent] = Editor.parent(editor, path);\n\n        match = n => n === parent;\n\n        height = point.path.length - path.length + 1;\n        at = point;\n        always = true;\n      }\n\n      if (!at) {\n        return;\n      }\n\n      var beforeRef = Editor.pointRef(editor, at, {\n        affinity: 'backward'\n      });\n      var afterRef;\n\n      try {\n        var [highest] = Editor.nodes(editor, {\n          at,\n          match,\n          mode,\n          voids\n        });\n\n        if (!highest) {\n          return;\n        }\n\n        var voidMatch = Editor.void(editor, {\n          at,\n          mode: 'highest'\n        });\n        var nudge = 0;\n\n        if (!voids && voidMatch) {\n          var [voidNode, voidPath] = voidMatch;\n\n          if (Element.isElement(voidNode) && editor.isInline(voidNode)) {\n            var after = Editor.after(editor, voidPath);\n\n            if (!after) {\n              var text = {\n                text: ''\n              };\n              var afterPath = Path.next(voidPath);\n              Transforms.insertNodes(editor, text, {\n                at: afterPath,\n                voids\n              });\n              after = Editor.point(editor, afterPath);\n            }\n\n            at = after;\n            always = true;\n          }\n\n          var siblingHeight = at.path.length - voidPath.length;\n          height = siblingHeight + 1;\n          always = true;\n        }\n\n        afterRef = Editor.pointRef(editor, at);\n        var depth = at.path.length - height;\n        var [, highestPath] = highest;\n        var lowestPath = at.path.slice(0, depth);\n        var position = height === 0 ? at.offset : at.path[depth] + nudge;\n\n        for (var [node, _path2] of Editor.levels(editor, {\n          at: lowestPath,\n          reverse: true,\n          voids\n        })) {\n          var split = false;\n\n          if (_path2.length < highestPath.length || _path2.length === 0 || !voids && Editor.isVoid(editor, node)) {\n            break;\n          }\n\n          var _point = beforeRef.current;\n          var isEnd = Editor.isEnd(editor, _point, _path2);\n\n          if (always || !beforeRef || !Editor.isEdge(editor, _point, _path2)) {\n            split = true;\n            var properties = Node.extractProps(node);\n            editor.apply({\n              type: 'split_node',\n              path: _path2,\n              position,\n              properties\n            });\n          }\n\n          position = _path2[_path2.length - 1] + (split || isEnd ? 1 : 0);\n        }\n\n        if (options.at == null) {\n          var _point2 = afterRef.current || Editor.end(editor, []);\n\n          Transforms.select(editor, _point2);\n        }\n      } finally {\n        var _afterRef;\n\n        beforeRef.unref();\n        (_afterRef = afterRef) === null || _afterRef === void 0 ? void 0 : _afterRef.unref();\n      }\n    });\n  },\n\n  /**\r\n   * Unset properties on the nodes at a location.\r\n   */\n  unsetNodes(editor, props) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n\n    if (!Array.isArray(props)) {\n      props = [props];\n    }\n\n    var obj = {};\n\n    for (var key of props) {\n      obj[key] = null;\n    }\n\n    Transforms.setNodes(editor, obj, options);\n  },\n\n  /**\r\n   * Unwrap the nodes at a location from a parent node, splitting the parent if\r\n   * necessary to ensure that only the content in the range is unwrapped.\r\n   */\n  unwrapNodes(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    Editor.withoutNormalizing(editor, () => {\n      var {\n        mode = 'lowest',\n        split = false,\n        voids = false\n      } = options;\n      var {\n        at = editor.selection,\n        match\n      } = options;\n\n      if (!at) {\n        return;\n      }\n\n      if (match == null) {\n        match = Path.isPath(at) ? matchPath(editor, at) : n => Editor.isBlock(editor, n);\n      }\n\n      if (Path.isPath(at)) {\n        at = Editor.range(editor, at);\n      }\n\n      var rangeRef = Range.isRange(at) ? Editor.rangeRef(editor, at) : null;\n      var matches = Editor.nodes(editor, {\n        at,\n        match,\n        mode,\n        voids\n      });\n      var pathRefs = Array.from(matches, _ref5 => {\n        var [, p] = _ref5;\n        return Editor.pathRef(editor, p);\n      } // unwrapNode will call liftNode which does not support splitting the node when nested.\n      // If we do not reverse the order and call it from top to the bottom, it will remove all blocks\n      // that wrap target node. So we reverse the order.\n      ).reverse();\n\n      var _loop = function _loop(pathRef) {\n        var path = pathRef.unref();\n        var [node] = Editor.node(editor, path);\n        var range = Editor.range(editor, path);\n\n        if (split && rangeRef) {\n          range = Range.intersection(rangeRef.current, range);\n        }\n\n        Transforms.liftNodes(editor, {\n          at: range,\n          match: n => Element.isAncestor(node) && node.children.includes(n),\n          voids\n        });\n      };\n\n      for (var pathRef of pathRefs) {\n        _loop(pathRef);\n      }\n\n      if (rangeRef) {\n        rangeRef.unref();\n      }\n    });\n  },\n\n  /**\r\n   * Wrap the nodes at a location in a new container node, splitting the edges\r\n   * of the range first to ensure that only the content in the range is wrapped.\r\n   */\n  wrapNodes(editor, element) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    Editor.withoutNormalizing(editor, () => {\n      var {\n        mode = 'lowest',\n        split = false,\n        voids = false\n      } = options;\n      var {\n        match,\n        at = editor.selection\n      } = options;\n\n      if (!at) {\n        return;\n      }\n\n      if (match == null) {\n        if (Path.isPath(at)) {\n          match = matchPath(editor, at);\n        } else if (editor.isInline(element)) {\n          match = n => Editor.isInline(editor, n) || Text.isText(n);\n        } else {\n          match = n => Editor.isBlock(editor, n);\n        }\n      }\n\n      if (split && Range.isRange(at)) {\n        var [start, end] = Range.edges(at);\n        var rangeRef = Editor.rangeRef(editor, at, {\n          affinity: 'inward'\n        });\n        Transforms.splitNodes(editor, {\n          at: end,\n          match,\n          voids\n        });\n        Transforms.splitNodes(editor, {\n          at: start,\n          match,\n          voids\n        });\n        at = rangeRef.unref();\n\n        if (options.at == null) {\n          Transforms.select(editor, at);\n        }\n      }\n\n      var roots = Array.from(Editor.nodes(editor, {\n        at,\n        match: editor.isInline(element) ? n => Editor.isBlock(editor, n) : n => Editor.isEditor(n),\n        mode: 'lowest',\n        voids\n      }));\n\n      for (var [, rootPath] of roots) {\n        var a = Range.isRange(at) ? Range.intersection(at, Editor.range(editor, rootPath)) : at;\n\n        if (!a) {\n          continue;\n        }\n\n        var matches = Array.from(Editor.nodes(editor, {\n          at: a,\n          match,\n          mode,\n          voids\n        }));\n\n        if (matches.length > 0) {\n          var _ret = function () {\n            var [first] = matches;\n            var last = matches[matches.length - 1];\n            var [, firstPath] = first;\n            var [, lastPath] = last;\n\n            if (firstPath.length === 0 && lastPath.length === 0) {\n              // if there's no matching parent - usually means the node is an editor - don't do anything\n              return \"continue\";\n            }\n\n            var commonPath = Path.equals(firstPath, lastPath) ? Path.parent(firstPath) : Path.common(firstPath, lastPath);\n            var range = Editor.range(editor, firstPath, lastPath);\n            var commonNodeEntry = Editor.node(editor, commonPath);\n            var [commonNode] = commonNodeEntry;\n            var depth = commonPath.length + 1;\n            var wrapperPath = Path.next(lastPath.slice(0, depth));\n\n            var wrapper = _objectSpread$2(_objectSpread$2({}, element), {}, {\n              children: []\n            });\n\n            Transforms.insertNodes(editor, wrapper, {\n              at: wrapperPath,\n              voids\n            });\n            Transforms.moveNodes(editor, {\n              at: range,\n              match: n => Element.isAncestor(commonNode) && commonNode.children.includes(n),\n              to: wrapperPath.concat(0),\n              voids\n            });\n          }();\n\n          if (_ret === \"continue\") continue;\n        }\n      }\n    });\n  }\n\n};\n\nvar hasSingleChildNest = (editor, node) => {\n  if (Element.isElement(node)) {\n    var element = node;\n\n    if (Editor.isVoid(editor, node)) {\n      return true;\n    } else if (element.children.length === 1) {\n      return hasSingleChildNest(editor, element.children[0]);\n    } else {\n      return false;\n    }\n  } else if (Editor.isEditor(node)) {\n    return false;\n  } else {\n    return true;\n  }\n};\n/**\r\n * Convert a range into a point by deleting it's content.\r\n */\n\n\nvar deleteRange = (editor, range) => {\n  if (Range.isCollapsed(range)) {\n    return range.anchor;\n  } else {\n    var [, end] = Range.edges(range);\n    var pointRef = Editor.pointRef(editor, end);\n    Transforms.delete(editor, {\n      at: range\n    });\n    return pointRef.unref();\n  }\n};\n\nvar matchPath = (editor, path) => {\n  var [node] = Editor.node(editor, path);\n  return n => n === node;\n};\n\nfunction ownKeys$1(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread$1(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$1(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$1(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nvar SelectionTransforms = {\n  /**\r\n   * Collapse the selection.\r\n   */\n  collapse(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var {\n      edge = 'anchor'\n    } = options;\n    var {\n      selection\n    } = editor;\n\n    if (!selection) {\n      return;\n    } else if (edge === 'anchor') {\n      Transforms.select(editor, selection.anchor);\n    } else if (edge === 'focus') {\n      Transforms.select(editor, selection.focus);\n    } else if (edge === 'start') {\n      var [start] = Range.edges(selection);\n      Transforms.select(editor, start);\n    } else if (edge === 'end') {\n      var [, end] = Range.edges(selection);\n      Transforms.select(editor, end);\n    }\n  },\n\n  /**\r\n   * Unset the selection.\r\n   */\n  deselect(editor) {\n    var {\n      selection\n    } = editor;\n\n    if (selection) {\n      editor.apply({\n        type: 'set_selection',\n        properties: selection,\n        newProperties: null\n      });\n    }\n  },\n\n  /**\r\n   * Move the selection's point forward or backward.\r\n   */\n  move(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var {\n      selection\n    } = editor;\n    var {\n      distance = 1,\n      unit = 'character',\n      reverse = false\n    } = options;\n    var {\n      edge = null\n    } = options;\n\n    if (!selection) {\n      return;\n    }\n\n    if (edge === 'start') {\n      edge = Range.isBackward(selection) ? 'focus' : 'anchor';\n    }\n\n    if (edge === 'end') {\n      edge = Range.isBackward(selection) ? 'anchor' : 'focus';\n    }\n\n    var {\n      anchor,\n      focus\n    } = selection;\n    var opts = {\n      distance,\n      unit\n    };\n    var props = {};\n\n    if (edge == null || edge === 'anchor') {\n      var point = reverse ? Editor.before(editor, anchor, opts) : Editor.after(editor, anchor, opts);\n\n      if (point) {\n        props.anchor = point;\n      }\n    }\n\n    if (edge == null || edge === 'focus') {\n      var _point = reverse ? Editor.before(editor, focus, opts) : Editor.after(editor, focus, opts);\n\n      if (_point) {\n        props.focus = _point;\n      }\n    }\n\n    Transforms.setSelection(editor, props);\n  },\n\n  /**\r\n   * Set the selection to a new value.\r\n   */\n  select(editor, target) {\n    var {\n      selection\n    } = editor;\n    target = Editor.range(editor, target);\n\n    if (selection) {\n      Transforms.setSelection(editor, target);\n      return;\n    }\n\n    if (!Range.isRange(target)) {\n      throw new Error(\"When setting the selection and the current selection is `null` you must provide at least an `anchor` and `focus`, but you passed: \".concat(Scrubber.stringify(target)));\n    }\n\n    editor.apply({\n      type: 'set_selection',\n      properties: selection,\n      newProperties: target\n    });\n  },\n\n  /**\r\n   * Set new properties on one of the selection's points.\r\n   */\n  setPoint(editor, props) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var {\n      selection\n    } = editor;\n    var {\n      edge = 'both'\n    } = options;\n\n    if (!selection) {\n      return;\n    }\n\n    if (edge === 'start') {\n      edge = Range.isBackward(selection) ? 'focus' : 'anchor';\n    }\n\n    if (edge === 'end') {\n      edge = Range.isBackward(selection) ? 'anchor' : 'focus';\n    }\n\n    var {\n      anchor,\n      focus\n    } = selection;\n    var point = edge === 'anchor' ? anchor : focus;\n    Transforms.setSelection(editor, {\n      [edge === 'anchor' ? 'anchor' : 'focus']: _objectSpread$1(_objectSpread$1({}, point), props)\n    });\n  },\n\n  /**\r\n   * Set new properties on the selection.\r\n   */\n  setSelection(editor, props) {\n    var {\n      selection\n    } = editor;\n    var oldProps = {};\n    var newProps = {};\n\n    if (!selection) {\n      return;\n    }\n\n    for (var k in props) {\n      if (k === 'anchor' && props.anchor != null && !Point.equals(props.anchor, selection.anchor) || k === 'focus' && props.focus != null && !Point.equals(props.focus, selection.focus) || k !== 'anchor' && k !== 'focus' && props[k] !== selection[k]) {\n        oldProps[k] = selection[k];\n        newProps[k] = props[k];\n      }\n    }\n\n    if (Object.keys(oldProps).length > 0) {\n      editor.apply({\n        type: 'set_selection',\n        properties: oldProps,\n        newProperties: newProps\n      });\n    }\n  }\n\n};\n\nvar TextTransforms = {\n  /**\r\n   * Delete content in the editor.\r\n   */\n  delete(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    Editor.withoutNormalizing(editor, () => {\n      var {\n        reverse = false,\n        unit = 'character',\n        distance = 1,\n        voids = false\n      } = options;\n      var {\n        at = editor.selection,\n        hanging = false\n      } = options;\n\n      if (!at) {\n        return;\n      }\n\n      var isCollapsed = false;\n\n      if (Range.isRange(at) && Range.isCollapsed(at)) {\n        isCollapsed = true;\n        at = at.anchor;\n      }\n\n      if (Point.isPoint(at)) {\n        var furthestVoid = Editor.void(editor, {\n          at,\n          mode: 'highest'\n        });\n\n        if (!voids && furthestVoid) {\n          var [, voidPath] = furthestVoid;\n          at = voidPath;\n        } else {\n          var opts = {\n            unit,\n            distance\n          };\n          var target = reverse ? Editor.before(editor, at, opts) || Editor.start(editor, []) : Editor.after(editor, at, opts) || Editor.end(editor, []);\n          at = {\n            anchor: at,\n            focus: target\n          };\n          hanging = true;\n        }\n      }\n\n      if (Path.isPath(at)) {\n        Transforms.removeNodes(editor, {\n          at,\n          voids\n        });\n        return;\n      }\n\n      if (Range.isCollapsed(at)) {\n        return;\n      }\n\n      if (!hanging) {\n        var [, _end] = Range.edges(at);\n        var endOfDoc = Editor.end(editor, []);\n\n        if (!Point.equals(_end, endOfDoc)) {\n          at = Editor.unhangRange(editor, at, {\n            voids\n          });\n        }\n      }\n\n      var [start, end] = Range.edges(at);\n      var startBlock = Editor.above(editor, {\n        match: n => Editor.isBlock(editor, n),\n        at: start,\n        voids\n      });\n      var endBlock = Editor.above(editor, {\n        match: n => Editor.isBlock(editor, n),\n        at: end,\n        voids\n      });\n      var isAcrossBlocks = startBlock && endBlock && !Path.equals(startBlock[1], endBlock[1]);\n      var isSingleText = Path.equals(start.path, end.path);\n      var startVoid = voids ? null : Editor.void(editor, {\n        at: start,\n        mode: 'highest'\n      });\n      var endVoid = voids ? null : Editor.void(editor, {\n        at: end,\n        mode: 'highest'\n      }); // If the start or end points are inside an inline void, nudge them out.\n\n      if (startVoid) {\n        var before = Editor.before(editor, start);\n\n        if (before && startBlock && Path.isAncestor(startBlock[1], before.path)) {\n          start = before;\n        }\n      }\n\n      if (endVoid) {\n        var after = Editor.after(editor, end);\n\n        if (after && endBlock && Path.isAncestor(endBlock[1], after.path)) {\n          end = after;\n        }\n      } // Get the highest nodes that are completely inside the range, as well as\n      // the start and end nodes.\n\n\n      var matches = [];\n      var lastPath;\n\n      for (var entry of Editor.nodes(editor, {\n        at,\n        voids\n      })) {\n        var [node, path] = entry;\n\n        if (lastPath && Path.compare(path, lastPath) === 0) {\n          continue;\n        }\n\n        if (!voids && Editor.isVoid(editor, node) || !Path.isCommon(path, start.path) && !Path.isCommon(path, end.path)) {\n          matches.push(entry);\n          lastPath = path;\n        }\n      }\n\n      var pathRefs = Array.from(matches, _ref => {\n        var [, p] = _ref;\n        return Editor.pathRef(editor, p);\n      });\n      var startRef = Editor.pointRef(editor, start);\n      var endRef = Editor.pointRef(editor, end);\n      var removedText = '';\n\n      if (!isSingleText && !startVoid) {\n        var _point = startRef.current;\n        var [_node] = Editor.leaf(editor, _point);\n        var {\n          path: _path\n        } = _point;\n        var {\n          offset\n        } = start;\n\n        var text = _node.text.slice(offset);\n\n        if (text.length > 0) {\n          editor.apply({\n            type: 'remove_text',\n            path: _path,\n            offset,\n            text\n          });\n          removedText = text;\n        }\n      }\n\n      pathRefs.reverse().map(r => r.unref()).filter(r => r !== null).forEach(p => Transforms.removeNodes(editor, {\n        at: p,\n        voids\n      }));\n\n      if (!endVoid) {\n        var _point2 = endRef.current;\n        var [_node2] = Editor.leaf(editor, _point2);\n        var {\n          path: _path2\n        } = _point2;\n\n        var _offset = isSingleText ? start.offset : 0;\n\n        var _text = _node2.text.slice(_offset, end.offset);\n\n        if (_text.length > 0) {\n          editor.apply({\n            type: 'remove_text',\n            path: _path2,\n            offset: _offset,\n            text: _text\n          });\n          removedText = _text;\n        }\n      }\n\n      if (!isSingleText && isAcrossBlocks && endRef.current && startRef.current) {\n        Transforms.mergeNodes(editor, {\n          at: endRef.current,\n          hanging: true,\n          voids\n        });\n      } // For Thai script, deleting N character(s) backward should delete\n      // N code point(s) instead of an entire grapheme cluster.\n      // Therefore, the remaining code points should be inserted back.\n\n\n      if (isCollapsed && reverse && unit === 'character' && removedText.length > 1 && removedText.match(/[\\u0E00-\\u0E7F]+/)) {\n        Transforms.insertText(editor, removedText.slice(0, removedText.length - distance));\n      }\n\n      var startUnref = startRef.unref();\n      var endUnref = endRef.unref();\n      var point = reverse ? startUnref || endUnref : endUnref || startUnref;\n\n      if (options.at == null && point) {\n        Transforms.select(editor, point);\n      }\n    });\n  },\n\n  /**\r\n   * Insert a fragment at a specific location in the editor.\r\n   */\n  insertFragment(editor, fragment) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    Editor.withoutNormalizing(editor, () => {\n      var {\n        hanging = false,\n        voids = false\n      } = options;\n      var {\n        at = editor.selection\n      } = options;\n\n      if (!fragment.length) {\n        return;\n      }\n\n      if (!at) {\n        return;\n      } else if (Range.isRange(at)) {\n        if (!hanging) {\n          at = Editor.unhangRange(editor, at);\n        }\n\n        if (Range.isCollapsed(at)) {\n          at = at.anchor;\n        } else {\n          var [, end] = Range.edges(at);\n\n          if (!voids && Editor.void(editor, {\n            at: end\n          })) {\n            return;\n          }\n\n          var pointRef = Editor.pointRef(editor, end);\n          Transforms.delete(editor, {\n            at\n          });\n          at = pointRef.unref();\n        }\n      } else if (Path.isPath(at)) {\n        at = Editor.start(editor, at);\n      }\n\n      if (!voids && Editor.void(editor, {\n        at\n      })) {\n        return;\n      } // If the insert point is at the edge of an inline node, move it outside\n      // instead since it will need to be split otherwise.\n\n\n      var inlineElementMatch = Editor.above(editor, {\n        at,\n        match: n => Editor.isInline(editor, n),\n        mode: 'highest',\n        voids\n      });\n\n      if (inlineElementMatch) {\n        var [, _inlinePath] = inlineElementMatch;\n\n        if (Editor.isEnd(editor, at, _inlinePath)) {\n          var after = Editor.after(editor, _inlinePath);\n          at = after;\n        } else if (Editor.isStart(editor, at, _inlinePath)) {\n          var before = Editor.before(editor, _inlinePath);\n          at = before;\n        }\n      }\n\n      var blockMatch = Editor.above(editor, {\n        match: n => Editor.isBlock(editor, n),\n        at,\n        voids\n      });\n      var [, blockPath] = blockMatch;\n      var isBlockStart = Editor.isStart(editor, at, blockPath);\n      var isBlockEnd = Editor.isEnd(editor, at, blockPath);\n      var isBlockEmpty = isBlockStart && isBlockEnd;\n      var mergeStart = !isBlockStart || isBlockStart && isBlockEnd;\n      var mergeEnd = !isBlockEnd;\n      var [, firstPath] = Node.first({\n        children: fragment\n      }, []);\n      var [, lastPath] = Node.last({\n        children: fragment\n      }, []);\n      var matches = [];\n\n      var matcher = _ref2 => {\n        var [n, p] = _ref2;\n        var isRoot = p.length === 0;\n\n        if (isRoot) {\n          return false;\n        }\n\n        if (isBlockEmpty) {\n          return true;\n        }\n\n        if (mergeStart && Path.isAncestor(p, firstPath) && Element.isElement(n) && !editor.isVoid(n) && !editor.isInline(n)) {\n          return false;\n        }\n\n        if (mergeEnd && Path.isAncestor(p, lastPath) && Element.isElement(n) && !editor.isVoid(n) && !editor.isInline(n)) {\n          return false;\n        }\n\n        return true;\n      };\n\n      for (var entry of Node.nodes({\n        children: fragment\n      }, {\n        pass: matcher\n      })) {\n        if (matcher(entry)) {\n          matches.push(entry);\n        }\n      }\n\n      var starts = [];\n      var middles = [];\n      var ends = [];\n      var starting = true;\n      var hasBlocks = false;\n\n      for (var [node] of matches) {\n        if (Element.isElement(node) && !editor.isInline(node)) {\n          starting = false;\n          hasBlocks = true;\n          middles.push(node);\n        } else if (starting) {\n          starts.push(node);\n        } else {\n          ends.push(node);\n        }\n      }\n\n      var [inlineMatch] = Editor.nodes(editor, {\n        at,\n        match: n => Text.isText(n) || Editor.isInline(editor, n),\n        mode: 'highest',\n        voids\n      });\n      var [, inlinePath] = inlineMatch;\n      var isInlineStart = Editor.isStart(editor, at, inlinePath);\n      var isInlineEnd = Editor.isEnd(editor, at, inlinePath);\n      var middleRef = Editor.pathRef(editor, isBlockEnd && !ends.length ? Path.next(blockPath) : blockPath);\n      var endRef = Editor.pathRef(editor, isInlineEnd ? Path.next(inlinePath) : inlinePath);\n      Transforms.splitNodes(editor, {\n        at,\n        match: n => hasBlocks ? Editor.isBlock(editor, n) : Text.isText(n) || Editor.isInline(editor, n),\n        mode: hasBlocks ? 'lowest' : 'highest',\n        always: hasBlocks && (!isBlockStart || starts.length > 0) && (!isBlockEnd || ends.length > 0),\n        voids\n      });\n      var startRef = Editor.pathRef(editor, !isInlineStart || isInlineStart && isInlineEnd ? Path.next(inlinePath) : inlinePath);\n      Transforms.insertNodes(editor, starts, {\n        at: startRef.current,\n        match: n => Text.isText(n) || Editor.isInline(editor, n),\n        mode: 'highest',\n        voids\n      });\n\n      if (isBlockEmpty && !starts.length && middles.length && !ends.length) {\n        Transforms.delete(editor, {\n          at: blockPath,\n          voids\n        });\n      }\n\n      Transforms.insertNodes(editor, middles, {\n        at: middleRef.current,\n        match: n => Editor.isBlock(editor, n),\n        mode: 'lowest',\n        voids\n      });\n      Transforms.insertNodes(editor, ends, {\n        at: endRef.current,\n        match: n => Text.isText(n) || Editor.isInline(editor, n),\n        mode: 'highest',\n        voids\n      });\n\n      if (!options.at) {\n        var path;\n\n        if (ends.length > 0 && endRef.current) {\n          path = Path.previous(endRef.current);\n        } else if (middles.length > 0 && middleRef.current) {\n          path = Path.previous(middleRef.current);\n        } else if (startRef.current) {\n          path = Path.previous(startRef.current);\n        }\n\n        if (path) {\n          var _end2 = Editor.end(editor, path);\n\n          Transforms.select(editor, _end2);\n        }\n      }\n\n      startRef.unref();\n      middleRef.unref();\n      endRef.unref();\n    });\n  },\n\n  /**\r\n   * Insert a string of text in the Editor.\r\n   */\n  insertText(editor, text) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    Editor.withoutNormalizing(editor, () => {\n      var {\n        voids = false\n      } = options;\n      var {\n        at = editor.selection\n      } = options;\n\n      if (!at) {\n        return;\n      }\n\n      if (Path.isPath(at)) {\n        at = Editor.range(editor, at);\n      }\n\n      if (Range.isRange(at)) {\n        if (Range.isCollapsed(at)) {\n          at = at.anchor;\n        } else {\n          var end = Range.end(at);\n\n          if (!voids && Editor.void(editor, {\n            at: end\n          })) {\n            return;\n          }\n\n          var start = Range.start(at);\n          var startRef = Editor.pointRef(editor, start);\n          var endRef = Editor.pointRef(editor, end);\n          Transforms.delete(editor, {\n            at,\n            voids\n          });\n          var startPoint = startRef.unref();\n          var endPoint = endRef.unref();\n          at = startPoint || endPoint;\n          Transforms.setSelection(editor, {\n            anchor: at,\n            focus: at\n          });\n        }\n      }\n\n      if (!voids && Editor.void(editor, {\n        at\n      })) {\n        return;\n      }\n\n      var {\n        path,\n        offset\n      } = at;\n      if (text.length > 0) editor.apply({\n        type: 'insert_text',\n        path,\n        offset,\n        text\n      });\n    });\n  }\n\n};\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\nvar Transforms = _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, GeneralTransforms), NodeTransforms), SelectionTransforms), TextTransforms);\n\nfunction styleInject$2(css, ref) {\n  if (ref === void 0) ref = {};\n  var insertAt = ref.insertAt;\n  if (!css || typeof document === 'undefined') {\n    return;\n  }\n  var head = document.head || document.getElementsByTagName('head')[0];\n  var style = document.createElement('style');\n  style.type = 'text/css';\n  if (insertAt === 'top') {\n    if (head.firstChild) {\n      head.insertBefore(style, head.firstChild);\n    } else {\n      head.appendChild(style);\n    }\n  } else {\n    head.appendChild(style);\n  }\n  if (style.styleSheet) {\n    style.styleSheet.cssText = css;\n  } else {\n    style.appendChild(document.createTextNode(css));\n  }\n}\nvar css_248z$2 = \".styles-module_date__svSd3 {\\n  color: #545d68 !important;\\n  text-transform: capitalize;\\n}\\n\";\nvar styles$2 = {\n  \"date\": \"styles-module_date__svSd3\"\n};\nstyleInject$2(css_248z$2);\nfunction formatRelativeDate(date, relativeTimeFormatter) {\n  var utcDate = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds()));\n  return relativeTimeFormatter.format(utcDate);\n}\nvar DateLabel = function DateLabel(_ref) {\n  var relativeTimeFormatter = _ref.relativeTimeFormatter,\n    date = _ref.date;\n  return /*#__PURE__*/React.createElement(CaptionText, {\n    className: styles$2.date\n  }, formatRelativeDate(date, relativeTimeFormatter));\n};\nDateLabel.propTypes = {\n  relativeTimeFormatter: PropTypes.any,\n  date: PropTypes.object\n};\n\nfunction _extends() {\n  _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n  return target;\n}\nfunction _objectWithoutProperties(source, excluded) {\n  if (source == null) return {};\n  var target = _objectWithoutPropertiesLoose(source, excluded);\n  var key, i;\n  if (Object.getOwnPropertySymbols) {\n    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);\n    for (i = 0; i < sourceSymbolKeys.length; i++) {\n      key = sourceSymbolKeys[i];\n      if (excluded.indexOf(key) >= 0) continue;\n      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;\n      target[key] = source[key];\n    }\n  }\n  return target;\n}\nfunction styleInject$1(css, ref) {\n  if (ref === void 0) ref = {};\n  var insertAt = ref.insertAt;\n  if (!css || typeof document === 'undefined') {\n    return;\n  }\n  var head = document.head || document.getElementsByTagName('head')[0];\n  var style = document.createElement('style');\n  style.type = 'text/css';\n  if (insertAt === 'top') {\n    if (head.firstChild) {\n      head.insertBefore(style, head.firstChild);\n    } else {\n      head.appendChild(style);\n    }\n  } else {\n    head.appendChild(style);\n  }\n  if (style.styleSheet) {\n    style.styleSheet.cssText = css;\n  } else {\n    style.appendChild(document.createTextNode(css));\n  }\n}\nvar css_248z$1 = \".styles-module_like_button__Oe0CN {\\n  background: #faf8f5 !important;\\n  border: 0px !important;\\n}\\n\\n.styles-module_has_no_amount__NpzMW {\\n  min-width: 10px !important;\\n  padding-left: 12px !important;\\n  padding-right: 4px !important;\\n}\\n\\n.styles-module_has_amount__DoRAC {\\n  min-width: 20px !important;\\n  padding-left: 12px !important;\\n  padding-right: 12px !important;\\n}\\n\\n.styles-module_empty_like_button__QmnJ3 {\\n  color: #545d68 !important;\\n}\\n\\n.styles-module_full_like_button__a1Naq {\\n  color: #9b0021 !important;\\n}\\n\";\nvar styles$1 = {\n  \"like_button\": \"styles-module_like_button__Oe0CN\",\n  \"has_no_amount\": \"styles-module_has_no_amount__NpzMW\",\n  \"has_amount\": \"styles-module_has_amount__DoRAC\",\n  \"empty_like_button\": \"styles-module_empty_like_button__QmnJ3\",\n  \"full_like_button\": \"styles-module_full_like_button__a1Naq\"\n};\nstyleInject$1(css_248z$1);\nvar _excluded = [\"isReadOnly\", \"isLiked\", \"amount\", \"content\", \"btnState\"];\nvar LikeButton = function LikeButton(_ref) {\n  var _ref$isReadOnly = _ref.isReadOnly,\n    isReadOnly = _ref$isReadOnly === void 0 ? false : _ref$isReadOnly,\n    _ref$isLiked = _ref.isLiked,\n    isLiked = _ref$isLiked === void 0 ? false : _ref$isLiked,\n    _ref$amount = _ref.amount,\n    amount = _ref$amount === void 0 ? 0 : _ref$amount,\n    content = _ref.content,\n    _ref$btnState = _ref.btnState,\n    btnState = _ref$btnState === void 0 ? 'initial' : _ref$btnState,\n    rest = _objectWithoutProperties(_ref, _excluded);\n  var getButtonClassName = function getButtonClassName() {\n    var className = \"\".concat(styles$1.like_button);\n    if (amount > 0) {\n      className += \" \".concat(styles$1.has_amount);\n    } else {\n      className += \" \".concat(styles$1.has_no_amount);\n    }\n    if (btnState !== 'initial') {\n      return className;\n    }\n    if (isLiked) {\n      className += \" \".concat(styles$1.full_like_button);\n    } else {\n      className += \" \".concat(styles$1.empty_like_button);\n    }\n    return className;\n  };\n  return isReadOnly ? /*#__PURE__*/React.createElement(Badge, {\n    type: \"neutral\",\n    leftIcon: FavoriteIcon,\n    \"aria-label\": content\n  }, amount || 0) : /*#__PURE__*/React.createElement(Button, _extends({}, rest, {\n    iconComponent: isLiked ? FavoriteSelectedIcon : FavoriteIcon,\n    className: \"\".concat(getButtonClassName()),\n    secondary: true,\n    screenReaderText: content,\n    \"aria-label\": content,\n    btnState: btnState\n  }), amount > 0 && amount);\n};\nLikeButton.propTypes = {\n  isReadOnly: PropTypes.bool,\n  isLiked: PropTypes.bool,\n  amount: PropTypes.number,\n  content: PropTypes.string,\n  btnState: PropTypes.string,\n  onClick: PropTypes.func\n};\n\nfunction styleInject(css, ref) {\n  if (ref === void 0) ref = {};\n  var insertAt = ref.insertAt;\n  if (!css || typeof document === 'undefined') {\n    return;\n  }\n  var head = document.head || document.getElementsByTagName('head')[0];\n  var style = document.createElement('style');\n  style.type = 'text/css';\n  if (insertAt === 'top') {\n    if (head.firstChild) {\n      head.insertBefore(style, head.firstChild);\n    } else {\n      head.appendChild(style);\n    }\n  } else {\n    head.appendChild(style);\n  }\n  if (style.styleSheet) {\n    style.styleSheet.cssText = css;\n  } else {\n    style.appendChild(document.createTextNode(css));\n  }\n}\n\nvar css_248z = \".styles-module_update_card_preview__jSylp {\\n  position: relative;\\n}\\n\\n.styles-module_organizer_update_preview__TqMJ4 {\\n  display: flex;\\n  align-items: baseline;\\n}\\n.styles-module_date__svSd3 {\\n  padding: 10px;\\n}\\n.styles-module_organizer_preview_content__SQn-H {\\n  text-overflow: ellipsis;\\n  overflow: hidden;\\n  display: -webkit-box;\\n  -webkit-line-clamp: 2;\\n  -webkit-box-orient: vertical;\\n}\\n.styles-module_organizer_preview_footer__wSmeb {\\n  height: auto !important;\\n  position: inherit !important;\\n  min-height: auto !important;\\n}\\n\";\nvar styles = {\"update_card_preview\":\"styles-module_update_card_preview__jSylp\",\"organizer_update_preview\":\"styles-module_organizer_update_preview__TqMJ4\",\"date\":\"styles-module_date__svSd3\",\"organizer_preview_content\":\"styles-module_organizer_preview_content__SQn-H\",\"organizer_preview_footer\":\"styles-module_organizer_preview_footer__wSmeb\"};\nstyleInject(css_248z);\n\nvar getPlainTextDescription = function getPlainTextDescription(description) {\n  try {\n    var newPlainText = description.map(function (n) {\n      return Node.string(n);\n    }).join('\\n');\n    return newPlainText;\n  } catch (e) {\n    return false;\n  }\n};\nvar OrganizerUpdatePreview = function OrganizerUpdatePreview(_ref) {\n  var organizerUpdateTitle = _ref.organizerUpdateTitle,\n    organizerUpdateContent = _ref.organizerUpdateContent,\n    date = _ref.date,\n    relativeTimeFormatter = _ref.relativeTimeFormatter,\n    id = _ref.id,\n    likeButtonProps = _ref.likeButtonProps,\n    clickHandler = _ref.clickHandler;\n  var plainTextContent = getPlainTextDescription(organizerUpdateContent);\n  var keyOnUpdate = function keyOnUpdate(event) {\n    if (event.key === 'Enter' || event.key === ' ') {\n      event.preventDefault();\n      clickHandler();\n    }\n  };\n  return /*#__PURE__*/React.createElement(\"div\", {\n    className: styles.update_card_preview,\n    tabIndex: \"0\",\n    onKeyDown: keyOnUpdate,\n    onClick: clickHandler\n  }, /*#__PURE__*/React.createElement(Card, {\n    id: id,\n    size: \"xs\"\n  }, /*#__PURE__*/React.createElement(Card.Header, {\n    className: styles.organizer_update_preview\n  }, organizerUpdateTitle, /*#__PURE__*/React.createElement(DateLabel, {\n    date: date,\n    className: styles.date,\n    relativeTimeFormatter: relativeTimeFormatter\n  })), /*#__PURE__*/React.createElement(Card.Content, {\n    className: styles.organizer_preview_content\n  }, plainTextContent), /*#__PURE__*/React.createElement(Card.Footer, {\n    className: styles.organizer_preview_footer\n  }, /*#__PURE__*/React.createElement(LikeButton, likeButtonProps))));\n};\nOrganizerUpdatePreview.propTypes = {\n  organizerUpdateTitle: PropTypes.string,\n  organizerUpdateContent: PropTypes.array,\n  date: PropTypes.object,\n  relativeTimeFormatter: PropTypes.any,\n  id: PropTypes.string,\n  clickHandler: PropTypes.func,\n  likeButtonProps: PropTypes.shape({\n    onClick: PropTypes.func,\n    isReadOnly: PropTypes.bool,\n    amount: PropTypes.number,\n    isLiked: PropTypes.bool,\n    content: PropTypes.string\n  })\n};\n\nexport { OrganizerUpdatePreview };\n"],"names":["isObject","o","Object","prototype","toString","call","isPlainObject","ctor","prot","undefined","constructor","hasOwnProperty","n","r","arguments","length","t","Array","e","i","Y","apply","Error","Q","getPrototypeOf","Function","Z","isArray","L","s","v","keys","nn","forEach","u","has","f","set","add","X","Map","q","Set","p","l","slice","rn","writable","configurable","get","enumerable","value","create","d","y","clear","delete","h","freeze","isFrozen","b","tn","_","U","j","g","O","S","w","m","P","M","x","H","A","I","k","a","N","c","R","concat","D","z","getOwnPropertyDescriptor","E","F","T","C","en","on","Proxy","revocable","revoke","proxy","J","push","K","from","G","W","Symbol","B","Reflect","for","ownKeys","getOwnPropertySymbols","getOwnPropertyNames","getOwnPropertyDescriptors","Number","isNaN","deleteProperty","defineProperty","setPrototypeOf","this","parseInt","un","produce","Promise","then","produceWithPatches","useProxies","setUseProxies","autoFreeze","setAutoFreeze","createDraft","finishDraft","applyPatches","path","op","$","an","fn","bind","ln","dn","_defineProperty","obj","key","DIRTY_PATHS","WeakMap","DIRTY_PATH_KEYS","NORMALIZING","PATH_REFS","POINT_REFS","RANGE_REFS","_objectWithoutProperties$1","source","excluded","target","sourceKeys","indexOf","_objectWithoutPropertiesLoose$1","sourceSymbolKeys","propertyIsEnumerable","CodepointType","getCharacterDistance","str","isRTL","isLTR","codepoints","codepointsIteratorRTL","left","None","right","distance","gb12Or13","char","code","codePointAt","type","getCodepointType","intersects","ZWJ","ExtPict","endsWithEmojiZWJ","substring","RI","endsWithOddNumberOfRIs","isBoundaryPair","SPACE","PUNCTUATION","CHAMELEON","splitByCharacterDistance","dist","at","isWordCharacter","remaining","test","charDist","nextChar","nextRemaining","end","char1","charAt","isLowSurrogate","charCodeAt","char2","isHighSurrogate","charCode","reExtend","rePrepend","reSpacingMark","reL","reV","reT","reLV","reLVT","reExtPict","Any","search","Extend","Prepend","SpacingMark","V","LV","LVT","NonBoundaryPairs","findIndex","endingEmojiZWJ","endingRIs","match","isElement","Node","isNodeList","children","Editor","isEditor","Element","isAncestor","isElementList","every","val","isElementProps","props","isElementType","elementVal","elementKey","matches","element","_excluded$4","_excluded2$3","ownKeys$8","object","enumerableOnly","symbols","filter","sym","_objectSpread$8","defineProperties","IS_EDITOR_CACHE","above","editor","options","voids","mode","selection","reverse","levels","Text","isText","Path","equals","addMark","after","range","anchor","point","edge","focus","positions","before","start","deleteBackward","unit","deleteForward","deleteFragment","direction","edges","first","node","fragment","hasBlocks","some","isBlock","hasInlines","isInline","hasTexts","insertBreak","insertSoftBreak","insertFragment","insertNode","insertText","text","cachedIsEditor","isVoid","normalizeNode","onChange","removeMark","getDirtyPaths","marks","Range","isRange","Operation","isOperationList","operations","isEnd","Point","isEdge","isStart","isEmpty","isNormalizing","offset","last","leaf","isExpanded","nodes","_node","prev","previous","block","prevNode","prevPath","blockPath","next","pointAfterLocation","to","span","isPath","parent","includes","universal","Span","isSpan","hit","nodeEntries","pass","_ref","isLower","compare","emit","normalize","force","popDirtyPath","pop","join","getDirtyPathKeys","allPaths","_ref2","allPathKeys","map","withoutNormalizing","dirtyPath","entry","max","_dirtyPath","_entry","parentPath","depth","firstPath","lastPath","common","isPoint","hasPath","pathRef","affinity","ref","current","unref","pathRefs","refs","pointRef","pointRefs","isNewBlock","blockText","leafTextRemaining","leafTextOffset","string","isFirst","calcDistance","started","getWordDistance","pointBeforeLocation","rangeRef","rangeRefs","setNormalizing","unhangRange","isCollapsed","endBlock","skip","isBefore","_excluded$3","_excluded2$2","IS_NODE_LIST_CACHE","ancestor","root","Scrubber","stringify","ancestors","child","index","childPath","another","descendant","descendants","elements","extractProps","newRoot","splice","_leaf","isNode","cachedResult","isTextProps","visited","isAfter","newPath","nextIndex","texts","ownKeys$7","_objectSpread$7","isNodeOperation","isOperation","endsWith","position","properties","newProperties","isSelectionOperation","isTextOperation","inverse","isSibling","inversePath","transform","inverseNewPath","_properties","_newProperties","paths","av","min","Math","endsAfter","as","bs","bv","endsAt","endsBefore","hasPrevious","isChild","isCommon","isDescendant","isParent","list","operationCanTransformPath","operation","relative","_op","_op2","_op3","_position","_op4","onp","copy","ownKeys$6","_objectSpread$6","result","_excluded$2","ownKeys$5","isBackward","rs","re","ts","te","isAfterStart","isBeforeEnd","intersection","rest","s1","e1","s2","e2","_objectSpread$5","isForward","points","affinityAnchor","affinityFocus","_scrubber","setScrubber","scrubber","JSON","isDeepEqual","_key","_excluded$1","_excluded2$1","ownKeys$4","_objectSpread$4","loose","omitText","isTextList","decorations","leaves","dec","leafEnd","decorationStart","decorationEnd","leafStart","assign","middle","off","_off","ownKeys$3","_objectSpread$3","GeneralTransforms","_path","_point","_path2","_node2","_parent","_index","_point2","_key2","_path3","_node3","_parent2","_index2","truePath","newParent","newIndex","_point3","_key3","_path4","_index3","_point4","_key4","_prev","preferNext","_path5","_offset","_text","_node4","_before","_after","_point5","_key5","_path6","_node5","_key6","_key7","_key8","_value","_path7","newNode","_node6","_parent4","_index4","_before2","_after2","_before3","_after3","_point6","_key9","applyToDraft","_excluded$5","_excluded2","ownKeys$2","_objectSpread$2","NodeTransforms","insertNodes","hanging","select","Transforms","_matchPath","isAtEnd","splitNodes","void","liftNodes","matchPath","parentNodeEntry","toPath","moveNodes","removeNodes","_toPath","splitPath","_toPath2","mergeNodes","commonPath","isPreviousSibling","emptyAncestor","hasSingleChildNest","emptyRef","toRef","targets","_ref3","depths","_ref4","setNodes","merge","split","splitMode","endAtEndOfNode","always","startAtStartOfNode","prop","nodeProp","hasChanges","height","deleteRange","afterRef","beforeRef","highest","voidMatch","voidNode","voidPath","afterPath","highestPath","lowestPath","_afterRef","unsetNodes","unwrapNodes","_ref5","_loop","wrapNodes","roots","rootPath","_ret","commonNodeEntry","commonNode","wrapperPath","wrapper","ownKeys$1","_objectSpread$1","SelectionTransforms","collapse","deselect","move","opts","setSelection","setPoint","oldProps","newProps","TextTransforms","furthestVoid","_end","endOfDoc","startBlock","isAcrossBlocks","isSingleText","startVoid","endVoid","startRef","endRef","removedText","startUnref","endUnref","inlineElementMatch","_inlinePath","blockMatch","isBlockStart","isBlockEnd","isBlockEmpty","mergeStart","mergeEnd","matcher","starts","middles","ends","starting","inlineMatch","inlinePath","isInlineStart","isInlineEnd","middleRef","_end2","startPoint","endPoint","_objectSpread","styles$2","css","insertAt","document","head","getElementsByTagName","style","createElement","firstChild","insertBefore","appendChild","styleSheet","cssText","createTextNode","styleInject$2","DateLabel","relativeTimeFormatter","date","className","utcDate","Date","UTC","getUTCFullYear","getUTCMonth","getUTCDate","getUTCHours","getUTCMinutes","getUTCSeconds","format","formatRelativeDate","_extends","_objectWithoutProperties","_objectWithoutPropertiesLoose","propTypes","styles$1","styleInject$1","_excluded","LikeButton","_ref$isReadOnly","isReadOnly","_ref$isLiked","isLiked","_ref$amount","amount","content","_ref$btnState","btnState","leftIcon","iconComponent","secondary","screenReaderText","onClick","styles","styleInject","OrganizerUpdatePreview","organizerUpdateTitle","organizerUpdateContent","id","likeButtonProps","clickHandler","plainTextContent","description","newPlainText","getPlainTextDescription","tabIndex","onKeyDown","event","preventDefault","size","Header","Content","Footer"],"sourceRoot":""}