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';
 /**
  * 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;
 /**
  * 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)
+    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])) :
+    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,
 };

 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);
+  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 {
   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,
     });
+    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) => {
       if (event === 'progress') {
         if (!internals.isCaptured) {
           internals.isCaptured = true;
     const timeWindow = internals.timeWindow;
     const divider = 1000 / timeWindow;
+    const bytesThreshold = (maxRate / divider);
+    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) {
           internals.ts = now;
           bytesLeft = bytesThreshold - internals.bytes;
           internals.bytes = bytesLeft < 0 ? -bytesLeft : 0;
+        }
+      }
+      if (maxChunkSize && chunkSize > maxChunkSize && chunkSize - maxChunkSize > minChunkSize) {
         chunkRemainder = _chunk.subarray(maxChunkSize);
         _chunk = _chunk.subarray(0, maxChunkSize);
+      }
+      pushChunk(_chunk, chunkRemainder ? () => {
+        process.nextTick(_callback, null, chunkRemainder);
+      pushChunk(
+        _chunk,
+        chunkRemainder
+          ? () => {
+              process.nextTick(_callback, null, chunkRemainder);
+            }
+          : _callback
+      );
     };
     transformChunk(chunk, function transformNextChunk(err, _chunk) {

     ')': '%29',
     '~': '%7E',
     '%20': '+',
+    '%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);
+  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;

@@ -9,12 +9,12 @@
9	import CanceledError from './cancel/CanceledError.js';	9	import CanceledError from './cancel/CanceledError.js';
10	import CancelToken from './cancel/CancelToken.js';	10	import CancelToken from './cancel/CancelToken.js';
11	import isCancel from './cancel/isCancel.js';	11	import isCancel from './cancel/isCancel.js';
12	import {VERSION} from './env/data.js';	12	import { VERSION } from './env/data.js';
13	import toFormData from './helpers/toFormData.js';	13	import toFormData from './helpers/toFormData.js';
14	import AxiosError from './core/AxiosError.js';	14	import AxiosError from './core/AxiosError.js';
15	import spread from './helpers/spread.js';	15	import spread from './helpers/spread.js';
16	import isAxiosError from './helpers/isAxiosError.js';	16	import isAxiosError from './helpers/isAxiosError.js';
17	import AxiosHeaders from "./core/AxiosHeaders.js";	17	import AxiosHeaders from './core/AxiosHeaders.js';
18	import adapters from './adapters/adapters.js';	18	import adapters from './adapters/adapters.js';
19	import HttpStatusCode from './helpers/HttpStatusCode.js';	19	import HttpStatusCode from './helpers/HttpStatusCode.js';
20		20
@@ -30,10 +30,10 @@
30	const instance = bind(Axios.prototype.request, context);	30	const instance = bind(Axios.prototype.request, context);
31		31
32	// Copy axios.prototype to instance	32	// Copy axios.prototype to instance
33	utils.extend(instance, Axios.prototype, context, {allOwnKeys: true});	33	utils.extend(instance, Axios.prototype, context, { allOwnKeys: true });
34		34
35	// Copy context to instance	35	// Copy context to instance
36	utils.extend(instance, context, null, {allOwnKeys: true});	36	utils.extend(instance, context, null, { allOwnKeys: true });
37		37
38	// Factory for creating new instances	38	// Factory for creating new instances
39	instance.create = function create(instanceConfig) {	39	instance.create = function create(instanceConfig) {
@@ -77,7 +77,7 @@
77		77
78	axios.AxiosHeaders = AxiosHeaders;	78	axios.AxiosHeaders = AxiosHeaders;
79		79
80	axios.formToJSON = thing => formDataToJSON(utils.isHTMLForm(thing) ? new FormData(thing) : thing);	80	axios.formToJSON = (thing) => formDataToJSON(utils.isHTMLForm(thing) ? new FormData(thing) : thing);
81		81
82	axios.getAdapter = adapters.getAdapter;	82	axios.getAdapter = adapters.getAdapter;
83		83
@@ -86,4 +86,4 @@
86	axios.default = axios;	86	axios.default = axios;
87		87
88	// this module should only have a default export	88	// this module should only have a default export
89	export default axios	89	export default axios;

@@ -1,3 +1,3 @@
1	'use strict'	1	'use strict';
2		2
3	export default typeof Blob !== 'undefined' ? Blob : null	3	export default typeof Blob !== 'undefined' ? Blob : null;

@@ -12,11 +12,11 @@
12	* @returns {string} The encoded value.	12	* @returns {string} The encoded value.
13	*/	13	*/
14	function encode(val) {	14	function encode(val) {
15	return encodeURIComponent(val).
16	replace(/%3A/gi, ':').
17	replace(/%24/g, '$').
18	replace(/%2C/gi, ',').
19	replace(/%20/g, '+');	15	return encodeURIComponent(val)
		16	.replace(/%3A/gi, ':')
		17	.replace(/%24/g, '$')
		18	.replace(/%2C/gi, ',')
		19	.replace(/%20/g, '+');
20	}	20	}
21		21
22	/**	22	/**
@@ -33,11 +33,13 @@
33	return url;	33	return url;
34	}	34	}
35		35
36	const _encode = options && options.encode \|\| encode;	36	const _encode = (options && options.encode) \|\| encode;
37		37
38	const _options = utils.isFunction(options) ? {
39	serialize: options
40	} : options;	38	const _options = utils.isFunction(options)
		39	? {
		40	serialize: options,
		41	}
		42	: options;
41		43
42	const serializeFn = _options && _options.serialize;	44	const serializeFn = _options && _options.serialize;
43		45
@@ -46,13 +48,13 @@
46	if (serializeFn) {	48	if (serializeFn) {
47	serializedParams = serializeFn(params, _options);	49	serializedParams = serializeFn(params, _options);
48	} else {	50	} else {
49	serializedParams = utils.isURLSearchParams(params) ?
50	params.toString() :
51	new AxiosURLSearchParams(params, _options).toString(_encode);	51	serializedParams = utils.isURLSearchParams(params)
		52	? params.toString()
		53	: new AxiosURLSearchParams(params, _options).toString(_encode);
52	}	54	}
53		55
54	if (serializedParams) {	56	if (serializedParams) {
55	const hashmarkIndex = url.indexOf("#");	57	const hashmarkIndex = url.indexOf('#');
56		58
57	if (hashmarkIndex !== -1) {	59	if (hashmarkIndex !== -1) {
58	url = url.slice(0, hashmarkIndex);	60	url = url.slice(0, hashmarkIndex);

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

@@ -24,7 +24,7 @@
24	const token = this;	24	const token = this;
25		25
26	// eslint-disable-next-line func-names	26	// eslint-disable-next-line func-names
27	this.promise.then(cancel => {	27	this.promise.then((cancel) => {
28	if (!token._listeners) return;	28	if (!token._listeners) return;
29		29
30	let i = token._listeners.length;	30	let i = token._listeners.length;
@@ -36,10 +36,10 @@
36	});	36	});
37		37
38	// eslint-disable-next-line func-names	38	// eslint-disable-next-line func-names
39	this.promise.then = onfulfilled => {	39	this.promise.then = (onfulfilled) => {
40	let _resolve;	40	let _resolve;
41	// eslint-disable-next-line func-names	41	// eslint-disable-next-line func-names
42	const promise = new Promise(resolve => {	42	const promise = new Promise((resolve) => {
43	token.subscribe(resolve);	43	token.subscribe(resolve);
44	_resolve = resolve;	44	_resolve = resolve;
45	}).then(onfulfilled);	45	}).then(onfulfilled);
@@ -127,7 +127,7 @@
127	});	127	});
128	return {	128	return {
129	token,	129	token,
130	cancel	130	cancel,
131	};	131	};
132	}	132	}
133	}	133	}

@@ -1,9 +1,9 @@
1	import CanceledError from "../cancel/CanceledError.js";
2	import AxiosError from "../core/AxiosError.js";	1	import CanceledError from '../cancel/CanceledError.js';
		2	import AxiosError from '../core/AxiosError.js';
3	import utils from '../utils.js';	3	import utils from '../utils.js';
4		4
5	const composeSignals = (signals, timeout) => {	5	const composeSignals = (signals, timeout) => {
6	const {length} = (signals = signals ? signals.filter(Boolean) : []);	6	const { length } = (signals = signals ? signals.filter(Boolean) : []);
7		7
8	if (timeout \|\| length) {	8	if (timeout \|\| length) {
9	let controller = new AbortController();	9	let controller = new AbortController();
@@ -15,34 +15,42 @@
15	aborted = true;	15	aborted = true;
16	unsubscribe();	16	unsubscribe();
17	const err = reason instanceof Error ? reason : this.reason;	17	const err = reason instanceof Error ? reason : this.reason;
18	controller.abort(err instanceof AxiosError ? err : new CanceledError(err instanceof Error ? err.message : err));	18	controller.abort(
		19	err instanceof AxiosError
		20	? err
		21	: new CanceledError(err instanceof Error ? err.message : err)
		22	);
19	}	23	}
20	}	24	};
21		25
22	let timer = timeout && setTimeout(() => {
23	timer = null;
24	onabort(new AxiosError(`timeout of ${timeout}ms exceeded`, AxiosError.ETIMEDOUT))
25	}, timeout)	26	let timer =
		27	timeout &&
		28	setTimeout(() => {
		29	timer = null;
		30	onabort(new AxiosError(`timeout of ${timeout}ms exceeded`, AxiosError.ETIMEDOUT));
		31	}, timeout);
26		32
27	const unsubscribe = () => {	33	const unsubscribe = () => {
28	if (signals) {	34	if (signals) {
29	timer && clearTimeout(timer);	35	timer && clearTimeout(timer);
30	timer = null;	36	timer = null;
31	signals.forEach(signal => {
32	signal.unsubscribe ? signal.unsubscribe(onabort) : signal.removeEventListener('abort', onabort);	37	signals.forEach((signal) => {
		38	signal.unsubscribe
		39	? signal.unsubscribe(onabort)
		40	: signal.removeEventListener('abort', onabort);
33	});	41	});
34	signals = null;	42	signals = null;
35	}	43	}
36	}	44	};
37		45
38	signals.forEach((signal) => signal.addEventListener('abort', onabort));	46	signals.forEach((signal) => signal.addEventListener('abort', onabort));
39		47
40	const {signal} = controller;	48	const { signal } = controller;
41		49
42	signal.unsubscribe = () => utils.asap(unsubscribe);	50	signal.unsubscribe = () => utils.asap(unsubscribe);
43		51
44	return signal;	52	return signal;
45	}	53	}
46	}	54	};
47		55
48	export default composeSignals;	56	export default composeSignals;

 import utils from '../utils.js';
 import platform from '../platform/index.js';
+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) {
+        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) {
+      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";

@@ -15,12 +15,17 @@
15	export default function deprecatedMethod(method, instead, docs) {	15	export default function deprecatedMethod(method, instead, docs) {
16	try {	16	try {
17	console.warn(	17	console.warn(
18	'DEPRECATED method `' + method + '`.' +
19	(instead ? ' Use `' + instead + '` instead.' : '') +
20	' This method will be removed in a future release.');	18	'DEPRECATED method `' +
		19	method +
		20	'`.' +
		21	(instead ? ' Use `' + instead + '` instead.' : '') +
		22	' This method will be removed in a future release.'
		23	);
21		24
22	if (docs) {	25	if (docs) {
23	console.warn('For more information about usage see ' + docs);	26	console.warn('For more information about usage see ' + docs);
24	}	27	}
25	} catch (e) { /* Ignore */ }	28	} catch (e) {
		29	/* Ignore */
		30	}
