{"version":3,"file":"umd/es6.js","mappings":"CAAA,SAA2CA,EAAMC,GAC1B,iBAAZC,SAA0C,iBAAXC,OACxCA,OAAOD,QAAUD,IACQ,mBAAXG,QAAyBA,OAAOC,IAC9CD,OAAO,GAAIH,GACe,iBAAZC,QACdA,QAA+B,sBAAID,IAEnCD,EAA4B,sBAAIC,IARlC,CASmB,oBAATK,KAAuBC,KAAOD,MAAM,WAC9C,M,yBCVC,SAASE,GAAG,IAAIC,EAAEC,OAAO,gBAAgBC,EAAEC,OAAO,SAASC,EAAEL,GAAG,OAAO,iBAAiBA,GAAG,iBAAiBA,KAAKA,EAAEG,EAAEH,KAAK,GAAGA,EAAE,IAAI,SAASM,EAAEN,GAAG,MAAM,iBAAiBA,IAAG,IAAKA,GAAG,iBAAiBA,GAAG,UAAUA,EAAEA,EAAEO,WAAW,CAACC,WAAWH,EAAEI,UAAUH,GAAGN,EAAEU,eAAe,SAASV,GAAG,QAAQA,KAAKA,EAAEC,IAAID,EAAEW,SAAS,SAASX,GAAG,IAAIA,GAAG,iBAAiBA,EAAE,MAAM,GAAG,IAAIC,EAAE,GAAG,OAAOK,EAAEN,EAAEY,YAAYX,EAAEY,KAAK,aAAaR,EAAEL,EAAEc,SAASb,EAAEY,KAAK,WAAWV,EAAEH,EAAEc,SAAST,EAAEL,EAAEe,WAAWd,EAAEY,KAAK,aAAaV,EAAEH,EAAEe,WAAWV,EAAEL,EAAEgB,WAAWf,EAAEY,KAAK,aAAaV,EAAEH,EAAEgB,WAAWV,EAAEN,EAAEiB,iBAAiBhB,EAAEY,KAAK,mBAAmBP,EAAEN,EAAEkB,iBAAiBjB,EAAEY,KAAK,mBAAmBP,EAAEN,EAAEmB,UAAUlB,EAAEY,KAAK,YAAYP,EAAEN,EAAEoB,UAAUnB,EAAEY,KAAK,YAAYP,EAAEN,EAAEqB,cAAcpB,EAAEY,KAAK,gBAAgBP,EAAEN,EAAEsB,eAAerB,EAAEY,KAAK,kBAAkBP,EAAEN,EAAEuB,UAAUtB,EAAEY,KAAK,WAAWP,EAAEN,EAAEwB,kBAAkBvB,EAAEY,KAAK,oBAAoBP,EAAEN,EAAEyB,SAASxB,EAAEY,KAAK,UAAUR,EAAEL,EAAE0B,UAAUzB,EAAEY,KAAK,YAAYV,EAAEH,EAAE0B,UAAUrB,EAAEL,EAAE2B,eAAe1B,EAAEY,KAAK,kBAAkBV,EAAEH,EAAE2B,eAAetB,EAAEL,EAAE4B,uBAAuB3B,EAAEY,KAAK,0BAA0BV,EAAEH,EAAE4B,uBAAuB3B,GAAGD,EAAE6B,MAAM,SAAS7B,GAAG,IAAI8B,EAAEC,OAAOC,eAAe,GAAG/B,EAAE,CAACgC,YAAW,EAAGC,MAAM,IAAI,IAAIlC,GAAG,iBAAiBA,EAAE,OAAO8B,EAAE,IAAIK,EAAE,GAAGC,EAAEpC,EAAEqC,cAAcC,QAAQ,OAAO,IAAIC,MAAM,KAAK,IAAI,IAAIC,KAAKJ,EAAE,CAAC,IAAIK,EAAEL,EAAEI,GAAGD,MAAM,IAAI,GAAGJ,EAAEM,EAAE,IAAI,IAAIA,EAAEC,QAAQD,EAAE,GAAG,OAAOnC,EAAE6B,EAAEvB,aAAakB,EAAElB,WAAU,GAAIP,EAAE8B,EAAE,cAAcL,EAAEhB,OAAOX,EAAEgC,EAAE,aAAa9B,EAAE8B,EAAE,gBAAgBL,EAAEf,SAASZ,EAAEgC,EAAE,eAAe9B,EAAE8B,EAAE,gBAAgBL,EAAEd,SAASb,EAAEgC,EAAE,eAAe7B,EAAE6B,EAAE,sBAAsBL,EAAEb,gBAAe,GAAIX,EAAE6B,EAAE,sBAAsBL,EAAEZ,gBAAe,GAAIZ,EAAE6B,EAAE,eAAeL,EAAEX,SAAQ,GAAIb,EAAE6B,EAAE,eAAeL,EAAEV,SAAQ,GAAId,EAAE6B,EAAE,mBAAmBL,EAAET,aAAY,GAAIf,EAAE6B,EAAE,qBAAqBL,EAAER,cAAa,GAAIhB,EAAE6B,EAAEZ,WAAWO,EAAEP,SAAQ,GAAIjB,EAAE6B,EAAE,uBAAuBL,EAAEN,iBAAgB,GAAIlB,EAAE6B,EAAEV,UAAUK,EAAEL,QAAO,GAAIpB,EAAE8B,EAAE,eAAeL,EAAEJ,QAAQvB,EAAEgC,EAAE,cAAc9B,EAAE8B,EAAE,qBAAqBL,EAAEH,aAAaxB,EAAEgC,EAAE,oBAAoB9B,EAAE8B,EAAE,6BAA6BL,EAAEF,qBAAqBzB,EAAEgC,EAAE,4BAA4BL,GAA/hE,CAA+jEpC,I,YCA/jE,IAASM,EAAOG,EAAPH,EAAqNN,EAA9MS,EAAED,OAAO,cAAcF,EAAE2C,SAAS,WAAW,IAAI3C,EAAE8B,EAAEzB,EAAE,IAAIuC,SAAQ,SAAUzC,EAAEE,GAAGL,EAAEG,EAAE2B,EAAEzB,KAAK,OAAOA,EAAEwC,QAAQ7C,EAAEK,EAAEyC,OAAOhB,EAAEzB,EAAEF,GAAG,EAAEE,GAAGL,EAAE+C,WAAW,SAAS/C,GAAG,QAAQA,KAAKA,EAAEG,K,YCA7L,IAASA,GAAAA,EAAueT,GAAlesD,UAAU,SAAS3C,GAAG,IAAIyB,SAASzB,EAAE,GAAG,WAAWyB,GAAGzB,EAAE,CAAC,GAAGA,aAAa4C,KAAK,MAAM,IAAI5C,EAAE6C,UAAU,GAAG7C,aAAa8C,OAAO,MAAM,IAAI9C,EAAE+C,WAAW,IAAIhB,EAAEiB,MAAMC,QAAQjD,GAAG,GAAG,GAAG,IAAI,IAAIL,KAAKK,EAAE+B,EAAEpC,GAAGG,EAAE6C,UAAU3C,EAAEL,IAAI,MAAM,IAAIuD,OAAOlD,EAAEmD,aAAaC,KAAKC,UAAUtB,EAAEL,OAAO4B,KAAKvB,GAAGwB,QAAQ,OAAO9B,EAAEyB,OAAOlD,IAAI,WAAWyB,EAAE+B,KAAKC,SAAS,KAAK3D,EAAE4D,KAAK,SAAS1D,GAAGA,EAAEF,EAAE6C,UAAU3C,GAAG,IAAI,IAAIyB,EAAE,EAAEM,EAAE,EAAEA,EAAE/B,EAAEqC,QAAQZ,EAAE,GAAGA,EAAEzB,EAAE2D,WAAW5B,KAAK,iBAAiB,OAAON,KCC7cmC,EAA2B,GAG/B,SAASC,EAAoBC,GAE5B,IAAIC,EAAeH,EAAyBE,GAC5C,QAAqBE,IAAjBD,EACH,OAAOA,EAAa1E,QAGrB,IAAIC,EAASsE,EAAyBE,GAAY,CAGjDzE,QAAS,IAOV,OAHA4E,EAAoBH,GAAUxE,EAAQA,EAAOD,QAASwE,GAG/CvE,EAAOD,QCpBfwE,EAAoBK,EAAI,CAAC7E,EAAS8E,KACjC,IAAI,IAAIC,KAAOD,EACXN,EAAoB9B,EAAEoC,EAAYC,KAASP,EAAoB9B,EAAE1C,EAAS+E,IAC5E1C,OAAOC,eAAetC,EAAS+E,EAAK,CAAExC,YAAY,EAAMyC,IAAKF,EAAWC,MCJ3EP,EAAoB9B,EAAI,CAACuC,EAAKC,IAAU7C,OAAO8C,UAAUC,eAAeC,KAAKJ,EAAKC,GCClFV,EAAoB/D,EAAKT,IACH,oBAAXQ,QAA0BA,OAAO8E,aAC1CjD,OAAOC,eAAetC,EAASQ,OAAO8E,YAAa,CAAE9C,MAAO,WAE7DH,OAAOC,eAAetC,EAAS,aAAc,CAAEwC,OAAO,K,gfCL5C+C,E,SACX,SAAWA,GAQPA,EAAwB,gBAAI,oBAQ5BA,EAAqB,aAAI,gBAUzBA,EAAoB,YAAI,gBAExBA,EAAqB,aAAI,gBASzBA,EAAa,KAAI,OAQjBA,EAAgB,QAAI,UAQpBA,EAAY,IAAI,MAShBA,EAAoB,YAAI,eAUxBA,EAAwB,gBAAI,qBAa5BA,EAAgC,wBAAI,8BArFxC,CAsFGA,IAAWA,EAAS,KCrFhB,MAAMC,EAA4BC,IACrC,IAAKA,EACD,MAAO,qBACX,MAAMC,EAAeD,EAAQF,EAAOI,cACpC,GAAID,EAAc,CACd,MAAM,QAAEjE,EAAO,QAAEC,EAAO,eAAEH,EAAc,OAAEH,EAAM,UAAEF,IAAc,IAAAiB,OAAMuD,GAEtE,GAAIjE,GAAWC,EACX,MAAO,aAEX,GAAIR,EAGA,OAAO,QAGX,GAAIK,EACA,OAAO,EAEX,GAAIH,EAAQ,CACR,MAAMwE,EAAMH,EAAQF,EAAOM,KAC3B,OAAKD,EAG2B,KAAxBxE,EAASV,OAAOkF,IAFJ,IAATxE,GAKnB,MAAM0E,EAAUL,EAAQF,EAAOQ,SAC/B,GAAID,EAAS,CACT,MAAME,EAAezC,KAAKpB,MAAM2D,GAAWvC,KAAK0C,MAChD,OAAOD,GAAgB,EAAIA,EAAe,aAE9C,MAAO,sB,aC7BJ,SAASE,EAAqBC,GACjC,OAAOA,EACAC,GAAWD,EAAYC,IAAsB,MAAXA,EAClCA,GAAYA,GAAU,KAAOA,EAAS,KAAmB,MAAXA,EAGlD,SAASC,EAAWC,EAAgB,MAAOC,EAAa,IAC3DD,EAAgBA,EAAc3D,cAC9B,IAAK,MAAM6D,KAAUD,EACjB,GAAIC,EAAO7D,gBAAkB2D,EACzB,OAAO,EAGf,OAAO,EAEJ,SAASG,EAAuBC,EAAOC,GAC1C,IAAIC,EACJD,EAAOlB,UAAYkB,EAAOlB,QAAU,IACpC,MAAM,KAAEoB,EAAI,cAAEC,GAAkBH,EAAOD,MACvC,GAAIG,EAAM,CACN,MAAME,GAAqB,IAATF,EAAsC,QAArBD,EAAKF,EAAMM,YAAyB,IAAPJ,OAAgB,EAASA,EAAGnB,QAAQF,EAAO0B,MAAQJ,EAC/GE,IACAJ,EAAOlB,QAAQF,EAAO2B,aAAeH,GAGzCD,IACAH,EAAOlB,QAAQF,EAAO4B,kBACA,IAAlBL,EAEQJ,EAAMM,KAAKvB,QAAQF,EAAO6B,eACtB,IAAI7D,KAAKmD,EAAMW,WAAWC,cAChCR,EAAcQ,eAOzB,SAASC,EAAeC,EAAUd,GACrC,OAAwB,MAApBc,EAASpB,QAAkBM,GAE3Bc,EAASC,QAAS,EAClBD,EAASR,KAAON,EAAMM,KACtBQ,EAASpB,OAASM,EAAMN,OACxBoB,EAASE,WAAahB,EAAMgB,WAE5BF,EAAS/B,QAAUpD,OAAOsF,OAAOtF,OAAOsF,OAAO,GAAIjB,EAAMjB,SAAU+B,EAAS/B,SAErEiB,GAGJ,CACHM,KAAMQ,EAASR,KACfZ,OAAQoB,EAASpB,OACjBsB,WAAYF,EAASE,WACrBjC,QAAS+B,EAAS/B,SC5D1B,IAAImC,EAAwC,SAAUC,EAASC,EAAYC,EAAGC,GAE1E,OAAO,IAAKD,IAAMA,EAAI7E,WAAU,SAAUC,EAASC,GAC/C,SAAS6E,EAAUzF,GAAS,IAAM0F,EAAKF,EAAUG,KAAK3F,IAAW,MAAOlC,GAAK8C,EAAO9C,IACpF,SAAS8H,EAAS5F,GAAS,IAAM0F,EAAKF,EAAiB,MAAExF,IAAW,MAAOlC,GAAK8C,EAAO9C,IACvF,SAAS4H,EAAKG,GAJlB,IAAe7F,EAIa6F,EAAOC,KAAOnF,EAAQkF,EAAO7F,QAJ1CA,EAIyD6F,EAAO7F,MAJhDA,aAAiBuF,EAAIvF,EAAQ,IAAIuF,GAAE,SAAU5E,GAAWA,EAAQX,OAIT+F,KAAKN,EAAWG,GAClGF,GAAMF,EAAYA,EAAUQ,MAAMX,EAASC,GAAc,KAAKK,YAK/D,SAASM,EAA0BC,GACtC,MAAMC,EAAehC,GAAWiB,EAAUvH,UAAM,OAAQ,GAAQ,YAC5D,IAAIuG,EACJ,IAAqB,IAAjBD,EAAOD,MACP,OAAOC,EAIX,GADAA,EAAOD,MAAQrE,OAAOsF,OAAOtF,OAAOsF,OAAO,GAAIe,EAAME,SAASlC,OAAQC,EAAOD,QACxEL,EAAWM,EAAOH,OAAQG,EAAOD,MAAMmC,SACxC,OAAOlC,EAEX,MAAM5B,EAAO4B,EAAOmC,GAAKJ,EAAMK,YAAYpC,GAE3C,IA6BIqC,EA7BAtC,QAAcgC,EAAMO,QAAQjE,IAAID,GAEpCmE,EAAc,GAAoB,UAAhBxC,EAAMyC,OAAqC,UAAhBzC,EAAMyC,MAAmB,CAMlE,GAAIT,EAAMU,QAAQrE,GAAM,CACpB2B,QAAegC,EAAMO,QAAQjE,IAAID,GACjC,MAAMmE,EAiBV,OAdAR,EAAMU,QAAQrE,IAAO,IAAA9B,YAKS,QAA7B2D,EAAK8B,EAAMU,QAAQrE,UAAyB,IAAP6B,GAAyBA,EAAGyC,OAAM,eAClEX,EAAMO,QAAQK,IAAIvE,EAAK,CACzBoE,MAAO,UACPnC,KAAMN,EAAMM,OAEI,UAAhBN,EAAMyC,OACN1C,EAAuBC,EAAOC,GAElCA,EAAO4C,eAAiBrD,EAAqBS,EAAO4C,gBAC7C5C,EAGX,GAAoB,YAAhBD,EAAMyC,MAAqB,CAC3B,MAAMlG,EAAWyF,EAAMU,QAAQrE,GAG/B,IAAK9B,EAED,aADMyF,EAAMO,QAAQO,OAAOzE,GACpB4B,EAEX,IACIqC,QAAuB/F,EAE3B,MAAOwG,GAEH,OAAO9C,QAIXqC,EAAiBtC,EAAMM,KAc3B,OATAL,EAAO+C,QAAU,IAAMxG,QAAQC,QAAQ,CACnCwD,OAAAA,EACAK,KAAMgC,EAAehC,KACrBvB,QAASuD,EAAevD,QACxBW,OAAQ4C,EAAe5C,OACvBsB,WAAYsB,EAAetB,WAC3BD,QAAQ,EACRqB,GAAI/D,IAED4B,KAEX,MAAO,CACHgC,YAAAA,EACAH,MAAO,IAAME,EAAMiB,aAAaC,QAAQC,IAAIlB,ICzFpD,IAAI,EAAwC,SAAUd,EAASC,EAAYC,EAAGC,GAE1E,OAAO,IAAKD,IAAMA,EAAI7E,WAAU,SAAUC,EAASC,GAC/C,SAAS6E,EAAUzF,GAAS,IAAM0F,EAAKF,EAAUG,KAAK3F,IAAW,MAAOlC,GAAK8C,EAAO9C,IACpF,SAAS8H,EAAS5F,GAAS,IAAM0F,EAAKF,EAAiB,MAAExF,IAAW,MAAOlC,GAAK8C,EAAO9C,IACvF,SAAS4H,EAAKG,GAJlB,IAAe7F,EAIa6F,EAAOC,KAAOnF,EAAQkF,EAAO7F,QAJ1CA,EAIyD6F,EAAO7F,MAJhDA,aAAiBuF,EAAIvF,EAAQ,IAAIuF,GAAE,SAAU5E,GAAWA,EAAQX,OAIT+F,KAAKN,EAAWG,GAClGF,GAAMF,EAAYA,EAAUQ,MAAMX,EAASC,GAAc,KAAKK,YAI/D,SAAS2B,EAAmBtC,EAAUuC,GACzC,IAAInD,EACJ,OAAO,EAAUvG,UAAM,OAAQ,GAAQ,YACnC,GAAyB,mBAAd0J,EACP,OAAOA,EAAUvC,GAErB,MAAM,YAAEwC,EAAW,cAAEC,EAAa,gBAAEC,GAAoBH,EACxD,GAAKC,WAAuBA,EAAYxC,EAASpB,UAC5C6D,WAAyBA,EAAczC,IACxC,OAAO,EAEX,GAAI0C,EACA,IAAK,MAAMC,KAAUD,EAAiB,CAClC,MAAMH,EAAYG,EAAgBC,GAClC,GAAIJ,WACQA,EAG0C,QAAjDnD,EAAKY,EAAS/B,QAAQ0E,EAAOxH,sBAAmC,IAAPiE,EAAgBA,EAAKY,EAAS/B,QAAQ0E,KAChG,OAAO,EAInB,OAAO,KCjCf,IAAI,EAAwC,SAAUtC,EAASC,EAAYC,EAAGC,GAE1E,OAAO,IAAKD,IAAMA,EAAI7E,WAAU,SAAUC,EAASC,GAC/C,SAAS6E,EAAUzF,GAAS,IAAM0F,EAAKF,EAAUG,KAAK3F,IAAW,MAAOlC,GAAK8C,EAAO9C,IACpF,SAAS8H,EAAS5F,GAAS,IAAM0F,EAAKF,EAAiB,MAAExF,IAAW,MAAOlC,GAAK8C,EAAO9C,IACvF,SAAS4H,EAAKG,GAJlB,IAAe7F,EAIa6F,EAAOC,KAAOnF,EAAQkF,EAAO7F,QAJ1CA,EAIyD6F,EAAO7F,MAJhDA,aAAiBuF,EAAIvF,EAAQ,IAAIuF,GAAE,SAAU5E,GAAWA,EAAQX,OAIT+F,KAAKN,EAAWG,GAClGF,GAAMF,EAAYA,EAAUQ,MAAMX,EAASC,GAAc,KAAKK,YAI/D,SAASiC,EAAYnB,EAASjC,EAAMqD,GACvC,OAAO,EAAUhK,UAAM,OAAQ,GAAQ,YACnC,IAAK,MAAMiK,KAAYD,EAAS,CAE5B,MAAM7H,EAAQ6H,EAAQC,GACtB,GAAc,WAAV9H,EAAoB,OACdyG,EAAQO,OAAOc,GACrB,SAEJ,MAAMC,QAAiBtB,EAAQjE,IAAIsF,GACnC,GAAuB,YAAnBC,EAASpB,MACT,SAEJ,MAAMqB,QAAiBhI,EAAM+H,EAAUvD,GACtB,WAAbwD,EAIa,WAAbA,UAGEvB,EAAQK,IAAIgB,EAAUE,UANlBvB,EAAQO,OAAOc,OCzBrC,IAAI,EAAwC,SAAUzC,EAASC,EAAYC,EAAGC,GAE1E,OAAO,IAAKD,IAAMA,EAAI7E,WAAU,SAAUC,EAASC,GAC/C,SAAS6E,EAAUzF,GAAS,IAAM0F,EAAKF,EAAUG,KAAK3F,IAAW,MAAOlC,GAAK8C,EAAO9C,IACpF,SAAS8H,EAAS5F,GAAS,IAAM0F,EAAKF,EAAiB,MAAExF,IAAW,MAAOlC,GAAK8C,EAAO9C,IACvF,SAAS4H,EAAKG,GAJlB,IAAe7F,EAIa6F,EAAOC,KAAOnF,EAAQkF,EAAO7F,QAJ1CA,EAIyD6F,EAAO7F,MAJhDA,aAAiBuF,EAAIvF,EAAQ,IAAIuF,GAAE,SAAU5E,GAAWA,EAAQX,OAIT+F,KAAKN,EAAWG,GAClGF,GAAMF,EAAYA,EAAUQ,MAAMX,EAASC,GAAc,KAAKK,YAO/D,SAASsC,EAA2B/B,GAMvC,MAAMgC,EAAiB,EAAGzB,QAAAA,EAASG,QAAAA,GAAWuB,IAAe,EAAUtK,UAAM,OAAQ,GAAQ,YACzF,IAAIuG,QAEEqC,EAAQO,OAAOmB,GAEU,QAA9B/D,EAAKwC,EAAQuB,UAAgC,IAAP/D,GAAyBA,EAAGxD,OAAO,aACnEgG,EAAQuB,MAEbhC,EAAenB,GAAa,EAAUnH,UAAM,OAAQ,GAAQ,YAC9D,IAAIoJ,EAAImB,EACJC,EAIJ,GAHArD,EAASsB,GAA0C,QAApCW,GAAMoB,EAAKrD,EAASb,QAAQmC,UAAuB,IAAPW,EAAgBA,EAAMoB,EAAG/B,GAAKJ,EAAMK,YAAYvB,EAASb,QACzF,QAA1BiE,EAAKpD,EAASC,cAA2B,IAAPmD,IAAsBpD,EAASC,QAAS,GAEvED,EAASC,OACT,OAAOD,EAIX,IAAKA,EAASb,OAAOD,MACjB,OAAOrE,OAAOsF,OAAOtF,OAAOsF,OAAO,GAAIH,GAAW,CAAEC,QAAQ,IAEhE,MAAMqD,EAActD,EAASb,OAAOD,MAC9BA,QAAcgC,EAAMO,QAAQjE,IAAIwC,EAASsB,IAC/C,GAEgB,UAAhBpC,EAAMyC,OACc,UAAhBzC,EAAMyC,OAEU,WAAhBzC,EAAMyC,MACN,OAAO3B,EAGX,IAECd,EAAMM,cACK8C,EAAmBtC,EAAUsD,EAAYC,iBAEjD,aADML,EAAehC,EAAOlB,EAASsB,IAC9BtB,SAGJA,EAAS/B,QAAQF,EAAOyF,wBACxBxD,EAAS/B,QAAQF,EAAO0F,yBAC3BH,EAAYjE,OAA6B,IAArBiE,EAAYjE,OAChCW,EAAS/B,QAAQF,EAAOyF,iBAAmBF,EAAYjE,MAEvDiE,EAAYhE,gBACZU,EAAS/B,QAAQF,EAAO0F,0BACU,IAA9BH,EAAYhE,cACN,sBACAgE,EAAYhE,cAAcQ,eAExC,IAAI4D,EAAMJ,EAAYI,MAAQ,EAC9B,GAAIJ,MAAAA,OAAiD,EAASA,EAAYK,gBAAiB,CACvF,MAAMC,EAAiB1C,EAAM2C,kBAAkB7D,EAAS/B,SAExD,GAAuB,eAAnB2F,EAEA,aADMV,EAAehC,EAAOlB,EAASsB,IAC9BtB,EAEX0D,EAAyB,uBAAnBE,EAA0CF,EAAME,EAE1D,MAAMpE,EAAOO,EAAeC,EAAUd,EAAMM,MACzB,mBAARkE,IACPA,QAAYA,EAAI1D,IAEpB,MAAM8D,EAAW,CACbnC,MAAO,SACP+B,IAAAA,EACA7D,UAAW9D,KAAK0C,MAChBe,KAAAA,IAGA8D,MAAAA,OAAiD,EAASA,EAAYS,gBAChEnB,EAAY1B,EAAMO,QAASzB,EAAUsD,EAAYS,SAE3D,MAAMtI,EAAWyF,EAAMU,QAAQ5B,EAASsB,IAOxC,OALA7F,MAAAA,GAAoDA,EAASE,QAAQmI,EAAStE,aACvE0B,EAAMU,QAAQ5B,EAASsB,UAExBJ,EAAMO,QAAQK,IAAI9B,EAASsB,GAAIwC,GAE9B9D,KAEX,MAAO,CACHmB,YAAAA,EACAH,MAAO,IAAME,EAAMiB,aAAanC,SAASqC,IAAIlB,IC1GrD,IAAI,EAAwC,SAAUd,EAASC,EAAYC,EAAGC,GAE1E,OAAO,IAAKD,IAAMA,EAAI7E,WAAU,SAAUC,EAASC,GAC/C,SAAS6E,EAAUzF,GAAS,IAAM0F,EAAKF,EAAUG,KAAK3F,IAAW,MAAOlC,GAAK8C,EAAO9C,IACpF,SAAS8H,EAAS5F,GAAS,IAAM0F,EAAKF,EAAiB,MAAExF,IAAW,MAAOlC,GAAK8C,EAAO9C,IACvF,SAAS4H,EAAKG,GAJlB,IAAe7F,EAIa6F,EAAOC,KAAOnF,EAAQkF,EAAO7F,QAJ1CA,EAIyD6F,EAAO7F,MAJhDA,aAAiBuF,EAAIvF,EAAQ,IAAIuF,GAAE,SAAU5E,GAAWA,EAAQX,OAIT+F,KAAKN,EAAWG,GAClGF,GAAMF,EAAYA,EAAUQ,MAAMX,EAASC,GAAc,KAAKK,YAItE,MAAMc,EAAUzI,SAEHgL,EAAavG,KAAUA,KAASA,EAAIgE,GAkB1C,SAASwC,GAAa,IAAEnC,EAAG,KAAEoC,EAAI,OAAElC,IACtC,MAAO,CAEH,CAACP,GAAU,EACXK,IAAAA,EACAE,OAAAA,EACAxE,IAAMD,GAAQ,EAAU1E,UAAM,OAAQ,GAAQ,YAC1C,MAAMmC,QAAckJ,EAAK3G,GACzB,IAAKvC,EACD,MAAO,CAAE2G,MAAO,SAEpB,GAEgB,WAAhB3G,EAAM2G,OACF3G,EAAM6E,UAAY7E,EAAM0I,IAAM3H,KAAK0C,MACnC,OAAOzD,EAEX,GAAIA,EAAMwE,KAAKvB,UACVF,EAAO0B,QAAQzE,EAAMwE,KAAKvB,SACvBF,EAAO6B,gBAAgB5E,EAAMwE,KAAKvB,SAClCF,EAAOyF,mBAAmBxI,EAAMwE,KAAKvB,SACrCF,EAAO0F,2BAA2BzI,EAAMwE,KAAKvB,SAAU,CAC3D,MAAMkG,EAAQ,CACV3E,KAAMxE,EAAMwE,KACZmC,MAAO,QACP9B,UAAW7E,EAAM6E,WAGrB,aADMiC,EAAIvE,EAAK4G,GACRA,EAGX,aADMnC,EAAOzE,GACN,CAAEoE,MAAO,aCtCrB,SAASyC,IACZ,MAAM5E,EAAO,GACPiC,EAAUwC,EAAa,CACzBC,KAAO3G,GAAQiC,EAAKjC,GACpBuE,IAAK,CAACvE,EAAKvC,KACPwE,EAAKjC,GAAOvC,GAEhBgH,OAASzE,WACEiC,EAAKjC,MAGpB,OAAO1C,OAAOsF,OAAOtF,OAAOsF,OAAO,GAAIsB,GAAU,CAAEjC,KAAAA,I,aChCvD,MAAM6E,EAAgB,WACf,SAASC,EAAkBC,EAAM/D,GACpC,OAAQ4B,IACJ,GAAIA,EAAQd,GACR,OAAOc,EAAQd,GAGnBc,EAAQoC,UAAYpC,EAAQoC,QAAUpC,EAAQoC,QAAQpJ,QAAQiJ,EAAe,KAC7EjC,EAAQqC,MAAQrC,EAAQqC,IAAMrC,EAAQqC,IAAIrJ,QAAQiJ,EAAe,KAEjEjC,EAAQpD,SAAWoD,EAAQpD,OAASoD,EAAQpD,OAAO7D,eACnD,MAAM0F,EAASL,EAAU4B,GACzB,OAAOmC,GAAO,IAAA1H,MAAKgE,GAAQ3E,WAAa2E,GAGzC,MAAM6D,EAAsBJ,GAAkB,GAAM,EAAGE,QAAAA,EAAU,GAAIC,IAAAA,EAAM,GAAIzF,OAAAA,EAAS,MAAO2F,OAAAA,EAAQnF,KAAAA,MACnG,CACHiF,IAAKD,GAAWA,GAAWC,EAAM,IAAM,IAAMA,EAC7CzF,OAAAA,EACA2F,OAAQA,EACRnF,KAAAA,MCtBR,IAAIoF,EAAkC,SAAUxL,EAAGN,GAC/C,IAAIK,EAAI,GACR,IAAK,IAAI0L,KAAKzL,EAAOyB,OAAO8C,UAAUC,eAAeC,KAAKzE,EAAGyL,IAAM/L,EAAEgM,QAAQD,GAAK,IAC9E1L,EAAE0L,GAAKzL,EAAEyL,IACb,GAAS,MAALzL,GAAqD,mBAAjCyB,OAAOkK,sBACtB,KAAI9J,EAAI,EAAb,IAAgB4J,EAAIhK,OAAOkK,sBAAsB3L,GAAI6B,EAAI4J,EAAErJ,OAAQP,IAC3DnC,EAAEgM,QAAQD,EAAE5J,IAAM,GAAKJ,OAAO8C,UAAUqH,qBAAqBnH,KAAKzE,EAAGyL,EAAE5J,MACvE9B,EAAE0L,EAAE5J,IAAM7B,EAAEyL,EAAE5J,KAE1B,OAAO9B,GA4CJ,SAAS8L,EAAW/D,EAAO9B,EAAK,IACnC,IAAI,QAAEqC,EAAO,YAAEF,EAAW,QAAEK,EAAO,kBAAEiC,EAAiB,mBAAEqB,EAAkB,oBAAEC,GAAwB/F,EAAIgG,EAAeR,EAAOxF,EAAI,CAAC,UAAW,cAAe,UAAW,oBAAqB,qBAAsB,wBACnN,MAAMiG,EAAanE,EAEnB,GADAmE,EAAW5D,QAAUA,GAAW2C,KAC3BJ,EAAUqB,EAAW5D,SACtB,MAAM,IAAI6D,MAAM,+BAcpB,OAZAD,EAAW9D,YAAcA,GAAemD,EACxCW,EAAWzD,QAAUA,GAAW,GAChCyD,EAAWxB,kBAAoBA,GAAqB7F,EACpDqH,EAAWH,mBACPA,GAAsBjE,EAA0BoE,GACpDA,EAAWF,oBACPA,GAAuBlC,EAA2BoC,GAEtDA,EAAWjE,SAAWvG,OAAOsF,OAAOtF,OAAOsF,OAAO,GAAIe,EAAME,UAAW,CAAElC,MAAOrE,OAAOsF,OAAO,CAAEuD,IAAK,IAAeC,iBAAiB,EAAOtC,QAAS,CAAC,OAAQkC,eAAgB,CAAEf,YAAc5D,GAAWA,GAAU,KAAOA,EAAS,KAAOS,MAAM,EAAOC,eAAe,EAAOyE,OAAQ,IAAMqB,KAE3RC,EAAWH,mBAAmBlE,QAC9BqE,EAAWF,oBAAoBnE,QACxBqE,ECpDJ,SAASE,EAAgB9D,EAAS+D,EAAS,IAC9C,OAAOvB,EAAa,CAChBC,KAAO3G,IACH,MAAMkI,EAAOhE,EAAQiE,QAAQF,EAASjI,GACtC,OAAOkI,EAAOlJ,KAAK5B,MAAM8K,QAAQtI,GAErC2E,IAAK,CAACvE,EAAKvC,KACPyG,EAAQkE,QAAQH,EAASjI,EAAKhB,KAAKC,UAAUxB,KAEjDgH,OAASzE,IACLkE,EAAQmE,WAAWJ,EAASjI,Q","sources":["webpack://AxiosCacheInterceptor/webpack/universalModuleDefinition","webpack://AxiosCacheInterceptor/./node_modules/cache-parser/index.min.js","webpack://AxiosCacheInterceptor/./node_modules/fast-defer/index.min.js","webpack://AxiosCacheInterceptor/./node_modules/object-code/index.min.js","webpack://AxiosCacheInterceptor/webpack/bootstrap","webpack://AxiosCacheInterceptor/webpack/runtime/define property getters","webpack://AxiosCacheInterceptor/webpack/runtime/hasOwnProperty shorthand","webpack://AxiosCacheInterceptor/webpack/runtime/make namespace object","webpack://AxiosCacheInterceptor/./src/util/headers.ts","webpack://AxiosCacheInterceptor/./src/header/interpreter.ts","webpack://AxiosCacheInterceptor/./src/interceptors/util.ts","webpack://AxiosCacheInterceptor/./src/interceptors/request.ts","webpack://AxiosCacheInterceptor/./src/util/cache-predicate.ts","webpack://AxiosCacheInterceptor/./src/util/update-cache.ts","webpack://AxiosCacheInterceptor/./src/interceptors/response.ts","webpack://AxiosCacheInterceptor/./src/storage/build.ts","webpack://AxiosCacheInterceptor/./src/storage/memory.ts","webpack://AxiosCacheInterceptor/./src/util/key-generator.ts","webpack://AxiosCacheInterceptor/./src/cache/create.ts","webpack://AxiosCacheInterceptor/./src/storage/web-api.ts"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"AxiosCacheInterceptor\"] = factory();\n\telse\n\t\troot[\"AxiosCacheInterceptor\"] = factory();\n})(typeof self === 'undefined' ? this : self, function() {\nreturn ","!function(e){var a=Symbol(\"cache-parser\"),r=Number;function t(e){return(\"string\"==typeof e||\"number\"==typeof e)&&(e=r(e))>=0&&e<1/0}function s(e){return\"number\"==typeof e||!0===e||\"string\"==typeof e&&\"false\"!==e}e.__internal={isDuration:t,toBoolean:s},e.isCacheControl=function(e){return!!e&&!!e[a]},e.tokenize=function(e){if(!e||\"object\"!=typeof e)return[];var a=[];return s(e.immutable)&&a.push(\"immutable\"),t(e.maxAge)&&a.push(\"max-age=\"+r(e.maxAge)),t(e.maxStale)&&a.push(\"max-stale=\"+r(e.maxStale)),t(e.minFresh)&&a.push(\"min-fresh=\"+r(e.minFresh)),s(e.mustRevalidate)&&a.push(\"must-revalidate\"),s(e.mustUnderstand)&&a.push(\"must-understand\"),s(e.noCache)&&a.push(\"no-cache\"),s(e.noStore)&&a.push(\"no-store\"),s(e.noTransform)&&a.push(\"no-transform\"),s(e.onlyIfCached)&&a.push(\"only-if-cached\"),s(e.private)&&a.push(\"private\"),s(e.proxyRevalidate)&&a.push(\"proxy-revalidate\"),s(e.public)&&a.push(\"public\"),t(e.sMaxAge)&&a.push(\"s-maxage=\"+r(e.sMaxAge)),t(e.staleIfError)&&a.push(\"stale-if-error=\"+r(e.staleIfError)),t(e.staleWhileRevalidate)&&a.push(\"stale-while-revalidate=\"+r(e.staleWhileRevalidate)),a},e.parse=function(e){var n=Object.defineProperty({},a,{enumerable:!1,value:1});if(!e||\"string\"!=typeof e)return n;var i={},o=e.toLowerCase().replace(/\\s+/g,\"\").split(\",\");for(var l in o){var u=o[l].split(\"=\",2);i[u[0]]=1===u.length||u[1]}return s(i.immutable)&&(n.immutable=!0),t(i[\"max-age\"])&&(n.maxAge=r(i[\"max-age\"])),t(i[\"max-stale\"])&&(n.maxStale=r(i[\"max-stale\"])),t(i[\"min-fresh\"])&&(n.minFresh=r(i[\"min-fresh\"])),s(i[\"must-revalidate\"])&&(n.mustRevalidate=!0),s(i[\"must-understand\"])&&(n.mustUnderstand=!0),s(i[\"no-cache\"])&&(n.noCache=!0),s(i[\"no-store\"])&&(n.noStore=!0),s(i[\"no-transform\"])&&(n.noTransform=!0),s(i[\"only-if-cached\"])&&(n.onlyIfCached=!0),s(i.private)&&(n.private=!0),s(i[\"proxy-revalidate\"])&&(n.proxyRevalidate=!0),s(i.public)&&(n.public=!0),t(i[\"s-maxage\"])&&(n.sMaxAge=r(i[\"s-maxage\"])),t(i[\"stale-if-error\"])&&(n.staleIfError=r(i[\"stale-if-error\"])),t(i[\"stale-while-revalidate\"])&&(n.staleWhileRevalidate=r(i[\"stale-while-revalidate\"])),n}}(\"undefined\"!=typeof exports?exports:window.CacheParser||(window.CacheParser={}));","!function(e){var r=Symbol(\"fast-defer\");e.deferred=function(){var e,n,t=new Promise((function(r,t){e=r,n=t}));return t.resolve=e,t.reject=n,t[r]=1,t},e.isDeferred=function(e){return!!e&&!!e[r]}}(\"undefined\"!=typeof exports?exports:window.FastDefer||(window.FastDefer={}));","!function(r){r.transform=function(t){var n=typeof t;if(\"object\"===n&&t){if(t instanceof Date)return\"#\"+t.getTime();if(t instanceof RegExp)return\"#\"+t.toString();var o=Array.isArray(t)?[]:{};for(var e in t)o[e]=r.transform(t[e]);return\"#\"+String(t.constructor)+JSON.stringify(o,Object.keys(o).sort())}return n+String(t)+(\"symbol\"===n?Math.random():\"\")},r.code=function(t){t=r.transform(t);for(var n=7,o=0;o {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","export var Header;\n(function (Header) {\n /**\n * ```txt\n * If-Modified-Since: , :: GMT\n * ```\n *\n * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/If-Modified-Since\n */\n Header[\"IfModifiedSince\"] = \"if-modified-since\";\n /**\n * ```txt\n * Last-Modified: , :: GMT\n * ```\n *\n * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Last-Modified\n */\n Header[\"LastModified\"] = \"last-modified\";\n /**\n * ```txt\n * If-None-Match: \"\"\n * If-None-Match: \"\", \"\", …\n * If-None-Match: *\n * ```\n *\n * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/If-None-Match\n */\n Header[\"IfNoneMatch\"] = \"if-none-match\";\n /** @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control */\n Header[\"CacheControl\"] = \"cache-control\";\n /**\n * ```txt\n * ETag: W / '';\n * ETag: '';\n * ```\n *\n * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/ETag\n */\n Header[\"ETag\"] = \"etag\";\n /**\n * ```txt\n * Expires: \n * ```\n *\n * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Expires\n */\n Header[\"Expires\"] = \"expires\";\n /**\n * ```txt\n * Age: \n * ```\n *\n * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Age\n */\n Header[\"Age\"] = \"age\";\n /**\n * ```txt\n * Content-Type: text/html; charset=UTF-8\n * Content-Type: multipart/form-data; boundary=something\n * ```\n *\n * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Type\n */\n Header[\"ContentType\"] = \"content-type\";\n /**\n * Used internally to mark the cache item as being revalidatable and enabling stale\n * cache state Contains a string of ASCII characters that can be used as ETag for\n * `If-Match` header Provided by user using `cache.etag` value.\n *\n * ```txt\n * X-Axios-Cache-Etag: \"\"\n * ```\n */\n Header[\"XAxiosCacheEtag\"] = \"x-axios-cache-etag\";\n /**\n * Used internally to mark the cache item as being revalidatable and enabling stale\n * cache state may contain `'use-cache-timestamp'` if `cache.modifiedSince` is `true`,\n * otherwise will contain a date from `cache.modifiedSince`. If a date is provided, it\n * can be used for `If-Modified-Since` header, otherwise the cache timestamp can be used\n * for `If-Modified-Since` header.\n *\n * ```txt\n * X-Axios-Cache-Last-Modified: , :: GMT\n * X-Axios-Cache-Last-Modified: use-cache-timestamp\n * ```\n */\n Header[\"XAxiosCacheLastModified\"] = \"x-axios-cache-last-modified\";\n})(Header || (Header = {}));\n","import { parse } from 'cache-parser';\nimport { Header } from '../util/headers';\nexport const defaultHeaderInterpreter = (headers) => {\n if (!headers)\n return 'not enough headers';\n const cacheControl = headers[Header.CacheControl];\n if (cacheControl) {\n const { noCache, noStore, mustRevalidate, maxAge, immutable } = parse(cacheControl);\n // Header told that this response should not be cached.\n if (noCache || noStore) {\n return 'dont cache';\n }\n if (immutable) {\n // 1 year is sufficient, as Infinity may cause more problems.\n // It might not be the best way, but a year is better than none.\n return 1000 * 60 * 60 * 24 * 365;\n }\n // Already out of date, for cache can be saved, but must be requested again\n if (mustRevalidate) {\n return 0;\n }\n if (maxAge) {\n const age = headers[Header.Age];\n if (!age) {\n return maxAge * 1000;\n }\n return (maxAge - Number(age)) * 1000;\n }\n }\n const expires = headers[Header.Expires];\n if (expires) {\n const milliseconds = Date.parse(expires) - Date.now();\n return milliseconds >= 0 ? milliseconds : 'dont cache';\n }\n return 'not enough headers';\n};\n","import { Header } from '../util/headers';\n/**\n * Creates a new validateStatus function that will use the one already used and also\n * accept status code 304.\n */\nexport function createValidateStatus(oldValidate) {\n return oldValidate\n ? (status) => oldValidate(status) || status === 304\n : (status) => (status >= 200 && status < 300) || status === 304;\n}\n/** Checks if the given method is in the methods array */\nexport function isMethodIn(requestMethod = 'get', methodList = []) {\n requestMethod = requestMethod.toLowerCase();\n for (const method of methodList) {\n if (method.toLowerCase() === requestMethod) {\n return true;\n }\n }\n return false;\n}\nexport function setRevalidationHeaders(cache, config) {\n var _a;\n config.headers || (config.headers = {});\n const { etag, modifiedSince } = config.cache;\n if (etag) {\n const etagValue = etag === true ? (_a = cache.data) === null || _a === void 0 ? void 0 : _a.headers[Header.ETag] : etag;\n if (etagValue) {\n config.headers[Header.IfNoneMatch] = etagValue;\n }\n }\n if (modifiedSince) {\n config.headers[Header.IfModifiedSince] =\n modifiedSince === true\n ? // If last-modified is not present, use the createdAt timestamp\n cache.data.headers[Header.LastModified] ||\n new Date(cache.createdAt).toUTCString()\n : modifiedSince.toUTCString();\n }\n}\n/**\n * Creates the new date to the cache by the provided response. Also handles possible 304\n * Not Modified by updating response properties.\n */\nexport function setupCacheData(response, cache) {\n if (response.status === 304 && cache) {\n // Set the cache information into the response object\n response.cached = true;\n response.data = cache.data;\n response.status = cache.status;\n response.statusText = cache.statusText;\n // Update possible new headers\n response.headers = Object.assign(Object.assign({}, cache.headers), response.headers);\n // return the old cache\n return cache;\n }\n // New Response\n return {\n data: response.data,\n status: response.status,\n statusText: response.statusText,\n headers: response.headers\n };\n}\n","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nimport { deferred } from 'fast-defer';\nimport { createValidateStatus, isMethodIn, setRevalidationHeaders } from './util';\nexport function defaultRequestInterceptor(axios) {\n const onFulfilled = (config) => __awaiter(this, void 0, void 0, function* () {\n var _a;\n if (config.cache === false) {\n return config;\n }\n // merge defaults with per request configuration\n config.cache = Object.assign(Object.assign({}, axios.defaults.cache), config.cache);\n if (!isMethodIn(config.method, config.cache.methods)) {\n return config;\n }\n const key = (config.id = axios.generateKey(config));\n // Assumes that the storage handled staled responses\n let cache = yield axios.storage.get(key);\n // Not cached, continue the request, and mark it as fetching\n emptyOrStale: if (cache.state === 'empty' || cache.state === 'stale') {\n /**\n * This checks for simultaneous access to a new key. The js event loop jumps on the\n * first await statement, so the second (asynchronous call) request may have already\n * started executing.\n */\n if (axios.waiting[key]) {\n cache = (yield axios.storage.get(key));\n break emptyOrStale;\n }\n // Create a deferred to resolve other requests for the same key when it's completed\n axios.waiting[key] = deferred();\n /**\n * Add a default reject handler to catch when the request is aborted without others\n * waiting for it.\n */\n (_a = axios.waiting[key]) === null || _a === void 0 ? void 0 : _a.catch(() => undefined);\n yield axios.storage.set(key, {\n state: 'loading',\n data: cache.data\n });\n if (cache.state === 'stale') {\n setRevalidationHeaders(cache, config);\n }\n config.validateStatus = createValidateStatus(config.validateStatus);\n return config;\n }\n let cachedResponse;\n if (cache.state === 'loading') {\n const deferred = axios.waiting[key];\n // Just in case, the deferred doesn't exists.\n /* istanbul ignore if 'really hard to test' */\n if (!deferred) {\n yield axios.storage.remove(key);\n return config;\n }\n try {\n cachedResponse = yield deferred;\n }\n catch (_b) {\n // The deferred is rejected when the request that we are waiting rejected cache.\n return config;\n }\n }\n else {\n cachedResponse = cache.data;\n }\n //Even though the response interceptor receives this one from here,\n // it has been configured to ignore cached responses = true\n // eslint-disable-next-line @typescript-eslint/require-await\n config.adapter = () => Promise.resolve({\n config,\n data: cachedResponse.data,\n headers: cachedResponse.headers,\n status: cachedResponse.status,\n statusText: cachedResponse.statusText,\n cached: true,\n id: key\n });\n return config;\n });\n return {\n onFulfilled,\n apply: () => axios.interceptors.request.use(onFulfilled)\n };\n}\n","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\n/** Tests an response against a {@link CachePredicateObject}. */\nexport function testCachePredicate(response, predicate) {\n var _a;\n return __awaiter(this, void 0, void 0, function* () {\n if (typeof predicate === 'function') {\n return predicate(response);\n }\n const { statusCheck, responseMatch, containsHeaders } = predicate;\n if ((statusCheck && !(yield statusCheck(response.status))) ||\n (responseMatch && !(yield responseMatch(response)))) {\n return false;\n }\n if (containsHeaders) {\n for (const header in containsHeaders) {\n const predicate = containsHeaders[header];\n if (predicate &&\n !(yield predicate(\n // Axios uses lowercase headers, but if for some reason it doesn't, we should\n // still be able to match.\n (_a = response.headers[header.toLowerCase()]) !== null && _a !== void 0 ? _a : response.headers[header]))) {\n return false;\n }\n }\n }\n return true;\n });\n}\n","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\n/** Function to update all caches, from CacheProperties.update, with the new data. */\nexport function updateCache(storage, data, entries) {\n return __awaiter(this, void 0, void 0, function* () {\n for (const cacheKey in entries) {\n // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n const value = entries[cacheKey];\n if (value === 'delete') {\n yield storage.remove(cacheKey);\n continue;\n }\n const oldValue = yield storage.get(cacheKey);\n if (oldValue.state === 'loading') {\n continue;\n }\n const newValue = yield value(oldValue, data);\n if (newValue === 'delete') {\n yield storage.remove(cacheKey);\n continue;\n }\n if (newValue === 'ignore') {\n continue;\n }\n yield storage.set(cacheKey, newValue);\n }\n });\n}\n","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nimport { testCachePredicate } from '../util/cache-predicate';\nimport { Header } from '../util/headers';\nimport { updateCache } from '../util/update-cache';\nimport { setupCacheData } from './util';\nexport function defaultResponseInterceptor(axios) {\n /**\n * Rejects cache for an response response.\n *\n * Also update the waiting list for this key by rejecting it.\n */\n const rejectResponse = ({ storage, waiting }, responseId) => __awaiter(this, void 0, void 0, function* () {\n var _a;\n // Update the cache to empty to prevent infinite loading state\n yield storage.remove(responseId);\n // Reject the deferred if present\n (_a = waiting[responseId]) === null || _a === void 0 ? void 0 : _a.reject(null);\n delete waiting[responseId];\n });\n const onFulfilled = (response) => __awaiter(this, void 0, void 0, function* () {\n var _b, _c;\n var _d;\n response.id = (_b = (_d = response.config).id) !== null && _b !== void 0 ? _b : (_d.id = axios.generateKey(response.config));\n (_c = response.cached) !== null && _c !== void 0 ? _c : (response.cached = false);\n // Response is already cached\n if (response.cached) {\n return response;\n }\n // Skip cache: either false or weird behavior\n // config.cache should always exists, at least from global config merge.\n if (!response.config.cache) {\n return Object.assign(Object.assign({}, response), { cached: false });\n }\n const cacheConfig = response.config.cache;\n const cache = yield axios.storage.get(response.id);\n if (\n // If the request interceptor had a problem\n cache.state === 'stale' ||\n cache.state === 'empty' ||\n // Should not hit here because of previous response.cached check\n cache.state === 'cached') {\n return response;\n }\n // Config told that this response should be cached.\n if (\n // For 'loading' values (post stale), this check was already run in the past.\n !cache.data &&\n !(yield testCachePredicate(response, cacheConfig.cachePredicate))) {\n yield rejectResponse(axios, response.id);\n return response;\n }\n // avoid remnant headers from remote server to break implementation\n delete response.headers[Header.XAxiosCacheEtag];\n delete response.headers[Header.XAxiosCacheLastModified];\n if (cacheConfig.etag && cacheConfig.etag !== true) {\n response.headers[Header.XAxiosCacheEtag] = cacheConfig.etag;\n }\n if (cacheConfig.modifiedSince) {\n response.headers[Header.XAxiosCacheLastModified] =\n cacheConfig.modifiedSince === true\n ? 'use-cache-timestamp'\n : cacheConfig.modifiedSince.toUTCString();\n }\n let ttl = cacheConfig.ttl || -1; // always set from global config\n if (cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.interpretHeader) {\n const expirationTime = axios.headerInterpreter(response.headers);\n // Cache should not be used\n if (expirationTime === 'dont cache') {\n yield rejectResponse(axios, response.id);\n return response;\n }\n ttl = expirationTime === 'not enough headers' ? ttl : expirationTime;\n }\n const data = setupCacheData(response, cache.data);\n if (typeof ttl === 'function') {\n ttl = yield ttl(response);\n }\n const newCache = {\n state: 'cached',\n ttl,\n createdAt: Date.now(),\n data\n };\n // Update other entries before updating himself\n if (cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.update) {\n yield updateCache(axios.storage, response, cacheConfig.update);\n }\n const deferred = axios.waiting[response.id];\n // Resolve all other requests waiting for this response\n deferred === null || deferred === void 0 ? void 0 : deferred.resolve(newCache.data);\n delete axios.waiting[response.id];\n // Define this key as cache on the storage\n yield axios.storage.set(response.id, newCache);\n // Return the response with cached as false, because it was not cached at all\n return response;\n });\n return {\n onFulfilled,\n apply: () => axios.interceptors.response.use(onFulfilled)\n };\n}\n","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nimport { Header } from '../util/headers';\nconst storage = Symbol();\n/** Returns true if the provided object was created from {@link buildStorage} function. */\nexport const isStorage = (obj) => !!obj && !!obj[storage];\n/**\n * Builds a custom storage.\n *\n * **Note**: You can only create an custom storage with this function.\n *\n * @example\n *\n * ```js\n * const myStorage = buildStorage({\n * find: () => {...},\n * set: () => {...},\n * remove: () => {...}\n * });\n *\n * const axios = setupCache(axios, { storage: myStorage });\n * ```\n */\nexport function buildStorage({ set, find, remove }) {\n return {\n //@ts-expect-error - we don't want to expose this\n [storage]: 1,\n set,\n remove,\n get: (key) => __awaiter(this, void 0, void 0, function* () {\n const value = yield find(key);\n if (!value) {\n return { state: 'empty' };\n }\n if (\n // Not cached or fresh value\n value.state !== 'cached' ||\n value.createdAt + value.ttl > Date.now()) {\n return value;\n }\n if (value.data.headers &&\n (Header.ETag in value.data.headers ||\n Header.LastModified in value.data.headers ||\n Header.XAxiosCacheEtag in value.data.headers ||\n Header.XAxiosCacheLastModified in value.data.headers)) {\n const stale = {\n data: value.data,\n state: 'stale',\n createdAt: value.createdAt\n };\n yield set(key, stale);\n return stale;\n }\n yield remove(key);\n return { state: 'empty' };\n })\n };\n}\n","import { buildStorage } from './build';\n/**\n * Creates a simple in-memory storage. This means that if you need to persist data between\n * page or server reloads, this will not help.\n *\n * This is the storage used by default.\n *\n * If you need to modify it's data, you can do by the `data` property.\n *\n * @example\n *\n * ```js\n * const memoryStorage = buildMemoryStorage();\n *\n * setupCache(axios, { storage: memoryStorage });\n *\n * // Simple example to force delete the request cache\n *\n * const { id } = axios.get('url');\n *\n * delete memoryStorage.data[id];\n * ```\n */\nexport function buildMemoryStorage() {\n const data = {};\n const storage = buildStorage({\n find: (key) => data[key],\n set: (key, value) => {\n data[key] = value;\n },\n remove: (key) => {\n delete data[key];\n }\n });\n return Object.assign(Object.assign({}, storage), { data });\n}\n","import { code } from 'object-code';\n// Remove first and last '/' char, if present\nconst SLASHES_REGEX = /^\\/|\\/$/g;\nexport function buildKeyGenerator(hash, generator) {\n return (request) => {\n if (request.id) {\n return request.id;\n }\n // Remove trailing slashes\n request.baseURL && (request.baseURL = request.baseURL.replace(SLASHES_REGEX, ''));\n request.url && (request.url = request.url.replace(SLASHES_REGEX, ''));\n // lowercase method\n request.method && (request.method = request.method.toLowerCase());\n const result = generator(request);\n return hash ? code(result).toString() : result;\n };\n}\nexport const defaultKeyGenerator = buildKeyGenerator(true, ({ baseURL = '', url = '', method = 'get', params, data }) => {\n return {\n url: baseURL + (baseURL && url ? '/' : '') + url,\n method,\n params: params,\n data\n };\n});\n","var __rest = (this && this.__rest) || function (s, e) {\n var t = {};\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n t[p] = s[p];\n if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n t[p[i]] = s[p[i]];\n }\n return t;\n};\nimport { defaultHeaderInterpreter } from '../header/interpreter';\nimport { defaultRequestInterceptor } from '../interceptors/request';\nimport { defaultResponseInterceptor } from '../interceptors/response';\nimport { isStorage } from '../storage/build';\nimport { buildMemoryStorage } from '../storage/memory';\nimport { defaultKeyGenerator } from '../util/key-generator';\n/**\n * Apply the caching interceptors for a already created axios instance.\n *\n * @example\n *\n * ```ts\n * import Axios from 'axios';\n * import { setupCache, AxiosCacheInstance } from 'axios-cache-interceptor';\n *\n * // instance will have our custom typings from the return of this function\n * const instance = setupCache(\n * Axios.create({\n * // Axios options\n * }),\n * {\n * // Axios-cache-interceptor options\n * }\n * );\n *\n * // OR\n *\n * const instance = axios.create({\n * // Axios options\n * }) as AxiosCacheInstance;\n *\n * // As this functions returns the same axios instance but only with\n * // different typings, you can ignore the function return.\n * setupCache(instance, {\n * // Axios-cache-interceptor options\n * });\n * ```\n *\n * @param axios The already created axios instance\n * @param config The config for the caching interceptors\n * @returns The same instance with extended typescript types.\n */\nexport function setupCache(axios, _a = {}) {\n var { storage, generateKey, waiting, headerInterpreter, requestInterceptor, responseInterceptor } = _a, cacheOptions = __rest(_a, [\"storage\", \"generateKey\", \"waiting\", \"headerInterpreter\", \"requestInterceptor\", \"responseInterceptor\"]);\n const axiosCache = axios;\n axiosCache.storage = storage || buildMemoryStorage();\n if (!isStorage(axiosCache.storage)) {\n throw new Error('Use buildStorage() function');\n }\n axiosCache.generateKey = generateKey || defaultKeyGenerator;\n axiosCache.waiting = waiting || {};\n axiosCache.headerInterpreter = headerInterpreter || defaultHeaderInterpreter;\n axiosCache.requestInterceptor =\n requestInterceptor || defaultRequestInterceptor(axiosCache);\n axiosCache.responseInterceptor =\n responseInterceptor || defaultResponseInterceptor(axiosCache);\n // CacheRequestConfig values\n axiosCache.defaults = Object.assign(Object.assign({}, axios.defaults), { cache: Object.assign({ ttl: 1000 * 60 * 5, interpretHeader: false, methods: ['get'], cachePredicate: { statusCheck: (status) => status >= 200 && status < 400 }, etag: false, modifiedSince: false, update: {} }, cacheOptions) });\n // Apply interceptors\n axiosCache.requestInterceptor.apply();\n axiosCache.responseInterceptor.apply();\n return axiosCache;\n}\n","import { buildStorage } from './build';\n/**\n * Creates a simple storage. You can persist his data by using `sessionStorage` or\n * `localStorage` with it.\n *\n * **ImplNote**: Without polyfill, this storage only works on browser environments.\n *\n * @example\n *\n * ```js\n * const fromLocalStorage = buildWebStorage(localStorage);\n * const fromSessionStorage = buildWebStorage(sessionStorage);\n *\n * const myStorage = new Storage();\n * const fromMyStorage = buildWebStorage(myStorage);\n * ```\n *\n * @param prefix The prefix to index the storage. Useful to prevent collision between\n * multiple places using the same storage.\n */\nexport function buildWebStorage(storage, prefix = '') {\n return buildStorage({\n find: (key) => {\n const json = storage.getItem(prefix + key);\n return json ? JSON.parse(json) : undefined;\n },\n set: (key, value) => {\n storage.setItem(prefix + key, JSON.stringify(value));\n },\n remove: (key) => {\n storage.removeItem(prefix + key);\n }\n });\n}\n"],"names":["root","factory","exports","module","define","amd","self","this","e","a","Symbol","r","Number","t","s","__internal","isDuration","toBoolean","isCacheControl","tokenize","immutable","push","maxAge","maxStale","minFresh","mustRevalidate","mustUnderstand","noCache","noStore","noTransform","onlyIfCached","private","proxyRevalidate","public","sMaxAge","staleIfError","staleWhileRevalidate","parse","n","Object","defineProperty","enumerable","value","i","o","toLowerCase","replace","split","l","u","length","deferred","Promise","resolve","reject","isDeferred","transform","Date","getTime","RegExp","toString","Array","isArray","String","constructor","JSON","stringify","keys","sort","Math","random","code","charCodeAt","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","undefined","__webpack_modules__","d","definition","key","get","obj","prop","prototype","hasOwnProperty","call","toStringTag","Header","defaultHeaderInterpreter","headers","cacheControl","CacheControl","age","Age","expires","Expires","milliseconds","now","createValidateStatus","oldValidate","status","isMethodIn","requestMethod","methodList","method","setRevalidationHeaders","cache","config","_a","etag","modifiedSince","etagValue","data","ETag","IfNoneMatch","IfModifiedSince","LastModified","createdAt","toUTCString","setupCacheData","response","cached","statusText","assign","__awaiter","thisArg","_arguments","P","generator","fulfilled","step","next","rejected","result","done","then","apply","defaultRequestInterceptor","axios","onFulfilled","defaults","methods","id","generateKey","cachedResponse","storage","emptyOrStale","state","waiting","catch","set","validateStatus","remove","_b","adapter","interceptors","request","use","testCachePredicate","predicate","statusCheck","responseMatch","containsHeaders","header","updateCache","entries","cacheKey","oldValue","newValue","defaultResponseInterceptor","rejectResponse","responseId","_c","_d","cacheConfig","cachePredicate","XAxiosCacheEtag","XAxiosCacheLastModified","ttl","interpretHeader","expirationTime","headerInterpreter","newCache","update","isStorage","buildStorage","find","stale","buildMemoryStorage","SLASHES_REGEX","buildKeyGenerator","hash","baseURL","url","defaultKeyGenerator","params","__rest","p","indexOf","getOwnPropertySymbols","propertyIsEnumerable","setupCache","requestInterceptor","responseInterceptor","cacheOptions","axiosCache","Error","buildWebStorage","prefix","json","getItem","setItem","removeItem"],"sourceRoot":""}