Comparing axios@1.13.5...axios@1.13.6 • npm-diff.app 📦🔃

 import httpAdapter from './http.js';
 import xhrAdapter from './xhr.js';
 import * as fetchAdapter from './fetch.js';
+import AxiosError from "../core/AxiosError.js";
+import AxiosError from '../core/AxiosError.js';
 /**
  * Known adapters mapping.
  * - `http` for Node.js
  * - `xhr` for browsers
  * - `fetch` for fetch API-based requests
+ *
+ *
  * @type {Object<string, Function|Object>}
  */
 const knownAdapters = {
   xhr: xhrAdapter,
   fetch: {
     get: fetchAdapter.getFetch,
+  }
+  },
 };
 // Assign adapter names for easier debugging and identification
 /**
  * Render a rejection reason string for unknown or unsupported adapters
+ *
+ *
  * @param {string} reason
  * @returns {string}
  */
 /**
  * Check if the adapter is resolved (function, null, or false)
+ *
+ *
  * @param {Function|null|false} adapter
  * @returns {boolean}
  */
+const isResolvedHandle = (adapter) => utils.isFunction(adapter) || adapter === null || adapter === false;
+const isResolvedHandle = (adapter) =>
+  utils.isFunction(adapter) || adapter === null || adapter === false;
 /**
  * Get the first suitable adapter from the provided list.
  * Tries each adapter in order until a supported one is found.
  * Throws an AxiosError if no adapter is suitable.
+ *
+ *
  * @param {Array<string|Function>|string|Function} adapters - Adapter(s) by name or function.
  * @param {Object} config - Axios request configuration
  * @throws {AxiosError} If no suitable adapter is available
+  }
   if (!adapter) {
+    const reasons = Object.entries(rejectedReasons)
+      .map(([id, state]) => `adapter ${id} ` +
+    const reasons = Object.entries(rejectedReasons).map(
+      ([id, state]) =>
+        `adapter ${id} ` +
         (state === false ? 'is not supported by the environment' : 'is not available in the build')
+      );
+    );
+    let s = length ?
+      (reasons.length > 1 ? 'since :\n' + reasons.map(renderReason).join('\n') : ' ' + renderReason(reasons[0])) :
+      'as no adapter specified';
+    let s = length
+      ? reasons.length > 1
+        ? 'since :\n' + reasons.map(renderReason).join('\n')
+        : ' ' + renderReason(reasons[0])
+      : 'as no adapter specified';
     throw new AxiosError(
       `There is no suitable adapter to dispatch the request ` + s,
    * Exposes all known adapters
    * @type {Object<string, Function|Object>}
    */
