{"mappings":"wTAWA,SAASA,IACL,MAAUC,MAAM,kC,CAEpB,SAASC,IACL,MAAUD,MAAM,oC,CAsBpB,SAASE,EAAWC,GAChB,GAAIC,IAAqBC,WAErB,OAAOA,WAAWF,EAAK,GAG3B,IAAKC,IAAqBL,IAAqBK,IAAqBC,WAEhE,OADAD,EAAmBC,WACZA,WAAWF,EAAK,GAE3B,IAEI,OAAOC,EAAiBD,EAAK,E,CAC/B,MAAMG,GACJ,IAEI,OAAOF,EAAiBG,KAAK,KAAMJ,EAAK,E,CAC1C,MAAMG,GAEJ,OAAOF,EAAiBG,KAAKC,KAAML,EAAK,E,GAsCpD,SAASM,IACAC,GAAaC,IAGlBD,GAAW,EACPC,EAAaC,OACbC,EAAQF,EAAaG,OAAOD,GAE5BE,GAAa,EAEbF,EAAMD,QACNI,I,CAIR,SAASA,IACL,IAAIN,EAAJ,CAGA,IAAIO,EAAUf,EAAWO,GACzBC,GAAW,EAGX,IADA,IAAIQ,EAAML,EAAMD,OACVM,GAAK,CAGP,IAFAP,EAAeE,EACfA,EAAQ,KACCE,EAAaG,GACdP,GACAA,EAAaI,GAAYI,MAGjCJ,GAAa,EACbG,EAAML,EAAMD,M,CAEhBD,EAAe,KACfD,GAAW,EAnEf,SAAyBU,GACrB,GAAIC,IAAuBC,aAEvB,OAAOA,aAAaF,GAGxB,IAAKC,IAAuBpB,IAAwBoB,IAAuBC,aAEvE,OADAD,EAAqBC,aACdA,aAAaF,GAExB,IAEWC,EAAmBD,E,CAC5B,MAAOd,GACL,IAEI,OAAOe,EAAmBd,KAAK,KAAMa,E,CACvC,MAAOd,GAGL,OAAOe,EAAmBd,KAAKC,KAAMY,E,GAgD7CG,CAAgBN,EAnBZ,C,CAoCR,SAASO,EAAKrB,EAAKsB,GACfjB,KAAKL,IAAMA,EACXK,KAAKiB,MAAQA,C,CAYjB,SAASC,IAAO,CCvIhB,SAASC,EAAWC,GAClB,GAAoB,iBAATA,EACT,MAAM,IAAIC,UAAU,mCAAqCC,KAAKC,UAAUH,G,CAK5E,SAASI,EAAqBJ,EAAMK,GAMlC,IALA,IAIIC,EAJAC,EAAM,GACNC,EAAoB,EACpBC,GAAY,EACZC,EAAO,EAEFC,EAAI,EAAQX,EAAKhB,QAAV2B,IAAoBA,EAAG,CACrC,GAAQX,EAAKhB,OAAT2B,EACFL,EAAON,EAAKY,WAAWD,OACpB,IAAa,KAATL,EACP,MAEAA,EAAO,EAAE,CACX,GAAa,KAATA,EAAmB,CACrB,GAAIG,IAAcE,EAAI,GAAc,IAATD,QAEpB,GAAID,IAAcE,EAAI,GAAc,IAATD,EAAY,CAC5C,GAAiB,EAAbH,EAAIvB,QAAoC,IAAtBwB,GAA8D,KAAnCD,EAAIK,WAAWL,EAAIvB,OAAS,IAAsD,KAAnCuB,EAAIK,WAAWL,EAAIvB,OAAS,GAC1H,GAAIuB,EAAIvB,OAAS,EAAG,CAClB,IAAI6B,EAAiBN,EAAIO,YAAY,KACrC,GAAID,IAAmBN,EAAIvB,OAAS,EAAG,EACd,IAAnB6B,GACFN,EAAM,GACNC,EAAoB,GAGpBA,GADAD,EAAMA,EAAIQ,MAAM,EAAGF,IACK7B,OAAS,EAAIuB,EAAIO,YAAY,KAEvDL,EAAYE,EACZD,EAAO,EACP,Q,OAEG,GAAmB,IAAfH,EAAIvB,QAA+B,IAAfuB,EAAIvB,OAAc,CAC/CuB,EAAM,GACNC,EAAoB,EACpBC,EAAYE,EACZD,EAAO,EACP,Q,CAGAL,IACEE,EAAIvB,OAAS,EACfuB,GAAO,MAEPA,EAAM,KACRC,EAAoB,E,MAGlBD,EAAIvB,OAAS,EACfuB,GAAO,IAAMP,EAAKe,MAAMN,EAAY,EAAGE,GAEvCJ,EAAMP,EAAKe,MAAMN,EAAY,EAAGE,GAClCH,EAAoBG,EAAIF,EAAY,EAEtCA,EAAYE,EACZD,EAAO,C,MACW,KAATJ,IAA8B,IAATI,IAC5BA,EAEFA,GAAO,C,CAGX,OAAOH,C,CC1EF,SAASS,EAAKhB,EAAciB,GAA4B,GAC7D,OAAIA,GACK,EAAAC,EAAAC,UAASnB,IAET,EAAAkB,EAAAC,UAASnB,GAAM,EAAAkB,EAAAE,SAAQpB,G,CCN3B,SAASqB,EAAcrB,GAC5B,OAAO,EAAAkB,EAAAI,WAAUtB,GAAMuB,QAAYC,OCpBtB,CAA4BC,IAC1C,GAAsB,iBAAXA,EACV,MAAM,IAAIxB,UAAU,qBAKrB,OAAOwB,EACLF,QAAO,sBAAwB,QAC/BA,QAAO,KAAO,Q,EDW8B,CAAaL,EAAAQ,KAAhB,KAA0B,G,CEL/D,SAASC,EAAUC,EAAcC,EAAU,OAAQC,EAAY,IACpE,MAAyB,UAArBC,EAAAC,SACK,GAAGJ,IAAOC,IAEZ,GAAGD,IAAOE,G,CCFZ,SAASG,EAAcjC,EAAckC,GAE1C,MAAMC,GAAM,EAAAjB,EAAAE,SAAQpB,GAIdoC,EAAiB,GAAGF,KAHH,EAAAhB,EAAAC,UAASnB,EAAMmC,KAGcA,IAGpD,OAAO,EAAAjB,EAAAmB,OAAK,EAAAnB,EAAAoB,SAAQtC,GAAOoC,E,CCPtB,SAASG,EAAcvC,EAAcwC,GAE1C,MAAML,GAAM,EAAAjB,EAAAE,SAAQpB,GAIdyC,EAAiB,IAHA,EAAAvB,EAAAC,UAASnB,EAAMmC,KAGKK,IAASL,IAGpD,OAAO,EAAAjB,EAAAmB,OAAK,EAAAnB,EAAAoB,SAAQtC,GAAOyC,E,CCVtB,SAASC,EAASd,EAAcC,EAAU,OAAQC,EAAY,OACnE,MAAyB,UAArBC,EAAAC,SACK,GAAGJ,IAAOC,IAEZ,GAAGD,IAAOE,G,CCRZ,SAASa,EAAoB3C,GAClC,MAAyB,UAArB+B,EAAAC,SACKhC,EAEF,KAAKA,C,CCFP,SAAS4C,EAAU5C,GACxB,MAAM6C,GAAkB,EAAA3B,EAAAE,SAAQpB,GAAMhB,OACtC,OAAOgB,EAAKe,MAAM,GAAI8B,E,CCAjB,SAASC,EAAW9C,EAAc+C,GAEvC,OAAOC,EAAAC,EAAA,CAAejD,EAAM+C,E,CCOvB,SAASG,EAAaC,EAAmBC,GAG9C,MAAMC,GAAW,EAAAnC,EAAAoC,UAASF,EAAYD,GAEtC,SAAeE,GAAyB,OAAbA,GAAsBA,EAASE,WAAW,KAAKrC,EAAAQ,MAAU2B,KAAa,EAAAnC,EAAAsC,SAAQL,G,KZxBvG3E,EACAiB,E,UARAgE,EAAU1B,EAAiB,GAgB9B,MACG,IAEQvD,EADsB,mBAAfC,WACYA,WAEAN,C,CAEzB,MAAOO,GACLF,EAAmBL,C,CAEvB,IAEQsB,EADwB,mBAAjBC,aACcA,aAEArB,C,CAE3B,MAAOqF,GACLjE,EAAqBpB,C,CAE5B,EAnBA,GAwED,IAEIU,EAFAE,EAAQ,GACRH,GAAW,EAEXK,GAAa,EAyCjBsE,EAAQE,SAAW,SAAUpF,GACzB,IAAIqF,EAAWC,MAAMC,UAAU9E,OAAS,GACxC,GAAI8E,UAAU9E,OAAS,EACnB,IAAK,IAAI2B,EAAI,EAAOmD,UAAU9E,OAAd2B,EAAsBA,IAClCiD,EAAKjD,EAAI,GAAKmD,UAAUnD,GAGhC1B,EAAM8E,KAAK,IAAInE,EAAKrB,EAAKqF,IACJ,IAAjB3E,EAAMD,QAAiBF,GACvBR,EAAWc,E,EASnBQ,EAAKoE,UAAUzE,IAAM,WACjBX,KAAKL,IAAI0F,MAAM,KAAMrF,KAAKiB,M,EAE9B4D,EAAQS,MAAQ,UAChBT,EAAQU,SAAU,EAClBV,EAAQW,IAAM,GACdX,EAAQY,KAAO,GACfZ,EAAQa,QAAU,GAClBb,EAAQc,SAAW,GAInBd,EAAQe,GAAK1E,EACb2D,EAAQgB,YAAc3E,EACtB2D,EAAQiB,KAAO5E,EACf2D,EAAQkB,IAAM7E,EACd2D,EAAQmB,eAAiB9E,EACzB2D,EAAQoB,mBAAqB/E,EAC7B2D,EAAQqB,KAAOhF,EACf2D,EAAQsB,gBAAkBjF,EAC1B2D,EAAQuB,oBAAsBlF,EAE9B2D,EAAQwB,UAAsBrD,GAAe,GAE7C6B,EAAQyB,QAAoBtD,IACxB,MAAUxD,MAAM,mC,EAGpBqF,EAAQ0B,IAAM,IAAqB,IACnC1B,EAAQ2B,MAAkBC,IACtB,MAAUjH,MAAM,iC,EAEpBqF,EAAQ6B,MAAQ,IAAoB,ECzEpC,IAAIC,EAAQ,CAEV/B,UAKE,IAJA,IAEI2B,EAFAK,EAAe,GACfC,GAAmB,EAGd9E,EAAImD,UAAU9E,OAAS,EAAG2B,IAAK,IAAO8E,EAAkB9E,IAAK,CACpE,IAAIX,EACK,EAALW,QAGU+E,IAARP,IACFA,EAAMpD,EAAAoD,OACRnF,EAAOmF,GAJPnF,EAAO8D,UAAUnD,GAOnBZ,EAAWC,GAGS,IAAhBA,EAAKhB,SAITwG,EAAexF,EAAO,IAAMwF,EAC5BC,EAA0C,KAAvBzF,EAAKY,WAAW,G,CASrC,OAFA4E,EAAepF,EAAqBoF,GAAeC,GAE/CA,EACED,EAAaxG,OAAS,EACjB,IAAMwG,EAEN,IACAA,EAAaxG,OAAS,EACxBwG,EAEA,G,EAIXlE,UAA8BtB,GAG5B,GAFAD,EAAWC,GAES,IAAhBA,EAAKhB,OAAc,MAAO,IAE9B,IAAI2G,EAAoC,KAAvB3F,EAAKY,WAAW,GAC7BgF,EAAyD,KAArC5F,EAAKY,WAAWZ,EAAKhB,OAAS,GAQtD,OAHoB,KAFpBgB,EAAOI,EAAqBJ,GAAO2F,IAE1B3G,QAAiB2G,IAAY3F,EAAO,KACzCA,EAAKhB,OAAS,GAAK4G,IAAmB5F,GAAQ,KAE9C2F,EAAmB,IAAM3F,EACtBA,C,EAGT2F,WAAgC3F,GAE9B,OADAD,EAAWC,GACJA,EAAKhB,OAAS,GAA4B,KAAvBgB,EAAKY,WAAW,E,EAG5CyB,OACE,GAAyB,IAArByB,UAAU9E,OACZ,MAAO,IAET,IADA,IAAI6G,EACKlF,EAAI,EAAOmD,UAAU9E,OAAd2B,IAAwBA,EAAG,CACzC,IAAImF,EAAMhC,UAAUnD,GACpBZ,EAAW+F,GACPA,EAAI9G,OAAS,SACA0G,IAAXG,EACFA,EAASC,EAETD,GAAU,IAAMC,E,CAGtB,YAAeJ,IAAXG,EACK,IACFN,EAAMjE,UAAUuE,E,EAGzBvC,SAA4ByC,EAAMC,GAIhC,GAHAjG,EAAWgG,GACXhG,EAAWiG,GAEPD,IAASC,EAAI,MAAO,GAKxB,IAHAD,EAAOR,EAAM/B,QAAQuC,OACrBC,EAAKT,EAAM/B,QAAQwC,IAEF,MAAO,GAIxB,IADA,IAAIC,EAAY,EACGF,EAAK/G,OAAjBiH,GAC8B,KAA/BF,EAAKnF,WAAWqF,KADYA,GASlC,IALA,IAAIC,EAAUH,EAAK/G,OACfmH,EAAUD,EAAUD,EAGpBG,EAAU,EACGJ,EAAGhH,OAAboH,GAC0B,KAA3BJ,EAAGpF,WAAWwF,KADUA,GAW9B,IAPA,IACIC,EADQL,EAAGhH,OACKoH,EAGhBpH,EAAmBqH,EAAVF,EAAkBA,EAAUE,EACrCC,GAAgB,EAChB3F,EAAI,EACI3B,GAAL2B,IAAeA,EAAG,CACvB,GAAIA,IAAM3B,EAAQ,CAChB,GAAIqH,EAAQrH,EAAQ,CAClB,GAAmC,KAA/BgH,EAAGpF,WAAWwF,EAAUzF,GAG1B,OAAOqF,EAAGjF,MAAMqF,EAAUzF,EAAI,GACzB,GAAU,IAANA,EAGT,OAAOqF,EAAGjF,MAAMqF,EAAUzF,E,MAEnBwF,EAAUnH,IACoB,KAAnC+G,EAAKnF,WAAWqF,EAAYtF,GAG9B2F,EAAgB3F,EACD,IAANA,IAGT2F,EAAgB,IAGpB,K,CAEF,IAAIC,EAAWR,EAAKnF,WAAWqF,EAAYtF,GAE3C,GAAI4F,IADSP,EAAGpF,WAAWwF,EAAUzF,GAEnC,MACoB,KAAb4F,IACPD,EAAgB3F,E,CAGpB,IAAI6F,EAAM,GAGV,IAAK7F,EAAIsF,EAAYK,EAAgB,EAAQJ,GAALvF,IAAgBA,EAClDA,IAAMuF,GAAkC,KAAvBH,EAAKnF,WAAWD,KAEjC6F,GADiB,IAAfA,EAAIxH,OACC,KAEA,OAMb,OAAIwH,EAAIxH,OAAS,EACRwH,EAAMR,EAAGjF,MAAMqF,EAAUE,IAGD,KAA3BN,EAAGpF,WADPwF,GAAWE,MAEPF,EACGJ,EAAGjF,MAAMqF,G,EAIpBK,UAA8BzG,GAC5B,OAAOA,C,EAGTsC,QAA0BtC,GAExB,GADAD,EAAWC,GACS,IAAhBA,EAAKhB,OAAc,MAAO,IAK9B,IAJA,IAAIsB,EAAON,EAAKY,WAAW,GACvB8F,EAAmB,KAATpG,EACVqG,GAAM,EACNC,GAAe,EACVjG,EAAIX,EAAKhB,OAAS,EAAG2B,GAAK,IAAKA,EAEtC,GAAa,MADbL,EAAON,EAAKY,WAAWD,KAEnB,IAAKiG,EAAc,CACjBD,EAAMhG,EACN,K,OAIJiG,GAAe,EAInB,OAAY,IAARD,EAAmBD,EAAU,IAAM,IACnCA,GAAmB,IAARC,EAAkB,KAC1B3G,EAAKe,MAAM,EAAG4F,E,EAGvBxF,SAA4BnB,EAAMmC,GAChC,QAAYuD,IAARvD,GAAoC,iBAARA,EAAkB,MAAM,IAAIlC,UAAU,mCACtEF,EAAWC,GAEX,IAGIW,EAHAkG,EAAQ,EACRF,GAAM,EACNC,GAAe,EAGnB,QAAYlB,IAARvD,GAAqBA,EAAInD,OAAS,GAAmBgB,EAAKhB,QAAnBmD,EAAInD,OAAuB,CACpE,GAAImD,EAAInD,SAAWgB,EAAKhB,QAAUmD,IAAQnC,EAAM,MAAO,GACvD,IAAI8G,EAAS3E,EAAInD,OAAS,EACtB+H,GAAmB,EACvB,IAAKpG,EAAIX,EAAKhB,OAAS,EAAG2B,GAAK,IAAKA,EAAG,CACrC,IAAIL,EAAON,EAAKY,WAAWD,GAC3B,GAAa,KAATL,GAGA,IAAKsG,EAAc,CACjBC,EAAQlG,EAAI,EACZ,K,OAGqB,IAArBoG,IAGFH,GAAe,EACfG,EAAmBpG,EAAI,GAEX,EAAVmG,IAEExG,IAAS6B,EAAIvB,WAAWkG,IACT,KAAXA,IAGJH,EAAMhG,IAKRmG,GAAS,EACTH,EAAMI,G,CAOd,OADIF,IAAUF,EAAKA,EAAMI,GAAkC,IAARJ,IAAYA,EAAM3G,EAAKhB,QACnEgB,EAAKe,MAAM8F,EAAOF,E,CAEzB,IAAKhG,EAAIX,EAAKhB,OAAS,EAAG2B,GAAK,IAAKA,EAClC,GAA2B,KAAvBX,EAAKY,WAAWD,IAGhB,IAAKiG,EAAc,CACjBC,EAAQlG,EAAI,EACZ,K,OAEe,IAARgG,IAGXC,GAAe,EACfD,EAAMhG,EAAI,GAId,OAAY,IAARgG,EAAmB,GAChB3G,EAAKe,MAAM8F,EAAOF,E,EAI7BvF,QAA0BpB,GACxBD,EAAWC,GAQX,IAPA,IAAIgH,GAAW,EACXC,EAAY,EACZN,GAAM,EACNC,GAAe,EAGfM,EAAc,EACTvG,EAAIX,EAAKhB,OAAS,EAAG2B,GAAK,IAAKA,EAAG,CACzC,IAAIL,EAAON,EAAKY,WAAWD,GAC3B,GAAa,KAATL,GASQ,IAARqG,IAGFC,GAAe,EACfD,EAAMhG,EAAI,GAEC,KAATL,GAEiB,IAAb0G,EACFA,EAAWrG,EACY,IAAhBuG,IACPA,EAAc,IACI,IAAbF,IAGTE,GAAc,QArBZ,IAAKN,EAAc,CACjBK,EAAYtG,EAAI,EAChB,K,EAuBR,OAAiB,IAAbqG,IAA2B,IAARL,GAEH,IAAhBO,GAEgB,IAAhBA,GAAqBF,IAAaL,EAAM,GAAKK,IAAaC,EAAY,EACjE,GAEFjH,EAAKe,MAAMiG,EAAUL,E,EAG9BQ,OAAwBC,GACtB,GAAmB,OAAfA,GAA6C,iBAAfA,EAChC,MAAM,IAAInH,UAAU,0EAA4EmH,GAElG,MAvVJ,EAAiB1F,EAAK0F,KACpB,IAAI/B,EAAM+B,EAAW/B,KAAO+B,EAAWC,KACnCC,EAAOF,EAAWE,OAASF,EAAWxF,MAAQ,KAAOwF,EAAWjF,KAAO,IAC3E,OAAKkD,EAGDA,IAAQ+B,EAAWC,KACdhC,EAAMiC,EAERjC,EA8UU,IA9UEiC,EALVA,C,EAmVAC,CAAQ,EAAKH,E,EAGtBI,MAAsBxH,GACpBD,EAAWC,GAEX,IAAIyH,EAAM,CAAEJ,KAAM,GAAIhC,IAAK,GAAIiC,KAAM,GAAInF,IAAK,GAAIP,KAAM,IACxD,GAAoB,IAAhB5B,EAAKhB,OAAc,OAAOyI,EAC9B,IAEIZ,EAFAvG,EAAON,EAAKY,WAAW,GACvB+E,EAAsB,KAATrF,EAEbqF,GACF8B,EAAIJ,KAAO,IACXR,EAAQ,GAERA,EAAQ,EAaV,IAXA,IAAIG,GAAW,EACXC,EAAY,EACZN,GAAM,EACNC,GAAe,EACfjG,EAAIX,EAAKhB,OAAS,EAIlBkI,EAAc,EAGXvG,GAAKkG,IAASlG,EAEnB,GAAa,MADbL,EAAON,EAAKY,WAAWD,KAUX,IAARgG,IAGFC,GAAe,EACfD,EAAMhG,EAAI,GAEC,KAATL,GAEiB,IAAb0G,EAAiBA,EAAWrG,EAA2B,IAAhBuG,IAAmBA,EAAc,IACtD,IAAbF,IAGXE,GAAc,QAlBZ,IAAKN,EAAc,CACjBK,EAAYtG,EAAI,EAChB,K,CAyCR,OArBiB,IAAbqG,IAA2B,IAARL,GAEP,IAAhBO,GAEgB,IAAhBA,GAAqBF,IAAaL,EAAM,GAAKK,IAAaC,EAAY,GACxD,IAARN,IACiCc,EAAIH,KAAOG,EAAI7F,KAAO5B,EAAKe,MAA5C,IAAdkG,GAAmBtB,EAA6C,EAA8CsB,EAA3CN,KAGvD,IAAdM,GAAmBtB,GACrB8B,EAAI7F,KAAO5B,EAAKe,MAAM,EAAGiG,GACzBS,EAAIH,KAAOtH,EAAKe,MAAM,EAAG4F,KAEzBc,EAAI7F,KAAO5B,EAAKe,MAAMkG,EAAWD,GACjCS,EAAIH,KAAOtH,EAAKe,MAAMkG,EAAWN,IAEnCc,EAAItF,IAAMnC,EAAKe,MAAMiG,EAAUL,IAG7BM,EAAY,EAAGQ,EAAIpC,IAAMrF,EAAKe,MAAM,EAAGkG,EAAY,GAAYtB,IAAY8B,EAAIpC,IAAM,KAElFoC,C,EAGT/F,IAAK,IACLgG,UAAW,IACXC,MAAO,KACPC,MAAO,MAGTrC,EAAMqC,MAAQrC,EAEdrE,EAAiBqE,E,0UYjfjBtC,EA3BA,CAAoB4E,EAAO1F,KACzB,GAAqB,iBAAV0F,EACT,OAAOA,EAGT,GAAqB,IAAjBA,EAAM7I,OACR,OAAO6I,EAGT,IAcIC,EAdAC,EAAY7G,EAAAC,SAAc0G,EAAO3G,EAAAE,QAAayG,IAAU1F,EACxD6F,EAAY9G,EAAAmB,KAAUnB,EAAAoB,QAAauF,GAAQE,GAK/C,OAQID,EARoBD,EAQA9G,MAAM,EAAG,MACV,IAAMG,EAAAQ,KAA4B,OAAhBoG,EARhC,IAAM5G,EAAAQ,IAAWsG,EAGnBA,C,6GCtBT,MAAM7G,SACJ8G,EAAQP,UACRQ,EAAS5F,QACT6F,EAAO/G,QACPgH,EAAOjB,OACPkB,EAAM1C,WACN2C,EAAUjG,KACVkG,EAAIjH,UACJkH,EAAShB,MACTiB,EAAKb,MACLc,EAAKpF,SACLqF,GAAQnF,QACRoF,GAAOlH,IACPmH,GAAGC,iBACHC,GAAgBpB,MAChBqB,IACE9H,S","sources":["node_modules/.pnpm/process@0.11.10/node_modules/process/browser.js","node_modules/.pnpm/path-browserify@1.0.1/node_modules/path-browserify/index.js","src/name.ts","src/normalize-trim.ts","node_modules/.pnpm/escape-string-regexp@5.0.0/node_modules/escape-string-regexp/index.js","src/add-exe-ext.ts","src/add-name-prefix.ts","src/add-name-suffix.ts","src/add-sh-ext.ts","src/add-sh-relative-prefix.ts","src/remove-ext.ts","src/replace-ext.ts","src/is-path-inside.ts","node_modules/.pnpm/replace-ext@2.0.0/node_modules/replace-ext/index.js","src/index-browser.ts"],"sourcesContent":["// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","// 'path' module extracted from Node.js v8.11.1 (only the posix part)\n// transplited with Babel\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\nfunction assertPath(path) {\n  if (typeof path !== 'string') {\n    throw new TypeError('Path must be a string. Received ' + JSON.stringify(path));\n  }\n}\n\n// Resolves . and .. elements in a path with directory names\nfunction normalizeStringPosix(path, allowAboveRoot) {\n  var res = '';\n  var lastSegmentLength = 0;\n  var lastSlash = -1;\n  var dots = 0;\n  var code;\n  for (var i = 0; i <= path.length; ++i) {\n    if (i < path.length)\n      code = path.charCodeAt(i);\n    else if (code === 47 /*/*/)\n      break;\n    else\n      code = 47 /*/*/;\n    if (code === 47 /*/*/) {\n      if (lastSlash === i - 1 || dots === 1) {\n        // NOOP\n      } else if (lastSlash !== i - 1 && dots === 2) {\n        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 /*.*/ || res.charCodeAt(res.length - 2) !== 46 /*.*/) {\n          if (res.length > 2) {\n            var lastSlashIndex = res.lastIndexOf('/');\n            if (lastSlashIndex !== res.length - 1) {\n              if (lastSlashIndex === -1) {\n                res = '';\n                lastSegmentLength = 0;\n              } else {\n                res = res.slice(0, lastSlashIndex);\n                lastSegmentLength = res.length - 1 - res.lastIndexOf('/');\n              }\n              lastSlash = i;\n              dots = 0;\n              continue;\n            }\n          } else if (res.length === 2 || res.length === 1) {\n            res = '';\n            lastSegmentLength = 0;\n            lastSlash = i;\n            dots = 0;\n            continue;\n          }\n        }\n        if (allowAboveRoot) {\n          if (res.length > 0)\n            res += '/..';\n          else\n            res = '..';\n          lastSegmentLength = 2;\n        }\n      } else {\n        if (res.length > 0)\n          res += '/' + path.slice(lastSlash + 1, i);\n        else\n          res = path.slice(lastSlash + 1, i);\n        lastSegmentLength = i - lastSlash - 1;\n      }\n      lastSlash = i;\n      dots = 0;\n    } else if (code === 46 /*.*/ && dots !== -1) {\n      ++dots;\n    } else {\n      dots = -1;\n    }\n  }\n  return res;\n}\n\nfunction _format(sep, pathObject) {\n  var dir = pathObject.dir || pathObject.root;\n  var base = pathObject.base || (pathObject.name || '') + (pathObject.ext || '');\n  if (!dir) {\n    return base;\n  }\n  if (dir === pathObject.root) {\n    return dir + base;\n  }\n  return dir + sep + base;\n}\n\nvar posix = {\n  // path.resolve([from ...], to)\n  resolve: function resolve() {\n    var resolvedPath = '';\n    var resolvedAbsolute = false;\n    var cwd;\n\n    for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n      var path;\n      if (i >= 0)\n        path = arguments[i];\n      else {\n        if (cwd === undefined)\n          cwd = process.cwd();\n        path = cwd;\n      }\n\n      assertPath(path);\n\n      // Skip empty entries\n      if (path.length === 0) {\n        continue;\n      }\n\n      resolvedPath = path + '/' + resolvedPath;\n      resolvedAbsolute = path.charCodeAt(0) === 47 /*/*/;\n    }\n\n    // At this point the path should be resolved to a full absolute path, but\n    // handle relative paths to be safe (might happen when process.cwd() fails)\n\n    // Normalize the path\n    resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);\n\n    if (resolvedAbsolute) {\n      if (resolvedPath.length > 0)\n        return '/' + resolvedPath;\n      else\n        return '/';\n    } else if (resolvedPath.length > 0) {\n      return resolvedPath;\n    } else {\n      return '.';\n    }\n  },\n\n  normalize: function normalize(path) {\n    assertPath(path);\n\n    if (path.length === 0) return '.';\n\n    var isAbsolute = path.charCodeAt(0) === 47 /*/*/;\n    var trailingSeparator = path.charCodeAt(path.length - 1) === 47 /*/*/;\n\n    // Normalize the path\n    path = normalizeStringPosix(path, !isAbsolute);\n\n    if (path.length === 0 && !isAbsolute) path = '.';\n    if (path.length > 0 && trailingSeparator) path += '/';\n\n    if (isAbsolute) return '/' + path;\n    return path;\n  },\n\n  isAbsolute: function isAbsolute(path) {\n    assertPath(path);\n    return path.length > 0 && path.charCodeAt(0) === 47 /*/*/;\n  },\n\n  join: function join() {\n    if (arguments.length === 0)\n      return '.';\n    var joined;\n    for (var i = 0; i < arguments.length; ++i) {\n      var arg = arguments[i];\n      assertPath(arg);\n      if (arg.length > 0) {\n        if (joined === undefined)\n          joined = arg;\n        else\n          joined += '/' + arg;\n      }\n    }\n    if (joined === undefined)\n      return '.';\n    return posix.normalize(joined);\n  },\n\n  relative: function relative(from, to) {\n    assertPath(from);\n    assertPath(to);\n\n    if (from === to) return '';\n\n    from = posix.resolve(from);\n    to = posix.resolve(to);\n\n    if (from === to) return '';\n\n    // Trim any leading backslashes\n    var fromStart = 1;\n    for (; fromStart < from.length; ++fromStart) {\n      if (from.charCodeAt(fromStart) !== 47 /*/*/)\n        break;\n    }\n    var fromEnd = from.length;\n    var fromLen = fromEnd - fromStart;\n\n    // Trim any leading backslashes\n    var toStart = 1;\n    for (; toStart < to.length; ++toStart) {\n      if (to.charCodeAt(toStart) !== 47 /*/*/)\n        break;\n    }\n    var toEnd = to.length;\n    var toLen = toEnd - toStart;\n\n    // Compare paths to find the longest common path from root\n    var length = fromLen < toLen ? fromLen : toLen;\n    var lastCommonSep = -1;\n    var i = 0;\n    for (; i <= length; ++i) {\n      if (i === length) {\n        if (toLen > length) {\n          if (to.charCodeAt(toStart + i) === 47 /*/*/) {\n            // We get here if `from` is the exact base path for `to`.\n            // For example: from='/foo/bar'; to='/foo/bar/baz'\n            return to.slice(toStart + i + 1);\n          } else if (i === 0) {\n            // We get here if `from` is the root\n            // For example: from='/'; to='/foo'\n            return to.slice(toStart + i);\n          }\n        } else if (fromLen > length) {\n          if (from.charCodeAt(fromStart + i) === 47 /*/*/) {\n            // We get here if `to` is the exact base path for `from`.\n            // For example: from='/foo/bar/baz'; to='/foo/bar'\n            lastCommonSep = i;\n          } else if (i === 0) {\n            // We get here if `to` is the root.\n            // For example: from='/foo'; to='/'\n            lastCommonSep = 0;\n          }\n        }\n        break;\n      }\n      var fromCode = from.charCodeAt(fromStart + i);\n      var toCode = to.charCodeAt(toStart + i);\n      if (fromCode !== toCode)\n        break;\n      else if (fromCode === 47 /*/*/)\n        lastCommonSep = i;\n    }\n\n    var out = '';\n    // Generate the relative path based on the path difference between `to`\n    // and `from`\n    for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {\n      if (i === fromEnd || from.charCodeAt(i) === 47 /*/*/) {\n        if (out.length === 0)\n          out += '..';\n        else\n          out += '/..';\n      }\n    }\n\n    // Lastly, append the rest of the destination (`to`) path that comes after\n    // the common path parts\n    if (out.length > 0)\n      return out + to.slice(toStart + lastCommonSep);\n    else {\n      toStart += lastCommonSep;\n      if (to.charCodeAt(toStart) === 47 /*/*/)\n        ++toStart;\n      return to.slice(toStart);\n    }\n  },\n\n  _makeLong: function _makeLong(path) {\n    return path;\n  },\n\n  dirname: function dirname(path) {\n    assertPath(path);\n    if (path.length === 0) return '.';\n    var code = path.charCodeAt(0);\n    var hasRoot = code === 47 /*/*/;\n    var end = -1;\n    var matchedSlash = true;\n    for (var i = path.length - 1; i >= 1; --i) {\n      code = path.charCodeAt(i);\n      if (code === 47 /*/*/) {\n          if (!matchedSlash) {\n            end = i;\n            break;\n          }\n        } else {\n        // We saw the first non-path separator\n        matchedSlash = false;\n      }\n    }\n\n    if (end === -1) return hasRoot ? '/' : '.';\n    if (hasRoot && end === 1) return '//';\n    return path.slice(0, end);\n  },\n\n  basename: function basename(path, ext) {\n    if (ext !== undefined && typeof ext !== 'string') throw new TypeError('\"ext\" argument must be a string');\n    assertPath(path);\n\n    var start = 0;\n    var end = -1;\n    var matchedSlash = true;\n    var i;\n\n    if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {\n      if (ext.length === path.length && ext === path) return '';\n      var extIdx = ext.length - 1;\n      var firstNonSlashEnd = -1;\n      for (i = path.length - 1; i >= 0; --i) {\n        var code = path.charCodeAt(i);\n        if (code === 47 /*/*/) {\n            // If we reached a path separator that was not part of a set of path\n            // separators at the end of the string, stop now\n            if (!matchedSlash) {\n              start = i + 1;\n              break;\n            }\n          } else {\n          if (firstNonSlashEnd === -1) {\n            // We saw the first non-path separator, remember this index in case\n            // we need it if the extension ends up not matching\n            matchedSlash = false;\n            firstNonSlashEnd = i + 1;\n          }\n          if (extIdx >= 0) {\n            // Try to match the explicit extension\n            if (code === ext.charCodeAt(extIdx)) {\n              if (--extIdx === -1) {\n                // We matched the extension, so mark this as the end of our path\n                // component\n                end = i;\n              }\n            } else {\n              // Extension does not match, so our result is the entire path\n              // component\n              extIdx = -1;\n              end = firstNonSlashEnd;\n            }\n          }\n        }\n      }\n\n      if (start === end) end = firstNonSlashEnd;else if (end === -1) end = path.length;\n      return path.slice(start, end);\n    } else {\n      for (i = path.length - 1; i >= 0; --i) {\n        if (path.charCodeAt(i) === 47 /*/*/) {\n            // If we reached a path separator that was not part of a set of path\n            // separators at the end of the string, stop now\n            if (!matchedSlash) {\n              start = i + 1;\n              break;\n            }\n          } else if (end === -1) {\n          // We saw the first non-path separator, mark this as the end of our\n          // path component\n          matchedSlash = false;\n          end = i + 1;\n        }\n      }\n\n      if (end === -1) return '';\n      return path.slice(start, end);\n    }\n  },\n\n  extname: function extname(path) {\n    assertPath(path);\n    var startDot = -1;\n    var startPart = 0;\n    var end = -1;\n    var matchedSlash = true;\n    // Track the state of characters (if any) we see before our first dot and\n    // after any path separator we find\n    var preDotState = 0;\n    for (var i = path.length - 1; i >= 0; --i) {\n      var code = path.charCodeAt(i);\n      if (code === 47 /*/*/) {\n          // If we reached a path separator that was not part of a set of path\n          // separators at the end of the string, stop now\n          if (!matchedSlash) {\n            startPart = i + 1;\n            break;\n          }\n          continue;\n        }\n      if (end === -1) {\n        // We saw the first non-path separator, mark this as the end of our\n        // extension\n        matchedSlash = false;\n        end = i + 1;\n      }\n      if (code === 46 /*.*/) {\n          // If this is our first dot, mark it as the start of our extension\n          if (startDot === -1)\n            startDot = i;\n          else if (preDotState !== 1)\n            preDotState = 1;\n      } else if (startDot !== -1) {\n        // We saw a non-dot and non-path separator before our dot, so we should\n        // have a good chance at having a non-empty extension\n        preDotState = -1;\n      }\n    }\n\n    if (startDot === -1 || end === -1 ||\n        // We saw a non-dot character immediately before the dot\n        preDotState === 0 ||\n        // The (right-most) trimmed path component is exactly '..'\n        preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n      return '';\n    }\n    return path.slice(startDot, end);\n  },\n\n  format: function format(pathObject) {\n    if (pathObject === null || typeof pathObject !== 'object') {\n      throw new TypeError('The \"pathObject\" argument must be of type Object. Received type ' + typeof pathObject);\n    }\n    return _format('/', pathObject);\n  },\n\n  parse: function parse(path) {\n    assertPath(path);\n\n    var ret = { root: '', dir: '', base: '', ext: '', name: '' };\n    if (path.length === 0) return ret;\n    var code = path.charCodeAt(0);\n    var isAbsolute = code === 47 /*/*/;\n    var start;\n    if (isAbsolute) {\n      ret.root = '/';\n      start = 1;\n    } else {\n      start = 0;\n    }\n    var startDot = -1;\n    var startPart = 0;\n    var end = -1;\n    var matchedSlash = true;\n    var i = path.length - 1;\n\n    // Track the state of characters (if any) we see before our first dot and\n    // after any path separator we find\n    var preDotState = 0;\n\n    // Get non-dir info\n    for (; i >= start; --i) {\n      code = path.charCodeAt(i);\n      if (code === 47 /*/*/) {\n          // If we reached a path separator that was not part of a set of path\n          // separators at the end of the string, stop now\n          if (!matchedSlash) {\n            startPart = i + 1;\n            break;\n          }\n          continue;\n        }\n      if (end === -1) {\n        // We saw the first non-path separator, mark this as the end of our\n        // extension\n        matchedSlash = false;\n        end = i + 1;\n      }\n      if (code === 46 /*.*/) {\n          // If this is our first dot, mark it as the start of our extension\n          if (startDot === -1) startDot = i;else if (preDotState !== 1) preDotState = 1;\n        } else if (startDot !== -1) {\n        // We saw a non-dot and non-path separator before our dot, so we should\n        // have a good chance at having a non-empty extension\n        preDotState = -1;\n      }\n    }\n\n    if (startDot === -1 || end === -1 ||\n    // We saw a non-dot character immediately before the dot\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly '..'\n    preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n      if (end !== -1) {\n        if (startPart === 0 && isAbsolute) ret.base = ret.name = path.slice(1, end);else ret.base = ret.name = path.slice(startPart, end);\n      }\n    } else {\n      if (startPart === 0 && isAbsolute) {\n        ret.name = path.slice(1, startDot);\n        ret.base = path.slice(1, end);\n      } else {\n        ret.name = path.slice(startPart, startDot);\n        ret.base = path.slice(startPart, end);\n      }\n      ret.ext = path.slice(startDot, end);\n    }\n\n    if (startPart > 0) ret.dir = path.slice(0, startPart - 1);else if (isAbsolute) ret.dir = '/';\n\n    return ret;\n  },\n\n  sep: '/',\n  delimiter: ':',\n  win32: null,\n  posix: null\n};\n\nposix.posix = posix;\n\nmodule.exports = posix;\n","import { basename, extname } from \"path\"\n\n/**\n * Get the name of the given file path.\n *\n * By default the file extension is included in the returned name. To remove the extension, set the second parameter to `false`.\n *\n * @example\n *\n * ```js\n * import { name } from \"patha\"\n *\n * name(\"path/to/file.md\") // gives \"file.md\"\n *\n * name(\"path/to/file.md\", false) // gives \"file\"\n * ```\n *\n * @param path The given file path\n * @param includeExtension If the name should include the file extension as well\n * @returns The base name without the extension\n */\nexport function name(path: string, includeExtension: boolean = true) {\n  if (includeExtension) {\n    return basename(path)\n  } else {\n    return basename(path, extname(path))\n  }\n}\n","import { normalize, sep } from \"path\"\nimport escapeRegexp from \"escape-string-regexp\"\n\n/**\n * Normalizes the path and removes the trailing slashes.\n *\n * @example\n *\n * ```js\n * import { normalize, normalizeTrim } from \"patha\"\n *\n * normalizeTrim(\"/foo/bar//baz/asdf/hello/../\") // gives \"/foo/bar/baz/asdf\"\n *\n * normalize(\"/foo/bar//baz/asdf/hello/../\") // gives \"/foo/bar/baz/asdf/\"\n * ```\n *\n * @param path The given file path\n * @returns The normalized and trimmed file path\n */\nexport function normalizeTrim(path: string) {\n  return normalize(path).replace(new RegExp(`${escapeRegexp(sep)}$`), \"\")\n}\n","export default function escapeStringRegexp(string) {\n\tif (typeof string !== 'string') {\n\t\tthrow new TypeError('Expected a string');\n\t}\n\n\t// Escape characters with special meaning either inside or outside character sets.\n\t// Use a simple backslash escape when it’s always valid, and a `\\xnn` escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.\n\treturn string\n\t\t.replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&')\n\t\t.replace(/-/g, '\\\\x2d');\n}\n","/**\n * Add bin extension to the given binary name.\n *\n * @example\n *\n * ```js\n * import { addExeExt } from \"patha\"\n *\n * addExeExt(\"path/to/file-name\") // gives \"path/to/file-name.exe\" on Windows and \"path/to/file-name\" on others\n * ```\n *\n * @param name The name you want to add the shell extension to\n * @param win_ext Defaults to `.exe` on Windows\n * @param other_ext Defaults to `\"\"` On other platforms.\n */\nexport function addExeExt(name: string, win_ext = \".exe\", other_ext = \"\") {\n  if (process.platform === \"win32\") {\n    return `${name}${win_ext}`\n  }\n  return `${name}${other_ext}`\n}\n","import { basename, dirname, extname, join } from \"path\"\n\n/**\n * Adds a prefix to the start of the name of the given path\n *\n * @example\n *\n * ```js\n * import { addNamePrefix } from \"patha\"\n *\n * addNamePrefix(\"path/to/file-name.ext\", \"new-\") // gives \"path/to/new-file-name.ext\"\n * ```\n *\n * @param path The given file path\n * @param prefix The prefix to add to the start of the file name\n * @returns The path with a prefix added to its file name\n */\nexport function addNamePrefix(path: string, prefix: string) {\n  // get the extension and the file name\n  const ext = extname(path)\n  const nameWithoutExt = basename(path, ext)\n\n  // add the name prefix\n  const NameWithPrefix = `${prefix}${nameWithoutExt}${ext}`\n\n  // add the dirname back\n  return join(dirname(path), NameWithPrefix)\n}\n","import { basename, dirname, extname, join } from \"path\"\n\n/**\n * Adds a suffix to the end of the name of the given path\n *\n * @example\n *\n * ```js\n * import { addNameSuffix } from \"patha\"\n *\n * addNameSuffix(\"path/to/file-name.ext\", \"-old\") // gives \"path/to/file-name-old.ext\"\n *\n * addNameSuffix(\"path/to/file-name.ext\", \".test\") // gives \"path/to/file-name.test.ext\"\n * ```\n *\n * @param path The given file path\n * @param suffix The suffix to add to the end of the file name\n * @returns The path with a suffix added to its file name\n */\nexport function addNameSuffix(path: string, suffix: string) {\n  // get the extension and the file name\n  const ext = extname(path)\n  const nameWithoutExt = basename(path, ext)\n\n  // add the name suffix\n  const NameWithSuffix = `${nameWithoutExt}${suffix}${ext}`\n\n  // add the dirname back\n  return join(dirname(path), NameWithSuffix)\n}\n","/**\n * Add a native shell extension to the given name.\n *\n * @example\n *\n * ```js\n * import { addShExt } from \"patha\"\n *\n * addShExt(\"path/to/file-name\") // gives \"path/to/file-name.cmd\" on Windows and \"path/to/file-name.sh\" on others\n *\n * addShExt(\"path/to/file-name\", \".bat\") // gives \"path/to/file-name.bat\" on Windows and \"path/to/file-name.sh\" on others\n * ```\n *\n * @param name The name you want to add the shell extension to\n * @param win_ext `.cmd` on Windows\n * @param other_ext `.sh` On others.\n * @returns The file path with the shell extension added\n */\nexport function addShExt(name: string, win_ext = \".cmd\", other_ext = \".sh\") {\n  if (process.platform === \"win32\") {\n    return `${name}${win_ext}`\n  }\n  return `${name}${other_ext}`\n}\n","/**\n * Prefix a `./` for unix shell and nothing for `cmd`.\n *\n * @example\n *\n * ```js\n * import { addShRelativePrefix } from \"patha\"\n *\n * addShRelativePrefix(\"some/file-name\") // gives \"some/file-name\" on Windows and \"./some/file-name\" on others.\n * ```\n *\n * @param path The given path\n * @returns The path with `./` added on Unix\n */\nexport function addShRelativePrefix(path: string) {\n  if (process.platform === \"win32\") {\n    return path\n  }\n  return `./${path}`\n}\n","import { extname } from \"path\"\n\n/**\n * Remove a path's extension.\n *\n * @example\n *\n * ```js\n * import { removeExt } from \"patha\"\n *\n * removeExt(\"some/dir/file.ext\") // gives \"some/dir/file\"\n * ```\n *\n * @param path The given path\n * @returns The path without its file extension\n */\nexport function removeExt(path: string) {\n  const extensionLength = extname(path).length\n  return path.slice(0, -extensionLength)\n}\n","import replaceExtOrig from \"replace-ext\"\n\n/**\n * Replaces the extension from path with extension and returns the updated path string.\n *\n * Does not replace the extension if path is not a string or is empty.\n *\n * @example\n *\n * ```js\n * import { replaceExt } from \"patha\"\n *\n * replaceExt(\"path/to/file.md\", \".html\") // gives \"path/to/file.html\"\n * ```\n *\n * @param path The given path\n * @param extension The extension to replace\n */\nexport function replaceExt(path: string, extension: string) {\n  // TODO replaceExt should not change `/` to `\\\\` on Windows\n  return replaceExtOrig(path, extension)\n}\n","import { relative, resolve, sep } from \"path\"\n\n/**\n * Check if a path is inside another path.\n *\n * Note that relative paths are resolved against `process.cwd()` to make them absolute.\n *\n * This function does not check if the paths exist and it only works with strings.\n *\n * @example\n *\n * ```js\n * import { isPathInside } from \"patha\"\n *\n * isPathInside(\"a/b/c\", \"a/b\")\n * //=> true\n *\n * isPathInside(\"a/b/c\", \"x/y\")\n * //=> false\n *\n * isPathInside(\"a/b/c\", \"a/b/c\")\n * //=> false\n *\n * isPathInside(\"/Users/some/dev/aa\", \"/Users/some\")\n * //=> true\n * ```\n */\nexport function isPathInside(childPath: string, parentPath: string): boolean {\n  // copied from is-path-inside because the package uses node:path that can't be bundled for the browser\n\n  const relation = relative(parentPath, childPath)\n\n  return Boolean(relation && relation !== \"..\" && !relation.startsWith(`..${sep}`) && relation !== resolve(childPath))\n}\n","'use strict';\n\nvar path = require('path');\n\nfunction replaceExt(npath, ext) {\n  if (typeof npath !== 'string') {\n    return npath;\n  }\n\n  if (npath.length === 0) {\n    return npath;\n  }\n\n  var nFileName = path.basename(npath, path.extname(npath)) + ext;\n  var nFilepath = path.join(path.dirname(npath), nFileName);\n\n  // Because `path.join` removes the head './' from the given path.\n  // This removal can cause a problem when passing the result to `require` or\n  // `import`.\n  if (startsWithSingleDot(npath)) {\n    return '.' + path.sep + nFilepath;\n  }\n\n  return nFilepath;\n}\n\nfunction startsWithSingleDot(fpath) {\n  var first2chars = fpath.slice(0, 2);\n  return first2chars === '.' + path.sep || first2chars === './';\n}\n\nmodule.exports = replaceExt;\n","import * as path from \"path\"\nconst {\n  basename,\n  delimiter,\n  dirname,\n  extname,\n  format,\n  isAbsolute,\n  join,\n  normalize,\n  parse,\n  posix,\n  relative,\n  resolve,\n  sep,\n  toNamespacedPath,\n  win32,\n} = path\n\nexport {\n  basename,\n  delimiter,\n  dirname,\n  extname,\n  format,\n  isAbsolute,\n  join,\n  normalize,\n  parse,\n  posix,\n  relative,\n  resolve,\n  sep,\n  toNamespacedPath,\n  win32,\n}\n\nexport * from \"./lib\"\n"],"names":["$57ac963a8e38d384$var$defaultSetTimout","Error","$57ac963a8e38d384$var$defaultClearTimeout","$57ac963a8e38d384$var$runTimeout","fun","$57ac963a8e38d384$var$cachedSetTimeout","setTimeout","e","call","this","$57ac963a8e38d384$var$cleanUpNextTick","$57ac963a8e38d384$var$draining","$57ac963a8e38d384$var$currentQueue","length","$57ac963a8e38d384$var$queue","concat","$57ac963a8e38d384$var$queueIndex","$57ac963a8e38d384$var$drainQueue","timeout","len","run","marker","$57ac963a8e38d384$var$cachedClearTimeout","clearTimeout","$57ac963a8e38d384$var$runClearTimeout","$57ac963a8e38d384$var$Item","array","$57ac963a8e38d384$var$noop","$08c3af4533a7470a$var$assertPath","path","TypeError","JSON","stringify","$08c3af4533a7470a$var$normalizeStringPosix","allowAboveRoot","code","res","lastSegmentLength","lastSlash","dots","i","charCodeAt","lastSlashIndex","lastIndexOf","slice","$1586b085dc576c38$export$a8ff84c12d48cfa6","includeExtension","$08c3af4533a7470a$exports","basename","extname","$616ec6bff867d311$export$873fead74fe2f1ff","normalize","replace","RegExp","string","sep","$78e10b4304ff7293$export$2d20c564cade3c93","name","win_ext","other_ext","$57ac963a8e38d384$exports","platform","$f20c8501d8e0956e$export$3e333f8cb13439c","prefix","ext","NameWithPrefix","join","dirname","$a3c2c27d75c4bb14$export$3b60a3e9bd1aef9d","suffix","NameWithSuffix","$766d165a1e1c2e96$export$609be29b80b555e1","$9d87039734e229ec$export$e1f23f8d3e53fe6","$e95fcdddb5c040f0$export$19c5468f88f6e968","extensionLength","$bac3938762e1404c$export$e9c34737ac8e53d2","extension","$parcel$interopDefault","$4364d685427d1fa0$exports","$122b43bb8628835c$export$7d0573375890d05c","childPath","parentPath","relation","relative","startsWith","resolve","$57ac963a8e38d384$var$process","e1","nextTick","args","Array","arguments","push","prototype","apply","title","browser","env","argv","version","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","dir","umask","$08c3af4533a7470a$var$posix","resolvedPath","resolvedAbsolute","undefined","isAbsolute","trailingSeparator","joined","arg","from","to","fromStart","fromEnd","fromLen","toStart","toLen","lastCommonSep","fromCode","out","_makeLong","hasRoot","end","matchedSlash","start","extIdx","firstNonSlashEnd","startDot","startPart","preDotState","format","pathObject","root","base","$08c3af4533a7470a$var$_format","parse","ret","delimiter","win32","posix","npath","first2chars","nFileName","nFilepath","$3f1ef6a35c86a93e$export$9bf319d8f74f51d1","$3f1ef6a35c86a93e$export$c889f2fcc19dbf12","$3f1ef6a35c86a93e$export$7f7b8152cc673abe","$3f1ef6a35c86a93e$export$d0e86f3a75393fa3","$3f1ef6a35c86a93e$export$d9468344d3651243","$3f1ef6a35c86a93e$export$e434c7255acda994","$3f1ef6a35c86a93e$export$f7e2c8231c57a8bd","$3f1ef6a35c86a93e$export$a3295358bff77e","$3f1ef6a35c86a93e$export$98e6a39c04603d36","$3f1ef6a35c86a93e$export$8585d06717c0ab37","$3f1ef6a35c86a93e$export$f0e7d1106eeabbe6","$3f1ef6a35c86a93e$export$f7ad0328861e2f03","$3f1ef6a35c86a93e$export$5aee1a5bd9743d8f","toNamespacedPath","$3f1ef6a35c86a93e$export$c8b5bbc3171ae22a","$3f1ef6a35c86a93e$export$e242fbdac2d35a87"],"version":3,"file":"index.browser.mjs.map"}