/proc/self/root/proc/4/root/var/runtime/node_modules/@aws-sdk/node_modules/axios/dist/node
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 v1.19.0 Copyright (c) 2026 Matt Zabriskie and contributors */'use strict'; var FormData$1 = require('form-data');var crypto = require('crypto');var url = require('url');var HttpsProxyAgent = require('https-proxy-agent');var http = require('http');var https = require('https');var http2 = require('http2');var util = require('util');var path = require('path');var followRedirects = require('follow-redirects');var zlib = require('zlib');var stream = require('stream');var events = require('events'); /** * 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; /* Creating a function that will check if an object has a property. */const hasOwnProperty = (({ hasOwnProperty}) => (obj, prop) => hasOwnProperty.call(obj, prop))(Object.prototype); /** * Walk the prototype chain (excluding the shared Object.prototype) looking for * an own `prop`. This distinguishes genuine own/inherited members — including * class accessors and template prototypes — from members injected via * Object.prototype pollution (e.g. `Object.prototype.username = '...'`), which * live on Object.prototype itself and are therefore never matched. * * @param {*} thing The value whose chain to inspect * @param {string|symbol} prop The property key to look for * * @returns {boolean} True when `prop` is owned below Object.prototype */const hasOwnInPrototypeChain = (thing, prop) => { let obj = thing; const seen = []; while (obj != null && obj !== Object.prototype) { if (seen.indexOf(obj) !== -1) { return false; } seen.push(obj); if (hasOwnProperty(obj, prop)) { return true; } obj = getPrototypeOf(obj); } return false;}; /** * Read `obj[prop]` only when it is safe from Object.prototype pollution. Own * properties and members inherited from a non-Object.prototype source (a class * instance or template object) are honored; a value reachable only through a * polluted Object.prototype is ignored and `undefined` is returned. * * @param {*} obj The source object * @param {string|symbol} prop The property key to read * * @returns {*} The resolved value, or undefined when unsafe/absent */const getSafeProp = (obj, prop) => obj != null && hasOwnInPrototypeChain(obj, prop) ? obj[prop] : undefined;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 (!isObject(val)) { return false; } const prototype = getPrototypeOf(val); return (prototype === null || prototype === Object.prototype || getPrototypeOf(prototype) === null) && // Treat any genuine (non-Object.prototype-polluted) Symbol.toStringTag or // Symbol.iterator as evidence the value is a tagged/iterable type rather // than a plain object, while ignoring keys injected onto Object.prototype. !hasOwnInPrototypeChain(val, toStringTag) && !hasOwnInPrototypeChain(val, iterator);}; /** * 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 FileList, otherwise false */const isFileList = kindOfTest('FileList');const isSet = kindOfTest('Set'); /** * 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. 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(...objs) { 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; } // findKey lowercases the key, so caseless lookup only applies to strings — // symbol keys are identity-matched. const targetKey = caseless && typeof key === 'string' && findKey(result, key) || key; // Read via own-prop only — a bare `result[targetKey]` walks the prototype // chain, so a polluted Object.prototype value could surface here and get // copied into the merged result. const existing = hasOwnProperty(result, targetKey) ? result[targetKey] : undefined; if (isPlainObject(existing) && isPlainObject(val)) { result[targetKey] = merge(existing, 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 = objs.length; i < l; i++) { const source = objs[i]; if (!source || isBuffer(source)) { continue; } forEach(source, assignValue); if (typeof source !== 'object' || isArray(source)) { continue; } const symbols = Object.getOwnPropertySymbols(source); for (let j = 0; j < symbols.length; j++) { const symbol = symbols[j]; if (propertyIsEnumerable.call(source, symbol)) { assignValue(source[symbol], symbol); } } } 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, { // Null-proto descriptor so a polluted Object.prototype.get cannot // hijack defineProperty's accessor-vs-data resolution. __proto__: null, value: bind(val, thisArg), writable: true, enumerable: true, configurable: true }); } else { Object.defineProperty(a, key, { __proto__: null, 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', { __proto__: null, value: constructor, writable: true, enumerable: false, configurable: true }); Object.defineProperty(constructor, 'super', { __proto__: null, 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; });};const { propertyIsEnumerable} = 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'].includes(name)) { 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 visited = new WeakSet(); const visit = source => { if (isObject(source)) { if (visited.has(source)) { return; } //Buffer check if (isBuffer(source)) { return source; } if (!('toJSON' in source)) { // add-on descent / delete-on-ascent: preserves path semantics, so DAG nodes serialise at every occurrence (see #7230). visited.add(source); let target; if (isSet(source)) { target = []; for (const value of source) { const reducedValue = visit(value); !isUndefined(reducedValue) && target.push(reducedValue); } } else { target = isArray(source) ? [] : {}; forEach(source, (value, key) => { const reducedValue = visit(value); !isUndefined(reducedValue) && (target[key] = reducedValue); }); } visited.delete(source); return target; } } return source; }; return visit(obj);}; /** * 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]); /** * Determine if a value is iterable via an iterator that is NOT sourced solely * from a polluted Object.prototype. Use this instead of `isIterable` whenever * the iterable comes from untrusted input (e.g. user-supplied header sources), * so `Object.prototype[Symbol.iterator] = ...` cannot turn an ordinary object * into an attacker-controlled entries iterator. * * @param {*} thing The value to test * * @returns {boolean} True if value has a non-polluted iterator */const isSafeIterable = thing => thing != null && hasOwnInPrototypeChain(thing, iterator) && isIterable(thing);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 hasOwnInPrototypeChain, getSafeProp, reduceDescriptors, freezeMethods, toObjectSet, toCamelCase, noop, toFiniteNumber, findKey, global: _global, isContextDefined, isSpecCompliantForm, toJSONObject, isAsyncFn, isThenable, setImmediate: _setImmediate, asap, isIterable, isSafeIterable}; // 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(); const hasKey = utils$1.hasOwnProp(parsed, key); if (!key || hasKey && utils$1.hasOwnProp(ignoreDuplicateOf, key)) { return; } if (key === 'set-cookie') { if (hasKey) { parsed[key].push(val); } else { parsed[key] = [val]; } } else { parsed[key] = hasKey ? parsed[key] + ', ' + val : val; } }); return parsed;}; 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);} // The control-code ranges are intentional: header sanitization strips C0/DEL bytes.// eslint-disable-next-line no-control-regexconst INVALID_UNICODE_HEADER_VALUE_CHARS = new RegExp('[\\u0000-\\u0008\\u000a-\\u001f\\u007f]+', 'g');// eslint-disable-next-line no-control-regexconst INVALID_BYTE_STRING_HEADER_VALUE_CHARS = new RegExp('[^\\u0009\\u0020-\\u007e\\u0080-\\u00ff]+', 'g');function sanitizeValue(value, invalidChars) { if (utils$1.isArray(value)) { return value.map(item => sanitizeValue(item, invalidChars)); } return trimSPorHTAB(String(value).replace(invalidChars, ''));}const sanitizeHeaderValue = value => sanitizeValue(value, INVALID_UNICODE_HEADER_VALUE_CHARS);const sanitizeByteStringHeaderValue = value => sanitizeValue(value, INVALID_BYTE_STRING_HEADER_VALUE_CHARS);function toByteStringHeaderObject(headers) { const byteStringHeaders = Object.create(null); utils$1.forEach(headers.toJSON(), (value, header) => { byteStringHeaders[header] = sanitizeByteStringHeaderValue(value); }); return byteStringHeaders;} const $internals = Symbol('internals');function normalizeHeader(header) { return header && String(header).trim().toLowerCase();}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 parameterNameRE = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;function trimOWS(value) { let start = 0; let end = value.length; while (start < end) { const code = value.charCodeAt(start); if (code !== 0x09 && code !== 0x20) { break; } start += 1; } while (end > start) { const code = value.charCodeAt(end - 1); if (code !== 0x09 && code !== 0x20) { break; } end -= 1; } return start === 0 && end === value.length ? value : value.slice(start, end);}function decodeQuotedString(value) { const last = value.length - 1; if (last < 1 || value.charCodeAt(0) !== 0x22 || value.charCodeAt(last) !== 0x22) { return value; } let decoded = ''; for (let i = 1; i < last; i++) { const code = value.charCodeAt(i); if (code === 0x22) { return value; } if (code === 0x5c) { i += 1; if (i >= last) { return value; } } decoded += value[i]; } return decoded;}function parseParameters(value) { const parameters = Object.create(null); const str = String(value); let start = 0; let quoted = false; let escaped = false; function parseParameter(end) { const part = trimOWS(str.slice(start, end)); const equals = part.indexOf('='); if (equals < 1) { return; } const name = trimOWS(part.slice(0, equals)); if (!parameterNameRE.test(name)) { return; } const normalizedName = name.toLowerCase(); if (normalizedName === '__proto__' || normalizedName === 'constructor' || normalizedName === 'prototype') { return; } const parameterValue = trimOWS(part.slice(equals + 1)); parameters[normalizedName] = decodeQuotedString(parameterValue); } for (let i = 0; i < str.length; i++) { const code = str.charCodeAt(i); if (quoted) { if (escaped) { escaped = false; } else if (code === 0x5c) { escaped = true; } else if (code === 0x22) { quoted = false; } } else if (code === 0x22) { quoted = true; } else if (code === 0x2c || code === 0x3b) { parseParameter(i); start = i + 1; } } parseParameter(str.length); return parameters;}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, { // Null-proto descriptor so a polluted Object.prototype.get cannot turn // this data descriptor into an accessor descriptor on the way in. __proto__: null, 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) { return; } 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.isSafeIterable(header)) { let obj = Object.create(null), dest, key; for (const entry of header) { if (!utils$1.isArray(entry)) { throw new TypeError('Object iterator must return a key-value pair'); } key = entry[0]; if (utils$1.hasOwnProp(obj, key)) { dest = obj[key]; obj[key] = utils$1.isArray(dest) ? [...dest, entry[1]] : [dest, entry[1]]; } else { obj[key] = 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() { const value = this.get('set-cookie'); return utils$1.isArray(value) ? value : value == null || value === false ? [] : [value]; } get [Symbol.toStringTag]() { return 'AxiosHeaders'; } static from(thing) { return thing instanceof this ? thing : new this(thing); } static parseParameters(value) { return parseParameters(value); } 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); const REDACTED = '[REDACTED ****]';function hasOwnOrPrototypeToJSON(source) { if (utils$1.hasOwnProp(source, 'toJSON')) { return true; } let prototype = Object.getPrototypeOf(source); while (prototype && prototype !== Object.prototype) { if (utils$1.hasOwnProp(prototype, 'toJSON')) { return true; } prototype = Object.getPrototypeOf(prototype); } return false;} // Build a plain-object snapshot of `config` and replace the value of any key// (case-insensitive) listed in `redactKeys` with REDACTED. Walks through arrays// and AxiosHeaders, and short-circuits on circular references.function redactConfig(config, redactKeys) { const lowerKeys = new Set(redactKeys.map(k => String(k).toLowerCase())); const seen = []; const visit = source => { if (source === null || typeof source !== 'object') return source; if (utils$1.isBuffer(source)) return source; if (seen.indexOf(source) !== -1) return undefined; if (source instanceof AxiosHeaders) { source = source.toJSON(); } seen.push(source); let result; if (utils$1.isArray(source)) { result = []; source.forEach((v, i) => { const reducedValue = visit(v); if (!utils$1.isUndefined(reducedValue)) { result[i] = reducedValue; } }); } else { if (!utils$1.isPlainObject(source) && hasOwnOrPrototypeToJSON(source)) { seen.pop(); return source; } result = Object.create(null); for (const [key, value] of Object.entries(source)) { const reducedValue = lowerKeys.has(key.toLowerCase()) ? REDACTED : visit(value); if (!utils$1.isUndefined(reducedValue)) { result[key] = reducedValue; } } } seen.pop(); return result; }; return visit(config);}function stringifySafely$1(value) { try { return String(value); } catch (err) { return ''; }}function aggregateErrorMessage(error) { const message = error.errors.map(entry => { try { return entry && entry.message ? stringifySafely$1(entry.message) : stringifySafely$1(entry); } catch (err) { return ''; } }).filter(Boolean).join('; '); return message || error.name || 'AggregateError';}class AxiosError extends Error { static from(error, code, config, request, response, customProps) { // `AggregateError` (thrown by Node on dual-stack/Happy-Eyeballs connection // failures) has an empty `message`; its detail lives in `errors[]`. Without // this, the wrapped error surfaces with a blank message (see #6721). let message = error.message; if (!message && utils$1.isArray(error.errors) && error.errors.length) { message = aggregateErrorMessage(error); } const axiosError = new AxiosError(message, code || error.code, config, request, response); // Match native `Error` `cause` semantics: non-enumerable. The wrapped // error often carries circular internals (sockets, requests, agents), so // an enumerable `cause` makes structured loggers (pino/winston) and any // own-property walk throw "Converting circular structure to JSON". // Regression from #6982; see #7205. `__proto__: null` mirrors the // `message` descriptor below (prototype-pollution-safe descriptor). Object.defineProperty(axiosError, 'cause', { __proto__: null, value: error, writable: true, enumerable: false, configurable: true }); 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', { // Null-proto descriptor so a polluted Object.prototype.get cannot turn // this data descriptor into an accessor descriptor on the way in. __proto__: null, 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() { // Opt-in redaction: when the request config carries a `redact` array, the // value of any matching key (case-insensitive, at any depth) is replaced // with REDACTED in the serialized snapshot. Undefined or empty leaves the // existing serialization behavior unchanged. const config = this.config; const redactKeys = config && utils$1.hasOwnProp(config, 'redact') ? config.redact : undefined; const serializedConfig = utils$1.isArray(redactKeys) && redactKeys.length > 0 ? redactConfig(config, redactKeys) : utils$1.toJSONObject(config); 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: serializedConfig, 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.ECONNREFUSED = 'ECONNREFUSED';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'; var PlatformBuffer = { isBufferAvailable() { return typeof Buffer !== 'undefined'; }, from(value) { return Buffer.from(value); }}; // Default nesting limit shared with the inverse transform (formDataToJSON) so// the FormData <-> JSON round-trip stays symmetric.const DEFAULT_FORM_DATA_MAX_DEPTH = 100; /** * 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$1 || 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 ? DEFAULT_FORM_DATA_MAX_DEPTH : options.maxDepth; const useBlob = _Blob && utils$1.isSpecCompliantForm(formData); const stack = []; 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)) { if (useBlob && typeof _Blob === 'function') { return new _Blob([value]); } if (PlatformBuffer && PlatformBuffer.isBufferAvailable()) { return PlatformBuffer.from(value); } throw new AxiosError('Blob is not supported. Use a Buffer instead.', AxiosError.ERR_NOT_SUPPORT); } return value; } function throwIfMaxDepthExceeded(depth) { if (depth > maxDepth) { throw new AxiosError('Object is too deeply nested (' + depth + ' levels). Max depth: ' + maxDepth, AxiosError.ERR_FORM_DATA_DEPTH_EXCEEDED); } } function stringifyWithDepthLimit(value, depth) { if (maxDepth === Infinity) { return JSON.stringify(value); } const ancestors = []; return JSON.stringify(value, function limitDepth(_key, currentValue) { if (!utils$1.isObject(currentValue)) { return currentValue; } while (ancestors.length && ancestors[ancestors.length - 1] !== this) { ancestors.pop(); } ancestors.push(currentValue); throwIfMaxDepthExceeded(depth + ancestors.length - 1); return currentValue; }); } /** * 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 = stringifyWithDepthLimit(value, 1); } 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 exposedHelpers = Object.assign(predicates, { defaultVisitor, convertValue, isVisitable }); function build(value, path, depth = 0) { if (utils$1.isUndefined(value)) return; throwIfMaxDepthExceeded(depth); if (stack.indexOf(value) !== -1) { throw new 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 ? value => 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; } url = url || ''; const _options = utils$1.isFunction(options) ? { serialize: options } : options; // Read serializer options pollution-safely: own properties and methods on a // class/template prototype are honored, but values injected onto a polluted // Object.prototype are ignored. const _encode = utils$1.getSafeProp(_options, 'encode') || encode; const serializeFn = utils$1.getSafeProp(_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, advertiseZstdAcceptEncoding: false, validateStatusUndefinedResolves: true}; var URLSearchParams = url.URLSearchParams; const ALPHA = 'abcdefghijklmnopqrstuvwxyz';const DIGIT = '0123456789';const ALPHABET = { DIGIT, ALPHA, ALPHA_DIGIT: ALPHA + ALPHA.toUpperCase() + DIGIT};const generateString = (size = 16, alphabet = ALPHABET.ALPHA_DIGIT) => { let str = ''; const { length } = alphabet; const randomValues = new Uint32Array(size); crypto.randomFillSync(randomValues); for (let i = 0; i < size; i++) { str += alphabet[randomValues[i] % length]; } return str;};var platform$1 = { isNode: true, classes: { URLSearchParams, FormData: FormData$1, Blob: typeof Blob !== 'undefined' && Blob || null }, ALPHABET, generateString, protocols: ['http', 'https', 'file', '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 });} const MAX_DEPTH = DEFAULT_FORM_DATA_MAX_DEPTH;function throwIfDepthExceeded(index) { if (index > MAX_DEPTH) { throw new AxiosError('FormData field is too deeply nested (' + index + ' levels). Max depth: ' + MAX_DEPTH, AxiosError.ERR_FORM_DATA_DEPTH_EXCEEDED); }} /** * It takes a string like `foo[x][y][z]` and returns an array like `['foo', 'x', 'y', 'z'] * * @param {string} name - The name of the property to get. * * @returns An array of strings. */function parsePropPath(name) { // foo[x][y][z] -> ['foo', 'x', 'y', 'z'] // foo.x.y.z -> ['foo', 'x', 'y', 'z'] // A path is split on `.` and on `[...]` groups. A segment — whether written // in dot notation or captured inside brackets — may contain any character // except `.`, `[` and `]`, so a key like `user-name` or `user name` is kept // literal instead of being split (#5402). `.`, `[` and `]` keep their existing // meaning, e.g. `foo[bar.baz]` -> ['foo', 'bar', 'baz'] and `[]` is an array push. // Excluding `[` from the bracket group also makes the match fail fast at the // next `[`, so a malformed name cannot rescan to the end of the string from // every unmatched `[` — parsing stays linear in the length of the name. const path = []; const pattern = /[^.[\]]+|\[([^.[\]]*)]/g; let match; while ((match = pattern.exec(name)) !== null) { throwIfDepthExceeded(path.length); path.push(match[0] === '[]' ? '' : match[1] || match[0]); } return path;} /** * 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) { throwIfDepthExceeded(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 (!utils$1.hasOwnProp(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', 'query'], method => { defaults.headers[method] = {};}); /** * 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, response.status >= 400 && response.status < 500 ? AxiosError.ERR_BAD_REQUEST : AxiosError.ERR_BAD_RESPONSE, response.config, response.request, response)); }} /** * 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) { if (!relativeURL) { return baseURL; } let end = baseURL.length; while (end > 0 && baseURL.charCodeAt(end - 1) === 47) { end--; } return baseURL.slice(0, end) + '/' + relativeURL.replace(/^\/+/, '');} const malformedHttpProtocol = /^https?:(?!\/\/)/i;const httpProtocolControlCharacters = /[\t\n\r]/g;function stripLeadingC0ControlOrSpace(url) { let i = 0; while (i < url.length && url.charCodeAt(i) <= 0x20) { i++; } return url.slice(i);}function normalizeURLForProtocolCheck(url) { return stripLeadingC0ControlOrSpace(url).replace(httpProtocolControlCharacters, '');} // Redact the parts of a URL that can carry secrets before it is embedded in an// error message. AxiosError.toJSON() serializes `message` verbatim and errors// are commonly logged, while the opt-in `config.redact` model only cleans// config keys — it cannot reach the message. Redact only the genuinely// sensitive substrings — userinfo (credentials), query parameter values and// fragment contents — with the same REDACTED marker the config redaction uses,// while keeping the scheme, host, path and parameter names so the offending// request stays accurately identifiable.function redactFragment(fragment) { if (!fragment) { return fragment; } return fragment.replace(/(^|&)([^=&]*=)?[^&]+/g, (match, separator, parameterName = '') => { return `${separator}${parameterName}${REDACTED}`; });}function redactSensitiveURLParts(url) { const redactedURL = url.replace(/^(https?:\/{0,2})[^/?#]*@/i, `$1${REDACTED}@`); const fragmentIndex = redactedURL.indexOf('#'); const urlWithoutFragment = fragmentIndex === -1 ? redactedURL : redactedURL.slice(0, fragmentIndex); const redactedURLWithoutFragment = urlWithoutFragment.replace(/([?&][^=&#]*=)[^&#]*/g, `$1${REDACTED}`); if (fragmentIndex === -1) { return redactedURLWithoutFragment; } return `${redactedURLWithoutFragment}#${redactFragment(redactedURL.slice(fragmentIndex + 1))}`;}function assertValidHttpProtocolURL(url, config) { if (typeof url === 'string') { const normalizedURL = normalizeURLForProtocolCheck(url); if (malformedHttpProtocol.test(normalizedURL)) { throw new AxiosError(`Invalid URL ${JSON.stringify(redactSensitiveURLParts(normalizedURL))}: missing "//" after protocol`, AxiosError.ERR_INVALID_URL, config); } }} /** * 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, config) { assertValidHttpProtocolURL(requestedURL, config); let isRelativeUrl = !isAbsoluteURL(requestedURL); if (baseURL && (isRelativeUrl || allowAbsoluteUrls === false)) { assertValidHttpProtocolURL(baseURL, config); return combineURLs(baseURL, requestedURL); } return requestedURL;} var DEFAULT_PORTS$1 = { ftp: 21, gopher: 70, http: 80, https: 443, ws: 80, wss: 443};function parseUrl(urlString) { try { return new URL(urlString); } catch { return null; }} /** * @param {string|object|URL} url - The URL as a string or URL instance, or a * compatible object (such as the result from legacy url.parse). * @return {string} The URL of the proxy that should handle the request to the * given URL. If no proxy is set, this will be an empty string. */function getProxyForUrl(url) { var parsedUrl = (typeof url === 'string' ? parseUrl(url) : url) || {}; var proto = parsedUrl.protocol; var hostname = parsedUrl.host; var port = parsedUrl.port; if (typeof hostname !== 'string' || !hostname || typeof proto !== 'string') { return ''; // Don't proxy URLs without a valid scheme or host. } proto = proto.split(':', 1)[0]; // Stripping ports in this way instead of using parsedUrl.hostname to make // sure that the brackets around IPv6 addresses are kept. hostname = hostname.replace(/:\d*$/, ''); port = parseInt(port) || DEFAULT_PORTS$1[proto] || 0; if (!shouldProxy(hostname, port)) { return ''; // Don't proxy URLs that match NO_PROXY. } var proxy = getEnv(proto + '_proxy') || getEnv('all_proxy'); if (proxy && proxy.indexOf('://') === -1) { // Missing scheme in proxy, default to the requested URL's scheme. proxy = proto + '://' + proxy; } return proxy;} /** * Determines whether a given URL should be proxied. * * @param {string} hostname - The host name of the URL. * @param {number} port - The effective port of the URL. * @returns {boolean} Whether the given URL should be proxied. * @private */function shouldProxy(hostname, port) { var NO_PROXY = getEnv('no_proxy').toLowerCase(); if (!NO_PROXY) { return true; // Always proxy if NO_PROXY is not set. } if (NO_PROXY === '*') { return false; // Never proxy if wildcard is set. } return NO_PROXY.split(/[,\s]/).every(function (proxy) { if (!proxy) { return true; // Skip zero-length hosts. } var parsedProxy = proxy.match(/^(.+):(\d+)$/); var parsedProxyHostname = parsedProxy ? parsedProxy[1] : proxy; var parsedProxyPort = parsedProxy ? parseInt(parsedProxy[2]) : 0; if (parsedProxyPort && parsedProxyPort !== port) { return true; // Skip if ports don't match. } if (!/^[.*]/.test(parsedProxyHostname)) { // No wildcards, so stop proxying if there is an exact match. return hostname !== parsedProxyHostname; } if (parsedProxyHostname.charAt(0) === '*') { // Remove leading wildcard. parsedProxyHostname = parsedProxyHostname.slice(1); } // Stop proxying if the hostname ends with the no_proxy host. return !hostname.endsWith(parsedProxyHostname); });} /** * Get the value for an environment variable. * * @param {string} key - The name of the environment variable. * @return {string} The value of the environment variable. * @private */function getEnv(key) { return process.env[key.toLowerCase()] || process.env[key.toUpperCase()] || '';} const VERSION = "1.19.0"; function parseProtocol(url) { const match = /^([-+\w]{1,25}):(?:\/\/)?/.exec(url); return match && match[1] || '';} // RFC 2397: data:[<mediatype>][;base64],<data>// mediatype = type/subtype followed by optional ;name=value parametersconst DATA_URL_PATTERN = /^([^,;]+\/[^,;]+)?((?:;[^,;=]+=[^,;]+)*)(;base64)?,([\s\S]*)$/; /** * Parse data uri to a Buffer or Blob * * @param {String} uri * @param {?Boolean} asBlob * @param {?Object} options * @param {?Function} options.Blob * * @returns {Buffer|Blob} */function fromDataURI(uri, asBlob, options) { const _Blob = options && options.Blob || platform.classes.Blob; const protocol = parseProtocol(uri); if (asBlob === undefined && _Blob) { asBlob = true; } if (protocol === 'data') { uri = protocol.length ? uri.slice(protocol.length + 1) : uri; const match = DATA_URL_PATTERN.exec(uri); if (!match) { throw new AxiosError('Invalid URL', AxiosError.ERR_INVALID_URL); } const type = match[1]; const params = match[2]; const encoding = match[3] ? 'base64' : 'utf8'; const body = match[4]; // RFC 2397 section 3: default mediatype is text/plain;charset=US-ASCII // Bare `data:,` leaves mime undefined; Blob normalises that to "" per spec. let mime = ''; if (type) { mime = params ? type + params : type; } else if (params) { mime = 'text/plain' + params; } const buffer = encoding === 'base64' ? Buffer.from(body, 'base64') : Buffer.from(decodeURIComponent(body), encoding); if (asBlob) { if (!_Blob) { throw new AxiosError('Blob is not supported', AxiosError.ERR_NOT_SUPPORT); } return new _Blob([buffer], { type: mime }); } return buffer; } throw new AxiosError('Unsupported protocol ' + protocol, AxiosError.ERR_NOT_SUPPORT);} const FORM_DATA_CONTENT_HEADERS = ['content-type', 'content-length']; /** * Apply the headers generated by a FormData implementation to the request headers, * honoring the `formDataHeaderPolicy` option: with 'content-only', copy only the * content-* headers; otherwise merge all of them. * * @param {AxiosHeaders} headers - the request headers to mutate * @param {Object | null | undefined} formHeaders - headers produced by the FormData implementation * @param {String} [policy] - the resolved `formDataHeaderPolicy` config value * * @returns {void} */function setFormDataHeaders(headers, formHeaders, policy) { if (policy !== 'content-only') { headers.set(formHeaders); return; } Object.entries(formHeaders || {}).forEach(([key, val]) => { if (FORM_DATA_CONTENT_HEADERS.includes(key.toLowerCase())) { headers.set(key, val); } });} const kInternals = Symbol('internals');class AxiosTransformStream extends stream.Transform { constructor(options) { options = utils$1.toFlatObject(options, { maxRate: 0, chunkSize: 64 * 1024, minChunkSize: 100, timeWindow: 500, ticksRate: 2, samplesCount: 15 }, null, (prop, source) => { return !utils$1.isUndefined(source[prop]); }); super({ readableHighWaterMark: options.chunkSize }); const internals = this[kInternals] = { timeWindow: options.timeWindow, chunkSize: options.chunkSize, maxRate: options.maxRate, minChunkSize: options.minChunkSize, bytesSeen: 0, isCaptured: false, notifiedBytesLoaded: 0, ts: Date.now(), bytes: 0, onReadCallback: null }; this.on('newListener', event => { if (event === 'progress') { if (!internals.isCaptured) { internals.isCaptured = true; } } }); } _read(size) { const internals = this[kInternals]; if (internals.onReadCallback) { internals.onReadCallback(); } return super._read(size); } _transform(chunk, encoding, callback) { const internals = this[kInternals]; const maxRate = internals.maxRate; const readableHighWaterMark = this.readableHighWaterMark; const timeWindow = internals.timeWindow; const divider = 1000 / timeWindow; const bytesThreshold = maxRate / divider; const minChunkSize = internals.minChunkSize !== false ? Math.max(internals.minChunkSize, bytesThreshold * 0.01) : 0; const pushChunk = (_chunk, _callback) => { const bytes = Buffer.byteLength(_chunk); internals.bytesSeen += bytes; internals.bytes += bytes; internals.isCaptured && this.emit('progress', internals.bytesSeen); if (this.push(_chunk)) { process.nextTick(_callback); } else { internals.onReadCallback = () => { internals.onReadCallback = null; process.nextTick(_callback); }; } }; const transformChunk = (_chunk, _callback) => { const chunkSize = Buffer.byteLength(_chunk); let chunkRemainder = null; let maxChunkSize = readableHighWaterMark; let bytesLeft; let passed = 0; if (maxRate) { const now = Date.now(); if (!internals.ts || (passed = now - internals.ts) >= timeWindow) { internals.ts = now; bytesLeft = bytesThreshold - internals.bytes; internals.bytes = bytesLeft < 0 ? -bytesLeft : 0; passed = 0; } bytesLeft = bytesThreshold - internals.bytes; } if (maxRate) { if (bytesLeft <= 0) { // next time window return setTimeout(() => { _callback(null, _chunk); }, timeWindow - passed); } if (bytesLeft < maxChunkSize) { maxChunkSize = bytesLeft; } } if (maxChunkSize && chunkSize > maxChunkSize && chunkSize - maxChunkSize > minChunkSize) { chunkRemainder = _chunk.subarray(maxChunkSize); _chunk = _chunk.subarray(0, maxChunkSize); } pushChunk(_chunk, chunkRemainder ? () => { process.nextTick(_callback, null, chunkRemainder); } : _callback); }; transformChunk(chunk, function transformNextChunk(err, _chunk) { if (err) { return callback(err); } if (_chunk) { transformChunk(_chunk, transformNextChunk); } else { callback(null); } }); }} const { asyncIterator} = Symbol;const readBlob = async function* (blob) { if (blob.stream) { yield* blob.stream(); } else if (blob.arrayBuffer) { yield await blob.arrayBuffer(); } else if (blob[asyncIterator]) { yield* blob[asyncIterator](); } else { yield blob; }}; const BOUNDARY_ALPHABET = platform.ALPHABET.ALPHA_DIGIT + '-_';const textEncoder = typeof TextEncoder === 'function' ? new TextEncoder() : new util.TextEncoder();const CRLF = '\r\n';const CRLF_BYTES = textEncoder.encode(CRLF);const CRLF_BYTES_COUNT = 2;class FormDataPart { constructor(name, value) { const { escapeName } = this.constructor; const isStringValue = utils$1.isString(value); let headers = `Content-Disposition: form-data; name="${escapeName(name)}"${!isStringValue && value.name ? `; filename="${escapeName(value.name)}"` : ''}${CRLF}`; if (isStringValue) { value = textEncoder.encode(String(value).replace(/\r?\n|\r\n?/g, CRLF)); } else { const safeType = String(value.type || 'application/octet-stream').replace(/[\r\n]/g, ''); headers += `Content-Type: ${safeType}${CRLF}`; } this.headers = textEncoder.encode(headers + CRLF); this.contentLength = isStringValue ? value.byteLength : value.size; this.size = this.headers.byteLength + this.contentLength + CRLF_BYTES_COUNT; this.name = name; this.value = value; } async *encode() { yield this.headers; const { value } = this; if (utils$1.isTypedArray(value)) { yield value; } else { yield* readBlob(value); } yield CRLF_BYTES; } static escapeName(name) { return String(name).replace(/[\r\n"]/g, match => ({ '\r': '%0D', '\n': '%0A', '"': '%22' })[match]); }}const formDataToStream = (form, headersHandler, options) => { const { tag = 'form-data-boundary', size = 25, boundary = tag + '-' + platform.generateString(size, BOUNDARY_ALPHABET) } = options || {}; if (!utils$1.isFormData(form)) { throw new TypeError('FormData instance required'); } if (boundary.length < 1 || boundary.length > 70) { throw new Error('boundary must be 1-70 characters long'); } const boundaryBytes = textEncoder.encode('--' + boundary + CRLF); const footerBytes = textEncoder.encode('--' + boundary + '--' + CRLF); let contentLength = footerBytes.byteLength; const parts = Array.from(form.entries()).map(([name, value]) => { const part = new FormDataPart(name, value); contentLength += part.size; return part; }); contentLength += boundaryBytes.byteLength * parts.length; contentLength = utils$1.toFiniteNumber(contentLength); const computedHeaders = { 'Content-Type': `multipart/form-data; boundary=${boundary}` }; if (Number.isFinite(contentLength)) { computedHeaders['Content-Length'] = contentLength; } headersHandler && headersHandler(computedHeaders); return stream.Readable.from(async function* () { for (const part of parts) { yield boundaryBytes; yield* part.encode(); } yield footerBytes; }());}; class ZlibHeaderTransformStream extends stream.Transform { __transform(chunk, encoding, callback) { this.push(chunk); callback(); } _transform(chunk, encoding, callback) { if (chunk.length !== 0) { this._transform = this.__transform; // Add Default Compression headers if no zlib headers are present if (chunk[0] !== 120) { // Hex: 78 const header = Buffer.alloc(2); header[0] = 120; // Hex: 78 header[1] = 156; // Hex: 9C this.push(header, encoding); } } this.__transform(chunk, encoding, callback); }} class Http2Sessions { constructor() { this.sessions = Object.create(null); } getSession(authority, options) { options = Object.assign({ sessionTimeout: 1000 }, options); let authoritySessions = this.sessions[authority]; if (authoritySessions) { let len = authoritySessions.length; for (let i = 0; i < len; i++) { const [sessionHandle, sessionOptions] = authoritySessions[i]; if (!sessionHandle.destroyed && !sessionHandle.closed && util.isDeepStrictEqual(sessionOptions, options)) { return sessionHandle; } } } const session = http2.connect(authority, options); let removed; let timer; const removeSession = () => { if (removed) { return; } removed = true; if (timer) { clearTimeout(timer); timer = null; } let entries = authoritySessions, len = entries.length, i = len; while (i--) { if (entries[i][0] === session) { if (len === 1) { delete this.sessions[authority]; } else { entries.splice(i, 1); } if (!session.closed) { session.close(); } return; } } }; const originalRequestFn = session.request; const { sessionTimeout } = options; if (sessionTimeout != null) { let streamsCount = 0; session.request = function () { const stream = originalRequestFn.apply(this, arguments); streamsCount++; if (timer) { clearTimeout(timer); timer = null; } stream.once('close', () => { if (! --streamsCount) { timer = setTimeout(() => { timer = null; removeSession(); }, sessionTimeout); } }); return stream; }; } session.once('close', removeSession); let entry = [session, options]; authoritySessions ? authoritySessions.push(entry) : authoritySessions = this.sessions[authority] = [entry]; return session; }} const callbackify = (fn, reducer) => { return utils$1.isAsyncFn(fn) ? function (...args) { const cb = args.pop(); fn.apply(this, args).then(value => { try { reducer ? cb(null, ...reducer(value)) : cb(null, value); } catch (err) { cb(err); } }, cb); } : fn;}; const LOOPBACK_HOSTNAMES = new Set(['localhost', '0.0.0.0']);const isIPv4Loopback = host => { const parts = host.split('.'); if (parts.length !== 4) return false; if (parts[0] !== '127') return false; return parts.every(p => /^\d+$/.test(p) && Number(p) >= 0 && Number(p) <= 255);}; /** * Canonicalize an IPv4 address written in shorthand, octal, or hex form into * dotted-decimal. IPv6 addresses and non-IP strings are returned unchanged so * the existing IPv4-mapped IPv6 unmap path and the isLoopback path can still * see them. * * Shorthand expansion mirrors Node's URL parser: literal parts fill from the * left, the final part fills the remaining octets from the right with * zero-padding on the left. * 127.1 -> 127.0.0.1 * 127.0.1 -> 127.0.0.1 * 1.2.3 -> 1.2.0.3 * * Each octet is parsed with an explicit base: 16 for `0x`/`0X` prefix, 8 for * zero-prefixed multi-digit all-`0-7` parts, 10 otherwise. Zero-prefixed * decimal-looking parts that contain `8` or `9` are rejected to match Node's * URL parser, and the comparison layer falls through to non-bypass if either * side rejects the form (fail-safe). * * Returns the input unchanged on any parse failure, out-of-range octet, or * unusual shape (1-part, 5+ parts) so the comparison layer fails closed. */const parseIPv4Octet = text => { if (/^0[xX][0-9a-fA-F]+$/.test(text)) { const n = parseInt(text.slice(2), 16); return Number.isFinite(n) ? n : null; } if (text.length > 1 && /^0[0-7]+$/.test(text)) { const n = parseInt(text, 8); return Number.isFinite(n) ? n : null; } if (text.length > 1 && /^0[0-9]+$/.test(text)) { return null; } if (/^[0-9]+$/.test(text)) { const n = parseInt(text, 10); return Number.isFinite(n) ? n : null; } return null;};const normalizeIPAddress = host => { if (typeof host !== 'string' || !host || host.indexOf(':') !== -1) { return host; } let h = host; if (h.charAt(0) === '[' && h.charAt(h.length - 1) === ']') { h = h.slice(1, -1); } h = h.replace(/\.+$/, ''); // Allowed characters for any IPv4 shape: digits, dot, 'x', 'X', hex digits. if (!/^[0-9.xXa-fA-F]+$/.test(h)) return host; const parts = h.split('.'); // No part may be empty (e.g. "127..0.1" or "127.0.0."). Trailing dots are // already stripped above; this guards against the empty-middle case. if (parts.some(p => p === '')) return host; if (parts.length === 4) { // Full IPv4 form: each part is an octet. const octets = parts.map(parseIPv4Octet); if (octets.some(n => n === null || n < 0 || n > 255)) return host; return octets.join('.'); } if (parts.length > 4) { return host; } // Shorthand: 1..3 parts. Node's URL parser treats a 1-part input as a 32-bit // integer split into octets, which has surprising semantics (e.g. "127" -> // "0.0.0.127"). Reject 1-part inputs to keep the helper predictable: the // fail-safe returns the input unchanged and the comparison layer falls // through to non-bypass. if (parts.length === 1) return host; // 2..3 parts: literal parts fill from the left, tail fills remaining octets // from the right with zero-padding. const literalOctets = parts.slice(0, -1); const tail = parts[parts.length - 1]; const tailSlots = 4 - literalOctets.length; // Tail is parsed as a full IPv4 number (hex/octal/decimal) and packed // low-byte-right into the remaining octets, matching Node's URL parser. // e.g. 127.65535 (tail 0xFFFF into 3 slots) -> 127.0.255.255; // 127.0x00ff (tail 0xFF into 3 slots) -> 127.0.0.255; // 127.0.65535 (tail 0xFFFF into 2 slots) -> 127.0.255.255. const tailValue = parseIPv4Octet(tail); if (tailValue === null) return host; const maxTail = (1 << 8 * tailSlots) - 1; if (tailValue < 0 || tailValue > maxTail) return host; const tailOctets = new Array(tailSlots).fill(0); for (let i = tailSlots - 1, v = tailValue; i >= 0; i--, v >>= 8) { tailOctets[i] = v & 0xff; } const literal = literalOctets.map(parseIPv4Octet); if (literal.some(n => n === null || n < 0 || n > 255)) return host; return [...literal, ...tailOctets].join('.');};const isIPv6ZeroGroup = group => /^0{1,4}$/.test(group); // The unspecified address (IPv4 0.0.0.0 / IPv6 ::) resolves to the local host// for outbound connections, so treat it as loopback-equivalent for NO_PROXY// matching. 0.0.0.0 is covered by LOOPBACK_HOSTNAMES; this handles compressed// and full IPv6 all-zero forms so both families bypass symmetrically.const isIPv6Unspecified = host => { if (host === '::') return true; const compressionIndex = host.indexOf('::'); if (compressionIndex !== -1) { if (compressionIndex !== host.lastIndexOf('::')) return false; const left = host.slice(0, compressionIndex); const right = host.slice(compressionIndex + 2); const leftGroups = left ? left.split(':') : []; const rightGroups = right ? right.split(':') : []; const explicitGroups = leftGroups.length + rightGroups.length; return explicitGroups < 8 && leftGroups.every(isIPv6ZeroGroup) && rightGroups.every(isIPv6ZeroGroup); } const groups = host.split(':'); return groups.length === 8 && groups.every(isIPv6ZeroGroup);};const isIPv6Loopback = host => { // Collapse all-zero groups: any form of ::1 / 0:0:...:0:1 // First, strip any leading "::" by normalising with Set lookup of common forms, // then fall back to structural check. if (host === '::1') return true; // Check IPv4-mapped IPv6 loopback: ::ffff:<v4-loopback> or ::ffff:<hex-v4-loopback> // Node's URL parser normalises ::ffff:127.0.0.1 → ::ffff:7f00:1 const v4MappedDotted = host.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/i); if (v4MappedDotted) return isIPv4Loopback(v4MappedDotted[1]); const v4MappedHex = host.match(/^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/i); if (v4MappedHex) { const high = parseInt(v4MappedHex[1], 16); // High 16 bits must start with 127 (0x7f) — i.e. 0x7f00..0x7fff return high >= 0x7f00 && high <= 0x7fff; } // Full-form ::1 variants: any number of zero groups followed by trailing 1 // e.g. 0:0:0:0:0:0:0:1, 0000:...:0001 const groups = host.split(':'); if (groups.length === 8) { for (let i = 0; i < 7; i++) { if (!/^0+$/.test(groups[i])) return false; } return /^0*1$/.test(groups[7]); } return false;};const isLoopback = host => { if (!host) return false; if (LOOPBACK_HOSTNAMES.has(host)) return true; if (isIPv4Loopback(host)) return true; if (isIPv6Unspecified(host)) return true; return isIPv6Loopback(host);};const DEFAULT_PORTS = { http: 80, https: 443, ws: 80, wss: 443, ftp: 21};const parseNoProxyEntry = entry => { let entryHost = entry; let entryPort = 0; if (entryHost.charAt(0) === '[') { const bracketIndex = entryHost.indexOf(']'); if (bracketIndex !== -1) { const host = entryHost.slice(1, bracketIndex); const rest = entryHost.slice(bracketIndex + 1); if (rest.charAt(0) === ':' && /^\d+$/.test(rest.slice(1))) { entryPort = Number.parseInt(rest.slice(1), 10); } return [host, entryPort]; } } const firstColon = entryHost.indexOf(':'); const lastColon = entryHost.lastIndexOf(':'); if (firstColon !== -1 && firstColon === lastColon && /^\d+$/.test(entryHost.slice(lastColon + 1))) { entryPort = Number.parseInt(entryHost.slice(lastColon + 1), 10); entryHost = entryHost.slice(0, lastColon); } return [entryHost, entryPort];}; // Convert IPv4-mapped IPv6 (::ffff:0:0/96 prefix) to IPv4 dotted form so both// sides of a NO_PROXY comparison see the same canonical address. Without this,// `NO_PROXY=192.168.1.5` would not match a request to `http://[::ffff:192.168.1.5]/`// (Node's URL parser normalises that to `[::ffff:c0a8:105]`), and vice-versa,// allowing the proxy-bypass policy to be circumvented by using the alternate// representation. Returns the input unchanged when not IPv4-mapped.const IPV4_MAPPED_DOTTED_RE = /^(?:::|(?:0{1,4}:){1,4}:|(?:0{1,4}:){5})ffff:(\d+\.\d+\.\d+\.\d+)$/i;const IPV4_MAPPED_HEX_RE = /^(?:::|(?:0{1,4}:){1,4}:|(?:0{1,4}:){5})ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/i;const unmapIPv4MappedIPv6 = host => { if (typeof host !== 'string' || host.indexOf(':') === -1) return host; const dotted = host.match(IPV4_MAPPED_DOTTED_RE); if (dotted) return dotted[1]; const hex = host.match(IPV4_MAPPED_HEX_RE); if (hex) { const high = parseInt(hex[1], 16); const low = parseInt(hex[2], 16); return `${high >> 8}.${high & 0xff}.${low >> 8}.${low & 0xff}`; } return host;};const normalizeNoProxyHost = hostname => { if (!hostname) { return hostname; } if (hostname.charAt(0) === '[' && hostname.charAt(hostname.length - 1) === ']') { hostname = hostname.slice(1, -1); } const trimmed = hostname.replace(/\.+$/, ''); // IPv4 shorthand/octal/hex → dotted-decimal; helper is a no-op for inputs // containing ':' (IPv6 and IPv4-mapped IPv6) so we fall through to unmap. const ipv4 = normalizeIPAddress(trimmed); if (ipv4 !== trimmed) { return ipv4; } return unmapIPv4MappedIPv6(trimmed);};function shouldBypassProxy(location) { let parsed; try { parsed = new URL(location); } catch (_err) { return false; } const noProxy = (process.env.no_proxy || process.env.NO_PROXY || '').toLowerCase(); if (!noProxy) { return false; } if (noProxy === '*') { return true; } const port = Number.parseInt(parsed.port, 10) || DEFAULT_PORTS[parsed.protocol.split(':', 1)[0]] || 0; const hostname = normalizeNoProxyHost(parsed.hostname.toLowerCase()); return noProxy.split(/[\s,]+/).some(entry => { if (!entry) { return false; } if (entry === '*') { return true; } let [entryHost, entryPort] = parseNoProxyEntry(entry); entryHost = normalizeNoProxyHost(entryHost); if (!entryHost) { return false; } if (entryPort && entryPort !== port) { return false; } if (entryHost.charAt(0) === '*') { entryHost = entryHost.slice(1); } if (entryHost.charAt(0) === '.') { return hostname.endsWith(entryHost); } return hostname === entryHost || isLoopback(hostname) && isLoopback(entryHost); });} /** * 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 => { if (!e || typeof e.loaded !== 'number') { return; } const rawLoaded = e.loaded; const total = e.lengthComputable ? e.total : undefined; const loaded = Math.max(0, 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, scheduler = utils$1.asap) => (...args) => scheduler(() => fn(...args)); /** * Estimate data: URL byte lengths *without* allocating large buffers. * - Fetch percent-decodes a base64 body before decoding it. * - Node's Buffer.from(body, 'base64') sizes its backing allocation from the * raw body, including ignored characters and content after padding. * - Non-base64 data is percent-decoded and then encoded as UTF-8. */const isHexDigit = charCode => charCode >= 48 && charCode <= 57 || charCode >= 65 && charCode <= 70 || charCode >= 97 && charCode <= 102;const isPercentEncodedByte = (str, i, len) => i + 2 < len && isHexDigit(str.charCodeAt(i + 1)) && isHexDigit(str.charCodeAt(i + 2));const hexValue = charCode => charCode <= 57 ? charCode - 48 : (charCode & 0xdf) - 55;const isBase64Char = charCode => charCode >= 65 && charCode <= 90 ||// A-ZcharCode >= 97 && charCode <= 122 ||// a-zcharCode >= 48 && charCode <= 57 ||// 0-9charCode === 43 ||// +charCode === 47 ||// /charCode === 45 ||// - (base64url)charCode === 95; // _ (base64url) const isBase64Whitespace = charCode => charCode === 9 || charCode === 10 || charCode === 12 || charCode === 13 || charCode === 32;const base64Bytes = significant => { const groups = Math.floor(significant / 4); const remainder = significant % 4; return groups * 3 + (remainder === 2 ? 1 : remainder === 3 ? 2 : 0);}; // Buffer.byteLength(body, 'base64') uses the raw string length as an allocation// upper bound even when Buffer.from later ignores characters or stops at '='.const estimateBase64BufferAllocation = body => { const len = body.length; let padding = 0; if (len > 0 && body.charCodeAt(len - 1) === 61 /* '=' */) { padding++; if (len > 1 && body.charCodeAt(len - 2) === 61 /* '=' */) { padding++; } } return Math.floor((len - padding) * 3 / 4);};const estimatePercentDecodedBase64Bytes = body => { const len = body.length; let significant = 0; let padding = 0; let invalid = false; for (let i = 0; i < len; i++) { let code = body.charCodeAt(i); if (code === 37 /* '%' */ && isPercentEncodedByte(body, i, len)) { code = hexValue(body.charCodeAt(i + 1)) * 16 + hexValue(body.charCodeAt(i + 2)); i += 2; } if (isBase64Whitespace(code)) { continue; } if (code === 61 /* '=' */) { padding++; continue; } if (!isBase64Char(code) || padding > 0) { invalid = true; continue; } significant++; } // Fetch rejects malformed forgiving-base64 input. Returning the raw-size // allocation bound keeps that invalid input from becoming a pre-check bypass. if (invalid || padding > 2 || padding > 0 && (significant + padding) % 4 !== 0 || significant % 4 === 1) { return estimateBase64BufferAllocation(body); } return base64Bytes(significant);};const estimateDataURLBytes = (url, estimateBase64) => { if (!url || typeof url !== 'string') return 0; if (!url.startsWith('data:')) return 0; const comma = url.indexOf(','); if (comma < 0) return 0; const meta = url.slice(5, comma); const body = url.slice(comma + 1); const isBase64 = /;base64/i.test(meta); if (isBase64) { return estimateBase64(body); } // Compute UTF-8 byte length directly from UTF-16 code units without allocating // a byte buffer (TextEncoder.encode would defeat the DoS guard on large bodies). // Valid %XX triplets count as one decoded byte; this matches the bytes that // decodeURIComponent(body) would produce before Buffer re-encodes the string. let bytes = 0; for (let i = 0, len = body.length; i < len; i++) { const c = body.charCodeAt(i); if (c === 37 /* '%' */ && isPercentEncodedByte(body, i, len)) { bytes += 1; i += 2; } else if (c < 0x80) { bytes += 1; } else if (c < 0x800) { bytes += 2; } else if (c >= 0xd800 && c <= 0xdbff && i + 1 < len) { const next = body.charCodeAt(i + 1); if (next >= 0xdc00 && next <= 0xdfff) { bytes += 4; i++; } else { bytes += 3; } } else { bytes += 3; } } return bytes;}; /** * Estimate the percent-decoded payload size used by Fetch data: URLs. * * @param {string} url * @returns {number} */function estimateDataURLDecodedBytes(url) { // Fetch removes URL fragments before processing a data: URL. const fragmentIndex = typeof url === 'string' ? url.indexOf('#') : -1; return estimateDataURLBytes(fragmentIndex === -1 ? url : url.slice(0, fragmentIndex), estimatePercentDecodedBase64Bytes);} /** * Estimate the Buffer backing allocation used by Node's raw base64 decoder. * * @param {string} url * @returns {number} */function estimateDataURLBufferAllocation(url) { return estimateDataURLBytes(url, estimateBase64BufferAllocation);} const zlibOptions = { flush: zlib.constants.Z_SYNC_FLUSH, finishFlush: zlib.constants.Z_SYNC_FLUSH};const brotliOptions = { flush: zlib.constants.BROTLI_OPERATION_FLUSH, finishFlush: zlib.constants.BROTLI_OPERATION_FLUSH};const zstdOptions = { flush: zlib.constants.ZSTD_e_flush, finishFlush: zlib.constants.ZSTD_e_flush};const isBrotliSupported = utils$1.isFunction(zlib.createBrotliDecompress);const isZstdSupported = utils$1.isFunction(zlib.createZstdDecompress);const ACCEPT_ENCODING = 'gzip, compress, deflate' + (isBrotliSupported ? ', br' : '');const ACCEPT_ENCODING_WITH_ZSTD = ACCEPT_ENCODING + (isZstdSupported ? ', zstd' : '');const scheduleProgress = typeof process !== 'undefined' && process.nextTick ? process.nextTick.bind(process) : utils$1.asap;const { http: httpFollow, https: httpsFollow} = followRedirects;const isHttps = /https:?/; // Symbols used to bind a single 'error' listener to a pooled socket and track// the request currently owning that socket across keep-alive reuse (issue #10780).const kAxiosSocketListener = Symbol('axios.http.socketListener');const kAxiosCurrentReq = Symbol('axios.http.currentReq'); // Tags HttpsProxyAgent instances installed by setProxy() so the redirect path// can strip them without clobbering a user-supplied agent that happens to be// an HttpsProxyAgent.const kAxiosInstalledTunnel = Symbol('axios.http.installedTunnel'); // Cache of CONNECT-tunneling agents keyed by proxy config so repeat requests// through the same proxy reuse a single agent (and its socket pool). The// keyspace is bounded by the set of distinct proxy configs the process uses,// so unbounded growth is not a concern in practice.const tunnelingAgentCache = new Map();const tunnelingAgentCacheUser = new WeakMap();// Minimum minor versions where Node's HTTP Agent supports native proxyEnv// handling. Checking the selected agent below also covers startup modes such// as NODE_OPTIONS=--use-env-proxy and --no-use-env-proxy precedence.const NODE_NATIVE_ENV_PROXY_SUPPORT = { 22: 21, 24: 5};function isNodeNativeEnvProxySupported(nodeVersion = process.versions && process.versions.node) { if (!nodeVersion) { return false; } const [major, minor] = nodeVersion.split('.').map(part => Number(part)); if (!Number.isInteger(major) || !Number.isInteger(minor)) { return false; } if (major > 24) { return true; } return NODE_NATIVE_ENV_PROXY_SUPPORT[major] != null && minor >= NODE_NATIVE_ENV_PROXY_SUPPORT[major];}function isNodeEnvProxyEnabled(agent, nodeVersion = process.versions && process.versions.node) { if (!isNodeNativeEnvProxySupported(nodeVersion)) { return false; } const agentOptions = agent && agent.options; return Boolean(agentOptions && utils$1.hasOwnProp(agentOptions, 'proxyEnv') && agentOptions.proxyEnv != null);}function getProxyEnvAgent(options, configHttpAgent, configHttpsAgent) { return isHttps.test(options.protocol) ? configHttpsAgent || https.globalAgent : configHttpAgent || http.globalAgent;}function getTunnelingAgent(agentOptions, userHttpsAgent) { const key = agentOptions.protocol + '//' + agentOptions.hostname + ':' + (agentOptions.port || '') + '#' + (agentOptions.auth || ''); const cache = userHttpsAgent ? tunnelingAgentCacheUser.get(userHttpsAgent) || tunnelingAgentCacheUser.set(userHttpsAgent, new Map()).get(userHttpsAgent) : tunnelingAgentCache; let agent = cache.get(key); if (agent) return agent; // Forward the user's TLS options (custom CA, rejectUnauthorized, client cert, // etc.) into the tunneling agent so they apply to the origin TLS upgrade // performed after CONNECT. Our proxy fields take precedence on conflict. const merged = userHttpsAgent && userHttpsAgent.options ? { ...userHttpsAgent.options, ...agentOptions } : agentOptions; agent = new HttpsProxyAgent(merged); if (userHttpsAgent && userHttpsAgent.options) { const originTLSOptions = { ...userHttpsAgent.options }; const callback = agent.callback; agent.callback = function axiosTunnelingAgentCallback(req, opts) { // HttpsProxyAgent v5 reads callback opts for the post-CONNECT origin TLS upgrade. return callback.call(this, req, { ...originTLSOptions, ...opts }); }; } agent[kAxiosInstalledTunnel] = true; cache.set(key, agent); return agent;}const supportedProtocols = platform.protocols.map(protocol => { return protocol + ':';}); // Node's WHATWG URL parser returns `username` and `password` percent-encoded.// Decode before composing the `auth` option so credentials such as// `my%40email.com:pass` are sent as `my@email.com:pass`. Falls back to the// original value for malformed input so a bad encoding never throws.const decodeURIComponentSafe$1 = value => { if (!utils$1.isString(value)) { return value; } try { return decodeURIComponent(value); } catch (error) { return value; }};const flushOnFinish = (stream, [throttled, flush]) => { stream.on('end', flush).on('error', flush); return throttled;};const http2Sessions = new Http2Sessions(); /** * If the proxy, auth, sensitive header, or config beforeRedirects functions are defined, * call them with the options object. * * @param {Object<string, any>} options - The options object that was passed to the request. * * @returns {Object<string, any>} */function dispatchBeforeRedirect(options, responseDetails, requestDetails) { if (options.beforeRedirects.proxy) { options.beforeRedirects.proxy(options); } if (options.beforeRedirects.auth) { options.beforeRedirects.auth(options); } if (options.beforeRedirects.sensitiveHeaders) { options.beforeRedirects.sensitiveHeaders(options, requestDetails); } if (options.beforeRedirects.config) { options.beforeRedirects.config(options, responseDetails, requestDetails); }}function stripMatchingHeaders(headers, sensitiveSet) { if (!headers) { return; } Object.keys(headers).forEach(header => { if (sensitiveSet.has(header.toLowerCase())) { delete headers[header]; } });}function isSameOriginRedirect(redirectOptions, requestDetails) { if (!requestDetails) { return false; } try { return new URL(requestDetails.url).origin === new URL(redirectOptions.href).origin; } catch (e) { // If origin comparison fails, treat the redirect as unsafe. return false; }} /** * If the proxy or config afterRedirects functions are defined, call them with the options * * @param {http.ClientRequestArgs} options * @param {AxiosProxyConfig} configProxy configuration from Axios options object * @param {string} location * * @returns {http.ClientRequestArgs} */function setProxy(options, configProxy, location, isRedirect, configHttpsAgent, configHttpAgent) { let proxy = configProxy; const proxyEnvAgent = getProxyEnvAgent(options, configHttpAgent, configHttpsAgent); if (!proxy && proxy !== false && !isNodeEnvProxyEnabled(proxyEnvAgent)) { const proxyUrl = getProxyForUrl(location); if (proxyUrl) { if (!shouldBypassProxy(location)) { proxy = new URL(proxyUrl); } } } // On redirect re-invocation, strip any stale Proxy-Authorization header carried // over from the prior request (e.g. new target no longer uses a proxy, or uses // a different proxy). Skip on the initial request so user-supplied headers are // preserved. Header names are case-insensitive, so remove every case variant. if (isRedirect && options.headers) { for (const name of Object.keys(options.headers)) { if (name.toLowerCase() === 'proxy-authorization') { delete options.headers[name]; } } } // Strip any tunneling agent we installed for the previous hop so a redirect // that drops the proxy or crosses an HTTPS↔HTTP boundary doesn't reuse a // stale one. Match on our Symbol marker so a user-supplied HttpsProxyAgent // (which won't carry the marker) is left alone. if (isRedirect && options.agent && options.agent[kAxiosInstalledTunnel]) { options.agent = undefined; } if (proxy) { // Read proxy fields without traversing the prototype chain. URL instances expose // username/password/hostname/host/port/protocol via getters on URL.prototype (so // direct reads are shielded), but plain object proxies — and the `auth` field // (which URL does not expose) — must be guarded so a polluted Object.prototype // (e.g. Object.prototype.auth = { username, password }) cannot inject // attacker-controlled credentials into the Proxy-Authorization header or // redirect proxying to an attacker-controlled host. const isProxyURL = proxy instanceof URL; const readProxyField = key => isProxyURL || utils$1.hasOwnProp(proxy, key) ? proxy[key] : undefined; const proxyUsername = readProxyField('username'); const proxyPassword = readProxyField('password'); let proxyAuth = utils$1.hasOwnProp(proxy, 'auth') ? proxy.auth : undefined; // Basic proxy authorization if (proxyUsername) { proxyAuth = (proxyUsername || '') + ':' + (proxyPassword || ''); } if (proxyAuth) { // Support proxy auth object form. Read sub-fields via own-prop checks so a // plain object inheriting from polluted Object.prototype cannot leak creds. const authIsObject = typeof proxyAuth === 'object'; const authUsername = authIsObject && utils$1.hasOwnProp(proxyAuth, 'username') ? proxyAuth.username : undefined; const authPassword = authIsObject && utils$1.hasOwnProp(proxyAuth, 'password') ? proxyAuth.password : undefined; const validProxyAuth = Boolean(authUsername || authPassword); if (validProxyAuth) { proxyAuth = (authUsername || '') + ':' + (authPassword || ''); } else if (authIsObject) { throw new AxiosError('Invalid proxy authorization', AxiosError.ERR_BAD_OPTION, { proxy }); } } const targetIsHttps = isHttps.test(options.protocol); if (targetIsHttps) { // CONNECT-tunneling path for HTTPS targets. Preserves end-to-end TLS to // the origin so the proxy cannot inspect the URL, headers, or body — the // behavior already promised by THREATMODEL.md (T-R9). HttpsProxyAgent // sends Proxy-Authorization on the CONNECT request only, never on the // wrapped TLS request, which is why we don't stamp it onto // options.headers here. If the user already supplied an HttpsProxyAgent, // they own tunneling end-to-end and we leave them alone; otherwise we // install our own tunneling agent and forward their TLS options (if any) // so a custom httpsAgent for cert pinning / rejectUnauthorized still // applies to the origin TLS upgrade. if (!(configHttpsAgent instanceof HttpsProxyAgent)) { const proxyHost = readProxyField('hostname') || readProxyField('host'); const proxyPort = readProxyField('port'); const rawProxyProtocol = readProxyField('protocol'); const normalizedProtocol = rawProxyProtocol ? rawProxyProtocol.includes(':') ? rawProxyProtocol : `${rawProxyProtocol}:` : 'http:'; // Bracket IPv6 literals for URL parsing; URL.hostname strips the // brackets again on read so the agent receives the raw form. const proxyHostForURL = proxyHost && proxyHost.includes(':') && !proxyHost.startsWith('[') ? `[${proxyHost}]` : proxyHost; const proxyURL = new URL(`${normalizedProtocol}//${proxyHostForURL}${proxyPort ? ':' + proxyPort : ''}`); const agentOptions = { protocol: proxyURL.protocol, hostname: proxyURL.hostname.replace(/^\[|\]$/g, ''), port: proxyURL.port, auth: proxyAuth && typeof proxyAuth === 'string' ? proxyAuth : undefined }; if (proxyURL.protocol === 'https:') { agentOptions.ALPNProtocols = ['http/1.1']; } const tunnelingAgent = getTunnelingAgent(agentOptions, configHttpsAgent); // Set both: `options.agent` is consumed by the native https.request path // (maxRedirects === 0); `options.agents.https` is consumed by // follow-redirects, which ignores `options.agent` when `options.agents` // is present. options.agent = tunnelingAgent; if (options.agents) { options.agents.https = tunnelingAgent; } } } else { // Forward-proxy mode for plaintext HTTP targets. The request line carries // the absolute URL and the proxy sees everything — acceptable for plain // HTTP since the wire was already plaintext. if (proxyAuth) { const base64 = Buffer.from(proxyAuth, 'utf8').toString('base64'); options.headers['Proxy-Authorization'] = 'Basic ' + base64; } // Preserve a user-supplied Host header (case-insensitive) so callers can override // the value forwarded to the proxy; otherwise default to the request URL's host. let hasUserHostHeader = false; for (const name of Object.keys(options.headers)) { if (name.toLowerCase() === 'host') { hasUserHostHeader = true; break; } } if (!hasUserHostHeader) { options.headers.host = options.hostname + (options.port ? ':' + options.port : ''); } const proxyHost = readProxyField('hostname') || readProxyField('host'); options.hostname = proxyHost; // Replace 'host' since options is not a URL object options.host = proxyHost; options.port = readProxyField('port'); options.path = location; const proxyProtocol = readProxyField('protocol'); if (proxyProtocol) { options.protocol = proxyProtocol.includes(':') ? proxyProtocol : `${proxyProtocol}:`; } } } options.beforeRedirects.proxy = function beforeRedirect(redirectOptions) { // Configure proxy for redirected request, passing the original config proxy to apply // the exact same logic as if the redirected request was performed by axios directly. setProxy(redirectOptions, configProxy, redirectOptions.href, true, configHttpsAgent, configHttpAgent); };}const isHttpAdapterSupported = typeof process !== 'undefined' && utils$1.kindOf(process) === 'process'; // temporary hotfix const wrapAsync = asyncExecutor => { return new Promise((resolve, reject) => { let onDone; let isDone; const done = (value, isRejected) => { if (isDone) return; isDone = true; onDone && onDone(value, isRejected); }; const _resolve = value => { done(value); resolve(value); }; const _reject = reason => { done(reason, true); reject(reason); }; asyncExecutor(_resolve, _reject, onDoneHandler => onDone = onDoneHandler).catch(_reject); });};const resolveFamily = ({ address, family}) => { if (!utils$1.isString(address)) { throw TypeError('address must be a string'); } return { address, family: family || (address.indexOf('.') < 0 ? 6 : 4) };};const buildAddressEntry = (address, family) => resolveFamily(utils$1.isObject(address) ? address : { address, family});const http2Transport = { request(options, cb) { const authority = options.protocol + '//' + options.hostname + ':' + (options.port || (options.protocol === 'https:' ? 443 : 80)); const { http2Options, headers } = options; const session = http2Sessions.getSession(authority, http2Options); const { HTTP2_HEADER_SCHEME, HTTP2_HEADER_METHOD, HTTP2_HEADER_PATH, HTTP2_HEADER_STATUS } = http2.constants; const http2Headers = { [HTTP2_HEADER_SCHEME]: options.protocol.replace(':', ''), [HTTP2_HEADER_METHOD]: options.method, [HTTP2_HEADER_PATH]: options.path }; utils$1.forEach(headers, (header, name) => { name.charAt(0) !== ':' && (http2Headers[name] = header); }); const req = session.request(http2Headers); req.once('response', responseHeaders => { const response = req; //duplex responseHeaders = Object.assign({}, responseHeaders); const status = responseHeaders[HTTP2_HEADER_STATUS]; delete responseHeaders[HTTP2_HEADER_STATUS]; response.headers = responseHeaders; response.statusCode = +status; cb(response); }); return req; }}; /*eslint consistent-return:0*/var httpAdapter = isHttpAdapterSupported && function httpAdapter(config) { return wrapAsync(async function dispatchHttpRequest(resolve, reject, onDone) { // Read config pollution-safely: own properties and members inherited from // a non-Object.prototype source (e.g. an Object.create(defaults) template) // are honored, but values injected onto a polluted Object.prototype are // ignored. All behavior-affecting reads in this adapter go through own() // so the protection boundary stays consistent. const own = key => utils$1.getSafeProp(config, key); const transitional = own('transitional') || transitionalDefaults; let data = own('data'); let lookup = own('lookup'); let family = own('family'); let httpVersion = own('httpVersion'); if (httpVersion === undefined) httpVersion = 1; let http2Options = own('http2Options'); const httpAgent = own('httpAgent'); const httpsAgent = own('httpsAgent'); const configProxy = own('proxy'); const responseType = own('responseType'); const responseEncoding = own('responseEncoding'); const socketPath = own('socketPath'); const method = own('method').toUpperCase(); const maxRedirects = own('maxRedirects'); const maxBodyLength = own('maxBodyLength'); const maxContentLength = own('maxContentLength'); const decompress = own('decompress'); let isDone; let rejected = false; let req; let connectPhaseTimer; httpVersion = +httpVersion; if (Number.isNaN(httpVersion)) { throw TypeError(`Invalid protocol version: '${config.httpVersion}' is not a number`); } if (httpVersion !== 1 && httpVersion !== 2) { throw TypeError(`Unsupported protocol version '${httpVersion}'`); } const isHttp2 = httpVersion === 2; if (lookup) { const _lookup = callbackify(lookup, value => utils$1.isArray(value) ? value : [value]); // hotfix to support opt.all option which is required for node 20.x lookup = (hostname, opt, cb) => { _lookup(hostname, opt, (err, arg0, arg1) => { if (err) { return cb(err); } const addresses = utils$1.isArray(arg0) ? arg0.map(addr => buildAddressEntry(addr)) : [buildAddressEntry(arg0, arg1)]; opt.all ? cb(err, addresses) : cb(err, addresses[0].address, addresses[0].family); }); }; } const abortEmitter = new events.EventEmitter(); function abort(reason) { try { abortEmitter.emit('abort', !reason || reason.type ? new CanceledError(null, config, req) : reason); } catch (err) { // ignore emit errors } } function clearConnectPhaseTimer() { if (connectPhaseTimer) { clearTimeout(connectPhaseTimer); connectPhaseTimer = null; } } function createTimeoutError() { const configTimeout = own('timeout'); let timeoutErrorMessage = configTimeout ? 'timeout of ' + configTimeout + 'ms exceeded' : 'timeout exceeded'; const configTimeoutErrorMessage = own('timeoutErrorMessage'); if (configTimeoutErrorMessage) { timeoutErrorMessage = configTimeoutErrorMessage; } return new AxiosError(timeoutErrorMessage, transitional.clarifyTimeoutError ? AxiosError.ETIMEDOUT : AxiosError.ECONNABORTED, config, req); } abortEmitter.once('abort', reject); const onFinished = () => { clearConnectPhaseTimer(); if (config.cancelToken) { config.cancelToken.unsubscribe(abort); } if (config.signal) { config.signal.removeEventListener('abort', abort); } abortEmitter.removeAllListeners(); }; if (config.cancelToken || config.signal) { config.cancelToken && config.cancelToken.subscribe(abort); if (config.signal) { config.signal.aborted ? abort() : config.signal.addEventListener('abort', abort); } } onDone((response, isRejected) => { isDone = true; clearConnectPhaseTimer(); if (isRejected) { rejected = true; onFinished(); return; } const { data } = response; if (data instanceof stream.Readable || data instanceof stream.Duplex) { const offListeners = stream.finished(data, () => { offListeners(); onFinished(); }); } else { onFinished(); } }); // Parse url const fullPath = buildFullPath(own('baseURL'), own('url'), own('allowAbsoluteUrls'), config); // Unix-socket requests (own socketPath) commonly pass a path-only url // like '/foo'; supply a synthetic base so new URL() can still parse it. // Use the own-property value (not config.socketPath) so a polluted // prototype cannot influence URL base selection. const urlBase = socketPath ? 'http://localhost' : platform.hasBrowserEnv ? platform.origin : undefined; const parsed = new URL(fullPath, urlBase); const protocol = parsed.protocol || supportedProtocols[0]; if (protocol === 'data:') { // Apply the same semantics as HTTP: only enforce if a finite, non-negative cap is set. if (maxContentLength > -1) { // Use the exact string passed to fromDataURI (the configured url); fall back to fullPath if needed. const dataUrl = String(own('url') || fullPath || ''); const estimated = estimateDataURLBufferAllocation(dataUrl); if (estimated > maxContentLength) { return reject(new AxiosError('maxContentLength size of ' + maxContentLength + ' exceeded', AxiosError.ERR_BAD_RESPONSE, config)); } } let convertedData; if (method !== 'GET') { return settle(resolve, reject, { status: 405, statusText: 'method not allowed', headers: {}, config }); } try { convertedData = fromDataURI(own('url'), responseType === 'blob', { Blob: config.env && config.env.Blob }); } catch (err) { throw AxiosError.from(err, AxiosError.ERR_BAD_REQUEST, config); } if (responseType === 'text') { convertedData = convertedData.toString(responseEncoding); if (!responseEncoding || responseEncoding === 'utf8') { convertedData = utils$1.stripBOM(convertedData); } } else if (responseType === 'stream') { convertedData = stream.Readable.from(convertedData); } return settle(resolve, reject, { data: convertedData, status: 200, statusText: 'OK', headers: new AxiosHeaders(), config }); } if (supportedProtocols.indexOf(protocol) === -1) { return reject(new AxiosError('Unsupported protocol ' + protocol, AxiosError.ERR_BAD_REQUEST, config)); } const headers = AxiosHeaders.from(config.headers).normalize(); // Set User-Agent (required by some servers) // See https://github.com/axios/axios/issues/69 // User-Agent is specified; handle case where no UA header is desired // Only set header if it hasn't been set in config headers.set('User-Agent', 'axios/' + VERSION, false); const { onUploadProgress, onDownloadProgress } = config; const maxRate = config.maxRate; let maxUploadRate = undefined; let maxDownloadRate = undefined; // support for spec compliant FormData objects if (utils$1.isSpecCompliantForm(data)) { const userBoundary = headers.getContentType(/boundary=([-_\w\d]{10,70})/i); data = formDataToStream(data, formHeaders => { headers.set(formHeaders); }, { tag: `axios-${VERSION}-boundary`, boundary: userBoundary && userBoundary[1] || undefined }); // support for https://www.npmjs.com/package/form-data api } else if (utils$1.isFormData(data) && utils$1.isFunction(data.getHeaders) && data.getHeaders !== Object.prototype.getHeaders) { setFormDataHeaders(headers, data.getHeaders(), own('formDataHeaderPolicy')); if (!headers.hasContentLength()) { try { const knownLength = await util.promisify(data.getLength).call(data); Number.isFinite(knownLength) && knownLength >= 0 && headers.setContentLength(knownLength); /*eslint no-empty:0*/ } catch (e) {} } } else if (utils$1.isBlob(data) || utils$1.isFile(data)) { data.size && headers.setContentType(data.type || 'application/octet-stream'); headers.setContentLength(data.size || 0); data = stream.Readable.from(readBlob(data)); } else if (data && !utils$1.isStream(data)) { if (Buffer.isBuffer(data)) ; else if (utils$1.isArrayBuffer(data)) { data = Buffer.from(new Uint8Array(data)); } else if (utils$1.isString(data)) { data = Buffer.from(data, 'utf-8'); } else { return reject(new AxiosError('Data after transformation must be a string, an ArrayBuffer, a Buffer, or a Stream', AxiosError.ERR_BAD_REQUEST, config)); } // Add Content-Length header if data exists headers.setContentLength(data.length, false); if (maxBodyLength > -1 && data.length > maxBodyLength) { return reject(new AxiosError('Request body larger than maxBodyLength limit', AxiosError.ERR_BAD_REQUEST, config)); } } const contentLength = utils$1.toFiniteNumber(headers.getContentLength()); if (utils$1.isArray(maxRate)) { maxUploadRate = maxRate[0]; maxDownloadRate = maxRate[1]; } else { maxUploadRate = maxDownloadRate = maxRate; } if (data && (onUploadProgress || maxUploadRate)) { if (!utils$1.isStream(data)) { data = stream.Readable.from(data, { objectMode: false }); } data = stream.pipeline([data, new AxiosTransformStream({ maxRate: utils$1.toFiniteNumber(maxUploadRate) })], utils$1.noop); onUploadProgress && data.on('progress', flushOnFinish(data, progressEventDecorator(contentLength, progressEventReducer(asyncDecorator(onUploadProgress, scheduleProgress), false, 3)))); } // HTTP basic authentication let auth = undefined; const configAuth = own('auth'); if (configAuth) { const username = utils$1.getSafeProp(configAuth, 'username') || ''; const password = utils$1.getSafeProp(configAuth, 'password') || ''; auth = username + ':' + password; } if (!auth && (parsed.username || parsed.password)) { const urlUsername = decodeURIComponentSafe$1(parsed.username); const urlPassword = decodeURIComponentSafe$1(parsed.password); auth = urlUsername + ':' + urlPassword; } auth && headers.delete('authorization'); let path$1; try { path$1 = buildURL(parsed.pathname + parsed.search, own('params'), own('paramsSerializer')).replace(/^\?/, ''); } catch (err) { return reject(AxiosError.from(err, AxiosError.ERR_BAD_REQUEST, config, null, null, { url: own('url'), exists: true })); } headers.set('Accept-Encoding', utils$1.hasOwnProp(transitional, 'advertiseZstdAcceptEncoding') && transitional.advertiseZstdAcceptEncoding === true ? ACCEPT_ENCODING_WITH_ZSTD : ACCEPT_ENCODING, false); // Null-prototype to block prototype pollution gadgets on properties read // directly by Node's http.request (e.g. insecureHTTPParser, lookup). const options = Object.assign(Object.create(null), { path: path$1, method: method, headers: toByteStringHeaderObject(headers), agents: { http: httpAgent, https: httpsAgent }, auth, protocol, family, beforeRedirect: dispatchBeforeRedirect, beforeRedirects: Object.create(null), http2Options }); // cacheable-lookup integration hotfix !utils$1.isUndefined(lookup) && (options.lookup = lookup); if (socketPath) { if (typeof socketPath !== 'string') { return reject(new AxiosError('socketPath must be a string', AxiosError.ERR_BAD_OPTION_VALUE, config)); } const allowedSocketPaths = own('allowedSocketPaths'); if (allowedSocketPaths != null) { const allowed = Array.isArray(allowedSocketPaths) ? allowedSocketPaths : [allowedSocketPaths]; const resolvedSocket = path.resolve(socketPath); const isAllowed = allowed.some(entry => typeof entry === 'string' && path.resolve(entry) === resolvedSocket); if (!isAllowed) { return reject(new AxiosError(`socketPath "${socketPath}" is not permitted by allowedSocketPaths`, AxiosError.ERR_BAD_OPTION_VALUE, config)); } } options.socketPath = socketPath; } else { options.hostname = parsed.hostname.startsWith('[') ? parsed.hostname.slice(1, -1) : parsed.hostname; options.port = parsed.port; setProxy(options, configProxy, protocol + '//' + parsed.hostname + (parsed.port ? ':' + parsed.port : '') + options.path, false, httpsAgent, httpAgent); } let transport; let isNativeTransport = false; // True only for the follow-redirects transport, which applies // options.maxBodyLength itself. Every other transport (http2, native // http/https, a user-supplied custom transport) needs the explicit // byte-counting pipeline below to enforce maxBodyLength on streamed uploads. let transportEnforcesMaxBodyLength = false; const isHttpsRequest = isHttps.test(options.protocol); // Don't clobber a CONNECT-tunneling agent installed by setProxy() for an // HTTPS target. if (options.agent == null) { options.agent = isHttpsRequest ? httpsAgent : httpAgent; } if (isHttp2) { transport = http2Transport; } else { const configTransport = own('transport'); if (configTransport) { transport = configTransport; } else if (maxRedirects === 0) { transport = isHttpsRequest ? https : http; isNativeTransport = true; } else { transportEnforcesMaxBodyLength = true; options.sensitiveHeaders = []; if (maxRedirects) { options.maxRedirects = maxRedirects; } const configBeforeRedirect = own('beforeRedirect'); if (configBeforeRedirect) { options.beforeRedirects.config = configBeforeRedirect; } if (auth) { // Restore HTTP Basic credentials on same-origin redirects only. // follow-redirects >= 1.15.8 strips Authorization on every redirect (see #6929); // cross-origin stripping is the documented mitigation for T-R2 in THREATMODEL.md // and is preserved by deliberately not restoring on origin change. const requestOrigin = parsed.origin; const authToRestore = auth; options.beforeRedirects.auth = function beforeRedirectAuth(redirectOptions) { try { if (new URL(redirectOptions.href).origin === requestOrigin) { redirectOptions.auth = authToRestore; } } catch (e) { // ignore malformed URL: leaving auth stripped is fail-safe } }; } const sensitiveHeaders = own('sensitiveHeaders'); if (sensitiveHeaders != null) { if (!utils$1.isArray(sensitiveHeaders)) { return reject(new AxiosError('sensitiveHeaders must be an array of strings', AxiosError.ERR_BAD_OPTION_VALUE, config)); } const sensitiveSet = new Set(); for (const header of sensitiveHeaders) { if (!utils$1.isString(header)) { return reject(new AxiosError('sensitiveHeaders must be an array of strings', AxiosError.ERR_BAD_OPTION_VALUE, config)); } sensitiveSet.add(header.toLowerCase()); } if (sensitiveSet.size) { options.sensitiveHeaders = Array.from(sensitiveSet); options.beforeRedirects.sensitiveHeaders = function beforeRedirectSensitiveHeaders(redirectOptions, requestDetails) { if (!isSameOriginRedirect(redirectOptions, requestDetails)) { stripMatchingHeaders(redirectOptions.headers, sensitiveSet); } }; } } transport = isHttpsRequest ? httpsFollow : httpFollow; } } // Set an explicit maxBodyLength option for transports that inspect it. // When maxBodyLength is -1 (default/unlimited), use Infinity so // follow-redirects does not fall back to its own 10MB default. if (maxBodyLength > -1) { options.maxBodyLength = maxBodyLength; } else { options.maxBodyLength = Infinity; } // Always set an explicit own value so a polluted // Object.prototype.insecureHTTPParser cannot enable the lenient parser // through Node's internal options copy options.insecureHTTPParser = Boolean(own('insecureHTTPParser')); // Create the request req = transport.request(options, function handleResponse(res) { clearConnectPhaseTimer(); if (req.destroyed) return; const streams = [res]; const responseLength = utils$1.toFiniteNumber(res.headers['content-length']); if (onDownloadProgress || maxDownloadRate) { const transformStream = new AxiosTransformStream({ maxRate: utils$1.toFiniteNumber(maxDownloadRate) }); onDownloadProgress && transformStream.on('progress', flushOnFinish(transformStream, progressEventDecorator(responseLength, progressEventReducer(asyncDecorator(onDownloadProgress, scheduleProgress), true, 3)))); streams.push(transformStream); } // decompress the response body transparently if required let responseStream = res; // return the last request in case of redirects const lastRequest = res.req || req; // if decompress disabled we should not decompress if (decompress !== false && res.headers['content-encoding']) { // if no content, but headers still say that it is encoded, // remove the header not confuse downstream operations if (method === 'HEAD' || res.statusCode === 204) { delete res.headers['content-encoding']; } switch ((res.headers['content-encoding'] || '').toLowerCase()) { /*eslint default-case:0*/ case 'gzip': case 'x-gzip': case 'compress': case 'x-compress': // add the unzipper to the body stream processing pipeline streams.push(zlib.createUnzip(zlibOptions)); // remove the content-encoding in order to not confuse downstream operations delete res.headers['content-encoding']; break; case 'deflate': streams.push(new ZlibHeaderTransformStream()); // add the unzipper to the body stream processing pipeline streams.push(zlib.createUnzip(zlibOptions)); // remove the content-encoding in order to not confuse downstream operations delete res.headers['content-encoding']; break; case 'br': if (isBrotliSupported) { streams.push(zlib.createBrotliDecompress(brotliOptions)); delete res.headers['content-encoding']; } break; case 'zstd': if (isZstdSupported) { streams.push(zlib.createZstdDecompress(zstdOptions)); delete res.headers['content-encoding']; } break; } } responseStream = streams.length > 1 ? stream.pipeline(streams, utils$1.noop) : streams[0]; const response = { status: res.statusCode, statusText: res.statusMessage, headers: new AxiosHeaders(res.headers), config, request: lastRequest }; if (responseType === 'stream') { // Enforce maxContentLength on streamed responses; previously this // was applied only to buffered responses. if (maxContentLength > -1) { const limit = maxContentLength; const source = responseStream; async function* enforceMaxContentLength() { let totalResponseBytes = 0; for await (const chunk of source) { totalResponseBytes += chunk.length; if (totalResponseBytes > limit) { throw new AxiosError('maxContentLength size of ' + limit + ' exceeded', AxiosError.ERR_BAD_RESPONSE, config, lastRequest); } yield chunk; } } responseStream = stream.Readable.from(enforceMaxContentLength(), { objectMode: false }); } response.data = responseStream; settle(resolve, reject, response); } else { const responseBuffer = []; let totalResponseBytes = 0; responseStream.on('data', function handleStreamData(chunk) { responseBuffer.push(chunk); totalResponseBytes += chunk.length; // make sure the content length is not over the maxContentLength if specified if (maxContentLength > -1 && totalResponseBytes > maxContentLength) { // stream.destroy() emit aborted event before calling reject() on Node.js v16 rejected = true; responseStream.destroy(); abort(new AxiosError('maxContentLength size of ' + maxContentLength + ' exceeded', AxiosError.ERR_BAD_RESPONSE, config, lastRequest)); } }); responseStream.on('aborted', function handlerStreamAborted() { if (rejected) { return; } const err = new AxiosError('stream has been aborted', AxiosError.ERR_BAD_RESPONSE, config, lastRequest, response); responseStream.destroy(err); reject(err); }); responseStream.on('error', function handleStreamError(err) { if (rejected) return; reject(AxiosError.from(err, null, config, lastRequest, response)); }); responseStream.on('end', function handleStreamEnd() { try { let responseData = responseBuffer.length === 1 ? responseBuffer[0] : Buffer.concat(responseBuffer); if (responseType !== 'arraybuffer') { responseData = responseData.toString(responseEncoding); if (!responseEncoding || responseEncoding === 'utf8') { responseData = utils$1.stripBOM(responseData); } } response.data = responseData; } catch (err) { return reject(AxiosError.from(err, null, config, response.request, response)); } settle(resolve, reject, response); }); } abortEmitter.once('abort', err => { if (!responseStream.destroyed) { responseStream.emit('error', err); responseStream.destroy(); } }); }); abortEmitter.once('abort', err => { if (req.close) { req.close(); } else { req.destroy(err); } }); // Handle errors req.on('error', function handleRequestError(err) { reject(AxiosError.from(err, null, config, req)); }); // set tcp keep alive to prevent drop connection by peer // Track every socket bound to this outer RedirectableRequest so a single // 'close' listener can release ownership on all of them. follow-redirects // re-emits the 'socket' event for each hop's native request onto the same // outer request, so attaching per-request listeners inside this handler // would accumulate across hops and trigger MaxListenersExceededWarning at // >= 11 redirects. Clearing only the last-bound socket would leave stale // kAxiosCurrentReq refs on earlier hop sockets returned to the keep-alive // pool, causing an idle-pool 'error' to be attributed to a closed req. const boundSockets = new Set(); req.on('socket', function handleRequestSocket(socket) { // default interval of sending ack packet is 1 minute // proxy agents (e.g. agent-base) may return a generic Duplex stream // that doesn't have setKeepAlive, so guard before calling if (typeof socket.setKeepAlive === 'function') { socket.setKeepAlive(true, 1000 * 60); } // Install a single 'error' listener per socket (not per request) to avoid // accumulating listeners on pooled keep-alive sockets that get reassigned // to new requests before the previous request's 'close' fires (issue #10780). // The listener is bound to the socket's currently-active request via a // symbol, which is swapped as the socket is reassigned. if (!socket[kAxiosSocketListener]) { socket.on('error', function handleSocketError(err) { const current = socket[kAxiosCurrentReq]; if (current && !current.destroyed) { current.destroy(err); } }); socket[kAxiosSocketListener] = true; } socket[kAxiosCurrentReq] = req; boundSockets.add(socket); }); req.once('close', function clearCurrentReq() { clearConnectPhaseTimer(); for (const socket of boundSockets) { if (socket[kAxiosCurrentReq] === req) { socket[kAxiosCurrentReq] = null; } } boundSockets.clear(); }); // Handle request timeout if (own('timeout')) { // This is forcing a int timeout to avoid problems if the `req` interface doesn't handle other types. const timeout = parseInt(own('timeout'), 10); if (Number.isNaN(timeout)) { abort(new AxiosError('error trying to parse `config.timeout` to int', AxiosError.ERR_BAD_OPTION_VALUE, config, req)); return; } const handleTimeout = function handleTimeout() { if (isDone) return; abort(createTimeoutError()); }; if (isNativeTransport && timeout > 0) { // Native ClientRequest#setTimeout starts from the socket lifecycle and // may not fire while TCP connect is still pending. Mirror the // follow-redirects wall-clock timer for the maxRedirects === 0 path. connectPhaseTimer = setTimeout(handleTimeout, timeout); } // Sometime, the response will be very slow, and does not respond, the connect event will be block by event loop system. // And timer callback will be fired, and abort() will be invoked before connection, then get "socket hang up" and code ECONNRESET. // At this time, if we have a large number of request, nodejs will hang up some socket on background. and the number will up and up. // And then these socket which be hang up will devouring CPU little by little. // ClientRequest.setTimeout will be fired on the specify milliseconds, and can make sure that abort() will be fired after connect. req.setTimeout(timeout, handleTimeout); } else { // explicitly reset the socket timeout value for a possible `keep-alive` request req.setTimeout(0); } // Send the request if (utils$1.isStream(data)) { let ended = false; let errored = false; data.on('end', () => { ended = true; }); data.once('error', err => { errored = true; req.destroy(err); }); data.on('close', () => { if (!ended && !errored) { abort(new CanceledError('Request stream has been aborted', config, req)); } }); // Enforce maxBodyLength for streamed uploads on every transport that // does not apply options.maxBodyLength itself (native http/https, http2, // and user-supplied custom transports). The follow-redirects transport // enforces it on the redirected HTTP/1 path. let uploadStream = data; if (maxBodyLength > -1 && !transportEnforcesMaxBodyLength) { const limit = maxBodyLength; let bytesSent = 0; uploadStream = stream.pipeline([data, new stream.Transform({ transform(chunk, _enc, cb) { bytesSent += chunk.length; if (bytesSent > limit) { return cb(new AxiosError('Request body larger than maxBodyLength limit', AxiosError.ERR_BAD_REQUEST, config, req)); } cb(null, chunk); } })], utils$1.noop); uploadStream.on('error', err => { if (!req.destroyed) req.destroy(err); }); } uploadStream.pipe(req); } else { data && req.write(data); req.end(); } });}; 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; // Match name=value by splitting on the semicolon separator instead of building a // RegExp from `name` — interpolating an unescaped string into a RegExp would let // metacharacters (e.g. `.+?` in an attacker-influenced cookie name) cause ReDoS or // match the wrong cookie. Browsers may serialize cookie pairs as either ";" or // "; ", so ignore optional whitespace before each cookie name. const cookies = document.cookie.split(';'); for (let i = 0; i < cookies.length; i++) { const cookie = cookies[i].replace(/^\s+/, ''); const eq = cookie.indexOf('='); if (eq !== -1 && cookie.slice(0, eq) === name) { try { return decodeURIComponent(cookie.slice(eq + 1)); } catch (e) { return cookie.slice(eq + 1); } } } return 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() {}}; const headersToObject = thing => thing instanceof AxiosHeaders ? { ...thing} : thing;const ownEnumerableKeys = thing => { if (Object.getOwnPropertySymbols && Object.getOwnPropertyDescriptor) { return Object.keys(thing).concat(Object.getOwnPropertySymbols(thing).filter(symbol => Object.getOwnPropertyDescriptor(thing, symbol).enumerable)); } return Object.keys(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 config1 = config1 || {}; 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. // `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', { // Null-proto descriptor so a polluted Object.prototype.get cannot turn // this data descriptor into an accessor descriptor on the way in. __proto__: null, 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); } } function getMergedTransitionalOption(prop) { const transitional2 = utils$1.hasOwnProp(config2, 'transitional') ? config2.transitional : undefined; if (!utils$1.isUndefined(transitional2)) { if (utils$1.isPlainObject(transitional2)) { if (utils$1.hasOwnProp(transitional2, prop)) { return transitional2[prop]; } } else { return undefined; } } const transitional1 = utils$1.hasOwnProp(config1, 'transitional') ? config1.transitional : undefined; if (utils$1.isPlainObject(transitional1) && utils$1.hasOwnProp(transitional1, prop)) { return transitional1[prop]; } return undefined; } // 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(ownEnumerableKeys({ ...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); }); if (utils$1.hasOwnProp(config2, 'validateStatus') && utils$1.isUndefined(config2.validateStatus) && getMergedTransitionalOption('validateStatusUndefinedResolves') === false) { if (utils$1.hasOwnProp(config1, 'validateStatus')) { config.validateStatus = getMergedValue(undefined, config1.validateStatus); } else { delete config.validateStatus; } } return config;} /** * Encode a UTF-8 string to a Latin-1 byte string for use with btoa(). * This is a modern replacement for the deprecated unescape(encodeURIComponent(str)) pattern. * * @param {string} str The string to encode * * @returns {string} UTF-8 bytes as a Latin-1 string */const encodeUTF8$1 = str => encodeURIComponent(str).replace(/%([0-9A-F]{2})/gi, (_, hex) => String.fromCharCode(parseInt(hex, 16)));function resolveConfig(config) { const newConfig = mergeConfig({}, config); // Read only own properties to prevent prototype pollution gadgets // (e.g. Object.prototype.baseURL = 'https://evil.com'). 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, newConfig), own('params'), own('paramsSerializer')); // HTTP basic authentication if (auth) { const username = utils$1.getSafeProp(auth, 'username') || ''; const password = utils$1.getSafeProp(auth, 'password') || ''; try { headers.set('Authorization', 'Basic ' + btoa(username + ':' + (password ? encodeUTF8$1(password) : ''))); } catch (e) { throw AxiosError.from(e, AxiosError.ERR_BAD_OPTION_VALUE, config); } } if (utils$1.isFormData(data)) { if (platform.hasStandardBrowserEnv || platform.hasStandardBrowserWebWorkerEnv || utils$1.isReactNative(data)) { headers.setContentType(undefined); // browser/web worker/RN handles it } else if (utils$1.isFunction(data.getHeaders)) { // Node.js FormData (like form-data package) setFormDataHeaders(headers, data.getHeaders(), own('formDataHeaderPolicy')); } } // 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. 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.startsWith('file:'))) { 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)); done(); // 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); done(); 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)); done(); // 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(toByteStringHeaderObject(requestHeaders), 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(); done(); 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.includes(protocol)) { reject(new AxiosError('Unsupported protocol ' + protocol + ':', AxiosError.ERR_BAD_REQUEST, config)); done(); return; } // Send the request request.send(requestData || null); });}; const composeSignals = (signals, timeout) => { signals = signals ? signals.filter(Boolean) : []; if (!timeout && !signals.length) { return; } const controller = new AbortController(); let aborted = false; 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) { return; } timer && clearTimeout(timer); timer = null; signals.forEach(signal => { signal.unsubscribe ? signal.unsubscribe(onabort) : signal.removeEventListener('abort', onabort); }); signals = null; }; signals.forEach(signal => { if (aborted) { return; } if (signal.aborted) { onabort.call(signal); return; } signal.addEventListener('abort', onabort, { once: true }); }); 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; /** * Encode a UTF-8 string to a Latin-1 byte string for use with btoa(). * This is a modern replacement for the deprecated unescape(encodeURIComponent(str)) pattern. * * @param {string} str The string to encode * * @returns {string} UTF-8 bytes as a Latin-1 string */const encodeUTF8 = str => encodeURIComponent(str).replace(/%([0-9A-F]{2})/gi, (_, hex) => String.fromCharCode(parseInt(hex, 16))); // Node's WHATWG URL parser returns `username` and `password` percent-encoded.// Decode before composing the `auth` option so credentials such as// `my%40email.com:pass` are sent as `my@email.com:pass`. Falls back to the// original value for malformed input so a bad encoding never throws.const decodeURIComponentSafe = value => { if (!utils$1.isString(value)) { return value; } try { return decodeURIComponent(value); } catch (error) { return value; }};const test = (fn, ...args) => { try { return !!fn(...args); } catch (e) { return false; }};const maybeWithAuthCredentials = url => { const protocolIndex = url.indexOf('://'); let urlToCheck = url; if (protocolIndex !== -1) { urlToCheck = urlToCheck.slice(protocolIndex + 3); } return urlToCheck.includes('@') || urlToCheck.includes(':');};const factory = env => { const globalObject = utils$1.global !== undefined && utils$1.global !== null ? utils$1.global : globalThis; const { ReadableStream, TextEncoder } = globalObject; env = utils$1.merge.call({ skipUndefined: true }, { Request: globalObject.Request, Response: globalObject.Response }, 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); 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(), 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, maxContentLength, maxBodyLength } = resolveConfig(config); const hasMaxContentLength = utils$1.isNumber(maxContentLength) && maxContentLength > -1; const hasMaxBodyLength = utils$1.isNumber(maxBodyLength) && maxBodyLength > -1; const own = key => utils$1.hasOwnProp(config, key) ? config[key] : undefined; 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; // AxiosError we raise while the request body is being streamed. Captured // by identity so the catch block can surface it directly, regardless of // how the runtime wraps the resulting fetch rejection (undici exposes it // as `err.cause`; some browsers drop the original error entirely). let pendingBodyError = null; const maxBodyLengthError = () => new AxiosError('Request body larger than maxBodyLength limit', AxiosError.ERR_BAD_REQUEST, config, request); try { // HTTP basic authentication let auth = undefined; const configAuth = own('auth'); if (configAuth) { const username = utils$1.getSafeProp(configAuth, 'username') || ''; const password = utils$1.getSafeProp(configAuth, 'password') || ''; auth = { username, password }; } if (maybeWithAuthCredentials(url)) { const parsedURL = new URL(url, platform.origin); if (!auth && (parsedURL.username || parsedURL.password)) { const urlUsername = decodeURIComponentSafe(parsedURL.username); const urlPassword = decodeURIComponentSafe(parsedURL.password); auth = { username: urlUsername, password: urlPassword }; } if (parsedURL.username || parsedURL.password) { parsedURL.username = ''; parsedURL.password = ''; url = parsedURL.href; } } if (auth) { headers.delete('authorization'); headers.set('Authorization', 'Basic ' + btoa(encodeUTF8((auth.username || '') + ':' + (auth.password || '')))); } // Enforce maxContentLength for data: URLs up-front so we never materialize // an oversized payload. The HTTP adapter applies the same check (see http.js // "if (protocol === 'data:')" branch). if (hasMaxContentLength && typeof url === 'string' && url.startsWith('data:')) { const estimated = estimateDataURLDecodedBytes(url); if (estimated > maxContentLength) { throw new AxiosError('maxContentLength size of ' + maxContentLength + ' exceeded', AxiosError.ERR_BAD_RESPONSE, config, request); } } // Enforce maxBodyLength against known-size bodies before dispatch using // the body's *actual* size — never a caller-declared Content-Length, // which could under-report to slip an oversized body past the check. // Unknown-size streams return undefined here and are counted per-chunk // below as fetch consumes them. if (hasMaxBodyLength && method !== 'get' && method !== 'head') { const outboundLength = await getBodyLength(data); if (typeof outboundLength === 'number' && isFinite(outboundLength)) { requestContentLength = outboundLength; if (outboundLength > maxBodyLength) { throw maxBodyLengthError(); } } } // A streamed body under maxBodyLength must be counted as fetch consumes // it; its size is never trusted from a caller-declared Content-Length. const mustEnforceStreamBody = hasMaxBodyLength && (utils$1.isReadableStream(data) || utils$1.isStream(data)); const trackRequestStream = (stream, onProgress, flush) => trackStream(stream, DEFAULT_CHUNK_SIZE, loadedBytes => { if (hasMaxBodyLength && loadedBytes > maxBodyLength) { throw pendingBodyError = maxBodyLengthError(); } onProgress && onProgress(loadedBytes); }, flush); if (supportsRequestStream && method !== 'get' && method !== 'head' && (onUploadProgress || mustEnforceStreamBody)) { requestContentLength = requestContentLength == null ? await resolveBodyLength(headers, data) : requestContentLength; // A declared length of 0 is only trusted to skip the wrap when we are // not enforcing a stream limit (which must not rely on that header). if (requestContentLength !== 0 || mustEnforceStreamBody) { 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] = onUploadProgress && progressEventDecorator(requestContentLength, progressEventReducer(asyncDecorator(onUploadProgress))) || []; data = trackRequestStream(_request.body, onProgress, flush); } } } else if (mustEnforceStreamBody && !isRequestSupported && isReadableStreamSupported && method !== 'get' && method !== 'head') { data = trackRequestStream(data); } else if (mustEnforceStreamBody && isRequestSupported && !supportsRequestStream && method !== 'get' && method !== 'head') { throw new AxiosError('Stream request bodies are not supported by the current fetch implementation', AxiosError.ERR_NOT_SUPPORT, config, request); } 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'); } } // Set User-Agent header if not already set (fetch defaults to 'node' in Node.js) headers.set('User-Agent', 'axios/' + VERSION, false); const resolvedOptions = { ...fetchOptions, signal: composedSignal, method: method.toUpperCase(), headers: toByteStringHeaderObject(headers.normalize()), 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 responseHeaders = AxiosHeaders.from(response.headers); // Cheap pre-check: if the server honestly declares a content-length that // already exceeds the cap, reject before we start streaming. if (hasMaxContentLength) { const declaredLength = utils$1.toFiniteNumber(responseHeaders.getContentLength()); if (declaredLength != null && declaredLength > maxContentLength) { throw new AxiosError('maxContentLength size of ' + maxContentLength + ' exceeded', AxiosError.ERR_BAD_RESPONSE, config, request); } } const isStreamResponse = supportsResponseStream && (responseType === 'stream' || responseType === 'response'); if (supportsResponseStream && response.body && (onDownloadProgress || hasMaxContentLength || isStreamResponse && unsubscribe)) { const options = {}; ['status', 'statusText', 'headers'].forEach(prop => { options[prop] = response[prop]; }); const responseContentLength = utils$1.toFiniteNumber(responseHeaders.getContentLength()); const [onProgress, flush] = onDownloadProgress && progressEventDecorator(responseContentLength, progressEventReducer(asyncDecorator(onDownloadProgress), true)) || []; let bytesRead = 0; const onChunkProgress = loadedBytes => { if (hasMaxContentLength) { bytesRead = loadedBytes; if (bytesRead > maxContentLength) { throw new AxiosError('maxContentLength size of ' + maxContentLength + ' exceeded', AxiosError.ERR_BAD_RESPONSE, config, request); } } onProgress && onProgress(loadedBytes); }; response = new Response(trackStream(response.body, DEFAULT_CHUNK_SIZE, onChunkProgress, () => { flush && flush(); unsubscribe && unsubscribe(); }), options); } responseType = responseType || 'text'; let responseData = await resolvers[utils$1.findKey(resolvers, responseType) || 'text'](response, config); // Fallback enforcement for environments without ReadableStream support // (legacy runtimes). Detect materialized size from typed output; skip // streams/Response passthrough since the user will read those themselves. if (hasMaxContentLength && !supportsResponseStream && !isStreamResponse) { let materializedSize; if (responseData != null) { if (typeof responseData.byteLength === 'number') { materializedSize = responseData.byteLength; } else if (typeof responseData.size === 'number') { materializedSize = responseData.size; } else if (typeof responseData === 'string') { materializedSize = typeof TextEncoder === 'function' ? new TextEncoder().encode(responseData).byteLength : responseData.length; } } if (typeof materializedSize === 'number' && materializedSize > maxContentLength) { throw new AxiosError('maxContentLength size of ' + maxContentLength + ' exceeded', AxiosError.ERR_BAD_RESPONSE, config, request); } } !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(); // Safari can surface fetch aborts as a DOMException-like object whose // branded getters throw. Prefer our composed signal reason before reading // the caught error, preserving timeout vs cancellation semantics. if (composedSignal && composedSignal.aborted && composedSignal.reason instanceof AxiosError) { const canceledError = composedSignal.reason; canceledError.config = config; request && (canceledError.request = request); if (err !== canceledError) { // Non-enumerable to match native Error `cause` semantics so loggers // don't recurse into circular fetch internals (see #7205). Object.defineProperty(canceledError, 'cause', { __proto__: null, value: err, writable: true, enumerable: false, configurable: true }); } throw canceledError; } // Surface a maxBodyLength violation we raised while the request body was // being streamed. Matching by identity (rather than reading // `err.cause.isAxiosError`) keeps the error deterministic across runtimes // and avoids both prototype-pollution reads and mis-attributing a foreign // AxiosError that merely happened to land in `err.cause`. if (pendingBodyError) { request && !pendingBodyError.request && (pendingBodyError.request = request); throw pendingBodyError; } // Re-throw AxiosErrors we raised synchronously (data: URL / content-length // pre-checks, response size enforcement) without re-wrapping them. if (err instanceof AxiosError) { request && !err.request && (err.request = request); throw err; } if (err && err.name === 'TypeError' && /Load failed|fetch/i.test(err.message)) { const networkError = new AxiosError('Network Error', AxiosError.ERR_NETWORK, config, request, err && err.response); // Non-enumerable to match native Error `cause` semantics so loggers // don't recurse into circular fetch internals (see #7205). Object.defineProperty(networkError, 'cause', { __proto__: null, value: err.cause || err, writable: true, enumerable: false, configurable: true }); throw networkError; } 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 { // Null-proto descriptors so a polluted Object.prototype.get cannot turn // these data descriptors into accessor descriptors on the way in. Object.defineProperty(fn, 'name', { __proto__: null, value }); } catch (e) { // eslint-disable-next-line no-empty } Object.defineProperty(fn, 'adapterName', { __proto__: null, 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, AxiosError.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); // Expose the current response on config so that transformResponse can // attach it to any AxiosError it throws (e.g. on JSON parse failure). // We clean it up afterwards to avoid polluting the config object. config.response = response; try { response.data = transformData.call(config, config.transformResponse, response); } finally { delete config.response; } response.headers = AxiosHeaders.from(response.headers); return response; }, function onAdapterRejection(reason) { if (!isCancel(reason)) { throwIfCancellationRequested(config); // Transform response data if (reason && reason.response) { config.response = reason.response; try { reason.response.data = transformData.call(config, config.transformResponse, reason.response); } finally { delete config.response; } reason.response.headers = AxiosHeaders.from(reason.response.headers); } } return Promise.reject(reason); });} 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' || options === null) { 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. 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), advertiseZstdAcceptEncoding: validators.transitional(validators.boolean), validateStatusUndefinedResolves: 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', 'query', '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 ? onFulfilled(newConfig) : newConfig; } catch (error) { if (!onRejected) { promise = Promise.reject(error); break; } try { const rejectedResult = onRejected.call(this, error); if (utils$1.isThenable(rejectedResult)) { promise = Promise.resolve(rejectedResult).then(() => dispatchRequest.call(this, newConfig)); } } catch (rejectedError) { promise = Promise.reject(rejectedError); } break; } } if (!promise) { try { promise = dispatchRequest.call(this, newConfig); } catch (error) { promise = 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, config); 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 && utils$1.hasOwnProp(config, 'data') ? config.data : undefined })); };});utils$1.forEach(['post', 'put', 'patch', 'query'], 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(); // QUERY is a safe/idempotent read method; multipart form bodies don't fit // its semantics, so no queryForm shorthand is generated. if (method !== 'query') { 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, WebServerReturnsAnUnknownError: 520, 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;