+  adapters: knownAdapters
+  adapters: knownAdapters,
 };

 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 { 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';
+import AxiosHeaders from "./core/AxiosHeaders.js";
+import AxiosHeaders from './core/AxiosHeaders.js';
 import adapters from './adapters/adapters.js';
 import HttpStatusCode from './helpers/HttpStatusCode.js';
   const instance = bind(Axios.prototype.request, context);
   // Copy axios.prototype to instance
+  utils.extend(instance, Axios.prototype, context, {allOwnKeys: true});
+  utils.extend(instance, Axios.prototype, context, { allOwnKeys: true });
   // Copy context to instance
+  utils.extend(instance, context, null, {allOwnKeys: true});
+  utils.extend(instance, context, null, { allOwnKeys: true });
   // Factory for creating new instances
   instance.create = function create(instanceConfig) {
 axios.AxiosHeaders = AxiosHeaders;
+axios.formToJSON = thing => formDataToJSON(utils.isHTMLForm(thing) ? new FormData(thing) : thing);
+axios.formToJSON = (thing) => formDataToJSON(utils.isHTMLForm(thing) ? new FormData(thing) : thing);
 axios.getAdapter = adapters.getAdapter;
 axios.default = axios;
 // this module should only have a default export
+export default axios
+export default axios;

 import utils from '../utils.js';
 class AxiosError extends Error {
+    static from(error, code, config, request, response, customProps) {
+        const axiosError = new AxiosError(error.message, code || error.code, config, request, response);
+        axiosError.cause = error;
+        axiosError.name = error.name;
+        customProps && Object.assign(axiosError, customProps);
+        return axiosError;
+  static from(error, code, config, request, response, customProps) {
+    const axiosError = new AxiosError(error.message, code || error.code, config, request, response);
+    axiosError.cause = error;
+    axiosError.name = error.name;
+    // Preserve status from the original error if not already set from response
+    if (error.status != null && axiosError.status == null) {
+      axiosError.status = error.status;
+    }
+    customProps && Object.assign(axiosError, customProps);
+    return axiosError;
+  }
     /**
      * Create an Error with the specified message, config, error code, request and response.
+     *
      * @returns {Error} The created error.
      */
     constructor(message, code, config, request, response) {
+        super(message);
+        this.name = 'AxiosError';
+        this.isAxiosError = true;
+        code && (this.code = code);
+        config && (this.config = config);
+        request && (this.request = request);
+        if (response) {
+            this.response = response;
+            this.status = response.status;
+        }
+      super(message);
+      // Make message enumerable to maintain backward compatibility
+      // The native Error constructor sets message as non-enumerable,
+      // but axios < v1.13.3 had it as enumerable
+      Object.defineProperty(this, 'message', {
+          value: message,
+          enumerable: true,
+          writable: true,
+          configurable: true
+      });
+      this.name = 'AxiosError';
+      this.isAxiosError = true;
+      code && (this.code = code);
+      config && (this.config = config);
+      request && (this.request = request);
+      if (response) {
+          this.response = response;
+          this.status = response.status;
+      }
+    }
+    toJSON() {
+        return {
+            // Standard
+            message: this.message,
+            name: this.name,
+            // Microsoft
+            description: this.description,
+            number: this.number,
+            // Mozilla
+            fileName: this.fileName,
+            lineNumber: this.lineNumber,
+            columnNumber: this.columnNumber,
+            stack: this.stack,
+            // Axios
+            config: utils.toJSONObject(this.config),
+            code: this.code,
+            status: this.status,
+        };
+    }
+  toJSON() {
+    return {
+      // Standard
+      message: this.message,
+      name: this.name,
+      // Microsoft
+      description: this.description,
+      number: this.number,
+      // Mozilla
+      fileName: this.fileName,
+      lineNumber: this.lineNumber,
+      columnNumber: this.columnNumber,
+      stack: this.stack,
+      // Axios
+      config: utils.toJSONObject(this.config),
+      code: this.code,
+      status: this.status,
+    };
+  }
+}
 // This can be changed to static properties as soon as the parser options in .eslint.cjs are updated.

 const kInternals = Symbol('internals');
+class AxiosTransformStream extends stream.Transform{
+class AxiosTransformStream extends stream.Transform {
   constructor(options) {
+    options = utils.toFlatObject(options, {
+      maxRate: 0,
+      chunkSize: 64 * 1024,
+      minChunkSize: 100,
+      timeWindow: 500,
+      ticksRate: 2,
+      samplesCount: 15
+    }, null, (prop, source) => {
+      return !utils.isUndefined(source[prop]);
+    });
+    options = utils.toFlatObject(
+      options,
+      {
+        maxRate: 0,
+        chunkSize: 64 * 1024,
+        minChunkSize: 100,
+        timeWindow: 500,
+        ticksRate: 2,
+        samplesCount: 15,
+      },
+      null,
+      (prop, source) => {
+        return !utils.isUndefined(source[prop]);
+      }
+    );
     super({
+      readableHighWaterMark: options.chunkSize
+      readableHighWaterMark: options.chunkSize,
     });
+    const internals = this[kInternals] = {
+    const internals = (this[kInternals] = {
       timeWindow: options.timeWindow,
       chunkSize: options.chunkSize,
       maxRate: options.maxRate,
       notifiedBytesLoaded: 0,
       ts: Date.now(),
       bytes: 0,
+      onReadCallback: null
+    };
+      onReadCallback: null,
+    });
+    this.on('newListener', event => {
+    this.on('newListener', (event) => {
       if (event === 'progress') {
         if (!internals.isCaptured) {
           internals.isCaptured = true;
     const timeWindow = internals.timeWindow;
     const divider = 1000 / timeWindow;
+    const bytesThreshold = (maxRate / divider);
+    const minChunkSize = internals.minChunkSize !== false ? Math.max(internals.minChunkSize, bytesThreshold * 0.01) : 0;
+    const bytesThreshold = maxRate / divider;
+    const minChunkSize =
+      internals.minChunkSize !== false
+        ? Math.max(internals.minChunkSize, bytesThreshold * 0.01)
+        : 0;
     const pushChunk = (_chunk, _callback) => {
       const bytes = Buffer.byteLength(_chunk);
           process.nextTick(_callback);
         };
+      }
+    }
+    };
     const transformChunk = (_chunk, _callback) => {
       const chunkSize = Buffer.byteLength(_chunk);
       if (maxRate) {
         const now = Date.now();
+        if (!internals.ts || (passed = (now - internals.ts)) >= timeWindow) {
+        if (!internals.ts || (passed = now - internals.ts) >= timeWindow) {
           internals.ts = now;
           bytesLeft = bytesThreshold - internals.bytes;
           internals.bytes = bytesLeft < 0 ? -bytesLeft : 0;
+        }
+      }
+      if (maxChunkSize && chunkSize > maxChunkSize && (chunkSize - maxChunkSize) > minChunkSize) {
+      if (maxChunkSize && chunkSize > maxChunkSize && chunkSize - maxChunkSize > minChunkSize) {
         chunkRemainder = _chunk.subarray(maxChunkSize);
         _chunk = _chunk.subarray(0, maxChunkSize);
+      }
+      pushChunk(_chunk, chunkRemainder ? () => {
+        process.nextTick(_callback, null, chunkRemainder);
+      } : _callback);
+      pushChunk(
+        _chunk,
+        chunkRemainder
+          ? () => {
+              process.nextTick(_callback, null, chunkRemainder);
+            }
+          : _callback
+      );
     };
     transformChunk(chunk, function transformNextChunk(err, _chunk) {

     ')': '%29',
     '~': '%7E',
     '%20': '+',
+    '%00': '\x00'
+    '%00': '\x00',
   };
   return encodeURIComponent(str).replace(/[!'()~]|%20|%00/g, function replacer(match) {
     return charMap[match];
 };
 prototype.toString = function toString(encoder) {
+  const _encode = encoder ? function(value) {
+    return encoder.call(this, value, encode);
+  } : 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]);
+  }, '').join('&');
+  return this._pairs
+    .map(function each(pair) {
+      return _encode(pair[0]) + '=' + _encode(pair[1]);
+    }, '')
+    .join('&');
 };
 export default AxiosURLSearchParams;

+'use strict'
+'use strict';
+export default typeof Blob !== 'undefined' ? Blob : null
+export default typeof Blob !== 'undefined' ? Blob : null;

  * @returns {string} The encoded value.
  */
 function encode(val) {
+  return encodeURIComponent(val).
+    replace(/%3A/gi, ':').
+    replace(/%24/g, '$').
+    replace(/%2C/gi, ',').
+    replace(/%20/g, '+');
+  return encodeURIComponent(val)
+    .replace(/%3A/gi, ':')
+    .replace(/%24/g, '$')
+    .replace(/%2C/gi, ',')
+    .replace(/%20/g, '+');
+}
 /**
     return url;
+  }
+  const _encode = options && options.encode || encode;
+  const _encode = (options && options.encode) || encode;
+  const _options = utils.isFunction(options) ? {
+    serialize: options
+  } : options;
+  const _options = utils.isFunction(options)
+    ? {
+        serialize: options,
+      }
+    : options;
   const serializeFn = _options && _options.serialize;
   if (serializeFn) {
     serializedParams = serializeFn(params, _options);
   } else {
+    serializedParams = utils.isURLSearchParams(params) ?
+      params.toString() :
+      new AxiosURLSearchParams(params, _options).toString(_encode);
+    serializedParams = utils.isURLSearchParams(params)
+      ? params.toString()
+      : new AxiosURLSearchParams(params, _options).toString(_encode);
+  }
   if (serializedParams) {
+    const hashmarkIndex = url.indexOf("#");
+    const hashmarkIndex = url.indexOf('#');
     if (hashmarkIndex !== -1) {
       url = url.slice(0, hashmarkIndex);

+import utils from "../utils.js";
+import utils from '../utils.js';
 const callbackify = (fn, reducer) => {
+  return utils.isAsyncFn(fn) ? function (...args) {
+    const cb = args.pop();
+    fn.apply(this, args).then((value) => {
+      try {
+        reducer ? cb(null, ...reducer(value)) : cb(null, value);
+      } catch (err) {
+        cb(err);
+  return utils.isAsyncFn(fn)
+    ? function (...args) {
+        const cb = args.pop();
+        fn.apply(this, args).then((value) => {
+          try {
+            reducer ? cb(null, ...reducer(value)) : cb(null, value);
+          } catch (err) {
+            cb(err);
+          }
+        }, cb);
+      }
+    }, cb);
+  } : fn;
+}
+    : fn;
+};
 export default callbackify;

     const token = this;
     // eslint-disable-next-line func-names
+    this.promise.then(cancel => {
+    this.promise.then((cancel) => {
       if (!token._listeners) return;
       let i = token._listeners.length;
     });
     // eslint-disable-next-line func-names
+    this.promise.then = onfulfilled => {
+    this.promise.then = (onfulfilled) => {
       let _resolve;
       // eslint-disable-next-line func-names
+      const promise = new Promise(resolve => {
+      const promise = new Promise((resolve) => {
         token.subscribe(resolve);
         _resolve = resolve;
       }).then(onfulfilled);
     });
     return {
       token,
+      cancel
+      cancel,
     };
+  }
+}

+import CanceledError from "../cancel/CanceledError.js";
+import AxiosError from "../core/AxiosError.js";
+import CanceledError from '../cancel/CanceledError.js';
+import AxiosError from '../core/AxiosError.js';
 import utils from '../utils.js';
 const composeSignals = (signals, timeout) => {
+  const {length} = (signals = signals ? signals.filter(Boolean) : []);
+  const { length } = (signals = signals ? signals.filter(Boolean) : []);
   if (timeout || length) {
     let controller = new AbortController();
         aborted = true;
         unsubscribe();
         const err = reason instanceof Error ? reason : this.reason;
+        controller.abort(err instanceof AxiosError ? err : new CanceledError(err instanceof Error ? err.message : err));
+        controller.abort(
+          err instanceof AxiosError
+            ? err
+            : new CanceledError(err instanceof Error ? err.message : err)
+        );
+      }
+    }
+    };
+    let timer = timeout && setTimeout(() => {
+      timer = null;
+      onabort(new AxiosError(`timeout of ${timeout}ms exceeded`, AxiosError.ETIMEDOUT))
+    }, timeout)
+    let timer =
+      timeout &&
+      setTimeout(() => {
+        timer = null;
+        onabort(new AxiosError(`timeout of ${timeout}ms exceeded`, AxiosError.ETIMEDOUT));
+      }, timeout);
     const unsubscribe = () => {
       if (signals) {
         timer && clearTimeout(timer);
         timer = null;
+        signals.forEach(signal => {
+          signal.unsubscribe ? signal.unsubscribe(onabort) : signal.removeEventListener('abort', onabort);
+        signals.forEach((signal) => {
+          signal.unsubscribe
+            ? signal.unsubscribe(onabort)
+            : signal.removeEventListener('abort', onabort);
         });
         signals = null;
+      }
+    }
+    };
     signals.forEach((signal) => signal.addEventListener('abort', onabort));
+    const {signal} = controller;
+    const { signal } = controller;
     signal.unsubscribe = () => utils.asap(unsubscribe);
     return signal;
+  }
+}
+};
 export default composeSignals;

 import utils from '../utils.js';
 import platform from '../platform/index.js';
+export default platform.hasStandardBrowserEnv ?
+export default platform.hasStandardBrowserEnv
+  ? // Standard browser envs support document.cookie
+    {
+      write(name, value, expires, path, domain, secure, sameSite) {
+        if (typeof document === 'undefined') return;
+  // Standard browser envs support document.cookie
+  {
+    write(name, value, expires, path, domain, secure, sameSite) {
+      if (typeof document === 'undefined') return;
+        const cookie = [`${name}=${encodeURIComponent(value)}`];
+      const cookie = [`${name}=${encodeURIComponent(value)}`];
+        if (utils.isNumber(expires)) {
+          cookie.push(`expires=${new Date(expires).toUTCString()}`);
+        }
+        if (utils.isString(path)) {
+          cookie.push(`path=${path}`);
+        }
+        if (utils.isString(domain)) {
+          cookie.push(`domain=${domain}`);
+        }
+        if (secure === true) {
+          cookie.push('secure');
+        }
+        if (utils.isString(sameSite)) {
+          cookie.push(`SameSite=${sameSite}`);
+        }
+      if (utils.isNumber(expires)) {
+        cookie.push(`expires=${new Date(expires).toUTCString()}`);
+      }
+      if (utils.isString(path)) {
+        cookie.push(`path=${path}`);
+      }
+      if (utils.isString(domain)) {
+        cookie.push(`domain=${domain}`);
+      }
+      if (secure === true) {
+        cookie.push('secure');
+      }
+      if (utils.isString(sameSite)) {
+        cookie.push(`SameSite=${sameSite}`);
+      }
+        document.cookie = cookie.join('; ');
+      },
+      document.cookie = cookie.join('; ');
+    },
+      read(name) {
+        if (typeof document === 'undefined') return null;
+        const match = document.cookie.match(new RegExp('(?:^|; )' + name + '=([^;]*)'));
+        return match ? decodeURIComponent(match[1]) : null;
+      },
+    read(name) {
+      if (typeof document === 'undefined') return null;
+      const match = document.cookie.match(new RegExp('(?:^|; )' + name + '=([^;]*)'));
+      return match ? decodeURIComponent(match[1]) : null;
+    },
+    remove(name) {
+      this.write(name, '', Date.now() - 86400000, '/');
+      remove(name) {
+        this.write(name, '', Date.now() - 86400000, '/');
+      },
+    }
+  }
+  :
+  // Non-standard browser env (web workers, react-native) lack needed support.
+  {
+    write() {},
+    read() {
+      return null;
+    },
+    remove() {}
+  };
+  : // Non-standard browser env (web workers, react-native) lack needed support.
+    {
+      write() {},
+      read() {
+        return null;
+      },
+      remove() {},
+    };

@@ -1,1 +1,1 @@
1		export const VERSION = "1.13.5";
	1	export const VERSION = "1.13.6";

 export default function deprecatedMethod(method, instead, docs) {
   try {
     console.warn(
+      'DEPRECATED method `' + method + '`.' +
+      (instead ? ' Use `' + instead + '` instead.' : '') +
+      ' This method will be removed in a future release.');
+      'DEPRECATED method `' +
+        method +
+        '`.' +
+        (instead ? ' Use `' + instead + '` instead.' : '') +
+        ' This method will be removed in a future release.'
+    );
     if (docs) {
       console.warn('For more information about usage see ' + docs);
+    }
+  } catch (e) { /* Ignore */ }
+  } catch (e) {
+    /* Ignore */
+  }
+}

 import defaults from '../defaults/index.js';
 import CanceledError from '../cancel/CanceledError.js';
 import AxiosHeaders from '../core/AxiosHeaders.js';
+import adapters from "../adapters/adapters.js";
+import adapters from '../adapters/adapters.js';
 /**
  * Throws a `CanceledError` if cancellation has been requested.
   config.headers = AxiosHeaders.from(config.headers);
   // Transform request data
+  config.data = transformData.call(
+    config,
+    config.transformRequest
+  );
+  config.data = transformData.call(config, config.transformRequest);
   if (['post', 'put', 'patch'].indexOf(config.method) !== -1) {
     config.headers.setContentType('application/x-www-form-urlencoded', false);
   const adapter = adapters.getAdapter(config.adapter || defaults.adapter, config);
+  return adapter(config).then(function onAdapterResolution(response) {
+    throwIfCancellationRequested(config);
+  return adapter(config).then(
+    function onAdapterResolution(response) {
+      throwIfCancellationRequested(config);
+    // Transform response data
+    response.data = transformData.call(
+      config,
+      config.transformResponse,
+      response
+    );
+      // Transform response data
+      response.data = transformData.call(config, config.transformResponse, response);
+    response.headers = AxiosHeaders.from(response.headers);
+      response.headers = AxiosHeaders.from(response.headers);
+    return response;
+  }, function onAdapterRejection(reason) {
+    if (!isCancel(reason)) {
+      throwIfCancellationRequested(config);
+      return response;
+    },
+    function onAdapterRejection(reason) {
+      if (!isCancel(reason)) {
+        throwIfCancellationRequested(config);
+      // 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);
+        // 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);
+        }
+      }
+      return Promise.reject(reason);
+    }
+    return Promise.reject(reason);
+  });
+  );
+}

   // foo.x.y.z
   // foo-x-y-z
   // foo x y z
+  return utils.matchAll(/\w+|\[(\w*)]/g, name).map(match => {
+  return utils.matchAll(/\w+|\[(\w*)]/g, name).map((match) => {
     return match[0] === '[]' ? '' : match[1] || match[0];
   });
+}

@@ -17,4 +17,3 @@
17	17
18	18	return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
19	19	}
20

 import util from 'util';
+import {Readable} from 'stream';
+import utils from "../utils.js";
+import readBlob from "./readBlob.js";
+import platform from "../platform/index.js";
+import { Readable } from 'stream';
+import utils from '../utils.js';
+import readBlob from './readBlob.js';
+import platform from '../platform/index.js';
 const BOUNDARY_ALPHABET = platform.ALPHABET.ALPHA_DIGIT + '-_';
 class FormDataPart {
   constructor(name, value) {
+    const {escapeName} = this.constructor;
+    const { escapeName } = this.constructor;
     const isStringValue = utils.isString(value);
     let headers = `Content-Disposition: form-data; name="${escapeName(name)}"${
     if (isStringValue) {
       value = textEncoder.encode(String(value).replace(/\r?\n|\r\n?/g, CRLF));
     } else {
+      headers += `Content-Type: ${value.type || "application/octet-stream"}${CRLF}`
+      headers += `Content-Type: ${value.type || 'application/octet-stream'}${CRLF}`;
+    }
     this.headers = textEncoder.encode(headers + CRLF);
     this.value = value;
+  }
+  async *encode(){
+  async *encode() {
     yield this.headers;
+    const {value} = this;
+    const { value } = this;
+    if(utils.isTypedArray(value)) {
+    if (utils.isTypedArray(value)) {
       yield value;
     } else {
       yield* readBlob(value);
+  }
   static escapeName(name) {
+      return String(name).replace(/[\r\n"]/g, (match) => ({
+        '\r' : '%0D',
+        '\n' : '%0A',
+        '"' : '%22',
+      }[match]));
+    return String(name).replace(
+      /[\r\n"]/g,
+      (match) =>
+        ({
+          '\r': '%0D',
+          '\n': '%0A',
+          '"': '%22',
+        })[match]
+    );
+  }
+}
   const {
     tag = 'form-data-boundary',
     size = 25,
+    boundary = tag + '-' + platform.generateString(size, BOUNDARY_ALPHABET)
+    boundary = tag + '-' + platform.generateString(size, BOUNDARY_ALPHABET),
   } = options || {};
+  if(!utils.isFormData(form)) {
+  if (!utils.isFormData(form)) {
     throw TypeError('FormData instance required');
+  }
   if (boundary.length < 1 || boundary.length > 70) {
+    throw Error('boundary must be 10-70 characters long')
+    throw Error('boundary must be 10-70 characters long');
+  }
   const boundaryBytes = textEncoder.encode('--' + boundary + CRLF);
   contentLength = utils.toFiniteNumber(contentLength);
   const computedHeaders = {
+    'Content-Type': `multipart/form-data; boundary=${boundary}`
+  }
+    'Content-Type': `multipart/form-data; boundary=${boundary}`,
+  };
   if (Number.isFinite(contentLength)) {
     computedHeaders['Content-Length'] = contentLength;
   headersHandler && headersHandler(computedHeaders);
+  return Readable.from((async function *() {
+    for(const part of parts) {
+      yield boundaryBytes;
+      yield* part.encode();
+    }
+  return Readable.from(
+    (async function* () {
+      for (const part of parts) {
+        yield boundaryBytes;
+        yield* part.encode();
+      }
+    yield footerBytes;
+  })());
+      yield footerBytes;
+    })()
+  );
 };
 export default formDataToStream;

  * @returns {Buffer|Blob}
  */
 export default function fromDataURI(uri, asBlob, options) {
+  const _Blob = options && options.Blob || platform.classes.Blob;
+  const _Blob = (options && options.Blob) || platform.classes.Blob;
   const protocol = parseProtocol(uri);
   if (asBlob === undefined && _Blob) {
         throw new AxiosError('Blob is not supported', AxiosError.ERR_NOT_SUPPORT);
+      }
+      return new _Blob([buffer], {type: mime});
+      return new _Blob([buffer], { type: mime });
+    }
     return buffer;

   HttpStatusCode,
   formToJSON,
   getAdapter,
+  mergeConfig
+  mergeConfig,
 } = axios;
 export {
   HttpStatusCode,
   formToJSON,
   getAdapter,
+  mergeConfig
+}
+  mergeConfig,
+};

+import URLSearchParams from './classes/URLSearchParams.js'
+import FormData from './classes/FormData.js'
+import Blob from './classes/Blob.js'
+import URLSearchParams from './classes/URLSearchParams.js';
+import FormData from './classes/FormData.js';
+import Blob from './classes/Blob.js';
 export default {
   isBrowser: true,
   classes: {
     URLSearchParams,
     FormData,
+    Blob
+    Blob,
   },
+  protocols: ['http', 'https', 'file', 'blob', 'url', 'data']
+  protocols: ['http', 'https', 'file', 'blob', 'url', 'data'],
 };

 export default {
   ...utils,
+  ...platform
+}
+  ...platform,
+};

 import crypto from 'crypto';
+import URLSearchParams from './classes/URLSearchParams.js'
+import FormData from './classes/FormData.js'
+import URLSearchParams from './classes/URLSearchParams.js';
+import FormData from './classes/FormData.js';
+const ALPHA = 'abcdefghijklmnopqrstuvwxyz'
+const ALPHA = 'abcdefghijklmnopqrstuvwxyz';
 const DIGIT = '0123456789';
 const ALPHABET = {
   DIGIT,
   ALPHA,
+  ALPHA_DIGIT: ALPHA + ALPHA.toUpperCase() + DIGIT
+}
+  ALPHA_DIGIT: ALPHA + ALPHA.toUpperCase() + DIGIT,
+};
 const generateString = (size = 16, alphabet = ALPHABET.ALPHA_DIGIT) => {
   let str = '';
+  const {length} = alphabet;
+  const { length } = alphabet;
   const randomValues = new Uint32Array(size);
   crypto.randomFillSync(randomValues);
   for (let i = 0; i < size; i++) {
+  }
   return str;
+}
+};
 export default {
   isNode: true,
   classes: {
     URLSearchParams,
     FormData,
+    Blob: typeof Blob !== 'undefined' && Blob || null
+    Blob: (typeof Blob !== 'undefined' && Blob) || null,
   },
   ALPHABET,
   generateString,
+  protocols: [ 'http', 'https', 'file', 'data' ]
+  protocols: ['http', 'https', 'file', 'data'],
 };

       fulfilled,
       rejected,
       synchronous: options ? options.synchronous : false,
+      runWhen: options ? options.runWhen : null
+      runWhen: options ? options.runWhen : null,
     });
     return this.handlers.length - 1;
