← Back
Editing: activity-sidebar.mjs.map
{"version":3,"mappings":";yMAAA,MAAeA,GAAA,sICEf,OAAO,kBAAoB,CAAE,EAC7B,OAAO,gBAAgB,OAAS,CAAE,EAClC,MAAMC,GAAgB,OAAO,gBAAgB,KACvCC,GAASC,GAAgB,EAAG,OAAO,kBAAkB,EAAE,WAAY,EAAC,MAAO,0ECkBjF,IAAIC,EAAI,OAAO,SAAY,SAAW,QAAU,KAC5CC,EAAeD,GAAK,OAAOA,EAAE,OAAU,WACvCA,EAAE,MACF,SAAsBE,EAAQC,EAAUC,EAAM,CAC9C,OAAO,SAAS,UAAU,MAAM,KAAKF,EAAQC,EAAUC,CAAI,CAC/D,EAEIC,EACAL,GAAK,OAAOA,EAAE,SAAY,WAC5BK,EAAiBL,EAAE,QACV,OAAO,sBAChBK,EAAiB,SAAwBH,EAAQ,CAC/C,OAAO,OAAO,oBAAoBA,CAAM,EACrC,OAAO,OAAO,sBAAsBA,CAAM,CAAC,CAC/C,EAEDG,EAAiB,SAAwBH,EAAQ,CAC/C,OAAO,OAAO,oBAAoBA,CAAM,CACzC,EAGH,SAASI,EAAmBC,EAAS,CAC/B,SAAW,QAAQ,MAAM,QAAQ,KAAKA,CAAO,CACnD,CAEA,IAAIC,EAAc,OAAO,OAAS,SAAqBC,EAAO,CAC5D,OAAOA,IAAUA,CACnB,EAEA,SAASC,GAAe,CACtBA,EAAa,KAAK,KAAK,IAAI,CAC7B,CACAC,GAAA,QAAiBD,EACjBC,GAAA,aAAsBC,EAGtBF,EAAa,aAAeA,EAE5BA,EAAa,UAAU,QAAU,OACjCA,EAAa,UAAU,aAAe,EACtCA,EAAa,UAAU,cAAgB,OAIvC,IAAIG,EAAsB,GAE1B,SAASC,EAAcC,EAAU,CAC/B,GAAI,OAAOA,GAAa,WACtB,MAAM,IAAI,UAAU,mEAAqE,OAAOA,CAAQ,CAE5G,CAEA,OAAO,eAAeL,EAAc,sBAAuB,CACzD,WAAY,GACZ,IAAK,UAAW,CACd,OAAOG,CACR,EACD,IAAK,SAASG,EAAK,CACjB,GAAI,OAAOA,GAAQ,UAAYA,EAAM,GAAKR,EAAYQ,CAAG,EACvD,MAAM,IAAI,WAAW,kGAAoGA,EAAM,GAAG,EAEpIH,EAAsBG,CAC1B,CACA,CAAC,EAEDN,EAAa,KAAO,UAAW,EAEzB,KAAK,UAAY,QACjB,KAAK,UAAY,OAAO,eAAe,IAAI,EAAE,WAC/C,KAAK,QAAU,OAAO,OAAO,IAAI,EACjC,KAAK,aAAe,GAGtB,KAAK,cAAgB,KAAK,eAAiB,MAC5C,EAIDA,EAAa,UAAU,gBAAkB,SAAyBO,EAAG,CACnE,GAAI,OAAOA,GAAM,UAAYA,EAAI,GAAKT,EAAYS,CAAC,EACjD,MAAM,IAAI,WAAW,gFAAkFA,EAAI,GAAG,EAEhH,YAAK,cAAgBA,EACd,IACR,EAED,SAASC,EAAiBC,EAAM,CAC9B,OAAIA,EAAK,gBAAkB,OAClBT,EAAa,oBACfS,EAAK,aACd,CAEAT,EAAa,UAAU,gBAAkB,UAA2B,CAClE,OAAOQ,EAAiB,IAAI,CAC7B,EAEDR,EAAa,UAAU,KAAO,SAAcU,EAAM,CAEhD,QADIhB,EAAO,CAAE,EACJiB,EAAI,EAAGA,EAAI,UAAU,OAAQA,IAAKjB,EAAK,KAAK,UAAUiB,CAAC,CAAC,EACjE,IAAIC,EAAWF,IAAS,QAEpBG,EAAS,KAAK,QAClB,GAAIA,IAAW,OACbD,EAAWA,GAAWC,EAAO,QAAU,eAChC,CAACD,EACR,MAAO,GAGT,GAAIA,EAAS,CACX,IAAIE,EAGJ,GAFIpB,EAAK,OAAS,IAChBoB,EAAKpB,EAAK,CAAC,GACToB,aAAc,MAGhB,MAAMA,EAGR,IAAIC,EAAM,IAAI,MAAM,oBAAsBD,EAAK,KAAOA,EAAG,QAAU,IAAM,GAAG,EAC5E,MAAAC,EAAI,QAAUD,EACRC,CACV,CAEE,IAAIC,EAAUH,EAAOH,CAAI,EAEzB,GAAIM,IAAY,OACd,MAAO,GAET,GAAI,OAAOA,GAAY,WACrBzB,EAAayB,EAAS,KAAMtB,CAAI,MAIhC,SAFIuB,EAAMD,EAAQ,OACdE,EAAYC,EAAWH,EAASC,CAAG,EAC9BN,EAAI,EAAGA,EAAIM,EAAK,EAAEN,EACzBpB,EAAa2B,EAAUP,CAAC,EAAG,KAAMjB,CAAI,EAGzC,MAAO,EACR,EAED,SAAS0B,EAAa5B,EAAQkB,EAAML,EAAUgB,EAAS,CACrD,IAAIC,EACAT,EACAU,EAsBJ,GApBAnB,EAAcC,CAAQ,EAEtBQ,EAASrB,EAAO,QACZqB,IAAW,QACbA,EAASrB,EAAO,QAAU,OAAO,OAAO,IAAI,EAC5CA,EAAO,aAAe,IAIlBqB,EAAO,cAAgB,SACzBrB,EAAO,KAAK,cAAekB,EACfL,EAAS,SAAWA,EAAS,SAAWA,CAAQ,EAI5DQ,EAASrB,EAAO,SAElB+B,EAAWV,EAAOH,CAAI,GAGpBa,IAAa,OAEfA,EAAWV,EAAOH,CAAI,EAAIL,EAC1B,EAAEb,EAAO,qBAEL,OAAO+B,GAAa,WAEtBA,EAAWV,EAAOH,CAAI,EACpBW,EAAU,CAAChB,EAAUkB,CAAQ,EAAI,CAACA,EAAUlB,CAAQ,EAE7CgB,EACTE,EAAS,QAAQlB,CAAQ,EAEzBkB,EAAS,KAAKlB,CAAQ,EAIxBiB,EAAId,EAAiBhB,CAAM,EACvB8B,EAAI,GAAKC,EAAS,OAASD,GAAK,CAACC,EAAS,OAAQ,CACpDA,EAAS,OAAS,GAGlB,IAAIC,EAAI,IAAI,MAAM,+CACED,EAAS,OAAS,IAAM,OAAOb,CAAI,EAAI,mEAEvB,EACpCc,EAAE,KAAO,8BACTA,EAAE,QAAUhC,EACZgC,EAAE,KAAOd,EACTc,EAAE,MAAQD,EAAS,OACnB3B,EAAmB4B,CAAC,CAC1B,CAGE,OAAOhC,CACT,CAEAQ,EAAa,UAAU,YAAc,SAAqBU,EAAML,EAAU,CACxE,OAAOe,EAAa,KAAMV,EAAML,EAAU,EAAK,CAChD,EAEDL,EAAa,UAAU,GAAKA,EAAa,UAAU,YAEnDA,EAAa,UAAU,gBACnB,SAAyBU,EAAML,EAAU,CACvC,OAAOe,EAAa,KAAMV,EAAML,EAAU,EAAI,CAC/C,EAEL,SAASoB,GAAc,CACrB,GAAI,CAAC,KAAK,MAGR,OAFA,KAAK,OAAO,eAAe,KAAK,KAAM,KAAK,MAAM,EACjD,KAAK,MAAQ,GACT,UAAU,SAAW,EAChB,KAAK,SAAS,KAAK,KAAK,MAAM,EAChC,KAAK,SAAS,MAAM,KAAK,OAAQ,SAAS,CAErD,CAEA,SAASC,EAAUlC,EAAQkB,EAAML,EAAU,CACzC,IAAIsB,EAAQ,CAAE,MAAO,GAAO,OAAQ,OAAW,OAAQnC,EAAQ,KAAMkB,EAAM,SAAUL,CAAU,EAC3FuB,EAAUH,EAAY,KAAKE,CAAK,EACpC,OAAAC,EAAQ,SAAWvB,EACnBsB,EAAM,OAASC,EACRA,CACT,CAEA5B,EAAa,UAAU,KAAO,SAAcU,EAAML,EAAU,CAC1D,OAAAD,EAAcC,CAAQ,EACtB,KAAK,GAAGK,EAAMgB,EAAU,KAAMhB,EAAML,CAAQ,CAAC,EACtC,IACR,EAEDL,EAAa,UAAU,oBACnB,SAA6BU,EAAML,EAAU,CAC3C,OAAAD,EAAcC,CAAQ,EACtB,KAAK,gBAAgBK,EAAMgB,EAAU,KAAMhB,EAAML,CAAQ,CAAC,EACnD,IACR,EAGLL,EAAa,UAAU,eACnB,SAAwBU,EAAML,EAAU,CACtC,IAAIwB,EAAMhB,EAAQiB,EAAUnB,EAAGoB,EAK/B,GAHA3B,EAAcC,CAAQ,EAEtBQ,EAAS,KAAK,QACVA,IAAW,OACb,OAAO,KAGT,GADAgB,EAAOhB,EAAOH,CAAI,EACdmB,IAAS,OACX,OAAO,KAET,GAAIA,IAASxB,GAAYwB,EAAK,WAAaxB,EACrC,EAAE,KAAK,eAAiB,EAC1B,KAAK,QAAU,OAAO,OAAO,IAAI,GAEjC,OAAOQ,EAAOH,CAAI,EACdG,EAAO,gBACT,KAAK,KAAK,iBAAkBH,EAAMmB,EAAK,UAAYxB,CAAQ,WAEtD,OAAOwB,GAAS,WAAY,CAGrC,IAFAC,EAAW,GAENnB,EAAIkB,EAAK,OAAS,EAAGlB,GAAK,EAAGA,IAChC,GAAIkB,EAAKlB,CAAC,IAAMN,GAAYwB,EAAKlB,CAAC,EAAE,WAAaN,EAAU,CACzD0B,EAAmBF,EAAKlB,CAAC,EAAE,SAC3BmB,EAAWnB,EACX,KACZ,CAGQ,GAAImB,EAAW,EACb,OAAO,KAELA,IAAa,EACfD,EAAK,MAAO,EAEZG,EAAUH,EAAMC,CAAQ,EAGtBD,EAAK,SAAW,IAClBhB,EAAOH,CAAI,EAAImB,EAAK,CAAC,GAEnBhB,EAAO,iBAAmB,QAC5B,KAAK,KAAK,iBAAkBH,EAAMqB,GAAoB1B,CAAQ,CACxE,CAEM,OAAO,IACR,EAELL,EAAa,UAAU,IAAMA,EAAa,UAAU,eAEpDA,EAAa,UAAU,mBACnB,SAA4BU,EAAM,CAChC,IAAIQ,EAAWL,EAAQF,EAGvB,GADAE,EAAS,KAAK,QACVA,IAAW,OACb,OAAO,KAGT,GAAIA,EAAO,iBAAmB,OAC5B,OAAI,UAAU,SAAW,GACvB,KAAK,QAAU,OAAO,OAAO,IAAI,EACjC,KAAK,aAAe,GACXA,EAAOH,CAAI,IAAM,SACtB,EAAE,KAAK,eAAiB,EAC1B,KAAK,QAAU,OAAO,OAAO,IAAI,EAEjC,OAAOG,EAAOH,CAAI,GAEf,KAIT,GAAI,UAAU,SAAW,EAAG,CAC1B,IAAIuB,EAAO,OAAO,KAAKpB,CAAM,EACzBqB,EACJ,IAAKvB,EAAI,EAAGA,EAAIsB,EAAK,OAAQ,EAAEtB,EAC7BuB,EAAMD,EAAKtB,CAAC,EACRuB,IAAQ,kBACZ,KAAK,mBAAmBA,CAAG,EAE7B,YAAK,mBAAmB,gBAAgB,EACxC,KAAK,QAAU,OAAO,OAAO,IAAI,EACjC,KAAK,aAAe,EACb,IACf,CAIM,GAFAhB,EAAYL,EAAOH,CAAI,EAEnB,OAAOQ,GAAc,WACvB,KAAK,eAAeR,EAAMQ,CAAS,UAC1BA,IAAc,OAEvB,IAAKP,EAAIO,EAAU,OAAS,EAAGP,GAAK,EAAGA,IACrC,KAAK,eAAeD,EAAMQ,EAAUP,CAAC,CAAC,EAI1C,OAAO,IACR,EAEL,SAASwB,EAAW3C,EAAQkB,EAAM0B,EAAQ,CACxC,IAAIvB,EAASrB,EAAO,QAEpB,GAAIqB,IAAW,OACb,MAAO,CAAE,EAEX,IAAIwB,EAAaxB,EAAOH,CAAI,EAC5B,OAAI2B,IAAe,OACV,CAAE,EAEP,OAAOA,GAAe,WACjBD,EAAS,CAACC,EAAW,UAAYA,CAAU,EAAI,CAACA,CAAU,EAE5DD,EACLE,EAAgBD,CAAU,EAAIlB,EAAWkB,EAAYA,EAAW,MAAM,CAC1E,CAEArC,EAAa,UAAU,UAAY,SAAmBU,EAAM,CAC1D,OAAOyB,EAAW,KAAMzB,EAAM,EAAI,CACnC,EAEDV,EAAa,UAAU,aAAe,SAAsBU,EAAM,CAChE,OAAOyB,EAAW,KAAMzB,EAAM,EAAK,CACpC,EAEDV,EAAa,cAAgB,SAASuC,EAAS7B,EAAM,CACnD,OAAI,OAAO6B,EAAQ,eAAkB,WAC5BA,EAAQ,cAAc7B,CAAI,EAE1B8B,EAAc,KAAKD,EAAS7B,CAAI,CAE1C,EAEDV,EAAa,UAAU,cAAgBwC,EACvC,SAASA,EAAc9B,EAAM,CAC3B,IAAIG,EAAS,KAAK,QAElB,GAAIA,IAAW,OAAW,CACxB,IAAIwB,EAAaxB,EAAOH,CAAI,EAE5B,GAAI,OAAO2B,GAAe,WACxB,MACK,MAAIA,IAAe,OACxB,OAAOA,EAAW,MAExB,CAEE,MACF,GAEArC,EAAa,UAAU,WAAa,UAAsB,CACxD,OAAO,KAAK,aAAe,EAAIL,EAAe,KAAK,OAAO,EAAI,CAAE,CACjE,EAED,SAASwB,EAAWsB,EAAKlC,EAAG,CAE1B,QADImC,EAAO,IAAI,MAAMnC,CAAC,EACbI,EAAI,EAAGA,EAAIJ,EAAG,EAAEI,EACvB+B,EAAK/B,CAAC,EAAI8B,EAAI9B,CAAC,EACjB,OAAO+B,CACT,CAEA,SAASV,EAAUH,EAAMc,EAAO,CAC9B,KAAOA,EAAQ,EAAId,EAAK,OAAQc,IAC9Bd,EAAKc,CAAK,EAAId,EAAKc,EAAQ,CAAC,EAC9Bd,EAAK,IAAK,CACZ,CAEA,SAASS,EAAgBG,EAAK,CAE5B,QADIG,EAAM,IAAI,MAAMH,EAAI,MAAM,EACrB9B,EAAI,EAAGA,EAAIiC,EAAI,OAAQ,EAAEjC,EAChCiC,EAAIjC,CAAC,EAAI8B,EAAI9B,CAAC,EAAE,UAAY8B,EAAI9B,CAAC,EAEnC,OAAOiC,CACT,CAEA,SAAS1C,EAAKqC,EAASM,EAAM,CAC3B,OAAO,IAAI,QAAQ,SAAUC,EAASC,EAAQ,CAC5C,SAASC,EAAcjC,EAAK,CAC1BwB,EAAQ,eAAeM,EAAMI,CAAQ,EACrCF,EAAOhC,CAAG,CAChB,CAEI,SAASkC,GAAW,CACd,OAAOV,EAAQ,gBAAmB,YACpCA,EAAQ,eAAe,QAASS,CAAa,EAE/CF,EAAQ,GAAG,MAAM,KAAK,SAAS,CAAC,EAGlCI,EAA+BX,EAASM,EAAMI,EAAU,CAAE,KAAM,GAAM,EAClEJ,IAAS,SACXM,EAA8BZ,EAASS,EAAe,CAAE,KAAM,EAAI,CAAE,CAE1E,CAAG,CACH,CAEA,SAASG,EAA8BZ,EAASvB,EAASoC,EAAO,CAC1D,OAAOb,EAAQ,IAAO,YACxBW,EAA+BX,EAAS,QAASvB,EAASoC,CAAK,CAEnE,CAEA,SAASF,EAA+BX,EAASM,EAAMxC,EAAU+C,EAAO,CACtE,GAAI,OAAOb,EAAQ,IAAO,WACpBa,EAAM,KACRb,EAAQ,KAAKM,EAAMxC,CAAQ,EAE3BkC,EAAQ,GAAGM,EAAMxC,CAAQ,UAElB,OAAOkC,EAAQ,kBAAqB,WAG7CA,EAAQ,iBAAiBM,EAAM,SAASQ,EAAa/C,EAAK,CAGpD8C,EAAM,MACRb,EAAQ,oBAAoBM,EAAMQ,CAAY,EAEhDhD,EAASC,CAAG,CAClB,CAAK,aAEK,IAAI,UAAU,sEAAwE,OAAOiC,CAAO,CAE9G,yEChfI,OAAO,OAAO,QAAW,WAE3Be,GAAA,QAAiB,SAAkBC,EAAMC,EAAW,CAC9CA,IACFD,EAAK,OAASC,EACdD,EAAK,UAAY,OAAO,OAAOC,EAAU,UAAW,CAClD,YAAa,CACX,MAAOD,EACP,WAAY,GACZ,SAAU,GACV,aAAc,EACxB,CACO,GAEJ,EAGDD,GAAA,QAAiB,SAAkBC,EAAMC,EAAW,CAClD,GAAIA,EAAW,CACbD,EAAK,OAASC,EACd,IAAIC,EAAW,UAAY,GAC3BA,EAAS,UAAYD,EAAU,UAC/BD,EAAK,UAAY,IAAIE,EACrBF,EAAK,UAAU,YAAcA,CACnC,CACA,uDCzBcG,GAAGC,GAAiB,EAAC,0ECEnC,OAAO,iBAAiBC,EAAS,CAAE,WAAY,CAAE,MAAO,IAAQ,CAAC,OAAO,WAAW,EAAG,CAAE,MAAO,QAAU,EAAE,EAE3G,IAAIC,EAAS,CAAE,EAEXC,EAAW,CAAE,EAEjBA,EAAS,WAAaC,EACtBD,EAAS,YAAcE,EACvBF,EAAS,cAAgBG,EAOzB,QALIC,EAAS,CAAE,EACXC,EAAY,CAAE,EACdC,EAAM,OAAO,WAAe,IAAc,WAAa,MAEvDC,EAAO,mEACF1D,EAAI,EAAGM,EAAMoD,EAAK,OAAQ1D,EAAIM,EAAK,EAAEN,EAC5CuD,EAAOvD,CAAC,EAAI0D,EAAK1D,CAAC,EAClBwD,EAAUE,EAAK,WAAW1D,CAAC,CAAC,EAAIA,EAKlCwD,EAAU,EAAiB,EAAI,GAC/BA,EAAU,EAAiB,EAAI,GAE/B,SAASG,EAASC,EAAK,CACrB,IAAItD,EAAMsD,EAAI,OAEd,GAAItD,EAAM,EAAI,EACZ,MAAM,IAAI,MAAM,gDAAgD,EAKlE,IAAIuD,EAAWD,EAAI,QAAQ,GAAG,EAC1BC,IAAa,KAAIA,EAAWvD,GAEhC,IAAIwD,EAAkBD,IAAavD,EAC/B,EACA,EAAKuD,EAAW,EAEpB,MAAO,CAACA,EAAUC,CAAe,CACnC,CAGA,SAASV,EAAYQ,EAAK,CACxB,IAAIG,EAAOJ,EAAQC,CAAG,EAClBC,EAAWE,EAAK,CAAC,EACjBD,EAAkBC,EAAK,CAAC,EAC5B,OAASF,EAAWC,GAAmB,EAAI,EAAKA,CAClD,CAEA,SAASE,EAAaJ,EAAKC,EAAUC,EAAiB,CACpD,OAASD,EAAWC,GAAmB,EAAI,EAAKA,CAClD,CAEA,SAAST,EAAaO,EAAK,CACzB,IAAIK,EACAF,EAAOJ,EAAQC,CAAG,EAClBC,EAAWE,EAAK,CAAC,EACjBD,EAAkBC,EAAK,CAAC,EAExBjC,EAAM,IAAI2B,EAAIO,EAAYJ,EAAKC,EAAUC,CAAe,CAAC,EAEzDI,EAAU,EAGV5D,EAAMwD,EAAkB,EACxBD,EAAW,EACXA,EAEA7D,EACJ,IAAKA,EAAI,EAAGA,EAAIM,EAAKN,GAAK,EACxBiE,EACGT,EAAUI,EAAI,WAAW5D,CAAC,CAAC,GAAK,GAChCwD,EAAUI,EAAI,WAAW5D,EAAI,CAAC,CAAC,GAAK,GACpCwD,EAAUI,EAAI,WAAW5D,EAAI,CAAC,CAAC,GAAK,EACrCwD,EAAUI,EAAI,WAAW5D,EAAI,CAAC,CAAC,EACjC8B,EAAIoC,GAAS,EAAKD,GAAO,GAAM,IAC/BnC,EAAIoC,GAAS,EAAKD,GAAO,EAAK,IAC9BnC,EAAIoC,GAAS,EAAID,EAAM,IAGzB,OAAIH,IAAoB,IACtBG,EACGT,EAAUI,EAAI,WAAW5D,CAAC,CAAC,GAAK,EAChCwD,EAAUI,EAAI,WAAW5D,EAAI,CAAC,CAAC,GAAK,EACvC8B,EAAIoC,GAAS,EAAID,EAAM,KAGrBH,IAAoB,IACtBG,EACGT,EAAUI,EAAI,WAAW5D,CAAC,CAAC,GAAK,GAChCwD,EAAUI,EAAI,WAAW5D,EAAI,CAAC,CAAC,GAAK,EACpCwD,EAAUI,EAAI,WAAW5D,EAAI,CAAC,CAAC,GAAK,EACvC8B,EAAIoC,GAAS,EAAKD,GAAO,EAAK,IAC9BnC,EAAIoC,GAAS,EAAID,EAAM,KAGlBnC,CACT,CAEA,SAASqC,EAAiBC,EAAK,CAC7B,OAAOb,EAAOa,GAAO,GAAK,EAAI,EAC5Bb,EAAOa,GAAO,GAAK,EAAI,EACvBb,EAAOa,GAAO,EAAI,EAAI,EACtBb,EAAOa,EAAM,EAAI,CACrB,CAEA,SAASC,EAAaC,EAAOC,EAAOC,EAAK,CAGvC,QAFIP,EACAQ,EAAS,CAAE,EACNzE,EAAIuE,EAAOvE,EAAIwE,EAAKxE,GAAK,EAChCiE,GACIK,EAAMtE,CAAC,GAAK,GAAM,WAClBsE,EAAMtE,EAAI,CAAC,GAAK,EAAK,QACtBsE,EAAMtE,EAAI,CAAC,EAAI,KAClByE,EAAO,KAAKN,EAAgBF,CAAG,CAAC,EAElC,OAAOQ,EAAO,KAAK,EAAE,CACvB,CAEA,SAASnB,EAAegB,EAAO,CAQ7B,QAPIL,EACA3D,EAAMgE,EAAM,OACZI,EAAapE,EAAM,EACnBqE,EAAQ,CAAE,EACVC,EAAiB,MAGZ5E,EAAI,EAAG6E,EAAOvE,EAAMoE,EAAY1E,EAAI6E,EAAM7E,GAAK4E,EACtDD,EAAM,KAAKN,EAAYC,EAAOtE,EAAIA,EAAI4E,EAAkBC,EAAOA,EAAQ7E,EAAI4E,CAAe,CAAC,EAI7F,OAAIF,IAAe,GACjBT,EAAMK,EAAMhE,EAAM,CAAC,EACnBqE,EAAM,KACJpB,EAAOU,GAAO,CAAC,EACfV,EAAQU,GAAO,EAAK,EAAI,EACxB,IACD,GACQS,IAAe,IACxBT,GAAOK,EAAMhE,EAAM,CAAC,GAAK,GAAKgE,EAAMhE,EAAM,CAAC,EAC3CqE,EAAM,KACJpB,EAAOU,GAAO,EAAE,EAChBV,EAAQU,GAAO,EAAK,EAAI,EACxBV,EAAQU,GAAO,EAAK,EAAI,EACxB,GACD,GAGIU,EAAM,KAAK,EAAE,CACtB,CAEA,IAAIG,EAAU,CAAE,EAIhBA,EAAQ,KAAO,SAAU5B,EAAQ6B,EAAQC,EAAMC,EAAMC,EAAQ,CAC3D,IAAIC,EAAGxE,EACHyE,EAAQF,EAAS,EAAKD,EAAO,EAC7BI,GAAQ,GAAKD,GAAQ,EACrBE,EAAQD,GAAQ,EAChBE,EAAQ,GACRvF,EAAIgF,EAAQE,EAAS,EAAK,EAC1BM,GAAIR,EAAO,GAAK,EAChBS,GAAIvC,EAAO6B,EAAS/E,CAAC,EAOzB,IALAA,GAAKwF,GAELL,EAAIM,IAAM,GAAM,CAACF,GAAU,EAC3BE,KAAO,CAACF,EACRA,GAASH,EACFG,EAAQ,EAAGJ,EAAKA,EAAI,IAAOjC,EAAO6B,EAAS/E,CAAC,EAAGA,GAAKwF,GAAGD,GAAS,EAAG,CAK1E,IAHA5E,EAAIwE,GAAM,GAAM,CAACI,GAAU,EAC3BJ,IAAO,CAACI,EACRA,GAASN,EACFM,EAAQ,EAAG5E,EAAKA,EAAI,IAAOuC,EAAO6B,EAAS/E,CAAC,EAAGA,GAAKwF,GAAGD,GAAS,EAAG,CAE1E,GAAIJ,IAAM,EACRA,EAAI,EAAIG,MACH,IAAIH,IAAME,EACf,OAAO1E,EAAI,KAAQ8E,GAAI,GAAK,GAE5B9E,QAAIA,EAAI,KAAK,IAAI,EAAGsE,CAAI,EACxBE,EAAIA,EAAIG,EAEV,OAAQG,GAAI,GAAK,GAAK9E,EAAI,KAAK,IAAI,EAAGwE,EAAIF,CAAI,CAC/C,EAEDH,EAAQ,MAAQ,SAAU5B,EAAQ9D,EAAO2F,EAAQC,EAAMC,EAAMC,EAAQ,CACnE,IAAIC,EAAGxE,EAAG+E,EACNN,EAAQF,EAAS,EAAKD,EAAO,EAC7BI,GAAQ,GAAKD,GAAQ,EACrBE,EAAQD,GAAQ,EAChBM,GAAMV,IAAS,GAAK,KAAK,IAAI,EAAG,GAAG,EAAI,KAAK,IAAI,EAAG,GAAG,EAAI,EAC1DjF,GAAIgF,EAAO,EAAKE,EAAS,EACzBM,GAAIR,EAAO,EAAI,GACfS,EAAIrG,EAAQ,GAAMA,IAAU,GAAK,EAAIA,EAAQ,EAAK,EAAI,EAmC1D,IAjCAA,EAAQ,KAAK,IAAIA,CAAK,EAElB,MAAMA,CAAK,GAAKA,IAAU,KAC5BuB,EAAI,MAAMvB,CAAK,EAAI,EAAI,EACvB+F,EAAIE,IAEJF,EAAI,KAAK,MAAM,KAAK,IAAI/F,CAAK,EAAI,KAAK,GAAG,EACrCA,GAASsG,EAAI,KAAK,IAAI,EAAG,CAACP,CAAC,GAAK,IAClCA,IACAO,GAAK,GAEHP,EAAIG,GAAS,EACflG,GAASuG,GAAKD,EAEdtG,GAASuG,GAAK,KAAK,IAAI,EAAG,EAAIL,CAAK,EAEjClG,EAAQsG,GAAK,IACfP,IACAO,GAAK,GAGHP,EAAIG,GAASD,GACf1E,EAAI,EACJwE,EAAIE,GACKF,EAAIG,GAAS,GACtB3E,GAAMvB,EAAQsG,EAAK,GAAK,KAAK,IAAI,EAAGT,CAAI,EACxCE,EAAIA,EAAIG,IAER3E,EAAIvB,EAAQ,KAAK,IAAI,EAAGkG,EAAQ,CAAC,EAAI,KAAK,IAAI,EAAGL,CAAI,EACrDE,EAAI,IAIDF,GAAQ,EAAG/B,EAAO6B,EAAS/E,EAAC,EAAIW,EAAI,IAAMX,IAAKwF,GAAG7E,GAAK,IAAKsE,GAAQ,EAAG,CAI9E,IAFAE,EAAKA,GAAKF,EAAQtE,EAClByE,GAAQH,EACDG,EAAO,EAAGlC,EAAO6B,EAAS/E,EAAC,EAAImF,EAAI,IAAMnF,IAAKwF,GAAGL,GAAK,IAAKC,GAAQ,EAAG,CAE7ElC,EAAO6B,EAAS/E,GAAIwF,EAAC,GAAKC,EAAI,GAC/B,GASA,SAAUxC,EAAS,CAEnB,MAAM2C,EAASzC,EACT0C,EAAYf,EACZgB,EACH,OAAO,QAAW,YAAc,OAAO,OAAO,KAAW,WACtD,OAAO,IAAO,4BAA4B,EAC1C,KAEN7C,EAAQ,OAAS8C,EACjB9C,EAAQ,WAAa+C,EACrB/C,EAAQ,kBAAoB,GAE5B,MAAMgD,EAAe,WACrBhD,EAAQ,WAAagD,EACrB,KAAM,CAAE,WAAYC,EAAkB,YAAaC,EAAmB,kBAAmBC,CAAuB,EAAK,WAgBrHL,EAAO,oBAAsBM,EAAmB,EAE5C,CAACN,EAAO,qBAAuB,OAAO,QAAY,KAClD,OAAO,QAAQ,OAAU,YAC3B,QAAQ,MACN,+IAED,EAGH,SAASM,GAAqB,CAE5B,GAAI,CACF,MAAMvE,EAAM,IAAIoE,EAAiB,CAAC,EAC5BI,EAAQ,CAAE,IAAK,UAAY,CAAE,MAAS,IAAI,EAChD,cAAO,eAAeA,EAAOJ,EAAiB,SAAS,EACvD,OAAO,eAAepE,EAAKwE,CAAK,EACzBxE,EAAI,QAAU,EACtB,MAAW,CACV,MAAO,EACZ,CACA,CAEC,OAAO,eAAeiE,EAAO,UAAW,SAAU,CAChD,WAAY,GACZ,IAAK,UAAY,CACf,GAAKA,EAAO,SAAS,IAAI,EACzB,OAAO,KAAK,MACjB,CACA,CAAE,EAED,OAAO,eAAeA,EAAO,UAAW,SAAU,CAChD,WAAY,GACZ,IAAK,UAAY,CACf,GAAKA,EAAO,SAAS,IAAI,EACzB,OAAO,KAAK,UACjB,CACA,CAAE,EAED,SAASQ,EAAcC,EAAQ,CAC7B,GAAIA,EAASP,EACX,MAAM,IAAI,WAAW,cAAgBO,EAAS,gCAAgC,EAGhF,MAAMC,EAAM,IAAIP,EAAiBM,CAAM,EACvC,cAAO,eAAeC,EAAKV,EAAO,SAAS,EACpCU,CACV,CAYC,SAASV,EAAQpG,EAAK+G,EAAkBF,EAAQ,CAE9C,GAAI,OAAO7G,GAAQ,SAAU,CAC3B,GAAI,OAAO+G,GAAqB,SAC9B,MAAM,IAAI,UACR,oEACT,EAEK,OAAOC,GAAYhH,CAAG,CAC3B,CACG,OAAOiH,EAAKjH,EAAK+G,EAAkBF,CAAM,CAC5C,CAECT,EAAO,SAAW,KAElB,SAASa,EAAMxH,EAAOsH,EAAkBF,EAAQ,CAC9C,GAAI,OAAOpH,GAAU,SACnB,OAAOyH,EAAWzH,EAAOsH,CAAgB,EAG3C,GAAIP,EAAkB,OAAO/G,CAAK,EAChC,OAAO0H,GAAc1H,CAAK,EAG5B,GAAIA,GAAS,KACX,MAAM,IAAI,UACR,kHAC0C,OAAOA,CACxD,EAQG,GALI2H,GAAW3H,EAAO+G,CAAiB,GAClC/G,GAAS2H,GAAW3H,EAAM,OAAQ+G,CAAiB,GAIpD,OAAOC,EAA4B,MAClCW,GAAW3H,EAAOgH,CAAuB,GACzChH,GAAS2H,GAAW3H,EAAM,OAAQgH,CAAuB,GAC5D,OAAOY,GAAgB5H,EAAOsH,EAAkBF,CAAM,EAGxD,GAAI,OAAOpH,GAAU,SACnB,MAAM,IAAI,UACR,uEACP,EAGG,MAAM6H,EAAU7H,EAAM,SAAWA,EAAM,QAAS,EAChD,GAAI6H,GAAW,MAAQA,IAAY7H,EACjC,OAAO2G,EAAO,KAAKkB,EAASP,EAAkBF,CAAM,EAGtD,MAAMU,EAAIC,GAAW/H,CAAK,EAC1B,GAAI8H,EAAG,OAAOA,EAEd,GAAI,OAAO,OAAW,KAAe,OAAO,aAAe,MACvD,OAAO9H,EAAM,OAAO,WAAW,GAAM,WACvC,OAAO2G,EAAO,KAAK3G,EAAM,OAAO,WAAW,EAAE,QAAQ,EAAGsH,EAAkBF,CAAM,EAGlF,MAAM,IAAI,UACR,kHAC0C,OAAOpH,CACtD,CACA,CAUC2G,EAAO,KAAO,SAAU3G,EAAOsH,EAAkBF,EAAQ,CACvD,OAAOI,EAAKxH,EAAOsH,EAAkBF,CAAM,CAC5C,EAID,OAAO,eAAeT,EAAO,UAAWG,EAAiB,SAAS,EAClE,OAAO,eAAeH,EAAQG,CAAgB,EAE9C,SAASkB,GAAYC,EAAM,CACzB,GAAI,OAAOA,GAAS,SAClB,MAAM,IAAI,UAAU,wCAAwC,EACvD,GAAIA,EAAO,EAChB,MAAM,IAAI,WAAW,cAAgBA,EAAO,gCAAgC,CAEjF,CAEC,SAASC,GAAOD,EAAME,EAAMC,EAAU,CAEpC,OADAJ,GAAWC,CAAI,EACXA,GAAQ,EACHd,EAAac,CAAI,EAEtBE,IAAS,OAIJ,OAAOC,GAAa,SACvBjB,EAAac,CAAI,EAAE,KAAKE,EAAMC,CAAQ,EACtCjB,EAAac,CAAI,EAAE,KAAKE,CAAI,EAE3BhB,EAAac,CAAI,CAC3B,CAMCtB,EAAO,MAAQ,SAAUsB,EAAME,EAAMC,EAAU,CAC7C,OAAOF,GAAMD,EAAME,EAAMC,CAAQ,CAClC,EAED,SAASb,GAAaU,EAAM,CAC1B,OAAAD,GAAWC,CAAI,EACRd,EAAac,EAAO,EAAI,EAAII,GAAQJ,CAAI,EAAI,CAAC,CACvD,CAKCtB,EAAO,YAAc,SAAUsB,EAAM,CACnC,OAAOV,GAAYU,CAAI,CACxB,EAIDtB,EAAO,gBAAkB,SAAUsB,EAAM,CACvC,OAAOV,GAAYU,CAAI,CACxB,EAED,SAASR,EAAYa,EAAQF,EAAU,CAKrC,IAJI,OAAOA,GAAa,UAAYA,IAAa,MAC/CA,EAAW,QAGT,CAACzB,EAAO,WAAWyB,CAAQ,EAC7B,MAAM,IAAI,UAAU,qBAAuBA,CAAQ,EAGrD,MAAMhB,EAASpD,EAAWsE,EAAQF,CAAQ,EAAI,EAC9C,IAAIf,EAAMF,EAAaC,CAAM,EAE7B,MAAMmB,EAASlB,EAAI,MAAMiB,EAAQF,CAAQ,EAEzC,OAAIG,IAAWnB,IAIbC,EAAMA,EAAI,MAAM,EAAGkB,CAAM,GAGpBlB,CACV,CAEC,SAASmB,GAAeC,EAAO,CAC7B,MAAMrB,EAASqB,EAAM,OAAS,EAAI,EAAIJ,GAAQI,EAAM,MAAM,EAAI,EACxDpB,EAAMF,EAAaC,CAAM,EAC/B,QAASxG,EAAI,EAAGA,EAAIwG,EAAQxG,GAAK,EAC/ByG,EAAIzG,CAAC,EAAI6H,EAAM7H,CAAC,EAAI,IAEtB,OAAOyG,CACV,CAEC,SAASK,GAAegB,EAAW,CACjC,GAAIf,GAAWe,EAAW5B,CAAgB,EAAG,CAC3C,MAAMnE,EAAO,IAAImE,EAAiB4B,CAAS,EAC3C,OAAOd,GAAgBjF,EAAK,OAAQA,EAAK,WAAYA,EAAK,UAAU,CACzE,CACG,OAAO6F,GAAcE,CAAS,CACjC,CAEC,SAASd,GAAiBa,EAAOE,EAAYvB,EAAQ,CACnD,GAAIuB,EAAa,GAAKF,EAAM,WAAaE,EACvC,MAAM,IAAI,WAAW,sCAAsC,EAG7D,GAAIF,EAAM,WAAaE,GAAcvB,GAAU,GAC7C,MAAM,IAAI,WAAW,sCAAsC,EAG7D,IAAIC,EACJ,OAAIsB,IAAe,QAAavB,IAAW,OACzCC,EAAM,IAAIP,EAAiB2B,CAAK,EACvBrB,IAAW,OACpBC,EAAM,IAAIP,EAAiB2B,EAAOE,CAAU,EAE5CtB,EAAM,IAAIP,EAAiB2B,EAAOE,EAAYvB,CAAM,EAItD,OAAO,eAAeC,EAAKV,EAAO,SAAS,EAEpCU,CACV,CAEC,SAASU,GAAYa,EAAK,CACxB,GAAIjC,EAAO,SAASiC,CAAG,EAAG,CACxB,MAAM1H,EAAMmH,GAAQO,EAAI,MAAM,EAAI,EAC5BvB,EAAMF,EAAajG,CAAG,EAE5B,OAAImG,EAAI,SAAW,GAInBuB,EAAI,KAAKvB,EAAK,EAAG,EAAGnG,CAAG,EAChBmG,CACZ,CAEG,GAAIuB,EAAI,SAAW,OACjB,OAAI,OAAOA,EAAI,QAAW,UAAYC,GAAYD,EAAI,MAAM,EACnDzB,EAAa,CAAC,EAEhBqB,GAAcI,CAAG,EAG1B,GAAIA,EAAI,OAAS,UAAY,MAAM,QAAQA,EAAI,IAAI,EACjD,OAAOJ,GAAcI,EAAI,IAAI,CAElC,CAEC,SAASP,GAASjB,EAAQ,CAGxB,GAAIA,GAAUP,EACZ,MAAM,IAAI,WAAW,0DACaA,EAAa,SAAS,EAAE,EAAI,QAAQ,EAExE,OAAOO,EAAS,CACnB,CAEC,SAASR,EAAYQ,EAAQ,CAC3B,MAAI,CAACA,GAAUA,IACbA,EAAS,GAEJT,EAAO,MAAM,CAACS,CAAM,CAC9B,CAECT,EAAO,SAAW,SAAmBmB,EAAG,CACtC,OAAOA,GAAK,MAAQA,EAAE,YAAc,IAClCA,IAAMnB,EAAO,SAChB,EAEDA,EAAO,QAAU,SAAkBmC,EAAGhB,EAAG,CAGvC,GAFIH,GAAWmB,EAAGhC,CAAgB,IAAGgC,EAAInC,EAAO,KAAKmC,EAAGA,EAAE,OAAQA,EAAE,UAAU,GAC1EnB,GAAWG,EAAGhB,CAAgB,IAAGgB,EAAInB,EAAO,KAAKmB,EAAGA,EAAE,OAAQA,EAAE,UAAU,GAC1E,CAACnB,EAAO,SAASmC,CAAC,GAAK,CAACnC,EAAO,SAASmB,CAAC,EAC3C,MAAM,IAAI,UACR,uEACP,EAGG,GAAIgB,IAAMhB,EAAG,SAEb,IAAIiB,EAAID,EAAE,OACNE,EAAIlB,EAAE,OAEV,QAASlH,EAAI,EAAGM,EAAM,KAAK,IAAI6H,EAAGC,CAAC,EAAGpI,EAAIM,EAAK,EAAEN,EAC/C,GAAIkI,EAAElI,CAAC,IAAMkH,EAAElH,CAAC,EAAG,CACjBmI,EAAID,EAAElI,CAAC,EACPoI,EAAIlB,EAAElH,CAAC,EACP,KACP,CAGG,OAAImI,EAAIC,EAAU,GACdA,EAAID,EAAU,EACX,CACR,EAEDpC,EAAO,WAAa,SAAqByB,EAAU,CACjD,OAAQ,OAAOA,CAAQ,EAAE,YAAa,GACpC,IAAK,MACL,IAAK,OACL,IAAK,QACL,IAAK,QACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,OACL,IAAK,QACL,IAAK,UACL,IAAK,WACH,MAAO,GACT,QACE,MAAO,EACd,CACE,EAEDzB,EAAO,OAAS,SAAiB7E,EAAMsF,EAAQ,CAC7C,GAAI,CAAC,MAAM,QAAQtF,CAAI,EACrB,MAAM,IAAI,UAAU,6CAA6C,EAGnE,GAAIA,EAAK,SAAW,EAClB,OAAO6E,EAAO,MAAM,CAAC,EAGvB,IAAI/F,EACJ,GAAIwG,IAAW,OAEb,IADAA,EAAS,EACJxG,EAAI,EAAGA,EAAIkB,EAAK,OAAQ,EAAElB,EAC7BwG,GAAUtF,EAAKlB,CAAC,EAAE,OAItB,MAAMkD,EAAS6C,EAAO,YAAYS,CAAM,EACxC,IAAI6B,EAAM,EACV,IAAKrI,EAAI,EAAGA,EAAIkB,EAAK,OAAQ,EAAElB,EAAG,CAChC,IAAIyG,EAAMvF,EAAKlB,CAAC,EAChB,GAAI+G,GAAWN,EAAKP,CAAgB,EAC9BmC,EAAM5B,EAAI,OAASvD,EAAO,QACvB6C,EAAO,SAASU,CAAG,IAAGA,EAAMV,EAAO,KAAKU,CAAG,GAChDA,EAAI,KAAKvD,EAAQmF,CAAG,GAEpBnC,EAAiB,UAAU,IAAI,KAC7BhD,EACAuD,EACA4B,CACD,UAEOtC,EAAO,SAASU,CAAG,EAG7BA,EAAI,KAAKvD,EAAQmF,CAAG,MAFd,WAAI,UAAU,6CAA6C,EAInEA,GAAO5B,EAAI,MAChB,CACG,OAAOvD,CACR,EAED,SAASE,EAAYsE,EAAQF,EAAU,CACrC,GAAIzB,EAAO,SAAS2B,CAAM,EACxB,OAAOA,EAAO,OAEhB,GAAIvB,EAAkB,OAAOuB,CAAM,GAAKX,GAAWW,EAAQvB,CAAiB,EAC1E,OAAOuB,EAAO,WAEhB,GAAI,OAAOA,GAAW,SACpB,MAAM,IAAI,UACR,2FACmB,OAAOA,CACjC,EAGG,MAAMpH,EAAMoH,EAAO,OACbY,EAAa,UAAU,OAAS,GAAK,UAAU,CAAC,IAAM,GAC5D,GAAI,CAACA,GAAahI,IAAQ,EAAG,MAAO,GAGpC,IAAIiI,EAAc,GAClB,OACE,OAAQf,EAAQ,CACd,IAAK,QACL,IAAK,SACL,IAAK,SACH,OAAOlH,EACT,IAAK,OACL,IAAK,QACH,OAAOkI,GAAYd,CAAM,EAAE,OAC7B,IAAK,OACL,IAAK,QACL,IAAK,UACL,IAAK,WACH,OAAOpH,EAAM,EACf,IAAK,MACH,OAAOA,IAAQ,EACjB,IAAK,SACH,OAAOmI,GAAcf,CAAM,EAAE,OAC/B,QACE,GAAIa,EACF,OAAOD,EAAY,GAAKE,GAAYd,CAAM,EAAE,OAE9CF,GAAY,GAAKA,GAAU,YAAa,EACxCe,EAAc,EACvB,CAEA,CACCxC,EAAO,WAAa3C,EAEpB,SAASsF,EAAclB,EAAUjD,EAAOC,EAAK,CAC3C,IAAI+D,EAAc,GA8BlB,IArBIhE,IAAU,QAAaA,EAAQ,KACjCA,EAAQ,GAINA,EAAQ,KAAK,UAIbC,IAAQ,QAAaA,EAAM,KAAK,UAClCA,EAAM,KAAK,QAGTA,GAAO,KAKXA,KAAS,EACTD,KAAW,EAEPC,GAAOD,GACT,MAAO,GAKT,IAFKiD,IAAUA,EAAW,UAGxB,OAAQA,EAAQ,CACd,IAAK,MACH,OAAOmB,GAAS,KAAMpE,EAAOC,CAAG,EAElC,IAAK,OACL,IAAK,QACH,OAAOoE,EAAU,KAAMrE,EAAOC,CAAG,EAEnC,IAAK,QACH,OAAOqE,GAAW,KAAMtE,EAAOC,CAAG,EAEpC,IAAK,SACL,IAAK,SACH,OAAOsE,EAAY,KAAMvE,EAAOC,CAAG,EAErC,IAAK,SACH,OAAOuE,EAAY,KAAMxE,EAAOC,CAAG,EAErC,IAAK,OACL,IAAK,QACL,IAAK,UACL,IAAK,WACH,OAAOwE,GAAa,KAAMzE,EAAOC,CAAG,EAEtC,QACE,GAAI+D,EAAa,MAAM,IAAI,UAAU,qBAAuBf,CAAQ,EACpEA,GAAYA,EAAW,IAAI,YAAa,EACxCe,EAAc,EACvB,CAEA,CAQCxC,EAAO,UAAU,UAAY,GAE7B,SAASkD,EAAM/B,EAAGtH,EAAGe,EAAG,CACtB,MAAMX,EAAIkH,EAAEtH,CAAC,EACbsH,EAAEtH,CAAC,EAAIsH,EAAEvG,CAAC,EACVuG,EAAEvG,CAAC,EAAIX,CACV,CAEC+F,EAAO,UAAU,OAAS,UAAmB,CAC3C,MAAMzF,EAAM,KAAK,OACjB,GAAIA,EAAM,IAAM,EACd,MAAM,IAAI,WAAW,2CAA2C,EAElE,QAASN,EAAI,EAAGA,EAAIM,EAAKN,GAAK,EAC5BiJ,EAAK,KAAMjJ,EAAGA,EAAI,CAAC,EAErB,OAAO,IACR,EAED+F,EAAO,UAAU,OAAS,UAAmB,CAC3C,MAAMzF,EAAM,KAAK,OACjB,GAAIA,EAAM,IAAM,EACd,MAAM,IAAI,WAAW,2CAA2C,EAElE,QAASN,EAAI,EAAGA,EAAIM,EAAKN,GAAK,EAC5BiJ,EAAK,KAAMjJ,EAAGA,EAAI,CAAC,EACnBiJ,EAAK,KAAMjJ,EAAI,EAAGA,EAAI,CAAC,EAEzB,OAAO,IACR,EAED+F,EAAO,UAAU,OAAS,UAAmB,CAC3C,MAAMzF,EAAM,KAAK,OACjB,GAAIA,EAAM,IAAM,EACd,MAAM,IAAI,WAAW,2CAA2C,EAElE,QAASN,EAAI,EAAGA,EAAIM,EAAKN,GAAK,EAC5BiJ,EAAK,KAAMjJ,EAAGA,EAAI,CAAC,EACnBiJ,EAAK,KAAMjJ,EAAI,EAAGA,EAAI,CAAC,EACvBiJ,EAAK,KAAMjJ,EAAI,EAAGA,EAAI,CAAC,EACvBiJ,EAAK,KAAMjJ,EAAI,EAAGA,EAAI,CAAC,EAEzB,OAAO,IACR,EAED+F,EAAO,UAAU,SAAW,UAAqB,CAC/C,MAAMS,EAAS,KAAK,OACpB,OAAIA,IAAW,EAAU,GACrB,UAAU,SAAW,EAAUoC,EAAU,KAAM,EAAGpC,CAAM,EACrDkC,EAAa,MAAM,KAAM,SAAS,CAC1C,EAED3C,EAAO,UAAU,eAAiBA,EAAO,UAAU,SAEnDA,EAAO,UAAU,OAAS,SAAiBmB,EAAG,CAC5C,GAAI,CAACnB,EAAO,SAASmB,CAAC,EAAG,MAAM,IAAI,UAAU,2BAA2B,EACxE,OAAI,OAASA,EAAU,GAChBnB,EAAO,QAAQ,KAAMmB,CAAC,IAAM,CACpC,EAEDnB,EAAO,UAAU,QAAU,UAAoB,CAC7C,IAAImD,EAAM,GACV,MAAMC,EAAMlG,EAAQ,kBACpB,OAAAiG,EAAM,KAAK,SAAS,MAAO,EAAGC,CAAG,EAAE,QAAQ,UAAW,KAAK,EAAE,KAAM,EAC/D,KAAK,OAASA,IAAKD,GAAO,SACvB,WAAaA,EAAM,GAC3B,EACGpD,IACFC,EAAO,UAAUD,CAAmB,EAAIC,EAAO,UAAU,SAG3DA,EAAO,UAAU,QAAU,SAAkBlH,EAAQ0F,EAAOC,EAAK4E,EAAWC,EAAS,CAInF,GAHItC,GAAWlI,EAAQqH,CAAgB,IACrCrH,EAASkH,EAAO,KAAKlH,EAAQA,EAAO,OAAQA,EAAO,UAAU,GAE3D,CAACkH,EAAO,SAASlH,CAAM,EACzB,MAAM,IAAI,UACR,iFACoB,OAAOA,CAClC,EAgBG,GAbI0F,IAAU,SACZA,EAAQ,GAENC,IAAQ,SACVA,EAAM3F,EAASA,EAAO,OAAS,GAE7BuK,IAAc,SAChBA,EAAY,GAEVC,IAAY,SACdA,EAAU,KAAK,QAGb9E,EAAQ,GAAKC,EAAM3F,EAAO,QAAUuK,EAAY,GAAKC,EAAU,KAAK,OACtE,MAAM,IAAI,WAAW,oBAAoB,EAG3C,GAAID,GAAaC,GAAW9E,GAASC,EACnC,MAAO,GAET,GAAI4E,GAAaC,EACf,MAAO,GAET,GAAI9E,GAASC,EACX,SAQF,GALAD,KAAW,EACXC,KAAS,EACT4E,KAAe,EACfC,KAAa,EAET,OAASxK,EAAQ,MAAO,GAE5B,IAAIsJ,EAAIkB,EAAUD,EACdhB,EAAI5D,EAAMD,EACd,MAAMjE,GAAM,KAAK,IAAI6H,EAAGC,CAAC,EAEnBkB,GAAW,KAAK,MAAMF,EAAWC,CAAO,EACxCE,GAAa1K,EAAO,MAAM0F,EAAOC,CAAG,EAE1C,QAASxE,GAAI,EAAGA,GAAIM,GAAK,EAAEN,GACzB,GAAIsJ,GAAStJ,EAAC,IAAMuJ,GAAWvJ,EAAC,EAAG,CACjCmI,EAAImB,GAAStJ,EAAC,EACdoI,EAAImB,GAAWvJ,EAAC,EAChB,KACP,CAGG,OAAImI,EAAIC,EAAU,GACdA,EAAID,EAAU,EACX,CACR,EAWD,SAASqB,EAAsBtG,EAAQuG,EAAK1B,EAAYP,EAAUkC,EAAK,CAErE,GAAIxG,EAAO,SAAW,EAAG,MAAO,GAmBhC,GAhBI,OAAO6E,GAAe,UACxBP,EAAWO,EACXA,EAAa,GACJA,EAAa,WACtBA,EAAa,WACJA,EAAa,cACtBA,EAAa,aAEfA,EAAa,CAACA,EACVE,GAAYF,CAAU,IAExBA,EAAa2B,EAAM,EAAKxG,EAAO,OAAS,GAItC6E,EAAa,IAAGA,EAAa7E,EAAO,OAAS6E,GAC7CA,GAAc7E,EAAO,OAAQ,CAC/B,GAAIwG,EAAK,MAAO,GACX3B,EAAa7E,EAAO,OAAS,CACvC,SAAc6E,EAAa,EACtB,GAAI2B,EAAK3B,EAAa,MACV,UASd,GALI,OAAO0B,GAAQ,WACjBA,EAAM1D,EAAO,KAAK0D,EAAKjC,CAAQ,GAI7BzB,EAAO,SAAS0D,CAAG,EAErB,OAAIA,EAAI,SAAW,EACV,GAEFE,EAAazG,EAAQuG,EAAK1B,EAAYP,EAAUkC,CAAG,EACrD,GAAI,OAAOD,GAAQ,SAExB,OADAA,EAAMA,EAAM,IACR,OAAOvD,EAAiB,UAAU,SAAY,WAC5CwD,EACKxD,EAAiB,UAAU,QAAQ,KAAKhD,EAAQuG,EAAK1B,CAAU,EAE/D7B,EAAiB,UAAU,YAAY,KAAKhD,EAAQuG,EAAK1B,CAAU,EAGvE4B,EAAazG,EAAQ,CAACuG,CAAG,EAAG1B,EAAYP,EAAUkC,CAAG,EAG9D,MAAM,IAAI,UAAU,sCAAsC,CAC7D,CAEC,SAASC,EAAc7H,EAAK2H,EAAK1B,EAAYP,EAAUkC,EAAK,CAC1D,IAAIE,EAAY,EACZC,EAAY/H,EAAI,OAChBgI,GAAYL,EAAI,OAEpB,GAAIjC,IAAa,SACfA,EAAW,OAAOA,CAAQ,EAAE,YAAa,EACrCA,IAAa,QAAUA,IAAa,SACpCA,IAAa,WAAaA,IAAa,YAAY,CACrD,GAAI1F,EAAI,OAAS,GAAK2H,EAAI,OAAS,EACjC,MAAO,GAETG,EAAY,EACZC,GAAa,EACbC,IAAa,EACb/B,GAAc,CACrB,CAGG,SAASgC,GAAMtD,GAAKzG,GAAG,CACrB,OAAI4J,IAAc,EACTnD,GAAIzG,EAAC,EAELyG,GAAI,aAAazG,GAAI4J,CAAS,CAE5C,CAEG,IAAI5J,GACJ,GAAI0J,EAAK,CACP,IAAIM,GAAa,GACjB,IAAKhK,GAAI+H,EAAY/H,GAAI6J,EAAW7J,KAClC,GAAI+J,GAAKjI,EAAK9B,EAAC,IAAM+J,GAAKN,EAAKO,KAAe,GAAK,EAAIhK,GAAIgK,EAAU,GAEnE,GADIA,KAAe,KAAIA,GAAahK,IAChCA,GAAIgK,GAAa,IAAMF,GAAW,OAAOE,GAAaJ,OAEtDI,KAAe,KAAIhK,IAAKA,GAAIgK,IAChCA,GAAa,EAGtB,KAEK,KADIjC,EAAa+B,GAAYD,IAAW9B,EAAa8B,EAAYC,IAC5D9J,GAAI+H,EAAY/H,IAAK,EAAGA,KAAK,CAChC,IAAIiK,GAAQ,GACZ,QAASC,GAAI,EAAGA,GAAIJ,GAAWI,KAC7B,GAAIH,GAAKjI,EAAK9B,GAAIkK,EAAC,IAAMH,GAAKN,EAAKS,EAAC,EAAG,CACrCD,GAAQ,GACR,KACX,CAEO,GAAIA,GAAO,OAAOjK,EACzB,CAGG,MAAO,EACV,CAEC+F,EAAO,UAAU,SAAW,SAAmB0D,EAAK1B,EAAYP,EAAU,CACxE,OAAO,KAAK,QAAQiC,EAAK1B,EAAYP,CAAQ,IAAM,EACpD,EAEDzB,EAAO,UAAU,QAAU,SAAkB0D,EAAK1B,EAAYP,EAAU,CACtE,OAAOgC,EAAqB,KAAMC,EAAK1B,EAAYP,EAAU,EAAI,CAClE,EAEDzB,EAAO,UAAU,YAAc,SAAsB0D,EAAK1B,EAAYP,EAAU,CAC9E,OAAOgC,EAAqB,KAAMC,EAAK1B,EAAYP,EAAU,EAAK,CACnE,EAED,SAAS2C,EAAU1D,EAAKiB,EAAQ3C,EAAQyB,EAAQ,CAC9CzB,EAAS,OAAOA,CAAM,GAAK,EAC3B,MAAMqF,EAAY3D,EAAI,OAAS1B,EAC1ByB,GAGHA,EAAS,OAAOA,CAAM,EAClBA,EAAS4D,IACX5D,EAAS4D,IAJX5D,EAAS4D,EAQX,MAAMC,EAAS3C,EAAO,OAElBlB,EAAS6D,EAAS,IACpB7D,EAAS6D,EAAS,GAEpB,IAAIrK,EACJ,IAAKA,EAAI,EAAGA,EAAIwG,EAAQ,EAAExG,EAAG,CAC3B,MAAMsK,GAAS,SAAS5C,EAAO,OAAO1H,EAAI,EAAG,CAAC,EAAG,EAAE,EACnD,GAAIiI,GAAYqC,EAAM,EAAG,OAAOtK,EAChCyG,EAAI1B,EAAS/E,CAAC,EAAIsK,EACvB,CACG,OAAOtK,CACV,CAEC,SAASuK,EAAW9D,EAAKiB,EAAQ3C,EAAQyB,EAAQ,CAC/C,OAAOgE,GAAWhC,GAAYd,EAAQjB,EAAI,OAAS1B,CAAM,EAAG0B,EAAK1B,EAAQyB,CAAM,CAClF,CAEC,SAASiE,EAAYhE,EAAKiB,EAAQ3C,EAAQyB,EAAQ,CAChD,OAAOgE,GAAWE,GAAahD,CAAM,EAAGjB,EAAK1B,EAAQyB,CAAM,CAC9D,CAEC,SAASmE,EAAalE,EAAKiB,EAAQ3C,EAAQyB,EAAQ,CACjD,OAAOgE,GAAW/B,GAAcf,CAAM,EAAGjB,EAAK1B,EAAQyB,CAAM,CAC/D,CAEC,SAASoE,EAAWnE,EAAKiB,EAAQ3C,EAAQyB,EAAQ,CAC/C,OAAOgE,GAAWK,GAAenD,EAAQjB,EAAI,OAAS1B,CAAM,EAAG0B,EAAK1B,EAAQyB,CAAM,CACrF,CAECT,EAAO,UAAU,MAAQ,SAAgB2B,EAAQ3C,EAAQyB,EAAQgB,EAAU,CAEzE,GAAIzC,IAAW,OACbyC,EAAW,OACXhB,EAAS,KAAK,OACdzB,EAAS,UAEAyB,IAAW,QAAa,OAAOzB,GAAW,SACnDyC,EAAWzC,EACXyB,EAAS,KAAK,OACdzB,EAAS,UAEA,SAASA,CAAM,EACxBA,EAASA,IAAW,EAChB,SAASyB,CAAM,GACjBA,EAASA,IAAW,EAChBgB,IAAa,SAAWA,EAAW,UAEvCA,EAAWhB,EACXA,EAAS,YAGX,OAAM,IAAI,MACR,yEACP,EAGG,MAAM4D,EAAY,KAAK,OAASrF,EAGhC,IAFIyB,IAAW,QAAaA,EAAS4D,KAAW5D,EAAS4D,GAEpD1C,EAAO,OAAS,IAAMlB,EAAS,GAAKzB,EAAS,IAAOA,EAAS,KAAK,OACrE,MAAM,IAAI,WAAW,wCAAwC,EAG1DyC,IAAUA,EAAW,QAE1B,IAAIe,EAAc,GAClB,OACE,OAAQf,EAAQ,CACd,IAAK,MACH,OAAO2C,EAAS,KAAMzC,EAAQ3C,EAAQyB,CAAM,EAE9C,IAAK,OACL,IAAK,QACH,OAAO+D,EAAU,KAAM7C,EAAQ3C,EAAQyB,CAAM,EAE/C,IAAK,QACL,IAAK,SACL,IAAK,SACH,OAAOiE,EAAW,KAAM/C,EAAQ3C,EAAQyB,CAAM,EAEhD,IAAK,SAEH,OAAOmE,EAAY,KAAMjD,EAAQ3C,EAAQyB,CAAM,EAEjD,IAAK,OACL,IAAK,QACL,IAAK,UACL,IAAK,WACH,OAAOoE,EAAU,KAAMlD,EAAQ3C,EAAQyB,CAAM,EAE/C,QACE,GAAI+B,EAAa,MAAM,IAAI,UAAU,qBAAuBf,CAAQ,EACpEA,GAAY,GAAKA,GAAU,YAAa,EACxCe,EAAc,EACvB,CAEE,EAEDxC,EAAO,UAAU,OAAS,UAAmB,CAC3C,MAAO,CACL,KAAM,SACN,KAAM,MAAM,UAAU,MAAM,KAAK,KAAK,MAAQ,KAAM,CAAC,CAC1D,CACE,EAED,SAASgD,EAAatC,EAAKlC,EAAOC,EAAK,CACrC,OAAID,IAAU,GAAKC,IAAQiC,EAAI,OACtBb,EAAO,cAAca,CAAG,EAExBb,EAAO,cAAca,EAAI,MAAMlC,EAAOC,CAAG,CAAC,CAEtD,CAEC,SAASoE,EAAWnC,EAAKlC,EAAOC,EAAK,CACnCA,EAAM,KAAK,IAAIiC,EAAI,OAAQjC,CAAG,EAC9B,MAAMsG,EAAM,CAAE,EAEd,IAAI9K,EAAIuE,EACR,KAAOvE,EAAIwE,GAAK,CACd,MAAMuG,EAAYtE,EAAIzG,CAAC,EACvB,IAAIgL,EAAY,KACZC,GAAoBF,EAAY,IAChC,EACCA,EAAY,IACT,EACCA,EAAY,IACT,EACA,EAEZ,GAAI/K,EAAIiL,IAAoBzG,EAAK,CAC/B,IAAI0G,GAAYC,GAAWC,GAAYC,GAEvC,OAAQJ,GAAgB,CACtB,IACMF,KAAY,MACdC,EAAYD,GAEd,MACF,IACEG,MAAazE,EAAIzG,EAAI,CAAC,GACjBkL,GAAa,OAAU,MAC1BG,IAAiBN,EAAY,KAAS,EAAOG,GAAa,GACtDG,GAAgB,MAClBL,EAAYK,KAGhB,MACF,IACEH,MAAazE,EAAIzG,EAAI,CAAC,EACtBmL,GAAY1E,EAAIzG,EAAI,CAAC,GAChBkL,GAAa,OAAU,MAASC,GAAY,OAAU,MACzDE,IAAiBN,EAAY,KAAQ,IAAOG,GAAa,KAAS,EAAOC,GAAY,GACjFE,GAAgB,OAAUA,GAAgB,OAAUA,GAAgB,SACtEL,EAAYK,KAGhB,MACF,IACEH,MAAazE,EAAIzG,EAAI,CAAC,EACtBmL,GAAY1E,EAAIzG,EAAI,CAAC,EACrBoL,GAAa3E,EAAIzG,EAAI,CAAC,GACjBkL,GAAa,OAAU,MAASC,GAAY,OAAU,MAASC,GAAa,OAAU,MACzFC,IAAiBN,EAAY,KAAQ,IAAQG,GAAa,KAAS,IAAOC,GAAY,KAAS,EAAOC,GAAa,GAC/GC,GAAgB,OAAUA,GAAgB,UAC5CL,EAAYK,IAG3B,CACA,CAESL,IAAc,MAGhBA,EAAY,MACZC,GAAmB,GACVD,EAAY,QAErBA,GAAa,MACbF,EAAI,KAAKE,IAAc,GAAK,KAAQ,KAAM,EAC1CA,EAAY,MAASA,EAAY,MAGnCF,EAAI,KAAKE,CAAS,EAClBhL,GAAKiL,EACV,CAEG,OAAOK,EAAsBR,CAAG,CACnC,CAKC,MAAMS,EAAuB,KAE7B,SAASD,EAAuBE,EAAY,CAC1C,MAAMlL,EAAMkL,EAAW,OACvB,GAAIlL,GAAOiL,EACT,OAAO,OAAO,aAAa,MAAM,OAAQC,CAAU,EAIrD,IAAIV,EAAM,GACN9K,EAAI,EACR,KAAOA,EAAIM,GACTwK,GAAO,OAAO,aAAa,MACzB,OACAU,EAAW,MAAMxL,EAAGA,GAAKuL,CAAoB,CAC9C,EAEH,OAAOT,CACV,CAEC,SAASjC,GAAYpC,EAAKlC,EAAOC,EAAK,CACpC,IAAIvC,EAAM,GACVuC,EAAM,KAAK,IAAIiC,EAAI,OAAQjC,CAAG,EAE9B,QAASxE,EAAIuE,EAAOvE,EAAIwE,EAAK,EAAExE,EAC7BiC,GAAO,OAAO,aAAawE,EAAIzG,CAAC,EAAI,GAAI,EAE1C,OAAOiC,CACV,CAEC,SAAS6G,EAAarC,EAAKlC,EAAOC,EAAK,CACrC,IAAIvC,EAAM,GACVuC,EAAM,KAAK,IAAIiC,EAAI,OAAQjC,CAAG,EAE9B,QAASxE,EAAIuE,EAAOvE,EAAIwE,EAAK,EAAExE,EAC7BiC,GAAO,OAAO,aAAawE,EAAIzG,CAAC,CAAC,EAEnC,OAAOiC,CACV,CAEC,SAAS0G,GAAUlC,EAAKlC,EAAOC,EAAK,CAClC,MAAMlE,EAAMmG,EAAI,QAEZ,CAAClC,GAASA,EAAQ,KAAGA,EAAQ,IAC7B,CAACC,GAAOA,EAAM,GAAKA,EAAMlE,KAAKkE,EAAMlE,GAExC,IAAImL,EAAM,GACV,QAASzL,EAAIuE,EAAOvE,EAAIwE,EAAK,EAAExE,EAC7ByL,GAAOC,GAAoBjF,EAAIzG,CAAC,CAAC,EAEnC,OAAOyL,CACV,CAEC,SAASzC,GAAcvC,EAAKlC,EAAOC,EAAK,CACtC,MAAMmH,EAAQlF,EAAI,MAAMlC,EAAOC,CAAG,EAClC,IAAIsG,EAAM,GAEV,QAAS9K,EAAI,EAAGA,EAAI2L,EAAM,OAAS,EAAG3L,GAAK,EACzC8K,GAAO,OAAO,aAAaa,EAAM3L,CAAC,EAAK2L,EAAM3L,EAAI,CAAC,EAAI,GAAI,EAE5D,OAAO8K,CACV,CAEC/E,EAAO,UAAU,MAAQ,SAAgBxB,EAAOC,EAAK,CACnD,MAAMlE,EAAM,KAAK,OACjBiE,EAAQ,CAAC,CAACA,EACVC,EAAMA,IAAQ,OAAYlE,EAAM,CAAC,CAACkE,EAE9BD,EAAQ,GACVA,GAASjE,EACLiE,EAAQ,IAAGA,EAAQ,IACdA,EAAQjE,IACjBiE,EAAQjE,GAGNkE,EAAM,GACRA,GAAOlE,EACHkE,EAAM,IAAGA,EAAM,IACVA,EAAMlE,IACfkE,EAAMlE,GAGJkE,EAAMD,IAAOC,EAAMD,GAEvB,MAAMqH,EAAS,KAAK,SAASrH,EAAOC,CAAG,EAEvC,cAAO,eAAeoH,EAAQ7F,EAAO,SAAS,EAEvC6F,CACR,EAKD,SAASC,GAAa9G,EAAQ+G,EAAKtF,EAAQ,CACzC,GAAKzB,EAAS,IAAO,GAAKA,EAAS,EAAG,MAAM,IAAI,WAAW,oBAAoB,EAC/E,GAAIA,EAAS+G,EAAMtF,EAAQ,MAAM,IAAI,WAAW,uCAAuC,CAC1F,CAECT,EAAO,UAAU,WACjBA,EAAO,UAAU,WAAa,SAAqBhB,EAAQ3B,EAAY2I,EAAU,CAC/EhH,EAASA,IAAW,EACpB3B,EAAaA,IAAe,EACvB2I,GAAUF,GAAY9G,EAAQ3B,EAAY,KAAK,MAAM,EAE1D,IAAIqG,EAAM,KAAK1E,CAAM,EACjBiH,EAAM,EACNhM,EAAI,EACR,KAAO,EAAEA,EAAIoD,IAAe4I,GAAO,MACjCvC,GAAO,KAAK1E,EAAS/E,CAAC,EAAIgM,EAG5B,OAAOvC,CACR,EAED1D,EAAO,UAAU,WACjBA,EAAO,UAAU,WAAa,SAAqBhB,EAAQ3B,EAAY2I,EAAU,CAC/EhH,EAASA,IAAW,EACpB3B,EAAaA,IAAe,EACvB2I,GACHF,GAAY9G,EAAQ3B,EAAY,KAAK,MAAM,EAG7C,IAAIqG,EAAM,KAAK1E,EAAS,EAAE3B,CAAU,EAChC4I,EAAM,EACV,KAAO5I,EAAa,IAAM4I,GAAO,MAC/BvC,GAAO,KAAK1E,EAAS,EAAE3B,CAAU,EAAI4I,EAGvC,OAAOvC,CACR,EAED1D,EAAO,UAAU,UACjBA,EAAO,UAAU,UAAY,SAAoBhB,EAAQgH,EAAU,CACjE,OAAAhH,EAASA,IAAW,EACfgH,GAAUF,GAAY9G,EAAQ,EAAG,KAAK,MAAM,EAC1C,KAAKA,CAAM,CACnB,EAEDgB,EAAO,UAAU,aACjBA,EAAO,UAAU,aAAe,SAAuBhB,EAAQgH,EAAU,CACvE,OAAAhH,EAASA,IAAW,EACfgH,GAAUF,GAAY9G,EAAQ,EAAG,KAAK,MAAM,EAC1C,KAAKA,CAAM,EAAK,KAAKA,EAAS,CAAC,GAAK,CAC5C,EAEDgB,EAAO,UAAU,aACjBA,EAAO,UAAU,aAAe,SAAuBhB,EAAQgH,EAAU,CACvE,OAAAhH,EAASA,IAAW,EACfgH,GAAUF,GAAY9G,EAAQ,EAAG,KAAK,MAAM,EACzC,KAAKA,CAAM,GAAK,EAAK,KAAKA,EAAS,CAAC,CAC7C,EAEDgB,EAAO,UAAU,aACjBA,EAAO,UAAU,aAAe,SAAuBhB,EAAQgH,EAAU,CACvE,OAAAhH,EAASA,IAAW,EACfgH,GAAUF,GAAY9G,EAAQ,EAAG,KAAK,MAAM,GAExC,KAAKA,CAAM,EACf,KAAKA,EAAS,CAAC,GAAK,EACpB,KAAKA,EAAS,CAAC,GAAK,IACpB,KAAKA,EAAS,CAAC,EAAI,QACzB,EAEDgB,EAAO,UAAU,aACjBA,EAAO,UAAU,aAAe,SAAuBhB,EAAQgH,EAAU,CACvE,OAAAhH,EAASA,IAAW,EACfgH,GAAUF,GAAY9G,EAAQ,EAAG,KAAK,MAAM,EAEzC,KAAKA,CAAM,EAAI,UACnB,KAAKA,EAAS,CAAC,GAAK,GACrB,KAAKA,EAAS,CAAC,GAAK,EACrB,KAAKA,EAAS,CAAC,EAClB,EAEDgB,EAAO,UAAU,gBAAkBkG,GAAmB,SAA0BlH,EAAQ,CACtFA,EAASA,IAAW,EACpBmH,GAAenH,EAAQ,QAAQ,EAC/B,MAAMoH,EAAQ,KAAKpH,CAAM,EACnBqH,EAAO,KAAKrH,EAAS,CAAC,GACxBoH,IAAU,QAAaC,IAAS,SAClCC,GAAYtH,EAAQ,KAAK,OAAS,CAAC,EAGrC,MAAMuH,EAAKH,EACT,KAAK,EAAEpH,CAAM,EAAI,GAAK,EACtB,KAAK,EAAEA,CAAM,EAAI,GAAK,GACtB,KAAK,EAAEA,CAAM,EAAI,GAAK,GAElBwH,EAAK,KAAK,EAAExH,CAAM,EACtB,KAAK,EAAEA,CAAM,EAAI,GAAK,EACtB,KAAK,EAAEA,CAAM,EAAI,GAAK,GACtBqH,EAAO,GAAK,GAEd,OAAO,OAAOE,CAAE,GAAK,OAAOC,CAAE,GAAK,OAAO,EAAE,EAC/C,CAAE,EAEDxG,EAAO,UAAU,gBAAkBkG,GAAmB,SAA0BlH,EAAQ,CACtFA,EAASA,IAAW,EACpBmH,GAAenH,EAAQ,QAAQ,EAC/B,MAAMoH,EAAQ,KAAKpH,CAAM,EACnBqH,EAAO,KAAKrH,EAAS,CAAC,GACxBoH,IAAU,QAAaC,IAAS,SAClCC,GAAYtH,EAAQ,KAAK,OAAS,CAAC,EAGrC,MAAMwH,EAAKJ,EAAQ,GAAK,GACtB,KAAK,EAAEpH,CAAM,EAAI,GAAK,GACtB,KAAK,EAAEA,CAAM,EAAI,GAAK,EACtB,KAAK,EAAEA,CAAM,EAETuH,EAAK,KAAK,EAAEvH,CAAM,EAAI,GAAK,GAC/B,KAAK,EAAEA,CAAM,EAAI,GAAK,GACtB,KAAK,EAAEA,CAAM,EAAI,GAAK,EACtBqH,EAEF,OAAQ,OAAOG,CAAE,GAAK,OAAO,EAAE,GAAK,OAAOD,CAAE,CAChD,CAAE,EAEDvG,EAAO,UAAU,UAAY,SAAoBhB,EAAQ3B,EAAY2I,EAAU,CAC7EhH,EAASA,IAAW,EACpB3B,EAAaA,IAAe,EACvB2I,GAAUF,GAAY9G,EAAQ3B,EAAY,KAAK,MAAM,EAE1D,IAAIqG,EAAM,KAAK1E,CAAM,EACjBiH,EAAM,EACNhM,EAAI,EACR,KAAO,EAAEA,EAAIoD,IAAe4I,GAAO,MACjCvC,GAAO,KAAK1E,EAAS/E,CAAC,EAAIgM,EAE5B,OAAAA,GAAO,IAEHvC,GAAOuC,IAAKvC,GAAO,KAAK,IAAI,EAAG,EAAIrG,CAAU,GAE1CqG,CACR,EAED1D,EAAO,UAAU,UAAY,SAAoBhB,EAAQ3B,EAAY2I,EAAU,CAC7EhH,EAASA,IAAW,EACpB3B,EAAaA,IAAe,EACvB2I,GAAUF,GAAY9G,EAAQ3B,EAAY,KAAK,MAAM,EAE1D,IAAIpD,EAAIoD,EACJ4I,EAAM,EACNvC,EAAM,KAAK1E,EAAS,EAAE/E,CAAC,EAC3B,KAAOA,EAAI,IAAMgM,GAAO,MACtBvC,GAAO,KAAK1E,EAAS,EAAE/E,CAAC,EAAIgM,EAE9B,OAAAA,GAAO,IAEHvC,GAAOuC,IAAKvC,GAAO,KAAK,IAAI,EAAG,EAAIrG,CAAU,GAE1CqG,CACR,EAED1D,EAAO,UAAU,SAAW,SAAmBhB,EAAQgH,EAAU,CAG/D,OAFAhH,EAASA,IAAW,EACfgH,GAAUF,GAAY9G,EAAQ,EAAG,KAAK,MAAM,EAC3C,KAAKA,CAAM,EAAI,KACZ,IAAO,KAAKA,CAAM,EAAI,GAAK,GADA,KAAKA,CAAM,CAEhD,EAEDgB,EAAO,UAAU,YAAc,SAAsBhB,EAAQgH,EAAU,CACrEhH,EAASA,IAAW,EACfgH,GAAUF,GAAY9G,EAAQ,EAAG,KAAK,MAAM,EACjD,MAAM0E,EAAM,KAAK1E,CAAM,EAAK,KAAKA,EAAS,CAAC,GAAK,EAChD,OAAQ0E,EAAM,MAAUA,EAAM,WAAaA,CAC5C,EAED1D,EAAO,UAAU,YAAc,SAAsBhB,EAAQgH,EAAU,CACrEhH,EAASA,IAAW,EACfgH,GAAUF,GAAY9G,EAAQ,EAAG,KAAK,MAAM,EACjD,MAAM0E,EAAM,KAAK1E,EAAS,CAAC,EAAK,KAAKA,CAAM,GAAK,EAChD,OAAQ0E,EAAM,MAAUA,EAAM,WAAaA,CAC5C,EAED1D,EAAO,UAAU,YAAc,SAAsBhB,EAAQgH,EAAU,CACrE,OAAAhH,EAASA,IAAW,EACfgH,GAAUF,GAAY9G,EAAQ,EAAG,KAAK,MAAM,EAEzC,KAAKA,CAAM,EAChB,KAAKA,EAAS,CAAC,GAAK,EACpB,KAAKA,EAAS,CAAC,GAAK,GACpB,KAAKA,EAAS,CAAC,GAAK,EACxB,EAEDgB,EAAO,UAAU,YAAc,SAAsBhB,EAAQgH,EAAU,CACrE,OAAAhH,EAASA,IAAW,EACfgH,GAAUF,GAAY9G,EAAQ,EAAG,KAAK,MAAM,EAEzC,KAAKA,CAAM,GAAK,GACrB,KAAKA,EAAS,CAAC,GAAK,GACpB,KAAKA,EAAS,CAAC,GAAK,EACpB,KAAKA,EAAS,CAAC,CACnB,EAEDgB,EAAO,UAAU,eAAiBkG,GAAmB,SAAyBlH,EAAQ,CACpFA,EAASA,IAAW,EACpBmH,GAAenH,EAAQ,QAAQ,EAC/B,MAAMoH,EAAQ,KAAKpH,CAAM,EACnBqH,EAAO,KAAKrH,EAAS,CAAC,GACxBoH,IAAU,QAAaC,IAAS,SAClCC,GAAYtH,EAAQ,KAAK,OAAS,CAAC,EAGrC,MAAM0E,EAAM,KAAK1E,EAAS,CAAC,EACzB,KAAKA,EAAS,CAAC,EAAI,GAAK,EACxB,KAAKA,EAAS,CAAC,EAAI,GAAK,IACvBqH,GAAQ,IAEX,OAAQ,OAAO3C,CAAG,GAAK,OAAO,EAAE,GAC9B,OAAO0C,EACP,KAAK,EAAEpH,CAAM,EAAI,GAAK,EACtB,KAAK,EAAEA,CAAM,EAAI,GAAK,GACtB,KAAK,EAAEA,CAAM,EAAI,GAAK,EAAE,CAC7B,CAAE,EAEDgB,EAAO,UAAU,eAAiBkG,GAAmB,SAAyBlH,EAAQ,CACpFA,EAASA,IAAW,EACpBmH,GAAenH,EAAQ,QAAQ,EAC/B,MAAMoH,EAAQ,KAAKpH,CAAM,EACnBqH,EAAO,KAAKrH,EAAS,CAAC,GACxBoH,IAAU,QAAaC,IAAS,SAClCC,GAAYtH,EAAQ,KAAK,OAAS,CAAC,EAGrC,MAAM0E,GAAO0C,GAAS,IACpB,KAAK,EAAEpH,CAAM,EAAI,GAAK,GACtB,KAAK,EAAEA,CAAM,EAAI,GAAK,EACtB,KAAK,EAAEA,CAAM,EAEf,OAAQ,OAAO0E,CAAG,GAAK,OAAO,EAAE,GAC9B,OAAO,KAAK,EAAE1E,CAAM,EAAI,GAAK,GAC7B,KAAK,EAAEA,CAAM,EAAI,GAAK,GACtB,KAAK,EAAEA,CAAM,EAAI,GAAK,EACtBqH,CAAI,CACT,CAAE,EAEDrG,EAAO,UAAU,YAAc,SAAsBhB,EAAQgH,EAAU,CACrE,OAAAhH,EAASA,IAAW,EACfgH,GAAUF,GAAY9G,EAAQ,EAAG,KAAK,MAAM,EAC1Cc,EAAU,KAAK,KAAMd,EAAQ,GAAM,GAAI,CAAC,CAChD,EAEDgB,EAAO,UAAU,YAAc,SAAsBhB,EAAQgH,EAAU,CACrE,OAAAhH,EAASA,IAAW,EACfgH,GAAUF,GAAY9G,EAAQ,EAAG,KAAK,MAAM,EAC1Cc,EAAU,KAAK,KAAMd,EAAQ,GAAO,GAAI,CAAC,CACjD,EAEDgB,EAAO,UAAU,aAAe,SAAuBhB,EAAQgH,EAAU,CACvE,OAAAhH,EAASA,IAAW,EACfgH,GAAUF,GAAY9G,EAAQ,EAAG,KAAK,MAAM,EAC1Cc,EAAU,KAAK,KAAMd,EAAQ,GAAM,GAAI,CAAC,CAChD,EAEDgB,EAAO,UAAU,aAAe,SAAuBhB,EAAQgH,EAAU,CACvE,OAAAhH,EAASA,IAAW,EACfgH,GAAUF,GAAY9G,EAAQ,EAAG,KAAK,MAAM,EAC1Cc,EAAU,KAAK,KAAMd,EAAQ,GAAO,GAAI,CAAC,CACjD,EAED,SAASyH,GAAU/F,EAAKrH,EAAO2F,EAAQ+G,EAAK3C,EAAKsD,EAAK,CACpD,GAAI,CAAC1G,EAAO,SAASU,CAAG,EAAG,MAAM,IAAI,UAAU,6CAA6C,EAC5F,GAAIrH,EAAQ+J,GAAO/J,EAAQqN,EAAK,MAAM,IAAI,WAAW,mCAAmC,EACxF,GAAI1H,EAAS+G,EAAMrF,EAAI,OAAQ,MAAM,IAAI,WAAW,oBAAoB,CAC3E,CAECV,EAAO,UAAU,YACjBA,EAAO,UAAU,YAAc,SAAsB3G,EAAO2F,EAAQ3B,EAAY2I,EAAU,CAIxF,GAHA3M,EAAQ,CAACA,EACT2F,EAASA,IAAW,EACpB3B,EAAaA,IAAe,EACxB,CAAC2I,EAAU,CACb,MAAMW,EAAW,KAAK,IAAI,EAAG,EAAItJ,CAAU,EAAI,EAC/CoJ,GAAS,KAAMpN,EAAO2F,EAAQ3B,EAAYsJ,EAAU,CAAC,CAC1D,CAEG,IAAIV,EAAM,EACNhM,EAAI,EAER,IADA,KAAK+E,CAAM,EAAI3F,EAAQ,IAChB,EAAEY,EAAIoD,IAAe4I,GAAO,MACjC,KAAKjH,EAAS/E,CAAC,EAAKZ,EAAQ4M,EAAO,IAGrC,OAAOjH,EAAS3B,CACjB,EAED2C,EAAO,UAAU,YACjBA,EAAO,UAAU,YAAc,SAAsB3G,EAAO2F,EAAQ3B,EAAY2I,EAAU,CAIxF,GAHA3M,EAAQ,CAACA,EACT2F,EAASA,IAAW,EACpB3B,EAAaA,IAAe,EACxB,CAAC2I,EAAU,CACb,MAAMW,EAAW,KAAK,IAAI,EAAG,EAAItJ,CAAU,EAAI,EAC/CoJ,GAAS,KAAMpN,EAAO2F,EAAQ3B,EAAYsJ,EAAU,CAAC,CAC1D,CAEG,IAAI1M,EAAIoD,EAAa,EACjB4I,EAAM,EAEV,IADA,KAAKjH,EAAS/E,CAAC,EAAIZ,EAAQ,IACpB,EAAEY,GAAK,IAAMgM,GAAO,MACzB,KAAKjH,EAAS/E,CAAC,EAAKZ,EAAQ4M,EAAO,IAGrC,OAAOjH,EAAS3B,CACjB,EAED2C,EAAO,UAAU,WACjBA,EAAO,UAAU,WAAa,SAAqB3G,EAAO2F,EAAQgH,EAAU,CAC1E,OAAA3M,EAAQ,CAACA,EACT2F,EAASA,IAAW,EACfgH,GAAUS,GAAS,KAAMpN,EAAO2F,EAAQ,EAAG,IAAM,CAAC,EACvD,KAAKA,CAAM,EAAK3F,EAAQ,IACjB2F,EAAS,CACjB,EAEDgB,EAAO,UAAU,cACjBA,EAAO,UAAU,cAAgB,SAAwB3G,EAAO2F,EAAQgH,EAAU,CAChF,OAAA3M,EAAQ,CAACA,EACT2F,EAASA,IAAW,EACfgH,GAAUS,GAAS,KAAMpN,EAAO2F,EAAQ,EAAG,MAAQ,CAAC,EACzD,KAAKA,CAAM,EAAK3F,EAAQ,IACxB,KAAK2F,EAAS,CAAC,EAAK3F,IAAU,EACvB2F,EAAS,CACjB,EAEDgB,EAAO,UAAU,cACjBA,EAAO,UAAU,cAAgB,SAAwB3G,EAAO2F,EAAQgH,EAAU,CAChF,OAAA3M,EAAQ,CAACA,EACT2F,EAASA,IAAW,EACfgH,GAAUS,GAAS,KAAMpN,EAAO2F,EAAQ,EAAG,MAAQ,CAAC,EACzD,KAAKA,CAAM,EAAK3F,IAAU,EAC1B,KAAK2F,EAAS,CAAC,EAAK3F,EAAQ,IACrB2F,EAAS,CACjB,EAEDgB,EAAO,UAAU,cACjBA,EAAO,UAAU,cAAgB,SAAwB3G,EAAO2F,EAAQgH,EAAU,CAChF,OAAA3M,EAAQ,CAACA,EACT2F,EAASA,IAAW,EACfgH,GAAUS,GAAS,KAAMpN,EAAO2F,EAAQ,EAAG,WAAY,CAAC,EAC7D,KAAKA,EAAS,CAAC,EAAK3F,IAAU,GAC9B,KAAK2F,EAAS,CAAC,EAAK3F,IAAU,GAC9B,KAAK2F,EAAS,CAAC,EAAK3F,IAAU,EAC9B,KAAK2F,CAAM,EAAK3F,EAAQ,IACjB2F,EAAS,CACjB,EAEDgB,EAAO,UAAU,cACjBA,EAAO,UAAU,cAAgB,SAAwB3G,EAAO2F,EAAQgH,EAAU,CAChF,OAAA3M,EAAQ,CAACA,EACT2F,EAASA,IAAW,EACfgH,GAAUS,GAAS,KAAMpN,EAAO2F,EAAQ,EAAG,WAAY,CAAC,EAC7D,KAAKA,CAAM,EAAK3F,IAAU,GAC1B,KAAK2F,EAAS,CAAC,EAAK3F,IAAU,GAC9B,KAAK2F,EAAS,CAAC,EAAK3F,IAAU,EAC9B,KAAK2F,EAAS,CAAC,EAAK3F,EAAQ,IACrB2F,EAAS,CACjB,EAED,SAAS4H,GAAgBlG,EAAKrH,EAAO2F,EAAQ0H,EAAKtD,EAAK,CACrDyD,GAAWxN,EAAOqN,EAAKtD,EAAK1C,EAAK1B,EAAQ,CAAC,EAE1C,IAAIuH,EAAK,OAAOlN,EAAQ,OAAO,UAAU,CAAC,EAC1CqH,EAAI1B,GAAQ,EAAIuH,EAChBA,EAAKA,GAAM,EACX7F,EAAI1B,GAAQ,EAAIuH,EAChBA,EAAKA,GAAM,EACX7F,EAAI1B,GAAQ,EAAIuH,EAChBA,EAAKA,GAAM,EACX7F,EAAI1B,GAAQ,EAAIuH,EAChB,IAAIC,EAAK,OAAOnN,GAAS,OAAO,EAAE,EAAI,OAAO,UAAU,CAAC,EACxD,OAAAqH,EAAI1B,GAAQ,EAAIwH,EAChBA,EAAKA,GAAM,EACX9F,EAAI1B,GAAQ,EAAIwH,EAChBA,EAAKA,GAAM,EACX9F,EAAI1B,GAAQ,EAAIwH,EAChBA,EAAKA,GAAM,EACX9F,EAAI1B,GAAQ,EAAIwH,EACTxH,CACV,CAEC,SAAS8H,GAAgBpG,EAAKrH,EAAO2F,EAAQ0H,EAAKtD,EAAK,CACrDyD,GAAWxN,EAAOqN,EAAKtD,EAAK1C,EAAK1B,EAAQ,CAAC,EAE1C,IAAIuH,EAAK,OAAOlN,EAAQ,OAAO,UAAU,CAAC,EAC1CqH,EAAI1B,EAAS,CAAC,EAAIuH,EAClBA,EAAKA,GAAM,EACX7F,EAAI1B,EAAS,CAAC,EAAIuH,EAClBA,EAAKA,GAAM,EACX7F,EAAI1B,EAAS,CAAC,EAAIuH,EAClBA,EAAKA,GAAM,EACX7F,EAAI1B,EAAS,CAAC,EAAIuH,EAClB,IAAIC,EAAK,OAAOnN,GAAS,OAAO,EAAE,EAAI,OAAO,UAAU,CAAC,EACxD,OAAAqH,EAAI1B,EAAS,CAAC,EAAIwH,EAClBA,EAAKA,GAAM,EACX9F,EAAI1B,EAAS,CAAC,EAAIwH,EAClBA,EAAKA,GAAM,EACX9F,EAAI1B,EAAS,CAAC,EAAIwH,EAClBA,EAAKA,GAAM,EACX9F,EAAI1B,CAAM,EAAIwH,EACPxH,EAAS,CACnB,CAECgB,EAAO,UAAU,iBAAmBkG,GAAmB,SAA2B7M,EAAO2F,EAAS,EAAG,CACnG,OAAO4H,GAAe,KAAMvN,EAAO2F,EAAQ,OAAO,CAAC,EAAG,OAAO,oBAAoB,CAAC,CACrF,CAAE,EAEDgB,EAAO,UAAU,iBAAmBkG,GAAmB,SAA2B7M,EAAO2F,EAAS,EAAG,CACnG,OAAO8H,GAAe,KAAMzN,EAAO2F,EAAQ,OAAO,CAAC,EAAG,OAAO,oBAAoB,CAAC,CACrF,CAAE,EAEDgB,EAAO,UAAU,WAAa,SAAqB3G,EAAO2F,EAAQ3B,EAAY2I,EAAU,CAGtF,GAFA3M,EAAQ,CAACA,EACT2F,EAASA,IAAW,EAChB,CAACgH,EAAU,CACb,MAAMe,GAAQ,KAAK,IAAI,EAAI,EAAI1J,EAAc,CAAC,EAE9CoJ,GAAS,KAAMpN,EAAO2F,EAAQ3B,EAAY0J,GAAQ,EAAG,CAACA,EAAK,CAChE,CAEG,IAAI9M,EAAI,EACJgM,EAAM,EACNe,EAAM,EAEV,IADA,KAAKhI,CAAM,EAAI3F,EAAQ,IAChB,EAAEY,EAAIoD,IAAe4I,GAAO,MAC7B5M,EAAQ,GAAK2N,IAAQ,GAAK,KAAKhI,EAAS/E,EAAI,CAAC,IAAM,IACrD+M,EAAM,GAER,KAAKhI,EAAS/E,CAAC,GAAMZ,EAAQ4M,GAAQ,GAAKe,EAAM,IAGlD,OAAOhI,EAAS3B,CACjB,EAED2C,EAAO,UAAU,WAAa,SAAqB3G,EAAO2F,EAAQ3B,EAAY2I,EAAU,CAGtF,GAFA3M,EAAQ,CAACA,EACT2F,EAASA,IAAW,EAChB,CAACgH,EAAU,CACb,MAAMe,GAAQ,KAAK,IAAI,EAAI,EAAI1J,EAAc,CAAC,EAE9CoJ,GAAS,KAAMpN,EAAO2F,EAAQ3B,EAAY0J,GAAQ,EAAG,CAACA,EAAK,CAChE,CAEG,IAAI9M,EAAIoD,EAAa,EACjB4I,EAAM,EACNe,EAAM,EAEV,IADA,KAAKhI,EAAS/E,CAAC,EAAIZ,EAAQ,IACpB,EAAEY,GAAK,IAAMgM,GAAO,MACrB5M,EAAQ,GAAK2N,IAAQ,GAAK,KAAKhI,EAAS/E,EAAI,CAAC,IAAM,IACrD+M,EAAM,GAER,KAAKhI,EAAS/E,CAAC,GAAMZ,EAAQ4M,GAAQ,GAAKe,EAAM,IAGlD,OAAOhI,EAAS3B,CACjB,EAED2C,EAAO,UAAU,UAAY,SAAoB3G,EAAO2F,EAAQgH,EAAU,CACxE,OAAA3M,EAAQ,CAACA,EACT2F,EAASA,IAAW,EACfgH,GAAUS,GAAS,KAAMpN,EAAO2F,EAAQ,EAAG,IAAM,IAAK,EACvD3F,EAAQ,IAAGA,EAAQ,IAAOA,EAAQ,GACtC,KAAK2F,CAAM,EAAK3F,EAAQ,IACjB2F,EAAS,CACjB,EAEDgB,EAAO,UAAU,aAAe,SAAuB3G,EAAO2F,EAAQgH,EAAU,CAC9E,OAAA3M,EAAQ,CAACA,EACT2F,EAASA,IAAW,EACfgH,GAAUS,GAAS,KAAMpN,EAAO2F,EAAQ,EAAG,MAAQ,MAAO,EAC/D,KAAKA,CAAM,EAAK3F,EAAQ,IACxB,KAAK2F,EAAS,CAAC,EAAK3F,IAAU,EACvB2F,EAAS,CACjB,EAEDgB,EAAO,UAAU,aAAe,SAAuB3G,EAAO2F,EAAQgH,EAAU,CAC9E,OAAA3M,EAAQ,CAACA,EACT2F,EAASA,IAAW,EACfgH,GAAUS,GAAS,KAAMpN,EAAO2F,EAAQ,EAAG,MAAQ,MAAO,EAC/D,KAAKA,CAAM,EAAK3F,IAAU,EAC1B,KAAK2F,EAAS,CAAC,EAAK3F,EAAQ,IACrB2F,EAAS,CACjB,EAEDgB,EAAO,UAAU,aAAe,SAAuB3G,EAAO2F,EAAQgH,EAAU,CAC9E,OAAA3M,EAAQ,CAACA,EACT2F,EAASA,IAAW,EACfgH,GAAUS,GAAS,KAAMpN,EAAO2F,EAAQ,EAAG,WAAY,WAAW,EACvE,KAAKA,CAAM,EAAK3F,EAAQ,IACxB,KAAK2F,EAAS,CAAC,EAAK3F,IAAU,EAC9B,KAAK2F,EAAS,CAAC,EAAK3F,IAAU,GAC9B,KAAK2F,EAAS,CAAC,EAAK3F,IAAU,GACvB2F,EAAS,CACjB,EAEDgB,EAAO,UAAU,aAAe,SAAuB3G,EAAO2F,EAAQgH,EAAU,CAC9E,OAAA3M,EAAQ,CAACA,EACT2F,EAASA,IAAW,EACfgH,GAAUS,GAAS,KAAMpN,EAAO2F,EAAQ,EAAG,WAAY,WAAW,EACnE3F,EAAQ,IAAGA,EAAQ,WAAaA,EAAQ,GAC5C,KAAK2F,CAAM,EAAK3F,IAAU,GAC1B,KAAK2F,EAAS,CAAC,EAAK3F,IAAU,GAC9B,KAAK2F,EAAS,CAAC,EAAK3F,IAAU,EAC9B,KAAK2F,EAAS,CAAC,EAAK3F,EAAQ,IACrB2F,EAAS,CACjB,EAEDgB,EAAO,UAAU,gBAAkBkG,GAAmB,SAA0B7M,EAAO2F,EAAS,EAAG,CACjG,OAAO4H,GAAe,KAAMvN,EAAO2F,EAAQ,CAAC,OAAO,oBAAoB,EAAG,OAAO,oBAAoB,CAAC,CACzG,CAAE,EAEDgB,EAAO,UAAU,gBAAkBkG,GAAmB,SAA0B7M,EAAO2F,EAAS,EAAG,CACjG,OAAO8H,GAAe,KAAMzN,EAAO2F,EAAQ,CAAC,OAAO,oBAAoB,EAAG,OAAO,oBAAoB,CAAC,CACzG,CAAE,EAED,SAASiI,GAAcvG,EAAKrH,EAAO2F,EAAQ+G,EAAK3C,EAAKsD,EAAK,CACxD,GAAI1H,EAAS+G,EAAMrF,EAAI,OAAQ,MAAM,IAAI,WAAW,oBAAoB,EACxE,GAAI1B,EAAS,EAAG,MAAM,IAAI,WAAW,oBAAoB,CAC5D,CAEC,SAASkI,GAAYxG,EAAKrH,EAAO2F,EAAQmI,EAAcnB,EAAU,CAC/D,OAAA3M,EAAQ,CAACA,EACT2F,EAASA,IAAW,EACfgH,GACHiB,GAAavG,EAAKrH,EAAO2F,EAAQ,CAAC,EAEpCc,EAAU,MAAMY,EAAKrH,EAAO2F,EAAQmI,EAAc,GAAI,CAAC,EAChDnI,EAAS,CACnB,CAECgB,EAAO,UAAU,aAAe,SAAuB3G,EAAO2F,EAAQgH,EAAU,CAC9E,OAAOkB,GAAW,KAAM7N,EAAO2F,EAAQ,GAAMgH,CAAQ,CACtD,EAEDhG,EAAO,UAAU,aAAe,SAAuB3G,EAAO2F,EAAQgH,EAAU,CAC9E,OAAOkB,GAAW,KAAM7N,EAAO2F,EAAQ,GAAOgH,CAAQ,CACvD,EAED,SAASoB,GAAa1G,EAAKrH,EAAO2F,EAAQmI,EAAcnB,EAAU,CAChE,OAAA3M,EAAQ,CAACA,EACT2F,EAASA,IAAW,EACfgH,GACHiB,GAAavG,EAAKrH,EAAO2F,EAAQ,CAAC,EAEpCc,EAAU,MAAMY,EAAKrH,EAAO2F,EAAQmI,EAAc,GAAI,CAAC,EAChDnI,EAAS,CACnB,CAECgB,EAAO,UAAU,cAAgB,SAAwB3G,EAAO2F,EAAQgH,EAAU,CAChF,OAAOoB,GAAY,KAAM/N,EAAO2F,EAAQ,GAAMgH,CAAQ,CACvD,EAEDhG,EAAO,UAAU,cAAgB,SAAwB3G,EAAO2F,EAAQgH,EAAU,CAChF,OAAOoB,GAAY,KAAM/N,EAAO2F,EAAQ,GAAOgH,CAAQ,CACxD,EAGDhG,EAAO,UAAU,KAAO,SAAelH,EAAQuO,EAAa7I,EAAOC,EAAK,CACtE,GAAI,CAACuB,EAAO,SAASlH,CAAM,EAAG,MAAM,IAAI,UAAU,6BAA6B,EAS/E,GARK0F,IAAOA,EAAQ,GAChB,CAACC,GAAOA,IAAQ,IAAGA,EAAM,KAAK,QAC9B4I,GAAevO,EAAO,SAAQuO,EAAcvO,EAAO,QAClDuO,IAAaA,EAAc,GAC5B5I,EAAM,GAAKA,EAAMD,IAAOC,EAAMD,GAG9BC,IAAQD,GACR1F,EAAO,SAAW,GAAK,KAAK,SAAW,EAAG,MAG9C,MAAIuO,EAAc,EAChB,MAAM,IAAI,WAAW,2BAA2B,EAElD,GAAI7I,EAAQ,GAAKA,GAAS,KAAK,OAAQ,MAAM,IAAI,WAAW,oBAAoB,EAChF,GAAIC,EAAM,EAAG,MAAM,IAAI,WAAW,yBAAyB,EAGvDA,EAAM,KAAK,SAAQA,EAAM,KAAK,QAC9B3F,EAAO,OAASuO,EAAc5I,EAAMD,IACtCC,EAAM3F,EAAO,OAASuO,EAAc7I,GAGtC,MAAMjE,EAAMkE,EAAMD,EAElB,OAAI,OAAS1F,GAAU,OAAOqH,EAAiB,UAAU,YAAe,WAEtE,KAAK,WAAWkH,EAAa7I,EAAOC,CAAG,EAEvC0B,EAAiB,UAAU,IAAI,KAC7BrH,EACA,KAAK,SAAS0F,EAAOC,CAAG,EACxB4I,CACD,EAGI9M,CACR,EAMDyF,EAAO,UAAU,KAAO,SAAe0D,EAAKlF,EAAOC,EAAKgD,EAAU,CAEhE,GAAI,OAAOiC,GAAQ,SAAU,CAS3B,GARI,OAAOlF,GAAU,UACnBiD,EAAWjD,EACXA,EAAQ,EACRC,EAAM,KAAK,QACF,OAAOA,GAAQ,WACxBgD,EAAWhD,EACXA,EAAM,KAAK,QAETgD,IAAa,QAAa,OAAOA,GAAa,SAChD,MAAM,IAAI,UAAU,2BAA2B,EAEjD,GAAI,OAAOA,GAAa,UAAY,CAACzB,EAAO,WAAWyB,CAAQ,EAC7D,MAAM,IAAI,UAAU,qBAAuBA,CAAQ,EAErD,GAAIiC,EAAI,SAAW,EAAG,CACpB,MAAM/F,EAAO+F,EAAI,WAAW,CAAC,GACxBjC,IAAa,QAAU9D,EAAO,KAC/B8D,IAAa,YAEfiC,EAAM/F,EAEf,CACA,MAAc,OAAO+F,GAAQ,SACxBA,EAAMA,EAAM,IACH,OAAOA,GAAQ,YACxBA,EAAM,OAAOA,CAAG,GAIlB,GAAIlF,EAAQ,GAAK,KAAK,OAASA,GAAS,KAAK,OAASC,EACpD,MAAM,IAAI,WAAW,oBAAoB,EAG3C,GAAIA,GAAOD,EACT,OAAO,KAGTA,EAAQA,IAAU,EAClBC,EAAMA,IAAQ,OAAY,KAAK,OAASA,IAAQ,EAE3CiF,IAAKA,EAAM,GAEhB,IAAIzJ,EACJ,GAAI,OAAOyJ,GAAQ,SACjB,IAAKzJ,EAAIuE,EAAOvE,EAAIwE,EAAK,EAAExE,EACzB,KAAKA,CAAC,EAAIyJ,MAEP,CACL,MAAMkC,EAAQ5F,EAAO,SAAS0D,CAAG,EAC7BA,EACA1D,EAAO,KAAK0D,EAAKjC,CAAQ,EACvBlH,EAAMqL,EAAM,OAClB,GAAIrL,IAAQ,EACV,MAAM,IAAI,UAAU,cAAgBmJ,EAClC,mCAAmC,EAEvC,IAAKzJ,EAAI,EAAGA,EAAIwE,EAAMD,EAAO,EAAEvE,EAC7B,KAAKA,EAAIuE,CAAK,EAAIoH,EAAM3L,EAAIM,CAAG,CAEtC,CAEG,OAAO,IACR,EAMD,MAAM+M,GAAS,CAAE,EACjB,SAASC,GAAGC,EAAKC,EAAYC,EAAM,CACjCJ,GAAOE,CAAG,EAAI,cAAwBE,CAAK,CACzC,aAAe,CACb,MAAO,EAEP,OAAO,eAAe,KAAM,UAAW,CACrC,MAAOD,EAAW,MAAM,KAAM,SAAS,EACvC,SAAU,GACV,aAAc,EACvB,CAAQ,EAGD,KAAK,KAAO,GAAG,KAAK,IAAI,KAAKD,CAAG,IAGhC,KAAK,MAEL,OAAO,KAAK,IACnB,CAEK,IAAI,MAAQ,CACV,OAAOA,CACd,CAEK,IAAI,KAAMnO,EAAO,CACf,OAAO,eAAe,KAAM,OAAQ,CAClC,aAAc,GACd,WAAY,GACZ,MAAAA,EACA,SAAU,EACnB,CAAQ,CACR,CAEK,UAAY,CACV,MAAO,GAAG,KAAK,IAAI,KAAKmO,CAAG,MAAM,KAAK,OAAO,EACpD,CACI,CACJ,CAECD,GAAE,2BACA,SAAUpL,EAAM,CACd,OAAIA,EACK,GAAGA,CAAI,+BAGT,gDACR,EAAE,UAAU,EACfoL,GAAE,uBACA,SAAUpL,EAAMyF,EAAQ,CACtB,MAAO,QAAQzF,CAAI,oDAAoD,OAAOyF,CAAM,EACrF,EAAE,SAAS,EACd2F,GAAE,mBACA,SAAUpE,EAAKwE,EAAOC,EAAO,CAC3B,IAAIC,EAAM,iBAAiB1E,CAAG,qBAC1B2E,EAAWF,EACf,OAAI,OAAO,UAAUA,CAAK,GAAK,KAAK,IAAIA,CAAK,EAAI,GAAK,GACpDE,EAAWC,GAAsB,OAAOH,CAAK,CAAC,EACrC,OAAOA,GAAU,WAC1BE,EAAW,OAAOF,CAAK,GACnBA,EAAQ,OAAO,CAAC,GAAK,OAAO,EAAE,GAAKA,EAAQ,EAAE,OAAO,CAAC,GAAK,OAAO,EAAE,MACrEE,EAAWC,GAAsBD,CAAQ,GAE3CA,GAAY,KAEdD,GAAO,eAAeF,CAAK,cAAcG,CAAQ,GAC1CD,CACR,EAAE,UAAU,EAEf,SAASE,GAAuBrE,EAAK,CACnC,IAAIqB,EAAM,GACN9K,EAAIyJ,EAAI,OACZ,MAAMlF,EAAQkF,EAAI,CAAC,IAAM,IAAM,EAAI,EACnC,KAAOzJ,GAAKuE,EAAQ,EAAGvE,GAAK,EAC1B8K,EAAM,IAAIrB,EAAI,MAAMzJ,EAAI,EAAGA,CAAC,CAAC,GAAG8K,CAAG,GAErC,MAAO,GAAGrB,EAAI,MAAM,EAAGzJ,CAAC,CAAC,GAAG8K,CAAG,EAClC,CAKC,SAASiD,GAAatH,EAAK1B,EAAQ3B,EAAY,CAC7C8I,GAAenH,EAAQ,QAAQ,GAC3B0B,EAAI1B,CAAM,IAAM,QAAa0B,EAAI1B,EAAS3B,CAAU,IAAM,SAC5DiJ,GAAYtH,EAAQ0B,EAAI,QAAUrD,EAAa,EAAE,CAEtD,CAEC,SAASwJ,GAAYxN,EAAOqN,EAAKtD,EAAK1C,EAAK1B,EAAQ3B,EAAY,CAC7D,GAAIhE,EAAQ+J,GAAO/J,EAAQqN,EAAK,CAC9B,MAAM7M,EAAI,OAAO6M,GAAQ,SAAW,IAAM,GAC1C,IAAIiB,GAEF,MAAIjB,IAAQ,GAAKA,IAAQ,OAAO,CAAC,EAC/BiB,GAAQ,OAAO9N,CAAC,WAAWA,CAAC,QAAQwD,EAAa,GAAK,CAAC,GAAGxD,CAAC,GAE3D8N,GAAQ,SAAS9N,CAAC,QAAQwD,EAAa,GAAK,EAAI,CAAC,GAAGxD,CAAC,iBACzCwD,EAAa,GAAK,EAAI,CAAC,GAAGxD,CAAC,GAKrC,IAAIyN,GAAO,iBAAiB,QAASK,GAAOtO,CAAK,CAC5D,CACG2O,GAAYtH,EAAK1B,EAAQ3B,CAAU,CACtC,CAEC,SAAS8I,GAAgB9M,EAAO8C,EAAM,CACpC,GAAI,OAAO9C,GAAU,SACnB,MAAM,IAAIiO,GAAO,qBAAqBnL,EAAM,SAAU9C,CAAK,CAEhE,CAEC,SAASiN,GAAajN,EAAOoH,EAAQzG,EAAM,CACzC,MAAI,KAAK,MAAMX,CAAK,IAAMA,GACxB8M,GAAe9M,EAAOW,CAAI,EACpB,IAAIsN,GAAO,iBAAyB,SAAU,aAAcjO,CAAK,GAGrEoH,EAAS,EACL,IAAI6G,GAAO,yBAGb,IAAIA,GAAO,iBAAyB,SACR,eAA6B7G,CAAM,GACnCpH,CAAK,CAC1C,CAKC,MAAM4O,GAAoB,oBAE1B,SAASC,GAAa/E,EAAK,CAMzB,GAJAA,EAAMA,EAAI,MAAM,GAAG,EAAE,CAAC,EAEtBA,EAAMA,EAAI,KAAI,EAAG,QAAQ8E,GAAmB,EAAE,EAE1C9E,EAAI,OAAS,EAAG,MAAO,GAE3B,KAAOA,EAAI,OAAS,IAAM,GACxBA,EAAMA,EAAM,IAEd,OAAOA,CACV,CAEC,SAASV,GAAad,EAAQwG,EAAO,CACnCA,EAAQA,GAAS,IACjB,IAAIlD,EACJ,MAAMxE,EAASkB,EAAO,OACtB,IAAIyG,EAAgB,KACpB,MAAMxC,EAAQ,CAAE,EAEhB,QAAS3L,EAAI,EAAGA,EAAIwG,EAAQ,EAAExG,EAAG,CAI/B,GAHAgL,EAAYtD,EAAO,WAAW1H,CAAC,EAG3BgL,EAAY,OAAUA,EAAY,MAAQ,CAE5C,GAAI,CAACmD,EAAe,CAElB,GAAInD,EAAY,MAAQ,EAEjBkD,GAAS,GAAK,IAAIvC,EAAM,KAAK,IAAM,IAAM,GAAI,EAClD,QACX,SAAoB3L,EAAI,IAAMwG,EAAQ,EAEtB0H,GAAS,GAAK,IAAIvC,EAAM,KAAK,IAAM,IAAM,GAAI,EAClD,QACX,CAGSwC,EAAgBnD,EAEhB,QACT,CAGO,GAAIA,EAAY,MAAQ,EACjBkD,GAAS,GAAK,IAAIvC,EAAM,KAAK,IAAM,IAAM,GAAI,EAClDwC,EAAgBnD,EAChB,QACT,CAGOA,GAAamD,EAAgB,OAAU,GAAKnD,EAAY,OAAU,KACnE,MAAUmD,IAEJD,GAAS,GAAK,IAAIvC,EAAM,KAAK,IAAM,IAAM,GAAI,EAMpD,GAHAwC,EAAgB,KAGZnD,EAAY,IAAM,CACpB,IAAKkD,GAAS,GAAK,EAAG,MACtBvC,EAAM,KAAKX,CAAS,CAC3B,SAAgBA,EAAY,KAAO,CAC5B,IAAKkD,GAAS,GAAK,EAAG,MACtBvC,EAAM,KACJX,GAAa,EAAM,IACnBA,EAAY,GAAO,GACpB,CACR,SAAgBA,EAAY,MAAS,CAC9B,IAAKkD,GAAS,GAAK,EAAG,MACtBvC,EAAM,KACJX,GAAa,GAAM,IACnBA,GAAa,EAAM,GAAO,IAC1BA,EAAY,GAAO,GACpB,CACR,SAAgBA,EAAY,QAAU,CAC/B,IAAKkD,GAAS,GAAK,EAAG,MACtBvC,EAAM,KACJX,GAAa,GAAO,IACpBA,GAAa,GAAM,GAAO,IAC1BA,GAAa,EAAM,GAAO,IAC1BA,EAAY,GAAO,GACpB,CACR,KACa,WAAI,MAAM,oBAAoB,CAE3C,CAEG,OAAOW,CACV,CAEC,SAASjB,GAAcxB,EAAK,CAC1B,MAAMkF,EAAY,CAAE,EACpB,QAASpO,EAAI,EAAGA,EAAIkJ,EAAI,OAAQ,EAAElJ,EAEhCoO,EAAU,KAAKlF,EAAI,WAAWlJ,CAAC,EAAI,GAAI,EAEzC,OAAOoO,CACV,CAEC,SAASvD,GAAgB3B,EAAKgF,EAAO,CACnC,IAAIxI,EAAG6G,EAAID,EACX,MAAM8B,EAAY,CAAE,EACpB,QAASpO,EAAI,EAAGA,EAAIkJ,EAAI,QACjB,GAAAgF,GAAS,GAAK,GADW,EAAElO,EAGhC0F,EAAIwD,EAAI,WAAWlJ,CAAC,EACpBuM,EAAK7G,GAAK,EACV4G,EAAK5G,EAAI,IACT0I,EAAU,KAAK9B,CAAE,EACjB8B,EAAU,KAAK7B,CAAE,EAGnB,OAAO6B,CACV,CAEC,SAAS3F,GAAeS,EAAK,CAC3B,OAAOtD,EAAO,YAAYqI,GAAY/E,CAAG,CAAC,CAC7C,CAEC,SAASsB,GAAY6D,EAAKC,EAAKvJ,EAAQyB,EAAQ,CAC7C,IAAIxG,EACJ,IAAKA,EAAI,EAAGA,EAAIwG,GACT,EAAAxG,EAAI+E,GAAUuJ,EAAI,QAAYtO,GAAKqO,EAAI,QADtB,EAAErO,EAExBsO,EAAItO,EAAI+E,CAAM,EAAIsJ,EAAIrO,CAAC,EAEzB,OAAOA,CACV,CAKC,SAAS+G,GAAYiB,EAAKjI,EAAM,CAC9B,OAAOiI,aAAejI,GACnBiI,GAAO,MAAQA,EAAI,aAAe,MAAQA,EAAI,YAAY,MAAQ,MACjEA,EAAI,YAAY,OAASjI,EAAK,IACrC,CACC,SAASkI,GAAaD,EAAK,CAEzB,OAAOA,IAAQA,CAClB,CAIC,MAAM0D,IAAuB,UAAY,CACvC,MAAM6C,EAAW,mBACXC,EAAQ,IAAI,MAAM,GAAG,EAC3B,QAASxO,EAAI,EAAGA,EAAI,GAAI,EAAEA,EAAG,CAC3B,MAAMyO,EAAMzO,EAAI,GAChB,QAASkK,EAAI,EAAGA,EAAI,GAAI,EAAEA,EACxBsE,EAAMC,EAAMvE,CAAC,EAAIqE,EAASvO,CAAC,EAAIuO,EAASrE,CAAC,CAEhD,CACG,OAAOsE,CACV,GAAK,EAGJ,SAASvC,GAAoByC,EAAI,CAC/B,OAAO,OAAO,OAAW,IAAcC,GAAyBD,CACnE,CAEC,SAASC,IAA0B,CACjC,MAAM,IAAI,MAAM,sBAAsB,CACvC,CACD,GAAEzL,CAAM,EAET,MAAM6C,EAAS7C,EAAO,OAEtBD,EAAe,KAAAC,EAAO,KACtBD,EAAsB,YAAAC,EAAO,YAC7BD,EAAiB,OAAAC,EAAO,OACxBD,EAAe,KAAAC,EAAO,KACtBD,EAAsB,YAAAC,EAAO,YAC7BD,EAA4B,kBAAAC,EAAO,kBACnCD,EAAqB,WAAAC,EAAO,WAC5BD,EAA4B,kBAAAC,EAAO,kBACnCD,EAAe,KAAAC,EAAO,KACtBD,EAAe,KAAAC,EAAO,KACtBD,EAAoB,UAAAC,EAAO,UAC3BD,EAAA,QAAkB8C,EAClB9C,EAAkB,QAAAC,EAAO,QACzBD,EAAiB,OAAAC,EAAO,OACxBD,EAAqB,WAAAC,EAAO,WAC5BD,EAA2B,iBAAAC,EAAO,iBAClCD,EAA2B,iBAAAC,EAAO,iBAClCD,EAAoB,UAAAC,EAAO,yECj0Eb0L,GAAG,UAAsB,CACtC,GAAI,OAAO,QAAW,YAAc,OAAO,OAAO,uBAA0B,WAAc,MAAO,GACjG,GAAI,OAAO,OAAO,UAAa,SAAY,MAAO,GAGlD,IAAI5G,EAAM,CAAE,EACRuF,EAAM,OAAO,MAAM,EACnBsB,EAAS,OAAOtB,CAAG,EAIvB,GAHI,OAAOA,GAAQ,UAEf,OAAO,UAAU,SAAS,KAAKA,CAAG,IAAM,mBACxC,OAAO,UAAU,SAAS,KAAKsB,CAAM,IAAM,kBAAqB,MAAO,GAU3E,IAAIC,EAAS,GACb9G,EAAIuF,CAAG,EAAIuB,EACX,QAASC,KAAK/G,EAAO,MAAO,GAG5B,GAFI,OAAO,OAAO,MAAS,YAAc,OAAO,KAAKA,CAAG,EAAE,SAAW,GAEjE,OAAO,OAAO,qBAAwB,YAAc,OAAO,oBAAoBA,CAAG,EAAE,SAAW,EAAK,MAAO,GAE/G,IAAIgH,EAAO,OAAO,sBAAsBhH,CAAG,EAG3C,GAFIgH,EAAK,SAAW,GAAKA,EAAK,CAAC,IAAMzB,GAEjC,CAAC,OAAO,UAAU,qBAAqB,KAAKvF,EAAKuF,CAAG,EAAK,MAAO,GAEpE,GAAI,OAAO,OAAO,0BAA6B,WAAY,CAE1D,IAAI0B,EAAgD,OAAO,yBAAyBjH,EAAKuF,CAAG,EAC5F,GAAI0B,EAAW,QAAUH,GAAUG,EAAW,aAAe,GAAQ,MAAO,EAC9E,CAEC,MAAO,EACP,mDC1CD,IAAIC,EAAalM,GAA4B,EAG/B,OAAA4L,GAAG,UAA+B,CAC/C,OAAOM,EAAY,GAAI,CAAC,CAAC,OAAO,WAChC,8CCJDC,GAAiB,oDCAjBC,GAAiB,mDCAjBC,GAAiB,uDCAjB3B,GAAiB,wDCAjB4B,GAAiB,4DCAjBC,GAAiB,yDCAjBxP,GAAiB,uDCAjByP,GAAiB,sDCAHC,GAAG,KAAK,iDCARC,GAAG,KAAK,mDCARvG,GAAG,KAAK,iDCARsD,GAAG,KAAK,iDCARkD,GAAG,KAAK,iDCARC,GAAG,KAAK,mDCARC,GAAG,OAAO,OAAS,SAAe3H,EAAG,CAClD,OAAOA,IAAMA,CACb,mDCHD,IAAI4H,EAA2B9M,GAAA,EAG/B,OAAA+M,GAAiB,SAAcC,EAAQ,CACtC,OAAIF,EAAOE,CAAM,GAAKA,IAAW,EACzBA,EAEDA,EAAS,EAAI,GAAK,CACzB,8CCPaC,GAAG,OAAO,0ECAxB,IAAIC,EAAyBlN,GAAA,EAE7B,GAAIkN,EACH,GAAI,CACHA,EAAM,CAAE,EAAE,QAAQ,CAClB,MAAW,CAEXA,EAAQ,IACV,CAGA,OAAAC,GAAiBD,kDCXjB,IAAIE,EAAkB,OAAO,gBAAkB,GAC/C,GAAIA,EACH,GAAI,CACHA,EAAgB,GAAI,IAAK,CAAE,MAAO,CAAC,CAAE,CACrC,MAAW,CAEXA,EAAkB,EACpB,CAGA,OAAAC,GAAiBD,kDCXjB,IAAIE,EAAa,OAAO,OAAW,KAAe,OAC9CC,EAAgBvN,GAAkB,EAGxB,OAAAkM,GAAG,UAA4B,CAI5C,OAHI,OAAOoB,GAAe,YACtB,OAAO,QAAW,YAClB,OAAOA,EAAW,KAAK,GAAM,UAC7B,OAAO,OAAO,KAAK,GAAM,SAAmB,GAEzCC,EAAe,CACtB,8CCVaC,GAAI,OAAO,QAAY,KAAe,QAAQ,gBAAmB,sDCD/E,IAAIC,EAAoCzN,GAAA,EAGxC,OAAA0N,GAAiBD,EAAQ,gBAAkB,qDCD3C,IAAIE,EAAgB,kDAChBC,EAAQ,OAAO,UAAU,SACzBzH,EAAM,KAAK,IACX0H,EAAW,oBAEXC,EAAW,SAAkB5I,EAAGhB,EAAG,CAGnC,QAFIpF,EAAM,CAAE,EAEH9B,EAAI,EAAGA,EAAIkI,EAAE,OAAQlI,GAAK,EAC/B8B,EAAI9B,CAAC,EAAIkI,EAAElI,CAAC,EAEhB,QAASkK,EAAI,EAAGA,EAAIhD,EAAE,OAAQgD,GAAK,EAC/BpI,EAAIoI,EAAIhC,EAAE,MAAM,EAAIhB,EAAEgD,CAAC,EAG3B,OAAOpI,CACV,EAEGiP,EAAQ,SAAeC,EAASjM,EAAQ,CAExC,QADIjD,EAAM,CAAE,EACH9B,EAAI+E,EAAamF,EAAI,EAAGlK,EAAIgR,EAAQ,OAAQhR,GAAK,EAAGkK,GAAK,EAC9DpI,EAAIoI,CAAC,EAAI8G,EAAQhR,CAAC,EAEtB,OAAO8B,CACV,EAEGmP,EAAQ,SAAUnP,EAAKoP,EAAQ,CAE/B,QADIhI,EAAM,GACDlJ,EAAI,EAAGA,EAAI8B,EAAI,OAAQ9B,GAAK,EACjCkJ,GAAOpH,EAAI9B,CAAC,EACRA,EAAI,EAAI8B,EAAI,SACZoH,GAAOgI,GAGf,OAAOhI,CACV,EAED,OAAAiI,GAAiB,SAAcrR,EAAM,CACjC,IAAIjB,EAAS,KACb,GAAI,OAAOA,GAAW,YAAc+R,EAAM,MAAM/R,CAAM,IAAMgS,EACxD,MAAM,IAAI,UAAUF,EAAgB9R,CAAM,EAyB9C,QAvBIE,EAAOgS,EAAM,UAAW,CAAC,EAEzBK,EACAC,EAAS,UAAY,CACrB,GAAI,gBAAgBD,EAAO,CACvB,IAAIE,EAASzS,EAAO,MAChB,KACAiS,EAAS/R,EAAM,SAAS,CAC3B,EACD,OAAI,OAAOuS,CAAM,IAAMA,EACZA,EAEJ,IACnB,CACQ,OAAOzS,EAAO,MACViB,EACAgR,EAAS/R,EAAM,SAAS,CAC3B,CAEJ,EAEGwS,EAAcpI,EAAI,EAAGtK,EAAO,OAASE,EAAK,MAAM,EAChDyS,EAAY,CAAE,EACTxR,EAAI,EAAGA,EAAIuR,EAAavR,IAC7BwR,EAAUxR,CAAC,EAAI,IAAMA,EAKzB,GAFAoR,EAAQ,SAAS,SAAU,oBAAsBH,EAAMO,EAAW,GAAG,EAAI,2CAA2C,EAAEH,CAAM,EAExHxS,EAAO,UAAW,CAClB,IAAI4S,EAAQ,UAAiB,CAAE,EAC/BA,EAAM,UAAY5S,EAAO,UACzBuS,EAAM,UAAY,IAAIK,EACtBA,EAAM,UAAY,IAC1B,CAEI,OAAOL,CACV,kDCjFD,IAAID,EAAiBnO,GAA2B,EAEhD,OAAA0O,GAAiB,SAAS,UAAU,MAAQP,8CCD5CQ,GAAiB,SAAS,UAAU,kDCApCC,GAAiB,SAAS,UAAU,mDCAtBC,GAAG,OAAO,QAAY,KAAe,SAAW,QAAQ,uDCDtE,IAAIC,EAAO9O,GAAwB,EAE/B+O,EAASC,GAA0B,EACnCC,EAAQC,GAAyB,EACjCC,EAAgBC,GAAyB,EAG/B,OAAAC,GAAGF,GAAiBL,EAAK,KAAKG,EAAOF,CAAM,kDCPzD,IAAID,EAAO9O,GAAwB,EAC/BsP,EAAsCN,GAAA,EAEtCC,EAAQC,GAAyB,EACjCK,EAAeH,GAAwB,EAG3C,OAAAI,GAAiB,SAAuBzT,EAAM,CAC7C,GAAIA,EAAK,OAAS,GAAK,OAAOA,EAAK,CAAC,GAAM,WACzC,MAAM,IAAIuT,EAAW,wBAAwB,EAE9C,OAAOC,EAAaT,EAAMG,EAAOlT,CAAI,CACrC,kDCZD,IAAI0T,EAAWzP,GAAkC,EAC7CiN,EAAsB+B,GAAA,EAEtBU,EACJ,GAAI,CAEHA,EAA0E,GAAI,YAAc,MAAM,SAClG,OAAQvN,EAAG,CACX,GAAI,CAACA,GAAK,OAAOA,GAAM,UAAY,EAAE,SAAUA,IAAMA,EAAE,OAAS,mBAC/D,MAAMA,CAER,CAGA,IAAIwN,EAAO,CAAC,CAACD,GAAoBzC,GAAQA,EAAK,OAAO,UAAyD,WAAa,EAEvHQ,EAAU,OACVmC,EAAkBnC,EAAQ,eAG9B,OAAAoC,GAAiBF,GAAQ,OAAOA,EAAK,KAAQ,WAC1CF,EAAS,CAACE,EAAK,GAAG,CAAC,EACnB,OAAOC,GAAoB,WACK,SAAmBxT,EAAO,CAE1D,OAAOwT,EAAgBxT,GAAS,KAAOA,EAAQqR,EAAQrR,CAAK,CAAC,CAChE,EACI,mDC3BJ,IAAI0T,EAAkB9P,GAAmC,EACrD+P,EAAmBf,GAAkC,EAErDgB,EAA4Cd,GAAA,EAGhD,OAAAe,GAAiBH,EACd,SAAkBI,EAAG,CAEtB,OAAOJ,EAAgBI,CAAC,CAC1B,EACGH,EACC,SAAkBG,EAAG,CACtB,GAAI,CAACA,GAAM,OAAOA,GAAM,UAAY,OAAOA,GAAM,WAChD,MAAM,IAAI,UAAU,yBAAyB,EAG9C,OAAOH,EAAiBG,CAAC,CAC5B,EACIF,EACC,SAAkBE,EAAG,CAEtB,OAAOF,EAAeE,CAAC,CAC3B,EACK,qDCxBL,IAAIC,EAAO,SAAS,UAAU,KAC1BC,EAAU,OAAO,UAAU,eAC3BtB,EAAO9O,GAAwB,EAGrB,OAAAqQ,GAAGvB,EAAK,KAAKqB,EAAMC,CAAO,kDCLxC,IAAIE,EAEA7C,EAAoCzN,GAAA,EAEpCuQ,EAA6BvB,GAAA,EAC7BwB,EAAsCtB,GAAA,EACtCuB,EAAwCrB,GAAA,EACxCsB,EAA0CC,GAAA,EAC1CC,EAA0CC,GAAA,EAC1CvB,EAAsCwB,GAAA,EACtCC,EAAoCC,GAAA,EAEpCvE,EAAoCwE,GAAA,EACpCvE,EAAwCwE,GAAA,EACxC/K,EAAoCgL,GAAA,EACpC1H,EAAoC2H,GAAA,EACpCzE,EAAoC0E,GAAA,EACpCzE,EAAwC0E,GAAA,EACxCvE,EAAsCwE,GAAA,EAEtCC,EAAY,SAGZC,EAAwB,SAAUC,EAAkB,CACvD,GAAI,CACH,OAAOF,EAAU,yBAA2BE,EAAmB,gBAAgB,EAAG,CAClF,MAAW,EACZ,EAEGxE,EAAuByE,GAAA,EACvBvE,EAA+CwE,GAAA,EAE/CC,EAAiB,UAAY,CAChC,MAAM,IAAIvC,CACV,EACGwC,EAAiB5E,GACjB,UAAY,CACd,GAAI,CAEH,OAAU,iBACH2E,CACP,MAAsB,CACtB,GAAI,CAEH,OAAO3E,EAAM,UAAW,QAAQ,EAAE,GAClC,MAAoB,CACpB,OAAO2E,CACX,CACA,CACA,GAAI,EACDA,EAEC3F,EAAa6F,KAAwB,EAErC9B,EAAW+B,GAAoB,EAC/BC,EAAaC,GAA0C,EACvDC,EAAcC,GAA2C,EAEzDrD,EAASsD,GAAgD,EACzDpD,EAAQqD,GAA+C,EAEvDC,EAAY,CAAE,EAEdC,EAAa,OAAO,WAAe,KAAe,CAACvC,EAAWK,EAAYL,EAAS,UAAU,EAE7FwC,GAAa,CAChB,UAAW,KACX,mBAAoB,OAAO,eAAmB,IAAcnC,EAAY,eACxE,UAAW,MACX,gBAAiB,OAAO,YAAgB,IAAcA,EAAY,YAClE,2BAA4BpE,GAAc+D,EAAWA,EAAS,CAAE,EAAC,OAAO,QAAQ,EAAG,GAAIK,EACvF,mCAAoCA,EACpC,kBAAmBiC,EACnB,mBAAoBA,EACpB,2BAA4BA,EAC5B,2BAA4BA,EAC5B,YAAa,OAAO,QAAY,IAAcjC,EAAY,QAC1D,WAAY,OAAO,OAAW,IAAcA,EAAY,OACxD,kBAAmB,OAAO,cAAkB,IAAcA,EAAY,cACtE,mBAAoB,OAAO,eAAmB,IAAcA,EAAY,eACxE,YAAa,QACb,aAAc,OAAO,SAAa,IAAcA,EAAY,SAC5D,SAAU,KACV,cAAe,UACf,uBAAwB,mBACxB,cAAe,UACf,uBAAwB,mBACxB,UAAWC,EACX,SAAU,KACV,cAAeC,EACf,iBAAkB,OAAO,aAAiB,IAAcF,EAAY,aACpE,iBAAkB,OAAO,aAAiB,IAAcA,EAAY,aACpE,iBAAkB,OAAO,aAAiB,IAAcA,EAAY,aACpE,yBAA0B,OAAO,qBAAyB,IAAcA,EAAY,qBACpF,aAAckB,EACd,sBAAuBe,EACvB,cAAe,OAAO,UAAc,IAAcjC,EAAY,UAC9D,eAAgB,OAAO,WAAe,IAAcA,EAAY,WAChE,eAAgB,OAAO,WAAe,IAAcA,EAAY,WAChE,aAAc,SACd,UAAW,MACX,sBAAuBpE,GAAc+D,EAAWA,EAASA,EAAS,GAAG,OAAO,QAAQ,GAAG,CAAC,EAAIK,EAC5F,SAAU,OAAO,MAAS,SAAW,KAAOA,EAC5C,QAAS,OAAO,IAAQ,IAAcA,EAAY,IAClD,yBAA0B,OAAO,IAAQ,KAAe,CAACpE,GAAc,CAAC+D,EAAWK,EAAYL,EAAS,IAAI,IAAG,EAAG,OAAO,QAAQ,EAAC,CAAE,EACpI,SAAU,KACV,WAAY,OACZ,WAAYxC,EACZ,oCAAqCP,EACrC,eAAgB,WAChB,aAAc,SACd,YAAa,OAAO,QAAY,IAAcoD,EAAY,QAC1D,UAAW,OAAO,MAAU,IAAcA,EAAY,MACtD,eAAgBG,EAChB,mBAAoBC,EACpB,YAAa,OAAO,QAAY,IAAcJ,EAAY,QAC1D,WAAY,OACZ,QAAS,OAAO,IAAQ,IAAcA,EAAY,IAClD,yBAA0B,OAAO,IAAQ,KAAe,CAACpE,GAAc,CAAC+D,EAAWK,EAAYL,EAAS,IAAI,IAAG,EAAG,OAAO,QAAQ,EAAC,CAAE,EACpI,sBAAuB,OAAO,kBAAsB,IAAcK,EAAY,kBAC9E,WAAY,OACZ,4BAA6BpE,GAAc+D,EAAWA,EAAS,GAAG,OAAO,QAAQ,EAAG,GAAIK,EACxF,WAAYpE,EAAa,OAASoE,EAClC,gBAAiBM,EACjB,mBAAoBkB,EACpB,eAAgBU,EAChB,cAAelD,EACf,eAAgB,OAAO,WAAe,IAAcgB,EAAY,WAChE,sBAAuB,OAAO,kBAAsB,IAAcA,EAAY,kBAC9E,gBAAiB,OAAO,YAAgB,IAAcA,EAAY,YAClE,gBAAiB,OAAO,YAAgB,IAAcA,EAAY,YAClE,aAAcS,EACd,YAAa,OAAO,QAAY,IAAcT,EAAY,QAC1D,YAAa,OAAO,QAAY,IAAcA,EAAY,QAC1D,YAAa,OAAO,QAAY,IAAcA,EAAY,QAE1D,4BAA6BrB,EAC7B,6BAA8BF,EAC9B,0BAA2B3B,EAC3B,0BAA2B6E,EAC3B,aAAcxF,EACd,eAAgBC,EAChB,aAAcvG,EACd,aAAcsD,EACd,aAAckD,EACd,eAAgBC,EAChB,cAAeG,EACf,2BAA4BoF,CAC5B,EAED,GAAIlC,EACH,GAAI,CACH,KAAK,KACL,OAAQ9N,EAAG,CAEX,IAAIuQ,GAAazC,EAASA,EAAS9N,CAAC,CAAC,EACrCsQ,GAAW,mBAAmB,EAAIC,EACpC,CAGA,IAAIC,GAAS,SAASA,EAAOzT,EAAM,CAClC,IAAI9C,EACJ,GAAI8C,IAAS,kBACZ9C,EAAQqV,EAAsB,sBAAsB,UAC1CvS,IAAS,sBACnB9C,EAAQqV,EAAsB,iBAAiB,UACrCvS,IAAS,2BACnB9C,EAAQqV,EAAsB,uBAAuB,UAC3CvS,IAAS,mBAAoB,CACvC,IAAIwM,EAAKiH,EAAO,0BAA0B,EACtCjH,IACHtP,EAAQsP,EAAG,UAEd,SAAYxM,IAAS,2BAA4B,CAC/C,IAAI0T,EAAMD,EAAO,kBAAkB,EAC/BC,GAAO3C,IACV7T,EAAQ6T,EAAS2C,EAAI,SAAS,EAEjC,CAEC,OAAAH,GAAWvT,CAAI,EAAI9C,EAEZA,CACP,EAEGyW,EAAiB,CACpB,UAAW,KACX,yBAA0B,CAAC,cAAe,WAAW,EACrD,mBAAoB,CAAC,QAAS,WAAW,EACzC,uBAAwB,CAAC,QAAS,YAAa,SAAS,EACxD,uBAAwB,CAAC,QAAS,YAAa,SAAS,EACxD,oBAAqB,CAAC,QAAS,YAAa,MAAM,EAClD,sBAAuB,CAAC,QAAS,YAAa,QAAQ,EACtD,2BAA4B,CAAC,gBAAiB,WAAW,EACzD,mBAAoB,CAAC,yBAA0B,WAAW,EAC1D,4BAA6B,CAAC,yBAA0B,YAAa,WAAW,EAChF,qBAAsB,CAAC,UAAW,WAAW,EAC7C,sBAAuB,CAAC,WAAY,WAAW,EAC/C,kBAAmB,CAAC,OAAQ,WAAW,EACvC,mBAAoB,CAAC,QAAS,WAAW,EACzC,uBAAwB,CAAC,YAAa,WAAW,EACjD,0BAA2B,CAAC,eAAgB,WAAW,EACvD,0BAA2B,CAAC,eAAgB,WAAW,EACvD,sBAAuB,CAAC,WAAY,WAAW,EAC/C,cAAe,CAAC,oBAAqB,WAAW,EAChD,uBAAwB,CAAC,oBAAqB,YAAa,WAAW,EACtE,uBAAwB,CAAC,YAAa,WAAW,EACjD,wBAAyB,CAAC,aAAc,WAAW,EACnD,wBAAyB,CAAC,aAAc,WAAW,EACnD,cAAe,CAAC,OAAQ,OAAO,EAC/B,kBAAmB,CAAC,OAAQ,WAAW,EACvC,iBAAkB,CAAC,MAAO,WAAW,EACrC,oBAAqB,CAAC,SAAU,WAAW,EAC3C,oBAAqB,CAAC,SAAU,WAAW,EAC3C,sBAAuB,CAAC,SAAU,YAAa,UAAU,EACzD,qBAAsB,CAAC,SAAU,YAAa,SAAS,EACvD,qBAAsB,CAAC,UAAW,WAAW,EAC7C,sBAAuB,CAAC,UAAW,YAAa,MAAM,EACtD,gBAAiB,CAAC,UAAW,KAAK,EAClC,mBAAoB,CAAC,UAAW,QAAQ,EACxC,oBAAqB,CAAC,UAAW,SAAS,EAC1C,wBAAyB,CAAC,aAAc,WAAW,EACnD,4BAA6B,CAAC,iBAAkB,WAAW,EAC3D,oBAAqB,CAAC,SAAU,WAAW,EAC3C,iBAAkB,CAAC,MAAO,WAAW,EACrC,+BAAgC,CAAC,oBAAqB,WAAW,EACjE,oBAAqB,CAAC,SAAU,WAAW,EAC3C,oBAAqB,CAAC,SAAU,WAAW,EAC3C,yBAA0B,CAAC,cAAe,WAAW,EACrD,wBAAyB,CAAC,aAAc,WAAW,EACnD,uBAAwB,CAAC,YAAa,WAAW,EACjD,wBAAyB,CAAC,aAAc,WAAW,EACnD,+BAAgC,CAAC,oBAAqB,WAAW,EACjE,yBAA0B,CAAC,cAAe,WAAW,EACrD,yBAA0B,CAAC,cAAe,WAAW,EACrD,sBAAuB,CAAC,WAAY,WAAW,EAC/C,qBAAsB,CAAC,UAAW,WAAW,EAC7C,qBAAsB,CAAC,UAAW,WAAW,CAC7C,EAEG/D,GAAOgE,GAAwB,EAC/BC,GAA0BC,GAAA,EAC1BC,GAAUnE,GAAK,KAAKG,EAAO,MAAM,UAAU,MAAM,EACjDiE,GAAepE,GAAK,KAAKC,EAAQ,MAAM,UAAU,MAAM,EACvDoE,GAAWrE,GAAK,KAAKG,EAAO,OAAO,UAAU,OAAO,EACpDmE,EAAYtE,GAAK,KAAKG,EAAO,OAAO,UAAU,KAAK,EACnDoE,EAAQvE,GAAK,KAAKG,EAAO,OAAO,UAAU,IAAI,EAG9CqE,EAAa,qGACbC,EAAe,WACfC,EAAe,SAAsB9O,EAAQ,CAChD,IAAIyE,EAAQiK,EAAU1O,EAAQ,EAAG,CAAC,EAC9B0E,EAAOgK,EAAU1O,EAAQ,EAAE,EAC/B,GAAIyE,IAAU,KAAOC,IAAS,IAC7B,MAAM,IAAIwH,EAAa,gDAAgD,EACjE,GAAIxH,IAAS,KAAOD,IAAU,IACpC,MAAM,IAAIyH,EAAa,gDAAgD,EAExE,IAAItC,EAAS,CAAE,EACf,OAAA6E,GAASzO,EAAQ4O,EAAY,SAAUG,EAAOzG,EAAQ0G,EAAOC,EAAW,CACvErF,EAAOA,EAAO,MAAM,EAAIoF,EAAQP,GAASQ,EAAWJ,EAAc,IAAI,EAAIvG,GAAUyG,CACtF,CAAE,EACMnF,CACP,EAGGsF,EAAmB,SAA0B1U,EAAM2U,EAAc,CACpE,IAAIC,EAAgB5U,EAChB6U,EAMJ,GALIhB,GAAOF,EAAgBiB,CAAa,IACvCC,EAAQlB,EAAeiB,CAAa,EACpCA,EAAgB,IAAMC,EAAM,CAAC,EAAI,KAG9BhB,GAAON,GAAYqB,CAAa,EAAG,CACtC,IAAI1X,EAAQqW,GAAWqB,CAAa,EAIpC,GAHI1X,IAAUmW,IACbnW,EAAQuW,GAAOmB,CAAa,GAEzB,OAAO1X,EAAU,KAAe,CAACyX,EACpC,MAAM,IAAIvE,EAAW,aAAepQ,EAAO,sDAAsD,EAGlG,MAAO,CACN,MAAO6U,EACP,KAAMD,EACN,MAAO1X,CACP,CACH,CAEC,MAAM,IAAIwU,EAAa,aAAe1R,EAAO,kBAAkB,CAC/D,EAED,OAAA8U,GAAiB,SAAsB9U,EAAM2U,EAAc,CAC1D,GAAI,OAAO3U,GAAS,UAAYA,EAAK,SAAW,EAC/C,MAAM,IAAIoQ,EAAW,2CAA2C,EAEjE,GAAI,UAAU,OAAS,GAAK,OAAOuE,GAAiB,UACnD,MAAM,IAAIvE,EAAW,2CAA2C,EAGjE,GAAI+D,EAAM,cAAenU,CAAI,IAAM,KAClC,MAAM,IAAI0R,EAAa,oFAAoF,EAE5G,IAAIjP,EAAQ6R,EAAatU,CAAI,EACzB+U,EAAoBtS,EAAM,OAAS,EAAIA,EAAM,CAAC,EAAI,GAElDuS,EAAYN,EAAiB,IAAMK,EAAoB,IAAKJ,CAAY,EACxEM,EAAoBD,EAAU,KAC9B9X,EAAQ8X,EAAU,MAClBE,EAAqB,GAErBL,EAAQG,EAAU,MAClBH,IACHE,EAAoBF,EAAM,CAAC,EAC3Bb,GAAavR,EAAOsR,GAAQ,CAAC,EAAG,CAAC,EAAGc,CAAK,CAAC,GAG3C,QAAS/W,GAAI,EAAGqX,EAAQ,GAAMrX,GAAI2E,EAAM,OAAQ3E,IAAK,EAAG,CACvD,IAAIsX,GAAO3S,EAAM3E,EAAC,EACdmM,GAAQiK,EAAUkB,GAAM,EAAG,CAAC,EAC5BlL,GAAOgK,EAAUkB,GAAM,EAAE,EAC7B,IAEGnL,KAAU,KAAOA,KAAU,KAAOA,KAAU,KACzCC,KAAS,KAAOA,KAAS,KAAOA,KAAS,MAE3CD,KAAUC,GAEb,MAAM,IAAIwH,EAAa,sDAAsD,EAS9E,IAPI0D,KAAS,eAAiB,CAACD,KAC9BD,EAAqB,IAGtBH,GAAqB,IAAMK,GAC3BH,EAAoB,IAAMF,EAAoB,IAE1ClB,GAAON,GAAY0B,CAAiB,EACvC/X,EAAQqW,GAAW0B,CAAiB,UAC1B/X,GAAS,KAAM,CACzB,GAAI,EAAEkY,MAAQlY,GAAQ,CACrB,GAAI,CAACyX,EACJ,MAAM,IAAIvE,EAAW,sBAAwBpQ,EAAO,6CAA6C,EAElG,MACJ,CACG,GAAIgO,GAAUlQ,GAAI,GAAM2E,EAAM,OAAQ,CACrC,IAAIgO,GAAOzC,EAAM9Q,EAAOkY,EAAI,EAC5BD,EAAQ,CAAC,CAAC1E,GASN0E,GAAS,QAAS1E,IAAQ,EAAE,kBAAmBA,GAAK,KACvDvT,EAAQuT,GAAK,IAEbvT,EAAQA,EAAMkY,EAAI,CAEvB,MACID,EAAQtB,GAAO3W,EAAOkY,EAAI,EAC1BlY,EAAQA,EAAMkY,EAAI,EAGfD,GAAS,CAACD,IACb3B,GAAW0B,CAAiB,EAAI/X,EAEpC,CACA,CACC,OAAOA,CACP,kDCvXD,IAAImY,EAAuCvU,GAAA,EAEvCwU,EAAgBxF,GAAkC,EAGlDyF,EAAWD,EAAc,CAACD,EAAa,4BAA4B,CAAC,CAAC,EAGzE,OAAAG,GAAiB,SAA4BxV,EAAM2U,EAAc,CAGhE,IAAIK,EAA2EK,EAAarV,EAAM,CAAC,CAAC2U,CAAY,EAChH,OAAI,OAAOK,GAAc,YAAcO,EAASvV,EAAM,aAAa,EAAI,GAC/DsV,EAAoC,CAACN,CAAS,CAAG,EAElDA,CACP,kDChBD,IAAIS,EAAiB3U,KAAkC,EACnD0U,EAAiC1F,GAAA,EAEjC4F,EAAYF,EAAU,2BAA2B,EAGjDG,EAAsB,SAAqBzY,EAAO,CACrD,OACCuY,GACGvY,GACA,OAAOA,GAAU,UACjB,OAAO,eAAeA,EAElB,GAEDwY,EAAUxY,CAAK,IAAM,oBAC5B,EAGG0Y,EAAoB,SAAqB1Y,EAAO,CACnD,OAAIyY,EAAoBzY,CAAK,EACrB,GAEDA,IAAU,MACb,OAAOA,GAAU,UACjB,WAAYA,GACZ,OAAOA,EAAM,QAAW,UACxBA,EAAM,QAAU,GAChBwY,EAAUxY,CAAK,IAAM,kBACrB,WAAYA,GACZwY,EAAUxY,EAAM,MAAM,IAAM,mBAChC,EAEG2Y,GAA6B,UAAY,CAC5C,OAAOF,EAAoB,SAAS,CACrC,KAGA,OAAAA,EAAoB,kBAAoBC,EAGxCE,GAAiBD,EAA4BF,EAAsBC,kDCzCnE,IAAIJ,EAAiC1U,GAAA,EACjC2U,EAAiB3F,KAAkC,EACnD+D,EAA0B7D,GAAA,EAC1BjC,EAAsBmC,GAAA,EAGtB1D,EAEJ,GAAIiJ,EAAgB,CAEnB,IAAItB,EAAQqB,EAAU,uBAAuB,EAEzCO,EAAgB,CAAE,EAElBC,EAAmB,UAAY,CAClC,MAAMD,CACN,EAEGE,EAAiB,CACpB,SAAUD,EACV,QAASA,CACT,EAEG,OAAO,OAAO,aAAgB,WACjCC,EAAe,OAAO,WAAW,EAAID,GAMtCxJ,EAAK,SAAiBtP,EAAO,CAC5B,GAAI,CAACA,GAAS,OAAOA,GAAU,SAC9B,MAAO,GAIR,IAAI6P,EAAsDgB,EAA8C7Q,EAAQ,WAAW,EACvHgZ,EAA2BnJ,GAAc8G,EAAO9G,EAAY,OAAO,EACvE,GAAI,CAACmJ,EACJ,MAAO,GAGR,GAAI,CAEH/B,EAAMjX,EAAsD+Y,CAAiB,CAC7E,OAAQhT,EAAG,CACX,OAAOA,IAAM8S,CAChB,CACE,CACF,KAAO,CAEN,IAAIL,EAAYF,EAAU,2BAA2B,EAEjDW,EAAa,kBAGjB3J,EAAK,SAAiBtP,EAAO,CAE5B,MAAI,CAACA,GAAU,OAAOA,GAAU,UAAY,OAAOA,GAAU,WACrD,GAGDwY,EAAUxY,CAAK,IAAMiZ,CAC5B,CACF,CAEA,OAAAC,GAAiB5J,kDClEjB,IAAIgJ,EAAiC1U,GAAA,EACjCsV,EAAUtG,GAAmB,EAE7BqE,EAAQqB,EAAU,uBAAuB,EACzCpF,EAAsCJ,GAAA,EAG1C,OAAAqG,GAAiB,SAAqBC,EAAO,CAC5C,GAAI,CAACF,EAAQE,CAAK,EACjB,MAAM,IAAIlG,EAAW,0BAA0B,EAEhD,OAAO,SAAc7M,EAAG,CACvB,OAAO4Q,EAAMmC,EAAO/S,CAAC,IAAM,IAC3B,CACD,kDCbD,MAAMgT,EAAsD,WAAa,CAAE,EAAC,YAG9D,OAAAC,GAAG,IAAMD,kDCJvB,IAAIf,EAAiC1U,GAAA,EACjCuV,EAA0CvG,GAAA,EAC1C2G,EAAYJ,EAAc,qBAAqB,EAC/CZ,EAAiBzF,KAAkC,EACnDe,EAAWb,GAAoB,EAE/BxB,EAAQ8G,EAAU,2BAA2B,EAC7CkB,EAAUlB,EAAU,6BAA6B,EAEjDmB,EAAoDlF,GAAA,EAGxD,OAAAmF,GAAiB,SAA6BpK,EAAI,CACjD,GAAI,OAAOA,GAAO,WACjB,MAAO,GAER,GAAIiK,EAAUC,EAAQlK,CAAE,CAAC,EACxB,MAAO,GAER,GAAI,CAACiJ,EAAgB,CACpB,IAAIzO,EAAM0H,EAAMlC,CAAE,EAClB,OAAOxF,IAAQ,4BACjB,CACC,GAAI,CAAC+J,EACJ,MAAO,GAER,IAAI8F,EAAoBF,EAAsB,EAC9C,OAAOE,GAAqB9F,EAASvE,CAAE,IAAMqK,EAAkB,SAC/D,kDC5BD,IAAIH,EAAU,SAAS,UAAU,SAC7B/G,EAAe,OAAO,SAAY,UAAY,UAAY,MAAQ,QAAQ,MAC1EmH,EACAC,EACJ,GAAI,OAAOpH,GAAiB,YAAc,OAAO,OAAO,gBAAmB,WAC1E,GAAI,CACHmH,EAAe,OAAO,eAAe,GAAI,SAAU,CAClD,IAAK,UAAY,CAChB,MAAMC,CACV,CACA,CAAG,EACDA,EAAmB,CAAE,EAErBpH,EAAa,UAAY,CAAE,KAAS,KAAI,KAAMmH,CAAY,CAC1D,OAAQjK,EAAG,CACPA,IAAMkK,IACTpH,EAAe,KAElB,MAECA,EAAe,KAGhB,IAAIqH,EAAmB,cACnBC,EAAe,SAA4B/Z,EAAO,CACrD,GAAI,CACH,IAAIga,EAAQR,EAAQ,KAAKxZ,CAAK,EAC9B,OAAO8Z,EAAiB,KAAKE,CAAK,CAClC,MAAW,CACX,MAAO,EACT,CACC,EAEGC,EAAoB,SAA0Bja,EAAO,CACxD,GAAI,CACH,OAAI+Z,EAAa/Z,CAAK,EAAY,IAClCwZ,EAAQ,KAAKxZ,CAAK,EACX,GACP,MAAW,CACX,MAAO,EACT,CACC,EACGwR,EAAQ,OAAO,UAAU,SACzB0I,EAAc,kBACdC,EAAU,oBACVC,EAAW,6BACXC,EAAW,6BACXC,EAAY,mCACZC,EAAY,0BACZhC,EAAiB,OAAO,QAAW,YAAc,CAAC,CAAC,OAAO,YAE1DiC,EAAS,EAAE,IAAK,KAEhBC,EAAQ,UAA4B,CAAE,MAAO,EAAQ,EACzD,GAAI,OAAO,UAAa,SAAU,CAEjC,IAAIC,EAAM,SAAS,IACflJ,EAAM,KAAKkJ,CAAG,IAAMlJ,EAAM,KAAK,SAAS,GAAG,IAC9CiJ,EAAQ,SAA0Bza,EAAO,CAGxC,IAAKwa,GAAU,CAACxa,KAAW,OAAOA,EAAU,KAAe,OAAOA,GAAU,UAC3E,GAAI,CACH,IAAI8J,EAAM0H,EAAM,KAAKxR,CAAK,EAC1B,OACC8J,IAAQuQ,GACLvQ,IAAQwQ,GACRxQ,IAAQyQ,GACRzQ,IAAQoQ,IACPla,EAAM,EAAE,GAAK,IAClB,MAAW,EAEb,MAAO,EACP,EAEH,CAEA,OAAA2a,GAAiBlI,EACd,SAAoBzS,EAAO,CAC5B,GAAIya,EAAMza,CAAK,EAAK,MAAO,GAE3B,GADI,CAACA,GACD,OAAOA,GAAU,YAAc,OAAOA,GAAU,SAAY,MAAO,GACvE,GAAI,CACHyS,EAAazS,EAAO,KAAM4Z,CAAY,CACtC,OAAQ7T,EAAG,CACX,GAAIA,IAAM8T,EAAoB,MAAO,EACxC,CACE,MAAO,CAACE,EAAa/Z,CAAK,GAAKia,EAAkBja,CAAK,CACxD,EACG,SAAoBA,EAAO,CAC5B,GAAIya,EAAMza,CAAK,EAAK,MAAO,GAE3B,GADI,CAACA,GACD,OAAOA,GAAU,YAAc,OAAOA,GAAU,SAAY,MAAO,GACvE,GAAIuY,EAAkB,OAAO0B,EAAkBja,CAAK,EACpD,GAAI+Z,EAAa/Z,CAAK,EAAK,MAAO,GAClC,IAAI4a,EAAWpJ,EAAM,KAAKxR,CAAK,EAC/B,OAAI4a,IAAaT,GAAWS,IAAaR,GAAY,CAAE,iBAAkB,KAAKQ,CAAQ,EAAY,GAC3FX,EAAkBja,CAAK,CAC9B,kDClGF,IAAI2a,EAAa/W,GAAsB,EAEnC4N,EAAQ,OAAO,UAAU,SACzBqJ,EAAiB,OAAO,UAAU,eAGlCC,EAAe,SAAsBrS,EAAOsS,EAAUrb,EAAU,CAChE,QAASkB,EAAI,EAAGM,EAAMuH,EAAM,OAAQ7H,EAAIM,EAAKN,IACrCia,EAAe,KAAKpS,EAAO7H,CAAC,IACxBlB,GAAY,KACZqb,EAAStS,EAAM7H,CAAC,EAAGA,EAAG6H,CAAK,EAE3BsS,EAAS,KAAKrb,EAAU+I,EAAM7H,CAAC,EAAGA,EAAG6H,CAAK,EAIzD,EAGGuS,EAAgB,SAAuB1S,EAAQyS,EAAUrb,EAAU,CACnE,QAASkB,EAAI,EAAGM,EAAMoH,EAAO,OAAQ1H,EAAIM,EAAKN,IAEtClB,GAAY,KACZqb,EAASzS,EAAO,OAAO1H,CAAC,EAAGA,EAAG0H,CAAM,EAEpCyS,EAAS,KAAKrb,EAAU4I,EAAO,OAAO1H,CAAC,EAAGA,EAAG0H,CAAM,CAG9D,EAGG2S,EAAgB,SAAuBC,EAAQH,EAAUrb,EAAU,CACnE,QAASyb,KAAKD,EACNL,EAAe,KAAKK,EAAQC,CAAC,IACzBzb,GAAY,KACZqb,EAASG,EAAOC,CAAC,EAAGA,EAAGD,CAAM,EAE7BH,EAAS,KAAKrb,EAAUwb,EAAOC,CAAC,EAAGA,EAAGD,CAAM,EAI3D,EAGD,SAASE,EAAQrS,EAAG,CAChB,OAAOyI,EAAM,KAAKzI,CAAC,IAAM,gBAC7B,CAGc,OAAAsS,GAAG,SAAiBvZ,EAAMiZ,EAAUO,EAAS,CACvD,GAAI,CAACX,EAAWI,CAAQ,EACpB,MAAM,IAAI,UAAU,6BAA6B,EAGrD,IAAIrb,EACA,UAAU,QAAU,IACpBA,EAAW4b,GAGXF,EAAQtZ,CAAI,EACZgZ,EAAahZ,EAAMiZ,EAAUrb,CAAQ,EAC9B,OAAOoC,GAAS,SACvBkZ,EAAclZ,EAAMiZ,EAAUrb,CAAQ,EAEtCub,EAAcnZ,EAAMiZ,EAAUrb,CAAQ,CAE7C,8CCjED6b,GAAiB,CAChB,eACA,eACA,eACA,YACA,aACA,aACA,aACA,oBACA,cACA,cACA,gBACA,gBACA,mDCdD,IAAIC,EAAqD5X,GAAA,EAErD6X,EAAI,OAAO,WAAe,IAAcC,GAAS,WAGvC,OAAAC,GAAG,UAAgC,CAEhD,QAD2DtP,EAAM,CAAE,EAC1DzL,EAAI,EAAGA,EAAI4a,EAAc,OAAQ5a,IACrC,OAAO6a,EAAED,EAAc5a,CAAC,CAAC,GAAM,aAElCyL,EAAIA,EAAI,MAAM,EAAImP,EAAc5a,CAAC,GAGnC,OAAOyL,CACP,kECdD,IAAI2E,EAA+CpN,GAAA,EAE/C4Q,EAA0C5B,GAAA,EAC1CM,EAAsCJ,GAAA,EAEtC/B,EAAsBiC,GAAA,EAGZ,OAAA4I,GAAG,SAChBhT,EACAiT,EACA7b,EACC,CACD,GAAI,CAAC4I,GAAQ,OAAOA,GAAQ,UAAY,OAAOA,GAAQ,WACtD,MAAM,IAAIsK,EAAW,wCAAwC,EAE9D,GAAI,OAAO2I,GAAa,UAAY,OAAOA,GAAa,SACvD,MAAM,IAAI3I,EAAW,0CAA0C,EAEhE,GAAI,UAAU,OAAS,GAAK,OAAO,UAAU,CAAC,GAAM,WAAa,UAAU,CAAC,IAAM,KACjF,MAAM,IAAIA,EAAW,yDAAyD,EAE/E,GAAI,UAAU,OAAS,GAAK,OAAO,UAAU,CAAC,GAAM,WAAa,UAAU,CAAC,IAAM,KACjF,MAAM,IAAIA,EAAW,uDAAuD,EAE7E,GAAI,UAAU,OAAS,GAAK,OAAO,UAAU,CAAC,GAAM,WAAa,UAAU,CAAC,IAAM,KACjF,MAAM,IAAIA,EAAW,2DAA2D,EAEjF,GAAI,UAAU,OAAS,GAAK,OAAO,UAAU,CAAC,GAAM,UACnD,MAAM,IAAIA,EAAW,yCAAyC,EAG/D,IAAI4I,EAAgB,UAAU,OAAS,EAAI,UAAU,CAAC,EAAI,KACtDC,EAAc,UAAU,OAAS,EAAI,UAAU,CAAC,EAAI,KACpDC,EAAkB,UAAU,OAAS,EAAI,UAAU,CAAC,EAAI,KACxDC,EAAQ,UAAU,OAAS,EAAI,UAAU,CAAC,EAAI,GAG9C1I,EAAO,CAAC,CAACxC,GAAQA,EAAKnI,EAAKiT,CAAQ,EAEvC,GAAI7K,EACHA,EAAgBpI,EAAKiT,EAAU,CAC9B,aAAcG,IAAoB,MAAQzI,EAAOA,EAAK,aAAe,CAACyI,EACtE,WAAYF,IAAkB,MAAQvI,EAAOA,EAAK,WAAa,CAACuI,EAChE,MAAO9b,EACP,SAAU+b,IAAgB,MAAQxI,EAAOA,EAAK,SAAW,CAACwI,CAC7D,CAAG,UACSE,GAAU,CAACH,GAAiB,CAACC,GAAe,CAACC,EAEvDpT,EAAIiT,CAAQ,EAAI7b,MAEhB,OAAM,IAAIwU,EAAa,6GAA6G,CAErI,kDCrDD,IAAIxD,EAA+CpN,GAAA,EAE/CsY,EAAyB,UAAkC,CAC9D,MAAO,CAAC,CAAClL,CACT,EAED,OAAAkL,EAAuB,wBAA0B,UAAmC,CAEnF,GAAI,CAAClL,EACJ,OAAO,KAER,GAAI,CACH,OAAOA,EAAgB,CAAE,EAAE,SAAU,CAAE,MAAO,CAAG,GAAE,SAAW,CAC9D,MAAW,CAEX,MAAO,EACT,CACC,EAEDmL,GAAiBD,kDCnBjB,IAAI/D,EAAuCvU,GAAA,EACvCwY,EAAwCxJ,GAAA,EACxCyJ,EAAiBvJ,KAAqC,EACtDjC,EAAsBmC,GAAA,EAEtBE,EAAsCqB,GAAA,EACtC+H,EAASnE,EAAa,cAAc,EAGxC,OAAAoE,GAAiB,SAA2BjN,EAAIlI,EAAQ,CACvD,GAAI,OAAOkI,GAAO,WACjB,MAAM,IAAI4D,EAAW,wBAAwB,EAE9C,GAAI,OAAO9L,GAAW,UAAYA,EAAS,GAAKA,EAAS,YAAckV,EAAOlV,CAAM,IAAMA,EACzF,MAAM,IAAI8L,EAAW,4CAA4C,EAGlE,IAAI+I,EAAQ,UAAU,OAAS,GAAK,CAAC,CAAC,UAAU,CAAC,EAE7CO,EAA+B,GAC/BC,EAA2B,GAC/B,GAAI,WAAYnN,GAAMuB,EAAM,CAC3B,IAAI0C,EAAO1C,EAAKvB,EAAI,QAAQ,EACxBiE,GAAQ,CAACA,EAAK,eACjBiJ,EAA+B,IAE5BjJ,GAAQ,CAACA,EAAK,WACjBkJ,EAA2B,GAE9B,CAEC,OAAID,GAAgCC,GAA4B,CAACR,KAC5DI,EACHD,EAA6C9M,EAAK,SAAUlI,EAAQ,GAAM,EAAI,EAE9EgV,EAA6C9M,EAAK,SAAUlI,CAAM,GAG7DkI,CACP,kDCvCD,IAAIoD,EAAO9O,GAAwB,EAC/B+O,EAASC,GAA0B,EACnCK,EAAcH,GAAwB,EAG5B,OAAA4J,GAAG,UAAqB,CACrC,OAAOzJ,EAAYP,EAAMC,EAAQ,SAAS,CAC1C,wDCPD,IAAI4J,EAAkD3Y,GAAA,EAElDoN,EAA+C4B,GAAA,EAE/CwF,EAAgBtF,GAAkC,EAClD4J,EAAY1J,GAA4C,EAE5D2J,EAAA,QAAiB,SAAkBC,EAAkB,CACpD,IAAIC,EAAOzE,EAAc,SAAS,EAC9B0E,EAAiBF,EAAiB,QAAU,UAAU,OAAS,GACnE,OAAOL,EACNM,EACA,GAAKC,EAAiB,EAAIA,EAAiB,GAC3C,EACA,CACD,EAEG9L,EACHA,EAAgB2L,EAAO,QAAS,QAAS,CAAE,MAAOD,EAAW,EAE7DC,gBAAuBD,iECpBxB,IAAIrB,EAAUzX,GAAmB,EAC7B+X,EAAwD/I,GAAA,EACxDS,EAAWP,GAAoB,EAC/BwF,EAAiCtF,GAAA,EACjCnC,EAAsB0D,GAAA,EACtBV,EAAWY,GAAoB,EAE/B+D,EAAYF,EAAU,2BAA2B,EACjDC,EAAiB7D,KAAkC,EAEnD+G,EAAI,OAAO,WAAe,IAAcC,GAAS,WACjDqB,EAAcpB,EAAsB,EAEpCqB,EAAS1E,EAAU,wBAAwB,EAG3CD,EAAWC,EAAU,0BAA2B,EAAI,GAAK,SAAiB7P,EAAOzI,EAAO,CAC3F,QAASY,EAAI,EAAGA,EAAI6H,EAAM,OAAQ7H,GAAK,EACtC,GAAI6H,EAAM7H,CAAC,IAAMZ,EAChB,OAAOY,EAGT,MAAO,EACP,EAIGqc,EAAQ,CAAE,UAAW,IAAM,EAC3B1E,GAAkB1H,GAAQgD,EAC7BwH,EAAQ0B,EAAa,SAAUG,EAAY,CAC1C,IAAIxa,EAAM,IAAI+Y,EAAEyB,CAAU,EAC1B,GAAI,OAAO,eAAexa,GAAOmR,EAAU,CAC1C,IAAI3M,EAAQ2M,EAASnR,CAAG,EAEpBmN,EAAagB,EAAK3J,EAAO,OAAO,WAAW,EAC/C,GAAI,CAAC2I,GAAc3I,EAAO,CACzB,IAAIiW,EAAatJ,EAAS3M,CAAK,EAE/B2I,EAAagB,EAAKsM,EAAY,OAAO,WAAW,CACpD,CAEGF,EAAM,IAAMC,CAAU,EAAI7J,EAASxD,EAAW,GAAG,CACpD,CACA,CAAE,EAEDwL,EAAQ0B,EAAa,SAAUG,EAAY,CAC1C,IAAIxa,EAAM,IAAI+Y,EAAEyB,CAAU,EACtB5N,EAAK5M,EAAI,OAASA,EAAI,IACtB4M,IACH2N,EACkD,IAAMC,CACvD,EAEA7J,EAAS/D,CAAE,EAGf,CAAE,EAIF,IAAI8N,EAAiB,SAA2Bpd,EAAO,CACF,IAAI6K,EAAQ,GAChE,OAAAwQ,EACmE4B,EAElE,SAAUI,EAAQH,EAAY,CAC7B,GAAI,CAACrS,EACJ,GAAI,CAEC,IAAMwS,EAAOrd,CAAK,IAAMkd,IAC3BrS,EAAmDmS,EAAOE,EAAY,CAAC,EAExE,MAAW,EAEhB,CACE,EACMrS,CACP,EAGGyS,EAAY,SAAsBtd,EAAO,CACG,IAAI6K,EAAQ,GAC3D,OAAAwQ,EACkE4B,EACgB,SAAUI,EAAQva,EAAM,CACxG,GAAI,CAAC+H,EACJ,GAAI,CAEHwS,EAAOrd,CAAK,EACZ6K,EAAmDmS,EAAOla,EAAM,CAAC,CACjE,MAAW,EAEhB,CACE,EACM+H,CACP,EAGD,OAAA0S,GAAiB,SAAyBvd,EAAO,CAChD,GAAI,CAACA,GAAS,OAAOA,GAAU,SAAY,MAAO,GAClD,GAAI,CAACuY,EAAgB,CAEpB,IAAIiF,EAAMR,EAAOxE,EAAUxY,CAAK,EAAG,EAAG,EAAE,EACxC,OAAIqY,EAAS0E,EAAaS,CAAG,EAAI,GACzBA,EAEJA,IAAQ,SACJ,GAGDF,EAAUtd,CAAK,CACxB,CACC,OAAK6Q,EACEuM,EAAepd,CAAK,EADP,IAEpB,kDClHD,IAAIud,EAA8C3Z,GAAA,EAGlD,OAAA6Z,GAAiB,SAAsBzd,EAAO,CAC7C,MAAO,CAAC,CAACud,EAAgBvd,CAAK,CAC9B,wDCFD,IAAI0d,EAA2C9Z,GAAA,EAC3C8V,EAAsB9G,GAAgC,EACtD2K,EAA8CzK,GAAA,EAC9C2K,EAAwCzK,GAAA,EAE5C,SAAS2K,EAAYC,EAAG,CACtB,OAAOA,EAAE,KAAK,KAAKA,CAAC,CACtB,CAEA,IAAIC,EAAkB,OAAO,OAAW,IACpCC,EAAkB,OAAO,OAAW,IAEpCC,EAAiBJ,EAAY,OAAO,UAAU,QAAQ,EAEtDK,EAAcL,EAAY,OAAO,UAAU,OAAO,EAClDM,EAAcN,EAAY,OAAO,UAAU,OAAO,EAClDO,EAAeP,EAAY,QAAQ,UAAU,OAAO,EAExD,GAAIE,EACF,IAAIM,EAAcR,EAAY,OAAO,UAAU,OAAO,EAGxD,GAAIG,EACF,IAAIM,EAAcT,EAAY,OAAO,UAAU,OAAO,EAGxD,SAASU,EAAoBre,EAAOse,GAAkB,CACpD,GAAI,OAAOte,GAAU,SACnB,MAAO,GAET,GAAI,CACF,OAAAse,GAAiBte,CAAK,EACf,EACR,MAAU,CACT,MAAO,EACX,CACA,CAEA6D,EAAA,kBAA4B6Z,EAC5B7Z,EAAA,oBAA8B6V,EAC9B7V,EAAA,aAAuB4Z,EAIvB,SAASc,EAAUhQ,EAAO,CACzB,OAEE,OAAO,QAAY,KACnBA,aAAiB,SAGjBA,IAAU,MACV,OAAOA,GAAU,UACjB,OAAOA,EAAM,MAAS,YACtB,OAAOA,EAAM,OAAU,UAG1B,CACA1K,EAAA,UAAoB0a,EAEpB,SAASC,EAAkBxe,EAAO,CAChC,OAAI,OAAO,YAAgB,KAAe,YAAY,OAC7C,YAAY,OAAOA,CAAK,EAI/Byd,EAAazd,CAAK,GAClBye,EAAWze,CAAK,CAEpB,CACA6D,EAAA,kBAA4B2a,EAG5B,SAASE,EAAa1e,EAAO,CAC3B,OAAOud,EAAgBvd,CAAK,IAAM,YACpC,CACA6D,EAAA,aAAuB6a,EAEvB,SAASC,EAAoB3e,EAAO,CAClC,OAAOud,EAAgBvd,CAAK,IAAM,mBACpC,CACA6D,EAAA,oBAA8B8a,EAE9B,SAASC,EAAc5e,EAAO,CAC5B,OAAOud,EAAgBvd,CAAK,IAAM,aACpC,CACA6D,EAAA,cAAwB+a,EAExB,SAASC,EAAc7e,EAAO,CAC5B,OAAOud,EAAgBvd,CAAK,IAAM,aACpC,CACA6D,EAAA,cAAwBgb,EAExB,SAASC,EAAY9e,EAAO,CAC1B,OAAOud,EAAgBvd,CAAK,IAAM,WACpC,CACA6D,EAAA,YAAsBib,EAEtB,SAASC,EAAa/e,EAAO,CAC3B,OAAOud,EAAgBvd,CAAK,IAAM,YACpC,CACA6D,EAAA,aAAuBkb,EAEvB,SAASC,EAAahf,EAAO,CAC3B,OAAOud,EAAgBvd,CAAK,IAAM,YACpC,CACA6D,EAAA,aAAuBmb,EAEvB,SAASC,EAAejf,EAAO,CAC7B,OAAOud,EAAgBvd,CAAK,IAAM,cACpC,CACA6D,EAAA,eAAyBob,EAEzB,SAASC,EAAelf,EAAO,CAC7B,OAAOud,EAAgBvd,CAAK,IAAM,cACpC,CACA6D,EAAA,eAAyBqb,EAEzB,SAASC,EAAgBnf,EAAO,CAC9B,OAAOud,EAAgBvd,CAAK,IAAM,eACpC,CACA6D,EAAA,gBAA0Bsb,EAE1B,SAASC,EAAiBpf,EAAO,CAC/B,OAAOud,EAAgBvd,CAAK,IAAM,gBACpC,CACA6D,EAAA,iBAA2Bub,EAE3B,SAASC,EAAcrf,EAAO,CAC5B,OAAO+d,EAAe/d,CAAK,IAAM,cACnC,CACAqf,EAAc,QACZ,OAAO,IAAQ,KACfA,EAAc,IAAI,GAAK,EAGzB,SAASC,EAAMtf,EAAO,CACpB,OAAI,OAAO,IAAQ,IACV,GAGFqf,EAAc,QACjBA,EAAcrf,CAAK,EACnBA,aAAiB,GACvB,CACA6D,EAAA,MAAgByb,EAEhB,SAASC,GAAcvf,EAAO,CAC5B,OAAO+d,EAAe/d,CAAK,IAAM,cACnC,CACAuf,GAAc,QACZ,OAAO,IAAQ,KACfA,GAAc,IAAI,GAAK,EAEzB,SAASC,GAAMxf,EAAO,CACpB,OAAI,OAAO,IAAQ,IACV,GAGFuf,GAAc,QACjBA,GAAcvf,CAAK,EACnBA,aAAiB,GACvB,CACA6D,EAAA,MAAgB2b,GAEhB,SAASC,GAAkBzf,EAAO,CAChC,OAAO+d,EAAe/d,CAAK,IAAM,kBACnC,CACAyf,GAAkB,QAChB,OAAO,QAAY,KACnBA,GAAkB,IAAI,OAAS,EAEjC,SAASC,EAAU1f,EAAO,CACxB,OAAI,OAAO,QAAY,IACd,GAGFyf,GAAkB,QACrBA,GAAkBzf,CAAK,EACvBA,aAAiB,OACvB,CACA6D,EAAA,UAAoB6b,EAEpB,SAASC,GAAkB3f,EAAO,CAChC,OAAO+d,EAAe/d,CAAK,IAAM,kBACnC,CACA2f,GAAkB,QAChB,OAAO,QAAY,KACnBA,GAAkB,IAAI,OAAS,EAEjC,SAASC,GAAU5f,EAAO,CACxB,OAAO2f,GAAkB3f,CAAK,CAChC,CACA6D,EAAA,UAAoB+b,GAEpB,SAASC,GAAsB7f,EAAO,CACpC,OAAO+d,EAAe/d,CAAK,IAAM,sBACnC,CACA6f,GAAsB,QACpB,OAAO,YAAgB,KACvBA,GAAsB,IAAI,WAAa,EAEzC,SAASC,GAAc9f,EAAO,CAC5B,OAAI,OAAO,YAAgB,IAClB,GAGF6f,GAAsB,QACzBA,GAAsB7f,CAAK,EAC3BA,aAAiB,WACvB,CACA6D,EAAA,cAAwBic,GAExB,SAASC,GAAmB/f,EAAO,CACjC,OAAO+d,EAAe/d,CAAK,IAAM,mBACnC,CACA+f,GAAmB,QACjB,OAAO,YAAgB,KACvB,OAAO,SAAa,KACpBA,GAAmB,IAAI,SAAS,IAAI,YAAY,CAAC,EAAG,EAAG,CAAC,CAAC,EAE3D,SAAStB,EAAWze,EAAO,CACzB,OAAI,OAAO,SAAa,IACf,GAGF+f,GAAmB,QACtBA,GAAmB/f,CAAK,EACxBA,aAAiB,QACvB,CACA6D,EAAA,WAAqB4a,EAGrB,IAAIuB,EAAwB,OAAO,kBAAsB,IAAc,kBAAoB,OAC3F,SAASC,EAA4BjgB,EAAO,CAC1C,OAAO+d,EAAe/d,CAAK,IAAM,4BACnC,CACA,SAASkgB,EAAoBlgB,EAAO,CAClC,OAAI,OAAOggB,EAA0B,IAC5B,IAGL,OAAOC,EAA4B,QAAY,MACjDA,EAA4B,QAAUA,EAA4B,IAAID,CAAuB,GAGxFC,EAA4B,QAC/BA,EAA4BjgB,CAAK,EACjCA,aAAiBggB,EACvB,CACAnc,EAAA,oBAA8Bqc,EAE9B,SAASC,EAAgBngB,EAAO,CAC9B,OAAO+d,EAAe/d,CAAK,IAAM,wBACnC,CACA6D,EAAA,gBAA0Bsc,EAE1B,SAASC,EAAcpgB,EAAO,CAC5B,OAAO+d,EAAe/d,CAAK,IAAM,uBACnC,CACA6D,EAAA,cAAwBuc,EAExB,SAASC,EAAcrgB,EAAO,CAC5B,OAAO+d,EAAe/d,CAAK,IAAM,uBACnC,CACA6D,EAAA,cAAwBwc,EAExB,SAASC,EAAkBtgB,EAAO,CAChC,OAAO+d,EAAe/d,CAAK,IAAM,oBACnC,CACA6D,EAAA,kBAA4Byc,EAE5B,SAASC,EAA4BvgB,EAAO,CAC1C,OAAO+d,EAAe/d,CAAK,IAAM,6BACnC,CACA6D,EAAA,4BAAsC0c,EAEtC,SAASC,EAAexgB,EAAO,CAC7B,OAAOqe,EAAoBre,EAAOge,CAAW,CAC/C,CACAna,EAAA,eAAyB2c,EAEzB,SAASC,EAAezgB,EAAO,CAC7B,OAAOqe,EAAoBre,EAAOie,CAAW,CAC/C,CACApa,EAAA,eAAyB4c,EAEzB,SAASC,EAAgB1gB,EAAO,CAC9B,OAAOqe,EAAoBre,EAAOke,CAAY,CAChD,CACAra,EAAA,gBAA0B6c,EAE1B,SAASC,EAAe3gB,EAAO,CAC7B,OAAO6d,GAAmBQ,EAAoBre,EAAOme,CAAW,CAClE,CACAta,EAAA,eAAyB8c,EAEzB,SAASC,EAAe5gB,EAAO,CAC7B,OAAO8d,GAAmBO,EAAoBre,EAAOoe,CAAW,CAClE,CACAva,EAAA,eAAyB+c,EAEzB,SAASC,EAAiB7gB,EAAO,CAC/B,OACEwgB,EAAexgB,CAAK,GACpBygB,EAAezgB,CAAK,GACpB0gB,EAAgB1gB,CAAK,GACrB2gB,EAAe3gB,CAAK,GACpB4gB,EAAe5gB,CAAK,CAExB,CACA6D,EAAA,iBAA2Bgd,EAE3B,SAASC,GAAiB9gB,EAAO,CAC/B,OAAO,OAAO,WAAe,MAC3B8f,GAAc9f,CAAK,GACnBkgB,EAAoBlgB,CAAK,EAE7B,CACA6D,EAAA,iBAA2Bid,GAE3B,CAAC,UAAW,aAAc,yBAAyB,EAAE,QAAQ,SAASC,EAAQ,CAC5E,OAAO,eAAeld,EAASkd,EAAQ,CACrC,WAAY,GACZ,MAAO,UAAW,CAChB,MAAM,IAAI,MAAMA,EAAS,+BAA+B,CAC9D,CACA,CAAG,CACH,CAAC,qDC7UDC,GAAiB,SAAkBzgB,EAAK,CACtC,OAAOA,GAAO,OAAOA,GAAQ,UACxB,OAAOA,EAAI,MAAS,YACpB,OAAOA,EAAI,MAAS,YACpB,OAAOA,EAAI,WAAc,UAChC,kECgBI0gB,EAA4B,OAAO,2BACrC,SAAmCrY,EAAK,CAGtC,QAFI1G,EAAO,OAAO,KAAK0G,CAAG,EACtBsY,EAAc,CAAC,EACVtgB,EAAI,EAAGA,EAAIsB,EAAK,OAAQtB,IACnBsgB,EAAAhf,EAAKtB,CAAC,CAAC,EAAI,OAAO,yBAAyBgI,EAAK1G,EAAKtB,CAAC,CAAC,EAE9D,OAAAsgB,CACT,EAEEC,EAAe,WACnBtd,EAAiB,gBAAS+Z,EAAG,CACvB,IAACwD,EAASxD,CAAC,EAAG,CAEhB,QADIyD,EAAU,CAAC,EACNzgB,EAAI,EAAGA,EAAI,UAAU,OAAQA,IACpCygB,EAAQ,KAAKC,EAAQ,UAAU1gB,CAAC,CAAC,CAAC,EAE7B,OAAAygB,EAAQ,KAAK,GAAG,EAsBhB,QAnBLzgB,EAAI,EACJjB,EAAO,UACPuB,EAAMvB,EAAK,OACXmK,EAAM,OAAO8T,CAAC,EAAE,QAAQuD,EAAc,SAASpY,EAAG,CAChDA,OAAM,KAAa,UACnB,GAAAnI,GAAKM,EAAY6H,SACrB,OAAQA,EAAG,CACT,IAAK,KAAa,cAAOpJ,EAAKiB,GAAG,CAAC,EAClC,IAAK,KAAa,cAAOjB,EAAKiB,GAAG,CAAC,EAClC,IAAK,KACC,IACF,OAAO,KAAK,UAAUjB,EAAKiB,GAAG,CAAC,OACrB,CACH,mBAEX,QACSmI,QAAA,CACX,CACD,EACQA,EAAIpJ,EAAKiB,CAAC,EAAGA,EAAIM,EAAK6H,EAAIpJ,EAAK,EAAEiB,CAAC,EACrC2gB,EAAOxY,CAAC,GAAK,CAACyY,EAASzY,CAAC,EAC1Be,GAAO,IAAMf,EAENe,GAAA,IAAMwX,EAAQvY,CAAC,EAGnB,OAAAe,CACT,EAMAjG,EAAA,UAAoB,SAASyL,EAAId,EAAK,CACpC,GAAI,OAAOiT,GAAY,KAAeA,GAAQ,gBAAkB,GACvD,OAAAnS,EAIL,UAAOmS,GAAY,IACrB,OAAO,UAAW,CAChB,OAAO5d,EAAQ,UAAUyL,EAAId,CAAG,EAAE,MAAM,KAAM,SAAS,CACzD,EAGF,IAAIkT,EAAS,GACb,SAASC,GAAa,CACpB,GAAI,CAACD,EAAQ,CACX,GAAID,GAAQ,iBACJ,UAAI,MAAMjT,CAAG,EACViT,GAAQ,iBACjB,QAAQ,MAAMjT,CAAG,EAEjB,QAAQ,MAAMA,CAAG,EAEVkT,EAAA,GAEJ,OAAApS,EAAG,MAAM,KAAM,SAAS,EAG1B,OAAAqS,CACT,EAGA,IAAIC,EAAS,CAAC,EACVC,EAAgB,KAEpB,GAAIC,EAAY,WAAY,CAC1B,IAAIC,EAAWD,EAAY,WAC3BC,EAAWA,EAAS,QAAQ,qBAAsB,MAAM,EACrD,QAAQ,MAAO,IAAI,EACnB,QAAQ,KAAM,KAAK,EACnB,YAAY,EACfF,EAAgB,IAAI,OAAO,IAAME,EAAW,IAAK,GAAG,CACtD,CACAle,EAAmB,kBAASme,EAAK,CAE3B,GADJA,EAAMA,EAAI,YAAY,EAClB,CAACJ,EAAOI,CAAG,EACT,GAAAH,EAAc,KAAKG,CAAG,EAAG,CAC3B,IAAIC,EAAMR,GAAQ,IACXG,EAAAI,CAAG,EAAI,UAAW,CACvB,IAAIxT,EAAM3K,EAAQ,OAAO,MAAMA,EAAS,SAAS,EACjD,QAAQ,MAAM,YAAame,EAAKC,EAAKzT,CAAG,CAC1C,OAEOoT,EAAAI,CAAG,EAAI,UAAW,CAAC,EAG9B,OAAOJ,EAAOI,CAAG,CACnB,EAWA,SAASV,EAAQ1Y,EAAKsZ,EAAM,CAE1B,IAAIC,EAAM,CACR,KAAM,CAAC,EACP,QAASC,CACX,EAEA,OAAI,UAAU,QAAU,IAAOD,EAAA,MAAQ,UAAU,CAAC,GAC9C,UAAU,QAAU,IAAOA,EAAA,OAAS,UAAU,CAAC,GAC/CE,EAAUH,CAAI,EAEhBC,EAAI,WAAaD,EACRA,GAEDre,EAAA,QAAQse,EAAKD,CAAI,EAGvBI,EAAYH,EAAI,UAAU,MAAO,WAAa,IAC9CG,EAAYH,EAAI,KAAK,MAAO,MAAQ,GACpCG,EAAYH,EAAI,MAAM,MAAO,OAAS,IACtCG,EAAYH,EAAI,aAAa,MAAO,cAAgB,IACpDA,EAAI,SAAQA,EAAI,QAAUI,GACvBC,EAAYL,EAAKvZ,EAAKuZ,EAAI,KAAK,CACxC,CACAte,EAAA,QAAkByd,EAIlBA,EAAQ,OAAS,CACf,KAAS,CAAC,EAAG,EAAE,EACf,OAAW,CAAC,EAAG,EAAE,EACjB,UAAc,CAAC,EAAG,EAAE,EACpB,QAAY,CAAC,EAAG,EAAE,EAClB,MAAU,CAAC,GAAI,EAAE,EACjB,KAAS,CAAC,GAAI,EAAE,EAChB,MAAU,CAAC,GAAI,EAAE,EACjB,KAAS,CAAC,GAAI,EAAE,EAChB,KAAS,CAAC,GAAI,EAAE,EAChB,MAAU,CAAC,GAAI,EAAE,EACjB,QAAY,CAAC,GAAI,EAAE,EACnB,IAAQ,CAAC,GAAI,EAAE,EACf,OAAW,CAAC,GAAI,EAAE,CACpB,EAGAA,EAAQ,OAAS,CACf,QAAW,OACX,OAAU,SACV,QAAW,SACX,UAAa,OACb,KAAQ,OACR,OAAU,QACV,KAAQ,UAER,OAAU,KACZ,EAGA,SAASiB,EAAiBzY,EAAK2Y,EAAW,CACpC,IAAAC,EAAQpB,EAAQ,OAAOmB,CAAS,EAEpC,OAAIC,EACK,QAAYpB,EAAQ,OAAOoB,CAAK,EAAE,CAAC,EAAI,IAAM5Y,EAC7C,QAAYwX,EAAQ,OAAOoB,CAAK,EAAE,CAAC,EAAI,IAEvC5Y,CAEX,CAGA,SAASsY,EAAetY,EAAK2Y,EAAW,CAC/B,OAAA3Y,CACT,CAGA,SAAS6Y,EAAYla,EAAO,CAC1B,IAAIma,EAAO,CAAC,EAEN,OAAAna,EAAA,QAAQ,SAAS4B,EAAKwY,EAAK,CAC/BD,EAAKvY,CAAG,EAAI,GACb,EAEMuY,CACT,CAGA,SAASJ,EAAYL,EAAKniB,EAAO8iB,EAAc,CAG7C,GAAIX,EAAI,eACJniB,GACA+iB,EAAW/iB,EAAM,OAAO,GAExBA,EAAM,UAAY6D,EAAQ,SAE1B,EAAE7D,EAAM,aAAeA,EAAM,YAAY,YAAcA,GAAQ,CACjE,IAAI6C,EAAM7C,EAAM,QAAQ8iB,EAAcX,CAAG,EACrC,OAACf,EAASve,CAAG,IACTA,EAAA2f,EAAYL,EAAKtf,EAAKigB,CAAY,GAEnCjgB,CAAA,CAIL,IAAAmgB,EAAYC,EAAgBd,EAAKniB,CAAK,EAC1C,GAAIgjB,EACK,OAAAA,EAIL,IAAA9gB,EAAO,OAAO,KAAKlC,CAAK,EACxBkjB,EAAcP,EAAYzgB,CAAI,EAQlC,GANIigB,EAAI,aACCjgB,EAAA,OAAO,oBAAoBlC,CAAK,GAKrCmjB,EAAQnjB,CAAK,IACTkC,EAAK,QAAQ,SAAS,GAAK,GAAKA,EAAK,QAAQ,aAAa,GAAK,GACrE,OAAOkhB,EAAYpjB,CAAK,EAItB,GAAAkC,EAAK,SAAW,EAAG,CACjB,GAAA6gB,EAAW/iB,CAAK,EAAG,CACrB,IAAI8C,EAAO9C,EAAM,KAAO,KAAOA,EAAM,KAAO,GAC5C,OAAOmiB,EAAI,QAAQ,YAAcrf,EAAO,IAAK,SAAS,EAEpD,GAAAugB,EAASrjB,CAAK,EACT,OAAAmiB,EAAI,QAAQ,OAAO,UAAU,SAAS,KAAKniB,CAAK,EAAG,QAAQ,EAEhE,GAAAsjB,EAAOtjB,CAAK,EACP,OAAAmiB,EAAI,QAAQ,KAAK,UAAU,SAAS,KAAKniB,CAAK,EAAG,MAAM,EAE5D,GAAAmjB,EAAQnjB,CAAK,EACf,OAAOojB,EAAYpjB,CAAK,CAC1B,CAGF,IAAIujB,EAAO,GAAI9a,EAAQ,GAAO+a,EAAS,CAAC,IAAK,GAAG,EAS5C,GANApI,EAAQpb,CAAK,IACPyI,EAAA,GACC+a,EAAA,CAAC,IAAK,GAAG,GAIhBT,EAAW/iB,CAAK,EAAG,CACrB,IAAIQ,EAAIR,EAAM,KAAO,KAAOA,EAAM,KAAO,GACzCujB,EAAO,aAAe/iB,EAAI,IAkB5B,GAdI6iB,EAASrjB,CAAK,IAChBujB,EAAO,IAAM,OAAO,UAAU,SAAS,KAAKvjB,CAAK,GAI/CsjB,EAAOtjB,CAAK,IACdujB,EAAO,IAAM,KAAK,UAAU,YAAY,KAAKvjB,CAAK,GAIhDmjB,EAAQnjB,CAAK,IACRujB,EAAA,IAAMH,EAAYpjB,CAAK,GAG5BkC,EAAK,SAAW,IAAM,CAACuG,GAASzI,EAAM,QAAU,GAClD,OAAOwjB,EAAO,CAAC,EAAID,EAAOC,EAAO,CAAC,EAGpC,GAAIV,EAAe,EACb,OAAAO,EAASrjB,CAAK,EACTmiB,EAAI,QAAQ,OAAO,UAAU,SAAS,KAAKniB,CAAK,EAAG,QAAQ,EAE3DmiB,EAAI,QAAQ,WAAY,SAAS,EAIxCA,EAAA,KAAK,KAAKniB,CAAK,EAEf,IAAAqF,EACJ,OAAIoD,EACFpD,EAASoe,EAAYtB,EAAKniB,EAAO8iB,EAAcI,EAAahhB,CAAI,EAEvDmD,EAAAnD,EAAK,IAAI,SAASC,EAAK,CAC9B,OAAOuhB,EAAevB,EAAKniB,EAAO8iB,EAAcI,EAAa/gB,EAAKsG,CAAK,EACxE,EAGH0Z,EAAI,KAAK,IAAI,EAENwB,EAAqBte,EAAQke,EAAMC,CAAM,CAClD,CAGA,SAASP,EAAgBd,EAAKniB,EAAO,CACnC,GAAIsiB,EAAYtiB,CAAK,EACZ,OAAAmiB,EAAI,QAAQ,YAAa,WAAW,EACzC,GAAAf,EAASphB,CAAK,EAAG,CACnB,IAAI4jB,EAAS,IAAO,KAAK,UAAU5jB,CAAK,EAAE,QAAQ,SAAU,EAAE,EACpB,QAAQ,KAAM,KAAK,EACnB,QAAQ,OAAQ,GAAG,EAAI,IAC1D,OAAAmiB,EAAI,QAAQyB,EAAQ,QAAQ,EAErC,GAAIC,EAAS7jB,CAAK,EAChB,OAAOmiB,EAAI,QAAQ,GAAKniB,EAAO,QAAQ,EACzC,GAAIqiB,EAAUriB,CAAK,EACjB,OAAOmiB,EAAI,QAAQ,GAAKniB,EAAO,SAAS,EAE1C,GAAIuhB,EAAOvhB,CAAK,EACP,OAAAmiB,EAAI,QAAQ,OAAQ,MAAM,CACrC,CAGA,SAASiB,EAAYpjB,EAAO,CAC1B,MAAO,IAAM,MAAM,UAAU,SAAS,KAAKA,CAAK,EAAI,GACtD,CAGA,SAASyjB,EAAYtB,EAAKniB,EAAO8iB,EAAcI,EAAahhB,EAAM,CAEvD,QADLmD,EAAS,CAAC,EACLzE,EAAI,EAAGkjB,EAAI9jB,EAAM,OAAQY,EAAIkjB,EAAG,EAAEljB,EACrCia,GAAe7a,EAAO,OAAOY,CAAC,CAAC,EACjCyE,EAAO,KAAKqe,EAAevB,EAAKniB,EAAO8iB,EAAcI,EACjD,OAAOtiB,CAAC,EAAG,GAAK,EAEpByE,EAAO,KAAK,EAAE,EAGb,OAAAnD,EAAA,QAAQ,SAASC,EAAK,CACpBA,EAAI,MAAM,OAAO,GACpBkD,EAAO,KAAKqe,EAAevB,EAAKniB,EAAO8iB,EAAcI,EACjD/gB,EAAK,GAAK,CAChB,CACD,EACMkD,CACT,CAGA,SAASqe,EAAevB,EAAKniB,EAAO8iB,EAAcI,EAAa/gB,EAAKsG,EAAO,CACzE,IAAI3F,EAAMgH,EAAKyJ,EAsCX,GArCGA,EAAA,OAAO,yBAAyBvT,EAAOmC,CAAG,GAAK,CAAE,MAAOnC,EAAMmC,CAAG,CAAE,EACtEoR,EAAK,IACHA,EAAK,IACDzJ,EAAAqY,EAAI,QAAQ,kBAAmB,SAAS,EAExCrY,EAAAqY,EAAI,QAAQ,WAAY,SAAS,EAGrC5O,EAAK,MACDzJ,EAAAqY,EAAI,QAAQ,WAAY,SAAS,GAGtCtH,GAAeqI,EAAa/gB,CAAG,IAClCW,EAAO,IAAMX,EAAM,KAEhB2H,IACCqY,EAAI,KAAK,QAAQ5O,EAAK,KAAK,EAAI,GAC7BgO,EAAOuB,CAAY,EACrBhZ,EAAM0Y,EAAYL,EAAK5O,EAAK,MAAO,IAAI,EAEvCzJ,EAAM0Y,EAAYL,EAAK5O,EAAK,MAAOuP,EAAe,CAAC,EAEjDhZ,EAAI,QAAQ;AAAA,CAAI,EAAI,KAClBrB,EACFqB,EAAMA,EAAI,MAAM;AAAA,CAAI,EAAE,IAAI,SAASia,EAAM,CACvC,MAAO,KAAOA,CACf,GAAE,KAAK;AAAA,CAAI,EAAE,MAAM,CAAC,EAErBja,EAAM;AAAA,EAAOA,EAAI,MAAM;AAAA,CAAI,EAAE,IAAI,SAASia,EAAM,CAC9C,MAAO,MAAQA,CAAA,CAChB,EAAE,KAAK;AAAA,CAAI,IAIVja,EAAAqY,EAAI,QAAQ,aAAc,SAAS,GAGzCG,EAAYxf,CAAI,EAAG,CACrB,GAAI2F,GAAStG,EAAI,MAAM,OAAO,EACrB,OAAA2H,EAEFhH,EAAA,KAAK,UAAU,GAAKX,CAAG,EAC1BW,EAAK,MAAM,8BAA8B,GACpCA,IAAK,MAAM,EAAG,EAAE,EAChBA,EAAAqf,EAAI,QAAQrf,EAAM,MAAM,IAExBA,IAAK,QAAQ,KAAM,KAAK,EACnB,QAAQ,OAAQ,GAAG,EACnB,QAAQ,WAAY,GAAG,EAC5BA,EAAAqf,EAAI,QAAQrf,EAAM,QAAQ,EACnC,CAGF,OAAOA,EAAO,KAAOgH,CACvB,CAGA,SAAS6Z,EAAqBte,EAAQke,EAAMC,EAAQ,CAElD,IAAIpc,EAAS/B,EAAO,OAAO,SAAS2e,EAAMC,EAAK,CAE7C,OAAIA,EAAI,QAAQ;AAAA,CAAI,GAAK,EAClBD,EAAOC,EAAI,QAAQ,kBAAmB,EAAE,EAAE,OAAS,GACzD,CAAC,EAEJ,OAAI7c,EAAS,GACJoc,EAAO,CAAC,GACPD,IAAS,GAAK,GAAKA,EAAO;AAAA,IAC3B,IACAle,EAAO,KAAK;AAAA,GAAO,EACnB,IACAme,EAAO,CAAC,EAGVA,EAAO,CAAC,EAAID,EAAO,IAAMle,EAAO,KAAK,IAAI,EAAI,IAAMme,EAAO,CAAC,CACpE,CAKA3f,EAAA,MAAgBD,GAAyB,EAEzC,SAASwX,EAAQ8I,EAAI,CACZ,aAAM,QAAQA,CAAE,CACzB,CACArgB,EAAA,QAAkBuX,EAElB,SAASiH,EAAU9hB,EAAK,CACtB,OAAO,OAAOA,GAAQ,SACxB,CACAsD,EAAA,UAAoBwe,EAEpB,SAASd,EAAOhhB,EAAK,CACnB,OAAOA,IAAQ,IACjB,CACAsD,EAAA,OAAiB0d,EAEjB,SAAS4C,EAAkB5jB,EAAK,CAC9B,OAAOA,GAAO,IAChB,CACAsD,EAAA,kBAA4BsgB,EAE5B,SAASN,EAAStjB,EAAK,CACrB,OAAO,OAAOA,GAAQ,QACxB,CACAsD,EAAA,SAAmBggB,EAEnB,SAASzC,EAAS7gB,EAAK,CACrB,OAAO,OAAOA,GAAQ,QACxB,CACAsD,EAAA,SAAmBud,EAEnB,SAASgD,EAAS7jB,EAAK,CACrB,OAAO,OAAOA,GAAQ,QACxB,CACAsD,EAAA,SAAmBugB,EAEnB,SAAS9B,EAAY/hB,EAAK,CACxB,OAAOA,IAAQ,MACjB,CACAsD,EAAA,YAAsBye,EAEtB,SAASe,EAASgB,EAAI,CACpB,OAAO7C,EAAS6C,CAAE,GAAKC,GAAeD,CAAE,IAAM,iBAChD,CACAxgB,EAAA,SAAmBwf,EACnBxf,EAAQ,MAAM,SAAWwf,EAEzB,SAAS7B,EAASjhB,EAAK,CACd,cAAOA,GAAQ,UAAYA,IAAQ,IAC5C,CACAsD,EAAA,SAAmB2d,EAEnB,SAAS8B,EAAOld,EAAG,CACjB,OAAOob,EAASpb,CAAC,GAAKke,GAAele,CAAC,IAAM,eAC9C,CACAvC,EAAA,OAAiByf,EACjBzf,EAAQ,MAAM,OAASyf,EAEvB,SAASH,EAAQpd,EAAG,CAClB,OAAOyb,EAASzb,CAAC,IACZue,GAAeve,CAAC,IAAM,kBAAoBA,aAAa,MAC9D,CACAlC,EAAA,QAAkBsf,EAClBtf,EAAQ,MAAM,cAAgBsf,EAE9B,SAASJ,EAAWxiB,EAAK,CACvB,OAAO,OAAOA,GAAQ,UACxB,CACAsD,EAAA,WAAqBkf,EAErB,SAASwB,GAAYhkB,EAAK,CACxB,OAAOA,IAAQ,MACR,OAAOA,GAAQ,WACf,OAAOA,GAAQ,UACf,OAAOA,GAAQ,UACf,OAAOA,GAAQ,UACf,OAAOA,EAAQ,GACxB,CACAsD,EAAA,YAAsB0gB,GAEtB1gB,EAAA,SAAmB+O,GAA4B,EAE/C,SAAS0R,GAAeE,EAAG,CACzB,OAAO,OAAO,UAAU,SAAS,KAAKA,CAAC,CACzC,CAGA,SAASC,GAAIjkB,EAAG,CACP,OAAAA,EAAI,GAAK,IAAMA,EAAE,SAAS,EAAE,EAAIA,EAAE,SAAS,EAAE,CACtD,CAGA,IAAIkkB,EAAS,CAAC,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MACxD,MAAO,MAAO,KAAK,EAGjC,SAASC,IAAY,CACf,IAAAve,MAAQ,KACRwe,EAAO,CAACH,GAAIre,EAAE,UAAU,EAChBqe,GAAIre,EAAE,YAAY,EAClBqe,GAAIre,EAAE,WAAY,IAAG,KAAK,GAAG,EACzC,MAAO,CAACA,EAAE,QAAQ,EAAGse,EAAOte,EAAE,SAAS,CAAC,EAAGwe,CAAI,EAAE,KAAK,GAAG,CAC3D,CAIA/gB,EAAA,IAAc,UAAW,CACf,YAAI,UAAW8gB,GAAU,EAAG9gB,EAAQ,OAAO,MAAMA,EAAS,SAAS,CAAC,CAC9E,EAgBAA,EAAA,SAAmBiP,GAAkB,EAErCjP,EAAA,QAAkB,SAASghB,EAAQC,EAAK,CAEtC,GAAI,CAACA,GAAO,CAACtD,EAASsD,CAAG,EAAU,OAAAD,EAInC,QAFI3iB,EAAO,OAAO,KAAK4iB,CAAG,EACtBlkB,EAAIsB,EAAK,OACNtB,KACLikB,EAAO3iB,EAAKtB,CAAC,CAAC,EAAIkkB,EAAI5iB,EAAKtB,CAAC,CAAC,EAExB,OAAAikB,CACT,EAEA,SAAShK,GAAejS,EAAKmc,EAAM,CACjC,OAAO,OAAO,UAAU,eAAe,KAAKnc,EAAKmc,CAAI,CACvD,CAEA,IAAIC,GAA2B,OAAO,OAAW,IAAc,OAAO,uBAAuB,EAAI,OAEjGnhB,EAAA,UAAoB,SAAmBohB,EAAU,CAC/C,GAAI,OAAOA,GAAa,WAChB,UAAI,UAAU,kDAAkD,EAEpE,GAAAD,IAA4BC,EAASD,EAAwB,EAAG,CAC9D,IAAA1V,EAAK2V,EAASD,EAAwB,EACtC,UAAO1V,GAAO,WACV,UAAI,UAAU,+DAA+D,EAE9E,6BAAeA,EAAI0V,GAA0B,CAClD,MAAO1V,EAAI,WAAY,GAAO,SAAU,GAAO,aAAc,GAC9D,EACMA,CAAA,CAGT,SAASA,GAAK,CAQZ,QAPI4V,EAAgBC,EAChBC,EAAU,IAAI,QAAQ,SAAUriB,EAASC,EAAQ,CAClCkiB,EAAAniB,EACDoiB,EAAAniB,CAAA,CACjB,EAEGrD,EAAO,CAAC,EACHiB,EAAI,EAAGA,EAAI,UAAU,OAAQA,IAC/BjB,EAAA,KAAK,UAAUiB,CAAC,CAAC,EAEnBjB,EAAA,KAAK,SAAUqB,EAAKhB,EAAO,CAC1BgB,EACFmkB,EAAcnkB,CAAG,EAEjBkkB,EAAellB,CAAK,CACtB,CACD,EAEG,IACOilB,EAAA,MAAM,KAAMtlB,CAAI,QAClBqB,EAAK,CACZmkB,EAAcnkB,CAAG,EAGZ,OAAAokB,CAAA,CAGT,OAAO,sBAAe9V,EAAI,OAAO,eAAe2V,CAAQ,CAAC,EAErDD,IAA0B,OAAO,eAAe1V,EAAI0V,GAA0B,CAChF,MAAO1V,EAAI,WAAY,GAAO,SAAU,GAAO,aAAc,GAC9D,EACM,OAAO,iBACZA,EACA2R,EAA0BgE,CAAQ,CACpC,CACF,EAEAphB,EAAQ,UAAU,OAASmhB,GAE3B,SAASK,GAAsBC,EAAQC,EAAI,CAKzC,GAAI,CAACD,EAAQ,CACP,IAAAE,EAAY,IAAI,MAAM,yCAAyC,EACnEA,EAAU,OAASF,EACVA,EAAAE,CAAA,CAEX,OAAOD,EAAGD,CAAM,CAClB,CAEA,SAASG,GAAYR,EAAU,CACzB,UAAOA,GAAa,WAChB,UAAI,UAAU,kDAAkD,EAMxE,SAASS,GAAgB,CAEvB,QADI/lB,EAAO,CAAC,EACHiB,EAAI,EAAGA,EAAI,UAAU,OAAQA,IAC/BjB,EAAA,KAAK,UAAUiB,CAAC,CAAC,EAGpB,IAAA+kB,EAAUhmB,EAAK,IAAI,EACnB,UAAOgmB,GAAY,WACf,UAAI,UAAU,4CAA4C,EAElE,IAAIC,EAAO,KACPL,EAAK,UAAW,CACX,OAAAI,EAAQ,MAAMC,EAAM,SAAS,CACtC,EAGSX,EAAA,MAAM,KAAMtlB,CAAI,EACtB,KAAK,SAASkD,EAAK,CAAE4e,GAAQ,SAAS8D,EAAG,KAAK,KAAM,KAAM1iB,CAAG,CAAC,CAAE,EAC3D,SAASgjB,EAAK,CAAEpE,GAAQ,SAAS4D,GAAsB,KAAK,KAAMQ,EAAKN,CAAE,CAAC,EAAG,EAGvF,cAAO,eAAeG,EAAe,OAAO,eAAeT,CAAQ,CAAC,EAC7D,wBAAiBS,EACAzE,EAA0BgE,CAAQ,CAAC,EACpDS,CACT,CACA7hB,EAAA,YAAsB4hB,0DCxsBtB,SAASK,EAAQ5K,EAAQ6K,EAAgB,CAAE,IAAI7jB,EAAO,OAAO,KAAKgZ,CAAM,EAAG,GAAI,OAAO,sBAAuB,CAAE,IAAI8K,EAAU,OAAO,sBAAsB9K,CAAM,EAAG6K,IAAmBC,EAAUA,EAAQ,OAAO,SAAU7X,EAAK,CAAE,OAAO,OAAO,yBAAyB+M,EAAQ/M,CAAG,EAAE,UAAa,IAAIjM,EAAK,KAAK,MAAMA,EAAM8jB,CAAO,EAAK,OAAO9jB,CAAK,CACnV,SAAS+jB,EAAcxmB,EAAQ,CAAE,QAASmB,EAAI,EAAGA,EAAI,UAAU,OAAQA,IAAK,CAAE,IAAIslB,EAAiB,UAAUtlB,CAAC,GAAnB,KAAuB,UAAUA,CAAC,EAAI,GAAIA,EAAI,EAAIklB,EAAQ,OAAOI,CAAM,EAAG,EAAE,EAAE,QAAQ,SAAU/jB,EAAK,CAAEgkB,EAAgB1mB,EAAQ0C,EAAK+jB,EAAO/jB,CAAG,CAAC,CAAI,GAAI,OAAO,0BAA4B,OAAO,iBAAiB1C,EAAQ,OAAO,0BAA0BymB,CAAM,CAAC,EAAIJ,EAAQ,OAAOI,CAAM,CAAC,EAAE,QAAQ,SAAU/jB,EAAK,CAAE,OAAO,eAAe1C,EAAQ0C,EAAK,OAAO,yBAAyB+jB,EAAQ/jB,CAAG,CAAC,CAAI,EAAE,CAAG,OAAO1C,CAAO,CACxf,SAAS0mB,EAAgBvd,EAAKzG,EAAKnC,EAAO,CAAE,OAAAmC,EAAMikB,EAAejkB,CAAG,EAAOA,KAAOyG,EAAO,OAAO,eAAeA,EAAKzG,EAAK,CAAE,MAAOnC,EAAO,WAAY,GAAM,aAAc,GAAM,SAAU,EAAI,CAAE,EAAY4I,EAAIzG,CAAG,EAAInC,EAAgB4I,CAAI,CAC1O,SAASyd,EAAgBC,EAAUC,EAAa,CAAE,GAAI,EAAED,aAAoBC,GAAgB,MAAM,IAAI,UAAU,mCAAmC,CAAI,CACvJ,SAASC,EAAkB/mB,EAAQgnB,EAAO,CAAE,QAAS7lB,EAAI,EAAGA,EAAI6lB,EAAM,OAAQ7lB,IAAK,CAAE,IAAIiP,EAAa4W,EAAM7lB,CAAC,EAAGiP,EAAW,WAAaA,EAAW,YAAc,GAAOA,EAAW,aAAe,GAAU,UAAWA,IAAYA,EAAW,SAAW,IAAM,OAAO,eAAepQ,EAAQ2mB,EAAevW,EAAW,GAAG,EAAGA,CAAU,CAAI,EAC3U,SAAS6W,EAAaH,EAAaI,EAAYC,EAAa,CAAE,OAAID,GAAYH,EAAkBD,EAAY,UAAWI,CAAU,EAAiE,OAAO,eAAeJ,EAAa,YAAa,CAAE,SAAU,EAAO,GAAUA,CAAY,CAC3R,SAASH,EAAe7lB,EAAK,CAAE,IAAI4B,EAAM0kB,EAAatmB,EAAK,QAAQ,EAAG,OAAO,OAAO4B,GAAQ,SAAWA,EAAM,OAAOA,CAAG,CAAE,CACzH,SAAS0kB,EAAatY,EAAOuY,EAAM,CAAE,GAAI,OAAOvY,GAAU,UAAYA,IAAU,KAAM,OAAOA,EAAO,IAAIwY,EAAOxY,EAAM,OAAO,WAAW,EAAG,GAAIwY,IAAS,OAAW,CAAE,IAAIrb,EAAMqb,EAAK,KAAKxY,EAAOuY,CAAiB,EAAG,GAAI,OAAOpb,GAAQ,SAAU,OAAOA,EAAK,MAAM,IAAI,UAAU,8CAA8C,CAAI,CAAC,OAA4B,OAAiB6C,CAAK,CAAE,CACvX,IAAIyY,EAAWpjB,GAAiB,EAC9B+C,EAASqgB,EAAS,OAChBC,EAAYrU,GAAe,EAC7B0O,EAAU2F,EAAU,QAClBC,EAAS5F,GAAWA,EAAQ,QAAU,UAC1C,SAAS6F,EAAWlY,EAAKxP,EAAQkG,EAAQ,CACvCgB,EAAO,UAAU,KAAK,KAAKsI,EAAKxP,EAAQkG,CAAM,CAChD,CACc,OAAAyhB,IAAgB,UAAY,CACxC,SAASC,GAAa,CACpBhB,EAAgB,KAAMgB,CAAU,EAChC,KAAK,KAAO,KACZ,KAAK,KAAO,KACZ,KAAK,OAAS,CAClB,CACE,OAAAX,EAAaW,EAAY,CAAC,CACxB,IAAK,OACL,MAAO,SAAcC,EAAG,CACtB,IAAIC,EAAQ,CACV,KAAMD,EACN,KAAM,IACP,EACG,KAAK,OAAS,EAAG,KAAK,KAAK,KAAOC,EAAW,KAAK,KAAOA,EAC7D,KAAK,KAAOA,EACZ,EAAE,KAAK,MACb,CACA,EAAK,CACD,IAAK,UACL,MAAO,SAAiBD,EAAG,CACzB,IAAIC,EAAQ,CACV,KAAMD,EACN,KAAM,KAAK,IACZ,EACG,KAAK,SAAW,IAAG,KAAK,KAAOC,GACnC,KAAK,KAAOA,EACZ,EAAE,KAAK,MACb,CACA,EAAK,CACD,IAAK,QACL,MAAO,UAAiB,CACtB,GAAI,KAAK,SAAW,EACpB,CAAI1kB,MAAM,KAAK,KAAK,KACpB,OAAI,KAAK,SAAW,EAAG,KAAK,KAAO,KAAK,KAAO,KAAU,KAAK,KAAO,KAAK,KAAK,KAC/E,EAAE,KAAK,OACAA,EACb,CACA,EAAK,CACD,IAAK,QACL,MAAO,UAAiB,CACtB,KAAK,KAAO,KAAK,KAAO,KACxB,KAAK,OAAS,CACpB,CACA,EAAK,CACD,IAAK,OACL,MAAO,SAAcwD,EAAG,CACtB,GAAI,KAAK,SAAW,EAAG,MAAO,GAG9B,QAFImhB,EAAI,KAAK,KACT3kB,EAAM,GAAK2kB,EAAE,KACVA,EAAIA,EAAE,MAAM3kB,GAAOwD,EAAImhB,EAAE,KAChC,OAAO3kB,CACb,CACA,EAAK,CACD,IAAK,SACL,MAAO,SAAgBrC,EAAG,CACxB,GAAI,KAAK,SAAW,EAAG,OAAOmG,EAAO,MAAM,CAAC,EAI5C,QAHI9D,EAAM8D,EAAO,YAAYnG,IAAM,CAAC,EAChCgnB,EAAI,KAAK,KACT5mB,EAAI,EACD4mB,GACLL,EAAWK,EAAE,KAAM3kB,EAAKjC,CAAC,EACzBA,GAAK4mB,EAAE,KAAK,OACZA,EAAIA,EAAE,KAER,OAAO3kB,CACb,CAGA,EAAK,CACD,IAAK,UACL,MAAO,SAAiBrC,EAAGinB,EAAY,CACrC,IAAI5kB,EACJ,OAAIrC,EAAI,KAAK,KAAK,KAAK,QAErBqC,EAAM,KAAK,KAAK,KAAK,MAAM,EAAGrC,CAAC,EAC/B,KAAK,KAAK,KAAO,KAAK,KAAK,KAAK,MAAMA,CAAC,GAC9BA,IAAM,KAAK,KAAK,KAAK,OAE9BqC,EAAM,KAAK,MAAO,EAGlBA,EAAM4kB,EAAa,KAAK,WAAWjnB,CAAC,EAAI,KAAK,WAAWA,CAAC,EAEpDqC,CACb,CACA,EAAK,CACD,IAAK,QACL,MAAO,UAAiB,CACtB,OAAO,KAAK,KAAK,IACvB,CAGA,EAAK,CACD,IAAK,aACL,MAAO,SAAoBrC,EAAG,CAC5B,IAAIgnB,EAAI,KAAK,KACTlhB,EAAI,EACJzD,EAAM2kB,EAAE,KAEZ,IADAhnB,GAAKqC,EAAI,OACF2kB,EAAIA,EAAE,MAAM,CACjB,IAAI1d,EAAM0d,EAAE,KACRE,EAAKlnB,EAAIsJ,EAAI,OAASA,EAAI,OAAStJ,EAGvC,GAFIknB,IAAO5d,EAAI,OAAQjH,GAAOiH,EAASjH,GAAOiH,EAAI,MAAM,EAAGtJ,CAAC,EAC5DA,GAAKknB,EACDlnB,IAAM,EAAG,CACPknB,IAAO5d,EAAI,QACb,EAAExD,EACEkhB,EAAE,KAAM,KAAK,KAAOA,EAAE,KAAU,KAAK,KAAO,KAAK,KAAO,OAE5D,KAAK,KAAOA,EACZA,EAAE,KAAO1d,EAAI,MAAM4d,CAAE,GAEvB,KACV,CACQ,EAAEphB,CACV,CACM,OAAK,aAAUA,EACRzD,CACb,CAGA,EAAK,CACD,IAAK,aACL,MAAO,SAAoBrC,EAAG,CAC5B,IAAIqC,EAAM8D,EAAO,YAAYnG,CAAC,EAC1BgnB,EAAI,KAAK,KACTlhB,EAAI,EAGR,IAFAkhB,EAAE,KAAK,KAAK3kB,CAAG,EACfrC,GAAKgnB,EAAE,KAAK,OACLA,EAAIA,EAAE,MAAM,CACjB,IAAIngB,EAAMmgB,EAAE,KACRE,EAAKlnB,EAAI6G,EAAI,OAASA,EAAI,OAAS7G,EAGvC,GAFA6G,EAAI,KAAKxE,EAAKA,EAAI,OAASrC,EAAG,EAAGknB,CAAE,EACnClnB,GAAKknB,EACDlnB,IAAM,EAAG,CACPknB,IAAOrgB,EAAI,QACb,EAAEf,EACEkhB,EAAE,KAAM,KAAK,KAAOA,EAAE,KAAU,KAAK,KAAO,KAAK,KAAO,OAE5D,KAAK,KAAOA,EACZA,EAAE,KAAOngB,EAAI,MAAMqgB,CAAE,GAEvB,KACV,CACQ,EAAEphB,CACV,CACM,YAAK,QAAUA,EACRzD,CACb,CAGA,EAAK,CACD,IAAKqkB,EACL,MAAO,SAAevX,EAAGgY,EAAS,CAChC,OAAOrG,EAAQ,KAAM2E,EAAcA,EAAc,GAAI0B,CAAO,EAAG,GAAI,CAEjE,MAAO,EAEP,cAAe,EACvB,CAAO,CAAC,CACR,CACA,CAAG,CAAC,EACKN,CACT,GAAG,kDCnLH,SAASO,EAAQ5mB,EAAKukB,EAAI,CACxB,IAAIsC,EAAQ,KACRC,EAAoB,KAAK,gBAAkB,KAAK,eAAe,UAC/DC,EAAoB,KAAK,gBAAkB,KAAK,eAAe,UACnE,OAAID,GAAqBC,GACnBxC,EACFA,EAAGvkB,CAAG,EACGA,IACJ,KAAK,eAEE,KAAK,eAAe,eAC9B,KAAK,eAAe,aAAe,GACnCygB,GAAQ,SAASuG,EAAa,KAAMhnB,CAAG,GAHvCygB,GAAQ,SAASuG,EAAa,KAAMhnB,CAAG,GAMpC,OAML,KAAK,iBACP,KAAK,eAAe,UAAY,IAI9B,KAAK,iBACP,KAAK,eAAe,UAAY,IAElC,KAAK,SAASA,GAAO,KAAM,SAAUA,EAAK,CACpC,CAACukB,GAAMvkB,EACJ6mB,EAAM,eAECA,EAAM,eAAe,aAI/BpG,GAAQ,SAASwG,EAAaJ,CAAK,GAHnCA,EAAM,eAAe,aAAe,GACpCpG,GAAQ,SAASyG,EAAqBL,EAAO7mB,CAAG,GAHhDygB,GAAQ,SAASyG,EAAqBL,EAAO7mB,CAAG,EAOzCukB,GACT9D,GAAQ,SAASwG,EAAaJ,CAAK,EACnCtC,EAAGvkB,CAAG,GAENygB,GAAQ,SAASwG,EAAaJ,CAAK,CAEzC,CAAG,EACM,KACT,CACA,SAASK,EAAoBtC,EAAM5kB,EAAK,CACtCgnB,EAAYpC,EAAM5kB,CAAG,EACrBinB,EAAYrC,CAAI,CAClB,CACA,SAASqC,EAAYrC,EAAM,CACrBA,EAAK,gBAAkB,CAACA,EAAK,eAAe,WAC5CA,EAAK,gBAAkB,CAACA,EAAK,eAAe,WAChDA,EAAK,KAAK,OAAO,CACnB,CACA,SAASuC,GAAY,CACf,KAAK,iBACP,KAAK,eAAe,UAAY,GAChC,KAAK,eAAe,QAAU,GAC9B,KAAK,eAAe,MAAQ,GAC5B,KAAK,eAAe,WAAa,IAE/B,KAAK,iBACP,KAAK,eAAe,UAAY,GAChC,KAAK,eAAe,MAAQ,GAC5B,KAAK,eAAe,OAAS,GAC7B,KAAK,eAAe,YAAc,GAClC,KAAK,eAAe,YAAc,GAClC,KAAK,eAAe,SAAW,GAC/B,KAAK,eAAe,aAAe,GAEvC,CACA,SAASH,EAAYpC,EAAM5kB,EAAK,CAC9B4kB,EAAK,KAAK,QAAS5kB,CAAG,CACxB,CACA,SAASonB,EAAeC,EAAQrnB,EAAK,CAOnC,IAAIsnB,EAASD,EAAO,eAChBE,EAASF,EAAO,eAChBC,GAAUA,EAAO,aAAeC,GAAUA,EAAO,YAAaF,EAAO,QAAQrnB,CAAG,EAAOqnB,EAAO,KAAK,QAASrnB,CAAG,CACrH,CACA,OAAAwnB,GAAiB,CACf,QAASZ,EACT,UAAWO,EACX,eAAgBC,CACjB,qDC7FD,SAASK,EAAeC,EAAUC,EAAY,CAAED,EAAS,UAAY,OAAO,OAAOC,EAAW,SAAS,EAAGD,EAAS,UAAU,YAAcA,EAAUA,EAAS,UAAYC,CAAW,CAErL,IAAIC,EAAQ,CAAE,EAEd,SAASC,EAAgBvkB,EAAMwkB,EAASza,EAAM,CACvCA,IACHA,EAAO,OAGT,SAASD,EAAW2a,EAAMC,EAAMC,EAAM,CACpC,OAAI,OAAOH,GAAY,SACdA,EAEAA,EAAQC,EAAMC,EAAMC,CAAI,CAErC,CAEE,IAAIC,GAEJ,SAAUC,EAAO,CACfV,EAAeS,EAAWC,CAAK,EAE/B,SAASD,EAAUH,EAAMC,EAAMC,EAAM,CACnC,OAAOE,EAAM,KAAK,KAAM/a,EAAW2a,EAAMC,EAAMC,CAAI,CAAC,GAAK,IAC/D,CAEI,OAAOC,CACR,GAAC7a,CAAI,EAEN6a,EAAU,UAAU,KAAO7a,EAAK,KAChC6a,EAAU,UAAU,KAAO5kB,EAC3BskB,EAAMtkB,CAAI,EAAI4kB,CACf,CAGD,SAASE,EAAMC,EAAUC,EAAO,CAC9B,GAAI,MAAM,QAAQD,CAAQ,EAAG,CAC3B,IAAInoB,EAAMmoB,EAAS,OAKnB,OAJAA,EAAWA,EAAS,IAAI,SAAUzoB,EAAG,CACnC,OAAO,OAAOA,CAAC,CACrB,CAAK,EAEGM,EAAM,EACD,UAAU,OAAOooB,EAAO,GAAG,EAAE,OAAOD,EAAS,MAAM,EAAGnoB,EAAM,CAAC,EAAE,KAAK,IAAI,EAAG,OAAO,EAAImoB,EAASnoB,EAAM,CAAC,EACpGA,IAAQ,EACV,UAAU,OAAOooB,EAAO,GAAG,EAAE,OAAOD,EAAS,CAAC,EAAG,MAAM,EAAE,OAAOA,EAAS,CAAC,CAAC,EAE3E,MAAM,OAAOC,EAAO,GAAG,EAAE,OAAOD,EAAS,CAAC,CAAC,CAExD,YACW,MAAM,OAAOC,EAAO,GAAG,EAAE,OAAO,OAAOD,CAAQ,CAAC,CAE1D,CAGD,SAASE,EAAWzf,EAAK0f,EAAQvgB,EAAK,CACpC,OAAOa,EAAI,OAAyB,EAAU0f,EAAO,MAAM,IAAMA,CAClE,CAGD,SAASC,EAAS3f,EAAK0f,EAAQE,EAAU,CACvC,OAAIA,IAAa,QAAaA,EAAW5f,EAAI,UAC3C4f,EAAW5f,EAAI,QAGVA,EAAI,UAAU4f,EAAWF,EAAO,OAAQE,CAAQ,IAAMF,CAC9D,CAGD,SAASG,EAAS7f,EAAK0f,EAAQrkB,EAAO,CAKpC,OAJI,OAAOA,GAAU,WACnBA,EAAQ,GAGNA,EAAQqkB,EAAO,OAAS1f,EAAI,OACvB,GAEAA,EAAI,QAAQ0f,EAAQrkB,CAAK,IAAM,EAE1C,CAEA,OAAA0jB,EAAgB,wBAAyB,SAAU/lB,EAAM9C,EAAO,CAC9D,MAAO,cAAgBA,EAAQ,4BAA8B8C,EAAO,GACrE,EAAE,SAAS,EACZ+lB,EAAgB,uBAAwB,SAAU/lB,EAAMumB,EAAU9gB,EAAQ,CAExE,IAAIqhB,EAEA,OAAOP,GAAa,UAAYE,EAAWF,EAAU,MAAM,GAC7DO,EAAa,cACbP,EAAWA,EAAS,QAAQ,QAAS,EAAE,GAEvCO,EAAa,UAGf,IAAIpb,EAEJ,GAAIib,EAAS3mB,EAAM,WAAW,EAE5B0L,EAAM,OAAO,OAAO1L,EAAM,GAAG,EAAE,OAAO8mB,EAAY,GAAG,EAAE,OAAOR,EAAMC,EAAU,MAAM,CAAC,MAChF,CACL,IAAI1oB,EAAOgpB,EAAS7mB,EAAM,GAAG,EAAI,WAAa,WAC9C0L,EAAM,QAAS,OAAO1L,EAAM,IAAK,EAAE,OAAOnC,EAAM,GAAG,EAAE,OAAOipB,EAAY,GAAG,EAAE,OAAOR,EAAMC,EAAU,MAAM,CAAC,CAC/G,CAEE,OAAA7a,GAAO,mBAAmB,OAAO,OAAOjG,CAAM,EACvCiG,CACR,EAAE,SAAS,EACZqa,EAAgB,4BAA6B,yBAAyB,EACtEA,EAAgB,6BAA8B,SAAU/lB,EAAM,CAC5D,MAAO,OAASA,EAAO,4BACzB,CAAC,EACD+lB,EAAgB,6BAA8B,iBAAiB,EAC/DA,EAAgB,uBAAwB,SAAU/lB,EAAM,CACtD,MAAO,eAAiBA,EAAO,+BACjC,CAAC,EACD+lB,EAAgB,wBAAyB,gCAAgC,EACzEA,EAAgB,yBAA0B,2BAA2B,EACrEA,EAAgB,6BAA8B,iBAAiB,EAC/DA,EAAgB,yBAA0B,sCAAuC,SAAS,EAC1FA,EAAgB,uBAAwB,SAAUtoB,EAAK,CACrD,MAAO,qBAAuBA,CAC/B,EAAE,SAAS,EACZsoB,EAAgB,qCAAsC,kCAAkC,EACxFgB,GAAA,MAAuBjB,kDC5HvB,IAAIkB,EAAwBlmB,KAA2B,MAAM,sBAC7D,SAASmmB,EAAkBpC,EAASqC,EAAUC,EAAW,CACvD,OAAOtC,EAAQ,eAAiB,KAAOA,EAAQ,cAAgBqC,EAAWrC,EAAQsC,CAAS,EAAI,IACjG,CACA,SAASC,EAAiBtoB,EAAO+lB,EAASsC,EAAWD,EAAU,CAC7D,IAAIG,EAAMJ,EAAkBpC,EAASqC,EAAUC,CAAS,EACxD,GAAIE,GAAO,KAAM,CACf,GAAI,EAAE,SAASA,CAAG,GAAK,KAAK,MAAMA,CAAG,IAAMA,IAAQA,EAAM,EAAG,CAC1D,IAAIrnB,EAAOknB,EAAWC,EAAY,gBAClC,MAAM,IAAIH,EAAsBhnB,EAAMqnB,CAAG,CAC/C,CACI,OAAO,KAAK,MAAMA,CAAG,CACzB,CAGE,OAAOvoB,EAAM,WAAa,GAAK,GAAK,IACtC,CACA,OAAAA,GAAiB,CACf,iBAAkBsoB,CACnB,kDChBDE,GAAiBC,EAoBjB,SAASA,EAAW/a,EAAId,EAAK,CAC3B,GAAI8b,EAAO,eAAe,EACxB,OAAOhb,EAGT,IAAIoS,EAAS,GACb,SAASC,GAAa,CACpB,GAAI,CAACD,EAAQ,CACX,GAAI4I,EAAO,kBAAkB,EAC3B,MAAM,IAAI,MAAM9b,CAAG,EACV8b,EAAO,kBAAkB,EAClC,QAAQ,MAAM9b,CAAG,EAEjB,QAAQ,KAAKA,CAAG,EAElBkT,EAAS,EACf,CACI,OAAOpS,EAAG,MAAM,KAAM,SAAS,CACnC,CAEE,OAAOqS,CACT,CAUA,SAAS2I,EAAQxnB,EAAM,CAErB,GAAI,CACF,GAAI,CAAC4Y,GAAO,aAAc,MAAO,EAClC,MAAW,CACV,MAAO,EACX,CACE,IAAIrR,EAAMqR,GAAO,aAAa5Y,CAAI,EAClC,OAAYuH,GAAR,KAAoB,GACjB,OAAOA,CAAG,EAAE,YAAa,IAAK,MACvC,wDCvCAkgB,GAAiBC,EAYjB,SAASC,EAAc7oB,EAAO,CAC5B,IAAIimB,EAAQ,KACZ,KAAK,KAAO,KACZ,KAAK,MAAQ,KACb,KAAK,OAAS,UAAY,CACxB6C,EAAe7C,EAAOjmB,CAAK,CAC5B,CACH,CAIA,IAAI+oB,EAGJH,EAAS,cAAgBI,EAGzB,IAAIC,EAAe,CACjB,UAAWjnB,GAAA,CACZ,EAIGknB,EAASlY,GAAoC,EAG7CjM,EAASmM,GAAiB,EAAC,OAC3BiY,GAAiB,OAAOrP,GAAW,IAAcA,GAAS,OAAO,OAAW,IAAc,OAAS,OAAO,KAAS,IAAc,KAAO,CAAE,GAAE,YAAc,UAAY,CAAE,EAC5K,SAASsP,EAAoBC,EAAO,CAClC,OAAOtkB,EAAO,KAAKskB,CAAK,CAC1B,CACA,SAASC,EAActiB,EAAK,CAC1B,OAAOjC,EAAO,SAASiC,CAAG,GAAKA,aAAemiB,CAChD,CACA,IAAII,EAAcnY,GAAqC,EACnDgU,EAAWzS,GAAmC,EAChD2V,EAAmBlD,EAAS,iBAC1BoE,EAAiB3W,GAAoB,EAAC,MACxC4W,EAAuBD,EAAe,qBACtCE,EAA6BF,EAAe,2BAC5CG,EAAwBH,EAAe,sBACvCI,EAAyBJ,EAAe,uBACxCK,EAAuBL,EAAe,qBACtCM,EAAyBN,EAAe,uBACxCO,EAA6BP,EAAe,2BAC5CQ,EAAuBR,EAAe,qBACpChD,EAAiB+C,EAAY,eACjCzW,GAAmB,EAAC8V,EAAUM,CAAM,EACpC,SAASe,GAAM,EACf,SAASjB,EAAcjD,EAASU,EAAQ2B,EAAU,CAChDW,EAASA,GAAU/V,GAA2B,EAC9C+S,EAAUA,GAAW,CAAE,EAOnB,OAAOqC,GAAa,YAAWA,EAAW3B,aAAkBsC,GAIhE,KAAK,WAAa,CAAC,CAAChD,EAAQ,WACxBqC,IAAU,KAAK,WAAa,KAAK,YAAc,CAAC,CAACrC,EAAQ,oBAK7D,KAAK,cAAgBuC,EAAiB,KAAMvC,EAAS,wBAAyBqC,CAAQ,EAGtF,KAAK,YAAc,GAGnB,KAAK,UAAY,GAEjB,KAAK,OAAS,GAEd,KAAK,MAAQ,GAEb,KAAK,SAAW,GAGhB,KAAK,UAAY,GAKjB,IAAI8B,EAAWnE,EAAQ,gBAAkB,GACzC,KAAK,cAAgB,CAACmE,EAKtB,KAAK,gBAAkBnE,EAAQ,iBAAmB,OAKlD,KAAK,OAAS,EAGd,KAAK,QAAU,GAGf,KAAK,OAAS,EAMd,KAAK,KAAO,GAKZ,KAAK,iBAAmB,GAGxB,KAAK,QAAU,SAAU5mB,EAAI,CAC3BgrB,GAAQ1D,EAAQtnB,CAAE,CACnB,EAGD,KAAK,QAAU,KAGf,KAAK,SAAW,EAChB,KAAK,gBAAkB,KACvB,KAAK,oBAAsB,KAI3B,KAAK,UAAY,EAIjB,KAAK,YAAc,GAGnB,KAAK,aAAe,GAGpB,KAAK,UAAY4mB,EAAQ,YAAc,GAGvC,KAAK,YAAc,CAAC,CAACA,EAAQ,YAG7B,KAAK,qBAAuB,EAI5B,KAAK,mBAAqB,IAAI8C,EAAc,IAAI,CAClD,CACAG,EAAc,UAAU,UAAY,UAAqB,CAGvD,QAFIoB,EAAU,KAAK,gBACf3f,EAAM,CAAE,EACL2f,GACL3f,EAAI,KAAK2f,CAAO,EAChBA,EAAUA,EAAQ,KAEpB,OAAO3f,CACR,GACA,UAAY,CACX,GAAI,CACF,OAAO,eAAeue,EAAc,UAAW,SAAU,CACvD,IAAKC,EAAa,UAAU,UAAqC,CAC/D,OAAO,KAAK,UAAW,CAC/B,EAAS,6EAAmF,SAAS,CACrG,CAAK,CACF,MAAW,EACd,GAAI,EAIJ,IAAIoB,EACA,OAAO,QAAW,YAAc,OAAO,aAAe,OAAO,SAAS,UAAU,OAAO,WAAW,GAAM,YAC1GA,EAAkB,SAAS,UAAU,OAAO,WAAW,EACvD,OAAO,eAAezB,EAAU,OAAO,YAAa,CAClD,MAAO,SAAetP,EAAQ,CAC5B,OAAI+Q,EAAgB,KAAK,KAAM/Q,CAAM,EAAU,GAC3C,OAASsP,EAAiB,GACvBtP,GAAUA,EAAO,0BAA0B0P,CACxD,CACA,CAAG,GAEDqB,EAAkB,SAAyB/Q,EAAQ,CACjD,OAAOA,aAAkB,IAC1B,EAEH,SAASsP,EAAS7C,EAAS,CACzBgD,EAASA,GAAU/V,GAA2B,EAY9C,IAAIoV,EAAW,gBAAgBW,EAC/B,GAAI,CAACX,GAAY,CAACiC,EAAgB,KAAKzB,EAAU,IAAI,EAAG,OAAO,IAAIA,EAAS7C,CAAO,EACnF,KAAK,eAAiB,IAAIiD,EAAcjD,EAAS,KAAMqC,CAAQ,EAG/D,KAAK,SAAW,GACZrC,IACE,OAAOA,EAAQ,OAAU,aAAY,KAAK,OAASA,EAAQ,OAC3D,OAAOA,EAAQ,QAAW,aAAY,KAAK,QAAUA,EAAQ,QAC7D,OAAOA,EAAQ,SAAY,aAAY,KAAK,SAAWA,EAAQ,SAC/D,OAAOA,EAAQ,OAAU,aAAY,KAAK,OAASA,EAAQ,QAEjEmD,EAAO,KAAK,IAAI,CAClB,CAGAN,EAAS,UAAU,KAAO,UAAY,CACpCpC,EAAe,KAAM,IAAIoD,CAAwB,CAClD,EACD,SAASU,EAAc7D,EAAQ9C,EAAI,CACjC,IAAIxkB,EAAK,IAAI4qB,EAEbvD,EAAeC,EAAQtnB,CAAE,EACzB0gB,GAAQ,SAAS8D,EAAIxkB,CAAE,CACzB,CAKA,SAASorB,EAAW9D,EAAQzmB,EAAOqpB,EAAO1F,EAAI,CAC5C,IAAIxkB,EAMJ,OALIkqB,IAAU,KACZlqB,EAAK,IAAI2qB,EACA,OAAOT,GAAU,UAAY,CAACrpB,EAAM,aAC7Cb,EAAK,IAAIsqB,EAAqB,QAAS,CAAC,SAAU,QAAQ,EAAGJ,CAAK,GAEhElqB,GACFqnB,EAAeC,EAAQtnB,CAAE,EACzB0gB,GAAQ,SAAS8D,EAAIxkB,CAAE,EAChB,IAEF,EACT,CACAypB,EAAS,UAAU,MAAQ,SAAUS,EAAO7iB,EAAUmd,EAAI,CACxD,IAAI3jB,EAAQ,KAAK,eACbiB,EAAM,GACNupB,EAAQ,CAACxqB,EAAM,YAAcspB,EAAcD,CAAK,EACpD,OAAImB,GAAS,CAACzlB,EAAO,SAASskB,CAAK,IACjCA,EAAQD,EAAoBC,CAAK,GAE/B,OAAO7iB,GAAa,aACtBmd,EAAKnd,EACLA,EAAW,MAETgkB,EAAOhkB,EAAW,SAAmBA,IAAUA,EAAWxG,EAAM,iBAChE,OAAO2jB,GAAO,aAAYA,EAAKsG,GAC/BjqB,EAAM,OAAQsqB,EAAc,KAAM3G,CAAE,GAAW6G,GAASD,EAAW,KAAMvqB,EAAOqpB,EAAO1F,CAAE,KAC3F3jB,EAAM,YACNiB,EAAMwpB,EAAc,KAAMzqB,EAAOwqB,EAAOnB,EAAO7iB,EAAUmd,CAAE,GAEtD1iB,CACR,EACD2nB,EAAS,UAAU,KAAO,UAAY,CACpC,KAAK,eAAe,QACrB,EACDA,EAAS,UAAU,OAAS,UAAY,CACtC,IAAI5oB,EAAQ,KAAK,eACbA,EAAM,SACRA,EAAM,SACF,CAACA,EAAM,SAAW,CAACA,EAAM,QAAU,CAACA,EAAM,kBAAoBA,EAAM,iBAAiB0qB,GAAY,KAAM1qB,CAAK,EAEnH,EACD4oB,EAAS,UAAU,mBAAqB,SAA4BpiB,EAAU,CAG5E,GADI,OAAOA,GAAa,WAAUA,EAAWA,EAAS,YAAa,GAC/D,EAAE,CAAC,MAAO,OAAQ,QAAS,QAAS,SAAU,SAAU,OAAQ,QAAS,UAAW,WAAY,KAAK,EAAE,SAASA,EAAW,IAAI,aAAa,EAAI,IAAK,MAAM,IAAIwjB,EAAqBxjB,CAAQ,EAChM,OAAK,oBAAe,gBAAkBA,EAC/B,IACR,EACD,OAAO,eAAeoiB,EAAS,UAAW,iBAAkB,CAI1D,WAAY,GACZ,IAAK,UAAe,CAClB,OAAO,KAAK,gBAAkB,KAAK,eAAe,UAAW,CACjE,CACA,CAAC,EACD,SAAS+B,EAAY3qB,EAAOqpB,EAAO7iB,EAAU,CAC3C,MAAI,CAACxG,EAAM,YAAcA,EAAM,gBAAkB,IAAS,OAAOqpB,GAAU,WACzEA,EAAQtkB,EAAO,KAAKskB,EAAO7iB,CAAQ,GAE9B6iB,CACT,CACA,OAAO,eAAeT,EAAS,UAAW,wBAAyB,CAIjE,WAAY,GACZ,IAAK,UAAe,CAClB,OAAO,KAAK,eAAe,aAC/B,CACA,CAAC,EAKD,SAAS6B,EAAchE,EAAQzmB,EAAOwqB,EAAOnB,EAAO7iB,EAAUmd,EAAI,CAChE,GAAI,CAAC6G,EAAO,CACV,IAAII,EAAWD,EAAY3qB,EAAOqpB,EAAO7iB,CAAQ,EAC7C6iB,IAAUuB,IACZJ,EAAQ,GACRhkB,EAAW,SACX6iB,EAAQuB,EAEd,CACE,IAAItrB,EAAMU,EAAM,WAAa,EAAIqpB,EAAM,OACvCrpB,EAAM,QAAUV,EAChB,IAAI2B,EAAMjB,EAAM,OAASA,EAAM,cAG/B,GADKiB,IAAKjB,EAAM,UAAY,IACxBA,EAAM,SAAWA,EAAM,OAAQ,CACjC,IAAIoL,EAAOpL,EAAM,oBACjBA,EAAM,oBAAsB,CAC1B,MAAOqpB,EACP,SAAU7iB,EACV,MAAOgkB,EACP,SAAU7G,EACV,KAAM,IACP,EACGvY,EACFA,EAAK,KAAOpL,EAAM,oBAElBA,EAAM,gBAAkBA,EAAM,oBAEhCA,EAAM,sBAAwB,CAClC,MACI6qB,EAAQpE,EAAQzmB,EAAO,GAAOV,EAAK+pB,EAAO7iB,EAAUmd,CAAE,EAExD,OAAO1iB,CACT,CACA,SAAS4pB,EAAQpE,EAAQzmB,EAAO8qB,EAAQxrB,EAAK+pB,EAAO7iB,EAAUmd,EAAI,CAChE3jB,EAAM,SAAWV,EACjBU,EAAM,QAAU2jB,EAChB3jB,EAAM,QAAU,GAChBA,EAAM,KAAO,GACTA,EAAM,UAAWA,EAAM,QAAQ,IAAI6pB,EAAqB,OAAO,CAAC,EAAWiB,EAAQrE,EAAO,QAAQ4C,EAAOrpB,EAAM,OAAO,EAAOymB,EAAO,OAAO4C,EAAO7iB,EAAUxG,EAAM,OAAO,EAC7KA,EAAM,KAAO,EACf,CACA,SAAS+qB,GAAatE,EAAQzmB,EAAOgrB,EAAM7rB,EAAIwkB,EAAI,CACjD,EAAE3jB,EAAM,UACJgrB,GAGFnL,GAAQ,SAAS8D,EAAIxkB,CAAE,EAGvB0gB,GAAQ,SAASoL,EAAaxE,EAAQzmB,CAAK,EAC3CymB,EAAO,eAAe,aAAe,GACrCD,EAAeC,EAAQtnB,CAAE,IAIzBwkB,EAAGxkB,CAAE,EACLsnB,EAAO,eAAe,aAAe,GACrCD,EAAeC,EAAQtnB,CAAE,EAGzB8rB,EAAYxE,EAAQzmB,CAAK,EAE7B,CACA,SAASkrB,GAAmBlrB,EAAO,CACjCA,EAAM,QAAU,GAChBA,EAAM,QAAU,KAChBA,EAAM,QAAUA,EAAM,SACtBA,EAAM,SAAW,CACnB,CACA,SAASmqB,GAAQ1D,EAAQtnB,EAAI,CAC3B,IAAIa,EAAQymB,EAAO,eACfuE,EAAOhrB,EAAM,KACb2jB,EAAK3jB,EAAM,QACf,GAAI,OAAO2jB,GAAO,WAAY,MAAM,IAAIgG,EAExC,GADAuB,GAAmBlrB,CAAK,EACpBb,EAAI4rB,GAAatE,EAAQzmB,EAAOgrB,EAAM7rB,EAAIwkB,CAAE,MAAO,CAErD,IAAIwH,EAAWC,GAAWprB,CAAK,GAAKymB,EAAO,UACvC,CAAC0E,GAAY,CAACnrB,EAAM,QAAU,CAACA,EAAM,kBAAoBA,EAAM,iBACjE0qB,GAAYjE,EAAQzmB,CAAK,EAEvBgrB,EACFnL,GAAQ,SAASwL,EAAY5E,EAAQzmB,EAAOmrB,EAAUxH,CAAE,EAExD0H,EAAW5E,EAAQzmB,EAAOmrB,EAAUxH,CAAE,CAE5C,CACA,CACA,SAAS0H,EAAW5E,EAAQzmB,EAAOmrB,EAAUxH,EAAI,CAC1CwH,GAAUG,GAAa7E,EAAQzmB,CAAK,EACzCA,EAAM,YACN2jB,EAAI,EACJsH,EAAYxE,EAAQzmB,CAAK,CAC3B,CAKA,SAASsrB,GAAa7E,EAAQzmB,EAAO,CAC/BA,EAAM,SAAW,GAAKA,EAAM,YAC9BA,EAAM,UAAY,GAClBymB,EAAO,KAAK,OAAO,EAEvB,CAGA,SAASiE,GAAYjE,EAAQzmB,EAAO,CAClCA,EAAM,iBAAmB,GACzB,IAAI2lB,EAAQ3lB,EAAM,gBAClB,GAAIymB,EAAO,SAAWd,GAASA,EAAM,KAAM,CAEzC,IAAIzD,EAAIliB,EAAM,qBACVkC,EAAS,IAAI,MAAMggB,CAAC,EACpBqJ,EAASvrB,EAAM,mBACnBurB,EAAO,MAAQ5F,EAGf,QAFI6F,EAAQ,EACRC,EAAa,GACV9F,GACLzjB,EAAOspB,CAAK,EAAI7F,EACXA,EAAM,QAAO8F,EAAa,IAC/B9F,EAAQA,EAAM,KACd6F,GAAS,EAEXtpB,EAAO,WAAaupB,EACpBZ,EAAQpE,EAAQzmB,EAAO,GAAMA,EAAM,OAAQkC,EAAQ,GAAIqpB,EAAO,MAAM,EAIpEvrB,EAAM,YACNA,EAAM,oBAAsB,KACxBurB,EAAO,MACTvrB,EAAM,mBAAqBurB,EAAO,KAClCA,EAAO,KAAO,MAEdvrB,EAAM,mBAAqB,IAAI6oB,EAAc7oB,CAAK,EAEpDA,EAAM,qBAAuB,CACjC,KAAS,CAEL,KAAO2lB,GAAO,CACZ,IAAI0D,EAAQ1D,EAAM,MACdnf,EAAWmf,EAAM,SACjBhC,EAAKgC,EAAM,SACXrmB,EAAMU,EAAM,WAAa,EAAIqpB,EAAM,OAQvC,GAPAwB,EAAQpE,EAAQzmB,EAAO,GAAOV,EAAK+pB,EAAO7iB,EAAUmd,CAAE,EACtDgC,EAAQA,EAAM,KACd3lB,EAAM,uBAKFA,EAAM,QACR,KAER,CACQ2lB,IAAU,OAAM3lB,EAAM,oBAAsB,KACpD,CACEA,EAAM,gBAAkB2lB,EACxB3lB,EAAM,iBAAmB,EAC3B,CACA4oB,EAAS,UAAU,OAAS,SAAUS,EAAO7iB,EAAUmd,EAAI,CACzDA,EAAG,IAAI+F,EAA2B,UAAU,CAAC,CAC9C,EACDd,EAAS,UAAU,QAAU,KAC7BA,EAAS,UAAU,IAAM,SAAUS,EAAO7iB,EAAUmd,EAAI,CACtD,IAAI3jB,EAAQ,KAAK,eACjB,OAAI,OAAOqpB,GAAU,YACnB1F,EAAK0F,EACLA,EAAQ,KACR7iB,EAAW,MACF,OAAOA,GAAa,aAC7Bmd,EAAKnd,EACLA,EAAW,MAET6iB,GAAU,MAA6B,KAAK,MAAMA,EAAO7iB,CAAQ,EAGjExG,EAAM,SACRA,EAAM,OAAS,EACf,KAAK,OAAQ,GAIVA,EAAM,QAAQ0rB,EAAY,KAAM1rB,EAAO2jB,CAAE,EACvC,IACR,EACD,OAAO,eAAeiF,EAAS,UAAW,iBAAkB,CAI1D,WAAY,GACZ,IAAK,UAAe,CAClB,OAAO,KAAK,eAAe,MAC/B,CACA,CAAC,EACD,SAASwC,GAAWprB,EAAO,CACzB,OAAOA,EAAM,QAAUA,EAAM,SAAW,GAAKA,EAAM,kBAAoB,MAAQ,CAACA,EAAM,UAAY,CAACA,EAAM,OAC3G,CACA,SAAS2rB,GAAUlF,EAAQzmB,EAAO,CAChCymB,EAAO,OAAO,SAAUrnB,EAAK,CAC3BY,EAAM,YACFZ,GACFonB,EAAeC,EAAQrnB,CAAG,EAE5BY,EAAM,YAAc,GACpBymB,EAAO,KAAK,WAAW,EACvBwE,EAAYxE,EAAQzmB,CAAK,CAC7B,CAAG,CACH,CACA,SAAS4rB,GAAUnF,EAAQzmB,EAAO,CAC5B,CAACA,EAAM,aAAe,CAACA,EAAM,cAC3B,OAAOymB,EAAO,QAAW,YAAc,CAACzmB,EAAM,WAChDA,EAAM,YACNA,EAAM,YAAc,GACpB6f,GAAQ,SAAS8L,GAAWlF,EAAQzmB,CAAK,IAEzCA,EAAM,YAAc,GACpBymB,EAAO,KAAK,WAAW,GAG7B,CACA,SAASwE,EAAYxE,EAAQzmB,EAAO,CAClC,IAAI6rB,EAAOT,GAAWprB,CAAK,EAC3B,GAAI6rB,IACFD,GAAUnF,EAAQzmB,CAAK,EACnBA,EAAM,YAAc,IACtBA,EAAM,SAAW,GACjBymB,EAAO,KAAK,QAAQ,EAChBzmB,EAAM,cAAa,CAGrB,IAAI0mB,EAASD,EAAO,gBAChB,CAACC,GAAUA,EAAO,aAAeA,EAAO,aAC1CD,EAAO,QAAS,CAE1B,CAGE,OAAOoF,CACT,CACA,SAASH,EAAYjF,EAAQzmB,EAAO2jB,EAAI,CACtC3jB,EAAM,OAAS,GACfirB,EAAYxE,EAAQzmB,CAAK,EACrB2jB,IACE3jB,EAAM,SAAU6f,GAAQ,SAAS8D,CAAE,EAAO8C,EAAO,KAAK,SAAU9C,CAAE,GAExE3jB,EAAM,MAAQ,GACdymB,EAAO,SAAW,EACpB,CACA,SAASqC,EAAegD,EAAS9rB,EAAOZ,EAAK,CAC3C,IAAIumB,EAAQmG,EAAQ,MAEpB,IADAA,EAAQ,MAAQ,KACTnG,GAAO,CACZ,IAAIhC,EAAKgC,EAAM,SACf3lB,EAAM,YACN2jB,EAAGvkB,CAAG,EACNumB,EAAQA,EAAM,IAClB,CAGE3lB,EAAM,mBAAmB,KAAO8rB,CAClC,CACA,cAAO,eAAelD,EAAS,UAAW,YAAa,CAIrD,WAAY,GACZ,IAAK,UAAe,CAClB,OAAI,KAAK,iBAAmB,OACnB,GAEF,KAAK,eAAe,SAC5B,EACD,IAAK,SAAaxqB,EAAO,CAGlB,KAAK,iBAMV,KAAK,eAAe,UAAYA,EACpC,CACA,CAAC,EACDwqB,EAAS,UAAU,QAAUW,EAAY,QACzCX,EAAS,UAAU,WAAaW,EAAY,UAC5CX,EAAS,UAAU,SAAW,SAAUxpB,EAAKukB,EAAI,CAC/CA,EAAGvkB,CAAG,CACP,kDCnmBD,IAAI2sB,EAAa,OAAO,MAAQ,SAAU/kB,EAAK,CAC7C,IAAI1G,EAAO,CAAE,EACb,QAASC,KAAOyG,EAAK1G,EAAK,KAAKC,CAAG,EAClC,OAAOD,CACR,EAGD0rB,GAAiBjD,EACjB,IAAIkD,EAAWjqB,GAA6B,EACxC4mB,EAAW5X,GAA6B,EAC5CE,GAAmB,EAAC6X,EAAQkD,CAAQ,EAIlC,QADI3rB,EAAOyrB,EAAWnD,EAAS,SAAS,EAC/BlD,EAAI,EAAGA,EAAIplB,EAAK,OAAQolB,IAAK,CACpC,IAAIvG,EAAS7e,EAAKolB,CAAC,EACdqD,EAAO,UAAU5J,CAAM,IAAG4J,EAAO,UAAU5J,CAAM,EAAIyJ,EAAS,UAAUzJ,CAAM,EACvF,CAEA,SAAS4J,EAAOhD,EAAS,CACvB,GAAI,EAAE,gBAAgBgD,GAAS,OAAO,IAAIA,EAAOhD,CAAO,EACxDkG,EAAS,KAAK,KAAMlG,CAAO,EAC3B6C,EAAS,KAAK,KAAM7C,CAAO,EAC3B,KAAK,cAAgB,GACjBA,IACEA,EAAQ,WAAa,KAAO,KAAK,SAAW,IAC5CA,EAAQ,WAAa,KAAO,KAAK,SAAW,IAC5CA,EAAQ,gBAAkB,KAC5B,KAAK,cAAgB,GACrB,KAAK,KAAK,MAAOmG,CAAK,GAG5B,CACA,OAAO,eAAenD,EAAO,UAAW,wBAAyB,CAI/D,WAAY,GACZ,IAAK,UAAe,CAClB,OAAO,KAAK,eAAe,aAC/B,CACA,CAAC,EACD,OAAO,eAAeA,EAAO,UAAW,iBAAkB,CAIxD,WAAY,GACZ,IAAK,UAAe,CAClB,OAAO,KAAK,gBAAkB,KAAK,eAAe,UAAW,CACjE,CACA,CAAC,EACD,OAAO,eAAeA,EAAO,UAAW,iBAAkB,CAIxD,WAAY,GACZ,IAAK,UAAe,CAClB,OAAO,KAAK,eAAe,MAC/B,CACA,CAAC,EAGD,SAASmD,GAAQ,CAEX,KAAK,eAAe,OAIxBrM,GAAQ,SAASsM,EAAS,IAAI,CAChC,CACA,SAASA,EAAQnI,EAAM,CACrBA,EAAK,IAAK,CACZ,CACA,cAAO,eAAe+E,EAAO,UAAW,YAAa,CAInD,WAAY,GACZ,IAAK,UAAe,CAClB,OAAI,KAAK,iBAAmB,QAAa,KAAK,iBAAmB,OACxD,GAEF,KAAK,eAAe,WAAa,KAAK,eAAe,SAC7D,EACD,IAAK,SAAa3qB,EAAO,CAGnB,KAAK,iBAAmB,QAAa,KAAK,iBAAmB,SAMjE,KAAK,eAAe,UAAYA,EAChC,KAAK,eAAe,UAAYA,EACpC,CACA,CAAC,gFC3HD,IAAI8D,EAASF,GAAA,EACT+C,EAAS7C,EAAO,OAGpB,SAASkqB,EAAW/e,EAAKC,EAAK,CAC5B,QAAS/M,KAAO8M,EACdC,EAAI/M,CAAG,EAAI8M,EAAI9M,CAAG,CAEtB,CACIwE,EAAO,MAAQA,EAAO,OAASA,EAAO,aAAeA,EAAO,gBAC9DgW,EAAiB,QAAA7Y,GAGjBkqB,EAAUlqB,EAAQD,CAAO,EACzBA,EAAiB,OAAAoqB,GAGnB,SAASA,EAAY1tB,EAAK+G,EAAkBF,EAAQ,CAClD,OAAOT,EAAOpG,EAAK+G,EAAkBF,CAAM,CAC7C,CAEA6mB,EAAW,UAAY,OAAO,OAAOtnB,EAAO,SAAS,EAGrDqnB,EAAUrnB,EAAQsnB,CAAU,EAE5BA,EAAW,KAAO,SAAU1tB,EAAK+G,EAAkBF,EAAQ,CACzD,GAAI,OAAO7G,GAAQ,SACjB,MAAM,IAAI,UAAU,+BAA+B,EAErD,OAAOoG,EAAOpG,EAAK+G,EAAkBF,CAAM,CAC7C,EAEA6mB,EAAW,MAAQ,SAAUhmB,EAAME,EAAMC,EAAU,CACjD,GAAI,OAAOH,GAAS,SAClB,MAAM,IAAI,UAAU,2BAA2B,EAEjD,IAAIZ,EAAMV,EAAOsB,CAAI,EACrB,OAAIE,IAAS,OACP,OAAOC,GAAa,SACtBf,EAAI,KAAKc,EAAMC,CAAQ,EAEvBf,EAAI,KAAKc,CAAI,EAGfd,EAAI,KAAK,CAAC,EAELA,CACT,EAEA4mB,EAAW,YAAc,SAAUhmB,EAAM,CACvC,GAAI,OAAOA,GAAS,SAClB,MAAM,IAAI,UAAU,2BAA2B,EAEjD,OAAOtB,EAAOsB,CAAI,CACpB,EAEAgmB,EAAW,gBAAkB,SAAUhmB,EAAM,CAC3C,GAAI,OAAOA,GAAS,SAClB,MAAM,IAAI,UAAU,2BAA2B,EAEjD,OAAOnE,EAAO,WAAWmE,CAAI,CAC/B,yECvCA,IAAItB,EAAS/C,GAAsB,EAAC,OAGhCsqB,EAAavnB,EAAO,YAAc,SAAUyB,EAAU,CAExD,OADAA,EAAW,GAAKA,EACRA,GAAYA,EAAS,YAAa,GACxC,IAAK,MAAM,IAAK,OAAO,IAAK,QAAQ,IAAK,QAAQ,IAAK,SAAS,IAAK,SAAS,IAAK,OAAO,IAAK,QAAQ,IAAK,UAAU,IAAK,WAAW,IAAK,MACxI,MAAO,GACT,QACE,MAAO,EACb,CACC,EAED,SAAS+lB,EAAmBC,EAAK,CAC/B,GAAI,CAACA,EAAK,MAAO,OAEjB,QADIC,IAEF,OAAQD,EAAG,CACT,IAAK,OACL,IAAK,QACH,MAAO,OACT,IAAK,OACL,IAAK,QACL,IAAK,UACL,IAAK,WACH,MAAO,UACT,IAAK,SACL,IAAK,SACH,MAAO,SACT,IAAK,SACL,IAAK,QACL,IAAK,MACH,OAAOA,EACT,QACE,GAAIC,EAAS,OACbD,GAAO,GAAKA,GAAK,YAAa,EAC9BC,EAAU,EAClB,EAMA,SAASC,EAAkBF,EAAK,CAC9B,IAAIG,EAAOJ,EAAmBC,CAAG,EACjC,GAAI,OAAOG,GAAS,WAAa5nB,EAAO,aAAeunB,GAAc,CAACA,EAAWE,CAAG,GAAI,MAAM,IAAI,MAAM,qBAAuBA,CAAG,EAClI,OAAOG,GAAQH,CACjB,CAKAI,GAAA,cAAwBC,EACxB,SAASA,EAAcrmB,EAAU,CAC/B,KAAK,SAAWkmB,EAAkBlmB,CAAQ,EAC1C,IAAIsf,EACJ,OAAQ,KAAK,SAAQ,CACnB,IAAK,UACH,KAAK,KAAOgH,EACZ,KAAK,IAAMC,EACXjH,EAAK,EACL,MACF,IAAK,OACH,KAAK,SAAWkH,EAChBlH,EAAK,EACL,MACF,IAAK,SACH,KAAK,KAAOmH,EACZ,KAAK,IAAMC,EACXpH,EAAK,EACL,MACF,QACE,KAAK,MAAQqH,EACb,KAAK,IAAMC,EACX,MACN,CACE,KAAK,SAAW,EAChB,KAAK,UAAY,EACjB,KAAK,SAAWroB,EAAO,YAAY+gB,CAAE,CACvC,CAEA+G,EAAc,UAAU,MAAQ,SAAUpnB,EAAK,CAC7C,GAAIA,EAAI,SAAW,EAAG,MAAO,GAC7B,IAAI4nB,EACAruB,EACJ,GAAI,KAAK,SAAU,CAEjB,GADAquB,EAAI,KAAK,SAAS5nB,CAAG,EACjB4nB,IAAM,OAAW,MAAO,GAC5BruB,EAAI,KAAK,SACT,KAAK,SAAW,CACpB,MACIA,EAAI,EAEN,OAAIA,EAAIyG,EAAI,OAAe4nB,EAAIA,EAAI,KAAK,KAAK5nB,EAAKzG,CAAC,EAAI,KAAK,KAAKyG,EAAKzG,CAAC,EAChEquB,GAAK,EACb,EAEDR,EAAc,UAAU,IAAMS,EAG9BT,EAAc,UAAU,KAAOU,EAG/BV,EAAc,UAAU,SAAW,SAAUpnB,EAAK,CAChD,GAAI,KAAK,UAAYA,EAAI,OACvB,OAAAA,EAAI,KAAK,KAAK,SAAU,KAAK,UAAY,KAAK,SAAU,EAAG,KAAK,QAAQ,EACjE,KAAK,SAAS,SAAS,KAAK,SAAU,EAAG,KAAK,SAAS,EAEhEA,EAAI,KAAK,KAAK,SAAU,KAAK,UAAY,KAAK,SAAU,EAAGA,EAAI,MAAM,EACrE,KAAK,UAAYA,EAAI,MACtB,EAID,SAAS+nB,EAAcC,EAAM,CAC3B,OAAIA,GAAQ,IAAa,EAAWA,GAAQ,IAAM,EAAa,EAAWA,GAAQ,IAAM,GAAa,EAAWA,GAAQ,IAAM,GAAa,EACpIA,GAAQ,IAAM,EAAO,GAAK,EACnC,CAKA,SAASC,EAAoB1J,EAAMve,EAAKzG,EAAG,CACzC,IAAIkK,EAAIzD,EAAI,OAAS,EACrB,GAAIyD,EAAIlK,EAAG,MACX,OAAI8mB,EAAK0H,EAAc/nB,EAAIyD,CAAC,CAAC,EAC7B,OAAI4c,GAAM,GACJA,EAAK,IAAG9B,EAAK,SAAW8B,EAAK,GAC1BA,GAEL,EAAE5c,EAAIlK,GAAK8mB,IAAO,GAAW,GACjCA,EAAK0H,EAAc/nB,EAAIyD,CAAC,CAAC,EACrB4c,GAAM,GACJA,EAAK,IAAG9B,EAAK,SAAW8B,EAAK,GAC1BA,GAEL,EAAE5c,EAAIlK,GAAK8mB,IAAO,GAAW,GACjCA,EAAK0H,EAAc/nB,EAAIyD,CAAC,CAAC,EACrB4c,GAAM,GACJA,EAAK,IACHA,IAAO,EAAGA,EAAK,EAAO9B,EAAK,SAAW8B,EAAK,GAE1CA,GAEF,GACT,CAUA,SAAS6H,EAAoB3J,EAAMve,EAAKmgB,EAAG,CACzC,IAAKngB,EAAI,CAAC,EAAI,OAAU,IACtB,OAAAue,EAAK,SAAW,EACT,IAET,GAAIA,EAAK,SAAW,GAAKve,EAAI,OAAS,EAAG,CACvC,IAAKA,EAAI,CAAC,EAAI,OAAU,IACtB,OAAAue,EAAK,SAAW,EACT,IAET,GAAIA,EAAK,SAAW,GAAKve,EAAI,OAAS,IAC/BA,EAAI,CAAC,EAAI,OAAU,IACtB,OAAAue,EAAK,SAAW,EACT,GAGf,CACA,CAGA,SAASgJ,EAAavnB,EAAK,CACzB,IAAImgB,EAAI,KAAK,UAAY,KAAK,SAC1ByH,EAAIM,EAAoB,KAAMloB,CAAM,EACxC,GAAI4nB,IAAM,OAAW,OAAOA,EAC5B,GAAI,KAAK,UAAY5nB,EAAI,OACvB,OAAAA,EAAI,KAAK,KAAK,SAAUmgB,EAAG,EAAG,KAAK,QAAQ,EACpC,KAAK,SAAS,SAAS,KAAK,SAAU,EAAG,KAAK,SAAS,EAEhEngB,EAAI,KAAK,KAAK,SAAUmgB,EAAG,EAAGngB,EAAI,MAAM,EACxC,KAAK,UAAYA,EAAI,MACvB,CAKA,SAAS8nB,EAAS9nB,EAAKzG,EAAG,CACxB,IAAI4uB,EAAQF,EAAoB,KAAMjoB,EAAKzG,CAAC,EAC5C,GAAI,CAAC,KAAK,SAAU,OAAOyG,EAAI,SAAS,OAAQzG,CAAC,EACjD,KAAK,UAAY4uB,EACjB,IAAIpqB,EAAMiC,EAAI,QAAUmoB,EAAQ,KAAK,UACrC,OAAAnoB,EAAI,KAAK,KAAK,SAAU,EAAGjC,CAAG,EACvBiC,EAAI,SAAS,OAAQzG,EAAGwE,CAAG,CACpC,CAIA,SAAS8pB,EAAQ7nB,EAAK,CACpB,IAAI4nB,EAAI5nB,GAAOA,EAAI,OAAS,KAAK,MAAMA,CAAG,EAAI,GAC9C,OAAI,KAAK,SAAiB4nB,EAAI,IACvBA,CACT,CAMA,SAASP,EAAUrnB,EAAKzG,EAAG,CACzB,IAAKyG,EAAI,OAASzG,GAAK,IAAM,EAAG,CAC9B,IAAIquB,EAAI5nB,EAAI,SAAS,UAAWzG,CAAC,EACjC,GAAIquB,EAAG,CACL,IAAI,EAAIA,EAAE,WAAWA,EAAE,OAAS,CAAC,EACjC,GAAI,GAAK,OAAU,GAAK,MACtB,OAAK,cAAW,EAChB,KAAK,UAAY,EACjB,KAAK,SAAS,CAAC,EAAI5nB,EAAIA,EAAI,OAAS,CAAC,EACrC,KAAK,SAAS,CAAC,EAAIA,EAAIA,EAAI,OAAS,CAAC,EAC9B4nB,EAAE,MAAM,EAAG,EAAE,CAE5B,CACI,OAAOA,CACX,CACE,YAAK,SAAW,EAChB,KAAK,UAAY,EACjB,KAAK,SAAS,CAAC,EAAI5nB,EAAIA,EAAI,OAAS,CAAC,EAC9BA,EAAI,SAAS,UAAWzG,EAAGyG,EAAI,OAAS,CAAC,CAClD,CAIA,SAASsnB,EAAStnB,EAAK,CACrB,IAAI4nB,EAAI5nB,GAAOA,EAAI,OAAS,KAAK,MAAMA,CAAG,EAAI,GAC9C,GAAI,KAAK,SAAU,CACjB,IAAIjC,EAAM,KAAK,UAAY,KAAK,SAChC,OAAO6pB,EAAI,KAAK,SAAS,SAAS,UAAW,EAAG7pB,CAAG,CACvD,CACE,OAAO6pB,CACT,CAEA,SAASJ,EAAWxnB,EAAKzG,EAAG,CAC1B,IAAIJ,GAAK6G,EAAI,OAASzG,GAAK,EAC3B,OAAIJ,IAAM,EAAU6G,EAAI,SAAS,SAAUzG,CAAC,GAC5C,KAAK,SAAW,EAAIJ,EACpB,KAAK,UAAY,EACbA,IAAM,EACR,KAAK,SAAS,CAAC,EAAI6G,EAAIA,EAAI,OAAS,CAAC,GAErC,KAAK,SAAS,CAAC,EAAIA,EAAIA,EAAI,OAAS,CAAC,EACrC,KAAK,SAAS,CAAC,EAAIA,EAAIA,EAAI,OAAS,CAAC,GAEhCA,EAAI,SAAS,SAAUzG,EAAGyG,EAAI,OAAS7G,CAAC,EACjD,CAEA,SAASsuB,EAAUznB,EAAK,CACtB,IAAI4nB,EAAI5nB,GAAOA,EAAI,OAAS,KAAK,MAAMA,CAAG,EAAI,GAC9C,OAAI,KAAK,SAAiB4nB,EAAI,KAAK,SAAS,SAAS,SAAU,EAAG,EAAI,KAAK,QAAQ,EAC5EA,CACT,CAGA,SAASF,EAAY1nB,EAAK,CACxB,OAAOA,EAAI,SAAS,KAAK,QAAQ,CACnC,CAEA,SAAS2nB,EAAU3nB,EAAK,CACtB,OAAOA,GAAOA,EAAI,OAAS,KAAK,MAAMA,CAAG,EAAI,EAC/C,wDClSA,IAAIooB,EAA6B7rB,KAA2B,MAAM,2BAClE,SAASzD,EAAKuvB,EAAU,CACtB,IAAIC,EAAS,GACb,OAAO,UAAY,CACjB,GAAI,CAAAA,EACJ,CAAAA,EAAS,GACT,QAASC,EAAO,UAAU,OAAQjwB,EAAO,IAAI,MAAMiwB,CAAI,EAAGC,EAAO,EAAGA,EAAOD,EAAMC,IAC/ElwB,EAAKkwB,CAAI,EAAI,UAAUA,CAAI,EAE7BH,EAAS,MAAM,KAAM/vB,CAAI,EAC1B,CACH,CACA,SAASmwB,GAAO,EAChB,SAASC,EAAU1H,EAAQ,CACzB,OAAOA,EAAO,WAAa,OAAOA,EAAO,OAAU,UACrD,CACA,SAAS2H,EAAI3H,EAAQnG,EAAMwN,EAAU,CACnC,GAAI,OAAOxN,GAAS,WAAY,OAAO8N,EAAI3H,EAAQ,KAAMnG,CAAI,EACxDA,IAAMA,EAAO,CAAE,GACpBwN,EAAWvvB,EAAKuvB,GAAYI,CAAI,EAChC,IAAIG,EAAW/N,EAAK,UAAYA,EAAK,WAAa,IAASmG,EAAO,SAC9D6H,EAAWhO,EAAK,UAAYA,EAAK,WAAa,IAASmG,EAAO,SAC9D8H,EAAiB,UAA0B,CACxC9H,EAAO,UAAU+H,EAAU,CACjC,EACGC,EAAgBhI,EAAO,gBAAkBA,EAAO,eAAe,SAC/D+H,EAAW,UAAoB,CACjCF,EAAW,GACXG,EAAgB,GACXJ,GAAUP,EAAS,KAAKrH,CAAM,CACpC,EACGiI,EAAgBjI,EAAO,gBAAkBA,EAAO,eAAe,WAC/DyF,EAAQ,UAAiB,CAC3BmC,EAAW,GACXK,EAAgB,GACXJ,GAAUR,EAAS,KAAKrH,CAAM,CACpC,EACGkI,EAAU,SAAiBvvB,EAAK,CAClC0uB,EAAS,KAAKrH,EAAQrnB,CAAG,CAC1B,EACGwvB,EAAU,UAAmB,CAC/B,IAAIxvB,EACJ,GAAIivB,GAAY,CAACK,EACf,OAAI,CAACjI,EAAO,gBAAkB,CAACA,EAAO,eAAe,SAAOrnB,EAAM,IAAIyuB,GAC/DC,EAAS,KAAKrH,EAAQrnB,CAAG,EAElC,GAAIkvB,GAAY,CAACG,EACf,OAAI,CAAChI,EAAO,gBAAkB,CAACA,EAAO,eAAe,SAAOrnB,EAAM,IAAIyuB,GAC/DC,EAAS,KAAKrH,EAAQrnB,CAAG,CAEnC,EACGyvB,EAAY,UAAqB,CACnCpI,EAAO,IAAI,GAAG,SAAU+H,CAAQ,CACjC,EACD,OAAIL,EAAU1H,CAAM,GAClBA,EAAO,GAAG,WAAY+H,CAAQ,EAC9B/H,EAAO,GAAG,QAASmI,CAAO,EACtBnI,EAAO,IAAKoI,EAAW,EAAMpI,EAAO,GAAG,UAAWoI,CAAS,GACtDP,GAAY,CAAC7H,EAAO,iBAE7BA,EAAO,GAAG,MAAO8H,CAAc,EAC/B9H,EAAO,GAAG,QAAS8H,CAAc,GAEnC9H,EAAO,GAAG,MAAOyF,CAAK,EACtBzF,EAAO,GAAG,SAAU+H,CAAQ,EACxBlO,EAAK,QAAU,IAAOmG,EAAO,GAAG,QAASkI,CAAO,EACpDlI,EAAO,GAAG,QAASmI,CAAO,EACnB,UAAY,CACjBnI,EAAO,eAAe,WAAY+H,CAAQ,EAC1C/H,EAAO,eAAe,QAASmI,CAAO,EACtCnI,EAAO,eAAe,UAAWoI,CAAS,EACtCpI,EAAO,KAAKA,EAAO,IAAI,eAAe,SAAU+H,CAAQ,EAC5D/H,EAAO,eAAe,MAAO8H,CAAc,EAC3C9H,EAAO,eAAe,QAAS8H,CAAc,EAC7C9H,EAAO,eAAe,SAAU+H,CAAQ,EACxC/H,EAAO,eAAe,MAAOyF,CAAK,EAClCzF,EAAO,eAAe,QAASkI,CAAO,EACtClI,EAAO,eAAe,QAASmI,CAAO,CACvC,CACH,CACA,OAAAE,GAAiBV,kDCnFjB,IAAIW,EACJ,SAASxK,EAAgBvd,EAAKzG,EAAKnC,EAAO,CAAE,OAAAmC,EAAMikB,EAAejkB,CAAG,EAAOA,KAAOyG,EAAO,OAAO,eAAeA,EAAKzG,EAAK,CAAE,MAAOnC,EAAO,WAAY,GAAM,aAAc,GAAM,SAAU,EAAI,CAAE,EAAY4I,EAAIzG,CAAG,EAAInC,EAAgB4I,CAAI,CAC1O,SAASwd,EAAe7lB,EAAK,CAAE,IAAI4B,EAAM0kB,EAAatmB,EAAK,QAAQ,EAAG,OAAO,OAAO4B,GAAQ,SAAWA,EAAM,OAAOA,CAAG,CAAE,CACzH,SAAS0kB,EAAatY,EAAOuY,EAAM,CAAE,GAAI,OAAOvY,GAAU,UAAYA,IAAU,KAAM,OAAOA,EAAO,IAAIwY,EAAOxY,EAAM,OAAO,WAAW,EAAG,GAAIwY,IAAS,OAAW,CAAE,IAAIrb,EAAMqb,EAAK,KAAKxY,EAAOuY,CAAiB,EAAG,GAAI,OAAOpb,GAAQ,SAAU,OAAOA,EAAK,MAAM,IAAI,UAAU,8CAA8C,CAAI,CAAC,OAAQob,IAAS,SAAW,OAAS,QAAQvY,CAAK,CAAE,CACvX,IAAIwe,EAAWnpB,GAA0B,EACrCgtB,EAAe,OAAO,aAAa,EACnCC,EAAc,OAAO,YAAY,EACjCC,EAAS,OAAO,OAAO,EACvBC,EAAS,OAAO,OAAO,EACvBC,EAAe,OAAO,aAAa,EACnCC,EAAiB,OAAO,eAAe,EACvCC,EAAU,OAAO,QAAQ,EAC7B,SAASC,EAAiBnxB,EAAOoxB,EAAM,CACrC,MAAO,CACL,MAAOpxB,EACP,KAAMoxB,CACP,CACH,CACA,SAASC,EAAeC,EAAM,CAC5B,IAAIvuB,EAAUuuB,EAAKV,CAAY,EAC/B,GAAI7tB,IAAY,KAAM,CACpB,IAAIwuB,EAAOD,EAAKJ,CAAO,EAAE,KAAM,EAI3BK,IAAS,OACXD,EAAKN,CAAY,EAAI,KACrBM,EAAKV,CAAY,EAAI,KACrBU,EAAKT,CAAW,EAAI,KACpB9tB,EAAQouB,EAAiBI,EAAM,EAAK,CAAC,EAE3C,CACA,CACA,SAASC,EAAWF,EAAM,CAGxB7P,GAAQ,SAAS4P,EAAgBC,CAAI,CACvC,CACA,SAASG,EAAYC,EAAaJ,EAAM,CACtC,OAAO,SAAUvuB,EAASC,EAAQ,CAChC0uB,EAAY,KAAK,UAAY,CAC3B,GAAIJ,EAAKP,CAAM,EAAG,CAChBhuB,EAAQouB,EAAiB,OAAW,EAAI,CAAC,EACzC,MACR,CACMG,EAAKL,CAAc,EAAEluB,EAASC,CAAM,CACrC,EAAEA,CAAM,CACV,CACH,CACA,IAAI2uB,EAAyB,OAAO,eAAe,UAAY,EAAE,EAC7DC,EAAuC,OAAO,gBAAgBjB,EAAwB,CACxF,IAAI,QAAS,CACX,OAAO,KAAKO,CAAO,CACpB,EACD,KAAM,UAAgB,CACpB,IAAIrJ,EAAQ,KAGRgK,EAAQ,KAAKf,CAAM,EACvB,GAAIe,IAAU,KACZ,OAAO,QAAQ,OAAOA,CAAK,EAE7B,GAAI,KAAKd,CAAM,EACb,OAAO,QAAQ,QAAQI,EAAiB,OAAW,EAAI,CAAC,EAE1D,GAAI,KAAKD,CAAO,EAAE,UAKhB,OAAO,IAAI,QAAQ,SAAUnuB,EAASC,EAAQ,CAC5Cye,GAAQ,SAAS,UAAY,CACvBoG,EAAMiJ,CAAM,EACd9tB,EAAO6kB,EAAMiJ,CAAM,CAAC,EAEpB/tB,EAAQouB,EAAiB,OAAW,EAAI,CAAC,CAErD,CAAS,CACT,CAAO,EAOH,IAAIO,EAAc,KAAKV,CAAY,EAC/B5L,EACJ,GAAIsM,EACFtM,EAAU,IAAI,QAAQqM,EAAYC,EAAa,IAAI,CAAC,MAC/C,CAGL,IAAIH,EAAO,KAAKL,CAAO,EAAE,KAAM,EAC/B,GAAIK,IAAS,KACX,OAAO,QAAQ,QAAQJ,EAAiBI,EAAM,EAAK,CAAC,EAEtDnM,EAAU,IAAI,QAAQ,KAAK6L,CAAc,CAAC,CAChD,CACI,YAAKD,CAAY,EAAI5L,EACdA,CACX,CACC,EAAEe,EAAgBwK,EAAuB,OAAO,cAAe,UAAY,CAC1E,OAAO,IACR,GAAGxK,EAAgBwK,EAAuB,SAAU,UAAmB,CACtE,IAAImB,EAAS,KAIb,OAAO,IAAI,QAAQ,SAAU/uB,EAASC,EAAQ,CAC5C8uB,EAAOZ,CAAO,EAAE,QAAQ,KAAM,SAAUlwB,EAAK,CAC3C,GAAIA,EAAK,CACPgC,EAAOhC,CAAG,EACV,MACR,CACM+B,EAAQouB,EAAiB,OAAW,EAAI,CAAC,CAC/C,CAAK,CACL,CAAG,CACH,CAAC,EAAGR,GAAwBgB,CAAsB,EAC9CI,EAAoC,SAA2C1J,EAAQ,CACzF,IAAI2J,EACAjX,EAAW,OAAO,OAAO6W,GAAuCI,EAAiB,GAAI7L,EAAgB6L,EAAgBd,EAAS,CAChI,MAAO7I,EACP,SAAU,EACd,CAAG,EAAGlC,EAAgB6L,EAAgBpB,EAAc,CAChD,MAAO,KACP,SAAU,EACd,CAAG,EAAGzK,EAAgB6L,EAAgBnB,EAAa,CAC/C,MAAO,KACP,SAAU,EACd,CAAG,EAAG1K,EAAgB6L,EAAgBlB,EAAQ,CAC1C,MAAO,KACP,SAAU,EACd,CAAG,EAAG3K,EAAgB6L,EAAgBjB,EAAQ,CAC1C,MAAO1I,EAAO,eAAe,WAC7B,SAAU,EACd,CAAG,EAAGlC,EAAgB6L,EAAgBf,EAAgB,CAClD,MAAO,SAAeluB,EAASC,EAAQ,CACrC,IAAIuuB,EAAOxW,EAASmW,CAAO,EAAE,KAAM,EAC/BK,GACFxW,EAASiW,CAAY,EAAI,KACzBjW,EAAS6V,CAAY,EAAI,KACzB7V,EAAS8V,CAAW,EAAI,KACxB9tB,EAAQouB,EAAiBI,EAAM,EAAK,CAAC,IAErCxW,EAAS6V,CAAY,EAAI7tB,EACzBgY,EAAS8V,CAAW,EAAI7tB,EAE3B,EACD,SAAU,EACX,GAAGgvB,EAAgB,EACpB,OAAAjX,EAASiW,CAAY,EAAI,KACzBjE,EAAS1E,EAAQ,SAAUrnB,EAAK,CAC9B,GAAIA,GAAOA,EAAI,OAAS,6BAA8B,CACpD,IAAIgC,EAAS+X,EAAS8V,CAAW,EAG7B7tB,IAAW,OACb+X,EAASiW,CAAY,EAAI,KACzBjW,EAAS6V,CAAY,EAAI,KACzB7V,EAAS8V,CAAW,EAAI,KACxB7tB,EAAOhC,CAAG,GAEZ+Z,EAAS+V,CAAM,EAAI9vB,EACnB,MACN,CACI,IAAI+B,EAAUgY,EAAS6V,CAAY,EAC/B7tB,IAAY,OACdgY,EAASiW,CAAY,EAAI,KACzBjW,EAAS6V,CAAY,EAAI,KACzB7V,EAAS8V,CAAW,EAAI,KACxB9tB,EAAQouB,EAAiB,OAAW,EAAI,CAAC,GAE3CpW,EAASgW,CAAM,EAAI,EACvB,CAAG,EACD1I,EAAO,GAAG,WAAYmJ,EAAW,KAAK,KAAMzW,CAAQ,CAAC,EAC9CA,CACR,EACD,OAAAkX,GAAiBF,8CCnLjBG,GAAiB,UAAY,CAC3B,MAAM,IAAI,MAAM,+CAA+C,CAChE,mDCqBDC,GAAiBtE,EAGjB,IAAIlD,EAGJkD,EAAS,cAAgBuE,EAGhBxuB,KAAkB,aAC3B,IAAIyuB,EAAkB,SAAyB7vB,EAAS7B,EAAM,CAC5D,OAAO6B,EAAQ,UAAU7B,CAAI,EAAE,MAChC,EAIGmqB,EAASlY,GAAoC,EAG7CjM,EAASmM,GAAiB,EAAC,OAC3BiY,GAAiB,OAAOrP,GAAW,IAAcA,GAAS,OAAO,OAAW,IAAc,OAAS,OAAO,KAAS,IAAc,KAAO,CAAE,GAAE,YAAc,UAAY,CAAE,EAC5K,SAASsP,EAAoBC,EAAO,CAClC,OAAOtkB,EAAO,KAAKskB,CAAK,CAC1B,CACA,SAASC,EAActiB,EAAK,CAC1B,OAAOjC,EAAO,SAASiC,CAAG,GAAKA,aAAemiB,CAChD,CAGA,IAAIuH,EAAYtf,GAAe,EAC3Buf,EACAD,GAAaA,EAAU,SACzBC,EAAQD,EAAU,SAAS,QAAQ,EAEnCC,EAAQ,UAAiB,CAAE,EAI7B,IAAIlL,EAAa9S,GAAyC,EACtD4W,EAAc1W,GAAqC,EACnDuS,EAAWtS,GAAmC,EAChDwV,EAAmBlD,EAAS,iBAC1BoE,EAAiBxW,GAAoB,EAAC,MACxCyW,EAAuBD,EAAe,qBACtCoH,EAA4BpH,EAAe,0BAC3CE,EAA6BF,EAAe,2BAC5CqH,EAAqCrH,EAAe,mCAGlDqD,EACAsD,EACAvqB,EACJqN,GAAmB,EAACgZ,EAAU/C,CAAM,EACpC,IAAI1C,EAAiB+C,EAAY,eAC7BuH,EAAe,CAAC,QAAS,QAAS,UAAW,QAAS,QAAQ,EAClE,SAASC,EAAgBnwB,EAASowB,EAAOtjB,EAAI,CAG3C,GAAI,OAAO9M,EAAQ,iBAAoB,WAAY,OAAOA,EAAQ,gBAAgBowB,EAAOtjB,CAAE,EAMvF,CAAC9M,EAAQ,SAAW,CAACA,EAAQ,QAAQowB,CAAK,EAAGpwB,EAAQ,GAAGowB,EAAOtjB,CAAE,EAAW,MAAM,QAAQ9M,EAAQ,QAAQowB,CAAK,CAAC,EAAGpwB,EAAQ,QAAQowB,CAAK,EAAE,QAAQtjB,CAAE,EAAO9M,EAAQ,QAAQowB,CAAK,EAAI,CAACtjB,EAAI9M,EAAQ,QAAQowB,CAAK,CAAC,CACrN,CACA,SAASR,EAAczK,EAASU,EAAQ2B,EAAU,CAChDW,EAASA,GAAU7V,GAA2B,EAC9C6S,EAAUA,GAAW,CAAE,EAOnB,OAAOqC,GAAa,YAAWA,EAAW3B,aAAkBsC,GAIhE,KAAK,WAAa,CAAC,CAAChD,EAAQ,WACxBqC,IAAU,KAAK,WAAa,KAAK,YAAc,CAAC,CAACrC,EAAQ,oBAI7D,KAAK,cAAgBuC,EAAiB,KAAMvC,EAAS,wBAAyBqC,CAAQ,EAKtF,KAAK,OAAS,IAAI3C,EAClB,KAAK,OAAS,EACd,KAAK,MAAQ,KACb,KAAK,WAAa,EAClB,KAAK,QAAU,KACf,KAAK,MAAQ,GACb,KAAK,WAAa,GAClB,KAAK,QAAU,GAMf,KAAK,KAAO,GAIZ,KAAK,aAAe,GACpB,KAAK,gBAAkB,GACvB,KAAK,kBAAoB,GACzB,KAAK,gBAAkB,GACvB,KAAK,OAAS,GAGd,KAAK,UAAYM,EAAQ,YAAc,GAGvC,KAAK,YAAc,CAAC,CAACA,EAAQ,YAG7B,KAAK,UAAY,GAKjB,KAAK,gBAAkBA,EAAQ,iBAAmB,OAGlD,KAAK,WAAa,EAGlB,KAAK,YAAc,GACnB,KAAK,QAAU,KACf,KAAK,SAAW,KACZA,EAAQ,WACL8G,IAAeA,EAAgB1Z,GAA0B,EAAC,eAC/D,KAAK,QAAU,IAAI0Z,EAAc9G,EAAQ,QAAQ,EACjD,KAAK,SAAWA,EAAQ,SAE5B,CACA,SAASkG,EAASlG,EAAS,CAEzB,GADAgD,EAASA,GAAU7V,GAA2B,EAC1C,EAAE,gBAAgB+Y,GAAW,OAAO,IAAIA,EAASlG,CAAO,EAI5D,IAAIqC,EAAW,gBAAgBW,EAC/B,KAAK,eAAiB,IAAIyH,EAAczK,EAAS,KAAMqC,CAAQ,EAG/D,KAAK,SAAW,GACZrC,IACE,OAAOA,EAAQ,MAAS,aAAY,KAAK,MAAQA,EAAQ,MACzD,OAAOA,EAAQ,SAAY,aAAY,KAAK,SAAWA,EAAQ,UAErEmD,EAAO,KAAK,IAAI,CAClB,CACA,OAAO,eAAe+C,EAAS,UAAW,YAAa,CAIrD,WAAY,GACZ,IAAK,UAAe,CAClB,OAAI,KAAK,iBAAmB,OACnB,GAEF,KAAK,eAAe,SAC5B,EACD,IAAK,SAAa7tB,EAAO,CAGlB,KAAK,iBAMV,KAAK,eAAe,UAAYA,EACpC,CACA,CAAC,EACD6tB,EAAS,UAAU,QAAU1C,EAAY,QACzC0C,EAAS,UAAU,WAAa1C,EAAY,UAC5C0C,EAAS,UAAU,SAAW,SAAU7sB,EAAKukB,EAAI,CAC/CA,EAAGvkB,CAAG,CACP,EAMD6sB,EAAS,UAAU,KAAO,SAAU5C,EAAO7iB,EAAU,CACnD,IAAIxG,EAAQ,KAAK,eACbixB,EACJ,OAAKjxB,EAAM,WAUTixB,EAAiB,GATb,OAAO5H,GAAU,WACnB7iB,EAAWA,GAAYxG,EAAM,gBACzBwG,IAAaxG,EAAM,WACrBqpB,EAAQtkB,EAAO,KAAKskB,EAAO7iB,CAAQ,EACnCA,EAAW,IAEbyqB,EAAiB,IAKdC,EAAiB,KAAM7H,EAAO7iB,EAAU,GAAOyqB,CAAc,CACrE,EAGDhF,EAAS,UAAU,QAAU,SAAU5C,EAAO,CAC5C,OAAO6H,EAAiB,KAAM7H,EAAO,KAAM,GAAM,EAAK,CACvD,EACD,SAAS6H,EAAiBzK,EAAQ4C,EAAO7iB,EAAU2qB,EAAYF,EAAgB,CAC7EN,EAAM,mBAAoBtH,CAAK,EAC/B,IAAIrpB,EAAQymB,EAAO,eACnB,GAAI4C,IAAU,KACZrpB,EAAM,QAAU,GAChBoxB,GAAW3K,EAAQzmB,CAAK,MACnB,CACL,IAAIb,EAEJ,GADK8xB,IAAgB9xB,EAAKkyB,EAAarxB,EAAOqpB,CAAK,GAC/ClqB,EACFqnB,EAAeC,EAAQtnB,CAAE,UAChBa,EAAM,YAAcqpB,GAASA,EAAM,OAAS,EAIrD,GAHI,OAAOA,GAAU,UAAY,CAACrpB,EAAM,YAAc,OAAO,eAAeqpB,CAAK,IAAMtkB,EAAO,YAC5FskB,EAAQD,EAAoBC,CAAK,GAE/B8H,EACEnxB,EAAM,WAAYwmB,EAAeC,EAAQ,IAAIoK,CAAoC,EAAOS,EAAS7K,EAAQzmB,EAAOqpB,EAAO,EAAI,UACtHrpB,EAAM,MACfwmB,EAAeC,EAAQ,IAAImK,CAA2B,MACjD,IAAI5wB,EAAM,UACf,MAAO,GAEPA,EAAM,QAAU,GACZA,EAAM,SAAW,CAACwG,GACpB6iB,EAAQrpB,EAAM,QAAQ,MAAMqpB,CAAK,EAC7BrpB,EAAM,YAAcqpB,EAAM,SAAW,EAAGiI,EAAS7K,EAAQzmB,EAAOqpB,EAAO,EAAK,EAAOkI,GAAc9K,EAAQzmB,CAAK,GAElHsxB,EAAS7K,EAAQzmB,EAAOqpB,EAAO,EAAK,CAG9B8H,UACVnxB,EAAM,QAAU,GAChBuxB,GAAc9K,EAAQzmB,CAAK,EAEjC,CAKE,MAAO,CAACA,EAAM,QAAUA,EAAM,OAASA,EAAM,eAAiBA,EAAM,SAAW,EACjF,CACA,SAASsxB,EAAS7K,EAAQzmB,EAAOqpB,EAAO8H,EAAY,CAC9CnxB,EAAM,SAAWA,EAAM,SAAW,GAAK,CAACA,EAAM,MAChDA,EAAM,WAAa,EACnBymB,EAAO,KAAK,OAAQ4C,CAAK,IAGzBrpB,EAAM,QAAUA,EAAM,WAAa,EAAIqpB,EAAM,OACzC8H,EAAYnxB,EAAM,OAAO,QAAQqpB,CAAK,EAAOrpB,EAAM,OAAO,KAAKqpB,CAAK,EACpErpB,EAAM,cAAcwxB,EAAa/K,CAAM,GAE7C8K,GAAc9K,EAAQzmB,CAAK,CAC7B,CACA,SAASqxB,EAAarxB,EAAOqpB,EAAO,CAClC,IAAIlqB,EACJ,MAAI,CAACmqB,EAAcD,CAAK,GAAK,OAAOA,GAAU,UAAYA,IAAU,QAAa,CAACrpB,EAAM,aACtFb,EAAK,IAAIsqB,EAAqB,QAAS,CAAC,SAAU,SAAU,YAAY,EAAGJ,CAAK,GAE3ElqB,CACT,CACA8sB,EAAS,UAAU,SAAW,UAAY,CACxC,OAAO,KAAK,eAAe,UAAY,EACxC,EAGDA,EAAS,UAAU,YAAc,SAAUO,EAAK,CACzCK,IAAeA,EAAgB1Z,GAA0B,EAAC,eAC/D,IAAIse,EAAU,IAAI5E,EAAcL,CAAG,EACnC,KAAK,eAAe,QAAUiF,EAE9B,KAAK,eAAe,SAAW,KAAK,eAAe,QAAQ,SAK3D,QAFI7L,EAAI,KAAK,eAAe,OAAO,KAC/B8L,EAAU,GACP9L,IAAM,MACX8L,GAAWD,EAAQ,MAAM7L,EAAE,IAAI,EAC/BA,EAAIA,EAAE,KAER,YAAK,eAAe,OAAO,MAAO,EAC9B8L,IAAY,IAAI,KAAK,eAAe,OAAO,KAAKA,CAAO,EAC3D,KAAK,eAAe,OAASA,EAAQ,OAC9B,IACR,EAGD,IAAIC,EAAU,WACd,SAASC,GAAwBhzB,EAAG,CAClC,OAAIA,GAAK+yB,EAEP/yB,EAAI+yB,GAIJ/yB,IACAA,GAAKA,IAAM,EACXA,GAAKA,IAAM,EACXA,GAAKA,IAAM,EACXA,GAAKA,IAAM,EACXA,GAAKA,IAAM,GACXA,KAEKA,CACT,CAIA,SAASizB,GAAcjzB,EAAGoB,EAAO,CAC/B,OAAIpB,GAAK,GAAKoB,EAAM,SAAW,GAAKA,EAAM,MAAc,EACpDA,EAAM,WAAmB,EACzBpB,IAAMA,EAEJoB,EAAM,SAAWA,EAAM,OAAeA,EAAM,OAAO,KAAK,KAAK,OAAmBA,EAAM,QAGxFpB,EAAIoB,EAAM,gBAAeA,EAAM,cAAgB4xB,GAAwBhzB,CAAC,GACxEA,GAAKoB,EAAM,OAAepB,EAEzBoB,EAAM,MAIJA,EAAM,QAHXA,EAAM,aAAe,GACd,GAGX,CAGAisB,EAAS,UAAU,KAAO,SAAUrtB,EAAG,CACrC+xB,EAAM,OAAQ/xB,CAAC,EACfA,EAAI,SAASA,EAAG,EAAE,EAClB,IAAIoB,EAAQ,KAAK,eACb8xB,EAAQlzB,EAMZ,GALIA,IAAM,IAAGoB,EAAM,gBAAkB,IAKjCpB,IAAM,GAAKoB,EAAM,gBAAkBA,EAAM,gBAAkB,EAAIA,EAAM,QAAUA,EAAM,cAAgBA,EAAM,OAAS,IAAMA,EAAM,OAClI,OAAA2wB,EAAM,qBAAsB3wB,EAAM,OAAQA,EAAM,KAAK,EACjDA,EAAM,SAAW,GAAKA,EAAM,MAAO+xB,EAAY,IAAI,EAAOP,EAAa,IAAI,EACxE,KAKT,GAHA5yB,EAAIizB,GAAcjzB,EAAGoB,CAAK,EAGtBpB,IAAM,GAAKoB,EAAM,MACnB,OAAIA,EAAM,SAAW,GAAG+xB,EAAY,IAAI,EACjC,KA0BT,IAAIC,EAAShyB,EAAM,aACnB2wB,EAAM,gBAAiBqB,CAAM,GAGzBhyB,EAAM,SAAW,GAAKA,EAAM,OAASpB,EAAIoB,EAAM,iBACjDgyB,EAAS,GACTrB,EAAM,6BAA8BqB,CAAM,GAKxChyB,EAAM,OAASA,EAAM,SACvBgyB,EAAS,GACTrB,EAAM,mBAAoBqB,CAAM,GACvBA,IACTrB,EAAM,SAAS,EACf3wB,EAAM,QAAU,GAChBA,EAAM,KAAO,GAETA,EAAM,SAAW,IAAGA,EAAM,aAAe,IAE7C,KAAK,MAAMA,EAAM,aAAa,EAC9BA,EAAM,KAAO,GAGRA,EAAM,UAASpB,EAAIizB,GAAcC,EAAO9xB,CAAK,IAEpD,IAAIiB,EACJ,OAAIrC,EAAI,EAAGqC,EAAMgxB,EAASrzB,EAAGoB,CAAK,EAAOiB,EAAM,KAC3CA,IAAQ,MACVjB,EAAM,aAAeA,EAAM,QAAUA,EAAM,cAC3CpB,EAAI,IAEJoB,EAAM,QAAUpB,EAChBoB,EAAM,WAAa,GAEjBA,EAAM,SAAW,IAGdA,EAAM,QAAOA,EAAM,aAAe,IAGnC8xB,IAAUlzB,GAAKoB,EAAM,OAAO+xB,EAAY,IAAI,GAE9C9wB,IAAQ,MAAM,KAAK,KAAK,OAAQA,CAAG,EAChCA,CACR,EACD,SAASmwB,GAAW3K,EAAQzmB,EAAO,CAEjC,GADA2wB,EAAM,YAAY,EACd,CAAA3wB,EAAM,MACV,IAAIA,EAAM,QAAS,CACjB,IAAIqpB,EAAQrpB,EAAM,QAAQ,IAAK,EAC3BqpB,GAASA,EAAM,SACjBrpB,EAAM,OAAO,KAAKqpB,CAAK,EACvBrpB,EAAM,QAAUA,EAAM,WAAa,EAAIqpB,EAAM,OAEnD,CACErpB,EAAM,MAAQ,GACVA,EAAM,KAIRwxB,EAAa/K,CAAM,GAGnBzmB,EAAM,aAAe,GAChBA,EAAM,kBACTA,EAAM,gBAAkB,GACxBkyB,GAAczL,CAAM,GAG1B,EAKA,SAAS+K,EAAa/K,EAAQ,CAC5B,IAAIzmB,EAAQymB,EAAO,eACnBkK,EAAM,eAAgB3wB,EAAM,aAAcA,EAAM,eAAe,EAC/DA,EAAM,aAAe,GAChBA,EAAM,kBACT2wB,EAAM,eAAgB3wB,EAAM,OAAO,EACnCA,EAAM,gBAAkB,GACxB6f,GAAQ,SAASqS,GAAezL,CAAM,EAE1C,CACA,SAASyL,GAAczL,EAAQ,CAC7B,IAAIzmB,EAAQymB,EAAO,eACnBkK,EAAM,gBAAiB3wB,EAAM,UAAWA,EAAM,OAAQA,EAAM,KAAK,EAC7D,CAACA,EAAM,YAAcA,EAAM,QAAUA,EAAM,SAC7CymB,EAAO,KAAK,UAAU,EACtBzmB,EAAM,gBAAkB,IAS1BA,EAAM,aAAe,CAACA,EAAM,SAAW,CAACA,EAAM,OAASA,EAAM,QAAUA,EAAM,cAC7EmyB,EAAK1L,CAAM,CACb,CAQA,SAAS8K,GAAc9K,EAAQzmB,EAAO,CAC/BA,EAAM,cACTA,EAAM,YAAc,GACpB6f,GAAQ,SAASuS,GAAgB3L,EAAQzmB,CAAK,EAElD,CACA,SAASoyB,GAAe3L,EAAQzmB,EAAO,CAwBrC,KAAO,CAACA,EAAM,SAAW,CAACA,EAAM,QAAUA,EAAM,OAASA,EAAM,eAAiBA,EAAM,SAAWA,EAAM,SAAW,IAAI,CACpH,IAAIV,EAAMU,EAAM,OAGhB,GAFA2wB,EAAM,sBAAsB,EAC5BlK,EAAO,KAAK,CAAC,EACTnnB,IAAQU,EAAM,OAEhB,KACN,CACEA,EAAM,YAAc,EACtB,CAMAisB,EAAS,UAAU,MAAQ,SAAUrtB,EAAG,CACtC4nB,EAAe,KAAM,IAAIkD,EAA2B,SAAS,CAAC,CAC/D,EACDuC,EAAS,UAAU,KAAO,SAAUoG,EAAMC,EAAU,CAClD,IAAIjlB,EAAM,KACNrN,EAAQ,KAAK,eACjB,OAAQA,EAAM,WAAU,CACtB,IAAK,GACHA,EAAM,MAAQqyB,EACd,MACF,OACEryB,EAAM,MAAQ,CAACA,EAAM,MAAOqyB,CAAI,EAChC,MACF,QACEryB,EAAM,MAAM,KAAKqyB,CAAI,EACrB,KACN,CACEryB,EAAM,YAAc,EACpB2wB,EAAM,wBAAyB3wB,EAAM,WAAYsyB,CAAQ,EACzD,IAAIC,GAAS,CAACD,GAAYA,EAAS,MAAQ,KAAUD,IAASxS,GAAQ,QAAUwS,IAASxS,GAAQ,OAC7F2S,EAAQD,EAAQrG,GAAQuG,GACxBzyB,EAAM,WAAY6f,GAAQ,SAAS2S,CAAK,EAAOnlB,EAAI,KAAK,MAAOmlB,CAAK,EACxEH,EAAK,GAAG,SAAUK,CAAQ,EAC1B,SAASA,EAASrE,GAAUsE,GAAY,CACtChC,EAAM,UAAU,EACZtC,KAAahhB,GACXslB,IAAcA,GAAW,aAAe,KAC1CA,GAAW,WAAa,GACxBC,GAAS,EAGjB,CACE,SAAS1G,IAAQ,CACfyE,EAAM,OAAO,EACb0B,EAAK,IAAK,CACd,CAME,IAAIQ,EAAUC,GAAYzlB,CAAG,EAC7BglB,EAAK,GAAG,QAASQ,CAAO,EACxB,IAAIE,GAAY,GAChB,SAASH,IAAU,CACjBjC,EAAM,SAAS,EAEf0B,EAAK,eAAe,QAASzD,EAAO,EACpCyD,EAAK,eAAe,SAAU7D,EAAQ,EACtC6D,EAAK,eAAe,QAASQ,CAAO,EACpCR,EAAK,eAAe,QAAS1D,EAAO,EACpC0D,EAAK,eAAe,SAAUK,CAAQ,EACtCrlB,EAAI,eAAe,MAAO6e,EAAK,EAC/B7e,EAAI,eAAe,MAAOolB,EAAM,EAChCplB,EAAI,eAAe,OAAQ2lB,EAAM,EACjCD,GAAY,GAOR/yB,EAAM,aAAe,CAACqyB,EAAK,gBAAkBA,EAAK,eAAe,YAAYQ,EAAS,CAC9F,CACExlB,EAAI,GAAG,OAAQ2lB,EAAM,EACrB,SAASA,GAAO3J,GAAO,CACrBsH,EAAM,QAAQ,EACd,IAAI1vB,GAAMoxB,EAAK,MAAMhJ,EAAK,EAC1BsH,EAAM,aAAc1vB,EAAG,EACnBA,KAAQ,MAKLjB,EAAM,aAAe,GAAKA,EAAM,QAAUqyB,GAAQryB,EAAM,WAAa,GAAKizB,EAAQjzB,EAAM,MAAOqyB,CAAI,IAAM,KAAO,CAACU,KACpHpC,EAAM,8BAA+B3wB,EAAM,UAAU,EACrDA,EAAM,cAERqN,EAAI,MAAO,EAEjB,CAIE,SAASshB,GAAQxvB,GAAI,CACnBwxB,EAAM,UAAWxxB,EAAE,EACnBszB,GAAQ,EACRJ,EAAK,eAAe,QAAS1D,EAAO,EAChC8B,EAAgB4B,EAAM,OAAO,IAAM,GAAG7L,EAAe6L,EAAMlzB,EAAE,CACrE,CAGE4xB,EAAgBsB,EAAM,QAAS1D,EAAO,EAGtC,SAASC,IAAU,CACjByD,EAAK,eAAe,SAAU7D,EAAQ,EACtCiE,GAAQ,CACZ,CACEJ,EAAK,KAAK,QAASzD,EAAO,EAC1B,SAASJ,IAAW,CAClBmC,EAAM,UAAU,EAChB0B,EAAK,eAAe,QAASzD,EAAO,EACpC6D,GAAQ,CACZ,CACEJ,EAAK,KAAK,SAAU7D,EAAQ,EAC5B,SAASiE,IAAS,CAChB9B,EAAM,QAAQ,EACdtjB,EAAI,OAAOglB,CAAI,CACnB,CAGE,OAAAA,EAAK,KAAK,OAAQhlB,CAAG,EAGhBrN,EAAM,UACT2wB,EAAM,aAAa,EACnBtjB,EAAI,OAAQ,GAEPglB,CACR,EACD,SAASS,GAAYzlB,EAAK,CACxB,OAAO,UAAqC,CAC1C,IAAIrN,EAAQqN,EAAI,eAChBsjB,EAAM,cAAe3wB,EAAM,UAAU,EACjCA,EAAM,YAAYA,EAAM,aACxBA,EAAM,aAAe,GAAKywB,EAAgBpjB,EAAK,MAAM,IACvDrN,EAAM,QAAU,GAChBmyB,EAAK9kB,CAAG,EAEX,CACH,CACA4e,EAAS,UAAU,OAAS,SAAUoG,EAAM,CAC1C,IAAIryB,EAAQ,KAAK,eACb2yB,EAAa,CACf,WAAY,EACb,EAGD,GAAI3yB,EAAM,aAAe,EAAG,OAAO,KAGnC,GAAIA,EAAM,aAAe,EAEvB,OAAIqyB,GAAQA,IAASryB,EAAM,MAAc,MACpCqyB,IAAMA,EAAOryB,EAAM,OAGxBA,EAAM,MAAQ,KACdA,EAAM,WAAa,EACnBA,EAAM,QAAU,GACZqyB,GAAMA,EAAK,KAAK,SAAU,KAAMM,CAAU,EACvC,MAKT,GAAI,CAACN,EAAM,CAET,IAAIa,EAAQlzB,EAAM,MACdV,EAAMU,EAAM,WAChBA,EAAM,MAAQ,KACdA,EAAM,WAAa,EACnBA,EAAM,QAAU,GAChB,QAAShB,EAAI,EAAGA,EAAIM,EAAKN,IAAKk0B,EAAMl0B,CAAC,EAAE,KAAK,SAAU,KAAM,CAC1D,WAAY,EAClB,CAAK,EACD,OAAO,IACX,CAGE,IAAIgC,EAAQiyB,EAAQjzB,EAAM,MAAOqyB,CAAI,EACrC,OAAIrxB,IAAU,GAAW,MACzBhB,EAAM,MAAM,OAAOgB,EAAO,CAAC,EAC3BhB,EAAM,YAAc,EAChBA,EAAM,aAAe,IAAGA,EAAM,MAAQA,EAAM,MAAM,CAAC,GACvDqyB,EAAK,KAAK,SAAU,KAAMM,CAAU,EAC7B,KACR,EAID1G,EAAS,UAAU,GAAK,SAAUkH,EAAIzlB,EAAI,CACxC,IAAI5D,EAAMof,EAAO,UAAU,GAAG,KAAK,KAAMiK,EAAIzlB,CAAE,EAC3C1N,EAAQ,KAAK,eACjB,OAAImzB,IAAO,QAGTnzB,EAAM,kBAAoB,KAAK,cAAc,UAAU,EAAI,EAGvDA,EAAM,UAAY,IAAO,KAAK,OAAQ,GACjCmzB,IAAO,YACZ,CAACnzB,EAAM,YAAc,CAACA,EAAM,oBAC9BA,EAAM,kBAAoBA,EAAM,aAAe,GAC/CA,EAAM,QAAU,GAChBA,EAAM,gBAAkB,GACxB2wB,EAAM,cAAe3wB,EAAM,OAAQA,EAAM,OAAO,EAC5CA,EAAM,OACRwxB,EAAa,IAAI,EACPxxB,EAAM,SAChB6f,GAAQ,SAASuT,EAAkB,IAAI,GAItCtpB,CACR,EACDmiB,EAAS,UAAU,YAAcA,EAAS,UAAU,GACpDA,EAAS,UAAU,eAAiB,SAAUkH,EAAIzlB,EAAI,CACpD,IAAI5D,EAAMof,EAAO,UAAU,eAAe,KAAK,KAAMiK,EAAIzlB,CAAE,EAC3D,OAAIylB,IAAO,YAOTtT,GAAQ,SAASwT,GAAyB,IAAI,EAEzCvpB,CACR,EACDmiB,EAAS,UAAU,mBAAqB,SAAUkH,EAAI,CACpD,IAAIrpB,EAAMof,EAAO,UAAU,mBAAmB,MAAM,KAAM,SAAS,EACnE,OAAIiK,IAAO,YAAcA,IAAO,SAO9BtT,GAAQ,SAASwT,GAAyB,IAAI,EAEzCvpB,CACR,EACD,SAASupB,GAAwBrP,EAAM,CACrC,IAAIhkB,EAAQgkB,EAAK,eACjBhkB,EAAM,kBAAoBgkB,EAAK,cAAc,UAAU,EAAI,EACvDhkB,EAAM,iBAAmB,CAACA,EAAM,OAGlCA,EAAM,QAAU,GAGPgkB,EAAK,cAAc,MAAM,EAAI,GACtCA,EAAK,OAAQ,CAEjB,CACA,SAASoP,EAAiBpP,EAAM,CAC9B2M,EAAM,0BAA0B,EAChC3M,EAAK,KAAK,CAAC,CACb,CAIAiI,EAAS,UAAU,OAAS,UAAY,CACtC,IAAIjsB,EAAQ,KAAK,eACjB,OAAKA,EAAM,UACT2wB,EAAM,QAAQ,EAId3wB,EAAM,QAAU,CAACA,EAAM,kBACvBszB,EAAO,KAAMtzB,CAAK,GAEpBA,EAAM,OAAS,GACR,IACR,EACD,SAASszB,EAAO7M,EAAQzmB,EAAO,CACxBA,EAAM,kBACTA,EAAM,gBAAkB,GACxB6f,GAAQ,SAAS0T,EAAS9M,EAAQzmB,CAAK,EAE3C,CACA,SAASuzB,EAAQ9M,EAAQzmB,EAAO,CAC9B2wB,EAAM,SAAU3wB,EAAM,OAAO,EACxBA,EAAM,SACTymB,EAAO,KAAK,CAAC,EAEfzmB,EAAM,gBAAkB,GACxBymB,EAAO,KAAK,QAAQ,EACpB0L,EAAK1L,CAAM,EACPzmB,EAAM,SAAW,CAACA,EAAM,SAASymB,EAAO,KAAK,CAAC,CACpD,CACAwF,EAAS,UAAU,MAAQ,UAAY,CACrC,OAAA0E,EAAM,wBAAyB,KAAK,eAAe,OAAO,EACtD,KAAK,eAAe,UAAY,KAClCA,EAAM,OAAO,EACb,KAAK,eAAe,QAAU,GAC9B,KAAK,KAAK,OAAO,GAEnB,KAAK,eAAe,OAAS,GACtB,IACR,EACD,SAASwB,EAAK1L,EAAQ,CACpB,IAAIzmB,EAAQymB,EAAO,eAEnB,IADAkK,EAAM,OAAQ3wB,EAAM,OAAO,EACpBA,EAAM,SAAWymB,EAAO,KAAI,IAAO,MAAK,CACjD,CAKAwF,EAAS,UAAU,KAAO,SAAUxF,EAAQ,CAC1C,IAAIR,EAAQ,KACRjmB,EAAQ,KAAK,eACbwzB,EAAS,GACb/M,EAAO,GAAG,MAAO,UAAY,CAE3B,GADAkK,EAAM,aAAa,EACf3wB,EAAM,SAAW,CAACA,EAAM,MAAO,CACjC,IAAIqpB,EAAQrpB,EAAM,QAAQ,IAAK,EAC3BqpB,GAASA,EAAM,QAAQpD,EAAM,KAAKoD,CAAK,CACjD,CACIpD,EAAM,KAAK,IAAI,CACnB,CAAG,EACDQ,EAAO,GAAG,OAAQ,SAAU4C,EAAO,CAKjC,GAJAsH,EAAM,cAAc,EAChB3wB,EAAM,UAASqpB,EAAQrpB,EAAM,QAAQ,MAAMqpB,CAAK,GAGhD,EAAArpB,EAAM,YAAeqpB,GAAU,OAA8C,EAACrpB,GAAM,aAAe,CAACqpB,GAAS,CAACA,EAAM,SACxH,CAAIpoB,OAAMglB,EAAM,KAAKoD,CAAK,EACrBpoB,KACHuyB,EAAS,GACT/M,EAAO,MAAO,EAEpB,EAAG,EAID,QAASznB,KAAKynB,EACR,KAAKznB,CAAC,IAAM,QAAa,OAAOynB,EAAOznB,CAAC,GAAM,aAChD,KAAKA,CAAC,GAAI,SAAoBmgB,EAAQ,CACpC,OAAO,UAAoC,CACzC,OAAOsH,EAAOtH,CAAM,EAAE,MAAMsH,EAAQ,SAAS,CAC9C,CACF,GAACznB,CAAC,GAKP,QAASJ,EAAI,EAAGA,EAAIkyB,EAAa,OAAQlyB,IACvC6nB,EAAO,GAAGqK,EAAalyB,CAAC,EAAG,KAAK,KAAK,KAAK,KAAMkyB,EAAalyB,CAAC,CAAC,CAAC,EAKlE,OAAK,WAAQ,SAAUA,EAAG,CACxB+xB,EAAM,gBAAiB/xB,CAAC,EACpB40B,IACFA,EAAS,GACT/M,EAAO,OAAQ,EAElB,EACM,IACR,EACG,OAAO,QAAW,aACpBwF,EAAS,UAAU,OAAO,aAAa,EAAI,UAAY,CACrD,OAAIkE,IAAsC,SACxCA,EAAoC/c,GAA4C,GAE3E+c,EAAkC,IAAI,CAC9C,GAEH,OAAO,eAAelE,EAAS,UAAW,wBAAyB,CAIjE,WAAY,GACZ,IAAK,UAAe,CAClB,OAAO,KAAK,eAAe,aAC/B,CACA,CAAC,EACD,OAAO,eAAeA,EAAS,UAAW,iBAAkB,CAI1D,WAAY,GACZ,IAAK,UAAe,CAClB,OAAO,KAAK,gBAAkB,KAAK,eAAe,MACtD,CACA,CAAC,EACD,OAAO,eAAeA,EAAS,UAAW,kBAAmB,CAI3D,WAAY,GACZ,IAAK,UAAe,CAClB,OAAO,KAAK,eAAe,OAC5B,EACD,IAAK,SAAajsB,EAAO,CACnB,KAAK,iBACP,KAAK,eAAe,QAAUA,EAEpC,CACA,CAAC,EAGDisB,EAAS,UAAYgG,EACrB,OAAO,eAAehG,EAAS,UAAW,iBAAkB,CAI1D,WAAY,GACZ,IAAK,UAAe,CAClB,OAAO,KAAK,eAAe,MAC/B,CACA,CAAC,EAMD,SAASgG,EAASrzB,EAAGoB,EAAO,CAE1B,GAAIA,EAAM,SAAW,EAAG,OAAO,KAC/B,IAAIiB,EACJ,OAAIjB,EAAM,WAAYiB,EAAMjB,EAAM,OAAO,QAAiB,CAACpB,GAAKA,GAAKoB,EAAM,QAErEA,EAAM,QAASiB,EAAMjB,EAAM,OAAO,KAAK,EAAE,EAAWA,EAAM,OAAO,SAAW,EAAGiB,EAAMjB,EAAM,OAAO,MAAK,EAAQiB,EAAMjB,EAAM,OAAO,OAAOA,EAAM,MAAM,EACzJA,EAAM,OAAO,MAAO,GAGpBiB,EAAMjB,EAAM,OAAO,QAAQpB,EAAGoB,EAAM,OAAO,EAEtCiB,CACT,CACA,SAAS8wB,EAAYtL,EAAQ,CAC3B,IAAIzmB,EAAQymB,EAAO,eACnBkK,EAAM,cAAe3wB,EAAM,UAAU,EAChCA,EAAM,aACTA,EAAM,MAAQ,GACd6f,GAAQ,SAAS4T,EAAezzB,EAAOymB,CAAM,EAEjD,CACA,SAASgN,EAAczzB,EAAOymB,EAAQ,CAIpC,GAHAkK,EAAM,gBAAiB3wB,EAAM,WAAYA,EAAM,MAAM,EAGjD,CAACA,EAAM,YAAcA,EAAM,SAAW,IACxCA,EAAM,WAAa,GACnBymB,EAAO,SAAW,GAClBA,EAAO,KAAK,KAAK,EACbzmB,EAAM,aAAa,CAGrB,IAAI2mB,EAASF,EAAO,gBAChB,CAACE,GAAUA,EAAO,aAAeA,EAAO,WAC1CF,EAAO,QAAS,CAExB,CAEA,CACI,OAAO,QAAW,aACpBwF,EAAS,KAAO,SAAUyH,EAAUpT,EAAM,CACxC,OAAI1a,IAAS,SACXA,EAAOyN,GAAkC,GAEpCzN,EAAKqmB,EAAUyH,EAAUpT,CAAI,CACrC,GAEH,SAAS2S,EAAQU,EAAIxsB,EAAG,CACtB,QAASnI,EAAI,EAAGkjB,EAAIyR,EAAG,OAAQ30B,EAAIkjB,EAAGljB,IACpC,GAAI20B,EAAG30B,CAAC,IAAMmI,EAAG,OAAOnI,EAE1B,MAAO,EACT,wDCj8BA40B,GAAiBC,EACjB,IAAIrK,EAAiBxnB,GAAoB,EAAC,MACxC0nB,EAA6BF,EAAe,2BAC5CG,EAAwBH,EAAe,sBACvCsK,EAAqCtK,EAAe,mCACpDuK,EAA8BvK,EAAe,4BAC3CT,EAAS/X,GAA2B,EACxCE,GAAmB,EAAC2iB,EAAW9K,CAAM,EACrC,SAASiL,EAAe70B,EAAIwwB,EAAM,CAChC,IAAIsE,EAAK,KAAK,gBACdA,EAAG,aAAe,GAClB,IAAItQ,EAAKsQ,EAAG,QACZ,GAAItQ,IAAO,KACT,OAAO,KAAK,KAAK,QAAS,IAAIgG,CAAuB,EAEvDsK,EAAG,WAAa,KAChBA,EAAG,QAAU,KACTtE,GAAQ,MAEV,KAAK,KAAKA,CAAI,EAChBhM,EAAGxkB,CAAE,EACL,IAAI+0B,EAAK,KAAK,eACdA,EAAG,QAAU,IACTA,EAAG,cAAgBA,EAAG,OAASA,EAAG,gBACpC,KAAK,MAAMA,EAAG,aAAa,CAE/B,CACA,SAASL,EAAU9N,EAAS,CAC1B,GAAI,EAAE,gBAAgB8N,GAAY,OAAO,IAAIA,EAAU9N,CAAO,EAC9DgD,EAAO,KAAK,KAAMhD,CAAO,EACzB,KAAK,gBAAkB,CACrB,eAAgBiO,EAAe,KAAK,IAAI,EACxC,cAAe,GACf,aAAc,GACd,QAAS,KACT,WAAY,KACZ,cAAe,IAChB,EAGD,KAAK,eAAe,aAAe,GAKnC,KAAK,eAAe,KAAO,GACvBjO,IACE,OAAOA,EAAQ,WAAc,aAAY,KAAK,WAAaA,EAAQ,WACnE,OAAOA,EAAQ,OAAU,aAAY,KAAK,OAASA,EAAQ,QAIjE,KAAK,GAAG,YAAa6F,CAAS,CAChC,CACA,SAASA,GAAY,CACnB,IAAI3F,EAAQ,KACR,OAAO,KAAK,QAAW,YAAc,CAAC,KAAK,eAAe,UAC5D,KAAK,OAAO,SAAU9mB,EAAIwwB,EAAM,CAC9BH,EAAKvJ,EAAO9mB,EAAIwwB,CAAI,CAC1B,CAAK,EAEDH,EAAK,KAAM,KAAM,IAAI,CAEzB,CACAqE,EAAU,UAAU,KAAO,SAAUxK,EAAO7iB,EAAU,CACpD,OAAK,qBAAgB,cAAgB,GAC9BuiB,EAAO,UAAU,KAAK,KAAK,KAAMM,EAAO7iB,CAAQ,CACxD,EAYDqtB,EAAU,UAAU,WAAa,SAAUxK,EAAO7iB,EAAUmd,EAAI,CAC9DA,EAAG,IAAI+F,EAA2B,cAAc,CAAC,CAClD,EACDmK,EAAU,UAAU,OAAS,SAAUxK,EAAO7iB,EAAUmd,EAAI,CAC1D,IAAIsQ,EAAK,KAAK,gBAId,GAHAA,EAAG,QAAUtQ,EACbsQ,EAAG,WAAa5K,EAChB4K,EAAG,cAAgBztB,EACf,CAACytB,EAAG,aAAc,CACpB,IAAIC,EAAK,KAAK,gBACVD,EAAG,eAAiBC,EAAG,cAAgBA,EAAG,OAASA,EAAG,gBAAe,KAAK,MAAMA,EAAG,aAAa,CACxG,CACC,EAKDL,EAAU,UAAU,MAAQ,SAAUj1B,EAAG,CACvC,IAAIq1B,EAAK,KAAK,gBACVA,EAAG,aAAe,MAAQ,CAACA,EAAG,cAChCA,EAAG,aAAe,GAClB,KAAK,WAAWA,EAAG,WAAYA,EAAG,cAAeA,EAAG,cAAc,GAIlEA,EAAG,cAAgB,EAEtB,EACDJ,EAAU,UAAU,SAAW,SAAUz0B,EAAKukB,EAAI,CAChDoF,EAAO,UAAU,SAAS,KAAK,KAAM3pB,EAAK,SAAU+0B,EAAM,CACxDxQ,EAAGwQ,CAAI,CACX,CAAG,CACF,EACD,SAAS3E,EAAK/I,EAAQtnB,EAAIwwB,EAAM,CAC9B,GAAIxwB,EAAI,OAAOsnB,EAAO,KAAK,QAAStnB,CAAE,EAQtC,GAPIwwB,GAAQ,MAEVlJ,EAAO,KAAKkJ,CAAI,EAKdlJ,EAAO,eAAe,OAAQ,MAAM,IAAIsN,EAC5C,GAAItN,EAAO,gBAAgB,aAAc,MAAM,IAAIqN,EACnD,OAAOrN,EAAO,KAAK,IAAI,CACzB,wDClKA2N,GAAiBC,EACjB,IAAIR,EAAY7xB,GAA8B,EAC9CgP,GAAmB,EAACqjB,EAAaR,CAAS,EAC1C,SAASQ,EAAYtO,EAAS,CAC5B,GAAI,EAAE,gBAAgBsO,GAAc,OAAO,IAAIA,EAAYtO,CAAO,EAClE8N,EAAU,KAAK,KAAM9N,CAAO,CAC9B,CACA,OAAAsO,EAAY,UAAU,WAAa,SAAUhL,EAAO7iB,EAAUmd,EAAI,CAChEA,EAAG,KAAM0F,CAAK,CACf,kDC/BD,IAAI+E,EACJ,SAAS7vB,EAAKuvB,EAAU,CACtB,IAAIC,EAAS,GACb,OAAO,UAAY,CACbA,IACJA,EAAS,GACTD,EAAS,MAAM,OAAQ,SAAS,EACjC,CACH,CACA,IAAItE,EAAiBxnB,GAA0B,EAAC,MAC9CsyB,EAAmB9K,EAAe,iBAClCK,EAAuBL,EAAe,qBACxC,SAAS0E,EAAK9uB,EAAK,CAEjB,GAAIA,EAAK,MAAMA,CACjB,CACA,SAAS+uB,EAAU1H,EAAQ,CACzB,OAAOA,EAAO,WAAa,OAAOA,EAAO,OAAU,UACrD,CACA,SAAS8N,EAAU9N,EAAQ+N,EAASC,EAAS3G,EAAU,CACrDA,EAAWvvB,EAAKuvB,CAAQ,EACxB,IAAI4G,EAAS,GACbjO,EAAO,GAAG,QAAS,UAAY,CAC7BiO,EAAS,EACb,CAAG,EACGtG,IAAQ,SAAWA,EAAMpd,GAA0B,GACvDod,EAAI3H,EAAQ,CACV,SAAU+N,EACV,SAAUC,CACX,EAAE,SAAUr1B,EAAK,CAChB,GAAIA,EAAK,OAAO0uB,EAAS1uB,CAAG,EAC5Bs1B,EAAS,GACT5G,EAAU,CACd,CAAG,EACD,IAAI6G,EAAY,GAChB,OAAO,SAAUv1B,EAAK,CACpB,GAAI,CAAAs1B,GACA,CAAAC,EAIJ,IAHAA,EAAY,GAGRxG,EAAU1H,CAAM,EAAG,OAAOA,EAAO,MAAO,EAC5C,GAAI,OAAOA,EAAO,SAAY,WAAY,OAAOA,EAAO,QAAS,EACjEqH,EAAS1uB,GAAO,IAAIyqB,EAAqB,MAAM,CAAC,EACjD,CACH,CACA,SAAS1X,EAAKzE,EAAI,CAChBA,EAAI,CACN,CACA,SAASknB,EAAKhvB,EAAMivB,EAAI,CACtB,OAAOjvB,EAAK,KAAKivB,CAAE,CACrB,CACA,SAASC,EAAYC,EAAS,CAE5B,MADI,CAACA,EAAQ,QACT,OAAOA,EAAQA,EAAQ,OAAS,CAAC,GAAM,WAAmB7G,EACvD6G,EAAQ,IAAK,CACtB,CACA,SAASC,GAAW,CAClB,QAAShH,EAAO,UAAU,OAAQ+G,EAAU,IAAI,MAAM/G,CAAI,EAAGC,EAAO,EAAGA,EAAOD,EAAMC,IAClF8G,EAAQ9G,CAAI,EAAI,UAAUA,CAAI,EAEhC,IAAIH,EAAWgH,EAAYC,CAAO,EAElC,GADI,MAAM,QAAQA,EAAQ,CAAC,CAAC,IAAGA,EAAUA,EAAQ,CAAC,GAC9CA,EAAQ,OAAS,EACnB,MAAM,IAAIT,EAAiB,SAAS,EAEtC,IAAIrE,EACAgF,EAAWF,EAAQ,IAAI,SAAUtO,EAAQznB,EAAG,CAC9C,IAAIw1B,EAAUx1B,EAAI+1B,EAAQ,OAAS,EAC/BN,EAAUz1B,EAAI,EAClB,OAAOu1B,EAAU9N,EAAQ+N,EAASC,EAAS,SAAUr1B,EAAK,CACnD6wB,IAAOA,EAAQ7wB,GAChBA,GAAK61B,EAAS,QAAQ9iB,CAAI,EAC1B,CAAAqiB,IACJS,EAAS,QAAQ9iB,CAAI,EACrB2b,EAASmC,CAAK,EACpB,CAAK,CACL,CAAG,EACD,OAAO8E,EAAQ,OAAOH,CAAI,CAC5B,CACA,OAAAM,GAAiBF,kDChEjBG,GAAiBjM,EAEjB,IAAIkM,EAAKpzB,GAAiB,EAAC,aACvBqzB,EAAWrkB,GAAmB,EAElCqkB,EAASnM,EAAQkM,CAAE,EACnBlM,EAAO,SAAWhY,GAAkD,EACpEgY,EAAO,SAAW9X,GAAkD,EACpE8X,EAAO,OAASvW,GAAgD,EAChEuW,EAAO,UAAYrW,GAAmD,EACtEqW,EAAO,YAAcpW,GAAqD,EAC1EoW,EAAO,SAAWlW,GAAA,EAClBkW,EAAO,SAAWjW,GAAA,EAGlBiW,EAAO,OAASA,EAOhB,SAASA,GAAS,CAChBkM,EAAG,KAAK,IAAI,CACd,CAEA,OAAAlM,EAAO,UAAU,KAAO,SAASmJ,EAAMtM,EAAS,CAC9C,IAAIzB,EAAS,KAEb,SAAS0O,EAAO3J,EAAO,CACjBgJ,EAAK,UACOA,EAAK,MAAMhJ,CAAK,IAA1B,IAA+B/E,EAAO,OACxCA,EAAO,MAAO,CAGtB,CAEEA,EAAO,GAAG,OAAQ0O,CAAM,EAExB,SAASH,GAAU,CACbvO,EAAO,UAAYA,EAAO,QAC5BA,EAAO,OAAQ,CAErB,CAEE+N,EAAK,GAAG,QAASQ,CAAO,EAIpB,CAACR,EAAK,WAAa,CAACtM,GAAWA,EAAQ,MAAQ,MACjDzB,EAAO,GAAG,MAAO4H,CAAK,EACtB5H,EAAO,GAAG,QAASsK,CAAO,GAG5B,IAAI0G,EAAW,GACf,SAASpJ,GAAQ,CACXoJ,IACJA,EAAW,GAEXjD,EAAK,IAAK,EACd,CAGE,SAASzD,GAAU,CACb0G,IACJA,EAAW,GAEP,OAAOjD,EAAK,SAAY,YAAYA,EAAK,QAAS,EAC1D,CAGE,SAAS1D,EAAQxvB,EAAI,CAEnB,GADAyzB,EAAS,EACLwC,EAAG,cAAc,KAAM,OAAO,IAAM,EACtC,MAAMj2B,CAEZ,CAEEmlB,EAAO,GAAG,QAASqK,CAAO,EAC1B0D,EAAK,GAAG,QAAS1D,CAAO,EAGxB,SAASiE,GAAU,CACjBtO,EAAO,eAAe,OAAQ0O,CAAM,EACpCX,EAAK,eAAe,QAASQ,CAAO,EAEpCvO,EAAO,eAAe,MAAO4H,CAAK,EAClC5H,EAAO,eAAe,QAASsK,CAAO,EAEtCtK,EAAO,eAAe,QAASqK,CAAO,EACtC0D,EAAK,eAAe,QAAS1D,CAAO,EAEpCrK,EAAO,eAAe,MAAOsO,CAAO,EACpCtO,EAAO,eAAe,QAASsO,CAAO,EAEtCP,EAAK,eAAe,QAASO,CAAO,CACxC,CAEE,OAAAtO,EAAO,GAAG,MAAOsO,CAAO,EACxBtO,EAAO,GAAG,QAASsO,CAAO,EAE1BP,EAAK,GAAG,QAASO,CAAO,EAExBP,EAAK,KAAK,OAAQ/N,CAAM,EAGjB+N,CACR,yDChIC,SAAUkD,EAAK,CACfA,EAAI,OAAS,SAAUC,EAAQC,EAAK,CAAE,OAAO,IAAIC,EAAUF,EAAQC,CAAG,CAAC,EACvEF,EAAI,UAAYG,EAChBH,EAAI,UAAYI,EAChBJ,EAAI,aAAeK,EAWnBL,EAAI,kBAAoB,GAAK,KAE7B,IAAIM,EAAU,CACZ,UAAW,WAAY,WAAY,UAAW,UAC9C,eAAgB,eAAgB,SAAU,aAC1C,cAAe,QAAS,QAC5B,EAEEN,EAAI,OAAS,CACX,OACA,wBACA,kBACA,UACA,UACA,eACA,YACA,UACA,WACA,YACA,QACA,aACA,QACA,MACA,QACA,SACA,gBACA,gBACJ,EAEE,SAASG,EAAWF,EAAQC,EAAK,CAC/B,GAAI,EAAE,gBAAgBC,GACpB,OAAO,IAAIA,EAAUF,EAAQC,CAAG,EAGlC,IAAIK,EAAS,KACbC,EAAaD,CAAM,EACnBA,EAAO,EAAIA,EAAO,EAAI,GACtBA,EAAO,oBAAsBP,EAAI,kBACjCO,EAAO,IAAML,GAAO,GACpBK,EAAO,IAAI,UAAYA,EAAO,IAAI,WAAaA,EAAO,IAAI,cAC1DA,EAAO,UAAYA,EAAO,IAAI,UAAY,cAAgB,cAC1DA,EAAO,KAAO,GACdA,EAAO,OAASA,EAAO,WAAaA,EAAO,QAAU,GACrDA,EAAO,IAAMA,EAAO,MAAQ,KAC5BA,EAAO,OAAS,CAAC,CAACN,EAClBM,EAAO,SAAW,CAAC,EAAEN,GAAUM,EAAO,IAAI,UAC1CA,EAAO,MAAQE,EAAE,MACjBF,EAAO,eAAiBA,EAAO,IAAI,eACnCA,EAAO,SAAWA,EAAO,eAAiB,OAAO,OAAOP,EAAI,YAAY,EAAI,OAAO,OAAOA,EAAI,QAAQ,EACtGO,EAAO,WAAa,GAKhBA,EAAO,IAAI,QACbA,EAAO,GAAK,OAAO,OAAOG,CAAM,GAK9BH,EAAO,IAAI,0BAA4B,SACzCA,EAAO,IAAI,wBAA0B,CAACN,GAIxCM,EAAO,cAAgBA,EAAO,IAAI,WAAa,GAC3CA,EAAO,gBACTA,EAAO,SAAWA,EAAO,KAAOA,EAAO,OAAS,GAElDI,EAAKJ,EAAQ,SAAS,CAC1B,CAEO,OAAO,SACV,OAAO,OAAS,SAAUlT,EAAG,CAC3B,SAASuT,GAAK,EACdA,EAAE,UAAYvT,EACd,IAAIwT,EAAO,IAAID,EACf,OAAOC,CACb,GAGO,OAAO,OACV,OAAO,KAAO,SAAUxT,EAAG,CACzB,IAAI1b,EAAI,GACR,QAASlI,KAAK4jB,EAAOA,EAAE,eAAe5jB,CAAC,GAAGkI,EAAE,KAAKlI,CAAC,EAClD,OAAOkI,CACb,GAGE,SAASmvB,EAAmBP,EAAQ,CAGlC,QAFIQ,EAAa,KAAK,IAAIf,EAAI,kBAAmB,EAAE,EAC/CgB,EAAY,EACPv3B,EAAI,EAAGkjB,EAAI2T,EAAQ,OAAQ72B,EAAIkjB,EAAGljB,IAAK,CAC9C,IAAIM,EAAMw2B,EAAOD,EAAQ72B,CAAC,CAAC,EAAE,OAC7B,GAAIM,EAAMg3B,EAKR,OAAQT,EAAQ72B,CAAC,EAAC,CAChB,IAAK,WACHw3B,EAAUV,CAAM,EAChB,MAEF,IAAK,QACHW,EAASX,EAAQ,UAAWA,EAAO,KAAK,EACxCA,EAAO,MAAQ,GACf,MAEF,IAAK,SACHW,EAASX,EAAQ,WAAYA,EAAO,MAAM,EAC1CA,EAAO,OAAS,GAChB,MAEF,QACE7F,GAAM6F,EAAQ,+BAAiCD,EAAQ72B,CAAC,CAAC,CACrE,CAEMu3B,EAAY,KAAK,IAAIA,EAAWj3B,CAAG,CACzC,CAEI,IAAIK,EAAI41B,EAAI,kBAAoBgB,EAChCT,EAAO,oBAAsBn2B,EAAIm2B,EAAO,QAC5C,CAEE,SAASC,EAAcD,EAAQ,CAC7B,QAAS92B,EAAI,EAAGkjB,EAAI2T,EAAQ,OAAQ72B,EAAIkjB,EAAGljB,IACzC82B,EAAOD,EAAQ72B,CAAC,CAAC,EAAI,EAE3B,CAEE,SAAS03B,EAAcZ,EAAQ,CAC7BU,EAAUV,CAAM,EACZA,EAAO,QAAU,KACnBW,EAASX,EAAQ,UAAWA,EAAO,KAAK,EACxCA,EAAO,MAAQ,IAEbA,EAAO,SAAW,KACpBW,EAASX,EAAQ,WAAYA,EAAO,MAAM,EAC1CA,EAAO,OAAS,GAEtB,CAEEJ,EAAU,UAAY,CACpB,IAAK,UAAY,CAAElyB,GAAI,IAAI,CAAG,EAC9B,MAAOmzB,EACP,OAAQ,UAAY,CAAE,YAAK,MAAQ,KAAa,IAAM,EACtD,MAAO,UAAY,CAAE,OAAO,KAAK,MAAM,IAAI,CAAG,EAC9C,MAAO,UAAY,CAAED,EAAa,IAAI,CAAC,CAC3C,EAEE,IAAIxN,EACJ,GAAI,CACFA,EAASlnB,GAAA,EAAkB,MAC5B,MAAY,CACXknB,EAAS,UAAY,EACzB,CACOA,IAAQA,EAAS,UAAY,IAElC,IAAI0N,EAAcrB,EAAI,OAAO,OAAO,SAAUpC,EAAI,CAChD,OAAOA,IAAO,SAAWA,IAAO,KACjC,GAED,SAASyC,EAAcJ,EAAQC,EAAK,CAClC,OAAO,IAAIE,EAAUH,EAAQC,CAAG,CACpC,CAEE,SAASE,EAAWH,EAAQC,EAAK,CAC/B,GAAI,EAAE,gBAAgBE,GACpB,OAAO,IAAIA,EAAUH,EAAQC,CAAG,EAGlCvM,EAAO,MAAM,IAAI,EAEjB,KAAK,QAAU,IAAIwM,EAAUF,EAAQC,CAAG,EACxC,KAAK,SAAW,GAChB,KAAK,SAAW,GAEhB,IAAIoB,EAAK,KAET,KAAK,QAAQ,MAAQ,UAAY,CAC/BA,EAAG,KAAK,KAAK,CACnB,EAEI,KAAK,QAAQ,QAAU,SAAU13B,EAAI,CACnC03B,EAAG,KAAK,QAAS13B,CAAE,EAInB03B,EAAG,QAAQ,MAAQ,IACzB,EAEI,KAAK,SAAW,KAEhBD,EAAY,QAAQ,SAAUzD,EAAI,CAChC,OAAO,eAAe0D,EAAI,KAAO1D,EAAI,CACnC,IAAK,UAAY,CACf,OAAO0D,EAAG,QAAQ,KAAO1D,CAAE,CAC5B,EACD,IAAK,SAAU2D,EAAG,CAChB,GAAI,CAACA,EACH,OAAAD,EAAG,mBAAmB1D,CAAE,EACxB0D,EAAG,QAAQ,KAAO1D,CAAE,EAAI2D,EACjBA,EAETD,EAAG,GAAG1D,EAAI2D,CAAC,CACZ,EACD,WAAY,GACZ,aAAc,EACf,EACF,EACL,CAEEnB,EAAU,UAAY,OAAO,OAAOzM,EAAO,UAAW,CACpD,YAAa,CACX,MAAOyM,CACb,CACG,GAEDA,EAAU,UAAU,MAAQ,SAAUhG,EAAM,CAC1C,GAAI,OAAO5qB,IAAW,YACpB,OAAOA,GAAO,UAAa,YAC3BA,GAAO,SAAS4qB,CAAI,EAAG,CACvB,GAAI,CAAC,KAAK,SAAU,CAClB,IAAIoH,EAAK/lB,KAA0B,cACnC,KAAK,SAAW,IAAI+lB,EAAG,MAAM,CACrC,CACMpH,EAAO,KAAK,SAAS,MAAMA,CAAI,CACrC,CAEI,YAAK,QAAQ,MAAMA,EAAK,SAAU,GAClC,KAAK,KAAK,OAAQA,CAAI,EACf,EACX,EAEEgG,EAAU,UAAU,IAAM,SAAUtM,EAAO,CACzC,OAAIA,GAASA,EAAM,QACjB,KAAK,MAAMA,CAAK,EAElB,KAAK,QAAQ,IAAG,EACT,EACX,EAEEsM,EAAU,UAAU,GAAK,SAAUxC,EAAI9zB,EAAS,CAC9C,IAAIw3B,EAAK,KACT,MAAI,CAACA,EAAG,QAAQ,KAAO1D,CAAE,GAAKyD,EAAY,QAAQzD,CAAE,IAAM,KACxD0D,EAAG,QAAQ,KAAO1D,CAAE,EAAI,UAAY,CAClC,IAAIp1B,EAAO,UAAU,SAAW,EAAI,CAAC,UAAU,CAAC,CAAC,EAAI,MAAM,MAAM,KAAM,SAAS,EAChFA,EAAK,OAAO,EAAG,EAAGo1B,CAAE,EACpB0D,EAAG,KAAK,MAAMA,EAAI94B,CAAI,CAC9B,GAGWmrB,EAAO,UAAU,GAAG,KAAK2N,EAAI1D,EAAI9zB,CAAO,CACnD,EAIE,IAAI23B,EAAQ,UACRC,EAAU,UACVC,EAAgB,uCAChBC,EAAkB,gCAClBlB,EAAS,CAAE,IAAKiB,EAAe,MAAOC,CAAe,EAQrDC,EAAY,4JAEZC,EAAW,gMAEXC,EAAc,6JACdC,EAAa,iMAEjB,SAASC,EAAc9yB,EAAG,CACxB,OAAOA,IAAM,KAAOA,IAAM;AAAA,GAAQA,IAAM,MAAQA,IAAM,GAC1D,CAEE,SAAS+yB,EAAS/yB,EAAG,CACnB,OAAOA,IAAM,KAAOA,IAAM,GAC9B,CAEE,SAASgzB,EAAahzB,EAAG,CACvB,OAAOA,IAAM,KAAO8yB,EAAa9yB,CAAC,CACtC,CAEE,SAASizB,EAASngB,EAAO9S,EAAG,CAC1B,OAAO8S,EAAM,KAAK9S,CAAC,CACvB,CAEE,SAASkzB,EAAUpgB,EAAO9S,EAAG,CAC3B,MAAO,CAACizB,EAAQngB,EAAO9S,CAAC,CAC5B,CAEE,IAAIsxB,EAAI,EACRT,EAAI,MAAQ,CACV,MAAOS,IACP,iBAAkBA,IAClB,KAAMA,IACN,YAAaA,IACb,UAAWA,IACX,UAAWA,IACX,iBAAkBA,IAClB,QAASA,IACT,eAAgBA,IAChB,YAAaA,IACb,mBAAoBA,IACpB,iBAAkBA,IAClB,QAASA,IACT,eAAgBA,IAChB,cAAeA,IACf,MAAOA,IACP,aAAcA,IACd,eAAgBA,IAChB,UAAWA,IACX,eAAgBA,IAChB,iBAAkBA,IAClB,SAAUA,IACV,eAAgBA,IAChB,OAAQA,IACR,YAAaA,IACb,sBAAuBA,IACvB,aAAcA,IACd,oBAAqBA,IACrB,oBAAqBA,IACrB,sBAAuBA,IACvB,sBAAuBA,IACvB,sBAAuBA,IACvB,UAAWA,IACX,oBAAqBA,IACrB,OAAQA,IACR,cAAeA,GACnB,EAEET,EAAI,aAAe,CACjB,IAAO,IACP,GAAM,IACN,GAAM,IACN,KAAQ,IACR,KAAQ,GACZ,EAEEA,EAAI,SAAW,CACb,IAAO,IACP,GAAM,IACN,GAAM,IACN,KAAQ,IACR,KAAQ,IACR,MAAS,IACT,OAAU,IACV,MAAS,IACT,OAAU,IACV,MAAS,IACT,OAAU,IACV,KAAQ,IACR,OAAU,IACV,IAAO,IACP,OAAU,IACV,MAAS,IACT,OAAU,IACV,KAAQ,IACR,OAAU,IACV,MAAS,IACT,OAAU,IACV,KAAQ,IACR,OAAU,IACV,OAAU,IACV,MAAS,IACT,OAAU,IACV,OAAU,IACV,OAAU,IACV,KAAQ,IACR,MAAS,IACT,OAAU,IACV,MAAS,IACT,OAAU,IACV,KAAQ,IACR,OAAU,IACV,OAAU,IACV,MAAS,IACT,MAAS,IACT,OAAU,IACV,MAAS,IACT,OAAU,IACV,KAAQ,IACR,OAAU,IACV,OAAU,IACV,MAAS,IACT,OAAU,IACV,IAAO,IACP,KAAQ,IACR,OAAU,IACV,MAAS,IACT,OAAU,IACV,KAAQ,IACR,OAAU,IACV,OAAU,IACV,MAAS,IACT,OAAU,IACV,OAAU,IACV,OAAU,IACV,KAAQ,IACR,MAAS,IACT,MAAS,IACT,OAAU,IACV,MAAS,IACT,OAAU,IACV,KAAQ,IACR,OAAU,IACV,KAAQ,IACR,KAAQ,IACR,IAAO,IACP,KAAQ,IACR,MAAS,IACT,KAAQ,IACR,MAAS,IACT,OAAU,IACV,IAAO,IACP,OAAU,IACV,KAAQ,IACR,IAAO,IACP,KAAQ,IACR,MAAS,IACT,IAAO,IACP,IAAO,IACP,KAAQ,IACR,IAAO,IACP,OAAU,IACV,KAAQ,IACR,KAAQ,IACR,KAAQ,IACR,MAAS,IACT,MAAS,IACT,KAAQ,IACR,OAAU,IACV,MAAS,IACT,KAAQ,IACR,MAAS,IACT,OAAU,IACV,OAAU,IACV,OAAU,IACV,OAAU,IACV,MAAS,IACT,OAAU,IACV,MAAS,IACT,MAAS,IACT,OAAU,IACV,OAAU,IACV,KAAQ,IACR,KAAQ,IACR,KAAQ,IACR,MAAS,IACT,MAAS,IACT,KAAQ,IACR,MAAS,IACT,MAAS,IACT,QAAW,IACX,KAAQ,IACR,IAAO,IACP,MAAS,IACT,KAAQ,IACR,MAAS,IACT,OAAU,IACV,GAAM,IACN,GAAM,IACN,GAAM,IACN,QAAW,IACX,GAAM,IACN,IAAO,IACP,MAAS,IACT,IAAO,IACP,QAAW,IACX,IAAO,IACP,IAAO,IACP,IAAO,IACP,MAAS,IACT,MAAS,IACT,KAAQ,IACR,MAAS,IACT,MAAS,IACT,QAAW,IACX,KAAQ,IACR,IAAO,IACP,MAAS,IACT,KAAQ,IACR,MAAS,IACT,OAAU,IACV,GAAM,IACN,GAAM,IACN,GAAM,IACN,QAAW,IACX,GAAM,IACN,IAAO,IACP,OAAU,IACV,MAAS,IACT,IAAO,IACP,QAAW,IACX,IAAO,IACP,IAAO,IACP,IAAO,IACP,MAAS,IACT,SAAY,IACZ,MAAS,IACT,IAAO,IACP,KAAQ,KACR,KAAQ,KACR,OAAU,KACV,KAAQ,KACR,IAAO,KACP,IAAO,KACP,IAAO,KACP,MAAS,KACT,MAAS,KACT,MAAS,KACT,MAAS,KACT,MAAS,KACT,MAAS,KACT,MAAS,KACT,MAAS,KACT,OAAU,KACV,OAAU,KACV,KAAQ,KACR,OAAU,KACV,OAAU,KACV,MAAS,KACT,MAAS,KACT,OAAU,KACV,OAAU,KACV,MAAS,KACT,MAAS,KACT,KAAQ,KACR,MAAS,KACT,OAAU,KACV,KAAQ,KACR,MAAS,KACT,QAAW,KACX,KAAQ,KACR,KAAQ,KACR,KAAQ,KACR,KAAQ,KACR,KAAQ,KACR,MAAS,KACT,KAAQ,KACR,KAAQ,KACR,KAAQ,KACR,KAAQ,KACR,KAAQ,KACR,OAAU,KACV,KAAQ,KACR,MAAS,KACT,MAAS,KACT,MAAS,KACT,KAAQ,KACR,MAAS,KACT,GAAM,KACN,KAAQ,KACR,IAAO,KACP,MAAS,KACT,OAAU,KACV,MAAS,KACT,KAAQ,KACR,MAAS,KACT,IAAO,KACP,IAAO,KACP,GAAM,KACN,IAAO,KACP,IAAO,KACP,IAAO,KACP,OAAU,KACV,IAAO,KACP,KAAQ,KACR,MAAS,KACT,GAAM,KACN,MAAS,KACT,GAAM,KACN,GAAM,KACN,IAAO,KACP,IAAO,KACP,KAAQ,KACR,KAAQ,KACR,KAAQ,KACR,MAAS,KACT,OAAU,KACV,KAAQ,KACR,KAAQ,KACR,MAAS,KACT,MAAS,KACT,OAAU,KACV,OAAU,KACV,KAAQ,KACR,KAAQ,KACR,IAAO,KACP,OAAU,KACV,MAAS,KACT,OAAU,KACV,MAAS,IACb,EAEE,OAAO,KAAKA,EAAI,QAAQ,EAAE,QAAQ,SAAUh1B,EAAK,CAC/C,IAAI4D,EAAIoxB,EAAI,SAASh1B,CAAG,EACpBkE,EAAI,OAAON,GAAM,SAAW,OAAO,aAAaA,CAAC,EAAIA,EACzDoxB,EAAI,SAASh1B,CAAG,EAAIkE,CACrB,GAED,QAASA,KAAK8wB,EAAI,MAChBA,EAAI,MAAMA,EAAI,MAAM9wB,CAAC,CAAC,EAAIA,EAI5BuxB,EAAIT,EAAI,MAER,SAASW,EAAMJ,EAAQ9E,EAAOrB,EAAM,CAClCmG,EAAO9E,CAAK,GAAK8E,EAAO9E,CAAK,EAAErB,CAAI,CACvC,CAEE,SAAS8G,EAAUX,EAAQ+B,EAAUlI,EAAM,CACrCmG,EAAO,UAAUU,EAAUV,CAAM,EACrCI,EAAKJ,EAAQ+B,EAAUlI,CAAI,CAC/B,CAEE,SAAS6G,EAAWV,EAAQ,CAC1BA,EAAO,SAAWgC,GAAShC,EAAO,IAAKA,EAAO,QAAQ,EAClDA,EAAO,UAAUI,EAAKJ,EAAQ,SAAUA,EAAO,QAAQ,EAC3DA,EAAO,SAAW,EACtB,CAEE,SAASgC,GAAUrC,EAAKsC,EAAM,CAC5B,OAAItC,EAAI,OAAMsC,EAAOA,EAAK,KAAI,GAC1BtC,EAAI,YAAWsC,EAAOA,EAAK,QAAQ,OAAQ,GAAG,GAC3CA,CACX,CAEE,SAAS9H,GAAO6F,EAAQ32B,EAAI,CAC1B,OAAAq3B,EAAUV,CAAM,EACZA,EAAO,gBACT32B,GAAM;AAAA,QAAa22B,EAAO,KACxB;AAAA,UAAeA,EAAO,OACtB;AAAA,QAAaA,EAAO,GAExB32B,EAAK,IAAI,MAAMA,CAAE,EACjB22B,EAAO,MAAQ32B,EACf+2B,EAAKJ,EAAQ,UAAW32B,CAAE,EACnB22B,CACX,CAEE,SAAStyB,GAAKsyB,EAAQ,CACpB,OAAIA,EAAO,SAAW,CAACA,EAAO,YAAYkC,EAAWlC,EAAQ,mBAAmB,EAC3EA,EAAO,QAAUE,EAAE,OACrBF,EAAO,QAAUE,EAAE,kBACnBF,EAAO,QAAUE,EAAE,MACpB/F,GAAM6F,EAAQ,gBAAgB,EAEhCU,EAAUV,CAAM,EAChBA,EAAO,EAAI,GACXA,EAAO,OAAS,GAChBI,EAAKJ,EAAQ,OAAO,EACpBJ,EAAU,KAAKI,EAAQA,EAAO,OAAQA,EAAO,GAAG,EACzCA,CACX,CAEE,SAASkC,EAAYlC,EAAQ5O,EAAS,CACpC,GAAI,OAAO4O,GAAW,UAAY,EAAEA,aAAkBJ,GACpD,MAAM,IAAI,MAAM,wBAAwB,EAEtCI,EAAO,QACT7F,GAAM6F,EAAQ5O,CAAO,CAE3B,CAEE,SAAS+Q,GAAQnC,EAAQ,CAClBA,EAAO,SAAQA,EAAO,QAAUA,EAAO,QAAQA,EAAO,SAAS,EAAC,GACrE,IAAIoC,EAASpC,EAAO,KAAKA,EAAO,KAAK,OAAS,CAAC,GAAKA,EAChDla,EAAMka,EAAO,IAAM,CAAE,KAAMA,EAAO,QAAS,WAAY,CAAE,GAGzDA,EAAO,IAAI,QACbla,EAAI,GAAKsc,EAAO,IAElBpC,EAAO,WAAW,OAAS,EAC3BW,EAASX,EAAQ,iBAAkBla,CAAG,CAC1C,CAEE,SAASuc,GAAOj3B,EAAMk3B,EAAW,CAC/B,IAAIp5B,EAAIkC,EAAK,QAAQ,GAAG,EACpBm3B,EAAWr5B,EAAI,EAAI,CAAE,GAAIkC,CAAM,EAAGA,EAAK,MAAM,GAAG,EAChDo3B,EAASD,EAAS,CAAC,EACnBE,EAAQF,EAAS,CAAC,EAGtB,OAAID,GAAal3B,IAAS,UACxBo3B,EAAS,QACTC,EAAQ,IAGH,CAAE,OAAQD,EAAQ,MAAOC,CAAK,CACzC,CAEE,SAASC,GAAQ1C,EAAQ,CAKvB,GAJKA,EAAO,SACVA,EAAO,WAAaA,EAAO,WAAWA,EAAO,SAAS,EAAC,GAGrDA,EAAO,WAAW,QAAQA,EAAO,UAAU,IAAM,IACnDA,EAAO,IAAI,WAAW,eAAeA,EAAO,UAAU,EAAG,CACzDA,EAAO,WAAaA,EAAO,YAAc,GACzC,MACN,CAEI,GAAIA,EAAO,IAAI,MAAO,CACpB,IAAI2C,EAAKN,GAAMrC,EAAO,WAAY,EAAI,EAClCwC,EAASG,EAAG,OACZF,EAAQE,EAAG,MAEf,GAAIH,IAAW,QAEb,GAAIC,IAAU,OAASzC,EAAO,cAAgBoB,EAC5Cc,EAAWlC,EACT,gCAAkCoB,EAAgB;AAAA,UACrCpB,EAAO,WAAW,UACxByC,IAAU,SAAWzC,EAAO,cAAgBqB,EACrDa,EAAWlC,EACT,kCAAoCqB,EAAkB;AAAA,UACzCrB,EAAO,WAAW,MAC5B,CACL,IAAIla,EAAMka,EAAO,IACboC,EAASpC,EAAO,KAAKA,EAAO,KAAK,OAAS,CAAC,GAAKA,EAChDla,EAAI,KAAOsc,EAAO,KACpBtc,EAAI,GAAK,OAAO,OAAOsc,EAAO,EAAE,GAElCtc,EAAI,GAAG2c,CAAK,EAAIzC,EAAO,WACjC,CAMMA,EAAO,WAAW,KAAK,CAACA,EAAO,WAAYA,EAAO,WAAW,CAAC,CACpE,MAEMA,EAAO,IAAI,WAAWA,EAAO,UAAU,EAAIA,EAAO,YAClDW,EAASX,EAAQ,cAAe,CAC9B,KAAMA,EAAO,WACb,MAAOA,EAAO,WACf,GAGHA,EAAO,WAAaA,EAAO,YAAc,EAC7C,CAEE,SAAS4C,GAAS5C,EAAQ6C,EAAa,CACrC,GAAI7C,EAAO,IAAI,MAAO,CAEpB,IAAIla,EAAMka,EAAO,IAGb2C,EAAKN,GAAMrC,EAAO,OAAO,EAC7Bla,EAAI,OAAS6c,EAAG,OAChB7c,EAAI,MAAQ6c,EAAG,MACf7c,EAAI,IAAMA,EAAI,GAAG6c,EAAG,MAAM,GAAK,GAE3B7c,EAAI,QAAU,CAACA,EAAI,MACrBoc,EAAWlC,EAAQ,6BACjB,KAAK,UAAUA,EAAO,OAAO,CAAC,EAChCla,EAAI,IAAM6c,EAAG,QAGf,IAAIP,EAASpC,EAAO,KAAKA,EAAO,KAAK,OAAS,CAAC,GAAKA,EAChDla,EAAI,IAAMsc,EAAO,KAAOtc,EAAI,IAC9B,OAAO,KAAKA,EAAI,EAAE,EAAE,QAAQ,SAAUgK,GAAG,CACvC6Q,EAASX,EAAQ,kBAAmB,CAClC,OAAQlQ,GACR,IAAKhK,EAAI,GAAGgK,EAAC,CACd,EACF,GAMH,QAAS5mB,EAAI,EAAGkjB,EAAI4T,EAAO,WAAW,OAAQ92B,EAAIkjB,EAAGljB,IAAK,CACxD,IAAI45B,EAAK9C,EAAO,WAAW92B,CAAC,EACxBkC,EAAO03B,EAAG,CAAC,EACXx6B,EAAQw6B,EAAG,CAAC,EACZP,EAAWF,GAAMj3B,EAAM,EAAI,EAC3Bo3B,GAASD,EAAS,OAClBE,EAAQF,EAAS,MACjB7pB,GAAM8pB,KAAW,GAAK,GAAM1c,EAAI,GAAG0c,EAAM,GAAK,GAC9CpxB,GAAI,CACN,KAAMhG,EACN,MAAO9C,EACP,OAAQk6B,GACR,MAAOC,EACP,IAAK/pB,EACf,EAIY8pB,IAAUA,KAAW,SAAW,CAAC9pB,KACnCwpB,EAAWlC,EAAQ,6BACjB,KAAK,UAAUwC,EAAM,CAAC,EACxBpxB,GAAE,IAAMoxB,IAEVxC,EAAO,IAAI,WAAW50B,CAAI,EAAIgG,GAC9BuvB,EAASX,EAAQ,cAAe5uB,EAAC,CACzC,CACM4uB,EAAO,WAAW,OAAS,CACjC,CAEIA,EAAO,IAAI,cAAgB,CAAC,CAAC6C,EAG7B7C,EAAO,QAAU,GACjBA,EAAO,KAAK,KAAKA,EAAO,GAAG,EAC3BW,EAASX,EAAQ,YAAaA,EAAO,GAAG,EACnC6C,IAEC,CAAC7C,EAAO,UAAYA,EAAO,QAAQ,YAAa,IAAK,SACvDA,EAAO,MAAQE,EAAE,OAEjBF,EAAO,MAAQE,EAAE,KAEnBF,EAAO,IAAM,KACbA,EAAO,QAAU,IAEnBA,EAAO,WAAaA,EAAO,YAAc,GACzCA,EAAO,WAAW,OAAS,CAC/B,CAEE,SAAS+C,GAAU/C,EAAQ,CACzB,GAAI,CAACA,EAAO,QAAS,CACnBkC,EAAWlC,EAAQ,wBAAwB,EAC3CA,EAAO,UAAY,MACnBA,EAAO,MAAQE,EAAE,KACjB,MACN,CAEI,GAAIF,EAAO,OAAQ,CACjB,GAAIA,EAAO,UAAY,SAAU,CAC/BA,EAAO,QAAU,KAAOA,EAAO,QAAU,IACzCA,EAAO,QAAU,GACjBA,EAAO,MAAQE,EAAE,OACjB,MACR,CACMS,EAASX,EAAQ,WAAYA,EAAO,MAAM,EAC1CA,EAAO,OAAS,EACtB,CAII,IAAIgD,EAAIhD,EAAO,KAAK,OAChBiD,EAAUjD,EAAO,QAChBA,EAAO,SACViD,EAAUA,EAAQjD,EAAO,SAAS,EAAC,GAGrC,QADIkD,EAAUD,EACPD,KAAK,CACV,IAAIG,EAAQnD,EAAO,KAAKgD,CAAC,EACzB,GAAIG,EAAM,OAASD,EAEjBhB,EAAWlC,EAAQ,sBAAsB,YAIjD,CAGI,GAAIgD,EAAI,EAAG,CACTd,EAAWlC,EAAQ,0BAA4BA,EAAO,OAAO,EAC7DA,EAAO,UAAY,KAAOA,EAAO,QAAU,IAC3CA,EAAO,MAAQE,EAAE,KACjB,MACN,CACIF,EAAO,QAAUiD,EAEjB,QADIt0B,EAAIqxB,EAAO,KAAK,OACbrxB,KAAMq0B,GAAG,CACd,IAAIld,EAAMka,EAAO,IAAMA,EAAO,KAAK,IAAG,EACtCA,EAAO,QAAUA,EAAO,IAAI,KAC5BW,EAASX,EAAQ,aAAcA,EAAO,OAAO,EAE7C,IAAI3uB,EAAI,GACR,QAASnI,KAAK4c,EAAI,GAChBzU,EAAEnI,CAAC,EAAI4c,EAAI,GAAG5c,CAAC,EAGjB,IAAIk5B,EAASpC,EAAO,KAAKA,EAAO,KAAK,OAAS,CAAC,GAAKA,EAChDA,EAAO,IAAI,OAASla,EAAI,KAAOsc,EAAO,IAExC,OAAO,KAAKtc,EAAI,EAAE,EAAE,QAAQ,SAAUgK,EAAG,CACvC,IAAIhnB,GAAIgd,EAAI,GAAGgK,CAAC,EAChB6Q,EAASX,EAAQ,mBAAoB,CAAE,OAAQlQ,EAAG,IAAKhnB,EAAG,EAC3D,EAET,CACQk6B,IAAM,IAAGhD,EAAO,WAAa,IACjCA,EAAO,QAAUA,EAAO,YAAcA,EAAO,WAAa,GAC1DA,EAAO,WAAW,OAAS,EAC3BA,EAAO,MAAQE,EAAE,IACrB,CAEE,SAASkD,EAAapD,EAAQ,CAC5B,IAAIqD,EAASrD,EAAO,OAChBsD,EAAWD,EAAO,YAAW,EAC7B/1B,EACAi2B,EAAS,GAEb,OAAIvD,EAAO,SAASqD,CAAM,EACjBrD,EAAO,SAASqD,CAAM,EAE3BrD,EAAO,SAASsD,CAAQ,EACnBtD,EAAO,SAASsD,CAAQ,GAEjCD,EAASC,EACLD,EAAO,OAAO,CAAC,IAAM,MACnBA,EAAO,OAAO,CAAC,IAAM,KACvBA,EAASA,EAAO,MAAM,CAAC,EACvB/1B,EAAM,SAAS+1B,EAAQ,EAAE,EACzBE,EAASj2B,EAAI,SAAS,EAAE,IAExB+1B,EAASA,EAAO,MAAM,CAAC,EACvB/1B,EAAM,SAAS+1B,EAAQ,EAAE,EACzBE,EAASj2B,EAAI,SAAS,EAAE,IAG5B+1B,EAASA,EAAO,QAAQ,MAAO,EAAE,EAC7B,MAAM/1B,CAAG,GAAKi2B,EAAO,YAAW,IAAOF,GACzCnB,EAAWlC,EAAQ,0BAA0B,EACtC,IAAMA,EAAO,OAAS,KAGxB,OAAO,cAAc1yB,CAAG,EACnC,CAEE,SAASk2B,EAAiBxD,EAAQpxB,EAAG,CAC/BA,IAAM,KACRoxB,EAAO,MAAQE,EAAE,UACjBF,EAAO,iBAAmBA,EAAO,UACvB0B,EAAa9yB,CAAC,IAGxBszB,EAAWlC,EAAQ,kCAAkC,EACrDA,EAAO,SAAWpxB,EAClBoxB,EAAO,MAAQE,EAAE,KAEvB,CAEE,SAASuD,EAAQlQ,EAAOrqB,EAAG,CACzB,IAAIsR,EAAS,GACb,OAAItR,EAAIqqB,EAAM,SACZ/Y,EAAS+Y,EAAM,OAAOrqB,CAAC,GAElBsR,CACX,CAEE,SAASqmB,EAAOtN,EAAO,CACrB,IAAIyM,EAAS,KACb,GAAI,KAAK,MACP,MAAM,KAAK,MAEb,GAAIA,EAAO,OACT,OAAO7F,GAAM6F,EACX,sDAAsD,EAE1D,GAAIzM,IAAU,KACZ,OAAO7lB,GAAIsyB,CAAM,EAEf,OAAOzM,GAAU,WACnBA,EAAQA,EAAM,SAAQ,GAIxB,QAFIrqB,EAAI,EACJ0F,EAAI,GAENA,EAAI60B,EAAOlQ,EAAOrqB,GAAG,EACrB82B,EAAO,EAAIpxB,EAEP,EAACA,GAcL,OAVIoxB,EAAO,gBACTA,EAAO,WACHpxB,IAAM;AAAA,GACRoxB,EAAO,OACPA,EAAO,OAAS,GAEhBA,EAAO,UAIHA,EAAO,MAAK,CAClB,KAAKE,EAAE,MAEL,GADAF,EAAO,MAAQE,EAAE,iBACbtxB,IAAM,SACR,SAEF40B,EAAgBxD,EAAQpxB,CAAC,EACzB,SAEF,KAAKsxB,EAAE,iBACLsD,EAAgBxD,EAAQpxB,CAAC,EACzB,SAEF,KAAKsxB,EAAE,KACL,GAAIF,EAAO,SAAW,CAACA,EAAO,WAAY,CAExC,QADI0D,EAASx6B,EAAI,EACV0F,GAAKA,IAAM,KAAOA,IAAM,KAC7BA,EAAI60B,EAAOlQ,EAAOrqB,GAAG,EACjB0F,GAAKoxB,EAAO,gBACdA,EAAO,WACHpxB,IAAM;AAAA,GACRoxB,EAAO,OACPA,EAAO,OAAS,GAEhBA,EAAO,UAIbA,EAAO,UAAYzM,EAAM,UAAUmQ,EAAQx6B,EAAI,CAAC,CAC5D,CACc0F,IAAM,KAAO,EAAEoxB,EAAO,SAAWA,EAAO,YAAc,CAACA,EAAO,SAChEA,EAAO,MAAQE,EAAE,UACjBF,EAAO,iBAAmBA,EAAO,WAE7B,CAAC0B,EAAa9yB,CAAC,IAAM,CAACoxB,EAAO,SAAWA,EAAO,aACjDkC,EAAWlC,EAAQ,iCAAiC,EAElDpxB,IAAM,IACRoxB,EAAO,MAAQE,EAAE,YAEjBF,EAAO,UAAYpxB,GAGvB,SAEF,KAAKsxB,EAAE,OAEDtxB,IAAM,IACRoxB,EAAO,MAAQE,EAAE,cAEjBF,EAAO,QAAUpxB,EAEnB,SAEF,KAAKsxB,EAAE,cACDtxB,IAAM,IACRoxB,EAAO,MAAQE,EAAE,WAEjBF,EAAO,QAAU,IAAMpxB,EACvBoxB,EAAO,MAAQE,EAAE,QAEnB,SAEF,KAAKA,EAAE,UAEL,GAAItxB,IAAM,IACRoxB,EAAO,MAAQE,EAAE,UACjBF,EAAO,SAAW,WACT,CAAA0B,EAAa9yB,CAAC,EAElB,GAAIizB,EAAQP,EAAW1yB,CAAC,EAC7BoxB,EAAO,MAAQE,EAAE,SACjBF,EAAO,QAAUpxB,UACRA,IAAM,IACfoxB,EAAO,MAAQE,EAAE,UACjBF,EAAO,QAAU,WACRpxB,IAAM,IACfoxB,EAAO,MAAQE,EAAE,UACjBF,EAAO,aAAeA,EAAO,aAAe,OACvC,CAGL,GAFAkC,EAAWlC,EAAQ,aAAa,EAE5BA,EAAO,iBAAmB,EAAIA,EAAO,SAAU,CACjD,IAAIjT,EAAMiT,EAAO,SAAWA,EAAO,iBACnCpxB,EAAI,IAAI,MAAMme,CAAG,EAAE,KAAK,GAAG,EAAIne,CAC7C,CACYoxB,EAAO,UAAY,IAAMpxB,EACzBoxB,EAAO,MAAQE,EAAE,IAC7B,CACU,SAEF,KAAKA,EAAE,UACL,GAAIF,EAAO,SAAWpxB,IAAM,KAAM,CAChCoxB,EAAO,MAAQE,EAAE,QACjBF,EAAO,QAAU,GACjBA,EAAO,SAAW,GAClB,QACZ,CAEcA,EAAO,SAAWA,EAAO,UAAY,IAAQA,EAAO,UACtDA,EAAO,MAAQE,EAAE,YACjBF,EAAO,SAAW,KAAOA,EAAO,SAAWpxB,EAC3CoxB,EAAO,SAAW,KACRA,EAAO,SAAWpxB,GAAG,YAAa,IAAKsyB,GACjDP,EAASX,EAAQ,aAAa,EAC9BA,EAAO,MAAQE,EAAE,MACjBF,EAAO,SAAW,GAClBA,EAAO,MAAQ,KACLA,EAAO,SAAWpxB,GAAG,YAAa,IAAKuyB,GACjDnB,EAAO,MAAQE,EAAE,SACbF,EAAO,SAAWA,EAAO,UAC3BkC,EAAWlC,EACT,6CAA6C,EAEjDA,EAAO,QAAU,GACjBA,EAAO,SAAW,IACTpxB,IAAM,KACf+xB,EAASX,EAAQ,oBAAqBA,EAAO,QAAQ,EACrDA,EAAO,SAAW,GAClBA,EAAO,MAAQE,EAAE,OACRyB,EAAQ/yB,CAAC,IAClBoxB,EAAO,MAAQE,EAAE,kBACjBF,EAAO,UAAYpxB,GAIrB,SAEF,KAAKsxB,EAAE,iBACDtxB,IAAMoxB,EAAO,IACfA,EAAO,MAAQE,EAAE,UACjBF,EAAO,EAAI,IAEbA,EAAO,UAAYpxB,EACnB,SAEF,KAAKsxB,EAAE,QACDtxB,IAAM,KACRoxB,EAAO,MAAQE,EAAE,KACjBS,EAASX,EAAQ,YAAaA,EAAO,OAAO,EAC5CA,EAAO,QAAU,KAEjBA,EAAO,SAAWpxB,EACdA,IAAM,IACRoxB,EAAO,MAAQE,EAAE,YACRyB,EAAQ/yB,CAAC,IAClBoxB,EAAO,MAAQE,EAAE,eACjBF,EAAO,EAAIpxB,IAGf,SAEF,KAAKsxB,EAAE,eACLF,EAAO,SAAWpxB,EACdA,IAAMoxB,EAAO,IACfA,EAAO,EAAI,GACXA,EAAO,MAAQE,EAAE,SAEnB,SAEF,KAAKA,EAAE,YACDtxB,IAAM,KACRoxB,EAAO,SAAWpxB,EAClBoxB,EAAO,MAAQE,EAAE,SACRtxB,IAAM,KACfoxB,EAAO,MAAQE,EAAE,UACjBF,EAAO,iBAAmBA,EAAO,UACxB2B,EAAQ/yB,CAAC,GAClBoxB,EAAO,SAAWpxB,EAClBoxB,EAAO,MAAQE,EAAE,mBACjBF,EAAO,EAAIpxB,GAEXoxB,EAAO,SAAWpxB,EAEpB,SAEF,KAAKsxB,EAAE,mBACLF,EAAO,SAAWpxB,EACdA,IAAMoxB,EAAO,IACfA,EAAO,MAAQE,EAAE,YACjBF,EAAO,EAAI,IAEb,SAEF,KAAKE,EAAE,QACDtxB,IAAM,IACRoxB,EAAO,MAAQE,EAAE,eAEjBF,EAAO,SAAWpxB,EAEpB,SAEF,KAAKsxB,EAAE,eACDtxB,IAAM,KACRoxB,EAAO,MAAQE,EAAE,cACjBF,EAAO,QAAUgC,GAAShC,EAAO,IAAKA,EAAO,OAAO,EAChDA,EAAO,SACTW,EAASX,EAAQ,YAAaA,EAAO,OAAO,EAE9CA,EAAO,QAAU,KAEjBA,EAAO,SAAW,IAAMpxB,EACxBoxB,EAAO,MAAQE,EAAE,SAEnB,SAEF,KAAKA,EAAE,cACDtxB,IAAM,KACRszB,EAAWlC,EAAQ,mBAAmB,EAGtCA,EAAO,SAAW,KAAOpxB,EACzBoxB,EAAO,MAAQE,EAAE,SACRF,EAAO,SAAWA,EAAO,UAAY,GAC9CA,EAAO,MAAQE,EAAE,YAEjBF,EAAO,MAAQE,EAAE,KAEnB,SAEF,KAAKA,EAAE,MACDtxB,IAAM,IACRoxB,EAAO,MAAQE,EAAE,aAEjBF,EAAO,OAASpxB,EAElB,SAEF,KAAKsxB,EAAE,aACDtxB,IAAM,IACRoxB,EAAO,MAAQE,EAAE,gBAEjBF,EAAO,OAAS,IAAMpxB,EACtBoxB,EAAO,MAAQE,EAAE,OAEnB,SAEF,KAAKA,EAAE,eACDtxB,IAAM,KACJoxB,EAAO,OACTW,EAASX,EAAQ,UAAWA,EAAO,KAAK,EAE1CW,EAASX,EAAQ,cAAc,EAC/BA,EAAO,MAAQ,GACfA,EAAO,MAAQE,EAAE,MACRtxB,IAAM,IACfoxB,EAAO,OAAS,KAEhBA,EAAO,OAAS,KAAOpxB,EACvBoxB,EAAO,MAAQE,EAAE,OAEnB,SAEF,KAAKA,EAAE,UACDtxB,IAAM,IACRoxB,EAAO,MAAQE,EAAE,iBACRwB,EAAa9yB,CAAC,EACvBoxB,EAAO,MAAQE,EAAE,eAEjBF,EAAO,cAAgBpxB,EAEzB,SAEF,KAAKsxB,EAAE,eACL,GAAI,CAACF,EAAO,cAAgB0B,EAAa9yB,CAAC,EACxC,SACSA,IAAM,IACfoxB,EAAO,MAAQE,EAAE,iBAEjBF,EAAO,cAAgBpxB,EAEzB,SAEF,KAAKsxB,EAAE,iBACDtxB,IAAM,KACR+xB,EAASX,EAAQ,0BAA2B,CAC1C,KAAMA,EAAO,aACb,KAAMA,EAAO,YACd,GACDA,EAAO,aAAeA,EAAO,aAAe,GAC5CA,EAAO,MAAQE,EAAE,OAEjBF,EAAO,cAAgB,IAAMpxB,EAC7BoxB,EAAO,MAAQE,EAAE,gBAEnB,SAEF,KAAKA,EAAE,SACD2B,EAAQN,EAAU3yB,CAAC,EACrBoxB,EAAO,SAAWpxB,GAElBuzB,GAAOnC,CAAM,EACTpxB,IAAM,IACRg0B,GAAQ5C,CAAM,EACLpxB,IAAM,IACfoxB,EAAO,MAAQE,EAAE,gBAEZwB,EAAa9yB,CAAC,GACjBszB,EAAWlC,EAAQ,+BAA+B,EAEpDA,EAAO,MAAQE,EAAE,SAGrB,SAEF,KAAKA,EAAE,eACDtxB,IAAM,KACRg0B,GAAQ5C,EAAQ,EAAI,EACpB+C,GAAS/C,CAAM,IAEfkC,EAAWlC,EAAQ,gDAAgD,EACnEA,EAAO,MAAQE,EAAE,QAEnB,SAEF,KAAKA,EAAE,OAEL,GAAIwB,EAAa9yB,CAAC,EAChB,SACSA,IAAM,IACfg0B,GAAQ5C,CAAM,EACLpxB,IAAM,IACfoxB,EAAO,MAAQE,EAAE,eACR2B,EAAQP,EAAW1yB,CAAC,GAC7BoxB,EAAO,WAAapxB,EACpBoxB,EAAO,YAAc,GACrBA,EAAO,MAAQE,EAAE,aAEjBgC,EAAWlC,EAAQ,wBAAwB,EAE7C,SAEF,KAAKE,EAAE,YACDtxB,IAAM,IACRoxB,EAAO,MAAQE,EAAE,aACRtxB,IAAM,KACfszB,EAAWlC,EAAQ,yBAAyB,EAC5CA,EAAO,YAAcA,EAAO,WAC5B0C,GAAO1C,CAAM,EACb4C,GAAQ5C,CAAM,GACL0B,EAAa9yB,CAAC,EACvBoxB,EAAO,MAAQE,EAAE,sBACR2B,EAAQN,EAAU3yB,CAAC,EAC5BoxB,EAAO,YAAcpxB,EAErBszB,EAAWlC,EAAQ,wBAAwB,EAE7C,SAEF,KAAKE,EAAE,sBACL,GAAItxB,IAAM,IACRoxB,EAAO,MAAQE,EAAE,iBACZ,IAAIwB,EAAa9yB,CAAC,EACvB,SAEAszB,EAAWlC,EAAQ,yBAAyB,EAC5CA,EAAO,IAAI,WAAWA,EAAO,UAAU,EAAI,GAC3CA,EAAO,YAAc,GACrBW,EAASX,EAAQ,cAAe,CAC9B,KAAMA,EAAO,WACb,MAAO,EACR,GACDA,EAAO,WAAa,GAChBpxB,IAAM,IACRg0B,GAAQ5C,CAAM,EACL6B,EAAQP,EAAW1yB,CAAC,GAC7BoxB,EAAO,WAAapxB,EACpBoxB,EAAO,MAAQE,EAAE,cAEjBgC,EAAWlC,EAAQ,wBAAwB,EAC3CA,EAAO,MAAQE,EAAE,QAGrB,SAEF,KAAKA,EAAE,aACL,GAAIwB,EAAa9yB,CAAC,EAChB,SACS+yB,EAAQ/yB,CAAC,GAClBoxB,EAAO,EAAIpxB,EACXoxB,EAAO,MAAQE,EAAE,sBAEZF,EAAO,IAAI,yBACd7F,GAAM6F,EAAQ,0BAA0B,EAE1CA,EAAO,MAAQE,EAAE,sBACjBF,EAAO,YAAcpxB,GAEvB,SAEF,KAAKsxB,EAAE,oBACL,GAAItxB,IAAMoxB,EAAO,EAAG,CACdpxB,IAAM,IACRoxB,EAAO,MAAQE,EAAE,sBAEjBF,EAAO,aAAepxB,EAExB,QACZ,CACU8zB,GAAO1C,CAAM,EACbA,EAAO,EAAI,GACXA,EAAO,MAAQE,EAAE,oBACjB,SAEF,KAAKA,EAAE,oBACDwB,EAAa9yB,CAAC,EAChBoxB,EAAO,MAAQE,EAAE,OACRtxB,IAAM,IACfg0B,GAAQ5C,CAAM,EACLpxB,IAAM,IACfoxB,EAAO,MAAQE,EAAE,eACR2B,EAAQP,EAAW1yB,CAAC,GAC7BszB,EAAWlC,EAAQ,kCAAkC,EACrDA,EAAO,WAAapxB,EACpBoxB,EAAO,YAAc,GACrBA,EAAO,MAAQE,EAAE,aAEjBgC,EAAWlC,EAAQ,wBAAwB,EAE7C,SAEF,KAAKE,EAAE,sBACL,GAAI,CAAC0B,EAAYhzB,CAAC,EAAG,CACfA,IAAM,IACRoxB,EAAO,MAAQE,EAAE,sBAEjBF,EAAO,aAAepxB,EAExB,QACZ,CACU8zB,GAAO1C,CAAM,EACTpxB,IAAM,IACRg0B,GAAQ5C,CAAM,EAEdA,EAAO,MAAQE,EAAE,OAEnB,SAEF,KAAKA,EAAE,UACL,GAAKF,EAAO,QAaDpxB,IAAM,IACfm0B,GAAS/C,CAAM,EACN6B,EAAQN,EAAU3yB,CAAC,EAC5BoxB,EAAO,SAAWpxB,EACToxB,EAAO,QAChBA,EAAO,QAAU,KAAOA,EAAO,QAC/BA,EAAO,QAAU,GACjBA,EAAO,MAAQE,EAAE,SAEZwB,EAAa9yB,CAAC,GACjBszB,EAAWlC,EAAQ,gCAAgC,EAErDA,EAAO,MAAQE,EAAE,yBAzBE,CACnB,GAAIwB,EAAa9yB,CAAC,EAChB,SACSkzB,EAASR,EAAW1yB,CAAC,EAC1BoxB,EAAO,QACTA,EAAO,QAAU,KAAOpxB,EACxBoxB,EAAO,MAAQE,EAAE,QAEjBgC,EAAWlC,EAAQ,iCAAiC,EAGtDA,EAAO,QAAUpxB,CAE/B,CAcU,SAEF,KAAKsxB,EAAE,oBACL,GAAIwB,EAAa9yB,CAAC,EAChB,SAEEA,IAAM,IACRm0B,GAAS/C,CAAM,EAEfkC,EAAWlC,EAAQ,mCAAmC,EAExD,SAEF,KAAKE,EAAE,YACP,KAAKA,EAAE,sBACP,KAAKA,EAAE,sBACL,IAAIyD,EACAv3B,EACJ,OAAQ4zB,EAAO,MAAK,CAClB,KAAKE,EAAE,YACLyD,EAAczD,EAAE,KAChB9zB,EAAS,WACT,MAEF,KAAK8zB,EAAE,sBACLyD,EAAczD,EAAE,oBAChB9zB,EAAS,cACT,MAEF,KAAK8zB,EAAE,sBACLyD,EAAczD,EAAE,sBAChB9zB,EAAS,cACT,KACd,CAEU,GAAIwC,IAAM,IAAK,CACb,IAAIg1B,EAAeR,EAAYpD,CAAM,EACjCA,EAAO,IAAI,kBAAoB,CAAC,OAAO,OAAOP,EAAI,YAAY,EAAE,SAASmE,CAAY,GACvF5D,EAAO,OAAS,GAChBA,EAAO,MAAQ2D,EACf3D,EAAO,MAAM4D,CAAY,IAEzB5D,EAAO5zB,CAAM,GAAKw3B,EAClB5D,EAAO,OAAS,GAChBA,EAAO,MAAQ2D,EAE7B,MAAqB9B,EAAQ7B,EAAO,OAAO,OAASyB,EAAaD,EAAa5yB,CAAC,EACnEoxB,EAAO,QAAUpxB,GAEjBszB,EAAWlC,EAAQ,kCAAkC,EACrDA,EAAO5zB,CAAM,GAAK,IAAM4zB,EAAO,OAASpxB,EACxCoxB,EAAO,OAAS,GAChBA,EAAO,MAAQ2D,GAGjB,SAEF,QACE,MAAM,IAAI,MAAM3D,EAAQ,kBAAoBA,EAAO,KAAK,CAElE,CAGI,OAAIA,EAAO,UAAYA,EAAO,qBAC5BO,EAAkBP,CAAM,EAEnBA,CACX,CAIO,OAAO,gBACT,UAAY,CACX,IAAI6D,EAAqB,OAAO,aAC5BjrB,EAAQ,KAAK,MACbkrB,EAAgB,UAAY,CAC9B,IAAIC,EAAW,MACXC,EAAY,GACZC,EACAC,EACAh5B,EAAQ,GACRwE,EAAS,UAAU,OACvB,GAAI,CAACA,EACH,MAAO,GAGT,QADI8K,EAAS,GACN,EAAEtP,EAAQwE,GAAQ,CACvB,IAAIwE,EAAY,OAAO,UAAUhJ,CAAK,CAAC,EACvC,GACE,CAAC,SAASgJ,CAAS,GACnBA,EAAY,GACZA,EAAY,SACZ0E,EAAM1E,CAAS,IAAMA,EAErB,MAAM,WAAW,uBAAyBA,CAAS,EAEjDA,GAAa,MACf8vB,EAAU,KAAK9vB,CAAS,GAGxBA,GAAa,MACb+vB,GAAiB/vB,GAAa,IAAM,MACpCgwB,EAAgBhwB,EAAY,KAAS,MACrC8vB,EAAU,KAAKC,EAAeC,CAAY,IAExCh5B,EAAQ,IAAMwE,GAAUs0B,EAAU,OAASD,KAC7CvpB,GAAUqpB,EAAmB,MAAM,KAAMG,CAAS,EAClDA,EAAU,OAAS,EAE/B,CACQ,OAAOxpB,CACf,EAEU,OAAO,eACT,OAAO,eAAe,OAAQ,gBAAiB,CAC7C,MAAOspB,EACP,aAAc,GACd,SAAU,EACX,GAED,OAAO,cAAgBA,CAE/B,GAAO,CAEN,GAAmD33B,CAAO,wCCpgDrDg4B,GAAmB,CACrB,6BAA8B,CAC1B,IAAK,MACL,KAAM,eACT,EACD,+BAAgC,CAC5B,IAAK,QACL,KAAM,uBACT,EACD,iCAAkC,CAC9B,IAAK,MACL,KAAM,sCACT,EACD,6BAA8B,CAC1B,IAAK,MACL,KAAM,qBACd,CACA,EAMMC,GAAkB,CACpB,IAAK,CACD,IAAK,MACL,KAAM,qBACT,EACD,iBAAkB,CACd,IAAK,WACL,KAAM,wCACT,EACD,IAAK,CACD,IAAK,MACL,KAAM,eACd,CACA,EACO,MAAMC,EAAgB,CACzB,YAAYpU,EAAS,CACjB,KAAK,QAAUA,GAAW,CAAE,EAC5B,KAAK,SAAW,GAChB,KAAK,MAAQ,GACb,KAAK,OAASwP,GAAI,OAAO,GAAM,CAAE,MAAO,GAAM,EAC9C,KAAK,QAAU,EACf,KAAK,OAAO,QAAUpxB,GAAK,CACnBA,EAAE,QAAQ,WAAW,0BAA0B,IAGnD,KAAK,SAAW,OAChB,KAAK,MAAQ,GAChB,EACD,KAAK,OAAO,UAAYi2B,GAAQ,CAC5B,EAAE,KAAK,QACH,EAAC,MAAK,UAAY,KAAK,SAG3B,KAAK,SAAW,GACZA,EAAK,IAEL,KAAK,SAAWH,GAAiBG,EAAK,GAAG,EAEpCA,EAAK,OAEV,KAAK,SAAWF,GAAgBE,EAAK,KAAK,YAAW,CAAE,GAEvD,KAAK,UAAY,CAAC,KAAK,QAAQ,WAC/B,KAAK,MAAQ,IAEpB,EACD,KAAK,OAAO,WAAa,IAAM,CAC3B,EAAE,KAAK,OACV,CACT,CACI,MAAMrC,EAAM,CACR,KAAK,OAAO,MAAMA,CAAI,CAC9B,CACI,OAAQ,CACJ,KAAK,OAAO,MAAO,EACnB,KAAK,MAAQ,EACrB,CACI,SAAU,CACN,OAAO,KAAK,UAAY,CAChC,CACA,CCzIe,SAASsC,GAAM3zB,EAAQ,CAAC,SAAA4zB,EAAW,EAAI,EAAI,GAAI,CAC7D,GAAI,OAAO5zB,GAAW,SACrB,MAAM,IAAI,UAAU,gCAAgC,OAAOA,CAAM,IAAI,EAKtE,GAFAA,EAASA,EAAO,KAAM,EAElBA,EAAO,SAAW,EACrB,MAAO,GAGR,MAAM6zB,EAAkB,IAAIJ,GAAgB,CAAC,SAAUG,CAAQ,CAAC,EAEhE,GAAIA,GAGH,GAFAC,EAAgB,MAAM7zB,CAAM,EAExB,CAAC6zB,EAAgB,UACpB,MAAO,OAEF,CAGN,IAAIx2B,EAAS,EACb,KAAO2C,EAAO,OAAS3C,GAAU,CAACw2B,EAAgB,OACjDA,EAAgB,MAAM7zB,EAAO,MAAM3C,EAAQ,KAAK,IAAIA,EAAS,IAAW2C,EAAO,MAAM,CAAC,CAAC,EACvF3C,GAAU,GAEb,CAEC,OAAOw2B,EAAgB,UAAU,MAAQ,KAC1C,CCugBA,SAASC,GAAmBC,EAAK,CAG/B,GAFAC,GAAmBD,CAAG,EACtBj9B,GAAc,mBAAqC,IAAI,IACnDA,GAAc,iBAAiB,IAAIi9B,EAAI,EAAE,EAAG,CAC9Ch9B,GAAO,KAAK,wBAAwBg9B,EAAI,EAAE,iCAAiC,EAC3E,MACJ,CACEj9B,GAAc,iBAAiB,IAAIi9B,EAAI,GAAIA,CAAG,EAC9Ch9B,GAAO,MAAM,4BAA4Bg9B,EAAI,EAAE,eAAe,CAChE,CAOA,SAASC,GAAmBD,EAAK,CAC/B,GAAI,OAAOA,GAAQ,SACjB,MAAM,IAAI,MAAM,8BAA8B,EAEhD,GAAI,CAACA,EAAI,IAAM,OAAOA,EAAI,IAAO,UAAYA,EAAI,KAAO,IAAI,OAAOA,EAAI,EAAE,EACvE,MAAM,IAAI,MAAM,oFAAoF,EAEtG,GAAI,CAACA,EAAI,SAAW,OAAOA,EAAI,SAAY,SACzC,MAAM,IAAI,MAAM,gDAAgD,EAElE,GAAI,CAACA,EAAI,QAAQ,MAAM,oBAAoB,EACzC,MAAM,IAAI,MAAM,kCAAkC,EAEpD,GAAI,CAACA,EAAI,aAAe,OAAOA,EAAI,aAAgB,SACjD,MAAM,IAAI,MAAM,sCAAsC,EAExD,GAAI,OAAOA,EAAI,eAAkB,UAAY,CAACJ,GAAMI,EAAI,aAAa,EACnE,MAAM,IAAI,MAAM,6CAA6C,EAE/D,GAAI,OAAOA,EAAI,OAAU,SACvB,MAAM,IAAI,MAAM,+CAA+C,EAEjE,GAAIA,EAAI,SAAW,OAAOA,EAAI,SAAY,WACxC,MAAM,IAAI,MAAM,yCAAyC,EAE3D,GAAIA,EAAI,QAAU,OAAOA,EAAI,QAAW,WACtC,MAAM,IAAI,MAAM,wCAAwC,CAE5D,CCzkBA,MAAME,GAAgB,6BAElB,OAAO,eAAe,IAAIA,EAAa,IAAM,SAChD,OAAO,eAAe,OACrBA,GACAC,GAAoBC,GAAqB,IAAMC,GAAA,WAAO,kCAAyB,qDAAC,EAAG,CAAE,WAAY,EAAO,EACzG,EAEmBN,GAAA,CAClB,GAAI,WACJ,MAAO,GACP,YAAa1B,GAAE,WAAY,UAAU,EACrC,cAAeiC,GACf,QAASJ,GACT,SAAU,CACF,SACR,CACA","names":["lightningBoltSVG","scopedGlobals","logger","getLoggerBuilder","R","ReflectApply","target","receiver","args","ReflectOwnKeys","ProcessEmitWarning","warning","NumberIsNaN","value","EventEmitter","eventsModule","once","defaultMaxListeners","checkListener","listener","arg","n","_getMaxListeners","that","type","i","doError","events","er","err","handler","len","listeners","arrayClone","_addListener","prepend","m","existing","w","onceWrapper","_onceWrap","state","wrapped","list","position","originalListener","spliceOne","keys","key","_listeners","unwrap","evlistener","unwrapListeners","emitter","listenerCount","arr","copy","index","ret","name","resolve","reject","errorListener","resolver","eventTargetAgnosticAddListener","addErrorHandlerIfEventEmitter","flags","wrapListener","inherits_browserModule","ctor","superCtor","TempCtor","streamBrowser","require$$0","exports","buffer","base64Js","byteLength","toByteArray","fromByteArray","lookup","revLookup","Arr","code","getLens","b64","validLen","placeHoldersLen","lens","_byteLength","tmp","curByte","tripletToBase64","num","encodeChunk","uint8","start","end","output","extraBytes","parts","maxChunkLength","len2","ieee754","offset","isLE","mLen","nBytes","e","eLen","eMax","eBias","nBits","d","s","c","rt","base64","ieee754$1","customInspectSymbol","Buffer","SlowBuffer","K_MAX_LENGTH","GlobalUint8Array","GlobalArrayBuffer","GlobalSharedArrayBuffer","typedArraySupport","proto","createBuffer","length","buf","encodingOrOffset","allocUnsafe","from","fromString","fromArrayView","isInstance","fromArrayBuffer","valueOf","b","fromObject","assertSize","size","alloc","fill","encoding","checked","string","actual","fromArrayLike","array","arrayView","byteOffset","obj","numberIsNaN","a","x","y","pos","mustMatch","loweredCase","utf8ToBytes","base64ToBytes","slowToString","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","str","max","thisStart","thisEnd","thisCopy","targetCopy","bidirectionalIndexOf","val","dir","arrayIndexOf","indexSize","arrLength","valLength","read","foundIndex","found","j","hexWrite","remaining","strLen","parsed","utf8Write","blitBuffer","asciiWrite","asciiToBytes","base64Write","ucs2Write","utf16leToBytes","res","firstByte","codePoint","bytesPerSequence","secondByte","thirdByte","fourthByte","tempCodePoint","decodeCodePointsArray","MAX_ARGUMENTS_LENGTH","codePoints","out","hexSliceLookupTable","bytes","newBuf","checkOffset","ext","noAssert","mul","defineBigIntMethod","validateNumber","first","last","boundsError","lo","hi","checkInt","min","maxBytes","wrtBigUInt64LE","checkIntBI","wrtBigUInt64BE","limit","sub","checkIEEE754","writeFloat","littleEndian","writeDouble","targetStart","errors","E","sym","getMessage","Base","range","input","msg","received","addNumericalSeparator","checkBounds","INVALID_BASE64_RE","base64clean","units","leadSurrogate","byteArray","src","dst","alphabet","table","i16","fn","BufferBigIntNotDefined","shams","symObj","symVal","_","syms","descriptor","hasSymbols","esObjectAtoms","esErrors","_eval","ref","syntax","uri","abs","floor","pow","round","_isNaN","$isNaN","sign","number","gOPD","$gOPD","gopd","$defineProperty","esDefineProperty","origSymbol","hasSymbolSham","Reflect_getPrototypeOf","$Object","Object_getPrototypeOf","ERROR_MESSAGE","toStr","funcType","concatty","slicy","arrLike","joiny","joiner","implementation","bound","binder","result","boundLength","boundArgs","Empty","functionBind","functionCall","functionApply","reflectApply","bind","$apply","require$$1","$call","require$$2","$reflectApply","require$$3","actualApply","$TypeError","$actualApply","callBindApplyHelpers","callBind","hasProtoAccessor","desc","$getPrototypeOf","get","reflectGetProto","originalGetProto","getDunderProto","getProto","O","call","$hasOwn","hasown","undefined","$Error","$EvalError","$RangeError","$ReferenceError","require$$4","$SyntaxError","require$$5","require$$6","$URIError","require$$7","require$$8","require$$9","require$$10","require$$11","require$$12","require$$13","require$$14","$Function","getEvalledConstructor","expressionSyntax","require$$15","require$$16","throwTypeError","ThrowTypeError","require$$17","require$$18","$ObjectGPO","require$$19","$ReflectGPO","require$$20","require$$21","require$$22","needsEval","TypedArray","INTRINSICS","errorProto","doEval","gen","LEGACY_ALIASES","require$$23","hasOwn","require$$24","$concat","$spliceApply","$replace","$strSlice","$exec","rePropName","reEscapeChar","stringToPath","match","quote","subString","getBaseIntrinsic","allowMissing","intrinsicName","alias","getIntrinsic","intrinsicBaseName","intrinsic","intrinsicRealName","skipFurtherCaching","isOwn","part","GetIntrinsic","callBindBasic","$indexOf","callBound","hasToStringTag","$toString","isStandardArguments","isLegacyArguments","supportsStandardArguments","isArguments","isRegexMarker","throwRegexMarker","badStringifier","hasLastIndexDataProperty","regexClass","isRegex","safeRegexTest","regex","cached","generatorFunction","isFnRegex","fnToStr","getGeneratorFunction","isGeneratorFunction","GeneratorFunction","badArrayLike","isCallableMarker","constructorRegex","isES6ClassFn","fnStr","tryFunctionObject","objectClass","fnClass","genClass","ddaClass","ddaClass2","ddaClass3","isIE68","isDDA","all","isCallable","strClass","hasOwnProperty","forEachArray","iterator","forEachString","forEachObject","object","k","isArray","forEach","thisArg","possibleTypedArrayNames","possibleNames","g","global","availableTypedArrays","defineDataProperty","property","nonEnumerable","nonWritable","nonConfigurable","loose","hasPropertyDescriptors","hasPropertyDescriptors_1","define","hasDescriptors","$floor","setFunctionLength","functionLengthIsConfigurable","functionLengthIsWritable","applyBind","module","originalFunction","func","adjustedLength","typedArrays","$slice","cache","typedArray","superProto","tryTypedArrays","getter","trySlices","whichTypedArray","tag","isTypedArray","isArgumentsObject","uncurryThis","f","BigIntSupported","SymbolSupported","ObjectToString","numberValue","stringValue","booleanValue","bigIntValue","symbolValue","checkBoxedPrimitive","prototypeValueOf","isPromise","isArrayBufferView","isDataView","isUint8Array","isUint8ClampedArray","isUint16Array","isUint32Array","isInt8Array","isInt16Array","isInt32Array","isFloat32Array","isFloat64Array","isBigInt64Array","isBigUint64Array","isMapToString","isMap","isSetToString","isSet","isWeakMapToString","isWeakMap","isWeakSetToString","isWeakSet","isArrayBufferToString","isArrayBuffer","isDataViewToString","SharedArrayBufferCopy","isSharedArrayBufferToString","isSharedArrayBuffer","isAsyncFunction","isMapIterator","isSetIterator","isGeneratorObject","isWebAssemblyCompiledModule","isNumberObject","isStringObject","isBooleanObject","isBigIntObject","isSymbolObject","isBoxedPrimitive","isAnyArrayBuffer","method","isBufferBrowser","getOwnPropertyDescriptors","descriptors","formatRegExp","isString","objects","inspect","isNull","isObject","process","warned","deprecated","debugs","debugEnvRegex","define_process_env_default","debugEnv","set","pid","opts","ctx","stylizeNoColor","isBoolean","isUndefined","stylizeWithColor","formatValue","styleType","style","arrayToHash","hash","idx","recurseTimes","isFunction","primitive","formatPrimitive","visibleKeys","isError","formatError","isRegExp","isDate","base","braces","formatArray","formatProperty","reduceToSingleString","simple","isNumber","l","line","prev","cur","ar","isNullOrUndefined","isSymbol","re","objectToString","isPrimitive","o","pad","months","timestamp","time","origin","add","prop","kCustomPromisifiedSymbol","original","promiseResolve","promiseReject","promise","callbackifyOnRejected","reason","cb","newReason","callbackify","callbackified","maybeCb","self","rej","ownKeys","enumerableOnly","symbols","_objectSpread","source","_defineProperty","_toPropertyKey","_classCallCheck","instance","Constructor","_defineProperties","props","_createClass","protoProps","staticProps","_toPrimitive","hint","prim","_require","_require2","custom","copyBuffer","buffer_list","BufferList","v","entry","p","hasStrings","nb","options","destroy","_this","readableDestroyed","writableDestroyed","emitErrorNT","emitCloseNT","emitErrorAndCloseNT","undestroy","errorOrDestroy","stream","rState","wState","destroy_1","_inheritsLoose","subClass","superClass","codes","createErrorType","message","arg1","arg2","arg3","NodeError","_Base","oneOf","expected","thing","startsWith","search","endsWith","this_len","includes","determiner","errorsBrowser","ERR_INVALID_OPT_VALUE","highWaterMarkFrom","isDuplex","duplexKey","getHighWaterMark","hwm","browser","deprecate","config","_stream_writable","Writable","CorkedRequest","onCorkedFinish","Duplex","WritableState","internalUtil","Stream","OurUint8Array","_uint8ArrayToBuffer","chunk","_isUint8Array","destroyImpl","_require$codes","ERR_INVALID_ARG_TYPE","ERR_METHOD_NOT_IMPLEMENTED","ERR_MULTIPLE_CALLBACK","ERR_STREAM_CANNOT_PIPE","ERR_STREAM_DESTROYED","ERR_STREAM_NULL_VALUES","ERR_STREAM_WRITE_AFTER_END","ERR_UNKNOWN_ENCODING","nop","noDecode","onwrite","current","realHasInstance","writeAfterEnd","validChunk","isBuf","writeOrBuffer","clearBuffer","decodeChunk","newChunk","doWrite","writev","onwriteError","sync","finishMaybe","onwriteStateUpdate","finished","needFinish","afterWrite","onwriteDrain","holder","count","allBuffers","endWritable","callFinal","prefinish","need","corkReq","objectKeys","_stream_duplex","Readable","onend","onEndNT","copyProps","SafeBuffer","isEncoding","_normalizeEncoding","enc","retried","normalizeEncoding","nenc","string_decoder","StringDecoder","utf16Text","utf16End","utf8FillLast","base64Text","base64End","simpleWrite","simpleEnd","r","utf8End","utf8Text","utf8CheckByte","byte","utf8CheckIncomplete","utf8CheckExtraBytes","total","ERR_STREAM_PREMATURE_CLOSE","callback","called","_len","_key","noop","isRequest","eos","readable","writable","onlegacyfinish","onfinish","writableEnded","readableEnded","onerror","onclose","onrequest","endOfStream","_Object$setPrototypeO","kLastResolve","kLastReject","kError","kEnded","kLastPromise","kHandlePromise","kStream","createIterResult","done","readAndResolve","iter","data","onReadable","wrapForNext","lastPromise","AsyncIteratorPrototype","ReadableStreamAsyncIteratorPrototype","error","_this2","createReadableStreamAsyncIterator","_Object$create","async_iterator","fromBrowser","_stream_readable","ReadableState","EElistenerCount","debugUtil","debug","ERR_STREAM_PUSH_AFTER_EOF","ERR_STREAM_UNSHIFT_AFTER_END_EVENT","kProxyEvents","prependListener","event","skipChunkCheck","readableAddChunk","addToFront","onEofChunk","chunkInvalid","addChunk","maybeReadMore","emitReadable","decoder","content","MAX_HWM","computeNewHighWaterMark","howMuchToRead","nOrig","endReadable","doRead","fromList","emitReadable_","flow","maybeReadMore_","dest","pipeOpts","doEnd","endFn","unpipe","onunpipe","unpipeInfo","cleanup","ondrain","pipeOnDrain","cleanedUp","ondata","indexOf","dests","ev","nReadingNextTick","updateReadableListening","resume","resume_","paused","endReadableNT","iterable","xs","_stream_transform","Transform","ERR_TRANSFORM_ALREADY_TRANSFORMING","ERR_TRANSFORM_WITH_LENGTH_0","afterTransform","ts","rs","err2","_stream_passthrough","PassThrough","ERR_MISSING_ARGS","destroyer","reading","writing","closed","destroyed","pipe","to","popCallback","streams","pipeline","destroys","pipeline_1","streamBrowserify","EE","inherits","didOnEnd","sax","strict","opt","SAXParser","SAXStream","createStream","buffers","parser","clearBuffers","S","rootNS","emit","F","newf","checkBufferLength","maxAllowed","maxActual","closeText","emitNode","flushBuffers","write","streamWraps","me","h","SD","CDATA","DOCTYPE","XML_NAMESPACE","XMLNS_NAMESPACE","nameStart","nameBody","entityStart","entityBody","isWhitespace","isQuote","isAttribEnd","isMatch","notMatch","nodeType","textopts","text","strictFail","newTag","parent","qname","attribute","qualName","prefix","local","attrib","qn","openTag","selfClosing","nv","closeTag","t","tagName","closeTo","close","parseEntity","entity","entityLC","numStr","beginWhiteSpace","charAt","starti","returnState","parsedEntity","stringFromCharCode","fromCodePoint","MAX_SIZE","codeUnits","highSurrogate","lowSurrogate","namespaceMapping","rootNameMapping","XmlTextDetector","node","isSvg","validate","xmlTextDetector","registerSidebarTab","tab","validateSidebarTab","sidebarTabTag","defineCustomElement","defineAsyncComponent","__vitePreload","LightningBolt"],"ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81],"sources":["../node_modules/@mdi/svg/svg/lightning-bolt.svg?raw","../node_modules/@nextcloud/files/dist/chunks/folder-29HuacU_.mjs","../node_modules/events/events.js","../node_modules/inherits/inherits_browser.js","../node_modules/readable-stream/lib/internal/streams/stream-browser.js","../node_modules/vite-plugin-node-polyfills/shims/buffer/dist/index.cjs","../node_modules/has-symbols/shams.js","../node_modules/has-tostringtag/shams.js","../node_modules/es-object-atoms/index.js","../node_modules/es-errors/index.js","../node_modules/es-errors/eval.js","../node_modules/es-errors/range.js","../node_modules/es-errors/ref.js","../node_modules/es-errors/syntax.js","../node_modules/es-errors/type.js","../node_modules/es-errors/uri.js","../node_modules/math-intrinsics/abs.js","../node_modules/math-intrinsics/floor.js","../node_modules/math-intrinsics/max.js","../node_modules/math-intrinsics/min.js","../node_modules/math-intrinsics/pow.js","../node_modules/math-intrinsics/round.js","../node_modules/math-intrinsics/isNaN.js","../node_modules/math-intrinsics/sign.js","../node_modules/gopd/gOPD.js","../node_modules/gopd/index.js","../node_modules/es-define-property/index.js","../node_modules/has-symbols/index.js","../node_modules/get-proto/Reflect.getPrototypeOf.js","../node_modules/get-proto/Object.getPrototypeOf.js","../node_modules/function-bind/implementation.js","../node_modules/function-bind/index.js","../node_modules/call-bind-apply-helpers/functionCall.js","../node_modules/call-bind-apply-helpers/functionApply.js","../node_modules/call-bind-apply-helpers/reflectApply.js","../node_modules/call-bind-apply-helpers/actualApply.js","../node_modules/call-bind-apply-helpers/index.js","../node_modules/dunder-proto/get.js","../node_modules/get-proto/index.js","../node_modules/hasown/index.js","../node_modules/get-intrinsic/index.js","../node_modules/call-bound/index.js","../node_modules/is-arguments/index.js","../node_modules/is-regex/index.js","../node_modules/safe-regex-test/index.js","../node_modules/generator-function/index.js","../node_modules/is-generator-function/index.js","../node_modules/is-callable/index.js","../node_modules/for-each/index.js","../node_modules/possible-typed-array-names/index.js","../node_modules/available-typed-arrays/index.js","../node_modules/define-data-property/index.js","../node_modules/has-property-descriptors/index.js","../node_modules/set-function-length/index.js","../node_modules/call-bind-apply-helpers/applyBind.js","../node_modules/call-bind/index.js","../node_modules/which-typed-array/index.js","../node_modules/is-typed-array/index.js","../node_modules/util/support/types.js","../node_modules/util/support/isBufferBrowser.js","../node_modules/util/util.js","../node_modules/readable-stream/lib/internal/streams/buffer_list.js","../node_modules/readable-stream/lib/internal/streams/destroy.js","../node_modules/readable-stream/errors-browser.js","../node_modules/readable-stream/lib/internal/streams/state.js","../node_modules/util-deprecate/browser.js","../node_modules/readable-stream/lib/_stream_writable.js","../node_modules/readable-stream/lib/_stream_duplex.js","../node_modules/safe-buffer/index.js","../node_modules/string_decoder/lib/string_decoder.js","../node_modules/readable-stream/lib/internal/streams/end-of-stream.js","../node_modules/readable-stream/lib/internal/streams/async_iterator.js","../node_modules/readable-stream/lib/internal/streams/from-browser.js","../node_modules/readable-stream/lib/_stream_readable.js","../node_modules/readable-stream/lib/_stream_transform.js","../node_modules/readable-stream/lib/_stream_passthrough.js","../node_modules/readable-stream/lib/internal/streams/pipeline.js","../node_modules/stream-browserify/index.js","../node_modules/sax/lib/sax.js","../node_modules/@file-type/xml/lib/index.js","../node_modules/is-svg/index.js","../node_modules/@nextcloud/files/dist/index.mjs","../src/sidebar.ts"],"sourcesContent":["export default \"<svg xmlns=\\\"http://www.w3.org/2000/svg\\\" id=\\\"mdi-lightning-bolt\\\" viewBox=\\\"0 0 24 24\\\"><path d=\\\"M11 15H6L13 1V9H18L11 23V15Z\\\" /></svg>\"","import { getLoggerBuilder } from \"@nextcloud/logger\";\nimport { join, encodePath, basename, extname, dirname } from \"@nextcloud/paths\";\nwindow._nc_files_scope ??= {};\nwindow._nc_files_scope.v4_0 ??= {};\nconst scopedGlobals = window._nc_files_scope.v4_0;\nconst logger = getLoggerBuilder().setApp(\"@nextcloud/files\").detectUser().build();\nconst FileType = Object.freeze({\n Folder: \"folder\",\n File: \"file\"\n});\nconst Permission = Object.freeze({\n /**\n * No permissions granted\n */\n NONE: 0,\n /**\n * Can read the file content\n */\n READ: 1,\n /**\n * Can modify the file itself (move, rename, etc)\n */\n UPDATE: 2,\n /**\n * Can create new files/folders inside a folder\n */\n CREATE: 4,\n /**\n * Can change the file content\n */\n WRITE: 4,\n /**\n * Can delete the node\n */\n DELETE: 8,\n /**\n * Can share the node\n */\n SHARE: 16,\n /**\n * All permissions are granted\n */\n ALL: 31\n});\nconst NodeStatus = Object.freeze({\n /** This is a new node and it doesn't exists on the filesystem yet */\n NEW: \"new\",\n /** This node has failed and is unavailable */\n FAILED: \"failed\",\n /** This node is currently loading or have an operation in progress */\n LOADING: \"loading\",\n /** This node is locked and cannot be modified */\n LOCKED: \"locked\"\n});\nfunction isDavResource(source, davService) {\n return source.match(davService) !== null;\n}\nfunction validateData(data, davService) {\n if (data.id && typeof data.id !== \"number\" && typeof data.id !== \"string\") {\n throw new Error(\"Invalid id type of value\");\n }\n if (!data.source) {\n throw new Error(\"Missing mandatory source\");\n }\n try {\n new URL(data.source);\n } catch {\n throw new Error(\"Invalid source format, source must be a valid URL\");\n }\n if (!data.source.startsWith(\"http\")) {\n throw new Error(\"Invalid source format, only http(s) is supported\");\n }\n if (!data.root) {\n throw new Error(\"Missing mandatory root\");\n }\n if (typeof data.root !== \"string\") {\n throw new Error(\"Invalid root type\");\n }\n if (!data.root.startsWith(\"/\")) {\n throw new Error(\"Root must start with a leading slash\");\n }\n if (!data.source.includes(data.root)) {\n throw new Error(\"Root must be part of the source\");\n }\n if (isDavResource(data.source, davService)) {\n const service = data.source.match(davService)[0];\n if (!data.source.includes(join(service, data.root))) {\n throw new Error(\"The root must be relative to the service. e.g /files/emma\");\n }\n }\n if (data.displayname && typeof data.displayname !== \"string\") {\n throw new Error(\"Invalid displayname type\");\n }\n if (data.mtime && !(data.mtime instanceof Date)) {\n throw new Error(\"Invalid mtime type\");\n }\n if (data.crtime && !(data.crtime instanceof Date)) {\n throw new Error(\"Invalid crtime type\");\n }\n if (!data.mime || typeof data.mime !== \"string\" || !data.mime.match(/^[-\\w.]+\\/[-+\\w.]+$/gi)) {\n throw new Error(\"Missing or invalid mandatory mime\");\n }\n if (\"size\" in data && typeof data.size !== \"number\" && data.size !== void 0) {\n throw new Error(\"Invalid size type\");\n }\n if (\"permissions\" in data && data.permissions !== void 0 && !(typeof data.permissions === \"number\" && data.permissions >= Permission.NONE && data.permissions <= Permission.ALL)) {\n throw new Error(\"Invalid permissions\");\n }\n if (data.owner && data.owner !== null && typeof data.owner !== \"string\") {\n throw new Error(\"Invalid owner type\");\n }\n if (data.attributes && typeof data.attributes !== \"object\") {\n throw new Error(\"Invalid attributes type\");\n }\n if (data.status && !Object.values(NodeStatus).includes(data.status)) {\n throw new Error(\"Status must be a valid NodeStatus\");\n }\n}\nfunction fixDates(data) {\n if (data.mtime && typeof data.mtime === \"string\") {\n if (!isNaN(Date.parse(data.mtime)) && JSON.stringify(new Date(data.mtime)) === JSON.stringify(data.mtime)) {\n data.mtime = new Date(data.mtime);\n }\n }\n if (data.crtime && typeof data.crtime === \"string\") {\n if (!isNaN(Date.parse(data.crtime)) && JSON.stringify(new Date(data.crtime)) === JSON.stringify(data.crtime)) {\n data.crtime = new Date(data.crtime);\n }\n }\n}\nfunction fixRegExp(pattern) {\n if (pattern instanceof RegExp) {\n return pattern;\n }\n const matches = pattern.match(/(\\/?)(.+)\\1([a-z]*)/i);\n if (!matches) {\n throw new Error(\"Invalid regular expression format.\");\n }\n const validFlags = Array.from(new Set(matches[3])).filter((flag) => \"gimsuy\".includes(flag)).join(\"\");\n return new RegExp(matches[2], validFlags);\n}\nclass Node {\n _attributes;\n _data;\n _knownDavService = /(remote|public)\\.php\\/(web)?dav/i;\n readonlyAttributes = Object.entries(Object.getOwnPropertyDescriptors(Node.prototype)).filter((e) => typeof e[1].get === \"function\" && e[0] !== \"__proto__\").map((e) => e[0]);\n handler = {\n set: (target, prop, value) => {\n if (this.readonlyAttributes.includes(prop)) {\n return false;\n }\n return Reflect.set(target, prop, value);\n },\n deleteProperty: (target, prop) => {\n if (this.readonlyAttributes.includes(prop)) {\n return false;\n }\n return Reflect.deleteProperty(target, prop);\n }\n };\n constructor(...[data, davService]) {\n if (!data.mime) {\n data.mime = \"application/octet-stream\";\n }\n fixDates(data);\n davService = fixRegExp(davService || this._knownDavService);\n validateData(data, davService);\n this._data = {\n ...data,\n attributes: {}\n };\n this._attributes = new Proxy(this._data.attributes, this.handler);\n this.update(data.attributes ?? {});\n if (davService) {\n this._knownDavService = davService;\n }\n }\n /**\n * Get the source url to this object\n * There is no setter as the source is not meant to be changed manually.\n * You can use the rename or move method to change the source.\n */\n get source() {\n return this._data.source.replace(/\\/$/i, \"\");\n }\n /**\n * Get the encoded source url to this object for requests purposes\n */\n get encodedSource() {\n const { origin } = new URL(this.source);\n return origin + encodePath(this.source.slice(origin.length));\n }\n /**\n * Get this object name\n * There is no setter as the source is not meant to be changed manually.\n * You can use the rename or move method to change the source.\n */\n get basename() {\n return basename(this.source);\n }\n /**\n * The nodes displayname\n * By default the display name and the `basename` are identical,\n * but it is possible to have a different name. This happens\n * on the files app for example for shared folders.\n */\n get displayname() {\n return this._data.displayname || this.basename;\n }\n /**\n * Set the displayname\n */\n set displayname(displayname) {\n validateData({ ...this._data, displayname }, this._knownDavService);\n this._data.displayname = displayname;\n }\n /**\n * Get this object's extension\n * There is no setter as the source is not meant to be changed manually.\n * You can use the rename or move method to change the source.\n */\n get extension() {\n return extname(this.source);\n }\n /**\n * Get the directory path leading to this object\n * Will use the relative path to root if available\n *\n * There is no setter as the source is not meant to be changed manually.\n * You can use the rename or move method to change the source.\n */\n get dirname() {\n return dirname(this.path);\n }\n /**\n * Get the file mime\n */\n get mime() {\n return this._data.mime || \"application/octet-stream\";\n }\n /**\n * Set the file mime\n * Removing the mime type will set it to `application/octet-stream`\n */\n set mime(mime) {\n mime ??= \"application/octet-stream\";\n validateData({ ...this._data, mime }, this._knownDavService);\n this._data.mime = mime;\n }\n /**\n * Get the file modification time\n */\n get mtime() {\n return this._data.mtime;\n }\n /**\n * Set the file modification time\n */\n set mtime(mtime) {\n validateData({ ...this._data, mtime }, this._knownDavService);\n this._data.mtime = mtime;\n }\n /**\n * Get the file creation time\n * There is no setter as the creation time is not meant to be changed\n */\n get crtime() {\n return this._data.crtime;\n }\n /**\n * Get the file size\n */\n get size() {\n return this._data.size;\n }\n /**\n * Set the file size\n */\n set size(size) {\n validateData({ ...this._data, size }, this._knownDavService);\n this.updateMtime();\n this._data.size = size;\n }\n /**\n * Get the file attribute\n * This contains all additional attributes not provided by the Node class\n */\n get attributes() {\n return this._attributes;\n }\n /**\n * Get the file permissions\n */\n get permissions() {\n if (this.owner === null && !this.isDavResource) {\n return Permission.READ;\n }\n return this._data.permissions !== void 0 ? this._data.permissions : Permission.NONE;\n }\n /**\n * Set the file permissions\n */\n set permissions(permissions) {\n validateData({ ...this._data, permissions }, this._knownDavService);\n this.updateMtime();\n this._data.permissions = permissions;\n }\n /**\n * Get the file owner\n * There is no setter as the owner is not meant to be changed\n */\n get owner() {\n if (!this.isDavResource) {\n return null;\n }\n return this._data.owner;\n }\n /**\n * Is this a dav-related resource ?\n */\n get isDavResource() {\n return isDavResource(this.source, this._knownDavService);\n }\n /**\n * Get the dav root of this object\n * There is no setter as the root is not meant to be changed\n */\n get root() {\n return this._data.root.replace(/^(.+)\\/$/, \"$1\");\n }\n /**\n * Get the absolute path of this object relative to the root\n */\n get path() {\n const idx = this.source.indexOf(\"://\");\n const protocol = this.source.slice(0, idx);\n const remainder = this.source.slice(idx + 3);\n const slashIndex = remainder.indexOf(\"/\");\n const host = remainder.slice(0, slashIndex);\n const rawPath = remainder.slice(slashIndex);\n const safeUrl = `${protocol}://${host}${encodePath(rawPath)}`;\n const url = new URL(safeUrl);\n let source = decodeURIComponent(url.pathname);\n if (this.isDavResource) {\n source = source.split(this._knownDavService).pop();\n }\n const firstMatch = source.indexOf(this.root);\n const root = this.root.replace(/\\/$/, \"\");\n return source.slice(firstMatch + root.length) || \"/\";\n }\n /**\n * Get the nodes file id if defined.\n * There is no setter as the fileid is not meant to be changed.\n *\n * @deprecated Nextcloud is migrating to snowflake ids which are strings. Use the `id` attribute instead.\n */\n get fileid() {\n return typeof this._data?.id === \"number\" ? this._data.id : void 0;\n }\n /**\n * Get the nodes id - if defined.\n *\n * Note: As Nextcloud is migrating to snowflake ids the id has to be a string,\n * due to limitations of the JavaScript number type (snowflake ids are 64bit JavaScript numbers can only accurately represent integers up to 53 bit).\n */\n get id() {\n if (typeof this._data?.id === \"undefined\" || typeof this._data.id === \"number\" && this._data.id < 0) {\n return void 0;\n }\n return String(this._data.id);\n }\n /**\n * Get the node status.\n */\n get status() {\n return this._data?.status;\n }\n /**\n * Set the node status.\n */\n set status(status) {\n validateData({ ...this._data, status }, this._knownDavService);\n this._data.status = status;\n }\n /**\n * Move the node to a new destination\n *\n * @param destination the new source.\n * e.g. https://cloud.domain.com/remote.php/dav/files/emma/Photos/picture.jpg\n */\n move(destination) {\n validateData({ ...this._data, source: destination }, this._knownDavService);\n const oldBasename = this.basename;\n this._data.source = destination;\n if (this.displayname === oldBasename && this.basename !== oldBasename) {\n this.displayname = this.basename;\n }\n }\n /**\n * Rename the node\n * This aliases the move method for easier usage\n *\n * @param basename The new name of the node\n */\n rename(basename2) {\n if (basename2.includes(\"/\")) {\n throw new Error(\"Invalid basename\");\n }\n this.move(dirname(this.source) + \"/\" + basename2);\n }\n /**\n * Update the mtime if exists\n */\n updateMtime() {\n if (this._data.mtime) {\n this._data.mtime = /* @__PURE__ */ new Date();\n }\n }\n /**\n * Update the attributes of the node\n * Warning, updating attributes will NOT automatically update the mtime.\n *\n * @param attributes The new attributes to update on the Node attributes\n */\n update(attributes) {\n for (const [name, value] of Object.entries(attributes)) {\n try {\n if (value === void 0) {\n delete this.attributes[name];\n } else {\n this.attributes[name] = value;\n }\n } catch (e) {\n if (e instanceof TypeError) {\n continue;\n }\n throw e;\n }\n }\n }\n /**\n * Returns a clone of the node\n */\n clone() {\n return new this.constructor(structuredClone(this._data), this._knownDavService);\n }\n /**\n * JSON representation of the node\n */\n toJSON() {\n return JSON.stringify([structuredClone(this._data), this._knownDavService.toString()]);\n }\n}\nclass File extends Node {\n constructor(...[data, davService]) {\n super(data, davService);\n }\n get type() {\n return FileType.File;\n }\n}\nclass Folder extends Node {\n constructor(...[data, davService]) {\n super({\n ...data,\n mime: \"httpd/unix-directory\"\n }, davService);\n }\n get type() {\n return FileType.Folder;\n }\n get extension() {\n return null;\n }\n get mime() {\n return \"httpd/unix-directory\";\n }\n}\nexport {\n FileType as F,\n Node as N,\n Permission as P,\n File as a,\n Folder as b,\n NodeStatus as c,\n logger as l,\n scopedGlobals as s\n};\n//# sourceMappingURL=folder-29HuacU_.mjs.map\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar R = typeof Reflect === 'object' ? Reflect : null\nvar ReflectApply = R && typeof R.apply === 'function'\n ? R.apply\n : function ReflectApply(target, receiver, args) {\n return Function.prototype.apply.call(target, receiver, args);\n }\n\nvar ReflectOwnKeys\nif (R && typeof R.ownKeys === 'function') {\n ReflectOwnKeys = R.ownKeys\n} else if (Object.getOwnPropertySymbols) {\n ReflectOwnKeys = function ReflectOwnKeys(target) {\n return Object.getOwnPropertyNames(target)\n .concat(Object.getOwnPropertySymbols(target));\n };\n} else {\n ReflectOwnKeys = function ReflectOwnKeys(target) {\n return Object.getOwnPropertyNames(target);\n };\n}\n\nfunction ProcessEmitWarning(warning) {\n if (console && console.warn) console.warn(warning);\n}\n\nvar NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {\n return value !== value;\n}\n\nfunction EventEmitter() {\n EventEmitter.init.call(this);\n}\nmodule.exports = EventEmitter;\nmodule.exports.once = once;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._eventsCount = 0;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nfunction checkListener(listener) {\n if (typeof listener !== 'function') {\n throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n }\n}\n\nObject.defineProperty(EventEmitter, 'defaultMaxListeners', {\n enumerable: true,\n get: function() {\n return defaultMaxListeners;\n },\n set: function(arg) {\n if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {\n throw new RangeError('The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received ' + arg + '.');\n }\n defaultMaxListeners = arg;\n }\n});\n\nEventEmitter.init = function() {\n\n if (this._events === undefined ||\n this._events === Object.getPrototypeOf(this)._events) {\n this._events = Object.create(null);\n this._eventsCount = 0;\n }\n\n this._maxListeners = this._maxListeners || undefined;\n};\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {\n throw new RangeError('The value of \"n\" is out of range. It must be a non-negative number. Received ' + n + '.');\n }\n this._maxListeners = n;\n return this;\n};\n\nfunction _getMaxListeners(that) {\n if (that._maxListeners === undefined)\n return EventEmitter.defaultMaxListeners;\n return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n return _getMaxListeners(this);\n};\n\nEventEmitter.prototype.emit = function emit(type) {\n var args = [];\n for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);\n var doError = (type === 'error');\n\n var events = this._events;\n if (events !== undefined)\n doError = (doError && events.error === undefined);\n else if (!doError)\n return false;\n\n // If there is no 'error' event listener then throw.\n if (doError) {\n var er;\n if (args.length > 0)\n er = args[0];\n if (er instanceof Error) {\n // Note: The comments on the `throw` lines are intentional, they show\n // up in Node's output if this results in an unhandled exception.\n throw er; // Unhandled 'error' event\n }\n // At least give some kind of context to the user\n var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));\n err.context = er;\n throw err; // Unhandled 'error' event\n }\n\n var handler = events[type];\n\n if (handler === undefined)\n return false;\n\n if (typeof handler === 'function') {\n ReflectApply(handler, this, args);\n } else {\n var len = handler.length;\n var listeners = arrayClone(handler, len);\n for (var i = 0; i < len; ++i)\n ReflectApply(listeners[i], this, args);\n }\n\n return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n var m;\n var events;\n var existing;\n\n checkListener(listener);\n\n events = target._events;\n if (events === undefined) {\n events = target._events = Object.create(null);\n target._eventsCount = 0;\n } else {\n // To avoid recursion in the case that type === \"newListener\"! Before\n // adding it to the listeners, first emit \"newListener\".\n if (events.newListener !== undefined) {\n target.emit('newListener', type,\n listener.listener ? listener.listener : listener);\n\n // Re-assign `events` because a newListener handler could have caused the\n // this._events to be assigned to a new object\n events = target._events;\n }\n existing = events[type];\n }\n\n if (existing === undefined) {\n // Optimize the case of one listener. Don't need the extra array object.\n existing = events[type] = listener;\n ++target._eventsCount;\n } else {\n if (typeof existing === 'function') {\n // Adding the second element, need to change to array.\n existing = events[type] =\n prepend ? [listener, existing] : [existing, listener];\n // If we've already got an array, just append.\n } else if (prepend) {\n existing.unshift(listener);\n } else {\n existing.push(listener);\n }\n\n // Check for listener leak\n m = _getMaxListeners(target);\n if (m > 0 && existing.length > m && !existing.warned) {\n existing.warned = true;\n // No error code for this since it is a Warning\n // eslint-disable-next-line no-restricted-syntax\n var w = new Error('Possible EventEmitter memory leak detected. ' +\n existing.length + ' ' + String(type) + ' listeners ' +\n 'added. Use emitter.setMaxListeners() to ' +\n 'increase limit');\n w.name = 'MaxListenersExceededWarning';\n w.emitter = target;\n w.type = type;\n w.count = existing.length;\n ProcessEmitWarning(w);\n }\n }\n\n return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n function prependListener(type, listener) {\n return _addListener(this, type, listener, true);\n };\n\nfunction onceWrapper() {\n if (!this.fired) {\n this.target.removeListener(this.type, this.wrapFn);\n this.fired = true;\n if (arguments.length === 0)\n return this.listener.call(this.target);\n return this.listener.apply(this.target, arguments);\n }\n}\n\nfunction _onceWrap(target, type, listener) {\n var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n var wrapped = onceWrapper.bind(state);\n wrapped.listener = listener;\n state.wrapFn = wrapped;\n return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n checkListener(listener);\n this.on(type, _onceWrap(this, type, listener));\n return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n function prependOnceListener(type, listener) {\n checkListener(listener);\n this.prependListener(type, _onceWrap(this, type, listener));\n return this;\n };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n function removeListener(type, listener) {\n var list, events, position, i, originalListener;\n\n checkListener(listener);\n\n events = this._events;\n if (events === undefined)\n return this;\n\n list = events[type];\n if (list === undefined)\n return this;\n\n if (list === listener || list.listener === listener) {\n if (--this._eventsCount === 0)\n this._events = Object.create(null);\n else {\n delete events[type];\n if (events.removeListener)\n this.emit('removeListener', type, list.listener || listener);\n }\n } else if (typeof list !== 'function') {\n position = -1;\n\n for (i = list.length - 1; i >= 0; i--) {\n if (list[i] === listener || list[i].listener === listener) {\n originalListener = list[i].listener;\n position = i;\n break;\n }\n }\n\n if (position < 0)\n return this;\n\n if (position === 0)\n list.shift();\n else {\n spliceOne(list, position);\n }\n\n if (list.length === 1)\n events[type] = list[0];\n\n if (events.removeListener !== undefined)\n this.emit('removeListener', type, originalListener || listener);\n }\n\n return this;\n };\n\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n\nEventEmitter.prototype.removeAllListeners =\n function removeAllListeners(type) {\n var listeners, events, i;\n\n events = this._events;\n if (events === undefined)\n return this;\n\n // not listening for removeListener, no need to emit\n if (events.removeListener === undefined) {\n if (arguments.length === 0) {\n this._events = Object.create(null);\n this._eventsCount = 0;\n } else if (events[type] !== undefined) {\n if (--this._eventsCount === 0)\n this._events = Object.create(null);\n else\n delete events[type];\n }\n return this;\n }\n\n // emit removeListener for all listeners on all events\n if (arguments.length === 0) {\n var keys = Object.keys(events);\n var key;\n for (i = 0; i < keys.length; ++i) {\n key = keys[i];\n if (key === 'removeListener') continue;\n this.removeAllListeners(key);\n }\n this.removeAllListeners('removeListener');\n this._events = Object.create(null);\n this._eventsCount = 0;\n return this;\n }\n\n listeners = events[type];\n\n if (typeof listeners === 'function') {\n this.removeListener(type, listeners);\n } else if (listeners !== undefined) {\n // LIFO order\n for (i = listeners.length - 1; i >= 0; i--) {\n this.removeListener(type, listeners[i]);\n }\n }\n\n return this;\n };\n\nfunction _listeners(target, type, unwrap) {\n var events = target._events;\n\n if (events === undefined)\n return [];\n\n var evlistener = events[type];\n if (evlistener === undefined)\n return [];\n\n if (typeof evlistener === 'function')\n return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n return unwrap ?\n unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n if (typeof emitter.listenerCount === 'function') {\n return emitter.listenerCount(type);\n } else {\n return listenerCount.call(emitter, type);\n }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n var events = this._events;\n\n if (events !== undefined) {\n var evlistener = events[type];\n\n if (typeof evlistener === 'function') {\n return 1;\n } else if (evlistener !== undefined) {\n return evlistener.length;\n }\n }\n\n return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n};\n\nfunction arrayClone(arr, n) {\n var copy = new Array(n);\n for (var i = 0; i < n; ++i)\n copy[i] = arr[i];\n return copy;\n}\n\nfunction spliceOne(list, index) {\n for (; index + 1 < list.length; index++)\n list[index] = list[index + 1];\n list.pop();\n}\n\nfunction unwrapListeners(arr) {\n var ret = new Array(arr.length);\n for (var i = 0; i < ret.length; ++i) {\n ret[i] = arr[i].listener || arr[i];\n }\n return ret;\n}\n\nfunction once(emitter, name) {\n return new Promise(function (resolve, reject) {\n function errorListener(err) {\n emitter.removeListener(name, resolver);\n reject(err);\n }\n\n function resolver() {\n if (typeof emitter.removeListener === 'function') {\n emitter.removeListener('error', errorListener);\n }\n resolve([].slice.call(arguments));\n };\n\n eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });\n if (name !== 'error') {\n addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });\n }\n });\n}\n\nfunction addErrorHandlerIfEventEmitter(emitter, handler, flags) {\n if (typeof emitter.on === 'function') {\n eventTargetAgnosticAddListener(emitter, 'error', handler, flags);\n }\n}\n\nfunction eventTargetAgnosticAddListener(emitter, name, listener, flags) {\n if (typeof emitter.on === 'function') {\n if (flags.once) {\n emitter.once(name, listener);\n } else {\n emitter.on(name, listener);\n }\n } else if (typeof emitter.addEventListener === 'function') {\n // EventTarget does not have `error` event semantics like Node\n // EventEmitters, we do not listen for `error` events here.\n emitter.addEventListener(name, function wrapListener(arg) {\n // IE does not have builtin `{ once: true }` support so we\n // have to do it manually.\n if (flags.once) {\n emitter.removeEventListener(name, wrapListener);\n }\n listener(arg);\n });\n } else {\n throw new TypeError('The \"emitter\" argument must be of type EventEmitter. Received type ' + typeof emitter);\n }\n}\n","if (typeof Object.create === 'function') {\n // implementation from standard node.js 'util' module\n module.exports = function inherits(ctor, superCtor) {\n if (superCtor) {\n ctor.super_ = superCtor\n ctor.prototype = Object.create(superCtor.prototype, {\n constructor: {\n value: ctor,\n enumerable: false,\n writable: true,\n configurable: true\n }\n })\n }\n };\n} else {\n // old school shim for old browsers\n module.exports = function inherits(ctor, superCtor) {\n if (superCtor) {\n ctor.super_ = superCtor\n var TempCtor = function () {}\n TempCtor.prototype = superCtor.prototype\n ctor.prototype = new TempCtor()\n ctor.prototype.constructor = ctor\n }\n }\n}\n","module.exports = require('events').EventEmitter;\n","'use strict';\n\nObject.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });\n\nvar buffer = {};\n\nvar base64Js = {};\n\nbase64Js.byteLength = byteLength;\nbase64Js.toByteArray = toByteArray;\nbase64Js.fromByteArray = fromByteArray;\n\nvar lookup = [];\nvar revLookup = [];\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\nfor (var i = 0, len = code.length; i < len; ++i) {\n lookup[i] = code[i];\n revLookup[code.charCodeAt(i)] = i;\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62;\nrevLookup['_'.charCodeAt(0)] = 63;\n\nfunction getLens (b64) {\n var len = b64.length;\n\n if (len % 4 > 0) {\n throw new Error('Invalid string. Length must be a multiple of 4')\n }\n\n // Trim off extra bytes after placeholder bytes are found\n // See: https://github.com/beatgammit/base64-js/issues/42\n var validLen = b64.indexOf('=');\n if (validLen === -1) validLen = len;\n\n var placeHoldersLen = validLen === len\n ? 0\n : 4 - (validLen % 4);\n\n return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n var lens = getLens(b64);\n var validLen = lens[0];\n var placeHoldersLen = lens[1];\n return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n var tmp;\n var lens = getLens(b64);\n var validLen = lens[0];\n var placeHoldersLen = lens[1];\n\n var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));\n\n var curByte = 0;\n\n // if there are placeholders, only get up to the last complete 4 chars\n var len = placeHoldersLen > 0\n ? validLen - 4\n : validLen;\n\n var i;\n for (i = 0; i < len; i += 4) {\n tmp =\n (revLookup[b64.charCodeAt(i)] << 18) |\n (revLookup[b64.charCodeAt(i + 1)] << 12) |\n (revLookup[b64.charCodeAt(i + 2)] << 6) |\n revLookup[b64.charCodeAt(i + 3)];\n arr[curByte++] = (tmp >> 16) & 0xFF;\n arr[curByte++] = (tmp >> 8) & 0xFF;\n arr[curByte++] = tmp & 0xFF;\n }\n\n if (placeHoldersLen === 2) {\n tmp =\n (revLookup[b64.charCodeAt(i)] << 2) |\n (revLookup[b64.charCodeAt(i + 1)] >> 4);\n arr[curByte++] = tmp & 0xFF;\n }\n\n if (placeHoldersLen === 1) {\n tmp =\n (revLookup[b64.charCodeAt(i)] << 10) |\n (revLookup[b64.charCodeAt(i + 1)] << 4) |\n (revLookup[b64.charCodeAt(i + 2)] >> 2);\n arr[curByte++] = (tmp >> 8) & 0xFF;\n arr[curByte++] = tmp & 0xFF;\n }\n\n return arr\n}\n\nfunction tripletToBase64 (num) {\n return lookup[num >> 18 & 0x3F] +\n lookup[num >> 12 & 0x3F] +\n lookup[num >> 6 & 0x3F] +\n lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n var tmp;\n var output = [];\n for (var i = start; i < end; i += 3) {\n tmp =\n ((uint8[i] << 16) & 0xFF0000) +\n ((uint8[i + 1] << 8) & 0xFF00) +\n (uint8[i + 2] & 0xFF);\n output.push(tripletToBase64(tmp));\n }\n return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n var tmp;\n var len = uint8.length;\n var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes\n var parts = [];\n var maxChunkLength = 16383; // must be multiple of 3\n\n // go through the array every three bytes, we'll deal with trailing stuff later\n for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)));\n }\n\n // pad the end with zeros, but make sure to not forget the extra bytes\n if (extraBytes === 1) {\n tmp = uint8[len - 1];\n parts.push(\n lookup[tmp >> 2] +\n lookup[(tmp << 4) & 0x3F] +\n '=='\n );\n } else if (extraBytes === 2) {\n tmp = (uint8[len - 2] << 8) + uint8[len - 1];\n parts.push(\n lookup[tmp >> 10] +\n lookup[(tmp >> 4) & 0x3F] +\n lookup[(tmp << 2) & 0x3F] +\n '='\n );\n }\n\n return parts.join('')\n}\n\nvar ieee754 = {};\n\n/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */\n\nieee754.read = function (buffer, offset, isLE, mLen, nBytes) {\n var e, m;\n var eLen = (nBytes * 8) - mLen - 1;\n var eMax = (1 << eLen) - 1;\n var eBias = eMax >> 1;\n var nBits = -7;\n var i = isLE ? (nBytes - 1) : 0;\n var d = isLE ? -1 : 1;\n var s = buffer[offset + i];\n\n i += d;\n\n e = s & ((1 << (-nBits)) - 1);\n s >>= (-nBits);\n nBits += eLen;\n for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n m = e & ((1 << (-nBits)) - 1);\n e >>= (-nBits);\n nBits += mLen;\n for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n if (e === 0) {\n e = 1 - eBias;\n } else if (e === eMax) {\n return m ? NaN : ((s ? -1 : 1) * Infinity)\n } else {\n m = m + Math.pow(2, mLen);\n e = e - eBias;\n }\n return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n};\n\nieee754.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n var e, m, c;\n var eLen = (nBytes * 8) - mLen - 1;\n var eMax = (1 << eLen) - 1;\n var eBias = eMax >> 1;\n var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0);\n var i = isLE ? 0 : (nBytes - 1);\n var d = isLE ? 1 : -1;\n var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;\n\n value = Math.abs(value);\n\n if (isNaN(value) || value === Infinity) {\n m = isNaN(value) ? 1 : 0;\n e = eMax;\n } else {\n e = Math.floor(Math.log(value) / Math.LN2);\n if (value * (c = Math.pow(2, -e)) < 1) {\n e--;\n c *= 2;\n }\n if (e + eBias >= 1) {\n value += rt / c;\n } else {\n value += rt * Math.pow(2, 1 - eBias);\n }\n if (value * c >= 2) {\n e++;\n c /= 2;\n }\n\n if (e + eBias >= eMax) {\n m = 0;\n e = eMax;\n } else if (e + eBias >= 1) {\n m = ((value * c) - 1) * Math.pow(2, mLen);\n e = e + eBias;\n } else {\n m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);\n e = 0;\n }\n }\n\n for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n e = (e << mLen) | m;\n eLen += mLen;\n for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n buffer[offset + i - d] |= s * 128;\n};\n\n/*!\n * The buffer module from node.js, for the browser.\n *\n * @author Feross Aboukhadijeh <https://feross.org>\n * @license MIT\n */\n\n(function (exports) {\n\n\tconst base64 = base64Js;\n\tconst ieee754$1 = ieee754;\n\tconst customInspectSymbol =\n\t (typeof Symbol === 'function' && typeof Symbol['for'] === 'function') // eslint-disable-line dot-notation\n\t ? Symbol['for']('nodejs.util.inspect.custom') // eslint-disable-line dot-notation\n\t : null;\n\n\texports.Buffer = Buffer;\n\texports.SlowBuffer = SlowBuffer;\n\texports.INSPECT_MAX_BYTES = 50;\n\n\tconst K_MAX_LENGTH = 0x7fffffff;\n\texports.kMaxLength = K_MAX_LENGTH;\n\tconst { Uint8Array: GlobalUint8Array, ArrayBuffer: GlobalArrayBuffer, SharedArrayBuffer: GlobalSharedArrayBuffer } = globalThis;\n\n\t/**\n\t * If `Buffer.TYPED_ARRAY_SUPPORT`:\n\t * === true Use Uint8Array implementation (fastest)\n\t * === false Print warning and recommend using `buffer` v4.x which has an Object\n\t * implementation (most compatible, even IE6)\n\t *\n\t * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n\t * Opera 11.6+, iOS 4.2+.\n\t *\n\t * We report that the browser does not support typed arrays if the are not subclassable\n\t * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`\n\t * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support\n\t * for __proto__ and has a buggy typed array implementation.\n\t */\n\tBuffer.TYPED_ARRAY_SUPPORT = typedArraySupport();\n\n\tif (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&\n\t typeof console.error === 'function') {\n\t console.error(\n\t 'This browser lacks typed array (Uint8Array) support which is required by ' +\n\t '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'\n\t );\n\t}\n\n\tfunction typedArraySupport () {\n\t // Can typed array instances can be augmented?\n\t try {\n\t const arr = new GlobalUint8Array(1);\n\t const proto = { foo: function () { return 42 } };\n\t Object.setPrototypeOf(proto, GlobalUint8Array.prototype);\n\t Object.setPrototypeOf(arr, proto);\n\t return arr.foo() === 42\n\t } catch (e) {\n\t return false\n\t }\n\t}\n\n\tObject.defineProperty(Buffer.prototype, 'parent', {\n\t enumerable: true,\n\t get: function () {\n\t if (!Buffer.isBuffer(this)) return undefined\n\t return this.buffer\n\t }\n\t});\n\n\tObject.defineProperty(Buffer.prototype, 'offset', {\n\t enumerable: true,\n\t get: function () {\n\t if (!Buffer.isBuffer(this)) return undefined\n\t return this.byteOffset\n\t }\n\t});\n\n\tfunction createBuffer (length) {\n\t if (length > K_MAX_LENGTH) {\n\t throw new RangeError('The value \"' + length + '\" is invalid for option \"size\"')\n\t }\n\t // Return an augmented `Uint8Array` instance\n\t const buf = new GlobalUint8Array(length);\n\t Object.setPrototypeOf(buf, Buffer.prototype);\n\t return buf\n\t}\n\n\t/**\n\t * The Buffer constructor returns instances of `Uint8Array` that have their\n\t * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n\t * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n\t * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n\t * returns a single octet.\n\t *\n\t * The `Uint8Array` prototype remains unmodified.\n\t */\n\n\tfunction Buffer (arg, encodingOrOffset, length) {\n\t // Common case.\n\t if (typeof arg === 'number') {\n\t if (typeof encodingOrOffset === 'string') {\n\t throw new TypeError(\n\t 'The \"string\" argument must be of type string. Received type number'\n\t )\n\t }\n\t return allocUnsafe(arg)\n\t }\n\t return from(arg, encodingOrOffset, length)\n\t}\n\n\tBuffer.poolSize = 8192; // not used by this implementation\n\n\tfunction from (value, encodingOrOffset, length) {\n\t if (typeof value === 'string') {\n\t return fromString(value, encodingOrOffset)\n\t }\n\n\t if (GlobalArrayBuffer.isView(value)) {\n\t return fromArrayView(value)\n\t }\n\n\t if (value == null) {\n\t throw new TypeError(\n\t 'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\n\t 'or Array-like Object. Received type ' + (typeof value)\n\t )\n\t }\n\n\t if (isInstance(value, GlobalArrayBuffer) ||\n\t (value && isInstance(value.buffer, GlobalArrayBuffer))) {\n\t return fromArrayBuffer(value, encodingOrOffset, length)\n\t }\n\n\t if (typeof GlobalSharedArrayBuffer !== 'undefined' &&\n\t (isInstance(value, GlobalSharedArrayBuffer) ||\n\t (value && isInstance(value.buffer, GlobalSharedArrayBuffer)))) {\n\t return fromArrayBuffer(value, encodingOrOffset, length)\n\t }\n\n\t if (typeof value === 'number') {\n\t throw new TypeError(\n\t 'The \"value\" argument must not be of type number. Received type number'\n\t )\n\t }\n\n\t const valueOf = value.valueOf && value.valueOf();\n\t if (valueOf != null && valueOf !== value) {\n\t return Buffer.from(valueOf, encodingOrOffset, length)\n\t }\n\n\t const b = fromObject(value);\n\t if (b) return b\n\n\t if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&\n\t typeof value[Symbol.toPrimitive] === 'function') {\n\t return Buffer.from(value[Symbol.toPrimitive]('string'), encodingOrOffset, length)\n\t }\n\n\t throw new TypeError(\n\t 'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\n\t 'or Array-like Object. Received type ' + (typeof value)\n\t )\n\t}\n\n\t/**\n\t * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n\t * if value is a number.\n\t * Buffer.from(str[, encoding])\n\t * Buffer.from(array)\n\t * Buffer.from(buffer)\n\t * Buffer.from(arrayBuffer[, byteOffset[, length]])\n\t **/\n\tBuffer.from = function (value, encodingOrOffset, length) {\n\t return from(value, encodingOrOffset, length)\n\t};\n\n\t// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:\n\t// https://github.com/feross/buffer/pull/148\n\tObject.setPrototypeOf(Buffer.prototype, GlobalUint8Array.prototype);\n\tObject.setPrototypeOf(Buffer, GlobalUint8Array);\n\n\tfunction assertSize (size) {\n\t if (typeof size !== 'number') {\n\t throw new TypeError('\"size\" argument must be of type number')\n\t } else if (size < 0) {\n\t throw new RangeError('The value \"' + size + '\" is invalid for option \"size\"')\n\t }\n\t}\n\n\tfunction alloc (size, fill, encoding) {\n\t assertSize(size);\n\t if (size <= 0) {\n\t return createBuffer(size)\n\t }\n\t if (fill !== undefined) {\n\t // Only pay attention to encoding if it's a string. This\n\t // prevents accidentally sending in a number that would\n\t // be interpreted as a start offset.\n\t return typeof encoding === 'string'\n\t ? createBuffer(size).fill(fill, encoding)\n\t : createBuffer(size).fill(fill)\n\t }\n\t return createBuffer(size)\n\t}\n\n\t/**\n\t * Creates a new filled Buffer instance.\n\t * alloc(size[, fill[, encoding]])\n\t **/\n\tBuffer.alloc = function (size, fill, encoding) {\n\t return alloc(size, fill, encoding)\n\t};\n\n\tfunction allocUnsafe (size) {\n\t assertSize(size);\n\t return createBuffer(size < 0 ? 0 : checked(size) | 0)\n\t}\n\n\t/**\n\t * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n\t * */\n\tBuffer.allocUnsafe = function (size) {\n\t return allocUnsafe(size)\n\t};\n\t/**\n\t * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n\t */\n\tBuffer.allocUnsafeSlow = function (size) {\n\t return allocUnsafe(size)\n\t};\n\n\tfunction fromString (string, encoding) {\n\t if (typeof encoding !== 'string' || encoding === '') {\n\t encoding = 'utf8';\n\t }\n\n\t if (!Buffer.isEncoding(encoding)) {\n\t throw new TypeError('Unknown encoding: ' + encoding)\n\t }\n\n\t const length = byteLength(string, encoding) | 0;\n\t let buf = createBuffer(length);\n\n\t const actual = buf.write(string, encoding);\n\n\t if (actual !== length) {\n\t // Writing a hex string, for example, that contains invalid characters will\n\t // cause everything after the first invalid character to be ignored. (e.g.\n\t // 'abxxcd' will be treated as 'ab')\n\t buf = buf.slice(0, actual);\n\t }\n\n\t return buf\n\t}\n\n\tfunction fromArrayLike (array) {\n\t const length = array.length < 0 ? 0 : checked(array.length) | 0;\n\t const buf = createBuffer(length);\n\t for (let i = 0; i < length; i += 1) {\n\t buf[i] = array[i] & 255;\n\t }\n\t return buf\n\t}\n\n\tfunction fromArrayView (arrayView) {\n\t if (isInstance(arrayView, GlobalUint8Array)) {\n\t const copy = new GlobalUint8Array(arrayView);\n\t return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength)\n\t }\n\t return fromArrayLike(arrayView)\n\t}\n\n\tfunction fromArrayBuffer (array, byteOffset, length) {\n\t if (byteOffset < 0 || array.byteLength < byteOffset) {\n\t throw new RangeError('\"offset\" is outside of buffer bounds')\n\t }\n\n\t if (array.byteLength < byteOffset + (length || 0)) {\n\t throw new RangeError('\"length\" is outside of buffer bounds')\n\t }\n\n\t let buf;\n\t if (byteOffset === undefined && length === undefined) {\n\t buf = new GlobalUint8Array(array);\n\t } else if (length === undefined) {\n\t buf = new GlobalUint8Array(array, byteOffset);\n\t } else {\n\t buf = new GlobalUint8Array(array, byteOffset, length);\n\t }\n\n\t // Return an augmented `Uint8Array` instance\n\t Object.setPrototypeOf(buf, Buffer.prototype);\n\n\t return buf\n\t}\n\n\tfunction fromObject (obj) {\n\t if (Buffer.isBuffer(obj)) {\n\t const len = checked(obj.length) | 0;\n\t const buf = createBuffer(len);\n\n\t if (buf.length === 0) {\n\t return buf\n\t }\n\n\t obj.copy(buf, 0, 0, len);\n\t return buf\n\t }\n\n\t if (obj.length !== undefined) {\n\t if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {\n\t return createBuffer(0)\n\t }\n\t return fromArrayLike(obj)\n\t }\n\n\t if (obj.type === 'Buffer' && Array.isArray(obj.data)) {\n\t return fromArrayLike(obj.data)\n\t }\n\t}\n\n\tfunction checked (length) {\n\t // Note: cannot use `length < K_MAX_LENGTH` here because that fails when\n\t // length is NaN (which is otherwise coerced to zero.)\n\t if (length >= K_MAX_LENGTH) {\n\t throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n\t 'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')\n\t }\n\t return length | 0\n\t}\n\n\tfunction SlowBuffer (length) {\n\t if (+length != length) { // eslint-disable-line eqeqeq\n\t length = 0;\n\t }\n\t return Buffer.alloc(+length)\n\t}\n\n\tBuffer.isBuffer = function isBuffer (b) {\n\t return b != null && b._isBuffer === true &&\n\t b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false\n\t};\n\n\tBuffer.compare = function compare (a, b) {\n\t if (isInstance(a, GlobalUint8Array)) a = Buffer.from(a, a.offset, a.byteLength);\n\t if (isInstance(b, GlobalUint8Array)) b = Buffer.from(b, b.offset, b.byteLength);\n\t if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n\t throw new TypeError(\n\t 'The \"buf1\", \"buf2\" arguments must be one of type Buffer or Uint8Array'\n\t )\n\t }\n\n\t if (a === b) return 0\n\n\t let x = a.length;\n\t let y = b.length;\n\n\t for (let i = 0, len = Math.min(x, y); i < len; ++i) {\n\t if (a[i] !== b[i]) {\n\t x = a[i];\n\t y = b[i];\n\t break\n\t }\n\t }\n\n\t if (x < y) return -1\n\t if (y < x) return 1\n\t return 0\n\t};\n\n\tBuffer.isEncoding = function isEncoding (encoding) {\n\t switch (String(encoding).toLowerCase()) {\n\t case 'hex':\n\t case 'utf8':\n\t case 'utf-8':\n\t case 'ascii':\n\t case 'latin1':\n\t case 'binary':\n\t case 'base64':\n\t case 'ucs2':\n\t case 'ucs-2':\n\t case 'utf16le':\n\t case 'utf-16le':\n\t return true\n\t default:\n\t return false\n\t }\n\t};\n\n\tBuffer.concat = function concat (list, length) {\n\t if (!Array.isArray(list)) {\n\t throw new TypeError('\"list\" argument must be an Array of Buffers')\n\t }\n\n\t if (list.length === 0) {\n\t return Buffer.alloc(0)\n\t }\n\n\t let i;\n\t if (length === undefined) {\n\t length = 0;\n\t for (i = 0; i < list.length; ++i) {\n\t length += list[i].length;\n\t }\n\t }\n\n\t const buffer = Buffer.allocUnsafe(length);\n\t let pos = 0;\n\t for (i = 0; i < list.length; ++i) {\n\t let buf = list[i];\n\t if (isInstance(buf, GlobalUint8Array)) {\n\t if (pos + buf.length > buffer.length) {\n\t if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf);\n\t buf.copy(buffer, pos);\n\t } else {\n\t GlobalUint8Array.prototype.set.call(\n\t buffer,\n\t buf,\n\t pos\n\t );\n\t }\n\t } else if (!Buffer.isBuffer(buf)) {\n\t throw new TypeError('\"list\" argument must be an Array of Buffers')\n\t } else {\n\t buf.copy(buffer, pos);\n\t }\n\t pos += buf.length;\n\t }\n\t return buffer\n\t};\n\n\tfunction byteLength (string, encoding) {\n\t if (Buffer.isBuffer(string)) {\n\t return string.length\n\t }\n\t if (GlobalArrayBuffer.isView(string) || isInstance(string, GlobalArrayBuffer)) {\n\t return string.byteLength\n\t }\n\t if (typeof string !== 'string') {\n\t throw new TypeError(\n\t 'The \"string\" argument must be one of type string, Buffer, or ArrayBuffer. ' +\n\t 'Received type ' + typeof string\n\t )\n\t }\n\n\t const len = string.length;\n\t const mustMatch = (arguments.length > 2 && arguments[2] === true);\n\t if (!mustMatch && len === 0) return 0\n\n\t // Use a for loop to avoid recursion\n\t let loweredCase = false;\n\t for (;;) {\n\t switch (encoding) {\n\t case 'ascii':\n\t case 'latin1':\n\t case 'binary':\n\t return len\n\t case 'utf8':\n\t case 'utf-8':\n\t return utf8ToBytes(string).length\n\t case 'ucs2':\n\t case 'ucs-2':\n\t case 'utf16le':\n\t case 'utf-16le':\n\t return len * 2\n\t case 'hex':\n\t return len >>> 1\n\t case 'base64':\n\t return base64ToBytes(string).length\n\t default:\n\t if (loweredCase) {\n\t return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8\n\t }\n\t encoding = ('' + encoding).toLowerCase();\n\t loweredCase = true;\n\t }\n\t }\n\t}\n\tBuffer.byteLength = byteLength;\n\n\tfunction slowToString (encoding, start, end) {\n\t let loweredCase = false;\n\n\t // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n\t // property of a typed array.\n\n\t // This behaves neither like String nor Uint8Array in that we set start/end\n\t // to their upper/lower bounds if the value passed is out of range.\n\t // undefined is handled specially as per ECMA-262 6th Edition,\n\t // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n\t if (start === undefined || start < 0) {\n\t start = 0;\n\t }\n\t // Return early if start > this.length. Done here to prevent potential uint32\n\t // coercion fail below.\n\t if (start > this.length) {\n\t return ''\n\t }\n\n\t if (end === undefined || end > this.length) {\n\t end = this.length;\n\t }\n\n\t if (end <= 0) {\n\t return ''\n\t }\n\n\t // Force coercion to uint32. This will also coerce falsey/NaN values to 0.\n\t end >>>= 0;\n\t start >>>= 0;\n\n\t if (end <= start) {\n\t return ''\n\t }\n\n\t if (!encoding) encoding = 'utf8';\n\n\t while (true) {\n\t switch (encoding) {\n\t case 'hex':\n\t return hexSlice(this, start, end)\n\n\t case 'utf8':\n\t case 'utf-8':\n\t return utf8Slice(this, start, end)\n\n\t case 'ascii':\n\t return asciiSlice(this, start, end)\n\n\t case 'latin1':\n\t case 'binary':\n\t return latin1Slice(this, start, end)\n\n\t case 'base64':\n\t return base64Slice(this, start, end)\n\n\t case 'ucs2':\n\t case 'ucs-2':\n\t case 'utf16le':\n\t case 'utf-16le':\n\t return utf16leSlice(this, start, end)\n\n\t default:\n\t if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n\t encoding = (encoding + '').toLowerCase();\n\t loweredCase = true;\n\t }\n\t }\n\t}\n\n\t// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)\n\t// to detect a Buffer instance. It's not possible to use `instanceof Buffer`\n\t// reliably in a browserify context because there could be multiple different\n\t// copies of the 'buffer' package in use. This method works even for Buffer\n\t// instances that were created from another copy of the `buffer` package.\n\t// See: https://github.com/feross/buffer/issues/154\n\tBuffer.prototype._isBuffer = true;\n\n\tfunction swap (b, n, m) {\n\t const i = b[n];\n\t b[n] = b[m];\n\t b[m] = i;\n\t}\n\n\tBuffer.prototype.swap16 = function swap16 () {\n\t const len = this.length;\n\t if (len % 2 !== 0) {\n\t throw new RangeError('Buffer size must be a multiple of 16-bits')\n\t }\n\t for (let i = 0; i < len; i += 2) {\n\t swap(this, i, i + 1);\n\t }\n\t return this\n\t};\n\n\tBuffer.prototype.swap32 = function swap32 () {\n\t const len = this.length;\n\t if (len % 4 !== 0) {\n\t throw new RangeError('Buffer size must be a multiple of 32-bits')\n\t }\n\t for (let i = 0; i < len; i += 4) {\n\t swap(this, i, i + 3);\n\t swap(this, i + 1, i + 2);\n\t }\n\t return this\n\t};\n\n\tBuffer.prototype.swap64 = function swap64 () {\n\t const len = this.length;\n\t if (len % 8 !== 0) {\n\t throw new RangeError('Buffer size must be a multiple of 64-bits')\n\t }\n\t for (let i = 0; i < len; i += 8) {\n\t swap(this, i, i + 7);\n\t swap(this, i + 1, i + 6);\n\t swap(this, i + 2, i + 5);\n\t swap(this, i + 3, i + 4);\n\t }\n\t return this\n\t};\n\n\tBuffer.prototype.toString = function toString () {\n\t const length = this.length;\n\t if (length === 0) return ''\n\t if (arguments.length === 0) return utf8Slice(this, 0, length)\n\t return slowToString.apply(this, arguments)\n\t};\n\n\tBuffer.prototype.toLocaleString = Buffer.prototype.toString;\n\n\tBuffer.prototype.equals = function equals (b) {\n\t if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n\t if (this === b) return true\n\t return Buffer.compare(this, b) === 0\n\t};\n\n\tBuffer.prototype.inspect = function inspect () {\n\t let str = '';\n\t const max = exports.INSPECT_MAX_BYTES;\n\t str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim();\n\t if (this.length > max) str += ' ... ';\n\t return '<Buffer ' + str + '>'\n\t};\n\tif (customInspectSymbol) {\n\t Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect;\n\t}\n\n\tBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n\t if (isInstance(target, GlobalUint8Array)) {\n\t target = Buffer.from(target, target.offset, target.byteLength);\n\t }\n\t if (!Buffer.isBuffer(target)) {\n\t throw new TypeError(\n\t 'The \"target\" argument must be one of type Buffer or Uint8Array. ' +\n\t 'Received type ' + (typeof target)\n\t )\n\t }\n\n\t if (start === undefined) {\n\t start = 0;\n\t }\n\t if (end === undefined) {\n\t end = target ? target.length : 0;\n\t }\n\t if (thisStart === undefined) {\n\t thisStart = 0;\n\t }\n\t if (thisEnd === undefined) {\n\t thisEnd = this.length;\n\t }\n\n\t if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n\t throw new RangeError('out of range index')\n\t }\n\n\t if (thisStart >= thisEnd && start >= end) {\n\t return 0\n\t }\n\t if (thisStart >= thisEnd) {\n\t return -1\n\t }\n\t if (start >= end) {\n\t return 1\n\t }\n\n\t start >>>= 0;\n\t end >>>= 0;\n\t thisStart >>>= 0;\n\t thisEnd >>>= 0;\n\n\t if (this === target) return 0\n\n\t let x = thisEnd - thisStart;\n\t let y = end - start;\n\t const len = Math.min(x, y);\n\n\t const thisCopy = this.slice(thisStart, thisEnd);\n\t const targetCopy = target.slice(start, end);\n\n\t for (let i = 0; i < len; ++i) {\n\t if (thisCopy[i] !== targetCopy[i]) {\n\t x = thisCopy[i];\n\t y = targetCopy[i];\n\t break\n\t }\n\t }\n\n\t if (x < y) return -1\n\t if (y < x) return 1\n\t return 0\n\t};\n\n\t// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n\t// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n\t//\n\t// Arguments:\n\t// - buffer - a Buffer to search\n\t// - val - a string, Buffer, or number\n\t// - byteOffset - an index into `buffer`; will be clamped to an int32\n\t// - encoding - an optional encoding, relevant is val is a string\n\t// - dir - true for indexOf, false for lastIndexOf\n\tfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n\t // Empty buffer means no match\n\t if (buffer.length === 0) return -1\n\n\t // Normalize byteOffset\n\t if (typeof byteOffset === 'string') {\n\t encoding = byteOffset;\n\t byteOffset = 0;\n\t } else if (byteOffset > 0x7fffffff) {\n\t byteOffset = 0x7fffffff;\n\t } else if (byteOffset < -0x80000000) {\n\t byteOffset = -0x80000000;\n\t }\n\t byteOffset = +byteOffset; // Coerce to Number.\n\t if (numberIsNaN(byteOffset)) {\n\t // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n\t byteOffset = dir ? 0 : (buffer.length - 1);\n\t }\n\n\t // Normalize byteOffset: negative offsets start from the end of the buffer\n\t if (byteOffset < 0) byteOffset = buffer.length + byteOffset;\n\t if (byteOffset >= buffer.length) {\n\t if (dir) return -1\n\t else byteOffset = buffer.length - 1;\n\t } else if (byteOffset < 0) {\n\t if (dir) byteOffset = 0;\n\t else return -1\n\t }\n\n\t // Normalize val\n\t if (typeof val === 'string') {\n\t val = Buffer.from(val, encoding);\n\t }\n\n\t // Finally, search either indexOf (if dir is true) or lastIndexOf\n\t if (Buffer.isBuffer(val)) {\n\t // Special case: looking for empty string/buffer always fails\n\t if (val.length === 0) {\n\t return -1\n\t }\n\t return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n\t } else if (typeof val === 'number') {\n\t val = val & 0xFF; // Search for a byte value [0-255]\n\t if (typeof GlobalUint8Array.prototype.indexOf === 'function') {\n\t if (dir) {\n\t return GlobalUint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n\t } else {\n\t return GlobalUint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n\t }\n\t }\n\t return arrayIndexOf(buffer, [val], byteOffset, encoding, dir)\n\t }\n\n\t throw new TypeError('val must be string, number or Buffer')\n\t}\n\n\tfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n\t let indexSize = 1;\n\t let arrLength = arr.length;\n\t let valLength = val.length;\n\n\t if (encoding !== undefined) {\n\t encoding = String(encoding).toLowerCase();\n\t if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n\t encoding === 'utf16le' || encoding === 'utf-16le') {\n\t if (arr.length < 2 || val.length < 2) {\n\t return -1\n\t }\n\t indexSize = 2;\n\t arrLength /= 2;\n\t valLength /= 2;\n\t byteOffset /= 2;\n\t }\n\t }\n\n\t function read (buf, i) {\n\t if (indexSize === 1) {\n\t return buf[i]\n\t } else {\n\t return buf.readUInt16BE(i * indexSize)\n\t }\n\t }\n\n\t let i;\n\t if (dir) {\n\t let foundIndex = -1;\n\t for (i = byteOffset; i < arrLength; i++) {\n\t if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n\t if (foundIndex === -1) foundIndex = i;\n\t if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n\t } else {\n\t if (foundIndex !== -1) i -= i - foundIndex;\n\t foundIndex = -1;\n\t }\n\t }\n\t } else {\n\t if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;\n\t for (i = byteOffset; i >= 0; i--) {\n\t let found = true;\n\t for (let j = 0; j < valLength; j++) {\n\t if (read(arr, i + j) !== read(val, j)) {\n\t found = false;\n\t break\n\t }\n\t }\n\t if (found) return i\n\t }\n\t }\n\n\t return -1\n\t}\n\n\tBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n\t return this.indexOf(val, byteOffset, encoding) !== -1\n\t};\n\n\tBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n\t return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n\t};\n\n\tBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n\t return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n\t};\n\n\tfunction hexWrite (buf, string, offset, length) {\n\t offset = Number(offset) || 0;\n\t const remaining = buf.length - offset;\n\t if (!length) {\n\t length = remaining;\n\t } else {\n\t length = Number(length);\n\t if (length > remaining) {\n\t length = remaining;\n\t }\n\t }\n\n\t const strLen = string.length;\n\n\t if (length > strLen / 2) {\n\t length = strLen / 2;\n\t }\n\t let i;\n\t for (i = 0; i < length; ++i) {\n\t const parsed = parseInt(string.substr(i * 2, 2), 16);\n\t if (numberIsNaN(parsed)) return i\n\t buf[offset + i] = parsed;\n\t }\n\t return i\n\t}\n\n\tfunction utf8Write (buf, string, offset, length) {\n\t return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n\t}\n\n\tfunction asciiWrite (buf, string, offset, length) {\n\t return blitBuffer(asciiToBytes(string), buf, offset, length)\n\t}\n\n\tfunction base64Write (buf, string, offset, length) {\n\t return blitBuffer(base64ToBytes(string), buf, offset, length)\n\t}\n\n\tfunction ucs2Write (buf, string, offset, length) {\n\t return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n\t}\n\n\tBuffer.prototype.write = function write (string, offset, length, encoding) {\n\t // Buffer#write(string)\n\t if (offset === undefined) {\n\t encoding = 'utf8';\n\t length = this.length;\n\t offset = 0;\n\t // Buffer#write(string, encoding)\n\t } else if (length === undefined && typeof offset === 'string') {\n\t encoding = offset;\n\t length = this.length;\n\t offset = 0;\n\t // Buffer#write(string, offset[, length][, encoding])\n\t } else if (isFinite(offset)) {\n\t offset = offset >>> 0;\n\t if (isFinite(length)) {\n\t length = length >>> 0;\n\t if (encoding === undefined) encoding = 'utf8';\n\t } else {\n\t encoding = length;\n\t length = undefined;\n\t }\n\t } else {\n\t throw new Error(\n\t 'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n\t )\n\t }\n\n\t const remaining = this.length - offset;\n\t if (length === undefined || length > remaining) length = remaining;\n\n\t if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n\t throw new RangeError('Attempt to write outside buffer bounds')\n\t }\n\n\t if (!encoding) encoding = 'utf8';\n\n\t let loweredCase = false;\n\t for (;;) {\n\t switch (encoding) {\n\t case 'hex':\n\t return hexWrite(this, string, offset, length)\n\n\t case 'utf8':\n\t case 'utf-8':\n\t return utf8Write(this, string, offset, length)\n\n\t case 'ascii':\n\t case 'latin1':\n\t case 'binary':\n\t return asciiWrite(this, string, offset, length)\n\n\t case 'base64':\n\t // Warning: maxLength not taken into account in base64Write\n\t return base64Write(this, string, offset, length)\n\n\t case 'ucs2':\n\t case 'ucs-2':\n\t case 'utf16le':\n\t case 'utf-16le':\n\t return ucs2Write(this, string, offset, length)\n\n\t default:\n\t if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n\t encoding = ('' + encoding).toLowerCase();\n\t loweredCase = true;\n\t }\n\t }\n\t};\n\n\tBuffer.prototype.toJSON = function toJSON () {\n\t return {\n\t type: 'Buffer',\n\t data: Array.prototype.slice.call(this._arr || this, 0)\n\t }\n\t};\n\n\tfunction base64Slice (buf, start, end) {\n\t if (start === 0 && end === buf.length) {\n\t return base64.fromByteArray(buf)\n\t } else {\n\t return base64.fromByteArray(buf.slice(start, end))\n\t }\n\t}\n\n\tfunction utf8Slice (buf, start, end) {\n\t end = Math.min(buf.length, end);\n\t const res = [];\n\n\t let i = start;\n\t while (i < end) {\n\t const firstByte = buf[i];\n\t let codePoint = null;\n\t let bytesPerSequence = (firstByte > 0xEF)\n\t ? 4\n\t : (firstByte > 0xDF)\n\t ? 3\n\t : (firstByte > 0xBF)\n\t ? 2\n\t : 1;\n\n\t if (i + bytesPerSequence <= end) {\n\t let secondByte, thirdByte, fourthByte, tempCodePoint;\n\n\t switch (bytesPerSequence) {\n\t case 1:\n\t if (firstByte < 0x80) {\n\t codePoint = firstByte;\n\t }\n\t break\n\t case 2:\n\t secondByte = buf[i + 1];\n\t if ((secondByte & 0xC0) === 0x80) {\n\t tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F);\n\t if (tempCodePoint > 0x7F) {\n\t codePoint = tempCodePoint;\n\t }\n\t }\n\t break\n\t case 3:\n\t secondByte = buf[i + 1];\n\t thirdByte = buf[i + 2];\n\t if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n\t tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F);\n\t if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n\t codePoint = tempCodePoint;\n\t }\n\t }\n\t break\n\t case 4:\n\t secondByte = buf[i + 1];\n\t thirdByte = buf[i + 2];\n\t fourthByte = buf[i + 3];\n\t if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n\t tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F);\n\t if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n\t codePoint = tempCodePoint;\n\t }\n\t }\n\t }\n\t }\n\n\t if (codePoint === null) {\n\t // we did not generate a valid codePoint so insert a\n\t // replacement char (U+FFFD) and advance only 1 byte\n\t codePoint = 0xFFFD;\n\t bytesPerSequence = 1;\n\t } else if (codePoint > 0xFFFF) {\n\t // encode to utf16 (surrogate pair dance)\n\t codePoint -= 0x10000;\n\t res.push(codePoint >>> 10 & 0x3FF | 0xD800);\n\t codePoint = 0xDC00 | codePoint & 0x3FF;\n\t }\n\n\t res.push(codePoint);\n\t i += bytesPerSequence;\n\t }\n\n\t return decodeCodePointsArray(res)\n\t}\n\n\t// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n\t// the lowest limit is Chrome, with 0x10000 args.\n\t// We go 1 magnitude less, for safety\n\tconst MAX_ARGUMENTS_LENGTH = 0x1000;\n\n\tfunction decodeCodePointsArray (codePoints) {\n\t const len = codePoints.length;\n\t if (len <= MAX_ARGUMENTS_LENGTH) {\n\t return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n\t }\n\n\t // Decode in chunks to avoid \"call stack size exceeded\".\n\t let res = '';\n\t let i = 0;\n\t while (i < len) {\n\t res += String.fromCharCode.apply(\n\t String,\n\t codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n\t );\n\t }\n\t return res\n\t}\n\n\tfunction asciiSlice (buf, start, end) {\n\t let ret = '';\n\t end = Math.min(buf.length, end);\n\n\t for (let i = start; i < end; ++i) {\n\t ret += String.fromCharCode(buf[i] & 0x7F);\n\t }\n\t return ret\n\t}\n\n\tfunction latin1Slice (buf, start, end) {\n\t let ret = '';\n\t end = Math.min(buf.length, end);\n\n\t for (let i = start; i < end; ++i) {\n\t ret += String.fromCharCode(buf[i]);\n\t }\n\t return ret\n\t}\n\n\tfunction hexSlice (buf, start, end) {\n\t const len = buf.length;\n\n\t if (!start || start < 0) start = 0;\n\t if (!end || end < 0 || end > len) end = len;\n\n\t let out = '';\n\t for (let i = start; i < end; ++i) {\n\t out += hexSliceLookupTable[buf[i]];\n\t }\n\t return out\n\t}\n\n\tfunction utf16leSlice (buf, start, end) {\n\t const bytes = buf.slice(start, end);\n\t let res = '';\n\t // If bytes.length is odd, the last 8 bits must be ignored (same as node.js)\n\t for (let i = 0; i < bytes.length - 1; i += 2) {\n\t res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256));\n\t }\n\t return res\n\t}\n\n\tBuffer.prototype.slice = function slice (start, end) {\n\t const len = this.length;\n\t start = ~~start;\n\t end = end === undefined ? len : ~~end;\n\n\t if (start < 0) {\n\t start += len;\n\t if (start < 0) start = 0;\n\t } else if (start > len) {\n\t start = len;\n\t }\n\n\t if (end < 0) {\n\t end += len;\n\t if (end < 0) end = 0;\n\t } else if (end > len) {\n\t end = len;\n\t }\n\n\t if (end < start) end = start;\n\n\t const newBuf = this.subarray(start, end);\n\t // Return an augmented `Uint8Array` instance\n\t Object.setPrototypeOf(newBuf, Buffer.prototype);\n\n\t return newBuf\n\t};\n\n\t/*\n\t * Need to make sure that buffer isn't trying to write out of bounds.\n\t */\n\tfunction checkOffset (offset, ext, length) {\n\t if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n\t if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n\t}\n\n\tBuffer.prototype.readUintLE =\n\tBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n\t offset = offset >>> 0;\n\t byteLength = byteLength >>> 0;\n\t if (!noAssert) checkOffset(offset, byteLength, this.length);\n\n\t let val = this[offset];\n\t let mul = 1;\n\t let i = 0;\n\t while (++i < byteLength && (mul *= 0x100)) {\n\t val += this[offset + i] * mul;\n\t }\n\n\t return val\n\t};\n\n\tBuffer.prototype.readUintBE =\n\tBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n\t offset = offset >>> 0;\n\t byteLength = byteLength >>> 0;\n\t if (!noAssert) {\n\t checkOffset(offset, byteLength, this.length);\n\t }\n\n\t let val = this[offset + --byteLength];\n\t let mul = 1;\n\t while (byteLength > 0 && (mul *= 0x100)) {\n\t val += this[offset + --byteLength] * mul;\n\t }\n\n\t return val\n\t};\n\n\tBuffer.prototype.readUint8 =\n\tBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n\t offset = offset >>> 0;\n\t if (!noAssert) checkOffset(offset, 1, this.length);\n\t return this[offset]\n\t};\n\n\tBuffer.prototype.readUint16LE =\n\tBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n\t offset = offset >>> 0;\n\t if (!noAssert) checkOffset(offset, 2, this.length);\n\t return this[offset] | (this[offset + 1] << 8)\n\t};\n\n\tBuffer.prototype.readUint16BE =\n\tBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n\t offset = offset >>> 0;\n\t if (!noAssert) checkOffset(offset, 2, this.length);\n\t return (this[offset] << 8) | this[offset + 1]\n\t};\n\n\tBuffer.prototype.readUint32LE =\n\tBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n\t offset = offset >>> 0;\n\t if (!noAssert) checkOffset(offset, 4, this.length);\n\n\t return ((this[offset]) |\n\t (this[offset + 1] << 8) |\n\t (this[offset + 2] << 16)) +\n\t (this[offset + 3] * 0x1000000)\n\t};\n\n\tBuffer.prototype.readUint32BE =\n\tBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n\t offset = offset >>> 0;\n\t if (!noAssert) checkOffset(offset, 4, this.length);\n\n\t return (this[offset] * 0x1000000) +\n\t ((this[offset + 1] << 16) |\n\t (this[offset + 2] << 8) |\n\t this[offset + 3])\n\t};\n\n\tBuffer.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE (offset) {\n\t offset = offset >>> 0;\n\t validateNumber(offset, 'offset');\n\t const first = this[offset];\n\t const last = this[offset + 7];\n\t if (first === undefined || last === undefined) {\n\t boundsError(offset, this.length - 8);\n\t }\n\n\t const lo = first +\n\t this[++offset] * 2 ** 8 +\n\t this[++offset] * 2 ** 16 +\n\t this[++offset] * 2 ** 24;\n\n\t const hi = this[++offset] +\n\t this[++offset] * 2 ** 8 +\n\t this[++offset] * 2 ** 16 +\n\t last * 2 ** 24;\n\n\t return BigInt(lo) + (BigInt(hi) << BigInt(32))\n\t});\n\n\tBuffer.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE (offset) {\n\t offset = offset >>> 0;\n\t validateNumber(offset, 'offset');\n\t const first = this[offset];\n\t const last = this[offset + 7];\n\t if (first === undefined || last === undefined) {\n\t boundsError(offset, this.length - 8);\n\t }\n\n\t const hi = first * 2 ** 24 +\n\t this[++offset] * 2 ** 16 +\n\t this[++offset] * 2 ** 8 +\n\t this[++offset];\n\n\t const lo = this[++offset] * 2 ** 24 +\n\t this[++offset] * 2 ** 16 +\n\t this[++offset] * 2 ** 8 +\n\t last;\n\n\t return (BigInt(hi) << BigInt(32)) + BigInt(lo)\n\t});\n\n\tBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n\t offset = offset >>> 0;\n\t byteLength = byteLength >>> 0;\n\t if (!noAssert) checkOffset(offset, byteLength, this.length);\n\n\t let val = this[offset];\n\t let mul = 1;\n\t let i = 0;\n\t while (++i < byteLength && (mul *= 0x100)) {\n\t val += this[offset + i] * mul;\n\t }\n\t mul *= 0x80;\n\n\t if (val >= mul) val -= Math.pow(2, 8 * byteLength);\n\n\t return val\n\t};\n\n\tBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n\t offset = offset >>> 0;\n\t byteLength = byteLength >>> 0;\n\t if (!noAssert) checkOffset(offset, byteLength, this.length);\n\n\t let i = byteLength;\n\t let mul = 1;\n\t let val = this[offset + --i];\n\t while (i > 0 && (mul *= 0x100)) {\n\t val += this[offset + --i] * mul;\n\t }\n\t mul *= 0x80;\n\n\t if (val >= mul) val -= Math.pow(2, 8 * byteLength);\n\n\t return val\n\t};\n\n\tBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n\t offset = offset >>> 0;\n\t if (!noAssert) checkOffset(offset, 1, this.length);\n\t if (!(this[offset] & 0x80)) return (this[offset])\n\t return ((0xff - this[offset] + 1) * -1)\n\t};\n\n\tBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n\t offset = offset >>> 0;\n\t if (!noAssert) checkOffset(offset, 2, this.length);\n\t const val = this[offset] | (this[offset + 1] << 8);\n\t return (val & 0x8000) ? val | 0xFFFF0000 : val\n\t};\n\n\tBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n\t offset = offset >>> 0;\n\t if (!noAssert) checkOffset(offset, 2, this.length);\n\t const val = this[offset + 1] | (this[offset] << 8);\n\t return (val & 0x8000) ? val | 0xFFFF0000 : val\n\t};\n\n\tBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n\t offset = offset >>> 0;\n\t if (!noAssert) checkOffset(offset, 4, this.length);\n\n\t return (this[offset]) |\n\t (this[offset + 1] << 8) |\n\t (this[offset + 2] << 16) |\n\t (this[offset + 3] << 24)\n\t};\n\n\tBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n\t offset = offset >>> 0;\n\t if (!noAssert) checkOffset(offset, 4, this.length);\n\n\t return (this[offset] << 24) |\n\t (this[offset + 1] << 16) |\n\t (this[offset + 2] << 8) |\n\t (this[offset + 3])\n\t};\n\n\tBuffer.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE (offset) {\n\t offset = offset >>> 0;\n\t validateNumber(offset, 'offset');\n\t const first = this[offset];\n\t const last = this[offset + 7];\n\t if (first === undefined || last === undefined) {\n\t boundsError(offset, this.length - 8);\n\t }\n\n\t const val = this[offset + 4] +\n\t this[offset + 5] * 2 ** 8 +\n\t this[offset + 6] * 2 ** 16 +\n\t (last << 24); // Overflow\n\n\t return (BigInt(val) << BigInt(32)) +\n\t BigInt(first +\n\t this[++offset] * 2 ** 8 +\n\t this[++offset] * 2 ** 16 +\n\t this[++offset] * 2 ** 24)\n\t});\n\n\tBuffer.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE (offset) {\n\t offset = offset >>> 0;\n\t validateNumber(offset, 'offset');\n\t const first = this[offset];\n\t const last = this[offset + 7];\n\t if (first === undefined || last === undefined) {\n\t boundsError(offset, this.length - 8);\n\t }\n\n\t const val = (first << 24) + // Overflow\n\t this[++offset] * 2 ** 16 +\n\t this[++offset] * 2 ** 8 +\n\t this[++offset];\n\n\t return (BigInt(val) << BigInt(32)) +\n\t BigInt(this[++offset] * 2 ** 24 +\n\t this[++offset] * 2 ** 16 +\n\t this[++offset] * 2 ** 8 +\n\t last)\n\t});\n\n\tBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n\t offset = offset >>> 0;\n\t if (!noAssert) checkOffset(offset, 4, this.length);\n\t return ieee754$1.read(this, offset, true, 23, 4)\n\t};\n\n\tBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n\t offset = offset >>> 0;\n\t if (!noAssert) checkOffset(offset, 4, this.length);\n\t return ieee754$1.read(this, offset, false, 23, 4)\n\t};\n\n\tBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n\t offset = offset >>> 0;\n\t if (!noAssert) checkOffset(offset, 8, this.length);\n\t return ieee754$1.read(this, offset, true, 52, 8)\n\t};\n\n\tBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n\t offset = offset >>> 0;\n\t if (!noAssert) checkOffset(offset, 8, this.length);\n\t return ieee754$1.read(this, offset, false, 52, 8)\n\t};\n\n\tfunction checkInt (buf, value, offset, ext, max, min) {\n\t if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n\t if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n\t if (offset + ext > buf.length) throw new RangeError('Index out of range')\n\t}\n\n\tBuffer.prototype.writeUintLE =\n\tBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n\t value = +value;\n\t offset = offset >>> 0;\n\t byteLength = byteLength >>> 0;\n\t if (!noAssert) {\n\t const maxBytes = Math.pow(2, 8 * byteLength) - 1;\n\t checkInt(this, value, offset, byteLength, maxBytes, 0);\n\t }\n\n\t let mul = 1;\n\t let i = 0;\n\t this[offset] = value & 0xFF;\n\t while (++i < byteLength && (mul *= 0x100)) {\n\t this[offset + i] = (value / mul) & 0xFF;\n\t }\n\n\t return offset + byteLength\n\t};\n\n\tBuffer.prototype.writeUintBE =\n\tBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n\t value = +value;\n\t offset = offset >>> 0;\n\t byteLength = byteLength >>> 0;\n\t if (!noAssert) {\n\t const maxBytes = Math.pow(2, 8 * byteLength) - 1;\n\t checkInt(this, value, offset, byteLength, maxBytes, 0);\n\t }\n\n\t let i = byteLength - 1;\n\t let mul = 1;\n\t this[offset + i] = value & 0xFF;\n\t while (--i >= 0 && (mul *= 0x100)) {\n\t this[offset + i] = (value / mul) & 0xFF;\n\t }\n\n\t return offset + byteLength\n\t};\n\n\tBuffer.prototype.writeUint8 =\n\tBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n\t value = +value;\n\t offset = offset >>> 0;\n\t if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0);\n\t this[offset] = (value & 0xff);\n\t return offset + 1\n\t};\n\n\tBuffer.prototype.writeUint16LE =\n\tBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n\t value = +value;\n\t offset = offset >>> 0;\n\t if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);\n\t this[offset] = (value & 0xff);\n\t this[offset + 1] = (value >>> 8);\n\t return offset + 2\n\t};\n\n\tBuffer.prototype.writeUint16BE =\n\tBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n\t value = +value;\n\t offset = offset >>> 0;\n\t if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);\n\t this[offset] = (value >>> 8);\n\t this[offset + 1] = (value & 0xff);\n\t return offset + 2\n\t};\n\n\tBuffer.prototype.writeUint32LE =\n\tBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n\t value = +value;\n\t offset = offset >>> 0;\n\t if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);\n\t this[offset + 3] = (value >>> 24);\n\t this[offset + 2] = (value >>> 16);\n\t this[offset + 1] = (value >>> 8);\n\t this[offset] = (value & 0xff);\n\t return offset + 4\n\t};\n\n\tBuffer.prototype.writeUint32BE =\n\tBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n\t value = +value;\n\t offset = offset >>> 0;\n\t if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);\n\t this[offset] = (value >>> 24);\n\t this[offset + 1] = (value >>> 16);\n\t this[offset + 2] = (value >>> 8);\n\t this[offset + 3] = (value & 0xff);\n\t return offset + 4\n\t};\n\n\tfunction wrtBigUInt64LE (buf, value, offset, min, max) {\n\t checkIntBI(value, min, max, buf, offset, 7);\n\n\t let lo = Number(value & BigInt(0xffffffff));\n\t buf[offset++] = lo;\n\t lo = lo >> 8;\n\t buf[offset++] = lo;\n\t lo = lo >> 8;\n\t buf[offset++] = lo;\n\t lo = lo >> 8;\n\t buf[offset++] = lo;\n\t let hi = Number(value >> BigInt(32) & BigInt(0xffffffff));\n\t buf[offset++] = hi;\n\t hi = hi >> 8;\n\t buf[offset++] = hi;\n\t hi = hi >> 8;\n\t buf[offset++] = hi;\n\t hi = hi >> 8;\n\t buf[offset++] = hi;\n\t return offset\n\t}\n\n\tfunction wrtBigUInt64BE (buf, value, offset, min, max) {\n\t checkIntBI(value, min, max, buf, offset, 7);\n\n\t let lo = Number(value & BigInt(0xffffffff));\n\t buf[offset + 7] = lo;\n\t lo = lo >> 8;\n\t buf[offset + 6] = lo;\n\t lo = lo >> 8;\n\t buf[offset + 5] = lo;\n\t lo = lo >> 8;\n\t buf[offset + 4] = lo;\n\t let hi = Number(value >> BigInt(32) & BigInt(0xffffffff));\n\t buf[offset + 3] = hi;\n\t hi = hi >> 8;\n\t buf[offset + 2] = hi;\n\t hi = hi >> 8;\n\t buf[offset + 1] = hi;\n\t hi = hi >> 8;\n\t buf[offset] = hi;\n\t return offset + 8\n\t}\n\n\tBuffer.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE (value, offset = 0) {\n\t return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt('0xffffffffffffffff'))\n\t});\n\n\tBuffer.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE (value, offset = 0) {\n\t return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt('0xffffffffffffffff'))\n\t});\n\n\tBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n\t value = +value;\n\t offset = offset >>> 0;\n\t if (!noAssert) {\n\t const limit = Math.pow(2, (8 * byteLength) - 1);\n\n\t checkInt(this, value, offset, byteLength, limit - 1, -limit);\n\t }\n\n\t let i = 0;\n\t let mul = 1;\n\t let sub = 0;\n\t this[offset] = value & 0xFF;\n\t while (++i < byteLength && (mul *= 0x100)) {\n\t if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n\t sub = 1;\n\t }\n\t this[offset + i] = ((value / mul) >> 0) - sub & 0xFF;\n\t }\n\n\t return offset + byteLength\n\t};\n\n\tBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n\t value = +value;\n\t offset = offset >>> 0;\n\t if (!noAssert) {\n\t const limit = Math.pow(2, (8 * byteLength) - 1);\n\n\t checkInt(this, value, offset, byteLength, limit - 1, -limit);\n\t }\n\n\t let i = byteLength - 1;\n\t let mul = 1;\n\t let sub = 0;\n\t this[offset + i] = value & 0xFF;\n\t while (--i >= 0 && (mul *= 0x100)) {\n\t if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n\t sub = 1;\n\t }\n\t this[offset + i] = ((value / mul) >> 0) - sub & 0xFF;\n\t }\n\n\t return offset + byteLength\n\t};\n\n\tBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n\t value = +value;\n\t offset = offset >>> 0;\n\t if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80);\n\t if (value < 0) value = 0xff + value + 1;\n\t this[offset] = (value & 0xff);\n\t return offset + 1\n\t};\n\n\tBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n\t value = +value;\n\t offset = offset >>> 0;\n\t if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);\n\t this[offset] = (value & 0xff);\n\t this[offset + 1] = (value >>> 8);\n\t return offset + 2\n\t};\n\n\tBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n\t value = +value;\n\t offset = offset >>> 0;\n\t if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);\n\t this[offset] = (value >>> 8);\n\t this[offset + 1] = (value & 0xff);\n\t return offset + 2\n\t};\n\n\tBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n\t value = +value;\n\t offset = offset >>> 0;\n\t if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);\n\t this[offset] = (value & 0xff);\n\t this[offset + 1] = (value >>> 8);\n\t this[offset + 2] = (value >>> 16);\n\t this[offset + 3] = (value >>> 24);\n\t return offset + 4\n\t};\n\n\tBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n\t value = +value;\n\t offset = offset >>> 0;\n\t if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);\n\t if (value < 0) value = 0xffffffff + value + 1;\n\t this[offset] = (value >>> 24);\n\t this[offset + 1] = (value >>> 16);\n\t this[offset + 2] = (value >>> 8);\n\t this[offset + 3] = (value & 0xff);\n\t return offset + 4\n\t};\n\n\tBuffer.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE (value, offset = 0) {\n\t return wrtBigUInt64LE(this, value, offset, -BigInt('0x8000000000000000'), BigInt('0x7fffffffffffffff'))\n\t});\n\n\tBuffer.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE (value, offset = 0) {\n\t return wrtBigUInt64BE(this, value, offset, -BigInt('0x8000000000000000'), BigInt('0x7fffffffffffffff'))\n\t});\n\n\tfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n\t if (offset + ext > buf.length) throw new RangeError('Index out of range')\n\t if (offset < 0) throw new RangeError('Index out of range')\n\t}\n\n\tfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n\t value = +value;\n\t offset = offset >>> 0;\n\t if (!noAssert) {\n\t checkIEEE754(buf, value, offset, 4);\n\t }\n\t ieee754$1.write(buf, value, offset, littleEndian, 23, 4);\n\t return offset + 4\n\t}\n\n\tBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n\t return writeFloat(this, value, offset, true, noAssert)\n\t};\n\n\tBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n\t return writeFloat(this, value, offset, false, noAssert)\n\t};\n\n\tfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n\t value = +value;\n\t offset = offset >>> 0;\n\t if (!noAssert) {\n\t checkIEEE754(buf, value, offset, 8);\n\t }\n\t ieee754$1.write(buf, value, offset, littleEndian, 52, 8);\n\t return offset + 8\n\t}\n\n\tBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n\t return writeDouble(this, value, offset, true, noAssert)\n\t};\n\n\tBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n\t return writeDouble(this, value, offset, false, noAssert)\n\t};\n\n\t// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\n\tBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n\t if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')\n\t if (!start) start = 0;\n\t if (!end && end !== 0) end = this.length;\n\t if (targetStart >= target.length) targetStart = target.length;\n\t if (!targetStart) targetStart = 0;\n\t if (end > 0 && end < start) end = start;\n\n\t // Copy 0 bytes; we're done\n\t if (end === start) return 0\n\t if (target.length === 0 || this.length === 0) return 0\n\n\t // Fatal error conditions\n\t if (targetStart < 0) {\n\t throw new RangeError('targetStart out of bounds')\n\t }\n\t if (start < 0 || start >= this.length) throw new RangeError('Index out of range')\n\t if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n\t // Are we oob?\n\t if (end > this.length) end = this.length;\n\t if (target.length - targetStart < end - start) {\n\t end = target.length - targetStart + start;\n\t }\n\n\t const len = end - start;\n\n\t if (this === target && typeof GlobalUint8Array.prototype.copyWithin === 'function') {\n\t // Use built-in when available, missing from IE11\n\t this.copyWithin(targetStart, start, end);\n\t } else {\n\t GlobalUint8Array.prototype.set.call(\n\t target,\n\t this.subarray(start, end),\n\t targetStart\n\t );\n\t }\n\n\t return len\n\t};\n\n\t// Usage:\n\t// buffer.fill(number[, offset[, end]])\n\t// buffer.fill(buffer[, offset[, end]])\n\t// buffer.fill(string[, offset[, end]][, encoding])\n\tBuffer.prototype.fill = function fill (val, start, end, encoding) {\n\t // Handle string cases:\n\t if (typeof val === 'string') {\n\t if (typeof start === 'string') {\n\t encoding = start;\n\t start = 0;\n\t end = this.length;\n\t } else if (typeof end === 'string') {\n\t encoding = end;\n\t end = this.length;\n\t }\n\t if (encoding !== undefined && typeof encoding !== 'string') {\n\t throw new TypeError('encoding must be a string')\n\t }\n\t if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n\t throw new TypeError('Unknown encoding: ' + encoding)\n\t }\n\t if (val.length === 1) {\n\t const code = val.charCodeAt(0);\n\t if ((encoding === 'utf8' && code < 128) ||\n\t encoding === 'latin1') {\n\t // Fast path: If `val` fits into a single byte, use that numeric value.\n\t val = code;\n\t }\n\t }\n\t } else if (typeof val === 'number') {\n\t val = val & 255;\n\t } else if (typeof val === 'boolean') {\n\t val = Number(val);\n\t }\n\n\t // Invalid ranges are not set to a default, so can range check early.\n\t if (start < 0 || this.length < start || this.length < end) {\n\t throw new RangeError('Out of range index')\n\t }\n\n\t if (end <= start) {\n\t return this\n\t }\n\n\t start = start >>> 0;\n\t end = end === undefined ? this.length : end >>> 0;\n\n\t if (!val) val = 0;\n\n\t let i;\n\t if (typeof val === 'number') {\n\t for (i = start; i < end; ++i) {\n\t this[i] = val;\n\t }\n\t } else {\n\t const bytes = Buffer.isBuffer(val)\n\t ? val\n\t : Buffer.from(val, encoding);\n\t const len = bytes.length;\n\t if (len === 0) {\n\t throw new TypeError('The value \"' + val +\n\t '\" is invalid for argument \"value\"')\n\t }\n\t for (i = 0; i < end - start; ++i) {\n\t this[i + start] = bytes[i % len];\n\t }\n\t }\n\n\t return this\n\t};\n\n\t// CUSTOM ERRORS\n\t// =============\n\n\t// Simplified versions from Node, changed for Buffer-only usage\n\tconst errors = {};\n\tfunction E (sym, getMessage, Base) {\n\t errors[sym] = class NodeError extends Base {\n\t constructor () {\n\t super();\n\n\t Object.defineProperty(this, 'message', {\n\t value: getMessage.apply(this, arguments),\n\t writable: true,\n\t configurable: true\n\t });\n\n\t // Add the error code to the name to include it in the stack trace.\n\t this.name = `${this.name} [${sym}]`;\n\t // Access the stack to generate the error message including the error code\n\t // from the name.\n\t this.stack; // eslint-disable-line no-unused-expressions\n\t // Reset the name to the actual name.\n\t delete this.name;\n\t }\n\n\t get code () {\n\t return sym\n\t }\n\n\t set code (value) {\n\t Object.defineProperty(this, 'code', {\n\t configurable: true,\n\t enumerable: true,\n\t value,\n\t writable: true\n\t });\n\t }\n\n\t toString () {\n\t return `${this.name} [${sym}]: ${this.message}`\n\t }\n\t };\n\t}\n\n\tE('ERR_BUFFER_OUT_OF_BOUNDS',\n\t function (name) {\n\t if (name) {\n\t return `${name} is outside of buffer bounds`\n\t }\n\n\t return 'Attempt to access memory outside buffer bounds'\n\t }, RangeError);\n\tE('ERR_INVALID_ARG_TYPE',\n\t function (name, actual) {\n\t return `The \"${name}\" argument must be of type number. Received type ${typeof actual}`\n\t }, TypeError);\n\tE('ERR_OUT_OF_RANGE',\n\t function (str, range, input) {\n\t let msg = `The value of \"${str}\" is out of range.`;\n\t let received = input;\n\t if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {\n\t received = addNumericalSeparator(String(input));\n\t } else if (typeof input === 'bigint') {\n\t received = String(input);\n\t if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) {\n\t received = addNumericalSeparator(received);\n\t }\n\t received += 'n';\n\t }\n\t msg += ` It must be ${range}. Received ${received}`;\n\t return msg\n\t }, RangeError);\n\n\tfunction addNumericalSeparator (val) {\n\t let res = '';\n\t let i = val.length;\n\t const start = val[0] === '-' ? 1 : 0;\n\t for (; i >= start + 4; i -= 3) {\n\t res = `_${val.slice(i - 3, i)}${res}`;\n\t }\n\t return `${val.slice(0, i)}${res}`\n\t}\n\n\t// CHECK FUNCTIONS\n\t// ===============\n\n\tfunction checkBounds (buf, offset, byteLength) {\n\t validateNumber(offset, 'offset');\n\t if (buf[offset] === undefined || buf[offset + byteLength] === undefined) {\n\t boundsError(offset, buf.length - (byteLength + 1));\n\t }\n\t}\n\n\tfunction checkIntBI (value, min, max, buf, offset, byteLength) {\n\t if (value > max || value < min) {\n\t const n = typeof min === 'bigint' ? 'n' : '';\n\t let range;\n\t if (byteLength > 3) {\n\t if (min === 0 || min === BigInt(0)) {\n\t range = `>= 0${n} and < 2${n} ** ${(byteLength + 1) * 8}${n}`;\n\t } else {\n\t range = `>= -(2${n} ** ${(byteLength + 1) * 8 - 1}${n}) and < 2 ** ` +\n\t `${(byteLength + 1) * 8 - 1}${n}`;\n\t }\n\t } else {\n\t range = `>= ${min}${n} and <= ${max}${n}`;\n\t }\n\t throw new errors.ERR_OUT_OF_RANGE('value', range, value)\n\t }\n\t checkBounds(buf, offset, byteLength);\n\t}\n\n\tfunction validateNumber (value, name) {\n\t if (typeof value !== 'number') {\n\t throw new errors.ERR_INVALID_ARG_TYPE(name, 'number', value)\n\t }\n\t}\n\n\tfunction boundsError (value, length, type) {\n\t if (Math.floor(value) !== value) {\n\t validateNumber(value, type);\n\t throw new errors.ERR_OUT_OF_RANGE(type || 'offset', 'an integer', value)\n\t }\n\n\t if (length < 0) {\n\t throw new errors.ERR_BUFFER_OUT_OF_BOUNDS()\n\t }\n\n\t throw new errors.ERR_OUT_OF_RANGE(type || 'offset',\n\t `>= ${type ? 1 : 0} and <= ${length}`,\n\t value)\n\t}\n\n\t// HELPER FUNCTIONS\n\t// ================\n\n\tconst INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;\n\n\tfunction base64clean (str) {\n\t // Node takes equal signs as end of the Base64 encoding\n\t str = str.split('=')[0];\n\t // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n\t str = str.trim().replace(INVALID_BASE64_RE, '');\n\t // Node converts strings with length < 2 to ''\n\t if (str.length < 2) return ''\n\t // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n\t while (str.length % 4 !== 0) {\n\t str = str + '=';\n\t }\n\t return str\n\t}\n\n\tfunction utf8ToBytes (string, units) {\n\t units = units || Infinity;\n\t let codePoint;\n\t const length = string.length;\n\t let leadSurrogate = null;\n\t const bytes = [];\n\n\t for (let i = 0; i < length; ++i) {\n\t codePoint = string.charCodeAt(i);\n\n\t // is surrogate component\n\t if (codePoint > 0xD7FF && codePoint < 0xE000) {\n\t // last char was a lead\n\t if (!leadSurrogate) {\n\t // no lead yet\n\t if (codePoint > 0xDBFF) {\n\t // unexpected trail\n\t if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);\n\t continue\n\t } else if (i + 1 === length) {\n\t // unpaired lead\n\t if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);\n\t continue\n\t }\n\n\t // valid lead\n\t leadSurrogate = codePoint;\n\n\t continue\n\t }\n\n\t // 2 leads in a row\n\t if (codePoint < 0xDC00) {\n\t if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);\n\t leadSurrogate = codePoint;\n\t continue\n\t }\n\n\t // valid surrogate pair\n\t codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000;\n\t } else if (leadSurrogate) {\n\t // valid bmp char, but last char was a lead\n\t if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);\n\t }\n\n\t leadSurrogate = null;\n\n\t // encode utf8\n\t if (codePoint < 0x80) {\n\t if ((units -= 1) < 0) break\n\t bytes.push(codePoint);\n\t } else if (codePoint < 0x800) {\n\t if ((units -= 2) < 0) break\n\t bytes.push(\n\t codePoint >> 0x6 | 0xC0,\n\t codePoint & 0x3F | 0x80\n\t );\n\t } else if (codePoint < 0x10000) {\n\t if ((units -= 3) < 0) break\n\t bytes.push(\n\t codePoint >> 0xC | 0xE0,\n\t codePoint >> 0x6 & 0x3F | 0x80,\n\t codePoint & 0x3F | 0x80\n\t );\n\t } else if (codePoint < 0x110000) {\n\t if ((units -= 4) < 0) break\n\t bytes.push(\n\t codePoint >> 0x12 | 0xF0,\n\t codePoint >> 0xC & 0x3F | 0x80,\n\t codePoint >> 0x6 & 0x3F | 0x80,\n\t codePoint & 0x3F | 0x80\n\t );\n\t } else {\n\t throw new Error('Invalid code point')\n\t }\n\t }\n\n\t return bytes\n\t}\n\n\tfunction asciiToBytes (str) {\n\t const byteArray = [];\n\t for (let i = 0; i < str.length; ++i) {\n\t // Node's code seems to be doing this and not & 0x7F..\n\t byteArray.push(str.charCodeAt(i) & 0xFF);\n\t }\n\t return byteArray\n\t}\n\n\tfunction utf16leToBytes (str, units) {\n\t let c, hi, lo;\n\t const byteArray = [];\n\t for (let i = 0; i < str.length; ++i) {\n\t if ((units -= 2) < 0) break\n\n\t c = str.charCodeAt(i);\n\t hi = c >> 8;\n\t lo = c % 256;\n\t byteArray.push(lo);\n\t byteArray.push(hi);\n\t }\n\n\t return byteArray\n\t}\n\n\tfunction base64ToBytes (str) {\n\t return base64.toByteArray(base64clean(str))\n\t}\n\n\tfunction blitBuffer (src, dst, offset, length) {\n\t let i;\n\t for (i = 0; i < length; ++i) {\n\t if ((i + offset >= dst.length) || (i >= src.length)) break\n\t dst[i + offset] = src[i];\n\t }\n\t return i\n\t}\n\n\t// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass\n\t// the `instanceof` check but they should be treated as of that type.\n\t// See: https://github.com/feross/buffer/issues/166\n\tfunction isInstance (obj, type) {\n\t return obj instanceof type ||\n\t (obj != null && obj.constructor != null && obj.constructor.name != null &&\n\t obj.constructor.name === type.name)\n\t}\n\tfunction numberIsNaN (obj) {\n\t // For IE11 support\n\t return obj !== obj // eslint-disable-line no-self-compare\n\t}\n\n\t// Create lookup table for `toString('hex')`\n\t// See: https://github.com/feross/buffer/issues/219\n\tconst hexSliceLookupTable = (function () {\n\t const alphabet = '0123456789abcdef';\n\t const table = new Array(256);\n\t for (let i = 0; i < 16; ++i) {\n\t const i16 = i * 16;\n\t for (let j = 0; j < 16; ++j) {\n\t table[i16 + j] = alphabet[i] + alphabet[j];\n\t }\n\t }\n\t return table\n\t})();\n\n\t// Return not function with Error if BigInt not supported\n\tfunction defineBigIntMethod (fn) {\n\t return typeof BigInt === 'undefined' ? BufferBigIntNotDefined : fn\n\t}\n\n\tfunction BufferBigIntNotDefined () {\n\t throw new Error('BigInt not supported')\n\t} \n} (buffer));\n\nconst Buffer = buffer.Buffer;\n\nexports.Blob = buffer.Blob;\nexports.BlobOptions = buffer.BlobOptions;\nexports.Buffer = buffer.Buffer;\nexports.File = buffer.File;\nexports.FileOptions = buffer.FileOptions;\nexports.INSPECT_MAX_BYTES = buffer.INSPECT_MAX_BYTES;\nexports.SlowBuffer = buffer.SlowBuffer;\nexports.TranscodeEncoding = buffer.TranscodeEncoding;\nexports.atob = buffer.atob;\nexports.btoa = buffer.btoa;\nexports.constants = buffer.constants;\nexports.default = Buffer;\nexports.isAscii = buffer.isAscii;\nexports.isUtf8 = buffer.isUtf8;\nexports.kMaxLength = buffer.kMaxLength;\nexports.kStringMaxLength = buffer.kStringMaxLength;\nexports.resolveObjectURL = buffer.resolveObjectURL;\nexports.transcode = buffer.transcode;\n//# sourceMappingURL=index.cjs.map\n","'use strict';\n\n/** @type {import('./shams')} */\n/* eslint complexity: [2, 18], max-statements: [2, 33] */\nmodule.exports = function hasSymbols() {\n\tif (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }\n\tif (typeof Symbol.iterator === 'symbol') { return true; }\n\n\t/** @type {{ [k in symbol]?: unknown }} */\n\tvar obj = {};\n\tvar sym = Symbol('test');\n\tvar symObj = Object(sym);\n\tif (typeof sym === 'string') { return false; }\n\n\tif (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; }\n\tif (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; }\n\n\t// temp disabled per https://github.com/ljharb/object.assign/issues/17\n\t// if (sym instanceof Symbol) { return false; }\n\t// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4\n\t// if (!(symObj instanceof Symbol)) { return false; }\n\n\t// if (typeof Symbol.prototype.toString !== 'function') { return false; }\n\t// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }\n\n\tvar symVal = 42;\n\tobj[sym] = symVal;\n\tfor (var _ in obj) { return false; } // eslint-disable-line no-restricted-syntax, no-unreachable-loop\n\tif (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }\n\n\tif (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }\n\n\tvar syms = Object.getOwnPropertySymbols(obj);\n\tif (syms.length !== 1 || syms[0] !== sym) { return false; }\n\n\tif (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }\n\n\tif (typeof Object.getOwnPropertyDescriptor === 'function') {\n\t\t// eslint-disable-next-line no-extra-parens\n\t\tvar descriptor = /** @type {PropertyDescriptor} */ (Object.getOwnPropertyDescriptor(obj, sym));\n\t\tif (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }\n\t}\n\n\treturn true;\n};\n","'use strict';\n\nvar hasSymbols = require('has-symbols/shams');\n\n/** @type {import('.')} */\nmodule.exports = function hasToStringTagShams() {\n\treturn hasSymbols() && !!Symbol.toStringTag;\n};\n","'use strict';\n\n/** @type {import('.')} */\nmodule.exports = Object;\n","'use strict';\n\n/** @type {import('.')} */\nmodule.exports = Error;\n","'use strict';\n\n/** @type {import('./eval')} */\nmodule.exports = EvalError;\n","'use strict';\n\n/** @type {import('./range')} */\nmodule.exports = RangeError;\n","'use strict';\n\n/** @type {import('./ref')} */\nmodule.exports = ReferenceError;\n","'use strict';\n\n/** @type {import('./syntax')} */\nmodule.exports = SyntaxError;\n","'use strict';\n\n/** @type {import('./type')} */\nmodule.exports = TypeError;\n","'use strict';\n\n/** @type {import('./uri')} */\nmodule.exports = URIError;\n","'use strict';\n\n/** @type {import('./abs')} */\nmodule.exports = Math.abs;\n","'use strict';\n\n/** @type {import('./floor')} */\nmodule.exports = Math.floor;\n","'use strict';\n\n/** @type {import('./max')} */\nmodule.exports = Math.max;\n","'use strict';\n\n/** @type {import('./min')} */\nmodule.exports = Math.min;\n","'use strict';\n\n/** @type {import('./pow')} */\nmodule.exports = Math.pow;\n","'use strict';\n\n/** @type {import('./round')} */\nmodule.exports = Math.round;\n","'use strict';\n\n/** @type {import('./isNaN')} */\nmodule.exports = Number.isNaN || function isNaN(a) {\n\treturn a !== a;\n};\n","'use strict';\n\nvar $isNaN = require('./isNaN');\n\n/** @type {import('./sign')} */\nmodule.exports = function sign(number) {\n\tif ($isNaN(number) || number === 0) {\n\t\treturn number;\n\t}\n\treturn number < 0 ? -1 : +1;\n};\n","'use strict';\n\n/** @type {import('./gOPD')} */\nmodule.exports = Object.getOwnPropertyDescriptor;\n","'use strict';\n\n/** @type {import('.')} */\nvar $gOPD = require('./gOPD');\n\nif ($gOPD) {\n\ttry {\n\t\t$gOPD([], 'length');\n\t} catch (e) {\n\t\t// IE 8 has a broken gOPD\n\t\t$gOPD = null;\n\t}\n}\n\nmodule.exports = $gOPD;\n","'use strict';\n\n/** @type {import('.')} */\nvar $defineProperty = Object.defineProperty || false;\nif ($defineProperty) {\n\ttry {\n\t\t$defineProperty({}, 'a', { value: 1 });\n\t} catch (e) {\n\t\t// IE 8 has a broken defineProperty\n\t\t$defineProperty = false;\n\t}\n}\n\nmodule.exports = $defineProperty;\n","'use strict';\n\nvar origSymbol = typeof Symbol !== 'undefined' && Symbol;\nvar hasSymbolSham = require('./shams');\n\n/** @type {import('.')} */\nmodule.exports = function hasNativeSymbols() {\n\tif (typeof origSymbol !== 'function') { return false; }\n\tif (typeof Symbol !== 'function') { return false; }\n\tif (typeof origSymbol('foo') !== 'symbol') { return false; }\n\tif (typeof Symbol('bar') !== 'symbol') { return false; }\n\n\treturn hasSymbolSham();\n};\n","'use strict';\n\n/** @type {import('./Reflect.getPrototypeOf')} */\nmodule.exports = (typeof Reflect !== 'undefined' && Reflect.getPrototypeOf) || null;\n","'use strict';\n\nvar $Object = require('es-object-atoms');\n\n/** @type {import('./Object.getPrototypeOf')} */\nmodule.exports = $Object.getPrototypeOf || null;\n","'use strict';\n\n/* eslint no-invalid-this: 1 */\n\nvar ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';\nvar toStr = Object.prototype.toString;\nvar max = Math.max;\nvar funcType = '[object Function]';\n\nvar concatty = function concatty(a, b) {\n var arr = [];\n\n for (var i = 0; i < a.length; i += 1) {\n arr[i] = a[i];\n }\n for (var j = 0; j < b.length; j += 1) {\n arr[j + a.length] = b[j];\n }\n\n return arr;\n};\n\nvar slicy = function slicy(arrLike, offset) {\n var arr = [];\n for (var i = offset || 0, j = 0; i < arrLike.length; i += 1, j += 1) {\n arr[j] = arrLike[i];\n }\n return arr;\n};\n\nvar joiny = function (arr, joiner) {\n var str = '';\n for (var i = 0; i < arr.length; i += 1) {\n str += arr[i];\n if (i + 1 < arr.length) {\n str += joiner;\n }\n }\n return str;\n};\n\nmodule.exports = function bind(that) {\n var target = this;\n if (typeof target !== 'function' || toStr.apply(target) !== funcType) {\n throw new TypeError(ERROR_MESSAGE + target);\n }\n var args = slicy(arguments, 1);\n\n var bound;\n var binder = function () {\n if (this instanceof bound) {\n var result = target.apply(\n this,\n concatty(args, arguments)\n );\n if (Object(result) === result) {\n return result;\n }\n return this;\n }\n return target.apply(\n that,\n concatty(args, arguments)\n );\n\n };\n\n var boundLength = max(0, target.length - args.length);\n var boundArgs = [];\n for (var i = 0; i < boundLength; i++) {\n boundArgs[i] = '$' + i;\n }\n\n bound = Function('binder', 'return function (' + joiny(boundArgs, ',') + '){ return binder.apply(this,arguments); }')(binder);\n\n if (target.prototype) {\n var Empty = function Empty() {};\n Empty.prototype = target.prototype;\n bound.prototype = new Empty();\n Empty.prototype = null;\n }\n\n return bound;\n};\n","'use strict';\n\nvar implementation = require('./implementation');\n\nmodule.exports = Function.prototype.bind || implementation;\n","'use strict';\n\n/** @type {import('./functionCall')} */\nmodule.exports = Function.prototype.call;\n","'use strict';\n\n/** @type {import('./functionApply')} */\nmodule.exports = Function.prototype.apply;\n","'use strict';\n\n/** @type {import('./reflectApply')} */\nmodule.exports = typeof Reflect !== 'undefined' && Reflect && Reflect.apply;\n","'use strict';\n\nvar bind = require('function-bind');\n\nvar $apply = require('./functionApply');\nvar $call = require('./functionCall');\nvar $reflectApply = require('./reflectApply');\n\n/** @type {import('./actualApply')} */\nmodule.exports = $reflectApply || bind.call($call, $apply);\n","'use strict';\n\nvar bind = require('function-bind');\nvar $TypeError = require('es-errors/type');\n\nvar $call = require('./functionCall');\nvar $actualApply = require('./actualApply');\n\n/** @type {(args: [Function, thisArg?: unknown, ...args: unknown[]]) => Function} TODO FIXME, find a way to use import('.') */\nmodule.exports = function callBindBasic(args) {\n\tif (args.length < 1 || typeof args[0] !== 'function') {\n\t\tthrow new $TypeError('a function is required');\n\t}\n\treturn $actualApply(bind, $call, args);\n};\n","'use strict';\n\nvar callBind = require('call-bind-apply-helpers');\nvar gOPD = require('gopd');\n\nvar hasProtoAccessor;\ntry {\n\t// eslint-disable-next-line no-extra-parens, no-proto\n\thasProtoAccessor = /** @type {{ __proto__?: typeof Array.prototype }} */ ([]).__proto__ === Array.prototype;\n} catch (e) {\n\tif (!e || typeof e !== 'object' || !('code' in e) || e.code !== 'ERR_PROTO_ACCESS') {\n\t\tthrow e;\n\t}\n}\n\n// eslint-disable-next-line no-extra-parens\nvar desc = !!hasProtoAccessor && gOPD && gOPD(Object.prototype, /** @type {keyof typeof Object.prototype} */ ('__proto__'));\n\nvar $Object = Object;\nvar $getPrototypeOf = $Object.getPrototypeOf;\n\n/** @type {import('./get')} */\nmodule.exports = desc && typeof desc.get === 'function'\n\t? callBind([desc.get])\n\t: typeof $getPrototypeOf === 'function'\n\t\t? /** @type {import('./get')} */ function getDunder(value) {\n\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\treturn $getPrototypeOf(value == null ? value : $Object(value));\n\t\t}\n\t\t: false;\n","'use strict';\n\nvar reflectGetProto = require('./Reflect.getPrototypeOf');\nvar originalGetProto = require('./Object.getPrototypeOf');\n\nvar getDunderProto = require('dunder-proto/get');\n\n/** @type {import('.')} */\nmodule.exports = reflectGetProto\n\t? function getProto(O) {\n\t\t// @ts-expect-error TS can't narrow inside a closure, for some reason\n\t\treturn reflectGetProto(O);\n\t}\n\t: originalGetProto\n\t\t? function getProto(O) {\n\t\t\tif (!O || (typeof O !== 'object' && typeof O !== 'function')) {\n\t\t\t\tthrow new TypeError('getProto: not an object');\n\t\t\t}\n\t\t\t// @ts-expect-error TS can't narrow inside a closure, for some reason\n\t\t\treturn originalGetProto(O);\n\t\t}\n\t\t: getDunderProto\n\t\t\t? function getProto(O) {\n\t\t\t\t// @ts-expect-error TS can't narrow inside a closure, for some reason\n\t\t\t\treturn getDunderProto(O);\n\t\t\t}\n\t\t\t: null;\n","'use strict';\n\nvar call = Function.prototype.call;\nvar $hasOwn = Object.prototype.hasOwnProperty;\nvar bind = require('function-bind');\n\n/** @type {import('.')} */\nmodule.exports = bind.call(call, $hasOwn);\n","'use strict';\n\nvar undefined;\n\nvar $Object = require('es-object-atoms');\n\nvar $Error = require('es-errors');\nvar $EvalError = require('es-errors/eval');\nvar $RangeError = require('es-errors/range');\nvar $ReferenceError = require('es-errors/ref');\nvar $SyntaxError = require('es-errors/syntax');\nvar $TypeError = require('es-errors/type');\nvar $URIError = require('es-errors/uri');\n\nvar abs = require('math-intrinsics/abs');\nvar floor = require('math-intrinsics/floor');\nvar max = require('math-intrinsics/max');\nvar min = require('math-intrinsics/min');\nvar pow = require('math-intrinsics/pow');\nvar round = require('math-intrinsics/round');\nvar sign = require('math-intrinsics/sign');\n\nvar $Function = Function;\n\n// eslint-disable-next-line consistent-return\nvar getEvalledConstructor = function (expressionSyntax) {\n\ttry {\n\t\treturn $Function('\"use strict\"; return (' + expressionSyntax + ').constructor;')();\n\t} catch (e) {}\n};\n\nvar $gOPD = require('gopd');\nvar $defineProperty = require('es-define-property');\n\nvar throwTypeError = function () {\n\tthrow new $TypeError();\n};\nvar ThrowTypeError = $gOPD\n\t? (function () {\n\t\ttry {\n\t\t\t// eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties\n\t\t\targuments.callee; // IE 8 does not throw here\n\t\t\treturn throwTypeError;\n\t\t} catch (calleeThrows) {\n\t\t\ttry {\n\t\t\t\t// IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '')\n\t\t\t\treturn $gOPD(arguments, 'callee').get;\n\t\t\t} catch (gOPDthrows) {\n\t\t\t\treturn throwTypeError;\n\t\t\t}\n\t\t}\n\t}())\n\t: throwTypeError;\n\nvar hasSymbols = require('has-symbols')();\n\nvar getProto = require('get-proto');\nvar $ObjectGPO = require('get-proto/Object.getPrototypeOf');\nvar $ReflectGPO = require('get-proto/Reflect.getPrototypeOf');\n\nvar $apply = require('call-bind-apply-helpers/functionApply');\nvar $call = require('call-bind-apply-helpers/functionCall');\n\nvar needsEval = {};\n\nvar TypedArray = typeof Uint8Array === 'undefined' || !getProto ? undefined : getProto(Uint8Array);\n\nvar INTRINSICS = {\n\t__proto__: null,\n\t'%AggregateError%': typeof AggregateError === 'undefined' ? undefined : AggregateError,\n\t'%Array%': Array,\n\t'%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer,\n\t'%ArrayIteratorPrototype%': hasSymbols && getProto ? getProto([][Symbol.iterator]()) : undefined,\n\t'%AsyncFromSyncIteratorPrototype%': undefined,\n\t'%AsyncFunction%': needsEval,\n\t'%AsyncGenerator%': needsEval,\n\t'%AsyncGeneratorFunction%': needsEval,\n\t'%AsyncIteratorPrototype%': needsEval,\n\t'%Atomics%': typeof Atomics === 'undefined' ? undefined : Atomics,\n\t'%BigInt%': typeof BigInt === 'undefined' ? undefined : BigInt,\n\t'%BigInt64Array%': typeof BigInt64Array === 'undefined' ? undefined : BigInt64Array,\n\t'%BigUint64Array%': typeof BigUint64Array === 'undefined' ? undefined : BigUint64Array,\n\t'%Boolean%': Boolean,\n\t'%DataView%': typeof DataView === 'undefined' ? undefined : DataView,\n\t'%Date%': Date,\n\t'%decodeURI%': decodeURI,\n\t'%decodeURIComponent%': decodeURIComponent,\n\t'%encodeURI%': encodeURI,\n\t'%encodeURIComponent%': encodeURIComponent,\n\t'%Error%': $Error,\n\t'%eval%': eval, // eslint-disable-line no-eval\n\t'%EvalError%': $EvalError,\n\t'%Float16Array%': typeof Float16Array === 'undefined' ? undefined : Float16Array,\n\t'%Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array,\n\t'%Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array,\n\t'%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined : FinalizationRegistry,\n\t'%Function%': $Function,\n\t'%GeneratorFunction%': needsEval,\n\t'%Int8Array%': typeof Int8Array === 'undefined' ? undefined : Int8Array,\n\t'%Int16Array%': typeof Int16Array === 'undefined' ? undefined : Int16Array,\n\t'%Int32Array%': typeof Int32Array === 'undefined' ? undefined : Int32Array,\n\t'%isFinite%': isFinite,\n\t'%isNaN%': isNaN,\n\t'%IteratorPrototype%': hasSymbols && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined,\n\t'%JSON%': typeof JSON === 'object' ? JSON : undefined,\n\t'%Map%': typeof Map === 'undefined' ? undefined : Map,\n\t'%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols || !getProto ? undefined : getProto(new Map()[Symbol.iterator]()),\n\t'%Math%': Math,\n\t'%Number%': Number,\n\t'%Object%': $Object,\n\t'%Object.getOwnPropertyDescriptor%': $gOPD,\n\t'%parseFloat%': parseFloat,\n\t'%parseInt%': parseInt,\n\t'%Promise%': typeof Promise === 'undefined' ? undefined : Promise,\n\t'%Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy,\n\t'%RangeError%': $RangeError,\n\t'%ReferenceError%': $ReferenceError,\n\t'%Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect,\n\t'%RegExp%': RegExp,\n\t'%Set%': typeof Set === 'undefined' ? undefined : Set,\n\t'%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols || !getProto ? undefined : getProto(new Set()[Symbol.iterator]()),\n\t'%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer,\n\t'%String%': String,\n\t'%StringIteratorPrototype%': hasSymbols && getProto ? getProto(''[Symbol.iterator]()) : undefined,\n\t'%Symbol%': hasSymbols ? Symbol : undefined,\n\t'%SyntaxError%': $SyntaxError,\n\t'%ThrowTypeError%': ThrowTypeError,\n\t'%TypedArray%': TypedArray,\n\t'%TypeError%': $TypeError,\n\t'%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array,\n\t'%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray,\n\t'%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array,\n\t'%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array,\n\t'%URIError%': $URIError,\n\t'%WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap,\n\t'%WeakRef%': typeof WeakRef === 'undefined' ? undefined : WeakRef,\n\t'%WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet,\n\n\t'%Function.prototype.call%': $call,\n\t'%Function.prototype.apply%': $apply,\n\t'%Object.defineProperty%': $defineProperty,\n\t'%Object.getPrototypeOf%': $ObjectGPO,\n\t'%Math.abs%': abs,\n\t'%Math.floor%': floor,\n\t'%Math.max%': max,\n\t'%Math.min%': min,\n\t'%Math.pow%': pow,\n\t'%Math.round%': round,\n\t'%Math.sign%': sign,\n\t'%Reflect.getPrototypeOf%': $ReflectGPO\n};\n\nif (getProto) {\n\ttry {\n\t\tnull.error; // eslint-disable-line no-unused-expressions\n\t} catch (e) {\n\t\t// https://github.com/tc39/proposal-shadowrealm/pull/384#issuecomment-1364264229\n\t\tvar errorProto = getProto(getProto(e));\n\t\tINTRINSICS['%Error.prototype%'] = errorProto;\n\t}\n}\n\nvar doEval = function doEval(name) {\n\tvar value;\n\tif (name === '%AsyncFunction%') {\n\t\tvalue = getEvalledConstructor('async function () {}');\n\t} else if (name === '%GeneratorFunction%') {\n\t\tvalue = getEvalledConstructor('function* () {}');\n\t} else if (name === '%AsyncGeneratorFunction%') {\n\t\tvalue = getEvalledConstructor('async function* () {}');\n\t} else if (name === '%AsyncGenerator%') {\n\t\tvar fn = doEval('%AsyncGeneratorFunction%');\n\t\tif (fn) {\n\t\t\tvalue = fn.prototype;\n\t\t}\n\t} else if (name === '%AsyncIteratorPrototype%') {\n\t\tvar gen = doEval('%AsyncGenerator%');\n\t\tif (gen && getProto) {\n\t\t\tvalue = getProto(gen.prototype);\n\t\t}\n\t}\n\n\tINTRINSICS[name] = value;\n\n\treturn value;\n};\n\nvar LEGACY_ALIASES = {\n\t__proto__: null,\n\t'%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'],\n\t'%ArrayPrototype%': ['Array', 'prototype'],\n\t'%ArrayProto_entries%': ['Array', 'prototype', 'entries'],\n\t'%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'],\n\t'%ArrayProto_keys%': ['Array', 'prototype', 'keys'],\n\t'%ArrayProto_values%': ['Array', 'prototype', 'values'],\n\t'%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'],\n\t'%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'],\n\t'%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype', 'prototype'],\n\t'%BooleanPrototype%': ['Boolean', 'prototype'],\n\t'%DataViewPrototype%': ['DataView', 'prototype'],\n\t'%DatePrototype%': ['Date', 'prototype'],\n\t'%ErrorPrototype%': ['Error', 'prototype'],\n\t'%EvalErrorPrototype%': ['EvalError', 'prototype'],\n\t'%Float32ArrayPrototype%': ['Float32Array', 'prototype'],\n\t'%Float64ArrayPrototype%': ['Float64Array', 'prototype'],\n\t'%FunctionPrototype%': ['Function', 'prototype'],\n\t'%Generator%': ['GeneratorFunction', 'prototype'],\n\t'%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'],\n\t'%Int8ArrayPrototype%': ['Int8Array', 'prototype'],\n\t'%Int16ArrayPrototype%': ['Int16Array', 'prototype'],\n\t'%Int32ArrayPrototype%': ['Int32Array', 'prototype'],\n\t'%JSONParse%': ['JSON', 'parse'],\n\t'%JSONStringify%': ['JSON', 'stringify'],\n\t'%MapPrototype%': ['Map', 'prototype'],\n\t'%NumberPrototype%': ['Number', 'prototype'],\n\t'%ObjectPrototype%': ['Object', 'prototype'],\n\t'%ObjProto_toString%': ['Object', 'prototype', 'toString'],\n\t'%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'],\n\t'%PromisePrototype%': ['Promise', 'prototype'],\n\t'%PromiseProto_then%': ['Promise', 'prototype', 'then'],\n\t'%Promise_all%': ['Promise', 'all'],\n\t'%Promise_reject%': ['Promise', 'reject'],\n\t'%Promise_resolve%': ['Promise', 'resolve'],\n\t'%RangeErrorPrototype%': ['RangeError', 'prototype'],\n\t'%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'],\n\t'%RegExpPrototype%': ['RegExp', 'prototype'],\n\t'%SetPrototype%': ['Set', 'prototype'],\n\t'%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'],\n\t'%StringPrototype%': ['String', 'prototype'],\n\t'%SymbolPrototype%': ['Symbol', 'prototype'],\n\t'%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'],\n\t'%TypedArrayPrototype%': ['TypedArray', 'prototype'],\n\t'%TypeErrorPrototype%': ['TypeError', 'prototype'],\n\t'%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'],\n\t'%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'],\n\t'%Uint16ArrayPrototype%': ['Uint16Array', 'prototype'],\n\t'%Uint32ArrayPrototype%': ['Uint32Array', 'prototype'],\n\t'%URIErrorPrototype%': ['URIError', 'prototype'],\n\t'%WeakMapPrototype%': ['WeakMap', 'prototype'],\n\t'%WeakSetPrototype%': ['WeakSet', 'prototype']\n};\n\nvar bind = require('function-bind');\nvar hasOwn = require('hasown');\nvar $concat = bind.call($call, Array.prototype.concat);\nvar $spliceApply = bind.call($apply, Array.prototype.splice);\nvar $replace = bind.call($call, String.prototype.replace);\nvar $strSlice = bind.call($call, String.prototype.slice);\nvar $exec = bind.call($call, RegExp.prototype.exec);\n\n/* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */\nvar rePropName = /[^%.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|%$))/g;\nvar reEscapeChar = /\\\\(\\\\)?/g; /** Used to match backslashes in property paths. */\nvar stringToPath = function stringToPath(string) {\n\tvar first = $strSlice(string, 0, 1);\n\tvar last = $strSlice(string, -1);\n\tif (first === '%' && last !== '%') {\n\t\tthrow new $SyntaxError('invalid intrinsic syntax, expected closing `%`');\n\t} else if (last === '%' && first !== '%') {\n\t\tthrow new $SyntaxError('invalid intrinsic syntax, expected opening `%`');\n\t}\n\tvar result = [];\n\t$replace(string, rePropName, function (match, number, quote, subString) {\n\t\tresult[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number || match;\n\t});\n\treturn result;\n};\n/* end adaptation */\n\nvar getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {\n\tvar intrinsicName = name;\n\tvar alias;\n\tif (hasOwn(LEGACY_ALIASES, intrinsicName)) {\n\t\talias = LEGACY_ALIASES[intrinsicName];\n\t\tintrinsicName = '%' + alias[0] + '%';\n\t}\n\n\tif (hasOwn(INTRINSICS, intrinsicName)) {\n\t\tvar value = INTRINSICS[intrinsicName];\n\t\tif (value === needsEval) {\n\t\t\tvalue = doEval(intrinsicName);\n\t\t}\n\t\tif (typeof value === 'undefined' && !allowMissing) {\n\t\t\tthrow new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!');\n\t\t}\n\n\t\treturn {\n\t\t\talias: alias,\n\t\t\tname: intrinsicName,\n\t\t\tvalue: value\n\t\t};\n\t}\n\n\tthrow new $SyntaxError('intrinsic ' + name + ' does not exist!');\n};\n\nmodule.exports = function GetIntrinsic(name, allowMissing) {\n\tif (typeof name !== 'string' || name.length === 0) {\n\t\tthrow new $TypeError('intrinsic name must be a non-empty string');\n\t}\n\tif (arguments.length > 1 && typeof allowMissing !== 'boolean') {\n\t\tthrow new $TypeError('\"allowMissing\" argument must be a boolean');\n\t}\n\n\tif ($exec(/^%?[^%]*%?$/, name) === null) {\n\t\tthrow new $SyntaxError('`%` may not be present anywhere but at the beginning and end of the intrinsic name');\n\t}\n\tvar parts = stringToPath(name);\n\tvar intrinsicBaseName = parts.length > 0 ? parts[0] : '';\n\n\tvar intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%', allowMissing);\n\tvar intrinsicRealName = intrinsic.name;\n\tvar value = intrinsic.value;\n\tvar skipFurtherCaching = false;\n\n\tvar alias = intrinsic.alias;\n\tif (alias) {\n\t\tintrinsicBaseName = alias[0];\n\t\t$spliceApply(parts, $concat([0, 1], alias));\n\t}\n\n\tfor (var i = 1, isOwn = true; i < parts.length; i += 1) {\n\t\tvar part = parts[i];\n\t\tvar first = $strSlice(part, 0, 1);\n\t\tvar last = $strSlice(part, -1);\n\t\tif (\n\t\t\t(\n\t\t\t\t(first === '\"' || first === \"'\" || first === '`')\n\t\t\t\t|| (last === '\"' || last === \"'\" || last === '`')\n\t\t\t)\n\t\t\t&& first !== last\n\t\t) {\n\t\t\tthrow new $SyntaxError('property names with quotes must have matching quotes');\n\t\t}\n\t\tif (part === 'constructor' || !isOwn) {\n\t\t\tskipFurtherCaching = true;\n\t\t}\n\n\t\tintrinsicBaseName += '.' + part;\n\t\tintrinsicRealName = '%' + intrinsicBaseName + '%';\n\n\t\tif (hasOwn(INTRINSICS, intrinsicRealName)) {\n\t\t\tvalue = INTRINSICS[intrinsicRealName];\n\t\t} else if (value != null) {\n\t\t\tif (!(part in value)) {\n\t\t\t\tif (!allowMissing) {\n\t\t\t\t\tthrow new $TypeError('base intrinsic for ' + name + ' exists, but the property is not available.');\n\t\t\t\t}\n\t\t\t\treturn void undefined;\n\t\t\t}\n\t\t\tif ($gOPD && (i + 1) >= parts.length) {\n\t\t\t\tvar desc = $gOPD(value, part);\n\t\t\t\tisOwn = !!desc;\n\n\t\t\t\t// By convention, when a data property is converted to an accessor\n\t\t\t\t// property to emulate a data property that does not suffer from\n\t\t\t\t// the override mistake, that accessor's getter is marked with\n\t\t\t\t// an `originalValue` property. Here, when we detect this, we\n\t\t\t\t// uphold the illusion by pretending to see that original data\n\t\t\t\t// property, i.e., returning the value rather than the getter\n\t\t\t\t// itself.\n\t\t\t\tif (isOwn && 'get' in desc && !('originalValue' in desc.get)) {\n\t\t\t\t\tvalue = desc.get;\n\t\t\t\t} else {\n\t\t\t\t\tvalue = value[part];\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tisOwn = hasOwn(value, part);\n\t\t\t\tvalue = value[part];\n\t\t\t}\n\n\t\t\tif (isOwn && !skipFurtherCaching) {\n\t\t\t\tINTRINSICS[intrinsicRealName] = value;\n\t\t\t}\n\t\t}\n\t}\n\treturn value;\n};\n","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar callBindBasic = require('call-bind-apply-helpers');\n\n/** @type {(thisArg: string, searchString: string, position?: number) => number} */\nvar $indexOf = callBindBasic([GetIntrinsic('%String.prototype.indexOf%')]);\n\n/** @type {import('.')} */\nmodule.exports = function callBoundIntrinsic(name, allowMissing) {\n\t/* eslint no-extra-parens: 0 */\n\n\tvar intrinsic = /** @type {(this: unknown, ...args: unknown[]) => unknown} */ (GetIntrinsic(name, !!allowMissing));\n\tif (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) {\n\t\treturn callBindBasic(/** @type {const} */ ([intrinsic]));\n\t}\n\treturn intrinsic;\n};\n","'use strict';\n\nvar hasToStringTag = require('has-tostringtag/shams')();\nvar callBound = require('call-bound');\n\nvar $toString = callBound('Object.prototype.toString');\n\n/** @type {import('.')} */\nvar isStandardArguments = function isArguments(value) {\n\tif (\n\t\thasToStringTag\n\t\t&& value\n\t\t&& typeof value === 'object'\n\t\t&& Symbol.toStringTag in value\n\t) {\n\t\treturn false;\n\t}\n\treturn $toString(value) === '[object Arguments]';\n};\n\n/** @type {import('.')} */\nvar isLegacyArguments = function isArguments(value) {\n\tif (isStandardArguments(value)) {\n\t\treturn true;\n\t}\n\treturn value !== null\n\t\t&& typeof value === 'object'\n\t\t&& 'length' in value\n\t\t&& typeof value.length === 'number'\n\t\t&& value.length >= 0\n\t\t&& $toString(value) !== '[object Array]'\n\t\t&& 'callee' in value\n\t\t&& $toString(value.callee) === '[object Function]';\n};\n\nvar supportsStandardArguments = (function () {\n\treturn isStandardArguments(arguments);\n}());\n\n// @ts-expect-error TODO make this not error\nisStandardArguments.isLegacyArguments = isLegacyArguments; // for tests\n\n/** @type {import('.')} */\nmodule.exports = supportsStandardArguments ? isStandardArguments : isLegacyArguments;\n","'use strict';\n\nvar callBound = require('call-bound');\nvar hasToStringTag = require('has-tostringtag/shams')();\nvar hasOwn = require('hasown');\nvar gOPD = require('gopd');\n\n/** @type {import('.')} */\nvar fn;\n\nif (hasToStringTag) {\n\t/** @type {(receiver: ThisParameterType<typeof RegExp.prototype.exec>, ...args: Parameters<typeof RegExp.prototype.exec>) => ReturnType<typeof RegExp.prototype.exec>} */\n\tvar $exec = callBound('RegExp.prototype.exec');\n\t/** @type {object} */\n\tvar isRegexMarker = {};\n\n\tvar throwRegexMarker = function () {\n\t\tthrow isRegexMarker;\n\t};\n\t/** @type {{ toString(): never, valueOf(): never, [Symbol.toPrimitive]?(): never }} */\n\tvar badStringifier = {\n\t\ttoString: throwRegexMarker,\n\t\tvalueOf: throwRegexMarker\n\t};\n\n\tif (typeof Symbol.toPrimitive === 'symbol') {\n\t\tbadStringifier[Symbol.toPrimitive] = throwRegexMarker;\n\t}\n\n\t/** @type {import('.')} */\n\t// @ts-expect-error TS can't figure out that the $exec call always throws\n\t// eslint-disable-next-line consistent-return\n\tfn = function isRegex(value) {\n\t\tif (!value || typeof value !== 'object') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// eslint-disable-next-line no-extra-parens\n\t\tvar descriptor = /** @type {NonNullable<typeof gOPD>} */ (gOPD)(/** @type {{ lastIndex?: unknown }} */ (value), 'lastIndex');\n\t\tvar hasLastIndexDataProperty = descriptor && hasOwn(descriptor, 'value');\n\t\tif (!hasLastIndexDataProperty) {\n\t\t\treturn false;\n\t\t}\n\n\t\ttry {\n\t\t\t// eslint-disable-next-line no-extra-parens\n\t\t\t$exec(value, /** @type {string} */ (/** @type {unknown} */ (badStringifier)));\n\t\t} catch (e) {\n\t\t\treturn e === isRegexMarker;\n\t\t}\n\t};\n} else {\n\t/** @type {(receiver: ThisParameterType<typeof Object.prototype.toString>, ...args: Parameters<typeof Object.prototype.toString>) => ReturnType<typeof Object.prototype.toString>} */\n\tvar $toString = callBound('Object.prototype.toString');\n\t/** @const @type {'[object RegExp]'} */\n\tvar regexClass = '[object RegExp]';\n\n\t/** @type {import('.')} */\n\tfn = function isRegex(value) {\n\t\t// In older browsers, typeof regex incorrectly returns 'function'\n\t\tif (!value || (typeof value !== 'object' && typeof value !== 'function')) {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn $toString(value) === regexClass;\n\t};\n}\n\nmodule.exports = fn;\n","'use strict';\n\nvar callBound = require('call-bound');\nvar isRegex = require('is-regex');\n\nvar $exec = callBound('RegExp.prototype.exec');\nvar $TypeError = require('es-errors/type');\n\n/** @type {import('.')} */\nmodule.exports = function regexTester(regex) {\n\tif (!isRegex(regex)) {\n\t\tthrow new $TypeError('`regex` must be a RegExp');\n\t}\n\treturn function test(s) {\n\t\treturn $exec(regex, s) !== null;\n\t};\n};\n","'use strict';\n\n// eslint-disable-next-line no-extra-parens, no-empty-function\nconst cached = /** @type {GeneratorFunctionConstructor} */ (function* () {}.constructor);\n\n/** @type {import('.')} */\nmodule.exports = () => cached;\n\n","'use strict';\n\nvar callBound = require('call-bound');\nvar safeRegexTest = require('safe-regex-test');\nvar isFnRegex = safeRegexTest(/^\\s*(?:function)?\\*/);\nvar hasToStringTag = require('has-tostringtag/shams')();\nvar getProto = require('get-proto');\n\nvar toStr = callBound('Object.prototype.toString');\nvar fnToStr = callBound('Function.prototype.toString');\n\nvar getGeneratorFunction = require('generator-function');\n\n/** @type {import('.')} */\nmodule.exports = function isGeneratorFunction(fn) {\n\tif (typeof fn !== 'function') {\n\t\treturn false;\n\t}\n\tif (isFnRegex(fnToStr(fn))) {\n\t\treturn true;\n\t}\n\tif (!hasToStringTag) {\n\t\tvar str = toStr(fn);\n\t\treturn str === '[object GeneratorFunction]';\n\t}\n\tif (!getProto) {\n\t\treturn false;\n\t}\n\tvar GeneratorFunction = getGeneratorFunction();\n\treturn GeneratorFunction && getProto(fn) === GeneratorFunction.prototype;\n};\n","'use strict';\n\nvar fnToStr = Function.prototype.toString;\nvar reflectApply = typeof Reflect === 'object' && Reflect !== null && Reflect.apply;\nvar badArrayLike;\nvar isCallableMarker;\nif (typeof reflectApply === 'function' && typeof Object.defineProperty === 'function') {\n\ttry {\n\t\tbadArrayLike = Object.defineProperty({}, 'length', {\n\t\t\tget: function () {\n\t\t\t\tthrow isCallableMarker;\n\t\t\t}\n\t\t});\n\t\tisCallableMarker = {};\n\t\t// eslint-disable-next-line no-throw-literal\n\t\treflectApply(function () { throw 42; }, null, badArrayLike);\n\t} catch (_) {\n\t\tif (_ !== isCallableMarker) {\n\t\t\treflectApply = null;\n\t\t}\n\t}\n} else {\n\treflectApply = null;\n}\n\nvar constructorRegex = /^\\s*class\\b/;\nvar isES6ClassFn = function isES6ClassFunction(value) {\n\ttry {\n\t\tvar fnStr = fnToStr.call(value);\n\t\treturn constructorRegex.test(fnStr);\n\t} catch (e) {\n\t\treturn false; // not a function\n\t}\n};\n\nvar tryFunctionObject = function tryFunctionToStr(value) {\n\ttry {\n\t\tif (isES6ClassFn(value)) { return false; }\n\t\tfnToStr.call(value);\n\t\treturn true;\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\nvar toStr = Object.prototype.toString;\nvar objectClass = '[object Object]';\nvar fnClass = '[object Function]';\nvar genClass = '[object GeneratorFunction]';\nvar ddaClass = '[object HTMLAllCollection]'; // IE 11\nvar ddaClass2 = '[object HTML document.all class]';\nvar ddaClass3 = '[object HTMLCollection]'; // IE 9-10\nvar hasToStringTag = typeof Symbol === 'function' && !!Symbol.toStringTag; // better: use `has-tostringtag`\n\nvar isIE68 = !(0 in [,]); // eslint-disable-line no-sparse-arrays, comma-spacing\n\nvar isDDA = function isDocumentDotAll() { return false; };\nif (typeof document === 'object') {\n\t// Firefox 3 canonicalizes DDA to undefined when it's not accessed directly\n\tvar all = document.all;\n\tif (toStr.call(all) === toStr.call(document.all)) {\n\t\tisDDA = function isDocumentDotAll(value) {\n\t\t\t/* globals document: false */\n\t\t\t// in IE 6-8, typeof document.all is \"object\" and it's truthy\n\t\t\tif ((isIE68 || !value) && (typeof value === 'undefined' || typeof value === 'object')) {\n\t\t\t\ttry {\n\t\t\t\t\tvar str = toStr.call(value);\n\t\t\t\t\treturn (\n\t\t\t\t\t\tstr === ddaClass\n\t\t\t\t\t\t|| str === ddaClass2\n\t\t\t\t\t\t|| str === ddaClass3 // opera 12.16\n\t\t\t\t\t\t|| str === objectClass // IE 6-8\n\t\t\t\t\t) && value('') == null; // eslint-disable-line eqeqeq\n\t\t\t\t} catch (e) { /**/ }\n\t\t\t}\n\t\t\treturn false;\n\t\t};\n\t}\n}\n\nmodule.exports = reflectApply\n\t? function isCallable(value) {\n\t\tif (isDDA(value)) { return true; }\n\t\tif (!value) { return false; }\n\t\tif (typeof value !== 'function' && typeof value !== 'object') { return false; }\n\t\ttry {\n\t\t\treflectApply(value, null, badArrayLike);\n\t\t} catch (e) {\n\t\t\tif (e !== isCallableMarker) { return false; }\n\t\t}\n\t\treturn !isES6ClassFn(value) && tryFunctionObject(value);\n\t}\n\t: function isCallable(value) {\n\t\tif (isDDA(value)) { return true; }\n\t\tif (!value) { return false; }\n\t\tif (typeof value !== 'function' && typeof value !== 'object') { return false; }\n\t\tif (hasToStringTag) { return tryFunctionObject(value); }\n\t\tif (isES6ClassFn(value)) { return false; }\n\t\tvar strClass = toStr.call(value);\n\t\tif (strClass !== fnClass && strClass !== genClass && !(/^\\[object HTML/).test(strClass)) { return false; }\n\t\treturn tryFunctionObject(value);\n\t};\n","'use strict';\n\nvar isCallable = require('is-callable');\n\nvar toStr = Object.prototype.toString;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\n/** @type {<This, A extends readonly unknown[]>(arr: A, iterator: (this: This | void, value: A[number], index: number, arr: A) => void, receiver: This | undefined) => void} */\nvar forEachArray = function forEachArray(array, iterator, receiver) {\n for (var i = 0, len = array.length; i < len; i++) {\n if (hasOwnProperty.call(array, i)) {\n if (receiver == null) {\n iterator(array[i], i, array);\n } else {\n iterator.call(receiver, array[i], i, array);\n }\n }\n }\n};\n\n/** @type {<This, S extends string>(string: S, iterator: (this: This | void, value: S[number], index: number, string: S) => void, receiver: This | undefined) => void} */\nvar forEachString = function forEachString(string, iterator, receiver) {\n for (var i = 0, len = string.length; i < len; i++) {\n // no such thing as a sparse string.\n if (receiver == null) {\n iterator(string.charAt(i), i, string);\n } else {\n iterator.call(receiver, string.charAt(i), i, string);\n }\n }\n};\n\n/** @type {<This, O>(obj: O, iterator: (this: This | void, value: O[keyof O], index: keyof O, obj: O) => void, receiver: This | undefined) => void} */\nvar forEachObject = function forEachObject(object, iterator, receiver) {\n for (var k in object) {\n if (hasOwnProperty.call(object, k)) {\n if (receiver == null) {\n iterator(object[k], k, object);\n } else {\n iterator.call(receiver, object[k], k, object);\n }\n }\n }\n};\n\n/** @type {(x: unknown) => x is readonly unknown[]} */\nfunction isArray(x) {\n return toStr.call(x) === '[object Array]';\n}\n\n/** @type {import('.')._internal} */\nmodule.exports = function forEach(list, iterator, thisArg) {\n if (!isCallable(iterator)) {\n throw new TypeError('iterator must be a function');\n }\n\n var receiver;\n if (arguments.length >= 3) {\n receiver = thisArg;\n }\n\n if (isArray(list)) {\n forEachArray(list, iterator, receiver);\n } else if (typeof list === 'string') {\n forEachString(list, iterator, receiver);\n } else {\n forEachObject(list, iterator, receiver);\n }\n};\n","'use strict';\n\n/** @type {import('.')} */\nmodule.exports = [\n\t'Float16Array',\n\t'Float32Array',\n\t'Float64Array',\n\t'Int8Array',\n\t'Int16Array',\n\t'Int32Array',\n\t'Uint8Array',\n\t'Uint8ClampedArray',\n\t'Uint16Array',\n\t'Uint32Array',\n\t'BigInt64Array',\n\t'BigUint64Array'\n];\n","'use strict';\n\nvar possibleNames = require('possible-typed-array-names');\n\nvar g = typeof globalThis === 'undefined' ? global : globalThis;\n\n/** @type {import('.')} */\nmodule.exports = function availableTypedArrays() {\n\tvar /** @type {ReturnType<typeof availableTypedArrays>} */ out = [];\n\tfor (var i = 0; i < possibleNames.length; i++) {\n\t\tif (typeof g[possibleNames[i]] === 'function') {\n\t\t\t// @ts-expect-error\n\t\t\tout[out.length] = possibleNames[i];\n\t\t}\n\t}\n\treturn out;\n};\n","'use strict';\n\nvar $defineProperty = require('es-define-property');\n\nvar $SyntaxError = require('es-errors/syntax');\nvar $TypeError = require('es-errors/type');\n\nvar gopd = require('gopd');\n\n/** @type {import('.')} */\nmodule.exports = function defineDataProperty(\n\tobj,\n\tproperty,\n\tvalue\n) {\n\tif (!obj || (typeof obj !== 'object' && typeof obj !== 'function')) {\n\t\tthrow new $TypeError('`obj` must be an object or a function`');\n\t}\n\tif (typeof property !== 'string' && typeof property !== 'symbol') {\n\t\tthrow new $TypeError('`property` must be a string or a symbol`');\n\t}\n\tif (arguments.length > 3 && typeof arguments[3] !== 'boolean' && arguments[3] !== null) {\n\t\tthrow new $TypeError('`nonEnumerable`, if provided, must be a boolean or null');\n\t}\n\tif (arguments.length > 4 && typeof arguments[4] !== 'boolean' && arguments[4] !== null) {\n\t\tthrow new $TypeError('`nonWritable`, if provided, must be a boolean or null');\n\t}\n\tif (arguments.length > 5 && typeof arguments[5] !== 'boolean' && arguments[5] !== null) {\n\t\tthrow new $TypeError('`nonConfigurable`, if provided, must be a boolean or null');\n\t}\n\tif (arguments.length > 6 && typeof arguments[6] !== 'boolean') {\n\t\tthrow new $TypeError('`loose`, if provided, must be a boolean');\n\t}\n\n\tvar nonEnumerable = arguments.length > 3 ? arguments[3] : null;\n\tvar nonWritable = arguments.length > 4 ? arguments[4] : null;\n\tvar nonConfigurable = arguments.length > 5 ? arguments[5] : null;\n\tvar loose = arguments.length > 6 ? arguments[6] : false;\n\n\t/* @type {false | TypedPropertyDescriptor<unknown>} */\n\tvar desc = !!gopd && gopd(obj, property);\n\n\tif ($defineProperty) {\n\t\t$defineProperty(obj, property, {\n\t\t\tconfigurable: nonConfigurable === null && desc ? desc.configurable : !nonConfigurable,\n\t\t\tenumerable: nonEnumerable === null && desc ? desc.enumerable : !nonEnumerable,\n\t\t\tvalue: value,\n\t\t\twritable: nonWritable === null && desc ? desc.writable : !nonWritable\n\t\t});\n\t} else if (loose || (!nonEnumerable && !nonWritable && !nonConfigurable)) {\n\t\t// must fall back to [[Set]], and was not explicitly asked to make non-enumerable, non-writable, or non-configurable\n\t\tobj[property] = value; // eslint-disable-line no-param-reassign\n\t} else {\n\t\tthrow new $SyntaxError('This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.');\n\t}\n};\n","'use strict';\n\nvar $defineProperty = require('es-define-property');\n\nvar hasPropertyDescriptors = function hasPropertyDescriptors() {\n\treturn !!$defineProperty;\n};\n\nhasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() {\n\t// node v0.6 has a bug where array lengths can be Set but not Defined\n\tif (!$defineProperty) {\n\t\treturn null;\n\t}\n\ttry {\n\t\treturn $defineProperty([], 'length', { value: 1 }).length !== 1;\n\t} catch (e) {\n\t\t// In Firefox 4-22, defining length on an array throws an exception.\n\t\treturn true;\n\t}\n};\n\nmodule.exports = hasPropertyDescriptors;\n","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\nvar define = require('define-data-property');\nvar hasDescriptors = require('has-property-descriptors')();\nvar gOPD = require('gopd');\n\nvar $TypeError = require('es-errors/type');\nvar $floor = GetIntrinsic('%Math.floor%');\n\n/** @type {import('.')} */\nmodule.exports = function setFunctionLength(fn, length) {\n\tif (typeof fn !== 'function') {\n\t\tthrow new $TypeError('`fn` is not a function');\n\t}\n\tif (typeof length !== 'number' || length < 0 || length > 0xFFFFFFFF || $floor(length) !== length) {\n\t\tthrow new $TypeError('`length` must be a positive 32-bit integer');\n\t}\n\n\tvar loose = arguments.length > 2 && !!arguments[2];\n\n\tvar functionLengthIsConfigurable = true;\n\tvar functionLengthIsWritable = true;\n\tif ('length' in fn && gOPD) {\n\t\tvar desc = gOPD(fn, 'length');\n\t\tif (desc && !desc.configurable) {\n\t\t\tfunctionLengthIsConfigurable = false;\n\t\t}\n\t\tif (desc && !desc.writable) {\n\t\t\tfunctionLengthIsWritable = false;\n\t\t}\n\t}\n\n\tif (functionLengthIsConfigurable || functionLengthIsWritable || !loose) {\n\t\tif (hasDescriptors) {\n\t\t\tdefine(/** @type {Parameters<define>[0]} */ (fn), 'length', length, true, true);\n\t\t} else {\n\t\t\tdefine(/** @type {Parameters<define>[0]} */ (fn), 'length', length);\n\t\t}\n\t}\n\treturn fn;\n};\n","'use strict';\n\nvar bind = require('function-bind');\nvar $apply = require('./functionApply');\nvar actualApply = require('./actualApply');\n\n/** @type {import('./applyBind')} */\nmodule.exports = function applyBind() {\n\treturn actualApply(bind, $apply, arguments);\n};\n","'use strict';\n\nvar setFunctionLength = require('set-function-length');\n\nvar $defineProperty = require('es-define-property');\n\nvar callBindBasic = require('call-bind-apply-helpers');\nvar applyBind = require('call-bind-apply-helpers/applyBind');\n\nmodule.exports = function callBind(originalFunction) {\n\tvar func = callBindBasic(arguments);\n\tvar adjustedLength = originalFunction.length - (arguments.length - 1);\n\treturn setFunctionLength(\n\t\tfunc,\n\t\t1 + (adjustedLength > 0 ? adjustedLength : 0),\n\t\ttrue\n\t);\n};\n\nif ($defineProperty) {\n\t$defineProperty(module.exports, 'apply', { value: applyBind });\n} else {\n\tmodule.exports.apply = applyBind;\n}\n","'use strict';\n\nvar forEach = require('for-each');\nvar availableTypedArrays = require('available-typed-arrays');\nvar callBind = require('call-bind');\nvar callBound = require('call-bound');\nvar gOPD = require('gopd');\nvar getProto = require('get-proto');\n\nvar $toString = callBound('Object.prototype.toString');\nvar hasToStringTag = require('has-tostringtag/shams')();\n\nvar g = typeof globalThis === 'undefined' ? global : globalThis;\nvar typedArrays = availableTypedArrays();\n\nvar $slice = callBound('String.prototype.slice');\n\n/** @type {<T = unknown>(array: readonly T[], value: unknown) => number} */\nvar $indexOf = callBound('Array.prototype.indexOf', true) || function indexOf(array, value) {\n\tfor (var i = 0; i < array.length; i += 1) {\n\t\tif (array[i] === value) {\n\t\t\treturn i;\n\t\t}\n\t}\n\treturn -1;\n};\n\n/** @typedef {import('./types').Getter} Getter */\n/** @type {import('./types').Cache} */\nvar cache = { __proto__: null };\nif (hasToStringTag && gOPD && getProto) {\n\tforEach(typedArrays, function (typedArray) {\n\t\tvar arr = new g[typedArray]();\n\t\tif (Symbol.toStringTag in arr && getProto) {\n\t\t\tvar proto = getProto(arr);\n\t\t\t// @ts-expect-error TS won't narrow inside a closure\n\t\t\tvar descriptor = gOPD(proto, Symbol.toStringTag);\n\t\t\tif (!descriptor && proto) {\n\t\t\t\tvar superProto = getProto(proto);\n\t\t\t\t// @ts-expect-error TS won't narrow inside a closure\n\t\t\t\tdescriptor = gOPD(superProto, Symbol.toStringTag);\n\t\t\t}\n\t\t\t// @ts-expect-error TODO: fix\n\t\t\tcache['$' + typedArray] = callBind(descriptor.get);\n\t\t}\n\t});\n} else {\n\tforEach(typedArrays, function (typedArray) {\n\t\tvar arr = new g[typedArray]();\n\t\tvar fn = arr.slice || arr.set;\n\t\tif (fn) {\n\t\t\tcache[\n\t\t\t\t/** @type {`$${import('.').TypedArrayName}`} */ ('$' + typedArray)\n\t\t\t] = /** @type {import('./types').BoundSlice | import('./types').BoundSet} */ (\n\t\t\t\t// @ts-expect-error TODO FIXME\n\t\t\t\tcallBind(fn)\n\t\t\t);\n\t\t}\n\t});\n}\n\n/** @type {(value: object) => false | import('.').TypedArrayName} */\nvar tryTypedArrays = function tryAllTypedArrays(value) {\n\t/** @type {ReturnType<typeof tryAllTypedArrays>} */ var found = false;\n\tforEach(\n\t\t/** @type {Record<`\\$${import('.').TypedArrayName}`, Getter>} */ (cache),\n\t\t/** @type {(getter: Getter, name: `\\$${import('.').TypedArrayName}`) => void} */\n\t\tfunction (getter, typedArray) {\n\t\t\tif (!found) {\n\t\t\t\ttry {\n\t\t\t\t\t// @ts-expect-error a throw is fine here\n\t\t\t\t\tif ('$' + getter(value) === typedArray) {\n\t\t\t\t\t\tfound = /** @type {import('.').TypedArrayName} */ ($slice(typedArray, 1));\n\t\t\t\t\t}\n\t\t\t\t} catch (e) { /**/ }\n\t\t\t}\n\t\t}\n\t);\n\treturn found;\n};\n\n/** @type {(value: object) => false | import('.').TypedArrayName} */\nvar trySlices = function tryAllSlices(value) {\n\t/** @type {ReturnType<typeof tryAllSlices>} */ var found = false;\n\tforEach(\n\t\t/** @type {Record<`\\$${import('.').TypedArrayName}`, Getter>} */(cache),\n\t\t/** @type {(getter: Getter, name: `\\$${import('.').TypedArrayName}`) => void} */ function (getter, name) {\n\t\t\tif (!found) {\n\t\t\t\ttry {\n\t\t\t\t\t// @ts-expect-error a throw is fine here\n\t\t\t\t\tgetter(value);\n\t\t\t\t\tfound = /** @type {import('.').TypedArrayName} */ ($slice(name, 1));\n\t\t\t\t} catch (e) { /**/ }\n\t\t\t}\n\t\t}\n\t);\n\treturn found;\n};\n\n/** @type {import('.')} */\nmodule.exports = function whichTypedArray(value) {\n\tif (!value || typeof value !== 'object') { return false; }\n\tif (!hasToStringTag) {\n\t\t/** @type {string} */\n\t\tvar tag = $slice($toString(value), 8, -1);\n\t\tif ($indexOf(typedArrays, tag) > -1) {\n\t\t\treturn tag;\n\t\t}\n\t\tif (tag !== 'Object') {\n\t\t\treturn false;\n\t\t}\n\t\t// node < 0.6 hits here on real Typed Arrays\n\t\treturn trySlices(value);\n\t}\n\tif (!gOPD) { return null; } // unknown engine\n\treturn tryTypedArrays(value);\n};\n","'use strict';\n\nvar whichTypedArray = require('which-typed-array');\n\n/** @type {import('.')} */\nmodule.exports = function isTypedArray(value) {\n\treturn !!whichTypedArray(value);\n};\n","// Currently in sync with Node.js lib/internal/util/types.js\n// https://github.com/nodejs/node/commit/112cc7c27551254aa2b17098fb774867f05ed0d9\n\n'use strict';\n\nvar isArgumentsObject = require('is-arguments');\nvar isGeneratorFunction = require('is-generator-function');\nvar whichTypedArray = require('which-typed-array');\nvar isTypedArray = require('is-typed-array');\n\nfunction uncurryThis(f) {\n return f.call.bind(f);\n}\n\nvar BigIntSupported = typeof BigInt !== 'undefined';\nvar SymbolSupported = typeof Symbol !== 'undefined';\n\nvar ObjectToString = uncurryThis(Object.prototype.toString);\n\nvar numberValue = uncurryThis(Number.prototype.valueOf);\nvar stringValue = uncurryThis(String.prototype.valueOf);\nvar booleanValue = uncurryThis(Boolean.prototype.valueOf);\n\nif (BigIntSupported) {\n var bigIntValue = uncurryThis(BigInt.prototype.valueOf);\n}\n\nif (SymbolSupported) {\n var symbolValue = uncurryThis(Symbol.prototype.valueOf);\n}\n\nfunction checkBoxedPrimitive(value, prototypeValueOf) {\n if (typeof value !== 'object') {\n return false;\n }\n try {\n prototypeValueOf(value);\n return true;\n } catch(e) {\n return false;\n }\n}\n\nexports.isArgumentsObject = isArgumentsObject;\nexports.isGeneratorFunction = isGeneratorFunction;\nexports.isTypedArray = isTypedArray;\n\n// Taken from here and modified for better browser support\n// https://github.com/sindresorhus/p-is-promise/blob/cda35a513bda03f977ad5cde3a079d237e82d7ef/index.js\nfunction isPromise(input) {\n\treturn (\n\t\t(\n\t\t\ttypeof Promise !== 'undefined' &&\n\t\t\tinput instanceof Promise\n\t\t) ||\n\t\t(\n\t\t\tinput !== null &&\n\t\t\ttypeof input === 'object' &&\n\t\t\ttypeof input.then === 'function' &&\n\t\t\ttypeof input.catch === 'function'\n\t\t)\n\t);\n}\nexports.isPromise = isPromise;\n\nfunction isArrayBufferView(value) {\n if (typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView) {\n return ArrayBuffer.isView(value);\n }\n\n return (\n isTypedArray(value) ||\n isDataView(value)\n );\n}\nexports.isArrayBufferView = isArrayBufferView;\n\n\nfunction isUint8Array(value) {\n return whichTypedArray(value) === 'Uint8Array';\n}\nexports.isUint8Array = isUint8Array;\n\nfunction isUint8ClampedArray(value) {\n return whichTypedArray(value) === 'Uint8ClampedArray';\n}\nexports.isUint8ClampedArray = isUint8ClampedArray;\n\nfunction isUint16Array(value) {\n return whichTypedArray(value) === 'Uint16Array';\n}\nexports.isUint16Array = isUint16Array;\n\nfunction isUint32Array(value) {\n return whichTypedArray(value) === 'Uint32Array';\n}\nexports.isUint32Array = isUint32Array;\n\nfunction isInt8Array(value) {\n return whichTypedArray(value) === 'Int8Array';\n}\nexports.isInt8Array = isInt8Array;\n\nfunction isInt16Array(value) {\n return whichTypedArray(value) === 'Int16Array';\n}\nexports.isInt16Array = isInt16Array;\n\nfunction isInt32Array(value) {\n return whichTypedArray(value) === 'Int32Array';\n}\nexports.isInt32Array = isInt32Array;\n\nfunction isFloat32Array(value) {\n return whichTypedArray(value) === 'Float32Array';\n}\nexports.isFloat32Array = isFloat32Array;\n\nfunction isFloat64Array(value) {\n return whichTypedArray(value) === 'Float64Array';\n}\nexports.isFloat64Array = isFloat64Array;\n\nfunction isBigInt64Array(value) {\n return whichTypedArray(value) === 'BigInt64Array';\n}\nexports.isBigInt64Array = isBigInt64Array;\n\nfunction isBigUint64Array(value) {\n return whichTypedArray(value) === 'BigUint64Array';\n}\nexports.isBigUint64Array = isBigUint64Array;\n\nfunction isMapToString(value) {\n return ObjectToString(value) === '[object Map]';\n}\nisMapToString.working = (\n typeof Map !== 'undefined' &&\n isMapToString(new Map())\n);\n\nfunction isMap(value) {\n if (typeof Map === 'undefined') {\n return false;\n }\n\n return isMapToString.working\n ? isMapToString(value)\n : value instanceof Map;\n}\nexports.isMap = isMap;\n\nfunction isSetToString(value) {\n return ObjectToString(value) === '[object Set]';\n}\nisSetToString.working = (\n typeof Set !== 'undefined' &&\n isSetToString(new Set())\n);\nfunction isSet(value) {\n if (typeof Set === 'undefined') {\n return false;\n }\n\n return isSetToString.working\n ? isSetToString(value)\n : value instanceof Set;\n}\nexports.isSet = isSet;\n\nfunction isWeakMapToString(value) {\n return ObjectToString(value) === '[object WeakMap]';\n}\nisWeakMapToString.working = (\n typeof WeakMap !== 'undefined' &&\n isWeakMapToString(new WeakMap())\n);\nfunction isWeakMap(value) {\n if (typeof WeakMap === 'undefined') {\n return false;\n }\n\n return isWeakMapToString.working\n ? isWeakMapToString(value)\n : value instanceof WeakMap;\n}\nexports.isWeakMap = isWeakMap;\n\nfunction isWeakSetToString(value) {\n return ObjectToString(value) === '[object WeakSet]';\n}\nisWeakSetToString.working = (\n typeof WeakSet !== 'undefined' &&\n isWeakSetToString(new WeakSet())\n);\nfunction isWeakSet(value) {\n return isWeakSetToString(value);\n}\nexports.isWeakSet = isWeakSet;\n\nfunction isArrayBufferToString(value) {\n return ObjectToString(value) === '[object ArrayBuffer]';\n}\nisArrayBufferToString.working = (\n typeof ArrayBuffer !== 'undefined' &&\n isArrayBufferToString(new ArrayBuffer())\n);\nfunction isArrayBuffer(value) {\n if (typeof ArrayBuffer === 'undefined') {\n return false;\n }\n\n return isArrayBufferToString.working\n ? isArrayBufferToString(value)\n : value instanceof ArrayBuffer;\n}\nexports.isArrayBuffer = isArrayBuffer;\n\nfunction isDataViewToString(value) {\n return ObjectToString(value) === '[object DataView]';\n}\nisDataViewToString.working = (\n typeof ArrayBuffer !== 'undefined' &&\n typeof DataView !== 'undefined' &&\n isDataViewToString(new DataView(new ArrayBuffer(1), 0, 1))\n);\nfunction isDataView(value) {\n if (typeof DataView === 'undefined') {\n return false;\n }\n\n return isDataViewToString.working\n ? isDataViewToString(value)\n : value instanceof DataView;\n}\nexports.isDataView = isDataView;\n\n// Store a copy of SharedArrayBuffer in case it's deleted elsewhere\nvar SharedArrayBufferCopy = typeof SharedArrayBuffer !== 'undefined' ? SharedArrayBuffer : undefined;\nfunction isSharedArrayBufferToString(value) {\n return ObjectToString(value) === '[object SharedArrayBuffer]';\n}\nfunction isSharedArrayBuffer(value) {\n if (typeof SharedArrayBufferCopy === 'undefined') {\n return false;\n }\n\n if (typeof isSharedArrayBufferToString.working === 'undefined') {\n isSharedArrayBufferToString.working = isSharedArrayBufferToString(new SharedArrayBufferCopy());\n }\n\n return isSharedArrayBufferToString.working\n ? isSharedArrayBufferToString(value)\n : value instanceof SharedArrayBufferCopy;\n}\nexports.isSharedArrayBuffer = isSharedArrayBuffer;\n\nfunction isAsyncFunction(value) {\n return ObjectToString(value) === '[object AsyncFunction]';\n}\nexports.isAsyncFunction = isAsyncFunction;\n\nfunction isMapIterator(value) {\n return ObjectToString(value) === '[object Map Iterator]';\n}\nexports.isMapIterator = isMapIterator;\n\nfunction isSetIterator(value) {\n return ObjectToString(value) === '[object Set Iterator]';\n}\nexports.isSetIterator = isSetIterator;\n\nfunction isGeneratorObject(value) {\n return ObjectToString(value) === '[object Generator]';\n}\nexports.isGeneratorObject = isGeneratorObject;\n\nfunction isWebAssemblyCompiledModule(value) {\n return ObjectToString(value) === '[object WebAssembly.Module]';\n}\nexports.isWebAssemblyCompiledModule = isWebAssemblyCompiledModule;\n\nfunction isNumberObject(value) {\n return checkBoxedPrimitive(value, numberValue);\n}\nexports.isNumberObject = isNumberObject;\n\nfunction isStringObject(value) {\n return checkBoxedPrimitive(value, stringValue);\n}\nexports.isStringObject = isStringObject;\n\nfunction isBooleanObject(value) {\n return checkBoxedPrimitive(value, booleanValue);\n}\nexports.isBooleanObject = isBooleanObject;\n\nfunction isBigIntObject(value) {\n return BigIntSupported && checkBoxedPrimitive(value, bigIntValue);\n}\nexports.isBigIntObject = isBigIntObject;\n\nfunction isSymbolObject(value) {\n return SymbolSupported && checkBoxedPrimitive(value, symbolValue);\n}\nexports.isSymbolObject = isSymbolObject;\n\nfunction isBoxedPrimitive(value) {\n return (\n isNumberObject(value) ||\n isStringObject(value) ||\n isBooleanObject(value) ||\n isBigIntObject(value) ||\n isSymbolObject(value)\n );\n}\nexports.isBoxedPrimitive = isBoxedPrimitive;\n\nfunction isAnyArrayBuffer(value) {\n return typeof Uint8Array !== 'undefined' && (\n isArrayBuffer(value) ||\n isSharedArrayBuffer(value)\n );\n}\nexports.isAnyArrayBuffer = isAnyArrayBuffer;\n\n['isProxy', 'isExternal', 'isModuleNamespaceObject'].forEach(function(method) {\n Object.defineProperty(exports, method, {\n enumerable: false,\n value: function() {\n throw new Error(method + ' is not supported in userland');\n }\n });\n});\n","module.exports = function isBuffer(arg) {\n return arg && typeof arg === 'object'\n && typeof arg.copy === 'function'\n && typeof arg.fill === 'function'\n && typeof arg.readUInt8 === 'function';\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors ||\n function getOwnPropertyDescriptors(obj) {\n var keys = Object.keys(obj);\n var descriptors = {};\n for (var i = 0; i < keys.length; i++) {\n descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i]);\n }\n return descriptors;\n };\n\nvar formatRegExp = /%[sdj%]/g;\nexports.format = function(f) {\n if (!isString(f)) {\n var objects = [];\n for (var i = 0; i < arguments.length; i++) {\n objects.push(inspect(arguments[i]));\n }\n return objects.join(' ');\n }\n\n var i = 1;\n var args = arguments;\n var len = args.length;\n var str = String(f).replace(formatRegExp, function(x) {\n if (x === '%%') return '%';\n if (i >= len) return x;\n switch (x) {\n case '%s': return String(args[i++]);\n case '%d': return Number(args[i++]);\n case '%j':\n try {\n return JSON.stringify(args[i++]);\n } catch (_) {\n return '[Circular]';\n }\n default:\n return x;\n }\n });\n for (var x = args[i]; i < len; x = args[++i]) {\n if (isNull(x) || !isObject(x)) {\n str += ' ' + x;\n } else {\n str += ' ' + inspect(x);\n }\n }\n return str;\n};\n\n\n// Mark that a method should not be used.\n// Returns a modified function which warns once by default.\n// If --no-deprecation is set, then it is a no-op.\nexports.deprecate = function(fn, msg) {\n if (typeof process !== 'undefined' && process.noDeprecation === true) {\n return fn;\n }\n\n // Allow for deprecating things in the process of starting up.\n if (typeof process === 'undefined') {\n return function() {\n return exports.deprecate(fn, msg).apply(this, arguments);\n };\n }\n\n var warned = false;\n function deprecated() {\n if (!warned) {\n if (process.throwDeprecation) {\n throw new Error(msg);\n } else if (process.traceDeprecation) {\n console.trace(msg);\n } else {\n console.error(msg);\n }\n warned = true;\n }\n return fn.apply(this, arguments);\n }\n\n return deprecated;\n};\n\n\nvar debugs = {};\nvar debugEnvRegex = /^$/;\n\nif (process.env.NODE_DEBUG) {\n var debugEnv = process.env.NODE_DEBUG;\n debugEnv = debugEnv.replace(/[|\\\\{}()[\\]^$+?.]/g, '\\\\$&')\n .replace(/\\*/g, '.*')\n .replace(/,/g, '$|^')\n .toUpperCase();\n debugEnvRegex = new RegExp('^' + debugEnv + '$', 'i');\n}\nexports.debuglog = function(set) {\n set = set.toUpperCase();\n if (!debugs[set]) {\n if (debugEnvRegex.test(set)) {\n var pid = process.pid;\n debugs[set] = function() {\n var msg = exports.format.apply(exports, arguments);\n console.error('%s %d: %s', set, pid, msg);\n };\n } else {\n debugs[set] = function() {};\n }\n }\n return debugs[set];\n};\n\n\n/**\n * Echos the value of a value. Trys to print the value out\n * in the best way possible given the different types.\n *\n * @param {Object} obj The object to print out.\n * @param {Object} opts Optional options object that alters the output.\n */\n/* legacy: obj, showHidden, depth, colors*/\nfunction inspect(obj, opts) {\n // default options\n var ctx = {\n seen: [],\n stylize: stylizeNoColor\n };\n // legacy...\n if (arguments.length >= 3) ctx.depth = arguments[2];\n if (arguments.length >= 4) ctx.colors = arguments[3];\n if (isBoolean(opts)) {\n // legacy...\n ctx.showHidden = opts;\n } else if (opts) {\n // got an \"options\" object\n exports._extend(ctx, opts);\n }\n // set default options\n if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\n if (isUndefined(ctx.depth)) ctx.depth = 2;\n if (isUndefined(ctx.colors)) ctx.colors = false;\n if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\n if (ctx.colors) ctx.stylize = stylizeWithColor;\n return formatValue(ctx, obj, ctx.depth);\n}\nexports.inspect = inspect;\n\n\n// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\ninspect.colors = {\n 'bold' : [1, 22],\n 'italic' : [3, 23],\n 'underline' : [4, 24],\n 'inverse' : [7, 27],\n 'white' : [37, 39],\n 'grey' : [90, 39],\n 'black' : [30, 39],\n 'blue' : [34, 39],\n 'cyan' : [36, 39],\n 'green' : [32, 39],\n 'magenta' : [35, 39],\n 'red' : [31, 39],\n 'yellow' : [33, 39]\n};\n\n// Don't use 'blue' not visible on cmd.exe\ninspect.styles = {\n 'special': 'cyan',\n 'number': 'yellow',\n 'boolean': 'yellow',\n 'undefined': 'grey',\n 'null': 'bold',\n 'string': 'green',\n 'date': 'magenta',\n // \"name\": intentionally not styling\n 'regexp': 'red'\n};\n\n\nfunction stylizeWithColor(str, styleType) {\n var style = inspect.styles[styleType];\n\n if (style) {\n return '\\u001b[' + inspect.colors[style][0] + 'm' + str +\n '\\u001b[' + inspect.colors[style][1] + 'm';\n } else {\n return str;\n }\n}\n\n\nfunction stylizeNoColor(str, styleType) {\n return str;\n}\n\n\nfunction arrayToHash(array) {\n var hash = {};\n\n array.forEach(function(val, idx) {\n hash[val] = true;\n });\n\n return hash;\n}\n\n\nfunction formatValue(ctx, value, recurseTimes) {\n // Provide a hook for user-specified inspect functions.\n // Check that value is an object with an inspect function on it\n if (ctx.customInspect &&\n value &&\n isFunction(value.inspect) &&\n // Filter out the util module, it's inspect function is special\n value.inspect !== exports.inspect &&\n // Also filter out any prototype objects using the circular check.\n !(value.constructor && value.constructor.prototype === value)) {\n var ret = value.inspect(recurseTimes, ctx);\n if (!isString(ret)) {\n ret = formatValue(ctx, ret, recurseTimes);\n }\n return ret;\n }\n\n // Primitive types cannot have properties\n var primitive = formatPrimitive(ctx, value);\n if (primitive) {\n return primitive;\n }\n\n // Look up the keys of the object.\n var keys = Object.keys(value);\n var visibleKeys = arrayToHash(keys);\n\n if (ctx.showHidden) {\n keys = Object.getOwnPropertyNames(value);\n }\n\n // IE doesn't make error fields non-enumerable\n // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\n if (isError(value)\n && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\n return formatError(value);\n }\n\n // Some type of object without properties can be shortcutted.\n if (keys.length === 0) {\n if (isFunction(value)) {\n var name = value.name ? ': ' + value.name : '';\n return ctx.stylize('[Function' + name + ']', 'special');\n }\n if (isRegExp(value)) {\n return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n }\n if (isDate(value)) {\n return ctx.stylize(Date.prototype.toString.call(value), 'date');\n }\n if (isError(value)) {\n return formatError(value);\n }\n }\n\n var base = '', array = false, braces = ['{', '}'];\n\n // Make Array say that they are Array\n if (isArray(value)) {\n array = true;\n braces = ['[', ']'];\n }\n\n // Make functions say that they are functions\n if (isFunction(value)) {\n var n = value.name ? ': ' + value.name : '';\n base = ' [Function' + n + ']';\n }\n\n // Make RegExps say that they are RegExps\n if (isRegExp(value)) {\n base = ' ' + RegExp.prototype.toString.call(value);\n }\n\n // Make dates with properties first say the date\n if (isDate(value)) {\n base = ' ' + Date.prototype.toUTCString.call(value);\n }\n\n // Make error with message first say the error\n if (isError(value)) {\n base = ' ' + formatError(value);\n }\n\n if (keys.length === 0 && (!array || value.length == 0)) {\n return braces[0] + base + braces[1];\n }\n\n if (recurseTimes < 0) {\n if (isRegExp(value)) {\n return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n } else {\n return ctx.stylize('[Object]', 'special');\n }\n }\n\n ctx.seen.push(value);\n\n var output;\n if (array) {\n output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n } else {\n output = keys.map(function(key) {\n return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n });\n }\n\n ctx.seen.pop();\n\n return reduceToSingleString(output, base, braces);\n}\n\n\nfunction formatPrimitive(ctx, value) {\n if (isUndefined(value))\n return ctx.stylize('undefined', 'undefined');\n if (isString(value)) {\n var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '')\n .replace(/'/g, \"\\\\'\")\n .replace(/\\\\\"/g, '\"') + '\\'';\n return ctx.stylize(simple, 'string');\n }\n if (isNumber(value))\n return ctx.stylize('' + value, 'number');\n if (isBoolean(value))\n return ctx.stylize('' + value, 'boolean');\n // For some reason typeof null is \"object\", so special case here.\n if (isNull(value))\n return ctx.stylize('null', 'null');\n}\n\n\nfunction formatError(value) {\n return '[' + Error.prototype.toString.call(value) + ']';\n}\n\n\nfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n var output = [];\n for (var i = 0, l = value.length; i < l; ++i) {\n if (hasOwnProperty(value, String(i))) {\n output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n String(i), true));\n } else {\n output.push('');\n }\n }\n keys.forEach(function(key) {\n if (!key.match(/^\\d+$/)) {\n output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n key, true));\n }\n });\n return output;\n}\n\n\nfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n var name, str, desc;\n desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };\n if (desc.get) {\n if (desc.set) {\n str = ctx.stylize('[Getter/Setter]', 'special');\n } else {\n str = ctx.stylize('[Getter]', 'special');\n }\n } else {\n if (desc.set) {\n str = ctx.stylize('[Setter]', 'special');\n }\n }\n if (!hasOwnProperty(visibleKeys, key)) {\n name = '[' + key + ']';\n }\n if (!str) {\n if (ctx.seen.indexOf(desc.value) < 0) {\n if (isNull(recurseTimes)) {\n str = formatValue(ctx, desc.value, null);\n } else {\n str = formatValue(ctx, desc.value, recurseTimes - 1);\n }\n if (str.indexOf('\\n') > -1) {\n if (array) {\n str = str.split('\\n').map(function(line) {\n return ' ' + line;\n }).join('\\n').slice(2);\n } else {\n str = '\\n' + str.split('\\n').map(function(line) {\n return ' ' + line;\n }).join('\\n');\n }\n }\n } else {\n str = ctx.stylize('[Circular]', 'special');\n }\n }\n if (isUndefined(name)) {\n if (array && key.match(/^\\d+$/)) {\n return str;\n }\n name = JSON.stringify('' + key);\n if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n name = name.slice(1, -1);\n name = ctx.stylize(name, 'name');\n } else {\n name = name.replace(/'/g, \"\\\\'\")\n .replace(/\\\\\"/g, '\"')\n .replace(/(^\"|\"$)/g, \"'\");\n name = ctx.stylize(name, 'string');\n }\n }\n\n return name + ': ' + str;\n}\n\n\nfunction reduceToSingleString(output, base, braces) {\n var numLinesEst = 0;\n var length = output.reduce(function(prev, cur) {\n numLinesEst++;\n if (cur.indexOf('\\n') >= 0) numLinesEst++;\n return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, '').length + 1;\n }, 0);\n\n if (length > 60) {\n return braces[0] +\n (base === '' ? '' : base + '\\n ') +\n ' ' +\n output.join(',\\n ') +\n ' ' +\n braces[1];\n }\n\n return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n}\n\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\nexports.types = require('./support/types');\n\nfunction isArray(ar) {\n return Array.isArray(ar);\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n return isObject(re) && objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\nexports.types.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n return isObject(d) && objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\nexports.types.isDate = isDate;\n\nfunction isError(e) {\n return isObject(e) &&\n (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\nexports.types.isNativeError = isError;\n\nfunction isFunction(arg) {\n return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n return arg === null ||\n typeof arg === 'boolean' ||\n typeof arg === 'number' ||\n typeof arg === 'string' ||\n typeof arg === 'symbol' || // ES6 symbol\n typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = require('./support/isBuffer');\n\nfunction objectToString(o) {\n return Object.prototype.toString.call(o);\n}\n\n\nfunction pad(n) {\n return n < 10 ? '0' + n.toString(10) : n.toString(10);\n}\n\n\nvar months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',\n 'Oct', 'Nov', 'Dec'];\n\n// 26 Feb 16:19:34\nfunction timestamp() {\n var d = new Date();\n var time = [pad(d.getHours()),\n pad(d.getMinutes()),\n pad(d.getSeconds())].join(':');\n return [d.getDate(), months[d.getMonth()], time].join(' ');\n}\n\n\n// log is just a thin wrapper to console.log that prepends a timestamp\nexports.log = function() {\n console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));\n};\n\n\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * The Function.prototype.inherits from lang.js rewritten as a standalone\n * function (not on Function.prototype). NOTE: If this file is to be loaded\n * during bootstrapping this function needs to be rewritten using some native\n * functions as prototype setup using normal JavaScript does not work as\n * expected during bootstrapping (see mirror.js in r114903).\n *\n * @param {function} ctor Constructor function which needs to inherit the\n * prototype.\n * @param {function} superCtor Constructor function to inherit prototype from.\n */\nexports.inherits = require('inherits');\n\nexports._extend = function(origin, add) {\n // Don't do anything if add isn't an object\n if (!add || !isObject(add)) return origin;\n\n var keys = Object.keys(add);\n var i = keys.length;\n while (i--) {\n origin[keys[i]] = add[keys[i]];\n }\n return origin;\n};\n\nfunction hasOwnProperty(obj, prop) {\n return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\nvar kCustomPromisifiedSymbol = typeof Symbol !== 'undefined' ? Symbol('util.promisify.custom') : undefined;\n\nexports.promisify = function promisify(original) {\n if (typeof original !== 'function')\n throw new TypeError('The \"original\" argument must be of type Function');\n\n if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {\n var fn = original[kCustomPromisifiedSymbol];\n if (typeof fn !== 'function') {\n throw new TypeError('The \"util.promisify.custom\" argument must be of type Function');\n }\n Object.defineProperty(fn, kCustomPromisifiedSymbol, {\n value: fn, enumerable: false, writable: false, configurable: true\n });\n return fn;\n }\n\n function fn() {\n var promiseResolve, promiseReject;\n var promise = new Promise(function (resolve, reject) {\n promiseResolve = resolve;\n promiseReject = reject;\n });\n\n var args = [];\n for (var i = 0; i < arguments.length; i++) {\n args.push(arguments[i]);\n }\n args.push(function (err, value) {\n if (err) {\n promiseReject(err);\n } else {\n promiseResolve(value);\n }\n });\n\n try {\n original.apply(this, args);\n } catch (err) {\n promiseReject(err);\n }\n\n return promise;\n }\n\n Object.setPrototypeOf(fn, Object.getPrototypeOf(original));\n\n if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, {\n value: fn, enumerable: false, writable: false, configurable: true\n });\n return Object.defineProperties(\n fn,\n getOwnPropertyDescriptors(original)\n );\n}\n\nexports.promisify.custom = kCustomPromisifiedSymbol\n\nfunction callbackifyOnRejected(reason, cb) {\n // `!reason` guard inspired by bluebird (Ref: https://goo.gl/t5IS6M).\n // Because `null` is a special error value in callbacks which means \"no error\n // occurred\", we error-wrap so the callback consumer can distinguish between\n // \"the promise rejected with null\" or \"the promise fulfilled with undefined\".\n if (!reason) {\n var newReason = new Error('Promise was rejected with a falsy value');\n newReason.reason = reason;\n reason = newReason;\n }\n return cb(reason);\n}\n\nfunction callbackify(original) {\n if (typeof original !== 'function') {\n throw new TypeError('The \"original\" argument must be of type Function');\n }\n\n // We DO NOT return the promise as it gives the user a false sense that\n // the promise is actually somehow related to the callback's execution\n // and that the callback throwing will reject the promise.\n function callbackified() {\n var args = [];\n for (var i = 0; i < arguments.length; i++) {\n args.push(arguments[i]);\n }\n\n var maybeCb = args.pop();\n if (typeof maybeCb !== 'function') {\n throw new TypeError('The last argument must be of type Function');\n }\n var self = this;\n var cb = function() {\n return maybeCb.apply(self, arguments);\n };\n // In true node style we process the callback on `nextTick` with all the\n // implications (stack, `uncaughtException`, `async_hooks`)\n original.apply(this, args)\n .then(function(ret) { process.nextTick(cb.bind(null, null, ret)) },\n function(rej) { process.nextTick(callbackifyOnRejected.bind(null, rej, cb)) });\n }\n\n Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original));\n Object.defineProperties(callbackified,\n getOwnPropertyDescriptors(original));\n return callbackified;\n}\nexports.callbackify = callbackify;\n","'use strict';\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return typeof key === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (typeof input !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (typeof res !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nvar _require = require('buffer'),\n Buffer = _require.Buffer;\nvar _require2 = require('util'),\n inspect = _require2.inspect;\nvar custom = inspect && inspect.custom || 'inspect';\nfunction copyBuffer(src, target, offset) {\n Buffer.prototype.copy.call(src, target, offset);\n}\nmodule.exports = /*#__PURE__*/function () {\n function BufferList() {\n _classCallCheck(this, BufferList);\n this.head = null;\n this.tail = null;\n this.length = 0;\n }\n _createClass(BufferList, [{\n key: \"push\",\n value: function push(v) {\n var entry = {\n data: v,\n next: null\n };\n if (this.length > 0) this.tail.next = entry;else this.head = entry;\n this.tail = entry;\n ++this.length;\n }\n }, {\n key: \"unshift\",\n value: function unshift(v) {\n var entry = {\n data: v,\n next: this.head\n };\n if (this.length === 0) this.tail = entry;\n this.head = entry;\n ++this.length;\n }\n }, {\n key: \"shift\",\n value: function shift() {\n if (this.length === 0) return;\n var ret = this.head.data;\n if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;\n --this.length;\n return ret;\n }\n }, {\n key: \"clear\",\n value: function clear() {\n this.head = this.tail = null;\n this.length = 0;\n }\n }, {\n key: \"join\",\n value: function join(s) {\n if (this.length === 0) return '';\n var p = this.head;\n var ret = '' + p.data;\n while (p = p.next) ret += s + p.data;\n return ret;\n }\n }, {\n key: \"concat\",\n value: function concat(n) {\n if (this.length === 0) return Buffer.alloc(0);\n var ret = Buffer.allocUnsafe(n >>> 0);\n var p = this.head;\n var i = 0;\n while (p) {\n copyBuffer(p.data, ret, i);\n i += p.data.length;\n p = p.next;\n }\n return ret;\n }\n\n // Consumes a specified amount of bytes or characters from the buffered data.\n }, {\n key: \"consume\",\n value: function consume(n, hasStrings) {\n var ret;\n if (n < this.head.data.length) {\n // `slice` is the same for buffers and strings.\n ret = this.head.data.slice(0, n);\n this.head.data = this.head.data.slice(n);\n } else if (n === this.head.data.length) {\n // First chunk is a perfect match.\n ret = this.shift();\n } else {\n // Result spans more than one buffer.\n ret = hasStrings ? this._getString(n) : this._getBuffer(n);\n }\n return ret;\n }\n }, {\n key: \"first\",\n value: function first() {\n return this.head.data;\n }\n\n // Consumes a specified amount of characters from the buffered data.\n }, {\n key: \"_getString\",\n value: function _getString(n) {\n var p = this.head;\n var c = 1;\n var ret = p.data;\n n -= ret.length;\n while (p = p.next) {\n var str = p.data;\n var nb = n > str.length ? str.length : n;\n if (nb === str.length) ret += str;else ret += str.slice(0, n);\n n -= nb;\n if (n === 0) {\n if (nb === str.length) {\n ++c;\n if (p.next) this.head = p.next;else this.head = this.tail = null;\n } else {\n this.head = p;\n p.data = str.slice(nb);\n }\n break;\n }\n ++c;\n }\n this.length -= c;\n return ret;\n }\n\n // Consumes a specified amount of bytes from the buffered data.\n }, {\n key: \"_getBuffer\",\n value: function _getBuffer(n) {\n var ret = Buffer.allocUnsafe(n);\n var p = this.head;\n var c = 1;\n p.data.copy(ret);\n n -= p.data.length;\n while (p = p.next) {\n var buf = p.data;\n var nb = n > buf.length ? buf.length : n;\n buf.copy(ret, ret.length - n, 0, nb);\n n -= nb;\n if (n === 0) {\n if (nb === buf.length) {\n ++c;\n if (p.next) this.head = p.next;else this.head = this.tail = null;\n } else {\n this.head = p;\n p.data = buf.slice(nb);\n }\n break;\n }\n ++c;\n }\n this.length -= c;\n return ret;\n }\n\n // Make sure the linked list only shows the minimal necessary information.\n }, {\n key: custom,\n value: function value(_, options) {\n return inspect(this, _objectSpread(_objectSpread({}, options), {}, {\n // Only inspect one level.\n depth: 0,\n // It should not recurse.\n customInspect: false\n }));\n }\n }]);\n return BufferList;\n}();","'use strict';\n\n// undocumented cb() API, needed for core, not for public API\nfunction destroy(err, cb) {\n var _this = this;\n var readableDestroyed = this._readableState && this._readableState.destroyed;\n var writableDestroyed = this._writableState && this._writableState.destroyed;\n if (readableDestroyed || writableDestroyed) {\n if (cb) {\n cb(err);\n } else if (err) {\n if (!this._writableState) {\n process.nextTick(emitErrorNT, this, err);\n } else if (!this._writableState.errorEmitted) {\n this._writableState.errorEmitted = true;\n process.nextTick(emitErrorNT, this, err);\n }\n }\n return this;\n }\n\n // we set destroyed to true before firing error callbacks in order\n // to make it re-entrance safe in case destroy() is called within callbacks\n\n if (this._readableState) {\n this._readableState.destroyed = true;\n }\n\n // if this is a duplex stream mark the writable part as destroyed as well\n if (this._writableState) {\n this._writableState.destroyed = true;\n }\n this._destroy(err || null, function (err) {\n if (!cb && err) {\n if (!_this._writableState) {\n process.nextTick(emitErrorAndCloseNT, _this, err);\n } else if (!_this._writableState.errorEmitted) {\n _this._writableState.errorEmitted = true;\n process.nextTick(emitErrorAndCloseNT, _this, err);\n } else {\n process.nextTick(emitCloseNT, _this);\n }\n } else if (cb) {\n process.nextTick(emitCloseNT, _this);\n cb(err);\n } else {\n process.nextTick(emitCloseNT, _this);\n }\n });\n return this;\n}\nfunction emitErrorAndCloseNT(self, err) {\n emitErrorNT(self, err);\n emitCloseNT(self);\n}\nfunction emitCloseNT(self) {\n if (self._writableState && !self._writableState.emitClose) return;\n if (self._readableState && !self._readableState.emitClose) return;\n self.emit('close');\n}\nfunction undestroy() {\n if (this._readableState) {\n this._readableState.destroyed = false;\n this._readableState.reading = false;\n this._readableState.ended = false;\n this._readableState.endEmitted = false;\n }\n if (this._writableState) {\n this._writableState.destroyed = false;\n this._writableState.ended = false;\n this._writableState.ending = false;\n this._writableState.finalCalled = false;\n this._writableState.prefinished = false;\n this._writableState.finished = false;\n this._writableState.errorEmitted = false;\n }\n}\nfunction emitErrorNT(self, err) {\n self.emit('error', err);\n}\nfunction errorOrDestroy(stream, err) {\n // We have tests that rely on errors being emitted\n // in the same tick, so changing this is semver major.\n // For now when you opt-in to autoDestroy we allow\n // the error to be emitted nextTick. In a future\n // semver major update we should change the default to this.\n\n var rState = stream._readableState;\n var wState = stream._writableState;\n if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.emit('error', err);\n}\nmodule.exports = {\n destroy: destroy,\n undestroy: undestroy,\n errorOrDestroy: errorOrDestroy\n};","'use strict';\n\nfunction _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }\n\nvar codes = {};\n\nfunction createErrorType(code, message, Base) {\n if (!Base) {\n Base = Error;\n }\n\n function getMessage(arg1, arg2, arg3) {\n if (typeof message === 'string') {\n return message;\n } else {\n return message(arg1, arg2, arg3);\n }\n }\n\n var NodeError =\n /*#__PURE__*/\n function (_Base) {\n _inheritsLoose(NodeError, _Base);\n\n function NodeError(arg1, arg2, arg3) {\n return _Base.call(this, getMessage(arg1, arg2, arg3)) || this;\n }\n\n return NodeError;\n }(Base);\n\n NodeError.prototype.name = Base.name;\n NodeError.prototype.code = code;\n codes[code] = NodeError;\n} // https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js\n\n\nfunction oneOf(expected, thing) {\n if (Array.isArray(expected)) {\n var len = expected.length;\n expected = expected.map(function (i) {\n return String(i);\n });\n\n if (len > 2) {\n return \"one of \".concat(thing, \" \").concat(expected.slice(0, len - 1).join(', '), \", or \") + expected[len - 1];\n } else if (len === 2) {\n return \"one of \".concat(thing, \" \").concat(expected[0], \" or \").concat(expected[1]);\n } else {\n return \"of \".concat(thing, \" \").concat(expected[0]);\n }\n } else {\n return \"of \".concat(thing, \" \").concat(String(expected));\n }\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith\n\n\nfunction startsWith(str, search, pos) {\n return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith\n\n\nfunction endsWith(str, search, this_len) {\n if (this_len === undefined || this_len > str.length) {\n this_len = str.length;\n }\n\n return str.substring(this_len - search.length, this_len) === search;\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes\n\n\nfunction includes(str, search, start) {\n if (typeof start !== 'number') {\n start = 0;\n }\n\n if (start + search.length > str.length) {\n return false;\n } else {\n return str.indexOf(search, start) !== -1;\n }\n}\n\ncreateErrorType('ERR_INVALID_OPT_VALUE', function (name, value) {\n return 'The value \"' + value + '\" is invalid for option \"' + name + '\"';\n}, TypeError);\ncreateErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {\n // determiner: 'must be' or 'must not be'\n var determiner;\n\n if (typeof expected === 'string' && startsWith(expected, 'not ')) {\n determiner = 'must not be';\n expected = expected.replace(/^not /, '');\n } else {\n determiner = 'must be';\n }\n\n var msg;\n\n if (endsWith(name, ' argument')) {\n // For cases like 'first argument'\n msg = \"The \".concat(name, \" \").concat(determiner, \" \").concat(oneOf(expected, 'type'));\n } else {\n var type = includes(name, '.') ? 'property' : 'argument';\n msg = \"The \\\"\".concat(name, \"\\\" \").concat(type, \" \").concat(determiner, \" \").concat(oneOf(expected, 'type'));\n }\n\n msg += \". Received type \".concat(typeof actual);\n return msg;\n}, TypeError);\ncreateErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF');\ncreateErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) {\n return 'The ' + name + ' method is not implemented';\n});\ncreateErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close');\ncreateErrorType('ERR_STREAM_DESTROYED', function (name) {\n return 'Cannot call ' + name + ' after a stream was destroyed';\n});\ncreateErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times');\ncreateErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable');\ncreateErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end');\ncreateErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);\ncreateErrorType('ERR_UNKNOWN_ENCODING', function (arg) {\n return 'Unknown encoding: ' + arg;\n}, TypeError);\ncreateErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');\nmodule.exports.codes = codes;\n","'use strict';\n\nvar ERR_INVALID_OPT_VALUE = require('../../../errors').codes.ERR_INVALID_OPT_VALUE;\nfunction highWaterMarkFrom(options, isDuplex, duplexKey) {\n return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;\n}\nfunction getHighWaterMark(state, options, duplexKey, isDuplex) {\n var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);\n if (hwm != null) {\n if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {\n var name = isDuplex ? duplexKey : 'highWaterMark';\n throw new ERR_INVALID_OPT_VALUE(name, hwm);\n }\n return Math.floor(hwm);\n }\n\n // Default value\n return state.objectMode ? 16 : 16 * 1024;\n}\nmodule.exports = {\n getHighWaterMark: getHighWaterMark\n};","\n/**\n * Module exports.\n */\n\nmodule.exports = deprecate;\n\n/**\n * Mark that a method should not be used.\n * Returns a modified function which warns once by default.\n *\n * If `localStorage.noDeprecation = true` is set, then it is a no-op.\n *\n * If `localStorage.throwDeprecation = true` is set, then deprecated functions\n * will throw an Error when invoked.\n *\n * If `localStorage.traceDeprecation = true` is set, then deprecated functions\n * will invoke `console.trace()` instead of `console.error()`.\n *\n * @param {Function} fn - the function to deprecate\n * @param {String} msg - the string to print to the console when `fn` is invoked\n * @returns {Function} a new \"deprecated\" version of `fn`\n * @api public\n */\n\nfunction deprecate (fn, msg) {\n if (config('noDeprecation')) {\n return fn;\n }\n\n var warned = false;\n function deprecated() {\n if (!warned) {\n if (config('throwDeprecation')) {\n throw new Error(msg);\n } else if (config('traceDeprecation')) {\n console.trace(msg);\n } else {\n console.warn(msg);\n }\n warned = true;\n }\n return fn.apply(this, arguments);\n }\n\n return deprecated;\n}\n\n/**\n * Checks `localStorage` for boolean values for the given `name`.\n *\n * @param {String} name\n * @returns {Boolean}\n * @api private\n */\n\nfunction config (name) {\n // accessing global.localStorage can trigger a DOMException in sandboxed iframes\n try {\n if (!global.localStorage) return false;\n } catch (_) {\n return false;\n }\n var val = global.localStorage[name];\n if (null == val) return false;\n return String(val).toLowerCase() === 'true';\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// A bit simpler than readable streams.\n// Implement an async ._write(chunk, encoding, cb), and it'll handle all\n// the drain event emission and buffering.\n\n'use strict';\n\nmodule.exports = Writable;\n\n/* <replacement> */\nfunction WriteReq(chunk, encoding, cb) {\n this.chunk = chunk;\n this.encoding = encoding;\n this.callback = cb;\n this.next = null;\n}\n\n// It seems a linked list but it is not\n// there will be only 2 of these for each stream\nfunction CorkedRequest(state) {\n var _this = this;\n this.next = null;\n this.entry = null;\n this.finish = function () {\n onCorkedFinish(_this, state);\n };\n}\n/* </replacement> */\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nWritable.WritableState = WritableState;\n\n/*<replacement>*/\nvar internalUtil = {\n deprecate: require('util-deprecate')\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\nvar Buffer = require('buffer').Buffer;\nvar OurUint8Array = (typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\nvar destroyImpl = require('./internal/streams/destroy');\nvar _require = require('./internal/streams/state'),\n getHighWaterMark = _require.getHighWaterMark;\nvar _require$codes = require('../errors').codes,\n ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,\n ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,\n ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE,\n ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED,\n ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES,\n ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END,\n ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;\nvar errorOrDestroy = destroyImpl.errorOrDestroy;\nrequire('inherits')(Writable, Stream);\nfunction nop() {}\nfunction WritableState(options, stream, isDuplex) {\n Duplex = Duplex || require('./_stream_duplex');\n options = options || {};\n\n // Duplex streams are both readable and writable, but share\n // the same options object.\n // However, some cases require setting options to different\n // values for the readable and the writable sides of the duplex stream,\n // e.g. options.readableObjectMode vs. options.writableObjectMode, etc.\n if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex;\n\n // object stream flag to indicate whether or not this stream\n // contains buffers or objects.\n this.objectMode = !!options.objectMode;\n if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;\n\n // the point at which write() starts returning false\n // Note: 0 is a valid value, means that we always return false if\n // the entire buffer is not flushed immediately on write()\n this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex);\n\n // if _final has been called\n this.finalCalled = false;\n\n // drain event flag.\n this.needDrain = false;\n // at the start of calling end()\n this.ending = false;\n // when end() has been called, and returned\n this.ended = false;\n // when 'finish' is emitted\n this.finished = false;\n\n // has it been destroyed\n this.destroyed = false;\n\n // should we decode strings into buffers before passing to _write?\n // this is here so that some node-core streams can optimize string\n // handling at a lower level.\n var noDecode = options.decodeStrings === false;\n this.decodeStrings = !noDecode;\n\n // Crypto is kind of old and crusty. Historically, its default string\n // encoding is 'binary' so we have to make this configurable.\n // Everything else in the universe uses 'utf8', though.\n this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n // not an actual buffer we keep track of, but a measurement\n // of how much we're waiting to get pushed to some underlying\n // socket or file.\n this.length = 0;\n\n // a flag to see when we're in the middle of a write.\n this.writing = false;\n\n // when true all writes will be buffered until .uncork() call\n this.corked = 0;\n\n // a flag to be able to tell if the onwrite cb is called immediately,\n // or on a later tick. We set this to true at first, because any\n // actions that shouldn't happen until \"later\" should generally also\n // not happen before the first write call.\n this.sync = true;\n\n // a flag to know if we're processing previously buffered items, which\n // may call the _write() callback in the same tick, so that we don't\n // end up in an overlapped onwrite situation.\n this.bufferProcessing = false;\n\n // the callback that's passed to _write(chunk,cb)\n this.onwrite = function (er) {\n onwrite(stream, er);\n };\n\n // the callback that the user supplies to write(chunk,encoding,cb)\n this.writecb = null;\n\n // the amount that is being written when _write is called.\n this.writelen = 0;\n this.bufferedRequest = null;\n this.lastBufferedRequest = null;\n\n // number of pending user-supplied write callbacks\n // this must be 0 before 'finish' can be emitted\n this.pendingcb = 0;\n\n // emit prefinish if the only thing we're waiting for is _write cbs\n // This is relevant for synchronous Transform streams\n this.prefinished = false;\n\n // True if the error was already emitted and should not be thrown again\n this.errorEmitted = false;\n\n // Should close be emitted on destroy. Defaults to true.\n this.emitClose = options.emitClose !== false;\n\n // Should .destroy() be called after 'finish' (and potentially 'end')\n this.autoDestroy = !!options.autoDestroy;\n\n // count buffered requests\n this.bufferedRequestCount = 0;\n\n // allocate the first CorkedRequest, there is always\n // one allocated and free to use, and we maintain at most two\n this.corkedRequestsFree = new CorkedRequest(this);\n}\nWritableState.prototype.getBuffer = function getBuffer() {\n var current = this.bufferedRequest;\n var out = [];\n while (current) {\n out.push(current);\n current = current.next;\n }\n return out;\n};\n(function () {\n try {\n Object.defineProperty(WritableState.prototype, 'buffer', {\n get: internalUtil.deprecate(function writableStateBufferGetter() {\n return this.getBuffer();\n }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n });\n } catch (_) {}\n})();\n\n// Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\nvar realHasInstance;\nif (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {\n realHasInstance = Function.prototype[Symbol.hasInstance];\n Object.defineProperty(Writable, Symbol.hasInstance, {\n value: function value(object) {\n if (realHasInstance.call(this, object)) return true;\n if (this !== Writable) return false;\n return object && object._writableState instanceof WritableState;\n }\n });\n} else {\n realHasInstance = function realHasInstance(object) {\n return object instanceof this;\n };\n}\nfunction Writable(options) {\n Duplex = Duplex || require('./_stream_duplex');\n\n // Writable ctor is applied to Duplexes, too.\n // `realHasInstance` is necessary because using plain `instanceof`\n // would return false, as no `_writableState` property is attached.\n\n // Trying to use the custom `instanceof` for Writable here will also break the\n // Node.js LazyTransform implementation, which has a non-trivial getter for\n // `_writableState` that would lead to infinite recursion.\n\n // Checking for a Stream.Duplex instance is faster here instead of inside\n // the WritableState constructor, at least with V8 6.5\n var isDuplex = this instanceof Duplex;\n if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);\n this._writableState = new WritableState(options, this, isDuplex);\n\n // legacy.\n this.writable = true;\n if (options) {\n if (typeof options.write === 'function') this._write = options.write;\n if (typeof options.writev === 'function') this._writev = options.writev;\n if (typeof options.destroy === 'function') this._destroy = options.destroy;\n if (typeof options.final === 'function') this._final = options.final;\n }\n Stream.call(this);\n}\n\n// Otherwise people can pipe Writable streams, which is just wrong.\nWritable.prototype.pipe = function () {\n errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());\n};\nfunction writeAfterEnd(stream, cb) {\n var er = new ERR_STREAM_WRITE_AFTER_END();\n // TODO: defer error events consistently everywhere, not just the cb\n errorOrDestroy(stream, er);\n process.nextTick(cb, er);\n}\n\n// Checks that a user-supplied chunk is valid, especially for the particular\n// mode the stream is in. Currently this means that `null` is never accepted\n// and undefined/non-string values are only allowed in object mode.\nfunction validChunk(stream, state, chunk, cb) {\n var er;\n if (chunk === null) {\n er = new ERR_STREAM_NULL_VALUES();\n } else if (typeof chunk !== 'string' && !state.objectMode) {\n er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer'], chunk);\n }\n if (er) {\n errorOrDestroy(stream, er);\n process.nextTick(cb, er);\n return false;\n }\n return true;\n}\nWritable.prototype.write = function (chunk, encoding, cb) {\n var state = this._writableState;\n var ret = false;\n var isBuf = !state.objectMode && _isUint8Array(chunk);\n if (isBuf && !Buffer.isBuffer(chunk)) {\n chunk = _uint8ArrayToBuffer(chunk);\n }\n if (typeof encoding === 'function') {\n cb = encoding;\n encoding = null;\n }\n if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;\n if (typeof cb !== 'function') cb = nop;\n if (state.ending) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {\n state.pendingcb++;\n ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);\n }\n return ret;\n};\nWritable.prototype.cork = function () {\n this._writableState.corked++;\n};\nWritable.prototype.uncork = function () {\n var state = this._writableState;\n if (state.corked) {\n state.corked--;\n if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);\n }\n};\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n // node::ParseEncoding() requires lower case.\n if (typeof encoding === 'string') encoding = encoding.toLowerCase();\n if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new ERR_UNKNOWN_ENCODING(encoding);\n this._writableState.defaultEncoding = encoding;\n return this;\n};\nObject.defineProperty(Writable.prototype, 'writableBuffer', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._writableState && this._writableState.getBuffer();\n }\n});\nfunction decodeChunk(state, chunk, encoding) {\n if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n chunk = Buffer.from(chunk, encoding);\n }\n return chunk;\n}\nObject.defineProperty(Writable.prototype, 'writableHighWaterMark', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._writableState.highWaterMark;\n }\n});\n\n// if we're already writing something, then just put this\n// in the queue, and wait our turn. Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\nfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n if (!isBuf) {\n var newChunk = decodeChunk(state, chunk, encoding);\n if (chunk !== newChunk) {\n isBuf = true;\n encoding = 'buffer';\n chunk = newChunk;\n }\n }\n var len = state.objectMode ? 1 : chunk.length;\n state.length += len;\n var ret = state.length < state.highWaterMark;\n // we must ensure that previous needDrain will not be reset to false.\n if (!ret) state.needDrain = true;\n if (state.writing || state.corked) {\n var last = state.lastBufferedRequest;\n state.lastBufferedRequest = {\n chunk: chunk,\n encoding: encoding,\n isBuf: isBuf,\n callback: cb,\n next: null\n };\n if (last) {\n last.next = state.lastBufferedRequest;\n } else {\n state.bufferedRequest = state.lastBufferedRequest;\n }\n state.bufferedRequestCount += 1;\n } else {\n doWrite(stream, state, false, len, chunk, encoding, cb);\n }\n return ret;\n}\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n state.writelen = len;\n state.writecb = cb;\n state.writing = true;\n state.sync = true;\n if (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED('write'));else if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);\n state.sync = false;\n}\nfunction onwriteError(stream, state, sync, er, cb) {\n --state.pendingcb;\n if (sync) {\n // defer the callback if we are being called synchronously\n // to avoid piling up things on the stack\n process.nextTick(cb, er);\n // this can emit finish, and it will always happen\n // after error\n process.nextTick(finishMaybe, stream, state);\n stream._writableState.errorEmitted = true;\n errorOrDestroy(stream, er);\n } else {\n // the caller expect this to happen before if\n // it is async\n cb(er);\n stream._writableState.errorEmitted = true;\n errorOrDestroy(stream, er);\n // this can emit finish, but finish must\n // always follow error\n finishMaybe(stream, state);\n }\n}\nfunction onwriteStateUpdate(state) {\n state.writing = false;\n state.writecb = null;\n state.length -= state.writelen;\n state.writelen = 0;\n}\nfunction onwrite(stream, er) {\n var state = stream._writableState;\n var sync = state.sync;\n var cb = state.writecb;\n if (typeof cb !== 'function') throw new ERR_MULTIPLE_CALLBACK();\n onwriteStateUpdate(state);\n if (er) onwriteError(stream, state, sync, er, cb);else {\n // Check if we're actually ready to finish, but don't emit yet\n var finished = needFinish(state) || stream.destroyed;\n if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n clearBuffer(stream, state);\n }\n if (sync) {\n process.nextTick(afterWrite, stream, state, finished, cb);\n } else {\n afterWrite(stream, state, finished, cb);\n }\n }\n}\nfunction afterWrite(stream, state, finished, cb) {\n if (!finished) onwriteDrain(stream, state);\n state.pendingcb--;\n cb();\n finishMaybe(stream, state);\n}\n\n// Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\nfunction onwriteDrain(stream, state) {\n if (state.length === 0 && state.needDrain) {\n state.needDrain = false;\n stream.emit('drain');\n }\n}\n\n// if there's something in the buffer waiting, then process it\nfunction clearBuffer(stream, state) {\n state.bufferProcessing = true;\n var entry = state.bufferedRequest;\n if (stream._writev && entry && entry.next) {\n // Fast case, write everything using _writev()\n var l = state.bufferedRequestCount;\n var buffer = new Array(l);\n var holder = state.corkedRequestsFree;\n holder.entry = entry;\n var count = 0;\n var allBuffers = true;\n while (entry) {\n buffer[count] = entry;\n if (!entry.isBuf) allBuffers = false;\n entry = entry.next;\n count += 1;\n }\n buffer.allBuffers = allBuffers;\n doWrite(stream, state, true, state.length, buffer, '', holder.finish);\n\n // doWrite is almost always async, defer these to save a bit of time\n // as the hot path ends with doWrite\n state.pendingcb++;\n state.lastBufferedRequest = null;\n if (holder.next) {\n state.corkedRequestsFree = holder.next;\n holder.next = null;\n } else {\n state.corkedRequestsFree = new CorkedRequest(state);\n }\n state.bufferedRequestCount = 0;\n } else {\n // Slow case, write chunks one-by-one\n while (entry) {\n var chunk = entry.chunk;\n var encoding = entry.encoding;\n var cb = entry.callback;\n var len = state.objectMode ? 1 : chunk.length;\n doWrite(stream, state, false, len, chunk, encoding, cb);\n entry = entry.next;\n state.bufferedRequestCount--;\n // if we didn't call the onwrite immediately, then\n // it means that we need to wait until it does.\n // also, that means that the chunk and cb are currently\n // being processed, so move the buffer counter past them.\n if (state.writing) {\n break;\n }\n }\n if (entry === null) state.lastBufferedRequest = null;\n }\n state.bufferedRequest = entry;\n state.bufferProcessing = false;\n}\nWritable.prototype._write = function (chunk, encoding, cb) {\n cb(new ERR_METHOD_NOT_IMPLEMENTED('_write()'));\n};\nWritable.prototype._writev = null;\nWritable.prototype.end = function (chunk, encoding, cb) {\n var state = this._writableState;\n if (typeof chunk === 'function') {\n cb = chunk;\n chunk = null;\n encoding = null;\n } else if (typeof encoding === 'function') {\n cb = encoding;\n encoding = null;\n }\n if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);\n\n // .end() fully uncorks\n if (state.corked) {\n state.corked = 1;\n this.uncork();\n }\n\n // ignore unnecessary end() calls.\n if (!state.ending) endWritable(this, state, cb);\n return this;\n};\nObject.defineProperty(Writable.prototype, 'writableLength', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._writableState.length;\n }\n});\nfunction needFinish(state) {\n return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\nfunction callFinal(stream, state) {\n stream._final(function (err) {\n state.pendingcb--;\n if (err) {\n errorOrDestroy(stream, err);\n }\n state.prefinished = true;\n stream.emit('prefinish');\n finishMaybe(stream, state);\n });\n}\nfunction prefinish(stream, state) {\n if (!state.prefinished && !state.finalCalled) {\n if (typeof stream._final === 'function' && !state.destroyed) {\n state.pendingcb++;\n state.finalCalled = true;\n process.nextTick(callFinal, stream, state);\n } else {\n state.prefinished = true;\n stream.emit('prefinish');\n }\n }\n}\nfunction finishMaybe(stream, state) {\n var need = needFinish(state);\n if (need) {\n prefinish(stream, state);\n if (state.pendingcb === 0) {\n state.finished = true;\n stream.emit('finish');\n if (state.autoDestroy) {\n // In case of duplex streams we need a way to detect\n // if the readable side is ready for autoDestroy as well\n var rState = stream._readableState;\n if (!rState || rState.autoDestroy && rState.endEmitted) {\n stream.destroy();\n }\n }\n }\n }\n return need;\n}\nfunction endWritable(stream, state, cb) {\n state.ending = true;\n finishMaybe(stream, state);\n if (cb) {\n if (state.finished) process.nextTick(cb);else stream.once('finish', cb);\n }\n state.ended = true;\n stream.writable = false;\n}\nfunction onCorkedFinish(corkReq, state, err) {\n var entry = corkReq.entry;\n corkReq.entry = null;\n while (entry) {\n var cb = entry.callback;\n state.pendingcb--;\n cb(err);\n entry = entry.next;\n }\n\n // reuse the free corkReq.\n state.corkedRequestsFree.next = corkReq;\n}\nObject.defineProperty(Writable.prototype, 'destroyed', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n if (this._writableState === undefined) {\n return false;\n }\n return this._writableState.destroyed;\n },\n set: function set(value) {\n // we ignore the value if the stream\n // has not been initialized yet\n if (!this._writableState) {\n return;\n }\n\n // backward compatibility, the user is explicitly\n // managing destroyed\n this._writableState.destroyed = value;\n }\n});\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\nWritable.prototype._destroy = function (err, cb) {\n cb(err);\n};","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a duplex stream is just a stream that is both readable and writable.\n// Since JS doesn't have multiple prototypal inheritance, this class\n// prototypally inherits from Readable, and then parasitically from\n// Writable.\n\n'use strict';\n\n/*<replacement>*/\nvar objectKeys = Object.keys || function (obj) {\n var keys = [];\n for (var key in obj) keys.push(key);\n return keys;\n};\n/*</replacement>*/\n\nmodule.exports = Duplex;\nvar Readable = require('./_stream_readable');\nvar Writable = require('./_stream_writable');\nrequire('inherits')(Duplex, Readable);\n{\n // Allow the keys array to be GC'ed.\n var keys = objectKeys(Writable.prototype);\n for (var v = 0; v < keys.length; v++) {\n var method = keys[v];\n if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];\n }\n}\nfunction Duplex(options) {\n if (!(this instanceof Duplex)) return new Duplex(options);\n Readable.call(this, options);\n Writable.call(this, options);\n this.allowHalfOpen = true;\n if (options) {\n if (options.readable === false) this.readable = false;\n if (options.writable === false) this.writable = false;\n if (options.allowHalfOpen === false) {\n this.allowHalfOpen = false;\n this.once('end', onend);\n }\n }\n}\nObject.defineProperty(Duplex.prototype, 'writableHighWaterMark', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._writableState.highWaterMark;\n }\n});\nObject.defineProperty(Duplex.prototype, 'writableBuffer', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._writableState && this._writableState.getBuffer();\n }\n});\nObject.defineProperty(Duplex.prototype, 'writableLength', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._writableState.length;\n }\n});\n\n// the no-half-open enforcer\nfunction onend() {\n // If the writable side ended, then we're ok.\n if (this._writableState.ended) return;\n\n // no more data can be written.\n // But allow more writes to happen in this tick.\n process.nextTick(onEndNT, this);\n}\nfunction onEndNT(self) {\n self.end();\n}\nObject.defineProperty(Duplex.prototype, 'destroyed', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n if (this._readableState === undefined || this._writableState === undefined) {\n return false;\n }\n return this._readableState.destroyed && this._writableState.destroyed;\n },\n set: function set(value) {\n // we ignore the value if the stream\n // has not been initialized yet\n if (this._readableState === undefined || this._writableState === undefined) {\n return;\n }\n\n // backward compatibility, the user is explicitly\n // managing destroyed\n this._readableState.destroyed = value;\n this._writableState.destroyed = value;\n }\n});","/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */\n/* eslint-disable node/no-deprecated-api */\nvar buffer = require('buffer')\nvar Buffer = buffer.Buffer\n\n// alternative to using Object.keys for old browsers\nfunction copyProps (src, dst) {\n for (var key in src) {\n dst[key] = src[key]\n }\n}\nif (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {\n module.exports = buffer\n} else {\n // Copy properties from require('buffer')\n copyProps(buffer, exports)\n exports.Buffer = SafeBuffer\n}\n\nfunction SafeBuffer (arg, encodingOrOffset, length) {\n return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.prototype = Object.create(Buffer.prototype)\n\n// Copy static methods from Buffer\ncopyProps(Buffer, SafeBuffer)\n\nSafeBuffer.from = function (arg, encodingOrOffset, length) {\n if (typeof arg === 'number') {\n throw new TypeError('Argument must not be a number')\n }\n return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.alloc = function (size, fill, encoding) {\n if (typeof size !== 'number') {\n throw new TypeError('Argument must be a number')\n }\n var buf = Buffer(size)\n if (fill !== undefined) {\n if (typeof encoding === 'string') {\n buf.fill(fill, encoding)\n } else {\n buf.fill(fill)\n }\n } else {\n buf.fill(0)\n }\n return buf\n}\n\nSafeBuffer.allocUnsafe = function (size) {\n if (typeof size !== 'number') {\n throw new TypeError('Argument must be a number')\n }\n return Buffer(size)\n}\n\nSafeBuffer.allocUnsafeSlow = function (size) {\n if (typeof size !== 'number') {\n throw new TypeError('Argument must be a number')\n }\n return buffer.SlowBuffer(size)\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\n/*</replacement>*/\n\nvar isEncoding = Buffer.isEncoding || function (encoding) {\n encoding = '' + encoding;\n switch (encoding && encoding.toLowerCase()) {\n case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':\n return true;\n default:\n return false;\n }\n};\n\nfunction _normalizeEncoding(enc) {\n if (!enc) return 'utf8';\n var retried;\n while (true) {\n switch (enc) {\n case 'utf8':\n case 'utf-8':\n return 'utf8';\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return 'utf16le';\n case 'latin1':\n case 'binary':\n return 'latin1';\n case 'base64':\n case 'ascii':\n case 'hex':\n return enc;\n default:\n if (retried) return; // undefined\n enc = ('' + enc).toLowerCase();\n retried = true;\n }\n }\n};\n\n// Do not cache `Buffer.isEncoding` when checking encoding names as some\n// modules monkey-patch it to support additional encodings\nfunction normalizeEncoding(enc) {\n var nenc = _normalizeEncoding(enc);\n if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);\n return nenc || enc;\n}\n\n// StringDecoder provides an interface for efficiently splitting a series of\n// buffers into a series of JS strings without breaking apart multi-byte\n// characters.\nexports.StringDecoder = StringDecoder;\nfunction StringDecoder(encoding) {\n this.encoding = normalizeEncoding(encoding);\n var nb;\n switch (this.encoding) {\n case 'utf16le':\n this.text = utf16Text;\n this.end = utf16End;\n nb = 4;\n break;\n case 'utf8':\n this.fillLast = utf8FillLast;\n nb = 4;\n break;\n case 'base64':\n this.text = base64Text;\n this.end = base64End;\n nb = 3;\n break;\n default:\n this.write = simpleWrite;\n this.end = simpleEnd;\n return;\n }\n this.lastNeed = 0;\n this.lastTotal = 0;\n this.lastChar = Buffer.allocUnsafe(nb);\n}\n\nStringDecoder.prototype.write = function (buf) {\n if (buf.length === 0) return '';\n var r;\n var i;\n if (this.lastNeed) {\n r = this.fillLast(buf);\n if (r === undefined) return '';\n i = this.lastNeed;\n this.lastNeed = 0;\n } else {\n i = 0;\n }\n if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);\n return r || '';\n};\n\nStringDecoder.prototype.end = utf8End;\n\n// Returns only complete characters in a Buffer\nStringDecoder.prototype.text = utf8Text;\n\n// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer\nStringDecoder.prototype.fillLast = function (buf) {\n if (this.lastNeed <= buf.length) {\n buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);\n return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n }\n buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);\n this.lastNeed -= buf.length;\n};\n\n// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a\n// continuation byte. If an invalid byte is detected, -2 is returned.\nfunction utf8CheckByte(byte) {\n if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;\n return byte >> 6 === 0x02 ? -1 : -2;\n}\n\n// Checks at most 3 bytes at the end of a Buffer in order to detect an\n// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)\n// needed to complete the UTF-8 character (if applicable) are returned.\nfunction utf8CheckIncomplete(self, buf, i) {\n var j = buf.length - 1;\n if (j < i) return 0;\n var nb = utf8CheckByte(buf[j]);\n if (nb >= 0) {\n if (nb > 0) self.lastNeed = nb - 1;\n return nb;\n }\n if (--j < i || nb === -2) return 0;\n nb = utf8CheckByte(buf[j]);\n if (nb >= 0) {\n if (nb > 0) self.lastNeed = nb - 2;\n return nb;\n }\n if (--j < i || nb === -2) return 0;\n nb = utf8CheckByte(buf[j]);\n if (nb >= 0) {\n if (nb > 0) {\n if (nb === 2) nb = 0;else self.lastNeed = nb - 3;\n }\n return nb;\n }\n return 0;\n}\n\n// Validates as many continuation bytes for a multi-byte UTF-8 character as\n// needed or are available. If we see a non-continuation byte where we expect\n// one, we \"replace\" the validated continuation bytes we've seen so far with\n// a single UTF-8 replacement character ('\\ufffd'), to match v8's UTF-8 decoding\n// behavior. The continuation byte check is included three times in the case\n// where all of the continuation bytes for a character exist in the same buffer.\n// It is also done this way as a slight performance increase instead of using a\n// loop.\nfunction utf8CheckExtraBytes(self, buf, p) {\n if ((buf[0] & 0xC0) !== 0x80) {\n self.lastNeed = 0;\n return '\\ufffd';\n }\n if (self.lastNeed > 1 && buf.length > 1) {\n if ((buf[1] & 0xC0) !== 0x80) {\n self.lastNeed = 1;\n return '\\ufffd';\n }\n if (self.lastNeed > 2 && buf.length > 2) {\n if ((buf[2] & 0xC0) !== 0x80) {\n self.lastNeed = 2;\n return '\\ufffd';\n }\n }\n }\n}\n\n// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.\nfunction utf8FillLast(buf) {\n var p = this.lastTotal - this.lastNeed;\n var r = utf8CheckExtraBytes(this, buf, p);\n if (r !== undefined) return r;\n if (this.lastNeed <= buf.length) {\n buf.copy(this.lastChar, p, 0, this.lastNeed);\n return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n }\n buf.copy(this.lastChar, p, 0, buf.length);\n this.lastNeed -= buf.length;\n}\n\n// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a\n// partial character, the character's bytes are buffered until the required\n// number of bytes are available.\nfunction utf8Text(buf, i) {\n var total = utf8CheckIncomplete(this, buf, i);\n if (!this.lastNeed) return buf.toString('utf8', i);\n this.lastTotal = total;\n var end = buf.length - (total - this.lastNeed);\n buf.copy(this.lastChar, 0, end);\n return buf.toString('utf8', i, end);\n}\n\n// For UTF-8, a replacement character is added when ending on a partial\n// character.\nfunction utf8End(buf) {\n var r = buf && buf.length ? this.write(buf) : '';\n if (this.lastNeed) return r + '\\ufffd';\n return r;\n}\n\n// UTF-16LE typically needs two bytes per character, but even if we have an even\n// number of bytes available, we need to check if we end on a leading/high\n// surrogate. In that case, we need to wait for the next two bytes in order to\n// decode the last character properly.\nfunction utf16Text(buf, i) {\n if ((buf.length - i) % 2 === 0) {\n var r = buf.toString('utf16le', i);\n if (r) {\n var c = r.charCodeAt(r.length - 1);\n if (c >= 0xD800 && c <= 0xDBFF) {\n this.lastNeed = 2;\n this.lastTotal = 4;\n this.lastChar[0] = buf[buf.length - 2];\n this.lastChar[1] = buf[buf.length - 1];\n return r.slice(0, -1);\n }\n }\n return r;\n }\n this.lastNeed = 1;\n this.lastTotal = 2;\n this.lastChar[0] = buf[buf.length - 1];\n return buf.toString('utf16le', i, buf.length - 1);\n}\n\n// For UTF-16LE we do not explicitly append special replacement characters if we\n// end on a partial character, we simply let v8 handle that.\nfunction utf16End(buf) {\n var r = buf && buf.length ? this.write(buf) : '';\n if (this.lastNeed) {\n var end = this.lastTotal - this.lastNeed;\n return r + this.lastChar.toString('utf16le', 0, end);\n }\n return r;\n}\n\nfunction base64Text(buf, i) {\n var n = (buf.length - i) % 3;\n if (n === 0) return buf.toString('base64', i);\n this.lastNeed = 3 - n;\n this.lastTotal = 3;\n if (n === 1) {\n this.lastChar[0] = buf[buf.length - 1];\n } else {\n this.lastChar[0] = buf[buf.length - 2];\n this.lastChar[1] = buf[buf.length - 1];\n }\n return buf.toString('base64', i, buf.length - n);\n}\n\nfunction base64End(buf) {\n var r = buf && buf.length ? this.write(buf) : '';\n if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);\n return r;\n}\n\n// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)\nfunction simpleWrite(buf) {\n return buf.toString(this.encoding);\n}\n\nfunction simpleEnd(buf) {\n return buf && buf.length ? this.write(buf) : '';\n}","// Ported from https://github.com/mafintosh/end-of-stream with\n// permission from the author, Mathias Buus (@mafintosh).\n\n'use strict';\n\nvar ERR_STREAM_PREMATURE_CLOSE = require('../../../errors').codes.ERR_STREAM_PREMATURE_CLOSE;\nfunction once(callback) {\n var called = false;\n return function () {\n if (called) return;\n called = true;\n for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n callback.apply(this, args);\n };\n}\nfunction noop() {}\nfunction isRequest(stream) {\n return stream.setHeader && typeof stream.abort === 'function';\n}\nfunction eos(stream, opts, callback) {\n if (typeof opts === 'function') return eos(stream, null, opts);\n if (!opts) opts = {};\n callback = once(callback || noop);\n var readable = opts.readable || opts.readable !== false && stream.readable;\n var writable = opts.writable || opts.writable !== false && stream.writable;\n var onlegacyfinish = function onlegacyfinish() {\n if (!stream.writable) onfinish();\n };\n var writableEnded = stream._writableState && stream._writableState.finished;\n var onfinish = function onfinish() {\n writable = false;\n writableEnded = true;\n if (!readable) callback.call(stream);\n };\n var readableEnded = stream._readableState && stream._readableState.endEmitted;\n var onend = function onend() {\n readable = false;\n readableEnded = true;\n if (!writable) callback.call(stream);\n };\n var onerror = function onerror(err) {\n callback.call(stream, err);\n };\n var onclose = function onclose() {\n var err;\n if (readable && !readableEnded) {\n if (!stream._readableState || !stream._readableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();\n return callback.call(stream, err);\n }\n if (writable && !writableEnded) {\n if (!stream._writableState || !stream._writableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();\n return callback.call(stream, err);\n }\n };\n var onrequest = function onrequest() {\n stream.req.on('finish', onfinish);\n };\n if (isRequest(stream)) {\n stream.on('complete', onfinish);\n stream.on('abort', onclose);\n if (stream.req) onrequest();else stream.on('request', onrequest);\n } else if (writable && !stream._writableState) {\n // legacy streams\n stream.on('end', onlegacyfinish);\n stream.on('close', onlegacyfinish);\n }\n stream.on('end', onend);\n stream.on('finish', onfinish);\n if (opts.error !== false) stream.on('error', onerror);\n stream.on('close', onclose);\n return function () {\n stream.removeListener('complete', onfinish);\n stream.removeListener('abort', onclose);\n stream.removeListener('request', onrequest);\n if (stream.req) stream.req.removeListener('finish', onfinish);\n stream.removeListener('end', onlegacyfinish);\n stream.removeListener('close', onlegacyfinish);\n stream.removeListener('finish', onfinish);\n stream.removeListener('end', onend);\n stream.removeListener('error', onerror);\n stream.removeListener('close', onclose);\n };\n}\nmodule.exports = eos;","'use strict';\n\nvar _Object$setPrototypeO;\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return typeof key === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (typeof input !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (typeof res !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nvar finished = require('./end-of-stream');\nvar kLastResolve = Symbol('lastResolve');\nvar kLastReject = Symbol('lastReject');\nvar kError = Symbol('error');\nvar kEnded = Symbol('ended');\nvar kLastPromise = Symbol('lastPromise');\nvar kHandlePromise = Symbol('handlePromise');\nvar kStream = Symbol('stream');\nfunction createIterResult(value, done) {\n return {\n value: value,\n done: done\n };\n}\nfunction readAndResolve(iter) {\n var resolve = iter[kLastResolve];\n if (resolve !== null) {\n var data = iter[kStream].read();\n // we defer if data is null\n // we can be expecting either 'end' or\n // 'error'\n if (data !== null) {\n iter[kLastPromise] = null;\n iter[kLastResolve] = null;\n iter[kLastReject] = null;\n resolve(createIterResult(data, false));\n }\n }\n}\nfunction onReadable(iter) {\n // we wait for the next tick, because it might\n // emit an error with process.nextTick\n process.nextTick(readAndResolve, iter);\n}\nfunction wrapForNext(lastPromise, iter) {\n return function (resolve, reject) {\n lastPromise.then(function () {\n if (iter[kEnded]) {\n resolve(createIterResult(undefined, true));\n return;\n }\n iter[kHandlePromise](resolve, reject);\n }, reject);\n };\n}\nvar AsyncIteratorPrototype = Object.getPrototypeOf(function () {});\nvar ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {\n get stream() {\n return this[kStream];\n },\n next: function next() {\n var _this = this;\n // if we have detected an error in the meanwhile\n // reject straight away\n var error = this[kError];\n if (error !== null) {\n return Promise.reject(error);\n }\n if (this[kEnded]) {\n return Promise.resolve(createIterResult(undefined, true));\n }\n if (this[kStream].destroyed) {\n // We need to defer via nextTick because if .destroy(err) is\n // called, the error will be emitted via nextTick, and\n // we cannot guarantee that there is no error lingering around\n // waiting to be emitted.\n return new Promise(function (resolve, reject) {\n process.nextTick(function () {\n if (_this[kError]) {\n reject(_this[kError]);\n } else {\n resolve(createIterResult(undefined, true));\n }\n });\n });\n }\n\n // if we have multiple next() calls\n // we will wait for the previous Promise to finish\n // this logic is optimized to support for await loops,\n // where next() is only called once at a time\n var lastPromise = this[kLastPromise];\n var promise;\n if (lastPromise) {\n promise = new Promise(wrapForNext(lastPromise, this));\n } else {\n // fast path needed to support multiple this.push()\n // without triggering the next() queue\n var data = this[kStream].read();\n if (data !== null) {\n return Promise.resolve(createIterResult(data, false));\n }\n promise = new Promise(this[kHandlePromise]);\n }\n this[kLastPromise] = promise;\n return promise;\n }\n}, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function () {\n return this;\n}), _defineProperty(_Object$setPrototypeO, \"return\", function _return() {\n var _this2 = this;\n // destroy(err, cb) is a private API\n // we can guarantee we have that here, because we control the\n // Readable class this is attached to\n return new Promise(function (resolve, reject) {\n _this2[kStream].destroy(null, function (err) {\n if (err) {\n reject(err);\n return;\n }\n resolve(createIterResult(undefined, true));\n });\n });\n}), _Object$setPrototypeO), AsyncIteratorPrototype);\nvar createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator(stream) {\n var _Object$create;\n var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, {\n value: stream,\n writable: true\n }), _defineProperty(_Object$create, kLastResolve, {\n value: null,\n writable: true\n }), _defineProperty(_Object$create, kLastReject, {\n value: null,\n writable: true\n }), _defineProperty(_Object$create, kError, {\n value: null,\n writable: true\n }), _defineProperty(_Object$create, kEnded, {\n value: stream._readableState.endEmitted,\n writable: true\n }), _defineProperty(_Object$create, kHandlePromise, {\n value: function value(resolve, reject) {\n var data = iterator[kStream].read();\n if (data) {\n iterator[kLastPromise] = null;\n iterator[kLastResolve] = null;\n iterator[kLastReject] = null;\n resolve(createIterResult(data, false));\n } else {\n iterator[kLastResolve] = resolve;\n iterator[kLastReject] = reject;\n }\n },\n writable: true\n }), _Object$create));\n iterator[kLastPromise] = null;\n finished(stream, function (err) {\n if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {\n var reject = iterator[kLastReject];\n // reject if we are waiting for data in the Promise\n // returned by next() and store the error\n if (reject !== null) {\n iterator[kLastPromise] = null;\n iterator[kLastResolve] = null;\n iterator[kLastReject] = null;\n reject(err);\n }\n iterator[kError] = err;\n return;\n }\n var resolve = iterator[kLastResolve];\n if (resolve !== null) {\n iterator[kLastPromise] = null;\n iterator[kLastResolve] = null;\n iterator[kLastReject] = null;\n resolve(createIterResult(undefined, true));\n }\n iterator[kEnded] = true;\n });\n stream.on('readable', onReadable.bind(null, iterator));\n return iterator;\n};\nmodule.exports = createReadableStreamAsyncIterator;","module.exports = function () {\n throw new Error('Readable.from is not available in the browser')\n};\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nmodule.exports = Readable;\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nReadable.ReadableState = ReadableState;\n\n/*<replacement>*/\nvar EE = require('events').EventEmitter;\nvar EElistenerCount = function EElistenerCount(emitter, type) {\n return emitter.listeners(type).length;\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\nvar Buffer = require('buffer').Buffer;\nvar OurUint8Array = (typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\n/*<replacement>*/\nvar debugUtil = require('util');\nvar debug;\nif (debugUtil && debugUtil.debuglog) {\n debug = debugUtil.debuglog('stream');\n} else {\n debug = function debug() {};\n}\n/*</replacement>*/\n\nvar BufferList = require('./internal/streams/buffer_list');\nvar destroyImpl = require('./internal/streams/destroy');\nvar _require = require('./internal/streams/state'),\n getHighWaterMark = _require.getHighWaterMark;\nvar _require$codes = require('../errors').codes,\n ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,\n ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF,\n ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT;\n\n// Lazy loaded to improve the startup performance.\nvar StringDecoder;\nvar createReadableStreamAsyncIterator;\nvar from;\nrequire('inherits')(Readable, Stream);\nvar errorOrDestroy = destroyImpl.errorOrDestroy;\nvar kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];\nfunction prependListener(emitter, event, fn) {\n // Sadly this is not cacheable as some libraries bundle their own\n // event emitter implementation with them.\n if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn);\n\n // This is a hack to make sure that our error handler is attached before any\n // userland ones. NEVER DO THIS. This is here only because this code needs\n // to continue to work with older versions of Node.js that do not include\n // the prependListener() method. The goal is to eventually remove this hack.\n if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (Array.isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];\n}\nfunction ReadableState(options, stream, isDuplex) {\n Duplex = Duplex || require('./_stream_duplex');\n options = options || {};\n\n // Duplex streams are both readable and writable, but share\n // the same options object.\n // However, some cases require setting options to different\n // values for the readable and the writable sides of the duplex stream.\n // These options can be provided separately as readableXXX and writableXXX.\n if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex;\n\n // object stream flag. Used to make read(n) ignore n and to\n // make all the buffer merging and length checks go away\n this.objectMode = !!options.objectMode;\n if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;\n\n // the point at which it stops calling _read() to fill the buffer\n // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex);\n\n // A linked list is used to store data chunks instead of an array because the\n // linked list can remove elements from the beginning faster than\n // array.shift()\n this.buffer = new BufferList();\n this.length = 0;\n this.pipes = null;\n this.pipesCount = 0;\n this.flowing = null;\n this.ended = false;\n this.endEmitted = false;\n this.reading = false;\n\n // a flag to be able to tell if the event 'readable'/'data' is emitted\n // immediately, or on a later tick. We set this to true at first, because\n // any actions that shouldn't happen until \"later\" should generally also\n // not happen before the first read call.\n this.sync = true;\n\n // whenever we return null, then we set a flag to say\n // that we're awaiting a 'readable' event emission.\n this.needReadable = false;\n this.emittedReadable = false;\n this.readableListening = false;\n this.resumeScheduled = false;\n this.paused = true;\n\n // Should close be emitted on destroy. Defaults to true.\n this.emitClose = options.emitClose !== false;\n\n // Should .destroy() be called after 'end' (and potentially 'finish')\n this.autoDestroy = !!options.autoDestroy;\n\n // has it been destroyed\n this.destroyed = false;\n\n // Crypto is kind of old and crusty. Historically, its default string\n // encoding is 'binary' so we have to make this configurable.\n // Everything else in the universe uses 'utf8', though.\n this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n // the number of writers that are awaiting a drain event in .pipe()s\n this.awaitDrain = 0;\n\n // if true, a maybeReadMore has been scheduled\n this.readingMore = false;\n this.decoder = null;\n this.encoding = null;\n if (options.encoding) {\n if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n this.decoder = new StringDecoder(options.encoding);\n this.encoding = options.encoding;\n }\n}\nfunction Readable(options) {\n Duplex = Duplex || require('./_stream_duplex');\n if (!(this instanceof Readable)) return new Readable(options);\n\n // Checking for a Stream.Duplex instance is faster here instead of inside\n // the ReadableState constructor, at least with V8 6.5\n var isDuplex = this instanceof Duplex;\n this._readableState = new ReadableState(options, this, isDuplex);\n\n // legacy\n this.readable = true;\n if (options) {\n if (typeof options.read === 'function') this._read = options.read;\n if (typeof options.destroy === 'function') this._destroy = options.destroy;\n }\n Stream.call(this);\n}\nObject.defineProperty(Readable.prototype, 'destroyed', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n if (this._readableState === undefined) {\n return false;\n }\n return this._readableState.destroyed;\n },\n set: function set(value) {\n // we ignore the value if the stream\n // has not been initialized yet\n if (!this._readableState) {\n return;\n }\n\n // backward compatibility, the user is explicitly\n // managing destroyed\n this._readableState.destroyed = value;\n }\n});\nReadable.prototype.destroy = destroyImpl.destroy;\nReadable.prototype._undestroy = destroyImpl.undestroy;\nReadable.prototype._destroy = function (err, cb) {\n cb(err);\n};\n\n// Manually shove something into the read() buffer.\n// This returns true if the highWaterMark has not been hit yet,\n// similar to how Writable.write() returns true if you should\n// write() some more.\nReadable.prototype.push = function (chunk, encoding) {\n var state = this._readableState;\n var skipChunkCheck;\n if (!state.objectMode) {\n if (typeof chunk === 'string') {\n encoding = encoding || state.defaultEncoding;\n if (encoding !== state.encoding) {\n chunk = Buffer.from(chunk, encoding);\n encoding = '';\n }\n skipChunkCheck = true;\n }\n } else {\n skipChunkCheck = true;\n }\n return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);\n};\n\n// Unshift should *always* be something directly out of read()\nReadable.prototype.unshift = function (chunk) {\n return readableAddChunk(this, chunk, null, true, false);\n};\nfunction readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n debug('readableAddChunk', chunk);\n var state = stream._readableState;\n if (chunk === null) {\n state.reading = false;\n onEofChunk(stream, state);\n } else {\n var er;\n if (!skipChunkCheck) er = chunkInvalid(state, chunk);\n if (er) {\n errorOrDestroy(stream, er);\n } else if (state.objectMode || chunk && chunk.length > 0) {\n if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {\n chunk = _uint8ArrayToBuffer(chunk);\n }\n if (addToFront) {\n if (state.endEmitted) errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());else addChunk(stream, state, chunk, true);\n } else if (state.ended) {\n errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF());\n } else if (state.destroyed) {\n return false;\n } else {\n state.reading = false;\n if (state.decoder && !encoding) {\n chunk = state.decoder.write(chunk);\n if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);\n } else {\n addChunk(stream, state, chunk, false);\n }\n }\n } else if (!addToFront) {\n state.reading = false;\n maybeReadMore(stream, state);\n }\n }\n\n // We can push more data if we are below the highWaterMark.\n // Also, if we have no data yet, we can stand some more bytes.\n // This is to work around cases where hwm=0, such as the repl.\n return !state.ended && (state.length < state.highWaterMark || state.length === 0);\n}\nfunction addChunk(stream, state, chunk, addToFront) {\n if (state.flowing && state.length === 0 && !state.sync) {\n state.awaitDrain = 0;\n stream.emit('data', chunk);\n } else {\n // update the buffer info.\n state.length += state.objectMode ? 1 : chunk.length;\n if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);\n if (state.needReadable) emitReadable(stream);\n }\n maybeReadMore(stream, state);\n}\nfunction chunkInvalid(state, chunk) {\n var er;\n if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk);\n }\n return er;\n}\nReadable.prototype.isPaused = function () {\n return this._readableState.flowing === false;\n};\n\n// backwards compatibility.\nReadable.prototype.setEncoding = function (enc) {\n if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n var decoder = new StringDecoder(enc);\n this._readableState.decoder = decoder;\n // If setEncoding(null), decoder.encoding equals utf8\n this._readableState.encoding = this._readableState.decoder.encoding;\n\n // Iterate over current buffer to convert already stored Buffers:\n var p = this._readableState.buffer.head;\n var content = '';\n while (p !== null) {\n content += decoder.write(p.data);\n p = p.next;\n }\n this._readableState.buffer.clear();\n if (content !== '') this._readableState.buffer.push(content);\n this._readableState.length = content.length;\n return this;\n};\n\n// Don't raise the hwm > 1GB\nvar MAX_HWM = 0x40000000;\nfunction computeNewHighWaterMark(n) {\n if (n >= MAX_HWM) {\n // TODO(ronag): Throw ERR_VALUE_OUT_OF_RANGE.\n n = MAX_HWM;\n } else {\n // Get the next highest power of 2 to prevent increasing hwm excessively in\n // tiny amounts\n n--;\n n |= n >>> 1;\n n |= n >>> 2;\n n |= n >>> 4;\n n |= n >>> 8;\n n |= n >>> 16;\n n++;\n }\n return n;\n}\n\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction howMuchToRead(n, state) {\n if (n <= 0 || state.length === 0 && state.ended) return 0;\n if (state.objectMode) return 1;\n if (n !== n) {\n // Only flow one buffer at a time\n if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;\n }\n // If we're asking for more than the current hwm, then raise the hwm.\n if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\n if (n <= state.length) return n;\n // Don't have enough\n if (!state.ended) {\n state.needReadable = true;\n return 0;\n }\n return state.length;\n}\n\n// you can override either this method, or the async _read(n) below.\nReadable.prototype.read = function (n) {\n debug('read', n);\n n = parseInt(n, 10);\n var state = this._readableState;\n var nOrig = n;\n if (n !== 0) state.emittedReadable = false;\n\n // if we're doing read(0) to trigger a readable event, but we\n // already have a bunch of data in the buffer, then just trigger\n // the 'readable' event and move on.\n if (n === 0 && state.needReadable && ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)) {\n debug('read: emitReadable', state.length, state.ended);\n if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);\n return null;\n }\n n = howMuchToRead(n, state);\n\n // if we've ended, and we're now clear, then finish it up.\n if (n === 0 && state.ended) {\n if (state.length === 0) endReadable(this);\n return null;\n }\n\n // All the actual chunk generation logic needs to be\n // *below* the call to _read. The reason is that in certain\n // synthetic stream cases, such as passthrough streams, _read\n // may be a completely synchronous operation which may change\n // the state of the read buffer, providing enough data when\n // before there was *not* enough.\n //\n // So, the steps are:\n // 1. Figure out what the state of things will be after we do\n // a read from the buffer.\n //\n // 2. If that resulting state will trigger a _read, then call _read.\n // Note that this may be asynchronous, or synchronous. Yes, it is\n // deeply ugly to write APIs this way, but that still doesn't mean\n // that the Readable class should behave improperly, as streams are\n // designed to be sync/async agnostic.\n // Take note if the _read call is sync or async (ie, if the read call\n // has returned yet), so that we know whether or not it's safe to emit\n // 'readable' etc.\n //\n // 3. Actually pull the requested chunks out of the buffer and return.\n\n // if we need a readable event, then we need to do some reading.\n var doRead = state.needReadable;\n debug('need readable', doRead);\n\n // if we currently have less than the highWaterMark, then also read some\n if (state.length === 0 || state.length - n < state.highWaterMark) {\n doRead = true;\n debug('length less than watermark', doRead);\n }\n\n // however, if we've ended, then there's no point, and if we're already\n // reading, then it's unnecessary.\n if (state.ended || state.reading) {\n doRead = false;\n debug('reading or ended', doRead);\n } else if (doRead) {\n debug('do read');\n state.reading = true;\n state.sync = true;\n // if the length is currently zero, then we *need* a readable event.\n if (state.length === 0) state.needReadable = true;\n // call internal read method\n this._read(state.highWaterMark);\n state.sync = false;\n // If _read pushed data synchronously, then `reading` will be false,\n // and we need to re-evaluate how much data we can return to the user.\n if (!state.reading) n = howMuchToRead(nOrig, state);\n }\n var ret;\n if (n > 0) ret = fromList(n, state);else ret = null;\n if (ret === null) {\n state.needReadable = state.length <= state.highWaterMark;\n n = 0;\n } else {\n state.length -= n;\n state.awaitDrain = 0;\n }\n if (state.length === 0) {\n // If we have nothing in the buffer, then we want to know\n // as soon as we *do* get something into the buffer.\n if (!state.ended) state.needReadable = true;\n\n // If we tried to read() past the EOF, then emit end on the next tick.\n if (nOrig !== n && state.ended) endReadable(this);\n }\n if (ret !== null) this.emit('data', ret);\n return ret;\n};\nfunction onEofChunk(stream, state) {\n debug('onEofChunk');\n if (state.ended) return;\n if (state.decoder) {\n var chunk = state.decoder.end();\n if (chunk && chunk.length) {\n state.buffer.push(chunk);\n state.length += state.objectMode ? 1 : chunk.length;\n }\n }\n state.ended = true;\n if (state.sync) {\n // if we are sync, wait until next tick to emit the data.\n // Otherwise we risk emitting data in the flow()\n // the readable code triggers during a read() call\n emitReadable(stream);\n } else {\n // emit 'readable' now to make sure it gets picked up.\n state.needReadable = false;\n if (!state.emittedReadable) {\n state.emittedReadable = true;\n emitReadable_(stream);\n }\n }\n}\n\n// Don't emit readable right away in sync mode, because this can trigger\n// another read() call => stack overflow. This way, it might trigger\n// a nextTick recursion warning, but that's not so bad.\nfunction emitReadable(stream) {\n var state = stream._readableState;\n debug('emitReadable', state.needReadable, state.emittedReadable);\n state.needReadable = false;\n if (!state.emittedReadable) {\n debug('emitReadable', state.flowing);\n state.emittedReadable = true;\n process.nextTick(emitReadable_, stream);\n }\n}\nfunction emitReadable_(stream) {\n var state = stream._readableState;\n debug('emitReadable_', state.destroyed, state.length, state.ended);\n if (!state.destroyed && (state.length || state.ended)) {\n stream.emit('readable');\n state.emittedReadable = false;\n }\n\n // The stream needs another readable event if\n // 1. It is not flowing, as the flow mechanism will take\n // care of it.\n // 2. It is not ended.\n // 3. It is below the highWaterMark, so we can schedule\n // another readable later.\n state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark;\n flow(stream);\n}\n\n// at this point, the user has presumably seen the 'readable' event,\n// and called read() to consume some data. that may have triggered\n// in turn another _read(n) call, in which case reading = true if\n// it's in progress.\n// However, if we're not ended, or reading, and the length < hwm,\n// then go ahead and try to read some more preemptively.\nfunction maybeReadMore(stream, state) {\n if (!state.readingMore) {\n state.readingMore = true;\n process.nextTick(maybeReadMore_, stream, state);\n }\n}\nfunction maybeReadMore_(stream, state) {\n // Attempt to read more data if we should.\n //\n // The conditions for reading more data are (one of):\n // - Not enough data buffered (state.length < state.highWaterMark). The loop\n // is responsible for filling the buffer with enough data if such data\n // is available. If highWaterMark is 0 and we are not in the flowing mode\n // we should _not_ attempt to buffer any extra data. We'll get more data\n // when the stream consumer calls read() instead.\n // - No data in the buffer, and the stream is in flowing mode. In this mode\n // the loop below is responsible for ensuring read() is called. Failing to\n // call read here would abort the flow and there's no other mechanism for\n // continuing the flow if the stream consumer has just subscribed to the\n // 'data' event.\n //\n // In addition to the above conditions to keep reading data, the following\n // conditions prevent the data from being read:\n // - The stream has ended (state.ended).\n // - There is already a pending 'read' operation (state.reading). This is a\n // case where the the stream has called the implementation defined _read()\n // method, but they are processing the call asynchronously and have _not_\n // called push() with new data. In this case we skip performing more\n // read()s. The execution ends in this method again after the _read() ends\n // up calling push() with more data.\n while (!state.reading && !state.ended && (state.length < state.highWaterMark || state.flowing && state.length === 0)) {\n var len = state.length;\n debug('maybeReadMore read 0');\n stream.read(0);\n if (len === state.length)\n // didn't get any data, stop spinning.\n break;\n }\n state.readingMore = false;\n}\n\n// abstract method. to be overridden in specific implementation classes.\n// call cb(er, data) where data is <= n in length.\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n// arbitrary, and perhaps not very meaningful.\nReadable.prototype._read = function (n) {\n errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED('_read()'));\n};\nReadable.prototype.pipe = function (dest, pipeOpts) {\n var src = this;\n var state = this._readableState;\n switch (state.pipesCount) {\n case 0:\n state.pipes = dest;\n break;\n case 1:\n state.pipes = [state.pipes, dest];\n break;\n default:\n state.pipes.push(dest);\n break;\n }\n state.pipesCount += 1;\n debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);\n var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;\n var endFn = doEnd ? onend : unpipe;\n if (state.endEmitted) process.nextTick(endFn);else src.once('end', endFn);\n dest.on('unpipe', onunpipe);\n function onunpipe(readable, unpipeInfo) {\n debug('onunpipe');\n if (readable === src) {\n if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n unpipeInfo.hasUnpiped = true;\n cleanup();\n }\n }\n }\n function onend() {\n debug('onend');\n dest.end();\n }\n\n // when the dest drains, it reduces the awaitDrain counter\n // on the source. This would be more elegant with a .once()\n // handler in flow(), but adding and removing repeatedly is\n // too slow.\n var ondrain = pipeOnDrain(src);\n dest.on('drain', ondrain);\n var cleanedUp = false;\n function cleanup() {\n debug('cleanup');\n // cleanup event handlers once the pipe is broken\n dest.removeListener('close', onclose);\n dest.removeListener('finish', onfinish);\n dest.removeListener('drain', ondrain);\n dest.removeListener('error', onerror);\n dest.removeListener('unpipe', onunpipe);\n src.removeListener('end', onend);\n src.removeListener('end', unpipe);\n src.removeListener('data', ondata);\n cleanedUp = true;\n\n // if the reader is waiting for a drain event from this\n // specific writer, then it would cause it to never start\n // flowing again.\n // So, if this is awaiting a drain, then we just call it now.\n // If we don't know, then assume that we are waiting for one.\n if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();\n }\n src.on('data', ondata);\n function ondata(chunk) {\n debug('ondata');\n var ret = dest.write(chunk);\n debug('dest.write', ret);\n if (ret === false) {\n // If the user unpiped during `dest.write()`, it is possible\n // to get stuck in a permanently paused state if that write\n // also returned false.\n // => Check whether `dest` is still a piping destination.\n if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {\n debug('false write response, pause', state.awaitDrain);\n state.awaitDrain++;\n }\n src.pause();\n }\n }\n\n // if the dest has an error, then stop piping into it.\n // however, don't suppress the throwing behavior for this.\n function onerror(er) {\n debug('onerror', er);\n unpipe();\n dest.removeListener('error', onerror);\n if (EElistenerCount(dest, 'error') === 0) errorOrDestroy(dest, er);\n }\n\n // Make sure our error handler is attached before userland ones.\n prependListener(dest, 'error', onerror);\n\n // Both close and finish should trigger unpipe, but only once.\n function onclose() {\n dest.removeListener('finish', onfinish);\n unpipe();\n }\n dest.once('close', onclose);\n function onfinish() {\n debug('onfinish');\n dest.removeListener('close', onclose);\n unpipe();\n }\n dest.once('finish', onfinish);\n function unpipe() {\n debug('unpipe');\n src.unpipe(dest);\n }\n\n // tell the dest that it's being piped to\n dest.emit('pipe', src);\n\n // start the flow if it hasn't been started already.\n if (!state.flowing) {\n debug('pipe resume');\n src.resume();\n }\n return dest;\n};\nfunction pipeOnDrain(src) {\n return function pipeOnDrainFunctionResult() {\n var state = src._readableState;\n debug('pipeOnDrain', state.awaitDrain);\n if (state.awaitDrain) state.awaitDrain--;\n if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {\n state.flowing = true;\n flow(src);\n }\n };\n}\nReadable.prototype.unpipe = function (dest) {\n var state = this._readableState;\n var unpipeInfo = {\n hasUnpiped: false\n };\n\n // if we're not piping anywhere, then do nothing.\n if (state.pipesCount === 0) return this;\n\n // just one destination. most common case.\n if (state.pipesCount === 1) {\n // passed in one, but it's not the right one.\n if (dest && dest !== state.pipes) return this;\n if (!dest) dest = state.pipes;\n\n // got a match.\n state.pipes = null;\n state.pipesCount = 0;\n state.flowing = false;\n if (dest) dest.emit('unpipe', this, unpipeInfo);\n return this;\n }\n\n // slow case. multiple pipe destinations.\n\n if (!dest) {\n // remove all.\n var dests = state.pipes;\n var len = state.pipesCount;\n state.pipes = null;\n state.pipesCount = 0;\n state.flowing = false;\n for (var i = 0; i < len; i++) dests[i].emit('unpipe', this, {\n hasUnpiped: false\n });\n return this;\n }\n\n // try to find the right one.\n var index = indexOf(state.pipes, dest);\n if (index === -1) return this;\n state.pipes.splice(index, 1);\n state.pipesCount -= 1;\n if (state.pipesCount === 1) state.pipes = state.pipes[0];\n dest.emit('unpipe', this, unpipeInfo);\n return this;\n};\n\n// set up data events if they are asked for\n// Ensure readable listeners eventually get something\nReadable.prototype.on = function (ev, fn) {\n var res = Stream.prototype.on.call(this, ev, fn);\n var state = this._readableState;\n if (ev === 'data') {\n // update readableListening so that resume() may be a no-op\n // a few lines down. This is needed to support once('readable').\n state.readableListening = this.listenerCount('readable') > 0;\n\n // Try start flowing on next tick if stream isn't explicitly paused\n if (state.flowing !== false) this.resume();\n } else if (ev === 'readable') {\n if (!state.endEmitted && !state.readableListening) {\n state.readableListening = state.needReadable = true;\n state.flowing = false;\n state.emittedReadable = false;\n debug('on readable', state.length, state.reading);\n if (state.length) {\n emitReadable(this);\n } else if (!state.reading) {\n process.nextTick(nReadingNextTick, this);\n }\n }\n }\n return res;\n};\nReadable.prototype.addListener = Readable.prototype.on;\nReadable.prototype.removeListener = function (ev, fn) {\n var res = Stream.prototype.removeListener.call(this, ev, fn);\n if (ev === 'readable') {\n // We need to check if there is someone still listening to\n // readable and reset the state. However this needs to happen\n // after readable has been emitted but before I/O (nextTick) to\n // support once('readable', fn) cycles. This means that calling\n // resume within the same tick will have no\n // effect.\n process.nextTick(updateReadableListening, this);\n }\n return res;\n};\nReadable.prototype.removeAllListeners = function (ev) {\n var res = Stream.prototype.removeAllListeners.apply(this, arguments);\n if (ev === 'readable' || ev === undefined) {\n // We need to check if there is someone still listening to\n // readable and reset the state. However this needs to happen\n // after readable has been emitted but before I/O (nextTick) to\n // support once('readable', fn) cycles. This means that calling\n // resume within the same tick will have no\n // effect.\n process.nextTick(updateReadableListening, this);\n }\n return res;\n};\nfunction updateReadableListening(self) {\n var state = self._readableState;\n state.readableListening = self.listenerCount('readable') > 0;\n if (state.resumeScheduled && !state.paused) {\n // flowing needs to be set to true now, otherwise\n // the upcoming resume will not flow.\n state.flowing = true;\n\n // crude way to check if we should resume\n } else if (self.listenerCount('data') > 0) {\n self.resume();\n }\n}\nfunction nReadingNextTick(self) {\n debug('readable nexttick read 0');\n self.read(0);\n}\n\n// pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\nReadable.prototype.resume = function () {\n var state = this._readableState;\n if (!state.flowing) {\n debug('resume');\n // we flow only if there is no one listening\n // for readable, but we still have to call\n // resume()\n state.flowing = !state.readableListening;\n resume(this, state);\n }\n state.paused = false;\n return this;\n};\nfunction resume(stream, state) {\n if (!state.resumeScheduled) {\n state.resumeScheduled = true;\n process.nextTick(resume_, stream, state);\n }\n}\nfunction resume_(stream, state) {\n debug('resume', state.reading);\n if (!state.reading) {\n stream.read(0);\n }\n state.resumeScheduled = false;\n stream.emit('resume');\n flow(stream);\n if (state.flowing && !state.reading) stream.read(0);\n}\nReadable.prototype.pause = function () {\n debug('call pause flowing=%j', this._readableState.flowing);\n if (this._readableState.flowing !== false) {\n debug('pause');\n this._readableState.flowing = false;\n this.emit('pause');\n }\n this._readableState.paused = true;\n return this;\n};\nfunction flow(stream) {\n var state = stream._readableState;\n debug('flow', state.flowing);\n while (state.flowing && stream.read() !== null);\n}\n\n// wrap an old-style stream as the async data source.\n// This is *not* part of the readable stream interface.\n// It is an ugly unfortunate mess of history.\nReadable.prototype.wrap = function (stream) {\n var _this = this;\n var state = this._readableState;\n var paused = false;\n stream.on('end', function () {\n debug('wrapped end');\n if (state.decoder && !state.ended) {\n var chunk = state.decoder.end();\n if (chunk && chunk.length) _this.push(chunk);\n }\n _this.push(null);\n });\n stream.on('data', function (chunk) {\n debug('wrapped data');\n if (state.decoder) chunk = state.decoder.write(chunk);\n\n // don't skip over falsy values in objectMode\n if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;\n var ret = _this.push(chunk);\n if (!ret) {\n paused = true;\n stream.pause();\n }\n });\n\n // proxy all the other methods.\n // important when wrapping filters and duplexes.\n for (var i in stream) {\n if (this[i] === undefined && typeof stream[i] === 'function') {\n this[i] = function methodWrap(method) {\n return function methodWrapReturnFunction() {\n return stream[method].apply(stream, arguments);\n };\n }(i);\n }\n }\n\n // proxy certain important events.\n for (var n = 0; n < kProxyEvents.length; n++) {\n stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));\n }\n\n // when we try to consume some more bytes, simply unpause the\n // underlying stream.\n this._read = function (n) {\n debug('wrapped _read', n);\n if (paused) {\n paused = false;\n stream.resume();\n }\n };\n return this;\n};\nif (typeof Symbol === 'function') {\n Readable.prototype[Symbol.asyncIterator] = function () {\n if (createReadableStreamAsyncIterator === undefined) {\n createReadableStreamAsyncIterator = require('./internal/streams/async_iterator');\n }\n return createReadableStreamAsyncIterator(this);\n };\n}\nObject.defineProperty(Readable.prototype, 'readableHighWaterMark', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._readableState.highWaterMark;\n }\n});\nObject.defineProperty(Readable.prototype, 'readableBuffer', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._readableState && this._readableState.buffer;\n }\n});\nObject.defineProperty(Readable.prototype, 'readableFlowing', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._readableState.flowing;\n },\n set: function set(state) {\n if (this._readableState) {\n this._readableState.flowing = state;\n }\n }\n});\n\n// exposed for testing purposes only.\nReadable._fromList = fromList;\nObject.defineProperty(Readable.prototype, 'readableLength', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._readableState.length;\n }\n});\n\n// Pluck off n bytes from an array of buffers.\n// Length is the combined lengths of all the buffers in the list.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromList(n, state) {\n // nothing buffered\n if (state.length === 0) return null;\n var ret;\n if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {\n // read it all, truncate the list\n if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.first();else ret = state.buffer.concat(state.length);\n state.buffer.clear();\n } else {\n // read part of list\n ret = state.buffer.consume(n, state.decoder);\n }\n return ret;\n}\nfunction endReadable(stream) {\n var state = stream._readableState;\n debug('endReadable', state.endEmitted);\n if (!state.endEmitted) {\n state.ended = true;\n process.nextTick(endReadableNT, state, stream);\n }\n}\nfunction endReadableNT(state, stream) {\n debug('endReadableNT', state.endEmitted, state.length);\n\n // Check that we didn't get one last unshift.\n if (!state.endEmitted && state.length === 0) {\n state.endEmitted = true;\n stream.readable = false;\n stream.emit('end');\n if (state.autoDestroy) {\n // In case of duplex streams we need a way to detect\n // if the writable side is ready for autoDestroy as well\n var wState = stream._writableState;\n if (!wState || wState.autoDestroy && wState.finished) {\n stream.destroy();\n }\n }\n }\n}\nif (typeof Symbol === 'function') {\n Readable.from = function (iterable, opts) {\n if (from === undefined) {\n from = require('./internal/streams/from');\n }\n return from(Readable, iterable, opts);\n };\n}\nfunction indexOf(xs, x) {\n for (var i = 0, l = xs.length; i < l; i++) {\n if (xs[i] === x) return i;\n }\n return -1;\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a transform stream is a readable/writable stream where you do\n// something with the data. Sometimes it's called a \"filter\",\n// but that's not a great name for it, since that implies a thing where\n// some bits pass through, and others are simply ignored. (That would\n// be a valid example of a transform, of course.)\n//\n// While the output is causally related to the input, it's not a\n// necessarily symmetric or synchronous transformation. For example,\n// a zlib stream might take multiple plain-text writes(), and then\n// emit a single compressed chunk some time in the future.\n//\n// Here's how this works:\n//\n// The Transform stream has all the aspects of the readable and writable\n// stream classes. When you write(chunk), that calls _write(chunk,cb)\n// internally, and returns false if there's a lot of pending writes\n// buffered up. When you call read(), that calls _read(n) until\n// there's enough pending readable data buffered up.\n//\n// In a transform stream, the written data is placed in a buffer. When\n// _read(n) is called, it transforms the queued up data, calling the\n// buffered _write cb's as it consumes chunks. If consuming a single\n// written chunk would result in multiple output chunks, then the first\n// outputted bit calls the readcb, and subsequent chunks just go into\n// the read buffer, and will cause it to emit 'readable' if necessary.\n//\n// This way, back-pressure is actually determined by the reading side,\n// since _read has to be called to start processing a new chunk. However,\n// a pathological inflate type of transform can cause excessive buffering\n// here. For example, imagine a stream where every byte of input is\n// interpreted as an integer from 0-255, and then results in that many\n// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in\n// 1kb of data being output. In this case, you could write a very small\n// amount of input, and end up with a very large amount of output. In\n// such a pathological inflating mechanism, there'd be no way to tell\n// the system to stop doing the transform. A single 4MB write could\n// cause the system to run out of memory.\n//\n// However, even in such a pathological case, only a single written chunk\n// would be consumed, and then the rest would wait (un-transformed) until\n// the results of the previous transformed chunk were consumed.\n\n'use strict';\n\nmodule.exports = Transform;\nvar _require$codes = require('../errors').codes,\n ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,\n ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING,\n ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;\nvar Duplex = require('./_stream_duplex');\nrequire('inherits')(Transform, Duplex);\nfunction afterTransform(er, data) {\n var ts = this._transformState;\n ts.transforming = false;\n var cb = ts.writecb;\n if (cb === null) {\n return this.emit('error', new ERR_MULTIPLE_CALLBACK());\n }\n ts.writechunk = null;\n ts.writecb = null;\n if (data != null)\n // single equals check for both `null` and `undefined`\n this.push(data);\n cb(er);\n var rs = this._readableState;\n rs.reading = false;\n if (rs.needReadable || rs.length < rs.highWaterMark) {\n this._read(rs.highWaterMark);\n }\n}\nfunction Transform(options) {\n if (!(this instanceof Transform)) return new Transform(options);\n Duplex.call(this, options);\n this._transformState = {\n afterTransform: afterTransform.bind(this),\n needTransform: false,\n transforming: false,\n writecb: null,\n writechunk: null,\n writeencoding: null\n };\n\n // start out asking for a readable event once data is transformed.\n this._readableState.needReadable = true;\n\n // we have implemented the _read method, and done the other things\n // that Readable wants before the first _read call, so unset the\n // sync guard flag.\n this._readableState.sync = false;\n if (options) {\n if (typeof options.transform === 'function') this._transform = options.transform;\n if (typeof options.flush === 'function') this._flush = options.flush;\n }\n\n // When the writable side finishes, then flush out anything remaining.\n this.on('prefinish', prefinish);\n}\nfunction prefinish() {\n var _this = this;\n if (typeof this._flush === 'function' && !this._readableState.destroyed) {\n this._flush(function (er, data) {\n done(_this, er, data);\n });\n } else {\n done(this, null, null);\n }\n}\nTransform.prototype.push = function (chunk, encoding) {\n this._transformState.needTransform = false;\n return Duplex.prototype.push.call(this, chunk, encoding);\n};\n\n// This is the part where you do stuff!\n// override this function in implementation classes.\n// 'chunk' is an input chunk.\n//\n// Call `push(newChunk)` to pass along transformed output\n// to the readable side. You may call 'push' zero or more times.\n//\n// Call `cb(err)` when you are done with this chunk. If you pass\n// an error, then that'll put the hurt on the whole operation. If you\n// never call cb(), then you'll never get another chunk.\nTransform.prototype._transform = function (chunk, encoding, cb) {\n cb(new ERR_METHOD_NOT_IMPLEMENTED('_transform()'));\n};\nTransform.prototype._write = function (chunk, encoding, cb) {\n var ts = this._transformState;\n ts.writecb = cb;\n ts.writechunk = chunk;\n ts.writeencoding = encoding;\n if (!ts.transforming) {\n var rs = this._readableState;\n if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);\n }\n};\n\n// Doesn't matter what the args are here.\n// _transform does all the work.\n// That we got here means that the readable side wants more data.\nTransform.prototype._read = function (n) {\n var ts = this._transformState;\n if (ts.writechunk !== null && !ts.transforming) {\n ts.transforming = true;\n this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n } else {\n // mark that we need a transform, so that any data that comes in\n // will get processed, now that we've asked for it.\n ts.needTransform = true;\n }\n};\nTransform.prototype._destroy = function (err, cb) {\n Duplex.prototype._destroy.call(this, err, function (err2) {\n cb(err2);\n });\n};\nfunction done(stream, er, data) {\n if (er) return stream.emit('error', er);\n if (data != null)\n // single equals check for both `null` and `undefined`\n stream.push(data);\n\n // TODO(BridgeAR): Write a test for these two error cases\n // if there's nothing in the write buffer, then that means\n // that nothing more will ever be provided\n if (stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0();\n if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();\n return stream.push(null);\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n\n'use strict';\n\nmodule.exports = PassThrough;\nvar Transform = require('./_stream_transform');\nrequire('inherits')(PassThrough, Transform);\nfunction PassThrough(options) {\n if (!(this instanceof PassThrough)) return new PassThrough(options);\n Transform.call(this, options);\n}\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\n cb(null, chunk);\n};","// Ported from https://github.com/mafintosh/pump with\n// permission from the author, Mathias Buus (@mafintosh).\n\n'use strict';\n\nvar eos;\nfunction once(callback) {\n var called = false;\n return function () {\n if (called) return;\n called = true;\n callback.apply(void 0, arguments);\n };\n}\nvar _require$codes = require('../../../errors').codes,\n ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS,\n ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;\nfunction noop(err) {\n // Rethrow the error if it exists to avoid swallowing it\n if (err) throw err;\n}\nfunction isRequest(stream) {\n return stream.setHeader && typeof stream.abort === 'function';\n}\nfunction destroyer(stream, reading, writing, callback) {\n callback = once(callback);\n var closed = false;\n stream.on('close', function () {\n closed = true;\n });\n if (eos === undefined) eos = require('./end-of-stream');\n eos(stream, {\n readable: reading,\n writable: writing\n }, function (err) {\n if (err) return callback(err);\n closed = true;\n callback();\n });\n var destroyed = false;\n return function (err) {\n if (closed) return;\n if (destroyed) return;\n destroyed = true;\n\n // request.destroy just do .end - .abort is what we want\n if (isRequest(stream)) return stream.abort();\n if (typeof stream.destroy === 'function') return stream.destroy();\n callback(err || new ERR_STREAM_DESTROYED('pipe'));\n };\n}\nfunction call(fn) {\n fn();\n}\nfunction pipe(from, to) {\n return from.pipe(to);\n}\nfunction popCallback(streams) {\n if (!streams.length) return noop;\n if (typeof streams[streams.length - 1] !== 'function') return noop;\n return streams.pop();\n}\nfunction pipeline() {\n for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) {\n streams[_key] = arguments[_key];\n }\n var callback = popCallback(streams);\n if (Array.isArray(streams[0])) streams = streams[0];\n if (streams.length < 2) {\n throw new ERR_MISSING_ARGS('streams');\n }\n var error;\n var destroys = streams.map(function (stream, i) {\n var reading = i < streams.length - 1;\n var writing = i > 0;\n return destroyer(stream, reading, writing, function (err) {\n if (!error) error = err;\n if (err) destroys.forEach(call);\n if (reading) return;\n destroys.forEach(call);\n callback(error);\n });\n });\n return streams.reduce(pipe);\n}\nmodule.exports = pipeline;","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nmodule.exports = Stream;\n\nvar EE = require('events').EventEmitter;\nvar inherits = require('inherits');\n\ninherits(Stream, EE);\nStream.Readable = require('readable-stream/lib/_stream_readable.js');\nStream.Writable = require('readable-stream/lib/_stream_writable.js');\nStream.Duplex = require('readable-stream/lib/_stream_duplex.js');\nStream.Transform = require('readable-stream/lib/_stream_transform.js');\nStream.PassThrough = require('readable-stream/lib/_stream_passthrough.js');\nStream.finished = require('readable-stream/lib/internal/streams/end-of-stream.js')\nStream.pipeline = require('readable-stream/lib/internal/streams/pipeline.js')\n\n// Backwards-compat with node 0.4.x\nStream.Stream = Stream;\n\n\n\n// old-style streams. Note that the pipe method (the only relevant\n// part of this class) is overridden in the Readable class.\n\nfunction Stream() {\n EE.call(this);\n}\n\nStream.prototype.pipe = function(dest, options) {\n var source = this;\n\n function ondata(chunk) {\n if (dest.writable) {\n if (false === dest.write(chunk) && source.pause) {\n source.pause();\n }\n }\n }\n\n source.on('data', ondata);\n\n function ondrain() {\n if (source.readable && source.resume) {\n source.resume();\n }\n }\n\n dest.on('drain', ondrain);\n\n // If the 'end' option is not supplied, dest.end() will be called when\n // source gets the 'end' or 'close' events. Only dest.end() once.\n if (!dest._isStdio && (!options || options.end !== false)) {\n source.on('end', onend);\n source.on('close', onclose);\n }\n\n var didOnEnd = false;\n function onend() {\n if (didOnEnd) return;\n didOnEnd = true;\n\n dest.end();\n }\n\n\n function onclose() {\n if (didOnEnd) return;\n didOnEnd = true;\n\n if (typeof dest.destroy === 'function') dest.destroy();\n }\n\n // don't leave dangling pipes when there are errors.\n function onerror(er) {\n cleanup();\n if (EE.listenerCount(this, 'error') === 0) {\n throw er; // Unhandled stream error in pipe.\n }\n }\n\n source.on('error', onerror);\n dest.on('error', onerror);\n\n // remove all the event listeners that were added.\n function cleanup() {\n source.removeListener('data', ondata);\n dest.removeListener('drain', ondrain);\n\n source.removeListener('end', onend);\n source.removeListener('close', onclose);\n\n source.removeListener('error', onerror);\n dest.removeListener('error', onerror);\n\n source.removeListener('end', cleanup);\n source.removeListener('close', cleanup);\n\n dest.removeListener('close', cleanup);\n }\n\n source.on('end', cleanup);\n source.on('close', cleanup);\n\n dest.on('close', cleanup);\n\n dest.emit('pipe', source);\n\n // Allow for unix-like usage: A.pipe(B).pipe(C)\n return dest;\n};\n",";(function (sax) { // wrapper for non-node envs\n sax.parser = function (strict, opt) { return new SAXParser(strict, opt) }\n sax.SAXParser = SAXParser\n sax.SAXStream = SAXStream\n sax.createStream = createStream\n\n // When we pass the MAX_BUFFER_LENGTH position, start checking for buffer overruns.\n // When we check, schedule the next check for MAX_BUFFER_LENGTH - (max(buffer lengths)),\n // since that's the earliest that a buffer overrun could occur. This way, checks are\n // as rare as required, but as often as necessary to ensure never crossing this bound.\n // Furthermore, buffers are only tested at most once per write(), so passing a very\n // large string into write() might have undesirable effects, but this is manageable by\n // the caller, so it is assumed to be safe. Thus, a call to write() may, in the extreme\n // edge case, result in creating at most one complete copy of the string passed in.\n // Set to Infinity to have unlimited buffers.\n sax.MAX_BUFFER_LENGTH = 64 * 1024\n\n var buffers = [\n 'comment', 'sgmlDecl', 'textNode', 'tagName', 'doctype',\n 'procInstName', 'procInstBody', 'entity', 'attribName',\n 'attribValue', 'cdata', 'script'\n ]\n\n sax.EVENTS = [\n 'text',\n 'processinginstruction',\n 'sgmldeclaration',\n 'doctype',\n 'comment',\n 'opentagstart',\n 'attribute',\n 'opentag',\n 'closetag',\n 'opencdata',\n 'cdata',\n 'closecdata',\n 'error',\n 'end',\n 'ready',\n 'script',\n 'opennamespace',\n 'closenamespace'\n ]\n\n function SAXParser (strict, opt) {\n if (!(this instanceof SAXParser)) {\n return new SAXParser(strict, opt)\n }\n\n var parser = this\n clearBuffers(parser)\n parser.q = parser.c = ''\n parser.bufferCheckPosition = sax.MAX_BUFFER_LENGTH\n parser.opt = opt || {}\n parser.opt.lowercase = parser.opt.lowercase || parser.opt.lowercasetags\n parser.looseCase = parser.opt.lowercase ? 'toLowerCase' : 'toUpperCase'\n parser.tags = []\n parser.closed = parser.closedRoot = parser.sawRoot = false\n parser.tag = parser.error = null\n parser.strict = !!strict\n parser.noscript = !!(strict || parser.opt.noscript)\n parser.state = S.BEGIN\n parser.strictEntities = parser.opt.strictEntities\n parser.ENTITIES = parser.strictEntities ? Object.create(sax.XML_ENTITIES) : Object.create(sax.ENTITIES)\n parser.attribList = []\n\n // namespaces form a prototype chain.\n // it always points at the current tag,\n // which protos to its parent tag.\n if (parser.opt.xmlns) {\n parser.ns = Object.create(rootNS)\n }\n\n // disallow unquoted attribute values if not otherwise configured\n // and strict mode is true\n if (parser.opt.unquotedAttributeValues === undefined) {\n parser.opt.unquotedAttributeValues = !strict;\n }\n\n // mostly just for error reporting\n parser.trackPosition = parser.opt.position !== false\n if (parser.trackPosition) {\n parser.position = parser.line = parser.column = 0\n }\n emit(parser, 'onready')\n }\n\n if (!Object.create) {\n Object.create = function (o) {\n function F () {}\n F.prototype = o\n var newf = new F()\n return newf\n }\n }\n\n if (!Object.keys) {\n Object.keys = function (o) {\n var a = []\n for (var i in o) if (o.hasOwnProperty(i)) a.push(i)\n return a\n }\n }\n\n function checkBufferLength (parser) {\n var maxAllowed = Math.max(sax.MAX_BUFFER_LENGTH, 10)\n var maxActual = 0\n for (var i = 0, l = buffers.length; i < l; i++) {\n var len = parser[buffers[i]].length\n if (len > maxAllowed) {\n // Text/cdata nodes can get big, and since they're buffered,\n // we can get here under normal conditions.\n // Avoid issues by emitting the text node now,\n // so at least it won't get any bigger.\n switch (buffers[i]) {\n case 'textNode':\n closeText(parser)\n break\n\n case 'cdata':\n emitNode(parser, 'oncdata', parser.cdata)\n parser.cdata = ''\n break\n\n case 'script':\n emitNode(parser, 'onscript', parser.script)\n parser.script = ''\n break\n\n default:\n error(parser, 'Max buffer length exceeded: ' + buffers[i])\n }\n }\n maxActual = Math.max(maxActual, len)\n }\n // schedule the next check for the earliest possible buffer overrun.\n var m = sax.MAX_BUFFER_LENGTH - maxActual\n parser.bufferCheckPosition = m + parser.position\n }\n\n function clearBuffers (parser) {\n for (var i = 0, l = buffers.length; i < l; i++) {\n parser[buffers[i]] = ''\n }\n }\n\n function flushBuffers (parser) {\n closeText(parser)\n if (parser.cdata !== '') {\n emitNode(parser, 'oncdata', parser.cdata)\n parser.cdata = ''\n }\n if (parser.script !== '') {\n emitNode(parser, 'onscript', parser.script)\n parser.script = ''\n }\n }\n\n SAXParser.prototype = {\n end: function () { end(this) },\n write: write,\n resume: function () { this.error = null; return this },\n close: function () { return this.write(null) },\n flush: function () { flushBuffers(this) }\n }\n\n var Stream\n try {\n Stream = require('stream').Stream\n } catch (ex) {\n Stream = function () {}\n }\n if (!Stream) Stream = function () {}\n\n var streamWraps = sax.EVENTS.filter(function (ev) {\n return ev !== 'error' && ev !== 'end'\n })\n\n function createStream (strict, opt) {\n return new SAXStream(strict, opt)\n }\n\n function SAXStream (strict, opt) {\n if (!(this instanceof SAXStream)) {\n return new SAXStream(strict, opt)\n }\n\n Stream.apply(this)\n\n this._parser = new SAXParser(strict, opt)\n this.writable = true\n this.readable = true\n\n var me = this\n\n this._parser.onend = function () {\n me.emit('end')\n }\n\n this._parser.onerror = function (er) {\n me.emit('error', er)\n\n // if didn't throw, then means error was handled.\n // go ahead and clear error, so we can write again.\n me._parser.error = null\n }\n\n this._decoder = null\n\n streamWraps.forEach(function (ev) {\n Object.defineProperty(me, 'on' + ev, {\n get: function () {\n return me._parser['on' + ev]\n },\n set: function (h) {\n if (!h) {\n me.removeAllListeners(ev)\n me._parser['on' + ev] = h\n return h\n }\n me.on(ev, h)\n },\n enumerable: true,\n configurable: false\n })\n })\n }\n\n SAXStream.prototype = Object.create(Stream.prototype, {\n constructor: {\n value: SAXStream\n }\n })\n\n SAXStream.prototype.write = function (data) {\n if (typeof Buffer === 'function' &&\n typeof Buffer.isBuffer === 'function' &&\n Buffer.isBuffer(data)) {\n if (!this._decoder) {\n var SD = require('string_decoder').StringDecoder\n this._decoder = new SD('utf8')\n }\n data = this._decoder.write(data)\n }\n\n this._parser.write(data.toString())\n this.emit('data', data)\n return true\n }\n\n SAXStream.prototype.end = function (chunk) {\n if (chunk && chunk.length) {\n this.write(chunk)\n }\n this._parser.end()\n return true\n }\n\n SAXStream.prototype.on = function (ev, handler) {\n var me = this\n if (!me._parser['on' + ev] && streamWraps.indexOf(ev) !== -1) {\n me._parser['on' + ev] = function () {\n var args = arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments)\n args.splice(0, 0, ev)\n me.emit.apply(me, args)\n }\n }\n\n return Stream.prototype.on.call(me, ev, handler)\n }\n\n // this really needs to be replaced with character classes.\n // XML allows all manner of ridiculous numbers and digits.\n var CDATA = '[CDATA['\n var DOCTYPE = 'DOCTYPE'\n var XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace'\n var XMLNS_NAMESPACE = 'http://www.w3.org/2000/xmlns/'\n var rootNS = { xml: XML_NAMESPACE, xmlns: XMLNS_NAMESPACE }\n\n // http://www.w3.org/TR/REC-xml/#NT-NameStartChar\n // This implementation works on strings, a single character at a time\n // as such, it cannot ever support astral-plane characters (10000-EFFFF)\n // without a significant breaking change to either this parser, or the\n // JavaScript language. Implementation of an emoji-capable xml parser\n // is left as an exercise for the reader.\n var nameStart = /[:_A-Za-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD]/\n\n var nameBody = /[:_A-Za-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\u00B7\\u0300-\\u036F\\u203F-\\u2040.\\d-]/\n\n var entityStart = /[#:_A-Za-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD]/\n var entityBody = /[#:_A-Za-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\u00B7\\u0300-\\u036F\\u203F-\\u2040.\\d-]/\n\n function isWhitespace (c) {\n return c === ' ' || c === '\\n' || c === '\\r' || c === '\\t'\n }\n\n function isQuote (c) {\n return c === '\"' || c === '\\''\n }\n\n function isAttribEnd (c) {\n return c === '>' || isWhitespace(c)\n }\n\n function isMatch (regex, c) {\n return regex.test(c)\n }\n\n function notMatch (regex, c) {\n return !isMatch(regex, c)\n }\n\n var S = 0\n sax.STATE = {\n BEGIN: S++, // leading byte order mark or whitespace\n BEGIN_WHITESPACE: S++, // leading whitespace\n TEXT: S++, // general stuff\n TEXT_ENTITY: S++, // & and such.\n OPEN_WAKA: S++, // <\n SGML_DECL: S++, // <!BLARG\n SGML_DECL_QUOTED: S++, // <!BLARG foo \"bar\n DOCTYPE: S++, // <!DOCTYPE\n DOCTYPE_QUOTED: S++, // <!DOCTYPE \"//blah\n DOCTYPE_DTD: S++, // <!DOCTYPE \"//blah\" [ ...\n DOCTYPE_DTD_QUOTED: S++, // <!DOCTYPE \"//blah\" [ \"foo\n COMMENT_STARTING: S++, // <!-\n COMMENT: S++, // <!--\n COMMENT_ENDING: S++, // <!-- blah -\n COMMENT_ENDED: S++, // <!-- blah --\n CDATA: S++, // <![CDATA[ something\n CDATA_ENDING: S++, // ]\n CDATA_ENDING_2: S++, // ]]\n PROC_INST: S++, // <?hi\n PROC_INST_BODY: S++, // <?hi there\n PROC_INST_ENDING: S++, // <?hi \"there\" ?\n OPEN_TAG: S++, // <strong\n OPEN_TAG_SLASH: S++, // <strong /\n ATTRIB: S++, // <a\n ATTRIB_NAME: S++, // <a foo\n ATTRIB_NAME_SAW_WHITE: S++, // <a foo _\n ATTRIB_VALUE: S++, // <a foo=\n ATTRIB_VALUE_QUOTED: S++, // <a foo=\"bar\n ATTRIB_VALUE_CLOSED: S++, // <a foo=\"bar\"\n ATTRIB_VALUE_UNQUOTED: S++, // <a foo=bar\n ATTRIB_VALUE_ENTITY_Q: S++, // <foo bar=\""\"\n ATTRIB_VALUE_ENTITY_U: S++, // <foo bar="\n CLOSE_TAG: S++, // </a\n CLOSE_TAG_SAW_WHITE: S++, // </a >\n SCRIPT: S++, // <script> ...\n SCRIPT_ENDING: S++ // <script> ... <\n }\n\n sax.XML_ENTITIES = {\n 'amp': '&',\n 'gt': '>',\n 'lt': '<',\n 'quot': '\"',\n 'apos': \"'\"\n }\n\n sax.ENTITIES = {\n 'amp': '&',\n 'gt': '>',\n 'lt': '<',\n 'quot': '\"',\n 'apos': \"'\",\n 'AElig': 198,\n 'Aacute': 193,\n 'Acirc': 194,\n 'Agrave': 192,\n 'Aring': 197,\n 'Atilde': 195,\n 'Auml': 196,\n 'Ccedil': 199,\n 'ETH': 208,\n 'Eacute': 201,\n 'Ecirc': 202,\n 'Egrave': 200,\n 'Euml': 203,\n 'Iacute': 205,\n 'Icirc': 206,\n 'Igrave': 204,\n 'Iuml': 207,\n 'Ntilde': 209,\n 'Oacute': 211,\n 'Ocirc': 212,\n 'Ograve': 210,\n 'Oslash': 216,\n 'Otilde': 213,\n 'Ouml': 214,\n 'THORN': 222,\n 'Uacute': 218,\n 'Ucirc': 219,\n 'Ugrave': 217,\n 'Uuml': 220,\n 'Yacute': 221,\n 'aacute': 225,\n 'acirc': 226,\n 'aelig': 230,\n 'agrave': 224,\n 'aring': 229,\n 'atilde': 227,\n 'auml': 228,\n 'ccedil': 231,\n 'eacute': 233,\n 'ecirc': 234,\n 'egrave': 232,\n 'eth': 240,\n 'euml': 235,\n 'iacute': 237,\n 'icirc': 238,\n 'igrave': 236,\n 'iuml': 239,\n 'ntilde': 241,\n 'oacute': 243,\n 'ocirc': 244,\n 'ograve': 242,\n 'oslash': 248,\n 'otilde': 245,\n 'ouml': 246,\n 'szlig': 223,\n 'thorn': 254,\n 'uacute': 250,\n 'ucirc': 251,\n 'ugrave': 249,\n 'uuml': 252,\n 'yacute': 253,\n 'yuml': 255,\n 'copy': 169,\n 'reg': 174,\n 'nbsp': 160,\n 'iexcl': 161,\n 'cent': 162,\n 'pound': 163,\n 'curren': 164,\n 'yen': 165,\n 'brvbar': 166,\n 'sect': 167,\n 'uml': 168,\n 'ordf': 170,\n 'laquo': 171,\n 'not': 172,\n 'shy': 173,\n 'macr': 175,\n 'deg': 176,\n 'plusmn': 177,\n 'sup1': 185,\n 'sup2': 178,\n 'sup3': 179,\n 'acute': 180,\n 'micro': 181,\n 'para': 182,\n 'middot': 183,\n 'cedil': 184,\n 'ordm': 186,\n 'raquo': 187,\n 'frac14': 188,\n 'frac12': 189,\n 'frac34': 190,\n 'iquest': 191,\n 'times': 215,\n 'divide': 247,\n 'OElig': 338,\n 'oelig': 339,\n 'Scaron': 352,\n 'scaron': 353,\n 'Yuml': 376,\n 'fnof': 402,\n 'circ': 710,\n 'tilde': 732,\n 'Alpha': 913,\n 'Beta': 914,\n 'Gamma': 915,\n 'Delta': 916,\n 'Epsilon': 917,\n 'Zeta': 918,\n 'Eta': 919,\n 'Theta': 920,\n 'Iota': 921,\n 'Kappa': 922,\n 'Lambda': 923,\n 'Mu': 924,\n 'Nu': 925,\n 'Xi': 926,\n 'Omicron': 927,\n 'Pi': 928,\n 'Rho': 929,\n 'Sigma': 931,\n 'Tau': 932,\n 'Upsilon': 933,\n 'Phi': 934,\n 'Chi': 935,\n 'Psi': 936,\n 'Omega': 937,\n 'alpha': 945,\n 'beta': 946,\n 'gamma': 947,\n 'delta': 948,\n 'epsilon': 949,\n 'zeta': 950,\n 'eta': 951,\n 'theta': 952,\n 'iota': 953,\n 'kappa': 954,\n 'lambda': 955,\n 'mu': 956,\n 'nu': 957,\n 'xi': 958,\n 'omicron': 959,\n 'pi': 960,\n 'rho': 961,\n 'sigmaf': 962,\n 'sigma': 963,\n 'tau': 964,\n 'upsilon': 965,\n 'phi': 966,\n 'chi': 967,\n 'psi': 968,\n 'omega': 969,\n 'thetasym': 977,\n 'upsih': 978,\n 'piv': 982,\n 'ensp': 8194,\n 'emsp': 8195,\n 'thinsp': 8201,\n 'zwnj': 8204,\n 'zwj': 8205,\n 'lrm': 8206,\n 'rlm': 8207,\n 'ndash': 8211,\n 'mdash': 8212,\n 'lsquo': 8216,\n 'rsquo': 8217,\n 'sbquo': 8218,\n 'ldquo': 8220,\n 'rdquo': 8221,\n 'bdquo': 8222,\n 'dagger': 8224,\n 'Dagger': 8225,\n 'bull': 8226,\n 'hellip': 8230,\n 'permil': 8240,\n 'prime': 8242,\n 'Prime': 8243,\n 'lsaquo': 8249,\n 'rsaquo': 8250,\n 'oline': 8254,\n 'frasl': 8260,\n 'euro': 8364,\n 'image': 8465,\n 'weierp': 8472,\n 'real': 8476,\n 'trade': 8482,\n 'alefsym': 8501,\n 'larr': 8592,\n 'uarr': 8593,\n 'rarr': 8594,\n 'darr': 8595,\n 'harr': 8596,\n 'crarr': 8629,\n 'lArr': 8656,\n 'uArr': 8657,\n 'rArr': 8658,\n 'dArr': 8659,\n 'hArr': 8660,\n 'forall': 8704,\n 'part': 8706,\n 'exist': 8707,\n 'empty': 8709,\n 'nabla': 8711,\n 'isin': 8712,\n 'notin': 8713,\n 'ni': 8715,\n 'prod': 8719,\n 'sum': 8721,\n 'minus': 8722,\n 'lowast': 8727,\n 'radic': 8730,\n 'prop': 8733,\n 'infin': 8734,\n 'ang': 8736,\n 'and': 8743,\n 'or': 8744,\n 'cap': 8745,\n 'cup': 8746,\n 'int': 8747,\n 'there4': 8756,\n 'sim': 8764,\n 'cong': 8773,\n 'asymp': 8776,\n 'ne': 8800,\n 'equiv': 8801,\n 'le': 8804,\n 'ge': 8805,\n 'sub': 8834,\n 'sup': 8835,\n 'nsub': 8836,\n 'sube': 8838,\n 'supe': 8839,\n 'oplus': 8853,\n 'otimes': 8855,\n 'perp': 8869,\n 'sdot': 8901,\n 'lceil': 8968,\n 'rceil': 8969,\n 'lfloor': 8970,\n 'rfloor': 8971,\n 'lang': 9001,\n 'rang': 9002,\n 'loz': 9674,\n 'spades': 9824,\n 'clubs': 9827,\n 'hearts': 9829,\n 'diams': 9830\n }\n\n Object.keys(sax.ENTITIES).forEach(function (key) {\n var e = sax.ENTITIES[key]\n var s = typeof e === 'number' ? String.fromCharCode(e) : e\n sax.ENTITIES[key] = s\n })\n\n for (var s in sax.STATE) {\n sax.STATE[sax.STATE[s]] = s\n }\n\n // shorthand\n S = sax.STATE\n\n function emit (parser, event, data) {\n parser[event] && parser[event](data)\n }\n\n function emitNode (parser, nodeType, data) {\n if (parser.textNode) closeText(parser)\n emit(parser, nodeType, data)\n }\n\n function closeText (parser) {\n parser.textNode = textopts(parser.opt, parser.textNode)\n if (parser.textNode) emit(parser, 'ontext', parser.textNode)\n parser.textNode = ''\n }\n\n function textopts (opt, text) {\n if (opt.trim) text = text.trim()\n if (opt.normalize) text = text.replace(/\\s+/g, ' ')\n return text\n }\n\n function error (parser, er) {\n closeText(parser)\n if (parser.trackPosition) {\n er += '\\nLine: ' + parser.line +\n '\\nColumn: ' + parser.column +\n '\\nChar: ' + parser.c\n }\n er = new Error(er)\n parser.error = er\n emit(parser, 'onerror', er)\n return parser\n }\n\n function end (parser) {\n if (parser.sawRoot && !parser.closedRoot) strictFail(parser, 'Unclosed root tag')\n if ((parser.state !== S.BEGIN) &&\n (parser.state !== S.BEGIN_WHITESPACE) &&\n (parser.state !== S.TEXT)) {\n error(parser, 'Unexpected end')\n }\n closeText(parser)\n parser.c = ''\n parser.closed = true\n emit(parser, 'onend')\n SAXParser.call(parser, parser.strict, parser.opt)\n return parser\n }\n\n function strictFail (parser, message) {\n if (typeof parser !== 'object' || !(parser instanceof SAXParser)) {\n throw new Error('bad call to strictFail')\n }\n if (parser.strict) {\n error(parser, message)\n }\n }\n\n function newTag (parser) {\n if (!parser.strict) parser.tagName = parser.tagName[parser.looseCase]()\n var parent = parser.tags[parser.tags.length - 1] || parser\n var tag = parser.tag = { name: parser.tagName, attributes: {} }\n\n // will be overridden if tag contails an xmlns=\"foo\" or xmlns:foo=\"bar\"\n if (parser.opt.xmlns) {\n tag.ns = parent.ns\n }\n parser.attribList.length = 0\n emitNode(parser, 'onopentagstart', tag)\n }\n\n function qname (name, attribute) {\n var i = name.indexOf(':')\n var qualName = i < 0 ? [ '', name ] : name.split(':')\n var prefix = qualName[0]\n var local = qualName[1]\n\n // <x \"xmlns\"=\"http://foo\">\n if (attribute && name === 'xmlns') {\n prefix = 'xmlns'\n local = ''\n }\n\n return { prefix: prefix, local: local }\n }\n\n function attrib (parser) {\n if (!parser.strict) {\n parser.attribName = parser.attribName[parser.looseCase]()\n }\n\n if (parser.attribList.indexOf(parser.attribName) !== -1 ||\n parser.tag.attributes.hasOwnProperty(parser.attribName)) {\n parser.attribName = parser.attribValue = ''\n return\n }\n\n if (parser.opt.xmlns) {\n var qn = qname(parser.attribName, true)\n var prefix = qn.prefix\n var local = qn.local\n\n if (prefix === 'xmlns') {\n // namespace binding attribute. push the binding into scope\n if (local === 'xml' && parser.attribValue !== XML_NAMESPACE) {\n strictFail(parser,\n 'xml: prefix must be bound to ' + XML_NAMESPACE + '\\n' +\n 'Actual: ' + parser.attribValue)\n } else if (local === 'xmlns' && parser.attribValue !== XMLNS_NAMESPACE) {\n strictFail(parser,\n 'xmlns: prefix must be bound to ' + XMLNS_NAMESPACE + '\\n' +\n 'Actual: ' + parser.attribValue)\n } else {\n var tag = parser.tag\n var parent = parser.tags[parser.tags.length - 1] || parser\n if (tag.ns === parent.ns) {\n tag.ns = Object.create(parent.ns)\n }\n tag.ns[local] = parser.attribValue\n }\n }\n\n // defer onattribute events until all attributes have been seen\n // so any new bindings can take effect. preserve attribute order\n // so deferred events can be emitted in document order\n parser.attribList.push([parser.attribName, parser.attribValue])\n } else {\n // in non-xmlns mode, we can emit the event right away\n parser.tag.attributes[parser.attribName] = parser.attribValue\n emitNode(parser, 'onattribute', {\n name: parser.attribName,\n value: parser.attribValue\n })\n }\n\n parser.attribName = parser.attribValue = ''\n }\n\n function openTag (parser, selfClosing) {\n if (parser.opt.xmlns) {\n // emit namespace binding events\n var tag = parser.tag\n\n // add namespace info to tag\n var qn = qname(parser.tagName)\n tag.prefix = qn.prefix\n tag.local = qn.local\n tag.uri = tag.ns[qn.prefix] || ''\n\n if (tag.prefix && !tag.uri) {\n strictFail(parser, 'Unbound namespace prefix: ' +\n JSON.stringify(parser.tagName))\n tag.uri = qn.prefix\n }\n\n var parent = parser.tags[parser.tags.length - 1] || parser\n if (tag.ns && parent.ns !== tag.ns) {\n Object.keys(tag.ns).forEach(function (p) {\n emitNode(parser, 'onopennamespace', {\n prefix: p,\n uri: tag.ns[p]\n })\n })\n }\n\n // handle deferred onattribute events\n // Note: do not apply default ns to attributes:\n // http://www.w3.org/TR/REC-xml-names/#defaulting\n for (var i = 0, l = parser.attribList.length; i < l; i++) {\n var nv = parser.attribList[i]\n var name = nv[0]\n var value = nv[1]\n var qualName = qname(name, true)\n var prefix = qualName.prefix\n var local = qualName.local\n var uri = prefix === '' ? '' : (tag.ns[prefix] || '')\n var a = {\n name: name,\n value: value,\n prefix: prefix,\n local: local,\n uri: uri\n }\n\n // if there's any attributes with an undefined namespace,\n // then fail on them now.\n if (prefix && prefix !== 'xmlns' && !uri) {\n strictFail(parser, 'Unbound namespace prefix: ' +\n JSON.stringify(prefix))\n a.uri = prefix\n }\n parser.tag.attributes[name] = a\n emitNode(parser, 'onattribute', a)\n }\n parser.attribList.length = 0\n }\n\n parser.tag.isSelfClosing = !!selfClosing\n\n // process the tag\n parser.sawRoot = true\n parser.tags.push(parser.tag)\n emitNode(parser, 'onopentag', parser.tag)\n if (!selfClosing) {\n // special case for <script> in non-strict mode.\n if (!parser.noscript && parser.tagName.toLowerCase() === 'script') {\n parser.state = S.SCRIPT\n } else {\n parser.state = S.TEXT\n }\n parser.tag = null\n parser.tagName = ''\n }\n parser.attribName = parser.attribValue = ''\n parser.attribList.length = 0\n }\n\n function closeTag (parser) {\n if (!parser.tagName) {\n strictFail(parser, 'Weird empty close tag.')\n parser.textNode += '</>'\n parser.state = S.TEXT\n return\n }\n\n if (parser.script) {\n if (parser.tagName !== 'script') {\n parser.script += '</' + parser.tagName + '>'\n parser.tagName = ''\n parser.state = S.SCRIPT\n return\n }\n emitNode(parser, 'onscript', parser.script)\n parser.script = ''\n }\n\n // first make sure that the closing tag actually exists.\n // <a><b></c></b></a> will close everything, otherwise.\n var t = parser.tags.length\n var tagName = parser.tagName\n if (!parser.strict) {\n tagName = tagName[parser.looseCase]()\n }\n var closeTo = tagName\n while (t--) {\n var close = parser.tags[t]\n if (close.name !== closeTo) {\n // fail the first time in strict mode\n strictFail(parser, 'Unexpected close tag')\n } else {\n break\n }\n }\n\n // didn't find it. we already failed for strict, so just abort.\n if (t < 0) {\n strictFail(parser, 'Unmatched closing tag: ' + parser.tagName)\n parser.textNode += '</' + parser.tagName + '>'\n parser.state = S.TEXT\n return\n }\n parser.tagName = tagName\n var s = parser.tags.length\n while (s-- > t) {\n var tag = parser.tag = parser.tags.pop()\n parser.tagName = parser.tag.name\n emitNode(parser, 'onclosetag', parser.tagName)\n\n var x = {}\n for (var i in tag.ns) {\n x[i] = tag.ns[i]\n }\n\n var parent = parser.tags[parser.tags.length - 1] || parser\n if (parser.opt.xmlns && tag.ns !== parent.ns) {\n // remove namespace bindings introduced by tag\n Object.keys(tag.ns).forEach(function (p) {\n var n = tag.ns[p]\n emitNode(parser, 'onclosenamespace', { prefix: p, uri: n })\n })\n }\n }\n if (t === 0) parser.closedRoot = true\n parser.tagName = parser.attribValue = parser.attribName = ''\n parser.attribList.length = 0\n parser.state = S.TEXT\n }\n\n function parseEntity (parser) {\n var entity = parser.entity\n var entityLC = entity.toLowerCase()\n var num\n var numStr = ''\n\n if (parser.ENTITIES[entity]) {\n return parser.ENTITIES[entity]\n }\n if (parser.ENTITIES[entityLC]) {\n return parser.ENTITIES[entityLC]\n }\n entity = entityLC\n if (entity.charAt(0) === '#') {\n if (entity.charAt(1) === 'x') {\n entity = entity.slice(2)\n num = parseInt(entity, 16)\n numStr = num.toString(16)\n } else {\n entity = entity.slice(1)\n num = parseInt(entity, 10)\n numStr = num.toString(10)\n }\n }\n entity = entity.replace(/^0+/, '')\n if (isNaN(num) || numStr.toLowerCase() !== entity) {\n strictFail(parser, 'Invalid character entity')\n return '&' + parser.entity + ';'\n }\n\n return String.fromCodePoint(num)\n }\n\n function beginWhiteSpace (parser, c) {\n if (c === '<') {\n parser.state = S.OPEN_WAKA\n parser.startTagPosition = parser.position\n } else if (!isWhitespace(c)) {\n // have to process this as a text node.\n // weird, but happens.\n strictFail(parser, 'Non-whitespace before first tag.')\n parser.textNode = c\n parser.state = S.TEXT\n }\n }\n\n function charAt (chunk, i) {\n var result = ''\n if (i < chunk.length) {\n result = chunk.charAt(i)\n }\n return result\n }\n\n function write (chunk) {\n var parser = this\n if (this.error) {\n throw this.error\n }\n if (parser.closed) {\n return error(parser,\n 'Cannot write after close. Assign an onready handler.')\n }\n if (chunk === null) {\n return end(parser)\n }\n if (typeof chunk === 'object') {\n chunk = chunk.toString()\n }\n var i = 0\n var c = ''\n while (true) {\n c = charAt(chunk, i++)\n parser.c = c\n\n if (!c) {\n break\n }\n\n if (parser.trackPosition) {\n parser.position++\n if (c === '\\n') {\n parser.line++\n parser.column = 0\n } else {\n parser.column++\n }\n }\n\n switch (parser.state) {\n case S.BEGIN:\n parser.state = S.BEGIN_WHITESPACE\n if (c === '\\uFEFF') {\n continue\n }\n beginWhiteSpace(parser, c)\n continue\n\n case S.BEGIN_WHITESPACE:\n beginWhiteSpace(parser, c)\n continue\n\n case S.TEXT:\n if (parser.sawRoot && !parser.closedRoot) {\n var starti = i - 1\n while (c && c !== '<' && c !== '&') {\n c = charAt(chunk, i++)\n if (c && parser.trackPosition) {\n parser.position++\n if (c === '\\n') {\n parser.line++\n parser.column = 0\n } else {\n parser.column++\n }\n }\n }\n parser.textNode += chunk.substring(starti, i - 1)\n }\n if (c === '<' && !(parser.sawRoot && parser.closedRoot && !parser.strict)) {\n parser.state = S.OPEN_WAKA\n parser.startTagPosition = parser.position\n } else {\n if (!isWhitespace(c) && (!parser.sawRoot || parser.closedRoot)) {\n strictFail(parser, 'Text data outside of root node.')\n }\n if (c === '&') {\n parser.state = S.TEXT_ENTITY\n } else {\n parser.textNode += c\n }\n }\n continue\n\n case S.SCRIPT:\n // only non-strict\n if (c === '<') {\n parser.state = S.SCRIPT_ENDING\n } else {\n parser.script += c\n }\n continue\n\n case S.SCRIPT_ENDING:\n if (c === '/') {\n parser.state = S.CLOSE_TAG\n } else {\n parser.script += '<' + c\n parser.state = S.SCRIPT\n }\n continue\n\n case S.OPEN_WAKA:\n // either a /, ?, !, or text is coming next.\n if (c === '!') {\n parser.state = S.SGML_DECL\n parser.sgmlDecl = ''\n } else if (isWhitespace(c)) {\n // wait for it...\n } else if (isMatch(nameStart, c)) {\n parser.state = S.OPEN_TAG\n parser.tagName = c\n } else if (c === '/') {\n parser.state = S.CLOSE_TAG\n parser.tagName = ''\n } else if (c === '?') {\n parser.state = S.PROC_INST\n parser.procInstName = parser.procInstBody = ''\n } else {\n strictFail(parser, 'Unencoded <')\n // if there was some whitespace, then add that in.\n if (parser.startTagPosition + 1 < parser.position) {\n var pad = parser.position - parser.startTagPosition\n c = new Array(pad).join(' ') + c\n }\n parser.textNode += '<' + c\n parser.state = S.TEXT\n }\n continue\n\n case S.SGML_DECL:\n if (parser.sgmlDecl + c === '--') {\n parser.state = S.COMMENT\n parser.comment = ''\n parser.sgmlDecl = ''\n continue;\n }\n\n if (parser.doctype && parser.doctype !== true && parser.sgmlDecl) {\n parser.state = S.DOCTYPE_DTD\n parser.doctype += '<!' + parser.sgmlDecl + c\n parser.sgmlDecl = ''\n } else if ((parser.sgmlDecl + c).toUpperCase() === CDATA) {\n emitNode(parser, 'onopencdata')\n parser.state = S.CDATA\n parser.sgmlDecl = ''\n parser.cdata = ''\n } else if ((parser.sgmlDecl + c).toUpperCase() === DOCTYPE) {\n parser.state = S.DOCTYPE\n if (parser.doctype || parser.sawRoot) {\n strictFail(parser,\n 'Inappropriately located doctype declaration')\n }\n parser.doctype = ''\n parser.sgmlDecl = ''\n } else if (c === '>') {\n emitNode(parser, 'onsgmldeclaration', parser.sgmlDecl)\n parser.sgmlDecl = ''\n parser.state = S.TEXT\n } else if (isQuote(c)) {\n parser.state = S.SGML_DECL_QUOTED\n parser.sgmlDecl += c\n } else {\n parser.sgmlDecl += c\n }\n continue\n\n case S.SGML_DECL_QUOTED:\n if (c === parser.q) {\n parser.state = S.SGML_DECL\n parser.q = ''\n }\n parser.sgmlDecl += c\n continue\n\n case S.DOCTYPE:\n if (c === '>') {\n parser.state = S.TEXT\n emitNode(parser, 'ondoctype', parser.doctype)\n parser.doctype = true // just remember that we saw it.\n } else {\n parser.doctype += c\n if (c === '[') {\n parser.state = S.DOCTYPE_DTD\n } else if (isQuote(c)) {\n parser.state = S.DOCTYPE_QUOTED\n parser.q = c\n }\n }\n continue\n\n case S.DOCTYPE_QUOTED:\n parser.doctype += c\n if (c === parser.q) {\n parser.q = ''\n parser.state = S.DOCTYPE\n }\n continue\n\n case S.DOCTYPE_DTD:\n if (c === ']') {\n parser.doctype += c\n parser.state = S.DOCTYPE\n } else if (c === '<') {\n parser.state = S.OPEN_WAKA\n parser.startTagPosition = parser.position\n } else if (isQuote(c)) {\n parser.doctype += c\n parser.state = S.DOCTYPE_DTD_QUOTED\n parser.q = c\n } else {\n parser.doctype += c\n }\n continue\n\n case S.DOCTYPE_DTD_QUOTED:\n parser.doctype += c\n if (c === parser.q) {\n parser.state = S.DOCTYPE_DTD\n parser.q = ''\n }\n continue\n\n case S.COMMENT:\n if (c === '-') {\n parser.state = S.COMMENT_ENDING\n } else {\n parser.comment += c\n }\n continue\n\n case S.COMMENT_ENDING:\n if (c === '-') {\n parser.state = S.COMMENT_ENDED\n parser.comment = textopts(parser.opt, parser.comment)\n if (parser.comment) {\n emitNode(parser, 'oncomment', parser.comment)\n }\n parser.comment = ''\n } else {\n parser.comment += '-' + c\n parser.state = S.COMMENT\n }\n continue\n\n case S.COMMENT_ENDED:\n if (c !== '>') {\n strictFail(parser, 'Malformed comment')\n // allow <!-- blah -- bloo --> in non-strict mode,\n // which is a comment of \" blah -- bloo \"\n parser.comment += '--' + c\n parser.state = S.COMMENT\n } else if (parser.doctype && parser.doctype !== true) {\n parser.state = S.DOCTYPE_DTD\n } else {\n parser.state = S.TEXT\n }\n continue\n\n case S.CDATA:\n if (c === ']') {\n parser.state = S.CDATA_ENDING\n } else {\n parser.cdata += c\n }\n continue\n\n case S.CDATA_ENDING:\n if (c === ']') {\n parser.state = S.CDATA_ENDING_2\n } else {\n parser.cdata += ']' + c\n parser.state = S.CDATA\n }\n continue\n\n case S.CDATA_ENDING_2:\n if (c === '>') {\n if (parser.cdata) {\n emitNode(parser, 'oncdata', parser.cdata)\n }\n emitNode(parser, 'onclosecdata')\n parser.cdata = ''\n parser.state = S.TEXT\n } else if (c === ']') {\n parser.cdata += ']'\n } else {\n parser.cdata += ']]' + c\n parser.state = S.CDATA\n }\n continue\n\n case S.PROC_INST:\n if (c === '?') {\n parser.state = S.PROC_INST_ENDING\n } else if (isWhitespace(c)) {\n parser.state = S.PROC_INST_BODY\n } else {\n parser.procInstName += c\n }\n continue\n\n case S.PROC_INST_BODY:\n if (!parser.procInstBody && isWhitespace(c)) {\n continue\n } else if (c === '?') {\n parser.state = S.PROC_INST_ENDING\n } else {\n parser.procInstBody += c\n }\n continue\n\n case S.PROC_INST_ENDING:\n if (c === '>') {\n emitNode(parser, 'onprocessinginstruction', {\n name: parser.procInstName,\n body: parser.procInstBody\n })\n parser.procInstName = parser.procInstBody = ''\n parser.state = S.TEXT\n } else {\n parser.procInstBody += '?' + c\n parser.state = S.PROC_INST_BODY\n }\n continue\n\n case S.OPEN_TAG:\n if (isMatch(nameBody, c)) {\n parser.tagName += c\n } else {\n newTag(parser)\n if (c === '>') {\n openTag(parser)\n } else if (c === '/') {\n parser.state = S.OPEN_TAG_SLASH\n } else {\n if (!isWhitespace(c)) {\n strictFail(parser, 'Invalid character in tag name')\n }\n parser.state = S.ATTRIB\n }\n }\n continue\n\n case S.OPEN_TAG_SLASH:\n if (c === '>') {\n openTag(parser, true)\n closeTag(parser)\n } else {\n strictFail(parser, 'Forward-slash in opening tag not followed by >')\n parser.state = S.ATTRIB\n }\n continue\n\n case S.ATTRIB:\n // haven't read the attribute name yet.\n if (isWhitespace(c)) {\n continue\n } else if (c === '>') {\n openTag(parser)\n } else if (c === '/') {\n parser.state = S.OPEN_TAG_SLASH\n } else if (isMatch(nameStart, c)) {\n parser.attribName = c\n parser.attribValue = ''\n parser.state = S.ATTRIB_NAME\n } else {\n strictFail(parser, 'Invalid attribute name')\n }\n continue\n\n case S.ATTRIB_NAME:\n if (c === '=') {\n parser.state = S.ATTRIB_VALUE\n } else if (c === '>') {\n strictFail(parser, 'Attribute without value')\n parser.attribValue = parser.attribName\n attrib(parser)\n openTag(parser)\n } else if (isWhitespace(c)) {\n parser.state = S.ATTRIB_NAME_SAW_WHITE\n } else if (isMatch(nameBody, c)) {\n parser.attribName += c\n } else {\n strictFail(parser, 'Invalid attribute name')\n }\n continue\n\n case S.ATTRIB_NAME_SAW_WHITE:\n if (c === '=') {\n parser.state = S.ATTRIB_VALUE\n } else if (isWhitespace(c)) {\n continue\n } else {\n strictFail(parser, 'Attribute without value')\n parser.tag.attributes[parser.attribName] = ''\n parser.attribValue = ''\n emitNode(parser, 'onattribute', {\n name: parser.attribName,\n value: ''\n })\n parser.attribName = ''\n if (c === '>') {\n openTag(parser)\n } else if (isMatch(nameStart, c)) {\n parser.attribName = c\n parser.state = S.ATTRIB_NAME\n } else {\n strictFail(parser, 'Invalid attribute name')\n parser.state = S.ATTRIB\n }\n }\n continue\n\n case S.ATTRIB_VALUE:\n if (isWhitespace(c)) {\n continue\n } else if (isQuote(c)) {\n parser.q = c\n parser.state = S.ATTRIB_VALUE_QUOTED\n } else {\n if (!parser.opt.unquotedAttributeValues) {\n error(parser, 'Unquoted attribute value')\n }\n parser.state = S.ATTRIB_VALUE_UNQUOTED\n parser.attribValue = c\n }\n continue\n\n case S.ATTRIB_VALUE_QUOTED:\n if (c !== parser.q) {\n if (c === '&') {\n parser.state = S.ATTRIB_VALUE_ENTITY_Q\n } else {\n parser.attribValue += c\n }\n continue\n }\n attrib(parser)\n parser.q = ''\n parser.state = S.ATTRIB_VALUE_CLOSED\n continue\n\n case S.ATTRIB_VALUE_CLOSED:\n if (isWhitespace(c)) {\n parser.state = S.ATTRIB\n } else if (c === '>') {\n openTag(parser)\n } else if (c === '/') {\n parser.state = S.OPEN_TAG_SLASH\n } else if (isMatch(nameStart, c)) {\n strictFail(parser, 'No whitespace between attributes')\n parser.attribName = c\n parser.attribValue = ''\n parser.state = S.ATTRIB_NAME\n } else {\n strictFail(parser, 'Invalid attribute name')\n }\n continue\n\n case S.ATTRIB_VALUE_UNQUOTED:\n if (!isAttribEnd(c)) {\n if (c === '&') {\n parser.state = S.ATTRIB_VALUE_ENTITY_U\n } else {\n parser.attribValue += c\n }\n continue\n }\n attrib(parser)\n if (c === '>') {\n openTag(parser)\n } else {\n parser.state = S.ATTRIB\n }\n continue\n\n case S.CLOSE_TAG:\n if (!parser.tagName) {\n if (isWhitespace(c)) {\n continue\n } else if (notMatch(nameStart, c)) {\n if (parser.script) {\n parser.script += '</' + c\n parser.state = S.SCRIPT\n } else {\n strictFail(parser, 'Invalid tagname in closing tag.')\n }\n } else {\n parser.tagName = c\n }\n } else if (c === '>') {\n closeTag(parser)\n } else if (isMatch(nameBody, c)) {\n parser.tagName += c\n } else if (parser.script) {\n parser.script += '</' + parser.tagName\n parser.tagName = ''\n parser.state = S.SCRIPT\n } else {\n if (!isWhitespace(c)) {\n strictFail(parser, 'Invalid tagname in closing tag')\n }\n parser.state = S.CLOSE_TAG_SAW_WHITE\n }\n continue\n\n case S.CLOSE_TAG_SAW_WHITE:\n if (isWhitespace(c)) {\n continue\n }\n if (c === '>') {\n closeTag(parser)\n } else {\n strictFail(parser, 'Invalid characters in closing tag')\n }\n continue\n\n case S.TEXT_ENTITY:\n case S.ATTRIB_VALUE_ENTITY_Q:\n case S.ATTRIB_VALUE_ENTITY_U:\n var returnState\n var buffer\n switch (parser.state) {\n case S.TEXT_ENTITY:\n returnState = S.TEXT\n buffer = 'textNode'\n break\n\n case S.ATTRIB_VALUE_ENTITY_Q:\n returnState = S.ATTRIB_VALUE_QUOTED\n buffer = 'attribValue'\n break\n\n case S.ATTRIB_VALUE_ENTITY_U:\n returnState = S.ATTRIB_VALUE_UNQUOTED\n buffer = 'attribValue'\n break\n }\n\n if (c === ';') {\n var parsedEntity = parseEntity(parser)\n if (parser.opt.unparsedEntities && !Object.values(sax.XML_ENTITIES).includes(parsedEntity)) {\n parser.entity = ''\n parser.state = returnState\n parser.write(parsedEntity)\n } else {\n parser[buffer] += parsedEntity\n parser.entity = ''\n parser.state = returnState\n }\n } else if (isMatch(parser.entity.length ? entityBody : entityStart, c)) {\n parser.entity += c\n } else {\n strictFail(parser, 'Invalid character in entity name')\n parser[buffer] += '&' + parser.entity + c\n parser.entity = ''\n parser.state = returnState\n }\n\n continue\n\n default: /* istanbul ignore next */ {\n throw new Error(parser, 'Unknown state: ' + parser.state)\n }\n }\n } // while\n\n if (parser.position >= parser.bufferCheckPosition) {\n checkBufferLength(parser)\n }\n return parser\n }\n\n /*! http://mths.be/fromcodepoint v0.1.0 by @mathias */\n /* istanbul ignore next */\n if (!String.fromCodePoint) {\n (function () {\n var stringFromCharCode = String.fromCharCode\n var floor = Math.floor\n var fromCodePoint = function () {\n var MAX_SIZE = 0x4000\n var codeUnits = []\n var highSurrogate\n var lowSurrogate\n var index = -1\n var length = arguments.length\n if (!length) {\n return ''\n }\n var result = ''\n while (++index < length) {\n var codePoint = Number(arguments[index])\n if (\n !isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity`\n codePoint < 0 || // not a valid Unicode code point\n codePoint > 0x10FFFF || // not a valid Unicode code point\n floor(codePoint) !== codePoint // not an integer\n ) {\n throw RangeError('Invalid code point: ' + codePoint)\n }\n if (codePoint <= 0xFFFF) { // BMP code point\n codeUnits.push(codePoint)\n } else { // Astral code point; split in surrogate halves\n // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae\n codePoint -= 0x10000\n highSurrogate = (codePoint >> 10) + 0xD800\n lowSurrogate = (codePoint % 0x400) + 0xDC00\n codeUnits.push(highSurrogate, lowSurrogate)\n }\n if (index + 1 === length || codeUnits.length > MAX_SIZE) {\n result += stringFromCharCode.apply(null, codeUnits)\n codeUnits.length = 0\n }\n }\n return result\n }\n /* istanbul ignore next */\n if (Object.defineProperty) {\n Object.defineProperty(String, 'fromCodePoint', {\n value: fromCodePoint,\n configurable: true,\n writable: true\n })\n } else {\n String.fromCodePoint = fromCodePoint\n }\n }())\n }\n})(typeof exports === 'undefined' ? this.sax = {} : exports)\n","import sax from 'sax';\nfunction startsWith(array, prefix) {\n if (prefix.length > array.length) {\n return false;\n }\n for (let i = 0; i < prefix.length; i++) {\n if (array[i] !== prefix[i]) {\n return false;\n }\n }\n return true;\n}\nfunction hasXmlTag(xmlString) {\n return /^<\\s*\\w+(?=\\s+[^<>]*=|>)/.test(xmlString);\n}\nfunction hasArrayXmlTag(array, encoding) {\n const textDecoder = new TextDecoder(encoding);\n return hasXmlTag(textDecoder.decode(array));\n}\nexport function isXml(array) {\n if (startsWith(array, [60, 63, 120, 109, 108, 32])) {\n return { xml: true, encoding: 'utf-8', offset: 0 };\n }\n if (startsWith(array, [0xEF, 0xBB, 0xBF])) { // UTF-8 BOM\n const encoding = 'utf-8';\n if (startsWith(array.subarray(3), [60, 63, 120, 109, 108, 32]) || hasArrayXmlTag(array, encoding)) {\n return { xml: true, encoding, offset: 3 };\n }\n }\n if (startsWith(array, [0xFE, 0xFF])) {\n const encoding = 'utf-16be';\n if (startsWith(array.subarray(2), [0, 60, 0, 63, 0, 120, 0, 109, 0, 108, 0, 32]) || hasArrayXmlTag(array, encoding)) {\n return { xml: true, encoding, offset: 2 };\n }\n }\n if (startsWith(array, [0xFF, 0xFE])) {\n const encoding = 'utf-16le';\n if (startsWith(array.subarray(2), [60, 0, 63, 0, 120, 0, 109, 0, 108, 0, 32, 0]) || hasArrayXmlTag(array, encoding)) {\n return { xml: true, encoding, offset: 2 };\n }\n return { xml: true, encoding: 'utf-16le', offset: 2 };\n }\n if (startsWith(array, [0, 60, 0, 63, 0, 120, 0, 109, 0, 108, 0, 32])) {\n return { xml: true, encoding: 'utf-16be', offset: 0 };\n }\n if (startsWith(array, [60, 0, 63, 0, 120, 0, 109, 0, 108, 0, 32, 0])) {\n return { xml: true, encoding: 'utf-16le', offset: 0 };\n }\n if (hasArrayXmlTag(array, 'utf-8')) {\n return { xml: true, encoding: 'utf-8', offset: 0 };\n }\n return { xml: false };\n}\n/**\n * Maps the root element namespace to corresponding file-type\n */\nconst namespaceMapping = {\n 'http://www.w3.org/2000/svg': {\n ext: 'svg',\n mime: 'image/svg+xml'\n },\n 'http://www.w3.org/1999/xhtml': {\n ext: 'xhtml',\n mime: 'application/xhtml+xml'\n },\n 'http://www.opengis.net/kml/2.2': {\n ext: 'kml',\n mime: 'application/vnd.google-earth.kml+xml'\n },\n 'http://www.opengis.net/gml': {\n ext: 'gml',\n mime: 'application/gml+xml'\n }\n};\n/**\n * Maps the root element name to corresponding file-type.\n * Used for Non-namespaced XML\n * @type {{rss: {ext: string, mime: string}}}\n */\nconst rootNameMapping = {\n rss: {\n ext: 'rss',\n mime: 'application/rss+xml'\n },\n 'score-partwise': {\n ext: 'musicxml',\n mime: 'application/vnd.recordare.musicxml+xml'\n },\n svg: {\n ext: 'svg',\n mime: 'image/svg+xml'\n }\n};\nexport class XmlTextDetector {\n constructor(options) {\n this.options = options ?? {};\n this.firstTag = true;\n this.onEnd = false;\n this.parser = sax.parser(true, { xmlns: true });\n this.nesting = 0;\n this.parser.onerror = e => {\n if (e.message.startsWith('Invalid character entity')) { // Allow entity reference\n return;\n }\n this.fileType = undefined;\n this.onEnd = true;\n };\n this.parser.onopentag = node => {\n ++this.nesting;\n if (!this.firstTag || this.onEnd) {\n return;\n }\n this.firstTag = false;\n if (node.uri) {\n // Resolve file-type boot root element namespace\n this.fileType = namespaceMapping[node.uri];\n }\n else if (node.name) {\n // Fall back on element name if there is no namespace\n this.fileType = rootNameMapping[node.name.toLowerCase()];\n }\n if (this.fileType && !this.options.fullScan) {\n this.onEnd = true;\n }\n };\n this.parser.onclosetag = () => {\n --this.nesting;\n };\n }\n write(text) {\n this.parser.write(text);\n }\n close() {\n this.parser.close();\n this.onEnd = true;\n }\n isValid() {\n return this.nesting === 0;\n }\n}\nexport const detectXml = {\n id: 'xml',\n detect: async (tokenizer) => {\n const buffer = new Uint8Array(512);\n // Increase sample size from 12 to 256.\n await tokenizer.peekBuffer(buffer, { length: 128, mayBeLess: true });\n const xmlDetection = isXml(buffer);\n if (xmlDetection.xml) {\n await tokenizer.ignore(xmlDetection.offset);\n const xmlTextDetector = new XmlTextDetector();\n const textDecoder = new TextDecoder(xmlDetection.encoding);\n do {\n const len = await tokenizer.readBuffer(buffer, { mayBeLess: true });\n const portion = buffer.subarray(0, len);\n const text = textDecoder.decode(portion);\n xmlTextDetector.write(text);\n if (len < buffer.length) {\n xmlTextDetector.close();\n }\n } while (!xmlTextDetector.onEnd);\n return xmlTextDetector.fileType ?? {\n ext: 'xml',\n mime: 'application/xml'\n };\n }\n }\n};\n","import {XmlTextDetector} from '@file-type/xml';\n\nexport default function isSvg(string, {validate = true} = {}) {\n\tif (typeof string !== 'string') {\n\t\tthrow new TypeError(`Expected a \\`string\\`, got \\`${typeof string}\\``);\n\t}\n\n\tstring = string.trim();\n\n\tif (string.length === 0) {\n\t\treturn false;\n\t}\n\n\tconst xmlTextDetector = new XmlTextDetector({fullScan: validate});\n\n\tif (validate) {\n\t\txmlTextDetector.write(string);\n\n\t\tif (!xmlTextDetector.isValid()) {\n\t\t\treturn false;\n\t\t}\n\t} else {\n\t\tconst chunkSize = 128;\n\n\t\tlet offset = 0;\n\t\twhile (string.length > offset && !xmlTextDetector.onEnd) {\n\t\t\txmlTextDetector.write(string.slice(offset, Math.min(offset + chunkSize, string.length)));\n\t\t\toffset += chunkSize;\n\t\t}\n\t}\n\n\treturn xmlTextDetector.fileType?.ext === 'svg';\n}\n","import { s as scopedGlobals, l as logger, F as FileType } from \"./chunks/folder-29HuacU_.mjs\";\nimport { a, b, N, c, P } from \"./chunks/folder-29HuacU_.mjs\";\nimport { TypedEventTarget } from \"typescript-event-target\";\nimport isSvg from \"is-svg\";\nimport { getCapabilities } from \"@nextcloud/capabilities\";\nimport { extname, basename } from \"@nextcloud/paths\";\nimport { getCanonicalLocale, getLanguage } from \"@nextcloud/l10n\";\nclass FilesRegistry extends TypedEventTarget {\n}\nfunction getRegistry() {\n scopedGlobals.registry ??= new FilesRegistry();\n return scopedGlobals.registry;\n}\nfunction getFilesRegistry() {\n return getRegistry();\n}\nconst DefaultType = Object.freeze({\n DEFAULT: \"default\",\n HIDDEN: \"hidden\"\n});\nfunction registerFileAction(action) {\n validateAction$1(action);\n scopedGlobals.fileActions ??= /* @__PURE__ */ new Map();\n if (scopedGlobals.fileActions.has(action.id)) {\n logger.error(`FileAction ${action.id} already registered`, { action });\n return;\n }\n scopedGlobals.fileActions.set(action.id, action);\n getRegistry().dispatchTypedEvent(\"register:action\", new CustomEvent(\"register:action\", { detail: action }));\n}\nfunction getFileActions() {\n if (scopedGlobals.fileActions) {\n return [...scopedGlobals.fileActions.values()];\n }\n return [];\n}\nfunction validateAction$1(action) {\n if (!action.id || typeof action.id !== \"string\") {\n throw new Error(\"Invalid id\");\n }\n if (!action.displayName || typeof action.displayName !== \"function\") {\n throw new Error(\"Invalid displayName function\");\n }\n if (\"title\" in action && typeof action.title !== \"function\") {\n throw new Error(\"Invalid title function\");\n }\n if (!action.iconSvgInline || typeof action.iconSvgInline !== \"function\") {\n throw new Error(\"Invalid iconSvgInline function\");\n }\n if (!action.exec || typeof action.exec !== \"function\") {\n throw new Error(\"Invalid exec function\");\n }\n if (\"enabled\" in action && typeof action.enabled !== \"function\") {\n throw new Error(\"Invalid enabled function\");\n }\n if (\"execBatch\" in action && typeof action.execBatch !== \"function\") {\n throw new Error(\"Invalid execBatch function\");\n }\n if (\"order\" in action && typeof action.order !== \"number\") {\n throw new Error(\"Invalid order\");\n }\n if (action.destructive !== void 0 && typeof action.destructive !== \"boolean\") {\n throw new Error(\"Invalid destructive flag\");\n }\n if (\"parent\" in action && typeof action.parent !== \"string\") {\n throw new Error(\"Invalid parent\");\n }\n if (action.default && !Object.values(DefaultType).includes(action.default)) {\n throw new Error(\"Invalid default\");\n }\n if (\"inline\" in action && typeof action.inline !== \"function\") {\n throw new Error(\"Invalid inline function\");\n }\n if (\"renderInline\" in action && typeof action.renderInline !== \"function\") {\n throw new Error(\"Invalid renderInline function\");\n }\n if (\"hotkey\" in action && action.hotkey !== void 0) {\n if (typeof action.hotkey !== \"object\") {\n throw new Error(\"Invalid hotkey configuration\");\n }\n if (typeof action.hotkey.key !== \"string\" || !action.hotkey.key) {\n throw new Error(\"Missing or invalid hotkey key\");\n }\n if (typeof action.hotkey.description !== \"string\" || !action.hotkey.description) {\n throw new Error(\"Missing or invalid hotkey description\");\n }\n }\n}\nfunction registerFileListAction(action) {\n validateAction(action);\n scopedGlobals.fileListActions ??= /* @__PURE__ */ new Map();\n if (scopedGlobals.fileListActions.has(action.id)) {\n logger.error(`FileListAction with id \"${action.id}\" is already registered`, { action });\n return;\n }\n scopedGlobals.fileListActions.set(action.id, action);\n getRegistry().dispatchTypedEvent(\"register:listAction\", new CustomEvent(\"register:listAction\", { detail: action }));\n}\nfunction getFileListActions() {\n if (scopedGlobals.fileListActions) {\n return [...scopedGlobals.fileListActions.values()];\n }\n return [];\n}\nfunction validateAction(action) {\n if (!action.id || typeof action.id !== \"string\") {\n throw new Error(\"Invalid id\");\n }\n if (!action.displayName || typeof action.displayName !== \"function\") {\n throw new Error(\"Invalid displayName function\");\n }\n if (\"iconSvgInline\" in action && typeof action.iconSvgInline !== \"function\") {\n throw new Error(\"Invalid iconSvgInline function\");\n }\n if (\"order\" in action && typeof action.order !== \"number\") {\n throw new Error(\"Invalid order\");\n }\n if (\"enabled\" in action && typeof action.enabled !== \"function\") {\n throw new Error(\"Invalid enabled function\");\n }\n if (!action.exec || typeof action.exec !== \"function\") {\n throw new Error(\"Invalid exec function\");\n }\n}\n/*!\n * SPDX-FileCopyrightText: 2023 Nextcloud GmbH and Nextcloud contributors\n * SPDX-License-Identifier: AGPL-3.0-or-later\n */\nfunction registerFileListFilter(filter) {\n scopedGlobals.fileListFilters ??= /* @__PURE__ */ new Map();\n if (scopedGlobals.fileListFilters.has(filter.id)) {\n throw new Error(`File list filter \"${filter.id}\" already registered`);\n }\n scopedGlobals.fileListFilters.set(filter.id, filter);\n getRegistry().dispatchTypedEvent(\"register:listFilter\", new CustomEvent(\"register:listFilter\", { detail: filter }));\n}\nfunction unregisterFileListFilter(filterId) {\n if (scopedGlobals.fileListFilters && scopedGlobals.fileListFilters.has(filterId)) {\n scopedGlobals.fileListFilters.delete(filterId);\n getRegistry().dispatchTypedEvent(\"unregister:listFilter\", new CustomEvent(\"unregister:listFilter\", { detail: filterId }));\n }\n}\nfunction getFileListFilters() {\n if (scopedGlobals.fileListFilters) {\n return [...scopedGlobals.fileListFilters.values()];\n }\n return [];\n}\n/*!\n * SPDX-FileCopyrightText: 2023 Nextcloud GmbH and Nextcloud contributors\n * SPDX-License-Identifier: AGPL-3.0-or-later\n */\nclass FileListFilter extends TypedEventTarget {\n id;\n order;\n constructor(id, order = 100) {\n super();\n this.id = id;\n this.order = order;\n }\n filter(nodes) {\n throw new Error(\"Not implemented\");\n }\n updateChips(chips) {\n this.dispatchTypedEvent(\"update:chips\", new CustomEvent(\"update:chips\", { detail: chips }));\n }\n filterUpdated() {\n this.dispatchTypedEvent(\"update:filter\", new CustomEvent(\"update:filter\"));\n }\n}\nfunction registerFileListHeader(header) {\n validateHeader(header);\n scopedGlobals.fileListHeaders ??= /* @__PURE__ */ new Map();\n if (scopedGlobals.fileListHeaders.has(header.id)) {\n logger.error(`Header ${header.id} already registered`, { header });\n return;\n }\n scopedGlobals.fileListHeaders.set(header.id, header);\n getRegistry().dispatchTypedEvent(\"register:listHeader\", new CustomEvent(\"register:listHeader\", { detail: header }));\n}\nfunction getFileListHeaders() {\n if (!scopedGlobals.fileListHeaders) {\n return [];\n }\n return [...scopedGlobals.fileListHeaders.values()];\n}\nfunction validateHeader(header) {\n if (!header.id || !header.render || !header.updated) {\n throw new Error(\"Invalid header: id, render and updated are required\");\n }\n if (typeof header.id !== \"string\") {\n throw new Error(\"Invalid id property\");\n }\n if (header.enabled !== void 0 && typeof header.enabled !== \"function\") {\n throw new Error(\"Invalid enabled property\");\n }\n if (header.render && typeof header.render !== \"function\") {\n throw new Error(\"Invalid render property\");\n }\n if (header.updated && typeof header.updated !== \"function\") {\n throw new Error(\"Invalid updated property\");\n }\n}\nfunction checkOptionalProperty(obj, property, type) {\n if (typeof obj[property] !== \"undefined\") {\n if (type === \"array\") {\n if (!Array.isArray(obj[property])) {\n throw new Error(`View ${property} must be an array`);\n }\n } else if (typeof obj[property] !== type) {\n throw new Error(`View ${property} must be a ${type}`);\n } else if (type === \"object\" && (obj[property] === null || Array.isArray(obj[property]))) {\n throw new Error(`View ${property} must be an object`);\n }\n }\n}\nclass Column {\n _column;\n constructor(column) {\n validateColumn(column);\n this._column = column;\n }\n get id() {\n return this._column.id;\n }\n get title() {\n return this._column.title;\n }\n get render() {\n return this._column.render;\n }\n get sort() {\n return this._column.sort;\n }\n get summary() {\n return this._column.summary;\n }\n}\nfunction validateColumn(column) {\n if (typeof column !== \"object\" || column === null) {\n throw new Error(\"View column must be an object\");\n }\n if (!column.id || typeof column.id !== \"string\") {\n throw new Error(\"A column id is required\");\n }\n if (!column.title || typeof column.title !== \"string\") {\n throw new Error(\"A column title is required\");\n }\n if (!column.render || typeof column.render !== \"function\") {\n throw new Error(\"A render function is required\");\n }\n checkOptionalProperty(column, \"sort\", \"function\");\n checkOptionalProperty(column, \"summary\", \"function\");\n}\nclass View {\n _view;\n constructor(view) {\n validateView(view);\n this._view = view;\n }\n get id() {\n return this._view.id;\n }\n get name() {\n return this._view.name;\n }\n get caption() {\n return this._view.caption;\n }\n get emptyTitle() {\n return this._view.emptyTitle;\n }\n get emptyCaption() {\n return this._view.emptyCaption;\n }\n get getContents() {\n return this._view.getContents;\n }\n get hidden() {\n return this._view.hidden;\n }\n get icon() {\n return this._view.icon;\n }\n set icon(icon) {\n this._view.icon = icon;\n }\n get order() {\n return this._view.order;\n }\n set order(order) {\n this._view.order = order;\n }\n get params() {\n return this._view.params;\n }\n set params(params) {\n this._view.params = params;\n }\n get columns() {\n return this._view.columns;\n }\n get emptyView() {\n return this._view.emptyView;\n }\n get parent() {\n return this._view.parent;\n }\n get sticky() {\n return this._view.sticky;\n }\n get expanded() {\n return this._view.expanded;\n }\n set expanded(expanded) {\n this._view.expanded = expanded;\n }\n get defaultSortKey() {\n return this._view.defaultSortKey;\n }\n get loadChildViews() {\n return this._view.loadChildViews;\n }\n}\nfunction validateView(view) {\n if (!view.icon || typeof view.icon !== \"string\" || !isSvg(view.icon)) {\n throw new Error(\"View icon is required and must be a valid svg string\");\n }\n if (!view.id || typeof view.id !== \"string\") {\n throw new Error(\"View id is required and must be a string\");\n }\n if (!view.getContents || typeof view.getContents !== \"function\") {\n throw new Error(\"View getContents is required and must be a function\");\n }\n if (!view.name || typeof view.name !== \"string\") {\n throw new Error(\"View name is required and must be a string\");\n }\n checkOptionalProperty(view, \"caption\", \"string\");\n checkOptionalProperty(view, \"columns\", \"array\");\n checkOptionalProperty(view, \"defaultSortKey\", \"string\");\n checkOptionalProperty(view, \"emptyCaption\", \"string\");\n checkOptionalProperty(view, \"emptyTitle\", \"string\");\n checkOptionalProperty(view, \"emptyView\", \"function\");\n checkOptionalProperty(view, \"expanded\", \"boolean\");\n checkOptionalProperty(view, \"hidden\", \"boolean\");\n checkOptionalProperty(view, \"loadChildViews\", \"function\");\n checkOptionalProperty(view, \"order\", \"number\");\n checkOptionalProperty(view, \"params\", \"object\");\n checkOptionalProperty(view, \"parent\", \"string\");\n checkOptionalProperty(view, \"sticky\", \"boolean\");\n if (view.columns) {\n view.columns.forEach(validateColumn);\n const columnIds = view.columns.reduce((set, column) => set.add(column.id), /* @__PURE__ */ new Set());\n if (columnIds.size !== view.columns.length) {\n throw new Error(\"View columns must have unique ids\");\n }\n }\n}\nclass Navigation extends TypedEventTarget {\n _views = [];\n _currentView = null;\n /**\n * Register a new view on the navigation\n *\n * @param views The views to register\n * @throws {Error} if a view with the same id is already registered\n * @throws {Error} if the registered view is invalid\n */\n register(...views) {\n for (const view of views) {\n if (this._views.find((search) => search.id === view.id)) {\n throw new Error(`IView id ${view.id} is already registered`);\n }\n validateView(view);\n }\n this._views.push(...views);\n this.dispatchTypedEvent(\"update\", new CustomEvent(\"update\"));\n }\n /**\n * Remove a registered view\n *\n * @param id The id of the view to remove\n */\n remove(id) {\n const index = this._views.findIndex((view) => view.id === id);\n if (index !== -1) {\n this._views.splice(index, 1);\n this.dispatchTypedEvent(\"update\", new CustomEvent(\"update\"));\n }\n }\n /**\n * Set the currently active view\n *\n * @param id - The id of the view to set as active\n * @throws {Error} If no view with the given id was registered\n * @fires UpdateActiveViewEvent\n */\n setActive(id) {\n if (id === null) {\n this._currentView = null;\n } else {\n const view = this._views.find(({ id: viewId }) => viewId === id);\n if (!view) {\n throw new Error(`No view with ${id} registered`);\n }\n this._currentView = view;\n }\n const event = new CustomEvent(\"updateActive\", { detail: this._currentView });\n this.dispatchTypedEvent(\"updateActive\", event);\n }\n /**\n * The currently active files view\n */\n get active() {\n return this._currentView;\n }\n /**\n * All registered views\n */\n get views() {\n return this._views;\n }\n}\nfunction getNavigation() {\n scopedGlobals.navigation ??= new Navigation();\n return scopedGlobals.navigation;\n}\nconst NewMenuEntryCategory = Object.freeze({\n /**\n * For actions where the user is intended to upload from their device\n */\n UploadFromDevice: 0,\n /**\n * For actions that create new nodes on the server without uploading\n */\n CreateNew: 1,\n /**\n * For everything not matching the other categories\n */\n Other: 2\n});\nclass NewMenu {\n _entries = [];\n registerEntry(entry) {\n this.validateEntry(entry);\n entry.category = entry.category ?? NewMenuEntryCategory.CreateNew;\n this._entries.push(entry);\n }\n unregisterEntry(entry) {\n const entryIndex = typeof entry === \"string\" ? this.getEntryIndex(entry) : this.getEntryIndex(entry.id);\n if (entryIndex === -1) {\n logger.warn(\"Entry not found, nothing removed\", { entry, entries: this.getEntries() });\n return;\n }\n this._entries.splice(entryIndex, 1);\n }\n /**\n * Get the list of registered entries\n *\n * @param context - The creation context. Usually the current folder\n */\n getEntries(context) {\n if (context) {\n return this._entries.filter((entry) => typeof entry.enabled === \"function\" ? entry.enabled(context) : true);\n }\n return this._entries;\n }\n getEntryIndex(id) {\n return this._entries.findIndex((entry) => entry.id === id);\n }\n validateEntry(entry) {\n if (!entry.id || !entry.displayName || !entry.iconSvgInline || !entry.handler) {\n throw new Error(\"Invalid entry\");\n }\n if (typeof entry.id !== \"string\" || typeof entry.displayName !== \"string\") {\n throw new Error(\"Invalid id or displayName property\");\n }\n if (entry.iconSvgInline && typeof entry.iconSvgInline !== \"string\") {\n throw new Error(\"Invalid icon provided\");\n }\n if (entry.enabled !== void 0 && typeof entry.enabled !== \"function\") {\n throw new Error(\"Invalid enabled property\");\n }\n if (typeof entry.handler !== \"function\") {\n throw new Error(\"Invalid handler property\");\n }\n if (\"order\" in entry && typeof entry.order !== \"number\") {\n throw new Error(\"Invalid order property\");\n }\n if (this.getEntryIndex(entry.id) !== -1) {\n throw new Error(\"Duplicate entry\");\n }\n }\n}\nfunction getNewFileMenu() {\n scopedGlobals.newFileMenu ??= new NewMenu();\n return scopedGlobals.newFileMenu;\n}\nfunction addNewFileMenuEntry(entry) {\n const newFileMenu = getNewFileMenu();\n return newFileMenu.registerEntry(entry);\n}\nfunction removeNewFileMenuEntry(entry) {\n const newFileMenu = getNewFileMenu();\n return newFileMenu.unregisterEntry(entry);\n}\nfunction getNewFileMenuEntries(context) {\n const newFileMenu = getNewFileMenu();\n return newFileMenu.getEntries(context).sort((a2, b2) => {\n if (a2.order !== void 0 && b2.order !== void 0 && a2.order !== b2.order) {\n return a2.order - b2.order;\n }\n return a2.displayName.localeCompare(b2.displayName, void 0, { numeric: true, sensitivity: \"base\" });\n });\n}\nfunction registerSidebarAction(action) {\n validateSidebarAction(action);\n scopedGlobals.filesSidebarActions ??= /* @__PURE__ */ new Map();\n if (scopedGlobals.filesSidebarActions.has(action.id)) {\n logger.warn(`Sidebar action with id \"${action.id}\" already registered. Skipping.`);\n return;\n }\n scopedGlobals.filesSidebarActions.set(action.id, action);\n logger.debug(`New sidebar action with id \"${action.id}\" registered.`);\n}\nfunction getSidebarActions() {\n if (scopedGlobals.filesSidebarActions) {\n return [...scopedGlobals.filesSidebarActions.values()];\n }\n return [];\n}\nfunction validateSidebarAction(action) {\n if (typeof action !== \"object\") {\n throw new Error(\"Sidebar action is not an object\");\n }\n if (!action.id || typeof action.id !== \"string\" || action.id !== CSS.escape(action.id)) {\n throw new Error(\"Sidebar actions need to have an id conforming to the HTML id attribute specifications\");\n }\n if (!action.displayName || typeof action.displayName !== \"function\") {\n throw new Error(\"Sidebar actions need to have a displayName function\");\n }\n if (!action.iconSvgInline || typeof action.iconSvgInline !== \"function\") {\n throw new Error(\"Sidebar actions need to have a iconSvgInline function\");\n }\n if (!action.enabled || typeof action.enabled !== \"function\") {\n throw new Error(\"Sidebar actions need to have an enabled function\");\n }\n if (!action.onClick || typeof action.onClick !== \"function\") {\n throw new Error(\"Sidebar actions need to have an onClick function\");\n }\n}\nfunction registerSidebarTab(tab) {\n validateSidebarTab(tab);\n scopedGlobals.filesSidebarTabs ??= /* @__PURE__ */ new Map();\n if (scopedGlobals.filesSidebarTabs.has(tab.id)) {\n logger.warn(`Sidebar tab with id \"${tab.id}\" already registered. Skipping.`);\n return;\n }\n scopedGlobals.filesSidebarTabs.set(tab.id, tab);\n logger.debug(`New sidebar tab with id \"${tab.id}\" registered.`);\n}\nfunction getSidebarTabs() {\n if (scopedGlobals.filesSidebarTabs) {\n return [...scopedGlobals.filesSidebarTabs.values()];\n }\n return [];\n}\nfunction validateSidebarTab(tab) {\n if (typeof tab !== \"object\") {\n throw new Error(\"Sidebar tab is not an object\");\n }\n if (!tab.id || typeof tab.id !== \"string\" || tab.id !== CSS.escape(tab.id)) {\n throw new Error(\"Sidebar tabs need to have an id conforming to the HTML id attribute specifications\");\n }\n if (!tab.tagName || typeof tab.tagName !== \"string\") {\n throw new Error(\"Sidebar tabs need to have the tagName name set\");\n }\n if (!tab.tagName.match(/^[a-z][a-z0-9-_]+$/)) {\n throw new Error('Sidebar tab \"tagName\" is invalid');\n }\n if (!tab.displayName || typeof tab.displayName !== \"string\") {\n throw new Error(\"Sidebar tabs need to have a name set\");\n }\n if (typeof tab.iconSvgInline !== \"string\" || !isSvg(tab.iconSvgInline)) {\n throw new Error(\"Sidebar tabs need to have an valid SVG icon\");\n }\n if (typeof tab.order !== \"number\") {\n throw new Error(\"Sidebar tabs need to have a numeric order set\");\n }\n if (tab.enabled && typeof tab.enabled !== \"function\") {\n throw new Error('Sidebar tab \"enabled\" is not a function');\n }\n if (tab.onInit && typeof tab.onInit !== \"function\") {\n throw new Error('Sidebar tab \"onInit\" is not a function');\n }\n}\nclass SidebarProxy {\n get #impl() {\n return window.OCA?.Files?._sidebar?.();\n }\n get available() {\n return !!this.#impl;\n }\n get isOpen() {\n return this.#impl?.isOpen ?? false;\n }\n get activeTab() {\n return this.#impl?.activeTab;\n }\n get node() {\n return this.#impl?.node;\n }\n open(node, tab) {\n this.#impl?.open(node, tab);\n }\n close() {\n this.#impl?.close();\n }\n setActiveTab(tabId) {\n this.#impl?.setActiveTab(tabId);\n }\n registerTab(tab) {\n registerSidebarTab(tab);\n }\n getTabs(context) {\n return this.#impl?.getTabs(context) ?? [];\n }\n getActions(context) {\n return this.#impl?.getActions(context) ?? [];\n }\n registerAction(action) {\n registerSidebarAction(action);\n }\n}\nfunction getSidebar() {\n return new SidebarProxy();\n}\nconst InvalidFilenameErrorReason = Object.freeze({\n ReservedName: \"reserved name\",\n Character: \"character\",\n Extension: \"extension\"\n});\nclass InvalidFilenameError extends Error {\n constructor(options) {\n super(`Invalid ${options.reason} '${options.segment}' in filename '${options.filename}'`, { cause: options });\n }\n /**\n * The filename that was validated\n */\n get filename() {\n return this.cause.filename;\n }\n /**\n * Reason why the validation failed\n */\n get reason() {\n return this.cause.reason;\n }\n /**\n * Part of the filename that caused this error\n */\n get segment() {\n return this.cause.segment;\n }\n}\nfunction validateFilename(filename) {\n const capabilities = getCapabilities().files;\n const forbiddenCharacters = capabilities.forbidden_filename_characters ?? [\"/\", \"\\\\\"];\n for (const character of forbiddenCharacters) {\n if (filename.includes(character)) {\n throw new InvalidFilenameError({ segment: character, reason: InvalidFilenameErrorReason.Character, filename });\n }\n }\n filename = filename.toLocaleLowerCase();\n const forbiddenFilenames = capabilities.forbidden_filenames ?? [\".htaccess\"];\n if (forbiddenFilenames.includes(filename)) {\n throw new InvalidFilenameError({ filename, segment: filename, reason: InvalidFilenameErrorReason.ReservedName });\n }\n const endOfBasename = filename.indexOf(\".\", 1);\n const basename2 = filename.substring(0, endOfBasename === -1 ? void 0 : endOfBasename);\n const forbiddenFilenameBasenames = capabilities.forbidden_filename_basenames ?? [];\n if (forbiddenFilenameBasenames.includes(basename2)) {\n throw new InvalidFilenameError({ filename, segment: basename2, reason: InvalidFilenameErrorReason.ReservedName });\n }\n const forbiddenFilenameExtensions = capabilities.forbidden_filename_extensions ?? [];\n for (const extension of forbiddenFilenameExtensions) {\n if (filename.length > extension.length && filename.endsWith(extension)) {\n throw new InvalidFilenameError({ segment: extension, reason: InvalidFilenameErrorReason.Extension, filename });\n }\n }\n}\nfunction isFilenameValid(filename) {\n try {\n validateFilename(filename);\n return true;\n } catch (error) {\n if (error instanceof InvalidFilenameError) {\n return false;\n }\n throw error;\n }\n}\nfunction getUniqueName(name, otherNames, options) {\n const opts = {\n suffix: (n) => `(${n})`,\n ignoreFileExtension: false,\n ...options\n };\n let newName = name;\n let i = 1;\n while (otherNames.includes(newName)) {\n const ext = opts.ignoreFileExtension ? \"\" : extname(name);\n const base = basename(name, ext);\n newName = `${base} ${opts.suffix(i++)}${ext}`;\n }\n return newName;\n}\nconst humanList = [\"B\", \"KB\", \"MB\", \"GB\", \"TB\", \"PB\"];\nconst humanListBinary = [\"B\", \"KiB\", \"MiB\", \"GiB\", \"TiB\", \"PiB\"];\nfunction formatFileSize(size, skipSmallSizes = false, binaryPrefixes = false, base1000 = false) {\n binaryPrefixes = binaryPrefixes && !base1000;\n if (typeof size === \"string\") {\n size = Number(size);\n }\n let order = size > 0 ? Math.floor(Math.log(size) / Math.log(base1000 ? 1e3 : 1024)) : 0;\n order = Math.min((binaryPrefixes ? humanListBinary.length : humanList.length) - 1, order);\n const readableFormat = binaryPrefixes ? humanListBinary[order] : humanList[order];\n let relativeSize = (size / Math.pow(base1000 ? 1e3 : 1024, order)).toFixed(1);\n if (skipSmallSizes === true && order === 0) {\n return (relativeSize !== \"0.0\" ? \"< 1 \" : \"0 \") + (binaryPrefixes ? humanListBinary[1] : humanList[1]);\n }\n if (order < 2) {\n relativeSize = parseFloat(relativeSize).toFixed(0);\n } else {\n relativeSize = parseFloat(relativeSize).toLocaleString(getCanonicalLocale());\n }\n return relativeSize + \" \" + readableFormat;\n}\nfunction parseFileSize(value, forceBinary = false) {\n try {\n value = `${value}`.toLocaleLowerCase().replaceAll(/\\s+/g, \"\").replaceAll(\",\", \".\");\n } catch {\n return null;\n }\n const match = value.match(/^([0-9]*(\\.[0-9]*)?)([kmgtp]?)(i?)b?$/);\n if (match === null || match[1] === \".\" || match[1] === \"\") {\n return null;\n }\n const bytesArray = {\n \"\": 0,\n k: 1,\n m: 2,\n g: 3,\n t: 4,\n p: 5,\n e: 6\n };\n const decimalString = `${match[1]}`;\n const base = match[4] === \"i\" || forceBinary ? 1024 : 1e3;\n return Math.round(Number.parseFloat(decimalString) * base ** bytesArray[match[3]]);\n}\nfunction stringify(value) {\n if (value instanceof Date) {\n return value.toISOString();\n }\n return String(value);\n}\nfunction orderBy(collection, identifiers, orders) {\n identifiers = identifiers ?? [(value) => value];\n orders = orders ?? [];\n const sorting = identifiers.map((_, index) => (orders[index] ?? \"asc\") === \"asc\" ? 1 : -1);\n const collator = Intl.Collator(\n [getLanguage(), getCanonicalLocale()],\n {\n // handle 10 as ten and not as one-zero\n numeric: true,\n usage: \"sort\"\n }\n );\n return [...collection].sort((a2, b2) => {\n for (const [index, identifier] of identifiers.entries()) {\n const value = collator.compare(stringify(identifier(a2)), stringify(identifier(b2)));\n if (value !== 0) {\n return value * sorting[index];\n }\n }\n return 0;\n });\n}\nconst FilesSortingMode = Object.freeze({\n Name: \"basename\",\n Modified: \"mtime\",\n Size: \"size\"\n});\nfunction sortNodes(nodes, options = {}) {\n const sortingOptions = {\n // Default to sort by name\n sortingMode: FilesSortingMode.Name,\n // Default to sort ascending\n sortingOrder: \"asc\",\n ...options\n };\n function basename2(node) {\n const name = node.displayname || node.attributes?.displayname || node.basename || \"\";\n if (node.type === FileType.Folder) {\n return name;\n }\n return name.lastIndexOf(\".\") > 0 ? name.slice(0, name.lastIndexOf(\".\")) : name;\n }\n const identifiers = [\n // 1: Sort favorites first if enabled\n ...sortingOptions.sortFavoritesFirst ? [(v) => v.attributes?.favorite !== 1] : [],\n // 2: Sort folders first if sorting by name\n ...sortingOptions.sortFoldersFirst ? [(v) => v.type !== \"folder\"] : [],\n // 3: Use sorting mode if NOT basename (to be able to use display name too)\n ...sortingOptions.sortingMode !== FilesSortingMode.Name ? [(v) => v[sortingOptions.sortingMode] ?? v.attributes[sortingOptions.sortingMode]] : [],\n // 4: Use display name if available, fallback to name\n (v) => basename2(v),\n // 5: Finally, use basename if all previous sorting methods failed\n (v) => v.basename\n ];\n const orders = [\n // (for 1): always sort favorites before normal files\n ...sortingOptions.sortFavoritesFirst ? [\"asc\"] : [],\n // (for 2): always sort folders before files\n ...sortingOptions.sortFoldersFirst ? [\"asc\"] : [],\n // (for 3): Reverse if sorting by mtime as mtime higher means edited more recent -> lower\n ...sortingOptions.sortingMode === FilesSortingMode.Modified ? [sortingOptions.sortingOrder === \"asc\" ? \"desc\" : \"asc\"] : [],\n // (also for 3 so make sure not to conflict with 2 and 3)\n ...sortingOptions.sortingMode !== FilesSortingMode.Modified && sortingOptions.sortingMode !== FilesSortingMode.Name ? [sortingOptions.sortingOrder] : [],\n // for 4: use configured sorting direction\n sortingOptions.sortingOrder,\n // for 5: use configured sorting direction\n sortingOptions.sortingOrder\n ];\n return orderBy(nodes, identifiers, orders);\n}\nexport {\n Column,\n DefaultType,\n a as File,\n FileListFilter,\n FileType,\n FilesSortingMode,\n b as Folder,\n InvalidFilenameError,\n InvalidFilenameErrorReason,\n Navigation,\n NewMenuEntryCategory,\n N as Node,\n c as NodeStatus,\n P as Permission,\n View,\n addNewFileMenuEntry,\n formatFileSize,\n getFileActions,\n getFileListActions,\n getFileListFilters,\n getFileListHeaders,\n getFilesRegistry,\n getNavigation,\n getNewFileMenu,\n getNewFileMenuEntries,\n getSidebar,\n getSidebarActions,\n getSidebarTabs,\n getUniqueName,\n isFilenameValid,\n orderBy,\n parseFileSize,\n registerFileAction,\n registerFileListAction,\n registerFileListFilter,\n registerFileListHeader,\n registerSidebarAction,\n registerSidebarTab,\n removeNewFileMenuEntry,\n sortNodes,\n unregisterFileListFilter,\n validateColumn,\n validateFilename,\n validateView\n};\n//# sourceMappingURL=index.mjs.map\n","/**\n * SPDX-FileCopyrightText: 2021 Nextcloud GmbH and Nextcloud contributors\n * SPDX-License-Identifier: AGPL-3.0-or-later\n */\n\nimport LightningBolt from '@mdi/svg/svg/lightning-bolt.svg?raw'\nimport { registerSidebarTab } from '@nextcloud/files'\nimport { t } from '@nextcloud/l10n'\nimport { defineAsyncComponent, defineCustomElement } from 'vue'\n\nconst sidebarTabTag = 'activity-files-sidebar-tab'\n\nif (window.customElements.get(sidebarTabTag) === undefined) {\n\twindow.customElements.define(\n\t\tsidebarTabTag,\n\t\tdefineCustomElement(defineAsyncComponent(() => import('./views/ActivityTab.vue')), { shadowRoot: false }),\n\t)\n\n\tregisterSidebarTab({\n\t\tid: 'activity',\n\t\torder: 50,\n\t\tdisplayName: t('activity', 'Activity'),\n\t\ticonSvgInline: LightningBolt,\n\t\ttagName: sidebarTabTag,\n\t\tenabled() {\n\t\t\treturn true\n\t\t},\n\t})\n}\n"],"file":"activity-sidebar.mjs"}
Save File
Cancel