26	}	31	}

 import defaults from '../defaults/index.js';
 import CanceledError from '../cancel/CanceledError.js';
 import AxiosHeaders from '../core/AxiosHeaders.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) {
+  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);
+    return response;
+  }, function onAdapterRejection(reason) {
+    if (!isCancel(reason)) {
+      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
+        );
+        // 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);
+  );
+}

@@ -14,7 +14,7 @@
14	// foo.x.y.z	14	// foo.x.y.z
15	// foo-x-y-z	15	// foo-x-y-z
16	// foo x y z	16	// foo x y z
17	return utils.matchAll(/\w+\|\[(\w*)]/g, name).map(match => {	17	return utils.matchAll(/\w+\|\[(\w*)]/g, name).map((match) => {
18	return match[0] === '[]' ? '' : match[1] \|\| match[0];	18	return match[0] === '[]' ? '' : match[1] \|\| match[0];
19	});	19	});
20	}	20	}

@@ -1,8 +1,8 @@
1	import util from 'util';	1	import util from 'util';
2	import {Readable} from 'stream';
3	import utils from "../utils.js";
4	import readBlob from "./readBlob.js";
5	import platform from "../platform/index.js";	2	import { Readable } from 'stream';
		3	import utils from '../utils.js';
		4	import readBlob from './readBlob.js';
		5	import platform from '../platform/index.js';