+  }

  * @returns {boolean} True if the payload is an error thrown by Axios, otherwise false
  */
 export default function isAxiosError(payload) {
+  return utils.isObject(payload) && (payload.isAxiosError === true);
+  return utils.isObject(payload) && payload.isAxiosError === true;
+}

 import platform from '../platform/index.js';
+export default platform.hasStandardBrowserEnv ? ((origin, isMSIE) => (url) => {
+  url = new URL(url, platform.origin);
+export default platform.hasStandardBrowserEnv
+  ? ((origin, isMSIE) => (url) => {
+      url = new URL(url, platform.origin);
+  return (
+    origin.protocol === url.protocol &&
+    origin.host === url.host &&
+    (isMSIE || origin.port === url.port)
+  );
+})(
+  new URL(platform.origin),
+  platform.navigator && /(msie|trident)/i.test(platform.navigator.userAgent)
+) : () => true;
+      return (
+        origin.protocol === url.protocol &&
+        origin.host === url.host &&
+        (isMSIE || origin.port === url.port)
+      );
+    })(
+      new URL(platform.origin),
+      platform.navigator && /(msie|trident)/i.test(platform.navigator.userAgent)
+    )
+  : () => true;

+"use strict";
+'use strict';
+import utils from "../utils.js";
+import AxiosHeaders from "./AxiosHeaders.js";
+import utils from '../utils.js';
+import AxiosHeaders from './AxiosHeaders.js';
+const headersToObject = (thing) =>
+  thing instanceof AxiosHeaders ? { ...thing } : thing;
+const headersToObject = (thing) => (thing instanceof AxiosHeaders ? { ...thing } : thing);
 /**
  * Config-specific merge-function which creates a new config-object
       mergeDeepProperties(headersToObject(a), headersToObject(b), prop, true),
   };
+  utils.forEach(
+    Object.keys({ ...config1, ...config2 }),
+    function computeConfigValue(prop) {
+      if (
+        prop === "__proto__" ||
+        prop === "constructor" ||
+        prop === "prototype"
+      )
+        return;
+      const merge = utils.hasOwnProp(mergeMap, prop)
+        ? mergeMap[prop]
+        : mergeDeepProperties;
+      const configValue = merge(config1[prop], config2[prop], prop);
+      (utils.isUndefined(configValue) && merge !== mergeDirectKeys) ||
+        (config[prop] = configValue);
+    },
+  );
+  utils.forEach(Object.keys({ ...config1, ...config2 }), function computeConfigValue(prop) {
+    if (prop === '__proto__' || prop === 'constructor' || prop === 'prototype') return;
+    const merge = utils.hasOwnProp(mergeMap, prop) ? mergeMap[prop] : mergeDeepProperties;
+    const configValue = merge(config1[prop], config2[prop], prop);
+    (utils.isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue);
+  });
   return config;
+}

Comparingaxios@1.13.5

Comparingaxios@1.13.5

Source

Source

npm diff

Options

Bundlephobia

Bundlephobia

Packagephobia

Packagephobia

+++0---0

Packagephobia

Bundlephobia

dist/browser/axios.cjs +++1007---747

dist/node/axios.cjs +++1660---1332

index.d.cts +++231---106

lib/adapters/adapters.js +++18---14

dist/axios.js +++161---51

dist/esm/axios.js +++1008---748

lib/axios.js +++6---6

lib/core/Axios.js +++57---43

lib/core/AxiosError.js +++52---35

lib/core/AxiosHeaders.js +++54---24

lib/helpers/AxiosTransformStream.js +++37---24

lib/helpers/AxiosURLSearchParams.js +++11---7

lib/platform/browser/classes/Blob.js +++2---2

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

lib/helpers/callbackify.js +++13---11

lib/cancel/CancelToken.js +++4---4

lib/helpers/composeSignals.js +++22---14

lib/helpers/cookies.js +++39---44

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

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

lib/core/dispatchRequest.js +++25---29

lib/adapters/fetch.js +++133---87

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

lib/helpers/formDataToStream.js +++32---26

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

lib/adapters/http.js +++589---538

index.js +++3---3

lib/defaults/index.js +++83---72

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

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

lib/platform/node/index.js +++9---10

lib/core/InterceptorManager.js +++1---1

lib/helpers/isAbsoluteURL.js +++0---1

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

lib/helpers/isURLSameOrigin.js +++13---11

lib/core/mergeConfig.js +++10---22

lib/helpers/parseHeaders.js +++34---20

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

lib/helpers/progressEventReducer.js +++21---14

lib/helpers/readBlob.js +++4---4

lib/helpers/resolveConfig.js +++23---14

lib/core/settle.js +++11---7

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

lib/helpers/throttle.js +++4---4

lib/helpers/toFormData.js +++43---25

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

lib/helpers/trackStream.js +++33---31

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

lib/platform/common/utils.js +++6---5

lib/utils.js +++149---93

lib/helpers/validator.js +++16---5

lib/adapters/xhr.js +++178---156

lib/helpers/ZlibHeaderTransformStream.js +++5---4

package.json +++10---4

CHANGELOG.md +++206---206

lib/adapters/README.md +++4---5

Source

Source

Comparing
`axios@1.13.5`

Comparing
`axios@1.13.5`

 // RawAxiosHeaders whose duplicates are ignored by node
 // c.f. https://nodejs.org/api/http.html#http_message_headers
 const 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'
+  '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',
 ]);
 /**
+ *
  * @returns {Object} Headers parsed into an object
  */
