https://scrubsunit.com/scripts/axios.js

1// Axios v1.7.8 Copyright (c) 2024 Matt Zabriskie and contributors
2(function (global, factory) {
3  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
4  typeof define === 'function' && define.amd ? define(factory) :
5  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.axios = factory());
6})(this, (function () { 'use strict';
7
8  function _AsyncGenerator(e) {
9    var r, t;
10    function resume(r, t) {
11      try {
12        var n = e[r](t),
13          o = n.value,
14          u = o instanceof _OverloadYield;
15        Promise.resolve(u ? o.v : o).then(function (t) {
16          if (u) {
17            var i = "return" === r ? "return" : "next";
18            if (!o.k || t.done) return resume(i, t);
19            t = e[i](t).value;
20          }
21          settle(n.done ? "return" : "normal", t);
22        }, function (e) {
23          resume("throw", e);
24        });
25      } catch (e) {
26        settle("throw", e);
27      }
28    }
29    function settle(e, n) {
30      switch (e) {
31        case "return":
32          r.resolve({
33            value: n,
34            done: !0
35          });
36          break;
37        case "throw":
38          r.reject(n);
39          break;
40        default:
41          r.resolve({
42            value: n,
43            done: !1
44          });
45      }
46      (r = r.next) ? resume(r.key, r.arg) : t = null;
47    }
48    this._invoke = function (e, n) {
49      return new Promise(function (o, u) {
50        var i = {
51          key: e,
52          arg: n,
53          resolve: o,
54          reject: u,
55          next: null
56        };
57        t ? t = t.next = i : (r = t = i, resume(e, n));
58      });
59    }, "function" != typeof e.return && (this.return = void 0);
60  }
61  _AsyncGenerator.prototype["function" == typeof Symbol && Symbol.asyncIterator || "@@asyncIterator"] = function () {
62    return this;
63  }, _AsyncGenerator.prototype.next = function (e) {
64    return this._invoke("next", e);
65  }, _AsyncGenerator.prototype.throw = function (e) {
66    return this._invoke("throw", e);
67  }, _AsyncGenerator.prototype.return = function (e) {
68    return this._invoke("return", e);
69  };
70  function _OverloadYield(t, e) {
71    this.v = t, this.k = e;
72  }
73  function _asyncGeneratorDelegate(t) {
74    var e = {},
75      n = !1;
76    function pump(e, r) {
77      return n = !0, r = new Promise(function (n) {
78        n(t[e](r));
79      }), {
80        done: !1,
81        value: new _OverloadYield(r, 1)
82      };
83    }
84    return e["undefined" != typeof Symbol && Symbol.iterator || "@@iterator"] = function () {
85      return this;
86    }, e.next = function (t) {
87      return n ? (n = !1, t) : pump("next", t);
88    }, "function" == typeof t.throw && (e.throw = function (t) {
89      if (n) throw n = !1, t;
90      return pump("throw", t);
91    }), "function" == typeof t.return && (e.return = function (t) {
92      return n ? (n = !1, t) : pump("return", t);
93    }), e;
94  }
95  function _asyncIterator(r) {
96    var n,
97      t,
98      o,
99      e = 2;
100    for ("undefined" != typeof Symbol && (t = Symbol.asyncIterator, o = Symbol.iterator); e--;) {
101      if (t && null != (n = r[t])) return n.call(r);
102      if (o && null != (n = r[o])) return new AsyncFromSyncIterator(n.call(r));
103      t = "@@asyncIterator", o = "@@iterator";
104    }
105    throw new TypeError("Object is not async iterable");
106  }
107  function AsyncFromSyncIterator(r) {
108    function AsyncFromSyncIteratorContinuation(r) {
109      if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object."));
110      var n = r.done;
111      return Promise.resolve(r.value).then(function (r) {
112        return {
113          value: r,
114          done: n
115        };
116      });
117    }
118    return AsyncFromSyncIterator = function (r) {
119      this.s = r, this.n = r.next;
120    }, AsyncFromSyncIterator.prototype = {
121      s: null,
122      n: null,
123      next: function () {
124        return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));
125      },
126      return: function (r) {
127        var n = this.s.return;
128        return void 0 === n ? Promise.resolve({
129          value: r,
130          done: !0
131        }) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments));
132      },
133      throw: function (r) {
134        var n = this.s.return;
135        return void 0 === n ? Promise.reject(r) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments));
136      }
137    }, new AsyncFromSyncIterator(r);
138  }
139  function _awaitAsyncGenerator(e) {
140    return new _OverloadYield(e, 0);
141  }
142  function _iterableToArrayLimit(r, l) {
143    var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
144    if (null != t) {
145      var e,
146        n,
147        i,
148        u,
149        a = [],
150        f = !0,
151        o = !1;

152      try {
153        if (i = (t = t.call(r)).next, 0 === l) {
154          if (Object(t) !== t) return;
155          f = !1;
156        } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
157      } catch (r) {
158        o = !0, n = r;
159      } finally {
160        try {
161          if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
162        } finally {
163          if (o) throw n;
164        }
165      }
166      return a;
167    }
168  }
169  function ownKeys(e, r) {
170    var t = Object.keys(e);
171    if (Object.getOwnPropertySymbols) {
172      var o = Object.getOwnPropertySymbols(e);
173      r && (o = o.filter(function (r) {
174        return Object.getOwnPropertyDescriptor(e, r).enumerable;
175      })), t.push.apply(t, o);
176    }
177    return t;
178  }
179  function _objectSpread2(e) {
180    for (var r = 1; r < arguments.length; r++) {
181      var t = null != arguments[r] ? arguments[r] : {};
182      r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
183        _defineProperty(e, r, t[r]);
184      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
185        Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
186      });
187    }
188    return e;
189  }
190  function _regeneratorRuntime() {
191    _regeneratorRuntime = function () {
192      return e;
193    };
194    var t,
195      e = {},
196      r = Object.prototype,
197      n = r.hasOwnProperty,
198      o = Object.defineProperty || function (t, e, r) {
199        t[e] = r.value;
200      },
201      i = "function" == typeof Symbol ? Symbol : {},
202      a = i.iterator || "@@iterator",
203      c = i.asyncIterator || "@@asyncIterator",
204      u = i.toStringTag || "@@toStringTag";
205    function define(t, e, r) {
206      return Object.defineProperty(t, e, {
207        value: r,
208        enumerable: !0,
209        configurable: !0,
210        writable: !0
211      }), t[e];
212    }
213    try {
214      define({}, "");
215    } catch (t) {
216      define = function (t, e, r) {
217        return t[e] = r;
218      };
219    }
220    function wrap(t, e, r, n) {
221      var i = e && e.prototype instanceof Generator ? e : Generator,
222        a = Object.create(i.prototype),
223        c = new Context(n || []);
224      return o(a, "_invoke", {
225        value: makeInvokeMethod(t, r, c)
226      }), a;
227    }
228    function tryCatch(t, e, r) {
229      try {
230        return {
231          type: "normal",
232          arg: t.call(e, r)
233        };
234      } catch (t) {
235        return {
236          type: "throw",
237          arg: t
238        };
239      }
240    }
241    e.wrap = wrap;
242    var h = "suspendedStart",
243      l = "suspendedYield",
244      f = "executing",
245      s = "completed",
246      y = {};
247    function Generator() {}
248    function GeneratorFunction() {}
249    function GeneratorFunctionPrototype() {}
250    var p = {};
251    define(p, a, function () {
252      return this;
253    });
254    var d = Object.getPrototypeOf,
255      v = d && d(d(values([])));
256    v && v !== r && n.call(v, a) && (p = v);
257    var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
258    function defineIteratorMethods(t) {
259      ["next", "throw", "return"].forEach(function (e) {
260        define(t, e, function (t) {
261          return this._invoke(e, t);
262        });
263      });
264    }
265    function AsyncIterator(t, e) {
266      function invoke(r, o, i, a) {
267        var c = tryCatch(t[r], t, o);
268        if ("throw" !== c.type) {
269          var u = c.arg,
270            h = u.value;
271          return h && "object" == typeof h && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) {
272            invoke("next", t, i, a);
273          }, function (t) {
274            invoke("throw", t, i, a);
275          }) : e.resolve(h).then(function (t) {
276            u.value = t, i(u);
277          }, function (t) {
278            return invoke("throw", t, i, a);
279          });
280        }
281        a(c.arg);
282      }
283      var r;
284      o(this, "_invoke", {
285        value: function (t, n) {
286          function callInvokeWithMethodAndArg() {
287            return new e(function (e, r) {
288              invoke(t, n, e, r);
289            });
290          }
291          return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
292        }
293      });
294    }
295    function makeInvokeMethod(e, r, n) {
296      var o = h;
297      return function (i, a) {
298        if (o === f) throw new Error("Generator is already running");
299        if (o === s) {
300          if ("throw" === i) throw a;
301          return {
302            value: t,
303            done: !0
304          };
305        }
306        for (n.method = i, n.arg = a;;) {
307          var c = n.delegate;
308          if (c) {
309            var u = maybeInvokeDelegate(c, n);
310            if (u) {
311              if (u === y) continue;
312              return u;
313            }
314          }
315          if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) {
316            if (o === h) throw o = s, n.arg;
317            n.dispatchException(n.arg);
318          } else "return" === n.method && n.abrupt("return", n.arg);
319          o = f;
320          var p = tryCatch(e, r, n);
321          if ("normal" === p.type) {
322            if (o = n.done ? s : l, p.arg === y) continue;
323            return {
324              value: p.arg,
325              done: n.done
326            };
327          }
328          "throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg);
329        }
330      };
331    }
332    function maybeInvokeDelegate(e, r) {
333      var n = r.method,
334        o = e.iterator[n];
335      if (o === t) return r.delegate = null, "throw" === n && e.iterator.return && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y;
336      var i = tryCatch(o, e.iterator, r.arg);
337      if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y;
338      var a = i.arg;
339      return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y);
340    }
341    function pushTryEntry(t) {
342      var e = {
343        tryLoc: t[0]
344      };
345      1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e);
346    }
347    function resetTryEntry(t) {
348      var e = t.completion || {};
349      e.type = "normal", delete e.arg, t.completion = e;
350    }
351    function Context(t) {
352      this.tryEntries = [{
353        tryLoc: "root"
354      }], t.forEach(pushTryEntry, this), this.reset(!0);
355    }
356    function values(e) {
357      if (e || "" === e) {
358        var r = e[a];
359        if (r) return r.call(e);
360        if ("function" == typeof e.next) return e;
361        if (!isNaN(e.length)) {
362          var o = -1,
363            i = function next() {
364              for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next;
365              return next.value = t, next.done = !0, next;
366            };
367          return i.next = i;
368        }
369      }
370      throw new TypeError(typeof e + " is not iterable");
371    }
372    return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", {
373      value: GeneratorFunctionPrototype,
374      configurable: !0
375    }), o(GeneratorFunctionPrototype, "constructor", {
376      value: GeneratorFunction,
377      configurable: !0
378    }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) {
379      var e = "function" == typeof t && t.constructor;
380      return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name));
381    }, e.mark = function (t) {
382      return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t;
383    }, e.awrap = function (t) {
384      return {
385        __await: t
386      };
387    }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () {
388      return this;
389    }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) {
390      void 0 === i && (i = Promise);
391      var a = new AsyncIterator(wrap(t, r, n, o), i);
392      return e.isGeneratorFunction(r) ? a : a.next().then(function (t) {
393        return t.done ? t.value : a.next();
394      });
395    }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () {
396      return this;
397    }), define(g, "toString", function () {
398      return "[object Generator]";
399    }), e.keys = function (t) {
400      var e = Object(t),
401        r = [];
402      for (var n in e) r.push(n);
403      return r.reverse(), function next() {
404        for (; r.length;) {
405          var t = r.pop();
406          if (t in e) return next.value = t, next.done = !1, next;
407        }
408        return next.done = !0, next;
409      };
410    }, e.values = values, Context.prototype = {
411      constructor: Context,
412      reset: function (e) {
413        if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t);
414      },
415      stop: function () {
416        this.done = !0;
417        var t = this.tryEntries[0].completion;
418        if ("throw" === t.type) throw t.arg;
419        return this.rval;
420      },
421      dispatchException: function (e) {
422        if (this.done) throw e;
423        var r = this;
424        function handle(n, o) {
425          return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o;
426        }
427        for (var o = this.tryEntries.length - 1; o >= 0; --o) {
428          var i = this.tryEntries[o],
429            a = i.completion;
430          if ("root" === i.tryLoc) return handle("end");
431          if (i.tryLoc <= this.prev) {
432            var c = n.call(i, "catchLoc"),
433              u = n.call(i, "finallyLoc");
434            if (c && u) {
435              if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
436              if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
437            } else if (c) {
438              if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
439            } else {
440              if (!u) throw new Error("try statement without catch or finally");
441              if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
442            }
443          }
444        }
445      },
446      abrupt: function (t, e) {
447        for (var r = this.tryEntries.length - 1; r >= 0; --r) {
448          var o = this.tryEntries[r];
449          if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) {
450            var i = o;
451            break;
452          }
453        }
454        i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null);
455        var a = i ? i.completion : {};
456        return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a);
457      },
458      complete: function (t, e) {
459        if ("throw" === t.type) throw t.arg;
460        return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y;
461      },
462      finish: function (t) {
463        for (var e = this.tryEntries.length - 1; e >= 0; --e) {
464          var r = this.tryEntries[e];
465          if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y;
466        }
467      },
468      catch: function (t) {
469        for (var e = this.tryEntries.length - 1; e >= 0; --e) {
470          var r = this.tryEntries[e];
471          if (r.tryLoc === t) {
472            var n = r.completion;
473            if ("throw" === n.type) {
474              var o = n.arg;
475              resetTryEntry(r);
476            }
477            return o;
478          }
479        }
480        throw new Error("illegal catch attempt");
481      },
482      delegateYield: function (e, r, n) {
483        return this.delegate = {
484          iterator: values(e),
485          resultName: r,
486          nextLoc: n
487        }, "next" === this.method && (this.arg = t), y;
488      }
489    }, e;
490  }
491  function _toPrimitive(t, r) {
492    if ("object" != typeof t || !t) return t;
493    var e = t[Symbol.toPrimitive];
494    if (void 0 !== e) {
495      var i = e.call(t, r || "default");
496      if ("object" != typeof i) return i;
497      throw new TypeError("@@toPrimitive must return a primitive value.");
498    }
499    return ("string" === r ? String : Number)(t);
500  }
501  function _toPropertyKey(t) {
502    var i = _toPrimitive(t, "string");
503    return "symbol" == typeof i ? i : String(i);
504  }
505  function _typeof(o) {
506    "@babel/helpers - typeof";
507
508    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
509      return typeof o;
510    } : function (o) {
511      return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
512    }, _typeof(o);
513  }
514  function _wrapAsyncGenerator(fn) {
515    return function () {
516      return new _AsyncGenerator(fn.apply(this, arguments));
517    };
518  }
519  function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
520    try {
521      var info = gen[key](arg);
522      var value = info.value;
523    } catch (error) {
524      reject(error);
525      return;
526    }
527    if (info.done) {
528      resolve(value);
529    } else {
530      Promise.resolve(value).then(_next, _throw);
531    }
532  }
533  function _asyncToGenerator(fn) {
534    return function () {
535      var self = this,
536        args = arguments;
537      return new Promise(function (resolve, reject) {
538        var gen = fn.apply(self, args);
539        function _next(value) {
540          asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
541        }
542        function _throw(err) {
543          asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
544        }
545        _next(undefined);
546      });
547    };
548  }
549  function _classCallCheck(instance, Constructor) {
550    if (!(instance instanceof Constructor)) {
551      throw new TypeError("Cannot call a class as a function");
552    }
553  }
554  function _defineProperties(target, props) {
555    for (var i = 0; i < props.length; i++) {
556      var descriptor = props[i];
557      descriptor.enumerable = descriptor.enumerable || false;
558      descriptor.configurable = true;
559      if ("value" in descriptor) descriptor.writable = true;
560      Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
561    }
562  }
563  function _createClass(Constructor, protoProps, staticProps) {
564    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
565    if (staticProps) _defineProperties(Constructor, staticProps);

1011      arguments[i] && forEach(arguments[i], assignValue);
1012    }
1013    return result;
1014  }
1015
1016  /**
1017   * Extends object a by mutably adding to it the properties of object b.
1018   *
1019   * @param {Object} a The object to be extended
1020   * @param {Object} b The object to copy properties from
1021   * @param {Object} thisArg The object to bind function to
1022   *
1023   * @param {Boolean} [allOwnKeys]
1024   * @returns {Object} The resulting value of object a
1025   */
1026  var extend = function extend(a, b, thisArg) {
1027    var _ref3 = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {},
1028      allOwnKeys = _ref3.allOwnKeys;
1029    forEach(b, function (val, key) {
1030      if (thisArg && isFunction(val)) {
1031        a[key] = bind(val, thisArg);
1032      } else {
1033        a[key] = val;
1034      }
1035    }, {
1036      allOwnKeys: allOwnKeys
1037    });
1038    return a;
1039  };
1040
1041  /**
1042   * Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)
1043   *
1044   * @param {string} content with BOM
1045   *
1046   * @returns {string} content value without BOM
1047   */
1048  var stripBOM = function stripBOM(content) {
1049    if (content.charCodeAt(0) === 0xFEFF) {
1050      content = content.slice(1);
1051    }
1052    return content;
1053  };
1054
1055  /**
1056   * Inherit the prototype methods from one constructor into another
1057   * @param {function} constructor
1058   * @param {function} superConstructor
1059   * @param {object} [props]
1060   * @param {object} [descriptors]
1061   *
1062   * @returns {void}
1063   */
1064  var inherits = function inherits(constructor, superConstructor, props, descriptors) {
1065    constructor.prototype = Object.create(superConstructor.prototype, descriptors);
1066    constructor.prototype.constructor = constructor;
1067    Object.defineProperty(constructor, 'super', {
1068      value: superConstructor.prototype
1069    });
1070    props && Object.assign(constructor.prototype, props);
1071  };
1072
1073  /**
1074   * Resolve object with deep prototype chain to a flat object
1075   * @param {Object} sourceObj source object
1076   * @param {Object} [destObj]
1077   * @param {Function|Boolean} [filter]
1078   * @param {Function} [propFilter]
1079   *
1080   * @returns {Object}
1081   */
1082  var toFlatObject = function toFlatObject(sourceObj, destObj, filter, propFilter) {
1083    var props;
1084    var i;
1085    var prop;
1086    var merged = {};
1087    destObj = destObj || {};
1088    // eslint-disable-next-line no-eq-null,eqeqeq
1089    if (sourceObj == null) return destObj;
1090    do {
1091      props = Object.getOwnPropertyNames(sourceObj);
1092      i = props.length;
1093      while (i-- > 0) {
1094        prop = props[i];
1095        if ((!propFilter || propFilter(prop, sourceObj, destObj)) && !merged[prop]) {
1096          destObj[prop] = sourceObj[prop];
1097          merged[prop] = true;
1098        }
1099      }
1100      sourceObj = filter !== false && getPrototypeOf(sourceObj);
1101    } while (sourceObj && (!filter || filter(sourceObj, destObj)) && sourceObj !== Object.prototype);
1102    return destObj;
1103  };
1104
1105  /**
1106   * Determines whether a string ends with the characters of a specified string
1107   *
1108   * @param {String} str
1109   * @param {String} searchString
1110   * @param {Number} [position= 0]
1111   *
1112   * @returns {boolean}
1113   */
1114  var endsWith = function endsWith(str, searchString, position) {
1115    str = String(str);
1116    if (position === undefined || position > str.length) {
1117      position = str.length;
1118    }
1119    position -= searchString.length;
1120    var lastIndex = str.indexOf(searchString, position);
1121    return lastIndex !== -1 && lastIndex === position;
1122  };
1123
1124  /**
1125   * Returns new array from array like object or null if failed
1126   *
1127   * @param {*} [thing]
1128   *
1129   * @returns {?Array}
1130   */
1131  var toArray = function toArray(thing) {
1132    if (!thing) return null;
1133    if (isArray(thing)) return thing;
1134    var i = thing.length;
1135    if (!isNumber(i)) return null;
1136    var arr = new Array(i);
1137    while (i-- > 0) {
1138      arr[i] = thing[i];
1139    }
1140    return arr;
1141  };
1142
1143  /**
1144   * Checking if the Uint8Array exists and if it does, it returns a function that checks if the
1145   * thing passed in is an instance of Uint8Array
1146   *
1147   * @param {TypedArray}
1148   *
1149   * @returns {Array}
1150   */
1151  // eslint-disable-next-line func-names
1152  var isTypedArray = function (TypedArray) {
1153    // eslint-disable-next-line func-names
1154    return function (thing) {
1155      return TypedArray && thing instanceof TypedArray;
1156    };
1157  }(typeof Uint8Array !== 'undefined' && getPrototypeOf(Uint8Array));
1158
1159  /**
1160   * For each entry in the object, call the function with the key and value.
1161   *
1162   * @param {Object<any, any>} obj - The object to iterate over.
1163   * @param {Function} fn - The function to call for each entry.
1164   *
1165   * @returns {void}
1166   */