6		6
7	const BOUNDARY_ALPHABET = platform.ALPHABET.ALPHA_DIGIT + '-_';	7	const BOUNDARY_ALPHABET = platform.ALPHABET.ALPHA_DIGIT + '-_';
8		8
@@ -14,7 +14,7 @@
14		14
15	class FormDataPart {	15	class FormDataPart {
16	constructor(name, value) {	16	constructor(name, value) {
17	const {escapeName} = this.constructor;	17	const { escapeName } = this.constructor;
18	const isStringValue = utils.isString(value);	18	const isStringValue = utils.isString(value);
19		19
20	let headers = `Content-Disposition: form-data; name="${escapeName(name)}"${	20	let headers = `Content-Disposition: form-data; name="${escapeName(name)}"${
@@ -24,7 +24,7 @@
24	if (isStringValue) {	24	if (isStringValue) {
25	value = textEncoder.encode(String(value).replace(/\r?\n\|\r\n?/g, CRLF));	25	value = textEncoder.encode(String(value).replace(/\r?\n\|\r\n?/g, CRLF));
26	} else {	26	} else {
27	headers += `Content-Type: ${value.type \|\| "application/octet-stream"}${CRLF}`	27	headers += `Content-Type: ${value.type \|\| 'application/octet-stream'}${CRLF}`;
28	}	28	}
29		29
30	this.headers = textEncoder.encode(headers + CRLF);	30	this.headers = textEncoder.encode(headers + CRLF);
@@ -37,12 +37,12 @@
37	this.value = value;	37	this.value = value;
38	}	38	}
39		39
40	async *encode(){	40	async *encode() {
41	yield this.headers;	41	yield this.headers;
42		42
43	const {value} = this;	43	const { value } = this;
44		44
45	if(utils.isTypedArray(value)) {	45	if (utils.isTypedArray(value)) {
46	yield value;	46	yield value;
47	} else {	47	} else {

@@ -17,7 +17,7 @@
17	* @returns {Buffer\|Blob}	17	* @returns {Buffer\|Blob}
18	*/	18	*/
19	export default function fromDataURI(uri, asBlob, options) {	19	export default function fromDataURI(uri, asBlob, options) {
20	const _Blob = options && options.Blob \|\| platform.classes.Blob;	20	const _Blob = (options && options.Blob) \|\| platform.classes.Blob;
21	const protocol = parseProtocol(uri);	21	const protocol = parseProtocol(uri);
22		22
23	if (asBlob === undefined && _Blob) {	23	if (asBlob === undefined && _Blob) {
@@ -43,7 +43,7 @@
43	throw new AxiosError('Blob is not supported', AxiosError.ERR_NOT_SUPPORT);	43	throw new AxiosError('Blob is not supported', AxiosError.ERR_NOT_SUPPORT);
44	}	44	}
45		45
46	return new _Blob([buffer], {type: mime});	46	return new _Blob([buffer], { type: mime });
47	}	47	}
48		48
49	return buffer;	49	return buffer;

@@ -1,13 +1,13 @@
1	import URLSearchParams from './classes/URLSearchParams.js'
2	import FormData from './classes/FormData.js'
3	import Blob from './classes/Blob.js'	1	import URLSearchParams from './classes/URLSearchParams.js';
		2	import FormData from './classes/FormData.js';
		3	import Blob from './classes/Blob.js';
4		4
5	export default {	5	export default {
6	isBrowser: true,	6	isBrowser: true,
7	classes: {	7	classes: {
8	URLSearchParams,	8	URLSearchParams,
9	FormData,	9	FormData,
10	Blob	10	Blob,
11	},	11	},
12	protocols: ['http', 'https', 'file', 'blob', 'url', 'data']	12	protocols: ['http', 'https', 'file', 'blob', 'url', 'data'],
13	};	13	};

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

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

@@ -1,20 +1,20 @@
1	import crypto from 'crypto';	1	import crypto from 'crypto';
2	import URLSearchParams from './classes/URLSearchParams.js'
3	import FormData from './classes/FormData.js'	2	import URLSearchParams from './classes/URLSearchParams.js';
		3	import FormData from './classes/FormData.js';
4		4
5	const ALPHA = 'abcdefghijklmnopqrstuvwxyz'	5	const ALPHA = 'abcdefghijklmnopqrstuvwxyz';
6		6
7	const DIGIT = '0123456789';	7	const DIGIT = '0123456789';
8		8
9	const ALPHABET = {	9	const ALPHABET = {
10	DIGIT,	10	DIGIT,
11	ALPHA,	11	ALPHA,
12	ALPHA_DIGIT: ALPHA + ALPHA.toUpperCase() + DIGIT
13	}	12	ALPHA_DIGIT: ALPHA + ALPHA.toUpperCase() + DIGIT,
		13	};
14		14
15	const generateString = (size = 16, alphabet = ALPHABET.ALPHA_DIGIT) => {	15	const generateString = (size = 16, alphabet = ALPHABET.ALPHA_DIGIT) => {
16	let str = '';	16	let str = '';
17	const {length} = alphabet;	17	const { length } = alphabet;
18	const randomValues = new Uint32Array(size);	18	const randomValues = new Uint32Array(size);
19	crypto.randomFillSync(randomValues);	19	crypto.randomFillSync(randomValues);
20	for (let i = 0; i < size; i++) {	20	for (let i = 0; i < size; i++) {
@@ -22,17 +22,16 @@
22	}	22	}
23		23
24	return str;	24	return str;
25	}	25	};
26		26
27
28	export default {	27	export default {
29	isNode: true,	28	isNode: true,
30	classes: {	29	classes: {
31	URLSearchParams,	30	URLSearchParams,
32	FormData,	31	FormData,
33	Blob: typeof Blob !== 'undefined' && Blob \|\| null	32	Blob: (typeof Blob !== 'undefined' && Blob) \|\| null,
34	},	33	},
35	ALPHABET,	34	ALPHABET,
36	generateString,	35	generateString,
37	protocols: [ 'http', 'https', 'file', 'data' ]	36	protocols: ['http', 'https', 'file', 'data'],
38	};	37	};

@@ -21,7 +21,7 @@
21	fulfilled,	21	fulfilled,
22	rejected,	22	rejected,
23	synchronous: options ? options.synchronous : false,	23	synchronous: options ? options.synchronous : false,
24	runWhen: options ? options.runWhen : null	24	runWhen: options ? options.runWhen : null,
25	});	25	});
26	return this.handlers.length - 1;	26	return this.handlers.length - 1;
27	}	27	}

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

@@ -10,5 +10,5 @@
10	* @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
11	*/	11	*/
12	export default function isAxiosError(payload) {	12	export default function isAxiosError(payload) {
13	return utils.isObject(payload) && (payload.isAxiosError === true);	13	return utils.isObject(payload) && payload.isAxiosError === true;
14	}	14	}

 import platform from '../platform/index.js';
+export default platform.hasStandardBrowserEnv ? ((origin, isMSIE) => (url) => {
+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)
+      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';
+import utils from "../utils.js";
+import utils from '../utils.js';
+import AxiosHeaders from './AxiosHeaders.js';
+const headersToObject = (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;
+}

 // 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',
+  '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) => {
   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();
+  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]) {
+      if (key === 'set-cookie') {
+        if (parsed[key]) {
+          parsed[key].push(val);
+        } else {
+          parsed[key] = [val];
+        }
       } else {
+        parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
+      }
+    } else {
+      parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
+    }
+    });
   return parsed;
 };

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

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`

+import speedometer from "./speedometer.js";
+import throttle from "./throttle.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) => {
     const loaded = e.loaded;
     const total = e.lengthComputable ? e.total : undefined;
     const progressBytes = loaded - bytesNotified;
     const data = {
       loaded,
       total,
+      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,
     };
     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));

@@ -1,15 +1,15 @@
1	const {asyncIterator} = Symbol;	1	const { asyncIterator } = Symbol;
2		2
3	const readBlob = async function* (blob) {	3	const readBlob = async function* (blob) {
4	if (blob.stream) {	4	if (blob.stream) {
5	yield* blob.stream()	5	yield* blob.stream();
6	} else if (blob.arrayBuffer) {	6	} else if (blob.arrayBuffer) {
7	yield await blob.arrayBuffer()	7	yield await blob.arrayBuffer();
8	} else if (blob[asyncIterator]) {	8	} else if (blob[asyncIterator]) {
9	yield* blob[asyncIterator]();	9	yield* blob[asyncIterator]();
10	} else {	10	} else {
11	yield blob;	11	yield blob;
12	}	12	}
13	}	13	};
14		14
15	export default readBlob;	15	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 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
+  );
   // HTTP basic authentication
   if (auth) {
+    headers.set('Authorization', 'Basic ' +
+    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
+      )
+    );
+  }
+}

@@ -48,7 +48,7 @@
48		48
49	const passed = startedAt && now - startedAt;	49	const passed = startedAt && now - startedAt;
50		50
51	return passed ? Math.round(bytesCount * 1000 / passed) : undefined;	51	return passed ? Math.round((bytesCount * 1000) / passed) : undefined;
52	};	52	};
53	}	53	}
54		54

@@ -18,23 +18,23 @@
18	timer = null;	18	timer = null;
19	}	19	}
20	fn(...args);	20	fn(...args);
21	}	21	};
22		22
23	const throttled = (...args) => {	23	const throttled = (...args) => {
24	const now = Date.now();	24	const now = Date.now();
25	const passed = now - timestamp;	25	const passed = now - timestamp;
26	if ( passed >= threshold) {	26	if (passed >= threshold) {
27	invoke(args, now);	27	invoke(args, now);
28	} else {	28	} else {
29	lastArgs = args;	29	lastArgs = args;
30	if (!timer) {	30	if (!timer) {
31	timer = setTimeout(() => {	31	timer = setTimeout(() => {
32	timer = null;	32	timer = null;
33	invoke(lastArgs)	33	invoke(lastArgs);
34	}, threshold - passed);	34	}, threshold - passed);
35	}	35	}
36	}	36	}
37	}	37	};
38		38
39	const flush = () => lastArgs && invoke(lastArgs);	39	const flush = () => lastArgs && invoke(lastArgs);
40		40

  */
 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;
+  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 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,
   });
   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]);

@@ -6,7 +6,7 @@
6		6
7	export default function toURLEncodedForm(data, options) {	7	export default function toURLEncodedForm(data, options) {
8	return toFormData(data, new platform.classes.URLSearchParams(), {	8	return toFormData(data, new platform.classes.URLSearchParams(), {
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)) {
11	this.append(key, value.toString('base64'));	11	this.append(key, value.toString('base64'));
12	return false;	12	return false;
@@ -14,6 +14,6 @@
14		14
15	return helpers.defaultVisitor.apply(this, arguments);	15	return helpers.defaultVisitor.apply(this, arguments);
16	},	16	},
17	...options	17	...options,
18	});	18	});
19	}	19	}

@@ -1,4 +1,3 @@
1
2	export const streamChunk = function* (chunk, chunkSize) {	1	export const streamChunk = function* (chunk, chunkSize) {
3	let len = chunk.byteLength;	2	let len = chunk.byteLength;
4		3
@@ -15,13 +14,13 @@
15	yield chunk.slice(pos, end);	14	yield chunk.slice(pos, end);
16	pos = end;	15	pos = end;
17	}	16	}
18	}	17	};
19		18
20	export const readBytes = async function* (iterable, chunkSize) {	19	export const readBytes = async function* (iterable, chunkSize) {
21	for await (const chunk of readStream(iterable)) {	20	for await (const chunk of readStream(iterable)) {
22	yield* streamChunk(chunk, chunkSize);	21	yield* streamChunk(chunk, chunkSize);
23	}	22	}
24	}	23	};
25		24
26	const readStream = async function* (stream) {	25	const readStream = async function* (stream) {
27	if (stream[Symbol.asyncIterator]) {	26	if (stream[Symbol.asyncIterator]) {
@@ -32,7 +31,7 @@
32	const reader = stream.getReader();	31	const reader = stream.getReader();
33	try {	32	try {
34	for (;;) {	33	for (;;) {
35	const {done, value} = await reader.read();	34	const { done, value } = await reader.read();
36	if (done) {	35	if (done) {
37	break;	36	break;
38	}	37	}
@@ -41,7 +40,7 @@
41	} finally {	40	} finally {
42	await reader.cancel();	41	await reader.cancel();
43	}	42	}
44	}	43	};
45		44
46	export const trackStream = (stream, chunkSize, onProgress, onFinish) => {	45	export const trackStream = (stream, chunkSize, onProgress, onFinish) => {
47	const iterator = readBytes(stream, chunkSize);	46	const iterator = readBytes(stream, chunkSize);
@@ -53,35 +52,38 @@
53	done = true;	52	done = true;
54	onFinish && onFinish(e);	53	onFinish && onFinish(e);
55	}	54	}
56	}	55	};
57		56
58	return new ReadableStream({
59	async pull(controller) {
60	try {
61	const {done, value} = await iterator.next();	57	return new ReadableStream(
		58	{
		59	async pull(controller) {
		60	try {
		61	const { done, value } = await iterator.next();
62		62
63	if (done) {
64	_onFinish();
65	controller.close();
66	return;
67	}	63	if (done) {
		64	_onFinish();
		65	controller.close();
		66	return;
		67	}
68		68
69	let len = value.byteLength;
70	if (onProgress) {
71	let loadedBytes = bytes += len;
72	onProgress(loadedBytes);	69	let len = value.byteLength;
		70	if (onProgress) {
		71	let loadedBytes = (bytes += len);
		72	onProgress(loadedBytes);
		73	}
		74	controller.enqueue(new Uint8Array(value));
		75	} catch (err) {
		76	_onFinish(err);
		77	throw err;
73	}	78	}
74	controller.enqueue(new Uint8Array(value));
75	} catch (err) {
76	_onFinish(err);
77	throw err;
78	}	79	},
		80	cancel(reason) {
		81	_onFinish(reason);
		82	return iterator.return();
		83	},
79	},	84	},
80	cancel(reason) {
81	_onFinish(reason);
82	return iterator.return();	85	{
		86	highWaterMark: 2,
83	}	87	}
84	}, {
85	highWaterMark: 2
86	})
87	}	88	);
		89	};

@@ -4,5 +4,5 @@
4	silentJSONParsing: true,	4	silentJSONParsing: true,
5	forcedJSONParsing: true,	5	forcedJSONParsing: true,
6	clarifyTimeoutError: false,	6	clarifyTimeoutError: false,
7	legacyInterceptorReqResOrdering: true	7	legacyInterceptorReqResOrdering: true,
8	};	8	};