+export default rawHeaders => {
+export default (rawHeaders) => {
   const parsed = {};
   let key;
   let val;
   let i;
+  rawHeaders && rawHeaders.split('\n').forEach(function parser(line) {
+    i = line.indexOf(':');
+    key = line.substring(0, i).trim().toLowerCase();
+    val = line.substring(i + 1).trim();
+  rawHeaders &&
+    rawHeaders.split('\n').forEach(function parser(line) {
+      i = line.indexOf(':');
+      key = line.substring(0, i).trim().toLowerCase();
+      val = line.substring(i + 1).trim();
+    if (!key || (parsed[key] && ignoreDuplicateOf[key])) {
+      return;
+    }
+      if (!key || (parsed[key] && ignoreDuplicateOf[key])) {
+        return;
+      }
+    if (key === 'set-cookie') {
+      if (parsed[key]) {
+        parsed[key].push(val);
+      if (key === 'set-cookie') {
+        if (parsed[key]) {
+          parsed[key].push(val);
+        } else {
+          parsed[key] = [val];
+        }
       } else {
+        parsed[key] = [val];
+        parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
+      }
+    } else {
+      parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
+    }
+  });
+    });
   return parsed;
 };

 export default function parseProtocol(url) {
   const match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url);
+  return match && match[1] || '';
+  return (match && match[1]) || '';
+}

+import speedometer from "./speedometer.js";
+import throttle from "./throttle.js";
+import utils from "../utils.js";
+import speedometer from './speedometer.js';
+import throttle from './throttle.js';
+import utils from '../utils.js';
 export const progressEventReducer = (listener, isDownloadStream, freq = 3) => {
   let bytesNotified = 0;
   const _speedometer = speedometer(50, 250);
+  return throttle(e => {
+  return throttle((e) => {
     const loaded = e.loaded;
     const total = e.lengthComputable ? e.total : undefined;
     const progressBytes = loaded - bytesNotified;
     const data = {
       loaded,
       total,
+      progress: total ? (loaded / total) : undefined,
+      progress: total ? loaded / total : undefined,
       bytes: progressBytes,
       rate: rate ? rate : undefined,
       estimated: rate && total && inRange ? (total - loaded) / rate : undefined,
       event: e,
       lengthComputable: total != null,
+      [isDownloadStream ? 'download' : 'upload']: true
+      [isDownloadStream ? 'download' : 'upload']: true,
     };
     listener(data);
   }, freq);
+}
+};
 export const progressEventDecorator = (total, throttled) => {
   const lengthComputable = total != null;
+  return [(loaded) => throttled[0]({
+    lengthComputable,
+    total,
+    loaded
+  }), throttled[1]];
+}
+  return [
+    (loaded) =>
+      throttled[0]({
+        lengthComputable,
+        total,
+        loaded,
+      }),
+    throttled[1],
+  ];
+};
+export const asyncDecorator = (fn) => (...args) => utils.asap(() => fn(...args));
+export const asyncDecorator =
+  (fn) =>
+  (...args) =>
+    utils.asap(() => fn(...args));

+const {asyncIterator} = Symbol;
+const { asyncIterator } = Symbol;
 const readBlob = async function* (blob) {
   if (blob.stream) {
+    yield* blob.stream()
+    yield* blob.stream();
   } else if (blob.arrayBuffer) {
+    yield await blob.arrayBuffer()
+    yield await blob.arrayBuffer();
   } else if (blob[asyncIterator]) {
     yield* blob[asyncIterator]();
   } else {
     yield blob;
+  }
+}
+};
 export default readBlob;

