@salla.sa/twilight-components 2.14.313 → 2.14.339

package/dist/components/axios.js

@@ -3,7 +3,7 @@
  */
 import { c as commonjsGlobal, g as getDefaultExportFromCjs } from './_commonjsHelpers.js';
 
-/*! Axios v1.10.0 Copyright (c) 2025 Matt Zabriskie and contributors */
+/*! Axios v1.13.3 Copyright (c) 2026 Matt Zabriskie and contributors */
 
 var axios_1;
 var hasRequiredAxios;
@@ -12,6 +12,13 @@ function requireAxios () {
 	if (hasRequiredAxios) return axios_1;
 	hasRequiredAxios = 1;
 
+	/**
+	 * Create a bound version of a function with a specified `this` context
+	 *
+	 * @param {Function} fn - The function to bind
+	 * @param {*} thisArg - The value to be passed as the `this` parameter
+	 * @returns {Function} A new function that will call the original function with the specified `this` context
+	 */
 	function bind(fn, thisArg) {
 	  return function wrap() {
 	    return fn.apply(thisArg, arguments);
@@ -63,7 +70,7 @@ function requireAxios () {
 	 */
 	function isBuffer(val) {
 	  return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor)
-	    && isFunction(val.constructor.isBuffer) && val.constructor.isBuffer(val);
+	    && isFunction$1(val.constructor.isBuffer) && val.constructor.isBuffer(val);
 	}
 
 	/**
@@ -108,7 +115,7 @@ function requireAxios () {
 	 * @param {*} val The value to test
 	 * @returns {boolean} True if value is a Function, otherwise false
 	 */
-	const isFunction = typeOfTest('function');
+	const isFunction$1 = typeOfTest('function');
 
 	/**
 	 * Determine if a value is a Number
@@ -152,6 +159,27 @@ function requireAxios () {
 	  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(toStringTag in val) && !(iterator in val);
 	};
 
+	/**
+	 * Determine if a value is an empty object (safely handles Buffers)
+	 *
+	 * @param {*} val The value to test
+	 *
+	 * @returns {boolean} True if value is an empty object, otherwise false
+	 */
+	const isEmptyObject = (val) => {
+	  // Early return for non-objects or Buffers to prevent RangeError
+	  if (!isObject(val) || isBuffer(val)) {
+	    return false;
+	  }
+
+	  try {
+	    return Object.keys(val).length === 0 && Object.getPrototypeOf(val) === Object.prototype;
+	  } catch (e) {
+	    // Fallback for any other objects that might cause RangeError with Object.keys()
+	    return false;
+	  }
+	};
+
 	/**
 	 * Determine if a value is a Date
 	 *
@@ -195,7 +223,7 @@ function requireAxios () {
 	 *
 	 * @returns {boolean} True if value is a Stream, otherwise false
 	 */
-	const isStream = (val) => isObject(val) && isFunction(val.pipe);
+	const isStream = (val) => isObject(val) && isFunction$1(val.pipe);
 
 	/**
 	 * Determine if a value is a FormData
@@ -208,10 +236,10 @@ function requireAxios () {
 	  let kind;
 	  return thing && (
 	    (typeof FormData === 'function' && thing instanceof FormData) || (
-	      isFunction(thing.append) && (
+	      isFunction$1(thing.append) && (
 	        (kind = kindOf(thing)) === 'formdata' ||
 	        // detect form-data instance
-	        (kind === 'object' && isFunction(thing.toString) && thing.toString() === '[object FormData]')
+	        (kind === 'object' && isFunction$1(thing.toString) && thing.toString() === '[object FormData]')
 	      )
 	    )
 	  )
@@ -247,10 +275,11 @@ function requireAxios () {
 	 * If 'obj' is an Object callback will be called passing
 	 * the value, key, and complete object for each property.
 	 *
-	 * @param {Object|Array} obj The object to iterate
+	 * @param {Object|Array<unknown>} obj The object to iterate
 	 * @param {Function} fn The callback to invoke for each item
 	 *
-	 * @param {Boolean} [allOwnKeys = false]
+	 * @param {Object} [options]
+	 * @param {Boolean} [options.allOwnKeys = false]
 	 * @returns {any}
 	 */
 	function forEach(obj, fn, {allOwnKeys = false} = {}) {
@@ -274,6 +303,11 @@ function requireAxios () {
 	      fn.call(null, obj[i], i, obj);
 	    }
 	  } else {
+	    // Buffer check
+	    if (isBuffer(obj)) {
+	      return;
+	    }
+
 	    // Iterate over object keys
 	    const keys = allOwnKeys ? Object.getOwnPropertyNames(obj) : Object.keys(obj);
 	    const len = keys.length;
@@ -287,6 +321,10 @@ function requireAxios () {
 	}
 
 	function findKey(obj, key) {
+	  if (isBuffer(obj)){
+	    return null;
+	  }
+
 	  key = key.toLowerCase();
 	  const keys = Object.keys(obj);
 	  let i = keys.length;
@@ -318,7 +356,7 @@ function requireAxios () {
 	 * Example:
 	 *
 	 * ```js
-	 * var result = merge({foo: 123}, {foo: 456});
+	 * const result = merge({foo: 123}, {foo: 456});
 	 * console.log(result.foo); // outputs 456
 	 * ```
 	 *
@@ -327,7 +365,7 @@ function requireAxios () {
 	 * @returns {Object} Result of all merge properties
 	 */
 	function merge(/* obj1, obj2, obj3, ... */) {
-	  const {caseless} = isContextDefined(this) && this || {};
+	  const {caseless, skipUndefined} = isContextDefined(this) && this || {};
 	  const result = {};
 	  const assignValue = (val, key) => {
 	    const targetKey = caseless && findKey(result, key) || key;
@@ -337,7 +375,7 @@ function requireAxios () {
 	      result[targetKey] = merge({}, val);
 	    } else if (isArray(val)) {
 	      result[targetKey] = val.slice();
-	    } else {
+	    } else if (!skipUndefined || !isUndefined(val)) {
 	      result[targetKey] = val;
 	    }
 	  };
@@ -355,15 +393,26 @@ function requireAxios () {
 	 * @param {Object} b The object to copy properties from
 	 * @param {Object} thisArg The object to bind function to
 	 *
-	 * @param {Boolean} [allOwnKeys]
+	 * @param {Object} [options]
+	 * @param {Boolean} [options.allOwnKeys]
 	 * @returns {Object} The resulting value of object a
 	 */
 	const extend = (a, b, thisArg, {allOwnKeys}= {}) => {
 	  forEach(b, (val, key) => {
-	    if (thisArg && isFunction(val)) {
-	      a[key] = bind(val, thisArg);
+	    if (thisArg && isFunction$1(val)) {
+	      Object.defineProperty(a, key, {
+	        value: bind(val, thisArg),
+	        writable: true,
+	        enumerable: true,
+	        configurable: true
+	      });
 	    } else {
-	      a[key] = val;
+	      Object.defineProperty(a, key, {
+	        value: val,
+	        writable: true,
+	        enumerable: true,
+	        configurable: true
+	      });
 	    }
 	  }, {allOwnKeys});
 	  return a;
@@ -394,7 +443,12 @@ function requireAxios () {
 	 */
 	const inherits = (constructor, superConstructor, props, descriptors) => {
 	  constructor.prototype = Object.create(superConstructor.prototype, descriptors);
-	  constructor.prototype.constructor = constructor;
+	  Object.defineProperty(constructor.prototype, 'constructor', {
+	    value: constructor,
+	    writable: true,
+	    enumerable: false,
+	    configurable: true
+	  });
 	  Object.defineProperty(constructor, 'super', {
 	    value: superConstructor.prototype
 	  });
@@ -576,13 +630,13 @@ function requireAxios () {
 	const freezeMethods = (obj) => {
 	  reduceDescriptors(obj, (descriptor, name) => {
 	    // skip restricted props in strict mode
-	    if (isFunction(obj) && ['arguments', 'caller', 'callee'].indexOf(name) !== -1) {
+	    if (isFunction$1(obj) && ['arguments', 'caller', 'callee'].indexOf(name) !== -1) {
 	      return false;
 	    }
 
 	    const value = obj[name];
 
-	    if (!isFunction(value)) return;
+	    if (!isFunction$1(value)) return;
 
 	    descriptor.enumerable = false;
 
@@ -619,6 +673,8 @@ function requireAxios () {
 	  return value != null && Number.isFinite(value = +value) ? value : defaultValue;
 	};
 
+
+
 	/**
 	 * If the thing is a FormData object, return true, otherwise return false.
 	 *
@@ -627,7 +683,7 @@ function requireAxios () {
 	 * @returns {boolean}
 	 */
 	function isSpecCompliantForm(thing) {
-	  return !!(thing && isFunction(thing.append) && thing[toStringTag] === 'FormData' && thing[iterator]);
+	  return !!(thing && isFunction$1(thing.append) && thing[toStringTag] === 'FormData' && thing[iterator]);
 	}
 
 	const toJSONObject = (obj) => {
@@ -640,6 +696,11 @@ function requireAxios () {
 	        return;
 	      }
 
+	      //Buffer check
+	      if (isBuffer(source)) {
+	        return source;
+	      }
+
 	      if(!('toJSON' in source)) {
 	        stack[i] = source;
 	        const target = isArray(source) ? [] : {};
@@ -664,7 +725,7 @@ function requireAxios () {
 	const isAsyncFn = kindOfTest('AsyncFunction');
 
 	const isThenable = (thing) =>
-	  thing && (isObject(thing) || isFunction(thing)) && isFunction(thing.then) && isFunction(thing.catch);
+	  thing && (isObject(thing) || isFunction$1(thing)) && isFunction$1(thing.then) && isFunction$1(thing.catch);
 
 	// original code
 	// https://github.com/DigitalBrainJS/AxiosPromise/blob/16deab13710ec09779922131f3fa5954320f83ab/lib/utils.js#L11-L34
@@ -688,7 +749,7 @@ function requireAxios () {
 	  })(`axios@${Math.random()}`, []) : (cb) => setTimeout(cb);
 	})(
 	  typeof setImmediate === 'function',
-	  isFunction(_global.postMessage)
+	  isFunction$1(_global.postMessage)
 	);
 
 	const asap = typeof queueMicrotask !== 'undefined' ?
@@ -697,7 +758,7 @@ function requireAxios () {
 	// *********************
 
 
-	const isIterable = (thing) => thing != null && isFunction(thing[iterator]);
+	const isIterable = (thing) => thing != null && isFunction$1(thing[iterator]);
 
 
 	var utils$1 = {
@@ -711,6 +772,7 @@ function requireAxios () {
 	  isBoolean,
 	  isObject,
 	  isPlainObject,
+	  isEmptyObject,
 	  isReadableStream,
 	  isRequest,
 	  isResponse,
@@ -720,7 +782,7 @@ function requireAxios () {
 	  isFile,
 	  isBlob,
 	  isRegExp,
-	  isFunction,
+	  isFunction: isFunction$1,
 	  isStream,
 	  isURLSearchParams,
 	  isTypedArray,
@@ -759,103 +821,75 @@ function requireAxios () {
 	  isIterable
 	};
 
-	/**
-	 * Create an Error with the specified message, config, error code, request and response.
-	 *
-	 * @param {string} message The error message.
-	 * @param {string} [code] The error code (for example, 'ECONNABORTED').
-	 * @param {Object} [config] The config.
-	 * @param {Object} [request] The request.
-	 * @param {Object} [response] The response.
-	 *
-	 * @returns {Error} The created error.
-	 */
-	function AxiosError(message, code, config, request, response) {
-	  Error.call(this);
-
-	  if (Error.captureStackTrace) {
-	    Error.captureStackTrace(this, this.constructor);
-	  } else {
-	    this.stack = (new Error()).stack;
-	  }
+	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;
+	    }
+
+	    /**
+	     * Create an Error with the specified message, config, error code, request and response.
+	     *
+	     * @param {string} message The error message.
+	     * @param {string} [code] The error code (for example, 'ECONNABORTED').
+	     * @param {Object} [config] The config.
+	     * @param {Object} [request] The request.
+	     * @param {Object} [response] The 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;
+	        }
+	    }
 
-	  this.message = message;
-	  this.name = 'AxiosError';
-	  code && (this.code = code);
-	  config && (this.config = config);
-	  request && (this.request = request);
-	  if (response) {
-	    this.response = response;
-	    this.status = response.status ? response.status : null;
-	  }
+	    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$1.toJSONObject(this.config),
+	            code: this.code,
+	            status: this.status,
+	        };
+	    }
 	}
 
-	utils$1.inherits(AxiosError, Error, {
-	  toJSON: function 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$1.toJSONObject(this.config),
-	      code: this.code,
-	      status: this.status
-	    };
-	  }
-	});
-
-	const prototype$1 = AxiosError.prototype;
-	const descriptors = {};
-
-	[
-	  'ERR_BAD_OPTION_VALUE',
-	  'ERR_BAD_OPTION',
-	  'ECONNABORTED',
-	  'ETIMEDOUT',
-	  'ERR_NETWORK',
-	  'ERR_FR_TOO_MANY_REDIRECTS',
-	  'ERR_DEPRECATED',
-	  'ERR_BAD_RESPONSE',
-	  'ERR_BAD_REQUEST',
-	  'ERR_CANCELED',
-	  'ERR_NOT_SUPPORT',
-	  'ERR_INVALID_URL'
-	// eslint-disable-next-line func-names
-	].forEach(code => {
-	  descriptors[code] = {value: code};
-	});
-
-	Object.defineProperties(AxiosError, descriptors);
-	Object.defineProperty(prototype$1, 'isAxiosError', {value: true});
-
-	// eslint-disable-next-line func-names
-	AxiosError.from = (error, code, config, request, response, customProps) => {
-	  const axiosError = Object.create(prototype$1);
-
-	  utils$1.toFlatObject(error, axiosError, function filter(obj) {
-	    return obj !== Error.prototype;
-	  }, prop => {
-	    return prop !== 'isAxiosError';
-	  });
-
-	  AxiosError.call(axiosError, error.message, code, config, request, response);
-
-	  axiosError.cause = error;
-
-	  axiosError.name = error.name;
-
-	  customProps && Object.assign(axiosError, customProps);
-
-	  return axiosError;
-	};
+	// This can be changed to static properties as soon as the parser options in .eslint.cjs are updated.
+	AxiosError.ERR_BAD_OPTION_VALUE = 'ERR_BAD_OPTION_VALUE';
+	AxiosError.ERR_BAD_OPTION = 'ERR_BAD_OPTION';
+	AxiosError.ECONNABORTED = 'ECONNABORTED';
+	AxiosError.ETIMEDOUT = 'ETIMEDOUT';
+	AxiosError.ERR_NETWORK = 'ERR_NETWORK';
+	AxiosError.ERR_FR_TOO_MANY_REDIRECTS = 'ERR_FR_TOO_MANY_REDIRECTS';
+	AxiosError.ERR_DEPRECATED = 'ERR_DEPRECATED';
+	AxiosError.ERR_BAD_RESPONSE = 'ERR_BAD_RESPONSE';
+	AxiosError.ERR_BAD_REQUEST = 'ERR_BAD_REQUEST';
+	AxiosError.ERR_CANCELED = 'ERR_CANCELED';
+	AxiosError.ERR_NOT_SUPPORT = 'ERR_NOT_SUPPORT';
+	AxiosError.ERR_INVALID_URL = 'ERR_INVALID_URL';
+
+	var AxiosError$1 = AxiosError;
 
 	// eslint-disable-next-line strict
 	var httpAdapter = null;
@@ -980,7 +1014,7 @@ function requireAxios () {
 	    }
 
 	    if (!useBlob && utils$1.isBlob(value)) {
-	      throw new AxiosError('Blob is not supported. Use a Buffer instead.');
+	      throw new AxiosError$1('Blob is not supported. Use a Buffer instead.');
 	    }
 
 	    if (utils$1.isArrayBuffer(value) || utils$1.isTypedArray(value)) {
@@ -1141,9 +1175,7 @@ function requireAxios () {
 	    replace(/%3A/gi, ':').
 	    replace(/%24/g, '$').
 	    replace(/%2C/gi, ',').
-	    replace(/%20/g, '+').
-	    replace(/%5B/gi, '[').
-	    replace(/%5D/gi, ']');
+	    replace(/%20/g, '+');
 	}
 
 	/**
@@ -1156,29 +1188,26 @@ function requireAxios () {
 	 * @returns {string} The formatted url
 	 */
 	function buildURL(url, params, options) {
-	  /*eslint no-param-reassign:0*/
 	  if (!params) {
 	    return url;
 	  }
-	  
+
 	  const _encode = options && options.encode || encode;
 
-	  if (utils$1.isFunction(options)) {
-	    options = {
-	      serialize: options
-	    };
-	  } 
+	  const _options = utils$1.isFunction(options) ? {
+	    serialize: options
+	  } : options;
 
-	  const serializeFn = options && options.serialize;
+	  const serializeFn = _options && _options.serialize;
 
 	  let serializedParams;
 
 	  if (serializeFn) {
-	    serializedParams = serializeFn(params, options);
+	    serializedParams = serializeFn(params, _options);
 	  } else {
 	    serializedParams = utils$1.isURLSearchParams(params) ?
 	      params.toString() :
-	      new AxiosURLSearchParams(params, options).toString(_encode);
+	      new AxiosURLSearchParams(params, _options).toString(_encode);
 	  }
 
 	  if (serializedParams) {
@@ -1203,6 +1232,7 @@ function requireAxios () {
 	   *
 	   * @param {Function} fulfilled The function to handle `then` for a `Promise`
 	   * @param {Function} rejected The function to handle `reject` for a `Promise`
+	   * @param {Object} options The options for the interceptor, synchronous and runWhen
 	   *
 	   * @return {Number} An ID used to remove interceptor later
 	   */
@@ -1221,7 +1251,7 @@ function requireAxios () {
 	   *
 	   * @param {Number} id The ID that was returned by `use`
 	   *
-	   * @returns {Boolean} `true` if the interceptor was removed, `false` otherwise
+	   * @returns {void}
 	   */
 	  eject(id) {
 	    if (this.handlers[id]) {
@@ -1342,7 +1372,7 @@ function requireAxios () {
 	};
 
 	function toURLEncodedForm(data, options) {
-	  return toFormData(data, new platform.classes.URLSearchParams(), Object.assign({
+	  return toFormData(data, new platform.classes.URLSearchParams(), {
 	    visitor: function(value, key, path, helpers) {
 	      if (platform.isNode && utils$1.isBuffer(value)) {
 	        this.append(key, value.toString('base64'));
@@ -1350,8 +1380,9 @@ function requireAxios () {
 	      }
 
 	      return helpers.defaultVisitor.apply(this, arguments);
-	    }
-	  }, options));
+	    },
+	    ...options
+	  });
 	}
 
 	/**
@@ -1547,11 +1578,11 @@ function requireAxios () {
 	      const strictJSONParsing = !silentJSONParsing && JSONRequested;
 
 	      try {
-	        return JSON.parse(data);
+	        return JSON.parse(data, this.parseReviver);
 	      } catch (e) {
 	        if (strictJSONParsing) {
 	          if (e.name === 'SyntaxError') {
-	            throw AxiosError.from(e, AxiosError.ERR_BAD_RESPONSE, this, null, this.response);
+	            throw AxiosError$1.from(e, AxiosError$1.ERR_BAD_RESPONSE, this, null, this.response);
 	          }
 	          throw e;
 	        }
@@ -1985,24 +2016,24 @@ function requireAxios () {
 	  return !!(value && value.__CANCEL__);
 	}
 
-	/**
-	 * A `CanceledError` is an object that is thrown when an operation is canceled.
-	 *
-	 * @param {string=} message The message.
-	 * @param {Object=} config The config.
-	 * @param {Object=} request The request.
-	 *
-	 * @returns {CanceledError} The created error.
-	 */
-	function CanceledError(message, config, request) {
-	  // eslint-disable-next-line no-eq-null,eqeqeq
-	  AxiosError.call(this, message == null ? 'canceled' : message, AxiosError.ERR_CANCELED, config, request);
-	  this.name = 'CanceledError';
+	class CanceledError extends AxiosError$1 {
+	  /**
+	   * A `CanceledError` is an object that is thrown when an operation is canceled.
+	   *
+	   * @param {string=} message The message.
+	   * @param {Object=} config The config.
+	   * @param {Object=} request The request.
+	   *
+	   * @returns {CanceledError} The created error.
+	   */
+	  constructor(message, config, request) {
+	    super(message == null ? 'canceled' : message, AxiosError$1.ERR_CANCELED, config, request);
+	    this.name = 'CanceledError';
+	    this.__CANCEL__ = true;
+	  }
 	}
 
-	utils$1.inherits(CanceledError, AxiosError, {
-	  __CANCEL__: true
-	});
+	var CanceledError$1 = CanceledError;
 
 	/**
 	 * Resolve or reject a Promise based on response status.
@@ -2018,9 +2049,9 @@ function requireAxios () {
 	  if (!response.status || !validateStatus || validateStatus(response.status)) {
 	    resolve(response);
 	  } else {
-	    reject(new AxiosError(
+	    reject(new AxiosError$1(
 	      'Request failed with status code ' + response.status,
-	      [AxiosError.ERR_BAD_REQUEST, AxiosError.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4],
+	      [AxiosError$1.ERR_BAD_REQUEST, AxiosError$1.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4],
 	      response.config,
 	      response.request,
 	      response
@@ -2104,7 +2135,7 @@ function requireAxios () {
 	      clearTimeout(timer);
 	      timer = null;
 	    }
-	    fn.apply(null, args);
+	    fn(...args);
 	  };
 
 	  const throttled = (...args) => {
@@ -2186,27 +2217,38 @@ function requireAxios () {
 
 	  // Standard browser envs support document.cookie
 	  {
-	    write(name, value, expires, path, domain, secure) {
-	      const cookie = [name + '=' + encodeURIComponent(value)];
+	    write(name, value, expires, path, domain, secure, sameSite) {
+	      if (typeof document === 'undefined') return;
 
-	      utils$1.isNumber(expires) && cookie.push('expires=' + new Date(expires).toGMTString());
+	      const cookie = [`${name}=${encodeURIComponent(value)}`];
 
-	      utils$1.isString(path) && cookie.push('path=' + path);
-
-	      utils$1.isString(domain) && cookie.push('domain=' + domain);
-
-	      secure === true && cookie.push('secure');
+	      if (utils$1.isNumber(expires)) {
+	        cookie.push(`expires=${new Date(expires).toUTCString()}`);
+	      }
+	      if (utils$1.isString(path)) {
+	        cookie.push(`path=${path}`);
+	      }
+	      if (utils$1.isString(domain)) {
+	        cookie.push(`domain=${domain}`);
+	      }
+	      if (secure === true) {
+	        cookie.push('secure');
+	      }
+	      if (utils$1.isString(sameSite)) {
+	        cookie.push(`SameSite=${sameSite}`);
+	      }
 
 	      document.cookie = cookie.join('; ');
 	    },
 
 	    read(name) {
-	      const match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)'));
-	      return (match ? decodeURIComponent(match[3]) : null);
+	      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);
+	      this.write(name, '', Date.now() - 86400000, '/');
 	    }
 	  }
 
@@ -2285,7 +2327,7 @@ function requireAxios () {
 
 	  function getMergedValue(target, source, prop, caseless) {
 	    if (utils$1.isPlainObject(target) && utils$1.isPlainObject(source)) {
-	      return utils$1.merge.call({caseless}, target, source);
+	      return utils$1.merge.call({ caseless }, target, source);
 	    } else if (utils$1.isPlainObject(source)) {
 	      return utils$1.merge({}, source);
 	    } else if (utils$1.isArray(source)) {
@@ -2294,12 +2336,11 @@ function requireAxios () {
 	    return source;
 	  }
 
-	  // eslint-disable-next-line consistent-return
-	  function mergeDeepProperties(a, b, prop , caseless) {
+	  function mergeDeepProperties(a, b, prop, caseless) {
 	    if (!utils$1.isUndefined(b)) {
-	      return getMergedValue(a, b, prop , caseless);
+	      return getMergedValue(a, b, prop, caseless);
 	    } else if (!utils$1.isUndefined(a)) {
-	      return getMergedValue(undefined, a, prop , caseless);
+	      return getMergedValue(undefined, a, prop, caseless);
 	    }
 	  }
 
@@ -2357,10 +2398,10 @@ function requireAxios () {
 	    socketPath: defaultToConfig2,
 	    responseEncoding: defaultToConfig2,
 	    validateStatus: mergeDirectKeys,
-	    headers: (a, b , prop) => mergeDeepProperties(headersToObject(a), headersToObject(b),prop, true)
+	    headers: (a, b, prop) => mergeDeepProperties(headersToObject(a), headersToObject(b), prop, true)
 	  };
 
-	  utils$1.forEach(Object.keys(Object.assign({}, config1, config2)), function computeConfigValue(prop) {
+	  utils$1.forEach(Object.keys({ ...config1, ...config2 }), function computeConfigValue(prop) {
 	    const merge = mergeMap[prop] || mergeDeepProperties;
 	    const configValue = merge(config1[prop], config2[prop], prop);
 	    (utils$1.isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue);
@@ -2372,7 +2413,7 @@ function requireAxios () {
 	var resolveConfig = (config) => {
 	  const newConfig = mergeConfig({}, config);
 
-	  let {data, withXSRFToken, xsrfHeaderName, xsrfCookieName, headers, auth} = newConfig;
+	  let { data, withXSRFToken, xsrfHeaderName, xsrfCookieName, headers, auth } = newConfig;
 
 	  newConfig.headers = headers = AxiosHeaders$1.from(headers);
 
@@ -2385,17 +2426,21 @@ function requireAxios () {
 	    );
 	  }
 
-	  let contentType;
-
 	  if (utils$1.isFormData(data)) {
 	    if (platform.hasStandardBrowserEnv || platform.hasStandardBrowserWebWorkerEnv) {
-	      headers.setContentType(undefined); // Let the browser set it
-	    } else if ((contentType = headers.getContentType()) !== false) {
-	      // fix semicolon duplication issue for ReactNative FormData implementation
-	      const [type, ...tokens] = contentType ? contentType.split(';').map(token => token.trim()).filter(Boolean) : [];
-	      headers.setContentType([type || 'multipart/form-data', ...tokens].join('; '));
+	      headers.setContentType(undefined); // browser handles it
+	    } else if (utils$1.isFunction(data.getHeaders)) {
+	      // Node.js FormData (like form-data package)
+	      const formHeaders = data.getHeaders();
+	      // Only set safe headers to avoid overwriting security headers
+	      const allowedHeaders = ['content-type', 'content-length'];
+	      Object.entries(formHeaders).forEach(([key, val]) => {
+	        if (allowedHeaders.includes(key.toLowerCase())) {
+	          headers.set(key, val);
+	        }
+	      });
 	    }
-	  }
+	  }  
 
 	  // Add xsrf header
 	  // This is only done if running in a standard browser environment.
@@ -2505,22 +2550,25 @@ function requireAxios () {
 	        return;
 	      }
 
-	      reject(new AxiosError('Request aborted', AxiosError.ECONNABORTED, config, request));
+	      reject(new AxiosError$1('Request aborted', AxiosError$1.ECONNABORTED, config, request));
 
 	      // Clean up request
 	      request = null;
 	    };
 
 	    // Handle low level network errors
-	    request.onerror = function handleError() {
-	      // Real errors are hidden from us by the browser
-	      // onerror should only fire if it's a network error
-	      reject(new AxiosError('Network Error', AxiosError.ERR_NETWORK, config, request));
-
-	      // Clean up request
-	      request = null;
+	  request.onerror = function handleError(event) {
+	       // Browsers deliver a ProgressEvent in XHR onerror
+	       // (message may be empty; when present, surface it)
+	       // See https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/error_event
+	       const msg = event && event.message ? event.message : 'Network Error';
+	       const err = new AxiosError$1(msg, AxiosError$1.ERR_NETWORK, config, request);
+	       // attach the underlying event for consumers who want details
+	       err.event = event || null;
+	       reject(err);
+	       request = null;
 	    };
-
+	    
 	    // Handle timeout
 	    request.ontimeout = function handleTimeout() {
 	      let timeoutErrorMessage = _config.timeout ? 'timeout of ' + _config.timeout + 'ms exceeded' : 'timeout exceeded';
@@ -2528,9 +2576,9 @@ function requireAxios () {
 	      if (_config.timeoutErrorMessage) {
 	        timeoutErrorMessage = _config.timeoutErrorMessage;
 	      }
-	      reject(new AxiosError(
+	      reject(new AxiosError$1(
 	        timeoutErrorMessage,
-	        transitional.clarifyTimeoutError ? AxiosError.ETIMEDOUT : AxiosError.ECONNABORTED,
+	        transitional.clarifyTimeoutError ? AxiosError$1.ETIMEDOUT : AxiosError$1.ECONNABORTED,
 	        config,
 	        request));
 
@@ -2580,7 +2628,7 @@ function requireAxios () {
 	        if (!request) {
 	          return;
 	        }
-	        reject(!cancel || cancel.type ? new CanceledError(null, config, request) : cancel);
+	        reject(!cancel || cancel.type ? new CanceledError$1(null, config, request) : cancel);
 	        request.abort();
 	        request = null;
 	      };
@@ -2594,7 +2642,7 @@ function requireAxios () {
 	    const protocol = parseProtocol(_config.url);
 
 	    if (protocol && platform.protocols.indexOf(protocol) === -1) {
-	      reject(new AxiosError('Unsupported protocol ' + protocol + ':', AxiosError.ERR_BAD_REQUEST, config));
+	      reject(new AxiosError$1('Unsupported protocol ' + protocol + ':', AxiosError$1.ERR_BAD_REQUEST, config));
 	      return;
 	    }
 
@@ -2617,13 +2665,13 @@ function requireAxios () {
 	        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$1 ? err : new CanceledError$1(err instanceof Error ? err.message : err));
 	      }
 	    };
 
 	    let timer = timeout && setTimeout(() => {
 	      timer = null;
-	      onabort(new AxiosError(`timeout ${timeout} of ms exceeded`, AxiosError.ETIMEDOUT));
+	      onabort(new AxiosError$1(`timeout of ${timeout}ms exceeded`, AxiosError$1.ETIMEDOUT));
 	    }, timeout);
 
 	    const unsubscribe = () => {
@@ -2736,14 +2784,18 @@ function requireAxios () {
 	  })
 	};
 
-	const isFetchSupported = typeof fetch === 'function' && typeof Request === 'function' && typeof Response === 'function';
-	const isReadableStreamSupported = isFetchSupported && typeof ReadableStream === 'function';
+	const DEFAULT_CHUNK_SIZE = 64 * 1024;
+
+	const {isFunction} = utils$1;
+
+	const globalFetchAPI = (({Request, Response}) => ({
+	  Request, Response
+	}))(utils$1.global);
+
+	const {
+	  ReadableStream: ReadableStream$1, TextEncoder
+	} = utils$1.global;
 
-	// used only inside the fetch adapter
-	const encodeText = isFetchSupported && (typeof TextEncoder === 'function' ?
-	    ((encoder) => (str) => encoder.encode(str))(new TextEncoder()) :
-	    async (str) => new Uint8Array(await new Response(str).arrayBuffer())
-	);
 
 	const test = (fn, ...args) => {
 	  try {
@@ -2753,278 +2805,380 @@ function requireAxios () {
 	  }
 	};
 
-	const supportsRequestStream = isReadableStreamSupported && test(() => {
-	  let duplexAccessed = false;
+	const factory = (env) => {
+	  env = utils$1.merge.call({
+	    skipUndefined: true
+	  }, globalFetchAPI, env);
 
-	  const hasContentType = new Request(platform.origin, {
-	    body: new ReadableStream(),
-	    method: 'POST',
-	    get duplex() {
-	      duplexAccessed = true;
-	      return 'half';
-	    },
-	  }).headers.has('Content-Type');
+	  const {fetch: envFetch, Request, Response} = env;
+	  const isFetchSupported = envFetch ? isFunction(envFetch) : typeof fetch === 'function';
+	  const isRequestSupported = isFunction(Request);
+	  const isResponseSupported = isFunction(Response);
 
-	  return duplexAccessed && !hasContentType;
-	});
+	  if (!isFetchSupported) {
+	    return false;
+	  }
 
-	const DEFAULT_CHUNK_SIZE = 64 * 1024;
+	  const isReadableStreamSupported = isFetchSupported && isFunction(ReadableStream$1);
 
-	const supportsResponseStream = isReadableStreamSupported &&
-	  test(() => utils$1.isReadableStream(new Response('').body));
+	  const encodeText = isFetchSupported && (typeof TextEncoder === 'function' ?
+	      ((encoder) => (str) => encoder.encode(str))(new TextEncoder()) :
+	      async (str) => new Uint8Array(await new Request(str).arrayBuffer())
+	  );
 
+	  const supportsRequestStream = isRequestSupported && isReadableStreamSupported && test(() => {
+	    let duplexAccessed = false;
 
-	const resolvers = {
-	  stream: supportsResponseStream && ((res) => res.body)
-	};
+	    const hasContentType = new Request(platform.origin, {
+	      body: new ReadableStream$1(),
+	      method: 'POST',
+	      get duplex() {
+	        duplexAccessed = true;
+	        return 'half';
+	      },
+	    }).headers.has('Content-Type');
 
-	isFetchSupported && (((res) => {
-	  ['text', 'arrayBuffer', 'blob', 'formData', 'stream'].forEach(type => {
-	    !resolvers[type] && (resolvers[type] = utils$1.isFunction(res[type]) ? (res) => res[type]() :
-	      (_, config) => {
-	        throw new AxiosError(`Response type '${type}' is not supported`, AxiosError.ERR_NOT_SUPPORT, config);
-	      });
+	    return duplexAccessed && !hasContentType;
 	  });
-	})(new Response));
 
-	const getBodyLength = async (body) => {
-	  if (body == null) {
-	    return 0;
-	  }
+	  const supportsResponseStream = isResponseSupported && isReadableStreamSupported &&
+	    test(() => utils$1.isReadableStream(new Response('').body));
 
-	  if(utils$1.isBlob(body)) {
-	    return body.size;
-	  }
+	  const resolvers = {
+	    stream: supportsResponseStream && ((res) => res.body)
+	  };
 
-	  if(utils$1.isSpecCompliantForm(body)) {
-	    const _request = new Request(platform.origin, {
-	      method: 'POST',
-	      body,
+	  isFetchSupported && ((() => {
+	    ['text', 'arrayBuffer', 'blob', 'formData', 'stream'].forEach(type => {
+	      !resolvers[type] && (resolvers[type] = (res, config) => {
+	        let method = res && res[type];
+
+	        if (method) {
+	          return method.call(res);
+	        }
+
+	        throw new AxiosError$1(`Response type '${type}' is not supported`, AxiosError$1.ERR_NOT_SUPPORT, config);
+	      });
 	    });
-	    return (await _request.arrayBuffer()).byteLength;
-	  }
+	  })());
 
-	  if(utils$1.isArrayBufferView(body) || utils$1.isArrayBuffer(body)) {
-	    return body.byteLength;
-	  }
+	  const getBodyLength = async (body) => {
+	    if (body == null) {
+	      return 0;
+	    }
 
-	  if(utils$1.isURLSearchParams(body)) {
-	    body = body + '';
-	  }
+	    if (utils$1.isBlob(body)) {
+	      return body.size;
+	    }
 
-	  if(utils$1.isString(body)) {
-	    return (await encodeText(body)).byteLength;
-	  }
-	};
+	    if (utils$1.isSpecCompliantForm(body)) {
+	      const _request = new Request(platform.origin, {
+	        method: 'POST',
+	        body,
+	      });
+	      return (await _request.arrayBuffer()).byteLength;
+	    }
 
-	const resolveBodyLength = async (headers, body) => {
-	  const length = utils$1.toFiniteNumber(headers.getContentLength());
+	    if (utils$1.isArrayBufferView(body) || utils$1.isArrayBuffer(body)) {
+	      return body.byteLength;
+	    }
 
-	  return length == null ? getBodyLength(body) : length;
-	};
+	    if (utils$1.isURLSearchParams(body)) {
+	      body = body + '';
+	    }
 
-	var fetchAdapter = isFetchSupported && (async (config) => {
-	  let {
-	    url,
-	    method,
-	    data,
-	    signal,
-	    cancelToken,
-	    timeout,
-	    onDownloadProgress,
-	    onUploadProgress,
-	    responseType,
-	    headers,
-	    withCredentials = 'same-origin',
-	    fetchOptions
-	  } = resolveConfig(config);
-
-	  responseType = responseType ? (responseType + '').toLowerCase() : 'text';
-
-	  let composedSignal = composeSignals$1([signal, cancelToken && cancelToken.toAbortSignal()], timeout);
-
-	  let request;
-
-	  const unsubscribe = composedSignal && composedSignal.unsubscribe && (() => {
+	    if (utils$1.isString(body)) {
+	      return (await encodeText(body)).byteLength;
+	    }
+	  };
+
+	  const resolveBodyLength = async (headers, body) => {
+	    const length = utils$1.toFiniteNumber(headers.getContentLength());
+
+	    return length == null ? getBodyLength(body) : length;
+	  };
+
+	  return async (config) => {
+	    let {
+	      url,
+	      method,
+	      data,
+	      signal,
+	      cancelToken,
+	      timeout,
+	      onDownloadProgress,
+	      onUploadProgress,
+	      responseType,
+	      headers,
+	      withCredentials = 'same-origin',
+	      fetchOptions
+	    } = resolveConfig(config);
+
+	    let _fetch = envFetch || fetch;
+
+	    responseType = responseType ? (responseType + '').toLowerCase() : 'text';
+
+	    let composedSignal = composeSignals$1([signal, cancelToken && cancelToken.toAbortSignal()], timeout);
+
+	    let request = null;
+
+	    const unsubscribe = composedSignal && composedSignal.unsubscribe && (() => {
 	      composedSignal.unsubscribe();
-	  });
+	    });
 
-	  let requestContentLength;
+	    let requestContentLength;
 
-	  try {
-	    if (
-	      onUploadProgress && supportsRequestStream && method !== 'get' && method !== 'head' &&
-	      (requestContentLength = await resolveBodyLength(headers, data)) !== 0
-	    ) {
-	      let _request = new Request(url, {
-	        method: 'POST',
-	        body: data,
-	        duplex: "half"
-	      });
+	    try {
+	      if (
+	        onUploadProgress && supportsRequestStream && method !== 'get' && method !== 'head' &&
+	        (requestContentLength = await resolveBodyLength(headers, data)) !== 0
+	      ) {
+	        let _request = new Request(url, {
+	          method: 'POST',
+	          body: data,
+	          duplex: "half"
+	        });
 
-	      let contentTypeHeader;
+	        let contentTypeHeader;
 
-	      if (utils$1.isFormData(data) && (contentTypeHeader = _request.headers.get('content-type'))) {
-	        headers.setContentType(contentTypeHeader);
-	      }
+	        if (utils$1.isFormData(data) && (contentTypeHeader = _request.headers.get('content-type'))) {
+	          headers.setContentType(contentTypeHeader);
+	        }
 
-	      if (_request.body) {
-	        const [onProgress, flush] = progressEventDecorator(
-	          requestContentLength,
-	          progressEventReducer(asyncDecorator(onUploadProgress))
-	        );
+	        if (_request.body) {
+	          const [onProgress, flush] = progressEventDecorator(
+	            requestContentLength,
+	            progressEventReducer(asyncDecorator(onUploadProgress))
+	          );
 
-	        data = trackStream(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush);
+	          data = trackStream(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush);
+	        }
 	      }
-	    }
 
-	    if (!utils$1.isString(withCredentials)) {
-	      withCredentials = withCredentials ? 'include' : 'omit';
-	    }
+	      if (!utils$1.isString(withCredentials)) {
+	        withCredentials = withCredentials ? 'include' : 'omit';
+	      }
 
-	    // Cloudflare Workers throws when credentials are defined
-	    // see https://github.com/cloudflare/workerd/issues/902
-	    const isCredentialsSupported = "credentials" in Request.prototype;
-	    request = new Request(url, {
-	      ...fetchOptions,
-	      signal: composedSignal,
-	      method: method.toUpperCase(),
-	      headers: headers.normalize().toJSON(),
-	      body: data,
-	      duplex: "half",
-	      credentials: isCredentialsSupported ? withCredentials : undefined
-	    });
+	      // Cloudflare Workers throws when credentials are defined
+	      // see https://github.com/cloudflare/workerd/issues/902
+	      const isCredentialsSupported = isRequestSupported && "credentials" in Request.prototype;
 
-	    let response = await fetch(request, fetchOptions);
+	      const resolvedOptions = {
+	        ...fetchOptions,
+	        signal: composedSignal,
+	        method: method.toUpperCase(),
+	        headers: headers.normalize().toJSON(),
+	        body: data,
+	        duplex: "half",
+	        credentials: isCredentialsSupported ? withCredentials : undefined
+	      };
 
-	    const isStreamResponse = supportsResponseStream && (responseType === 'stream' || responseType === 'response');
+	      request = isRequestSupported && new Request(url, resolvedOptions);
 
-	    if (supportsResponseStream && (onDownloadProgress || (isStreamResponse && unsubscribe))) {
-	      const options = {};
+	      let response = await (isRequestSupported ? _fetch(request, fetchOptions) : _fetch(url, resolvedOptions));
 
-	      ['status', 'statusText', 'headers'].forEach(prop => {
-	        options[prop] = response[prop];
-	      });
+	      const isStreamResponse = supportsResponseStream && (responseType === 'stream' || responseType === 'response');
 
-	      const responseContentLength = utils$1.toFiniteNumber(response.headers.get('content-length'));
+	      if (supportsResponseStream && (onDownloadProgress || (isStreamResponse && unsubscribe))) {
+	        const options = {};
 
-	      const [onProgress, flush] = onDownloadProgress && progressEventDecorator(
-	        responseContentLength,
-	        progressEventReducer(asyncDecorator(onDownloadProgress), true)
-	      ) || [];
+	        ['status', 'statusText', 'headers'].forEach(prop => {
+	          options[prop] = response[prop];
+	        });
 
-	      response = new Response(
-	        trackStream(response.body, DEFAULT_CHUNK_SIZE, onProgress, () => {
-	          flush && flush();
-	          unsubscribe && unsubscribe();
-	        }),
-	        options
-	      );
-	    }
+	        const responseContentLength = utils$1.toFiniteNumber(response.headers.get('content-length'));
 
-	    responseType = responseType || 'text';
+	        const [onProgress, flush] = onDownloadProgress && progressEventDecorator(
+	          responseContentLength,
+	          progressEventReducer(asyncDecorator(onDownloadProgress), true)
+	        ) || [];
 
-	    let responseData = await resolvers[utils$1.findKey(resolvers, responseType) || 'text'](response, config);
+	        response = new Response(
+	          trackStream(response.body, DEFAULT_CHUNK_SIZE, onProgress, () => {
+	            flush && flush();
+	            unsubscribe && unsubscribe();
+	          }),
+	          options
+	        );
+	      }
 
-	    !isStreamResponse && unsubscribe && unsubscribe();
+	      responseType = responseType || 'text';
 
-	    return await new Promise((resolve, reject) => {
-	      settle(resolve, reject, {
-	        data: responseData,
-	        headers: AxiosHeaders$1.from(response.headers),
-	        status: response.status,
-	        statusText: response.statusText,
-	        config,
-	        request
-	      });
-	    })
-	  } catch (err) {
-	    unsubscribe && unsubscribe();
-
-	    if (err && err.name === 'TypeError' && /Load failed|fetch/i.test(err.message)) {
-	      throw Object.assign(
-	        new AxiosError('Network Error', AxiosError.ERR_NETWORK, config, request),
-	        {
-	          cause: err.cause || err
-	        }
-	      )
+	      let responseData = await resolvers[utils$1.findKey(resolvers, responseType) || 'text'](response, config);
+
+	      !isStreamResponse && unsubscribe && unsubscribe();
+
+	      return await new Promise((resolve, reject) => {
+	        settle(resolve, reject, {
+	          data: responseData,
+	          headers: AxiosHeaders$1.from(response.headers),
+	          status: response.status,
+	          statusText: response.statusText,
+	          config,
+	          request
+	        });
+	      })
+	    } catch (err) {
+	      unsubscribe && unsubscribe();
+
+	      if (err && err.name === 'TypeError' && /Load failed|fetch/i.test(err.message)) {
+	        throw Object.assign(
+	          new AxiosError$1('Network Error', AxiosError$1.ERR_NETWORK, config, request),
+	          {
+	            cause: err.cause || err
+	          }
+	        )
+	      }
+
+	      throw AxiosError$1.from(err, err && err.code, config, request);
 	    }
+	  }
+	};
+
+	const seedCache = new Map();
+
+	const getFetch = (config) => {
+	  let env = (config && config.env) || {};
+	  const {fetch, Request, Response} = env;
+	  const seeds = [
+	    Request, Response, fetch
+	  ];
+
+	  let len = seeds.length, i = len,
+	    seed, target, map = seedCache;
 
-	    throw AxiosError.from(err, err && err.code, config, request);
+	  while (i--) {
+	    seed = seeds[i];
+	    target = map.get(seed);
+
+	    target === undefined && map.set(seed, target = (i ? new Map() : factory(env)));
+
+	    map = target;
 	  }
-	});
 
+	  return target;
+	};
+
+	getFetch();
+
+	/**
+	 * Known adapters mapping.
+	 * Provides environment-specific adapters for Axios:
+	 * - `http` for Node.js
+	 * - `xhr` for browsers
+	 * - `fetch` for fetch API-based requests
+	 * 
+	 * @type {Object<string, Function|Object>}
+	 */
 	const knownAdapters = {
 	  http: httpAdapter,
 	  xhr: xhrAdapter,
-	  fetch: fetchAdapter
+	  fetch: {
+	    get: getFetch,
+	  }
 	};
 
+	// Assign adapter names for easier debugging and identification
 	utils$1.forEach(knownAdapters, (fn, value) => {
 	  if (fn) {
 	    try {
-	      Object.defineProperty(fn, 'name', {value});
+	      Object.defineProperty(fn, 'name', { value });
 	    } catch (e) {
 	      // eslint-disable-next-line no-empty
 	    }
-	    Object.defineProperty(fn, 'adapterName', {value});
+	    Object.defineProperty(fn, 'adapterName', { value });
 	  }
 	});
 
+	/**
+	 * Render a rejection reason string for unknown or unsupported adapters
+	 * 
+	 * @param {string} reason
+	 * @returns {string}
+	 */
 	const renderReason = (reason) => `- ${reason}`;
 
+	/**
+	 * Check if the adapter is resolved (function, null, or false)
+	 * 
+	 * @param {Function|null|false} adapter
+	 * @returns {boolean}
+	 */
 	const isResolvedHandle = (adapter) => utils$1.isFunction(adapter) || adapter === null || adapter === false;
 
-	var adapters = {
-	  getAdapter: (adapters) => {
-	    adapters = utils$1.isArray(adapters) ? adapters : [adapters];
+	/**
+	 * 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
+	 * @returns {Function} The resolved adapter function
+	 */
+	function getAdapter(adapters, config) {
+	  adapters = utils$1.isArray(adapters) ? adapters : [adapters];
 
-	    const {length} = adapters;
-	    let nameOrAdapter;
-	    let adapter;
+	  const { length } = adapters;
+	  let nameOrAdapter;
+	  let adapter;
 
-	    const rejectedReasons = {};
+	  const rejectedReasons = {};
 
-	    for (let i = 0; i < length; i++) {
-	      nameOrAdapter = adapters[i];
-	      let id;
+	  for (let i = 0; i < length; i++) {
+	    nameOrAdapter = adapters[i];
+	    let id;
 
-	      adapter = nameOrAdapter;
+	    adapter = nameOrAdapter;
 
-	      if (!isResolvedHandle(nameOrAdapter)) {
-	        adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];
+	    if (!isResolvedHandle(nameOrAdapter)) {
+	      adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];
 
-	        if (adapter === undefined) {
-	          throw new AxiosError(`Unknown adapter '${id}'`);
-	        }
-	      }
-
-	      if (adapter) {
-	        break;
+	      if (adapter === undefined) {
+	        throw new AxiosError$1(`Unknown adapter '${id}'`);
 	      }
+	    }
 
-	      rejectedReasons[id || '#' + i] = adapter;
+	    if (adapter && (utils$1.isFunction(adapter) || (adapter = adapter.get(config)))) {
+	      break;
 	    }
 
-	    if (!adapter) {
+	    rejectedReasons[id || '#' + i] = adapter;
+	  }
 
-	      const reasons = Object.entries(rejectedReasons)
-	        .map(([id, state]) => `adapter ${id} ` +
-	          (state === false ? 'is not supported by the environment' : 'is not available in the build')
-	        );
+	  if (!adapter) {
+	    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,
-	        'ERR_NOT_SUPPORT'
-	      );
-	    }
+	    throw new AxiosError$1(
+	      `There is no suitable adapter to dispatch the request ` + s,
+	      'ERR_NOT_SUPPORT'
+	    );
+	  }
 
-	    return adapter;
-	  },
+	  return adapter;
+	}
+
+	/**
+	 * Exports Axios adapters and utility to resolve an adapter
+	 */
+	var adapters = {
+	  /**
+	   * Resolve an adapter from a list of adapter names or functions.
+	   * @type {Function}
+	   */
+	  getAdapter,
+
+	  /**
+	   * Exposes all known adapters
+	   * @type {Object<string, Function|Object>}
+	   */
 	  adapters: knownAdapters
 	};
 
@@ -3041,7 +3195,7 @@ function requireAxios () {
 	  }
 
 	  if (config.signal && config.signal.aborted) {
-	    throw new CanceledError(null, config);
+	    throw new CanceledError$1(null, config);
 	  }
 	}
 
@@ -3067,7 +3221,7 @@ function requireAxios () {
 	    config.headers.setContentType('application/x-www-form-urlencoded', false);
 	  }
 
-	  const adapter = adapters.getAdapter(config.adapter || defaults$1.adapter);
+	  const adapter = adapters.getAdapter(config.adapter || defaults$1.adapter, config);
 
 	  return adapter(config).then(function onAdapterResolution(response) {
 	    throwIfCancellationRequested(config);
@@ -3101,7 +3255,7 @@ function requireAxios () {
 	  });
 	}
 
-	const VERSION = "1.10.0";
+	const VERSION = "1.13.3";
 
 	const validators$1 = {};
 
@@ -3131,9 +3285,9 @@ function requireAxios () {
 	  // eslint-disable-next-line func-names
 	  return (value, opt, opts) => {
 	    if (validator === false) {
-	      throw new AxiosError(
+	      throw new AxiosError$1(
 	        formatMessage(opt, ' has been removed' + (version ? ' in ' + version : '')),
-	        AxiosError.ERR_DEPRECATED
+	        AxiosError$1.ERR_DEPRECATED
 	      );
 	    }
 
@@ -3172,7 +3326,7 @@ function requireAxios () {
 
 	function assertOptions(options, schema, allowUnknown) {
 	  if (typeof options !== 'object') {
-	    throw new AxiosError('options must be an object', AxiosError.ERR_BAD_OPTION_VALUE);
+	    throw new AxiosError$1('options must be an object', AxiosError$1.ERR_BAD_OPTION_VALUE);
 	  }
 	  const keys = Object.keys(options);
 	  let i = keys.length;
@@ -3183,12 +3337,12 @@ function requireAxios () {
 	      const value = options[opt];
 	      const result = value === undefined || validator(value, opt, options);
 	      if (result !== true) {
-	        throw new AxiosError('option ' + opt + ' must be ' + result, AxiosError.ERR_BAD_OPTION_VALUE);
+	        throw new AxiosError$1('option ' + opt + ' must be ' + result, AxiosError$1.ERR_BAD_OPTION_VALUE);
 	      }
 	      continue;
 	    }
 	    if (allowUnknown !== true) {
-	      throw new AxiosError('Unknown option ' + opt, AxiosError.ERR_BAD_OPTION);
+	      throw new AxiosError$1('Unknown option ' + opt, AxiosError$1.ERR_BAD_OPTION);
 	    }
 	  }
 	}
@@ -3340,14 +3494,19 @@ function requireAxios () {
 
 	    if (!synchronousRequestInterceptors) {
 	      const chain = [dispatchRequest.bind(this), undefined];
-	      chain.unshift.apply(chain, requestInterceptorChain);
-	      chain.push.apply(chain, responseInterceptorChain);
+	      chain.unshift(...requestInterceptorChain);
+	      chain.push(...responseInterceptorChain);
 	      len = chain.length;
 
 	      promise = Promise.resolve(config);
 
+	      let prevResult = config;
 	      while (i < len) {
-	        promise = promise.then(chain[i++], chain[i++]);
+	        promise = promise
+	            .then(chain[i++])
+	            .then(result => { prevResult = result !== undefined ? result : prevResult; })
+	            .catch(chain[i++])
+	            .then(() => prevResult);
 	      }
 
 	      return promise;
@@ -3357,8 +3516,6 @@ function requireAxios () {
 
 	    let newConfig = config;
 
-	    i = 0;
-
 	    while (i < len) {
 	      const onFulfilled = requestInterceptorChain[i++];
 	      const onRejected = requestInterceptorChain[i++];
@@ -3380,7 +3537,7 @@ function requireAxios () {
 	    len = responseInterceptorChain.length;
 
 	    while (i < len) {
-	      promise = promise.then(responseInterceptorChain[i++], responseInterceptorChain[i++]);
+	      promise = promise.then(responseInterceptorChain[i++]).catch(responseInterceptorChain[i++]);
 	    }
 
 	    return promise;
@@ -3483,7 +3640,7 @@ function requireAxios () {
 	        return;
 	      }
 
-	      token.reason = new CanceledError(message, config, request);
+	      token.reason = new CanceledError$1(message, config, request);
 	      resolvePromise(token.reason);
 	    });
 	  }
@@ -3567,7 +3724,7 @@ function requireAxios () {
 	 *
 	 *  ```js
 	 *  function f(x, y, z) {}
-	 *  var args = [1, 2, 3];
+	 *  const args = [1, 2, 3];
 	 *  f.apply(null, args);
 	 *  ```
 	 *
@@ -3662,6 +3819,12 @@ function requireAxios () {
 	  LoopDetected: 508,
 	  NotExtended: 510,
 	  NetworkAuthenticationRequired: 511,
+	  WebServerIsDown: 521,
+	  ConnectionTimedOut: 522,
+	  OriginIsUnreachable: 523,
+	  TimeoutOccurred: 524,
+	  SslHandshakeFailed: 525,
+	  InvalidSslCertificate: 526,
 	};
 
 	Object.entries(HttpStatusCode).forEach(([key, value]) => {
@@ -3702,14 +3865,14 @@ function requireAxios () {
 	axios.Axios = Axios$1;
 
 	// Expose Cancel & CancelToken
-	axios.CanceledError = CanceledError;
+	axios.CanceledError = CanceledError$1;
 	axios.CancelToken = CancelToken$1;
 	axios.isCancel = isCancel;
 	axios.VERSION = VERSION;
 	axios.toFormData = toFormData;
 
 	// Expose AxiosError class
-	axios.AxiosError = AxiosError;
+	axios.AxiosError = AxiosError$1;
 
 	// alias for CanceledError for backward compatibility
 	axios.Cancel = axios.CanceledError;