axios 1.1.3 → 1.3.4

package/dist/axios.js

@@ -1,4 +1,4 @@
-// Axios v1.1.3 Copyright (c) 2022 Matt Zabriskie and contributors
+// Axios v1.3.4 Copyright (c) 2023 Matt Zabriskie and contributors
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
   typeof define === 'function' && define.amd ? define(factory) :
@@ -36,6 +36,52 @@
     });
     return Constructor;
   }
+  function _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+  }
+  function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+  }
+  function _iterableToArrayLimit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+      for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+        _arr.push(_s.value);
+        if (i && _arr.length === i) break;
+      }
+    } catch (err) {
+      _d = true;
+      _e = err;
+    } finally {
+      try {
+        if (!_n && _i["return"] != null) _i["return"]();
+      } finally {
+        if (_d) throw _e;
+      }
+    }
+    return _arr;
+  }
+  function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(o);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+  }
+  function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+    return arr2;
+  }
+  function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
 
   function bind(fn, thisArg) {
     return function wrap() {
@@ -274,7 +320,7 @@
    * @param {Function} fn The callback to invoke for each item
    *
    * @param {Boolean} [allOwnKeys = false]
-   * @returns {void}
+   * @returns {any}
    */
   function forEach(obj, fn) {
     var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
@@ -308,6 +354,27 @@
       }
     }
   }