+import platform from "../platform/index.js";
+import utils from "../utils.js";
+import isURLSameOrigin from "./isURLSameOrigin.js";
+import cookies from "./cookies.js";
+import buildFullPath from "../core/buildFullPath.js";
+import mergeConfig from "../core/mergeConfig.js";
+import AxiosHeaders from "../core/AxiosHeaders.js";
+import buildURL from "./buildURL.js";
+import platform from '../platform/index.js';
+import utils from '../utils.js';
+import isURLSameOrigin from './isURLSameOrigin.js';
+import cookies from './cookies.js';
+import buildFullPath from '../core/buildFullPath.js';
+import mergeConfig from '../core/mergeConfig.js';
+import AxiosHeaders from '../core/AxiosHeaders.js';
+import buildURL from './buildURL.js';
 export default (config) => {
   const newConfig = mergeConfig({}, config);
   newConfig.headers = headers = AxiosHeaders.from(headers);
+  newConfig.url = buildURL(buildFullPath(newConfig.baseURL, newConfig.url, newConfig.allowAbsoluteUrls), config.params, config.paramsSerializer);
+  newConfig.url = buildURL(
+    buildFullPath(newConfig.baseURL, newConfig.url, newConfig.allowAbsoluteUrls),
+    config.params,
+    config.paramsSerializer
+  );
   // HTTP basic authentication
   if (auth) {
+    headers.set('Authorization', 'Basic ' +
+      btoa((auth.username || '') + ':' + (auth.password ? unescape(encodeURIComponent(auth.password)) : ''))
+    headers.set(
+      'Authorization',
+      'Basic ' +
+        btoa(
+          (auth.username || '') +
+            ':' +
+            (auth.password ? unescape(encodeURIComponent(auth.password)) : '')
+        )
     );
+  }
+        }
       });
