File Explorer

/proc/self/root/var/runtime/node_modules/@aws-sdk/node_modules/axios/dist/browser

This explorer reads the filesystem of the server it runs on, so /workspace/user isn't present here. Browsing and the terminal still work against this server's own disk from /.

axios.cjs111 KB · 4339 lines
/*! Axios v1.15.2 Copyright (c) 2026 Matt Zabriskie and contributors */'use strict'; /** * 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);  };} // utils is a library of generic helper functions non-specific to axios const { toString } = Object.prototype;const { getPrototypeOf } = Object;const { iterator, toStringTag } = Symbol; const kindOf = ((cache) => (thing) => {  const str = toString.call(thing);  return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());})(Object.create(null)); const kindOfTest = (type) => {  type = type.toLowerCase();  return (thing) => kindOf(thing) === type;}; const typeOfTest = (type) => (thing) => typeof thing === type; /** * Determine if a value is a non-null object * * @param {Object} val The value to test * * @returns {boolean} True if value is an Array, otherwise false */const { isArray } = Array; /** * Determine if a value is undefined * * @param {*} val The value to test * * @returns {boolean} True if the value is undefined, otherwise false */const isUndefined = typeOfTest('undefined'); /** * Determine if a value is a Buffer * * @param {*} val The value to test * * @returns {boolean} True if value is a Buffer, otherwise false */function isBuffer(val) {  return (    val !== null &&    !isUndefined(val) &&    val.constructor !== null &&    !isUndefined(val.constructor) &&    isFunction$1(val.constructor.isBuffer) &&    val.constructor.isBuffer(val)  );} /** * Determine if a value is an ArrayBuffer * * @param {*} val The value to test * * @returns {boolean} True if value is an ArrayBuffer, otherwise false */const isArrayBuffer = kindOfTest('ArrayBuffer'); /** * Determine if a value is a view on an ArrayBuffer * * @param {*} val The value to test * * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false */function isArrayBufferView(val) {  let result;  if (typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView) {    result = ArrayBuffer.isView(val);  } else {    result = val && val.buffer && isArrayBuffer(val.buffer);  }  return result;} /** * Determine if a value is a String * * @param {*} val The value to test * * @returns {boolean} True if value is a String, otherwise false */const isString = typeOfTest('string'); /** * Determine if a value is a Function * * @param {*} val The value to test * @returns {boolean} True if value is a Function, otherwise false */const isFunction$1 = typeOfTest('function'); /** * Determine if a value is a Number * * @param {*} val The value to test * * @returns {boolean} True if value is a Number, otherwise false */const isNumber = typeOfTest('number'); /** * Determine if a value is an Object * * @param {*} thing The value to test * * @returns {boolean} True if value is an Object, otherwise false */const isObject = (thing) => thing !== null && typeof thing === 'object'; /** * Determine if a value is a Boolean * * @param {*} thing The value to test * @returns {boolean} True if value is a Boolean, otherwise false */const isBoolean = (thing) => thing === true || thing === false; /** * Determine if a value is a plain Object * * @param {*} val The value to test * * @returns {boolean} True if value is a plain Object, otherwise false */const isPlainObject = (val) => {  if (kindOf(val) !== 'object') {    return false;  }   const prototype = getPrototypeOf(val);  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 * * @param {*} val The value to test * * @returns {boolean} True if value is a Date, otherwise false */const isDate = kindOfTest('Date'); /** * Determine if a value is a File * * @param {*} val The value to test * * @returns {boolean} True if value is a File, otherwise false */const isFile = kindOfTest('File'); /** * Determine if a value is a React Native Blob * React Native "blob": an object with a `uri` attribute. Optionally, it can * also have a `name` and `type` attribute to specify filename and content type * * @see https://github.com/facebook/react-native/blob/26684cf3adf4094eb6c405d345a75bf8c7c0bf88/Libraries/Network/FormData.js#L68-L71 *  * @param {*} value The value to test *  * @returns {boolean} True if value is a React Native Blob, otherwise false */const isReactNativeBlob = (value) => {  return !!(value && typeof value.uri !== 'undefined');}; /** * Determine if environment is React Native * ReactNative `FormData` has a non-standard `getParts()` method *  * @param {*} formData The formData to test *  * @returns {boolean} True if environment is React Native, otherwise false */const isReactNative = (formData) => formData && typeof formData.getParts !== 'undefined'; /** * Determine if a value is a Blob * * @param {*} val The value to test * * @returns {boolean} True if value is a Blob, otherwise false */const isBlob = kindOfTest('Blob'); /** * Determine if a value is a FileList * * @param {*} val The value to test * * @returns {boolean} True if value is a File, otherwise false */const isFileList = kindOfTest('FileList'); /** * Determine if a value is a Stream * * @param {*} val The value to test * * @returns {boolean} True if value is a Stream, otherwise false */const isStream = (val) => isObject(val) && isFunction$1(val.pipe); /** * Determine if a value is a FormData * * @param {*} thing The value to test * * @returns {boolean} True if value is an FormData, otherwise false */function getGlobal() {  if (typeof globalThis !== 'undefined') return globalThis;  if (typeof self !== 'undefined') return self;  if (typeof window !== 'undefined') return window;  if (typeof global !== 'undefined') return global;  return {};} const G = getGlobal();const FormDataCtor = typeof G.FormData !== 'undefined' ? G.FormData : undefined; const isFormData = (thing) => {  if (!thing) return false;  if (FormDataCtor && thing instanceof FormDataCtor) return true;  // Reject plain objects inheriting directly from Object.prototype so prototype-pollution gadgets can't spoof FormData (GHSA-6chq-wfr3-2hj9).  const proto = getPrototypeOf(thing);  if (!proto || proto === Object.prototype) return false;  if (!isFunction$1(thing.append)) return false;  const kind = kindOf(thing);  return kind === 'formdata' ||    // detect form-data instance    (kind === 'object' && isFunction$1(thing.toString) && thing.toString() === '[object FormData]');}; /** * Determine if a value is a URLSearchParams object * * @param {*} val The value to test * * @returns {boolean} True if value is a URLSearchParams object, otherwise false */const isURLSearchParams = kindOfTest('URLSearchParams'); const [isReadableStream, isRequest, isResponse, isHeaders] = [  'ReadableStream',  'Request',  'Response',  'Headers',].map(kindOfTest); /** * Trim excess whitespace off the beginning and end of a string * * @param {String} str The String to trim * * @returns {String} The String freed of excess whitespace */const trim = (str) => {  return str.trim ? str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');};/** * Iterate over an Array or an Object invoking a function for each item. * * If `obj` is an Array callback will be called passing * the value, index, and complete array for each item. * * If 'obj' is an Object callback will be called passing * the value, key, and complete object for each property. * * @param {Object|Array<unknown>} obj The object to iterate * @param {Function} fn The callback to invoke for each item * * @param {Object} [options] * @param {Boolean} [options.allOwnKeys = false] * @returns {any} */function forEach(obj, fn, { allOwnKeys = false } = {}) {  // Don't bother if no value provided  if (obj === null || typeof obj === 'undefined') {    return;  }   let i;  let l;   // Force an array if not already something iterable  if (typeof obj !== 'object') {    /*eslint no-param-reassign:0*/    obj = [obj];  }   if (isArray(obj)) {    // Iterate over array values    for (i = 0, l = obj.length; i < l; i++) {      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;    let key;     for (i = 0; i < len; i++) {      key = keys[i];      fn.call(null, obj[key], key, obj);    }  }} /** * Finds a key in an object, case-insensitive, returning the actual key name. * Returns null if the object is a Buffer or if no match is found. * * @param {Object} obj - The object to search. * @param {string} key - The key to find (case-insensitive). * @returns {?string} The actual key name if found, otherwise null. */function findKey(obj, key) {  if (isBuffer(obj)) {    return null;  }   key = key.toLowerCase();  const keys = Object.keys(obj);  let i = keys.length;  let _key;  while (i-- > 0) {    _key = keys[i];    if (key === _key.toLowerCase()) {      return _key;    }  }  return null;} const _global = (() => {  /*eslint no-undef:0*/  if (typeof globalThis !== 'undefined') return globalThis;  return typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : global;})(); const isContextDefined = (context) => !isUndefined(context) && context !== _global; /** * Accepts varargs expecting each argument to be an object, then * immutably merges the properties of each object and returns result. * * When multiple objects contain the same key the later object in * the arguments list will take precedence. * * Example: * * ```js * const result = merge({foo: 123}, {foo: 456}); * console.log(result.foo); // outputs 456 * ``` * * @param {Object} obj1 Object to merge * * @returns {Object} Result of all merge properties */function merge(/* obj1, obj2, obj3, ... */) {  const { caseless, skipUndefined } = (isContextDefined(this) && this) || {};  const result = {};  const assignValue = (val, key) => {    // Skip dangerous property names to prevent prototype pollution    if (key === '__proto__' || key === 'constructor' || key === 'prototype') {      return;    }     const targetKey = (caseless && findKey(result, key)) || key;    if (isPlainObject(result[targetKey]) && isPlainObject(val)) {      result[targetKey] = merge(result[targetKey], val);    } else if (isPlainObject(val)) {      result[targetKey] = merge({}, val);    } else if (isArray(val)) {      result[targetKey] = val.slice();    } else if (!skipUndefined || !isUndefined(val)) {      result[targetKey] = val;    }  };   for (let i = 0, l = arguments.length; i < l; i++) {    arguments[i] && forEach(arguments[i], assignValue);  }  return result;} /** * Extends object a by mutably adding to it the properties of object b. * * @param {Object} a The object to be extended * @param {Object} b The object to copy properties from * @param {Object} thisArg The object to bind function to * * @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$1(val)) {        Object.defineProperty(a, key, {          value: bind(val, thisArg),          writable: true,          enumerable: true,          configurable: true,        });      } else {        Object.defineProperty(a, key, {          value: val,          writable: true,          enumerable: true,          configurable: true,        });      }    },    { allOwnKeys }  );  return a;}; /** * Remove byte order marker. This catches EF BB BF (the UTF-8 BOM) * * @param {string} content with BOM * * @returns {string} content value without BOM */const stripBOM = (content) => {  if (content.charCodeAt(0) === 0xfeff) {    content = content.slice(1);  }  return content;}; /** * Inherit the prototype methods from one constructor into another * @param {function} constructor * @param {function} superConstructor * @param {object} [props] * @param {object} [descriptors] * * @returns {void} */const inherits = (constructor, superConstructor, props, descriptors) => {  constructor.prototype = Object.create(superConstructor.prototype, descriptors);  Object.defineProperty(constructor.prototype, 'constructor', {    value: constructor,    writable: true,    enumerable: false,    configurable: true,  });  Object.defineProperty(constructor, 'super', {    value: superConstructor.prototype,  });  props && Object.assign(constructor.prototype, props);}; /** * Resolve object with deep prototype chain to a flat object * @param {Object} sourceObj source object * @param {Object} [destObj] * @param {Function|Boolean} [filter] * @param {Function} [propFilter] * * @returns {Object} */const toFlatObject = (sourceObj, destObj, filter, propFilter) => {  let props;  let i;  let prop;  const merged = {};   destObj = destObj || {};  // eslint-disable-next-line no-eq-null,eqeqeq  if (sourceObj == null) return destObj;   do {    props = Object.getOwnPropertyNames(sourceObj);    i = props.length;    while (i-- > 0) {      prop = props[i];      if ((!propFilter || propFilter(prop, sourceObj, destObj)) && !merged[prop]) {        destObj[prop] = sourceObj[prop];        merged[prop] = true;      }    }    sourceObj = filter !== false && getPrototypeOf(sourceObj);  } while (sourceObj && (!filter || filter(sourceObj, destObj)) && sourceObj !== Object.prototype);   return destObj;}; /** * Determines whether a string ends with the characters of a specified string * * @param {String} str * @param {String} searchString * @param {Number} [position= 0] * * @returns {boolean} */const endsWith = (str, searchString, position) => {  str = String(str);  if (position === undefined || position > str.length) {    position = str.length;  }  position -= searchString.length;  const lastIndex = str.indexOf(searchString, position);  return lastIndex !== -1 && lastIndex === position;}; /** * Returns new array from array like object or null if failed * * @param {*} [thing] * * @returns {?Array} */const toArray = (thing) => {  if (!thing) return null;  if (isArray(thing)) return thing;  let i = thing.length;  if (!isNumber(i)) return null;  const arr = new Array(i);  while (i-- > 0) {    arr[i] = thing[i];  }  return arr;}; /** * Checking if the Uint8Array exists and if it does, it returns a function that checks if the * thing passed in is an instance of Uint8Array * * @param {TypedArray} * * @returns {Array} */// eslint-disable-next-line func-namesconst isTypedArray = ((TypedArray) => {  // eslint-disable-next-line func-names  return (thing) => {    return TypedArray && thing instanceof TypedArray;  };})(typeof Uint8Array !== 'undefined' && getPrototypeOf(Uint8Array)); /** * For each entry in the object, call the function with the key and value. * * @param {Object<any, any>} obj - The object to iterate over. * @param {Function} fn - The function to call for each entry. * * @returns {void} */const forEachEntry = (obj, fn) => {  const generator = obj && obj[iterator];   const _iterator = generator.call(obj);   let result;   while ((result = _iterator.next()) && !result.done) {    const pair = result.value;    fn.call(obj, pair[0], pair[1]);  }}; /** * It takes a regular expression and a string, and returns an array of all the matches * * @param {string} regExp - The regular expression to match against. * @param {string} str - The string to search. * * @returns {Array<boolean>} */const matchAll = (regExp, str) => {  let matches;  const arr = [];   while ((matches = regExp.exec(str)) !== null) {    arr.push(matches);  }   return arr;}; /* Checking if the kindOfTest function returns true when passed an HTMLFormElement. */const isHTMLForm = kindOfTest('HTMLFormElement'); const toCamelCase = (str) => {  return str.toLowerCase().replace(/[-_\s]([a-z\d])(\w*)/g, function replacer(m, p1, p2) {    return p1.toUpperCase() + p2;  });}; /* Creating a function that will check if an object has a property. */const hasOwnProperty = (  ({ hasOwnProperty }) =>  (obj, prop) =>    hasOwnProperty.call(obj, prop))(Object.prototype); /** * Determine if a value is a RegExp object * * @param {*} val The value to test * * @returns {boolean} True if value is a RegExp object, otherwise false */const isRegExp = kindOfTest('RegExp'); const reduceDescriptors = (obj, reducer) => {  const descriptors = Object.getOwnPropertyDescriptors(obj);  const reducedDescriptors = {};   forEach(descriptors, (descriptor, name) => {    let ret;    if ((ret = reducer(descriptor, name, obj)) !== false) {      reducedDescriptors[name] = ret || descriptor;    }  });   Object.defineProperties(obj, reducedDescriptors);}; /** * Makes all methods read-only * @param {Object} obj */ const freezeMethods = (obj) => {  reduceDescriptors(obj, (descriptor, name) => {    // skip restricted props in strict mode    if (isFunction$1(obj) && ['arguments', 'caller', 'callee'].indexOf(name) !== -1) {      return false;    }     const value = obj[name];     if (!isFunction$1(value)) return;     descriptor.enumerable = false;     if ('writable' in descriptor) {      descriptor.writable = false;      return;    }     if (!descriptor.set) {      descriptor.set = () => {        throw Error("Can not rewrite read-only method '" + name + "'");      };    }  });}; /** * Converts an array or a delimited string into an object set with values as keys and true as values. * Useful for fast membership checks. * * @param {Array|string} arrayOrString - The array or string to convert. * @param {string} delimiter - The delimiter to use if input is a string. * @returns {Object} An object with keys from the array or string, values set to true. */const toObjectSet = (arrayOrString, delimiter) => {  const obj = {};   const define = (arr) => {    arr.forEach((value) => {      obj[value] = true;    });  };   isArray(arrayOrString) ? define(arrayOrString) : define(String(arrayOrString).split(delimiter));   return obj;}; const noop = () => {}; const toFiniteNumber = (value, defaultValue) => {  return value != null && Number.isFinite((value = +value)) ? value : defaultValue;}; /** * If the thing is a FormData object, return true, otherwise return false. * * @param {unknown} thing - The thing to check. * * @returns {boolean} */function isSpecCompliantForm(thing) {  return !!(    thing &&    isFunction$1(thing.append) &&    thing[toStringTag] === 'FormData' &&    thing[iterator]  );} /** * Recursively converts an object to a JSON-compatible object, handling circular references and Buffers. * * @param {Object} obj - The object to convert. * @returns {Object} The JSON-compatible object. */const toJSONObject = (obj) => {  const stack = new Array(10);   const visit = (source, i) => {    if (isObject(source)) {      if (stack.indexOf(source) >= 0) {        return;      }       //Buffer check      if (isBuffer(source)) {        return source;      }       if (!('toJSON' in source)) {        stack[i] = source;        const target = isArray(source) ? [] : {};         forEach(source, (value, key) => {          const reducedValue = visit(value, i + 1);          !isUndefined(reducedValue) && (target[key] = reducedValue);        });         stack[i] = undefined;         return target;      }    }     return source;  };   return visit(obj, 0);}; /** * Determines if a value is an async function. * * @param {*} thing - The value to test. * @returns {boolean} True if value is an async function, otherwise false. */const isAsyncFn = kindOfTest('AsyncFunction'); /** * Determines if a value is thenable (has then and catch methods). * * @param {*} thing - The value to test. * @returns {boolean} True if value is thenable, otherwise false. */const isThenable = (thing) =>  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 /** * Provides a cross-platform setImmediate implementation. * Uses native setImmediate if available, otherwise falls back to postMessage or setTimeout. * * @param {boolean} setImmediateSupported - Whether setImmediate is supported. * @param {boolean} postMessageSupported - Whether postMessage is supported. * @returns {Function} A function to schedule a callback asynchronously. */const _setImmediate = ((setImmediateSupported, postMessageSupported) => {  if (setImmediateSupported) {    return setImmediate;  }   return postMessageSupported    ? ((token, callbacks) => {        _global.addEventListener(          'message',          ({ source, data }) => {            if (source === _global && data === token) {              callbacks.length && callbacks.shift()();            }          },          false        );         return (cb) => {          callbacks.push(cb);          _global.postMessage(token, '*');        };      })(`axios@${Math.random()}`, [])    : (cb) => setTimeout(cb);})(typeof setImmediate === 'function', isFunction$1(_global.postMessage)); /** * Schedules a microtask or asynchronous callback as soon as possible. * Uses queueMicrotask if available, otherwise falls back to process.nextTick or _setImmediate. * * @type {Function} */const asap =  typeof queueMicrotask !== 'undefined'    ? queueMicrotask.bind(_global)    : (typeof process !== 'undefined' && process.nextTick) || _setImmediate; // ********************* const isIterable = (thing) => thing != null && isFunction$1(thing[iterator]); var utils$1 = {  isArray,  isArrayBuffer,  isBuffer,  isFormData,  isArrayBufferView,  isString,  isNumber,  isBoolean,  isObject,  isPlainObject,  isEmptyObject,  isReadableStream,  isRequest,  isResponse,  isHeaders,  isUndefined,  isDate,  isFile,  isReactNativeBlob,  isReactNative,  isBlob,  isRegExp,  isFunction: isFunction$1,  isStream,  isURLSearchParams,  isTypedArray,  isFileList,  forEach,  merge,  extend,  trim,  stripBOM,  inherits,  toFlatObject,  kindOf,  kindOfTest,  endsWith,  toArray,  forEachEntry,  matchAll,  isHTMLForm,  hasOwnProperty,  hasOwnProp: hasOwnProperty, // an alias to avoid ESLint no-prototype-builtins detection  reduceDescriptors,  freezeMethods,  toObjectSet,  toCamelCase,  noop,  toFiniteNumber,  findKey,  global: _global,  isContextDefined,  isSpecCompliantForm,  toJSONObject,  isAsyncFn,  isThenable,  setImmediate: _setImmediate,  asap,  isIterable,}; 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;     // 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.   *   * @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);     // 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$1.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.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';AxiosError.ERR_FORM_DATA_DEPTH_EXCEEDED = 'ERR_FORM_DATA_DEPTH_EXCEEDED'; // eslint-disable-next-line strictvar httpAdapter = null; /** * Determines if the given thing is a array or js object. * * @param {string} thing - The object or array to be visited. * * @returns {boolean} */function isVisitable(thing) {  return utils$1.isPlainObject(thing) || utils$1.isArray(thing);} /** * It removes the brackets from the end of a string * * @param {string} key - The key of the parameter. * * @returns {string} the key without the brackets. */function removeBrackets(key) {  return utils$1.endsWith(key, '[]') ? key.slice(0, -2) : key;} /** * It takes a path, a key, and a boolean, and returns a string * * @param {string} path - The path to the current key. * @param {string} key - The key of the current object being iterated over. * @param {string} dots - If true, the key will be rendered with dots instead of brackets. * * @returns {string} The path to the current key. */function renderKey(path, key, dots) {  if (!path) return key;  return path    .concat(key)    .map(function each(token, i) {      // eslint-disable-next-line no-param-reassign      token = removeBrackets(token);      return !dots && i ? '[' + token + ']' : token;    })    .join(dots ? '.' : '');} /** * If the array is an array and none of its elements are visitable, then it's a flat array. * * @param {Array<any>} arr - The array to check * * @returns {boolean} */function isFlatArray(arr) {  return utils$1.isArray(arr) && !arr.some(isVisitable);} const predicates = utils$1.toFlatObject(utils$1, {}, null, function filter(prop) {  return /^is[A-Z]/.test(prop);}); /** * Convert a data object to FormData * * @param {Object} obj * @param {?Object} [formData] * @param {?Object} [options] * @param {Function} [options.visitor] * @param {Boolean} [options.metaTokens = true] * @param {Boolean} [options.dots = false] * @param {?Boolean} [options.indexes = false] * * @returns {Object} **/ /** * It converts an object into a FormData object * * @param {Object<any, any>} obj - The object to convert to form data. * @param {string} formData - The FormData object to append to. * @param {Object<string, any>} options * * @returns */function toFormData(obj, formData, options) {  if (!utils$1.isObject(obj)) {    throw new TypeError('target must be an object');  }   // eslint-disable-next-line no-param-reassign  formData = formData || new (FormData)();   // eslint-disable-next-line no-param-reassign  options = utils$1.toFlatObject(    options,    {      metaTokens: true,      dots: false,      indexes: false,    },    false,    function defined(option, source) {      // eslint-disable-next-line no-eq-null,eqeqeq      return !utils$1.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 maxDepth = options.maxDepth === undefined ? 100 : options.maxDepth;  const useBlob = _Blob && utils$1.isSpecCompliantForm(formData);   if (!utils$1.isFunction(visitor)) {    throw new TypeError('visitor must be a function');  }   function convertValue(value) {    if (value === null) return '';     if (utils$1.isDate(value)) {      return value.toISOString();    }     if (utils$1.isBoolean(value)) {      return value.toString();    }     if (!useBlob && utils$1.isBlob(value)) {      throw new AxiosError('Blob is not supported. Use a Buffer instead.');    }     if (utils$1.isArrayBuffer(value) || utils$1.isTypedArray(value)) {      return useBlob && typeof Blob === 'function' ? new Blob([value]) : Buffer.from(value);    }     return value;  }   /**   * Default visitor.   *   * @param {*} value   * @param {String|Number} key   * @param {Array<String|Number>} path   * @this {FormData}   *   * @returns {boolean} return true to visit the each prop of the value recursively   */  function defaultVisitor(value, key, path) {    let arr = value;     if (utils$1.isReactNative(formData) && utils$1.isReactNativeBlob(value)) {      formData.append(renderKey(path, key, dots), convertValue(value));      return false;    }     if (value && !path && typeof value === 'object') {      if (utils$1.endsWith(key, '{}')) {        // eslint-disable-next-line no-param-reassign        key = metaTokens ? key : key.slice(0, -2);        // eslint-disable-next-line no-param-reassign        value = JSON.stringify(value);      } else if (        (utils$1.isArray(value) && isFlatArray(value)) ||        ((utils$1.isFileList(value) || utils$1.endsWith(key, '[]')) && (arr = utils$1.toArray(value)))      ) {        // eslint-disable-next-line no-param-reassign        key = removeBrackets(key);         arr.forEach(function each(el, index) {          !(utils$1.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;      }    }     if (isVisitable(value)) {      return true;    }     formData.append(renderKey(path, key, dots), convertValue(value));     return false;  }   const stack = [];   const exposedHelpers = Object.assign(predicates, {    defaultVisitor,    convertValue,    isVisitable,  });   function build(value, path, depth = 0) {    if (utils$1.isUndefined(value)) return;     if (depth > maxDepth) {      throw new AxiosError(        'Object is too deeply nested (' + depth + ' levels). Max depth: ' + maxDepth,        AxiosError.ERR_FORM_DATA_DEPTH_EXCEEDED      );    }     if (stack.indexOf(value) !== -1) {      throw Error('Circular reference detected in ' + path.join('.'));    }     stack.push(value);     utils$1.forEach(value, function each(el, key) {      const result =        !(utils$1.isUndefined(el) || el === null) &&        visitor.call(formData, el, utils$1.isString(key) ? key.trim() : key, path, exposedHelpers);       if (result === true) {        build(el, path ? path.concat(key) : [key], depth + 1);      }    });     stack.pop();  }   if (!utils$1.isObject(obj)) {    throw new TypeError('data must be an object');  }   build(obj);   return formData;} /** * It encodes a string by replacing all characters that are not in the unreserved set with * their percent-encoded equivalents * * @param {string} str - The string to encode. * * @returns {string} The encoded string. */function encode$1(str) {  const charMap = {    '!': '%21',    "'": '%27',    '(': '%28',    ')': '%29',    '~': '%7E',    '%20': '+',  };  return encodeURIComponent(str).replace(/[!'()~]|%20/g, function replacer(match) {    return charMap[match];  });} /** * It takes a params object and converts it to a FormData object * * @param {Object<string, any>} params - The parameters to be converted to a FormData object. * @param {Object<string, any>} options - The options object passed to the Axios constructor. * * @returns {void} */function AxiosURLSearchParams(params, options) {  this._pairs = [];   params && toFormData(params, this, options);} const prototype = AxiosURLSearchParams.prototype; prototype.append = function append(name, value) {  this._pairs.push([name, value]);}; prototype.toString = function toString(encoder) {  const _encode = encoder    ? function (value) {        return encoder.call(this, value, encode$1);      }    : encode$1;   return this._pairs    .map(function each(pair) {      return _encode(pair[0]) + '=' + _encode(pair[1]);    }, '')    .join('&');}; /** * It replaces URL-encoded forms of `:`, `$`, `,`, and spaces with * their plain counterparts (`:`, `$`, `,`, `+`). * * @param {string} val The value to be encoded. * * @returns {string} The encoded value. */function encode(val) {  return encodeURIComponent(val)    .replace(/%3A/gi, ':')    .replace(/%24/g, '$')    .replace(/%2C/gi, ',')    .replace(/%20/g, '+');} /** * Build a URL by appending params to the end * * @param {string} url The base of the url (e.g., http://www.google.com) * @param {object} [params] The params to be appended * @param {?(object|Function)} options * * @returns {string} The formatted url */function buildURL(url, params, options) {  if (!params) {    return url;  }   const _encode = (options && options.encode) || encode;   const _options = utils$1.isFunction(options)    ? {        serialize: options,      }    : options;   const serializeFn = _options && _options.serialize;   let serializedParams;   if (serializeFn) {    serializedParams = serializeFn(params, _options);  } else {    serializedParams = utils$1.isURLSearchParams(params)      ? params.toString()      : new AxiosURLSearchParams(params, _options).toString(_encode);  }   if (serializedParams) {    const hashmarkIndex = url.indexOf('#');     if (hashmarkIndex !== -1) {      url = url.slice(0, hashmarkIndex);    }    url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;  }   return url;} class InterceptorManager {  constructor() {    this.handlers = [];  }   /**   * Add a new interceptor to the stack   *   * @param {Function} fulfilled The function to handle `then` for a `Promise`   * @param {Function} rejected The function to handle `reject` for a `Promise`   * @param {Object} options The options for the interceptor, synchronous and runWhen   *   * @return {Number} An ID used to remove interceptor later   */  use(fulfilled, rejected, options) {    this.handlers.push({      fulfilled,      rejected,      synchronous: options ? options.synchronous : false,      runWhen: options ? options.runWhen : null,    });    return this.handlers.length - 1;  }   /**   * Remove an interceptor from the stack   *   * @param {Number} id The ID that was returned by `use`   *   * @returns {void}   */  eject(id) {    if (this.handlers[id]) {      this.handlers[id] = null;    }  }   /**   * Clear all interceptors from the stack   *   * @returns {void}   */  clear() {    if (this.handlers) {      this.handlers = [];    }  }   /**   * Iterate over all the registered interceptors   *   * This method is particularly useful for skipping over any   * interceptors that may have become `null` calling `eject`.   *   * @param {Function} fn The function to call for each interceptor   *   * @returns {void}   */  forEach(fn) {    utils$1.forEach(this.handlers, function forEachHandler(h) {      if (h !== null) {        fn(h);      }    });  }} var transitionalDefaults = {  silentJSONParsing: true,  forcedJSONParsing: true,  clarifyTimeoutError: false,  legacyInterceptorReqResOrdering: true,}; var URLSearchParams$1 = typeof URLSearchParams !== 'undefined' ? URLSearchParams : AxiosURLSearchParams; var FormData$1 = typeof FormData !== 'undefined' ? FormData : null; var Blob$1 = typeof Blob !== 'undefined' ? Blob : null; var platform$1 = {  isBrowser: true,  classes: {    URLSearchParams: URLSearchParams$1,    FormData: FormData$1,    Blob: Blob$1,  },  protocols: ['http', 'https', 'file', 'blob', 'url', 'data'],}; const hasBrowserEnv = typeof window !== 'undefined' && typeof document !== 'undefined'; const _navigator = (typeof navigator === 'object' && navigator) || undefined; /** * Determine if we're running in a standard browser environment * * This allows axios to run in a web worker, and react-native. * Both environments support XMLHttpRequest, but not fully standard globals. * * web workers: *  typeof window -> undefined *  typeof document -> undefined * * react-native: *  navigator.product -> 'ReactNative' * nativescript *  navigator.product -> 'NativeScript' or 'NS' * * @returns {boolean} */const hasStandardBrowserEnv =  hasBrowserEnv &&  (!_navigator || ['ReactNative', 'NativeScript', 'NS'].indexOf(_navigator.product) < 0); /** * Determine if we're running in a standard browser webWorker environment * * Although the `isStandardBrowserEnv` method indicates that * `allows axios to run in a web worker`, the WebWorker will still be * filtered out due to its judgment standard * `typeof window !== 'undefined' && typeof document !== 'undefined'`. * This leads to a problem when axios post `FormData` in webWorker */const hasStandardBrowserWebWorkerEnv = (() => {  return (    typeof WorkerGlobalScope !== 'undefined' &&    // eslint-disable-next-line no-undef    self instanceof WorkerGlobalScope &&    typeof self.importScripts === 'function'  );})(); const origin = (hasBrowserEnv && window.location.href) || 'http://localhost'; var utils = /*#__PURE__*/Object.freeze({  __proto__: null,  hasBrowserEnv: hasBrowserEnv,  hasStandardBrowserEnv: hasStandardBrowserEnv,  hasStandardBrowserWebWorkerEnv: hasStandardBrowserWebWorkerEnv,  navigator: _navigator,  origin: origin}); var platform = {  ...utils,  ...platform$1,}; function toURLEncodedForm(data, options) {  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'));        return false;      }       return helpers.defaultVisitor.apply(this, arguments);    },    ...options,  });} /** * It takes a string like `foo[x][y][z]` and returns an array like `['foo', 'x', 'y', 'z'] * * @param {string} name - The name of the property to get. * * @returns An array of strings. */function parsePropPath(name) {  // foo[x][y][z]  // foo.x.y.z  // foo-x-y-z  // foo x y z  return utils$1.matchAll(/\w+|\[(\w*)]/g, name).map((match) => {    return match[0] === '[]' ? '' : match[1] || match[0];  });} /** * Convert an array to an object. * * @param {Array<any>} arr - The array to convert to an object. * * @returns An object with the same keys and values as the array. */function arrayToObject(arr) {  const obj = {};  const keys = Object.keys(arr);  let i;  const len = keys.length;  let key;  for (i = 0; i < len; i++) {    key = keys[i];    obj[key] = arr[key];  }  return obj;} /** * It takes a FormData object and returns a JavaScript object * * @param {string} formData The FormData object to convert to JSON. * * @returns {Object<string, any> | null} The converted object. */function formDataToJSON(formData) {  function buildPath(path, value, target, index) {    let name = path[index++];     if (name === '__proto__') return true;     const isNumericKey = Number.isFinite(+name);    const isLast = index >= path.length;    name = !name && utils$1.isArray(target) ? target.length : name;     if (isLast) {      if (utils$1.hasOwnProp(target, name)) {        target[name] = utils$1.isArray(target[name])          ? target[name].concat(value)          : [target[name], value];      } else {        target[name] = value;      }       return !isNumericKey;    }     if (!target[name] || !utils$1.isObject(target[name])) {      target[name] = [];    }     const result = buildPath(path, value, target[name], index);     if (result && utils$1.isArray(target[name])) {      target[name] = arrayToObject(target[name]);    }     return !isNumericKey;  }   if (utils$1.isFormData(formData) && utils$1.isFunction(formData.entries)) {    const obj = {};     utils$1.forEachEntry(formData, (name, value) => {      buildPath(parsePropPath(name), value, obj, 0);    });     return obj;  }   return null;} const own = (obj, key) => (obj != null && utils$1.hasOwnProp(obj, key) ? obj[key] : undefined); /** * It takes a string, tries to parse it, and if it fails, it returns the stringified version * of the input * * @param {any} rawValue - The value to be stringified. * @param {Function} parser - A function that parses a string into a JavaScript object. * @param {Function} encoder - A function that takes a value and returns a string. * * @returns {string} A stringified version of the rawValue. */function stringifySafely(rawValue, parser, encoder) {  if (utils$1.isString(rawValue)) {    try {      (parser || JSON.parse)(rawValue);      return utils$1.trim(rawValue);    } catch (e) {      if (e.name !== 'SyntaxError') {        throw e;      }    }  }   return (encoder || JSON.stringify)(rawValue);} const defaults = {  transitional: transitionalDefaults,   adapter: ['xhr', 'http', 'fetch'],   transformRequest: [    function transformRequest(data, headers) {      const contentType = headers.getContentType() || '';      const hasJSONContentType = contentType.indexOf('application/json') > -1;      const isObjectPayload = utils$1.isObject(data);       if (isObjectPayload && utils$1.isHTMLForm(data)) {        data = new FormData(data);      }       const isFormData = utils$1.isFormData(data);       if (isFormData) {        return hasJSONContentType ? JSON.stringify(formDataToJSON(data)) : data;      }       if (        utils$1.isArrayBuffer(data) ||        utils$1.isBuffer(data) ||        utils$1.isStream(data) ||        utils$1.isFile(data) ||        utils$1.isBlob(data) ||        utils$1.isReadableStream(data)      ) {        return data;      }      if (utils$1.isArrayBufferView(data)) {        return data.buffer;      }      if (utils$1.isURLSearchParams(data)) {        headers.setContentType('application/x-www-form-urlencoded;charset=utf-8', false);        return data.toString();      }       let isFileList;       if (isObjectPayload) {        const formSerializer = own(this, 'formSerializer');        if (contentType.indexOf('application/x-www-form-urlencoded') > -1) {          return toURLEncodedForm(data, formSerializer).toString();        }         if (          (isFileList = utils$1.isFileList(data)) ||          contentType.indexOf('multipart/form-data') > -1        ) {          const env = own(this, 'env');          const _FormData = env && env.FormData;           return toFormData(            isFileList ? { 'files[]': data } : data,            _FormData && new _FormData(),            formSerializer          );        }      }       if (isObjectPayload || hasJSONContentType) {        headers.setContentType('application/json', false);        return stringifySafely(data);      }       return data;    },  ],   transformResponse: [    function transformResponse(data) {      const transitional = own(this, 'transitional') || defaults.transitional;      const forcedJSONParsing = transitional && transitional.forcedJSONParsing;      const responseType = own(this, 'responseType');      const JSONRequested = responseType === 'json';       if (utils$1.isResponse(data) || utils$1.isReadableStream(data)) {        return data;      }       if (        data &&        utils$1.isString(data) &&        ((forcedJSONParsing && !responseType) || JSONRequested)      ) {        const silentJSONParsing = transitional && transitional.silentJSONParsing;        const strictJSONParsing = !silentJSONParsing && JSONRequested;         try {          return JSON.parse(data, own(this, 'parseReviver'));        } catch (e) {          if (strictJSONParsing) {            if (e.name === 'SyntaxError') {              throw AxiosError.from(e, AxiosError.ERR_BAD_RESPONSE, this, null, own(this, 'response'));            }            throw e;          }        }      }       return data;    },  ],   /**   * A timeout in milliseconds to abort a request. If set to 0 (default) a   * timeout is not created.   */  timeout: 0,   xsrfCookieName: 'XSRF-TOKEN',  xsrfHeaderName: 'X-XSRF-TOKEN',   maxContentLength: -1,  maxBodyLength: -1,   env: {    FormData: platform.classes.FormData,    Blob: platform.classes.Blob,  },   validateStatus: function validateStatus(status) {    return status >= 200 && status < 300;  },   headers: {    common: {      Accept: 'application/json, text/plain, */*',      'Content-Type': undefined,    },  },}; utils$1.forEach(['delete', 'get', 'head', 'post', 'put', 'patch'], (method) => {  defaults.headers[method] = {};}); // RawAxiosHeaders whose duplicates are ignored by node// c.f. https://nodejs.org/api/http.html#http_message_headersconst ignoreDuplicateOf = utils$1.toObjectSet([  'age',  'authorization',  'content-length',  'content-type',  'etag',  'expires',  'from',  'host',  'if-modified-since',  'if-unmodified-since',  'last-modified',  'location',  'max-forwards',  'proxy-authorization',  'referer',  'retry-after',  'user-agent',]); /** * Parse headers into an object * * ``` * Date: Wed, 27 Aug 2014 08:58:49 GMT * Content-Type: application/json * Connection: keep-alive * Transfer-Encoding: chunked * ``` * * @param {String} rawHeaders Headers needing to be parsed * * @returns {Object} Headers parsed into an object */var parseHeaders = (rawHeaders) => {  const parsed = {};  let key;  let val;  let i;   rawHeaders &&    rawHeaders.split('\n').forEach(function parser(line) {      i = line.indexOf(':');      key = line.substring(0, i).trim().toLowerCase();      val = line.substring(i + 1).trim();       if (!key || (parsed[key] && ignoreDuplicateOf[key])) {        return;      }       if (key === 'set-cookie') {        if (parsed[key]) {          parsed[key].push(val);        } else {          parsed[key] = [val];        }      } else {        parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;      }    });   return parsed;}; const $internals = Symbol('internals'); const INVALID_HEADER_VALUE_CHARS_RE = /[^\x09\x20-\x7E\x80-\xFF]/g; function trimSPorHTAB(str) {  let start = 0;  let end = str.length;   while (start < end) {    const code = str.charCodeAt(start);     if (code !== 0x09 && code !== 0x20) {      break;    }     start += 1;  }   while (end > start) {    const code = str.charCodeAt(end - 1);     if (code !== 0x09 && code !== 0x20) {      break;    }     end -= 1;  }   return start === 0 && end === str.length ? str : str.slice(start, end);} function normalizeHeader(header) {  return header && String(header).trim().toLowerCase();} function sanitizeHeaderValue(str) {  return trimSPorHTAB(str.replace(INVALID_HEADER_VALUE_CHARS_RE, ''));} function normalizeValue(value) {  if (value === false || value == null) {    return value;  }   return utils$1.isArray(value) ? value.map(normalizeValue) : sanitizeHeaderValue(String(value));} function parseTokens(str) {  const tokens = Object.create(null);  const tokensRE = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;  let match;   while ((match = tokensRE.exec(str))) {    tokens[match[1]] = match[2];  }   return tokens;} const isValidHeaderName = (str) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim()); function matchHeaderValue(context, value, header, filter, isHeaderNameFilter) {  if (utils$1.isFunction(filter)) {    return filter.call(this, value, header);  }   if (isHeaderNameFilter) {    value = header;  }   if (!utils$1.isString(value)) return;   if (utils$1.isString(filter)) {    return value.indexOf(filter) !== -1;  }   if (utils$1.isRegExp(filter)) {    return filter.test(value);  }} function formatHeader(header) {  return header    .trim()    .toLowerCase()    .replace(/([a-z\d])(\w*)/g, (w, char, str) => {      return char.toUpperCase() + str;    });} function buildAccessors(obj, header) {  const accessorName = utils$1.toCamelCase(' ' + header);   ['get', 'set', 'has'].forEach((methodName) => {    Object.defineProperty(obj, methodName + accessorName, {      value: function (arg1, arg2, arg3) {        return this[methodName].call(this, header, arg1, arg2, arg3);      },      configurable: true,    });  });} class AxiosHeaders {  constructor(headers) {    headers && this.set(headers);  }   set(header, valueOrRewrite, rewrite) {    const self = this;     function setHeader(_value, _header, _rewrite) {      const lHeader = normalizeHeader(_header);       if (!lHeader) {        throw new Error('header name must be a non-empty string');      }       const key = utils$1.findKey(self, lHeader);       if (        !key ||        self[key] === undefined ||        _rewrite === true ||        (_rewrite === undefined && self[key] !== false)      ) {        self[key || _header] = normalizeValue(_value);      }    }     const setHeaders = (headers, _rewrite) =>      utils$1.forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite));     if (utils$1.isPlainObject(header) || header instanceof this.constructor) {      setHeaders(header, valueOrRewrite);    } else if (utils$1.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {      setHeaders(parseHeaders(header), valueOrRewrite);    } else if (utils$1.isObject(header) && utils$1.isIterable(header)) {      let obj = {},        dest,        key;      for (const entry of header) {        if (!utils$1.isArray(entry)) {          throw TypeError('Object iterator must return a key-value pair');        }         obj[(key = entry[0])] = (dest = obj[key])          ? utils$1.isArray(dest)            ? [...dest, entry[1]]            : [dest, entry[1]]          : entry[1];      }       setHeaders(obj, valueOrRewrite);    } else {      header != null && setHeader(valueOrRewrite, header, rewrite);    }     return this;  }   get(header, parser) {    header = normalizeHeader(header);     if (header) {      const key = utils$1.findKey(this, header);       if (key) {        const value = this[key];         if (!parser) {          return value;        }         if (parser === true) {          return parseTokens(value);        }         if (utils$1.isFunction(parser)) {          return parser.call(this, value, key);        }         if (utils$1.isRegExp(parser)) {          return parser.exec(value);        }         throw new TypeError('parser must be boolean|regexp|function');      }    }  }   has(header, matcher) {    header = normalizeHeader(header);     if (header) {      const key = utils$1.findKey(this, header);       return !!(        key &&        this[key] !== undefined &&        (!matcher || matchHeaderValue(this, this[key], key, matcher))      );    }     return false;  }   delete(header, matcher) {    const self = this;    let deleted = false;     function deleteHeader(_header) {      _header = normalizeHeader(_header);       if (_header) {        const key = utils$1.findKey(self, _header);         if (key && (!matcher || matchHeaderValue(self, self[key], key, matcher))) {          delete self[key];           deleted = true;        }      }    }     if (utils$1.isArray(header)) {      header.forEach(deleteHeader);    } else {      deleteHeader(header);    }     return deleted;  }   clear(matcher) {    const keys = Object.keys(this);    let i = keys.length;    let deleted = false;     while (i--) {      const key = keys[i];      if (!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {        delete this[key];        deleted = true;      }    }     return deleted;  }   normalize(format) {    const self = this;    const headers = {};     utils$1.forEach(this, (value, header) => {      const key = utils$1.findKey(headers, header);       if (key) {        self[key] = normalizeValue(value);        delete self[header];        return;      }       const normalized = format ? formatHeader(header) : String(header).trim();       if (normalized !== header) {        delete self[header];      }       self[normalized] = normalizeValue(value);       headers[normalized] = true;    });     return this;  }   concat(...targets) {    return this.constructor.concat(this, ...targets);  }   toJSON(asStrings) {    const obj = Object.create(null);     utils$1.forEach(this, (value, header) => {      value != null &&        value !== false &&        (obj[header] = asStrings && utils$1.isArray(value) ? value.join(', ') : value);    });     return obj;  }   [Symbol.iterator]() {    return Object.entries(this.toJSON())[Symbol.iterator]();  }   toString() {    return Object.entries(this.toJSON())      .map(([header, value]) => header + ': ' + value)      .join('\n');  }   getSetCookie() {    return this.get('set-cookie') || [];  }   get [Symbol.toStringTag]() {    return 'AxiosHeaders';  }   static from(thing) {    return thing instanceof this ? thing : new this(thing);  }   static concat(first, ...targets) {    const computed = new this(first);     targets.forEach((target) => computed.set(target));     return computed;  }   static accessor(header) {    const internals =      (this[$internals] =      this[$internals] =        {          accessors: {},        });     const accessors = internals.accessors;    const prototype = this.prototype;     function defineAccessor(_header) {      const lHeader = normalizeHeader(_header);       if (!accessors[lHeader]) {        buildAccessors(prototype, _header);        accessors[lHeader] = true;      }    }     utils$1.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);     return this;  }} AxiosHeaders.accessor([  'Content-Type',  'Content-Length',  'Accept',  'Accept-Encoding',  'User-Agent',  'Authorization',]); // reserved names hotfixutils$1.reduceDescriptors(AxiosHeaders.prototype, ({ value }, key) => {  let mapped = key[0].toUpperCase() + key.slice(1); // map `set` => `Set`  return {    get: () => value,    set(headerValue) {      this[mapped] = headerValue;    },  };}); utils$1.freezeMethods(AxiosHeaders); /** * Transform the data for a request or a response * * @param {Array|Function} fns A single function or Array of functions * @param {?Object} response The response object * * @returns {*} The resulting transformed data */function transformData(fns, response) {  const config = this || defaults;  const context = response || config;  const headers = AxiosHeaders.from(context.headers);  let data = context.data;   utils$1.forEach(fns, function transform(fn) {    data = fn.call(config, data, headers.normalize(), response ? response.status : undefined);  });   headers.normalize();   return data;} function isCancel(value) {  return !!(value && value.__CANCEL__);} class CanceledError extends AxiosError {  /**   * 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.ERR_CANCELED, config, request);    this.name = 'CanceledError';    this.__CANCEL__ = true;  }} /** * Resolve or reject a Promise based on response status. * * @param {Function} resolve A function that resolves the promise. * @param {Function} reject A function that rejects the promise. * @param {object} response The response. * * @returns {object} The response. */function settle(resolve, reject, response) {  const validateStatus = response.config.validateStatus;  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      )    );  }} function parseProtocol(url) {  const match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url);  return (match && match[1]) || '';} /** * Calculate data maxRate * @param {Number} [samplesCount= 10] * @param {Number} [min= 1000] * @returns {Function} */function speedometer(samplesCount, min) {  samplesCount = samplesCount || 10;  const bytes = new Array(samplesCount);  const timestamps = new Array(samplesCount);  let head = 0;  let tail = 0;  let firstSampleTS;   min = min !== undefined ? min : 1000;   return function push(chunkLength) {    const now = Date.now();     const startedAt = timestamps[tail];     if (!firstSampleTS) {      firstSampleTS = now;    }     bytes[head] = chunkLength;    timestamps[head] = now;     let i = tail;    let bytesCount = 0;     while (i !== head) {      bytesCount += bytes[i++];      i = i % samplesCount;    }     head = (head + 1) % samplesCount;     if (head === tail) {      tail = (tail + 1) % samplesCount;    }     if (now - firstSampleTS < min) {      return;    }     const passed = startedAt && now - startedAt;     return passed ? Math.round((bytesCount * 1000) / passed) : undefined;  };} /** * Throttle decorator * @param {Function} fn * @param {Number} freq * @return {Function} */function throttle(fn, freq) {  let timestamp = 0;  let threshold = 1000 / freq;  let lastArgs;  let timer;   const invoke = (args, now = Date.now()) => {    timestamp = now;    lastArgs = null;    if (timer) {      clearTimeout(timer);      timer = null;    }    fn(...args);  };   const throttled = (...args) => {    const now = Date.now();    const passed = now - timestamp;    if (passed >= threshold) {      invoke(args, now);    } else {      lastArgs = args;      if (!timer) {        timer = setTimeout(() => {          timer = null;          invoke(lastArgs);        }, threshold - passed);      }    }  };   const flush = () => lastArgs && invoke(lastArgs);   return [throttled, flush];} const progressEventReducer = (listener, isDownloadStream, freq = 3) => {  let bytesNotified = 0;  const _speedometer = speedometer(50, 250);   return throttle((e) => {    const rawLoaded = e.loaded;    const total = e.lengthComputable ? e.total : undefined;    const loaded = total != null ? Math.min(rawLoaded, total) : rawLoaded;    const progressBytes = Math.max(0, loaded - bytesNotified);    const rate = _speedometer(progressBytes);     bytesNotified = Math.max(bytesNotified, loaded);     const data = {      loaded,      total,      progress: total ? loaded / total : undefined,      bytes: progressBytes,      rate: rate ? rate : undefined,      estimated: rate && total ? (total - loaded) / rate : undefined,      event: e,      lengthComputable: total != null,      [isDownloadStream ? 'download' : 'upload']: true,    };     listener(data);  }, freq);}; const progressEventDecorator = (total, throttled) => {  const lengthComputable = total != null;   return [    (loaded) =>      throttled[0]({        lengthComputable,        total,        loaded,      }),    throttled[1],  ];}; const asyncDecorator =  (fn) =>  (...args) =>    utils$1.asap(() => fn(...args)); var isURLSameOrigin = platform.hasStandardBrowserEnv  ? ((origin, isMSIE) => (url) => {      url = new URL(url, platform.origin);       return (        origin.protocol === url.protocol &&        origin.host === url.host &&        (isMSIE || origin.port === url.port)      );    })(      new URL(platform.origin),      platform.navigator && /(msie|trident)/i.test(platform.navigator.userAgent)    )  : () => true; var cookies = platform.hasStandardBrowserEnv  ? // Standard browser envs support document.cookie    {      write(name, value, expires, path, domain, secure, sameSite) {        if (typeof document === 'undefined') return;         const cookie = [`${name}=${encodeURIComponent(value)}`];         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) {        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, '/');      },    }  : // Non-standard browser env (web workers, react-native) lack needed support.    {      write() {},      read() {        return null;      },      remove() {},    }; /** * Determines whether the specified URL is absolute * * @param {string} url The URL to test * * @returns {boolean} True if the specified URL is absolute, otherwise false */function isAbsoluteURL(url) {  // A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL).  // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed  // by any combination of letters, digits, plus, period, or hyphen.  if (typeof url !== 'string') {    return false;  }   return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);} /** * Creates a new URL by combining the specified URLs * * @param {string} baseURL The base URL * @param {string} relativeURL The relative URL * * @returns {string} The combined URL */function combineURLs(baseURL, relativeURL) {  return relativeURL    ? baseURL.replace(/\/?\/$/, '') + '/' + relativeURL.replace(/^\/+/, '')    : baseURL;} /** * Creates a new URL by combining the baseURL with the requestedURL, * only when the requestedURL is not already an absolute URL. * If the requestURL is absolute, this function returns the requestedURL untouched. * * @param {string} baseURL The base URL * @param {string} requestedURL Absolute or relative URL to combine * * @returns {string} The combined full path */function buildFullPath(baseURL, requestedURL, allowAbsoluteUrls) {  let isRelativeUrl = !isAbsoluteURL(requestedURL);  if (baseURL && (isRelativeUrl || allowAbsoluteUrls === false)) {    return combineURLs(baseURL, requestedURL);  }  return requestedURL;} const headersToObject = (thing) => (thing instanceof AxiosHeaders ? { ...thing } : thing); /** * Config-specific merge-function which creates a new config-object * by merging two configuration objects together. * * @param {Object} config1 * @param {Object} config2 * * @returns {Object} New object resulting from merging config2 to config1 */function mergeConfig(config1, config2) {  // eslint-disable-next-line no-param-reassign  config2 = config2 || {};   // Use a null-prototype object so that downstream reads such as `config.auth`  // or `config.baseURL` cannot inherit polluted values from Object.prototype  // (see GHSA-q8qp-cvcw-x6jj). `hasOwnProperty` is restored as a non-enumerable  // own slot to preserve ergonomics for user code that relies on it.  const config = Object.create(null);  Object.defineProperty(config, 'hasOwnProperty', {    value: Object.prototype.hasOwnProperty,    enumerable: false,    writable: true,    configurable: true,  });   function getMergedValue(target, source, prop, caseless) {    if (utils$1.isPlainObject(target) && utils$1.isPlainObject(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)) {      return source.slice();    }    return source;  }   function mergeDeepProperties(a, b, prop, caseless) {    if (!utils$1.isUndefined(b)) {      return getMergedValue(a, b, prop, caseless);    } else if (!utils$1.isUndefined(a)) {      return getMergedValue(undefined, a, prop, caseless);    }  }   // eslint-disable-next-line consistent-return  function valueFromConfig2(a, b) {    if (!utils$1.isUndefined(b)) {      return getMergedValue(undefined, b);    }  }   // eslint-disable-next-line consistent-return  function defaultToConfig2(a, b) {    if (!utils$1.isUndefined(b)) {      return getMergedValue(undefined, b);    } else if (!utils$1.isUndefined(a)) {      return getMergedValue(undefined, a);    }  }   // eslint-disable-next-line consistent-return  function mergeDirectKeys(a, b, prop) {    if (utils$1.hasOwnProp(config2, prop)) {      return getMergedValue(a, b);    } else if (utils$1.hasOwnProp(config1, prop)) {      return getMergedValue(undefined, a);    }  }   const mergeMap = {    url: valueFromConfig2,    method: valueFromConfig2,    data: valueFromConfig2,    baseURL: defaultToConfig2,    transformRequest: defaultToConfig2,    transformResponse: defaultToConfig2,    paramsSerializer: defaultToConfig2,    timeout: defaultToConfig2,    timeoutMessage: defaultToConfig2,    withCredentials: defaultToConfig2,    withXSRFToken: defaultToConfig2,    adapter: defaultToConfig2,    responseType: defaultToConfig2,    xsrfCookieName: defaultToConfig2,    xsrfHeaderName: defaultToConfig2,    onUploadProgress: defaultToConfig2,    onDownloadProgress: defaultToConfig2,    decompress: defaultToConfig2,    maxContentLength: defaultToConfig2,    maxBodyLength: defaultToConfig2,    beforeRedirect: defaultToConfig2,    transport: defaultToConfig2,    httpAgent: defaultToConfig2,    httpsAgent: defaultToConfig2,    cancelToken: defaultToConfig2,    socketPath: defaultToConfig2,    allowedSocketPaths: defaultToConfig2,    responseEncoding: defaultToConfig2,    validateStatus: mergeDirectKeys,    headers: (a, b, prop) =>      mergeDeepProperties(headersToObject(a), headersToObject(b), prop, true),  };   utils$1.forEach(Object.keys({ ...config1, ...config2 }), function computeConfigValue(prop) {    if (prop === '__proto__' || prop === 'constructor' || prop === 'prototype') return;    const merge = utils$1.hasOwnProp(mergeMap, prop) ? mergeMap[prop] : mergeDeepProperties;    const a = utils$1.hasOwnProp(config1, prop) ? config1[prop] : undefined;    const b = utils$1.hasOwnProp(config2, prop) ? config2[prop] : undefined;    const configValue = merge(a, b, prop);    (utils$1.isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue);  });   return config;} var resolveConfig = (config) => {  const newConfig = mergeConfig({}, config);   // Read only own properties to prevent prototype pollution gadgets  // (e.g. Object.prototype.baseURL = 'https://evil.com'). See GHSA-q8qp-cvcw-x6jj.  const own = (key) => (utils$1.hasOwnProp(newConfig, key) ? newConfig[key] : undefined);   const data = own('data');  let withXSRFToken = own('withXSRFToken');  const xsrfHeaderName = own('xsrfHeaderName');  const xsrfCookieName = own('xsrfCookieName');  let headers = own('headers');  const auth = own('auth');  const baseURL = own('baseURL');  const allowAbsoluteUrls = own('allowAbsoluteUrls');  const url = own('url');   newConfig.headers = headers = AxiosHeaders.from(headers);   newConfig.url = buildURL(    buildFullPath(baseURL, url, allowAbsoluteUrls),    config.params,    config.paramsSerializer  );   // HTTP basic authentication  if (auth) {    headers.set(      'Authorization',      'Basic ' +        btoa(          (auth.username || '') +            ':' +            (auth.password ? unescape(encodeURIComponent(auth.password)) : '')        )    );  }   if (utils$1.isFormData(data)) {    if (platform.hasStandardBrowserEnv || platform.hasStandardBrowserWebWorkerEnv) {      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.  // Specifically not if we're in a web worker, or react-native.   if (platform.hasStandardBrowserEnv) {    if (utils$1.isFunction(withXSRFToken)) {      withXSRFToken = withXSRFToken(newConfig);    }     // Strict boolean check — prevents proto-pollution gadgets (e.g. Object.prototype.withXSRFToken = 1)    // and misconfigurations (e.g. "false") from short-circuiting the same-origin check and leaking    // the XSRF token cross-origin. See GHSA-xx6v-rp6x-q39c.    const shouldSendXSRF =      withXSRFToken === true ||      (withXSRFToken == null && isURLSameOrigin(newConfig.url));     if (shouldSendXSRF) {      const xsrfValue = xsrfHeaderName && xsrfCookieName && cookies.read(xsrfCookieName);       if (xsrfValue) {        headers.set(xsrfHeaderName, xsrfValue);      }    }  }   return newConfig;}; const isXHRAdapterSupported = typeof XMLHttpRequest !== 'undefined'; var xhrAdapter = isXHRAdapterSupported &&  function (config) {    return new Promise(function dispatchXhrRequest(resolve, reject) {      const _config = resolveConfig(config);      let requestData = _config.data;      const requestHeaders = AxiosHeaders.from(_config.headers).normalize();      let { responseType, onUploadProgress, onDownloadProgress } = _config;      let onCanceled;      let uploadThrottled, downloadThrottled;      let flushUpload, flushDownload;       function done() {        flushUpload && flushUpload(); // flush events        flushDownload && flushDownload(); // flush events         _config.cancelToken && _config.cancelToken.unsubscribe(onCanceled);         _config.signal && _config.signal.removeEventListener('abort', onCanceled);      }       let request = new XMLHttpRequest();       request.open(_config.method.toUpperCase(), _config.url, true);       // Set the request timeout in MS      request.timeout = _config.timeout;       function onloadend() {        if (!request) {          return;        }        // Prepare the response        const responseHeaders = AxiosHeaders.from(          'getAllResponseHeaders' in request && request.getAllResponseHeaders()        );        const responseData =          !responseType || responseType === 'text' || responseType === 'json'            ? request.responseText            : request.response;        const response = {          data: responseData,          status: request.status,          statusText: request.statusText,          headers: responseHeaders,          config,          request,        };         settle(          function _resolve(value) {            resolve(value);            done();          },          function _reject(err) {            reject(err);            done();          },          response        );         // Clean up request        request = null;      }       if ('onloadend' in request) {        // Use onloadend if available        request.onloadend = onloadend;      } else {        // Listen for ready state to emulate onloadend        request.onreadystatechange = function handleLoad() {          if (!request || request.readyState !== 4) {            return;          }           // The request errored out and we didn't get a response, this will be          // handled by onerror instead          // With one exception: request that using file: protocol, most browsers          // will return status as 0 even though it's a successful request          if (            request.status === 0 &&            !(request.responseURL && request.responseURL.indexOf('file:') === 0)          ) {            return;          }          // readystate handler is calling before onerror or ontimeout handlers,          // so we should call onloadend on the next 'tick'          setTimeout(onloadend);        };      }       // Handle browser request cancellation (as opposed to a manual cancellation)      request.onabort = function handleAbort() {        if (!request) {          return;        }         reject(new AxiosError('Request aborted', AxiosError.ECONNABORTED, config, request));         // Clean up request        request = null;      };       // Handle low level network errors      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(msg, AxiosError.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';        const transitional = _config.transitional || transitionalDefaults;        if (_config.timeoutErrorMessage) {          timeoutErrorMessage = _config.timeoutErrorMessage;        }        reject(          new AxiosError(            timeoutErrorMessage,            transitional.clarifyTimeoutError ? AxiosError.ETIMEDOUT : AxiosError.ECONNABORTED,            config,            request          )        );         // Clean up request        request = null;      };       // Remove Content-Type if data is undefined      requestData === undefined && requestHeaders.setContentType(null);       // Add headers to the request      if ('setRequestHeader' in request) {        utils$1.forEach(requestHeaders.toJSON(), function setRequestHeader(val, key) {          request.setRequestHeader(key, val);        });      }       // Add withCredentials to request if needed      if (!utils$1.isUndefined(_config.withCredentials)) {        request.withCredentials = !!_config.withCredentials;      }       // Add responseType to request if needed      if (responseType && responseType !== 'json') {        request.responseType = _config.responseType;      }       // Handle progress if needed      if (onDownloadProgress) {        [downloadThrottled, flushDownload] = progressEventReducer(onDownloadProgress, true);        request.addEventListener('progress', downloadThrottled);      }       // Not all browsers support upload events      if (onUploadProgress && request.upload) {        [uploadThrottled, flushUpload] = progressEventReducer(onUploadProgress);         request.upload.addEventListener('progress', uploadThrottled);         request.upload.addEventListener('loadend', flushUpload);      }       if (_config.cancelToken || _config.signal) {        // Handle cancellation        // eslint-disable-next-line func-names        onCanceled = (cancel) => {          if (!request) {            return;          }          reject(!cancel || cancel.type ? new CanceledError(null, config, request) : cancel);          request.abort();          request = null;        };         _config.cancelToken && _config.cancelToken.subscribe(onCanceled);        if (_config.signal) {          _config.signal.aborted            ? onCanceled()            : _config.signal.addEventListener('abort', onCanceled);        }      }       const protocol = parseProtocol(_config.url);       if (protocol && platform.protocols.indexOf(protocol) === -1) {        reject(          new AxiosError(            'Unsupported protocol ' + protocol + ':',            AxiosError.ERR_BAD_REQUEST,            config          )        );        return;      }       // Send the request      request.send(requestData || null);    });  }; const composeSignals = (signals, timeout) => {  const { length } = (signals = signals ? signals.filter(Boolean) : []);   if (timeout || length) {    let controller = new AbortController();     let aborted;     const onabort = function (reason) {      if (!aborted) {        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)        );      }    };     let timer =      timeout &&      setTimeout(() => {        timer = null;        onabort(new AxiosError(`timeout of ${timeout}ms exceeded`, AxiosError.ETIMEDOUT));      }, timeout);     const unsubscribe = () => {      if (signals) {        timer && clearTimeout(timer);        timer = null;        signals.forEach((signal) => {          signal.unsubscribe            ? signal.unsubscribe(onabort)            : signal.removeEventListener('abort', onabort);        });        signals = null;      }    };     signals.forEach((signal) => signal.addEventListener('abort', onabort));     const { signal } = controller;     signal.unsubscribe = () => utils$1.asap(unsubscribe);     return signal;  }}; const streamChunk = function* (chunk, chunkSize) {  let len = chunk.byteLength;   if (len < chunkSize) {    yield chunk;    return;  }   let pos = 0;  let end;   while (pos < len) {    end = pos + chunkSize;    yield chunk.slice(pos, end);    pos = end;  }}; const readBytes = async function* (iterable, chunkSize) {  for await (const chunk of readStream(iterable)) {    yield* streamChunk(chunk, chunkSize);  }}; const readStream = async function* (stream) {  if (stream[Symbol.asyncIterator]) {    yield* stream;    return;  }   const reader = stream.getReader();  try {    for (;;) {      const { done, value } = await reader.read();      if (done) {        break;      }      yield value;    }  } finally {    await reader.cancel();  }}; const trackStream = (stream, chunkSize, onProgress, onFinish) => {  const iterator = readBytes(stream, chunkSize);   let bytes = 0;  let done;  let _onFinish = (e) => {    if (!done) {      done = true;      onFinish && onFinish(e);    }  };   return new ReadableStream(    {      async pull(controller) {        try {          const { done, value } = await iterator.next();           if (done) {            _onFinish();            controller.close();            return;          }           let len = value.byteLength;          if (onProgress) {            let loadedBytes = (bytes += len);            onProgress(loadedBytes);          }          controller.enqueue(new Uint8Array(value));        } catch (err) {          _onFinish(err);          throw err;        }      },      cancel(reason) {        _onFinish(reason);        return iterator.return();      },    },    {      highWaterMark: 2,    }  );}; 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; const test = (fn, ...args) => {  try {    return !!fn(...args);  } catch (e) {    return false;  }}; const factory = (env) => {  env = utils$1.merge.call(    {      skipUndefined: true,    },    globalFetchAPI,    env  );   const { fetch: envFetch, Request, Response } = env;  const isFetchSupported = envFetch ? isFunction(envFetch) : typeof fetch === 'function';  const isRequestSupported = isFunction(Request);  const isResponseSupported = isFunction(Response);   if (!isFetchSupported) {    return false;  }   const isReadableStreamSupported = isFetchSupported && isFunction(ReadableStream$1);   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 request = new Request(platform.origin, {        body: new ReadableStream$1(),        method: 'POST',        get duplex() {          duplexAccessed = true;          return 'half';        },      });       const hasContentType = request.headers.has('Content-Type');       if (request.body != null) {        request.body.cancel();      }       return duplexAccessed && !hasContentType;    });   const supportsResponseStream =    isResponseSupported &&    isReadableStreamSupported &&    test(() => utils$1.isReadableStream(new Response('').body));   const resolvers = {    stream: supportsResponseStream && ((res) => res.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(              `Response type '${type}' is not supported`,              AxiosError.ERR_NOT_SUPPORT,              config            );          });      });    })();   const getBodyLength = async (body) => {    if (body == null) {      return 0;    }     if (utils$1.isBlob(body)) {      return body.size;    }     if (utils$1.isSpecCompliantForm(body)) {      const _request = new Request(platform.origin, {        method: 'POST',        body,      });      return (await _request.arrayBuffer()).byteLength;    }     if (utils$1.isArrayBufferView(body) || utils$1.isArrayBuffer(body)) {      return body.byteLength;    }     if (utils$1.isURLSearchParams(body)) {      body = body + '';    }     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(      [signal, cancelToken && cancelToken.toAbortSignal()],      timeout    );     let request = null;     const unsubscribe =      composedSignal &&      composedSignal.unsubscribe &&      (() => {        composedSignal.unsubscribe();      });     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',        });         let 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))          );           data = trackStream(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush);        }      }       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 = isRequestSupported && 'credentials' in Request.prototype;       // If data is FormData and Content-Type is multipart/form-data without boundary,      // delete it so fetch can set it correctly with the boundary      if (utils$1.isFormData(data)) {        const contentType = headers.getContentType();        if (          contentType &&          /^multipart\/form-data/i.test(contentType) &&          !/boundary=/i.test(contentType)        ) {          headers.delete('content-type');        }      }       const resolvedOptions = {        ...fetchOptions,        signal: composedSignal,        method: method.toUpperCase(),        headers: headers.normalize().toJSON(),        body: data,        duplex: 'half',        credentials: isCredentialsSupported ? withCredentials : undefined,      };       request = isRequestSupported && new Request(url, resolvedOptions);       let response = await (isRequestSupported        ? _fetch(request, fetchOptions)        : _fetch(url, resolvedOptions));       const isStreamResponse =        supportsResponseStream && (responseType === 'stream' || responseType === 'response');       if (supportsResponseStream && (onDownloadProgress || (isStreamResponse && unsubscribe))) {        const options = {};         ['status', 'statusText', 'headers'].forEach((prop) => {          options[prop] = response[prop];        });         const responseContentLength = utils$1.toFiniteNumber(response.headers.get('content-length'));         const [onProgress, flush] =          (onDownloadProgress &&            progressEventDecorator(              responseContentLength,              progressEventReducer(asyncDecorator(onDownloadProgress), true)            )) ||          [];         response = new Response(          trackStream(response.body, DEFAULT_CHUNK_SIZE, onProgress, () => {            flush && flush();            unsubscribe && unsubscribe();          }),          options        );      }       responseType = responseType || 'text';       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.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,            err && err.response          ),          {            cause: err.cause || err,          }        );      }       throw AxiosError.from(err, err && err.code, config, request, err && err.response);    }  };}; 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;   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: {    get: getFetch,  },}; // Assign adapter names for easier debugging and identificationutils$1.forEach(knownAdapters, (fn, value) => {  if (fn) {    try {      Object.defineProperty(fn, 'name', { value });    } catch (e) {      // eslint-disable-next-line no-empty    }    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; /** * 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 rejectedReasons = {};   for (let i = 0; i < length; i++) {    nameOrAdapter = adapters[i];    let id;     adapter = nameOrAdapter;     if (!isResolvedHandle(nameOrAdapter)) {      adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];       if (adapter === undefined) {        throw new AxiosError(`Unknown adapter '${id}'`);      }    }     if (adapter && (utils$1.isFunction(adapter) || (adapter = adapter.get(config)))) {      break;    }     rejectedReasons[id || '#' + i] = adapter;  }   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';     throw new AxiosError(      `There is no suitable adapter to dispatch the request ` + s,      'ERR_NOT_SUPPORT'    );  }   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,}; /** * Throws a `CanceledError` if cancellation has been requested. * * @param {Object} config The config that is to be used for the request * * @returns {void} */function throwIfCancellationRequested(config) {  if (config.cancelToken) {    config.cancelToken.throwIfRequested();  }   if (config.signal && config.signal.aborted) {    throw new CanceledError(null, config);  }} /** * Dispatch a request to the server using the configured adapter. * * @param {object} config The config that is to be used for the request * * @returns {Promise} The Promise to be fulfilled */function dispatchRequest(config) {  throwIfCancellationRequested(config);   config.headers = AxiosHeaders.from(config.headers);   // Transform request data  config.data = transformData.call(config, config.transformRequest);   if (['post', 'put', 'patch'].indexOf(config.method) !== -1) {    config.headers.setContentType('application/x-www-form-urlencoded', false);  }   const adapter = adapters.getAdapter(config.adapter || defaults.adapter, config);   return adapter(config).then(    function onAdapterResolution(response) {      throwIfCancellationRequested(config);       // 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)) {        throwIfCancellationRequested(config);         // Transform response data        if (reason && reason.response) {          reason.response.data = transformData.call(            config,            config.transformResponse,            reason.response          );          reason.response.headers = AxiosHeaders.from(reason.response.headers);        }      }       return Promise.reject(reason);    }  );} const VERSION = "1.15.2"; const validators$1 = {}; // eslint-disable-next-line func-names['object', 'boolean', 'number', 'function', 'string', 'symbol'].forEach((type, i) => {  validators$1[type] = function validator(thing) {    return typeof thing === type || 'a' + (i < 1 ? 'n ' : ' ') + type;  };}); const deprecatedWarnings = {}; /** * Transitional option validator * * @param {function|boolean?} validator - set to false if the transitional option has been removed * @param {string?} version - deprecated version / removed since version * @param {string?} message - some message with additional info * * @returns {function} */validators$1.transitional = function transitional(validator, version, message) {  function formatMessage(opt, desc) {    return (      '[Axios v' +      VERSION +      "] Transitional option '" +      opt +      "'" +      desc +      (message ? '. ' + message : '')    );  }   // eslint-disable-next-line func-names  return (value, opt, opts) => {    if (validator === false) {      throw new AxiosError(        formatMessage(opt, ' has been removed' + (version ? ' in ' + version : '')),        AxiosError.ERR_DEPRECATED      );    }     if (version && !deprecatedWarnings[opt]) {      deprecatedWarnings[opt] = true;      // eslint-disable-next-line no-console      console.warn(        formatMessage(          opt,          ' has been deprecated since v' + version + ' and will be removed in the near future'        )      );    }     return validator ? validator(value, opt, opts) : true;  };}; validators$1.spelling = function spelling(correctSpelling) {  return (value, opt) => {    // eslint-disable-next-line no-console    console.warn(`${opt} is likely a misspelling of ${correctSpelling}`);    return true;  };}; /** * Assert object's properties type * * @param {object} options * @param {object} schema * @param {boolean?} allowUnknown * * @returns {object} */ function assertOptions(options, schema, allowUnknown) {  if (typeof options !== 'object') {    throw new AxiosError('options must be an object', AxiosError.ERR_BAD_OPTION_VALUE);  }  const keys = Object.keys(options);  let i = keys.length;  while (i-- > 0) {    const opt = keys[i];    // Use hasOwnProperty so a polluted Object.prototype.<opt> cannot supply    // a non-function validator and cause a TypeError. See GHSA-q8qp-cvcw-x6jj.    const validator = Object.prototype.hasOwnProperty.call(schema, opt) ? schema[opt] : undefined;    if (validator) {      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        );      }      continue;    }    if (allowUnknown !== true) {      throw new AxiosError('Unknown option ' + opt, AxiosError.ERR_BAD_OPTION);    }  }} var validator = {  assertOptions,  validators: validators$1,}; const validators = validator.validators; /** * Create a new instance of Axios * * @param {Object} instanceConfig The default config for the instance * * @return {Axios} A new instance of Axios */class Axios {  constructor(instanceConfig) {    this.defaults = instanceConfig || {};    this.interceptors = {      request: new InterceptorManager(),      response: new InterceptorManager(),    };  }   /**   * Dispatch a request   *   * @param {String|Object} configOrUrl The config specific for this request (merged with this.defaults)   * @param {?Object} config   *   * @returns {Promise} The Promise to be fulfilled   */  async request(configOrUrl, config) {    try {      return await this._request(configOrUrl, config);    } catch (err) {      if (err instanceof Error) {        let dummy = {};         Error.captureStackTrace ? Error.captureStackTrace(dummy) : (dummy = new Error());         // slice off the Error: ... line        const stack = (() => {          if (!dummy.stack) {            return '';          }           const firstNewlineIndex = dummy.stack.indexOf('\n');           return firstNewlineIndex === -1 ? '' : dummy.stack.slice(firstNewlineIndex + 1);        })();        try {          if (!err.stack) {            err.stack = stack;            // match without the 2 top stack lines          } else if (stack) {            const firstNewlineIndex = stack.indexOf('\n');            const secondNewlineIndex =              firstNewlineIndex === -1 ? -1 : stack.indexOf('\n', firstNewlineIndex + 1);            const stackWithoutTwoTopLines =              secondNewlineIndex === -1 ? '' : stack.slice(secondNewlineIndex + 1);             if (!String(err.stack).endsWith(stackWithoutTwoTopLines)) {              err.stack += '\n' + stack;            }          }        } catch (e) {          // ignore the case where "stack" is an un-writable property        }      }       throw err;    }  }   _request(configOrUrl, config) {    /*eslint no-param-reassign:0*/    // Allow for axios('example/url'[, config]) a la fetch API    if (typeof configOrUrl === 'string') {      config = config || {};      config.url = configOrUrl;    } else {      config = configOrUrl || {};    }     config = mergeConfig(this.defaults, config);     const { transitional, paramsSerializer, headers } = config;     if (transitional !== undefined) {      validator.assertOptions(        transitional,        {          silentJSONParsing: validators.transitional(validators.boolean),          forcedJSONParsing: validators.transitional(validators.boolean),          clarifyTimeoutError: validators.transitional(validators.boolean),          legacyInterceptorReqResOrdering: validators.transitional(validators.boolean),        },        false      );    }     if (paramsSerializer != null) {      if (utils$1.isFunction(paramsSerializer)) {        config.paramsSerializer = {          serialize: paramsSerializer,        };      } else {        validator.assertOptions(          paramsSerializer,          {            encode: validators.function,            serialize: validators.function,          },          true        );      }    }     // Set config.allowAbsoluteUrls    if (config.allowAbsoluteUrls !== undefined) ; else if (this.defaults.allowAbsoluteUrls !== undefined) {      config.allowAbsoluteUrls = this.defaults.allowAbsoluteUrls;    } else {      config.allowAbsoluteUrls = true;    }     validator.assertOptions(      config,      {        baseUrl: validators.spelling('baseURL'),        withXsrfToken: validators.spelling('withXSRFToken'),      },      true    );     // Set config.method    config.method = (config.method || this.defaults.method || 'get').toLowerCase();     // Flatten headers    let contextHeaders = headers && utils$1.merge(headers.common, headers[config.method]);     headers &&      utils$1.forEach(['delete', 'get', 'head', 'post', 'put', 'patch', 'common'], (method) => {        delete headers[method];      });     config.headers = AxiosHeaders.concat(contextHeaders, headers);     // filter out skipped interceptors    const requestInterceptorChain = [];    let synchronousRequestInterceptors = true;    this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {      if (typeof interceptor.runWhen === 'function' && interceptor.runWhen(config) === false) {        return;      }       synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;       const transitional = config.transitional || transitionalDefaults;      const legacyInterceptorReqResOrdering =        transitional && transitional.legacyInterceptorReqResOrdering;       if (legacyInterceptorReqResOrdering) {        requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);      } else {        requestInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);      }    });     const responseInterceptorChain = [];    this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {      responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);    });     let promise;    let i = 0;    let len;     if (!synchronousRequestInterceptors) {      const chain = [dispatchRequest.bind(this), undefined];      chain.unshift(...requestInterceptorChain);      chain.push(...responseInterceptorChain);      len = chain.length;       promise = Promise.resolve(config);       while (i < len) {        promise = promise.then(chain[i++], chain[i++]);      }       return promise;    }     len = requestInterceptorChain.length;     let newConfig = config;     while (i < len) {      const onFulfilled = requestInterceptorChain[i++];      const onRejected = requestInterceptorChain[i++];      try {        newConfig = onFulfilled(newConfig);      } catch (error) {        onRejected.call(this, error);        break;      }    }     try {      promise = dispatchRequest.call(this, newConfig);    } catch (error) {      return Promise.reject(error);    }     i = 0;    len = responseInterceptorChain.length;     while (i < len) {      promise = promise.then(responseInterceptorChain[i++], responseInterceptorChain[i++]);    }     return promise;  }   getUri(config) {    config = mergeConfig(this.defaults, config);    const fullPath = buildFullPath(config.baseURL, config.url, config.allowAbsoluteUrls);    return buildURL(fullPath, config.params, config.paramsSerializer);  }} // Provide aliases for supported request methodsutils$1.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) {  /*eslint func-names:0*/  Axios.prototype[method] = function (url, config) {    return this.request(      mergeConfig(config || {}, {        method,        url,        data: (config || {}).data,      })    );  };}); utils$1.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {  function generateHTTPMethod(isForm) {    return function httpMethod(url, data, config) {      return this.request(        mergeConfig(config || {}, {          method,          headers: isForm            ? {                'Content-Type': 'multipart/form-data',              }            : {},          url,          data,        })      );    };  }   Axios.prototype[method] = generateHTTPMethod();   Axios.prototype[method + 'Form'] = generateHTTPMethod(true);}); /** * A `CancelToken` is an object that can be used to request cancellation of an operation. * * @param {Function} executor The executor function. * * @returns {CancelToken} */class CancelToken {  constructor(executor) {    if (typeof executor !== 'function') {      throw new TypeError('executor must be a function.');    }     let resolvePromise;     this.promise = new Promise(function promiseExecutor(resolve) {      resolvePromise = resolve;    });     const token = this;     // eslint-disable-next-line func-names    this.promise.then((cancel) => {      if (!token._listeners) return;       let i = token._listeners.length;       while (i-- > 0) {        token._listeners[i](cancel);      }      token._listeners = null;    });     // eslint-disable-next-line func-names    this.promise.then = (onfulfilled) => {      let _resolve;      // eslint-disable-next-line func-names      const promise = new Promise((resolve) => {        token.subscribe(resolve);        _resolve = resolve;      }).then(onfulfilled);       promise.cancel = function reject() {        token.unsubscribe(_resolve);      };       return promise;    };     executor(function cancel(message, config, request) {      if (token.reason) {        // Cancellation has already been requested        return;      }       token.reason = new CanceledError(message, config, request);      resolvePromise(token.reason);    });  }   /**   * Throws a `CanceledError` if cancellation has been requested.   */  throwIfRequested() {    if (this.reason) {      throw this.reason;    }  }   /**   * Subscribe to the cancel signal   */   subscribe(listener) {    if (this.reason) {      listener(this.reason);      return;    }     if (this._listeners) {      this._listeners.push(listener);    } else {      this._listeners = [listener];    }  }   /**   * Unsubscribe from the cancel signal   */   unsubscribe(listener) {    if (!this._listeners) {      return;    }    const index = this._listeners.indexOf(listener);    if (index !== -1) {      this._listeners.splice(index, 1);    }  }   toAbortSignal() {    const controller = new AbortController();     const abort = (err) => {      controller.abort(err);    };     this.subscribe(abort);     controller.signal.unsubscribe = () => this.unsubscribe(abort);     return controller.signal;  }   /**   * Returns an object that contains a new `CancelToken` and a function that, when called,   * cancels the `CancelToken`.   */  static source() {    let cancel;    const token = new CancelToken(function executor(c) {      cancel = c;    });    return {      token,      cancel,    };  }} /** * Syntactic sugar for invoking a function and expanding an array for arguments. * * Common use case would be to use `Function.prototype.apply`. * *  ```js *  function f(x, y, z) {} *  const args = [1, 2, 3]; *  f.apply(null, args); *  ``` * * With `spread` this example can be re-written. * *  ```js *  spread(function(x, y, z) {})([1, 2, 3]); *  ``` * * @param {Function} callback * * @returns {Function} */function spread(callback) {  return function wrap(arr) {    return callback.apply(null, arr);  };} /** * Determines whether the payload is an error thrown by Axios * * @param {*} payload The value to test * * @returns {boolean} True if the payload is an error thrown by Axios, otherwise false */function isAxiosError(payload) {  return utils$1.isObject(payload) && payload.isAxiosError === true;} const HttpStatusCode = {  Continue: 100,  SwitchingProtocols: 101,  Processing: 102,  EarlyHints: 103,  Ok: 200,  Created: 201,  Accepted: 202,  NonAuthoritativeInformation: 203,  NoContent: 204,  ResetContent: 205,  PartialContent: 206,  MultiStatus: 207,  AlreadyReported: 208,  ImUsed: 226,  MultipleChoices: 300,  MovedPermanently: 301,  Found: 302,  SeeOther: 303,  NotModified: 304,  UseProxy: 305,  Unused: 306,  TemporaryRedirect: 307,  PermanentRedirect: 308,  BadRequest: 400,  Unauthorized: 401,  PaymentRequired: 402,  Forbidden: 403,  NotFound: 404,  MethodNotAllowed: 405,  NotAcceptable: 406,  ProxyAuthenticationRequired: 407,  RequestTimeout: 408,  Conflict: 409,  Gone: 410,  LengthRequired: 411,  PreconditionFailed: 412,  PayloadTooLarge: 413,  UriTooLong: 414,  UnsupportedMediaType: 415,  RangeNotSatisfiable: 416,  ExpectationFailed: 417,  ImATeapot: 418,  MisdirectedRequest: 421,  UnprocessableEntity: 422,  Locked: 423,  FailedDependency: 424,  TooEarly: 425,  UpgradeRequired: 426,  PreconditionRequired: 428,  TooManyRequests: 429,  RequestHeaderFieldsTooLarge: 431,  UnavailableForLegalReasons: 451,  InternalServerError: 500,  NotImplemented: 501,  BadGateway: 502,  ServiceUnavailable: 503,  GatewayTimeout: 504,  HttpVersionNotSupported: 505,  VariantAlsoNegotiates: 506,  InsufficientStorage: 507,  LoopDetected: 508,  NotExtended: 510,  NetworkAuthenticationRequired: 511,  WebServerIsDown: 521,  ConnectionTimedOut: 522,  OriginIsUnreachable: 523,  TimeoutOccurred: 524,  SslHandshakeFailed: 525,  InvalidSslCertificate: 526,}; Object.entries(HttpStatusCode).forEach(([key, value]) => {  HttpStatusCode[value] = key;}); /** * Create an instance of Axios * * @param {Object} defaultConfig The default config for the instance * * @returns {Axios} A new instance of Axios */function createInstance(defaultConfig) {  const context = new Axios(defaultConfig);  const instance = bind(Axios.prototype.request, context);   // Copy axios.prototype to instance  utils$1.extend(instance, Axios.prototype, context, { allOwnKeys: true });   // Copy context to instance  utils$1.extend(instance, context, null, { allOwnKeys: true });   // Factory for creating new instances  instance.create = function create(instanceConfig) {    return createInstance(mergeConfig(defaultConfig, instanceConfig));  };   return instance;} // Create the default instance to be exportedconst axios = createInstance(defaults); // Expose Axios class to allow class inheritanceaxios.Axios = Axios; // Expose Cancel & CancelTokenaxios.CanceledError = CanceledError;axios.CancelToken = CancelToken;axios.isCancel = isCancel;axios.VERSION = VERSION;axios.toFormData = toFormData; // Expose AxiosError classaxios.AxiosError = AxiosError; // alias for CanceledError for backward compatibilityaxios.Cancel = axios.CanceledError; // Expose all/spreadaxios.all = function all(promises) {  return Promise.all(promises);}; axios.spread = spread; // Expose isAxiosErroraxios.isAxiosError = isAxiosError; // Expose mergeConfigaxios.mergeConfig = mergeConfig; axios.AxiosHeaders = AxiosHeaders; axios.formToJSON = (thing) => formDataToJSON(utils$1.isHTMLForm(thing) ? new FormData(thing) : thing); axios.getAdapter = adapters.getAdapter; axios.HttpStatusCode = HttpStatusCode; axios.default = axios; module.exports = axios;//# sourceMappingURL=axios.cjs.map