+  function findKey(obj, key) {
+    key = key.toLowerCase();
+    var keys = Object.keys(obj);
+    var i = keys.length;
+    var _key;
+    while (i-- > 0) {
+      _key = keys[i];
+      if (key === _key.toLowerCase()) {
+        return _key;
+      }
+    }
+    return null;
+  }
+  var _global = function () {
+    /*eslint no-undef:0*/
+    if (typeof globalThis !== "undefined") return globalThis;
+    return typeof self !== "undefined" ? self : typeof window !== 'undefined' ? window : global;
+  }();
+  var isContextDefined = function isContextDefined(context) {
+    return !isUndefined(context) && context !== _global;
+  };
 
   /**
    * Accepts varargs expecting each argument to be an object, then
@@ -329,16 +396,19 @@
    */
   function /* obj1, obj2, obj3, ... */
   merge() {
+    var _ref2 = isContextDefined(this) && this || {},
+      caseless = _ref2.caseless;
     var result = {};
     var assignValue = function assignValue(val, key) {
-      if (isPlainObject(result[key]) && isPlainObject(val)) {
-        result[key] = merge(result[key], val);
+      var targetKey = caseless && findKey(result, key) || key;
+      if (isPlainObject(result[targetKey]) && isPlainObject(val)) {
+        result[targetKey] = merge(result[targetKey], val);
       } else if (isPlainObject(val)) {
-        result[key] = merge({}, val);
+        result[targetKey] = merge({}, val);
       } else if (isArray(val)) {
-        result[key] = val.slice();
+        result[targetKey] = val.slice();
       } else {
-        result[key] = val;
+        result[targetKey] = val;
       }
     };
     for (var i = 0, l = arguments.length; i < l; i++) {
@@ -358,8 +428,8 @@
    * @returns {Object} The resulting value of object a
    */
   var extend = function extend(a, b, thisArg) {
-    var _ref2 = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {},
-      allOwnKeys = _ref2.allOwnKeys;
+    var _ref3 = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {},
+      allOwnKeys = _ref3.allOwnKeys;
     forEach(b, function (val, key) {
       if (thisArg && isFunction(val)) {
         a[key] = bind(val, thisArg);
@@ -528,14 +598,14 @@
   /* Checking if the kindOfTest function returns true when passed an HTMLFormElement. */
   var isHTMLForm = kindOfTest('HTMLFormElement');
   var toCamelCase = function toCamelCase(str) {
-    return str.toLowerCase().replace(/[_-\s]([a-z\d])(\w*)/g, function replacer(m, p1, p2) {
+    return str.toLowerCase().replace(/[-_\s]([a-z\d])(\w*)/g, function replacer(m, p1, p2) {
       return p1.toUpperCase() + p2;
     });
   };
 
   /* Creating a function that will check if an object has a property. */
-  var hasOwnProperty = function (_ref3) {
-    var hasOwnProperty = _ref3.hasOwnProperty;
+  var hasOwnProperty = function (_ref4) {
+    var hasOwnProperty = _ref4.hasOwnProperty;
     return function (obj, prop) {
       return hasOwnProperty.call(obj, prop);
     };
@@ -567,6 +637,10 @@
 
   var freezeMethods = function freezeMethods(obj) {
     reduceDescriptors(obj, function (descriptor, name) {
+      // skip restricted props in strict mode
+      if (isFunction(obj) && ['arguments', 'caller', 'callee'].indexOf(name) !== -1) {
+        return false;
+      }
       var value = obj[name];
       if (!isFunction(value)) return;
       descriptor.enumerable = false;
@@ -576,7 +650,7 @@
       }
       if (!descriptor.set) {
         descriptor.set = function () {
-          throw Error('Can not read-only method \'' + name + '\'');
+          throw Error('Can not rewrite read-only method \'' + name + '\'');
         };
       }
     });
@@ -596,6 +670,56 @@
     value = +value;
     return Number.isFinite(value) ? value : defaultValue;
   };
+  var ALPHA = 'abcdefghijklmnopqrstuvwxyz';
+  var DIGIT = '0123456789';
+  var ALPHABET = {
+    DIGIT: DIGIT,
+    ALPHA: ALPHA,
+    ALPHA_DIGIT: ALPHA + ALPHA.toUpperCase() + DIGIT
+  };
+  var generateString = function generateString() {
+    var size = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 16;
+    var alphabet = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ALPHABET.ALPHA_DIGIT;
+    var str = '';
+    var length = alphabet.length;
+    while (size--) {
+      str += alphabet[Math.random() * length | 0];
+    }
+    return str;
+  };
+
+  /**
+   * If the thing is a FormData object, return true, otherwise return false.
+   *
+   * @param {unknown} thing - The thing to check.
+   *
+   * @returns {boolean}
+   */
+  function isSpecCompliantForm(thing) {
+    return !!(thing && isFunction(thing.append) && thing[Symbol.toStringTag] === 'FormData' && thing[Symbol.iterator]);
+  }
+  var toJSONObject = function toJSONObject(obj) {
+    var stack = new Array(10);
+    var visit = function visit(source, i) {
+      if (isObject(source)) {
+        if (stack.indexOf(source) >= 0) {
+          return;
+        }
+        if (!('toJSON' in source)) {
+          stack[i] = source;
+          var target = isArray(source) ? [] : {};
+          forEach(source, function (value, key) {
+            var reducedValue = visit(value, i + 1);
+            !isUndefined(reducedValue) && (target[key] = reducedValue);
+          });
+          stack[i] = undefined;
+          return target;
+        }
+      }
+      return source;
+    };
+    return visit(obj, 0);
+  };
   var utils = {
     isArray: isArray,
     isArrayBuffer: isArrayBuffer,
@@ -639,7 +763,14 @@
     toObjectSet: toObjectSet,
     toCamelCase: toCamelCase,
     noop: noop,
-    toFiniteNumber: toFiniteNumber
+    toFiniteNumber: toFiniteNumber,
+    findKey: findKey,
+    global: _global,
+    isContextDefined: isContextDefined,
+    ALPHABET: ALPHABET,
+    generateString: generateString,
+    isSpecCompliantForm: isSpecCompliantForm,
+    toJSONObject: toJSONObject
   };
 
   /**
@@ -682,7 +813,7 @@
         columnNumber: this.columnNumber,
         stack: this.stack,
         // Axios
-        config: this.config,
+        config: utils.toJSONObject(this.config),
         code: this.code,
         status: this.response && this.response.status ? this.response.status : null
       };
@@ -717,8 +848,8 @@
     return axiosError;
   };
 
-  /* eslint-env browser */
-  var browser = (typeof self === "undefined" ? "undefined" : _typeof(self)) == 'object' ? self.FormData : window.FormData;
+  // eslint-disable-next-line strict
+  var httpAdapter = null;
 
   /**
    * Determines if the given thing is a array or js object.
@@ -774,17 +905,6 @@
     return /^is[A-Z]/.test(prop);
   });
 
-  /**
-   * If the thing is a FormData object, return true, otherwise return false.
-   *
-   * @param {unknown} thing - The thing to check.
-   *
-   * @returns {boolean}
-   */
-  function isSpecCompliant(thing) {
-    return thing && utils.isFunction(thing.append) && thing[Symbol.toStringTag] === 'FormData' && thing[Symbol.iterator];
-  }
-
   /**
    * Convert a data object to FormData
    *
@@ -814,7 +934,7 @@
     }
 
     // eslint-disable-next-line no-param-reassign
-    formData = formData || new (browser || FormData)();
+    formData = formData || new (FormData)();
 
     // eslint-disable-next-line no-param-reassign
     options = utils.toFlatObject(options, {
@@ -831,7 +951,7 @@
     var dots = options.dots;
     var indexes = options.indexes;
     var _Blob = options.Blob || typeof Blob !== 'undefined' && Blob;
-    var useBlob = _Blob && isSpecCompliant(formData);
+    var useBlob = _Blob && utils.isSpecCompliantForm(formData);
     if (!utils.isFunction(visitor)) {
       throw new TypeError('visitor must be a function');
     }
@@ -867,7 +987,7 @@
           key = metaTokens ? key : key.slice(0, -2);
           // eslint-disable-next-line no-param-reassign
           value = JSON.stringify(value);
-        } else if (utils.isArray(value) && isFlatArray(value) || utils.isFileList(value) || utils.endsWith(key, '[]') && (arr = utils.toArray(value))) {
+        } else if (utils.isArray(value) && isFlatArray(value) || (utils.isFileList(value) || utils.endsWith(key, '[]')) && (arr = utils.toArray(value))) {
           // eslint-disable-next-line no-param-reassign
           key = removeBrackets(key);
           arr.forEach(function each(el, index) {
@@ -1079,6 +1199,7 @@
     }]);
     return InterceptorManager;
   }();
+  var InterceptorManager$1 = InterceptorManager;
 
   var transitionalDefaults = {
     silentJSONParsing: true,
@@ -1088,7 +1209,9 @@
 
   var URLSearchParams$1 = typeof URLSearchParams !== 'undefined' ? URLSearchParams : AxiosURLSearchParams;
 
-  var FormData$1 = FormData;
+  var FormData$1 = typeof FormData !== 'undefined' ? FormData : null;
+
+  var Blob$1 = typeof Blob !== 'undefined' ? Blob : null;
 
   /**
    * Determine if we're running in a standard browser environment
@@ -1114,14 +1237,30 @@
     }
     return typeof window !== 'undefined' && typeof document !== 'undefined';
   }();
+
+  /**
+   * Determine if we're running in a standard browser webWorker environment
+   *
+   * Although the `isStandardBrowserEnv` method indicates that
+   * `allows axios to run in a web worker`, the WebWorker will still be
+   * filtered out due to its judgment standard
+   * `typeof window !== 'undefined' && typeof document !== 'undefined'`.
+   * This leads to a problem when axios post `FormData` in webWorker
+   */
+  var isStandardBrowserWebWorkerEnv = function () {
+    return typeof WorkerGlobalScope !== 'undefined' &&
+    // eslint-disable-next-line no-undef
+    self instanceof WorkerGlobalScope && typeof self.importScripts === 'function';
+  }();
   var platform = {
     isBrowser: true,
     classes: {
       URLSearchParams: URLSearchParams$1,
       FormData: FormData$1,
-      Blob: Blob
+      Blob: Blob$1
     },
     isStandardBrowserEnv: isStandardBrowserEnv,
+    isStandardBrowserWebWorkerEnv: isStandardBrowserWebWorkerEnv,
     protocols: ['http', 'https', 'file', 'blob', 'url', 'data']
   };
 
@@ -1214,201 +1353,143 @@
     return null;
   }
 
+  var DEFAULT_CONTENT_TYPE = {
+    'Content-Type': undefined
+  };
+
   /**
-   * Resolve or reject a Promise based on response status.
+   * It takes a string, tries to parse it, and if it fails, it returns the stringified version
+   * of the input
    *
-   * @param {Function} resolve A function that resolves the promise.
-   * @param {Function} reject A function that rejects the promise.
-   * @param {object} response The response.
+   * @param {any} rawValue - The value to be stringified.
+   * @param {Function} parser - A function that parses a string into a JavaScript object.
+   * @param {Function} encoder - A function that takes a value and returns a string.
    *
-   * @returns {object} The response.
+   * @returns {string} A stringified version of the rawValue.
    */
-  function settle(resolve, reject, response) {
-    var validateStatus = response.config.validateStatus;
-    if (!response.status || !validateStatus || validateStatus(response.status)) {
-      resolve(response);
-    } else {
-      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));
+  function stringifySafely(rawValue, parser, encoder) {
+    if (utils.isString(rawValue)) {
+      try {
+        (parser || JSON.parse)(rawValue);
+        return utils.trim(rawValue);
+      } catch (e) {
+        if (e.name !== 'SyntaxError') {
+          throw e;
+        }
+      }
     }
+    return (encoder || JSON.stringify)(rawValue);
   }
-
-  var cookies = platform.isStandardBrowserEnv ?
-  // Standard browser envs support document.cookie
-  function standardBrowserEnv() {
-    return {
-      write: function write(name, value, expires, path, domain, secure) {
-        var cookie = [];
-        cookie.push(name + '=' + encodeURIComponent(value));
-        if (utils.isNumber(expires)) {
-          cookie.push('expires=' + new Date(expires).toGMTString());
+  var defaults = {
+    transitional: transitionalDefaults,
+    adapter: ['xhr', 'http'],
+    transformRequest: [function transformRequest(data, headers) {
+      var contentType = headers.getContentType() || '';
+      var hasJSONContentType = contentType.indexOf('application/json') > -1;
+      var isObjectPayload = utils.isObject(data);
+      if (isObjectPayload && utils.isHTMLForm(data)) {
+        data = new FormData(data);
+      }
+      var isFormData = utils.isFormData(data);
+      if (isFormData) {
+        if (!hasJSONContentType) {
+          return data;
         }
-        if (utils.isString(path)) {
-          cookie.push('path=' + path);
+        return hasJSONContentType ? JSON.stringify(formDataToJSON(data)) : data;
+      }
+      if (utils.isArrayBuffer(data) || utils.isBuffer(data) || utils.isStream(data) || utils.isFile(data) || utils.isBlob(data)) {
+        return data;
+      }
+      if (utils.isArrayBufferView(data)) {
+        return data.buffer;
+      }
+      if (utils.isURLSearchParams(data)) {
+        headers.setContentType('application/x-www-form-urlencoded;charset=utf-8', false);
+        return data.toString();
+      }
+      var isFileList;
+      if (isObjectPayload) {
+        if (contentType.indexOf('application/x-www-form-urlencoded') > -1) {
+          return toURLEncodedForm(data, this.formSerializer).toString();
         }
-        if (utils.isString(domain)) {
-          cookie.push('domain=' + domain);
+        if ((isFileList = utils.isFileList(data)) || contentType.indexOf('multipart/form-data') > -1) {
+          var _FormData = this.env && this.env.FormData;
+          return toFormData(isFileList ? {
+            'files[]': data
+          } : data, _FormData && new _FormData(), this.formSerializer);
         }
-        if (secure === true) {
-          cookie.push('secure');
+      }
+      if (isObjectPayload || hasJSONContentType) {
+        headers.setContentType('application/json', false);
+        return stringifySafely(data);
+      }
+      return data;
+    }],
+    transformResponse: [function transformResponse(data) {
+      var transitional = this.transitional || defaults.transitional;
+      var forcedJSONParsing = transitional && transitional.forcedJSONParsing;
+      var JSONRequested = this.responseType === 'json';
+      if (data && utils.isString(data) && (forcedJSONParsing && !this.responseType || JSONRequested)) {
+        var silentJSONParsing = transitional && transitional.silentJSONParsing;
+        var strictJSONParsing = !silentJSONParsing && JSONRequested;
+        try {
+          return JSON.parse(data);
+        } catch (e) {
+          if (strictJSONParsing) {
+            if (e.name === 'SyntaxError') {
+              throw AxiosError.from(e, AxiosError.ERR_BAD_RESPONSE, this, null, this.response);
+            }
+            throw e;
+          }
         }
-        document.cookie = cookie.join('; ');
-      },
-      read: function read(name) {
-        var match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)'));
-        return match ? decodeURIComponent(match[3]) : null;
-      },
-      remove: function remove(name) {
-        this.write(name, '', Date.now() - 86400000);
       }
-    };
-  }() :
-  // Non standard browser env (web workers, react-native) lack needed support.
-  function nonStandardBrowserEnv() {
-    return {
-      write: function write() {},
-      read: function read() {
-        return null;
-      },
-      remove: function remove() {}
-    };
-  }();
+      return data;
+    }],
+    /**
+     * A timeout in milliseconds to abort a request. If set to 0 (default) a
+     * timeout is not created.
+     */
+    timeout: 0,
+    xsrfCookieName: 'XSRF-TOKEN',
+    xsrfHeaderName: 'X-XSRF-TOKEN',
+    maxContentLength: -1,
+    maxBodyLength: -1,
+    env: {
+      FormData: platform.classes.FormData,
+      Blob: platform.classes.Blob
+    },
+    validateStatus: function validateStatus(status) {
+      return status >= 200 && status < 300;
+    },
+    headers: {
+      common: {
+        'Accept': 'application/json, text/plain, */*'
+      }
+    }
+  };
+  utils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {
+    defaults.headers[method] = {};
+  });
+  utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
+    defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);
+  });
+  var defaults$1 = defaults;
 
-  /**
-   * Determines whether the specified URL is absolute
-   *
-   * @param {string} url The URL to test
-   *
-   * @returns {boolean} True if the specified URL is absolute, otherwise false
-   */
-  function isAbsoluteURL(url) {
-    // A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL).
-    // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed
-    // by any combination of letters, digits, plus, period, or hyphen.
-    return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
-  }
+  // RawAxiosHeaders whose duplicates are ignored by node
+  // c.f. https://nodejs.org/api/http.html#http_message_headers
+  var ignoreDuplicateOf = utils.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']);
 
   /**
-   * Creates a new URL by combining the specified URLs
-   *
-   * @param {string} baseURL The base URL
-   * @param {string} relativeURL The relative URL
+   * Parse headers into an object
    *
-   * @returns {string} The combined URL
-   */
-  function combineURLs(baseURL, relativeURL) {
-    return relativeURL ? baseURL.replace(/\/+$/, '') + '/' + relativeURL.replace(/^\/+/, '') : baseURL;
-  }
-
-  /**
-   * Creates a new URL by combining the baseURL with the requestedURL,
-   * only when the requestedURL is not already an absolute URL.
-   * If the requestURL is absolute, this function returns the requestedURL untouched.
+   * ```
+   * Date: Wed, 27 Aug 2014 08:58:49 GMT
+   * Content-Type: application/json
+   * Connection: keep-alive
+   * Transfer-Encoding: chunked
+   * ```
    *
-   * @param {string} baseURL The base URL
-   * @param {string} requestedURL Absolute or relative URL to combine
-   *
-   * @returns {string} The combined full path
-   */
-  function buildFullPath(baseURL, requestedURL) {
-    if (baseURL && !isAbsoluteURL(requestedURL)) {
-      return combineURLs(baseURL, requestedURL);
-    }
-    return requestedURL;
-  }
-
-  var isURLSameOrigin = platform.isStandardBrowserEnv ?
-  // Standard browser envs have full support of the APIs needed to test
-  // whether the request URL is of the same origin as current location.
-  function standardBrowserEnv() {
-    var msie = /(msie|trident)/i.test(navigator.userAgent);
-    var urlParsingNode = document.createElement('a');
-    var originURL;
-
-    /**
-    * Parse a URL to discover it's components
-    *
-    * @param {String} url The URL to be parsed
-    * @returns {Object}
-    */
-    function resolveURL(url) {
-      var href = url;
-      if (msie) {
-        // IE needs attribute set twice to normalize properties
-        urlParsingNode.setAttribute('href', href);
-        href = urlParsingNode.href;
-      }
-      urlParsingNode.setAttribute('href', href);
-
-      // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils
-      return {
-        href: urlParsingNode.href,
-        protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',
-        host: urlParsingNode.host,
-        search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, '') : '',
-        hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',
-        hostname: urlParsingNode.hostname,
-        port: urlParsingNode.port,
-        pathname: urlParsingNode.pathname.charAt(0) === '/' ? urlParsingNode.pathname : '/' + urlParsingNode.pathname
-      };
-    }
-    originURL = resolveURL(window.location.href);
-
-    /**
-    * Determine if a URL shares the same origin as the current location
-    *
-    * @param {String} requestURL The URL to test
-    * @returns {boolean} True if URL shares the same origin, otherwise false
-    */
-    return function isURLSameOrigin(requestURL) {
-      var parsed = utils.isString(requestURL) ? resolveURL(requestURL) : requestURL;
-      return parsed.protocol === originURL.protocol && parsed.host === originURL.host;
-    };
-  }() :
-  // Non standard browser envs (web workers, react-native) lack needed support.
-  function nonStandardBrowserEnv() {
-    return function isURLSameOrigin() {
-      return true;
-    };
-  }();
-
-  /**
-   * A `CanceledError` is an object that is thrown when an operation is canceled.
-   *
-   * @param {string=} message The message.
-   * @param {Object=} config The config.
-   * @param {Object=} request The request.
-   *
-   * @returns {CanceledError} The created error.
-   */
-  function CanceledError(message, config, request) {
-    // eslint-disable-next-line no-eq-null,eqeqeq
-    AxiosError.call(this, message == null ? 'canceled' : message, AxiosError.ERR_CANCELED, config, request);
-    this.name = 'CanceledError';
-  }
-  utils.inherits(CanceledError, AxiosError, {
-    __CANCEL__: true
-  });
-
-  function parseProtocol(url) {
-    var match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url);
-    return match && match[1] || '';
-  }
-
-  // RawAxiosHeaders whose duplicates are ignored by node
-  // c.f. https://nodejs.org/api/http.html#http_message_headers
-  var ignoreDuplicateOf = utils.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']);
-
-  /**
-   * Parse headers into an object
-   *
-   * ```
-   * Date: Wed, 27 Aug 2014 08:58:49 GMT
-   * Content-Type: application/json
-   * Connection: keep-alive
-   * Transfer-Encoding: chunked
-   * ```
-   *
-   * @param {String} rawHeaders Headers needing to be parsed
+   * @param {String} rawHeaders Headers needing to be parsed
    *
    * @returns {Object} Headers parsed into an object
    */
@@ -1438,7 +1519,6 @@
   });
 
   var $internals = Symbol('internals');
-  var $defaults = Symbol('defaults');
   function normalizeHeader(header) {
     return header && String(header).trim().toLowerCase();
   }
@@ -1457,10 +1537,16 @@
     }
     return tokens;
   }
-  function matchHeaderValue(context, value, header, filter) {
+  function isValidHeaderName(str) {
+    return /^[-_a-zA-Z]+$/.test(str.trim());
+  }
+  function matchHeaderValue(context, value, header, filter, isHeaderNameFilter) {
     if (utils.isFunction(filter)) {
       return filter.call(this, value, header);
     }
+    if (isHeaderNameFilter) {
+      value = header;
+    }
     if (!utils.isString(value)) return;
     if (utils.isString(filter)) {
       return value.indexOf(filter) !== -1;
@@ -1485,153 +1571,415 @@
       });
     });
   }
-  function findKey(obj, key) {
-    key = key.toLowerCase();
-    var keys = Object.keys(obj);
-    var i = keys.length;
-    var _key;
-    while (i-- > 0) {
-      _key = keys[i];
-      if (key === _key.toLowerCase()) {
-        return _key;
-      }
+  var AxiosHeaders = /*#__PURE__*/function (_Symbol$iterator, _Symbol$toStringTag) {
+    function AxiosHeaders(headers) {
+      _classCallCheck(this, AxiosHeaders);
+      headers && this.set(headers);
     }
-    return null;
-  }
-  function AxiosHeaders(headers, defaults) {
-    headers && this.set(headers);
-    this[$defaults] = defaults || null;
-  }
-  Object.assign(AxiosHeaders.prototype, {
-    set: function set(header, valueOrRewrite, rewrite) {
-      var self = this;
-      function setHeader(_value, _header, _rewrite) {
-        var lHeader = normalizeHeader(_header);
-        if (!lHeader) {
-          throw new Error('header name must be a non-empty string');
+    _createClass(AxiosHeaders, [{
+      key: "set",
+      value: function set(header, valueOrRewrite, rewrite) {
+        var self = this;
+        function setHeader(_value, _header, _rewrite) {
+          var lHeader = normalizeHeader(_header);
+          if (!lHeader) {
+            throw new Error('header name must be a non-empty string');
+          }
+          var key = utils.findKey(self, lHeader);
+          if (!key || self[key] === undefined || _rewrite === true || _rewrite === undefined && self[key] !== false) {
+            self[key || _header] = normalizeValue(_value);
+          }
         }
-        var key = findKey(self, lHeader);
-        if (key && _rewrite !== true && (self[key] === false || _rewrite === false)) {
-          return;
+        var setHeaders = function setHeaders(headers, _rewrite) {
+          return utils.forEach(headers, function (_value, _header) {
+            return setHeader(_value, _header, _rewrite);
+          });
+        };
+        if (utils.isPlainObject(header) || header instanceof this.constructor) {
+          setHeaders(header, valueOrRewrite);
+        } else if (utils.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {
+          setHeaders(parseHeaders(header), valueOrRewrite);
+        } else {
+          header != null && setHeader(valueOrRewrite, header, rewrite);
         }
-        self[key || _header] = normalizeValue(_value);
+        return this;
       }
-      if (utils.isPlainObject(header)) {
-        utils.forEach(header, function (_value, _header) {
-          setHeader(_value, _header, valueOrRewrite);
-        });
-      } else {
-        setHeader(valueOrRewrite, header, rewrite);
-      }
-      return this;
-    },
-    get: function get(header, parser) {
-      header = normalizeHeader(header);
-      if (!header) return undefined;
-      var key = findKey(this, header);
-      if (key) {
-        var value = this[key];
-        if (!parser) {
-          return value;
+    }, {
+      key: "get",
+      value: function get(header, parser) {
+        header = normalizeHeader(header);
+        if (header) {
+          var key = utils.findKey(this, header);
+          if (key) {
+            var value = this[key];
+            if (!parser) {
+              return value;
+            }
+            if (parser === true) {
+              return parseTokens(value);
+            }
+            if (utils.isFunction(parser)) {
+              return parser.call(this, value, key);
+            }
+            if (utils.isRegExp(parser)) {
+              return parser.exec(value);
+            }
+            throw new TypeError('parser must be boolean|regexp|function');
+          }
         }
-        if (parser === true) {
-          return parseTokens(value);
+      }
+    }, {
+      key: "has",
+      value: function has(header, matcher) {
+        header = normalizeHeader(header);
+        if (header) {
+          var key = utils.findKey(this, header);
+          return !!(key && this[key] !== undefined && (!matcher || matchHeaderValue(this, this[key], key, matcher)));
         }
-        if (utils.isFunction(parser)) {
-          return parser.call(this, value, key);
+        return false;
+      }
+    }, {
+      key: "delete",
+      value: function _delete(header, matcher) {
+        var self = this;
+        var deleted = false;
+        function deleteHeader(_header) {
+          _header = normalizeHeader(_header);
+          if (_header) {
+            var key = utils.findKey(self, _header);
+            if (key && (!matcher || matchHeaderValue(self, self[key], key, matcher))) {
+              delete self[key];
+              deleted = true;
+            }
+          }
         }
-        if (utils.isRegExp(parser)) {
-          return parser.exec(value);
+        if (utils.isArray(header)) {
+          header.forEach(deleteHeader);
+        } else {
+          deleteHeader(header);
         }
-        throw new TypeError('parser must be boolean|regexp|function');
-      }
-    },
-    has: function has(header, matcher) {
-      header = normalizeHeader(header);
-      if (header) {
-        var key = findKey(this, header);
-        return !!(key && (!matcher || matchHeaderValue(this, this[key], key, matcher)));
+        return deleted;
       }
-      return false;
-    },
-    "delete": function _delete(header, matcher) {
-      var self = this;
-      var deleted = false;
-      function deleteHeader(_header) {
-        _header = normalizeHeader(_header);
-        if (_header) {
-          var key = findKey(self, _header);
-          if (key && (!matcher || matchHeaderValue(self, self[key], key, matcher))) {
-            delete self[key];
+    }, {
+      key: "clear",
+      value: function clear(matcher) {
+        var keys = Object.keys(this);
+        var i = keys.length;
+        var deleted = false;
+        while (i--) {
+          var key = keys[i];
+          if (!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {
+            delete this[key];
             deleted = true;
           }
         }
+        return deleted;
       }
-      if (utils.isArray(header)) {
-        header.forEach(deleteHeader);
-      } else {
-        deleteHeader(header);
+    }, {
+      key: "normalize",
+      value: function normalize(format) {
+        var self = this;
+        var headers = {};
+        utils.forEach(this, function (value, header) {
+          var key = utils.findKey(headers, header);
+          if (key) {
+            self[key] = normalizeValue(value);
+            delete self[header];
+            return;
+          }
+          var normalized = format ? formatHeader(header) : String(header).trim();
+          if (normalized !== header) {
+            delete self[header];
+          }
+          self[normalized] = normalizeValue(value);
+          headers[normalized] = true;
+        });
+        return this;
       }
-      return deleted;
-    },
-    clear: function clear() {
-      return Object.keys(this).forEach(this["delete"].bind(this));
-    },
-    normalize: function normalize(format) {
-      var self = this;
-      var headers = {};
-      utils.forEach(this, function (value, header) {
-        var key = findKey(headers, header);
-        if (key) {
-          self[key] = normalizeValue(value);
-          delete self[header];
-          return;
+    }, {
+      key: "concat",
+      value: function concat() {
+        var _this$constructor;
+        for (var _len = arguments.length, targets = new Array(_len), _key = 0; _key < _len; _key++) {
+          targets[_key] = arguments[_key];
         }
-        var normalized = format ? formatHeader(header) : String(header).trim();
-        if (normalized !== header) {
-          delete self[header];
+        return (_this$constructor = this.constructor).concat.apply(_this$constructor, [this].concat(targets));
+      }
+    }, {
+      key: "toJSON",
+      value: function toJSON(asStrings) {
+        var obj = Object.create(null);
+        utils.forEach(this, function (value, header) {
+          value != null && value !== false && (obj[header] = asStrings && utils.isArray(value) ? value.join(', ') : value);
+        });
+        return obj;
+      }
+    }, {
+      key: _Symbol$iterator,
+      value: function value() {
+        return Object.entries(this.toJSON())[Symbol.iterator]();
+      }
+    }, {
+      key: "toString",
+      value: function toString() {
+        return Object.entries(this.toJSON()).map(function (_ref) {
+          var _ref2 = _slicedToArray(_ref, 2),
+            header = _ref2[0],
+            value = _ref2[1];
+          return header + ': ' + value;
+        }).join('\n');
+      }
+    }, {
+      key: _Symbol$toStringTag,
+      get: function get() {
+        return 'AxiosHeaders';
+      }
+    }], [{
+      key: "from",
+      value: function from(thing) {
+        return thing instanceof this ? thing : new this(thing);
+      }
+    }, {
+      key: "concat",
+      value: function concat(first) {
+        var computed = new this(first);
+        for (var _len2 = arguments.length, targets = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+          targets[_key2 - 1] = arguments[_key2];
         }
-        self[normalized] = normalizeValue(value);
-        headers[normalized] = true;
-      });
-      return this;
-    },
-    toJSON: function toJSON(asStrings) {
-      var obj = Object.create(null);
-      utils.forEach(Object.assign({}, this[$defaults] || null, this), function (value, header) {
-        if (value == null || value === false) return;
-        obj[header] = asStrings && utils.isArray(value) ? value.join(', ') : value;
-      });
-      return obj;
+        targets.forEach(function (target) {
+          return computed.set(target);
+        });
+        return computed;
+      }
+    }, {
+      key: "accessor",
+      value: function accessor(header) {
+        var internals = this[$internals] = this[$internals] = {
+          accessors: {}
+        };
+        var accessors = internals.accessors;
+        var prototype = this.prototype;
+        function defineAccessor(_header) {
+          var lHeader = normalizeHeader(_header);
+          if (!accessors[lHeader]) {
+            buildAccessors(prototype, _header);
+            accessors[lHeader] = true;
+          }
+        }
+        utils.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);
+        return this;
+      }
+    }]);
+    return AxiosHeaders;
+  }(Symbol.iterator, Symbol.toStringTag);
+  AxiosHeaders.accessor(['Content-Type', 'Content-Length', 'Accept', 'Accept-Encoding', 'User-Agent', 'Authorization']);
+  utils.freezeMethods(AxiosHeaders.prototype);
+  utils.freezeMethods(AxiosHeaders);
+  var AxiosHeaders$1 = AxiosHeaders;
+
+  /**
+   * Transform the data for a request or a response
+   *
+   * @param {Array|Function} fns A single function or Array of functions
+   * @param {?Object} response The response object
+   *
+   * @returns {*} The resulting transformed data
+   */
+  function transformData(fns, response) {
+    var config = this || defaults$1;
+    var context = response || config;
+    var headers = AxiosHeaders$1.from(context.headers);
+    var data = context.data;
+    utils.forEach(fns, function transform(fn) {
+      data = fn.call(config, data, headers.normalize(), response ? response.status : undefined);
+    });
+    headers.normalize();
+    return data;
+  }
+
+  function isCancel(value) {
+    return !!(value && value.__CANCEL__);
+  }
+
+  /**
+   * A `CanceledError` is an object that is thrown when an operation is canceled.
+   *
+   * @param {string=} message The message.
+   * @param {Object=} config The config.
+   * @param {Object=} request The request.
+   *
+   * @returns {CanceledError} The created error.
+   */
+  function CanceledError(message, config, request) {
+    // eslint-disable-next-line no-eq-null,eqeqeq
+    AxiosError.call(this, message == null ? 'canceled' : message, AxiosError.ERR_CANCELED, config, request);
+    this.name = 'CanceledError';
+  }
+  utils.inherits(CanceledError, AxiosError, {
+    __CANCEL__: true
+  });
+
+  /**
+   * Resolve or reject a Promise based on response status.
+   *
+   * @param {Function} resolve A function that resolves the promise.
+   * @param {Function} reject A function that rejects the promise.
+   * @param {object} response The response.
+   *
+   * @returns {object} The response.
+   */
+  function settle(resolve, reject, response) {
+    var validateStatus = response.config.validateStatus;
+    if (!response.status || !validateStatus || validateStatus(response.status)) {
+      resolve(response);
+    } else {
+      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));
+    }
+  }
+
+  var cookies = platform.isStandardBrowserEnv ?
+  // Standard browser envs support document.cookie
+  function standardBrowserEnv() {
+    return {
+      write: function write(name, value, expires, path, domain, secure) {
+        var cookie = [];
+        cookie.push(name + '=' + encodeURIComponent(value));
+        if (utils.isNumber(expires)) {
+          cookie.push('expires=' + new Date(expires).toGMTString());
+        }
+        if (utils.isString(path)) {
+          cookie.push('path=' + path);
+        }
+        if (utils.isString(domain)) {
+          cookie.push('domain=' + domain);
+        }
+        if (secure === true) {
+          cookie.push('secure');
+        }
+        document.cookie = cookie.join('; ');
+      },
+      read: function read(name) {
+        var match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)'));
+        return match ? decodeURIComponent(match[3]) : null;
+      },
+      remove: function remove(name) {
+        this.write(name, '', Date.now() - 86400000);
+      }
+    };
+  }() :
+  // Non standard browser env (web workers, react-native) lack needed support.
+  function nonStandardBrowserEnv() {
+    return {
+      write: function write() {},
+      read: function read() {
+        return null;
+      },
+      remove: function remove() {}
+    };
+  }();
+
+  /**
+   * Determines whether the specified URL is absolute
+   *
+   * @param {string} url The URL to test
+   *
+   * @returns {boolean} True if the specified URL is absolute, otherwise false
+   */
+  function isAbsoluteURL(url) {
+    // A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL).
+    // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed
+    // by any combination of letters, digits, plus, period, or hyphen.
+    return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
+  }
+
+  /**
+   * Creates a new URL by combining the specified URLs
+   *
+   * @param {string} baseURL The base URL
+   * @param {string} relativeURL The relative URL
+   *
+   * @returns {string} The combined URL
+   */
+  function combineURLs(baseURL, relativeURL) {
+    return relativeURL ? baseURL.replace(/\/+$/, '') + '/' + relativeURL.replace(/^\/+/, '') : baseURL;
+  }
+
+  /**
+   * Creates a new URL by combining the baseURL with the requestedURL,
+   * only when the requestedURL is not already an absolute URL.
+   * If the requestURL is absolute, this function returns the requestedURL untouched.
+   *
+   * @param {string} baseURL The base URL
+   * @param {string} requestedURL Absolute or relative URL to combine
+   *
+   * @returns {string} The combined full path
+   */
+  function buildFullPath(baseURL, requestedURL) {
+    if (baseURL && !isAbsoluteURL(requestedURL)) {
+      return combineURLs(baseURL, requestedURL);
     }
-  });
-  Object.assign(AxiosHeaders, {
-    from: function from(thing) {
-      if (utils.isString(thing)) {
-        return new this(parseHeaders(thing));
+    return requestedURL;
+  }
+
+  var isURLSameOrigin = platform.isStandardBrowserEnv ?
+  // Standard browser envs have full support of the APIs needed to test
+  // whether the request URL is of the same origin as current location.
+  function standardBrowserEnv() {
+    var msie = /(msie|trident)/i.test(navigator.userAgent);
+    var urlParsingNode = document.createElement('a');
+    var originURL;
+
+    /**
+    * Parse a URL to discover it's components
+    *
+    * @param {String} url The URL to be parsed
+    * @returns {Object}
+    */
+    function resolveURL(url) {
+      var href = url;
+      if (msie) {
+        // IE needs attribute set twice to normalize properties
+        urlParsingNode.setAttribute('href', href);
+        href = urlParsingNode.href;
       }
-      return thing instanceof this ? thing : new this(thing);
-    },
-    accessor: function accessor(header) {
-      var internals = this[$internals] = this[$internals] = {
-        accessors: {}
+      urlParsingNode.setAttribute('href', href);
+
+      // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils
+      return {
+        href: urlParsingNode.href,
+        protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',
+        host: urlParsingNode.host,
+        search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, '') : '',
+        hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',
+        hostname: urlParsingNode.hostname,
+        port: urlParsingNode.port,
+        pathname: urlParsingNode.pathname.charAt(0) === '/' ? urlParsingNode.pathname : '/' + urlParsingNode.pathname
       };
-      var accessors = internals.accessors;
-      var prototype = this.prototype;
-      function defineAccessor(_header) {
-        var lHeader = normalizeHeader(_header);
-        if (!accessors[lHeader]) {
-          buildAccessors(prototype, _header);
-          accessors[lHeader] = true;
-        }
-      }
-      utils.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);
-      return this;
     }
-  });
-  AxiosHeaders.accessor(['Content-Type', 'Content-Length', 'Accept', 'Accept-Encoding', 'User-Agent']);
-  utils.freezeMethods(AxiosHeaders.prototype);
-  utils.freezeMethods(AxiosHeaders);
+    originURL = resolveURL(window.location.href);
+
+    /**
+    * Determine if a URL shares the same origin as the current location
+    *
+    * @param {String} requestURL The URL to test
+    * @returns {boolean} True if URL shares the same origin, otherwise false
+    */
+    return function isURLSameOrigin(requestURL) {
+      var parsed = utils.isString(requestURL) ? resolveURL(requestURL) : requestURL;
+      return parsed.protocol === originURL.protocol && parsed.host === originURL.host;
+    };
+  }() :
+  // Non standard browser envs (web workers, react-native) lack needed support.
+  function nonStandardBrowserEnv() {
+    return function isURLSameOrigin() {
+      return true;
+    };
+  }();
+
+  function parseProtocol(url) {
+    var match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url);
+    return match && match[1] || '';
+  }
 
   /**
    * Calculate data maxRate
@@ -1689,16 +2037,18 @@
         progress: total ? loaded / total : undefined,
         bytes: progressBytes,
         rate: rate ? rate : undefined,
-        estimated: rate && total && inRange ? (total - loaded) / rate : undefined
+        estimated: rate && total && inRange ? (total - loaded) / rate : undefined,
+        event: e
       };
       data[isDownloadStream ? 'download' : 'upload'] = true;
       listener(data);
     };
   }
-  function xhrAdapter(config) {
+  var isXHRAdapterSupported = typeof XMLHttpRequest !== 'undefined';
+  var xhrAdapter = isXHRAdapterSupported && function (config) {
     return new Promise(function dispatchXhrRequest(resolve, reject) {
       var requestData = config.data;
-      var requestHeaders = AxiosHeaders.from(config.headers).normalize();
+      var requestHeaders = AxiosHeaders$1.from(config.headers).normalize();
       var responseType = config.responseType;
       var onCanceled;
       function done() {
@@ -1709,7 +2059,7 @@
           config.signal.removeEventListener('abort', onCanceled);
         }
       }
-      if (utils.isFormData(requestData) && platform.isStandardBrowserEnv) {
+      if (utils.isFormData(requestData) && (platform.isStandardBrowserEnv || platform.isStandardBrowserWebWorkerEnv)) {
         requestHeaders.setContentType(false); // Let the browser set it
       }
 
@@ -1731,7 +2081,7 @@
           return;
         }
         // Prepare the response
-        var responseHeaders = AxiosHeaders.from('getAllResponseHeaders' in request && request.getAllResponseHeaders());
+        var responseHeaders = AxiosHeaders$1.from('getAllResponseHeaders' in request && request.getAllResponseHeaders());
         var responseData = !responseType || responseType === 'text' || responseType === 'json' ? request.responseText : request.response;
         var response = {
           data: responseData,
@@ -1874,191 +2224,52 @@
       // Send the request
       request.send(requestData || null);
     });
-  }
-
-  var adapters = {
-    http: xhrAdapter,
-    xhr: xhrAdapter
-  };
-  var adapters$1 = {
-    getAdapter: function getAdapter(nameOrAdapter) {
-      if (utils.isString(nameOrAdapter)) {
-        var adapter = adapters[nameOrAdapter];
-        if (!nameOrAdapter) {
-          throw Error(utils.hasOwnProp(nameOrAdapter) ? "Adapter '".concat(nameOrAdapter, "' is not available in the build") : "Can not resolve adapter '".concat(nameOrAdapter, "'"));
-        }
-        return adapter;
-      }
-      if (!utils.isFunction(nameOrAdapter)) {
-        throw new TypeError('adapter is not a function');
-      }
-      return nameOrAdapter;
-    },
-    adapters: adapters
   };
 
-  var DEFAULT_CONTENT_TYPE = {
-    'Content-Type': 'application/x-www-form-urlencoded'
+  var knownAdapters = {
+    http: httpAdapter,
+    xhr: xhrAdapter
   };
-
-  /**
-   * If the browser has an XMLHttpRequest object, use the XHR adapter, otherwise use the HTTP
-   * adapter
-   *
-   * @returns {Function}
-   */
-  function getDefaultAdapter() {
-    var adapter;
-    if (typeof XMLHttpRequest !== 'undefined') {
-      // For browsers use XHR adapter
-      adapter = adapters$1.getAdapter('xhr');
-    } else if (typeof process !== 'undefined' && utils.kindOf(process) === 'process') {
-      // For node use HTTP adapter
-      adapter = adapters$1.getAdapter('http');
-    }
-    return adapter;
-  }
-
-  /**
-   * It takes a string, tries to parse it, and if it fails, it returns the stringified version
-   * of the input
-   *
-   * @param {any} rawValue - The value to be stringified.
-   * @param {Function} parser - A function that parses a string into a JavaScript object.
-   * @param {Function} encoder - A function that takes a value and returns a string.
-   *
-   * @returns {string} A stringified version of the rawValue.
-   */
-  function stringifySafely(rawValue, parser, encoder) {
-    if (utils.isString(rawValue)) {
+  utils.forEach(knownAdapters, function (fn, value) {
+    if (fn) {
       try {
-        (parser || JSON.parse)(rawValue);
-        return utils.trim(rawValue);
+        Object.defineProperty(fn, 'name', {
+          value: value
+        });
       } catch (e) {
-        if (e.name !== 'SyntaxError') {
-          throw e;
-        }
+        // eslint-disable-next-line no-empty
       }
+      Object.defineProperty(fn, 'adapterName', {
+        value: value
+      });
     }
-    return (encoder || JSON.stringify)(rawValue);
-  }
-  var defaults = {
-    transitional: transitionalDefaults,
-    adapter: getDefaultAdapter(),
-    transformRequest: [function transformRequest(data, headers) {
-      var contentType = headers.getContentType() || '';
-      var hasJSONContentType = contentType.indexOf('application/json') > -1;
-      var isObjectPayload = utils.isObject(data);
-      if (isObjectPayload && utils.isHTMLForm(data)) {
-        data = new FormData(data);
-      }
-      var isFormData = utils.isFormData(data);
-      if (isFormData) {
-        if (!hasJSONContentType) {
-          return data;
+  });
+  var adapters = {
+    getAdapter: function getAdapter(adapters) {
+      adapters = utils.isArray(adapters) ? adapters : [adapters];
+      var _adapters = adapters,
+        length = _adapters.length;
+      var nameOrAdapter;
+      var adapter;
+      for (var i = 0; i < length; i++) {
+        nameOrAdapter = adapters[i];
+        if (adapter = utils.isString(nameOrAdapter) ? knownAdapters[nameOrAdapter.toLowerCase()] : nameOrAdapter) {
+          break;
         }
-        return hasJSONContentType ? JSON.stringify(formDataToJSON(data)) : data;
-      }
-      if (utils.isArrayBuffer(data) || utils.isBuffer(data) || utils.isStream(data) || utils.isFile(data) || utils.isBlob(data)) {
-        return data;
-      }
-      if (utils.isArrayBufferView(data)) {
-        return data.buffer;
       }
-      if (utils.isURLSearchParams(data)) {
-        headers.setContentType('application/x-www-form-urlencoded;charset=utf-8', false);
-        return data.toString();
-      }
-      var isFileList;
-      if (isObjectPayload) {
-        if (contentType.indexOf('application/x-www-form-urlencoded') > -1) {
-          return toURLEncodedForm(data, this.formSerializer).toString();
+      if (!adapter) {
+        if (adapter === false) {
+          throw new AxiosError("Adapter ".concat(nameOrAdapter, " is not supported by the environment"), 'ERR_NOT_SUPPORT');
         }
-        if ((isFileList = utils.isFileList(data)) || contentType.indexOf('multipart/form-data') > -1) {
-          var _FormData = this.env && this.env.FormData;
-          return toFormData(isFileList ? {
-            'files[]': data
-          } : data, _FormData && new _FormData(), this.formSerializer);
-        }
-      }
-      if (isObjectPayload || hasJSONContentType) {
-        headers.setContentType('application/json', false);
-        return stringifySafely(data);
+        throw new Error(utils.hasOwnProp(knownAdapters, nameOrAdapter) ? "Adapter '".concat(nameOrAdapter, "' is not available in the build") : "Unknown adapter '".concat(nameOrAdapter, "'"));
       }
-      return data;
-    }],
-    transformResponse: [function transformResponse(data) {
-      var transitional = this.transitional || defaults.transitional;
-      var forcedJSONParsing = transitional && transitional.forcedJSONParsing;
-      var JSONRequested = this.responseType === 'json';
-      if (data && utils.isString(data) && (forcedJSONParsing && !this.responseType || JSONRequested)) {
-        var silentJSONParsing = transitional && transitional.silentJSONParsing;
-        var strictJSONParsing = !silentJSONParsing && JSONRequested;
-        try {
-          return JSON.parse(data);
-        } catch (e) {
-          if (strictJSONParsing) {
-            if (e.name === 'SyntaxError') {
-              throw AxiosError.from(e, AxiosError.ERR_BAD_RESPONSE, this, null, this.response);
-            }
-            throw e;
-          }
-        }
+      if (!utils.isFunction(adapter)) {
+        throw new TypeError('adapter is not a function');
       }
-      return data;
-    }],
-    /**
-     * A timeout in milliseconds to abort a request. If set to 0 (default) a
-     * timeout is not created.
-     */
-    timeout: 0,
-    xsrfCookieName: 'XSRF-TOKEN',
-    xsrfHeaderName: 'X-XSRF-TOKEN',
-    maxContentLength: -1,
-    maxBodyLength: -1,
-    env: {
-      FormData: platform.classes.FormData,
-      Blob: platform.classes.Blob
+      return adapter;
     },
-    validateStatus: function validateStatus(status) {
-      return status >= 200 && status < 300;
-    },
-    headers: {
-      common: {
-        'Accept': 'application/json, text/plain, */*'
-      }
-    }
+    adapters: knownAdapters
   };
-  utils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {
-    defaults.headers[method] = {};
-  });
-  utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
-    defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);
-  });
-
-  /**
-   * Transform the data for a request or a response
-   *
-   * @param {Array|Function} fns A single function or Array of functions
-   * @param {?Object} response The response object
-   *
-   * @returns {*} The resulting transformed data
-   */
-  function transformData(fns, response) {
-    var config = this || defaults;
-    var context = response || config;
-    var headers = AxiosHeaders.from(context.headers);
-    var data = context.data;
-    utils.forEach(fns, function transform(fn) {
-      data = fn.call(config, data, headers.normalize(), response ? response.status : undefined);
-    });
-    headers.normalize();
-    return data;
-  }
-
-  function isCancel(value) {
-    return !!(value && value.__CANCEL__);
-  }
 
   /**
    * Throws a `CanceledError` if cancellation has been requested.
@@ -2072,7 +2283,7 @@
       config.cancelToken.throwIfRequested();
     }
     if (config.signal && config.signal.aborted) {
-      throw new CanceledError();
+      throw new CanceledError(null, config);
     }
   }
 
@@ -2085,17 +2296,20 @@
    */
   function dispatchRequest(config) {
     throwIfCancellationRequested(config);
-    config.headers = AxiosHeaders.from(config.headers);
+    config.headers = AxiosHeaders$1.from(config.headers);
 
     // Transform request data
     config.data = transformData.call(config, config.transformRequest);
-    var adapter = config.adapter || defaults.adapter;
+    if (['post', 'put', 'patch'].indexOf(config.method) !== -1) {
+      config.headers.setContentType('application/x-www-form-urlencoded', false);
+    }
+    var adapter = adapters.getAdapter(config.adapter || defaults$1.adapter);
     return adapter(config).then(function onAdapterResolution(response) {
       throwIfCancellationRequested(config);
 
       // Transform response data
       response.data = transformData.call(config, config.transformResponse, response);
-      response.headers = AxiosHeaders.from(response.headers);
+      response.headers = AxiosHeaders$1.from(response.headers);
       return response;
     }, function onAdapterRejection(reason) {
       if (!isCancel(reason)) {
@@ -2104,13 +2318,17 @@
         // Transform response data
         if (reason && reason.response) {
           reason.response.data = transformData.call(config, config.transformResponse, reason.response);
-          reason.response.headers = AxiosHeaders.from(reason.response.headers);
+          reason.response.headers = AxiosHeaders$1.from(reason.response.headers);
         }
       }
       return Promise.reject(reason);
     });
   }
 
+  var headersToObject = function headersToObject(thing) {
+    return thing instanceof AxiosHeaders$1 ? thing.toJSON() : thing;
+  };
+
   /**
    * Config-specific merge-function which creates a new config-object
    * by merging two configuration objects together.
@@ -2124,9 +2342,11 @@
     // eslint-disable-next-line no-param-reassign
     config2 = config2 || {};
     var config = {};
-    function getMergedValue(target, source) {
+    function getMergedValue(target, source, caseless) {
       if (utils.isPlainObject(target) && utils.isPlainObject(source)) {
-        return utils.merge(target, source);
+        return utils.merge.call({
+          caseless: caseless
+        }, target, source);
       } else if (utils.isPlainObject(source)) {
         return utils.merge({}, source);
       } else if (utils.isArray(source)) {
@@ -2136,76 +2356,79 @@
     }
 
     // eslint-disable-next-line consistent-return
-    function mergeDeepProperties(prop) {
-      if (!utils.isUndefined(config2[prop])) {
-        return getMergedValue(config1[prop], config2[prop]);
-      } else if (!utils.isUndefined(config1[prop])) {
-        return getMergedValue(undefined, config1[prop]);
+    function mergeDeepProperties(a, b, caseless) {
+      if (!utils.isUndefined(b)) {
+        return getMergedValue(a, b, caseless);
+      } else if (!utils.isUndefined(a)) {
+        return getMergedValue(undefined, a, caseless);
       }
     }
 
     // eslint-disable-next-line consistent-return
-    function valueFromConfig2(prop) {
-      if (!utils.isUndefined(config2[prop])) {
-        return getMergedValue(undefined, config2[prop]);
+    function valueFromConfig2(a, b) {
+      if (!utils.isUndefined(b)) {
+        return getMergedValue(undefined, b);
       }
     }
 
     // eslint-disable-next-line consistent-return
-    function defaultToConfig2(prop) {
-      if (!utils.isUndefined(config2[prop])) {
-        return getMergedValue(undefined, config2[prop]);
-      } else if (!utils.isUndefined(config1[prop])) {
-        return getMergedValue(undefined, config1[prop]);
+    function defaultToConfig2(a, b) {
+      if (!utils.isUndefined(b)) {
+        return getMergedValue(undefined, b);
+      } else if (!utils.isUndefined(a)) {
+        return getMergedValue(undefined, a);
       }
     }
 
     // eslint-disable-next-line consistent-return
-    function mergeDirectKeys(prop) {
+    function mergeDirectKeys(a, b, prop) {
       if (prop in config2) {
-        return getMergedValue(config1[prop], config2[prop]);
+        return getMergedValue(a, b);
       } else if (prop in config1) {
-        return getMergedValue(undefined, config1[prop]);
+        return getMergedValue(undefined, a);
       }
     }
     var mergeMap = {
-      'url': valueFromConfig2,
-      'method': valueFromConfig2,
-      'data': valueFromConfig2,
-      'baseURL': defaultToConfig2,
-      'transformRequest': defaultToConfig2,
-      'transformResponse': defaultToConfig2,
-      'paramsSerializer': defaultToConfig2,
-      'timeout': defaultToConfig2,
-      'timeoutMessage': defaultToConfig2,
-      'withCredentials': defaultToConfig2,
-      'adapter': defaultToConfig2,
-      'responseType': defaultToConfig2,
-      'xsrfCookieName': defaultToConfig2,
-      'xsrfHeaderName': defaultToConfig2,
-      'onUploadProgress': defaultToConfig2,
-      'onDownloadProgress': defaultToConfig2,
-      'decompress': defaultToConfig2,
-      'maxContentLength': defaultToConfig2,
-      'maxBodyLength': defaultToConfig2,
-      'beforeRedirect': defaultToConfig2,
-      'transport': defaultToConfig2,
-      'httpAgent': defaultToConfig2,
-      'httpsAgent': defaultToConfig2,
-      'cancelToken': defaultToConfig2,
-      'socketPath': defaultToConfig2,
-      'responseEncoding': defaultToConfig2,
-      'validateStatus': mergeDirectKeys
+      url: valueFromConfig2,
+      method: valueFromConfig2,
+      data: valueFromConfig2,
+      baseURL: defaultToConfig2,
+      transformRequest: defaultToConfig2,
+      transformResponse: defaultToConfig2,
+      paramsSerializer: defaultToConfig2,
+      timeout: defaultToConfig2,
+      timeoutMessage: defaultToConfig2,
+      withCredentials: defaultToConfig2,
+      adapter: defaultToConfig2,
+      responseType: defaultToConfig2,
+      xsrfCookieName: defaultToConfig2,
+      xsrfHeaderName: defaultToConfig2,
+      onUploadProgress: defaultToConfig2,
+      onDownloadProgress: defaultToConfig2,
+      decompress: defaultToConfig2,
+      maxContentLength: defaultToConfig2,
+      maxBodyLength: defaultToConfig2,
+      beforeRedirect: defaultToConfig2,
+      transport: defaultToConfig2,
+      httpAgent: defaultToConfig2,
+      httpsAgent: defaultToConfig2,
+      cancelToken: defaultToConfig2,
+      socketPath: defaultToConfig2,
+      responseEncoding: defaultToConfig2,
+      validateStatus: mergeDirectKeys,
+      headers: function headers(a, b) {
+        return mergeDeepProperties(headersToObject(a), headersToObject(b), true);
+      }
     };
     utils.forEach(Object.keys(config1).concat(Object.keys(config2)), function computeConfigValue(prop) {
       var merge = mergeMap[prop] || mergeDeepProperties;
-      var configValue = merge(prop);
+      var configValue = merge(config1[prop], config2[prop], prop);
       utils.isUndefined(configValue) && merge !== mergeDirectKeys || (config[prop] = configValue);
     });
     return config;
   }
 
-  var VERSION = "1.1.3";
+  var VERSION = "1.3.4";
 
   var validators$1 = {};
 
@@ -2296,8 +2519,8 @@
       _classCallCheck(this, Axios);
       this.defaults = instanceConfig;
       this.interceptors = {
-        request: new InterceptorManager(),
-        response: new InterceptorManager()
+        request: new InterceptorManager$1(),
+        response: new InterceptorManager$1()
       };
     }
 
@@ -2323,7 +2546,8 @@
         config = mergeConfig(this.defaults, config);
         var _config = config,
           transitional = _config.transitional,
-          paramsSerializer = _config.paramsSerializer;
+          paramsSerializer = _config.paramsSerializer,
+          headers = _config.headers;
         if (transitional !== undefined) {
           validator.assertOptions(transitional, {
             silentJSONParsing: validators.transitional(validators["boolean"]),
@@ -2340,13 +2564,14 @@
 
         // Set config.method
         config.method = (config.method || this.defaults.method || 'get').toLowerCase();
+        var contextHeaders;
 
         // Flatten headers
-        var defaultHeaders = config.headers && utils.merge(config.headers.common, config.headers[config.method]);
-        defaultHeaders && utils.forEach(['delete', 'get', 'head', 'post', 'put', 'patch', 'common'], function cleanHeaderConfig(method) {
-          delete config.headers[method];
+        contextHeaders = headers && utils.merge(headers.common, headers[config.method]);
+        contextHeaders && utils.forEach(['delete', 'get', 'head', 'post', 'put', 'patch', 'common'], function (method) {
+          delete headers[method];
         });
-        config.headers = new AxiosHeaders(config.headers, defaultHeaders);
+        config.headers = AxiosHeaders$1.concat(contextHeaders, headers);
 
         // filter out skipped interceptors
         var requestInterceptorChain = [];
@@ -2439,6 +2664,7 @@
     Axios.prototype[method] = generateHTTPMethod();
     Axios.prototype[method + 'Form'] = generateHTTPMethod(true);
   });
+  var Axios$1 = Axios;
 
   /**
    * A `CancelToken` is an object that can be used to request cancellation of an operation.
@@ -2554,6 +2780,7 @@
     }]);
     return CancelToken;
   }();
+  var CancelToken$1 = CancelToken;
 
   /**
    * Syntactic sugar for invoking a function and expanding an array for arguments.
@@ -2593,6 +2820,79 @@
     return utils.isObject(payload) && payload.isAxiosError === true;
   }
 
+  var HttpStatusCode = {
+    Continue: 100,
+    SwitchingProtocols: 101,
+    Processing: 102,
+    EarlyHints: 103,
+    Ok: 200,
+    Created: 201,
+    Accepted: 202,
+    NonAuthoritativeInformation: 203,
+    NoContent: 204,
+    ResetContent: 205,
+    PartialContent: 206,
+    MultiStatus: 207,
+    AlreadyReported: 208,
+    ImUsed: 226,
+    MultipleChoices: 300,
+    MovedPermanently: 301,
+    Found: 302,
+    SeeOther: 303,
+    NotModified: 304,
+    UseProxy: 305,
+    Unused: 306,
+    TemporaryRedirect: 307,
+    PermanentRedirect: 308,
+    BadRequest: 400,
+    Unauthorized: 401,
+    PaymentRequired: 402,
+    Forbidden: 403,
+    NotFound: 404,
+    MethodNotAllowed: 405,
+    NotAcceptable: 406,
+    ProxyAuthenticationRequired: 407,
+    RequestTimeout: 408,
+    Conflict: 409,
+    Gone: 410,
+    LengthRequired: 411,
+    PreconditionFailed: 412,
+    PayloadTooLarge: 413,
+    UriTooLong: 414,
+    UnsupportedMediaType: 415,
+    RangeNotSatisfiable: 416,
+    ExpectationFailed: 417,
+    ImATeapot: 418,
+    MisdirectedRequest: 421,
+    UnprocessableEntity: 422,
+    Locked: 423,
+    FailedDependency: 424,
+    TooEarly: 425,
+    UpgradeRequired: 426,
+    PreconditionRequired: 428,
+    TooManyRequests: 429,
+    RequestHeaderFieldsTooLarge: 431,
+    UnavailableForLegalReasons: 451,
+    InternalServerError: 500,
+    NotImplemented: 501,
+    BadGateway: 502,
+    ServiceUnavailable: 503,
+    GatewayTimeout: 504,
+    HttpVersionNotSupported: 505,
+    VariantAlsoNegotiates: 506,
+    InsufficientStorage: 507,
+    LoopDetected: 508,
+    NotExtended: 510,
+    NetworkAuthenticationRequired: 511
+  };
+  Object.entries(HttpStatusCode).forEach(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      key = _ref2[0],
+      value = _ref2[1];
+    HttpStatusCode[value] = key;
+  });
+  var HttpStatusCode$1 = HttpStatusCode;
+
   /**
    * Create an instance of Axios
    *
@@ -2601,11 +2901,11 @@
    * @returns {Axios} A new instance of Axios
    */
   function createInstance(defaultConfig) {
-    var context = new Axios(defaultConfig);
-    var instance = bind(Axios.prototype.request, context);
+    var context = new Axios$1(defaultConfig);
+    var instance = bind(Axios$1.prototype.request, context);
 
     // Copy axios.prototype to instance
-    utils.extend(instance, Axios.prototype, context, {
+    utils.extend(instance, Axios$1.prototype, context, {
       allOwnKeys: true
     });
 
@@ -2622,14 +2922,14 @@
   }
 
   // Create the default instance to be exported
-  var axios = createInstance(defaults);
+  var axios = createInstance(defaults$1);
 
   // Expose Axios class to allow class inheritance
-  axios.Axios = Axios;
+  axios.Axios = Axios$1;
 
   // Expose Cancel & CancelToken
   axios.CanceledError = CanceledError;
-  axios.CancelToken = CancelToken;
+  axios.CancelToken = CancelToken$1;
   axios.isCancel = isCancel;
   axios.VERSION = VERSION;
   axios.toFormData = toFormData;
@@ -2648,9 +2948,15 @@
 
   // Expose isAxiosError
   axios.isAxiosError = isAxiosError;
+
+  // Expose mergeConfig
+  axios.mergeConfig = mergeConfig;
+  axios.AxiosHeaders = AxiosHeaders$1;
   axios.formToJSON = function (thing) {
     return formDataToJSON(utils.isHTMLForm(thing) ? new FormData(thing) : thing);
   };
+  axios.HttpStatusCode = HttpStatusCode$1;
+  axios["default"] = axios;
 
   return axios;