{"version":3,"file":"54.373cad104ee47fae449b.js","mappings":"0IAAA,IAAaA,EACS,oBAAXC,OACDA,OAAO,mBADb,EAEM,CAAC,GAAC,kBAAkB,KAEjBC,EACS,oBAAXD,QAA0BA,OAAOE,IAClCF,OAAOE,IAAI,mBACX,qBAEGC,EACS,oBAAXH,QAA0BA,OAAOE,IAClCF,OAAOE,IAAI,eACX,iBAEV,SAAgBE,EAAQC,G,QACXA,KAAWA,EAAMF,E,CAG9B,SAAgBG,EAAYD,G,IACnBA,GAA0B,iBAAVA,EAAoB,OAAO,E,GAC5CE,MAAMC,QAAQH,GAAQ,OAAO,E,IAC3BI,EAAQC,OAAOC,eAAeN,G,OAC/BI,GAASA,IAAUC,OAAOE,aACtBP,EAAMJ,MAAgBI,EAAMQ,YAAYZ,E,CAUrD,IAAaa,EACTJ,OAAOI,QACP,SAAgBC,EAAQV,G,IACfW,IAAIC,KAAOZ,EACRa,EAAIb,EAAOY,KACXF,EAAOE,GAAOZ,EAAMY,I,OAGrBF,C,EAGFI,EACU,oBAAZC,SAA2BA,QAAQD,QACpCC,QAAQD,aACgC,IAAjCT,OAAOW,sBAAd,SACAC,GAAAA,OACIZ,OAAOa,oBAAoBD,GAAKE,OAC5Bd,OAAOW,sBAAsBC,GADjC,EAGJZ,OAAOa,oBAEjB,SAAgBE,EAAYC,EAAMC,G,mBAAgB,GAC1CpB,MAAMC,QAAQkB,GAAO,OAAOA,EAAKE,Q,IAC/BC,EAAQnB,OAAOoB,OAAOpB,OAAOC,eAAee,I,OAClDP,EAAQO,GAAMK,SAAd,SAAsBd,G,GACdA,IAAQd,E,KAGN6B,EAAOtB,OAAOuB,yBAAyBP,EAAMT,GAC9CZ,EAAAA,EAAAA,M,GACD2B,EAAKE,IAAK,C,IACLP,E,MACK,IAAIQ,MAAM,gDAEpB9B,EAAQ2B,EAAKE,IAAIE,KAAKV,E,CAEtBM,EAAKK,WACLR,EAAMZ,GAAOZ,EAEbK,OAAO4B,eAAeT,EAAOZ,EAAK,C,MAC9BZ,EACAkC,UAAU,EACVC,cAAc,G,KAInBX,C,CAGX,SAAgBY,EAAKpC,EAAOqC,G,GACpBnC,MAAMC,QAAQH,G,IACTW,IAAI2B,EAAI,EAAGA,EAAItC,EAAMuC,OAAQD,IAAKD,EAAGC,EAAGtC,EAAMsC,GAAItC,QAEvDc,EAAQd,GAAO0B,SAAf,SAAuBd,GAAAA,OAAOyB,EAAGzB,EAAKZ,EAAMY,GAAMZ,EAAlB,G,CAIxC,SAAgBwC,EAAanB,EAAMoB,G,IACzBd,EAAOtB,OAAOuB,yBAAyBP,EAAMoB,G,QAC1Cd,GAAQA,EAAKK,U,CAG1B,SAAgBnB,EAAI6B,EAAOD,G,OAChBpC,OAAOE,UAAUoC,eAAeZ,KAAKW,EAAOD,E,CAGvD,SAAgBG,EAAGC,EAAGC,G,OAEdD,IAAMC,EACO,IAAND,GAAW,EAAIA,GAAM,EAAIC,EAEzBD,GAAMA,GAAKC,GAAMA,C,CCtGhC,IAAaC,EACTvC,SAAYwC,G,KACHC,OAAS,G,KACTD,OAASA,E,KAITE,eAAgB,E,KAGhBC,QAAU,I,EA0BvB,SAASC,EAAOC,GACZA,EAAMvD,GAAasD,Q,CAzBnBE,EAAAA,UAAAA,WAAAA,SAAWC,GACHA,I,KACKJ,QAAU,G,KACVK,eAAiB,G,KACjBD,cAAgBA,E,EAG7BH,EAAAA,UAAAA,OAAAA,W,KACSK,Q,KACAR,OAAOvB,QAAQ0B,G,KACfH,OAAS,I,EAElBQ,EAAAA,UAAAA,MAAAA,WACQC,OAASX,EAAWY,UACpBZ,EAAWY,QAAUD,KAAKV,O,EAKtCD,EAAWY,QAAU,KACrBZ,EAAWa,MAAQ,W,OACPF,KAAKC,QAAU,IAAIZ,EAAWW,KAAKC,Q,ECrB/CE,IAAMC,EAAc,CAAC,EA+CrB,SAASV,I,KACAW,SAAU,C,CAGnB,SAASC,EAAOC,G,OACLA,EAAMC,MAAQD,EAAM5C,I,CAI/B,SAAS8C,EAAKd,EAAOZ,G,IACXwB,EAAQZ,EAAMvD,G,GAChBmE,IAAUA,EAAMG,WAAY,CAC5BH,EAAMG,YAAa,E,IACbpE,EAAQqD,EAAMZ,G,OACpBwB,EAAMG,YAAa,EACZpE,C,QAEJqD,EAAMZ,E,CA0BjB,SAAS4B,EAAYJ,GACZA,EAAMK,WACPL,EAAMK,UAAW,EACbL,EAAMjB,QAAQqB,EAAYJ,EAAMjB,Q,CAI5C,SAASuB,EAAYN,GACZA,EAAMC,OAAMD,EAAMC,KAAOM,EAAoBP,EAAM5C,M,CAG5D,SAASmD,EAAoBnD,G,IACnB4C,EAAQ5C,GAAQA,EAAKvB,G,GACvBmE,EAAO,CACPA,EAAMG,YAAa,E,IACbf,EAAQjC,EAAY6C,EAAMZ,OAAO,G,OACvCY,EAAMG,YAAa,EACZf,C,QAEJjC,EAAYC,E,CAsBvB,SAASoD,EAAgBR,G,IACC,IAAlBA,EAAMF,QACN,MAAM,IAAIjC,MACN,uHACI4C,KAAKC,UAAUX,EAAOC,I,CAKtC,SAASW,EAAiB3B,G,IAKjBtC,IAAI2B,EAAIW,EAAOV,OAAS,EAAGD,GAAK,EAAGA,IAAK,C,IACnC2B,EAAQhB,EAAOX,GAAGxC,GACnBmE,EAAMK,WACHpE,MAAMC,QAAQ8D,EAAM5C,MAChBwD,EAAgBZ,IAAQI,EAAYJ,GACjCa,EAAiBb,IAAQI,EAAYJ,G,EAK5D,SAASc,EAAuBC,G,GACvBA,GAA4B,iBAAXA,E,KAChBf,EAAQe,EAAOlF,G,GAChBmE,E,cACQZ,EAAAA,EAAAA,MAAO4B,EAAAA,EAAAA,S,GACf/E,MAAMC,QAAQ6E,IAoBZ,GAAIH,EAAgBZ,GAAQ,C,GAC/BI,EAAYJ,GACZgB,EAAS1C,QAAS,EACdc,EAAMd,OAASlB,EAAKkB,O,IACf5B,IAAI2B,EAAIe,EAAMd,OAAQD,EAAIjB,EAAKkB,OAAQD,IAAK2C,EAAS3C,IAAK,O,IAE1D3B,IAAI2B,EAAIjB,EAAKkB,OAAQD,EAAIe,EAAMd,OAAQD,IAAK2C,EAAS3C,IAAK,E,IAE9D3B,IAAI2B,EAAI,EAAGA,EAAIe,EAAMd,OAAQD,SAEV4C,IAAhBD,EAAS3C,IAAkByC,EAAuB1B,EAAMf,G,OA5BhEjC,OAAO8E,KAAK9B,GAAO3B,SAAnB,SAA2Bd,QAELsE,IAAd7D,EAAKT,IAAuBC,EAAIQ,EAAMT,GAG9BqE,EAASrE,IAEjBmE,EAAuB1B,EAAMzC,KAJ7BqE,EAASrE,IAAO,EAChByD,EAAYJ,G,IAOpB5D,OAAO8E,KAAK9D,GAAMK,SAAlB,SAA0Bd,QAEHsE,IAAf7B,EAAMzC,IAAuBC,EAAIwC,EAAOzC,KACxCqE,EAASrE,IAAO,EAChByD,EAAYJ,G,GAnBZ,CAF+B,C,CAuC/C,SAASa,EAAiBb,G,iBACTZ,EAAAA,EAAAA,MAIP8B,EAAO9E,OAAO8E,KAAK9B,GAChBf,EAAI6C,EAAK5C,OAAS,EAAGD,GAAK,EAAGA,IAAK,C,IACjC1B,EAAMuE,EAAK7C,GACX8C,EAAY/D,EAAKT,G,QAELsE,IAAdE,IAA4BvE,EAAIQ,EAAMT,G,OAC/B,E,IAKDZ,EAAQqD,EAAMzC,GACdqD,EAAQjE,GAASA,EAAMF,G,GACzBmE,EAAQA,EAAM5C,OAAS+D,GAAaxC,EAAG5C,EAAOoF,G,OACvC,C,QAOZD,EAAK5C,SAAWlC,OAAO8E,KAAK9D,GAAMkB,M,CAG7C,SAASsC,EAAgBZ,GACdZ,IAAAA,EAAAA,EAAAA,M,GACHA,EAAMd,SAAW0B,EAAM5C,KAAKkB,OAAQ,OAAO,E,IAQzC8C,EAAahF,OAAOuB,yBAAyByB,EAAOA,EAAMd,OAAS,G,SAErE8C,GAAeA,EAAWxD,I,mCA1OlC,SAA6ByD,EAAOC,EAAQC,GACxCF,EAAMrC,OAAOvB,SAAb,SAAqB2B,GACjBA,EAAMvD,GAAasE,YAAa,C,IAE/BoB,EAQIzF,EAAQwF,IAAWA,EAAOzF,GAAawF,QAAUA,GACtDV,EAAiBU,EAAMrC,SARnBqC,EAAMnC,SACN4B,EAAuBO,EAAMrC,OAAO,IAGxC2B,EAAiBU,EAAMrC,Q,cAQ/B,SAAgBwC,EAAYpE,EAAM2B,G,IACxB7C,EAAUD,MAAMC,QAAQkB,GACxBgC,EAAQmB,EAAoBnD,GAClCe,EAAKiB,GAAD,SAAQZ,IA0FhB,SAAuBY,EAAOZ,EAAMT,G,IAC5BL,EAAOmC,EAAYrB,GACnBd,EACAA,EAAKK,WAAaA,EAElB8B,EAAYrB,GAAQd,EAAO,CACvBQ,cAAc,E,WACdH,EACAH,IAAAA,W,OArDZ,SAAaoC,EAAOxB,GAChBgC,EAAgBR,G,IACVjE,EAAQmE,EAAKH,EAAOC,GAAQxB,G,OAC9BwB,EAAMG,WAAmBpE,EAEzBA,IAAUmE,EAAKF,EAAM5C,KAAMoB,IAASxC,EAAYD,IAChDuE,EAAYN,GACJA,EAAMC,KAAKzB,GAAQgD,EAAYzF,EAAOiE,IAE3CjE,C,CA6CY6B,CAAI6B,KAAK5D,GAAc2C,E,EAElCiD,IAAAA,SAAI1F,IA5ChB,SAAaiE,EAAOxB,EAAMzC,G,GACtByE,EAAgBR,GAChBA,EAAMgB,SAASxC,IAAQ,GAClBwB,EAAMK,SAAU,C,GACb1B,EAAG5C,EAAOmE,EAAKH,EAAOC,GAAQxB,IAAQ,OAC1C4B,EAAYJ,GACZM,EAAYN,E,CAEhBA,EAAMC,KAAKzB,GAAQzC,C,CAqCP0F,CAAIhC,KAAK5D,GAAc2C,EAAMzC,E,GAIzCK,OAAO4B,eAAeoB,EAAOZ,EAAMd,E,CAzG/BgE,CAActC,EAAOZ,EAAMtC,GAAWqC,EAAanB,EAAMoB,G,QA0NnC/B,EAAQ+B,EAAMzC,EAtNlCsF,EAAQtC,EAASA,EAAOsC,MAAQvC,EAAWY,Q,OAsNvBjD,EAvML2C,EAuMaZ,EAvMN3C,EAuMYE,EArN1B,C,MACVsF,EACAhB,UAAU,EACVF,YAAY,EACZwB,WAAW,EACXX,SAAU,CAAC,E,OACXjC,E,KACA3B,E,MACAgC,EACAa,KAAM,K,OACNd,EACAW,SAAS,GA2Mb1D,OAAO4B,eAAevB,EAAQ+B,EAAM,CAChCzC,MAAOA,EACPgC,YAAY,EACZE,UAAU,IA1MdoD,EAAMrC,OAAO4C,KAAKxC,GACXA,C,IC3CX,SAAgBoC,EAAYpE,EAAM2B,G,IACxBsC,EAAQtC,EAASA,EAAOsC,MAAQvC,EAAWY,QAC3CM,EAAQ,C,MAEVqB,EAEAhB,UAAU,EAEVsB,WAAW,EAEXX,SAAU,CAAC,E,OAEXjC,E,KAEA3B,EAEAgC,MAAO,KAEPJ,OAAQ,CAAC,EAETiB,KAAM,KAENd,OAAQ,M,EAGYlD,MAAMC,QAAQkB,GAGhCyE,MAAMC,UAAU,CAAC9B,GAAQ+B,GACzBF,MAAMC,UAAU9B,EAAOgC,GAJtB7C,EAAAA,EAAAA,OAAQ8C,EAAAA,EAAAA,M,OAMfjC,EAAMZ,MAAQ6C,EACdjC,EAAMb,OAASA,EAEfkC,EAAMrC,OAAO4C,KAAKK,GACXA,C,CAGXrC,IAAMoC,EAAc,C,IAyDpB,SAAahC,EAAOxB,G,GACZA,IAAS3C,EAAa,OAAOmE,EAC5BhB,IAAAA,EAAAA,EAAAA,O,IAGAgB,EAAMK,UAAYzD,EAAIoC,EAAQR,G,OACxBQ,EAAOR,G,IAGZzC,EAAQgE,EAAOC,GAAOxB,G,GACxBwB,EAAM2B,YAAc3F,EAAYD,G,OACzBA,E,GAIPiE,EAAMK,SAAU,C,GAEZtE,IAAUmE,EAAKF,EAAM5C,KAAMoB,GAAO,OAAOzC,EAE7CiD,EAASgB,EAAMC,I,QAGXjB,EAAOR,GAAQgD,EAAYzF,EAAOiE,E,EA7E1CpD,IAAAA,SAAIH,EAAQ+B,G,OACDA,KAAQuB,EAAOtD,E,EAE1BI,QAAAA,SAAQJ,G,OACGK,QAAQD,QAAQkD,EAAOtD,G,MA4EtC,SAAauD,EAAOxB,EAAMzC,G,IACjBiE,EAAMK,SAAU,C,IACXc,EAAYjB,EAAKF,EAAM5C,KAAMoB,G,GAIfzC,EACd4C,EAAGwC,EAAWpF,IAAUA,IAAUiE,EAAMhB,OAAOR,GAC/CG,EAAGwC,EAAWpF,IAAUyC,KAAQwB,EAAM5C,KAC3B,OAAO,EACxBgD,EAAYJ,E,QAEhBA,EAAMgB,SAASxC,IAAQ,EACvBwB,EAAMC,KAAKzB,GAAQzC,GACZ,C,iBAGX,SAAwBiE,EAAOxB,G,YAEIyC,IAA3Bf,EAAKF,EAAM5C,KAAMoB,IAAuBA,KAAQwB,EAAM5C,QACtD4C,EAAMgB,SAASxC,IAAQ,EACvB4B,EAAYJ,IAEZA,EAAMC,aAAaD,EAAMC,KAAKzB,IAC3B,C,2BAKX,SAAkCwB,EAAOxB,G,IAC/B0D,EAAQnC,EAAOC,GACftC,EAAOZ,QAAQa,yBAAyBuE,EAAO1D,G,OACjDd,IACAA,EAAKO,UAAW,EAChBP,EAAKQ,cAAgBjC,MAAMC,QAAQgG,IAAmB,WAAT1D,GAE1Cd,C,EA3GPM,eAAAA,W,MACU,IAAIH,MAAM,2D,EAEpBxB,eAAAA,SAAeI,G,OACJL,OAAOC,eAAeI,EAAOW,K,EAExC+E,eAAAA,W,MACU,IAAItE,MAAM,2D,GAIlBkE,EAAa,CAAC,EAqBpB,SAAShC,EAAOC,G,OACLA,EAAMC,MAAQD,EAAM5C,I,CAI/B,SAAS8C,EAAKd,EAAOZ,G,IACXwB,EAAQZ,EAAMvD,GACd6B,EAAOZ,QAAQa,yBACjBqC,EAAQD,EAAOC,GAASZ,EACxBZ,G,OAEGd,GAAQA,EAAK3B,K,CAmExB,SAASqE,EAAYJ,GACZA,EAAMK,WACPL,EAAMK,UAAW,EACjBL,EAAMC,KAAOzD,EAAOW,EAAY6C,EAAM5C,MAAO4C,EAAMhB,QACnDgB,EAAMhB,OAAS,KACXgB,EAAMjB,QAAQqB,EAAYJ,EAAMjB,Q,CAvG5CZ,EAAK6D,GAAD,SAAerF,EAAKyF,GACpBL,EAAWpF,GAAO,W,OACd0F,UAAU,GAAKA,UAAU,GAAG,GACrBD,EAAGE,MAAM7C,KAAM4C,U,KAG9BN,EAAWQ,eAAiB,SAASvC,EAAOxB,G,GACpCgE,MAAMC,SAASjE,I,MACT,IAAIX,MAAM,8C,OAEbmE,EAAYO,eAAezE,KAAK2B,KAAMO,EAAM,GAAIxB,E,EAE3DuD,EAAWN,IAAM,SAASzB,EAAOxB,EAAMzC,G,GACtB,WAATyC,GAAqBgE,MAAMC,SAASjE,I,MAC9B,IAAIX,MAAM,uE,OAEbmE,EAAYP,IAAI3D,KAAK2B,KAAMO,EAAM,GAAIxB,EAAMzC,E,oCA/E/C,WAAyB,E,gBCkFhC,SAAgB2G,EAAatD,EAAOF,G,IAC3BxC,IAAI2B,EAAI,EAAGA,EAAIa,EAAQZ,OAAQD,IAAK,C,IAC/BsE,EAAQzD,EAAQb,GACfuE,EAAAA,EAAAA,K,GACa,IAAhBA,EAAKtE,QAA6B,YAAbqE,EAAME,GAC3BzD,EAAQuD,EAAM5G,UACX,C,QACCqB,EAAOgC,EACFf,EAAI,EAAGA,EAAIuE,EAAKtE,OAAS,EAAGD,I,KACjCjB,EAAOA,EAAKwF,EAAKvE,MACY,iBAATjB,EAChB,MAAM,IAAIS,MAAM,6CAA+C+E,EAAKE,KAAK,M,IAE3EnG,EAAMiG,EAAKA,EAAKtE,OAAS,G,OACvBqE,EAAME,I,IACL,UACDzF,EAAKT,GAAOgG,EAAM5G,M,UAEjB,MACGE,MAAMC,QAAQkB,GAEdA,EAAK2F,OAAOpG,EAAK,EAAGgG,EAAM5G,OAE1BqB,EAAKT,GAAOgG,EAAM5G,M,UAGrB,SACGE,MAAMC,QAAQkB,GACdA,EAAK2F,OAAOpG,EAAK,UAEVS,EAAKT,G,oBAIV,IAAIkB,MAAM,gCAAkC8E,EAAME,I,SAIjEzD,C,CCnHXQ,IAAMoD,EAAiB,CACnBC,WAA6B,oBAAVpB,OAA4C,oBAAZ/E,QACnDoG,WACuB,oBAAZC,SAEuB,mBAPtC,WAA2B,EAOEC,KACzBC,SAAU,KACVC,SAAU,KACVC,OAAQ,MAGCC,EACTjH,SAAYkH,G,EACDhE,KAAMuD,EAAgBS,G,KACxBC,cAAcjE,KAAKwD,Y,KACnBU,QAAUlE,KAAKkE,QAAQC,KAAKnE,K,EAErCkE,EAAAA,UAAAA,QAAAA,SAAQvG,EAAMyG,EAAQvE,G,IAsBdgC,E,UApBgB,mBAATlE,GAAyC,mBAAXyG,EAAuB,C,IACtDC,EAAcD,E,EACXzG,E,IAEH2G,EAAOtE,K,OACN,SAAwBrC,G,0BAAO0G,G,qEAC3BC,EAAKJ,QAAQvG,GAAb,SAAmBgC,GAAAA,OAASyE,EAAO/F,KAAAA,MAAP+F,EAAA,CAAYpE,EAAML,GAAlB,OAA4B4E,GAA5B,G,KAMjB,mBAAXH,E,MACD,IAAIhG,MAAM,gE,QAEEoD,IAAlB3B,GAAwD,mBAAlBA,E,MAChC,IAAIzB,MAAM,mE,GAOpB7B,EAAYoB,GAAO,C,IACbiE,EAAQvC,EAAWa,QACnBsC,EAAQxC,KAAK+B,YAAYpE,GAC3B6G,GAAW,E,IAEX3C,EAASuC,EAAO5B,G,GACL,C,CAFf,QAKQgC,EAAU5C,EAAMlC,SACfkC,EAAM7B,O,QAEX8B,aAAkB4C,QACX5C,EAAO6C,MAAP,SACH7C,G,OACID,EAAMhC,WAAWC,GACVG,EAAK2E,cAAc9C,EAAQD,E,IAHnC,SAKHgD,G,MACIhD,EAAMlC,SACAkF,C,KAIlBhD,EAAMhC,WAAWC,GACVG,KAAK2E,cAAc9C,EAAQD,G,aAGnBJ,KADfK,EAASuC,EAAOzG,IACiBA,EAC1BkE,IAAW7F,EAAU6F,OAASL,C,EAG7CqD,EAAAA,UAAAA,YAAAA,SAAYlH,G,IACHpB,EAAYoB,G,MACP,IAAIS,MAAM,4F,IAEdwD,EAAQvC,EAAWa,QACnBsC,EAAQxC,KAAK+B,YAAYpE,G,SACzBvB,GAAa0I,UAAW,EAC9BlD,EAAM7B,QACCyC,C,EAEXuC,EAAAA,UAAAA,YAAAA,SAAYpF,EAAOE,G,IACTU,EAAQZ,GAASA,EAAMvD,G,IACxBmE,IAAUA,EAAMuE,S,MACX,IAAI1G,MAAM,6E,GAEhBmC,EAAM2B,U,MACA,IAAI9D,MAAM,wCAEbwD,IAAAA,EAAAA,EAAAA,M,OACPA,EAAMhC,WAAWC,GACVG,KAAK2E,mBAAcnD,EAAWI,E,EAEzCoD,EAAAA,UAAAA,cAAAA,SAAc1I,G,KACLmH,WAAanH,C,EAEtB2H,EAAAA,UAAAA,cAAAA,SAAc3H,G,KACLkH,WAAalH,E,EACX0D,KAAM1D,EAAQ2I,EAAcC,E,EAEvCjC,EAAAA,UAAAA,aAAAA,SAAatF,EAAM8B,G,OAEXpD,EAAQsB,GACDsF,EAAatF,EAAM8B,GAGvBO,KAAKkE,QAAQvG,GAAb,SAAmBgC,GAAAA,OAASsD,EAAatD,EAAOF,EAAR,G,EAGnDkF,EAAAA,UAAAA,cAAAA,SAAc9C,EAAQD,G,IACZuD,EAAYvD,EAAMrC,OAAO,GACzBuC,OAAwBN,IAAXK,GAAwBA,IAAWsD,E,QACjDC,aAAaxD,EAAOC,EAAQC,GAC7BA,EAAY,C,GACRqD,EAAU/I,GAAawE,S,MACvBgB,EAAMlC,SACA,IAAItB,MAAM,qHAEhB7B,EAAYsF,KAEZA,EAAS7B,KAAKqF,SAASxD,EAAQ,KAAMD,IAErCA,EAAMnC,UACNmC,EAAMnC,QAAQ0C,KAAK,C,GACX,U,KACE,G,MACCN,IAEXD,EAAM9B,eAAeqC,KAAK,C,GAClB,U,KACE,GACN7F,MAAO6I,EAAU/I,GAAauB,O,MAKtCkE,EAAS7B,KAAKqF,SAASF,EAAW,GAAIvD,G,OAE1CA,EAAMlC,SACFkC,EAAMnC,SACNmC,EAAM/B,cAAc+B,EAAMnC,QAASmC,EAAM9B,gBAEtC+B,IAAW7F,EAAU6F,OAASL,C,EAOzC6D,EAAAA,UAAAA,SAAAA,SAAS1F,EAAOwD,EAAMvB,G,WACZrB,EAAQZ,EAAMvD,G,IACfmE,E,OACG5D,OAAO2I,SAAS3F,GAAeA,EAC5BK,KAAKuF,aAAa5F,EAAO,KAAMiC,G,GAGtCrB,EAAMqB,QAAUA,E,OACTjC,E,IAENY,EAAMK,S,OACAL,EAAM5C,K,IAEZ4C,EAAM2B,UAAW,C,GAClB3B,EAAM2B,WAAY,E,KACbqD,aAAahF,EAAMZ,MAAOwD,EAAMvB,GAEjC5B,KAAK6D,S,GAED7D,KAAKwD,WAAY,CACVjC,IAAAA,EAAAA,EAAAA,S,IACFpB,IAAMpB,KAAQwC,EACVA,EAASxC,IAAOiB,KAAK6D,SAAStD,EAAOxB,E,KAE3C,C,aACUyB,EAAAA,EAAAA,KACb9B,EAAKf,GAAD,SAAOoB,GACF5B,EAAIqD,EAAMzB,IAAOiB,EAAK6D,SAAStD,EAAOxB,E,IAInDiB,KAAK8D,Q,KACAA,OAAOvD,GAKZP,KAAKyD,YAAc7B,EAAMpC,e,OAClBgG,OAAOjF,EAAMC,MAGpB2C,GAAQvB,EAAMnC,SDlNvB,SAAyBc,EAAOkF,EAAUhG,EAASK,GACtDtD,MAAMC,QAAQ8D,EAAM5C,MAKxB,SAA8B4C,EAAOkF,EAAUhG,EAASK,G,iBACzCU,EAAAA,EAAAA,KAAMe,EAAAA,EAAAA,SAGbf,EAAK3B,OAASlB,EAAKkB,SACjBlB,G,EAAc,CAAC6C,EAAM7C,IAArBA,GAAM6C,EAAAA,EAAAA,GACNf,G,EAA2B,CAACK,EAAgBL,IAA5CA,GAASK,EAAAA,EAAAA,I,QAGT4F,EAAQlF,EAAK3B,OAASlB,EAAKkB,OAG7B8G,EAAQ,EACLhI,EAAKgI,KAAWnF,EAAKmF,IAAUA,EAAQhI,EAAKkB,UAC7C8G,E,QAIFC,EAAMjI,EAAKkB,OACR+G,EAAMD,GAAShI,EAAKiI,EAAM,KAAOpF,EAAKoF,EAAMF,EAAQ,MACrDE,E,IAID3I,IAAI2B,EAAI+G,EAAO/G,EAAIgH,IAAOhH,E,GACvB2C,EAAS3C,IAAM4B,EAAK5B,KAAOjB,EAAKiB,GAAI,C,IAC9BuE,EAAOsC,EAAShI,OAAO,CAACmB,IAC9Ba,EAAQ0C,KAAK,CACTiB,GAAI,U,KACJD,EACA7G,MAAOkE,EAAK5B,KAEhBkB,EAAeqC,KAAK,CAChBiB,GAAI,U,KACJD,EACA7G,MAAOqB,EAAKiB,I,SAKlBiH,EAAYD,GAAOjI,EAAKkB,OACxBiH,EAAerG,EAAQZ,OAGpBD,EAAIgH,EAAMF,EAAQ,EAAG9G,GAAKgH,IAAOhH,EAAG,C,IACnCuE,EAAOsC,EAAShI,OAAO,CAACmB,IAC9Ba,EAAQqG,EAAelH,EAAIgH,GAAO,CAC9BxC,GAAI,M,KACJD,EACA7G,MAAOkE,EAAK5B,IAEZiH,GACA/F,EAAeqC,KAAK,CAChBiB,GAAI,S,KACJD,G,CAMP0C,GACD/F,EAAeqC,KAAK,CAChBiB,GAAI,UACJD,KAAMsC,EAAShI,OAAO,CAAC,WACvBnB,MAAOqB,EAAKkB,Q,CApEdkH,CAAqBxF,EAAOkF,EAAUhG,EAASK,GAyEzD,SAA+BS,EAAOkF,EAAUhG,EAASK,G,aACxCU,EAAAA,EAAAA,KACb9B,EAAK6B,EAAMgB,UAAP,SAAkBrE,EAAK8I,G,IACjBC,EAAYtI,EAAKT,GACjBZ,EAAQkE,EAAKtD,GACbkG,EAAM4C,EAA2B9I,KAAOS,EAAO,UAAY,MAArC,S,GACxBsI,IAAc3J,GAAgB,YAAP8G,E,KACrBD,EAAOsC,EAAShI,OAAOP,GAC7BuC,EAAQ0C,KAAY,WAAPiB,EAAkB,C,GAACA,E,KAAID,GAAQ,C,GAACC,E,KAAID,E,MAAM7G,IACvDwD,EAAeqC,KACJ,QAAPiB,EACM,CAACA,GAAI,S,KAAUD,GACR,WAAPC,EACA,CAACA,GAAI,M,KAAOD,EAAM7G,MAAO2J,GACzB,CAAC7C,GAAI,U,KAAWD,EAAM7G,MAAO2J,GARM,C,IA9E3CC,CAAsB3F,EAAOkF,EAAUhG,EAASK,E,CCgN1CqG,CACI5F,EACA4C,EACAvB,EAAMnC,QACNmC,EAAM9B,e,QAIXS,EAAMC,I,EAMjB+E,EAAAA,UAAAA,aAAAA,SAAaa,EAAMC,EAAUzE,G,WACnBrB,EAAQ6F,EAAKhK,GACfmE,IACKP,KAAKwD,aAENjD,EAAMC,KAAO9C,EAAY6C,EAAMZ,OAAO,IAE1CyG,EAAO7F,EAAMC,M,IAGX8F,IAAgBD,KAAczE,EAAMnC,QACpC8G,EAAmB,SAACxH,EAAMzC,EAAOgD,G,GAC/BhD,IAAUgD,E,MACJlB,MAAM,qC,IAIVoI,IAAgBjG,GAASjB,IAAW8G,E,GAEtC/J,EAAQC,GAAQ,C,IACV6G,EACFqD,GAAeF,IAAgB/F,EAAMgB,SAASxC,GACxCsH,EAAS5I,OAAOsB,GAChB,K,GAMN1C,EAHJC,EAAQ0D,EAAKqF,SAAS/I,EAAO6G,EAAMvB,MAI/BA,EAAMpC,eAAgB,GAItBhD,MAAMC,QAAQ6C,IAAWR,EAAaQ,EAAQP,GAC9CO,EAAOP,GAAQzC,EAEfK,OAAO4B,eAAee,EAAQP,EAAM,C,MAACzC,IAIrCkK,GAAelK,IAAUiE,EAAM5C,KAAKoB,GAAO,M,KAG9C,IAAIyH,GAAetH,EAAG5C,EAAOiE,EAAM5C,KAAKoB,I,OAIpCxC,EAAYD,KAAWK,OAAO2I,SAAShJ,IAC5CoC,EAAKpC,EAAOiK,E,CAGZC,GAAexG,EAAK4D,U,EACfA,SAASrD,EAAOxB,EAAMzC,E,SAInCoC,EAAK0H,EAAMG,GACJH,C,EC3RfjG,IAAMsG,EAAQ,IAAI1C,EAqBLG,EAAUuC,EAAMvC,QAQAuC,EAAMzB,cAAcb,KAAKsC,GAQzBA,EAAMxC,cAAcE,KAAKsC,GAO1BA,EAAMxD,aAAakB,KAAKsC,GAMzBA,EAAM5B,YAAYV,KAAKsC,GAUvBA,EAAM1B,YAAYZ,KAAKsC,G,wBCxClDC,EAAQ,EApBR,SAA+BC,GAE3B,IADA,IAAIC,EAAS,IAAIC,gBACRC,EAAK,EAAGC,EAAKpK,OAAO8E,KAAKkF,GAAOG,EAAKC,EAAGlI,OAAQiI,IAAM,CAC3D,IAAI5J,EAAM6J,EAAGD,GACb,GAAItK,MAAMC,QAAQkK,EAAKzJ,IACnB,IAAK,IAAI8J,EAAK,EAAGC,EAAKN,EAAKzJ,GAAM8J,EAAKC,EAAGpI,OAAQmI,IAAM,CACnD,IAAIE,EAAOD,EAAGD,GACVE,SACAN,EAAOO,OAAOjK,EAAKgK,EAE3B,MAGkB,OAAdP,EAAKzJ,SAA+BsE,IAAdmF,EAAKzJ,IAC3B0J,EAAOO,OAAOjK,EAAKyJ,EAAKzJ,GAGpC,CACA,OAAO0J,CACX,C,sFCpBO,SAASQ,EAAQC,GACpB,OAAOC,MAAMD,EAAK,CAAEE,YAAa,eACrC,CACO,SAASC,EAASH,EAAKV,EAAMc,GAChC,MAAMC,EAAWD,EAAcA,IAAgB,KACzCE,EAAU,CACZ,eAAgB,sBACZD,GAAY,CAAE,CAACA,EAASE,YAAaF,EAASG,eAEtD,OAAOP,MAAMD,EAAK,CACdS,OAAQ,OACRC,KAAM/G,KAAKC,UAAU0F,GACrBgB,QAASA,EACTJ,YAAa,eAErB,CACO,SAASS,EAAaX,EAAKV,EAAMc,GACpC,MAAMC,EAAWD,EAAcA,IAAgB,KACzCE,EAAU,IACRD,GAAY,CAAE,CAACA,EAASE,YAAaF,EAASG,eAEtD,OAAOP,MAAMD,EAAK,CACdS,OAAQ,OACRC,KAAMpB,EACNgB,QAASA,EACTJ,YAAa,eAErB,CACO,SAASU,EAAYZ,EAAKV,GAC7B,MAAMC,EAAUD,aAAgBE,gBAAmBF,GAAO,OAAsBA,GAEhF,OADmCU,EAAIa,QAAQ,MAAQ,EAEdb,EAAIa,QAAQ,MAAQb,EAAIxI,OAAS,EAChCwI,EAAMT,EAAOuB,WAAad,EAAM,IAAMT,EAAOuB,WAG5Ed,EAAM,IAAMT,EAAOuB,UAClC,CACO,SAASC,EAA0BC,EAASC,GAC/C,OAAOD,EAAQE,OAAOC,IAElB,MADAF,EAAcG,qBACRD,CAAM,IAEX9D,MAAKgE,MAAOC,IACb,GAAIA,EAASC,GACT,OAAOD,EAASE,OAEf,GAAwB,MAApBF,EAASG,OAEd,MADAR,EAAcS,iBACRJ,EAASG,OAEd,GAAwB,MAApBH,EAASG,OAAgB,CAC9B,MAAME,QAAqBL,EAASE,OAEpC,MADAP,EAAcW,eAAeD,GAAcE,SACrCP,EAASG,MACnB,CACK,GAAwB,MAApBH,EAASG,OAEd,MADAR,EAAca,iBACRR,EAASG,OAEd,CACD,MAAME,QAAqBL,EAASE,OAEpC,MADAP,EAAcc,eAAeJ,GAAcE,SACrCP,EAASG,MACnB,KAECpE,MAAMsE,GAAiBA,GAChC,C,kDCnEO,MAAMK,EACT,WAAAvM,CAAYwM,GACR,MAAM,YAAE7B,KAAgBa,GAAkBgB,EAC1CtJ,KAAKyH,YAAcA,EACnBzH,KAAKsI,cAAgBA,CACzB,CACA,OAAAlB,CAAQC,EAAKkC,GACT,OAAIA,EACOA,EAAmBC,6BAA6B,KAAcnC,GAAMrH,KAAKsI,eAC3E5D,MAAK7C,GACDA,EAAO4H,aAKD,IAAIhF,SAAQiF,QAJZ7H,EAAOA,SASf,KAAgC,KAAcwF,GAAMrH,KAAKsI,cAExE,CACA,eAAAqB,CAAgBtC,EAAKV,EAAM4C,GACvB,OAAOvJ,KAAKoH,QAAQ,IAAkBC,EAAKV,GAAO4C,EACtD,CACA,QAAA/B,CAASH,EAAKV,EAAM4C,GAChB,OAAIA,EACOA,EAAmBC,6BAA6B,KAAenC,EAAKV,EAAM3G,KAAKyH,aAAczH,KAAKsI,eAAe5D,MAAK7C,GACpHA,EAAO4H,aAKD,IAAIhF,SAAQiF,QAJZ7H,EAAOA,SASf,KAAgC,KAAewF,EAAKV,EAAM3G,KAAKyH,aAAczH,KAAKsI,cAEjG,CACA,YAAAN,CAAaX,EAAKV,GACd,OAAO,KAAgC,KAAmBU,EAAKV,EAAM3G,KAAKyH,aAAczH,KAAKsI,cACjG,E,mBC7CG,SAASsB,EAAOA,GACnBC,SAASC,iBAAiB,eAAgBC,IACtCH,EAAOG,EAAEC,OAAO,GAExB,C","sources":["webpack://matrix-licensor/./node_modules/immer/src/common.js","webpack://matrix-licensor/./node_modules/immer/src/scope.js","webpack://matrix-licensor/./node_modules/immer/src/es5.js","webpack://matrix-licensor/./node_modules/immer/src/proxy.js","webpack://matrix-licensor/./node_modules/immer/src/patches.js","webpack://matrix-licensor/./node_modules/immer/src/immer.js","webpack://matrix-licensor/./node_modules/immer/src/index.js","webpack://matrix-licensor/./node_modules/pbs-stdlib/urls.js","webpack://matrix-licensor/./node_modules/spry-react/utils/fetchExtensions.js","webpack://matrix-licensor/./node_modules/spry-react/utils/fetchWithStandardErrorHandling.js","webpack://matrix-licensor/./node_modules/spry-react/utils/onLoad.js"],"sourcesContent":["export const NOTHING =\n    typeof Symbol !== \"undefined\"\n        ? Symbol(\"immer-nothing\")\n        : {[\"immer-nothing\"]: true}\n\nexport const DRAFTABLE =\n    typeof Symbol !== \"undefined\" && Symbol.for\n        ? Symbol.for(\"immer-draftable\")\n        : \"__$immer_draftable\"\n\nexport const DRAFT_STATE =\n    typeof Symbol !== \"undefined\" && Symbol.for\n        ? Symbol.for(\"immer-state\")\n        : \"__$immer_state\"\n\nexport function isDraft(value) {\n    return !!value && !!value[DRAFT_STATE]\n}\n\nexport function isDraftable(value) {\n    if (!value || typeof value !== \"object\") return false\n    if (Array.isArray(value)) return true\n    const proto = Object.getPrototypeOf(value)\n    if (!proto || proto === Object.prototype) return true\n    return !!value[DRAFTABLE] || !!value.constructor[DRAFTABLE]\n}\n\nexport function original(value) {\n    if (value && value[DRAFT_STATE]) {\n        return value[DRAFT_STATE].base\n    }\n    // otherwise return undefined\n}\n\nexport const assign =\n    Object.assign ||\n    function assign(target, value) {\n        for (let key in value) {\n            if (has(value, key)) {\n                target[key] = value[key]\n            }\n        }\n        return target\n    }\n\nexport const ownKeys =\n    typeof Reflect !== \"undefined\" && Reflect.ownKeys\n        ? Reflect.ownKeys\n        : typeof Object.getOwnPropertySymbols !== \"undefined\"\n        ? obj =>\n              Object.getOwnPropertyNames(obj).concat(\n                  Object.getOwnPropertySymbols(obj)\n              )\n        : Object.getOwnPropertyNames\n\nexport function shallowCopy(base, invokeGetters = false) {\n    if (Array.isArray(base)) return base.slice()\n    const clone = Object.create(Object.getPrototypeOf(base))\n    ownKeys(base).forEach(key => {\n        if (key === DRAFT_STATE) {\n            return // Never copy over draft state.\n        }\n        const desc = Object.getOwnPropertyDescriptor(base, key)\n        let {value} = desc\n        if (desc.get) {\n            if (!invokeGetters) {\n                throw new Error(\"Immer drafts cannot have computed properties\")\n            }\n            value = desc.get.call(base)\n        }\n        if (desc.enumerable) {\n            clone[key] = value\n        } else {\n            Object.defineProperty(clone, key, {\n                value,\n                writable: true,\n                configurable: true\n            })\n        }\n    })\n    return clone\n}\n\nexport function each(value, cb) {\n    if (Array.isArray(value)) {\n        for (let i = 0; i < value.length; i++) cb(i, value[i], value)\n    } else {\n        ownKeys(value).forEach(key => cb(key, value[key], value))\n    }\n}\n\nexport function isEnumerable(base, prop) {\n    const desc = Object.getOwnPropertyDescriptor(base, prop)\n    return !!desc && desc.enumerable\n}\n\nexport function has(thing, prop) {\n    return Object.prototype.hasOwnProperty.call(thing, prop)\n}\n\nexport function is(x, y) {\n    // From: https://github.com/facebook/fbjs/blob/c69904a511b900266935168223063dd8772dfc40/packages/fbjs/src/core/shallowEqual.js\n    if (x === y) {\n        return x !== 0 || 1 / x === 1 / y\n    } else {\n        return x !== x && y !== y\n    }\n}\n","import {DRAFT_STATE} from \"./common\"\n\n/** Each scope represents a `produce` call. */\nexport class ImmerScope {\n    constructor(parent) {\n        this.drafts = []\n        this.parent = parent\n\n        // Whenever the modified draft contains a draft from another scope, we\n        // need to prevent auto-freezing so the unowned draft can be finalized.\n        this.canAutoFreeze = true\n\n        // To avoid prototype lookups:\n        this.patches = null\n    }\n    usePatches(patchListener) {\n        if (patchListener) {\n            this.patches = []\n            this.inversePatches = []\n            this.patchListener = patchListener\n        }\n    }\n    revoke() {\n        this.leave()\n        this.drafts.forEach(revoke)\n        this.drafts = null // Make draft-related methods throw.\n    }\n    leave() {\n        if (this === ImmerScope.current) {\n            ImmerScope.current = this.parent\n        }\n    }\n}\n\nImmerScope.current = null\nImmerScope.enter = function() {\n    return (this.current = new ImmerScope(this.current))\n}\n\nfunction revoke(draft) {\n    draft[DRAFT_STATE].revoke()\n}\n","\"use strict\"\nimport {\n    each,\n    has,\n    is,\n    isDraft,\n    isDraftable,\n    isEnumerable,\n    shallowCopy,\n    DRAFT_STATE\n} from \"./common\"\nimport {ImmerScope} from \"./scope\"\n\n// property descriptors are recycled to make sure we don't create a get and set closure per property,\n// but share them all instead\nconst descriptors = {}\n\nexport function willFinalize(scope, result, isReplaced) {\n    scope.drafts.forEach(draft => {\n        draft[DRAFT_STATE].finalizing = true\n    })\n    if (!isReplaced) {\n        if (scope.patches) {\n            markChangesRecursively(scope.drafts[0])\n        }\n        // This is faster when we don't care about which attributes changed.\n        markChangesSweep(scope.drafts)\n    }\n    // When a child draft is returned, look for changes.\n    else if (isDraft(result) && result[DRAFT_STATE].scope === scope) {\n        markChangesSweep(scope.drafts)\n    }\n}\n\nexport function createProxy(base, parent) {\n    const isArray = Array.isArray(base)\n    const draft = clonePotentialDraft(base)\n    each(draft, prop => {\n        proxyProperty(draft, prop, isArray || isEnumerable(base, prop))\n    })\n\n    // See \"proxy.js\" for property documentation.\n    const scope = parent ? parent.scope : ImmerScope.current\n    const state = {\n        scope,\n        modified: false,\n        finalizing: false, // es5 only\n        finalized: false,\n        assigned: {},\n        parent,\n        base,\n        draft,\n        copy: null,\n        revoke,\n        revoked: false // es5 only\n    }\n\n    createHiddenProperty(draft, DRAFT_STATE, state)\n    scope.drafts.push(draft)\n    return draft\n}\n\nfunction revoke() {\n    this.revoked = true\n}\n\nfunction source(state) {\n    return state.copy || state.base\n}\n\n// Access a property without creating an Immer draft.\nfunction peek(draft, prop) {\n    const state = draft[DRAFT_STATE]\n    if (state && !state.finalizing) {\n        state.finalizing = true\n        const value = draft[prop]\n        state.finalizing = false\n        return value\n    }\n    return draft[prop]\n}\n\nfunction get(state, prop) {\n    assertUnrevoked(state)\n    const value = peek(source(state), prop)\n    if (state.finalizing) return value\n    // Create a draft if the value is unmodified.\n    if (value === peek(state.base, prop) && isDraftable(value)) {\n        prepareCopy(state)\n        return (state.copy[prop] = createProxy(value, state))\n    }\n    return value\n}\n\nfunction set(state, prop, value) {\n    assertUnrevoked(state)\n    state.assigned[prop] = true\n    if (!state.modified) {\n        if (is(value, peek(source(state), prop))) return\n        markChanged(state)\n        prepareCopy(state)\n    }\n    state.copy[prop] = value\n}\n\nfunction markChanged(state) {\n    if (!state.modified) {\n        state.modified = true\n        if (state.parent) markChanged(state.parent)\n    }\n}\n\nfunction prepareCopy(state) {\n    if (!state.copy) state.copy = clonePotentialDraft(state.base)\n}\n\nfunction clonePotentialDraft(base) {\n    const state = base && base[DRAFT_STATE]\n    if (state) {\n        state.finalizing = true\n        const draft = shallowCopy(state.draft, true)\n        state.finalizing = false\n        return draft\n    }\n    return shallowCopy(base)\n}\n\nfunction proxyProperty(draft, prop, enumerable) {\n    let desc = descriptors[prop]\n    if (desc) {\n        desc.enumerable = enumerable\n    } else {\n        descriptors[prop] = desc = {\n            configurable: true,\n            enumerable,\n            get() {\n                return get(this[DRAFT_STATE], prop)\n            },\n            set(value) {\n                set(this[DRAFT_STATE], prop, value)\n            }\n        }\n    }\n    Object.defineProperty(draft, prop, desc)\n}\n\nfunction assertUnrevoked(state) {\n    if (state.revoked === true)\n        throw new Error(\n            \"Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? \" +\n                JSON.stringify(source(state))\n        )\n}\n\n// This looks expensive, but only proxies are visited, and only objects without known changes are scanned.\nfunction markChangesSweep(drafts) {\n    // The natural order of drafts in the `scope` array is based on when they\n    // were accessed. By processing drafts in reverse natural order, we have a\n    // better chance of processing leaf nodes first. When a leaf node is known to\n    // have changed, we can avoid any traversal of its ancestor nodes.\n    for (let i = drafts.length - 1; i >= 0; i--) {\n        const state = drafts[i][DRAFT_STATE]\n        if (!state.modified) {\n            if (Array.isArray(state.base)) {\n                if (hasArrayChanges(state)) markChanged(state)\n            } else if (hasObjectChanges(state)) markChanged(state)\n        }\n    }\n}\n\nfunction markChangesRecursively(object) {\n    if (!object || typeof object !== \"object\") return\n    const state = object[DRAFT_STATE]\n    if (!state) return\n    const {base, draft, assigned} = state\n    if (!Array.isArray(object)) {\n        // Look for added keys.\n        Object.keys(draft).forEach(key => {\n            // The `undefined` check is a fast path for pre-existing keys.\n            if (base[key] === undefined && !has(base, key)) {\n                assigned[key] = true\n                markChanged(state)\n            } else if (!assigned[key]) {\n                // Only untouched properties trigger recursion.\n                markChangesRecursively(draft[key])\n            }\n        })\n        // Look for removed keys.\n        Object.keys(base).forEach(key => {\n            // The `undefined` check is a fast path for pre-existing keys.\n            if (draft[key] === undefined && !has(draft, key)) {\n                assigned[key] = false\n                markChanged(state)\n            }\n        })\n    } else if (hasArrayChanges(state)) {\n        markChanged(state)\n        assigned.length = true\n        if (draft.length < base.length) {\n            for (let i = draft.length; i < base.length; i++) assigned[i] = false\n        } else {\n            for (let i = base.length; i < draft.length; i++) assigned[i] = true\n        }\n        for (let i = 0; i < draft.length; i++) {\n            // Only untouched indices trigger recursion.\n            if (assigned[i] === undefined) markChangesRecursively(draft[i])\n        }\n    }\n}\n\nfunction hasObjectChanges(state) {\n    const {base, draft} = state\n\n    // Search for added keys and changed keys. Start at the back, because\n    // non-numeric keys are ordered by time of definition on the object.\n    const keys = Object.keys(draft)\n    for (let i = keys.length - 1; i >= 0; i--) {\n        const key = keys[i]\n        const baseValue = base[key]\n        // The `undefined` check is a fast path for pre-existing keys.\n        if (baseValue === undefined && !has(base, key)) {\n            return true\n        }\n        // Once a base key is deleted, future changes go undetected, because its\n        // descriptor is erased. This branch detects any missed changes.\n        else {\n            const value = draft[key]\n            const state = value && value[DRAFT_STATE]\n            if (state ? state.base !== baseValue : !is(value, baseValue)) {\n                return true\n            }\n        }\n    }\n\n    // At this point, no keys were added or changed.\n    // Compare key count to determine if keys were deleted.\n    return keys.length !== Object.keys(base).length\n}\n\nfunction hasArrayChanges(state) {\n    const {draft} = state\n    if (draft.length !== state.base.length) return true\n    // See #116\n    // If we first shorten the length, our array interceptors will be removed.\n    // If after that new items are added, result in the same original length,\n    // those last items will have no intercepting property.\n    // So if there is no own descriptor on the last position, we know that items were removed and added\n    // N.B.: splice, unshift, etc only shift values around, but not prop descriptors, so we only have to check\n    // the last one\n    const descriptor = Object.getOwnPropertyDescriptor(draft, draft.length - 1)\n    // descriptor can be null, but only for newly created sparse arrays, eg. new Array(10)\n    if (descriptor && !descriptor.get) return true\n    // For all other cases, we don't have to compare, as they would have been picked up by the index setters\n    return false\n}\n\nfunction createHiddenProperty(target, prop, value) {\n    Object.defineProperty(target, prop, {\n        value: value,\n        enumerable: false,\n        writable: true\n    })\n}\n","\"use strict\"\nimport {\n    assign,\n    each,\n    has,\n    is,\n    isDraftable,\n    isDraft,\n    shallowCopy,\n    DRAFT_STATE\n} from \"./common\"\nimport {ImmerScope} from \"./scope\"\n\n// Do nothing before being finalized.\nexport function willFinalize() {}\n\nexport function createProxy(base, parent) {\n    const scope = parent ? parent.scope : ImmerScope.current\n    const state = {\n        // Track which produce call this is associated with.\n        scope,\n        // True for both shallow and deep changes.\n        modified: false,\n        // Used during finalization.\n        finalized: false,\n        // Track which properties have been assigned (true) or deleted (false).\n        assigned: {},\n        // The parent draft state.\n        parent,\n        // The base state.\n        base,\n        // The base proxy.\n        draft: null,\n        // Any property proxies.\n        drafts: {},\n        // The base copy with any updated values.\n        copy: null,\n        // Called by the `produce` function.\n        revoke: null\n    }\n\n    const {revoke, proxy} = Array.isArray(base)\n        ? // [state] is used for arrays, to make sure the proxy is array-ish and not violate invariants,\n          // although state itself is an object\n          Proxy.revocable([state], arrayTraps)\n        : Proxy.revocable(state, objectTraps)\n\n    state.draft = proxy\n    state.revoke = revoke\n\n    scope.drafts.push(proxy)\n    return proxy\n}\n\nconst objectTraps = {\n    get,\n    has(target, prop) {\n        return prop in source(target)\n    },\n    ownKeys(target) {\n        return Reflect.ownKeys(source(target))\n    },\n    set,\n    deleteProperty,\n    getOwnPropertyDescriptor,\n    defineProperty() {\n        throw new Error(\"Object.defineProperty() cannot be used on an Immer draft\") // prettier-ignore\n    },\n    getPrototypeOf(target) {\n        return Object.getPrototypeOf(target.base)\n    },\n    setPrototypeOf() {\n        throw new Error(\"Object.setPrototypeOf() cannot be used on an Immer draft\") // prettier-ignore\n    }\n}\n\nconst arrayTraps = {}\neach(objectTraps, (key, fn) => {\n    arrayTraps[key] = function() {\n        arguments[0] = arguments[0][0]\n        return fn.apply(this, arguments)\n    }\n})\narrayTraps.deleteProperty = function(state, prop) {\n    if (isNaN(parseInt(prop))) {\n        throw new Error(\"Immer only supports deleting array indices\") // prettier-ignore\n    }\n    return objectTraps.deleteProperty.call(this, state[0], prop)\n}\narrayTraps.set = function(state, prop, value) {\n    if (prop !== \"length\" && isNaN(parseInt(prop))) {\n        throw new Error(\"Immer only supports setting array indices and the 'length' property\") // prettier-ignore\n    }\n    return objectTraps.set.call(this, state[0], prop, value)\n}\n\n// returns the object we should be reading the current value from, which is base, until some change has been made\nfunction source(state) {\n    return state.copy || state.base\n}\n\n// Access a property without creating an Immer draft.\nfunction peek(draft, prop) {\n    const state = draft[DRAFT_STATE]\n    const desc = Reflect.getOwnPropertyDescriptor(\n        state ? source(state) : draft,\n        prop\n    )\n    return desc && desc.value\n}\n\nfunction get(state, prop) {\n    if (prop === DRAFT_STATE) return state\n    let {drafts} = state\n\n    // Check for existing draft in unmodified state.\n    if (!state.modified && has(drafts, prop)) {\n        return drafts[prop]\n    }\n\n    const value = source(state)[prop]\n    if (state.finalized || !isDraftable(value)) {\n        return value\n    }\n\n    // Check for existing draft in modified state.\n    if (state.modified) {\n        // Assigned values are never drafted. This catches any drafts we created, too.\n        if (value !== peek(state.base, prop)) return value\n        // Store drafts on the copy (when one exists).\n        drafts = state.copy\n    }\n\n    return (drafts[prop] = createProxy(value, state))\n}\n\nfunction set(state, prop, value) {\n    if (!state.modified) {\n        const baseValue = peek(state.base, prop)\n        // Optimize based on value's truthiness. Truthy values are guaranteed to\n        // never be undefined, so we can avoid the `in` operator. Lastly, truthy\n        // values may be drafts, but falsy values are never drafts.\n        const isUnchanged = value\n            ? is(baseValue, value) || value === state.drafts[prop]\n            : is(baseValue, value) && prop in state.base\n        if (isUnchanged) return true\n        markChanged(state)\n    }\n    state.assigned[prop] = true\n    state.copy[prop] = value\n    return true\n}\n\nfunction deleteProperty(state, prop) {\n    // The `undefined` check is a fast path for pre-existing keys.\n    if (peek(state.base, prop) !== undefined || prop in state.base) {\n        state.assigned[prop] = false\n        markChanged(state)\n    }\n    if (state.copy) delete state.copy[prop]\n    return true\n}\n\n// Note: We never coerce `desc.value` into an Immer draft, because we can't make\n// the same guarantee in ES5 mode.\nfunction getOwnPropertyDescriptor(state, prop) {\n    const owner = source(state)\n    const desc = Reflect.getOwnPropertyDescriptor(owner, prop)\n    if (desc) {\n        desc.writable = true\n        desc.configurable = !Array.isArray(owner) || prop !== \"length\"\n    }\n    return desc\n}\n\nfunction markChanged(state) {\n    if (!state.modified) {\n        state.modified = true\n        state.copy = assign(shallowCopy(state.base), state.drafts)\n        state.drafts = null\n        if (state.parent) markChanged(state.parent)\n    }\n}\n","import {each} from \"./common\"\n\nexport function generatePatches(state, basePath, patches, inversePatches) {\n    Array.isArray(state.base)\n        ? generateArrayPatches(state, basePath, patches, inversePatches)\n        : generateObjectPatches(state, basePath, patches, inversePatches)\n}\n\nfunction generateArrayPatches(state, basePath, patches, inversePatches) {\n    let {base, copy, assigned} = state\n\n    // Reduce complexity by ensuring `base` is never longer.\n    if (copy.length < base.length) {\n        ;[base, copy] = [copy, base]\n        ;[patches, inversePatches] = [inversePatches, patches]\n    }\n\n    const delta = copy.length - base.length\n\n    // Find the first replaced index.\n    let start = 0\n    while (base[start] === copy[start] && start < base.length) {\n        ++start\n    }\n\n    // Find the last replaced index. Search from the end to optimize splice patches.\n    let end = base.length\n    while (end > start && base[end - 1] === copy[end + delta - 1]) {\n        --end\n    }\n\n    // Process replaced indices.\n    for (let i = start; i < end; ++i) {\n        if (assigned[i] && copy[i] !== base[i]) {\n            const path = basePath.concat([i])\n            patches.push({\n                op: \"replace\",\n                path,\n                value: copy[i]\n            })\n            inversePatches.push({\n                op: \"replace\",\n                path,\n                value: base[i]\n            })\n        }\n    }\n\n    const useRemove = end != base.length\n    const replaceCount = patches.length\n\n    // Process added indices.\n    for (let i = end + delta - 1; i >= end; --i) {\n        const path = basePath.concat([i])\n        patches[replaceCount + i - end] = {\n            op: \"add\",\n            path,\n            value: copy[i]\n        }\n        if (useRemove) {\n            inversePatches.push({\n                op: \"remove\",\n                path\n            })\n        }\n    }\n\n    // One \"replace\" patch reverses all non-splicing \"add\" patches.\n    if (!useRemove) {\n        inversePatches.push({\n            op: \"replace\",\n            path: basePath.concat([\"length\"]),\n            value: base.length\n        })\n    }\n}\n\nfunction generateObjectPatches(state, basePath, patches, inversePatches) {\n    const {base, copy} = state\n    each(state.assigned, (key, assignedValue) => {\n        const origValue = base[key]\n        const value = copy[key]\n        const op = !assignedValue ? \"remove\" : key in base ? \"replace\" : \"add\"\n        if (origValue === value && op === \"replace\") return\n        const path = basePath.concat(key)\n        patches.push(op === \"remove\" ? {op, path} : {op, path, value})\n        inversePatches.push(\n            op === \"add\"\n                ? {op: \"remove\", path}\n                : op === \"remove\"\n                ? {op: \"add\", path, value: origValue}\n                : {op: \"replace\", path, value: origValue}\n        )\n    })\n}\n\nexport function applyPatches(draft, patches) {\n    for (let i = 0; i < patches.length; i++) {\n        const patch = patches[i]\n        const {path} = patch\n        if (path.length === 0 && patch.op === \"replace\") {\n            draft = patch.value\n        } else {\n            let base = draft\n            for (let i = 0; i < path.length - 1; i++) {\n                base = base[path[i]]\n                if (!base || typeof base !== \"object\")\n                    throw new Error(\"Cannot apply patch, path doesn't resolve: \" + path.join(\"/\")) // prettier-ignore\n            }\n            const key = path[path.length - 1]\n            switch (patch.op) {\n                case \"replace\":\n                    base[key] = patch.value\n                    break\n                case \"add\":\n                    if (Array.isArray(base)) {\n                        // TODO: support \"foo/-\" paths for appending to an array\n                        base.splice(key, 0, patch.value)\n                    } else {\n                        base[key] = patch.value\n                    }\n                    break\n                case \"remove\":\n                    if (Array.isArray(base)) {\n                        base.splice(key, 1)\n                    } else {\n                        delete base[key]\n                    }\n                    break\n                default:\n                    throw new Error(\"Unsupported patch operation: \" + patch.op)\n            }\n        }\n    }\n    return draft\n}\n","import * as legacyProxy from \"./es5\"\nimport * as modernProxy from \"./proxy\"\nimport {applyPatches, generatePatches} from \"./patches\"\nimport {\n    assign,\n    each,\n    has,\n    is,\n    isDraft,\n    isDraftable,\n    isEnumerable,\n    shallowCopy,\n    DRAFT_STATE,\n    NOTHING\n} from \"./common\"\nimport {ImmerScope} from \"./scope\"\n\nfunction verifyMinified() {}\n\nconst configDefaults = {\n    useProxies: typeof Proxy !== \"undefined\" && typeof Reflect !== \"undefined\",\n    autoFreeze:\n        typeof process !== \"undefined\"\n            ? process.env.NODE_ENV !== \"production\"\n            : verifyMinified.name === \"verifyMinified\",\n    onAssign: null,\n    onDelete: null,\n    onCopy: null\n}\n\nexport class Immer {\n    constructor(config) {\n        assign(this, configDefaults, config)\n        this.setUseProxies(this.useProxies)\n        this.produce = this.produce.bind(this)\n    }\n    produce(base, recipe, patchListener) {\n        // curried invocation\n        if (typeof base === \"function\" && typeof recipe !== \"function\") {\n            const defaultBase = recipe\n            recipe = base\n\n            const self = this\n            return function curriedProduce(base = defaultBase, ...args) {\n                return self.produce(base, draft => recipe.call(this, draft, ...args)) // prettier-ignore\n            }\n        }\n\n        // prettier-ignore\n        {\n            if (typeof recipe !== \"function\") {\n                throw new Error(\"The first or second argument to `produce` must be a function\")\n            }\n            if (patchListener !== undefined && typeof patchListener !== \"function\") {\n                throw new Error(\"The third argument to `produce` must be a function or undefined\")\n            }\n        }\n\n        let result\n\n        // Only plain objects, arrays, and \"immerable classes\" are drafted.\n        if (isDraftable(base)) {\n            const scope = ImmerScope.enter()\n            const proxy = this.createProxy(base)\n            let hasError = true\n            try {\n                result = recipe(proxy)\n                hasError = false\n            } finally {\n                // finally instead of catch + rethrow better preserves original stack\n                if (hasError) scope.revoke()\n                else scope.leave()\n            }\n            if (result instanceof Promise) {\n                return result.then(\n                    result => {\n                        scope.usePatches(patchListener)\n                        return this.processResult(result, scope)\n                    },\n                    error => {\n                        scope.revoke()\n                        throw error\n                    }\n                )\n            }\n            scope.usePatches(patchListener)\n            return this.processResult(result, scope)\n        } else {\n            result = recipe(base)\n            if (result === undefined) return base\n            return result !== NOTHING ? result : undefined\n        }\n    }\n    createDraft(base) {\n        if (!isDraftable(base)) {\n            throw new Error(\"First argument to `createDraft` must be a plain object, an array, or an immerable object\") // prettier-ignore\n        }\n        const scope = ImmerScope.enter()\n        const proxy = this.createProxy(base)\n        proxy[DRAFT_STATE].isManual = true\n        scope.leave()\n        return proxy\n    }\n    finishDraft(draft, patchListener) {\n        const state = draft && draft[DRAFT_STATE]\n        if (!state || !state.isManual) {\n            throw new Error(\"First argument to `finishDraft` must be a draft returned by `createDraft`\") // prettier-ignore\n        }\n        if (state.finalized) {\n            throw new Error(\"The given draft is already finalized\") // prettier-ignore\n        }\n        const {scope} = state\n        scope.usePatches(patchListener)\n        return this.processResult(undefined, scope)\n    }\n    setAutoFreeze(value) {\n        this.autoFreeze = value\n    }\n    setUseProxies(value) {\n        this.useProxies = value\n        assign(this, value ? modernProxy : legacyProxy)\n    }\n    applyPatches(base, patches) {\n        // Mutate the base state when a draft is passed.\n        if (isDraft(base)) {\n            return applyPatches(base, patches)\n        }\n        // Otherwise, produce a copy of the base state.\n        return this.produce(base, draft => applyPatches(draft, patches))\n    }\n    /** @internal */\n    processResult(result, scope) {\n        const baseDraft = scope.drafts[0]\n        const isReplaced = result !== undefined && result !== baseDraft\n        this.willFinalize(scope, result, isReplaced)\n        if (isReplaced) {\n            if (baseDraft[DRAFT_STATE].modified) {\n                scope.revoke()\n                throw new Error(\"An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.\") // prettier-ignore\n            }\n            if (isDraftable(result)) {\n                // Finalize the result in case it contains (or is) a subset of the draft.\n                result = this.finalize(result, null, scope)\n            }\n            if (scope.patches) {\n                scope.patches.push({\n                    op: \"replace\",\n                    path: [],\n                    value: result\n                })\n                scope.inversePatches.push({\n                    op: \"replace\",\n                    path: [],\n                    value: baseDraft[DRAFT_STATE].base\n                })\n            }\n        } else {\n            // Finalize the base draft.\n            result = this.finalize(baseDraft, [], scope)\n        }\n        scope.revoke()\n        if (scope.patches) {\n            scope.patchListener(scope.patches, scope.inversePatches)\n        }\n        return result !== NOTHING ? result : undefined\n    }\n    /**\n     * @internal\n     * Finalize a draft, returning either the unmodified base state or a modified\n     * copy of the base state.\n     */\n    finalize(draft, path, scope) {\n        const state = draft[DRAFT_STATE]\n        if (!state) {\n            if (Object.isFrozen(draft)) return draft\n            return this.finalizeTree(draft, null, scope)\n        }\n        // Never finalize drafts owned by another scope.\n        if (state.scope !== scope) {\n            return draft\n        }\n        if (!state.modified) {\n            return state.base\n        }\n        if (!state.finalized) {\n            state.finalized = true\n            this.finalizeTree(state.draft, path, scope)\n\n            if (this.onDelete) {\n                // The `assigned` object is unreliable with ES5 drafts.\n                if (this.useProxies) {\n                    const {assigned} = state\n                    for (const prop in assigned) {\n                        if (!assigned[prop]) this.onDelete(state, prop)\n                    }\n                } else {\n                    const {base, copy} = state\n                    each(base, prop => {\n                        if (!has(copy, prop)) this.onDelete(state, prop)\n                    })\n                }\n            }\n            if (this.onCopy) {\n                this.onCopy(state)\n            }\n\n            // At this point, all descendants of `state.copy` have been finalized,\n            // so we can be sure that `scope.canAutoFreeze` is accurate.\n            if (this.autoFreeze && scope.canAutoFreeze) {\n                Object.freeze(state.copy)\n            }\n\n            if (path && scope.patches) {\n                generatePatches(\n                    state,\n                    path,\n                    scope.patches,\n                    scope.inversePatches\n                )\n            }\n        }\n        return state.copy\n    }\n    /**\n     * @internal\n     * Finalize all drafts in the given state tree.\n     */\n    finalizeTree(root, rootPath, scope) {\n        const state = root[DRAFT_STATE]\n        if (state) {\n            if (!this.useProxies) {\n                // Create the final copy, with added keys and without deleted keys.\n                state.copy = shallowCopy(state.draft, true)\n            }\n            root = state.copy\n        }\n\n        const needPatches = !!rootPath && !!scope.patches\n        const finalizeProperty = (prop, value, parent) => {\n            if (value === parent) {\n                throw Error(\"Immer forbids circular references\")\n            }\n\n            // In the `finalizeTree` method, only the `root` object may be a draft.\n            const isDraftProp = !!state && parent === root\n\n            if (isDraft(value)) {\n                const path =\n                    isDraftProp && needPatches && !state.assigned[prop]\n                        ? rootPath.concat(prop)\n                        : null\n\n                // Drafts owned by `scope` are finalized here.\n                value = this.finalize(value, path, scope)\n\n                // Drafts from another scope must prevent auto-freezing.\n                if (isDraft(value)) {\n                    scope.canAutoFreeze = false\n                }\n\n                // Preserve non-enumerable properties.\n                if (Array.isArray(parent) || isEnumerable(parent, prop)) {\n                    parent[prop] = value\n                } else {\n                    Object.defineProperty(parent, prop, {value})\n                }\n\n                // Unchanged drafts are never passed to the `onAssign` hook.\n                if (isDraftProp && value === state.base[prop]) return\n            }\n            // Unchanged draft properties are ignored.\n            else if (isDraftProp && is(value, state.base[prop])) {\n                return\n            }\n            // Search new objects for unfinalized drafts. Frozen objects should never contain drafts.\n            else if (isDraftable(value) && !Object.isFrozen(value)) {\n                each(value, finalizeProperty)\n            }\n\n            if (isDraftProp && this.onAssign) {\n                this.onAssign(state, prop, value)\n            }\n        }\n\n        each(root, finalizeProperty)\n        return root\n    }\n}\n","import {Immer} from \"./immer\"\n\nconst immer = new Immer()\n\n/**\n * The `produce` function takes a value and a \"recipe function\" (whose\n * return value often depends on the base state). The recipe function is\n * free to mutate its first argument however it wants. All mutations are\n * only ever applied to a __copy__ of the base state.\n *\n * Pass only a function to create a \"curried producer\" which relieves you\n * from passing the recipe function every time.\n *\n * Only plain objects and arrays are made mutable. All other objects are\n * considered uncopyable.\n *\n * Note: This function is __bound__ to its `Immer` instance.\n *\n * @param {any} base - the initial state\n * @param {Function} producer - function that receives a proxy of the base state as first argument and which can be freely modified\n * @param {Function} patchListener - optional function that will be called with all the patches produced here\n * @returns {any} a new state, or the initial state if nothing was modified\n */\nexport const produce = immer.produce\nexport default produce\n\n/**\n * Pass true to automatically freeze all copies created by Immer.\n *\n * By default, auto-freezing is disabled in production.\n */\nexport const setAutoFreeze = immer.setAutoFreeze.bind(immer)\n\n/**\n * Pass true to use the ES2015 `Proxy` class when creating drafts, which is\n * always faster than using ES5 proxies.\n *\n * By default, feature detection is used, so calling this is rarely necessary.\n */\nexport const setUseProxies = immer.setUseProxies.bind(immer)\n\n/**\n * Apply an array of Immer patches to the first argument.\n *\n * This function is a producer, which means copy-on-write is in effect.\n */\nexport const applyPatches = immer.applyPatches.bind(immer)\n\n/**\n * Create an Immer draft from the given base state, which may be a draft itself.\n * The draft can be modified until you finalize it with the `finishDraft` function.\n */\nexport const createDraft = immer.createDraft.bind(immer)\n\n/**\n * Finalize an Immer draft from a `createDraft` call, returning the base state\n * (if no changes were made) or a modified copy. The draft must *not* be\n * mutated afterwards.\n *\n * Pass a function as the 2nd argument to generate Immer patches based on the\n * changes that were made.\n */\nexport const finishDraft = immer.finishDraft.bind(immer)\n\nexport {\n    original,\n    isDraft,\n    isDraftable,\n    NOTHING as nothing,\n    DRAFTABLE as immerable\n} from \"./common\"\n\nexport {Immer}\n","\"use strict\";\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nfunction createURLSearchParams(data) {\r\n    var params = new URLSearchParams();\r\n    for (var _i = 0, _a = Object.keys(data); _i < _a.length; _i++) {\r\n        var key = _a[_i];\r\n        if (Array.isArray(data[key])) {\r\n            for (var _b = 0, _c = data[key]; _b < _c.length; _b++) {\r\n                var item = _c[_b];\r\n                if (item !== null && item !== undefined) {\r\n                    params.append(key, item);\r\n                }\r\n            }\r\n        }\r\n        else {\r\n            if (data[key] !== null && data[key] !== undefined) {\r\n                params.append(key, data[key]);\r\n            }\r\n        }\r\n    }\r\n    return params;\r\n}\r\nexports.createURLSearchParams = createURLSearchParams;\r\n","import { createURLSearchParams } from 'pbs-stdlib/urls';\nexport function getJson(url) {\n    return fetch(url, { credentials: \"same-origin\" });\n}\nexport function postJson(url, data, getCsrfInfo) {\n    const csrfInfo = getCsrfInfo ? getCsrfInfo() : null;\n    const headers = {\n        \"Content-Type\": \"application/json\",\n        ...(csrfInfo && { [csrfInfo.headerName]: csrfInfo.requestToken })\n    };\n    return fetch(url, {\n        method: \"POST\",\n        body: JSON.stringify(data),\n        headers: headers,\n        credentials: 'same-origin'\n    });\n}\nexport function postFormData(url, data, getCsrfInfo) {\n    const csrfInfo = getCsrfInfo ? getCsrfInfo() : null;\n    const headers = {\n        ...(csrfInfo && { [csrfInfo.headerName]: csrfInfo.requestToken })\n    };\n    return fetch(url, {\n        method: \"POST\",\n        body: data,\n        headers: headers,\n        credentials: \"same-origin\"\n    });\n}\nexport function urlWithData(url, data) {\n    const params = (data instanceof URLSearchParams) ? data : createURLSearchParams(data);\n    const doesUrlContainAQueryString = url.indexOf(\"?\") >= 0;\n    if (doesUrlContainAQueryString) {\n        const isLastCharacterAQuestionMark = url.indexOf(\"?\") == url.length - 1;\n        return isLastCharacterAQuestionMark ? url + params.toString() : url + \"&\" + params.toString();\n    }\n    else\n        return url + \"?\" + params.toString();\n}\nexport function withStandardErrorHandling(promise, errorHandlers) {\n    return promise.catch((reason) => {\n        errorHandlers.handleNetworkError();\n        throw reason;\n    })\n        .then(async (response) => {\n        if (response.ok) {\n            return response.json();\n        }\n        else if (response.status === 404) {\n            errorHandlers.handle404Error();\n            throw response.status;\n        }\n        else if (response.status === 403) {\n            const responseJson = await response.json();\n            errorHandlers.handle403Error(responseJson?.message);\n            throw response.status;\n        }\n        else if (response.status === 401) {\n            errorHandlers.handle401Error();\n            throw response.status;\n        }\n        else {\n            const responseJson = await response.json();\n            errorHandlers.handle500Error(responseJson?.message);\n            throw response.status;\n        }\n    })\n        .then((responseJson) => responseJson);\n}\n","import * as fetch from \"./fetchExtensions\";\nexport class FetchWithStandardErrorHandling {\n    constructor(props) {\n        const { getCsrfInfo, ...errorHandlers } = props;\n        this.getCsrfInfo = getCsrfInfo;\n        this.errorHandlers = errorHandlers;\n    }\n    getJson(url, concurrencyContext) {\n        if (concurrencyContext) {\n            return concurrencyContext.thenForLastWithErrorHandling(fetch.getJson(url), this.errorHandlers)\n                .then(result => {\n                if (!result.wasCancelled) {\n                    return result.result;\n                }\n                else {\n                    /* note: this request was \"cancelled\" so we return a new promise for the result that we never resolve */\n                    return new Promise(resolve => { });\n                }\n            });\n        }\n        else {\n            return fetch.withStandardErrorHandling(fetch.getJson(url), this.errorHandlers);\n        }\n    }\n    getJsonWithData(url, data, concurrencyContext) {\n        return this.getJson(fetch.urlWithData(url, data), concurrencyContext);\n    }\n    postJson(url, data, concurrencyContext) {\n        if (concurrencyContext) {\n            return concurrencyContext.thenForLastWithErrorHandling(fetch.postJson(url, data, this.getCsrfInfo), this.errorHandlers).then(result => {\n                if (!result.wasCancelled) {\n                    return result.result;\n                }\n                else {\n                    /* note: this request was \"cancelled\" so we return a new promise for the result that we never resolve */\n                    return new Promise(resolve => { });\n                }\n            });\n        }\n        else {\n            return fetch.withStandardErrorHandling(fetch.postJson(url, data, this.getCsrfInfo), this.errorHandlers);\n        }\n    }\n    postFormData(url, data) {\n        return fetch.withStandardErrorHandling(fetch.postFormData(url, data, this.getCsrfInfo), this.errorHandlers);\n    }\n}\n","export function onLoad(onLoad) {\n    document.addEventListener(\"load.matrix\", (e) => {\n        onLoad(e.detail);\n    });\n}\n"],"names":["NOTHING","Symbol","DRAFTABLE","for","DRAFT_STATE","isDraft","value","isDraftable","Array","isArray","proto","Object","getPrototypeOf","prototype","constructor","assign","target","let","key","has","ownKeys","Reflect","getOwnPropertySymbols","obj","getOwnPropertyNames","concat","shallowCopy","base","invokeGetters","slice","clone","create","forEach","desc","getOwnPropertyDescriptor","get","Error","call","enumerable","defineProperty","writable","configurable","each","cb","i","length","isEnumerable","prop","thing","hasOwnProperty","is","x","y","ImmerScope","parent","drafts","canAutoFreeze","patches","revoke","draft","usePatches","patchListener","inversePatches","leave","this","current","enter","const","descriptors","revoked","source","state","copy","peek","finalizing","markChanged","modified","prepareCopy","clonePotentialDraft","assertUnrevoked","JSON","stringify","markChangesSweep","hasArrayChanges","hasObjectChanges","markChangesRecursively","object","assigned","undefined","keys","baseValue","descriptor","scope","result","isReplaced","createProxy","set","proxyProperty","finalized","push","Proxy","revocable","arrayTraps","objectTraps","proxy","owner","setPrototypeOf","fn","arguments","apply","deleteProperty","isNaN","parseInt","applyPatches","patch","path","op","join","splice","configDefaults","useProxies","autoFreeze","process","name","onAssign","onDelete","onCopy","Immer","config","setUseProxies","produce","bind","recipe","defaultBase","self","args","hasError","Promise","then","processResult","error","createDraft","isManual","finishDraft","setAutoFreeze","modernProxy","legacyProxy","baseDraft","willFinalize","finalize","isFrozen","finalizeTree","freeze","basePath","delta","start","end","useRemove","replaceCount","generateArrayPatches","assignedValue","origValue","generateObjectPatches","generatePatches","root","rootPath","needPatches","finalizeProperty","isDraftProp","immer","exports","data","params","URLSearchParams","_i","_a","_b","_c","item","append","getJson","url","fetch","credentials","postJson","getCsrfInfo","csrfInfo","headers","headerName","requestToken","method","body","postFormData","urlWithData","indexOf","toString","withStandardErrorHandling","promise","errorHandlers","catch","reason","handleNetworkError","async","response","ok","json","status","handle404Error","responseJson","handle403Error","message","handle401Error","handle500Error","FetchWithStandardErrorHandling","props","concurrencyContext","thenForLastWithErrorHandling","wasCancelled","resolve","getJsonWithData","onLoad","document","addEventListener","e","detail"],"sourceRoot":""}