Comparing axios@0.33.0...axios@1.0.0 • npm-diff.app 📦🔃

@@ -1,19 +1,7 @@
1	Copyright (c) 2014-present Matt Zabriskie	1	# Copyright (c) 2014-present Matt Zabriskie & Collaborators
2		2
3	Permission is hereby granted, free of charge, to any person obtaining a copy
4	of this software and associated documentation files (the "Software"), to deal
5	in the Software without restriction, including without limitation the rights
6	to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7	copies of the Software, and to permit persons to whom the Software is
8	furnished to do so, subject to the following conditions:	3	Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
9		4
10	The above copyright notice and this permission notice shall be included in
11	all copies or substantial portions of the Software.	5	The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
12		6
13	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19	THE SOFTWARE.	7	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 'use strict';
+var utils = require('./utils');
+var bind = require('./helpers/bind');
+var Axios = require('./core/Axios');
+var mergeConfig = require('./core/mergeConfig');
+var defaults = require('./defaults');
+import utils from './utils.js';
+import bind from './helpers/bind.js';
+import Axios from './core/Axios.js';
+import mergeConfig from './core/mergeConfig.js';
+import defaults from './defaults/index.js';
+import formDataToJSON from './helpers/formDataToJSON.js';
+import CanceledError from './cancel/CanceledError.js';
+import CancelToken from'./cancel/CancelToken.js';
+import isCancel from'./cancel/isCancel.js';
+import {VERSION} from './env/data.js';
+import toFormData from './helpers/toFormData.js';
+import AxiosError from './core/AxiosError.js';
+import spread from './helpers/spread.js';
+import isAxiosError from './helpers/isAxiosError.js';
 /**
  * Create an instance of Axios
+ *
  * @param {Object} defaultConfig The default config for the instance
+ *
+ * @returns {Axios} A new instance of Axios
  */
 function createInstance(defaultConfig) {
+  var context = new Axios(defaultConfig);
+  const context = new Axios(defaultConfig);
+  const instance = bind(Axios.prototype.request, context);
   // Copy axios.prototype to instance
+  utils.extend(instance, Axios.prototype, context, {allOwnKeys: true});
   // Copy context to instance
+  utils.extend(instance, context, null, {allOwnKeys: true});
   // Factory for creating new instances
   instance.create = function create(instanceConfig) {
+}
 // Create the default instance to be exported
+const axios = createInstance(defaults);
 // Expose Axios class to allow class inheritance
 axios.Axios = Axios;
 // Expose Cancel & CancelToken
+axios.CanceledError = require('./cancel/CanceledError');
+axios.CancelToken = require('./cancel/CancelToken');
+axios.isCancel = require('./cancel/isCancel');
+axios.VERSION = require('./env/data').version;
+axios.CanceledError = CanceledError;
+axios.CancelToken = CancelToken;
+axios.isCancel = isCancel;
+axios.VERSION = VERSION;
+axios.toFormData = toFormData;
 // Expose AxiosError class
+axios.AxiosError = AxiosError;
 // alias for CanceledError for backward compatibility
 axios.Cancel = axios.CanceledError;
 axios.all = function all(promises) {
   return Promise.all(promises);
 };
+axios.spread = require('./helpers/spread');
+axios.spread = spread;
 // Expose isAxiosError
+axios.isAxiosError = isAxiosError;
+axios.formToJSON = thing => {
   return formDataToJSON(utils.isHTMLForm(thing) ? new FormData(thing) : thing);
 };
+module.exports = axios;
+// Allow use of default import syntax in TypeScript
+export default axios;

 'use strict';
+import toFormData from './toFormData.js';
+/**
+ * It encodes a string by replacing all characters that are not in the unreserved set with
+ * their percent-encoded equivalents
+ *
+ * @param {string} str - The string to encode.
+ *
+ * @returns {string} The encoded string.
+ */
 function encode(str) {
+  // Do not map `%00` back to a raw null byte: that reversed
+  // the safe percent-encoding from encodeURIComponent and enabled null byte injection.
+  const charMap = {
     '!': '%21',
     "'": '%27',
     '(': '%28',
     ')': '%29',
     '~': '%7E',
+    '%20': '+',
+    '%00': '\x00'
   };
+  return encodeURIComponent(str).replace(
+    /[!'\(\)~]|%20/g,
+    function replacer(match) {
+      return charMap[match];
+    }
+  return encodeURIComponent(str).replace(/[!'()~]|%20|%00/g, function replacer(match) {
+    return charMap[match];
+  });
+}
+/**
+ * It takes a params object and converts it to a FormData object
+ *
+ * @param {Object<string, any>} params - The parameters to be converted to a FormData object.
+ * @param {Object<string, any>} options - The options object passed to the Axios constructor.
+ *
+ * @returns {void}
+ */
 function AxiosURLSearchParams(params, options) {
   this._pairs = [];
   params && toFormData(params, this, options);
+}
+const prototype = AxiosURLSearchParams.prototype;
 prototype.append = function append(name, value) {
   this._pairs.push([name, value]);
 };
 prototype.toString = function toString(encoder) {
+  var _encode = encoder
+    ? function(value) {
+      return encoder.call(this, value, encode);
+    }
+  const _encode = encoder ? function(value) {
+    return encoder.call(this, value, encode);
+  } : encode;
+  return this._pairs
+    .map(function each(pair) {
+      return _encode(pair[0]) + '=' + _encode(pair[1]);
+    }, '')
+  return this._pairs.map(function each(pair) {
+    return _encode(pair[0]) + '=' + _encode(pair[1]);
+  }, '').join('&');
 };
+export default AxiosURLSearchParams;

@@ -1,7 +1,7 @@
1	'use strict';	1	'use strict';
2		2
3	module.exports = function bind(fn, thisArg) {	3	export default function bind(fn, thisArg) {
4	return function wrap() {	4	return function wrap() {
5	return fn.apply(thisArg, arguments);	5	return fn.apply(thisArg, arguments);
6	};	6	};
7	};	7	}

@@ -1,7 +1,7 @@
1	'use strict';	1	'use strict';
2		2
3	var isAbsoluteURL = require('../helpers/isAbsoluteURL');
4	var combineURLs = require('../helpers/combineURLs');	3	import isAbsoluteURL from '../helpers/isAbsoluteURL.js';
		4	import combineURLs from '../helpers/combineURLs.js';
5		5
6	/**	6	/**
7	* Creates a new URL by combining the baseURL with the requestedURL,	7	* Creates a new URL by combining the baseURL with the requestedURL,
@@ -10,14 +10,12 @@
10	*	10	*
11	* @param {string} baseURL The base URL	11	* @param {string} baseURL The base URL
12	* @param {string} requestedURL Absolute or relative URL to combine	12	* @param {string} requestedURL Absolute or relative URL to combine
13	* @param {boolean} allowAbsoluteUrls Set to true to allow absolute URLs
14	*	13	*
15	* @returns {string} The combined full path	14	* @returns {string} The combined full path
16	*/	15	*/
17	module.exports = function buildFullPath(baseURL, requestedURL, allowAbsoluteUrls) {
18	var isRelativeURL = !isAbsoluteURL(requestedURL);
19	if (baseURL && (isRelativeURL \|\| allowAbsoluteUrls === false)) {	16	export default function buildFullPath(baseURL, requestedURL) {
		17	if (baseURL && !isAbsoluteURL(requestedURL)) {
20	return combineURLs(baseURL, requestedURL);	18	return combineURLs(baseURL, requestedURL);
21	}	19	}
22	return requestedURL;	20	return requestedURL;
23	};	21	}

 'use strict';
+var utils = require('../utils');
+import utils from '../utils.js';
+import AxiosURLSearchParams from '../helpers/AxiosURLSearchParams.js';
+/**
+ * It replaces all instances of the characters `:`, `$`, `,`, `+`, `[`, and `]` with their
+ * URI encoded counterparts
+ *
+ * @param {string} val The value to be encoded.
+ *
+ * @returns {string} The encoded value.
+ */
 function encode(val) {
   return encodeURIComponent(val).
     replace(/%3A/gi, ':').
  * @param {string} url The base of the url (e.g., http://www.google.com)
  * @param {object} [params] The params to be appended
  * @param {?object} options
+ *
  * @returns {string} The formatted url
  */
+export default function buildURL(url, params, options) {
   /*eslint no-param-reassign:0*/
   if (!params) {
     return url;
+  }
+  const hashmarkIndex = url.indexOf('#');
   if (hashmarkIndex !== -1) {
     url = url.slice(0, hashmarkIndex);
+  }
+  var _encode = encode;
+  const _encode = options && options.encode || encode;
+  if (options) {
+    if (utils.isFunction(options)) {
+      serializeFn = options;
+    } else {
+      _encode = utils.hasOwnProperty(options, 'encode') && options.encode || encode;
+      serializeFn = utils.hasOwnProperty(options, 'serialize') ? options.serialize : undefined;
+    }
+  const serializerParams = utils.isURLSearchParams(params) ?
+    params.toString() :
+    new AxiosURLSearchParams(params, options).toString(_encode);
+  var serializedParams;
+  if (serializeFn) {
+    serializedParams = serializeFn(params, options);
+  } else {
+    serializedParams = utils.isURLSearchParams(params) ?
+      params.toString() :
+  if (serializerParams) {
+    url += (url.indexOf('?') === -1 ? '?' : '&') + serializerParams;
+  }
+  if (serializedParams) {
+    url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;
+  }
   return url;
+}

 'use strict';
+var AxiosError = require('../core/AxiosError');
+import AxiosError from '../core/AxiosError.js';
+import utils from '../utils.js';
 /**
  * A `CanceledError` is an object that is thrown when an operation is canceled.
+ *
+ * @class
  * @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
   __CANCEL__: true
 });
+export default CanceledError;

@@ -5,10 +5,11 @@
5	*	5	*
6	* @param {string} baseURL The base URL	6	* @param {string} baseURL The base URL
7	* @param {string} relativeURL The relative URL	7	* @param {string} relativeURL The relative URL
		8	*
8	* @returns {string} The combined URL	9	* @returns {string} The combined URL
9	*/	10	*/
10	module.exports = function combineURLs(baseURL, relativeURL) {	11	export default function combineURLs(baseURL, relativeURL) {
11	return relativeURL	12	return relativeURL
12	? baseURL.replace(/\/?\/$/, '') + '/' + relativeURL.replace(/^\/+/, '')	13	? baseURL.replace(/\/+$/, '') + '/' + relativeURL.replace(/^\/+/, '')
13	: baseURL;	14	: baseURL;
14	};	15	}

 'use strict';
+import utils from './../utils.js';
+import platform from '../platform/index.js';
+module.exports = (
+export default platform.isStandardBrowserEnv ?
+  // Standard browser envs support document.cookie
+    (function standardBrowserEnv() {
+      return {
+        write: function write(name, value, expires, path, domain, secure) {
+          var cookie = [];
+// Standard browser envs support document.cookie
+  (function standardBrowserEnv() {
+    return {
+      write: function write(name, value, expires, path, domain, secure) {
+        const cookie = [];
+        cookie.push(name + '=' + encodeURIComponent(value));
+          if (utils.isNumber(expires)) {
+            cookie.push('expires=' + new Date(expires).toGMTString());
+        if (utils.isNumber(expires)) {
+          cookie.push('expires=' + new Date(expires).toGMTString());
+        }
+          if (utils.isString(path)) {
+            cookie.push('path=' + path);
+        if (utils.isString(path)) {
+          cookie.push('path=' + path);
+        }
+          if (utils.isString(domain)) {
+            cookie.push('domain=' + domain);
+        if (utils.isString(domain)) {
+          cookie.push('domain=' + domain);
+        }
+          if (secure === true) {
+            cookie.push('secure');
+        if (secure === true) {
+          cookie.push('secure');
+        }
+          document.cookie = cookie.join('; ');
+        document.cookie = cookie.join('; ');
+      },
+        read: function read(name) {
+          var nameEQ = name + '=';
+          var cookies = document.cookie.split(';');
+      read: function read(name) {
+        const match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)'));
+        return (match ? decodeURIComponent(match[3]) : null);
+      },
+          for (var i = 0; i < cookies.length; i++) {
+            cookie = cookies[i];
+            while (cookie.charAt(0) === ' ') {
+              cookie = cookie.substring(1);
+            }
+            if (cookie.indexOf(nameEQ) === 0) {
+              return decodeURIComponent(cookie.substring(nameEQ.length));
+            }
+      remove: function remove(name) {
+        this.write(name, '', Date.now() - 86400000);
+      }
+    };
+  })() :
+          return 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() {}
+      };
+    })()
+// 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() {}
+    };
+  })();

@@ -1,3 +1,1 @@
1	module.exports = {
2	"version": "0.33.0"
3	};	1	export const VERSION = "1.0.0";

@@ -9,8 +9,10 @@
9	* @param {string} method The name of the deprecated method	9	* @param {string} method The name of the deprecated method
10	* @param {string} [instead] The alternate method to use if applicable	10	* @param {string} [instead] The alternate method to use if applicable
11	* @param {string} [docs] The documentation URL to get further details	11	* @param {string} [docs] The documentation URL to get further details
		12	*
		13	* @returns {void}
12	*/	14	*/
13	module.exports = function deprecatedMethod(method, instead, docs) {	15	export default function deprecatedMethod(method, instead, docs) {
14	try {	16	try {
15	console.warn(	17	console.warn(
16	'DEPRECATED method `' + method + '`.' +	18	'DEPRECATED method `' + method + '`.' +
@@ -21,4 +23,4 @@
21	console.warn('For more information about usage see ' + docs);	23	console.warn('For more information about usage see ' + docs);
22	}	24	}
23	} catch (e) { /* Ignore */ }	25	} catch (e) { /* Ignore */ }
24	};	26	}

 'use strict';
+var utils = require('./../utils');
+var transformData = require('./transformData');
+var isCancel = require('../cancel/isCancel');
+var defaults = require('../defaults');
+var CanceledError = require('../cancel/CanceledError');
+var normalizeHeaderName = require('../helpers/normalizeHeaderName');
+import transformData from './transformData.js';
+import isCancel from '../cancel/isCancel.js';
+import defaults from '../defaults/index.js';
+import CanceledError from '../cancel/CanceledError.js';
+import AxiosHeaders from '../core/AxiosHeaders.js';
 /**
  * Throws a `CanceledError` if cancellation has been requested.
+ *
+ * @param {Object} config The config that is to be used for the request
+ *
+ * @returns {void}
  */
 function throwIfCancellationRequested(config) {
   if (config.cancelToken) {
  * Dispatch a request to the server using the configured adapter.
+ *
  * @param {object} config The config that is to be used for the request
+ *
  * @returns {Promise} The Promise to be fulfilled
  */
+export default function dispatchRequest(config) {
   throwIfCancellationRequested(config);
+  // Ensure headers exist
+  config.headers = AxiosHeaders.from(config.headers);
   // Transform request data
   config.data = transformData.call(
     config,
+    config.data,
+    config.headers,
+    null,
     config.transformRequest
   );
+  normalizeHeaderName(config.headers, 'Accept');
+  const adapter = config.adapter || defaults.adapter;
+  // Flatten headers
+  var commonHeaders = utils.hasOwnProperty(config.headers, 'common') && config.headers.common
+    ? config.headers.common
+    : {};
+  var methodHeaders = config.method &&
+    utils.hasOwnProperty(config.headers, config.method) &&
+    config.headers[config.method]
+    ? config.headers[config.method]
+    : {};
+  config.headers = utils.merge(commonHeaders, methodHeaders, config.headers);
+  utils.forEach(
+    ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],
+    function cleanHeaderConfig(method) {
+      delete config.headers[method];
+    }
+  );
+  utils.forEach(config.headers, function sanitizeHeaderConfigValue(value, header) {
+    config.headers[header] = sanitizeHeaderValue(value);
+  });
+  var adapter = config.adapter || defaults.adapter;
   return adapter(config).then(function onAdapterResolution(response) {
     throwIfCancellationRequested(config);
     // Transform response data
     response.data = transformData.call(
       config,
+      response.data,
+      response.headers,
+      response.status,
+      config.transformResponse,
+      response
     );
+    response.headers = AxiosHeaders.from(response.headers);
     return response;
   }, function onAdapterRejection(reason) {
     if (!isCancel(reason)) {
       if (reason && reason.response) {
         reason.response.data = transformData.call(
           config,
+          reason.response.data,
+          reason.response.headers,
+          reason.response.status,
+          config.transformResponse,
+          reason.response
         );
+        reason.response.headers = AxiosHeaders.from(reason.response.headers);
+      }
+    }
     return Promise.reject(reason);
   });
+}

@@ -1,2 +1,2 @@
1	// eslint-disable-next-line strict
2	module.exports = require('form-data');	1	import FormData from 'form-data';
		2	export default FormData;

@@ -1,3 +1,3 @@
1	'use strict';	1	'use strict';
2		2
3	module.exports = FormData;	3	export default FormData;

 'use strict';
+var utils = require('../utils');
+import utils from '../utils.js';
+var MAX_FORM_DATA_TO_JSON_DEPTH = 100;
+function assertPathDepth(path) {
+  var depth = path.length - 1;
+  if (depth > MAX_FORM_DATA_TO_JSON_DEPTH) {
+    throw new AxiosError(
+      'Maximum object depth of ' + MAX_FORM_DATA_TO_JSON_DEPTH + ' exceeded (got ' + depth + ' levels)',
+      AxiosError.ERR_FORM_DATA_DEPTH_EXCEEDED
+    );
+  }
+}
+/**
+ * It takes a string like `foo[x][y][z]` and returns an array like `['foo', 'x', 'y', 'z']
+ *
+ * @param {string} name - The name of the property to get.
+ *
+ * @returns An array of strings.
+ */
 function parsePropPath(name) {
   // foo[x][y][z]
   // foo.x.y.z
   // foo-x-y-z
   // foo x y z
+  return utils.matchAll(/\w+|\[(\w*)]/g, name).map(match => {
     return match[0] === '[]' ? '' : match[1] || match[0];
   });
+}
+/**
+ * Convert an array to an object.
+ *
+ * @param {Array<any>} arr - The array to convert to an object.
+ *
+ * @returns An object with the same keys and values as the array.
+ */
 function arrayToObject(arr) {
+  var obj = {};
+  var keys = Object.keys(arr);
+  var i;
+  var len = keys.length;
+  const obj = {};
+  const keys = Object.keys(arr);
+  let i;
+  const len = keys.length;
+  let key;
   for (i = 0; i < len; i++) {
     key = keys[i];
     obj[key] = arr[key];
   return obj;
+}
+/**
+ * It takes a FormData object and returns a JavaScript object
+ *
+ * @param {string} formData The FormData object to convert to JSON.
+ *
+ * @returns {Object<string, any> | null} The converted object.
+ */
 function formDataToJSON(formData) {
   function buildPath(path, value, target, index) {
+    var name = path[index++];
+    if (name === '__proto__') return true;
+    var isNumericKey = Number.isFinite(+name);
+    let name = path[index++];
+    const isNumericKey = Number.isFinite(+name);
+    const isLast = index >= path.length;
     name = !name && utils.isArray(target) ? target.length : name;
     if (isLast) {
+      if (utils.hasOwnProp(target, name)) {
         target[name] = [target[name], value];
       } else {
         target[name] = value;
       target[name] = [];
+    }
+    const result = buildPath(path, value, target[name], index);
     if (result && utils.isArray(target[name])) {
       target[name] = arrayToObject(target[name]);
+  }
   if (utils.isFormData(formData) && utils.isFunction(formData.entries)) {
+    const obj = {};
+    utils.forEachEntry(formData, function(name, value) {
+      var path = parsePropPath(name);
+      assertPathDepth(path);
+    utils.forEachEntry(formData, (name, value) => {
+      buildPath(parsePropPath(name), value, obj, 0);
     });
     return obj;
   return null;
+}
+export default formDataToJSON;

@@ -1,10 +1,11 @@
1	'use strict';	1	import URLSearchParams from './classes/URLSearchParams.js'
		2	import FormData from './classes/FormData.js'
2		3
3	module.exports = {	4	export default {
4	isNode: true,	5	isNode: true,
5	classes: {	6	classes: {
6	URLSearchParams: require('./classes/URLSearchParams'),
7	FormData: require('./classes/FormData'),	7	URLSearchParams,
		8	FormData,
8	Blob: typeof Blob !== 'undefined' && Blob \|\| null	9	Blob: typeof Blob !== 'undefined' && Blob \|\| null
9	},	10	},
10	protocols: [ 'http', 'https', 'file', 'data' ]	11	protocols: [ 'http', 'https', 'file', 'data' ]

@@ -4,11 +4,12 @@
4	* Determines whether the specified URL is absolute	4	* Determines whether the specified URL is absolute
5	*	5	*
6	* @param {string} url The URL to test	6	* @param {string} url The URL to test
		7	*
7	* @returns {boolean} True if the specified URL is absolute, otherwise false	8	* @returns {boolean} True if the specified URL is absolute, otherwise false
8	*/	9	*/
9	module.exports = function isAbsoluteURL(url) {	10	export default function isAbsoluteURL(url) {
10	// A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL).	11	// A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL).
11	// RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed	12	// RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed
12	// by any combination of letters, digits, plus, period, or hyphen.	13	// by any combination of letters, digits, plus, period, or hyphen.
13	return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);	14	return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
14	};	15	}

@@ -1,6 +1,6 @@
1	'use strict';	1	'use strict';
2		2
3	var utils = require('../utils');	3	import utils from '../utils.js';
4		4
5	/**	5	/**
6	* Config-specific merge-function which creates a new config-object	6	* Config-specific merge-function which creates a new config-object
@@ -8,28 +8,17 @@
8	*	8	*
9	* @param {Object} config1	9	* @param {Object} config1
10	* @param {Object} config2	10	* @param {Object} config2
		11	*
11	* @returns {Object} New object resulting from merging config2 to config1	12	* @returns {Object} New object resulting from merging config2 to config1
12	*/	13	*/
13	module.exports = function mergeConfig(config1, config2) {	14	export default function mergeConfig(config1, config2) {
14	// eslint-disable-next-line no-param-reassign	15	// eslint-disable-next-line no-param-reassign
15	config2 = config2 \|\| {};	16	config2 = config2 \|\| {};
16	// Use a null-prototype object so a polluted Object.prototype cannot leak
17	// values (e.g. transport, adapter) into the returned config via inheritance.
18	var config = Object.create(null);	17	const config = {};
19		18
20	function getOwn(source, prop) {
21	return utils.hasOwnProperty(source, prop) ? source[prop] : undefined;
22	}
23
24	function hasOwn(source, prop) {
25	return utils.hasOwnProperty(source, prop);
26	}
27
28	function getMergedValue(target, source) {	19	function getMergedValue(target, source) {
29	if (utils.isPlainObject(target) && utils.isPlainObject(source)) {	20	if (utils.isPlainObject(target) && utils.isPlainObject(source)) {
30	return utils.merge(target, source);	21	return utils.merge(target, source);
31	} else if (utils.isEmptyObject(source)) {
32	return utils.merge({}, target);
33	} else if (utils.isPlainObject(source)) {	22	} else if (utils.isPlainObject(source)) {
34	return utils.merge({}, source);	23	return utils.merge({}, source);
35	} else if (utils.isArray(source)) {	24	} else if (utils.isArray(source)) {
@@ -40,39 +29,39 @@
40		29
41	// eslint-disable-next-line consistent-return	30	// eslint-disable-next-line consistent-return

@@ -1,15 +1,15 @@
1	'use strict';	1	'use strict';
2		2
3	var utils = require('./../utils');	3	import utils from './../utils.js';
4		4
5	// Headers whose duplicates are ignored by node	5	// RawAxiosHeaders whose duplicates are ignored by node
6	// c.f. https://nodejs.org/api/http.html#http_message_headers	6	// c.f. https://nodejs.org/api/http.html#http_message_headers
7	var ignoreDuplicateOf = [	7	const ignoreDuplicateOf = utils.toObjectSet([
8	'age', 'authorization', 'content-length', 'content-type', 'etag',	8	'age', 'authorization', 'content-length', 'content-type', 'etag',
9	'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since',	9	'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since',
10	'last-modified', 'location', 'max-forwards', 'proxy-authorization',	10	'last-modified', 'location', 'max-forwards', 'proxy-authorization',
11	'referer', 'retry-after', 'user-agent'	11	'referer', 'retry-after', 'user-agent'
12	];	12	]);
13		13
14	/**	14	/**
15	* Parse headers into an object	15	* Parse headers into an object
@@ -21,31 +21,33 @@
21	* Transfer-Encoding: chunked	21	* Transfer-Encoding: chunked
22	* ```	22	* ```
23	*	23	*
24	* @param {String} headers Headers needing to be parsed	24	* @param {String} rawHeaders Headers needing to be parsed
		25	*
25	* @returns {Object} Headers parsed into an object	26	* @returns {Object} Headers parsed into an object
26	*/	27	*/
27	module.exports = function parseHeaders(headers) {
28	var parsed = {};
29	var key;
30	var val;
31	var i;	28	export default rawHeaders => {
		29	const parsed = {};
		30	let key;
		31	let val;
		32	let i;
32		33
33	if (!headers) { return parsed; }
34
35	utils.forEach(headers.split('\n'), function parser(line) {	34	rawHeaders && rawHeaders.split('\n').forEach(function parser(line) {
36	i = line.indexOf(':');	35	i = line.indexOf(':');
37	key = utils.trim(line.slice(0, i)).toLowerCase();
38	val = utils.trim(line.slice(i + 1));	36	key = line.substring(0, i).trim().toLowerCase();

 'use strict';
+var AxiosError = require('../core/AxiosError');
+var parseProtocol = require('./parseProtocol');
+import AxiosError from '../core/AxiosError.js';
+import parseProtocol from './parseProtocol.js';
+import platform from '../platform/index.js';
+const DATA_URL_PATTERN = /^(?:([^;]+);)?(?:[^;]+;)?(base64|),([\s\S]*)$/;
 /**
  * Parse data uri to a Buffer or Blob
+ *
  * @param {String} uri
  * @param {?Boolean} asBlob
  * @param {?Object} options
  * @param {?Function} options.Blob
+ *
  * @returns {Buffer|Blob}
  */
+module.exports = function fromDataURI(uri, asBlob, options) {
+  var _Blob = options && options.Blob || platform.classes.Blob;
+export default function fromDataURI(uri, asBlob, options) {
+  const _Blob = options && options.Blob || platform.classes.Blob;
+  const protocol = parseProtocol(uri);
   if (asBlob === undefined && _Blob) {
     asBlob = true;
   if (protocol === 'data') {
     uri = protocol.length ? uri.slice(protocol.length + 1) : uri;
+    const match = DATA_URL_PATTERN.exec(uri);
     if (!match) {
       throw new AxiosError('Invalid URL', AxiosError.ERR_INVALID_URL);
+    }
+    var mime = match[1];
+    var isBase64 = match[2];
+    var body = match[3];
+    const mime = match[1];
+    const isBase64 = match[2];
+    const body = match[3];
+    const buffer = Buffer.from(decodeURIComponent(body), isBase64 ? 'base64' : 'utf8');
     if (asBlob) {
       if (!_Blob) {
+  }
   throw new AxiosError('Unsupported protocol ' + protocol, AxiosError.ERR_NOT_SUPPORT);
+}

@@ -1,1 +1,2 @@
1	module.exports = require('./lib/axios');	1	import axios from './lib/axios.js';
		2	export default axios;

+import URLSearchParams from './classes/URLSearchParams.js'
+import FormData from './classes/FormData.js'
+/**
+ * Determine if we're running in a standard browser environment
+ *
+ * This allows axios to run in a web worker, and react-native.
+ * Both environments support XMLHttpRequest, but not fully standard globals.
+ *
+ * web workers:
+ *  typeof window -> undefined
+ *  typeof document -> undefined
+ *
+ * react-native:
+ *  navigator.product -> 'ReactNative'
+ * nativescript
+ *  navigator.product -> 'NativeScript' or 'NS'
+ *
+ * @returns {boolean}
+ */
+const isStandardBrowserEnv = (() => {
+  let product;
+  if (typeof navigator !== 'undefined' && (
+    (product = navigator.product) === 'ReactNative' ||
+    product === 'NativeScript' ||
+    product === 'NS')
+  ) {
+    return false;
+  }
+  return typeof window !== 'undefined' && typeof document !== 'undefined';
+})();
+export default {
   isBrowser: true,
   classes: {
+    URLSearchParams: require('./classes/URLSearchParams'),
+    FormData: require('./classes/FormData'),
+    URLSearchParams,
+    FormData,
+    Blob
   },
+  isStandardBrowserEnv,
   protocols: ['http', 'https', 'file', 'blob', 'url', 'data']
 };

@@ -1,3 +1,3 @@
1	'use strict';	1	import platform from './node/index.js';
2		2
3	module.exports = require('./node/');	3	export {platform as default}

 'use strict';
+import utils from './../utils.js';
+function InterceptorManager() {
+  this.handlers = [];
+class InterceptorManager {
+  constructor() {
+    this.handlers = [];
+  }
+/**
+ * Add a new interceptor to the stack
+ *
+ * @param {Function} fulfilled The function to handle `then` for a `Promise`
+ * @param {Function} rejected The function to handle `reject` for a `Promise`
+ *
+ * @return {Number} An ID used to remove interceptor later
+ */
+InterceptorManager.prototype.use = function use(fulfilled, rejected, options) {
+  this.handlers.push({
+    fulfilled: fulfilled,
+    rejected: rejected,
+    synchronous: options ? options.synchronous : false,
+    runWhen: options ? options.runWhen : null
+  });
+  return this.handlers.length - 1;
+};
+/**
+ * Remove an interceptor from the stack
+ *
+ * @param {Number} id The ID that was returned by `use`
+ */
+InterceptorManager.prototype.eject = function eject(id) {
+  if (this.handlers[id]) {
+  /**
+   * Add a new interceptor to the stack
+   *
+   * @param {Function} fulfilled The function to handle `then` for a `Promise`
+   * @param {Function} rejected The function to handle `reject` for a `Promise`
+   *
+   * @return {Number} An ID used to remove interceptor later
+   */
+  use(fulfilled, rejected, options) {
+    this.handlers.push({
+      fulfilled,
+      rejected,
+      synchronous: options ? options.synchronous : false,
+      runWhen: options ? options.runWhen : null
+    });
+    return this.handlers.length - 1;
+  }
+};
+/**
+ * Clear all interceptors from the stack
+ */
+InterceptorManager.prototype.clear = function clear() {
+  if (this.handlers) {
+  /**
+   * Remove an interceptor from the stack
+   *
+   * @param {Number} id The ID that was returned by `use`
+   *
+   * @returns {Boolean} `true` if the interceptor was removed, `false` otherwise
+   */
+  eject(id) {
+    if (this.handlers[id]) {
+      this.handlers[id] = null;
+    }
+  }
+};
+/**
+ * Iterate over all the registered interceptors
+ *
+ * This method is particularly useful for skipping over any
+ * interceptors that may have become `null` calling `eject`.
+ *
+ * @param {Function} fn The function to call for each interceptor
+ */
+InterceptorManager.prototype.forEach = function forEach(fn) {
+  utils.forEach(this.handlers, function forEachHandler(h) {
+    if (h !== null) {
+  /**
+   * Clear all interceptors from the stack
+   *
+   * @returns {void}
+   */
+  clear() {
+    if (this.handlers) {
+      this.handlers = [];
+    }
+  });
+  }
+  /**
+   * Iterate over all the registered interceptors
+   *
+   * This method is particularly useful for skipping over any
+   * interceptors that may have become `null` calling `eject`.
+   *
+   * @param {Function} fn The function to call for each interceptor
+   *
+   * @returns {void}
+   */
+  forEach(fn) {
+    utils.forEach(this.handlers, function forEachHandler(h) {
+      if (h !== null) {
+        fn(h);
+      }
+    });
+  }
+}
+export default InterceptorManager;

@@ -1,13 +1,14 @@
1	'use strict';	1	'use strict';
2		2
3	var utils = require('./../utils');	3	import utils from './../utils.js';
4		4
5	/**	5	/**
6	* Determines whether the payload is an error thrown by Axios	6	* Determines whether the payload is an error thrown by Axios
7	*	7	*
8	* @param {*} payload The value to test	8	* @param {*} payload The value to test
		9	*
9	* @returns {boolean} True if the payload is an error thrown by Axios, otherwise false	10	* @returns {boolean} True if the payload is an error thrown by Axios, otherwise false
10	*/	11	*/
11	module.exports = function isAxiosError(payload) {	12	export default function isAxiosError(payload) {
12	return utils.isObject(payload) && (payload.isAxiosError === true);	13	return utils.isObject(payload) && (payload.isAxiosError === true);
13	};	14	}

@@ -1,5 +1,5 @@
1	'use strict';	1	'use strict';
2		2
3	module.exports = function isCancel(value) {	3	export default function isCancel(value) {
4	return !!(value && value.__CANCEL__);	4	return !!(value && value.__CANCEL__);
5	};	5	}

 'use strict';
+import utils from './../utils.js';
+import platform from '../platform/index.js';
+module.exports = (
+export default 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');
+// 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() {
+    const msie = /(msie|trident)/i.test(navigator.userAgent);
+    const urlParsingNode = document.createElement('a');
+    let originURL;
+      /**
+      * Parse a URL to discover it's components
+      *
+      * @param {String} url The URL to be parsed
+      * @returns {Object}
+      */
+      function resolveURL(url) {
+    /**
+    * Parse a URL to discover it's components
+    *
+    * @param {String} url The URL to be parsed
+    * @returns {Object}
+    */
+    function resolveURL(url) {
+      let href = url;
+        if (msie) {
+          // IE needs attribute set twice to normalize properties
+          urlParsingNode.setAttribute('href', href);
+          href = urlParsingNode.href;
+        }
+      if (msie) {
+        // IE needs attribute set twice to normalize properties
         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
+        href = urlParsingNode.href;
+      }
+      urlParsingNode.setAttribute('href', 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 &&
+      // 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
       };
+    }
+    // Non standard browser envs (web workers, react-native) lack needed support.
+    (function nonStandardBrowserEnv() {
+      return function isURLSameOrigin() {
+        return true;
+      };
+    })()
+    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) {
+      const 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;
+    };
+  })();

 import commonjs from '@rollup/plugin-commonjs';
 import {terser} from "rollup-plugin-terser";
 import json from '@rollup/plugin-json';
+import { babel } from '@rollup/plugin-babel';
+import autoExternal from 'rollup-plugin-auto-external';
+import bundleSize from 'rollup-plugin-bundle-size'
 const lib = require("./package.json");
 const outputFileName = 'axios';
 const name = "axios";
 const input = './lib/axios.js';
+const buildConfig = ({es5, browser = true, minifiedVersion = true, ...config}) => {
   const build = ({minified}) => ({
     input,
     },
     plugins: [
       json(),
+      resolve({browser}),
       commonjs(),
       minified && terser(),
+      minified && bundleSize(),
+      ...(es5 ? [babel({
+        babelHelpers: 'bundled',
+        presets: ['@babel/preset-env']
+      })] : []),
       ...(config.plugins || []),
+    ]
   });
+  const configs = [
     build({minified: false}),
+    build({minified: true}),
   ];
+  if (minifiedVersion) {
+    configs.push(build({minified: true}))
+  }
+  return configs;
 };
 export default async () => {
   const year = new Date().getFullYear();
+  const banner = `// Axios v${lib.version} Copyright (c) ${year} ${lib.author} and contributors`;
   return [
     ...buildConfig({
+      es5: true,
       output: {
         file: `dist/${outputFileName}`,
         name,
         exports: "named",
         banner
+      }
+    }),
+    // Node.js commonjs build
+    {
+      input,
+      output: {
+        file: `dist/node/${name}.cjs`,
+        format: "cjs",
+        preferConst: true,
+        exports: "default",
+        banner
+      },
+      plugins: [
+        autoExternal(),
+        resolve(),
+        commonjs()
+      ]
+    }
+  ]
 };

 'use strict';
+import AxiosError from './AxiosError.js';
 /**
  * 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.
  */
+module.exports = function settle(resolve, reject, response) {
+export default function settle(resolve, reject, response) {
+  const validateStatus = response.config.validateStatus;
   if (!response.status || !validateStatus || validateStatus(response.status)) {
     resolve(response);
   } else {
       response
     ));
+  }
+}

Comparingaxios@0.33.0

Comparingaxios@0.33.0

Source

npm diff

Options

Bundlephobia

Bundlephobia

Packagephobia

Packagephobia

+++0---0

Packagephobia

LICENSE +++4---16

dist/axios.js +++1576---1368

dist/esm/axios.js +++1491---1254

lib/axios.js +++33---25

lib/core/Axios.js +++126---116

lib/core/AxiosError.js +++14---87

lib/helpers/AxiosURLSearchParams.js +++31---23

lib/helpers/bind.js +++2---2

lib/core/buildFullPath.js +++5---7

lib/helpers/buildURL.js +++20---27

lib/cancel/CanceledError.js +++5---4

lib/cancel/CancelToken.js +++90---87

bin/check-build-version.js +++0---19

lib/helpers/combineURLs.js +++4---3

lib/helpers/cookies.js +++40---54

lib/env/data.js +++1---3

lib/helpers/defaultRedactKeys.js +++0---3

lib/helpers/deprecatedMethod.js +++4---2

lib/core/dispatchRequest.js +++21---49

lib/helpers/estimateDataURLDecodedBytes.js +++0---79

lib/env/classes/FormData.js +++2---2

lib/platform/browser/classes/FormData.js +++1---1

lib/platform/node/classes/FormData.js +++2---2

lib/helpers/formDataToJSON.js +++37---36

lib/helpers/fromDataURI.js +++15---13

lib/adapters/http.js +++297---485

index.js +++2---1

lib/defaults/index.js +++50---46

lib/platform/browser/index.js +++37---5

lib/platform/index.js +++2---2

lib/platform/node/index.js +++5---4

lib/core/InterceptorManager.js +++61---53

lib/helpers/isAbsoluteURL.js +++3---2

lib/helpers/isAxiosError.js +++4---3

lib/cancel/isCancel.js +++2---2

lib/helpers/isURLSameOrigin.js +++55---56

lib/core/mergeConfig.js +++17---33

lib/helpers/normalizeHeaderName.js +++0---12

lib/helpers/null.js +++1---1

lib/helpers/parseHeaders.js +++24---22

lib/helpers/parseProtocol.js +++3---3

rollup.config.js +++36---6

lib/helpers/sanitizeHeaderValue.js +++0---22

lib/core/settle.js +++6---4

lib/helpers/shouldBypassProxy.js +++0---187

lib/helpers/spread.js +++3---2

bin/ssl_hotfix.js +++1---1

lib/helpers/toFormData.js +++73---56

lib/helpers/toURLEncodedForm.js +++5---5

lib/core/transformData.js +++15---10

lib/defaults/transitional.js +++1---1

lib/platform/browser/classes/URLSearchParams.js +++2---3

lib/platform/node/classes/URLSearchParams.js +++2---3

lib/utils.js +++305---257

lib/helpers/validator.js +++20---15

lib/adapters/xhr.js +++101---160

package.json +++58---25

AGENTS.md +++0---38

CHANGELOG.md +++162---1166

CLAUDE.md +++0---1

README.md +++39---70

SECURITY.md +++3---2

UPGRADE_GUIDE.md +++1---188

mise.toml +++0---2

index.d.ts +++205---73

dist/node/axios.cjs +++3750---0

karma.conf.cjs +++250---0

lib/core/AxiosHeaders.js +++274---0

lib/helpers/AxiosTransformStream.js +++191---0

Comparing
`axios@0.33.0`

Comparing
`axios@0.33.0`

@@ -18,10 +18,11 @@
18	* ```	18	* ```
19	*	19	*
20	* @param {Function} callback	20	* @param {Function} callback
		21	*
21	* @returns {Function}	22	* @returns {Function}
22	*/	23	*/
23	module.exports = function spread(callback) {	24	export default function spread(callback) {
24	return function wrap(arr) {	25	return function wrap(arr) {
25	return callback.apply(null, arr);	26	return callback.apply(null, arr);
26	};	27	};
27	};	28	}

@@ -1,4 +1,4 @@
1	const {spawn} = require('child_process');	1	import {spawn} from 'child_process';
2		2
3	const args = process.argv.slice(2);	3	const args = process.argv.slice(2);
4		4

@@ -1,10 +1,10 @@
1	'use strict';	1	'use strict';
2		2
3	var utils = require('../utils');
4	var toFormData = require('./toFormData');
5	var platform = require('../platform/');	3	import utils from '../utils.js';
		4	import toFormData from './toFormData.js';
		5	import platform from '../platform/index.js';
6		6
7	module.exports = function toURLEncodedForm(data, options) {	7	export default function toURLEncodedForm(data, options) {
8	return toFormData(data, new platform.classes.URLSearchParams(), Object.assign({	8	return toFormData(data, new platform.classes.URLSearchParams(), Object.assign({
9	visitor: function(value, key, path, helpers) {	9	visitor: function(value, key, path, helpers) {
10	if (platform.isNode && utils.isBuffer(value)) {	10	if (platform.isNode && utils.isBuffer(value)) {
@@ -15,4 +15,4 @@
15	return helpers.defaultVisitor.apply(this, arguments);	15	return helpers.defaultVisitor.apply(this, arguments);
16	}	16	}
17	}, options));	17	}, options));
18	};	18	}

 'use strict';
+var utils = require('./../utils');
+import utils from './../utils.js';
+import defaults from '../defaults/index.js';
+import AxiosHeaders from '../core/AxiosHeaders.js';
 /**
  * Transform the data for a request or a response
+ *
+ * @param {Object|String} data The data to be transformed
+ * @param {Array} headers The headers for the request or response
+ * @param {Number} status HTTP status code
  * @param {Array|Function} fns A single function or Array of functions
+ * @param {?Object} response The response object
+ *
  * @returns {*} The resulting transformed data
  */
+module.exports = function transformData(data, headers, status, fns) {
+  var context = this || defaults;
+export default function transformData(fns, response) {
+  const config = this || defaults;
+  const context = response || config;
+  const headers = AxiosHeaders.from(context.headers);
+  let data = context.data;
   utils.forEach(fns, function transform(fn) {
+    data = fn.call(config, data, headers.normalize(), response ? response.status : undefined);
   });
+  headers.normalize();
   return data;
+}

@@ -1,5 +1,4 @@
1	'use strict';	1	'use strict';
2		2
3	var AxiosURLSearchParams = require('../../../helpers/AxiosURLSearchParams');
4
5	module.exports = typeof URLSearchParams !== 'undefined' ? URLSearchParams : AxiosURLSearchParams;	3	import AxiosURLSearchParams from '../../../helpers/AxiosURLSearchParams.js';
		4	export default typeof URLSearchParams !== 'undefined' ? URLSearchParams : AxiosURLSearchParams;

@@ -1,24 +1,26 @@
1	'use strict';	1	'use strict';
2		2
3	var VERSION = require('../env/data').version;
4	var AxiosError = require('../core/AxiosError');	3	import {VERSION} from '../env/data.js';
		4	import AxiosError from '../core/AxiosError.js';
5		5
6	var validators = {};	6	const validators = {};
7		7
8	// eslint-disable-next-line func-names	8	// eslint-disable-next-line func-names
9	['object', 'boolean', 'number', 'function', 'string', 'symbol'].forEach(function(type, i) {	9	['object', 'boolean', 'number', 'function', 'string', 'symbol'].forEach((type, i) => {
10	validators[type] = function validator(thing) {	10	validators[type] = function validator(thing) {
11	return typeof thing === type \|\| 'a' + (i < 1 ? 'n ' : ' ') + type;	11	return typeof thing === type \|\| 'a' + (i < 1 ? 'n ' : ' ') + type;
12	};	12	};
13	});	13	});
14		14
15	var deprecatedWarnings = {};	15	const deprecatedWarnings = {};
16		16
17	/**	17	/**
18	* Transitional option validator	18	* Transitional option validator
		19	*
19	* @param {function\|boolean?} validator - set to false if the transitional option has been removed	20	* @param {function\|boolean?} validator - set to false if the transitional option has been removed
20	* @param {string?} version - deprecated version / removed since version	21	* @param {string?} version - deprecated version / removed since version
21	* @param {string?} message - some message with additional info	22	* @param {string?} message - some message with additional info
		23	*
22	* @returns {function}	24	* @returns {function}
23	*/	25	*/
24	validators.transitional = function transitional(validator, version, message) {	26	validators.transitional = function transitional(validator, version, message) {
@@ -27,7 +29,7 @@
27	}	29	}
28		30
29	// eslint-disable-next-line func-names	31	// eslint-disable-next-line func-names
30	return function(value, opt, opts) {	32	return (value, opt, opts) => {
31	if (validator === false) {	33	if (validator === false) {
32	throw new AxiosError(	34	throw new AxiosError(
33	formatMessage(opt, ' has been removed' + (version ? ' in ' + version : '')),	35	formatMessage(opt, ' has been removed' + (version ? ' in ' + version : '')),
@@ -52,23 +54,26 @@
52		54
53	/**	55	/**
54	* Assert object's properties type	56	* Assert object's properties type
		57	*
55	* @param {object} options	58	* @param {object} options
56	* @param {object} schema	59	* @param {object} schema
57	* @param {boolean?} allowUnknown	60	* @param {boolean?} allowUnknown
		61	*
		62	* @returns {object}
58	*/	63	*/
59		64
60	function assertOptions(options, schema, allowUnknown) {	65	function assertOptions(options, schema, allowUnknown) {
61	if (typeof options !== 'object') {	66	if (typeof options !== 'object') {
62	throw new AxiosError('options must be an object', AxiosError.ERR_BAD_OPTION_VALUE);	67	throw new AxiosError('options must be an object', AxiosError.ERR_BAD_OPTION_VALUE);
63	}	68	}
64	var keys = Object.keys(options);
65	var i = keys.length;	69	const keys = Object.keys(options);
		70	let i = keys.length;
66	while (i-- > 0) {	71	while (i-- > 0) {
67	var opt = keys[i];
68	var validator = schema[opt];	72	const opt = keys[i];
		73	const validator = schema[opt];
69	if (validator) {	74	if (validator) {
70	var value = options[opt];
71	var result = value === undefined \|\| validator(value, opt, options);	75	const value = options[opt];
		76	const result = value === undefined \|\| validator(value, opt, options);
72	if (result !== true) {	77	if (result !== true) {
73	throw new AxiosError('option ' + opt + ' must be ' + result, AxiosError.ERR_BAD_OPTION_VALUE);	78	throw new AxiosError('option ' + opt + ' must be ' + result, AxiosError.ERR_BAD_OPTION_VALUE);
74	}	79	}
@@ -80,7 +85,7 @@
80	}	85	}
81	}	86	}
82		87
83	module.exports = {
84	assertOptions: assertOptions,
85	validators: validators	88	export default {
		89	assertOptions,
		90	validators
86	};	91	};

@@ -1,5 +1,6 @@
1	# Reporting a Vulnerability	1	# Reporting a Vulnerability
2		2
3	If you discover a security vulnerability within axios, please submit a report via [huntr.dev](https://huntr.dev/bounties/?target=https%3A%2F%2Fgithub.com%2Faxios%2Faxios). Bounties and CVEs are automatically managed and allocated via the platform.	3	If you discover a security vulnerability in axios please disclose it via [our huntr page](https://huntr.dev/repos/axios/axios/). Bounty eligibility, CVE assignment, response times and past reports are all there.
4		4
5	All security vulnerabilities will be promptly addressed.	5
		6	Thank you for improving the security of axios.