+    }
+  }
+  }
   // Add xsrf header
   // This is only done if running in a standard browser environment.
+  }
   return newConfig;
+}
+};

   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
+    ));
+    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
+      )
+    );
+  }
+}

     const passed = startedAt && now - startedAt;
+    return passed ? Math.round(bytesCount * 1000 / passed) : undefined;
+    return passed ? Math.round((bytesCount * 1000) / passed) : undefined;
   };
+}

       timer = null;
+    }
     fn(...args);
+  }
+  };
   const throttled = (...args) => {
     const now = Date.now();
     const passed = now - timestamp;
+    if ( passed >= threshold) {
+    if (passed >= threshold) {
       invoke(args, now);
     } else {
       lastArgs = args;
       if (!timer) {
         timer = setTimeout(() => {
           timer = null;
+          invoke(lastArgs)
+          invoke(lastArgs);
         }, threshold - passed);
+      }
+    }
+  }
+  };
   const flush = () => lastArgs && invoke(lastArgs);

  */
 function renderKey(path, key, dots) {
   if (!path) return key;
+  return path.concat(key).map(function each(token, i) {
+    // eslint-disable-next-line no-param-reassign
+    token = removeBrackets(token);
+    return !dots && i ? '[' + token + ']' : token;
+  }).join(dots ? '.' : '');
+  return path
+    .concat(key)
+    .map(function each(token, i) {
+      // eslint-disable-next-line no-param-reassign
+      token = removeBrackets(token);
+      return !dots && i ? '[' + token + ']' : token;
+    })
+    .join(dots ? '.' : '');
+}
 /**
   formData = formData || new (PlatformFormData || FormData)();
   // eslint-disable-next-line no-param-reassign
+  options = utils.toFlatObject(options, {
+    metaTokens: true,
+    dots: false,
+    indexes: false
+  }, false, function defined(option, source) {
+    // eslint-disable-next-line no-eq-null,eqeqeq
+    return !utils.isUndefined(source[option]);
+  });
+  options = utils.toFlatObject(
+    options,
+    {
+      metaTokens: true,
+      dots: false,
+      indexes: false,
+    },
+    false,
+    function defined(option, source) {
+      // eslint-disable-next-line no-eq-null,eqeqeq
+      return !utils.isUndefined(source[option]);
+    }
+  );
   const metaTokens = options.metaTokens;
   // eslint-disable-next-line no-use-before-define
   const visitor = options.visitor || defaultVisitor;
   const dots = options.dots;
   const indexes = options.indexes;
+  const _Blob = options.Blob || typeof Blob !== 'undefined' && Blob;
+  const _Blob = options.Blob || (typeof Blob !== 'undefined' && Blob);
   const useBlob = _Blob && utils.isSpecCompliantForm(formData);
   if (!utils.isFunction(visitor)) {
   function defaultVisitor(value, key, path) {
     let arr = value;
+    if (utils.isReactNative(formData) && utils.isReactNativeBlob(value)) {
+      formData.append(renderKey(path, key, dots), convertValue(value));
+      return false;
+    }
     if (value && !path && typeof value === 'object') {
       if (utils.endsWith(key, '{}')) {
         // 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))
+        )) {
+        ((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) {
+          !(utils.isUndefined(el) || el === null) && formData.append(
+            // eslint-disable-next-line no-nested-ternary
+            indexes === true ? renderKey([key], index, dots) : (indexes === null ? key : key + '[]'),
+            convertValue(el)
+          );
+          !(utils.isUndefined(el) || el === null) &&
+            formData.append(
+              // eslint-disable-next-line no-nested-ternary
+              indexes === true
+                ? renderKey([key], index, dots)
+                : indexes === null
+                  ? key
+                  : key + '[]',
+              convertValue(el)
+            );
         });
         return false;
+      }
   const exposedHelpers = Object.assign(predicates, {
     defaultVisitor,
     convertValue,
+    isVisitable
+    isVisitable,
   });
   function build(value, path) {
     stack.push(value);
     utils.forEach(value, function each(el, key) {
+      const result = !(utils.isUndefined(el) || el === null) && visitor.call(
+        formData, el, utils.isString(key) ? key.trim() : key, path, exposedHelpers
+      );
+      const result =
+        !(utils.isUndefined(el) || el === null) &&
+        visitor.call(formData, el, utils.isString(key) ? key.trim() : key, path, exposedHelpers);
       if (result === true) {
         build(el, path ? path.concat(key) : [key]);

 export default function toURLEncodedForm(data, options) {
   return toFormData(data, new platform.classes.URLSearchParams(), {
+    visitor: function(value, key, path, helpers) {
+    visitor: function (value, key, path, helpers) {
       if (platform.isNode && utils.isBuffer(value)) {
         this.append(key, value.toString('base64'));
         return false;
       return helpers.defaultVisitor.apply(this, arguments);
     },
+    ...options
+    ...options,
   });
+}