1456        code: this.code,
1457        status: this.status
1458      };
1459    }
1460  });
1461  var prototype$1 = AxiosError.prototype;
1462  var descriptors = {};
1463  ['ERR_BAD_OPTION_VALUE', 'ERR_BAD_OPTION', 'ECONNABORTED', 'ETIMEDOUT', 'ERR_NETWORK', 'ERR_FR_TOO_MANY_REDIRECTS', 'ERR_DEPRECATED', 'ERR_BAD_RESPONSE', 'ERR_BAD_REQUEST', 'ERR_CANCELED', 'ERR_NOT_SUPPORT', 'ERR_INVALID_URL'
1464  // eslint-disable-next-line func-names
1465  ].forEach(function (code) {
1466    descriptors[code] = {
1467      value: code
1468    };
1469  });
1470  Object.defineProperties(AxiosError, descriptors);
1471  Object.defineProperty(prototype$1, 'isAxiosError', {
1472    value: true
1473  });
1474
1475  // eslint-disable-next-line func-names
1476  AxiosError.from = function (error, code, config, request, response, customProps) {
1477    var axiosError = Object.create(prototype$1);
1478    utils$1.toFlatObject(error, axiosError, function filter(obj) {
1479      return obj !== Error.prototype;
1480    }, function (prop) {
1481      return prop !== 'isAxiosError';
1482    });
1483    AxiosError.call(axiosError, error.message, code, config, request, response);
1484    axiosError.cause = error;
1485    axiosError.name = error.name;
1486    customProps && Object.assign(axiosError, customProps);
1487    return axiosError;
1488  };
1489
1490  // eslint-disable-next-line strict
1491  var httpAdapter = null;
1492
1493  /**
1494   * Determines if the given thing is a array or js object.
1495   *
1496   * @param {string} thing - The object or array to be visited.
1497   *
1498   * @returns {boolean}
1499   */
1500  function isVisitable(thing) {
1501    return utils$1.isPlainObject(thing) || utils$1.isArray(thing);
1502  }
1503
1504  /**
1505   * It removes the brackets from the end of a string
1506   *
1507   * @param {string} key - The key of the parameter.
1508   *
1509   * @returns {string} the key without the brackets.
1510   */
1511  function removeBrackets(key) {
1512    return utils$1.endsWith(key, '[]') ? key.slice(0, -2) : key;
1513  }
1514
1515  /**
1516   * It takes a path, a key, and a boolean, and returns a string
1517   *
1518   * @param {string} path - The path to the current key.
1519   * @param {string} key - The key of the current object being iterated over.
1520   * @param {string} dots - If true, the key will be rendered with dots instead of brackets.
1521   *
1522   * @returns {string} The path to the current key.
1523   */
1524  function renderKey(path, key, dots) {
1525    if (!path) return key;
1526    return path.concat(key).map(function each(token, i) {
1527      // eslint-disable-next-line no-param-reassign
1528      token = removeBrackets(token);
1529      return !dots && i ? '[' + token + ']' : token;
1530    }).join(dots ? '.' : '');
1531  }
1532
1533  /**
1534   * If the array is an array and none of its elements are visitable, then it's a flat array.
1535   *
1536   * @param {Array<any>} arr - The array to check
1537   *
1538   * @returns {boolean}
1539   */
1540  function isFlatArray(arr) {
1541    return utils$1.isArray(arr) && !arr.some(isVisitable);
1542  }
1543  var predicates = utils$1.toFlatObject(utils$1, {}, null, function filter(prop) {
1544    return /^is[A-Z]/.test(prop);
1545  });
1546
1547  /**
1548   * Convert a data object to FormData
1549   *
1550   * @param {Object} obj
1551   * @param {?Object} [formData]
1552   * @param {?Object} [options]
1553   * @param {Function} [options.visitor]
1554   * @param {Boolean} [options.metaTokens = true]
1555   * @param {Boolean} [options.dots = false]
1556   * @param {?Boolean} [options.indexes = false]
1557   *
1558   * @returns {Object}
1559   **/
1560
1561  /**
1562   * It converts an object into a FormData object
1563   *
1564   * @param {Object<any, any>} obj - The object to convert to form data.
1565   * @param {string} formData - The FormData object to append to.
1566   * @param {Object<string, any>} options
1567   *
1568   * @returns
1569   */
1570  function toFormData(obj, formData, options) {
1571    if (!utils$1.isObject(obj)) {
1572      throw new TypeError('target must be an object');
1573    }
1574
1575    // eslint-disable-next-line no-param-reassign
1576    formData = formData || new (FormData)();
1577
1578    // eslint-disable-next-line no-param-reassign
1579    options = utils$1.toFlatObject(options, {
1580      metaTokens: true,
1581      dots: false,
1582      indexes: false
1583    }, false, function defined(option, source) {
1584      // eslint-disable-next-line no-eq-null,eqeqeq
1585      return !utils$1.isUndefined(source[option]);
1586    });
1587    var metaTokens = options.metaTokens;
1588    // eslint-disable-next-line no-use-before-define
1589    var visitor = options.visitor || defaultVisitor;
1590    var dots = options.dots;
1591    var indexes = options.indexes;
1592    var _Blob = options.Blob || typeof Blob !== 'undefined' && Blob;
1593    var useBlob = _Blob && utils$1.isSpecCompliantForm(formData);
1594    if (!utils$1.isFunction(visitor)) {
1595      throw new TypeError('visitor must be a function');
1596    }
1597    function convertValue(value) {
1598      if (value === null) return '';
1599      if (utils$1.isDate(value)) {
1600        return value.toISOString();
1601      }
1602      if (!useBlob && utils$1.isBlob(value)) {
1603        throw new AxiosError('Blob is not supported. Use a Buffer instead.');
1604      }
1605      if (utils$1.isArrayBuffer(value) || utils$1.isTypedArray(value)) {
1606        return useBlob && typeof Blob === 'function' ? new Blob([value]) : Buffer.from(value);
1607      }
1608      return value;
1609    }
1610
1611    /**
1612     * Default visitor.
1613     *
1614     * @param {*} value
1615     * @param {String|Number} key
1616     * @param {Array<String|Number>} path
1617     * @this {FormData}
1618     *
1619     * @returns {boolean} return true to visit the each prop of the value recursively
1620     */
1621    function defaultVisitor(value, key, path) {
1622      var arr = value;
1623      if (value && !path && _typeof(value) === 'object') {
1624        if (utils$1.endsWith(key, '{}')) {
1625          // eslint-disable-next-line no-param-reassign
1626          key = metaTokens ? key : key.slice(0, -2);
1627          // eslint-disable-next-line no-param-reassign
1628          value = JSON.stringify(value);
1629        } else if (utils$1.isArray(value) && isFlatArray(value) || (utils$1.isFileList(value) || utils$1.endsWith(key, '[]')) && (arr = utils$1.toArray(value))) {
1630          // eslint-disable-next-line no-param-reassign
1631          key = removeBrackets(key);
1632          arr.forEach(function each(el, index) {
1633            !(utils$1.isUndefined(el) || el === null) && formData.append(
1634            // eslint-disable-next-line no-nested-ternary
1635            indexes === true ? renderKey([key], index, dots) : indexes === null ? key : key + '[]', convertValue(el));
1636          });
1637          return false;

1638        }
1639      }
1640      if (isVisitable(value)) {
1641        return true;
1642      }
1643      formData.append(renderKey(path, key, dots), convertValue(value));
1644      return false;
1645    }
1646    var stack = [];
1647    var exposedHelpers = Object.assign(predicates, {
1648      defaultVisitor: defaultVisitor,
1649      convertValue: convertValue,
1650      isVisitable: isVisitable
1651    });
1652    function build(value, path) {
1653      if (utils$1.isUndefined(value)) return;
1654      if (stack.indexOf(value) !== -1) {
1655        throw Error('Circular reference detected in ' + path.join('.'));
1656      }
1657      stack.push(value);
1658      utils$1.forEach(value, function each(el, key) {
1659        var result = !(utils$1.isUndefined(el) || el === null) && visitor.call(formData, el, utils$1.isString(key) ? key.trim() : key, path, exposedHelpers);
1660        if (result === true) {
1661          build(el, path ? path.concat(key) : [key]);
1662        }
1663      });
1664      stack.pop();
1665    }
1666    if (!utils$1.isObject(obj)) {
1667      throw new TypeError('data must be an object');
1668    }
1669    build(obj);
1670    return formData;
1671  }
1672
1673  /**
1674   * It encodes a string by replacing all characters that are not in the unreserved set with
1675   * their percent-encoded equivalents
1676   *
1677   * @param {string} str - The string to encode.
1678   *
1679   * @returns {string} The encoded string.
1680   */
1681  function encode$1(str) {
1682    var charMap = {
1683      '!': '%21',
1684      "'": '%27',
1685      '(': '%28',
1686      ')': '%29',
1687      '~': '%7E',
1688      '%20': '+',
1689      '%00': '\x00'
1690    };
1691    return encodeURIComponent(str).replace(/[!'()~]|%20|%00/g, function replacer(match) {
1692      return charMap[match];
1693    });
1694  }
1695
1696  /**
1697   * It takes a params object and converts it to a FormData object
1698   *
1699   * @param {Object<string, any>} params - The parameters to be converted to a FormData object.
1700   * @param {Object<string, any>} options - The options object passed to the Axios constructor.
1701   *
1702   * @returns {void}
1703   */
1704  function AxiosURLSearchParams(params, options) {
1705    this._pairs = [];
1706    params && toFormData(params, this, options);
1707  }
1708  var prototype = AxiosURLSearchParams.prototype;
1709  prototype.append = function append(name, value) {
1710    this._pairs.push([name, value]);
1711  };
1712  prototype.toString = function toString(encoder) {
1713    var _encode = encoder ? function (value) {
1714      return encoder.call(this, value, encode$1);
1715    } : encode$1;
1716    return this._pairs.map(function each(pair) {
1717      return _encode(pair[0]) + '=' + _encode(pair[1]);
1718    }, '').join('&');
1719  };
1720
1721  /**
1722   * It replaces all instances of the characters `:`, `$`, `,`, `+`, `[`, and `]` with their
1723   * URI encoded counterparts
1724   *
1725   * @param {string} val The value to be encoded.
1726   *
1727   * @returns {string} The encoded value.
1728   */
1729  function encode(val) {
1730    return encodeURIComponent(val).replace(/%3A/gi, ':').replace(/%24/g, '$').replace(/%2C/gi, ',').replace(/%20/g, '+').replace(/%5B/gi, '[').replace(/%5D/gi, ']');
1731  }
1732
1733  /**
1734   * Build a URL by appending params to the end
1735   *
1736   * @param {string} url The base of the url (e.g., http://www.google.com)
1737   * @param {object} [params] The params to be appended
1738   * @param {?(object|Function)} options
1739   *
1740   * @returns {string} The formatted url
1741   */
1742  function buildURL(url, params, options) {
1743    /*eslint no-param-reassign:0*/
1744    if (!params) {
1745      return url;
1746    }
1747    var _encode = options && options.encode || encode;
1748    if (utils$1.isFunction(options)) {
1749      options = {
1750        serialize: options
1751      };
1752    }
1753    var serializeFn = options && options.serialize;
1754    var serializedParams;
1755    if (serializeFn) {
1756      serializedParams = serializeFn(params, options);
1757    } else {
1758      serializedParams = utils$1.isURLSearchParams(params) ? params.toString() : new AxiosURLSearchParams(params, options).toString(_encode);
1759    }
1760    if (serializedParams) {
1761      var hashmarkIndex = url.indexOf("#");
1762      if (hashmarkIndex !== -1) {
1763        url = url.slice(0, hashmarkIndex);
1764      }
1765      url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;
1766    }
1767    return url;
1768  }
1769
1770  var InterceptorManager = /*#__PURE__*/function () {
1771    function InterceptorManager() {
1772      _classCallCheck(this, InterceptorManager);
1773      this.handlers = [];
1774    }
1775
1776    /**
1777     * Add a new interceptor to the stack
1778     *
1779     * @param {Function} fulfilled The function to handle `then` for a `Promise`
1780     * @param {Function} rejected The function to handle `reject` for a `Promise`
1781     *
1782     * @return {Number} An ID used to remove interceptor later
1783     */
1784    _createClass(InterceptorManager, [{
1785      key: "use",
1786      value: function use(fulfilled, rejected, options) {
1787        this.handlers.push({
1788          fulfilled: fulfilled,
1789          rejected: rejected,
1790          synchronous: options ? options.synchronous : false,
1791          runWhen: options ? options.runWhen : null
1792        });
1793        return this.handlers.length - 1;
1794      }
1795
1796      /**
1797       * Remove an interceptor from the stack
1798       *
1799       * @param {Number} id The ID that was returned by `use`
1800       *
1801       * @returns {Boolean} `true` if the interceptor was removed, `false` otherwise
1802       */
1803    }, {
1804      key: "eject",
1805      value: function eject(id) {
1806        if (this.handlers[id]) {
1807          this.handlers[id] = null;
1808        }
1809      }
1810
1811      /**
1812       * Clear all interceptors from the stack
1813       *
1814       * @returns {void}
1815       */
1816    }, {
1817      key: "clear",
1818      value: function clear() {
1819        if (this.handlers) {
1820          this.handlers = [];
1821        }
1822      }
1823
1824      /**
1825       * Iterate over all the registered interceptors
1826       *
1827       * This method is particularly useful for skipping over any
1828       * interceptors that may have become `null` calling `eject`.
1829       *
1830       * @param {Function} fn The function to call for each interceptor
1831       *
1832       * @returns {void}
1833       */
1834    }, {
1835      key: "forEach",
1836      value: function forEach(fn) {
1837        utils$1.forEach(this.handlers, function forEachHandler(h) {
1838          if (h !== null) {
1839            fn(h);
1840          }
1841        });
1842      }
1843    }]);
1844    return InterceptorManager;
1845  }();
1846  var InterceptorManager$1 = InterceptorManager;
1847
1848  var transitionalDefaults = {
1849    silentJSONParsing: true,
1850    forcedJSONParsing: true,
1851    clarifyTimeoutError: false
1852  };
1853
1854  var URLSearchParams$1 = typeof URLSearchParams !== 'undefined' ? URLSearchParams : AxiosURLSearchParams;
1855
1856  var FormData$1 = typeof FormData !== 'undefined' ? FormData : null;
1857
1858  var Blob$1 = typeof Blob !== 'undefined' ? Blob : null;
1859
1860  var platform$1 = {
1861    isBrowser: true,
1862    classes: {
1863      URLSearchParams: URLSearchParams$1,
1864      FormData: FormData$1,
1865      Blob: Blob$1
1866    },
1867    protocols: ['http', 'https', 'file', 'blob', 'url', 'data']
1868  };
1869
1870  var hasBrowserEnv = typeof window !== 'undefined' && typeof document !== 'undefined';
1871  var _navigator = (typeof navigator === "undefined" ? "undefined" : _typeof(navigator)) === 'object' && navigator || undefined;
1872
1873  /**
1874   * Determine if we're running in a standard browser environment
1875   *
1876   * This allows axios to run in a web worker, and react-native.
1877   * Both environments support XMLHttpRequest, but not fully standard globals.
1878   *
1879   * web workers:
1880   *  typeof window -> undefined
1881   *  typeof document -> undefined
1882   *
1883   * react-native:
1884   *  navigator.product -> 'ReactNative'
1885   * nativescript
1886   *  navigator.product -> 'NativeScript' or 'NS'
1887   *
1888   * @returns {boolean}
1889   */
1890  var hasStandardBrowserEnv = hasBrowserEnv && (!_navigator || ['ReactNative', 'NativeScript', 'NS'].indexOf(_navigator.product) < 0);
1891
1892  /**
1893   * Determine if we're running in a standard browser webWorker environment
1894   *
1895   * Although the `isStandardBrowserEnv` method indicates that
1896   * `allows axios to run in a web worker`, the WebWorker will still be
1897   * filtered out due to its judgment standard
1898   * `typeof window !== 'undefined' && typeof document !== 'undefined'`.
1899   * This leads to a problem when axios post `FormData` in webWorker
1900   */
1901  var hasStandardBrowserWebWorkerEnv = function () {
1902    return typeof WorkerGlobalScope !== 'undefined' &&
1903    // eslint-disable-next-line no-undef
1904    self instanceof WorkerGlobalScope && typeof self.importScripts === 'function';
1905  }();
1906  var origin = hasBrowserEnv && window.location.href || 'http://localhost';
1907
1908  var utils = /*#__PURE__*/Object.freeze({
1909    __proto__: null,
1910    hasBrowserEnv: hasBrowserEnv,
1911    hasStandardBrowserWebWorkerEnv: hasStandardBrowserWebWorkerEnv,
1912    hasStandardBrowserEnv: hasStandardBrowserEnv,
1913    navigator: _navigator,
1914    origin: origin
1915  });
1916
1917  var platform = _objectSpread2(_objectSpread2({}, utils), platform$1);
1918
1919  function toURLEncodedForm(data, options) {
1920    return toFormData(data, new platform.classes.URLSearchParams(), Object.assign({
1921      visitor: function visitor(value, key, path, helpers) {
1922        if (platform.isNode && utils$1.isBuffer(value)) {
1923          this.append(key, value.toString('base64'));
1924          return false;
1925        }
1926        return helpers.defaultVisitor.apply(this, arguments);
1927      }
1928    }, options));
1929  }
1930
1931  /**
1932   * It takes a string like `foo[x][y][z]` and returns an array like `['foo', 'x', 'y', 'z']
1933   *
1934   * @param {string} name - The name of the property to get.
1935   *

1936   * @returns An array of strings.
1937   */
1938  function parsePropPath(name) {
1939    // foo[x][y][z]
1940    // foo.x.y.z
1941    // foo-x-y-z
1942    // foo x y z
1943    return utils$1.matchAll(/\w+|\[(\w*)]/g, name).map(function (match) {
1944      return match[0] === '[]' ? '' : match[1] || match[0];
1945    });
1946  }
1947
1948  /**
1949   * Convert an array to an object.
1950   *
1951   * @param {Array<any>} arr - The array to convert to an object.
1952   *
1953   * @returns An object with the same keys and values as the array.
1954   */
1955  function arrayToObject(arr) {
1956    var obj = {};
1957    var keys = Object.keys(arr);
1958    var i;
1959    var len = keys.length;
1960    var key;
1961    for (i = 0; i < len; i++) {
1962      key = keys[i];
1963      obj[key] = arr[key];
1964    }
1965    return obj;
1966  }
1967
1968  /**
1969   * It takes a FormData object and returns a JavaScript object
1970   *
1971   * @param {string} formData The FormData object to convert to JSON.
1972   *
1973   * @returns {Object<string, any> | null} The converted object.
1974   */
1975  function formDataToJSON(formData) {
1976    function buildPath(path, value, target, index) {
1977      var name = path[index++];
1978      if (name === '__proto__') return true;
1979      var isNumericKey = Number.isFinite(+name);
1980      var isLast = index >= path.length;
1981      name = !name && utils$1.isArray(target) ? target.length : name;
1982      if (isLast) {
1983        if (utils$1.hasOwnProp(target, name)) {
1984          target[name] = [target[name], value];
1985        } else {
1986          target[name] = value;
1987        }
1988        return !isNumericKey;
1989      }
1990      if (!target[name] || !utils$1.isObject(target[name])) {
1991        target[name] = [];
1992      }
1993      var result = buildPath(path, value, target[name], index);
1994      if (result && utils$1.isArray(target[name])) {
1995        target[name] = arrayToObject(target[name]);
1996      }
1997      return !isNumericKey;
1998    }
1999    if (utils$1.isFormData(formData) && utils$1.isFunction(formData.entries)) {
2000      var obj = {};
2001      utils$1.forEachEntry(formData, function (name, value) {
2002        buildPath(parsePropPath(name), value, obj, 0);
2003      });
2004      return obj;
2005    }
2006    return null;
2007  }
2008
2009  /**
2010   * It takes a string, tries to parse it, and if it fails, it returns the stringified version
2011   * of the input
2012   *
2013   * @param {any} rawValue - The value to be stringified.
2014   * @param {Function} parser - A function that parses a string into a JavaScript object.
2015   * @param {Function} encoder - A function that takes a value and returns a string.
2016   *
2017   * @returns {string} A stringified version of the rawValue.
2018   */
2019  function stringifySafely(rawValue, parser, encoder) {
2020    if (utils$1.isString(rawValue)) {
2021      try {
2022        (parser || JSON.parse)(rawValue);
2023        return utils$1.trim(rawValue);
2024      } catch (e) {
2025        if (e.name !== 'SyntaxError') {
2026          throw e;
2027        }
2028      }
2029    }
2030    return (encoder || JSON.stringify)(rawValue);
2031  }
2032  var defaults = {
2033    transitional: transitionalDefaults,
2034    adapter: ['xhr', 'http', 'fetch'],
2035    transformRequest: [function transformRequest(data, headers) {
2036      var contentType = headers.getContentType() || '';
2037      var hasJSONContentType = contentType.indexOf('application/json') > -1;
2038      var isObjectPayload = utils$1.isObject(data);
2039      if (isObjectPayload && utils$1.isHTMLForm(data)) {
2040        data = new FormData(data);
2041      }
2042      var isFormData = utils$1.isFormData(data);
2043      if (isFormData) {
2044        return hasJSONContentType ? JSON.stringify(formDataToJSON(data)) : data;
2045      }
2046      if (utils$1.isArrayBuffer(data) || utils$1.isBuffer(data) || utils$1.isStream(data) || utils$1.isFile(data) || utils$1.isBlob(data) || utils$1.isReadableStream(data)) {
2047        return data;
2048      }
2049      if (utils$1.isArrayBufferView(data)) {
2050        return data.buffer;
2051      }
2052      if (utils$1.isURLSearchParams(data)) {
2053        headers.setContentType('application/x-www-form-urlencoded;charset=utf-8', false);
2054        return data.toString();
2055      }
2056      var isFileList;
2057      if (isObjectPayload) {
2058        if (contentType.indexOf('application/x-www-form-urlencoded') > -1) {
2059          return toURLEncodedForm(data, this.formSerializer).toString();
2060        }
2061        if ((isFileList = utils$1.isFileList(data)) || contentType.indexOf('multipart/form-data') > -1) {
2062          var _FormData = this.env && this.env.FormData;
2063          return toFormData(isFileList ? {
2064            'files[]': data
2065          }

2065 : data, _FormData && new _FormData(), this.formSerializer);
2066        }
2067      }
2068      if (isObjectPayload || hasJSONContentType) {
2069        headers.setContentType('application/json', false);
2070        return stringifySafely(data);
2071      }
2072      return data;
2073    }],
2074    transformResponse: [function transformResponse(data) {
2075      var transitional = this.transitional || defaults.transitional;
2076      var forcedJSONParsing = transitional && transitional.forcedJSONParsing;
2077      var JSONRequested = this.responseType === 'json';
2078      if (utils$1.isResponse(data) || utils$1.isReadableStream(data)) {
2079        return data;
2080      }
2081      if (data && utils$1.isString(data) && (forcedJSONParsing && !this.responseType || JSONRequested)) {
2082        var silentJSONParsing = transitional && transitional.silentJSONParsing;
2083        var strictJSONParsing = !silentJSONParsing && JSONRequested;
2084        try {
2085          return JSON.parse(data);
2086        } catch (e) {
2087          if (strictJSONParsing) {
2088            if (e.name === 'SyntaxError') {
2089              throw AxiosError.from(e, AxiosError.ERR_BAD_RESPONSE, this, null, this.response);
2090            }
2091            throw e;
2092          }
2093        }
2094      }
2095      return data;
2096    }],
2097    /**
2098     * A timeout in milliseconds to abort a request. If set to 0 (default) a
2099     * timeout is not created.
2100     */
2101    timeout: 0,
2102    xsrfCookieName: 'XSRF-TOKEN',
2103    xsrfHeaderName: 'X-XSRF-TOKEN',
2104    maxContentLength: -1,
2105    maxBodyLength: -1,
2106    env: {
2107      FormData: platform.classes.FormData,
2108      Blob: platform.classes.Blob
2109    },
2110    validateStatus: function validateStatus(status) {
2111      return status >= 200 && status < 300;
2112    },
2113    headers: {
2114      common: {
2115        'Accept': 'application/json, text/plain, */*',
2116        'Content-Type': undefined
2117      }
2118    }
2119  };
2120  utils$1.forEach(['delete', 'get', 'head', 'post', 'put', 'patch'], function (method) {
2121    defaults.headers[method] = {};
2122  });
2123  var defaults$1 = defaults;
2124
2125  // RawAxiosHeaders whose duplicates are ignored by node
2126  // c.f. https://nodejs.org/api/http.html#http_message_headers
2127  var ignoreDuplicateOf = utils$1.toObjectSet(['age', 'authorization', 'content-length', 'content-type', 'etag', 'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since', 'last-modified', 'location', 'max-forwards', 'proxy-authorization', 'referer', 'retry-after', 'user-agent']);
2128
2129  /**
2130   * Parse headers into an object
2131   *
2132   * ```
2133   * Date: Wed, 27 Aug 2014 08:58:49 GMT
2134   * Content-Type: application/json
2135   * Connection: keep-alive
2136   * Transfer-Encoding: chunked
2137   * ```
2138   *
2139   * @param {String} rawHeaders Headers needing to be parsed
2140   *
2141   * @returns {Object} Headers parsed into an object
2142   */
2143  var parseHeaders = (function (rawHeaders) {
2144    var parsed = {};
2145    var key;
2146    var val;
2147    var i;
2148    rawHeaders && rawHeaders.split('\n').forEach(function parser(line) {
2149      i = line.indexOf(':');
2150      key = line.substring(0, i).trim().toLowerCase();
2151      val = line.substring(i + 1).trim();
2152      if (!key || parsed[key] && ignoreDuplicateOf[key]) {
2153        return;
2154      }
2155      if (key === 'set-cookie') {
2156        if (parsed[key]) {
2157          parsed[key].push(val);
2158        } else {
2159          parsed[key] = [val];
2160        }
2161      } else {
2162        parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
2163      }
2164    });
2165    return parsed;
2166  });
2167
2168  var $internals = Symbol('internals');
2169  function normalizeHeader(header) {
2170    return header && String(header).trim().toLowerCase();
2171  }
2172  function normalizeValue(value) {
2173    if (value === false || value == null) {
2174      return value;
2175    }
2176    return utils$1.isArray(value) ? value.map(normalizeValue) : String(value);
2177  }
2178  function parseTokens(str) {
2179    var tokens = Object.create(null);
2180    var tokensRE = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;
2181    var match;
2182    while (match = tokensRE.exec(str)) {
2183      tokens[match[1]] = match[2];
2184    }
2185    return tokens;
2186  }
2187  var isValidHeaderName = function isValidHeaderName(str) {
2188    return /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim());
2189  };
2190  function matchHeaderValue(context, value, header, filter, isHeaderNameFilter) {
2191    if (utils$1.isFunction(filter)) {
2192      return filter.call(this, value, header);
2193    }
2194    if (isHeaderNameFilter) {
2195      value = header;
2196    }
2197    if (!utils$1.isString(value)) return;
2198    if (utils$1.isString(filter)) {
2199      return value.indexOf(filter) !== -1;
2200    }
2201    if (utils$1.isRegExp(filter)) {
2202      return filter.test(value);
2203    }
2204  }
2205  function formatHeader(header) {
2206    return header.trim().toLowerCase().replace(/([a-z\d])(\w*)/g, function (w, _char, str) {
2207      return _char.toUpperCase() + str;
2208    });
2209  }
2210  function buildAccessors(obj, header) {
2211    var accessorName = utils$1.toCamelCase(' ' + header);
2212    ['get', 'set', 'has'].forEach(function (methodName) {
2213      Object.defineProperty(obj, methodName + accessorName, {
2214        value: function value(arg1, arg2, arg3) {
2215          return this[methodName].call(this, header, arg1, arg2, arg3);
2216        },
2217        configurable: true
2218      });
2219    });
2220  }

