axios 1.1.3 → 1.2.0-alpha.1

package/dist/axios.js

@@ -1,4 +1,4 @@
-// Axios v1.1.3 Copyright (c) 2022 Matt Zabriskie and contributors
+// Axios v1.2.0-alpha.1 Copyright (c) 2022 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,23 @@
       }
     }
   }
+  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 = typeof self === "undefined" ? typeof global === "undefined" ? undefined : global : self;
+  var isContextDefined = function isContextDefined(context) {
+    return !isUndefined(context) && context !== _global;
+  };
 
   /**
    * Accepts varargs expecting each argument to be an object, then
@@ -329,16 +392,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 +424,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);
@@ -534,8 +600,8 @@
   };
 
   /* 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 +633,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 +646,7 @@
       }
       if (!descriptor.set) {
         descriptor.set = function () {
-          throw Error('Can not read-only method \'' + name + '\'');
+          throw Error('Can not rewrite read-only method \'' + name + '\'');
         };
       }
     });
@@ -639,7 +709,10 @@
     toObjectSet: toObjectSet,
     toCamelCase: toCamelCase,
     noop: noop,
-    toFiniteNumber: toFiniteNumber
+    toFiniteNumber: toFiniteNumber,
+    findKey: findKey,
+    global: _global,
+    isContextDefined: isContextDefined
   };
 
   /**
@@ -719,6 +792,7 @@
 
   /* eslint-env browser */
   var browser = (typeof self === "undefined" ? "undefined" : _typeof(self)) == 'object' ? self.FormData : window.FormData;
+  var FormData$2 = browser;
 
   /**
    * Determines if the given thing is a array or js object.
@@ -814,7 +888,7 @@
     }
 
     // eslint-disable-next-line no-param-reassign
-    formData = formData || new (browser || FormData)();
+    formData = formData || new (FormData$2 || FormData)();
 
     // eslint-disable-next-line no-param-reassign
     options = utils.toFlatObject(options, {
@@ -1079,6 +1153,7 @@
     }]);
     return InterceptorManager;
   }();
+  var InterceptorManager$1 = InterceptorManager;
 
   var transitionalDefaults = {
     silentJSONParsing: true,
@@ -1438,7 +1513,6 @@
   });
 
   var $internals = Symbol('internals');
-  var $defaults = Symbol('defaults');
   function normalizeHeader(header) {
     return header && String(header).trim().toLowerCase();
   }
@@ -1457,6 +1531,9 @@
     }
     return tokens;
   }
+  function isValidHeaderName(str) {
+    return /^[-_a-zA-Z]+$/.test(str.trim());
+  }
   function matchHeaderValue(context, value, header, filter) {
     if (utils.isFunction(filter)) {
       return filter.call(this, value, header);
@@ -1485,153 +1562,201 @@
       });
     });
   }
-  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 && (!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');
+        return deleted;
       }
-    },
-    has: function has(header, matcher) {
-      header = normalizeHeader(header);
-      if (header) {
-        var key = findKey(this, header);
-        return !!(key && (!matcher || matchHeaderValue(this, this[key], key, matcher)));
+    }, {
+      key: "clear",
+      value: function clear() {
+        return Object.keys(this).forEach(this["delete"].bind(this));
       }
-      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];
-            deleted = true;
+    }, {
+      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;
+      }
+    }, {
+      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];
         }
+        return (_this$constructor = this.constructor).concat.apply(_this$constructor, [this].concat(targets));
       }
-      if (utils.isArray(header)) {
-        header.forEach(deleteHeader);
-      } else {
-        deleteHeader(header);
+    }, {
+      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;
       }
-      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;
-        }
-        var normalized = format ? formatHeader(header) : String(header).trim();
-        if (normalized !== header) {
-          delete self[header];
+    }, {
+      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;
-    }
-  });
-  Object.assign(AxiosHeaders, {
-    from: function from(thing) {
-      if (utils.isString(thing)) {
-        return new this(parseHeaders(thing));
+        targets.forEach(function (target) {
+          return computed.set(target);
+        });
+        return computed;
       }
-      return thing instanceof this ? thing : new this(thing);
-    },
-    accessor: 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;
+    }, {
+      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;
       }
-      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']);
   utils.freezeMethods(AxiosHeaders.prototype);
   utils.freezeMethods(AxiosHeaders);
+  var AxiosHeaders$1 = AxiosHeaders;
 
   /**
    * Calculate data maxRate
@@ -1689,7 +1814,8 @@
         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);
@@ -1698,7 +1824,7 @@
   function xhrAdapter(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() {
@@ -1731,7 +1857,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,
@@ -1898,7 +2024,7 @@
   };
 
   var DEFAULT_CONTENT_TYPE = {
-    'Content-Type': 'application/x-www-form-urlencoded'
+    'Content-Type': undefined
   };
 
   /**
@@ -2035,6 +2161,7 @@
   utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
     defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);
   });
+  var defaults$1 = defaults;
 
   /**
    * Transform the data for a request or a response
@@ -2045,9 +2172,9 @@
    * @returns {*} The resulting transformed data
    */
   function transformData(fns, response) {
-    var config = this || defaults;
+    var config = this || defaults$1;
     var context = response || config;
-    var headers = AxiosHeaders.from(context.headers);
+    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);
@@ -2085,17 +2212,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 = 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 +2234,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 +2258,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 +2272,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.2.0-alpha.1";
 
   var validators$1 = {};
 
@@ -2296,8 +2435,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 +2462,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 +2480,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 +2580,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 +2696,7 @@
     }]);
     return CancelToken;
   }();
+  var CancelToken$1 = CancelToken;
 
   /**
    * Syntactic sugar for invoking a function and expanding an array for arguments.
@@ -2601,11 +2744,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 +2765,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 +2791,11 @@
 
   // Expose isAxiosError
   axios.isAxiosError = isAxiosError;
+  axios.AxiosHeaders = AxiosHeaders$1;
   axios.formToJSON = function (thing) {
     return formDataToJSON(utils.isHTMLForm(thing) ? new FormData(thing) : thing);
   };
+  axios["default"] = axios;
 
   return axios;