2221  var AxiosHeaders = /*#__PURE__*/function (_Symbol$iterator, _Symbol$toStringTag) {
2222    function AxiosHeaders(headers) {
2223      _classCallCheck(this, AxiosHeaders);
2224      headers && this.set(headers);
2225    }
2226    _createClass(AxiosHeaders, [{
2227      key: "set",
2228      value: function set(header, valueOrRewrite, rewrite) {
2229        var self = this;
2230        function setHeader(_value, _header, _rewrite) {
2231          var lHeader = normalizeHeader(_header);
2232          if (!lHeader) {
2233            throw new Error('header name must be a non-empty string');
2234          }
2235          var key = utils$1.findKey(self, lHeader);
2236          if (!key || self[key] === undefined || _rewrite === true || _rewrite === undefined && self[key] !== false) {
2237            self[key || _header] = normalizeValue(_value);
2238          }
2239        }
2240        var setHeaders = function setHeaders(headers, _rewrite) {
2241          return utils$1.forEach(headers, function (_value, _header) {
2242            return setHeader(_value, _header, _rewrite);
2243          });
2244        };
2245        if (utils$1.isPlainObject(header) || header instanceof this.constructor) {
2246          setHeaders(header, valueOrRewrite);
2247        } else if (utils$1.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {
2248          setHeaders(parseHeaders(header), valueOrRewrite);
2249        } else if (utils$1.isHeaders(header)) {
2250          var _iterator = _createForOfIteratorHelper(header.entries()),
2251            _step;
2252          try {
2253            for (_iterator.s(); !(_step = _iterator.n()).done;) {
2254              var _step$value = _slicedToArray(_step.value, 2),
2255                key = _step$value[0],
2256                value = _step$value[1];
2257              setHeader(value, key, rewrite);
2258            }
2259          } catch (err) {
2260            _iterator.e(err);
2261          } finally {
2262            _iterator.f();
2263          }
2264        } else {
2265          header != null && setHeader(valueOrRewrite, header, rewrite);
2266        }
2267        return this;
2268      }
2269    }, {
2270      key: "get",
2271      value: function get(header, parser) {
2272        header = normalizeHeader(header);
2273        if (header) {
2274          var key = utils$1.findKey(this, header);
2275          if (key) {
2276            var value = this[key];
2277            if (!parser) {
2278              return value;
2279            }
2280            if (parser === true) {
2281              return parseTokens(value);
2282            }
2283            if (utils$1.isFunction(parser)) {
2284              return parser.call(this, value, key);
2285            }
2286            if (utils$1.isRegExp(parser)) {
2287              return parser.exec(value);
2288            }
2289            throw new TypeError('parser must be boolean|regexp|function');
2290          }
2291        }
2292      }
2293    }, {
2294      key: "has",
2295      value: function has(header, matcher) {
2296        header = normalizeHeader(header);
2297        if (header) {
2298          var key = utils$1.findKey(this, header);
2299          return !!(key && this[key] !== undefined && (!matcher || matchHeaderValue(this, this[key], key, matcher)));
2300        }
2301        return false;
2302      }
2303    }, {
2304      key: "delete",
2305      value: function _delete(header, matcher) {
2306        var self = this;
2307        var deleted = false;
2308        function deleteHeader(_header) {
2309          _header = normalizeHeader(_header);
2310          if (_header) {
2311            var key = utils$1.findKey(self, _header);
2312            if (key && (!matcher || matchHeaderValue(self, self[key], key, matcher))) {
2313              delete self[key];
2314              deleted = true;
2315            }
2316          }
2317        }
2318        if (utils$1.isArray(header)) {
2319          header.forEach(deleteHeader);
2320        } else {
2321          deleteHeader(header);
2322        }
2323        return deleted;
2324      }
2325    }, {
2326      key: "clear",
2327      value: function clear(matcher) {
2328        var keys = Object.keys(this);
2329        var i = keys.length;
2330        var deleted = false;
2331        while (i--) {
2332          var key = keys[i];
2333          if (!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {
2334            delete this[key];
2335            deleted = true;
2336          }
2337        }
2338        return deleted;
2339      }
2340    }, {
2341      key: "normalize",
2342      value: function normalize(format) {
2343        var self = this;
2344        var headers = {};
2345        utils$1.forEach(this, function (value, header) {
2346          var key = utils$1.findKey(headers, header);
2347          if (key) {
2348            self[key] = normalizeValue(value);
2349            delete self[header];
2350            return;
2351          }
2352          var normalized = format ? formatHeader(header) : String(header).trim();
2353          if (normalized !== header) {
2354            delete self[header];
2355          }
2356          self[normalized] = normalizeValue(value);
2357          headers[normalized] = true;
2358        });
2359        return this;
2360      }
2361    }, {
2362      key: "concat",
2363      value: function concat() {
2364        var _this$constructor;
2365        for (var _len = arguments.length, targets = new Array(_len), _key = 0; _key < _len; _key++) {
2366          targets[_key] = arguments[_key];
2367        }
2368        return (_this$constructor = this.constructor).concat.apply(_this$constructor, [this].concat(targets));
2369      }
2370    }, {
2371      key: "toJSON",
2372      value: function toJSON(asStrings) {
2373        var obj = Object.create(null);
2374        utils$1.forEach(this, function (value, header) {
2375          value != null && value !== false && (obj[header] = asStrings && utils$1.isArray(value) ? value.join(', ') : value);
2376        });
2377        return obj;
2378      }
2379    }, {
2380      key: _Symbol$iterator,
2381      value: function value() {
2382        return Object.entries(this.toJSON())[Symbol.iterator]();
2383      }
2384    }, {
2385      key: "toString",
2386      value: function toString() {
2387        return Object.entries(this.toJSON()).map(function (_ref) {
2388          var _ref2 = _slicedToArray(_ref, 2),
2389            header = _ref2[0],
2390            value = _ref2[1];
2391          return header + ': ' + value;
2392        }).join('\n');
2393      }
2394    }, {
2395      key: _Symbol$toStringTag,
2396      get: function get() {
2397        return 'AxiosHeaders';
2398      }
2399    }], [{
2400      key: "from",
2401      value: function from(thing) {
2402        return thing instanceof this ? thing : new this(thing);
2403      }
2404    }, {
2405      key: "concat",
2406      value: function concat(first) {
2407        var computed = new this(first);
2408        for (var _len2 = arguments.length, targets = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
2409          targets[_key2 - 1] = arguments[_key2];
2410        }
2411        targets.forEach(function (target) {
2412          return computed.set(target);
2413        });
2414        return computed;
2415      }
2416    }, {
2417      key: "accessor",
2418      value: function accessor(header) {
2419        var internals = this[$internals] = this[$internals] = {
2420          accessors: {}
2421        };
2422        var accessors = internals.accessors;
2423        var prototype = this.prototype;
2424        function defineAccessor(_header) {
2425          var lHeader = normalizeHeader(_header);
2426          if (!accessors[lHeader]) {
2427            buildAccessors(prototype, _header);
2428            accessors[lHeader] = true;
2429          }
2430        }
2431        utils$1.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);
2432        return this;
2433      }
2434    }]);
2435    return AxiosHeaders;
2436  }(Symbol.iterator, Symbol.toStringTag);
2437  AxiosHeaders.accessor(['Content-Type', 'Content-Length', 'Accept', 'Accept-Encoding', 'User-Agent', 'Authorization']);
2438
2439  // reserved names hotfix
2440  utils$1.reduceDescriptors(AxiosHeaders.prototype, function (_ref3, key) {
2441    var value = _ref3.value;
2442    var mapped = key[0].toUpperCase() + key.slice(1); // map `set` => `Set`
2443    return {
2444      get: function get() {
2445        return value;
2446      },
2447      set: function set(headerValue) {
2448        this[mapped] = headerValue;
2449      }
2450    };
2451  });
2452  utils$1.freezeMethods(AxiosHeaders);
2453  var AxiosHeaders$1 = AxiosHeaders;
2454
2455  /**
2456   * Transform the data for a request or a response
2457   *
2458   * @param {Array|Function} fns A single function or Array of functions
2459   * @param {?Object} response The response object
2460   *
2461   * @returns {*} The resulting transformed data
2462   */
2463  function transformData(fns, response) {
2464    var config = this || defaults$1;
2465    var context = response || config;
2466    var headers = AxiosHeaders$1.from(context.headers);
2467    var data = context.data;

2468    utils$1.forEach(fns, function transform(fn) {
2469      data = fn.call(config, data, headers.normalize(), response ? response.status : undefined);
2470    });
2471    headers.normalize();
2472    return data;
2473  }
2474
2475  function isCancel(value) {
2476    return !!(value && value.__CANCEL__);
2477  }
2478
2479  /**
2480   * A `CanceledError` is an object that is thrown when an operation is canceled.
2481   *
2482   * @param {string=} message The message.
2483   * @param {Object=} config The config.
2484   * @param {Object=} request The request.
2485   *
2486   * @returns {CanceledError} The created error.
2487   */
2488  function CanceledError(message, config, request) {
2489    // eslint-disable-next-line no-eq-null,eqeqeq
2490    AxiosError.call(this, message == null ? 'canceled' : message, AxiosError.ERR_CANCELED, config, request);
2491    this.name = 'CanceledError';
2492  }
2493  utils$1.inherits(CanceledError, AxiosError, {
2494    __CANCEL__: true
2495  });
2496
2497  /**
2498   * Resolve or reject a Promise based on response status.
2499   *
2500   * @param {Function} resolve A function that resolves the promise.
2501   * @param {Function} reject A function that rejects the promise.
2502   * @param {object} response The response.
2503   *
2504   * @returns {object} The response.
2505   */
2506  function settle(resolve, reject, response) {
2507    var validateStatus = response.config.validateStatus;
2508    if (!response.status || !validateStatus || validateStatus(response.status)) {
2509      resolve(response);
2510    } else {
2511      reject(new AxiosError('Request failed with status code ' + response.status, [AxiosError.ERR_BAD_REQUEST, AxiosError.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4], response.config, response.request, response));
2512    }
2513  }
2514
2515  function parseProtocol(url) {
2516    var match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url);
2517    return match && match[1] || '';
2518  }
2519
2520  /**
2521   * Calculate data maxRate
2522   * @param {Number} [samplesCount= 10]
2523   * @param {Number} [min= 1000]
2524   * @returns {Function}
2525   */
2526  function speedometer(samplesCount, min) {
2527    samplesCount = samplesCount || 10;
2528    var bytes = new Array(samplesCount);
2529    var timestamps = new Array(samplesCount);
2530    var head = 0;
2531    var tail = 0;
2532    var firstSampleTS;
2533    min = min !== undefined ? min : 1000;
2534    return function push(chunkLength) {
2535      var now = Date.now();
2536      var startedAt = timestamps[tail];
2537      if (!firstSampleTS) {
2538        firstSampleTS = now;
2539      }
2540      bytes[head] = chunkLength;
2541      timestamps[head] = now;
2542      var i = tail;
2543      var bytesCount = 0;
2544      while (i !== head) {
2545        bytesCount += bytes[i++];
2546        i = i % samplesCount;
2547      }
2548      head = (head + 1) % samplesCount;
2549      if (head === tail) {
2550        tail = (tail + 1) % samplesCount;
2551      }
2552      if (now - firstSampleTS < min) {
2553        return;
2554      }
2555      var passed = startedAt && now - startedAt;
2556      return passed ? Math.round(bytesCount * 1000 / passed) : undefined;
2557    };
2558  }
2559
2560  /**
2561   * Throttle decorator
2562   * @param {Function} fn
2563   * @param {Number} freq
2564   * @return {Function}
2565   */
2566  function throttle(fn, freq) {
2567    var timestamp = 0;
2568    var threshold = 1000 / freq;
2569    var lastArgs;
2570    var timer;
2571    var invoke = function invoke(args) {
2572      var now = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Date.now();
2573      timestamp = now;
2574      lastArgs = null;
2575      if (timer) {
2576        clearTimeout(timer);
2577        timer = null;
2578      }
2579      fn.apply(null, args);
2580    };
2581    var throttled = function throttled() {
2582      var now = Date.now();
2583      var passed = now - timestamp;
2584      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
2585        args[_key] = arguments[_key];
2586      }
2587      if (passed >= threshold) {
2588        invoke(args, now);
2589      } else {
2590        lastArgs = args;
2591        if (!timer) {
2592          timer = setTimeout(function () {
2593            timer = null;
2594            invoke(lastArgs);
2595          }, threshold - passed);
2596        }
2597      }
2598    };
2599    var flush = function flush() {
2600      return lastArgs && invoke(lastArgs);
2601    };
2602    return [throttled, flush];
2603  }
2604
2605  var progressEventReducer = function progressEventReducer(listener, isDownloadStream) {
2606    var freq = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 3;
2607    var bytesNotified = 0;
2608    var _speedometer = speedometer(50, 250);
2609    return throttle(function (e) {
2610      var loaded = e.loaded;
2611      var total = e.lengthComputable ? e.total : undefined;
2612      var progressBytes = loaded - bytesNotified;
2613      var rate = _speedometer(progressBytes);
2614      var inRange = loaded <= total;
2615      bytesNotified = loaded;
2616      var data = _defineProperty({
2617        loaded: loaded,
2618        total: total,
2619        progress: total ? loaded / total : undefined,
2620        bytes: progressBytes,
2621        rate: rate ? rate : undefined,
2622        estimated: rate && total && inRange ? (total - loaded) / rate : undefined,
2623        event: e,
2624        lengthComputable: total != null
2625      }, isDownloadStream ? 'download' : 'upload', true);
2626      listener(data);
2627    }, freq);
2628  };
2629  var progressEventDecorator = function progressEventDecorator(total, throttled) {
2630    var lengthComputable = total != null;
2631    return [function (loaded) {
2632      return throttled[0]({
2633        lengthComputable: lengthComputable,
2634        total: total,
2635        loaded: loaded
2636      });
2637    }, throttled[1]];
2638  };
2639  var asyncDecorator = function asyncDecorator(fn) {
2640    return function () {
2641      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
2642        args[_key] = arguments[_key];
2643      }
2644      return utils$1.asap(function () {
2645        return fn.apply(void 0, args);
2646      });
2647    };
2648  };
2649
2650  var isURLSameOrigin = platform.hasStandardBrowserEnv ? function (origin, isMSIE) {
2651    return function (url) {
2652      url = new URL(url, platform.origin);
2653      return origin.protocol === url.protocol && origin.host === url.host && (isMSIE || origin.port === url.port);
2654    };
2655  }